# HG changeset patch # User skip # Date 1267108159 0 # Node ID 29cda98b007e69a181cdfe0d6a566c157d477ecf # Parent 5f8e5adbbed98113447f57ccd6286fad2c32b028 Initial import of Podcatcher from the Bergamot project diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/Podcast.rss --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/Podcast.rss Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,86 @@ +/* + * Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB + * + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of the License "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * EmbedDev AB - initial contribution. + * + * Contributors: + * + * Description: + * + */ + +// RESOURCE IDENTIFIER +NAME PODC // 4 letter ID + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "Podcast.hrh" +#include "languages.rss" + +#define APPICON "\\resource\\apps\\Podcast.mif" +RESOURCE RSS_SIGNATURE { } + +RESOURCE TBUF { buf = "Podcatcher"; } + +RESOURCE EIK_APP_INFO + { + } + +RESOURCE LOCALISABLE_APP_INFO r_podcast_localisable_app_info + { + short_caption = STRING_r_short_caption; + caption_and_icon = + CAPTION_AND_ICON_INFO + { + caption = STRING_r_caption; + number_of_icons = 1; + icon_file = APPICON; + }; + } + +RESOURCE DIALOG r_dlg_about + { + flags = EAknDialogGenericNoteFlags; + buttons = R_AVKON_SOFTKEYS_CLOSE; + items = + { + DLG_LINE + { + type = EAknCtNote; + id = EPodcastAboutDlg; + control = AVKON_NOTE + { + layout = EGeneralLayout; + singular_label = STRING_r_about_text_s60; + imagefile = APPICON; + imageid = EMbmPodcastPodcatcher_64px; + imagemask = EMbmPodcastPodcatcher_64px_mask; + }; + } + }; + } + + + +#include "PodcastStrings.ra" +#include "PodcastFeedView.ra" +#include "PodcastShowsView.ra" +#include "PodcastSettingsView.ra" +#include "PodcastSearchView.ra" +#include "PodcastQueueView.ra" +#include "PodcastDialogs.ra" diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/PodcastClient_common.rls --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/PodcastClient_common.rls Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB + * + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of the License "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * EmbedDev AB - initial contribution. + * + * Contributors: + * + * Description: + * + */ + +CHARACTER_SET UTF8 +// Strings common between languages + +// Application caption +rls_string STRING_r_caption "Podcatcher" +rls_string STRING_r_short_caption "Podcatcher" + +rls_string STRING_r_about_text_s60 "Podcatcher 1.00\n© 2007-2010 Sebastian Brannstrom, Lars Persson, Anders Fridlund, EmbedDev AB" diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/PodcastClient_english.rls --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/PodcastClient_english.rls Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,218 @@ +/* + * Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB + * + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of the License "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * EmbedDev AB - initial contribution. + * + * Contributors: + * + * Description: + * + */ + +// list view commands +rls_string STRING_r_listbox_listview_cmd_close_debug "Close (debug)" +rls_string STRING_r_listbox_listview_cmd_close_debug_shorttext "Close" + +// Menu commands, view filtering and navigation +rls_string STRING_r_view_cmd "View" + +// Navigation to shows view +rls_string STRING_r_view_main_cmd "Main" +rls_string STRING_r_view_new_shows_cmd "Unplayed" +rls_string STRING_r_view_about_cmd "About" + +// Navigation to feeds +rls_string STRING_r_view_feeds_cmd "Feeds" +rls_string STRING_r_view_remove_download_short_cmd "Remove" +rls_string STRING_r_view_remove_download_cmd "Remove Download" + +// Actions for feeds +rls_string STRING_r_view_add_feed_cmd "Add Feed" +rls_string STRING_r_view_add_feed_cmd_short "Add" +rls_string STRING_r_view_edit_feed_cmd "Edit Feed" +rls_string STRING_r_view_edit_feed_cmd_short "Edit" + +rls_string STRING_r_view_delete_feed_cmd "Remove Feed" +rls_string STRING_r_view_delete_feed_cmd_short "Remove" +rls_string STRING_r_view_delete_played_cmd "Delete All Played" +rls_string STRING_r_update_feed_cmd "Update Feed" +rls_string STRING_r_update_feed_short_cmd "Update" +rls_string STRING_r_update_all_feeds_cmd "Update All" +rls_string STRING_r_update_all_feeds_short_cmd "Upd. All" + +rls_string STRING_r_podcast_feeds_update_message "Updating..." +rls_string STRING_r_podcast_feeds_update_error "Update failed!" + +// Actions for shows +rls_string STRING_r_view_download_show_cmd "Download" +rls_string STRING_r_view_delete_show_cmd "Delete" +rls_string STRING_r_view_delete_shows_cmd "Delete All" +rls_string STRING_r_view_delete_show_cmd "Delete" +rls_string STRING_r_view_stop_downloads_cmd "Suspend Downloading" +rls_string STRING_r_view_resume_downloads_cmd "Resume Downloading" +rls_string STRING_r_view_mark_all_played_cmd "Mark all old" +rls_string STRING_r_view_show_unplayed_cmd "Show Unplayed Only" +rls_string STRING_r_view_show_info_cmd "Info" +rls_string STRING_r_view_show_play_cmd "Play" +// Common actions +rls_string STRING_r_settings_cmd "Settings" + +// Categories (strings max 20 character long) +rls_string STRING_r_category_all "All Shows" +rls_string STRING_r_category_new "Unplayed" +rls_string STRING_r_category_dled "Shows on Phone" +rls_string STRING_r_category_pending "Downloader" + +// View titles +rls_string STRING_r_view_feeds_title "Feeds" + +// Shows view status strings +rls_string STRING_r_podcast_shows_title_format "%d Unplayed, %d Total" +rls_string STRING_r_podcast_shows_title_download "%d Queued" +rls_string STRING_r_podcast_shows_downloads_suspended "%d Queued (Suspended)" +rls_string STRING_r_podcast_shows_no_items "No items" + +// Feeds view status strings +rls_string STRING_r_podcast_feeds_title_format "%d Feeds" +rls_string STRING_r_podcast_feeds_status_format "%d new" +rls_string STRING_r_podcast_shows_never_updated "Never" +rls_string STRING_r_podcast_feeds_is_updating "Updating..." +rls_string STRING_r_podcast_no_feeds "(no feeds)" + +// DIALOG string +rls_string STRING_r_about_title "About" + +rls_string STRING_r_add_feed_title "Add feed" +rls_string STRING_r_edit_feed_title "Edit feed" + +rls_string STRING_r_add_feed_prompt "Enter search terms or feed URL" +rls_string STRING_r_edit_feed_prompt "Feed URL" +rls_string STRING_r_add_feed_title_prompt "Feed Title" + +rls_string STRING_r_remove_feed_title "Remove feed" +rls_string STRING_r_remove_feed_prompt "Remove feed '%S'?" + +rls_string STRING_r_enable_downloads_title "Resume downloading" +rls_string STRING_r_enable_downloads_prompt "There are shows in the download queue. Do you want to download now?" + +rls_string STRING_r_update_new_feed_title "Update feed" +rls_string STRING_r_update_new_feed_prompt "Do you want to update the feed now?" + +rls_string STRING_r_delete_show_title "Delete Show" +rls_string STRING_r_delete_show_prompt "Delete show '%S'?" + +// Settings view +rls_string STRING_r_podcast_settings_title "Settings" +rls_string STRING_r_podcast_setting_showdir "Podcast directory" +rls_string STRING_r_podcast_setting_autoupdate "Automatic update" +rls_string STRING_r_podcast_setting_autodownload "Automatic download" +rls_string STRING_r_podcast_setting_connection "Connection" +rls_string STRING_r_podcast_setting_default "Use default" +rls_string STRING_r_podcast_setting_alwaysask "Always ask" +rls_string STRING_r_podcast_setting_useiap "Select Access point" +rls_string STRING_r_podcast_setting_iaplist "Access points" + +// Choicelist for autodownload +rls_string STRING_podcast_autoupdate_option1 "Off" +rls_string STRING_podcast_autoupdate_option2 "Every hour" +rls_string STRING_podcast_autoupdate_option3 "Four times a day" +rls_string STRING_podcast_autoupdate_option4 "Twice a day" +rls_string STRING_podcast_autoupdate_option5 "Daily" + +// Latest strings here + +rls_string STRING_r_view_import_export_feeds_cmd "Import/export feeds" // Import feeds cmd in feedview + +rls_string STRING_r_view_import_feeds_cmd "Import feeds" // Import feeds cmd in feedview +rls_string STRING_r_view_import_feeds_cmd_short "Import" + +rls_string STRING_r_view_import_feeds_title "Select OPML file" + +rls_string STRING_r_view_feeds_status "%d Feeds" // Used in base view listbox for feeds status text max 32 chars + +rls_string STRING_r_cancel_update_all_feeds_cmd "Cancel update" +rls_string STRING_r_cancel_update_all_feeds_short_cmd "Cancel" + +rls_string STRING_r_suspend_download_cmd "Suspend" // String used for cmd to suspend current download rather than removing it from the que. +rls_string STRING_r_view_resume_short_dls_cmd "Resume" // Short download cmd +rls_string STRING_r_view_onphone_status "%d Unplayed, %d Total" // Used in base view listbox status for shows on phone text max 32 chars +rls_string STRING_r_view_onphone_status_unknown "Unknown" // Used for unknown status event + +rls_string STRING_r_view_remove_all_downloads_cmd "Remove All" +rls_string STRING_r_view_remove_all_downloads_cmd_short "Clear" + +rls_string STRING_r_podcast_subtitle "" + +rls_string STRING_r_add_feed_exists "A feed with this URL already exists" // shown when adding or changing a feed to a URL that already exists +rls_string STRING_r_add_feed_exists_title "Duplicate Feed" // title of error dialogs when adding feeds + +rls_string STRING_r_add_feed_replace "All existing shows in this feed will be deleted! Continue?" // shown when changing an existing feed URL +rls_string STRING_r_add_feed_replace_title "Warning" // title to dialog +rls_string STRING_r_view_export_feeds_cmd "Export Feeds" // Export feeds cmd in feedview +rls_string STRING_r_view_export_feeds_cmd_short "Export" + +rls_string STRING_r_catchup_feed "Mark all shows as played?" // shown when first updating a new feed +rls_string STRING_r_catchup_feed_title "First Update" // title to dialog + +rls_string STRING_r_on "On" +rls_string STRING_r_off "Off" + +rls_string STRING_r_enter_filename "Enter file name" +rls_string STRING_r_view_export_feeds_title "Select folder" +rls_string STRING_r_view_export_feeds_softkey "Select" + +rls_string STRING_r_playview_tab_info "Info" +rls_string STRING_r_playview_tab_play "Play" +rls_string STRING_r_exit_cmd "Exit" +rls_string STRING_r_cba_options "Options" +rls_string STRING_r_cba_hide "Hide" + +rls_string STRING_r_tabgroup_feeds "Feeds" +rls_string STRING_r_tabgroup_queue "Queue" +rls_string STRING_r_tabgroup_queue_counter "Queue (%d)" +rls_string STRING_r_tabgroup_shows "Shows" + +rls_string STRING_r_podcast_empty_queue "(queue empty)" +rls_string STRING_r_podcast_empty_list "(no shows)" +rls_string STRING_r_podcast_empty_search "(no search results)" +rls_string STRING_r_podcast_empty_list_updating "(updating...)" + +rls_string STRING_r_view_help "Help" +rls_string STRING_r_view_mark_as_played_cmd_short "Mark old" +rls_string STRING_r_view_mark_as_unplayed_cmd_short "Mark new" +rls_string STRING_r_view_more_options "More actions" + +rls_string STRING_r_search "Search" +rls_string STRING_r_search_help "Search for podcasts" +rls_string STRING_r_search_title "Enter search terms" + +rls_string STRING_add_feed_title "Add feed" +rls_string STRING_add_feed_query "Add feed '%S'?" +rls_string STRING_add_feed_success "Feed added. Update now?" +rls_string STRING_add_feed_error "Could not add feed" + +rls_string STRING_import_feed_success "%d feeds imported. Update all feeds now?" +rls_string STRING_import_feed_failure "Feed import failed" +rls_string STRING_export_feed_success "%d feeds exported" +rls_string STRING_export_feed_failure "Feed export failed" + +rls_string STRING_r_clear_query "Clear download queue?" +rls_string STRING_r_search_noresults "No search results" +rls_string STRING_r_cba_search "Search" +rls_string STRING_r_searching "Searching..." +rls_string STRING_r_importing "Importing..." +rls_string STRING_r_exporting "Exporting..." + +rls_string STRING_r_cba_cancel "Cancel" + +rls_string STRING_r_podcast_connection_error "Connection failed. Check connection settings." +rls_string STRING_r_exit_shows_downloading "Shows are being downloaded. Exit anyway?" + +rls_string STRING_r_search_results "Search results" diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/PodcastDialogs.ra --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/PodcastDialogs.ra Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB + * + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of the License "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * EmbedDev AB - initial contribution. + * + * Contributors: + * + * Description: + * + */ + +RESOURCE DIALOG r_messagedlg_ok +{ + flags = EAknInformationNoteFlags; + buttons = R_AVKON_SOFTKEYS_OK_EMPTY; + items = + { + DLG_LINE + { + type = EAknCtNote; + id = EGeneralNote; + control = AVKON_NOTE + { + layout = EGeneralLayout; + imagefile = AVKON_ICON_FILE; + imageid = EMbmAvkonQgn_note_ok; + imagemask = EMbmAvkonQgn_note_ok_mask; + }; + } + }; +} + +RESOURCE DIALOG r_errordlg_ok +{ + flags = EAknInformationNoteFlags; + buttons = R_AVKON_SOFTKEYS_OK_EMPTY; + items = + { + DLG_LINE + { + type = EAknCtNote; + id = EGeneralNote; + control = AVKON_NOTE + { + layout = EGeneralLayout; + imagefile = AVKON_ICON_FILE; + imageid = EMbmAvkonQgn_note_error; + imagemask = EMbmAvkonQgn_note_error_mask; + }; + } + }; +} + + +RESOURCE DIALOG r_querydlg + { + flags = EGeneralQueryFlags; + buttons = R_AVKON_SOFTKEYS_YES_NO; + items = + { + DLG_LINE + { + type = EAknCtQuery; + id = EQueryControl; + control = AVKON_CONFIRMATION_QUERY + { + layout = EConfirmationQueryLayout; + label = ""; + }; + } + }; + } diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/PodcastFeedView.ra --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/PodcastFeedView.ra Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,309 @@ +/* + * Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB + * + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of the License "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * EmbedDev AB - initial contribution. + * + * Contributors: + * + * Description: + * + */ + +RESOURCE HOTKEYS r_podcast_feedview_hotkeys + { + control = + { + HOTKEY { command = EAknCmdExit; key='e'; } + }; + } + +RESOURCE MENU_BAR r_podcast_feedview_menubar + { + titles = + { + MENU_TITLE { menu_pane = r_podcast_feedview_menu; txt = "Feeds"; } + }; + } + +RESOURCE MENU_PANE r_podcast_feedview_menu + { + items = + { + MENU_ITEM + { + command = EPodcastImportExportFeeds; + txt = STRING_r_view_import_export_feeds_cmd; + cascade = r_importexport_menu; + }, + MENU_ITEM + { + command = EPodcastAbout; + txt = STRING_r_view_about_cmd; + }, + MENU_ITEM + { + command = EPodcastHelp; + txt = STRING_r_view_help; + }, + MENU_ITEM + { + command = EAknSoftkeyExit; + txt = STRING_r_exit_cmd; + } + }; + } + +RESOURCE MENU_PANE r_importexport_menu + { + items = { + MENU_ITEM + { + command = EPodcastImportFeeds; + txt = STRING_r_view_import_feeds_cmd; + }, + MENU_ITEM + { + command = EPodcastExportFeeds; + txt = STRING_r_view_export_feeds_cmd; + } + }; + } + +RESOURCE CBA r_podcast_cba + { + buttons = + { + CBA_BUTTON + {id=EAknSoftkeyOptions; txt = STRING_r_cba_options;}, + CBA_BUTTON + {id=EPodcastHide; txt = STRING_r_cba_hide;} + }; + } + +RESOURCE AVKON_VIEW r_podcast_feedview +{ + hotkeys = r_podcast_feedview_hotkeys; + menubar = r_podcast_feedview_menubar; + cba = r_podcast_cba; + toolbar = r_feedview_toolbar; +} + +RESOURCE AVKON_TOOLBAR r_feedview_toolbar + { + flags = KAknToolbarFixed; + items = + { + TBAR_CTRL + { + type = EAknCtButton; + id = EPodcastUpdateAllFeeds; + control = AVKON_BUTTON + { + states = + { + AVKON_BUTTON_STATE + { + //bmpfile = AVKON_BITMAP_FILE; + //bmpid = EMbmAvkonQgn_indi_find_goto; + txt = STRING_r_update_feed_short_cmd; + helptxt = STRING_r_update_all_feeds_cmd; + } + }; + }; + }, + TBAR_CTRL + { + type = EAknCtButton; + id = EPodcastCancelUpdateAllFeeds; + control = AVKON_BUTTON + { + states = + { + AVKON_BUTTON_STATE + { + //bmpfile = AVKON_BITMAP_FILE; + //bmpid = EMbmAvkonQgn_indi_find_goto; + txt = STRING_r_cancel_update_all_feeds_short_cmd; + helptxt = STRING_r_cancel_update_all_feeds_cmd; + } + }; + }; + }, + TBAR_CTRL + { + type = EAknCtButton; + id = EPodcastAddFeed; + control = AVKON_BUTTON + { + flags = KAknButtonTextInsideFrame; + states = + { + AVKON_BUTTON_STATE + { + //bmpfile = AVKON_BITMAP_FILE; + //bmpid = EMbmAvkonQgn_indi_find_goto; + //press_bmpid = EMbmAvkonQgn_indi_find_goto; + txt = STRING_r_view_add_feed_cmd_short; + helptxt = STRING_r_view_add_feed_cmd; + } + }; + }; + }, + TBAR_CTRL + { + type = EAknCtButton; + id = EPodcastSettings; + control = AVKON_BUTTON + { + states = + { + AVKON_BUTTON_STATE + { + //bmpfile = AVKON_BITMAP_FILE; + //bmpid = EMbmAvkonQgn_indi_find_goto; + //press_bmpid = EMbmAvkonQgn_indi_find_goto; + txt = STRING_r_settings_cmd; + helptxt = STRING_r_settings_cmd; + } + }; + }; + } + };// items + } + +RESOURCE DIALOG r_podcast_add_feed_dlg +{ + buttons = R_AVKON_SOFTKEYS_OK_CANCEL; + + flags = EGeneralQueryFlags; + title = STRING_r_add_feed_title; + items = + { + DLG_LINE + { + type = EAknCtQuery; + id = EGeneralQuery; + control= AVKON_DATA_QUERY + { + layout = EDataLayout; + control = EDWIN + { + flags= EEikEdwinNoHorizScrolling | EEikEdwinResizable; // | EEikEdwinNoAutoSelection; + maxlength = 256; + width = 4; + lines = 5; + }; + }; + } + }; +} + +RESOURCE DIALOG r_podcast_edit_feed_dlg +{ + buttons = R_AVKON_SOFTKEYS_OK_CANCEL; + + flags = EGeneralQueryFlags; + items = + { + DLG_LINE + { + type = EAknCtMultilineQuery; + id = EMultilineFirstLine; + control= AVKON_DATA_QUERY + { + layout = EMultiDataFirstEdwin; + label = STRING_r_add_feed_title_prompt; + control = EDWIN + { + flags= EEikEdwinNoHorizScrolling | EEikEdwinResizable; + maxlength = 256; + width = 4; + lines = 5; + }; + }; + }, + DLG_LINE + { + type = EAknCtMultilineQuery; + id = EMultilineSecondLine; + control= AVKON_DATA_QUERY + { + layout = EMultiDataSecondEdwin; + label = STRING_r_edit_feed_prompt; + control = EDWIN + { + flags= EEikEdwinNoHorizScrolling | EEikEdwinResizable; + maxlength = 1024; + width = 4; + lines = 5; + }; + }; + } + }; +} + +RESOURCE STYLUS_POPUP_MENU r_feedview_popup_menu + { + items = + { + STYLUS_POPUP_MENU_ITEM + { + txt = STRING_r_view_edit_feed_cmd_short; + command = EPodcastEditFeed; + }, + STYLUS_POPUP_MENU_ITEM + { + txt = STRING_r_view_delete_feed_cmd_short; + command = EPodcastDeleteFeed; + }, + STYLUS_POPUP_MENU_ITEM + { + txt = STRING_r_update_feed_short_cmd; + command = EPodcastUpdateFeed; + } + }; + } + +RESOURCE FILESELECTIONDIALOG r_podcast_import_podcast + { + title = STRING_r_view_import_feeds_title; + root_path = ""; + filters = + { + FILTER + { + filter_type = EFilenameFilter; + filter_style = EInclusiveFilter; + filter_data = { "*.*" }; + } + }; + } + +RESOURCE FILESELECTIONDIALOG r_podcast_export_feeds + { + title = STRING_r_view_export_feeds_title; + root_path = ""; + filters = + { + FILTER + { + filter_type = EFilenameFilter; + filter_style = EInclusiveFilter; + filter_data = { "*.*" }; + } + }; + } + +RESOURCE FILENAMEPROMPTDIALOG r_podcast_filename_prompt_dialog +{ + filename_prompt = STRING_r_enter_filename; + default_filename = "feeds.opml"; + path = ""; +} diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/PodcastQueueView.ra --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/PodcastQueueView.ra Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,152 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +RESOURCE AVKON_VIEW r_podcast_queueview +{ + menubar = r_podcast_queueview_menubar; + cba = R_AVKON_SOFTKEYS_OPTIONS_BACK; + toolbar = r_queueview_toolbar; +} + +RESOURCE MENU_BAR r_podcast_queueview_menubar + { + titles = + { + MENU_TITLE { menu_pane = r_podcast_queueview_menu; txt = ""; } + }; + } + +RESOURCE MENU_PANE r_podcast_queueview_menu + { + items = + { + MENU_ITEM + { + command = EPodcastAbout; + txt = STRING_r_view_about_cmd; + }, + MENU_ITEM + { + command = EPodcastHelp; + txt = STRING_r_view_help; + }, + MENU_ITEM + { + command = EAknSoftkeyExit; + txt = STRING_r_exit_cmd; + } + }; + } + +RESOURCE AVKON_TOOLBAR r_queueview_toolbar + { + flags = KAknToolbarFixed; + items = + { + + TBAR_CTRL + { + type = EAknCtButton; + id =EPodcastSuspendDownloads; + control = AVKON_BUTTON + { + states = + { + AVKON_BUTTON_STATE + { + //bmpfile = AVKON_BITMAP_FILE; + //bmpid = EMbmAvkonQgn_indi_find_goto; + txt = STRING_r_suspend_download_cmd; + helptxt = STRING_r_view_stop_downloads_cmd; + } + }; + }; + }, + TBAR_CTRL + { + type = EAknCtButton; + id =EPodcastResumeDownloads; + control = AVKON_BUTTON + { + states = + { + AVKON_BUTTON_STATE + { + //bmpfile = AVKON_BITMAP_FILE; + //bmpid = EMbmAvkonQgn_indi_find_goto; + txt = STRING_r_view_resume_short_dls_cmd; + helptxt = STRING_r_view_resume_downloads_cmd; + } + }; + }; + }, + TBAR_CTRL + { + type = EAknCtButton; + id = EPodcastRemoveDownload; + control = AVKON_BUTTON + { + states = + { + AVKON_BUTTON_STATE + { + //bmpfile = AVKON_BITMAP_FILE; + //bmpid = EMbmAvkonQgn_indi_find_goto; + txt = STRING_r_view_remove_download_short_cmd; + helptxt = STRING_r_view_remove_download_cmd; + } + }; + }; + }, + TBAR_CTRL + { + type = EAknCtButton; + id =EPodcastRemoveAllDownloads; + control = AVKON_BUTTON + { + states = + { + AVKON_BUTTON_STATE + { + //bmpfile = AVKON_BITMAP_FILE; + //bmpid = EMbmAvkonQgn_indi_find_goto; + txt = STRING_r_view_remove_all_downloads_cmd_short; + helptxt = STRING_r_view_remove_all_downloads_cmd; + } + }; + }; + } + }; + } + +RESOURCE STYLUS_POPUP_MENU r_queueview_popup_menu + { + items = + { + /* STYLUS_POPUP_MENU_ITEM + { + txt = STRING_r_view_show_info_cmd; + command = EPodcastShowInfo; + },*/ + STYLUS_POPUP_MENU_ITEM + { + txt = STRING_r_view_remove_download_short_cmd; + command = EPodcastRemoveDownload; + } + }; + } diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/PodcastSearchView.ra --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/PodcastSearchView.ra Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,182 @@ +/* + * Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB + * + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of the License "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * EmbedDev AB - initial contribution. + * + * Contributors: + * + * Description: + * + */ + +RESOURCE AVKON_VIEW r_podcast_searchview +{ + menubar = r_podcast_searchview_menubar; + cba = R_AVKON_SOFTKEYS_OPTIONS_BACK; +// toolbar = r_searchview_toolbar; +} + + +RESOURCE MENU_BAR r_podcast_searchview_menubar + { + titles = + { + MENU_TITLE { menu_pane = r_podcast_searchview_menu; txt = ""; } + }; + } + +RESOURCE MENU_PANE r_podcast_searchview_menu + { + items = + { + MENU_ITEM + { + command = EPodcastAbout; + txt = STRING_r_view_about_cmd; + }, + MENU_ITEM + { + command = EPodcastHelp; + txt = STRING_r_view_help; + }, + MENU_ITEM + { + command = EAknSoftkeyExit; + txt = STRING_r_exit_cmd; + } + }; + } + + +RESOURCE AVKON_TOOLBAR r_searchview_toolbar + { + flags = KAknToolbarFixed; + items = + { + TBAR_CTRL + { + type = EAknCtButton; + id = EPodcastSearch; + control = AVKON_BUTTON + { + states = + { + AVKON_BUTTON_STATE + { + //bmpfile = AVKON_BITMAP_FILE; + //bmpid = EMbmAvkonQgn_indi_find_goto; + txt = STRING_r_search; + helptxt = STRING_r_update_all_feeds_cmd; + } + }; + }; + }, + TBAR_CTRL + { + type = EAknCtButton; + id = EPodcastCancelUpdateAllFeeds; + control = AVKON_BUTTON + { + states = + { + AVKON_BUTTON_STATE + { + //bmpfile = AVKON_BITMAP_FILE; + //bmpid = EMbmAvkonQgn_indi_find_goto; + txt = STRING_r_cancel_update_all_feeds_short_cmd; + helptxt = STRING_r_cancel_update_all_feeds_cmd; + } + }; + }; + }/*, + TBAR_CTRL + { + type = EAknCtButton; + id = EPodcastAddSearchResult; + control = AVKON_BUTTON + { + states = + { + AVKON_BUTTON_STATE + { + //bmpfile = AVKON_BITMAP_FILE; + //bmpid = EMbmAvkonQgn_indi_find_goto; + txt = STRING_r_view_add_feed_cmd_short; + helptxt = STRING_r_view_add_feed_cmd; + } + }; + }; + }*/ + };// items + } + + +RESOURCE CBA r_podcast_search_cba + { + buttons = + { + CBA_BUTTON + {id=EAknSoftkeyOk; txt = STRING_r_cba_search;}, + CBA_BUTTON + {id=EAknSoftkeyCancel; txt = STRING_r_cba_cancel;} + }; + } +RESOURCE DIALOG r_podcast_search_dlg +{ + buttons = r_podcast_search_cba; + + flags = EGeneralQueryFlags; + title = STRING_r_search_title; + items = + { + DLG_LINE + { + type = EAknCtQuery; + id = EGeneralQuery; + control= AVKON_DATA_QUERY + { + layout = EDataLayout; + control = EDWIN + { + flags= EEikEdwinNoHorizScrolling | EEikEdwinResizable; + maxlength = 256; + width = 4; + lines = 5; + }; + }; + } + }; +} + + +RESOURCE DIALOG r_waitdlg +{ + flags = EAknWaitNoteFlags; + buttons = R_AVKON_SOFTKEYS_CANCEL; + items = + { + DLG_LINE + { + type = EAknCtNote; + id = EWaitDlg; + control= AVKON_NOTE + { + layout = EWaitLayout; + flags= EAknWaitNoteFlags; + singular_label = STRING_r_searching; + imagefile = APPICON; + imageid = EMbmPodcastPodcatcher_64px; + imagemask = EMbmPodcastPodcatcher_64px_mask; + animation = R_QGN_GRAF_WAIT_BAR_ANIM; + }; + } + }; +} + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/PodcastSettingsView.ra --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/PodcastSettingsView.ra Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,262 @@ +/* + * Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB + * + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of the License "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * EmbedDev AB - initial contribution. + * + * Contributors: + * + * Description: + * + */ + +RESOURCE MENU_BAR r_podcast_settingsview_menubar + { + titles = + { + MENU_TITLE { menu_pane = r_podcast_settingsview_menu; txt = ""; } + }; + } + +RESOURCE MENU_PANE r_podcast_settingsview_menu + { + items = + { + MENU_ITEM + { + command = EPodcastHelp; + txt = STRING_r_view_help; + } + }; + } + + +RESOURCE AVKON_VIEW r_podcast_settingsview +{ + menubar = r_podcast_settingsview_menubar; + cba = R_AVKON_SOFTKEYS_OPTIONS_BACK; +} + +RESOURCE AVKON_SETTING_ITEM_LIST r_podcast_settings +{ +title = STRING_r_podcast_settings_title; +items = + { + AVKON_SETTING_ITEM + { + name = STRING_r_podcast_setting_showdir; + identifier = EPodcastSettingShowDir; + setting_page_resource = r_podcast_showdir_page; + }, + AVKON_SETTING_ITEM + { + identifier = EPodcastSettingAutoUpdate; + setting_page_resource = r_podcast_autoupdate_page_resource; + associated_resource = r_podcast_autoupdate_texts; + name = STRING_r_podcast_setting_autoupdate; + }, + AVKON_SETTING_ITEM + { + identifier = EPodcastSettingAutoDownload; + setting_page_resource = r_podcast_autodownload_page_resource; + associated_resource = r_on_off_texts; + name = STRING_r_podcast_setting_autodownload; + }, + AVKON_SETTING_ITEM + { + identifier = EPodcastSettingConnection; + setting_page_resource = r_podcast_connection_page_resource; + associated_resource = r_podcast_connection_texts; + name = STRING_r_podcast_setting_connection; + }, + AVKON_SETTING_ITEM + { + identifier = EPodcastSettingIAPList; + setting_page_resource = r_setting_iap_page_resource; + associated_resource = r_setting_iap_texts; + name = STRING_r_podcast_setting_iaplist; + } + }; +} + +RESOURCE AVKON_SETTING_PAGE r_podcast_showdir_page +{ + label=STRING_r_podcast_setting_showdir; + type = EEikCtEdwin; + editor_resource_id = r_podcast_showdir; +} + +RESOURCE EDWIN r_podcast_showdir +{ + lines = 3; + maxlength = 256; + default_input_mode = EAknEditorTextInputMode; +} + +RESOURCE AVKON_SETTING_PAGE r_podcast_connection_page_resource +{ + label= STRING_r_podcast_setting_connection; + type = EAknCtPopupSettingList; + editor_resource_id = r_setting_connection_popup_list_entry; +} + +RESOURCE POPUP_SETTING_LIST r_setting_connection_popup_list_entry +{ +} + +RESOURCE AVKON_POPUP_SETTING_TEXTS r_podcast_connection_texts +{ + setting_texts_resource = r_podcast_connection_closed; + popped_up_texts_resource = r_podcast_connection_opened; +} + +RESOURCE ARRAY r_podcast_connection_closed +{ + items = + { + AVKON_ENUMERATED_TEXT{value=EConnectionDefault; text = STRING_r_podcast_setting_default;}, + AVKON_ENUMERATED_TEXT{value=EConnectionAlwaysAsk; text = STRING_r_podcast_setting_alwaysask;}, + AVKON_ENUMERATED_TEXT{value=EConnectionUseIap; text = STRING_r_podcast_setting_useiap;} + }; +} + +RESOURCE ARRAY r_podcast_connection_opened +{ + items = + { + LBUF { txt=STRING_r_podcast_setting_default; }, + LBUF { txt=STRING_r_podcast_setting_alwaysask; }, + LBUF { txt=STRING_r_podcast_setting_useiap; } + }; +} + +RESOURCE AVKON_SETTING_PAGE r_podcast_autodownload_page_resource +{ + label= STRING_r_podcast_setting_autodownload; + type = EAknCtPopupSettingList; + number= 0; +} + +RESOURCE AVKON_POPUP_SETTING_TEXTS r_on_off_texts +{ + flags = 0; + setting_texts_resource = r_setting_on_off_closed; + popped_up_texts_resource = r_setting_on_off_opened; +} + +RESOURCE ARRAY r_setting_on_off_closed +{ + items = + { + AVKON_ENUMERATED_TEXT { value=1; text=STRING_r_on; }, + AVKON_ENUMERATED_TEXT { value=0; text=STRING_r_off; } + }; +} + +RESOURCE ARRAY r_setting_on_off_opened +{ + items = + { + LBUF { txt=STRING_r_on; }, + LBUF { txt=STRING_r_off; } + }; +} + +RESOURCE AVKON_SETTING_PAGE r_podcast_autoupdate_page_resource +{ + label= STRING_r_podcast_setting_autoupdate; + type = EAknCtPopupSettingList; + editor_resource_id = r_setting_autoupdate_popup_list_entry; +} + +RESOURCE POPUP_SETTING_LIST r_setting_autoupdate_popup_list_entry +{ +} + +RESOURCE AVKON_POPUP_SETTING_TEXTS r_podcast_autoupdate_texts +{ + flags = 0; + setting_texts_resource = r_podcast_autoupdate_closed; + popped_up_texts_resource = r_podcast_autoupdate_opened; +} + +RESOURCE ARRAY r_podcast_autoupdate_closed +{ + items = + { + AVKON_ENUMERATED_TEXT { value=0; text=STRING_podcast_autoupdate_option1; }, + AVKON_ENUMERATED_TEXT { value=60; text=STRING_podcast_autoupdate_option2; }, + AVKON_ENUMERATED_TEXT { value=360; text=STRING_podcast_autoupdate_option3; }, + AVKON_ENUMERATED_TEXT { value=720; text=STRING_podcast_autoupdate_option4; }, + AVKON_ENUMERATED_TEXT { value=1440; text=STRING_podcast_autoupdate_option5; } + }; +} + +RESOURCE ARRAY r_podcast_autoupdate_opened +{ + items = + { + LBUF { txt=STRING_podcast_autoupdate_option1; }, + LBUF { txt=STRING_podcast_autoupdate_option2; }, + LBUF { txt=STRING_podcast_autoupdate_option3; }, + LBUF { txt=STRING_podcast_autoupdate_option4; }, + LBUF { txt=STRING_podcast_autoupdate_option5; } + }; +} + +RESOURCE FILESELECTIONDIALOG r_podcast_showdir_selector +{ + title = STRING_r_view_export_feeds_title; + root_path = ""; + filters = + { + FILTER + { + filter_type = EFilenameFilter; + filter_style = EInclusiveFilter; + filter_data = { "*.*" }; + } + }; +} + +RESOURCE TBUF r_podcast_softkey_select { buf = STRING_r_view_export_feeds_softkey; } +RESOURCE TBUF r_settings_title { buf = STRING_r_podcast_settings_title; } + +RESOURCE AVKON_SETTING_PAGE r_setting_iap_page_resource +{ + label= STRING_r_podcast_setting_iaplist; + type = EAknCtPopupSettingList; + editor_resource_id = r_setting_iap_popup_list_entry; +} + +RESOURCE POPUP_SETTING_LIST r_setting_iap_popup_list_entry +{ +} + +RESOURCE AVKON_POPUP_SETTING_TEXTS r_setting_iap_texts +{ + setting_texts_resource = r_setting_iap_closed; + popped_up_texts_resource = r_setting_iap_opened; +} + +RESOURCE ARRAY r_setting_iap_closed +{ + items = + { + AVKON_ENUMERATED_TEXT{value=0; text = "";} + }; +} + +RESOURCE ARRAY r_setting_iap_opened +{ + items = + { + LBUF { txt=""; } + }; +} diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/PodcastShowsView.ra --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/PodcastShowsView.ra Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,276 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +RESOURCE AVKON_VIEW r_podcast_showsview +{ + menubar = r_podcast_showsview_menubar; + cba = R_AVKON_SOFTKEYS_OPTIONS_BACK; + toolbar = r_showsview_toolbar; +} + +RESOURCE MENU_BAR r_podcast_showsview_menubar + { + titles = + { + MENU_TITLE { menu_pane = r_podcast_showsview_menu; txt = "Shows"; } + }; + } + +RESOURCE MENU_PANE r_podcast_showsview_menu + { + items = + { + MENU_ITEM + { + command = EPodcastMarkAllPlayed; + txt = STRING_r_view_mark_all_played_cmd; + }, + MENU_ITEM + { + command = EPodcastAbout; + txt = STRING_r_view_about_cmd; + }, + MENU_ITEM + { + command = EPodcastHelp; + txt = STRING_r_view_help; + }, + MENU_ITEM + { + command = EAknSoftkeyExit; + txt = STRING_r_exit_cmd; + } + }; + } + +RESOURCE AVKON_TOOLBAR r_showsview_toolbar + { + flags = KAknToolbarFixed; + items = + { + TBAR_CTRL + { + type = EAknCtButton; + id = EPodcastUpdateFeed; + control = AVKON_BUTTON + { + states = + { + AVKON_BUTTON_STATE + { + //bmpfile = AVKON_BITMAP_FILE; + //bmpid = EMbmAvkonQgn_indi_find_goto; + txt = STRING_r_update_feed_short_cmd; + helptxt = STRING_r_update_feed_cmd; + } + }; + }; + }, + TBAR_CTRL + { + type = EAknCtButton; + id = EPodcastCancelUpdateAllFeeds; + control = AVKON_BUTTON + { + states = + { + AVKON_BUTTON_STATE + { + //bmpfile = AVKON_BITMAP_FILE; + //bmpid = EMbmAvkonQgn_indi_find_goto; + txt = STRING_r_cancel_update_all_feeds_short_cmd; + helptxt = STRING_r_cancel_update_all_feeds_cmd; + } + }; + }; + }, + TBAR_CTRL + { + type = EAknCtButton; + id = EPodcastDownloadShow; + control = AVKON_BUTTON + { + states = + { + AVKON_BUTTON_STATE + { + //bmpfile = AVKON_BITMAP_FILE; + //bmpid = EMbmAvkonQgn_indi_find_goto; + txt = STRING_r_view_download_show_cmd; + helptxt = STRING_r_view_download_show_cmd; + } + }; + }; + }, + TBAR_CTRL + { + type = EAknCtButton; + id =EPodcastDeleteShow; + control = AVKON_BUTTON + { + states = + { + AVKON_BUTTON_STATE + { + //bmpfile = AVKON_BITMAP_FILE; + //bmpid = EMbmAvkonQgn_indi_find_goto; + txt = STRING_r_view_delete_show_cmd; + helptxt = STRING_r_view_delete_show_cmd; + } + }; + }; + }, + TBAR_CTRL + { + type = EAknCtButton; + id = EPodcastMarkAsPlayed; + control = AVKON_BUTTON + { + states = + { + AVKON_BUTTON_STATE + { + //bmpfile = AVKON_BITMAP_FILE; + //bmpid = EMbmAvkonQgn_indi_find_goto; + txt = STRING_r_view_mark_as_played_cmd_short; + helptxt = STRING_r_view_mark_as_played_cmd_short; + } + }; + }; + }, + TBAR_CTRL + { + type = EAknCtButton; + id =EPodcastMarkAsUnplayed; + control = AVKON_BUTTON + { + states = + { + AVKON_BUTTON_STATE + { + //bmpfile = AVKON_BITMAP_FILE; + //bmpid = EMbmAvkonQgn_indi_find_goto; + txt = STRING_r_view_mark_as_unplayed_cmd_short; + helptxt = STRING_r_view_mark_as_unplayed_cmd_short; + } + }; + }; + } + }; + } + +RESOURCE STYLUS_POPUP_MENU r_showview_popup_menu + { + items = + { +/* STYLUS_POPUP_MENU_ITEM + { + txt = STRING_r_view_show_play_cmd; + command = EPodcastPlay; + },*/ + STYLUS_POPUP_MENU_ITEM + { + txt = STRING_r_view_show_info_cmd; + command = EPodcastShowInfo; + }, + STYLUS_POPUP_MENU_ITEM + { + txt = STRING_r_view_mark_as_unplayed_cmd_short; + command = EPodcastMarkAsUnplayed; + }, + STYLUS_POPUP_MENU_ITEM + { + txt = STRING_r_view_mark_as_played_cmd_short; + command = EPodcastMarkAsPlayed; + }, + STYLUS_POPUP_MENU_ITEM + { + txt = STRING_r_view_download_show_cmd; + command = EPodcastDownloadShow; + }, + STYLUS_POPUP_MENU_ITEM + { + txt = STRING_r_view_delete_show_cmd; + command = EPodcastDeleteShow; + } + }; + } + +/* +RESOURCE DIALOG r_show_info_note + { + flags = EEikDialogFlagNoDrag | + EEikDialogFlagNoTitleBar | + EEikDialogFlagCbaButtons | + EEikDialogFlagFillAppClientRect; + + buttons = R_AVKON_SOFTKEYS_OK_EMPTY ; + items = + { + DLG_LINE + { + type = EAknCtNote; + id = EGeneralNote; + control = AVKON_NOTE + { + layout = ENotificationWithGraphicsLayout; + }; + } + }; + + }*/ + +RESOURCE DIALOG r_show_info_note +{ + flags = EAknDialogGenericQueryFlags | EEikDialogFlagNoBorder | EEikDialogFlagNoShadow; + buttons = R_AVKON_SOFTKEYS_OK_EMPTY; + items= + { + + DLG_LINE + { + type = EAknCtPopupHeadingPane; + id = EAknMessageQueryHeaderId; + itemflags = EEikDlgItemNonFocusing; + control = AVKON_HEADING + { + headinglayout=R_AVKON_LIST_HEADING_PANE_POPUPS; + }; + }, + DLG_LINE + { + type = EAknCtMessageQuery; + id = EAknMessageQueryContentId; + control = AVKON_MESSAGE_QUERY + { + + }; + } , + DLG_LINE + { + itemflags = EEikDlgItemNonFocusing; + type = EEikCtImage; + id = EPodcastShowInfoImage; + control = IMAGE + { + + }; + } + }; +} + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/PodcastStrings.ra --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/PodcastStrings.ra Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,121 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +RESOURCE TBUF r_podcast_main_player_cmd{buf = STRING_r_view_player_cmd;} + +RESOURCE TBUF r_podcast_show_cmd{buf = STRING_r_view_show_cmd;} +RESOURCE TBUF r_podcast_update_cmd{buf = STRING_r_update_feeds_cmd;} + +RESOURCE TBUF r_podcast_update_all_cmd{buf = STRING_r_update_all_feeds_cmd;} +RESOURCE TBUF r_podcast_view_cmd {buf = STRING_r_view_cmd;} + +RESOURCE TBUF r_podcast_remove_feed_title {buf = STRING_r_remove_feed_title;} +RESOURCE TBUF r_podcast_remove_feed_prompt {buf = STRING_r_remove_feed_prompt;} + +RESOURCE TBUF r_podcast_update_new_feed_title {buf = STRING_r_update_new_feed_title;} +RESOURCE TBUF r_podcast_update_new_feed_prompt {buf = STRING_r_update_new_feed_prompt;} + +RESOURCE TBUF r_podcast_delete_played_title {buf = STRING_r_delete_played_title;} +RESOURCE TBUF r_podcast_delete_played_prompt {buf = STRING_r_delete_played_prompt;} + +RESOURCE TBUF r_podcast_delete_show_title {buf = STRING_r_delete_show_title;} +RESOURCE TBUF r_podcast_delete_show_prompt {buf = STRING_r_delete_show_prompt;} + +RESOURCE TBUF r_podcast_remove_chapter_title {buf = STRING_r_remove_chapter_title;} +RESOURCE TBUF r_podcast_remove_chapter_prompt {buf = STRING_r_remove_chapter_prompt;} + + +RESOURCE TBUF r_podcast_enable_downloads_title {buf = STRING_r_enable_downloads_title;} +RESOURCE TBUF r_podcast_enable_downloads_prompt {buf = STRING_r_enable_downloads_prompt;} + +RESOURCE TBUF r_podcast_feeds_title_format {buf = STRING_r_podcast_feeds_title_format;} +RESOURCE TBUF r_podcast_feeds_status_format {buf = STRING_r_podcast_feeds_status_format;} + +RESOURCE TBUF r_podcast_onphone_status {buf = STRING_r_view_onphone_status;} +RESOURCE TBUF r_podcast_onphone_status_unknown {buf = STRING_r_view_onphone_status_unknown;} + +RESOURCE TBUF r_podcast_subtitle {buf = STRING_r_podcast_subtitle;} + + +RESOURCE TBUF r_podcast_shows_no_items {buf = STRING_r_podcast_shows_no_items;} + +// Shows view status strings +RESOURCE TBUF r_podcast_shows_title_format { buf = STRING_r_podcast_shows_title_format;} +RESOURCE TBUF r_podcast_shows_title_download {buf = STRING_r_podcast_shows_title_download;} +RESOURCE TBUF r_podcast_shows_downloads_suspended { buf = STRING_r_podcast_shows_downloads_suspended;} +RESOURCE TBUF r_podcast_empty_queue { buf = STRING_r_podcast_empty_queue; } +RESOURCE TBUF r_podcast_empty_list { buf = STRING_r_podcast_empty_list; } +RESOURCE TBUF r_podcast_empty_list_updating { buf = STRING_r_podcast_empty_list_updating; } +RESOURCE TBUF r_podcast_empty_search { buf = STRING_r_podcast_empty_search; } + + +RESOURCE TBUF r_podcast_feeds_update_message {buf = STRING_r_podcast_feeds_update_message;} +RESOURCE TBUF r_podcast_feeds_update_error {buf = STRING_r_podcast_feeds_update_error;} + +// Feeds status +RESOURCE TBUF r_podcast_feeds_never_updated {buf = STRING_r_podcast_shows_never_updated;} +RESOURCE TBUF r_podcast_feeds_is_updating {buf = STRING_r_podcast_feeds_is_updating;} + +RESOURCE TBUF r_podcast_feeds_no_feeds {buf = STRING_r_podcast_no_feeds;} +RESOURCE TBUF r_podcast_import_feeds_title {buf = STRING_r_view_import_feeds_title;} +RESOURCE TBUF r_podcast_export_feeds_title {buf = STRING_r_view_export_feeds_title;} +RESOURCE TBUF r_podcast_export_feeds_softkey {buf = STRING_r_view_export_feeds_softkey;} +RESOURCE TBUF r_podcast_pending_status_active {buf = STRING_r_podcast_shows_title_download;} +RESOURCE TBUF r_podcast_pending_status_suspended {buf = STRING_r_podcast_shows_downloads_suspended;} +RESOURCE TBUF r_podcast_feeds_status {buf = STRING_r_view_feeds_status;} + +RESOURCE TBUF r_add_feed_exists {buf = STRING_r_add_feed_exists;} +RESOURCE TBUF r_add_feed_exists_title {buf = STRING_r_add_feed_exists_title;} + +RESOURCE TBUF r_add_feed_replace {buf = STRING_r_add_feed_replace;} +RESOURCE TBUF r_add_feed_replace_title {buf = STRING_r_add_feed_replace_title;} + +RESOURCE TBUF r_catchup_feed {buf = STRING_r_catchup_feed;} +RESOURCE TBUF r_catchup_feed_title {buf = STRING_r_catchup_feed_title;} +RESOURCE TBUF r_remove_all_dlg {buf = STRING_r_remove_all_dlg;} +RESOURCE TBUF r_question_title {buf = STRING_r_question_title;} +RESOURCE TBUF r_podcast_addfeed_prompt {buf = STRING_r_add_feed_prompt;} +RESOURCE TBUF r_podcast_addfeed_title_prompt {buf = STRING_r_add_feed_title_prompt;} + +RESOURCE TBUF r_tabgroup_feeds {buf = STRING_r_tabgroup_feeds;} +RESOURCE TBUF r_tabgroup_queue {buf = STRING_r_tabgroup_queue;} +RESOURCE TBUF r_tabgroup_queue_counter {buf = STRING_r_tabgroup_queue_counter;} +RESOURCE TBUF r_tabgroup_search {buf = STRING_r_search;} +RESOURCE TBUF r_tabgroup_shows {buf = STRING_r_tabgroup_shows;} + +RESOURCE TBUF r_search_prompt {buf = STRING_r_search_title;} +RESOURCE TBUF r_podcast_no_search_results {buf = STRING_r_podcast_empty_list;} + +RESOURCE TBUF r_add_feed_title {buf=STRING_add_feed_title;} +RESOURCE TBUF r_add_feed_query {buf=STRING_add_feed_query;} +RESOURCE TBUF r_add_feed_success {buf=STRING_add_feed_success;} +RESOURCE TBUF r_add_feed_failure {buf=STRING_add_feed_error;} + +RESOURCE TBUF r_import_feed_success {buf=STRING_import_feed_success;} +RESOURCE TBUF r_import_feed_failure {buf=STRING_import_feed_failure;} +RESOURCE TBUF r_export_feed_success {buf=STRING_export_feed_success;} +RESOURCE TBUF r_export_feed_failure {buf=STRING_export_feed_failure;} +RESOURCE TBUF r_clear_query {buf=STRING_r_clear_query;} +RESOURCE TBUF r_search_noresults {buf=STRING_r_search_noresults;} +RESOURCE TBUF r_podcast_connection_error {buf = STRING_r_podcast_connection_error;} +RESOURCE TBUF r_searching {buf=STRING_r_searching;} +RESOURCE TBUF r_importing {buf=STRING_r_importing;} +RESOURCE TBUF r_exporting {buf=STRING_r_exporting;} +RESOURCE TBUF r_exit_shows_downloading {buf=STRING_r_exit_shows_downloading;} +RESOURCE TBUF r_search_results {buf=STRING_r_search_results;} +RESOURCE TBUF r_podcast_no_feeds {buf=STRING_r_podcast_no_feeds;} diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/Podcast_reg.rss --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/Podcast_reg.rss Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB + * + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of the License "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * EmbedDev AB - initial contribution. + * + * Contributors: + * + * Description: + * + */ + +#include +#include + +UID2 KUidAppRegistrationResourceFile +UID3 0xA0009D00 + +RESOURCE APP_REGISTRATION_INFO + { + app_file="Podcast"; + + localisable_resource_file = "\\resource\\apps\\podcast"; + localisable_resource_id = R_PODCAST_LOCALISABLE_APP_INFO; + + embeddability=KAppNotEmbeddable; + newfile=KAppDoesNotSupportNewFile; + } + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/Podcatcher_64px.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/Podcatcher_64px.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,2732 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + eJzsvWmTHTlyIPgL4j/kfpBZt9kWFTgCAfSOrdm7UqMdqtXW1S1pTDZWxq6iqjnDJGtZLGl6f/36 +DUfESx7Fp5HUkxmVWUlPPA+HA3D4Bcdf/B+/+fqrw3dv//Dyq/Rsvpv+4i9O716+eP/23a/uCHr3 +169f//Tj+3cI+sVvf3kX8rMZGh3+un4jDf/u5bsfX7198yv6E/3xHj/9i69f/OHlyzcv7g4/vn7x +8Mu7X/wS/vK7V+9fv4S//ebtd9++eP/tH1+++6bkH/7nsxevfqlvBlTnF++hUZj/co5/Gecw34Xl +V3nBBi/e/POLH3989f/hn0uqCWDHtz+9+e7Vm++Pb//nr+6+CnfzXcnwH/zlP7/67csfxz8DffOc +a72bn4W6LHm1xue33/708PLN+9+8e/vtyx9/PL19/fbdj7+6O/3pxZu7v3nxPfzlxd1/ffn69dt/ +uTu+fvHt/5iABcs3969ev4TePrx4D+Ri3w9/HeI3x59evf7u1z89/OEl8CGVFcHpG0L5+x8BF6DF +3xG8fvPXDwD5+uX790AkvHB2tJyA8W8flJRf/Obw69/97a8vdyGmuxPx62/+639xbeDD0K+Y4UeD +H1c+8Nu/Ovr+0Qew4T/+9uX3r2iQgfv/7ZdC77u3Pzy8ePc/fuRmwij8y+9ePvzwGsaIeJris+Uu +Bfyhv0kr4A1zPa3h7quYV/hzDhGaWJvO9Zf//Orlv/zq7tdv37xk1h7evf+aBzrneeaf/Jff/vT6 +5bvfv3n1HigrCGrM2795+93L19DePn//+sX3P2onQ//JDX734t33L9/DFHn7+qf3NIGrvgHG7vmL +P71Ergd+wd/+8PLN797+HdH4VYjrs1LKAmNe+JcE9MV6V5ZwFyq9pMAEDfbqoD8ZP2JDXPoSmCF/ +8RuYBn/77tX3r978qt5Vnht/9e7Vd31qrPGu8g9C/Ky676bfTC70/P37l2+EfJiSp79xU2x+9jdf +wxsvb747vX1A9v+I6wimwBuYHa/ffs9/s9/pL/Dxn35g6unf38BI/ebdqzeIc/o1/aV+85vXP8Gf +/urd259++Os3//R2+gWLkN+9e/EtNLv72z/895ffvgdRIID+29c/vXr/EqTAD7/8ICLo1ruXd/xH ++DD9U///8U+fX/4TLNX+cYZe3vzzy9dvf3BoDfLizXd3f//i3Q8fR/2b1y/evHh3R3DD/PzVP8Nf +XgCPOu4O+wSkL97/EYTNyzff/Wg4+Z8jPoZ9HN/X3+KkeHd3fPfTj3+8+93bt68N7fgnwy5ggmL7 +fx/v+A194M3fvmEG7d8kDbZvAonw7+4t0PrxN8Af/z1jP714/frV9+9e/PDHV99ee8GVv9ub+G+f +M7H+9PCHt69f/fjQ55OD/ObFu/evvn398us//fj+5cOHsCE3/unVm+9gIpLQ6dS+ffgBdYW7r//4 +4oeXhPP9H++p5deGcPkGBKMXfV999QGZCNvu8Y37+1+9e/HdKxC3sJcfX//08u638M8Xr+8U/Mvp +OhjEPSD6bvrH6T9NM36FOc15XuYVnjq3+TAf5/N8me9DCDGkkMMCm88aWjiEYziFc7jEOYYYY44l +rvDU2OIhHuNpiud4ifdpTiHFlNKSSlpBsWrpkI7pBM85XdJ9nnPICZ4FnpLX3PIhH/Mpn/Ml3y9A +yxKWuKQlT8uyFHjWpS5tOSzH5bRclvsyl1BiSQU+DX8u0/+tnelfwb7D1X+hKhjtZ5JvII3YkeZl +Iq7gt/4s8p3ltwIcK8Az/VmJf/jd3G8H+D7Cz8NE/zsRe0/wjUzmn8BsYDcSB1/QGVIsgYn9l/80 +3d/fX+7P96f74/3hvsFT79f7cr/c5/t0H+/D/Xy5v1wu58vpcrwcLu1SL+ulXJZLvqRLvAR4F3z8 +fDmfz6fz8XyYzu1cz+u5nJdzPqdzPAcg6/50OZ1Pp9PxdDi1Uz2tp3JaThmGLp4CkH5/vBzPx9Px +eDwc27Ee12M5Lsd8TMc4HQP07/5wOZwPp8PxcDi0Qz2sh3JYDvmQDvEQgBX3NFb399Qd7NCZOoXd +wo4drHPYvZW6iJ3EbmbqKnYWuwsdxgeRXC4T9Rz7fqL+IweQB434gJxAXiA3FuII8gS5gnzBZzbu +IH/gawImIZuAUfA04lUlfiHHkGfItdw7s/+6fOJz3j7THiQ8+pTnuH+mK8DD/oHO5Lu/+Ob4DvpU +8Gulp8LT5IHBLEd6YF4AH5Cp9yuJjhVEBAiDRE9eYcnCh/mrrm1aGzyH9bjClEImwojcV1oxNcAD +MqSCoKi5wkqv9M66VvxqFWZRhalWTzQEF5wabZ5gaYFIarGllhsIByBvbdC6tXagB+ZngzmMY0cT +AWYVLEIQYjATI8zHBLMyw9zETgFlNJS4/mgdRnoCiUB+MojCBKJwod/wZwaxuNBT6EEOFOwMCcsG +/z9M9MsRXwo/j/LzRA+sN/h5QWmKszmSHKJ3pYhfIEFBwuIDshCkLAi8WCcSto0E7iHCogSJe4af +F/hJCwNkL0rfANIXMaCYBUEKY4IG7krSuELfG8hjksiPSBvkFi8f4h/yEfmJfG3EZRzPQnzPMAIJ +KMKuzjg4MERnGKwTDNkBm8IgrhON6ALjm2isA8jLe1yVMBNOMCtwBBpMlBUmzQLTJwOpERg6w/LH +SXaG6XaEkWqAZkUjaQK5n2EHiMD5GeTDBVbkCfaHA5BUcfLBrgEmOfQ9wgjNIDsusF5PsM0cYLup +8IYCm08G/kQYyTmxXMI1TU+yJ8pD43We+ZHFJvLmRMLixF9Heg70tAkZdyJmnGjm47IBgbqQUM0k +WFG0RhKv+MwkZO9J0KKoPZO4RYGLX4eJ5G4j2YvSd+XVCDIYpXAmSQyyGB6aaceZRDIKZRTLZxLN +KJxRPKOAbizBrkiDK0/71Gca/lk/61mvPdNVcPnEZ9k/Xdb9o037uw/8wk+E73K3zM/WllawmgEB +mL7f/HwExx/h7XkG8RmxacltTVexlAgTGU3yCkub2rQ6w6pTjOuz1EK6S8uztiydrtujJophaYVQ +0D0EKljNV9HGvM4Loi2gJOYF0YK+BI0FbXiG6tYdqGKd3BvjBVqPZ1O0VQO+rkLfv/ju5d37t3d/ +/0dU46fNv2GoIivNSMkCIoh+SSuoqHvxCSS1GJZ1/AWpHCcd4rlTPFc7yx8ff0E8NpFG/t0OJQ3z +F6JDt9W63N2OPkP4OQP7V+9evnzjraINgLCKPWRCNJsQnTciVMWnCVCn42bSKiLpGDPpurKBntzW +2bdN2DhJ+sIWjZv1DNs3buNH2Ngb7PcL6QEBdAPUEw6wvaK6kUA/uYcdCE0JtETivPvaWkL7BiTz +uwRdRMEGy+w+inod0SIZlGy0Li6mZx8HKwM060lU6jCYGmfaGuknG2lN7KVF7Co0tZIYYvp8xten +9ZWsR7Qf2YI8ga6AhsC9WJJsS5o1KZpvFY13o+2ivjs5ZTeTsltI2a2o6qKeS2912inrpo200hPp +o6yLRtJCF9JAK8yQA8yrE8yze5h1AeZfgpm4AAErbPYN9/4jqAJn4P09KAoBlIYEKsQC1K2gYPBe +bgpgIAUQzXD8yqYKUldZTSdlEM3zRib6gcx0UQzJWIdnwmFNZHhlGq9Mqi9rpojTmw2uIwdZJrhg +zrR47qlbs3Qt0pt4sS08NypZymfyPCRSqytpzGeYjpH04FU8DepmwN6xEUbTkr9gqvK0pQkcZDqT +ckw2JI07PahZXHEd9C+ej+wgSNT7xSx/oJY+TDopa6UFfRWklrJiGrAlKaesnqKCyioqKKn04Q/a +yl10dMGRWdfmoT6QJo9PFe1+leHFgeYh5y+cCDwpoB9+xISNxEixFKpMhuPgr8ERz+axAUWevDaj +3wbGbCLHTYJ2C2nhvPL6qhvXXF9vbGWyfTnYlhOZltFWWzcsebUdtlal2JVsVbJNqVYlfqROZFSq +WXkis5KcBGhW0sN2ZSTOZrMuC63iVaxMXM1saR6nnampD5ucs5idbHiy6cnGJxug/iEOTPK/D07N +n/n154ow2P+DOfYC7y0T+fWS+PdIPrrtp/9WbFtaaYsqstBX929y7U3st6DxoTVRZDUc3UrAZbA4 +16VtOs55WWSb4UkPUx6mO8x53lqybCnNpveFpnW0Kc0uEpzJaGufZQbr3JV9Z6IJe7AZepE5yZvP +YpvPQTafM0nre7Ieo0ho3oJWmOYHNEGPZJHSNgQbUSDrNZE1W8jGrWT1HsgQxq8LGstkOAcypXFb +WciNhmu2TudKHraj6ApnEOX36JIjXSLSgy47ZB9JBXLn8ZqljYWUkaMa45czbwZn79oA0/5ojjx1 +4WUx74MY9Bcx4tn5qe7PIrZ6EhudnaCXyQzzg9jjq3hDl1F93KiOBxH2LO674hgnlvqoN5Lv5SzS +f/S6lI3XZfS7XMhFdiJ32WEy90uFicL+l4WmTjIvTMCZTNY0+2LONNWO4pE5kLyr5JdZweYhNWcx +B00iJ00kR02QVcI760WcNmdy3PAjnopysKdNLFVZHzVnrvPlHgdfrnpyuy9XPbndlzurL3c6X8yd +q77c7s1t5s3t/tzFeX4Gjw97eybn7Lni6rni59l7egZfz4TOnsHd4x0+zulDT3N+H/X9qPeHZ90y +2i/JXEHROYSC2jRm1+hzGR7i1CT/w/H5zKCAhQUeiwpM28CAqDtbhcdUHprkF3EusmtRZzb5FSea +1MGm89kmctMJTDM3qWtRnItncy6qe3FlRW5ymtxejzuIq7GSqxGdjexuRIcjuRzJ6chuxzPNgONE +3kf2P6IHEn2QhVSqTJ7IRN7ISMoWm0aodvME53nJk0gH98Aa4OC4N6EwD0LhpELB8W01n2zeyQNj +3yRCQMWAX/+69ufBTet5Kc5az8jpCh89F7M4bSO51j0Pj+K8bQPz8tS9uMYx5tXRFOQqqvFiKjEr +xGhz32/2iZPsFHXYJT49OLYJjU20COaPhcbE3d5nf1f4+9w/sVjXwVN3ujrTx/nOs11kM40Pjs2B +RG61UYklTuJC7yPS3GjwWLAD/UKjoFPYJu/IQNLHj6ywWJQnbOI7q6kuoxJ+Lwq4Kt9AyiR6t2rc +XZHxqkzcxHOqM0OdCYoDMZn9qboNazeV5OuBZO6J5PBFLO3ZlBy2txdTdFDVOUym6+DegHuEajtd +38m0wZjOIyoPSld4DwtYVpr4OZrydBK0Z4s23Js6pS/RF0WLWmBsUt6p79V3rxLKrLIRMhUH2SBZ +CVNF7Cyb6IV31HvRy1Q36/pZlG04y7PIU5zG1rW2yubRRP87DEqcU+Ps6V8WNGUDnzXwJDr4alr4 +aaOH50ETP6op6jTxpevikyjjZ4ltqja+mD5+sOl9/6hGfpQpTaHKjUo+uIKuOYNGd5Bq5OoSSpPz +ClWZsjph2TEUTCNfnE6uE+vkNwwJWbrsDsnvCBJ/LJThUS3keGbvy+A4yOQ4INfBJA== + + + 2R5HmogX8Rup/6B7EHi01IdwphHr2R/B3AguB2QVL97R/AneoxDNi7fYcNYhas1+hfOkbjwJWgfZ +yNSbpz4G72VoEr8+OOkm8m29n1wgW4PZ3fUwhrT1qRLcVk/EoR77M1XRJWWl6rIZAmXirOgui2CO +i/6Ie2iiH4OYpgyeBLK9ELmUv+O8apq6o26ge3H9sRNIl1pfaHEyt0/5tHUGA3K2kcAx8H5U9KEK +o8ctpG8g+DWsM+l+Fm9NzwZg98x5civtse3i6FacbBfmqVzMDpZlN8lmIRvFla1CNwu/Xbh16HcM +FOnTsG3oxpHd5lHIXtmK8IM9x1GMT+J4d+PuPPgH8eCbD1/sqWtO/ONgP6+WApMmUY/UUroMZnQ3 +pFcxh9SU7sa0hrrF4pnMoB5Nag1t78Pam5C2GNdqXi+TBWZcaOYD6Q0+waH4aI2a3BPb3IOKrZa3 +V7QPsr5V3V5FCixmiLMpLqaLauBBxMlskW7dPs/2nOw5Dg9LqMNEP8is9jH1MRzeM6o0q0ozqyTs +Y4EfF/qZXJ7VyfZs3cOby7nq1vpqasDiMrDEdp/MfI8uISuonuFSoC7Ooj+bXd9te7HvJ1kKzZ5q +T+dgsWdxT76SAAIzPLonuGfuzyYN6zI85/GZTvuv4+45PPK0/UO6I4dB9jl/lvH3SMLfB62aSTwU +Hzfwt9bNaN+YjT+ZX0uXmpo5ecgi6p4sNVm35mpgu2dyWURH81itzlRNg5nqTf6jmUOrxW/ydCWA +w/lFPoQjQRzLNVIHgHcBiBNgEhv2InOLfAFizbI9yw4BtmrVsmXbajH3QO5OgmkMu2EyAdAAdq2P +o9cSQ/WAvNZMv8DWGRMmTkTOoODAf4zPUAcaEwpui5aSCtYwQwNsNuelUbpJaY1yAcg0h19SXuaG +L1lgZOJKx6sIt6UotPQswkzohN4Uq+S4RJiZiCA2wIUYY5vDMvQ9hLUgpCgTIna95/nclfgswTzx +KS63REuUhgo4BwSxFEAxDNsCfeWzXIiczvkwttSe4bZ2lzImADlKb4uWKP3y6ZTLM0oRCsicHG85 +U7eoOQWmrmnMmwqx5oErjfxJ+Msal0wjOiNblBF4UC1i2lJoLhPmtng/JyHm+as3L+l0kWXEbCE9 +22lzRACjYXxA4GQHBPB4wDoYkPdyPCBRyL704wFoOE49br+xMC5iX6RNSO2aMe+CatNyEftia12c +dia82hZ7E975pyZLPm5bS35wTXU7w/umjm2XcTxdtTjU5ui5Eqdu67tMiV2uBPr51WWlpgg7rg4S +MHDOK7NJulWilkmW6EQ5VdQf2H11kSAdO6wKWRgHcVDJVIgyGRbNgpAJwWdGZjk10s+NVLJLnXdB +J8gkKc6LuBjcLHFnSPJwimSblRC992cym/ST3D9XDdPqcn7IU3AxT0F02T7rLvfgYrkHPZ9dnUI2 +naatu9PNqrjJNthmsw+57JpUMLlk9mVjzXp79uI8SNFZs1vP53miiG6CeYH2KtqpZ3I2RpoQ67l9 +bCqMk2F2h4j6dNA0+LNMhnkaBMY4Gbq3KbhElaL+JpsSw6SYHvEJjtNiOzGOmyh9Twxbpit5KqOI +CZsUlSEhbOs0qvO0lTs2U7zouT5Zrk6XyWWl7M4+DH7yPllGx4fzlKPbAyMXOEdwdqBQuUiwP8vk +aH8+CSo99zA+ku212mkuOse1n+GcrrY/JJfMhSqJazSRdfvD6XuayL8WSJThvscy7B6maaK9DvOn +zjAlA0xFTKBt6jqDOZdgrlWYX6f1ApMpwSRaMUR0qhegNsHcWGE6nGACBBj2QnkeZ5AEESTASuN6 +ge0h0ogeMFXDLfUKkv90voAVHidYOYXSLU7ohb8PlEpXYEYe0HF1b6e6/BG1n3NAbTBWp1seT0Mz +dfr48bQPJd2ZYWrx5+lqHE6PtPg4nD/OsjvM0k+yTFeOsnzmQRYKf3Lws6U6WdwzWcTzQkeGOM+4 +0smiBSYpZRvTWaQLZRwfKee40qEmPvSEB6JgOd3TucUTpSD3dN5M+VVBs4ufpsLTVHiaCk9TwU0F +566qZZ7JtwDaWWmNbPK2ZKlFQvbntfMtn/cxOcPyeSezvuRU12eeTPn67T+95/I/d3/36vs3L9/T +waNr0H5mX3kwKQ8m5cEUppkeYfOnt/zEAcFzMqU+A60z363pGSi28bNG5trnaYg+5bPPyhJiXtDv +EfAD6a7WZ2uK7fNIeBzNp1PSlp83M8dPfs5E+f2bNy8eXn53972A7mDFwUy5CqbpKL6bTfWFqzbz +VRfLIybztLOXVzsj40+Dh03OxJg14fImJgvpFpc64VwuLqzbXS6rmcW7VKCtq2XZ5QIN4V1xs5BR +/Lgx42tH7OtFJPnWYhG9aETBGhLdelitGgQbyQfy8JzIlOjlILgYBH3DO+/lMDqeh8HvOIHIjXYC +Xc+e87lzPHW+8rlzskMOJK77IfOLHTCPcsgcxPtEp8sLna3RPA/O9DiS/c1HyzG/B/YIOj6iZ4qW +R46O32JL9jvydIst2e/I0y22ZL8jTz9/S+5nl7aFK7ZlK7ZFK7YlK1y9imlIcHblKobU5tmifz2n ++TgE7TVsXyYXuXex+yF634+pH3YB/G0In2qF7A+nfySOz4nyrFOORSyunTXfHxJfNpHvHvtO0yb8 +7ULguyC45qefr0bCJRY+uWB4D4fvA+I9JD4ExV1Su4z3NIbFXWD88rHA+Kh6wdJvdfmQUgObWGhl +rhybwhp7eCQ8p5Cvakm3QshRtwbyK1Mcr87hOrIIa5xOiRf9RcJQ15XG26H8sj071qt7NoD9ns1j +S3r00TaLg6R5UVKInEVS19S1o7SxH4KanG/rs07W+q9reyP7fjkiRPEg2qiyKxXFkSAtE9UkeRAd +ueT9mkg1OUrkJ1I5qF4MChQSUkd6vOdAXjB2zdrxKaLMPJPJkq36ESSfZHWxvNkwJOf29FzSTyYJ +exwskUrzYO9d8qsmvWrCq090rZc2Zl19VnWga+V/NoWAps+p//NY0R8WpT/TDL9ihdOGP335ji9V +SVzS+cmS/6vtpLqX6m6qJq4auZz1X8zOTRObumbsqrmrBq+avGr0qtmrhi+ZvpvCIUuZW/SSZM1L +5Pi+Woio96PUwxSEANpFuW5rfimm0dqFFVUXkrMhYNkOH1fm6h6ugMZMoEdrStwK5ZeJz3RVeqax +nl1TH/3wyGEn97t/TsPjc7rO0/hPUc/dMy5yO36ZhiTUa8f+x4P/o2Fyr3Hfyc7/l+vHE/zrScpc +qXSzU3o+45lGLWn/0DodtevPUK5/rrfLp68/7ZdP++XTfvkfZr9MC0gIv3UssMB93hZtJ1zQCf7I +KVBX98svxcT75ZftuikAqK4328UV35/7Xp6vb+Y5jaYQfj2lnj2lnj2lnj2lnj2lnj2lnj2lnj2l +nj2lnj0lmTzlGz1Nhaep8DQVflbqGe65n5XUFdAmbl+QFSYIPjXDSA8jLs9mPPb1M5Lf9KNfaKS3 +60Z6c0a689iRiqzqMekWZlgnVzOiG9WqCXO5CNF/zSwirVcNaq/rspY7phTdD+UhfBEWVxRx+vRK +vP9xtUvOU4ryk80k+Llxrn7oGpB9Of+P1uifHqnF/ykxiH1QAeRBT8fYJmXskjP42oaPeVo/U0hP +j/haf7aInh7LRdqLaM4I+lBxjmjZPxfp+AfKczATpuGs/9kyffbFOdJQ5/LeUnt6Yk9VDhXL6flg +rctHxC9wpoRyVYxKbghIuhVPvFLaSFhK+3CS7hciHH2upcyB/bg1jQ5dO+mc6Ui2+Uk/4nH9QoRf +JsqX6/5WAEPHr98G9uRvffK3Pvlbn/ytT/7WJ3/rk7/1yd/65G998qw8OdmepsLTVHiaCp/sb7Vb +N+pmGHUQcQiv3ZLw6CGjabgVYbwJczxpNN6E6a9xG44aTVfPGmVXtjC4cqH+Tg6tXqh3ckiJ0MlV +3/dTZSxhmHwJw2HG6JyxGTM9OmX4IBrPFp0rH5opMk8mmSh9mnDi33gNXZ8f29kxzg2YGRNODJoV +Oif6jKAcWnbSNVjNOAmiJD/iGsYVvMBwBxhiLZ3fdufGzMPk/EvHSdbweJnKcrXY61jo9XD9RpVJ +lvljtyfsR3G4N8HdosJ1WQ/TY5fabq611XG9dshwkAbTo+IAh/nj4uBgSZ4iD6aPCAQvErxQGMWC +CAacAdMVweBEg0wFEd245iMN/YWWNQ48DjldmHDlvkVfVnQY5+nqMPdFOl6c00f50VsyJhtqf3GO +W7Tu+uJt6VEe7158lMZ82sj+7RUZ4yUZYbht5LjbCmD0Jzf8n7IfuB3B3YXh7sGYNlm+V3aGYW8Y +dwe3P/BEwMMTJzl18aGpACoDKgwHGIRCikIgJeEEo19hhWRQDGZQCk4gtKuTHxfYPg40hSK85UKT +ZwVJEXGHP8NcqcDfRNdqnGAarDDwCcjAKzQOMEQLjGSgGzMOMF4LMCTYmYQGA7LAQAS6EuM40W0Y +C6y3AMzmdYaiFBkcgLnIWGSrSlBkpl7jyRzsspN4Nxnr+D7PgWmOZ21zeGF/YEHOKPwZ2OXqXuh+ +pg85HPPGv9S9S4NrafpER+MH3IyjX3r6eRdKXPVPk2dx+sB1Eo9cJvHhS0WnD9wqOl4i4e4V/dC1 +opNcHCEuY/IPeqfxqm5jOfRxT4c9Ih3zWOh4R6UrPo50ocflcj/RtZx8FedCV3BW9J2j9xpvFxH3 +wtNUeJoKT1PhaSr4qfCzyke1+VmY28/LopGP/rwyUmV+llMrX5A2pBg+M2/oZ5XL+tIAc7le26DU +D9Uj2seBN9fKkF/8A0tr+sja8qtre4eTX2AWGZ5ciOZ6RaKrN5RtInhHW3mXSQPDLhwzxoX3UeGx +MtEmJjxZMK/fRFMtJqyHg08fC9eE4TctbjSWOeJ/xf6vSX5N9lPjJonU08I1j0RhLXSPLsdT+Lcq +ZZAKncule3QPm5pI26pIF6uLJPWQqDKSVkXin70cUp6kGtJK16gcpBaShiC5GpLEpelicK2HlKQi +UpJiSGj1oO5+mCiWc6A6SEcyjjg8OUsdpEw3JT1VQrpBJaTBPv1kB4W4J66XUfoZt8a6OjqnqVdU +styq7Z2x+xtj511hJSutNG3uiu03xfrySoPvc1NiaSyydJh2dZbGSkvX/Z9yuetQbkkcaZPzgrqa +S1uP2rUaTB+rw/RYLabFFxsYsgA/VJPJVWW6XpcJZsJ0pThTv6roen2mXqHpSo2maSjT5As1XbvA +KPhKEVeuMYJnulKyyd9mJHPvP1IBJ5Aac12p2tIac72KLHDy3fysREl5q0tuc3wkh+52KL9Myanl +qpID4E++MINLPqiNcs1CoYSYxxJvNC9BjZ9rJtBgBD2GqJglxei2CV2IarCndtUZPhbn+2iU71MD +hh8NGT6G6GOxxx2qcZnBzsYXyoQZlAG6Lmiey9qGVUGJQpRXKpOOr5i5Po9vhvHfew== + + + YdvdGolX809jGhbOx3Irr5b2fCy1EsZ4GrToUY8eL3IcEyq3KZWWUDkN9/8Wu4KvDtVTRnsYrGGu +kbPP/1o3iadbA2NrYgxGxrTN+nI88rz65GTByWULloE7B/EEcPZQHtMFqXMuWbKXex1TJs+WMvlY +0uQqF6IeMPrSs+G2+XDXEydHw2vHkmlIyV0P2+uhMU0qUOeLdBknAXfOZTZvb0jVlGa+HTVSStdK +Z1zOcr6FT7dg8vKFqvDkUiborpxoAdMo0VmWBny6EGcy8KLSuZV76CyZ7dCpM3QkAvUr0HykjD1M +16tE5/1ESZwF2MUJnKEncMJEPp/vQbYlkHMrMOUIEhDvTo73mUfus7T7jyv30we1+41u/ymq/fSx +bITryQjUudt2DXOOH+/aFdPl492bPp5sca17PHKfaZl9rIPT51pmH+ve9Cm5JPvubRx9+EbcIEFV +aSVTPZ21RS6is0Sq9qOa6RyhW7SZbi7LGwt13wojX2jXUiAkoFaBnMBDHAvs7rS3k651R048Lima +ERs2Bv6GtF7dmW+F8Mu266vevG2h0lHPrTs9N1FxM9Qe9774ber3Jc2TeeGvVS1/1Efoip45/6DX +e73u62MIPo7gFWl/rKHrwDB1JxdacF0auuWz2n2cwccaKN7gPXRB0pCTOdFWsRza7PPspQSh1AUP +Uhc8W+yjTKKur1YD/OjS7y/O4xXpOxvFi6O50XI+frbK/zmpfet0y8Q+bwJ4Gj2Vnk5PqafVU3vv +TxX6c4WO6oFuT7mnnajvFCoXRxo3VG7oPF45C0hXJ++PAh4t466am8qOAW6u6O40A9VfeEr6i62L ++VkCVYjto1ZgEeAvpS1jkbeCp+UqSW207jGiQeXKrgv7m2H8InGa4jVxCtAvvGfz4uTO7lDV5IKa +q1SO9AFNEadfetrrsDvgE1CveeyAzxBu/ZTjRVsKfKi3bM6bEQXTTsApDUoFn028nXC7UunxE4Xb +v2XO9Ke8+7PfPl0Tkvv3b/yZaDpyfXYYNFqtYNaFsYqiXtm86l24H1z3t0P5M4O/eOnxEr8k+CsY +vkzwXHW7pLHK4icl+lKa7ydl+X5SsugjVtuV9MBPSTjcZc49hs6H5j4lOYFSEz4pSeXfMzrv00RJ +mMldvjS6yRs5GIdD8+I33//ibzBqz2oYrjW/OebPXHjzh87ef86nv2jB5asRgnwlQKBfvfJ0tORO +TvNcnKu+SCIoJ4SuFD+vah70KHqvby6hw03R8nuLnfNWGuRuoUBRdPX8p4kMnySLrMhyKxZb59uG +qsTW1cbgCPuJFivvxhprv0wavuN+8stilKLB/JXkhDg/C0kiDsTzzUR8NxHv43USW0X+ST/12qJG +FxfpBUa84bMFdpIzxuNP+ttkTc7u//25XHnuyfsxBCpx3LxWkwZd7jzocmoan63ud5IuV+kDq0uk +LE0fMYv1Iq8zeR4fKZ/gctHyZOky20S0RD5JTZPZ1tdJj9XXmSwBbblaYYed0Veyzx7JPTtM4oq/ +l6PIUZPPJPfsJDXKu6/9I9ln006GagKaSlKVpSpNWZ6yRD2QyXYiuXr2Y6y6a7bzw9UCa83SWc6W +uBIGPXqxfJU2yWIyVVbWiir5mpyit3QdnFZ9kawUf2x+0XyrSq47nTjdCPhwXqP6VnQqwfd0JQlr +m+E45mBta3LoxJLcq4lSr3puI88rdP1fyP8daULhdDrQVOKJFGUi8b0JZ4pfRJo+6yTO+37SGatd +6EnnIuec70kqoU+cjznfoz8cRrvBCJ+14Pyfz4n3f3WE4ZGHJvAku5u6uNTRlXf727ivXdvQTnop +x7ifBbeH+fg1LzC/eVUxGdlsPKgRdL+5SmC8GcDntoxZLWM2ixS0moYMliFvZZOv4m8QG9NThrSU +achHGW8LG9NPhrSTId1kyDKZxvQSSm1ij9GY4MSGnKY5aaJTkk0x9HSnSTKe7iXh5uzyntjNpBfL +cfITu5zGFCg9BkqJUNOQC6X5UEFngYzMxeVFneUt/XCoHBB9Opj8538w+Wa5JNedGeMo/+xxnlw+ +55ePNIz19GkV5T4w1pvRnn5W7PAD4z19cvTwoyO+sWTrOgcMhrUGm0mkazVgJ0iVXDvi0JklhyZg +RO/RrJwvxfQfLhvnemFPrOtpVqrzlNgur1t4L5RTnKp7MHvzQlcbzbYX805sidnTJidbsrFJRdAs +7EyWkF5Ju9JtSFVsu4OZZ2KETZaNnUjzJd2X5hqrvlxL7EBB+jNZThdS8Weyn1ABRhU40w05BYvy +TJTEgbrwgeb3WaqM8YkE7H+UJ1PVHlSKUS1GxbjSauHyUqoe073JM2nJXGmK60zhiYWFjv5yoSlf +aurE1cisHlmQMwycZrNMlGlThzwbzrTBZb/Ps6FMm9EwTeZq57FT4zTQmH34JNXSqxxNV89QVUqM +OVwLOGxPT8kZjyScXCezV0/IOmdZeNvi9MjZKT04NdwxnSmrZrRaz3a3tJqtyMqPlIXl3KlpODfl +LVe9ne08nJqKlNldKENnnyQGpus0WK5VLtK67v5j4/Xj12V92sVZj16nNX3kTq2rd2x96Nnfv/Wh +e7c+4Tau6Urp2k8pZvvoMz1a7fZjz3r9mR77wyPVcukZLRJlrfZe6VMUanWouREsdqxmhiXCf+bV +0o9fLo22wvQpl0t/+vXSp2W6cr30DS6Y/plXTMthB19A5H66UlzCl5fYFpigEhNPtsefk+3xSIbE +AhxIGOhoGCIbS/uWvFLawaKKJJb6zesjqujtUP6H00nL1cgJQK/WmieFhjf0g7kLrx+ClnzgK5u5 +eqDPlCr+iUeg9c7MddjMfc43nYKenCO6u6JpQ5ctPbjbMBfxSsvWbp5pPhx9QWE+sa+LUz979dnu +ltdkas0tZ+6MB1iPllF97w+yct2jTGu60OputM4PtOJPm+zyRJnIKB0K5SNvbq9FeTtRMrW4ZCWl +mv2yJ8mq76xcSS86cEVK8dSyrxa9tUe+RXRih+3/3i5Z3kw+VmH/w3f97i/wvXLc7sOV968cxfPP +9Khe+djX+ZFHfIlyio96/zlnWz9l3/m8FPFP2HWm2+VPy8FWqRlE677S4YpeWSpeqSZ2cqWlVunO +vrQUdWsiIwt7xnsq988qTFEfuZe9xtj2WlnurlwsO2GfNxWn/N2y3Puh7pTw4CJR1831shMHgh/d +eLHkEqY/t7zWdn2XxEL/mI6QufL/B/e6L0Q4broNekmZhhVPrUgiBO/YTXduvFmVkib4CoCPaAVf +ivGLNuj12v68fmkK49P9AU/3BzzdH/B0f8DT/QFP9wf8bMX4fy3Cp/sDnu4PeHKKPRWNf5oKT1Ph +aSr869/X+ulFDMdz3p/1sf9w/vJ29Uxh25wpvBijj1Zk7yDZlXVTXrrYb9dKTdP/pyG78+fqWFc0 +wShHn9FlQA4DKZSERgCrSZojzwpSoyyQM2n6pB5NcsKRXQNo6S1Si4Oz4i/umPhKSRpHy1y2vGWi +zFTXZFVefHUX9fZr5vksQXz1/GsWOrv/VzwKyHbxgeKnJwnrXyS0P1ssoEcDNNBfJO3z48H+jwTz +Pxa338fmPyVGvwm1s/z+mXL6ipgmIT19ec3EA5sem0r5oxNzMfmnElBl4GnwXxYThGka3JfnXRqb +ykSVittLFEg2PuLXhBlcFzoTFUJbhsJsjY8o2h2h8CcCfcx1+MUoWUAuZR7vLoUPxFa8kMOTXFgi +Dn7BmhSxXBeXX4rpy4Tn1foWbaxvYQVBVeCwi+Fej+Q4X5P3M40HKjZlorcepmsloke35CMlotFX +MJlPaeubNE/SKDeulIraVqTlcN7hSi3aIOHRXj+rTFYe6uD8iGOsNLtTOxwxPVAWiEVNRYqS/Jwo +jWSh2B+nQjVLhpL46dijL5Iw1w5FX5ExnyBhHlcDp4/rgXrf83GT+D+WLN0WLb2WqHPZZviPhUvr +Jq8/D0k727SdTfnSyeXwt9PVAqYcozrSrNRrjHq0ahuvYjX28ctQJGY1adBquBGl34nCCu42bnUt +csUKr9Q5QrnvJT/rvhK92mQapzkMoSBQSuJ4lFyjL02LUOYaQTxclXy3QcfFh1BBG2R5XcMmXQQ6 +COL8zp1yjxi4emzDuB3KDwloAHzz67dvfvPu1Zv3r958/9VXTm77P0y//gH/kvgvv3nx/v3Ld29A +oH/9//704t3LH+8Ob75//fI7kOUbwF0Iz3Jeq/w/3ZXyDCN68v8EXf0Ju2u2wD/8if75/8Cv/x2A +/3KX7/7m7h//23z3HcH/4bfwvy3OBwcTvHfPAbZ51wDTzz6/gg9hb+h1f0tDAZYT6BeUg76uxOY8 +V9hxcDtcC22LM88LrOAqFasS5wL9wwt8AbwU67ouz8DQzEyvgPj/9Er6a7sCkY8932NC0D/Bd6xY +wBK2zAoqw7rSGxSW2rPQahw+fg2mn31+BZ++hz4HnFqgoyBF6T0KK+FZamDn+c9fg+lnn1/Bp+9R +mvTznmNrfJbbGoRBbZ7bNZB/8xabvoU+VoofFgW5QeBPXYG4Mdhg0hdQt9asn31wIM9Z5cI1mJ8N +IzZ9CVEDs0TH9MHB+CNt+Pg1mJ8PW3wDtzZjojA/APr5azA/Alt8+h4QdBG2BVxmy7zCdo0x9ASC +jWV1RnqxepBkAUjBNZDe/AstuPnut1x9JMLy5EJyax5LIHSxiko3K+SwL9Lxk4qr+e4fDlzz+O5f +/Eztc+XasF1bTFfW7AYbgv7AUn9duDBtJ6/EMFRJylyGFr0oRCb0ks0F6vl2fj08MvLDatzAPPHX +5iuTCrt8oNp3MWH44ypvZTtyFg1IR6CfaR1mqUiTa7NHuXUN5iXHFl+ndQVlP9H+uAaeWtBuKcTo +hnFOFNiasLGwiUOVNHBXHUS4W8rXhCkWutrIXAG5VXtF9v/hRhN/K4z9PF1hCLOwxYTpFZhfkNeE ++02HnzZRkJ198AdRe0UMKkg+93yH6ZbDvtkP/Bbhx/iaHL0irq/sLkxozmBFjrXQ8lLbqJ1qCcyq +XJW8JyYUB9JR8OBgvC7yXhJvYJ76LT6ldatVeE3D4xTV5QrIY7ymo+Bbfj9dWN0E/VSUzZ+lr1b+ +y/HdTz/+UfGYuyHOv5zmuwN8/8O/TD/BM2ih13VQ0kC/yrGWZ8tdhoWNlT8DcOGrPMPoYiTfgZ+P +4Byf4cWEBFYM12D9428m1EFxIs+Bxn7FY2E4ScEiqyT81wJmAh2IxN0LIVaAP+g8dq+D/2ExKyQ4 +rgXsmSUjuD2bI3wGgKU9A9tPyEiw5AG2rM/WeV4dad/i53MGemACEhgbhhU+3Jpv+CdoGEIGnEB2 +bziHbcN/Rl7VBhhj9i8HzRp35jJQ6ZkqPTpNY9sM8zcxAkOKzG6gpg8E6Ah8O1IK4KVA54Zeads/ +jd3vbR2rtC12zHG10+D5b9RuB+o0/dP0+6nd/eKXd//w9/AbTWpYBcOU/thMJ+gdgA== + + + 7+Iw5T95wtew1Ge1gmZSY4xYnpfmfJ3LimKiOfDzERzqs7IulcAOySPgjuRWM5+wlwISFLDjRrBk +ojwsjSEpg3rFzXINmYEL7Kh3I2XQstYVpxmD09oUJZjpDEQznIF4pejd1ZfjgCKHQPIBB/gPOYcs +/GzP0FmN4PAszrBDfYWxIZ6U3DalQsDwDI9LM7AFWAtIGi6MGX0CDF5i0LYpy8uWOd5xw4D7NsHK +DITz5xPsiHNlAgJNVAAuz4D3kdtWZtgMs3eBBsqbXAUBTGqYvdLjUgrPCAADtevAnXmFaRKrsHdZ +YxJgCkGJxdRZxovgpAxLbZG28E/BmueiCGAVKc9RuTUEy2oDvERpCxtvUgRVgWDyKwU1y+dhR0Q3 +ADdFk0GAnQkw5wUY0C3ABMxzNAQpKhdB6VqFMzhvShOOzy0TivYsx1lmGEgV4ngFbSBpx9ZlkY4h +GLvOI9mSImh5UWDOiwKbEmYdq6gW6cxva6Q+gCSNocg8AlFLSCtMjqiTAwSWfD7BzC5Ca8vMQwQm +JWrFiS+fl8mFOmG1z2PGlE7ZoJ8vjT8Pr4pxEWBDxjNwrUEQZFzwgmCtK815AObGIwM6SE5VgDWX +VXhdYzEEMCN1CEITKVYXeEmS1+UoKBZUP5P2lrkNwDwvQm2aq+JdcF+Q1Qx87nhLnYUKKrvHQMz8 +EoaXlYHlGcbrtcNFZhKCc5a+BVi8grdAR7PQG5dWBUXGMWEUS1oFWFLSVR6ToS3j2xgtrFLcpjrT +GJhMBJLMFiCo2kIASzsGw2Yg5M6hFiGhzTrAICejIAi5j2TW/laQDjoQIBuobYNpn5emk5F724Ch +IOq0t0UGAsCYDirUxnWVtiuWcWeOo3AXYF11jRWHoCUVNDUxARF6W6UpluwUIGju+qamax/BYZa1 +3yrPGgAC49IOARpLAgzzYgiIRF46lcVfI3Un6DxgYd8Sy5zObUaQcBR1wGQTQWDWpVthq72zlkLB +ChLJEKRkG04BMAPLsq7KWAOSv5UpMBYAdI62cHjAAQjcVHYFJapm3XRhC5VZ1DJPdcbaeBYBsMtJ +EokMLK0qs3EzUgQL0KVteXI3WOPZdpvIcgpagilYhK+p8MzATTCq8MOw7EkR6Ksyb5cIWqJOltVg +XXbbpgTg1Iqu5MQiBoCtrxeRfQ0Wd6rN0cQICnqadXGGkLRt1PWC8Zq7/ypt0Q7WnUbwwpKL2SZs +FRgIZF1vKGn4XStqYbriin1+QWYMu0/zO+hawmoI2px0zeMJGgSCigT/1inAKg8A07rKq1LSKQBb +ZVIC4irvApWpxS0LGwxmTU4UMoL2LJWmCwYFPQNJZefhmksRYJ6H/UsRlFilt0tuVWYRvK4tgoIM +XnkZ2iiiYQXDu5rGEmxxAN6gU1b2e7CMTbk29QiBYJCsqh4JaxEMs0/nV2radp2zyQdiLVo+IeuU +i7q8sW1LVSddKVna4gkdZQ1ryjNtGTq4qSZBAJIz266WK+8eCAa5peCyKArVlVH4lyTAZvtMRF+H +4m1rlsWYsHY8AkHNLTrtsRyyAEEaVt1XYxQEESsLLY4wBq5ZWbPULDAM3Stn1mqfh0WsnFmLfr5v +7SFHpWpNtoH2sUkoBXXdAPPvBAh7uyKYFRjrasCyGII+xcUNy+C8hrWrYwyrMSTHRAaWqEOecbNW +tMscls3QQNtVVQMY5izADNuPKlOhGoISVE4srFsgsKUgwAILkoAZNiXdqTDBQhCATIcfiqAWaRti +KErW3AQIapqqc6jHK4Kcm7BA1FwE1qTq3KpdWJ7FrPyuqG8yAgAvzAOYUlHWDQjrpqJ+SS0oMEV9 +VbJ1s6CsFDAIaO5CcXuFqNQIXLLKNLBddRRAQVt1s1lqq9pWzLig2iABg64EvKHKEJCiwt1Fx7cA +0QZmrMAjAYJYVgpAwBqClhadB6yPhnk1pRraAsMEGFvOytlZmQh6X9WFR6wXYNIVUpZqWJuukJJF +AUcw/C4IqDMIrE5Yk93CwK7ywA6hwqeacoF2MfO7oQM68NCGZMC0RgVG5UBzG6aEZBick0oO2sYY +uGY1QpqIRIAV/fwaFW2YzWSMQjxsWiq1qoi9BpNNJ9Cq6hKCQ1UlgOYCA5fWhPq5yHTHvU6X8drl +ZnMyVolHikJRBKyKIzAuqklXNGKV+lBVaojVTwgW7X1m5YYR2GRT1QjBJeig6BwMGA8pOgNEPGBL +25NIu1UENapAXlHtfq7gxIsDvR0L40WBuXouMHCWFRNNEyUoypq+jhi4gEUjE4NtDARSxImR5hIM +QTYFN6vXC8G0zTN45VkcZFDHYQhOSlcUGoqX+CyrXniDLWxqs4uBgGu23upWhWC01akTJHARCL/m +PjnnVYC64mQmMYJoNhFObhYFAbaf3FRGsqWFwGwrbl1FRUNwtyEbO1QQiJdn6stWZnhmk6XLSEaQ +8VJOpSAJtdkcRbbmEBZ0JsKP1D/fdEspKGsYGG3hoe0pQIppySCoQEdwUSdHDbzGALguyctuBpKH +TTYqXXgBPQRNd0Vc2gIMWUcxyZwFYNKWDav2K4JUbFvlfR1g6nKE4SwL96BQbX+3S/DnC4gd/bwo +tIhgXXRHoSFiYMN9X94U7PN4WlG0ELYTEJijAmsRqmCXEVcbIs3JEGAOmZMyzwUMFqjuHrzVBthR +UtIZm9iVGnCXUN8AfYTRogtQd5Qm+xQAu25D2igDFzF2I4b6dHlUkGi5jASA+M1RJndkRxUC1Vz3 +GyWCm3W3rYpgNR2msLGIQMyd00mk21RAUZ2ULvRtCtai0gQzSo0C1U9riIujINikT1HaYsBY+MJG +OAGD0oonTQ3BOuucFacHArGKz0buQBdW1VqXohpXxGQnVa5SZmrjzHE8Fp5raAJUT0ZE1SkagjIn +W3aLIoAppRSwIyKopSzTIAkPSAeWXZVlxXMBZ9E7I3s1GBirusRW8dQj0NRp2joVbzZDY5HNVQda +NFTW5Gg3mpObc4wA9xjTp6OGN6hH25WHpJucXMSooCWgalBRG/9K2+cKttlM/mQGpqbiU7zcCFxm +jSosaNsp3q556sZA4kWNipVdXfQqczjSlqwIYlLmNIrXMQW2XzUxzYgCW5C5fx6Pzo6aa0QrTPVs +VX0xMGQ7bjUDJCaQqupQWCsr6ghM2bY2GXMA1qSKz6K7DYF1D2hidwMwL1nbSigoou87r7vJCHtj +qX6dCtam7uAmigACTTsgAWoIwtw2MzRxPFzkcjOyogpr88sheGnq09bxSqaQw8ixUwaB62y6H1o1 ++vlim0hbqxJQbBemvVHelFQhN9U7dnddeKbxHoKamkdyxsB9zzViq+n5joXdbUDTUF9GJA4CNMKO +bfswmXYMVM9gZFcPI8iwgrJICbXbAdidAQ1nJANrm4tObtVJEVz69G5NOtb9iG4mgnGJfGLCZHks +QFcTPXOOi67FxW2vNGUUrQbZAMxaQ1y8jiZ2EQDVSYF2jRKLCsKsHRNRC3v+ohsDCUduGKNZG6YO +RoxQq9xh/xOA1F3XTVsAqgkiyrN+vJmDwvi6moteHOgMpLTNjSaEYNFPgFlKAQCjru+A3jgEVtPp +I8cXGQFYXMG43RJT0FhpJ2Bmpy0CNQqGYlw1agDrDiS+SWpZ1BmyKgMbM0OEfBUOJEozty2MNV8E +FrVhMwe8EBiDejJscSHUPHg61q4pdorV4YS2ptkvqyqjCd2JVeY7MJv6moKp0wOwm8tdZ0qBbWdh +bFm0bYwCjDyuSSJfPK4aA6Omtlc2MRgTzqdgG0dTpGszV4yJ6CTavb3ruUDdzOAUNgTjJ7tu0Jjf +CFSrOfMqSKjsrYq16OpGcNWmKjgT9sekaeC9GoE5+F1GESylKV7ZU1M0URI1dAzblmMsBYYZAYZZ +zLjNYloCNEs4ty+ElCgpTDkjkyOZz2KDVnVv1CZYfU/ZZmdUfzwC1ecr+hkjAGOnqXqlhn8qFoOL +7IxmoOstrhRGAGCxapCwmKRnK/radMTEzwRtm8mIZWUZkTA4GBTvWnSCAYKixmUS51NCUyGrQFqj +AgGzaojqDQAoORlFtWCFNmEEJOsE57gSAle0vHoPFIGqqZEddIJAvDqRzUEGklYngkdtZgSLpu24 +WC1eBxSwrQKw3gGN3yOUnNXC76Yfp1EeO1DN3SoeMUXQVy5tWM8FrOFJt0hXDrOxnBNNH2kN6vrv +nnt8XdNgrGQZy+uKhedUpmFsSUAcTaaPF421VHT8nx7/ONCaVA3LnHtDDWczbnOniuI53APWNqir +Js/EiAQg5cMyMKhXC3MVo9o64nWHpsWmpk23igdGzJOROv3NnIpFZ0azbJzu2ANgSkpp3xSJgNWM +WxH/0HZOurrEqkrNyYJsKkxC41T12zQbAp2CGinCdiHo0ky2IzzycTwCJq+Kq75f40/RjwCYm1GF +tCrdGfevGhytDIxBySLXKSHIswU9owUuEGs1QSIOPETgWBg6grA23RUlWgbAss4mSPTzoKwoATYH +sGlUL3KR4E2e/eoWayhjrpEq3dH29YyRMxVwQfxJOVhICN1wCqo62aJZmpmcnSoxJP8DoUqTLAGE +NN3oNXaWMSe3OwmbodQci6iZZwhsMqsXCQkiKKtgCZLDE3Ls6Oif5lqL7PBnYMw6G2jU9MWtqd5R +OH7rX6zOruz1gO6TGT6ekr4JBKKMhHpUkKaos7lHDhCcVdKjOHgu0K6la/QjUwPplRryCLR39aAM +goPmNK7i10JgVraI6MnRgvIo09dmn6+zcrXabplBacg6diqTsW3VvSaL0xZawgxVINpMireVovtC +U70JWlOigXCRtwt8mU1o1XsQr+12wVz1AAZhq0tyZhdSxgCl9bcYYZReKT1TBQXAq6TyRbarGFhC +3/AWgal/ILpoBaI1A2DJrmPdMlGfPL0rbbS8jKZlMWBTurJT0yTnAIGp6qBLaIsaJhnI4j8fi/Zr +FZc8AHPSrUUtK0RqLt6sFgxA+6TT4BwibaokUuSEgYsJBTfBAYFNGfVPArCrz5JSCvoSx+K5q7F0 +CpzNXjSwD63nYsZtyTpDfYqdqm6IGRPHeM9TehfO0KrsSdTtBduu6imP4hQCYLIMvcTpiAjMyTIO ++hRf0EOpMr9ERaA5v9HC7QBcw1L7MPLni/mE3IgVp+KQt5WB6lcbpkx3lUdWQxlYFhUIZZmzADUY +BgRENduxrQ0Z+STlZYuu8iabXsYsOrVau5uEEJikmmUzAPV31eG1NV44QlDNsFAENQXdd4J1t3Qv +LycCElnZHA8W0cW2JW/cBNg2qJ9Z/ef4KvPqE5ARrM6ZqgktAOzp0SvbnQgL6hZrfRYAeDbtLQXl +d0vF3ClseeObFrWcUQTp53OwzzcOXmafyajhsYxavekNFq0AsKb/RI4uCzDrJiZpJwRTMdtjeYg2 +6EZLTvnnAl6KSmo6SaBgTY2N7OESFBJDZvZVi61Joj2/qVpaLm5LihHMilk3ELWrEA== + + + Y1M7VFQUtIpU84uas4kfV57YDg6vj81pLfLuqtsf+SyNpKjaoKboI0Xi+IqciyhImxk6tfU+RXMm +mNjGl63mpCnKFApf8grQfHMEq0Mnan4qAmvU/chWQHVrpaem5MYdH3flZu552e0ZWFZlajHvGYJD +33k4MrWg78h4WBVpLTp+sWvJjc+njDK+ueBJFo8W9lWWBbCgtmoI5qYu7yKuH2gLer45UDvQAgw9 +IIKcWWYLMNTF2KXxH1WzK0fBCeakENBVLQlc8ouQqqo+TTVVAKi7tJyb0B6oIthTvxBBT2EQ9x8C +s6YwOCnUmHMMTrOOV88T02wVGJiuQVFSAiHA8Vosel9ZZCEwqGVt5gNaUGYXWooUno8KTQnjxF8E +NosO6kReMDFKGWu72RLcNk0WEAOdz37lvWQJbtfpHtAlWCQycvIZA2OwLa4GRdBdYou5xBBB1Xmo +ISlsKzla3V5d5LQgA1EkKYIezV0kaWUJJtu6KMd+mRechLZRsKjvKhT9vHobe0oAAoOG+SnUy5+X +KHb1To8lWNqoJaNSS1sI0bIiFuzOYvOQN76lWw6Wgrgky8+RWCF/Hp16OgmSRDiWzGt1UKoAmItm +SnQ/NIB7PFobLklXQeifXrPmu8y6lS7o+rN8ZHE44OeLLkO1wbGlLZdkuvniNUgSUHzua3E6VQoi +4Bacu5aPzMsbgKVZLFo9d9h0XTVNW49tUGPLBJqrYu2pyxqgRmDRfpGfQdH2xKlZZDQA66JJr01U +MmyZNfu7NtV9Fszf1hzfIgGKBSMsevaGktIZqCFnSR9nBMXOOgm1zwXcM8/oqDMCV05b5LZsUwIs +Z1OhTRoiOOk5MvInPRdwn4fkODGwpSTLCSAE1mw59JLNBEAYXe1atkmLCYDKsmRJdQAGDumhL/Fs +AnCxk2AqUVED00MbVQ+YEVrLndJ03KU4p5qm2AIQ9HhFMIeOQCU1pnavacNGO4tBpEpWwsynVRSB +5sfgLRQiEYtFhTDBQdiFGS96yI6sYh1fTbic1VWDBMgGNLNzWYAlWMPW+uftNAkFL2R2LKsQEDFX +jYEad5+d/wjAZdXsdlJZZTIGTSEn74fOUD2naKfxCLwo2L2snxmT4yi0GGYdbkcBnoHSl2leBQD1 +fJkcdROZIkOgJ5WwYZhLdlOLgTCCQlPh5H6SEUHPYvSMVWxrZwTJphVg0XVLWZwipCSuhi1D6jIx +Jh1u3YHR9rVjALkLykXPDUbzmJH8zdEN7XMBR0nmnbtM9ECb3Yl9pww0nQnAugnPXdJFy80fgLRF +MtBUHgSvuhTJ1H6ueyDnsoZm5idtrHp2Q/2oC0oRFRwUmlNFxvEhR1NdWf3HHCQUsAxcmvKWshhV +G1yaHpfSBB+0PoIhaN3WXktVWjUChZbmovIvYgGn52aq6mo0vIVnCw+PKs89g3vmXG/F21eextYA +2LkruxB6FngXRrpMHKAbYtatQcNw6AbhWA12TDQsPHLOOgdlZ5kLFU+t0zaCbfG+HHXF0OFkAksS +Cbq+VhII2DSZS49TA5WH6lGL9jJNDEGf4KzH0yg8g0C0JlVO9mML5BpNilfybPGsfFxlHmlWcSb/ +ovbLEp/Q5cteHwUzUM6hUebdqv5iyqUQrBa0bKp4ADiJ9o1xmbwUZWKzgB+7v5FXs4vtie6KbVFT +5xBW0YyT0DiE+hVHSDltKMgE/oriro0DCEiB+meg6cyaC/YhWcQtqSmKvZAcSwwI15yUCVHRgtBV +tOY7w5jyonyk0OtXFH3uk0Y1PYxTz7pE6OC7hq8lcwn7sPBGnKIeBQjNQpHo8yvCry7WKYkgCjg1 +NpAx3SAoAaknQUBD6SvlIGi+gpyrQTBGGp8LmLou/ZXwFgKr4FW7IMnhbAb2mBMev4+6FiStODa3 +boos3Nj0kBqyq/Q8kLjqBFNLMlZ144Zq3vgIKhIfgkVSLSCA4LXKiGmcG4BrVAKCOMgBWPigI+am +rnMyBGFWBBoipMSblnR6SYJQUcMAsc7qkELwrBwPYvT1xJ8Ngjnb7FI5RzlGOuspCPAoVsxW1lGk +rDdGkPVQeqgm7QHYNxadHZQVp+suWqpZ0NAtskD0A1WBhIecUov+BF0HpjUEOySCSNHT91zAmU9e +48ckASCs6i/GqaE50KhXF0FgajWmJSeVUnIAEYGSYoNNq6U1z03ndk+ZL7o5Y1M56YE53KvOIopg +fEXp2lTQSOaQylkEN10cQROIF03rC413dwGu66qr1tKSLQ89SGrUV5TdLh5cNzcx6Z7TGmiw9BQV +Jt0vumYo8sdA0E8EqCFhBNoQLpb+hngXxbsGOb2R9AwTUqBHRRKWVZHOWg5EwKNs1aCSn59YAMg0 +FgKShm4RaPpciHrgVMXGV3xQJOtC0gQbPFfTqbK9aq5u2Wc7FiQHkXEHFY0ajyoVnUSLFjHgE0wK +LrKxIjBG7YHouf0IlOajK4LC3lXqmBwHrHZEEP1TPI0A2MfAzrbSeSsORtCWUBSBZP4iWXqaD/NQ +VPBSpJsRrJrVhW2jnhgTQ4HUGBbc86pFSjhP3j4+cyRB1QU+hGVBA9rDOWN9XtQCIrLshJ4k0vtV +P1OErarQ4LodeOaXA+Ow5kl54/PREgFEYD+4nvUcFII5EkCFBjiHMFQrXVLtKDNKkmQFOsA+5poA +tOqkFgZmPCoPY8xaVUEO95KM16IsFWMZJuKkQMeqZ65oV7eqDJFTfBGpas6Elp3GSNfKtTSKulRI +aJBJQEDOKCMB3bSAw8Jp57zPcWwWi2ZIdgh1lmsH1KSnqBAYrUJHUg0XwXzAgIDs9O1KFCGoJkxn +oyBhOSglTI0SAmcyGJEw3PYVHGcdB6vRkUDEKL0rJz0iUKIHWpGIXzdzihuBRY3BsjA1Zt2XpeAE +lsbh3C18lR6zAA1Zo2LUjcI1WZI6prAtu2KxDg/FKIW3sqlgzR9xEZCgJRcxVgeCVSLMWaU6kKu1 +JDKCEJTVIqZmoV+pOvR3VI4I6xRF5zyIUYokVVZVxH9R1CnRsp5AJ/kjLZMWguiJMgguQc38YpWS +Yo1iIOqK3lNwEtIwiGuZ0ShEHxS82IkRyVAn/68lJytpmHmriTGzBVkXwcZgdUt3/21P5FokJYtb +WorG0s+rx+6IonQUzRpvaiVveqBdmy1xHSmjUsYCXjUcY0TMLj8iSoI5xgGi5hykWSXpHu9zfiEF +ZCxvCT2TDwJeLZ13XTQksy6aOkQnmL6SQFEsCtSdA8GWnapnsCimo+ErzXPbE3AyysQo07wUpUwP +J1gWJPoBLJ03rWKCVq4mWzm5SH25HJjSMIMGMavVeIl06u3q+5Uw2FSqJvTSCDwoOChh66w5BjFr +xNSCe4tlMVLEVC3+Hsk0w3bhox6Vc3uypihsXq90+XSVRYhCl9CqQeDZLP42G1CUZkyiWXpGsuoQ +6B2wZJVFM5QSH6pgYtXk76f8MUHKwv4jVTLt6OygephJxj0IeGl2lAIVDj0m2EsrkIfg+XUkgn3O +VtgrsA71IGANDPdznFiHwHLQtGRCNrelPwqLaIsGlmdRKWd/aFXDeXsCpMhbW925OlLMHxTcrHYE +nlV4ruCqnjv67fl1JM+pJuCXVQJE8F35+dUARfpjEIH6FDDpZi4O/HwAgwXCbpXn+vk9xH30DdFD +BQBXLCmBpVtRJmKdZtg7Ald1xTscqOh6mwPdWBJg4lB518T3lVAFQNTrSiBFY5b86gfR61ogYYal +HbQikxzymquOOdaPTFw9D+0BtMe/FSWjZrZbi64V1BFAcbWyIlFUBI29gQ5etJTMWjTURyaPHGxA +cFqbONhkV6EydVn9RVKHhZQUFnlhZfmrdM0ze/2KZn6jYjdzkibaP1I+qqIWwqrHzMdkCEFb8Pgb +8SXL4Q6q3EOJLwEr1Yiu1lY58xSwhk8LvUpPwgtkxhFGlZtL5WFriSJi24zeK8JL1a6ujte3stLx +UBhra1j9NoosntFDxuargJ+PYKylICXwkOZAozavbN+yflwXktEKJEZgZb6ZtCXXdqXUkzJi7UCl +QJU40JDrhjAHRpMrSr26WRMzsEZGqTu6EKbjAztn9i0dZzrKK+wSuYTvilW4Tv4jWhAV65GRmj+H +bqegc4GBifVfnjkLp9jNhWXrt7KiQD0lNsgRIBl3rllBGrLNp6VaYEtT23Hkl7iqVzJKoRtsncVk +rnr2hIp08eiQS4CLdAFhQHhV3uhIVozs0I5PuwKX6cIShwt5W7EYLIdpsUTiShlmyBpy6fFUWGVR +0eTt6zrh9oXzXOtGrYt4o7Cheg/RHOB6WNRUTVvCMKNdFqgKl1CA8c0qy0fSD6+MGC6Jn6Zwd/hB +hm5Oq0xAsgYfNmAc21bE5pFzDSGr25TKBHKlDAUy46rWZ3NtG57LZuOmY3VAoYCnhIFn8XUOWGcM +wecNBQpUcSbU+rbWL491xwPk0V9885eHd+/Pr759/+rtmxfv/nT3KwD94vjLu7/8+v27V2++v/vF +13988cPL4+uXVGr6j399/uXd/4lN/sujTX73px9ecqP/C75xC/1honK06EjF2iSgZFFldNBNqVJt +oICyqzUetZZ3li2q0lmtlaUKGbIPIzho4gra3SIoQlKnEjIvFpXvBNThk7wR17ZRUK0MSDtM36+j +p+CV9f0BKSx+V1FSCFAgE2DE+ra9sw7rjgM4engbWS5U3Bd+mamGPNgzkeqfh7TAEke+4mbPqkGJ +dNVk5hrpxlxJpJsl5PQwgoNUMGGCZQMPchCPOxcCqQUKVO7OmR1mri36o9jd5LAaUClgBB28ajqp +wzoXPpowUKBAZa9Q69v27jqsOx4IeyPe2IRllUGD1dsk+LYb2H4ScTXpNUOJ8s9J7cAiP8Zd0HkF +M2kBDyMY+AAajfqMpFQsFpphT1qlGiSpw74VlxVoe3Vs2TRxw6M0oL5eWavgytXXBqRzYS/y8H4F +KmuFVN+299Vh3TFAWDtj8Wq8WaDiNUF0VcKS6IYRsDxW0lyT3eaA9yIgZPGaK7mnVpk3i9hNDhpm +tpuYXjBvdVVrPVXMes/NAZW5scxp0xaXNTvNHFYDCgFdrDC0cjxgQIr1xKIxVwhQoDJXiPVte2cd +1i0HmLdgcbaw0k0ZoGDiL7A9tEQ3vIBOT8YARk1DpnsS8sL3e6F50FkLVpUgTnhe9WEEh1mDuFRL +uHBcVkqhcNcKn5NVIHcNj7nqvLe2aMPFtMFqQKVAB0fBlQ/YDFixBBuaPwMFClTmCrW+be+uw7rj +gXAXc4ZQwqZG2hYaVg1TOug6ikTXkmV//1hhuWucxWsRGWvE/LiHERykKjbTKpVGcdJxjgGpnGKs +CFA5m9cUNm1Xrd/nsRpQKbBpL2DxQA5YMXwxm0wSChSonBVqfdveXYd1xwPhbKBjf7iJlbRS8XrQ +eeo6XPDD09Td+LHarSmypRby91LluFl3Mw9WbRR99LmKhZe4Lh52LhW1Sgio7BUL3g== + + + t8XcGLV2DKsHEgWKQMGVL2/wSFFRa8ZdIUCByl0h1rft3epIdxxg5i61rnT3WlhCJOkwg3Y68jaK +LFjRY0D3K9ntOSKXFn1bs6r8Dtw0aR6BK3v7MCLI55TI0Ai89gSo9kfhI0W+LYZ457rB2oFCgQ2O +gSWxw2OtEmP2BDBMWau09pa+r4ZyxwBkbWANd8mRdYX9TT+dwXorUb9Wi30yxuCSFf/agvFXobht +z0qfXFqAS2jWqSueeIGZdSc2hm8p1zl4lB3Ib9ePd6jEKDzOPu/62xmmvFU6/Qzt3TSU274/bp4c +bmie/F4ce0Ede/C/76YiN4r8dDNH2+A+5HAuKOoie8h0fNiAY4/cYhiZte5sya+9IqMCv53GBADX +drEcjI7VAedu0zowTnw5adqxYuVUySrrFCiQEHRqXdveL4d1zwOSVF9uMFJBwszMkVTEhxGME086 +BvrVIqqWVIfAApZzqg6oHZOcftcWJUbJzaHsEH03f7qDJYV0QIlFIOdWxtcrUEdWSPVte0c71n3v +b2UscirLLJ2jiOTDCEYuwL/vOGkEcMhGRqetuXPw0uaAyttSlzC2RYnRVIIr1g5UCpS9Cu7F1jpW +ZJ4clu0UKJDZa9T6tr27HeueBzcyFiklZzEfjQUgOxizWCRzHEuUcgoUJpGsSadOyMkDlbuYkzG2 +RTHLuW0OawcqBcpdBfeinR0rGqFS6alToEDlrlDr2/buulKgOx7cyl5EIhoX1CMnis7dDq18goSB +3d+8xkW5KzVVFajcbUnnrrbFfbWoNq1YHZAJ0M8LNLii5IaUFrZU/jQCFKjMVZ+Xa2vdclh3HLiR +vcgJYkE1YSxL+LABV3WPc81fNczaKotq1rukFMhdw5jQHMa2ZI6lMGJ1QKFAmStgNIuk3mLHGoLm +NzkKFMgUGLW+rfXLY93x4Ab2Ir1/rTJka9IsCAeunJHLwBQUSNsn94t99gZUzgaRuL0tviIqULE6 +oFCgnBUw7t4Y+Buw4qyTky+dAgUqZ4Va39b65bHueHAre5HkFaev4WaBufsPG3DlPBbuR0s677Ic +FsXi3FGnOAGVvSnM+7bzsoYdVgUKBTbzGYy7jJwO7liRpyluKFCgIhBqfVvrl8e648GNLMZA/hx1 +4lB9kYcdWG/TQGBe1fzofYONcnVA7VtOOjyubY9oOqwdSBTY8BhYEy87VmLOvI4UKFARCLVj294v +h3XDg5sajbRT8PnTWZL/H3ZgV14+mG8Cx1ZYUdTQXufa+yeC17dcY4w7lB1Ir9fPd7Aeq3BIh/mv +7xegySfzl2jboVOKdc+AbzkF5H9BbOtDpiMbMv8q1iMluGeVvWY9OnDk3IKvuE60HJWyKBdVHG7J +h8mI6VgWVnJ8XduiF7R4rB3orccORqVSUrc6Vgw7B6kYbBQokBEYta5t75fDuueBKIpfZDjSBUSa +LIEb4MMGjLpW0arceggi+QrTnYO5OMZKsSjfduHg/oi1A4UCRmBglHhScdiQzqul73UCFKh8FWJd +296tjnTPgdsZj5g9UMTPT7VQHjZgqjogvG1cJCgkO/VBBUSqB3LXElaYzJu22RKHO9IOk/fr2Ah4 +ttRnh3ReLdevE6BA5a0Q69r2Xjmsew7cynSkw5lRDbcito2DYpmJzKeHAme9coJCNt7q0TQBKm/l +wj7fFq8VUt4a1g6cLRvHQWd3psmQosGk1aCNAAUyAiPWt7VueaxbDtzMbqQj51UUrHkJnbkKDnaw +KMrVbbymqzFXjwgKUJkrR4F922SHWhzWDhQKFIGA6SiM1WcXrOhykuPQnQIFKneFWt/W+uWx7nhw +K9ORjqNnTW3AxN6HEYyG2crOHyqQoSaDFpyheiwDkPuGZd5q2rSle1nqBqsBlQKb+7MypzV9lyBF +qynPcSRAgcpcIda37b3tSHccuIXhSEUZZg15YVbVwwgmbczucZC7UXHSSRIz5vC2GBxQ+aoHAl1b +LLKofDWsBlQKFEEHW9lyw0rxFs7b6xQoUBkr1Pq2vruGdceDmxmOlJxsQatZ4rgOTM7Bpv2Qe9iC +3Bn6lRzXVD8xAZU7clmIbwsbT1H2GlYDKgWKoIMlBdNhRQ2qxTxSoEBlr1A7tu3dNaw7HtzKcKSS +hVGWxGJz10PtOG6wvEw8KLWoGJabVxWoXVslC2NoK+WeRqwduNTOmg7VCxoMJ11oZkB5vwL180Lr +2Lb3ql6BLTZvb2AuIrlLU3O0mKbgwXqABnvB55PGQV/y7GeCzZo4511buTluxNqB46o2sBZsGrCu +Le4IQJh+vNPaW/ZOOZQbBrC5+DFj7l/DjqMz+jofuh3nwK7qe9Byb+gilxNZiS4Uaw5IzEhYEHRt +m7aYgaC6nKslr0Bvx3Ww07A61lmutR0oUCAjMGp9W+uXx7rjwQ3suIS7u7pysIbQwwbaL6xIVNlT +Aj96YUbCw9E1OaDydY65bdpikYAQN1g7kAlQtgqUjinXuwEnariz3VMg71cgf95o9W2tVw7ptv83 +M+Lwxougw5WwpNbDBtyvGsXSGEuTeawlg+iyhlwdkLuW9fZi33axPdJhXdzGSRTo2PTdjOp3DVjn +1RzanQIFKnOFWt/W+uWx7nhwKzMOrwmRU+YzlQt/2EAxtTMJb2POepogsLczUXmj5IDKW1XZXFss +J6XRN0XaYfx6kyYMRdVKSgB1nJgyJyUg+vsVqJwVWn1b65THuu3/zYw4vFSl6ZhRndeHDThwLQ6m +NyWNyOk1jdA3quTSgcrbwMWEfdvMh25HrB0oFCgCAc+tX8piWDGwrbcIGAUKVO4Ktb6t9ctj3fHg +VkZckmsbWbFRZXiAUhVYJjcHjdRLnVu67WVJHcYdS3oc1rXMlgvjUHqgKcIdiixYreKQ4MScgr6H +yesVqIwVSn1b65PHuu3+LQy4JOemWS9sqgR3cOiHxqlgkebgSnYwdgtUwtUBla10LGXbtsmZfofV +gEqBIuhguw/EsJIvMYWRAgUqY4Va39Z317DueHAzAw6XTdCBXPH2sIcRTC66prQtUjNotjKzCa/n +qNEBlTuxlLBpm1Rn9VjToMgurY+Pgf3aZ6x6mfNAgQKNvUzt2LZ317DueHArAw5p4JI1qHq32Cev +A8+r3iAl9RbR2EnG8hrVKUJA7VtbNcxvbRNeyZU2WAegWbcDWOtbDlhrvwSrU1AtsjVQ69r2fjms +Gx7czIrDqmVNBw5Gq0/eDqZqpgIsFqHrI7+KJtrGvaTUed9W7p8esXYgUWAIDCw16AekdS279yNM +P91JdS2tTx3jpvv/djZcRt9tzc5+ediAA1dZ/IqLBnL/0H6Q+xWxbKEF6OxsIJVDXNq6abu609aG +tQO9DdfBs1RKG7Di6TKpRdUpUCAjMGp9W+uXx7rjwQ1suEy374kPJVtpEwcOFvvHC1Ziz0Vreo+I +FvmKLqSQF6sQ5dpiSuecN1g7UCjQkRHwrAWHHFL0pCtbjAAFKl+FWN/WuuWQ7jhwMzMu9zjlzKfz +Hjbg4IpiplbEeshaeQMLtM7VAZW3cprfty16Htoh7bC5Hxp0YOSCXiFgSMmRnsNIgAKNt23XtsdE +HdYdB25lxGFlz9LUiFmMswoMfIcwU5uLRYDtphwY1dZhylgpdO9aYkXhuEXZgfRyZasAnW7VUVJO +tlQusbcrUNkqhPq21iWPddP5mxlwme75EB2MKu49bMBS5ZTJ1cKP7moFPL0RggMqZ7VGlWtLJRrb +BmsHCgWKQMCzFQDtSGeqy1tHAhSovBVifVvrlkO648CtzDe84MqSzUgiPezAEkTPyRnMyfYPmH4O +xv3CItAa19eWi95p7TB6mJOSBp6b1XPvONFy0JtT7PUKNL62Ejdtk8u2M6y77t/CfqPCwZbtW+de +hqifyVv02o4EqyYFnW+zsjWsITug8rVIGTzXdsGqIWmD1YBKgXK2g7VuWcc692qtnQIFKmeFWt/W +d9ew7nhwM/stdy9e4ytVH0Yw+eaakqG2bbErvuYaQocpa7PlTPaWa1i3CA2oL9fPdzDdmzognXuh +zv5+BSpn1bC2lr6fhnPX+VsZbji2XL0SMc9zNbY68Gplrui4Ho9uDnZTXFPN3s7o0VSyJFNrm7k8 +84h1AM6akTiA1UE8YC1LizsKCGi8NWpd294vw7rjwc0MNywXlvRAPoV3H3Zgu/IuuT3AjXwPaRNQ +O9eSJkH6tqWtO6wd2OPOA1jr/A5YTVb297cuajul1q73yOHb9P5T7Lbwr5dIuaCvxZktDwMwaLk/ +uo6girOdd7J+PQqDiA+LXcvW29URU3Vv48/oJl/5NsCOY6ZbusaXCYw/aVS5lkK7R7jp460O2S1J +D9iGme9rftiAg6WMIalcDRLtgtz0RonCNyArkLuFl+5pEMParlwlccTagUKBjoKAXUC/Y0UNNtkg +CgUKNMYytb5tcqeUDeuOBzez0BZcKzpwyY7UODDGSuR6lIx3w2rJimw3fpRg5XGyem/xdpNZrWJr +u+rdUh5rBwoFyl4BIyP0divDSmf1lpEAgSlzhVbX0jrlUe4YcCsDDS8HsdJuUc5Ze2jAE356uYj4 +rkK//xyvTckOpHzNs8Z8rCXe377GDc4OnN1qNihKcHfBzKzmGF3x7F6vIGNrtVxebWld8ji3vb+Z +ibZgQrIqoSSWH3bgJoEcvEwrdjFR9B6pXFJzQGUtFa8Y2xbdzj1WD7SiHw6MfJBjZB0rZiNojVyj +QIHKXaHWt7V+eaw7HtzKSMN7buxoFCV+P+zARkMPm9v9QwvWrYgOKKzZNCtc8dSj8yB6sU34pl6V +RWzkRcPEenWVvVWBxk8J1ru21hOPcNfrW9hmeBFc1EI2c1HbbAC7vatGLU/T5EZE7FdQK87KS9JG +3TRQZG0LVtXbYvVAokCZKmCnsnWsc79FolOgQOWsUOvbWr881h0Pbmab4Qa6Js1oraYaGDjM/Yo2 +IFhKM82W44GXTaEM60BlLwz6vm3lW0M9VgMqBYqgg/0tWIwVdx85T9opUKCxt+za+u4a1h0PbmWi +kTBSVzGlHDyMYFwpurFjbcXVmJN06lBdqw5U5sDG3nZtl6blhpxqIUCloA+PgsV87khJSNq1YUKA +ApW5Qqxv63urSHccuO2ZumGUMSXzYQdtcssNXcBm3qucdBfp3gUCKn9Cq+uuba/PYlg9sKbO3w6l +orgD0nFKd/cCAY3B5lNzE7V3y7BuOfChM3W3LMjyIVPw9//L6rPMBaZtrtsTdh5slVTmkjTm2Wuu +zAU1FdYSXX0W2LPwUt2xPsu8rK6Kh2J1QGcuOnCvpOKw9porjgJfn8VR69tavxzWPQ9uZDrOS8Uz +aKraa30WB5ZiKtixKrlNVnMFO6YReFefBTu2xE3LRatIK8IO0Td/O41gq6NiCHu9FfdqX5vFkena +uk52nPue36yQ54KnddQattosDtyrqMBuj/fWS36p1FvBztVZS4pYbRZkg9zK7dtmvQ== + + + odJjNaBSwAg62KqoOKy93oqjwNdmcdS6tq67HeueB7cq5LmgSmrHy7Q2iwP3KipIb5m1rK/UW8G+ +ySWsvjYL8iGum5Y+TmQ4e/TKVWbxYKuhYjh7rRX3dl+XxVHq2rqudpz7/t+sjmdBDVPzZLQui4da +BRUENr5xsNdamQteTFCaAypnNYfStc1SZ33A2oG9LouD9goqDmmvteII8HVZHLG+rXXLY91y4FZ1 +PAsOUFU9Qp1IHmwVVHCKyC1CvdYKdk0rjLq6LMiGOW5aJldvz3B6p5lVZXHgYPVTDGevs+Le7muy +OEp9W+uTx7nr/y1qeOL7ZzX8rSaLB1v1FASuFpyUOivYL82odjVZEKzWiWsLgnLRCnqGtQNdTRYH +DlY9xWHtZr6jwHsDHLW+rfXLY93x4GY1PHEX6Eaa1mTxYKsIQTMk66yTOisI1APGriYLgtd10zK5 +QsiGM/miyVqRxYGD1U4xnMFqrLi3K1DfLpT6tsHZroZz1/9bVfBE0qykrdVjGcFSOQWBIMd96RUB +1uaLtGjfiqWru7altrbD2oFWj2UES+UUhzVYjRVHgQIVgVA7tu39clg3PLhtEU+cJlVrrFg9lhEs +xVOQFr75gBbRrDJvDRq90Hos1L+4bdfLrjqEHWjVWEaw1E3pKIfVpO92tVg8meMqqf2qj7LsgP9b +1GKZMUxhS7hbig5sVVPmJVoZ8n7jwDJbUW1/OwFe7jXnZWybV7sauWN1QG8pdnCvmuKw9voqjgJf +i8VR69smJ4UV654HX57/iUj5/g+KrWktFg+2qilIar/hQeqrYLc6B60Wy0z3sWl9TW0LzFqaGvaK +1QFdLRYHtrIpDmmvr+II8LVYHLG+rXWrI91z4HbGIuagqnfBarF4sJZNQXKDnGW2+iozXbgXogMy +azDsHDdtgTehXyXBSB3M1WJx4F41xSHt9VUcAb4WiyPWt7VeOax7DtzMVEz+qpVSjbUKtaopSC78 +wZdd4a7p/dCuFguyQeu89ba4npNGdRSrA/ZaLA7aT986pL2+iiPA12JxxPq21i2HdceBm9mKC+ZV +aNzFarF4sFVNmfFmyVzGWizYt7bouUmrxYJ8AH0pj20BqBfGd6wO6GqxOHCvmuKw9voqjgJfi8VR +69tavxzWPQ9uZS4ueDvkogmDWovFgYNVTUF6q5w1tfoqCJzXsK3Fgl1WC6K3xam36ixVrB04u1os +HqxlUxzSXl/FEeBrsThifdve2450x4FbGIwolVYrN6i1WBw4WNUUJHVNmjUk9VUQGGr1RVeUryWr +98faAm3NgpiK1YBKgSLoYKma4rD2+iqOAl+LxVHr2/ruGtYdD25mMOLoWu1Xq8XiwKFfFrjQBDQH +rE1bGMLogModuoh4bItlWTSb1LAacHa1WEZwitZWsM5yDc9AgQKVvULt2LZ317DueHAroxFpmM3Q +sLnroW2JKhOWmKw0thKWYz+Q0BdkChoo7y1j0snoUHbgYvPWQ2NYdIoKTiuE4N4uMP240Dm07B1y +KMe+3yoRlIiNdr9FMS3Bg6PusQHPXIzFd6gPqRUHtBmzaB6na7sudmK3Y+3AcUUbWIqmjFi5uspI +gNZhGWntLXunHMoNA/7NzvDNeBYo68mKbsM5sFVMmTMemlZTQ2qrwAjj9bseSMxIq55n9G3xKj/V +4xSrA3obroOddtWx9toqjgJfh8VR69r2fnlNcMeDG9hweIJNbtPrdVg81CqmEKWzBnn0useEh3zD +6oDMlopSLG7aFr0P1GF1wF6HxUH7+u84e20V935fh8XR6tr2XnWku/7fzIDLeP4z6d6kdVg82Cqm +zBkLVM6i3EqSO3atJLtZTuuwIBt6hNvarrY/dqwO6OqwOHCvmOKw9toqjgJfh8VR69r2fjmsex7c +yoTLeBRMK0pEydL3UC2ZgtRqlqrVVsGerUkjP1aHBbmg6ppru7rq6ILUwXodFgedrWKKw9lrq7j3 ++zosjlbXtnfKYd31/2YGXEYzVVUEq8PiwVYxBelds2q9UlsF+6a3xbk6LMiHlnRsrC10s+lRKcXq +gK4OiwPPVjHFYe21VRwFvg6Lo9a17f1yWPc8uJUBl4NVBep1WEaoFE1BckuJevvGrLxtWW0PrcOC +UApNDC2r5bx0lAPQlOAOna1iisPZa6u41/s6LI5S17b3yWHddf8WxhsJe80EtDosDhysYgqSuqzq +MdBbGjOuDq0cZHVYaG+J6rPQtgnvbLO7EAVrByoFiqCD5fytw9prqzgKfB0WR61v67urWPc8uJnx +hsumaNKg1WEZwdDLKv3oxfglbRiBQWrgzT3FmFZp0FiotqX93FL4os1Fr8gurY+PgcWy7UjRHhD3 +YidAgcpdvbtgaNu7JUj3HLiV6YYDHFX6WBUWB0bWhFWFrV47hToH1aFEYFz0DEbURETq8Wxp9tIW +V69dDqpYO3B2VVhGMJ3tGLCSrDSGCQUKNObOeuLMte3ddVg3PLiZDZep81als/ap28FSLwWBWjyx +9d1htoLibdxJUmv7tr2clcPagVaFZQRzzZQRabUx7+/XKiwjqb1l71PHuOn+v50Fl2Y88+mzJR82 +YKuXArIAFrFWx5TKKnOsLjTXb2iPxVRn13YBFpSywdqB3oLr4NnqpTisvbKKo8BXYXHUura9Xw7r +ngc3sODSbNX1XRUWD7Z6KUjqusyWTcZuBuhWXpoHcrdWvF192xYv8tbSZIa1A10VFgeetWCKQ9or +qzgCfBUWR6xr27vVke45cDMjLvUIpavC4sFaMAXJLf1uD66sgl1bcksOqLzNQe+wt7Z4XEdDe4q0 +w1wVFgeerV6KQ9orqzgCfBUWR6xr23vlsO45cCsTLqHmoTf2qnnsgFYyhaiVWKTWVsGOlaSlS83I +AB7IJb6uJV4+rdFNQ9mBVoXFAZ1m1VH2yiru7b4KiyPUte1d8lrgpvM3M98SpuLqDRZWhcWDrV4K +krssGvWRyirYtX6VoFVhQTbINfG+7YqxmnWDtQNdFRYHnrVgikPaK6s4AnwVFkesa9u71ZHuOXAr +4y2hnmq3PGgVlhEs4XOgtpvLyfaPavep2QW8AA1LqmPLFV+8jhg9zElJA89WL8Xh7JVV3Ot9FRZH +qWvbu+Sw7rt/C+sNt0+5zcJVYXHgYPVSiNag9aH1WuSIWZfVl1tRvvbjvtZ2tYxfh9WASoHNeANL +vRSHtVdWcRT4KiyOWt/Wd9ew7nhwM+stdh+eq8IygldJfQZgWvROscJHE6lzTeMFRY8xkgTM67Jr +CwpM3WD1QCvF4sDkClgVQbEcTLUaOgUKVPYKtb5td5o6rDse3Mp+wyHOallaMRYHRiqqCltRxskX +mpTcXpePgMqb2mzT1baYuWnmmyA1mL5fP9/BoOnY+m92+3hdw0iAApW33XJwbXtnDeuOAzez3pCI +rGWtrRTLCJazsgQMPVbGkeDYXETbSrEQOOvZO992VuvLYe1AK8UygqWSwIi1ld37W5e3nVJr13vk +8G16/29bigUaqrtlsOAcWIuogEEM4z+UWZnDauexrRzLHArsI0PZljksmqDq0HWYt9w6eLZiKg6l +1Vxx73bVWRyRrqV3KRnKXcdvdcwu4OW3UfMXtUKLB1stFSQ3N82Lkqor1DOpGeAqtCAT9Ey+a4sn +/VXbM6wd6Cq0OPBstVQc1l51xVHgK7Q4an1b65fHuuPBzay30Jy32Sq0eLDVUiGCLRdNjlFj53LR +AjhWoQUZkVe1mK3tghpm2GDtQFehxYFnK6fisFrdFUeAq9DiaHUtm3O3G8odA25lvIW2KZHysIFa +NRWkVvxave4KdqxLDavRgjwoq54ZtLbLvu6LB85uTS/7eioOaa+84gjwVVocsb5t21d+2XPgZiZc +wFRlPYVuVVpGsNRTIXp7CX4JDoZuKrgqLciHumqFU2tbnFpiWD3QqrQ48Gz1VBzWXnnFUeCrtDhq +fVvrl8e648GtjDjAXO2wlFVpGcFGQw+q61kr7FnTydjPZQG4b1vWFovlqhpn3OogK9XiwLNVVnE4 +Z6vB4t4/u3otjlbf1vrkse76fwsrDrCCjrGt1zKC3U4WlzrWa8F+abk2V68FwXHd1GuhKYfrZsTq +gVavxYGdXtexzlaDxVEwu3otjlrf1vrlse54cDMrDnWVWf0cVq/FgYNVViGCgyZQai4IdK5mvZTC +6rXQ/mIJlK6t3hHvsBpwdvVaRrBWRuhYZ6vB4iiYXb0WR61v67trWHc8uJUVR2LJUiW1XosDh7lv +8/VZkKi81WDBvjVLobR6LbRWq94x5drmqnWFvKJRtapQz5kYwFxa5f9n712XIzeOddEn4Dv0H0XY +KxZo1AV1WfolUra3z6Eth2XvrYgTOyYoDkfiFi+zORzbWk9/8susKhSAJgn0DMluTkshsZFA3bOy +8l5VpW3JwVJ1oK3ytVSdrb+tR5srnczA5425G6xyztcyhKbMKtznXs8lOVh4fEUFUPK1ME4V7rX6 +lgQAN6q1BhYz6QCaMqtUlQ5RutKCqEqG6OPCK0Tth1VqHc/AVuZrqcLwPnXVx+Kjxy1IWYhjXLwa +gZXoDwCEt4PPuSdSPFDwxVMwAXkJIp2SqjWDb+kZuTv0oNYamHpwfCDg/uBg8MkI3Od8icS465Cs +jekakWHHGMgdCzRRMXcsf+tB/LPHaq61AlYdWzNjJ4Qz6EWA5EMvFA2egwyv8kywQKsi7gUlAnzC +YJdCMxSXE5mWgJp9oVCFc2IAigYJ47he8AuZxkeYLUW0UEhTH9Ogs5M8RicMR0CWFp1yvMAILROh +sTdLViTxqfDM62U3RiOqQo/9KAnvkN0rx4V74uq1sNpeKL8AXSd5nWKRt7wraWLS1jtOFaQLCnAJ +NRWTmfG4xEsWLhSGmDqmXHamYmUhhmCLh5OT5JoyMl/uVjRFmUvTRZPPQNzpLjNDU6s5cBdT20dw +xi7ZmbEMWc+GFTHyLRIAyXxP1/xYkIHGppltwfKWYDYamlhWAO2M7CD6VHEKSnQitiJI0Zy3SRDS +GE2e894Kg1xgVtaX1j8W/0RZyGBLZKeqONrYligZjyBJm7ZPJ9pGXFfthDTTIDvt00LSSZ2wn4bZ +BZXWzMKhNGNz6zgxoaQGoSUgfikIymQtcDDwLy6hfK7fkVHbnGI2ymz7PqdRdyi3BQGNnBaZRlcR +vzSp8BiWlc3JAAjIGiCZ6RRRielXeXtxLM3x2rU64UMgFnL81Td/Cm9+f/326Pbjh5+JmN+d314D +2AH45i83138lin9HRL9pBHx0/tPFdf3i4C/v8Ua18ur7//nHP1xcUjUHvys/6Yz53Q9/PvnLzdtz +/BwcPve++Hr1m39fXV7Tq4a6dXvx48e78w84Zuj8uj0dfXH288Xl29vza7zXq9/96fquf4f/3aUj +6jeqbb+ig+wf1xdnBM7nWf3pP08vP8q3P59f/PTz3cNfX59e8cfUl/z5f27zmP518Q== + + + 9u7n2UNKXz/7iOaP59+zx/LvrR7Hr7PH8esLjOPmx/9zfnZ3dPPx+i117ejmkVnvh/WO9z99evdh +9gAHZZ59qN/86c03l+9/Pn2j5o7x4m3FGd8zJnzznzN6vC1k8u7j7Y8fib8/O587C1J05hLndp55 +VHruYK4/Xn13dnf6z/P5WFsXefaBXd98f3dxd/YIYe/H94G//vvF5YIBDso8PyU9bLu5o/vx9MP5 +H27P/+9Hwt/5dHVU6tlHiC03d4S35x8+Xs7nTPLncyjQPV1XD3R9PfWrDoHzv9fk5OHOPjDvz7wg +F9dzl+Pm/fnt6d3N7ewF6QtsNZpdXD9CMesTDt8++2i+v/l4e3b+x9vT9z9fnM0f1oJRveCuOb65 +en/z4eJuzqZ5ig4wH/Zo27/79vzd6uu9tLeNY9pLe9s5jr20t23Snv2Spb13t6ckulz+5ebiw6uS +92Yv6l7e2z55b7b+ZS/ujYa2F/f24t5e3NuLe1+euGdfobi3YEy7Ie41+rUIfEtGst0iH8lBR+f/ +PL/8/ufTtzf/+rJtX3LIsFj4ZEfMMw/px8uPj3Arn4HZ3Fbh7sPd22/P/3lxig4tkH7qQi/GE/zx +9OOHDxen10eygLvCS89em7fzyeLbl6CL8wcy/6R6+xJH1RIKsO3U7Obduw/nd0fPQdNeaNt/xyPc +oQ1/Ce4YXoJnN5c3t//1r59FjJlJn3+9nK9KTF/vN9AnjOXD+/Oz7z4+sh92jyNQ7WyUown4eHl6 ++/t/v7+5Pr+eP7Zpwecf5dJBHt9cf7g73WCQfcFnH+RsX58PH2/fnZ6df392uoSGDArtkmzSdG07 +G8u3XHhW7YKxbLf43OglY/nv2WP57xfkQf56c3F9d5KUZC+hjzz/PtGhk8Rc7BA/9DqNCRtpRrbd +prCQGdrzdi8qGS0xkmwLMTi9vbj7+er8br7JapeIwmx+9Jf5lOCXlyAE8wdi5g/EvMBAZjMivzwy +5HogaqsH8oierh6I3X6ivP2H5vMY4p9diXX319OLxwTlL/zs3B1ZebmaeFc8Rf58fvvTOWZyh5ig +pZvrNa7F03Vg7zK0KdP3Gl2G1KtzGepmD2jLlZ4L0G27VZ5fVpDI8c3N5dHt+fl/z7ZqvkbPqLcX +l6fz7bo7pcQ4nJ0b4Pb07cXH+aibP98NZe12C2jzB/J2/kDebvNAdk3E/PPN7fufby5vfvp1h0ST +PVnbIbL2aojZ/LCcLSdmrzaMbSeJWfNqfG8XxK1t+U5fFk6xzVt99kh2ba/vnMfta43Zn+35t4/Z +nw7wpWP2Z3Obuxmzv4CQb/uRNHultv5Imi/h7NiRtJNZFB5xjanI2zKP7eyqvbXYtf0+G6+Ies3G +sq2nXrNHsitBON/MNm8d/3x6fX1++f355fnZEn3atOCzD/Jvs62Rmw5yWvDFzqFvLz68vzw9O786 +v7778+n7HTqMrk6pqtmGyV2QjtpV/nc1+akGP+eOmn/NlzDy51tMKbf+9FqWa3CbT6/ZI9k13vsY +Ycx/zuRjV+jdAsza9j0yWw209Xtk9kh2hcObH4D8PIlXtmX3vVvkH/Tu4vJyif/T5Qus9GzUvbuZ +zzjdvMBATi//dfrrI0zOYCPend4u2ony/fOzg7PH9CPu5pqvaJWvnx/hZo/n7WNe/bX18uNWx8W9 +u725mk8J+OPnD2CaTcr7cZXm/8LdnznAUakXCAK6Pj+dHTFydnp59uebt/OH1xd4AQPU9ezT6fTs +7OPVx8fdouqFq4o8+9huz1lFMXt4b99e3F38c8HgSoEXEklOry+uTl8sNeyu5qFrwt4ZZssku7NX +4wwzfyS7pv3YO8Nsibp3fkazvTfMOlXC/sbC7SCAW38ovRp3mPkj2bVDaSfdYWbzn7vhDrNgn2y9 +O8wrol6vxh1m/kh2xViyd4fZu8Nsy2H0BbjDqC/FHWYBzd/20+vVuMPMH8mu8d676Q6zALO2fY+8 +GneY+SPZFQ5v29xhttr+szvePAu23FLi8UJruItZAxf4Ae5X4clW4elybuzAIjxdB16o8d1P2vjN +n958yzl73izTfM1iiHbniHq9eYvmqwF3JGvRq764elGenD1Fe5iiuT1Fe40Ubfay7inanqK9Eor2 ++1sCfNks2jmm4DXSsz2HtqdnXyY9+6IZtFdLz/b82Z6efWn0rDbqvFlmhX9lZG324L8gG95+28zZ +Nv5L3jazB7/fNl/4tvmybgv668W/zy//enn665tlwY7b6LDTtatutvekzPzfFjhQViV2ifLdnl/d +PBY+vlu5XvYpUnYjRYqaP6AdyJGyUl/rdqU6+n+7ov++pt/092t6sXptLtszieOuJ1D58B4pVOaO +cZ9A5ctLoPLMQ7u4fnv+7uL6Yr5hmSbj/PTu2wXksyqx9QlitoWHeoUXFP645LLxLffUXzKWXfHV +3ysstpccPLa3d9OutKEZZtuD5xcRui0n2mc3V+9vPhB78N3HR0jYLgfwpTHuEEE4vb24+/nq/G7+ +vtklwjBbM/jLfFrwy0uQgvkDecRnqB6IeYGBzNZy/vLIkOuBqK0eyCN2z3og9sUOz4USwrYfnZsc +N7t0hL7arIif5QzdHRPHRmu6Mw5E+wDAvTl598zJy9IUbqNWaW9OXjcre3Py3py8Nyd/HuICg7Ju +v15EaPYm5K0yIe/v4FjtTch7E/Jzi0V7E/LNy6tS9ibkvQl5b0LeWyXfXrx793H+bSbbTgoWDmdX +qMHs9HQfPt6+I+bo+2Vp/geFtteylxb3+OaaxPLr+cs2KffsQ/z1/PLy5l9zx3l58dPPd/S+OUM+ +3NnDHBfb3oWUfbQMSQdl9kq3vdJtr3R7dD++pntuhYR+/dPt+fn118SBnX9N0vLFTzdf//Pi5vL8 +7uvb87df39yeXv80e6vtijZuyXGwV8ntVXLPP7a9Sm6vknvusy3Mtrqc/vfF1ce7R66ArLEtf//s +yOZmj+n8kh4WqXyqEi+m7/n2ggWwExxoL+UR860IgyfpUN0hlH9NaqcP78/P6LS6fQ5f+Gfnumcr +a9Ik/P7f74k5WKDQmBZ8AYP+0lEuVttMC27zWu6g4o1EpmdXSe31Nnu9zece115vs8V6m6SlEb1N +UuKw+mavt9nrbfZ6m73eZq+32ettdlxvc5kUGq/ChWKvhHp6JdT3SbTdQS3Ua86f8cpCgDdQsu31 +hq8j/nefQ+NFEh1seQ6N+QPZ8hwa85OB7HNobKXj7fYfns9zscmzCyp3fz29eMwGsz8792fnPv/U +xgPZ8rNzn39q287OjeS0bT8/lx41u3J07vNOfdrcb8uxu3g99zmnlnTghRrf55zarZxT3/98+vbm +X09xf9HuUKIvPLvArvh1zk6Kto/If/YtNPtizbe/zneX+vUFkGz+QB45F+qB/HvLKcC2U7Obd+8+ +nN9hS9yev11Ep3dNBviOR/plCACbr+prlAS2ZVVe933ie9Fsl0UzZdqv5qLkz+eP+4RVaJk/f361 +tp0/pn9dvF3gjpe+fvYRNaqbPaL5TNRL8FBLRjKfr30JtvaLVGo8QRbt3eGu9kqNnVBquL1SY2tZ +4fBalBrzB7JXauyA+LtXamzvsbtXamwjJd8rNfZKjW1Vanxhotnd6QJHy9comL27PT27O738y83F +fG9tKTxzjXNLW5uQ5vrj1Xc0Bf9ckEOgLvICEejf313cnT2ieatFNXz994vLBQMclHl+T87D2Xl2 +fjz9cP6H2/P/+/H8+my+2DMq9ewDPHs6L7PnHskyrdYWxznPH8kTCjzbciq8vmRH7eHsKzTubuYf +bjcvMJTXmrfpNaU5WnCEvbu9uZq/e/jj59d0zT9m96mLHhzePnXREx1Y+9RFX0jqoidRGv394+2P +Hy+Juu2SHnGfe2Vnwt8WyEk7ouddEh+2V7WuV1G9Qv+xBWPaDf+x+ePZbu+x+ePY+45tj4Gi50ve +PJJH4HWbKe5q/uzVGClme8LsbRTTAb60jaJ95UYKbLktUInvxb29uLdz4t6SvbMX+PYC33S4e4Fv +L/DtBb4vWuCbzV++RoHvtfqlzc7osBf5tk/km714e4lvNLS9xLeX+PYS317iW9SBVyDxda9Q4lsw +pt2Q+Br1WmS+JSPZS33bI/X9r5ubtz/dns4/71+jyPcqr1hYFCO+5SESrzHjxWyRbp/x4tkJwj6N +50MD2We8+EQOI+eBeBW0eZ+/Y2vJ2LtL4u7k1u//+vHy9OyXr1cCunl/enZx9+t/LVAsfrj79XK+ +jjt9/fzezktuON/2nbVoMLu2mf4ARNyhvfQ6NaKfkqZn2xWjy2jBlvMMHziV4/FrIm9fDuOwi7cB +viaGe+mdoFu+cRYOZ1cUIrO9Tj58vH13enb+/dnpEo50UOj5bRezBXFZ3OOb6w93p4/dWldL5eNy +zz7Ef/28IFL4EjYket/MOKWrUY6Lbe86yjZahqODMrukQFdm9uY9/e+Lq48LTHPl+2dfasa1V5Nl +yM1OS3Z+SQ+LlM1ViRfjsb69YLp3kkzZL+E1QH1gGnySiNSe23sZUWn5Lba7wiLNzy2YJ+H3/35/ +c32+gI+YFtzeMzb3dTGzNC2453Z3nxXc80svzy/t2aU9uzS3D98nKryD/NLrtAa8Sv/oDdjBPYe7 +V5lvsCyntxd3P1+dL8jrvkvEYfaB+Mt8ivDLSxCE+QN5JPFNPRCzzXLSL498WQ9EbfWKPOKuUg/E +vsBAlhqatv7wfJWe0ZcXd389vXhMXbA/O/dn5/NT6i0/O+cPZMvPzvlHzv7s3FqhZvvPz6VHzf7o +fAVH5+7oofe3NG4jL/TkRGMH1uLpOrBDiPBaUxHtr8jb3VxErz777EZGkO3m2v6+OIf1rvFtO5lk +6eqUqpqdXmInCPuqTf+u+1Ugc4fMv+YTxvz5DuyvbacYf6SiHx73ONpdgsGRVH/OG3BXKMYrPJue +Nf5rW7Mv7FN8PPtWamazsdue46N5NUk+nkUR9cxj+u6LiXLdufQYr9OJb3OE235zymK2dNupA+wN +WKq/v+IEyLvojrDJuuwSrs0Oa9wVVlvNv/Z8z2w/+3Z6lXT7h3fnt3+4uN0GFcm2rPPd6Y/z13gX +FJp6NdtUxWP/n8s0loMyL5eK6+P12d92iJq8Oiw79Kt29WXg2R/3ePaCeKa+FHJ29FIuJizsIG7+ +77en1x/ezbhFYnvw/XXqQzYMYdh2VcgmHOgucNWyXFvCV+/1IWll2HPum8vLLViTbZmSzZB176u5 +pAMv1Pii65+++uZPqn3z++u35RoogDpA3vzl5vqvVAWnKWkEfHT+08V1/eLgL++5Diuvvv/16seb +y4PfHJ2+/el8pVbN6q8X17/89uAj/duuvjvoHWp++JUe/h/68X8I9K+VXf159f/973b1lqA//O2g +PWzbNoaV7g59t7o6aNRha5XrEqDR9L5TbqXtYdcZD0A0LtJ7c2ii86uzg8YcBmX1Sg== + + + 60PToow9dFZTlepQ+0BFukNnFL0gQKusRZHuMOhg6Zv2MDpF3zhqtus8A0yHZ+1diPmZivhDFbqo +yxfhUNtguVZjjVs1EUVaBYA3gXumWnzk0TWlNDWjqE8ddYEANkZLABqgjb4AUIjG4YMffOMshkwA +02kGBO+djNgoLmRoulrLjdN04jkGw/03raL1UfZQY6JVOAydjIhAVkW1Uv6wU5gEAjjTuZVyh0pb +NNShK1QIf2PkQnhHw5VvUTFKawZYFdBdtNDFFbdIhakQ90J3K+kVFZJuWgA8ht/wULRe8dBk8gjk +Y8egVnvF3+iOhk2z6nSUSoz3K574yEPCmtOa+MMYO4dqW/qERuQOnWfcYBwwdgWc0M7mMt6HFaON +yX3xdgW8Mi0KAdeAQFj51nAhxkdaAsJPLHYDfLU0aKBvq8pzyx/L76Z/mUo3ffHURFO3kfrR9B1J +XW36vqbxMJITuqfZ5kE39agxLU0/L2nqmnru0vQ2ZX7TAjT1CvAqNfUypaVs+rVMq92U5c4o0VQ4 +kfGm6REnoVbT4xbjX0w/YkhY64xV6XObK8A8cZWYDG4G88QNyzJzZ7TK3Qupw8FnbOz6jSUDNTpt +R959Tb39eIM2k13c1NuYt3pXf5WoQVPIAc++Svsh0QymK51lmBAWoTyBez4gTk1PnTL9Kt9kCtcU +Esdk0OU9IHQQeKRsQixaF0Y1mro0A1gVIKQtuyAIqhDaau4AEJnXgNonVBa871aZrKfHswNG/Rgz +ABVYzHiugMk6b43SCpN1rjJ1BZ01put7ixEZPxgRDZt2iumHjYnx/I1MDOYuAoXL3GF6g+mnlxaA +yKHOC2CZvoSMJyagGSxlp8pSEpHCavu82iCZNMQOWJYBVIjGEXi2+29cp2JCLeuF+sWQ8Q9lmK67 +HkcZjW2/yTJdT3uM22G6bgek2Rmn+h2G7RTasq+Ad7KbTN58ZjXan52cHJ2qN7F0Im10OXKpkzrT +AiUnFDYdj8zhBBlSlY6/0V1Qie7IOc2bgbdHF7gQCJjLFKzlc83z0guNk7Md694TdsYSbEomljQ0 +waOE5EYZ4SEyjneKCzE+JsIc3WpIuv2qIus1xTeJQUmYTZRZCLqVM8NbGbgBUeLWqWDmT7h7RK4H +RxM98/R649LpZXmQRMYdH2/Wy2FPy8cI2lklbRAaBjkiw0rm2soR6vxqesqOD+LxST09zMfn/Zgh +yDS7J9ljtmLMd0xZkzH3MuJuhEz7iv8Zs0hjHmrKZo05MSHOLrFqTuY0JlxEn5gu+5j4PfAYKrjC +MIKsBCx/pipMd1R5z3RJ68JwMunqap40U7dM3DL5y9QvU8ieQGYimmloprFDEixPxyNO++Tg6MeD +7Ol+9DMJIr/5xzWEhrern25P316ck1SibPwtVUNrowL+RsJzQ5+bQ+sNMKBynFero58ObHfYOiJB +ADT5oaFh0NxhYwc6WWiJCb2Org7eUfNHRyQu/MdH9M23iihUexiCNjRPgNByKBkGFpledfTSoieq +c7RULU57Tx354TSNzgsjBkGC5lkTWpoEUIeBlwMHjmGBgvBdaTlwNP2iGTKHru2inP7KgSFMR0tH +jVElLgQ5R7zXmFGayOCVcBSeBomzhiiZnCQuWCeHjemfj+mw0QZoVkDh0Kho5Agm3hCIZ2hw0jLh +fKRChJtG80lIw6CJwmljWjDo2O+gQThsTP98zGeNcbb+onOdHDUqgrzTBAD/AWiD4zLmsNNy7hFX +4IQmOBmfbh1vw8icIXYqOK5j7G3FvBBtZjrChCy0ONNot7foPtEB6rvjs0ZjIY8P8qtGPrYrKSxH +i8LO5gacMJW0X9A77gS4Wu5Wx3IWd7Phfre8+dvAXCbGhoYIwuerYoYl8hdE1uWocZrr6FrQe8x6 +p420E8GoBGzgwDvaojacNCTv8Y72HpUwShisKiMJUTQ6aoiYtCyLEgZ1OGoIpywfB4RlLL9620pD +CRMb4KZzvDMtWgbqquC7DGjxcfpZXnFhtSplUT/Op4TWPHbl6MvSA0ZktSpdZDxeVYPAQGkRqnFG +oheYB8J8mSprV9VM8Wwy6XTEWq7SbPNk21iWg1fDRJmmjFgd7eFVhVe8ohmt+kWvsErwgjHHCpbR +gcA4hSOkxy1+E1cF/RhBtaCYcQWHuS3bCdozmnNvrFqlbVA6i+5ru6r2CfaSYXxT0fFWMkae82a0 +Maz6vYjd2hYAdrNyfJAw+cgT2u930ARWPiSSAKKhI/eQkEoOGzptVj1ZYcojByZDQJoIwVeZMmGV +QWV64gXilmlbJnyJ7mUc6iljpp4ZZQtxZdpaaC8/HR8MELgT/C6lmZelBjStryAtGmgGXfBpI8km +5y7yZksKmTSCBoO0cgTzICEEaRP7eUmCkqsmquG5tLr/ZjzZQgq8rtajGS9ZM1rSZrLmzQgpmjHS +NFO8akaY14wxs5kibzPG72a8AYTualXtkWa8jZrxPmumW7EZ79ZmvJ2bwY7XUmhIE/gTUGKmGVbl +U07IimPCxXJY9G6VKXDDlMn0lKmZ0C45pn1P3Zqa/FluuaKQQoCbmoh2wjpkItuGJL1mAtzU1Dm9 +TcWbUj410dRtpH40fUdSV5u+rzKcph5PGnJTj5lnpemnJU1dU89dmt+mn+D6DMxL0B+TJqbpq85S +1fVnfjluC0pUZ3LBm6ZHnIRaTY9bCf+aGgFp6viU5c+TZkjRXk2o2CXtkWsH3IZ0xqph97qKZynb +qqn3Vdp7Tb35jEmQwQZuqh2c9nj/DaiAt4kNw8JnUlHxaoWeFIaukJxmQpcqxrAQr/6rTN8Kf8kI +4pOqIlNBYFFoK05VMK1wsUBGEyHI9/RcMFarnh0WtLYqscsjdvr44A8kIXxbc9kOynpqgVgGx4/U +rFcmq0lCx/jsYtbUakiRTLRJiDIJ1ormnaSJxACPZidBmGzjONDVV1iNLso4/XgJfSHCgoPVN15r +IQ8uJISXDSP7JNNUSCHcmHWYeIK03ou2uxUlIM0LK9z4h3NpNxA/pNPnQaUKOqkg6MSxdyrkhtPu +IxwWzSvmRPR6nrHbQ0OZNb+djTKnXvu0aQlBtMy8ZT1GJ7wr1iXYHpAJGH7371LxvnRqo24idaTv +R+pq6WkaTj2aNOYy5DwtZVby3NVTh3eiE0jzi9IdH4ZpCUzh4cs6pdXkxdSy+Xm9xyhRYUTCmvxF +xqsJ8lW4xxjqTf9NxuGMwhnPKzTHpHaB65W9gGknAXqlXcUvMdvdvxgXQr2QePt6qeWgkpKgZeWm +7/rOixJCV30Xhb8SCBHV0fAn8zOawMEEq7TKgzUYL9N4HadLPcaGMbpMMWqEc4yToaDkFGt5+mjQ +GbFHiF/tifF+ySXLjuLKXai3XWq+bM3h5vWr4QbX0p8hEZjQCZ4d72pikidSdo/RqzzThShx/XZA +uXi90qEvC4b1NKYQQNFK+4pGAiOc7r8AxviuIr5Fh1GQirGOT5YEyliZaXrG24ruZ9Quh0NG+6be +EA3viMHjycG7g//4x8E/WFn1w9sDt/rNb1c//K8p4Ks3avXNe/rT0kH11Zuyylf9w3iZB6tcodAZ +ioywbISDIyTlEiNEHiP6eCugzGS7jLfTaMNxGXQhSI+C4x6yBhwd9hOagRJjunIPLcKnNZ2aErEx +oeMSow40o/5NCDcXmpL3yQGwZrqmR8nksFm3MtNTa3KsrcGANQfk+ATNOCafTw7f6fk8PsWl4PS0 +nzAEY64hd3DEXUw5kAmfkqd/zM9MeZ4xZyQlZXWbsrx5+Zu8/hOuj8tNucOaeRxsed5MFXmY0I4J +fUEJ9KNIU9QPdFSlfjo3pZZp+41o6oTqjikzFxvP8mQhxocAD2l8UIwPkvFZk4jK6EQaH1k1Dl5D +j//NNWK/iCLCE4coItxxWIaBNo/kFG/pRL8Skdmg84ddEAN+hN8A/B6cgWkDAAOc6IjMq2RFJ1kM +5hJ36EmqDfwNFQlQPnSys1RrOxLnY2tN8kZQuoWaK9rOiOimYFqLUC+2ImoqSFF0FEECSeIhG01E +M0YyDsnCFmKJh8TKmgARGzGsEIwYdFpYDmimuhYLDAMUbA1U2rgILXM8tIqfo4JhkA4/GmDoGGex +qxQ+EfV8xzIylzFaSJ/yHftX5CloMAcd9H80BZjIJs8CT4JjwTzNAgxZLMrRGDstKioMiZGhwwYE +oBPNEg/oWMoE4Wp123HnxLzA1i0DLVAHCZfZXs8mIRKnoyAipD4tClL5IsLqDSnbJi2Rsq0T0xlr +2lg8D5gDFDXijxF5U6B6eEBwg7zduAcs01OfSBbGNypqsUtbg9knTsO0Is4SfosatLPJjYGEWMM6 +IK8FaZjrjMRHdF4qaWPn2eqWyAY15ID/nlYXEwiAyspQVglkADsBRFEhJBDtXZ2/0fCkAUa3ziUU +14bdDRx7xPAuwMaisWarv+AGbR2V6KFOFn1C7S6JnNQOENSgZSHh3sFDpyJt5jB6EXfwnXJMrfJ3 +qMsmzRWjXlM3aFot3jbUKxuFPWNxHd3mOcv9BqaSMKTrsTWTCYAME5Xrp6hZM48NDLRtqly+ovXQ +rFXAevDejLwb0r5uk2dZC/OmLHUiJUQhu7T2rUl4Hk0i16BIIs/J2UKlTHa0kdZZuy2I7geY2AzR +1YWE7EZYCB2TVUmUQ/hhpYvA9qDS18mfqNo71uZWpFlQKhSjrsTUNRdl1NYGgagQk4GwS5uupeM+ +y9ECo0WFOZXHyMpwUATRCybSyVRDG5uag3WqkNcB7cn0l2l0UxPpRMibQskzrW8Ksc8HQpNPBPEA +Y28pxsWMw5aVQyYTb+AwEZA26S34ffU61YAKXHKaGpw7Z7A7rzM2+9+iGQXCoGE+dv5QQ2en2JfF +TI3N8CpwfDJaiCxwinOENlEQ36ogpmdCa9pXKzrmCYVp8/1wBQnUsFbI0okbsPTrSjoDPwe/CvQt +4S7tzKOzTRs9mtuoAY2khQ5aW9beUZvJUP4POt9/983t3cBnHNKOeBDDvXd1Bp/9j9dvVx9+Pn1/ +vrpix+j/pK++pv8O9NAndyQ9rWERhMVczCSAS1zKJggbvJRREE52MavAMtRiZoFKbcIuULENGAYW +QBezDKnUQqaBericbaBCmzAOXGwx68ALtpx5+OrNRuzDV282YiAgZy9nIWhoGzIRhPybshEs52/C +SFDBzVgJ1hNsxExgj2/ETqDgBgyFFNuApUDBjZgKFNyIrUi6gw0YC2lyOWsh5TZhLuSAWcJeiN5m +OYMBMfhTj8okRq9otlxSN66tkj+O+QwtITYSHHNvuAxN6eq729Prn86XB8zQgUQIb9inQRN15ZgZ +nIvQ01lxhDph46V1HXtW0cpFBgVMJnvZ8N8TNljx2/z1iQQ2YK/nOk/E8A8TtLTMdWlHR5BDPoDy +nqMSpGu5mlac3nM9ubWmai53pql7lV43dedTNaV/J3kmBMG5gyc0RaVrJwe5O6WDJw== + + + B8NqWnRh2Boqlq7kLgEw7fia8a2Zhnqa8uvqbaqjryJ1oW8mdYH/dLHqrXSpHlI/MXle+mlpihdl +PzsTRJrlEqoDXELbSDwGnDS1Z2f6doVdqKGtHbPpJsJ1VwBNfiBOt4N1vzPwCYXD/dQjlM5t4oRa +WO7BoLVEGBS8hql1RSwbXgXrwdm18OELgZ1GiVGkkcMhlDEBpmXaIUSq5LTmg6AFlolzgZwFfHxh +3ohVEEUmk9yTAyKYAY7XQBf2guUFUGyCB0PPjrRQ5zEZI1of6JwSkGfmBOQfOk5eSeKg5KThHyes +rPFOFIKeDgcBBcfq2FQp4wQxFcL2ccuMONybJvePsUuOiTSIkwMel+aDXUbKH/HomzwfjKE8R231 +un+b6xhUwe2UZnJf+q7IxHSrvr88Kh1W1aDSvFQj52lZ8Z/QVXOYZ6mf6DxJ/WLIHFULxr3itlNH ++zVl5xXLTHha9zzeHjnaVZ6Xk4Nm8DpBZDq4CtvJZirNQHogyKArjDrNpLvNdEjNdNwFZXrUafLb +fgKbXEc/y03GnX4pBJMJSfv1aiZr2kzXvZkiR1PjTrMGt5o1KNhMEbVZg87NGqxv1myOZs0eatZs +tWa4I1P3Bhu3zH61vX29kE2PVM2UVDQZryqC0qyhOxVdOsleNQTyOMctHIY6+byL0aWDL4nMJInC +U0E66XjMXqwWMtUyh/mHzGGy5Mj3MtXRMqOZqpUV4cZK84D1Rzu/q1+lflQ15Ib6dnIv6t7Iy7rP +qYbcqZN+BuAD1fIc0laUs7y8SDNTl5Z5mbQw6IVQIrzTse9pbrsfzXTIuhzg43laM53TSV+zNIMF +1LEaTdNPxhpsEEzp/25oGvfZLD4ZKsEmE8L2ruGssSpkNLUsow/nn0CTRfrqzXQp0TEeD7H8UwwQ +AXCEKWKJHDe3Bu/EaDxET0gWEywWYWoyH3krVK+b4fspDlRtNnWjazChH0czHMh021eT0wznrkmT +t/b1GswqS1UhYL+kg96tG8faEa+dnDJ315VE1YWpddIcQinTsjATU3AAgnpjPgw4SNmQxKpanWg8 +O4d2iAtshY4pMezSG6VVkW8UH3ZiUZUDw2uNoHHRxZ3AY1N0gBqo7HEOwk2VdYmW9TBFYYHoJcRS +nDFnxEKsT8pJVl6JUgPw4owJ5hY/2A2I+9egg1CiCb+P/jV9BxXCpiCsQ8npWJiD6Vni87Votph/ +EqM7fiA64+Qgv2RLNQK9mKi0jgOxU6VgkBxr9MrUnBzk7sgEevQLs8oa1zzNYJI6q6ME+vBiEPWD +aj4psHnJhDBhLUVowwesneo/gMLVxNbV9TR5EavmmjW9KrNUdb5MUzXGZs1UlImqZqy8lgImw8bz +L82B8ajwaLCaboiUTZ6/CnebGnljdrLucbxsgZOHLSQ6GGMDW0gUMSFURLHDs5qKXnBTVtAJGmjQ +oTm2cLLm8FawMiAKJIjRQDTNR9Au+bH/cIWDjTrruIQXvfqaor47jFDYBtOSWAn15NHZxq0ezW1V +R/GGDhpNIWC0NpI8ZuToKU3SgQ1pjZDuEbURg8aI3ohxZERxpPiI5gA4oToE3ITuMJleSnnYjWRM +e5i2j6kPAaf4z8AxBWKjwZgGsXZ/vPX4CBrToa/erKFE0NdPdj208RNqBF37hB7Ba2hCkeR8LDSJ +Nd8TqsT+SRO6xMruCWXihVvTy3XUSQ7yMX0SDfN0mtbRKFEqj6mUQKfrtI5SVXha0aoKpStqVWF/ +M0T/KcWqN9PkiI+fX2lKeLr64+35+fUnJRkKOcsQMSm2QBDuHzg4yB66jgffGssJAjj2U5IMxWAk +grxNhkZlO/YKNyGIT5+D5QVesUYKUe1dqyW0PyA7AUl+nUvBmK7KMsSPkmTIIdNKek9bWFlx5iQu +jHeqNkrxJieKYHKOISWB7FqMFgofidO2tsMcQww4S4ERo29c1ByexpSGLRgp/NwSNqcMKiF1Pngn +qSIUe3bC6Bgl5sfQPxyfJh5sAHVs1PNUcStJhjwSYyAbQDCyBayDZRJ/g8lJhoL4PMs5wKUlVUBn +Qsp24cVh1hidHc1M17IPn+J4I+mnX0m/2VRAGM3JABDKnjweIncYJseUdwNZU2BxUkocQ0PH4Wna +wBNTEt4YLBrRXxetWGYCrEQOYbDJT1EhnJkxoiQmQr8ZaZJDp0U+AKCV12LAs0g4AMzTJqQcQw7e +okBOnWJxgmfbR9sGU55zjqHgxbaSXqbSTV88NdHUbaR+NH1HpKdN39U0GkbwrtVprnnITT1mnpWm +n5Y0dU09d2l+m36C0wo01RLwKjX1MqWVbMpSprVuymJnhGgqjMhY0/RokxCr6TErYZ/8CDrhrO9U +ykgUkqNnZ3xIiKgzquOwloYzrqs2JQRIkYHor1lVA+BtpdMw077ivSd5B8rmo+0pTvnDPdzUm5g3 ++uArpgXJKsbxbUwwdF6NzqYMQ8oa6RWRFbtKZCeZ8lydYCgTpky48heZsjWFtAE7TPQJXzot6YW8 +MjmVToiCZS5F51kkWGJcVFYl7HQxpRci5jImHO4k/UrkDE2JYNf5hUJKMERTH1SBoA7JDZTqQEMc +INs3xDQ9599Bb9BfJlKpv4zxMe8BpukYuE4pzHjgjtktl2emzy+Upg5zK0l+GIDJd7FMvmbKYnNy +B7aV8yr6soqs0DUpVYPDvq1zCznZyBLoEQffuJj9nTtrhOrlqRfMk90UK0oJBDarmpQa2ZyM5EqS +uRA9DwOS7Dv+JhNtbKQ42FGyj/KuS4dBvzEloNlbW+9e6UM+ZVRIx06XN5WkbimUwjCdHVITyZDH +2Mn0ZpU3gWwLNr5jpT2aAd0KEmAemAlj0ua9nOcune8xlwlAC6aRSg5JznEhVDSuMo4JqWXOXfDQ +JnosntwVxQ6rippXhF4RGRFSHgSntU9sSRCUboOM27bsKk/tO1+YEu6gkfgveKzLGJRMb3C0x3iU +lmeX8yryNHRpqiznwTEtkzeZSzkaW57aCBLDMy3JCEen6+j8HZ/P0yN8fMqP2YAhp6AFGwfMxJjb +mDIkY55lzNRM+Z5MnjN1zsQ5U90pezXmwMYsmmCfSeioJbmQspIDiokC24FtZgxLcqFEUpjktCE9 +M0USvpMJEhOtlNBA6HAma4mqZbKXqV6mjD1hzMQz085MXEfUNz0ejxnsOZbkGESdYbVnD5COkM5x +6iD4ccV12YU0EmMlS3J+gBaCpBtIl0F3JI8Eor0TWzKxlSFy5iD623H+CpopsRhDjMQPwmHrYV6m +FYHrTgv/SzoVJ9mFWIJYm89OcgIwkki2Jrtqco6xY85nZ2JOLhic5LPrSj47k/LZpaNCcayd5LNL +4f8IundVUoRohjmG+PlYEtrl1H+GcwxpkSA1564KKaNdyTtoJA5QImE4/5VJCe1y/rphiiE8H6d0 +dqb+os5m51I2O7sqjmfHKZ2dDNlzCryU6Svls5NkYCVjZIowrbPZ+ZTNTq9SAshxMrsoCYYUJ7yU +1GN+lcumZHYx5TVbpbSoKdqiVTlzqs65xswq5bIrudNSkkjJf8PZ1YpHluZMdum00T5nDwsp0aNJ +wanaOldFHnMmO5My2cWUyU6lTHZBpTKcFlBSxQXpS1Qpk50No0x2PG+CiRxnJc6qw1R2uk9ldzxI +Zdfqkmy3lKzzn0rlnMvOrUr7KWlZ6SDnstOragycyy6s+lGWVHYp/tqDwea0axL1W6ey83GUy86O +ctml9EK8Yoxkq4JQjGFWVtytyoJX6GRVSGnsOsEuG0Zp7KIgouBSQruMSVUWO1Vy2B0Pc9i1YZVR +n3vpY0pil8fhZUM5K8HZTBckiV1cVTswBWunDThIYZcy2HWrvIPzVPZ7PKcWzWSAU9h1OaVx18eP +F1JSZRpiyAnnteN0UAnCBKrNmZRjoWE9CctkLlO5TAczGcyksqeUmZpmYrousZ2kG/KSBwDvhymj +jR+mjPY5c57rJDy/6oN31c5KnZRsqRIbnMYhKVUlHQ8PVZKuWlXmos43lCaQk7fy6PI340VIWS5D +tU7NeClHeaOzOFjhQjNClmaMTIlsxQrfmjFKNmOcbcZI3Yyxvhntima6b5rx1mpGW68Zb81mvHeb +4dZupnu/GZAHL6dSlQqzpIsWEgNPkeOcLloxFXI5MBjOrYlKNVM6Joe170ldM6aFg3TRsGwc53TR +PUVtRhS3qYhxMybUTYXJuXidLjq3kXG578ggXXQX+vE09YDSmJtq0DwrTT8taeqaeu7S/Db9BA/O +Q2/6dWrqharP1a4/+Juy2Akd+rO5GR3fq4JSTY9Tw1TRMSGrMzaJprpLxdndmzNF+9RGlShadkXS +ClQ98zZUXEuTiXdT76a045p6y0mfxtu2qfZt2tn9N2nvF06sEIiKWxtniQ6rQmiaCTWqWMNCsvqv +MlUrHGYhfRUbKomiXc+qpkTROSc4t8KJojP+B0ESDiE3PV+cEkXbVTMi5k2m5vtMQ/tMQ/tMQ/tM +Q/tMQ3qfaWifaWiMpPtMQ/tMQ/tMQ/tMQ9uSaQghktmhd+DS28HOAgbfKY/sBlc9DAGfokXigE+W +R2AykSgLEq1YoNEss4n1nzBIhN0QtCi2OeEtpJCgQ7K4y91fsTMq+4MI5tEpwml1ewdupJjl9PI4 +V/iWmwCLf3HVcByMz2kGnCyk0jqlfc4B3XIbAMJzTbkISXO6fJiQWpciQdq0NopFZESkaCWaFpbb +xUuBjZhGzBhY/xSZRiuRnRVSsLnt057YnMq+S33C53x+IpwlJ8/vxEcsHLJfnDjxpLQCkepKSh+V +UJyjg1ls7dLs8CqJj4JKRu4utCng2qRrCqBKYIgEcWeIOCfFNiXIla/iYUx2hWxgCIfRxxSnHKJO +flBRmUQ/LW9AGpPEF2FZXbDCG7sUGc0QdrjiKay+oblJKXRl1yMxQ6pYdZKhChbBNmWlsHwdksG2 +STb5jv1MaEqseEjApifrxhHaYuLxfNNEK6Hx4q7KJpiWL4FxqofAU4Gka0bHBNKsbtF9RQY45XJj +hi14WY5OHbIw9FrX97njOHNdD8ylsO0yeJfdI/P8QOOj0oUVaQo9a9tNDwqgHWniebwcw5lSMeQh +tUw4ezIJXJCWsO4ts4PWOtMD2K7q861m+ZuUkKBjLoamoWsHaEggzbYSgBQzLUYlXyNOYwxA3qDQ +VIkeXuuQmwmsVGQDAgARWjGV8mBLymgrXasSRncpxX8KbJfEFlW26CAmX9EV5S9avtdjJa4VkuW/ +y+m/5ToZI56amn1bJMm/Su5kTK5c0t8XABt+kydIAiFFNKdvBolHkoec6J8BIJrAna7N1r8WB4th ++pZGl/L9M1HK+fjPOOG/OC5VGf+VuEquyQ99dtAMkqanpP/WVzWM8lBLxiF0xWSzowuSE90nDxzu +7CjnNY+omQybs2erZPMUYo/pG8wVkxWtM6mRrwIMaZ3vlwE5vX2XpovxXMgYJ8CQ1Q== + + + FH28adNdgbpL4n8I+VkIpjGm/kCoO2OUL/n/a6wrF5kwqrKDMWseU1oLTucyyoqe8j2xl7wo1utL +AMSDLeVXT8nXyw9xsyzJ16t7AJxoSquLANL1fsxsnR0MOpPSsaPDWjpc3wWwKknmzw4q1jJfw6Kn +2epTInVOre5Vbo5WRknme5fIlfWyyLSMiXQLj0Do4tPwdPaE71OkJyzLd6IUjC8Z+8/SrQA8+cNr +AYDiSlzWy0UBbcvk4eygB5l8viEXSAfPAhzirewEub3hUDgi0ZS1lkPYY2ZkCt8UoEO3qykn9VAO +rTb5S0zj8GkdYbaWOHwkz1EcTRH4FgI4T9DphdAP5yXHyuhD3SlOsJO/PDqbWeXRvVUStYMTqKmq +LGEcayI3pgxlBV3GUiaRazlTKTLUJmylNLkJYyklN2Etkxi7mLlMYtsG7CVKbsRgSkzEBiymhFhs +wmSyQmEjNpMDQ5YzmimAczmriTFuyGwivdRydhOhpBswnF+92YjlhES9AdPJcUXL2U6OUVrKeFKh +DVhPKbWU+eQOLmQ/WVe3jAFFsNUGLCjWeAMmFBi1nA0F9i5kRDkr2gasKCuONmFGmRhsxI4yAdqI +IU0B4stYUiGxS5lSoeibsKVyimzCmEoo3CasqZzPGzCnkp5sE/ZUmtyEQU3pNZezqJJ1YDmTKvzS +cjZVym3CqI4UhbFE/n8HW5VkqsxDvxJzmgQjOYlF81ruTAx8rmsjRLTwcdRVJrUNOCuERqLvwgTB +g1k8ksUPt+U7Unk4GIvkgEQuP/F3FB5K52v0Elmo5hzYYcWj37S4xhf7jt0dDPafaFWHAzrehE+n +g1epdIUqsSeyaxBQDedapJTVEdWnIG1ucPyt0/1nR2ezazy6v0aDiSdaVFd7P6u+ZmWTennJ2nKe +iQ1Wl21wy9eXim2ywg8gOLPaqmKsrzhtQ6sq7puImjDhiT9HHkg1ZOJ1yXlpEKUld5aGFA8c2RVT +5wvWwO1ELc6zifBqMZ4AILlJicdzckMpSyhC8SVao78CjsPSq1sHmZAyve0G9La/rG1wQWdFt5mq +dwPyTr+YYWQQlgMADkSHsIHV5+Bml7wJnecrKOlblby8mWFmwcQkSwjEvMl8byQnewRNJFHVHXI+ +FBJUDWJdgP+2lQ4hjXSQTg4/5c2Xvzo6m1vf0X31GSe+mYNK7997a5BOIvWXop2kEl6MeLyNlqIe +U4flyCfZaRajH0/ScgTkYstR8AECUdQEyDAG/cRVn3ArcDC5sJSsbvCJKGWlBAc8dVk/ZuFI0UEl +0GVmUgFgO5/i+SI4YAwTKTnE3wpcNA2JE1LwM0ZOZVRumBmWfCllbojFgp6pYcYnMKtpev4opiza +Z/2NlMMLKYNbDdis0K2GmsIWugB2s5RqOauTPkwyKFFmRMVAmsIAxReMs1Ej5W+WW62IhJybYzLZ +G1EHaqSLLsoehX6CBWniQqGgwZWlGooZRKPgfPaQFM34YyS8RCql/lsklp9d8dG9FSsfJf3woOaH +VGoT/KuyXC3AQCm1GAel2FIszI0txENh8JdiYiq1DBdlZpdi40OEgum0k6T0RrFDLOgivAehezMu +u08jLsVlzSDuKuBAlggJWlwfNZN/OlM4cgtkE068OA+yNrG/YNhlowTrv4AGLE9yZ6IkvmBtASe7 +lgDEkOIroPcIEuEowgsBJL4CYmtQq8mQNtyODv7tvA9oJtlZnraB4YHTRovwdueERpypv5t8Go18 +0X/Le3FWrUf31uqVTMig1gf24XR5Bbh0gUXiXrzEubGFiyzFFi/zWjxH3iba+vdmbvpsmWQ+/HJ+ +91sJC5XUm98dIBCaCBtLspZocGRZOCLguqSXOZ2fn1s7BBLSnHgkh+UznSilp4Uz0IkmCVs7RIzA +pOJF4dQ6bwuAGXhmQDKEc01qHBsZwrUSz5ZrpWdOhJ7aPcYpwXncO3bMlEzea0DD7p4wnn7LYf5Q +lbDu3nDEa4Zo0eKDZ4qSrFqie1jn1ZVnjvrn+4vLF35Ugx+2ITF5WiK5eMZOegj0Z5pbkTvfvXyR +W83PIl2gX+ULO6rBDts4nowVc2BY9NPV+Ask9Z4KKev68RIvKO/L+B0yP7S2QNyoBjdqA/6uAunH +XyCp97nOPLrcaj/+3K8MMaMazKiN48lYMf5m3LmrCpT636AzYOjzAJvpHDToTlehSTOex2bcvITn +jeahGQ+jVJzH2UynonSwfDOezmY848fTkfN0MB4OZiND8jAYM301GYyag7kQ1AzVJ3ZUhx20Ikc2 +INVEZEgeQa60jDG1W01D7lr/iR/V4QetHE/Gm3yjEQbEFhOoSixJUFecqLG1oqTJuRFxm4fcRcFi +oWQK5ZTHtIxWrFwFguHg3nNxsxAYcXuRrycvNeEWHwVVfEh3WDQe9owYJGTHMUtJL50Jkm7YtMNH +zrKheliDdjziqXR6cOkN8E/j3qkWvOEJP+mUqq/UY9JrtJN/M+KKGdBUpQ9DF7ANSfyEjthCKcW+ +vVE5xuPhlB6D+lSdv4I3kgoy9jyeltlL5bmU4zsZEIXHORhRsWdzoIqcntUkUbrlIPSqd8cHVe9P +DmRsrkCqcVcTQoWqyTo5qOcx11B6Wg8EA0vHLizlkbOoEX4xH3yFidLs3ou0FTodTsgkg4QfYK1Y +rgaus246AVoOR7VdKXUsSZmTyUgb3jSILdNsA+1we4BZ9QCHlBF+1Rfykk4vhV+wP0CyrHAq5wjj +GqEEUhRxRnYxSBeAl6QuucxxNVZkywyS1TvQWc75B2jHsQtED4H3AatdJnN0nM5m3GQlMX8O+gcj +Ce1oz0tUEYNw44MVoQaHPfLLVCCLDBHRid9WBkKg4VybpS5VQuFygxnCrluWUwf3X1ni/XChU19T +gVQNFljpV6kp9308vrMcmbGWCdT9tS7mr6d3d+e317//9/ub27u///o+3enSrn53dHNzOfzm+vTH +y/M/frx4e/5BvlLTiv5G3OOHu9tTtNdXR4hHSGChRGuF/7ZGlOa/+9v56eWfT+9uL/5N3w2qit9f +Xpydf392enlx/dMfby/e/r/nv1Y3zizhYj9eXp7frZrV0enZL/86vX0rGREX3iOjOOK+SymXNeJK ++Zn92FcZlJ5sDh7EGZXS1XarUrAZft4om36BuUo/efdUHw1rKOUkCGvFrQx6Mvgyd/64H8f860tW +8GBokauIJouoJu64mibPpbMSLgUs2uUHJK6FKrbVJBURgn/uS0tkslasC0550jDgleTq5LxSZZLy +FK3yu1xGXmlTJqekJpaXTVWmkY95cful7dtr6o6kZS2LusoXGIgTCmOS/Eo5jvk3/9c/pdbsKjXG +omGXvkgfJK58JRJAepG/lKIg86nDpf7SSOrF8UHpzoaRXVzVVfpVmhCwLjZu/LzMWVJXach1Z5LF +lvt7WX73w87vmlRn+olPy/tSJH17Vvp3ORKpnS3hGP+RIjKKqLv6ifOSiO+ILBhHjeAp3ZyhOJZF +vELkDi8Ak/FbADl3At+7ZVM2bH7I5fOPvgg3kx6PcyfSs9z+ovoPRtX1TXGIY+7EycG4i7maRljX +PM58cCKVhWU7M5/TfGEj/iILC7/S+fZpsHg6p5DnD3WKkI+xlC3PWaHO4TIqX3MiT/nbvpBa5RYa +bk8JkGXddIMhNz5oOo1dpvsBTRlxESTNc37w2DIh6ky35vbUdCNUm5zFOPee5XwPq/SGNVmm43UL +2hiJ3//hqhQFN9+lbJgPFXVRLrc8Otu41aPlrULJjkTFveZtPQV4OF84bSDQhG/FlavfN9lDMu8c +Sac8d+9kBXHaPdXj3P1TulN2EF8zOnMPsb2t30XV42P7SO7Wa3ta06WJSgRTFYL54BbL05c2mfip +ztpm2dsmlr4v2WqJtKqc/vzh7ZbHc3L/sAmn1BjKtn/bE9j1xFWvhoBERMAP2MDewXIZgWE/h8Pk +0+M5jQrET8XGmbb8gqV5+I4L+1gK13VDwZhpaNWTukep4w86scDiwde/gdjAwxG5C++lNZovP+bE +riye1rsW9m0j2RErEsNRmYecVXZdCaIsxKTEmrLMbONodhst572r6cin3i35j8Lrfxxy641KF2mq +Q+nDFa0p7opmj+bOB4eNnkGK3aTzRVaDcveeENrwornQItNhOiJIooXu/qEjAoxHl7IPs9dh/yoo +G8ULl8i1Ep/10QpaaHPiY4W7Ti5IHR4TC1s+2qRlzCRCcaujArw8EQdI3S1J+CSvevxoW888vAte +d8zVU9MdIKpPGkn8vQMzz6G7snbKdvT5VQFBAWh9l+4v4bugFS/tqERmsD19I3mPIEgoviyMb4Eu +BeU9FImKNRWTEmtBD4nVv+HLW2nA7rer331PEu31T6vfHB19c3b28epvN3csEldYPTk65URY03MJ +7S5977/pe7+mXCbCa3r6u/p59bu/3Nz97fzs5vYtYb4I/2I57GyX/LlsUPB/0RNx/fibP/0x7ZW/ +v7u5vZJXaZS0ud/e/Hj+5ps/xTfUie/vfr08f9M3LV8tnLXq8AgPGbqeX8exsVLi25t/bXBFw5ep +jjCcA9cE20VW2emutXy5j4I/kgtTomw5B6de5SS4/ACTs0eqFBiyjRWPib1uYq+b2DrdhHeJRU5p +IgbS12dnmjUzcjVf3LHSL/8a8syduAsmnpnLfn6WGdyJUXAkykyz9TjzHmKajUc6RXUPRwuPKxXG +PBe2xn1FvBVnjyHbPKuVo/mtkADORoDPxzivYZedeJ2k7MpsREopKzPspIbh0jGdLgGWcIt1oFKS +G0iRpAlUoilwEXfr8iW+w348xn/7oDoiwCthvxVnTXyA/WbPOcM+D1pIeM/FeiSdbNnlD7bHbsR8 +w/MdJ8SDRVWIfAP32cZtHi1uE8eU0Z+f6TY5sRFS38C2fVWBaKlleSpQm0C2XDJWQBCr5EqZAqqX +vzU+X1dP4pSpP4ORN90b1sPQ6AOwbgpLQziZjiqfbn2v+X7jTm4R1qW8l4/r/pR24Js4BNWj87h3 +nm+V1EoPvqpmagoqTa4BPSxtJDRpP0XamHTtagAsPeFI3MksDaBlbBI2p8fANXPFgZvj2VrTqU8T +ZRrQCNVFGyQQlnoHEdK5J5FmFq1Kdc77VyLN/OHmdm9h3VtY91LMXorZW1j3Fta9hXVvYd1bWPcW +1r2FdTctrBN76tXB1HjarDGxrjHEPquNtZO7Oe61sYLr1Y+V7YgIQRJdYmKdNHy0QcNPZGFt1phY +a3tqs8beeq+NtVlnZJ2aJmvT5bTIetjTm1nXdZ5zQlVm1jWDWVfw82gnuoAbLNXe1vqk2omT83d3 +e1vr3ta611LstRR7W+ve1vqEtlZc78N5jK4OWrkEUHIOkjyi2HSUYdnaesKsWIrwHYOysbUquAbU +V1+1/7mNqwqBdwiFjVoIdG+sRCCkeAgaSS80tK0igA13dj9UlNAP5qWRcXVJm0eL2w== + + + xLFkLTHNn5ndbvlWR2iU2ORpNONChmXT2UkFy6ZMwLoJDDcderMWlA2eVcEa1N4Lysa2CpQ7K1jE +QbjtoJf9B/nuwdxXtue1kcmkli3W1n3K7ytQ3wFkp/VmHWQwV92a+Ru3vx72oFjxOaSKaedYqpiO +ogf2g62KrwX24xALa5ndut36o3VTtamo0mRagMRmjrA+wA71BCLKhhLKq7Gf/u3ip5/3IspeRNmL +KHsRZS+i7EWUpxRR5PrQLEekEBnd1dJGAVUySS64DtRLIOzvaUQAya9r+WTY+DMKKVoGdJ+QgvQ6 +nXm4qAopjclsKWXS6NgD9PFGn0pKYffKtHZJSGETj9V57fh1LRUIpOdSM6SXL9h3bwTBknd2HagS +aHLBIai9D9RztpNhFDtFrrEWThKoLq4Ocw6WCWww0m4ydob0nDeXMjbP3rDxtaAnF0wmA85RZeMh +V9BaCJkOu4fVIkc99KrVoegymft7hZIvXhr4x/u9KLAXBfaiwF4U2IsCe1Hg6USBzIYzt+9sDgxj +EDIW6z5uC754PUiiOqxcnW1bHVYpCkzVn2VBYQ0kNXgy7cNTBoXx/T0DHpsGJtw5EquviQkLD5dE +SJjS/oGYsMeanIaEPdIkjic9SFn/ecSBEqgjaTKKQOBxiBBAFjBzbz0kc+frIN0YwpF/adlFHFgH +KuUqUK68ybxoBcoBaBVoOpoiFwxe5WCwHJFUtd03NAWVWKYyH1NIKcZ119VMe3AP8EEBgSiuVcT2 +fJKAMB7k1QBYhWxNB1rBytBSaNcAsnZkKVpsOOVr+vMpXlaN5LPQzktiV0V9ZYdt/xQWjEXL8Zpk +lrs7GgiRqNV3t6fXP51vFALmCTFwrQd8pNNB5IkdQib8DGoCnaDa6hWS6FpciZUBLdKl5oemvM4V +NKWG3EqBHB8wyFegkwMup3vIpOa63XGnUuFcNlffNzgZ6r3nnQpOuB1ozFzhdtque/DAa3Q8dAoX +jirf0ZHBhwK/wz1JrVdy7RAdBcS6qbYb8T1Imy/XBz5cGh7PSJ8+iqVY2PbRRm23uEdX2/ERqH1r +A59qUbc4PJW31ma1msEPUB8rFxeQUCa3+eFQ5DxEBRVM5oZwUQzft5JBtNwm4YLly3czoKWlzb/z +u1w6Fy7IkJ5rZDCFH+JSXQ9qxtU2dZvNpEelgtLpCu9Ly5PBlhRK1YbIPGG9b6puBr4GMcOa4FJP +AqEspwPIEOloesBbvmkq11AqqHbGqJd9u+NC41rrJicdmvR5Mtjj6fjvEy97l+JRt/kInQxuMvy6 +p1SgfzypH/vJnE74ZFmO6+5UA/jqzZpREXBc46TRYR+HXRwPaDzi8dodV92oezGZv3uBtRjcmfUy +fj55nOO7o5A1vkW+ctrLFikVxDCR3uaXJ5PP7yXKUScJNJhoVyVswVLVa2LbOKu7Vx1fS6NwEZKv +eXrixw8NAn2CJo4/dgMZlNbFG7mq5OGypk2XdxM5XNzg0QYN4tYsvhZyRH8/UT1GbBrfa25Sknxa +MnOYYotO8tv88mTyeSZgzgm8O+Qs+VcZkJ6JhHRVrcOP1wCePiZh0mHaJ1UXywelS5MiX0AoQmfX +7/fPdeGRcLH6E7lYYieMwmU7mYHtTMATyDm/CUQjNbw/M0B41/TQlNe5bIPCuVo80AFVPQmzmj+c +VFM3Mu5B1buq28eDQTzKmhIN5LvGE2tqiAFzD0fd4ZYP3NYMdbt1Ogw5PAQNBycRWLhvcxjjaz0B ++Y6thwtHkKdJLN6ylo82arn1RS/4ORnTsuIdm3fA4Plg0jMtrE6rLlf7ZkBigbSsurzLRblkWelO +DC+D58SJlo+bcVVN3U4z6UUz7GUzHMTxaFCF++yRWyxZQ0DiO+WKDce98qndeKgUX16eIdKt9IC3 +fHFpLi6le1wf9Cm1Nfh2XFPdzKQTw04Ox3B8MB7TY/xl3avCXPaDqHvG98XWXQMrWR5P6sd+xkZT +Ou5u1YXcYzqhppBBLZNWhp0a9mk8gsH4RmvUN11abmZABrxjV90ZWe3Be3/IvxxIWYZtDi2xN9iN +AHHaogQixAmH0cQKREIa36+FqErWngUnVxVxMK2NaafiFh3cucmcb9lesKcgKLZsMe6X5XvjB9uu +ExEn3QUuF9j3vZPn44PBTgSo2ukZ1Ezqbda13kz62EyG0UyH2vB04HbPPB0NZsy21bxOZxqpM9Zd +CrlmSRKODBeFgBssC8s5GyyMlFu4NIPR5MWR/b7J8ogYucECoeBmSzTaaC7xaHEsncVDuYwKIe0W +lgaHW62CKpDOSw5iBy0TVZ2fwcrk3w2/pPnIhRsp7Ve5/gI4O/BECayqQMTkRtzFXWrJAOaW0u/c +fC6duzcewPFkSPOTQMGcGdH7FsHfMkhaixD1Gl4K14riXkdJBpUeIJyFQ2QTIJbByZ3jvfPCZ5HN +yoQqyYNyhQllA1YB0ZzZNKHGw+0nA/iITL/zu1w6Fy7Tl56PgRG48K5ASDwxghFSQ35G7fl3aToX +bsb1N30DSVysUCWNzOHads5jl0CEcLl6uSkuA7htn/sl73LpXLhCjNQwjT3A3S9Dgs5zIzXkZ543 +XSZVXubCzbj+pm9gArqfxxh4RPQNX1VP45alUj0amNxPPxy8Xo0np584fD2Z18nMT0aCYpMpmExS +P5DxPbqdL2d/cqAgWVruUCQ+tMXxwKhtA+57LMT0pHyGr3SsIaXg50l1AbsVSwjpdmHTFjW4qGFo +gyq+6VyTtAGhYaQ0ojOCdVkPFjYt0UytfFIaLWzxaIMWNa7KhIL6Mxuu2bony4B7xZkl6+QG6KQ3 +4tf57cm0QKU58ulFNK7TojvyUlogJ8CNvu5xgbWgZ9Eg9Y36NrFAqaM1EvefcvdaO4CV4l+APqmk +toifV5H0h9N/3txe3CX90X9kGeNz3pyN68xxcXNj4FnVweBAfKHj+0QzCHKPA90EACY1bL4I9YcB +K9hFccsMDsomHeWST2SuUVbcOWMwfKm25LPS8nx8kCERWWzEtQNWOfhZ0qbCfaAadMXz9dFsoxP0 +w32ruW/ieKrB+paPuBbvSy180WxuRC6aLb04kVtqFV8Innra8GAYkgbDN/Oi2WrELJo6vnY0TUvD +M2e6fuYanl4cJlV/fb6Nt3xF7RKvBhdLvl+3q8aJHD8OKgLcGJ0u+MxfoSIkj+kXaryYx8XrMr2g +keVVRsoeq3tQgDUldNwi72nD7cKzTiH13jGTdiUTQtOGD4wO+QN2HQ2HgVAz5DrknhW+nNSMJyRD +jsVDMLSx/sqxIxQD+IJYAsjdxoZajZLOkE5zpcQjuQ2O/SAPSYIABNPH8ymHvQuSARGPbFN2nTiU +HirYhWm2raZRiUzkaVJXOMI6VSMc2GPuLn9i0ye4FNxKmiOuBWwzbrUVtJaW5HLchPousCqUu6pK +V9kHlI4314+GR2xVPWSeFdvPCubN+2reJst8PF35+x1ct8RnBDe7wmzEWRARLoBbg/nCV221yCrP +cuHr/zi/ZMd5JrvfPgHpxc7WXi5KcuwtpSBxhMienIGaoY0lDKvhZHSGrwCugc24RDOuFHcGd4I2 +QFjceZ0B5TmX6YvkanOtuU3uB3ejgow+ntQ2am7cnWmP38GRu8V+z3+vJLMqsv2ByNPGJLaLRU7G +COl0BWrGnzfjGul7di+h7wNONyYbCdAUCH/NNK4vlqtuSt254YY703BvANO8MH41KZFrq6qdtD3u +3XQAvI8R9uCMUEhrjEv3XbU8CbSD4LNkc0b9QLSA9Td8blQQviE65WLMMFzwHpBDGvXQMcq0M7L3 +I6uOnJPp0IetNeL7QeKX5h9i+KcVdl7JK2LGA18fb2DnOOZL7Q0TPKiQiHMWj0gRuOEywPNjoJJw +nDcOXt3w6smZ5JC0wrATfKORxVqLkVoWQpWvmKMDs69xuOkecnag+GxSPYjkvChpShGE52EfxhrK +OSbDNfBXNJ4hzFvQtLUc8xHTghdAwPFAE3N2UEC0Mp1ziF5L4yRSx1o8BeZJs8sAhAgjd4T7NkZc +Xk+CqQt8bzrOycB3hLdUD0+HalXHV7Lj9m7afnxJOMmGDjqXzlut+OpxYy23A+95L+3Aof4QLpc8 +iSS/dCiEs4XPHdBb3IROn3b9E+31DmM5PqhAIVgvnrk0N34ICCypH4p6kDYCTywtPpukqV9OI8Av +JDS0acFxmTmWiyaIeSXFOU3ZMw73swOFTRLhe2nz0HrtWAvko1xxTic3ADSBcDzGNMRg0Q5w1LQ8 +Sufh7sAo6hhFMaGmB4Q06VxIQGjBEeMFp9NOkrGaSCf9ZDNik4IvCMwpoadOK3GMB2ugCwjclO8i +pwk0sIL2ACxMG2SJEgiCs171ldC+tMKs5JYShOgKoSWcwDPEIqAWRFvqKI+llQJJHSkV5J5OhnPG +uvRt4R7klng2RT8fq3BzdZ5YBfUkrAKCyFi7TyigQoBaiU5LYrolh3KkvcBxMAlkWjF5nQBl7wWB +o22dzu7iLNWL16Rh9pgbFdTUbWCGGaaDFX8RBdAddjrw3iOZP/oaxjVxeA4AcQ1ASgFA9cLS3dc8 +GfBJznXeSlntuLIrOgDF0JAAJwXg+24GcJLwKpuCSrGGaw5hDQR+5JzBSC5rkYkCw+7ZppK7VH02 +6uXDapsX2CR0DjuSBTo6u3HCWBADSa0clYvPt3G+u/1x1ayOLj/y9lFZi6rmbguWlZjzZHp8VSBG +HwqpDHJ1D7s8M0FuKlDDn3f95wWQa8RpmkEI0+KjP1WgEWOkED2Uf50djN+VHqbC4x6fzTDsGPPb +9AFCIZSFwwj+RXgqMysGB25nVnR+E+8GWZR1v9yWFjIIHtUSPeKrPgT3V0FFwlhDIlZv3tlETTez +T59fX5e0mApi7HAa9WPTONWT0+CHbp+MiwM8JDIVtQkc4UPcHdK+ZRAJY4fM6dAWUhFYkgHEtEVm +XYFKBUaUT0nILFcDkQxnRf7BiKRaVuUwgEu6vmT/XGrPoNyDXEPuYt//42ossyyL0G9K4I21bP4l +ttnINTPEZfs1EQREvxX9I7iXH/iaGaI4li8yAPuN7NTjuOigvWHLoW3BslKzXcCW6T0p2KqoQLjo +TKVd5qKcpXyDAmRFD6ulSc80L13gqaK6oWbqAWnujg8yiNmgzq9yDRDCfJ47/nXMV2dE50MBNVy6 +60sXQNVCBUvdKPVIN3P3s8oOzy6hmuYbJWqCBTxQATJZD6naSjAoiOTqgFSHAa/M48m/joVkdf27 +TKJy4fxcT1cBpV7kOhoJLTFOtIWsKNwsnnrS6lUFzF0bd70floRbj0Y9nZfJ5HG56STXayDj4tjr +atSTKZkMYGw89P21CpBnXE9pIMxpNmgbNljC4byHEdsNzSz763JYS9E6w88aUkcGyGFHZL/6RsML +Wle1ZEBu6uyggCB4epujq1ENgrcVC565rQJh+UQ61H9VOt1XNRnbnCNQ2YeIN8SxRA== + + + auQnAlxb6p924l8u97QUQoPpDtV0K0iXHNtF0m1r80XfCWZF2ALbrLRJ/ikSe36YDZUMEL0Zs8HV +R56k0tBV9RRAauzsoIKVuz5KRTGrNHJrCSCaqNSl8lHpdaloPLZPn246Z4j6dzLh+UFSoTqHUHMT +qSm5oDLNuATVwsxPbE/HERQFFBGI5cVanJMEieoMWiYTugKQmYI4VX0TJRK+ryUBcktnBwVEUnqX +vHalFqS3bU3VUgbI5HJv+m9Sf/taRmP69JmFOgShH5JNJD1gZi26B1yGB9bggrYIV6JWruaRMOsC +wabVxFx4JkiCcaxpsymCvgCgCzPJfSyBaJ/GoEQJmuqpQKkx1lIVmGXtx6pURcJPF03om8sAaEdT +lzKoH0aqZTyuT5/cjmRMZdPNd/kBLAltTM13K1nLTdWEouL/aEd7iYRr2TvqqofEFDVCpJ4Vrg0H +zQUgmCicCgAzjckwPUhBvIacnWspgNQQr06BQGG4KpUgYQJfjpQbygBoflJnMqgeANcyHtFnoMTw +77OZFqcHzLGj40crufrKmFriaAjhrAapwxnjJIC+wDzuvMEpCqV2bFldrISHDuzzZXoIYWMkqsua +sPKVgroKvGCpqUBye9jsGUYsndGBFyPVBNUvU5rSXoacHfS9Kl+VnpeaJuP7HBQYZ6jLFFgeaJrh +jIKjle+NsWD+7z306IPOKVawqDayUJNB0ONrsWO6LrKOkk8OmB8RpJufsY1Fh58h4sJp+yoKoDRz +dtDDiMRC+5trEX2L+BtwQwVwdpD7UkCl/6mSyXg+AzLToaDSMZd+434dOvE6zqiiYfdua2LMQuOI +aCBnmV2xOsCyIYvKh+hYr8yadA2bQkxhwThpqF5hPzGtkBSOcWsn+2EWg7r22T8ejk1ESeFMlUkE +x5CfwSVDOA6YgD3nWJPUODEZPjT0yVgjKij7gJbCgVdVnHTEilMcLDG4aYjvvSVh3gTnodniMEE2 +SFrOucLXTTErcGhEie/EW4vNh54/YMXxMR/+JoqxMG9rDj5jeICFZDhvZ/cGD3XiDtdGdvfCLHI2 +jzbCGEezZoyEWLr8B0B2w4QxAq6fTiPpj0/hRZx3x6UEPD4kMhy07AMOew2KRD8S5mSfmdhJbJHt +ArxvYV3pcEsfs+Tjst55+IwaOHpH2JCiJIDERGTvC9vGOK9ZuM5hrUInVgmS0PXakriEyrFLbxvo +c6EM83pMZEWL/3IgjvSQj5lHkgg95te1aFme5oJl72kN7Ew/uaxhWqdWehABH9YzsRmrpxVE9QzM +Zg3cGCO2JnvpRBvE0C8hzKwz71hR32JzOXidsLKDiC5O9WOqyEl8EkA4BVx2y8Hp6/EcxQyIZ3jM +nIEsKXFdIgkKdlW+flt4ZbYMwaDtmAnEXRJMYHHycHIBOuKYRe7gCI6NH5JHFXrL5IMoQWIYc7pO +jR3vEnuCITL5CMLCOJQGAGkdjg+YOoAr1MkpJjNE0LhQkenMbUYvEIToIqNkjI7/spzQwq5JBNQ7 +XAUBxZOiAwtXckLFzGQD9jRmwBxTaLYfOvbyQmYOHXViNaNiVrPDhNAuA90gWbuDIMcmmUCCa1CQ +6iflaU4ifLSg0FDsA0bc3ZFwL16MN1QrjCXz2gYF6JAviU2aOGGQIGVNURopH74sS0drhXjM7XaS +xZ3o/NiL9NPIx0ar9DTeosBgr1+eivham0HbyetknI6ire4kzRIOZuNF7OLjnD0fFTvKSQoVuIEw +nWFvucMQFTslcMol/kpSPRrOziBXTPKtdo1h/pfVEhraDLYTehEllRMXRrhgBuic6I2IPkR+QvBi +WifkZM9S9rVHB8E9w5DO17xiexHfk2XuM7BEwRDHDX6HZS/kDhTWhX0J8Izeg7UHLhzD7EinrSQV +ZB2ClpJgN30nDgSDmduYiHQwpgEtjeeDTSkj7oG0dWjgLbTmGCs1dsgigQio9jDp1mD0ZHeF1oQg +eTYUKwICHCpYxwKTKdaJCIiKWsO4zDpBa+DEGteU1t62Vtx2lHGIcsKEHrHhgIhrllrbOK/hI3ZX +a+E3T993Vu4mGZfrcH5FBFXA0dEy0ZnZX+iVYGLlHBESqvbJdGPxwjzJ5SQkK7WqfWmqMcziLoZx +VpXBk4Wz9bkQhSH1wbCc4mgPsgjGqlzsJx1Fe8a6ZNliqhMHMXGpor+BK+5EygHAWikUIXKzbKfZ +XwcOCXyGqGRUg78ce32xndrJJ+w0KLrWpPQMkuewYZYiCA8r2hBqjZ3EIBXyFVhnTNbYo4AQDvpn +xV8p9kC07Nkr5cSSY1MAupBDFlHY80zUJsW84uUWz+k8biq3BMMssdwHnv4mKOGp5QBM8GrRy2CE +CSEun2RKUVoQJjOhVpYd6mnalahpwfNpWi1EwRA7ESVPDBEDx7l3aK4CBFG5VWxUmkRv4jvgwRdI +GKBfcoMwM6PGc+yVpgGtK7qu4SM5m7RxXry1lNFrizpbMs1EhExxyXldJvaDikTOxQwEgSHyU8WX +pavzNMyHcfAmfFkyAi8x8UjU4sLDjkkdMxY48mkHS+gpYiXkfOddDy93iDFifmTyQqcx35MbiHJ0 +/CzWrSD6FsjFcHMieuGgsGV9lLWip2KdiERmGPbli7JTjbyB36Zt2UUUzIlKBiyOdTbwlmxlyyaN +sz9MDn+AJSLoBYcAiZ2Sr4zEiLQIM2HvX6FNx+wUKyouOltbR6OgZwXPf1AR11lWxgwnbmNmw7LP +46HEoh/CLkPECLnAtQtdUqTRJFC7xoZeyRGRXosIhoa3F7wK4KwGKt0ZFvottEbaJqEf5PgHNkZb +nNMQxWxMUbiTwo4oxCHrSukMAE22Lus4IqiSgayPmyrmtHokpiLdKRb3SIZQ6wo6z0KvqOVYwXY0 +t7tEIagIlIhsAmhjGz6d01i2Kk9BIODN3HrzwnwG6DsnBGhUdUUMvG598lDvuqS17HyK3erEV5ek +xyjOFBquU+wz3olzLGA4+i0y3Gj5iDXQcGPmr+UTF5PKIeK8xmbkpIbKJ19WmLYiUwPE5rNOmj5N +DtgcbhMka5zwMK3cWQcCwQ7udNgwVdNwkI/JF52kbLjNgmBENnwjNQJnYRYnZM1qGsMAGBiPYbZo +mctgd8E2GXvh8Q1KxlRnPIkb8xWcLbAVH0/8iaykj6BENtAxG0XBGFJsW7LqaN+CRXetbOaUbd1K +1iYJLqAtSA/QwgQNk1rUIptATwwdQTSGxM/W3VPasIkIPoieaPghh1wdsbHAgSqIboO593ltH+GW +TON9G5Jyw5p7inYRmRLYU4COInovMsrMfqO4btnRoG2Fj/1k7mLhGj0B8eA0EsRZvbSMMtBsxMTD +Q/7AFocCG6cr7RP2KDY27WPCEuIJxKCHE1yzgxKHiEjcIG9EhYBHxV90UI4isEZsqsQIIGoCiQlF +DcAMPtQO1I5EkdgULQE5EX8jtF6Gg5n44Gfri+nAv3hOsA73L8cxm1GBHNAZyIYNxfYP0BuT4qGI +ADpQENNKqnEoz3wnDnua3cglXobjZ1m9S9QMRIuNKVCAQR1L9G48XxtzGLFrObyx44yX1KaXEBsF +dk0TO0N8PSIGYtBJKS36DFgFWw41sCRFrXDjp7bi+GaY/DNvTrMQJduZcU6IBiIWodJcwfOPiC8d ++dPCxBHAFgcpi1pvZWGOeB4tzCAwlVk6fuc1iz1vkUYBMSfEELBWeVrQEtLYnIAA6qWjud1l+Sdg +nohFAYGz/tO5jOUr8yQKjYjQ/Lmp45+IWBT38foGk8iuOSnUgR27CgiuNGzLjilOjA42zqeRf4pi +PSYPCgY1XNqW0v1zbkBkhgTzWT2QqkEABAxfbf+Tw5ck1C1B+j6n4pNB3LuPvRizU/pEkqo460VI +E0LSEc0pHWpJBCOGWiMQUE/yKrKABRsT7S/NHuTVzRFItg26xict97hkDFFsfIT7l9xUfF9pT7SJ +2C6JqB8mVlzY9NHSprk0zFNWbCdp+/1jqA+buqZOEakCzkAleKNugExyUdASdOJLoRcj1MYZOmbh +1xN5/lf5N8zT5N+Q8JQ+h2v7RAEqyI4xClAR0CcEqODgvy9ApXq3D1DZ2QCVfWxKznr3bLEpn5j4 +bh+isg9R2aUQFacfDFGBq88oQgWgRwJU1DMGqKg5ASrs1jSIT6kH9pnCU9p0R2h+KCEqan6Iiq6i +Rq5qWB2ioiYhKt1qHKKi288UoiIVDUJUutUkREVNQlT0oKLx2D5TiIpOU54fSojKp8ao+HGMip/E +qHA09SBGhQTYYYyK9pMYFQINYlRQyzBGxU9jVPwLxKjo5BadH0qMSvc5g1TEK3oQo/LZIlSG8Snc +0u6Hp4hYWYenMKQOT+F0MNsSnsKdqcNT8gBKeEo9os8UnpISgzT5oYSndM8SnsJjHoanxEl4SlwT +nhLH4Skye9sanhJVpr7ykMNTnPqM4SnIt74t4Smc+/1VhKcwyjwcnuJnhKfoGeEpiWso4SlqFJ7i +4mcKUEHSqE8NUHFBDvotjVDxErPBl3Y8GKHSlXgPvaZsjlDxD0eohHnNPhShMij5YITKwz3eR6i8 +dISKF0ZtNyJUqMzyABVvHg1QAa+yD1DZB6jsA1Q2C1ChqRkGqEDLWQeotNFNA1TaDQNU4F01CFBR +ywNU4ihAJU4CVGJ4OEClnQSo6C0PUPElQCWkmA2+HhSe+rKZOFTEzw9RGRTPQSphbZBKyKKqUzPb +zlEqKkepyL2s05IcqBLmB6qMinOois+RKp/Bf3QfqXJ/pAr2xmeJVLHpQsESqZI0en2kitkkUoW5 +hlGkim4nkSp+Eqli1kSqxEmkSpgVqaIej1QZzOMLRKropO5Qkqx3fcCIDjlgJNSRKlwmhX3cH6gC +a54Equg6UKVLgSqtn9luH6jiUqCKXh9cg0AV3ISyJlDlkR6nOBWv93Eqzxen0qphpIp6NFLFjiJV +7ChSpZtEquhRpIp7PFKFr015mkAV/3icSua3tiVORUmYis1hKnYSMKJiDhhRcRCmUsI+pkVTkAqx +VSlIJVEIDlIh8i9BKmsKrmuzD1IxKUjFrivIQSoInpMgFe8HQSoPdHYcooKDah+i8jlDVHx8whAV +KC+HISrspfhoiIqahKh0c0JUYnihEJXBJG5DiIoqwRpGzQ5RsX596YUhKo+2fX+IyrjovBCV+/q9 +D1F51hAVqBFHISpwNRmGqKjHQ1TaUYhKF5eHqOCykacOUbGLQ1TsIESlnq8XCFEhudCnEJUUK9Ll +sI3waIQKrWuK+WjVtHCOUKGtlyJUnCoRKm1MESp2XqslQEWlAJV1xTg8JayNTnm4qzk6xe+jU7Yt +OkW8eO6LTqnefkp0in8oOqV6uY9O2eXolPtQKUenLESm+6NT7kOnFJ2yEKH20Slro1P+9v33g6CU +z3vlkNyQijACuLKzQ1kPsocZNYy1HAUbeVU1bBnGF8AZX7KJW/36T/ywjvKcmhH7DA== + + + g/hiQU6aIXWg+UEzGZBuLERXyje5r6WS8XiwvdZj1Q9/PvnHn74ljPrN2cXtGS2wfvPb1dd8BU6L +VaeX1UKHlIOApScl5ix4yEiiAAadAESEIzCnQxyPF5sVYgwgP1lxXIlOLn2M8EBK/p0YJq4PbJMG +p2thICJuit3y0UCr+BByLohRLIEaBPAgZ8AJe80o9pdmT5iOLxXE/aoE70zA43AIx5NBwUeel8WZ +aqCsz/b1V/BaBbcCz4jQiihp+eJovAle9FEJghvygk+dFlhGk5MDne/i9bg7kFv1qmNP7Sj5Ikfd +OZ508GSrLibDKpqVVbjrV/FfdicCuBPPt2e5cun789Pbs5/lRmmJI/rslANKdgRB65Tw6YpBAQpw +VrqyogMmVrhgqWT3gL7Nao5W570N9IdajH52uLCMjuVL3hEk97CDc7St+GKw5w8JU53rBADHrBUc +B3CDArv9K4/G+Vua60tIZdbYjimId4qlJRp4y5oUbpMvHsOll3CK94kuabmUgcUgOrsuORKBJSBc +rwbBDPf6tumZ8ynCPgMKGQ95451NZ+eSsXQSexLvj0L5mP7D0rE0PmPxEDMyWRYBLl4YnPuTpQFw +g8WhYtPlIeAmC0TFpksE4OJFWjNbqAkHxj944nlFvnrTr8nStYCKTbOmN8CszWsBX0ZoAAzKtAhM +wpfQt7VsKrA6eAHCdxIcKcRrH9KHoyrvBb5jspU7/o/6SpqQhJUnuWo+QsZWjFAONjC23IqffQYp +KxpRADSwEMqSyMcANB4e945qqMCcGEOtwSTwtbGKT3gWYXFHOxS1rBTslJwMnKMLZxB0uLjjFgZh +OAPB4RNdY4WLyQ6g8CnrnCsQixSmmpdBG+wXcTZT7AvpRUNqJEddvqqWL8lVnBZTRRMk/smyewrf +Ie45EI5Gw3sEWBlbRIiRcCAKY5oUZL0cz1sOv8tw5qTou6sDxO+xcjaDCHs6a1PefBK5eNt4UVrj +NtMgN7lidjjjKPHeEqXj+LZQufxRMhrCzixZ6TFXUs7Izatw3I0cF0m7yTpsb7nmF7468N8gsclA +C3J8AI8dCfcwcJADB8KqZ5/c0fNC5Ge+9Jx/ZQisa9DHG/YlVxy43MpVuJo9co5hdhPvQpiAsYhw +FOpS7L3kizHZYbk77FzLhTR76rFqTSJUxQERGiuLTLR8G6bcvs4Eku9WTzedAOSNXK7ZqiAsq2Hz +IiGhNbpfkvGqHU/W8eHbIuEaSkuidJyp0djaW959JC7OehwWHre8R2AVPBVwp+7z8UN3p7erZkUi +36+/TQxRusF1JllrgRq0rUVCgosUH558k/TJQdrzQVxAWwbBxKg7vuOXRIAusegte4sBZ61iSt2y +DOyiw8Oa92uqmTY26VDf3Tnh1Yiupm2tHE5tKEstnOmgwXFdhPZrrPXSuJRYXIab9BsWCHjkOFgv ++d7sQXBYCq2m/cm2BAMtJVTKpjWIZ4GShAgrFIhduvq5I0bAg1CSUEgifIqshnAEfffVAbz6owSD +GtZonxDId+wh2N9N7RMPAlAr06f5siw22rkIKzzPqMHdUUQnOCjphFViIGG4mjrwZbLw+VMcZAen +HitkQHTt8AANfG+sdazpxnpAFOOFQIyp7+QC3sn7ZlJJM22omfammXa5WTOwZs34mzXT1KyZzWq2 +T/pYcPhFIC7hCnVbxfEwnv1nuD1Jw0tnp+NqFYZhOIj5hPdNTgKq+Urill2ntRDV8ctB2WG9a1qu +ujZ6mB33LQHfgzF+9WZNU0RJB70hOld3lR7HQ0Gt/UiFsx5/0YwqacaNrJvvQXdPDoaB3dYnRg+E +jk59Qg4iJAjBjimHBG07qGgdu7ZkTOOgmZiYhRNIURKNgzvjYd3BOLRlv0UjAX9s6PEh2SNh5jpm +JTdHgbBeQxteNcXOJQ3S0AeOyXcc4G6Ly/7JAZz4QIYa9rFvZQ9Bi8CmzxPIeU4ikvsPEN7Gqpi+ +GoTaScBn3xjrMXFBVdUnjl1CwAFcO9G5k+lMnTyg7MaQidHimwkb7+D2JS7HcCqc0M0IRgjE3IJR +A/tnkbbEcbRm8J1oiS34uQ5mIaKozCD/gFhaYlg49zH8lxGvsq5olxQqQUctRqCjs41bPZrbKqxK +ntXaUL/B6bpWa6/lRdqehWhXZzdX728+Xr9dffj59P356urm7Xl1zD+sFl+D16LoHmG2AEe4zSLo +JtgtmvcRfoNYTDCcxMcJjn/1Zg2W81bu8ZxF5gmmE3SK60waJtie9PYjfJdpGGH8mlk8uV8fv2Dp +KvW42i7OdEMGss8S9fFT2cd4P/9oHuIf2Z93Df/YJf5x9P5R/tEU/jFuzEAqMZlGCIJg6pTXKjAD +aWkvrcnOw2omm1M3pIcUBx8VnEraCFHUVSzkZ8rNM+AgNbu4DDlIzR5GAw5SJ25pOQdpmGeDA9a9 +HKT9HBykncVB1r1ZwkGOxt+smaZmzWzO4yBjXMhBmoc4SLOAgxy2vJSDfIhhHNY8j2E0jzKMZhOG +cdyVBxhG144ZRmykjRhGRLI8FcPoonqYYRR7fPR+FuM4rG4Z46gnjGM9Y5+ZcYSrrrBwcSnjiH3J +LJydxTeqnm/coNGjmY2+ONs4xO7FbONyHF/KNg5R8x62cS22P8g+jqtdzj7qNezjEPOfk31czsxd +nP1yDn7ub+dvN2HmYE/z4kEOKzRSdwqkSX8zOD+3ySbI35SX06/yr7OD8btx4ari9BN+5gFwhzA0 +mDKAE0ZJEDwhQdsGeGsSj9e6lr8MCHU6QWof2sacvyRY0bl1xCOUJtKP437ks5hCpZjM6WgRSAPe +pe1gVWrZtQHUYELnHLAqXy2dH+ApSSeYA42x6aKYiWbRdR0RGKgxadTF7cqo+ofRJOJEHl4IEiXF +ysWctRFGUUnb2LUuZID8v8lQeWzF7VWmnfMEIPlLCyuoROhxXgTDObmiYguAYtcIxSuEOCzMu3I4 +nznXQdsxW4twnNyE/JVMj1XbqV+jbrZsqxn2tZl80+Q6++SOOuFxziEp/9UAqZpzvDuOG8ov+Z2B +lahlMZr9i+H4p2DOM/CC4CsC5cJQPBtOyQiIlwQ6DJGAfC3PSp69KY881Zwi1nHSKFAinjNlgefs +c2w4/xRHZ6ce16PgvxzNp1cy5uM09k30g0an4+LhSRML8wPTdsbG5CUThzS3C6fuqzfTybsX9uCU +orsPT+oktWSsGMo92ZxFNhFEKVwEH9NICsZxxS2LtkqtMcfYIFlimWrmBwTKM1k0wpo5L6zZKNet +NS1b/CMJ255/qNBxGi3iRIVIEo8GtGgRB4+wlBaRUYhW2pPNPdnck83PTzb9QA7HlgBLROJHiOxF +lEHVFVfg8aG4QQdZHWY7/jgDzkhOVhI8nCDIDQiZAU44iBvhlDkckxwOOQUkBEDJetawr02I4Pk5 +jQDq6Fa93MGPEp5kmGoxAP9n/5QaDEAm6/hNop9kNIS3RlSc16GTzHMGDrAGaZzY6CkpgSUBk0nh +kmkiUEk+RwZz9VCcAkirobkGQ9qQANxqDnqCc9saztRYkvRYNYZc4oiF7EASlIjHyDTI4X9O7ryk ++dPinkISuEP2Or5HCvmf4SK0pihSCXDeOjpccCTJLTcbNno0s1GFcNWOI5AQhD1IafJYPMIavOyB +izATcu1i3PzqzVLsFMozFz9lLEsxNHntLcTR0e5XA6ZpsAb5rJWMk3IqevFt9KCGcIKEuhVzwo6N +Ckd86/gkgmxEB3pkf0hWWBHOBWv9AISvLLIkecfpiCJynlDVLgGQCtdwSgWTEulCkazlOtggac3j +YclbyhmfOMsKRy4HydfIqVnYwQog1mifAJSCsPGVYaVtFBc69voTtoyTVzvWKqv8nNg5vlGUNjCC +pZmviPBO4/t8MemmBeH2HDrNZyPylwmn0aJ99oEN4D2CFUMJgtv4jGDvwBPmReBZyLyIF15EkuAC +gjMIEM3B3eiPDsBD17J33pg9yb/u1RJax245VFnkbO8u0NJwRFVs15EoYJjjMxWOO5z/xCAujq/R +Qogui9KcKYLDjDmS2XgOddTUWSebEply1xe1MKU45C6hrvCOOTrbuNWjua3CAa/lW8lbK1lsaiKl +hill13Afec+I7/LCXQMyMNk32OWTnQPg8r1DnMkmu+erN2v2DwPHO4iA8/eQMDNLdhGXGO0jgo13 +EjNgw70E0Hg3MWy0nwCbuaP61R5bNry+j6aOOTpOQczOnC7dl8DPHfxb5a4Afob1NDCPxyljSMKS +SWs5Rt51SEwHFTAv/1Nx8iPIg2SkpW0FCVFxXjy4uiKf5jodHCNGixwGtFGRF9bQicah7YE9svnq +Hq8gV6oQEegieWcV8xKSopkvAB4Xs44tgyvO0B+QQAmBlxu0djSnNYfwg47zt4T/n733zk9kSRoA +9wLcARkECFe+ADk8SEISEshbnCSEFabfvPljf3uBPc5eY6+x19g0ZbJ8YXq6+z1mvukPVWVFZkaG +z4wMfCHPPGLDSBb42VyEgSpzzEsaP9VX0fAEOx9PaGHBm0B4HCBBV45wcIsIFtwU0Qn5n0PzFhTO +MojCeQbGB2AIRMA3EEP5SaG9GEPEBOgsdOEoOocn5SLwNDTqYA4C2oxB1jG6dg1ly7MJMEusKoGA +SiBxKqLEErNPOVq6mIxh4d6WgPa2aHgnBLqKEgi3hHTa3/Ap+ImELLqkEF73LqlKF71CLRvHV6TG +8b47SfOuiVxPNfOv9cqIWEOw3Co3gWr1BqAFbeE393tAQLokYF0VeFkHBeMagnTZBTxWQcNrasvE +Ix7fPAWvkkYltaSv4LXXuAH+Gxjp+kdwj1r3VcQAN2LoHF5WrB1hWT9kS25KYG6iEzQ8zONNUOiU +DUoUNeoKJW2eFfERIlhyDd39IL0RkG8r4vEhEw6MmFcT9uG3cH8ZppjYfwuv3eOAy6dN15+z38z8 +/TKAl3Vm5wzeO4w2RVUCiKA7fkV8ATo6p1smn3H4yuKIAFPiRVwThWLgYUx1yaUnWY/hEVg9/XcI +NGojgVYfSP1nPWiQtjTw+5OtHtPWdk4C3z2Brp6gUC6gHb3CrGbOkWxYFBXRUiuE7vQluqweingt +sc7TaWbuToF8BfDp+FyWjpGS4TMjLWuezkXNvlcTeva9LkTR4DM9TYNHepoBj4x0TT50TdnwHIWB +tiEqFqJujEP9WI0UrtV7PE0UaCPUE/RY4R3R8CReH/K60p3E25yKT3SFvUDja/bRNVKa6YpGRhYV +/tN9FTHAjWj75tAVBeToyh7tX7ZBWVinHcbg4B0yDMzDhOayFSPjKzMpCt3pC+01HXNQCYkPAXOI +MLWZIZkZ55eiawrsvxUZXI2A4OYFes4s0DM8hqstdUGskSBxrP4JUhd4aaQnApYpMALC0sDnVlcM +qnpOwMriNyMgcogCPq+nm0ZEP08DcrKrJTZ0UWbcecVZeElgXEdr6P5XgXH8mhdxyQ== + + + Ri21zdl1ZqGu4e0aQIU4n8RbxNxmljO3ab25LcQNdosQ10l3pGAI6S7EDXYL8Ui2W4ivIga4EUPn +st1C600t2p25HYGBQ1jWyStfnUXD7Ec7+yXC8TBFGgkQVP1A0K4oPAzOooJyCbXGB/E1jIlwjOPX +iTgOjWqvyJq378xCfQObHRZv09rd6ooJsuAT8V/YRpaqVnplMwHdCAQvUUfGBIdOoNIorJr1aOwL +6OCWPRobBDqmGitFJiIxrvytIaI4IfLQDTnyo4gBbsTQeVZyF8gxyuYvOREEnI/jaWrw4SDrWHgh +LK+QGPDcEzYkhgPGFL6MmuVMhAZNiBwROu46acfBamis49c8vBwBbz0u0Xdmob7R3n2cnWfbU0uA +km2rkCA2a+chQmS+6smQfOiaEDWDk0kRmpcLEaNs72vJUbZW3RKk7jyYaBVyxFBpgz8dN/Gn4wYP +JG7wQGQcEP40+UjypwW99yEQoNUHWn/aVsj//npJj+mf4U9rRTp2UIW4G3/a6ksX/rRTp9b+tOWX +i/vTtIk/raVlzdO5qFmSOVp6lvzpeSla8qdpoz9NG/1pLV2TD11TtkZG6f3pualb9qdpE3+advKn +FzRsefjn6/lwUBl3BtPO4CMSwY+RuUu+8JyP4Js4flPpzcC/F42vdnPqwRdMejPj2eTTe1Yf1D/a +Y2Aat9rjoP07L36Zrfd6HcCpo89OU2pZGw57MWBij6ZR78WPOvhtbArMAACCbM/btjdpikAUevWp +Y3sWtb+C6R3atgiEyQei1QfGtngiNG/8AizoxaBSn35qQGc/6+PmUJ0kaIVAmDSttf8z9eY6PzoA +4fZAawhEfdQeA7FZnY6H3TYYWBSvOSASzYqvmHIsEAMohEQK/BNiCf4fReH/ob+kM8h2o12oc5X8 +UNcM/K/gRUUucLf0T+mW1U2ZBf+VJ0z8d+X9YlRDbkDd8l5e1piJn92pgmPYKY06BLLQy2Ik0z+h +X1GHZNErzovkVXKAGU+Cccmcjogx5pWtGtwGNPcyMa/8X4ipmBehi44yimWzKOosRlTTSAjduBjK +fDg/bTCEdLNCEbw1wSuo44InbmhRgGeIYH4kuo0JHswUkfyDbgMaNeV21HNTQQK/ka9innhip4Ph +XwP0B9DZSK8HvbFzMA1v2BNLA33+oy2/jWWlHMNCpwdmBtsDGukMvLgBfoot3ZjUJAyMhdhNZ9Jp +9BBAI4TqtN7sLgVh3jFk6pNOU/0cLzImKe/F+/ukDRQabf299MFxrzdDl2EMx9H6aASQhhcHfNSW +0BfQAPWWASq9+fd3sHagda0zReAY1E/vYiw1BgO0u6U7hptJSwJGeeUBlCRSNCqTFYeHJNA9DSIX +FzQZe3E5UQ9m7sVRmTOahel9d2nz2CFoYIwe0thGj+Xa7949r8cbIIYD000Dx4NJB2aeKlft5TqT +Ua/+N/4ziJGJrx/Bn2LkyJ+FPXteNH/vngdgtD6emqxYptcetOZYcFt8ImAqOt0FUdX5q59bDN5m +HtnhoDXrTN3MgYSycg6A9LcidCp3y1xP2vkf7cFFqwXxgkhcRfJct71IBSaIXC/TWhPIx4Z1WVCE +Cl28Bw/psbB0LSNYlJtQ11EZ4D+cBv85U/LE8v9pN2dwCOgF+tZMn8H724S1UvuTlJpb4bBWRmtl +9CuUkZkGwjtDNNwEQZuPggiLHMJaE/i257UG+oUaiPnlGkhca6A/SQNdLXnFsoVTZUJya5dqrcV+ +S5dq7rvM1wrtD5/SXAotvlZof5pCE+JsHKXOMeD/8zAGmIjzLL7YlefgTQkw/18KT/P4ZhoKJoXA +anLWcUJmHShca7U/Rasl4vgqPY4R0R2TPKx0g06hwBzqxDpS+C9Xa4m1WvuT1No6UrjWRr+zNrKI +FFKSelkrm3+zsoHHJ9fKZq1s1spmrWx+lrJxk3uwVjr/uykZkh5+gdphf2+1889SGjDwxogUrImL +rr9D+0W0yHGc5nyeKDI8hwtGUyyKxInwNB//x20lLSix/ynylo7jW8cpWAYEXTaJJS/PmxTvmlPw +/nNk8FziiluLq/+tuFqqNNxaXP1J4kq6M4Fi4yzcGULSCl45KnBm13es5ZUbecWv5dXavFrLq59q +XsEL/mnVvGJFVPRvLa8WkVe/+eH4f5a8+oNiiH+uqFHlvuUP/F9Ud2kuubSWJg7S5Dc/6PzPkiZr +b+1PEUmrPsdE4+O5QJQl4qi4HS8mOAqXBKXiiRWkPP5L5df6XOtaAq7T39dbu3+kNkhwOFOJEUV4 +sSC6iTfB8CaXU673fP/wKc2l1NanWv8opfYHBQn+MK5Za6Ofm//OxFmWQ3Vg4X3ycWB7oTJ43Pqo +6787/12gfm8N9M/SH+uw0L82LMRiP4AWYckxWNqDoXFQiGM4YX0EaUHptT6o/0fJv7X9vLaff2ch +bm0/s0wCFmoB9rMoALUMDzVERYpjTaoLr+3nf5P9zKw10J+kgdbbEn+KPFkrsp+8LYFKxdAcx6Hb +ZWhYZgb5I3RcXN4f+adQ4T9nSnNptd88E22t1dZ+1Vod/TnqyOa2DemcOBNf38T7L/ekfvN0wrXO ++XfvZfyp0mStuH6yHwXeRzkOEDz2nwSGEdZ3efzL/affPNV0rcvW/tNaDf05asjKf4oyAgVsMK98 +PwAv8Cy/dqT+5Y7Ub57pt1Y+a+WzVj5/vPKBhyKAky/wXiWIxycS64yWf7ny+c3TNP9ZqgPG4OK8 +SMXhHq7Ax0UaHi4VKEpEsTchLjKokjUFr9SBT2i1eAgnUn9ikeF/0ZFi0+JP+ByxEKfwaTR8LRjD +cdTyMad/jhCeS2Ktc/D+OJkn8DzNCehiMRHWSje7T4aFBdUTWC7iCutxVARwXTBpbXf/EeLfae+B +pnFmX4Lj6Dj8xVE8z+GkEjrBCeujyf9uxSb+5ql9a8VmsqHOsVQCKq0EHxdE9IOO8xy06imOxWpM +jHMsDX/Q0JZnVKt+rdjWiu0foNgE6SZRNiEk0A1aXJxmKNRJNM7R9LrC7b9cr62TPv8ovbbe31ir +o99ZHVnvb3AsMKLR7jrPRCmGAh5VlKETzNqz+ndvcojrpM+1BlproLUG+okaiBPgRg8dp+gEKqcg +xKN0Ig738BLUWgH9WgVE//pageI6Q3OtgtYqaK2CfroKomhBZOHSMWKUE+M0KppIrXeX1iroN0/Y +XCuQ9RGtXyE2WQaJTZ6Jx9HZWE6A96yg0nbwpB63Pqe1mLhZ59T9UQILnU1lRBYlf3MUB42IKMwB +R4ey5GNaKDEcuLhQn4n4xNafdyb1D+O6tcX8vzieJayv2PqN7edfr85+8+qea3W2vu7kD2K9tU77 +H11iD09mxTkeEDs8e8xTnHzimGZXcI39P4UK/zlTmkun/eaZ5/88jbRO/vs3RZak5D8xTvMwsoRz +/4BTQa3rhywosH5qtrKpuLmCML3Z4XjQHk9WJW50QBURY7sWQP5cteuAdiF5zSZWLLhysSuJO9ff +/x6R83+udFoQP2uJopUo43H9b29pOO78dziYArZ6CoiMdzR9Cv5RNtGaOf/tzIm1Tm1cH0zeh+P+ +qlQUAdCdelLwM5W/rNSnYAyDiWRLYuU1adZ77dJrod4EvaM3FKV7V2mPm8B8Mn52Q3ymfDQeTuvT +9muu/TFutydBciToo3JngB/rO7ohO9KDuwI6to6HLiqKtz/8AYc3RY8T3tgxsPECg1k/Oxx1cB+c +9HDUGVSGHQU0Hs64/d4DLsW99mF90Br2O/9tmzW90wwNdn8jd//Pc8Zdie0iWOQBKbaLkrFNSO1q +pz/qKVJ7HnMe2/G4DxUw/A7dmGRhtUtOAJgJWHHroR8PgLXnLfaGf3l5oGjWamatZv44NaPSsL2e +yY2Ho+pnvTX8K1rvmCsYEpQ7DUNLwvVj+vfI3Gs3uVZE/wP/964+r4uvIvGj2UMaiJflcqM3wyop +KirPhqN6M4gZAY250Ru0/sViu9IZdL2Z9o9271/swPP/Kwf+J2FSio4Cs+5zVXjUgHSHRU4xh3qd +PrLPFJ57n0xJnvsaTEcuee5XhBhV0STwLIV3JZmESIoqmEsvBYMFkeOXk1u/z17OT0kItJzH2nZZ +b5Uiux56gvUxadhHKQbeRualWR4yHQvzhUV+9XeiYoFYmP33v397z+qT7qrEZ6ENBCfEt0sDSnEl +r2w10J9tkPxESl/rwd+WlaGPziEuZiwd9YUcoX8OY7iy1LHXtg5OrBX872Id/0RXfjE9DoMbXplP +loyCaGC5E/wmuGJ4Dp5hZOICPtOIsQT/6i6OnIkU54gwUVqQdcvncPxfzdmQUb2DWpGNfrTHcvQe +KaDmZIyCIbxif7Tq4y58IgAHx00YhXYOo/x7RfYjeFqf9abP9jHw+TgKnVaCh5N4RFEJAV1zKMYT +8MpSZabzHJI1D5L70seJ1/yglR5P0Wgn8AkPn7yeDweVMWjdGXxEIvhxpg34p1LvtafTNpKwlYab +cQYer8CHyAgDmHwOosW6+69H/9xTac6Hp8DtZ2falr5zRlcdEiDQdfqOEpzAs/DwcYIVaZbVhACk +766KGe9VuyV/mWATCc09ygmWY2C6AjlE9cv7dg8GWvHHAi+KtDbMoKT3kB+hfRDpG16kEpxIdkiz +HM9w2m9p5dvs33X503icRVENUaRoeDuTEa14OaQvM72ZjFAW/IeOIzxSbIIxXQjy07P6BzAG69LX +tMiIGKkcnYijdeF5/IMShDhCn8gLWGaqZ+1EgRMlkAfwjHjxgE14Mwccb1w0msXLHY/DKz7QK44R +0QXv8k2f8DQ5uvuTowFkCSzDigAsEwdgWUEPVhQAZhMILJDq2jXmeAAP5qYoo9WABY+KBwnKFCxP +8zSDLyiluYRmGRICvGkbtsFzB2ARFhSwcLQ0+BfApfRwWZHjRQguTicETapYNCFffCok8K0oUYYF +KGNluDwcLhx+5oBPyHBFhmU0o4vzIs8xWrgwKIZoHv5HvVlVhstA7LIIvawEF0ClNIOD2BUEbUcY +uXFRUqBaqDRaM0DxBFSeEXUCIi4kMC5VxHMJCieTSshlcMqBRGEcBZGQgIMVZLCAcHWcEucBE2lG +yzCQCCBcmcQYjGUMl0drFge+z4HIyYzICijDAcyLRfiLJ2hGwCycYNHFaZAGZGNChBkREjg0SA6u +lCCvVFxk42iQLOACODTQvYjCmAxLsXGcK8hRIk7BgKmCcYGERkFM8jJXiZzAohQNNSgq8iKnmTIt +L7cyZcwPGCgQfvKMaVoBCxGJZggECUpa5FiGFwgJC0cp4IvmwQ/DKAXI+zQvyvCouIioBqwbJZoK +M2AHwUmjGSAMQloDHfASWA5TPRwnw8hsCmiPgQfzAZtyGP0mQjLKcZB/IAJYsEo8OU6aheOMxyV4 +CfATXz5Eg7XlzMcpC1U6AVZHVNdeGqcA4HJo+pw8zIRAUwzSZ7ACeJzFX7MChVCiZA== + + + 0MgMxGLAEgMh/oHCCQxJRicrsEiHJICopszrAnCqUIaZPEhUSbxDQUYHCweHyCssCQgJQeR5ijeF +qIo5WYzyeMlklhRloU9zMkuyoF9cLCkKqJtHHE0BBOCFBnwnsQ8rHdXGkPg4gASnnJDh0BQQEAIW +uuj8N9BNrIgXHIosyKVIRpJolK6LluQQI+MxYRDGCTrB4UUBaBW1wlhRSVi2g57lHQVFI7FodRha +lpkCEHcMmjFDIboDRgfFa6hJ0cwCTpsCPxTdmUCEHkcMJM+fY4HsiSNaFoCohz8SQGZipcwlUHcQ +PbwkhThcDELGJ1THMCsT8rjMk7CEIloPHso3xEQih4UJA5eNVgQFXEZJdbCk4oR3FAPFCVc8LkMF +FMHRcCSAuJFooAAxC1iACMiIYBVBKa0Tg0U9hhmHQ0VcLsikyfBxhkZTpgQgi+FAE3GEA4oGhBQn +lYQAhwd74RhimaCeAAjgBcRFsiRmeVrKcwMGlpRKIIqII1nMDII0fQ4LIqXYhgRVgKxOI9UWZ2Sg +CYFH3Aza8Qi6mBDRoAFNsGgasmZjZT0v6SRSsyHFpohP8CVeD8hMcQHLJ0HkMJA4Eu6cXP6DkSmK +1q4VpFRkNChGDgfEIZLpQoIFVp8X2zsJyT6R1a7EpICvVIQm4MwxOmVscsB6p7AhBi93h2MEMgXx +LLDN8TpLI1QudKewYMYwETZZJI8xJxkStarD96kXOQLem87HADozQamBVejS9BsJOIBYqLfa3unQ +i90RJ1ja1ioU06iqDRx9exWS2REqG0C65qZIg36BFx3L67kHbPoRBB+ofs/q4/bEmx589IBbpQGD +//tIwHz2jgyfIHJB/ABpBGaKByrp89rFed5LA67OQpj/8eiewY9oiJ/63+gwQuXDreOIFT2U0Ir2 +FDhsNIg0sHKQrBIEYHFBQMDAQNqPli9r0P+Q5D6kVQbSv2KKiECH4MwkjmUpLPo4CstVYIQi1cEo +/5OsTWjT8FDY8bLyEMAAkPnGA0MbMQnP8YCTEEvS2PRm5THpf2CoIuJ06HaIilQGxhWya3gGMh8S +aXwcjQnIRhorFOV/pJkA/4VCU5ZvYDQ0UjBA/yCxBqQ9yyP5IAtneVD6HxJYBsli5MXBuvKS9BB4 +fHkAJSJRDJxkbHdSQM5hZ0j5n0ap8axGTwIXkEGuLzDDBQQJuEs8abcCW1S+h0P3Q4IrYv2L7BhR +lm4MjBsgl0kUxAR2eGncgepsKP+TiITikMkB9QP4V7ZkaCDC0XdxPoEdvzhQlVqjQx6Z/odsdVDI +U4NEzaiuJR/HbYEzTWH1CIxtrfeWkFSP9v/L/iqykDi43uBfmeVu2w1vdtgbQnk1nI0U5oO1qWjs +nApc3NxUZuQsccVTSJAWo8AqrgKjGqLAbWW1eBXwkqqmrWw5iLJZwkglryQKw6YeMiJEva3HMww2 +l4AdzouayI+lJ8/zNp58QtKYcQoQBKOFB/wL4BsgXUy4XBgeA+fNGsY316EWdXAM4gNRMUNkpwKI +jDjOigQcoY1Eidg+kIiWDDHQ8YRKuTSGWckoEUY5kKiGFsmYo+d8hKOT6I0cnyx3JlMy5Gp3JFnZ +TdMcgDOeBLbNRjFESNEIHIOkJjOhKfyq+ne/MexBMP+HJ1Aa9oEJECi1eyPw/zL1SbeNBg4Ue/Mz +CG2FH2BU0EwIXFWrsMmsB7DmjXivOh+fU/JBbvjXgPy73H7XvL8ekX9lgCnzV33cIp8VhmPp0cW4 +Af6+GNcHH7Dr6hTYGcTfmdl0OhwAYjI+Y8hntXpD2wg+0LTAHeGgI5h+66ONPoDrpTzQfIAfseCR +FB8Fg+s0u204PhSglQcLdXxQwjtYKRLr1qsnUVtu2Jz1AQnl6tO6x/cak//2JtFfxKYE/PvurHw+ +bLVNX+55A//p9wbgdaQ+nY47jdkUpyqAppjq/hcgVgCfaNX87PRaY4B71EY+5iC/hf9M/x618dvA +zmDy+qM+nuwRqc5k0x91uPa4LXw+sWgHc3txM2kkE81ffyh2BsNB2wViekNA4S03mJFbhn/tvBqd +QQsMlHYxN0Ac1fb0HE3CeX5k6xUt/5KYoG0x4Wr+nXqj13ZD+I6r+icxevKHa1aHTX8xRcPpNWeT +6bD/ayXZz6PD5KQON62hzgMs5pYcfzpfVOE1I7/NUP4JXDp5/+s31sa/mA0mvU7zT5fFAhdl6bhy +QtVqqp9t5EK4WGG55a+VwWBaFDxf6jCtvzotdIzXcVZSw187qQg+t+A0qf+4YsTfYDJuCO9vN5P5 ++1dPRjljZzWNxhB4vH3oZl+MO8BrdDMr4ze/gepHMq86nI2b7Qw8uboS8fdnO2aV8yLDFYbjft1K +QJIIfO/02raNNTRAtv61JE6ZvCXnNa2PP9pTYPbACMnkOOdmdsZv/ng33VESoDs3RnUArulKtmnb +/3IasJ9cZzBtj3v1prsABNn6F7tsWwX0Hxf824dXpaDdCTdTJFv/5ms3GJ7NNTVt+998cu/ozLg7 +slTb/gb61lm5/M9cW620/tWjGY6mnX7nv+g4+O8yJuAt/+oh9NvTeqs+rS87jsSS49hqSfsgbjiO +aKzRoenjauHWm+11Rt7a0JseTxtDuOeEmU+v8h3+1gMdjv5GG1sfY2jG6sQIbnM8aPZmQJzdnVW0 +i4Nf52YjYAzXpyg9pe1F+RyZ9mf9R0cWiIFOv/6hiRBIgOFjb3XWeB/2Wu2xV41R60Z5PWnrG5vP +nuE0Q6tCK50YFsozG8BdqRpYQ+8TRfGSWJ33O27B71jpu/ic3zESXhJzfkdrrVZXn0mhA3efTLxV +6SowRMJOrS2WjdF2BmgHUInlAOPmyHf4SlzoK2Ghr3hTHDp8xJmvscNXMkXN9ZFETgw111e0Gfs7 +fURpBanTR+b0ZN3cnKB0Ekz5pj71nuH8PIOMIdtcDzr/MRWFZKPbzqA1/GuiGyrRotPo9DrTv3UN +0CSkCakK27iEpdpZWWmApd9ZfVQeNpGqN2Nr8y9qpE9m2bqWu4WhvRIRtbQDXh0Bd2U8yfdH07+z +7V5vYoot7TfFIbylXEZNz1zS6+aANQ/4pq+ute24UEIeGSmwHRLQK9lqFTfknKernnZx/clNezwF +yrGnIwJNW3MS1itL9ImqqSV9iO9fQIgURBHWtzKOifiI8FJMqEHfEKCzPtW7FkR7VS2nJwYjYs8K +tHbaSjPlwIj2va7f/H9Gw/EUmkHKwgUez9qtzqzvvWpPhr2ZlC9JYI+mNcBnI2+hB102eKSpMm7D +ayxUy0O/DKySIzyqt/T2UR/djKJ5NBkN9ZRX73WkyYgyi7dGnaiWhprD3pjAiDc9mw69V/UJcMEU +eUjgIuEd1Udg/JNOf9YjJIK6qglvXTIUvU111ZV85kyv3W7BoOqNaq3KnJUdD0fpcbuOL1IwOHkB +9cQxjc60UZR0uA38wDsO2l9UNIg+Q/9Rl0aarNIb7ECmZTbOKjORFy9bH/yoT1T1IPA8y1vO10t7 +G+TMZMwBapDNbG93MGx2h7Op9wMfsLRp2gG0BW3cBkyBlsoNgIGqCeJwBGftyaeyaGhVCKLEX/AM +Rxh/hkEz3g90RstdW8U7ZynNOC5m0xGYlf1IGAIyGV0DI+i0AGHJaHYchYpmxxUhJufYVpkcrVkR +xLHjH21vrf2fqTff6kzrpJ6lVaFs5PtyffAxQ2JzOJLXW8ncL/aGjXrvqj2a9SakhiX4pTYcadmF +eIcOFxJvDY6YJkpSbfdK9SkY3jEM/h3nJgT1W7SEqr8HBRXZlmxQgxvusFez4WXQLgoxvgAN+DNK +sGOgmz4uzHo9GWdAdUE8gLfGZaC874oIbUK/tDmEByH+AxbtA3wjizt1fTVfjBFdRn604dXIXoD0 ++qBpwqjkJ4BJe51B2zsFi65XvglZnsNZXM7qkBi8ZXx1o93ARzIlDX+0xyN4qHFi/4E8iAm6F0VR +YDHihgXduusvYCAmWL0p3tVHug7Bw8rHu1Yag2e5Wk4v3gFx5ytV74XN0Bkv0CMX0pir5Jgpq1Y1 +Bb3O00ADianBwNjXsBEFzNtTbAaVtPTNRoAJ8fFUzbQMzeDM6r2efatJtzNqABrqBm2HNgYUMZ60 +4RzG7rqVRZKEtQDgFeAZNIetttW85C+Iue0pcgteI3EybBwP3odelU2JJcVLoVtRrT5Ca25YLJo0 +DAZDlaC9nQFizeGkIy+Ks7mEhmFjIhloDEWmspIEuLKSAKgpVkmxG8z6GZL1NboUt5bPpXvrwG7E +ylWnxDSKD38Ec7xgkAx9hJSE/iM3FiNEtEsc4MbWSDC2NWVKEle4mQ2ytPPGzZ0nrkUx/soZxw6i +QEkt8N62G7GbTqs9jJ0NgU5uP9szDJQVbQRZg1cDS06mvWgLd4GIWmZfB36En0nt1Sirm29GrT54 +3Ru4HtSo5Ro4Pg+pfEErdwmRDUejcRSFTKM9mJDgquV0KNszomjfcqy6+HGKtm+Lz17o7AnNGsK2 +fw2l0mb2zT51zUxlb6s96XwM6kYz1VRIN6SzF3YQUcMhPEHgol190uhM+/WRdVM4E7yK1sQB20jE +IS1KgrdCNHGkKs4xVq3I42QBwG+A1Vvext/e3Bh4aGN7uoPfq8Rss4zqSGwW0SRCZGiE3AnXSlMz +NiPA3jgK+dFuYONWdDj+iNoOXmojHYsmSmvoW6FSGzIsx3Y/bEaOGo168oEFM0rBbZqDiR1KQZsp +cHFkp9OUKj/63ehEvpnLpk0DOgMObZrj4ch6yO+DabTV0yyJaZvJrCHPijXraQKkm2Kjm45lEm10 +oNaxbTJof9TVMIVFo+YQiICBfZse3USxSYOC1bWbfNaBBdlWlbtpK+g1DNoTvW4nW/1nFNX4PmbI +Bm2gf2U9cNBgOGoOHRpMbKaOGrRmtqaRDQeDz+0ZGFjDAB2zQdOVQECt64OBHEUz9yFQKycp3OwT +giNwHa1GvTilFjgoLe9ToHp7UXkKen8wDmZKH6gGQn+YKSTQBhoanYGDdsPKZawzsKzEHqBaeDEh +DCna6DjYUjH4G+iyNjxO0UqYDMfQ4DPZR9A3fAekJ9+fiCIlpq2Qd2GMmBh6/QFPOY2cpbTUzkay +IinVHsB4hzvTC4s1RC/qQrr5BizaFF5xKY0lypjrcdgUKHxo1Gu1qPnQofvbAW6gQ7MxcdWfk8iG +QbNGfTyxQa4q/4EhRpiWLhor1qWLtmONgeDUmrQwBcvm/fq4O9GO2kVjZdQu2hKjdtGaHLWpAaiZ +42zSzg2bKAxnw8dYr47G70PDVpdBm/WhDJnYkwXQVO2pVg0hpWamAMZ6kYQ8RbOWH26EF9RaWHZN +yRiFTTscUnNQIhqON1W8WNdIbvtkYt0zEuo4/Nfs/20TOSIaDvHN9cagTlpuToZ15o1Dkxtd9R/t +M+A7dEa9dlobg4plOrIfnq5mj4/jfK4NBRh8yR1d7DyG9m8P/Hv1u/AJu3MRyaTGxQ== + + + /mfyY7BxUtgIB/zZTj062RauS3lhK5m6Lh6ecUfJ8pP/LDWeNcVCnjmL+2iO26KoSe4r9xGmtlN7 +L9Hd1H54NElNTpmYx5faK2+M5UYn08xH6bKc2ufa1Wzn4LCZi0b9H4auyq170J+YK/iS4kNxmvt6 +znAPkXC6PyxPwHSnn6FDYWtWyHHbt5mvnv/W48u9UycNU2DbYuJdvLl8fErXstEb607Jdsnn1H63 +8JxKTqL9UC7smxUCxda7x4eQVXh7vZjl3p9vxUwv1btLvmc+p9lP8YHWoONtJ9eky9+p/SP/LYYD +hjzJvny8DMGvne/ccet4IxOJf22nq5GtAR7DXb018/gSX4FQM9/kLwPZT+51bz/tY3dCmfPwWyiV +9V8Xsu3Z7uHNydbnXrNZ78JfnVD+vfyJe6apWF0cd7bfkp2Xk1am5zvyR8ahp1m6XN35huMPpvZO +PlmPT9i7eU6lB01/P3RwthcT+08HHVGMTd7Z9Lh5TIe6SVqB2MydTG4A2kR/W7xlqVayk43VwfrS +ZweBSLid6YmVPp7BfdmXyh7vb93mwwl+Atbl+FHYOhSzw5fQ/k3rMck0tp4R2MOBD0zoUNjdgkvy +KNwKlwOIp8NMNyhEJNK8aZUp+nnrLBer7+8UNkIPY9iLAF+8ICioicdHNTaPOfQ7dFjYl37t3+ZP +cfNsOP+GgTH3zDEg3TsqdHiYDzO5o48DCc7twf5e6+v8Ba2kMmAA7yLDS72ARpkTZQDP6gDowMEV +bNTm0DN+I5N7RajOtSdHnPAgfDXTtdxXKPceO/3O1+v+7YzQuL7cL+VeD9O1z+Y0XdlunqVrDAtW +Py0+32+Bb1oP+bu3o5mCIky1GjJ96arA4r3ouCQv2P0w917NtxA+Adh6MHS4tXeLVwhC9vjyr3To +JsPdnRRS4/HnNZc8uz1CKxTnO2MBLN5uOJQZJl70qNROnMS7jCe8sBCUx7cXOpgFCrkenaFO+CT4 +p0h1MJxDoTFM7dWmm+nayXRmRKVuJQm8ywt/N96Az2pAjn1HO2k9nmZXiXYhsDMKZj+Fq4d8g9rf +zbXH4zDVrhzsKQPB6FCQUS6mX09oRG37kbcC5NTTaO74S6xj3scLGq9+90/TFy+Zs0L2/SRO0aeN +ViHb6t8j4WmyBsVMTzi4VWEL0/LBQ6ZU2zrQjcHjA6NoX+SKXV8bdHW5DyUMS70nb4fG0erbNcGv +8LQ42mwkEqE97lyHkb1jYIlkO5OOAKVl5LHCBLeOS+qs9trJnT7g5KsgJK+z0MHJw4nc6ccTkGMs +eOsr7xanr61+uvp2kot1DgIFDODdXxLStbPhR+qmdlwv5OOXdx7ffojKPynoGOXDw3OmsCMk78Ca +zxL5Zvd7R+4AMUivjgXzzqO/DMTjgT991Rvtku0u6yUg/vycePW5G02f3lcHHh8hwuX3r6mauHOR +LX/XaI3K2N3Jvaf9LxodcFUovAY3PtE0gMwdtAFL8Q3dW2n14fuuRtMQX+8CJVoc5sO15gHA4uUt +YOy77dDhgcCit+lqODXIdjqXLTi1Ddikljs9LUUK+3k+iN7CuXzsDnDz2lnKl+mdUFG4Vo8qf4rx +o84ul7ppxMRK6eyKbrxcp9mdje08E9x+ydLFbDkFfx0CEqcPqHYjeUSHA9kj5dmhx6f9BrdEz+Cf +GSgUs+hD9KdQLTOX8O0B+lrpIAufZTCo9H6kIPKR3BXz+jDKwyb7QCbD5vBBTukqAxudq3BwL7A/ +LYiUMvhD5Ys91ASOpoKGhMYA5gLgpPFQ4DTxhOGgIHZq8NkeAqb2gkDoUQSHbNYp+lPCGIRY1SIT +fbMH36JpHKmoxI3h4DAWBx97lwoKqgifSi/7xFzUxTu0XVrXC6FbBo9PtxD4G4gsFTaaBsKTFh0H +aFbqnwiU0nNRHYPHp13LQzOSs10SPGT0S5kV7lT9E9OYKWG4IAvYuKzMSiUVPc3iuVgi6wDPFHGO +jI4Ddc6w8YUZUnWc6vEpKDzQTVPBSVIL4kg7mqz6LXqr61RaF5XvCIrRrOqhSrWoMcRE2oRV9pQR +VhThgYkUz6WA8IjAukU1MQZbekEoB6sP8ajAPjQTgGhqCmvOR4ZoQTDG9pUO0BivhDgdvEC/MPqV +mYrCTfQdCPAvVtJ7ifQgffX+cQrMytORTmGkazeng0KKprseX9FXfAU44QMCYZvMLn37hddpbTe1 +R1U2Qvmbu5KsyiLbhDlBWAV6L4lsBygZOgbYfAEqOES4ZnQCOCynGcEPTL/go6U3Je49lAtptrt9 +gvwA7YRCyEHw+OLDE0rMR8LvXO706Jsje8m8ttNXg+p1ujo97udD5VhA+7ZXSCV8I9mpuAqqzhfu +4Pix9p2+yGYq0IaRrKu+BjHAA4VWmHamhLEh7jWvr9Li08lV7mS8+2YGIM2Xno/Tp7eXwE6WRnbt +6xYnF+2xZPqVhQxQ209RxXeI2vsO9p4DtC5k3wECE8Xr5/Zp7v1yUo11Ko/AbM5/Z7G9zTKbj/bO +kKUr5PGRzpBKoXBq2MO+S18Ucl+3r9nOlxDbe+/7PoB9u0sDnBy+ieJVawgHF1HtI8mMrfaeVVCA +kiVg/yTPQthV4gGHuY9I8Ah3cMkevgFD7cKf/QzdZ2Odw4OktFZaPGl8kS4g+2hBdYSBHCPXoFJC +6AedslsweFDGNC8RJzEQK6di5xDTucoAlVIPeBaq/a+1/omBJrrt0yyYUCtUeHs9TOSK9+I7cMfz +DMUUuTM92MuN4JPOScE0lpe7fbvMvV+HikBOF3JMsJXHHIg8VagDElhwvezvdK34Siy8PO9uFfKD +2RvjS/Tj0urvh7djj3GxWT7JXFZSYC73/XPJwZ/d+9KX59WbQi7Ykl+oxD7cocTurFGhyqeNkeoj +62MOzEMXrEv282kjGTosvr7KlPUcBSsYPc10z0LAtK+8qzybhJGWl0yXOdhQXyiBACrZ6vcoqETO +IbYf1GgH8PhM+l51z9hSOidZdxS9DB3d1L/lDmpiau/0fhO4j58bWtgX6Wqx9QXW5WDMpK43EmgN +0AocBGZMG5LcO3oB5NjR52SGFjlxCYQq6OWlDkDUJvnXEd1I7V37o0SQjOF7m3vvs8pXunZdvwcd +JHtU4SnFgtGUIop01gcwPL5ErzB8t6IYWmlZk7mXBOaSe1kyomjPvxQjpHdyDa5ddeReYiCQez8A +JReCld5eIcc/MKHD++ddI0QXXj4Btkxwb6b8+onwCdblUDiZ5aJXrUgqef7VVVRUTdgsDLJSaBAQ +X2T0PezkYnd7KRmf/nbss/3yBvE5kQZXzB1IEvT2gIdqnsn0Lw6BFtMYHudc5mLGPgBUX03yoV3h +ndBYKt1BUhK2t77jqeTtd2fvvdT4SCXvCiQoLLGx755oeHxIY++H74USgk3obqklFQB++rQJ1u9h +L9ceXZSROSFslbkt+IzJndbONtXuxZteuQYU3dF2/pUaPOfea7l3jy8fHp7N0nwq/ZhvVnpBnbkk +RSY/fF0gUBOb4iR2fpOulVOQDRMR4+D3A6lxJDFLV65iz8nOS/wdrPjtLlgXwrzB6uggBiimvAsM +lKfrwuveZ0zfKXP43QeL/LGR+j5qttUXcK1m6Xhj9BGlSzdh6RlYYmCP1ba/I4XAMBHUvaIb5WNG +BaHoVzjk80im16feAb10H4TD5MV9am+UoI1Tk9rBdQEtxfjlcNeyEWqSbLUa38YmD5EclXjwF7Jt +oZuu5ep0phffilNM+LuTSl5c9tCCERLGQEVof+KgefcImCZ3lr6qpb6NtLE1yXYOziapZMFXF46E +u2L2PHtzpFiHgqRfxP1O8zF33LyqZLhbZmpY+JetDaA8qMtC4OSonCg9FaaSESwtYhQQ2qmwd7qd +fs99bD1zYnIUzQJzqLOrgkJWHwT23h5ConvcD277XiF17+cbsYeR1vLGI4vXdrarhdetnSqYX+gp +//I1baIYpBGfxWm+kdkNeHzJsxD7mK7VdjY0xHJ0rIAtS1EqiSzKWAjLfz5ZEEhpq5BNPwMTMXV8 +B+RYLlzjlZghHm2im87X0mLi6iPBvWX6YJIZyrIJVAR16CoFI4NwTTHPgBdWuznqpvYPR7dAV/YG +1I4JiHam65+eZLj7zevSwRPndzVTyczTQAlEn2Av3eNz4H7khyTfCakh1IYnMNYJpsuzW8BFeEio +IJJ0fOO8ELyvTNOn93SL6PTg9LyVa/UTYXLPAowsAKT8RfdDlb9YCA/fPnmCU5XdCyxwQ+fDr9x7 +4qSXa+x2fIny23i/kO4NNlE4VEcvYPXhVl7yPBt7yp2e7sewqcZcViOFPP0eKCTTV5vygt4GgOSv +xYSDQvowI/hGfO643vMZ5E+vEgS4eb6CsjSaOz3ezAJpqWWg/fCscl9IUdNXsOaDRmFjN0wDF/Ya +fpNgAOewb4ANj+IEWHY3EMTOpVgTX+S9q5RPu/smIWGvEDjupxOfT+dbhVzlrFrwjTggXG7bHyk2 +88CpvCiZQeCXamChPby0WN3KpsH/Sqn9SDRo2gtstFOEweIn0CjPGnlsq5vmApnrfGDSeIaChNYj +i5qEH9AKAMaN3Fv2Ui1nmOB7zRQE7T9pQZf5ND38vNglPSc7TkVkL3t8toSvBN8f0S4AXCsmV68W +n4q+4nMc0Et3RjSelgvPYPVT28gUQXuU0E4WUme56MXnPkG1h0J4WNgNhgVgBnE+4Eqkemizca+d +aN5IW3DCyTU5UzIEccQU9sKbqgNvoDFSbY9a74XAaTFBLjKi1cunLfiil642Ru/YW2SEzY9MfzP+ +RVhKqdLoW+ZKVb+gXm7Z/bq4d3lRSVdn14xRofDj3HG/MwFqK9MHI+wJhbczX8LaArhI7l8BjJ21 +ylvmyy3bFPHEMNbMN4aliEO72s7tc77+dryZ6Yd2CAUt0xhhfRyd34GV7hD79jpgBN8ZZgoVyvsr +WMTS7jcwuY/PZY2MxOfX2H9X2JmN2hlulgGeDvC0CZ8cNekH4kCCRvO9zNdXJZU7bl1OcyeBQAFu +gx7jfaN0r95HplF+unO8Ifd8MgPWuNF4LZtZsJIZO95qQboLpy93X4GGbPZpUhyfzKbU8WNxX8cP +0lyAgdKsJc9fGrPC2wvThzTGKpvpDyQpHbQzhPiHfI7x4KO6j0A53AVy7zujLWF6Oj0ovPaiMU0v +nZfwB1iNya6YfAlV4X5QSL8ubHDAAoOAq6c5v3+YoG9PY+l4cTKFxwaAQXdcv0tNgnebudOT5+9c +e/9lU10wZPO/cUBFv4+A+HiKCcnGxY7br+G3CeBclUqF1+lzpJDyt2vazTgBMQqWMLJjUAGqORX5 +jIP+wsXiQ7z2lG/U0re5D36no5NeiuCSZZaipbGckpYkj9bC40NbkNnPx/3vQrqSGiXPJrOhNjQo +CN904irXzNa7ud1OrCnus/l2/uH9OK+EJ1GTKuD4agHqpno6HoluwlhIEYkthLHKgw== + + + WHsrxQq5WRptS14Ci8MfyRUG6TOgP2vBTHdvPyIZKDqIH0DAVWe1lnpwA0tDCejlZoYPFmJAjrWS +uQ9CWkrva1sSliXcXaevhuU34fA72CVdZojjjH+/nA8/Z4C/LzB9NTiLkAV071MHYOzwe/ck17hr +XwFuOywV719Hb0hGKuxjgXllcaQ44QEQ4JHCljC+LB0B0+cIiOjT7wwakhwdZS4DU0hP+8J1pRUD +nHodLvjoAPCbL6/CuZONd4qcAW48ooWb7/c0UgkFX1lM6mArjQGNFXYePga59+FzCIWOTOPXkqjP +xGF0uFacRUcv6dOHYFxdfXgEwJ9vzjZf4hcltpZgwyd7hdfwTVI3FwVOLT/UqW0tnLfsx2fBD3e9 +45ohKwBGQjE9/J7E4OmOi9xz536L3K1WBUDypH5zps5f40ZfAvv3rOAv+gqlvuIWAQfpdjuaOwlt +8WTPvel2vtkIt+ApglvmSHra39yBC/8K7bV9TaT7WUztvURm6VpWfAVeZwt42LFIPT1Mtwvq4DAU +NpDeS+09X2fEwXGNzj1/PDPA36/2UjEZGJAXlRbgv84+mLDGFM0XdorlkXocKbqxk7gRhJPOh1CL +3D8w+Y1IJvY5aNW3Ex+3YzDWEsxAztDZzsajH/BLaLf5naO2IwOk3vmN7C4NfIL+JjD3rxtFGDn1 +0ez/eaicsmNg0qT3YgSPHE68OXSp14IZqp1BtzeZRpvDmXxQO/D//d//z/T//b/sTwJLn02a4/fx +t/YA4PGg64UVUoiTf4F0a9hoeyu5gpQ2CA8RD/Hw9YmW5MzUJDhRTKiXnOhaqdcfOKblHfd6M3R8 +eDj2EgXX583IMz0JCicPZviK7gmBZXTwTfg26Znar13eUWB2dFPu+mw4GDY/x8N+W+3/tCNfP2J6 +iFf+9AIlohXAt+nx9K/huJshzvOaH5K161U/atNsD/c58BaTZtDIEdbgpQGDaQVnJcClqgx7HTnN +aL6Zl9UMQ95yrVzca2E3aEQkWXTQF55ZJgc7f76JPBM15x9zmUqxnC3FwgVUlw5dX5NuDH/Y497d +fQeCE6Nk1YPbKqU6pCFoVx5gsYWSLY5bgAI67x0ll9120rCykzW9zkcxV+pJeYaxoHQz2eAS1abY +km51cNOrdqrzdCrfLJJujoeN+rRc/7s9dpfF6MCdElm6kiqmJDLfAtXssvfkoUrDQzds6ZnSBROY +XoVhh1y4LFYL6mZRCGUG73wBS5Ctj/DNLx25f4Z35MAamHOVvFDJGq/EtSnW6QGO15S4pJwrnOrz +t30mvNy6Oq0D+2psk8cpT6I27vTPYNaKdSKmih/DpXW0rSqszhqQ8IaD6RXUCW5RWiYTjyynWBvX +RyM518N+YSFpGdbVngwyZKaUZVNJxdQMV4/bEaxyf4fzHK8nbZRAUiOSewO1T0DwXtCbd/rZ9kpZ +5N6JfK/cX5/tgXeCrw+sD7ykjQf52VufwMeqCSpfYBVFt7VNEXAtsL+HM+8ImB9eoNXbmLVQ1xjc +R70zgLeIEB2FvaAz5dMBWFJYmnkEbzD3dtCVI3Vvr/43vFcLrCG6GxZaDJNZ8xMO73iQQzn+Khjc +2wBQzQyMbviudt+ZeGeD7gCI86g7PgKgm+POyJ0FWYQ8W5+2a5+zfmNQ7/Tssuc0NOxKxIKxAGSi +yZPS1ZbigI11227cdNp/uR0KoY7t5opZryNfkuPET6ZqyG7kQIARcsZRt5uZ7FbZlXpZdutwBYGi +OoDqP1ayLBczs9wpNrPZ2KMAYxco7LkGR1DUuW3Otao90f0nEGvGe0B1H3CoBylPUfFywUNsX2cV +31ALBfoHuvS2UX3Q1t3ZVL0pQkWhDoJRX+QHYN7k7QbKXVjwEpuLAXHHpRaa9jJUVn0JRtzsaNIj +CZBgmZQbqsiLt+CNi6ft8UBrrYEX6FJR85H3G4ABkV9k7AnJYHRfG7wK1HQCWINOlbnvGd34PaWa +rrbCKlxhXHkVIkl+50ErTz4xzRQMHfJvYujophGjYqGzUOjoc8rCXwy3f5lklReXyi/0Yo89qk0z +ufdEsVvaujqo596p+0PlLRM6uBI+N4Js6WAjEvNfeXwbocPu/kbw/CGxEf7sgFdv79GN0CxZ3Qif +3eU2ItQZQ8UO7gOoe34jG7zkJszkDAwu1+WOLt4O2UycjQsPQv8BZe+gI6rqW6r02s56fOPx4UEj +HR6dn6ROE5PDeGn/NloYPnA3+fHTA5V7KNzXCgfpgya9mxYHUi/s9mUoG9m9Av2VBavp4glF2XJi +G+4j6RuVJ+Px3qQGOgkfUzGuiqehjmwSL0xvmJdhd4dq7dCo5wsV7PiZmuwD2PFZ6LC4sYMmjtYl +143GJvEiF//e+wJ/Fnvg6/ucttOn8fPZ06V5p0XxhU8ev0RNO33ZPi97fLpu1U6FzmnRZ97p/kZg +PKF9Y/NOK/QTt8kkd9VOPT6124k/fBax6JT/DNT993nzTrngU2if+TCf6WbhhfP4tq5HvbLZXKlC +5jRl0amwtT0YBw8sOr1/oQrv51W1U5RZq3Rb3NjfoU9ea6adFktMzRK9zMNh7Q11Cmixkdeu6S2g +5KfZYRl2GzSuauCefezRQdApNzSQUpnKSJ1W/H5dpzzffx2pnaqUjLt9HT9/DmoWnabqgljYpk07 +fTl6u7LqtOTxbbOBvSfzue5vPE+2PttX5p1eZoOH39v9slmnob1e8lDtFKyLlpR2jx5SF+adcvf3 +VCFBnZt2uln4ELev+syFWaceH1V4fi5YzFXY8nUHZ1mrTutUMfx2Y95pkUr72wHxHnXq8ekRPN0K +H0md3kcCOgQfnXMHEnrzT92CptOHfaosRmjY6a6uU49vsllqD4WreoQB3YojPf2WHx/qFp0KW2K3 +VXix6jRHne0+J1CnaNddO9fj72Tqa3x+Zdppdc/PWnZ62q6ylFmnUPJzjxGq+hrcNJvrZPO01D5/ +fAgGTDu98Q8+LDutfl6+NVCnHp9xro9F6uZ0tG/eaZn1XRdS+wfmnY5ONs06BTIZdnvzWtycWiD4 +8YK6PTrNmXd6dph/fbl8fjbt9Pmie4w6hfrFONeve75VsOj0KU49T3oR807Pv0b9i0Sc1XUKekHd +vh5HBpYIHvuqoQ2LTu+vqXynf2Laafw8srmReo4AOQa6TX7rmWb2Kr5KnTbYoI5pgg/l+i7qlPEf +BkramZapt91kGnYaVjsFvcBuAdivb1noH4z1nU6GOwdSp9OjkG6mG0/1xyDuNHNPH2sFYXg8uT7c +AL2AbqNGqXQcQXMFnWanBlFY2hRwp0f0aUQnCMMj7hxrGnY7mT1FncJepG63x+N6YwA7pXSdjsfp +9lCm35MNXacT/ispaZqj5GVUh97NYfut5pHsh3b9VdAOqnS98zJMWr69v6T7N1ZvP6nSm2+mvjVI +fiB6czsWX4M12All5XF9tUXdWyFOv9akt5Nu3MCVwuBz887sPRaKlePkk+XbOLN79Wb99rP+4lcw +ZnyfZnYempZvy6HBEWP9tnHxvqe+1WFM2LrYbDZKFl/HSzul/esJfvvu/07ovr0OdWTj9J3eTBow +dt04qQ7M3mMplwt1x5Zvb32N2Ib126dc8kDGmMn7N9+LuG359mtaGZUs33ZvmMyl+taAsX63cPhi +9TUY0uUeb/n2hOEO76wx5msOGtWy1dc7GzvHT7uWb/Pps0bb8u0Jc7RJW2MsvcFsB5MWb/kSlT/Y +leecDOzp3oZql5Mj6W02uq/nylLtrbibVt9zEy58pfXAslTL/5iV5M+brwffjiR3tPDKY9GTGU7O +8S+NHGOm29DDzG5EThL3wMP8qsF/ovBZYSOcu8rCf26R/6Z4b1hGSP3VrzKy5BtvMv6DSkSS58DP +0dhjh1usH3x40ke8AT0dgiNiZ/GBH/ixdzMgWjd3QH/v+0p/W7HOQSMIpNNmfjx7i0Y04na86fGp +3SJPx6JTYQv6OY/mnXL3D5adAiXyRevsMXKuyNOx7BSqvKZVpy2yU64KfGSi2/h5pkp02trZ2VI7 +Rda/0imrQy+0/pWZFnuaToP3yHslu9Ug+ICx7BRZ/xadAn8QWP8vaqdgLpq5Plt2ChA84aw7hda/ +ZaceH7T/P83nur8Rteu07LfsFNkUaqeQ9zXdQpuiplnVdkLuHv2SFiKYfWj13bR7mfUHJO9btBS2 +vl/ydxeO7fhPie4kaZEBc35KS9LSwLpvgT7EzhURoDkszMaScNmppnQcH+tsJcPqP4ejQKsmOetQ +JmF//3AU3B8pEAMIxGGitP2FRnGYKD7mgOCq52HPrCqapO4P8z7pn/DZUOoAmcByB4ptCcYDJncw +wo100Scg9jKxz3bOp/xzRVrMUszsQmmcg70Uyem+nRxJMSUw5OsKeLADDdrZrowdbLdL4piYQWVH +i0Al4gYGTJ3wPh/6BxLkrdZLMhtUN3GsGxQ5pNeZH5DuWZjxH1FEHE0XDkQoB9LyeZY5dUI6/Eca +PHbmTebn37Ccn8enzhD9Y7mC8vpVN53Xb0uZ365EY2YzhMbrtQ2y3K/fENEn9ixcIssGGL2b+SpY +gvK4IXcZWXuRuShLpSuNRsaUVXz6nh/zpngHxs2DRMlLY57JPCRO7PHusUaWVvQEjaLnJa8VPayl +6PE4kW7+6XhMIlAZsgaBO1j0mOPuBd5AIyPYYjzhfBj/I+GOHpjj7j6yYSm2rbgSxeNMp3a/Of/U +SC2GJsce3dTOnFBdPN2RdhNMB5IL6WZFajFiVu1KdEdafYMYzYNeboZzTchMwgDaAe7cHYFbhQ1J +On8L7oDB3eUslik8ouvb/hIaA47zL4gYylpLfw5DBzLlEJSMgjrmwGi3wMxAIbwTuzy7Rr6rF9zy +nT3XAV1Z37yb2a7lFh2+psPwn8cQsUlhIAsgGQP5U7PlBBgjFxT+AxZUDUQbaQPMT5GCRtq4uFSG +RIwLzWVaNB3ZYbExsZpkimpPr2MGK8y4JKrHdxYyLkmr6GSFuRU93fjE47NUTC5sRrUxsGYep5Zq +yeObZ32LECel+a0nM95vFbVy2gRZZ0NV8doMaXp0YqkrL66k8bgx6cCQrA06eek8PncrCLx8W8PC +yebXrODAZ2tYzLF+xUpfBYUpeQlg1YGLcQGudAVMq1DmHZe8wysBu7d3YuaZJGnVLY2x1/EKMaaV +aHOOa6SNw7yJY4PjOj2cLGgda/ZfwHhKZs6glUFrqqCZzN3nhoMcIwxsc66cHm2ujCszd9/b8znK +eD/WsJIluGVSVnEDPfH5sXO/uePW+VBsSz12DieKWnYMI5gbhiWdUDDlF+dlOpzYu3i6gUiUbByK +gxRwNRCdbbkYThzYnhgI9pFDFirqowRD149z+OR4U1J7yEg528M8TxpRIqANfh1Dms/P0YFFUANY +ghs2Noyp+LBgkGN7s8Pjm2dQWwsKAK20hCz3PPXZq2W3AuBYFQBu/X3r+fldoNzjDg== + + + 6RpbwTmeobfk1Vjf1zHc1LtdBVHlpnT+eVJUJYPmLJyp42PhkwPa/2Td0qe0Y2WHLPcsbun2IC8J +IGtOFtcgS2Fx9AW7nejGtAx+AueiZXFTr9s5ugSodtNdhMQulnCiD8nqR2MXktVFSPonWgvewil2 +DsmCqRGMJK3+3GGSE3gu4cxteEPxkvRDOZlp1fIC4Q1AB98MmhA6qWJYLfdrpdOpFnEfj88uStc/ +gZu790vFfSBanGN9OlFgEa+B2BFcUTIhNzWRhpHGlE7N9KY0oAPrYKIkk10Y0xDLp3pTeh7cYXsM +jcdnPx638QX26Fr06yiC8MXmUoSnOkt4MX5JXgbtp+ZM56eq8lP0ywLR6NGpXu9ZTcjjs6F0QDta +pbeIADi69vEehzV3h5hXhyC9R6fqrGxZgB2donPSQ6Qti+dCqDq4WeUnz2/AWYFnbojBkusISs6C +8UTni3kb53xXNdN22l1R11uQAJhVvNUs2oo9C6t4KwQ2B/OZ+0uAaTy+pTcp0KrZqzyPazhaR3K+ +0Uh74hjOshyIoSjepApFlsnzwJlf7yn+vgkwzQ7hfEpUuz/oR9ZFOKC1OLPomOpKdhiy6PCpx+fM +hi7UDQTGROfe47MwIuBZzl1XqCTMz+S3RovpJdqkGzRItElXv4HnQqKZRkiyADGp72Ul2rUq0WTv +dR4LXg/MWaJ5XO4gQWCLSzSFK4s3wxVINLBqZhJtbt4HcOaXaIbYBYazvESDUJbfe0VwbHaDwpmA +sosT8/jMrAGNEroZ2nnQ5NahuY3Cha+05y2Bz2OIjcNny27Ayvrl3f9tLYZcWmZZwOcXUzNmxhH4 ++cQsAHazMZeQ9fgsxeyCpx+0zHyDfGmNJ76IgQJWTXeoyUrCOMNxZ9pbQkFxGABn+SMQCIqFQ63b +eXeGo910dxleNtlNQMBWEavGuhDMLwStC602BE8jy9j3BJHWN68mS3t8d7duo1lE7MJSG97OZd/b +x2AhsOXt+6dvM104rxaDqzZ/SMuoxSCcZex7AoqiCxfXYgiOiX1vBkXxXi3guNWG9roQSZin76W1 +oUYXvur3iVEv4OlKjiNB+WN6DkvSlZrDU+oxDEtb4HVssyQkKsMudt/u7paJVevi/ADYstxNjMuE +t+3PWttgzJW5K68k7MXKIwJrGXXF5za7p1mAz5uYTeTKxXE63ZAsKQKd7XFkL71iykYjBrWUjcZc ++ZUuFBOTuWtZHs+zPrlm4e+DkTHuUOmCuRqT1Z22BcAs926UaI/bA/UAGLu9d1peRYQEYEycz8Sw +OIMIV/I16ioGi4FZMPu97eFbTBEeOX7valAuKcLAXJJGxqyr6rND/mxg6llIa4Cy5SYfG5HB5etG ++OYlvxFJsy8wby5vlkGHb25ZPoeO1GLGDDpdxtDCOXT2GXRIJq8gh86yU5RBZ5ktOGcOnX0GHZkt +uEwOnX0GncbqWyKHzj6DTpMtuEQOnX0GnU224Fw5dPYZdChbcAU5dPbtpNzqpXPoDIyryaBTPIsl +c+jsM+iQPeacQ6c5kGyTYVbxF8ysbesz8NaZQLrDLi6GZBrpzTkf3N51ly9V0PnICx+GzemtX5Pg +gNtI72NOq+3nWzpijy+nP7CxMJ72djXkqs0VVXR8wE0yWPurfeMURNHu8dkBsz+H5W5+KNbnlDnn +en66yJWRX9wjPTb/kCwyHx0iV3ZDMkuZg3OZK2nOlazJ646CqGd75kugms51FASfHzM9DDJ/2Ngq +aIxuBls6XnUf2bKfmsdlspv2JOS8gUFEyWDNl40Y42Q3q20brZfklOxm7Z/abzgQ0jJvexhE45o6 +uSF5XTaDJlPYHTDtESzauGPTYL6dMh/dyax6YS6nF3GlldvbYK2PUM6VYopy385cZh06+/YAWWZ7 +2Yo9ZgydOQUOu/GRLkwCvr02PTS7wI5V0dLssswCIywlfR6Yo9nlOo9v5nQGfo48voZT/suWJmhl +nZpmnQRjb0obz8D7Dz63rAaVMkvRtF4/xzPwrk8RtIraCKbp+rnN44uPnXJi7IhBezodAltZhuhY +3fmwykyZB5gzxbvHmDbAuiTGHNNE3U9SlWgLYUwb+GUyd/cR7UGnku5gvUkmlztb1hDzNbpZCqtf +mcct7fPldCAsAHQ3tRrZBMQb80LDf95subvkwtlTPD4HZ++j5NrZswKgP6O4AAinq1HAOiu3arhL +lVtohV4pZ/0imzTmbAFT3JyDDB7bkDTMSrNw4gxkb5cj53FIc3ax5YkmZH/licfgXtnYkcmJ4Sh/ +IDd1gXJiZ8SKkr+O5wvvmLhK2FJySJAzSB3rjKipqTZfwB47dsvxKr9b2mNfx/OFd6zT7PQniBbG +06dDpMGjcyWsSWDOiIxmSJp8ZDAoZp7wh82QtMzsrMVs8MS5HZL96XTnpDi7Ienv7ojq4r84JWkV +EZkTFJFZ8pQasIS3XURkpD0+h/Sc7WR0Z5mIDOHvnywfkQEAAjanO+ZIQ1skImPIFlw+IgPT0HQR +GauMVKf8PG6uiIxpnP/ERXqOu+QcmKIHGM6Zkt0d34OlOiitsXyqGsvW58bdGMvs0XVoywUx2Ock +jk5Xc5IBrkvy0r+aoA6YWjLgcKbXTRraggfYSf0CE8iso0tzpI8Zji6YZgs65dXNfWjWeEIV5dW5 +PK9nm1dHpI7aZAo7B0FPbS+pIriXsC1tj+pVjHeRwmcuFZ2c8251MGk1+XCwl1WcqbPPh5v//rFF +8uHMTkFX+qvOh1siz2KOfDi7E6qry4eDUeslOdBFPpzJjaCWSVyL58NpTkPJ3/hXnQ+nv3cUZ8St +Oh/O8ZaAleTDaXasXBy1XCwfTu+LWW3rwEy25TProYJb2ZlIAEp7JtLKtnRzJvJm6OpMpBPvT7rs +smZAFh2QWD4bHcEJO62+Szhu8kgsoWB7DMFZQSaX4SSDzRl4Z4kGk+usA2LG885ELRuLE8/+713D +iWf/t8NC6JjQMtpzd7MMG6rJR0RUYVk2BMBsr5Uxk2OWbHg/csuGNtY4xPd8/qIpoa3mNmAEZz72 +schHBnBWkgiZi7nTYo5wrK8EtrhNy+qYtfFKYMfb0LRRad1tjcGwMYYFk8/sL3ZydKiVjFR6c9ED +IsScrS4WXigjtb756iKJ1GVGan2z4SZk4JDqt5KM1Kfv1WSkQjiryEiF+WLLZ6RCKKvISIVw3F0D +rXOJzc71IQaxvjR17kNGwYi0+lo2vFuaDXWpcOZybNWpcOg8v+2JnlWkwpmuy8pT4RaPW2oxZu+7 +z+FXLpEKR95BhJLhfkoqnElU4SekwpnHx1z6Z/d2hiEpCsj7k+0Snz4tz6q6uRFea49low5ukduD +XhAU7yqi6CKADIFZ32w3pw1juGR43s0FIhv93uUWjt3tvECUm6k8tRfn5GZ9Xt2T5XU4euUgR0dN +1IPKv7BqXNisP2kNUInLw4vPYu+m/prbas3yhcR26qVQO6zkU7GpH0j+Qu1IvEdlw3MP+XEqXRJq +J9lMtJnNZmKnsAhBdSSrI19PO2Qp4qTNxTLLOoNekpSj9Giddxa/TFZI8tImu+01L87I4DPRKf+5 +69vfGFpl2HH3d3bJbq2YZadUoZaxy7DzXXTO6ladvtl0WowkiE71uVjJ0ISIwumT3bi7z7JSmVCX +ArYZsEt2o6O6TrX1+Pb6Vhl2wtbWtzB7skp2e7TLOuvbZ9gNazXLTnfK7c+WVadt+3p8l3fWnebP +H4uW6N0esHuvVp1eajPs0KoChpVmjX5JdJ502W7PrB2OKmhack9lVxC5YAW3k1RnWTAxRM9lL+mw +MOvpFapd7NjFkVutBRsa4Llo9ogqO8PVpPY4n1DVR02s61h9uxgSsS9mMyinw6lO5zyw97rKSnJm +ZUdM7lRxEV2yqyQ3VxTuMef6iKRDNiS6E3KOc31OReRsz/W5pyeHInKW8zOr++ZUbMTt/JxrDbhG +ulOdEd1dakvUj3PPL8W2dSEiy+OubgvQ2Ud6F8mmWywOM282nZkfINfiXF02ncv7YZbMpjOLCer5 +ZflsOrNcukUzH62z6cxi8eYn7ZfJptOgReJZ0/vHlsqmMwPlcEPIAtl0C2rkObPpzPZpFF25smw6 +s1w60t9fTTadWS6dy7M9c2TTmcXa5Qrsq8umM1tdFOldaTadmXFDnh1dTTadWS6dxW3zS2TTGYf0 +uWVtKS2aTWdmnHp8q86mM1s/k9NQS2bT6UE51hReKJvOyrZcbTade4wtk02nA6XfE19RNt1CGJs7 +m842x2pl2XTmudWrzqYzAwB6WXE2ndluie4M/Aqy6czEg9Z7XUU2ncPOyIqy6Zz1yyqy6cyQoVrj +q8qmc8rkWk02nVkunWU9vuUdwIjqAGrqi811dZN1FS9jkUp9bQ6XiU/fDsyuQT43tKpls3i9OsOQ +pnCXZ9X16qytC3d4mob8c+FJxZLmJCTMyXQ0LFySgCZBwSLr2WpQuiG5FQUuqstpN6YWGhLEGBjU +XGWX7YZkfpDCUsLY4Mmm7LKFyIRaTOsRHdEnE51HxG4nRg6Fze0jc0q1LLtCd0uXuSPuuXJpki9S +5s6yutypq1wll2XurDK53CXSuTogYX8+WS10t9xaFe9HbqrM2EapXJW5c4woQsQsXeZOsmHsC90t +XeYO5745FLpzt3k0Ol3BPVfs0TVtv4ju8yxOV3ZEaXSqmtwL5/KAqR0E3dKn5S4PLFDnePbQiT5h +Gh10nm0j8K4S6dycaPY4ZxhaH+JwnV8IerE5djjHITKIHcvQn5aS3VXYAj1v+fX5RPDSVMs5m90N +ZbXfU6z0F0zs0pyGAkTlcB7c9WkoAMrx/Jjr01AAmLsT3fYHm5HsW0nm4/JbIbCioM114NLqu4Tj +qrarGRTiZFd1FRyIoBgy2U0zhZ1z2REwV4m1VjUg9Im11YExsbY6WN2tgBDYSgoZIxoDo3UjzEjd +ZYnKmhkqHeu92p2h3jVu6cJMPOMJaltP3OoMdXvSXUlminLz8fyWhBFUebaqCobgRcV6i9g171/P +VajaavcNFl5b2pzAUOxOdc4BZwW3BGA4y1arxlBkJjS74XC+s6rXLhIZ5trhDYZM2PDGRSKDqwj8 +0hXu5PxKqxp3C7ChyeGKRetWz1fhzi7zcQk2lAlNqnC3kkp5jvlE7irlLZtPpFTKW54NbSrcafOS +3OSHLFLhzq7eK6xxN3+FO7e3msPsp+UTa5++VTPHynt1nVgLgDmbOR43hg6uTbdYYq0+85FfNn4E +8wvPTNOh57vnCsFZQG4a7oiAcFaSz3lGufPFHOFY58Lqkpg8TtdMoHJ58+S3myUxkbuiUECEDWyY +DDgshIu4llz3zWUak5skJv/Bi94TJbSYmzQm7SQdYqcqKGVdLNOYkgFXGeq2brvClcmAG650k8Tk +Pxjoje9F/cq7uZKYrE4QwdqJNpp2PsPwTsrhXeJWfp1haHJZ4t09rgGxihzXbNT6Vg== + + + Mei/zFuRbq5yjwiV1vbY/equprpHu28rynG9t7yaan4bpjGZq9yjQ6W82II5rgR/KscwXGQ9O+e4 +giG5znq2y3GVIkBwIcqieX+y6Qcz3koHtVyXzmZiJ7e5rfZJ1ePLHYWqtYPhW0gAv4oVlN1XuHsq +tBj/4WYOKx4U2iVix9IvTRLe+dEV2akmH87jm2zd3FfIUJW2Dlsy+3hvkQ8XtE7CG8/ekrRWJuvS +8Khdq9w/YWtbvAo+WyXhPVl2CuayWRixlnOlilsP15ad+o8b0Q+rOmxBtVMlk0tFcIVniE61qWkT +v7ij1hFkdVmOwcDRY8+sU48PIlhfc06ThlfX5/6R6D3dr1h0Kmz5uPPcmxqD1WfEvdp0WtwWrDst +Xm49mHWK6r7FS5rUSn2nV3Z1BE9vrDvN568LmpNdoNtt+D6s/JKSMGe7BzHt6lu0Y7OUZTsyv5J6 +202mXUAMJYfTvKomwZzvOb3RqWzWSNEerfLM2sSJFUXn8tgkQCofRLtBmipmzgcnXehmAPtAn9jk +GCGxTkkyHq2yHBKkZOtBZd2kNjknNk1WVZkFBXQdKrO4jSTl7I9WWS6doTIL6KA6zxE0u6w73c2T +S2SlOZzQxFjyuKMn3abXvPNTotYw727uKosWQzKc0tLzi2ukz3VKy+OzG5R1nHi+IQFpaX1OSxqP +4WysTlzlnw53tZvXeWPNlMVcCQD72MXV1w4x2Jf8qi5vvI9suLvh0EU2km142e0uz0t+mZto1ZxE +w5VxCyW7mW9Zz3Wv9Ut+wciy9hZNmAW47CW0ZnfFWeaLOXktxrvibBwg8/iY9tCIyRZrvTBXvQNr +CVNYmY9cL+glzKK73jjhzoqP0Y6Vc/k6zcj0cX7nkB2qx2cZVeG+DQcIuvHx/PaIRe0n/8Gd9ebg +fIlkhnoWS5Rls89kmivHKjHXPQfEkHT5L62iXezY0RrXDIk4qi/tVhNcO2cqYHfbRSonec+VTSqg +U0ljh/VTd95bRedEHdfEoKtrbFplZg5gTlV0/PrsWhtgOq2yHMYcc3ncT1K7c7kkxhzr6cyFsTL3 +ZAHMkC5sZh1KGFswC9BtDqDre0isEsRc5QDanE53kQXoNgfQGE+eJwvQbQ4gecPh/FmAbnMAUdR6 +4SxADanYeJj6c7DzZQG6zQGEGFs8C1DFp73c0OZYzZsF6DYHUPGRF8oCtBiSIQeQ3K/E4zHOavmi +fO4rsi1TlI+Yy08symeIKvyUonxOFdlWU5QP54zYGyjLF+Xz+EyswpUX5TPWR/4ZRfms6yOvsiif +q/qVyxTlI6MKcFCC5aAkFDmlBltX9Vv+bqiTVdwN5bKun6u7oZau60dMbQV3Q1nV9ZvvnNKidf3s +q/otdDeUSV0/+6iQuSc+f10/c+KzvRtqgbp+zpS8irp+9idDlMjVknX9nDK5VhTQta3q5/HNFdC1 +rOtnPzVd7GLhun6agRiq+i1QAcS0rp/9hMxOqC5S1880HdHuVnP3iHGdKWt6F/QCdf3sb/5S9sSX +rOtnq+iySIutoK6ffVh4rhuobOr62bu6pqegF6jrZ5YmqbLecvX4VpDzPlddP3soMM6/irp+9hsq +Htdwlkl812ekLlrXz8TUJKr6kdUZqCXq+unYkNJW9dPc2TV3egql1PVzzHtdSV0/+6p+CiUvWdfP +/sA1kZG6VF0/NX/LjBZ191wtXNfPHoHIgl1BXT8bXpt02RXV49u1h+K6Hp9DOTnX9fiWquunQDFl +n3mzOQx1/WzyHhxP27bnretnb8nDGw9WUdfPSoffGHcSF8vfcmHOyzuJTmzoVNfPfr9Ze4pg8bp+ +WmzrvcVF6/HNd0jDuh7fCthHqeq3fD0+N0lMTrc3GM9qzFeKT5+RulxdP01g21DVD2cMLV/XT0mV +sqsrunRdP3szx4LG5q7rZ1/Vb+lbm6S6fkvG+lzW9XOR97qCun72Vf3mrse3UBauTloa6/otngxP +VPUjelmqrp8xlExW9bO65Wzeun72x7t0Wmzhun72B510MaWF6/qZrAtR1c/+Xjj3df0Wj1tqMTZ/ +zpOFX7lEXT9VcJlV9Vv49KCurp8tRRAVQJar62dvGGLvdfm6fvYJsZJGXrqun3aS+qp+BnvM9U1W +2rp+1kYQtmEcbrJyWdfPlQ2zdF0/ciWNGzg22bUW/Gle189eOdhmca4sIRbr/ZiJeniws9Eurs1P +fOjvlfrENyrqdCV4ah3atT94r0tb1FCTTGPq7s3hwYjMg8exKamrgEZDRocqYqjYRVtQ8Hmu8UTL +E5j7xkw+N4BaOdkIPZ5vU7G7rogbwXyqje2zw+MoFRhsxJqPI44df54UDnvPicvr3UCkH/RnvjNU +6eM8vfU9ywgbT/UWC369pXx8fK+0c3bxfcV/d+8fPT6Rj3LN+FnhLnoaHW/w5SL3lrnqXh+1qmfC +7Wetfc5/3wTa79u36SCX+9qsXZ12k739u2H7KDD4fhW/fePUQDjfuD0/8m+zgaLge388Pg7OPrce +ueFTOynxPsrtPLyuVW82oqGX1Abz8X0T2mf9KaqQOc1QhffmCVUUdq7G47dEYDyJ3x5Ptl6ExoRv +PFaUTMta6CAWuY2y5cSmnPb2FRtPnoaw2FxiC+dWG2WIJr9076H8mkg3L0fQoVZKQMJ6krM32reb +TpVPzJCFkAGmO92B68Jub1jOFWU0Bur+dmXr5qF2uD0Yxwo7DPcx2+q1Nlowk/RETg7dmIVH3Dk8 +r3Y2QDmJG+lCreajttst5O9XhlqTfaRjHzC1SpZImlPjrcTUgFgzw8Oh4MvOPL7cQ6F9hwpoZp+L +V3fCeba1mYpN909SsUlrr5DY6lbytyn2BaBtcFjs3dw9pUvCRgPAufmWweLymQE61BVhKuP9S2qv +vDFGs0r3h5CS06e3t6+h/M1dCf4CE670ojBpN4zd+kP+fow8Jyo2DcDTCK9TLIljfNQv/6IDKHYM +MCIOwJ/iLsr6BQLneAT+PAgjCbPlB1rscQweZKPyh4VYIc+cxQHYEhXKhX2zQqB0fEyH/Z/9fLP7 +naBih2IQDRQO7pnezdJ72U49RoMXByHiRX07e+Dxya+yEfUVk3m4PpJfHMfUF+z23kdafnFBKy9e +JLQVD3bVZ2rPUO8Xs2HiFexbglMEXA8wsQtm+hSCcw4yz5MvIACLVzS6CYcuHV2xYLqXu8R0Gx8h +iNlLgPKDYZdubotJZV8MiEJIXhm6GTmgYaMYzFvq082jY4i2S1r65vIagYVJrftbsOcQzC1Gammb +CUY4aP3XImqnTPAotYd72YMb3leZXvRjN11pvpdzp8cbVZUklW2BrNZx9WkdzgwTLBX2zeABSl4U +4mX5QIGY4aeV7Xbx+SH+ka7Otjv5h1aFgrOiEfViSn5jnmcvKWk17l9YmbxqHDH13JHYlPngNoIQ +yOQus1AD3sZksr8FsBvPsDbbLS2Zu/ytZF0M4W9W+cVhEPm9vgD+fJAgvjYLcEkeYvLXD5TyiyZG +88a8dOTRPLDohccnvcp1tyU+6H7xeC5aTavdM93RiBlFCliIGaAroaDRiZnk88UwkL/NnJ1kgr0x +zOkXSpk8Fa0ZxYy+Sq8fURuQAnF0o2tQ2RcD0lLi+LtuCJNk5u5lAma1GY11Nis77HaiP6WoQHQi +TRcIF3RuGoUnwZ9cEGUF0/mnFPwzCRhp++sQyo0wsfpP4JsbSBOlKDKD4EmVKHLc6eJLFDrmpZhF +CKZEKQS5Q4RTDvnTADwq+k2HqcGbxycv1Oku5rtw1tdQnkn8C2w4yM6nYOHFm1L2rZtuaYRQmaL4 +xilciFOCDuhi5htaHB8XCGPnoIP7IZLEcOpPacksAaIHP8PCFQocrGls9ZDk+5Rx/rrqI5d5fWhB +1VhaOIhiQgfVfItq+Qa58figuUMqclT1ef/0VtGzJSZba3CkJ46ewqK+ZzKIN58exKxR+QYGQ3yG +7aidB+aEMCbRs42De3hU4GoKbbBrlJWv2pblCczVr5Ag+GFBD4I9flRBVLW1a3m8iFiVFV79TLCf +EaE5GPD4ABV9UJCIg9LT+veu9Ky7GQKivsErmrSlsUGHXTxndOuEWkI6dbtbBzQdKoAX0QhiFGyP +ae9dkEWmUjNZMbueVYsrtNe7PocD3YQv7rWXUATUdbnbGMbyYC7I0Bln7h9lGweYRo3tqydAWVxR +X7kZWscyxmYbsNMNjEpu8rgD8bQhX7eR2FJHozkLd9hghjISUmxIU0f7TUYCF0NIUEbTJaopoYsL +MApyk6qCgidUH1lBwuzxQkGC7vqPsA4JZihgU5eBgISC+tGFzktCh7QhEkC3KhKkJbFAAoECXM8B +0X4meKqgoPQc3fy6RigAFqxCCWZ0gM+mYSIWL7oSEpgZTaKgeXFmRQd+JEYBv+BxMx+X5qRkCwIl +PDvTIrSUrEDUN4uhZcagEgOYy4IgUF6OS5bCt53oQQD90o0tsRoBfNWFQtNKzXqJvFzQdIBcDZIt +rPGgryceUJFpPY2jZHcgg9jVA1DxoI5BvR/GlXxSCZsq5aoN5dqVgbZdEN8nhK+QqWUuVYzdP+sW +R225IIGoMndxGgMqIep2DBY0tiTHB0g8LEhjpPbRiF5LAAYaIznekkxJEPppkOwqo9KExuwwMddq +qACIyFXQFSZsxhAkOV4zBq0WswVhwfFulhOf7Qmqq7EYUQVJZWxEpaxf7EEQCzrvNBAAmFkvL+iC +0zATXLoxgLnYjsIFf274c0+XEgBm8qIFgGMlikZeBBO7KlXaj0HRyMZR6DTR/GNQqXJRabnrhioV +PYR4X6+Jdu3p0sUYmMw9faz+CWlsmjxRH7Dbyewp3qRof7Vjklem3JeFLf0dJiS5wmq8qvD6KjuK +laEclqiO6PDHxyHy+G6+pTgbdIrh14pTHEN/wp33gPTrqw2vvygFcX/v/m9403kpJP2ZDEADshSR +/ixzGAA8DXWdnMoe9jGlxsKoUuP4rvAafDxFfi7h5RJBOa2rS7y4plvKiyiYC/Hq4+BdeUVG+CLb +x5/yi3M8DbpY3qwrz0KkZ/wSVeI15xEyQkIXR0no758rQZZzCsfHSkKZhfQUYY+uN2ZUrJJSo3mv +UlShUkC+NCTddgaZ13DXIQ69wDj49mIM+aVyEYO8EQbi6nsb/HlNo2/w4sQqj2zsrNqF7kwtRMTe +WjtR4GHel9VA5JvcyxtYeOEhkovV93eSHwP/NZjLfp77MrjexbtLcjNZ3lFW9j4SYIyDrBlEM3j4 +1I0DRPneRgQxeBK/TMSLhZS/Xcsdtw42JGK/v6OVsBpDRhT/f9rOvN/Xorryr+C8h4OGhPHcp+Yq +4wQXEZLrEBEiaksAidoyKEJ3/Kdfe9f6rv38zrkHRJSk82m5Vef3TDXs2sPaa7//1tevnozl9ebb +9fLpb++nfLJiH7zzo+dxL4eF/c7rD2LZv/OzI73z6NWn979+kcJd9M6v8rfXq9tufA== + + + 8M7b5fzXr6v9yc/F1P7+J9zxeQK+u/mzB3H1739xnP/61a1/9538T9959O14m9//utz5w6+eKG+x +C/J//OCPT8a32P16WSJWp2K1/csH8YB9lXf821/7F3TUZ8+f7G29pfON3Ioywn/5J/31wcVN8Eu+ +ZXyMF90+LlHUPeZFf6162++N/cdz9373eQgItbt//uy3n3sjnPTv/Xh809Jpb/Vf/AW+8f/81Xd/ +GW7Oy//oD/K7y/7+16fvbuH1iYTLv97dkM89elYS5l+fD4fXb7714KV/+eZHh/bLt1++uetjX79/ +/8X3v/bhy/d3/OmHelHb/ia/9Pwvnj0efP+7z8rW/gGRvfD1ff/l5+1I/6dv/STC+R/9v29fzdTW +9cy5XD/4yafvv/fxjz7+3W9+9+H1c1f/fPXghVdTev3DX3/08sfvvffT9/7rk5c+evfTD9778JPr +b1w/eOG1h6++OttL77370a/fuwaP0v5jXPbKs7HGwx92Nyr5mKPMHumX/nN9//evfP0n33r7pf88 +3vz2HTeaj9w//PSPTzz32//9ytWTTzz77s2TTzz31q9/8cRz+eXXnnjqlT89p+ab9iI4SPm5sTG2 +4jNff+m9j1/89HvP/uDRv99zpuNAWP/x0+9/a6/Xf3/xvZ9898GffvPNB6+88PN/fennL7/x2ncf +fHJ85KV6z1HoL70ELj8nzrkP30/+8Ymnv/nD+sTzD/7pDcU7X9rf8g8vzQdPPPf0d7+r3n954tl/ ++9oP9X0/1B++88TzL5RfP/HcD372yhPP/PHrH8tHNuNsfPnT97/s2Xj15O3p+D93NupEPE/HLzgb +b4XX3xCNuo1FXT35PxeNuo1F2QP+5aNRav7tZ6O9xj4d/+fOxqsnv/gs++85G20Lfek7/p1n4xnL +0en4P3c26nQ/T8f/ubNxf8vldLycjbfYjId38VR71d4VMxcp8NfFjKTlFjSSJt8MiMW3f/8dy5rn +/viHH32+mLnIsVDBH/yjPvyp8xj+wYfxuT9675nQhveJ8tozEereokn5+s9rOR/conzn37/3Np8r +4aKAzitPoVoKxiNP8ivPhEhJX3sQ51f71nOXePbzkQ9MvFtwmZ9dTtunIx+tvfzg8yGDW/6cC1KY +0xN4uiVDxQ+yt/VTT33jlBbfeMb60FPpe7/6xjfP3u+yf5/i2ETWXIJON3dP8j88PDi6Pyt19vkS +IadvPUO0zXGpZ+8e3b/CVf3D0AO2Mv7gS8cnfe/PZHlceEA8jbfriQDTtx7871sf/vHe19qDe+El +MUf/2xle+vjZz0aovvPaXdTL8eovn7t5/Ba//fbrbz3zvXsBpsfW6p++/sURquN73/yRb2Cc0L99 +9hafPnaLV/7xlbtbpb72T+d5rRjqcz/Msq21nl55Vv+6ufQ9oA8ew2/vVfvca38USuNji5l9OP78 +zshf8C+OtwTM5Vv5y0V/nvoAvKNDH//rL4U+3vzLoQ92zheGPgh8RLT480Iftw6Gv8/Z88ztEFw9 ++cwvPi7v3CGCvwzC0w9//utfnYOwV/fdQYDg0EPwq7tDgKMhhuDnt0Mgz9F+n7uD8Mm3//jXBuHt +b/7wdgjKL95P804I7HMcmH+bD/TmS4TAPm8d3PKzUCD5b4wDPoYHfOOjvxhDu3ryy93izT98lbV4 +ZiB8lUgeBU6+8Aaely+8xTt/+mpb6vu//fSyK//O2fjxL//wJda0fdNfv11ej93irb+wLb7sUP74 +vT/dSsu/+BnP/MOdW3zn4R8/euwWHz3x19/hzROJ+Plv8fHXzlu8+cHtLY5XfvDmu3d/9+YvL+v3 +zTsTf7z8v175yb019uMPvuIaoyTrV1tj733yFd/h/Se+8hp748OvvMbe/OhvEr2fvcE7H1/W2Bcs +kZ9/0Wf89ksP5V9cY7//9KvNxptv3dmuHrHPG4kvvMU7f5vk0yl2/xbvffzVZuPN3/7p3pKKEfvy +i+rN3/8dC/txPMqbH376FT/j4yc+b2ds++XLf8anX/s73+GiJ//861//a/sz/+mXt7d44p/e+O1r +j+Fy3vnLZ8CdE/mLRuKd9/74Vd5B0vKd337FRfXO7/8KOOevS8t3Pvzkr4q6LzyH3vnjp3f05L9r +i7/z6RN3m+9+/WuPNf/x65gK6MkySD/5zrPyTvR7HpLjvU++O1Ewb226O2bf2//wwS9tyv/Tt95s +JyLzLUzG508E7C//ZLvyElt55eL31pPlzdum8DOPm8LPGZPp5sObG4Mxz8vu+L3Ld974w4sXRPU2 +bO943B63bu841h43cO+41e64LR5zQN/CgXnKozt+vdsX2CbuN3DaP333yd//7rN3PG53nvz9l289 +V7/aA/j6Xrjff/TgzNN+8P0fHXIjPBtusO+/nvGK3XX0/PjhszjOwtHz41efP43UT58JK/DHj27s +WxPv+W7+5JD2n/b//PpPxKV+5tuW7/z0w5uAef/DzdPhMHrzVeby2buewjd/dMNTyouzzH9+71dP +/+fD3/aXf/Ti+/Pr847r2m7abXhHzvlnSMBurfc3f/Lgb7rj593v6vE7vn7c3rG//q1vPHzh9X/8 +5/94+Nvxr3944acvfPjvdsW9+ItnfuX1+/S7P7ugp39abvMY7s7uO4+eu+ODfTsckO/8xHkOynZ/ +2v96+2tv2AF36xrKL/68vKKcojf3Uvrmq/wrJvad3zT71uyh/f3rN/Djfz9dENDP73u/8JT/dccv ++/u38x3H2h2P8O9/U0//0c9PJOnPjq9jmt261Zx5+Llg6/9GqDVehc8HW/83Qq2vnvyLYOv/Rqg1 +0vLzwdZ/F9T6T//v21f/vJfUqym99b0Pf303xnT15JO757X3Pvn0D/pBe+vF937zuw8fvf3n9z6+ +Stf+v2P/n/53rOuU53VubTeaeh+9c/UUv71OT18/+vDqybcevPDxJy/97t1PfvfRh29//Ofrb+yu +dP3gxY8+ev/6qRdefe3lf7/+3n/94aOPP7n2ZT/96Prha689rcDWF/7ujd/96XfvvP/eY79/8LMf +PHr91Zeuv3Htd3hrv8M/6+p0vLXfYv/Jv9tf/tbVcf3C/v8/+79Xz3y6v+ul/e8fXR03x/5/ZX/a +X/6H/+9nb18dMRD7Jn/ejX/Z//jfu+v/XtfrH1z/4n8d17/e9/3ZT65av0m9Xddys+qxrj+4au2m +zNWva71ZpaXr3a6l7PbuP2a/bvWmlKzmUdu6fveqlZu22tAFs+8LW75JueuOdax23dJNXUvN48h1 +/76um8Yd0k07yv7LuMmz7vaxb3zw4DnnuC7rpqbUdUW+aSOX6zJvWi71uoybOZr+M+pI16XdtLZf +YP+59P2zd6/K/po5uGCMMa9LuumjTj3iqPuRZT8qd14hpzmvH3JF0Vvvl+p9P6LfrMRH5Lr0KrzS +/ui2Jq+0fzfXvuP+XS1TP0yHLpg3vaSij9hPLnvZ3Rxjf+y+Yg902e+wxyOXNXTl1Nvu4astJ11Z +xl6yGt8xznGaTMAxG79b/LnvwVCzp6Ne7/k71n4B5qHvd7lu4yZNTVzxK/TjpqX9CvvBa9/gbD68 +2h2pj+u2/KnrZuQ89PfSNGH7S3qnWf0++76tc7+StUD6fp4+Udfrgr1Q8l5Cu512h+dtT9N+nz72 +zO8hK3nP8/6emVvWoPYUA1BZGXtC9Yc9ZqnXPa97yWhe9aA663XeF/S9mXc77yv3Bbl7EPajV9qr +P+8HrlG1pI62V0ZOMUjHTd0Tv785HzczNXpW2fd4dJX4/KaBzb316/2LvRyHXnuOfp3Gzep7ieyv +7nNP07tXqe8Nst+755t+7J60F0Uv7brXm5SOuWWOb9j3klpFI5f2lLe9V9STVr3eA1TynoJ9hzH3 +DA8PSNcqLVq/eySPpL22v/jYa2JvxZr2iOzJ3nPR1G5aEtqDlZG+2Z+dYlWkvcj21K+iOdWFuzlH +3UuiaksdGjntem37vYXW3hB7Ec3CyJZjr4Gi+x9Jq7r0xLjtN9IW3FO6J39/9M1IZbLnmkY63Ryd +ORt6JU3mnsQ51h65sl9uHWMLoLK/dwvk/ZdSxmQbsun049ymuvYc571Jtszgg/O+3dprbS/do+e2 +ZflN07xvOTC2IMh6vz2vZU/q3AOy57s1Pr+sub8/x0rS9x7swz3bPe/naMEce5+nvcpn3ctci32P +zG6nWvRKe95r3c/YCyCXpEkbacut6z39LNe0V1LXdO+xXl2TsP/FaktbFqThZ3UtkCKpc533Atv/ +73qvht5qieWbF7da2jlFn93mftTc71+1AfZk798fix24R3KPdVFPq/uRW/CxZPeK25K6e6QXz5tz ++YI+9zQnJlT3y2k/J0lS70/Z81ElvPaL53FoYPUGZc/V7pkS9nuG9scvffQhyZu1dFdWO01mbn/D +yn2qpx17Le6vnGO/y26PeRRtyT0D7KM0uuTUnhTutXt6PfiLZHPSSvJ4sub26M082HD7FrMxu7lt +ab6HS1O3Jz9rke8ZW5qovTa636lrWe1b7NWzP6bv/XX0sldRnno37Tc9oejrpmXb0D7bskkjMrln +HZp0jXDa37/20bT3xz4VjrqX4cMrvcMs6mjJYmTviJWa7tDbzJqTIbHN0bPbb17tScj8Yi/KY99M +cmNs8bbfqtMeXu4VkbEHpe/Fsoc3z540GkdSe4uGscWypFb1opqzxLCumZeX2f7FHvhj7CnMEkN7 +Ze//JknPLHE7kZ57pPMWUPuXZWQ2275X0TiPsfewJr/vvbHbSM+9PPbRHvtsL/R2fZ6z+9k1Jxbk +9CZDHO8LdIwmXr/vBSPxsLpWyx5Qn89r7O9OmpiBINvPPLak2j1Zx089F+SeoSVJLxGSaGvH7Av2 +HuGZ+zhN+5V08KZYsW2gtqyjsW1RaziIuw5irdi1xdGWgXyeViiPmHuoLfm71tm+YlpsJh0JRT+Y +aa8CyQqNxpaqbFCtYG1Pju7V9RI6U6UD7cNjH0yMZJa2sK/Y08vI9+N8xKjM2jjQibY6VtWsezmp +LZVJzcYhVOPl1VMkyPfIbxmoNmfJbqdZmP1DSta+okogM/9b1qKx7OOedqs6Y/KWvDoztzAt51zM +JqG7V9Sekn1et6blUvce0d7Yn783jdp9n9Oe7bpPavVw3JTKeGVtomrxM/WEvVELk7c3x8qFX+yT +gg3Z6hZEWefRPn84DRbtcWhb7CW69xsbpe0jQBfO6p1dRx7xqk0X1oXapQHYeiuLWYs6SzvdK3I/ +uhx7oCRUhmTpPlOOUz5tLXPpdfdGbhwiRdJif42ksiZVetX+2tSyrtg9e+KneqY0A63uqdU+fZxK +4u0xVnturVHH6Zbp+o7dk/fLaccde7ak2O5Ve/1/OBpK5qH7fOaoHFq+ElClIYn21FR9xpaywxrp +LAcftnXagn6JGh0fpjW4tT3OjKXZkvontWr3bEmD3r70SvvJx+6Wolm1x/WKnIiyBA== + + + qj9r1b2ltjYSynGWpJfemaT6arxY1G1fOpvVbE38/gWHsDbxPl6u79ke717959Uzr29jRebOnq66 +/2efjsf1Uz9+4Yc//dEPv3ctdfHh07vnv2QcbePl8LbYX6Ij5AN9U91Hm3q2MKz6ptkGs95HWlby +JtuM438rwXs17+NIVxQtdmnNi1sWjauU00PtQ5ol5k6OnXZ417eQpxJ6xXrkvhCRt8W7lqBGcq+C +3ZHTFtB7GDEEtrgYOs6alLUDcVJnYdz2wNLOmBA6OSfihcNBbVkAWxrV/QN9g42VLdD63NtkP28U +3XBYeMhA68XttsXyQ5kKQ4tAIq9zATO3m8f+ElkgdXcjUlPzF7QpMb5X3T469Qupi7uZEW9SPxcn +2j48Y6n4nZsPht1mMelw36IVG3Ov86Qn1eFpQN4nlCRGNWepNnu57uGXTTmsqaRVmLfMq+/fW8PP +WsRJ7a0wJ7WHzq596LZjzZi3VtGFGD4td038Pqi39TlZKgOXwR6lnvyItpXHfbLP1RDitR+oV20M +lOm9JXlkPjBHdk+pUmH0UguTbmtfWe21Gm1uaCVWBl+T9tesKenckZRI6KrI/JjVLCMBA2z2mX2U +JX6A/ctBthe12szqlpbNMh/1Xh1SPDjGtvjRrEtF0ev0aQ23j+4PQKvX0SeNC3uBlZq6LLyFGNbC +HRyMWLfLa12Wmtpb9UQfkAJwb3++e/Xy1TZyStqLs0tcTTkcunb5wJ7KSct1v5aMny6lX3M/UbXO +C/ZTt/DXDts92mCSKnnwg62XFxtJkyew/Nkf2Fm6Bcbf9OEoC06auOSUBm7bZwn/QdNI0d4mYNMd +V91vstslyyzrPnT1ey2yd+002SPVdfwuNsgW37TbsddrK95KemUZqLbWpULJ6Nvnsn6RZH1reBar +EWN9nxMjx/IdOkRlvhdvkG10Z5mIw+6A1vVpW7Motu618ifDOWXPq71VK4Z3tup2rR7uNMKRwyxq +eCoOBOxuWcJxh9EPBBBWFldsc5RftFSzhSdyfisz3IDjTG0Z27zUlOWrOZNAob0VIc0QkqSETNQS +H/muV2Pvij6qBbK8BrK6F94Dv3SzquArard13Cv33EcoUorTWdIOR0y1fY7w2YPOX7a5zCnRkgXp +kromgZr69B3aOI/CwRVba8Mwx2zUlQxqD5lRcdqwZjmY1CEnz7S2yp09i0nyEWcbIxsKjI6C42AT +5K3n4jzpsnCHRzoUJR7AyaaRS/tU1pqVq0Aje+w1qhfQHOqQ9idMO1uG7RStIynWmso88fL05L+v +gi6vfSrtTvtx2f9RpxfUFuJ4M9gVLDjMMGm3ekkp/15XA/dQrplWPrr/Wn0qaWVmPXlrrOzWJXGz +/4u4ui85pC50bCpciGVIAWADSpjunqqLwzSW86reyhS57ZYdA8nrSepSGrjHlg5BKdgSIkfo112S +rHkYyt719kJJCh3Yn2pjX+n1JVXVThzP6qncEfuvy9mh1tDE4m6z62VKFeQBPccbJxxwGgWEe6WJ +s1XKd/P7y2EiWS49X+JExiQ2SbU8KTiCsDU9iyxEXntq+FnTuqB1XE5V4kFn19G7F8rYQ4SDUoe1 +5ts+tlIsHZAG8rlpuz1krUsAaw4sLjqnh7o70mHoaN/tnvhiCRjdWQfc4oLF9dOWrNor+bwqMxb7 +Wnw0RqFWpA55fUOx/JnNg7CPs+wL+t6Q6snVq7weHpdDYle7R1bkvuO2qoZ1sP01PjSHXW/7RPOh +u7eBtbbOMCSpy8iELZmZZ8wbSaTpeT/qRM9L1abaNl2mr8CrVWUgDTZ3lsdMxttRLAw6Ju302pMa +tQWteupxsMmTXLC7bVHXT197Xzk0SVQEOfJWSpYK+3urdP3MSCVZ2XKw1xiooiNSfj68/ZIXWt1J +Oj9yBxfSbvfuXTv8uVLy6x6oR+oZsu5r+Jc1O1t61tjHOl50KW2fbZODXB15ISHKFhz+QaKNewxv +fV6xB+UbUk/b4raf3vhklyzHrL5hW9nDmwQ/hb5TQQuJFCZXLtzYY6Xz99Hx7+uYnVgqsyQ2+R6N +5XGzWDh4YNEmDel4bMHBSMsho12sU0ZzIeGnRyxfMRLKGS8tJ6sM826xxlTOldFN0ILkVZfuiDid +Q7+Xw3GfVviXl/fdY82SMFRuOxib3dyD6V1ZOu27olPStKBL4HHMUiA/UE/WVMpnua/Zlh+68W4u ++SFKeK5TxpDDg88A7w6cDDImte+SBl624vB5JR+51iFXFNTc4oWnoI4cjMWLRA4jea9S8XG0L5Cy +dqD5Z1k5ChpISsjHKSlRup3Kag8E2O7BW4wXVL9oeJfV1p6/2PVbs9CeeCi3KSePXmLf6dEVjoxs +U2Dg9tpqPaNyYISXLUX0+8M7HUfZXrJyGi/c5rs9dSovvVPDjN+juuTj0wmh5tyqiDpGOGplEmr0 +tRhKsT695dlMaN5yDUtULHTfqo8osm7kRNX5oE+Q22va6bMvaHZKT0IGDAKamKS4ThJ5M7JcpZnR +fMioKTSwZ6zI2yXnxr6TIis6J9RUt5aPZC0XzNXVUzkg1dY5LQUj2bGAo3wgesI7OMqWU5LzBz8o +fSuDOom2wkl7aAwLLs+HxIckYpZkkoZF/oWkj9z6nT1UHL1bnBzd/my5SXvhlrIRtLrwgB/2VGm9 +SnuUM38ey8/AubF7tkSMqGRWk9N4N70DJDFatZcMT4wWg2SwHinXA257OYXubSpttE+1OZNc0k2e +/InmohUvL+wexcNhtm2TlOtDcYeJIoa7XHGogQt6L8p9iKmjoqcrjCCl5sD63P94Q25qvKOXrnSg +1li5K1xT9OGXjofyhadCmGYPKoaogqV7Ap6X4153y7LNtcv3L45MdOiQJ0iuNexNTfw+RTMK2/50 +xbW2TiljaA6N8sFelRtuL7LBC7WF4bJ3NXaO3tMq9h5/mcm6aMtLrb3KRtWHbkMe+2P/Rb6vN/Sb +PZzSa24moZ9LhzR1beqDAO+hod/61yrcWNI/azclXHt7kicuFJn6BUfU3jOKFLf4RN4mETOwL0O/ +aXll6S8KAU86trmvA02Gx0y+iKNRm006lT57yanQ5Qso+myFj2Xn7b941ctvN5dMxRvJDlbEluBF +d1kY7ppkvCaSrnKHMsD7F0O7rdnzEnM2EVV74nd/lrzwUO7ltO8quTpj+tGU9/qVHqhVII+Z3nBi +V1RmvWDELXw9Wrk6YAobVqeFZJxEw9Y9+fXiHJK6r1VaiA9KJG49qijmKOtdu38iRvZWlP/j8N7T +fWVbHW7bVSeJltjMOsm0cis+fnVovenWsvt1A+3I7EOczY9jQMfU8C6gB9+Pn1CJS2R7YWkzGQTC +thKvfYRXdY/vXkW0S1WYR5qDAg/qaTrXFf0bGviKO09tIQykP2qhP/yMLHi0JcTnIlPG9YNXP/zk ++qnX3vj+W6/99u0/vPfTP//hPYNGnlLUWv78p68fvPbJx7/78DfXT7344gvvvvvpBz/56JO3dZc7 +6JJnPr0ienkM7TwtmbVYRavJMXkCR04USTaKBAkkMA1hIfytyCCWrST4Ue7IoK0myZuFDHq865HF +UneXT1Lt7dIe6wi5lCbymJDb413cp9SW73fpPNOaYRE8upKbbHmztaTjtRIKSBJobNAsiTWkq29J +RRhG2+Hxnn1nRXM7wq0sQtRNX7wXleOVLKUq4dgsVu73PNKgN0cE5DbgW1ruRW75vZe0y6TYcq6W +iHhrK9/r0n3kTzsEBADxYm10P0rTkeZtW8LzFAj3uh7RhYiVNTEzV/ESd8XpvS6uGiiSkrDyol06 +5HaeHBxb58FwUyCNjfaZLt1Haug+UpeshC02dbxIfVI4vwHCAdVULXWRGQ+vPtPFC6Uu93WT0+7g +sqrjXoKYoP5hhaIS9dejuM/jXR4OZHC3nXIg8Ibkbj1S0cmxLSHZxFJqU/eRdK+LubHgFL5H4kmR +jLlFgKQzn+cVSkfGfGOOH+/SfSRgilSygQ9dBgQSdBK4kwhPwKIE1CkoL/d7tGgLUIIp/WZq9W4d +5NCgH+AtttRHw9yaplXRex26g7EgC+iJVnOSgJYcR7UnIMUdZyy1+z2PrhR9OdB+UcBlRMnsklzW +USPNBzDGQaBRkv+xjq2A30p2B5pvhlV47WBZVVL8JmJZZ+++xf2eR1fSGtjrOj/lUUGDtqYnxUxh +mVS4Yst+/Mb3eiRKalt+D8FnFpEba1WokdmOCKmTMmo4YR7reUSPEDL0zBo9048hfEIPCKfzNzqX +4nPXcdC+AEeMa7rf84iTSrtSPcLv4QD0PVfPy+2R3C4r/DZ3ex5d4aoqnG7IDhmlQpbsE35JKOIQ +rzIiMqciZ9ljPY/UQ2hWQQmMUC3zjn2T3JZr8O5h+FgPN+iFnobl4h4dRDK+t5mJ6awNBiqh2sUo +f75O9bI3ob7tftcjex20GeWkrPZHAqWM0+0zx93Dz56Af/Go/tvOYyE8OSalexhX6bNVq0IwjkQY +sGc2vWxAmhqVsx2OmDs9fCEwDflVZPU0rEMJAStsu703hB6Zw/q53/NIXoq07RIde1masGImHcW4 +CEqjpkbknJyHV/d7HqmHONOeUs66256OStBYV9J4Wexy2aIirzB07nXwTqiM8idLYZIPE+FmPQ+d +rLPn+HyG5rEe745sXfBQME/7R15oTPi9X9+4ut/DrtynZXcPgUPpv3ea8ujTSt6Rd9qPrrDtEYLW +5uWBPLDgJ0bSPhmJai1hs7LFz+M9EmGTMOipI1cikY1faA1X4o/o0Ie8ABKDj/foHkmmoGRX00GK +VoGZved1y5YtWkFdgj61SXyvR+K4s4B2T84oR3hEULmxiiyyq1ypoHiTDnU8SXsfLtn2GrPqw9/2 +x/0enRoTpN26mJ0dzXriiJCq7tPwPIzv9+gOGX8eEUVhn+yrlSNbkfPzaJNDMiWrbI/3oPUpRDjC +CkrSMZrahRmQ01O7tssrf4TW91iPbpGEvus41NnByI4eQLHYnHv5ox1wij/Wozsc3hr4yApoy6aA +pKJoBzKiFqtkWF66x+M93AMUjiHM3OOwGlcaxuo+DAVnuGPgPt7ziB5WkZAx1h4yNiOI32oU6PGY +aX2/h/cwZncf4UVKQLRPdTLZJy6Fs68Ut7jTwR2G/MBSW6Voqd2ww1nqao5uRfdyh8d6fAt5nLcB +Ddo0gfqTgZlob8Wdtuyydqryd3p0ByNUdTixlAZ+8nKxhQ/cv0JAL6JA93tYnYAodahmLImi8c7y +9R2L7qI1m1F5dIfHOrSV9+fgEKj2pkg9ySyx0lKzunQURiik8/0eDKY9Q+k8d6Tr4MLx3++dSg/v +H1P/TQfgM6//PRavNOaWv9QDXr+fELH/8+urfv3U09c/+/erT7GIL2kWX8YylnhXZK0Rhs86r3VE +KoqFeEra9YogbBGt41vjKlG920cjxKCBXwJogdFlqLsAxpnHcq4A55GBeeAr1/E10Q== + + + n1m9OlPsK1TMIQ5AK0DC8dgapy28gsLs3CJ6FrjARNjC8qwP+1okIhVBazUemhVuAPt42PORRsKN +K8Pp/IyzDdydM+Dyi3TDih/xtooe9KX2wNYB4asXvB6MmfXdfnnH/2PtVhD78BambHhAC1/S/cmQ +jzV0Ku2YQQiFOdodQgRLlwDochhm22M3n+0WFgqfHz1bmMc8gnbby1uG1J9ZCR1LsgKk4OBXEEp5 +Fn349aWX7DHec8+Y332rPxv2FiswRZpIBr7KOzdHlrASFugi4oiFgG2lrXyL/Z/jICNHoZGKsZ1Q +eoWa2geI1K0iT6WUn4HBvLCIgBvL4tKAjh5ZD5qQZitQTYXPBfc1PkE9ii9sU64yY0o64R0tQe99 +xWVCWuA9BHvcQoevy8KKNlz7fM3Mwu3uxSGg/m7LuYnk7SBC1JNQXKrh4PYQa9/oIDs/br9ZcQAb +PFSW5brXsaHo2CiFeDawN9DdFYOp+Ou2hiBx73iMEFZ2KCTs6vuf8e5jUwh+euLCRTv6gJ4DfW1h +Cz269GQCmc09vK+8RRIQgoiCgY1pz8IQJ+xvHFIAVQkb5/AZCDE/OE+KT9JlyS5IcTsCqFo0uEUI +jgEksVTO80n8d7dJQKjg5nNAWztjMwFZCfwqdGkLI0PgWGBIsR0Mnx13vDHCpZNfE7qqALfFfqh4 +Rsba0Ka0WuaxGEs7ZmyjdrkH6JYgcJWY3P1Rfj+WmJ6HR8Ar+QN1bDmqFaR4Sro+X/CcXA2jFvn5 +dz56riUVpRNn0kCuxTAB4rltVzn2fUX0HESNUlgkW25hbOdAeWTWUfEwdUXHAdFUMMIG/G+p0T37 +GW9LD1TFve96//El1+1+rvGGHwjc35biuwDwgVgfe8Yuv/g/V8JKCwpzDoPU/KRhIICYwRBIUfem +AUkdPZ2guYDiQ/ZCBeyYSX9S297Kd/UABFMRVF8g7YoWhdkeMPHI3vEKJyOBl8TNoADSlssSItMg +XqEbaOLrJfcEkyGH8/QRX12JRB24ufYj1kxEphhOvnqbJRrnRABktzFuskCcyd9d+Lu09+TvzgXZ +ZoEiRLlSnhSj1cIDYb4SSUj+7iIpeA3SS+8il4ggSSFtNW7d+uq5AZRSKWxbHGfGzyONZSHkM/My +pp5xcu4g2Lh64uNbeKfe/Mx6uF0tJUnvzpcR+UA9B0tunxYHuSyFpdYuY0CPVU/PCx1b+5Ia6IC2 +APejIK2Ep9njPB15zOH03G2vwzghdjtGzacY2H6cTIrKy6jJhIX1DZUE1Kzsz1UuK/pdPWOCx9zS +Qm+udAFhpFos4WXEb4uI1rt6a9DzZ4QOrLzAUCH5/6zBIHgdQ/+I8Sp4B3v4m9VDct1NWDT3h/SU +REVbfGQsbIU2P1APOGp5yhN+iIL85GQhuraX8DLiOQTq/kZlql0uYWRZoTUc+RqX4/aAPIepgEBN +HqYwHCxL8rJncIsewoe7DUb6bL+rd+DQPXvOLzm3wJuf+bbHxZHQBwpPSC2Ts+0D9RhHzyogr0GB +CqHzwIXsj+FrwzgidQ1AQ4l9qbY+R4ESwAGX9hZeY9254tR6HgkkoZEQFj0RVyuxFe9MZrHD61wj +YD1IVTrXyGM9Vfqre+wVOMKHW3jIutfjk9GhGnr427mP6WH/nnqrrwKSHLNJD1HWggvrvDNJmhE6 +qpHgFb6L88GCLuljwX7gJ82GDug9rGkMXDGNg+XO0Pfz7LHcfl83cP7SOXuRI37qIvfn+1YfqoeB +/7cHk/AQx7rs4t2Ue+HOuSSQ0YEzK8Aww9jpOJjIkXGOahxMtz0+mMpFkPhkEkwkcTifJxOJOcJm +xBeqLdDWeTKVyMa6PZnO1zwloFAfc92eTfpO2U23h5N+oVzz28NJCc+a2/NwElxlpXnncCqBcDwP +J6VYWSX0HnCm5O3RJPBURc3wvizO5zhPJjXJ8DlPJnWA1YujqSiFRLnocTRp5AYC9DyaNBJGYUTU +XuBeS1DJR3L0Sac9jybBX4ZjbyxtJZFZoJ5n0/0lcSs6RDlAFlcM0AfqARlaLmqy8vu0XE+VtYZg +OVXWWgBbKMbbMZoFyAPoJmV5r29B9vKRLvLxzNwvcfxxhacyrOyaneGTbxwPpKegRl/eyh0VhHSN +aw4gGg5FukerclwCjvWCDDiy3NnuEUZ/KI1iLF+1wIE7r8AdjvRCosA1eF7PAwKA4UUI7uGRG+Zy +wpEHiPNciWXgYgRCRcM3DkNg1Il6HGQKFfvqstcffWaa7kygDmDu3UgJ/EAZKHhzz55Hd3rsfxQs +GBOkn2wQRsiFS5E8GVA/YDONyC3Sn85tIKSytEPBsJz1siIZUCCODiyYFOVTGW8R1bp9RAs0V7mo +QEr2sUTDqFQiiywCuaAVCm6B/5SfIs946CCdcist5LxhSmmzJ9zqQhr7kHXbKZ8r32qignRX38Gg +3uE45Z0PG85p9SpJYMYb+zumPv4ea4MLMu4g6xK6o3JjWxhzNTLO9gEA/JWvwK3XcTkYD72yHc0c +nIKAsZtX7UBxSSsUkvjGwI2GPxe38tRR0MKMrco+JPR+f5Gc6pKefefc/UAD1BbZ/JY9WggQYuxt +pxE2C0gljSsGFLCfHXDMoYHGsdLfJy/X9ABVG7mGcXse/vfe4HGrXmDtgtruaMQHShsZymIMRKRy +P3w3YYvJASIVSLDAGokpS8JS7A2CJzZ2ag10ihJZ2MYFYKfTcSp+jSPCAEqKIyH7dOVrdfZ6WUF3 +2rHG7vRM+UhatlYuODhgkEsb17nTjKID54puoJMS4660O+0WSb9njyINwkjxmkSp2kUani9++iXp +QWpJM6mkKA6LKc74hrBm5jltbjMQG/lBzkC0B8ZwhRb6V9zg4WemK4TU6/ddv3h8/2q2KVQ50sR0 +xIB+HlZleD1BO4Xme59DP9kRC4DhfZQToWDx5k6tdpSPqUDXwq55X0ooADA5Y1MNhevuo/TyfxP7 +j+w/3Umu2Ikglk2H81WeiMGbyS+U0wX8xnuAmwUy0HnXyKfVe0xMG5mayx5Xbef3P/MoBvokLfqN +YrW9J6PcSwHoKotqgnTHcUMan2CmOnGc5+MU9iqHajbyncxzTqIM0wouPqXYtDINfR9g2cmseGiE +gCUihxogBGfRaJMJcUcMSikpRzzCAm94JyiKPZ2FUyFzkV8mc4PSEPg9UlKRscmv3Z04tKeMNKUm +QSghXY5INbKY6abw6YfXMLn8h1P7wNt2EelUZw5BZKF7KpZ6SSIQyL+QhjDPTNBJAFMJg1KzlDtz +ZAZXKmd1hgWTkUldZeB4J8HtJQk1v8qGav7B4mLi6RL6Z+4TOHjyPpPfmKSHhRlItpQ0pd2e1Uw2 +0nnjAYdTL/Hw69AuZF5Ktjv3tWUjELD+lf2qIIFgGdVZDMPJz6vGPCkv/qGTh5wRJayQMA6yKGtQ +BygZxcfxOOLnuRTO40qyUbfxoCHpzvMBfK7cIseESapx+hE+F5EcdGdcOfNP4HOazb8PQhjym5yZ +SOKlUsjkfJXo4rRuXlJkRZJ5oPWtT9kitcg61g4Q4EBZ7VJglEtSWBjqMT2VIIktCDrINRmcuQhF +2rn492e+Ci44KTwyiVAvuxN1D02kxH+NU1pBa2XMZA8ntxJLhGgUlOosIaYcm2rlZPqoqcFlIDUt +snjMtTXMJlGJvQahlJOuFBozYwEAFmypZVYnma0V6oZlVRQNAMELU1hKZpLCay239sSuShih+hql +GBbg/2TzoHlAYJB41XnY/JvK234oEgWgxWU63aQaWg3NESQZB7QjsB6RZVuCYUk9yoCVjScpKLsJ +G3TZflK7o3+X5aEml8ZJC0k7hF9krsAGKEFp8dAHhvnNtmGM1RbGYWknVZlNs+b0lR7xDRHLJBwC +xKTFhibnNA6Cxjvtb5tOeAFRqHdRRLLA9sQwy79Gtkqr/nryeAtu6nSZmoItQHpECdIJj7hg0ewK +9SiN+zSLRf3RB5NLoPGkAqnG5+uKJLQsHVKz5GWbKSzvQjP5+n7Ez3GHqINIfAJF6rYmOTmRjzbZ +y/L1FU8qWWPyBja/ogD2tDt/nhpOHpFBARzOIlV7sKCZsEQMlXYjmU50Oej++h3kQkRdxGkjdLnS +iBSn0Y7JToYqToWvEe3QvIB0SBF/q8H/FW5WU0LJIFFP9hXOxszhXq3AJmjHS7WwF7NjPVot8n1g +WJJwBUBH9H2Fo1FOBvzXQvQcZGgVaTRqy/GotgSj2jEVOoclCoq1IC1Y4RRkmtZhmpNp0rzpwxQu +mWwqEBDAEh6RG3d4rRMUk86QvCXIhkVnsIuHbIkqCAeMJFyLDsAmZT3jO+gsc5RXGbItwTToM0Be +WI5qrevsHqGXWCIkDDZzv2iOOSWUyHF0Sw6IinSYKx1PU6ijUkd38pSR3hIpTA9xGSAPlbhdEU6w +MF2k4m4LDaqz/kDWPNZTw6fg2VUsWdtR4tumUZ+W7pGIO6dtTs3RmLah5/B4pziOEyNSSZRcDkY+ +lLGP3aYDPNmhAE0G9m5LHrPcLirAQwlpnMYoCTWbF3BhM3OSCMgzOIIIxHABpnMLpVlcRr4eXhTl +zyqWIco+853ooBg+5yhRpwHRehIJiE9mWw9kzfER02cQZAFO8zWJQCRjYopPszQcwc0xpXiJK6B1 +vh4WRJG71Ph6wfrEHJDLeV5qrNVz2FLO1VQpW0rzufYcVPtifSb34AAAf5wim7naBGvEcU3Es2pw +QCCw6ElYcwCt1daho7YCamqLfQUKkxk9I1XYE+TL4RGHza4cRAdrNVMh4M+HQ8aUCG2Y0MJsEs0q +oYIysCUpBXma9sZDPIKQpUaYd5pRDd5KWCHFD7CG+RjIJ1/OD5eepOCfMtATFt2aJ3L3GCaAgG2S +QImeK+euFEo8kOYSMoQ1Dbdlct5p5vh5vzR5GySLeTSLyS/Mm5AOZ0ijG4iIIUFsyBcOUzNIC1HK +tLQIeEfMtGAtTrnX6UyqxkgV/1EGymtviph98jKjgnkysIj8VqbyZBsCy3XqfCkLlg97ZUdwhZK1 +X4C+AtFsy2FkfsDvOXTV7GxS0T0k99Rk+gfMQ9p+ApQ+LfRsJzg3a+Byq8N7AM2GMswWtkAO1LRZ +08RM0Aw0R8bIpFLwgPaCmgHLuJHv2W28QGonPG+BFIPABgvExBJ4rYH7muNkXShOjUY+LmSdW9s3 +3YqUfVlBGYw7FDAmYoGsliTscpdrAu2/k+Xg38O+ow55zmVfFbeZCT1J46j2PC0evFayGIvnDPqR +Lk15MEVJ2q3eYB0B3IZJSj3TA3SYv2YvxOZV08PAHHy2f7t1W2fbKwHJPWNdSLZ8t/n5z0N46Z0h +IbH00/xILZRNNpwgvhfZ9JbCyylsPgG1aa+A2uJWU5vRK05R5QrTTxSbD3qkFMwugVNSLCvyAfBB +IEeIiuseYYdx2JEWa5Is5wuAgENQYTRomAXgbhFVZ5g7ZDWw+IkAQ6OILIQiqoc+1w== + + + GDCabN9kBirZtGYwVQ9JCuHUOQnT1IZJJ3nbQsnDAm6BiuSK7CPLlLu2NQ8noKvdyftRTxq2mxuH +BrmqauuQULuZn4Bogj3VOuHN0ottjgSn7VNVR2CPXDmeUEU6RU/2uaRd2Q9D8HVuLf+9rvMk4xQk +AXlg3Cu2wUrvqAYKJqmZ60lLpVNYPX2i8eDGuBAJNzPPaNe2OO+xPyTZV61W2ioyB9ErJa/ZNXCE +CgKeUEJxWY3D5mzwV2EmB0VOK34AHf4B2UHVjFpcwPNI11dzrNDFVvFWs7MqBU2RiJ8yho8lUTNN +EQoi+FidnMUaZOgHhrgoJ9bUa30bSNZBD+VeQON8hA3aUUGIPMwgjioGPVjF1WGghSwcuaw5xU2g +6Vu2QRHxGQIoLiCMrw64F4ISRu1q+5B5kDGXly+o8Xt10LTegdAsEZ+gXWsYorhAsq1hBVYFCUXv +yPP61OJPtjb0evM8ZfMjqc1pe7IwyqV/cEctuUi/r4QRFtawvAZHt6qXCAbzcVKWxgjzBPBHk+ge +NjZYLWQ4X5+2SAu2DR5R8SxBTA6BBPqGof2YM768ZDzJJdjDtLnFvCWWS3Od5VagTwQsJnXXCZvq +aWZPszHTzDSHinz4Clxc6xKXrWZuq+GIEE5h1VDcF5bjkcxqlKwKlmS2IdEIYYAftlXlOlTUad0Q +mZTPaZBeIayMBlK7UzJc6BpoQLtZefJgGfnP03AcsDIYNAqHKphczfq9gGYZp6msdGh6ReK5bAHt +KZzAlpqNkyQvlXhCTTndKhRoIMZmeIYOmEc55xUIC6ZaFo2094WvLxdTbKtHQV4hrYaJ9liYufiM +haqow0wAAaQ1/G76T+we+XdMwGpv4byAt3KYY8ppmJDjQryLhzRBKQ4ZD07RVQxfdARMkrYB3QMH +LOGtBPdsNwLnSyITQPlXh5cYoMBkb6pWoESCkH7CUmnJSvIa+wcJUfLxqbYYM9klHQjjXiZss5za +yXM+TcYPSxXtYddiMjO2aRKyDUEAiVhd2c6JHNzIOjUBkRoBJmFg+URHryF/mn9QHSHS8ap2NhPj +9AHMLw73yLPDLywMwMX4ChORHs6ZwEM+3EPmGPztwY/Xup+aTPJ2yL+cT7iBVgL8HJe7CuwxWowE +tiBfznenEMyzxRWtW3YvbsmRK2OpmNzQplER1iOgnMU0mor9gtSVCiyTR/63fNjolsHTa3wX3kD1 +DA9uLTYncRrAn2hjcq64oDQYoRTNAk4qh4UIo+Tlz0cAvoWyOL8BWh/16Baw2h/TRtbhttaF2nUF +7W12uQc04ExOfTB3enK2HgZDHVQ1XGB6JglAf0QqwdSXvABM53TxkeRghm0nOlzJBs221vKCSFHT +IDuJjh7f08MiLxh/9jinOvw3kp54o7g+7jZH2GnxPr56OV/sMCE7dI6N+7FmrEGPYHQ1NxiJzXQ4 +9zKb9XIua9y4zNSeNoGKrYd0IhCHrQM4zW0kE/YEJnwSJjrFwzTzKMwiIDeDtCnRmnm0Szcd4GEW +GHkiHPfIosSioIHtaUVSgvE+mgssMym86Owj+Q6tWuEiYCUQuDRCFLDqtmx9mV/oDdAbm3YNtxmo +cr/UEiuZiG6XLXVJTi7Y+xxuuUPxObVHs+WnJ9M+2sUSZBiyIPtY+83cuc30lsmAbHR1NVuNkca1 +T/GJVnyBU0Oz9Cv+fljnHM6yU5TA5ieknnfacJ4C+MJyPqDFoSN19xgJD3qLtmcfvnW1yxHvROYo +FuHBLc82dR7Uxnxa5kvjs/E5yKwVzeqWR/6zPoW2zV8QMvsB0yzhbZnPX215K1v4okSr3m3iHHja +6Mio5oc0abWVsgRnYTQTmjwwP19w6WlB1G6LBjCV2sUmEabSu7piSHriDjBZ7LTJQ5QU7libLwm9 +WB29p0tVEQoyrHYxaNQe/gbKo3BF9ztXEVMmyA5st2XTJiO2e2BtfYEiAEQrPUxNrm5+cXCHdjJe +Eg5JEd7phwuOpGmVBYvo4J0I9tzaQAliNFtFsNFP62EyLiEH0eaz7bn2EvcVZfgK5yBOe9Xhd/Tc +FUdU98aPyYbYs5PaaXpoyfweAJsUKEcSts/ZzuFIgAZRNL7K/OUXlalJKszSnf/olwJ9qh4xwEL8 +e/AM76IZqU0OaPCI0y0iCDYc1TnTdtkCkvOLwwIkFR14JurUgh62CKl74hyiCFLjDuaCkey+GZBD +y61dgt4vu4CEI+1oCeTt9MO0uVNMYmnYwjt9H2pr7OTuMc2jOLFHstvgSMGRHd4aMimDnk7tjvmg +HtZfNjWv2pEJn2Quq93c5nTxFUGQiktUfMuK1tNOwb/ceQbMqFyRW8WrBJ292ooDyWNz5Oz24XYq +MVROMo6KApTbMI4BpkQneLldIchQj45lPFfLBTpy5ctx+0AG3nHb1YUWSo89Lvy12ct15n8ddQYp +LN6TdPqlso8T2tPEhs2TadpmcQE4tXR4zHHpZLKuSEPgiprdTsNtH12Q3KbLPdSe9sZhdvP3bDRH +8Z4QOqMG9fPwPQ+PJMmWySx3+MIARKlDPnfV6tGqhBTdHkL0ICWXKVdDbZ9E3elGQpTkzDtYeATl +YeqGN4sH6sDmFZ/3CjrpZALwbYKZKUqu7gQdPOTUWEFql0CxaDeqLZLPXhye5e+0Eg53JeMJ/NCL +IRFkyPV8utbUnPbuAYp+SJYerrGgIRRDuSI6+oWkf4LNHQfhJDNZNO/r1mOojLzDvrwtYE3irgSJ +fvGGqKfwxp1yMs0UmIoXFlpSNWmeP4evUz3JNPAHElyo0QHN/DHsbsSCpBbPkTwmXWqs0gqlpJ7u +xVQNE5YDcnp1VyN+1FP0dzL+RAGuOgBiqtcuUTt7kKqZunuJvMNqBYxfrO40TXOIF8wEqOn9klOk +VRBU2sPpM6I4viU00+Fk7WJlsFOTAOr6OofxTokmPkCanCnFqq06sgsREQjjjrmYVPPIbte44hxI +EVVSOij7DhhJ4ukUzlPtC6HNvpc/e81l+nwPzJLkV92bVVz9qpxX9CiHJes2ZYO0XAzLfPvJayHo +uOnxD7TMaPoBrbjYkXRp7neyuAFp45GRHVyird3/Jgw752eWYRrPy9xMteG+ZmbILFJP8hajh3b1 +V0N84Hx/j5MPt3RD5OEclhRRgNsbCC3EE/vy70uLVzCTaInllUwvZ8WMFcBHKhramQmqrsFPaQ86 +SQWwGuV8xwcP4vDcZEc1Z1HskWVAYvHiwn3BBehH3LKUkyuSbWhqod1rn/4EHgty0KNwUt7ldsoB +Z1eDi+zFlRMeOoPdPEAn1RDqOvg8k62k5JfcJoc00GV01wngk/USyw0wFYWZjlvZ9+6VFP7ur0CX +kYkAM3ZUxVocVJa/hfN53pjmK1vVmkHIoraO0imgyXC8aoEnEL+oVK7u7A9+EafG1sNNQIIbn9IS +hSua93YE6IEXDVeAU4FCgpBWGkC1vHsl52vz8blV0Al94IyjbkL0WiD6Jsx0+BnZwYLssZwY8D7A +Rec0KXniAz75MxJBUHWIUAJfbTMBT+ezDhKEerh3dYWrqEkvmbAGzBnaUe5NnAADvQvNBpN8GLAo +5UiSZ0D4mt2G2yyoLeUPzp0LOolPKFzKlmgrFEqMIQUbKd2Q7P/RBQ2Gd/UkbtkOVUYi/pX1jhWK +frUrYvIkqA01UvpbDxyqnPvW1vznhFkm+17J7lJUhWMZ0HS7LRVqnJQvQT/NFaF5t8lXwH0DJHRN +k+wmRxvr9DAl80yrJiZPiAqBycUaB7Zlck2LuOJAHwGxyVsf4mND3d42Hu1kbbqM5IJ2B9Ag9TTI +ZNaKt4Z2V7pTs3IMquCh6qiNgLZCedjxS1ar/4U72DajMFvxFS1o54G5dA6L4l/oERMDFXsiLnCR +QPUABlbbPPZem5LUfslEDKKj2ScbNWbZI8JAe0Az5lNV2FVU4w59Pe+Ad6ETcrTlNUkg7+CPsbyg +n+tBZtSjSKTK9E3be2DUVCFJQENZd8sF51pXTlEPD2d3aCao+wUYFR17D4mr31cKqsAVykdsAeQY +OpBneayOEXE/gByC9BXfg+qU/RKshFZRGqIQ0rLLZ/bcmV4VXwAvYRrn5uKCAucbpSCAbnPRyW0c +Hi46mQzfN4ui3BckG5sRU+0GyYZyPsB+yOVBvvICHQMaAfj+dDrZYgR8BUhC9cgOFlQW3MLyES54 +FViY5fJLIsFyfqccN433HkQb1Sb5wqxa8vt0V9rYPcAzJPh5RHchjOVsELWppblgkOQKs1mpB/gs +Vn22Owpe1oEmjfvKxYdC4OPigrzCLzEdLmy4DYiTQ1yvCzqwWbnMMulZRtVMuZKhtjNohtC7J6O1 +CGH2AtOJqZNx0jFQLcUjw9vUKJ1W7Ocj384lRGdUPAh2EuFbMse9MnSKbxkEZIW8ZsXuASrggEnm +7y8e2lLCnalzQXk4/Hecn+1MR7UNBVM9g+SqI04G4tB2RRmpQQ0VGn/oTMtXFKxC+T8BkRFkc5kS +/KIcLIYZdZeaklHtSgWwI8vWyGbmhTXN/CK+wgKBe9rrakx58GmqvcjYyZ7d4bJuekayS3UYqN2C +J/r0/LaboIIerggIdxsM+S3scMGmZvwiR5Iyy3k4tg3ZJD4WejSYzsCiySMPEk8BixhsADfrDLiI +X2J5IPZWH3dfivx+v9QyZn01qL98qrQwipXJxKLrhptyBZUPW5jJtrO4wtEhag+43k054opLT4a1 +8cABQbveaxsvL84HRwGoa9BwEuPzd8029DS3778U+b4tanj0wGWxXI3kP0nwlhEf3Vpnhdl8Xhz/ +ogFb2ZCTWX0BkRyXIRqXersdRcDNZUzYmGYbXeTDOvIgTMCJGauVtFAsa7UzRTP0AOjElcFCrvN0 +bZ1u5149ZW8DQEKBX4c2JLeVfjWdkt6inoecFHP5z/D9QxU4fQewr9ajFb4h+SZIpkA0HB6k6e3e +7J0mwSpxBQWY1M5+JVPMiRKGddes9ZwUMdRBmTAWLCFPWjvJs+uZgNmihA4QnuywVqN9qdTU4iOy +EOuUURLg//zsar8/Jcpbc6Gp2KmHQYXhO9FeLoaGlosESs34AQMYg5cb7I7EpIta426WJDeGdV2w +fACB093cQY6TStADwj0jh5ddFhwWUYs5Uie7M1imvaENinHa4VmA6c5JOy2TSunzSXHxscxVQMr8 +gPbRpwXTrjwgE901hDwJnzm+KteoBeIzr4BwoYoP5DyuoCMXXOawIGumGyfK73ElCIybc7BVZsC9 +2ZNvDUhYnl49d862F3pHMt7ocLd17sJ4nV2spgcDpLUg0lxIYwdfTpILWa5kJumPhaQFebFcvCbY +SiI/WKh7qg/UXg2v3/q8NpHy6LvzGFgkxtCB7sYqSZGjKjRPIuFEEBFZrkraUP2cFIcLePNlqtXu +dJFqv5PcTs4QAZiuRZX4Ae6oS00FUvm7S19PF38e9ovKzkfjES5FO1eGProN5dGBJw== + + + HyAMEiUyiJQeoDQruR5Yv4c1SKqbVMK1srSHdEUlGbgQAlNYKHSaYclOKMJKR3Rupyi5KwZrkQ04 +uGiasSMKABGynRQLDvYkhVkp53EY70msSY5GMCoJHu3smpvL1MRcQ00DdZHcqwC4y2HMswxGiyIS +MlMh/JCPBEx6pu7BNekb4mhohrRRCusw9ZFZupIx6+LXaVC4W0KJE4gqxRKyrZjKyBW6deqWaTYk +Ee2ogmZPLqILuUO8NmQbwuWEFkYl8gapFKhZRezBPqByEMhF4UU1xPRTfJEMW8U8SoT7jsfasFk8 +RO0+HAHC9G+ACIjvIElaGHLEf7INmkLJ3mTKvevTTEuRiz9cfePakQoXxJ5nEWTKRgize/gKaSWK +JGnm7HCv+Cs6KpH84Z1SNsU5rd3kKUvrx97mYBpfIcbogfiVyYG3mhsEQ2EzaspMhLIRU7u4wLqK +L1FI20S8S7EcKoibvSzZ8427eeFm4+CRd3jaKUfQp9oTG36/YhY6KZXk31acuRwwKbtypJzFA+Q1 +3snW7DA2BXh4g8k5l3tUcyLv8HCMt5jqRu5g6sacbs5irCc3OnDWMkf4+5vrEzk7N+LA8qtqZE+g +TcrG0gVVmOvCcyJDwTZwjBIahFpuuCBGywFJcrwuGbAglFOzG3NFWWqy+jU+gczI5i9LIQfEciVA +dTIxKixXiQTmEvXJq4H2SpZeFIGG2u3MNc5Rr/usWOPK8nhrD9NHauNHyRqgl2JG0pVR/gPWov13 +1wORd0G8Rqr/JaeihCV8UJkLsAThg6K2sXpEXiB+KEi2o/K5RNg4osLIDNwdkfKA3wqGN51DTe1S +ksz8+0nBlxK4RXg2BZHMTjEKt6aqxRfqRE0CfOTJRSmaoNrNriO2YkPS7pSKotiMrzCPNNYXyXoQ +LU8nR8rlSLq5FZOH0CLJ0SWLWsKeY5qwfSLFjGRDwQONZZTtMMIup2oUjr/kMtQjINAUFSTPbxhg +NKKqQwnqbQotmaKGUy2ydsFvki40GfJ2SWecro9IFSkKOIWdVCLBYNmqKVGbdgavaoEvSxLq5OYr +kdk7iVQ6WxRKaL/PspUgcEsjDEl22IEfmELOaivGPYNsY5npZwrLTd1U0k9zorKNUNtlOu0ULlUn +r6HFpuNMx5W+ML3uJAtPLLBWlQKBpIiaD4DD8LaOVYoMTOWjRZUUFOkjiAgOnB/GJ2OTa3uROnxY +i9fuO5xEKRtJ2/PAhSUdSDkq2r+wLx12n6st1bJEeeuUnErCO0lHlAAornMFq4VEhI7EgsTn77g8 +AAOfESAEFQjmEoSprjRuusXsDFnDh2X9q0fmprQm5HgOjrPhY1mi8KjBcIR6rjAV2bXTZc8IfTln +Fk2veKRNcKT8JInbadBzNC+gaaA09TSihVAuFvgkY5EOmYgoWpvqZoNT/G+uKIxGPik9rnPm9VEN +k6ZInp+RztJrpLCqA5YlhZD7ipAiW4QQhtqlBWWXPk9vqXxAbVMU3Gq84JnzSQW86SRQvIHqSE4R +hjbgPIRU8E5iO0WZOVKEjfCoBpFIi9TC0kkIbXyJw7makgAxgwan0xUYdPHbJqeQlcjW1tnsoh+S +Yy6PLbW+5LghJjH6ZjMooATd+3IRIfXA/zrjsB9WIHSiKPcEaEIFPtzMI4GaUyCgpLYt4ImB3gew +DYBGC2ZGxDWUsYtTLpAn1RyZpBQLVpLAreXskKMUq8AXE3uR4iXdW+coWkI4vIL8NBh3hb4XeLQt +U+5Og4Hh/hLSxlXzKCxvtBaYqxSOTmGOEgCqUQ0gOhmcWfSu2334cwnvgwYLlEwfINiSKw9QUbwC +u3PdhGaZJ7wiV1Q7kHJgrlztQJMr+PSSKMzWixVw5TRYmBHS1A8SsbSLQEcPy5lx8pTGiTKM9ciD +O3GBCCpyZMeO8Axkh3euRxyHedwEi90IqlWxH4oLfYQ5mNd5IHXoksXJuCIuNMiUKsmAxxHhjpIt +AyYJu6xc8qak9LZSO5nc5MbMCEYUF1ngjIIlMbK0FZ20jVvkmNCJ4RqWLWoEHiaCoRgjocZkVLYI +9hRpPRVYmWwlCnEWlIQc2MxslEgxqZxlaSVVnVLmqKuV3PaesfHg3qYDZyg/OJwu3yyMLf+TieN5 +BIkViUJHaLjF9h/lZYp3XVFVncAkQAsbSVNI3nGxBSV2hfURn6iJcZPTBDRtw8Xtkxzgmmj5jgBk +LShPiS0bVibvnEhRJQe08AXQzPLsZAMzZd/KDDwsB46bk/sVEZ2z+bG1n01sy7yTO8A861LpWDkb +DSbiWQEvtZ3h6xNyrQH1R84inECYaXvLk6gMjjG6UfId+ko/OojEQoQXW4awA07/AoCkckMOpwtr +9/o8JQl9ekgEplSOvwmwR7NjhVsn4NJyvxXjhjSk0BIUkzVIwmq3i0muFgtc021Un/BB9leba0sL +HtSihLWITmShDQB79Kx56RH3jU5y2r27ncelzRUwHuihpKM591GvSCLWcIYRECjkhnr0dQlEOMny +Ofv3Uf32sNWZkEvqGMZInWw9XkbdgTIog5bHxGmrZ664zqVgj+PWnO8tO63dYBqqs5CTdxpgxn+r +Zlzy1knOyiCpHmMSB1++cRUp7d7qFK4jdrN04zOFQqrTIpqnZAXBHuCaT8lZY97eUEcouaF4dyFA +YA/DtkORabwE3nF9xnAKF0RV9Saqp5D/kPmBYzPVh6IOfPwSzdDr6kVHMWqXiKhOwmnNeYCoOb3Z +d21FCFsBJh2b9NX5Y3i7+YELZnfrWCJ4706DPm+poJ7z1Ges2CqfmZLOhVjQAd5GpIW6jsG4cZkk +5Rp25hfcCBW0s90UzWmnpEfqxBtG5mP+eBM5m3nygGonBIGoDjySwh9UEl+cxi69IGim8bxsX65A +CeMYdhzD0P5p4CivwAV4e3kn7DOAztM+f0i4pvebfPYVcK1VMMYpKwtZKHeZoco8Yc0ue7GrS1vp +OF9eHdXbjVyBzHqyC2kZg9YA5iGuqHrwrldgIWcDilItjxHpM4TfxAhQcXyleVK2AbHMIBRMALBo +ut5W0HNkSy0WIKASJXFRWjOZKCKnYBSVT/DIFrJn9ixbUYI6eCCwZUkcSz3c1+Uitkk9haVD3gqN +PZXSrac4EpRZ5FJbjLpWRfFiB+BSWpRqkmtx51DNxRVz2KVIgNemGnS81dujkORwfbo/iqv34YM8 +wv7FMyBlNGEMsDEzIEg0d0kZOMDNWlOMTMzNNdt1kuPd6JHZtWynZpcb9FlEplYGRZL4BZTzwzs7 +Rxa92krz5gqhLXKYNjqLWQ1heoupW15x/bcAwsnDyef8RZk9w4jFfGq1wwtSPpxEXN/3ooeirlLs +5FKXFt+5ARWFpxkt+D3hE/UMqFH5YOv9WPw671dFwUMpyw5A8bkTEAXaPKoIWpnOecWCSlBY5uK8 +Q6kyrvemHo2QdB3FxHI2SwLMQHIDC651oDGS6vjQVRxEo6P08+LsG1VtgCHZ+WmoY+PGC/LMopMl +27x9wG+LqVc5glr8MBJHuDQSFF3nvCufV464jMqIvqS9oJChbESnjOdisPgZK9BaVzJdCWmsYai3 +NqPp6GUvaO2JqStX66DNMOOTY182YyUj45wJxRqkcUkJx0AszA7+wBJgXtx0KLelOESSlzNIRY+U +0AwdYskmPn8I1/hhFipBAAo4Hn6/70gkgkQ+PGMr2KkIYChoIW8Vk5HMMSW/qHxe8lYVl3Mn/xY/ +jPIM+DBQ9fC692SC7AY/VJ8tGLZOyieCE2q3uAFMUh2Zxp9HKHeeVm1WW/Q9Fo6dJ8F+gBaOsqYF +kKJHccaTZUltIkraP9l6+QQ6IT+XTDB4qA5TUg/7JPH1iP2Mj6gpR1o9vFo5WAlHVGHP5p6qy+n0 +Bc8HQesFYYJIqUoyja50DyJMhfxXPOAazJ4uitEB2Tt0gCcXbGnmZmiBPJOTsRIClOqEx4NiXk4D +r2771CEhAnspryB1QD5qjrqT3dknLPaDg8w7uF/4AksMbDePidrFOwydpNgJpf10ID6hMzVRVtPq +JpG0J3tlUrPuNXkkHsXQ1trwFh38Agch9e7nNA3R7N7UDuBWi2Y5QwlP14uDC0aQFutLGM8c9KZY +ZQIQpVAJ7KsE5BXfRvPk/IAzPrKYgc/gBjQ6ZeJjkdOwMdXKDiw2Oki8JW3OkVMkv3LQtDUq8c1r +2GEgd0o85uTU0J9htkxWhvTn0YJ3UmXooEbrhrViz8N05uwJfGUn55X5NjNGDjSDwiRKyiv6Ww2M +W/gty6kK9iieCk+ZsZMoSTJzFGABGTnWhZWMlzLbV4kctuTTpwYaXu1l2kW8Gr6imEnsOIJoxtSm +ZJLeJz8VozBcwtWEpXz1ISpZaXDAYAvUSM23Fbg3aCdWpLX0i9qaDN0FBttOP3yxEqAJHTlA0L14 +AeCehYUngzQZkUKUA9mSLxBYVHXcMeqpZsTuFqJw7GQAPhj8GlaAD8O2L0NixXdeZr+tmm+JZZJ5 +CLWoZLyZk8eLiAiXoLzStnvU7hUWWJsckKjnhZiT57gY2jkNK8TtBvDSKaxT5JxanX0GsdLJGER6 +v94J6PYRd5hBAHQYHc4VzrVeFz4dQN8tQjgt8u4EaSyExvgu8xeRRQdLq6+AW8mZYuWSP0uF0wsj +yTJU1QRn0wxmZw6d3qXimIRspcTTvfyx4aGvMv+TWOjIGz5fypwog9wdXYdFFSl2bdycYLJiy5kM +5KCUgh9nBB/JCOaZE283nKjp+sFlxWK0oWNKtEC0dddE0sozxyg9Zs4qCpKd8LkW1j5MW5FRXgn5 +8z0GJRndOkkVAaNkslij7kDpWI65XEGjYjrDM2wRrWFyJpOqRDoQTzD4rxK/1Mvy1TVYRoKWCH40 +IzWbLUhdUEzGhu8Ue9nQpGyMEyQAmKiGAgwfvKIFhzkr0qaLEYGkkp7HSR1e9uRAYPUaqG2ug3vS +RFKmka8CKwk74ANhhIS9h0OiUqChcmzpBGXlR0p1AQ9l0CPFxNvJpnNWEa7Ge1GFpGKeEhPnim0/ +MPwQW7QoFwIDbjemsVi8MV1GJEbP4Lj+onYx+CGheqmn3wEkBkpAjxSoAGDcMeICYJGmI4eePYe3 +oR7tsbY5wtTTTQ2clE2qO7QVvAPZZfUOwyb3o6JQuIXonldqt5g8MHhY1Q5CuFIDF+sa6urpcKdv +9bnzC/MSnnjTboWaofVcd0eom7c9nHMFmCzkDVJRmvFdhtjcYiSzgdWib+lGxR4msSNdC1Qs8694 +azOYF3Rfv1SrAhoCEjTWhzNQbtGjW0G1V2cB1DbCrEWmKEg7HCFa+MlYPNxecpkMrqio5aBqAxtT +Z6B9awO7Xc0pMsJbE9WGtY3X8ktd+MZ6lPVZFlLziBribFYJ8eqp0Ehng5ZBuIagNedkFEk+2/79 +WLeCt5G+zlEDKafw6YLuo0HFrtjirluYT2PeQT60yCrX36cPkq3YeAEGAF2p7RNMoQ== + + + abenkxmF1M8p4OOHJ2/lOPCictj04J8uIzkSG98xQ7yfaP8ZLIxRmlBtnoWp5CN0dn/5QucDBk8J +UWeY6JhziV/Djk5dUbCjw9rmitT1AA1eDkIhw0zjQCKpEiNiay0XGe1npXLYR5XmgA5CCgIIn050 +wSkIJI8rJmZOBasOUWNX7Ypvo0eyjnrIJJLmY/HL4HIWZau4OfsZW080Pxlk0F0HoJkehsQdLkTT +WcxKxS3ZDkGB4URDwQhN5aBwzVnYWc2OV1EZJil+ABubPr9NkywW2vsEcNsA8x5pDeJF6E6tcar7 +EbknWuDmTRitOuJ2wMPaXeFXzeQcFIKgioF2E8PBPvSQJKZsVZuo8ghEJ6k13XlSzmpKi7QIMuNN +Ok/MB6LgOUJvS2RaNecGofaIBSVbvSGfaCh9OPv3GugRZYo6US9/wyW5q1AN0mg7nYz7MLvE9GAY +IIQhL+1ydljLPMLbXe1RnJBGmm5ykiMZa5dkLmFo5ckyYWRXcvYI1HMPyx2oHFbCqeyPKGTdcQb0 +S8lKyCizX8p7C+KCrNy+5PxqcUsN1yePkYoCNThRnN1FHHDi+kimKSCdsEd2f9R9l6QQBL0H5Etq +r5ATajudcKCbwVJw+AqjCNUjM2ndZgeira44FTtF1RcAviQHFMmAiR8A0jhpJReBu6CZRJzfXgDj +yorqqbSrIE3Gap/cmrrA9cXJQCSeWo5IkyRjcUUKCymPMAKoIj0FH8QhAIrwkmjZeadJ5Ygzm18B +2ZitYMFbZwKa8vmTbiDF0JmZ1V9tJH7Pnjy1u79qDMPTjhKEADpZXbbZhBEzUD2EPtUeBotdbDlZ +sFzQ4K7MeAnBOforQQoDkXMO7D6xiqPEwxmuKWWX8G5ui5NBMeTk3GT0mIgqT+fALmN0iDhgPhrm +Z7uDSmLEoZPZmt3DD/xnKogkl9GgjYNMPU4ENiMBVHs0lSYqDFFxNjQ6B7/fKkS99NB2/jX5bSm5 +hGEPXwtXjO4EfUcAk4OScBRUImNntj2ZEQ6NJ9MeYPdTwuTgmXvdAjKiErHahYhEol6ArygRSzdN +ATlICfciXwnRpTPRI20bf3AK9g3GdU5npqezHY+Afo98ZsNHLSwUJnd8b5k3tQYnQGYJu8dvPYME +oBpLBS8szSOy6eFfU082+ko5eH7C4ajl8A1o+4pIsRZNm6BU1VneyCBDq3q8E48oNl8ZmFqMAcjx +yL1NFZVsTsmuuQQINnUn9dND2yQBfiYLx3d0BFQ92dnoFZKpYg6pc36FKyCzOO7AFaR8cA8BtOQH +8j2RrgrgphpD5ekrVp/pAQyFMulHAsCNHH5Gnq/o0OEUu6wVay2mNjgvQGlnORzxFfYkFcMwAGTF +xquOzpJQyEiWoJk4IuseAL7azYuwGrpMwlA3dMEsE6vFEyJeq6S2fuJzXSfU72QASL3MDol0giof +R4ykwT4mnykXBiYFu2KjEO8FHNsDU0eEucVOPJkvTi5f703h7cNZdbhZYs2bdF49LYYh2Dc4z3mi +v9oUs8ECwBUkTvMLo6t73FKmmEPMNfxjMa6QDkl+uMp48DtgwaZ6qRuUzTQjALiFB7xilCn3TreA +quGWDLiLr1heHNRWFGaqmndgqxVuT28rMMiwnABQ4YpK1NsUxsVKYGrBoFNuop4tvCfxi3QLreMC +l33vljYwl5l2JX5gWrWGy0EHi5g7BZwXecVJVWNiF5HYcBItgPNmvsquC6e2oJwcTS24Y3o3wc50 +6fnRzPLDmSTkR7LeMWMiZJen5ePR7C9rWJfBh5cCxgc1gkW/LI/2GCUPcUuz/hjbMXzmQ5VgxhyI +pE7uoW4/es8X9AduU7iKejAL4cKAPMF4kaLa6nhouwEIrbhZ/XuS3NQBir+7VgtMCKXevQBvoa/o +VjQcnJeR4HeCqU6IhCOoE9Z5BYhjfOPm8QFVBpmCQTMgCNDxTrYjzFdrgcN17M3BBOMoOD+rbOjN +Zi9KNQjRfU+Yk+BfMHaoBwPYGicHkxJzzKlVuWef1rg5d4SkyKZWp6wXV5AErp7Ds4Fv4lR/SSGx +OjxWjdGF+0QdZmBaM9gYeCAhVLVniVcCk4BGPk0LlUxjRnq12uLH4e+klKpHzlv1VPNGZfuVt8Jk +lqhqmrN2LsELX3yLtBho4RWtM17UBbKS63AHeVYPKnr/3ZzusDekcJn2qL9leq5uCgnnJg1zMRH3 +mN2gr2nytj6DPsvEJilooYYRdxh4zvVR8F7eaLsAAKmaS9worWFyyR6cqmo3k9hFdTH1LHP/m1PM +/vwj+AyHs9nh1TOfHGzNxWTj1YRv5k0Af6c2C+E467app5ppoekcpH24sFgz0hZIHoTpPa4A6C07 +eJkv8MgtGApN9kcqJJY1oQ167DIgrAvpnWNcl/YwqyLFBADQuqDIiiUN+6bt/WXmvW6aA9a1mffw +74WPQVCfWsPnwDtyluOkqMGziB7Ulj2l8Aku3hH2DhgHU9Bb9pOjMNmXYsLLaQ4eeBH8FfKQwHoQ +Xw27J7QIBhO5Hona2fCj4jAH4VG+mvA//p5sNFKOWhRu45KF9TPHR1BnGxeSP3Mkcxhgi6ZpukRI +EI4Y2BGOLgJuYB1NZgqeEsSTm8F2Ol36gVCSUVewEs/LOJ+UBsRPuGCZ9aCJQPvCmDmdYpCCo1Rx +gVSDgPU4PX76S4rxkH+QE3AZJNKiKjVXOIgq9hvToZ5t/AECZR2u/tGNl6Anog816EyrgzHQmb15 +daEvJT7hXyj1kyjeDAZVWsWUWSvofYf5YgT8SqamRS3ijqYUHs5ZV9tcDegcgobBK+HyjnwVyDcc +xqaqZcTVzn7nEQ5nEA6Chod/GJ+/kGSSueYP5gEg41ugSLjC3B/N45Wj+qXayUizw7Gco/bgWT4C +erYUrgY7ayCZ9jPswtPhkYH4gQ+4TtfkacOcxq5VYyTM4d0kLFuh1rEogQ9Hfw5tH65w+Oc4jMZ3 +6O5MpNAF1FEpdiirPcw/zUJVWwYclXZw5SgTNBk2wEkKl3Pills1gXi5uBnxonw49wDC6u5U0h6l +AqYhxa7sUAxp9SOWObD9zv49hqC5pYtBp6IwMxt1OmGorfsXEHnjKnMz2jXeCFNSwNZSgq7apQWc +aKd0ZFPyr2MFV3R1IUM8qWoGfzkpwmovXxB+HMibOz0A9VIk4KsGxzCou8A2nowZDVni0szEzXQQ +UGU3nCkJzmVn9rs2pbSfUrkCio3kcrPw9IvAniwHYYRdOxJ7j9NHFTHIyHSygxDCs4XXhJ9DNuf0 +U6qULVfCIhnrqK6qnIZrwsJvv8jikSSlnJfkXZKvMZN+WO29w3+u2nhw0yc7s48S1StLJ/Q0jPUJ +x7PCZtNk9QHjlMLXu6tvwZaionrECSuC8l7cULHE0gxQjXLlH9CB7Yqr/U6rjbstXE2kHjmhilCN +2lJrsfj9c9UZkjlfACqoZzofdmtOvr38sTLfuxGRTn4K/LUfAQNzcXrPnUdSuUBttH6leJ0l8GZk +2BbuSKlPmfNAqprBr2onNNYSHA7q0QEutBHchVE/THgvsPnFmiwIMUByWjLyFQnOdTiJFzAieD87 +PoKwQ7lt3SOxqutBHpEwQeoxxTV8h2HuLECEp+sjAxYySFyApT6NIezOQXZZszKcaZeyd5PgRtXZ +ciTSl3FZ2DhuuKLHFQTQ9RZC8cq91p0vB1Gq3G/1km4ZmYYkshbyuiPvF8AsLl0xHi5Xc4tkWe2O +RrlFu2cOolwuKdnYLJjoXFCyL4Aqmht4ezGmagOwdpKki3SSCXJcUhPJoYUR8XC9wOqETZDZZAUy +9XKUkuAj/SCbp3G5DAnQbBypZ9orihuiz4VOIiedLDZqdy6lwWMk+Qm5kPSuEAc5o2QENYZFuZJy +MnFqO4twuiLXgtbVRU0nmcQHVGvA/yAfdNqqy7XINTjDJ15C3VjkEAFHI71A0bdaAqao4PJi7QKR +IxVC+a2UoOm4C4J8nZ8T6QMtbBgkVYdW4AColAIT4ZpOmCJzcSlRyvw2gO5Gg3MxXglstzRFcZxz +BbbCRJkqxtTBf9hxLastahMFU5PrVXZHvCZeJX4R7dwDx8fbTFvJXADtjLZTpCzjdFTOnxz1ukCL +YARPlHe3zinQeoEd1JodEcHWwGRyzjpgQmf3aG2OwDc6qVEaoqLzoBeXnjBCTkviCGwhe6cFFldR +9EnSJBmdCP5JFn0INVI/ZlRuF+JYAGCq/hzgOOHPmDhJilGvcBJM62ElCAkIxhqfi/2oKOdxJo5D +I4EZ5CqxpGYvZll4XtJgQo/z75WcB6tnMtHI8lYm3KC0ue4M/2AeFjIXvVxFuIwoPlpwAJztOc4Q +CIu8uvaxxAXFdaqLqESis75au0PNjqpMamsbzlN2/R4cy1AdLKQ/fLSSgUc9T6QaWca53x5ZOWRD +c/kq+BlSOw+kvHwK9n73yAIKce9AfSi8jj6Q5Ir9sh9cBf2QiBu6C4dRsJRsshSFxCaZFZmNK0Wq +u9ZMlI40KYOCIgNNkPxo0OQuwliop6YOSEaUD+JSNNTcJLtjkL7WnVjYijcJxWoK1VDIc8mReq6C +LJG/GjnrlGhJVoEV5aWQlalPUN+5Q8OyONN9lAyYsB2cOBUV4ineYC2cCFkKnj3AV84qlHFaXNcx +kuYI+4FeqbgmwIsZc7bCuQGOY7hCFc6Q5OJ7KXKE7fqlCJjvwTmlO5AbPRyLgsnsKM4idnXubgwV +VPBGyIgUzVcEQ5asrDScuQz+F5xDikKuLXzy+D/6sHFQmn06l3QtMbGkHklnUSkXspBFm+jGmUkX +zyj4bMnQptjMxCXbxIoku6uYXLs6q6M1izE5kgWRFq6rOoZAklWL6rjkcxVD22rkxpt1K3Q0+ZmH +TQr8jXrkMaKkqf3pLV47+XP0EqCzU1A0N5tuLPUZ3m0oq06I+Jlm3qLysVz4zshRj0L2ZJZSTMiz +Ue2ba/lMbIuwjjrOjL/k8mbISQU6mjHmZ8Y/BidXOAmshEkbmX8ni0A7WfJNMsAFns/iEaRGWzZN +weHdROSI5Foj43OwhGefZlhzjhd2m16w20I/syLJ8Lanxy9OgpqownT+fRjgc7dn+BeM/ee11/lS +2S9FudJsnLKaUsipRIeuGNVtKCYVkVSQXqb2PtVNBrpVq6OWCDmy6bJzCxrwhXIhfNBcLudF9oYx +q57DSi+qupZH8jhBSxheaA1j4DdT5KRmQ9ploxJQzpFzmIIsKupckaQQnzWCOM7peMHtrLZ2ObHb +5CcM8YcSunUdSUTPyQ1E0kOqZyY1D3ByphAB00bw8jghYyklZlMBkjseQTYeVpW/mqMF06BH7eQ1 +nH1NKOjMzSAKujARlQ1CSNP2n0WUjmgjp4+biJrib5VJOb0JsPSwOM32gEnx7hWMeN52zkeeToHS +1h5R1k2yLUUBPco0UycgRT2oOkJv71Z26vCa787hdF3n6QoJiDYZyskUEHgPZHiH2A== + + + rCZiVU+xA958dSsGbjgHtQZLLAQNCNoaVZ3scOXsPYTVxGPWPFKXk5ujvDGNMLDs4+AD8jml45+5 +gnKhYackh3ZBSEa2xHQqZLCCUon+OElAsXRaFD8m/CBLx9EkcKEda2tFvWOzAa3wyULpR/6HYYzN +4XJx1wyX/cIlBtHdYa+bfPgyjdaZBqOVQwHG5DpytTnpZbEcWOMoR8bNH8HyIjk9XUYUK7X6DBC7 +4XQmPHVsmE0wWerxenGWTI28jajmqdR5afy+QHoWyfSTwoFketA+XOZbYljtPmKBSfctJAK60iCc +Q9WFqOr0mVJCjpM/jhSQYlpMoHiYIo90vRpo8XJxFSiBvaLqCvFS43SmoKMT4lmgUEiQU9WNKVGK +mmr9qfa5XExkYQ1qoVPp8GRxcvXUk9eJYTFJJulvWskq4Y4eG+lxpPGjypRsPqwaCdpq1xTlVGnB +p1CjzjDZcIfXzOE8U9LwhnVQalK2YMRBSJfs4j9qs5ayy32VYY+A2nZXK+e1mcyKiHbpRjapTX+H +ZkXNReBJlmVzRp/pFQV4LTySao1o3DyxDNDM0vLh88le9/Xy0lQzZP6GB7HD68kA74VbAkSlrxeZ +mFhrFFpQUqgihCVgNJCH4RTCytHwKltlslS8sKPsn55VbGhG0T31kDZ4mJkC+hDp0kFQprbylsmV +hMtCy2+RqWs2idA8VNTzTMmzrgNtRmKFm2JRoavptlyPSsgl+bM6Mkydzy5jQml7iv6JaEO6iiyn +aUIWc6FVM4hAzAYythgIT+axKp7IJhXMBSIOu/p6w3Gq7OVl0wm/GbnOTog7s6n9zG5fDzmoHiqo +jrjiKN1pebKQRS8nnJPMfxMeKI01L+fYHeSAkw0q411DlItJGLTUpCZyQVI0mOXZnEXOVlRk9SCT +lhijKKWmS0kmlxeSDMR2IldTrh55ZSnrmas5psxgly5OMorHyFYi+zdIpXIQwssXdKyIWFDnDvdP +qradnMd3NFtKBecQaHbiPrIky8lisZwdIP/DNH9PZO5GGiBRmMECwpNMTcTmBTVtq53py6xIxxKK +03eFeqRpCUl2qDz3gm6XwEo5OCCTUtuiOMjSQiAeNmnBCkoC1hRshUMsydpp0lkwek27A9OCRlEB +oBKVSeEeFA2nE7cTyffyneXl0t+kI5O1jq+O/GRcq5ADOfGdYhIs9UROOWtDjIMulJcXKcc5HFjl +IEMt93CCCtqQyIRGiSDjGCIk9Uij1bfAFxppmsVZRErqn1BhcJ6YqxQ4FjR8kwugtVF7kORvzIR2 +Crn61Rp0MZsdlFUFxYAaxdoWLL2aTBnmmrrKkuyyTXPgCJUDqdQ85YYXBIdyGqt/gSeOItymvEEH +q3Fsa5c4TbxWq7E5bBTlEyv0pfb0MQMkSm3TFNeGqhS2jqiEpakrob3CLAyfgfggDgJfwU2c46Ch +hO/g982FyzFO4eCp2Qpnkx4lJ4bMkLrsvCCn/qy/nKO+rvlqlgvT5NDVavhY5WeBs3neRFI+sQ0U +CFCnsHT5lsUhOBxbPMGhzCjTIe3RXpF99KGQulrPcp0XvbKQkwpnuUieXqGbuKNaBfI+hualnt73 +dRYOkUaTfQNI0MUifbLJKrKmUerpluuLNwK/LJdJfIJjFzNqTs/gWJnmbYYRx1aegBMHPNRnzTfI +4dDCTWqGU+5d61kHercYvtGrRBqYphFtVHx2rUbSVCkij56awtEuRQsjazp0Jt6e6oA/BQe5Iru+ +JPFkaWJHICdSaF5yfvPSa52aGZo9UwgTUDPqRcj/Gq6W5HLg/B5dj2J70wny1VxDkOjyhMPwpeRX +Oon8okftYs66yQLs9tdRhK4nX4GzFvzQwS8UJDlpdWt3QDWFk4ottJLtE3JMtaVyC4IazXczkg1O +N9svwWZw5wpXvpOja1rjpGJgPw8V3TOd+DJxnpBCV42BGxYF9jxFbXGpnFh23a5TtcH9di8UKaCD +gcJigonKBEjdAZhq9GoKghJJqzpvefj2BdmhDH2mXLGiumqGLMHCEhZ5pKyatqWZqI8TUz9IF/yR +/ppMfEdZSH6flKkP696BPCUfFORPWebLdF1Pgi0EoVBE1FNs7nEgqi1A6IVhc1pMOc5Vg6bPQSeS +o5IjG7eknxMDi6iVuSqnt1VZYexO+2hpz6iwejJAUCOKHhNqLjbqNHHDDFLjZWFEhOiUHraDBtxr +UiMEyC3D/EzLy5lTiOERGESwCLhaLW36CJaSkD6QtzrggydsmbWsuKAB2I/s0Czn0OHA5MMzNhvF +mtUSLOWEA5y+dteanuGcX4Hl6CZAr/2C9FArm6XI9r+8/VoQJ05DqpEiMNJrdKwpalJWoCRyBBj6 +iZvo1pP5C4pM6+b6M4bBpjXGpCtos8rutFswsh8uqA0PEsrD3gzdp1CYPWmiYAL1k/YhnBnufsL+ +kOsdnFPk5EgRkgeJ0vOmXm8tmYU8OIAiSz1HZVTp6DJMIaiEAkbW5f5vu1DklWxWIrvkhwEGUqUM +jRDT4YWuHYw3tJPqmf4FpKd5BSFrtYDP6/RgJyoEDFjgD2P+QdeVI2DhxcSNfCyPyAZBycqDjDsF +a3N1OqGCsYdpN6CccV5MXye1B+FdmwgW7Id5xLEpVlTAc7S2c2ovkikdKC2EWjMTUAI+DGKD+GUJ +EDNxy2MYUtBhIYbTRmpcrZHItbwPKK+OMEihoruqW6zbo7s2XTE7STVLuIKY2S4NKsfPyG+UtTai +WFkHPVui2OZgcLC+cd6PyCSWQVurrzDJvQzWI5vcedjaxEoTNlVnS14+WrkCUuq8oqKwwlQZqiUo +unuwxcs+PborZC3TfE/ji4FDTBM8Nd4yEQnN86w9QLT1QGlH/J3ZiFLa5e8fgX4K/lBd4OpEOYgp +RjBA54j4jKixpyVczqE66Ryh1JJPUMp3hlGWaOzkfsnFHZQ0fJibSyJaFNnSanJAWmaw7EPdheyY +ANTR0gELKkTPA8Pe1V5pJqJEe/MKlBtCavdyGckWDGbJMAw/Mp1+XPmETZLmxIXiynPIkhYshR1p +FQbdGaMAJGametAxINlcvBVLOwXhM1kGPtpWYEGazSdAhuex309i+sBrO7Utkonlj40aBuxMdC6X +iz536iDvOgUtRYIfy0opxNbDFYkoSD0DQ8lnSANQTDVnsxGlcTGU6nJ9XjY57L8unN2ttmraekTM +5EUUo6hEJJB3DgvsRPcQpyspQkvd1MW4zAoebZ6JKDd4qboaRskuKZVOh0ewuzudpPsKaM+Rl9X3 +hAdfXnPTufN9KQgofFxkczOjbZ7+UNBpq5q7OWBATmk9nWFaK/+/q7PbteU4jvQTnHfYNwSkgU13 +dVV1d9lXEi0BAwi2YXsA+8ogzhAcAUNqQNH2+O294/uy1j4SCOKgeq9e3at/qjIjIyMaOxAwfAzt +hivKbKZTqvaaWwjQHnaaIXidBc/upipfZ6qJpQt9X000VIXMSn4NYtNxNCr5hf2eLf0s7NNnV6yU +NH4zxpC8033g9JEEO7ioZijh24sAFDRvXptHYCnrUqIK4ezdf5c1/dAAoRnsBxCZZQ3bWVI0imh1 +V8ZHI+O9j4DsHjQC4Q7VVk/5w7mvsaFn0SKdzZ3s1omoredZWbbscR37NuJuxkbswe8JlWrUlUxr +RSvto5yDkuxbG78Dg7YiRb6u01HwaheY3QslR0CtoB0fz+upIy66CQCyXhY6tNVW09oV3DsMUFfS +R3j2LiYWP9UfTUPE8ZIzo+sJQscSSjkkWpEp4phwDbXsmUN60wp2a9tHe++pPYQuAqtOTXPJGYOS +XmUlcbAIQS0sKWUQT6eKBvCd9/5YXEYlpSfih/SsHiUCTu8PVhcgiagY0HG6xDfOkrHXmSgIh8rI +optnFfdPM64o9tGakC6cbdjBY5bH9ZHuT99tXgFm3HL4pjpn014U5vwErtW7a6rJ60hNrVn/I+S3 +pe6RkKhJcsiSs8RXH84+UGSb2xUX8xDVfcchoUYl/GlYhmWx2r53MOnPdhVrD75JPLdta9u7wFDy +8v22MfqyWeqEG3ftTBRRnqVTDNmylrjrOtU7BpnAdMlK3gO9S+LPbeWE5R0r5GAID/alcK+ylnRt +OQm92uOa+g22nOSFS2eVYs9CREcpRrkKJdpBRmJL1k5X30R1dKt0aTjzDTv0mwfgquympCOyJS9o +mhVVTVdp8P1JRbvzNZGd5X+ahw5wtBwUT0taZ3kAntP39P22FUn8klm9/ahO/IRj1/T+2kFQPHZr +d1iSQHt5sxIfx9tklvcINZBDPiAzdbHNDmgGY+xi3aEvM1MrGdrBXTmMTMelMdRFR19i2bC/D4QG +qRA2jaKewc/u5Q+XXZZ+zyHM8dSVzW1C8ltDrjswZb+L29tQ1IHaqhAwSTSYO02CeYrPqwiZkDdo +VRdzJ9qPEgRJFDBX9rgogcauYlAHaGVznIQaz4zS3uh0bfQ36mADbxGcVOMjZeAXZ7Er90sKZfT3 +Eg6EPhLSESYctPGe2l0B7KaHRqrA0MwMNzXFPFKse2Czp8c6gUMkbFNMSF9rcIbIPrJAgb8DrihS +Ej515qsBKSN/J0gYpzBuHjiAtDyCnFMvhYjBcx1HwIlk63DO2a6IGL6t8l2ErbEt4JKz4D4yFGcc +yh/uIXo/YlLEy8j9JOoNIEWROQW3G1yt97KTBf2+hFu3Qk1wtzS+lbFkiq596btbBnDJFZDFWdsX +b4WWetFeLO56Lf2JyzmvROUvTarGo0dMeAd5yAOJqnGNMvXQeg+/7jDCxykWGC2UUnoZsARqD28+ +WEjHy5c9pp5MdrueuSirHG4fVGgDuJ+I/cjwDOyGD+gkF8Vo71br5wK9GsMup1k2BbnwqgMtKEEZ +91EiOdQLcogssmHA4r43VFCNGG9eu5zz0ypdo2E090K/4QXzZFQXYmTbE8HnSo1DLRe1ldxCakuN +dmhgC5VDPJqmcbKpzRygWp/samlayG0PLgYwe3uIrBhauQccTpxHo4W+hqBR28MntYf+tEroL30O +388JNjVUvgCzcTR/Sv5l1PqL8Rk58NDH5Cl5oVJXfYgGVYQ8wD4zqyQ3pux+L/i4yzr+THrylNVS +3oEBH+0pq+aBbBjs6iwJXPuB1UZ65cZ0YY+kiXTtPPdh+S8UALgVsEhXcYbHswUcIoKSWZXHWN+h +zBEZ3o5Z2MdjdxlpqvaPqPGXExtY8rjL9SvpzX7xkeuwdWbEhuP5sBkaAid0B0yvohUsvNsuHjG7 +McpvYqit24rxlBs1qMcDBx2jOBl8IBN+3u3wFzAm81cDzRjhZKLnZbbpIVqJo5oI4feuy+6bVc4X +qAnkQnKdTmgKnFHhVb7HlRcRnDXuVGtNfYhkVPmRMMS6IgKB6LstuV1kKQ9kxOiS4dzadD6PORea +CjnHu0QunqD72z004Vxag+AxGa2hRwDPSVmMqfU2bqKn8V1S7VHOxPTjM8WK3ISMNQ== + + + bo0/L5P9uG2ObSmUF91bz2NtbzRfKMed/vDHqxRhCrvUeaEu+wDnqzoiWj0V1caIYdtPNAt+z1kN +5L7WG2u8lF1JOW8uO9B7WbTe1RptYaGmGvCIyY9aMnkxoUi5Zc7qrt1Plw9fxC+rylQeQ0TPTD0w +FQOQoij/CJTiUyLB7LitVHB5KUqOaqbGnnRpMk/cqu6yz+tjMBEelcByTioTOlQ7/R17OnPTn2at +Av7B2ByvfMNyNQP3pOK3rCLSzPIoHjtExt5sfk3rWl5rnD2WrdGZL5fNrygMZKykE5iQFxJgZ9UT +LmYI7B9RB3w8RuE26PLktcwkTa1Cpt7U1EgT58Mmdjt4j8hkHuXkUWWRSY5pI+rs8PCuao2ON55t +chRZd4/mfrHPcvnLKSweqBAzLt1B4FSFykFd6hY3oILcHyMJ8fRmbxlbGnuQoo/LPOw0RtTPZCvD +wzzkqEMaPDW+JU8rZxm+Taia16w2SzDekDupGLx/g787aCNK86d+JHr6nuro5q3AD+uUywEL7lnW +5Z0fURAiT12ZRohVynnhsRSKRGi4AOtkCr0N0LIFpt1t6MGYX3lru4Bmc6q+NA2chczn9kPlmJpG +5uW/bwgYrp0qA5qbr5j1jkoaYTi59rEEhZhh3LHGZmHBys+WFFF6yRNTWdWndjxWawHeQZPAMhIE +5oXD+2xISAyHg64nC+O3JaarZJ9XAWCXGrkZh+CQ8S294OrbotAey908tonC+HX0D9MNXAQo3Kn/ +2em/CokTucCsD8s0ofqWkRbTre+m9fkMVjGqFhX+fbqDhr6CUyslPs6bkBaAu6nqvbDRRpc9xFO0 +AIa0Uq2FUAuYVZdu1lvpEWiMyZ0/tF8xxnjYA3m40dRAh2jqN1C5pWdAS/Mmo2SWkcVoenGgdp17 +3F6W5QjnsMfLJR3C7Pl1Gb/Dm02mE9wHnVaOcArhbFnVpDYl4uvLesqKpkuE5sVYJNmIT4/dqAYm +VJFXVyrcxn2k3yHBHCW0TEGMUnhDYABoY+hpjvjnNaoeb7JSogZ5ssP8mdR/mwH0o6KlqxezrWqS +dkTeAoXRfHaSovUyItftKlo04kfHbk/GdnL/vXqLsrdWA7PENfL9jysO6cLcLfxHiSTn+ZeffHiL +9hllzrpLESMl6S30HxGOYxRnXs3iw7UnFHckvVNnvGTZJ7WLsIcSYSHyj156lrZQlFwlj/b5UjMZ +0lbp2vBnRSGS1vLndNw4IOWkaG5MULrdCoC2qN4C+vEsF7c0NxyK2ZdnXTqakuXxMxcN87rlLIVS +6HjyQhJqak9wHR86HrOEdpDlkKcPESIiGnVOW64icM6sck8kOHhBu2wYxLxntQHBmEXXvA/NCVTU +kCleTVYIXgD57i4OBGzzMqX5wk/A1qU95px6AoxXS8Uq5fNRn5hqhs/G+uTdzypA1py2DTV1R5h8 +OWSYMnzg9CSXX4i2pt4/6vqqTdARpU8/c3s0u1oqzo9VvwFpFqTEby4r6Mhu3qKlR2slZATZg1Bx +VktrTmnZMEY4O6uZcV5qmHNKAFkvZemubz1Tog+k4rbTmgLHsG0tOcz0rNAsCKdvzVfjEW5Nryub +TG3iT21rEpLbYSn4DTbbTat77sHdmV/7FgCl4h5gpxIuenxf371P3Lu0ch1KMtBgNjWFmdX1iE+W +17YQerb4Ln8xPt/+9RPtJ4qwwxzLfIGu8/RFybrYbCLUCWp3gsziCIySdRnWgsMWczUqxYuEXUjL +ozhnLnJ8PHc7fcqsk/mJWdgXMRDzzawLpysWJbe4xmOgvJ4iLEExGEWHzTgKNV+OMX5YWws3W6Zr +fnANoRO/cYi1mJPTDPu4gym1AqKk+4AXSzLdqG7bRBlzlT0fsknEb7pQIByXsDVdhJvDCRSFWFcW +vMes5H1ewo2DDucE9HuV7oa1QPXaAmdBsy9Bx48ozI5LnZkEDvr0lXJaIothOCW9Jr/fFPbJvJ3I +hVzwUmAAWQ5wAMBOJKZzvygkqnNBNiwf/vl6o0zv8Q48aPhx3M5l131qtwBddpzfxR0dql9tNnfY +q48eLIRiXSUqlRuAHLv5L2ye5DxdLRncbQahBMW4j9LhOE3Bw93NDcKJ5C6m80Mw0e+q+d7rwNwE +N79eKmOJb4JaQh6eRkQJ54lZ/d1NodtNvBhNLSYYMLJ6cVuB8INTfVhlYNWHSWPGl0ZEoPmJC6+j +jMrx60Qc4dCZ/NHBBYF8DEAZVjEmpb5AeZ1+bwvPgXNzh1HV6KAcfW3GcC7M6ka3tuUMza95qYPh +l40l8B0N6vwaSGeyajSpefQDLowudPqlkkS5O2+CfX/Kl+kpA6jHGgB/L+s1DVpDGm1dexuJb7pD +Hq7sHfWn7uMNYa3vVPqQ3cxYgJ4Gag59lOmmNYoUVIpZnWWhP/osju517s92HeO9Pjzd3O08nIfW +1MwVjGXn3bTdZmqg579y4lEllb5sdgwymPmwI0Oz3orj6b1zCpliCeQVxpSZSFN9oNlllDpJ19Ep +SezlC0t9PfNF89cfJ+akYSXz2h8u8Ykhk2MmAm+HTbjT0kBTUW+WxEjezMu5HCQFT1E1l6id8K7P +ah6eBf5TWVdzidmAPou0rDuXn3ct0M52oxbNLs8H3PsgiFhG4Fu6fxT5fdR6PEwwuL42QCPjOqok +SpfcLKB8TFdyFCfzDZfr9uP8dFwaFhQqxgTUPn5k6cTMosyPUg1lBwClUWLQOcK0xEIj8aXb6agy +r41+KQAN+jaJcDxeTxl9FttlVKDI52kgywEO9bmOkHszvS1DDWYQykLAJ7kMjxMcNgz5xCj7MOMh +50sydj5O7WQU8YGI6uLz1DKxg3A8GwSWWSo0fGLML/sfbW+9JXeOUoviR5BBJ4mM9HDa/MGGgxob +ecCvGm3L42VLkiIS1+Gde0wyd8T0ZZMmfZvLztZRcs4/sIXVsWNudR3SW3IplTlELiRZ5eItSYZF +BaOkwJPcjH3tbxIyZELGqQMOe9S13TqJsPtGFYwzftzhOtESjxb/5dWGqYnA5KTKRxKNKKYE6bJH +RuneYKA8rcROG9pTOYEQcKFEa3C6qq+wWf5Era+fXlsNhBYVkrbbcdhyssdSc468Kbc3vz7J8tKp +66pu5bsKiKcz4Cy4cb8WeQDmKlq42gV34eBdfZhZki0ZE0qmQHXfviezHLKo0GX+wRJoP5ajzuoy +UaKvpZeRD+lNpterTIVOopcW6eDE+ZcuyOMpXYijikcIwedVRJ1rO4GkheEgiKTFhwtlp8xTKg/l +bpx6wrnV+s4vUMbtJAX+ampKSxNQeON5QcIBDJFGpDwfdVBgL8RAF2FmCplaKRj5vgfbVDgPJTIS +hcdeMcnsqjLK0hfD1yJvDEUKDBxYZHDcyDQBwnc9aA3js5Al5CDzQt/4EfKbQw8zADwwWhwLbksg +g7Qc24TZqstA765hNXOrcn75lkag7H/8r0/HWz72ltf57Xj7xT/86u/++e//7jdvgRq++eX7lv// +/ol/+cdPiLyoTkwM8sMnNKDushjDkwDxi7zcKQUEA8w4b4FlqUNu/Es4MSiroBPGYQh+HaSiJIFU +jQioMom9//M7JLoTaeWhbfppQ3JMjh41ayoyj5YmEJaQy9CDgkJ5VCNwCakOxT//VVyTf//U3v72 +/Vd///7v+y9fHxYkHPwHrBKwtnoMliOKdfQCH7BnkMuMVdiirnhTNZ2KEL2p+KjJWGJou1f56bda +bpQ2ro8ta08QLFI4JYySvbyK/Yqgwct2+dAxghdjwuCG6jhv5yb5srO2BAHNeInHjWKmbRMzbQSz +YfX2sjXjfvbLOWjoxuAIbCzDxykKCaNWTb6MT8fTv5dpOg/UKhuk9aLG5QO9NMZKDZQYS5J6wHDg +DU8Z15OMW1VfeTyu7VlEPfbQqykhY8aXhlM+UEep/5XdutSsR4OpW4km4HPwkxpPjdfuZ/OQcUBm +5b34GaRo2AY2x+AG1y4NQDo8dJy6FgXaw69E8rZ9XWqiBKR8fJtssfDkGS4brl7VV0xCAGTApLcg +06yKL6oh/ggiceq3or2zJCHPsppOdntcCm54FWaphiwvvB03KDhpsnUHKUVIT1BIel7XRpAfPbYr +wSUEfV+qaei/eLmgt/7y+C56Y6s+2Nel7+ZJqAgN3+3Dc35K2r6XFnBQalmvMIJx4pJmqw/TJQpg +3XlcL7ysVSt0xqWsCIuQ8V2ccJScmdQeqcXLm0NJg8K1RyxF5K7uLrT+W1JhPeS3p0RvAWNrkXsZ +ri0ZA+V/HFHditv4DMLiUVZe8ZnTh17fQcxiM758kSHFfrah5C4/MW3mddO85cThEWAEQ0sKewjP +3rJ7WjW5YjyoHcP7ezadj46iUQJhZUaLZG/b+P5NJoANgIZkaElzCDQ/UxDgZ5TI/4QowjAlt8z9 +91lHQKg60/Cpov+cL59KNf2dtMcoTf92W3G4EXZGB+7UXVLtJfJq4jgV27OluwU3hSk2wtgvuLXG +fLq3Ylqmw02x+ZVTRzMaQzgpvcTe7+GsPXAue4ptOssk8/m6XABI4uazqc5t1jy+dE7lE6xWTXYr +KgaIXa8yJjgPNbfPJKQZXwpkgzVl/JTH6NX2HrEkN6bS+6Dp6qWa5HzFPwpyuuERzZcai9tN1mW6 +AKZ84QRMRysmw7nU2L7u2qNbJtEaCCDMCsPUGePjoMitNklECXIQOvsY2ozGMRU3T4sCN2ZY+lk+ +XNzZRPX9qdBBT6WjwpOAb1Z/5vL5oj6dTKO18mMAfbhUz2SH6fCuQ7b683Vu24plKoFXzRd7KCcV +mNhDPNdTt+LoFrCehLGMNYo9vvS9QGru9ldse124jWh9KYZPPNxGeUY0dXJ8i4bxbiuTEkQFNCtz +j+G4MvFsOTT5pTaNyJkS/cTgGXcF97HvtOXtaeU+djBD6bGF4bYeJE+ZCtismPmlTAAuOErjlbXB ++cr4PMrZ8yjfEQ03mprpoXEHt8setz4kIzreGT9PzYKjrAzu5bw5UlG/YGAxPDV0eC4l0odOMdmC +IVBB3bjweunAFK/SCrRzb+mBhvMjfjB6C1PdyrgbUrc6Aqra11kdOIWNXx9Sbc3wlSIzO9C0zRYt +aJjD9ID2CzTjKMb9yyXnLEeqXq7QZynYdTXvttUYCxJ4HemLTKvLk8bNttlJgb+H73bccHQOw8gD +P6K7rMju+0XVx2LkrCXvKAMPqNdEH5pv2BJR+mFXyasRr1Cmv7ZMXmCA49LY5Lxeqmd4ON9l7gQN +JVsOO3ywPdPuzH6xMvy45IImSloasKjLftohi1mK/Sp5X66qbn3+MME6qyP/LFfjU3JzxlpXl4Ee +/Swam8yUWxLZTe8+fpehAl5eyWkbMl5eZdqWhz2NFmvWJ5pSwmXwgic7XL+ZiIRrq5pw9yshfYRN +2PV76ce9pbjvMmwZ9o6ezYtP1R3yYPmzFMns0CIYxxbFg5nO8FJphumn1+HIqbAHTA== + + + t2tL0B11+5pgRcZNV5GnzJ3oKXbL7DrBlU8JHV1KweNNeDbDeBgjV5UWyIeGNiOYFdBGzYR09UqP +nIublFgSrKWVME9tSADXrbP5qj1gL15beP34elsqItmXFG7W+GTCiaRx2bWcKBYviB5Xs8N1FVs5 +47vpoIc8UDZMTPweSkxM95j83at8TI5J9/8qT1Wsx3sorxstgwe3dOq7Xi1EWX4xvDtU21jpcAB9 +Cw9qYbMqOtfp2sNNVDIB6Soo+nNrG35djIfr1Vmfvwt+YT1fMNFOEUGON3sxB6zzrvLkPKRA5u/N +M2LCw9xUv3OCYXfIaosnCWcwiCehaKDJO6ASgYZs0i/PDNwE3BgHsmCJPZLFb5FnuAoAfV9sQcUf +Qwj5EFRH/hwx2Ob1C8ypCYfOBZKg22y2DG7IQ8lM91KAAb35DrVIeQQebDmz5Z7IYtcdw11j4b8z +vKLHKCgBQ8sS9yZCMupAkCghUlm/d+suC3X0uu/IXC+abnGKqXHKAXjJ9FFP8tQCdZ4PL/CmoJR8 +v15r6I7X25XIDzP2i0wdPa88p9WQTnCfJ7ntSYUHoVWUe7xMfujgy/vdfBU2Wzc/1/Vd17BtHhnk +21R/L8XFQmDSaDqknry/M0AcM4CgSzxTGa+2udzDT8yU7xnrtoT/S8azvI2ebU+JpVyTFwTE0cSe +u5MKaM9VOpdCHKm4MLGVg2UC28QobdnLh2kYFqm7c/8W36YFCVBECOzuzq3UwDIerY6htV6TfZAZ +fjoZUoDa/O/MztdRa8J07Wx292krdfpSZxmbzvdnt+3nFAnGZ12FUJok2aNpILl02zrbKsWC7spn +a/Upw4EvUEGaTo/9hZ9dz686hD23mWo4x5IMBSnGAqxtjCNpMFuKk35UXIO0R+pwR9m6+kidkrfY +Iu8dXig2Yn6D7lj5udtJkWIP0ZUaoIBhfEJEgsYxzuE4Ny7iWRzPvXnrfgLHmy4Kx1K56hi7oLHK +7uHqOmKlR0fbA33H+iiQg+nqKpMRmPDagiE3hZxEN5Yex+58j9EjvmOFWizfpdsotNapW0dcEAdf +Jc2GKurcDapjv8vxGK/P32UE3Gzy1h+0qTKVcXdpjRG6sTqod17WEs3AuoaXVyfFVRlHr0g9hO28 +/EFsMw6BOdPFqYTxrLUb6ESA43ZWBLmh2/OspbOZotzOgfdadQwMHVhNSzR5W34RWg2Z8Py9VTaw +v8PobdjZBHBvJ3ugkVncGk5Kw3Orz/TGF+Fx2ZH6hFOedWmZ/qVQe3Yz8U4OgyBK4ADUvj++8Jhr +2zVOk/1DUVphmbSQXuZ2FIEeOtTqEF3W27PlS1Z/YSCkerNAlX0EYtbALmXniN1vgJqj9khtJzBO +30mNNOD0GQodEeVCDfXxoC0443OnixD2swWkb5iDByyaSjdc+Bs9O5LJlsEOtq9XvskHTO3mI1DT +nfuHGghzNxwPe9AgBxYgluLhfNRK9ImCCfzYuoiKtr7xG6bjKUiR4O71Gs1CvMjR9lMMndD8Eruh +2zZqH/NYvFJI9MV8f55OLbfW83qPdqGRPaL9IaHQh5YUNuNLd84+5BfeV3vtYe15Z95k/Y6HY3G9 +2zpqG5qEBAt8fNk2/qhF1zCUniVIYVI6BANNY7pyEtQmFGuWLho+b69JkFJMEMzLGWqGgzlL7KSV +ye0ukH62Yejo1swVhTijzYli8CwNiGWJvdUkiOUzQOtUs6H7s5AG6PZ/zxIkc/I/vT9M1aS1fX2g +ySfRn2P6tGmcGoU3b/+Z8VERObUEZTjLcBhpbbaotJ0wTOF9x705PMtmOcI8ry3tLBbtVb5KJ0a9 +HL9S3iGZgtIhre7PKiF/CgmyRy/p8OxBr9nc+lZnkYovMSE6xwphb63KGeuWT5o6E9WM+gldx+vn +qS+8FDxplm7ZotwA7CB+g+1qeCPu32SWvHycIP9mPCVcrMekV7u9SwCZAIdC26tW2cz5N46PRc8j +zB/KOce4jj/ZwZe9+qcSQz33RzWMQ9Dxxxa77nTZKoPLVvaV2CzYi5VU01qBhgWt7Mnusjxw7Zu3 +mDI7nHcVAsiKm+EV42PZ6Od1oaPMUlSQB2p6RrRcUwjFRrSraP2YtH422fex1/wDvfRiMJuJr3LP +oyFAeOCw8Kfiy1FrVMaMui/Ne6q5LdebnGcwjIyL8rwFMnxJbqPuCpqthfZRaELVIm5jaELDzFCS +IwnU1RO/y86IQH7Sj8PQCgxzpIH/0ZxWPSPqBHeZXB7SFSdyCZUo7FlU2G9z9x+bQdAucpFs505e +HlcTihjNUj6ftzTqjPpo+McvwNiM5UfMpdWSqPHEoZNxFsS7VTkeGi3dFLOROO7ix3m+Sb41UhhP +gQ87MmhJVsgbm6WFx0wUefePUkNpelI3WCSz+mCm2bCq3oG/E76gK8yGyrSDMyTKqTrCdZkN37g/ +hmjDhPnFlifcklchvdjEf55xf1OchzANEo+jD5eaM644iQja28F///JtwBAE+afCejAe8qaGt9W5 +Yg9rySYwrNIN2E02Ob2mNUpEt5+bBuRDDjnav0vJKYjwQyyib4I4bZaLlLPTX6R/ELncLEyeuwhJ +LVua0+c+AlbiTH22I/W7sp4+ZK91gVJuXgjmTaceKNMc0Hwy7NW+L8L2OwvlZ2kFdPoLKO75ttqs +RHv7ixpRShW51XQPTKFbICc6S9njEqIKMBsS0dW9yqe6+npn/XYzNFozm06omhX3Byfhdr2C12J1 +T52+GD9WkWhfdmUwLPyY1g0L7Sxtr8CSJccd7uJ2davzhOx5i5byP9Sf6Cqp1a1ZhbSsnb9ffCMF +9lfxvnxY3eMxdL0UtsHvC2NWrS6cs9OSeu0ldxiaEtO2UnqnkeXoL9g542dWFIBxerbcyusAleQb +wklFeclGFyJy97g1jz0Ugyov2Rk5gYybwTKtST5lj905lodPK3+ZflbJ9RwWb0sq6OUBsjvnu3F1 +xpjUdBM+zlETyl6TKj1bOsIcdZKnmbO+rc+riNRLDaMML82MvVmYX/Rq23rM4Njjqd+xVYF2Tfqp +KHF5Uo+QLuWT64v0p8vwIzuqSPbyCSOsMdY9TG54EoiGvbhEZBgu+ITOXeFpZir6jCuKyUvg53HL +phy8djBNoXxp61k1Ixhx0wNMU8T3e1+pr2vH0gqK8To/DJJLpoQK8qw9iNnSw/CYEuBblS5zy3sA +QTsLdYeuLzQZjXUxP/GYZtqiu9SJM+1o17K5zwQNjY+sDc1cWDPYJXTmMarVDjFrQAVXtAz/la+c +XjoYdYwvk2tLZbSyUEO+KkfslV/rrjJsbwVbtkLYVzlma9vjJ8pD27vTh6hCZdc9ShXA15Ub9xfe +O9rO8CTMnuZv4gPtqXtLcxrY7lHnLB5OMYZxE/u91v4NuQpgu7dXPmxzytzmsfTCB6Xo+xht3lUl +sLxLKVFzcx+gqmtve/ShZBn26I8J3xQJebb9U1rUqWtvfKZ1AWNa1vPMLtfth/rOEP+/MFeth/oW +TEFEgYfc/Z8CpO6Cj+9rZ5RiWsdVCeVVdXM9VUlCqKQ816bd3AUwKxG4NoA0/2x87qkiJHo4nmac +cIgYN3PW04oVLAoPodM93AdUCAXN5NP1cnCvdnUPUQA18g5pI7EAVQ6qWN0mb3jVaYXIrWBVigyo +NtTUaJbAYK2zB4sSeHaZtooDw0yl0GuRrbRxN6EK3M7ZDZWDq9krBAHLU8D3gvkRx2TQ5ymJawiR +30XQ7BudbvezAdGq9J/b77YJRZbv1xJ8JEtgrSK95isfLVvvq8BLuWvvU44A+fXs1SpdzK9DJGmV +wHCd5t0U06EnbGbqfpxSXiIMWAKkJSMIRYBLWynrtLqIrluTTceta46blQWCth1mvBgTW0wx41Fl +3RR39qMjIr/6F9WOZs2ZWuLNCe5SRcP/jw1HPd/XMkGV7IDjBempZAhSFM4JNh3vyG1K23ntdZFr +qnNvVvRn89WnXvte+art1pqdtddkBwXQDLfmQ+ogGd9yiqF+Mh4yaq66sD18zqv8LKhmsz+OLKjp +FAVHHyPUcgRcb7+vVe80UHnGlt84cw9Q5TU47Ox/cEbKq+7vA2erlNt65ukJYyfCEiMs8D6puq7p +jMJVHZUUiV5gBzI/rLH/JMj9pmqJG7Qn81nwsWM45oqoDErB+Jv33cqD+zp2Ww9brN7SbI7qTrf5 +vGuxjMENe+wZ6Eo+uvOpHPOoPe77I6Jihdow2w17fa9IvV6NQ6DeAIrLOwssPNK1filj7sTcXv3x +zKqWd0kJneZQMVkGr7/jJJuJKArJlEwuO8e9LlgB7SDfFCeQCyFVxZ5XNYtPrd3O297zowS1+yte +aa3qOLcnYYhUxtIZazPWSn8oW7pza3+MLvZJyo5fsoycKkevqEnNI2Ihqs4eg1naJ+d2D89peqEh +10GG357cEgNLDpeb5aNGOp1PeNmeEhX/8gHLg8fsPM4XQY2HjiJytkxVNXv3kRLp6K93HPfdb+ok +rxIE5m5RSzzkNnAI4xMTrI665n6jXQ+WG5qsX3hLX44Zof7sva0nbHaXYSqI+f5TZak/+UmFEPDi +HiTe7wECuWWKfuoESD8+fQJnNdBy9a75GhP8CY3tT0xR+eTWvJCXiwcOcr2pGAVFJFuW3hSHqTB6 +orddDukWn09JJyG8QrfccWmCOjnCgL986ykXtRN0PdBaWqUjcCP4JDsiaf+zXgrPKDoMz8iHrsmE +bldlK2jMQlnMTIG0zl2FuVAVo0I0rQahwBOtnWIvQ4mbhzoDLL6nfZHNfDp131kkepoGlsaPl4DP +lMJ96mCOvUu71W8R2v2T+xbqBbJa9hXQn/VDttCOcb0MPCgr0m+lHQsVmE2H5rqdo+RNltrZ4xT6 +uZOFoFklMZxsxCs95a+7xt8lL3FZ6mxlRBiw6LakedV3zhe5eKg/sJZUwZWWFUReVl3qcWomuzmR +tj9MOypedZWZBbvmSlxDaF20DHY8QuWGwUOtIE7yLAIzAkfzsk+2FU89TWAh9CMxK56P3+I3XG1U +Hy7FyPJIlbaMEV+2D/9+Arb/9tNX//ZXv/rp57/9/eeff/+HH7/96b/e/vp90y/gp9zj+uXbX/3T +zz/9/sfv337x61//6vPnf//hH//w87f56C/f/uL9g3/z/v+n3/3601e/+p/z337z4//+3bf/9d1P +f/mXn7766h++/f67f/7p29//3+9++vT9H7/9j+/evv3xx+z73f97/8vb9z9998ef//DTd29//D9/ ++M9sed9lf/yrr37z97/99N/VdhfA + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/new/Audio.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/new/Audio.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,23 @@ + + + + + + + + + + + + + + + + + + + + + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/new/Audio_downloaded.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/new/Audio_downloaded.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,39 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/new/Audio_downloaded_new.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/new/Audio_downloaded_new.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,54 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/new/Audio_downloading.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/new/Audio_downloading.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,139 @@ + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/new/Audio_failed.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/new/Audio_failed.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,33 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/new/Audio_new.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/new/Audio_new.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,39 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/new/Audio_queued.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/new/Audio_queued.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,43 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/new/Audio_suspended.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/new/Audio_suspended.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,28 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/new/Feed.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/new/Feed.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,1574 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + + + + + eJzsvWmTHbmRIPgL4j/kfpCZZLvMjsAZ0I6t2buyVzvUYSqpW21tY2VUFVXiDJOsZbG6R/vr1284 +4r0kk+TrQ5rMIJNJTzwPhwNw+AXHT/6333z1bPft2z++fBZv55vpJz85vHv54v3bdz+/IejNL16/ +/vGH9+8Q9NPf/uxmSbczNNr9Yv1aGv7Dy3c/vHr75uf0K/rlHX76p1+9+OPLl29e3Ox+eP3i/mc3 +P/0Z/OZ3r96/fgm/+83bb7958f6bP7989/Wrb96++eHrGL7/n1/f/eJXu+df3b549TMlA/AeX7yH +TyzL383h78K8zDdz+3kq2ODFm3958cMPr/4//HWJawTY/u2Pb7599ea7/dv/+fObZwv+iRH+wK/+ +71e/ffnD+Pv5trbYUsafcqKfYqCf8F/4XYbPHd9+8+P9yzfvf/Pu7Tcvf/jh8Pb123c//Pzm8JcX +b25++eI7+M2Lm396+fr123+92b9+8c3/mIA3+eu7V69fAhvuX7y/WYgpu18s4ev9j69ef/urH+// ++BIYFEtFcPyaUP7+B8AFaPFnBNevf3EPkK9evn8P9MILkbGHX/7Tfz3AaLy9p3YAvJlvl5sF/v3p +b3a/+t2vf3WC17WbAzLwf6ffwv/mW+iYbxGW7JuEghjwH9dkaBHh87dtwBErN/jt3+89Z4gkbPjP +v3353SuaNzCG/+1n0tN3b7+/f/Huf/zAzWKAP/yb3728//41jDQNzFJu882S8Zv+JK2Aqzx0ca03 +z0KJ8OvYyk1o1qaP18t/efXyX39+86u3b17yoOzevf+Kp0tK88zf+Te//fH1y3e/f/PqPVBWENR4 +VH759tuXr6G9ff7u9YvvftBOLv07N/jdi3ffvXwP8+zt6x/f05pY9Q0w6s9f/OUlTp2FX/Dr71++ ++d3bfyAan9V4W0rJN2WRf4HDZb0pEUZ3pVfApFxykzfzW2nkGT0iQ1T6DphaP/kNzJ9fv3v13as3 +PxcK69d//+7Vt31O1XCz8jfqxO3q/jb9y9RCx9+/f/lGqIe5fPilm5vz7S+/gjee3nx7eHuP3P8B +FyPMgDcwOV6//Y5/Zz/Tb+DjP37P1NP/v4aB+s27V28Q5/Qr+s369W9e/wi/+vt3b3/8/hdv/vR2 ++ikLpd+9e/ENNLv59R//+8tv3oNwEUD/6asfX71/CaLk+599ENFvXr948+LdDcHhwwx8/upf4Dcv +gJQb/hj8psM+jvT48k+w9PtnGXp68y8vX7/9/mWHG+TFm29v/vHFu+8/jhqG4Z3DQP/Vfx/R2xfv +/wxS6uWbb38wsvi/Y0cZ9nF8X32Dk+Ldzf7djz/8+eZ3b9++NrTjrwy7gAmK7f9zvOM39IE3v37D +DDp/kzTYvgkEwn+6t0Drh98Av/zPjP3w4vXrV9+9e/H9n199c+kFF35vb+LffcrE+sv9H9++fvXD +fZ9PDvKbF+/ev/rm9cuv/vLD+5f3H8KG3PjTqzffwkQkodOpfXv/PeobN1/9+cX3Lwnn+z/fUcuv +DGH+GgSjF33Pnn1AJoZ4s3/jfv/37158+wrELahU+9c/vrz5Lfz3xesbBf9sugwGcQ+Ivp3+efov +04xfyxznNOe5wrPObd7N+/k4n+a7ZQFtIS5pyUtZ6tKW3bJfDstxOYU5LCGEFEqo8KyhhV3Yh8MU +juEU7uIclxhijDmWWEE7a3EX9/EAzzGe4l2a05IiPBmekmpqaZf26ZCO6ZTuMtCSlxxyzGnKORd4 +al5zy7u8z4d8yndlLksBDaDAp+HXZfq/tDP9a7G/y8X/oT4Z7HuUv0AasSPOeSKu4F/9XuRvkp8K +cKwAz/T7SvzDv839tIO/e/i+m+ifA7H3AH+RyfwdmA3sRuLgCzoDqht8xaX/8F+mu7u7093x7nC3 +v9vdNXjWu3pX7vJduot34W65m093p9PpeDqc9qfdqZ3WUz2VUz6lUzyF0wLvgo8fT8fj8XDcH3fT +sR3XYz2WYz6mYzyG4wJk3R1Oh+PhcNgfdod2WA/1UA75kGDowmEB0u/2p/1xf9jv97t926/7ui/7 +vE/7uA/TfoH+3e1Ou+PusNvvdru2W3d1V3Z5l3ZxF3YLsOKOxurujrqDHTpSp7Bb2LGddQ67V6mL +2EnsZqKuYmexu9BhfBDJ6TRRz7HvB+o/cgB50IgPyAnkBXIjE0eQJ8gV5As+s3EH+QNfEzAJ2QSM +gqcRr1biF3IMeYZcS70z51+nRz7H7TOdg4RHj3n25890Abg7f6Az6eYnX+/fQZ8KflV6VniaPDCY +ZU8PzAvgAzL1rpLoqCAiQBhEelKFJQsf5q+1tqk2eHZ1X2FKIRNhRO5WWjHrAg/IkBUExZpWWOkr +vXOtK361FWbRClNtPdAQnHBqtHmCpQUiqQW04hoIByCvNmjdWtvRA/OzwRzGsaOJALMKFiEIMZiJ +AeZjhFmZYG5ip4AyGkpcf7QOAz0LiUB+EojCCKIw00/4PYFYzPQUepADBTtDwrLBv7uJftjjS+H7 +Xr4f6IH1Bt9PKE1xNgeSQ/SuGPALJChIWHxAFoKUBYEX1omEbSOBuwuwKEHiHuH7Cb7TwgDZi9J3 +AemLGFDMgiCFMUEruZI0XqHvDeQxSeQHpA1yi5cP8Q/5iPxEvjbiMo5nIb4nGIEIFGFXZxwcGKIj +DNYBhmyHTWEQ60QjmmF8I431AvLyDlclzIQDzAocgQYTpcKkyTB9EpAagKEzLH+cZEeYbnsYqQZo +KlpJE8j9BDtAAM7PIB9OsCIPsD/sgKQVJx/sGhn2lwjMW0Bk38GiP8IWs4dBb2mFNxTYfBLwJ8BI +zpHlEq5peqI9QR4ar+PMjyw2kTcHEhYH/trTs6OnTci4AzHjQDMflw0I1ExCNZFgRdEaSLziM5OQ +vSNBi6L2SOIWBS5+7SaSu41kL0rfyqsRZDBK4USSGGQxPDTT9jOJZBTKKJaPJJpROKN4RgHdWIJd +kAYXnvbYZxr+u37SUy8900VweeSTz58u6/7Zpv3NB37gJ8DfcpPJd1TBagYEYPp+/fkI9j/A29MM +4jNg05JajRexlAATGU3yFZY2tWnrDKtOMdbb2JZ4E/Nty7nTdX3URDEsrWUp6DcCFWxNF9GGVGf0 +WdwWUBITOZFAX4LGgna5RXXrBlSxTu6V8QKt+6Mp2qoBX1ah7158+/Lm/dubf/wzqvHT5v8wVIGV +ZqQkgwiiH2IFFfVcfAJJLSy5jj8gleOkQzw3iudiZ/nj4w+IxybSyL/roaRh/kJ0M6Cr+eZ69BnC +TxnYv3/38uUbbxVtAIRV7CETosmE6LwRoSo+TYA6HTeRVhFIx5hJ15UN9OC2zr5twsZJ0he2aNys +Z9i+cRvfw8beYL/PpAcsoBugnrCD7RXVjQj6yR3sQGhKoCUS5rOvrSV03oBkfpegWRRssMzugqjX +AS2SQclG6+JkevZ+sDJAs55EpV4GU+NIWyN9ZyOtib2Uxa5CUyuKIabPJ3w9rq9kPaL9yBbkAXQF +NATuxJJkW9KsSdF8V9F4N9ou6ruTU3YTKbuFlN0VVV3Uc+mtTjtl3bSRVnogfZR10UBaaCYNdIUZ +soN5dYB5dgezboH5F2EmZiCgwmbfcO/fgypwBN7fgaKwgNIQQYXIQF0FBYP3clMAF1IA0QzHr2Sq +IHWV1XRSBtE8b2Si78hMF8WQjHV4JhzWSIZXovFKpPqyZoo4vdngOrKTZYIL5kiL5466NUvXAr2J +F1vmubGSpXwkz0MktXoljfkI0zGQHlzF06BuBuwdG2E0LfkLpipPW5rAi0xnUo7JhqRxpwc1iwuu +g/7F85EdBJF6n83yB2rpw6STslZa0FdBaikrpgu2JOWU1VNUUFlFBSWVPvxBW7mLji44EuvaPNQ7 +0uTxWUW7rzK8ONA85PyFE4EnBfTDj5iwkRgplsIqk2E/+GtwxJN5bECRJ6/N6LeBMZvIcROhXSYt +nFdeX3Xjmuvrja1Mti8H23Ii0zLYauuGJa+23daqFLuSrUq2KdWqxI+sExmValYeyKwkJwGalfSw +XRmIs8msy0KruIqViauZLc39dGZq6sMm5yxmJxuebHqy8ckGqH+IA5P888Gp+Zlff6sIF/t3Mcfe +wnvLRH69KP49ko9u++k/FduWKm1RRRZ6df8n197EfgsaH1oTRVbD3q0EXAbZuS5t03HOyyLbDE96 +mPIw3WHO89aSZEtpNr1PNK2DTWl2keBMRlv7KDNY567sOxNN2J3N0JPMSd58sm0+O9l8jiSt78h6 +DCKheQuqMM13aILuySKlbQg2ooWs10jWbCEbdyWrd0eGMH6d0Fgmw3khUxq3lUxuNFyz63RcycO2 +F13hCKL8Dl1ypEsEetBlh+wjqUDuPF6ztLGQMrJXY/x05M3g6F0bYNrvzZGnLrwk5v0iBv1JjHh2 +fqr7s4itHsVGZyfoaTLDfCf2eBVvaB7Vx43quBNhz+K+K45hYqmPeiP5Xo4i/UevS9l4XUa/y4lc +ZAdyl+0mc7+sMFHY/5Jp6kTzwiw4k8maZl/MkabaXjwyO5J3K/llKtg8pOZkc9BEctIEctQsskp4 +Zz2J0+ZIjht+xFNRdva0iaUq66PmzHW+3P3gy1VPbvflqie3+3Jn9eVOx5O5c9WX2725zby53Z+b +nedn8Piwt2dyzp4Lrp4Lfp5zT8/g65nQ2TO4e7zDxzl96GnO76O+H/X+8KzLo/0SzRUUnENoUZvG +7Bp9TsNDnJrkHxyfTwwKWFjgoajAtA0MiLqzVXhM5aFJfhLnIrsWdWaTX3GiSb3YdD7aRG46gWnm +RnUtinPxaM5FdS9WVuQmp8md63E7cTWu5GpEZyO7G9HhSC5Hcjqy2/FIM2A/kfeR/Y/ogUQfZCGV +KpEnMpI3MpCyxaYRqt08wXle8iTSwd2xBjg47k0ozINQOKhQcHyr5pNNZ/LA2DeJEFAx4Ne/rv15 +cNN6Xoqz1jNyusBHz8UkTttArnXPw704b9vAvDR1L65xjHm1NwV5FdU4m0rMCjHa3HebfeIgO8U6 +7BKPD45tQmMTLYL5Y6Excbf32d8V/j73DyzWdfDUna7O9HG+82wX2Uzjg2OzI5G72qiEEiZxofcR +aW40eCzYgX6iUdApbJN3ZCDp43tWWCzKs2ziO9VUl1EJvxMFXJVvIGUSvVs17q7IeFUmbOI5qzND +nQmKAzGZ/am6DWs3K8nXHcncA8nhk1jasyk5bG9nU3RQ1dlNpuvg3oB7hGo7Xd9JtMGYziMqD0pX +eA8LWFaa+Nmb8nQQtEeLNtyZOqUv0RcFi1pgbFLeqe/Vd1cJZa6yETIVO9kgWQlTRewom+iJd9Q7 +0ctUN+v6WZBtOMmT5SlOY+ta28rm0UT/7AYlzqlx9vQvC5qygc8aeBQdvJoWftjo4WnQxPdqijpN +PHddfBJl/CixTdXGs+njO5vedw9q5HuZ0hSq3KjkgyvokjNodAepRq4uoTg5r9AqUw== + + + VicsO4YW08iz08l1Yh38hiEhS5fdIfkdi8QfC2V4rBZyPLL3ZXAcJHIckOtgkmyPPU3Ek/iN1H/Q +PQg8WupDONKI9eyPxdwILgekihdvb/4E71EI5sXLNpzrELVmv8JxUjeeBK0X2cjUm6c+Bu9laBK/ +3jnpJvKt3k0ukK3B7O56GEPa+qwS3FZPxG7d92daRZeUlarLZgiUibOiuywWc1z0R9xDE30bxDRl +8ESQ7YXIpfwd51XT1B11A92J64+dQLrU+kILk7l9yuPWGQzI0UYCx8D7UdGHKowet5C+geDXsM6k ++0m8NT0bgN0zx8mttIe2i71bcbJdmKcymx0sy26SzUI2igtbhW4Wfrtw69DvGCjSp2Hb0I0juc2j +kL2yFeE7e/ajGJ/E8e7G3Xnwd+LBNx++2FOXnPj7wX6ulgITJ1GP1FI6DWZ0N6SrmENqSndjWkPd +YvFMZlCPJrWGts/D2puQthjXal7nyQIzLjTzgfQGn+BQfLRGTe6Jbe5BxVbL2yvaO1nfqm5XkQLZ +DHE2xcV0UQ18EXEyW6Rbt8+jPQd79sPDEmo30Tcyq31MfQyH94wqzarSzCoJ+1jgx4V+JpdndbA9 +W/fw5nKuurVeTQ3ILgNLbPfJzPfgErIW1TNcCtTJWfRHs+u7bS/2/SRLodmz2tM5WOzJ7kkXEkBg +hgf3LO6Z+7NJwzoNz3F8psP51/7s2T3wtPOHdEcOg5zn/FnG3wMJfx+0aibxUHzcwN9aN6N9Yzb+ +ZH4tXWpq5qQhi6h7stRk3ZqrC9s9k8si2pvHqjpTNQ5mqjf592YOVYvfpOlCAIfzi3wIR4I4lmuk +DgDvAhAnwCQ27EnmFvkCxJple5YdAmzVqmXLtlU290DqToJpDLthMgHQAHatj6OvJSyrB6S6JvoB +ts5Ap3oCZ1Bw4D+EW9SBxoSC66KlpIK6zNAAm80pN0o3Ka1RLgCZ5njkKOW54UsyjEzAFICFcVuK +Qou3AWZCJ/SqWCXHJcDMRAShAS7EGNq85KHvy1ILQooyIWDXe57PTQm3EeaJT3G5JlqidFkB54Ag +lAIohmHL0FdkRyPkdM6HscV2i9vaTUyYAOQovS5aovTLp1Mqt5QitCBzUrjmTN2i5hSYtcYxb2oJ +axq40sifhD/UkBON6IxsUUbUW3gDpi0tzWXCXBfvpyTEPH/15iUde7KMmC2kZzttjghgNIwPCBzs +gAAeD6iDAXknxwMihexLPx6AhuPU4/YbC+Mk9kXchNQuGfMuqDblk9gXW+vicGbCq21xbsI7/9Rk +ycdta8kPrqluZ3jf1L6dZRxPFy0OtTl6rsSh2/ouU+IsVwL9/OqyUlOEHVc7CRg455XZJN0qUcsk +SXSiHFbUH9h9dZIgHTusClkYO3FQyVQIMhmyZkHIhOAzI7OcGunnRlayS513QSfIJCnOWVwMbpa4 +MyRpOEWyzUoI3vszmU36KPfPRcN0dTk/5Ck4macguGyfepZ7cLLcg57Prk4hm07T1t3pZlXYZBts +s9mHXHZNKphcMnveWLPenj05D1Jw1uzW83mcKKIbYV6gvYp26pGcjYEmRD22j02FcTLM7hBRnw6a +Bn+UyTBPg8AYJ0P3Ni0uUaWov8mmxDAppgd8guO02E6M/SZK3xPD8nQhT2UUMcsmRWVICNs6jdZ5 +2sodmyle9FyeLBeny+SyUs7OPgx+8j5ZRseH85Sj2wMjFzhHcHagUDlJsD/J5Gh/OwkqPfcwPJDt +Ve00F53jOp/hnK52fkgumgtVEtdoIuv2h9P3MJF/bSFRhvsey7A7mKaR9jrMnzrClFxgKmICbVPX +Gcy5CHNthfl1qCeYTBEmUcUQ0WE9AbUR5kaF6XCACbDAsBfK8ziCJAggASqN6wm2h0AjusNUDbfU +V5D8h+MJrPAwwcoplG5xQC/83UKpdAVm5A4dV3d2qssfUfucA2qDsTpd83gamqnTx4+nfSjpzgxT +iz9PF+NweqTFx+H8cZazwyz9JMt04SjLJx5kofAnBz9bXCeLe0aLeJ7oyBDnGa90sijDJKVsYzqL +dKKM4z3lHK90qIkPPeGBKFhOd3Ru8UApyD2dN1F+1aLZxU9T4WkqPE2Fp6ngpoJzV61lnsm3ANpZ +aY1s8paT1CIh+/PS+ZZP+5icYfm0k1lfcqrrE0+mfPX2T++5btDNP7z67s3L93Tw6BK0n9lXHkzK +g0l5MC3TTI+w+fEtHzkgeE6mrLegdaabGm9BsQ2fNDKXPk9D9JjP3pa8hIS1ceKCH4g363pbY2if +RsLDaB5PScufNzPHT37KRPn9mzcv7l9+e/OdgG5gxcFMuQim6Si+m031hYs280UXywMm83RmL1c7 +I+NPgy+bnIkxa8LlTUwW0i0udcK5XFxYt7tcqpnFZ6lAW1dLPssFGsK74mYho/hhY8bXjjivFxHl +rxaL6EUjCtaQ6NZDtWoQbCTvyMNzIFOil4PgYhD0F955J4fR8TwM/g0TiNxgJ9D17DmfO8dT55XP +nZMdsiNx3Q+Zn+yAeZBD5iDeJzpdXuhsjeZ5cKbHnuxvPlqO+T2wR9DxET1TlB84On6NLdnvyNM1 +tmS/I0/X2JL9jjx9/pbczy5tC1dsy1Zsi1ZsS1a4ehXTkODsylUMqc2zRf96TvN+CNpr2L5MLnLv +YvdD9L4fU9+dBfC3IXyqFXJ+OP0jcXxOlGedcixicems+fkh8byJfPfYd5w24W8XAj8Lgmt++vFi +JFxi4ZMLhvdw+HlAvIfEh6C4S2qX8Z7GsLgLjJ8+FhgfVS9Y+m3NH1JqYBNbWplXjk2BvMEfMHSS +LmpJ10LIUbcG8itRHG+dl8vIAqxxOiVe9AcJQ11WGq+H8sv27LBe3LMB7PdsHlvSo/e2WewkzYuS +QuQskrqmLh2lDf0Q1OR8W590stZ/Xdob2ffLESGKB9FGlVypKI4EaZmoJsmD6Mgl79dEqsleIj+B +ykH1YlCgkJA60uM9O/KCsWvWjk8RZeaZjJZs1Y8g+SSrk+XNLkNybk/PJf1kkrDHzhKpNA/2ziW/ +atKrJrz6RNf11Masq0+qDnSp/M+mEND0KfV/Hir6w6L0M83wC1Y4bfjTl+/4UpXEJZ0fLPl/tZ1U +91LdTdXEVSOXs/6L2blxYlPXjF01d9XgVZNXjV41e9XwJdN3Uzgkl7kFL0lqyoHj+2ohot6PUg9T +EBbQLsplW/NLMY3WLqyoNZOcXRYs2+HjylzdwxXQmAn0YE2Ja6H8MvEZL0rPONaza+qjHx457OR+ +9s9heHxO13Ea/yvquXvGRW7HL+OQhHrp2P948H80TO407jvZ+f9y+XiCfz1JmQuVbs6Unk94plFL +On9onY7a9Sco15/r7fLp60/75dN++bRf/tXslzGDhPBbR4YF7vO2aDvhgk7wS06Burhffikm3i+/ +bNeNC4DWerVdXPH9re/l6fJmnuJoCuHXU+rZU+rZU+rZU+rZU+rZU+rZU+rZU+rZU+rZU5LJU77R +01R4mgpPU+GzUs9wz/2kpK4FbeL2BVlhguCxGUZ6GDHfznjs6zOS3/SjX2ikt8tGenNGuvPYkYqs +6jHpFmZYR1czohvVqglzuQjRf80sIq1XDWqv67KWO6YU3Q3lIXwRFlcUcXp8Jd6/Xu2S85SCfGcz +Cb5vnKsfugbkvJz/R2v0Tw/U4n9MDOI8qADyoKdjbJMyzpIz+NqGj3laP1FITw/4Wj9bRE8P5SKd +i2jOCPpQcY5g2T8n6fgHynMwE6bhrP/RMn3Oi3PEoc7lnaX29MSeVTlULKfng7UuHxC/wJmylIti +VHJDQNJVPPFKaSNLLu3DSbpfiHD0uZYyL+zHXePo0LWTzomOZJuf9CMe1y9E+GWiPF/2twIYL5d8 +8rc++Vuf/K1P/tYnf+uTv/XJ3/rkb33ytz55Vp6cbE9T4WkqPE2FL/O32q0b62YYdRBxCC/dkvDg +IaNpuBVhvAlzPGk03oTpr3EbjhpNF88aJVe2cHHlQv2dHFq9UO/kkBKhk6u+76fKWMIw+hKGw4zR +OWMzZnpwyvBBNJ4tOlc+NFNknkwyUfo04cS/8Rq6Pj+2s2OcGzAzJpwYNCt0TvQZQTm07KRrsJpx +EgRJfsQ1jCs4w3AvMMRaOr+dnRszD5PzL+0nWcPjZSr5YrHXsdDr7vKNKpMs84duTzgfxeHeBHeL +Ctdl3U0PXWq7udZWx/XSIcNBGkwPigMc5o+Lg50leYo8mD4iELxI8EJhFAsiGHAGTBcEgxMNMhVE +dOOaDzT0J1rWOPA45HRhwoX7Fn1Z0WGcp4vD3BfpeHFOH+UHb8mYbKj9xTlu0brri7elR3m8e/FR +GvNpI/u3V2SMl2Qsw20j+7OtAEZ/csP/mP3A7QjuLgx3D8a0yfK9sDMMe8O4O7j9gScCHp44yKmL +D00FUBlQYdjBIBRSFBZSEg4w+iuskASKwQxKwQGE9urkxwm2jx1NoQBvOdHkqSApAu7wR5grK/A3 +0rUaB5gGFQY+Ahl4hcYOhijDSC50Y8YOxisDQxY7k9BgQDIMxEJXYuwnug0jw3pbgNm8zlCUIoMX +YC4yFtmqEhSZqdd4Mge77CTeTcY6vs9zYJrjWdscXjg/sCBnFP4G7HJ1L3Q/04ccjmnjX+repcG1 +ND3S0fgBN+Pol54+70KJi/5p8ixOH7hO4oHLJD58qej0gVtFx0sk3L2iH7pWdJKLI8RlTP5B7zSu +6jaWQx93dNgj0DGPTMc7VrriY08XepxOdxNdy8lXcWa6gnNF3zl6r/F2EXEvPE2Fp6nwNBWepoKf +Cp9VPqrNt8vcPi+LRj76eWWkynybYitfkDakGD4xb+izymV9aYC5XK5tUNYP1SM6jwNvrpUhv/gH +ltb0kbXlV9f2Die/wCwyPLkQzeWKRBdvKNtE8Pa28k6TBoZdOGaMC59HhcfKRJuY8GTBvH4TzWox +YT0cfPhYuGYZftLiRmOZI/5f6P+b5Mdo3zVuEkk9LVzzSBTWQvfocjyFf1qlDFKhc7l0j+5uUxNp +WxXpZHWRpB4SVUbSqkj8vZdDSpNUQ6p0jcpOaiFpCJKrIUlcmi4G13pIUSoiRSmGhFYP6u67iWI5 +O6qDtCfjiMOTs9RBSnRT0lMlpCtUQhrs00c7KMQ9cbmM0mfcGuvq6BymXlHJcqu2d8ae3xg7nxVW +stJK0+au2H5TrC+vNPg+NyWWxiJLu+msztJYaemy/1Mudx3KLYkjbXJeUFdzaetRu1SD6WN1mB6q +xZR9sYEhC/BDNZlcVabLdZlgJkwXijP1q4ou12fqFZou1GiahjJNvlDTpQuMFl8p4sI1RvBMF0o2 ++duMZO79NRVwAqkxr5WqLdWQ1ovIFk6+m29LkJS3Nac2hwdy6K6H8suUnLVcVHIA/OgLM7jkg9oo +lywUSoh5KPFG8xLU+LlkAg1G0EOIillSjG6b0IWoBnvqrDrDx+J8H43yPTZg+NGQ4Q== + + + Q4g+Fns8QzUuM9jZ+EKZZQZlgK4LmudS27AqKFGI8kpl0vEVM5fn8dUw/mcvbHu2RsLF/NMQh4Xz +sdzKi6U9H0qthDGeBi161KPHixzHhMptSqUlVE7D/b/FruBbh+opoz0M1jDXyDnP/6qbxNOtgbE1 +MQYjY9pmfTkeeV49OllwctmCZeDOTjwBnD2UxnRB6pxLluzlXseUyaOlTD6UNFnlQtQdRl96Ntw2 +H+5y4uRoeJ2xZBpScutuez00pkkt1PkiXcZJwJ1zmc3bG1I1pZlvRw2U0lXpjMtRzrfw6RZMXj5R +FZ5UygTdlRMtYBpFOsvSgE8n4kwCXqx0buUOOktmO3TqCB0JQH0FmveUsYfpeivReTdREmcBdnEC +59ITOGEiH493INsiyLkKTNmDBMS7k8Nd4pH7JO3+48r99EHtfqPbP0a1nz6WjXA5GYE6d92uYc7x +w127YLp8vHvTx5MtLnWPR+4TLbOPdXD6VMvsY92bHpNLct69jaMP34gbJKgqrSSqp1Nb4CI6OVC1 +H9VM5wDdos10c1neWKj7Whj5QrsWF0ICahXICTzEkWF3p72ddK0bcuJxSdGE2LAx8HeJ9eLOfC2E +X7ZdX/TmbQuVjnrueqbnRipuhtrjuS9+m/p9ivNkXvhLVcsf9BG6omfOP+j1Xq/7+hiCjyN4Rdof +a+g6MEzdyYUWXJeGbvmsdh9n8LEGijd4D90iacjRnGhVLIc2+zx7KUEodcEXqQueLPZRJlHXq9UA +37v0+5PzeAX6m4zi7GhutJz3n6zyf0pqX52umdjnTQBPo6fS0+kp9bR6au/8qUJ/rtBRPdDtKfe0 +E/WdQuXiSOOGyg2d+wtnAenq5POjgHvLuFvNTWXHADdXdHeageovPCX9xdbFfBtBFWL7qBVYBPhD +aXks8lbwtNxKUhute4xoULmyy8L+ahi/SJzGcEmcAvQL79k8OblzdqhqckHNKpUjfUBTxOmXnvba +nR3wWVCveeiAzxBufczxoi0FPtRbNufNiILpTMApDUoFn028nnC7UOnxkcLtPzJn+jHv/uS3T5eE +5Pn7N/5MNB25PjsMGq1WMOuWsYqiXtlc9S7cD67766H8zOAvXnqcw5cEfwXDlwmei26XOFZZfFSi +L6X5PirL91HJog9YbRfSAx+TcHiWOfcQOh+ae0xyAqUmPCpJ5T8zOu/TREmYyF2eG93kjRwMw6F5 +8Zuf/+BvMGq36zJca351zJ+48OYPnb3/lE9/0YJLFyME6UKAQL965elgyZ2c5pmdq75IIignhFaK +n69qHvQoeq9vLqHDTdHyO4ud81a6yN1CC0XR1fMfJzJ8oiyyIsutWGydbxtaJbauNgZH2A+0WHk3 +1lj7adLwHfeTXxaCFA3mrygnxPnJJIk4EM83E/HdRLyPr5PYKvJf+q7XFjW6uEgvMOINny2wg5wx +Hr/T7yZrcnT/9ud04bkj78cQqMRx81pNHHS546DLqWl8tLrfUbq8Sh9YXSJlafqIWawXeR3J8/hA ++QSXi5YmS5fZJqJF8klqmsy2vk58qL7OZAlo+WKFHXZGX8g+eyD3bDeJK/5OjiIHTT6T3LOD1Cjv +vvaPZJ9NZzJUE9BUkqosVWnK8pQl6o5MtgPJ1aMfY9Vdk50fXi2w1iyd5WiJK8ugR2fLV2mTLCZT +ZWWtqJKvySl6S9fOadUnyUrxx+az5lut5LrTidONgA/nNapvRacS/J0uJGFtMxzHHKxtTQ6dWJJ7 +NVHqVc9t5HmFrv8T+b8DTSicTjuaSjyRgkwkvjfhSPGLQNOnTuK87yedsdqFnnQucs75jqQS+sT5 +mPMd+sNhtBuM8FELzv/tnHj/N0e4PPDQBJ5kd1MXlzq60tn+Nu5rlza0g17KMe5ni9vDfPyaF5jf +vFYxGdls3KkRdLe5SmC8GcDntoxZLWM2ixS0moYMliFvZZOv4m8QG9NThrSUachHGW8LG9NPhrST +Id1kyDKZxvQSSm1ij9GY4MSGnKY5aaJTlE1x6elOk2Q83UnCzdHlPbGbSS+W4+QndjmNKVB6DJQS +oaYhF0rzoRadBTIyJ5cXdZS39MOhckD06WDy3/7B5Kvlklx2Zoyj/NnjPLl8zi8faRjr6XEV5T4w +1pvRnj4rdviB8Z4eHT386IhvLNm1zgsGw1qDzSTQtRqwE8SVXDvi0Jklh2bBiN6DWTlfiumvLhvn +cmFPrOtpVqrzlNgur1t4L5RTnKq7M3vzRFcbzbYX805sidnTJidbsrFJRdAs7ESWkF5JW+k2pFVs +u52ZZ2KETZaNHUnzJd2X5hqrvlxLbEdB+iNZTidS8Weyn1ABRhU40Q05BYvyTJTEgbrwjub3UaqM +8YkE7H+QJ1HVHlSKUS1GxXil1cLlpVQ9pnuTZ9KSudIU15nCEwuZjv5yoSlfaurA1cisHtkiZxg4 +zSZPlGmzDnk2nGmDy/48z4YybUbDNJqrncdOjdOFxuzDJ6lyr3I0XTxDtVJizO5SwGF7ekrOeETh +ZJ3MXj0g65xl4W2LwwNnp/Tg1HDHdKKsmtFqPdrd0mq2Iis/UhaWc6em4dyUt1z1drbjcGoqUGZ3 +oQyd8yQxMF2nwXJd5SKty+4/Nl4/fl3W4y7OevA6rekjd2pdvGPrQ8/5/VsfunfrEbdxTRdK1z6m +mO2Dz/RgtduPPfXyMz30iweq5dIzWiTKWu290qco1OpQc2Ox2LGaGZYI/4lXSz98uTTaCtNjLpd+ +/PXShzxduF76ChdMf+YV03LYwRcQuZsuFJfw5SW2BSaoxMST7fG3ZHs8kCGRgQMRAx0NQ2Rjad+S +KqUdZFUksdRvqg+ootdD+Venk5aLkROAXqw1TwoNb+g7cxdePgQt+cAXNnP1QB8pVfyRR6D1zsw6 +bOY+55tOQU/OEd1d0bShy5a+uNsws3ilZWs3zzQfjj6hMJ/Y18Wpn736bHfLazK15pYzd8YDrHvL +qL7zB1m57lGiNV1odTda5zta8YdNdnmkTGSUDoXykTe316K8nSiZWlyyklLNftmDZNV3VlbSi3Zc +kVI8teyrRW/tnm8Rndhh+7+2S5Y3k49V2P/wXb/nF/heOG734cr7F47i+Wd6UK986Ov4wCO+RDnF +R73/lLOtj9l3Pi1F/BG7znS9/Gk52Co1g2jdr3S4oleWCheqiR1caakq3TkvLUXdmsjIwp7xnsr9 +swpT1EfuZa8xtr1WlrsrF8tO2OdNxSl/tyz3fqg7JTw4SdR1c73sxIHgBzdeLLmE6c8t1bVd3iWx +0D+mIySu/P/Bve4LEY6bboNeUqbhiqdWJBGCd+ymOzferEpJE3wFwEe0gi/F+EUbdL20P9cvTWF8 +uj/g6f6Ap/sDnu4PeLo/4On+gM9WjP99ET7dH/B0f8CTU+ypaPzTVHiaCk9T4d/+vtbHFzEcz3l/ +0sf+6vzl7eKZwrY5U3gyRu+tyN5OsivXTXnpYj9dKjVN/05Ddufn6lgXNMEgR5/RZUAOAymUhEYA +q0maI88KUqMskCNp+qQeTXLCkV0DaOllqcXBWfEnd0y8UpLG3jKXLW+ZKDPVNVqVF1/dRb39mnk+ +SxBfPf+ahc7u/4pHAdku3lH89CBh/ZOE9meLBfRogAb6i6R9fjzY/5Fg/sfi9uex+cfE6Dehdpbf +nymnL4hpEtLTl9dM3LHpsamUPzoxs8k/lYAqAw+D/7KYIIzT4L48nqWxqUxUqbi9RIFk4wN+TZjB +a6YzUcvS8lCYrfERRbsjFH5FoI+5Dr8YJQvIXObx7lL4QGjFCzk8yYUl4uAHrEkRymVx+aWYvkx4 +Xqxv0cb6FlYQVAUOuxju9EiO8zV5P9N4oGJTJnrrYbpUInp0Sz5QIhp9BZP5lLa+SfMkjXLjQqmo +bUVaDuftLtSiXSQ82utnlcnKQ+2cH3GMlSZ3aocjpjvKArGoqUhRkp8TpZFkiv1xKlSzZCiJn449 ++iIJc+lQ9AUZ8wgJ87AaOH1cD9T7nvebxP+xZOm2aOmlRJ3TNsN/LFy6bvL605C0s03b2ZQvnVwO +fztcLGDKMao9zUq9xqhHq7bxKlZjH74MRWJWkwathhtR+p0orOBu41aXIles8EqdI5T7XvKz7ivR +q02mcZyXIRQESkkYj5Jr9KVpEcq0BhAPFyXfddBx8SFU0AZZvtZlky4CHQRxfuNOuQcMXD20YVwP +5YcENAC+/tXbN7959+rN+1dvvnv2zMlt/4vpV9/jbyL/5jcv3r9/+e4NCPSv/t8fX7x7+cPN7s13 +r19+C7J8A7hZltuU6ir/xptSbjGiJ/9G6OqP2F2zBf7wF/rv/wM//ncA/utNuvnlzT//t/nmW4L/ +4bfwzxbnvYMJ3pvnANu8a4DpZ59fwIewN/S6X9NQgOUE+gXloNdKbE7zCjsOboe10LY487zACq5S +sSpyLtAfXuAL4KVY1zXfgqGZmF4B8b/0SvptuwCRjz0/x4SgP8HfsGIBS9gyV1AZaqU3KCy226Wt +Yfj4JZh+9vkFfPoe+hxwKkNHQYrSexRWltvYwM7zn78E088+v4BP36M06ec9x2q4Ta0uwqA2z+0S +yL95i03fQh8rxQ+Lgtwg8KcuQNwYbDDpC6hbNeln7x3Ic1a5cAnmZ8OITV9C1MAs0TG9dzD+SBs+ +fgnm58MW38CtzZgozA+Afv4SzI/AFp++BwRdgG0Bl1meK2zXGEOPINhYViekF6sHSRaAFFwD6c0/ +0IKbb37L1UcCLE8uJFfTWAKhi1VUulkhh32Rjp+suJpv/rDjmsc3/+pnap8rl4bt0mK6sGY32BD0 +R5b6NXNh2k5eCctQJSlxGVr0ohCZ0Es2F6jn2/l1/8DID6txA/PEX5qvTCrs8gvVvgsRwx8XeSvb +kbNoQDoC/UzrMEtFmlyaPcqtSzAvObb4Oq0VlP1I+2NdeGpBu1yI0Q3jnCiwNWEjs4lDlTRwVx1E +uFvKl4QpFrrayFwBuVV7Qfb/8UoTfyuM/TytMIRJ2GLC9ALML8hLwv2qw0+bKMjOPviDqL0gBhUk +n3t+humaw77ZD/wW4cf4khy9IK4v7C5MaEpgRY610FJe26idagnMVbkqeU9MKA6ko+DewXhdpHNJ +vIF56rf4lNatVuE1DY9TVJcLII/xko6Cb/n9dGJ1E/RTUTY/S19d+Tf7dz/+8GfFY+6GMP9smm92 +8PcP/zr9CM+ghV7WQUkDfZZAN7/NNyCpE1b+XIALz0AlXG8xku/Az0dwKLd4MSGBFcMlWP/4mwl1 +UJzI80JjX/FYGE5SsMhWEv61gJlAByJx90KIFeBfdB471GhY5EAEhwbTcc0JwfF2DvAZAK75Fmw/ +ISPCkgdYjbd1nqsj7Rv8fEF6YAISGBsuDT7cmm/4F2gIhhbgBLJ7w6VuG/4LNpwzYAzJvxyWJ+7M +ZaDS81p6dJiGtrhfAd6bASkyu4GaPhCgI/DNSCmAc4HODb3Stn8Zu9/bOlZpW+yY4w== + + + aqfB8b9Tux2ow/Sn6fdTu/npz27+8I/wE01qWAXDlP7YTCfoDYBvwjDlHz3hV1CfbtcVNJM1zAXL +89KcX+c1ophoDvx8Aw63peaVwB7JA2BDcq2ZT9hLAQkK2BNsBDkR5QtMLoLEBOoVN0vrkhiYYUe9 +GSmDlutacZoxOHL3ECWY6QxEM5yBeKXozcWX44Aih6BNURpSWpLwM9+isxrB8NMMOxQCC09Kbhtj +IWC9xePSDGwLrIUDIYCZhD4BBuewaNuY5GV5DjfccMF9m2BlBsL58w12xHllAhaaqOvcllvgfeC2 +KzNshtmboYHyJq2MACd1TEJsKKXwjAAwUFsH7sAeDAt6FfbmGqIA47IosZg6y3gRHJVhsWVpG8Is +WNNcFEFYi/IclVtDkKsNcA7SFjbeqAhWBYLJrxSsST6fbjESJ03RZBBgZwLMeQEu6BZgAuY5GAJY +/cJFULqqcAbnTWnCcfgvoci3Kcwyw1LIzPECFGjHas7aMQBj13kkW1QELWUFppQV2JSw3jFYdDbz +Ww3ch/U2LEXmEYhaRgqTI+jkAIEln28ws4vQ2pLwsKFiKO+vOPHl8zK5cF2s9nnMmNIpu+jnS+PP +w6tCyAJsyHgG1nXh5TjTghcEda045xGYGo9MhkUeVwGuqVTh9RqKIYAZqUOwNJZiy7zAS6K8LgVB +saD6GbW3xG0EpjkLtREWrOBdcF+Q1Tyvc8db1lmooLJ7DMTML2F4qQwMtxiv1w6XIHgBnJL0bYHF +K3gDdDQJvSG3VVAkHBNGkWMVYIlRV3mIhraMb2O0sEpxm+pMY2A0EUgyW4CgagsBLO0YDJuBkDsv +axES2qwDvOQ1CIIl9ZFM2l+UDjoQIBu4LUz7lJtORultBSketQu56EDAbp+KTrFQq7StWMadOY7C +XYBr1TVWHIIWVdCskQlYoberNMWSnQIEzV3f1GbtAYChywJeZdast8C4eIYAjSUBgvJiCIhEXjor +iT8Egrqz6DwIPAiNZU7nNiNoOIo6YLyJEDDp0l1hq72xlkJBhf8aghhtwykAZmDJtSpjDUj+VqbA +WADQOdjCkQFvyE1l16JErUk33XXRWbTMPNUZa+NZBMAuJ0kkMrC0VZmNm5EiyECXtuXJvcAaT7bb +BJJT2BJMwSJ8jYVmxoKbYFDhh2HZgyLQVyXaLgmUg06WarAuu3VTQnBsRVdyZBEDwNbXC8s+eDWw +f22OJkYQ0NOsi3NhtQWBQdcLxmtu/knaoh2sO43ghSUXkk3YVWAgkHW9oaThd0XUwnTFFft8Rmb4 +3QeBfQetZamGoM1R1zyeoEEgfCwEU2RI5UFgrFVeBcaAfB6QRSUAVG1+F/zYwpaFGQZzjU4UMgJA +VpouGBT0DCSVnYdrLkWAaR72L0VQwiq9zamJBouva1lQkMErL0MbRTSsxfBW01gWXRyId9EpK/s9 +qFymRZt6hMAF5o+qR8baAnJHFU3MUJa2dU4mH4S1FYZUp1yw5Y0+ibjqpCslSVs8oaOsYU0ZEQTV +xDDsLghAcibb1dIquweAQW4puGRFoboyCv8SBdhsnwno61C8rSZZjBFrxyMQ1Nyi0x7LIQsQpOGq ++2pQ3q5YWSg7whhYk7Imy4CBjJ1X3b6WutrnYRErZ2rRz/etfUlBqarRNtA+Ng2loK4bYP6NAGFv +VwSzAsNaDViyIehTXNywDE51qV0dY9galuiYyMASdMgTbtaKNs9L3gwNtK2qGsAwJwEm2H5UmVpW +Q1AWlRNZdAsAtrgIsMCCRGDAAuC6U2GCBSMIeGZ+ToqAZXogQ64oWbynBIyxqcpDerwiSKkJC0TN +ReAaVZ2r0oWw3Iak/F5R32QEAM7MA1htgdcNAMFgke7myGICgTHoq6KuGwBjJpsQtjbuQnB7hajU +CMxJZRrYrjIKAE5VN5u8sgTGtmLGZdMGEbjoSsAbqgwBKSrcXXR8CxBtYMYKPBIgiGWlAASsIWgx +6zwQfTREU6rRd5GzAENLSTmrygmA46oLj1gvwKgrpIiCh1ibrpCSVAEHMPwsCKgzCExOWJPdwsCu +8sAOIcIHwaJcAAWs34WMDuiFh3aJBow1KDAoB7LbMCUkw+AUVXLQNsbAmtQIaSwSEVb08zUY2mIm +o/YINi2VWiuLvYBLWidQNXUpoK6tSgDNBQbm1oT6uch0x71Ol3E1uYk0mYw14uFjS1EEoooDMGTV +pFc0YpX6ZVWpIVY/Icja+yTKDSGwyWaqEbq6Fh0Um4MFlm/RGaDioZh+nlm7VQRrUIFcUe1+ruDI +iwNNX1b6Am5r1XOBgbOsmNI1UYSirOnriIEZLBqZGGJjAJAiTow0lcUQJFNwk3q9EEzbPIOrzOLK +gzoOQ3VSekWhoXiJz7LqhTe4gdrUZhcDAWuy3upWhWC01akTJHARCKZ86pNzrgLUFScziRGsZhPh +5BZRANtPaiojxdICYLIVV6uqaKE5G7LNqyLAyzP1ZZUYHmc2WbqMJASRLuVUCiJTG2dzFNmaQ9ii +M3ENasTi55tuKQVlDQODLTx0qAmQYloyCCrQEVzUybEuvMYAWHP0spuB5GGTjUoXXkQPQdNdEZe2 +AJekoxh5ziIwasuGVfsVQSy2rfK+DjB1OcLIlsw9CFTb3+0S/PkAYkc/rwotIKhZdxQaIgY23Pfl +TYt9Hk8rihYidgIAU1DgWoQq2GXE1YZIUzQEmEPmpMxzAYMFqrsHb7URdpQYdcZGdqVG3CXUN0Af +YbToAtQdpck+BcCu25A2ysAsxm7BUJ8sj4iux1RGAlB1CjK5AzuqEKjmut8oEdysu60qgmo6TBFj +EYCYO6eTSLepiKI6Kl3o2xSsRaUJZpQaBaqfojB3FCw26dkRgVjnqtqGGOEIXJRWPGlqCOqsc1ad +HhHluwlEkTvYhapaay6qcUUgfFXlKiahtnAcj4VnXZoA1ZOB+6Cq4wieoy27rAhgSikF4ogAIFnK +Mg2i8gDEd5NdlWXFcwEn0TsLezUYGFZ1iVXx1CPQ1GnaOhVvMkMjy+YaKw+0aKisycVKN9S4OccI +0Pdu+nTQ8Eastl25lbc6z14WowKAIaoaVMzGP2/7XME2m8mfzMDYVHyKlxuBedaoQkbbTvF2zVM3 +BqShqFFRxdWFrzKHI23JiiBEZU6jeB1TYPtVE9OMKLAFmfrn8ejsqLlGtMJUz1bVF4DdpbSaAYJx +40UdCnVlRR2BMdnWJmMOwDWq4pNtt2nONmxidwMw5aRtJRQU0fed6tlkhL2xrH6dCtam7uAmigAC +TTsgAWoIlrltZqjEw0UuNyMrqLDufjkA56Y+bR2vZgo5LBFxygCwzqb7oVWjny+2ibS6KgHFdmHa +G+VNURVyU71jd9eR0JPJCVBT80jOGLjvuUbsanq+Y2F3G9A01JcRiYMATZhiE7xpx0D1DBZ29RCC +hDlWSaSE2u1pds6AhjOSgWubi05u1UkTpWTZ9G6NO5a6H7HPRAAG5BMTxssDYCk00TPnoI4lAuv2 +SlNG0WqQDcCsNaTF62hiFwFQnRRo1yixqCDM2jEWtdCyZd0YSDhywxDM2jB1MGGEWuUO+58ApO66 +btoCUE0QUZ71480cFMbXaC76wg50BlLa5kYTQrDoJ8AspQCAQdf3gt44BCbT6QvHFxkBerCN242d +g0mUdgImcdqmbFEwNBVUo04403WwhdXYF3WGVGWgMEOE/KocQMtzti2MNV8EFrVhEwe8EBgW9WTY +4kKoefBsrHtT7BSrwwnXtNkvVZVRAKewynwHZnNfq6nTA7Cby11nAjDZzsLYkrVtCAIMMq6VI188 +rhYDw6a2VzYxGAGY62IbR1OktZkrxkR0qqzd27ueC9TNDE5hQzBswbnrBo35jUC1mpOsAti6alWs +xVY3gFdtqoITgHE2abrwXo3AtPhdRhHk0hSv7KlpNVFSNHS8pOYYS4FhRoBhFjNuk5iWAE0SznUL +oVFSmHJGJkczn8UGrere0AcxKvJss7OYPx7z1op5mVA/IwQZy7KreqWGfw4WgyvsjGag6y2uFEYA +YLFqkLAQuWc5oq9NR0z8TNC2mYzIlWVExuDgonirhuYQQVHjMorzKaOpkFQg1aBA0ClVQ1RvAEDJ +ySiqBSu0GSMgSSe4xJUAWNHy6j1QBKqmFnbQCQLx6hQ2BxlIWp0IHrWZESyatuNisngdUMC2CsB6 +BzR+j1ByVgu/m36cRnnsQDJ3q3jEFEFfubRhPRewhif7IsXOmq+oiKaPtC7q+u+ee3xd02CsZBnL +64qF50SmIV6NAUk0GT9eNNayouP/8PDHMaVD1bDEoRZqOJtxmzpVFM/hHrC2QV01eSZGZE6cD8vA +Rb1aOdueWtTrnjHHQqemTbeEB0bMkxE7/c2cikVnRrZsnO7Yyxj6Ukr7pkgEVDNuWfxj2znq6hKr +KmcnC5KpMBn1NNVv42wIdApqpAjbLYsuzag7wkMfxyNg8iqJsOds8afiRwBtCBXSqnRn3L/WxdHK +wLAoWeQ6ZQTFgp7FAheIdTVBIg48ROBYuHQES226K0q0DIClziZI9POgrCgBfQ4UU4LQcGXvLgL7 +6hZrCIA5qtIdbF/P2B0VcIv4k3K1kFC5lY9XzhvpE5M/Ts5OlRia/wFQpUmXAFq6utFr7AyA0TkJ +m6HUHIuimWcIbDKrs4QEEZRUsCxF58Ta0dF/zbVW2OHPwJB0NtCo6YtbU72jSPzWvVidXdnrAd0n +M3w8Rn0TCEQZCfWoIE1BZ3OPHCA4qaRHcfBcoF1L1+hHxtSMLL1SQx6B9q4elEHwojmNVfxaCEzK +FhU9qwXlUaZrYkBGK1jtlLXvlqA0JB07k8kr79My8uwXg5YwQxWINpPibaXovtBUb4LWlGggXJTt +onGiwaD3IF7b7RZz1QMYhK0uyZldSBkDlNbfYoRReqX0TBUUAFdJ5StsVzGwLH3DywJT/0Bx0QpE +awZATq5j3TJRnzy9K260vIymZTFgE7rK7NQ0zTkAYFx10CW0RQ2jDGTxnw9F+1XFJQ/AFHVrUcsK +kZqLN6kFU2Y36TQ4h0ibKokUOWFgNqHQJzgisCmj/skyO/VZUkqXsnAsnrsaSqfA2exFA/vQei5m +3JYkM7T4FDtV3RAzJo7xnqf0LpyhtbInUbcXbFvVUx7EKYTnCCxDL3I6IgJTtIwDm+KId1XXQytB +EeAQy+iKxAZgNdFlNlsJ5hNyIxacikPeVgaqX22YMt1VXlgNZWDJKhBKnpMANRgGBAQ127GtDRn5 +JOVlWVd5k02vYBadWq3dTUIITFJJ6kkB9bfq8Ooah5YUIVjNsFAEa1x031msu6V7eSUREMlK5niw +iC62LWnjJsC2i/qZ1X+OrzKvPgEZQXTOVE1oAWBPj65sdyJsUbdY67MAwLNpb3FRfrdYzJ3Clje+ +KavljCJIP58W+3zj4GXxmYwaHiuo1ZveYNEKAGv6T+HosgCTbmKSdkIwFbM9lodoFw== + + + 3WjJKf9cwLmopKaTBArW1NjCHi5BITFk5n+y2Jok2vObkqXl4rakGDF3WTcQtasQY1M7lFWUglaR +an7Bcjbh48oT3cHx9aE5rUXever2Rz5LIymoNqgp+kiROL4K5yIK0maGztp6n4I5E0xs48uqOWk4 +/l4Shy95BWi+OYLVoVMsP7VInua4ApJbKz01pWTu+LArl2zuedntGViqMrWY9wzBS995ODJVUOky +Hq6KdC06fsG05JL5fMoo47MLniTxaGFfZVlgdEez5aituryLuH6gLej55kDtQAsw9IBIEbuNwWHN +xi6N/4iajbC1SUMnhTBX1pLAJb+oZFOJe1JbybZLy7kJ7YEqgj31CxH0FAZx/yEwaQqDk0KZOcfg +OOt49TwxzVYpxWlQlJTACHDyWPR+FZFVOFVTtsNZR6ZlswstRargMDUlTBJ/sYqBRQdtIoNen5Wx +fTerbpsmC4iBzmdfZS+pbtfpHlAAaySycPIZA8NiW9y6KILuEsvmEkMEq85DDUlhW8nR6vYqApu5 +clAkKYIezc2StILUrm0ryqvzgpPQNgqy+q6Wop9Xb2NPCUDgomF+CvXy51eOYq/e6VGqpY32ZFRs +aQshWFZEQQ9itnkoG1+3HCwFsTTLz5FYIX8enXo6CaJEOOrMa3VQqgCYimZKdD90nV08WhvmqKtg +6Z+uSfNdZt1KK7r+LB9ZHA74+aLLUG1wbGnLJZpuXr0GSQKKz30tTqeKCws4AALVlo/MyxuApVks +Wj132LRWTdO2YxvY2DKB5lWx9tRlDVAjsGi/yM+gaHvi1CwyGoBr1qTXJioZtkya/b021X0q5m9r +jm+RAEXFCIuevaGkdAZqyFnSxxlBsLNOQu1zAffMMzrqjMDIaYvclm1KgKVkKrRJQwRHPUdG/qTn +Au7zkBwnBraUZDkBhMA1WQ69ZDMBEEZXu5Z00lZMAFSWRUuqA/CS9WRSFs8mALOdBBOJiuQuemhj +1QNmhNZypzQdtwbnVNMUWwCCHq8I5qUjUEmNW3+NGzb2sxhIqmQlJD6togg0PwY3Q5aISIFEhTDb +W9iFGS96yI6sYh1fTbhM6qpBAmQDSuxcFmBZrGFr/fN2moSCFzI7chUCAuaqMVDj7sn5jyoev9Ts +dlJZZTIumkJO3g+doXpO0U7jETgr2L2snxnT4yi4GGYdbkcBnoHSl2leBQD1fFni4xIiU2QI7KQS +NFzmktzUYiCMoNBUJLkfZcSiZzF6xiq2tTOCZNMKsOi6pSxOEVISV8OWS+wyMUQdbtmBUc4lOwaQ +uqDMem4wmMeM5G8KbmifCzhIMm/qMtEDdXbDntAkHSB5nanZJpxM0pXVcvMHIG2RDOwqD0bGdCmS +qf1c90DJZY3d/MSNVc9uqB8VgIsJDgrNqSLj+JCCqa6i/kcWsAzMTXlLWYyqDeamx6U0wQetj8UQ +tG5r17IqrRqBQkszq/wLWMDpuZmquhoNb+DZwsOjynPP4E6c6614+8rT2BoAO3dlF0LPguzCchJG +HRbqJk8WhkM3iMRqoGOqYc2mc0TW28zFI5lAETMtm7li6HAygSWJBF1flQVC1AQMdOlJaqDwUD1q +wV6miSHoE5z1eBqFZ56xUzGrnOzHFsg1GhWv5NkCEFa7zCPNKkaH7VK0X5b4hC5f8fpEc12h+1rO +oeHYV/UXUy6FYLWgZTbFI7Kd+YzjMikXZWKzgJ+4vyMntlpwUHTXyJo6exWDZZxEDqE+4wippA1F +nsDPKO7aJIAQydrRYOosmktk54ZGedUUjZZjiQHhNUVlQlC0IHQVrfnOMKaclY8Uen1G0ec+aVTT +wzj1rEskWWAEwJq5hBFQ3ogRKC7IqKFIjMqXIvzqYp2SCIKAY5P0mmp6npzBfiaJCUH6SjkImq+g +52oixy2fC5i6Lv2VGD4CV8GrdkGSCDsDLeaEOROi1EX2Gj6jpI2+boosXMzkkENqsQc4khxo5c+L +JZmSuXFDT2OAoZNDsJKvqqkstDIZrUQUAFiDErCIgxyARQ46wvZf52gIllkRaIiQEm9a1OklCULB +DIPISRCMIJhtgp5AluAu8WdEMCebXSrnKMdIZz0FAR7EitnKOoqU9cYIZjuUHkzaA7BvLDo7KCtO +112wVLNqodto+kGU/A3hIefaocKo68C0htgPiUjdgOcCTnLyOlgCQIzmL45cHoGBKRVB0LMYo5my +0Q4gxl7agI5PC4xGg99vxiEmUSddHrOc9MAc7qqziCIYzyhdmwoayRxSOYvgpotj0QTixdL6Iu/u +Aqy16qo1vvY89MipUc8ou109uH1uYtK9pDVENkQZwQxyR9cMRf4YCPqJADUkjEAbwmzpb4g3K966 +yOmNZmeYIud5MrBE3fAtByLgUbbVoOwaRGDq01gOADUL3QLQ9Lmw2oHT2M+qVD7uwOySBBs8V9Op +sr0qJLfskx0L0oPImLPGOw0eVSo6ibIVMQjJzsPj+ueNFYEhaA9Ez3VHoKJzUgS0NZu2lc0DgHpE +ELQQmUYhuTHoZ1vxvJUEI2I/nZQs8zf24zqopqjgpUg3I4iW1RU1vIknu7LuwJrtHaIVKYm3dsYe +oRJJEHWBT9X0oEHkqNszOnWnFlA0XR+AmkjvVj2e1Ky6OigN/Rmf+ZXAuChvz+h8tEYAgzuJhQfP +5RwUgCUSgIUGJIcwWARv7keZAx/yIAQ4+FITINqRStIAlYchJK2qoId7I5+wVgRhNhHHdgltjzYN +k1VlCJLiG53mTAu4STkeyUPFYg9Np5aaBAiUjLLgDl5gHYvKm32w2Ow8W3ZI0JR9rNChp6hCTxRH +sGq4QQ8YEFCcvqZEEYLVhKnuXVQjREz5wM6I5wpObDAGjn8oOMw6DlKjA4FzVnorJz0iUKMHoSvU +WBKFUtwILGoMloVZQ9J9mfVpKo0juVuhH7OY22xRscimKtfWUcdUUFcs1uGhGKXwVjYVrPmjLoKo +mRtYHQgmnjCnanWgXmtJZAQjiBYxNQv9QtWhf6ByRFinKDjnQQhSJCmxqsLt56JOiZb0BDrJH2kZ +tRBET5RBcFnUzC9WKSmsQQxEXdHnFHClJDQnW7HMaBSi9wrOdmJEMtTJ/2vJyUIaArMmxsw9yFoZ +G4PVLd39tz2RC4FFkwlnS9Eo/bx6MUdUoXQUzRpvaiVveqBdK2ZGIGVUyljAVcMxRkRx+RFBEswx +DhA05yDOFrE/w/tcXpgcK8gzeS/gaum8NWtIpmZNHaITTM8kUBSKAnXnKMn0umJnsCimo+ErzXM7 +J+BglKlRVrQaKINVi7EsSPQDWDpvrLxTlsTVZFdOLlJfLgemNMygQcxkNV4KnXq7+H4lDDaVVRN6 +aQTuFbwoYXXWHIOQNGJqwb3FshgpYqoWf49kWk7Gwkc9Vs7tSZqisHm90DWkq2QmCmFg5QhsNou/ +zQYUpRmTaHLPSFYdAr0DlqySNUOp8aEKJlZN/n7KHxOk1PW9oUqmHZ0dVA8zybh7AedmRylQ4dBj +gr20AnkInl9GItjDbIW9MutQ9wJW0d7PcWIdAstBk+RNhC0XjsLOrEXJqheV0h9a1XDeOQEyRkt0 +5+pIMb9XcLPaETDGUs5B/Dwr+7u13+dInlNNwC+rBIjgm/L51QBF+mMQgQrXRUy6mYsDPx/A0E12 +qzzXz59D3EffED1UALCi/oKlW1EmYp3msFIyLo4kXgeDP7R5oRtLFpg4VN418n0lXAEQ9LqCv4dX +Sn71veh1bQkExjJIpNOscshracHGnMLUKP6xECTZ49+IkrEmtltnXSuoI4DiamVFgqgIGnsDHbxk +VWmChfrEh6mF8mJtwg3ZVahMXVJ/kdRhISVFRN7C8lfpmmeWLbNlfs/4MtRdwBLs5aMoCtQQKMdk +viG+LHj8jfiCGZurlvnhmkTLGi0QvkQ59LSsqE1aKRkMYLSzQV+y1MrD1hpGXFAPwR0M8aKmeXNx +wL6RBYWnwnBNIsUJ0zPuBRzXFhz4+QYc2YoRmnFC4a2fWJtR9eY1r80BmZXAFry6zLdFhS1GmtId +qwcKBarFwQvXDWEeHLhimpTxa0oYyKN8RhgBdYhg80xjW8ccw3qBY1KAEl8XVmE8+ZBoHTesSYaq +/rJSqJZnDzoYGIhJuFJDDksIFqIBy+cloQw9mzR0TU4BychL2Ypg58CwcNRqsS3Lbl/Qo1XVMRms +1g36M4to5Hr8BOt0yfhU20YpEpFX5U1cmLAZgzu46eOsBmbwEoIJnmPi3hJHuUpipSQz5AxIGJkL +UZYVzd5VlvuCbsnIMx3knK53dkhhSxocNQm4Jha1RecWr/cFo4WNwZTXL7UqwyorCCROubk4Yrgq +fpyWm933MnRzrDIHySK834AxAtPKjVZSJGJwwHtJvkTVMgzInEtSo21oi2ezYx6weqBQwAg6eGF/ +54B1RaUjbShQoIo0oba39f0yrBd4gDz6ydd/t3v3/vjqm/ev3r558e4vNz8H0E//689u/u6r9+9e +vfnu5qdf/fnF9y/3r19Suek//+4v37/82c3/gY32Dzb6xZGb/J/wF7fR7ycqSYvOVKw/BIoWVUcH +/ZSq1S4UVHb1xoPW8068TSHtoFtXFixkzN5vwJa8Ms8mK6o5loB5oaiMJ6AOH+eODG2pPEgZkXaY +vF9HT8E4b0UidKQzn9UbCRAgI+jEWlvfK8N6gQM4enQ4t1CBX/hhpjryYNMEqoG+xAy6O/IVN3xW +D0qg6yYT10k35nIyHaImpfJ+A5YqJkwwb+LIMTqMx52Dzao6oHJ3TiwFXVtM4ArrBmsHCgWMoIMX +Syl1WGc+njBSIEBlr1JrbX2/DOsFHgh7A97ahKWVQYvVGyX4xhuwdiNxNepVQ5Fy0LG4Kl1NZ9wF +vVcwU9GV+w0Yyy6Z34jLxeLUq7bBtJJjh30jbivQ+NaxpVREHFF2oLxeWavgwBXYRqQze5LH9wtQ +WaukWlvfKcN6gQHC2hkLWOPtAiteFUTXJeRIt4yA9VFJe412owPejYCQ7LRXdlFVmTdZbCcPlSRJ +phdMXF3VWlNV1lcHKnNDmeOmLS7rsGywdiAT0MUKQwPHBEakMx/SHgkQoDJXibW2vluG9ZwDzFuw +OttS6baMOdBNGKB0t0i3vIBeTwYBRk6XRHclpMx3fKGJ0FkLlpUgjnhm9X4DThbIxXrChVSFJuVQ +uGul8I4pQO4aOjl13ltbXHMhbrB2oFCgg6PgwIdsRqwLnkfcUiBAZa5Sa219vwzrBR4IdzFvCCVs +bKRuoXHVMK2DrqSIdDVZ8neQFZa7xlm8GpGxBsyRu9+ApTI208rVRmnSSZ4BqpxisAhQOZtqXDZt +o9TwG7B2oFBg017Agb2QI9aF65eNFAhQOavUWlvfL8N6gQfC2YWO/pFsiZUK2IPOs9bhkh+epu7W +j2o3p8iWWmpj1HiDMNtBA1gLP6GfPq1i5UWpjTdjiSk1TAio7BVz3bfF/Bg1eAyrBw== + + + EgWKQMHhNlqkQZEuPX7SCRCgcleJdW17tzrSMw4wc/O6Vrp/bclLIOkwg3Y68jaILKjoNaA7luwG +HZFLWd/WtDK/B0dLnJ9RJVlE7GsBm1lWXAeqAVLWmjdtMcw7rxusHSgU2OAYWJM7HNagcWZHAMOU +tUprb+n7aijPGICsXVjDzSmwrnB+209nsN5M1K/WYr+MMbgkxV/bYvxVKIbOZ6VvFddLvJVDLFiV +vXiYmXdiY/iWfKXDgLID+e368Q7VOIXD2eddfzvDlLdKp5+hvZuGctv3LzRPdo8zT34vzr1FnXvw +z7dTkVtFfryas21wIT6jkC4o6iJ7yHS834BLj97iUQvWY1dLgLWqjAYkflsSgG+LZfNi2WB1wORs +WgcOnH05YsX7RuqWAgEyBZ1a17b3y2E94wFJqi83GKkoYWLSJB3xfgMOnOtPBRzZ2sdk2ma1Lee4 +OqB2jPP6h7bouEzNo+wQeTd/uoMLp5GOKOst+jE2rxegjqyS2tu6HnWs572/lrHI6SyzdI6ikvcb +cEDflVbXBByykWnBF+gcvLQ5oPK2rHnZtE1yVn7A2oFCgbJXwb3gmsNa7cCso0CAjKBT29u6frky +bmc8uJKxSGk52Xw0FoR0YFQignI3URoUcgx0NJ06S4oeqNxFd9qmLYY2W95g7UChQLmr4F6402Et +Vu3JUSBA5a5S69r2fjmsZzy4lr2IRJCLdWUnisxdB5VTJAzsLucasnKX66oaULnbos5da5vlfMKA +tQOZAP28Qnthcoe02EVKjgABKnOVWNe2d8th3XLgSvYiJ4ktqgljacL7DThwisgzqfurhlmrslSL +3CdlQO4aVZBaNm3xqGhcNlg7UChQ5io4Wc1FhzVbjpOjQICMoFPr2vZ+OaxnPLiCvUjvr6sMWY2a +CeHAgbNyGRgXBdL2yf0Sp70ClbOLyEbXFg+jKtCwdqBQoJxVMN7BMGu5asWa7fSLo0CAylml1rXt +/XJYz3hwNXsR5RWlsJF7CvP37zfgwLks3I8Wdd4lOTCKBbqDTvFk0R4s5r3M523nXJczrAoUCmzm +Cxh2GTkh7LDimZ2wpUCAikCpdW17vxzWMx5cy2LE6/+aOnGoxsj9GVhv1EBgqmp+9L7BRlkdUPuW +og6Pa9uDmg5rBxIFNjwGtuTLjjV1JaRTkLzC0qkd2vZ+OawbHlzXaMSdojUZPToAcH8GdiXmF/NN +4NgKK4oa2lXdFXRx47xsW9YQwhnKDqTX6+c7WI9WOKTD/Nf3C9Dkk/lLrK3vlGE9Y8A3nAby7xDb ++pDpyIbMv4n1GLNFNrz16MCF0wueca1oOi7lo1xYdbhFHyYjpmNpWEpS8m2TOPMHrA7orUcHDhZ3 +dljl6NZIgQDZ/OzUura9X8EXEt/wQBTFLzIc6RIizZfADfB+A8ZchKKVufkgBDLLVZnuHCSgMpYL +Rvm2WNl25X2xY3VAoYARdHDQrDqHdLETKo4AASpflVjXtnfLkJ5z4HrGIypQRfz8VA/lfgPO5Plh +chsVCkJ+2ckPULAk5UOA3LWGVSbT2BYP1JTQBqQOJu/XsVGwpT97pHhVYdi8n2HKWSW1t+xdcijP +un8tuxErz6egVltRo7xD8UKSxEupctorzTmrn73K2TQDKmP5xj7fFhdzUsYqVgdkAkyaJGWsHmpy +SMFaWuXCiU6AAJmATqxr27vlsG45cDWjMRZNOMEbTfPSmavg3E8WVT6kygt6NebyGUEDKnP5LPDQ +tsmplgFrBwoFikDBwRdoV6zBzkM7CgSo3FVqXdveL4f1jAfXshvxdgOJ3EfO7L3fgPGeQPb84OUE +Ue0FTbSjmwUGIPdtxT03btrSxSzrBmsHCgU292dlTmv6LkUaOGw1EhBcNM0R69r2bnWkZxy4htWI +QmmeNd6FJ4buN+DkL3Lgy1Fp0kkWM17N0MLigMpXPhE4tMUqi8pXw9qBQoEi6GAt1+ywYrClrBsK +BKiMVWpdW99dw3rGg6tZjbh0esRqnnUn6+Bk18zi5Rl0KIRzSWdlb63qJCagcodvCxnawrZTlL2G +tQOFAkXQwZrY6bDS0aa0oUCAyl6ldmjbu2tYz3hwLauRrhsJsiSyzV0PNQ2malImUhazimG+etWA +2rUqKRhDW673tMHagXntrOlQvaGh48S6HAbU9wtQP6+0Dm17r9YLsGzz9gq2IpKbm9qixTQFD9YT +NNgLOqC0GfScZj8TbNaEOZ215avjNlg7cFzVBtaKTQPW2sIZAbV11nZae8veKYdywwC2FT9myf1b +GHF0SF/nQzfiHLiXfcei/msRe00rhSW6Uaw5IDEjY0XQ2sa2GX38qsu5YvIK9EacA3cNy2HtmSCO +Ap8J4qh1bXu/3BH3Mx5cwYgDpGtVPw4WEbrfQN2NFStuFxL1sRsz8HT0Gh1Q+TqH1Ma2GZ2nSxix +OiAToGxVaNCr2hxOS2f27xcgc7XT6tr2XhnSs/5fzYLDKy8WHa6INbXuN+B+1yjWxshN5rHWDKLb +GtLqgMyaWa4v9m3zYjtUx+qAQoGOTd/NqIDXiHXh+gYjBQJU5iq1rm3vV8d6zoNrmXF4T0gu6lOc +mzFXoZjXGYW3ISU9S7CwqzNRfaPogMpbVa56W1zNQUNvgtTB+PUmTQQarQaQwxnsHjz3fgEqZ5VW +17Z3qmM96//VjDi8VaXpmFGh1/sNOHMxDqY3Rg3H6T2N0Dcq5dKBytsl5U1bANKp2wGrAwoFikDB +0W5lcViDXSPgKBCgclepdW17vzrWcx5cy4jDijcxq4GqyvAApTKwTG5aNEwvhW7pupccO4w71uQ8 +rGtJ005dfopyAJoi7KB4iN9KDinO4PcwfX3we1in1LXtfXJYt92/hgFHwl6HkM5E3m/A/dQ4VSzS +BFxNOIZugUpYHVDZSmdStm3p/qERawcKBYqgg/VCEIc1WGFwR4EAlbFKrWvru2tYz3hwNQMOl82i +A1nx+rD7DTiZyooEU9EgBOoJQQC2sAYHVO6EUpZN22Y6q8PaBkVW/bQD2K99wRr65tQpCONGptQO +bXt3DesZD65lwCENVLOGc/5Dn7wOPFe9QooLLpKxE43la1CnCAG1b61qjN/aNryTK26wDkCzbgew +FrgcsK79FqxOwWphrYFa17b3y2Hd8OBqVhyWLWs6cDBaffJ2MJUzFWCx8Fwf+SqaaBz3krLO5235 +AuoN1g4kCgyBgaUI/YB0reXs/QjTT3dSXUvrU8e46f5/nA2XQUSta3L2y/0GLFfiPeOqgdK/anVp +sG6hRef6wUCsh5hb3bSN7ri1YnVAb8M5sJRKG7EuXP5vpECAvIF2antb16+O9ZwHV7Dh8EqcdREf +SrLaJg6cLfCPN6yEnojW9CIRro9hQObLIiWihrZ49nZOI1YHFAp0ZBRsFYcc0tCZ3QkI/XC8JzZ4 +Fmq3DOk5B65mxuUeI0x8NO9+A86uKmZsRayHpKU3sELrvDqg8paP8w9tgx2GNqQOltyJQQeO/Q6B +jjRYpTFHgACNt23b1vWqYz3nwLWMOCztWZoaMdk4q8DMlwgztalY+NeuyoFRbR2mjOVK974llhQO +G5QOSC9Xtiqw61YOJSZkS6mY/nYBKluV0N7Wdalj3Xb+agYcXuRkp3Ko5N79Bpy5zOkzudioaTxZ +71ZAKb4sDqic5SJVQ1uq0dhGrA4oFCgCBVsFUIcU67hYgVolQIDKWyW2t3XdMqTnHLiW+YY3XFmm +GUmk+zOwRNBzcwZztP0Dpp+DMV/w5KIG9bXlIpdaO4wDrEtJB45W0N3hDHzf5Ph6ARpfWwljW9el +jvW8+9ew36hysKX6rnOvQ9QP5GW5twPv8ipx0fk2K1uXuiQHVL5SYd6x7YJVQ+KI1QGFAuVsB2vh +Moe1l2t1FAhQOavU9rZDdxXrOQ+uZr/l7sWLfKfq/QaMvrmmZKhtW+yOr3ldlg5T1iZLmOwtqZDy +gNAB5eX6+Q6mi1NHpL1Sp3u/AJWzalhry6GfivO889cy3HBsqXwlYZ719OQIrlbnis7q8eimxa6K +a6rZ9wN6ZXYZptoWJWJSKadYR+Cs6YgDWB3EA9aSWzijgIDGW6PWte39MrfzGQ+uZrhhvbCop/Ep +vHt/BtaKmQi0PcCNfA9pE1A716JmQPq2pdUzrB3Y484D2G769VhNVvb3ty5qO6XWrvfI4dv0/jF2 +2/Jvl0VZ0NfizJb7AZi13h/dR7CKs513MrsfRUDEh6r3srl2G0yjkWQQDI/ydYAOB1bJXzYvYxh/ +slNlLY32jnDbx2udsAO8xVId6MLm+w04W8oYkrpmUXRTanqlRGnRA7lbeOueBjGsbeQyiSPWDhQK +dBQU3AP6DmuwC2gdBQI0xgq1va3rV8d6zoOrWWgF14oOXLTzNA6Mtx3J/ShYgSNqvYpkV36UxWrj +JPXe4vUms1rF1laqo45YO1AoUPYqONr1Vg5r0MtIHQEMU+YqrdbSdaqjPGfAtQw0vB3EarsFPWTt +oBmP9+ntIuq76heg470pyYGUr2nWmI+1xPP3NWxwdmByq7lD43DDzKzmGN3x7F8vIGPraom80tJ1 +qeM86/3VTLSKs1uVUBLL92fgJoGcOssF4Lygi14klUpsDqispcoVY9tg27nD6oFEgSLoW3+SM2QO +a7AiuY4CASp3lVrXtvfLYT3jwbWMtErSWc0/zPq+PwMbDT1sbhcQLVi0IjigsGbTLHDJU4/Og+jF +NuGbelWy2Mg6gWe9u6q/VYDGT6HQte09cQjPen0N2wxvggtaxWYuapsNYLd38d3aNNHkSkTs16JW +nNWXpI26aaDI2ga8N2SL1QOJAmWqgrvK5rD2ayQcBQJUziq1rm3vl8N6xoOr2Wa4gdaoGa2rqgYO +nPodbUCwlDpKluOBt02hDOtAZS8M+nnbteW8wdqBQoEi6GB/DZZgxdKCKWwoEKCxt5y19d01rGc8 +uJaJRsJIXcWUcnC/Aae+sWNhxWrMiTp1qKhVBypzYGNvZ21z01pDTrVQYHS5EANYzGeHNHJO40iA +AJW5Sqxr63urSM84cN0DdcMoY0rm/Rm0yTU3dAObea9S1F2kexcIqPxZ2lrP2vbiLIbVA9fY+duh +VBV3RDpM6e5eIKAx2HxqbqL2bhnWLQe++EDdI6uxfMgU/P2/W3EWYB6sgHV7vM6DrYzKXJvFPK3g +ylwxS5XVNFecZa50q+66aRtdCQ/DGl0JDzMXPdjKqHisVnDFU+CKs3hqe1vXr471nAdXMh3nihEX +i/5ocRYP5koq2LFVcpus4Ap2TCPwrjgLdiyHseW6SBlpQ+ggrjSLB1sRlY7Qiq34V7vCLJ5M17b3 +xuE86/nVqnhWvA9HrWErzOLBVkJlrnRxveSXytll7Bx88xVYlK9R9szedp3likqP1QFdYRYPthIq +HqsVW/EUuMIsnlrXtvfLYT3jwbWqeMIQ52DHy7QwiwdbCRWkt8xa01eKrWDf+BbWoQ== + + + MAvyIdSx5erjRIrTAV1ZFg+2AiodpxVa8W93RVk8pa5t75PDedb/qxXxrFjxW/NktCiLh1r5FAS2 +ddUEaC60AjjxrH9zQOWs5lD2tuusddYdVgfsRVk81MqneKRWaMUT4IqyeGJd294th3XLgWsV8ax4 +/8aqeoQ6kTzYyqfgFOFrhFyhFeyalhd1RVmQDXPYtGyu2J7h9E4zK8niwVY8peO0Iiv+7a4gi6fU +te19cjjP+n+NAp74/lkNfyvI4sFWOgWB1YKTUmQF+6UZ1a4gC4LVOnFtQVBmLZ9nWDvQFWTxYCud +4rGame8pcN4AT61r2/vlsJ7x4FrWI+0C3UjTgiwebOUgaIYknXVSZAWBesDYFWRBcK2bls1VQTac +zVdM1nIsHmyFUzpOK7Di3+6KsXhKXdvqbFfDedb/K1mORJrVs7ViLCNYyqYgEOS4r7siwLX5Ci3a +t2Lp6q5tWVs7w9qBVoxlBEvZFI81dSWlU5C8ktKpHdr2fjmsGx5c1XakabJqgRUrxjKCpXIK0iLX +HjQtsUIzatHohRZjof6Fbbtec9Uh7EArxTKCpWhKRzmsJn23K8TiyRxXydqv+ij5DPi/RCGWGcMU +toS7pejAVjJlLquV9bbiKrAybEK6Qiwz3u41p7xpG+Vu5AFrB3pL0YGtZIrHasVVPAWuEIun1rVt +Tgob1jMefHn+JyKVyz+aK8TiwVYyBUnt1ztIcRXsVuegFWKZ6UI2La5pbfFWajXsDWsHukIsHqw1 +UzxSK67iCXCFWDyxrm3vVkd6xoGrGYsFc1DVu2CFWDxYa6YguYucZbbiKjPduLcEB+SuZVxN27Zg +MPR7JARph7lCLB7c76F0SLW8in9/L8TiSe0te5ccyrPuX8tOLM1fsiLHqz3USqYgtXOOvuYKd4xv +hx4KsSAPtMKbawuLOWoAx7B2YC/E4qF29NYjteIqngBXiMUT69r2bjmsWw5czVAEGqqlzlkhFg+2 +kikz3iuZyliIBfvWsh6atEIsyAdQltKmbZbr4gesHegKsXiwlUzxWK24iqfAFWLx1Lq2vV8O6xkP +rmUrAuYk93y4QiwebCVTkN5VDnpacRUEznXZFmLBLqul4NpmvGw7bLB2oCvE4sFaM8UjteIqngBX +iMUT69r2bnWkZxy4hrWIQqlaoUEtxOLBVjIFSa1yP5cVV0Hgsq6+4orytSR1/VjbAhazRTAVawe6 +QiwjWEqmeKxWXMVT4AqxeGpdW99dw3rGg6tZizi6VvXVCrF4cL8qsOBNaLN5X23awhAGB1TuNKl6 +79oWdpmPWDvQFWIZwTFYW8Ua2ZwcKRCgslepHdr27hrWMx5cy2JEGmazMmzuemjLQWVCDtGKYith +KfTTCH1BxkWj5L1liDoZHcoOzDZvPTQsWaeo4tQqCP7tDNOPK52+Ze+QQzn2/VpZoERssJstimkJ +HiynRKkTZiPqlYrYh9iKA9qMyZrE6drWbMd1O9YOHFe0gaViyoiVS6uMBGgRlpHW3rJ3yqHcMOA/ +7ADfjAeBkh6r6AacA1u5lDnDDtPUzpDCKrCk8PJdDyRm5GiHGV1bDK+pHmdYO9AbcA7ctSuHtV+x +4yhwRVg8ta5t75fDesaDKxhweHxNLsfrRVg81MqlEKWzRniksAr2KsvpcVeEZc6o92hgztoGuwvU +Ye3AXoTFQ239O5z9Tkn3fleExdPq2vZedaTb/l/Nest4aXrUvUmLsHiwlUuZMxannEW5lQx37FqJ +dqecFmFBNvTwtrWNtjs5rNFvmlqExYOtXIrHaoVVPAWuCIun1rXt/XJYz3hwLRMOMNeg5SS0CIuH +ar0UpFZTVK2wCvasRg37WBEW5IIqVq5tdHXRFWmH9SIsHmrlUjxOK6zi3++KsHhaXdveKYd12/+r +GXCAOa2qIlgRFg+2cilIb02q9UphFeyb3v3mirAgH1rUsbG28Iqm56QMawe6IiwebOVSPFYrrOIp +cEVYPLWube+Xw3rGg2sZcIBZy+z0IiwjVCqmILmlBL13Y1betqS2hxZhQSjFJYaWyVJIHEoPNCXY +Qa1ciscZ/B6mrw9+D+uUura9Tw7rtvvXMN5I2GsaoBVh8WArl4Kk5qoeA72fMWNZWi0bZEVYaG8J +6rOwtvij3YKoWDvQFWEZwXL41mO1wiqeAleExVPr2vruGtYzHlzNeMNlUzRj0IqwjGDo5Sr96GX4 +JWcYgYuUn0s9v5hW6aKBUGubnc5qWPOgyKqPdgCLZeuQRrvU3hEgQOWuEju07d1SpGccuJbphgMc +VPpYCRYPBtYsVYWtXjiF/tAYBBiyHsAImoVIPZ4tx17bZqz3t26wdqArwTKC6WDHiDX27alTEMet +TKkd2vbuOqwbHlzNhkPaVs3vtRIsI1iKpSBQKyfGvjsUqyUex50ktnbetteyclg70EqwjGAumDIi +XW3M+/u1BMtIam/Z+9Qxbrr/H2fBpYIHPn2q5P0GbMVSQOGGRaylMaWsCgg3F5ezEixzCqaMurag +9IPFusHagd6Cc2ArluKxWlkVT4ErweKpdW17vxzWMx5cwYJLxUrguxIsHmzFUpDUmmdLJWM3A3Qr +5eaB3K2I96pv2+IV3lqXzLB2oCvB4sFaLcUjDZ0tnQBXgsUTGzwLtVsd6RkHrmbEpR4ddCVYPFir +pSC5pd/qwWVVsGs5teiAytu06O311hbP6mhcT5F2mCvB4sFWLMUjtbIqngBXgsUT69r2XjmsZxy4 +lgkHmNOid/WqeeyAVi+FqJWIoxZWwY6VqHVLzchI0a7v7S3x2mkNbRrKDrQSLB7YNSuH0sqq+Le7 +EiyeUNe2d8lh3XT+auZbwjxcvb7CSrB4sBVLQXJz1qiPlFXBrvVLBK0EC7JBL4h3bele6LrB2oGu +BIsHa7UUj9TKqngCXAkWT6xr27vVkZ5x4FrGG2Ce+xUPWoJlBEvsPGVnLkfbP1a7SS3a9gFE5riO +LfHkR64jRg9zUrKDrViKx2llVfzrXQkWT6lr27vksJ51/xrWG26fcmuFK8HiwVYshWhdtDi0lFXB +frV59bVWlK/9rK+1jZbu67B2oCvBMoKlWIrHamVVPAWuBIun1rX13TWsZzy4mvWWug/PlWAZwVXy +nhOeK9fbxAqfS6TONY0XFD3DSBIw1XzWFhSYdYPVA60OiwejK6AqgmIJmGo1OAqSszActa5t75fD +esaDa9lvOMRJLUurxOLBQMWqwlaVcfSFRiW3F+UjoPJmbbbpaltMSTXzTZB2mKvDMoJB07H13+ze +8bUuGwIEqLztloNr2ztrWM84cDXrDYlIWtPa6rCMYDkoS8Clx8o4Epyyi2hbHRYCJz1459vOan05 +rB1odVhGsJQRGLG2cvb+1uVtp9Ta9R45fJve/8fWYZljd7d4C86BtYLKHFHrHGqszDHaUWirxTJH +VOyHmi0wMSw7taPrMG+5ObBVUvEoteCKf3cvzeKJ7C29S8lQnnX8WmfsIl57GzR5UcuzeLAVUkFy +U9O8KCm5Qj2To/uuPAsyQQ/ku7Z4zF+1PcPaga48iwdbIRWP1UqueApceRZPrWvb++WwnvHgatZb +zM7bbOVZPNgKqRDBlosmZ6ixc6lo9Rsrz4KMSFUtZmu7oIa5bLB2oCvP4sFWS8Vj1aIrnoBensXT +2ltm5243lGcMuJbxFvOmPsr9BmqlVJBa9WtZ0RXsWJcaVqAFeVCqHhi0tst50RcPTG5NL+fFVDxS +K7viCXAlWjyxrm0+L/tyzoGrmXAR85T1CLqVaBnBUkyF6O319yU4GLtN4Eq0IB/WquVNrW1waolh +9UAr0eLBVkzFY7WyK54CV6LFU+va9n45rGc8uJYRB5hXOyllJVpGsNHQg+p60CqSj9rXbeGeRbdt +WVtcnarGGbc6yOq0eLCVVfE4rQCLf78r1uJpdW17nxzWs/5fw4oDrKBjbIu1jGC3k4W8jsVasF9a +Ps0Va0FwqJtiLTTlcN2MWD3QirV4cNfrHFYrwOIpcMVaPLWube+Xw3rGg6tZcairzOrnsGItHmxl +VYjgRRMoNRckomKpN1JYsRbaXyyB0rXV2+Ed1g50xVpGsJZFcFitAIunwBVr8dS6tr67hvWMB9ey +4kgsWaqkFmvx4NS3efQpBd1SuQAL9q1ZCqUVa6G1uuoFU65tWrWokFc0Vi0p1HMmBjDXVfFIrQCL +J8AVa/HEura+t4r0jAPXPXA3jLIWaxmhUlaFaO5+Li7AQv0zF4AVa6E5ZdqrawsGQNlg9UALkw5Q +KavikQ5T2nlBFmdD9EPhbqL+/+y963LkxrUm+gR8h/qjCHvHBo28AEhs/RIp2+NzaMth2TOKODHR +QbHZEke89LDZtrWf/qzvW5lAAiiSQHWTrGKXFBILC8j7ypXrnv2wulrHM7CVyVqyGLxPXfVJthZc +gZSEOOLi1Qhcqf5AgDguyyYlnogXM5eu8wmMQCyBMXLemdINvzUtEnfYQa05MPbg+EDB/cFB8MkI +3CV8MUYYdxuitTHdITLoGIHEDQappY7Fb8uALALJYzUhTAbMOrZmxk4EZ9ALD8kHL4LRCMOrNBMq +0AZcCirclQ7EptAMATOgXIFWfaECMvfrLXVli2xxrBf8go0pkUqYLSlFhEpz1Ougo5N8wOj0losS +KVpsTPBCXyudiYDN2eVEUqcKGLmaJvkxOtUV4n2oOGRcpJWiwuFnaDEEWxol/QqsKyRKstKXJHAx +NAdJYgDk3juOFej1BLbE0Syc0AnBuMILK2dL23HEGqkRlczUFmJkZefiBA4pZSEtXbpZUWYhJdSW ++apbBUaVu86t1bDd4Pr4TSBUNDTLOkRFGxYyWpcC0v8Y5qCaLvoxsQFjs8q3yPqy51dxbNG2ImD6 +yOq3RjNQBtB5FaXAMaooJIgobGAkrm1nhwmtnK2e+MvkLp2Hol7rW5ZdrGSV5R4s6xh5gkWr4/Vm +Mt6K+kYshKs1k5YgY2WbuJJyVqeNCacFExfNw6U04XNZey5aHTFROKagOJP0wPKzNUnG9yBJaU+2 +1qcMs63qNdsu30/ArefKqCNy1lKsCbXmqzmLswo7oa5tSgbQlpoJQqe6VOYb82/SDiMWHK9frRMe +BG1Hkr/65k/hze+v3x7dfvzws5Dzu/PbawArAN/85eb6r0Lz74TsF4WCj85/urjOXxz85T3emFJf +ff8///iHi0up5uB33U85Z373w59P/nLz9hw/BwfQvS++Xv3m31eX1/KqkG7dXvz48e78A44aOcNu +T0dfnP18cfn29vwa7+3qd3+6vuvf4X938ST7TfmVHGT/uL44E2A6z/IP/3l6+VG//PfDH16fXvE7 +dIK92tZx/Dp7HL++wDhkP88eyb8u3t79PHs08eutHtHP5xc//Xw3e0jp82cf082P/+f87O7o5uP1 +W+nf0c0je6Mf4Dvuf/n07sPsUQ7KPPtQv/nTm28u3/98+sbMHePF24w3vmdM+OY/Zw== + + + 9HhbyOTdx9sfPwqHf3Y+dxa06MwlTu08N9EUYX3ueH48/XD+h9vz//tRJmE+CR2VevYRXt98f3dx +d/YIlexH+YFf//3i8nz+/hyUefYR2rlDu/549d3Z3ek/F4wsL/LsA8OWmzu22/MPHy/nnxvp8zkU +6J6umwe6vp76ZYfA+d9zcvJwZx+Y92dekIvructx8/789vTu5nb2gvQFnh3Nvr/5eHt2/sfb0/c/ +X5zNPuIemYr8pLve8r1zcf0ICRkMxr7grjm+uXp/8+Hibs6meYoOkA97tO3ffXv+bvX1XtrbjnHs +pb3tHdFe2lszyi2R9vyXLO29uz0VtvfyLzcXH16ZvDdbiN+Le9sp7s3el3txby/u7cW9yaj24t5e +3PtixL3CvhaBb8lItlzk869O5Fswol0R+UQOOjr/5/nl9z+fvr3515dt+9Ijk2Lhazkwf7z8+Ai3 +8hmYzW2VDD7cvf32/J8Xp+jQAqknL/RiPMEfTz9++HBxen2kC7grvPTstXk7/xh++xLn8PyBzD+F +377EMbyEAmw7Nbt59+7D+d3Rc9C0F9r233GEO7ThL8G3wEvw7Oby5va//vWzijEz6fOvl/NVifHr +/Qb6hLF8eH9+9t3HR/bD7nEEs317Pny8fXd6dv792ekSxBsUen6pY/bgZHE/Xp7eHt9cf7g7vZ6/ +btOCL2BNWzrK3//7/c31+Qaj7AvukmxSVGU5e462XMVhygVj2W4lR2GXjOW/Z4/lv1+QB/nrzcX1 +3UlUX7yEPvL8+7hVTyJzsUP80Os0JizkG7adDdpI0bPYmrDda7RrktESI8m2EIPT24u7n6/O7+Yb +4HaJKMw+9n55RJmSDQefbvFAHuHF84GYbRYVfnHzB+K2eiDzqfIvL0GUX6UVfjE3sO1H5+XF3V9P +Lx6TJb/ws3N3ZOXlauLFO+6FFvLP57c/nWMmd4gJWrq5XuNaPF0H9i5DGyvUvnol6rQFXinbrUwz +Zu8xtP0eQ19WkMjxzc3l0e35+X/Ptmq+Rs+otxeXp/PturukxDCHs+PKb0/fXnycj7rp893Qbm63 +xDl/IG/nD+TtNg9k10TMP9/cvv/55vLmp193SDTZk7UdImuvhpjNj2DZcmL2asPYdpKYFa/HZfXV +7PRl4RTbvNVnj2TX9vrOedy+3pj92SzLPmb/vjG+bMz+bD/cXYvZX0DIt/1Imr3Jtv5Imi/h7NiR +tJNZFB7xKMnI2jLn+xfyuv8id/zWO2r8OBvLtp56zR7JrgTh/G22OfX459Pr6/PL788vz8+W6NOm +BZ/fIjTb0rrpIKcFX+wc+vbiw/vL07Pzq/Pruz+fvt+hw+jqVKqabZjcCelolf5dTX6awc+5o+av ++fx3+nyLKeXWn8TLcg1u8+k1eyS7xnsfI4z5z4l87Aq9W4BZ275HZusQtn6PzB7JrnB48yORnyfx +yrbsvneL/IPeXVxeLvF/utzmlX53e3M1fzD8+Pm1ko8wOZlh7DGP8dwy9vFFYq5mj+VH3Mk1Xzeu +Xz+/Uf/yX6e/zh6TUL6709tFlFK/315N+N3NfMnj5gUGcntOEXDucE7fvr24u/jnfHGqL/AC9pjr ++eM6O/t49fFxb6F8ZFmRF4houj4/nR3+cnZ6efbnm7fzx9YXeP7gs9m8RbZ6qfm/cAhzF3BY6oVE +ktPri6vTF0sNu6t56Iqwd4bZMsnu7NU4w8wfya5pP/bOMNui7t1fWDjRKeyaN8z8nGa75g6zgJRv ++6H0atxh5o9k1w6lnXSHmc1/7oY7zBe547feHebs1bjDzB/JrhhL9u4we3eYbTmMvgB3GPOluMMs +oPnbfhK/GneY+SPZNd57N91hFmDWtu+RV+MOM38ku8LhbZs7zFbbf3bHm2fBlltKPF5oDXcxa+AC +P8D9KjzZKjxdzo0dWISn68ALNb77SRu/+dObb5mz580yzdcshmh3jqjXm7dovhpwR7IWPU8C8Jei +pkvy5Owp2sMUrd5TtNdI0WYv656i7SnaK6Fov78VwJfNop1jCl4jPdtzaHt69mXSsy+aQXu19GzP +n+3p2ZdGz3KjzptlVvhXRtZmD/4LsuHtt82cbdN8ydtm9uD32+YL3zZf1m1Bf7349/nlXy9Pf32z +LNhxGx12qnJVzfae1Jn/2wIHyqzELlG+2/Orm8fSG+xYrpf5OUX2+VH2+VE+E9KtzNe2XJlK/l+u +5L+v5bf8/VperF6by/bF9dvzdxfXF/MNXLfn789P775dsN2yEs8+vn2OGB3XjuWI+fAeWWLmjm6X +csTM5Ea+tAQx28JDvcILCn9cctn4lnvqLxnLrvjq7xUW20sOHtvbu2lXWkQRtpy6bWhS2vrw+Zur +9zcfhC3/7uMjJGyXA/jiGHeIIJzeXtz9fHV+Nx/XdokwzNap/fKIcSobDj7d4oE8ogzNB2JeQhkx +eyCPOD/lA3FbPZD5pPmXXaHMu3GILpR6dukIfbVZET/LGbo7Jo6N1nRnHIj2AYB7c/LumZOXpSnc +Rq3S3py8blb25uS9OfkZx/NazckkLjAo2/LrRYRmb0Lem5D3JuT9NSOTke1NyGu6uz0q4r0JeW9C +3puQP792YkdNyK/J2Pr24t27j/NvM9l2UrBwOLtCDWanp/vw8fadcLbfL0vzPyi0vXYknf5lYxuU +efah/Xp+eXnzr7nju7z46ec7eV+cIQ/u7CGOi23vAsbdeXxzLaL79fx9Nym3V7q9qNJtf8ft46PZ +K92egpR+/dPt+fn118KBnX99cf324qebr/95cXN5fvf17fnbr29uT69/mr3V9tq4vTZur43ba+PW +jGw+H7ZXyb0MV2XCbKvL6X9fXH28e+Tqx3xJ0vfPjnj17DGdX8rDIpVPVuLF9D3fXpB/P8H+eimP +mG9VljiJe3yHUP41qZ0+vD8/k4Pr9jl84Z9dOnrVyprZJCot8WJpf1pwm9cwdvb3/34vvN4Go+wL +vgDj/Yg29wlUU3u9zV5vs9fbfEF6m6ilUb1NVOJQfbPX2+z1Nnu9zV5vs9fb7PU2O663uYwKjVfh +QrFXQj29Eur7KPztoBbqdebP2EAfte0qtlcZAfycesMXok/7HBrbRhxeTQ6N+RkbtjyHxvwV2fIc +GvMHsuU5NJ7nHpDt9ibe/uPz8uLur6cXj1kp9mfn/uzcn50bD2TLz859/qltOzuXUuVtPzY3EqZ3 +5ejc5536tLnflmN38Xruc04t6cALNb7PObVbOae+//n07c2/nuL+ot2hRF94doFd8eucnRRtH5H/ +7Fto9sWabx8hp7lb279fAMnmD+TX+QP5dcspwLZTs5t37z6c32FL3J6/XUSnd00G+I4j/TIEgM1X +9TVKAtuyKq/7PvG9aLbLollhqq/mouR8PuMl2IwlI5nPaLwEn2F8OXsk/7p4u8CdMH79/CNy80f0 +8/njnofZkNLnz89BfYlKjSfIor073NVeqbETSo16r9TYWlY4vBalxvyB7JUaOyD+7pUa23vs7pUa +20jJ90qNvVJjW5UaX5hodne6wNHyNQpm725Pz+5OL/9yczHfsVkLz1zj1NJz+2cezs7Z8uPph/M/ +3J7/34/n12fzOc5RqReISf/+7uLu7BEFVi6x4eu/X1wuyJUwKPP8mq/ZPrbXH6++Eyz+54Kh5UWe +fWRnT+dl9twjWabV2uI45/kjeUKBZ1tOhdeX7GjBefDu9uZq/nD48bMP5zWlbnqtqY7Kw9m3ttzd +zOenbl5gKPvcRYPB7XMX7XMXPbFqeb5M8qWlLnoSpdHfP97++PFSJnuX9IivM/fKApFiy4Wj50m5 +8kJ63iXxYXtV61r+8KvX4T02fxxb7jtWvjrfsQUj2vuOrRnlixsoer7kzSPh96/bTHGX82evyEhR +7q0UN7ttpZjtzbRrRgpsuS1Qie/Fvdct7i1Bs73Atxf49gLfXuDbC3x7ge/1C3yzRYPXKPC9Xr+0 +2Tkd9hLfdkp8sxdwL/HtJb69xPdJaLaX+PYS3w5LfIV5LTLfkpFsudRXvTqpb8GI9lLfmlG+uNT3 +v25u3v50ezr/vH+NIt+rvDNiUYz4lodIvMaMF7OFuX3Gi2cnCPs0ng8NZJ/x4hM5jJQH4lXQ5n3+ +jq0lY+8uhbvTS4j/68fL07Nfvl4p6Ob96dnF3a//tUAn/OHu18v5Ou749fO7cC+5cHnbd9aiweza +ZvoDEHGH9tLr1Igu2y87ca5ulnNo22/9+cBUjsevibx9OYzDLt4G+JoY7qXXZ275xlk4nF1RiMz2 +Ovnw8fbd6dn592enSzjSQaHn15QvW61lYxuUefah/evnBdH5l9Dqy/tiBueRjXBcbHvXL27O45vr +D3enj12lmGtVxuV2SYFu3OzNe/rfF1cfF5i2uu+ffcmJc68my1A9O6fV+aU8LFI2ZyVejMf69oL7 +5iQaGV/Ca0D6wD18EonVntvblVtf9yzSLrFIaYEXn7HTgi/gJ790lL//9/ub6/MNRtkX/EJYwj2/ +9PL80p5d2rNLc/vwfSRUO8gvvU5rwAac07Yzg8/jJr3967RXmT9DOtHbi7ufr84X5HXfJeIw+0D8 +5RGfgmw4+HR75YxfHvkyH4jZ6hV5JINPPhC31QOZT5l/eQnC/CodiZdaz7b++Ly8uPvr6cVjEvX+ +7Nyfnfuzc+OBbPnZOZ8J2PKzc/5AtvzsXEqVt/3Y3EiY3h+dr+Do3B099P6Wxm3khZ6cEu7AWjxd +B3YIEV5rKqJ98tnRKHcvFdHrvSJvI4vBdrOif1+cw3rX+LadTLJ0dSpVzU4vsQuE3azK+O+6Xx1k +7pD5az7ZSJ/vwP7adorxRyn64XHnsd0lGIyk+nPagLtCMV7h2fSs8V/bmn1hn+Lj+ROkvZocH8Vs +YWrbk3w8iyLqmcf03RcT5bpz6TFepxPfYtbt9e6g7benwN6Akf39FSdA3kV3hE3WZdv3UT6m2WGN +u8Jqm8P5sVF7Znt/Jn2GvfTDu/PbP1zcboOKZFvW+e70x/lrvAsKTbuabefg2P/nMo3loMzLpeL6 +eH32tx2iJq8Oyw6bVbn6MvDsj3s8e0E8M18KOTt6KRcTCjuIuv777en1h3czbpHYHnx/nfqQTVi1 +bWc/N4wz2QVtiA5tS/jqvT4krgw95765vNyCNdmWKdkMWfe+mks68EKNL7r+6atv/mTKN7+/fttd +AwVQBcibv9xc/1WqYJqSQsFH5z9dXOcvDv7ynnV4ffX9r1c/3lwe/Obo9O1P5yuzKlZ/vbj+5bcH +H+XfcvXdQe9Q88Ov8vD/yI//I6B/rfzqz6v/73+Xq7cC/eFvB+VhWZZtWNnqsKlWVweFOSy9qasI +KKy8r0y9sv6wqlwDQOvqVt67Q9fWzersoHCHwXi7svbQlSjjD2tvpUpzaJsgRarD2hl5IYDSeI8i +1WGwwcs35WFbG/mmlmarqiHAVXi2TR3a9CxFmkMTqtZ2X4RD64Nnrc67elW0KFIaAA== + + + GhfYM1PiowZdM8ZKM0b6VEkXBODb1gtABujbpgOgkIyjCc3gm9pjyAJwlSUgNE2tI3aGhZxMV+nZ +uEwnntvg2H9XGlkf4w8tJtqEw1DpiATkTWtWpjmsDCZBALWr6pWpD431aKhCV6QQ/rYtC+GdDFe/ +RcUobQnwJqC7aKFqV2xRCksh9sJWK+2VFNJuegAaDL/gUKxdcWg6eQJq2oqg0jaG39hKhi2zWttW +K3FNs+LEtxwS1lzWpDls26pGtaV8IiOqD+uGuEEccH4FnLC1T2WaJqyINi71pfEr4JUrUQi4BgTC +ypeOhYiPsgSCn1jsAvjqZdBA39J0zyU/1t9F/zKWLvrisYkibyP2o+g7Erta9H2N4yGSC7rH2eag +i3zUmJain5c4dUU+d3F6i25+4wIU+QpwlYp8meJSFv1axtUuuuVOKFFkOJHwpugRJ6JW0eMW8a+N +P9oQsbZ23sTPfaoA88QqMRlsBvPEhnWZ2RlrUvdC7HBoEjZW/cbSgTobtyN3X5FvP27QYrKLi3wb +c6tX+VeRGhQdOeDsm7gfIs0gXak8YUpYlPIE9nxAnIqeOiX61X2TKFzRkTiSwTrtAaWDwCPjI2LJ +uhDVZOriDGBVgJC+2wVBUUXQ1rIDQGSugbQvqKx4X60SWY+PZwdE/bZNAFTgMeOpApJ1bo2uFZJ1 +Vhm7gs46V/W9xYhcMxiRDFt2iuuHjYlp+I1ODOauBQp3c4fpDa6fXlkAIYc2LYAnfQkJT1xAM1jK +ynRLKUQKq92k1QbJlCFWwLIEkEIyjsDZ7r+pK9NG1PKNUr82JPxDGdL1usdRorHvN1mi63GPsR3S +dT8gzbWrTb/DsJ1C2e0r4J3uJpc2n1uN9melJ0dl8k2snYgbXY9c6aRNtMDoCYVNx5HVOEGGVKXi +N7YKJtIdPae5Gbg9qsBCIGB1omAlz7WGS680Ts92rHtP2Ikl2JQkljI0xaOI5M445SESjleGhYiP +kTC39WpIuptVRtZziu8igxIxWyizEnSvZ0bjdeAORImtS8HEn7B7Qq4HR5M8c3obV8fTy3OQQsZr +Hm++0cNelo8IWnmjbQgaBj0iw0rn2usRWjer6Sk7PojHJ/X0MB+f92OGINHsnmSP2Yox3zFlTcbc +y4i7UTLdZPzPmEUa81BTNmvMiSlxriOrVuucthEX0SfS5aaN/B54DBPqjmEEWQlY/kRVSHdM9550 +ydqO4STpqnKeNFG3RNwS+UvUL1HInkAmIppoaKKxQxKsT8cjTvvk4OjHg+TpfvSzCCK/+cc1hIa3 +q59uT99enItUYnz7W6lG1sYE/G0Fz5187g5944ABmeO8WR39dOCrw7IWEgRAkR6KYGpZYGzsIKsu +Syz04Ojq4J00f3Qk4sJ/fETfmtIIhSoPQ7BO5gkQWQ6jw8Aiy6tKXnr0xFS1LFWJ076RjvxwGkfX +KCMGQULm2QpaugiQdrkcOHAcBQrBd2P1wLHyS2bIHdZl1erpb2owhPFoqaQxqaQOQc+RprGYUZnI +0BjlKBojZ20Nghb0JKmDr/Wwcf3zsRw21gHNOlA4dKZ1egQLbwjEczI4bVlwvpVCgpvO8iSUYchE +4bRxJRh07HfQIBw2rn8+5lnjap9/UdWVHjWmBXmXCQD+A1CGmmXcYWX13BOuoFaaUOv4bFlzG7bk +DLFTwXEdY28b8kKymeUIU7JQ4kyT3V6i+0IHpO81zxqLhTw+SK8K/divtLAeLQY7mw3UylTKfkHv +2AlwtexWRTmL3SzY75KbvwzkMjE2NCQQnq+GDEvLL4Ss61FTW9ZRlaD3mPXKOm2nBaMSsIEDd7RH +bThpRN7jjm4aVEKUcFhVIolQNDlqhJiUlEUFgyocNYJTnseBYBnl18aX2lDExAK4WdfcmR4tA3VN +aKoEKPFx/Nm9YmGz6sqifpxPEa05dlPLl10PiMhm1XWReLzKBoGByiJk42yFXmAeBPN1qrxfZTPF +2STprIW1XMXZ5mT7tlsOroZrdZoSYgkR4NQmvOKKJrTqFz3DKsULYo5XLJMDgTiFI6THLb5pVx36 +EUGtopirOxxmW75StCeaszferOI26DqL7lu/yvYJ9pIjvpm25lZyTp/TZvRtWPV7Ebu17ADYzabm +QULykSa03++gCVQ+RJIAomFb9lCQSg8bOW1WPVkh5dEDkxCQJkHwVaJMWGVQmZ54gbgl2pYIX6R7 +CYd6ypioZ0LZjriStna0l0/HBwMErhS/u9LkZaUBK+urSIsGikEXmriRdJOzi9xsUSETR1BgkF6P +YA4SQpB1bT8vUVCqs4kqOJfe9t+MJ1tJQWOz9SjGS1aMlrSYrHkxQopijDTFFK+KEeYVY8wspshb +jPG7GG8ApbvWZHukGG+jYrzPiulWLMa7tRhv52Kw460WGtIEfgJKTJrhTTrllKzUJFyUw9qmXiUK +XJAyuZ4yFRPapcd001O3Iid/ni1nFFIJcJET0UpZh0RkyxCl10SAi5w6x7exeNGVj00UeRuxH0Xf +kdjVou+rDqfIxxOHXORj5qwU/bTEqSvyuYvzW/QTnJ+BaQn6Y9K1cfqys9RU/ZnfHbcdSmRncoc3 +RY84EbWKHrci/hU5AsrU8ZTl51EzZGSvRlSsovaoLgfchnbGm2H3qoxn6bZVke+ruPeKfPM5FyGD +DVxkOzju8f4bUIHGRzYMC59IRcardfSkY+g6klNM6FLGGHbEq/8q0beOvySCNFFVkaggsCiUGaeq +mNZxsUBG10KQ7+m5Yqw1PTusaO1NZJdH7PTxwR9EQvg257JrKOulBWEZaj5Ks41xSU0SKuJz3SZN +rYUUSaItQpSLsFI17yJNRAZ4NDsRQrKN48BmX2E1qlbH2YyXsOmIsOJg9k1jrZKHOkSE1w2j+yTR +VEghbMzXmHiBlE2j2u5SlYAyL1S48Uddx90g/JCNnwcTK6i0gmAjx16ZkBqOu09wWDWvmBPV6zXE +7gYayqT5rXyrc9rYJm5aQRCrM++px6iUd8W6BN8DEgHD7/5dLN6Xjm3kTcSO9P2IXe16GoeTjyaO +uRtympZuVtLc5VOHd6oTiPOL0hUPw7gEruPhu3WKq8nFtLr5ud5jlMgwImJN+iLh1QT5Mtwjhjau +/ybhcELhhOcZmmNSq8B6dS9g2kWAXtk645fIdvcvxoVQLyTevl5pOZioJCip3GyqvvOqhLBZ31Xh +bxQiRHU0/Mn8jCZwMMEmrvJgDcbLNF7H6VKPsWGMLlOMGuEccTJ0KDnFWk6fDDoh9gjxsz0x3i+p +ZLejWHkd8m0Xm++25nDzNqvhBrfanyERmNAJzk5T58QkTaTuHmdXaaY7osT6/YBycb3ioa8LhvV0 +riOAqpVuMhoJjKht/wUwpqky4tvpMDqkItbxZImghJWJpie8zeh+Qu3ucEhoX+QbouCOGDyeHLw7 ++I9/HPyDyqof3h7Uq9/8dvXD/5oCvnpjVt+8lz+lHFRfvelW+ap/GC/zYJUzFDpDkRGWjXBwhKQs +MULkMaKPtwLKTLbLeDuNNhzLoAtBexRq9pAacHS4mdAMlBjTlXtoET7N6dSUiI0JHUuMOlCM+jch +3Cw0Je+TA2DNdE2Pkslhs25lpqfW5FhbgwFrDsjxCZpwTD+fHL7T83l8imvB6Wk/YQjGXEPq4Ii7 +mHIgEz4lTf+Yn5nyPGPOSEvq6hbd8qblL9L6T7g+lptyhznzONjy3EwZeZjQjgl9QQn0o5OmpB/o +qIn9rOsptYzbb0RTJ1R3TJlZbDzLk4UYHwIc0vigGB8k47MmEpXRiTQ+snIcvIYe/5trxH4JRYQn +jlBEuONQhoE2T+SUxsuJfqUis0PnD6ugBvwWfgPwe6gdTBsAOOBEJWTeRCu6yGIwl9SHjUi1gd9I +kQDlQ6U7y5S+EnG+Lb2L3gjGllBztb5yKroZmNZaqBdLFTUNpCg5iiCBRPGQRhPVjImMI7Kwh1jS +QGKlJkDFRgwrBKcGnRKWA5mpqsQCwwBVWfoDubqFlrk99IbPrYFhUA4/GWCoiLPYVQafqHq+oozM +Ms4q6TNNRf+KNAUF5qCC/k+mABNZpFngJNQUzOMswJBFUU7GWFlVUWFIRIYKGxCASjVLHNCxlgnK +1dqyYufUvEDrloMWqIKES7a3oUlIxOlWERFSn1UFqX7RwuoNKdtHLZHxZa2mM2raKJ4HzAGKOvXH +aLkpUD08INggtxt7QJle+iSyML4xrVW7tHeYfeE0XKnirOC3qkErH90YRIh11AE1VpGGXGcrfETV +aCVlWzW0ukWyIQ3VwP9GVhcTCIBJylCqBBKATgCtqhAiSPauTd9YeNIAo8u6jihuHd0NanrEcBdg +Y8lYk9VfcUO2jon00EaLvqB2FUVOaQcI6tCykvCmhodORtrcYduouIPvTE1qlb5DXT5qroh6Rd6g +K61620ivfKvsGcV1dJtzlvoNTBVhyOZjKyYTABmmNXU/RcWaeSxgoC1j5fqVrIelVgHrwb3ZcjfE +fV1Gz7IS5k1d6khKhEJWce1LF/G8dZFcgyKpPKdni5RyydFGW6d2WxG9GWBiMUTXOkRkd8pC2DZa +lVQ5hB9euwhsDyZ+Hf2Jsr3jfWpFmwWlQjHpShu7Vrc6au+DQkxoo4GwipuulOM+ydEKk0WFOZVj +pDIcFEH1gpF0kmpY52NzsE515HVAexL9JY0uciIdCXnRUfJE64uO2KcDoUgngnqA0VuKuJhw2FM5 +5BLxBg4LASmj3oLvs9exBlRQR6epwblzBrvzOmNz81s0Y0AYLMzHdXNoobMz9GVxU2MzvApqnowe +Iguc4mpBm1YR35ugpmdpX/bVSk5ld2hk8/1wBQnUUSvk5cQNWPp1JZsWfg7NCm5UgruyM4/ONm30 +aG6jXnacl4UOsg+ovZM2o6H8H3K+/+6b27uBzzikHfUghnvv6gw++x+v364+/Hz6/nx1Rcfo/5Sv +vpb/DuzQJ3ckPa1hEZTFXMwkgEtcyiYoG7yUUVBOdjGrQBlqMbMgpTZhF6TYBgwDBdDFLEMstZBp +kB4uZxuk0CaMA4stZh24YMuZh6/ebMQ+fPVmIwYCcvZyFkKGtiETIci/KRtBOX8TRkIKbsZKUE+w +ETOBPb4RO4GCGzAUWmwDlgIFN2IqUHAjtiLqDjZgLLTJ5ayFltuEudADZgl7oXqb5QwGxOBPPSqj +GL2S2aqjunFtlfy4TWdoF2KjwTH3hsvIlK6+uz29/ul8ecCMHEiC8I4+DVaoK2NmcC5CT+fVEeqE +xktfV/SskpVrCQqYTHrZ8O8JDVZ8m74+0cAG7PVU54ka/mGC1pZZl63lCKqRD6B7z6gE7VqqplSn +91RPaq3ImkudKfJexddF3vlYTde/kzQTiuDs4IlMUde1k4PUna6DJwfDakp0YdgaKtaupC4BMO34 +mvGtmYZ8mtLr7G2so68idqFvJnaBf6o26612KR9SPzFpXvppKTovyn52Jog0yyXUBg== + + + uISWrfAYcNK0DZ3pyxV2oYW2dsymuxauuwoo0gN45BaE0cEnFD7LU49QObeFEyphuQeDVgphMPAa +ltaNsGx4FXwDzq6ED18IdBoVRlFGDodQYgJMy7JDhFTpac2DoASWqXOBngU8vjBvwiqoIpMk9+RA ++hjgeA10oRcsF8DQBA+Gno60UOeRjAmtD3JOKaghcwLyDx0nV1I4KD1p+OOEypqmVoVgI4eDgkJN +dWyslDghTIWyfWyZiMPeFKl/xC49JuIgTg44LsuDXUfKjzj6Is0HMZRzVGav+7epjkEVbKdrJvWl +74pOTLXq+8tR2bDKBhXnJRs5p2XFP6HK5jDNUj/RaZL6xdA5yhaMvWLbsaP9mtJ5xZMJj+uextsj +R7lK83JyUAxeR4hOB6vwlW6mrhlIDwIZdIWoU0y6W0yHVEzH3aFMjzpFettPYJHq6Ge5SLjTL4Vi +siBpv17FZE2L6boXU+Qoctwp1uBWsQYFiymiFmvQuViD9cWazVGs2UPFmq1WDHdk7N5g43azn23v +Jl/IokeqYkoqioRXGUEp1tCdjC6dJK8aATU4xz0chir9vGrbOh58UWQWSRSeCtrJmmNu1GqhU61z +mH7oHEZLjn6vU916MpqxWl0RNtY1D1h/tPNd/ir2I6shNdS3k3qR90Zf5n2ONaROnfQzAB+oknMo +W1HP8u5FnJm8tM7LpIVBL5QS4Z1t+56mtvvRTIdsuwN8PE9rpnM66WuWZrCAts1GU/STsQYbFFP6 +vxuaxptkFp8MVWCTCaG9azhrVIWMppYy+nD+BTRZpK/eTJcSHeN4hOWfYoAKgCNMUUvkuLk1eKdG +4yF6QrKYYLEKU5P5SFshe10M309xIGuzyBtdgwn9OIrhQKbbPpucYjh3RZy8ta/XYFa3VBkC9ks6 +6N26cawd8drJ6ebuOpOoqjC1TrpDKGVKCjNtDA5AUG+bDgMGKTuRWE1pI42nc2iFuMBS6ZhRw668 +MdZ08o3hYacWVT0wGmsRNK66uBN4bKoO0AKVG5yDcFOlLtFTD9MpLBooaDzDJVsEysaARFpvy+i2 +Gijcds6YiCbFD7oBsX8FOgglmvL76F/Rd9AgbArCOpScNYU5mJ41Pt+qZov8kxrd8QPRGScH6SUt +1Qj0IlEpawZix0rBINXU6HVTc3KQuqMT2KBfmFVqXNM0g0mqvG010IeLIdQPqvmowOaSKWHCWqrQ +hg+oneo/gMLVtWWd11OkRcyaK9b0qpulrPPdNGVjLNZMRTdR2Yx1r7WAS7Dx/GtzYDwyPBqsZj1E +yiLNX4a7RY68bXKy7nG82wInD1tIbHDOB1pIjDAhUsTQ4dlMRS+4KRvoBB006NAcezhZM7wVrAyI +gghijXRG5iOIrKh+7D9c4WCTztYs0ahefU3R1hy2UNgG22L3C0N0dLZxq0dzW5UC9IYOtqw0YDQ3 +kjxm5OgpTdSBDWmNku4RtVGDxojeqHFkRHG0+IjmADihOgLchO6QTC+lPHQjGdMe0vYx9RHgFP8J +HFMgGg3GNIja/fHW4xE0pkNfvVlDiaCvn+x6aOMn1Ai69gk9gtfQhCLp+djRJGq+J1SJ/kkTukRl +94QyceHW9HIdddKDfEyfVMM8naZ1NEqVymMqpdDpOq2jVBmeZrQqQ+mMWmXYXwzRf0qx8s00OeLb +z680FTxd/fH2/Pz6k5IMhZRlSJgU30EQ7h8YHOQP64qDL51nggDGfmqSoTY4jSAvo6FRSBG9wl0I +6tNXw/ICr1inhUCfSquh/QHZCUTyq+oYjFlnWYb4qEmGamRaie9lCxuvzpzChXGnWmcMN7lQBJdy +DBkNZLdqtDD4SJ22rR/mGCLgLAZGjL6pW8vwNFIaWjBi+LkXbI4ZVELsfGhqTRVh6NkJo2OrMT9O +/mF8mnqwAVTRqCcEvyo1yVCDxBjIBhCcbgFfwzKJv8GlJENBfZ71HGBpTRVQuRCzXTTqMOucTY5m +rirpw2cYb6T9bFbab5oKBKOZDACh7NHjoWWHYXKMeTeQNQUWJ2PUMTRUDE+zDp6YmvDGYdGE/tat +V8tMgJWoRhhs9FM0CGcmRnSJidBvIk106PTIBwC0aqwa8DwSDgDzrAsxx1ANb1Egp42xOKGh7aMs +g+ueU46h0KhtJb6MpYu+eGyiyNuI/Sj6jmhPi76rcTRE8Kq0ca455CIfM2el6KclTl2Rz12c36Kf +4LgCRbYEXKUiX6a4kkW3lHGti26xE0IUGUYkrCl6tImIVfSYFbFPfwQbcbapTMxIFKKjZ+WaEBHR +JlTHYa0NJ1w3ZUwIECMD0V+3ygbAbWXjMOO+4t7TvAPd5pPtqU75wz1c5JuYG33wFWlBtIoxvo0E +w6bVqHzMMGS8014JWfGrSHaiKa/OEwwlwpQIV/oiUbaiI23ADtc2EV8qq+mFGuNSKp3QKpbVMTrP +I8EScdF4E7GzbmN6IfjfRByuNP1KywxNkWDn+YVCTDAkUx9MB0Edmhso1oGGGCDbN0SanvLvoDfo +L4lU7C8xvk17gDQdA7cxhRkHXpPdqtPM9PmF4tRhbjXJDwGY/LrtJt+SsviU3IG2cq5i060iFbou +pmqosW/z3EK1bmQN9GgH39Rt8neuvFOql6ZeMU93U5tRSiCwW+Wk1OnmJJIbTeYi9DwMSHJT8ZtE +tLGR2sGO0n2Udl08DPqNqQHNjff57tU+pFPGhHjsVGlTaeqWjlI40tkhNdEMecRO0ptV2gS6LWh8 +x0o3aAZ0K2iAeSATRtLWNHqe1/F8b1OZALQgjTR6SDLHhVLRdpVwTEktOXfFQx/psXpyZxQ7rDJq +nhF6I2RESXlQnLZNZEuConQZdNy+pKu8tF83HVPCDjqN/4LHuo7B6PSGWvYYR+k5u8yryGmo4lR5 +5sFxJcmbzqUejSWntgWJ4UxrMsLR6To6f8fn8/QIH5/yYzZgyClYxcYBMzHmNqYMyZhnGTM1U74n +kedEnRNxTlR3yl6NObAxi6bY5yI6Wk0uZLzmgCJRoB3YJ8awSy4USQpJThniMymS8p0kSCRaMaGB +0uFE1iJVS2QvUb1EGXvCmIhnop2JuI6ob3w8HjPYcyzJbVB1hrcNPUAqQbqaqYPgx9Wuyy5kkRgr +WpLTQxFMkLWGdBmsaw5tENo7sSULWxlaZg6SvxXzV8hMqcUYYiR+CA77BuZlWRG47pTwv5RTcZJd +iBLE2nx2mhOASKLZmvyqSDnGjpnPzrUpuWCoNZ9d1eWzczGfXTwqDGPtNJ9dDP9H0H2dJUVo3TDH +EJ+PNaFdSv3nmGPIqgRpmbsqxIx2Xd5Bp3GAGgnD/FcuJrRL+euGKYbwfBzT2bn8izybXR2z2flV +53h2HNPZ6ZAbpsCLmb5iPjtNBtZljIwRpnk2uyZms7OrmABynMyu1QRDhgkvNfVYs0plYzK7NuY1 +W8W0qDHaojQpc6pNucbcKuay63KnxSSRmv+G2dU6jyzLTHbxtLFNyh4WYqJHF4NTra/rLPKYmexc +zGTXxkx2JmayCyaWYVpATRUXtC+tiZnsfBhlsuO8KSYyzkqdVYep7Gyfyu54kMqutF2y3a5knv9U +K2cuu3rVtR+TlnUdZC47u8rGwFx2YdWPsktlF+OvGzDYTLumUb95KrumHeWy86NcdjG9EFeMSLbq +EIoY5nXF61W34Bk6eRNiGrtKscuHURq7VhFRcSmiXcKkLIud6XLYHQ9z2JVhlVCfvWzamMQujaPR +DVV7Dc4mXdAkdu0q24ExWDtuwEEKu5jBrlqlHZymst/jKbVoIgNMYVellMZVHz/ekZIs0xAhJ8xr +x3RQEUICVaZMym1Hw3oSlshconKJDiYymEhlTykTNU3EdF1iO0031GgeALwfpox2zTBldJMy59WV +hudnfWjqbGfFTmq2VI0NjuPQlKqajodD1aSr3nRzkecbihPI5K0cXfpmvAgxy2XI1qkYL+Uob3QS +BzNcKEbIUoyRKZKtNsO3YoySxRhnizFSF2OsL0a7opjum2K8tYrR1ivGW7MY791iuLWL6d4vBuSh +0VMpS4XZpYtWEgNPkeOULtqQCtUpMBjOrZFKFVM6pod105O6YkwLB+miYdk4Tumie4pajChukRHj +YkyoiwyTU/E8XXRqI+Fy35FBuugq9OMp8gHFMRfZoDkrRT8tceqKfO7i/Bb9BA/Ow8b161TkC5Wf +q1V/8BfdYkd06M/mYnR8rzqUKnqcGqaKbiOy1s5H0dRWsTjdvZkpuoltZImidVdErUDWs8aHjGsp +EvEu8t0Ud1yRbznt03jbFtm+jTu7/ybu/Y4T6whExq2Ns0SHVUdoigk1yljDjmT1XyWq1nGYHenL +2FBNFF33rGpMFJ1ygrMVJopO+B8USRhC7nq+OCaK9qtiRMyLRM33mYb2mYb2mYb2mYb2mYbsPtPQ +PtPQGEn3mYb2mYb2mYb2mYa2JdMQQiSTQ+/ApbeCnQUMfm0aZDe46mEI+FQtEgM+KY/AZKJRFiJa +UaCxlNnU+i8YpMJuCFYV20x4Cykk2BAt7nr3V1s5k/xBFPPkFGFa3d6BGylmmV4e5wpvuQmw+Heu +GjWD8ZlmoNaFNNbGtM8poFtvA0B4rusuQrJMlw8TUlnHSJAyro2hiIyIFGtU00K5Xb0UaMR0asbA ++sfINFmJ5KwQg819n/bEp1T2VewTPuf5iXCWlDy/Uh+xcEi/OHXiiWkFWqkrKn1MRHFGB1NsreLs +cJXUR8FEI3cVyhhw7eI1BVAlEKJB3AmizkltGRPk6lftYRvtCsnAEA7bpo1xyqG10Q+qNS7ST88N +KGPS+CIsax288sZ1jIwmhA5XnMLsG5mbmEJXdz0SM8SKTaUZqmARLGNWCs/rkBy2TbTJV/QzkSnx +6iEBm56uGyO01cTT8KaJUkPj1V2VJpiSl8DUpofAU0Gka6JjBFmqW2xfkQNO1akxRwtekqNjhzwM +vb7u+1wxztzmA6tj2HY3+Dq5R6b5gcbHxAsr4hQ21La7HhRAO+LEc7yM4YypGNKQShLOnkwCF7Ql +rHtJdtD72vUA2lWbdKtZ+iYmJKjIxcg0VOUADQVkaSsByJBpcSb6GjGNMQBpg0JTpXp4a0NqJlCp +SAMCAC20YibmwdaU0V67liWMrmKK/xjYroktsmzRQU2+qitKX5S812OlrhWa5b9K6b/1OhmnnpqW +vi2a5N9EdzKSqzrq7zsADb/REySCkCKa6ZtB4pHkISX6JwBEE7hTlcn6V+JgcaRvcXQx3z+JUsrH +f8aE/+q4lGX8N+oquSY/9NlBMUiaHpP++yarYZSHWjMOoSsumR3roDnRm+iBw86Ocl5zRMVk2Mye +baLNU4k9pm8wVyQr1iZSo18FGNKqpl8G5PRuqjhdxHMlY0yAoaup+nhXxrsCbRXF/xDSsxJM51z+ +gVJ3YlTT5f/Psa67yISoSgdjah5jWgumcxllRY/5nuglr4r1/BIA9WCL+dVj8vXuhw== + + + ull2ydezewBq1ZRmFwHE6/3IbJ0dDDoT07Gjw1Y7nN8FsOqSzJ8dZKxluobFTrPVx0TqTK3emNSc +rIzRzPd1JFe+0UWWZYykW3kEQZcmDs8mT/g+RXrEsnQnSofxXcb+s3grACd/eC0AUNyoy3p3UUBZ +kjycHfQgl8435AKp4FmAQ7zUnaC3NxwqR6SastIzhL1NjEzHNwXo0P1qykk9lEOrjP4S0zh8WUeY +rTUOH8lzsOODLUv2Wzhy3Ajyw9VB3WiOlfGHAkeCnfTl0dnMKo/urdLUBk6gLquyC+NYE7kxZSgz +6DKWMopcy5lKlaE2YSu1yU0YSy25CWsZxdjFzGUU2zZgL1FyIwZTYyI2YDE1xGITJpMKhY3YTAaG +LGc0YwDnclYTY9yQ2UR6qeXsJkJJN2A4v3qzEcsJiXoDppNxRcvZTsYoLWU8pdAGrKeWWsp8soML +2U/q6pYxoAi22oAFxRpvwIQCo5azocDehYwos6JtwIpScbQJM0pisBE7SgK0EUMaA8SXsaRKYpcy +pUrRN2FL9RTZhDHVULhNWFM9nzdgTjU92SbsqTa5CYMa02suZ1E168ByJlX5peVsqpbbhFEdKQrb +LvL/O9iqNFNlGvqVmtM0GKnWWLTG6p2Jgee6dUpEOz5OukpSW4CzQmgk+q5MEDyY1SNZ/XBL3pHK +4WAsmgMSufzU31F5KJuu0YtkIZtzYIdXj35X4hpf7Du6OzjsP9WqDgd0vAmfLgevMfEKVWFPdNcE +Uzk41yKlrCAxaL8GabPB8bdN6D87Optd49H9NfpWJl5oUV7t/az6mpWN6uUla8s8ExusLm1wy9dX +im2ywg8gOFltkzHWV0zbUJqM+xaipkx45M+RB9IMmXjb5bxELuF4Z2mI8cAtXTFtumAN3E5r1Xk2 +El6rxhMANDep8Hi13lBKCUUpvkZr9FfAMSw9u3WQhJT0thrQ2/6ytsEFnRndJlWvBuRdfpFhJAjL +AQAD0SFsYPUZ3FxHb8K64RWU8q2JXt5kmCmYuGgJgZg3me+N5OQGQRNRVK0PmQ9FBt0i1gX4jx2C +DiGNdNBODj/l5ktfHZ3Nre/ovvoqq76Zg0rv33trkE4j9ZeinaYSXox43EZLUY/UYTnyaXaaxejH +SVqOgCy2HAUfIBCdmgAZxqCfuOoTbgUGkytLSXVDE4lSUkow4KlK+jEPR4oKKoEqMZMGAF81MZ6v +BQeMYSIlh/pbgYuWITEhBZ8xciljUsNkWNKllKkhigU9U0PGJ5DVdD1/1MYs2mf9jZTDCylDvRqw +WaFaDTWFJXQBdLPUapnVyR5GGVQoM6JiIE1hgOoLxmzUSPmb5FavIiFzc0wmeyPqII1Ubd3qHoV+ +goJ0EOaZQlcQFBPxVHAEx3MDQdGNv8U+Rial/lvklZ9b79G99cqu0eTDg4ofUqhNsC/LcbUA/7TU +YgzUYktxMDW2EAuVvV+Kh7HUMkzUmV2Kiw+RCVLpWlPSO0N3WFBF+A5C8+bq5DyNqJQ66QWBZQxj +aSE/q+OjJfGv5RAwMbAWLrw4DZIusb9euE4mCWq/gAaUJtmZVtNeUFfAVNcafhhidAW0HkHjG1V0 +AdfI6AoIrcGsJkPacDPW8G7nPpCZpKu8CIQtBy77wcHXnemMmKe/Gn9qy1a/6L/lVpxV69F9tSIe +kRMyqPWBfThdXgUuXWCVtxcvcWps4SJrscXLvBbPkbVJtv69eZs+Wx6ZD7+c3/1Wg0I18eZ3BwiD +FsJGOdYLCW4pCbcIt+6Sy5zOz85ta4QRypw0SA3LE10oZSML56ARjfK1rREvYmA+UXVTWTe+A5B9 +J/uRIMw0aXFqJAhrFY4t1SrPTIMe2z3GKcEs7hXdMjWP9xrQsLsnxNNvGeQPRQk1947xrgliVYcP +jqnVVNUa20ONV9U9M+aftxd3XzSjGpphGxqRZzWOizN20kOgPbNsRW98b/SL1Gp6VtkC/eq+8KMa +/LCN48lYMQeOgp/Nxt9BYu+lkPF1P17hBPV9N/4aeR9K30HqUQ31qA14uyqkH38Hib1PdabRpVb7 +8ad+JYgb1eBGbRxPxorxF+POXWWg2P8CnQE7nwZYTOegQHeqDE2K8TwW4+Y1OG80D8V4GF3FaZzF +dCq6DnbfjKezGM/48XTknA7i4WA2EiQNg5jZZJNB1BzMhaJmyD7xozr8oBU9sgHJJiJB0ghSpd0Y +Y7vZNKSu9Z80ozqaQSvHk/FGz2gEAdFeAkWJF/npimkaS68qmpQZEXd56E0UFAo1TygTHssyerVx +dRAMB7eeq5OFwoTba3k5eVcT7vAxUMSHeINF0cCa0QYN2KnJUsrL2gVNNuzK4SNzbJgeVqCdBtFU +Nj7U8Q3wz+LWqRK84QmfbEzU19Xj4mu0k34TcdUI6LLSh6EK2IbClEND7KGSomdva2ri8XBKj0F9 +ss5fwRfJBB17Gk9J9tI0LFXzRgbE4DEDIypuaAw0LZOzuihIlwxBz3p3fJD1/uRAx1Z3kGzc2YRI +oWyyTg7yeUw1dD3NB4KBxWMXdvKWOdQEv8gHX2GiLJ17kbTCxsMJeWSQ7gOsFaVq4Do10xFQMhjV +V12pY03JHA1G1nHTILLM0gJa4e4At+oBNRJGNKu+UKPJ9GLwBb0Bol2FiZxbSGOCEkhQxHzsao7u +AI2mdElljrOxCp/mgub0DnKWM/uA7Dg6QPQQSG5Uukzm6DiezbjHSiP+amgfnKazkz2vMUUE4b4H +r0INDntkl8lAHvkh2lq9thIQAg0zbXZ1mS4QLjWYIHTc8kwc3H/lhffDdU59TR0ka7CDdf3qakp9 +H4/vLMVl3Hepy9HNzSVvdXF/Pb27O7+9/v316Y+X53/8ePH2/INe6mL7q1+6j/79/ub27u+/vo/3 +vgg+ydp6aMZKZau9U0347/52fnr559O724t/y3eDStrvLy/Ozr8/O728uP7pj7cXb//f819jddMW +/ybM6Ie721N0v293MRf78fLy/G5VrI5Oz3751+ntW82HuPAWGcN4+yomXLaIKuUzvdhXCRSffAod +xBkVk9VWq65gMfy8MD7+AnMVf3L3ZB8Na+jKaQjWiq0MejL4MnX+uB/H/MtLVvBfKJGpSCZLqCZu +uJqmzpWzEg4FFO3SA7S7lYh1oYZU1H72K0t0slbUBMcsaRjwSjN1MqtUN0lpilbpXSqjr6zrJqdL +TKwvi6xMoR9zcful7dsr8o7EZe0WdZWuL1AXFGKS/ooZjvmb//VPsTW/io1RNKziF/GDyJWvVAKI +L9KXWhRkPna4q79rJPbi+KDrzoZxXazqKv7qmlCw7Szc+HmZcqSu4pDzzkR7Lft72f3uh53eFbHO ++BOfdu+7IvHbs65/lyORuvZdMMZ/xHiMTtRd/cSsJOo5ogvGmBE8xXszDCNZ1CdEb/ACMJq+FZAy +J/DWLR9zYfMhlU8/+iJsJj4ep07EZ737xfQfjKrrm2KAY+rEycG4i6maQlnXNM50cCKRhaeVmec0 +r2vEX+Rg4Sub7p4Gi2dTAnl+aGN8fNt2ZbvnpE5nsIxJl5zoU/q2L2RWqYWC7RkFUtaN9xey8UHT +cew63Q9oyoSLEGme2cHbkoSoctWau1PjfVBldBVj5j3PbA+r+IaarMpw3YJlOjVPVVrRf+CqmAvz +oaKV06stj842bvVocau4U6pGmuJe87aeAjycLVw2EGjCt+rI1e+b5B+Zdo4mU567d5KCOO6e7HHu +/um60+0gXjI6cw/R2tbvouzxsX2kN+uVPa2p4kRFgmk6gvngFkvTFzeZeqnO2mbJ16bt+r5kq0XS +alLy84e3WxrPyf3DFpwyYygt/74nsOuJq10NAZGIgB/wgb7BehWBo5fDYfToaZhEBeKnoXGm7H7B +zjx8x8JN2xXO64aCMdHQrCd5j2LHH3RhgcWDl7+B2MC/EZkL76U1llcfM60rxdN818K63WhuxIzE +MCbzkDll15WAA4tt25yyzGzjaG4bYPWQIDCjI596s+Q/Ol7/45BbL0y8RtMcah+uDhreFE1/5qoJ +NTZ6Ahk6SadrrAbl7j0hrOOi1aFEnsN4RIhEC939Q0cEGI8q5h6mz2H/Kpi6Uh9cIdeVeqyPVtBD +m9M+VtjFS2eHx8TClo82aBlm0wqBuNlRAV5eiAOk7lIkfJFXG/woy4Y8fB0aW5Grl35XgJg+ZaTw +9zWYeQbu6toZX8nnVx0ICkDfVPH2Et4Ebbi0oxKJwZZjUF9AQwa1z9WB3gHdFdT3UCQaaiomJdaC +HhKrf8OrW2XA9W9Xv/teRN/rn1a/OTr65uzs49Xfbu4ow2ZYPTk69URY03MN7O763n/T935NuUSE +1/T0d/nz6nd/ubn72/nZze1bwfz/ZEfUcljxnhHoHn0w8H6xE7n++Js//THulb+/u7m90ldxlLK5 +3978eP7mmz+1b6QT39/9enn+pm9av1o4a9nhER4ydH0+HceTKyW+vfnXBhc0fJnqCMcMuC74qqXK +zlal59U+Bt5IdZgSZc8MnHaVUuDyoVBDc1OTZw7qMbHXTex1E1unm2jqyCLHJBED6euzM82WjFzO +F1dU+qVfQ565UmfByDOz7OdnmcGdOANHosQ0+wZn3kNMs2uQTNHcw9EiDNCEMc+FrXFfkSqos8eQ +bZ7VytHsViCA0wjw+RjnNexyrV4nMbcyjUgxYWWCneQwA6NmvAJYgy3WgbqSbCDGkUZQF0uBa7jL +Ol3hO+zHY/x3I1MkBHil7LdhzsQH2G96zjn6PFgl4T0XGwLa5nwjxLYaMd/we8cJ8XDRxvH+7bON +2zxa3CaOKWc/P9PtUlojJL6BbfsqA8lS6/JkoDKCfHfFWAeCWKUXynSgfPlL16TL6kWccvlnMPLG +W8N6GBp9AFZNYXEIJ9NRpdOt7zVvN670DmHblW/047w/XTvwTRyC8tE18eJ7+cjYwVfZTE1BXZNr +QA9LGxFNyk+RNiZduxoAu54wDncySwNoNzYNmrNj4Jq5YtjmeLbWdOrTRJkCNMJUrQ8aBiu9gwhZ +108izSxaleycb16JNPOHm9u9hXVvYd1LMXspZm9h3VtY9xbWvYV1b2HdW1j3FtbdtLBO7KlXB1Pj +abHGxLrGEPusNlajN3Pca2MF12sfK+sQKVZWi0ysk4aPljf8VBbWYo2JNbenFmvsrffaWIt1Rtap +aTI3XU6LrIc9vZl1XeeZESozs64ZzLqCn0c7UQXcX2n2ttYn1U6cnL+729ta97bWvZZir6XY21r3 +ttYntLXich9mMbo6KPUKQM04KPKIoekowZK19YSsWIzwHYOSsTUruAbUV5+1/7mNqwaBdwiFba0S +6N5Y2aLNoHZOJhca2lYRwIYbux8s2tC8NDKuLmnzaHGbOJa8F6b5M7PbJe90hEaJJk9niQsJlkxn +JxksmTIBqyYw3HPYuLWgZPDMCuag8l5QMrZloNRZxSIG4ZaDXvYfpJsHU19pzytbkg== + + + ybjFyrxP6X0G6juA3LSNWwcZzFW1Zv7G7a+HPShWfA6pYto5ShXTUfTAfrBZ8bXAfhxqYe1mN283 +/2jdVG0qqhSJFiCtWS1YH2CHegIRZUMJ5dXYT/928dPPexFlL6LsRZS9iLIXUfYiylOKKHp5aJIj +YoiMrXJpowNlMkkquA7USyD093QqgKTXuXwybPwZhZSgA7pPSEF6nco9UrSxmsZktpQyaXTsAfp4 +o08lpdC9Mq5dFFJo4vE2rR1f51KBQnouNUF6+YK+eyMIlrzy60CZQJMKDkHlfaCes50Mo7NTpBpz +4SSC8uLmMOVgmcAGI60mYyek57xZyvk0e8PG14KeXDCZDDhFlY2HnEFzIWQ67B6Wixz50LNWh6LL +ZO7vFUq+eGngH+/3osBeFNiLAntRYC8K7EWBpxMFEhtObr/2KTCMIGQstn3cFnzxepBGdXi9ONuX +NqxiFJjJP0uCwhpIbPBk2oenDArj7T0DHlsGptw5EquviQkLj5RskPizeSAm7LEmpyFhjzSJ48kO +UtZ/HnGgC9TRNBmdQNDgEBGALmDi3npI4s7XQaoxhJF/cdlVHFgH6sploFR5kXjRDJQC0DLQdDSd +XDB4lYLBUkRS1nbf0BTUxTJ18zGFdMVYd17NtAf3AB8UEATzvBG255MEhPEgrwbALGRrOtAM1g0t +hnYNIGtHFqPFhlO+pj+f4mVVaD4L3MfKxK5G+kqH7eYpLBiLluM1ySx3dzIQIVGr725Pr3863ygE +DNZf3OoBH+l4EDXCDiETfgIVoToM1tsVkuh6XIiVACXSpaaHonudKii6GlIrHeT4gKAmA50csJzt +IZOa83bHnYqFU9lUfd/gZKj3nncm1MrtQGNWd9xOWVUPHniFcBq1wXWjpqnkyOChwHe4JakMjV46 +JByJOQymrEZ8D9Lm6+WBD5eGxzPSp49iKRa2fbRJ22CM5D8/PgJtU/rAU621JQ5P03jvk1rN4Qeo +j9eLC0Qo07v8cCgyD1GHCi5xQ7KalvetJJAst4u44Hn1bgKUsrTpd3qXSqfCHTLE5xwZXMcPsVTV +g4pxtUXeZjHpUVdB1+kM77uWJ4PtUihlGyLxhPm+yboZeAlighUIRWRPgqAs0wEkiHY0PuAt75lK +NXQVZDtj1Mu+3XGhca15k5MOTfo8GezxdPz3iZe9S/Go2zxCJ4ObDD/vqRToH0/yx34ypxM+WZbj +vDvZAL56s2ZUAhzXOGl02MdhF8cDGo94vHbHWTfyXkzm715gLgZXbr2Mn06euubVUcgaXyJfuexl +j5QKapiIb9PLk8nn9xLl1kYJNLjWr7qwBS9Vr4ltY1b3xlS8lsbgIqQm5+nLNhw6BPoIU4/bqQYy +qKwL8k1oNNSDZUOlV3cLOVzc4NEmDZbxUsgR/f1E9ZiwabzV3MUk+bJk7jDGFp2kt+nlyeTzRMDq +WuHVIbPkXyVAfBYSUmW1Dj9eA3j6mIRJh2WfZF3sPui6NCnyBYQiVH79fv9cFx4pF2s/kYsVdsIZ +XLaTGNjKBTyBnPNNOMStdq4HKO8aH4rudSpboHCqFg9yQGVPyqymDyfV5I2Me5D1Luv28WAQj7Km +QgN503hkTZ0wYPXDUXe45QN3NZtG+JXahiGHV8OSWmsEFm7bHMb4+kaAvGPr4cIB5GkSi7es5aNN +WhZid9g0n5st7da7onEH7F0TXHxG23HN9VrfBIgMkNU113epKEt261yp2WXwHPnQ7uNiXFWRt1NM +elEMe1kMB3E8GlTHe/aorXasISBynXrBRs1eNbHd9tAYXlyeINqt+IC3vLQ0FdfSPaYP+hTbGnw7 +rilvZtKJYSeHYzg+GI/pMe4y71XHWvaDyHvGu2LzroGR7B5P8sd+xkZTOu5u1oXUYzmfppBBLZNW +hp0a9mk8gsH4RmvUN921XMyADDjHKrsxMtuD9/7QfxlG2Q0bd3s3zFQLEJMWRZAgTjhsXZuBhD/j +7VqIqaTuLNR6URFDaX0bdyru0MGNm+R7u+0FawpCYrstxn553hk/2HaVCjjxHnC9vL7vnT4fHwx2 +IkDZTk+gYlJvsa71YtLHYjKMYjrUgtOBuz3TdBSYMV9m8zqdaSTOWHcl5JoliTgyXBQBbrAslHI2 +WBgtt3BpBqNJi6P7fZPlUSFygwVCwc2WaLTR6sihtWPZrD3Uq6isBrQLi44TO5gOUjWagbiGjkmq +Ts9gZNLvgi9lPlLhQks3q1R/Bzg7aIQSeJOBhMVtcQ93V0sCkFeKv1PzqXTq3ngAx5MhzU8BBWNm +i96XCP3WQcpahNau4aSgNsOtjpoKKj4UwZT+ELkEhLMr9b7x3nXhs0hm3YQazYJyhQml+aoDyZz5 +OKGugdNPAvCIjL/Tu1Q6Fe6mLz4fAyNw3V0HEeHEKUZoDekZtaffXdOpcDGuv+gbiMJihipxZDWu +bGcWuwgShEvV6z1xCcC2m9QvfZdKp8IZYsSGZewBzn4JEmyaG60hPXPebDep+jIVLsb1F30DE9D9 +PMbAH6Jv+Cp7GresldrRwPRu+uHg7Wo8Of3E4evJvE5mfjISFJtMwWSS+oGMb9Gtmu7sj+4TIknr +DYrCh5Y4HojaPuC2x46YnnSf4Svb5pCu4OdJdAGrFSWEeLewKzsluCphhBSZplYFTgOhYaQykjOC +mqyHC4PnsqaJKqOFLR5t0mLJHCGfPbUFbXu6DLhVnCxZpfc/R60RX6e3J9MCmd6oiS9aV1dWNUeN +llbICXCjr3tcYC3oWfRHfaNNGVmg2NEciftP2b3SD2Bd8S9Am9Qltmg/rxrpD6f/vLm9uIvao/9I +MsbnvDcbl5nj2ubCwa+qgrlB+MKat4kmEOSeGnQTABjUkL2shfLDgRWsWnXKDDVUTbbVKz5xJ6nx +6szZBscrtTWbldXn44MEaZHDRh07kOEIXpayqXAbqJSVF7w8mhY6RT/ctpr6pm6nFqxv9xFraZqu +Fl4zmxrRa2a7XpzoHbWG14HHnhYcDCFxMLyXF81mI6ZoWvPS0TgtBWfOVf3MFZxeHCZZf5t0F2/3 +lbQrvBocLHm7bpWNExl+aqgIcF90vN4zfYWKkDqmX6jxYh53PpfxhYwsrTIS9njbgwJsKaFii9zT +ju3Cr84g8d4xSbvRCZFpwwfOhvQBHUfDYRDUDKkOvWWFV5O68YQkyLH6B4ayzb+q6QZFAK+HFYDe +bOyk1VaTGcppboz6I5ehphckkpcCgunjfOphXwfNf4hHWpTrSt1JDw2swjLb3sqoVCZqZFJXOMIq +kyMc2GN2l5/4+AmuBPea5Ii1gG3GnbaK1tqSXo0bUb8OVISyq6brKj1AofnrR8MRe5MPmbPi+1nB +vDVNNm+TZT6ervz97q1P7DFSYQ54z6v8dSuPq4B53av1VkWQ7bru9X+cX9JtnmT32ycgvdjZttFr +kmr6ShlIHKGlH2dAPt5DvWQZFKvk/6EmyYDFuEQxrhQ3BleKNkBY3HidAN1zKtMXSdWmWlOb7Ae7 +kUFGH09qGzU37s60x+/gxl1iv6e/V5pXFbn+QORlYwrbRZGTqKOdzkDF+PNiXKN8T+cS+T7gdCPZ +iICig/Br0ri+WKq66OpODRfsTMHeAGa5MM1qUiLVllU7aXvcu+kAuI8R9FA7pZDeuTredlVyEmSr +wWPJp3z6QWgB9Tc8NzII74eOmRgTDNe7B2SQRj1yjJJ2tvR9pOqornU67GHpnXp+iPhl+UPN/rLC +dWP0lTDjgZfHO1g5jnmlvSPBgwpJOGf1h1SBGw4DnB8HlUTNrHHw6YZPT8ojh5QVji7whUUOa6sm +al0I031Fjg7MvsXhZnvI2YHh2WR6kMh5rSYpRQheA+sw1lDPMR2ug7eiawghbyHTVjLio40L3gEC +jgeZmLODDiQrU9U1YtfiOIUmUotnwDxZOgxAiHB6Q3hTti2urhfBtA68NR3nZOAN4aXUw+kwpal4 +ITvu7pbtxyvCA0NPoALy1vDicec924HvfKPtwJ3+EA6XnESRXyoUwtnCcweEGfegy6dV/yR7vcJY +jg8yUAi+Ub9cmZtmCAiU1A9VPSgbgRMri0+DtPSrtgjvCxENfVxwXGWO5ZIJIq9kmNGUfnG4nR0o +7KII30ubh76xNbVATasXnMvJDYBMINyOMQ1t8GgHOOpKjrJu4OxAFK2JophQ1wNCnHQWUhBaqIXx +gstppalYXSsn/WQzYpOCLwjklNDT2hp1iwdrYDsQuKmmapkk0MEG2gOwMGXQJYogmQWgU1eJ7Euv +zEpqKUKErghawgU8QTzCaUG0tY7usWulg8SOdBWknk6Gc0Zd+rPcEU/78hayCjdX55FVME/CKjgf +tfuCAiYEqJXktBSmWzMot7IXGAUTQa5Uk9cJUPZeEDjasrbJWZxSvfpMOrLHbFRR05aBDDNMByt+ +0SqgOqxs4N4Tmb9tchhrYnAOAO0agJYCQOpF/Etf82TAJynTeallbc3KruQAVENDBJx0gKbvZgDL +CZ+yKagrVrDmENZA4EXO/EV6VYtOFBj2hjaV1KXss1EvH1bbfL5NIsdrLSx+JUcyDg6PPa75kltT +t1u4cb67/XFVrI4uP3L7mKRFNXO3BWUlcp6kx1cdxNlDJZVBL+6hwzMJcpGBCn5e9Z93gFQjTtME +EpTUoz9WYBFhZBA7lH6dHYzfdT2Mhcc9Ppth2HHut/EDBEIYD3cR/IvgVDIrDgdu5VZyfiOoB/oS +6H7ZllV6CR7VCz3iRR+URnHbRyO9dSKL9eadTdR0M/v0+fV1UYtpIMYOp9E+No1TPbkMfuj0SVwc +4KGQqda6wPge4e6Q9C2BRBg7JKeDdM0tsCQBhGlryboClTqYUD6jAbOsBiIZzor0g4hkSqpyCGDJ +ui/ZP3e1J1DqQaohdbHv/3E2llmWReg3NezGe5p/hW12esmMcNnNmvgBod9G/lHcSw+8ZEZIE7x8 +TZBDQJimaVR0sI2j5dCXYFml2Spgy/SeFLQqGlA4OVNll9WtnqW8PwGyYgOrpYvPMi9V4FRJ3VAz +9YA4d8cHCUQ2qGpWqQYIYU2aO/465sUZbd2EDlSwdNWX7gBZCxksdqOrR7uZup9UdniuI6pZ3ieR +EyzggUxhlUOytiIMCiK9OCDW4cArczzp17GSrKp/l0hUKpye8+nqQLEXqY5CA0tcrdpCKgo3i6ae +tHqVAVPXxl3vh6XB1qNRT+dlMnksN53kfA10XIy8zkY9mZLJAMbGw6a/VAHyTN1TGghzlgZtR4Ml +3M17mLDd0MzSW5dBLZ3WGV7WkDoSQA87IfvZNxY+0DarJQFSU2cHHQiCZ+NTbDWqQei2oeCZ2uog +lE+0Q/1XXaf7qiZjm3MEGv8Q8YY4FkmN/ix4u0HrbK3e5XpLS0doMN0hm24D6ZKRXSLdlj5d8x1h +XoUtsM3GuuifopHnh8lQSYDqzcgGZx81IpWGKqunA8TGzg4yWHfTR1dRm1QaqbUIUA== + + + TVTsUvdR1+uuovHYPn265ZwR6l/phKcHTYRaixAcLDTWpV5PGWdcQ2ph5he2p2L8RAdqEYbVqLU4 +pQhS1Rm0TC5UHUBnCuJU9k2Mg+9riYDU0tlBBxIpvYo+u1oLktuWLmspAXRy2Zv+m9jfvpbRmD59 +ZqEOQeCH5hKJD8glAnUH4txKqHmqHJdbuBKVejGPBll3EGxaK8xFQ4KkGEdNm4/x8x0AujAX3cci +SPZpG4wqQWM9GSg2Ri1VB/PUfqy6qkT4qVoX+uYSANrR2KUE6ocRaxmP69MntxIZE1fbcXLTA1gS +MBG8lEmYcjSVE4qM/5Md3WgcXEnvqKse0saYESH1VLgWDJkLQDBVOHUAzDQmw/UgA/EacnaqpQPE +hrg6HQQKw1VXCdIl8Gqk1FACQPMTO5NA+QBYy3hEn4ESw7/PJ1ocHwpNdAZRnxdfOZdLHIUgnLcg +dThjag2f72CI0aRfIZTabUl1sVEeOtDny/UQwcZWqC41Yd1XBuoq8IJdTR0ktYfNnmBCwpwNXIxY +E1S/pDRdewlydtD3qvuq63lX02R8n4MC4wytEwXWB1Bgp35wvDXGg/m/99BzIqDWhgoWU7YUahII +enyrdsy6aqmj5MkB8yNCdNMztrHq8BNEXTh9X0UH6Jo5O+hhBrccuVWqRfUt6m/AhjrA2UHqSwfq ++h8rmYznMyCzzKGJx1z8jVQqQQ5Uh2POWHiY58SYQuOIaCBjmV9RHeBpyJITM7Q19crUpFvYFNoY +FIyTRsiQsp+YVkgKx7izk36YnUHdNsk/Ho5NQkkF0CQSwQjyM7hkKMcBE3DDDGuaGKeNhg8LfTLW +SArqPpClqMGrGqYc8eoUB0sM7hnirbcizLtQN9BsMUiQBknPjCu8bIqswKFTJX701qL5sOEHVBwf +8/B3rRoL07Zm6BnhARaS4byd3Rs6VKk7XNnS3QuzyFweZQtjnMyacxpgWac/ANINE8YIuH7WFil/ +mhhcxKw7dUy/04RIhoPVfcCgVznwKghzus9cW2lkkRfUkJmEdUV+iWhYrSnb1AFX/zk4ejf+sKxb +Tf+IiUjeF75s23nNwnUOaxUqtUqIhG7XlqyBQM5rsHsblDLM6zHVRPRfFgIjXH/w7WMphB7z61q0 +LE9zvXLTyBr4mX5yScO0Tq30IAI+rGeiGaunFUL1HMxmBdwYW2xNeum0PqihXwOYqTOvqKgvsblq +eJ1Q2SFEF6f6sVRUa3wSQDgF6uSW42B5xHOrZkA8w2PmDGTJqOuSSFCwq/LybeWVaRmCQbsmE4ib +JEhgcfIwtYAccWSRKziCY+OH6FGF3pJ8CCWIDGNK1mmx4+vInmCIJB9BWZgapQFAUofjA1IHcIU2 +OsUkhggaFykynbnN6AVCEOuWKNm2Nf9STihh1xQC2tS4CAKKJyMHVoVSIZIN2NPIgNWk0LQf1vTy +Ql4O29rIaraGrKbHV7LLQDdE1q4gyNEkE+Qb2Wd+TXnTwGembaDQMCCUkOuOlHtp1Hgj0wxjyby2 +QQEqZEuiSRMEAulR1hSVXc/Dl7J0670Sj7ndjrJ4rTo/epF+GvnYaJWexlsUGNzYl6ciTa7NkO3U +2GicblVbXWmSJRzMrlGxi8c5PR8NHeU0gQrcQEhn6C13GFpDpwQmXOJXmujRMTeDXjDJO+0KR/6X +agkLbQbthI2KkqZWF0a4YAbonOD4TdFHyE8IjZrWBTnpWUpfe3QQ3DMM6bzkFdtL+J4kc5+BJQpO +OG7wO5S9kDlQWRf6EuAZvQdrD1w4htlRTltNKUgdgtWSYDebSh0IBjO3MRGpYHUDWrqGB5sxTt0D +ZevIwEtozTFWaeyQIoEKqP4w6tZg9KS7QulC0CwbRhUBIlUE6lgMUivUdNeXI93CuEydoHdwYm3X +lLYyb6W67RgnR61I5Q3952H8cnWSWst2XsNHdFcr4Tcv31debyYZl0NYg28RVFF6yEEsNq+/wmqX +MLGSaWkZqvbJdGPxwjzJ1SQiK5WmfGmqMczhroZxqsrgycJcfXVolSFtgqOcUssepAhGVS72k21V +e0Zdsm4xU6mDmLpUgWNlxZVKOQB4r4VaiNyU7Sz9dZjFKfDmIDWqwV+OXl80aNf6CZ0GVdcalZ5B +sxwWZCmC8rCqDZHW6CQGqZAXYJ2RrNGjQBAO+mfDrww9ED09e7WcWnJ8DEBXckgRhZ5nqjbpzCuN +3uE5ncdN5ZbgyBLrbeDxb4QKnnoGYIJXQx54nvhkQiowBU6VFoLJJNTG06Fept2omtaDDMtqyVZu +hZ1oNUuMEIOamXdkrgIEUb1TbFQaNwEd0oMvhBK/nOaqBDPqGsZeWRnQuqLrGj7Ss8m6ulFvLePs +2qKyM1OeGfRNeZd5XdZbcNsKNIjTYswniy9LV+dpmA9Xw5vwZckIvMTUI9GqCw8dkyoyFjjyZQdr +6CliJfR8566HlzvEGDU/krzIacxbcoNQjorPat2K+hbIxXBzEnpRQ2FLfZT3qqeiTkQjMxx9+Vrd +qU7fwG/Tl3QRBXNiogGLsc4O3pKlbtmocW4Oo8MfYJEINopDgLSV0a+cxoiUCDOh96/SpmM6xaqK +S87WspZRQFUEz39QkbryVMYMJ25jZsPT5/FQY9EPYZcRYoRM4LYWflsVaTIJ0q7zoVdytEiuJQTD +wtsLXgVwVgOVrpxqDMBHWR+FfhyQP9AY7XFOQxTzbYzCnRSuHTg+6EqrGqaLxtdJx9GCKjnI+rin +Yk6rR2oqspWhuGdLY9YVFAIAoVfVclSwHc3trlAIwVIoEWkCKNsyfDqnsWxVnoJAwJu5bNwL8xmg +70wIUJjsghh43TbRQ72qotayamLsVqW+uiI9tupMYeE6RZ/xSp1jAcPR75HhxupH1EDDjZlf6yd1 +G1UOLc5rbEamNDRN9GWFaaslNUBsPnXS8ml0wGa4TdCcccrDlHpjHQgEHdzlsCFVs3CQb6MvukjZ +cJsFwWhp+EZqBOZgVidkSzWNIwAGxmOYLUpyGXQXLKOxFx7foGSkOuNJ3JivYK7AUn088aelkr4F +JfKh9kjiBi4/xNi2aNWxTQkWvY6bOeZa95qzSYMLgsjdh9TCBOHdpEqrsgn0xNARtE6grqzvKe1o +IoKzYlM1zSFDro5oLKhhX1TdBrn3eW0f4Y5M1zRliMoN7+4rCla1paeAoIy8VxllZr9RXApSuxH5 +2E/mLhau0RMQD6aREM7qpWWUgWajjTw85A9scSiwcbrKPqFHsfNxHwuWCE+gBj2c4JYOSgwR0bhB +bkRcy0HxQZ6hHEVgjdpUhRFA1AQuFFE1ABl8qB2kHY0i8TFaAnIi/rbQejkGM/Hgp/XFVeBfGqZX +h/tXzZjN1oAcyBlIw4ah/QP0xsV4KCGANSiIKzXReHlIjSYd9izdyDVehvGzVO8KNQPRojEFCjCo +Y4XejedrYw6jrUqGN1bMdyltNhpiY8CuWWFnhK9HxEAbbFRKqz4DVsGSoQZepKgV7vu0Xh3fHMk/ +eXOGYDLXmatrJRqIWIRKcwXPPyG+cuRPCwtHAFscpCwrtF8X5ojz6GEGganMy/E7r1nseQ+OAzEn +pgnUKk8L1hARUwICqJeO5naX8k/APElZEDjffDqXsXxlnkSh0SI0f27i+CciFp37eH5/SUvXnBjq +QMeuDgQPK9qy2xgnJgcb82mkn6pYb6MHBUEFS/uudP+cGlCZIcKapB6I1SAAAoavsv/J8CUNdYuQ +vs+x+GQQ9+7jRo3ZMXmiSFXMehHihIh0JHMqh1oUwYShtggEtJOsihSwYGPyciDSgzy7N6JC4kNs +HZy07HGXMcTQ+GgdHFn8A6UboU2+CRpRP0yruLDpo6VNszSlM7WdxO33j6E+bOqaOkWkDDgDleCN +ugEy6TVBS9CJV0IvRqiNM3TMwq8n8vzP8m+4p8m/oeEpfQbX8okCVJAdYxSgoqBPCFDBwX9fgEr2 +bh+gsrMBKvvYlJT17tliUz4x8d0+RGUforJLISq1fTBEBa4+owgVgB4JUDHPGKBi5gSo0K1pEJ+S +D+wzhaeU8YbQ9NCFqJj5ISo2ixq5ymF5iIqZhKhUq3GIii0/U4iKVjQIUalWkxAVMwlRsYOKxmP7 +TCEqNk55euhCVD41RqUZx6g0kxgVhl0PYlREgB3GqNhmEqMioEGMCmoZxqg00xiV5gViVGx0i04P +XYxK9TmDVNQrehCj8tkiVIbxKWxp98NTVKzMw1MIycNTmA5mW8JT2Jk8PCUNoAtPyUf0mcJTYgaR +Ij104SnVs4SncMzD8JR2Ep7SrglPacfhKTp72xqe0ppEffUhhafU5jOGpyDf+raEpzD3+6sITyHK +PBye0swIT7EzwlMi19CFp5hReErdfqYAFSSN+tQAlTroQb+lESqNxmzw0o4HI1SqLt7DrimbIlSa +hyNUwrxmH4pQGZR8MELl4R7vI1ReOkKlUUZtNyJUpMzyAJXGPRqgAl5lH6CyD1DZB6hsFqAiUzMM +UIGWMw9QKdt6GqBSbhigAu+qQYCKWR6g0o4CVNpJgEobHg5QKScBKnbLA1SaLkAlxJgNXg4KT33d +TItjVAblU5RKWBulEpKsWpu5jac4FZPiVPRe1mlRhqqE+aEqo+IMVmlSrMpn8CDdx6rcH6uC3fFZ +YlV8vFKwi1WJOr0+VsVtEqtCvmEUq2LLSaxKM4lVcWtiVdpJrEqYFatiHo9VGczjC8Sq2KjwMJqu +d33IiA0pZCTksSosEwM/7g9VgT1PQ1VsHqpSxVCVspnZbh+qUsdQFbs+vAahKrgLZU2oyiM9jpEq +9T5S5RkjVUozjFUxj8aq+FGsih/FqlSTWBU7ilWpH49V4cUpTxOq0jweqZI4rm2JVDEaqOJToIqf +hIyYNoWMmHYQqNIFfkyLxjAVYaximEqkEAxTEfKvYSprCq5rsw9TcTFMxa8ryDCVMqQwlaYZhKk8 +0NlxkAoOqn2QyucMUmnaJwxSgfpyGKRCP8VHg1TMJEilmhOk0oYXClIZTOI2BKmYLlzDmdlBKr5Z +X3phkMqjbd8fpDIpOitI5b5+74NUnjVIBYrEUZAKnE2GQSrm8SCVchSkUrXLg1Rw3chTB6n4xUEq +fhCkks/XCwSpiFzYxCCVGC1SpcCN8GiMiqxrjPoozbRwilGRrRdjVGrTxaiUbYxR8fNa7UJUTAxR +WVeMASphbXzKw11N8SnNPj5l2+JT1I/nvviU7O2nxKc0D8WnZC/38Sm7HJ9yHyql+JSFyHR/fMp9 +6BTjUxYi1D4+ZW18yt++/34QlvJ5Lx3SO1IRSABndrqU9SB/mFDDec842JarCuU9PPwT4IzXbOJe +v/6TZlhH9xybUQsNQbxakGkztA40P2gmAeKdhehK903qa1fJeDzYXuux6oc/n/zjT98KRv3m7OL2 +TBbYvvnt6mtegFNi1eVlttAhZiGg9GTUoAUfGU0VQNAJQEI4Ajkd4XgatVo5mIxosw== + + + pOtKW+u1jy18kKKHJ4aJCwTLqMGpSpiIhJuiYz4aKA0PoboOahaLoAIhPMgacEK/GUOPafrCVLxW +EDesCrxyAY/DIRxPBgUveS5L7bKBUp/d5F/BbxXcCnwjQqmipOfV0XgTGtVHRQjuyAtN7LTCEpqc +HNh0G2+D2wPZamMq+mq3mjFy1J3jSQdPnuNqMiyOW3mDS3wN/9JPCOBKXdq269Kl789Pb89+1jul +NZLos1MOKNkRBg35AimfrggKUIBT6UpFB4yscMIy0e4BfZu3jFfn3gb6Qy0mPytcWSbH8iV3hMg9 +dHFufaneGPT9EWGqqisFwDVrBdcB3KFAx3/ToHF+K4tyCanMO1+RgjS1obQkAy+pSWGbvHoM117C +Lb6JdMnqtQwUg+TsumQsAiUgXLAGwQw3+5bxmRkVYZ8BhWwPufHOprNzSSydRJ+098ehfIz/Yeko +jc9YPESNTJZFgYsXBuf+ZGkA3GBxpNh0eQS4yQJJsekSAbh4kdbMFmrCgfEPTjxX5Ks3/ZosXQuo +2Cw1vQF2ba4FvBmhAXAoUyI0CV9C31bSVOBtaBQI70lwpBCvmxA/HFV5L/AdyUvq+D/yS2lCFFae +5LL5FjK2IULVsIHRcque9glkvGpEAbDAQihLWh4D0Hg0uHnUhkNLDhVmTodJ4MWxhic8RVjc0g5F +LZWCldGTgVm6cAZBh4tbbmEQhjsQXD7RNSpcXHIBhVdZVdcdxCOJqeUyCH8feDFmzQs7vYiDqiF1 +mqUuXVbLa3INE2Oa1gWNgPJ0UOEt4g1D4WQ03CPAyrZEjJgIB6owlklB3svxvKUAvAQnJyXfXR0g +go/K2QQS7Km8j5nzReTitmlUaY37TIPe5YrZYc5R4b01TqfmfaF6/aPmNISdWfPSY660nNO7V+G6 +2zIyUnaTr7G99aJfeOvAgUPEJgctyPEBfHY04MPBRQ4cCFXPTXRITwuRnnntOX8lCKxr0MerN7lh +6HKpl+Fa+uQcw+ym/oUNonxqJoiJ1+AYVVrL/okuy9VhVZcsZOmrR9WaxqiqCyI0Vh65aHkfpt6/ +TgLJ29XjXScANU6v1yxNUJbV0bwoSOid7ZdkvGrHk3V8+L5IOIfKkhjbztRoPPc9700rzJlvcAY0 +uOe9BbLAAQGX5W4hP3R3ersqViLy/frbyBDFO1xnkrUSqCHbWiUkOEnx8ORd0icHcc8HdQItCYKJ +0Va85VdEgCqy6CX9xYCz3pBSl5SB67bGw5r3a6qZNjbpUN/dOQHWiK+WbW1qnNpQlnq400GDU1ct +tF9jrZfFtcTqNFzE39BLIhJZOHPaMct6EB4Wg6tlf9KW4KClhErZlQ4RLVCSCGGFArGKlz9Xwgg0 +IJQiFIoIH2OrIRxB3311AL/+VsNBHTXaJwJqKvoI9rdTN5EHAajU6bO8LotGu7qFFZ4z6nB7FHwz +LMsxQAlmYxg5eJ0svP4Mw+zg1OOVDKiuHT6ggTfH+pqabqwHRDEuBKJMm0qv4J28LyaVFNOGimlv +immXizUDK9aMv1gzTcWa2cxm+6SPBodfBCITrlC3N4yIaeg/w/Y0Ea+cnTWrNRiGYxjzCfdNSgNq +eSlxSedpq0R1/HJQdljvmpazro0eZkd+a8j3YIxfvVnTlNDIQW+EbuVdlcfxUFBrP1LlrMdfFKNK +inEj6+Z70N2Tg2Fot28iowdCJ6e+IIcQEgRhtzGLhGw7qGhrurYkTGPYTBuZhRNIURqPg1vjYd3B +OKyn36LTkD8aepoQ7ZEwcx1Tyc04EOo1rOOqGTqXFEhEHxiVXzPE3XdO+ycHcOIDGSroZV/qHoIW +gabPE8h5tcYk9x8gwI2qmL4aBNtpyGffGPWYuKIq6xOjlxByIAvCSKST6UydPKDsxpCF0eLdhEVT +w+1LnY7hVDihmwhNbkDMPRg1sH8eiUtqxmuGpopaYkSeChaAzVUG+QdE0wrDwuzH8FtDxMq6onVQ +hUqwTTQCHZ1t3OrR3FZhVWrUjlVDrzVUa9/Hi6STvlyd3Vy9v/l4/Xb14efT9+erq5u3+TH/sFp8 +DV6ronuE2Qoc4TZF0E2wWzXvI/wGsZhguIiPExz/6s0aLOdW7vGcIvME0wU6xXWShgm2R739CN91 +GkYYv2YWT+7Xxy9Yukw9bp6HM31iBrLPE/XxU9nH9n7+0T3EP9Kfdw3/WEX+cfT+Uf7RdfxjuzED +adRk2kIQBFNnGmsCGUgve2lNfh6qmXxK3hAfYiR8a5AWqnUQRfP8PJ8pO8+Ag7R0cRlykJYeRgMO +0kZuaTkH6cizwQHrXg7Sfw4O0s/iIPPeLOEgR+Mv1kxTsWY253GQbbuQg3QPcZBuAQc5bHkpB/kQ +wziseR7D6B5lGN0mDOO4Kw8wjHU5ZhixkTZiGBHJ8lQMY92ahxlGtce3TTOLcRxWt4xxtBPGMZ+x +z8w4wlVXWbh2KeOIfUkWzs/iG03PN27Q6NHMRl+cbRxi92K2cTmOL2Ubh6h5D9u4FtsfZB/H1S5n +H+0a9nGI+c/JPi5n5i7OfjkHP/e387ebMHOwpzXqQQ4rNJJ3KqSIfxM4PZfRJshvupfTr9Kvs4Px +u3HhrOL4E37mAfAaYWgwZQAnnNEweEGCsgzw1hQer6xLfhkQ6nSC5D7GO2YwCV51bpXwCF0T8cdx +P/JZTKExJHO29QikAe9SVrAqlXRtADWY0LkaWJUul04PBblBIhuSa2vyk4lqsa4qoTDQY8qwO78r +Z/IfzoqM03J8IWiYFLWLKXEjrKKaubEq65AA+v8iQfWxVL9XnXemCkD+lxJmUA3RY2oEx7RcraEJ +wNA3wnCJEIiFiTc1DmimOygr8rWIx0lN6F9N9pi1Hfs16mZJY82wr8XkmyLV2ed3tBGRUxpJ/S8H +aNVM814zcCi95DsHM1FJOZoOxvD8M7DnOfhL8JZAvTMUz45ZGQFpNIcOIYYx+VafjT43rnvkVDNL +bM28USBFnDPjgeh0OnZMQcUA7djjfBT8y3A+u9IxH8exb6IgdDaeFw9PmpqYH5i2M1qTl0wcMt0u +nLqv3kwn717Yg1OK7j48qZPskm3GUe7p5iy6iShKZSN4TiMvGAOLS8q2xqyxx/igiWJJNtNDQb5K +yKJT3qxulDcbpbv1rqTJvxVpu+EPEypm0hJWVImkMGlAixKB8IhLKREahXClPdnck8092fz8ZLMZ +COLYEuCJRP4ILd2IEii75QpMPjQ36CD1Yb7ixwlwJoKy0ejhCEF6QAgN8MJB4Aiz5jAoORwyCyQk +QE18VtDZJrRg+plHAHVUq17w4KPGJzlSLQLwfzqo5GAAElnHb2P1HjkYktvWMLFDpcnnHDxgHTI5 +0eqpWYE1B5OL8ZJxIlBJOkcGc/VQoAJIq5O5BkdaVBb3TCLqCd5ta1hT50XUo24M6cQRDFmBJBiV +j5FskMG/Vq+9DLaO/ikigtdIYMerpJACGj5Ca4paX2nqOpHDkbdAL7rZsNGjmY3K4sIWD+ndMqRz +QUDCGrzsgYswE4LtYtz86s1S7FTKMxc/dSxLMTS67S3E0dHuNwOmabAG6azVpJN6Kjbq3NiAGsIL +EvpWzAk9Gw2O+LLmSQTZSA70lg6R1FhZ+e19MwDhK49ESU3NjEQtkp5I1XUEIBuuY04FF3PpQpNs +9UbYoJnN28MudSmTPjHNCkOXg6ZsZG4WelgBRJX2CUAxChtfOWptW/Who9ufsmXMX11TrWzSc2Tn +eKmobGBES5OvaOGexit9MemuBOFuGDvNs7E0mqGZSclODugEG8B7BK+WEkS38Yyge+AJeRG4FpIX +aZQX0Ty4gOAMAsQyuhv9sQF4WJd0zxuzJ+nXvWpCX9MvRyprmfC9DrI0DKlqy3UkChhW80yF5w4T +oDgExvEmLcToqtrNaeqygLxHTAL5A3OCitCsmzLAELi2aFXjkmYkYRNyyR1zdLZxq0dzW3XIDoqE +TybwMrABjTLDpLJrmI+0ZdR3eeGmARWYbBts8snGAXD51hHGZJPN89WbNduHwPEGEuD8LaS8zJJN +xBKjbSSw8UYi/zXcSgCNNxNho+0E2MwN1a/22LLR2PtI6pihYxJiOnPW8cYEPlfwb9XbAvgM62kg +i8eUMdgQnLSSMfJ1hdR0UAFz+Z+KkR9BHqQipewqCIiGmfHg6oqMmut0cESMEjkMZJ8iM6yTA42h +7YEe2by8pzEQKw3ypDatZp5FEhlE+vDSduDOuFhtaRmUYhUCiErmYNyktaM5rQXm+GT+FouEPMvI +xhQtFLYIMXg3x1LUeFJRZbAn3LI9MawLmUAq1Y8w5YiHiQhXbjb0kH8anL8Hw50lhlcW6oH/n733 +zk8lSRoA9wLcARkECFe+AAmEB0lIQgJ5i5OEsMJ0T88f+9sL7HH2GnuNvcamKe8LeNPq13zzzRtU +lRWZGRkZLiMyoAeEw3cQQ/5JoLMYncMEiCx05SiKwxNyEVgS6nQwBwEdxiDlGF27hrLl6QSYJZaU +gEElEDvlUWKJ0acsL1xMRkH9l8fUR8I7IdBllIC5JYRof32vLGay6JJCeOG7ICkd9AqFbBxfkkrh +c3clzTsmci3VuF/rtRGximCZdR4CNZotQAvq0m/Oz4A4FtY2oNBlHQR0a3DCZRcwrIKEF9VWFY9Y +fPMUvEwaFdUSvoIXX+MG+G+go2sfwTNqzVcRHdyIrnN4XbF6hFXtkE13UwLvJjJBwmAeb4JAUTYo +UVQvK6S0eZrHIUSw6Bq6+0F4wyHTlsbjQxocGDEpJ+zDb+H5MkwxsfkWbEcGWHzqdH2X/ebc90uh +O2iB/invpQW8eRgdisoEEEG3/PL4CnQUp1tVPmPwpcURDqbE87gqCkHBYEx5yYUneY/uEVg97XcI +NGojgJYfCP3nPWiQljTw88lWi2lzPSeB755AV08QKBfQil5hVjNjSzY8coqoqRVCt/0SyCDE4tXE +6qbTnOtOKZgTRZNxV5qOnpLhMz0tq566ombfqwE9+16XomjwmZamwSMtzYBHerpWPnRM2TCOQkfb +EBVLUTfGoXasegpXyz2WVJRoU4gnaLHCW6JhJN4Q7nWpO2FvMzI+0SX2HIkv2kfXSKmmy+s3Mi/t +P81XER3ciLpvBl1RoBxd1aP+y9InCyu1QxccvEOGgnmYUF0228j4ykyCQHf6wnv1NJuDJOJ4H8Yp +5M2jKeVmxvml6JoC629ZDtcjUOzmJXrOue+ZTAChB1VYeUsr1ogTdqz2CRIXeGmEJ9CvksDFzWhg +UXnlFYOinuGwsPhhBKQcIofj9TTTiGjnqUNOfr3Ehi7KjNuuOLycAlYgUNMauv+Vo2y/hsweFm1U +U5vLrnNLdQ3T84EIsY/EW0bdplZTt0mtus3FdXoLF9dwdyRgFNydi+v0FsUjUW9RfBXRwY3oOhf1 +FlKrapHO1O0IdBzGSRQQj6/OImH2o5X+EgFmIsOi6xaQTkBz6hWF6gcNLUGalqt8KA== + + + voZeQ4ay/TpOYdeo+oost33nlukb6uwEz/FqvVteMU5kfDz+C+vIQt1Kr6gmoBuB4CXqSJlgUAQq +idyqeY9Kv4AGbtWj0kGgYarSUkQi4uPS3yoiiitYHrohR3wU0cGN6DrPC+aCcoyi+qucCALOxvE0 +Vfiw4XU0vBCWlUgMWO4JCxLDDmMCX0ZNMwZMg1ewHB4a7hpux8B6aLTt1/CiNOHkcYW+c0v1DTPZ +Yd0iF6eeagIUdFuJBLFa64YIkfqqJUPlQ8eEqBqcSIpQvVyKGEV9X02OorbqlCA14WC8mcsRQyV1 +9nTcwJ6O6yyQuM4CEXGgsKeVjwR7mtNaH5wCtPxAbU9bMvmfL5e0mP4V9rSapWMDFYzLgT1t+qW9 +PW3Xqbk9bfblCvY0aWBPq2lZ9dQVNQs8R03Pgj3tlqIFe5rU29Ok3p5W07XyoWPKVvEorT3tmrpF +e5o0sKdJO3t6ScWWhX++no9HtWlvNO+NPiIR/Bipu8oXnvMJfBPHb2qDBfj3ovXVbc89+IJJb266 +mH16z5qj5kd3ClTjTncatH7nxS/zzcGgB3bq5LPXFlo2xuNBDKjYk3nUe/FHE/zWNwVqAAChbM9a +tjdoikCUBs25bXsatb+C6R3qtgiEwQe82Qf6tngiJKv/AizoxajWnH+qQOc/m9P2WJ4kaIVAGDRt +dP8z9xZ6f/QAwq2BNhCI5qQ7BWyzPp+O+10wsChec0AkqhVfM+WYIAZQiBIp8E+IJfj/BIH/i/4S +QpCtRrtU5zL5oa4p+B/Oi4pc4G7JX9ItrZkyDf4jTljxn7X3i1ENdwPqlvWyosRM/OpOJRzDTknU +IeCFXhojmfwF/fIaJPNe3i2S17kDjPYkGJe40xExxryiVoPbgOZeKuYV/wMxFfMidJFRStJslkWd +yYgaKg6hGRdFGA/nlw1Gwd3MUARvTfBy8rhgxA3JczCGCOZHotuYYFwmj/gfNBvQqAmno3ZNBQn8 +RryKeeaJnY7Gf47QH0BmI7ke9MbOwTS8YU8sC+T5H13xbSwv5BiWegMwM9ge0Ehv5MUN8FOs6caE +JmGgLMRuerNea4AA6iHU5812fyUIbseQa856bflzvMiYpLwX7++zLhBopPn3wgfHg8ECXYYxnkab +kwlAGl4c8FFXQF9ABdRbBaj0Ft/fwdqB1o3eHIGjUD+Di6nQGAzQ6pbuwPFo1oOpndJddoXebDJo +/oX/hCmfMQxJWDUwkSsPIDaeIFElrThM/ENXOfBMnFPl9MXFVD6Y2xdHldBIGiYA3mWN3Yuggd7B +SGI1PlbovnsPvB5vQDGcIEYmvqEEP8fIEWcV9hx40fy9Bx6A0eZ0brBiuUF31HGx4Fb4jCFgMq6c +OVHlycmfmwzeYh758aiz6M2dzEEJZe07ANLfmtApXT9zPesW/+iOLjodRJKwCxnJrm57EQpMKFK9 +DGtNIBsb1mVBHip08R4M0qNh8VqKMyk3Ia+jNMDfnAZ/nyl5YsX/dNsLOAT0An1rJM/g/W3cRqj9 +ZkLNKf/YCKONMFq7MDKSQPhkiISHIOjwkeNhkUNYawLf9ryRQH+jBKL+dgnEbyTQbyaBrla8hdnE +qDKgyo1JtZFi/3uTyvVd5huB9g+fkiuBFt8ItN9QoHFxOo6y6yjwvyz0ASbiLI3vfmUZeJcCvCFA +8GCz+O4aAuaNwIJz5n5CauMo3Ei1HyHVEnF8lR5D8eiOSRZWukFRKDCHOrHxFP7LxVpiI9Z+M7G2 +8RRupNFP8xQSgnjZCJt/s7CB4ZMbYbMRNhthsxE2v0rYOMk92Aid/92UdEkPf4PYoX+22PnXCQ3o +eKN4ApbNRTfkofMikmcYRhWfx/MUy+Ca0gSNPHE8jOZjf9ZR0pIc+3fht2QcXzpOwDIg6K5JzHlZ +1qB4l0vG+/vwYFfsitmwqx/HrlaqHrdhVz+GXQl3JhB0nIbHPohbwStHOcbo+o4Nv3LCr9gNv/px +/GqjXv0e/EpUr+D9/qSsXtE8Kvq34VfL8KsfHhz/r+NXP8WH+M9lNTJTN/2B/4PKLrniSxtuYsNN +fnig87+Om2ystR/BktYdx0Ti8FzAyhJxVNuO5RMMgUuCEvHEGlIe/6X8axPXuuGAzjjgJv19c7T7 +w6RBgsFpSBTPw4sF0U28CYo1uJxyc+b7D5+SK6G2iWr93YTaT3ES/MN2zUYa/dr8dypO0wwqAwvv +k48DxQqVwWM2oa7/7vx3jvjZEuhfJz82bqF/Juu1MwRobAeQPCw5Bkt7UCR2CjEUw21CkJbkXptA +/d+N/230543+/AP1Z5pK8DC33hvhOSBzYVBDlCcY2qC68EZ//jfpz9RGAv1mEmhzLPEj+MlGkP3i +YwlUKoZkGAZdHUPCMjPIHiHj/Or2yO9Chb/PlFxJtR+eibaRahu7aiOO/jniyOK2DSFOnIpvbuL9 +l1tSPzydcCNzfowltbmKdyO4fo4dBd5HGQZQM7afOIriNnd5/Mvtpx+earqRZRv7aSOG/jliyMx+ +ilIcARQsr3g/AMuxNLsxpP7lhtQPz/TbCJ+N8NkIn3+88IFBEcCC51iv5MRjE4lNRsu/XPj88DTN +f53ogD64OMsTcXjMy7FxnoTxpxxB8Mj3xsV5ChW7JuCVOvAJKRcPYXjixxUZ/heFFBsWf8JxxFyc +wNFo+FowimGI1X1Ovw8TdsWxNjl4vyPP41iWZDh0sRgPa6UbXTlDw4LqCcwXcYX1OCoCuCmYtNG7 +/372b3f2QJI4sy/BMGQc/mIIlmVwUgmZYLhNaPK/W7DxPzy1byPYljtQZ2giAYVWgo1zPPpBxlkG +avUEQ2MxxscZmoQ/SKjLU7JWvxFsG8H20wUbJ9wkSie4BLpBi4mTFIE6icYZktxUuP2Xy7VN0ufv +Jtc25xsbcfSj3Gz4fIOhgRKNTtdZKkpQBLCoohSZoDaW1b/7kIPfJH1uJNBGAm0k0C+UQAwHD3rI +OEEmUDkFLh4lE3F4QJcgNgLo7xVA5N9fK5DfZGhuRNBGBG1E0C8XQQTJ8TRcOoqPMnycREUTic3p +0kYE/fCEzY0A2dQn+jvYJk0htslS8TiKjWU4eM8KqlsHw/CYTZzWcuxmk1P3uzEsFJtK8TRK/mYI +BuoZUZgDjoKyxDAtlBgOrGAo8ngcsfXDYlL/YbtuozH/L8KzuM0VWz9Yf/77xdkPr+65EWeb607+ +QVtvI9P+R5fYw8isOMMCSoaxxyzBiBHHJL2Ga+x/Fyr8fabkSqb98Mzzf6VE2iT//SNZsUXyHx8n +WehZwrl/wKggNvVDlmRYvzRb2ZDdXEGY3vx4OupOZ+tiNxqgEouxXAvAf666TUC7kLwWM7MtuHa2 +K7A7x9+75JO/yC3++3KnJfGz4ShqjjKdNv/yVsbT3n/HoznYVk8BnvJO5k/Bf5ROtNmc//bNiaVO +Y9oczd7H0+G6RJQCoDPxJOFnLn5Za87BGEZIUhGi8BqO/+jevNbm4lP8zbT7PgDa9p36YXPUGQ97 +/+0aNb2HDxlv7BjoWYFJb1Qb90Zz+CwhPBsthvnxpNdFHfGUsv+Kon9BpI7nzXn39QpI1iYeMElI +L2ft5gCOuTttd3Ef0mDQq2pv1DUEV+h+TLv4FakBVmq2AfaNOqooOyI1r+TPfj9j3BHbLgOEjpRs +uywo2wquXe8NJwOJa7tR57Eej/uQAcPv0I1JJlq7YASAmQASNB/68Qhoe97yYPynlwWCZiNmNmLm +HydmZBq2ljOF6XhS/2x2xn9Gmz1jAaME5dgAQpy9NRghnBBRnhX543jSbMNn0oPWYDE1Nu0NLhbR +/sD/uWu69QPImP5oD6YCA0dj/pj/NfkXs+1ab9T35rp/dAf/YgOe/V8Z8L8Ik4J3FKh1n+vCowqk +Oy7wNZqjHcVLLOB9NheUQkHVG/SGDvfc3+FilLkOx9IEPnKkErySC8FcesHTy/EMuxpL+jlnOb8k +IdB0HhvdZXNUivR6aKc1p0rFPkpQ8KoxL0mzcNPRMF+YZ9d/JypmiKXFf//7l/esOeuvi32WuoBx +Qnw7Y52kZGleWUqgf7ZC8gspfSMHf+xWhjY6g3YxZWqoL2UI/T4bw5Gmjq22jXNiI+B/inb8C630 +5eQ4dG54xX2yohdEBcuhGSlJ8U5z2lc6GdqzKXKCUFGSE9v80Z2KnmSM+EmzhzwTEWWrz/H0vybr +QLEMDH6k4hwOhsQrAP/qL4/4mcY9YuXS4YARpPXqbFi2gmU/gqfNxWD+bO0Dd7ejUCgSjDxi0aon +OHSHIR9PwCtLpZm6iYA1dpL7sseJ1+Kok53O0Whn8AkLn7yej0e1KWjdG31EIvhxrgv2T6056M7n +XcRhay0n4ww8XoEPkRIGMPkcRIt191+P9rmn1naHp8DtZ2/eFb6zR1cTEiCQddqOEgzH0jCyOEHz +JE2rXADCd1flnPeq2xG/TNCJhOqS5ATNUDBdQTlE+cv77gA6WvHHHMvzpNrNIOXuKD9C5yDCNyxP +JBhe2SFJMyzFqL8lpW/zfzXFT+NxGnk1eJ4g4e1MerTi5RC+zA0WIkJp8H9kHOGRoBOU4UIoPz1r +fgBlsCl8TfIUj5HKkIk4WheWxT8Ijosj9PEsh/maHEjHcwwvgEzBAPByik54cymG1S8aSePljsfh +FR/oFUPx6IJ38RpPGCqOLvZkSABZAEvRPABLxQFYmtOC5TmA2QQCCziveo0ZFsCDuSnSaFVgwaNy +KkEYgmVJlqTw7aMkk1AtQ4KD12jDNnjuACzCggQWjpYE/wK4hBYuzTMsD8HFyQSnygOLJsRbTbkE +vhUlStEAZbQIl4XDhcPPpdiECJenaEo1ujjLswylhgudYojm4f/J16aKcCmIXRqhlxbgAqiEanAQ +uxyn7ggjN84LQk4NlURrBiheAZWleA2DiHMJjEsZ8UyCwMmkAnIpnE8gUBhDQCQk4GA5ESwgXM1O +ibNgE6lGS1GQCCBckcQojGUMl0VrFge2T4pnxI1Icyh9AcyLRviLJ0iKw1s4QaOL0yANiAKfh+kO +Ajg0SAauFCeuVJyn42iQNNgFcGigex65MSmaoOM4EZAheJxfAfMA45wSGgExyYq7imc4GuVfyE5R +nuUZ1ZRJcbmlKeP9gIEC5ifOmCQlsBCRaIaAkaCMRIamWE7BYeEoOXyLPPihGyUH9z7J8iI8Is4j +qgHrRvCGzAxoVXDSaAYIg5DWQAesAJbBVA/HSVHiNgW0R8HAfLBNGYx+AyYZZRi4fyACaLBKrHKc +JA3HGY8L8BLgJ758iARryxiPU2SqZAKsDi+vvTBODsBl0PQZcZgJjiQoJM9gBfA4jb+mOQKhREqP +ETcQjQELGwjtH8icwJBEdNIcjWRIArBqwvjSf0ZmyjBNB7EqYe8QcKODhYNDZKUtCQgJQWRZgjWE +KLM5kY2yeMnELcmLTJ9kxC1Jg35xsaQooG4W7WgCIAAvNNh3wvahhThsDImNA0hwyg== + + + CREOSQAGwWGmi4K7gWyiebzgkGXBXYp4pBKNwl3QAh+iRDwmdMw4QSYYvCgArbyaGUsiCfN20LN4 +oiBJJBqtDkWKPJMD7I5CM6YIRHdA6SBYFTVJkpnDOVHghyQ7E4jQ42gDifNnaMB74oiWOcDq4Y8E +4JlYKDMJ1B1EDytwIQZXehDxCcUxzMqEe1zck7CEIloPFvI3tIl4BjMTCi4bKTEKuIyC6KCVghPe +UQwEJ1zxuAgVUARDwpEA4kasgQDEzGEGwiElgpYYpbBOFGb1GGYcDhXtck4kTYqNUySaMsEBXgwH +mogjHBAkIKS4UkhwcHiwF4ZSLBOUEwABLId2kciJaZYUktiAgiXkCfA82pE03gycMH0GMyKpkoYA +lYNbnUSiLU6JQBMci3YzaMci6HyCR4MGNEGjaYiSjRblvCCTlJINCTaJfYIv8XrAzRTnMH/ieAYD +iSPmzoi1PSiRokj1WkFKRUqDpOQwgB0ins4laKD1ebG+kxD0E1HsCpsU7CsZoQk4c4xOEZsM0N4J +rIjBm9vhGAFPQXsW6OZ4nYURSre1E5gxY5gImzTix3gn6RK16uP3uRcZAt6b3scIGjNBoYGZ69Lw +GwE4gFhqdrre+diLzRE7WOrWMhRDr6oFHG17GZJRCJUFIE1zQ6RBu8CLAvQGzgEbfgTBB+rfi+a0 +O/NmRx8DYFapwOD/PCpgPnsnuk8QucDFx3wKmpm17Hnj4rzoBTyU9eYh0P94tA/Fz3Bn8lsARvcF +eiZ+QHGIsMH/KEAadSP1ArYqx5EqscoDylUL2jgSL0hLEY6aaXx7gyhvaKT3QikLmIooGwiOIBF7 +AJpknDI2lhMCg+QFPhFXaGuAESC9F6lBpAKupN8CvQ0JChbwLPWIgeVLSCYHgfkaGrqo/zNIQiIB +DtirCJrhKYrGgHiGMVY2WFFQxDHbhXJaqRrQUKZRJBo1WHJSWhxsj6gWFDAE3dqgZ6JqmuBRD1Qc +SBYzlU9Sx+OyaipCoxLSUpNwyzX/QvEttQ+nvgisO0KhLylkHIP1UJ4EijMSfxwHlHg0AKBLs0iq +CJd7aH8I6IcLS0GWKmm3PFBLcCYbQ9MElqYMgUU1sGuQNkJJ/xUMGKgmsxDRrLiAHBgAWjcW2G6I +74LlAswZcXkSW3O0OCbtDwyVR8KDR7QsQgX6OlKVWYrEG4EB1hYaExC3JNZRpP8qNU/4L5TDosgE +o0HryACVBhEaUCDA7kCqjSDvxUFpfwhgKSTekWMA/CvSLcfi+ygIHkl3GkhIDpMJwAgjKEycUvXC +ehJLq1QvmgF0FkcKC9i9yChjSVZpCgHzRry3RfNDgMtjlQ7tLF4UmBR0RSErnOf4BPahkLgDmclI +/xWIhMB7FKoc4F9ROSaBVoC+i7MJ7EuIA+1LrceKI9P+EPkKgYx/SNSU7K1g47gtwVAE1riA/aZ2 +CCQELqX+X9EFgpRuhkL7nhK33G235c2PB2MoAseLibT5YC0zEvs7OCZubH1R4q0CkvGp4jQcLVmf +lGzb8EATU+OVw0sqW0uiMsqLmi4llEgTKAxbD0gv5bU8l6UorIED047lVc5EU+cQy1o4hxKCEhYn +AEFQanjAZAW8Df5QWvEYHgXnTevG5ypOSh4chfYBL2m2op0KWEYcZ9GCHaF2bvJY5RSIVum1IuMJ +mXJJDLOWk5zWom9a9lYr3die8wl2eKM3osu72pvNlV58qyh36YBWFVOpDy63THDSOd3RCGz97gYz +IQn8qv7XsDUeQDD/hydQGQ+BVhmodAcT8D+55qzfRQMHumL7MwjVzz/AqKDmGbiq12GTxQBgzRvx +XvU+PufKB4XxnyPl39Xuu+r99UT5Vw5ox382px3ls9J4Kjy6mLbA3xfT5ugDdl2fA9VV8XduMZ+P +R4CY9M8o5bNGs6VuBB+oWuCOsB8bTL/z0UUfwPWSHqg+wI9o8EhwuYPB9dr9Lhwf8vmLg4UyPijg +HayUEuvmqydQW2HcXgwBCRWa86bH9xoT//Ym0V+Kcy74991Z9Xzc6Rq+PPAG/jMcjMDrSHM+n/Za +izlOcgFNMdX9L0CsAb6iVfuzN+hMAe5RGzG2RnwL/5n/Nenit4G90ez1j+Z0dqBI7lc2/aMJ1x63 +hc9nJu1gujhuJoxkpvrrH4qd0XjUdYCYwRhQeMcJZsSW4b93Xq3eqAMGSjqYGyCOend+jiZhPz9l +6zUt/4qYIC0x4Wj+vWZr0HVC+Lar+k/a6Mk/HG912PRvpmg4vfZiNh8P/15O9uvoMDlrwjgIKPPA +FnNKjr98X9ThzTU/Zii/wy6dvf/5g6Xx37wNZoNe+5/OiyNxUg4NM11eR0v7d/NdOBXObip/OZnK +X3/3VEiOjtN2U/mz10Fh7bbTERr+A6b02UWWqoM5iS3/5kmJ0Z9mE2qNgaU7hOb1xbQHrEUnU9N/ +8wNEPuJ19fFi2u7mYBD0WtjeP9ogIwzeKjE2b04/unOgB0CXwey44GTp9d/8zaps7bxMMaXxdNg0 +25XKKb/3Bl3LxqrJKlv/481zwo4TvKNAaGeWudz2711+20n1RmCcg2bb2bSUrX8430aX7UyaAFzb +kcagbv83b9qdEvo/Bxt2CK8SQkctTiapbP3DCXM0PnM1NXX7HyBv7Rnv/8ykVQulv3s048m8N+z9 +F2UW/JQxASv57x7CsDtvdprz5qrjSKw4jp2OcP7hZNcpGqOPH8+6nd5i6L3qzsaDhZBTIoHJHpOk +VzpeAWu/mHhLA7ht4RldbdqFqb6yu5djWZoVZpM9Tnib03lr3Jx2vG10tEx6W9KoJXaCuhAH5e2B +UTTnXdCwi1zUlo37o3G7P17MvR/4zBotqpxTBkdw1p19eq+aMyAFBQJWzBR/wVIMFTcfNOX9QCdZ +ztpKGgRNqMZxsZhPwECtR0IpICulGxhBr+OdCdfHORiFjGbbFVFMzratNDlStR6IDKZ/dL2N7n/m +3mKnN2+2eoPeXJDKJCPB1BNTtTn6WDQ/ut7aeCIuoVas8SJeOpNeFDcRQYKRTTUkMkSXEqgeNQe9 +mebRbDIWdgAt+S8mzU5H2ifZY292MR9LK6Yn24R30pyAXTDrDReDpryK0rrnBt1uB9qUN/JmJU3x +q7Zw8tPxJDvtNnHKsk4GBuTYPhId9ROEcOYPftCU/hcRDaLP0P/JG1yYrNQb7EDlOxAGK65avjn6 +ozmrS+hQEgLhfZc4A9iUg96o652hROGZdeOJSD/jP7rTCTzwnalXGSJL4Dpw0JeLJqQubxVfwqRl +EEbjmAPKxC15mcJVLadonSN/dOGthN5Wc9ActW0m2R70JmDtoFf+P2BvfAAKEAYeIJkoWA4FI+1n +j0uLwUDE4013OoPCdD7VdVEv3XrzEHJj7M0KFGK8L7R/E2oglcZZ1Xs963qPh3CDZWcoqACyylFH +S4xSe7mJEA5Uh9c/iiTB87AKlv1XWsll3BSPC18UIe06o4ayzmGEBkY/HvEDb30CTJ/pDKB73ms3 +B1qyMv1AjjXR0Zf+G4DjfL2u3r+GsFFSqNL8Jq3AHo/ag0UH6MdDSDFaBmb0RXkMr/uHOfOAHbUG +XQdDwtMtDifzv/LdwWBmShjSJ43CLfRtVhTOQKse0CKfNScNSaGhHLSujtsKjqpdce1uGU/+0tG2 +BlECMr13ZzVjmJr2KPkYY9J7hpO3df0q21yPev8x7FjZ6LY36oz/nGmoXdGip5Sb2hEmVHirN/+A +Wwsm4MsQxiNIKV4Vf3b0jRcuj5cQFohw9RVptKx2H1HC+JxOCn9FC4qKq48YYXyMq6/Ypb7ilvqK +F75yh8K4ho4sKMKYoDRohN5mO3oinH2CB2i8xNbfPBGESE9xl99Rxri3/Y5e8jsTurL9jtWumyni +DbmOLNHri9b7eNDpTkXPIHw6C2rFrqaxwlxTc4fCYgJGAo0veSy57iegKoV/BjdFDQR6UwvnA0O+ +rnmntAEU7zWcs/ifyXg6h2qQUroqVOscOrRRKNc6BUnlNKp3B5XmHPQNhcsATm+m0HdN2h5D/+lx +QdlS+boB4w5gr0bjQyGgiuGp3zbGE8U76Ty4PBgD5fOqO1kMZpIAPIBvpcs6NBPV3uUhKzj1mzLS +OfSyF7wpjtpjAwsbvIFm3MVI1suU79C1MQh3UHMQLCgZKDAF2z153KT8pgS0qYbeGQxBAjPrtDsd +GQ0E6NaS+qkc+7AF0Is0dsOOALHPMGnptlDCOxrLhoa3N0Ia/HjWE7ux94hQXmAcWnhBlPYCaovU ++bxgKFwpDQWlNYKa4knFbrAZklOZIUrPBm4txlJ7m0BLxq4OjUtB5YbAH8FUN2hZoI+Qya79yIlT +qFirO8UBbmyOBH3bC8FsqyvNRyWucDMLZKnnjZvbT1yNYvyVPY5tdqMUDu+97bZiN71Odxw7GwNN +rwuRChRHsA+7Im5jsuM71h4PYHkAAFnPspXtZvNBtIO7QEQtCQRr8PAzob3sIXTyzaQzBK8HI8eD +mnQcA8cxfNIXpHRdkrLhZDKNImEXHcAgekct52PBu8TyvHXLqWzYxAnSui2OG9Cwd9UawrZ/joUK +b9bNPjXNdDj9GrcATme9j1FT7zTUNkRL2xLiBqwgooZjeDLsoF1z1urNh82JdVPcZqrZJ0at24Np +tD0ewau9oEvOYqiwpcS3W+jqITx/3rD1tBMFNjy8Q8dmAKDhO2BN4rVhSBQbtkJCQu/l0/X6Bzxw +nUQ/Hbb7w3xsk49hP9odQR3D2Q5CH+AtJK+nk2/Aos3hhW3CWKIUa0j3sCnY1JA3KwKcTIc+AVuk +N3of2zSbKi6usmmKPKWt5nRmgVzUsAVVLLCfFBzCQWOJSThoO1X5P+xaKxkFZ9p82Jz2Z+pRO2gs +jdpBW8WoHbRWjtqIyavnuJh1gUqMlFuLffw+mkc7g8n0fTyy2u6TWRQqZoCHzKzJYhYFPBM6ZUeg +qUL461r+ZxKdalkSEvhGLT+cMC/QTuBdsn/ZCE1yO+wPN4c47Uxn6h1vKIBQM9ERPZuZ99weRkXv +env4V9+CDcoNx/geZrUHV9c75jKWPUMtQWBB19F61ItzTIE+3/E+Beq3F7WnoPcPykYHguNSCCcj +aQfaQC2mN7IQnVC+2g0ZthFUFkESJIzZIBTpMvuLM5RZK2XEZABogYBvdrytv7yFae8PdNe1FV8G +38sqloVyoWLEZqqFgbdW1wgdOTqSGVDGq8ZmKK3l9TcXgtMPe0EJ2ghCUlFgStsKVZUSYdm2sxC6 +uNFkIAYVGRI3atMezaxQCtrMewOlhW3MP2fitZkWbRCPtZONU1EOGA0Zs13Vkhi2mQHTWTwZNWa3 +A9Wxm1GLVg/aQpZNRt2PpnyyaSoAgGI6sm4zINvIda4z+7RC4rPZ6U4VR5GGrdRyhDdSBQEz154O +GjL8Qc9CSQYNxpO2hWKEGswspo4adBaWBrvFDgafW29gLGIWo7YjhoBaN0ejsRxXKg== + + + hAZAJ0tWbOiVXWWuowJIZXvkJNCcFuvcLoZeBMKsVUMS4Tb2vLFQRBYSGDJOhDalDNmQGgysW836 +vQkwc0YWQhs2m4LdOJ114fCmzroVww6cs3rxC8XczIYDfRaSx05NBSfj1jEwBpQ0oHF+aVeUMHUM +yYslXGRdK5QEJxS0ZWDA2ng007rtwAi8F/iVwlWldDs3/+ieAfHfmwy6WTWabJ08itoIXsUtxmvw +78DZg/m9wpT5vKwTC2EQlt85ickw+o6C/dWw4oWOTmGHtfGgJ0pFQ+NBHCguAVGajocAiX+Op/2G +KJkYi+mdjUfj9if4qKuY5Glv5Mz0FQeNA62g2340FybgDLtiFFMWyNFWc15t/tUVzUx4ZZT1ssDL +HXB+JjptybbGfzjoEsVKmK2odafoU/Ne3S3PlawcGhtExlPVuY3drBAsCIDcKccdsFK9957IvjgX +CJOpwwH9m4frMJaThnRpjmn3oleEK0c0YcZlS6aUAgXQmtTuSYX3Wv2lozBIdyRTlR2vFoM12YzK +QRvqWM5js4xNfT1LMadad/PO2XhErHqWqdVETXUcKGq9SzW8QfexAyaoEGYwnhPQaL45wVGdPRvR +wUA4oh/IXFmQe0QnEGdNICXkdApnnKTQnYGhNZ1LUJF1ZKfWxGvA7JYURBKbc4AJwFiOZW+piQ9W +bN2Y9oYQabcKy95W1hhNx2pIV90P2MfMnjNrdBNbxow+wgGyPYWKaz5f+UTdftglsHluu62bXvdP +ex6lICIlX7IfTMPK3JbwAhkYUIgbn4tha9TsiRF2gcYn2Gne5rTrnX92vYLbyTsTA+H+/OyOvDMc +YdEcKQtveSEX9TZn8LGs+4ox8VEUHzJHwNXA/hovvBPAOb2An3TxnkZdY3AfsKpOT9VR2As6kz4d +gRnDi1YnMJnM20Mn503voPkXjL9vTnDoCORVs0X7Ew7veFRAR1UyGNzbCCB1AUY3fpe77828i1Ef +VgKJOt757WlvYruxUGOAEcRlGgpvjNWaSWaIA0rDMqqhS0Wz5c856RCDYu02Fhh4Vx+DZTRVMJDJ +RMF2bUhYIcUt5SiOp4CRFVdwkc3dQ0pGqwlntIIvMjMHRkl93hx1pJBoh7xYKI3y17mly8M2dtwe +oUr1wHpdERGoFxaYy+ANVgbzkm3oyPw0mg7gq4PZHFjkCynZ5//7v/+f+f/7f1njTPgM7K/36bfa +jj8e9b3wijaFCc/zCTkmUGNiyzOL5XriyLP1/PFxnC10Yf/wJXN0sfcYOrxN+Q+ad+ETeu8ikstM +y8PP5Mdo66S0FQ74871mdLbLXVeK3E4yc11OnzFHyeqT/ywzXbT5UpE6i/tIhtkhiFnhq/ARJnYz +By/R/cxheDLLzE6pmMeXOahuTcVGJ/PcR+WymjlkuvV8L5VuF6JR/4euq2rnHvTHF0q+JP9Qnhe+ +nnPMQyScHY6rs+xxff4ZSnM7i1KB2b3NfQ38tx5f4Z04aRkC2+UT7/zN5eNTtpGP3ph3qmyXfM4c +9kvPmeQsOgwVwr5FKVDuvHt8CFmlN6BhFN6fb/ncIDO4S77nPuf5T/6BVKHjba/QJqvfmcMj/y2G +A4Y8y798vIzBr73vwnHneCsXiX/tZuuRnREew12zs/D4El+BULvYZi8D+U/m9eAw66P3Qrnz8Fso +k/dfl/LdxX765mTn86Ddbvbhr16o+F79xD2TRKzJT3u7b8ney0knN/Ad+SPT0NMiW63vfcPxBzMH +J5+0x8cd3DxnsqO2fxhKnR3E+OFTqsfzsdk7nZ22j8lQP0lKENuFk9kNQBvv7/K3NNFJ9vKxJlhf +8iwViIS7uQFfG+IZ3Fd9mfzx4c5tMZxgZ2Bdjh+5nTSfH7+EDm86j0mqtfOMwKZHPjChNLe/A5fk +kbvlLkcQT+lcP8hFBNK86VQJ8nnnrBBrHu6VtkIPU9gLB1+8ICioicdHtLaPGfQ7lC4dCr8Ob4un +uHk+XHzDwKh76hiQ7h0RSqeLYapw9JES4NymDg86X+cvaCWlAQN4FzlW6AU0yp1IA3iWB0AGUlew +UZdBz9itXOEVoRoIyyOGe+C+2tlG4StUeI+dfhebTf9ujmtdXx5WCq/pbOOzPc/Wdttn2QZFg9XP +8s/3O+CbzkPx7u1oIaEIU62KTF/6MrD4IDqtiAt2Py6814sdhE8AthkMpXcObvEKQcgeX/GVDN3k +mLuTUmY6/bxmkme3R2iF4mxvyoHF2w+HcuPEixaV6okr8S7iCS8sBOXxHYRSi0CpMCBzxAmbBP+U +iR6Gk+Za48xBY76dbZzMF3pUalZSgXdx4e+mW/BZA/Cx72gvq8XT4irRLQX2JsH8J3f1UGwRh/uF +7nQaJrq11IE0EIwOCRnVcvb1hETUdhh5K8GdehotHH/xTbz38YLG69/D0+zFS+6slH8/iRPkaatT +yneG94h5GqxBOTfgUrcybG5eTT3kKo2dlGYMHh8YRfeiUO77uqCry0PIYWjiPXk71o9W264NfoXn +5cl2K5EIHTDnGowcHM/G7/nerMdBbhl5rFHBneOKPKuDbnJvCHbyVRCS11kodfJwInb68QT4GA3e ++qr75flrZ5itv50UYr1UoIQBvPsrXLZxNv7I3DSOm6Vi/PLO4zsMEcUnCR2TYnh8TpX2uOQdWPNF +otjuf++JHaANMmhixrz36K8C9pjyZ68Gk31lu8tmBbA/P8Nffe5Hs6f39ZHHp2Dh4vvXTIPfu8hX +vxukSmTs7xXes/4XlQy4KpVeg1ufaBqA5466YEuxLc1bYfXh+75K0ii+3gdCtDwuhhvtFMDi5S3Y +2He7oXSKo9HbbD2cGeV7vcsOnNoWbNIonJ5WIqXDIhtEb+FcPvZHuHnjLOPLDU6IKFyrR3l/8vGj +3j6TuWnF+Frl7IpsvVxn6b2t3SIV3H3Jk+V8NQN/pQGJkymi20oekeFA/kh6lvb41N/glugZ/DMH +mWIefYj+5OpV6hK+TaGvpQ7y8FkOg8oeRko8GylcUa8PkyJscgh4MmwOHxSkrnKw0bkMB/cC+1OD +yEiDT0tfHKAmcDQ1NCQ0BjAXACeLhwKniScMBwWx04DPDhAwuRcEQosiOGSjTtGfAsYgxLoameib +A/gWTeNIRiVuDAeHsTj6OLiUUFBH+JR6OVTMRV68tOXSOl4IzTJ4fJqFwN9AZMmw0TQQntToSKFZ +yX8iUFLPZXkMHp96LdNGJGe5JHjI6Jc0K9yp/CemMUPCcEAWsHFVmpVMKlqaxXMxRVYKzxTtHBEd +KXnOsPGFEVI1O9Xjk1CY0kxTwklSDeJIPZq8/C16q+lUWBd53ykoRrWqaZlqUWOIiazBVjmQRliT +mAcmUjyXEsIjAusU1YoxWNILQjlYfYhHCXbaiAGiqUlb0x0ZogXBGDuUOkBjvOLiZPAC/cLol2bK +czfRd8DAv2hB7iWyo+zV+8cpUCtPJxqBkW3cnI5KGZLse3xlX/kV4IQNcArdZHHpOyy9zhv7mQOi +thUq3txVRFEW2VWoEwqtQGslKdsBSoaGAVZfgAgOKUwzMgEMltMc5weqX/DR1JriDx6qpSzd3z1B +doB6QiFkIHh88fEJwRcj4XemcHr0zSh7yb12s1ej+nW2Pj8eFkPVWED9dlDKJHwT0ai4CsrGF+7g ++LHxnb3I52pQhxG0q6EKMcAChVqYeqYKZYM/aF9fZfmnk6vCyXT/zQhAlq08H2dPby+BniyM7NrX +L88uulNB9atyOSC2n6KS7RC1th2sLQeoXYi2AwTG89fP3dPC++WsHuvVHoHaXPzOY32bprYfrY0h +U1PI41MaQzKFwqlhC/sue1EqfN2+5ntfXOzgfej7APrtPglwkn7j+avOGA4uIutHghpbHzzLoAAl +C8B+J8uC25f8AenCRyR4hDu4pNNvQFG78Oc/Q/f5WC+dSgprpcaTyhbpA7KPlmRDGPAx5RrUKgj9 +oFN6BzoPqpjmBeJUDMTMqNhLYzqXN0CtMgCWhaz/q7V/xUAT/e5pHkyoEyq9vaYThfI9/w7M8SJF +UGXmTAv2civ4pDFSMI0VxW7fLgvv16Ey4NOlAhXsFPEORJYqlAEJzLheDvf6ZvuKL7087++UiqPF +G+VLDOPC6h+Gd2OPcb5dPcld1jJgLvfDc8HAX9z7spfn9ZtSIdgRX8jEPt4j+P6iVSOqp62JbCNr +fQ7UQx+sS/7zaSsZSpdfX0XKeo6CFYye5vpnIaDa197lPZuEnpaXXJ9KbckvJEcAkewMBwQUIucQ +2w+ytwNYfAZ9r7tnrCmdK7fuJHoZOrppfosdNPjMwen9NjAfP7fUsC+y9XLnC6xLakplrrcSaA3Q +CqQCC6oLSe4dvQB87OhztkCLnLgETBX08tIEIBqz4uuEbGUOrv1RhZOMYgfbB++L2le2cd28Bx0k +B0TpKUOD0VQiEnfWOjA8vsSgNH43oxhSatkQd68SmMPdSys9itb7l6C47F6hxXTrtrtXMRC4ez8A +JZeCtcFBqcA+UKH0/fO+HqIDK18BtqrYvbnq6yfCJ1iXNHeyKESvOpFM8vyrL4moBrddGuUF1yAg +vsjke9wrxO4OMiI+/d3YZ/flDeJzJgyuXEgJHPQ2xUIxT+WGF2kgxVSKxzmTu1jQDwDVV7NiaJ97 +V0gsme4gKXG7O9/xTPL2u3fwXml9ZJJ3JSUozLGx7Z5oeXxIYh+G77kKgq2Q3UJLIgDs9HkbrN/D +QaE7uagidYLbqTI78BlVOG2cbcvd8zeDagMIuqPd4isxei68NwrvHl8xPD5bZNlM9rHYrg2CGnVJ +8Ex++PqAoSa2+Vns/CbbqGbgNkxE9IM/DGSmkcQiW7uKPSd7L/F3sOK3+2BdFOoNFkepGKCY6j5Q +UJ6uS68HnzFtp1T6ewgW+WMr833U7sov4FotsvHW5CNKVm7CwjOwxEAfa+x+R0qBcSKoeUW2qseU +DEKSr3DI55HcYEi8A3rpP3Dp5MV95mCSIPVTE9rBdQEt+fjleN+0EWqS7HRa3/omD5ECkXjwl/Jd +rp9tFJpkbhDfiRNU+LuXSV5cDtCCKTiMjorQ+USqffcINk3hLHvVyHzraWNnlu+lzmaZZMnX5I64 +u3L+PH9zJGmHnCBf+MNe+7Fw3L6q5Zhbaq5b+JedLSA8iMtS4OSomqg8leaCEiwsYhQQ2il3cLqb +fS987DwzfHISzQN1qLcvg0JaHwT23h1Dons8DO76XiF1HxZbsYeJWvPGI4s39nbrpdedvTqYX+ip ++PI1byMfpB6f5XmxldsPeHzJsxD9mG009rZUxHJ0LIGtCl4qgSyqmAmLfz6ZEEhlp5TPPgMVMXN8 +B/hYIdxgJZ8hHm2iny02snzi6iPBvOWGYJI5wrQJFARNaCoFI6NwQ1LPgBXWuDnqZw7Tk1sgKwcj +Ys8ARDfX989Pcsz99nUl9cT4Hc1UUPNUUALRJ9hL//gcmB/FsXLfcZkxlIYn0NcJpg== + + + y9I7wER4SMggkmR867wUvK/Ns6f3ZEfRaer0vFPoDBNh5ZkFGFkAcPmL/ofMfzETHr99soqdKp1e +YIYbOh9/Fd4TJ4NCa7/nS1Tfpoel7GC0jdyhGnoBqw+P8pLn+dhT4fT0MIZVNeqyHikVyfdAKZm9 +2hYX9DYAOH8jxqVK2XSO803YwnFz4NPxn0EtCHDzfAV5abRwerydB9xSvYEOw4vafSlDzF/Bmo9a +pa39MAlM2Gv4TYICO4d+A9vwKK4AS+8Hgti45Bv8i3h2lfGpT98EJByUAsfDbOLz6XynVKid1Uu+ +CQOYy233I0PnHhh5LwpqEPglK1joDC/L13fyWfDfSuYwEg0a9gIb7ZWhs/gJNCrS+j22088ygdx1 +MTBrPUNGQmqRRczCD2gFwMaN3Jv2Uq/mqOB7wxAE6T/pQJP5NDv+vNhXWk5WOxWRvWjxWRK+5Hx/ +RKcAcK2oQrNefir7ys9xQC/9haLxvFp6Bquf2UWqCDqjhHoylzkrRC8+DxVUm+bC49J+MMwBNYjx +AVMiM0CHjQfdRPtGOILjTq6VM1W6II6o0kF4WzbgdTSmFNuTznspcFpOKBcZ0erl0w58McjWW5N3 +bC1S3PZHbrgd/1JoSpnK5FvclbJ8Qb3c0odN/uDyopatL64pvUBhp4XjYW8GxFZuCEY44EpvZ76E +uQZwkTy8Ahg761R3jJdb1CniiXGsXWyNKxGbdo292+di8+14OzcM7SkEtEhjCu3j6PwOrHRPcW6v +AabYd7qZQoHy/goWsbL/DVTu43NRIiP2+TX135X2FpNujlnkgKUDLG2FTY6aDANxwEGjxUHu66uW +KRx3LueFk0CgBI9Bj/G5UXbQHCLVqDjfO94Sez5ZAG1cr7xWjTRYQY2d7nQg3YWzl/uvQEK2h6SS +HZ8s5sTxY/lQsx+EuQAFpd1Inr+0FqW3F2oIaYyWDtMflKSU6uYU7B/uc4wHH9F/BMLhLlB435vs +cPPTear0OojGVL30XsIfYDVm+3zyJVSH50Eh7brQwRENFAKmmWX8/nGCvD2NZePl2RyGDQCF7rh5 +l5kF77YLpyfP34Xu4cu2vGBI539jgIh+nwD28RTjkq2LPadfw28TwLiqVEqv8+dIKePvNtSHcRza +KJjDiIZBDYjmTOQzDvoLl8sP8cZTsdXI3hY+2L2ehntJjEvkWZKUxnxKWJIiWguPDx1B5j8fD79L +2VpmkjybLcZq1yDHfZOJq0I73+wX9nuxNn9IF7vFh/fjouSeRE3qYMfXS1A2NbPxSHQb+kLKiG0h +jNUe+MZbJVYqLLLoWPISaBz+SKE0yp4B+dkI5voHhxFBQdFA/AAMrr5odOTADcwNBaCX2zk2WIoB +PtZJFj4U3FJ439gRsCzg7jp7Na6+cenvYF9pMkMc5/yH1WL4OQfsfY4ays5ZhCwge596AGPp7/2T +QuuuewV2W7pSvn+dvCEeKW0fE8xLiyP4CVOAgUdKO9z0snIEVJ8jwKJPv3NoSKJ3lLoMzCE9HXLX +tU4M7NTrcMlHBoDdfHkVLpxsvRPKGeDGE5K7+X7PIpFQ8lX5pAa21BjQWGnv4WNUeB8/h5DryNB/ +LbD6XBx6hxvlRXTykj19CMbl1YchAP5ie7H9Er+o0I0EHT45KL2Gb5KauUhwGsWxRmyr4bzlPz5L +fnjqHVcNWQIw4crZ8fcsBqM7LgrPvfsd5Wm1zACSJ82bM3n+KjP6Eui/ZyV/2VeqDCWzCBhIt7vR +wkloh1X2PJjvFtutcAdGEdxSR8LT4fYeXPhXqK8dqjzdz3zm4CWyyDby/CuwOjvAwo5FmtlxtluS +B4eh0IHsQebg+TrHj44bZOH545kC9n59kImJwAC/qHXA/usdggmrVNFiaa9cncjhSNGtvcQNx530 +PrhG5P6BKm5FcrHPUae5m/i4nYKxVuA1XTky39t69IP9EtpvfxeI3cgIiXd2K79PAptguA3U/etW +GXpOfST9f6alaDl1KFwBXROuznlLaLMeJ81RV5MUKNxnpb4OU3lF1p32KhbwrNAoaDIi4c1cH+9i +MJ8uevBAqqKrrqwKg/5wxVWYbye+86AYRuUTw7i+UJp944F53IoRsdBZCHDqOQ1/UczhZZKWXlxK +v9CLA/qoMc8By6Lcr+xcpZqAXu7T0lsqlLriPreCdCW1FYn5gQ4DuE//cCt4/pDYCn/2wKu39+hW +aJGsb4XP7gpbEeKMImKp+wDqHqxa8JKZUbMzMLhCH6zkW5rOxek4YLLDBxRrgw6U5LdE5bULLIvp +NJ1qZcOT85PMaWKWjlcOb6Ol8QNzU5w+PRCFh9J9o5TKptrkfpYfCb3Qu5ehfGT/CvRX5cymiycU +pauJXaj1aRtVZ9PpwawBOgkfEzGmjqchj2wWL81vqJdxf4/o7JGo5wsZ7PSZmB0C2PFFKF3e2kMT +R+tS6Edjs3iZiX8ffIE/ywPw9X1B3enT9Pns6dK40zL/wiaPX6KGnb7sngO5r+lW7pTrnZZ9xp0e +bgWmM9I3Ne60Rj4x21RyX+7U45O7nfnDZxGTTtnPQNN/XzTulAk+hQ6pD+OZbpdeGI9v53oyqBrN +lSjlTjMmnXI7u6NpMGXS6f0LUXo/r8udojhYqdvy1uEeefLaMOy0XKEapuilHtKNN9QpoMVWUb2m +t4CSnxbpKuw2qF/VwD39OCCDoFNmrCOlKpETOq35/ZpOWXb4OpE7lSkZd/s6ff4cNUw6zTQ5vrRL +Gnb6cvR2ZdZpBWh9dODgyXiuh1vPs53P7pVxp5f5YPp7d1g16jR0MEim5U7BuqhJaf/oIXNh3Clz +f0+UEsS5YafbpQ9+92pIXRh16vERpefnkslcuR1ff3SWN+u0SZTDbzfGnZaJrL8b4O9Rpx6fFsHz +nfCR0Ol9JKBB8NE5kxLQW3zql1SdPhwSVT5Cwk73NZ16fLPtSnfMXTUjFOiWn2jpt/r40DTplNvh ++53Si1mnBeJs/zmBOkU2snqux9/JzNf0/Mqw0/qBnzbt9LRbpwmjTiHnZx4jRP01uG0019n2aaV7 +/vgQDBh2euMffZh2Wv+8fGuhTj0+/Vwfy8TN6eTQuNMq7bsuZQ5Txp1OTraNOgU8GXZ781renpsg ++PGCuD06LRh3epYuvr5cPj8bdvp80T9GnUL5op/r1z3bKZl0+hQnnmeDiHGn51+T4UUiTms6Bb2g +bl+PIyNTBE999dCWSaf310SxNzwx7DR+HtneyjxHAB8D3Sa/tZtm8cq/Cp226KBm0wQfqs191Cnl +Twcq6plWibf9ZBZ2GpY7Bb3AbgHYr2+R6aem2k5n472U0On8KKSZ6dZT8zGIO83dk8dqRhiezq7T +W6AX0G1Uz5WOI2iuoNP8XMcKK9sc7vSIPI1oGGF4wpxjSUPvJvOnqFPYi9Dt7nTabI1gp4Sm0+k0 +2x2L9Huypel0xn4lBUlzlLyMatC7Pe6+NTyC/tBtvnLqQVWu917GSdO395fk8Mbs7SdRefMt5Lc6 +zg9Yb2HP5GuwBnuhvDiury6vecvFydeG8HbWj+t2JTf63L4zeo+ZYu04+WT6Nk7tX72Zv/1svvgl +jOnfZ6m9h7bp22podESZv21dvB/IbzUY43YuttutisnX8cpe5fB6ht+++78Tmm+vQz1ROX0nt5M6 +jF23Tuojo/eYyxVC/anp21tfK7Zl/vapkEyJGDN4/+Z74XdN337Na5OK6dv+DZW7lN/qMDbsl9Iv +Zl+DIV0esKZvTygmfWeOMV971KpXzb7e29o7fto3fVvMnrW6pm9PqKNt0hxj2S1qN5g0ectWiGJq +X5xzMnCgeRtqXM6OhLf56KF2V1Yab+X9rPyemTHhK7UFlic6/se8wH/efAP4diKYo6VXFrOe3Hh2 +jn+p+Bg134UWZn4rcpK4BxbmVwP+E4XPSlvhwlUe/nOL7DfJesM8QuiveZUTOd90m/KnahGBnwM7 +R6WPpXdoP/jwZIj2BrR0FDsidhYf+YEde7cArHV7D/T3fij1txPrpVpBwJ22i9PFWzSiYrfTbY9P +7hZZOiadcjvQznk07pS5fzDtFAiRL1Kjjynniiwd006hyGubddpRdsrUgY2s6DZ+nqsrOu3s7e3I +nSLtX+qU1qAXav/STMsDVafBe2S9KrtVIThFmXaKtH+TToE9CLT/F7lTMBfVXJ9NOwUInjHmnULt +37RTjw/q/5/Gcz3cilp1WvWbdop0CrlTuPdV3UKdoqFa1W5C7B79EhYimH/oDJ20e1kMR8q9b9KS +2/l+Kd5d2LZjPwW6E7hFDsz5KStwS93WfQsMIXauFA6adGkxFZjLXj2j2fGx3k4yLP+TngQ6DcFY +hzwJ2/vpSfBwIkEMIBDpRGX3C40inSg/FgDjahZhz7TMmoTu00Wf8E/4bCx0gFRgsQNJtwTjAZNL +TXAjjfcJsL1c7LNb8En/XCk1ZsFndiE1LsBeysrpvp0cCT4lMOTrGniwBxXaxb6IHay3C+xYMYPa +nhqBkscNDJg4YX0+9A8kyFu1lWQ0qH7iWDMo5ZBeF35Aumdhyn9EKPxoGncgQjngls+L3Kkd0uE/ +wuCxMW8wP/+W6fw8PnmG6B/TFRTXr75tv3470vz2BRozmiFUXq8tkOV8/caIPrFl4RBZFsDI/dxX +yRSUxwm5i8g6iLiiLJmuVBIZU1b56ds95g3xDpSbB4GSV8Y8lXtInFjj3WOOLDXrCepZz0tRzXpo +U9bjsSPd4tPxVIlAacgqBO5h1mOMuxeYLyYi2GQ84WIY/yPgjhwZ4+4+smXKts12JfLHGU7tftv9 +1JRSDE2OPrppnNmhuny6J5wmGA6kENLMSinFFLPq1qJ7wurr2GgR9HIzdjUhIw4DaAeYc3cK3Erb +UEnnb8E9MLi7gskyhSdkc9dfQWPAfv4lEUOYS+nPcSglUo6CkpFTxxgY6RSYESiEd8Upz75+3zVL +Tved9a4DsrK5fbewXMsdMnxNhuE/jyHFIYWOLABnDBRPjZYTYEy5oPAfsKCyI1pPG2B+EhfU08bF +pTQkxbjQXOZlw5Gly62Z2SQzRHd+HdNpYfolkS2+s5B+STplOy3MKevpx2cen6lgcqAzyo2BNvM4 +NxVLHp+b9S1DnFTca09Ge79TVvNpA2SdjWXBazGk+dGJqay8uBLG40SlA0MyV+jEpfP4nK0gsPIt +FQs7nV+1giOfpWLhYv3KtaEMClPyCsDqIwfjArvSETC1QHE7LvGEVwB2b23EuJmkUqtbGWOv0zVi +TM3RXI5rovbDvPFTneE6T8+W1I5V5y9gPBUjY9BMoTUU0FTu7nPLho8pFGzjXTk/2l7brszdfe+6 +M5TxeaxuJSvwyKQq4wZa4u6xc7+959T4kHRLLXbSM0ks27oRjBXDioYpGO4X+2VKz6xNPM1ABErW +D8WGCzgaiEa3XA4nNtteMRBsI4dMRNRHBbquH13Y5PhQUh1kJMX2UM+zVlTh0Aa/jg== + + + Ic0XXXRg4tQAmuCWhQ5jyD5MNsixtdrh8bkZ1M6SDEDNLeGWe577rMWyUwZwLDMAp/a++fz8DlDu +cYZ0la5g78/QavKyr+/rGB7q3a6DqApzsvg8K8ucQRULZ2j4mNjkgPY/aaf0KZxYWSHL+RY3NXuQ +lQSQ5XKLq5AlbXH0Bb2b6MfUG/wEzkW9xQ2tbnvvEqDabWceEitfwonWJasdjZVLVuMhGZ6oNXgT +o9jeJQumpthIwuq7dpOcwLiEM6fuDclK0g7lZKEWy0u4NwAdfFNoQihSRbdaztdKI1NN/D4en5WX +bngCD3fvV/L7QLTY+/o0rMDEXwOxwzmiZAXfVHkaJipVOrPQqtKADsydiQJPdqBMQyyfalVpN7jD ++hgaj896PE79C/TRNe/XUITCFnMlCE81mvBy+yV5GbSemj2dn8rCT5IvS3ijJ6dauWc2IY/PgtIB +7aiF3jIM4Ojax3ps1twZYl5tnPQejagz02UBdjSCzk4OKXVZPBeFqIOHVX5l/AacFXjmhBhMd52C +kvNgPFF3Pm/9nO/qRtJOfSrq+AgSADPztxp5W7FlYeZvhcBcbD5jewlsGo9v5UMKtGrWIs/jGI7a +kHQ3GuFMHMNZdQdiKJI1KUMRebIbOO7lnmTvGwBTnRC6E6Lq80E/0i7CAbXGmUdhqms5Ycij4FOP +z34bOhA3EBgVdX3GZ6JEwFjOfUeoVKifyW+VFNNytFk/qONos772AM8BRzP0kOQBYjLfq3K0a5mj +idarGw1eC8yeo3kcniBBYMtzNGlXlm/Ga+BoYNWMOJrrvQ/guOdoOt8FhrM6R4NQVj97RXAsToPC +uYB0ihPz+Iy0AZUQuhlbWdDKo0NjHYUJX6njLYHNo/ONw2erHsCK8uXd/23OhhxqZnmwzy/mRpsZ +e+DdsVkA7GbLFZP1+EzZ7JLRD+rNfINsaZUlvoyCAlZNE9RkxmHs4ThT7U2hID8MgLN6CASCYmJQ +a07e7eGoD90dupcNThMQsHX4qrEsBPMLQe1CLQ3B08gq+r2CSJvbV7OVLb67W6feLIXvwlQa3rrS +7619sBDY6vr907eRLHQrxeCquXdp6aUYhLOKfq+AIsnC5aUYgmOg3xtBkaxXEzhOpaG1LEQc5ul7 +ZWmokoWv2nNi1At4upZwJMh/DOOwBFmpCp6SwzBMdYHXqcWSKFEZdnD6dne3iq9a4+cHwFbd3Ypx +Gext61hrC4w5UnfFlYS9mFlEYC2jjva5xelpHuDzJmbhuXIQTqcZkilFoNge2+2lFUz5aEQnlvLR +mCO70oFgonJ3HdPwPPPINRN7H4yMcoZKB5urNVtftC0AZnp2I3l7nAbUA2D07sFpdR0eEoAx3p2K +YRKDCFfyNerIB4uBmWz2e8vgW0wRHtF/72hQDilCt7kEiYy3rizP0uzZyNCyENYAZcvNPrYio8vX +rfDNS3ErkqVfYN5c0SiDDt/csnoOnVKK6TPoNBlDS+fQWWfQIZ68hhw6005RBp1ptqDLHDrrDDpl +tuAqOXTWGXQqrW+FHDrrDDpVtuAKOXTWGXQW2YKucuisM+hQtuAacuis2wm51Svn0Ok2riqDTrIs +Vsyhs86gQ/qYfQ6dKiDZIsOs5i8ZadvmMfDmmUCaYBcHQzL09BbsA7f3neVLlTQ28tLBsAWt9mvg +HHDq6X0sqKW9u6VTnPEVtAEbS+PpYF9FrupcUUnGB5wkg3W/ujd2ThT1GZ8VMOs4LGfzQ74+u8w5 +x/PTeK70+8U50mPuh2SS+WjjubIaklHKHJyLq6Q5R7ymqAkFkWN73CVQzV2FguD4McNgEPduYzOn +MboZbGV/1X1kx3pqHofJbupISLeOQUTJYM1X9RjjZDezYxu1lWSX7GZun1ofOCi4ZdEyGERlmtqZ +IUVNNoMqU9gZMHUIFqk/sWlR33aZj854VrPkyuhFu9LM7G3R5iGUrlJMUe7bmcOsQ3vbHiDL6Cxb +0sf0rjM7x2E/PtG4ScC314ZBs0ucWJVN1S7TLDCFpqTNA7NVuxzn8S3sYuBd5PG17PJfdlROK/PU +NPMkGGtVWh8D70997pgNKmOUomm+frYx8I6jCDpltQfTcP2c5vHFp3Y5MVbEoI5Oh8DWliE6lU8+ +zDJT3ACzp3jnGFM7WFfEmG2aqPNJyhxtKYypHb9U7u4+og50qmgC6w0yuZzpsjqfr97Mkrb6lbHf +0jpfTgPCBEB/Wy2RDUC8US8k/OfNcndXHBh7ksVnY+x9VBwbe2YAtDGKS4CwuxoFrLN0q4azVLml +VuiVsJcvokpjvC1gipu9k8Fj6ZKGWWkmRpyO7K1y5Dw2ac4OjjzRhKyvPPHozCsLPTI504XyBwpz +ByhXnIyYUfLXsTv3joGphDUlmwQ5Hdcxz4iaG0rzJfSxY6c7Xt7vpvrY17E79455mp02gmhpPH3a +eBo8GlPCnARcemRUQ1LlI4NBUW7cHxZDUm9meylmgSfG6ZCso9Ptk+KshqS9uyOq8f/ilKR1eGRO +kEdmxSg1oAnvOvDICGd8Nuk5u8no3ioeGYW9f7K6RwYACFhEd7hIQ1vGI6PLFlzdIwPT0DQeGbOM +VLv8PMaVR8bQz3/iID3HWXIOTNEDG86ekp2F78FSHYRaWT6VlWXzuHEnyjJ9dB3acUAM1jmJk9P1 +RDLAdUle+tfj1AFTSwZsYnqdpKEtGcCulC8wgczcu+QifUwXumCYLWiXV+c6aFYfoYry6hzG61nm +1SlSRy0yhe2doKeWl1Qpdq9Ct7QM1avp7yKFzxwKOjHn3SwwaT35cLCXdcTUWefDub9/bJl8OKMo +6Npw3flwK+RZuMiHs4pQXV8+HPRar7gDHeTDGdwIaprEtXw+nCoaSvzGv+58OO29ozgjbt35cLa3 +BKwlH051YuUg1HK5fDitLWZ2rAMz2VbPrIcCbm0xkQCUOibSTLd0EhN5M3YUE2m392d9elU1II8C +JFbPRkdwwnar7xCOkzwSUyhYH0Nw1pDJpYtksIiBt+doMLnO3CGmj3dW1LIxiXj2f+/rIp793zYL +odmEpt6eu5tVtqGcfKTwKqy6DQEwy2tljPiY6Ta8nzjdhhbaOMS3O3vRkNDWcxswguNu+5jkIwM4 +a0mELMScSTFbOOZXApvcpmUWZq2/Etj2NjS1V1pzW2MwrPdhweQz64udbA1qKSOV3F42QEQxZ7OL +hZfKSG1uvzpIInWYkdrcbjlxGdik+q0lI/Xpez0ZqRDOOjJSYb7Y6hmpEMo6MlIhHGfXQGtMYqO4 +PrRBzC9NdR1kFIwIq6/ehncrb0NNKpwxH1t3KhyK57eM6FlHKpzhuqw9FW55v6UaY9a2uwu7coVU +OOUdRCgZ7pekwhl4FX5BKpyxf8yhfXZvpRgqWYHy/mSrxKdP01hVJzfCq/WxfNTGLHIa6AVBsY48 +ig4cyBCY+c12LnUY3SXDbg8XFNno9w6PcKxu5wWs3Ejkyb3YJzdr8+qeTK/D0QoH0TtqIB7k/Qur +xoWN+hPWAJW4TF98lgc3zdfCTmdRLCV2My+lRrpWzMTmfsD5S40j/h6VDS88FKeZbIVrnORz0XY+ +n4udwiIE9YkojnwD9ZAFj5M6F8so6wxaSUKO0qN53ln8MllTkpc62e2gfXGmdD4rOmU/932HW2Oz +DDvm/s4q2a0TM+2UKDVyVhl2voveWdOs0zeLTsuRhKJTbS5WMjRTeOG0yW7M3WdVqkyoSQHbDlgl +u5FRTafqenwHQ7MMO25n55tbPJkluz1aZZ0NrTPsxo2Gaad71e5nx6zTrnU9vss7806L549lU/Tu +juiDV7NOL9UZdmhVwYYVZo1+CXSedNjuwKgd9iqoWjJPVUcQmWANtxNEZ5UzUETPRSspXVoMtALV +ynfsIORWrcGGRnguqjOi2t54Pak99hGqWq+JeR2rbwdDUpyLWQzKLjjVLs4DW6/rrCRnVHbE4E4V +B94lq0pyrrxwjwXHIZI22ZDoTkgXcX12ReQs4/qc05NNETnT+RnVfbMrNuJ0fva1Bhwj3a7OiOYu +tRXqxznfL+WueSEi03BXpwXorD29y2TTLeeHcZtNZ2QHiLU415dN5/B+mBWz6Yx8gtr9sno2nVEu +3bKZj+bZdEa+eONI+1Wy6VRoEfas4f1jK2XTGYGyuSFkiWy6JSWyy2w6o3MaSVauLZvOKJdOae+v +J5vOKJfOYWyPi2w6I1+7WIF9fdl0RquLPL1rzaYzUm6UsaPryaYzyqUzuW1+hWw6/ZA+d8w1pWWz +6YyUU49v3dl0RutnEA21YjadFpRtTeGlsunMdMv1ZtM5x9gq2XQaUNoz8TVl0y2FMdfZdJY5VmvL +pjPOrV53Np0RANDLmrPpjE5LNDHwa8imM2IPaut1Hdl0Nicja8qms5cv68imM0KGrI2vK5vOLpNr +Pdl0Rrl0pvX4VjcAI7IBqKov5urqJvMqXvoildraHA4Tn75tNrsK+czYrJbN8vXqdEOaw1Oedder +M9cunOFpHvK7wpOMJVUkJMzJtFUsHJKAKkHBJOvZbFCaITllBQ6qy6kPppYaEsQYGJSrsstWQzIO +pDDlMBZ4sii7bMIyoRRTW0RH5MlMYxHRu4mJTWFza8+cVC3LqtDdymXuFPdcOVTJlylzZ1pd7tRR +rpLDMndmmVzOEukcBUhYxyfLhe5WW6vy/cRJlRlLL5WjMne2HkWImJXL3Ak6jHWhu5XL3OHcN5tC +d84Ojyana7jnij66Jq0X0XmexenaQpQmp7LKvXQuD5haKuiUPk1PeWCBOtvYQzv6hGl00Hi29MA7 +SqRzEtHssc8wNA/icJxfCHqxCDt0EUQGsWPq+lNTsrMKW6DnHb82nwhemmo6Z6O7oczOe8q14ZKJ +XapoKEBUNvHgjqOhACjb+DHH0VAAmLOIbuvAZsT71pL5uPpRCKwoaHEduLD6DuE4qu1qBEUR2VVf +xw5EUHSZ7IaZwva57AiYo8RasxoQ2sTa+kifWFsfre9WQAhsLYWMEY2B0TphZkrZZYrKhhEqbeu9 +WsVQ7+uPdGEmnj6C2tISN4uh7s76a8lMkW4+dq9J6EFVF+uqYAhe1MyPiB3v/WtXharNTt9g4bWV +1QkMxSqq0wWcNdwSgOGsWq0aQxE3odENh+5iVa8dJDK4OuENhgy24Y2DRAZHHviVK9yJ+ZVmNe6W +2IYGwRXL1q12V+HOKvNxhW0oEppQ4W4tlfJs84mcVcpbNZ9IqpS3+ja0qHCnzktykh+yTIU7q3qv +sMad+wp3Tm81h9lPqyfWPn3Lao6Z9eo4sRYAs1dzPE4UHVybbrnEWm3mI7uq/wjmF54ZpkO7u+cK +wVmCb+ruiIBw1pLPeUY4s8Vs4ZjnwmqSmDx210ygcnlu8tuNkpiUp6KQQYR12zAZsFkIB34tse6b +wzQmJ0lM/tSL1hJVSDEnaUzqSdr4TmVQ0rqYpjElA44y1C3NdmlXJgNOdqWTJCZ/ag== + + + pFW+l7Ur71wlMZlFEMHaiRaS1p1ieCfk8K5wK79GMTS4LPHuHteAWEeOaz5qfqsYtF/cVqRzVe4R +odJcH7tf39VU9+j0bU05rvemV1O512FaM1flHm0q5cWWzHFV7E8pDMNB1rN9jisYkuOsZ6scV8ED +BBeiyhv3J6p+MOOtkmoU+mQ+Fzu5Lex0T+oeX+EoVG+kxm8hDvwq11B2X+nuqdSh/OntAhY8yLWr +8B0Lv1RJeOdHV8pOVflwHt9s5+a+pnRVqeuwJfOP9yb5cEHzJLzp4i1JqnmyJg2P2DfL/eN2dvmr +4LNZEt6TaadgLtulCW06V6K883Bt2qn/uBX9MKvDFpQ7lTK5ZATXWErRqTo1bebn9+Q6grQmyzEY +OHocGHXq8UEEa2vOqdLwmtrcPyV6Tw9rJp1yOz7mvPAm+2C1GXGvFp2WdznzTsuXOw9GnaK6b/GK +KrVS2+mVVR3B0xvzTovF65Iqsgt0uwvfh6VfQhLmYj8VU6++STs6T5i2U+ZXEm/7yawDiKHkeF6U +xSSY8z2jVTqlwxrB26MWnnkLP7Ek6ByGTQKkskF0GqSqYmYfOOlANgPYKW1ik62HxDwlSR9aZTok +SMnmg8o7SW2yT2yarasyC3Lo2lRmcepJKliHVpkuna4yC+ig7iYEzSrrTnPz5ApZaTYRmhhLHmf0 +pDn0cjs/yWsN8+5cV1k0GZIuSku7Xxwj3VWUlsdnNShzP7G7IQFuaR6nJYxHFxurYVfFp/S++vC6 +qK+ZspwpAWAfO7j62sYH+1Jc1+WN95EtZzccOshGsnQvOz3leSmuchOtnJOouzJuqWQ34yNrV/da +vxSX9Cyrb9GEWYCrXkJrdFecab6YndWivyvOwgAy9o+pg0YMjlibJVf1Dsw5TGltNnKzpOUwy556 +44Q7s32MTqzsy9epRqb189u77FA9PlOvCvOtCyDox6fu9RGT2k/+1J354aC7RDJdPYsVyrJZZzK5 +yrFKuLrnQDEkTf5Lp2zlO7bVxlVDUoTqC6fVil3rMhWwv+sglVN5z5VFKqBdSWOb9ZNP3jtl+0Qd +x8SgqWtsWGXGBTC7Kjp+bXatBTCNVFkNY7a5PM4nqT65XBFjtvV0XGGsyjyZANOlCxtphwLGlswC +dJoD6PgeErMEMUc5gBbR6Q6yAJ3mAOr9yW6yAJ3mACpvOHSfBeg0BxB5rZfOAlSRioWFqY2DdZcF +6DQHEGJs+SxAGZ/WfEOdY+U2C9BpDqBkIy+VBWgyJF0OoPK8Eo9HP6vVi/I5r8i2SlE+xVx+YVE+ +nVfhlxTls6vItp6ifDhnxFpBWb0on8dnoBWuvSifvj7yryjKZ14feZ1F+RzVr1ylKJ/SqwAHxZkO +SkCRXWqweVW/1e+GOlnH3VAO6/o5uhtq5bp+iqmt4W4os7p+7uKUlq3rZ13Vb6m7oQzq+ll7hYwt +cfd1/YyJz/JuqCXq+tlT8jrq+llHhkieqxXr+tllcq3JoWtZ1c/jc+XQNa3rZz01je9i6bp+qoHo +qvotUQHEsK6f9YSMIlSXqetnmI5odau5c8Q4zpQ1vAt6ibp+1jd/SWfiK9b1sxR0eSTF1lDXz9ot +7OoGKou6ftamrmEU9BJ1/YzSJOWtt1o9vjXkvLuq62cNBfr511HXz/pAxeMYziqJ79qM1GXr+hmo +moqqfsrqDMQKdf0025BQV/VT3dnlOj2FkOr62ea9rqWun3VVP4mSV6zrZx1wrchIXamun5y/ZUSL +mnuulq7rZ41ApMGuoa6fxV6b9ek11ePbt4biuB6fTTk5x/X4VqrrJ0Ex3D5uszl0df0s8h5so227 +buv6WWvy8MaDddT1M5PhN/qTxOXytxyo8+JJot02tKvrZ33erI4iWL6unxrbWmtx2Xp87oI0zOvx +rWH7SFX9Vq/H5ySJye72Bn2shrtSfNqM1NXq+qkc27qqfjhjaPW6flKqlFVd0ZXr+lmrOSY05rqu +n3VVv5VvbRLq+q3o63NY189B3usa6vpZV/VzXY9vqSxcDbfU1/VbPhleUdVP0ctKdf30rmRlVT+z +W87c1vWzDu/SSLGl6/pZBzppfEpL1/UzWBdFVT/re+Gc1/Vb3m+pxpj7nCcTu3KFun4y4zKq6rd0 +9KCmrp8lRSgqgKxW189aMcTW6+p1/awTYgWJvHJdP/UktVX9dPqY45us1HX9zJUgrMPY3GTlsK6f +Ix1m5bp+ypXUH+BYZNea7E/jun7WwsEyi3NtCbFY7scMxMODlY52cW0c8aG9V+oT36iokZXgqblr +1zrwXpO2qKImkcbk05t0aqLMg8e+KaGrgEpCRscyYojYRZeT8HmuskSrM5j7Rs0+t4BYOdkKPZ7v +ErG7Po8bwXyqrd2z9HGUCIy2Yu3HCUNPP09K6cFz4vJ6PxAZBv257xxR+TjP7nwvctzWU7NDg19v +GR8bP6jsnV18X7Hf/ftHj49no0w7fla6i55Gp1tstcy85a7610ed+hl3+9nonrPfN4Hu++5tNsgU +vrYbV6f95ODwbtw9Coy+X/lv3zQz4s63bs+P/Lt0oMz53h+Pj4OLz51HZvzUTQp7H+V2pq8b9Zut +aOgls0V9fN+EDml/hijlTnNE6b19QpS5vavp9C0RmM7it8eznReuNWNbjzUp07IRSsUit1G6mtgW +096+YtPZ0xgWm0vs4NxqPQ9R5ZcePFRfE9n25QQa1FIJSFhPcvFG+vazmeqJEbIQMsB053twXejd +LdO5oozGQNPfre3cPDTSu6NprLRHMR+LnUFnqwMzSU/E5NCtRXjCnMN4tbMRykncypYaDR+x2+0g +e782VqvsE832AVOr5RVJc7K/VTE1wNaM8JDmfPmFx1d4KHXvUAHN/HP56o47z3e2M7H54UkmNusc +lBI7/VrxNkO/ALSN0uXBzd1TtsJttQCcm28RLC6fGSBDfR6mMt6/ZA6qW1M0q+xwDCk5e3p7+xoq +3txV4C8w4dogCpN2w9isT7P3U2Q5EbF5AEYjvM4xJ46xUb/4iwwg3zHACD8Cf/L7KOsXMJzjCfgz +FUYcZscPpNjjFDzIR8UPS7FSkTqLA7AVIlQI+xalQOX4mAz7P4fFdv87QcTSfBANFA7umdzPkwf5 +XjNGghepkOJFczef8vjEV/mI/IrKPVwfiS+OY/ILevfgIyu+uCClFy8C2sqpffmZ3DOU++V8WPEK +9i3AKYNdDzCxD2b6FIJzDlLPsy/AAMtXJLoJh6wcXdFgupf7ium2PkIQs5cA5alxn2zv8knpXAyw +QkheObIdSZGwUQzmLQ3J9tExRNslKXxzeY3AwqTWwx3YcwjmFiOxtEsFIwzU/hsRuVMqeJQ5wL0c +wAPvq9wg+rGfrbXfq4XT4626TJLSsUBebbj61AZnjgpWSodG8AAlLwvxspqSIObYeW23W35+iH9k +64vdXvGhUyPgrEhEvZiS36jnxUtGWI37F1okrwajmHrhiG+L++A2ghBIFS7zUALexkSyvwWwW8+w +NtstKai77K2gXYzhb1r6xWAQxYMhB/58ECC+tktwSR5i4tcPhPSLVIzmjXrpiaN5oNELj094Vejv +Cvug/8XiuaglrfrMdE/FZiQuYMJmgKyEjEbDZpLPF+NA8TZ3dpILDqYwp5+r5IpEtKFnM9oqvX5E +bYALxNGNrkHpXAxwS2HH3/VDmCRzdy8zMKvtaKy3XdujdxPDOUEEojNhuoC5oLhp5J4EfzJBlBVM +Fp8y8M8k2Ei7X2nIN8KK1X8C39xAmqhEkRoEI1WiyHAnyy9RaJhXYiYumAohEeSewp2SZk8DMFT0 +mwwTozePT1yo032878J5X0t6JuxfoMPB7XwKFp6/qeTf+tmOiglVCYJtncKFOFXQAVnOfUON4+MC +YewcdHA/RpwYTv0pK6glgPXgZ5i5QoaDJY2lHJKds4aR9uIyBtRn8NUZVHMyQIDHF1iv2WPHJYVy +h55t57Pb4LOrOWx8o7r7QNSUgkoQ4V5RAyKU3z0qSgK6QgUS97SssqFn29vpozLR8Y0K02lqvK9U +IYB+gO5VKPlkEER3m41pQNzd1bISiF5AtVXKA4jUAF6/4tNBhN47eCQBjgthSDmiXYmeQhqL4qfP +s1e4xZ9mIpt5naswv+MXyhxTH5eSpvQsK0mowDRUNbfhi3uEO4We7JeVlv3M7X5T1E1SlKiW4PsZ +gPjbZsraYsuwEK64Lost2OkWXgFm9rgHpVjpdUu8IyOxI4xncH2uVN7vwyMBY7kgdHrgSyEqz9Ht +r2uAp1AJdBqNoA2uvy0CeuHAyMohAQmFWV1CwpMSCYvHCwkJmhs7QgoUPE7pluLuDgkFHl8w/9B5 +EZEAxqNEAj81RYKIgv1dBQqO8t9jBQqOAoUpQgGgZKFbsf43WhJ7JAAm1I/hTmn+oi+ggFqQRnSA +b9W4VyMhJhP23dY4VsRImObuH2UkBFq7V08mdCBcRytVLQd8zIiULEGE3NOiOnJYPAeQR+F6DBEj +AGhdHIOILrml5PjkILHiaoTNaRpxfnEUFjQdDpuAcIQHxPnDUQfToDOXgYAAonl0oR4DaT0GbFda +8qcwJYLgduTVmG2XT/OqdrF9uR0slV4zqfMOFiewKo0FV6ex2JJjUNAYuSqNBVensX1TEA4AYBqL +OCBTFQjtNGxQKdCYJSaIFSkiFvL4HGDCEoQTzufxWYIwQ6Wj1YAAokpvz1JEFXNM2EjuG4IgVp2G +Ymd4fMtNg3I1BrT3taOg7fdnhUmd5UN4DNM0q7r0643SygBZIjvFBBV2PwYNt6RWJSoqakQRrrgl +5US5MZJDMrekVt3iFKn+k9LwMYoWjIVApwEM0swMe2SQVSZr+unybQBbEbJNV3xJHgpm30V3JNi2 +d/0I9VrphIlY8zuCrGF4R8TsMwK/jiIbhD663ka2n188Ttzxo6AfZApj75pkCmPfmj919Q3+zETw +n8+zLjIU/fTu4eFb6TX4iOq/vGQ+JHM1IHn9nolOIJAU7dPkvsKxpphBOhNWuNX8R9W0+KIUlV+g ++y4kFwwwdhUet6ObSU70lCXRNILKnsuZkMKtpui5XJIdei+oJjTywlVjglehfEFA90AIZ6YA45nC +llzrxdcUp3sZwo6z1oSEZH8ZkdTrXcqfDsCkxsuo4Fvj8pByLglcXW5KtisX6IEAtv3wSAo+0ftS +KHZW70N+0MDmPxXkkh2x00YU90L8/7VdeV/iOhf+BP0OYdzYbJN0dxsVRHBcGBEVdESQDjogKMs7 +d/65n/09JyltRVRGvXd+V5vSHpKzJXme05qYdyjvlBZ20m7ianOVns6HG2/hY+Ott0SfntVpBbv3 +E20GidPkKS9KpBGJTJsbrKXKq31ro2wcbtk/mnEfiquWYr7/Vi54YI3r0L14YtRshwjJWTqKuOXX +MVWcqT7YVi0wCQNlb45M/6hT5v7R6OJK0IB8J1Gv+Ue8ZaIAUwgAH6tVN1FiVcX3og== + + + 9Hits0/l3bXRsS/7OnF+GwBrPIq4rTZ/BR8YQRQ0grFUBbUU2YkvSoxAett6JS6Brp3LLRHxyTGu +V3rwL4HATvnIuREPkfMA7F4SmBJWHcvVRT4hPA/LWXBmyKcC8AcCezP2QygY+dG0eH0fRNhaQbs7 +H6oSqrpLr6REdtLnV3f2pj21oyxA8B1+k14b/MCPyv4eeQJoF0j+BMYuEKeNjMgwccgwjfZ250s3 +x9JXtif0KcbyjYa410TEo3MeCN1CMnOkmdhuOe4I3AsD14fQdlsGauxQ9ek78NR/NxSH2SZxOLWJ +djzqeP2j/l3rrkvSyqqibRUYK3ebvVzf8068f4bZ3s3o3usOyQrRtkqZQsExs95Nr+kRUYNiXtsR +jEFCa355TZSJfFJ3I1Ho7E93t52fO16vZ3/SykakKkds8ZceTh5j6dtfsDqJpW7UhVi61ryIpXmu +FIvnB2lsViQMEYzsOR92DU5iJeeyXn97tJM62D+bANDFbOlen+yuKws7Z9ve8aY2aK1p+a3qt2w1 +d1ra1Ia0J5CKSXBQjjQgK6dwm/0+Hy7GEmuHRmxZWzpFjjMLY5nPOlosndjcxLN7sdT3L4c4vkP8 +4GtseUtvxtIH5/lY8nGuj/7v+AhSboSFcjzlQ8Mhf5Or1cYxWOyJwFBkCLF0q4XI7umjn2MRJMa7 +A5BYE02sRIv7R7+8pB9F4D3RKBLNlThGY37Zzx34Yg9fxM/yynCMOBciMxXN14fueAqbnYEK+Sdl +4b9joEL+SaLeszNQ2ISlRQyaxc1Qds1H2Ys5sWRIQmLztoWjIQvviGqqfQfi/whMWzzScK5Nwxc8 +zkOzLMQmpXG04oUezIepCBfVXFRhQqrsh/P49fhbhLNXQWNZrb62uNLqLpVzazvGrwkYFOsRvkeL +q8YVVkEtgAs97GZCidPkyWcbZpY4fo+xkJjYc767zm5uc8k7yRaa6zE/mirnLKCZ+BP+JtGpzY0n +zboRDL0eda/GkcinaT/lNsqa7/aNc8oa+4UEHMFyQ84rjSu+4RY42KpRx1oH/7hpCBG+advHQuKy +KICC5vl4mdS+oOOjq9DbGtGlXLupRz64iuk1GIuY3a8PHhfEWJ7WY2SiNVTgtdE0E2SBt9MMZktI +NJhN1vyyio32V5lr0o8PR9PTTJDHRJw3F7VFH8aX0/FB1x/ukZccr7OX1ktJn96G1CSW3ejO1F92 +n+3U5VwLyQVnoHxcTszeoI37rXzSTynsi8azyxcpQW8H0/qy/wyw4LixRObcX3/tfkv4z6CZOW16 +mSDkn7FDYp3puNgUMoMRRypMnVijS049PrFAl1Oz3AtArgmIJjXKrj9kaHZvrUefZx2YX3yaaT0p +GDbJRaWE3eSuZ/dKYN2Hy/5M/bCizcxJStnPnuwI3v0hzRj6E5Z+9Ne1X+EWcRqxg2+L/j4mdvqp +CW6o31/7WopiH7RwmVafirjdKNeSOwGJVZ4gsfDcXJTCqvK9CQqL7qwdSQGS8fr+XMToiYj8Yj4a +KkZpaTxfI2+aPuT4WlH0p3wKj9TgnCbOiXcXboDXpkuPuL7syzQDk2N1YtH6/m1x/F7UOKJOfNYq +5jM5q/fHAX1UeYU+wsh5mz7yGeJp3Il8t+qM3MkU5iSCYSoL74I4xEsNpQquoioQjJ6vgmqoAhgL +9ieqBFzov6GE+tphqAL9osOcUAW4zlYnaMTw3euzKGEWpP91PFr8UeTXObRXaUT8Q3FjLV5OONKM +TCT+XaoP+OL4qYOXejFbH2r91wVIu7wqojH4WEjt3o6CqHynNYqXDzP4NGTLiIgJny7WXgiLWVVZ +9AZhtnwXMbtR7MXe7kNlXH04vRf9ceWCUbkPRdD8QeXmCQ1+GfhvJWJ4mvuRP57wMfEag4/4WKn7 +YR/zhh/sQyf2YR877X7Yxyq9v0q9zwU0+oGPveIi1deGcTuzKl/0sfboY9ao1CLhKjU2TROvimj8 +XebDWWxShNf/mDUqt4MJl/I1NrtTVdrvcOwn72PaqHRHHxxGPzYtMmD/MvswRl/e2YdgnVydm3sr +PvngMhQRWzq9LUX70Gi8PAdEZuTXNNHwHj/SB8yWjdsPOlWjPfhotmx0h2+mulfnocbjKLJOfleI +N0axaPNm7suT5uKc2CpIpBjLEb+mEJ2wJhAS6g03HbHADPd0kW1fff7+Um7ll9Yr5rgKsya2jMvj +qtfLgdxXBkWrCFX7R3GJ5sFWOPl0Kyx2xmm/mVHFvlkNbtMCgP0yhINRY7CxjSBun8dAhfyT+Jb/ +iIEK+SflKQOFMNhumQtULAr0FDMpAZz5QE+xsDzepI6S/i6wuK9KbA3fdQ7NY4qrfwY/mmgXrXgu +xepfT7qqX9o9rybGXFRB2DIVRQorR6r4Fn3b0Z1V7yrxM3Nr5Y62O86cE4GuJUwLG2//OfNnFEK4 +e68ca38lcZo85anEMg0lWuX1lcxWeXH1OnNrf3vYOtnqnkkobvsieeUTTTfnQcX0iR4+uxC1bmM/ +HcFg6z4A2TiWzzbgE+4JeVT/cioBuBAa4ttVPY/cSEUQLeLIN2yjZUpsTSK07bIqaxxZUPW8HNBC +y1Fctl3nEWAtggi3W8YYP6qa/ljO6ZzYmoWwmnzacGqBderzyqsFqjC9wPoTy6uVhRcLrD+xvFpy +UVMLrFPvKa8e/LuhrIJLFRir7XSbUY5JWViAMyVvOHrAC8zatte66+7X/3h9hRH5j8I//Gm7hHGH +cNOEholn9xtKPOd5zQTZ7yoLNW2rP8ze3Qzvet16/w9ZgVOMaNu9XofEtwql3BnZ+eeh1x8SIZ+c +9EimVEogq/Xqdad3g7tGx3tyvXZ+sF8uZMkK8TuwircyWoMuwHl5EYy5plCyBf+f/4YfRwpVKbct +h8BvmxquDQeOzW0DT8B/OgxTdV2L2niJ43Dd1OGAGS7l5LwOIo5BhGNRapt4geFargsHtuOahuOr +Cr4MvzFo/AFF7kHzF2Gq6diGS34TgxyQix+UNLFrx4quGqZJHaJTlTtUJ/fKMnTINaBrhFuqblg2 +gTPMtbjjEs5Vk5vYZ8aYDhZhlupwg5Mb6JzBXJdzwpjKdFvcpdtgMZfYqq4zakInHJtRkAIfWK5J +MoqpWrrLLJCnm9R0LMJQTRwHBjcYFpjdUG1mok50alvMhm/iTBViqWpalkEtwm3VMcE1uMps3dFx +LAbIJaYKqoF2RtG5apscnUh1dd0iOuiDgjFQFLPE6A1qc8Id1WHwrRmFu6ppM53Ab5s5Dn5i266Q +bRtgEvhOSzdtlMRtimNhrmoZKBvsyMF4MBRQmkF0XbUcMO+kpjPK9nTHdS2TaIXuENyq2Wt4pNip +w2ckc3vXaZKTekt6GH3lmj8PXsQNRwoDPVOIIW7CYGC49woa0gV9g4kdCp2C4VAHo8xWOVrIUi3T +0tGW8AtHV5reV5MZn9pXDkZltvADgzocewpnbIuLMxYEB7Qt8E1omjpoEZtgfNF2XActB3pnBmQP +E24A/YOLGpQJ37VR73Cl5YJoHtzxwtgg9D51bI5q2aYtYoZhl+/hjM0NxvEM5+BU6GPcsETbBKcD +b6QuFXdw1zDQyRg4MGQAPGNYDMPDcbFtqAy1YsDYqVAWOuvLQ7M/12wywb2dnTCP7cEBJCTyW7Ex +D+BwOUSEzaRCDNu00O8ghhwCQWgZriFiCQSikU1pfI5OIPRBwZqQYjA5oAZdS9cdAiqGCQ1TD7g1 +JC4L3IrCoG8g5bi26+IV0FUT+wz+DQlEfJ8J0kxDBzGmzrkuMhRo3hUa1bnJ4TbLsoS7udjRySFk +lJ/TNc7Zpyq8rLgkniDnZ8r+tpw9YS4Vc9byMkysxXrLO+nX7zowl7YG9f95pN7t9ob1ofcAn5BW +3xsMe32PDG57v/EM3DK+HGblo5zyfw/e9iQ= + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/originals/SVG_Left_overlays/Blue_left.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/originals/SVG_Left_overlays/Blue_left.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,1574 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + eJzsvWmTHbmRIPgL4j/kfpCZZLvMjsAZ0I6t2buyRzvUYSqpW21tY2VUFVXiDJOsZbHUq/316zcc +8V6SSfL1pckMMpn0xPNwOACHX3D85H/7zVfPdt++/ePLZ/F2vpl+8pPDu5cv3r999/Mbgt784vXr +H394/w5BP/3tz26WdDtDo90v1q+l4T+8fPfDq7dvfk6/ol/e4ad/+tWLP758+ebFze6H1y/uf3bz +05/Bb3736v3rl/C7/esfX379+uWf3t/+8JfvfqYvBSzHF+/h98vyd3P4uzAv883cfp4TNnjx5i8v +fvjh1f+Hvy5xjQDbv/3xzbev3ny3f/v//vwGmsIv4A/84r+++u3LH85/m29ba5mbHN9+8+P9yzfv +f/Pu7Tcvf/jh8Pb123c//Pzm8NcXb25++eI7+M2Lm396+fr123+52b9+8c3/nKDL+eu7V69fQu/u +X7y/Waivu18s4ev9j69ef/urH+//+BL6HUtFcPyaUP7+B8AFaPFnBNevf3EPkK9evn8PpMELkV+H +X/7TfzsAk9/eUzui9na5WeDfn/5m96vf/fpXJ3hduzkgp/53+i38b75NeWgRluybhIIY8B/XZGgR +4fO3bcARKzf47d/vPWeYgdDwn3/78rtXNB1gsP77z6Sn795+f//i3f/8gZvFAH/4N797ef/9axhS +GoOl3GYchNx/klbAVWrxLK715lkoEX4dW7kJzdr08Xr5l1cv/+XnN796++YlD8ru3fuveF6kNM/8 +nX/z2x9fv3z3+zev3gNlBUGNR+WXb799+Rra2+fvXr/47gft5NK/c4PfvXj33cv3MKXevv7xPU31 +Vd8Ao/78xV9f4tRZ+AW//v7lm9+9/Qei8VldbmMENufG/8KQxLLelAiju9Ir0gy9nG9m924aeUaP +yBCVvgOm1k9+A/Pn1+9efffqzc+Fwvr137979W2fUzXcrPyNOnG7ur9N/zK10PH371++EephLh9+ +6ebmfPvLr+CNpzffHt7eI/d/wFUHM+ANTI7Xb7/j39nP9Bv4+I/fM/X0/69hoH7z7tUbxDn9in6z +fv2b1z/Cr/7+3dsfv//Fmz+9nX7KsuZ37158A81ufv3H//Hym/cgMwTQf/rqx1fvX96+ePX9zz6I +6DevX7x58e6G4PBhBj5/9Rf4zQsg5YY/Br/psI8jPb78Eyz9/lmGnt785eXrt9+/7HCDvHjz7c0/ +vnj3/cdRwzC8cxjov/rvI3r74v2fQUq9fPPtD0YW/3fsKMM+ju+rb3BSvLvZv/vxhz/f/O7t29eG +dvyVYRcwQbH9f4x3/IY+8ObXb5hB52+SBts3gUD4D/cWaP3wG+CX/5GxH168fv3qu3cvvv/zq28u +veDC7+1N/LtPmVh/vf/j29evfrjv88lBfvPi3ftX37x++dVff3j/8v5D2JAbf3r15luYiCR0OrVv +779H1eLmqz+/+P4l4Xz/5ztq+ZUhzF+DYPSi79mzD8jEEG/2b9zv//7di29fgbgVTenmt/DfF69v +FPyz6TIYxD0g+nb65+m/TDN+LXOc05znCs86t3k37+fjfJrvlgW0hbikJS9lqUtbdst+OSzH5RTm +sIQQUiihwrOGFnZhHw5TOIZTuItzXGLAvSyWWEENa3EX9/EAzzGe4l2a05IiPBmekmpqaZf26ZCO +6ZTuMtCSlxxyBJ0u51zgqXnNLe/yPh/yKd+VuSwFNIACn4Zfl+n/0s70r8X+Lhf/h4pjsO9R/gJp +xI4454m4gn/1e5G/SX4qwLECPNPvK/EP/zb30w7+7uH7bqJ/DsTeA/xFJvN3YDawG4mDL+gMqG7w +FZf+w3+Z7u7uTnfHu8Pd/m531+BZ7+pduct36S7ehbvlbj7dnU6n4+lw2p92p3ZaT/VUTvmUTvEU +Tgu8Cz5+PB2Px8Nxf9xNx3Zcj/VYjvmYjvEYjguQdXc4HY6Hw2F/2B3aYT3UQznkQ4KhC4cFSL/b +n/bH/WG/3+/2bb/u677s8z7t4z5M+wX6d7c77Y67w26/2+3abt3VXdnlXdrFXdgtwIo7Gqu7O+oO +duhIncJuYcd21jnsXqUuYiexm4m6ip3F7kKH8UEkp9NEPce+H6j/yAHkQSM+ICeQF8iNTBxBniBX +kC/4zMYd5A98TcAkZBMwCp5GvFqJX8gx5BlyLfXOnH+dHvkct890DhIePebZnz/TBeDu/IHOpJuf +fL1/B30q+FXpWeFp8sBglj09MC+AD8jUu0qio4KIAGEQ6UkVlix8mL/W2qba4NnVfYUphUyEEblb +acWsCzwgQ1YQFGtaYaWv9M61rvjVVphFK0y19UBDcMKp0eYJlhaIpBZabKmBcADyaoPWYL3t6IH5 +2WAO49jRRIBZBYsQhBjMxADzMcKsTDA3sVNAGQ0lrj9ah4GehUQgPwlEYQRRmOkn/J5ALGZ6Cj3I +gYKdIWHZ4N/dRD/s8aXwfS/fD/TAeoPvJ5SmOJsDySF6Vwz4BRIUJCw+IAtByoLAC+tEwraRwN0F +WJQgcY/w/QTfaWGA7EXpu4D0RQwoZkGQwpigOVxJGq/Q9wbymCTyA9IGucXLh/iHfER+Il8bcRnH +sxDfE4xABIqwqzMODgzREQbrAEO2w6YwiHWiEc0wvpHGegF5eYerEmbCAWYFjkCDiVJh0mSYPglI +DcDQGZY/TrIjTLc9jFQDNBWmZp5A7ifYAQJwfgb5cIIVeYD9YQckrTj5YNfIsL9EYN4CIvsOFv0R +tpg9DHpLK7yhwOaTgD8BRnKOLJdwTdMT7Qny0HgdZ35ksYm8OZCwOPDXnp4dPW1Cxh2IGQea+bhs +QKBmEqqJBCuK1kDiFZ+ZhOwdCVoUtUcStyhw8Ws3kdxtJHtR+lZejSCDUQonksQgi+GhmbafSSSj +UEaxfCTRjMIZxTMK6MYS7II0uPC0xz7T8N/1k5566Zkugssjn3z+dFn3zzbtbz7wAz8B/pabPN/W +FitYzYAATN+vPx/B/gd4e5pBfAZsWlKr8SKWEmAio0m+wtKmNm2dYdUpxnob2xJvYr5tOXe6ro+a +KIaltSwF/Uaggq3pItqQ6pwRbQElMZETCfQlaCxol1tUt25AFevkXhkv0Lo/mqKtGvBlFfruxbcv +b96/vfnHP6MaP23+D0MVWGlGSjKIIPohVlBRz8UnkNTCkuv4A1I5TjrEc6N4LnaWPz7+gHhsIo38 +ux5KGuYvRDcDuppvrkefIfyUgf37dy9fvvFW0QZAWMUeMiGaTIjOGxGq4tMEqNNxE2kVgXSMmXRd +2UAPbuvs2yZsnCR9YYvGzXqG7Ru38T1s7A32+0x6wAK6AeoJO9heUd2IoJ/cwQ6EpgRaImE++9pa +QucNSOZ3CZpFwQbL7C6Ieh3QIhmUbLQuTqZn7wcrAzTrSVTqZTA1jrQ10nc20prYS1nsKjS1ohhi ++nzC1+P6StYj2o9sQR5AV0BD4E4sSbYlzZoUzXcVjXej7aK+OzllN5GyW0jZXVHVRT2X3uq0U9ZN +G2mlB9JHWRcNpIVm0kBXmCE7mFcHmGd3MOsWmH8RZmIGAips9g33/j2oAkfg/R0oCgsoDRFUiAzU +VVAweC83BXAhBRDNcPxKpgpSV1lNJ2UQzfNGJvqOzHRRDMlYh2fCYY1keCUar0SqL2umiNObDa4j +O1kmuGCOtHjuqFuzdC3Qm3ixZZ4bK1nKR/I8RFKrV9KYjzAdA+nBVTwN6mbA3rERRtOSv2Cq8rSl +CbzIdCblmGxIGnd6ULO44DroXzwf2UEQqffZLH+glj5MOilrpQV9FaSWsmK6YEtSTlk9RQWVVVRQ +UunDH7SVu+jogiOxrs1DvSNNHp9VtPsqw4sDzUPOXzgReFJAP/yICRuJkWIprDIZ9oO/Bkc8mccG +FHny2ox+GxiziRw3Edpl0sJ55fVVN665vt7YymT7crAtJzItg622bljyatttrUqxK9mqZJtSrUr8 +yDqRUalm5YHMSnISoFlJD9uVgTibzLostIqrWJm4mtnS3E9npqY+bHLOYnay4cmmJxufbID6hzgw +yT8fnJqf+fW3inCxfxdz7C28t0zk14vi3yP56Laf/lOxbanSFlVkoVf3f3LtTey3oPGhNVFkNezd +SsBlkJ3r0jYd57wsss3wpIcpD9Md5jxvLUm2lGbT+0TTOtiUZhcJzmS0tY8yg3Xuyr4z0YTd2Qw9 +yZzkzSfb5rOTzedI0vqOrMcgEpq3oArTfIcm6J4sUtqGYCNayHqNZM0WsnFXsnp3ZAjj1wmNZTKc +FzKlcVvJ5EbDNbtOx5U8bHvRFY4gyu/QJUe6RKAHXXbIPpIK5M7jNUsbCykjezXGT0feDI7etQGm +/d4ceerCS2LeL2LQn8SIZ+enuj+L2OpRbHR2gp4mM8x3Yo9X8YbmUX3cqI47EfYs7rviGCaW+qg3 +ku/lKNJ/9LqUjddl9LucyEV2IHfZbjL3ywoThf0vmaZONC/MgjOZrGn2xRxpqu3FI7MjebeSX6aC +zUNqTjYHTSQnTSBHzSKrhHfWkzhtjuS44Uc8FWVnT5tYqrI+as5c58vdD75c9eR2X656crsvd1Zf +7nQ8mTtXfbndm9vMm9v9udl5fgaPD3t7JufsueDqueDnOff0DL6eCZ09g7vHO3yc04ee5vw+6vtR +7w/PujzaL9FcQcE5hBa1acyu0ec0PMSpSf7B8fnEoICFBR6KCkzbwICoO1uFx1QemuQncS6ya1Fn +NvkVJ5rUi03no03kphOYZm5U16I4F4/mXFT3YmVFbnKa3LketxNX40quRnQ2srsRHY7kciSnI7sd +jzQD9hN5H9n/iB5I9EEWUqkSeSIjeSMDKVtsGqHazROc5yVPIh3cHWuAg+PehMI8CIWDCgXHt2o+ +2XQmD4x9kwgBFQN+/evanwc3reelOGs9I6cLfPRcTOK0DeRa9zzci/O2DcxLU/fiGseYV3tTkFdR +jbOpxKwQo819t9knDrJTrMMu8fjg2CY0NtEimD8WGhN3e5/9XeHvc//AYl0HT93p6kwf5zvPdpHN +ND44NjsSuauNSihhEhd6H5HmRoPHgh3oJxoFncI2eUcGkj6+Z4XFojzLJr5TTXUZlfA7UcBV+QZS +JtG7VePuioxXZcImnrM6M9SZoDgQk9mfqtuwdrOSfN2RzD2QHD6JpT2bksP2djZFB1Wd3WS6Du4N +uEeottP1nUQbjOk8ovKgdIX3sIBlpYmfvSlPB0F7tGjDnalT+hJ9UbCoBcYm5Z36Xn13lVDmKhsh +U7GTDZKVMFXEjrKJnnhHvRO9THWzrp8F2YaTPFme4jS2rrWtbB5N9M9uUOKcGmdP/7KgKRv4rIFH +0cGraeGHjR6eBk18r6ao08Rz18UnUcaPEttUbTybPr6z6X33oEa+lylNocqNSj64gi45g0Z3kGrk +6hKKk/MKrTJldcKyY2gxjTw7nVwn1sFvGBKydNkdkt+xSPyxUIbHaiHHI3tfBsdBIg== + + + xwG5DibJ9tjTRDyJ30j9B92DwKOlPoQjjVjP/ljMjeByQKp48fbmT/AehWBevGzDuQ5Ra/YrHCd1 +40nQepGNTL156mPwXoYm8eudk24i3+rd5ALZGszurocxpK3PKsFt9UTs1n1/plV0SVmpumyGQJk4 +K7rLYjHHRX/EPTTRt0FMUwZPBNleiFzK33FeNU3dUTfQnbj+2AmkS60vtDCZ26c8bp3BgBxtJHAM +vB8VfajC6HEL6RsIfg3rTLqfxFvTswHYPXOc3Ep7aLvYuxUn24V5KrPZwbLsJtksZKO4sFXoZuG3 +C7cO/Y6BIn0atg3dOJLbPArZK1sRvrNnP4rxSRzvbtydB38nHnzz4Ys9dcmJvx/s52opMHES9Ugt +pdNgRndDuoo5pKZ0N6Y11C0Wz2QG9WhSa2j7PKy9CWmLca3mdZ4sMONCMx9Ib/AJDsVHa9Tkntjm +HlRstby9or2T9a3qdhUpkM0QZ1NcTBfVwBcRJ7NFunX7PNpzsGc/PCyhdhN9I7Pax9THcHjPqNKs +Ks2skrCPBX5c6GdyeVYH27N1D28u56pb69XUgOwysMR2n8x8Dy4ha1E9w6VAnZxFfzS7vtv2Yt9P +shSaPas9nYPFnuyedCEBBGZ4cM/inrk/mzSs0/Acx2c6nH/tz57dA087f0h35DDIec6fZfw9kPD3 +QatmEg/Fxw38rXUz2jdm40/m19KlpmZOGrKIuidLTdatubqw3TO5LKK9eayqM1XjYKZ6k39v5lC1 ++E2aLgRwOL/Ih3AkiGO5RuoA8C4AcQJMYsOeZG6RL0CsWbZn2SHAVq1atmxbZXMPpO4kmMawGyYT +AA1g1/o4+lrCsnpAqmuiH2DrDHSqJ3AGBQf+Q7hFHWhMKLguWkoqqMsMDbDZnHKjdJPSGuUCkGmO +R45Snhu+JMPIBEwBWBi3pSi0eBtgJnRCr4pVclwCzExEEBrgQoyhzUse+r4stSCkKBMCdr3n+dyU +cBthnvgUl2uiJUqXFXAOCEIpgGIYtgx9RXY0Qk7nfBhbbLe4rd3EhAlAjtLroiVKv3w6pXJLKUIL +MieFa87ULWpOgVlrHPOmlrCmgSuN/En4Qw050YjOyBZlRL2FN2Da0tJcJsx18X5KQszzV29e0rEn +y4jZQnq20+aIAEbD+IDAwQ4I4PGAOhiQd3I8IFLIvvTjAWg4Tj1uv7EwTmJfxE1I7ZIx74JqUz6J +fbG1Lg5nJrzaFucmvPNPTZZ83LaW/OCa6naG903t21nG8XTR4lCbo+dKHLqt7zIlznIl0M+vLis1 +RdhxtZOAgXNemU3SrRK1TJJEJ8phRf2B3VcnCdKxw6qQhbETB5VMhSCTIWsWhEwIPjMyy6mRfm5k +JbvUeRd0gkyS4pzFxeBmiTtDkoZTJNushOC9P5PZpI9y/1w0TFeX80OegpN5CoLL9qlnuQcnyz3o ++ezqFLLpNG3dnW5WhU22wTabfchl16SCySWz54016+3Zk/MgBWfNbj2fx4kiuhHmBdqraKceydkY +aELUY/vYVBgnw+wOEfXpoGnwR5kM8zQIjHEydG/T4hJVivqbbEoMk2J6wCc4TovtxNhvovQ9MSxP +F/JURhGzbFJUhoSwrdNonaet3LGZ4kXP5clycbpMLivl7OzD4Cfvk2V0fDhPObo9MHKBcwRnBwqV +kwT7k0yO9reToNJzD8MD2V7VTnPROa7zGc7paueH5KK5UCVxjSaybn84fQ8T+dcWEmW477EMu4Np +Gmmvw/ypI0zJBaYiJtA2dZ3BnIsw11aYX4d6gskUYRJVDBEd1hNQG2FuVJgOB5gACwx7oTyPI0iC +ABKg0rieYHsINKI7TNVwS30FyX84nsAKDxOsnELpFgf0wt8tlEpXYEbu0HF1Z6e6/BG1zzmgNhir +0zWPp6GZOn38eNqHku7MMLX483QxDqdHWnwczh9nOTvM0k+yTBeOsnziQRYKf3Lws8V1srhntIjn +iY4McZ7xSieLMkxSyjams0gnyjjeU87xSoea+NATHoiC5XRH5xYPlILc03kT5Vctml38NBWepsLT +VHiaCm4qOHfVWuaZfAugnZXWyCZvOUktErI/L51v+bSPyRmWTzuZ9SWnuj7xZMpXb//0nusG3fzD +q+/evHxPB48uQfuZfeXBpDyYlAfTMs30CJsf3/KRA4LnZMp6C1pnuqnxFhTb8Ekjc+nzNESP+ext +yUtIWBsnLviBeLOutzWG9mkkPIzm8ZS0/Hkzc/zkp0yU37958+L+5bc33wnoBlYczJSLYJqO4rvZ +VF+4aDNfdLE8YDJPZ/ZytTMy/jT4ssmZGLMmXN7EZCHd4lInnMvFhXW7y6WaWXyWCrR1teSzXKAh +vCtuFjKKHzZmfO2I83oRUf5qsYheNKJgDYluPVSrBsFG8o48PAcyJXo5CC4GQX/hnXdyGB3Pw+Df +MIHIDXYCXc+e87lzPHVe+dw52SE7Etf9kPnJDpgHOWQO4n2i0+WFztZongdneuzJ/uaj5ZjfA3sE +HR/RM0X5gaPj19iS/Y48XWNL9jvydI0t2e/I0+dvyf3s0rZwxbZsxbZoxbZkhatXMQ0Jzq5cxZDa +PFv0r+c074egvYbty+Qi9y52P0Tv+zH13VkAfxvCp1oh54fTPxLH50R51inHIhaXzpqfHxLPm8h3 +j33HaRP+diHwsyC45qcfL0bCJRY+uWB4D4efB8R7SHwIirukdhnvaQyLu8D46WOB8VH1gqXf1vwh +pQY2saWVeeXYFMgb/AFDJ+milnQthBx1ayC/EsXx1nm5jCzAGqdT4kV/kDDUZaXxeii/bM8O68U9 +G8B+z+axJT16b5vFTtK8KClEziKpa+rSUdrQD0FNzrf1SSdr/delvZF9vxwRongQbVTJlYriSJCW +iWqSPIiOXPJ+TaSa7CXyE6gcVC8GBQoJqSM93rMjLxi7Zu34FFFmnsloyVb9CJJPsjpZ3uwyJOf2 +9FzSTyYJe+wskUrzYO9c8qsmvWrCq090XU9tzLr6pOpAl8r/bAoBTZ9S/+ehoj8sSj/TDL9ghdOG +P335ji9VSVzS+cGS/1fbSXUv1d1UTVw1cjnrv5idGyc2dc3YVXNXDV41edXoVbNXDV8yfTeFQ3KZ +W/CSpKYcOL6vFiLq/Sj1MAVhAe2iXLY1vxTTaO3CilozydllwbIdPq7M1T1cAY2ZQA/WlLgWyi8T +n/Gi9IxjPbumPvrhkcNO7mf/HIbH53Qdp/G/op67Z1zkdvwyDkmol479jwf/R8PkTuO+k53/L5eP +J/jXk5S5UOnmTOn5hGcataTzh9bpqF1/gnL9ud4un77+tF8+7ZdP++V/mv0yZpAQfuvIsMB93hZt +J1zQCX7JKVAX98svxcT75ZftunEB0Fqvtosrvr/1vTxd3sxTHE0h/HpKPXtKPXtKPXtKPXtKPXtK +PXtKPXtKPXtKPXtKMnnKN3qaCk9T4WkqfFbqGe65n5TUtaBN3L4gK0wQPDbDSA8j5tsZj319RvKb +fvQLjfR22Uhvzkh3HjtSkVU9Jt3CDOvoakZ0o1o1YS4XIfqvmUWk9apB7XVd1nLHlKK7oTyEL8Li +iiJOj6/E+59Xu+Q8pSDf2UyC7xvn6oeuATkv5//RGv3TA7X4HxODOA8qgDzo6RjbpIyz5Ay+tuFj +ntZPFNLTA77WzxbR00O5SOcimjOCPlScI1j2z0k6/oHyHMyEaTjrf7RMn/PiHHGoc3lnqT09sWdV +DhXL6flgrcsHxC9wpizlohiV3BCQdBVPvFLayJJL+3CS7hciHH2upcwL+3HXODp07aRzoiPZ5if9 +iMf1CxF+mSjPl/2tAMabOJ/8rU/+1id/65O/9cnf+uRvffK3Pvlbn/ytT56VJyfb01R4mgpPU+HL +/K1268a6GUYdRBzCS7ckPHjIaBpuRRhvwhxPGo03Yfpr3IajRtPFs0bJlS1cXLlQfyeHVi/UOzmk +ROjkqu/7qTKWMIy+hOEwY3TO2IyZHpwyfBCNZ4vOlQ/NFJknk0yUPk048W+8hq7Pj+3sGOcGzIwJ +JwbNCp0TfUZQDi076RqsZpwEQZIfcQ3jCs4w3AsMsZbOb2fnxszD5PxL+0nW8HiZSr5Y7HUs9Lq7 +fKPKJMv8odsTzkdxuDfB3aLCdVl300OX2m6utdVxvXTIcJAG04PiAIf54+JgZ0meIg+mjwgELxK8 +UBjFgggGnAHTBcHgRINMBRHduOYDDf2JljUOPA45XZhw4b5FX1Z0GOfp4jD3RTpenNNH+cFbMiYb +an9xjlu07vribelRHu9efJTGfNrI/u0VGeMlGctw28j+bCuA0Z/c8D9mP3A7grsLw92DMW2yfC/s +DMPeMO4Obn/giYCHJw5y6uJDUwFUBlQYdjAIhRSFhZSEA4z+CiskgWIwg1JwAKG9Ovlxgu1jR1Mo +wFtONHkqSIqAO/wR5soK/I10rcYBpkGFgY9ABl6hsYMhyjCSC92YsYPxysCQxc4kNBiQDAOx0JUY ++4luw8iw3hZgNq8zFKXI4AWYi4xFtqoERWbqNZ7MwS47iXeTsY7v8xyY5njWNocXzg8syBmFvwG7 +XN0L3c/0IYdj2viXundpcC1Nj3Q0fsDNOPqlp8+7UOKif5o8i9MHrpN44DKJD18qOn3gVtHxEgl3 +r+iHrhWd5OIIcRmTf9A7jau6jeXQxx0d9gh0zCPT8Y6VrvjY04Uep9PdRNdy8lWcma7gXNF3jt5r +vF1E3AtPU+FpKjxNhaep4KfCZ5WPavPtMrfPy6KRj35eGaky36bYyhekDSmGT8wb+qxyWV8aYC6X +axuU9UP1iM7jwJtrZcgv/oGlNX1kbfnVtb3DyS8wiwxPLkRzuSLRxRvKNhG8va2806SBYReOGePC +51HhsTLRJiY8WTCv30SzWkxYDwcfPhauWYaftLjRWOaI/xf6/yb5Mdp3jZtEUk8L1zwShbXQPboc +T+GfVimDVOhcLt2ju9vURNpWRTpZXSSph0SVkbQqEn/v5ZDSJNWQKl2jspNaSBqC5GpIEpemi8G1 +HlKUikhRiiGh1YO6+26iWM6O6iDtyTji8OQsdZAS3ZT0VAnpCpWQBvv00Q4KcU9cLqP0GbfGujo6 +h6lXVLLcqu2dsec3xs5nhZWstNK0uSu23xTryysNvs9NiaWxyNJuOquzNFZauuz/lMtdh3JL4kib +nBfU1VzaetQu1WD6WB2mh2oxZV9sYMgC/FBNJleV6XJdJpgJ04XiTP2qosv1mXqFpgs1mqahTJMv +1HTpAqPFV4q4cI0RPNOFkk3+NiOZe/+ZCjiB1JjXStWWakjrRWQLJ9/NtyVIytuaU5vDAzl010P5 +ZUrOWi4qOQB+9IUZXPJBbZRLFgolxDyUeKN5CWr8XDKBBiPoIUTFLClGt03oQlSDPXVWneFjcb6P +RvkeGzD8aMjwIUQfiz2eoRqXGexsfKHMMoMyQNcFzXOpbVgVlChEeaUy6fiKmcvz+A== + + + ahj/oxe2PVsj4WL+aYjDwvlYbuXF0p4PpVbCGE+DFj3q0eNFjmNC5Tal0hIqp+H+32JX8K1D9ZTR +HgZrmGvknOd/1U3i6dbA2JoYg5ExbbO+HI88rx6dLDi5bMEycGcnngDOHkpjuiB1ziVL9nKvY8rk +0VImH0qarHIh6g6jLz0bbpsPdzlxcjS8zlgyDSm5dbe9HhrTpBbqfJEu4yTgzrnM5u0NqZrSzLej +BkrpqnTG5SjnW/h0CyYvn6gKTyplgu7KiRYwjSKdZWnApxNxJgEvVjq3cgedJbMdOnWEjgSgvgLN +e8rYw3S9lei8myiJswC7OIFz6QmcMJGPxzuQbRHkXAWm7EEC4t3J4S7xyH2Sdv9x5X76oHa/0e0f +o9pPH8tGuJyMQJ27btcw5/jhrl0wXT7evenjyRaXuscj94mW2cc6OH2qZfax7k2PySU5797G0Ydv +xA0SVJVWEtXTqS1wEZ0cqNqPaqZzgG7RZrq5LG8s1H0tjHyhXYsLIQG1CuQEHuLIsLvT3k661g05 +8bikaEJs2Bj4u8R6cWe+FsIv264vevO2hUpHPXc903MjFTdD7fHcF79N/T7FeTIv/KWq5Q/6CF3R +M+cf9Hqv1319DMHHEbwi7Y81dB0Ypu7kQguuS0O3fFa7jzP4WAPFG7yHbpE05GhOtCqWQ5t9nr2U +IJS64IvUBU8W+yiTqOvVaoDvXfr9yXm8Av1NRnF2NDdazvtPVvk/JbWvTtdM7PMmgKfRU+np9JR6 +Wj21d/5UoT9X6Kge6PaUe9qJ+k6hcnGkcUPlhs79hbOAdHXy+VHAvWXcreamsmOAmyu6O81A9Ree +kv5i62K+jaAKsX3UCiwC/KG0PBZ5K3habiWpjdY9RjSoXNllYX81jF8kTmO4JE4B+oX3bJ6c3Dk7 +VDW5oGaVypE+oCni9EtPe+3ODvgsqNc8dMBnCLc+5njRlgIf6i2b82ZEwXQm4JQGpYLPJl5PuF2o +9PhI4fbvmTP9mHd/8tunS0Ly/P0bfyaajlyfHQaNViuYdctYRVGvbK56F+4H1/31UH5m8BcvPc7h +S4K/guHLBM9Ft0scqyw+KtGX0nwfleX7qGTRB6y2C+mBj0k4PMucewidD809JjmBUhMelaTyHxmd +92miJEzkLs+NbvJGDobh0Lz4zc9/8DcYtdt1Ga41vzrmT1x484fO3n/Kp79owaWLEYJ0IUCgX73y +dLDkTk7zzM5VXyQRlBNCK8XPVzUPehS91zeX0OGmaPmdxc55K13kbqGFoujq+Y8TGT5RFlmR5VYs +ts63Da0SW1cbgyPsB1qsvBtrrP00afiO+8kvC0GKBvNXlBPi/GSSRByI55uJ+G4i3sfXSWwV+S99 +12uLGl1cpBcY8YbPFthBzhiP3+l3kzU5un/7c7rw3JH3YwhU4rh5rSYOutxx0OXUND5a3e8oXV6l +D6wukbI0fcQs1ou8juR5fKB8gstFS5Oly2wT0SL5JDVNZltfJz5UX2eyBLR8scIOO6MvZJ89kHu2 +m8QVfydHkYMmn0nu2UFqlHdf+0eyz6YzGaoJaCpJVZaqNGV5yhJ1RybbgeTq0Y+x6q7Jzg+vFlhr +ls5ytMSVZdCjs+WrtEkWk6myslZUydfkFL2la+e06pNkpfhj81nzrVZy3enE6UbAh/Ma1beiUwn+ +TheSsLYZjmMO1rYmh04syb2aKPWq5zbyvELX/4n834EmFE6nHU0lnkhBJhLfm3Ck+EWg6VMncd73 +k85Y7UJPOhc553xHUgl94nzM+Q794TDaDUb4qAXn/3ZOvP+rI1weeGgCT7K7qYtLHV3pbH8b97VL +G9pBL+UY97PF7WE+fs0LzG9eq5iMbDbu1Ai621wlMN4M4HNbxqyWMZtFClpNQwbLkLeyyVfxN4iN +6SlDWso05KOMt4WN6SdD2smQbjJkmUxjegmlNrHHaExwYkNO05w00SnKprj0dKdJMp7uJOHm6PKe +2M2kF8tx8hO7nMYUKD0GSolQ05ALpflQi84CGZmTy4s6ylv64VA5IPp0MPlv/2Dy1XJJLjszxlH+ +7HGeXD7nl480jPX0uIpyHxjrzWhPnxU7/MB4T4+OHn50xDeW7FrnBYNhrcFmEuhaDdgJ4kquHXHo +zJJDs2BE78GsnC/F9J8uG+dyYU+s62lWqvOU2C6vW3gvlFOcqrsze/NEVxvNthfzTmyJ2dMmJ1uy +sUlF0CzsRJaQXklb6TakVWy7nZlnYoRNlo0dSfMl3ZfmGqu+XEtsR0H6I1lOJ1LxZ7KfUAFGFTjR +DTkFi/JMlMSBuvCO5vdRqozxiQTsf5AnUdUeVIpRLUbFeKXVwuWlVD2me5Nn0pK50hTXmcITC5mO +/nKhKV9q6sDVyKwe2SJnGDjNJk+UabMOeTacaYPL/jzPhjJtRsM0mqudx06N04XG7MMnqXKvcjRd +PEO1UmLM7lLAYXt6Ss54ROFkncxePSDrnGXhbYvDA2en9ODUcMd0oqya0Wo92t3SarYiKz9SFpZz +p6bh3JS3XPV2tuNwaipQZnehDJ3zJDEwXafBcl3lIq3L7j82Xj9+XdbjLs568Dqt6SN3al28Y+tD +z/n9Wx+6d+sRt3FNF0rXPqaY7YPP9GC124899fIzPfSLB6rl0jNaJMpa7b3SpyjU6lBzY7HYsZoZ +lgj/iVdLP3y5NNoK02Mul3789dKHPF24XvoKF0x/5hXTctjBFxC5my4Ul/DlJbYFJqjExJPt8bdk +ezyQIZGBAxEDHQ1DZGNp35IqpR1kVSSx1G+qD6ii10P5n04nLRcjJwC9WGueFBre0HfmLrx8CFry +gS9s5uqBPlKq+COPQOudmXXYzH3ON52CnpwjuruiaUOXLX1xt2Fm8UrL1m6eaT4cfUJhPrGvi1M/ +e/XZ7pbXZGrNLWfujAdY95ZRfecPsnLdo0RrutDqbrTOd7TiD5vs8kiZyCgdCuUjb26vRXk7UTK1 +uGQlpZr9sgfJqu+srKQX7bgipXhq2VeL3to93yI6scP2f22XLG8mH6uw/+G7fs8v8L1w3O7Dlfcv +HMXzz/SgXvnQ1/GBR3yJcoqPev8pZ1sfs+98Wor4I3ad6Xr503KwVWoG0bpf6XBFrywVLlQTO7jS +UlW6c15airo1kZGFPeM9lftnFaaoj9zLXmNse60sd1culp2wz5uKU/5uWe79UHdKeHCSqOvmetmJ +A8EPbrxYcgnTn1uqa7u8S2Khf0xHSFz5/4N73RciHDfdBr2kTMMVT61IIgTv2E13brxZlZIm+AqA +j2gFX4rxizboeml/rl+awvh0f8DT/QFP9wc83R/wdH/A0/0Bn60Y/9sifLo/4On+gCen2FPR+Kep +8DQVnqbCv/59rY8vYjie8/6kj/2n85e3i2cK2+ZM4ckYvbciezvJrlw35aWL/XSp1DT9Ow3ZnZ+r +Y13QBIMcfUaXATkMpFASGgGsJmmOPCtIjbJAjqTpk3o0yQlHdg2gpZelFgdnxZ/cMfFKSRp7y1y2 +vGWizFTXaFVefHUX9fZr5vksQXz1/GsWOrv/Kx4FZLt4R/HTg4T1TxLany0W0KMBGugvkvb58WD/ +R4L5H4vbn8fmHxOj34TaWX5/ppy+IKZJSE9fXjNxx6bHplL+6MTMJv9UAqoMPAz+y2KCME6D+/J4 +lsamMlGl4vYSBZKND/g1YQavmc5ELUvLQ2G2xkcU7Y5Q+BWBPuY6/GKULCBzmce7S+EDoRUv5PAk +F5aIgx+wJkUol8Xll2L6MuF5sb5FG+tbWEFQFTjsYrjTIznO1+T9TOOBik2Z6K2H6VKJ6NEt+UCJ +aPQVTOZT2vomzZM0yo0LpaK2FWk5nLe7UIt2kfBor59VJisPtXN+xDFWmtypHY6Y7igLxKKmIkVJ +fk6URpIp9sepUM2SoSR+OvboiyTMpUPRF2TMIyTMw2rg9HE9UO973m8S/8eSpduipZcSdU7bDP+x +cOm6yetPQ9LONm1nU750cjn87XCxgCnHqPY0K/Uaox6t2sarWI19+DIUiVlNGrQabkTpd6KwgruN +W12KXLHCK3WOUO57yc+6r0SvNpnGcV6GUBAoJWE8Sq7Rl6ZFKNMaQDxclHzXQcfFh1BBG2T5WpdN +ugh0EMT5jTvlHjBw9dCGcT2UHxLQAPj6V2/f/ObdqzfvX7357tkzJ7f9L6ZffY+/ifyb37x4//7l +uzcg0L/6f3588e7lDze7N9+9fvktyPIN4GZZblOqq/wbb0q5xYie/Buhqz9id80W+MNf6b//N/z4 +PwD4Lzfp5pc3//zf55tvCf6H38I/W5z3DiZ4b54DbPOuAaaffX4BH8Le0Ot+TUMBlhPoF5SDXiux +Oc0r7Di4HdZC2+LM8wIruErFqsi5QH94gS+Al2Jd13wLhmZiegXE/9Ir6bftAkQ+9vwcE4L+BH/D +igUsYctcQWWold6gsNhul7aG4eOXYPrZ5xfw6Xvoc8CpDB0FKUrvUVhZbmMDO89//hJMP/v8Aj59 +j9Kkn/ccq+E2tboIg9o8t0sg/+YtNn0LfawUPywKcoPAn7oAcWOwwaQvoG7VpJ+9dyDPWeXCJZif +DSM2fQlRA7NEx/Tewfgjbfj4JZifD1t8A7c2Y6IwPwD6+UswPwJbfPoeEHQBtgVcZnmusF1jDD2C +YGNZnZBerB4kWQBScA2kN/9AC26++S1XHwmwPLmQXE1jCYQuVlHpZoUc9kU6frLiar75w45rHt/8 +i5+pfa5cGrZLi+nCmt1gQ9AfWerXzIVpO3klLEOVpMRlaNGLQmRCL9lcoJ5v59f9AyM/rMYNzBN/ +ab4yqbDLL1T7LkQMf1zkrWxHzqIB6Qj0M63DLBVpcmn2KLcuwbzk2OLrtFZQ9iPtj3XhqQXtciFG +N4xzosDWhI3MJg5V0sBddRDhbilfEqZY6GojcwXkVu0F2f/HK038rTD287TCECZhiwnTCzC/IC8J +96sOP22iIDv74A+i9oIYVJB87vkZpmsO+2Y/8FuEH+NLcvSCuL6wuzChKYEVOdZCS3lto3aqJTBX +5arkPTGhOJCOgnsH43WRziXxBuap3+JTWrdahdc0PE5RXS6APMZLOgq+5ffTidVN0E9F2fwsfXXl +3+zf/fjDnxWPuRvC/LNpvtnB3z/8y/QjPIMWelkHJQ30WQLd/DbfgKROWPlzAS48A5VwvcVIvgM/ +H8Gh3OLFhARWDJdg/eNvJtRBcSLPC419xWNhOEnBIltJ+NcCZgIdiMTdCyFWgH/ReexQo2GRAxEc +GkzHNScEx9s5wGcAuOZbsP2EjAhLHmA13tZ5ro60b/DzBemBCUhgbLg0+HBrvuFfoSEYWoATyO4N +l7pt+BdsOGfAGJJ/OSxP3JnLQKXntfToMA1tcb8CvDcDUmR2AzV9IEBH4JuRUgDnAp0beqVt/zp2 +v7d1rNK22DHH1U6D43+ndjtQh+lP0++ndvPTn9384R/hJ5rUsAqGKf2xmU7QGwDfhA== + + + Yco/esKvoD7dritoJmuYC5bnpTm/zmtEMdEc+PkGHG5LzSuBPZIHwIbkWjOfsJcCEhSwJ9gIciLK +F5hcBIkJ1CtultYlMTDDjnozUgYt17XiNGNw5O4hSjDTGYhmOAPxStGbiy/HAUUOQZuiNKS0JOFn +vkVnNYLhpxl2KAQWnpTcNsZCwHqLx6UZ2BZYCwdCADMJfQIMzmHRtjHJy/Icbrjhgvs2wcoMhPPn +G+yI88oELDRR17ktt8D7wG1XZtgMszdDA+VNWhkBTuqYhNhQSuEZAWCgtg7cgT0YFvQq7M01RAHG +ZVFiMXWW8SI4KsNiy9I2hFmwprkogrAW5Tkqt4YgVxvgHKQtbLxREawKBJNfKViTfD7dYiROmqLJ +IMDOBJjzAlzQLcAEzHMwBLD6hYugdFXhDM6b0oTj8F9CkW9TmGWGpZCZ4wUo0I7VnLVjAMau80i2 +qAhaygpMKSuwKWG9Y7DobOa3GrgP621YiswjELWMFCZH0MkBAks+32BmF6G1JeFhQ8VQ3l9x4svn +ZXLhuljt85gxpVN20c+Xxp+HV4WQBdiQ8Qys68LLcaYFLwjqWnHOIzA1HpkMizyuAlxTqcLrNRRD +ADNSh2BpLMWWeYGXRHldCoJiQfUzam+J2whMcxZqIyxYwbvgviCreV7njress1BBZfcYiJlfwvBS +GRhuMV6vHS5B8AI4JenbAotX8AboaBJ6Q26roEg4JowixyrAEqOu8hANbRnfxmhhleI21ZnGwGgi +kGS2AEHVFgJY2jEYNgMhd17WIiS0WQd4yWsQBEvqI5m0vygddCBANnBbmPYpN52M0tsKUjxqF3LR +gYDdPhWdYqFWaVuxjDtzHIW7ANeqa6w4BC2qoFkjE7BCb1dpiiU7BQiau76pzdoDAEOXBbzKrFlv +gXHxDAEaSwIE5cUQEIm8dFYSfwgEdWfReRB4EBrLnM5tRtBwFHXAeBMhYNKlu8JWe2MthYIK/zUE +MdqGUwDMwJJrVcYakPytTIGxAKBzsIUjA96Qm8quRYlak26666KzaJl5qjPWxrMIgF1OkkhkYGmr +Mhs3I0WQgS5ty5N7gTWebLcJJKewJZiCRfgaC82MBTfBoMIPw7IHRaCvSrRdEigHnSzVYF1266aE +4NiKruTIIgaAra8Xln3wamD/2hxNjCCgp1kX58JqCwKDrheM19z8k7RFO1h3GsELSy4km7CrwEAg +63pDScPviqiF6Yor9vmMzPC7DwL7DlrLUg1Bm6OueTxBg0D4WAimyJDKg8BYq7wKjAH5PCCLSgCo +2vwu+LGFLQszDOYanShkBICsNF0wKOgZSCo7D9dcigDTPOxfiqCEVXqbUxMNFl/XsqAgg1dehjaK +aFiL4a2msSy6OBDvolNW9ntQuUyLNvUIgQvMH1WPjLUF5I4qmpihLG3rnEw+CGsrDKlOuWDLG30S +cdVJV0qStnhCR1nDmjIiCKqJYdhdEIDkTLarpVV2DwCD3FJwyYpCdWUU/iUKsNk+E9DXoXhbTbIY +I9aORyCouUWnPZZDFiBIw1X31aC8XbGyUHaEMbAmZU2WAQMZO6+6fS11tc/DIlbO1KKf71v7koJS +VaNtoH1sGkpBXTfA/BsBwt6uCGYFhrUasGRD0Ke4uGEZnOpSuzrGsDUs0TGRgSXokCfcrBVtnpe8 +GRpoW1U1gGFOAkyw/agytayGoCwqJ7LoFgBscRFggQWJwIAFwHWnwgQLRhDwzPycFAHL9ECGXFGy +eE8JGGNTlYf0eEWQUhMWiJqLwDWqOlelC2G5DUn5vaK+yQgAnJkHsNoCrxsAgsEi3c2RxQQCY9BX +RV03AMZMNiFsbdyF4PYKUakRmJPKNLBdZRQAnKpuNnllCYxtxYzLpg0icNGVgDdUGQJSVLi76PgW +INrAjBV4JEAQy0oBCFhD0GLWeSD6aIimVKPvImcBhpaSclaVEwDHVRcesV6AUVdIEQUPsTZdISWp +Ag5g+FkQUGcQmJywJruFgV3lgR1ChA+CRbkACli/Cxkd0AsP7RINGGtQYFAOZLdhSkiGwSmq5KBt +jIE1qRHSWCQirOjnazC0xUxG7RFsWiq1VhZ7AZe0TqBq6lJAXVuVAJoLDMytCfVzkemOe50u42py +E2kyGWvEw8eWoghEFQdgyKpJr2jEKvXLqlJDrH5CkLX3SZQbQmCTzVQjdHUtOig2Bwss36IzQMVD +Mf08s3arCNagArmi2v1cwZEXB5q+rPQF3Naq5wIDZ1kxpWuiCEVZ09cRAzNYNDIxxMYAIEWcGGkq +iyFIpuAm9XohmLZ5BleZxZUHdRyG6qT0ikJD8RKfZdULb3ADtanNLgYC1mS91a0KwWirUydI4CIQ +TPnUJ+dcBagrTmYSI1jNJsLJLaIAtp/UVEaKpQXAZCuuVlXRQnM2ZJtXRYCXZ+rLKjE8zmyydBlJ +CCJdyqkURKY2zuYosjWHsEVn4hrUiMXPN91SCsoaBgZbeOhQEyDFtGQQVKAjuKiTY114jQGw5uhl +NwPJwyYblS68iB6CprsiLm0BLklHMfKcRWDUlg2r9iuCWGxb5X0dYOpyhJEtmXsQqLa/2yX48wHE +jn5eFVpAULPuKDREDGy478ubFvs8nlYULUTsBACmoMC1CFWwy4irDZGmaAgwh8xJmecCBgtUdw/e +aiPsKDHqjI3sSo24S6hvgD7CaNEFqDtKk30KgF23IW2UgVmM3YKhPlkeEV2PqYwEoOoUZHIHdlQh +UM11v1EiuFl3W1UE1XSYIsYiADF3TieRblMRRXVUutC3KViLShPMKDUKVD9FYe4oWGzSsyMCsc5V +tQ0xwhG4KK140tQQ1FnnrDo9Isp3E4gid7ALVbXWXFTjikD4qspVTEJt4TgeC8+6NAGqJwP3QVXH +ETxHW3ZZEcCUUgrEEQFAspRlGkTlAYjvJrsqy4rnAk6idxb2ajAwrOoSq+KpR6Cp07R1Kt5khkaW +zTVWHmjRUFmTi5VuqHFzjhGg79306aDhjVhtu3Irb3WevSxGBQBDVDWomI1/3va5gm02kz+ZgbGp ++BQvNwLzrFGFjLad4u2ap24MSENRo6KKqwtfZQ5H2pIVQYjKnEbxOqbA9qsmphlRYAsy9c/j0dlR +c41ohameraovALtLaTUDBOPGizoU6sqKOgJjsq1NxhyAa1TFJ9tu05xt2MTuBmDKSdtKKCii7zvV +s8kIe2NZ/ToVrE3dwU0UAQSadkAC1BAsc9vMUImHi1xuRlZQYd39cgDOTX3aOl7NFHJYIuKUAWCd +TfdDq0Y/X2wTaXVVAortwrQ3ypuiKuSmesfuriOhJ5MToKbmkZwxcN9zjdjV9HzHwu42oGmoLyMS +BwGaMMUmeNOOgeoZLOzqIQQJc6ySSAm129PsnAENZyQD1zYXndyqkyZKybLp3Rp3LHU/Yp+JAAzI +JyaMlwfAUmiiZ85BHUsE1u2Vpoyi1SAbgFlrSIvX0cQuAqA6KdCuUWJRQZi1YyxqoWXLujGQcOSG +IZi1Yepgwgi1yh32PwFI3XXdtAWgmiCiPOvHmzkojK/RXPSFHegMpLTNjSaEYNFPgFlKAQCDru8F +vXEITKbTF44vMgL0YBu3GzsHkyjtBEzitE3ZomBoKqhGnXCm62ALq7Ev6gypykBhhgj5VTmAluds +WxhrvggsasMmDnghMCzqybDFhVDz4NlY96bYKVaHE65ps1+qKqMATmGV+Q7M5r5WU6cHYDeXu84E +YLKdhbEla9sQBBhkXCtHvnhcLQaGTW2vbGIwAjDXxTaOpkhrM1eMiehUWbu3dz0XqJsZnMKGYNiC +c9cNGvMbgWo1J1kFsHXVqliLrW4Ar9pUBScA42zSdOG9GoFp8buMIsilKV7ZU9NqoqRo6HhJzTGW +AsOMAMMsZtwmMS0BmiSc6xZCo6Qw5YxMjmY+iw1a1b2hD2JU5NlmZzF/POatFfMyoX5GCDKWZVf1 +Sg3/HCwGV9gZzUDXW1wpjADAYtUgYSFyz3JEX5uOmPiZoG0zGZEry4iMwcFF8VYNzSGCosZlFOdT +RlMhqUCqQYGgU6qGqN4AgJKTUVQLVmgzRkCSTnCJKwGwouXVe6AIVE0t7KATBOLVKWwOMpC0OhE8 +ajMjWDRtx8Vk8TqggG0VgPUOaPweoeSsFn43/TiN8tiBZO5W8Ygpgr5yacN6LmANT/ZFip01X1ER +TR9pXdT13z33+LqmwVjJMpbXFQvPiUxDvBoDkmgyfrxorGVFx//h4Y9jSoeqYYlDLdRwNuM2daoo +nsM9YG2DumryTIzInDgfloGLerVytj21qNc9Y46FTk2bbgkPjJgnI3b6mzkVi86MbNk43bGXMfSl +lPZNkQioZtyy+Me2c9TVJVZVzk4WJFNhMuppqt/G2RDoFNRIEbZbFl2aUXeEhz6OR8DkVRJhz9ni +T8WPANoQKqRV6c64f62Lo5WBYVGyyHXKCIoFPYsFLhDraoJEHHiIwLFw6QiW2nRXlGgZAEudTZDo +50FZUQL6HCimBKHhyt5dBPbVLdYQAHNUpTvYvp6xOyrgFvEn5WohoXIrH6+cN9InJn+cnJ0qMTT/ +A6BKky4BtHR1o9fYGQCjcxI2Q6k5FkUzzxDYZFZnCQkiKKlgWYrOibWjo/+aa62ww5+BIelsoFHT +F7emekeR+K17sTq7stcDuk9m+HiM+iYQiDIS6lFBmoLO5h45QHBSSY/i4LlAu5au0Y+MqRlZeqWG +PALtXT0og+BFcxqr+LUQmJQtKnpWC8qjTNfEgIxWsNopa98tQWlIOnYmk1fep2Xk2S8GLWGGKhBt +JsXbStF9oaneBK0p0UC4KNtF40SDQe9BvLbbLeaqBzAIW12SM7uQMgYorb/FCKP0SumZKigArpLK +V9iuYmBZ+oaXBab+geKiFYjWDICcXMe6ZaI+eXpX3Gh5GU3LYsAmdJXZqWmacwDAuOqgS2iLGkYZ +yOI/H4r2q4pLHoAp6tailhUiNRdvUgumzG7SaXAOkTZVEilywsBsQqFPcERgU0b9k2V26rOklC5l +4Vg8dzWUToGz2YsG9qH1XMy4LUlmaPEpdqq6IWZMHOM9T+ldOENrZU+ibi/YtqqnPIhTCM8RWIZe +5HREBKZoGQc2xRHvqq6HVoIiwCGW0RWJDcBqoststhLMJ+RGLDgVh7ytDFS/2jBluqu8sBrKwJJV +IJQ8JwFqMAwICGq2Y1sbMvJJysuyrvImm17BLDq1WrubhBCYpJLUkwLqb9Xh1TUOLSlCsJphoQjW +uOi+s1h3S/fySiIgkpXM8WARXWxb0sZNgG0X9TOr/xxfZV59AjKC6JypmtACwJ4eXdnuRNiibrHW +ZwGAZ9Pe4qL8brGYO4Utb3xTVssZRZB+Pi32+cbBy+IzGTU8VlCrN73BohUA1vSfwtFlASbdxCTt +hGAqZnssD9EuutGSU/65gHNRSU0nCRSsqbGFPVyCQmLIzP9ksTVJtOc3JUvLxW1JMQ== + + + Yu6ybiBqVyHGpnYoqygFrSLV/ILlbMLHlSe6g+PrQ3Nai7x71e2PfJZGUlBtUFP0kSJxfBXORRSk +zQydtfU+BXMmmNjGl1Vz0nD8vSQOX/IK0HxzBKtDp1h+apE8zXEFJLdWempKydzxYVcu2dzzstsz +sFRlajHvGYKXvvNwZKqg0mU8XBXpWnT8gmnJJfP5lFHGZxc8SeLRwr7KssDojmbLUVt1eRdx/UBb +0PPNgdqBFmDoAZEidhuDw5qNXRr/ETUbYWuThk4KYa6sJYFLflHJphL3pLaSbZeWcxPaA1UEe+oX +IugpDOL+Q2DSFAYnhTJzjsFx1vHqeWKarVKK06AoKYER4OSx6P0qIqtwqqZsh7OOTMtmF1qKVMFh +akqYJP5iFQOLDtpEBr0+K2P7blbdNk0WEAOdz77KXlLdrtM9oADWSGTh5DMGhsW2uHVRBN0lls0l +hghWnYcaksK2kqPV7VUENnPloEhSBD2amyVpBald21aUV+cFJ6FtFGT1XS1FP6/exp4SgMBFw/wU +6uXPrxzFXr3To1RLG+3JqNjSFkKwrIiCHsRs81A2vm45WApiaZafI7FC/jw69XQSRIlw1JnX6qBU +ATAVzZTofug6u3i0NsxRV8HSP12T5rvMupVWdP1ZPrI4HPDzRZeh2uDY0pZLNN28eg2SBBSf+1qc +ThUXFnAABKotH5mXNwBLs1i0eu6waa2apm3HNrCxZQLNq2LtqcsaoEZg0X6Rn0HR9sSpWWQ0ANes +Sa9NVDJsmTT7e22q+1TM39Yc3yIBiooRFj17Q0npDNSQs6SPM4JgZ52E2ucC7plndNQZgZHTFrkt +25QAS8lUaJOGCI56joz8Sc8F3OchOU4MbCnJcgIIgWuyHHrJZgIgjK52LemkrZgAqCyLllQH4CXr +yaQsnk0AZjsJJhIVyV300MaqB8wIreVOaTpuDc6ppim2AAQ9XhHMS0egkhq3/ho3bOxnMZBUyUpI +fFpFEWh+DG6GLBGRAokKYba3sAszXvSQHVnFOr6acJnUVYMEyAaU2LkswLJYw9b65+00CQUvZHbk +KgQEzFVjoMbdk/MfVTx+qdntpLLKZFw0hZy8HzpD9ZyincYjcFawe1k/M6bHUXAxzDrcjgI8A6Uv +07wKAOr5ssTHJUSmyBDYSSVouMwluanFQBhBoalIcj/KiEXPYvSMVWxrZwTJphVg0XVLWZwipCSu +hi2X2GViiDrcsgOjnEt2DCB1QZn13GAwjxnJ3xTc0D4XcJBk3tRlogfq7IY9oUk6QPI6U7NNOJmk +K6vl5g9A2iIZ2FUejIzpUiRT+7nugZLLGrv5iRurnt1QPyoAFxMcFJpTRcbxIQVTXUX9jyxgGZib +8payGFUbzE2PS2mCD1ofiyFo3dauZVVaNQKFlmZW+RewgNNzM1V1NRrewLOFh0eV557BnTjXW/H2 +laexNQB27souhJ4F2YXlJIw6LNRNniwMh24QidVAx1TDmk3niKy3mYtHMoEiZlo2c8XQ4WQCSxIJ +ur4qC4SoCRjo0pPUQOGhetSCvUwTQ9AnOOvxNArPPGOnYlY52Y8tkGs0Kl7JswUgrHaZR5pVjA7b +pWi/LPEJXb7i9YnmukL3tZxDw7Gv6i+mXArBakHLbIpHZDvzGcdlUi7KxGYBP3F/R05steCg6K6R +NXX2KgbLOIkcQn3GEVJJG4o8gZ9R3LVJACGStaPB1Fk0l8jODY3yqikaLccSA8JrisqEoGhB6Cpa +851hTDkrHyn0+oyiz33SqKaHcepZl0iywAiANXMJI6C8ESNQXJBRQ5EYlS9F+NXFOiURBAHHJuk1 +1fQ8OYP9TBITgvSVchA0X0HP1USOWz4XMHVd+isxfASuglftgiQRdgZazAlzJkSpi+w1fEZJG33d +FFm4mMkhh9RiD3AkOdDKnxdLMiVz44aexgBDJ4dgJV9VU1loZTJaiSgAsAYlYBEHOQCLHHSE7b/O +0RAssyLQECEl3rSo00sShIIZBpGTIBhBMNsEPYEswV3iz4hgTja7VM5RjpHOegoCPIgVs5V1FCnr +jRHMdig9mLQHYN9YdHZQVpyuu2CpZtVCt9H0gyj5G8JDzrVDhVHXgWkNsR8SkboBzwWc5OR1sASA +GM1fHLk8AgNTKoKgZzFGM2WjHUCMvbQBHZ8WGI0Gv9+MQ0yiTro8ZjnpgTncVWcRRTCeUbo2FTSS +OaRyFsFNF8eiCcSLpfVF3t0FWGvVVWt87XnokVOjnlF2u3pw+9zEpHtJa4hsiDKCGeSOrhmK/DEQ +9BMBakgYgTaE2dLfEG9WvHWR0xvNzjBFzvNkYIm64VsORMCjbKtB2TWIwNSnsRwAaha6BaDpc2G1 +A6exn1WpfNyB2SUJNniuplNle1VIbtknOxakB5ExZ413GjyqVHQSZStiEJKdh8f1zxsrAkPQHoie +645AReekCGhrNm0rmwcA9YggaCEyjUJyY9DPtuJ5KwlGxH46KVnmb+zHdVBNUcFLkW5GEC2rK2p4 +E092Zd2BNds7RCtSEm/tjD1CJZIg6gKfqulBg8hRt2d06k4toGi6PgA1kd6tejypWXV1UBr6Mz7z +K4FxUd6e0flojQAGdxILD57LOSgASyQACw1IDmGwCN7cjzIHPuRBCHDwpSZAtCOVpAEqD0NIWlVB +D/dGPmGtCMJsIo7tEtoebRomq8oQJMU3Os2ZFnCTcjySh4rFHppOLTUJECgZZcEdvMA6FpU3+2Cx +2Xm27JCgKftYoUNPUYWeKI5g1XCDHjAgoDh9TYkiBKsJU927qEaImPKBnRHPFZzYYAwc/1BwmHUc +pEYHAues9FZOekSgRg9CV6ixJAqluBFY1BgsC7OGpPsy69NUGkdyt0I/ZjG32aJikU1Vrq2jjqmg +rlisw0MxSuGtbCpY80ddBFEzN7A6EEw8YU7V6kC91pLICEYQLWJqFvqFqkP/QOWIsE5RcM6DEKRI +UmJVhdvPRZ0SLekJdJI/0jJqIYieKIPgsqiZX6xSUliDGIi6os8p4EpJaE62YpnRKETvFZztxIhk +qJP/15KThTQEZk2MmXuQtTI2BqtbuvtveyIXAosmE86WolH6efVijqhC6SiaNd7USt70QLtWzIxA +yqiUsYCrhmOMiOLyI4IkmGMcIGjOQZwtYn+G97m8MDlWkGfyXsDV0nlr1pBMzZo6RCeYnkmgKBQF +6s5Rkul1xc5gUUxHw1ea53ZOwMEoU6OsaDVQBqsWY1mQ6AewdN5YeacsiavJrpxcpL5cDkxpmEGD +mMlqvBQ69Xbx/UoYbCqrJvTSCNwreFHC6qw5BiFpxNSCe4tlMVLEVC3+Hsm0nIyFj3qsnNuTNEVh +83qha0hXyUwUwsDKEdhsFn+bDShKMybR5J6RrDoEegcsWSVrhlLjQxVMrJr8/ZQ/Jkip63tDlUw7 +OjuoHmaScfcCzs2OUqDCoccEe2kF8hA8v4xEsIfZCntl1qHuBayivZ/jxDoEloMmyZsIWy4chZ1Z +i5JVLyqlP7Sq4bxzAmSMlujO1ZFifq/gZrUjYIylnIP4eVb2d2u/z5E8p5qAX1YJEME35fOrAYr0 +xyACFa6LmHQzFwd+PoChm+xWea6fP4e4j74heqgAYEX9BUu3okzEOs1hpWRcHEm8DgZ/aPNCN5Ys +MHGovGvk+0q4AiDodQV/D6+U/Op70evaEgiMZZBIp1nlkNfSgo05halR/GMhSLLHvxElY01st866 +VlBHAMXVyooEURE09gY6eMmq0gQL9YkPUwvlxdqEG7KrUJm6pP4iqcNCSoqIvIXlr9I1zyxbZsv8 +nvFlqLuAJdjLR1EUqCFQjsl8Q3xZ8Pgb8QUzNlct88M1iZY1WiB8iXLoaVlRm7RSMhjAaGeDvmSp +lYetNYy4oB6COxjiRU3z5uKAfSMLCk+F4ZpEihOmZ9wLOK4tOPDzDTiyFSM044TCWz+xNqPqzWte +mwMyK4EteHWZb4sKW4w0pTtWDxQKVIuDF64bwjw4cMU0KePXlDCQR/mMMALqEMHmmca2jjmG9QLH +pAAlvi6swnjyIdE6bliTDFX9ZaVQLc8edDAwEJNwpYYclhAsRMPM8vUbWVWgohIn5BiQDL3UrQh2 +EAwrR60W3LL09gVdWlU9k8GK3aBDs4hKrudPsFCXDFC1fZRCEXlV5sSFCZsxuoO7Pk5r4AavIZjh +OSbuLrGUyyRWyjJD1pBbj2dDlIVF87ev7YhbGE51EHQKZI8UNqTRUZuAi2JRW/Ru8YJfMFzYGEyJ +/VKsMqyyhEDklJuLQ4bL4sdpudl9L2M3xyqTkEzC+w0YQzCt3GgpRSIGR7zX5EtULsOAzLkkRdqG +tng4O+YBqwcKBYyggxd2eA5YV9Q60oYCBapME2p7W98vw3qBB8ijn3z9d7t374+vvnn/6u2bF+/+ +evNzAP30v/3s5u++ev/u1Zvvbn761Z9ffP9y//ol1Zv+8+/++v3Ln938H9ho/2CjXxy5yf8Jf3Ef +/X6imrToTcUCRKBpUXl0UFCpXO1CUWVXcDxoQe/E+xTSDsp1ZclC1uz9BmzZK/NswqKaZwmYF4oK +eQLq8HHyyNCW6oOUEWmHyft19BSM81ZEQkc682G9kQABMoJOrLX1vTKsFziAo0encwtV+IUfZiok +D0ZNoCLoS8ygvCNfccdn/aAEum8ycaF0Yy5n0yFq0irvN2ApY8IE8y6OHKPTeNw52K2qAyp358Ri +0LXFDK6wbrB2oFDACDp4sZxSh3Xm8wkjBQJU9iq11tb3y7Be4IGwN+C1TVhbGdRYvVKCr7wBczcS +V6PeNRQpCR2rq9LddMZdUHwFM1Vdud+Ase6SOY64XixOvWo7TCs5dtg34rcClW8dW0pJxBFlB8rr +lbUKDlyCbUQ6syt5fL8AlbVKqrX1nTKsFxggrJ2xgjVeL7DiXUF0X0KOdM0ImB+V1NdoVzrg5QgI +yU59ZR9VlXmTxXjyUMmSZHrBxtVVrUVVZX11oDI3lDlu2uKyDssGawcyAV2sMDRwUGBEOvMp7ZEA +ASpzlVhr67tlWM85wLwFs7Mtla7LmANdhQFad4t0zQso9mQRYOh0SXRZQsp8yRfaCJ21YFoJ4oiH +Vu834GSRXCwoXEhVaFIPhbtWCu+YAuSuoZdT5721xTUX4gZrBwoFOjgKDnzKZsS64IHELQUCVOYq +tdbW98uwXuCBcBcTh1DCxkbqFlpXDfM66E6KSHeTJX8JWWG5a5zFuxEZa8AkufsNWEpjM61cbpQm +nSQaoM4pFosAlbOpxmXTNkoRvwFrBwoFNu0FHNgNOWJduIDZSIEAlbNKrbX1/TKsF3ggnF3o7B/J +llipgj3oPGsdbvnhaequ/ah2dYpsqaU2Ro1XCLMhNIC18hM66tMqZl6U4ngz1phSy4SAyl6x131b +TJBRi8eweiBRoAgUHG6jhRoU6dIDKJ0AASp3lVjXtnerIz3jADM3r2ulC9iWvASSDg== + + + M2inI2+DyIKKbgO6ZMmu0BG5lPVtTUvze3C0zPkZVZJFxL5WsJllxXWgGiBlrXnTFuO887rB2oFC +gQ2OgTW7w2ENGmh2BDBMWau09pa+r4byjAHI2oU13JwC6wrn1/10BuvVRP1uLXbMGINLUvy1LcZf +hWLsfFb6VvG9xFs5xYJl2YuHmXknNoZvyXc6DCg7kN+uH+9QDVQ4nH3e9bczTHmrdPoZ2rtpKLd9 +/0LzZPc48+T34t1b1LsH/3w7FblW5MeredsGH+IziumCoi6yh0zH+w249PAtnrVgPXa1DFgry2hA +4rdlAfi2WDcvlg1WB0zOpnXgwOmXI1a8cKRuKRAgU9CpdW17vxzWMx6QpPpyg5GqEiYmTfIR7zfg +wMn+VMGRrX3Mpm1W3HKOqwNqxzixf2iLnsvUPMoOkXfzpzu4cB7piLLeoh9j83oB6sgqqb2t61HH +et77axmLnM8yS+coLHm/AQf0XWl5TcAhG5lWfIHOwUubAypvy5qXTdskh+UHrB0oFCh7Fdwrrjms +1U7MOgoEyAg6tb2t65er43bGgysZi5SXk81HY1FIB0YlIih3E+VBIcdAR9Ops6TogcpddKdt2mJs +s+UN1g4UCpS7Cu6VOx3WYuWeHAUCVO4qta5t75fDesaDa9mLSAS5WFd2osjcdVA5RsLA7nOuISt3 +ubCqAZW7LerctbZZDigMWDuQCdDPK7RXJndIi92k5AgQoDJXiXVte7cc1i0HrmQvcpbYopow1ia8 +34AD54g8k8K/api1Kku1yIVSBuSuUQmpZdMWz4rGZYO1A4UCZa6CkxVddFizJTk5CgTICDq1rm3v +l8N6xoMr2Iv0/rrKkNWoqRAOHDgtl4FxUSBtn9wvcdorUDm7iGx0bfE0qgINawcKBcpZBeMlDLPW +q1as2Y6/OAoEqJxVal3b3i+H9YwHV7MXUV5RDhu5pzCB/34DDpzMwv1oUeddkhOjWKE76BQnoLI3 +LvN52znX5QyrAoUCm/kChl1Gjgg7rHhoJ2wpEKAiUGpd294vh/WMB9eyGPH+v6ZOHCoycn8G1is1 +EJiqmh+9b7BRVgfUvqWow+Pa9qimw9qBRIENj4Et+7JjTV0J6RQkr7B0aoe2vV8O64YH1zUacado +TUaPTgDcn4FdjfnFfBM4tsKKooZ2VXcF3dw4L9uWNYRwhrID6fX6+Q7WsxUO6TD/9f0CNPlk/hJr +6ztlWM8Y8A3ngfwbxLY+ZDqyIfOvYj3GbJENbz06cOH8gmdcLJrOS/koF5YdbtGHyYjpWBuWspR8 +2yTO/AGrA3rr0YGDxZ0dVjm7NVIgQDY/O7Wube9X8JXENzwQRfGLDEe6hUgTJnADvN+AMRmhaGlu +PgmBzHJlpjsHCaiM5YpRvi2Wtl15X+xYHVAoYAQdHDStziFd7IiKI0CAylcl1rXt3TKk5xy4nvGI +ClQRPz8VRLnfgDN5fpjcRpWCkF929AMULMn5ECB3rWGZyTS2xRM1JbQBqYPJ+3VsFGz5zx7pYgl/ +jgABKm+VWNe298phPePAtUxHrD6fghpuRe3yDsVLSRKvpsqprzTtrIb2KufTDKi85Vv7fFtcz0l5 +q1gdkAkwgZKUt3qwySEFg2mVSyc6AQJkAjqxrm3vlsO65cDV7MZYNOcEbzXNS2eugnM/XVT5oCqv +6dWYy+cEDajM5fPAQ9smJ1sGrB0oFCgCBQdfpF2xBjsT7SgQoHJXqXVte78c1jMeXMt0xBsOJHgf +Obv3fgPGuwLZ+YMXFEQ1GTTZjm4XGIDctxW33bhpS5ezrBusHSgU2NyflTmt6bsUaeDI1UhAcAE1 +R6xr27vVkZ5x4BqGI0qledaQF54aut+Ak7/MgS9IpUknmcx4PUMLiwMqX/lU4NAWKy0qXw1rBwoF +iqCDtWSzw4rxlrJuKBCgMlapdW19dw3rGQ+uZjji0ulBq3nWzayDk101ixdo0MEQziedlb21qp+Y +gModvjFkaAsbT1H2GtYOFAoUQQdrcqfDSseb0oYCASp7ldqhbe+uYT3jwbUMR7pyJMiSyDZ3PdSU +mKqJmUhZzCqG+fpVA2rXqmRhDG255tMGawfmtbOmQ/WWho4Ta3MYUN8vQP280jq07b1aL8Cyzdsr +mItIbm5qjhbTFDxYT9FgL+iQ0mbQc5r9TLBZE+Z01pavj9tg7cBxVRtYqzYNWGsLZwTU1lnbae0t +e6ccyg0D2Fz8mDH3r2HH0UF9nQ/djnPgXvodC/uvRUw2rRaW6Fax5oDEjIxVQWsb22Z086su5wrK +K9DbcQ7cNSyHtSeDOAp8Moij1rXt/XLH3M94cAU7DpCuVV05WEjofgN1t1asuF1I4MduzcAT0mt0 +QOXrHFIb22b0ny5hxOqATICyVaFBr2tzOC2j2b9fgMzVTqtr23tlSM/6fzUjDq+9WHS4ItbVut+A ++32jWB8jN5nHWjeIbmxIqwMya2a5wti3zYvtUB2rAwoFOjZ9N6MiXiPWhWscjBQIUJmr1Lq2vV8d +6zkPrmXG4V0huahbcW7GXIViamcU3oaU9DjBwt7ORDWOogMqb1W56m1xNQeNvglSB+PXmzQRaLQ6 +QA5nsLvw3PsFqJxVWl3b3qmO9az/VzPi8GaVpmNGxV7vN+DMBTmY3hg1Iqd3NULfqJxLBypvl5Q3 +bQFIJ28HrA4oFCgCBUe7mcVhDXaVgKNAgMpdpda17f3qWM95cC0jDqvexKwGqirDA5RKwTK5adFI +vRS7pStfcuww7liTM7GuJU079fopygFoirCD4kF+KzukOIPfw/T1we9hnVLXtvfJYd12/xoGHAl7 +HUI6F3m/AfeT41S1SHNwNecYugUqYXVAZSsdS9m2pTuIRqwdKBQogg7WS0Ec1mDFwR0FAlTGKrWu +re+uYT3jwdUMOFw2iw5kxSvE7jfgZCorEkyFgxCopwQB2MIaHFC5E0pZNm2b6awOaxsUWXXVDmC/ +9gVr6JtTpyCMG5lSO7Tt3TWsZzy4lgGHNFDdGk77D33yOvBc9RopLrpIxk40lq9BnSIE1L61qmF+ +a9vwXq64wToAzbodwFrkcsC69puwOgWrRbYGal3b3i+HdcODq1lxWLqs6cDBaPXJ28FU0lSAxSJ0 +feSraKJx3EvKOp+35UuoN1g7kCgwBAaWQvQD0rWWs/cjTD/dSXUtrU8d46b7/342XAYRta7J2S/3 +G7Bci/eMKwdK/6rVpsHahRag62cDsSZibnXTNroj14rVAb0N58BSLm3EunAJwJECAfIG2qntbV2/ +OtZzHlzBhsNrcdZFfCjJ6ps4cLbYP96yEnouWtPLRLhGhgGZL4uUiRra4vHbOY1YHVAo0JFRsFUd +ckhDZ3YnIPQD8p7Y4Fmo3TKk5xy4mhmXe5gw8em8+w04u8qYsRWxHpKW38AqrfPqgMpbPtI/tA12 +INqQOlhyhwYdOPZ7BDrSYNXGHAECNN62bVvXq471nAPXMuKwvGdpasRk46wCM18kzNSmYhFguy4H +RrV1mDKWq937llhWOGxQOiC9XNmqwK5bOZSYky3lYvrbBahsVUJ7W9eljnXb+asZcHiZkx3MobJ7 +9xtw5lKnz+Ryo6YhZb1fAaX4sjigcpYLVQ1tqU5jG7E6oFCgCBRsVUAdUqzlYkVqlQABKm+V2N7W +dcuQnnPgWuYb3nJlyWYkke7PwBJEz80ZzNH2D5h+DsZ8wcOLGtfXlotcbO0wDrAuJR04WlF3hzPw +nZPj6wVofG0ljG1dlzrW8+5fw36j6sGW7bvOvRZRP5OX5e4OvM+rxEXn26xsXeqSHFD5SsV5x7YL +Vg6JI1YHFAqUsx2sxcsc1l6y1VEQesEHT21vO3RXsZ7z4Gr2W+5evMj3qt5vwOiba0qG2rbF7vma +12XpMGVtspzJ3pKKKQ8IHVBerp/vYLo8dUTaq3W69wtQOauGtbYc+qk4zzt/LcMNx5ZKWBLmWQ9Q +juBqta7ouB6Pblrsurimmn0/o1dml2SqbVEiJpVyinUEzpqROIDVQTxgLbmFMwoIaLw1al3b3i9z +O5/x4GqGG9YMi3ogn8K792dgrZqJQNsD3Mj3kDYBtXMtahKkb1taPcPagT3uPIDttl+P1WRlf3/r +orZTau16jxy+Te8fY7ct/3qJlAV9Lc5suR+AWWv+0Z0EqzjbeSezO1IERHyoejeba7fBNBpJBsHw +KF8J6HBgpfxl8zKG8Sc7VdbSaO8It3281iE7wFss1YEubb7fgLOljCGpaxZFN6Wm10qUFj2Qu4U3 +72kQw9pGLpU4Yu1AoUBHQcE9oO+wBruE1lEgQGOsUNvbun51rOc8uJqFVnCt6MBFO1LjwHjjkdyR +gkU4opasSHbtR1msPE5S7y1ecTKrVWxtpULqiLUDhQJlr4KjXXHlsAa9kNQRwDBlrtJqLV2nOspz +BlzLQMMbQqy+W9Bz1g6a8YSf3jCivqt+CTrenZIcSPmaZo35WEs8gl/DBmcHJreaOzQOt8zMao7R +Pc/+9QIytq6WyystXZc6zrPeX81Eqzi7VQklsXx/Bm4SyKmzXALOC7roZVKpxOaAyloqXjG2Dbad +O6weSBQogr71JzlG5rAGK5TrKBCgclepdW17vxzWMx5cy0irJJ3V/MPE7/szsNHQw+Z2CdGCdSuC +AwprNs0Clz316DyIXmwTvqlXJYuNrBN41vur+lsFaPwUCl3b3hOH8KzX17DN8Da4oIVs5qK22QB2 +exffr00TTa5FxH4tasVZjUnaqJsGiqxtwLtDtlg9kChQpiq4q2wOa79KwlEgQOWsUuva9n45rGc8 +uJpthhtojZrRuqpq4MCp39MGBEu1o2Q5HnjjFMqwDlT2wqCft11bzhusHSgUKIIO9ldhCVasLpjC +hgIBGnvLWVvfXcN6xoNrmWgkjNRVTCkH9xtw6hs71lasxpyoU4fqWnWgMgc29nbWNjctN+RUCwVG +lwsxgMV8dkgj5zSOBAhQmavEura+t4r0jAPXPVM3jDKmZN6fQZtcdUO3sJn3KkXdRbp3gYDKn6Wt +9axtr89iWD1wjZ2/HUqVcUekw5Tu7gUCGoPNp+Ymau+WYd1y4IvP1D2yIMuHTMHf/5vVZwHmwQpY +tyfsPNgqqcy1WczTaq7MFbNUWU1z9VnmSjfrrpu20VXxMKzRVfEwc9GDrZKKx2o1VzwFrj6Lp7a3 +df3qWM95cCXTca4YcbHoj9Zn8WAupoIdWyW3yWquYMc0Au/qs2DHchhbrouUkjaEDuKqs3iw1VHp +CK3ein+1q83iyXRte28czrOeX62QZ8U7cdQattosHmxVVOZKl9dLfqkcX8bOwTdfhEX5GmXP7G3X +Wa6p9Fgd0NVm8WCrouKxWr0VT4GrzeKpdW17vxzWMx5cq5AnDHEOdrxMa7N4sFVRQXrLrGV9pd4K +9o1vYh1qsyAfQh1brj5OpDgd0FVm8WCrodJxWq0V/3ZXl8VT6tr2PjmcZ/2/Wh3Pig== + + + Vb81T0brsnioVVBBYFtXTYDmWiuAE4/7NwdUzmoOZW+7zlpr3WF1wF6XxUOtgopHarVWPAGuLosn +1rXt3XJYtxy4Vh3PindwrKpHqBPJg62CCk4RvkrI1VrBrmmFUVeXBdkwh03L5urtGU7vNLOqLB5s +9VM6Tquz4t/uarJ4Sl3b3ieH86z/16jhie+f1fC3miwebNVTEFgtOCl1VrBfmlHtarIgWK0T1xYE +ZdYKeoa1A11NFg+26ikeq5n5ngLnDfDUura9Xw7rGQ+uZT3SLtCNNK3J4sFWEYJmSNJZJ3VWEKgH +jF1NFgTXumnZXCFkw9l80WStyOLBVjul47QaK/7trh6Lp9S1rc52NZxn/b+S5UikWUlbq8cygqVy +CgJBjvvSKwJcmy/Son0rlq7u2pa1tTOsHWj1WEawVE7xWFNXUjoFySspndqhbe+Xw7rhwVVtR5om +q9ZYsXosI1iKpyAtcvNB0yorNKMWjV5oPRbqX9i262VXHcIOtGosI1jqpnSUw2rSd7taLJ7McZWs +/bqPks+A/0vUYpkxTGFLuFuKDmxVU+ayWmVvq68CK8MmpKvFMuMNX3PKm7ZR7kcesHagtxQd2Kqm +eKxWX8VT4GqxeGpd2+aksGE948GX538iUrn/o7laLB5sVVOQ1H7Dg9RXwW51DlotlpkuZdP6mtYW +b6ZWw96wdqCrxeLBWjbFI7X6Kp4AV4vFE+va9m51pGccuJqxWDAHVb0LVovFg7VsCpK7yFlmq68y +0617S3BA7lrG1bRtCwZDv0pCkHaYq8Xiwf0uSofU6qt4AlwtFk+sa9t75bCeceBapmJp/qoVOWHt +oVY1Bcmdc/RlV7hrfEn0UIsF2aB13lxbWM9RYziGtQN7LRYPtdO3HqnVV/EEuFosnljXtnfLYd1y +4Gq2ItBQLXvOarF4sFVNmfF6yVTGWizYt5b13KTVYkE+gL6UNm2z3Bo/YO1AV4vFg61qisdq9VU8 +Ba4Wi6fWte39cljPeHAtcxEwJ7ntw9Vi8WCrmoL0rnLW0+qrIHCuy7YWC3ZZjQXXNuOd22GDtQNd +LRYP1rIpHqnVV/EEuFosnljXtnerIz3jwDUMRpRK1coNai0WD7aqKUhqlVu6rL4KApd19UVXlK8l +qffH2hYwmi2IqVg70NViGcFSNcVjtfoqngJXi8VT69r67hrWMx5czWDE0bXar1aLxYP7jYEF70Ob +zQFr0xaGMDigcqdJ7XvXtrDXfMTaga4WywiOwdoq1sgW5UiBAJW9Su3QtnfXsJ7x4FpGI9Iwm6Fh +c9dDWw4qE3KIVhpbCUuhH0joCzIuGijvLUPUyehQdmC2eeuhYck6RRWnFkLwb2eYflzp9C17hxzK +se/XSgQlYoPdb1FMS/BgOShKnTAzUW9WxD7EVhzQZkzWPE7XtmY7sduxduC4og0sRVNGrFxdZSRA +67CMtPaWvVMO5YYB/25n+GY8C5T0ZEW34RzYKqbMGXaYpqaG1FaBJYV38HogMSNHO8/o2mKETfU4 +w9qB3oZz4K5dOaz9oh1HgavD4ql1bXu/HNYzHlzBhsMTbHJFXq/D4qFWMYUonTXII7VVsFdZDpC7 +OixzRr1HY3PWNtiVoA5rB/Y6LB5q69/h7DdLuve7OiyeVte296oj3fb/agZcxrvTo+5NWofFg61i +ypyxQOUsyq0kuWPXSrSb5bQOC7KhR7itbbTdyWGNftPUOiwebBVTPFarreIpcHVYPLWube+Xw3rG +g2uZcIC5Bq0ooXVYPFRLpiC1mqVqtVWwZzVq5MfqsCAXVLFybaOrjq5IO6zXYfFQq5jicVptFf9+ +V4fF0+ra9k45rNv+X82AA8xpVRXB6rB4sFVMQXprUq1Xaqtg3/QGOFeHBfnQoo6NtYVXND0qZVg7 +0NVh8WCrmOKxWm0VT4Grw+KpdW17vxzWMx5cy4ADzFppp9dhGaFSNAXJLSXo7Ruz8rYltT20DgtC +KTQxtEyWReJQeqApwQ5qFVM8zuD3MH198HtYp9S17X1yWLfdv4bxRsJeMwGtDosHW8UUJDVX9Rjo +LY0ZK9Nq5SCrw0J7S1CfhbXFH+0uRMXaga4OywiW87ceq9VW8RS4OiyeWtfWd9ewnvHgasYbLpui +SYNWh2UEQy9X6Ucvxi9pwwhcpAJd6inGtEoXjYVa2+x0VsOaB0VW3bQDWCxbhzSae9EREJ0r0hE7 +tO3dUqRnHLiW6YYDHFT6WBUWDwbWLFWFrV47hf7QGAQYsp7BCJqISD2eLc1e22Ys+bdusHagq8Iy +gulsx4g19u2pUxDHrUypHdr27jqsGx5czYZD2lZN8bUqLCNY6qUgUIsnxr47FCsoHsedJLZ23raX +s3JYO9CqsIxgrpkyIl1tzPv7tQrLSGpv2fvUMW66/+9nwaWCZz59tuT9Bmz1UkDhhkWs1TGlsgoI +NxeasyoscwqmjLq2oPSDxbrB2oHegnNgq5fisVplFU+Bq8LiqXVte78c1jMeXMGCS8UK4bsqLB5s +9VKQ1JpnyyZjNwN0K+XmgdytiLerb9viRd5amsywdqCrwuLBWjDFIw2dLZ0AV4XFExs8C7VbHekZ +B65mxKUeIHRVWDxYC6YguaXf7cGVVbBrObXogMrbtOgd9tYWj+toaE+RdpirwuLBVi/FI7XKKp4A +V4XFE+va9l45rGccuJYJB5jTojf2qnnsgFYyhaiVoKPWVsGOlailS83ISNEu8e0t8fJpjW4ayg60 +Kiwe2DUrh9Iqq/i3uyosnlDXtnfJYd10/mrmW8JUXL3BwqqweLDVS0Fyc9aoj1RWwa71qwStCguy +Qa+Jd23pdui6wdqBrgqLB2vBFI/UKqt4AlwVFk+sa9u71ZGeceBaxhtgnvstD1qFZQRL+DxlZy5H +2z9Wu08t2vYBROa4ji3x8EeuI0YPc1Kyg61eisdplVX8610VFk+pa9u75LCedf8a1htun3JxhavC +4sFWL4VoXbQ+tFRWwX61efXlVpSv/bivtY2W8euwdqCrwjKCpV6Kx2qVVTwFrgqLp9a19d01rGc8 +uJr1lroPz1VhGcFVUp8THi3XO8UKH02kzjWNFxQ9xkgSMNV81hYUmHWD1QOtFIsHoyugKoJiOZhq +NTgKkrMwHLWube+Xw3rGg2vZbzjESS1LK8biwUDFqsJWlXH0hUYlt9flI6DyZm226WpbzEo1802Q +dpgrxTKCQdOx9d/s9vG1LhsCBKi87ZaDa9s7a1jPOHA16w2JSFrW2kqxjGA5K0vApcfKOBKcsoto +WykWAic9e+fbzmp9OawdaKVYRrBUEhixtnL2/tblbafU2vUeOXyb3v/7lmKZY3e3eAvOgbWIyhxR +6xzKrMwx2mloK8cyR1Tsh7ItMDEsQbWj6zBvuTmwFVPxKLXmin93r87iiewtvUvJUJ51/FrH7CJe +fhs0f1ErtHiw1VJBclPTvCipukI9k9P7rkILMkHP5Lu2eNJftT3D2oGuQosHWy0Vj9WqrngKXIUW +T61r2/vlsJ7x4GrWW8zO22wVWjzYaqkQwZaLJseosXOpaAEcq9CCjEhVLWZru6CGuWywdqCr0OLB +Vk7FY9W6K56AXqHF09pbZuduN5RnDLiW8RbzpkTK/QZq1VSQWvVrWd0V7FiXGlajBXlQqp4ZtLbL +ed0XD0xuTS/n9VQ8Uqu84glwVVo8sa5tPq/8cs6Bq5lwEVOV9RS6VWkZwVJPhejtJfglOBi7TeCq +tCAf1qoVTq1tcGqJYfVAq9LiwVZPxWO1yiueAlelxVPr2vZ+OaxnPLiWEQeYVzssZVVaRrDR0IPq +etYqko/al27hnkW3bVlbXJ2qxhm3OshKtXiwVVbxOK0Gi3+/q9fiaXVte58c1rP+X8OKA6ygY2zr +tYxgt5OFvI71WrBfWkHN1WtBcKibei005XDdjFg90Oq1eHDX6xxWq8HiKXD1Wjy1rm3vl8N6xoOr +WXGoq8zq57B6LR5slVWI4EUTKDUXJKJiqZdSWL0W2l8sgdK11TviHdYOdPVaRrBWRnBYrQaLp8DV +a/HUura+u4b1jAfXsuJILFmqpNZr8eDUt3n0KQXdUrkGC/atWQql1WuhtbrqHVOubVq1rpBXNFat +KtRzJgYwl1bxSK0GiyfA1WvxxLq2vreK9IwD1z1zN4yy1msZoVJZhWjufi6uwUL9MxeA1WuhOWXa +q2sLBkDZYPVAC5MOUKms4pEOU9p5QRZnQ/Rz4W6i9m4Z1i0H/kPWa3HH8L501M8KtuAtSGrE0Vy8 +34Az+w8AiNvlXLX2hNzNPEfLCRQgDsGywH63zHFsuzSs3REGrB74/7P3rsuRG9ea6BPwHeqPIuwd +GzTyAiCx9UukbI/PoS2HZc8o4sREB8VmSxzx0sNm29Z++rO+b2UCCaBIAtVNsopdUkgsLCDvK1eu +e8YeHB8ouD84CD4ZgbucL8YI425DtDama0QGHSOQuME4tdSx+G0ZkEggeawmhMmAWcfWzNiJ4Ax6 +4SH54EUwGmR4lWZCBdqAe0GFu9KB2BSaIWDGlCvQqi9UQPJ+vaiubJEwjvWCX7AxK1IJsyWliFBp +mnoddHSSDxidXnRRIkuLjTle6GulMxGwObu0SOpUASNX0yQ/Rqe6QrwPFYeMu7RSYDj8DC2GYEuj +pF+BdYVcSVb6kgQuhuYgTwyA3HvHsQK9ocCWOJqFEzohGLd4YeVsaTuOWCM1opKZ2kKMrOxcnMAh +pUSkpUuXK8ospJzaMl91q8Cocte5tRq5G1wfwgmEioZmWYeoaMNCRutSQAYgwzRU00U/JjZgbFb5 +Fllf9vwqji3aVgRMH1n91mgSygA6r6IUOEYVhQQRhQ2MxLXt7DChlbPVE3+Z36XzUNSbfcuyC5es +svSDZR0jT7BodbzhTMZbUd+IhXC1JtMSZKxsE1dSzuq0MeG0YOKiebiUJnwua89FqyMmCscUFGeS +Hlh+tibJ+B4kKe3J1vqUZLZVvWbbpfwJuPhcGXUEz1qKNaHWlDVncVZhJ9S1TfkA2lKTQehUl8p8 +Y/5N2mHEguP1q3XCg6DtSPJX3/wpvPn99duj248ffhZyfnd+ew1gBeCbv9xc/1Vo/p2Q/aJQ8NH5 +TxfX+YuDv7zHG1Pqq+//5x//cHEp1Rz8rvsp58zvfvjzyV9u3p7j5+AAuvfF16vf/Pvq8lpeFdKt +24sfP96df8BRI2fY7enoi7OfLy7f3p5f471d/e5P13f9O/zvLp5kvym/koPsH9cXZwJM51n+4T9P +Lz/ql/9++MPr0yt+h06wV9s6jl9nj+PXFxiH7OfZI/nXxdu7n2ePJn691SP6+fzip5/vZg8pff7s +Y7r58f+cn90d3Xy8fiv9O7p5ZG/0A3zH/S+f3n2YPcpBmWcf6jd/evPN5fufT9+YuWO8eJvxxveM +Cd/854webwuZvPt4++NH4fDPzufOghaducSpnecmmiKszx3Pj6cfzv9we/5/P8okzA== + + + J6GjUs8+wuub7+8u7s4eoZL9KD/w679fXJ7P35+DMs8+Qjt3aNcfr747uzv954KR5UWefWDYcnPH +dnv+4ePl/HMjfT6HAt3TdfNA19dTv+wQOP97Tk4e7uwD8/7MC3JxPXc5bt6f357e3dzOXpC+wLOj +2fc3H2/Pzv94e/r+54uz2UfcI1ORn3TXW753Lq4fISGDwdgX3DXHN1fvbz5c3M3ZNE/RAfJhj7b9 +u2/P362+3kt72zGOvbS3vSPaS3trRrkl0p7/kqW9d7enwvZe/uXm4sMrk/dmC/F7cW87xb3Z+3Iv +7u3Fvb24NxnVXtzbi3tfjLhX2Nci8C0ZyZaLfP7ViXwLRrQrIp/IQUfn/zy//P7n07c3//qybV96 +ZFIsfC0H5o+XHx/hVj4Ds7mtksGHu7ffnv/z4hQdWiD15IVejCf44+nHDx8uTq+PdAF3hZeevTZv +5x/Db1/iHJ4/kPmn8NuXOIaXUIBtp2Y37959OL87eg6a9kLb/juOcIc2/CX4FngJnt1c3tz+179+ +VjFmJn3+9XK+KjF+vd9AnzCWD+/Pz777+Mh+2D2OYLZvz4ePt+9Oz86/PztdgniDQs8vdcwenCzu +x8vT2+Ob6w93p9fz121a8AWsaUtH+ft/v7+5Pt9glH3BXZJNiqosZ8/Rlqs4TLlgLNut5CjskrH8 +9+yx/PcL8iB/vbm4vjuJ6ouX0Eeefx+36klkLnaIH3qdxoSFfMO2s0EbKXoWWxO2e412TTJaYiTZ +FmJwentx9/PV+d18A9wuEYXZx94vjyhTsuHg0y0eyCO8eD4Qs82iwi9u/kDcVg9kPlX+5SWI8qu0 +wi/mBrb96Ly8uPvr6cVjsuQXfnbujqy8XE28eMe90EL++fz2p3PM5A4xQUs312tci6frwN5laGOF +2levRJ22wCtlu5Vpxuw9hrbfY+jLChI5vrm5PLo9P//v2VbN1+gZ9fbi8nS+XXeXlBjmcHZc+e3p +24uP81E3fb4b2s3tljjnD+Tt/IG83eaB7JqI+eeb2/c/31ze/PTrDokme7K2Q2Tt1RCz+REsW07M +Xm0Y204Ss+L1uKy+mp2+LJxim7f67JHs2l7fOY/b1xuzP5tl2cfs3zfGl43Zn+2Hu2sx+wsI+bYf +SbM32dYfSfMlnB07knYyi8IjHiUZWVvmfP9CXvdf5I7fekeNH2dj2dZTr9kj2ZUgnL/NNqce/3x6 +fX1++f355fnZEn3atODzW4RmW1o3HeS04IudQ99efHh/eXp2fnV+fffn0/c7dBhdnUpVsw2TOyEd +rdK/q8lPM/g5d9T8NZ//Tp9vMaXc+pN4Wa7BbT69Zo9k13jvY4Qx/zmRj12hdwswa9v3yGwdwtbv +kdkj2RUOb34k8vMkXtmW3fdukX/Qu4vLyyX+T5fbvNLvbm+u5g+GHz+/VvIRJiczjD3mMZ5bxj6+ +SMzV7LH8iDu55uvG9evnN+pf/uv019ljEsp3d3q7iFLq99urCb+7mS953LzAQG7PKQLOHc7p27cX +dxf/nC9O9QVewB5zPX9cZ2cfrz4+7i2Ujywr8gIRTdfnp7PDX85OL8/+fPN2/tj6As8ffDabt8hW +LzX/Fw5h7gIOS72QSHJ6fXF1+mKpYXc1D10R9s4wWybZnb0aZ5j5I9k17cfeGWZb1L37CwsnOoVd +84aZn9Ns19xhFpDybT+UXo07zPyR7NqhtJPuMLP5z91wh/kid/zWu8OcvRp3mPkj2RVjyd4dZu8O +sy2H0RfgDmO+FHeYBTR/20/iV+MOM38ku8Z776Y7zALM2vY98mrcYeaPZFc4vG1zh9lq+8/uePMs +2HJLiccLreEuZg1c4Ae4X4UnW4Wny7mxA4vwdB14ocZ3P2njN3968y1z9rxZpvmaxRDtzhH1evMW +zVcD7kjWoudJAP5S1HRJnpw9RXuYotV7ivYaKdrsZd1TtD1FeyUU7fe3AviyWbRzTMFrpGd7Dm1P +z75MevZFM2ivlp7t+bM9PfvS6Flu1HmzzAr/ysja7MF/QTa8/baZs22aL3nbzB78ftt84dvmy7ot +6K8X/z6//Ovl6a9vlgU7bqPDTlWuqtnekzrzf1vgQJmV2CXKd3t+dfNYeoMdy/UyP6fIPj/KPj/K +Z0K6lfnalitTyf/Llfz3tfyWv1/Li9Vrc9m+uH57/u7i+mK+gev2/P356d23C7ZbVuLZx7fPEaPj +2rEcMR/eI0vM3NHtUo6YmdzIl5YgZlt4qFd4QeGPSy4b33JP/SVj2RVf/b3CYnvJwWN7ezftSoso +wpZTtw1NSlsfPn9z9f7mg7Dl3318hITtcgBfHOMOEYTT24u7n6/O7+bj2i4Rhtk6tV8eMU5lw8Gn +WzyQR5Sh+UDMSygjZg/kEeenfCBuqwcynzT/siuUeTcO0YVSzy4doa82K+JnOUN3x8Sx0ZrujAPR +PgBwb07ePXPysjSF26hV2puT183K3py8Nyc/43heqzmZxAUGZVt+vYjQ7E3IexPy3oS8v2ZkMrK9 +CXlNd7dHRbw3Ie9NyHsT8ufXTuyoCfk1GVvfXrx793H+bSbbTgoWDmdXqMHs9HQfPt6+E872+2Vp +/geFtteOpNO/bGyDMs8+tF/PLy9v/jV3fJcXP/18J++LM+TBnT3EcbHtXcC4O49vrkV0v56/7ybl +9kq3F1W67e+4fXw0e6XbU5DSr3+6PT+//lo4sPOvL67fXvx08/U/L24uz+++vj1/+/XN7en1T7O3 +2l4bt9fG7bVxe23cmpHN58P2KrmX4apMmG11Of3vi6uPd49c/ZgvSfr+2RGvnj2m80t5WKTyyUq8 +mL7n2wvy7yfYXy/lEfOtyhIncY/vEMq/JrXTh/fnZ3Jw3T6HL/yzS0evWlkzm0SlJV4s7U8LbvMa +xs7+/t/vhdfbYJR9wRdgvB/R5j6Bamqvt9nrbfZ6my9IbxO1NKq3iUocqm/2epu93mavt9nrbfZ6 +m73eZsf1NpdRofEqXCj2SqinV0J9H4W/HdRCvc78GRvoo7ZdxfYqI4CfU2/4QvRpn0Nj24jDq8mh +MT9jw5bn0Ji/IlueQ2P+QLY8h8bz3AOy3d7E2398Xl7c/fX04jErxf7s3J+d+7Nz44Fs+dm5zz+1 +bWfnUqq87cfmRsL0rhyd+7xTnzb323LsLl7Pfc6pJR14ocb3Oad2K+fU9z+fvr3511PcX7Q7lOgL +zy6wK36ds5Oi7SPyn30Lzb5Y8+0j5DR3a/v3CyDZ/IH8On8gv245Bdh2anbz7t2H8ztsidvzt4vo +9K7JAN9xpF+GALD5qr5GSWBbVuV13ye+F812WTQrTPXVXJScz2e8BJuxZCTzGY2X4DOML2eP5F8X +bxe4E8avn39Ebv6Ifj5/3PMwG1L6/Pk5qC9RqfEEWbR3h7vaKzV2QqlR75UaW8sKh9ei1Jg/kL1S +YwfE371SY3uP3b1SYxsp+V6psVdqbKtS4wsTze5OFzhavkbB7N3t6dnd6eVfbi7mOzZr4ZlrnFp6 +bv/Mw9k5W348/XD+h9vz//vx/PpsPsc5KvUCMenf313cnT2iwMolNnz994vLBbkSBmWeX/M128f2 ++uPVd4LF/1wwtLzIs4/s7Om8zJ57JMu0Wlsc5zx/JE8o8GzLqfD6kh0tOA/e3d5czR8OP3724bym +1E2vNdVReTj71pa7m/n81M0LDGWfu2gwuH3uon3uoidWLc+XSb601EVPojT6+8fbHz9eymTvkh7x +deZeWSBSbLlw9DwpV15Iz7skPmyval3LH371OrzH5o9jy33HylfnO7ZgRHvfsTWjfHEDRc+XvHkk +/P51mynucv7sFRkpyr2V4ma3rRSzvZl2zUiBLbcFKvG9uPe6xb0laLYX+PYC317g2wt8e4FvL/C9 +foFvtmjwGgW+1+uXNjunw17i206Jb/YC7iW+vcS3l/g+Cc32Et9e4tthia8wr0XmWzKSLZf6qlcn +9S0Y0V7qWzPKF5f6/tfNzdufbk/nn/evUeR7lXdGLIoR3/IQideY8WK2MLfPePHsBGGfxvOhgewz +Xnwih5HyQLwK2rzP37G1ZOzdpXB3egnxf/14eXr2y9crBd28Pz27uPv1vxbohD/c/Xo5X8cdv35+ +F+4lFy5v+85aNJhd20x/ACLu0F56nRrRZftlJ87VzXIObfutPx+YyvH4NZG3L4dx2MXbAF8Tw730 ++swt3zgLh7MrCpHZXicfPt6+Oz07//7sdAlHOij0/JryZau1bGyDMs8+tH/9vCA6/xJafXlfzOA8 +shGOi23v+sXNeXxz/eHu9LGrFHOtyrjcLinQjZu9eU//++Lq4wLTVvf9sy85ce7VZBmqZ+e0Or+U +h0XK5qzEi/FY315w35xEI+NLeA1IH7iHTyKx2nN7u3Lr655F2iUWKS3w4jN2WvAF/OSXjvL3/35/ +c32+wSj7gl8IS7jnl16eX9qzS3t2aW4fvo+Eagf5pddpDdiAc9p2ZvB53KS3f532KvNnSCd6e3H3 +89X5grzuu0QcZh+IvzziU5ANB59ur5zxyyNf5gMxW70ij2TwyQfitnog8ynzLy9BmF+lI/FS69nW +H5+XF3d/Pb14TKLen537s3N/dm48kC0/O+czAVt+ds4fyJafnUup8rYfmxsJ0/uj8xUcnbujh97f +0riNvNCTU8IdWIun68AOIcJrTUW0Tz47GuXupSJ6vVfkbWQx2G5W9O+Lc1jvGt+2k0mWrk6lqtnp +JXaBsJtVGf9d96uDzB0yf80nG+nzHdhf204x/ihFPzzuPLa7BIORVH9OG3BXKMYrPJueNf5rW7Mv +7FN8PH+CtFeT46OYLUxte5KPZ1FEPfOYvvtiolx3Lj3G63TiW8y6vd4dtP32FNgbMLK/v+IEyLvo +jrDJumz7PsrHNDuscVdYbXM4PzZqz2zvz6TPsJd+eHd++4eL221QkWzLOt+d/jh/jXdBoWlXs+0c +HPv/XKaxHJR5uVRcH6/P/rZD1OTVYdlhsypXXwae/XGPZy+IZ+ZLIWdHL+ViQmEHUdd/vz29/vBu +xi0S24Pvr1Mfsgmrtu3s54ZxJrugDdGhbQlfvdeHxJWh59w3l5dbsCbbMiWbIeveV3NJB16o8UXX +P331zZ9M+eb312+7a6AAqgB585eb679KFUxTUij46Pyni+v8xcFf3rMOr6++//Xqx5vLg98cnb79 +6XxlVsXqrxfXv/z24KP8W66+O+gdan74VR7+H/nxfwT0r5Vf/Xn1//3vcvVWoD/87aA8LMuyDStb +HTbV6uqgMIelN3UVAYWV95WpV9YfVpVrAGhd3cp7d+jaulmdHRTuMBhvV9YeuhJl/GHtrVRpDm0T +pEh1WDsjLwRQGu9RpDoMNnj5pjxsayPf1NJsVTUEuArPtqlDm56lSHNoQtXa7otwaH3wrNV5V6+K +FkVKA0DjAntmSnzUoGvGWGnGSJ8q6YIAfNt6AcgAfdt0ABSScTShGXxTewxZAK6yBA== + + + hKapdcTOsJCT6So9G5fpxHMbHPvvSiPrY/yhxUSbcBgqHZGAvGnNyjSHlcEkCKB2Vb0y9aGxHg1V +6IoUwt+2ZSG8k+Hqt6gYpS0B3gR0Fy1U7YotSmEpxF7YaqW9kkLaTQ9Ag+EXHIq1Kw5NJ09ATVsR +VNrG8BtbybBlVmvbaiWuaVac+JZDwprLmjSHbVvVqLaUT2RE9WHdEDeIA86vgBO29qlM04QV0cal +vjR+BbxyJQoB14BAWPnSsRDxUZZA8BOLXQBfvQwa6Fua7rnkx/q76F/G0kVfPDZR5G3EfhR9R2JX +i76vcTxEckH3ONscdJGPGtNS9PMSp67I5y5Ob9HNb1yAIl8BrlKRL1NcyqJfy7jaRbfcCSWKDCcS +3hQ94kTUKnrcIv618UcbItbWzpv4uU8VYJ5YJSaDzWCe2LAuMztjTepeiB0OTcLGqt9YOlBn43bk +7ivy7ccNWkx2cZFvY271Kv8qUoOiIwecfRP3Q6QZpCuVJ0wJi1KewJ4PiFPRU6dEv7pvEoUrOhJH +MlinPaB0EHhkfEQsWReimkxdnAGsChDSd7sgKKoI2lp2AIjMNZD2BZUV76tVIuvx8eyAqN+2CYAK +PGY8VUCyzq3RtUKyzipjV9BZ56q+txiRawYjkmHLTnH9sDExDb/RicHctUDhbu4wvcH10ysLIOTQ +pgXwpC8h4YkLaAZLWZluKYVIYbWbtNogmTLECliWAFJIxhE42/03dWXaiFq+UerXhoR/KEO6Xvc4 +SjT2/SZLdD3uMbZDuu4HpLl2tel3GLZTKLt9BbzT3eTS5nOr0f6s9OSoTL6JtRNxo+uRK520iRYY +PaGw6TiyGifIkKpU/MZWwUS6o+c0NwO3RxVYCASsThSs5LnWcOmVxunZjnXvCTuxBJuSxFKGpngU +kdwZpzxEwvHKsBDxMRLmtl4NSXezysh6TvFdZFAiZgtlVoLu9cxovA7cgSixdSmY+BN2T8j14GiS +Z05v4+p4enkOUsh4zePNN3rYy/IRQStvtA1Bw6BHZFjpXHs9QutmNT1lxwfx+KSeHubj837MECSa +3ZPsMVsx5jumrMmYexlxN0qmm4z/GbNIYx5qymaNOTElznVk1Wqd0zbiIvpEuty0kd8Dj2FC3TGM +ICsBy5+oCumO6d6TLlnbMZwkXVXOkybqlohbIn+J+iUK2RPIREQTDU00dkiC9el4xGmfHBz9eJA8 +3Y9+FkHkN/+4htDwdvXT7enbi3ORSoxvfyvVyNqYgL+t4LmTz92hbxwwIHOcN6ujnw58dVjWQoIA +KNJDEUwtC4yNHWTVZYmFHhxdHbyT5o+ORFz4j4/oW1MaoVDlYQjWyTwBIsthdBhYZHlVyUuPnpiq +lqUqcdo30pEfTuPoGmXEIEjIPFtBSxcB0i6XAweOo0Ah+G6sHjhWfskMucO6rFo9/U0NhjAeLZU0 +JpXUIeg50jQWMyoTGRqjHEVj5KytQdCCniR18LUeNq5/PpbDxjqgWQcKh860To9g4Q2BeE4Gpy0L +zrdSSHDTWZ6EMgyZKJw2rgSDjv0OGoTDxvXPxzxrXO3zL6q60qPGtCDvMgHAfwDKULOMO6ysnnvC +FdRKE2odny1rbsOWnCF2KjiuY+xtQ15INrMcYUoWSpxpsttLdF/ogPS95lljsZDHB+lVoR/7lRbW +o8VgZ7OBWplK2S/oHTsBrpbdqihnsZsF+11y85eBXCbGhoYEwvPVkGFp+YWQdT1qass6qhL0HrNe +WafttGBUAjZw4I72qA0njch73NFNg0qIEg6rSiQRiiZHjRCTkrKoYFCFo0ZwyvM4ECyj/Nr4UhuK +mFgAN+uaO9OjZaCuCU2VACU+jj+7VyxsVl1Z1I/zKaI1x25q+bLrARHZrLouEo9X2SAwUFmEbJyt +0AvMg2C+TpX3q2ymOJsknbWwlqs425xs33bLwdVwrU5TQiwhApzahFdc0YRW/aJnWKV4QczximVy +IBCncIT0uMU37apDPyKoVRRzdYfDbMtXivZEc/bGm1XcBl1n0X3rV9k+wV5yxDfT1txKzulz2oy+ +Dat+L2K3lh0Au9nUPEhIPtKE9vsdNIHKh0gSQDRsyx4KUulhI6fNqicrpDx6YBIC0iQIvkqUCasM +KtMTLxC3RNsS4Yt0L+FQTxkT9Uwo2xFX0taO9vLp+GCAwJXid1eavKw0YGV9FWnRQDHoQhM3km5y +dpGbLSpk4ggKDNLrEcxBQgiyru3nJQpKdTZRBefS2/6b8WQrKWhsth7FeMmK0ZIWkzUvRkhRjJGm +mOJVMcK8YoyZxRR5izF+F+MNoHTXmmyPFONtVIz3WTHdisV4txbj7VwMdrzVQkOawE9AiUkzvEmn +nJKVmoSLcljb1KtEgQtSJtdTpmJCu/SYbnrqVuTkz7PljEIqAS5yIlop65CIbBmi9JoIcJFT5/g2 +Fi+68rGJIm8j9qPoOxK7WvR91eEU+XjikIt8zJyVop+WOHVFPndxfot+gvMzMC1Bf0y6Nk5fdpaa +qj/zu+O2Q4nsTO7wpugRJ6JW0eNWxL8iR0CZOp6y/Dxqhozs1YiKVdQe1eWA29DOeDPsXpXxLN22 +KvJ9FfdekW8+5yJksIGLbAfHPd5/AyrQ+MiGYeETqch4tY6edAxdR3KKCV3KGMOOePVfJfrW8ZdE +kCaqKhIVBBaFMuNUFdM6LhbI6FoI8j09V4y1pmeHFa29iezyiJ0+PviDSAjf5lx2DWW9tCAsQ81H +abYxLqlJQkV8rtukqbWQIkm0RYhyEVaq5l2kicgAj2YnQki2cRzY7CusRtXqOJvxEjYdEVYczL5p +rFXyUIeI8LphdJ8kmgophI35GhMvkLJpVNtdqhJQ5oUKN/6o67gbhB+y8fNgYgWVVhBs5NgrE1LD +cfcJDqvmFXOier2G2N1AQ5k0v5VvdU4b28RNKwhideY99RiV8q5Yl+B7QCJg+N2/i8X70rGNvInY +kb4fsatdT+Nw8tHEMXdDTtPSzUqau3zq8E51AnF+UbriYRiXwHU8fLdOcTW5mFY3P9d7jBIZRkSs +SV8kvJogX4Z7xNDG9d8kHE4onPA8Q3NMahVYr+4FTLsI0CtbZ/wS2e7+xbgQ6oXE29crLQcTlQQl +lZtN1XdelRA267sq/I1ChKiOhj+Zn9EEDibYxFUerMF4mcbrOF3qMTaM0WWKUSOcI06GDiWnWMvp +k0EnxB4hfrYnxvsllex2FCuvQ77tYvPd1hxu3mY13OBW+zMkAhM6wdlp6pyYpInU3ePsKs10R5RY +vx9QLq5XPPR1wbCeznUEULXSTUYjgRG17b8AxjRVRnw7HUaHVMQ6niwRlLAy0fSEtxndT6jdHQ4J +7Yt8QxTcEYPHk4N3B//xj4N/UFn1w9uDevWb365++F9TwFdvzOqb9/KnlIPqqzfdKl/1D+NlHqxy +hkJnKDLCshEOjpCUJUaIPEb08VZAmcl2GW+n0YZjGXQhaI9CzR5SA44ONxOagRJjunIPLcKnOZ2a +ErExoWOJUQeKUf8mhJuFpuR9cgCsma7pUTI5bNatzPTUmhxrazBgzQE5PkETjunnk8N3ej6PT3Et +OD3tJwzBmGtIHRxxF1MOZMKnpOkf8zNTnmfMGWlJXd2iW960/EVa/wnXx3JT7jBnHgdbnpspIw8T +2jGhLyiBfnTSlPQDHTWxn3U9pZZx+41o6oTqjikzi41nebIQ40OAQxofFOODZHzWRKIyOpHGR1aO +g9fQ439zjdgvoYjwxBGKCHccyjDQ5omc0ng50a9UZHbo/GEV1IDfwm8Afg+1g2kDAAecqITMm2hF +F1kM5pL6sBGpNvAbKRKgfKh0Z5nSVyLOt6V30RvB2BJqrtZXTkU3A9NaC/ViqaKmgRQlRxEkkCge +0miimjGRcUQW9hBLGkis1ASo2IhhheDUoFPCciAzVZVYYBigKkt/IFe30DK3h97wuTUwDMrhJwMM +FXEWu8rgE1XPV5SRWcZZJX2mqehfkaagwBxU0P/JFGAiizQLnISagnmcBRiyKMrJGCurKioMichQ +YQMCUKlmiQM61jJBuVpbVuycmhdo3XLQAlWQcMn2NjQJiTjdKiJC6rOqINUvWli9IWX7qCUyvqzV +dEZNG8XzgDlAUaf+GC03BaqHBwQb5HZjDyjTS59EFsY3prVql/YOsy+chitVnBX8VjVo5aMbgwix +jjqgxirSkOtshY+oGq2kbKuGVrdINqShGvjfyOpiAgEwSRlKlUAC0AmgVRVCBMnetekbC08aYHRZ +1xHFraO7QU2PGO4CbCwZa7L6K27I1jGRHtpo0RfUrqLIKe0AQR1aVhLe1PDQyUibO2wbFXfwnalJ +rdJ3qMtHzRVRr8gbdKVVbxvplW+VPaO4jm5zzlK/gakiDNl8bMVkAiDDtKbup6hYM48FDLRlrFy/ +kvWw1CpgPbg3W+6GuK/L6FlWwrypSx1JiVDIKq596SKety6Sa1Aklef0bJFSLjnaaOvUbiuiNwNM +LIboWoeI7E5ZCNtGq5Iqh/DDaxeB7cHEr6M/UbZ3vE+taLOgVCgmXWlj1+pWR+19UIgJbTQQVnHT +lXLcJzlaYbKoMKdyjFSGgyKoXjCSTlIN63xsDtapjrwOaE+iv6TRRU6kIyEvOkqeaH3REft0IBTp +RFAPMHpLERcTDnsqh1wi3sBhISBl1FvwffY61oAK6ug0NTh3zmB3Xmdsbn6LZgwIg4X5uG4OLXR2 +hr4sbmpshldBzZPRQ2SBU1wtaNMq4nsT1PQs7cu+Wsmp7A6NbL4friCBOmqFvJy4AUu/rmTTws+h +WcGNSnBXdubR2aaNHs1t1MuO87LQQfYBtXfSZjSU/0PO9999c3s38BmHtKMexHDvXZ3BZ//j9dvV +h59P35+vrugY/Z/y1dfy34Ed+uSOpKc1LIKymIuZBHCJS9kEZYOXMgrKyS5mFShDLWYWpNQm7IIU +24BhoAC6mGWIpRYyDdLD5WyDFNqEcWCxxawDF2w58/DVm43Yh6/ebMRAQM5ezkLI0DZkIgT5N2Uj +KOdvwkhIwc1YCeoJNmImsMc3YidQcAOGQottwFKg4EZMBQpuxFZE3cEGjIU2uZy10HKbMBd6wCxh +L1Rvs5zBgBj8qUdlFKNXMlt1VDeurZIft+kM7UJsNDjm3nAZmdLVd7en1z+dLw+YkQNJEN7Rp8EK +dWXMDM5F6Om8OkKd0Hjp64qeVbJyLUEBk0kvG/49ocGKb9PXJxrYgL2e6jxRwz9M0Noy67K1HEE1 +8gF07xmVoF1L1ZTq9J7qSa0VWXOpM0Xeq/i6yDsfq+n6d5JmQhGcHTyRKeq6dnKQutN18ORgWE2J +LgxbQ8XaldQlAKYdXzO+NdOQT1N6nb2NdfRVxC70zcQu8E/VZr3VLuVD6icmzUs/LUXnRdnPzgSR +ZrmE2gCX0LIVHgNOmrahM325wi600NaO2XTXwnVXAUV6AI/cgjA6+ITCZ3nqESrntg== + + + cEIlLPdg0EohDAZew9K6EZYNr4JvwNmV8OELgU6jwijKyOEQSkyAaVl2iJAqPa15EJTAMnUu0LOA +xxfmTVgFVWSS5J4cSB8DHK+BLvSC5QIYmuDB0NORFuo8kjGh9UHOKQU1ZE5A/qHj5EoKB6UnDX+c +UFnT1KoQbORwUFCoqY6NlRInhKlQto8tE3HYmyL1j9ilx0QcxMkBx2V5sOtI+RFHX6T5IIZyjsrs +df821TGogu10zaS+9F3RialWfX85KhtW2aDivGQj57Ss+CdU2RymWeonOk1Svxg6R9mCsVdsO3a0 +X1M6r3gy4XHd03h75ChXaV5ODorB6wjR6WAVvtLN1DUD6UEgg64QdYpJd4vpkIrpuDuU6VGnSG/7 +CSxSHf0sFwl3+qVQTBYk7dermKxpMV33YoocRY47xRrcKtagYDFF1GINOhdrsL5YszmKNXuoWLPV +iuGOjN0bbNxu9rPt3eQLWfRIVUxJRZHwKiMoxRq6k9Glk+RVI6AG57iHw1Cln1dtW8eDL4rMIonC +U0E7WXPMjVotdKp1DtMPncNoydHvdapbT0YzVqsrwsa65gHrj3a+y1/FfmQ1pIb6dlIv8t7oy7zP +sYbUqZN+BuADVXIOZSvqWd69iDOTl9Z5mbQw6IVSIryzbd/T1HY/mumQbXeAj+dpzXROJ33N0gwW +0LbZaIp+MtZgg2JK/3dD03iTzOKToQpsMiG0dw1njaqQ0dRSRh/Ov4Ami/TVm+lSomMcj7D8UwxQ +AXCEKWqJHDe3Bu/UaDxET0gWEyxWYWoyH2krZK+L4fspDmRtFnmjazChH0cxHMh022eTUwznroiT +t/b1GszqlipDwH5JB71bN461I147Od3cXWcSVRWm1kl3CKVMSWGmjcEBCOpt02HAIGUnEqspbaTx +dA6tEBdYKh0zatiVN8aaTr4xPOzUoqoHRmMtgsZVF3cCj03VAVqgcoNzEG6q1CV66mE6hUUDBY1n +uGSLQNkYkEjrbRndVgOF284ZE9Gk+EE3IPavQAehRFN+H/0r+g4ahE1BWIeSs6YwB9Ozxudb1WyR +f1KjO34gOuPkIL2kpRqBXiQqZc1A7FgpGKSaGr1uak4OUnd0Ahv0C7NKjWuaZjBJlbetBvpwMYT6 +QTUfFdhcMiVMWEsV2vABtVP9B1C4uras83qKtIhZc8WaXnWzlHW+m6ZsjMWaqegmKpux7rUWcAk2 +nn9tDoxHhkeD1ayHSFmk+ctwt8iRt01O1j2Od1vg5GELiQ3O+UALiREmRIoYOjybqegFN2UDnaCD +Bh2aYw8na4a3gpUBURBBrJHOyHwEkRXVj/2HKxxs0tmaJRrVq68p2prDFgrbYFvsfmGIjs42bvVo +bqtSgN7QwZaVBozmRpLHjBw9pYk6sCGtUdI9ojZq0BjRGzWOjCiOFh/RHAAnVEeAm9AdkumllIdu +JGPaQ9o+pj4CnOI/gWMKRKPBmAZRuz/eejyCxnToqzdrKBH09ZNdD238hBpB1z6hR/AamlAkPR87 +mkTN94Qq0T9pQpeo7J5QJi7cml6uo056kI/pk2qYp9O0jkapUnlMpRQ6Xad1lCrD04xWZSidUasM ++4sh+k8pVr6ZJkd8+/mVpoKnqz/enp9ff1KSoZCyDAmT4jsIwv0Dg4P8YV1x8KXzTBDA2E9NMtQG +pxHkZTQ0CimiV7gLQX36alhe4BXrtBDoU2k1tD8gO4FIflUdgzHrLMsQHzXJUI1MK/G9bGHj1ZlT +uDDuVOuM4SYXiuBSjiGjgexWjRYGH6nTtvXDHEMEnMXAiNE3dWsZnkZKQwtGDD/3gs0xg0qInQ9N +rakiDD07YXRsNebHyT+MT1MPNoAqGvWE4FelJhlqkBgD2QCC0y3ga1gm8Te4lGQoqM+zngMsrakC +KhditotGHWads8nRzFUlffgM4420n81K+01TgWA0kwEglD16PLTsMEyOMe8GsqbA4mSMOoaGiuFp +1sETUxPeOCya0N+69WqZCbAS1QiDjX6KBuHMxIguMRH6TaSJDp0e+QCAVo1VA55HwgFgnnUh5hiq +4S0K5LQxFic0tH2UZXDdc8oxFBq1rcSXsXTRF49NFHkbsR9F3xHtadF3NY6GCF6VNs41h1zkY+as +FP20xKkr8rmL81v0ExxXoMiWgKtU5MsUV7LoljKuddEtdkKIIsOIhDVFjzYRsYoesyL26Y9gI842 +lYkZiUJ09KxcEyIi2oTqOKy14YTrpowJAWJkIPrrVtkAuK1sHGbcV9x7mneg23yyPdUpf7iHi3wT +c6MPviItiFYxxreRYNi0GpWPGYaMd9orISt+FclONOXVeYKhRJgS4UpfJMpWdKQN2OHaJuJLZTW9 +UGNcSqUTWsWyOkbneSRYIi4abyJ21m1MLwT/m4jDlaZfaZmhKRLsPL9QiAmGZOqD6SCoQ3MDxTrQ +EANk+4ZI01P+HfQG/SWRiv0lxrdpD5CmY+A2pjDjwGuyW3WamT6/UJw6zK0m+SEAk1+33eRbUhaf +kjvQVs5VbLpVpELXxVQNNfZtnluo1o2sgR7t4Ju6Tf7OlXdK9dLUK+bpbmozSgkEdquclDrdnERy +o8lchJ6HAUluKn6TiDY2UjvYUbqP0q6Lh0G/MTWgufE+373ah3TKmBCPnSptKk3d0lEKRzo7pCaa +IY/YSXqzSptAtwWN71jpBs2AbgUNMA9kwkjamkbP8zqe720qE4AWpJFGD0nmuFAq2q4SjimpJeeu +eOgjPVZP7oxih1VGzTNCb4SMKCkPitO2iWxJUJQug47bl3SVl/brpmNK2EGn8V/wWNcxGJ3eUMse +4yg9Z5d5FTkNVZwqzzw4riR507nUo7Hk1LYgMZxpTUY4Ol1H5+/4fJ4e4eNTfswGDDkFq9g4YCbG +3MaUIRnzLGOmZsr3JPKcqHMizonqTtmrMQc2ZtEU+1xER6vJhYzXHFAkCrQD+8QYdsmFIkkhySlD +fCZFUr6TBIlEKyY0UDqcyFqkaonsJaqXKGNPGBPxTLQzEdcR9Y2Px2MGe44luQ2qzvC2oQdIJUhX +M3UQ/LjaddmFLBJjRUtyeiiCCbLWkC6Ddc2hDUJ7J7ZkYStDy8xB8rdi/gqZKbUYQ4zED8Fh38C8 +LCsC150S/pdyKk6yC1GCWJvPTnMCEEk0W5NfFSnH2DHz2bk2JRcMteazq7p8di7ms4tHhWGsneaz +i+H/CLqvs6QIrRvmGOLzsSa0S6n/HHMMWZUgLXNXhZjRrss76DQOUCNhmP/KxYR2KX/dMMUQno9j +OjuXf5Fns6tjNju/6hzPjmM6Ox1ywxR4MdNXzGenycC6jJExwjTPZtfEbHZ2FRNAjpPZtZpgyDDh +paYea1apbExm18a8ZquYFjVGW5QmZU61KdeYW8Vcdl3utJgkUvPfMLta55Flmckunja2SdnDQkz0 +6GJwqvV1nUUeM5Odi5ns2pjJzsRMdsHEMkwLqKnigvalNTGTnQ+jTHacN8VExlmps+owlZ3tU9kd +D1LZlbZLttuVzPOfauXMZVevuvZj0rKug8xlZ1fZGJjLLqz6UXap7GL8dQMGm2nXNOo3T2XXtKNc +dn6Uyy6mF+KKEclWHUIRw7yueL3qFjxDJ29CTGNXKXb5MEpj1yoiKi5FtEuYlGWxM10Ou+NhDrsy +rBLqs5dNG5PYpXE0uqFqr8HZpAuaxK5dZTswBmvHDThIYRcz2FWrtIPTVPZ7PKUWTWSAKeyqlNK4 +6uPHO1KSZRoi5IR57ZgOKkJIoMqUSbntaFhPwhKZS1Qu0cFEBhOp7ClloqaJmK5LbKfphhrNA4D3 +w5TRrhmmjG5S5ry60vD8rA9Nne2s2EnNlqqxwXEcmlJV0/FwqJp01ZtuLvJ8Q3ECmbyVo0vfjBch +ZrkM2ToV46Uc5Y1O4mCGC8UIWYoxMkWy1Wb4VoxRshjjbDFG6mKM9cVoVxTTfVOMt1Yx2nrFeGsW +471bDLd2Md37xYA8NHoqZakwu3TRSmLgKXKc0kUbUqE6BQbDuTVSqWJKx/SwbnpSV4xp4SBdNCwb +xylddE9RixHFLTJiXIwJdZFhciqep4tObSRc7jsySBddhX48RT6gOOYiGzRnpeinJU5dkc9dnN+i +n+DBedi4fp2KfKHyc7XqD/6iW+yIDv3ZXIyO71WHUkWPU8NU0W1E1tr5KJraKhanuzczRTexjSxR +tO6KqBXIetb4kHEtRSLeRb6b4o4r8i2nfRpv2yLbt3Fn99/Evd9xYh2ByLi1cZbosOoITTGhRhlr +2JGs/qtE1ToOsyN9GRuqiaLrnlWNiaJTTnC2wkTRCf+DIglDyF3PF8dE0X5VjIh5kaj5PtPQPtPQ +PtPQPtPQPtOQ3Wca2mcaGiPpPtPQPtPQPtPQPtPQtmQaQohkcugduPRWsLOAwa9Ng+wGVz0MAZ+q +RWLAJ+URmEw0ykJEKwo0ljKbWv8Fg1TYDcGqYpsJbyGFBBuixV3v/morZ5I/iGKenCJMq9s7cCPF +LNPL41zhLTcBFv/OVaNmMD7TDNS6kMbamPY5BXTrbQAIz3XdRUiW6fJhQirrGAlSxrUxFJERkWKN +aloot6uXAo2YTs0YWP8YmSYrkZwVYrC579Oe+JTKvop9wuc8PxHOkpLnV+ojFg7pF6dOPDGtQCt1 +RaWPiSjO6GCKrVWcHa6S+iiYaOSuQhkDrl28pgCqBEI0iDtB1DmpLWOCXP2qPWyjXSEZGMJh27Qx +Tjm0NvpBtcZF+um5AWVMGl+EZa2DV964jpHRhNDhilOYfSNzE1Po6q5HYoZYsak0QxUsgmXMSuF5 +HZLDtok2+Yp+JjIlXj0kYNPTdWOEtpp4Gt40UWpovLqr0gRT8hKY2vQQeCqIdE10jCBLdYvtK3LA +qTo15mjBS3J07JCHodfXfZ8rxpnbfGB1DNvuBl8n98g0P9D4mHhhRZzChtp214MCaEeceI6XMZwx +FUMaUknC2ZNJ4IK2hHUvyQ56X7seQLtqk241S9/EhAQVuRiZhqocoKGALG0lABkyLc5EXyOmMQYg +bVBoqlQPb21IzQQqFWlAAKCFVszEPNiaMtpr17KE0VVM8R8D2zWxRZYtOqjJV3VF6YuS93qs1LVC +s/xXKf23Xifj1FPT0rdFk/yb6E5GclVH/X0HoOE3eoJEEFJEM30zSDySPKRE/wSAaAJ3qjJZ/0oc +LI70LY4u5vsnUUr5+M+Y8F8dl7KM/0ZdJdfkhz47KAZJ02PSf99kNYzyUGvGIXTFJbNjHTQnehM9 +cNjZUc5rjqiYDJvZs020eSqxx/QN5opkxdpEavSrAENa1fTLgJzeTRWni3iuZIwJMHQ1VR/vynhX +oK2i+B9CelaC6ZzLP1DqToxquvz/OdZ1F5kQVelgTM1jTGvBdC6jrOgx3xO95FWxnl8CoB5sMb96 +TL7e/VA3yy75enYPQK2a0uwigHi9H5mts4NBZ2I6dnTYaofzuwBWXZL5s4OMtUzXsA== + + + 2Gm2+phInanVG5Oak5Uxmvm+juTKN7rIsoyRdCuPIOjSxOHZ5Anfp0iPWJbuROkwvsvYfxZvBeDk +D68FAIobdVnvLgooS5KHs4Me5NL5hlwgFTwLcIiXuhP09oZD5YhUU1Z6hrC3iZHp+KYAHbpfTTmp +h3JoldFfYhqHL+sIs7XG4SN5DnZ8sGXJfgtHjhtBfrg6qBvNsTL+UOBIsJO+PDqbWeXRvVWa2sAJ +1GVVdmEcayI3pgxlBl3GUkaRazlTqTLUJmylNrkJY6klN2Etoxi7mLmMYtsG7CVKbsRgakzEBiym +hlhswmRSobARm8nAkOWMZgzgXM5qYowbMptIL7Wc3UQo6QYM51dvNmI5IVFvwHQyrmg528kYpaWM +pxTagPXUUkuZT3ZwIftJXd0yBhTBVhuwoFjjDZhQYNRyNhTYu5ARZVa0DVhRKo42YUZJDDZiR0mA +NmJIY4D4MpZUSexSplQp+iZsqZ4imzCmGgq3CWuq5/MGzKmmJ9uEPdUmN2FQY3rN5SyqZh1YzqQq +v7ScTdVymzCqI0Vh20X+fwdblWaqTEO/UnOaBiPVGovWWL0zMfBct06JaMfHSVdJagtwVgiNRN+V +CYIHs3okqx9uyTtSORyMRXNAIpef+jsqD2XTNXqRLGRzDuzw6tHvSlzji31HdweH/ada1eGAjjfh +0+XgNSZeoSrsie6aYCoH51qklBUkBu3XIG02OP62Cf1nR2ezazy6v0bfysQLLcqrvZ9VX7OyUb28 +ZG2ZZ2KD1aUNbvn6SrFNVvgBBCerbTLG+oppG0qTcd9C1JQJj/w58kCaIRNvu5yXyCUc7ywNMR64 +pSumTResgdtprTrPRsJr1XgCgOYmFR6v1htKKaEoxddojf4KOIalZ7cOkpCS3lYDettf1ja4oDOj +26Tq1YC8yy8yjARhOQBgIDqEDaw+g5vr6E1YN7yCUr410cubDDMFExctIRDzJvO9kZzcIGgiiqr1 +IfOhyKBbxLoA/7FD0CGkkQ7ayeGn3Hzpq6OzufUd3VdfZdU3c1Dp/XtvDdJppP5StNNUwosRj9to +KeqROixHPs1Osxj9OEnLEZDFlqPgAwSiUxMgwxj0E1d9wq3AYHJlKaluaCJRSkoJBjxVST/m4UhR +QSVQJWbSAOCrJsbzteCAMUyk5FB/K3DRMiQmpOAzRi5lTGqYDEu6lDI1RLGgZ2rI+ASymq7nj9qY +Rfusv5FyeCFlqFcDNitUq6GmsIQugG6WWi2zOtnDKIMKZUZUDKQpDFB9wZiNGil/k9zqVSRkbo7J +ZG9EHaSRqq1b3aPQT1CQDsI8U+gKgmIingqO4HhuICi68bfYx8ik1H+LvPJz6z26t17ZNZp8eFDx +Qwq1CfZlOa4W4J+WWoyBWmwpDqbGFmKhsvdL8TCWWoaJOrNLcfEhMkEqXWtKemfoDguqCN9BaN5c +nZynEZVSJ70gsIxhLC3kZ3V8tCT+tRwCJgbWwoUXp0HSJfbXC9fJJEHtF9CA0iQ702raC+oKmOpa +ww9DjK6A1iNofKOKLuAaGV0BoTWY1WRIG27GGt7t3Acyk3SVF4Gw5cBlPzj4ujOdEfP0V+NPbdnq +F/233Iqzaj26r1bEI3JCBrU+sA+ny6vApQus8vbiJU6NLVxkLbZ4mdfiObI2yda/N2/TZ8sj8+GX +87vfalCoJt787gBh0ELYKMd6IcEtJeEW4dZdcpnT+dm5bY0wQpmTBqlheaILpWxk4Rw0olG+tjXi +RQzMJ6puKuvGdwCy72Q/EoSZJi1OjQRhrcKxpVrlmWnQY7vHOCWYxb2iW6bm8V4DGnb3hHj6LYP8 +oSih5t4x3jVBrOrwwTG1mqpaY3uo8aq6Z8b88/bi7otmVEMzbEMj8qzGcXHGTnoItGeWreiN741+ +kVpNzypboF/dF35Ugx+2cTwZK+bAUfCz2fg7SOy9FDK+7scrnKC+78ZfI+9D6TtIPaqhHrUBb1eF +9OPvILH3qc40utRqP/7UrwRxoxrcqI3jyVgx/mLcuasMFPtfoDNg59MAi+kcFOhOlaFJMZ7HYty8 +BueN5qEYD6OrOI2zmE5F18Hum/F0FuMZP56OnNNBPBzMRoKkYRAzm2wyiJqDuVDUDNknflSHH7Si +RzYg2UQkSBpBqrQbY2w3m4bUtf6TZlRHM2jleDLe6BmNICDaS6Ao8SI/XTFNY+lVRZMyI+IuD72J +gkKh5gllwmNZRq82rg6C4eDWc3WyUJhwey0vJ+9qwh0+Bor4EG+wKBpYM9qgATs1WUp5WbugyYZd +OXxkjg3Twwq00yCaysaHOr4B/lncOlWCNzzhk42J+rp6XHyNdtJvIq4aAV1W+jBUAdtQmHJoiD1U +UvTsbU1NPB5O6TGoT9b5K/gimaBjT+MpyV6ahqVq3siAGDxmYETFDY2BpmVyVhcF6ZIh6Fnvjg+y +3p8c6NjqDpKNO5sQKZRN1slBPo+phq6n+UAwsHjswk7eMoea4Bf54CtMlKVzL5JW2Hg4IY8M0n2A +taJUDVynZjoCSgaj+qordawpmaPByDpuGkSWWVpAK9wd4FY9oEbCiGbVF2o0mV4MvqA3QLSrMJFz +C2lMUAIJipiPXc3RHaDRlC6pzHE2VuHTXNCc3kHOcmYfkB1HB4geAsmNSpfJHB3Hsxn3WGnEXw3t +g9N0drLnNaaIINz34FWowWGP7DIZyCM/RFur11YCQqBhps2uLtMFwqUGE4SOW56Jg/uvvPB+uM6p +r6mDZA12sK5fXU2p7+PxnaW4jPsudTm6ubnkrS7ur6d3d+e317+/Pv3x8vyPHy/enn/QS11sf/VL +99G/39/c3v391/fx3hfBJ1lbD81YqWy1d6oJ/93fzk8v/3x6d3vxb/luUEn7/eXF2fn3Z6eXF9c/ +/fH24u3/e/5rrG7a4t+EGf1wd3uK7vftLuZiP15ent+titXR6dkv/zq9fav5EBfeImMYb1/FhMsW +UaV8phf7KoHik0+hgzijYrLaatUVLIafF8bHX2Cu4k/unuyjYQ1dOQ3BWrGVQU8GX6bOH/fjmH95 +yQr+CyUyFclkCdXEDVfT1LlyVsKhgKJdeoB2txKxLtSQitrPfmWJTtaKmuCYJQ0DXmmmTmaV6iYp +TdEqvUtl9JV13eR0iYn1ZZGVKfRjLm6/tH17Rd6RuKzdoq7S9QXqgkJM0l8xwzF/87/+KbbmV7Ex +ioZV/CJ+ELnylUoA8UX6UouCzMcOd/V3jcReHB903dkwrotVXcVfXRMKtp2FGz8vU47UVRxy3plo +r2V/L7vf/bDTuyLWGX/i0+59VyR+e9b173IkUte+C8b4jxiP0Ym6q5+YlUQ9R3TBGDOCp3hvhmEk +i/qE6A1eAEbTtwJS5gTeuuVjLmw+pPLpR1+EzcTH49SJ+Kx3v5j+g1F1fVMMcEydODkYdzFVUyjr +msaZDk4ksvC0MvOc5nWN+IscLHxl093TYPFsSiDPD22Mj2/brmz3nNTpDJYx6ZITfUrf9oXMKrVQ +sD2jQMq68f5CNj5oOo5dp/sBTZlwESLNMzt4W5IQVa5ac3dqvA+qjK5izLznme1hFd9Qk1UZrluw +TKfmqUor+g9cFXNhPlS0cnq15dHZxq0eLW4Vd0rVSFPca97WU4CHs4XLBgJN+FYdufp9k/wj087R +ZMpz905SEMfdkz3O3T9dd7odxEtGZ+4hWtv6XZQ9PraP9Ga9sqc1VZyoSDBNRzAf3GJp+uImUy/V +Wdss+dq0Xd+XbLVIWk1Kfv7wdkvjObl/2IJTZgyl5d/3BHY9cbWrISASEfADPtA3WK8icPRyOIwe +PQ2TqED8NDTOlN0v2JmH71i4abvCed1QMCYamvUk71Hs+IMuLLB48PI3EBv4NyJz4b20xvLqY6Z1 +pXia71pYtxvNjZiRGMZkHjKn7LoScGCxbZtTlpltHM1tA6weEgRmdORTb5b8R8frfxxy64WJ12ia +Q+3D1UHDm6Lpz1w1ocZGTyBDJ+l0jdWg3L0nhHVctDqUyHMYjwiRaKG7f+iIAONRxdzD9DnsXwVT +V+qDK+S6Uo/10Qp6aHPaxwq7eOns8JhY2PLRBi3DbFohEDc7KsDLC3GA1F2KhC/yaoMfZdmQh69D +Yyty9dLvChDTp4wU/r4GM8/AXV074yv5/KoDQQHomyreXsKboA2XdlQiMdhyDOoLaMig9rk60Dug +u4L6HopEQ03FpMRa0ENi9W94dasMuP7t6nffi+h7/dPqN0dH35ydfbz6280dZdgMqydHp54Ia3qu +gd1d3/tv+t6vKZeI8Jqe/i5/Xv3uLzd3fzs/u7l9K5j/n+yIWg4r3jMC3aMPBt4vdiLXH3/zpz/G +vfL3dze3V/oqjlI299ubH8/ffPOn9o104vu7Xy/P3/RN61cLZy07PMJDhq7Pp+N4cqXEtzf/2uCC +hi9THeGYAdcFX7VU2dmq9Lzax8AbqQ5TouyZgdOuUgpcPhRqaG5q8sxBPSb2uom9bmLrdBNNHVnk +mCRiIH19dqbZkpHL+eKKSr/0a8gzV+osGHlmlv38LDO4E2fgSJSYZt/gzHuIaXYNkimaezhahAGa +MOa5sDXuK1IFdfYYss2zWjma3QoEcBoBPh/jvIZdrtXrJOZWphEpJqxMsJMcZmDUjFcAa7DFOlBX +kg3EONII6mIpcA13WacrfIf9eIz/bmSKhACvlP02zJn4APtNzzlHnwerJLznYkNA25xvhNhWI+Yb +fu84IR4u2jjev322cZtHi9vEMeXs52e6XUprhMQ3sG1fZSBZal2eDFRGkO+uGOtAEKv0QpkOlC9/ +6Zp0Wb2IUy7/DEbeeGtYD0OjD8CqKSwO4WQ6qnS69b3m7caV3iFsu/KNfpz3p2sHvolDUD66Jl58 +Lx8ZO/gqm6kpqGtyDehhaSOiSfkp0saka1cDYNcTxuFOZmkA7camQXN2DFwzVwzbHM/Wmk59mihT +gEaYqvVBw2CldxAh6/pJpJlFq5Kd880rkWb+cHO7t7DuLax7KWYvxewtrHsL697Curew7i2sewvr +3sK6mxbWiT316mBqPC3WmFjXGGKf1cZq9GaOe22s4HrtY2UdIsXKapGJddLw0fKGn8rCWqwxseb2 +1GKNvfVeG2uxzsg6NU3mpstpkfWwpzezrus8M0JlZtY1g1lX8PNoJ6qA+yvN3tb6pNqJk/N3d3tb +697WutdS7LUUe1vr3tb6hLZWXO7DLEZXB6VeAagZB0UeMTQdJViytp6QFYsRvmNQMrZmBdeA+uqz +9j+3cdUg8A6hsK1VAt0bK1u0GdTOyeRCQ9sqAthwY/eDRRual0bG1SVtHi1uE8eS98I0f2Z2u+Sd +jtAo0eTpLHEhwZLp7CSDJVMmYNUEhnsOG7cWlAyeWcEcVN4LSsa2DJQ6q1jEINxy0Mv+g3TzYOor +7XllSzIZt1iZ9ym9z0B9B5CbtnHrIIO5qtbM37j99bAHxYrPIVVMO0epYjqKHtgPNg== + + + K74W2I9DLazd7Obt5h+tm6pNRZUi0QKkNasF6wPsUE8gomwoobwa++nfLn76eS+i7EWUvYiyF1H2 +IspeRHlKEUUvD01yRAyRsVUubXSgTCZJBdeBegmE/p5OBZD0OpdPho0/o5ASdED3CSlIr1O5R4o2 +VtOYzJZSJo2OPUAfb/SppBS6V8a1i0IKTTzeprXj61wqUEjPpSZIL1/Qd28EwZJXfh0oE2hSwSGo +vA/Uc7aTYXR2ilRjLpxEUF7cHKYcLBPYYKTVZOyE9Jw3SzmfZm/Y+FrQkwsmkwGnqLLxkDNoLoRM +h93DcpEjH3rW6lB0mcz9vULJFy8N/OP9XhTYiwJ7UWAvCuxFgb0o8HSiQGLDye3XPgWGEYSMxbaP +24IvXg/SqA6vF2f70oZVjAIz+WdJUFgDiQ2eTPvwlEFhvL1nwGPLwJQ7R2L1NTFh4ZGSDRJ/Ng/E +hD3W5DQk7JEmcTzZQcr6zyMOdIE6miajEwgaHCIC0AVM3FsPSdz5Okg1hjDyLy67igPrQF25DJQq +LxIvmoFSAFoGmo6mkwsGr1IwWIpIytruG5qCulimbj6mkK4Y686rmfbgHuCDAoJgnjfC9nySgDAe +5NUAmIVsTQeawbqhxdCuAWTtyGK02HDK1/TnU7ysCs1ngftYmdjVSF/psN08hQVj0XK8Jpnl7k4G +IiRq9d3t6fVP5xuFgMH6i1s94CMdD6JG2CFkwk+gIlSHwXq7QhJdjwuxEqBEutT0UHSvUwVFV0Nq +pYMcHxDUZKCTA5azPWRSc97uuFOxcCqbqu8bnAz13vPOhFq5HWjM6o7bKavqwQOvEE6jNrhu1DSV +HBk8FPgOtySVodFLh4QjMYfBlNWI70HafL088OHS8HhG+vRRLMXCto82aRuMkfznx0egbUofeKq1 +tsThaRrvfVKrOfwA9fF6cYEIZXqXHw5F5iHqUMElbkhW0/K+lQSS5XYRFzyv3k2AUpY2/U7vUulU +uEOG+Jwjg+v4IZaqelAxrrbI2ywmPeoq6Dqd4X3X8mSwXQqlbEMknjDfN1k3Ay9BTLACoYjsSRCU +ZTqABNGOxge85T1TqYaugmxnjHrZtzsuNK41b3LSoUmfJ4M9no7/PvGydykedZtH6GRwk+HnPZUC +/eNJ/thP5nTCJ8tynHcnG8BXb9aMSoDjGieNDvs47OJ4QOMRj9fuOOtG3ovJ/N0LzMXgyq2X8dPJ +U9e8OgpZ40vkK5e97JFSQQ0T8W16eTL5/F6i3NoogQbX+lUXtuCl6jWxbczq3piK19IYXITU5Dx9 +2YZDh0AfYepxO9VABpV1Qb4JjYZ6sGyo9OpuIYeLGzzapMEyXgo5or+fqB4TNo23mruYJF+WzB3G +2KKT9Da9PJl8nghYXSu8OmSW/KsEiM9CQqqs1uHHawBPH5Mw6bDsk6yL3QddlyZFvoBQhMqv3++f +68Ij5WLtJ3Kxwk44g8t2EgNbuYAnkHO+CYe41c71AOVd40PRvU5lCxRO1eJBDqjsSZnV9OGkmryR +cQ+y3mXdPh4M4lHWVGggbxqPrKkTBqx+OOoOt3zgrmbTCL9S2zDk8GpYUmuNwMJtm8MYX98IkHds +PVw4gDxNYvGWtXy0SctC7A6b5nOzpd16VzTugL1rgovPaDuuuV7rmwCRAbK65vouFWXJbp0rNbsM +niMf2n1cjKsq8naKSS+KYS+L4SCOR4PqeM8etdWONQRErlMv2KjZqya22x4aw4vLE0S7FR/wlpeW +puJausf0QZ9iW4NvxzXlzUw6MezkcAzHB+MxPcZd5r3qWMt+EHnPeFds3jUwkt3jSf7Yz9hoSsfd +zbqQeizn0xQyqGXSyrBTwz6NRzAY32iN+qa7losZkAHnWGU3RmZ78N4f+i/DKLth427vhplqAWLS +oggSxAmHrWszkPBnvF0LMZXUnYVaLypiKK1v407FHTq4cZN8b7e9YE1BSGy3xdgvzzvjB9uuUgEn +3gOul9f3vdPn44PBTgQo2+kJVEzqLda1Xkz6WEyGUUyHWnA6cLdnmo4CM+bLbF6nM43EGeuuhFyz +JBFHhosiwA2WhVLOBguj5RYuzWA0aXF0v2+yPCpEbrBAKLjZEo02Wh05tHYsm7WHehWV1YB2YdFx +YgfTQapGMxDX0DFJ1ekZjEz6XfClzEcqXGjpZpXq7wBnB41QAm8ykLC4Le7h7mpJAPJK8XdqPpVO +3RsP4HgypPkpoGDMbNH7EqHfOkhZi9DaNZwU1Ga41VFTQcWHIpjSHyKXgHB2pd433rsufBbJrJtQ +o1lQrjChNF91IJkzHyfUNXD6SQAekfF3epdKp8Ld9MXnY2AErrvrICKcOMUIrSE9o/b0u2s6FS7G +9Rd9A1FYzFAljqzGle3MYhdBgnCper0nLgHYdpP6pe9S6VQ4Q4zYsIw9wNkvQYJNc6M1pGfOm+0m +VV+mwsW4/qJvYAK6n8cY+EP0DV9lT+OWtVI7GpjeTT8cvF2NJ6efOHw9mdfJzE9GgmKTKZhMUj+Q +8S26VdOd/dF9QiRpvUFR+NASxwNR2wfc9tgR05PuM3xl2xzSFfw8iS5gtaKEEO8WdmWnBFcljJAi +09SqwGkgNIxURnJGUJP1cGHwXNY0UWW0sMWjTVosmSPks6e2oG1PlwG3ipMlq/T+56g14uv09mRa +INMbNfFF6+rKquao0dIKOQFu9HWPC6wFPYv+qG+0KSMLFDuaI3H/KbtX+gGsK/4FaJO6xBbt51Uj +/eH0nze3F3dRe/QfScb4nPdm4zJzXNtcOPhVVTA3CF9Y8zbRBILcU4NuAgCDGrKXtVB+OLCCVatO +maGGqsm2esUn7iQ1Xp052+B4pbZms7L6fHyQIC1y2KhjBzIcwctSNhVuA5Wy8oKXR9NCp+iH21ZT +39Tt1IL17T5iLU3T1cJrZlMjes1s14sTvaPW8Drw2NOCgyEkDob38qLZbMQUTWteOhqnpeDMuaqf +uYLTi8Mk62+T7uLtvpJ2hVeDgyVv162ycSLDTw0VAe6Ljtd7pq9QEVLH9As1XszjzucyvpCRpVVG +wh5ve1CALSVUbJF72rFd+NUZJN47Jmk3OiEybfjA2ZA+oONoOAyCmiHVobes8GpSN56QBDlW/8BQ +tvlXNd2gCOD1sALQm42dtNpqMkM5zY1Rf+Qy1PSCRPJSQDB9nE897Oug+Q/xSItyXak76aGBVVhm +21sZlcpEjUzqCkdYZXKEA3vM7vITHz/BleBekxyxFrDNuNNW0Vpb0qtxI+rXgYpQdtV0XaUHKDR/ +/Wg4Ym/yIXNWfD8rmLemyeZtsszH05W/3731iT1GKswB73mVv27lcRUwr3u13qoIsl3Xvf6P80u6 +zZPsfvsEpBc72zZ6TVJNXykDiSO09OMMyMd7qJcsg2KV/D/UJBmwGJcoxpXixuBK0QYIixuvE6B7 +TmX6IqnaVGtqk/1gNzLI6ONJbaPmxt2Z9vgd3LhL7Pf090rzqiLXH4i8bExhuyhyEnW00xmoGH9e +jGuU7+lcIt8HnG4kGxFQdBB+TRrXF0tVF13dqeGCnSnYG8AsF6ZZTUqk2rJqJ22PezcdAPcxgh5q +pxTSO1fH265KToJsNXgs+ZRPPwgtoP6G50YG4f3QMRNjguF694AM0qhHjlHSzpa+j1Qd1bVOhz0s +vVPPDxG/LH+o2V9WuG6MvhJmPPDyeAcrxzGvtHckeFAhCees/pAqcMNhgPPjoJKomTUOPt3w6Ul5 +5JCywtEFvrDIYW3VRK0LYbqvyNGB2bc43GwPOTswPJtMDxI5r9UkpQjBa2AdxhrqOabDdfBWdA0h +5C1k2kpGfLRxwTtAwPEgE3N20IFkZaq6RuxaHKfQRGrxDJgnS4cBCBFObwhvyrbF1fUimNaBt6bj +nAy8IbyUejgdpjQVL2TH3d2y/XhFeGDoCVRA3hpePO68ZzvwnW+0HbjTH8LhkpMo8kuFQjhbeO6A +MOMedPm06p9kr1cYy/FBBgrBN+qXK3PTDAGBkvqhqgdlI3BiZfFpkJZ+1RbhfSGioY8LjqvMsVwy +QeSVDDOa0i8Ot7MDhV0U4Xtp89A3tqYWqGn1gnM5uQGQCYTbMaahDR7tAEddyVHWDZwdiKI1URQT +6npAiJPOQgpCC7UwXnA5rTQVq2vlpJ9sRmxS8AWBnBJ6WlujbvFgDWwHAjfVVC2TBDrYQHsAFqYM +ukQRJLMAdOoqkX3plVlJLUWI0BVBS7iAJ4hHOC2IttbRPXatdJDYka6C1NPJcM6oS3+WO+JpX95C +VuHm6jyyCuZJWAXno3ZfUMCEALWSnJbCdGsG5Vb2AqNgIsiVavI6AcreCwJHW9Y2OYtTqlefSUf2 +mI0qatoykGGG6WDFL1oFVIeVDdx7IvO3TQ5jTQzOAaBdA9BSAEi9iH/pa54M+CRlOi+1rK1Z2ZUc +gGpoiICTDtD03QxgOeFTNgV1xQrWHMIaCLzImb9Ir2rRiQLD3tCmkrqUfTbq5cNqm8+3SeR4rYXF +r+RIxsHhscc1X3Jr6nYLN853tz+uitXR5UduH5O0qGbutqCsRM6T9Piqgzh7qKQy6MU9dHgmQS4y +UMHPq/7zDpBqxGmaQIKSevTHCiwijAxih9Kvs4Pxu66HsfC4x2czDDvO/TZ+gEAI4+Eugn8RnEpm +xeHArdxKzm8E9UBfAt0v27JKL8GjeqFHvOiD0ihu+2ikt05ksd68s4mabmafPr++LmoxDcTY4TTa +x6ZxqieXwQ+dPomLAzwUMtVaFxjfI9wdkr4lkAhjh+R0kK65BZYkgDBtLVlXoFIHE8pnNGCW1UAk +w1mRfhCRTElVDgEsWfcl++eu9gRKPUg1pC72/T/OxjLLsgj9pobdeE/zr7DNTi+ZES67WRM/IPTb +yD+Ke+mBl8wIaYKXrwlyCAjTNI2KDrZxtBz6EiyrNFsFbJnek4JWRQMKJ2eq7LK61bOU9ydAVmxg +tXTxWealCpwqqRtqph4Q5+74IIHIBlXNKtUAIaxJc8dfx7w4o62b0IEKlq760h0gayGDxW509Wg3 +U/eTyg7PdUQ1y/skcoIFPJAprHJI1laEQUGkFwfEOhx4ZY4n/TpWklX17xKJSoXTcz5dHSj2ItVR +aGCJq1VbSEXhZtHUk1avMmDq2rjr/bA02Ho06um8TCaP5aaTnK+BjouR19moJ1MyGcDYeNj0lypA +nql7SgNhztKg7WiwhLt5DxO2G5pZeusyqKXTOsPLGlJHAuhhJ2Q/+8bCB9pmtSRAaursoANB8Gx8 +iq1GNQjdNhQ8U1sdhPKJdqj/qut0X9VkbHOOQOMfIt4QxyKp0Z8Fbzdona3Vu1xvaekIDaY7ZNNt +IF0yskuk29Kna74jzKuwBbbZWBf9UzTy/DAZKglQvRnZ4OyjRqTSUGX1dIDY2NlBButu+ugqapNK +I7UWAaqJil3qPup63VU0HtunT7ecM0L9K53w9KCJUGsRgoOFxrrU6ynjjGtILcz8wg== + + + 9lSMn+hALcKwGrUWpxRBqjqDlsmFqgPoTEGcyr6JcfB9LRGQWjo76EAipVfRZ1drQXLb0mUtJYBO +LnvTfxP729cyGtOnzyzUIQj80Fwi8QG5RKDuQJxbCTVPleNyC1eiUi/m0SDrDoJNa4W5aEiQFOOo +afMxfr4DQBfmovtYBMk+bYNRJWisJwPFxqil6mCe2o9VV5UIP1XrQt9cAkA7GruUQP0wYi3jcX36 +5FYiY+JqO05uegBLAiaClzIJU46mckKR8X+yoxuNgyvpHXXVQ9oYMyKkngrXgiFzAQimCqcOgJnG +ZLgeZCBeQ85OtXSA2BBXp4NAYbjqKkG6BF6NlBpKAGh+YmcSKB8AaxmP6DNQYvj3+USL40Ohic4g +6vPiK+dyiaMQhPMWpA5nTK3h8x0MMZr0K4RSuy2pLjbKQwf6fLkeItjYCtWlJqz7ykBdBV6wq6mD +pPaw2RNMSJizgYsRa4Lql5Smay9Bzg76XnVfdT3vapqM73NQYJyhdaLA+gAK7NQPjrfGeDD/9x56 +TgTU2lDBYsqWQk0CQY9v1Y5ZVy11lDw5YH5EiG56xjZWHX6CqAun76voAF0zZwc9zOCWI7dKtai+ +Rf0N2FAHODtIfelAXf9jJZPxfAZkljk08ZiLv5FKJciB6nDMGQsP85wYU2gcEQ1kLPMrqgM8DVly +Yoa2pl6ZmnQLm0Ibg4Jx0ggZUvYT0wpJ4Rh3dtIPszOo2yb5x8OxSSipAJpEIhhBfgaXDOU4YAJu +mGFNE+O00fBhoU/GGklB3QeyFDV4VcOUI16d4mCJwT1DvPVWhHkX6gaaLQYJ0iDpmXGFl02RFTh0 +qsSP3lo0Hzb8gIrjYx7+rlVjYdrWDD0jPMBCMpy3s3tDhyp1hytbunthFpnLo2xhjJNZc04DLOv0 +B0C6YcIYAdfP2iLlTxODi5h1p47pd5oQyXCwug8Y9CoHXgVhTveZayuNLPKCGjKTsK7ILxENqzVl +mzrg6j8HR+/GH5Z1q+kfMRHJ+8KXbTuvWbjOYa1CpVYJkdDt2pI1EMh5DXZvg1KGeT2mmoj+y0Jg +hOsPvn0shdBjfl2LluVprlduGlkDP9NPLmmY1qmVHkTAh/VMNGP1tEKonoPZrIAbY4utSS+d1gc1 +9GsAM3XmFRX1JTZXDa8TKjuE6OJUP5aKao1PAginQJ3cchwsj3hu1QyIZ3jMnIEsGXVdEgkKdlVe +vq28Mi1DMGjXZAJxkwQJLE4ephaQI44scgVHcGz8ED2q0FuSD6EEkWFMyTotdnwd2RMMkeQjKAtT +ozQASOpwfEDqAK7QRqeYxBBB4yJFpjO3Gb1ACGLdEiXbtuZfygkl7JpCQJsaF0FA8WTkwKpQKkSy +AXsaGbCaFJr2w5peXsjLYVsbWc3WkNX0+Ep2GeiGyNoVBDmaZIJ8I/vMrylvGvjMtA0UGgaEEnLd +kXIvjRpvZJphLJnXNihAhWxJNGmCQCA9ypqisut5+FKWbr1X4jG321EWr1XnRy/STyMfG63S03iL +AoMb+/JUpMm1GbKdGhuN061qqytNsoSD2TUqdvE4p+ejoaOcJlCBGwjpDL3lDkNr6JTAhEv8ShM9 +OuZm0Asmeadd4cj/Ui1hoc2gnbBRUdLU6sIIF8wAnRMcvyn6CPkJoVHTuiAnPUvpa48OgnuGIZ2X +vGJ7Cd+TZO4zsETBCccNfoeyFzIHKutCXwI8o/dg7YELxzA7ymmrKQWpQ7BaEuxmU6kDwWDmNiYi +FaxuQEvX8GAzxql7oGwdGXgJrTnGKo0dUiRQAdUfRt0ajJ50VyhdCJplw6giQKSKQB2LQWqFmu76 +cqRbGJepE/QOTqztmtJW5q1Utx3j5KgVqbyh/zyMX65OUmvZzmv4iO5qJfzm5fvK680k43IIa/At +gipKDzmIxeb1V1jtEiZWMi0tQ9U+mW4sXpgnuZpEZKXSlC9NNYY53NUwTlUZPFmYq68OrTKkTXCU +U2rZgxTBqMrFfrKtas+oS9YtZip1EFOXKnCsrLhSKQcA77VQC5Gbsp2lvw6zOAXeHKRGNfjL0euL +Bu1aP6HToOpao9IzaJbDgixFUB5WtSHSGp3EIBXyAqwzkjV6FAjCQf9s+JWhB6KnZ6+WU0uOjwHo +Sg4potDzTNUmnXml0Ts8p/O4qdwSHFlivQ08/o1QwVPPAEzwasgDzxOfTEgFpsCp0kIwmYTaeDrU +y7QbVdN6kGFZLdnKrbATrWaJEWJQM/OOzFWAIKp3io1K4yagQ3rwhVDil9NclWBGXcPYKysDWld0 +XcNHejZZVzfqrWWcXVtUdmbKM4O+Ke8yr8t6C25bgQZxWoz5ZPFl6eo8DfPhangTviwZgZeYeiRa +deGhY1JFxgJHvuxgDT1FrISe79z18HKHGKPmR5IXOY15S24QylHxWa1bUd8CuRhuTkIvaihsqY/y +XvVU1IloZIajL1+rO9XpG/ht+pIuomBOTDRgMdbZwVuy1C0bNc7NYXT4AywSwUZxCJC2MvqV0xiR +EmEm9P5V2nRMp1hVccnZWtYyCqiK4PkPKlJXnsqY4cRtzGx4+jweaiz6IewyQoyQCdzWwm+rIk0m +Qdp1PvRKjhbJtYRgWHh7wasAzmqg0pVTjQH4KOuj0I8D8gcaoz3OaYhivo1RuJPCtQPHB11pVcN0 +0fg66ThaUCUHWR/3VMxp9UhNRbYyFPdsacy6gkIAIPSqWo4KtqO53RUKIVgKJSJNAGVbhk/nNJat +ylMQCHgzl417YT4D9J0JAQqTXRADr9smeqhXVdRaVk2M3arUV1ekx1adKSxcp+gzXqlzLGA4+j0y +3Fj9iBpouDHza/2kbqPKocV5jc3IlIamib6sMG21pAaIzadOWj6NDtgMtwmaM055mFJvrAOBoIO7 +HDakahYO8m30RRcpG26zIBgtDd9IjcAczOqEbKmmcQTAwHgMs0VJLoPugmU09sLjG5SMVGc8iRvz +FcwVWKqPJ/60VNK3oEQ+1B5J3MDlhxjbFq06tinBotdxM8dc615zNmlwQRC5+5BamCC8m1RpVTaB +nhg6gtYJ1JX1PaUdTURwVmyqpjlkyNURjQU17Iuq2yD3Pq/tI9yR6ZqmDFG54d19RcGqtvQUEJSR +9yqjzOw3iktBajciH/vJ3MXCNXoC4sE0EsJZvbSMMtBstJGHh/yBLQ4FNk5X2Sf0KHY+7mPBEuEJ +1KCHE9zSQYkhIho3yI2IazkoPsgzlKMIrFGbqjACiJrAhSKqBiCDD7WDtKNRJD5GS0BOxN8WWi/H +YCYe/LS+uAr8S8P06nD/qhmz2RqQAzkDadgwtH+A3rgYDyUEsAYFcaUmGi8PqdGkw56lG7nGyzB+ +lupdoWYgWjSmQAEGdazQu/F8bcxhtFXJ8MaK+S6lzUZDbAzYNSvsjPD1iBhog41KadVnwCpYMtTA +ixS1wn2f1qvjmyP5J2/OEEzmOnN1rUQDEYtQaa7g+SfEV478aWHhCGCLg5RlhfbrwhxxHj3MIDCV +eTl+5zWLPe/BcSDmxDSBWuVpwRoiYkpAAPXS0dzuUv4JmCcpCwLnm0/nMpavzJMoNFqE5s9NHP9E +xKJzH8/vL2npmhNDHejY1YHgYUVbdhvjxORgYz6N9FMV6230oCCoYGnfle6fUwMqM0RYk9QDsRoE +QMDwVfY/Gb6koW4R0vc5Fp8M4t593KgxOyZPFKmKWS9CnBCRjmRO5VCLIpgw1BaBgHaSVZECFmxM +Xg5EepBn90ZUSHyIrYOTlj3uMoYYGh+tgyOLf6B0I7TJN0Ej6odpFRc2fbS0aZamdKa2k7j9/jHU +h01dU6eIlAFnoBK8UTdAJr0maAk68UroxQi1cYaOWfj1RJ7/Wf4N9zT5NzQ8pc/gWj5RgAqyY4wC +VBT0CQEqOPjvC1DJ3u0DVHY2QGUfm5Ky3j1bbMonJr7bh6jsQ1R2KUSltg+GqMDVZxShAtAjASrm +GQNUzJwAFbo1DeJT8oF9pvCUMt4Qmh66EBUzP0TFZlEjVzksD1ExkxCVajUOUbHlZwpR0YoGISrV +ahKiYiYhKnZQ0XhsnylExcYpTw9diMqnxqg04xiVZhKjwrDrQYyKCLDDGBXbTGJUBDSIUUEtwxiV +Zhqj0rxAjIqNbtHpoYtRqT5nkIp6RQ9iVD5bhMowPoUt7X54ioqVeXgKIXl4CtPBbEt4CjuTh6ek +AXThKfmIPlN4SswgUqSHLjylepbwFI55GJ7STsJT2jXhKe04PEVnb1vDU1qTqK8+pPCU2nzG8BTk +W9+W8BTmfn8V4SlEmYfDU5oZ4Sl2RnhK5Bq68BQzCk+p288UoIKkUZ8aoFIHPei3NEKl0ZgNXtrx +YIRK1cV72DVlU4RK83CESpjX7EMRKoOSD0aoPNzjfYTKS0eoNMqo7UaEipRZHqDSuEcDVMCr7ANU +9gEq+wCVzQJUZGqGASrQcuYBKmVbTwNUyg0DVOBdNQhQMcsDVNpRgEo7CVBpw8MBKuUkQMVueYBK +0wWohBizwctB4amvm2lxjMqgfIpSCWujVEKSVWszt/EUp2JSnIreyzotylCVMD9UZVScwSpNilX5 +DB6k+1iV+2NVsDs+S6yKj1cKdrEqUafXx6q4TWJVyDeMYlVsOYlVaSaxKm5NrEo7iVUJs2JVzOOx +KoN5fIFYFRsVHkbT9a4PGbEhhYyEPFaFZWLgx/2hKrDnaaiKzUNVqhiqUjYz2+1DVeoYqmLXh9cg +VAV3oawJVXmkxzFSpd5HqjxjpEpphrEq5tFYFT+KVfGjWJVqEqtiR7Eq9eOxKrw45WlCVZrHI1US +x7UtkSpGA1V8ClTxk5AR06aQEdMOAlW6wI9p0RimIoxVDFOJFIJhKkL+NUxlTcF1bfZhKi6Gqfh1 +BRmmUoYUptI0gzCVBzo7DlLBQbUPUvmcQSpN+4RBKlBfDoNU6Kf4aJCKmQSpVHOCVNrwQkEqg0nc +hiAV04VrODM7SMU360svDFJ5tO37g1QmRWcFqdzX732QyrMGqUCROApSgbPJMEjFPB6kUo6CVKp2 +eZAKrht56iAVvzhIxQ+CVPL5eoEgFZELmxikEqNFqhS4ER6NUZF1jVEfpZkWTjEqsvVijEptuhiV +so0xKn5eq12IiokhKuuKMUAlrI1PebirKT6l2cenbFt8ivrx3Befkr39lPiU5qH4lOzlPj5ll+NT +7kOlFJ+yEJnuj0+5D51ifMpChNrHp6yNT/nb998PwlI+76VDekcqAgngzE6Xsh7kDxNqOO8ZB9ty +VaG8h4d/Apzxmk3c69d/0gzr6J5jM2qhIYhXCzJthtaB5gfNJEC8sxBd6b5Jfe0qGY8H22s9Vv3w +55N//OlbwajfnF3cnskC2ze/XX3NC3BKrLq8zBY6xCwElJ6MGrTgI6OpAgg6AUgIRyCnIxxPo1Yr +B5MRbZZ0XWlrvfaxhQ9S9PDEMHGBYBk1OFUJE5FwU3TMRwOl4SFU10HNYhFUIIQHWQ== + + + A07oN2PoMU1fmIrXCuKGVYFXLuBxOITjyaDgJc9lqV02UOqzm/wr+K2CW4FvRChVlPS8OhpvQqP6 +qAjBHXmhiZ1WWEKTkwObbuNtcHsgW21MRV/tVjNGjrpzPOngyXNcTYbFcStvcImv4V/6CQFcqUvb +dl269P356e3Zz3qntEYSfXbKASU7wqAhXyDl0xVBAQpwKl2p6ICRFU5YJto9oG/zlvHq3NtAf6jF +5GeFK8vkWL7kjhC5hy7OrS/VG4O+PyJMVXWlALhmreA6gDsU6PhvGjTOb2VRLiGVeecrUpCmNpSW +ZOAlNSlsk1eP4dpLuMU3kS5ZvZaBYpCcXZeMRaAEhAvWIJjhZt8yPjOjIuwzoJDtITfe2XR2Loml +k+iT9v44lI/xPywdpfEZi4eokcmyKHDxwuDcnywNgBssjhSbLo8AN1kgKTZdIgAXL9Ka2UJNODD+ +wYnninz1pl+TpWsBFZulpjfArs21gDcjNAAOZUqEJuFL6NtKmgq8DY0C4T0JjhTidRPih6Mq7wW+ +I3lJHf9HfilNiMLKk1w230LGNkSoGjYwWm7V0z6BjFeNKAAWWAhlSctjABqPBjeP2nBoyaHCzOkw +Cbw41vCEpwiLW9qhqKVSsDJ6MjBLF84g6HBxyy0MwnAHgssnukaFi0suoPAqq+q6g3gkMbVcBuHv +Ay/GrHlhpxdxUDWkTrPUpctqeU2uYWJM07qgEVCeDiq8RbxhKJyMhnsEWNmWiBET4UAVxjIpyHs5 +nrcUgJfg5KTku6sDRPBROZtAgj2V9zFzvohc3DaNKq1xn2nQu1wxO8w5Kry3xunUvC9Ur3/UnIaw +M2teesyVlnN69ypcd1tGRspu8jW2t170C28dOHCI2OSgBTk+gM+OBnw4uMiBA6HquYkO6Wkh0jOv +PeevBIF1Dfp49SY3DF0u9TJcS5+cY5jd1L+wQZRPzQQx8Roco0pr2T/RZbk6rOqShSx99aha0xhV +dUGExsojFy3vw9T710kgebt6vOsEoMbp9ZqlCcqyOpoXBQm9s/2SjFfteLKOD98XCedQWRJj25ka +jee+571phTnzDc6ABve8t0AWOCDgstwt5IfuTm9XxUpEvl9/GxmieIfrTLJWAjVkW6uEBCcpHp68 +S/rkIO75oE6gJUEwMdqKt/yKCFBFFr2kvxhw1htS6pIycN3WeFjzfk0108YmHeq7OyfAGvHVsq1N +jVMbylIPdzpocOqqhfZrrPWyuJZYnYaL+Bt6SUQiC2dOO2ZZD8LDYnC17E/aEhy0lFApu9IhogVK +EiGsUCBW8fLnShiBBoRShEIR4WNsNYQj6LuvDuDX32o4qKNG+0RATUUfwf526ibyIACVOn2W12XR +aFe3sMJzRh1uj4JvhmU5BijBbAwjB6+ThdefYZgdnHq8kgHVtcMHNPDmWF9T0431gCjGhUCUaVPp +FbyT98WkkmLaUDHtTTHtcrFmYMWa8RdrpqlYM5vZbJ/00eDwi0BkwhXq9oYRMQ39Z9ieJuKVs7Nm +tQbDcAxjPuG+SWlALS8lLuk8bZWojl8Oyg7rXdNy1rXRw+zIbw35HozxqzdrmhIaOeiN0K28q/I4 +Hgpq7UeqnPX4i2JUSTFuZN18D7p7cjAM7fZNZPRA6OTUF+QQQoIg7DZmkZBtBxVtTdeWhGkMm2kj +s3ACKUrjcXBrPKw7GIf19Ft0GvJHQ08Toj0SZq5jKrkZB0K9hnVcNUPnkgKJ6AOj8muGuPvOaf/k +AE58IEMFvexL3UPQItD0eQI5r9aY5P4DBLhRFdNXg2A7DfnsG6MeE1dUZX1i9BJCDmRBGIl0Mp2p +kweU3RiyMFq8m7Boarh9qdMxnAondBOhyQ2IuQejBvbPI3FJzXjN0FRRS4zIU8ECsLnKIP+AaFph +WJj9GH5riFhZV7QOqlAJtolGoKOzjVs9mtsqrEqN2rFq6LWGau37eJF00pers5ur9zcfr9+uPvx8 ++v58dXXzNj/mH1aLr8FrVXSPMFuBI9ymCLoJdqvmfYTfIBYTDBfxcYLjX71Zg+Xcyj2eU2SeYLpA +p7hO0jDB9qi3H+G7TsMI49fM4sn9+vgFS5epx83zcKZPzED2eaI+fir72N7PP7qH+Ef6867hH6vI +P47eP8o/uo5/bDdmII2aTFsIgmDqTGNNIAPpZS+tyc9DNZNPyRviQ4yEbw3SQrUOomien+czZecZ +cJCWLi5DDtLSw2jAQdrILS3nIB15Njhg3ctB+s/BQfpZHGTemyUc5Gj8xZppKtbM5jwOsm0XcpDu +IQ7SLeAghy0v5SAfYhiHNc9jGN2jDKPbhGEcd+UBhrEuxwwjNtJGDCMiWZ6KYaxb8zDDqPb4tmlm +MY7D6pYxjnbCOOYz9pkZR7jqKgvXLmUcsS/JwvlZfKPp+cYNGj2a2eiLs41D7F7MNi7H8aVs4xA1 +72Eb12L7g+zjuNrl7KNdwz4OMf852cflzNzF2S/n4Of+dv52E2YO9rRGPchhhUbyToUU8W8Cp+cy +2gT5Tfdy+lX6dXYwfjcunFUcf8LPPABeIwwNpgzghDMaBi9IUJYB3prC45V1yS8DQp1OkNzHeMcM +JsGrzq0SHqFrIv447kc+iyk0hmTOth6BNOBdygpWpZKuDaAGEzpXA6vS5dLpoSA3SGRDcm1NfjJR +LdZVJRQGekwZdud35Uz+w1mRcVqOLwQNk6J2MSVuhFVUMzdWZR0SQP9fJKg+lur3qvPOVAHI/1LC +DKohekyN4JiWqzU0ARj6RhguEQKxMPGmxgHNdAdlRb4W8TipCf2ryR6ztmO/Rt0saawZ9rWYfFOk +Ovv8jjYickojqf/lAK2aad5rBg6ll3znYCYqKUfTwRiefwb2PAd/Cd4SqHeG4tkxKyMgjebQIcQw +Jt/qs9HnxnWPnGpmia2ZNwqkiHNmPBCdTseOKagYoB17nI+CfxnOZ1c65uM49k0UhM7G8+LhSVMT +8wPTdkZr8pKJQ6bbhVP31Zvp5N0Le3BK0d2HJ3WSXbLNOMo93ZxFNxFFqWwEz2nkBWNgcUnZ1pg1 +9hgfNFEsyWZ6KMhXCVl0ypvVjfJmo3S33pU0+bcibTf8YULFTFrCiiqRFCYNaFEiEB5xKSVCoxCu +tCebe7K5J5ufn2w2A0EcWwI8kcgfoaUbUQJlt1yByYfmBh2kPsxX/DgBzkRQNho9HCFIDwihAV44 +CBxh1hwGJYdDZoGEBKiJzwo624QWTD/zCKCOatULHnzU+CRHqkUA/k8HlRwMQCLr+G2s3iMHQ3Lb +GiZ2qDT5nIMHrEMmJ1o9NSuw5mByMV4yTgQqSefIYK4eClQAaXUy1+BIi8rinklEPcG7bQ1r6ryI +etSNIZ04giErkASj8jGSDTL41+q1l8HW0T9FRPAaCex4lRRSQMNHaE1R6ytNXSdyOPIW6EU3GzZ6 +NLNRWVzY4iG9W4Z0LghIWIOXPXARZkKwXYybX71Zip1Keebip45lKYZGt72FODra/WbANA3WIJ21 +mnRST8VGnRsbUEN4QULfijmhZ6PBEV/WPIkgG8mB3tIhkhorK7+9bwYgfOWRKKmpmZGoRdITqbqO +AGTDdcyp4GIuXWiSrd4IGzSzeXvYpS5l0iemWWHoctCUjczNQg8rgKjSPgEoRmHjK0etbas+dHT7 +U7aM+atrqpVNeo7sHC8VlQ2MaGnyFS3c03ilLybdlSDcDWOneTaWRjM0MynZyQGdYAN4j+DVUoLo +Np4RdA88IS8C10LyIo3yIpoHFxCcQYBYRnejPzYAD+uS7nlj9iT9uldN6Gv65UhlLRO+10GWhiFV +bbmORAHDap6p8NxhAhSHwDjepIUYXVW7OU1dFpD3iEkgf2BOUBGadVMGGALXFq1qXNKMJGxCLrlj +js42bvVobqsO2UGR8MkEXgY2oFFmmFR2DfORtoz6Li/cNKACk22DTT7ZOAAu3zrCmGyyeb56s2b7 +EDjeQAKcv4WUl1myiVhitI0ENt5I5L+GWwmg8WYibLSdAJu5ofrVHls2GnsfSR0zdExCTGfOOt6Y +wOcK/q16WwCfYT0NZPGYMgYbgpNWMka+rpCaDipgLv9TMfIjyINUpJRdBQHRMDMeXF2RUXOdDo6I +USKHgexTZIZ1cqAxtD3QI5uX9zQGYqVBntSm1cyzSCKDSB9e2g7cGRerLS2DUqxCAFHJHIybtHY0 +p7XAHJ/M32KRkGcZ2ZiihcIWIQbv5liKGk8qqgz2hFu2J4Z1IRNIpfoRphzxMBHhys2GHvJPg/P3 +YLizxPDKQj0ADUitOYhBP0vaYiYKEzmymHKUfngxFqEy4OkQg0BjDJljpl1jtLxrZZR6UgqBaklO +GwaWrCtaNTExmQX/2yj2GeSE+P/Ze+/8VJKkAXAvwB2QQYBw5atAEsKDJGRB3uIkIaww3dPzx/72 +AnucvcZeY6+xacr7At60+jXffPMGVWVFZkZGhsuIDHQZJWBuSTHa39gri5ksuqQQXvguSkoXvUIh +K+BLUil87q6meddErqca72u9MiLWECyzykOgeqMJaEFb+s39GRDHwtoGFLqsg4BuDU687AKGVZDw +otqq6hGLb56Cl0mjolriV/Dia9wA/w10dP0jeEat+ypmgBszdA6vK9aOsKofsuVuSuLdRCZJGMzj +TxIoygYlihplhZw2T/M4hAgWXUN3P4hvOGTa0nh8SIMDIyaVhH34LTxfhikmDt+C7cgAi0+bru+x +35z3fil0By3QP5W9NIc3D6NDUYUAYuiWXx5fgY7idKvqZwy+tDjGwZR4HldFISgYjKksufgk7zM8 +Aqun/w6BRm1E0MoDsf+8Dw3SlgZ+PtnqMW2t5yTx3RPo6gkC5QLa0SvMamYcyYZHThEttULojl8C +GYRYvJZYvXSa89wpBXOiaFLwpOkYKRk+M9Ky5qknag68mtBz4HUhigaf6WkaPNLTDHhkpGv1Q9eU +DeMoDLQNUbEQdWMc6sdqpHCt3GNJVYk2lXiCFiu8JRpG4g3gXpe7E/c2o+ATXWLPkfiifXSNlGa6 +vHEj8/L+030VM8CNaftm0BUF6tFVfdq/bH2ysFI7dMHBO2QomIcJ1WWrjYyvzCQIdKcvvFdPtzlI +QsD7UKCQN4+m1JsZ55eiawrsv2U5XI9AtZsX6DnnvWcyCYQeVGGVLa1aI07csfonSFzgpRGfQL9K +Ehc3o4FF5VdWDIp6hsPC4ocRkHqIHI7X000jpp+nATn51RIbuihTcFxxeDkFrECgpTV0/ytHOX4N +mT0s2qilNo9d5xbqGqbnAxHiHIm3iLpNLaduk3p1mxMMegsn6Lg7EjAq7s4JBr1F9UjSW1RfxQxw +Y4bOJb2F1KtapDt1OwYdhwKJAuLx1VkkzH60019iwExkWHTdAtIJaE67olD9oKElSNNKlQ/V19Br +yFCOXwsUdo1qr8jy2ndukb6hzk7wHK/Vu5UV4yTGx+O/sI4s1q30S2oCuhEIXqKOlA== + + + CQZFoJLIrZr3afQLaOBWfRodBBqmGi1FIiJekP/WEJGgYnnohhzpUcwAN2boPC+aC+oxSuqveiII +OCvgaWrw4cDraHghLCuTGLDckzYkhh3GBL6MmmZMmAavYjk8NNx13I6B9dBox6/hRWniyeMSfecW +6htmssO6RR5OPbUEKOq2MglitdYLESL1VU+G6oeuCVEzOIkUoXq5EDFK+r6WHCVt1S1B6sLBeCuX +I4ZKGuxpwcSeFgwWiGCwQCQcqOxp9SPRnub01genAq080NrTtkz+58slPaZ/hT2tZenYQAXjcmFP +W37pbE87dWptT1t9uYQ9TZrY01pa1jz1RM0iz9HSs2hPe6Vo0Z4mjfY0abSntXStfuiasjU8Sm9P +e6ZuyZ4mTexp0smeXlCxZeGfr2ej4cWkO5x1hx+xGH6M1F31C9/ZGL4R8JuL/hz8e9786rRmPnzB +pD83mU8//aeNYeOjMwGqcbszCdu/8+OX+Ua/3wU7dfzZbYkt66NRPwFU7PEs7j//owF+G5sCNQCA +ULdnbdubNEUgSv3GzLE9jdpfwfQObVsEwuQD3uoDY1s8EZI1fgEW9Hx40Zh9akDnPxuT1kiZJGiF +QJg0rXf+M/MXun90AcLtgdYRiMa4MwFsszabjHodMLA4XnNAJJoVXzHlWCAGUIgaKfBPiCX4/wSB +/4v+EkOQ7Ua7UOcK+aGuKfgfzo+KXOBuyV/SLa2bMg3+I01Y9Z+V94tRDXcD6pb1s5LETP7qTmUc +w05J1CHghX4aI5n8Bf3yOiTzft4rkle5A8z2JBiXtNMRMSb8klaD24Dmfirhl/4DMZXwI3SRcUrW +bBZFncWI6hoOoRsXRZgP55cNRsXdrFAEb03wc8q4YMQNyXMwhgjmR6LbmGBcJo/4HzQb0KgJt6P2 +TAVJ/Ea6innqS5wMR38O0R9AZiO5HvYnzsA0/FFfIgvk+R8d6W0iL+YYlrp9MDPYHtBId+jHDfBT +rOkmxCZRoCwkbrrTbrOPABoh1GaNVm8pCF7HkGtMuy3lc7zImKT85+/v0w4QaKT19+IHR/3+HF2G +MZrEG+MxQBpeHPBRR0RfSAPUXwWo9Bff38Hagdb17gyBo1A//fOJ2BgM0O6W7tDRcNqFqZ3yXXaF +7nTcb/yF/4QpnwkMSVw1MJErHyA2niBRJS0BJv6hqxx4RuA0OX2ClMoHc/sEVAmNpGEC4F3W3L0I +GhgdjCRW4xOFzrt/z+/zh1TDCWNk4htK8HOMHGlWUd+eH83fv+cDGG1MZiYrlut3hm0PC26HzwQC +puDKnRNVmZzyucXgbeaRHw3b8+7MzRzUUFa+AyD9rQid8vUz19NO8Y/O8LzdRiQJu1CQ7Om2F7HA +hCrVy7TWBLKxYV0W5KFCF+/BID0aFq+lOItyE8o6ygP8zWnw95mSL1H8T6c1h0NAL9C3ZvIM3t/G +rYXabybU3PKPtTBaC6OVCyMzCYRPhkh4CIIOHzkeFjmEtSbwbc9rCfQ3SiDqb5dA/FoC/WYS6GrJ +W5gtjCoTqlybVGsp9r83qTzfZb4WaP/wKXkSaMJaoP2GAo0TaAFl11Hgf1noA0wKLI3vfmUZeJcC +vCFA9GCz+O4aAuaNwIJz1n5Cau0oXEu1HyHVkgK+So+heHTHJAsr3aAoFJhDnVx7Cv/lYi25Fmu/ +mVhbewrX0uineQoJUbyshc2/WdjA8Mm1sFkLm7WwWQubXyVs3OQerIXO/25KhqSHv0Hs0D9b7Pzr +hAZ0vFE8Acvmohvy0HkRyTMMo4nP43mKZXBNaYJGnjgeRvOxP+soaUGO/bvwW1LAl44TsAwIumsS +c16WNSne5ZHx/j482BO7Ytbs6sexq6Wqx63Z1Y9hV+KdCQQt0PDYB3EreOUox5hd37HmV274Fbvm +Vz+OX63Vq9+DX0nqFbzfn1TUK5pHRf/W/GoRfvXDg+P/dfzqp/gQ/7msRmHqlj/wf1DZJU98ac1N +HLjJDw90/tdxk7W19iNY0qrjmEgcngtYWVJAte1YPskQuCQoISRXkPL4L+Vf67jWNQd0xwHX6e/r +o90fJg2SDE5DongeXiyIbuJNUqzJ5ZTrM99/+JQ8CbV1VOvvJtR+ipPgH7Zr1tLo1+a/UwJNM6gM +LLxPXgCKFSqDx6xDXf/d+e8c8bMl0L9OfqzdQv9M1utkCNDYDiB5WHIMlvagSOwUYiiGW4cgLci9 +1oH6vxv/W+vPa/35B+rPNJXkYW69P8ZzQObCoIY4TzC0SXXhtf78b9KfqbUE+s0k0PpY4kfwk7Ug ++8XHEqhUDMkwDLo6hoRlZpA9Qgr88vbI70KFv8+UPEm1H56JtpZqa7tqLY7+OeLI5rYNMU6cEtY3 +8f7LLakfnk64ljk/xpJaX8W7Flw/x44C7+MMA6gZ208cRXHruzz+5fbTD081Xcuytf20FkP/HDFk +ZT/FKY4ACpZfuh+A5ViaXRtS/3JD6odn+q2Fz1r4rIXPP174wKAIYMFzrF924rHJ5Dqj5V8ufH54 +mua/TnRAH5zA8oQAj3k5VuBJGH/KEQSPfG+cwFOo2DUBr9SBT0ileAjDEz+uyPC/KKTYtPgTjiPm +BAJHo+FrwSiGIZb3Of0+TNgTx1rn4P2OPI9jWZLh0MViPKyVbnblDA0LqicxX8QV1gVUBHBdMGmt +d//97N/p7IEkcWZfkmFIAf5iCJZlcFIJmWS4dWjyv1uw8T88tW8t2BY7UGdoIgmFVpIVOB79IAWW +gVo9wdBYjPECQ5PwBwl1eUrR6teCbS3Yfrpg48SbROkkl0Q3aDECSRGok7jAkOS6wu2/XK6tkz5/ +N7m2Pt9Yi6Mf5WbD5xsMDZRodLrOUnGCIoBFFafIJLW2rP7dhxz8OulzLYHWEmgtgX6hBGI4eNBD +CgSZROUUOCFOJgV4QJck1gLo7xVA5N9fK5BfZ2iuRdBaBK1F0C8XQQTJ8TRcOoqPM7xAoqKJxPp0 +aS2CfnjC5lqArOsT/R1sk6YQ22QpQUCxsQwH71lBdetgGB6zjtNajN2sc+p+N4aFYlMpnkbJ3wzB +QD0jDnPAUVCWFKaFEsOBFQxFHo8jtn5YTOo/bNetNeb/RXgWt75i6wfrz3+/OPvh1T3X4mx93ck/ +aOutZdr/6BJ7GJklMCygZBh7zBKMFHFM0iu4xv53ocLfZ0qeZNoPzzz/V0qkdfLfP5IV2yT/8QLJ +Qs8Szv0DRgWxrh+yIMP6pdnKpuzmCsL050eTYWcyXRW70QGVWYztWgD+c9VpANqF5DWfWm3BlbNd +kd25/t4jn/xFbvHflzstiJ81R9FylMmk8Ze/Mpp0/zsazsC2egrxlH88ewr/o3Si9eb8t29OLHXq +k8Zw+j6aDFYlolQA3YknGT8z6cuLxgyMYYgkFSEJr8Hoj87N68VMeoq/mXTe+0DbvtM+bAzbo0H3 +vx2zpvfwIeNPHAE9KzTuDi9G3eEMPkuKz4bzQX407nZQRzyl7r+i6l8UqaNZY9Z5vQKStYEHTBLy +y2mr0Ydj7kxaHdyHPBj0qtoddkzBFTofkw5+ReqAlRotgH2zjirqjkjdK+Wz388Yd8W2ywChQzXb +LovKtopr17qDcV/m2l7UeazH4z4UwPA7dGOShdYuGgFgJoAErYd+NATanr/cH/3pZ4GgWYuZtZj5 +x4kZhYbt5UxhMhrXPhvt0Z/xRtdcwKhBuTaAEGdv9ocIJ0ScZyX+OBo3WvCZ/KDZn0/MTXuTi0X0 +P/B/7hpe/QAKpj9a/YnIwNGYP2Z/jf/FbPuiO+z5c50/Ov1/sQHP/q8M+F+ESdE7CtS6z1XhUQPS +Gxf4Gs7QjuJlFvA+nYlKoajq9bsDl3vu73AxKlyHY2kCHzlSSV7NhWAuvejp5XiGXY4l/ZyznF+S +EGg5j7Xusj4qRXo9tNMaE7ViHycoeNWYn6RZuOlomC/Ms6u/ExUzxNL8v//9y3/amPZWxT5LHcA4 +Ib7dsU5StjSvbCXQP1sh+YWUvpaDP3YrQxudQbuYsjTUFzKEfp+N4UpTx1bb2jmxFvA/RTv+hVb6 +YnIcOjf80j5Z0guigeXSjJSleLsx6amdDK3pBDlBqDjJSW3+6EwkTzJG/LjRRZ6JmLrV52jyX4t1 +oFgGBj9SAoeDIfEKwL96iyN+qnOP2Ll0OGAE6b06a5atYtmP4Glj3p892/vAve0oFIoEI49YtOpJ +Dt1hyAtJeGWpPFMvEbDmTvJA9ij5Why2s5MZGu0UPmHhk9ez0fBiAlp3hx+xGH6c64D9c9Hod2az +DuKwF0034ww9XoEPkRIGMPkcRot191+f/rnvouUNT6Hbz+6sI37njK4GJEAg6/QdJRmOpWFkcZLm +SZrWuADE767KOf9Vpy19maSTSc0lyUmaoWC6gnqIypf3nT50tOKPOZbnSa2bQc7dUX+EzkHEb1ie +SDK8ukOSZliK0X5Lyt/m/2pInwoCjbwaPE+Q8HYmI1rxcohf5vpzCaE0+D9SQHgk6CRluhDqT08b +H0AZbIhfkzzFY6QyZFJA68Ky+AfBcQJCH89ymK8pgXQ8x/AiyAMYAF4+oJP+3AHDGheNpPFyCwK8 +4gO9YigeXfAuXeMJQ8XRxZ4MCSCLYCmaB2ApAYClOT1YngOYTSKwgPNq15hhATyYmyKPVgMWPCof +JAlTsCzJkhS+fZRkkpplSHLwGm3YBs8dgEVYkMHC0ZLgXwCX0MOleYblITiBTHKaPLB4UrrVlEvi +W1HiFA1QRktwWThcOPzcAZuU4PIUTWlGJ7A8y1BauNAphmge/p9ybaoEl4LYpRF6aREugEpoBgex +y3HajjByBV4UclqoJFozQPEqqCzF6xiEwCUxLhXEM0kCJ5OKyKVwPoFIYQwBkZCEg+UksIBwdTtF +YMEm0oyWoiARQLgSiVEYyxgui9ZMALbPAc9IG5HmUPoCmBeN8CckSYrDWzhJo4vTIA1IAp+H6Q4i +ODRIBq4UJ62UwNMCGiQNdgEcGuieR25MiiZoAScCMgSP8ytgHqDAqaEREJOstKt4hqNR/oXiFOVZ +ntFMmZSWW54y3g8YKGB+0oxJUgYLEYlmCBgJykhkaIrlVBwWjpLDt8iDH4ZRcnDvkywvwSMEHlEN +WDeCN2VmQKuCk0YzQBiEtAY6YEWwDKZ6OE6KkrYpoD0KBuaDbcpg9JswyTjDwP0DEUCDVWLV4yRp +OE5BEOElwU98+RAJ1pYxH6fEVMkkWB1eWXtxnByAy6DpM9IwkxxJUEiewQrgAo2/pjkCoUROj5E2 +EI0BixsI7R/InMCQJHTSHI1kSBKwasL80n9GYcowTQexKnHvEHCjg4WDQ2TlLQkICUFkWYI1haiw +OYmNsnjJpC3JS0yfZKQtSYN+cbGkOKBuFu1oAiAALzTYd+L2ocU4bAyJFQAkOOWkBIckAIPgMNNF +wd1ANtE8XnDIsuAuRTxSjUbxLmiRD1ESHpMGZpwkkwxeFIBWXsuMZZGEeTvoWTpRkA== + + + JRKNVociJZ7JAXZHoRlTBKI7oHQQrIaaZMnM4Zwo8EOWnUlE6ALaQNL8GRrwHgHRMgdYPfyRBDwT +C2UmibqD6GFFLsTgSg8SPqE4hlmZcI9LexKWUETrwUL+hjYRz2BmQsFlI2VGAZdRFB20WnDCO4qB +4IQrLkhQAUUwJBwJIG7EGghAzBxmIBxSImiZUYrrRGFWj2EKcKhol3MSaVKsQJFoygQHeDEcaFJA +OCBIQEiCWkhwcHiwF4ZSLROUEwABLId2kcSJaZYUk9iAgiXmCfA82pE03gycOH0GMyK5koYIlYNb +nUSiTaAkoEmORbsZtGMRdD7Jo0EDmqDRNCTJRktyXpRJasmGBJvMPsGXeD3gZhI4zJ84nsFABMTc +Gam2ByVRFKldK0ipSGmQlRwGsEPE07kkDbQ+P9Z3kqJ+IoldcZOCfaUgNAlnjtEpYZMB2juBFTF4 +czscI+ApaM8C3RyvszhC+bZ2AjNmDBNhk0b8GO8kQ6JWbfQ+8yNDwH/T/RhCYyYsNrByXZp+IwIH +EEuNdsc/G/mxOeIES9tagWLqVbWBo2+vQDILobIBpGtuijRoF/hRgF7fPWDTjyD4UO173ph0pv7s +8KMPzCoNGPyfRxXMZ//Y8AkiF7j4mE9BM/Mie1Y/Pyv6AQ9l/XkI9D8+/UPpM9yZ8haAMXyBnkkf +UBwibPA/KpBm3ci9gK3KcaRGrPKAcrWCVkDiBWkp4lEzjW9vkOQNjfReKGUBU5FkA8ERJGIPQJMU +KHNjOSkySF7kE4JKWwOMAOm9SA0iVXBl/RbobUhQsIBnaUcMLF9CNjkIzNfQ0CX9n0ESEglwwF4l +0AxPUTQGxDOMubLBSoJCwGwXymm1akBDmUaRaNRgyUl5cbA9ollQwBAMa4OeSappkkc9UAKQLFYq +n6yOC4pqKkGjkvJSk3DLNf5C8S0XH259EVh3hEJfVsg4BuuhPAkUZyT+OA4o8WgAQJdmkVQRL/fQ +/xDRDxeWgixV1m55oJbgTDaGpgksTRkCi2pg1yBthJL/KxowUE1mIaJZaQE5MAC0biyw3RDfBcsF +mDPi8iS25mhpTPofGCqPhAePaFmCCvR1pCqzFIk3AgOsLTQmIG5JrKPI/1VrnvBfKIclkQlGg9aR +ASoNIjSgQIDdgVQbUd5Lg9L/EMFSSLwjxwD4V6JbjsX3URA8ku40kJAcJhOAEUZUmDi16oX1JJbW +qF40A+hMQAoL2L3IKGNJVm0KAfNGurdF90OEy2OVDu0sXhKYFHRFISuc5/gk9qGQuAOFycj/FYmE +wHsUqhzgX0k5JoFWgL4T2CT2JQhA+9LqsdLI9D8kvkIg4x8SNaV4K1gBtyUYisAaF7DftA6BpMil +tP8ruUCQ0s1QaN9T0pa77TT9+VF/BEXgaD6WNx+sZUZifwfHCObWFyXdKiAbnxpOw9Gy9Ukptg0P +NDEtXjm8pIq1JCmjvKTpUmKJNJHCsPWA9FJez3NZisIaODDtWF7jTLR0DrGsjXMoKSphAgEIgtLC +AyYr4G3wh9qKx/AoOG/aMD5PcVLK4Ci0D3hZs5XsVMAyBJxFC3aE1rnJY5VTJFq114oUkgrlkhjm +RU52Wku+acVbrXZj+87G2OGN3kgu72p3OlN78e2i3OUDWk1MpTG43DbByeB0RyNw9LubzIQk8Kva +X4PmqA/B/B++UGU0AFplqNLpj8H/5BrTXgcNHOiKrc8wVD//AKOCmmfoqlaDTeZ9gDV/zH/V/fic +qR8URn8O1X9XO++a99dj9V85oB3/2Zi01c9Ko4n46HzSBH+fTxrDD9h1bQZUV9XfuflsNhoCYjI+ +o9TP6o2mthF8oGmBO8J+bDD99kcHfQDXS36g+QA/osEj0eUOBtdt9TpwfMjnLw0WyviwiHewUmqs +W6+eSG2FUWs+ACRUaMwavsBrQvrbn0J/qc654N93p9WzUbtj+nLPH/rPoD8Er2ON2WzSbc5nOMkF +NMVU978AsQL4qlatz26/PQG4R22k2BrpLfxn9te4g9+GdobT1z8ak+meKrlf3fSPBlx73BY+n1q0 +g+niuJk4kqnmr38odoajYccFYvojQOFtN5iRWkb/3nk1u8M2GCjpYm6AOGqd2RmahPP81K1XtPxL +YoK0xYSr+XcbzX7HDeE7ruo/aaOn/nC91WHTv5mi4fRa8+lsNPh7Odmvo8PUtAHjIKDMA1vMLTn+ +8n1RgzfX/Jih/A67dPr+5w+Wxn/zNpj2u61/Oi+OCaQSGma5vK6W9u/mu3AqnNNU/nIzlb/+7qmQ +HC3QTlP5s9tGYe2O0xEb/gOm9NlBlqqLOUkt/+ZJSdGfVhNqjoClO4Dm9fmkC6xFN1MzfvMDRD7i +dbXRfNLq5GAQ9ErY3j/aICNM3qoxNmtMPjozoAdAl8H0qOBm6Y3f/M2q7MVZmWJKo8mgYbUr1VN+ +7/Y7to01k1W3/seb54QTJ3hHgdDuLHOl7d+7/I6T6g7BOPuNlrtpqVv/cL6NLtsZNwC4liuNQdv+ +b960WyX0fy427ABeJYSOWtxMUt36hxPmcHTqaWra9j9A3joz3v+ZSasVSn/3aEbjWXfQ/S/KLPgp +YwJW8t89hEFn1mg3Zo1lx5FcchxbbfH8w82uUzVGH+OTQoLwSz9UQGo35debbufP3Og/d/di+8fT +Trs7H/ivOtNRfy7moMhfZI9I0i8fxwBamY/9pT7c5vBM72LSganBinuYY1maFWefPUr6G5NZc9SY +tP0tdBRN+pvyLGX2g7qQJuHvglE0Zh3QsINc2raNe8NRqzeaz/wf+IwbEYGSgwZHcNqZfvqvGlMg +NUWCV80Uf8FSDCVYD5ryf6CTL3dtZY2DJjTjOJ/PxmCg9iOhVJDV0hCMoNv2T8Xr5lyMQkGz44qo +JufYVp4cqVkPRAaTPzr+euc/M3+x3Z01mt1+dyZKcZKRYRqJqdoYfswbHx3/xWgsLaFeDPISXtrj +bhw3kUCCkU10JDJAlxhoHjX63anu0XQ8EncMLfs7xo12W95X2SN/dj4byStmJNukf9wYg10w7Q7m +/YayivK65/qdThvaoDfK5iYt8au1iPKT0Tg76TRwirNBZoaUWEBSv+H9NGX8RcTD6DMdSxAnK/cG +O9D4GsTBSquWbwz/aExrMjrUhED432XOADZlvzvs+KcosXhq33gs0c/oj85kDA+Ip9pVhsgSuQ4c +9OW8AanLX8WXNukZhNk4ZoAycUteoXBNywla59gfHXiLob/Z6DeGLYdJtvrdMVg76MX/D9gbH4AC +xIGHSCYOlkPFSHvZo9K835fweNOZTKHwnU0MXdRKt/48hFwf+bMihZjvC/3fhBZIpX5a9V9PO/6j +Adxg2SkKQoCsctjWE6PcXmkihg/V4HWREknwPKya5fyVXtKZN8XjwhdLyLvOrKGio5ihgTGOR/rA +XxsDU2kyBeiedVuNvp6sLD9QYlMM9GX8BuA4X6tp968pbJREqjbXSTuwR8NWf94G+vQAUoyegZl9 +UR7B8gAwxx6wo2a/42JIeLrFwXj2V77T708tCUP+pF64hb7Qisp5aNcDWuTTxrguK0CUi9bVUUvF +UfUrrt8to/FfBtrWIUpEpv/u9MIcpq49SlbGmPSf4mRvQ7/qNtfD7n9MO1Y3uu0O26M/pzpqV7Xo +quWmfoRJDd5qjT/g1oIJ+wqE0RBSil/Dn11944fL4yfEBSI8fUWaLavTR5Q4PreTwl/RoqLi6SNG +HB/j6St2oa+4hb7ixa+8oVDQ0ZENRZgTlA6N0DvtRE+Eu0/wAM2X2P6bJ4KQ6Enw+B1ljnvH7+gF +v7OgK8fvWP26WSLelOsoEr02b76P+u3ORPIkwqfTsF7s6hqrzDUtdyjMx2Ak0PhSxpLrfAKqUvlz +cFPUQKQ3rXDeM+XrundqG0D1Xsc5i/8ZjyYzqAappatKtc6hQx6Vcm1QkDROplqnX2nMQN9QuPTh +9KYqfdei7RH0tx4V1C3Vr+swTgH2ajY+FDKqGp72bX00Vr2Tz4/L/RFQPq8643l/KgvAPfhWvtxD +N1H93R+KggPsfaRzGGUveFMctkYmFjZ4A82486Gil6nfoWtmEO6g5iBaUApQYAq2usq4SeVNCWhT +daPzGIIEZtZJZzI0GwjQrWX1Uz32QROgF2nsph0BYp9i0jJsoaR/OFIMDX93iDT40bQrdePsEaH8 +wDi08YKo7QXUFqnzedFQuFIbCmprBDXFk0rcYDMkpzFD1J4N3FqKvfY3gJaMXR06l4LGDYE/gqlx +0LJAHyGTXf+RG6dQ8aLmFge4sTUSjG3PRbOtpjYf1bjCzWyQpZ03bu48cS2K8VfOOHbYjXL4vP+2 +00zcdNudUeJ0BDS9DkQqUBzBPuxIuE0ojvJEa9SH5QQAZCPLVrebzvrxNu4CEbUsEOzBw8/E9opH +0c034/YAvO4PXQ9q3HYNHMf8yV+Q8vVK6obj8SSOhF28D4PuXbWcjUTvEsvz9i0nimEjEKR9Wxxn +oGPvmjWEbf8ciRXh7Jt96poZcPo1agKcTrsfw4bRaahviJa2KcYZ2EFEDUfwJNlFu8a02Z0NGmP7 +prjNRLdPzFq3+pN4azSEV4FBl5zNUGFLmW830VVFeP68aetJOw5seHjnjsMAQMN3wJqka8aQKDZt +hYSE0ctn6PUPeEA7jn+6bPeH9djGH4NevDOEOoa7HYQ+wFtIWU8334BFm8EL3sSxxCnWlO5hU7Cp +IW9WBURZDn0Mtkh3+D5yaDZRXXTl0BR5SpuNydQGuahhE6pYYD+pOISLxjKTcNF2ovF/OLVWMwrO +svmgMelNtaN20VgetYu2qlG7aK0etRmT185xPu0AlRgptzb7+H04i7f748n7aGi33cfTOFTMAA+Z +2pPFNA54JnTKDkFTlfA3tPzPOD7RsyQk8M1afrhhXqCdyLsU/7IZmpR22B9uDXHSnky1O95UAKFm +kiN6OrXuuTWIS9711uCvng0bVBqO8L3NWg+uoXfMZWx7hlqCyIKu47W4H+ekAn2+7X8K1W7PL57C +/j8oBx0IjkslnMykHWgDtZju0EZ0QvnqNGTYRlRZREmQNGeDUKQr7E9gKKtW6gjLENACAd9s+5t/ ++QuT7h/obmw7vgy+V1QsG+VCw4itVAsTb62hETpydCUzoIzXjM1UWivrby0EJx/OghK0EYWkqiCV +vhWqQiXBcmxnI3Rxo3FfCkIyJW7UpjWc2qEUtJl1+2oL25x/TqVrNm3aIB7rJBsnkhwwGzJmu5ol +MW0zBaazdDJqzm77mmM3sxbNLrSFbJsMOx8N5WTTUgAAxXRo36ZPtpDr3GD26YXEZ6PdmaiOIk1b +aeUIb6YKAmauPx00Zfj9ro2SDBqMxi0bxQg1mNpMHTVoz20NdpsdDD6338BYxMyHLVcMAbVuDIcj +JQ5VDA2ATpas1NCvuMo8RwWQ6vbISaA7LTa4XUy9CIRVq7oswh3seXOhiCwkMGScOA== + + + bUkZiiHV79u3mva6Y2DmDG2ENmw2AbtxMu3A4U3cdSuFHbhn9dIXqrlZDQf6LGSPnZYKjkfNI2AM +qGlA5/zSryhh6RhSFku8+PqiUBKdUNCWgQFuo+FU77YDI/Cf41cqV5Xa7dz4o3MKxH933O9ktWhy +dPKoain4Vbcer8C/A2cP5vcKU+zzik4shkHYfucmJsPsOwr2d4EVL3R0Cju8GPW7klQ0NR6kgeKS +EaXJaACQ+Odo0qtLkomxmd7paDhqfYKPOqpJnnSH7kxfadA40Aq67YczcQLusCtFMWWBHG02ZtXG +Xx3JzIRXTNkvC7wMAudzotOWbHP0h4suUayE1Yrad4o+te7V2/JcKcqhuUFkPlWD29jLCsECAsid +ctQGK9V970rsi/OAMIU6XNC/dbgOYztpSJfWmPYueiW4SkQTZlyOZEqpUACtSf2eVHmvtV+6CoP0 +RjJVxfFqM1iLzagetKmO5T42y9zUN7IUa6r1Nu+cg0fErmeFWi3UVNeBova7VMcbDB+7YIIqYQbj +OQGN5htjHNXZdRAdDIQj+YGslQWlR3QCcdoAUkJJv3DHSQqdKRhaw70ElVhHdmJPvCbMbkFBJLM5 +F5gAjOVI8ZZa+GCl1vVJdwCRdquy7B1ljdl07IZ01fmAfUydObNON3FkzOgjHCDbVam41vNVTtSd +h10Cm+e204Sh7s48SkVEar7kPJi6nbkt4wUyMKAQ1z/ng+aw0ZUi7EL1T7DT/I1Jxz/77PhFt5N/ +KgXC/fnZGfqnOMKiMVQX6vJDLupvTOFjRfeVYuLjKD5khoBrgf01mvvHgHP6AT/p4D2NusbgPmAV +nq6mo6gfdCZ/OgQzhhezjmHymb+LTs4b/n7jLxh/3xjj0BHIq6bz1icc3tGwgI6qFDC4tyFA6hyM +bvSudN+d+ufDHqwcEne981uT7thxY6HGACOIy9RV3hi7NZPNEBeUhmVU3ZC65sifc/IhBsU6bSww +8I4xBstsqmAg47GK7TqQsEqK28pRHE8BIyuu4CJbu4fUjFYXzmgHX2JmLoyS2qwxbMsh0S55sVhK +5a8zW5eHY+y4M0LV6oH9uiIi0C4sMJfBG6wM5mXb0JX5aTYdwFf70xmwyOdyctD/93//P7P/9/+y +x5n4Gdhf75NvrR1/NOz54ZVuKhOe55NKTKDOxFZmlsh1pZFna/mjI4EtdGD/8CVzeL7zGNm/PQju +Ne6ix/TOeSyXmZQHn6mP4cZxaSMaCua7jfh0m7uuFLmtVOa6nD5lDlPVp+BpZjJv8aUidSoESIbZ +Iohp4avwESW2M3sv8d3MfnQ8zUxPqIQvkNmrbkykRsez3EflsprZZzq1fPcg3SrE48EPQ1fV9j3o +jy+UAin+oTwrfD3nmIdYNDsYVafZo9rsM5LmtualArN9m/vqB299gcI7cdw0BbbNJ9/5m8vHp2w9 +H7+x7lTdLvWc2e+VnjOpaXwQKUQD81Ko3H73BRCySm9Awyi8P9/yuX6mf5d6z33O8p/8A6lBx9tO +oUVWvzP7h8FbDAcMeZp/+XgZgV8734Wj9tFGLiZ8bWdrsa0hHsNdoz33BZJfoUir2GIvQ/lP5nVv +PxugdyK5s+hbJJMPXpfynflu+uZ463Ov1Wr04K9upPhe/cQ9k0SiwU+622+p7stxO9cPHAZjk8jT +PFut7XzD8Ycze8eftC/A7d08Z7LDVnAQOTjdS/CDp4Muzyem73R20joiI70UKUNsFY6nNwBtfLDD +39JEO9XNJxpgfcnTg1As2sn1+YsBnsF9NZDJH+1v3RajSXYK1uXokdtK8/nRS2T/pv2Yoppbzwhs +ehgAE0pzu1twSR65W+5yCPGUzvXCXEwkzZt2lSCft04Licb+Tmkj8jCBvXDwxQuCgpr4AkRz84hB +vyPp0r74a/+2eIKb56PFNwyMuqeOAOneEZF0uhilCocfByKc24P9vfbX2QtaSXnAAN55jhV7AY1y +x/IAnpUBkKGDK9iow6Bn7Eau8IpQDYTlIcM9cF+tbL3wFSm8J06+i41GcDvHNa8v9yuF13S2/tma +ZS+2W6fZOkWD1c/yz/db4Jv2Q/Hu7XAuowhTrYZMX3oKMKEfn1SkBbsfFd5rxTbCJwDbCEfSW3u3 +eIUgZF+g+EpGbnLM3XEpM5l8XjOp09tDtEIC251wYPF2o5HcKPmiR6V24mq8S3jCCwtB+QJ7kYN5 +qFTokznimE2Bf8pEF8NJc81RZq8+28zWj2dzIyp1K6nCu7Twd5MN+KwO+Nh3vJvV42l+leyUQjvj +cP6Tu3ooNon93UJnMokSnYuDPXkgGB0yMqrl7OsxiahtP/ZWgjv1JF44+uIbeO/jBRVq34OT7PlL +7rSUfz8WCPKk2S7l24N7xDxN1qCc63MHtwpsblY9eMhV6lsHujH4AmAUnfNCuRfogK4u9yGHoYn3 +1O3IOFp9uxb4FZ2Vx5vNZDKyx5zpMLJ3NB2957vTLge5ZezxggpvHVWUWe11UjsDsJOvwpC8TiMH +xw/HUqcfT4CP0eBtoLpbnr22B9na23Eh0T0IlTCA92CFy9ZPRx+Zm/pRo1QULu98gf0IUXyS0TEu +RkdnVGmHS92BNZ8ni63e947UAdog/QZmzDuPwSpgjwfB7FV/vKtud9moAPYXZPirz9149uS+NvQF +VCxcev+aqfM75/nqd53UiIzdncJ7NviikQFXpdJreOMTTQPw3GEHbCm2qXsrrj5839NIGtXXu0CI +lkfFaL11ALB4eQs29t12JH3A0ehtthbNDPPd7mUbTm0DNqkXTk4qsdJ+kQ2jt3AuH7tD3Lx+mgnk ++sdEHK7Vo7I/eeGwu8tkbpoJ/qJyekU2X66z9M7GdpEKb7/kyXK+moG/0oDEyQOi00wdktFQ/lB+ +lvYFtN/glugZ/DMHmWIefYj+5GpV6hK+PUBfyx3k4bMcBpXdj5V4Nla4ol4fxkXYZB/wZNgcPijI +XeVgozMFDu4F9qcFkZEHn5a/2ENN4Ggu0JDQGMBcAJwsHgqcJp4wHBTETh0+20PAlF4QCD2K4JDN +OkV/ihiDEGtaZKJv9uBbNI1DBZW4MRwcxuLwY+9SRkEN4VPuZV81F2Xx0rZL63ohdMvgC+gWAn8D +kaXARtNAeNKi4wDNSvkTgZJ7Litj8AW0a5k2IznbJcFDRr/kWeFOlT8xjZkShguygI2r8qwUUtHT +LJ6LJbIO8EzRzpHQcaDMGTY+N0Oqbqf6AjIKD3TTlHGS0oI41I4mr3yL3uo6FddF2XcqitGsalqh +WtQYYiJrslX25BFeyMwDEymeSwnhEYF1i2rVGGzpBaEcrD7Eoww7bcYA0dTkremNDNGCYIztyx2g +MV5xAhk+R78w+uWZ8txN/B0w8C9alHvJ7DB79f5xAtTKk7FOYGTrNyfDUoYke75AOVB+BThhQ5xK +N5lfBvZLr7P6bmaPuNiIFG/uKpIoi22r1AmVVqC3ktTtACVDwwCrL0AER1SmGZkEBstJjgsC1S/8 +aGlN8XsP1VKW7m0fIztAO6EIMhB8AWF0TPDFWPSdKZwcfjPqXnKvnezVsHadrc2OBsVINRHSvu2X +MsnAWDIqrsKK8YU7OHqsf2fP87kLqMOI2tVAgxhggUItTDtTlbLB77Wur7L80/FV4Xiy+2YGIMtW +no+yJ7eXQE8WR3Yd6JWn552JqPpVuRwQ209x2XaI29sO9pYD1C4k2wEC4/nr585J4f1yWkt0Lx6B +2lz8zmN9m6Y2H+2NIUtTyBdQG0MKhcKpYQv7LnteKnzdvua7X1xi730Q+AD67S4JcJJ+4/mr9ggO +LqboR6IaW+s/K6AAJYvAfifLgtuV/QHpwkcsfIg7uKTTb0BROw/mPyP3+UQ3fZAS10qLJ40t0gNk +Hy8phjDgY+o1uKgg9INO6S3oPKhimheJUzUQK6NiJ43pXNkAF5U+sCwU/V+r/asGmux1TvJgQu1I +6e01nSyU7/l3YI4XKYIqM6d6sJcb4SedkYJprCh1+3ZZeL+OlAGfLhWocLuIdyCyVKEMSGLG9bK/ +07PaV3zp5Xl3q1Qczt+oQHIgiKu/H91OPAp8q3qcu7zIgLncD85EA39+H8hentVuSoVwW3qhEPto +h+B78+YFUT1pjhUbWe9zoB56YF3yn08bqUi6/PoqUdZzHKxg/CTXO40A1f7iXdmzKehpecn1qIMN +5YXsCCBS7UGfgELkDGL7QfF2AIvPpO9V94w1pTP11h3HLyOHN41vqYM6n9k7ud8E5uPnhhb2ebZW +bn+BdTmYUJnrjSRaA7QCB6E51YEk945eAD52+Dmdo0VOXgKmCnp5aQAQ9WnxdUw2M3vXwbjKSUax +/c299/nFV7Z+3bgHHaT6ROkpQ4PRVGIyd9Y7MHyBZL80ereiGFJuWZd2rxqYy91Lqz2K9vuXoLjs +TqHJdGqOu1c1ELh7PwAll8IX/b1SgX2gIun7510jRBdWvgpsVbV7c9XXT4RPsC5p7nheiF+1Y5nU +2VdPFlF1brM0zIuuQUB8sfH3qFtI3O1lJHwGO4nPzssbxOdUHFy5cCBy0NsDFop5Kjc4TwMpplE8 +zpjc+Zx+AKi+mhYju9y7SmIpdAdJidve+hYyqdvv7t57pfmRSd2V1KAwx8a2e7LpCyCJvR+95yoI +tkp2iy2JELDTZy2wfg97hc74vIrUCW6rymzBZ1ThpH66qXTP3/SrdSDoDreLr8TwufBeL7z7AsXo +6HSeZTPZx2Lroh/WqUuiZ/Ij0AMMNbnJTxNnN9l6NQO3YTJmHPx+KDOJJefZi6vEc6r7IryDFb/d +BeuiUm+wODpIAIqp7gIF5em69Lr3mdB3SqW/B2CRPzYy34etjvICrtU8KzTHH3GychMVn4ElBvpY +ffs7VgqNkmHdK7JZPaIUELJ8hUM+i+X6A+Id0EvvgUunzu8ze+MkaZya2A6uC2jJC5ejXctGqEmq +3W5+G5s8xApE8iFYyne4XrZeaJC5vrAlEFT0u5tJnV/20YKpOIyBitD5xEHr7hFsmsJp9qqe+TbS +xtY03z04nWZSpUCDO+Tuyvmz/M2hrB1yonzh97utx8JR6+oix9xSM8PCv2xtAOFBXJZCx4fVZOWp +NBOVYHER44DQTri9k+3se+Fj65nhU+N4HqhD3V0FFNL6ILD3zggS3eN+eDvwCql7v9hMPIy1mjce +mVDf2a6VXrd2amB+kafiy9eshXyQRnyWZ8VmbjfkC6ROI/Rjtl7f2dAQy+GRDLYqeqlEsqhiJiz9 ++WRBIJWtUj77DFTEzNEd4GOFaJ2VfYZ4tMletljP8smrjyTzlhuASeYIyyZQEDSgqRSODaN1WT0D +Vlj95rCX2U+Pb4Gs7A+JHRMQnVwvODvOMfeb15WDJyboaqaimqeBEoo/wV56R2fA/CiO1PuOy4yg +NDyGvk4wXZbeAibCQ1IBkSKFjbNS+P5ilj25J9uqTg9OztqF9iAZVZ9ZgJGFAJc/7w== + + + fSj8FzPh0dsnq9qp8ukFZriRs9FX4T153C80d7uBZPVtsl/K9oebyB2qoxew+vAoL3WWTzwVTk72 +E1hVoy5rsVKRfA+VUtmrTWlBb0OA89cT3EEpm85xgTFbOGr0Awb+078IA9w8X0FeGi+cHG3mAbfU +bqD96PzivpQhZq9gzYfN0sZulAQm7DX8JkmBnUO/gW14KKjA0ruhMDYu+Tr/Ip1dZQLa0zcRCXul +0NEgm/x8OtsqFS5Oa6XAmAHM5bbzkaFzD4yyF0U1CPxSFCx0hpfla1v5LPhvJbMfi4dNe4GNdsrQ +WfwEGhVp4x7b6mWZUO66GJo2nyEjIfXIIqbRB7QCYOPG7i17qVVzVPi9bgqCDB63ocl8kh19nu+q +LSe7nYrIXrL4bAlfdr4/olMAuFZUoVErP5UD5WcB0Etvrmo8q5aewepntpEqgs4ooZ7MZU4L8fPP +fRXVprnoqLQbjnJADWICwJTI9NFh414n2boRj+C442v1TNUuiEOqtBfdVAx4A42pxfa4/V4KnZST +6kVGtHr5tAVf9LO15vgdW4sUt/mRG2wKXypNKVMZf0u7UpEvqJdber/B712eX2Rr82vKKFDYSeFo +0J0CsZUbgBH2udLbaSBprQGcp/avAMZO29Ut8+WWdAohOUq0is1RJebQrr5z+1xsvB1t5gaRHZWA +lmhMpX0cnt2Ble6qzu11wFT7zjBTKFDeX8EiVna/gcp9dCZJZMQ+vybBu9LOfNzJMfMcsHSApa2y +yVGTQUgAHDRe7Oe+vi4yhaP25axwHAqV4DHoET43yvYbA6QaFWc7RxtSz8dzoI0bldeqmQYrqrGT +rTaku2j2cvcVSMjWgFSz4+P5jDh6LO/r9oM4F6CgtOqps5fmvPT2Qg0gjdHyYfqDmpQOOjkV+4f7 +HOMhQPQegXC4CxXed8Zb3OxkdlB67ccTml66L9EPsBrTXT71EqnB86CIfl3o8JAGCgHTyDLB4ChJ +3p4kskJ5OoNhA0ChO2rcZabhu83CyfHzd6Gz/7KpLBjS+d8YIKLfx4B9PCW4VPN8x+3X8NskMK4q +ldLr7DlWygQ7de1hHIc2CuYwkmFwAURzJvYpgP6i5fKDUH8qNuvZ28IHu9PVcS+ZcUk8S5bSmE+J +S1JEa+ELoCPI/Ofj/ncpe5EZp06n85HWNchx32TyqtDKN3qF3W6ixe/TxU7x4f2oKLsnUZMa2PG1 +EpRNjawQi29CX0gZsS2EsYsHvv5WSZQK8yw6lrwEGkcwVigNs6dAftbDud7efkxUUHQQPwCDq83r +bSVwA3NDEejlZo4NlxKAj7VThQ8VtxTf17dELIu4u85ejapvXPo73FObzBDHueB+tRh9zgF7n6MG +inMWIQvI3qcuwFj6e/e40LzrXIHdlq6U71/Hb4hHytvHAvPy4oh+wgPAwGOlLW5yWTkEqs8hYNEn +3zk0JMk7Sl2GZpCe9rnri3YC7NTraClAhoDdfHkVLRxvvBPqGeDGY5K7+X7PIpFQClT5lA623BjQ +WGnn4WNYeB89R5DryNR/LbL6nAC9w/XyPD5+yZ48hAVl9WEIQLDYmm++COcVup6ko8d7pdfoTUo3 +FxlOvTjSiW0tnLf8x2cpCE+9Bc2QZQBjrpwdfU8TMLrjvPDcvd9Sn1YrDCB13Lg5VeavMaMvgf57 +WgqWA6XKQDaLgIF0ux0vHEe2WHXP/dl2sdWMtmEUwS11KD4dbO7AhX+F+tq+xtP9zGf2XmLzbD3P +vwKrsw0s7ESskR1lOyVlcBgKHcruZfaer3P88KhOFp4/nilg79f6mYQEDPCLizbYf919MGGNKlos +7ZSrYyUcKb6xk7zhuOPuB1eP3T9QxY1YLvE5bDe2kx+3EzDWCrymK0fmuxuPQbBfIrut7wKxHRsi +8c5u5HdJYBMMNoG6f90sQ89pgKT/z7QcLacNhSuga8W1OW9JfdbjuDHs6JICxfustNdhqq/IutNf +xQKeFeoFXUYkvJnr410K5jNED+7JVXe1lVhh0B+u0Arz7aR3PhTDqH5iGtcXSbNvPDCPmwkiETmN +AE49o+Evitm/TNHyi0v5F3qxRx/WZzlgWZR7la2rgwagl/u0/JaKHFxxnxthunKwEUsEgQ4DuE9v +fyN89pDciH52wau39/hGZJ6qbURP7wobMeKUIhIH9yHUPVi18CUzpaanYHCFHljJtzSdE2gBMNnB +A4q1QQdKylui8toBlsVkkj5oZqPjs+PMSXKaFir7t/HS6IG5KU6eHojCQ+m+XjrIHrTI3Sw/FHuh +ty8j+djuFeivyllNF08oTleT21Dr0zeqTieTvWkddBI9IhJMDU9DGdlUKM1uqJdRb4do75Co53MF +7OSZmO4D2MI8ki5v7KCJo3Up9OKJqVBmhO+9L/BnuQ++vi9oO32aPJ8+XZp3WuZf2NTRS9y005ft +MyD3dd0qnXLdk3LAvNP9jdBkSgYm5p1ekE/MJpXaVTr1BZRup8HoacyiU/Yz1AjeF807ZcJPkX3q +w3ymm6UXxhfYuh73q2ZzJUq5k4xFp9zW9nASPrDo9P6FKL2f1ZROURys3G15Y3+HPH6tm3ZarlB1 +S/RSD+n6G+oU0GKzqF3TW0DJT/N0FXYbNq5q6J5+7JNh0CkzMpBSlciJnV4Eg7pOWXbwOlY6VSgZ +d/s6ef4c1i06zTQ4vrRNmnb6cvh2ZdVpBWh9dGjvyXyu+xvP063PzpV5p5f5cPp7e1A16zSy10+l +lU7BumhJaffwIXNu3ilzf0+UksSZaaebpQ9++2pAnZt16gsQpefnksVcua1Ab3iat+q0QZSjbzfm +nZaJbLAT4u9Rp76AHsGzreih2Ol9LKRD8OEZcyCit/jUK2k6fdgnqnyMhJ3u6jr1Baablc6Iu2rE +KNAtP9bTb/XxoWHRKbfF99qlF6tOC8Tp7nMSdYpsZO1cj75Tma/J2ZVpp7W9IG3Z6UmnRhNmnULO +zzzGiNpreNNsrtPNk0rn7PEhHDLt9CY4/LDstPZ5+dZEnfoCxrk+lombk/G+eadVOnBdyuwfmHc6 +Pt406xTwZNjtzWt5c2aB4Mdz4vbwpGDe6Wm6+Ppy+fxs2unzee8IdQrli3GuX/dsu2TR6ZNAPE/7 +MfNOz77Gg/OkQOs6Bb2gbl+PYkNLBE8CtciGRaf310SxOzg27VQ4i21uZJ5jgI+BblPf+k0zf+Vf +xU6bdFi3acIP1cYu6pQKpkMV7UyrxNtuKgs7jSqdgl5gtwDs17fE9A8m+k6no50DsdPZYUQ3042n +xmMYd5q7J4+0jDA6mV6nN0AvoNu4kSsdxdBcQaf5mYEVVjY53OkheRLTMcLomDnDkobeTuVPUKew +F7Hb7cmk0RzCTgldp5NJtjOS6Pd4Q9fplP1KiZLmMHUZ16F3c9R5q/tE/aHTeOW0g6pc77yMUpZv +7y/JwY3V20+i8haYK28NnB+w3sKOxddgDXYieWlcXx1e95YTyNe6+HbaEwy7kht+bt6ZvcdM8eIo +9WT5VqB2r96s3342XoIyxozvs9TOQ8vybTUyPKSs3zbP3/eUtzqMcVvnm61mxeJrobJT2b+e4rfv +we+k7tvrSFdSTt/JzZQBY9fN49rQ7D3mcoVIb2L59jbQTGxYv30qpA4kjJm8fwu88NuWb79mF+OK +5dveDZW7VN4aMDboldIvVl+DIV3usZZvjykmfWeNsUBr2KxVrb7e2dg5etq1fFvMnjY7lm+PqcNN +0hpj2Q1qO5yyeMtWiOLBrjTnVGhP9zZSv5weim/z8X39rqzU38q7WeU9M2WiV1oLLE+0g495kf+8 +Bfrw7Vg0R0uvLGY9udH0DP/S8DFqtg0tzPxG7Dh5DyzMrzr8Jw6flTaihas8/OcW2W+y9YZ5hNhf +4yoncb7JJhU8uIiJ/BzYORp9LL1FB8GHxwO0N6Clo9oRiVNhGAR27N0csNbNHdDf+77c31aie9AM +A+60WZzM3+IxDbudbPoCSrfI0rHolNuCds6jeafM/YNlp0CIfJE6fUw9V2TpWHYKRV7LqtO2ulOm +BmxkVbfCWa6m6rS9s7OldIq0f7lTWodeqP3LMy33NZ2G75H1qu5Wg+ADyrJTpP1bdArsQaD9vyid +grlo5vps2SlA8JSx7hRq/5ad+gJQ//80n+v+Rtyu02rQslOkUyidwr2v6RbqFHXNqnaSUvfol7gQ +4fxDe+Cm3ct8MFTvfYuW3Nb3S/Hu3LEd+ynSncgtcmDOT1mRWxq27ltoALFzpXLQpEvzichcdmoZ +3Y5PdLdSUeWf9DjUrovGOuRJ2N5Pj8P7YxliCIFIJyvbX2gU6WT5sQAYV6MIe6YV1iR2ny4GxH+i +pyOxA6QCSx3IuiUYD5jcwRg30nmfANvLJT47hYD8z5VaYxZ9Zudy4wLspaye7tvxoehTAkO+vgAP +dqBCO9+VsIP1dpEdq2ZwsaNFoOxxAwMmjtlAAP0DCfJWayWZDaqXPNINSj2k13kQkO5plAoeEio/ +ms4diFAOuOXzPHfihHT4jzh4bMybzC+4YTk/X0CZIfrHcgWl9attOq/fljy/XZHGzGYIlddrG2S5 +X78Rok9sWbhElg0wcjf3VbIE5XND7hKy9mKeKEuhK41ExpRVfvr2jnlTvAPl5kGk5KUxT+Ueksf2 +ePdZI0vLesJG1vNS1LIe2pL1+JxIt/h0NFEjUB6yBoE7mPWY4+4F5otJCLYYT7QYxf+IuCOH5ri7 +j21Ysm2rXYn8caZTu9/0PjW1FEOTow9v6qdOqC6f7IinCaYDKUR0s1JLMdWsOhfxHXH1DWy0CHq5 +GXmakBmHAbQDzLk7FW7lbaim87fwDhjcXcFimaJjsrEdrKAxYD//goghrKX05yhyIFGOipKRU8cc +GOkWmBkohHfVKc+ucd81Sm73nf2uA7KysXk3t13LLTJ6TUbhP48R1SGFgSwAZwwVT8yWE2BMvaDw +H7CgiiPaSBtgfjIXNNLG+aU8JNW40FxmZdORpcvNqdUkM0Rndp0waGHGJVEsvtOIcUnaZSctzC3r +6QlTX8BSMLnQGZXGQJt5nFmKJV/Ay/qWIU4q3rUns73fLmv5tAmyTkeK4LUZ0uzw2FJWnl+J43Gj +0oEhWSt00tL5Au5WEFj5toqFk86vWcFhwFax8LB+5YuBAgpT8hLAakMX4wK70hUwrUDxOi7phFcE +dm9vxHiZpFqrWxpjr5MVYkzL0TyOa6z1w7zxE4PhOktPF9SONecvYDwVM2PQSqE1FdBU7u5zw4GP +qRRs8105O9xc2a7M3X1vezOU8XmsYSUr8MikquAGWuLesXO/uePW+JB1Sz120lNZLDu6EcwVw4qO +KZjuF+dlSk/tTTzdQERKNg7FgQu4GohOt1wMJw7bXjUQbCNHLETURwW6rh892OT4UFIbZCTH9lDP +02Zc5dAGv44gzRc9dGDh1ACa4IaNDmPKPiw2yJG92uELeBnU1oIMQMst4ZZ7ngXsxQ== + + + slsGcKQwALf2vvX8gi5Q7nOHdI2u4OzP0Gvyiq/v6wge6t2ugqgKM7L4PC0rnEETC2dq+FjY5ID2 +P2m39CmeWNkhy/0WtzR7kJUEkOVxi2uQJW9x9AW9newltBv8GM5Fu8VNrW5n7xKg2k13HhI7X8Kx +3iWrH42dS1bnIRkcazV4C6PY2SULpqbaSOLqe3aTHMO4hFO37g3ZStIP5XiuFcsLuDcAHXxTaEIo +UsWwWu7XSidTLfw+voCdl25wDA9375fy+0C0OPv6dKzAwl8DscO5omQV39R4GsYaVToz16vSgA6s +nYkiT3ahTEMsn+hVaS+4w/oYGk/Afjxu/Qv04TUf1FGEyhbzJAhPdJrwYvsldRm2n5oznZ8owk+W +Lwt4o8cnerlnNSFfwIbSAe1ohd4iDODwOsD6HNbcHWJeHZz0Pp2os9JlAXZ0gs5JDql1WTwXlaiD +h1VBdfwGnBV45oYYLHedipLzYDxxbz5v45zvambSTnsq6voIEgCz8reaeVuxZWHlb4XAPGw+c3sJ +bBpfYOlDCrRq9iLP5xqO1pD0NhrxTBzDWXYHYiiyNalAkXiyFzje5Z5s75sA05wQehOi2vPBINIu +oiGtxplHYaorOWHIo+BTX8B5G7oQNxAYFfd8xmehRMBYzl1XqFSpn6lvjRTTc7RpL2zgaNOe/gDP +BUcz9ZDkAWIy38tytGuFo0nWqxcNXg/MmaP5XJ4gQWCLczR5V5ZvRivgaGDVzDia570P4HjnaAbf +BYazPEeDUJY/e0VwbE6DormQfIqT8AXMtAGNELoZ2VnQ6qNDcx2FiV5p4y2BzWPwjcNnyx7ASvLl +PfhtzYZcamZ5sM/PZ2abGXvgvbFZAOxmwxOT9QUs2eyC0Q/azXyDbGmNJb6IggJWTRfUZMVhnOG4 +U+0toSA/DICzfAgEgmJhUOtO3p3haA/dXbqXTU4TELBV+KqxLATzi0DtQisNwdPYMvq9ikgbm1fT +pS2+u1u33iyV78JSGt560u/tfbAQ2PL6/dO3mSz0KsXgqnl3aRmlGISzjH6vgiLLwsWlGIJjot+b +QZGtVws4bqWhvSxEHObpe2lpqJGFr/pzYtQLeLqScCTIf0zjsERZqQmeUsIwLHWB14nNkqhRGXVx ++nZ3t4yvWufnB8CW3d2qcZnsbftYaxuMuVJ3pZWEvVhZRGAt4672uc3paR7g8yZh47lyEU6nG5Il +RaDYHsftpRdM+XjMIJby8YQru9KFYKJyd23L8DzryDULex+MjHKHShebqzldXbQtAGZ5diN7e9wG +1ANg9PbeSXUVHhKAMd6bimERgwhX8jXuygeLgVls9nvb4FtMET7Jf+9qUC4pwrC5RImMt64iz9Ls +6dDUshDXAGXLTT82YsPL143ozUtxI5alX2DeXNEsgw7f3LJ8Dp1aihkz6HQZQwvn0Nln0CGevIIc +OstOUQadZbagxxw6+ww6dbbgMjl09hl0Gq1viRw6+ww6TbbgEjl09hl0NtmCnnLo7DPoULbgCnLo +7NuJudVL59AZNq4mg062LJbMobPPoEP6mHMOnSYg2SbD7CJYMtO2rWPgrTOBdMEuLoZk6uktOAdu +77rLlyrpbOSFg2ELeu3XxDng1tP7WNBKe29LpzrjK+gDNhbG096uhly1uaKyjA+5SQbrfHVunJwo +2jM+O2D2cVju5od8fU6Zc67np/NcGfeLe6QnvA/JIvPRwXNlNySzlDk4F09Jc654TVEXCqLE9nhL +oJp5CgXB8WOmwSDe3cZWTmN0M9jS/qr72Jb91Hwuk920kZBeHYOIksGaL+sxxsluVsc2WivJKdnN +2j61P3BQccuibTCIxjR1MkOKumwGTaawO2DaECzSeGLTpL6dMh/d8axGyZPRi3alldnbpK1DKD2l +mKLct1OXWYfOtj1AltlZtqyPGV1nTo7DnjDWuUnAt9emQbMLnFiVLdUuyywwlaakzwNzVLtc5/HN +nWLgPeTxNZ3yX7Y0Tivr1DTrJBh7VdoYAx88+NyyGlTGLEXTev0cY+BdRxG0y1oPpun6uc3jEyZO +OTF2xKCNTofAVpYhOlFOPqwyU7wAc6Z49xjTOliXxJhjmqj7SSocbSGMaR2/VO7uPqYNdKroAutN +Mrnc6bIGn6/RzJK3+pW539I+X04HwgJAb1MrkU1AvFEvJPznzXZ3V1wYe7LF52DsfVRcG3tWAPQx +iguAcLoaBayzfKuGu1S5hVbolXCWL5JKY74tYIqbs5PBZ+uShllpFkacgeztcuR8DmnOLo480YTs +rzzxGcwrGz0yNTWE8ocKMxcoV52MWFHy15E3946JqYQ1JYcEOQPXsc6ImplK8wX0sSO3O17Z75b6 +2NeRN/eOdZqdPoJoYTx9OngafDpTwpoEPHpkNEPS5CODQVFe3B82Q9JuZmcpZoMnxu2Q7KPTnZPi +7Iakv7sjrvP/4pSkVXhkjpFHZskoNaAJb7vwyIhnfA7pOdup+M4yHhmVvX+8vEcGAAjZRHd4SENb +xCNjyBZc3iMD09B0HhmrjFSn/DzGk0fG1M9/7CI9x11yDkzRAxvOmZLdhe/BUh2EVlk+UZRl67hx +N8oyfXgd2XJBDPY5ieOT1UQywHVJXQZX49QBU0uFHGJ63aShLRjArpYvMIHM2rvkIX3MELpgmi3o +lFfnOWjWGKGK8upcxuvZ5tWpUkdtMoWdnaAntpdUqXavSre0DdW7MN5FCp+5FHRSzrtVYNJq8uFg +L6uIqbPPh/N+/9gi+XBmUdAXg1Xnwy2RZ+EhH84uQnV1+XDQa73kDnSRD2dyI6hlEtfi+XCaaCjp +m+Cq8+H0947ijLhV58M53hKwknw4zYmVi1DLxfLh9LaY1bEOzGRbPrMeCriVxUQCUNqYSCvd0k1M +5M3IVUyk096f9uhl1YA8CpBYPhsdwYk6rb5LOG7ySCyhYH0MwVlBJpchksEmBt6Zo8HkOmuHmDHe +WVXLxiLiOfi9a4h4Dn47LIRuE1p6e+5ultmGSvKRyquw7DYEwGyvlTHjY5bb8H7sdhvaaOMQ397s +RVNCW81twAiOt+1jkY8M4KwkEbKQcCfFHOFYXwlscZuWVZi18Upgx9vQtF5p3W2N4ajRhwWTz+wv +dnI0qOWMVHJz0QAR1ZytLhZeKCO1sfnqIonUZUZqY7PpxmXgkOq3kozUp+/VZKRCOKvISIX5Ystn +pEIoq8hIhXDcXQOtM4nN4vrQBrG+NNVzkFE4Jq6+dhveLb0Ndalw5nxs1alwKJ7fNqJnFalwpuuy +8lS4xf2WWozZ2+4e7MolUuHUdxChZLhfkgpn4lX4Balw5v4xl/bZvZ1iqGYF6vuT7RKfPi1jVd3c +CK/Vx/JxB7PIbaAXBMW68ii6cCBDYNY323nUYQyXDHs9XFBlo9+7PMKxu50XsHIzkaf04pzcrM+r +e7K8DkcvHCTvqIl4UPYvrBoXNetPXANU4jJ9/lnu3zReC1vtebGU3M68lOrpi2ImMQsCzl+qH/L3 +qGx44aE4yWQrXP04n4u38vlc4gQWIaiNJXEU6GuHLHqctLlYZlln0EoSc5QerfPOhMvUhZq8tMlu +e63zU7XzWdUp+7kb2N8YWWXYMfd3dslu7YRlp0SpnrPLsAucd08bVp2+2XRajiVVnepzsVKRqcoL +p092Y+4+q3JlQl0K2GbILtmNjOs61dbj2xtYZdhxW1vf3PzJKtnt0S7rbGCfYTeq1y073al2PttW +nXbs6/Fd3ll3Wjx7LFuid3tI771adXqpzbBDqwo2rDhr9Euk85TLdntm7bBXQdOSeaq6gsiEL3A7 +UXRWORNF9EyyktKleV8vUO18xy5CbrUabGSI56I5I7rYGa0mtcc5QlXvNbGuY/XtYkiqczGbQTkF +pzrFeWDrdZWV5MzKjpjcqeLCu2RXSc6TF+6x4DpE0iEbEt0J6SGuz6mInG1cn3t6cigiZzk/s7pv +TsVG3M7PudaAa6Q71RnR3aW2RP049/ul3LEuRGQZ7uq2AJ29p3eRbLrF/DBes+nM7ACpFufqsulc +3g+zZDadmU9Qv1+Wz6Yzy6VbNPPROpvOzBdvHmm/TDadBi3injW9f2ypbDozUA43hCyQTbegRPaY +TWd2TiPLypVl05nl0qnt/dVk05nl0rmM7fGQTWfma5cqsK8um85sdZGnd6XZdGbKjTp2dDXZdGa5 +dBa3zS+RTWcc0ueWtaa0aDadmXLqC6w6m85s/UyioZbMptODcqwpvFA2nZVuudpsOvcYWyabTgdK +fya+omy6hTDmOZvONsdqZdl05rnVq86mMwMAellxNp3ZaYkuBn4F2XRm7EFrva4im87hZGRF2XTO +8mUV2XRmyFC08VVl0zllcq0mm84sl86yHt/yBmBMMQA19cU8Xd1kXcXLWKRSX5vDZeLTt8Nm1yCf +GVnVslm8Xp1hSDN4yrPqenXW2oU7PM0iQU94UrCkiYSEOZmOioVLEtAkKFhkPVsNSjckt6zARXU5 +7cHUQkOCGAOD8lR22W5I5oEUlhzGBk82ZZctWCaUYlqL6JA8nuosIno7OXYobG7vmZOrZdkVulu6 +zJ3qniuXKvkiZe4sq8uduMpVclnmziqTy10inasACfv4ZKXQ3XJrVb4fu6kyY+ulclXmztGjCBGz +dJk7UYexL3S3dJk7nPvmUOjO3eHR+GQF91zRh9ek/SK6z7M4WVmI0vhEUbkXzuUBUzsIu6VPy1Me +WKDOMfbQiT5hGh00nm098K4S6dxENPucMwytgzhc5xeCXmzCDj0EkUHsWLr+tJTsrsIW6HkrqM8n +gpemWs7Z7G4oq/Oe8sVgwcQuTTQUICqHeHDX0VAAlGP8mOtoKADMXUS3fWAz4n0ryXxc/igEVhS0 +uQ5cXH2XcFzVdjWDoorsqq1iByIohkx200xh51x2BMxVYq1VDQh9Ym1taEysrQ1XdysgBLaSQsaI +xsBo3TAzteyyRGXdDJWO9V7tYqh3jUe6MBPPGEFta4lbxVB3pr2VZKbINx971ySMoKrzVVUwBC8u +rI+IXe/9a0+Fqq1O32DhtaXVCQzFLqrTA5wV3BKA4SxbrRpDkTah2Q2H3mJVr10kMng64Q1HTLbh +jYtEBlce+KUr3En5lVY17hbYhibBFYvWrfZW4c4u83GJbSgRmljhbiWV8hzzidxVyls2n0iulLf8 +NrSpcKfNS3KTH7JIhTu7eq+wxp33CndubzWH2U/LJ9Y+fStqjpX16jqxFgBzVnN8bhQdXJtuscRa +feYju6z/COYXnpqmQ3u75wrBWYBvGu6IgHBWks95SrizxRzhWOfC6pKYfE7XTKByeV7y282SmNSn +opBBRA3bMBVyWAgXfi2p7pvLNCY3SUzBgxe9JaqSYm7SmLSTdPCdKqDkdbFMY0qFXGWo25rt8q5M +hdzsSjdJTMGDoV75XtSuvPOUxGQVQQRrJ9pIWm+K4Z2Yw7vErfw6xdDkssS7e1wDYg== + + + FTmu+bj1rWLQfvFakc5TuUeESmt97H51V1Pdo9O3FeW43lteTeVdh2lOPZV7dKiUl1gwx1W1P+Uw +DBdZz845rmBIrrOe7XJcRQ8QXIgqb96fpPrBjLfKQb3QI/O5xPFtYatzXPMFCoeRWv1g9BbhwK/y +BcruK909ldpUML1ZwIIHuXZVvmPxlyYJ7+zwSt2pJh/OF5hu3dxfqF1V2jpsqfzjvUU+XNg6CW8y +f0uRWp6sS8Mjdq1y/7itbf4q/GyVhPdk2SmYy2ZpTFvOlShvPVxbdho8asY/rOqwhZVO5UwuBcEX +LKXqVJuaNg3yO0odQVqX5RgOHT72zTr1BSCC9TXnNGl4DX3unxq9J/sXFp1yWwHmrPCm+GD1GXGv +Np2WtznrTsuXWw9mnaK6b0JFk1qp7/TKro7gyY11p8XidUkT2QW63Ybvo/IvMQlzvnuQ0K6+RTs6 +T1i2U+dXEm+7qawLiJHUaFZUxCSY8z2jVzrlwxrR26MVnnkbP7Es6FyGTQKksmF0GqSpYuYcOOlC +NgPYB/rEJkcPiXVKkjG0ynJIkJKtB5V3k9rknNg0XVVlFuTQdajM4taTVLAPrbJcOkNlFtBBzUsI +ml3Wne7mySWy0hwiNDGWfO7oSXfo5XV+stca5t15rrJoMSRDlJZ+v7hGuqcoLV/AblDWfmJvQwLc +0jpOSxyPITZWx66KT+ld7eF10VgzZTFTAsA+cnH1tYMP9qW4qssb72Mb7m44dJGNZOtednvK81Jc +5iZaJSfRcGXcQslu5kfWnu61fiku6FnW3qIJswCXvYTW7K44y3wxJ6vFeFecjQFk7h/TBo2YHLE2 +Sp7qHVhzmNLKbORGSc9hFj31xgl3VvsYnVg5l6/TjEzv53d22aF6fJZeFebbEEDQEybe9RGL2k/B +gzvrw0FviWSGehZLlGWzz2TylGOV9HTPgWpIuvyXdtnOd+yojWuGpArVF0+rVbvWYypgb9tFKqf6 +niubVECnksYO66ecvLfLzok6rolBV9fYtMqMB2BOVXSC+uxaG2A6qbIcxhxzedxPUntyuSTGHOvp +eMJYlXmyAGZIFzbTDkWMLZgF6DYH0PU9JFYJYq5yAG2i011kAbrNATT6k71kAbrNAVTfcOg9C9Bt +DiDyWi+cBaghFRsLUx8H6y0L0G0OIMTY4lmACj7t+YY2x8prFqDbHEDZRl4oC9BiSIYcQPV5JR6P +cVbLF+VzX5FtmaJ8qrn8wqJ8Bq/CLynK51SRbTVF+XDOiL2CsnxRPl/ARCtceVE+Y33kX1GUz7o+ +8iqL8rmqX7lMUT61VwEOirMclIgip9Rg66p+y98NdbyKu6Fc1vVzdTfU0nX9VFNbwd1QVnX9vMUp +LVrXz76q30J3Q5nU9bP3Cplb4t7r+pkTn+3dUAvU9XOm5FXU9bOPDJE9V0vW9XPK5FqRQ9e2qp8v +4Mmha1nXz35qOt/FwnX9NAMxVPVboAKIaV0/+wmZRaguUtfPNB3R7lZz94hxnSlrehf0AnX97G/+ +ks/El6zrZyvo8kiKraCun71b2NMNVDZ1/exNXdMo6AXq+pmlSSpbb7l6fCvIefdU188eCvTzr6Ku +n/2Bis81nGUS3/UZqYvW9TNRNVVV/dTVGYgl6vrptiGhreqnubPLc3oKIdf1c8x7XUldP/uqfjIl +L1nXzz7gWpWRulRdPyV/y4wWdfdcLVzXzx6BSINdQV0/m7027dErqse3aw/FdT0+h3JyruvxLVXX +T4Ziun28ZnMY6vrZ5D04Rtt2vNb1s9fk4Y0Hq6jrZyXDb4wniYvlb7lQ56WTRKdt6FTXz/68WRtF +sHhdPy229dbiovX4vAVpWNfjW8H2kav6LV+Pz00Sk9PtDcZYDW+l+PQZqcvV9dM4tg1V/XDG0PJ1 +/eRUKbu6okvX9bNXcyxozHNdP/uqfkvf2iTW9VvS1+eyrp+LvNcV1PWzr+rnuR7fQlm4Om5prOu3 +eDK8qqqfqpel6voZXcnqqn5Wt5x5retnH96lk2IL1/WzD3TS+ZQWrutnsi6qqn7298K5r+u3uN9S +izHvOU8WduUSdf0UxmVW1W/h6EFdXT9bilBVAFmurp+9Yoit1+Xr+tknxIoSeem6ftpJ6qv6GfQx +1zdZaev6WStBWIdxuMnKZV0/VzrM0nX91CtpPMCxya612J/mdf3shYNtFufKEmKx3E+YiIcHOx3t +/No84kN/r9QnvlFRJyvBU2vXrn3gvS5tUUNNEo0ppzfpg7E6Dx77psSuQhoJGR8piCES5x1OxueZ +xhKtTmHuGzX93ABi5Xgj8ni2TSTuejxuBPOpNrZP00dxIjTcSLQexww9+TwupfvPycvr3VBsEA7m +vnNE5eMsu/U9z3EbT402DX69ZQKssFfZOT3/vmK/e/ePvgDPxpmWcFq6i5/EJxtstcy85a5614ft +2il3+1nvnLHfN6HO+/ZtNswUvjbrVye9VH//btQ5DA2/X/nvwCQz5M42bs8Og9t0qMwF3h+PjsLz +z61HZvTUSYl7H+V2pq/rtZuNeOQls0F9fN9E9ulghijlTnJE6b11TJS5navJ5C0ZmkyF26Pp1gvX +nLLNxws507IeOUjEbuN0Nbkppb19JSbTpxEsNpfcwrnVRh6iyS/de6i+JrOtyzE0qOUSkLCe5PyN +DOxmM9VjM2QhZIDpznbgutDbG5ZzRRmNoUawc7F181BPbw8nidIOxXzMt/rtjTbMJD2WkkM35tEx +cwbj1U6HKCdxI1uq1wPEdqeN7P2LkVZlH+u2D5jaRV6VNKf4W1VTA2zNDA9pLpCf+wKFh1LnDhXQ +zD+Xr+64s3x7M5OY7R9nEtP2Xim51bso3mboF4C2Ybrcv7l7yla4jSaAc/MtgcXlM0NkpMfDVMb7 +l8xedWOCZpUdjCAlZ09ub18jxZu7CvwFJnzRj8Ok3Sg269Ps/QRZTkRiFoLRCK8zzIkTbDwo/SJD +yHcMMMIPwZ/8Lsr6BQznaAz+PIgiDrMVBFLscQIe5OPSh6VEqUidCgBshYgUooF5KVQ5OiKjwc9B +sdX7ThKJNB9GA4WDeyZ38+RevttIkODFQUT1orGdP/AFpFf5mPKKyj1cH0ovjhLKC3p77yMrvTgn +5RcvItrKB7vKM6VnKPfL+ajqFexbhFMGux5gYhfM9CkC5xymnqdfgAGWr0h0Ew5ZObyiwXQvd1XT +bX5EIGYvAcoPRj2ytc2n5HMxwAoheeXIVuyAhI0SMG9pQLYOjyDaLknxm8trBBYmte5vwZ4jMLcY +iaVtKhxjoPZfjymdUuHDzB7uZQ8eeF/l+vGP3exF671aODnaqCkkKR8L5LWGa0BrcOaocKW0bwYP +UPKiEC+rBzLEHDu72O6Unx+Ej2xtvt0tPrQvCDgrElEvpuQ36nn+khFX4/6FlsirzqimXjjkW9I+ +uI0hBFKFyzyUgLcJiexvAezmM6zNdkuK6i57K2oXI/ibln8xGERxb8CBPx9EiK+tElySh4T09QMh +/yJVo3mjXrrSaB5o9MIXEF8VetviPuh9sXguWkmrPTPd0bAZmQtYsBkgKyGj0bGZ1PP5KFS8zZ0e +58L9Cczp5yq5IhGvG9mMvkpvEFEb4AICutE1LJ+LAW4p7vi7XgSTZO7uZQpmtRlPdDcvdujt5GBG +EKH4VJwuYC4obhq5J8GfTBhlBZPFpwz8MwU20vZXGvKNqGr1n8A3N5AmKnGkBsFIlTgy3MnySxwa +5pWEhQumQsgEuaNyp6TZkxAMFf0mo8TwzReQFupkF++7aD7QlJ+J+xfocHA7n4CF528q+bdetq1h +QlWCYJsncCFOVHRAlnPfUOP4OEcYOwMd3I8QJ4ZTf8qKaglgPfgZZq6Q4WBJYyuHFOesaaS9tIwh +7Rl8dQrVnAwQ4MIc6zU77KikUu7Qs818dhN8djWDjW80dx9ImlJYDSLaLepARPLbh0VZQFeoUPKe +VlQ29GxzM31YJtqBYWEyORjtqlUIoB+gexVKAQUE0dlkEzoQd3cXWRlEN6TZKuU+RGoIr1/xaS9G +7+w9kgDHhSikHMmuRE8hjcXx0+fpK9ziT1OJzbzONJjfCopljqmPS1lTelaUJFRgGqqam/DFPcKd +Sk8OKkrLbuZ2tyHpJgeUpJbg+xmA+Ntkyvpiy7AQrrQu8w3Y6QZeAWb6uAOlWOl1Q7ojI7kljqd/ +faZW3u+jQxFjuTB0euBLISrP8c2va4CnSAl0Go+hDW68LQJ64cDIyhERCYVpTUbCkxoJ88dzGQm6 +GzsiKhQ8Tuim6u4OGQW+QDj/0H6RkADGo0YCP7FEgoSC3W0VCg7z3yMVCg5DhQlCAaBksVup/jda +EmckACbUS+BOaf68J6KAmpNmdIBv1bjXIiGhEPbdxihRxEiY5O4fFSSEmttXTxZ0IF5HK1ctB3zM +jJRsQUS806I2clg6B1BG4XkMMTMAaF1cg4gvuKWU+OQwseRqRK1pGnF+aRQ2NB2NWoBwhQfE+aNx +F9OgM5ehkAiicXiuHQNpPwZsV9rypyglgeC2lNWYbpZP8pp2iV2lHSyVfmFR5x0sTmhZGgsvT2OJ +BcegojFyWRoLL09ju5YgXADANBZzQaYaEPppOKBSpDFbTBBLUkQi4gu4wIQtCDeczxewBWGFSler +AQHE1d6ehYgq4Zqwkdw3BUEsOw3VzvAFFpsG5WkMaO/rR0E7788Kc3Caj+AxTNKs5tKvN0ovAxSJ +7BYTVNT7GHTcklqWqKi4GUV44paUG+XGTA4p3JJadotTpPZPSsfHKFo0FkLtOjBIM1PskUFWmaLp +p8u3IWxFKDZd8SW1L5p9552haNve9WLUa6UdJRKN7xiyhuEdEdPPGPw6jmwQ+vB6E9l+Qek4cSuI +gn6QKYy9a7IpjH1rwYOrb/BnJob/fJ52kKEYpLf3999Kr+FHVP/lJfMhm6sh2ev3TLRDoZRkn6Z2 +VY411QzSmajKrRY8rKalF6W48gLddyG7YICxq/K4Hd6Mc5KnLIWmEVb3XM5EVG41Vc/lkuLQe0E1 +oZEXrpoQvQrlcwK6ByI4MwUYzxS25JovgYY03csIdpw1xyQk+8uYrF5vU8F0CCY1XsZF3xqXh5Rz +SeDqchOyVTlHD0SwrYdHUvSJ3pciidNaD/KDOjb/qTCXakud1uO4FyK8LRBUvxYoRpPhl8wecbOt +GN6IxiTTG3ufDHFasvVeT7iA+P/3du17aexa+AnmHYZaleuQydwSb1VBhBaVirSCVgSZqpWCcjl7 +95/97GetJMwMI1q39pz6KyaZzCJZtyTfWjMuoqc9SZFEKJr5pfFGprE+crca9uGO962XVFBcq55Q ++ts8o4E0LkP1oqlp7y5ESL5mo4hbeRNdxVdDgW2tiilhoOLVkaNK/QZVpenZhQgD0r1Up61K9NpB +Ao4gADrWbm0jxZaB70UZ0na/SuTd7emxon2ZOr0JgDUaRdzWez+CC3ZgBd1gLi0RWg== + + + ipzEVyRGILVts5mUQNfe+Y6w+PQM16vfqy5g2BmFnNvJEDkPwO5VgSlh1rHcXZRTQvMwnQVXhnIm +AH/AsLcT3wSDMT6aFa/vAwvbqORvTyeGhKpus2sZ4Z2s9+t7Hxc9taMtg/EdfpJaG3zgpYY6I8eA +doHkxzB2gThtFYSHSYKH6d7t9t8NSmb2wvMFP8VcPpEQ94pZPCrngeAtODMmxWTuN5JM4F5ouApC +27+2kWOHhgrfgab+s6Ux03N0Romn54+nfX90NLq9vh3oWW1dy+9UTLMx6A1LI98/8f+eFIdX05/+ +YKKv6fmdeqFSYU7Rvxr2fF3koDiXXgRjkNCaSq+JRiLn8m4kCl38zvfvykvHm53id9LcimTliCP+ +6v3JQyJ78wN2J4nMlbGcyLZ7Z4ksLdUTyfI4i9WmhCGCmT2Oh12CkrjppaI/2p3uZQ6qX2MAulgt ++eXJ/qa2vPd11z/ezo+vN/LlndanYqv0pb6dn5ChQCri4KCcaRCsXBDbHI3oZCWR2ji0E7n86heM +cRZhLu+LLJ/Ipra3sfVjIvP53SHO7xAvfEjkdqxeIntwWk6kH5ZGqP9MIUilKSbK0YyChsP4Tand +ntlgbSgMQ5MmZGavrxHZ/fKgfCyCxHh3ABLnRRUz0ZKq9MNPKysC7YlakaiuJdEayznlO/DFHorE +98baZIY4VyIrFSl3Jny2hL08AhXGn7Tl/10EKow/SdT75REorMLWIgHV2nZIu61Q9lpJbBnS4Nj8 +XaFoGIVnIpuqysD+j0C0taM8rrVZ+IKH91BtCLJpKZx87cwK1sNMJBbVWzFgQWpWw3X8cvYtQtlb +wLFivrOxsnY9WG2UNvbsHzEYFPMRPkeTq2YZVkEuAIcRDgohxUX05LMNL6Y4e4+xoJj6yD5ztl/a +XvVPipXeZkJZU/PUDMJMdC5+k+q3l2aLZscOpt6Jqlf3SPjTrHK53UZeqX33lJjdaiUFJdhuyHWl +e0G3eIWCrLodzHVQ5Z4tSCjR3h0LijmRAAXV09k26e6MzEoXobZ1o1u5u54VuXCRsNowF7G6Xx48 +LIu5zOdjFKI5VKC1UTcTeIHfuxn0luBo0JtsqLSKrbsP0tdkH+6PFruZwI8JO++t5FcUjC+X44OB +mu6Rn57ts1c362kV3gbXJLbdqM5Ebbu/7nXkWgvOBVegclIuzP74Ds9b5bRyKea7PC3mzjIivB0s +6zn1DLCIcWOKzKnaf+1/Sqln0JxSfnGaIPifmUJinuks2RQ8g53EUJgR26PLmHoytkGXS7M8C4Cv +CQJNRjS6fl8gxY8bQ/LY68D6osJMm2kRYZOxqIyQmzz17F8IrPswp1bq+7X8i2OSkvajJzuCd39I +MYb6hKkfo838j/CIuCiwg2+L/jwL7IwysdjQaLTxoR7FPkjlPGvMk7jZarTTe0EQqxELYmHbUjSE +1aIfYyEssrdxJAnIiNfnxySmcyTKK+Woqdj11dl6jXHT7CHF14qiPpUzWDKCtrxoE+8u3AKtzdYf +cH85km4GFsdWbNP6+mNx8qfIcUSeqKhVQkVy1n8eB+Gj5jPhI7Sc34ePVIR4UexEvlv1hbGTBZGT +CIapLb8K4hAvNZQsuIiyQET0FAtaIQtgLjieKBNwo/8bJnQ2DkMWWGd9k4UswH22EQsjhu9efwkT +XoL0P49Hiz+K/HwM7dkwIv6huBkXz2OK9MJIJP5dqjfo4uypg6dG8bIxtEfPE5ByeZZEd/w2k9q/ +mQZW+Upp1M7vX6DT4C0jJGI6XWs/YRYvZWXNH4fe8lWB2a3aMPH7MTRn2YeLRzGaZS7YzZ8hCVI+ +aF7NhcHPA/1tRgRPSt/KxzEdE68xeIuO1Qdv1jF/8sYx9BNv1rEvgzfrWHP4r1zvYwLdUaBjz6hI +67lp3LyYlU/q2N30bdJotiPmKjm2iBPPkuj+O8+Hq1ichD96mzSaN+OYSimOvVypmnevUOy59zFt +NQfTN05jlFhkGXB+efk0pu9eOYZgn9xaWvqdfdLxeUgisfrlph4dQ7f79BoQWZGf40TXf3jLGNBb +dm/eqFTdu/FbvWV3MPmtq3t2Heo+TCP75FeZeHeaiFavlt7NVVeWxFFBIsWYjvghg+iEG0NIiD/Z +ZmKDGZ7pIse+zvuf5/Iov7rZdGZZmG1xZMzNsl7Px/JcGSStIlStSkmJ5sFROD1/FBYn46yqFgxx +bjaC2/IBwH4ewsHIMTjYRhC3PxeBCuNP4lv+RxGoMP6kzUegEAbbb1CBikWBnlohI4AzBfTUKrnZ +IXWaVqfAWtWQ2Bq+6xyqxwR3/yZ89FAu+dqpJGt9OBkYKrX7vZGaxaIqQpaZKFLYPDLEt1i7zGLr +/kXqe+HGLR3t9tkSi0DXEqaFg7d6zvxRCCE8vTeP8/+K4iJ62jzFBgkpuo3NtcJOY2X9snDjfbrf +OdkZfJVQ3O5Z+kIFmq5Og4zpEyt8diEq3W41G8FgOwqA7B7LZxvwCfeULHXefZEAXAgN0d2WVcbY +SFMEWkRJCbZ77UhsTSK0dw1D5jiaQdZzLggL5aK47F2HRoC1CCJ8d23P8KOWo+ZySpbE0SyE1eTT +hgsTrDN/Lr1aoAqLE6z/YHq1tvxkgvUfTK+WsaiFCdaZ16RXj//Z0tZBpSqm2d4b9KIxJm15GVrq +/mR6jx2c9q5/fTuodn75I83U5Q+BH1On8EGo+I8NDn5Uu1qy25/67b7/fZLSqwNtuZ3fGU2Kt1eT +2+GgM/qlr0GTqed3h8O+ntyp1Etf9b2/74ejiS6+RD8Z6oV6PYWhrWf7fbkd33b7/lz//OlBtVEp +6mu6HMXfTkmNZB1pmKQNY4EOsjdwoK0RfQf+n/4FH0caMQj8s2CGTxfkz2lHI4oTcPcvqHyEwg9o ++ku39QP97BvRe0j4WDOpwQllumkZjms5+k/NNA1mEiBjG57ruMBCgxLX0U3HcCyL6sxwuEVdrNvc +dfWCZhmU2ibFOyzb9fScaRDuwSUGlLhl61D3bM/UsSO3OdziGqbJXUvPUYNZFn6bZ7guCszg1PUE +ddMxOX675bg23ALUbU49HcZnu9zDETPLAeLUcG3T1eMzKWilJ+SLwc18ZTABrveGXV+v9TtwUS/c +3PZ7+knnWgqAPNPn170flZLhedxzUAyUcQqjXiAhKDoedWy8yEzHZS6KCSZDbTkp1/M8ZD/0w3lT +w/bgAjdsh9uemJ3HHWCpxS0i6w58ZUGzDWYLeVDD5I6FHGQuE3KyUf0tw6bUcnXs53iC957jgSBh +HJbLTVvIjXnYkwMphpQ8yuGrHceVrKcG5cBSVAVu4WCZwzj+Jq5n6/FJ/P84n54C85lLCNCFAugj +R/56jDs2Cy0AzMFwObEtHbhmUtMEPkML4RbcZxnE5kyvQosJ3CDIKehDOLoNaLJBgYnuGtRyhFaF +ZbyFgCip4AzYAgNiDPQZOcq5bYIMbAaagdrMmcfg7nhLFVqAzaZs4WBv2OKCxYFNoAW5roNCFUXO +PdGKZIJKFVXGtmG8MwqoCSbKEYaPDAGLoChQ+M0JEQKNtVQXtdgGdVDayDNb+ANOOUUpe6b8NoeZ +YuquSS2kGmupYosLFo8tNgxENAgGcbBZZsMFFwyE2ugpQIWonIJQc2Jx4kqicy2CBmcwVAtmB/MU +DoGDSaCtAUu57oG7ccH9ELg9LFfBUjzLYbaew57CVqhhuS7eybiJ3ieuJoVHilPVvsNKUwzommjg +oD7CbxKYvmixGZM6YHqoEqAsYmrQNTa1uRbBc84ZtnhEsRyooxMAj+xiHUYjnCI4R+UU51oECWID +UTRK8DIoUFu4RZwrGDn8BidkCaUgTBp3tKEqGmB7KBqodDUO9ZisgySwbuJELUPITJKItlSRGY7F +xYgtU9qHSRiXTBDyVvrrRJXZkcrPHIILAHaSbBBFl4AvmvWfVVCoNkOh4rw5KD0YouI3rBzCLYD6 +ENDGiAXHm6phk2NYFkdywE/mcvAFtrQhmCGluITZzLWEtsdaqhroCK530Ndzgdc6zhUdLWoE+s24 +zhQeaRFqV7qhVXfl7gb2OmI7kcvBxqfWufZPRp3bPux1rsed//h6ZzAYTjoT/x6u6NcjfzwZjnx9 +fDP8C1vglll32DUdlbT/ApxZKFc= + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/originals/SVG_Left_overlays/Broken_left.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/originals/SVG_Left_overlays/Broken_left.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,1568 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + + eJzsvWmTHbmRIPgL4j/kfpCZZLvMjsAZ0I6t2buyRzvUYSqpW21tY2VUFVXiDJOsZbHUq/316zcc +8V6SSfL1pckMMpn0xPNwOACHX3D85H/7zVfPdt++/ePLZ/F2vpl+8pPDu5cv3r999/Mbgt784vXr +H394/w5BP/3tz26WdDtDo90v1q+l4T+8fPfDq7dvfk6/ol/e4ad/+tWLP758+ebFze6H1y/uf3bz +05/Bb3736v3rl/C7/bu3//Plm69fv/zT+9sf/vLdz/S1gOf44j20WJa/m8PfhXmZb+b285ywwYs3 +f3nxww+v/j/8dYlrBNj+7Y9vvn315rv92//35zfQFH4Bf+AX//XVb1/+8OBvj2+/+fH+5Zv3v3n3 +9puXP/xwePv67bsffn5z+OuLNze/fPEd/ObFzT+9fP367b/c7F+/+OZ/TtDf/PXdq9cvoWv3L97f +LNTR3S+W8PX+x1evv/3Vj/d/fAmdjqUiOH5NKH//A+ACtPgzguvXv7gHyFcv378HquCFyKzDL//p +vx2Aw2/vqR0RervcLPDvT3+z+9Xvfv2rE7yu3RyQSf87/Rb+N9+mPLQIS/ZNQkEM+I9rMrSI8Pnb +NuCIlRv89u/3njPMO2j4z799+d0rmgswTv/9Z9LTd2+/v3/x7n/+wM1igD/8m9+9vP/+NYwmsX8p +t/lmyfhNf5JWwFVq8Syu9eZZKBF+HVu5Cc3a9PF6+ZdXL//l5ze/evvmJQ/K7t37r3hKpDTP/J1/ +89sfX7989/s3r94DZQVBjUfll2+/ffka2tvn716/+O4H7eTSv3OD3714993L9zCb3r7+8T3N81Xf +AKP+/MVfX+LUWfgFv/7+5Zvfvf0HovFZXW5jBDbnxv/CkMSy3pQIo7vSK9IMvZxvZvduGnlGj8gQ +lb4DptZPfgPz59fvXn336s3PhcL69d+/e/Vtn1M13Kz8jTpxu7q/Tf8ytdDx9+9fvhHqYS4ffunm +5nz7y6/gjac33x7e3iP3f8AFBzPgDUyO12+/49/Zz/Qb+PiP3zP19P+vYaB+8+7VG8Q5/Yp+s379 +m9c/wq/+/t3bH7//xZs/vZ1+yoLmd+9efAPNbn79x//x8pv3IDAE0H/66sdX71/evnj1/c8+iOg3 +r1+8efHuhuDwYQY+f/UX+M0LIOWGPwa/6bCPIz2+/BMs/f5Zhp7e/OXl67ffv+xwg7x48+3NP754 +9/3HUcMwvHMY6L/67yN6++L9n0FKvXzz7Q9GFv937CjDPo7vq29wUry72b/78Yc/3/zu7dvXhnb8 +lWEXMEGx/X+Md/yGPvDm12+YQedvkgbbN4FA+A/3Fmj98Bvgl/+RsR9evH796rt3L77/86tvLr3g +wu/tTfy7T5lYf73/49vXr3647/PJQX7z4t37V9+8fvnVX394//L+Q9iQG3969eZbmIgkdDq1b++/ +R63i5qs/v/j+JeF8/+c7avmVIcxfg2D0ou/Zsw/IxBBv9m/c7//+3YtvX4G4RTXp9Y8vb34L/33x ++kbBP5sug0HcA6Jvp3+e/ss049cyxznNea7wrHObd/N+Ps6n+W5ZQFuIS1ryUpa6tGW37JfDclxO +YQ5LCCGFEio8a2hhF/bhMIVjOIW7OMclBtzLYokVNLAWd3EfD/Ac4ynepTktKcKT4SmpppZ2aZ8O +6ZhO6S4DLXnJIUdQ53LOBZ6a19zyLu/zIZ/yXZnLUkADKPBp+HWZ/i/tTP9a7O9y8X+oMwb7HuUv +kEbsiHOeiCv4V78X+ZvkpwIcK8Az/b4S//Bvcz/t4O8evu8m+udA7D3AX2QyfwdmA7uROPiCzoDq +Bl9x6T/8l+nu7u50d7w73O3vdncNnvWu3pW7fJfu4l24W+7m093pdDqeDqf9aXdqp/VUT+WUT+kU +T+G0wLvg48fT8Xg8HPfH3XRsx/VYj+WYj+kYj+G4AFl3h9PheDgc9ofdoR3WQz2UQz4kGLpwWID0 +u/1pf9wf9vv9bt/2677uyz7v0z7uw7RfoH93u9PuuDvs9rvdru3WXd2VXd6lXdyF3QKsuKOxuruj +7mCHjtQp7BZ2bGedw+5V6iJ2EruZqKvYWewudBgfRHI6TdRz7PuB+o8cQB404gNyAnmB3MjEEeQJ +cgX5gs9s3EH+wNcETEI2AaPgacSrlfiFHEOeIddS78z51+mRz3H7TOcg4dFjnv35M10A7s4f6Ey6 ++cnX+3fQp4JflZ4VniYPDGbZ0wPzAviATL2rJDoqiAgQBpGeVGHJwof5a61tqg2eXd1XmFLIRBiR +u5VWzLrAAzJkBUGxphVW+krvXOuKX22FWbTCVFsPNAQnnBptnmBpgUhqocWWGggHIK82aN1a29ED +87PBHMaxo4kAswoWIQgxmIkB5mOEWZlgbmKngDIaSlx/tA4DPQuJQH4SiMIIojDTT/g9gVjM9BR6 +kAMFO0PCssG/u4l+2ONL4ftevh/ogfUG308oTXE2B5JD9K4Y8AskKEhYfEAWgpQFgRfWiYRtI4G7 +C7AoQeIe4fsJvtPCANmL0ncB6YsYUMyCIIUxQUu4kjReoe8N5DFJ5AekDXKLlw/xD/mI/ES+NuIy +jmchvicYgQgUYVdnHBwYoiMM1gGGbIdNYRDrRCOaYXwjjfUC8vIOVyXMhAPMChyBBhOlwqTJMH0S +kBqAoTMsf5xkR5huexipBmgqTM08gdxPsAME4PwM8uEEK/IA+8MOSFpx8sGukWF/icC8BUT2HSz6 +I2wxexj0llZ4Q4HNJwF/AozkHFku4ZqmJ9oT5KHxOs78yGITeXMgYXHgrz09O3rahIw7EDMONPNx +2YBAzSRUEwlWFK2BxCs+MwnZOxK0KGqPJG5R4OLXbiK520j2ovStvBpBBqMUTiSJQRbDQzNtP5NI +RqGMYvlIohmFM4pnFNCNJdgFaXDhaY99puG/6yc99dIzXQSXRz75/Omy7p9t2t984Ad+AvwtN3m+ +rS1WsJoBAZi+X38+gv0P8PY0g/gM2LSkVuNFLCXAREaTfIWlTW3aOsOqU4z1NrYl3sR823LudF0f +NVEMS2tZCvqNQAVb00W0IdU5I9oCSmIiJxLoS9BY0C63qG7dgCrWyb0yXqB1fzRFWzXgyyr03Ytv +X968f3vzj39GNX7a/B+GKrDSjJRkEEH0Q6ygop6LTyCphSXX8Qekcpx0iOdG8VzsLH98/AHx2EQa ++Xc9lDTMX4huBnQ131yPPkP4KQP79+9evnzjraINgLCKPWRCNJkQnTciVMWnCVCn4ybSKgLpGDPp +urKBHtzW2bdN2DhJ+sIWjZv1DNs3buN72Ngb7PeZ9IAFdAPUE3awvaK6EUE/uYMdCE0JtETCfPa1 +tYTOG5DM7xI0i4INltldEPU6oEUyKNloXZxMz94PVgZo1pOo1Mtgahxpa6TvbKQ1sZey2FVoakUx +xPT5hK/H9ZWsR7Qf2YI8gK6AhsCdWJJsS5o1KZrvKhrvRttFfXdyym4iZbeQsruiqot6Lr3Vaaes +mzbSSg+kj7IuGkgLzaSBrjBDdjCvDjDP7mDWLTD/IszEDARU2Owb7v17UAWOwPs7UBQWUBoiqBAZ +qKugYPBebgrgQgogmuH4lUwVpK6ymk7KIJrnjUz0HZnpohiSsQ7PhMMayfBKNF6JVF/WTBGnNxtc +R3ayTHDBHGnx3FG3ZulaoDfxYss8N1aylI/keYikVq+kMR9hOgbSg6t4GtTNgL1jI4ymJX/BVOVp +SxN4kelMyjHZkDTu9KBmccF10L94PrKDIFLvs1n+QC19mHRS1koL+ipILWXFdMGWpJyyeooKKquo +oKTShz9oK3fR0QVHYl2bh3pHmjw+q2j3VYYXB5qHnL9wIvCkgH74ERM2EiPFUlhlMuwHfw2OeDKP +DSjy5LUZ/TYwZhM5biK0y6SF88rrq25cc329sZXJ9uVgW05kWgZbbd2w5NW221qVYleyVck2pVqV ++JF1IqNSzcoDmZXkJECzkh62KwNxNpl1WWgVV7EycTWzpbmfzkxNfdjknMXsZMOTTU82PtkA9Q9x +YJJ/Pjg1P/PrbxXhYv8u5thbeG+ZyK8Xxb9H8tFtP/2nYttSpS2qyEKv7v/k2pvYb0HjQ2uiyGrY +u5WAyyA716VtOs55WWSb4UkPUx6mO8x53lqSbCnNpveJpnWwKc0uEpzJaGsfZQbr3JV9Z6IJu7MZ +epI5yZtPts1nJ5vPkaT1HVmPQSQ0b0EVpvkOTdA9WaS0DcFGtJD1GsmaLWTjrmT17sgQxq8TGstk +OC9kSuO2ksmNhmt2nY4redj2oiscQZTfoUuOdIlAD7rskH0kFcidx2uWNhZSRvZqjJ+OvBkcvWsD +TPu9OfLUhZfEvF/EoD+JEc/OT3V/FrHVo9jo7AQ9TWaY78Qer+INzaP6uFEddyLsWdx3xTFMLPVR +byTfy1Gk/+h1KRuvy+h3OZGL7EDust1k7pcVJgr7XzJNnWhemAVnMlnT7Is50lTbi0dmR/JuJb9M +BZuH1JxsDppITppAjppFVgnvrCdx2hzJccOPeCrKzp42sVRlfdScuc6Xux98uerJ7b5c9eR2X+6s +vtzpeDJ3rvpyuze3mTe3+3Oz8/wMHh/29kzO2XPB1XPBz3Pu6Rl8PRM6ewZ3j3f4OKcPPc35fdT3 +o94fnnV5tF+iuYKCcwgtatOYXaPPaXiIU5P8g+PziUEBCws8FBWYtoEBUXe2Co+pPDTJT+JcZNei +zmzyK040qRebzkebyE0nMM3cqK5FcS4ezbmo7sXKitzkNLlzPW4nrsaVXI3obGR3IzocyeVITkd2 +Ox5pBuwn8j6y/xE9kOiDLKRSJfJERvJGBlK22DRCtZsnOM9LnkQ6uDvWAAfHvQmFeRAKBxUKjm/V +fLLpTB4Y+yYRAioG/PrXtT8PblrPS3HWekZOF/jouZjEaRvIte55uBfnbRuYl6buxTWOMa/2piCv +ohpnU4lZIUab+26zTxxkp1iHXeLxwbFNaGyiRTB/LDQm7vY++7vC3+f+gcW6Dp6609WZPs53nu0i +m2l8cGx2JHJXG5VQwiQu9D4izY0GjwU70E80CjqFbfKODCR9fM8Ki0V5lk18p5rqMirhd6KAq/IN +pEyid6vG3RUZr8qETTxndWaoM0FxICazP1W3Ye1mJfm6I5l7IDl8Ekt7NiWH7e1sig6qOrvJdB3c +G3CPUG2n6zuJNhjTeUTlQekK72EBy0oTP3tTng6C9mjRhjtTp/Ql+qJgUQuMTco79b367iqhzFU2 +QqZiJxskK2GqiB1lEz3xjnonepnqZl0/C7INJ3myPMVpbF1rW9k8muif3aDEOTXOnv5lQVM28FkD +j6KDV9PCDxs9PA2a+F5NUaeJ566LT6KMHyW2qdp4Nn18Z9P77kGNfC9TmkKVG5V8cAVdcgaN7iDV +yNUlFCfnFVplyuqEZcfQYhp5djq5TqyD3zAkZOmyOyS/Y5H4Y6EMj9VCjkf2vgyOgw== + + + RI4Dch1Mku2xp4l4Er+R+g+6B4FHS30IRxqxnv2xmBvB5YBU8eLtzZ/gPQrBvHjZhnMdotbsVzhO +6saToPUiG5l689TH4L0MTeLXOyfdRL7Vu8kFsjWY3V0PY0hbn1WC2+qJ2K37/kyr6JKyUnXZDIEy +cVZ0l8Vijov+iHtoom+DmKYMngiyvRC5lL/jvGqauqNuoDtx/bETSJdaX2hhMrdPedw6gwE52kjg +GHg/KvpQhdHjFtI3EPwa1pl0P4m3pmcDsHvmOLmV9tB2sXcrTrYL81Rms4Nl2U2yWchGcWGr0M3C +bxduHfodA0X6NGwbunEkt3kUsle2Inxnz34U45M43t24Ow/+Tjz45sMXe+qSE38/2M/VUmDiJOqR +WkqnwYzuhnQVc0hN6W5Ma6hbLJ7JDOrRpNbQ9nlYexPSFuNazes8WWDGhWY+kN7gExyKj9aoyT2x +zT2o2Gp5e0V7J+tb1e0qUiCbIc6muJguqoEvIk5mi3Tr9nm052DPfnhYQu0m+kZmtY+pj+HwnlGl +WVWaWSVhHwv8uNDP5PKsDrZn6x7eXM5Vt9arqQHZZWCJ7T6Z+R5cQtaieoZLgTo5i/5odn237cW+ +n2QpNHtWezoHiz3ZPelCAgjM8OCexT1zfzZpWKfhOY7PdDj/2p89uweedv6Q7shhkPOcP8v4eyDh +74NWzSQeio8b+FvrZrRvzMafzK+lS03NnDRkEXVPlpqsW3N1YbtncllEe/NYVWeqxsFM9Sb/3syh +avGbNF0I4HB+kQ/hSBDHco3UAeBdAOIEmMSGPcncIl+AWLNsz7JDgK1atWzZtsrmHkjdSTCNYTdM +JgAawK71cfS1hGX1gFTXRD/A1hnoVE/gDAoO/IdwizrQmFBwXbSUVFCXGRpgsznlRukmpTXKBSDT +HI8cpTw3fEmGkQmYArAwbktRaPE2wEzohF4Vq+S4BJiZiCA0wIUYQ5uXPPR9WWpBSFEmBOx6z/O5 +KeE2wjzxKS7XREuULivgHBCEUgDFMGwZ+orsaISczvkwtthucVu7iQkTgByl10VLlH75dErlllKE +FmROCtecqVvUnAKz1jjmTS1hTQNXGvmT8IcacqIRnZEtyoh6C2/AtKWluUyY6+L9lISY56/evKRj +T5YRs4X0bKfNEQGMhvEBgYMdEMDjAXUwIO/keECkkH3pxwPQcJx63H5jYZzEvoibkNolY94F1aZ8 +Evtia10czkx4tS3OTXjnn5os+bhtLfnBNdXtDO+b2rezjOPposWhNkfPlTh0W99lSpzlSqCfX11W +aoqw42onAQPnvDKbpFslapkkiU6Uw4r6A7uvThKkY4dVIQtjJw4qmQpBJkPWLAiZEHxmZJZTI/3c +yEp2qfMu6ASZJMU5i4vBzRJ3hiQNp0i2WQnBe38ms0kf5f65aJiuLueHPAUn8xQEl+1Tz3IPTpZ7 +0PPZ1Slk02naujvdrAqbbINtNvuQy65JBZNLZs8ba9bbsyfnQQrOmt16Po8TRXQjzAu0V9FOPZKz +MdCEqMf2sakwTobZHSLq00HT4I8yGeZpEBjjZOjepsUlqhT1N9mUGCbF9IBPcJwW24mx30Tpe2JY +ni7kqYwiZtmkqAwJYVun0TpPW7ljM8WLnsuT5eJ0mVxWytnZh8FP3ifL6PhwnnJ0e2DkAucIzg4U +KicJ9ieZHO1vJ0Gl5x6GB7K9qp3monNc5zOc09XOD8lFc6FK4hpNZN3+cPoeJvKvLSTKcN9jGXYH +0zTSXof5U0eYkgtMRUygbeo6gzkXYa6tML8O9QSTKcIkqhgiOqwnoDbC3KgwHQ4wARYY9kJ5HkeQ +BAEkQKVxPcH2EGhEd5iq4Zb6CpL/cDyBFR4mWDmF0i0O6IW/WyiVrsCM3KHj6s5Odfkjap9zQG0w +VqdrHk9DM3X6+PG0DyXdmWFq8efpYhxOj7T4OJw/znJ2mKWfZJkuHGX5xIMsFP7k4GeL62Rxz2gR +zxMdGeI845VOFmWYpJRtTGeRTpRxvKec45UONfGhJzwQBcvpjs4tHigFuafzJsqvWjS7+GkqPE2F +p6nwNBXcVHDuqrXMM/kWQDsrrZFN3nKSWiRkf1463/JpH5MzLJ92MutLTnV94smUr97+6T3XDbr5 +h1ffvXn5ng4eXYL2M/vKg0l5MCkPpmWa6RE2P77lIwcEz8mU9Ra0znRT4y0otuGTRubS52mIHvPZ +25KXkLA2TlzwA/FmXW9rDO3TSHgYzeMpafnzZub4yU+ZKL9/8+bF/ctvb74T0A2sOJgpF8E0HcV3 +s6m+cNFmvuhiecBkns7s5WpnZPxp8GWTMzFmTbi8iclCusWlTjiXiwvrdpdLNbP4LBVo62rJZ7lA +Q3hX3CxkFD9szPjaEef1IqL81WIRvWhEwRoS3XqoVg2CjeQdeXgOZEr0chBcDIL+wjvv5DA6nofB +v2ECkRvsBLqePedz53jqvPK5c7JDdiSu+yHzkx0wD3LIHMT7RKfLC52t0TwPzvTYk/3NR8sxvwf2 +CDo+omeK8gNHx6+xJfsdebrGlux35OkaW7LfkafP35L72aVt4Ypt2Ypt0YptyQpXr2IaEpxduYoh +tXm26F/Pad4PQXsN25fJRe5d7H6I3vdj6ruzAP42hE+1Qs4Pp38kjs+J8qxTjkUsLp01Pz8knjeR +7x77jtMm/O1C4GdBcM1PP16MhEssfHLB8B4OPw+I95D4EBR3Se0y3tMYFneB8dPHAuOj6gVLv635 +Q0oNbGJLK/PKsSmQN/gDhk7SRS3pWgg56tZAfiWK463zchlZgDVOp8SL/iBhqMtK4/VQftmeHdaL +ezaA/Z7NY0t69N42i52keVFSiJxFUtfUpaO0oR+Cmpxv65NO1vqvS3sj+345IkTxINqokisVxZEg +LRPVJHkQHbnk/ZpINdlL5CdQOaheDAoUElJHerxnR14wds3a8SmizDyT0ZKt+hEkn2R1srzZZUjO +7em5pJ9MEvbYWSKV5sHeueRXTXrVhFef6Lqe2ph19UnVgS6V/9kUApo+pf7PQ0V/WJR+phl+wQqn +DX/68h1fqpK4pPODJf+vtpPqXqq7qZq4auRy1n8xOzdObOqasavmrhq8avKq0atmrxq+ZPpuCofk +MrfgJUlNOXB8Xy1E1PtR6mEKwgLaRblsa34pptHahRW1ZpKzy4JlO3xcmat7uAIaM4EerClxLZRf +Jj7jRekZx3p2TX30wyOHndzP/jkMj8/pOk7jf0U9d8+4yO34ZRySUC8d+x8P/o+GyZ3GfSc7/18u +H0/wrycpc6HSzZnS8wnPNGpJ5w+t01G7/gTl+nO9XT59/Wm/fNovn/bL/zT7ZcwgIfzWkWGB+7wt +2k64oBP8klOgLu6XX4qJ98sv23XjAqC1Xm0XV3x/63t5uryZpziaQvj1lHr2lHr2lHr2lHr2lHr2 +lHr2lHr2lHr2lHr2lGTylG/0NBWepsLTVPis1DPccz8pqWtBm7h9QVaYIHhshpEeRsy3Mx77+ozk +N/3oFxrp7bKR3pyR7jx2pCKreky6hRnW0dWM6Ea1asJcLkL0XzOLSOtVg9rruqzljilFd0N5CF+E +xRVFnB5fifc/r3bJeUpBvrOZBN83ztUPXQNyXs7/ozX6pwdq8T8mBnEeVAB50NMxtkkZZ8kZfG3D +xzytnyikpwd8rZ8toqeHcpHORTRnBH2oOEew7J+TdPwD5TmYCdNw1v9omT7nxTniUOfyzlJ7emLP +qhwqltPzwVqXD4hf4ExZykUxKrkhIOkqnniltJEll/bhJN0vRDj6XEuZF/bjrnF06NpJ50RHss1P ++hGP6xci/DJRni/7WwGMN3E++Vuf/K1P/tYnf+uTv/XJ3/rkb33ytz75W588K09Otqep8DQVnqbC +l/lb7daNdTOMOog4hJduSXjwkNE03Iow3oQ5njQab8L017gNR42mi2eNkitbuLhyof5ODq1eqHdy +SInQyVXf91NlLGEYfQnDYcbonLEZMz04ZfggGs8WnSsfmikyTyaZKH2acOLfeA1dnx/b2THODZgZ +E04MmhU6J/qMoBxadtI1WM04CYIkP+IaxhWcYbgXGGItnd/Ozo2Zh8n5l/aTrOHxMpV8sdjrWOh1 +d/lGlUmW+UO3J5yP4nBvgrtFheuy7qaHLrXdXGur43rpkOEgDaYHxQEO88fFwc6SPEUeTB8RCF4k +eKEwigURDDgDpguCwYkGmQoiunHNBxr6Ey1rHHgccrow4cJ9i76s6DDO08Vh7ot0vDinj/KDt2RM +NtT+4hy3aN31xdvSozzevfgojfm0kf3bKzLGSzKW4baR/dlWAKM/ueF/zH7gdgR3F4a7B2PaZPle +2BmGvWHcHdz+wBMBD08c5NTFh6YCqAyoMOxgEAopCgspCQcY/RVWSALFYAal4ABCe3Xy4wTbx46m +UIC3nGjyVJAUAXf4I8yVFfgb6VqNA0yDCgMfgQy8QmMHQ5RhJBe6MWMH45WBIYudSWgwIBkGYqEr +MfYT3YaRYb0twGxeZyhKkcELMBcZi2xVCYrM1Gs8mYNddhLvJmMd3+c5MM3xrG0OL5wfWJAzCn8D +drm6F7qf6UMOx7TxL3Xv0uBamh7paPyAm3H0S0+fd6HERf80eRanD1wn8cBlEh++VHT6wK2i4yUS +7l7RD10rOsnFEeIyJv+gdxpXdRvLoY87OuwR6JhHpuMdK13xsacLPU6nu4mu5eSrODNdwbmi7xy9 +13i7iLgXnqbC01R4mgpPU8FPhc8qH9Xm22Vun5dFIx/9vDJSZb5NsZUvSBtSDJ+YN/RZ5bK+NMBc +Ltc2KOuH6hGdx4E318qQX/wDS2v6yNryq2t7h5NfYBYZnlyI5nJFoos3lG0ieHtbeadJA8MuHDPG +hc+jwmNlok1MeLJgXr+JZrWYsB4OPnwsXLMMP2lxo7HMEf8v9P9N8mO07xo3iaSeFq55JAproXt0 +OZ7CP61SBqnQuVy6R3e3qYm0rYp0srpIUg+JKiNpVST+3sshpUmqIVW6RmUntZA0BMnVkCQuTReD +az2kKBWRohRDQqsHdffdRLGcHdVB2pNxxOHJWeogJbop6akS0hUqIQ326aMdFOKeuFxG6TNujXV1 +dA5Tr6hkuVXbO2PPb4ydzworWWmlaXNXbL8p1pdXGnyfmxJLY5Gl3XRWZ2mstHTZ/ymXuw7llsSR +NjkvqKu5tPWoXarB9LE6TA/VYsq+2MCQBfihmkyuKtPlukwwE6YLxZn6VUWX6zP1Ck0XajRNQ5km +X6jp0gVGi68UceEaI3imCyWb/G1GMvf+MxVwAqkxr5WqLdWQ1ovIFk6+m29LkJS3Nac2hwdy6K6H +8suUnLVcVHIA/OgLM7jkg9oolywUSoh5KPFG8xLU+LlkAg1G0EOIillSjG6b0IWoBnvqrDrDx+J8 +H43yPTZg+NGQ4UOIPhZ7PEM1LjPY2fhCmWUGZYCuC5rnUtuwKihRiPJKZdLxFTOX5w== + + + 8dUw/kcvbHu2RsLF/NMQh4XzsdzKi6U9H0qthDGeBi161KPHixzHhMptSqUlVE7D/b/FruBbh+op +oz0M1jDXyDnP/6qbxNOtgbE1MQYjY9pmfTkeeV49OllwctmCZeDOTjwBnD2UxnRB6pxLluzlXseU +yaOlTD6UNFnlQtQdRl96Ntw2H+5y4uRoeJ2xZBpScutuez00pkkt1PkiXcZJwJ1zmc3bG1I1pZlv +Rw2U0lXpjMtRzrfw6RZMXj5RFZ5UygTdlRMtYBpFOsvSgE8n4kwCXqx0buUOOktmO3TqCB0JQH0F +mveUsYfpeivReTdREmcBdnEC59ITOGEiH493INsiyLkKTNmDBMS7k8Nd4pH7JO3+48r99EHtfqPb +P0a1nz6WjXA5GYE6d92uYc7xw127YLp8vHvTx5MtLnWPR+4TLbOPdXD6VMvsY92bHpNLct69jaMP +34gbJKgqrSSqp1Nb4CI6OVC1H9VM5wDdos10c1neWKj7Whj5QrsWF0ICahXICTzEkWF3p72ddK0b +cuJxSdGE2LAx8HeJ9eLOfC2EX7ZdX/TmbQuVjnrueqbnRipuhtrjuS9+m/p9ivNkXvhLVcsf9BG6 +omfOP+j1Xq/7+hiCjyN4Rdofa+g6MEzdyYUWXJeGbvmsdh9n8LEGijd4D90iacjRnGhVLIc2+zx7 +KUEodcEXqQueLPZRJlHXq9UA37v0+5PzeAX6m4zi7GhutJz3n6zyf0pqX52umdjnTQBPo6fS0+kp +9bR6au/8qUJ/rtBRPdDtKfe0E/WdQuXiSOOGyg2d+wtnAenq5POjgHvLuFvNTWXHADdXdHeageov +PCX9xdbFfBtBFWL7qBVYBPhDaXks8lbwtNxKUhute4xoULmyy8L+ahi/SJzGcEmcAvQL79k8Oblz +dqhqckHNKpUjfUBTxOmXnvbanR3wWVCveeiAzxBufczxoi0FPtRbNufNiILpTMApDUoFn028nnC7 +UOnxkcLt3zNn+jHv/uS3T5eE5Pn7N/5MNB25PjsMGq1WMOuWsYqiXtlc9S7cD67766H8zOAvXnqc +w5cEfwXDlwmei26XOFZZfFSiL6X5PirL91HJog9YbRfSAx+TcHiWOfcQOh+ae0xyAqUmPCpJ5T8y +Ou/TREmYyF2eG93kjRwMw6F58Zuf/+BvMGq36zJca351zJ+48OYPnb3/lE9/0YJLFyME6UKAQL96 +5elgyZ2c5pmdq75IIignhFaKn69qHvQoeq9vLqHDTdHyO4ud81a6yN1CC0XR1fMfJzJ8oiyyIsut +WGydbxtaJbauNgZH2A+0WHk31lj7adLwHfeTXxaCFA3mrygnxPnJJIk4EM83E/HdRLyPr5PYKvJf ++q7XFjW6uEgvMOINny2wg5wxHr/T7yZrcnT/9ud04bkj78cQqMRx81pNHHS546DLqWl8tLrfUbq8 +Sh9YXSJlafqIWawXeR3J8/hA+QSXi5YmS5fZJqJF8klqmsy2vk58qL7OZAlo+WKFHXZGX8g+eyD3 +bDeJK/5OjiIHTT6T3LOD1CjvvvaPZJ9NZzJUE9BUkqosVWnK8pQl6o5MtgPJ1aMfY9Vdk50fXi2w +1iyd5WiJK8ugR2fLV2mTLCZTZWWtqJKvySl6S9fOadUnyUrxx+az5lut5LrTidONgA/nNapvRacS +/J0uJGFtMxzHHKxtTQ6dWJJ7NVHqVc9t5HmFrv8T+b8DTSicTjuaSjyRgkwkvjfhSPGLQNOnTuK8 +7yedsdqFnnQucs75jqQS+sT5mPMd+sNhtBuM8FELzv/tnHj/V0e4PPDQBJ5kd1MXlzq60tn+Nu5r +lza0g17KMe5ni9vDfPyaF5jfvFYxGdls3KkRdLe5SmC8GcDntoxZLWM2ixS0moYMliFvZZOv4m8Q +G9NThrSUachHGW8LG9NPhrSTId1kyDKZxvQSSm1ij9GY4MSGnKY5aaJTlE1x6elOk2Q83UnCzdHl +PbGbSS+W4+QndjmNKVB6DJQSoaYhF0rzoRadBTIyJ5cXdZS39MOhckD06WDy3/7B5Kvlklx2Zoyj +/NnjPLl8zi8faRjr6XEV5T4w1pvRnj4rdviB8Z4eHT386IhvLNm1zgsGw1qDzSTQtRqwE8SVXDvi +0Jklh2bBiN6DWTlfiuk/XTbO5cKeWNfTrFTnKbFdXrfwXiinOFV3Z/bmia42mm0v5p3YErOnTU62 +ZGOTiqBZ2IksIb2SttJtSKvYdjszz8QImywbO5LmS7ovzTVWfbmW2I6C9EeynE6k4s9kP6ECjCpw +ohtyChblmSiJA3XhHc3vo1QZ4xMJ2P8gT6KqPagUo1qMivFKq4XLS6l6TPcmz6Qlc6UprjOFJxYy +Hf3lQlO+1NSBq5FZPbJFzjBwmk2eKNNmHfJsONMGl/15ng1l2oyGaTRXO4+dGqcLjdmHT1LlXuVo +uniGaqXEmN2lgMP29JSc8YjCyTqZvXpA1jnLwtsWhwfOTunBqeGO6URZNaPVerS7pdVsRVZ+pCws +505Nw7kpb7nq7WzH4dRUoMzuQhk650liYLpOg+W6ykVal91/bLx+/Lqsx12c9eB1WtNH7tS6eMfW +h57z+7c+dO/WI27jmi6Urn1MMdsHn+nBarcfe+rlZ3roFw9Uy6VntEiUtdp7pU9RqNWh5sZisWM1 +MywR/hOvln74cmm0FabHXC79+OulD3m6cL30FS6Y/swrpuWwgy8gcjddKC7hy0tsC0xQiYkn2+Nv +yfZ4IEMiAwciBjoahsjG0r4lVUo7yKpIYqnfVB9QRa+H8j+dTlouRk4AerHWPCk0vKHvzF14+RC0 +5ANf2MzVA32kVPFHHoHWOzPrsJn7nG86BT05R3R3RdOGLlv64m7DzOKVlq3dPNN8OPqEwnxiXxen +fvbqs90tr8nUmlvO3BkPsO4to/rOH2TlukeJ1nSh1d1one9oxR822eWRMpFROhTKR97cXovydqJk +anHJSko1+2UPklXfWVlJL9pxRUrx1LKvFr21e75FdGKH7f/aLlneTD5WYf/Dd/2eX+B74bjdhyvv +XziK55/pQb3yoa/jA4/4EuUUH/X+U862Pmbf+bQU8UfsOtP18qflYKvUDKJ1v9Lhil5ZKlyoJnZw +paWqdOe8tBR1ayIjC3vGeyr3zypMUR+5l73G2PZaWe6uXCw7YZ83Faf83bLc+6HulPDgJFHXzfWy +EweCH9x4seQSpj+3VNd2eZfEQv+YjpC48v8H97ovRDhuug16SZmGK55akUQI3rGb7tx4syolTfAV +AB/RCr4U4xdt0PXS/ly/NIXx6f6Ap/sDnu4PeLo/4On+gKf7Az5bMf63Rfh0f8DT/QFPTrGnovFP +U+FpKjxNhX/9+1ofX8RwPOf9SR/7T+cvbxfPFLbNmcKTMXpvRfZ2kl25bspLF/vpUqlp+ncasjs/ +V8e6oAkGOfqMLgNyGEihJDQCWE3SHHlWkBplgRxJ0yf1aJITjuwaQEsvSy0Ozoo/uWPilZI09pa5 +bHnLRJmprtGqvPjqLurt18zzWYL46vnXLHR2/1c8Csh28Y7ipwcJ658ktD9bLKBHAzTQXyTt8+PB +/o8E8z8Wtz+PzT8mRr8JtbP8/kw5fUFMk5Cevrxm4o5Nj02l/NGJmU3+qQRUGXgY/JfFBGGcBvfl +8SyNTWWiSsXtJQokGx/wa8IMXjOdiVqWlofCbI2PKNodofArAn3MdfjFKFlA5jKPd5fCB0IrXsjh +SS4sEQc/YE2KUC6Lyy/F9GXC82J9izbWt7CCoCpw2MVwp0dynK/J+5nGAxWbMtFbD9OlEtGjW/KB +EtHoK5jMp7T1TZonaZQbF0pFbSvScjhvd6EW7SLh0V4/q0xWHmrn/IhjrDS5UzscMd1RFohFTUWK +kvycKI0kU+yPU6GaJUNJ/HTs0RdJmEuHoi/ImEdImIfVwOnjeqDe97zfJP6PJUu3RUsvJeqcthn+ +Y+HSdZPXn4aknW3azqZ86eRy+NvhYgFTjlHtaVbqNUY9WrWNV7Ea+/BlKBKzmjRoNdyI0u9EYQV3 +G7e6FLlihVfqHKHc95KfdV+JXm0yjeO8DKEgUErCeJRcoy9Ni1CmNYB4uCj5roOOiw+hgjbI8rUu +m3QR6CCI8xt3yj1g4OqhDeN6KD8koAHw9a/evvnNu1dv3r96892zZ05u+19Mv/oefxP5N7958f79 +y3dvQKB/9f/8+OLdyx9udm++e/3yW5DlG8DNstymVFf5N96UcosRPfk3Qld/xO6aLfCHv9J//2/4 +8X8A8F9u0s0vb/75v8833xL8D7+Ff7Y47x1M8N48B9jmXQNMP/v8Aj6EvaHX/ZqGAiwn0C8oB71W +YnOaV9hxcDushbbFmecFVnCVilWRc4H+8AJfAC/Fuq75FgzNxPQKiP+lV9Jv2wWIfOz5OSYE/Qn+ +hhULWMKWuYLKUCu9QWGx3S5tDcPHL8H0s88v4NP30OeAUxk6ClKU3qOwstzGBnae//wlmH72+QV8 ++h6lST/vOVbDbWp1EQa1eW6XQP7NW2z6FvpYKX5YFOQGgT91AeLGYINJX0Ddqkk/e+9AnrPKhUsw +PxtGbPoSogZmiY7pvYPxR9rw8UswPx+2+AZubcZEYX4A9POXYH4Etvj0PSDoAmwLuMzyXGG7xhh6 +BMHGsjohvVg9SLIApOAaSG/+gRbcfPNbrj4SYHlyIbmaxhIIXayi0s0KOeyLdPxkxdV884cd1zy+ ++Rc/U/tcuTRslxbThTW7wYagP7LUr5kL03bySliGKkmJy9CiF4XIhF6yuUA9386v+wdGfliNG5gn +/tJ8ZVJhl1+o9l2IGP64yFvZjpxFA9IR6Gdah1kq0uTS7FFuXYJ5ybHF12mtoOxH2h/rwlML2uVC +jG4Y50SBrQkbmU0cqqSBu+ogwt1SviRMsdDVRuYKyK3aC7L/j1ea+Fth7OdphSFMwhYTphdgfkFe +Eu5XHX7aREF29sEfRO0FMagg+dzzM0zXHPbNfuC3CD/Gl+ToBXF9YXdhQlMCK3KshZby2kbtVEtg +rspVyXtiQnEgHQX3DsbrIp1L4g3MU7/Fp7RutQqvaXicorpcAHmMl3QUfMvvpxOrm6CfirL5Wfrq +yr/Zv/vxhz8rHnM3hPln03yzg79/+JfpR3gGLfSyDkoa6LMEuvltvgFJnbDy5wJceAYq4XqLkXwH +fj6CQ7nFiwkJrBguwfrH30yog+JEnhca+4rHwnCSgkW2kvCvBcwEOhCJuxdCrAD/ovPYoUbDIgci +ODSYjmtOCI63c4DPAHDNt2D7CRkRljzAaryt81wdad/g5wvSAxOQwNhwafDh1nzDv0JDMLQAJ5Dd +Gy512/Av2HDOgDEk/3JYnrgzl4FKz2vp0WEa2uJ+BXhvBqTI7AZq+kCAjsA3I6UAzgU6N/RK2/51 +7H5v61ilbbFjjqudBsf/Tu12oA7Tn6bfT+3mpz+7+cM/wk80qWEVDFP6YzOdoDcAvg== + + + CcOUf/SEX0F9ul1X0EzWMBcsz0tzfp3XiGKiOfDzDTjclppXAnskD4ANybVmPmEvBSQoYE+wEeRE +lC8wuQgSE6hX3CytS2Jghh31ZqQMWq5rxWnG4MjdQ5RgpjMQzXAG4pWiNxdfjgOKHII2RWlIaUnC +z3yLzmoEw08z7FAILDwpuW2MhYD1Fo9LM7AtsBYOhABmEvoEGJzDom1jkpflOdxwwwX3bYKVGQjn +zzfYEeeVCVhooq5zW26B94HbrsywGWZvhgbKm7QyApzUMQmxoZTCMwLAQG0duAN7MCzoVdiba4gC +jMuixGLqLONFcFSGxZalbQizYE1zUQRhLcpzVG4NQa42wDlIW9h4oyJYFQgmv1KwJvl8usVInDRF +k0GAnQkw5wW4oFuACZjnYAhg9QsXQemqwhmcN6UJx+G/hCLfpjDLDEshM8cLUKAdqzlrxwCMXeeR +bFERtJQVmFJWYFPCesdg0dnMbzVwH9bbsBSZRyBqGSlMjqCTAwSWfL7BzC5Ca0vCw4aKoby/4sSX +z8vkwnWx2ucxY0qn7KKfL40/D68KIQuwIeMZWNeFl+NMC14Q1LXinEdgajwyGRZ5XAW4plKF12so +hgBmpA7B0liKLfMCL4nyuhQExYLqZ9TeErcRmOYs1EZYsIJ3wX1BVvO8zh1vWWehgsruMRAzv4Th +pTIw3GK8XjtcguAFcErStwUWr+AN0NEk9IbcVkGRcEwYRY5VgCVGXeUhGtoyvo3RwirFbaozjYHR +RCDJbAGCqi0EsLRjMGwGQu68rEVIaLMO8JLXIAiW1EcyaX9ROuhAgGzgtjDtU246GaW3FaR41C7k +ogMBu30qOsVCrdK2Yhl35jgKdwGuVddYcQhaVEGzRiZghd6u0hRLdgoQNHd9U5u1BwCGLgt4lVmz +3gLj4hkCNJYECMqLISASeemsJP4QCOrOovMg8CA0ljmd24yg4SjqgPEmQsCkS3eFrfbGWgoFFf5r +CGK0DacAmIEl16qMNSD5W5kCYwFA52ALRwa8ITeVXYsStSbddNdFZ9Ey81RnrI1nEQC7nCSRyMDS +VmU2bkaKIANd2pYn9wJrPNluE0hOYUswBYvwNRaaGQtugkGFH4ZlD4pAX5VouyRQDjpZqsG67NZN +CcGxFV3JkUUMAFtfLyz74NXA/rU5mhhBQE+zLs6F1RYEBl0vGK+5+Sdpi3aw7jSCF5ZcSDZhV4GB +QNb1hpKG3xVRC9MVV+zzGZnhdx8E9h20lqUagjZHXfN4ggaB8LEQTJEhlQeBsVZ5FRgD8nlAFpUA +ULX5XfBjC1sWZhjMNTpRyAgAWWm6YFDQM5BUdh6uuRQBpnnYvxRBCav0NqcmGiy+rmVBQQavvAxt +FNGwFsNbTWNZdHEg3kWnrOz3oHKZFm3qEQIXmD+qHhlrC8gdVTQxQ1na1jmZfBDWVhhSnXLBljf6 +JOKqk66UJG3xhI6yhjVlRBBUE8OwuyAAyZlsV0ur7B4ABrml4JIVherKKPxLFGCzfSagr0Pxtppk +MUasHY9AUHOLTnsshyxAkIar7qtBebtiZaHsCGNgTcqaLAMGMnZedfta6mqfh0WsnKlFP9+39iUF +papG20D72DSUgrpugPk3AoS9XRHMCgxrNWDJhqBPcXHDMjjVpXZ1jGFrWKJjIgNL0CFPuFkr2jwv +eTM00LaqagDDnASYYPtRZWpZDUFZVE5k0S0A2OIiwAILEoEBC4DrToUJFowg4Jn5OSkClumBDLmi +ZPGeEjDGpioP6fGKIKUmLBA1F4FrVHWuShfCchuS8ntFfZMRADgzD2C1BV43AASDRbqbI4sJBMag +r4q6bgCMmWxC2Nq4C8HtFaJSIzAnlWlgu8ooADhV3WzyyhIY24oZl00bROCiKwFvqDIEpKhwd9Hx +LUC0gRkr8EiAIJaVAhCwhqDFrPNA9NEQTalG30XOAgwtJeWsKicAjqsuPGK9AKOukCIKHmJtukJK +UgUcwPCzIKDOIDA5YU12CwO7ygM7hAgfBItyARSwfhcyOqAXHtolGjDWoMCgHMhuw5SQDINTVMlB +2xgDa1IjpLFIRFjRz9dgaIuZjNoj2LRUaq0s9gIuaZ1A1dSlgLq2KgE0FxiYWxPq5yLTHfc6XcbV +5CbSZDLWiIePLUURiCoOwJBVk17RiFXql1Wlhlj9hCBr75MoN4TAJpupRujqWnRQbA4WWL5FZ4CK +h2L6eWbtVhGsQQVyRbX7uYIjLw40fVnpC7itVc8FBs6yYkrXRBGKsqavIwZmsGhkYoiNAUCKODHS +VBZDkEzBTer1QjBt8wyuMosrD+o4DNVJ6RWFhuIlPsuqF97gBmpTm10MBKzJeqtbFYLRVqdOkMBF +IJjyqU/OuQpQV5zMJEawmk2Ek1tEAWw/qamMFEsLgMlWXK2qooXmbMg2r4oAL8/Ul1VieJzZZOky +khBEupRTKYhMbZzNUWRrDmGLzsQ1qBGLn2+6pRSUNQwMtvDQoSZAimnJIKhAR3BRJ8e68BoDYM3R +y24GkodNNipdeBE9BE13RVzaAlySjmLkOYvAqC0bVu1XBLHYtsr7OsDU5QgjWzL3IFBtf7dL8OcD +iB39vCq0gKBm3VFoiBjYcN+XNy32eTytKFqI2AkATEGBaxGqYJcRVxsiTdEQYA6ZkzLPBQwWqO4e +vNVG2FFi1Bkb2ZUacZdQ3wB9hNGiC1B3lCb7FAC7bkPaKAOzGLsFQ32yPCK6HlMZCUDVKcjkDuyo +QqCa636jRHCz7raqCKrpMEWMRQBi7pxOIt2mIorqqHShb1OwFpUmmFFqFKh+isLcUbDYpGdHBGKd +q2obYoQjcFFa8aSpIaizzll1ekSU7yYQRe5gF6pqrbmoxhWB8FWVq5iE2sJxPBaedWkCVE8G7oOq +jiN4jrbssiKAKaUUiCMCgGQpyzSIygMQ3012VZYVzwWcRO8s7NVgYFjVJVbFU49AU6dp61S8yQyN +LJtrrDzQoqGyJhcr3VDj5hwjQN+76dNBwxux2nblVt7qPHtZjAoAhqhqUDEb/7ztcwXbbCZ/MgNj +U/EpXm4E5lmjChltO8XbNU/dGJCGokZFFVcXvsocjrQlK4IQlTmN4nVMge1XTUwzosAWZOqfx6Oz +o+Ya0QpTPVtVXwB2l9JqBgjGjRd1KNSVFXUExmRbm4w5ANeoik+23aY527CJ3Q3AlJO2lVBQRN93 +qmeTEfbGsvp1KlibuoObKAIINO2ABKghWOa2maESDxe53IysoMK6++UAnJv6tHW8minksETEKQPA +Opvuh1aNfr7YJtLqqgQU24Vpb5Q3RVXITfWO3V1HQk8mJ0BNzSM5Y+C+5xqxq+n5joXdbUDTUF9G +JA4CNGGKTfCmHQPVM1jY1UMIEuZYJZESaren2TkDGs5IBq5tLjq5VSdNlJJl07s17ljqfsQ+EwEY +kE9MGC8PgKXQRM+cgzqWCKzbK00ZRatBNgCz1pAWr6OJXQRAdVKgXaPEooIwa8dY1ELLlnVjIOHI +DUMwa8PUwYQRapU77H8CkLrrumkLQDVBRHnWjzdzUBhfo7noCzvQGUhpmxtNCMGinwCzlAIABl3f +C3rjEJhMpy8cX2QE6ME2bjd2DiZR2gmYxGmbskXB0FRQjTrhTNfBFlZjX9QZUpWBwgwR8qtyAC3P +2bYw1nwRWNSGTRzwQmBY1JNhiwuh5sGzse5NsVOsDidc02a/VFVGAZzCKvMdmM19raZOD8BuLned +CcBkOwtjS9a2IQgwyLhWjnzxuFoMDJvaXtnEYARgrottHE2R1mauGBPRqbJ2b+96LlA3MziFDcGw +BeeuGzTmNwLVak6yCmDrqlWxFlvdAF61qQpOAMbZpOnCezUC0+J3GUWQS1O8sqem1URJ0dDxkppj +LAWGGQGGWcy4TWJaAjRJONcthEZJYcoZmRzNfBYbtKp7Qx/EqMizzc5i/njMWyvmZUL9jBBkLMuu +6pUa/jlYDK6wM5qBrre4UhgBgMWqQcJC5J7liL42HTHxM0HbZjIiV5YRGYODi+KtGppDBEWNyyjO +p4ymQlKBVIMCQadUDVG9AQAlJ6OoFqzQZoyAJJ3gElcCYEXLq/dAEaiaWthBJwjEq1PYHGQgaXUi +eNRmRrBo2o6LyeJ1QAHbKgDrHdD4PULJWS38bvpxGuWxA8ncreIRUwR95dKG9VzAGp7sixQ7a76i +Ipo+0rqo67977vF1TYOxkmUsrysWnhOZhng1BiTRZPx40VjLio7/w8Mfx5QOVcMSh1qo4WzGbepU +UTyHe8DaBnXV5JkYkTlxPiwDF/Vq5Wx7alGve8YcC52aNt0SHhgxT0bs9DdzKhadGdmycbpjL2Po +SyntmyIRUM24ZfGPbeeoq0usqpydLEimwmTU01S/jbMh0CmokSJstyy6NKPuCA99HI+Ayaskwp6z +xZ+KHwG0IVRIq9Kdcf9aF0crA8OiZJHrlBEUC3oWC1wg1tUEiTjwEIFj4dIRLLXprijRMgCWOpsg +0c+DsqIE9DlQTAlCw5W9uwjsq1usIQDmqEp3sH09Y3dUwC3iT8rVQkLlVj5eOW+kT0z+ODk7VWJo +/gdAlSZdAmjp6kavsTMARuckbIZScyyKZp4hsMmszhISRFBSwbIUnRNrR0f/NddaYYc/A0PS2UCj +pi9uTfWOIvFb92J1dmWvB3SfzPDxGPVNIBBlJNSjgjQFnc09coDgpJIexcFzgXYtXaMfGVMzsvRK +DXkE2rt6UAbBi+Y0VvFrITApW1T0rBaUR5muiQEZrWC1U9a+W4LSkHTsTCavvE/LyLNfDFrCDFUg +2kyKt5Wi+0JTvQlaU6KBcFG2i8aJBoPeg3htt1vMVQ9gELa6JGd2IWUMUFp/ixFG6ZXSM1VQAFwl +la+wXcXAsvQNLwtM/QPFRSsQrRkAObmOdctEffL0rrjR8jKalsWATegqs1PTNOcAgHHVQZfQFjWM +MpDFfz4U7VcVlzwAU9StRS0rRGou3qQWTJndpNPgHCJtqiRS5ISB2YRCn+CIwKaM+ifL7NRnSSld +ysKxeO5qKJ0CZ7MXDexD67mYcVuSzNDiU+xUdUPMmDjGe57Su3CG1sqeRN1esG1VT3kQpxCeI7AM +vcjpiAhM0TIObIoj3lVdD60ERYBDLKMrEhuA1USX2WwlmE/IjVhwKg55WxmofrVhynRXeWE1lIEl +q0AoeU4C1GAYEBDUbMe2NmTkk5SXZV3lTTa9gll0arV2NwkhMEklqScF1N+qw6trHFpShGA1w0IR +rHHRfWex7pbu5ZVEQCQrmePBIrrYtqSNmwDbLupnVv85vsq8+gRkBNE5UzWhBYA9Pbqy3YmwRd1i +rc8CAM+mvcVF+d1iMXcKW974pqyWM4og/Xxa7PONg5fFZzJqeKygVm96g0UrAKzpP4WjywJMuolJ +2gnBVMz2WB6iXXSjJaf8cwHnopKaThIoWFNjC3u4BIXEkJn/yWJrkmjPb0qWlovbkg== + + + YsTcZd1A1K5CjE3tUFZRClpFqvkFy9mEjytPdAfH14fmtBZ596rbH/ksjaSg2qCm6CNF4vgqnIso +SJsZOmvrfQrmTDCxjS+r5qTh+HtJHL7kFaD55ghWh06x/NQieZrjCkhurfTUlJK548OuXLK552W3 +Z2CpytRi3jMEL33n4chUQaXLeLgq0rXo+AXTkkvm8ymjjM8ueJLEo4V9lWWB0R3NlqO26vIu4vqB +tqDnmwO1Ay3A0AMiRew2Boc1G7s0/iNqNsLWJg2dFMJcWUsCl/yikk0l7kltJdsuLecmtAeqCPbU +L0TQUxjE/YfApCkMTgpl5hyD46zj1fPENFulFKdBUVICI8DJY9H7VURW4VRN2Q5nHZmWzS60FKmC +w9SUMEn8xSoGFh20iQx6fVbG9t2sum2aLCAGOp99lb2kul2ne0ABrJHIwslnDAyLbXHrogi6Syyb +SwwRrDoPNSSFbSVHq9urCGzmykGRpAh6NDdL0gpSu7atKK/OC05C2yjI6rtain5evY09JQCBi4b5 +KdTLn185ir16p0epljbak1GxpS2EYFkRBT2I2eahbHzdcrAUxNIsP0dihfx5dOrpJIgS4agzr9VB +qQJgKpop0f3QdXbxaG2Yo66CpX+6Js13mXUrrej6s3xkcTjg54suQ7XBsaUtl2i6efUaJAkoPve1 +OJ0qLizgAAhUWz4yL28AlmaxaPXcYdNaNU3bjm1gY8sEmlfF2lOXNUCNwKL9Ij+Dou2JU7PIaACu +WZNem6hk2DJp9vfaVPepmL+tOb5FAhQVIyx69oaS0hmoIWdJH2cEwc46CbXPBdwzz+ioMwIjpy1y +W7YpAZaSqdAmDREc9RwZ+ZOeC7jPQ3KcGNhSkuUEEALXZDn0ks0EQBhd7VrSSVsxAVBZFi2pDsBL +1pNJWTybAMx2EkwkKpK76KGNVQ+YEVrLndJ03BqcU01TbAEIerwimJeOQCU1bv01btjYz2IgqZKV +kPi0iiLQ/BjcDFkiIgUSFcJsb2EXZrzoITuyinV8NeEyqasGCZANKLFzWYBlsYat9c/baRIKXsjs +yFUICJirxkCNuyfnP6p4/FKz20lllcm4aAo5eT90huo5RTuNR+CsYPeyfmZMj6PgYph1uB0FeAZK +X6Z5FQDU82WJj0uITJEhsJNK0HCZS3JTi4EwgkJTkeR+lBGLnsXoGavY1s4Ikk0rwKLrlrI4RUhJ +XA1bLrHLxBB1uGUHRjmX7BhA6oIy67nBYB4zkr8puKF9LuAgybypy0QP1NkNe0KTdIDkdaZmm3Ay +SVdWy80fgLRFMrCrPBgZ06VIpvZz3QMllzV28xM3Vj27oX5UAC4mOCg0p4qM40MKprqK+h9ZwDIw +N+UtZTGqNpibHpfSBB+0PhZD0LqtXcuqtGoECi3NrPIvYAGn52aq6mo0vIFnCw+PKs89gztxrrfi +7StPY2sA7NyVXQg9C7ILy0kYdViomzxZGA7dIBKrgY6phjWbzhFZbzMXj2QCRcy0bOaKocPJBJYk +EnR9VRYIURMw0KUnqYHCQ/WoBXuZJoagT3DW42kUnnnGTsWscrIfWyDXaFS8kmcLQFjtMo80qxgd +tkvRflniE7p8xesTzXWF7ms5h4ZjX9VfTLkUgtWCltkUj8h25jOOy6RclInNAn7i/o6c2GrBQdFd +I2vq7FUMlnESOYT6jCOkkjYUeQI/o7hrkwBCJGtHg6mzaC6RnRsa5VVTNFqOJQaE1xSVCUHRgtBV +tOY7w5hyVj5S6PUZRZ/7pFFND+PUsy6RZIERAGvmEkZAeSNGoLggo4YiMSpfivCri3VKIggCjk3S +a6rpeXIG+5kkJgTpK+UgaL6CnquJHLd8LmDquvRXYvgIXAWv2gVJIuwMtJgT5kyIUhfZa/iMkjb6 +uimycDGTQw6pxR7gSHKglT8vlmRK5sYNPY0Bhk4OwUq+qqay0MpktBJRAGANSsAiDnIAFjnoCNt/ +naMhWGZFoCFCSrxpUaeXJAgFMwwiJ0EwgmC2CXoCWYK7xJ8RwZxsdqmcoxwjnfUUBHgQK2Yr6yhS +1hsjmO1QejBpD8C+sejsoKw4XXfBUs2qhW6j6QdR8jeEh5xrhwqjrgPTGmI/JCJ1A54LOMnJ62AJ +ADGavzhyeQQGplQEQc9ijGbKRjuAGHtpAzo+LTAaDX6/GYeYRJ10ecxy0gNzuKvOIopgPKN0bSpo +JHNI5SyCmy6ORROIF0vri7y7C7DWqqvW+Nrz0COnRj2j7Hb14Pa5iUn3ktYQ2RBlBDPIHV0zFPlj +IOgnAtSQMAJtCLOlvyHerHjrIqc3mp1hipznycASdcO3HIiAR9lWg7JrEIGpT2M5ANQsdAtA0+fC +agdOYz+rUvm4A7NLEmzwXE2nyvaqkNyyT3YsSA8iY84a7zR4VKnoJMpWxCAkOw+P6583VgSGoD0Q +PdcdgYrOSRHQ1mzaVjYPAOoRQdBCZBqF5Magn23F81YSjIj9dFKyzN/Yj+ugmqKClyLdjCBaVlfU +8Cae7Mq6A2u2d4hWpCTe2hl7hEokQdQFPlXTgwaRo27P6NSdWkDRdH0AaiK9W/V4UrPq6qA09Gd8 +5lcC46K8PaPz0RoBDO4kFh48l3NQAJZIABYakBzCYBG8uR9lDnzIgxDg4EtNgGhHKkkDVB6GkLSq +gh7ujXzCWhGE2UQc2yW0Pdo0TFaVIUiKb3SaMy3gJuV4JA8Viz00nVpqEiBQMsqCO3iBdSwqb/bB +YrPzbNkhQVP2sUKHnqIKPVEcwarhBj1gQEBx+poSRQhWE6a6d1GNEDHlAzsjnis4scEYOP6h4DDr +OEiNDgTOWemtnPSIQI0ehK5QY0kUSnEjsKgxWBZmDUn3ZdanqTSO5G6FfsxibrNFxSKbqlxbRx1T +QV2xWIeHYpTCW9lUsOaPugiiZm5gdSCYeMKcqtWBeq0lkRGMIFrE1Cz0C1WH/oHKEWGdouCcByFI +kaTEqgq3n4s6JVrSE+gkf6Rl1EIQPVEGwWVRM79YpaSwBjEQdUWfU8CVktCcbMUyo1GI3is424kR +yVAn/68lJwtpCMyaGDP3IGtlbAxWt3T33/ZELgQWTSacLUWj9PPqxRxRhdJRNGu8qZW86YF2rZgZ +gZRRKWMBVw3HGBHF5UcESTDHOEDQnIM4W8T+DO9zeWFyrCDP5L2Aq6Xz1qwhmZo1dYhOMD2TQFEo +CtSdoyTT64qdwaKYjoavNM/tnICDUaZGWdFqoAxWLcayINEPYOm8sfJOWRJXk105uUh9uRyY0jCD +BjGT1XgpdOrt4vuVMNhUVk3opRG4V/CihNVZcwxC0oipBfcWy2KkiKla/D2SaTkZCx/1WDm3J2mK +wub1QteQrpKZKISBlSOw2Sz+NhtQlGZMosk9I1l1CPQOWLJK1gylxocqmFg1+fspf0yQUtf3hiqZ +dnR2UD3MJOPuBZybHaVAhUOPCfbSCuQheH4ZiWAPsxX2yqxD3QtYRXs/x4l1CCwHTZI3EbZcOAo7 +sxYlq15USn9oVcN55wTIGC3Rnasjxfxewc1qR8AYSzkH8fOs7O/Wfp8jeU41Ab+sEiCCb8rnVwMU +6Y9BBCpcFzHpZi4O/HwAQzfZrfJcP38OcR99Q/RQAcCK+guWbkWZiHWaw0rJuDiSeB0M/tDmhW4s +WWDiUHnXyPeVcAVA0OsK/h5eKfnV96LXtSUQGMsgkU6zyiGvpQUbcwpTo/jHQpBkj38jSsaa2G6d +da2gjgCKq5UVCaIiaOwNdPCSVaUJFuoTH6YWyou1CTdkV6EydUn9RVKHhZQUEXkLy1+la55ZtsyW ++T3jy1B3AUuwl4+iKFBDoByT+Yb4suDxN+ILZmyuWuaHaxIta7RA+BLl0NOyojZppWQwgNHOBn3J +UisPW2sYcUE9BHcwxIua5s3FAftGFhSeCsM1iRQnTM+4F3BcW3Dg5xtwZCtGaMYJhbd+Ym1G1ZvX +vDYHZFYCW/DqMt8WFbYYaUp3rB4oFKgWBy9cN4R5cOCKaVLGrylhII/yGWEE1CGCzTONbR1zDOsF +jkkBSnxdWIXx5EOiddywJhmq+stKoVqePehgYCAm4UoNOSwhWIiGmeXrN7KqQEUlTsgxIBl6qVsR +7CAYVo5aLbhl6e0LurSqeiaDFbtBh2YRlVzPn2ChLhmgavsohSLyqsyJCxM2Y3QHd32c1sANXkMw +w3NM3F1iKZdJrJRlhqwhtx7PhigLi+ZvX9sRtzCc6iDoFMgeKWxIo6M2ARfForbo3eIFv2C4sDGY +EvulWGVYZQmByCk3F4cMl8WP03Kz+17Gbo5VJiGZhPcbMIZgWrnRUopEDI54r8mXqFyGAZlzSYq0 +DW3xcHbMA1YPFAoYQQcv7PAcsK6odaQNBQpUmSbU9ra+X4b1Ag+QRz/5+u92794fX33z/tXbNy/e +/fXm5wD66X/72c3fffX+3as339389Ks/v/j+5f71S6o3/eff/fX7lz+7+T+w0f7BRr84cpP/E/7i +Pvr9RDVp0ZuKBYhA06Ly6KCgUrnahaLKruB40ILeifcppB2U68qShazZ+w3Yslfm2YRFNc8SMC8U +FfIE1OHj5JGhLdUHKSPSDpP36+gpGOetiISOdObDeiMBAmQEnVhr63tlWC9wAEePTucWqvALP8xU +SB6MmkBF0JeYQXlHvuKOz/pBCXTfZOJC6cZczqZD1KRV3m/AUsaECeZdHDlGp/G4c7BbVQdU7s6J +xaBrixlcYd1g7UChgBF08GI5pQ7rzOcTRgoEqOxVaq2t75dhvcADYW/Aa5uwtjKosXqlBF95A+Zu +JK5GvWsoUhI6Vlelu+mMu6D4CmaqunK/AWPdJXMccb1YnHrVdphWcuywb8RvBSrfOraUkogjyg6U +1ytrFRy4BNuIdGZX8vh+ASprlVRr6ztlWC8wQFg7YwVrvF5gxbuC6L6EHOmaETA/Kqmv0a50wMsR +EJKd+so+qirzJovx5KGSJcn0go2rq1qLqsr66kBlbihz3LTFZR2WDdYOZAK6WGFo4KDAiHTmU9oj +AQJU5iqx1tZ3y7Cec4B5C2ZnWypdlzEHugoDtO4W6ZoXUOzJIsDQ6ZLosoSU+ZIvtBE6a8G0EsQR +D63eb8DJIrlYULiQqtCkHgp3rRTeMQXIXUMvp857a4trLsQN1g4UCnRwFBz4lM2IdcEDiVsKBKjM +VWqtre+XYb3AA+EuJg6hhI2N1C20rhrmddCdFJHuJkv+ErLCctc4i3cjMtaASXL3G7CUxmZaudwo +TTpJNECdUywWASpnU43Lpm2UIn4D1g4UCmzaCziwG3LEunABs5ECASpnlVpr6/tlWC/wQDi70Nk/ +ki2xUgV70HnWOtzyw9PUXftR7eoU2VJLbYwarxBmQ2gAa+UndNSnVcy8KMXxZqwxpZYJAZW9Yq/7 +tpggoxaPYfVAokARKDjcRgs1KNKlB1A6AQJU7iqxrm3vVkd6xgFmbl7XShewLXkJJA== + + + HWbQTkfeBpEFFd0GdMmSXaEjcinr25qW5vfgaJnzM6oki4h9rWAzy4rrQDVAylrzpi3Geed1g7UD +hQIbHANrdofDGjTQ7AhgmLJWae0tfV8N5RkDkLULa7g5BdYVzq/76QzWq4n63VrsmDEGl6T4a1uM +vwrF2Pms9K3ie4m3cooFy7IXDzPzTmwM35LvdBhQdiC/XT/eoRqocDj7vOtvZ5jyVun0M7R301Bu ++/6F5snucebJ78W7t6h3D/75dipyrciPV/O2DT7EZxTTBUVdZA+ZjvcbcOnhWzxrwXrsahmwVpbR +gMRvywLwbbFuXiwbrA6YnE3rwIHTL0eseOFI3VIgQKagU+va9n45rGc8IEn15QYjVSVMTJrkI95v +wIGT/amCI1v7mE3brLjlHFcH1I5xYv/QFj2XqXmUHSLv5k93cOE80hFlvUU/xub1AtSRVVJ7W9ej +jvW899cyFjmfZZbOUVjyfgMO6LvS8pqAQzYyrfgCnYOXNgdU3pY1L5u2SQ7LD1g7UChQ9iq4V1xz +WKudmHUUCJARdGp7W9cvV8ftjAdXMhYpLyebj8aikA6MSkRQ7ibKg0KOgY6mU2dJ0QOVu+hO27TF +2GbLG6wdKBQodxXcK3c6rMXKPTkKBKjcVWpd294vh/WMB9eyF5EIcrGu7ESRueugcoyEgd3nXENW +7nJhVQMqd1vUuWttsxxQGLB2IBOgn1dor0zukBa7SckRIEBlrhLr2vZuOaxbDlzJXuQssUU1YaxN +eL8BB84ReSaFf9Uwa1WWapELpQzIXaMSUsumLZ4VjcsGawcKBcpcBScruuiwZktychQIkBF0al3b +3i+H9YwHV7AX6f11lSGrUVMhHDhwWi4D46JA2j65X+K0V6BydhHZ6NriaVQFGtYOFAqUswrGSxhm +rVetWLMdf3EUCFA5q9S6tr1fDusZD65mL6K8ohw2ck9hAv/9Bhw4mYX70aLOuyQnRrFCd9ApTkBl +b1zm87ZzrssZVgUKBTbzBQy7jBwRdljx0E7YUiBARaDUura9Xw7rGQ+uZTHi/X9NnThUZOT+DKxX +aiAwVTU/et9go6wOqH1LUYfHte1RTYe1A4kCGx4DW/Zlx5q6EtIpSF5h6dQObXu/HNYND65rNOJO +0ZqMHp0AuD8Duxrzi/kmcGyFFUUN7aruCrq5cV62LWsI4QxlB9Lr9fMdrGcrHNJh/uv7BWjyyfwl +1tZ3yrCeMeAbzgP5N4htfch0ZEPmX8V6jNkiG956dODC+QXPuFg0nZfyUS4sO9yiD5MR07E2LGUp ++bZJnPkDVgf01qMDB4s7O6xydmukQIBsfnZqXdver+AriW94IIriFxmOdAuRJkzgBni/AWMyQtHS +3HwSApnlykx3DhJQGcsVo3xbLG278r7YsTqgUMAIOjhoWp1DutgRFUeAAJWvSqxr27tlSM85cD3j +ERWoIn5+KohyvwFn8vwwuY0qBSG/7OgHKFiS8yFA7lrDMpNpbIsnakpoA1IHk/fr2CjY8p890sUS +/hwBAlTeKrGube+Vw3rGgWuZjlh9PgU13Ira5R2Kl5IkXk2VU19p2lkN7VXOpxlQecu39vm2uJ6T +8laxOiATYAIlKW/1YJNDCgbTKpdOdAIEyAR0Yl3b3i2HdcuBq9mNsWjOCd5qmpfOXAXnfrqo8kFV +XtOrMZfPCRpQmcvngYe2TU62DFg7UChQBAoOvki7Yg12JtpRIEDlrlLr2vZ+OaxnPLiW6Yg3HEjw +PnJ27/0GjHcFsvMHLyiIajJosh3dLjAAuW8rbrtx05YuZ1k3WDtQKLC5PytzWtN3KdLAkauRgOAC +ao5Y17Z3qyM948A1DEeUSvOsIS88NXS/ASd/mQNfkEqTTjKZ8XqGFhYHVL7yqcChLVZaVL4a1g4U +ChRBB2vJZocV4y1l3VAgQGWsUuva+u4a1jMeXM1wxKXTg1bzrJtZBye7ahYv0KCDIZxPOit7a1U/ +MQGVO3xjyNAWNp6i7DWsHSgUKIIO1uROh5WON6UNBQJU9iq1Q9veXcN6xoNrGY505UiQJZFt7nqo +KTFVEzORsphVDPP1qwbUrlXJwhjacs2nDdYOzGtnTYfqLQ0dJ9bmMKC+X4D6eaV1aNt7tV6AZZu3 +VzAXkdzc1Bwtpil4sJ6iwV7QIaXNoOc0+5lgsybM6awtXx+3wdqB46o2sFZtGrDWFs4IqK2zttPa +W/ZOOZQbBrC5+DFj7l/DjqOD+jofuh3nwL30Oxb2X4uYbFotLNGtYs0BiRkZq4LWNrbN6OZXXc4V +lFegt+McuGtYDmtPBnEU+GQQR61r2/vljrmf8eAKdhwgXau6crCQ0P0G6m6tWHG7kMCP3ZqBJ6TX +6IDK1zmkNrbN6D9dwojVAZkAZatCg17X5nBaRrN/vwCZq51W17b3ypCe9f9qRhxee7HocEWsq3W/ +Aff7RrE+Rm4yj7VuEN3YkFYHZNbMcoWxb5sX26E6VgcUCnRs+m5GRbxGrAvXOBgpEKAyV6l1bXu/ +OtZzHlzLjMO7QnJRt+LcjLkKxdTOKLwNKelxgoW9nYlqHEUHVN6qctXb4moOGn0TpA7GrzdpItBo +dYAczmB34bn3C1A5q7S6tr1THetZ/69mxOHNKk3HjIq93m/AmQtyML0xakRO72qEvlE5lw5U3i4p +b9oCkE7eDlgdUChQBAqOdjOLwxrsKgFHgQCVu0qta9v71bGe8+BaRhxWvYlZDVRVhgcolYJlctOi +kXopdktXvuTYYdyxJmdiXUuadur1U5QD0BRhB8WD/FZ2SHEGv4fp64Pfwzqlrm3vk8O67f41DDgS +9jqEdC7yfgPuJ8epapHm4GrOMXQLVMLqgMpWOpaybUt3EI1YO1AoUAQdrJeCOKzBioM7CgSojFVq +XVvfXcN6xoOrGXC4bBYdyIpXiN1vwMlUViSYCgchUE8JArCFNTigcieUsmzaNtNZHdY2KLLqqh3A +fu0L1tA3p05BGDcypXZo27trWM94cC0DDmmgujWc9h/65HXgueo1Ulx0kYydaCxfgzpFCKh9a1XD +/Na24b1ccYN1AJp1O4C1yOWAde03YXUKVotsDdS6tr1fDuuGB1ez4rB0WdOBg9Hqk7eDqaSpAItF +6PrIV9FE47iXlHU+b8uXUG+wdiBRYAgMLIXoB6RrLWfvR5h+upPqWlqfOsZN9//9bLgMImpdk7Nf +7jdguRbvGVcOlP5Vq02DtQstQNfPBmJNxNzqpm10R64VqwN6G86BpVzaiHXhEoAjBQLkDbRT29u6 +fnWs5zy4gg2H1+Ksi/hQktU3ceBssX+8ZSX0XLSml4lwjQwDMl8WKRM1tMXjt3MasTqgUKAjo2Cr +OuSQhs7sTkDoB+Q9scGzULtlSM85cDUzLvcwYeLTefcbcHaVMWMrYj0kLb+BVVrn1QGVt3ykf2gb +7EC0IXWw5A4NOnDs9wh0pMGqjTkCBGi8bdu2rlcd6zkHrmXEYXnP0tSIycZZBWa+SJipTcUiwHZd +Doxq6zBlLFe79y2xrHDYoHRAermyVYFdt3IoMSdbysX0twtQ2aqE9rauSx3rtvNXM+DwMic7mENl +9+434MylTp/J5UZNQ8p6vwJK8WVxQOUsF6oa2lKdxjZidUChQBEo2KqAOqRYy8WK1CoBAlTeKrG9 +reuWIT3nwLXMN7zlypLNSCLdn4EliJ6bM5ij7R8w/RyM+YKHFzWury0XudjaYRxgXUo6cLSi7g5n +4Dsnx9cL0PjaShjbui51rOfdv4b9RtWDLdt3nXston4mL8vdHXifV4mLzrdZ2brUJTmg8pWK845t +F6wcEkesDigUKGc7WIuXOay9ZKujIPSCD57a3nbormI958HV7LfcvXiR71W934DRN9eUDLVti93z +Na/L0mHK2mQ5k70lFVMeEDqgvFw/38F0eeqItFfrdO8XoHJWDWttOfRTcZ53/lqGG44tlbAkzLMe +oBzB1Wpd0XE9Ht202HVxTTX7fkavzC7JVNuiREwq5RTrCJw1I3EAq4N4wFpyC2cUENB4a9S6tr1f +5nY+48HVDDesGRb1QD6Fd+/PwFo1E4G2B7iR7yFtAmrnWtQkSN+2tHqGtQN73HkA222/HqvJyv7+ +1kVtp9Ta9R45fJveP8ZuW/71EikL+lqc2XI/ALPW/KM7CVZxtvNOZnekCIj4UPVuNtdug2k0kgyC +4VG+EtDhwEr5y+ZlDONPdqqspdHeEW77eK1DdoC3WKoDXdp8vwFnSxlDUtcsim5KTa+VKC16IHcL +b97TIIa1jVwqccTagUKBjoKCe0DfYQ12Ca2jQIDGWKG2t3X96ljPeXA1C63gWtGBi3akxoHxxiO5 +IwWLcEQtWZHs2o+yWHmcpN5bvOJkVqvY2kqF1BFrBwoFyl4FR7viymENeiGpI4Bhylyl1Vq6TnWU +5wy4loGGN4RYfbeg56wdNOMJP71hRH1X/RJ0vDslOZDyNc0a87GWeAS/hg3ODkxuNXdoHG6ZmdUc +o3ue/esFZGxdLZdXWroudZxnvb+aiVZxdqsSSmL5/gzcJJBTZ7kEnBd00cukUonNAZW1VLxibBts +O3dYPZAoUAR9609yjMxhDVYo11EgQOWuUuva9n45rGc8uJaRVkk6q/mHid/3Z2CjoYfN7RKiBetW +BAcU1myaBS576tF5EL3YJnxTr0oWG1kn8Kz3V/W3CtD4KRS6tr0nDuFZr69hm+FtcEEL2cxFbbMB +7PYuvl+bJppci4j9WtSKsxqTtFE3DRRZ24B3h2yxeiBRoExVcFfZHNZ+lYSjQIDKWaXWte39cljP +eHA12ww30Bo1o3VV1cCBU7+nDQiWakfJcjzwximUYR2o7IVBP2+7tpw3WDtQKFAEHeyvwhKsWF0w +hQ0FAjT2lrO2vruG9YwH1zLRSBipq5hSDu434NQ3dqytWI05UacO1bXqQGUObOztrG1uWm7IqRYK +jC4XYgCL+eyQRs5pHAkQoDJXiXVtfW8V6RkHrnumbhhlTMm8P4M2ueqGbmEz71WKuot07wIBlT9L +W+tZ216fxbB64Bo7fzuUKuOOSIcp3d0LBDQGm0/NTdTeLcO65cAXn6l7ZEGWD5mCv/83q88CzIMV +sG5P2HmwVVKZa7OYp9VcmStmqbKa5uqzzJVu1l03baOr4mFYo6viYeaiB1slFY/Vaq54Clx9Fk9t +b+v61bGe8+BKpuNcMeJi0R+tz+LBXEwFO7ZKbpPVXMGOaQTe1WfBjuUwtlwXKSVtCB3EVWfxYKuj +0hFavRX/alebxZPp2vbeOJxnPb9aIc+Kd+KoNWy1WTzYqqjMlS6vl/xSOb6MnYNvvgiL8jXKntnb +rrNcU+mxOqCrzeLBVkXFY7V6K54CV5vFU+va9n45rGc8uFYhTxjiHOx4mdZm8WCrooL0llnL+kq9 +Fewb38Q61GZBPoQ6tlx9nEhxOqCrzOLBVkOl47RaK/7tri6Lp9S17X1yOM/6f7U6ng== + + + Fat+a56M1mXxUKuggsC2rpoAzbVWACce928OqJzVHMredp211rrD6oC9LouHWgUVj9RqrXgCXF0W +T6xr27vlsG45cK06nhXv4FhVj1AnkgdbBRWcInyVkKu1gl3TCqOuLguyYQ6bls3V2zOc3mlmVVk8 +2OqndJxWZ8W/3dVk8ZS6tr1PDudZ/69RwxPfP6vhbzVZPNiqpyCwWnBS6qxgvzSj2tVkQbBaJ64t +CMqsFfQMawe6miwebNVTPFYz8z0FzhvgqXVte78c1jMeXMt6pF2gG2lak8WDrSIEzZCks07qrCBQ +Dxi7miwIrnXTsrlCyIaz+aLJWpHFg612SsdpNVb82109Fk+pa1ud7Wo4z/p/JcuRSLOStlaPZQRL +5RQEghz3pVcEuDZfpEX7Vixd3bUta2tnWDvQ6rGMYKmc4rGmrqR0CpJXUjq1Q9veL4d1w4Or2o40 +TVatsWL1WEawFE9BWuTmg6ZVVmhGLRq90Hos1L+wbdfLrjqEHWjVWEaw1E3pKIfVpO92tVg8meMq +Wft1HyWfAf+XqMUyY5jClnC3FB3YqqbMZbXK3lZfBVaGTUhXi2XGG77mlDdto9yPPGDtQG8pOrBV +TfFYrb6Kp8DVYvHUurbNSWHDesaDL8//RKRy/0dztVg82KqmIKn9hgepr4Ld6hy0WiwzXcqm9TWt +Ld5MrYa9Ye1AV4vFg7Vsikdq9VU8Aa4WiyfWte3d6kjPOHA1Y7FgDqp6F6wWiwdr2RQkd5GzzFZf +ZaZb95bggNy1jKtp2xYMhn6VhCDtMFeLxYP7XZQOqdVX8QS4WiyeWNe298phPePAtUzF0vxVK3LC +2kOtagqSO+foy65w1/iS6KEWC7JB67y5trCeo8ZwDGsH9losHmqnbz1Sq6/iCXC1WDyxrm3vlsO6 +5cDVbEWgoVr2nNVi8WCrmjLj9ZKpjLVYsG8t67lJq8WCfAB9KW3aZrk1fsDaga4Wiwdb1RSP1eqr +eApcLRZPrWvb++WwnvHgWuYiYE5y24erxeLBVjUF6V3lrKfVV0HgXJdtLRbsshoLrm3GO7fDBmsH +ulosHqxlUzxSq6/iCXC1WDyxrm3vVkd6xoFrGIwolaqVG9RaLB5sVVOQ1Cq3dFl9FQQu6+qLrihf +S1Lvj7UtYDRbEFOxdqCrxTKCpWqKx2r1VTwFrhaLp9a19d01rGc8uJrBiKNrtV+tFosH9xsDC96H +NpsD1qYtDGFwQOVOk9r3rm1hr/mItQNdLZYRHIO1VayRLcqRAgEqe5XaoW3vrmE948G1jEakYTZD +w+auh7YcVCbkEK00thKWQj+Q0BdkXDRQ3luGqJPRoezAbPPWQ8OSdYoqTi2E4N/OMP240ulb9g45 +lGPfr5UISsQGu9+imJbgwXJQlDphZqLerIh9iK04oM2YrHmcrm3NdmK3Y+3AcUUbWIqmjFi5uspI +gNZhGWntLXunHMoNA/7dzvDNeBYo6cmKbsM5sFVMmTPsME1NDamtAksK7+D1QGJGjnae0bXFCJvq +cYa1A70N58Bdu3JY+0U7jgJXh8VT69r2fjmsZzy4gg2HJ9jkirxeh8VDrWIKUTprkEdqq2Cvshwg +d3VY5ox6j8bmrG2wK0Ed1g7sdVg81Na/w9lvlnTvd3VYPK2ube9VR7rt/9UMuIx3p0fdm7QOiwdb +xZQ5Y4HKWZRbSXLHrpVoN8tpHRZkQ49wW9tou5PDGv2mqXVYPNgqpnisVlvFU+DqsHhqXdveL4f1 +jAfXMuEAcw1aUULrsHiolkxBajVL1WqrYM9q1MiP1WFBLqhi5dpGVx1dkXZYr8PioVYxxeO02ir+ +/a4Oi6fVte2dcli3/b+aAQeY06oqgtVh8WCrmIL01qRar9RWwb7pDXCuDgvyoUUdG2sLr2h6VMqw +dqCrw+LBVjHFY7XaKp4CV4fFU+va9n45rGc8uJYBB5i10k6vwzJCpWgKkltK0Ns3ZuVtS2p7aB0W +hFJoYmiZLIvEofRAU4Id1CqmeJzB72H6+uD3sE6pa9v75LBuu38N442EvWYCWh0WD7aKKUhqruox +0FsaM1am1cpBVoeF9pagPgtriz/aXYiKtQNdHZYRLOdvPVarreIpcHVYPLWure+uYT3jwdWMN1w2 +RZMGrQ7LCIZertKPXoxf0oYRuEgFutRTjGmVLhoLtbbZ6ayGNQ+KrLppB7BYtg5pNPeiIyA6V6Qj +dmjbu6VIzzhwLdMNBzio9LEqLB4MrFmqClu9dgr9oTEIMGQ9gxE0EZF6PFuavbbNWPJv3WDtQFeF +ZQTT2Y4Ra+zbU6cgjluZUju07d11WDc8uJoNh7StmuJrVVhGsNRLQaAWT4x9dyhWUDyOO0ls7bxt +L2flsHagVWEZwVwzZUS62pj392sVlpHU3rL3qWPcdP/fz4JLBc98+mzJ+w3Y6qWAwg2LWKtjSmUV +EG4uNGdVWOYUTBl1bUHpB4t1g7UDvQXnwFYvxWO1yiqeAleFxVPr2vZ+OaxnPLiCBZeKFcJ3VVg8 +2OqlIKk1z5ZNxm4G6FbKzQO5WxFvV9+2xYu8tTSZYe1AV4XFg7VgikcaOls6Aa4Kiyc2eBZqtzrS +Mw5czYhLPUDoqrB4sBZMQXJLv9uDK6tg13Jq0QGVt2nRO+ytLR7X0dCeIu0wV4XFg61eikdqlVU8 +Aa4KiyfWte29cljPOHAtEw4wp0Vv7FXz2AGtZApRK0FHra2CHStRS5eakZGiXeLbW+Ll0xrdNJQd +aFVYPLBrVg6lVVbxb3dVWDyhrm3vksO66fzVzLeEqbh6g4VVYfFgq5eC5OasUR+prIJd61cJWhUW +ZINeE+/a0u3QdYO1A10VFg/WgikeqVVW8QS4KiyeWNe2d6sjPePAtYw3wDz3Wx60CssIlvB5ys5c +jrZ/rHafWrTtA4jMcR1b4uGPXEeMHuakZAdbvRSP0yqr+Ne7KiyeUte2d8lhPev+Naw33D7l4gpX +hcWDrV4K0bpofWiprIL9avPqy60oX/txX2sbLePXYe1AV4VlBEu9FI/VKqt4ClwVFk+ta+u7a1jP +eHA16y11H56rwjKCq6Q+JzxarneKFT6aSJ1rGi8oeoyRJGCq+awtKDDrBqsHWikWD0ZXQFUExXIw +1WpwFCRnYThqXdveL4f1jAfXst9wiJNallaMxYOBilWFrSrj6AuNSm6vy0dA5c3abNPVtpiVauab +IO0wV4plBIOmY+u/2e3ja102BAhQedstB9e2d9awnnHgatYbEpG0rLWVYhnBclaWgEuPlXEkOGUX +0bZSLAROevbOt53V+nJYO9BKsYxgqSQwYm3l7P2ty9tOqbXrPXL4Nr3/9y3FMsfubvEWnANrEZU5 +otY5lFmZY7TT0FaOZY6o2A9lW2BiWIJqR9dh3nJzYCum4lFqzRX/7l6dxRPZW3qXkqE86/i1jtlF +vPw2aP6iVmjxYKulguSmpnlRUnWFeian912FFmSCnsl3bfGkv2p7hrUDXYUWD7ZaKh6rVV3xFLgK +LZ5a17b3y2E948HVrLeYnbfZKrR4sNVSIYItF02OUWPnUtECOFahBRmRqlrM1nZBDXPZYO1AV6HF +g62ciseqdVc8Ab1Ci6e1t8zO3W4ozxhwLeMt5k2JlPsN1KqpILXq17K6K9ixLjWsRgvyoFQ9M2ht +l/O6Lx6Y3JpezuupeKRWecUT4Kq0eGJd23xe+eWcA1cz4SKmKuspdKvSMoKlngrR20vwS3AwdpvA +VWlBPqxVK5xa2+DUEsPqgValxYOtnorHapVXPAWuSoun1rXt/XJYz3hwLSMOMK92WMqqtIxgo6EH +1fWsVSQftS/dwj2Lbtuytrg6VY0zbnWQlWrxYKus4nFaDRb/flevxdPq2vY+Oaxn/b+GFQdYQcfY +1msZwW4nC3kd67Vgv7SCmqvXguBQN/VaaMrhuhmxeqDVa/Hgrtc5rFaDxVPg6rV4al3b3i+H9YwH +V7PiUFeZ1c9h9Vo82CqrEMGLJlBqLkhExVIvpbB6LbS/WAKla6t3xDusHejqtYxgrYzgsFoNFk+B +q9fiqXVtfXcN6xkPrmXFkViyVEmt1+LBqW/z6FMKuqVyDRbsW7MUSqvXQmt11TumXNu0al0hr2is +WlWo50wMYC6t4pFaDRZPgKvX4ol1bX1vFekZB6575m4YZa3XMkKlsgrR3P1cXIOF+mcuAKvXQnPK +tFfXFgyAssHqgRYmHaBSWcUjHaa084Iszobo58LdRO3dMqxbDvyHrNfijuF96aifFWzBW5DUiKO5 +eL8BZ/YfABC3y7lq7Qm5m3mOlhMoQByCZYH9bpnj2HZpWLsj/P/svety5Ma1JvoEfIf6owh7xwaN +vABIbP0SKdvjc2jLYdkzijgx0UGx2RJHvPSw2ba1n/6s71uZQAIokkB1k6xilxQSCwvI+8qV656D +WnNg7MHxgYL7g4PgkxG4y/lijDDuNkRrY7pGZNAxAokbjFNLHYvflgGJBJLHakKYDJh1bM2MnQjO +oBcekg9eBKNBhldpJlSgDbgXVLgrHYhNoRkCZky5Aq36QgUk79eL6soWCeNYL/gFG7MilTBbUooI +laap10FHJ/mA0elFFyWytNiY44W+VjoTAZuzS4ukThUwcjVN8mN0qivE+1BxyLhLKwWGw8/QYgi2 +NEr6FVhXyJVkpS9J4GJoDvLEAMi9dxwr0BsKbImjWTihE4JxixdWzpa244g1UiMqmaktxMjKzsUJ +HFJKRFq6dLmizELKqS3zVbcKjCp3nVurkbvB9SGcQKhoaJZ1iIo2LGS0LgVkADJMQzVd9GNiA8Zm +lW+R9WXPr+LYom1FwPSR1W+NJqEMoPMqSoFjVFFIEFHYwEhc284OE1o5Wz3xl/ldOg9Fvdm3LLtw +ySpLP1jWMfIEi1bHG85kvBX1jVgIV2syLUHGyjZxJeWsThsTTgsmLpqHS2nC57L2XLQ6YqJwTEFx +JumB5WdrkozvQZLSnmytT0lmW9Vrtl3Kn4CLz5VRR/CspVgTak1ZcxZnFXZCXduUD6AtNRmETnWp +zDfm36QdRiw4Xr9aJzwI2o4kf/XNn8Kb31+/Pbr9+OFnIed357fXAFYAvvnLzfVfhebfCdkvCgUf +nf90cZ2/OPjLe7wxpb76/n/+8Q8Xl1LNwe+6n3LO/O6HP5/85ebtOX4ODqB7X3y9+s2/ry6v5VUh +3bq9+PHj3fkHHDVyht2ejr44+/ni8u3t+TXe29Xv/nR917/D/+7iSfab8is5yP5xfXEmwHSe5R/+ +8/Tyo37574c/vD694nfoBHu1reP4dfY4fn2Bcch+nj2Sf128vft59mji11s9op/PL376+W72kNLn +zz6mmx//z/nZ3dHNx+u30r+jm0f2Rj/Ad9z/8undh9mjHJR59qF+86c331y+//n0jZk7xou3GW98 +z5jwzX/O6PG2kMm7j7c/fhQO/+x87ixo0ZlLnNp5bqIpwvrc8fx4+uH8D7fn//ejTA== + + + wnwSOir17CO8vvn+7uLu7BEq2Y/yA7/++8Xl+fz9OSjz7CO0c4d2/fHqu7O7038uGFle5NkHhi03 +d2y35x8+Xs4/N9LncyjQPV03D3R9PfXLDoHzv+fk5OHOPjDvz7wgF9dzl+Pm/fnt6d3N7ewF6Qs8 +O5p9f/Px9uz8j7en73++OJt9xD0yFflJd73le+fi+hESMhiMfcFdc3xz9f7mw8XdnE3zFB0gH/Zo +27/79vzd6uu9tLcd49hLe9s7or20t2aUWyLt+S9Z2nt3eyps7+Vfbi4+vDJ5b7YQvxf3tlPcm70v +9+LeXtzbi3uTUe3Fvb2498WIe4V9LQLfkpFsucjnX53It2BEuyLyiRx0dP7P88vvfz59e/OvL9v2 +pUcmxcLXcmD+ePnxEW7lMzCb2yoZfLh7++35Py9O0aEFUk9e6MV4gj+efvzw4eL0+kgXcFd46dlr +83b+Mfz2Jc7h+QOZfwq/fYljeAkF2HZqdvPu3Yfzu6PnoGkvtO2/4wh3aMNfgm+Bl+DZzeXN7X/9 +62cVY2bS518v56sS49f7DfQJY/nw/vzsu4+P7Ifd4whm+/Z8+Hj77vTs/Puz0yWINyj0/FLH7MHJ +4n68PL09vrn+cHd6PX/dpgVfwJq2dJS///f7m+vzDUbZF9wl2aSoynL2HG25isOUC8ay3UqOwi4Z +y3/PHst/vyAP8tebi+u7k6i+eAl95Pn3caueROZih/ih12lMWMg3bDsbtJGiZ7E1YbvXaNckoyVG +km0hBqe3F3c/X53fzTfA7RJRmH3s/fKIMiUbDj7d4oE8wovnAzHbLCr84uYPxG31QOZT5V9egii/ +Siv8Ym5g24/Oy4u7v55ePCZLfuFn5+7IysvVxIt33Ast5J/Pb386x0zuEBO0dHO9xrV4ug7sXYY2 +Vqh99UrUaQu8UrZbmWbM3mNo+z2GvqwgkeObm8uj2/Pz/55t1XyNnlFvLy5P59t1d0mJYQ5nx5Xf +nr69+DgfddPnu6Hd3G6Jc/5A3s4fyNttHsiuiZh/vrl9//PN5c1Pv+6QaLInaztE1l4NMZsfwbLl +xOzVhrHtJDErXo/L6qvZ6cvCKbZ5q88eya7t9Z3zuH29MfuzWZZ9zP59Y3zZmP3Zfri7FrO/gJBv ++5E0e5Nt/ZE0X8LZsSNpJ7MoPOJRkpG1Zc73L+R1/0Xu+K131PhxNpZtPfWaPZJdCcL522xz6vHP +p9fX55ffn1+eny3Rp00LPr9FaLalddNBTgu+2Dn07cWH95enZ+dX59d3fz59v0OH0dWpVDXbMLkT +0tEq/bua/DSDn3NHzV/z+e/0+RZTyq0/iZflGtzm02v2SHaN9z5GGPOfE/nYFXq3ALO2fY/M1iFs +/R6ZPZJd4fDmRyI/T+KVbdl97xb5B727uLxc4v90uc0r/e725mr+YPjx82slH2FyMsPYYx7juWXs +44vEXM0ey4+4k2u+bly/fn6j/uW/Tn+dPSahfHent4sopX6/vZrwu5v5ksfNCwzk9pwi4NzhnL59 +e3F38c/54lRf4AXsMdfzx3V29vHq4+PeQvnIsiIvENF0fX46O/zl7PTy7M83b+ePrS/w/MFns3mL +bPVS83/hEOYu4LDUC4kkp9cXV6cvlhp2V/PQFWHvDLNlkt3Zq3GGmT+SXdN+7J1htkXdu7+wcKJT +2DVvmPk5zXbNHWYBKd/2Q+nVuMPMH8muHUo76Q4zm//cDXeYL3LHb707zNmrcYeZP5JdMZbs3WH2 +7jDbchh9Ae4w5ktxh1lA87f9JH417jDzR7JrvPduusMswKxt3yOvxh1m/kh2hcPbNneYrbb/7I43 +z4Itt5R4vNAa7mLWwAV+gPtVeLJVeLqcGzuwCE/XgRdqfPeTNn7zpzffMmfPm2War1kM0e4cUa83 +b9F8NeCOZC16ngTgL0VNl+TJ2VO0hylavador5GizV7WPUXbU7RXQtF+fyuAL5tFO8cUvEZ6tufQ +9vTsy6RnXzSD9mrp2Z4/29OzL42e5UadN8us8K+MrM0e/Bdkw9tvmznbpvmSt83swe+3zRe+bb6s +24L+evHv88u/Xp7++mZZsOM2OuxU5aqa7T2pM/+3BQ6UWYldony351c3j6U32LFcL/Nziuzzo+zz +o3wmpFuZr225MpX8v1zJf1/Lb/n7tbxYvTaX7Yvrt+fvLq4v5hu4bs/fn5/efbtgu2Ulnn18+xwx +Oq4dyxHz4T2yxMwd3S7liJnJjXxpCWK2hYd6hRcU/rjksvEt99RfMpZd8dXfKyy2lxw8trd30660 +iCJsOXXb0KS09eHzN1fvbz4IW/7dx0dI2C4H8MUx7hBBOL29uPv56vxuPq7tEmGYrVP75RHjVDYc +fLrFA3lEGZoPxLyEMmL2QB5xfsoH4rZ6IPNJ8y+7Qpl34xBdKPXs0hH6arMifpYzdHdMHBut6c44 +EO0DAPfm5N0zJy9LU7iNWqW9OXndrOzNyXtz8jOO57Wak0lcYFC25deLCM3ehLw3Ie9NyPtrRiYj +25uQ13R3e1TEexPy3oS8NyF/fu3EjpqQX5Ox9e3Fu3cf599msu2kYOFwdoUazE5P9+Hj7TvhbL9f +luZ/UGh77Ug6/cvGNijz7EP79fzy8uZfc8d3efHTz3fyvjhDHtzZQxwX294FjLvz+OZaRPfr+ftu +Um6vdHtRpdv+jtvHR7NXuj0FKf36p9vz8+uvhQM7//ri+u3FTzdf//Pi5vL87uvb87df39yeXv80 +e6vttXF7bdxeG7fXxq0Z2Xw+bK+SexmuyoTZVpfT/764+nj3yNWP+ZKk758d8erZYzq/lIdFKp+s +xIvpe769IP9+gv31Uh4x36oscRL3+A6h/GtSO314f34mB9ftc/jCP7t09KqVNbNJVFrixdL+tOA2 +r2Hs7O///V54vQ1G2Rd8Acb7EW3uE6im9nqbvd5mr7f5gvQ2UUujepuoxKH6Zq+32ett9nqbvd5m +r7fZ6212XG9zGRUar8KFYq+Eenol1PdR+NtBLdTrzJ+xgT5q21VsrzIC+Dn1hi9En/Y5NLaNOLya +HBrzMzZseQ6N+Suy5Tk05g9ky3NoPM89INvtTbz9x+flxd1fTy8es1Lsz8792bk/OzceyJafnfv8 +U9t2di6lytt+bG4kTO/K0bnPO/Vpc78tx+7i9dznnFrSgRdqfJ9zardyTn3/8+nbm389xf1Fu0OJ +vvDsArvi1zk7Kdo+Iv/Zt9DsizXfPkJOc7e2f78Aks0fyK/zB/LrllOAbadmN+/efTi/w5a4PX+7 +iE7vmgzwHUf6ZQgAm6/qa5QEtmVVXvd94nvRbJdFs8JUX81Fyfl8xkuwGUtGMp/ReAk+w/hy9kj+ +dfF2gTth/Pr5R+Tmj+jn88c9D7Mhpc+fn4P6EpUaT5BFe3e4q71SYyeUGvVeqbG1rHB4LUqN+QPZ +KzV2QPzdKzW299jdKzW2kZLvlRp7pca2KjW+MNHs7nSBo+VrFMze3Z6e3Z1e/uXmYr5jsxaeucap +pef2zzycnbPlx9MP53+4Pf+/H8+vz+ZznKNSLxCT/v3dxd3ZIwqsXGLD13+/uFyQK2FQ5vk1X7N9 +bK8/Xn0nWPzPBUPLizz7yM6ezsvsuUeyTKu1xXHO80fyhALPtpwKry/Z0YLz4N3tzdX84fDjZx/O +a0rd9FpTHZWHs29tubuZz0/dvMBQ9rmLBoPb5y7a5y56YtXyfJnkS0td9CRKo79/vP3x46VM9i7p +EV9n7pUFIsWWC0fPk3LlhfS8S+LD9qrWtfzhV6/De2z+OLbcd6x8db5jC0a09x1bM8oXN1D0fMmb +R8LvX7eZ4i7nz16RkaLcWyludttKMdubadeMFNhyW6AS34t7r1vcW4Jme4FvL/DtBb69wLcX+PYC +3+sX+GaLBq9R4Hu9fmmzczrsJb7tlPhmL+Be4ttLfHuJ75PQbC/x7SW+HZb4CvNaZL4lI9lyqa96 +dVLfghHtpb41o3xxqe9/3dy8/en2dP55/xpFvld5Z8SiGPEtD5F4jRkvZgtz+4wXz04Q9mk8HxrI +PuPFJ3IYKQ/Eq6DN+/wdW0vG3l0Kd6eXEP/Xj5enZ798vVLQzfvTs4u7X/9rgU74w92vl/N13PHr +53fhXnLh8rbvrEWD2bXN9Acg4g7tpdepEV22X3biXN0s59C23/rzgakcj18TeftyGIddvA3wNTHc +S6/P3PKNs3A4u6IQme118uHj7bvTs/Pvz06XcKSDQs+vKV+2WsvGNijz7EP7188LovMvodWX98UM +ziMb4bjY9q5f3JzHN9cf7k4fu0ox16qMy+2SAt242Zv39L8vrj4uMG113z/7khPnXk2WoXp2Tqvz +S3lYpGzOSrwYj/XtBffNSTQyvoTXgPSBe/gkEqs9t7crt77uWaRdYpHSAi8+Y6cFX8BPfukof//v +9zfX5xuMsi/4hbCEe37p5fmlPbu0Z5fm9uH7SKh2kF96ndaADTinbWcGn8dNevvXaa8yf4Z0orcX +dz9fnS/I675LxGH2gfjLIz4F2XDw6fbKGb888mU+ELPVK/JIBp98IG6rBzKfMv/yEoT5VToSL7We +bf3xeXlx99fTi8ck6v3ZuT8792fnxgPZ8rNzPhOw5Wfn/IFs+dm5lCpv+7G5kTC9PzpfwdG5O3ro +/S2N28gLPTkl3IG1eLoO7BAivNZURPvks6NR7l4qotd7Rd5GFoPtZkX/vjiH9a7xbTuZZOnqVKqa +nV5iFwi7WZXx33W/OsjcIfPXfLKRPt+B/bXtFOOPUvTD485ju0swGEn157QBd4VivMKz6Vnjv7Y1 ++8I+xcfzJ0h7NTk+itnC1LYn+XgWRdQzj+m7LybKdefSY7xOJ77FrNvr3UHbb0+BvQEj+/srToC8 +i+4Im6zLtu+jfEyzwxp3hdU2h/Njo/bM9v5M+gx76Yd357d/uLjdBhXJtqzz3emP89d4FxSadjXb +zsGx/89lGstBmZdLxfXx+uxvO0RNXh2WHTarcvVl4Nkf93j2gnhmvhRydvRSLiYUdhB1/ffb0+sP +72bcIrE9+P469SGbsGrbzn5uGGeyC9oQHdqW8NV7fUhcGXrOfXN5uQVrsi1Tshmy7n01l3TghRpf +dP3TV9/8yZRvfn/9trsGCqAKkDd/ubn+q1TBNCWFgo/Of7q4zl8c/OU96/D66vtfr368uTz4zdHp +25/OV2ZVrP56cf3Lbw8+yr/l6ruD3qHmh1/l4f+RH/9HQP9a+dWfV//f/y5XbwX6w98OysOyLNuw +stVhU62uDgpzWHpTVxFQWHlfmXpl/WFVuQaA1tWtvHeHrq2b1dlB4Q6D8XZl7aErUcYf1t5KlebQ +NkGKVIe1M/JCAKXxHkWqw2CDl2/Kw7Y28k0tzVZVQ4Cr8GybOrTpWYo0hyZUre2+CIfWB89anXf1 +qmhRpDQANC6wZ6bERw26ZoyVZoz0qZIuCMC3rReADNC3TQdAIRlHE5rBN7XHkAXgKg== + + + S0BomlpH7AwLOZmu0rNxmU48t8Gx/640sj7GH1pMtAmHodIRCcib1qxMc1gZTIIAalfVK1MfGuvR +UIWuSCH8bVsWwjsZrn6LilHaEuBNQHfRQtWu2KIUlkLsha1W2isppN30ADQYfsGhWLvi0HTyBNS0 +FUGlbQy/sZUMW2a1tq1W4ppmxYlvOSSsuaxJc9i2VY1qS/lERlQf1g1xgzjg/Ao4YWufyjRNWBFt +XOpL41fAK1eiEHANCISVLx0LER9lCQQ/sdgF8NXLoIG+pemeS36sv4v+ZSxd9MVjE0XeRuxH0Xck +drXo+xrHQyQXdI+zzUEX+agxLUU/L3Hqinzu4vQW3fzGBSjyFeAqFfkyxaUs+rWMq110y51Qoshw +IuFN0SNORK2ixy3iXxt/tCFibe28iZ/7VAHmiVViMtgM5okN6zKzM9ak7oXY4dAkbKz6jaUDdTZu +R+6+It9+3KDFZBcX+TbmVq/yryI1KDpywNk3cT9EmkG6UnnClLAo5Qns+YA4FT11SvSr+yZRuKIj +cSSDddoDSgeBR8ZHxJJ1IarJ1MUZwKoAIX23C4KiiqCtZQeAyFwDaV9QWfG+WiWyHh/PDoj6bZsA +qMBjxlMFJOvcGl0rJOusMnYFnXWu6nuLEblmMCIZtuwU1w8bE9PwG50YzF0LFO7mDtMbXD+9sgBC +Dm1aAE/6EhKeuIBmsJSV6ZZSiBRWu0mrDZIpQ6yAZQkghWQcgbPdf1NXpo2o5Rulfm1I+IcypOt1 +j6NEY99vskTX4x5jO6TrfkCaa1ebfodhO4Wy21fAO91NLm0+txrtz0pPjsrkm1g7ETe6HrnSSZto +gdETCpuOI6txggypSsVvbBVMpDt6TnMzcHtUgYVAwOpEwUqeaw2XXmmcnu1Y956wE0uwKUksZWiK +RxHJnXHKQyQcrwwLER8jYW7r1ZB0N6uMrOcU30UGJWK2UGYl6F7PjMbrwB2IEluXgok/YfeEXA+O +Jnnm9DaujqeX5yCFjNc83nyjh70sHxG08kbbEDQMekSGlc611yO0blbTU3Z8EI9P6ulhPj7vxwxB +otk9yR6zFWO+Y8qajLmXEXejZLrJ+J8xizTmoaZs1pgTU+JcR1at1jltIy6iT6TLTRv5PfAYJtQd +wwiyErD8iaqQ7pjuPemStR3DSdJV5Txpom6JuCXyl6hfopA9gUxENNHQRGOHJFifjkec9snB0Y8H +ydP96GcRRH7zj2sIDW9XP92evr04F6nE+Pa3Uo2sjQn42wqeO/ncHfrGAQMyx3mzOvrpwFeHZS0k +CIAiPRTB1LLA2NhBVl2WWOjB0dXBO2n+6EjEhf/4iL41pREKVR6GYJ3MEyCyHEaHgUWWV5W89OiJ +qWpZqhKnfSMd+eE0jq5RRgyChMyzFbR0ESDtcjlw4DgKFILvxuqBY+WXzJA7rMuq1dPf1GAI49FS +SWNSSR2CniNNYzGjMpGhMcpRNEbO2hoELehJUgdf62Hj+udjOWysA5p1oHDoTOv0CBbeEIjnZHDa +suB8K4UEN53lSSjDkInCaeNKMOjY76BBOGxc/3zMs8bVPv+iqis9akwL8i4TAPwHoAw1y7jDyuq5 +J1xBrTSh1vHZsuY2bMkZYqeC4zrG3jbkhWQzyxGmZKHEmSa7vUT3hQ5I32ueNRYLeXyQXhX6sV9p +YT1aDHY2G6iVqZT9gt6xE+Bq2a2Kcha7WbDfJTd/GchlYmxoSCA8Xw0ZlpZfCFnXo6a2rKMqQe8x +65V12k4LRiVgAwfuaI/acNKIvMcd3TSohCjhsKpEEqFoctQIMSkpiwoGVThqBKc8jwPBMsqvjS+1 +oYiJBXCzrrkzPVoG6prQVAlQ4uP4s3vFwmbVlUX9OJ8iWnPsppYvux4Qkc2q6yLxeJUNAgOVRcjG +2Qq9wDwI5utUeb/KZoqzSdJZC2u5irPNyfZttxxcDdfqNCXEEiLAqU14xRVNaNUveoZVihfEHK9Y +JgcCcQpHSI9bfNOuOvQjglpFMVd3OMy2fKVoTzRnb7xZxW3QdRbdt36V7RPsJUd8M23NreScPqfN +6Nuw6vcidmvZAbCbTc2DhOQjTWi/30ETqHyIJAFEw7bsoSCVHjZy2qx6skLKowcmISBNguCrRJmw +yqAyPfECcUu0LRG+SPcSDvWUMVHPhLIdcSVt7Wgvn44PBghcKX53pcnLSgNW1leRFg0Ugy40cSPp +JmcXudmiQiaOoMAgvR7BHCSEIOvafl6ioFRnE1VwLr3tvxlPtpKCxmbrUYyXrBgtaTFZ82KEFMUY +aYopXhUjzCvGmFlMkbcY43cx3gBKd63J9kgx3kbFeJ8V061YjHdrMd7OxWDHWy00pAn8BJSYNMOb +dMopWalJuCiHtU29ShS4IGVyPWUqJrRLj+mmp25FTv48W84opBLgIieilbIOiciWIUqviQAXOXWO +b2PxoisfmyjyNmI/ir4jsatF31cdTpGPJw65yMfMWSn6aYlTV+RzF+e36Cc4PwPTEvTHpGvj9GVn +qan6M787bjuUyM7kDm+KHnEiahU9bkX8K3IElKnjKcvPo2bIyF6NqFhF7VFdDrgN7Yw3w+5VGc/S +basi31dx7xX55nMuQgYbuMh2cNzj/TegAo2PbBgWPpGKjFfr6EnH0HUkp5jQpYwx7IhX/1Wibx1/ +SQRpoqoiUUFgUSgzTlUxreNigYyuhSDf03PFWGt6dljR2pvILo/Y6eODP4iE8G3OZddQ1ksLwjLU +fJRmG+OSmiRUxOe6TZpaCymSRFuEKBdhpWreRZqIDPBodiKEZBvHgc2+wmpUrY6zGS9h0xFhxcHs +m8ZaJQ91iAivG0b3SaKpkELYmK8x8QIpm0a13aUqAWVeqHDjj7qOu0H4IRs/DyZWUGkFwUaOvTIh +NRx3n+Cwal4xJ6rXa4jdDTSUSfNb+VbntLFN3LSCIFZn3lOPUSnvinUJvgckAobf/btYvC8d28ib +iB3p+xG72vU0DicfTRxzN+Q0Ld2spLnLpw7vVCcQ5xelKx6GcQlcx8N36xRXk4tpdfNzvccokWFE +xJr0RcKrCfJluEcMbVz/TcLhhMIJzzM0x6RWgfXqXsC0iwC9snXGL5Ht7l+MC6FeSLx9vdJyMFFJ +UFK52VR951UJYbO+q8LfKESI6mj4k/kZTeBggk1c5cEajJdpvI7TpR5jwxhdphg1wjniZOhQcoq1 +nD4ZdELsEeJne2K8X1LJbkex8jrk2y42323N4eZtVsMNbrU/QyIwoROcnabOiUmaSN09zq7STHdE +ifX7AeXiesVDXxcM6+lcRwBVK91kNBIYUdv+C2BMU2XEt9NhdEhFrOPJEkEJKxNNT3ib0f2E2t3h +kNC+yDdEwR0xeDw5eHfwH/84+AeVVT+8PahXv/nt6of/NQV89casvnkvf0o5qL56063yVf8wXubB +KmcodIYiIywb4eAISVlihMhjRB9vBZSZbJfxdhptOJZBF4L2KNTsITXg6HAzoRkoMaYr99AifJrT +qSkRGxM6lhh1oBj1b0K4WWhK3icHwJrpmh4lk8Nm3cpMT63JsbYGA9YckOMTNOGYfj45fKfn8/gU +14LT037CEIy5htTBEXcx5UAmfEqa/jE/M+V5xpyRltTVLbrlTctfpPWfcH0sN+UOc+ZxsOW5mTLy +MKEdE/qCEuhHJ01JP9BRE/tZ11NqGbffiKZOqO6YMrPYeJYnCzE+BDik8UExPkjGZ00kKqMTaXxk +5Th4DT3+N9eI/RKKCE8coYhwx6EMA22eyCmNlxP9SkVmh84fVkEN+C38BuD3UDuYNgBwwIlKyLyJ +VnSRxWAuqQ8bkWoDv5EiAcqHSneWKX0l4nxbehe9EYwtoeZqfeVUdDMwrbVQL5YqahpIUXIUQQKJ +4iGNJqoZExlHZGEPsaSBxEpNgIqNGFYITg06JSwHMlNViQWGAaqy9AdydQstc3voDZ9bA8OgHH4y +wFARZ7GrDD5R9XxFGZllnFXSZ5qK/hVpCgrMQQX9n0wBJrJIs8BJqCmYx1mAIYuinIyxsqqiwpCI +DBU2IACVapY4oGMtE5SrtWXFzql5gdYtBy1QBQmXbG9Dk5CI060iIqQ+qwpS/aKF1RtSto9aIuPL +Wk1n1LRRPA+YAxR16o/RclOgenhAsEFuN/aAMr30SWRhfGNaq3Zp7zD7wmm4UsVZwW9Vg1Y+ujGI +EOuoA2qsIg25zlb4iKrRSsq2amh1i2RDGqqB/42sLiYQAJOUoVQJJACdAFpVIUSQ7F2bvrHwpAFG +l3UdUdw6uhvU9IjhLsDGkrEmq7/ihmwdE+mhjRZ9Qe0qipzSDhDUoWUl4U0ND52MtLnDtlFxB9+Z +mtQqfYe6fNRcEfWKvEFXWvW2kV75VtkziuvoNucs9RuYKsKQzcdWTCYAMkxr6n6KijXzWMBAW8bK +9StZD0utAtaDe7Plboj7uoyeZSXMm7rUkZQIhazi2pcu4nnrIrkGRVJ5Ts8WKeWSo422Tu22Inoz +wMRiiK51iMjulIWwbbQqqXIIP7x2EdgeTPw6+hNle8f71Io2C0qFYtKVNnatbnXU3geFmNBGA2EV +N10px32SoxUmiwpzKsdIZTgoguoFI+kk1bDOx+ZgnerI64D2JPpLGl3kRDoS8qKj5InWFx2xTwdC +kU4E9QCjtxRxMeGwp3LIJeINHBYCUka9Bd9nr2MNqKCOTlODc+cMdud1xubmt2jGgDBYmI/r5tBC +Z2foy+KmxmZ4FdQ8GT1EFjjF1YI2rSK+N0FNz9K+7KuVnMru0Mjm++EKEqijVsjLiRuw9OtKNi38 +HJoV3KgEd2VnHp1t2ujR3Ea97DgvCx1kH1B7J21GQ/k/5Hz/3Te3dwOfcUg76kEM997VGXz2P16/ +XX34+fT9+eqKjtH/KV99Lf8d2KFP7kh6WsMiKIu5mEkAl7iUTVA2eCmjoJzsYlaBMtRiZkFKbcIu +SLENGAYKoItZhlhqIdMgPVzONkihTRgHFlvMOnDBljMPX73ZiH346s1GDATk7OUshAxtQyZCkH9T +NoJy/iaMhBTcjJWgnmAjZgJ7fCN2AgU3YCi02AYsBQpuxFSg4EZsRdQdbMBYaJPLWQsttwlzoQfM +EvZC9TbLGQyIwZ96VEYxeiWzVUd149oq+XGbztAuxEaDY+4Nl5EpXX13e3r90/nygBk5kAThHX0a +rFBXxszgXISezqsj1AmNl76u6FklK9cSFDCZ9LLh3xMarPg2fX2igQ3Y66nOEzX8wwStLbMuW8sR +VCMfQPeeUQnatVRNqU7vqZ7UWpE1lzpT5L2Kr4u887Garn8naSYUwdnBE5mirmsnB6k7XQdPDobV +lOjCsDVUrF1JXQJg2vE141szDfk0pdfZ21hHX0XsQt9M7AL/VG3WW+1SPqR+YtK89NNSdF6U/exM +EGmWS6gNcAktW+Ex4KRpGzrTlyvsQgtt7ZhNdy1cdxVQpAfwyC0Io4NPKHyWpx6hcg== + + + bgsnVMJyDwatFMJg4DUsrRth2fAq+AacXQkfvhDoNCqMoowcDqHEBJiWZYcIqdLTmgdBCSxT5wI9 +C3h8Yd6EVVBFJknuyYH0McDxGuhCL1gugKEJHgw9HWmhziMZE1of5JxSUEPmBOQfOk6upHBQetLw +xwmVNU2tCsFGDgcFhZrq2FgpcUKYCmX72DIRh70pUv+IXXpMxEGcHHBclge7jpQfcfRFmg9iKOeo +zF73b1MdgyrYTtdM6kvfFZ2YatX3l6OyYZUNKs5LNnJOy4p/QpXNYZqlfqLTJPWLoXOULRh7xbZj +R/s1pfOKJxMe1z2Nt0eOcpXm5eSgGLyOEJ0OVuEr3UxdM5AeBDLoClGnmHS3mA6pmI67Q5kedYr0 +tp/AItXRz3KRcKdfCsVkQdJ+vYrJmhbTdS+myFHkuFOswa1iDQoWU0Qt1qBzsQbrizWbo1izh4o1 +W60Y7sjYvcHG7WY/295NvpBFj1TFlFQUCa8yglKsoTsZXTpJXjUCanCOezgMVfp51bZ1PPiiyCyS +KDwVtJM1x9yo1UKnWucw/dA5jJYc/V6nuvVkNGO1uiJsrGsesP5o57v8VexHVkNqqG8n9SLvjb7M ++xxrSJ066WcAPlAl51C2op7l3Ys4M3lpnZdJC4NeKCXCO9v2PU1t96OZDtl2B/h4ntZM53TS1yzN +YAFtm42m6CdjDTYopvR/NzSNN8ksPhmqwCYTQnvXcNaoChlNLWX04fwLaLJIX72ZLiU6xvEIyz/F +ABUAR5iilshxc2vwTo3GQ/SEZDHBYhWmJvORtkL2uhi+n+JA1maRN7oGE/pxFMOBTLd9NjnFcO6K +OHlrX6/BrG6pMgTsl3TQu3XjWDvitZPTzd11JlFVYWqddIdQypQUZtoYHICg3jYdBgxSdiKxmtJG +Gk/n0ApxgaXSMaOGXXljrOnkG8PDTi2qemA01iJoXHVxJ/DYVB2gBSo3OAfhpkpdoqceplNYNFDQ +eIZLtgiUjQGJtN6W0W01ULjtnDERTYofdANi/wp0EEo05ffRv6LvoEHYFIR1KDlrCnMwPWt8vlXN +FvknNbrjB6IzTg7SS1qqEehFolLWDMSOlYJBqqnR66bm5CB1RyewQb8wq9S4pmkGk1R522qgDxdD +qB9U81GBzSVTwoS1VKENH1A71X8Ahatryzqvp0iLmDVXrOlVN0tZ57tpysZYrJmKbqKyGeteawGX +YOP51+bAeGR4NFjNeoiURZq/DHeLHHnb5GTd43i3BU4etpDY4JwPtJAYYUKkiKHDs5mKXnBTNtAJ +OmjQoTn2cLJmeCtYGRAFEcQa6YzMRxBZUf3Yf7jCwSadrVmiUb36mqKtOWyhsA22xe4XhujobONW +j+a2KgXoDR1sWWnAaG4keczI0VOaqAMb0hol3SNqowaNEb1R48iI4mjxEc0BcEJ1BLgJ3SGZXkp5 +6EYypj2k7WPqI8Ap/hM4pkA0GoxpELX7463HI2hMh756s4YSQV8/2fXQxk+oEXTtE3oEr6EJRdLz +saNJ1HxPqBL9kyZ0icruCWXiwq3p5TrqpAf5mD6phnk6TetolCqVx1RKodN1WkepMjzNaFWG0hm1 +yrC/GKL/lGLlm2lyxLefX2kqeLr64+35+fUnJRkKKcuQMCm+gyDcPzA4yB/WFQdfOs8EAYz91CRD +bXAaQV5GQ6OQInqFuxDUp6+G5QVesU4LgT6VVkP7A7ITiORX1TEYs86yDPFRkwzVyLQS38sWNl6d +OYUL4061zhhucqEILuUYMhrIbtVoYfCROm1bP8wxRMBZDIwYfVO3luFppDS0YMTwcy/YHDOohNj5 +0NSaKsLQsxNGx1Zjfpz8w/g09WADqKJRTwh+VWqSoQaJMZANIDjdAr6GZRJ/g0tJhoL6POs5wNKa +KqByIWa7aNRh1jmbHM1cVdKHzzDeSPvZrLTfNBUIRjMZAELZo8dDyw7D5BjzbiBrCixOxqhjaKgY +nmYdPDE14Y3Dogn9rVuvlpkAK1GNMNjop2gQzkyM6BITod9EmujQ6ZEPAGjVWDXgeSQcAOZZF2KO +oRreokBOG2NxQkPbR1kG1z2nHEOhUdtKfBlLF33x2ESRtxH7UfQd0Z4WfVfjaIjgVWnjXHPIRT5m +zkrRT0ucuiKfuzi/RT/BcQWKbAm4SkW+THEli24p41oX3WInhCgyjEhYU/RoExGr6DErYp/+CDbi +bFOZmJEoREfPyjUhIqJNqI7DWhtOuG7KmBAgRgaiv26VDYDbysZhxn3Fvad5B7rNJ9tTnfKHe7jI +NzE3+uAr0oJoFWN8GwmGTatR+ZhhyHinvRKy4leR7ERTXp0nGEqEKRGu9EWibEVH2oAdrm0ivlRW +0ws1xqVUOqFVLKtjdJ5HgiXiovEmYmfdxvRC8L+JOFxp+pWWGZoiwc7zC4WYYEimPpgOgjo0N1Cs +Aw0xQLZviDQ95d9Bb9BfEqnYX2J8m/YAaToGbmMKMw68JrtVp5np8wvFqcPcapIfAjD5ddtNviVl +8Sm5A23lXMWmW0UqdF1M1VBj3+a5hWrdyBro0Q6+qdvk71x5p1QvTb1inu6mNqOUQGC3ykmp081J +JDeazEXoeRiQ5KbiN4loYyO1gx2l+yjtungY9BtTA5ob7/Pdq31Ip4wJ8dip0qbS1C0dpXCks0Nq +ohnyiJ2kN6u0CXRb0PiOlW7QDOhW0ADzQCaMpK1p9Dyv4/nepjIBaEEaafSQZI4LpaLtKuGYklpy +7oqHPtJj9eTOKHZYZdQ8I/RGyIiS8qA4bZvIlgRF6TLouH1JV3lpv246poQddBr/BY91HYPR6Q21 +7DGO0nN2mVeR01DFqfLMg+NKkjedSz0aS05tCxLDmdZkhKPTdXT+js/n6RE+PuXHbMCQU7CKjQNm +YsxtTBmSMc8yZmqmfE8iz4k6J+KcqO6UvRpzYGMWTbHPRXS0mlzIeM0BRaJAO7BPjGGXXCiSFJKc +MsRnUiTlO0mQSLRiQgOlw4msRaqWyF6ieoky9oQxEc9EOxNxHVHf+Hg8ZrDnWJLboOoMbxt6gFSC +dDVTB8GPq12XXcgiMVa0JKeHIpggaw3pMljXHNogtHdiSxa2MrTMHCR/K+avkJlSizHESPwQHPYN +zMuyInDdKeF/KafiJLsQJYi1+ew0JwCRRLM1+VWRcowdM5+da1NywVBrPruqy2fnYj67eFQYxtpp +PrsY/o+g+zpLitC6YY4hPh9rQruU+s8xx5BVCdIyd1WIGe26vINO4wA1Eob5r1xMaJfy1w1TDOH5 +OKazc/kXeTa7Omaz86vO8ew4prPTITdMgRczfcV8dpoMrMsYGSNM82x2TcxmZ1cxAeQ4mV2rCYYM +E15q6rFmlcrGZHZtzGu2imlRY7RFaVLmVJtyjblVzGXX5U6LSSI1/w2zq3UeWZaZ7OJpY5uUPSzE +RI8uBqdaX9dZ5DEz2bmYya6NmexMzGQXTCzDtICaKi5oX1oTM9n5MMpkx3lTTGSclTqrDlPZ2T6V +3fEglV1pu2S7Xck8/6lWzlx29aprPyYt6zrIXHZ2lY2BuezCqh9ll8ouxl83YLCZdk2jfvNUdk07 +ymXnR7nsYnohrhiRbNUhFDHM64rXq27BM3TyJsQ0dpVilw+jNHatIqLiUkS7hElZFjvT5bA7Huaw +K8MqoT572bQxiV0aR6MbqvYanE26oEns2lW2A2OwdtyAgxR2MYNdtUo7OE1lv8dTatFEBpjCrkop +jas+frwjJVmmIUJOmNeO6aAihASqTJmU246G9SQskblE5RIdTGQwkcqeUiZqmojpusR2mm6o0TwA +eD9MGe2aYcroJmXOqysNz8/60NTZzoqd1GypGhscx6EpVTUdD4eqSVe96eYizzcUJ5DJWzm69M14 +EWKWy5CtUzFeylHe6CQOZrhQjJClGCNTJFtthm/FGCWLMc4WY6QuxlhfjHZFMd03xXhrFaOtV4y3 +ZjHeu8VwaxfTvV8MyEOjp1KWCrNLF60kBp4ixyldtCEVqlNgMJxbI5UqpnRMD+umJ3XFmBYO0kXD +snGc0kX3FLUYUdwiI8bFmFAXGSan4nm66NRGwuW+I4N00VXox1PkA4pjLrJBc1aKflri1BX53MX5 +LfoJHpyHjevXqcgXKj9Xq/7gL7rFjujQn83F6PhedShV9Dg1TBXdRmStnY+iqa1icbp7M1N0E9vI +EkXrrohagaxnjQ8Z11Ik4l3kuynuuCLfctqn8bYtsn0bd3b/Tdz7HSfWEYiMWxtniQ6rjtAUE2qU +sYYdyeq/SlSt4zA70pexoZoouu5Z1ZgoOuUEZytMFJ3wPyiSMITc9XxxTBTtV8WImBeJmu8zDe0z +De0zDe0zDe0zDdl9pqF9pqExku4zDe0zDe0zDe0zDW1LpiGESCaH3oFLbwU7Cxj82jTIbnDVwxDw +qVokBnxSHoHJRKMsRLSiQGMps6n1XzBIhd0QrCq2mfAWUkiwIVrc9e6vtnIm+YMo5skpwrS6vQM3 +UswyvTzOFd5yE2Dx71w1agbjM81ArQtprI1pn1NAt94GgPBc112EZJkuHyakso6RIGVcG0MRGREp +1qimhXK7einQiOnUjIH1j5FpshLJWSEGm/s+7YlPqeyr2Cd8zvMT4SwpeX6lPmLhkH5x6sQT0wq0 +UldU+piI4owOpthaxdnhKqmPgolG7iqUMeDaxWsKoEogRIO4E0Sdk9oyJsjVr9rDNtoVkoEhHLZN +G+OUQ2ujH1RrXKSfnhtQxqTxRVjWOnjljesYGU0IHa44hdk3Mjcxha7ueiRmiBWbSjNUwSJYxqwU +ntchOWybaJOv6GciU+LVQwI2PV03RmiriafhTROlhsaruypNMCUvgalND4GngkjXRMcIslS32L4i +B5yqU2OOFrwkR8cOeRh6fd33uWKcuc0HVsew7W7wdXKPTPMDjY+JF1bEKWyobXc9KIB2xInneBnD +GVMxpCGVJJw9mQQuaEtY95LsoPe16wG0qzbpVrP0TUxIUJGLkWmoygEaCsjSVgKQIdPiTPQ1Yhpj +ANIGhaZK9fDWhtRMoFKRBgQAWmjFTMyDrSmjvXYtSxhdxRT/MbBdE1tk2aKDmnxVV5S+KHmvx0pd +KzTLf5XSf+t1Mk49NS19WzTJv4nuZCRXddTfdwAafqMnSAQhRTTTN4PEI8lDSvRPAIgmcKcqk/Wv +xMHiSN/i6GK+fxKllI//jAn/1XEpy/hv1FVyTX7os4NikDQ9Jv33TVbDKA+1ZhxCV1wyO9ZBc6I3 +0QOHnR3lvOaIismwmT3bRJunEntM32CuSFasTaRGvwowpFVNvwzI6d1UcbqI50rGmABDV1P18a6M +dwXaKor/IaRnJZjOufwDpe7EqKbL/59jXXeRCVGVDsbUPMa0FkznMsqKHvM90UteFev5JQDqwRbz +q8fk690PdbPskq9n9wDUqinNLgKI1/uR2To7GHQmpmNHh612OL8LYNUlmT87yFjLdA== + + + DYudZquPidSZWr0xqTlZGaOZ7+tIrnyjiyzLGEm38giCLk0cnk2e8H2K9Ihl6U6UDuO7jP1n8VYA +Tv7wWgCguFGX9e6igLIkeTg76EEunW/IBVLBswCHeKk7QW9vOFSOSDVlpWcIe5sYmY5vCtCh+9WU +k3ooh1YZ/SWmcfiyjjBbaxw+kudgxwdbluy3cOS4EeSHq4O60Rwr4w8FjgQ76cujs5lVHt1bpakN +nEBdVmUXxrEmcmPKUGbQZSxlFLmWM5UqQ23CVmqTmzCWWnIT1jKKsYuZyyi2bcBeouRGDKbGRGzA +YmqIxSZMJhUKG7GZDAxZzmjGAM7lrCbGuCGzifRSy9lNhJJuwHB+9WYjlhMS9QZMJ+OKlrOdjFFa +ynhKoQ1YTy21lPlkBxeyn9TVLWNAEWy1AQuKNd6ACQVGLWdDgb0LGVFmRduAFaXiaBNmlMRgI3aU +BGgjhjQGiC9jSZXELmVKlaJvwpbqKbIJY6qhcJuwpno+b8CcanqyTdhTbXITBjWm11zOomrWgeVM +qvJLy9lULbcJozpSFLZd5P93sFVppso09Cs1p2kwUq2xaI3VOxMDz3XrlIh2fJx0laS2AGeF0Ej0 +XZkgeDCrR7L64Za8I5XDwVg0ByRy+am/o/JQNl2jF8lCNufADq8e/a7ENb7Yd3R3cNh/qlUdDuh4 +Ez5dDl5j4hWqwp7orgmmcnCuRUpZQWLQfg3SZoPjb5vQf3Z0NrvGo/tr9K1MvNCivNr7WfU1KxvV +y0vWlnkmNlhd2uCWr68U22SFH0BwstomY6yvmLahNBn3LURNmfDInyMPpBky8bbLeYlcwvHO0hDj +gVu6Ytp0wRq4ndaq82wkvFaNJwBoblLh8Wq9oZQSilJ8jdbor4BjWHp26yAJKeltNaC3/WVtgws6 +M7pNql4NyLv8IsNIEJYDAAaiQ9jA6jO4uY7ehHXDKyjlWxO9vMkwUzBx0RICMW8y3xvJyQ2CJqKo +Wh8yH4oMukWsC/AfOwQdQhrpoJ0cfsrNl746Optb39F99VVWfTMHld6/99YgnUbqL0U7TSW8GPG4 +jZaiHqnDcuTT7DSL0Y+TtBwBWWw5Cj5AIDo1ATKMQT9x1SfcCgwmV5aS6oYmEqWklGDAU5X0Yx6O +FBVUAlViJg0AvmpiPF8LDhjDREoO9bcCFy1DYkIKPmPkUsakhsmwpEspU0MUC3qmhoxPIKvpev6o +jVm0z/obKYcXUoZ6NWCzQrUaagpL6ALoZqnVMquTPYwyqFBmRMVAmsIA1ReM2aiR8jfJrV5FQubm +mEz2RtRBGqnautU9Cv0EBekgzDOFriAoJuKp4AiO5waCoht/i32MTEr9t8grP7feo3vrlV2jyYcH +FT+kUJtgX5bjagH+aanFGKjFluJgamwhFip7vxQPY6llmKgzuxQXHyITpNK1pqR3hu6woIrwHYTm +zdXJeRpRKXXSCwLLGMbSQn5Wx0dL4l/LIWBiYC1ceHEaJF1if71wnUwS1H4BDShNsjOtpr2groCp +rjX8MMToCmg9gsY3qugCrpHRFRBag1lNhrThZqzh3c59IDNJV3kRCFsOXPaDg6870xkxT381/tSW +rX7Rf8utOKvWo/tqRTwiJ2RQ6wP7cLq8Cly6wCpvL17i1NjCRdZii5d5LZ4ja5Ns/XvzNn22PDIf +fjm/+60GhWrize8OEAYthI1yrBcS3FISbhFu3SWXOZ2fndvWCCOUOWmQGpYnulDKRhbOQSMa5Wtb +I17EwHyi6qaybnwHIPtO9iNBmGnS4tRIENYqHFuqVZ6ZBj22e4xTglncK7plah7vNaBhd0+Ip98y +yB+KEmruHeNdE8SqDh8cU6upqjW2hxqvqntmzD9vL+6+aEY1NMM2NCLPahwXZ+ykh0B7ZtmK3vje +6Bep1fSssgX61X3hRzX4YRvHk7FiDhwFP5uNv4PE3ksh4+t+vMIJ6vtu/DXyPpS+g9SjGupRG/B2 +VUg//g4Se5/qTKNLrfbjT/1KEDeqwY3aOJ6MFeMvxp27ykCx/wU6A3Y+DbCYzkGB7lQZmhTjeSzG +zWtw3mgeivEwuorTOIvpVHQd7L4ZT2cxnvHj6cg5HcTDwWwkSBoGMbPJJoOoOZgLRc2QfeJHdfhB +K3pkA5JNRIKkEaRKuzHGdrNpSF3rP2lGdTSDVo4n442e0QgCor0EihIv8tMV0zSWXlU0KTMi7vLQ +mygoFGqeUCY8lmX0auPqIBgObj1XJwuFCbfX8nLyribc4WOgiA/xBouigTWjDRqwU5OllJe1C5ps +2JXDR+bYMD2sQDsNoqlsfKjjG+Cfxa1TJXjDEz7ZmKivq8fF12gn/SbiqhHQZaUPQxWwDYUph4bY +QyVFz97W1MTj4ZQeg/pknb+CL5IJOvY0npLspWlYquaNDIjBYwZGVNzQGGhaJmd1UZAuGYKe9e74 +IOv9yYGOre4g2bizCZFC2WSdHOTzmGroepoPBAOLxy7s5C1zqAl+kQ++wkRZOvciaYWNhxPyyCDd +B1grStXAdWqmI6BkMKqvulLHmpI5Goys46ZBZJmlBbTC3QFu1QNqJIxoVn2hRpPpxeALegNEuwoT +ObeQxgQlkKCI+djVHN0BGk3pksocZ2MVPs0Fzekd5Cxn9gHZcXSA6CGQ3Kh0mczRcTybcY+VRvzV +0D44TWcne15jigjCfQ9ehRoc9sguk4E88kO0tXptJSAEGmba7OoyXSBcajBB6LjlmTi4/8oL74fr +nPqaOkjWYAfr+tXVlPo+Ht9Zisu471KXo5ubS97q4v56end3fnv9++vTHy/P//jx4u35B73UxfZX +v3Qf/fv9ze3d3399H+99EXyStfXQjJXKVnunmvDf/e389PLPp3e3F/+W7waVtN9fXpydf392enlx +/dMfby/e/r/nv8bqpi3+TZjRD3e3p+h+3+5iLvbj5eX53apYHZ2e/fKv09u3mg9x4S0yhvH2VUy4 +bBFVymd6sa8SKD75FDqIMyomq61WXcFi+HlhfPwF5ir+5O7JPhrW0JXTEKwVWxn0ZPBl6vxxP475 +l5es4L9QIlORTJZQTdxwNU2dK2clHAoo2qUHaHcrEetCDamo/exXluhkragJjlnSMOCVZupkVqlu +ktIUrdK7VEZfWddNTpeYWF8WWZlCP+bi9kvbt1fkHYnL2i3qKl1foC4oxCT9FTMc8zf/659ia34V +G6NoWMUv4geRK1+pBBBfpC+1KMh87HBXf9dI7MXxQdedDeO6WNVV/NU1oWDbWbjx8zLlSF3FIeed +ifZa9vey+90PO70rYp3xJz7t3ndF4rdnXf8uRyJ17btgjP+I8RidqLv6iVlJ1HNEF4wxI3iK92YY +RrKoT4je4AVgNH0rIGVO4K1bPubC5kMqn370RdhMfDxOnYjPeveL6T8YVdc3xQDH1ImTg3EXUzWF +sq5pnOngRCILTyszz2le14i/yMHCVzbdPQ0Wz6YE8vzQxvj4tu3Kds9Jnc5gGZMuOdGn9G1fyKxS +CwXbMwqkrBvvL2Tjg6bj2HW6H9CUCRch0jyzg7clCVHlqjV3p8b7oMroKsbMe57ZHlbxDTVZleG6 +Bct0ap6qtKL/wFUxF+ZDRSunV1senW3c6tHiVnGnVI00xb3mbT0FeDhbuGwg0IRv1ZGr3zfJPzLt +HE2mPHfvJAVx3D3Z49z903Wn20G8ZHTmHqK1rd9F2eNj+0hv1it7WlPFiYoE03QE88EtlqYvbjL1 +Up21zZKvTdv1fclWi6TVpOTnD2+3NJ6T+4ctOGXGUFr+fU9g1xNXuxoCIhEBP+ADfYP1KgJHL4fD +6NHTMIkKxE9D40zZ/YKdefiOhZu2K5zXDQVjoqFZT/IexY4/6MICiwcvfwOxgX8jMhfeS2ssrz5m +WleKp/muhXW70dyIGYlhTOYhc8quKwEHFtu2OWWZ2cbR3DbA6iFBYEZHPvVmyX90vP7HIbdemHiN +pjnUPlwdNLwpmv7MVRNqbPQEMnSSTtdYDcrde0JYx0WrQ4k8h/GIEIkWuvuHjggwHlXMPUyfw/5V +MHWlPrhCriv1WB+toIc2p32ssIuXzg6PiYUtH23QMsymFQJxs6MCvLwQB0jdpUj4Iq82+FGWDXn4 +OjS2Ilcv/a4AMX3KSOHvazDzDNzVtTO+ks+vOhAUgL6p4u0lvAnacGlHJRKDLcegvoCGDGqfqwO9 +A7orqO+hSDTUVExKrAU9JFb/hle3yoDr365+972Ivtc/rX5zdPTN2dnHq7/d3FGGzbB6cnTqibCm +5xrY3fW9/6bv/ZpyiQiv6env8ufV7/5yc/e387Ob27eC+f/JjqjlsOI9I9A9+mDg/WIncv3xN3/6 +Y9wrf393c3ulr+IoZXO/vfnx/M03f2rfSCe+v/v18vxN37R+tXDWssMjPGTo+nw6jidXSnx7868N +Lmj4MtURjhlwXfBVS5WdrUrPq30MvJHqMCXKnhk47SqlwOVDoYbmpibPHNRjYq+b2Osmtk430dSR +RY5JIgbS12dnmi0ZuZwvrqj0S7+GPHOlzoKRZ2bZz88ygztxBo5EiWn2Dc68h5hm1yCZormHo0UY +oAljngtb474iVVBnjyHbPKuVo9mtQACnEeDzMc5r2OVavU5ibmUakWLCygQ7yWEGRs14BbAGW6wD +dSXZQIwjjaAulgLXcJd1usJ32I/H+O9GpkgI8ErZb8OciQ+w3/Scc/R5sErCey42BLTN+UaIbTVi +vuH3jhPi4aKN4/3bZxu3ebS4TRxTzn5+ptultEZIfAPb9lUGkqXW5clAZQT57oqxDgSxSi+U6UD5 +8peuSZfVizjl8s9g5I23hvUwNPoArJrC4hBOpqNKp1vfa95uXOkdwrYr3+jHeX+6duCbOATlo2vi +xffykbGDr7KZmoK6JteAHpY2IpqUnyJtTLp2NQB2PWEc7mSWBtBubBo0Z8fANXPFsM3xbK3p1KeJ +MgVohKlaHzQMVnoHEbKun0SaWbQq2TnfvBJp5g83t3sL697Cupdi9lLM3sK6t7DuLax7C+vewrq3 +sO4trLtpYZ3YU68OpsbTYo2JdY0h9lltrEZv5rjXxgqu1z5W1iFSrKwWmVgnDR8tb/ipLKzFGhNr +bk8t1thb77WxFuuMrFPTZG66nBZZD3t6M+u6zjMjVGZmXTOYdQU/j3aiCri/0uxtrU+qnTg5f3e3 +t7Xuba17LcVeS7G3te5trU9oa8XlPsxidHVQ6hWAmnFQ5BFD01GCJWvrCVmxGOE7BiVja1ZwDaiv +Pmv/cxtXDQLvEArbWiXQvbGyRZtB7ZxMLjS0rSKADTd2P1i0oXlpZFxd0ubR4jZxLHkvTPNnZrdL +3ukIjRJNns4SFxIsmc5OMlgyZQJWTWC457Bxa0HJ4JkVzEHlvaBkbMtAqbOKRQzCLQe97D9INw+m +vtKeV7Ykk3GLlXmf0vsM1HcAuWkbtw4ymKtqzfyN218Pe1Cs+BxSxbRzlCqmo+iB/Q== + + + YLPia4H9ONTC2s1u3m7+0bqp2lRUKRItQFqzWrA+wA71BCLKhhLKq7Gf/u3ip5/3IspeRNmLKHsR +ZS+i7EWUpxRR9PLQJEfEEBlb5dJGB8pkklRwHaiXQOjv6VQASa9z+WTY+DMKKUEHdJ+QgvQ6lXuk +aGM1jclsKWXS6NgD9PFGn0pKoXtlXLsopNDE421aO77OpQKF9FxqgvTyBX33RhAseeXXgTKBJhUc +gsr7QD1nOxlGZ6dINebCSQTlxc1hysEygQ1GWk3GTkjPebOU82n2ho2vBT25YDIZcIoqGw85g+ZC +yHTYPSwXOfKhZ60ORZfJ3N8rlHzx0sA/3u9Fgb0osBcF9qLAXhTYiwJPJwokNpzcfu1TYBhByFhs ++7gt+OL1II3q8Hpxti9tWMUoMJN/lgSFNZDY4Mm0D08ZFMbbewY8tgxMuXMkVl8TExYeKdkg8Wfz +QEzYY01OQ8IeaRLHkx2krP884kAXqKNpMjqBoMEhIgBdwMS99ZDEna+DVGMII//isqs4sA7UlctA +qfIi8aIZKAWgZaDpaDq5YPAqBYOliKSs7b6hKaiLZermYwrpirHuvJppD+4BPiggCOZ5I2zPJwkI +40FeDYBZyNZ0oBmsG1oM7RpA1o4sRosNp3xNfz7Fy6rQfBa4j5WJXY30lQ7bzVNYMBYtx2uSWe7u +ZCBColbf3Z5e/3S+UQgYrL+41QM+0vEgaoQdQib8BCpCdRistysk0fW4ECsBSqRLTQ9F9zpVUHQ1 +pFY6yPEBQU0GOjlgOdtDJjXn7Y47FQunsqn6vsHJUO8970yolduBxqzuuJ2yqh488ArhNGqD60ZN +U8mRwUOB73BLUhkavXRIOBJzGExZjfgepM3XywMfLg2PZ6RPH8VSLGz7aJO2wRjJf358BNqm9IGn +WmtLHJ6m8d4ntZrDD1AfrxcXiFCmd/nhUGQeog4VXOKGZDUt71tJIFluF3HB8+rdBChladPv9C6V +ToU7ZIjPOTK4jh9iqaoHFeNqi7zNYtKjroKu0xnedy1PBtulUMo2ROIJ832TdTPwEsQEKxCKyJ4E +QVmmA0gQ7Wh8wFveM5Vq6CrIdsaol32740LjWvMmJx2a9Hky2OPp+O8TL3uX4lG3eYROBjcZft5T +KdA/nuSP/WROJ3yyLMd5d7IBfPVmzagEOK5x0uiwj8Mujgc0HvF47Y6zbuS9mMzfvcBcDK7cehk/ +nTx1zaujkDW+RL5y2cseKRXUMBHfppcnk8/vJcqtjRJocK1fdWELXqpeE9vGrO6NqXgtjcFFSE3O +05dtOHQI9BGmHrdTDWRQWRfkm9BoqAfLhkqv7hZyuLjBo00aLOOlkCP6+4nqMWHTeKu5i0nyZcnc +YYwtOklv08uTyeeJgNW1wqtDZsm/SoD4LCSkymodfrwG8PQxCZMOyz7Juth90HVpUuQLCEWo/Pr9 +/rkuPFIu1n4iFyvshDO4bCcxsJULeAI555twiFvtXA9Q3jU+FN3rVLZA4VQtHuSAyp6UWU0fTqrJ +Gxn3IOtd1u3jwSAeZU2FBvKm8ciaOmHA6oej7nDLB+5qNo3wK7UNQw6vhiW11ggs3LY5jPH1jQB5 +x9bDhQPI0yQWb1nLR5u0LMTusGk+N1varXdF4w7Yuya4+Iy245rrtb4JEBkgq2uu71JRluzWuVKz +y+A58qHdx8W4qiJvp5j0ohj2shgO4ng0qI737FFb7VhDQOQ69YKNmr1qYrvtoTG8uDxBtFvxAW95 +aWkqrqV7TB/0KbY1+HZcU97MpBPDTg7HcHwwHtNj3GXeq4617AeR94x3xeZdAyPZPZ7kj/2MjaZ0 +3N2sC6nHcj5NIYNaJq0MOzXs03gEg/GN1qhvumu5mAEZcI5VdmNktgfv/aH/MoyyGzbu9m6YqRYg +Ji2KIEGccNi6NgMJf8bbtRBTSd1ZqPWiIobS+jbuVNyhgxs3yfd22wvWFITEdluM/fK8M36w7SoV +cOI94Hp5fd87fT4+GOxEgLKdnkDFpN5iXevFpI/FZBjFdKgFpwN3e6bpKDBjvszmdTrTSJyx7krI +NUsScWS4KALcYFko5WywMFpu4dIMRpMWR/f7JsujQuQGC4SCmy3RaKPVkUNrx7JZe6hXUVkNaBcW +HSd2MB2kajQDcQ0dk1SdnsHIpN8FX8p8pMKFlm5Wqf4OcHbQCCXwJgMJi9viHu6ulgQgrxR/p+ZT +6dS98QCOJ0OanwIKxswWvS8R+q2DlLUIrV3DSUFthlsdNRVUfCiCKf0hcgkIZ1fqfeO968Jnkcy6 +CTWaBeUKE0rzVQeSOfNxQl0Dp58E4BEZf6d3qXQq3E1ffD4GRuC6uw4iwolTjNAa0jNqT7+7plPh +Ylx/0TcQhcUMVeLIalzZzix2ESQIl6rXe+ISgG03qV/6LpVOhTPEiA3L2AOc/RIk2DQ3WkN65rzZ +blL1ZSpcjOsv+gYmoPt5jIE/RN/wVfY0blkrtaOB6d30w8Hb1Xhy+onD15N5ncz8ZCQoNpmCyST1 +Axnfols13dkf3SdEktYbFIUPLXE8ELV9wG2PHTE96T7DV7bNIV3Bz5PoAlYrSgjxbmFXdkpwVcII +KTJNrQqcBkLDSGUkZwQ1WQ8XBs9lTRNVRgtbPNqkxZI5Qj57agva9nQZcKs4WbJK73+OWiO+Tm9P +pgUyvVETX7SurqxqjhotrZAT4EZf97jAWtCz6I/6RpsyskCxozkS95+ye6UfwLriX4A2qUts0X5e +NdIfTv95c3txF7VH/5FkjM95bzYuM8e1zYWDX1UFc4PwhTVvE00gyD016CYAMKghe1kL5YcDK1i1 +6pQZaqiabKtXfOJOUuPVmbMNjldqazYrq8/HBwnSIoeNOnYgwxG8LGVT4TZQKSsveHk0LXSKfrht +NfVN3U4tWN/uI9bSNF0tvGY2NaLXzHa9ONE7ag2vA489LTgYQuJgeC8vms1GTNG05qWjcVoKzpyr ++pkrOL04TLL+Nuku3u4raVd4NThY8nbdKhsnMvzUUBHgvuh4vWf6ChUhdUy/UOPFPO58LuMLGVla +ZSTs8bYHBdhSQsUWuacd24VfnUHivWOSdqMTItOGD5wN6QM6jobDIKgZUh16ywqvJnXjCUmQY/UP +DGWbf1XTDYoAXg8rAL3Z2EmrrSYzlNPcGPVHLkNNL0gkLwUE08f51MO+Dpr/EI+0KNeVupMeGliF +Zba9lVGpTNTIpK5whFUmRziwx+wuP/HxE1wJ7jXJEWsB24w7bRWttSW9Gjeifh2oCGVXTddVeoBC +89ePhiP2Jh8yZ8X3s4J5a5ps3ibLfDxd+fvdW5/YY6TCHPCeV/nrVh5XAfO6V+utiiDbdd3r/zi/ +pNs8ye63T0B6sbNto9ck1fSVMpA4Qks/zoB8vId6yTIoVsn/Q02SAYtxiWJcKW4MrhRtgLC48ToB +uudUpi+Sqk21pjbZD3Yjg4w+ntQ2am7cnWmP38GNu8R+T3+vNK8qcv2ByMvGFLaLIidRRzudgYrx +58W4RvmeziXyfcDpRrIRAUUH4dekcX2xVHXR1Z0aLtiZgr0BzHJhmtWkRKotq3bS9rh30wFwHyPo +oXZKIb1zdbztquQkyFaDx5JP+fSD0ALqb3huZBDeDx0zMSYYrncPyCCNeuQYJe1s6ftI1VFd63TY +w9I79fwQ8cvyh5r9ZYXrxugrYcYDL493sHIc80p7R4IHFZJwzuoPqQI3HAY4Pw4qiZpZ4+DTDZ+e +lEcOKSscXeALixzWVk3UuhCm+4ocHZh9i8PN9pCzA8OzyfQgkfNaTVKKELwG1mGsoZ5jOlwHb0XX +EELeQqatZMRHGxe8AwQcDzIxZwcdSFamqmvErsVxCk2kFs+AebJ0GIAQ4fSG8KZsW1xdL4JpHXhr +Os7JwBvCS6mH02FKU/FCdtzdLduPV4QHhp5ABeSt4cXjznu2A9/5RtuBO/0hHC45iSK/VCiEs4Xn +Dggz7kGXT6v+SfZ6hbEcH2SgEHyjfrkyN80QECipH6p6UDYCJ1YWnwZp6VdtEd4XIhr6uOC4yhzL +JRNEXskwoyn94nA7O1DYRRG+lzYPfWNraoGaVi84l5MbAJlAuB1jGtrg0Q5w1JUcZd3A2YEoWhNF +MaGuB4Q46SykILRQC+MFl9NKU7G6Vk76yWbEJgVfEMgpoae1NeoWD9bAdiBwU03VMkmggw20B2Bh +yqBLFEEyC0CnrhLZl16ZldRShAhdEbSEC3iCeITTgmhrHd1j10oHiR3pKkg9nQznjLr0Z7kjnvbl +LWQVbq7OI6tgnoRVcD5q9wUFTAhQK8lpKUy3ZlBuZS8wCiaCXKkmrxOg7L0gcLRlbZOzOKV69Zl0 +ZI/ZqKKmLQMZZpgOVvyiVUB1WNnAvScyf9vkMNbE4BwA2jUALQWA1Iv4l77myYBPUqbzUsvampVd +yQGohoYIOOkATd/NAJYTPmVTUFesYM0hrIHAi5z5i/SqFp0oMOwNbSqpS9lno14+rLb5fJtEjtda +WPxKjmQcHB57XPMlt6Zut3DjfHf746pYHV1+5PYxSYtq5m4LykrkPEmPrzqIs4dKKoNe3EOHZxLk +IgMV/LzqP+8AqUacpgkkKKlHf6zAIsLIIHYo/To7GL/rehgLj3t8NsOw49xv4wcIhDAe7iL4F8Gp +ZFYcDtzKreT8RlAP9CXQ/bItq/QSPKoXesSLPiiN4raPRnrrRBbrzTubqOlm9unz6+uiFtNAjB1O +o31sGqd6chn80OmTuDjAQyFTrXWB8T3C3SHpWwKJMHZITgfpmltgSQII09aSdQUqdTChfEYDZlkN +RDKcFekHEcmUVOUQwJJ1X7J/7mpPoNSDVEPqYt//42wssyyL0G9q2I33NP8K2+z0khnhsps18QNC +v438o7iXHnjJjJAmePmaIIeAME3TqOhgG0fLoS/BskqzVcCW6T0paFU0oHBypsouq1s9S3l/AmTF +BlZLF59lXqrAqZK6oWbqAXHujg8SiGxQ1axSDRDCmjR3/HXMizPaugkdqGDpqi/dAbIWMljsRleP +djN1P6ns8FxHVLO8TyInWMADmcIqh2RtRRgURHpxQKzDgVfmeNKvYyVZVf8ukahUOD3n09WBYi9S +HYUGlrhatYVUFG4WTT1p9SoDpq6Nu94PS4OtR6Oezstk8lhuOsn5Gui4GHmdjXoyJZMBjI2HTX+p +AuSZuqc0EOYsDdqOBku4m/cwYbuhmaW3LoNaOq0zvKwhdSSAHnZC9rNvLHygbVZLAqSmzg46EATP +xqfYalSD0G1DwTO11UEon2iH+q+6TvdVTcY25wg0/iHiDXEskhr9WfB2g9bZWr3L9ZaWjtBgukM2 +3QbSJSO7RLotfbrmO8K8Cltgm4110T9FI88Pk6GSANWbkQ3OPmpEKg1VVk8HiI2dHWSw7qaPrqI2 +qTRSaxGgmqjYpe6jrtddReOxffp0yzkj1L/SCU8Pmgi1FiE4WGisS72eMs64htTCzA== + + + L2xPxfiJDtQiDKtRa3FKEaSqM2iZXKg6gM4UxKnsmxgH39cSAamls4MOJFJ6FX12tRYkty1d1lIC +6OSyN/03sb99LaMxffrMQh2CwA/NJRIfkEsE6g7EuZVQ81Q5LrdwJSr1Yh4Nsu4g2LRWmIuGBEkx +jpo2H+PnOwB0YS66j0WQ7NM2GFWCxnoyUGyMWqoO5qn9WHVVifBTtS70zSUAtKOxSwnUDyPWMh7X +p09uJTImrrbj5KYHsCRgIngpkzDlaConFBn/Jzu60Ti4kt5RVz2kjTEjQuqpcC0YMheAYKpw6gCY +aUyG60EG4jXk7FRLB4gNcXU6CBSGq64SpEvg1UipoQSA5id2JoHyAbCW8Yg+AyWGf59PtDg+FJro +DKI+L75yLpc4CkE4b0HqcMbUGj7fwRCjSb9CKLXbkupiozx0oM+X6yGCja1QXWrCuq8M1FXgBbua +OkhqD5s9wYSEORu4GLEmqH5Jabr2EuTsoO9V91XX866myfg+BwXGGVonCqwPoMBO/eB4a4wH83/v +oedEQK0NFSymbCnUJBD0+FbtmHXVUkfJkwPmR4TopmdsY9XhJ4i6cPq+ig7QNXN20MMMbjlyq1SL +6lvU34ANdYCzg9SXDtT1P1YyGc9nQGaZQxOPufgbqVSCHKgOx5yx8DDPiTGFxhHRQMYyv6I6wNOQ +JSdmaGvqlalJt7AptDEoGCeNkCFlPzGtkBSOcWcn/TA7g7ptkn88HJuEkgqgSSSCEeRncMlQjgMm +4IYZ1jQxThsNHxb6ZKyRFNR9IEtRg1c1TDni1SkOlhjcM8Rbb0WYd6FuoNlikCANkp4ZV3jZFFmB +Q6dK/OitRfNhww+oOD7m4e9aNRambc3QM8IDLCTDeTu7N3SoUne4sqW7F2aRuTzKFsY4mTXnNMCy +Tn8ApBsmjBFw/awtUv40MbiIWXfqmH6nCZEMB6v7gEGvcuBVEOZ0n7m20sgiL6ghMwnrivwS0bBa +U7apA67+c3D0bvxhWbea/hETkbwvfNm285qF6xzWKlRqlRAJ3a4tWQOBnNdg9zYoZZjXY6qJ6L8s +BEa4/uDbx1IIPebXtWhZnuZ65aaRNfAz/eSShmmdWulBBHxYz0QzVk8rhOo5mM0KuDG22Jr00ml9 +UEO/BjBTZ15RUV9ic9XwOqGyQ4guTvVjqajW+CSAcArUyS3HwfKI51bNgHiGx8wZyJJR1yWRoGBX +5eXbyivTMgSDdk0mEDdJkMDi5GFqATniyCJXcATHxg/Rowq9JfkQShAZxpSs02LH15E9wRBJPoKy +MDVKA4CkDscHpA7gCm10ikkMETQuUmQ6c5vRC4Qg1i1Rsm1r/qWcUMKuKQS0qXERBBRPRg6sCqVC +JBuwp5EBq0mhaT+s6eWFvBy2tZHVbA1ZTY+vZJeBboisXUGQo0kmyDeyz/ya8qaBz0zbQKFhQCgh +1x0p99Ko8UamGcaSeW2DAlTIlkSTJggE0qOsKSq7nocvZenWeyUec7sdZfFadX70Iv008rHRKj2N +tygwuLEvT0WaXJsh26mx0Tjdqra60iRLOJhdo2IXj3N6Pho6ymkCFbiBkM7QW+4wtIZOCUy4xK80 +0aNjbga9YJJ32hWO/C/VEhbaDNoJGxUlTa0ujHDBDNA5wfGboo+QnxAaNa0LctKzlL726CC4ZxjS +eckrtpfwPUnmPgNLFJxw3OB3KHshc6CyLvQlwDN6D9YeuHAMs6OctppSkDoEqyXBbjaVOhAMZm5j +IlLB6ga0dA0PNmOcugfK1pGBl9CaY6zS2CFFAhVQ/WHUrcHoSXeF0oWgWTaMKgJEqgjUsRikVqjp +ri9HuoVxmTpB7+DE2q4pbWXeSnXbMU6OWpHKG/rPw/jl6iS1lu28ho/orlbCb16+r7zeTDIuh7AG +3yKoovSQg1hsXn+F1S5hYiXT0jJU7ZPpxuKFeZKrSURWKk350lRjmMNdDeNUlcGThbn66tAqQ9oE +Rzmllj1IEYyqXOwn26r2jLpk3WKmUgcxdakCx8qKK5VyAPBeC7UQuSnbWfrrMItT4M1BalSDvxy9 +vmjQrvUTOg2qrjUqPYNmOSzIUgTlYVUbIq3RSQxSIS/AOiNZo0eBIBz0z4ZfGXogenr2ajm15PgY +gK7kkCIKPc9UbdKZVxq9w3M6j5vKLcGRJdbbwOPfCBU89QzABK+GPPA88cmEVGAKnCotBJNJqI2n +Q71Mu1E1rQcZltWSrdwKO9FqlhghBjUz78hcBQiieqfYqDRuAjqkB18IJX45zVUJZtQ1jL2yMqB1 +Rdc1fKRnk3V1o95axtm1RWVnpjwz6JvyLvO6rLfgthVoEKfFmE8WX5auztMwH66GN+HLkhF4ialH +olUXHjomVWQscOTLDtbQU8RK6PnOXQ8vd4gxan4keZHTmLfkBqEcFZ/VuhX1LZCL4eYk9KKGwpb6 +KO9VT0WdiEZmOPrytbpTnb6B36Yv6SIK5sREAxZjnR28JUvdslHj3BxGhz/AIhFsFIcAaSujXzmN +ESkRZkLvX6VNx3SKVRWXnK1lLaOAqgie/6AideWpjBlO3MbMhqfP46HGoh/CLiPECJnAbS38tirS +ZBKkXedDr+RokVxLCIaFtxe8CuCsBipdOdUYgI+yPgr9OCB/oDHa45yGKObbGIU7KVw7cHzQlVY1 +TBeNr5OOowVVcpD1cU/FnFaP1FRkK0Nxz5bGrCsoBABCr6rlqGA7mttdoRCCpVAi0gRQtmX4dE5j +2ao8BYGAN3PZuBfmM0DfmRCgMNkFMfC6baKHelVFrWXVxNitSn11RXps1ZnCwnWKPuOVOscChqPf +I8ON1Y+ogYYbM7/WT+o2qhxanNfYjExpaJroywrTVktqgNh86qTl0+iAzXCboDnjlIcp9cY6EAg6 +uMthQ6pm4SDfRl90kbLhNguC0dLwjdQIzMGsTsiWahpHAAyMxzBblOQy6C5YRmMvPL5ByUh1xpO4 +MV/BXIGl+njiT0slfQtK5EPtkcQNXH6IsW3RqmObEix6HTdzzLXuNWeTBhcEkbsPqYUJwrtJlVZl +E+iJoSNonUBdWd9T2tFEBGfFpmqaQ4ZcHdFYUMO+qLoNcu/z2j7CHZmuacoQlRve3VcUrGpLTwFB +GXmvMsrMfqO4FKR2I/Kxn8xdLFyjJyAeTCMhnNVLyygDzUYbeXjIH9jiUGDjdJV9Qo9i5+M+FiwR +nkANejjBLR2UGCKicYPciLiWg+KDPEM5isAatakKI4CoCVwoomoAMvhQO0g7GkXiY7QE5ET8baH1 +cgxm4sFP64urwL80TK8O96+aMZutATmQM5CGDUP7B+iNi/FQQgBrUBBXaqLx8pAaTTrsWbqRa7wM +42ep3hVqBqJFYwoUYFDHCr0bz9fGHEZblQxvrJjvUtpsNMTGgF2zws4IX4+IgTbYqJRWfQasgiVD +DbxIUSvc92m9Or45kn/y5gzBZK4zV9dKNBCxCJXmCp5/QnzlyJ8WFo4AtjhIWVZovy7MEefRwwwC +U5mX43des9jzHhwHYk5ME6hVnhasISKmBARQLx3N7S7ln4B5krIgcL75dC5j+co8iUKjRWj+3MTx +T0QsOvfx/P6Slq45MdSBjl0dCB5WtGW3MU5MDjbm00g/VbHeRg8KggqW9l3p/jk1oDJDhDVJPRCr +QQAEDF9l/5PhSxrqFiF9n2PxySDu3ceNGrNj8kSRqpj1IsQJEelI5lQOtSiCCUNtEQhoJ1kVKWDB +xuTlQKQHeXZvRIXEh9g6OGnZ4y5jiKHx0To4svgHSjdCm3wTNKJ+mFZxYdNHS5tmaUpnajuJ2+8f +Q33Y1DV1ikgZcAYqwRt1A2TSa4KWoBOvhF6MUBtn6JiFX0/k+Z/l33BPk39Dw1P6DK7lEwWoIDvG +KEBFQZ8QoIKD/74AlezdPkBlZwNU9rEpKevds8WmfGLiu32Iyj5EZZdCVGr7YIgKXH1GESoAPRKg +Yp4xQMXMCVChW9MgPiUf2GcKTynjDaHpoQtRMfNDVGwWNXKVw/IQFTMJUalW4xAVW36mEBWtaBCi +Uq0mISpmEqJiBxWNx/aZQlRsnPL00IWofGqMSjOOUWkmMSoMux7EqIgAO4xRsc0kRkVAgxgV1DKM +UWmmMSrNC8So2OgWnR66GJXqcwapqFf0IEbls0WoDONT2NLuh6eoWJmHpxCSh6cwHcy2hKewM3l4 +ShpAF56Sj+gzhafEDCJFeujCU6pnCU/hmIfhKe0kPKVdE57SjsNTdPa2NTylNYn66kMKT6nNZwxP +Qb71bQlPYe73VxGeQpR5ODylmRGeYmeEp0SuoQtPMaPwlLr9TAEqSBr1qQEqddCDfksjVBqN2eCl +HQ9GqFRdvIddUzZFqDQPR6iEec0+FKEyKPlghMrDPd5HqLx0hEqjjNpuRKhImeUBKo17NEAFvMo+ +QGUfoLIPUNksQEWmZhigAi1nHqBStvU0QKXcMEAF3lWDABWzPEClHQWotJMAlTY8HKBSTgJU7JYH +qDRdgEqIMRu8HBSe+rqZFseoDMqnKJWwNkolJFm1NnMbT3EqJsWp6L2s06IMVQnzQ1VGxRms0qRY +lc/gQbqPVbk/VgW747PEqvh4pWAXqxJ1en2sitskVoV8wyhWxZaTWJVmEqvi1sSqtJNYlTArVsU8 +HqsymMcXiFWxUeFhNF3v+pARG1LISMhjVVgmBn7cH6oCe56Gqtg8VKWKoSplM7PdPlSljqEqdn14 +DUJVcBfKmlCVR3ocI1XqfaTKM0aqlGYYq2IejVXxo1gVP4pVqSaxKnYUq1I/HqvCi1OeJlSleTxS +JXFc2xKpYjRQxadAFT8JGTFtChkx7SBQpQv8mBaNYSrCWMUwlUghGKYi5F/DVNYUXNdmH6biYpiK +X1eQYSplSGEqTTMIU3mgs+MgFRxU+yCVzxmk0rRPGKQC9eUwSIV+io8GqZhJkEo1J0ilDS8UpDKY +xG0IUjFduIYzs4NUfLO+9MIglUfbvj9IZVJ0VpDKff3eB6k8a5AKFImjIBU4mwyDVMzjQSrlKEil +apcHqeC6kacOUvGLg1T8IEgln68XCFIRubCJQSoxWqRKgRvh0RgVWdcY9VGaaeEUoyJbL8ao1KaL +USnbGKPi57XahaiYGKKyrhgDVMLa+JSHu5riU5p9fMq2xaeoH8998SnZ20+JT2keik/JXu7jU3Y5 +PuU+VErxKQuR6f74lPvQKcanLESofXzK2viUv33//SAs5fNeOqR3pCKQAM7sdCnrQf4woYbznnGw +LVcVynt4+CfAGa/ZxL1+/SfNsI7uOTajFhqCeLUg02ZoHWh+0EwCxDsL0ZXum9TXrpLxeLC91mPV +D38++cefvhWM+s3Zxe2ZLLB989vV17wAp8Sqy8tsoUPMQkDpyahBCz4ymiqAoBOAhHAEcjrC8TRq +tXIwGdFmSdeVttZrH1v4IEUPTwwTFwiWUYNTlTARCTdFx3w0UBoeQnUd1CwWQQVCeA== + + + kDXghH4zhh7T9IWpeK0gblgVeOUCHodDOJ4MCl7yXJbaZQOlPrvJv4LfKrgV+EaEUkVJz6uj8SY0 +qo+KENyRF5rYaYUlNDk5sOk23ga3B7LVxlT01W41Y+SoO8eTDp48x9VkWBy38gaX+Br+pZ8QwJW6 +tG3XpUvfn5/env2sd0prJNFnpxxQsiMMGvIFUj5dERSgAKfSlYoOGFnhhGWi3QP6Nm8Zr869DfSH +Wkx+VriyTI7lS+4IkXvo4tz6Ur0x6PsjwlRVVwqAa9YKrgO4Q4GO/6ZB4/xWFuUSUpl3viIFaWpD +aUkGXlKTwjZ59RiuvYRbfBPpktVrGSgGydl1yVgESkC4YA2CGW72LeMzMyrCPgMK2R5y451NZ+eS +WDqJPmnvj0P5GP/D0lEan7F4iBqZLIsCFy8Mzv3J0gC4weJIsenyCHCTBZJi0yUCcPEirZkt1IQD +4x+ceK7IV2/6NVm6FlCxWWp6A+zaXAt4M0ID4FCmRGgSvoS+raSpwNvQKBDek+BIIV43IX44qvJe +4DuSl9Txf+SX0oQorDzJZfMtZGxDhKphA6PlVj3tE8h41YgCYIGFUJa0PAag8Whw86gNh5YcKsyc +DpPAi2MNT3iKsLilHYpaKgUroycDs3ThDIIOF7fcwiAMdyC4fKJrVLi45AIKr7KqrjuIRxJTy2UQ +/j7wYsyaF3Z6EQdVQ+o0S126rJbX5BomxjStCxoB5emgwlvEG4bCyWi4R4CVbYkYMREOVGEsk4K8 +l+N5SwF4CU5OSr67OkAEH5WzCSTYU3kfM+eLyMVt06jSGveZBr3LFbPDnKPCe2ucTs37QvX6R81p +CDuz5qXHXGk5p3evwnW3ZWSk7CZfY3vrRb/w1oEDh4hNDlqQ4wP47GjAh4OLHDgQqp6b6JCeFiI9 +89pz/koQWNegj1dvcsPQ5VIvw7X0yTmG2U39CxtE+dRMEBOvwTGqtJb9E12Wq8OqLlnI0lePqjWN +UVUXRGisPHLR8j5MvX+dBJK3q8e7TgBqnF6vWZqgLKujeVGQ0DvbL8l41Y4n6/jwfZFwDpUlMbad +qdF47nvem1aYM9/gDGhwz3sLZIEDAi7L3UJ+6O70dlWsROT79beRIYp3uM4kayVQQ7a1SkhwkuLh +ybukTw7ing/qBFoSBBOjrXjLr4gAVWTRS/qLAWe9IaUuKQPXbY2HNe/XVDNtbNKhvrtzAqwRXy3b +2tQ4taEs9XCngwanrlpov8ZaL4tridVpuIi/oZdEJLJw5rRjlvUgPCwGV8v+pC3BQUsJlbIrHSJa +oCQRwgoFYhUvf66EEWhAKEUoFBE+xlZDOIK+++oAfv2thoM6arRPBNRU9BHsb6duIg8CUKnTZ3ld +Fo12dQsrPGfU4fYo+GZYlmOAEszGMHLwOll4/RmG2cGpxysZUF07fEADb471NTXdWA+IYlwIRJk2 +lV7BO3lfTCoppg0V094U0y4XawZWrBl/sWaaijWzmc32SR8NDr8IRCZcoW5vGBHT0H+G7WkiXjk7 +a1ZrMAzHMOYT7puUBtTyUuKSztNWier45aDssN41LWddGz3MjvzWkO/BGL96s6YpoZGD3gjdyrsq +j+OhoNZ+pMpZj78oRpUU40bWzfeguycHw9Bu30RGD4ROTn1BDiEkCMJuYxYJ2XZQ0dZ0bUmYxrCZ +NjILJ5CiNB4Ht8bDuoNxWE+/RachfzT0NCHaI2HmOqaSm3Eg1GtYx1UzdC4pkIg+MCq/Zoi775z2 +Tw7gxAcyVNDLvtQ9BC0CTZ8nkPNqjUnuP0CAG1UxfTUIttOQz74x6jFxRVXWJ0YvIeRAFoSRSCfT +mTp5QNmNIQujxbsJi6aG25c6HcOpcEI3EZrcgJh7MGpg/zwSl9SM1wxNFbXEiDwVLACbqwzyD4im +FYaF2Y/ht4aIlXVF66AKlWCbaAQ6Otu41aO5rcKq1Kgdq4Zea6jWvo8XSSd9uTq7uXp/8/H67erD +z6fvz1dXN2/zY/5htfgavFZF9wizFTjCbYqgm2C3at5H+A1iMcFwER8nOP7VmzVYzq3c4zlF5gmm +C3SK6yQNE2yPevsRvus0jDB+zSye3K+PX7B0mXrcPA9n+sQMZJ8n6uOnso/t/fyje4h/pD/vGv6x +ivzj6P2j/KPr+Md2YwbSqMm0hSAIps401gQykF720pr8PFQz+ZS8IT7ESPjWIC1U6yCK5vl5PlN2 +ngEHaeniMuQgLT2MBhykjdzScg7SkWeDA9a9HKT/HBykn8VB5r1ZwkGOxl+smaZizWzO4yDbdiEH +6R7iIN0CDnLY8lIO8iGGcVjzPIbRPcowuk0YxnFXHmAY63LMMGIjbcQwIpLlqRjGujUPM4xqj2+b +ZhbjOKxuGeNoJ4xjPmOfmXGEq66ycO1SxhH7kiycn8U3mp5v3KDRo5mNvjjbOMTuxWzjchxfyjYO +UfMetnEttj/IPo6rXc4+2jXs4xDzn5N9XM7MXZz9cg5+7m/nbzdh5mBPa9SDHFZoJO9USBH/JnB6 +LqNNkN90L6dfpV9nB+N348JZxfEn/MwD4DXC0GDKAE44o2HwggRlGeCtKTxeWZf8MiDU6QTJfYx3 +zGASvOrcKuERuibij+N+5LOYQmNI5mzrEUgD3qWsYFUq6doAajChczWwKl0unR4KcoNENiTX1uQn +E9ViXVVCYaDHlGF3flfO5D+cFRmn5fhC0DApahdT4kZYRTVzY1XWIQH0/0WC6mOpfq8670wVgPwv +JcygGqLH1AiOablaQxOAoW+E4RIhEAsTb2oc0Ex3UFbkaxGPk5rQv5rsMWs79mvUzZLGmmFfi8k3 +Raqzz+9oIyKnNJL6Xw7QqpnmvWbgUHrJdw5mopJyNB2M4flnYM9z8JfgLYF6ZyieHbMyAtJoDh1C +DGPyrT4bfW5c98ipZpbYmnmjQIo4Z8YD0el07JiCigHascf5KPiX4Xx2pWM+jmPfREHobDwvHp40 +NTE/MG1ntCYvmThkul04dV+9mU7evbAHpxTdfXhSJ9kl24yj3NPNWXQTUZTKRvCcRl4wBhaXlG2N +WWOP8UETxZJspoeCfJWQRae8Wd0obzZKd+tdSZN/K9J2wx8mVMykJayoEklh0oAWJQLhEZdSIjQK +4Up7srknm3uy+fnJZjMQxLElwBOJ/BFauhElUHbLFZh8aG7QQerDfMWPE+BMBGWj0cMRgvSAEBrg +hYPAEWbNYVByOGQWSEiAmvisoLNNaMH0M48A6qhWveDBR41PcqRaBOD/dFDJwQAkso7fxuo9cjAk +t61hYodKk885eMA6ZHKi1VOzAmsOJhfjJeNEoJJ0jgzm6qFABZBWJ3MNjrSoLO6ZRNQTvNvWsKbO +i6hH3RjSiSMYsgJJMCofI9kgg3+tXnsZbB39U0QEr5HAjldJIQU0fITWFLW+0tR1Iocjb4FedLNh +o0czG5XFhS0e0rtlSOeCgIQ1eNkDF2EmBNvFuPnVm6XYqZRnLn7qWJZiaHTbW4ijo91vBkzTYA3S +WatJJ/VUbNS5sQE1hBck9K2YE3o2GhzxZc2TCLKRHOgtHSKpsbLy2/tmAMJXHomSmpoZiVokPZGq +6whANlzHnAou5tKFJtnqjbBBM5u3h13qUiZ9YpoVhi4HTdnI3Cz0sAKIKu0TgGIUNr5y1Nq26kNH +tz9ly5i/uqZa2aTnyM7xUlHZwIiWJl/Rwj2NV/pi0l0Jwt0wdppnY2k0QzOTkp0c0Ak2gPcIXi0l +iG7jGUH3wBPyInAtJC/SKC+ieXABwRkEiGV0N/pjA/CwLumeN2ZP0q971YS+pl+OVNYy4XsdZGkY +UtWW60gUMKzmmQrPHSZAcQiM401aiNFVtZvT1GUBeY+YBPIH5gQVoVk3ZYAhcG3RqsYlzUjCJuSS +O+bobONWj+a26pAdFAmfTOBlYAMaZYZJZdcwH2nLqO/ywk0DKjDZNtjkk40D4PKtI4zJJpvnqzdr +tg+B4w0kwPlbSHmZJZuIJUbbSGDjjUT+a7iVABpvJsJG2wmwmRuqX+2xZaOx95HUMUPHJMR05qzj +jQl8ruDfqrcF8BnW00AWjyljsCE4aSVj5OsKqemgAubyPxUjP4I8SEVK2VUQEA0z48HVFRk11+ng +iBglchjIPkVmWCcHGkPbAz2yeXlPYyBWGuRJbVrNPIskMoj04aXtwJ1xsdrSMijFKgQQlczBuElr +R3NaC8zxyfwtFgl5lpGNKVoobBFi8G6OpajxpKLKYE+4ZXtiWBcygVSqH2HKEQ8TEa7cbOgh/zQ4 +fw+GO0sMryzUA9CA1JqDGPSzpC1mojCRI4spR+mHF2MRKgOeDjEINMaQOWbaNUbLu1ZGqSelEKiW +5LRhYMm6olUTE5NZ8L+NYt//z95756eSJA2AewHugAwChCtfBZIQHiQhC/IWJwlhhemenj/2txfY +4+w19hp7jU1T3hfwptWv+eabN6gqKzIzMjJcRmSQ8E4IdBklYG5JMdrf2CuLmSy6pBBe+C5KShe9 +QiEr4EtSKXzurqZ510Supxrva70yItYQLLPKQ6B6owloQVv6zf0ZEMfC2gYUuqyDgG4NTrzsAoZV +kPCi2qrqEYtvnoKXSaOiWuJX8OJr3AD/DXR0/SN4Rq37KmaAGzN0Dq8r1o6wqh+y5W5K4t1EJkkY +zONPEijKBiWKGmWFnDZP8ziECBZdQ3c/iG84ZNrSeHxIgwMjJpWEffgtPF+GKSYO34LtyACLT5uu +77HfnPd+KXQHLdA/lb00hzcPo0NRhQBi6JZfHl+BjuJ0q+pnDL60OMbBlHgeV0UhKBiMqSy5+CTv +MzwCq6f/DoFGbUTQygOx/7wPDdKWBn4+2eoxba3nJPHdE+jqCQLlAtrRK8xqZhzJhkdOES21QuiO +XwIZhFi8lli9dJrz3CkFc6JoUvCk6RgpGT4z0rLmqSdqDrya0HPgdSGKBp/paRo80tMMeGSka/VD +15QN4ygMtA1RsRB1Yxzqx2qkcK3cY0lViTaVeIIWK7wlGkbiDeBel7sT9zaj4BNdYs+R+KJ9dI2U +Zrq8cSPz8v7TfRUzwI1p+2bQFQXq0VV92r9sfbKwUjt0wcE7ZCiYhwnVZauNjK/MJAh0py+8V0+3 +OUhCwPtQoJA3j6bUmxnnl6JrCuy/ZTlcj0C1mxfoOee9ZzIJhB5UYZUtrVojTtyx+idIXOClEZ9A +v0oSFzejgUXlV1YMinqGw8LihxGQeogcjtfTTSOmn6cBOfnVEhu6KFNwXHF4OQWsQKClNXT/K0c5 +fg2ZPSzaqKU2j13nFuoapucDEeIcibeIuk0tp26TenWbEwx6CyfouDsSMCruzgkGvUX1SNJbVF/F +DHBjhs4lvYXUq1qkO3U7Bh2HAokC4vHVWSTMfrTTX2LATGRYdN0C0gloTruiUP2goSVI00qVD9XX +0GvIUI5fCxR2jWqvyPLad26RvqHOTvAcr9W7lRXjJMbH47+wjizWrfRLagK6EQheog== + + + jpQJBkWgksitmvdp9Ato4FZ9Gh0EGqYaLUUiIl6Q/9YQkaBieeiGHOlRzAA3Zug8L5oL6jFK6q96 +Igg4K+BpavDhwOtoeCEsK5MYsNyTNiSGHcYEvoyaZkyYBq9iOTw03HXcjoH10GjHr+FFaeLJ4xJ9 +5xbqG2ayw7pFHk49tQQo6rYyCWK11gsRIvVVT4bqh64JUTM4iRSherkQMUr6vpYcJW3VLUHqwsF4 +K5cjhkoa7GnBxJ4WDBaIYLBAJByo7Gn1I9Ge5vTWB6cCrTzQ2tO2TP7nyyU9pn+FPa1l6dhABeNy +YU9bfulsTzt1am1PW325hD1NmtjTWlrWPPVEzSLP0dKzaE97pWjRniaN9jRptKe1dK1+6JqyNTxK +b097pm7JniZN7GnSyZ5eULFl4Z+vZ6PhxaQ7nHWHH7EYfozUXfUL39kYvhHwm4v+HPx73vzqtGY+ +fMGkPzeZTz/9p41h46MzAapxuzMJ27/z45f5Rr/fBTt1/NltiS3ro1E/AVTs8SzuP/+jAX4bmwI1 +AIBQt2dt25s0RSBK/cbMsT2N2l/B9A5tWwTC5APe6gNjWzwRkjV+ARb0fHjRmH1qQOc/G5PWSJkk +aIVAmDStd/4z8xe6f3QBwu2B1hGIxrgzAWyzNpuMeh0wsDhec0AkmhVfMeVYIAZQiBop8E+IJfj/ +BIH/i/4SQ5DtRrtQ5wr5oa4p+B/Oj4pc4G7JX9ItrZsyDf4jTVj1n5X3i1ENdwPqlvWzksRM/upO +ZRzDTknUIeCFfhojmfwF/fI6JPN+3iuSV7kDzPYkGJe00xExJvySVoPbgOZ+KuGX/gMxlfAjdJFx +StZsFkWdxYjqGg6hGxdFmA/nlw1Gxd2sUARvTfBzyrhgxA3JczCGCOZHotuYYFwmj/gfNBvQqAm3 +o/ZMBUn8RrqKeepLnAxHfw7RH0BmI7ke9ifOwDT8UV8iC+T5Hx3pbSIv5hiWun0wM9ge0Eh36McN +8FOs6SbEJlGgLCRuutNus48AGiHUZo1WbykIXseQa0y7LeVzvMiYpPzn7+/TDhBopPX34gdH/f4c +XYYxmsQb4zFAGl4c8FFHRF9IA9RfBaj0F9/fwdqB1vXuDIGjUD/984nYGAzQ7pbu0NFw2oWpnfJd +doXudNxv/IX/hCmfCQxJXDUwkSsfIDaeIFElLQEm/qGrHHhG4DQ5fYKUygdz+wRUCY2kYQLgXdbc +vQgaGB2MJFbjE4XOu3/P7/OHVMMJY2TiG0rwc4wcaVZR354fzd+/5wMYbUxmJiuW63eGbQ8LbofP +BAKm4MqdE1WZnPK5xeBt5pEfDdvz7szNHNRQVr4DIP2tCJ3y9TPX007xj87wvN1GJAm7UJDs6bYX +scCEKtXLtNYEsrFhXRbkoUIX78EgPRoWr6U4i3ITyjrKA/zNafD3mZIvUfxPpzWHQ0Av0Ldm8gze +38athdpvJtTc8o+1MFoLo5ULIzMJhE+GSHgIgg4fOR4WOYS1JvBtz2sJ9DdKIOpvl0D8WgL9ZhLo +aslbmC2MKhOqXJtUayn2vzepPN9lvhZo//ApeRJowlqg/YYCjRNoAWXXUeB/WegDTAosje9+ZRl4 +lwK8IUD0YLP47hoC5o3AgnPWfkJq7ShcS7UfIdWSAr5Kj6F4dMckCyvdoCgUmEOdXHsK/+ViLbkW +a7+ZWFt7CtfS6Kd5CglRvKyFzb9Z2MDwybWwWQubtbBZC5tfJWzc5B6shc7/bkqGpIe/QezQP1vs +/OuEBnS8UTwBy+aiG/LQeRHJMwyjic/jeYplcE1pgkaeOB5G87E/6yhpQY79u/BbUsCXjhOwDAi6 +axJzXpY1Kd7lkfH+PjzYE7ti1uzqx7GrparHrdnVj2FX4p0JBC3Q8NgHcSt45SjHmF3fseZXbvgV +u+ZXP45frdWr34NfSeoVvN+fVNQrmkdF/9b8ahF+9cOD4/91/Oqn+BD/uaxGYeqWP/B/UNklT3xp +zU0cuMkPD3T+13GTtbX2I1jSquOYSByeC1hZUkC17Vg+yRC4JCghJFeQ8vgv5V/ruNY1B3THAdfp +7+uj3R8mDZIMTkOieB5eLIhu4k1SrMnllOsz33/4lDwJtXVU6+8m1H6Kk+AftmvW0ujX5r9TAk0z +qAwsvE9eAIoVKoPHrENd/9357xzxsyXQv05+rN1C/0zW62QI0NgOIHlYcgyW9qBI7BRiKIZbhyAt +yL3Wgfq/G/9b689r/fkH6s80leRhbr0/xnNA5sKghjhPMLRJdeG1/vxv0p+ptQT6zSTQ+ljiR/CT +tSD7xccSqFQMyTAMujqGhGVmkD1CCvzy9sjvQoW/z5Q8SbUfnom2lmpru2otjv454sjmtg0xTpwS +1jfx/sstqR+eTriWOT/GklpfxbsWXD/HjgLv4wwDqBnbTxxFceu7PP7l9tMPTzVdy7K1/bQWQ/8c +MWRlP8UpjgAKll+6H4DlWJpdG1L/ckPqh2f6rYXPWvishc8/XvjAoAhgwXOsX3biscnkOqPlXy58 +fnia5r9OdEAfnMDyhACPeTlW4EkYf8oRBI98b5zAU6jYNQGv1IFPSKV4CMMTP67I8L8opNi0+BOO +I+YEAkej4WvBKIYhlvc5/T5M2BPHWufg/Y48j2NZkuHQxWI8rJVuduUMDQuqJzFfxBXWBVQEcF0w +aa13//3s3+nsgSRxZl+SYUgB/mIIlmVwUgmZZLh1aPK/W7DxPzy1by3YFjtQZ2giCYVWkhU4Hv0g +BZaBWj3B0FiM8QJDk/AHCXV5StHq14JtLdh+umDjxJtE6SSXRDdoMQJJEaiTuMCQ5LrC7b9crq2T +Pn83ubY+31iLox/lZsPnGwwNlGh0us5ScYIigEUVp8gktbas/t2HHPw66XMtgdYSaC2BfqEEYjh4 +0EMKBJlE5RQ4IU4mBXhAlyTWAujvFUDk318rkF9naK5F0FoErUXQLxdBBMnxNFw6io8zvECioonE ++nRpLYJ+eMLmWoCs6xP9HWyTphDbZClBQLGxDAfvWUF162AYHrOO01qM3axz6n43hoViUymeRsnf +DMFAPSMOc8BRUJYUpoUSw4EVDEUejyO2flhM6j9s16015v9FeBa3vmLrB+vPf784++HVPdfibH3d +yT9o661l2v/oEnsYmSUwLKBkGHvMEowUcUzSK7jG/nehwt9nSp5k2g/PPP9XSqR18t8/khXbJP/x +AslCzxLO/QNGBbGuH7Igw/ql2cqm7OYKwvTnR5NhZzJdFbvRAZVZjO1aAP5z1WkA2oXkNZ9abcGV +s12R3bn+3iOf/EVu8d+XOy2InzVH0XKUyaTxl78ymnT/OxrOwLZ6CvGUfzx7Cv+jdKL15vy3b04s +deqTxnD6PpoMViWiVADdiScZPzPpy4vGDIxhiCQVIQmvweiPzs3rxUx6ir+ZdN77QNu+0z5sDNuj +Qfe/HbOm9/Ah408cAT0rNO4OL0bd4Qw+S4rPhvNBfjTudlBHPKXuv6LqXxSpo1lj1nm9ApK1gQdM +EvLLaavRh2PuTFod3Ic8GPSq2h12TMEVOh+TDn5F6oCVGi2AfbOOKuqOSN0r5bPfzxh3xbbLAKFD +Ndsui8q2imvXuoNxX+baXtR5rMfjPhTA8Dt0Y5KF1i4aAWAmgASth340BNqev9wf/elngaBZi5m1 +mPnHiRmFhu3lTGEyGtc+G+3Rn/FG11zAqEG5NoAQZ2/2hwgnRJxnJf44Gjda8Jn8oNmfT8xNe5OL +RfQ/8H/uGl79AAqmP1r9icjA0Zg/Zn+N/8Vs+6I77PlznT86/X+xAc/+rwz4X4RJ0TsK1LrPVeFR +A9IbF/gaztCO4mUW8D6diUqhqOr1uwOXe+7vcDEqXIdjaQIfOVJJXs2FYC696OnleIZdjiX9nLOc +X5IQaDmPte6yPipFej200xoTtWIfJyh41ZifpFm46WiYL8yzq78TFTPE0vy///3Lf9qY9lbFPksd +wDghvt2xTlK2NK9sJdA/WyH5hZS+loM/ditDG51Bu5iyNNQXMoR+n43hSlPHVtvaObEW8D9FO/6F +Vvpichw6N/zSPlnSC6KB5dKMlKV4uzHpqZ0MrekEOUGoOMlJbf7oTCRPMkb8uNFFnomYutXnaPJf +i3WgWAYGP1ICh4Mh8QrAv3qLI36qc4/YuXQ4YATpvTprlq1i2Y/gaWPenz3b+8C97SgUigQjj1i0 +6kkO3WHIC0l4Zak8Uy8RsOZO8kD2KPlaHLazkxka7RQ+YeGT17PR8GICWneHH7EYfpzrgP1z0eh3 +ZrMO4rAXTTfjDD1egQ+REgYw+RxGi3X3X5/+ue+i5Q1PodvP7qwjfueMrgYkQCDr9B0lGY6lYWRx +kuZJmta4AMTvrso5/1WnLX2ZpJNJzSXJSZqhYLqCeojKl/edPnS04o85ludJrZtBzt1Rf4TOQcRv +WJ5IMry6Q5JmWIrRfkvK3+b/akifCgKNvBo8T5DwdiYjWvFyiF/m+nMJoTT4P1JAeCToJGW6EOpP +TxsfQBlsiF+TPMVjpDJkUkDrwrL4B8FxAkIfz3KYrymBdDzH8CLIAxgAXj6gk/7cAcMaF42k8XIL +ArziA71iKB5d8C5d4wlDxdHFngwJIItgKZoHYCkBgKU5PVieA5hNIrCA82rXmGEBPJibIo9WAxY8 +Kh8kCVOwLMmSFL59lGSSmmVIcvAabdgGzx2ARViQwcLRkuBfAJfQw6V5huUhOIFMcpo8sHhSutWU +S+JbUeIUDVBGS3BZOFw4/NwBm5Tg8hRNaUYnsDzLUFq40CmGaB7+n3JtqgSXgtilEXppES6ASmgG +B7HLcdqOMHIFXhRyWqgkWjNA8SqoLMXrGITAJTEuFcQzSQInk4rIpXA+gUhhDAGRkISD5SSwgHB1 +O0VgwSbSjJaiIBFAuBKJURjLGC6L1kwAts8Bz0gbkeZQ+gKYF43wJyRJisNbOEmji9MgDUgCn4fp +DiI4NEgGrhQnrZTA0wIaJA12ARwa6J5HbkyKJmgBJwIyBI/zK2AeoMCpoREQk6y0q3iGo1H+heIU +5Vme0UyZlJZbnjLeDxgoYH7SjElSBgsRiWYIGAnKSGRoiuVUHBaOksO3yIMfhlFycO+TLC/BIwQe +UQ1YN4I3ZWZAq4KTRjNAGIS0BjpgRbAMpno4ToqStimgPQoG5oNtymD0mzDJOMPA/QMRQINVYtXj +JGk4TkEQ4SXBT3z5EAnWljEfp8RUySRYHV5Ze3GcHIDLoOkz0jCTHElQSJ7BCuACjb+mOQKhRE6P +kTYQjQGLGwjtH8icwJAkdNIcjWRIErBqwvzSf0ZhyjBNB7Eqce8QcKODhYNDZOUtCQgJQWRZgjWF +qLA5iY2yeMmkLclLTJ9kpC1Jg35xsaQ4oG4W7WgCIAAvNNh34vahxThsDIkVACQ45aQEhyQAg+Aw +00XB3UA20TxecMiy4C5FPFKNRvEuaJEPURIekwZmnCSTDF4UgFZey4xlkYR5O+hZOg== + + + UZAlEo1WhyIlnskBdkehGVMEojugdBCshppkyczhnCjwQ5adSUToAtpA0vwZGvAeAdEyB1g9/JEE +PBMLZSaJuoPoYUUuxOBKDxI+oTiGWZlwj0t7EpZQROvBQv6GNhHPYGZCwWUjZUYBl1EUHbRacMI7 +ioHghCsuSFABRTAkHAkgbsQaCEDMHGYgHFIiaJlRiutEYVaPYQpwqGiXcxJpUqxAkWjKBAd4MRxo +UkA4IEhASIJaSHBweLAXhlItE5QTAAEsh3aRxIlplhST2ICCJeYJ8DzakTTeDJw4fQYzIrmShgiV +g1udRKJNoCSgSY5Fuxm0YxF0PsmjQQOaoNE0JMlGS3JelElqyYYEm8w+wZd4PeBmEjjMnziewUAE +xNwZqbYHJVEUqV0rSKlIaZCVHAawQ8TTuSQNtD4/1neSon4iiV1xk4J9pSA0CWeO0SlhkwHaO4EV +MXhzOxwj4ClozwLdHK+zOEL5tnYCM2YME2GTRvwY7yRDolZt9D7zI0PAf9P9GEJjJiw2sHJdmn4j +AgcQS412xz8b+bE54gRL21qBYupVtYGjb69AMguhsgGka26KNGgX+FGAXt89YNOPIPhQ7XvemHSm +/uzwow/MKg0Y/J9HFcxn/9jwCSIXuPiYT0Ez8yJ7Vj8/K/oBD2X9eQj0Pz79Q+kz3JnyFoAxfIGe +SR9QHCJs8D8qkGbdyL2ArcpxpEas8oBytYJWQOIFaSniUTONb2+Q5A2N9F4oZQFTkWQDwREkYg9A +kxQoc2M5KTJIXuQTgkpbA4wA6b1IDSJVcGX9FuhtSFCwgGdpRwwsX0I2OQjM19DQJf2fQRISCXDA +XiXQDE9RNAbEM4y5ssFKgkLAbBfKabVqQEOZRpFo1GDJSXlxsD2iWVDAEAxrg55JqmmSRz1QApAs +ViqfrI4LimoqQaOS8lKTcMs1/kLxLRcfbn0RWHeEQl9WyDgG66E8CRRnJP44DijxaABAl2aRVBEv +99D/ENEPF5aCLFXWbnmgluBMNoamCSxNGQKLamDXIG2Ekv8rGjBQTWYhollpATkwALRuLLDdEN8F +ywWYM+LyJLbmaGlM+h8YKo+EB49oWYIK9HWkKrMUiTcCA6wtNCYgbkmso8j/VWue8F8ohyWRCUaD +1pEBKg0iNKBAgN2BVBtR3kuD0v8QwVJIvCPHAPhXoluOxfdREDyS7jSQkBwmE4ARRlSYOLXqhfUk +ltaoXjQD6ExACgvYvcgoY0lWbQoB80a6t0X3Q4TLY5UO7SxeEpgUdEUhK5zn+CT2oZC4A4XJyP8V +iYTAexSqHOBfSTkmgVaAvhPYJPYlCED70uqx0sj0PyS+QiDjHxI1pXgrWAG3JRiKwBoXsN+0DoGk +yKW0/yu5QJDSzVBo31PSlrvtNP35UX8EReBoPpY3H6xlRmJ/B8cI5tYXJd0qIBufGk7D0bL1SSm2 +DQ80MS1eObykirUkKaO8pOlSYok0kcKw9YD0Ul7Pc1mKwho4MO1YXuNMtHQOsayNcygpKmECAQiC +0sIDJivgbfCH2orH8Cg4b9owPk9xUsrgKLQPeFmzlexUwDIEnEULdoTWucljlVMkWrXXihSSCuWS +GOZFTnZaS75pxVutdmP7zsbY4Y3eSC7vanc6U3vx7aLc5QNaTUylMbjcNsHJ4HRHI3D0u5vMhCTw +q9pfg+aoD8H8H75QZTQAWmWo0umPwf/kGtNeBw0c6IqtzzBUP/8Ao4KaZ+iqVoNN5n2ANX/Mf9X9 ++JypHxRGfw7Vf1c775r312P1XzmgHf/ZmLTVz0qjifjofNIEf59PGsMP2HVtBlRX1d+5+Ww2GgJi +Mj6j1M/qjaa2EXygaYE7wn5sMP32Rwd9ANdLfqD5AD+iwSPR5Q4G1231OnB8yOcvDRbK+LCId7BS +aqxbr55IbYVRaz4AJFRozBq+wGtC+tufQn+pzrng33en1bNRu2P6cs8f+s+gPwSvY43ZbNJtzmc4 +yQU0xVT3vwCxAviqVq3Pbr89AbhHbaTYGukt/Gf217iD34Z2htPXPxqT6Z4quV/d9I8GXHvcFj6f +WrSD6eK4mTiSqeavfyh2hqNhxwVi+iNA4W03mJFaRv/eeTW7wzYYKOliboA4ap3ZGZqE8/zUrVe0 +/EtigrTFhKv5dxvNfscN4Tuu6j9po6f+cL3VYdO/maLh9Frz6Ww0+Hs52a+jw9S0AeMgoMwDW8wt +Of7yfVGDN9f8mKH8Drt0+v7nD5bGf/M2mPa7rX86L44JpBIaZrm8rpb27+a7cCqc01T+cjOVv/7u +qZAcLdBOU/mz20Zh7Y7TERv+A6b02UGWqos5SS3/5klJ0Z9WE2qOgKU7gOb1+aQLrEU3UzN+8wNE +PuJ1tdF80urkYBD0StjeP9ogI0zeqjE2a0w+OjOgB0CXwfSo4Gbpjd/8zarsxVmZYkqjyaBhtSvV +U37v9ju2jTWTVbf+x5vnhBMneEeB0O4sc6Xt37v8jpPqDsE4+42Wu2mpW/9wvo0u2xk3ALiWK41B +2/5v3rRbJfR/LjbsAF4lhI5a3ExS3fqHE+ZwdOppatr2P0DeOjPe/5lJqxVKf/doRuNZd9D9L8os ++CljAlby3z2EQWfWaDdmjWXHkVxyHFtt8fzDza5TNUYf45NCgvBLP1RAajfl15tu58/c6D9392L7 +x9NOuzsf+K8601F/LuagyF9kj0jSLx/HAFqZj/2lPtzm8EzvYtKBqcGKe5hjWZoVZ589Svobk1lz +1Ji0/S10FE36m/IsZfaDupAm4e+CUTRmHdCwg1zato17w1GrN5rP/B/4jBsRgZKDBkdw2pl++q8a +UyA1RYJXzRR/wVIMJVgPmvJ/oJMvd21ljYMmNOM4n8/GYKD2I6FUkNXSEIyg2/ZPxevmXIxCQbPj +iqgm59hWnhypWQ9EBpM/Ov565z8zf7HdnTWa3X53JkpxkpFhGomp2hh+zBsfHf/FaCwtoV4M8hJe +2uNuHDeRQIKRTXQkMkCXGGgeNfrdqe7RdDwSdwwt+zvGjXZb3lfZI392PhvJK2Yk26R/3BiDXTDt +Dub9hrKK8rrn+p1OG9qgN8rmJi3xq7WI8pPRODvpNHCKs0FmhpRYQFK/4f00ZfxFxMPoMx1LECcr +9wY70PgaxMFKq5ZvDP9oTGsyOtSEQPjfZc4ANmW/O+z4pyixeGrfeCzRz+iPzmQMD4in2lWGyBK5 +Dhz05bwBqctfxZc26RmE2ThmgDJxS16hcE3LCVrn2B8deIuhv9noN4Yth0m2+t0xWDvoxf8P2Bsf +gALEgYdIJg6WQ8VIe9mj0rzfl/B405lMofCdTQxd1Eq3/jyEXB/5syKFmO8L/d+EFkilflr1X087 +/qMB3GDZKQpCgKxy2NYTo9xeaSKGD9XgdZESSfA8rJrl/JVe0pk3xePCF0vIu86soaKjmKGBMY5H ++sBfGwNTaTIF6J51W42+nqwsP1BiUwz0ZfwG4Dhfq2n3rylslESqNtdJO7BHw1Z/3gb69ABSjJ6B +mX1RHsHyADDHHrCjZr/jYkh4usXBePZXvtPvTy0JQ/6kXriFvtCKynlo1wNa5NPGuC4rQJSL1tVR +S8VR9Suu3y2j8V8G2tYhSkSm/+70whymrj1KVsaY9J/iZG9Dv+o218Puf0w7Vje67Q7boz+nOmpX +teiq5aZ+hEkN3mqNP+DWggn7CoTREFKKX8OfXX3jh8vjJ8QFIjx9RZotq9NHlDg+t5PCX9GiouLp +I0YcH+PpK3ahr7iFvuLFr7yhUNDRkQ1FmBOUDo3QO+1ET4S7T/AAzZfY/psngpDoSfD4HWWOe8fv +6AW/s6Arx+9Y/bpZIt6U6ygSvTZvvo/67c5E8iTCp9OwXuzqGqvMNS13KMzHYCTQ+FLGkut8AqpS ++XNwU9RApDetcN4z5eu6d2obQPVexzmL/xmPJjOoBqmlq0q1zqFDHpVybVCQNE6mWqdfacxA31C4 +9OH0pip916LtEfS3HhXULdWv6zBOAfZqNj4UMqoanvZtfTRWvZPPj8v9EVA+rzrjeX8qC8A9+Fa+ +3EM3Uf3dH4qCA+x9pHMYZS94Uxy2RiYWNngDzbjzoaKXqd+ha2YQ7qDmIFpQClBgCra6yrhJ5U0J +aFN1o/MYggRm1klnMjQbCNCtZfVTPfZBE6AXaeymHQFin2LSMmyhpH84UgwNf3eINPjRtCt14+wR +ofzAOLTxgqjtBdQWqfN50VC4UhsKamsENcWTStxgMySnMUPUng3cWoq99jeAloxdHTqXgsYNgT+C +qXHQskAfIZNd/5Ebp1DxouYWB7ixNRKMbc9Fs62mNh/VuMLNbJClnTdu7jxxLYrxV844dtiNcvi8 +/7bTTNx0251R4nQENL0ORCpQHME+7Ei4TSiO8kRr1IflBABkI8tWt5vO+vE27gIRtSwQ7MHDz8T2 +ikfRzTfj9gC87g9dD2rcdg0cx/zJX5Dy9UrqhuPxJI6EXbwPg+5dtZyNRO8Sy/P2LSeKYSMQpH1b +HGegY++aNYRt/xyJFeHsm33qmhlw+jVqApxOux/DhtFpqG+IlrYpxhnYQUQNR/Ak2UW7xrTZnQ0a +Y/umuM1Et0/MWrf6k3hrNIRXgUGXnM1QYUuZbzfRVUV4/rxp60k7Dmx4eOeOwwBAw3fAmqRrxpAo +Nm2FhITRy2fo9Q94QDuOf7ps94f12MYfg168M4Q6hrsdhD7AW0hZTzffgEWbwQvexLHEKdaU7mFT +sKkhb1YFRFkOfQy2SHf4PnJoNlFddOXQFHlKm43J1Aa5qGETqlhgP6k4hIvGMpNw0Xai8X84tVYz +Cs6y+aAx6U21o3bRWB61i7aqUbtorR61GZPXznE+7QCVGCm3Nvv4fTiLt/vjyftoaLfdx9M4VMwA +D5nak8U0DngmdMoOQVOV8De0/M84PtGzJCTwzVp+uGFeoJ3IuxT/shmalHbYH24NcdKeTLU73lQA +oWaSI3o6te65NYhL3vXW4K+eDRtUGo7wvc1aD66hd8xlbHuGWoLIgq7jtbgf56QCfb7tfwrVbs8v +nsL+PygHHQiOSyWczKQdaAO1mO7QRnRC+eo0ZNhGVFlESZA0Z4NQpCvsT2Aoq1bqCMsQ0AIB32z7 +m3/5C5PuH+hubDu+DL5XVCwb5ULDiK1UCxNvraEROnJ0JTOgjNeMzVRaK+tvLQQnH86CErQRhaSq +IJW+FapCJcFybGcjdHGjcV8KQjIlbtSmNZzaoRS0mXX7agvbnH9OpWs2bdogHuskGyeSHDAbMma7 +miUxbTMFprN0MmrObvuaYzezFs0utIVsmww7Hw3lZNNSAADFdGjfpk+2kOvcYPbphcRno92ZqI4i +TVtp5QhvpgoCZq4/HTRl+P2ujZIMGozGLRvFCDWY2kwdNWjPbQ12mx0MPrffwFjEzIctVwwBtW4M +hyMlDlUMDYBOlqzU0K+4yjxHBZDq9shJoDstNrhdTL0IhFWruizCHex5c6GILCQwZA== + + + nDhtSRmKIdXv27ea9rpjYOYMbYQ2bDYBu3Ey7cDhTdx1K4UduGf10hequVkNB/osZI+dlgqOR80j +YAyoaUDn/NKvKGHpGFIWS7z4+qJQEp1Q0JaBAW6j4VTvtgMj8J/jVypXldrt3PijcwrEf3fc72S1 +aHJ08qhqKfhVtx6vwL8DZw/m9wpT7POKTiyGQdh+5yYmw+w7CvZ3gRUvdHQKO7wY9buSVDQ1HqSB +4pIRpcloAJD452jSq0uSibGZ3uloOGp9go86qkmedIfuTF9p0DjQCrrthzNxAu6wK0UxZYEcbTZm +1cZfHcnMhFdM2S8LvAwC53Oi05Zsc/SHiy5RrITVitp3ij617tXb8lwpyqG5QWQ+VYPb2MsKwQIC +yJ1y1AYr1X3vSuyL84AwhTpc0L91uA5jO2lIl9aY9i56JbhKRBNmXI5kSqlQAK1J/Z5Uea+1X7oK +g/RGMlXF8WozWIvNqB60qY7lPjbL3NQ3shRrqvU275yDR8SuZ4VaLdRU14Gi9rtUxxsMH7tggiph +BuM5AY3mG2Mc1dl1EB0MhCP5gayVBaVHdAJx2gBSQkm/cMdJCp0pGFrDvQSVWEd2Yk+8JsxuQUEk +szkXmACM5Ujxllr4YKXW9Ul3AJF2q7LsHWWN2XTshnTV+YB9TJ05s043cWTM6CMcINtVqbjW81VO +1J2HXQKb57bThKHuzjxKRURqvuQ8mLqduS3jBTIwoBDXP+eD5rDRlSLsQvVPsNP8jUnHP/vs+EW3 +k38qBcL9+dkZ+qc4wqIxVBfq8kMu6m9M4WNF95Vi4uMoPmSGgGuB/TWa+8eAc/oBP+ngPY26xuA+ +YBWerqajqB90Jn86BDOGF7OOYfKZv4tOzhv+fuMvGH/fGOPQEcirpvPWJxze0bCAjqoUMLi3IUDq +HIxu9K50353658MerBwSd73zW5Pu2HFjocYAI4jL1FXeGLs1k80QF5SGZVTdkLrmyJ9z8iEGxTpt +LDDwjjEGy2yqYCDjsYrtOpCwSorbylEcTwEjK67gIlu7h9SMVhfOaAdfYmYujJLarDFsyyHRLnmx +WErlrzNbl4dj7LgzQtXqgf26IiLQLiwwl8EbrAzmZdvQlflpNh3AV/vTGbDI53Jy0P/3f/8/s//3 +/7LHmfgZ2F/vk2+tHX807PnhlW4qE57nk0pMoM7EVmaWyHWlkWdr+aMjgS10YP/wJXN4vvMY2b89 +CO417qLH9M55LJeZlAefqY/hxnFpIxoK5ruN+HSbu64Uua1U5rqcPmUOU9Wn4GlmMm/xpSJ1KgRI +htkiiGnhq/ARJbYzey/x3cx+dDzNTE+ohC+Q2atuTKRGx7PcR+WymtlnOrV89yDdKsTjwQ9DV9X2 +PeiPL5QCKf6hPCt8PeeYh1g0OxhVp9mj2uwzkua25qUCs32b++oHb32Bwjtx3DQFts0n3/mby8en +bD0fv7HuVN0u9ZzZ75WeM6lpfBApRAPzUqjcfvcFELJKb0DDKLw/3/K5fqZ/l3rPfc7yn/wDqUHH +206hRVa/M/uHwVsMBwx5mn/5eBmBXzvfhaP20UYuJnxtZ2uxrSEew12jPfcFkl+hSKvYYi9D+U/m +dW8/G6B3Irmz6Fskkw9el/Kd+W765njrc6/VavTgr26k+F79xD2TRKLBT7rbb6nuy3E71w8cBmOT +yNM8W63tfMPxhzN7x5+0L8Dt3TxnssNWcBA5ON1L8IOngy7PJ6bvdHbSOiIjvRQpQ2wVjqc3AG18 +sMPf0kQ71c0nGmB9ydODUCzayfX5iwGewX01kMkf7W/dFqNJdgrW5eiR20rz+dFLZP+m/ZiimlvP +CGx6GAATSnO7W3BJHrlb7nII8ZTO9cJcTCTNm3aVIJ+3TguJxv5OaSPyMIG9cPDFC4KCmvgCRHPz +iEG/I+nSvvhr/7Z4gpvno8U3DIy6p44A6d4RkXS6GKUKhx8HIpzbg/299tfZC1pJecAA3nmOFXsB +jXLH8gCelQGQoYMr2KjDoGfsRq7wilANhOUhwz1wX61svfAVKbwnTr6LjUZwO8c1ry/3K4XXdLb+ +2ZplL7Zbp9k6RYPVz/LP91vgm/ZD8e7tcC6jCFOthkxfegowoR+fVKQFux8V3mvFNsInANsIR9Jb +e7d4hSBkX6D4SkZucszdcSkzmXxeM6nT20O0QgLbnXBg8Xajkdwo+aJHpXbiarxLeMILC0H5AnuR +g3moVOiTOeKYTYF/ykQXw0lzzVFmrz7bzNaPZ3MjKnUrqcK7tPB3kw34rA742He8m9XjaX6V7JRC +O+Nw/pO7eig2if3dQmcyiRKdi4M9eSAYHTIyquXs6zGJqG0/9laCO/UkXjj64ht47+MFFWrfg5Ps ++UvutJR/PxYI8qTZLuXbg3vEPE3WoJzrcwe3CmxuVj14yFXqWwe6MfgCYBSd80K5F+iAri73IYeh +iffU7cg4Wn27FvgVnZXHm81kMrLHnOkwsnc0Hb3nu9MuB7ll7PGCCm8dVZRZ7XVSOwOwk6/CkLxO +IwfHD8dSpx9PgI/R4G2guluevbYH2drbcSHRPQiVMID3YIXL1k9HH5mb+lGjVBQu73yB/QhRfJLR +MS5GR2dUaYdL3YE1nyeLrd73jtQB2iD9BmbMO4/BKmCPB8HsVX+8q2532agA9hdk+KvP3Xj25L42 +9AVULFx6/5qp8zvn+ep3ndSIjN2dwns2+KKRAVel0mt44xNNA/DcYQdsKbapeyuuPnzf00ga1de7 +QIiWR8VovXUAsHh5Czb23XYkfcDR6G22Fs0M893uZRtObQM2qRdOTiqx0n6RDaO3cC4fu0PcvH6a +CeT6x0QcrtWjsj954bC7y2Rumgn+onJ6RTZfrrP0zsZ2kQpvv+TJcr6agb/SgMTJA6LTTB2S0VD+ +UH6W9gW03+CW6Bn8MweZYh59iP7kalXqEr49QF/LHeThsxwGld2PlXg2VriiXh/GRdhkH/Bk2Bw+ +KMhd5WCjMwUO7gX2pwWRkQeflr/YQ03gaC7QkNAYwFwAnCweCpwmnjAcFMROHT7bQ8CUXhAIPYrg +kM06RX+KGIMQa1pkom/24Fs0jUMFlbgxHBzG4vBj71JGQQ3hU+5lXzUXZfHStkvreiF0y+AL6BYC +fwORpcBG00B40qLjAM1K+ROBknsuK2PwBbRrmTYjOdslwUNGv+RZ4U6VPzGNmRKGC7KAjavyrBRS +0dMsnoslsg7wTNHOkdBxoMwZNj43Q6pup/oCMgoPdNOUcZLSgjjUjiavfIve6joV10XZdyqK0axq +WqFa1BhiImuyVfbkEV7IzAMTKZ5LCeERgXWLatUYbOkFoRysPsSjDDttxgDR1OSt6Y0M0YJgjO3L +HaAxXnECGT5HvzD65Zny3E38HTDwL1qUe8nsMHv1/nEC1MqTsU5gZOs3J8NShiR7vkA5UH4FOGFD +nEo3mV8G9kuvs/puZo+42IgUb+4qkiiLbavUCZVWoLeS1O0AJUPDAKsvQARHVKYZmQQGy0mOCwLV +L/xoaU3xew/VUpbubR8jO0A7oQgyEHwBYXRM8MVY9J0pnBx+M+pecq+d7NWwdp2tzY4GxUg1EdK+ +7ZcyycBYMiquworxhTs4eqx/Z8/zuQuow4ja1UCDGGCBQi1MO1OVssHvta6vsvzT8VXheLL7ZgYg +y1aej7Int5dATxZHdh3olafnnYmo+lW5HBDbT3HZdojb2w72lgPULiTbAQLj+evnzknh/XJaS3Qv +HoHaXPzOY32bpjYf7Y0hS1PIF1AbQwqFwqlhC/sue14qfN2+5rtfXGLvfRD4APrtLglwkn7j+av2 +CA4upuhHohpb6z8roAAli8B+J8uC25X9AenCRyx8iDu4pNNvQFE7D+Y/I/f5RDd9kBLXSosnjS3S +A2QfLymGMOBj6jW4qCD0g07pLeg8qGKaF4lTNRAro2Injelc2QAXlT6wLBT9X6v9qwaa7HVO8mBC +7Ujp7TWdLJTv+Xdgjhcpgiozp3qwlxvhJ52RgmmsKHX7dll4v46UAZ8uFahwu4h3ILJUoQxIYsb1 +sr/Ts9pXfOnleXerVBzO36hAciCIq78f3U48Cnyrepy7vMiAudwPzkQDf34fyF6e1W5KhXBbeqEQ ++2iH4Hvz5gVRPWmOFRtZ73OgHnpgXfKfTxupSLr8+ipR1nMcrGD8JNc7jQDV/uJd2bMp6Gl5yfWo +gw3lhewIIFLtQZ+AQuQMYvtB8XYAi8+k71X3jDWlM/XWHccvI4c3jW+pgzqf2Tu53wTm4+eGFvZ5 +tlZuf4F1OZhQmeuNJFoDtAIHoTnVgST3jl4APnb4OZ2jRU5eAqYKenlpABD1afF1TDYze9fBuMpJ +RrH9zb33+cVXtn7duAcdpPpE6SlDg9FUYjJ31jswfIFkvzR6t6IYUm5Zl3avGpjL3UurPYr2+5eg +uOxOocl0ao67VzUQuHs/ACWXwhf9vVKBfaAi6fvnXSNEF1a+CmxVtXtz1ddPhE+wLmnueF6IX7Vj +mdTZV08WUXVuszTMi65BQHyx8feoW0jc7WUkfAY7ic/OyxvE51QcXLlwIHLQ2wMWinkqNzhPAymm +UTzOmNz5nH4AqL6aFiO73LtKYil0B0mJ2976FjKp2+/u3nul+ZFJ3ZXUoDDHxrZ7sukLIIm9H73n +Kgi2SnaLLYkQsNNnLbB+D3uFzvi8itQJbqvKbMFnVOGkfrqpdM/f9Kt1IOgOt4uvxPC58F4vvPsC +xejodJ5lM9nHYuuiH9apS6Jn8iPQAww1uclPE2c32Xo1A7dhMmYc/H4oM4kl59mLq8RzqvsivIMV +v90F66JSb7A4OkgAiqnuAgXl6br0uveZ0HdKpb8HYJE/NjLfh62O8gKu1TwrNMcfcbJyExWfgSUG ++lh9+ztWCo2SYd0rslk9ohQQsnyFQz6L5foD4h3QS++BS6fO7zN74yRpnJrYDq4LaMkLl6Ndy0ao +Sardbn4bmzzECkTyIVjKd7hetl5okLm+sCUQVPS7m0mdX/bRgqk4jIGK0PnEQevuEWyawmn2qp75 +NtLG1jTfPTidZlKlQIM75O7K+bP8zaGsHXKifOH3u63HwlHr6iLH3FIzw8K/bG0A4UFclkLHh9Vk +5ak0E5VgcRHjgNBOuL2T7ex74WPrmeFT43geqEPdXQUU0vogsPfOCBLd4354O/AKqXu/2Ew8jLWa +Nx6ZUN/ZrpVet3ZqYH6Rp+LL16yFfJBGfJZnxWZuN+QLpE4j9GO2Xt/Z0BDL4ZEMtip6qUSyqGIm +LP35ZEEgla1SPvsMVMTM0R3gY4VonZV9hni0yV62WM/yyauPJPOWG4BJ5gjLJlAQNKCpFI4No3VZ +PQNWWP3msJfZT49vgazsD4kdExCdXC84O84x95vXlYMnJuhqpqKap4ESij/BXnpHZ8D8KI7U+47L +jKA0PIa+TjBdlt4CJsJDUgGRIoWNs1L4/mKWPbkn26pOD07O2oX2IBlVn1mAkYUAlw== + + + P+99KPwXM+HR2yer2qny6QVmuJGz0VfhPXncLzR3u4Fk9W2yX8r2h5vIHaqjF7D68CgvdZZPPBVO +TvYTWFWjLmuxUpF8D5VS2atNaUFvQ4Dz1xPcQSmbznGBMVs4avQDBv7TvwgD3DxfQV4aL5wcbeYB +t9RuoP3o/OK+lCFmr2DNh83Sxm6UBCbsNfwmSYGdQ7+BbXgoqMDSu6EwNi75Ov8inV1lAtrTNxEJ +e6XQ0SCb/Hw62yoVLk5rpcCYAczltvORoXMPjLIXRTUI/FIULHSGl+VrW/ks+G8lsx+Lh017gY12 +ytBZ/AQaFWnjHtvqZZlQ7roYmjafISMh9cgiptEHtAJg48buLXupVXNU+L1uCoIMHrehyXySHX2e +76otJ7udishesvhsCV92vj+iUwC4VlShUSs/lQPlZwHQS2+uajyrlp7B6me2kSqCziihnsxlTgvx +8899FdWmueiotBuOckANYgLAlMj00WHjXifZuhGP4Ljja/VM1S6IQ6q0F91UDHgDjanF9rj9Xgqd +lJPqRUa0evm0BV/0s7Xm+B1bixS3+ZEbbApfKk0pUxl/S7tSkS+ol1t6v8HvXZ5fZGvza8ooUNhJ +4WjQnQKxlRuAEfa50ttpIGmtAZyn9q8Axk7b1S3z5ZZ0CiE5SrSKzVEl5tCuvnP7XGy8HW3mBpEd +lYCWaEylfRye3YGV7qrO7XXAVPvOMFMoUN5fwSJWdr+Byn10JklkxD6/JsG70s583Mkx8xywdICl +rbLJUZNBSAAcNF7s576+LjKFo/blrHAcCpXgMegRPjfK9hsDpBoVZztHG1LPx3OgjRuV16qZBiuq +sZOtNqS7aPZy9xVIyNaAVLPj4/mMOHos7+v2gzgXoKC06qmzl+a89PZCDSCN0fJh+oOalA46ORX7 +h/sc4yFA9B6BcLgLFd53xlvc7GR2UHrtxxOaXrov0Q+wGtNdPvUSqcHzoIh+XejwkAYKAdPIMsHg +KEneniSyQnk6g2EDQKE7atxlpuG7zcLJ8fN3obP/sqksGNL53xggot/HgH08JbhU83zH7dfw2yQw +riqV0uvsOVbKBDt17WEchzYK5jCSYXABRHMm9imA/qLl8oNQfyo269nbwge709VxL5lxSTxLltKY +T4lLUkRr4QugI8j85+P+dyl7kRmnTqfzkdY1yHHfZPKq0Mo3eoXdbqLF79PFTvHh/agouydRkxrY +8bUSlE2NrBCLb0JfSBmxLYSxiwe+/lZJlArzLDqWvAQaRzBWKA2zp0B+1sO53t5+TFRQdBA/AIOr +zettJXADc0MR6OVmjg2XEoCPtVOFDxW3FN/Xt0Qsi7i7zl6Nqm9c+jvcU5vMEMe54H61GH3OAXuf +owaKcxYhC8jepy7AWPp797jQvOtcgd2WrpTvX8dviEfK28cC8/LiiH7CA8DAY6UtbnJZOQSqzyFg +0SffOTQkyTtKXYZmkJ72ueuLdgLs1OtoKUCGgN18eRUtHG+8E+oZ4MZjkrv5fs8ikVAKVPmUDrbc +GNBYaefhY1h4Hz1HkOvI1H8tsvqcAL3D9fI8Pn7JnjyEBWX1YQhAsNiab74I5xW6nqSjx3ul1+hN +SjcXGU69ONKJbS2ct/zHZykIT70FzZBlAGOunB19TxMwuuO88Ny931KfVisMIHXcuDlV5q8xoy+B +/ntaCpYDpcpANouAgXS7HS8cR7ZYdc/92Xax1Yy2YRTBLXUoPh1s7sCFf4X62r7G0/3MZ/ZeYvNs +Pc+/AquzDSzsRKyRHWU7JWVwGAodyu5l9p6vc/zwqE4Wnj+eKWDv1/qZhAQM8IuLNth/3X0wYY0q +WiztlKtjJRwpvrGTvOG44+4HV4/dP1DFjVgu8TlsN7aTH7cTMNYKvKYrR+a7G49BsF8iu63vArEd +GyLxzm7kd0lgEww2gbp/3SxDz2mApP/PtBwtpw2FK6BrxbU5b0l91uO4MezokgLF+6y012Gqr8i6 +01/FAp4V6gVdRiS8mevjXQrmM0QP7slVd7WVWGHQH67QCvPtpHc+FMOofmIa1xdJs288MI+bCSIR +OY0ATj2j4S+K2b9M0fKLS/kXerFHH9ZnOWBZlHuVrauDBqCX+7T8loocXHGfG2G6crARSwSBDgO4 +T29/I3z2kNyIfnbBq7f3+EZknqptRE/vChsx4pQiEgf3IdQ9WLXwJTOlpqdgcIUeWMm3NJ0TaAEw +2cEDirVBB0rKW6Ly2gGWxWSSPmhmo+Oz48xJcpoWKvu38dLogbkpTp4eiMJD6b5eOsgetMjdLD8U +e6G3LyP52O4V6K/KWU0XTyhOV5PbUOvTN6pOJ5O9aR10Ej0iEkwNT0MZ2VQozW6ol1Fvh2jvkKjn +cwXs5JmY7gPYwjySLm/soImjdSn04ompUGaE770v8Ge5D76+L2g7fZo8nz5dmnda5l/Y1NFL3LTT +l+0zIPd13Sqdct2TcsC80/2N0GRKBibmnV6QT8wmldpVOvUFlG6nwehpzKJT9jPUCN4XzTtlwk+R +ferDfKabpRfGF9i6HverZnMlSrmTjEWn3Nb2cBI+sOj0/oUovZ/VlE5RHKzcbXljf4c8fq2bdlqu +UHVL9FIP6fob6hTQYrOoXdNbQMlP83QVdhs2rmronn7sk2HQKTMykFKVyImdXgSDuk5ZdvA6VjpV +KBl3+zp5/hzWLTrNNDi+tE2advpy+HZl1WkFaH10aO/JfK77G8/Trc/OlXmnl/lw+nt7UDXrNLLX +T6WVTsG6aElp9/Ahc27eKXN/T5SSxJlpp5ulD377akCdm3XqCxCl5+eSxVy5rUBveJq36rRBlKNv +N+adlolssBPi71GnvoAewbOt6KHY6X0spEPw4RlzIKK3+NQraTp92CeqfIyEne7qOvUFppuVzoi7 +asQo0C0/1tNv9fGhYdEpt8X32qUXq04LxOnucxJ1imxk7VyPvlOZr8nZlWmntb0gbdnpSadGE2ad +Qs7PPMaI2mt402yu082TSufs8SEcMu30Jjj8sOy09nn51kSd+gLGuT6WiZuT8b55p1U6cF3K7B+Y +dzo+3jTrFPBk2O3Na3lzZoHgx3Pi9vCkYN7pabr4+nL5/Gza6fN57wh1CuWLca5f92y7ZNHpk0A8 +T/sx807PvsaD86RA6zoFvaBuX49iQ0sETwK1yIZFp/fXRLE7ODbtVDiLbW5knmOAj4FuU9/6TTN/ +5V/FTpt0WLdpwg/Vxi7qlAqmQxXtTKvE224qCzuNKp2CXmC3AOzXt8T0Dyb6TqejnQOx09lhRDfT +jafGYxh3mrsnj7SMMDqZXqc3QC+g27iRKx3F0FxBp/mZgRVWNjnc6SF5EtMxwuiYOcOSht5O5U9Q +p7AXsdvtyaTRHMJOCV2nk0m2M5Lo93hD1+mU/UqJkuYwdRnXoXdz1Hmr+0T9odN45bSDqlzvvIxS +lm/vL8nBjdXbT6LyFpgrbw2cH7Dewo7F12ANdiJ5aVxfHV73lhPI17r4dtoTDLuSG35u3pm9x0zx +4ij1ZPlWoHav3qzffjZegjLGjO+z1M5Dy/JtNTI8pKzfNs/f95S3OoxxW+ebrWbF4muhslPZv57i +t+/B76Tu2+tIV1JO38nNlAFj183j2tDsPeZyhUhvYvn2NtBMbFi/fSqkDiSMmbx/C7zw25Zvv2YX +44rl294NlbtU3howNuiV0i9WX4MhXe6xlm+PKSZ9Z42xQGvYrFWtvt7Z2Dl62rV8W8yeNjuWb4+p +w03SGmPZDWo7nLJ4y1aI4sGuNOdUaE/3NlK/nB6Kb/Pxff2urNTfyrtZ5T0zZaJXWgssT7SDj3mR +/7wF+vDtWDRHS68sZj250fQM/9LwMWq2DS3M/EbsOHkPLMyvOvwnDp+VNqKFqzz85xbZb7L1hnmE +2F/jKidxvskmFTy4iIn8HNg5Gn0svUUHwYfHA7Q3oKWj2hGJU2EYBHbs3Ryw1s0d0N/7vtzfVqJ7 +0AwD7rRZnMzf4jENu51s+gJKt8jSseiU24J2zqN5p8z9g2WnQIh8kTp9TD1XZOlYdgpFXsuq07a6 +U6YGbGRVt8JZrqbqtL2zs6V0irR/uVNah16o/cszLfc1nYbvkfWq7laD4APKslOk/Vt0CuxBoP2/ +KJ2CuWjm+mzZKUDwlLHuFGr/lp36AlD//zSf6/5G3K7TatCyU6RTKJ3Cva/pFuoUdc2qdpJS9+iX +uBDh/EN74Kbdy3wwVO99i5bc1vdL8e7csR37KdKdyC1yYM5PWZFbGrbuW2gAsXOlctCkS/OJyFx2 +ahndjk90t1JR5Z/0ONSui8Y65EnY3k+Pw/tjGWIIgUgnK9tfaBTpZPmxABhXowh7phXWJHafLgbE +f6KnI7EDpAJLHci6JRgPmNzBGDfSeZ8A28slPjuFgPzPlVpjFn1m53LjAuylrJ7u2/Gh6FMCQ76+ +AA92oEI735Wwg/V2kR2rZnCxo0Wg7HEDAyaO2UAA/QMJ8lZrJZkNqpc80g1KPaTXeRCQ7mmUCh4S +Kj+azh2IUA645fM8d+KEdPiPOHhszJvML7hhOT9fQJkh+sdyBaX1q206r9+WPL9dkcbMZgiV12sb +ZLlfvxGiT2xZuESWDTByN/dVsgTlc0PuErL2Yp4oS6ErjUTGlFV++vaOeVO8A+XmQaTkpTFP5R6S +x/Z491kjS8t6wkbW81LUsh7akvX4nEi3+HQ0USNQHrIGgTuY9Zjj7gXmi0kIthhPtBjF/4i4I4fm +uLuPbViybatdifxxplO73/Q+NbUUQ5OjD2/qp06oLp/siKcJpgMpRHSzUksx1aw6F/EdcfUNbLQI +erkZeZqQGYcBtAPMuTsVbuVtqKbzt/AOGNxdwWKZomOysR2soDFgP/+CiCGspfTnKHIgUY6KkpFT +xxwY6RaYGSiEd9Upz65x3zVKbved/a4DsrKxeTe3XcstMnpNRuE/jxHVIYWBLABnDBVPzJYTYEy9 +oPAfsKCKI9pIG2B+Mhc00sb5pTwk1bjQXGZl05Gly82p1SQzRGd2nTBoYcYlUSy+04hxSdplJy3M +LevpCVNfwFIwudAZlcZAm3mcWYolX8DL+pYhTiretSezvd8ua/m0CbJOR4rgtRnS7PDYUlaeX4nj +caPSgSFZK3TS0vkC7lYQWPm2ioWTzq9ZwWHAVrHwsH7li4ECClPyEsBqQxfjArvSFTCtQPE6LumE +VwR2b2/EeJmkWqtbGmOvkxViTMvRPI5rrPXDvPETg+E6S08X1I415y9gPBUzY9BKoTUV0FTu7nPD +gY+pFGzzXTk73FzZrszdfW97M5TxeaxhJSvwyKSq4AZa4t6xc7+549b4kHVLPXbSU1ksO7oRzBXD +io4pmO4X52VKT+1NPN1AREo2DsWBC7gaiE63XAwnDtteNRBsI0csRNRHBbquHz3Y5PhQUhtkJMf2 +UM/TZlzl0Aa/jiDNFz10YOHUAJrgho0OY8o+LDbIkb3a4Qt4GdTWggxAyy3hlnueBQ== + + + 7MWyWwZwpDAAt/a+9fyCLlDuc4d0ja7g7M/Qa/KKr+/rCB7q3a6CqAozsvg8LSucQRMLZ2r4WNjk +gPY/abf0KZ5Y2SHL/Ra3NHuQlQSQ5XGLa5Alb3H0Bb2d7CW0G/wYzkW7xU2tbmfvEqDaTXceEjtf +wrHeJasfjZ1LVuchGRxrNXgLo9jZJQumptpI4up7dpMcw7iEU7fuDdlK0g/leK4Vywu4NwAdfFNo +QihSxbBa7tdKJ1Mt/D6+gJ2XbnAMD3fvl/L7QLQ4+/p0rMDCXwOxw7miZBXf1HgaxhpVOjPXq9KA +DqydiSJPdqFMQyyf6FVpL7jD+hgaT8B+PG79C/ThNR/UUYTKFvMkCE90mvBi+yV1GbafmjOdnyjC +T5YvC3ijxyd6uWc1IV/AhtIB7WiF3iIM4PA6wPoc1twdYl4dnPQ+naiz0mUBdnSCzkkOqXVZPBeV +qIOHVUF1/AacFXjmhhgsd52KkvNgPHFvPm/jnO9qZtJOeyrq+ggSALPyt5p5W7FlYeVvhcA8bD5z +ewlsGl9g6UMKtGr2Is/nGo7WkPQ2GvFMHMNZdgdiKLI1qUCReLIXON7lnmzvmwDTnBB6E6La88Eg +0i6iIa3GmUdhqis5Ycij4FNfwHkbuhA3EBgV93zGZ6FEwFjOXVeoVKmfqW+NFNNztGkvbOBo057+ +AM8FRzP1kOQBYjLfy3K0a4WjSdarFw1eD8yZo/lcniBBYItzNHlXlm9GK+BoYNXMOJrnvQ/geOdo +Bt8FhrM8R4NQlj97RXBsToOiuZB8ipPwBcy0AY0QuhnZWdDqo0NzHYWJXmnjLYHNY/CNw2fLHsBK +8uU9+G3NhlxqZnmwz89nZpsZe+C9sVkA7GbDE5P1BSzZ7ILRD9rNfINsaY0lvoiCAlZNF9RkxWGc +4bhT7S2hID8MgLN8CASCYmFQ607eneFoD91dupdNThMQsFX4qrEsBPOLQO1CKw3B09gy+r2KSBub +V9OlLb67W7feLJXvwlIa3nrS7+19sBDY8vr907eZLPQqxeCqeXdpGaUYhLOMfq+CIsvCxaUYgmOi +35tBka1XCzhupaG9LEQc5ul7aWmokYWv+nNi1At4upJwJMh/TOOwRFmpCZ5SwjAsdYHXic2SqFEZ +dXH6dne3jK9a5+cHwJbd3apxmext+1hrG4y5UnellYS9WFlEYC3jrva5zelpHuDzJmHjuXIRTqcb +kiVFoNgex+2lF0z5eMwglvLxhCu70oVgonJ3bcvwPOvINQt7H4yMcodKF5urOV1dtC0AZnl2I3t7 +3AbUA2D09t5JdRUeEoAx3puKYRGDCFfyNe7KB4uBWWz2e9vgW0wRPsl/72pQLinCsLlEiYy3riLP +0uzp0NSyENcAZctNPzZiw8vXjejNS3EjlqVfYN5c0SyDDt/csnwOnVqKGTPodBlDC+fQ2WfQIZ68 +ghw6y05RBp1ltqDHHDr7DDp1tuAyOXT2GXQarW+JHDr7DDpNtuASOXT2GXQ22YKecujsM+hQtuAK +cujs24m51Uvn0Bk2riaDTrYslsyhs8+gQ/qYcw6dJiDZJsPsIlgy07atY+CtM4F0wS4uhmTq6S04 +B27vusuXKuls5IWDYQt67dfEOeDW0/tY0Ep7b0unOuMr6AM2FsbT3q6GXLW5orKMD7lJBut8dW6c +nCjaMz47YPZxWO7mh3x9Tplzruen81wZ94t7pCe8D8ki89HBc2U3JLOUOTgXT0lzrnhNURcKosT2 +eEugmnkKBcHxY6bBIN7dxlZOY3Qz2NL+qvvYlv3UfC6T3bSRkF4dg4iSwZov6zHGyW5WxzZaK8kp +2c3aPrU/cFBxy6JtMIjGNHUyQ4q6bAZNprA7YNoQLNJ4YtOkvp0yH93xrEbJk9GLdqWV2dukrUMo +PaWYoty3U5dZh862PUCW2Vm2rI8ZXWdOjsOeMNa5ScC316ZBswucWJUt1S7LLDCVpqTPA3NUu1zn +8c2dYuA95PE1nfJftjROK+vUNOskGHtV2hgDHzz43LIaVMYsRdN6/Rxj4F1HEbTLWg+m6fq5zeMT +Jk45MXbEoI1Oh8BWliE6UU4+rDJTvABzpnj3GNM6WJfEmGOaqPtJKhxtIYxpHb9U7u4+pg10qugC +600yudzpsgafr9HMkrf6lbnf0j5fTgfCAkBvUyuRTUC8US8k/OfNdndXXBh7ssXnYOx9VFwbe1YA +9DGKC4BwuhoFrLN8q4a7VLmFVuiVcJYvkkpjvi1gipuzk8Fn65KGWWkWRpyB7O1y5HwOac4ujjzR +hOyvPPEZzCsbPTI1NYTyhwozFyhXnYxYUfLXkTf3jomphDUlhwQ5A9exzoiamUrzBfSxI7c7Xtnv +lvrY15E39451mp0+gmhhPH06eBp8OlPCmgQ8emQ0Q9LkI4NBUV7cHzZD0m5mZylmgyfG7ZDso9Od +k+LshqS/uyOu8//ilKRVeGSOkUdmySg1oAlvu/DIiGd8Duk526n4zjIeGZW9f7y8RwYACNlEd3hI +Q1vEI2PIFlzeIwPT0HQeGauMVKf8PMaTR8bUz3/sIj3HXXIOTNEDG86Zkt2F78FSHYRWWT5RlGXr +uHE3yjJ9eB3ZckEM9jmJ45PVRDLAdUldBlfj1AFTS4UcYnrdpKEtGMCuli8wgczau+QhfcwQumCa +LeiUV+c5aNYYoYry6lzG69nm1alSR20yhZ2doCe2l1Spdq9Kt7QN1bsw3kUKn7kUdFLOu1Vg0mry +4WAvq4ips8+H837/2CL5cGZR0BeDVefDLZFn4SEfzi5CdXX5cNBrveQOdJEPZ3IjqGUS1+L5cJpo +KOmb4Krz4fT3juKMuFXnwzneErCSfDjNiZWLUMvF8uH0tpjVsQ7MZFs+sx4KuJXFRAJQ2phIK93S +TUzkzchVTKTT3p/26GXVgDwKkFg+Gx3BiTqtvks4bvJILKFgfQzBWUEmlyGSwSYG3pmjweQ6a4eY +Md5ZVcvGIuI5+L1riHgOfjsshG4TWnp77m6W2YZK8pHKq7DsNgTAbK+VMeNjltvwfux2G9po4xDf +3uxFU0JbzW3ACI637WORjwzgrCQRspBwJ8Uc4VhfCWxxm5ZVmLXxSmDH29C0XmndbY3hqNGHBZPP +7C92cjSo5YxUcnPRABHVnK0uFl4oI7Wx+eoiidRlRmpjs+nGZeCQ6reSjNSn79VkpEI4q8hIhfli +y2ekQiiryEiFcNxdA60zic3i+tAGsb401XOQUTgmrr52G94tvQ11qXDmfGzVqXAont82omcVqXCm +67LyVLjF/ZZajNnb7h7syiVS4dR3EKFkuF+SCmfiVfgFqXDm/jGX9tm9nWKoZgXq+5PtEp8+LWNV +3dwIr9XH8nEHs8htoBcExbryKLpwIENg1jfbedRhDJcMez1cUGWj37s8wrG7nRewcjORp/TinNys +z6t7srwORy8cJO+oiXhQ9i+sGhc1609cA1TiMn3+We7fNF4LW+15sZTczryU6umLYiYxCwLOX6of +8veobHjhoTjJZCtc/Tifi7fy+VziBBYhqI0lcRToa4csepy0uVhmWWfQShJzlB6t886Ey9SFmry0 +yW57rfNTtfNZ1Sn7uRvY3xhZZdgx93d2yW7thGWnRKmes8uwC5x3TxtWnb7ZdFqOJVWd6nOxUpGp +ygunT3Zj7j6rcmVCXQrYZsgu2Y2M6zrV1uPbG1hl2HFbW9/c/Mkq2e3RLutsYJ9hN6rXLTvdqXY+ +21adduzr8V3eWXdaPHssW6J3e0jvvVp1eqnNsEOrCjasOGv0S6TzlMt2e2btsFdB05J5qrqCyIQv +cDtRdFY5E0X0TLKS0qV5Xy9Q7XzHLkJutRpsZIjnojkjutgZrSa1xzlCVe81sa5j9e1iSKpzMZtB +OQWnOsV5YOt1lZXkzMqOmNyp4sK7ZFdJzpMX7rHgOkTSIRsS3QnpIa7PqYicbVyfe3pyKCJnOT+z +um9OxUbczs+51oBrpDvVGdHdpbZE/Tj3+6XcsS5EZBnu6rYAnb2nd5FsusX8MF6z6czsAKkW5+qy +6VzeD7NkNp2ZT1C/X5bPpjPLpVs089E6m87MF28eab9MNp0GLeKeNb1/bKlsOjNQDjeELJBNt6BE +9phNZ3ZOI8vKlWXTmeXSqe391WTTmeXSuYzt8ZBNZ+Zrlyqwry6bzmx1kad3pdl0ZsqNOnZ0Ndl0 +Zrl0FrfNL5FNZxzS55a1prRoNp2ZcuoLrDqbzmz9TKKhlsym04NyrCm8UDadlW652mw69xhbJptO +B0p/Jr6ibLqFMOY5m842x2pl2XTmudWrzqYzAwB6WXE2ndlpiS4GfgXZdGbsQWu9riKbzuFkZEXZ +dM7yZRXZdGbIULTxVWXTOWVyrSabziyXzrIe3/IGYEwxADX1xTxd3WRdxctYpFJfm8Nl4tO3w2bX +IJ8ZWdWyWbxenWFIM3jKs+p6ddbahTs8zSJBT3hSsKSJhIQ5mY6KhUsS0CQoWGQ9Ww1KNyS3rMBF +dTntwdRCQ4IYA4PyVHbZbkjmgRSWHMYGTzZlly1YJpRiWovokDye6iwiejs5dihsbu+Zk6tl2RW6 +W7rMneqeK5cq+SJl7iyry524ylVyWebOKpPLXSKdqwAJ+/hkpdDdcmtVvh+7qTJj66VyVebO0aMI +EbN0mTtRh7EvdLd0mTuc++ZQ6M7d4dH4ZAX3XNGH16T9IrrPszhZWYjS+ERRuRfO5QFTOwi7pU/L +Ux5YoM4x9tCJPmEaHTSebT3wrhLp3EQ0+5wzDK2DOFznF4JebMIOPQSRQexYuv60lOyuwhboeSuo +zyeCl6Zaztnsbiir857yxWDBxC5NNBQgKod4cNfRUACUY/yY62goAMxdRLd9YDPifSvJfFz+KARW +FLS5DlxcfZdwXNV2NYOiiuyqrWIHIiiGTHbTTGHnXHYEzFVirVUNCH1ibW1oTKytDVd3KyAEtpJC +xojGwGjdMDO17LJEZd0MlY71Xu1iqHeNR7owE88YQW1riVvFUHemvZVkpsg3H3vXJIygqvNVVTAE +Ly6sj4hd7/1rT4WqrU7fYOG1pdUJDMUuqtMDnBXcEoDhLFutGkORNqHZDYfeYlWvXSQyeDrhDUdM +tuGNi0QGVx74pSvcSfmVVjXuFtiGJsEVi9at9lbhzi7zcYltKBGaWOFuJZXyHPOJ3FXKWzafSK6U +t/w2tKlwp81LcpMfskiFO7t6r7DGnfcKd25vNYfZT8sn1j59K2qOlfXqOrEWAHNWc3xuFB1cm26x +xFp95iO7rP8I5heemqZDe7vnCsFZgG8a7oiAcFaSz3lKuLPFHOFY58Lqkph8TtdMoHJ5XvLbzZKY +1KeikEFEDdswFXJYCBd+Lanum8s0JjdJTMGDF70lqpJibtKYtJN08J0qoOR1sUxjSoVcZajbmu3y +rkyF3OxKN0lMwYOhXvle1K6885TEZBVBBGsn2khab4rhnZjDu8St/DrF0OSyxLt7XA== + + + A2IVOa75uPWtYtB+8VqRzlO5R4RKa33sfnVXU92j07cV5bjeW15N5V2HaU49lXt0qJSXWDDHVbU/ +5TAMF1nPzjmuYEius57tclxFDxBciCpv3p+k+sGMt8pBvdAj87nE8W1hq3Nc8wUKh5Fa/WD0FuHA +r/IFyu4r3T2V2lQwvVnAgge5dlW+Y/GXJgnv7PBK3akmH84XmG7d3F+oXVXaOmyp/OO9RT5c2DoJ +bzJ/S5FanqxLwyN2rXL/uK1t/ir8bJWE92TZKZjLZmlMW86VKG89XFt2Gjxqxj+s6rCFlU7lTC4F +wRcspepUm5o2DfI7Sh1BWpflGA4dPvbNOvUFIIL1Nec0aXgNfe6fGr0n+xcWnXJbAeas8Kb4YPUZ +ca82nZa3OetOy5dbD2adorpvQkWTWqnv9MqujuDJjXWnxeJ1SRPZBbrdhu+j8i8xCXO+e5DQrr5F +OzpPWLZT51cSb7uprAuIkdRoVlTEJJjzPaNXOuXDGtHboxWeeRs/sSzoXIZNAqSyYXQapKli5hw4 +6UI2A9gH+sQmRw+JdUqSMbTKckiQkq0HlXeT2uSc2DRdVWUW5NB1qMzi1pNUsA+tslw6Q2UW0EHN +SwiaXdad7ubJJbLSHCI0MZZ87uhJd+jldX6y1xrm3XmusmgxJEOUln6/uEa6pygtX8BuUNZ+Ym9D +AtzSOk5LHI8hNlbHropP6V3t4XXRWDNlMVMCwD5ycfW1gw/2pbiqyxvvYxvubjh0kY1k6152e8rz +UlzmJlolJ9FwZdxCyW7mR9ae7rV+KS7oWdbeogmzAJe9hNbsrjjLfDEnq8V4V5yNAWTuH9MGjZgc +sTZKnuodWHOY0sps5EZJz2EWPfXGCXdW+xidWDmXr9OMTO/nd3bZoXp8ll4V5tsQQNATJt71EYva +T8GDO+vDQW+JZIZ6FkuUZbPPZPKUY5X0dM+Baki6/Jd22c537KiNa4akCtUXT6tVu9ZjKmBv20Uq +p/qeK5tUQKeSxg7rp5y8t8vOiTquiUFX19i0yowHYE5VdIL67FobYDqpshzGHHN53E9Se3K5JMYc +6+l4wliVebIAZkgXNtMORYwtmAXoNgfQ9T0kVglirnIAbaLTXWQBus0BNPqTvWQBus0BVN9w6D0L +0G0OIPJaL5wFqCEVGwtTHwfrLQvQbQ4gxNjiWYAKPu35hjbHymsWoNscQNlGXigL0GJIhhxA9Xkl +Ho9xVssX5XNfkW2ZonyqufzConwGr8IvKcrnVJFtNUX5cM6IvYKyfFE+X8BEK1x5UT5jfeRfUZTP +uj7yKovyuapfuUxRPrVXAQ6KsxyUiCKn1GDrqn7L3w11vIq7oVzW9XN1N9TSdf1UU1vB3VBWdf28 +xSktWtfPvqrfQndDmdT1s/cKmVvi3uv6mROf7d1QC9T1c6bkVdT1s48MkT1XS9b1c8rkWpFD17aq +ny/gyaFrWdfPfmo638XCdf00AzFU9VugAohpXT/7CZlFqC5S1880HdHuVnP3iHGdKWt6F/QCdf3s +b/6Sz8SXrOtnK+jySIqtoK6fvVvY0w1UNnX97E1d0yjoBer6maVJKltvuXp8K8h591TXzx4K9POv +oq6f/YGKzzWcZRLf9Rmpi9b1M1E1VVX91NUZiCXq+um2IaGt6qe5s8tzegoh1/VzzHtdSV0/+6p+ +MiUvWdfPPuBalZG6VF0/JX/LjBZ191wtXNfPHoFIg11BXT+bvTbt0Suqx7drD8V1PT6HcnKu6/Et +VddPhmK6fbxmcxjq+tnkPThG23a81vWz1+ThjQerqOtnJcNvjCeJi+VvuVDnpZNEp23oVNfP/rxZ +G0WweF0/Lbb11uKi9fi8BWlY1+NbwfaRq/otX4/PTRKT0+0NxlgNb6X49Bmpy9X10zi2DVX9cMbQ +8nX95FQpu7qiS9f1s1dzLGjMc10/+6p+S9/aJNb1W9LX57Kun4u81xXU9bOv6ue5Ht9CWbg6bmms +67d4Mryqqp+ql6Xq+hldyeqqfla3nHmt62cf3qWTYgvX9bMPdNL5lBau62eyLqqqfvb3wrmv67e4 +31KLMe85TxZ25RJ1/RTGZVbVb+HoQV1dP1uKUFUAWa6un71iiK3X5ev62SfEihJ56bp+2knqq/oZ +9DHXN1lp6/pZK0FYh3G4ycplXT9XOszSdf3UK2k8wLHJrrXYn+Z1/eyFg20W58oSYrHcT5iIhwc7 +He382jziQ3+v1Ce+UVEnK8FTa9eufeC9Lm1RQ00SjSmnN+mDsToPHvumxK5CGgkZHymIIRLnHU7G +55nGEq1OYe4bNf3cAGLleCPyeLZNJO56PG4E86k2tk/TR3EiNNxItB7HDD35PC6l+8/Jy+vdUGwQ +Dua+c0Tl4yy79T3PcRtPjTYNfr1lAqywV9k5Pf++Yr9794++AM/GmZZwWrqLn8QnG2y1zLzlrnrX +h+3aKXf7We+csd83oc779m02zBS+NutXJ71Uf/9u1DkMDb9f+e/AJDPkzjZuzw6D23SozAXeH4+O +wvPPrUdm9NRJiXsf5Xamr+u1m4145CWzQX1830T26WCGKOVOckTpvXVMlLmdq8nkLRmaTIXbo+nW +C9ecss3HCznTsh45SMRu43Q1uSmlvX0lJtOnESw2l9zCudVGHqLJL917qL4ms63LMTSo5RKQsJ7k +/I0M7GYz1WMzZCFkgOnOduC60NsblnNFGY2hRrBzsXXzUE9vDyeJ0g7FfMy3+u2NNswkPZaSQzfm +0TFzBuPVTocoJ3EjW6rXA8R2p43s/YuRVmUf67YPmNpFXpU0p/hbVVMDbM0MD2kukJ/7AoWHUucO +FdDMP5ev7rizfHszk5jtH2cS0/ZeKbnVuyjeZugXgLZhuty/uXvKVriNJoBz8y2BxeUzQ2Skx8NU +xvuXzF51Y4JmlR2MICVnT25vXyPFm7sK/AUmfNGPw6TdKDbr0+z9BFlORGIWgtEIrzPMiRNsPCj9 +IkPIdwwwwg/Bn/wuyvoFDOdoDP48iCIOsxUEUuxxAh7k49KHpUSpSJ0KAGyFiBSigXkpVDk6IqPB +z0Gx1ftOEok0H0YDhYN7Jnfz5F6+20iQ4MVBRPWisZ0/8AWkV/mY8orKPVwfSi+OEsoLenvvIyu9 +OCflFy8i2soHu8ozpWco98v5qOoV7FuEUwa7HmBiF8z0KQLnHKaep1+AAZavSHQTDlk5vKLBdC93 +VdNtfkQgZi8Byg9GPbK1zafkczHACiF55chW7ICEjRIwb2lAtg6PINouSfGby2sEFia17m/BniMw +txiJpW0qHGOg9l+PKZ1S4cPMHu5lDx54X+X68Y/d7EXrvVo4OdqoKSQpHwvktYZrQGtw5qhwpbRv +Bg9Q8qIQL6sHMsQcO7vY7pSfH4SPbG2+3S0+tC8IOCsSUS+m5Dfqef6SEVfj/oWWyKvOqKZeOORb +0j64jSEEUoXLPJSAtwmJ7G8B7OYzrM12S4rqLnsrahcj+JuWfzEYRHFvwIE/H0SIr60SXJKHhPT1 +AyH/IlWjeaNeutJoHmj0whcQXxV62+I+6H2xeC5aSas9M93RsBmZC1iwGSArIaPRsZnU8/koVLzN +nR7nwv0JzOnnKrkiEa8b2Yy+Sm8QURvgAgK60TUsn4sBbinu+LteBJNk7u5lCma1GU90Ny926O3k +YEYQofhUnC5gLihuGrknwZ9MGGUFk8WnDPwzBTbS9lca8o2oavWfwDc3kCYqcaQGwUiVODLcyfJL +HBrmlYSFC6ZCyAS5o3KnpNmTEAwV/SajxPDNF5AW6mQX77toPtCUn4n7F+hwcDufgIXnbyr5t162 +rWFCVYJgmydwIU5UdECWc99Q4/g4Rxg7Ax3cjxAnhlN/yopqCWA9+BlmrpDhYEljK4cU56xppL20 +jCHtGXx1CtWcDBDgwhzrNTvsqKRS7tCzzXx2E3x2NYONbzR3H0iaUlgNItot6kBE8tuHRVlAV6hQ +8p5WVDb0bHMzfVgm2oFhYTI5GO2qVQigH6B7FUoBBQTR2WQTOhB3dxdZGUQ3pNkq5T5EagivX/Fp +L0bv7D2SAMeFKKQcya5ETyGNxfHT5+kr3OJPU4nNvM40mN8KimWOqY9LWVN6VpQkVGAaqpqb8MU9 +wp1KTw4qSstu5na3IekmB5SkluD7GYD422TK+mLLsBCutC7zDdjpBl4BZvq4A6VY6XVDuiMjuSWO +p399plbe76NDEWO5MHR64EshKs/xza9rgKdICXQaj6ENbrwtAnrhwMjKEREJhWlNRsKTGgnzx3MZ +CbobOyIqFDxO6Kbq7g4ZBb5AOP/QfpGQAMajRgI/sUSChILdbRUKDvPfIxUKDkOFCUIBoGSxW6n+ +N1oSZyQAJtRL4E5p/rwnooCak2Z0gG/VuNciIaEQ9t3GKFHESJjk7h8VJISa21dPFnQgXkcrVy0H +fMyMlGxBRLzTojZyWDoHUEbheQwxMwBoXVyDiC+4pZT45DCx5GpErWkacX5pFDY0HY1agHCFB8T5 +o3EX06Azl6GQCKJxeK4dA2k/BmxX2vKnKCWB4LaU1Zhulk/ymnaJXaUdLJV+YVHnHSxOaFkaCy9P +Y4kFx6CiMXJZGgsvT2O7liBcAMA0FnNBphoQ+mk4oFKkMVtMEEtSRCLiC7jAhC0IN5zPF7AFYYVK +V6sBAcTV3p6FiCrhmrCR3DcFQSw7DdXO8AUWmwblaQxo7+tHQTvvzwpzcJqP4DFM0qzm0q83Si8D +FInsFhNU1PsYdNySWpaoqLgZRXjilpQb5cZMDincklp2i1Ok9k9Kx8coWjQWQu06MEgzU+yRQVaZ +oumny7chbEUoNl3xJbUvmn3nnaFo2971YtRrpR0lEo3vGLKG4R0R088Y/DqObBD68HoT2X5B6Thx +K4iCfpApjL1rsimMfWvBg6tv8Gcmhv98nnaQoRikt/f330qv4UdU/+Ul8yGbqyHZ6/dMtEOhlGSf +pnZVjjXVDNKZqMqtFjyspqUXpbjyAt13IbtggLGr8rgd3oxzkqcshaYRVvdczkRUbjVVz+WS4tB7 +QTWhkReumhC9CuVzAroHIjgzBRjPFLbkmi+BhjTdywh2nDXHJCT7y5isXm9TwXQIJjVexkXfGpeH +lHNJ4OpyE7JVOUcPRLCth0dS9InelyKJ01oP8oM6Nv+pMJdqS53W47gXIrwtEFS/FihGk+GXzB5x +s60Y3ojGJNMbe58McVqy9V7//2u79r7EdSb8CfodyroqN9v0RltvKxcRdlFZERV0RZCKLgpa4N1z +/jmf/Z1J0jYguhzZ83NXmpBMk8lkkjzPtKoLSJwnT3pTIhEkaurKaDtV3/Izu3XzKGv/6MY5FNes +xbj9Ni71cDRuIvPSE5NuP0JIztMi4lbaQVdxrnCwrVnWGAxUuD22+NVjXedXk8trSgPq+4l2i1/p +PQsFWFQA2FiruYcSmwq+F2Wotx4rhNVuTU647JvExX0IrOki4rbV/Rl+YYazoBP2pQ== + + + Sakl4SS+xjACZm07jTgDuvavsnTGJwNcr/bMi8DETnHk3IxHyHkIdq9TTAmjjtnuopSglofhLLgy +lFIh+AMTey/2gyoY+dE0fX0fzLDtsvpwMVYYVPWQ3kxR72R83tr/Ou+pHWkVJt/RN2a14S/8qs7P +yDNAO0XyZzB2ijjt5qmHiYOH6fRzj58GRS19bXtUn7Qv30iEe83MeDTOQ6pbcGYOGybtoB53KO6F +E5dDaAc9EzV2pHD6Diz1n13J0WxLdnRiy+rJ5NHzj/2H3sNATktbkpota1p90B0Wfc879f4aF4a3 +kydvMJY3ZTVby5fLjlXwboddT6YxKNaNLWAMDFrj4TUiEzkVd8NQ6MKde9AvrZzstAt3pLErROXQ +I/768+lLLH3/E3YnsdStshpLt7qXsbRerMXipVEakw0GQ4Q9e82H3YCRZJIrBc/PTfZTh5XzGQCd +rpbuzenBjrS6f57zTvbUUW9bLWWb3wrN4lltTx2TIUUqZsFB1tOQrJzDbfq+Pl6LJbaPzNiGun6G +HGcB+vK54KixdGJvD3O/xlLfPx1h/47wiy+xjazRjaUPL0qx5MuKj/bvcASpOMFAOT3FoeGIvym2 +WsEcrA7pxJDYFNLSvR4iu2cv3MciSIy1Q5BYpUmMRIvzq59eks8isB5xFtHkZhxnY2mD+w58sQcX +cVffHAeIc1lYqUipPXaDJWxxBirin6TV/46BivgnhnovzkBhErYWMUhW9yLZLY6yV4t0y5AEx+bl +qKEhC+/QaKqKA/P/GIa2eqziWpuGG7x8hmSdik2ywVGrl0a4HqYELqq7psCC1KhE6/hNcBdq7E3Q +WEFtb69t9gbr9eL2vvlzBgbFeITvYnBVEGEVxgK40MJBPpI4Tx57tmFhicF7jKnExFfnu+scFPfW +vdNCubsT47OpcaGFNJM+xd8kHlsrwaLZNsOut0Xz6hxTf5rmLrdTV7nZdy6I1qmUE3AF2w22rnSu +9V23rMNYddoY68CvuyYVwYe2f0IlbtAAKEheBNuk/iUJrq4ja+uIW7l+1xC+uI4ZLegLXd1vDl9W +aV+m4zHyYgwVWK3oZkIv8Hs3g94SHA16k20eVrHb/8J8Tfrl+Xi+mwn9GJ3n3TV1jcP4bDk+HPDu +HnvJYJ+9vlNLcnobXBPddqM5E77tPt9vs7UWnAuuQKU4W5i9UR/PW6UkdynaJ1UvbFymKL0dLusb +/BlgynFjiMwF338dfEvwZ9Csojo/TBD8T2CQGGcaBJuCZzDjSIUpM3t0xqnHZzbobGlmZwHwNSHR +pIjs+nOeFL5uD8lrrwPrC6eZdpKUYWNcVIqOGzv1HFxTrPtog6/Uz5vqwpwkk/3qyY7w3R9sGCN7 +wtAPf0f9GR0R5xE7+Lbo7wGx46dmuCHf3/5SE7EPUr5KK9Mi7nfrreR+SGLVZ0gszFsRKaym/nWG +wiL728dMAGO8vr8WMZkSUVoriVPFrK0H6zXypukjHV8rivZUSuGVEuapNI++u3AXrDZde8H9pc/c +DCyOzZlN68ePxfEnGuOIOuGsVYwzOVtPJyF91HiHPsKZ83v6iDPE87gT9m7VBbmTOcyJgGFKqx+C +OOhLDZkKrkUVUEaPq6AZqQD6gu0RlYAb/d8oob19FKnAuHzUnEgFuM9WZmjE6N3riyhhEaT/fTya +/lHk9zm0d2lE/ENxgRavZgxpQSYS/y7VErYYPHXwVisWa0PLf18AG5d3RXRGy02pg/tJOCs/OBrV +q+cFbBq8pSBixqarrTemxaKqrHqjyFt+iJjdrQ5jv29DI4g+nN8KP4hcMBtPkQhSOmzcTtHgV6H9 +NoSBJ8UfpZMZG6OvMVjGxmqDpW3MGy/ZhsfY0jZ2NljaxhrDf+V6Xwvo+KGNvWMizfe6cb+wKt+0 +sf5kudFotITpyjQ2TxPviuj8O8+Hq9isCM9fbjQa96MZk+IaW9yoGv0PGPbU+5h2G4PJkt3wY/Nm +BpxfFu/G5NMH2xDuk5srK7+bn/roKhIRWz+7r4lt6HTeXgOEFfk9TXS8l2XagN6yc7+kUXX6o2W9 +ZWcw/q2re3cd6rxMhH3yh6Z4ZxITk7crn6aSayv0qMCQYgxH/JJCdCIzg5AQb7zn0A1mdKYTjn3t +z09X7Ci/vtOwgijMFj0ybgRRr1cjdq4Mg1YRquZXcYbmwVE4OX0UpifjNE/mFXpuVsJqagiwX0Vw +MGoMDrYC4vbnGKiIf6J3+Y8YqIh/kqYZKITBDuo6RcVEoKeaT1HgjAM91fJGcEidJPkpsFpRGLaG +7zqH5AnB3b8Gv7o4Lmr1gok1vpwOFB7a/VlJBFxUmY5lSkQKG8cKvYuRcwxny7tO3OXvM8Xj3KOz +4gjQNYNp4eDNnzN/RSFEp/fGifqvJM6TJ01LrJNIYqa+s5nP1te2bvL39rfn7Gl2cM6guNxl8poT +TbcXYcT0qRE9uyCObqeSFjDYNgcgOyfs2QZ8wj3BrtqfzhgAF0FDeq5plJAbaVCihV7xge30LIat +MYS2X1dYjKMWRj1vhLTQhojL9tu6AKwJiHC/Zwb4UdPifbkgK/RoFsFq7GnDuQHWqT8XXk1RhfkB +1n8wvFpafTPA+g+GVzMuam6Adeoj4dWjf3alLTCpsqa19gddkWOSVlchp+aNJ89YwGrlvN7DoNL+ +2/MlTWY/BH7g05E1y6D/dcuCLAvzKx0pnvOHfW/QevTuxgm5MpBWW2rWHxcebscPw0Hb/1vehCxN +VnPD4aMcz5ZrxXN5/6/noT+W6Y3k06Gcr9USSG+9W+7sYfTQefSmyqsXh5V6uSBvykE7/rKKvC1b +KEUjLWgNFGHlQQ8tichZ+H/xS0pO4PNYIoqTIcSGXimO6WZcFy5sx7VMh3cfCrclEiX+hsRXuPgJ +Wb9kUz6UL38QuYtCT+CXoxCiu4b8hHV0xdRs2VAs29FAfxn6reZaeJmXhERFomUdvMZ/rCKvgOLy +kpCoYAKkOhqxZF6RwHfEte3wFkS4AwyWFLQiLEhCEUS4DRHucgd2UJA0xTEyrib0DHNcx5RNxXIt +m344GegfaNC0jaiTUMxyTbGnPAc6oCkmIWZYRzMVzXL1QCQmM0QXuz+TU5GCKlSUacihSMzPCM3A +mqYmNoPnVKSw6bxO0LNQ5kzf86+0gVpK1kFR2WfQXQHsiWSI5uigZ8OwHF1jCifG1IWrWya1NNMl +WNSxiOugoUFDLI3AKKKa+bUJbdEMGxsFyoNPxXRNzRT0zNK30B1T09DSeA5+Et2IJPC0A2WDayoV +DCisC3clGUdUH03fSuH9eU7QvkBC1PZbUAqhGllodmUUzYEBgSZkNBea/SRZim2hdmFYXBwHSyGW +mXFp2gINQkndor8NsN+8NJ3GcdVcW7dpPd1mcgwjA2nbdAgrqRFXhjvbjq1xCWJORXKVjOOaFnZP +N3UdLY4ooCGqskwGZil0SmMFMjZUpQXBrOinoaOxzORQu8/Y2Husqwt1QTRxTVYSbo83h6kSyBBy +Kq/UNS/nbr4rjqP6LTDxhKzWxv7DoAe+M5e9hRXhZDhuY1HBVwa3DnTyxJoPQ496tNnQ8zTTc9Dh +oCGRCqKmBWoLxha7rmtamA70Ho3ubE6FjzfmWxZL60TXrFCNKCuju6Gag9ENxjIa72h0AxujfTJo +Hy3HdoPRRh2j/iMRszmVVwqbl/PWyOiKYYGKzIVGppJjSzYs4HR93NiA1bza7nmnfvvhERbw3qj9 +P09uDwZY13uGb+Se743GQ9+TR/fDX5gDVYLisBU4Lkr/B6fn6Hs= + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/originals/SVG_Left_overlays/Download_left.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/originals/SVG_Left_overlays/Download_left.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,1627 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + + + + + + + + eJzsvWuTHMlxIPgL8j/0faAZaXdoZcYzg7d2ZvVqrW7Bh3FIiTLZ2hg4Aw6xiwbmMBjxeL/+/B0e +WdVAAyhJFLc7gUbDO8rTwyPCw1/h8ZP/7ddfPdt9+/YPL5/F2/lm+slPDu9evnj/9t3Pbwh68w+v +X//4w/t3CPrpb352s6TbGRrt/mH9Whr+48t3P7x6++bn9Cv65R1++qdfvfjDy5dvXtzsfnj94v5n +Nz/9Gfzmt6/ev34Jvzu+/fOb129ffPv165d/fH/7w79+9zN9MWA6vngPbZbl7+bwd2Fe5pu5/Txn +bPDizb+++OGHV/8f/rrENQJs//bHN9++evPd/u3/+/MbaAq/gD/wi//66jcvf3jwt8e33/x4//LN ++1+/e/vNyx9+OLx9/fbdDz+/OfzlxZubX7z4Dn7z4uafX75+/fbPN/vXL775nxP0OH999+r1S+jc +/Yv3Nwt1dfcPS/h6/+Or19/+8sf7P7yEbsdSERy/JpS/+wFwAVr8GcH163+4B8hXL9+/B6rghciu +wy/++b8dgMdv76kdEXq73Czw709/vfvlb3/1yxO8rt0ckEn/O/0W/jffpjy0CEv2TUJBDPiPazK0 +iPD52zbgiJUb/Obv954zzDto+C+/efndK5oNME7//WfS03dvv79/8e5//sDNYoA//Jvfvrz//jWM +JrF/Kbf5Zsn4TX+SVsBVavEsrvXmWSgRfh1buQnN2vTxevmvr17++ec3v3z75iUPyu7d+694SqQ0 +z/ydf/ObH1+/fPe7N6/eA2UFQY1H5Rdvv335Gtrb5+9ev/juB+3k0r9zg9++ePfdy/cwm96+/vE9 +zfRV3wCj/vzFX17i1Fn4Bb/6/uWb3779R6LxWV1uYwQ258b/wpDEst6UCKO70ivSDL2cb2b3bhp5 +Ro/IEJW+A6bWT34N8+dX71599+rNz4XC+vXfv3v1bZ9TNdys/I06cbu6v03/MrXQ8ffvX74R6mEu +H37h5uZ8+4uv4I2nN98e3t4j93/ABQcz4A1Mjtdvv+Pf2c/0G/j4j98z9fT/r2Ggfv3u1RvEOf2S +frN+/evXP8Kv/v7d2x+//4c3f3w7/ZRFzW/fvfgGmt386g//4+U370FkCKD/9NWPr96/vH3x6vuf +fRDRr1+/ePPi3Q3B4cMMfP7qX+E3L4CUG/4Y/KbDPo70+PKPsPT7Zxl6evOvL1+//f5lhxvkxZtv +b/7pxbvvP44ahuGdw0D/1X8f0dsX7/8EUurlm29/MLL4v2NHGfZxfF99g5Pi3c3+3Y8//Onmt2/f +vja0468Mu4AJiu3/Ot7xa/rAm1+9YQadv0kabN8EAuGv7i3Q+uE3wC//mrEfXrx+/eq7dy++/9Or +by694MLv7U38u0+ZWH+5/8Pb169+uO/zyUF+/eLd+1ffvH751V9+eP/y/kPYkBt/fPXmW5iIJHQ6 +tW/vv0et4uarP734/iXhfP+nO2r5lSHMX4Ng9KLv2bMPyMQQb/Zv3O///t2Lb1+BuAVFaf/6x5c3 +v4H/vnh9o+CfTZfBIO4B0bfTv0z/ZZrxa5njnOY8V3jWuc27eT8f59N8tyygLcQlLXkpS13aslv2 +y2E5LqcwhyWEkEIJFZ41tLAL+3CYwjGcwl2c4xID7mWxxAoaWIu7uI8HeI7xFO/SnJYU4cnwlFRT +S7u0T4d0TKd0l4GWvOSQY05TzrnAU/OaW97lfT7kU74rc1kKaAAFPg2/LtP/pZ3pX4v9XS7+D3XG +YN+j/AXSiB1xzhNxBf/q9yJ/k/xUgGMFeKbfV+If/m3upx383cP33UT/HIi9B/iLTObvwGxgNxIH +X9AZUN3gKy79h/8y3d3dne6Od4e7/d3ursGz3tW7cpfv0l28C3fL3Xy6O51Ox9PhtD/tTu20nuqp +nPIpneIpnBZ4F3z8eDoej4fj/ribju24HuuxHPMxHeMxHBcg6+5wOhwPh8P+sDu0w3qoh3LIhwRD +Fw4LkH63P+2P+8N+v9/t237d133Z533ax32Y9gv072532h13h91+t9u13bqru7LLu7SLu7BbgBV3 +NFZ3d9Qd7NCROoXdwo7trHPYvUpdxE5iNxN1FTuL3YUO44NITqeJeo59P1D/kQPIg0Z8QE4gL5Ab +mTiCPEGuIF/wmY07yB/4moBJyCZgFDyNeLUSv5BjyDPkWuqdOf86PfI5bp/pHCQ8esyzP3+mC8Dd ++QOdSTc/+Xr/DvpU8KvSs8LT5IHBLHt6YF4AH5Cpd5VERwURAcIg0pMqLFn4MH+ttU21wbOr+wpT +CpkII3K30opZF3hAhqwgKNa0wkpf6Z1rXfGrrTCLVphq64GG4IRTo80TLC0QSS202FID4QDk1Qat +W2s7emB+NpjDOHY0EWBWwSIEIQYzMcB8jDArE8xN7BRQRkOJ64/WYaBnIRHITwJRGEEUZvoJvycQ +i5meQg9yoGBnSFg2+Hc30Q97fCl838v3Az2w3uD7CaUpzuZAcojeFQN+gQQFCYsPyEKQsiDwwjqR +sG0kcHcBFiVI3CN8P8F3Whgge1H6LiB9EQOKWRCkMCZoCVeSxiv0vYE8Jon8gLRBbvHyIf4hH5Gf +yNdGXMbxLMT3BCMQgSLs6oyDA0N0hME6wJDtsCkMYp1oRDOMb6SxXkBe3uGqhJlwgFmBI9BgolSY +NBmmTwJSAzB0huWPk+wI020PI9UATYWpmSeQ+wl2gACcn0E+nGBFHmB/2AFJK04+2DUy7C8RmLeA +yL6DRX+ELWYPg97SCm8osPkk4E+AkZwjyyVc0/REe4I8NF7HmR9ZbCJvDiQsDvy1p2dHT5uQcQdi +xoFmPi4bEKiZhGoiwYqiNZB4xWcmIXtHghZF7ZHELQpc/NpNJHcbyV6UvpVXI8hglMKJJDHIYnho +pu1nEskolFEsH0k0o3BG8YwCurEEuyANLjztsc80/Hf9pKdeeqaL4PLIJ58/Xdb9i037mw/8wE+A +v+Umz7e1xQpWMyAA0/frz0ew/wHenmYQnwGbltRqvIilBJjIaJKvsLSpTVtnWHWKsd7GtsSbmG9b +zp2u66MmimFpLUtBvxGoYGu6iDakOmdEW0BJTOREAn0JGgva5RbVrRtQxTq5V8YLtO6PpmirBnxZ +hb578e3Lm/dvb/7pT6jGT5v/w1AFVpqRkgwiiH6IFVTUc/EJJLWw5Dr+gFSOkw7x3Ciei53lj48/ +IB6bSCP/roeShvkL0c2Aruab69FnCD9lYP/+3cuXb7xVtAEQVrGHTIgmE6LzRoSq+DQB6nTcRFpF +IB1jJl1XNtCD2zr7tgkbJ0lf2KJxs55h+8ZtfA8be4P9PpMesIBugHrCDrZXVDci6Cd3sAOhKYGW +SJjPvraW0HkDkvldgmZRsMEyuwuiXge0SAYlG62Lk+nZ+8HKAM16EpV6GUyNI22N9J2NtCb2Uha7 +Ck2tKIaYPp/w9bi+kvWI9iNbkAfQFdAQuBNLkm1JsyZF811F491ou6jvTk7ZTaTsFlJ2V1R1Uc+l +tzrtlHXTRlrpgfRR1kUDaaGZNNAVZsgO5tUB5tkdzLoF5l+EmZiBgAqbfcO9fw+qwBF4fweKwgJK +QwQVIgN1FRQM3stNAVxIAUQzHL+SqYLUVVbTSRlE87yRib4jM10UQzLW4ZlwWCMZXonGK5Hqy5op +4vRmg+vITpYJLpgjLZ476tYsXQv0Jl5smefGSpbykTwPkdTqlTTmI0zHQHpwFU+Duhmwd2yE0bTk +L5iqPG1pAi8ynUk5JhuSxp0e1CwuuA76F89HdhBE6n02yx+opQ+TTspaaUFfBamlrJgu2JKUU1ZP +UUFlFRWUVPrwB23lLjq64Eisa/NQ70iTx2cV7b7K8OJA85DzF04EnhTQDz9iwkZipFgKq0yG/eCv +wRFP5rEBRZ68NqPfBsZsIsdNhHaZtHBeeX3VjWuurze2Mtm+HGzLiUzLYKutG5a82nZbq1LsSrYq +2aZUqxI/sk5kVKpZeSCzkpwEaFbSw3ZlIM4msy4LreIqViauZrY099OZqakPm5yzmJ1seLLpycYn +G6D+IQ5M8s8Hp+Znfv2tIlzs38UcewvvLRP59aL490g+uu2n/1RsW6q0RRVZ6NX9n1x7E/staHxo +TRRZDXu3EnAZZOe6tE3HOS+LbDM86WHKw3SHOc9bS5Itpdn0PtG0Djal2UWCMxlt7aPMYJ27su9M +NGF3NkNPMid588m2+exk8zmStL4j6zGIhOYtqMI036EJuieLlLYh2IgWsl4jWbOFbNyVrN4dGcL4 +dUJjmQznhUxp3FYyudFwza7TcSUP2150hSOI8jt0yZEuEehBlx2yj6QCufN4zdLGQsrIXo3x05E3 +g6N3bYBpvzdHnrrwkpj3ixj0JzHi2fmp7s8itnoUG52doKfJDPOd2ONVvKF5VB83quNOhD2L+644 +homlPuqN5Hs5ivQfvS5l43UZ/S4ncpEdyF22m8z9ssJEYf9LpqkTzQuz4Ewma5p9MUeaanvxyOxI +3q3kl6lg85Cak81BE8lJE8hRs8gq4Z31JE6bIzlu+BFPRdnZ0yaWqqyPmjPX+XL3gy9XPbndl6ue +3O7LndWXOx1P5s5VX2735jbz5nZ/bnaen8Hjw96eyTl7Lrh6Lvh5zj09g69nQmfP4O7xDh/n9KGn +Ob+P+n7U+8OzLo/2SzRXUHAOoUVtGrNr9DkND3Fqkn9wfD4xKGBhgYeiAtM2MCDqzlbhMZWHJvlJ +nIvsWtSZTX7FiSb1YtP5aBO56QSmmRvVtSjOxaM5F9W9WFmRm5wmd67H7cTVuJKrEZ2N7G5EhyO5 +HMnpyG7HI82A/UTeR/Y/ogcSfZCFVKpEnshI3shAyhabRqh28wTnecmTSAd3xxrg4Lg3oTAPQuGg +QsHxrZpPNp3JA2PfJEJAxYBf/7r258FN63kpzlrPyOkCHz0XkzhtA7nWPQ/34rxtA/PS1L24xjHm +1d4U5FVU42wqMSvEaHPfbfaJg+wU67BLPD44tgmNTbQI5o+FxsTd3md/V/j73D+wWNfBU3e6OtPH ++c6zXWQzjQ+OzY5E7mqjEkqYxIXeR6S50eCxYAf6iUZBp7BN3pGBpI/vWWGxKM+yie9UU11GJfxO +FHBVvoGUSfRu1bi7IuNVmbCJ56zODHUmKA7EZPan6jas3awkX3ckcw8kh09iac+m5LC9nU3RQVVn +N5mug3sD7hGq7XR9J9EGYzqPqDwoXeE9LGBZaeJnb8rTQdAeLdpwZ+qUvkRfFCxqgbFJeae+V99d +JZS5ykbIVOxkg2QlTBWxo2yiJ95R70QvU92s62dBtuEkT5anOI2ta20rm0cT/bMblDinxtnTvyxo +ygY+a+BRdPBqWvhho4enQRPfqynqNPHcdfFJlPGjxDZVG8+mj+9set89qJHvZUpTqHKjkg+uoEvO +oNEdpBq5uoTi5LxCq0xZnbDsGFpMI89OJ9eJdfAbhoQsXXaH5HcsEn8slOGxWsjxyA== + + + 3pfBcZDIcUCug0myPfY0EU/iN1L/Qfcg8GipD+FII9azPxZzI7gckCpevL35E7xHIZgXL9twrkPU +mv0Kx0ndeBK0XmQjU2+e+hi8l6FJ/HrnpJvIt3o3uUC2BrO762EMaeuzSnBbPRG7dd+faRVdUlaq +LpshUCbOiu6yWMxx0R9xD030bRDTlMETQbYXIpfyd5xXTVN31A10J64/dgLpUusLLUzm9imPW2cw +IEcbCRwD70dFH6owetxC+gaCX8M6k+4n8db0bAB2zxwnt9Ie2i72bsXJdmGeymx2sCy7STYL2Sgu +bBW6Wfjtwq1Dv2OgSJ+GbUM3juQ2j0L2ylaE7+zZj2J8Ese7G3fnwd+JB998+GJPXXLi7wf7uVoK +TJxEPVJL6TSY0d2QrmIOqSndjWkNdYvFM5lBPZrUGto+D2tvQtpiXKt5nScLzLjQzAfSG3yCQ/HR +GjW5J7a5BxVbLW+vaO9kfau6XUUKZDPE2RQX00U18EXEyWyRbt0+j/Yc7NkPD0uo3UTfyKz2MfUx +HN4zqjSrSjOrJOxjgR8X+plcntXB9mzdw5vLuerWejU1ILsMLLHdJzPfg0vIWlTPcClQJ2fRH82u +77a92PeTLIVmz2pP52CxJ7snXUgAgRke3LO4Z+7PJg3rNDzH8ZkO51/7s2f3wNPOH9IdOQxynvNn +GX8PJPx90KqZxEPxcQN/a92M9o3Z+JP5tXSpqZmThiyi7slSk3Vrri5s90wui2hvHqvqTNU4mKne +5N+bOVQtfpOmCwEczi/yIRwJ4liukToAvAtAnACT2LAnmVvkCxBrlu1ZdgiwVauWLdtW2dwDqTsJ +pjHshskEQAPYtT6OvpawrB6Q6proB9g6A53qCZxBwYH/EG5RBxoTCq6LlpIK6jJDA2w2p9wo3aS0 +RrkAZJrjkaOU54YvyTAyAVMAFsZtKQot3gaYCZ3Qq2KVHJcAMxMRhAa4EGNo85KHvi9LLQgpyoSA +Xe95Pjcl3EaYJz7F5ZpoidJlBZwDglAKoBiGLUNfkR2NkNM5H8YW2y1uazcxYQKQo/S6aInSL59O +qdxSitCCzEnhmjN1i5pTYNYax7ypJaxp4EojfxL+UENONKIzskUZUW/hDZi2tDSXCXNdvJ+SEPP8 +1ZuXdOzJMmK2kJ7ttDkigNEwPiBwsAMCeDygDgbknRwPiBSyL/14ABqOU4/bbyyMk9gXcRNSu2TM +u6DalE9iX2yti8OZCa+2xbkJ7/xTkyUft60lP7imup3hfVP7dpZxPF20ONTm6LkSh27ru0yJs1wJ +9POry0pNEXZc7SRg4JxXZpN0q0QtkyTRiXJYUX9g99VJgnTssCpkYezEQSVTIchkyJoFIROCz4zM +cmqknxtZyS513gWdIJOkOGdxMbhZ4s6QpOEUyTYrIXjvz2Q26aPcPxcN09Xl/JCn4GSeguCyfepZ +7sHJcg96Prs6hWw6TVt3p5tVYZNtsM1mH3LZNalgcsnseWPNenv25DxIwVmzW8/ncaKIboR5gfYq +2qlHcjYGmhD12D42FcbJMLtDRH06aBr8USbDPA0CY5wM3du0uESVov4mmxLDpJge8AmO02I7Mfab +KH1PDMvThTyVUcQsmxSVISFs6zRa52krd2ymeNFzebJcnC6Ty0o5O/sw+Mn7ZBkdH85Tjm4PjFzg +HMHZgULlJMH+JJOj/e0kqPTcw/BAtle101x0jut8hnO62vkhuWguVElco4ms2x9O38NE/rWFRBnu +eyzD7mCaRtrrMH/qCFNygamICbRNXWcw5yLMtRXm16GeYDJFmEQVQ0SH9QTURpgbFabDASbAAsNe +KM/jCJIggASoNK4n2B4CjegOUzXcUl9B8h+OJ7DCwwQrp1C6xQG98HcLpdIVmJE7dFzd2akuf0Tt +cw6oDcbqdM3jaWimTh8/nvahpDszTC3+PF2Mw+mRFh+H88dZzg6z9JMs04WjLJ94kIXCnxz8bHGd +LO4ZLeJ5oiNDnGe80smiDJOUso3pLNKJMo73lHO80qEmPvSEB6JgOd3RucUDpSD3dN5E+VWLZhc/ +TYWnqfA0FZ6mgpsKzl21lnkm3wJoZ6U1sslbTlKLhOzPS+dbPu1jcobl005mfcmprk88mfLV2z++ +57pBN//46rs3L9/TwaNL0H5mX3kwKQ8m5cG0TDM9wubHt3zkgOA5mbLegtaZbmq8BcU2fNLIXPo8 +DdFjPntb8hIS1saJC34g3qzrbY2hfRoJD6N5PCUtf97MHD/5KRPld2/evLh/+e3NdwK6gRUHM+Ui +mKaj+G421Rcu2swXXSwPmMzTmb1c7YyMPw2+bHImxqwJlzcxWUi3uNQJ53JxYd3ucqlmFp+lAm1d +LfksF2gI74qbhYzih40ZXzvivF5ElL9aLKIXjShYQ6JbD9WqQbCRvCMPz4FMiV4OgotB0F94550c +RsfzMPg3TCByg51A17PnfO4cT51XPndOdsiOxHU/ZH6yA+ZBDpmDeJ/odHmhszWa58GZHnuyv/lo +Oeb3wB5Bx0f0TFF+4Oj4NbZkvyNP19iS/Y48XWNL9jvy9Plbcj+7tC1csS1bsS1asS1Z4epVTEOC +sytXMaQ2zxb96znN+yFor2H7MrnIvYvdD9H7fkx9dxbA34bwqVbI+eH0j8TxOVGedcqxiMWls+bn +h8TzJvLdY99x2oS/XQj8LAiu+enHi5FwiYVPLhjew+HnAfEeEh+C4i6pXcZ7GsPiLjB++lhgfFS9 +YOm3NX9IqYFNbGllXjk2BfIGf8DQSbqoJV0LIUfdGsivRHG8dV4uIwuwxumUeNEfJAx1WWm8Hsov +27PDenHPBrDfs3lsSY/e22axkzQvSgqRs0jqmrp0lDb0Q1CT82190sla/3Vpb2TfL0eEKB5EG1Vy +paI4EqRlopokD6Ijl7xfE6kme4n8BCoH1YtBgUJC6kiP9+zIC8auWTs+RZSZZzJaslU/guSTrE6W +N7sMybk9PZf0k0nCHjtLpNI82DuX/KpJr5rw6hNd11Mbs64+qTrQpfI/m0JA06fU/3mo6A+L0s80 +wy9Y4bThT1++40tVEpd0frDk/9V2Ut1LdTdVE1eNXM76L2bnxolNXTN21dxVg1dNXjV61exVw5dM +303hkFzmFrwkqSkHju+rhYh6P0o9TEFYQLsol23NL8U0WruwotZMcnZZsGyHjytzdQ9XQGMm0IM1 +Ja6F8svEZ7woPeNYz66pj3545LCT+9k/h+HxOV3HafyvqOfuGRe5Hb+MQxLqpWP/48H/0TC507jv +ZOf/y+XjCf71JGUuVLo5U3o+4ZlGLen8oXU6atefoFx/rrfLp68/7ZdP++XTfvmfZr+MGSSE3zoy +LHCft0XbCRd0gl9yCtTF/fJLMfF++WW7blwAtNar7eKK7299L0+XN/MUR1MIv55Sz55Sz55Sz55S +z55Sz55Sz55Sz55Sz55Sz56STJ7yjZ6mwtNUeJoKn5V6hnvuJyV1LWgTty/IChMEj80w0sOI+XbG +Y1+fkfymH/1CI71dNtKbM9Kdx45UZFWPSbcwwzq6mhHdqFZNmMtFiP5rZhFpvWpQe12Xtdwxpehu +KA/hi7C4oojT4yvx/ufVLjlPKch3NpPg+8a5+qFrQM7L+X+0Rv/0QC3+x8QgzoMKIA96OsY2KeMs +OYOvbfiYp/UThfT0gK/1s0X09FAu0rmI5oygDxXnCJb9c5KOf6A8BzNhGs76Hy3T57w4RxzqXN5Z +ak9P7FmVQ8Vyej5Y6/IB8QucKUu5KEYlNwQkXcUTr5Q2suTSPpyk+4UIR59rKfPCftw1jg5dO+mc +6Ei2+Uk/4nH9QoRfJsrzZX8rgPEmzid/65O/9cnf+uRvffK3Pvlbn/ytT/7WJ3/rk2flycn2NBWe +psLTVPgyf6vdurFuhlEHEYfw0i0JDx4ymoZbEcabMMeTRuNNmP4at+Go0XTxrFFyZQsXVy7U38mh +1Qv1Tg4pETq56vt+qowlDKMvYTjMGJ0zNmOmB6cMH0Tj2aJz5UMzRebJJBOlTxNO/BuvoevzYzs7 +xrkBM2PCiUGzQudEnxGUQ8tOugarGSdBkORHXMO4gjMM9wJDrKXz29m5MfMwOf/SfpI1PF6mki8W +ex0Lve4u36gyyTJ/6PaE81Ec7k1wt6hwXdbd9NCltptrbXVcLx0yHKTB9KA4wGH+uDjYWZKnyIPp +IwLBiwQvFEaxIIIBZ8B0QTA40SBTQUQ3rvlAQ3+iZY0Dj0NOFyZcuG/RlxUdxnm6OMx9kY4X5/RR +fvCWjMmG2l+c4xatu754W3qUx7sXH6Uxnzayf3tFxnhJxjLcNrI/2wpg9Cc3/I/ZD9yO4O7CcPdg +TJss3ws7w7A3jLuD2x94IuDhiYOcuvjQVACVARWGHQxCIUVhISXhAKO/wgpJoBjMoBQcQGivTn6c +YPvY0RQK8JYTTZ4KkiLgDn+EubICfyNdq3GAaVBh4COQgVdo7GCIMozkQjdm7GC8MjBksTMJDQYk +w0AsdCXGfqLbMDKstwWYzesMRSkyeAHmImORrSpBkZl6jSdzsMtO4t1krOP7PAemOZ61zeGF8wML +ckbhb8AuV/dC9zN9yOGYNv6l7l0aXEvTIx2NH3Azjn7p6fMulLjonybP4vSB6yQeuEziw5eKTh+4 +VXS8RMLdK/qha0UnuThCXMbkH/RO46puYzn0cUeHPQId88h0vGOlKz72dKHH6XQ30bWcfBVnpis4 +V/Sdo/cabxcR98LTVHiaCk9T4Wkq+KnwWeWj2ny7zO3zsmjko59XRqrMtym28gVpQ4rhE/OGPqtc +1pcGmMvl2gZl/VA9ovM48OZaGfKLf2BpTR9ZW351be9w8gvMIsOTC9Fcrkh08YayTQRvbyvvNGlg +2IVjxrjweVR4rEy0iQlPFszrN9GsFhPWw8GHj4VrluEnLW40ljni/4X+v0l+jPZd4yaR1NPCNY9E +YS10jy7HU/inVcogFTqXS/fo7jY1kbZVkU5WF0nqIVFlJK2KxN97OaQ0STWkSteo7KQWkoYguRqS +xKXpYnCthxSlIlKUYkho9aDuvpsolrOjOkh7Mo44PDlLHaRENyU9VUK6QiWkwT59tINC3BOXyyh9 +xq2xro7OYeoVlSy3antn7PmNsfNZYSUrrTRt7ortN8X68kqD73NTYmkssrSbzuosjZWWLvs/5XLX +odySONIm5wV1NZe2HrVLNZg+VofpoVpM2RcbGLIAP1STyVVlulyXCWbCdKE4U7+q6HJ9pl6h6UKN +pmko0+QLNV26wGjxlSIuXGMEz3ShZJO/zUjm3n+mAk4gNea1UrWlGtJ6EdnCyXfzbQmS8rbm1Obw +QA7d9VB+mZKzlotKDoAffWEGl3xQG+WShUIJMQ8l3mhegho/l0ygwQh6CFExS4rRbRO6ENVgT51V +Z/hYnO+jUb7HBgw/GjJ8CNHHYo9nqMZlBjsbXyizzKAM0HVB81xqG1YFJQpRXqlMOg== + + + vmLm8jy+Gsa/9sK2Z2skXMw/DXFYOB/LrbxY2vOh1EoY42nQokc9erzIcUyo3KZUWkLlNNz/W+wK +vnWonjLaw2ANc42c8/yvukk83RoYWxNjMDKmbdaX45Hn1aOTBSeXLVgG7uzEE8DZQ2lMF6TOuWTJ +Xu51TJk8WsrkQ0mTVS5E3WH0pWfDbfPhLidOjobXGUumISW37rbXQ2Oa1EKdL9JlnATcOZfZvL0h +VVOa+XbUQCldlc64HOV8C59uweTlE1XhSaVM0F050QKmUaSzLA34dCLOJODFSudW7qCzZLZDp47Q +kQDUV6B5Txl7mK63Ep13EyVxFmAXJ3AuPYETJvLxeAeyLYKcq8CUPUhAvDs53CUeuU/S7j+u3E8f +1O43uv1jVPvpY9kIl5MRqHPX7RrmHD/ctQumy8e7N3082eJS93jkPtEy+1gHp0+1zD7WvekxuSTn +3ds4+vCNuEGCqtJKono6tQUuopMDVftRzXQO0C3aTDeX5Y2Fuq+FkS+0a3EhJKBWgZzAQxwZdnfa +20nXuiEnHpcUTYgNGwN/l1gv7szXQvhl2/VFb962UOmo565nem6k4maoPZ774rep36c4T+aFv1S1 +/EEfoSt65vyDXu/1uq+PIfg4glek/bGGrgPD1J1caMF1aeiWz2r3cQYfa6B4g/fQLZKGHM2JVsVy +aLPPs5cShFIXfJG64MliH2USdb1aDfC9S78/OY9XoL/JKM6O5kbLef/JKv+npPbV6ZqJfd4E8DR6 +Kj2dnlJPq6f2zp8q9OcKHdUD3Z5yTztR3ylULo40bqjc0Lm/cBaQrk4+Pwq4t4y71dxUdgxwc0V3 +pxmo/sJT0l9sXcy3EVQhto9agUWAP5SWxyJvBU/LrSS10brHiAaVK7ss7K+G8YvEaQyXxClAv/Ce +zZOTO2eHqiYX1KxSOdIHNEWcfulpr93ZAZ8F9ZqHDvgM4dbHHC/aUuBDvWVz3owomM4EnNKgVPDZ +xOsJtwuVHh8p3P4jc6Yf8+5Pfvt0SUiev3/jz0TTkeuzw6DRagWzbhmrKOqVzVXvwv3gur8eys8M +/uKlxzl8SfBXMHyZ4LnodoljlcVHJfpSmu+jsnwflSz6gNV2IT3wMQmHZ5lzD6HzobnHJCdQasKj +klT+mtF5nyZKwkTu8tzoJm/kYBgOzYvf/PwHf4NRu12X4Vrzq2P+xIU3f+js/ad8+osWXLoYIUgX +AgT61StPB0vu5DTP7Fz1RRJBOSG0Uvx8VfOgR9F7fXMJHW6Klt9Z7Jy30kXuFlooiq6e/ziR4RNl +kRVZbsVi63zb0CqxdbUxOMJ+oMXKu7HG2k+Thu+4n/yyEKRoMH9FOSHOTyZJxIF4vpmI7ybifXyd +xFaR/9J3vbao0cVFeoERb/hsgR3kjPH4nX43WZOj+7c/pwvPHXk/hkAljpvXauKgyx0HXU5N46PV +/Y7S5VX6wOoSKUvTR8xivcjrSJ7HB8onuFy0NFm6zDYRLZJPUtNktvV14kP1dSZLQMsXK+ywM/pC +9tkDuWe7SVzxd3IUOWjymeSeHaRGefe1fyT7bDqToZqAppJUZalKU5anLFF3ZLIdSK4e/Rir7prs +/PBqgbVm6SxHS1xZBj06W75Km2QxmSora0WVfE1O0Vu6dk6rPklWij82nzXfaiXXnU6cbgR8OK9R +fSs6leDvdCEJa5vhOOZgbWty6MSS3KuJUq96biPPK3T9n8j/HWhC4XTa0VTiiRRkIvG9CUeKXwSa +PnUS530/6YzVLvSkc5FzznckldAnzsec79AfDqPdYISPWnD+b+fE+785wuWBhybwJLuburjU0ZXO +9rdxX7u0oR30Uo5xP1vcHubj17zA/Oa1isnIZuNOjaC7zVUC480APrdlzGoZs1mkoNU0ZLAMeSub +fBV/g9iYnjKkpUxDPsp4W9iYfjKknQzpJkOWyTSml1BqE3uMxgQnNuQ0zUkTnaJsiktPd5ok4+lO +Em6OLu+J3Ux6sRwnP7HLaUyB0mOglAg1DblQmg+16CyQkTm5vKijvKUfDpUDok8Hk//2DyZfLZfk +sjNjHOXPHufJ5XN++UjDWE+Pqyj3gbHejPb0WbHDD4z39Ojo4UdHfGPJrnVeMBjWGmwmga7VgJ0g +ruTaEYfOLDk0C0b0HszK+VJM/+mycS4X9sS6nmalOk+J7fK6hfdCOcWpujuzN090tdFsezHvxJaY +PW1ysiUbm1QEzcJOZAnplbSVbkNaxbbbmXkmRthk2diRNF/SfWmuserLtcR2FKQ/kuV0IhV/JvsJ +FWBUgRPdkFOwKM9ESRyoC+9ofh+lyhifSMD+B3kSVe1BpRjVYlSMV1otXF5K1WO6N3kmLZkrTXGd +KTyxkOnoLxea8qWmDlyNzOqRLXKGgdNs8kSZNuuQZ8OZNrjsz/NsKNNmNEyjudp57NQ4XWjMPnyS +KvcqR9PFM1QrJcbsLgUctqen5IxHFE7WyezVA7LOWRbetjg8cHZKD04Nd0wnyqoZrdaj3S2tZiuy +8iNlYTl3ahrOTXnLVW9nOw6npgJldhfK0DlPEgPTdRos11Uu0rrs/mPj9ePXZT3u4qwHr9OaPnKn +1sU7tj70nN+/9aF7tx5xG9d0oXTtY4rZPvhMD1a7/dhTLz/TQ794oFouPaNFoqzV3it9ikKtDjU3 +Fosdq5lhifCfeLX0w5dLo60wPeZy6cdfL33I04Xrpa9wwfRnXjEthx18AZG76UJxCV9eYltggkpM +PNkef0u2xwMZEhk4EDHQ0TBENpb2LalS2kFWRRJL/ab6gCp6PZT/6XTScjFyAtCLteZJoeENfWfu +wsuHoCUf+MJmrh7oI6WKP/IItN6ZWYfN3Od80ynoyTmiuyuaNnTZ0hd3G2YWr7Rs7eaZ5sPRJxTm +E/u6OPWzV5/tbnlNptbccubOeIB1bxnVd/4gK9c9SrSmC63uRut8Ryv+sMkuj5SJjNKhUD7y5vZa +lLcTJVOLS1ZSqtkve5Cs+s7KSnrRjitSiqeWfbXord3zLaITO2z/13bJ8mbysQr7H77r9/wC3wvH +7T5cef/CUTz/TA/qlQ99HR94xJcop/io959ytvUx+86npYg/YteZrpc/LQdbpWYQrfuVDlf0ylLh +QjWxgystVaU756WlqFsTGVnYM95TuX9WYYr6yL3sNca218pyd+Vi2Qn7vKk45e+W5d4PdaeEByeJ +um6ul504EPzgxosllzD9uaW6tsu7JBb6x3SExJX/P7jXfSHCcdNt0EvKNFzx1IokQvCO3XTnxptV +KWmCrwD4iFbwpRi/aIOul/bn+qUpjE/3BzzdH/B0f8DT/QFP9wc83R/w2Yrxvy/Cp/sDnu4PeHKK +PRWNf5oKT1PhaSr829/X+vgihuM570/62H86f3m7eKawbc4UnozReyuyt5PsynVTXrrYT5dKTdO/ +05Dd+bk61gVNMMjRZ3QZkMNACiWhEcBqkubIs4LUKAvkSJo+qUeTnHBk1wBaellqcXBW/MkdE6+U +pLG3zGXLWybKTHWNVuXFV3dRb79mns8SxFfPv2ahs/u/4lFAtot3FD89SFj/JKH92WIBPRqggf4i +aZ8fD/Z/JJj/sbj9eWz+MTH6Taid5fdnyukLYpqE9PTlNRN3bHpsKuWPTsxs8k8loMrAw+C/LCYI +4zS4L49naWwqE1Uqbi9RINn4gF8TZvCa6UzUsrQ8FGZrfETR7giFXxHoY67DL0bJAjKXeby7FD4Q +WvFCDk9yYYk4+AFrUoRyWVx+KaYvE54X61u0sb6FFQRVgcMuhjs9kuN8Td7PNB6o2JSJ3nqYLpWI +Ht2SD5SIRl/BZD6lrW/SPEmj3LhQKmpbkZbDebsLtWgXCY/2+lllsvJQO+dHHGOlyZ3a4YjpjrJA +LGoqUpTk50RpJJlif5wK1SwZSuKnY4++SMJcOhR9QcY8QsI8rAZOH9cD9b7n/SbxfyxZui1aeilR +57TN8B8Ll66bvP40JO1s03Y25Usnl8PfDhcLmHKMak+zUq8x6tGqbbyK1diHL0ORmNWkQavhRpR+ +JworuNu41aXIFSu8UucI5b6X/Kz7SvRqk2kc52UIBYFSEsaj5Bp9aVqEMq0BxMNFyXcddFx8CBW0 +QZavddmki0AHQZzfuFPuAQNXD20Y10P5IQENgK9/+fbNr9+9evP+1Zvvnj1zctv/Yvrl9/ibyL/5 +9Yv371++ewMC/av/58cX717+cLN7893rl9+CLN8AbpblNqW6yr/xppRbjOjJvxG6+iN212yB3/+F +/vt/w4//A4B/vkk3v7j5l/8+33xL8N//Bv7Z4rx3MMF78xxgm3cNMP3s8wv4EPaGXvcrGgqwnEC/ +oBz0WonNaV5hx8HtsBbaFmeeF1jBVSpWRc4F+v0LfAG8FOu65lswNBPTKyD+l15Jv20XIPKx5+eY +EPRH+BtWLGAJW+YKKkOt9AaFxXa7tDUMH78E088+v4BP30OfA05l6ChIUXqPwspyGxvYef7zl2D6 +2ecX8Ol7lCb9vOdYDbep1UUY1Oa5XQL5N2+x6VvoY6X4YVGQGwT+1AWIG4MNJn0Bdasm/ey9A3nO +KhcuwfxsGLHpS4gamCU6pvcOxh9pw8cvwfx82OIbuLUZE4X5AdDPX4L5Edji0/eAoAuwLeAyy3OF +7Rpj6BEEG8vqhPRi9SDJApCCayC9+QdacPPNb7j6SIDlyYXkahpLIHSxiko3K+SwL9LxkxVX883v +d1zz+ObPfqb2uXJp2C4tpgtrdoMNQX9gqV8zF6bt5JWwDFWSEpehRS8KkQm9ZHOBer6dX/cPjPyw +GjcwT/yl+cqkwi6/UO27EDH8cZG3sh05iwakI9DPtA6zVKTJpdmj3LoE85Jji6/TWkHZj7Q/1oWn +FrTLhRjdMM6JAlsTNjKbOFRJA3fVQYS7pXxJmGKhq43MFZBbtRdk/x+uNPG3wtjP0wpDmIQtJkwv +wPyCvCTcrzr8tImC7OyDP4jaC2JQQfK552eYrjnsm/3AbxF+jC/J0Qvi+sLuwoSmBFbkWAst5bWN +2qmWwFyVq5L3xITiQDoK7h2M10U6l8QbmKd+i09p3WoVXtPwOEV1uQDyGC/pKPiW300nVjdBPxVl +87P01ZV/s3/34w9/Ujzmbgjzz6b5Zgd/f//n6Ud4Bi30sg5KGuizBLr5bb4BSZ2w8ucCXHgGKuF6 +i5F8B34+gkO5xYsJCawYLsH6x99MqIPiRJ4XGvuKx8JwkoJFtpLwrwXMBDoQibsXQqwA/6Lz2KFG +wyIHIjg0mI5rTgiOt3OAzwBwzbdg+wkZEZY8wGq8rfNcHWnf4OcL0gMTkMDYcGnw4dZ8w79AQzC0 +ACeQ3RsuddvwX7HhnAFjSP7lsDxxZy4DlZ7X0qPDNLTF/Qrw3gxIkdkN1PSBAB2Bb0ZKAZwLdG7o +lbb9y9j93taxSttixxxXOw2O/53a7UAdpj9Ov5vazU9/dvP7f4KfaFLDKhim9MdmOg== + + + QW8AfBOGKf/oCb+C+nS7rqCZrGEuWJ6X5vw6rxHFRHPg5xtwuC01rwT2SB4AG5JrzXzCXgpIUMCe +YCPIiShfYHIRJCZQr7hZWpfEwAw76s1IGbRc14rTjMGRu4cowUxnIJrhDMQrRW8uvhwHFDkEbYrS +kNKShJ/5Fp3VCIafZtihEFh4UnLbGAsB6y0el2ZgW2AtHAgBzCT0CTA4h0XbxiQvy3O44YYL7tsE +KzMQzp9vsCPOKxOw0ERd57bcAu8Dt12ZYTPM3gwNlDdpZQQ4qWMSYkMphWcEgIHaOnAH9mBY0Kuw +N9cQBRiXRYnF1FnGi+CoDIstS9sQZsGa5qIIwlqU56jcGoJcbYBzkLaw8UZFsCoQTH6lYE3y+XSL +kThpiiaDADsTYM4LcEG3ABMwz8EQwOoXLoLSVYUzOG9KE47DfwlFvk1hlhmWQmaOF6BAO1Zz1o4B +GLvOI9miImgpKzClrMCmhPWOwaKzmd9q4D6st2EpMo9A1DJSmBxBJwcILPl8g5ldhNaWhIcNFUN5 +f8WJL5+XyYXrYrXPY8aUTtlFP18afx5eFUIWYEPGM7CuCy/HmRa8IKhrxTmPwNR4ZDIs8rgKcE2l +Cq/XUAwBzEgdgqWxFFvmBV4S5XUpCIoF1c+ovSVuIzDNWaiNsGAF74L7gqzmeZ073rLOQgWV3WMg +Zn4Jw0tlYLjFeL12uATBC+CUpG8LLF7BG6CjSegNua2CIuGYMIocqwBLjLrKQzS0ZXwbo4VVittU +ZxoDo4lAktkCBFVbCGBpx2DYDITceVmLkNBmHeAlr0EQLKmPZNL+onTQgQDZwG1h2qfcdDJKbytI +8ahdyEUHAnb7VHSKhVqlbcUy7sxxFO4CXKuuseIQtKiCZo1MwAq9XaUpluwUIGju+qY2aw8ADF0W +8CqzZr0FxsUzBGgsCRCUF0NAJPLSWUn8IRDUnUXnQeBBaCxzOrcZQcNR1AHjTYSASZfuClvtjbUU +Cir81xDEaBtOATADS65VGWtA8rcyBcYCgM7BFo4MeENuKrsWJWpNuumui86iZeapzlgbzyIAdjlJ +IpGBpa3KbNyMFEEGurQtT+4F1niy3SaQnMKWYAoW4WssNDMW3ASDCj8Myx4Ugb4q0XZJoBx0slSD +ddmtmxKCYyu6kiOLGAC2vl5Y9sGrgf1rczQxgoCeZl2cC6stCAy6XjBec/PP0hbtYN1pBC8suZBs +wq4CA4Gs6w0lDb8rohamK67Y5zMyw+8+COw7aC1LNQRtjrrm8QQNAuFjIZgiQyoPAmOt8iowBuTz +gCwqAaBq87vgxxa2LMwwmGt0opARALLSdMGgoGcgqew8XHMpAkzzsH8pghJW6W1OTTRYfF3LgoIM +XnkZ2iiiYS2Gt5rGsujiQLyLTlnZ70HlMi3a1CMELjB/VD0y1haQO6poYoaytK1zMvkgrK0wpDrl +gi1v9EnEVSddKUna4gkdZQ1ryoggqCaGYXdBAJIz2a6WVtk9AAxyS8ElKwrVlVH4lyjAZvtMQF+H +4m01yWKMWDsegaDmFp32WA5ZgCANV91Xg/J2xcpC2RHGwJqUNVkGDGTsvOr2tdTVPg+LWDlTi36+ +b+1LCkpVjbaB9rFpKAV13QDzbwQIe7simBUY1mrAkg1Bn+LihmVwqkvt6hjD1rBEx0QGlqBDnnCz +VrR5XvJmaKBtVdUAhjkJMMH2o8rUshqCsqicyKJbALDFRYAFFiQCAxYA150KEywYQcAz83NSBCzT +AxlyRcniPSVgjE1VHtLjFUFKTVggai4C16jqXJUuhOU2JOX3ivomIwBwZh7Aagu8bgAIBot0N0cW +EwiMQV8Vdd0AGDPZhLC1cReC2ytEpUZgTirTwHaVUQBwqrrZ5JUlMLYVMy6bNojARVcC3lBlCEhR +4e6i41uAaAMzVuCRAEEsKwUgYA1Bi1nngeijIZpSjb6LnAUYWkrKWVVOABxXXXjEegFGXSFFFDzE +2nSFlKQKOIDhZ0FAnUFgcsKa7BYGdpUHdggRPggW5QIoYP0uZHRALzy0SzRgrEGBQTmQ3YYpIRkG +p6iSg7YxBtakRkhjkYiwop+vwdAWMxm1R7BpqdRaWewFXNI6gaqpSwF1bVUCaC4wMLcm1M9Fpjvu +dbqMq8lNpMlkrBEPH1uKIhBVHIAhqya9ohGr1C+rSg2x+glB1t4nUW4IgU02U43Q1bXooNgcLLB8 +i84AFQ/F9PPM2q0iWIMK5Ipq93MFR14caPqy0hdwW6ueCwycZcWUrokiFGVNX0cMzGDRyMQQGwOA +FHFipKkshiCZgpvU64Vg2uYZXGUWVx7UcRiqk9IrCg3FS3yWVS+8wQ3Upja7GAhYk/VWtyoEo61O +nSCBi0Aw5VOfnHMVoK44mUmMYDWbCCe3iALYflJTGSmWFgCTrbhaVUULzdmQbV4VAV6eqS+rxPA4 +s8nSZSQhiHQpp1IQmdo4m6PI1hzCFp2Ja1AjFj/fdEspKGsYGGzhoUNNgBTTkkFQgY7gok6OdeE1 +BsCao5fdDCQPm2xUuvAiegia7oq4tAW4JB3FyHMWgVFbNqzarwhisW2V93WAqcsRRrZk7kGg2v5u +l+DPBxA7+nlVaAFBzbqj0BAxsOG+L29a7PN4WlG0ELETAJiCAtciVMEuI642RJqiIcAcMidlngsY +LFDdPXirjbCjxKgzNrIrNeIuob4B+gijRReg7ihN9ikAdt2GtFEGZjF2C4b6ZHlEdD2mMhKAqlOQ +yR3YUYVANdf9RongZt1tVRFU02GKGIsAxNw5nUS6TUUU1VHpQt+mYC0qTTCj1ChQ/RSFuaNgsUnP +jgjEOlfVNsQIR+CitOJJU0NQZ52z6vSIKN9NIIrcwS5U1VpzUY0rAuGrKlcxCbWF43gsPOvSBKie +DNwHVR1H8Bxt2WVFAFNKKRBHBADJUpZpEJUHIL6b7KosK54LOIneWdirwcCwqkusiqcegaZO09ap +eJMZGlk211h5oEVDZU0uVrqhxs05RoC+d9Ong4Y3YrXtyq281Xn2shgVAAxR1aBiNv552+cKttlM +/mQGxqbiU7zcCMyzRhUy2naKt2ueujEgDUWNiiquLnyVORxpS1YEISpzGsXrmALbr5qYZkSBLcjU +P49HZ0fNNaIVpnq2qr4A7C6l1QwQjBsv6lCoKyvqCIzJtjYZcwCuURWfbLtNc7ZhE7sbgCknbSuh +oIi+71TPJiPsjWX161SwNnUHN1EEEGjaAQlQQ7DMbTNDJR4ucrkZWUGFdffLATg39WnreDVTyGGJ +iFMGgHU23Q+tGv18sU2k1VUJKLYL094ob4qqkJvqHbu7joSeTE6AmppHcsbAfc81YlfT8x0Lu9uA +pqG+jEgcBGjCFJvgTTsGqmewsKuHECTMsUoiJdRuT7NzBjSckQxc21x0cqtOmigly6Z3a9yx1P2I +fSYCMCCfmDBeHgBLoYmeOQd1LBFYt1eaMopWg2wAZq0hLV5HE7sIgOqkQLtGiUUFYdaOsaiFli3r +xkDCkRuGYNaGqYMJI9Qqd9j/BCB113XTFoBqgojyrB9v5qAwvkZz0Rd2oDOQ0jY3mhCCRT8BZikF +AAy6vhf0xiEwmU5fOL7ICNCDbdxu7BxMorQTMInTNmWLgqGpoBp1wpmugy2sxr6oM6QqA4UZIuRX +5QBanrNtYaz5IrCoDZs44IXAsKgnwxYXQs2DZ2Pdm2KnWB1OuKbNfqmqjAI4hVXmOzCb+1pNnR6A +3VzuOhOAyXYWxpasbUMQYJBxrRz54nG1GBg2tb2yicEIwFwX2ziaIq3NXDEmolNl7d7e9VygbmZw +ChuCYQvOXTdozG8EqtWcZBXA1lWrYi22ugG8alMVnACMs0nThfdqBKbF7zKKIJemeGVPTauJkqKh +4yU1x1gKDDMCDLOYcZvEtARoknCuWwiNksKUMzI5mvksNmhV94Y+iFGRZ5udxfzxmLdWzMuE+hkh +yFiWXdUrNfxzsBhcYWc0A11vcaUwAgCLVYOEhcg9yxF9bTpi4meCts1kRK4sIzIGBxfFWzU0hwiK +GpdRnE8ZTYWkAqkGBYJOqRqiegMASk5GUS1Yoc0YAUk6wSWuBMCKllfvgSJQNbWwg04QiFensDnI +QNLqRPCozYxg0bQdF5PF64ACtlUA1jug8XuEkrNa+N304zTKYweSuVvFI6YI+sqlDeu5gDU82Rcp +dtZ8RUU0faR1Udd/99zj65oGYyXLWF5XLDwnMg3xagxIosn48aKxlhUd/4eHP44pHaqGJQ61UMPZ +jNvUqaJ4DveAtQ3qqskzMSJz4nxYBi7q1crZ9tSiXveMORY6NW26JTwwYp6M2Olv5lQsOjOyZeN0 +x17G0JdS2jdFIqCaccviH9vOUVeXWFU5O1mQTIXJqKepfhtnQ6BTUCNF2G5ZdGlG3REe+jgeAZNX +SYQ9Z4s/FT8CaEOokFalO+P+tS6OVgaGRcki1ykjKBb0LBa4QKyrCRJx4CECx8KlI1hq011RomUA +LHU2QaKfB2VFCehzoJgShIYre3cR2Fe3WEMAzFGV7mD7esbuqIBbxJ+Uq4WEyq18vHLeSJ+Y/HFy +dqrE0PwPgCpNugTQ0tWNXmNnAIzOSdgMpeZYFM08Q2CTWZ0lJIigpIJlKTon1o6O/muutcIOfwaG +pLOBRk1f3JrqHUXit+7F6uzKXg/oPpnh4zHqm0AgykioRwVpCjqbe+QAwUklPYqD5wLtWrpGPzKm +ZmTplRryCLR39aAMghfNaazi10JgUrao6FktKI8yXRMDMlrBaqesfbcEpSHp2JlMXnmflpFnvxi0 +hBmqQLSZFG8rRfeFpnoTtKZEA+GibBeNEw0GvQfx2m63mKsewCBsdUnO7ELKGKC0/hYjjNIrpWeq +oAC4SipfYbuKgWXpG14WmPoHiotWIFozAHJyHeuWifrk6V1xo+VlNC2LAZvQVWanpmnOAQDjqoMu +oS1qGGUgi/98KNqvKi55AKaoW4taVojUXLxJLZgyu0mnwTlE2lRJpMgJA7MJhT7BEYFNGfVPltmp +z5JSupSFY/Hc1VA6Bc5mLxrYh9ZzMeO2JJmhxafYqeqGmDFxjPc8pXfhDK2VPYm6vWDbqp7yIE4h +PEdgGXqR0xERmKJlHNgUR7yruh5aCYoAh1hGVyQ2AKuJLrPZSjCfkBux4FQc8rYyUP1qw5TprvLC +aigDS1aBUPKcBKjBMCAgqNmObW3IyCcpL8u6yptsegWz6NRq7W4SQmCSSlJPCqi/VYdX1zi0pAjB +aoaFIljjovvOYt0t3csriYBIVjLHg0V0sW1JGzcBtl3Uz6z+c3yVefUJyAiic6ZqQgsAe3p0ZbsT +YYu6xVqfBQCeTXuLi/K7xWLuFLa88U1ZLWcUQfr5tNjnGwcvi89k1PBYQa3e9AaLVgBY038KR5cF +mHQTk7QTgqmY7bE8RLvoRktO+ecCzkUlNZ0kULCmxhb2cAkKiSEz/5PF1iTRnt+ULA== + + + LRe3JcWIucu6gahdhRib2qGsohS0ilTzC5azCR9XnugOjq8PzWkt8u5Vtz/yWRpJQbVBTdFHisTx +VTgXUZA2M3TW1vsUzJlgYhtfVs1Jw/H3kjh8yStA880RrA6dYvmpRfI0xxWQ3FrpqSklc8eHXblk +c8/Lbs/AUpWpxbxnCF76zsORqYJKl/FwVaRr0fELpiWXzOdTRhmfXfAkiUcL+yrLAqM7mi1HbdXl +XcT1A21BzzcHagdagKEHRIrYbQwOazZ2afxH1GyErU0aOimEubKWBC75RSWbStyT2kq2XVrOTWgP +VBHsqV+IoKcwiPsPgUlTGJwUysw5BsdZx6vniWm2SilOg6KkBEaAk8ei96uIrMKpmrIdzjoyLZtd +aClSBYepKWGS+ItVDCw6aBMZ9PqsjO27WXXbNFlADHQ++yp7SXW7TveAAlgjkYWTzxgYFtvi1kUR +dJdYNpcYIlh1HmpICttKjla3VxHYzJWDIkkR9GhulqQVpHZtW1FenRechLZRkNV3tRT9vHobe0oA +AhcN81Oolz+/chR79U6PUi1ttCejYktbCMGyIgp6ELPNQ9n4uuVgKYilWX6OxAr58+jU00kQJcJR +Z16rg1IFwFQ0U6L7oevs4tHaMEddBUv/dE2a7zLrVlrR9Wf5yOJwwM8XXYZqg2NLWy7RdPPqNUgS +UHzua3E6VVxYwAEQqLZ8ZF7eACzNYtHqucOmtWqath3bwMaWCTSvirWnLmuAGoFF+0V+BkXbE6dm +kdEAXLMmvTZRybBl0uzvtanuUzF/W3N8iwQoKkZY9OwNJaUzUEPOkj7OCIKddRJqnwu4Z57RUWcE +Rk5b5LZsUwIsJVOhTRoiOOo5MvInPRdwn4fkODGwpSTLCSAErsly6CWbCYAwutq1pJO2YgKgsixa +Uh2Al6wnk7J4NgGY7SSYSFQkd9FDG6seMCO0ljul6bg1OKeaptgCEPR4RTAvHYFKatz6a9ywsZ/F +QFIlKyHxaRVFoPkxuBmyREQKJCqE2d7CLsx40UN2ZBXr+GrCZVJXDRIgG1Bi57IAy2INW+uft9Mk +FLyQ2ZGrEBAwV42BGndPzn9U8filZreTyiqTcdEUcvJ+6AzVc4p2Go/AWcHuZf3MmB5HwcUw63A7 +CvAMlL5M8yoAqOfLEh+XEJkiQ2AnlaDhMpfkphYDYQSFpiLJ/SgjFj2L0TNWsa2dESSbVoBF1y1l +cYqQkrgatlxil4kh6nDLDoxyLtkxgNQFZdZzg8E8ZiR/U3BD+1zAQZJ5U5eJHqizG/aEJukAyetM +zTbhZJKurJabPwBpi2RgV3kwMqZLkUzt57oHSi5r7OYnbqx6dkP9qABcTHBQaE4VGceHFEx1FfU/ +soBlYG7KW8piVG0wNz0upQk+aH0shqB1W7uWVWnVCBRamlnlX8ACTs/NVNXVaHgDzxYeHlWeewZ3 +4lxvxdtXnsbWANi5K7sQehZkF5aTMOqwUDd5sjAcukEkVgMdUw1rNp0jst5mLh7JBIqYadnMFUOH +kwksSSTo+qosEKImYKBLT1IDhYfqUQv2Mk0MQZ/grMfTKDzzjJ2KWeVkP7ZArtGoeCXPFoCw2mUe +aVYxOmyXov2yxCd0+YrXJ5rrCt3Xcg4Nx76qv5hyKQSrBS2zKR6R7cxnHJdJuSgTmwX8xP0dObHV +goOiu0bW1NmrGCzjJHII9RlHSCVtKPIEfkZx1yYBhEjWjgZTZ9FcIjs3NMqrpmi0HEsMCK8pKhOC +ogWhq2jNd4Yx5ax8pNDrM4o+90mjmh7GqWddIskCIwDWzCWMgPJGjEBxQUYNRWJUvhThVxfrlEQQ +BBybpNdU0/PkDPYzSUwI0lfKQdB8BT1XEzlu+VzA1HXpr8TwEbgKXrULkkTYGWgxJ8yZEKUustfw +GSVt9HVTZOFiJoccUos9wJHkQCt/XizJlMyNG3oaAwydHIKVfFVNZaGVyWglogDAGpSARRzkACxy +0BG2/zpHQ7DMikBDhJR406JOL0kQCmYYRE6CYATBbBP0BLIEd4k/I4I52exSOUc5RjrrKQjwIFbM +VtZRpKw3RjDbofRg0h6AfWPR2UFZcbrugqWaVQvdRtMPouRvCA851w4VRl0HpjXEfkhE6gY8F3CS +k9fBEgBiNH9x5PIIDEypCIKexRjNlI12ADH20gZ0fFpgNBr8fjMOMYk66fKY5aQH5nBXnUUUwXhG +6dpU0EjmkMpZBDddHIsmEC+W1hd5dxdgrVVXrfG156FHTo16Rtnt6sHtcxOT7iWtIbIhyghmkDu6 +Zijyx0DQTwSoIWEE2hBmS39DvFnx1kVObzQ7wxQ5z5OBJeqGbzkQAY+yrQZl1yACU5/GcgCoWegW +gKbPhdUOnMZ+VqXycQdmlyTY4LmaTpXtVSG5ZZ/sWJAeRMacNd5p8KhS0UmUrYhBSHYeHtc/b6wI +DEF7IHquOwIVnZMioK3ZtK1sHgDUI4Kghcg0CsmNQT/biuetJBgR++mkZJm/sR/XQTVFBS9FuhlB +tKyuqOFNPNmVdQfWbO8QrUhJvLUz9giVSIKoC3yqpgcNIkfdntGpO7WAoun6ANREerfq8aRm1dVB +aejP+MyvBMZFeXtG56M1AhjcSSw8eC7noAAskQAsNCA5hMEieHM/yhz4kAchwMGXmgDRjlSSBqg8 +DCFpVQU93Bv5hLUiCLOJOLZLaHu0aZisKkOQFN/oNGdawE3K8UgeKhZ7aDq11CRAoGSUBXfwAutY +VN7sg8Vm59myQ4Km7GOFDj1FFXqiOIJVww16wICA4vQ1JYoQrCZMde+iGiFiygd2RjxXcGKDMXD8 +Q8Fh1nGQGh0InLPSWznpEYEaPQhdocaSKJTiRmBRY7AszBqS7susT1NpHMndCv2Yxdxmi4pFNlW5 +to46poK6YrEOD8UohbeyqWDNH3URRM3cwOpAMPGEOVWrA/VaSyIjGEG0iKlZ6BeqDv0jlSPCOkXB +OQ9CkCJJiVUVbj8XdUq0pCfQSf5Iy6iFIHqiDILLomZ+sUpJYQ1iIOqKPqeAKyWhOdmKZUajEL1X +cLYTI5KhTv5fS04W0hCYNTFm7kHWytgYrG7p7r/tiVwILJpMOFuKRunn1Ys5ogqlo2jWeFMredMD +7VoxMwIpo1LGAq4ajjEiisuPCJJgjnGAoDkHcbaI/Rne5/LC5FhBnsl7AVdL561ZQzI1a+oQnWB6 +JoGiUBSoO0dJptcVO4NFMR0NX2me2zkBB6NMjbKi1UAZrFqMZUGiH8DSeWPlnbIkria7cnKR+nI5 +MKVhBg1iJqvxUujU28X3K2Gwqaya0EsjcK/gRQmrs+YYhKQRUwvuLZbFSBFTtfh7JNNyMhY+6rFy +bk/SFIXN64WuIV0lM1EIAytHYLNZ/G02oCjNmESTe0ay6hDoHbBklawZSo0PVTCxavL3U/6YIKWu +7w1VMu3o7KB6mEnG3Qs4NztKgQqHHhPspRXIQ/D8MhLBHmYr7JVZh7oXsIr2fo4T6xBYDpokbyJs +uXAUdmYtSla9qJT+0KqG884JkDFaojtXR4r5vYKb1Y6AMZZyDuLnWdnfrf0+R/KcagJ+WSVABN+U +z68GKNIfgwhUuC5i0s1cHPj5AIZuslvluX7+HOI++obooQKAFfUXLN2KMhHrNIeVknFxJPE6GPyh +zQvdWLLAxKHyrpHvK+EKgKDXFfw9vFLyq+9Fr2tLIDCWQSKdZpVDXksLNuYUpkbxj4UgyR7/RpSM +NbHdOutaQR0BFFcrKxJERdDYG+jgJatKEyzUJz5MLZQXaxNuyK5CZeqS+oukDgspKSLyFpa/Stc8 +s2yZLfN7xpeh7gKWYC8fRVGghkA5JvMN8WXB42/EF8zYXLXMD9ckWtZogfAlyqGnZUVt0krJYACj +nQ36kqVWHrbWMOKCegjuYIgXNc2biwP2jSwoPBWGaxIpTpiecS/guLbgwM834MhWjNCMEwpv/cTa +jKo3r3ltDsisBLbg1WW+LSpsMdKU7lg9UChQLQ5euG4I8+DAFdOkjF9TwkAe5TPCCKhDBJtnGts6 +5hjWCxyTApT4urAK48mHROu4YU0yVPWXlUK1PHvQwcBATMKVGnJYQrAQDTPL129kVYGKSpyQY0Ay +9FK3IthBMKwctVpwy9LbF3RpVfVMBit2gw7NIiq5nj/BQl0yQNX2UQpF5FWZExcmbMboDu76OK2B +G7yGYIbnmLi7xFIuk1gpywxZQ249ng1RFhbN3762I25hONVB0CmQPVLYkEZHbQIuikVt0bvFC37B +cGFjMCX2S7HKsMoSApFTbi4OGS6LH6flZve9jN0cq0xCMgnvN2AMwbRyo6UUiRgc8V6TL1G5DAMy +55IUaRva4uHsmAesHigUMIIOXtjhOWBdUetIGwoUqDJNqO1tfb8M6wUeII9+8vXf7d69P7765v2r +t29evPvLzc8B9NP/9rObv/vq/btXb767+elXf3rx/cv965dUb/pPv/3L9y9/dvN/YKP9g43+4chN +/k/4i/vo9xPVpEVvKhYgAk2LyqODgkrlaheKKruC40ELeifep5B2UK4rSxayZu83YMtemWcTFtU8 +S8C8UFTIE1CHj5NHhrZUH6SMSDtM3q+jp2CctyISOtKZD+uNBAiQEXRira3vlWG9wAEcPTqdW6jC +L/wwUyF5MGoCFUFfYgblHfmKOz7rByXQfZOJC6UbczmbDlGTVnm/AUsZEyaYd3HkGJ3G487BblUd +ULk7JxaDri1mcIV1g7UDhQJG0MGL5ZQ6rDOfTxgpEKCyV6m1tr5fhvUCD4S9Aa9twtrKoMbqlRJ8 +5Q2Yu5G4GvWuoUhJ6Fhdle6mM+6C4iuYqerK/QaMdZfMccT1YnHqVdthWsmxw74RvxWofOvYUkoi +jig7UF6vrFVw4BJsI9KZXcnj+wWorFVSra3vlGG9wABh7YwVrPF6gRXvCqL7EnKka0bA/Kikvka7 +0gEvR0BIduor+6iqzJssxpOHSpYk0ws2rq5qLaoq66sDlbmhzHHTFpd1WDZYO5AJ6GKFoYGDAiPS +mU9pjwQIUJmrxFpb3y3Des4B5i2YnW2pdF3GHOgqDNC6W6RrXkCxJ4sAQ6dLossSUuZLvtBG6KwF +00oQRzy0er8BJ4vkYkHhQqpCk3oo3LVSeMcUIHcNvZw6760trrkQN1g7UCjQwVFw4FM2I9YFDyRu +KRCgMleptba+X4b1Ag+Eu5g4hBI2NlK30LpqmNdBd1JEupss+UvICstd4yzejchYAybJ3W/AUhqb +aeVyozTpJNEAdU6xWASonE01Lpu2UYr4DVg7UCiwaS/gwG7IEevCBcxGCgSonFVqra3vl2G9wAPh +7EJn/0i2xEoV7EHnWetwyw9PU3ftR7WrU2RLLbUxarxCmA2hAayVn9BRn1Yx86IUx5uxxpRaJgRU +9oq97ttigoxaPIbVA4kCRaDgcBst1KBIlx5A6QQIULmrxLq2vVsd6RkHmLl5XStdwA== + + + tuQlkHSYQTsdeRtEFlR0G9AlS3aFjsilrG9rWprfg6Nlzs+okiwi9rWCzSwrrgPVAClrzZu2GOed +1w3WDhQKbHAMrNkdDmvQQLMjgGHKWqW1t/R9NZRnDEDWLqzh5hRYVzi/7qczWK8m6ndrsWPGGFyS +4q9tMf4qFGPns9K3iu8l3sopFizLXjzMzDuxMXxLvtNhQNmB/Hb9eIdqoMLh7POuv51hylul08/Q +3k1Due37F5onu8eZJ78T796i3j3459upyLUiP17N2zb4EJ9RTBcUdZE9ZDreb8Clh2/xrAXrsatl +wFpZRgMSvy0LwLfFunmxbLA6YHI2rQMHTr8cseKFI3VLgQCZgk6ta9v75bCe8YAk1ZcbjFSVMDFp +ko94vwEHTvanCo5s7WM2bbPilnNcHVA7xon9Q1v0XKbmUXaIvJs/3cGF80hHlPUW/Rib1wtQR1ZJ +7W1djzrW895fy1jkfJZZOkdhyfsNOKDvSstrAg7ZyLTiC3QOXtocUHlb1rxs2iY5LD9g7UChQNmr +4F5xzWGtdmLWUSBARtCp7W1dv1wdtzMeXMlYpLycbD4ai0I6MCoRQbmbKA8KOQY6mk6dJUUPVO6i +O23TFmObLW+wdqBQoNxVcK/c6bAWK/fkKBCgclepdW17vxzWMx5cy15EIsjFurITReaug8oxEgZ2 +n3MNWbnLhVUNqNxtUeeutc1yQGHA2oFMgH5eob0yuUNa7CYlR4AAlblKrGvbu+WwbjlwJXuRs8QW +1YSxNuH9Bhw4R+SZFP5Vw6xVWapFLpQyIHeNSkgtm7Z4VjQuG6wdKBQocxWcrOiiw5otyclRIEBG +0Kl1bXu/HNYzHlzBXqT311WGrEZNhXDgwGm5DIyLAmn75H6J016BytlFZKNri6dRFWhYO1AoUM4q +GC9hmLVetWLNdvzFUSBA5axS69r2fjmsZzy4mr2I8opy2Mg9hQn89xtw4GQW7keLOu+SnBjFCt1B +pzgBlb1xmc/bzrkuZ1gVKBTYzBcw7DJyRNhhxUM7YUuBABWBUuva9n45rGc8uJbFiPf/NXXiUJGR ++zOwXqmBwFTV/Oh9g42yOqD2LUUdHte2RzUd1g4kCmx4DGzZlx1r6kpIpyB5haVTO7Tt/XJYNzy4 +rtGIO0VrMnp0AuD+DOxqzC/mm8CxFVYUNbSruivo5sZ52basIYQzlB1Ir9fPd7CerXBIh/mv7xeg +ySfzl1hb3ynDesaAbzgP5N8htvUh05ENmX8T6zFmi2x469GBC+cXPONi0XReyke5sOxwiz5MRkzH +2rCUpeTbJnHmD1gd0FuPDhws7uywytmtkQIBsvnZqXVte7+CryS+4YEoil9kONItRJowgRvg/QaM +yQhFS3PzSQhklisz3TlIQGUsV4zybbG07cr7YsfqgEIBI+jgoGl1DuliR1QcAQJUviqxrm3vliE9 +58D1jEdUoIr4+akgyv0GnMnzw+Q2qhSE/LKjH6BgSc6HALlrDctMprEtnqgpoQ1IHUzer2OjYMt/ +9kgXS/hzBAhQeavEura9Vw7rGQeuZTpi9fkU1HArapd3KF5Kkng1VU59pWlnNbRXOZ9mQOUt39rn +2+J6TspbxeqATIAJlKS81YNNDikYTKtcOtEJECAT0Il1bXu3HNYtB65mN8aiOSd4q2leOnMVnPvp +osoHVXlNr8ZcPidoQGUunwce2jY52TJg7UChQBEoOPgi7Yo12JloR4EAlbtKrWvb++WwnvHgWqYj +3nAgwfvI2b33GzDeFcjOH7ygIKrJoMl2dLvAAOS+rbjtxk1bupxl3WDtQKHA5v6szGlN36VIA0eu +RgKCC6g5Yl3b3q2O9IwD1zAcUSrNs4a88NTQ/Qac/GUOfEEqTTrJZMbrGVpYHFD5yqcCh7ZYaVH5 +alg7UChQBB2sJZsdVoy3lHVDgQCVsUqta+u7a1jPeHA1wxGXTg9azbNuZh2c7KpZvECDDoZwPums +7K1V/cQEVO7wjSFDW9h4irLXsHagUKAIOliTOx1WOt6UNhQIUNmr1A5te3cN6xkPrmU40pUjQZZE +trnroabEVE3MRMpiVjHM168aULtWJQtjaMs1nzZYOzCvnTUdqrc0dJxYm8OA+n4B6ueV1qFt79V6 +AZZt3l7BXERyc1NztJim4MF6igZ7QYeUNoOe0+xngs2aMKeztnx93AZrB46r2sBatWnAWls4I6C2 +ztpOa2/ZO+VQbhjA5uLHjLl/CzuODurrfOh2nAP30u9Y2H8tYrJptbBEt4o1ByRmZKwKWtvYNqOb +X3U5V1Begd6Oc+CuYTmsPRnEUeCTQRy1rm3vlzvmfsaDK9hxgHSt6srBQkL3G6i7tWLF7UICP3Zr +Bp6QXqMDKl/nkNrYNqP/dAkjVgdkApStCg16XZvDaRnN/v0CZK52Wl3b3itDetb/qxlxeO3FosMV +sa7W/Qbc7xvF+hi5yTzWukF0Y0NaHZBZM8sVxr5tXmyH6lgdUCjQsem7GRXxGrEuXONgpECAylyl +1rXt/epYz3lwLTMO7wrJRd2KczPmKhRTO6PwNqSkxwkW9nYmqnEUHVB5q8pVb4urOWj0TZA6GL/e +pIlAo9UBcjiD3YXn3i9A5azS6tr2TnWsZ/2/mhGHN6s0HTMq9nq/AWcuyMH0xqgROb2rEfpG5Vw6 +UHm7pLxpC0A6eTtgdUChQBEoONrNLA5rsKsEHAUCVO4qta5t71fHes6DaxlxWPUmZjVQVRkeoFQK +lslNi0bqpdgtXfmSY4dxx5qciXUtadqp109RDkBThB0UD/Jb2SHFGfwepq8Pfg/rlLq2vU8O67b7 +1zDgSNjrENK5yPsNuJ8cp6pFmoOrOcfQLVAJqwMqW+lYyrYt3UE0Yu1AoUARdLBeCuKwBisO7igQ +oDJWqXVtfXcN6xkPrmbA4bJZdCArXiF2vwEnU1mRYCochEA9JQjAFtbggMqdUMqyadtMZ3VY26DI +qqt2APu1L1hD35w6BWHcyJTaoW3vrmE948G1DDikgerWcNp/6JPXgeeq10hx0UUydqKxfA3qFCGg +9q1VDfNb24b3csUN1gFo1u0A1iKXA9a134TVKVgtsjVQ69r2fjmsGx5czYrD0mVNBw5Gq0/eDqaS +pgIsFqHrI19FE43jXlLW+bwtX0K9wdqBRIEhMLAUoh+QrrWcvR9h+ulOqmtpfeoYN93/j7PhMoio +dU3OfrnfgOVavGdcOVD6V602DdYutABdPxuINRFzq5u20R25VqwO6G04B5ZyaSPWhUsAjhQIkDfQ +Tm1v6/rVsZ7z4Ao2HF6Lsy7iQ0lW38SBs8X+8ZaV0HPRml4mwjUyDMh8WaRM1NAWj9/OacTqgEKB +joyCreqQQxo6szsBoR+Q98QGz0LtliE958DVzLjcw4SJT+fdb8DZVcaMrYj1kLT8BlZpnVcHVN7y +kf6hbbAD0YbUwZI7NOjAsd8j0JEGqzbmCBCg8bZt27pedaznHLiWEYflPUtTIyYbZxWY+SJhpjYV +iwDbdTkwqq3DlLFc7d63xLLCYYPSAenlylYFdt3KocScbCkX098uQGWrEtrbui51rNvOX82Aw8uc +7GAOld2734Azlzp9JpcbNQ0p6/0KKMWXxQGVs1yoamhLdRrbiNUBhQJFoGCrAuqQYi0XK1KrBAhQ +eavE9rauW4b0nAPXMt/wlitLNiOJdH8GliB6bs5gjrZ/wPRzMOYLHl7UuL62XORia4dxgHUp6cDR +iro7nIHvnBxfL0DjaythbOu61LGed/8a9htVD7Zs33XutYj6mbwsd3fgfV4lLjrfZmXrUpfkgMpX +Ks47tl2wckgcsTqgUKCc7WAtXuaw9pKtjoLQCz54anvbobuK9ZwHV7PfcvfiRb5X9X4DRt9cUzLU +ti12z9e8LkuHKWuT5Uz2llRMeUDogPJy/XwH0+WpI9JerdO9X4DKWTWsteXQT8V53vlrGW44tlTC +kjDPeoByBFerdUXH9Xh002LXxTXV7PsZvTK7JFNtixIxqZRTrCNw1ozEAawO4gFryS2cUUBA461R +69r2fpnb+YwHVzPcsGZY1AP5FN69PwNr1UwE2h7gRr6HtAmonWtRkyB929LqGdYO7HHnAWy3/Xqs +Jiv7+1sXtZ1Sa9d75PBtev8Yu235t0ukLOhrcWbL/QDMWvOP7iRYxdnOO5ndkSIg4kPVu9lcuw2m +0UgyCIZH+UpAhwMr5S+blzGMP9mpspZGe0e47eO1DtkB3mKpDnRp8/0GnC1lDEldsyi6KTW9VqK0 +6IHcLbx5T4MY1jZyqcQRawcKBToKCu4BfYc12CW0jgIBGmOF2t7W9atjPefB1Sy0gmtFBy7akRoH +xhuP5I4ULMIRtWRFsms/ymLlcZJ6b/GKk1mtYmsrFVJHrB0oFCh7FRztiiuHNeiFpI4AhilzlVZr +6TrVUZ4z4FoGGt4QYvXdgp6zdtCMJ/z0hhH1XfVL0PHulORAytc0a8zHWuIR/Bo2ODswudXcoXG4 +ZWZWc4zuefavF5CxdbVcXmnputRxnvX+aiZaxdmtSiiJ5fszcJNATp3lEnBe0EUvk0olNgdU1lLx +irFtsO3cYfVAokAR9K0/yTEyhzVYoVxHgQCVu0qta9v75bCe8eBaRlol6azmHyZ+35+BjYYeNrdL +iBasWxEcUFizaRa47KlH50H0YpvwTb0qWWxkncCz3l/V3ypA46dQ6Nr2njiEZ72+hm2Gt8EFLWQz +F7XNBrDbu/h+bZpoci0i9mtRK85qTNJG3TRQZG0D3h2yxeqBRIEyVcFdZXNY+1USjgIBKmeVWte2 +98thPePB1Wwz3EBr1IzWVVUDB079njYgWKodJcvxwBunUIZ1oLIXBv287dpy3mDtQKFAEXSwvwpL +sGJ1wRQ2FAjQ2FvO2vruGtYzHlzLRCNhpK5iSjm434BT39ixtmI15kSdOlTXqgOVObCxt7O2uWm5 +IadaKDC6XIgBLOazQxo5p3EkQIDKXCXWtfW9VaRnHLjumbphlDEl8/4M2uSqG7qFzbxXKeou0r0L +BFT+LG2tZ217fRbD6oFr7PztUKqMOyIdpnR3LxDQGGw+NTdRe7cM65YDX3ym7pEFWT5kCv7u360+ +CzAPVsC6PWHnwVZJZa7NYp5Wc2WumKXKapqrzzJXull33bSNroqHYY2uioeZix5slVQ8Vqu54ilw +9Vk8tb2t61fHes6DK5mOc8WIi0V/tD6LB3MxFezYKrlNVnMFO6YReFefBTuWw9hyXaSUtCF0EFed +xYOtjkpHaPVW/KtdbRZPpmvbe+NwnvX8aoU8K96Jo9aw1WbxYKuiMle6vF7yS+X4MnYOvvkiLMrX +KHtmb7vOck2lx+qArjaLB1sVFY/V6q14ClxtFk+ta9v75bCe8eBahTxhiHOw42Vam8WDrYoK0ltm +Lesr9Vawb3wT61CbBfkQ6thy9XEixemArjKLB1sNlY7Taq34t7u6LJ5S17b3yeE86w== + + + /9XqeFas+q15MlqXxUOtggoC27pqAjTXWgGceNy/OaByVnMoe9t11lrrDqsD9rosHmoVVDxSq7Xi +CXB1WTyxrm3vlsO65cC16nhWvINjVT1CnUgebBVUcIrwVUKu1gp2TSuMurosyIY5bFo2V2/PcHqn +mVVl8WCrn9JxWp0V/3ZXk8VT6tr2PjmcZ/2/Rg1PfP+shr/VZPFgq56CwGrBSamzgv3SjGpXkwXB +ap24tiAos1bQM6wd6GqyeLBVT/FYzcz3FDhvgKfWte39cljPeHAt65F2gW6kaU0WD7aKEDRDks46 +qbOCQD1g7GqyILjWTcvmCiEbzuaLJmtFFg+22ikdp9VY8W939Vg8pa5tdbar4Tzr/5UsRyLNStpa +PZYRLJVTEAhy3JdeEeDafJEW7VuxdHXXtqytnWHtQKvHMoKlcorHmrqS0ilIXknp1A5te78c1g0P +rmo70jRZtcaK1WMZwVI8BWmRmw+aVlmhGbVo9ELrsVD/wrZdL7vqEHagVWMZwVI3paMcVpO+29Vi +8WSOq2Tt132UfAb8X6IWy4xhClvC3VJ0YKuaMpfVKntbfRVYGTYhXS2WGW/4mlPetI1yP/KAtQO9 +pejAVjXFY7X6Kp4CV4vFU+vaNieFDesZD748/xORyv0fzdVi8WCrmoKk9hsepL4Kdqtz0GqxzHQp +m9bXtLZ4M7Ua9oa1A10tFg/WsikeqdVX8QS4WiyeWNe2d6sjPePA1YzFgjmo6l2wWiwerGVTkNxF +zjJbfZWZbt1bggNy1zKupm1bMBj6VRKCtMNcLRYP7ndROqRWX8UT4GqxeGJd294rh/WMA9cyFUvz +V63ICWsPtaopSO6coy+7wl3jS6KHWizIBq3z5trCeo4awzGsHdhrsXionb71SK2+iifA1WLxxLq2 +vVsO65YDV7MVgYZq2XNWi8WDrWrKjNdLpjLWYsG+taznJq0WC/IB9KW0aZvl1vgBawe6WiwebFVT +PFarr+IpcLVYPLWube+Xw3rGg2uZi4A5yW0frhaLB1vVFKR3lbOeVl8FgXNdtrVYsMtqLLi2Ge/c +DhusHehqsXiwlk3xSK2+iifA1WLxxLq2vVsd6RkHrmEwolSqVm5Qa7F4sFVNQVKr3NJl9VUQuKyr +L7qifC1JvT/WtoDRbEFMxdqBrhbLCJaqKR6r1VfxFLhaLJ5a19Z317Ce8eBqBiOOrtV+tVosHtxv +DCx4H9psDlibtjCEwQGVO01q37u2hb3mI9YOdLVYRnAM1laxRrYoRwoEqOxVaoe2vbuG9YwH1zIa +kYbZDA2bux7aclCZkEO00thKWAr9QEJfkHHRQHlvGaJORoeyA7PNWw8NS9Ypqji1EIJ/O8P040qn +b9k75FCOfb9WIigRG+x+i2JaggfLQVHqhJmJerMi9iG24oA2Y7Lmcbq2NduJ3Y61A8cVbWApmjJi +5eoqIwFah2WktbfsnXIoNwz4DzvDN+NZoKQnK7oN58BWMWXOsMM0NTWktgosKbyD1wOJGTnaeUbX +FiNsqscZ1g70NpwDd+3KYe0X7TgKXB0WT61r2/vlsJ7x4Ao2HJ5gkyvyeh0WD7WKKUTprEEeqa2C +vcpygNzVYZkz6j0am7O2wa4EdVg7sNdh8VBb/w5nv1nSvd/VYfG0ura9Vx3ptv9XM+Ay3p0edW/S +OiwebBVT5owFKmdRbiXJHbtWot0sp3VYkA09wm1to+1ODmv0m6bWYfFgq5jisVptFU+Bq8PiqXVt +e78c1jMeXMuEA8w1aEUJrcPioVoyBanVLFWrrYI9q1EjP1aHBbmgipVrG111dEXaYb0Oi4daxRSP +02qr+Pe7OiyeVte2d8ph3fb/agYcYE6rqghWh8WDrWIK0luTar1SWwX7pjfAuTosyIcWdWysLbyi +6VEpw9qBrg6LB1vFFI/Vaqt4ClwdFk+ta9v75bCe8eBaBhxg1ko7vQ7LCJWiKUhuKUFv35iVty2p +7aF1WBBKoYmhZbIsEofSA00JdlCrmOJxBr+H6euD38M6pa5t75PDuu3+NYw3EvaaCWh1WDzYKqYg +qbmqx0BvacxYmVYrB1kdFtpbgvosrC3+aHchKtYOdHVYRrCcv/VYrbaKp8DVYfHUura+u4b1jAdX +M95w2RRNGrQ6LCMYerlKP3oxfkkbRuAiFehSTzGmVbpoLNTaZqezGtY8KLLqph3AYtk6pNHci46A +6FyRjtihbe+WIj3jwLVMNxzgoNLHqrB4MLBmqSps9dop9IfGIMCQ9QxG0ERE6vFsafbaNmPJv3WD +tQNdFZYRTGc7Rqyxb0+dgjhuZUrt0LZ312Hd8OBqNhzStmqKr1VhGcFSLwWBWjwx9t2hWEHxOO4k +sbXztr2clcPagVaFZQRzzZQR6Wpj3t+vVVhGUnvL3qeOcdP9/zgLLhU88+mzJe83YKuXAgo3LGKt +jimVVUC4udCcVWGZUzBl1LUFpR8s1g3WDvQWnANbvRSP1SqreApcFRZPrWvb++WwnvHgChZcKlYI +31Vh8WCrl4Kk1jxbNhm7GaBbKTcP5G5FvF192xYv8tbSZIa1A10VFg/Wgikeaehs6QS4Kiye2OBZ +qN3qSM84cDUjLvUAoavC4sFaMAXJLf1uD66sgl3LqUUHVN6mRe+wt7Z4XEdDe4q0w1wVFg+2eike +qVVW8QS4KiyeWNe298phPePAtUw4wJwWvbFXzWMHtJIpRK0EHbW2CnasRC1dakZGinaJb2+Jl09r +dNNQdqBVYfHArlk5lFZZxb/dVWHxhLq2vUsO66bzVzPfEqbi6g0WVoXFg61eCpKbs0Z9pLIKdq1f +JWhVWJANek28a0u3Q9cN1g50VVg8WAumeKRWWcUT4KqweGJd296tjvSMA9cy3gDz3G950CosI1jC +5yk7czna/rHafWrRtg8gMsd1bImHP3IdMXqYk5IdbPVSPE6rrOJf76qweEpd294lh/Ws+9ew3nD7 +lIsrXBUWD7Z6KUTrovWhpbIK9qvNqy+3onztx32tbbSMX4e1A10VlhEs9VI8Vqus4ilwVVg8ta6t +765hPePB1ay31H14rgrLCK6S+pzwaLneKVb4aCJ1rmm8oOgxRpKAqeaztqDArBusHmilWDwYXQFV +ERTLwVSrwVGQnIXhqHVte78c1jMeXMt+wyFOallaMRYPBipWFbaqjKMvNCq5vS4fAZU3a7NNV9ti +VqqZb4K0w1wplhEMmo6t/2a3j6912RAgQOVttxxc295Zw3rGgatZb0hE0rLWVoplBMtZWQIuPVbG +keCUXUTbSrEQOOnZO992VuvLYe1AK8UygqWSwIi1lbP3ty5vO6XWrvfI4dv0/j+2FMscu7vFW3AO +rEVU5oha51BmZY7RTkNbOZY5omI/lG2BiWEJqh1dh3nLzYGtmIpHqTVX/Lt7dRZPZG/pXUqG8qzj +1zpmF/Hy26D5i1qhxYOtlgqSm5rmRUnVFeqZnN53FVqQCXom37XFk/6q7RnWDnQVWjzYaql4rFZ1 +xVPgKrR4al3b3i+H9YwHV7PeYnbeZqvQ4sFWS4UItlw0OUaNnUtFC+BYhRZkRKpqMVvbBTXMZYO1 +A12FFg+2cioeq9Zd8QT0Ci2e1t4yO3e7oTxjwLWMt5g3JVLuN1CrpoLUql/L6q5gx7rUsBotyINS +9cygtV3O6754YHJrejmvp+KRWuUVT4Cr0uKJdW3zeeWXcw5czYSLmKqsp9CtSssIlnoqRG8vwS/B +wdhtAlelBfmwVq1wam2DU0sMqwdalRYPtnoqHqtVXvEUuCotnlrXtvfLYT3jwbWMOMC82mEpq9Iy +go2GHlTXs1aRfNS+dAv3LLpty9ri6lQ1zrjVQVaqxYOtsorHaTVY/PtdvRZPq2vb++SwnvX/GlYc +YAUdY1uvZQS7nSzkdazXgv3SCmquXguCQ93Ua6Eph+tmxOqBVq/Fg7te57BaDRZPgavX4ql1bXu/ +HNYzHlzNikNdZVY/h9Vr8WCrrEIEL5pAqbkgERVLvZTC6rXQ/mIJlK6t3hHvsHagq9cygrUygsNq +NVg8Ba5ei6fWtfXdNaxnPLiWFUdiyVIltV6LB6e+zaNPKeiWyjVYsG/NUiitXgut1VXvmHJt06p1 +hbyisWpVoZ4zMYC5tIpHajVYPAGuXosn1rX1vVWkZxy47pm7YZS1XssIlcoqRHP3c3ENFuqfuQCs +XgvNKdNeXVswAMoGqwdamHSASmUVj3SY0s4Lsjgbop8LdxO1d8uwbjnwV1mvxR3D+9JRPyvYgrcg +qRFHc/F+A87sPwAgbpdz1doTcjfzHC0nUIA4BMsC+90yx/+fvXddjty41kSfgO9QfxRh79igkRcA +ia1fImV7fA5tOSx7RhEnJjooNlviiJceNtu29tOf9X0rE0gARRKobpJV7JJCYmEBeV+5ct1z+K1p +kbvDDmrNgbEHxwcK7g8Ogk9G4C7nizHCuNsQrY3pGpFBxwgkbjBOLXUsflsGJBJIHqsJYTJg1rE1 +M3YiOINeeEg+eBGMBhlepZlQgTbgXlDhrnQgNoVmCJgx5Qq06gsVkLxfL6orWySMY73gF2zMilTC +bEkpIlSapl4HHZ3kA0anF12UyNJiY44X+lrpTARszi4tkjpVwMjVNMmP0amuEO9DxSHjLq0UGA4/ +Q4sh2NIo6VdgXSFXkpW+JIGLoTnIEwMg995xrEBvKLAljmbhhE4Ixi1eWDlb2o4j1kiNqGSmthAj +KzsXJ3BIKRFp6dLlijILKae2zFfdKjCq3HVurUbuBteHcAKhoqFZ1iEq2rCQ0boUkAHIMA3VdNGP +iQ0Ym1W+RdaXPb+KY4u2FQHTR1a/NZqEMoDOqygFjlFFIUFEYQMjcW07O0xo5Wz1xF/md+k8FPVm +37LswiWrLP1gWcfIEyxaHW84k/FW1DdiIVytybQEGSvbxJWUszptTDgtmLhoHi6lCZ/L2nPR6oiJ +wjEFxZmkB5afrUkyvgdJSnuytT4lmW1Vr9l2KX8CLj5XRh3Bs5ZiTag1Zc1ZnFXYCXVtUz6AttRk +EDrVpTLfmH+Tdhix4Hj9ap3wIGg7kvzVN38Kb35//fbo9uOHn4Wc353fXgNYAfjmLzfXfxWafydk +vygUfHT+08V1/uLgL+/xxpT66vv/+cc/XFxKNQe/637KOfO7H/588pebt+f4OTiA7n3x9eo3/766 +vJZXhXTr9uLHj3fnH3DUyBl2ezr64uzni8u3t+fXeG9Xv/vT9V3/Dv+7iyfZb8qv5CD7x/XFmQDT +eZZ/+M/Ty4/65b8f/vD69IrfoRPs1baO49fZ4/j1BcYh+3n2SP518fbu59mjiV9v9Yh+Pr/46ee7 +2UNKnz/7mG5+/D/nZ3dHNx+v30r/jm4e2Rv9AN9x/8undx9mj3JQ5tmH+s2f3nxz+f7n0zdm7hgv +3ma88T1jwjf/OaPH20Im7z7e/vhROPyz87mzoEVnLnFq57mJpgjrc8fz4+mH8z/cng== + + + /9+PMgnzSeio1LOP8Prm+7uLu7NHqGQ/yg/8+u8Xl+fz9+egzLOP0M4d2vXHq+/O7k7/uWBkeZFn +Hxi23Nyx3Z5/+Hg5/9xIn8+hQPd03TzQ9fXULzsEzv+ek5OHO/vAvD/zglxcz12Om/fnt6d3N7ez +F6Qv8Oxo9v3Nx9uz8z/enr7/+eJs9hH3yFTkJ931lu+di+tHSMhgMPYFd83xzdX7mw8Xd3M2zVN0 +gHzYo23/7tvzd6uv99LedoxjL+1t74j20t6aUW6JtOe/ZGnv3e2psL2Xf7m5+PDK5L3ZQvxe3NtO +cW/2vtyLe3txby/uTUa1F/f24t4XI+4V9rUIfEtGsuUin391It+CEe2KyCdy0NH5P88vv//59O3N +v75s25cemRQLX8uB+ePlx0e4lc/AbG6rZPDh7u235/+8OEWHFkg9eaEX4wn+ePrxw4eL0+sjXcBd +4aVnr83b+cfw25c4h+cPZP4p/PYljuElFGDbqdnNu3cfzu+OnoOmvdC2/44j3KENfwm+BV6CZzeX +N7f/9a+fVYyZSZ9/vZyvSoxf7zfQJ4zlw/vzs+8+PrIfdo8jmO3b8+Hj7bvTs/Pvz06XIN6g0PNL +HbMHJ4v78fL09vjm+sPd6fX8dZsWfAFr2tJR/v7f72+uzzcYZV9wl2SToirL2XO05SoOUy4Yy3Yr +OQq7ZCz/PXss//2CPMhfby6u706i+uIl9JHn38etehKZix3ih16nMWEh37DtbNBGip7F1oTtXqNd +k4yWGEm2hRic3l7c/Xx1fjffALdLRGH2sffLI8qUbDj4dIsH8ggvng/EbLOo8IubPxC31QOZT5V/ +eQmi/Cqt8Iu5gW0/Oi8v7v56evGYLPmFn527IysvVxMv3nEvtJB/Pr/96RwzuUNM0NLN9RrX4uk6 +sHcZ2lih9tUrUact8ErZbmWaMXuPoe33GPqygkSOb24uj27Pz/97tlXzNXpGvb24PJ1v190lJYY5 +nB1Xfnv69uLjfNRNn++GdnO7Jc75A3k7fyBvt3kguyZi/vnm9v3PN5c3P/26Q6LJnqztEFl7NcRs +fgTLlhOzVxvGtpPErHg9LquvZqcvC6fY5q0+eyS7ttd3zuP29cbsz2ZZ9jH7943xZWP2Z/vh7lrM +/gJCvu1H0uxNtvVH0nwJZ8eOpJ3MovCIR0lG1pY537+Q1/0XueO33lHjx9lYtvXUa/ZIdiUI52+z +zanHP59eX59ffn9+eX62RJ82Lfj8FqHZltZNBzkt+GLn0LcXH95fnp6dX51f3/359P0OHUZXp1LV +bMPkTkhHq/TvavLTDH7OHTV/zee/0+dbTCm3/iRelmtwm0+v2SPZNd77GGHMf07kY1fo3QLM2vY9 +MluHsPV7ZPZIdoXDmx+J/DyJV7Zl971b5B/07uLycon/0+U2r/S725ur+YPhx8+vlXyEyckMY495 +jOeWsY8vEnM1eyw/4k6u+bpx/fr5jfqX/zr9dfaYhPLdnd4uopT6/fZqwu9u5kseNy8wkNtzioBz +h3P69u3F3cU/54tTfYEXsMdczx/X2dnHq4+PewvlI8uKvEBE0/X56ezwl7PTy7M/37ydP7a+wPMH +n83mLbLVS83/hUOYu4DDUi8kkpxeX1ydvlhq2F3NQ1eEvTPMlkl2Z6/GGWb+SHZN+7F3htkWde/+ +wsKJTmHXvGHm5zTbNXeYBaR82w+lV+MOM38ku3Yo7aQ7zGz+czfcYb7IHb/17jBnr8YdZv5IdsVY +sneH2bvDbMth9AW4w5gvxR1mAc3f9pP41bjDzB/JrvHeu+kOswCztn2PvBp3mPkj2RUOb9vcYbba +/rM73jwLttxS4vFCa7iLWQMX+AHuV+HJVuHpcm7swCI8XQdeqPHdT9r4zZ/efMucPW+Wab5mMUS7 +c0S93rxF89WAO5K16HkSgL8UNV2SJ2dP0R6maPWeor1GijZ7WfcUbU/RXglF+/2tAL5sFu0cU/Aa +6dmeQ9vTsy+Tnn3RDNqrpWd7/mxPz740epYbdd4ss8K/MrI2e/BfkA1vv23mbJvmS942swe/3zZf ++Lb5sm4L+uvFv88v/3p5+uubZcGO2+iwU5Wrarb3pM783xY4UGYldony3Z5f3TyW3mDHcr3Mzymy +z4+yz4/ymZBuZb625cpU8v9yJf99Lb/l79fyYvXaXLYvrt+ev7u4vphv4Lo9f39+evftgu2WlXj2 +8e1zxOi4dixHzIf3yBIzd3S7lCNmJjfypSWI2RYe6hVeUPjjksvGt9xTf8lYdsVXf6+w2F5y8Nje +3k270iKKsOXUbUOT0taHz99cvb/5IGz5dx8fIWG7HMAXx7hDBOH09uLu56vzu/m4tkuEYbZO7ZdH +jFPZcPDpFg/kEWVoPhDzEsqI2QN5xPkpH4jb6oHMJ82/7Apl3o1DdKHUs0tH6KvNivhZztDdMXFs +tKY740C0DwDcm5N3z5y8LE3hNmqV9ubkdbOyNyfvzcnPOJ7Xak4mcYFB2ZZfLyI0exPy3oS8NyHv +rxmZjGxvQl7T3e1REe9NyHsT8t6E/Pm1EztqQn5Nxta3F+/efZx/m8m2k4KFw9kVajA7Pd2Hj7fv +hLP9flma/0Gh7bUj6fQvG9ugzLMP7dfzy8ubf80d3+XFTz/fyfviDHlwZw9xXGx7FzDuzuObaxHd +r+fvu0m5vdLtRZVu+ztuHx/NXun2FKT0659uz8+vvxYO7Pzri+u3Fz/dfP3Pi5vL87uvb8/ffn1z +e3r90+ytttfG7bVxe23cXhu3ZmTz+bC9Su5luCoTZltdTv/74urj3SNXP+ZLkr5/dsSrZ4/p/FIe +Fql8shIvpu/59oL8+wn210t5xHyrssRJ3OM7hPKvSe304f35mRxct8/hC//s0tGrVtbMJlFpiRdL ++9OC27yGsbO///d74fU2GGVf8AUY70e0uU+gmtrrbfZ6m73e5gvS20QtjeptohKH6pu93mavt9nr +bfZ6m73eZq+32XG9zWVUaLwKF4q9EurplVDfR+FvB7VQrzN/xgb6qG1Xsb3KCODn1Bu+EH3a59DY +NuLwanJozM/YsOU5NOavyJbn0Jg/kC3PofE894Bstzfx9h+flxd3fz29eMxKsT8792fn/uzceCBb +fnbu809t29m5lCpv+7G5kTC9K0fnPu/Up839thy7i9dzn3NqSQdeqPF9zqndyjn1/c+nb2/+9RT3 +F+0OJfrCswvsil/n7KRo+4j8Z99Csy/WfPsIOc3d2v79Akg2fyC/zh/Ir1tOAbadmt28e/fh/A5b +4vb87SI6vWsywHcc6ZchAGy+qq9REtiWVXnd94nvRbNdFs0KU301FyXn8xkvwWYsGcl8RuMl+Azj +y9kj+dfF2wXuhPHr5x+Rmz+in88f9zzMhpQ+f34O6ktUajxBFu3d4a72So2dUGrUe6XG1rLC4bUo +NeYPZK/U2AHxd6/U2N5jd6/U2EZKvldq7JUa26rU+MJEs7vTBY6Wr1Ewe3d7enZ3evmXm4v5js1a +eOYap5ae2z/zcHbOlh9PP5z/4fb8/348vz6bz3GOSr1ATPr3dxd3Z48osHKJDV///eJyQa6EQZnn +13zN9rG9/nj1nWDxPxcMLS/y7CM7ezovs+ceyTKt1hbHOc8fyRMKPNtyKry+ZEcLzoN3tzdX84fD +j599OK8pddNrTXVUHs6+teXuZj4/dfMCQ9nnLhoMbp+7aJ+76IlVy/Nlki8tddGTKI3+/vH2x4+X +Mtm7pEd8nblXFogUWy4cPU/KlRfS8y6JD9urWtfyh1+9Du+x+ePYct+x8tX5ji0Y0d53bM0oX9xA +0fMlbx4Jv3/dZoq7nD97RUaKcm+luNltK8Vsb6ZdM1Jgy22BSnwv7r1ucW8Jmu0Fvr3Atxf49gLf +XuDbC3yvX+CbLRq8RoHv9fqlzc7psJf4tlPim72Ae4lvL/HtJb5PQrO9xLeX+HZY4ivMa5H5loxk +y6W+6tVJfQtGtJf61ozyxaW+/3Vz8/an29P55/1rFPle5Z0Ri2LEtzxE4jVmvJgtzO0zXjw7Qdin +8XxoIPuMF5/IYaQ8EK+CNu/zd2wtGXt3KdydXkL8Xz9enp798vVKQTfvT88u7n79rwU64Q93v17O +13HHr5/fhXvJhcvbvrMWDWbXNtMfgIg7tJdep0Z02X7ZiXN1s5xD237rzwemcjx+TeTty2EcdvE2 +wNfEcC+9PnPLN87C4eyKQmS218mHj7fvTs/Ovz87XcKRDgo9v6Z82WotG9ugzLMP7V8/L4jOv4RW +X94XMziPbITjYtu7fnFzHt9cf7g7fewqxVyrMi63Swp042Zv3tP/vrj6uMC01X3/7EtOnHs1WYbq +2Tmtzi/lYZGyOSvxYjzWtxfcNyfRyPgSXgPSB+7hk0is9tzertz6umeRdolFSgu8+IydFnwBP/ml +o/z9v9/fXJ9vMMq+4BfCEu75pZfnl/bs0p5dmtuH7yOh2kF+6XVaAzbgnLadGXweN+ntX6e9yvwZ +0oneXtz9fHW+IK/7LhGH2QfiL4/4FGTDwafbK2f88siX+UDMVq/IIxl88oG4rR7IfMr8y0sQ5lfp +SLzUerb1x+flxd1fTy8ek6j3Z+f+7NyfnRsPZMvPzvlMwJafnfMHsuVn51KqvO3H5kbC9P7ofAVH +5+7oofe3NG4jL/TklHAH1uLpOrBDiPBaUxHtk8+ORrl7qYhe7xV5G1kMtpsV/fviHNa7xrftZJKl +q1OpanZ6iV0g7GZVxn/X/eogc4fMX/PJRvp8B/bXtlOMP0rRD487j+0uwWAk1Z/TBtwVivEKz6Zn +jf/a1uwL+xQfz58g7dXk+ChmC1PbnuTjWRRRzzym776YKNedS4/xOp34FrNur3cHbb89BfYGjOzv +rzgB8i66I2yyLtu+j/IxzQ5r3BVW2xzOj43aM9v7M+kz7KUf3p3f/uHidhtUJNuyznenP85f411Q +aNrVbDsHx/4/l2ksB2VeLhXXx+uzv+0QNXl1WHbYrMrVl4Fnf9zj2QvimflSyNnRS7mYUNhB1PXf +b0+vP7ybcYvE9uD769SHbMKqbTv7uWGcyS5oQ3RoW8JX7/UhcWXoOffN5eUWrMm2TMlmyLr31VzS +gRdqfNH1T1998ydTvvn99dvuGiiAKkDe/OXm+q9SBdOUFAo+Ov/p4jp/cfCX96zD66vvf7368eby +4DdHp29/Ol+ZVbH668X1L789+Cj/lqvvDnqHmh9+lYf/R378HwH9a+VXf179f/+7XL0V6A9/OygP +y7Jsw8pWh021ujoozGHpTV1FQGHlfWXqlfWHVeUaAFpXt/LeHbq2blZnB4U7DMbblbWHrkQZf1h7 +K1WaQ9sEKVId1s7ICwGUxnsUqQ6DDV6+KQ/b2sg3tTRbVQ0BrsKzberQpmcp0hyaULW2+yIcWh88 +a3Xe1auiRZHSANC4wJ6ZEh816JoxVpox0qdKuiAA37ZeADJA3zYdAIVkHE1oBt/UHg== + + + QxaAqywBoWlqHbEzLORkukrPxmU68dwGx/670sj6GH9oMdEmHIZKRyQgb1qzMs1hZTAJAqhdVa9M +fWisR0MVuiKF8LdtWQjvZLj6LSpGaUuANwHdRQtVu2KLUlgKsRe2WmmvpJB20wPQYPgFh2LtikPT +yRNQ01YElbYx/MZWMmyZ1dq2WolrmhUnvuWQsOayJs1h21Y1qi3lExlRfVg3xA3igPMr4IStfSrT +NGFFtHGpL41fAa9ciULANSAQVr50LER8lCUQ/MRiF8BXL4MG+pamey75sf4u+pexdNEXj00UeRux +H0XfkdjVou9rHA+RXNA9zjYHXeSjxrQU/bzEqSvyuYvTW3TzGxegyFeAq1TkyxSXsujXMq520S13 +Qokiw4mEN0WPOBG1ih63iH9t/NGGiLW18yZ+7lMFmCdWiclgM5gnNqzLzM5Yk7oXYodDk7Cx6jeW +DtTZuB25+4p8+3GDFpNdXOTbmFu9yr+K1KDoyAFn38T9EGkG6UrlCVPCopQnsOcD4lT01CnRr+6b +ROGKjsSRDNZpDygdBB4ZHxFL1oWoJlMXZwCrAoT03S4IiiqCtpYdACJzDaR9QWXF+2qVyHp8PDsg +6rdtAqACjxlPFZCsc2t0rZCss8rYFXTWuarvLUbkmsGIZNiyU1w/bExMw290YjB3LVC4mztMb3D9 +9MoCCDm0aQE86UtIeOICmsFSVqZbSiFSWO0mrTZIpgyxApYlgBSScQTOdv9NXZk2opZvlPq1IeEf +ypCu1z2OEo19v8kSXY97jO2QrvsBaa5dbfodhu0Uym5fAe90N7m0+dxqtD8rPTkqk29i7UTc6Hrk +SidtogVGTyhsOo6sxgkypCoVv7FVMJHu6DnNzcDtUQUWAgGrEwUrea41XHqlcXq2Y917wk4swaYk +sZShKR5FJHfGKQ+RcLwyLER8jIS5rVdD0t2sMrKeU3wXGZSI2UKZlaB7PTMarwN3IEpsXQom/oTd +E3I9OJrkmdPbuDqeXp6DFDJe83jzjR72snxE0MobbUPQMOgRGVY6116P0LpZTU/Z8UE8Pqmnh/n4 +vB8zBIlm9yR7zFaM+Y4pazLmXkbcjZLpJuN/xizSmIeaslljTkyJcx1ZtVrntI24iD6RLjdt5PfA +Y5hQdwwjyErA8ieqQrpjuvekS9Z2DCdJV5XzpIm6JeKWyF+ifolC9gQyEdFEQxONHZJgfToecdon +B0c/HiRP96OfRRD5zT+uITS8Xf10e/r24lykEuPb30o1sjYm4G8reO7kc3foGwcMyBznzeropwNf +HZa1kCAAivRQBFPLAmNjB1l1WWKhB0dXB++k+aMjERf+4yP61pRGKFR5GIJ1Mk+AyHIYHQYWWV5V +8tKjJ6aqZalKnPaNdOSH0zi6RhkxCBIyz1bQ0kWAtMvlwIHjKFAIvhurB46VXzJD7rAuq1ZPf1OD +IYxHSyWNSSV1CHqONI3FjMpEhsYoR9EYOWtrELSgJ0kdfK2Hjeufj+WwsQ5o1oHCoTOt0yNYeEMg +npPBacuC860UEtx0liehDEMmCqeNK8GgY7+DBuGwcf3zMc8aV/v8i6qu9KgxLci7TADwH4Ay1Czj +Diur555wBbXShFrHZ8ua27AlZ4idCo7rGHvbkBeSzSxHmJKFEmea7PYS3Rc6IH2vedZYLOTxQXpV +6Md+pYX1aDHY2WygVqZS9gt6x06Aq2W3KspZ7GbBfpfc/GUgl4mxoSGB8Hw1ZFhafiFkXY+a2rKO +qgS9x6xX1mk7LRiVgA0cuKM9asNJI/Ied3TToBKihMOqEkmEoslRI8SkpCwqGFThqBGc8jwOBMso +vza+1IYiJhbAzbrmzvRoGahrQlMlQImP48/uFQubVVcW9eN8imjNsZtavux6QEQ2q66LxONVNggM +VBYhG2cr9ALzIJivU+X9KpspziZJZy2s5SrONifbt91ycDVcq9OUEEuIAKc24RVXNKFVv+gZVile +EHO8YpkcCMQpHCE9bvFNu+rQjwhqFcVc3eEw2/KVoj3RnL3xZhW3QddZdN/6VbZPsJcc8c20NbeS +c/qcNqNvw6rfi9itZQfAbjY1DxKSjzSh/X4HTaDyIZIEEA3bsoeCVHrYyGmz6skKKY8emISANAmC +rxJlwiqDyvTEC8Qt0bZE+CLdSzjUU8ZEPRPKdsSVtLWjvXw6PhggcKX43ZUmLysNWFlfRVo0UAy6 +0MSNpJucXeRmiwqZOIICg/R6BHOQEIKsa/t5iYJSnU1Uwbn0tv9mPNlKChqbrUcxXrJitKTFZM2L +EVIUY6QppnhVjDCvGGNmMUXeYozfxXgDKN21JtsjxXgbFeN9Vky3YjHercV4OxeDHW+10JAm8BNQ +YtIMb9Ipp2SlJuGiHNY29SpR4IKUyfWUqZjQLj2mm566FTn582w5o5BKgIuciFbKOiQiW4YovSYC +XOTUOb6NxYuufGyiyNuI/Sj6jsSuFn1fdThFPp445CIfM2el6KclTl2Rz12c36Kf4PwMTEvQH5Ou +jdOXnaWm6s/87rjtUCI7kzu8KXrEiahV9LgV8a/IEVCmjqcsP4+aISN7NaJiFbVHdTngNrQz3gy7 +V2U8S7etinxfxb1X5JvPuQgZbOAi28Fxj/ffgAo0PrJhWPhEKjJeraMnHUPXkZxiQpcyxrAjXv1X +ib51/CURpImqikQFgUWhzDhVxbSOiwUyuhaCfE/PFWOt6dlhRWtvIrs8YqePD/4gEsK3OZddQ1kv +LQjLUPNRmm2MS2qSUBGf6zZpai2kSBJtEaJchJWqeRdpIjLAo9mJEJJtHAc2+wqrUbU6zma8hE1H +hBUHs28aa5U81CEivG4Y3SeJpkIKYWO+xsQLpGwa1XaXqgSUeaHCjT/qOu4G4Yds/DyYWEGlFQQb +OfbKhNRw3H2Cw6p5xZyoXq8hdjfQUCbNb+VbndPGNnHTCoJYnXlPPUalvCvWJfgekAgYfvfvYvG+ +dGwjbyJ2pO9H7GrX0zicfDRxzN2Q07R0s5LmLp86vFOdQJxflK54GMYlcB0P361TXE0uptXNz/Ue +o0SGERFr0hcJrybIl+EeMbRx/TcJhxMKJzzP0ByTWgXWq3sB0y4C9MrWGb9Etrt/MS6EeiHx9vVK +y8FEJUFJ5WZT9Z1XJYTN+q4Kf6MQIaqj4U/mZzSBgwk2cZUHazBepvE6Tpd6jA1jdJli1AjniJOh +Q8kp1nL6ZNAJsUeIn+2J8X5JJbsdxcrrkG+72Hy3NYebt1kNN7jV/gyJwIROcHaaOicmaSJ19zi7 +SjPdESXW7weUi+sVD31dMKyncx0BVK10k9FIYERt+y+AMU2VEd9Oh9EhFbGOJ0sEJaxMND3hbUb3 +E2p3h0NC+yLfEAV3xODx5ODdwX/84+AfVFb98PagXv3mt6sf/tcU8NUbs/rmvfwp5aD66k23ylf9 +w3iZB6ucodAZioywbISDIyRliREijxF9vBVQZrJdxttptOFYBl0I2qNQs4fUgKPDzYRmoMSYrtxD +i/BpTqemRGxM6Fhi1IFi1L8J4WahKXmfHABrpmt6lEwOm3UrMz21JsfaGgxYc0COT9CEY/r55PCd +ns/jU1wLTk/7CUMw5hpSB0fcxZQDmfApafrH/MyU5xlzRlpSV7foljctf5HWf8L1sdyUO8yZx8GW +52bKyMOEdkzoC0qgH500Jf1AR03sZ11PqWXcfiOaOqG6Y8rMYuNZnizE+BDgkMYHxfggGZ81kaiM +TqTxkZXj4DX0+N9cI/ZLKCI8cYQiwh2HMgy0eSKnNF5O9CsVmR06f1gFNeC38BuA30PtYNoAwAEn +KiHzJlrRRRaDuaQ+bESqDfxGigQoHyrdWab0lYjzbeld9EYwtoSaq/WVU9HNwLTWQr1YqqhpIEXJ +UQQJJIqHNJqoZkxkHJGFPcSSBhIrNQEqNmJYITg16JSwHMhMVSUWGAaoytIfyNUttMztoTd8bg0M +g3L4yQBDRZzFrjL4RNXzFWVklnFWSZ9pKvpXpCkoMAcV9H8yBZjIIs0CJ6GmYB5nAYYsinIyxsqq +igpDIjJU2IAAVKpZ4oCOtUxQrtaWFTun5gVatxy0QBUkXLK9DU1CIk63ioiQ+qwqSPWLFlZvSNk+ +aomML2s1nVHTRvE8YA5Q1Kk/RstNgerhAcEGud3YA8r00ieRhfGNaa3apb3D7Aun4UoVZwW/VQ1a ++ejGIEKsow6osYo05Dpb4SOqRisp26qh1S2SDWmoBv43srqYQABMUoZSJZAAdAJoVYUQQbJ3bfrG +wpMGGF3WdURx6+huUNMjhrsAG0vGmqz+ihuydUykhzZa9AW1qyhySjtAUIeWlYQ3NTx0MtLmDttG +xR18Z2pSq/Qd6vJRc0XUK/IGXWnV20Z65Vtlzyiuo9ucs9RvYKoIQzYfWzGZAMgwran7KSrWzGMB +A20ZK9evZD0stQpYD+7Nlrsh7usyepaVMG/qUkdSIhSyimtfuojnrYvkGhRJ5Tk9W6SUS4422jq1 +24rozQATiyG61iEiu1MWwrbRqqTKIfzw2kVgezDx6+hPlO0d71Mr2iwoFYpJV9rYtbrVUXsfFGJC +Gw2EVdx0pRz3SY5WmCwqzKkcI5XhoAiqF4ykk1TDOh+bg3WqI68D2pPoL2l0kRPpSMiLjpInWl90 +xD4dCEU6EdQDjN5SxMWEw57KIZeIN3BYCEgZ9RZ8n72ONaCCOjpNDc6dM9id1xmbm9+iGQPCYGE+ +rptDC52doS+Lmxqb4VVQ82T0EFngFFcL2rSK+N4ENT1L+7KvVnIqu0Mjm++HK0igjlohLyduwNKv +K9m08HNoVnCjEtyVnXl0tmmjR3Mb9bLjvCx0kH1A7Z20GQ3l/5Dz/Xff3N4NfMYh7agHMdx7V2fw +2f94/Xb14efT9+erKzpG/6d89bX8d2CHPrkj6WkNi6As5mImAVziUjZB2eCljIJysotZBcpQi5kF +KbUJuyDFNmAYKIAuZhliqYVMg/RwOdsghTZhHFhsMevABVvOPHz1ZiP24as3GzEQkLOXsxAytA2Z +CEH+TdkIyvmbMBJScDNWgnqCjZgJ7PGN2AkU3ICh0GIbsBQouBFTgYIbsRVRd7ABY6FNLmcttNwm +zIUeMEvYC9XbLGcwIAZ/6lEZxeiVzFYd1Y1rq+THbTpDuxAbDY65N1xGpnT13e3p9U/nywNm5EAS +hHf0abBCXRkzg3MRejqvjlAnNF76uqJnlaxcS1DAZNLLhn9PaLDi2/T1iQY2YK+nOk/U8A8TtLbM +umwtR1CNfADde0YlaNdSNaU6vad6UmtF1lzqTJH3Kr4u8s7Harr+naSZUARnB09kirqunRyk7nQd +PDkYVlOiC8PWULF2JXUJgGnH14xvzTTk05ReZ29jHX0VsQt9M7EL/FO1WW+1S/mQ+olJ89JPS9F5 +UfazM0GkWS6hNsAltGyFx4CTpm3oTF+usAsttLVjNt21cN1VQJEewCO3IIwOPqHwWQ== + + + nnqEyrktnFAJyz0YtFIIg4HXsLRuhGXDq+AbcHYlfPhCoNOoMIoycjiEEhNgWpYdIqRKT2seBCWw +TJ0L9Czg8YV5E1ZBFZkkuScH0scAx2ugC71guQCGJngw9HSkhTqPZExofZBzSkENmROQf+g4uZLC +QelJwx8nVNY0tSoEGzkcFBRqqmNjpcQJYSqU7WPLRBz2pkj9I3bpMREHcXLAcVke7DpSfsTRF2k+ +iKGcozJ73b9NdQyqYDtdM6kvfVd0YqpV31+OyoZVNqg4L9nIOS0r/glVNodplvqJTpPUL4bOUbZg +7BXbjh3t15TOK55MeFz3NN4eOcpVmpeTg2LwOkJ0OliFr3Qzdc1AehDIoCtEnWLS3WI6pGI67g5l +etQp0tt+AotURz/LRcKdfikUkwVJ+/UqJmtaTNe9mCJHkeNOsQa3ijUoWEwRtViDzsUarC/WbI5i +zR4q1my1YrgjY/cGG7eb/Wx7N/lCFj1SFVNSUSS8yghKsYbuZHTpJHnVCKjBOe7hMFTp51Xb1vHg +iyKzSKLwVNBO1hxzo1YLnWqdw/RD5zBacvR7nerWk9GM1eqKsLGuecD6o53v8lexH1kNqaG+ndSL +vDf6Mu9zrCF16qSfAfhAlZxD2Yp6lncv4szkpXVeJi0MeqGUCO9s2/c0td2PZjpk2x3g43laM53T +SV+zNIMFtG02mqKfjDXYoJjS/93QNN4ks/hkqAKbTAjtXcNZoypkNLWU0YfzL6DJIn31ZrqU6BjH +Iyz/FANUABxhiloix82twTs1Gg/RE5LFBItVmJrMR9oK2eti+H6KA1mbRd7oGkzox1EMBzLd9tnk +FMO5K+LkrX29BrO6pcoQsF/SQe/WjWPtiNdOTjd315lEVYWpddIdQilTUphpY3AAgnrbdBgwSNmJ +xGpKG2k8nUMrxAWWSseMGnbljbGmk28MDzu1qOqB0ViLoHHVxZ3AY1N1gBao3OAchJsqdYmeephO +YdFAQeMZLtkiUDYGJNJ6W0a31UDhtnPGRDQpftANiP0r0EEo0ZTfR/+KvoMGYVMQ1qHkrCnMwfSs +8flWNVvkn9Tojh+Izjg5SC9pqUagF4lKWTMQO1YKBqmmRq+bmpOD1B2dwAb9wqxS45qmGUxS5W2r +gT5cDKF+UM1HBTaXTAkT1lKFNnxA7VT/ARSuri3rvJ4iLWLWXLGmV90sZZ3vpikbY7FmKrqJymas +e60FXIKN51+bA+OR4dFgNeshUhZp/jLcLXLkbZOTdY/j3RY4edhCYoNzPtBCYoQJkSKGDs9mKnrB +TdlAJ+igQYfm2MPJmuGtYGVAFEQQa6QzMh9BZEX1Y//hCgebdLZmiUb16muKtuawhcI22Ba7Xxii +o7ONWz2a26oUoDd0sGWlAaO5keQxI0dPaaIObEhrlHSPqI0aNEb0Ro0jI4qjxUc0B8AJ1RHgJnSH +ZHop5aEbyZj2kLaPqY8Ap/hP4JgC0WgwpkHU7o+3Ho+gMR366s0aSgR9/WTXQxs/oUbQtU/oEbyG +JhRJz8eOJlHzPaFK9E+a0CUquyeUiQu3ppfrqJMe5GP6pBrm6TSto1GqVB5TKYVO12kdpcrwNKNV +GUpn1CrD/mKI/lOKlW+myRHffn6lqeDp6o+35+fXn5RkKKQsQ8Kk+A6CcP/A4CB/WFccfOk8EwQw +9lOTDLXBaQR5GQ2NQoroFe5CUJ++GpYXeMU6LQT6VFoN7Q/ITiCSX1XHYMw6yzLER00yVCPTSnwv +W9h4deYULow71TpjuMmFIriUY8hoILtVo4XBR+q0bf0wxxABZzEwYvRN3VqGp5HS0IIRw8+9YHPM +oBJi50NTa6oIQ89OGB1bjflx8g/j09SDDaCKRj0h+FWpSYYaJMZANoDgdAv4GpZJ/A0uJRkK6vOs +5wBLa6qAyoWY7aJRh1nnbHI0c1VJHz7DeCPtZ7PSftNUIBjNZAAIZY8eDy07DJNjzLuBrCmwOBmj +jqGhYniadfDE1IQ3Dosm9LduvVpmAqxENcJgo5+iQTgzMaJLTIR+E2miQ6dHPgCgVWPVgOeRcACY +Z12IOYZqeIsCOW2MxQkNbR9lGVz3nHIMhUZtK/FlLF30xWMTRd5G7EfRd0R7WvRdjaMhgleljXPN +IRf5mDkrRT8tceqKfO7i/Bb9BMcVKLIl4CoV+TLFlSy6pYxrXXSLnRCiyDAiYU3Ro01ErKLHrIh9 ++iPYiLNNZWJGohAdPSvXhIiINqE6DmttOOG6KWNCgBgZiP66VTYAbisbhxn3Ffee5h3oNp9sT3XK +H+7hIt/E3OiDr0gLolWM8W0kGDatRuVjhiHjnfZKyIpfRbITTXl1nmAoEaZEuNIXibIVHWkDdri2 +ifhSWU0v1BiXUumEVrGsjtF5HgmWiIvGm4iddRvTC8H/JuJwpelXWmZoigQ7zy8UYoIhmfpgOgjq +0NxAsQ40xADZviHS9JR/B71Bf0mkYn+J8W3aA6TpGLiNKcw48JrsVp1mps8vFKcOc6tJfgjA5Ndt +N/mWlMWn5A60lXMVm24VqdB1MVVDjX2b5xaqdSNroEc7+KZuk79z5Z1SvTT1inm6m9qMUgKB3Son +pU43J5HcaDIXoedhQJKbit8koo2N1A52lO6jtOviYdBvTA1obrzPd6/2IZ0yJsRjp0qbSlO3dJTC +kc4OqYlmyCN2kt6s0ibQbUHjO1a6QTOgW0EDzAOZMJK2ptHzvI7ne5vKBKAFaaTRQ5I5LpSKtquE +Y0pqybkrHvpIj9WTO6PYYZVR84zQGyEjSsqD4rRtIlsSFKXLoOP2JV3lpf266ZgSdtBp/Bc81nUM +Rqc31LLHOErP2WVeRU5DFafKMw+OK0nedC71aCw5tS1IDGdakxGOTtfR+Ts+n6dH+PiUH7MBQ07B +KjYOmIkxtzFlSMY8y5ipmfI9iTwn6pyIc6K6U/ZqzIGNWTTFPhfR0WpyIeM1BxSJAu3APjGGXXKh +SFJIcsoQn0mRlO8kQSLRigkNlA4nshapWiJ7ieolytgTxkQ8E+1MxHVEfePj8ZjBnmNJboOqM7xt +6AFSCdLVTB0EP652XXYhi8RY0ZKcHopggqw1pMtgXXNog9DeiS1Z2MrQMnOQ/K2Yv0JmSi3GECPx +Q3DYNzAvy4rAdaeE/6WcipPsQpQg1uaz05wARBLN1uRXRcoxdsx8dq5NyQVDrfnsqi6fnYv57OJR +YRhrp/nsYvg/gu7rLClC64Y5hvh8rAntUuo/xxxDViVIy9xVIWa06/IOOo0D1EgY5r9yMaFdyl83 +TDGE5+OYzs7lX+TZ7OqYzc6vOsez45jOTofcMAVezPQV89lpMrAuY2SMMM2z2TUxm51dxQSQ42R2 +rSYYMkx4qanHmlUqG5PZtTGv2SqmRY3RFqVJmVNtyjXmVjGXXZc7LSaJ1Pw3zK7WeWRZZrKLp41t +UvawEBM9uhican1dZ5HHzGTnYia7NmayMzGTXTCxDNMCaqq4oH1pTcxk58Mokx3nTTGRcVbqrDpM +ZWf7VHbHg1R2pe2S7XYl8/ynWjlz2dWrrv2YtKzrIHPZ2VU2BuayC6t+lF0quxh/3YDBZto1jfrN +U9k17SiXnR/lsovphbhiRLJVh1DEMK8rXq+6Bc/QyZsQ09hVil0+jNLYtYqIiksR7RImZVnsTJfD +7niYw64Mq4T67GXTxiR2aRyNbqjaa3A26YImsWtX2Q6MwdpxAw5S2MUMdtUq7eA0lf0eT6lFExlg +CrsqpTSu+vjxjpRkmYYIOWFeO6aDihASqDJlUm47GtaTsETmEpVLdDCRwUQqe0qZqGkipusS22m6 +oUbzAOD9MGW0a4Ypo5uUOa+uNDw/60NTZzsrdlKzpWpscByHplTVdDwcqiZd9aabizzfUJxAJm/l +6NI340WIWS5Dtk7FeClHeaOTOJjhQjFClmKMTJFstRm+FWOULMY4W4yRuhhjfTHaFcV03xTjrVWM +tl4x3prFeO8Ww61dTPd+MSAPjZ5KWSrMLl20khh4ihyndNGGVKhOgcFwbo1UqpjSMT2sm57UFWNa +OEgXDcvGcUoX3VPUYkRxi4wYF2NCXWSYnIrn6aJTGwmX+44M0kVXoR9PkQ8ojrnIBs1ZKfppiVNX +5HMX57foJ3hwHjauX6ciX6j8XK36g7/oFjuiQ382F6Pje9WhVNHj1DBVdBuRtXY+iqa2isXp7s1M +0U1sI0sUrbsiagWynjU+ZFxLkYh3ke+muOOKfMtpn8bbtsj2bdzZ/Tdx73ecWEcgMm5tnCU6rDpC +U0yoUcYadiSr/ypRtY7D7EhfxoZqoui6Z1VjouiUE5ytMFF0wv+gSMIQctfzxTFRtF8VI2JeJGq+ +zzS0zzS0zzS0zzS0zzRk95mG9pmGxki6zzS0zzS0zzS0zzS0LZmGECKZHHoHLr0V7Cxg8GvTILvB +VQ9DwKdqkRjwSXkEJhONshDRigKNpcym1n/BIBV2Q7Cq2GbCW0ghwYZocde7v9rKmeQPopgnpwjT +6vYO3Egxy/TyOFd4y02Axb9z1agZjM80A7UupLE2pn1OAd16GwDCc113EZJlunyYkMo6RoKUcW0M +RWREpFijmhbK7eqlQCOmUzMG1j9GpslKJGeFGGzu+7QnPqWyr2Kf8DnPT4SzpOT5lfqIhUP6xakT +T0wr0EpdUeljIoozOphiaxVnh6ukPgomGrmrUMaAaxevKYAqgRAN4k4QdU5qy5ggV79qD9toV0gG +hnDYNm2MUw6tjX5QrXGRfnpuQBmTxhdhWevglTeuY2Q0IXS44hRm38jcxBS6uuuRmCFWbCrNUAWL +YBmzUnheh+SwbaJNvqKfiUyJVw8J2PR03RihrSaehjdNlBoar+6qNMGUvASmNj0EngoiXRMdI8hS +3WL7ihxwqk6NOVrwkhwdO+Rh6PV13+eKceY2H1gdw7a7wdfJPTLNDzQ+Jl5YEaewobbd9aAA2hEn +nuNlDGdMxZCGVJJw9mQSuKAtYd1LsoPe164H0K7apFvN0jcxIUFFLkamoSoHaCggS1sJQIZMizPR +14hpjAFIGxSaKtXDWxtSM4FKRRoQAGihFTMxD7amjPbatSxhdBVT/MfAdk1skWWLDmryVV1R+qLk +vR4rda3QLP9VSv+t18k49dS09G3RJP8mupORXNVRf98BaPiNniARhBTRTN8MEo8kDynRPwEgmsCd +qkzWvxIHiyN9i6OL+f5JlFI+/jMm/FfHpSzjv1FXyTX5oc8OikHS9Jj03zdZDaM81JpxCF1xyexY +B82J3kQPHHZ2lPOaIyomw2b2bBNtnkrsMX2DuSJZsTaRGv0qwJBWNf0yIKd3U8XpIp4rGWMCDF1N +1ce7Mt4VaKso/oeQnpVgOufyD5S6E6OaLv9/jnXdRSZEVToYU/MY01owncsoK3rM90QveVWs55cA +qAdbzK8ek693P9TNsku+nt0DUKumNLsIIF7vR2br7GDQmZiOHR222uH8LoBVl2T+7A== + + + IGMt0zUsdpqtPiZSZ2r1xqTmZGWMZr6vI7nyjS6yLGMk3cojCLo0cXg2ecL3KdIjlqU7UTqM7zL2 +n8VbATj5w2sBgOJGXda7iwLKkuTh7KAHuXS+IRdIBc8CHOKl7gS9veFQOSLVlJWeIextYmQ6vilA +h+5XU07qoRxaZfSXmMbhyzrCbK1x+Eiegx0fbFmy38KR40aQH64O6kZzrIw/FDgS7KQvj85mVnl0 +b5WmNnACdVmVXRjHmsiNKUOZQZexlFHkWs5Uqgy1CVupTW7CWGrJTVjLKMYuZi6j2LYBe4mSGzGY +GhOxAYupIRabMJlUKGzEZjIwZDmjGQM4l7OaGOOGzCbSSy1nNxFKugHD+dWbjVhOSNQbMJ2MK1rO +djJGaSnjKYU2YD211FLmkx1cyH5SV7eMAUWw1QYsKNZ4AyYUGLWcDQX2LmREmRVtA1aUiqNNmFES +g43YURKgjRjSGCC+jCVVEruUKVWKvglbqqfIJoyphsJtwprq+bwBc6rpyTZhT7XJTRjUmF5zOYuq +WQeWM6nKLy1nU7XcJozqSFHYdpH/38FWpZkq09Cv1JymwUi1xqI1Vu9MDDzXrVMi2vFx0lWS2gKc +FUIj0XdlguDBrB7J6odb8o5UDgdj0RyQyOWn/o7KQ9l0jV4kC9mcAzu8evS7Etf4Yt/R3cFh/6lW +dTig4034dDl4jYlXqAp7orsmmMrBuRYpZQWJQfs1SJsNjr9tQv/Z0dnsGo/ur9G3MvFCi/Jq72fV +16xsVC8vWVvmmdhgdWmDW76+UmyTFX4Awclqm4yxvmLahtJk3LcQNWXCI3+OPJBmyMTbLuclcgnH +O0tDjAdu6Ypp0wVr4HZaq86zkfBaNZ4AoLlJhcer9YZSSihK8TVao78CjmHp2a2DJKSkt9WA3vaX +tQ0u6MzoNql6NSDv8osMI0FYDgAYiA5hA6vP4OY6ehPWDa+glG9N9PImw0zBxEVLCMS8yXxvJCc3 +CJqIomp9yHwoMugWsS7Af+wQdAhppIN2cvgpN1/66uhsbn1H99VXWfXNHFR6/95bg3Qaqb8U7TSV +8GLE4zZainqkDsuRT7PTLEY/TtJyBGSx5Sj4AIHo1ATIMAb9xFWfcCswmFxZSqobmkiUklKCAU9V +0o95OFJUUAlUiZk0APiqifF8LThgDBMpOdTfCly0DIkJKfiMkUsZkxomw5IupUwNUSzomRoyPoGs +puv5ozZm0T7rb6QcXkgZ6tWAzQrVaqgpLKELoJulVsusTvYwyqBCmREVA2kKA1RfMGajRsrfJLd6 +FQmZm2My2RtRB2mkautW9yj0ExSkgzDPFLqCoJiIp4IjOJ4bCIpu/C32MTIp9d8ir/zceo/urVd2 +jSYfHlT8kEJtgn1ZjqsF+KelFmOgFluKg6mxhVio7P1SPIyllmGizuxSXHyITJBK15qS3hm6w4Iq +wncQmjdXJ+dpRKXUSS8ILGMYSwv5WR0fLYl/LYeAiYG1cOHFaZB0if31wnUySVD7BTSgNMnOtJr2 +groCprrW8MMQoyug9Qga36iiC7hGRldAaA1mNRnShpuxhnc794HMJF3lRSBsOXDZDw6+7kxnxDz9 +1fhTW7b6Rf8tt+KsWo/uqxXxiJyQQa0P7MPp8ipw6QKrvL14iVNjCxdZiy1e5rV4jqxNsvXvzdv0 +2fLIfPjl/O63GhSqiTe/O0AYtBA2yrFeSHBLSbhFuHWXXOZ0fnZuWyOMUOakQWpYnuhCKRtZOAeN +aJSvbY14EQPziaqbyrrxHYDsO9mPBGGmSYtTI0FYq3BsqVZ5Zhr02O4xTglmca/olql5vNeAht09 +IZ5+yyB/KEqouXeMd00Qqzp8cEytpqrW2B5qvKrumTH/vL24+6IZ1dAM29CIPKtxXJyxkx4C7Zll +K3rje6NfpFbTs8oW6Ff3hR/V4IdtHE/GijlwFPxsNv4OEnsvhYyv+/EKJ6jvu/HXyPtQ+g5Sj2qo +R23A21Uh/fg7SOx9qjONLrXajz/1K0HcqAY3auN4MlaMvxh37ioDxf4X6AzY+TTAYjoHBbpTZWhS +jOexGDevwXmjeSjGw+gqTuMsplPRdbD7ZjydxXjGj6cj53QQDwezkSBpGMTMJpsMouZgLhQ1Q/aJ +H9XhB63okQ1INhEJkkaQKu3GGNvNpiF1rf+kGdXRDFo5now3ekYjCIj2EihKvMhPV0zTWHpV0aTM +iLjLQ2+ioFCoeUKZ8FiW0auNq4NgOLj1XJ0sFCbcXsvLybuacIePgSI+xBssigbWjDZowE5NllJe +1i5osmFXDh+ZY8P0sALtNIimsvGhjm+Afxa3TpXgDU/4ZGOivq4eF1+jnfSbiKtGQJeVPgxVwDYU +phwaYg+VFD17W1MTj4dTegzqk3X+Cr5IJujY03hKspemYamaNzIgBo8ZGFFxQ2OgaZmc1UVBumQI +eta744Os9ycHOra6g2TjziZECmWTdXKQz2OqoetpPhAMLB67sJO3zKEm+EU++AoTZenci6QVNh5O +yCODdB9grShVA9epmY6AksGovupKHWtK5mgwso6bBpFllhbQCncHuFUPqJEwoln1hRpNpheDL+gN +EO0qTOTcQhoTlECCIuZjV3N0B2g0pUsqc5yNVfg0FzSnd5CznNkHZMfRAaKHQHKj0mUyR8fxbMY9 +VhrxV0P74DSdnex5jSkiCPc9eBVqcNgju0wG8sgP0dbqtZWAEGiYabOry3SBcKnBBKHjlmfi4P4r +L7wfrnPqa+ogWYMdrOtXV1Pq+3h8Zyku475LXY5ubi55q4v76+nd3fnt9e+vT3+8PP/jx4u35x/0 +UhfbX/3SffTv9ze3d3//9X2890XwSdbWQzNWKlvtnWrCf/e389PLP5/e3V78W74bVNJ+f3lxdv79 +2enlxfVPf7y9ePv/nv8aq5u2+DdhRj/c3Z6i+327i7nYj5eX53erYnV0evbLv05v32o+xIW3yBjG +21cx4bJFVCmf6cW+SqD45FPoIM6omKy2WnUFi+HnhfHxF5ir+JO7J/toWENXTkOwVmxl0JPBl6nz +x/045l9esoL/QolMRTJZQjVxw9U0da6clXAooGiXHqDdrUSsCzWkovazX1mik7WiJjhmScOAV5qp +k1mluklKU7RK71IZfWVdNzldYmJ9WWRlCv2Yi9svbd9ekXckLmu3qKt0fYG6oBCT9FfMcMzf/K9/ +iq35VWyMomEVv4gfRK58pRJAfJG+1KIg87HDXf1dI7EXxwdddzaM62JVV/FX14SCbWfhxs/LlCN1 +FYecdybaa9nfy+53P+z0roh1xp/4tHvfFYnfnnX9uxyJ1LXvgjH+I8ZjdKLu6idmJVHPEV0wxozg +Kd6bYRjJoj4heoMXgNH0rYCUOYG3bvmYC5sPqXz60RdhM/HxOHUiPuvdL6b/YFRd3xQDHFMnTg7G +XUzVFMq6pnGmgxOJLDytzDyneV0j/iIHC1/ZdPc0WDybEsjzQxvj49u2K9s9J3U6g2VMuuREn9K3 +fSGzSi0UbM8okLJuvL+QjQ+ajmPX6X5AUyZchEjzzA7eliRElavW3J0a74Mqo6sYM+95ZntYxTfU +ZFWG6xYs06l5qtKK/gNXxVyYDxWtnF5teXS2catHi1vFnVI10hT3mrf1FODhbOGygUATvlVHrn7f +JP/ItHM0mfLcvZMUxHH3ZI9z90/XnW4H8ZLRmXuI1rZ+F2WPj+0jvVmv7GlNFScqEkzTEcwHt1ia +vrjJ1Et11jZLvjZt1/clWy2SVpOSnz+83dJ4Tu4ftuCUGUNp+fc9gV1PXO1qCIhEBPyAD/QN1qsI +HL0cDqNHT8MkKhA/DY0zZfcLdubhOxZu2q5wXjcUjImGZj3JexQ7/qALCywevPwNxAb+jchceC+t +sbz6mGldKZ7muxbW7UZzI2YkhjGZh8wpu64EHFhs2+aUZWYbR3PbAKuHBIEZHfnUmyX/0fH6H4fc +emHiNZrmUPtwddDwpmj6M1dNqLHRE8jQSTpdYzUod+8JYR0XrQ4l8hzGI0IkWujuHzoiwHhUMfcw +fQ77V8HUlfrgCrmu1GN9tIIe2pz2scIuXjo7PCYWtny0Qcswm1YIxM2OCvDyQhwgdZci4Yu82uBH +WTbk4evQ2IpcvfS7AsT0KSOFv6/BzDNwV9fO+Eo+v+pAUAD6poq3l/AmaMOlHZVIDLYcg/oCGjKo +fa4O9A7orqC+hyLRUFMxKbEW9JBY/Rte3SoDrn+7+t33Ivpe/7T6zdHRN2dnH6/+dnNHGTbD6snR +qSfCmp5rYHfX9/6bvvdryiUivKanv8ufV7/7y83d387Pbm7fCub/JzuilsOK94xA9+iDgfeLncj1 +x9/86Y9xr/z93c3tlb6Ko5TN/fbmx/M33/ypfSOd+P7u18vzN33T+tXCWcsOj/CQoevz6TieXCnx +7c2/Nrig4ctURzhmwHXBVy1VdrYqPa/2MfBGqsOUKHtm4LSrlAKXD4UampuaPHNQj4m9bmKvm9g6 +3URTRxY5JokYSF+fnWm2ZORyvrii0i/9GvLMlToLRp6ZZT8/ywzuxBk4EiWm2Tc48x5iml2DZIrm +Ho4WYYAmjHkubI37ilRBnT2GbPOsVo5mtwIBnEaAz8c4r2GXa/U6ibmVaUSKCSsT7CSHGRg14xXA +GmyxDtSVZAMxjjSCulgKXMNd1ukK32E/HuO/G5kiIcArZb8NcyY+wH7Tc87R58EqCe+52BDQNucb +IbbViPmG3ztOiIeLNo73b59t3ObR4jZxTDn7+Zlul9IaIfENbNtXGUiWWpcnA5UR5LsrxjoQxCq9 +UKYD5ctfuiZdVi/ilMs/g5E33hrWw9DoA7BqCotDOJmOKp1ufa95u3GldwjbrnyjH+f96dqBb+IQ +lI+uiRffy0fGDr7KZmoK6ppcA3pY2ohoUn6KtDHp2tUA2PWEcbiTWRpAu7Fp0JwdA9fMFcM2x7O1 +plOfJsoUoBGman3QMFjpHUTIun4SaWbRqmTnfPNKpJk/3NzuLax7C+teitlLMXsL697Curew7i2s +ewvr3sK6t7DupoV1Yk+9OpgaT4s1JtY1hthntbEavZnjXhsruF77WFmHSLGyWmRinTR8tLzhp7Kw +FmtMrLk9tVhjb73XxlqsM7JOTZO56XJaZD3s6c2s6zrPjFCZmXXNYNYV/DzaiSrg/kqzt7U+qXbi +5Pzd3d7Wure17rUUey3F3ta6t7U+oa0Vl/swi9HVQalXAGrGQZFHDE1HCZasrSdkxWKE7xiUjK1Z +wTWgvvqs/c9tXDUIvEMobGuVQPfGyhZtBrVzMrnQ0LaKADbc2P1g0YbmpZFxdUmbR4vbxLHkvTDN +n5ndLnmnIzRKNHk6S1xIsGQ6O8lgyZQJWDWB4Z7Dxq0FJYNnVjAHlfeCkrEtA6XOKhYxCLcc9LL/ +IN08mPpKe17ZkkzGLVbmfUrvM1DfAeSmbdw6yGCuqjXzN25/PexBseJzSBXTzlGqmA== + + + jqIH9oPNiq8F9uNQC2s3u3m7+UfrpmpTUaVItABpzWrB+gA71BOIKBtKKK/Gfvq3i59+3osoexFl +L6LsRZS9iLIXUZ5SRNHLQ5McEUNkbJVLGx0ok0lSwXWgXgKhv6dTASS9zuWTYePPKKQEHdB9QgrS +61TukaKN1TQms6WUSaNjD9DHG30qKYXulXHtopBCE4+3ae34OpcKFNJzqQnSyxf03RtBsOSVXwfK +BJpUcAgq7wP1nO1kGJ2dItWYCycRlBc3hykHywQ2GGk1GTshPefNUs6n2Rs2vhb05ILJZMApqmw8 +5AyaCyHTYfewXOTIh561OhRdJnN/r1DyxUsD/3i/FwX2osBeFNiLAntRYC8KPJ0okNhwcvu1T4Fh +BCFjse3jtuCL14M0qsPrxdm+tGEVo8BM/lkSFNZAYoMn0z48ZVAYb+8Z8NgyMOXOkVh9TUxYeKRk +g8SfzQMxYY81OQ0Je6RJHE92kLL+84gDXaCOpsnoBIIGh4gAdAET99ZDEne+DlKNIYz8i8uu4sA6 +UFcuA6XKi8SLZqAUgJaBpqPp5ILBqxQMliKSsrb7hqagLpapm48ppCvGuvNqpj24B/iggCCY542w +PZ8kIIwHeTUAZiFb04FmsG5oMbRrAFk7shgtNpzyNf35FC+rQvNZ4D5WJnY10lc6bDdPYcFYtByv +SWa5u5OBCIlafXd7ev3T+UYhYLD+4lYP+EjHg6gRdgiZ8BOoCNVhsN6ukETX40KsBCiRLjU9FN3r +VEHR1ZBa6SDHBwQ1GejkgOVsD5nUnLc77lQsnMqm6vsGJ0O997wzoVZuBxqzuuN2yqp68MArhNOo +Da4bNU0lRwYPBb7DLUllaPTSIeFIzGEwZTXie5A2Xy8PfLg0PJ6RPn0US7Gw7aNN2gZjJP/58RFo +m9IHnmqtLXF4msZ7n9RqDj9AfbxeXCBCmd7lh0OReYg6VHCJG5LVtLxvJYFkuV3EBc+rdxOglKVN +v9O7VDoV7pAhPufI4Dp+iKWqHlSMqy3yNotJj7oKuk5neN+1PBlsl0Ip2xCJJ8z3TdbNwEsQE6xA +KCJ7EgRlmQ4gQbSj8QFvec9UqqGrINsZo1727Y4LjWvNm5x0aNLnyWCPp+O/T7zsXYpH3eYROhnc +ZPh5T6VA/3iSP/aTOZ3wybIc593JBvDVmzWjEuC4xkmjwz4Ouzge0HjE47U7zrqR92Iyf/cCczG4 +cutl/HTy1DWvjkLW+BL5ymUve6RUUMNEfJtenkw+v5cotzZKoMG1ftWFLXipek1sG7O6N6bitTQG +FyE1OU9ftuHQIdBHmHrcTjWQQWVdkG9Co6EeLBsqvbpbyOHiBo82abCMl0KO6O8nqseETeOt5i4m +yZclc4cxtugkvU0vTyafJwJW1wqvDpkl/yoB4rOQkCqrdfjxGsDTxyRMOiz7JOti90HXpUmRLyAU +ofLr9/vnuvBIuVj7iVyssBPO4LKdxMBWLuAJ5JxvwiFutXM9QHnX+FB0r1PZAoVTtXiQAyp7UmY1 +fTipJm9k3IOsd1m3jweDeJQ1FRrIm8Yja+qEAasfjrrDLR+4q9k0wq/UNgw5vBqW1FojsHDb5jDG +1zcC5B1bDxcOIE+TWLxlLR9t0rIQu8Om+dxsabfeFY07YO+a4OIz2o5rrtf6JkBkgKyuub5LRVmy +W+dKzS6D58iHdh8X46qKvJ1i0oti2MtiOIjj0aA63rNHbbVjDQGR69QLNmr2qonttofG8OLyBNFu +xQe85aWlqbiW7jF90KfY1uDbcU15M5NODDs5HMPxwXhMj3GXea861rIfRN4z3hWbdw2MZPd4kj/2 +Mzaa0nF3sy6kHsv5NIUMapm0MuzUsE/jEQzGN1qjvumu5WIGZMA5VtmNkdkevPeH/sswym7YuNu7 +YaZagJi0KIIEccJh69oMJPwZb9dCTCV1Z6HWi4oYSuvbuFNxhw5u3CTf220vWFMQEtttMfbL8874 +wbarVMCJ94Dr5fV97/T5+GCwEwHKdnoCFZN6i3WtF5M+FpNhFNOhFpwO3O2ZpqPAjPkym9fpTCNx +xrorIdcsScSR4aIIcINloZSzwcJouYVLMxhNWhzd75ssjwqRGywQCm62RKONVkcOrR3LZu2hXkVl +NaBdWHSc2MF0kKrRDMQ1dExSdXoGI5N+F3wp85EKF1q6WaX6O8DZQSOUwJsMJCxui3u4u1oSgLxS +/J2aT6VT98YDOJ4MaX4KKBgzW/S+ROi3DlLWIrR2DScFtRluddRUUPGhCKb0h8glIJxdqfeN964L +n0Uy6ybUaBaUK0wozVcdSObMxwl1DZx+EoBHZPyd3qXSqXA3ffH5GBiB6+46iAgnTjFCa0jPqD39 +7ppOhYtx/UXfQBQWM1SJI6txZTuz2EWQIFyqXu+JSwC23aR+6btUOhXOECM2LGMPcPZLkGDT3GgN +6ZnzZrtJ1ZepcDGuv+gbmIDu5zEG/hB9w1fZ07hlrdSOBqZ30w8Hb1fjyeknDl9P5nUy85ORoNhk +CiaT1A9kfItu1XRnf3SfEElab1AUPrTE8UDU9gG3PXbE9KT7DF/ZNod0BT9PogtYrSghxLuFXdkp +wVUJI6TINLUqcBoIDSOVkZwR1GQ9XBg8lzVNVBktbPFokxZL5gj57KktaNvTZcCt4mTJKr3/OWqN ++Dq9PZkWyPRGTXzRurqyqjlqtLRCToAbfd3jAmtBz6I/6httysgCxY7mSNx/yu6VfgDrin8B2qQu +sUX7edVIfzj9583txV3UHv1HkjE+573ZuMwc1zYXDn5VFcwNwhfWvE00gSD31KCbAMCghuxlLZQf +Dqxg1apTZqiharKtXvGJO0mNV2fONjheqa3ZrKw+Hx8kSIscNurYgQxH8LKUTYXbQKWsvODl0bTQ +KfrhttXUN3U7tWB9u49YS9N0tfCa2dSIXjPb9eJE76g1vA489rTgYAiJg+G9vGg2GzFF05qXjsZp +KThzrupnruD04jDJ+tuku3i7r6Rd4dXgYMnbdatsnMjwU0NFgPui4/We6StUhNQx/UKNF/O487mM +L2RkaZWRsMfbHhRgSwkVW+SedmwXfnUGifeOSdqNTohMGz5wNqQP6DgaDoOgZkh16C0rvJrUjSck +QY7VPzCUbf5VTTcoAng9rAD0ZmMnrbaazFBOc2PUH7kMNb0gkbwUEEwf51MP+zpo/kM80qJcV+pO +emhgFZbZ9lZGpTJRI5O6whFWmRzhwB6zu/zEx09wJbjXJEesBWwz7rRVtNaW9GrciPp1oCKUXTVd +V+kBCs1fPxqO2Jt8yJwV388K5q1psnmbLPPxdOXvd299Yo+RCnPAe17lr1t5XAXM616ttyqCbNd1 +r//j/JJu8yS73z4B6cXOto1ek1TTV8pA4ggt/TgD8vEe6iXLoFgl/w81SQYsxiWKcaW4MbhStAHC +4sbrBOieU5m+SKo21ZraZD/YjQwy+nhS26i5cXemPX4HN+4S+z39vdK8qsj1ByIvG1PYLoqcRB3t +dAYqxp8X4xrlezqXyPcBpxvJRgQUHYRfk8b1xVLVRVd3arhgZwr2BjDLhWlWkxKptqzaSdvj3k0H +wH2MoIfaKYX0ztXxtquSkyBbDR5LPuXTD0ILqL/huZFBeD90zMSYYLjePSCDNOqRY5S0s6XvI1VH +da3TYQ9L79TzQ8Qvyx9q9pcVrhujr4QZD7w83sHKccwr7R0JHlRIwjmrP6QK3HAY4Pw4qCRqZo2D +Tzd8elIeOaSscHSBLyxyWFs1UetCmO4rcnRg9i0ON9tDzg4MzybTg0TOazVJKULwGliHsYZ6julw +HbwVXUMIeQuZtpIRH21c8A4QcDzIxJwddCBZmaquEbsWxyk0kVo8A+bJ0mEAQoTTG8Kbsm1xdb0I +pnXgrek4JwNvCC+lHk6HKU3FC9lxd7dsP14RHhh6AhWQt4YXjzvv2Q585xttB+70h3C45CSK/FKh +EM4WnjsgzLgHXT6t+ifZ6xXGcnyQgULwjfrlytw0Q0CgpH6o6kHZCJxYWXwapKVftUV4X4ho6OOC +4ypzLJdMEHklw4ym9IvD7exAYRdF+F7aPPSNrakFalq94FxObgBkAuF2jGlog0c7wFFXcpR1A2cH +omhNFMWEuh4Q4qSzkILQQi2MF1xOK03F6lo56SebEZsUfEEgp4Se1taoWzxYA9uBwE01VcskgQ42 +0B6AhSmDLlEEySwAnbpKZF96ZVZSSxEidEXQEi7gCeIRTguirXV0j10rHSR2pKsg9XQynDPq0p/l +jnjal7eQVbi5Oo+sgnkSVsH5qN0XFDAhQK0kp6Uw3ZpBuZW9wCiYCHKlmrxOgLL3gsDRlrVNzuKU +6tVn0pE9ZqOKmrYMZJhhOljxi1YB1WFlA/eeyPxtk8NYE4NzAGjXALQUAFIv4l/6micDPkmZzkst +a2tWdiUHoBoaIuCkAzR9NwNYTviUTUFdsYI1h7AGAi9y5i/Sq1p0osCwN7SppC5ln416+bDa5vNt +Ejlea2HxKzmScXB47HHNl9yaut3CjfPd7Y+rYnV0+ZHbxyQtqpm7LSgrkfMkPb7qIM4eKqkMenEP +HZ5JkIsMVPDzqv+8A6QacZomkKCkHv2xAosII4PYofTr7GD8ruthLDzu8dkMw45zv40fIBDCeLiL +4F8Ep5JZcThwK7eS8xtBPdCXQPfLtqzSS/CoXugRL/qgNIrbPhrprRNZrDfvbKKmm9mnz6+vi1pM +AzF2OI32sWmc6sll8EOnT+LiAA+FTLXWBcb3CHeHpG8JJMLYITkdpGtugSUJIExbS9YVqNTBhPIZ +DZhlNRDJcFakH0QkU1KVQwBL1n3J/rmrPYFSD1INqYt9/4+zscyyLEK/qWE33tP8K2yz00tmhMtu +1sQPCP028o/iXnrgJTNCmuDla4IcAsI0TaOig20cLYe+BMsqzVYBW6b3pKBV0YDCyZkqu6xu9Szl +/QmQFRtYLV18lnmpAqdK6oaaqQfEuTs+SCCyQVWzSjVACGvS3PHXMS/OaOsmdKCCpau+dAfIWshg +sRtdPdrN1P2kssNzHVHN8j6JnGABD2QKqxyStRVhUBDpxQGxDgdemeNJv46VZFX9u0SiUuH0nE9X +B4q9SHUUGljiatUWUlG4WTT1pNWrDJi6Nu56PywNth6Nejovk8ljuekk52ug42LkdTbqyZRMBjA2 +Hjb9pQqQZ+qe0kCYszRoOxos4W7ew4TthmaW3roMaum0zvCyhtSRAHrYCdnPvrHwgbZZLQmQmjo7 +6EAQPBufYqtRDUK3DQXP1FYHoXyiHeq/6jrdVzUZ25wj0PiHiDfEsUhq9GfB2w1aZ2v1LtdbWjpC +g+kO2XQbSJeM7BLptvTpmu8I8ypsgW021kX/FI08P0yGSgJUb0Y2OPuoEak0VFk9HSA2dnaQwbqb +PrqK2qTSSK1FgGqiYpe6j7pedxWNx/bp0y3njFD/Sic8PWgi1FqE4GChsS71eso44w== + + + GlILM7+wPRXjJzpQizCsRq3FKUWQqs6gZXKh6gA6UxCnsm9iHHxfSwSkls4OOpBI6VX02dVakNy2 +dFlLCaCTy97038T+9rWMxvTpMwt1CAI/NJdIfEAuEag7EOdWQs1T5bjcwpWo1It5NMi6g2DTWmEu +GhIkxThq2nyMn+8A0IW56D4WQbJP22BUCRrryUCxMWqpOpin9mPVVSXCT9W60DeXANCOxi4lUD+M +WMt4XJ8+uZXImLjajpObHsCSgIngpUzClKOpnFBk/J/s6Ebj4Ep6R131kDbGjAipp8K1YMhcAIKp +wqkDYKYxGa4HGYjXkLNTLR0gNsTV6SBQGK66SpAugVcjpYYSAJqf2JkEygfAWsYj+gyUGP59PtHi ++FBoojOI+rz4yrlc4igE4bwFqcMZU2v4fAdDjCb9CqHUbkuqi43y0IE+X66HCDa2QnWpCeu+MlBX +gRfsauogqT1s9gQTEuZs4GLEmqD6JaXp2kuQs4O+V91XXc+7mibj+xwUGGdonSiwPoACO/WD460x +Hsz/vYeeEwG1NlSwmLKlUJNA0ONbtWPWVUsdJU8OmB8RopuesY1Vh58g6sLp+yo6QNfM2UEPM7jl +yK1SLapvUX8DNtQBzg5SXzpQ1/9YyWQ8nwGZZQ5NPObib6RSCXKgOhxzxsLDPCfGFBpHRAMZy/yK +6gBPQ5acmKGtqVemJt3CptDGoGCcNEKGlP3EtEJSOMadnfTD7Azqtkn+8XBsEkoqgCaRCEaQn8El +QzkOmIAbZljTxDhtNHxY6JOxRlJQ94EsRQ1e1TDliFenOFhicM8Qb70VYd6FuoFmi0GCNEh6Zlzh +ZVNkBQ6dKvGjtxbNhw0/oOL4mIe/a9VYmLY1Q88ID7CQDOft7N7QoUrd4cqW7l6YRebyKFsY42TW +nNMAyzr9AZBumDBGwPWztkj508TgImbdqWP6nSZEMhys7gMGvcqBV0GY033m2koji7yghswkrCvy +S0TDak3Zpg64+s/B0bvxh2XdavpHTETyvvBl285rFq5zWKtQqVVCJHS7tmQNBHJeg93boJRhXo+p +JqL/shAY4fqDbx9LIfSYX9eiZXma65WbRtbAz/STSxqmdWqlBxHwYT0TzVg9rRCq52A2K+DG2GJr +0kun9UEN/RrATJ15RUV9ic1Vw+uEyg4hujjVj6WiWuOTAMIpUCe3HAfLI55bNQPiGR4zZyBLRl2X +RIKCXZWXbyuvTMsQDNo1mUDcJEECi5OHqQXkiCOLXMERHBs/RI8q9JbkQyhBZBhTsk6LHV9H9gRD +JPkIysLUKA0AkjocH5A6gCu00SkmMUTQuEiR6cxtRi8Qgli3RMm2rfmXckIJu6YQ0KbGRRBQPBk5 +sCqUCpFswJ5GBqwmhab9sKaXF/Jy2NZGVrM1ZDU9vpJdBrohsnYFQY4mmSDfyD7za8qbBj4zbQOF +hgGhhFx3pNxLo8YbmWYYS+a1DQpQIVsSTZogEEiPsqao7HoevpSlW++VeMztdpTFa9X50Yv008jH +Rqv0NN6iwODGvjwVaXJthmynxkbjdKva6kqTLOFgdo2KXTzO6flo6CinCVTgBkI6Q2+5w9AaOiUw +4RK/0kSPjrkZ9IJJ3mlXOPK/VEtYaDNoJ2xUlDS1ujDCBTNA5wTHb4o+Qn5CaNS0LshJz1L62qOD +4J5hSOclr9hewvckmfsMLFFwwnGD36HshcyByrrQlwDP6D1Ye+DCMcyOctpqSkHqEKyWBLvZVOpA +MJi5jYlIBasb0NI1PNiMceoeKFtHBl5Ca46xSmOHFAlUQPWHUbcGoyfdFUoXgmbZMKoIEKkiUMdi +kFqhpru+HOkWxmXqBL2DE2u7prSVeSvVbcc4OWpFKm/oPw/jl6uT1Fq28xo+ortaCb95+b7yejPJ +uBzCGnyLoIrSQw5isXn9FVa7hImVTEvLULVPphuLF+ZJriYRWak05UtTjWEOdzWMU1UGTxbm6qtD +qwxpExzllFr2IEUwqnKxn2yr2jPqknWLmUodxNSlChwrK65UygHAey3UQuSmbGfpr8MsToE3B6lR +Df5y9PqiQbvWT+g0qLrWqPQMmuWwIEsRlIdVbYi0RicxSIW8AOuMZI0eBYJw0D8bfmXogejp2avl +1JLjYwC6kkOKKPQ8U7VJZ15p9A7P6TxuKrcER5ZYbwOPfyNU8NQzABO8GvLA88QnE1KBKXCqtBBM +JqE2ng71Mu1G1bQeZFhWS7ZyK+xEq1lihBjUzLwjcxUgiOqdYqPSuAnokB58IZT45TRXJZhR1zD2 +ysqA1hVd1/CRnk3W1Y16axln1xaVnZnyzKBvyrvM67LegttWoEGcFmM+WXxZujpPw3y4Gt6EL0tG +4CWmHolWXXjomFSRscCRLztYQ08RK6HnO3c9vNwhxqj5keRFTmPekhuEclR8VutW1LdALoabk9CL +Ggpb6qO8Vz0VdSIameHoy9fqTnX6Bn6bvqSLKJgTEw1YjHV28JYsdctGjXNzGB3+AItEsFEcAqSt +jH7lNEakRJgJvX+VNh3TKVZVXHK2lrWMAqoieP6DitSVpzJmOHEbMxuePo+HGot+CLuMECNkAre1 +8NuqSJNJkHadD72So0VyLSEYFt5e8CqAsxqodOVUYwA+yvoo9OOA/IHGaI9zGqKYb2MU7qRw7cDx +QVda1TBdNL5OOo4WVMlB1sc9FXNaPVJTka0MxT1bGrOuoBAACL2qlqOC7Whud4VCCJZCiUgTQNmW +4dM5jWWr8hQEAt7MZeNemM8AfWdCgMJkF8TA67aJHupVFbWWVRNjtyr11RXpsVVnCgvXKfqMV+oc +CxiOfo8MN1Y/ogYabsz8Wj+p26hyaHFeYzMypaFpoi8rTFstqQFi86mTlk+jAzbDbYLmjFMeptQb +60Ag6OAuhw2pmoWDfBt90UXKhtssCEZLwzdSIzAHszohW6ppHAEwMB7DbFGSy6C7YBmNvfD4BiUj +1RlP4sZ8BXMFlurjiT8tlfQtKJEPtUcSN3D5Ica2RauObUqw6HXczDHXutecTRpcEETuPqQWJgjv +JlValU2gJ4aOoHUCdWV9T2lHExGcFZuqaQ4ZcnVEY0EN+6LqNsi9z2v7CHdkuqYpQ1RueHdfUbCq +LT0FBGXkvcooM/uN4lKQ2o3Ix34yd7FwjZ6AeDCNhHBWLy2jDDQbbeThIX9gi0OBjdNV9gk9ip2P ++1iwRHgCNejhBLd0UGKIiMYNciPiWg6KD/IM5SgCa9SmKowAoiZwoYiqAcjgQ+0g7WgUiY/REpAT +8beF1ssxmIkHP60vrgL/0jC9Oty/asZstgbkQM5AGjYM7R+gNy7GQwkBrEFBXKmJxstDajTpsGfp +Rq7xMoyfpXpXqBmIFo0pUIBBHSv0bjxfG3MYbVUyvLFivktps9EQGwN2zQo7I3w9IgbaYKNSWvUZ +sAqWDDXwIkWtcN+n9er45kj+yZszBJO5zlxdK9FAxCJUmit4/gnxlSN/Wlg4AtjiIGVZof26MEec +Rw8zCExlXo7fec1iz3twHIg5MU2gVnlasIaImBIQQL10NLe7lH8C5knKgsD55tO5jOUr8yQKjRah ++XMTxz8Rsejcx/P7S1q65sRQBzp2dSB4WNGW3cY4MTnYmE8j/VTFehs9KAgqWNp3pfvn1IDKDBHW +JPVArAYBEDB8lf1Phi9pqFuE9H2OxSeDuHcfN2rMjskTRapi1osQJ0SkI5lTOdSiCCYMtUUgoJ1k +VaSABRuTlwORHuTZvREVEh9i6+CkZY+7jCGGxkfr4MjiHyjdCG3yTdCI+mFaxYVNHy1tmqUpnant +JG6/fwz1YVPX1CkiZcAZqARv1A2QSa8JWoJOvBJ6MUJtnKFjFn49ked/ln/DPU3+DQ1P6TO4lk8U +oILsGKMAFQV9QoAKDv77AlSyd/sAlZ0NUNnHpqSsd88Wm/KJie/2ISr7EJVdClGp7YMhKnD1GUWo +APRIgIp5xgAVMydAhW5Ng/iUfGCfKTyljDeEpocuRMXMD1GxWdTIVQ7LQ1TMJESlWo1DVGz5mUJU +tKJBiEq1moSomEmIih1UNB7bZwpRsXHK00MXovKpMSrNOEalmcSoMOx6EKMiAuwwRsU2kxgVAQ1i +VFDLMEalmcaoNC8Qo2KjW3R66GJUqs8ZpKJe0YMYlc8WoTKMT2FLux+eomJlHp5CSB6ewnQw2xKe +ws7k4SlpAF14Sj6izxSeEjOIFOmhC0+pniU8hWMehqe0k/CUdk14SjsOT9HZ29bwlNYk6qsPKTyl +Np8xPAX51rclPIW5319FeApR5uHwlGZGeIqdEZ4SuYYuPMWMwlPq9jMFqCBp1KcGqNRBD/otjVBp +NGaDl3Y8GKFSdfEedk3ZFKHSPByhEuY1+1CEyqDkgxEqD/d4H6Hy0hEqjTJquxGhImWWB6g07tEA +FfAq+wCVfYDKPkBlswAVmZphgAq0nHmAStnW0wCVcsMAFXhXDQJUzPIAlXYUoNJOAlTa8HCASjkJ +ULFbHqDSdAEqIcZs8HJQeOrrZlocozIon6JUwtoolZBk1drMbTzFqZgUp6L3sk6LMlQlzA9VGRVn +sEqTYlU+gwfpPlbl/lgV7I7PEqvi45WCXaxK1On1sSpuk1gV8g2jWBVbTmJVmkmsilsTq9JOYlXC +rFgV83isymAeXyBWxUaFh9F0vetDRmxIISMhj1VhmRj4cX+oCux5Gqpi81CVKoaqlM3MdvtQlTqG +qtj14TUIVcFdKGtCVR7pcYxUqfeRKs8YqVKaYayKeTRWxY9iVfwoVqWaxKrYUaxK/XisCi9OeZpQ +lebxSJXEcW1LpIrRQBWfAlX8JGTEtClkxLSDQJUu8GNaNIapCGMVw1QihWCYipB/DVNZU3Bdm32Y +iothKn5dQYaplCGFqTTNIEzlgc6Og1RwUO2DVD5nkErTPmGQCtSXwyAV+ik+GqRiJkEq1ZwglTa8 +UJDKYBK3IUjFdOEazswOUvHN+tILg1Qebfv+IJVJ0VlBKvf1ex+k8qxBKlAkjoJU4GwyDFIxjwep +lKMglapdHqSC60aeOkjFLw5S8YMglXy+XiBIReTCJgapxGiRKgVuhEdjVGRdY9RHaaaFU4yKbL0Y +o1KbLkalbGOMip/XaheiYmKIyrpiDFAJa+NTHu5qik9p9vEp2xafon4898WnZG8/JT6leSg+JXu5 +j0/Z5fiU+1ApxacsRKb741PuQ6cYn7IQofbxKWvjU/72/feDsJTPe+mQ3pGKQAI4s9OlrAf5w4Qa +znvGwbZcVSjv4eGfAGe8ZhP3+vWfNMM6uufYjFpoCOLVgkyboXWg+UEzCRDvLERXum9SX7tKxuPB +9lqPVT/8+eQff/pWMOo3Zxe3Z7LA9s1vV1/zApwSqy4vs4UOMQsBpSejBi34yGiqAIJOABLCEcjp +CMfTqNXKwWREmyVdV9par31s4YMUPTwxTFwgWEYNTlXCRCTcFB3z0UBpeAjVdVCzWA== + + + BBUI4UHWgBP6zRh6TNMXpuK1grhhVeCVC3gcDuF4Mih4yXNZapcNlPrsJv8KfqvgVuAbEUoVJT2v +jsab0Kg+KkJwR15oYqcVltDk5MCm23gb3B7IVhtT0Ve71YyRo+4cTzp48hxXk2Fx3MobXOJr+Jd+ +QgBX6tK2XZcufX9+env2s94prZFEn51yQMmOMGjIF0j5dEVQgAKcSlcqOmBkhROWiXYP6Nu8Zbw6 +9zbQH2ox+VnhyjI5li+5I0TuoYtz60v1xqDvjwhTVV0pAK5ZK7gO4A4FOv6bBo3zW1mUS0hl3vmK +FKSpDaUlGXhJTQrb5NVjuPYSbvFNpEtWr2WgGCRn1yVjESgB4YI1CGa42beMz8yoCPsMKGR7yI13 +Np2dS2LpJPqkvT8O5WP8D0tHaXzG4iFqZLIsCly8MDj3J0sD4AaLI8WmyyPATRZIik2XCMDFi7Rm +tlATDox/cOK5Il+96ddk6VpAxWap6Q2wa3Mt4M0IDYBDmRKhSfgS+raSpgJvQ6NAeE+CI4V43YT4 +4ajKe4HvSF5Sx/+RX0oTorDyJJfNt5CxDRGqhg2Mllv1tE8g41UjCoAFFkJZ0vIYgMajwc2jNhxa +cqgwczpMAi+ONTzhKcLilnYoaqkUrIyeDMzShTMIOlzccguDMNyB4PKJrlHh4pILKLzKqrruIB5J +TC2XQfj7wIsxa17Y6UUcVA2p0yx16bJaXpNrmBjTtC5oBJSngwpvEW8YCiej4R4BVrYlYsREOFCF +sUwK8l6O5y0F4CU4OSn57uoAEXxUziaQYE/lfcycLyIXt02jSmvcZxr0LlfMDnOOCu+tcTo17wvV +6x81pyHszJqXHnOl5ZzevQrX3ZaRkbKbfI3trRf9wlsHDhwiNjloQY4P4LOjAR8OLnLgQKh6bqJD +elqI9Mxrz/krQWBdgz5evckNQ5dLvQzX0ifnGGY39S9sEOVTM0FMvAbHqNJa9k90Wa4Oq7pkIUtf +ParWNEZVXRChsfLIRcv7MPX+dRJI3q4e7zoBqHF6vWZpgrKsjuZFQULvbL8k41U7nqzjw/dFwjlU +lsTYdqZG47nveW9aYc58gzOgwT3vLZAFDgi4LHcL+aG709tVsRKR79ffRoYo3uE6k6yVQA3Z1ioh +wUmKhyfvkj45iHs+qBNoSRBMjLbiLb8iAlSRRS/pLwac9YaUuqQMXLc1Hta8X1PNtLFJh/ruzgmw +Rny1bGtT49SGstTDnQ4anLpqof0aa70sriVWp+Ei/oZeEpHIwpnTjlnWg/CwGFwt+5O2BActJVTK +rnSIaIGSRAgrFIhVvPy5EkagAaEUoVBE+BhbDeEI+u6rA/j1txoO6qjRPhFQU9FHsL+duok8CECl +Tp/ldVk02tUtrPCcUYfbo+CbYVmOAUowG8PIwetk4fVnGGYHpx6vZEB17fABDbw51tfUdGM9IIpx +IRBl2lR6Be/kfTGppJg2VEx7U0y7XKwZWLFm/MWaaSrWzGY22yd9NDj8IhCZcIW6vWFETEP/Gban +iXjl7KxZrcEwHMOYT7hvUhpQy0uJSzpPWyWq45eDssN617ScdW30MDvyW0O+B2P86s2apoRGDnoj +dCvvqjyOh4Ja+5EqZz3+ohhVUowbWTffg+6eHAxDu30TGT0QOjn1BTmEkCAIu41ZJGTbQUVb07Ul +YRrDZtrILJxAitJ4HNwaD+sOxmE9/RadhvzR0NOEaI+EmeuYSm7GgVCvYR1XzdC5pEAi+sCo/Joh +7r5z2j85gBMfyFBBL/tS9xC0CDR9nkDOqzUmuf8AAW5UxfTVINhOQz77xqjHxBVVWZ8YvYSQA1kQ +RiKdTGfq5AFlN4YsjBbvJiyaGm5f6nQMp8IJ3URocgNi7sGogf3zSFxSM14zNFXUEiPyVLAAbK4y +yD8gmlYYFmY/ht8aIlbWFa2DKlSCbaIR6Ohs41aP5rYKq1Kjdqwaeq2hWvs+XiSd9OXq7Obq/c3H +67erDz+fvj9fXd28zY/5h9Xia/BaFd0jzFbgCLcpgm6C3ap5H+E3iMUEw0V8nOD4V2/WYDm3co/n +FJknmC7QKa6TNEywPertR/iu0zDC+DWzeHK/Pn7B0mXqcfM8nOkTM5B9nqiPn8o+tvfzj+4h/pH+ +vGv4xyryj6P3j/KPruMf240ZSKMm0xaCIJg601gTyEB62Utr8vNQzeRT8ob4ECPhW4O0UK2DKJrn +5/lM2XkGHKSli8uQg7T0MBpwkDZyS8s5SEeeDQ5Y93KQ/nNwkH4WB5n3ZgkHORp/sWaaijWzOY+D +bNuFHKR7iIN0CzjIYctLOciHGMZhzfMYRvcow+g2YRjHXXmAYazLMcOIjbQRw4hIlqdiGOvWPMww +qj2+bZpZjOOwumWMo50wjvmMfWbGEa66ysK1SxlH7EuycH4W32h6vnGDRo9mNvribOMQuxezjctx +fCnbOETNe9jGtdj+IPs4rnY5+2jXsI9DzH9O9nE5M3dx9ss5+Lm/nb/dhJmDPa1RD3JYoZG8UyFF +/JvA6bmMNkF+072cfpV+nR2M340LZxXHn/AzD4DXCEODKQM44YyGwQsSlGWAt6bweGVd8suAUKcT +JPcx3jGDSfCqc6uER+iaiD+O+5HPYgqNIZmzrUcgDXiXsoJVqaRrA6jBhM7VwKp0uXR6KMgNEtmQ +XFuTn0xUi3VVCYWBHlOG3fldOZP/cFZknJbjC0HDpKhdTIkbYRXVzI1VWYcE0P8XCaqPpfq96rwz +VQDyv5Qwg2qIHlMjOKblag1NAIa+EYZLhEAsTLypcUAz3UFZka9FPE5qQv9qsses7divUTdLGmuG +fS0m3xSpzj6/o42InNJI6n85QKtmmveagUPpJd85mIlKytF0MIbnn4E9z8FfgrcE6p2heHbMyghI +ozl0CDGMybf6bPS5cd0jp5pZYmvmjQIp4pwZD0Sn07FjCioGaMce56PgX4bz2ZWO+TiOfRMFobPx +vHh40tTE/MC0ndGavGTikOl24dR99WY6effCHpxSdPfhSZ1kl2wzjnJPN2fRTURRKhvBcxp5wRhY +XFK2NWaNPcYHTRRLspkeCvJVQhad8mZ1o7zZKN2tdyVN/q1I2w1/mFAxk5awokokhUkDWpQIhEdc +SonQKIQr7cnmnmzuyebnJ5vNQBDHlgBPJPJHaOlGlEDZLVdg8qG5QQepD/MVP06AMxGUjUYPRwjS +A0JogBcOAkeYNYdByeGQWSAhAWris4LONqEF0888AqijWvWCBx81PsmRahGA/9NBJQcDkMg6fhur +98jBkNy2hokdKk0+5+AB65DJiVZPzQqsOZhcjJeME4FK0jkymKuHAhVAWp3MNTjSorK4ZxJRT/Bu +W8OaOi+iHnVjSCeOYMgKJMGofIxkgwz+tXrtZbB19E8REbxGAjteJYUU0PARWlPU+kpT14kcjrwF +etHNho0ezWxUFhe2eEjvliGdCwIS1uBlD1yEmRBsF+PmV2+WYqdSnrn4qWNZiqHRbW8hjo52vxkw +TYM1SGetJp3UU7FR58YG1BBekNC3Yk7o2WhwxJc1TyLIRnKgt3SIpMbKym/vmwEIX3kkSmpqZiRq +kfREqq4jANlwHXMquJhLF5pkqzfCBs1s3h52qUuZ9IlpVhi6HDRlI3Oz0MMKIKq0TwCKUdj4ylFr +26oPHd3+lC1j/uqaamWTniM7x0tFZQMjWpp8RQv3NF7pi0l3JQh3w9hpno2l0QzNTEp2ckAn2ADe +I3i1lCC6jWcE3QNPyIvAtZC8SKO8iObBBQRnECCW0d3ojw3Aw7qke96YPUm/7lUT+pp+OVJZy4Tv +dZClYUhVW64jUcCwmmcqPHeYAMUhMI43aSFGV9VuTlOXBeQ9YhLIH5gTVIRm3ZQBhsC1RasalzQj +CZuQS+6Yo7ONWz2a26pDdlAkfDKBl4ENaJQZJpVdw3ykLaO+yws3DajAZNtgk082DoDLt44wJpts +nq/erNk+BI43kADnbyHlZZZsIpYYbSOBjTcS+a/hVgJovJkIG20nwGZuqH61x5aNxt5HUscMHZMQ +05mzjjcm8LmCf6veFsBnWE8DWTymjMGG4KSVjJGvK6SmgwqYy/9UjPwI8iAVKWVXQUA0zIwHV1dk +1FyngyNilMhhIPsUmWGdHGgMbQ/0yOblPY2BWGmQJ7VpNfMsksgg0oeXtgN3xsVqS8ugFKsQQFQy +B+MmrR3NaS0wxyfzt1gk5FlGNqZoobBFiMG7OZaixpOKKoM94ZbtiWFdyARSqX6EKUc8TES4crOh +h/zT4Pw9GO4sMbyyUA9AA1JrDmLQz5K2mInCRI4sphylH16MRagMeDrEINAYQ+aYadcYLe9aGaWe +lEKgWpLThoEl64pWzf/P3nvnp5IkDYB7Ae6ADAKEK18FkhAeJCEL8hYnCWGF6Z6eP/a3F9jj7DX2 +GnuNTVPeF/Cm1a/55ps3qCorMjMyMlxGZIgXk1FQ/+Ux9ZHwTgh0GSVgbkkx2t/YK4uZLLqkEF74 +LkpKF71CISvgS1IpfO6upnnXRK6nGu9rvTIi1hAss8pDoHqjCWhBW/rN/RkQx8LaBhS6rIOAbg1O +vOwChlWQ8KLaquoRi2+egpdJo6Ja4lfw4mvcAP8NdHT9I3hGrfsqZoAbM3QOryvWjrCqH7Llbkri +3UQmSRjM408SKMoGJYoaZYWcNk/zOIQIFl1Ddz+Ibzhk2tJ4fEiDAyMmlYR9+C08X4YpJg7fgu3I +AItPm67vsd+c934pdAct0D+VvTSHNw+jQ1GFAGLoll8eX4GO4nSr6mcMvrQ4xsGUeB5XRSEoGIyp +LLn4JO8zPAKrp/8OgUZtRNDKA7H/vA8N0pYGfj7Z6jFtreck8d0T6OoJAuUC2tErzGpmHMmGR04R +LbVC6I5fAhmEWLyWWL10mvPcKQVzomhS8KTpGCkZPjPSsuapJ2oOvJrQc+B1IYoGn+lpGjzS0wx4 +ZKRr9UPXlA3jKAy0DVGxEHVjHOrHaqRwrdxjSVWJNpV4ghYrvCUaRuIN4F6XuxP3NqPgE11iz5H4 +on10jZRmurxxI/Py/tN9FTPAjWn7ZtAVBerRVX3av2x9srBSO3TBwTtkKJiHCdVlq42Mr8wkCHSn +L7xXT7c5SELA+1CgkDePptSbGeeXomsK7L9lOVyPQLWbF+g5571nMgmEHlRhlS2tWiNO3LH6J0hc +4KURn0C/ShIXN6OBReVXVgyKeobDwuKHEZB6iByO19NNI6afpwE5+dUSG7ooU3BccXg5BaxAoKU1 +dP8rRzl+DZk9LNqopTaPXecW6hqm5wMR4hyJt4i6TS2nbpN6dZsTDHoLJ+i4OxIwKu7OCQa9RfVI +0ltUX8UMcGOGziW9hdSrWqQ7dTsGHYcCiQLi8dVZJMx+tNNfYsBMZFh03QLSCWhOu6JQ/aChJUjT +SpUP1dfQa8hQjl8LFHaNaq/I8tp3bpG+oc5O8Byv1buVFeMkxsfjv7COLNat9EtqAg== + + + uhEIXqKOlAkGRaCSyK2a92n0C2jgVn0aHQQaphotRSIiXpD/1hCRoGJ56IYc6VHMADdm6Dwvmgvq +MUrqr3oiCDgr4Glq8OHA62h4ISwrkxiw3JM2JIYdxgS+jJpmTJgGr2I5PDTcddyOgfXQaMev4UVp +4snjEn3nFuobZrLDukUeTj21BCjqtjIJYrXWCxEi9VVPhuqHrglRMziJFKF6uRAxSvq+lhwlbdUt +QerCwXgrlyOGShrsacHEnhYMFohgsEAkHKjsafUj0Z7m9NYHpwKtPNDa07ZM/ufLJT2mf4U9rWXp +2EAF43JhT1t+6WxPO3VqbU9bfbmEPU2a2NNaWtY89UTNIs/R0rNoT3ulaNGeJo32NGm0p7V0rX7o +mrI1PEpvT3umbsmeJk3sadLJnl5QsWXhn69no+HFpDucdYcfsRh+jNRd9Qvf2Ri+EfCbi/4c/Hve +/Oq0Zj58waQ/N5lPP/2njWHjozMBqnG7Mwnbv/Pjl/lGv98FO3X82W2JLeujUT8BVOzxLO4//6MB +fhubAjUAgFC3Z23bmzRFIEr9xsyxPY3aX8H0Dm1bBMLkA97qA2NbPBGSNX4BFvR8eNGYfWpA5z8b +k9ZImSRohUCYNK13/jPzF7p/dAHC7YHWEYjGuDMBbLM2m4x6HTCwOF5zQCSaFV8x5VggBlCIGinw +T4gl+P8Egf+L/hJDkO1Gu1DnCvmhrin4H86Pilzgbslf0i2tmzIN/iNNWPWflfeLUQ13A+qW9bOS +xEz+6k5lHMNOSdQh4IV+GiOZ/AX98jok837eK5JXuQPM9iQYl7TTETEm/JJWg9uA5n4q4Zf+AzGV +8CN0kXFK1mwWRZ3FiOoaDqEbF0WYD+eXDUbF3axQBG9N8HPKuGDEDclzMIYI5kei25hgXCaP+B80 +G9CoCbej9kwFSfxGuop56kucDEd/DtEfQGYjuR72J87ANPxRXyIL5PkfHeltIi/mGJa6fTAz2B7Q +SHfoxw3wU6zpJsQmUaAsJG66026zjwAaIdRmjVZvKQhex5BrTLst5XO8yJik/Ofv79MOEGik9ffi +B0f9/hxdhjGaxBvjMUAaXhzwUUdEX0gD1F8FqPQX39/B2oHW9e4MgaNQP/3zidgYDNDulu7Q0XDa +hamd8l12he503G/8hf+EKZ8JDElcNTCRKx8gNp4gUSUtASb+oasceEbgNDl9gpTKB3P7BFQJjaRh +AuBd1ty9CBoYHYwkVuMThc67f8/v84dUwwljZOIbSvBzjBxpVlHfnh/N37/nAxhtTGYmK5brd4Zt +Dwtuh88EAqbgyp0TVZmc8rnF4G3mkR8N2/PuzM0c1FBWvgMg/a0InfL1M9fTTvGPzvC83UYkCbtQ +kOzpthexwIQq1cu01gSysWFdFuShQhfvwSA9GhavpTiLchPKOsoD/M1p8PeZki9R/E+nNYdDQC/Q +t2byDN7fxq2F2m8m1Nzyj7UwWgujlQsjMwmET4ZIeAiCDh85HhY5hLUm8G3Pawn0N0og6m+XQPxa +Av1mEuhqyVuYLYwqE6pcm1RrKfa/N6k832W+Fmj/8Cl5EmjCWqD9hgKNE2gBZddR4H9Z6ANMCiyN +735lGXiXArwhQPRgs/juGgLmjcCCc9Z+QmrtKFxLtR8h1ZICvkqPoXh0xyQLK92gKBSYQ51cewr/ +5WItuRZrv5lYW3sK19Lop3kKCVG8rIXNv1nYwPDJtbBZC5u1sFkLm18lbNzkHqyFzv9uSoakh79B +7NA/W+z864QGdLxRPAHL5qIb8tB5EckzDKOJz+N5imVwTWmCRp44HkbzsT/rKGlBjv278FtSwJeO +E7AMCLprEnNeljUp3uWR8f4+PNgTu2LW7OrHsaulqset2dWPYVfinQkELdDw2AdxK3jlKMeYXd+x +5ldu+BW75lc/jl+t1avfg19J6hW8359U1CuaR0X/1vxqEX71w4Pj/3X86qf4EP+5rEZh6pY/8H9Q +2SVPfGnNTRy4yQ8PdP7XcZO1tfYjWNKq45hIHJ4LWFlSQLXtWD7JELgkKCEkV5Dy+C/lX+u41jUH +dMcB1+nv66PdHyYNkgxOQ6J4Hl4siG7iTVKsyeWU6zPff/iUPAm1dVTr7ybUfoqT4B+2a9bS6Nfm +v1MCTTOoDCy8T14AihUqg8esQ13/3fnvHPGzJdC/Tn6s3UL/TNbrZAjQ2A4geVhyDJb2oEjsFGIo +hluHIC3IvdaB+r8b/1vrz2v9+QfqzzSV5GFuvT/Gc0DmwqCGOE8wtEl14bX+/G/Sn6m1BPrNJND6 +WOJH8JO1IPvFxxKoVAzJMAy6OoaEZWaQPUIK/PL2yO9Chb/PlDxJtR+eibaWamu7ai2O/jniyOa2 +DTFOnBLWN/H+yy2pH55OuJY5P8aSWl/FuxZcP8eOAu/jDAOoGdtPHEVx67s8/uX20w9PNV3LsrX9 +tBZD/xwxZGU/xSmOAAqWX7ofgOVYml0bUv9yQ+qHZ/qthc9a+KyFzz9e+MCgCGDBc6xfduKxyeQ6 +o+VfLnx+eJrmv050QB+cwPKEAI95OVbgSRh/yhEEj3xvnMBTqNg1Aa/UgU9IpXgIwxM/rsjwvyik +2LT4E44j5gQCR6Pha8EohiGW9zn9PkzYE8da5+D9jjyPY1mS4dDFYjyslW525QwNC6onMV/EFdYF +VARwXTBprXf//ezf6eyBJHFmX5JhSAH+YgiWZXBSCZlkuHVo8r9bsPE/PLVvLdgWO1BnaCIJhVaS +FTge/SAFloFaPcHQWIzxAkOT8AcJdXlK0erXgm0t2H66YOPEm0TpJJdEN2gxAkkRqJO4wJDkusLt +v1yurZM+fze5tj7fWIujH+Vmw+cbDA2UaHS6zlJxgiKARRWnyCS1tqz+3Ycc/Drpcy2B1hJoLYF+ +oQRiOHjQQwoEmUTlFDghTiYFeECXJNYC6O8VQOTfXyuQX2dorkXQWgStRdAvF0EEyfE0XDqKjzO8 +QKKiicT6dGktgn54wuZagKzrE/0dbJOmENtkKUFAsbEMB+9ZQXXrYBges47TWozdrHPqfjeGhWJT +KZ5Gyd8MwUA9Iw5zwFFQlhSmhRLDgRUMRR6PI7Z+WEzqP2zXrTXm/0V4Fre+YusH689/vzj74dU9 +1+Jsfd3JP2jrrWXa/+gSexiZJTAsoGQYe8wSjBRxTNIruMb+d6HC32dKnmTaD888/1dKpHXy3z+S +Fdsk//ECyULPEs79A0YFsa4fsiDD+qXZyqbs5grC9OdHk2FnMl0Vu9EBlVmM7VoA/nPVaQDaheQ1 +n1ptwZWzXZHduf7eI5/8RW7x35c7LYifNUfRcpTJpPGXvzKadP87Gs7AtnoK8ZR/PHsK/6N0ovXm +/LdvTix16pPGcPo+mgxWJaJUAN2JJxk/M+nLi8YMjGGIJBUhCa/B6I/OzevFTHqKv5l03vtA277T +PmwM26NB978ds6b38CHjTxwBPSs07g4vRt3hDD5Lis+G80F+NO52UEc8pe6/oupfFKmjWWPWeb0C +krWBB0wS8stpq9GHY+5MWh3chzwY9KraHXZMwRU6H5MOfkXqgJUaLYB9s44q6o5I3Svls9/PGHfF +tssAoUM12y6LyraKa9e6g3Ff5tpe1Hmsx+M+FMDwO3RjkoXWLhoBYCaABK2HfjQE2p6/3B/96WeB +oFmLmbWY+ceJGYWG7eVMYTIa1z4b7dGf8UbXXMCoQbk2gBBnb/aHCCdEnGcl/jgaN1rwmfyg2Z9P +zE17k4tF9D/wf+4aXv0ACqY/Wv2JyMDRmD9mf43/xWz7ojvs+XOdPzr9f7EBz/6vDPhfhEnROwrU +us9V4VED0hsX+BrO0I7iZRbwPp2JSqGo6vW7A5d77u9wMSpch2NpAh85UklezYVgLr3o6eV4hl2O +Jf2cs5xfkhBoOY+17rI+KkV6PbTTGhO1Yh8nKHjVmJ+kWbjpaJgvzLOrvxMVM8TS/L///ct/2pj2 +VsU+Sx3AOCG+3bFOUrY0r2wl0D9bIfmFlL6Wgz92K0MbnUG7mLI01BcyhH6fjeFKU8dW29o5sRbw +P0U7/oVW+mJyHDo3/NI+WdILooHl0oyUpXi7MempnQyt6QQ5Qag4yUlt/uhMJE8yRvy40UWeiZi6 +1edo8l+LdaBYBgY/UgKHgyHxCsC/eosjfqpzj9i5dDhgBOm9OmuWrWLZj+BpY96fPdv7wL3tKBSK +BCOPWLTqSQ7dYcgLSXhlqTxTLxGw5k7yQPYo+VoctrOTGRrtFD5h4ZPXs9HwYgJad4cfsRh+nOuA +/XPR6Hdmsw7isBdNN+MMPV6BD5ESBjD5HEaLdfdfn/6576LlDU+h28/urCN+54yuBiRAIOv0HSUZ +jqVhZHGS5kma1rgAxO+uyjn/VactfZmkk0nNJclJmqFguoJ6iMqX950+dLTijzmW50mtm0HO3VF/ +hM5BxG9YnkgyvLpDkmZYitF+S8rf5v9qSJ8KAo28GjxPkPB2JiNa8XKIX+b6cwmhNPg/UkB4JOgk +ZboQ6k9PGx9AGWyIX5M8xWOkMmRSQOvCsvgHwXECQh/PcpivKYF0PMfwIsgDGABePqCT/twBwxoX +jaTxcgsCvOIDvWIoHl3wLl3jCUPF0cWeDAkgi2ApmgdgKQGApTk9WJ4DmE0isIDzateYYQE8mJsi +j1YDFjwqHyQJU7AsyZIUvn2UZJKaZUhy8Bpt2AbPHYBFWJDBwtGS4F8Al9DDpXmG5SE4gUxymjyw +eFK61ZRL4ltR4hQNUEZLcFk4XDj83AGblODyFE1pRiewPMtQWrjQKYZoHv6fcm2qBJeC2KURemkR +LoBKaAYHsctx2o4wcgVeFHJaqCRaM0DxKqgsxesYhMAlMS4VxDNJAieTisilcD6BSGEMAZGQhIPl +JLCAcHU7RWDBJtKMlqIgEUC4EolRGMsYLovWTAC2zwHPSBuR5lD6ApgXjfAnJEmKw1s4SaOL0yAN +SAKfh+kOIjg0SAauFCetlMDTAhokDXYBHBronkduTIomaAEnAjIEj/MrYB6gwKmhERCTrLSreIaj +Uf6F4hTlWZ7RTJmUllueMt4PGChgftKMSVIGCxGJZggYCcpIZGiK5VQcFo6Sw7fIgx+GUXJw75Ms +L8EjBB5RDVg3gjdlZkCrgpNGM0AYhLQGOmBFsAymejhOipK2KaA9Cgbmg23KYPSbMMk4w8D9AxFA +g1Vi1eMkaThOQRDhJcFPfPkQCdaWMR+nxFTJJFgdXll7cZwcgMug6TPSMJMcSVBInsEK4AKNv6Y5 +AqFETo+RNhCNAYsbCO0fyJzAkCR00hyNZEgSsGrC/NJ/RmHKME0HsSpx7xBwo4OFg0Nk5S0JCAlB +ZFmCNYWosDmJjbJ4yaQtyUtMn2SkLUmDfnGxpDigbhbtaAIgAC802Hfi9qHFOGwMiRUAJDjlpASH +JACD4DDTRcHdQDbRPF5wyLLgLkU8Uo1G8S5okQ9REh6TBmacJJMMXhSAVl7LjGWRhA== + + + eTvoWTpRkCUSjVaHIiWeyQF2R6EZUwSiO6B0EKyGmmTJzOGcKPBDlp1JROgC2kDS/Bka8B4B0TIH +WD38kQQ8EwtlJom6g+hhRS7E4EoPEj6hOIZZmXCPS3sSllBE68FC/oY2Ec9gZkLBZSNlRgGXURQd +tFpwwjuKgeCEKy5IUAFFMCQcCSBuxBoIQMwcZiAcUiJomVGK60RhVo9hCnCoaJdzEmlSrECRaMoE +B3gxHGhSQDggSEBIglpIcHB4sBeGUi0TlBMAASyHdpHEiWmWFJPYgIIl5gnwPNqRNN4MnDh9BjMi +uZKGCJWDW51Eok2gJKBJjkW7GbRjEXQ+yaNBA5qg0TQkyUZLcl6USWrJhgSbzD7Bl3g94GYSOMyf +OJ7BQATE3BmptgclURSpXStIqUhpkJUcBrBDxNO5JA20Pj/Wd5KifiKJXXGTgn2lIDQJZ47RKWGT +Ado7gRUxeHM7HCPgKWjPAt0cr7M4Qvm2dgIzZgwTYZNG/BjvJEOiVm30PvMjQ8B/0/0YQmMmLDaw +cl2afiMCBxBLjXbHPxv5sTniBEvbWoFi6lW1gaNvr0AyC6GyAaRrboo0aBf4UYBe3z1g048g+FDt +e96YdKb+7PCjD8wqDRj8n0cVzGf/2PAJIhe4+JhPQTPzIntWPz8r+gEPZf15CPQ/Pv1D6TPcmfIW +gDF8gZ5JH1AcImzwPyqQZt3IvYCtynGkRqzygHK1glZA4gVpKeJRM41vb5DkDY30XihlAVORZAPB +ESRiD0CTFChzYzkpMkhe5BOCSlsDjADpvUgNIlVwZf0W6G1IULCAZ2lHDCxfQjY5CMzX0NAl/Z9B +EhIJcMBeJdAMT1E0BsQzjLmywUqCQsBsF8pptWpAQ5lGkWjUYMlJeXGwPaJZUMAQDGuDnkmqaZJH +PVACkCxWKp+sjguKaipBo5LyUpNwyzX+QvEtFx9ufRFYd4RCX1bIOAbroTwJFGck/jgOKPFoAECX +ZpFUES/30P8Q0Q8XloIsVdZueaCW4Ew2hqYJLE0ZAotqYNcgbYSS/ysaMFBNZiGiWWkBOTAAtG4s +sN0Q3wXLBZgz4vIktuZoaUz6Hxgqj4QHj2hZggr0daQqsxSJNwIDrC00JiBuSayjyP9Va57wXyiH +JZEJRoPWkQEqDSI0oECA3YFUG1HeS4PS/xDBUki8I8cA+FeiW47F91EQPJLuNJCQHCYTgBFGVJg4 +teqF9SSW1qheNAPoTEAKC9i9yChjSVZtCgHzRrq3RfdDhMtjlQ7tLF4SmBR0RSErnOf4JPahkLgD +hcnI/xWJhMB7FKoc4F9JOSaBVoC+E9gk9iUIQPvS6rHSyPQ/JL5CIOMfEjWleCtYAbclGIrAGhew +37QOgaTIpbT/K7lAkNLNUGjfU9KWu+00/flRfwRF4Gg+ljcfrGVGYn8Hxwjm1hcl3SogG58aTsPR +svVJKbYNDzQxLV45vKSKtSQpo7yk6VJiiTSRwrD1gPRSXs9zWYrCGjgw7Vhe40y0dA6xrI1zKCkq +YQIBCILSwgMmK+Bt8IfaisfwKDhv2jA+T3FSyuAotA94WbOV7FTAMgScRQt2hNa5yWOVUyRatdeK +FJIK5ZIY5kVOdlpLvmnFW612Y/vOxtjhjd5ILu9qdzpTe/HtotzlA1pNTKUxuNw2wcngdEcjcPS7 +m8yEJPCr2l+D5qgPwfwfvlBlNABaZajS6Y/B/+Qa014HDRzoiq3PMFQ//wCjgppn6KpWg03mfYA1 +f8x/1f34nKkfFEZ/DtV/VzvvmvfXY/VfOaAd/9mYtNXPSqOJ+Oh80gR/n08aww/YdW0GVFfV37n5 +bDYaAmIyPqPUz+qNprYRfKBpgTvCfmww/fZHB30A10t+oPkAP6LBI9HlDgbXbfU6cHzI5y8NFsr4 +sIh3sFJqrFuvnkhthVFrPgAkVGjMGr7Aa0L6259Cf6nOueDfd6fVs1G7Y/pyzx/6z6A/BK9jjdls +0m3OZzjJBTTFVPe/ALEC+KpWrc9uvz0BuEdtpNga6S38Z/bXuIPfhnaG09c/GpPpniq5X930jwZc +e9wWPp9atIPp4riZOJKp5q9/KHaGo2HHBWL6I0DhbTeYkVpG/955NbvDNhgo6WJugDhqndkZmoTz +/NStV7T8S2KCtMWEq/l3G81+xw3hO67qP2mjp/5wvdVh07+ZouH0WvPpbDT4eznZr6PD1LQB4yCg +zANbzC05/vJ9UYM31/yYofwOu3T6/ucPlsZ/8zaY9rutfzovjgmkEhpmubyulvbv5rtwKpzTVP5y +M5W//u6pkBwt0E5T+bPbRmHtjtMRG/4DpvTZQZaqizlJLf/mSUnRn1YTao6ApTuA5vX5pAusRTdT +M37zA0Q+4nW10XzS6uRgEPRK2N4/2iAjTN6qMTZrTD46M6AHQJfB9KjgZumN3/zNquzFWZliSqPJ +oGG1K9VTfu/2O7aNNZNVt/7Hm+eEEyd4R4HQ7ixzpe3fu/yOk+oOwTj7jZa7aalb/3C+jS7bGTcA +uJYrjUHb/m/etFsl9H8uNuwAXiWEjlrcTFLd+ocT5nB06mlq2vY/QN46M97/mUmrFUp/92hG41l3 +0P0vyiz4KWMCVvLfPYRBZ9ZoN2aNZceRXHIcW23x/MPNrlM1Rh/jk0KC8Es/VEBqN+XXm27nz9zo +P3f3YvvH0067Ox/4rzrTUX8u5qDIX2SPSNIvH8cAWpmP/aU+3ObwTO9i0oGpwYp7mGNZmhVnnz1K ++huTWXPUmLT9LXQUTfqb8ixl9oO6kCbh74JRNGYd0LCDXNq2jXvDUas3ms/8H/iMGxGBkoMGR3Da +mX76rxpTIDVFglfNFH/BUgwlWA+a8n+gky93bWWNgyY04zifz8ZgoPYjoVSQ1dIQjKDb9k/F6+Zc +jEJBs+OKqCbn2FaeHKlZD0QGkz86/nrnPzN/sd2dNZrdfncmSnGSkWEaianaGH7MGx8d/8VoLC2h +XgzyEl7a424cN5FAgpFNdCQyQJcYaB41+t2p7tF0PBJ3DC37O8aNdlveV9kjf3Y+G8krZiTbpH/c +GINdMO0O5v2Gsoryuuf6nU4b2qA3yuYmLfGrtYjyk9E4O+k0cIqzQWaGlFhAUr/h/TRl/EXEw+gz +HUsQJyv3BjvQ+BrEwUqrlm8M/2hMazI61IRA+N9lzgA2Zb877PinKLF4at94LNHP6I/OZAwPiKfa +VYbIErkOHPTlvAGpy1/FlzbpGYTZOGaAMnFLXqFwTcsJWufYHx14i6G/2eg3hi2HSbb63TFYO+jF +/w/YGx+AAsSBh0gmDpZDxUh72aPSvN+X8HjTmUyh8J1NDF3USrf+PIRcH/mzIoWY7wv934QWSKV+ +WvVfTzv+owHcYNkpCkKArHLY1hOj3F5pIoYP1eB1kRJJ8DysmuX8lV7SmTfF48IXS8i7zqyhoqOY +oYExjkf6wF8bA1NpMgXonnVbjb6erCw/UGJTDPRl/AbgOF+rafevKWyURKo210k7sEfDVn/eBvr0 +AFKMnoGZfVEewfIAMMcesKNmv+NiSHi6xcF49le+0+9PLQlD/qReuIW+0IrKeWjXA1rk08a4LitA +lIvW1VFLxVH1K67fLaPxXwba1iFKRKb/7vTCHKauPUpWxpj0n+Jkb0O/6jbXw+5/TDtWN7rtDtuj +P6c6ale16Krlpn6ESQ3eao0/4NaCCfsKhNEQUopfw59dfeOHy+MnxAUiPH1Fmi2r00eUOD63k8Jf +0aKi4ukjRhwf4+krdqGvuIW+4sWvvKFQ0NGRDUWYE5QOjdA77URPhLtP8ADNl9j+myeCkOhJ8Pgd +ZY57x+/oBb+zoCvH71j9ulki3pTrKBK9Nm++j/rtzkTyJMKn07Be7Ooaq8w1LXcozMdgJND4UsaS +63wCqlL5c3BT1ECkN61w3jPl67p3ahtA9V7HOYv/GY8mM6gGqaWrSrXOoUMelXJtUJA0TqZap19p +zEDfULj04fSmKn3Xou0R9LceFdQt1a/rME4B9mo2PhQyqhqe9m19NFa9k8+Py/0RUD6vOuN5fyoL +wD34Vr7cQzdR/d0fioID7H2kcxhlL3hTHLZGJhY2eAPNuPOhopep36FrZhDuoOYgWlAKUGAKtrrK +uEnlTQloU3Wj8xiCBGbWSWcyNBsI0K1l9VM99kEToBdp7KYdAWKfYtIybKGkfzhSDA1/d4g0+NG0 +K3Xj7BGh/MA4tPGCqO0F1Bap83nRULhSGwpqawQ1xZNK3GAzJKcxQ9SeDdxair32N4CWjF0dOpeC +xg2BP4KpcdCyQB8hk13/kRunUPGi5hYHuLE1Eoxtz0WzraY2H9W4ws1skKWdN27uPHEtivFXzjh2 +2I1y+Lz/ttNM3HTbnVHidAQ0vQ5EKlAcwT7sSLhNKI7yRGvUh+UEAGQjy1a3m8768TbuAhG1LBDs +wcPPxPaKR9HNN+P2ALzuD10Patx2DRzH/MlfkPL1SuqG4/EkjoRdvA+D7l21nI1E7xLL8/YtJ4ph +IxCkfVscZ6Bj75o1hG3/HIkV4eybfeqaGXD6NWoCnE67H8OG0Wmob4iWtinGGdhBRA1H8CTZRbvG +tNmdDRpj+6a4zUS3T8xat/qTeGs0hFeBQZeczVBhS5lvN9FVRXj+vGnrSTsObHh4547DAEDDd8Ca +pGvGkCg2bYWEhNHLZ+j1D3hAO45/umz3h/XYxh+DXrwzhDqGux2EPsBbSFlPN9+ARZvBC97EscQp +1pTuYVOwqSFvVgVEWQ59DLZId/g+cmg2UV105dAUeUqbjcnUBrmoYROqWGA/qTiEi8Yyk3DRdqLx +fzi1VjMKzrL5oDHpTbWjdtFYHrWLtqpRu2itHrUZk9fOcT7tAJUYKbc2+/h9OIu3++PJ+2hot93H +0zhUzAAPmdqTxTQOeCZ0yg5BU5XwN7T8zzg+0bMkJPDNWn64YV6gnci7FP+yGZqUdtgfbg1x0p5M +tTveVAChZpIjejq17rk1iEve9dbgr54NG1QajvC9zVoPrqF3zGVse4ZagsiCruO1uB/npAJ9vu1/ +CtVuzy+ewv4/KAcdCI5LJZzMpB1oA7WY7tBGdEL56jRk2EZUWURJkDRng1CkK+xPYCirVuoIyxDQ +AgHfbPubf/kLk+4f6G5sO74MvldULBvlQsOIrVQLE2+toRE6cnQlM6CM14zNVFor628tBCcfzoIS +tBGFpKoglb4VqkIlwXJsZyN0caNxXwpCMiVu1KY1nNqhFLSZdftqC9ucf06lazZt2iAe6yQbJ5Ic +MBsyZruaJTFtMwWms3Qyas5u+5pjN7MWzS60hWybDDsfDeVk01IAAMV0aN+mT7aQ69xg9umFxGej +3ZmojiJNW2nlCG+mCgJmrj8dNGX4/a6NkgwajMYtG8UINZjaTB01aM9tDXabHQw+t9/AWMTMhy1X +DAG1bgyHIyUOVQwNgE6WrNTQr7jKPEcFkOr2yEmgOy02uF1MvQiEVau6LMId7HlzoQ== + + + iCwkMGScOG1JGYoh1e/bt5r2umNg5gxthDZsNgG7cTLtwOFN3HUrhR24Z/XSF6q5WQ0H+ixkj52W +Co5HzSNgDKhpQOf80q8oYekYUhZLvPj6olASnVDQloEBbqPhVO+2AyPwn+NXKleV2u3c+KNzCsR/ +d9zvZLVocnTyqGop+FW3Hq/AvwNnD+b3ClPs84pOLIZB2H7nJibD7DsK9neBFS90dAo7vBj1u5JU +NDUepIHikhGlyWgAkPjnaNKrS5KJsZne6Wg4an2CjzqqSZ50h+5MX2nQONAKuu2HM3EC7rArRTFl +gRxtNmbVxl8dycyEV0zZLwu8DALnc6LTlmxz9IeLLlGshNWK2neKPrXu1dvyXCnKoblBZD5Vg9vY +ywrBAgLInXLUBivVfe9K7IvzgDCFOlzQv3W4DmM7aUiX1pj2LnoluEpEE2ZcjmRKqVAArUn9nlR5 +r7VfugqD9EYyVcXxajNYi82oHrSpjuU+Nsvc1DeyFGuq9TbvnINHxK5nhVot1FTXgaL2u1THGwwf +u2CCKmEG4zkBjeYbYxzV2XUQHQyEI/mBrJUFpUd0AnHaAFJCSb9wx0kKnSkYWsO9BJVYR3ZiT7wm +zG5BQSSzOReYAIzlSPGWWvhgpdb1SXcAkXarsuwdZY3ZdOyGdNX5gH1MnTmzTjdxZMzoIxwg21Wp +uNbzVU7UnYddApvnttOEoe7OPEpFRGq+5DyYup25LeMFMjCgENc/54PmsNGVIuxC9U+w0/yNScc/ +++z4RbeTfyoFwv352Rn6pzjCojFUF+ryQy7qb0zhY0X3lWLi4yg+ZIaAa4H9NZr7x4Bz+gE/6eA9 +jbrG4D5gFZ6upqOoH3QmfzoEM4YXs45h8pm/i07OG/5+4y8Yf98Y49ARyKum89YnHN7RsICOqhQw +uLchQOocjG70rnTfnfrnwx6sHBJ3vfNbk+7YcWOhxgAjiMvUVd4YuzWTzRAXlIZlVN2QuubIn3Py +IQbFOm0sMPCOMQbLbKpgIOOxiu06kLBKitvKURxPASMrruAiW7uH1IxWF85oB19iZi6MktqsMWzL +IdEuebFYSuWvM1uXh2PsuDNC1eqB/boiItAuLDCXwRusDOZl29CV+Wk2HcBX+9MZsMjncnLQ//d/ +/z+z//f/sseZ+BnYX++Tb60dfzTs+eGVbioTnueTSkygzsRWZpbIdaWRZ2v5oyOBLXRg//Alc3i+ +8xjZvz0I7jXuosf0znksl5mUB5+pj+HGcWkjGgrmu434dJu7rhS5rVTmupw+ZQ5T1afgaWYyb/Gl +InUqBEiG2SKIaeGr8BEltjN7L/HdzH50PM1MT6iEL5DZq25MpEbHs9xH5bKa2Wc6tXz3IN0qxOPB +D0NX1fY96I8vlAIp/qE8K3w955iHWDQ7GFWn2aPa7DOS5rbmpQKzfZv76gdvfYHCO3HcNAW2zSff ++ZvLx6dsPR+/se5U3S71nNnvlZ4zqWl8EClEA/NSqNx+9wUQskpvQMMovD/f8rl+pn+Xes99zvKf +/AOpQcfbTqFFVr8z+4fBWwwHDHmaf/l4GYFfO9+Fo/bRRi4mfG1na7GtIR7DXaM99wWSX6FIq9hi +L0P5T+Z1bz8boHciubPoWySTD16X8p35bvrmeOtzr9Vq9OCvbqT4Xv3EPZNEosFPuttvqe7LcTvX +DxwGY5PI0zxbre18w/GHM3vHn7QvwO3dPGeyw1ZwEDk43Uvwg6eDLs8npu90dtI6IiO9FClDbBWO +pzcAbXyww9/SRDvVzScaYH3J04NQLNrJ9fmLAZ7BfTWQyR/tb90Wo0l2Ctbl6JHbSvP50Utk/6b9 +mKKaW88IbHoYABNKc7tbcEkeuVvucgjxlM71wlxMJM2bdpUgn7dOC4nG/k5pI/Iwgb1w8MULgoKa ++AJEc/OIQb8j6dK++Gv/tniCm+ejxTcMjLqnjgDp3hGRdLoYpQqHHwcinNuD/b3219kLWkl5wADe +eY4VewGNcsfyAJ6VAZChgyvYqMOgZ+xGrvCKUA2E5SHDPXBfrWy98BUpvCdOvouNRnA7xzWvL/cr +hdd0tv7ZmmUvtlun2TpFg9XP8s/3W+Cb9kPx7u1wLqMIU62GTF96CjChH59UpAW7HxXea8U2wicA +2whH0lt7t3iFIGRfoPhKRm5yzN1xKTOZfF4zqdPbQ7RCAtudcGDxdqOR3Cj5okelduJqvEt4wgsL +QfkCe5GDeahU6JM54phNgX/KRBfDSXPNUWavPtvM1o9ncyMqdSupwru08HeTDfisDvjYd7yb1eNp +fpXslEI743D+k7t6KDaJ/d1CZzKJEp2Lgz15IBgdMjKq5ezrMYmobT/2VoI79SReOPriG3jv4wUV +at+Dk+z5S+60lH8/FgjypNku5duDe8Q8TdagnOtzB7cKbG5WPXjIVepbB7ox+AJgFJ3zQrkX6ICu +Lvchh6GJ99TtyDhafbsW+BWdlcebzWQyssec6TCydzQdvee70y4HuWXs8YIKbx1VlFntdVI7A7CT +r8KQvE4jB8cPx1KnH0+Aj9HgbaC6W569tgfZ2ttxIdE9CJUwgPdghcvWT0cfmZv6UaNUFC7vfIH9 +CFF8ktExLkZHZ1Rph0vdgTWfJ4ut3veO1AHaIP0GZsw7j8EqYI8HwexVf7yrbnfZqAD2F2T4q8/d +ePbkvjb0BVQsXHr/mqnzO+f56ned1IiM3Z3Cezb4opEBV6XSa3jjE00D8NxhB2wptql7K64+fN/T +SBrV17tAiJZHxWi9dQCweHkLNvbddiR9wNHobbYWzQzz3e5lG05tAzapF05OKrHSfpENo7dwLh+7 +Q9y8fpoJ5PrHRByu1aOyP3nhsLvLZG6aCf6icnpFNl+us/TOxnaRCm+/5MlyvpqBv9KAxMkDotNM +HZLRUP5Qfpb2BbTf4JboGfwzB5liHn2I/uRqVeoSvj1AX8sd5OGzHAaV3Y+VeDZWuKJeH8ZF2GQf +8GTYHD4oyF3lYKMzBQ7uBfanBZGRB5+Wv9hDTeBoLtCQ0BjAXACcLB4KnCaeMBwUxE4dPttDwJRe +EAg9iuCQzTpFf4oYgxBrWmSib/bgWzSNQwWVuDEcHMbi8GPvUkZBDeFT7mVfNRdl8dK2S+t6IXTL +4AvoFgJ/A5GlwEbTQHjSouMAzUr5E4GSey4rY/AFtGuZNiM52yXBQ0a/5FnhTpU/MY2ZEoYLsoCN +q/KsFFLR0yyeiyWyDvBM0c6R0HGgzBk2PjdDqm6n+gIyCg9005RxktKCONSOJq98i97qOhXXRdl3 +KorRrGpaoVrUGGIia7JV9uQRXsjMAxMpnksJ4RGBdYtq1Rhs6QWhHKw+xKMMO23GANHU5K3pjQzR +gmCM7csdoDFecQIZPke/MPrlmfLcTfwdMPAvWpR7yewwe/X+cQLUypOxTmBk6zcnw1KGJHu+QDlQ +fgU4YUOcSjeZXwb2S6+z+m5mj7jYiBRv7iqSKIttq9QJlVagt5LU7QAlQ8MAqy9ABEdUphmZBAbL +SY4LAtUv/GhpTfF7D9VSlu5tHyM7QDuhCDIQfAFhdEzwxVj0nSmcHH4z6l5yr53s1bB2na3NjgbF +SDUR0r7tlzLJwFgyKq7CivGFOzh6rH9nz/O5C6jDiNrVQIMYYIFCLUw7U5Wywe+1rq+y/NPxVeF4 +svtmBiDLVp6Psie3l0BPFkd2HeiVp+ediaj6VbkcENtPcdl2iNvbDvaWA9QuJNsBAuP56+fOSeH9 +clpLdC8egdpc/M5jfZumNh/tjSFLU8gXUBtDCoXCqWEL+y57Xip83b7mu19cYu99EPgA+u0uCXCS +fuP5q/YIDi6m6EeiGlvrPyugACWLwH4ny4Lblf0B6cJHLHyIO7ik029AUTsP5j8j9/lEN32QEtdK +iyeNLdIDZB8vKYYw4GPqNbioIPSDTukt6DyoYpoXiVM1ECujYieN6VzZABeVPrAsFP1fq/2rBprs +dU7yYELtSOntNZ0slO/5d2COFymCKjOnerCXG+EnnZGCaawodft2WXi/jpQBny4VqHC7iHcgslSh +DEhixvWyv9Oz2ld86eV5d6tUHM7fqEByIIirvx/dTjwKfKt6nLu8yIC53A/ORAN/fh/IXp7VbkqF +cFt6oRD7aIfge/PmBVE9aY4VG1nvc6AeemBd8p9PG6lIuvz6KlHWcxysYPwk1zuNANX+4l3Zsyno +aXnJ9aiDDeWF7AggUu1Bn4BC5Axi+0HxdgCLz6TvVfeMNaUz9dYdxy8jhzeNb6mDOp/ZO7nfBObj +54YW9nm2Vm5/gXU5mFCZ640kWgO0AgehOdWBJPeOXgA+dvg5naNFTl4Cpgp6eWkAEPVp8XVMNjN7 +18G4yklGsf3Nvff5xVe2ft24Bx2k+kTpKUOD0VRiMnfWOzB8gWS/NHq3ohhSblmXdq8amMvdS6s9 +ivb7l6C47E6hyXRqjrtXNRC4ez8AJZfCF/29UoF9oCLp++ddI0QXVr4KbFW1e3PV10+ET7Auae54 +XohftWOZ1NlXTxZRdW6zNMyLrkFAfLHx96hbSNztZSR8BjuJz87LG8TnVBxcuXAgctDbAxaKeSo3 +OE8DKaZRPM6Y3PmcfgCovpoWI7vcu0piKXQHSYnb3voWMqnb7+7ee6X5kUndldSgMMfGtnuy6Qsg +ib0fvecqCLZKdostiRCw02ctsH4Pe4XO+LyK1Aluq8pswWdU4aR+uql0z9/0q3Ug6A63i6/E8Lnw +Xi+8+wLF6Oh0nmUz2cdi66If1qlLomfyI9ADDDW5yU8TZzfZejUDt2EyZhz8figziSXn2YurxHOq ++yK8gxW/3QXrolJvsDg6SACKqe4CBeXpuvS695nQd0qlvwdgkT82Mt+HrY7yAq7VPCs0xx9xsnIT +FZ+BJQb6WH37O1YKjZJh3SuyWT2iFBCyfIVDPovl+gPiHdBL74FLp87vM3vjJGmcmtgOrgtoyQuX +o13LRqhJqt1ufhubPMQKRPIhWMp3uF62XmiQub6wJRBU9LubSZ1f9tGCqTiMgYrQ+cRB6+4RbJrC +afaqnvk20sbWNN89OJ1mUqVAgzvk7sr5s/zNoawdcqJ84fe7rcfCUevqIsfcUjPDwr9sbQDhQVyW +QseH1WTlqTQTlWBxEeOA0E64vZPt7HvhY+uZ4VPjeB6oQ91dBRTS+iCw984IEt3jfng78Aqpe7/Y +TDyMtZo3HplQ39mulV63dmpgfpGn4svXrIV8kEZ8lmfFZm435AukTiP0Y7Ze39nQEMvhkQy2Knqp +RLKoYiYs/flkQSCVrVI++wxUxMzRHeBjhWidlX2GeLTJXrZYz/LJq48k85YbgEnmCMsmUBA0oKkU +jg2jdVk9A1ZY/eawl9lPj2+BrOwPiR0TEJ1cLzg7zjH3m9eVgycm6GqmopqngRKKP8FeekdnwPwo +jtT7jsuMoDQ8hr5OMF2W3gImwkNSAZEihY2zUvj+YpY9uSfbqk4PTs7ahfYgGVWfWQ== + + + gJGFAJc/730o/Bcz4dHbJ6vaqfLpBWa4kbPRV+E9edwvNHe7gWT1bbJfyvaHm8gdqqMXsPrwKC91 +lk88FU5O9hNYVaMua7FSkXwPlVLZq01pQW9DgPPXE9xBKZvOcYExWzhq9AMG/tO/CAPcPF9BXhov +nBxt5gG31G6g/ej84r6UIWavYM2HzdLGbpQEJuw1/CZJgZ1Dv4FteCiowNK7oTA2Lvk6/yKdXWUC +2tM3EQl7pdDRIJv8fDrbKhUuTmulwJgBzOW285Ghcw+MshdFNQj8UhQsdIaX5Wtb+Sz4byWzH4uH +TXuBjXbK0Fn8BBoVaeMe2+plmVDuuhiaNp8hIyH1yCKm0Qe0AmDjxu4te6lVc1T4vW4Kggwet6HJ +fJIdfZ7vqi0nu52KyF6y+GwJX3a+P6JTALhWVKFRKz+VA+VnAdBLb65qPKuWnsHqZ7aRKoLOKKGe +zGVOC/Hzz30V1aa56Ki0G45yQA1iAsCUyPTRYeNeJ9m6EY/guONr9UzVLohDqrQX3VQMeAONqcX2 +uP1eCp2Uk+pFRrR6+bQFX/Szteb4HVuLFLf5kRtsCl8qTSlTGX9Lu1KRL6iXW3q/we9dnl9ka/Nr +yihQ2EnhaNCdArGVG4AR9rnS22kgaa0BnKf2rwDGTtvVLfPllnQKITlKtIrNUSXm0K6+c/tcbLwd +beYGkR2VgJZoTKV9HJ7dgZXuqs7tdcBU+84wUyhQ3l/BIlZ2v4HKfXQmSWTEPr8mwbvSznzcyTHz +HLB0gKWtsslRk0FIABw0Xuznvr4uMoWj9uWscBwKleAx6BE+N8r2GwOkGhVnO0cbUs/Hc6CNG5XX +qpkGK6qxk602pLto9nL3FUjI1oBUs+Pj+Yw4eizv6/aDOBegoLTqqbOX5rz09kINII3R8mH6g5qU +Djo5FfuH+xzjIUD0HoFwuAsV3nfGW9zsZHZQeu3HE5peui/RD7Aa010+9RKpwfOgiH5d6PCQBgoB +08gyweAoSd6eJLJCeTqDYQNAoTtq3GWm4bvNwsnx83ehs/+yqSwY0vnfGCCi38eAfTwluFTzfMft +1/DbJDCuKpXS6+w5VsoEO3XtYRyHNgrmMJJhcAFEcyb2KYD+ouXyg1B/Kjbr2dvCB7vT1XEvmXFJ +PEuW0phPiUtSRGvhC6AjyPzn4/53KXuRGadOp/OR1jXIcd9k8qrQyjd6hd1uosXv08VO8eH9qCi7 +J1GTGtjxtRKUTY2sEItvQl9IGbEthLGLB77+VkmUCvMsOpa8BBpHMFYoDbOnQH7Ww7ne3n5MVFB0 +ED8Ag6vN620lcANzQxHo5WaODZcSgI+1U4UPFbcU39e3RCyLuLvOXo2qb1z6O9xTm8wQx7ngfrUY +fc4Be5+jBopzFiELyN6nLsBY+nv3uNC861yB3ZaulO9fx2+IR8rbxwLz8uKIfsIDwMBjpS1uclk5 +BKrPIWDRJ985NCTJO0pdhmaQnva564t2AuzU62gpQIaA3Xx5FS0cb7wT6hngxmOSu/l+zyKRUApU ++ZQOttwY0Fhp5+FjWHgfPUeQ68jUfy2y+pwAvcP18jw+fsmePIQFZfVhCECw2JpvvgjnFbqepKPH +e6XX6E1KNxcZTr040oltLZy3/MdnKQhPvQXNkGUAY66cHX1PEzC647zw3L3fUp9WKwwgddy4OVXm +rzGjL4H+e1oKlgOlykA2i4CBdLsdLxxHtlh1z/3ZdrHVjLZhFMEtdSg+HWzuwIV/hfravsbT/cxn +9l5i82w9z78Cq7MNLOxErJEdZTslZXAYCh3K7mX2nq9z/PCoThaeP54pYO/X+pmEBAzwi4s22H/d +fTBhjSpaLO2Uq2MlHCm+sZO84bjj7gdXj90/UMWNWC7xOWw3tpMftxMw1gq8pitH5rsbj0GwXyK7 +re8CsR0bIvHObuR3SWATDDaBun/dLEPPaYCk/8+0HC2nDYUroGvFtTlvSX3W47gx7OiSAsX7rLTX +YaqvyLrTX8UCnhXqBV1GJLyZ6+NdCuYzRA/uyVV3tZVYYdAfrtAK8+2kdz4Uw6h+YhrXF0mzbzww +j5sJIhE5jQBOPaPhL4rZv0zR8otL+Rd6sUcf1mc5YFmUe5Wtq4MGoJf7tPyWihxccZ8bYbpysBFL +BIEOA7hPb38jfPaQ3Ih+dsGrt/f4RmSeqm1ET+8KGzHilCISB/ch1D1YtfAlM6Wmp2BwhR5Yybc0 +nRNoATDZwQOKtUEHSspbovLaAZbFZJI+aGaj47PjzElymhYq+7fx0uiBuSlOnh6IwkPpvl46yB60 +yN0sPxR7obcvI/nY7hXor8pZTRdPKE5Xk9tQ69M3qk4nk71pHXQSPSISTA1PQxnZVCjNbqiXUW+H +aO+QqOdzBezkmZjuA9jCPJIub+ygiaN1KfTiialQZoTvvS/wZ7kPvr4vaDt9mjyfPl2ad1rmX9jU +0UvctNOX7TMg93XdKp1y3ZNywLzT/Y3QZEoGJuadXpBPzCaV2lU69QWUbqfB6GnMolP2M9QI3hfN +O2XCT5F96sN8ppulF8YX2Loe96tmcyVKuZOMRafc1vZwEj6w6PT+hSi9n9WUTlEcrNxteWN/hzx+ +rZt2Wq5QdUv0Ug/p+hvqFNBis6hd01tAyU/zdBV2GzauauiefuyTYdApMzKQUpXIiZ1eBIO6Tll2 +8DpWOlUoGXf7Onn+HNYtOs00OL60TZp2+nL4dmXVaQVofXRo78l8rvsbz9Otz86VeaeX+XD6e3tQ +Nes0stdPpZVOwbpoSWn38CFzbt4pc39PlJLEmWmnm6UPfvtqQJ2bdeoLEKXn55LFXLmtQG94mrfq +tEGUo2835p2WiWywE+LvUae+gB7Bs63oodjpfSykQ/DhGXMgorf41CtpOn3YJ6p8jISd7uo69QWm +m5XOiLtqxCjQLT/W02/18aFh0Sm3xffapRerTgvE6e5zEnWKbGTtXI++U5mvydmVaae1vSBt2elJ +p0YTZp1Czs88xojaa3jTbK7TzZNK5+zxIRwy7fQmOPyw7LT2efnWRJ36Asa5PpaJm5PxvnmnVTpw +XcrsH5h3Oj7eNOsU8GTY7c1reXNmgeDHc+L28KRg3ulpuvj6cvn8bNrp83nvCHUK5Ytxrl/3bLtk +0emTQDxP+zHzTs++xoPzpEDrOgW9oG5fj2JDSwRPArXIhkWn99dEsTs4Nu1UOIttbmSeY4CPgW5T +3/pNM3/lX8VOm3RYt2nCD9XGLuqUCqZDFe1Mq8TbbioLO40qnYJeYLcA7Ne3xPQPJvpOp6OdA7HT +2WFEN9ONp8ZjGHeauyePtIwwOplepzdAL6DbuJErHcXQXEGn+ZmBFVY2OdzpIXkS0zHC6Jg5w5KG +3k7lT1CnsBex2+3JpNEcwk4JXaeTSbYzkuj3eEPX6ZT9SomS5jB1Gdehd3PUeav7RP2h03jltIOq +XO+8jFKWb+8vycGN1dtPovIWmCtvDZwfsN7CjsXXYA12InlpXF8dXveWE8jXuvh22hMMu5Ibfm7e +mb3HTPHiKPVk+Vagdq/erN9+Nl6CMsaM77PUzkPL8m01MjykrN82z9/3lLc6jHFb55utZsXia6Gy +U9m/nuK378HvpO7b60hXUk7fyc2UAWPXzePa0Ow95nKFSG9i+fY20ExsWL99KqQOJIyZvH8LvPDb +lm+/ZhfjiuXb3g2Vu1TeGjA26JXSL1ZfgyFd7rGWb48pJn1njbFAa9isVa2+3tnYOXratXxbzJ42 +O5Zvj6nDTdIaY9kNajucsnjLVojiwa4051RoT/c2Ur+cHopv8/F9/a6s1N/Ku1nlPTNloldaCyxP +tIOPeZH/vAX68O1YNEdLryxmPbnR9Az/0vAxarYNLcz8Ruw4eQ8szK86/CcOn5U2ooWrPPznFtlv +svWGeYTYX+MqJ3G+ySYVPLiIifwc2DkafSy9RQfBh8cDtDegpaPaEYlTYRgEduzdHLDWzR3Q3/u+ +3N9WonvQDAPutFmczN/iMQ27nWz6Akq3yNKx6JTbgnbOo3mnzP2DZadAiHyROn1MPVdk6Vh2CkVe +y6rTtrpTpgZsZFW3wlmupuq0vbOzpXSKtH+5U1qHXqj9yzMt9zWdhu+R9aruVoPgA8qyU6T9W3QK +7EGg/b8onYK5aOb6bNkpQPCUse4Uav+WnfoCUP//NJ/r/kbcrtNq0LJTpFMoncK9r+kW6hR1zap2 +klL36Je4EOH8Q3vgpt3LfDBU732LltzW90vx7tyxHfsp0p3ILXJgzk9ZkVsatu5baACxc6Vy0KRL +84nIXHZqGd2OT3S3UlHln/Q41K6LxjrkSdjeT4/D+2MZYgiBSCcr219oFOlk+bEAGFejCHumFdYk +dp8uBsR/oqcjsQOkAksdyLolGA+Y3MEYN9J5nwDbyyU+O4WA/M+VWmMWfWbncuMC7KWsnu7b8aHo +UwJDvr4AD3agQjvflbCD9XaRHatmcLGjRaDscQMDJo7ZQAD9AwnyVmslmQ2qlzzSDUo9pNd5EJDu +aZQKHhIqP5rOHYhQDrjl8zx34oR0+I84eGzMm8wvuGE5P19AmSH6x3IFpfWrbTqv35Y8v12Rxsxm +CJXXaxtkuV+/EaJPbFm4RJYNMHI391WyBOVzQ+4SsvZinihLoSuNRMaUVX769o55U7wD5eZBpOSl +MU/lHpLH9nj3WSNLy3rCRtbzUtSyHtqS9ficSLf4dDRRI1AesgaBO5j1mOPuBeaLSQi2GE+0GMX/ +iLgjh+a4u49tWLJtq12J/HGmU7vf9D41tRRDk6MPb+qnTqgun+yIpwmmAylEdLNSSzHVrDoX8R1x +9Q1stAh6uRl5mpAZhwG0A8y5OxVu5W2opvO38A4Y3F3BYpmiY7KxHaygMWA//4KIIayl9OcociBR +joqSkVPHHBjpFpgZKIR31SnPrnHfNUpu9539rgOysrF5N7ddyy0yek1G4T+PEdUhhYEsAGcMFU/M +lhNgTL2g8B+woIoj2kgbYH4yFzTSxvmlPCTVuNBcZmXTkaXLzanVJDNEZ3adMGhhxiVRLL7TiHFJ +2mUnLcwt6+kJU1/AUjC50BmVxkCbeZxZiiVfwMv6liFOKt61J7O93y5r+bQJsk5HiuC1GdLs8NhS +Vp5fieNxo9KBIVkrdNLS+QLuVhBY+baKhZPOr1nBYcBWsfCwfuWLgQIKU/ISwGpDF+MCu9IVMK1A +8Tou6YRXBHZvb8R4maRaq1saY6+TFWJMy9E8jmus9cO88ROD4TpLTxfUjjXnL2A8FTNj0EqhNRXQ +VO7uc8OBj6kUbPNdOTvcXNmuzN19b3szlPF5rGElK/DIpKrgBlri3rFzv7nj1viQdUs9dtJTWSw7 +uhHMFcOKjimY7hfnZUpP7U083UBESjYOxYELuBqITrdcDCcO2141EGwjRyxE1EcFuq4fPdjk+FBS +G2Qkx/ZQz9NmXOXQBr+OIM0XPXRg4dQAmuCGjQ5jyj4sNsiRvdrhC3gZ1NaCDEDLLQ== + + + 4ZZ7ngXsxbJbBnCkMAC39r71/IIuUO5zh3SNruDsz9Br8oqv7+sIHurdroKoCjOy+DwtK5xBEwtn +avhY2OSA9j9pt/QpnljZIcv9Frc0e5CVBJDlcYtrkCVvcfQFvZ3sJbQb/BjORbvFTa1uZ+8SoNpN +dx4SO1/Csd4lqx+NnUtW5yEZHGs1eAuj2NklC6am2kji6nt2kxzDuIRTt+4N2UrSD+V4rhXLC7g3 +AB18U2hCKFLFsFru10onUy38Pr6AnZducAwPd++X8vtAtDj7+nSswMJfA7HDuaJkFd/UeBrGGlU6 +M9er0oAOrJ2JIk92oUxDLJ/oVWkvuMP6GBpPwH48bv0L9OE1H9RRhMoW8yQIT3Sa8GL7JXUZtp+a +M52fKMJPli8LeKPHJ3q5ZzUhX8CG0gHtaIXeIgzg8DrA+hzW3B1iXh2c9D6dqLPSZQF2dILOSQ6p +dVk8F5Wog4dVQXX8BpwVeOaGGCx3nYqS82A8cW8+b+Oc72pm0k57Kur6CBIAs/K3mnlbsWVh5W+F +wDxsPnN7CWwaX2DpQwq0avYiz+cajtaQ9DYa8Uwcw1l2B2IosjWpQJF4shc43uWebO+bANOcEHoT +otrzwSDSLqIhrcaZR2GqKzlhyKPgU1/AeRu6EDcQGBX3fMZnoUTAWM5dV6hUqZ+pb40U03O0aS9s +4GjTnv4AzwVHM/WQ5AFiMt/LcrRrhaNJ1qsXDV4PzJmj+VyeIEFgi3M0eVeWb0Yr4Ghg1cw4mue9 +D+B452gG3wWGszxHg1CWP3tFcGxOg6K5kHyKk/AFzLQBjRC6GdlZ0OqjQ3MdhYleaeMtgc1j8I3D +Z8sewEry5T34bc2GXGpmebDPz2dmmxl74L2xWQDsZsMTk/UFLNnsgtEP2s18g2xpjSW+iIICVk0X +1GTFYZzhuFPtLaEgPwyAs3wIBIJiYVDrTt6d4WgP3V26l01OExCwVfiqsSwE84tA7UIrDcHT2DL6 +vYpIG5tX06Utvrtbt94sle/CUhreetLv7X2wENjy+v3Tt5ks9CrF4Kp5d2kZpRiEs4x+r4Iiy8LF +pRiCY6Lfm0GRrVcLOG6lob0sRBzm6XtpaaiRha/6c2LUC3i6knAkyH9M47BEWakJnlLCMCx1gdeJ +zZKoURl1cfp2d7eMr1rn5wfAlt3dqnGZ7G37WGsbjLlSd6WVhL1YWURgLeOu9rnN6Wke4PMmYeO5 +chFOpxuSJUWg2B7H7aUXTPl4zCCW8vGEK7vShWCicndty/A868g1C3sfjIxyh0oXm6s5XV20LQBm +eXYje3vcBtQDYPT23kl1FR4SgDHem4phEYMIV/I17soHi4FZbPZ72+BbTBE+yX/valAuKcKwuUSJ +jLeuIs/S7OnQ1LIQ1wBly00/NmLDy9eN6M1LcSOWpV9g3lzRLIMO39yyfA6dWooZM+h0GUML59DZ +Z9AhnryCHDrLTlEGnWW2oMccOvsMOnW24DI5dPYZdBqtb4kcOvsMOk224BI5dPYZdDbZgp5y6Owz +6FC24Apy6OzbibnVS+fQGTauJoNOtiyWzKGzz6BD+phzDp0mINkmw+wiWDLTtq1j4K0zgXTBLi6G +ZOrpLTgHbu+6y5cq6WzkhYNhC3rt18Q54NbT+1jQSntvS6c64yvoAzYWxtPeroZctbmisowPuUkG +63x1bpycKNozPjtg9nFY7uaHfH1OmXOu56fzXBn3i3ukJ7wPySLz0cFzZTcks5Q5OBdPSXOueE1R +FwqixPZ4S6CaeQoFwfFjpsEg3t3GVk5jdDPY0v6q+9iW/dR8LpPdtJGQXh2DiJLBmi/rMcbJblbH +NlorySnZzdo+tT9wUHHLom0wiMY0dTJDirpsBk2msDtg2hAs0nhi06S+nTIf3fGsRsmT0Yt2pZXZ +26StQyg9pZii3LdTl1mHzrY9QJbZWbasjxldZ06Ow54w1rlJwLfXpkGzC5xYlS3VLsssMJWmpM8D +c1S7XOfxzZ1i4D3k8TWd8l+2NE4r69Q06yQYe1XaGAMfPPjcshpUxixF03r9HGPgXUcRtMtaD6bp ++rnN4xMmTjkxdsSgjU6HwFaWITpRTj6sMlO8AHOmePcY0zpYl8SYY5qo+0kqHG0hjGkdv1Tu7j6m +DXSq6ALrTTK53OmyBp+v0cySt/qVud/SPl9OB8ICQG9TK5FNQLxRLyT85812d1dcGHuyxedg7H1U +XBt7VgD0MYoLgHC6GgWss3yrhrtUuYVW6JVwli+SSmO+LWCKm7OTwWfrkoZZaRZGnIHs7XLkfA5p +zi6OPNGE7K888RnMKxs9MjU1hPKHCjMXKFedjFhR8teRN/eOiamENSWHBDkD17HOiJqZSvMF9LEj +tzte2e+W+tjXkTf3jnWanT6CaGE8fTp4Gnw6U8KaBDx6ZDRD0uQjg0FRXtwfNkPSbmZnKWaDJ8bt +kOyj052T4uyGpL+7I67z/+KUpFV4ZI6RR2bJKDWgCW+78MiIZ3wO6TnbqfjOMh4Zlb1/vLxHBgAI +2UR3eEhDW8QjY8gWXN4jA9PQdB4Zq4xUp/w8xpNHxtTPf+wiPcddcg5M0QMbzpmS3YXvwVIdhFZZ +PlGUZeu4cTfKMn14HdlyQQz2OYnjk9VEMsB1SV0GV+PUAVNLhRxiet2koS0YwK6WLzCBzNq75CF9 +zBC6YJot6JRX5zlo1hihivLqXMbr2ebVqVJHbTKFnZ2gJ7aXVKl2r0q3tA3VuzDeRQqfuRR0Us67 +VWDSavLhYC+riKmzz4fzfv/YIvlwZlHQF4NV58MtkWfhIR/OLkJ1dflw0Gu95A50kQ9nciOoZRLX +4vlwmmgo6ZvgqvPh9PeO4oy4VefDOd4SsJJ8OM2JlYtQy8Xy4fS2mNWxDsxkWz6zHgq4lcVEAlDa +mEgr3dJNTOTNyFVMpNPen/boZdWAPAqQWD4bHcGJOq2+Szhu8kgsoWB9DMFZQSaXIZLBJgbemaPB +5Dprh5gx3llVy8Yi4jn4vWuIeA5+OyyEbhNaenvubpbZhkrykcqrsOw2BMBsr5Ux42OW2/B+7HYb +2mjjEN/e7EVTQlvNbcAIjrftY5GPDOCsJBGykHAnxRzhWF8JbHGbllWYtfFKYMfb0LRead1tjeGo +0YcFk8/sL3ZyNKjljFRyc9EAEdWcrS4WXigjtbH56iKJ1GVGamOz6cZl4JDqt5KM1Kfv1WSkQjir +yEiF+WLLZ6RCKKvISIVw3F0DrTOJzeL60AaxvjTVc5BROCauvnYb3i29DXWpcOZ8bNWpcCie3zai +ZxWpcKbrsvJUuMX9llqM2dvuHuzKJVLh1HcQoWS4X5IKZ+JV+AWpcOb+MZf22b2dYqhmBer7k+0S +nz4tY1Xd3Aiv1cfycQezyG2gFwTFuvIounAgQ2DWN9t51GEMlwx7PVxQZaPfuzzCsbudF7ByM5Gn +9OKc3KzPq3uyvA5HLxwk76iJeFD2L6waFzXrT1wDVOIyff5Z7t80Xgtb7XmxlNzOvJTq6YtiJjEL +As5fqh/y96hseOGhOMlkK1z9OJ+Lt/L5XOIEFiGojSVxFOhrhyx6nLS5WGZZZ9BKEnOUHq3zzoTL +1IWavLTJbnut81O181nVKfu5G9jfGFll2DH3d3bJbu2EZadEqZ6zy7ALnHdPG1advtl0Wo4lVZ3q +c7FSkanKC6dPdmPuPqtyZUJdCthmyC7ZjYzrOtXW49sbWGXYcVtb39z8ySrZ7dEu62xgn2E3qtct +O92pdj7bVp127OvxXd5Zd1o8eyxbond7SO+9WnV6qc2wQ6sKNqw4a/RLpPOUy3Z7Zu2wV0HTknmq +uoLIhC9wO1F0VjkTRfRMspLSpXlfL1DtfMcuQm61GmxkiOeiOSO62BmtJrXHOUJV7zWxrmP17WJI +qnMxm0E5Bac6xXlg63WVleTMyo6Y3KniwrtkV0nOkxfuseA6RNIhGxLdCekhrs+piJxtXJ97enIo +Imc5P7O6b07FRtzOz7nWgGukO9UZ0d2ltkT9OPf7pdyxLkRkGe7qtgCdvad3kWy6xfwwXrPpzOwA +qRbn6rLpXN4Ps2Q2nZlPUL9fls+mM8ulWzTz0TqbzswXbx5pv0w2nQYt4p41vX9sqWw6M1AON4Qs +kE23oET2mE1ndk4jy8qVZdOZ5dKp7f3VZNOZ5dK5jO3xkE1n5muXKrCvLpvObHWRp3el2XRmyo06 +dnQ12XRmuXQWt80vkU1nHNLnlrWmtGg2nZly6gusOpvObP1MoqGWzKbTg3KsKbxQNp2VbrnabDr3 +GFsmm04HSn8mvqJsuoUw5jmbzjbHamXZdOa51avOpjMDAHpZcTad2WmJLgZ+Bdl0ZuxBa72uIpvO +4WRkRdl0zvJlFdl0ZshQtPFVZdM5ZXKtJpvOLJfOsh7f8gZgTDEANfXFPF3dZF3Fy1ikUl+bw2Xi +07fDZtcgnxlZ1bJZvF6dYUgzeMqz6np11tqFOzzNIkFPeFKwpImEhDmZjoqFSxLQJChYZD1bDUo3 +JLeswEV1Oe3B1EJDghgDg/JUdtluSOaBFJYcxgZPNmWXLVgmlGJai+iQPJ7qLCJ6Ozl2KGxu75mT +q2XZFbpbusyd6p4rlyr5ImXuLKvLnbjKVXJZ5s4qk8tdIp2rAAn7+GSl0N1ya1W+H7upMmPrpXJV +5s7RowgRs3SZO1GHsS90t3SZO5z75lDozt3h0fhkBfdc0YfXpP0ius+zOFlZiNL4RFG5F87lAVM7 +CLulT8tTHligzjH20Ik+YRodNJ5tPfCuEuncRDT7nDMMrYM4XOcXgl5swg49BJFB7Fi6/rSU7K7C +Fuh5K6jPJ4KXplrO2exuKKvznvLFYMHELk00FCAqh3hw19FQAJRj/JjraCgAzF1Et31gM+J9K8l8 +XP4oBFYUtLkOXFx9l3Bc1XY1g6KK7KqtYgciKIZMdtNMYedcdgTMVWKtVQ0IfWJtbWhMrK0NV3cr +IAS2kkLGiMbAaN0wM7XsskRl3QyVjvVe7WKod41HujATzxhBbWuJW8VQd6a9lWSmyDcfe9ckjKCq +81VVMAQvLqyPiF3v/WtPhaqtTt9g4bWl1QkMxS6q0wOcFdwSgOEsW60aQ5E2odkNh95iVa9dJDJ4 +OuENR0y24Y2LRAZXHvilK9xJ+ZVWNe4W2IYmwRWL1q32VuHOLvNxiW0oEZpY4W4llfIc84ncVcpb +Np9IrpS3/Da0qXCnzUtykx+ySIU7u3qvsMad9wp3bm81h9lPyyfWPn0rao6V9eo6sRYAc1ZzfG4U +HVybbrHEWn3mI7us/wjmF56apkN7u+cKwVmAbxruiIBwVpLPeUq4s8Uc4VjnwuqSmHxO10ygcnle +8tvNkpjUp6KQQUQN2zAVclgIF34tqe6byzQmN0lMwYMXvSWqkmJu0pi0k3TwnSqg5HWxTGNKhVxl +qNua7fKuTIXc7Eo3SUzBg6Fe+V7UrrzzlMRkFUEEayfaSFpviuGdmMO7xK38OsXQ5A== + + + ssS7e1wDYhU5rvm49a1i0H7xWpHOU7lHhEprfex+dVdT3aPTtxXluN5bXk3lXYdpTj2Ve3SolJdY +MMdVtT/lMAwXWc/OOa5gSK6znu1yXEUPEFyIKm/en6T6wYy3ykG90CPzucTxbWGrc1zzBQqHkVr9 +YPQW4cCv8gXK7ivdPZXaVDC9WcCCB7l2Vb5j8ZcmCe/s8ErdqSYfzheYbt3cX6hdVdo6bKn8471F +PlzYOglvMn9LkVqerEvDI3atcv+4rW3+KvxslYT3ZNkpmMtmaUxbzpUobz1cW3YaPGrGP6zqsIWV +TuVMLgXBFyyl6lSbmjYN8jtKHUFal+UYDh0+9s069QUggvU15zRpeA197p8avSf7FxadclsB5qzw +pvhg9Rlxrzadlrc5607Ll1sPZp2ium9CRZNaqe/0yq6O4MmNdafF4nVJE9kFut2G76PyLzEJc757 +kNCuvkU7Ok9YtlPnVxJvu6msC4iR1GhWVMQkmPM9o1c65cMa0dujFZ55Gz+xLOhchk0CpLJhdBqk +qWLmHDjpQjYD2Af6xCZHD4l1SpIxtMpySJCSrQeVd5Pa5JzYNF1VZRbk0HWozOLWk1SwD62yXDpD +ZRbQQc1LCJpd1p3u5sklstIcIjQxlnzu6El36OV1frLXGubdea6yaDEkQ5SWfr+4RrqnKC1fwG5Q +1n5ib0MC3NI6TkscjyE2Vseuik/pXe3hddFYM2UxUwLAPnJx9bWDD/aluKrLG+9jG+5uOHSRjWTr +XnZ7yvNSXOYmWiUn0XBl3ELJbuZH1p7utX4pLuhZ1t6iCbMAl72E1uyuOMt8MSerxXhXnI0BZO4f +0waNmByxNkqe6h1Yc5jSymzkRknPYRY99cYJd1b7GJ1YOZev04xM7+d3dtmhenyWXhXm2xBA0BMm +3vURi9pPwYM768NBb4lkhnoWS5Rls89k8pRjlfR0z4FqSLr8l3bZznfsqI1rhqQK1RdPq1W71mMq +YG/bRSqn+p4rm1RAp5LGDuunnLy3y86JOq6JQVfX2LTKjAdgTlV0gvrsWhtgOqmyHMYcc3ncT1J7 +crkkxhzr6XjCWJV5sgBmSBc20w5FjC2YBeg2B9D1PSRWCWKucgBtotNdZAG6zQE0+pO9ZAG6zQFU +33DoPQvQbQ4g8lovnAWoIRUbC1MfB+stC9BtDiDE2OJZgAo+7fmGNsfKaxag2xxA2UZeKAvQYkiG +HED1eSUej3FWyxflc1+RbZmifKq5/MKifAavwi8pyudUkW01Rflwzoi9grJ8UT5fwEQrXHlRPmN9 +5F9RlM+6PvIqi/K5ql+5TFE+tVcBDoqzHJSIIqfUYOuqfsvfDXW8iruhXNb1c3U31NJ1/VRTW8Hd +UFZ1/bzFKS1a18++qt9Cd0OZ1PWz9wqZW+Le6/qZE5/t3VAL1PVzpuRV1PWzjwyRPVdL1vVzyuRa +kUPXtqqfL+DJoWtZ189+ajrfxcJ1/TQDMVT1W6ACiGldP/sJmUWoLlLXzzQd0e5Wc/eIcZ0pa3oX +9AJ1/exv/pLPxJes62cr6PJIiq2grp+9W9jTDVQ2df3sTV3TKOgF6vqZpUkqW2+5enwryHn3VNfP +Hgr086+irp/9gYrPNZxlEt/1GamL1vUzUTVVVf3U1RmIJer66bYhoa3qp7mzy3N6CiHX9XPMe11J +XT/7qn4yJS9Z188+4FqVkbpUXT8lf8uMFnX3XC1c188egUiDXUFdP5u9Nu3RK6rHt2sPxXU9Pody +cq7r8S1V10+GYrp9vGZzGOr62eQ9OEbbdrzW9bPX5OGNB6uo62clw2+MJ4mL5W+5UOelk0SnbehU +18/+vFkbRbB4XT8ttvXW4qL1+LwFaVjX41vB9pGr+i1fj89NEpPT7Q3GWA1vpfj0GanL1fXTOLYN +Vf1wxtDydf3kVCm7uqJL1/WzV3MsaMxzXT/7qn5L39ok1vVb0tfnsq6fi7zXFdT1s6/q57ke30JZ +uDpuaazrt3gyvKqqn6qXper6GV3J6qp+Vrecea3rZx/epZNiC9f1sw900vmUFq7rZ7Iuqqp+9vfC +ua/rt7jfUosx7zlPFnblEnX9FMZlVtVv4ehBXV0/W4pQVQBZrq6fvWKIrdfl6/rZJ8SKEnnpun7a +Seqr+hn0Mdc3WWnr+lkrQViHcbjJymVdP1c6zNJ1/dQraTzAscmutdif5nX97IWDbRbnyhJisdxP +mIiHBzsd7fzaPOJDf6/UJ75RUScrwVNr16594L0ubVFDTRKNKac36YOxOg8e+6bErkIaCRkfKYgh +EucdTsbnmcYSrU5h7hs1/dwAYuV4I/J4tk0k7no8bgTzqTa2T9NHcSI03Ei0HscMPfk8LqX7z8nL +691QbBAO5r5zROXjLLv1Pc9xG0+NNg1+vWUCrLBX2Tk9/75iv3v3j74Az8aZlnBauoufxCcbbLXM +vOWueteH7dopd/tZ75yx3zehzvv2bTbMFL4261cnvVR//27UOQwNv1/578AkM+TONm7PDoPbdKjM +Bd4fj47C88+tR2b01EmJex/ldqav67WbjXjkJbNBfXzfRPbpYIYo5U5yROm9dUyUuZ2ryeQtGZpM +hduj6dYL15yyzccLOdOyHjlIxG7jdDW5KaW9fSUm06cRLDaX3MK51UYeoskv3XuoviazrcsxNKjl +EpCwnuT8jQzsZjPVYzNkIWSA6c524LrQ2xuWc0UZjaFGsHOxdfNQT28PJ4nSDsV8zLf67Y02zCQ9 +lpJDN+bRMXMG49VOhygncSNbqtcDxHanjez9i5FWZR/rtg+Y2kVelTSn+FtVUwNszQwPaS6Qn/sC +hYdS5w4V0Mw/l6/uuLN8ezOTmO0fZxLT9l4pudW7KN5m6BeAtmG63L+5e8pWuI0mgHPzLYHF5TND +ZKTHw1TG+5fMXnVjgmaVHYwgJWdPbm9fI8Wbuwr8BSZ80Y/DpN0oNuvT7P0EWU5EYhaC0QivM8yJ +E2w8KP0iQ8h3DDDCD8Gf/C7K+gUM52gM/jyIIg6zFQRS7HECHuTj0oelRKlInQoAbIWIFKKBeSlU +OToio8HPQbHV+04SiTQfRgOFg3smd/PkXr7bSJDgxUFE9aKxnT/wBaRX+Zjyiso9XB9KL44Sygt6 +e+8jK704J+UXLyLayge7yjOlZyj3y/mo6hXsW4RTBrseYGIXzPQpAuccpp6nX4ABlq9IdBMOWTm8 +osF0L3dV021+RCBmLwHKD0Y9srXNp+RzMcAKIXnlyFbsgISNEjBvaUC2Do8g2i5J8ZvLawQWJrXu +b8GeIzC3GImlbSocY6D2X48pnVLhw8we7mUPHnhf5frxj93sReu9Wjg52qgpJCkfC+S1hmtAa3Dm +qHCltG8GD1DyohAvqwcyxBw7u9julJ8fhI9sbb7dLT60Lwg4KxJRL6bkN+p5/pIRV+P+hZbIq86o +pl445FvSPriNIQRShcs8lIC3CYnsbwHs5jOszXZLiuoueytqFyP4m5Z/MRhEcW/AgT8fRIivrRJc +koeE9PUDIf8iVaN5o1660mgeaPTCFxBfFXrb4j7ofbF4LlpJqz0z3dGwGZkLWLAZICsho9GxmdTz ++ShUvM2dHufC/QnM6ecquSIRrxvZjL5KbxBRG+ACArrRNSyfiwFuKe74u14Ek2Tu7mUKZrUZT3Q3 +L3bo7eRgRhCh+FScLmAuKG4auSfBn0wYZQWTxacM/DMFNtL2Vxryjahq9Z/ANzeQJipxpAbBSJU4 +MtzJ8kscGuaVhIULpkLIBLmjcqek2ZMQDBX9JqPE8M0XkBbqZBfvu2g+0JSfifsX6HBwO5+Ahedv +Kvm3XratYUJVgmCbJ3AhTlR0QJZz31Dj+DhHGDsDHdyPECeGU3/KimoJYD34GWaukOFgSWMrhxTn +rGmkvbSMIe0ZfHUK1ZwMEODCHOs1O+yopFLu0LPNfHYTfHY1g41vNHcfSJpSWA0i2i3qQETy24dF +WUBXqFDynlZUNvRsczN9WCbagWFhMjkY7apVCKAfoHsVSgEFBNHZZBM6EHd3F1kZRDek2SrlPkRq +CK9f8WkvRu/sPZIAx4UopBzJrkRPIY3F8dPn6Svc4k9Tic28zjSY3wqKZY6pj0tZU3pWlCRUYBqq +mpvwxT3CnUpPDipKy27mdrch6SYHlKSW4PsZgPjbZMr6YsuwEK60LvMN2OkGXgFm+rgDpVjpdUO6 +IyO5JY6nf32mVt7vo0MRY7kwdHrgSyEqz/HNr2uAp0gJdBqPoQ1uvC0CeuHAyMoREQmFaU1GwpMa +CfPHcxkJuhs7IioUPE7opuruDhkFvkA4/9B+kZAAxqNGAj+xRIKEgt1tFQoO898jFQoOQ4UJQgGg +ZLFbqf43WhJnJAAm1EvgTmn+vCeigJqTZnSAb9W41yIhoRD23cYoUcRImOTuHxUkhJrbV08WdCBe +RytXLQd8zIyUbEFEvNOiNnJYOgdQRuF5DDEzAGhdXIOIL7illPjkMLHkakStaRpxfmkUNjQdjVqA +cIUHxPmjcRfToDOXoZAIonF4rh0DaT8GbFfa8qcoJYHgtpTVmG6WT/KadoldpR0slX5hUecdLE5o +WRoLL09jiQXHoKIxclkaCy9PY7uWIFwAwDQWc0GmGhD6aTigUqQxW0wQS1JEIuILuMCELQg3nM8X +sAVhhUpXqwEBxNXenoWIKuGasJHcNwVBLDsN1c7wBRabBuVpDGjv60dBO+/PCnNwmo/gMUzSrObS +rzdKLwMUiewWE1TU+xh03JJalqiouBlFeOKWlBvlxkwOKdySWnaLU6T2T0rHxyhaNBZC7TowSDNT +7JFBVpmi6afLtyFsRSg2XfEltS+afeedoWjb3vVi1GulHSUSje8YsobhHRHTzxj8Oo5sEPrwehPZ +fkHpOHEriIJ+kCmMvWuyKYx9a8GDq2/wZyaG/3yedpChGKS39/ffSq/hR1T/5SXzIZurIdnr90y0 +Q6GUZJ+mdlWONdUM0pmoyq0WPKympReluPIC3Xchu2CAsavyuB3ejHOSpyyFphFW91zORFRuNVXP +5ZLi0HtBNaGRF66aEL0K5XMCugciODMFGM8UtuSaL4GGNN3LCHacNcckJPvLmKxeb1PBdAgmNV7G +Rd8al4eUc0ng6nITslU5Rw9EsK2HR1L0id6XIonTWg/ygzo2/6kwl2pLndbjuBcivC0QVL8WKEaT +4ZfMHnGzrRjeiMb+/9quda2J5OlfwdzDREQ5hEkfpk8KKGfQKAgECbrGxERAMMEQ3t398r/2t6q6 +M5kMEVnZXZ6V6UqmprsOv6qu6oTh1ttXn26d08p274eVe3CcxC/6KUeW48grU9eL87Xnfb1cS9+u +mD/aM6EUd3JQCvZb/yAybXwemZeYvWlfjCok78v5itv2EkLF+yQU2052uC8DrX/ZVeHqsibC1c2H +T9QGFBuzzUa4EqcKGShiADbWOHmJHE8S/F6UnmhcVpm/u3GzH3h/nj0+ywprIl9xew== + + + 3v6WvZBmXtDK1nJCraXcTvyJrxF4a1uqz/hC18bHFfL4uWFd7+AqvAUcez5UztOZUeU8K3Y/pZoS +njr22cX2LFkeHmfByLA9nxV/wLFflv4gAWN/tExf3wcetrhTOT8eJL5UdV5+Nk/oJB8/33g16VM7 +0TQ439vX3mqzf/ClWtgjFwrtVMkv1Nip4rS8RggzAwjTuli9fNTd5OVPpkPypLW8ZqO6V8Hj0Tjf +kGwBzKxXE9+qzViqe6HjhhLa1mmKEnubhPYdWOr/liPLjYqtYCau7N9cdvq7/fPT825cjp5HlZUd +zmvddm+z3+kcdv4arPe+3HzvdAfxs7iycrC2s2PVeudLr92J6QyK+mxyNQZfWgvHa/KdyLFzN74K +vf7VbV1sT+0vNde/svpy7lQObfGfXh3+KJXPvkF2Upr/kkyXyo32h1JZbB6UZravyzis+zJEtrLb +/bDPYCR6bmq901+92Zh/U31fKKBTtHSfD7eWoumN96ud/ZeV69PFyvbKyev1k82jg5eVAetRpaJY +HPQrzZqVE3qb/b4YPCnNLr5NSwuVp0fY41yHtTxet5VSefblS6S+Ks2/e/QW1/cWX3hRWliR7VL5 +zfF2ae7HVB/t34YK0uYNHpQT86E0POrfbDYaQx/c65FjRN6FePn0FCu7Rz8CxmKRGO/OisQVGuJJ +tJlw9a0zF7wIrCfvRTR8NoPeuL0QsAO/2COw+Fp7NhhWnHdykYptNwduGMLu34Ea9Z+i6f+uAzXq +P/mq9/07UDiE1KIEw72XI96NUGXf26SUYQ6ArbNKhoZdeEunqaoW/H8XVLu3W8FYW4YH/HgMwxqx +nfPKqex9kFk8nM/1otpPEghI9eoojn8ePoWM/QQktl5pLj55dtp9Wttc3Ei/FcqgeB7hXf5w1fCE +VXYWwMEMu2sjjpP4+c823Jvj8HuMiePsK/vO2a3Nl087h+s77aVS8Kb6Mc/aTGKsfzN72ZgaBs1m +mi29mTev1i7haTlAbqtWCWbfOma8Vd2ZhStIN3xcaX0Sy25HgK5aTTzrEK7bKbEIqr3YJ44LdAAK +hsfDNOniAxtefRpZWyufyl20Ze6FTyXZgLVQdP/85sc0rWX8PMZa/gwVWG0eZjIU+DXMIFoC0CCa +LIZjFcsXLzzWlH9c7U6GmQzHyM/bTypPQhnfh+M33bDc3c7cMM9+unQwF9rbAE2UdqM5s5B2v99o ++lgL4IIRaHvGB+bO9QXut7bnAqTwRxWxvvBhntrbWVhfCJ8Bph43HpE5DvnX1uvZ8Bk0tVmZfEwQ +8GdokHjOdHjYFJAhncFWWFLI0X1PfaaQoPvQ7PcCgDVZoynJd9ev1tj6q8Ueu406EF9Cm2lpjjps +vhc1T3rzu56tT1TrfrsQIvXVs8q9e5Ke961PdmTf/eHVOLInPPrRX6p8G20RJzV28Nui3w0bO/35 +Qm+o3198cZCvfbCdj+VknMXZcq0xt5E1sWqFJhbSpvItrBPxqtDCYhuLu56B73i9u83iZozF9pPt +vKukB0+H8Rr7puW3Ar9WFO1pex6vkoxWIRp9d+EyWG354Afml30PMxAcTwpJ6+9vi2e+0xlHlEno +WpVCJ+f59/2sfVS/o32EnvPr9lHoEE/qnfjvVr1n72RC5yRXw4ymf6vEQV9q6EXwKS8C6ugFEZyM +RABrwfnkhYCJ/i+E0Fx8OxKB/HDJ7UgEmGcnhTbi6LvX7yOE+1T6765H0x9FvruHdmcbEf9Q3FCK +HwuGdM9OJP5dqgfY4vBTBz+bxf3m0OjfzcDr5U4WreuHudTW2U3mlb+pjb2PV/ewaUDLHIuCTe81 +fuIW9xXlXud6hJa/1Zhd3uuVfj2H+vD04eRZ9IcnF9L69xELtv2m/mWsDf4xs996TvFs84/t/YKN +0dcYPMTGDroPtrHO4IFzuCw92MaOug+2sXrvH0HvbQatfmZjd5jIyV3LOLu3KH9qYxc3D9NGvZFz +Vy+xSZK4k0XrnyEfRrEii07/Ydqon10XTCpI7P5GVb/4DcMe+z6m5Xr35oHL6JcmeQbsX+6/jJtH +vzmHLE8+mZr6lX+K648jFqWnR2cH+Tm0Wj+PAbmIfJckWp0fD5kDomXr7IFG1bq4fihatrqDX0Ld +nXGo9eMmlyf/lou3bkr54ZepR2PDJ1O0VfCVYjyO+GIeqxO6UCFhncFLSwnmaE+X2/Y1H3//6Lfy +T5fqangKs0FbxoXhqdeP135fmR1axVJ1uJrx1TzYCs+Nb4VpZ1wOw7WE9s1JdlslK7B/HJWDUWKw +sc1V3P69DtSo/0RP+Y86UKP+UzTegcIy2FZNUFUsX+jZW5unwlko9OztLAw3qTdzYRe4V018bQ2/ +6xyG+wyzfw7/tFEvlb1jz1a+OOwm4Wj342R22IvaIV3O5yuF9d2EniJXrbTPO59mv66d6c3d1Us7 +ZXOla1+mhY13+Jz5rRbCaPde36/8I46T+EXjHGtsxFHXlp6trdSePP+8dmZeX60crnTf+1Lc6oe5 +T6HR9OU4OzF9KEefXchrt1Ut52qwzVCAbO37zzbgJ9xn/VXz0ZEvwI1KQ2L1RG5jb6ROjRa6Copt +nSpfW/MV2ota4s848uzU80LWFlrI12UvmiJXWMtVhC9O02H96ESFtRyzKdqajcpq/tOGEw9Yz/97 +x6upqjD5gPW/eLw6mv7pAet/8Xi170VNPGA9/zvHq6//txw9B5Pa4byx0W3ne0zR9DRQDjqDmyt8 +g2qsdk7Pu9Xm351+xGP/w+AHfqcxVzJWPBZKAUUhudqKZtZ7f3Yve812p9247HwdzMbVbjTdqKz0 +B+vnXwbnvW6z/3f8DEg8rqz2epfxzMrOweb7eOOvq15/ENOz4sNevHZwMIsdrjvfd3R+fd667Iy9 +v3L8plrbWY+fxfm5/KU2w3yeIyfOGjAjeJu/B8TRiFi8Av8f/xndwA+LdyOWiFRrrmOWMPhPwtoT +Y0XKxihWKuFSvLBCgkhYIhl3msfHzYgFeQHbv2HwCi6+AenPOI3fxB/+YHEbn7gfcZkopXUsEiW0 +NPF3pDDHLbE12qmY80RaYeMFeLR2UurYJSYV3OEDHddMxGuRSbgzwsQ84QxejFXCJbMaxtpqJeKj +SCWMG2WBYrD9mCaOM45vMIrDU9LEMmboZSuRo6SngpYTeJbFF9IUHy4SKRwuXxsurYllYo1xEu5g +iXJSaAG8GFcaBQKLsgqZc2UEElIjuLZAkCzVjm4SiqUWSdbZFMUpOHPSwhKAR2pplSYFsWp4xRrl +nySVThWQDLOM1JNy7VxsklQykOdRRBozXAFJGfwNAhUaXjKJgYcbHAPZCiBYxzSuYLhGl2hhYZEc +dAyTIhXAW3DtCqcGOuIabGAtAulwNAugSA5SgLHGOcIYLMiSXiWsCsZgT4LuUCBp4mE0N/AOWKUx +OHZMIAdQukQ/S4KIBCxOM4cUDquEdwRVpQnxhrGWgsZSKK87lqZOIEU5eJZMhEaFwNiigsDovC2g +UThFd+hUeArnBt9hDM1bJYKBr8PkuOCcxlbgM2B6CucHFGkkqtgboAIZahzLVKIgQI3wRroB1Czo +EaA7eENYt0o0mCyMDT6SxhLoa2ixDt0JKGCjMTJ28GgaooUb5cL9gqEudOIcugXOUcCqLPyyiqSA +BupAFfQAeHIKSl6LUM2SKaLgop13jaHUHAiLeU2QsYF9gDuhzaNulCSdpUaT9pUEX6lHJD+0HFAB +WF3MNfwGraIFeWnQYuFJIB6LLAsAUI2+TkZNE1d2uoN45uBoq3Fw1rzqHP591cmB2BxAFxgCWAaZ +eurQHdAJnAInytBoCE3CQxOIQCOCsIQLBegDOEIiQXQz6AKgBOVxIRVgg4QjeUIV9OqkA/EAAewW +NQ8AwiSOLa4RpC8ECgmMTmsyhDECcjAM7wSC4DBZpCBuIE9gCROrEhwhoAmAEiZByWDrQqD7eFgD +aEHDlGi50glNKFEgVYEEYvce4H0e0MbAI9H8ABOsIvgBoEcQEwwQyUPUOAn5gBYNwagyFqbOEFAN +rgoiIqhak1eNrqt0rS1iE9ycEvaqxFmcFwrfWSsR4Zy2/pkFEj5TaANPQ9CzioJTaiRPCeEQ9Qn0 +CiS8TRFqmEQjFCEoo3UT7DFF09FMOWWA4Iwl/LhFqgI0coNhACyXgShAMdqCE3HUusYowVzwBKGk +R61xSjVC1eEM0Gu4xHvA29BQpPcvMUQp0BcGCeQxTkEe0vskKFATWnr5okcywts0JRgCPEKzIIQe +oyAPtCDya4G6g7HWKY2lTS0hMkY+jojFU+IxTkEewcgRtiC4oLsLD38MUAbGGfyR6VA8HaOgSacW +AxEiKCIhYLBQHkBFGvvwQHAHAZoYjBHwfseN8wiIL4AIKKLg2FkyVxkA12jpMXucgo4GnuFx3wpF +9uy9G8YelMHbaUg2Q847RkEWlhIFpGiDcZt500ADR9UjChKcZ4MqDDCkpf5NGqBK+PsBUeDJQ0FZ +VAfeOU6pAkwxS+IHPhCYEOrJW1D8WirEemUVhUyHKIVYP06pIsWLC1Mh6wk+3qQU7IiSxWJ6MBi/ +E45uAV4I4x5FOGEePWWMUMWIYcCTfWzm3taVj/6k+3pUpFQxhjAJd2NOYR0JkguK6HTJCHIwdIwG +1TAQRlEEdbBSB+LUQZMQuRHpOacsp0Cp4hwoLwBfAQRWnpIyyticz2dwAuD+LHskQ07ZdTUaPp3R +gy1FoYBz40FmrRB0MOLxeD2iTAMFkTiKIxiMCJwR6w26DEiXM9x0+IlLIqDnIgFTTq+BcRLNjHAG +JmsppgGBggBCoURJZOsYEnJLG5JIlwG/h7cJCH0onET6BAygDvkDXDBJQFqkkHKlJO1AOFPOU1L0 +JO7zew8ACJM4S8Pz46HiC5TqiALm5iylgj5RgRkKND8wJUpkMRM02s9sjFL1FK08xe87CJYRfDEG +4K4j5ZQ/CbQvlPU4hRzGQ3xKOI1+SJiG2SCgi8P8H2MCjLX1DjNOqUYWdi5W+yxMgD1pcClILMgr +Pbzo1PrMFKQuCR7GKYguimIOioXjLRnIkZQyJArjHDYFCrLgQzCWiIOOsIkYQl4F7q0d94+kHUmB +QKio0PxoUo57igyYJSEBDXlPwFIJnk7JRABwhDMYh9CFIcP6FDpPIPjmhLUwXZdSFm4pF8PpE0fY +Q1if6PscPD/2IcT5jQJlGXK0tbAIPRCSyPsxg6ZcqECgIKYwJ0KLo6glyCQxUnKGeRZtZjH4auN3 +Jrkx3s68K8HMLKYAzqIKKZyj2zjFud8bScqoihSKxN4+wEydcbgbwsyVdlwIMiJkS4izPv8sUpCH +wUSD3ER7d6VMC11BpJh0au8SMvFRsECg3Ib23ZzyUkxlDWcUIULYCVYNSRdXqd9rjlMwxWIEJ5ip +pcgCEVdiKofXDMVqYAOqUkO3j1Mw0bOMZqtDtoIQKJVBF6IMcGzsN7y3SJQvOgo/GA== + + + bI0htNOcNlx+U5wjwGxDhlwgVfMkRntnhkkKIk0aRAN7E6okgKUwLg2xGadUR5t4QBhN0GvTUGLg +kibn0O4pfWcszKVAQsEqjXEDtJaiqaCWVW6rjaUHxAeMcQRsBQLtcRxky7TbwIQU3IvwHGIV7XGK +sWvtVjTDKDdX+72tXa1YToJf7UjHM7Px8XsqWa2HslVWm/rphf8pbgPRjNFpwHQMwNz3LKkzAcYQ +EC1BDVgKQ1wGsUJ6Dlt2DDLKiwndljJ6Rltvn+dR9UjStthDDiOP0ElK28ZqtDlZKurf2vAiImDF +BbZSVNv6DnPgmCUAxZcE0H8dhWVNRZjUq5zyMUgt/UIgAwSL0xgUadqwbMmEj7GaNhYIepQuQmKD +ZS+8S2rDEZT8LrN6azKTKMN8KDUISoBSAsKsLw36zJp2rWEOGAjgFxeGnmdStFMMiTxsrbH2YbLE +DrchjoppimH5pHrrOZMo/5Xt1oqE6qovP29021ToXViIpqf3mqedw37z/LLTj06vm//XiZvdbm/Q +HHSu4JX4tN+5HvT6nfj6rPcnUuCW4dunpzd2N6P/B9uMwxY= + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/originals/SVG_Left_overlays/Green_left.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/originals/SVG_Left_overlays/Green_left.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,1574 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + eJzsvWmTHbmRIPgL4j/kfpCZZLvMjsAZ0I6t2buyRzvUYSqpW21tY2VUFVXiDJOsZbHUq/316zcc +8V6SSfL1pckMMpn0xPNwOACHX3D85H/7zVfPdt++/ePLZ/F2vpl+8pPDu5cv3r999/Mbgt784vXr +H394/w5BP/3tz26WdDtDo90v1q+l4T+8fPfDq7dvfk6/ol/e4ad/+tWLP758+ebFze6H1y/uf3bz +05/Bb3736v3rl/C7v38Hv/r69cs/vb/94S/f/UzfCmiOL95Dg2X5uzn8XZiX+WZuP88ZG7x485cX +P/zw6v/DX5e4RoDt3/745ttXb77bv/1/f34DTeEX8Ad+8V9f/fblD+e/zbettcxNjm+/+fH+5Zv3 +v3n39puXP/xwePv67bsffn5z+OuLNze/fPEd/ObFzT+9fP367b/c7F+/+OZ/TtDn/PXdq9cvoXv3 +L97fLNTZ3S+W8PX+x1evv/3Vj/d/fAkdj6UiOH5NKH//A+ACtPgzguvXv7gHyFcv378H0uCFyLDD +L//pvx2Ay2/vqR1Re7vcLPDvT3+z+9Xvfv2rE7yu3RyQU/87/Rb+N9+mPLQIS/ZNQkEM+I9rMrSI +8PnbNuCIlRv89u/3njPMQGj4z799+d0rmg8wWP/9Z9LTd2+/v3/x7n/+wM1igD/8m9+9vP/+NQwp +jcFSbjMOQu4/SSvgKrV4Ftd68yyUCL+OrdyEZm36eL38y6uX//Lzm1+9ffOSB2X37v1XPC9Smmf+ +zr/57Y+vX777/ZtX74GygqDGo/LLt9++fA3t7fN3r19894N2cunfucHvXrz77uV7mFJvX//4nub6 +qm+AUX/+4q8vceos/IJff//yze/e/gPR+KwutzECm3Pjf2FIYllvSoTRXekVaYZezjezezeNPKNH +ZIhK3wFT6ye/gfnz63evvnv15udCYf3679+9+rbPqRpuVv5Gnbhd3d+mf5la6Pj79y/fCPUwlw+/ +dHNzvv3lV/DG05tvD2/vkfs/4KqDGfAGJsfrt9/x7+xn+g18/MfvmXr6/9cwUL959+oN4px+Rb9Z +v/7N6x/hV3//7u2P3//izZ/eTj9lYfO7dy++gWY3v/7j/3j5zXsQGgLoP33146v3L29fvPr+Zx9E +9JvXL968eHdDcPgwA5+/+gv85gWQcsMfg9902MeRHl/+CZZ+/yxDT2/+8vL12+9fdrhBXrz59uYf +X7z7/uOoYRjeOQz0X/33Eb198f7PIKVevvn2ByOL/zt2lGEfx/fVNzgp3t3s3/34w59vfvf27WtD +O/7KsAuYoNj+P8Y7fkMfePPrN8yg8zdJg+2bQCD8h3sLtH74DfDL/8jYDy9ev3713bsX3//51TeX +XnDh9/Ym/t2nTKy/3v/x7etXP9z3+eQgv3nx7v2rb16//OqvP7x/ef8hbMiNP7168y1MRBI6ndq3 +99+janHz1Z9ffP+ScL7/8x21/MoQ5q9BMHrR9+zZB2RiiDf7N+73f//uxbevQNyCqrR//ePLm9/C +f1+8vlHwz6bLYBD3gOjb6Z+n/zLN+LXMcU5znis869zm3byfj/NpvlsW0Bbikpa8lKUubdkt++Ww +HJdTmMMSQkihhArPGlrYhX04TOEYTuEuznGJAfeyWGIFNazFXdzHAzzHeIp3aU5LivBkeEqqqaVd +2qdDOqZTustAS15yyDGnKedc4Kl5zS3v8j4f8inflbksBTSAAp+GX5fp/9LO9K/F/i4X/4eKY7Dv +Uf4CacSOOOeJuIJ/9XuRv0l+KsCxAjzT7yvxD/8299MO/u7h+26ifw7E3gP8RSbzd2A2sBuJgy/o +DKhu8BWX/sN/me7u7k53x7vD3f5ud9fgWe/qXbnLd+ku3oW75W4+3Z1Op+PpcNqfdqd2Wk/1VE75 +lE7xFE4LvAs+fjwdj8fDcX/cTcd2XI/1WI75mI7xGI4LkHV3OB2Oh8Nhf9gd2mE91EM55EOCoQuH +BUi/25/2x/1hv9/v9m2/7uu+7PM+7eM+TPsF+ne3O+2Ou8Nuv9vt2m7d1V3Z5V3axV3YLcCKOxqr +uzvqDnboSJ3CbmHHdtY57F6lLmInsZuJuoqdxe5Ch/FBJKfTRD3Hvh+o/8gB5EEjPiAnkBfIjUwc +QZ4gV5Av+MzGHeQPfE3AJGQTMAqeRrxaiV/IMeQZci31zpx/nR75HLfPdA4SHj3m2Z8/0wXg7vyB +zqSbn3y9fwd9KvhV6VnhafLAYJY9PTAvgA/I1LtKoqOCiABhEOlJFZYsfJi/1tqm2uDZ1X2FKYVM +hBG5W2nFrAs8IENWEBRrWmGlr/TOta741VaYRStMtfVAQ3DCqdHmCZYWiKQWWmypgXAA8mqD1mC9 +7eiB+dlgDuPY0USAWQWLEIQYzMQA8zHCrEwwN7FTQBkNJa4/WoeBnoVEID8JRGEEUZjpJ/yeQCxm +ego9yIGCnSFh2eDf3UQ/7PGl8H0v3w/0wHqD7yeUpjibA8khelcM+AUSFCQsPiALQcqCwAvrRMK2 +kcDdBViUIHGP8P0E32lhgOxF6buA9EUMKGZBkMKYoDlcSRqv0PcG8pgk8gPSBrnFy4f4h3xEfiJf +G3EZx7MQ3xOMQASKsKszDg4M0REG6wBDtsOmMIh1ohHNML6RxnoBeXmHqxJmwgFmBY5Ag4lSYdJk +mD4JSA3A0BmWP06yI0y3PYxUAzQVpmaeQO4n2AECcH4G+XCCFXmA/WEHJK04+WDXyLC/RGDeAiL7 +Dhb9EbaYPQx6Syu8ocDmk4A/AUZyjiyXcE3TE+0J8tB4HWd+ZLGJvDmQsDjw156eHT1tQsYdiBkH +mvm4bECgZhKqiQQritZA4hWfmYTsHQlaFLVHErcocPFrN5HcbSR7UfpWXo0gg1EKJ5LEIIvhoZm2 +n0kko1BGsXwk0YzCGcUzCujGEuyCNLjwtMc+0/Df9ZOeeumZLoLLI598/nRZ98827W8+8AM/Af6W +mzzf1hYrWM2AAEzfrz8fwf4HeHuaQXwGbFpSq/EilhJgIqNJvsLSpjZtnWHVKcZ6G9sSb2K+bTl3 +uq6PmiiGpbUsBf1GoIKt6SLakOqcEW0BJTGREwn0JWgsaJdbVLduQBXr5F4ZL9C6P5qirRrwZRX6 +7sW3L2/ev735xz+jGj9t/g9DFVhpRkoyiCD6IVZQUc/FJ5DUwpLr+ANSOU46xHOjeC52lj8+/oB4 +bCKN/LseShrmL0Q3A7qab65HnyH8lIElN7K3ijYAwir2kAnRZEJ03ohQFZ8mQJ2Om0irCKRjzKTr +ygZ6cFtn3zZh4yTpC1s0btYzbN+4je9hY2+w32fSAxbQDVBP2MH2iupGBP3kDnYgNCXQEgnz2dfW +EjpvQDK/S9AsCjZYZndB1OuAFsmgZKN1cTI9ez9YGaBZT6JSL4OpcaStkb6zkdbEXspiV6GpFcUQ +0+cTvh7XV7Ie0X5kC/IAugIaAndiSbItadakaL6raLwbbRf13ckpu4mU3ULK7oqqLuq59FannbJu +2kgrPZA+yrpoIC00kwa6wgzZwbw6wDy7g1m3wPyLMBMzEFBhs2+49+9BFTgC7+9AUVhAaYigQmSg +roKCwXu5KYALKYBohuNXMlWQuspqOimDaJ43MtF3ZKaLYkjGOjwTDmskwyvReCVSfVkzRZzebHAd +2ckywQVzpMVzR92apWuB3sSLLfPcWMlSPpLnIZJavZLGfITpGEgPruJpUDcD9o6NMJqW/AVTlact +TeBFpjMpx2RD0rjTg5rFBddB/+L5yA6CSL3PZvkDtfRh0klZKy3oqyC1lBXTBVuScsrqKSqorKKC +kkof/qCt3EVHFxyJdW0e6h1p8visot1XGV4caB5y/sKJwJMC+uFHTNhIjBRLYZXJsB/8NTjiyTw2 +oMiT12b028CYTeS4idAukxbOK6+vunHN9fXGVibbl4NtOZFpGWy1dcOSV9tua1WKXclWJduUalXi +R9aJjEo1Kw9kVpKTAM1KetiuDMTZZNZloVVcxcrE1cyW5n46MzX1YZNzFrOTDU82Pdn4ZAPUP8SB +Sf754NT8zK+/VYSL/buYY2/hvWUiv14U/x7JR7f99J+KbUuVtqgiC726/5Nrb2K/BY0PrYkiq2Hv +VgIug+xcl7bpOOdlkW2GJz1MeZjuMOd5a0mypTSb3iea1sGmNLtIcCajrX2UGaxzV/adiSbszmbo +SeYkbz7ZNp+dbD5HktZ3ZD0GkdC8BVWY5js0QfdkkdI2BBvRQtZrJGu2kI27ktW7I0MYv05oLJPh +vJApjdtKJjcartl1Oq7kYduLrnAEUX6HLjnSJQI96LJD9pFUIHcer1naWEgZ2asxfjryZnD0rg0w +7ffmyFMXXhLzfhGD/iRGPDs/1f1ZxFaPYqOzE/Q0mWG+E3u8ijc0j+rjRnXcibBncd8VxzCx1Ee9 +kXwvR5H+o9elbLwuo9/lRC6yA7nLdpO5X1aYKOx/yTR1onlhFpzJZE2zL+ZIU20vHpkdybuV/DIV +bB5Sc7I5aCI5aQI5ahZZJbyznsRpcyTHDT/iqSg7e9rEUpX1UXPmOl/ufvDlqie3+3LVk9t9ubP6 +cqfjydy56svt3txm3tzuz83O8zN4fNjbMzlnzwVXzwU/z7mnZ/D1TOjsGdw93uHjnD70NOf3Ud+P +en941uXRfonmCgrOIbSoTWN2jT6n4SFOTfIPjs8nBgUsLPBQVGDaBgZE3dkqPKby0CQ/iXORXYs6 +s8mvONGkXmw6H20iN53ANHOjuhbFuXg056K6FysrcpPT5M71uJ24GldyNaKzkd2N6HAklyM5Hdnt +eKQZsJ/I+8j+R/RAog+ykEqVyBMZyRsZSNli0wjVbp7gPC95Eung7lgDHBz3JhTmQSgcVCg4vlXz +yaYzeWDsm0QIqBjw61/X/jy4aT0vxVnrGTld4KPnYhKnbSDXuufhXpy3bWBemroX1zjGvNqbgryK +apxNJWaFGG3uu80+cZCdYh12iccHxzahsYkWwfyx0Ji42/vs7wp/n/sHFus6eOpOV2f6ON95tots +pvHBsdmRyF1tVEIJk7jQ+4g0Nxo8FuxAP9Eo6BS2yTsykPTxPSssFuVZNvGdaqrLqITfiQKuyjeQ +MonerRp3V2S8KhM28ZzVmaHOBMWBmMz+VN2GtZuV5OuOZO6B5PBJLO3ZlBy2t7MpOqjq7CbTdXBv +wD1CtZ2u7yTaYEznEZUHpSu8hwUsK0387E15Ogjao0Ub7kyd0pfoi4JFLTA2Ke/U9+q7q4QyV9kI +mYqdbJCshKkidpRN9MQ76p3oZaqbdf0syDac5MnyFKexda1tZfNoon92gxLn1Dh7+pcFTdnAZw08 +ig5eTQs/bPTwNGjiezVFnSaeuy4+iTJ+lNimauPZ9PGdTe+7BzXyvUxpClVuVPLBFXTJGTS6g1Qj +V5dQnJxXaJUpqxOWHUOLaeTZ6eQ6sQ5+w5CQpcvukPyOReKPhTI8Vgs5Htn7MjgOEg== + + + OQ7IdTBJtseeJuJJ/EbqP+geBB4t9SEcacR69sdibgSXA1LFi7c3f4L3KATz4mUbznWIWrNf4Tip +G0+C1otsZOrNUx+D9zI0iV/vnHQT+VbvJhfI1mB2dz2MIW19Vgluqydit+77M62iS8pK1WUzBMrE +WdFdFos5Lvoj7qGJvg1imjJ4Isj2QuRS/o7zqmnqjrqB7sT1x04gXWp9oYXJ3D7lcesMBuRoI4Fj +4P2o6EMVRo9bSN9A8GtYZ9L9JN6ang3A7pnj5FbaQ9vF3q042S7MU5nNDpZlN8lmIRvFha1CNwu/ +Xbh16HcMFOnTsG3oxpHc5lHIXtmK8J09+1GMT+J4d+PuPPg78eCbD1/sqUtO/P1gP1dLgYmTqEdq +KZ0GM7ob0lXMITWluzGtoW6xeCYzqEeTWkPb52HtTUhbjGs1r/NkgRkXmvlAeoNPcCg+WqMm98Q2 +96Biq+XtFe2drG9Vt6tIgWyGOJviYrqoBr6IOJkt0q3b59Gegz374WEJtZvoG5nVPqY+hsN7RpVm +VWlmlYR9LPDjQj+Ty7M62J6te3hzOVfdWq+mBmSXgSW2+2Tme3AJWYvqGS4F6uQs+qPZ9d22F/t+ +kqXQ7Fnt6Rws9mT3pAsJIDDDg3sW98z92aRhnYbnOD7T4fxrf/bsHnja+UO6I4dBznP+LOPvgYS/ +D1o1k3goPm7gb62b0b4xG38yv5YuNTVz0pBF1D1ZarJuzdWF7Z7JZRHtzWNVnakaBzPVm/x7M4eq +xW/SdCGAw/lFPoQjQRzLNVIHgHcBiBNgEhv2JHOLfAFizbI9yw4BtmrVsmXbKpt7IHUnwTSG3TCZ +AGgAu9bH0dcSltUDUl0T/QBbZ6BTPYEzKDjwH8It6kBjQsF10VJSQV1maIDN5pQbpZuU1igXgExz +PHKU8tzwJRlGJmAKwMK4LUWhxdsAM6ETelWskuMSYGYigtAAF2IMbV7y0PdlqQUhRZkQsOs9z+em +hNsI88SnuFwTLVG6rIBzQBBKARTDsGXoK7KjEXI658PYYrvFbe0mJkwAcpReFy1R+uXTKZVbShFa +kDkpXHOmblFzCsxa45g3tYQ1DVxp5E/CH2rIiUZ0RrYoI+otvAHTlpbmMmGui/dTEmKev3rzko49 +WUbMFtKznTZHBDAaxgcEDnZAAI8H1MGAvJPjAZFC9qUfD0DDcepx+42FcRL7Im5CapeMeRdUm/JJ +7IutdXE4M+HVtjg34Z1/arLk47a15AfXVLczvG9q384yjqeLFofaHD1X4tBtfZcpcZYrgX5+dVmp +KcKOq50EDJzzymySbpWoZZIkOlEOK+oP7L46SZCOHVaFLIydOKhkKgSZDFmzIGRC8JmRWU6N9HMj +K9mlzrugE2SSFOcsLgY3S9wZkjScItlmJQTv/ZnMJn2U++eiYbq6nB/yFJzMUxBctk89yz04We5B +z2dXp5BNp2nr7nSzKmyyDbbZ7EMuuyYVTC6ZPW+sWW/PnpwHKThrduv5PE4U0Y0wL9BeRTv1SM7G +QBOiHtvHpsI4GWZ3iKhPB02DP8pkmKdBYIyToXubFpeoUtTfZFNimBTTAz7BcVpsJ8Z+E6XviWF5 +upCnMoqYZZOiMiSEbZ1G6zxt5Y7NFC96Lk+Wi9NlclkpZ2cfBj95nyyj48N5ytHtgZELnCM4O1Co +nCTYn2RytL+dBJWeexgeyPaqdpqLznGdz3BOVzs/JBfNhSqJazSRdfvD6XuYyL+2kCjDfY9l2B1M +00h7HeZPHWFKLjAVMYG2qesM5lyEubbC/DrUE0ymCJOoYojosJ6A2ghzo8J0OMAEWGDYC+V5HEES +BJAAlcb1BNtDoBHdYaqGW+orSP7D8QRWeJhg5RRKtzigF/5uoVS6AjNyh46rOzvV5Y+ofc4BtcFY +na55PA3N1Onjx9M+lHRnhqnFn6eLcTg90uLjcP44y9lhln6SZbpwlOUTD7JQ+JODny2uk8U9o0U8 +T3RkiPOMVzpZlGGSUrYxnUU6UcbxnnKOVzrUxIee8EAULKc7Ord4oBTkns6bKL9q0ezip6nwNBWe +psLTVHBTwbmr1jLP5FsA7ay0RjZ5y0lqkZD9eel8y6d9TM6wfNrJrC851fWJJ1O+evun91w36OYf +Xn335uV7Onh0CdrP7CsPJuXBpDyYlmmmR9j8+JaPHBA8J1PWW9A6002Nt6DYhk8amUufpyF6zGdv +S15Cwto4ccEPxJt1va0xtE8j4WE0j6ek5c+bmeMnP2Wi/P7Nmxf3L7+9+U5AN7DiYKZcBNN0FN/N +pvrCRZv5oovlAZN5OrOXq52R8afBl03OxJg14fImJgvpFpc64VwuLqzbXS7VzOKzVKCtqyWf5QIN +4V1xs5BR/LAx42tHnNeLiPJXi0X0ohEFa0h066FaNQg2knfk4TmQKdHLQXAxCPoL77yTw+h4Hgb/ +hglEbrAT6Hr2nM+d46nzyufOyQ7Zkbjuh8xPdsA8yCFzEO8TnS4vdLZG8zw402NP9jcfLcf8Htgj +6PiIninKDxwdv8aW7Hfk6Rpbst+Rp2tsyX5Hnj5/S+5nl7aFK7ZlK7ZFK7YlK1y9imlIcHblKobU +5tmifz2neT8E7TVsXyYXuXex+yF634+p784C+NsQPtUKOT+c/pE4PifKs045FrG4dNb8/JB43kS+ +e+w7TpvwtwuBnwXBNT/9eDESLrHwyQXDezj8PCDeQ+JDUNwltct4T2NY3AXGTx8LjI+qFyz9tuYP +KTWwiS2tzCvHpkDe4A8YOkkXtaRrIeSoWwP5lSiOt87LZWQB1jidEi/6g4ShLiuN10P5ZXt2WC/u +2QD2ezaPLenRe9ssdpLmRUkhchZJXVOXjtKGfghqcr6tTzpZ678u7Y3s++WIEMWDaKNKrlQUR4K0 +TFST5EF05JL3ayLVZC+Rn0DloHoxKFBISB3p8Z4decHYNWvHp4gy80xGS7bqR5B8ktXJ8maXITm3 +p+eSfjJJ2GNniVSaB3vnkl816VUTXn2i63pqY9bVJ1UHulT+Z1MIaPqU+j8PFf1hUfqZZvgFK5w2 +/OnLd3ypSuKSzg+W/L/aTqp7qe6mauKqkctZ/8Xs3DixqWvGrpq7avCqyatGr5q9aviS6bspHJLL +3IKXJDXlwPF9tRBR70ephykIC2gX5bKt+aWYRmsXVtSaSc4uC5bt8HFlru7hCmjMBHqwpsS1UH6Z ++IwXpWcc69k19dEPjxx2cj/75zA8PqfrOI3/FfXcPeMit+OXcUhCvXTsfzz4Pxomdxr3nez8f7l8 +PMG/nqTMhUo3Z0rPJzzTqCWdP7ROR+36E5Trz/V2+fT1p/3yab982i//0+yXMYOE8FtHhgXu87Zo +O+GCTvBLToG6uF9+KSbeL79s140LgNZ6tV1c8f2t7+Xp8mae4mgK4ddT6tlT6tlT6tlT6tlT6tlT +6tlT6tlT6tlT6tlTkslTvtHTVHiaCk9T4bNSz3DP/aSkrgVt4vYFWWGC4LEZRnoYMd/OeOzrM5Lf +9KNfaKS3y0Z6c0a689iRiqzqMekWZlhHVzOiG9WqCXO5CNF/zSwirVcNaq/rspY7phTdDeUhfBEW +VxRxenwl3v+82iXnKQX5zmYSfN84Vz90Dch5Of+P1uifHqjF/5gYxHlQAeRBT8fYJmWcJWfwtQ0f +87R+opCeHvC1fraInh7KRToX0ZwR9KHiHMGyf07S8Q+U52AmTMNZ/6Nl+pwX54hDncs7S+3piT2r +cqhYTs8Ha10+IH6BM2UpF8Wo5IaApKt44pXSRpZc2oeTdL8Q4ehzLWVe2I+7xtGhayedEx3JNj/p +RzyuX4jwy0R5vuxvBTDexPnkb33ytz75W5/8rU/+1id/65O/9cnf+uRvffKsPDnZnqbC01R4mgpf +5m+1WzfWzTDqIOIQXrol4cFDRtNwK8J4E+Z40mi8CdNf4zYcNZounjVKrmzh4sqF+js5tHqh3skh +JUInV33fT5WxhGH0JQyHGaNzxmbM9OCU4YNoPFt0rnxopsg8mWSi9GnCiX/jNXR9fmxnxzg3YGZM +ODFoVuic6DOCcmjZSddgNeMkCJL8iGsYV3CG4V5giLV0fjs7N2YeJudf2k+yhsfLVPLFYq9jodfd +5RtVJlnmD92ecD6Kw70J7hYVrsu6mx661HZzra2O66VDhoM0mB4UBzjMHxcHO0vyFHkwfUQgeJHg +hcIoFkQw4AyYLggGJxpkKojoxjUfaOhPtKxx4HHI6cKEC/ct+rKiwzhPF4e5L9Lx4pw+yg/ekjHZ +UPuLc9yiddcXb0uP8nj34qM05tNG9m+vyBgvyViG20b2Z1sBjP7khv8x+4HbEdxdGO4ejGmT5Xth +Zxj2hnF3cPsDTwQ8PHGQUxcfmgqgMqDCsINBKKQoLKQkHGD0V1ghCRSDGZSCAwjt1cmPE2wfO5pC +Ad5yoslTQVIE3OGPMFdW4G+kazUOMA0qDHwEMvAKjR0MUYaRXOjGjB2MVwaGLHYmocGAZBiIha7E +2E90G0aG9bYAs3mdoShFBi/AXGQsslUlKDJTr/FkDnbZSbybjHV8n+fANMeztjm8cH5gQc4o/A3Y +5epe6H6mDzkc08a/1L1Lg2tpeqSj8QNuxtEvPX3ehRIX/dPkWZw+cJ3EA5dJfPhS0ekDt4qOl0i4 +e0U/dK3oJBdHiMuY/IPeaVzVbSyHPu7osEegYx6ZjnesdMXHni70OJ3uJrqWk6/izHQF54q+c/Re +4+0i4l54mgpPU+FpKjxNBT8VPqt8VJtvl7l9XhaNfPTzykiV+TbFVr4gbUgxfGLe0GeVy/rSAHO5 +XNugrB+qR3QeB95cK0N+8Q8srekja8uvru0dTn6BWWR4ciGayxWJLt5Qtong7W3lnSYNDLtwzBgX +Po8Kj5WJNjHhyYJ5/Saa1WLCejj48LFwzTL8pMWNxjJH/L/Q/zfJj9G+a9wkknpauOaRKKyF7tHl +eAr/tEoZpELncuke3d2mJtK2KtLJ6iJJPSSqjKRVkfh7L4eUJqmGVOkalZ3UQtIQJFdDkrg0XQyu +9ZCiVESKUgwJrR7U3XcTxXJ2VAdpT8YRhydnqYOU6Kakp0pIV6iENNinj3ZQiHvichmlz7g11tXR +OUy9opLlVm3vjD2/MXY+K6xkpZWmzV2x/aZYX15p8H1uSiyNRZZ201mdpbHS0mX/p1zuOpRbEkfa +5LygrubS1qN2qQbTx+owPVSLKftiA0MW4IdqMrmqTJfrMsFMmC4UZ+pXFV2uz9QrNF2o0TQNZZp8 +oaZLFxgtvlLEhWuM4JkulGzytxnJ3PvPVMAJpMa8Vqq2VENaLyJbOPluvi1BUt7WnNocHsihux7K +L1Ny1nJRyQHwoy/M4JIPaqNcslAoIeahxBvNS1Dj55IJNBhBDyEqZkkxum1CF6Ia7Kmz6gwfi/N9 +NMr32IDhR0OGDyH6WOzxDNW4zGBn4wtllhmUAbouaJ5LbcOqoEQhyiuVScdXzFyexw== + + + V8P4H72w7dkaCRfzT0McFs7HcisvlvZ8KLUSxngatOhRjx4vchwTKrcplZZQOQ33/xa7gm8dqqeM +9jBYw1wj5zz/q24ST7cGxtbEGIyMaZv15XjkefXoZMHJZQuWgTs78QRw9lAa0wWpcy5Zspd7HVMm +j5Yy+VDSZJULUXcYfenZcNt8uMuJk6PhdcaSaUjJrbvt9dCYJrVQ54t0GScBd85lNm9vSNWUZr4d +NVBKV6UzLkc538KnWzB5+URVeFIpE3RXTrSAaRTpLEsDPp2IMwl4sdK5lTvoLJnt0KkjdCQA9RVo +3lPGHqbrrUTn3URJnAXYxQmcS0/ghIl8PN6BbIsg5yowZQ8SEO9ODneJR+6TtPuPK/fTB7X7jW7/ +GNV++lg2wuVkBOrcdbuGOccPd+2C6fLx7k0fT7a41D0euU+0zD7WwelTLbOPdW96TC7Jefc2jj58 +I26QoKq0kqieTm2Bi+jkQNV+VDOdA3SLNtPNZXljoe5rYeQL7VpcCAmoVSAn8BBHht2d9nbStW7I +icclRRNiw8bA3yXWizvztRB+2XZ90Zu3LVQ66rnrmZ4bqbgZao/nvvht6vcpzpN54S9VLX/QR+iK +njn/oNd7ve7rYwg+juAVaX+soevAMHUnF1pwXRq65bPafZzBxxoo3uA9dIukIUdzolWxHNrs8+yl +BKHUBV+kLniy2EeZRF2vVgN879LvT87jFehvMoqzo7nRct5/ssr/Kal9dbpmYp83ATyNnkpPp6fU +0+qpvfOnCv25Qkf1QLen3NNO1HcKlYsjjRsqN3TuL5wFpKuTz48C7i3jbjU3lR0D3FzR3WkGqr/w +lPQXWxfzbQRViO2jVmAR4A+l5bHIW8HTcitJbbTuMaJB5couC/urYfwicRrDJXEK0C+8Z/Pk5M7Z +oarJBTWrVI70AU0Rp1962mt3dsBnQb3moQM+Q7j1MceLthT4UG/ZnDcjCqYzAac0KBV8NvF6wu1C +pcdHCrd/z5zpx7z7k98+XRKS5+/f+DPRdOT67DBotFrBrFvGKop6ZXPVu3A/uO6vh/Izg7946XEO +XxL8FQxfJnguul3iWGXxUYm+lOb7qCzfRyWLPmC1XUgPfEzC4Vnm3EPofGjuMckJlJrwqCSV/8jo +vE8TJWEid3ludJM3cjAMh+bFb37+g7/BqN2uy3Ct+dUxf+LCmz909v5TPv1FCy5djBCkCwEC/eqV +p4Mld3KaZ3au+iKJoJwQWil+vqp50KPovb65hA43RcvvLHbOW+kidwstFEVXz3+cyPCJssiKLLdi +sXW+bWiV2LraGBxhP9Bi5d1YY+2nScN33E9+WQhSNJi/opwQ5yeTJOJAPN9MxHcT8T6+TmKryH/p +u15b1OjiIr3AiDd8tsAOcsZ4/E6/m6zJ0f3bn9OF5468H0OgEsfNazVx0OWOgy6npvHR6n5H6fIq +fWB1iZSl6SNmsV7kdSTP4wPlE1wuWposXWabiBbJJ6lpMtv6OvGh+jqTJaDlixV22Bl9Ifvsgdyz +3SSu+Ds5ihw0+Uxyzw5So7z72j+SfTadyVBNQFNJqrJUpSnLU5aoOzLZDiRXj36MVXdNdn54tcBa +s3SWoyWuLIMenS1fpU2ymEyVlbWiSr4mp+gtXTunVZ8kK8Ufm8+ab7WS604nTjcCPpzXqL4VnUrw +d7qQhLXNcBxzsLY1OXRiSe7VRKlXPbeR5xW6/k/k/w40oXA67Wgq8UQKMpH43oQjxS8CTZ86ifO+ +n3TGahd60rnIOec7kkroE+djznfoD4fRbjDCRy04/7dz4v1fHeHywEMTeJLdTV1c6uhKZ/vbuK9d +2tAOeinHuJ8tbg/z8WteYH7zWsVkZLNxp0bQ3eYqgfFmAJ/bMma1jNksUtBqGjJYhryVTb6Kv0Fs +TE8Z0lKmIR9lvC1sTD8Z0k6GdJMhy2Qa00sotYk9RmOCExtymuakiU5RNsWlpztNkvF0Jwk3R5f3 +xG4mvViOk5/Y5TSmQOkxUEqEmoZcKM2HWnQWyMicXF7UUd7SD4fKAdGng8l/+weTr5ZLctmZMY7y +Z4/z5PI5v3ykYaynx1WU+8BYb0Z7+qzY4QfGe3p09PCjI76xZNc6LxgMaw02k0DXasBOEFdy7YhD +Z5YcmgUjeg9m5Xwppv902TiXC3tiXU+zUp2nxHZ53cJ7oZziVN2d2Zsnutpotr2Yd2JLzJ42OdmS +jU0qgmZhJ7KE9EraSrchrWLb7cw8EyNssmzsSJov6b4011j15VpiOwrSH8lyOpGKP5P9hAowqsCJ +bsgpWJRnoiQO1IV3NL+PUmWMTyRg/4M8iar2oFKMajEqxiutFi4vpeox3Zs8k5bMlaa4zhSeWMh0 +9JcLTflSUweuRmb1yBY5w8BpNnmiTJt1yLPhTBtc9ud5NpRpMxqm0VztPHZqnC40Zh8+SZV7laPp +4hmqlRJjdpcCDtvTU3LGIwon62T26gFZ5ywLb1scHjg7pQenhjumE2XVjFbr0e6WVrMVWfmRsrCc +OzUN56a85aq3sx2HU1OBMrsLZeicJ4mB6ToNlusqF2lddv+x8frx67Ied3HWg9dpTR+5U+viHVsf +es7v3/rQvVuPuI1rulC69jHFbB98pger3X7sqZef6aFfPFAtl57RIlHWau+VPkWhVoeaG4vFjtXM +sET4T7xa+uHLpdFWmB5zufTjr5c+5OnC9dJXuGD6M6+YlsMOvoDI3XShuIQvL7EtMEElJp5sj78l +2+OBDIkMHIgY6GgYIhtL+5ZUKe0gqyKJpX5TfUAVvR7K/3Q6abkYOQHoxVrzpNDwhr4zd+HlQ9CS +D3xhM1cP9JFSxR95BFrvzKzDZu5zvukU9OQc0d0VTRu6bOmLuw0zi1datnbzTPPh6BMK84l9XZz6 +2avPdre8JlNrbjlzZzzAureM6jt/kJXrHiVa04VWd6N1vqMVf9hkl0fKREbpUCgfeXN7LcrbiZKp +xSUrKdXslz1IVn1nZSW9aMcVKcVTy75a9Nbu+RbRiR22/2u7ZHkz+ViF/Q/f9Xt+ge+F43Yfrrx/ +4Sief6YH9cqHvo4PPOJLlFN81PtPOdv6mH3n01LEH7HrTNfLn5aDrVIziNb9SocremWpcKGa2MGV +lqrSnfPSUtStiYws7Bnvqdw/qzBFfeRe9hpj22tlubtyseyEfd5UnPJ3y3Lvh7pTwoOTRF0318tO +HAh+cOPFkkuY/txSXdvlXRIL/WM6QuLK/x/c674Q4bjpNuglZRqueGpFEiF4x266c+PNqpQ0wVcA +fEQr+FKMX7RB10v7c/3SFMan+wOe7g94uj/g6f6Ap/sDnu4P+GzF+N8W4dP9AU/3Bzw5xZ6Kxj9N +haep8DQV/vXva318EcPxnPcnfew/nb+8XTxT2DZnCk/G6L0V2dtJduW6KS9d7KdLpabp32nI7vxc +HeuCJhjk6DO6DMhhIIWS0AhgNUlz5FlBapQFciRNn9SjSU44smsALb0stTg4K/7kjolXStLYW+ay +5S0TZaa6Rqvy4qu7qLdfM89nCeKr51+z0Nn9X/EoINvFO4qfHiSsf5LQ/myxgB4N0EB/kbTPjwf7 +PxLM/1jc/jw2/5gY/SbUzvL7M+X0BTFNQnr68pqJOzY9NpXyRydmNvmnElBl4GHwXxYThHEa3JfH +szQ2lYkqFbeXKJBsfMCvCTN4zXQmallaHgqzNT6iaHeEwq8I9DHX4RejZAGZyzzeXQofCK14IYcn +ubBEHPyANSlCuSwuvxTTlwnPi/Ut2ljfwgqCqsBhF8OdHslxvibvZxoPVGzKRG89TJdKRI9uyQdK +RKOvYDKf0tY3aZ6kUW5cKBW1rUjL4bzdhVq0i4RHe/2sMll5qJ3zI46x0uRO7XDEdEdZIBY1FSlK +8nOiNJJMsT9OhWqWDCXx07FHXyRhLh2KviBjHiFhHlYDp4/rgXrf836T+D+WLN0WLb2UqHPaZviP +hUvXTV5/GpJ2tmk7m/Klk8vhb4eLBUw5RrWnWanXGPVo1TZexWrsw5ehSMxq0qDVcCNKvxOFFdxt +3OpS5IoVXqlzhHLfS37WfSV6tck0jvMyhIJAKQnjUXKNvjQtQpnWAOLhouS7DjouPoQK2iDL17ps +0kWggyDOb9wp94CBq4c2jOuh/JCABsDXv3r75jfvXr15/+rNd8+eObntfzH96nv8TeTf/ObF+/cv +370Bgf7V//Pji3cvf7jZvfnu9ctvQZZvADfLcptSXeXfeFPKLUb05N8IXf0Ru2u2wB/+Sv/9v+HH +/wHAf7lJN7+8+ef/Pt98S/A//Bb+2eK8dzDBe/McYJt3DTD97PML+BD2hl73axoKsJxAv6Ac9FqJ +zWleYcfB7bAW2hZnnhdYwVUqVkXOBfrDC3wBvBTruuZbMDQT0ysg/pdeSb9tFyDysefnmBD0J/gb +VixgCVvmCipDrfQGhcV2u7Q1DB+/BNPPPr+AT99DnwNOZegoSFF6j8LKchsb2Hn+85dg+tnnF/Dp +e5Qm/bznWA23qdVFGNTmuV0C+Tdvselb6GOl+GFRkBsE/tQFiBuDDSZ9AXWrJv3svQN5zioXLsH8 +bBix6UuIGpglOqb3DsYfacPHL8H8fNjiG7i1GROF+QHQz1+C+RHY4tP3gKALsC3gMstzhe0aY+gR +BBvL6oT0YvUgyQKQgmsgvfkHWnDzzW+5+kiA5cmF5GoaSyB0sYpKNyvksC/S8ZMVV/PNH3Zc8/jm +X/xM7XPl0rBdWkwX1uwGG4L+yFK/Zi5M28krYRmqJCUuQ4teFCITesnmAvV8O7/uHxj5YTVuYJ74 +S/OVSYVdfqHadyFi+OMib2U7chYNSEegn2kdZqlIk0uzR7l1CeYlxxZfp7WCsh9pf6wLTy1olwsx +umGcEwW2JmxkNnGokgbuqoMId0v5kjDFQlcbmSsgt2ovyP4/Xmnib4Wxn6cVhjAJW0yYXoD5BXlJ +uF91+GkTBdnZB38QtRfEoILkc8/PMF1z2Df7gd8i/BhfkqMXxPWF3YUJTQmsyLEWWsprG7VTLYG5 +Klcl74kJxYF0FNw7GK+LdC6JNzBP/Raf0rrVKrym4XGK6nIB5DFe0lHwLb+fTqxugn4qyuZn6asr +/2b/7scf/qx4zN0Q5p9N880O/v7hX6Yf4Rm00Ms6KGmgzxLo5rf5BiR1wsqfC3DhGaiE6y1G8h34 ++QgO5RYvJiSwYrgE6x9/M6EOihN5XmjsKx4Lw0kKFtlKwr8WMBPoQCTuXgixAvyLzmOHGg2LHIjg +0GA6rjkhON7OAT4DwDXfgu0nZERY8gCr8bbOc3WkfYOfL0gPTEACY8OlwYdb8w3/Cg3B0AKcQHZv +uNRtw79gwzkDxpD8y2F54s5cBio9r6VHh2loi/sV4L0ZkCKzG6jpAwE6At+MlAI4F+jc0Ctt+9ex ++72tY5W2xY45rnYaHP87tduBOkx/mn4/tZuf/uzmD/8IP9GkhlUwTOmPzXSC3gD4Jg== + + + DFP+0RN+BfXpdl1BM1nDXLA8L835dV4jionmwM834HBbal4J7JE8ADYk15r5hL0UkKCAPcFGkBNR +vsDkIkhMoF5xs7QuiYEZdtSbkTJoua4VpxmDI3cPUYKZzkA0wxmIV4reXHw5DihyCNoUpSGlJQk/ +8y06qxEMP82wQyGw8KTktjEWAtZbPC7NwLbAWjgQAphJ6BNgcA6Lto1JXpbncMMNF9y3CVZmIJw/ +32BHnFcmYKGJus5tuQXeB267MsNmmL0ZGihv0soIcFLHJMSGUgrPCAADtXXgDuzBsKBXYW+uIQow +LosSi6mzjBfBURkWW5a2IcyCNc1FEYS1KM9RuTUEudoA5yBtYeONimBVIJj8SsGa5PPpFiNx0hRN +BgF2JsCcF+CCbgEmYJ6DIYDVL1wEpasKZ3DelCYch/8SinybwiwzLIXMHC9AgXas5qwdAzB2nUey +RUXQUlZgSlmBTQnrHYNFZzO/1cB9WG/DUmQegahlpDA5gk4OEFjy+QYzuwitLQkPGyqG8v6KE18+ +L5ML18Vqn8eMKZ2yi36+NP48vCqELMCGjGdgXRdejjMteEFQ14pzHoGp8chkWORxFeCaShVer6EY +ApiROgRLYym2zAu8JMrrUhAUC6qfUXtL3EZgmrNQG2HBCt4F9wVZzfM6d7xlnYUKKrvHQMz8EoaX +ysBwi/F67XAJghfAKUnfFli8gjdAR5PQG3JbBUXCMWEUOVYBlhh1lYdoaMv4NkYLqxS3qc40BkYT +gSSzBQiqthDA0o7BsBkIufOyFiGhzTrAS16DIFhSH8mk/UXpoAMBsoHbwrRPuelklN5WkOJRu5CL +DgTs9qnoFAu1StuKZdyZ4yjcBbhWXWPFIWhRBc0amYAVertKUyzZKUDQ3PVNbdYeABi6LOBVZs16 +C4yLZwjQWBIgKC+GgEjkpbOS+EMgqDuLzoPAg9BY5nRuM4KGo6gDxpsIAZMu3RW22htrKRRU+K8h +iNE2nAJgBpZcqzLWgORvZQqMBQCdgy0cGfCG3FR2LUrUmnTTXRedRcvMU52xNp5FAOxykkQiA0tb +ldm4GSmCDHRpW57cC6zxZLtNIDmFLcEULMLXWGhmLLgJBhV+GJY9KAJ9VaLtkkA56GSpBuuyWzcl +BMdWdCVHFjEAbH29sOyDVwP71+ZoYgQBPc26OBdWWxAYdL1gvObmn6Qt2sG60wheWHIh2YRdBQYC +WdcbShp+V0QtTFdcsc9nZIbffRDYd9BalmoI2hx1zeMJGgTCx0IwRYZUHgTGWuVVYAzI5wFZVAJA +1eZ3wY8tbFmYYTDX6EQhIwBkpemCQUHPQFLZebjmUgSY5mH/UgQlrNLbnJposPi6lgUFGbzyMrRR +RMNaDG81jWXRxYF4F52yst+DymVatKlHCFxg/qh6ZKwtIHdU0cQMZWlb52TyQVhbYUh1ygVb3uiT +iKtOulKStMUTOsoa1pQRQVBNDMPuggAkZ7JdLa2yewAY5JaCS1YUqiuj8C9RgM32mYC+DsXbapLF +GLF2PAJBzS067bEcsgBBGq66rwbl7YqVhbIjjIE1KWuyDBjI2HnV7Wupq30eFrFyphb9fN/alxSU +qhptA+1j01AK6roB5t8IEPZ2RTArMKzVgCUbgj7FxQ3L4FSX2tUxhq1hiY6JDCxBhzzhZq1o87zk +zdBA26qqAQxzEmCC7UeVqWU1BGVROZFFtwBgi4sACyxIBAYsAK47FSZYMIKAZ+bnpAhYpgcy5IqS +xXtKwBibqjykxyuClJqwQNRcBK5R1bkqXQjLbUjK7xX1TUYA4Mw8gNUWeN0AEAwW6W6OLCYQGIO+ +Kuq6ATBmsglha+MuBLdXiEqNwJxUpoHtKqMA4FR1s8krS2BsK2ZcNm0QgYuuBLyhyhCQosLdRce3 +ANEGZqzAIwGCWFYKQMAaghazzgPRR0M0pRp9FzkLMLSUlLOqnAA4rrrwiPUCjLpCiih4iLXpCilJ +FXAAw8+CgDqDwOSENdktDOwqD+wQInwQLMoFUMD6XcjogF54aJdowFiDAoNyILsNU0IyDE5RJQdt +YwysSY2QxiIRYUU/X4OhLWYyao9g01KptbLYC7ikdQJVU5cC6tqqBNBcYGBuTaifi0x33Ot0GVeT +m0iTyVgjHj62FEUgqjgAQ1ZNekUjVqlfVpUaYvUTgqy9T6LcEAKbbKYaoatr0UGxOVhg+RadASoe +iunnmbVbRbAGFcgV1e7nCo68OND0ZaUv4LZWPRcYOMuKKV0TRSjKmr6OGJjBopGJITYGACnixEhT +WQxBMgU3qdcLwbTNM7jKLK48qOMwVCelVxQaipf4LKteeIMbqE1tdjEQsCbrrW5VCEZbnTpBAheB +YMqnPjnnKkBdcTKTGMFqNhFObhEFsP2kpjJSLC0AJltxtaqKFpqzIdu8KgK8PFNfVonhcWaTpctI +QhDpUk6lIDK1cTZHka05hC06E9egRix+vumWUlDWMDDYwkOHmgAppiWDoAIdwUWdHOvCawyANUcv +uxlIHjbZqHThRfQQNN0VcWkLcEk6ipHnLAKjtmxYtV8RxGLbKu/rAFOXI4xsydyDQLX93S7Bnw8g +dvTzqtACgpp1R6EhYmDDfV/etNjn8bSiaCFiJwAwBQWuRaiCXUZcbYg0RUOAOWROyjwXMFigunvw +VhthR4lRZ2xkV2rEXUJ9A/QRRosuQN1RmuxTAOy6DWmjDMxi7BYM9cnyiOh6TGUkAFWnIJM7sKMK +gWqu+40Swc2626oiqKbDFDEWAYi5czqJdJuKKKqj0oW+TcFaVJpgRqlRoPopCnNHwWKTnh0RiHWu +qm2IEY7ARWnFk6aGoM46Z9XpEVG+m0AUuYNdqKq15qIaVwTCV1WuYhJqC8fxWHjWpQlQPRm4D6o6 +juA52rLLigCmlFIgjggAkqUs0yAqD0B8N9lVWVY8F3ASvbOwV4OBYVWXWBVPPQJNnaatU/EmMzSy +bK6x8kCLhsqaXKx0Q42bc4wAfe+mTwcNb8Rq25Vbeavz7GUxKgAYoqpBxWz887bPFWyzmfzJDIxN +xad4uRGYZ40qZLTtFG/XPHVjQBqKGhVVXF34KnM40pasCEJU5jSK1zEFtl81Mc2IAluQqX8ej86O +mmtEK0z1bFV9AdhdSqsZIBg3XtShUFdW1BEYk21tMuYAXKMqPtl2m+ZswyZ2NwBTTtpWQkERfd+p +nk1G2BvL6tepYG3qDm6iCCDQtAMSoIZgmdtmhko8XORyM7KCCuvulwNwburT1vFqppDDEhGnDADr +bLofWjX6+WKbSKurElBsF6a9Ud4UVSE31Tt2dx0JPZmcADU1j+SMgfuea8Supuc7Fna3AU1DfRmR +OAjQhCk2wZt2DFTPYGFXDyFImGOVREqo3Z5m5wxoOCMZuLa56ORWnTRRSpZN79a4Y6n7EftMBGBA +PjFhvDwAlkITPXMO6lgisG6vNGUUrQbZAMxaQ1q8jiZ2EQDVSYF2jRKLCsKsHWNRCy1b1o2BhCM3 +DMGsDVMHE0aoVe6w/wlA6q7rpi0A1QQR5Vk/3sxBYXyN5qIv7EBnIKVtbjQhBIt+AsxSCgAYdH0v +6I1DYDKdvnB8kRGgB9u43dg5mERpJ2ASp23KFgVDU0E16oQzXQdbWI19UWdIVQYKM0TIr8oBtDxn +28JY80VgURs2ccALgWFRT4YtLoSaB8/GujfFTrE6nHBNm/1SVRkFcAqrzHdgNve1mjo9ALu53HUm +AJPtLIwtWduGIMAg41o58sXjajEwbGp7ZRODEYC5LrZxNEVam7liTESnytq9veu5QN3M4BQ2BMMW +nLtu0JjfCFSrOckqgK2rVsVabHUDeNWmKjgBGGeTpgvv1QhMi99lFEEuTfHKnppWEyVFQ8dLao6x +FBhmBBhmMeM2iWkJ0CThXLcQGiWFKWdkcjTzWWzQqu4NfRCjIs82O4v54zFvrZiXCfUzQpCxLLuq +V2r452AxuMLOaAa63uJKYQQAFqsGCQuRe5Yj+tp0xMTPBG2byYhcWUZkDA4uirdqaA4RFDUuozif +MpoKSQVSDQoEnVI1RPUGAJScjKJasEKbMQKSdIJLXAmAFS2v3gNFoGpqYQedIBCvTmFzkIGk1Yng +UZsZwaJpOy4mi9cBBWyrAKx3QOP3CCVntfC76cdplMcOJHO3ikdMEfSVSxvWcwFreLIvUuys+YqK +aPpI66Ku/+65x9c1DcZKlrG8rlh4TmQa4tUYkEST8eNFYy0rOv4PD38cUzpUDUscaqGGsxm3qVNF +8RzuAWsb1FWTZ2JE5sT5sAxc1KuVs+2pRb3uGXMsdGradEt4YMQ8GbHT38ypWHRmZMvG6Y69jKEv +pbRvikRANeOWxT+2naOuLrGqcnayIJkKk1FPU/02zoZAp6BGirDdsujSjLojPPRxPAImr5IIe84W +fyp+BNCGUCGtSnfG/WtdHK0MDIuSRa5TRlAs6FkscIFYVxMk4sBDBI6FS0ew1Ka7okTLAFjqbIJE +Pw/KihLQ50AxJQgNV/buIrCvbrGGAJijKt3B9vWM3VEBt4g/KVcLCZVb+XjlvJE+Mfnj5OxUiaH5 +HwBVmnQJoKWrG73GzgAYnZOwGUrNsSiaeYbAJrM6S0gQQUkFy1J0TqwdHf3XXGuFHf4MDElnA42a +vrg11TuKxG/di9XZlb0e0H0yw8dj1DeBQJSRUI8K0hR0NvfIAYKTSnoUB88F2rV0jX5kTM3I0is1 +5BFo7+pBGQQvmtNYxa+FwKRsUdGzWlAeZbomBmS0gtVOWftuCUpD0rEzmbzyPi0jz34xaAkzVIFo +MyneVoruC031JmhNiQbCRdkuGicaDHoP4rXdbjFXPYBB2OqSnNmFlDFAaf0tRhilV0rPVEEBcJVU +vsJ2FQPL0je8LDD1DxQXrUC0ZgDk5DrWLRP1ydO74kbLy2haFgM2oavMTk3TnAMAxlUHXUJb1DDK +QBb/+VC0X1Vc8gBMUbcWtawQqbl4k1owZXaTToNziLSpkkiREwZmEwp9giMCmzLqnyyzU58lpXQp +C8fiuauhdAqczV40sA+t52LGbUkyQ4tPsVPVDTFj4hjveUrvwhlaK3sSdXvBtlU95UGcQniOwDL0 +IqcjIjBFyziwKY54V3U9tBIUAQ6xjK5IbABWE11ms5VgPiE3YsGpOORtZaD61YYp013lhdVQBpas +AqHkOQlQg2FAQFCzHdvakJFPUl6WdZU32fQKZtGp1drdJITAJJWknhRQf6sOr65xaEkRgtUMC0Ww +xkX3ncW6W7qXVxIBkaxkjgeL6GLbkjZuAmy7qJ9Z/ef4KvPqE5ARROdM1YQWAPb06Mp2J8IWdYu1 +PgsAPJv2Fhfld4vF3ClseeObslrOKIL082mxzzcOXhafyajhsYJavekNFq0AsKb/FI4uCzDpJiZp +JwRTMdtjeYh20Y2WnPLPBZyLSmo6SaBgTY0t7OESFBJDZv4ni61Joj2/KVlaLm5Lig== + + + EXOXdQNRuwoxNrVDWUUpaBWp5hcsZxM+rjzRHRxfH5rTWuTdq25/5LM0koJqg5qijxSJ46twLqIg +bWborK33KZgzwcQ2vqyak4bj7yVx+JJXgOabI1gdOsXyU4vkaY4rILm10lNTSuaOD7tyyeael92e +gaUqU4t5zxC89J2HI1MFlS7j4apI16LjF0xLLpnPp4wyPrvgSRKPFvZVlgVGdzRbjtqqy7uI6wfa +gp5vDtQOtABDD4gUsdsYHNZs7NL4j6jZCFubNHRSCHNlLQlc8otKNpW4J7WVbLu0nJvQHqgi2FO/ +EEFPYRD3HwKTpjA4KZSZcwyOs45XzxPTbJVSnAZFSQmMACePRe9XEVmFUzVlO5x1ZFo2u9BSpAoO +U1PCJPEXqxhYdNAmMuj1WRnbd7PqtmmygBjofPZV9pLqdp3uAQWwRiILJ58xMCy2xa2LIugusWwu +MUSw6jzUkBS2lRytbq8isJkrB0WSIujR3CxJK0jt2raivDovOAltoyCr72op+nn1NvaUAAQuGuan +UC9/fuUo9uqdHqVa2mhPRsWWthCCZUUU9CBmm4ey8XXLwVIQS7P8HIkV8ufRqaeTIEqEo868Vgel +CoCpaKZE90PX2cWjtWGOugqW/umaNN9l1q20ouvP8pHF4YCfL7oM1QbHlrZcounm1WuQJKD43Nfi +dKq4sIADIFBt+ci8vAFYmsWi1XOHTWvVNG07toGNLRNoXhVrT13WADUCi/aL/AyKtidOzSKjAbhm +TXptopJhy6TZ32tT3adi/rbm+BYJUFSMsOjZG0pKZ6CGnCV9nBEEO+sk1D4XcM88o6POCIyctsht +2aYEWEqmQps0RHDUc2TkT3ou4D4PyXFiYEtJlhNACFyT5dBLNhMAYXS1a0knbcUEQGVZtKQ6AC9Z +TyZl8WwCMNtJMJGoSO6ihzZWPWBGaC13StNxa3BONU2xBSDo8YpgXjoCldS49de4YWM/i4GkSlZC +4tMqikDzY3AzZImIFEhUCLO9hV2Y8aKH7Mgq1vHVhMukrhokQDagxM5lAZbFGrbWP2+nSSh4IbMj +VyEgYK4aAzXunpz/qOLxS81uJ5VVJuOiKeTk/dAZqucU7TQegbOC3cv6mTE9joKLYdbhdhTgGSh9 +meZVAFDPlyU+LiEyRYbATipBw2UuyU0tBsIICk1FkvtRRix6FqNnrGJbOyNINq0Ai65byuIUISVx +NWy5xC4TQ9Thlh0Y5VyyYwCpC8qs5waDecxI/qbghva5gIMk86YuEz1QZzfsCU3SAZLXmZptwskk +XVktN38A0hbJwK7yYGRMlyKZ2s91D5Rc1tjNT9xY9eyG+lEBuJjgoNCcKjKODymY6irqf2QBy8Dc +lLeUxajaYG56XEoTfND6WAxB67Z2LavSqhEotDSzyr+ABZyem6mqq9HwBp4tPDyqPPcM7sS53oq3 +rzyNrQGwc1d2IfQsyC4sJ2HUYaFu8mRhOHSDSKwGOqYa1mw6R2S9zVw8kgkUMdOymSuGDicTWJJI +0PVVWSBETcBAl56kBgoP1aMW7GWaGII+wVmPp1F45hk7FbPKyX5sgVyjUfFKni0AYbXLPNKsYnTY +LkX7ZYlP6PIVr0801xW6r+UcGo59VX8x5VIIVgtaZlM8ItuZzzguk3JRJjYL+In7O3JiqwUHRXeN +rKmzVzFYxknkEOozjpBK2lDkCfyM4q5NAgiRrB0Nps6iuUR2bmiUV03RaDmWGBBeU1QmBEULQlfR +mu8MY8pZ+Uih12cUfe6TRjU9jFPPukSSBUYArJlLGAHljRiB4oKMGorEqHwpwq8u1imJIAg4Nkmv +qabnyRnsZ5KYEKSvlIOg+Qp6riZy3PK5gKnr0l+J4SNwFbxqFySJsDPQYk6YMyFKXWSv4TNK2ujr +psjCxUwOOaQWe4AjyYFW/rxYkimZGzf0NAYYOjkEK/mqmspCK5PRSkQBgDUoAYs4yAFY5KAjbP91 +joZgmRWBhggp8aZFnV6SIBTMMIicBMEIgtkm6AlkCe4Sf0YEc7LZpXKOcox01lMQ4EGsmK2so0hZ +b4xgtkPpwaQ9APvGorODsuJ03QVLNasWuo2mH0TJ3xAecq4dKoy6DkxriP2QiNQNeC7gJCevgyUA +xGj+4sjlERiYUhEEPYsxmikb7QBi7KUN6Pi0wGg0+P1mHGISddLlMctJD8zhrjqLKILxjNK1qaCR +zCGVswhuujgWTSBeLK0v8u4uwFqrrlrja89Dj5wa9Yyy29WD2+cmJt1LWkNkQ5QRzCB3dM1Q5I+B +oJ8IUEPCCLQhzJb+hniz4q2LnN5odoYpcp4nA0vUDd9yIAIeZVsNyq5BBKY+jeUAULPQLQBNnwur +HTiN/axK5eMOzC5JsMFzNZ0q26tCcss+2bEgPYiMOWu80+BRpaKTKFsRg5DsPDyuf95YERiC9kD0 +XHcEKjonRUBbs2lb2TwAqEcEQQuRaRSSG4N+thXPW0kwIvbTSckyf2M/roNqigpeinQzgmhZXVHD +m3iyK+sOrNneIVqRknhrZ+wRKpEEURf4VE0PGkSOuj2jU3dqAUXT9QGoifRu1eNJzaqrg9LQn/GZ +XwmMi/L2jM5HawQwuJNYePBczkEBWCIBWGhAcgiDRfDmfpQ58CEPQoCDLzUBoh2pJA1QeRhC0qoK +erg38glrRRBmE3Fsl9D2aNMwWVWGICm+0WnOtICblOORPFQs9tB0aqlJgEDJKAvu4AXWsai82QeL +zc6zZYcETdnHCh16iir0RHEEq4Yb9IABAcXpa0oUIVhNmOreRTVCxJQP7Ix4ruDEBmPg+IeCw6zj +IDU6EDhnpbdy0iMCNXoQukKNJVEoxY3AosZgWZg1JN2XWZ+m0jiSuxX6MYu5zRYVi2yqcm0ddUwF +dcViHR6KUQpvZVPBmj/qIoiauYHVgWDiCXOqVgfqtZZERjCCaBFTs9AvVB36BypHhHWKgnMehCBF +khKrKtx+LuqUaElPoJP8kZZRC0H0RBkEl0XN/GKVksIaxEDUFX1OAVdKQnOyFcuMRiF6r+BsJ0Yk +Q538v5acLKQhMGtizNyDrJWxMVjd0t1/2xO5EFg0mXC2FI3Sz6sXc0QVSkfRrPGmVvKmB9q1YmYE +UkaljAVcNRxjRBSXHxEkwRzjAEFzDuJsEfszvM/lhcmxgjyT9wKuls5bs4ZkatbUITrB9EwCRaEo +UHeOkkyvK3YGi2I6Gr7SPLdzAg5GmRplRauBMli1GMuCRD+ApfPGyjtlSVxNduXkIvXlcmBKwwwa +xExW46XQqbeL71fCYFNZNaGXRuBewYsSVmfNMQhJI6YW3Fssi5Eipmrx90im5WQsfNRj5dyepCkK +m9cLXUO6SmaiEAZWjsBms/jbbEBRmjGJJveMZNUh0DtgySpZM5QaH6pgYtXk76f8MUFKXd8bqmTa +0dlB9TCTjLsXcG52lAIVDj0m2EsrkIfg+WUkgj3MVtgrsw51L2AV7f0cJ9YhsBw0Sd5E2HLhKOzM +WpSselEp/aFVDeedEyBjtER3ro4U83sFN6sdAWMs5RzEz7Oyv1v7fY7kOdUE/LJKgAi+KZ9fDVCk +PwYRqHBdxKSbuTjw8wEM3WS3ynP9/DnEffQN0UMFACvqL1i6FWUi1mkOKyXj4kjidTD4Q5sXurFk +gYlD5V0j31fCFQBBryv4e3il5Fffi17XlkBgLINEOs0qh7yWFmzMKUyN4h8LQZI9/o0oGWtiu3XW +tYI6AiiuVlYkiIqgsTfQwUtWlSZYqE98mFooL9Ym3JBdhcrUJfUXSR0WUlJE5C0sf5WueWbZMlvm +94wvQ90FLMFePoqiQA2BckzmG+LLgsffiC+YsblqmR+uSbSs0QLhS5RDT8uK2qSVksEARjsb9CVL +rTxsrWHEBfUQ3MEQL2qaNxcH7BtZUHgqDNckUpwwPeNewHFtwYGfb8CRrRihGScU3vqJtRlVb17z +2hyQWQlswavLfFtU2GKkKd2xeqBQoFocvHDdEObBgSumSRm/poSBPMpnhBFQhwg2zzS2dcwxrBc4 +JgUo8XVhFcaTD4nWccOaZKjqLyuFann2oIOBgZiEKzXksIRgIRpmlq/fyKoCFZU4IceAZOilbkWw +g2BYOWq14Jalty/o0qrqmQxW7AYdmkVUcj1/goW6ZICq7aMUisirMicuTNiM0R3c9XFaAzd4DcEM +zzFxd4mlXCaxUpYZsobcejwboiwsmr99bUfcwnCqg6BTIHuksCGNjtoEXBSL2qJ3ixf8guHCxmBK +7JdilWGVJQQip9xcHDJcFj9Oy83uexm7OVaZhGQS3m/AGIJp5UZLKRIxOOK9Jl+ichkGZM4lKdI2 +tMXD2TEPWD1QKGAEHbyww3PAuqLWkTYUKFBlmlDb2/p+GdYLPEAe/eTrv9u9e3989c37V2/fvHj3 +15ufA+in/+1nN3/31ft3r958d/PTr/784vuX+9cvqd70n3/31+9f/uzm/8BG+wcb/eLITf5P+Iv7 +6PcT1aRFbyoWIAJNi8qjg4JK5WoXiiq7guNBC3on3qeQdlCuK0sWsmbvN2DLXplnExbVPEvAvFBU +yBNQh4+TR4a2VB+kjEg7TN6vo6dgnLciEjrSmQ/rjQQIkBF0Yq2t75VhvcABHD06nVuowi/8MFMh +eTBqAhVBX2IG5R35ijs+6wcl0H2TiQulG3M5mw5Rk1Z5vwFLGRMmmHdx5BidxuPOwW5VHVC5OycW +g64tZnCFdYO1A4UCRtDBi+WUOqwzn08YKRCgsleptba+X4b1Ag+EvQGvbcLayqDG6pUSfOUNmLuR +uBr1rqFISehYXZXupjPuguIrmKnqyv0GjHWXzHHE9WJx6lXbYVrJscO+Eb8VqHzr2FJKIo4oO1Be +r6xVcOASbCPSmV3J4/sFqKxVUq2t75RhvcAAYe2MFazxeoEV7wqi+xJypGtGwPyopL5Gu9IBL0dA +SHbqK/uoqsybLMaTh0qWJNMLNq6uai2qKuurA5W5ocxx0xaXdVg2WDuQCehihaGBgwIj0plPaY8E +CFCZq8RaW98tw3rOAeYtmJ1tqXRdxhzoKgzQuluka15AsSeLAEOnS6LLElLmS77QRuisBdNKEEc8 +tHq/ASeL5GJB4UKqQpN6KNy1UnjHFCB3Db2cOu+tLa65EDdYO1Ao0MFRcOBTNiPWBQ8kbikQoDJX +qbW2vl+G9QIPhLuYOIQSNjZSt9C6apjXQXdSRLqbLPlLyArLXeMs3o3IWAMmyd1vwFIam2nlcqM0 +6STRAHVOsVgEqJxNNS6btlGK+A1YO1AosGkv4MBuyBHrwgXMRgoEqJxVaq2t75dhvcAD4exCZ/9I +tsRKFexB51nrcMsPT1N37Ue1q1NkSy21MWq8QpgNoQGslZ/QUZ9WMfOiFMebscaUWiYEVPaKve7b +YoKMWjyG1QOJAkWg4HAbLdSgSJceQOkECFC5q8S6tr1bHekZB5i5eV0rXcC25CWQdA== + + + mEE7HXkbRBZUdBvQJUt2hY7Ipaxva1qa34OjZc7PqJIsIva1gs0sK64D1QApa82bthjnndcN1g4U +CmxwDKzZHQ5r0ECzI4Bhylqltbf0fTWUZwxA1i6s4eYUWFc4v+6nM1ivJup3a7FjxhhckuKvbTH+ +KhRj57PSt4rvJd7KKRYsy148zMw7sTF8S77TYUDZgfx2/XiHaqDC4ezzrr+dYcpbpdPP0N5NQ7nt ++xeaJ7vHmSe/F+/eot49+Ofbqci1Ij9ezds2+BCfUUwXFHWRPWQ63m/ApYdv8awF67GrZcBaWUYD +Er8tC8C3xbp5sWywOmByNq0DB06/HLHihSN1S4EAmYJOrWvb++WwnvGAJNWXG4xUlTAxaZKPeL8B +B072pwqObO1jNm2z4pZzXB1QO8aJ/UNb9Fym5lF2iLybP93BhfNIR5T1Fv0Ym9cLUEdWSe1tXY86 +1vPeX8tY5HyWWTpHYcn7DTig70rLawIO2ci04gt0Dl7aHFB5W9a8bNomOSw/YO1AoUDZq+Becc1h +rXZi1lEgQEbQqe1tXb9cHbczHlzJWKS8nGw+GotCOjAqEUG5mygPCjkGOppOnSVFD1Tuojtt0xZj +my1vsHagUKDcVXCv3OmwFiv35CgQoHJXqXVte78c1jMeXMteRCLIxbqyE0XmroPKMRIGdp9zDVm5 +y4VVDajcbVHnrrXNckBhwNqBTIB+XqG9MrlDWuwmJUeAAJW5Sqxr27vlsG45cCV7kbPEFtWEsTbh +/QYcOEfkmRT+VcOsVVmqRS6UMiB3jUpILZu2eFY0LhusHSgUKHMVnKzoosOaLcnJUSBARtCpdW17 +vxzWMx5cwV6k99dVhqxGTYVw4MBpuQyMiwJp++R+idNegcrZRWSja4unURVoWDtQKFDOKhgvYZi1 +XrVizXb8xVEgQOWsUuva9n45rGc8uJq9iPKKctjIPYUJ/PcbcOBkFu5HizrvkpwYxQrdQac4AZW9 +cZnP2865LmdYFSgU2MwXMOwyckTYYcVDO2FLgQAVgVLr2vZ+OaxnPLiWxYj3/zV14lCRkfszsF6p +gcBU1fzofYONsjqg9i1FHR7Xtkc1HdYOJApseAxs2Zcda+pKSKcgeYWlUzu07f1yWDc8uK7RiDtF +azJ6dALg/gzsaswv5pvAsRVWFDW0q7or6ObGedm2rCGEM5QdSK/Xz3ewnq1wSIf5r+8XoMkn85dY +W98pw3rGgG84D+TfILb1IdORDZl/FesxZotseOvRgQvnFzzjYtF0XspHubDscIs+TEZMx9qwlKXk +2yZx5g9YHdBbjw4cLO7ssMrZrZECAbL52al1bXu/gq8kvuGBKIpfZDjSLUSaMIEb4P0GjMkIRUtz +80kIZJYrM905SEBlLFeM8m2xtO3K+2LH6oBCASPo4KBpdQ7pYkdUHAECVL4qsa5t75YhPefA9YxH +VKCK+PmpIMr9BpzJ88PkNqoUhPyyox+gYEnOhwC5aw3LTKaxLZ6oKaENSB1M3q9jo2DLf/ZIF0v4 +cwQIUHmrxLq2vVcO6xkHrmU6YvX5FNRwK2qXdyheSpJ4NVVOfaVpZzW0VzmfZkDlLd/a59viek7K +W8XqgEyACZSkvNWDTQ4pGEyrXDrRCRAgE9CJdW17txzWLQeuZjfGojkneKtpXjpzFZz76aLKB1V5 +Ta/GXD4naEBlLp8HHto2OdkyYO1AoUARKDj4Iu2KNdiZaEeBAJW7Sq1r2/vlsJ7x4FqmI95wIMH7 +yNm99xsw3hXIzh+8oCCqyaDJdnS7wADkvq247cZNW7qcZd1g7UChwOb+rMxpTd+lSANHrkYCgguo +OWJd296tjvSMA9cwHFEqzbOGvPDU0P0GnPxlDnxBKk06yWTG6xlaWBxQ+cqnAoe2WGlR+WpYO1Ao +UAQdrCWbHVaMt5R1Q4EAlbFKrWvru2tYz3hwNcMRl04PWs2zbmYdnOyqWbxAgw6GcD7prOytVf3E +BFTu8I0hQ1vYeIqy17B2oFCgCDpYkzsdVjrelDYUCFDZq9QObXt3DesZD65lONKVI0GWRLa566Gm +xFRNzETKYlYxzNevGlC7ViULY2jLNZ82WDswr501Haq3NHScWJvDgPp+Aernldahbe/VegGWbd5e +wVxEcnNTc7SYpuDBeooGe0GHlDaDntPsZ4LNmjCns7Z8fdwGaweOq9rAWrVpwFpbOCOgts7aTmtv +2TvlUG4YwObix4y5fw07jg7q63zodpwD99LvWNh/LWKyabWwRLeKNQckZmSsClrb2Dajm191OVdQ +XoHejnPgrmE5rD0ZxFHgk0Ecta5t75c75n7GgyvYcYB0rerKwUJC9xuou7Vixe1CAj92awaekF6j +Aypf55Da2Daj/3QJI1YHZAKUrQoNel2bw2kZzf79AmSudlpd294rQ3rW/6sZcXjtxaLDFbGu1v0G +3O8bxfoYuck81rpBdGNDWh2QWTPLFca+bV5sh+pYHVAo0LHpuxkV8RqxLlzjYKRAgMpcpda17f3q +WM95cC0zDu8KyUXdinMz5ioUUzuj8DakpMcJFvZ2JqpxFB1QeavKVW+Lqzlo9E2QOhi/3qSJQKPV +AXI4g92F594vQOWs0ura9k51rGf9v5oRhzerNB0zKvZ6vwFnLsjB9MaoETm9qxH6RuVcOlB5u6S8 +aQtAOnk7YHVAoUARKDjazSwOa7CrBBwFAlTuKrWube9Xx3rOg2sZcVj1JmY1UFUZHqBUCpbJTYtG +6qXYLV35kmOHcceanIl1LWnaqddPUQ5AU4QdFA/yW9khxRn8HqavD34P65S6tr1PDuu2+9cw4EjY +6xDSucj7DbifHKeqRZqDqznH0C1QCasDKlvpWMq2Ld1BNGLtQKFAEXSwXgrisAYrDu4oEKAyVql1 +bX13DesZD65mwOGyWXQgK14hdr8BJ1NZkWAqHIRAPSUIwBbW4IDKnVDKsmnbTGd1WNugyKqrdgD7 +tS9YQ9+cOgVh3MiU2qFt765hPePBtQw4pIHq1nDaf+iT14HnqtdIcdFFMnaisXwN6hQhoPatVQ3z +W9uG93LFDdYBaNbtANYilwPWtd+E1SlYLbI1UOva9n45rBseXM2Kw9JlTQcORqtP3g6mkqYCLBah +6yNfRRON415S1vm8LV9CvcHagUSBITCwFKIfkK61nL0fYfrpTqpraX3qGDfd//ez4TKIqHVNzn65 +34DlWrxnXDlQ+letNg3WLrQAXT8biDURc6ubttEduVasDuhtOAeWcmkj1oVLAI4UCJA30E5tb+v6 +1bGe8+AKNhxei7Mu4kNJVt/EgbPF/vGWldBz0ZpeJsI1MgzIfFmkTNTQFo/fzmnE6oBCgY6Mgq3q +kEMaOrM7AaEfkPfEBs9C7ZYhPefA1cy43MOEiU/n3W/A2VXGjK2I9ZC0/AZWaZ1XB1Te8pH+oW2w +A9GG1MGSOzTowLHfI9CRBqs25ggQoPG2bdu6XnWs5xy4lhGH5T1LUyMmG2cVmPkiYaY2FYsA23U5 +MKqtw5SxXO3et8SywmGD0gHp5cpWBXbdyqHEnGwpF9PfLkBlqxLa27oudazbzl/NgMPLnOxgDpXd +u9+AM5c6fSaXGzUNKev9CijFl8UBlbNcqGpoS3Ua24jVAYUCRaBgqwLqkGItFytSqwQIUHmrxPa2 +rluG9JwD1zLf8JYrSzYjiXR/BpYgem7OYI62f8D0czDmCx5e1Li+tlzkYmuHcYB1KenA0Yq6O5yB +75wcXy9A42srYWzrutSxnnf/GvYbVQ+2bN917rWI+pm8LHd34H1eJS4632Zl61KX5IDKVyrOO7Zd +sHJIHLE6oFCgnO1gLV7msPaSrY6C0As+eGp726G7ivWcB1ez33L34kW+V/V+A0bfXFMy1LYtds/X +vC5Lhylrk+VM9pZUTHlA6IDycv18B9PlqSPSXq3TvV+Aylk1rLXl0E/Fed75axluOLZUwpIwz3qA +cgRXq3VFx/V4dNNi18U11ez7Gb0yuyRTbYsSMamUU6wjcNaMxAGsDuIBa8ktnFFAQOOtUeva9n6Z +2/mMB1cz3LBmWNQD+RTevT8Da9VMBNoe4Ea+h7QJqJ1rUZMgfdvS6hnWDuxx5wFst/16rCYr+/tb +F7WdUmvXe+TwbXr/GLtt+ddLpCzoa3Fmy/0AzFrzj+4kWMXZzjuZ3ZEiIOJD1bvZXLsNptFIMgiG +R/lKQIcDK+Uvm5cxjD/ZqbKWRntHuO3jtQ7ZAd5iqQ50afP9BpwtZQxJXbMouik1vVaitOiB3C28 +eU+DGNY2cqnEEWsHCgU6CgruAX2HNdgltI4CARpjhdre1vWrYz3nwdUstIJrRQcu2pEaB8Ybj+SO +FCzCEbVkRbJrP8pi5XGSem/xipNZrWJrKxVSR6wdKBQoexUc7YorhzXohaSOAIYpc5VWa+k61VGe +M+BaBhreEGL13YKes3bQjCf89IYR9V31S9Dx7pTkQMrXNGvMx1riEfwaNjg7MLnV3KFxuGVmVnOM +7nn2rxeQsXW1XF5p6brUcZ71/momWsXZrUooieX7M3CTQE6d5RJwXtBFL5NKJTYHVNZS8YqxbbDt +3GH1QKJAEfStP8kxMoc1WKFcR4EAlbtKrWvb++WwnvHgWkZaJems5h8mft+fgY2GHja3S4gWrFsR +HFBYs2kWuOypR+dB9GKb8E29KllsZJ3As95f1d8qQOOnUOja9p44hGe9voZthrfBBS1kMxe1zQaw +27v4fm2aaHItIvZrUSvOakzSRt00UGRtA94dssXqgUSBMlXBXWVzWPtVEo4CASpnlVrXtvfLYT3j +wdVsM9xAa9SM1lVVAwdO/Z42IFiqHSXL8cAbp1CGdaCyFwb9vO3act5g7UChQBF0sL8KS7BidcEU +NhQI0Nhbztr67hrWMx5cy0QjYaSuYko5uN+AU9/YsbZiNeZEnTpU16oDlTmwsbeztrlpuSGnWigw +ulyIASzms0MaOadxJECAylwl1rX1vVWkZxy47pm6YZQxJfP+DNrkqhu6hc28VynqLtK9CwRU/ixt +rWdte30Ww+qBa+z87VCqjDsiHaZ0dy8Q0BhsPjU3UXu3DOuWA198pu6RBVk+ZAr+/t+sPgswD1bA +uj1h58FWSWWuzWKeVnNlrpilymqaq88yV7pZd920ja6Kh2GNroqHmYsebJVUPFarueIpcPVZPLW9 +retXx3rOgyuZjnPFiItFf7Q+iwdzMRXs2Cq5TVZzBTumEXhXnwU7lsPYcl2klLQhdBBXncWDrY5K +R2j1VvyrXW0WT6Zr23vjcJ71/GqFPCveiaPWsNVm8WCrojJXurxe8kvl+DJ2Dr75IizK1yh7Zm+7 +znJNpcfqgK42iwdbFRWP1eqteApcbRZPrWvb++WwnvHgWoU8YYhzsONlWpvFg62KCtJbZi3rK/VW +sG98E+tQmwX5EOrYcvVxIsXpgK4yiwdbDZWO02qt+Le7uiyeUte298nhPOv/1ep4Vg== + + + rPqteTJal8VDrYIKAtu6agI011oBnHjcvzmgclZzKHvbddZa6w6rA/a6LB5qFVQ8Uqu14glwdVk8 +sa5t75bDuuXAtep4VryDY1U9Qp1IHmwVVHCK8FVCrtYKdk0rjLq6LMiGOWxaNldvz3B6p5lVZfFg +q5/ScVqdFf92V5PFU+ra9j45nGf9v0YNT3z/rIa/1WTxYKuegsBqwUmps4L90oxqV5MFwWqduLYg +KLNW0DOsHehqsniwVU/xWM3M9xQ4b4Cn1rXt/XJYz3hwLeuRdoFupGlNFg+2ihA0Q5LOOqmzgkA9 +YOxqsiC41k3L5gohG87miyZrRRYPttopHafVWPFvd/VYPKWubXW2q+E86/+VLEcizUraWj2WESyV +UxAIctyXXhHg2nyRFu1bsXR117asrZ1h7UCrxzKCpXKKx5q6ktIpSF5J6dQObXu/HNYND65qO9I0 +WbXGitVjGcFSPAVpkZsPmlZZoRm1aPRC67FQ/8K2XS+76hB2oFVjGcFSN6WjHFaTvtvVYvFkjqtk +7dd9lHwG/F+iFsuMYQpbwt1SdGCrmjKX1Sp7W30VWBk2IV0tlhlv+JpT3rSNcj/ygLUDvaXowFY1 +xWO1+iqeAleLxVPr2jYnhQ3rGQ++PP8Tkcr9H83VYvFgq5qCpPYbHqS+Cnarc9Bqscx0KZvW17S2 +eDO1GvaGtQNdLRYP1rIpHqnVV/EEuFosnljXtnerIz3jwNWMxYI5qOpdsFosHqxlU5DcRc4yW32V +mW7dW4IDctcyrqZtWzAY+lUSgrTDXC0WD+53UTqkVl/FE+BqsXhiXdveK4f1jAPXMhVL81etyAlr +D7WqKUjunKMvu8Jd40uih1osyAat8+bawnqOGsMxrB3Ya7F4qJ2+9UitvoonwNVi8cS6tr1bDuuW +A1ezFYGGatlzVovFg61qyozXS6Yy1mLBvrWs5yatFgvyAfSltGmb5db4AWsHulosHmxVUzxWq6/i +KXC1WDy1rm3vl8N6xoNrmYuAOcltH64Wiwdb1RSkd5WznlZfBYFzXba1WLDLaiy4thnv3A4brB3o +arF4sJZN8UitvoonwNVi8cS6tr1bHekZB65hMKJUqlZuUGuxeLBVTUFSq9zSZfVVELisqy+6onwt +Sb0/1raA0WxBTMXaga4WywiWqikeq9VX8RS4WiyeWtfWd9ewnvHgagYjjq7VfrVaLB7cbwwseB/a +bA5Ym7YwhMEBlTtNat+7toW95iPWDnS1WEZwDNZWsUa2KEcKBKjsVWqHtr27hvWMB9cyGpGG2QwN +m7se2nJQmZBDtNLYSlgK/UBCX5Bx0UB5bxmiTkaHsgOzzVsPDUvWKao4tRCCfzvD9ONKp2/ZO+RQ +jn2/ViIoERvsfotiWoIHy0FR6oSZiXqzIvYhtuKANmOy5nG6tjXbid2OtQPHFW1gKZoyYuXqKiMB +WodlpLW37J1yKDcM+Hc7wzfjWaCkJyu6DefAVjFlzrDDNDU1pLYKLCm8g9cDiRk52nlG1xYjbKrH +GdYO9DacA3ftymHtF+04ClwdFk+ta9v75bCe8eAKNhyeYJMr8nodFg+1iilE6axBHqmtgr3KcoDc +1WGZM+o9GpuztsGuBHVYO7DXYfFQW/8OZ79Z0r3f1WHxtLq2vVcd6bb/VzPgMt6dHnVv0josHmwV +U+aMBSpnUW4lyR27VqLdLKd1WJANPcJtbaPtTg5r9Jum1mHxYKuY4rFabRVPgavD4ql1bXu/HNYz +HlzLhAPMNWhFCa3D4qFaMgWp1SxVq62CPatRIz9WhwW5oIqVaxtddXRF2mG9DouHWsUUj9Nqq/j3 +uzosnlbXtnfKYd32/2oGHGBOq6oIVofFg61iCtJbk2q9UlsF+6Y3wLk6LMiHFnVsrC28oulRKcPa +ga4OiwdbxRSP1WqreApcHRZPrWvb++WwnvHgWgYcYNZKO70OywiVoilIbilBb9+Ylbctqe2hdVgQ +SqGJoWWyLBKH0gNNCXZQq5jicQa/h+nrg9/DOqWube+Tw7rt/jWMNxL2mglodVg82CqmIKm5qsdA +b2nMWJlWKwdZHRbaW4L6LKwt/mh3ISrWDnR1WEawnL/1WK22iqfA1WHx1Lq2vruG9YwHVzPecNkU +TRq0OiwjGHq5Sj96MX5JG0bgIhXoUk8xplW6aCzU2mansxrWPCiy6qYdwGLZOqTR3IuOgOhckY7Y +oW3vliI948C1TDcc4KDSx6qweDCwZqkqbPXaKfSHxiDAkPUMRtBEROrxbGn22jZjyb91g7UDXRWW +EUxnO0assW9PnYI4bmVK7dC2d9dh3fDgajYc0rZqiq9VYRnBUi8FgVo8MfbdoVhB8TjuJLG187a9 +nJXD2oFWhWUEc82UEelqY97fr1VYRlJ7y96njnHT/X8/Cy4VPPPpsyXvN2CrlwIKNyxirY4plVVA +uLnQnFVhmVMwZdS1BaUfLNYN1g70FpwDW70Uj9Uqq3gKXBUWT61r2/vlsJ7x4AoWXCpWCN9VYfFg +q5eCpNY8WzYZuxmgWyk3D+RuRbxdfdsWL/LW0mSGtQNdFRYP1oIpHmnobOkEuCosntjgWajd6kjP +OHA1Iy71AKGrwuLBWjAFyS39bg+urIJdy6lFB1TepkXvsLe2eFxHQ3uKtMNcFRYPtnopHqlVVvEE +uCosnljXtvfKYT3jwLVMOMCcFr2xV81jB7SSKUStBB21tgp2rEQtXWpGRop2iW9viZdPa3TTUHag +VWHxwK5ZOZRWWcW/3VVh8YS6tr1LDuum81cz3xKm4uoNFlaFxYOtXgqSm7NGfaSyCnatXyVoVViQ +DXpNvGtLt0PXDdYOdFVYPFgLpnikVlnFE+CqsHhiXdverY70jAPXMt4A89xvedAqLCNYwucpO3M5 +2v6x2n1q0bYPIDLHdWyJhz9yHTF6mJOSHWz1UjxOq6ziX++qsHhKXdveJYf1rPvXsN5w+5SLK1wV +Fg+2eilE66L1oaWyCvarzasvt6J87cd9rW20jF+HtQNdFZYRLPVSPFarrOIpcFVYPLWure+uYT3j +wdWst9R9eK4Kywiukvqc8Gi53ilW+Ggida5pvKDoMUaSgKnms7agwKwbrB5opVg8GF0BVREUy8FU +q8FRkJyF4ah1bXu/HNYzHlzLfsMhTmpZWjEWDwYqVhW2qoyjLzQqub0uHwGVN2uzTVfbYlaqmW+C +tMNcKZYRDJqOrf9mt4+vddkQIEDlbbccXNveWcN6xoGrWW9IRNKy1laKZQTLWVkCLj1WxpHglF1E +20qxEDjp2Tvfdlbry2HtQCvFMoKlksCItZWz97cubzul1q73yOHb9P7ftxTLHLu7xVtwDqxFVOaI +WudQZmWO0U5DWzmWOaJiP5RtgYlhCaodXYd5y82BrZiKR6k1V/y7e3UWT2Rv6V1KhvKs49c6Zhfx +8tug+YtaocWDrZYKkpua5kVJ1RXqmZzedxVakAl6Jt+1xZP+qu0Z1g50FVo82GqpeKxWdcVT4Cq0 +eGpd294vh/WMB1ez3mJ23mar0OLBVkuFCLZcNDlGjZ1LRQvgWIUWZESqajFb2wU1zGWDtQNdhRYP +tnIqHqvWXfEE9AotntbeMjt3u6E8Y8C1jLeYNyVS7jdQq6aC1Kpfy+quYMe61LAaLciDUvXMoLVd +zuu+eGBya3o5r6fikVrlFU+Aq9LiiXVt83nll3MOXM2Ei5iqrKfQrUrLCJZ6KkRvL8EvwcHYbQJX +pQX5sFatcGptg1NLDKsHWpUWD7Z6Kh6rVV7xFLgqLZ5a17b3y2E948G1jDjAvNphKavSMoKNhh5U +17NWkXzUvnQL9yy6bcva4upUNc641UFWqsWDrbKKx2k1WPz7Xb0WT6tr2/vksJ71/xpWHGAFHWNb +r2UEu50s5HWs14L90gpqrl4LgkPd1GuhKYfrZsTqgVavxYO7XuewWg0WT4Gr1+KpdW17vxzWMx5c +zYpDXWVWP4fVa/Fgq6xCBC+aQKm5IBEVS72Uwuq10P5iCZSurd4R77B2oKvXMoK1MoLDajVYPAWu +Xoun1rX13TWsZzy4lhVHYslSJbVeiwenvs2jTynolso1WLBvzVIorV4LrdVV75hybdOqdYW8orFq +VaGeMzGAubSKR2o1WDwBrl6LJ9a19b1VpGccuO6Zu2GUtV7LCJXKKkRz93NxDRbqn7kArF4LzSnT +Xl1bMADKBqsHWph0gEplFY90mNLOC7I4G6KfC3cTtXfLsG458B+yXos7hvelo35WsAVvQVIjjubi +/Qac2X8AQNwu56q1J+Ru5jlaTqAAcQiWBfa7ZY5j26Vh7Y4wYP3/2XvX5ciNa030CfgO9UcR9o4N +GnkBkNj6JVK2x+fQlsOyZxRxYqKDYrMljnjpYbNtaz/9Wd+3MoEEUCSB6iZZxS4pJBYWkPeVK9c9 +c2DswfGBgvuDg+CTEbjL+WKMMO42RGtjukZk0DECiRuMU0sdi9+WAYkEksdqQpgMmHVszYydCM6g +Fx6SD14Eo0GGV2kmVKANuBdUuCsdiE2hGQJmTLkCrfpCBSTv14vqyhYJ41gv+AUbsyKVMFtSigiV +pqnXQUcn+YDR6UUXJbK02Jjjhb5WOhMBm7NLi6ROFTByNU3yY3SqK8T7UHHIuEsrBYbDz9BiCLY0 +SvoVWFfIlWSlL0ngYmgO8sQAyL13HCvQGwpsiaNZOKETgnGLF1bOlrbjiDVSIyqZqS3EyMrOxQkc +UkpEWrp0uaLMQsqpLfNVtwqMKnedW6uRu8H1IZxAqGholnWIijYsZLQuBWQAMkxDNV30Y2IDxmaV +b5H1Zc+v4tiibUXA9JHVb40moQyg8ypKgWNUUUgQUdjASFzbzg4TWjlbPfGX+V06D0W92bcsu3DJ +Kks/WNYx8gSLVscbzmS8FfWNWAhXazItQcbKNnEl5axOGxNOCyYumodLacLnsvZctDpionBMQXEm +6YHlZ2uSjO9BktKebK1PSWZb1Wu2XcqfgIvPlVFH8KylWBNqTVlzFmcVdkJd25QPoC01GYROdanM +N+bfpB1GLDhev1onPAjajiR/9c2fwpvfX789uv344Wch53fnt9cAVgC++cvN9V+F5t8J2S8KBR+d +/3Rxnb84+Mt7vDGlvvr+f/7xDxeXUs3B77qfcs787oc/n/zl5u05fg4OoHtffL36zb+vLq/lVSHd +ur348ePd+QccNXKG3Z6Ovjj7+eLy7e35Nd7b1e/+dH3Xv8P/7uJJ9pvyKznI/nF9cSbAdJ7lH/7z +9PKjfvnvhz+8Pr3id+gEe7Wt4/h19jh+fYFxyH6ePZJ/Xby9+3n2aOLXWz2in88vfvr5bvaQ0ufP +PqabH//P+dnd0c3H67fSv6ObR/ZGP8B33P/y6d2H2aMclHn2oX7zpzffXL7/+fSNmTvGi7cZb3zP +mPDNf87o8baQybuPtz9+FA7/7HzuLGjRmUuc2nluoinC+tzx/Hj64fwPt+f/96NMwg== + + + fBI6KvXsI7y++f7u4u7sESrZj/IDv/77xeX5/P05KPPsI7Rzh3b98eq7s7vTfy4YWV7k2QeGLTd3 +bLfnHz5ezj830udzKNA9XTcPdH099csOgfO/5+Tk4c4+MO/PvCAX13OX4+b9+e3p3c3t7AXpCzw7 +mn1/8/H27PyPt6fvf744m33EPTIV+Ul3veV75+L6ERIyGIx9wV1zfHP1/ubDxd2cTfMUHSAf9mjb +v/v2/N3q6720tx3j2Et72zuivbS3ZpRbIu35L1nae3d7Kmzv5V9uLj68MnlvthC/F/e2U9ybvS/3 +4t5e3NuLe5NR7cW9vbj3xYh7hX0tAt+SkWy5yOdfnci3YES7IvKJHHR0/s/zy+9/Pn17868v2/al +RybFwtdyYP54+fERbuUzMJvbKhl8uHv77fk/L07RoQVST17oxXiCP55+/PDh4vT6SBdwV3jp2Wvz +dv4x/PYlzuH5A5l/Cr99iWN4CQXYdmp28+7dh/O7o+egaS+07b/jCHdow1+Cb4GX4NnN5c3tf/3r +ZxVjZtLnXy/nqxLj1/sN9Alj+fD+/Oy7j4/sh93jCGb79nz4ePvu9Oz8+7PTJYg3KPT8Usfswcni +frw8vT2+uf5wd3o9f92mBV/AmrZ0lL//9/ub6/MNRtkX3CXZpKjKcvYcbbmKw5QLxrLdSo7CLhnL +f88ey3+/IA/y15uL67uTqL54CX3k+fdxq55E5mKH+KHXaUxYyDdsOxu0kaJnsTVhu9do1ySjJUaS +bSEGp7cXdz9fnd/NN8DtElGYfez98ogyJRsOPt3igTzCi+cDMdssKvzi5g/EbfVA5lPlX16CKL9K +K/xibmDbj87Li7u/nl48Jkt+4Wfn7sjKy9XEi3fcCy3kn89vfzrHTO4QE7R0c73GtXi6DuxdhjZW +qH31StRpC7xStluZZszeY2j7PYa+rCCR45uby6Pb8/P/nm3VfI2eUW8vLk/n23V3SYlhDmfHld+e +vr34OB910+e7od3cbolz/kDezh/I220eyK6JmH++uX3/883lzU+/7pBosidrO0TWXg0xmx/BsuXE +7NWGse0kMStej8vqq9npy8Iptnmrzx7Jru31nfO4fb0x+7NZln3M/n1jfNmY/dl+uLsWs7+AkG/7 +kTR7k239kTRfwtmxI2knsyg84lGSkbVlzvcv5HX/Re74rXfU+HE2lm099Zo9kl0JwvnbbHPq8c+n +19fnl9+fX56fLdGnTQs+v0VotqV100FOC77YOfTtxYf3l6dn51fn13d/Pn2/Q4fR1alUNdswuRPS +0Sr9u5r8NIOfc0fNX/P57/T5FlPKrT+Jl+Ua3ObTa/ZIdo33PkYY858T+dgVercAs7Z9j8zWIWz9 +Hpk9kl3h8OZHIj9P4pVt2X3vFvkHvbu4vFzi/3S5zSv97vbmav5g+PHzayUfYXIyw9hjHuO5Zezj +i8RczR7Lj7iTa75uXL9+fqP+5b9Of509JqF8d6e3iyilfr+9mvC7m/mSx80LDOT2nCLg3OGcvn17 +cXfxz/niVF/gBewx1/PHdXb28erj495C+ciyIi8Q0XR9fjo7/OXs9PLszzdv54+tL/D8wWezeYts +9VLzf+EQ5i7gsNQLiSSn1xdXpy+WGnZX89AVYe8Ms2WS3dmrcYaZP5Jd037snWG2Rd27v7BwolPY +NW+Y+TnNds0dZgEp3/ZD6dW4w8wfya4dSjvpDjOb/9wNd5gvcsdvvTvM2atxh5k/kl0xluzdYfbu +MNtyGH0B7jDmS3GHWUDzt/0kfjXuMPNHsmu89266wyzArG3fI6/GHWb+SHaFw9s2d5ittv/sjjfP +gi23lHi80BruYtbABX6A+1V4slV4upwbO7AIT9eBF2p895M2fvOnN98yZ8+bZZqvWQzR7hxRrzdv +0Xw14I5kLXqeBOAvRU2X5MnZU7SHKVq9p2ivkaLNXtY9RdtTtFdC0X5/K4Avm0U7xxS8Rnq259D2 +9OzLpGdfNIP2aunZnj/b07MvjZ7lRp03y6zwr4yszR78F2TD22+bOdum+ZK3zezB77fNF75tvqzb +gv568e/zy79env76Zlmw4zY67FTlqprtPakz/7cFDpRZiV2ifLfnVzePpTfYsVwv83OK7POj7POj +fCakW5mvbbkylfy/XMl/X8tv+fu1vFi9Npfti+u35+8uri/mG7huz9+fn959u2C7ZSWefXz7HDE6 +rh3LEfPhPbLEzB3dLuWImcmNfGkJYraFh3qFFxT+uOSy8S331F8yll3x1d8rLLaXHDy2t3fTrrSI +Imw5ddvQpLT14fM3V+9vPghb/t3HR0jYLgfwxTHuEEE4vb24+/nq/G4+ru0SYZitU/vlEeNUNhx8 +usUDeUQZmg/EvIQyYvZAHnF+ygfitnog80nzL7tCmXfjEF0o9ezSEfpqsyJ+ljN0d0wcG63pzjgQ +7QMA9+bk3TMnL0tTuI1apb05ed2s7M3Je3PyM47ntZqTSVxgULbl14sIzd6EvDch703I+2tGJiPb +m5DXdHd7VMR7E/LehLw3IX9+7cSOmpBfk7H17cW7dx/n32ay7aRg4XB2hRrMTk/34ePtO+Fsv1+W +5n9QaHvtSDr9y8Y2KPPsQ/v1/PLy5l9zx3d58dPPd/K+OEMe3NlDHBfb3gWMu/P45lpE9+v5+25S +bq90e1Gl2/6O28dHs1e6PQUp/fqn2/Pz66+FAzv/+uL67cVPN1//8+Lm8vzu69vzt1/f3J5e/zR7 +q+21cXtt3F4bt9fGrRnZfD5sr5J7Ga7KhNlWl9P/vrj6ePfI1Y/5kqTvnx3x6tljOr+Uh0Uqn6zE +i+l7vr0g/36C/fVSHjHfqixxEvf4DqH8a1I7fXh/fiYH1+1z+MI/u3T0qpU1s0lUWuLF0v604Dav +Yezs7//9Xni9DUbZF3wBxvsRbe4TqKb2epu93mavt/mC9DZRS6N6m6jEofpmr7fZ6232epu93mav +t9nrbXZcb3MZFRqvwoVir4R6eiXU91H420Et1OvMn7GBPmrbVWyvMgL4OfWGL0Sf9jk0to04vJoc +GvMzNmx5Do35K7LlOTTmD2TLc2g8zz0g2+1NvP3H5+XF3V9PLx6zUuzPzv3ZuT87Nx7Ilp+d+/xT +23Z2LqXK235sbiRM78rRuc879Wlzvy3H7uL13OecWtKBF2p8n3Nqt3JOff/z6dubfz3F/UW7Q4m+ +8OwCu+LXOTsp2j4i/9m30OyLNd8+Qk5zt7Z/vwCSzR/Ir/MH8uuWU4Btp2Y37959OL/Dlrg9f7uI +Tu+aDPAdR/plCACbr+prlAS2ZVVe933ie9Fsl0WzwlRfzUXJ+XzGS7AZS0Yyn9F4CT7D+HL2SP51 +8XaBO2H8+vlH5OaP6Ofzxz0PsyGlz5+fg/oSlRpPkEV7d7irvVJjJ5Qa9V6psbWscHgtSo35A9kr +NXZA/N0rNbb32N0rNbaRku+VGnulxrYqNb4w0ezudIGj5WsUzN7dnp7dnV7+5eZivmOzFp65xqml +5/bPPJyds+XH0w/nf7g9/78fz6/P5nOco1IvEJP+/d3F3dkjCqxcYsPXf7+4XJArYVDm+TVfs31s +rz9efSdY/M8FQ8uLPPvIzp7Oy+y5R7JMq7XFcc7zR/KEAs+2nAqvL9nRgvPg3e3N1fzh8ONnH85r +St30WlMdlYezb225u5nPT928wFD2uYsGg9vnLtrnLnpi1fJ8meRLS130JEqjv3+8/fHjpUz2LukR +X2fulQUixZYLR8+TcuWF9LxL4sP2qta1/OFXr8N7bP44ttx3rHx1vmMLRrT3HVszyhc3UPR8yZtH +wu9ft5niLufPXpGRotxbKW5220ox25tp14wU2HJboBLfi3uvW9xbgmZ7gW8v8O0Fvr3Atxf49gLf +6xf4ZosGr1Hge71+abNzOuwlvu2U+GYv4F7i20t8e4nvk9BsL/HtJb4dlvgK81pkviUj2XKpr3p1 +Ut+CEe2lvjWjfHGp73/d3Lz96fZ0/nn/GkW+V3lnxKIY8S0PkXiNGS9mC3P7jBfPThD2aTwfGsg+ +48UnchgpD8SroM37/B1bS8beXQp3p5cQ/9ePl6dnv3y9UtDN+9Ozi7tf/2uBTvjD3a+X83Xc8evn +d+FecuHytu+sRYPZtc30ByDiDu2l16kRXbZfduJc3Szn0Lbf+vOBqRyPXxN5+3IYh128DfA1MdxL +r8/c8o2zcDi7ohCZ7XXy4ePtu9Oz8+/PTpdwpINCz68pX7Zay8Y2KPPsQ/vXzwui8y+h1Zf3xQzO +IxvhuNj2rl/cnMc31x/uTh+7SjHXqozL7ZIC3bjZm/f0vy+uPi4wbXXfP/uSE+deTZahenZOq/NL +eVikbM5KvBiP9e0F981JNDK+hNeA9IF7+CQSqz23tyu3vu5ZpF1ikdICLz5jpwVfwE9+6Sh//+/3 +N9fnG4yyL/iFsIR7funl+aU9u7Rnl+b24ftIqHaQX3qd1oANOKdtZwafx016+9dprzJ/hnSitxd3 +P1+dL8jrvkvEYfaB+MsjPgXZcPDp9soZvzzyZT4Qs9Ur8kgGn3wgbqsHMp8y//IShPlVOhIvtZ5t +/fF5eXH319OLxyTq/dm5Pzv3Z+fGA9nys3M+E7DlZ+f8gWz52bmUKm/7sbmRML0/Ol/B0bk7euj9 +LY3byAs9OSXcgbV4ug7sECK81lRE++Szo1HuXiqi13tF3kYWg+1mRf++OIf1rvFtO5lk6epUqpqd +XmIXCLtZlfHfdb86yNwh89d8spE+34H9te0U449S9MPjzmO7SzAYSfXntAF3hWK8wrPpWeO/tjX7 +wj7Fx/MnSHs1OT6K2cLUtif5eBZF1DOP6bsvJsp159JjvE4nvsWs2+vdQdtvT4G9ASP7+ytOgLyL +7gibrMu276N8TLPDGneF1TaH82Oj9sz2/kz6DHvph3fnt3+4uN0GFcm2rPPd6Y/z13gXFJp2NdvO +wbH/z2Uay0GZl0vF9fH67G87RE1eHZYdNqty9WXg2R/3ePaCeGa+FHJ29FIuJhR2EHX999vT6w/v +ZtwisT34/jr1IZuwatvOfm4YZ7IL2hAd2pbw1Xt9SFwZes59c3m5BWuyLVOyGbLufTWXdOCFGl90 +/dNX3/zJlG9+f/22uwYKoAqQN3+5uf6rVME0JYWCj85/urjOXxz85T3r8Prq+1+vfry5PPjN0enb +n85XZlWs/npx/ctvDz7Kv+Xqu4PeoeaHX+Xh/5Ef/0dA/1r51Z9X/9//LldvBfrD3w7Kw7Is27Cy +1WFTra4OCnNYelNXEVBYeV+ZemX9YVW5BoDW1a28d4eurZvV2UHhDoPxdmXtoStRxh/W3kqV5tA2 +QYpUh7Uz8kIApfEeRarDYIOXb8rDtjbyTS3NVlVDgKvwbJs6tOlZijSHJlSt7b4Ih9YHz1qdd/Wq +aFGkNAA0LrBnpsRHDbpmjJVmjPSpki4IwLetF4AM0LdNB0AhGUcTmsE3tceQBeAqSw== + + + QGiaWkfsDAs5ma7Ss3GZTjy3wbH/rjSyPsYfWky0CYeh0hEJyJvWrExzWBlMggBqV9UrUx8a69FQ +ha5IIfxtWxbCOxmufouKUdoS4E1Ad9FC1a7YohSWQuyFrVbaKymk3fQANBh+waFYu+LQdPIE1LQV +QaVtDL+xlQxbZrW2rVbimmbFiW85JKy5rElz2LZVjWpL+URGVB/WDXGDOOD8Cjhha5/KNE1YEW1c +6kvjV8ArV6IQcA0IhJUvHQsRH2UJBD+x2AXw1cuggb6l6Z5Lfqy/i/5lLF30xWMTRd5G7EfRdyR2 +tej7GsdDJBd0j7PNQRf5qDEtRT8vceqKfO7i9Bbd/MYFKPIV4CoV+TLFpSz6tYyrXXTLnVCiyHAi +4U3RI05EraLHLeJfG3+0IWJt7byJn/tUAeaJVWIy2AzmiQ3rMrMz1qTuhdjh0CRsrPqNpQN1Nm5H +7r4i337coMVkFxf5NuZWr/KvIjUoOnLA2TdxP0SaQbpSecKUsCjlCez5gDgVPXVK9Kv7JlG4oiNx +JIN12gNKB4FHxkfEknUhqsnUxRnAqgAhfbcLgqKKoK1lB4DIXANpX1BZ8b5aJbIeH88OiPptmwCo +wGPGUwUk69waXSsk66wydgWdda7qe4sRuWYwIhm27BTXDxsT0/AbnRjMXQsU7uYO0xtcP72yAEIO +bVoAT/oSEp64gGawlJXpllKIFFa7SasNkilDrIBlCSCFZByBs91/U1emjajlG6V+bUj4hzKk63WP +o0Rj32+yRNfjHmM7pOt+QJprV5t+h2E7hbLbV8A73U0ubT63Gu3PSk+OyuSbWDsRN7oeudJJm2iB +0RMKm44jq3GCDKlKxW9sFUykO3pOczNwe1SBhUDA6kTBSp5rDZdeaZye7Vj3nrATS7ApSSxlaIpH +EcmdccpDJByvDAsRHyNhbuvVkHQ3q4ys5xTfRQYlYrZQZiXoXs+MxuvAHYgSW5eCiT9h94RcD44m +eeb0Nq6Op5fnIIWM1zzefKOHvSwfEbTyRtsQNAx6RIaVzrXXI7RuVtNTdnwQj0/q6WE+Pu/HDEGi +2T3JHrMVY75jypqMuZcRd6Nkusn4nzGLNOahpmzWmBNT4lxHVq3WOW0jLqJPpMtNG/k98Bgm1B3D +CLISsPyJqpDumO496ZK1HcNJ0lXlPGmibom4JfKXqF+ikD2BTEQ00dBEY4ckWJ+OR5z2ycHRjwfJ +0/3oZxFEfvOPawgNb1c/3Z6+vTgXqcT49rdSjayNCfjbCp47+dwd+sYBAzLHebM6+unAV4dlLSQI +gCI9FMHUssDY2EFWXZZY6MHR1cE7af7oSMSF//iIvjWlEQpVHoZgncwTILIcRoeBRZZXlbz06Imp +almqEqd9Ix354TSOrlFGDIKEzLMVtHQRIO1yOXDgOAoUgu/G6oFj5ZfMkDusy6rV09/UYAjj0VJJ +Y1JJHYKeI01jMaMykaExylE0Rs7aGgQt6ElSB1/rYeP652M5bKwDmnWgcOhM6/QIFt4QiOdkcNqy +4HwrhQQ3neVJKMOQicJp40ow6NjvoEE4bFz/fMyzxtU+/6KqKz1qTAvyLhMA/AegDDXLuMPK6rkn +XEGtNKHW8dmy5jZsyRlip4LjOsbeNuSFZDPLEaZkocSZJru9RPeFDkjfa541Fgt5fJBeFfqxX2lh +PVoMdjYbqJWplP2C3rET4GrZrYpyFrtZsN8lN38ZyGVibGhIIDxfDRmWll8IWdejprasoypB7zHr +lXXaTgtGJWADB+5oj9pw0oi8xx3dNKiEKOGwqkQSoWhy1AgxKSmLCgZVOGoEpzyPA8Eyyq+NL7Wh +iIkFcLOuuTM9WgbqmtBUCVDi4/ize8XCZtWVRf04nyJac+ymli+7HhCRzarrIvF4lQ0CA5VFyMbZ +Cr3APAjm61R5v8pmirNJ0lkLa7mKs83J9m23HFwN1+o0JcQSIsCpTXjFFU1o1S96hlWKF8Qcr1gm +BwJxCkdIj1t806469COCWkUxV3c4zLZ8pWhPNGdvvFnFbdB1Ft23fpXtE+wlR3wzbc2t5Jw+p83o +27Dq9yJ2a9kBsJtNzYOE5CNNaL/fQROofIgkAUTDtuyhIJUeNnLarHqyQsqjByYhIE2C4KtEmbDK +oDI98QJxS7QtEb5I9xIO9ZQxUc+Esh1xJW3taC+fjg8GCFwpfnelyctKA1bWV5EWDRSDLjRxI+km +Zxe52aJCJo6gwCC9HsEcJIQg69p+XqKgVGcTVXAuve2/GU+2koLGZutRjJesGC1pMVnzYoQUxRhp +iileFSPMK8aYWUyRtxjjdzHeAEp3rcn2SDHeRsV4nxXTrViMd2sx3s7FYMdbLTSkCfwElJg0w5t0 +yilZqUm4KIe1Tb1KFLggZXI9ZSomtEuP6aanbkVO/jxbziikEuAiJ6KVsg6JyJYhSq+JABc5dY5v +Y/GiKx+bKPI2Yj+KviOxq0XfVx1OkY8nDrnIx8xZKfppiVNX5HMX57foJzg/A9MS9Meka+P0ZWep +qfozvztuO5TIzuQOb4oecSJqFT1uRfwrcgSUqeMpy8+jZsjIXo2oWEXtUV0OuA3tjDfD7lUZz9Jt +qyLfV3HvFfnmcy5CBhu4yHZw3OP9N6ACjY9sGBY+kYqMV+voScfQdSSnmNCljDHsiFf/VaJvHX9J +BGmiqiJRQWBRKDNOVTGt42KBjK6FIN/Tc8VYa3p2WNHam8guj9jp44M/iITwbc5l11DWSwvCMtR8 +lGYb45KaJFTE57pNmloLKZJEW4QoF2Glat5FmogM8Gh2IoRkG8eBzb7CalStjrMZL2HTEWHFweyb +xlolD3WICK8bRvdJoqmQQtiYrzHxAimbRrXdpSoBZV6ocOOPuo67QfghGz8PJlZQaQXBRo69MiE1 +HHef4LBqXjEnqtdriN0NNJRJ81v5Vue0sU3ctIIgVmfeU49RKe+KdQm+ByQCht/9u1i8Lx3byJuI +Hen7Ebva9TQOJx9NHHM35DQt3aykucunDu9UJxDnF6UrHoZxCVzHw3frFFeTi2l183O9xyiRYUTE +mvRFwqsJ8mW4RwxtXP9NwuGEwgnPMzTHpFaB9epewLSLAL2ydcYvke3uX4wLoV5IvH290nIwUUlQ +UrnZVH3nVQlhs76rwt8oRIjqaPiT+RlN4GCCTVzlwRqMl2m8jtOlHmPDGF2mGDXCOeJk6FByirWc +Phl0QuwR4md7YrxfUsluR7HyOuTbLjbfbc3h5m1Www1utT9DIjChE5ydps6JSZpI3T3OrtJMd0SJ +9fsB5eJ6xUNfFwzr6VxHAFUr3WQ0EhhR2/4LYExTZcS302F0SEWs48kSQQkrE01PeJvR/YTa3eGQ +0L7IN0TBHTF4PDl4d/Af/zj4B5VVP7w9qFe/+e3qh/81BXz1xqy+eS9/SjmovnrTrfJV/zBe5sEq +Zyh0hiIjLBvh4AhJWWKEyGNEH28FlJlsl/F2Gm04lkEXgvYo1OwhNeDocDOhGSgxpiv30CJ8mtOp +KREbEzqWGHWgGPVvQrhZaEreJwfAmumaHiWTw2bdykxPrcmxtgYD1hyQ4xM04Zh+Pjl8p+fz+BTX +gtPTfsIQjLmG1MERdzHlQCZ8Spr+MT8z5XnGnJGW1NUtuuVNy1+k9Z9wfSw35Q5z5nGw5bmZMvIw +oR0T+oIS6EcnTUk/0FET+1nXU2oZt9+Ipk6o7pgys9h4licLMT4EOKTxQTE+SMZnTSQqoxNpfGTl +OHgNPf4314j9EooITxyhiHDHoQwDbZ7IKY2XE/1KRWaHzh9WQQ34LfwG4PdQO5g2AHDAiUrIvIlW +dJHFYC6pDxuRagO/kSIByodKd5YpfSXifFt6F70RjC2h5mp95VR0MzCttVAvlipqGkhRchRBAoni +IY0mqhkTGUdkYQ+xpIHESk2Aio0YVghODTolLAcyU1WJBYYBqrL0B3J1Cy1ze+gNn1sDw6AcfjLA +UBFnsasMPlH1fEUZmWWcVdJnmor+FWkKCsxBBf2fTAEmskizwEmoKZjHWYAhi6KcjLGyqqLCkIgM +FTYgAJVqljigYy0TlKu1ZcXOqXmB1i0HLVAFCZdsb0OTkIjTrSIipD6rClL9ooXVG1K2j1oi48ta +TWfUtFE8D5gDFHXqj9FyU6B6eECwQW439oAyvfRJZGF8Y1qrdmnvMPvCabhSxVnBb1WDVj66MYgQ +66gDaqwiDbnOVviIqtFKyrZqaHWLZEMaqoH/jawuJhAAk5ShVAkkAJ0AWlUhRJDsXZu+sfCkAUaX +dR1R3Dq6G9T0iOEuwMaSsSarv+KGbB0T6aGNFn1B7SqKnNIOENShZSXhTQ0PnYy0ucO2UXEH35ma +1Cp9h7p81FwR9Yq8QVda9baRXvlW2TOK6+g25yz1G5gqwpDNx1ZMJgAyTGvqfoqKNfNYwEBbxsr1 +K1kPS60C1oN7s+VuiPu6jJ5lJcybutSRlAiFrOLaly7ieesiuQZFUnlOzxYp5ZKjjbZO7bYiejPA +xGKIrnWIyO6UhbBttCqpcgg/vHYR2B5M/Dr6E2V7x/vUijYLSoVi0pU2dq1uddTeB4WY0EYDYRU3 +XSnHfZKjFSaLCnMqx0hlOCiC6gUj6STVsM7H5mCd6sjrgPYk+ksaXeREOhLyoqPkidYXHbFPB0KR +TgT1AKO3FHEx4bCncsgl4g0cFgJSRr0F32evYw2ooI5OU4Nz5wx253XG5ua3aMaAMFiYj+vm0EJn +Z+jL4qbGZngV1DwZPUQWOMXVgjatIr43QU3P0r7sq5Wcyu7QyOb74QoSqKNWyMuJG7D060o2Lfwc +mhXcqAR3ZWcenW3a6NHcRr3sOC8LHWQfUHsnbUZD+T/kfP/dN7d3A59xSDvqQQz33tUZfPY/Xr9d +ffj59P356oqO0f8pX30t/x3YoU/uSHpawyIoi7mYSQCXuJRNUDZ4KaOgnOxiVoEy1GJmQUptwi5I +sQ0YBgqgi1mGWGoh0yA9XM42SKFNGAcWW8w6cMGWMw9fvdmIffjqzUYMBOTs5SyEDG1DJkKQf1M2 +gnL+JoyEFNyMlaCeYCNmAnt8I3YCBTdgKLTYBiwFCm7EVKDgRmxF1B1swFhok8tZCy23CXOhB8wS +9kL1NssZDIjBn3pURjF6JbNVR3Xj2ir5cZvO0C7ERoNj7g2XkSldfXd7ev3T+fKAGTmQBOEdfRqs +UFfGzOBchJ7OqyPUCY2Xvq7oWSUr1xIUMJn0suHfExqs+DZ9faKBDdjrqc4TNfzDBK0tsy5byxFU +Ix9A955RCdq1VE2pTu+pntRakTWXOlPkvYqvi7zzsZqufydpJhTB2cETmaKuaycHqTtdB08OhtWU +6MKwNVSsXUldAmDa8TXjWzMN+TSl19nbWEdfRexC30zsAv9UbdZb7VI+pH5i0rz001J0XpT97EwQ +aZZLqA1wCS1b4THgpGkbOtOXK+xCC23tmE13LVx3FVCkB/DILQijg08ofJanHqFybg== + + + CydUwnIPBq0UwmDgNSytG2HZ8Cr4BpxdCR++EOg0KoyijBwOocQEmJZlhwip0tOaB0EJLFPnAj0L +eHxh3oRVUEUmSe7JgfQxwPEa6EIvWC6AoQkeDD0daaHOIxkTWh/knFJQQ+YE5B86Tq6kcFB60vDH +CZU1Ta0KwUYOBwWFmurYWClxQpgKZfvYMhGHvSlS/4hdekzEQZwccFyWB7uOlB9x9EWaD2Io56jM +XvdvUx2DKthO10zqS98VnZhq1feXo7JhlQ0qzks2ck7Lin9Clc1hmqV+otMk9Yuhc5QtGHvFtmNH ++zWl84onEx7XPY23R45ylebl5KAYvI4QnQ5W4SvdTF0zkB4EMugKUaeYdLeYDqmYjrtDmR51ivS2 +n8Ai1dHPcpFwp18KxWRB0n69ismaFtN1L6bIUeS4U6zBrWINChZTRC3WoHOxBuuLNZujWLOHijVb +rRjuyNi9wcbtZj/b3k2+kEWPVMWUVBQJrzKCUqyhOxldOkleNQJqcI57OAxV+nnVtnU8+KLILJIo +PBW0kzXH3KjVQqda5zD90DmMlhz9Xqe69WQ0Y7W6Imysax6w/mjnu/xV7EdWQ2qobyf1Iu+Nvsz7 +HGtInTrpZwA+UCXnULainuXdizgzeWmdl0kLg14oJcI72/Y9TW33o5kO2XYH+Hie1kzndNLXLM1g +AW2bjaboJ2MNNiim9H83NI03ySw+GarAJhNCe9dw1qgKGU0tZfTh/AtoskhfvZkuJTrG8QjLP8UA +FQBHmKKWyHFza/BOjcZD9IRkMcFiFaYm85G2Qva6GL6f4kDWZpE3ugYT+nEUw4FMt302OcVw7oo4 +eWtfr8GsbqkyBOyXdNC7deNYO+K1k9PN3XUmUVVhap10h1DKlBRm2hgcgKDeNh0GDFJ2IrGa0kYa +T+fQCnGBpdIxo4ZdeWOs6eQbw8NOLap6YDTWImhcdXEn8NhUHaAFKjc4B+GmSl2ipx6mU1g0UNB4 +hku2CJSNAYm03pbRbTVQuO2cMRFNih90A2L/CnQQSjTl99G/ou+gQdgUhHUoOWsKczA9a3y+Vc0W ++Sc1uuMHojNODtJLWqoR6EWiUtYMxI6VgkGqqdHrpubkIHVHJ7BBvzCr1LimaQaTVHnbaqAPF0Oo +H1TzUYHNJVPChLVUoQ0fUDvVfwCFq2vLOq+nSIuYNVes6VU3S1nnu2nKxlismYpuorIZ615rAZdg +4/nX5sB4ZHg0WM16iJRFmr8Md4scedvkZN3jeLcFTh62kNjgnA+0kBhhQqSIocOzmYpecFM20Ak6 +aNChOfZwsmZ4K1gZEAURxBrpjMxHEFlR/dh/uMLBJp2tWaJRvfqaoq05bKGwDbbF7heG6Ohs41aP +5rYqBegNHWxZacBobiR5zMjRU5qoAxvSGiXdI2qjBo0RvVHjyIjiaPERzQFwQnUEuAndIZleSnno +RjKmPaTtY+ojwCn+EzimQDQajGkQtfvjrccjaEyHvnqzhhJBXz/Z9dDGT6gRdO0TegSvoQlF0vOx +o0nUfE+oEv2TJnSJyu4JZeLCrenlOuqkB/mYPqmGeTpN62iUKpXHVEqh03VaR6kyPM1oVYbSGbXK +sL8Yov+UYuWbaXLEt59faSp4uvrj7fn59SclGQopy5AwKb6DINw/MDjIH9YVB186zwQBjP3UJENt +cBpBXkZDo5AieoW7ENSnr4blBV6xTguBPpVWQ/sDshOI5FfVMRizzrIM8VGTDNXItBLfyxY2Xp05 +hQvjTrXOGG5yoQgu5RgyGshu1Whh8JE6bVs/zDFEwFkMjBh9U7eW4WmkNLRgxPBzL9gcM6iE2PnQ +1JoqwtCzE0bHVmN+nPzD+DT1YAOoolFPCH5VapKhBokxkA0gON0CvoZlEn+DS0mGgvo86znA0poq +oHIhZrto1GHWOZsczVxV0ofPMN5I+9mstN80FQhGMxkAQtmjx0PLDsPkGPNuIGsKLE7GqGNoqBie +Zh08MTXhjcOiCf2tW6+WmQArUY0w2OinaBDOTIzoEhOh30Sa6NDpkQ8AaNVYNeB5JBwA5lkXYo6h +Gt6iQE4bY3FCQ9tHWQbXPaccQ6FR20p8GUsXffHYRJG3EftR9B3RnhZ9V+NoiOBVaeNcc8hFPmbO +StFPS5y6Ip+7OL9FP8FxBYpsCbhKRb5McSWLbinjWhfdYieEKDKMSFhT9GgTEavoMStin/4INuJs +U5mYkShER8/KNSEiok2ojsNaG064bsqYECBGBqK/bpUNgNvKxmHGfcW9p3kHus0n21Od8od7uMg3 +MTf64CvSgmgVY3wbCYZNq1H5mGHIeKe9ErLiV5HsRFNenScYSoQpEa70RaJsRUfagB2ubSK+VFbT +CzXGpVQ6oVUsq2N0nkeCJeKi8SZiZ93G9ELwv4k4XGn6lZYZmiLBzvMLhZhgSKY+mA6COjQ3UKwD +DTFAtm+IND3l30Fv0F8SqdhfYnyb9gBpOgZuYwozDrwmu1WnmenzC8Wpw9xqkh8CMPl1202+JWXx +KbkDbeVcxaZbRSp0XUzVUGPf5rmFat3IGujRDr6p2+TvXHmnVC9NvWKe7qY2o5RAYLfKSanTzUkk +N5rMReh5GJDkpuI3iWhjI7WDHaX7KO26eBj0G1MDmhvv892rfUinjAnx2KnSptLULR2lcKSzQ2qi +GfKInaQ3q7QJdFvQ+I6VbtAM6FbQAPNAJoykrWn0PK/j+d6mMgFoQRpp9JBkjgulou0q4ZiSWnLu +ioc+0mP15M4odlhl1Dwj9EbIiJLyoDhtm8iWBEXpMui4fUlXeWm/bjqmhB10Gv8Fj3Udg9HpDbXs +MY7Sc3aZV5HTUMWp8syD40qSN51LPRpLTm0LEsOZ1mSEo9N1dP6Oz+fpET4+5cdswJBTsIqNA2Zi +zG1MGZIxzzJmaqZ8TyLPiTon4pyo7pS9GnNgYxZNsc9FdLSaXMh4zQFFokA7sE+MYZdcKJIUkpwy +xGdSJOU7SZBItGJCA6XDiaxFqpbIXqJ6iTL2hDERz0Q7E3EdUd/4eDxmsOdYktug6gxvG3qAVIJ0 +NVMHwY+rXZddyCIxVrQkp4cimCBrDekyWNcc2iC0d2JLFrYytMwcJH8r5q+QmVKLMcRI/BAc9g3M +y7IicN0p4X8pp+IkuxAliLX57DQnAJFEszX5VZFyjB0zn51rU3LBUGs+u6rLZ+diPrt4VBjG2mk+ +uxj+j6D7OkuK0LphjiE+H2tCu5T6zzHHkFUJ0jJ3VYgZ7bq8g07jADUShvmvXExol/LXDVMM4fk4 +prNz+Rd5Nrs6ZrPzq87x7Dims9MhN0yBFzN9xXx2mgysyxgZI0zzbHZNzGZnVzEB5DiZXasJhgwT +XmrqsWaVysZkdm3Ma7aKaVFjtEVpUuZUm3KNuVXMZdflTotJIjX/DbOrdR5Zlpns4mljm5Q9LMRE +jy4Gp1pf11nkMTPZuZjJro2Z7EzMZBdMLMO0gJoqLmhfWhMz2fkwymTHeVNMZJyVOqsOU9nZPpXd +8SCVXWm7ZLtdyTz/qVbOXHb1qms/Ji3rOshcdnaVjYG57MKqH2WXyi7GXzdgsJl2TaN+81R2TTvK +ZedHuexieiGuGJFs1SEUMczriterbsEzdPImxDR2lWKXD6M0dq0iouJSRLuESVkWO9PlsDse5rAr +wyqhPnvZtDGJXRpHoxuq9hqcTbqgSezaVbYDY7B23ICDFHYxg121Sjs4TWW/x1Nq0UQGmMKuSimN +qz5+vCMlWaYhQk6Y147poCKEBKpMmZTbjob1JCyRuUTlEh1MZDCRyp5SJmqaiOm6xHaabqjRPAB4 +P0wZ7ZphyugmZc6rKw3Pz/rQ1NnOip3UbKkaGxzHoSlVNR0Ph6pJV73p5iLPNxQnkMlbObr0zXgR +YpbLkK1TMV7KUd7oJA5muFCMkKUYI1MkW22Gb8UYJYsxzhZjpC7GWF+MdkUx3TfFeGsVo61XjLdm +Md67xXBrF9O9XwzIQ6OnUpYKs0sXrSQGniLHKV20IRWqU2AwnFsjlSqmdEwP66YndcWYFg7SRcOy +cZzSRfcUtRhR3CIjxsWYUBcZJqfiebro1EbC5b4jg3TRVejHU+QDimMuskFzVop+WuLUFfncxfkt ++gkenIeN69epyBcqP1er/uAvusWO6NCfzcXo+F51KFX0ODVMFd1GZK2dj6KprWJxunszU3QT28gS +ReuuiFqBrGeNDxnXUiTiXeS7Ke64It9y2qfxti2yfRt3dv9N3PsdJ9YRiIxbG2eJDquO0BQTapSx +hh3J6r9KVK3jMDvSl7Ghmii67lnVmCg65QRnK0wUnfA/KJIwhNz1fHFMFO1XxYiYF4ma7zMN7TMN +7TMN7TMN7TMN2X2moX2moTGS7jMN7TMN7TMN7TMNbUumIYRIJofegUtvBTsLGPzaNMhucNXDEPCp +WiQGfFIegclEoyxEtKJAYymzqfVfMEiF3RCsKraZ8BZSSLAhWtz17q+2cib5gyjmySnCtLq9AzdS +zDK9PM4V3nITYPHvXDVqBuMzzUCtC2msjWmfU0C33gaA8FzXXYRkmS4fJqSyjpEgZVwbQxEZESnW +qKaFcrt6KdCI6dSMgfWPkWmyEslZIQab+z7tiU+p7KvYJ3zO8xPhLCl5fqU+YuGQfnHqxBPTCrRS +V1T6mIjijA6m2FrF2eEqqY+CiUbuKpQx4NrFawqgSiBEg7gTRJ2T2jImyNWv2sM22hWSgSEctk0b +45RDa6MfVGtcpJ+eG1DGpPFFWNY6eOWN6xgZTQgdrjiF2TcyNzGFru56JGaIFZtKM1TBIljGrBSe +1yE5bJtok6/oZyJT4tVDAjY9XTdGaKuJp+FNE6WGxqu7Kk0wJS+BqU0PgaeCSNdExwiyVLfYviIH +nKpTY44WvCRHxw55GHp93fe5Ypy5zQdWx7DtbvB1co9M8wONj4kXVsQpbKhtdz0ogHbEied4GcMZ +UzGkIZUknD2ZBC5oS1j3kuyg97XrAbSrNulWs/RNTEhQkYuRaajKARoKyNJWApAh0+JM9DViGmMA +0gaFpkr18NaG1EygUpEGBABaaMVMzIOtKaO9di1LGF3FFP8xsF0TW2TZooOafFVXlL4oea/HSl0r +NMt/ldJ/63UyTj01LX1bNMm/ie5kJFd11N93ABp+oydIBCFFNNM3g8QjyUNK9E8AiCZwpyqT9a/E +weJI3+LoYr5/EqWUj/+MCf/VcSnL+G/UVXJNfuizg2KQND0m/fdNVsMoD7VmHEJXXDI71kFzojfR +A4edHeW85oiKybCZPdtEm6cSe0zfYK5IVqxNpEa/CjCkVU2/DMjp3VRxuojnSsaYAENXU/Xxrox3 +Bdoqiv8hpGclmM65/AOl7sSopsv/n2Ndd5EJUZUOxtQ8xrQWTOcyyooe8z3RS14V6/klAOrBFvOr +x+Tr3Q91s+ySr2f3ANSqKc0uAojX+5HZOjsYdCamY0eHrXY4vwtg1SWZPzvIWMt0DQ== + + + i51mq4+J1JlavTGpOVkZo5nv60iufKOLLMsYSbfyCIIuTRyeTZ7wfYr0iGXpTpQO47uM/WfxVgBO +/vBaAKC4UZf17qKAsiR5ODvoQS6db8gFUsGzAId4qTtBb284VI5INWWlZwh7mxiZjm8K0KH71ZST +eiiHVhn9JaZx+LKOMFtrHD6S52DHB1uW7Ldw5LgR5Ierg7rRHCvjDwWOBDvpy6OzmVUe3VulqQ2c +QF1WZRfGsSZyY8pQZtBlLGUUuZYzlSpDbcJWapObMJZachPWMoqxi5nLKLZtwF6i5EYMpsZEbMBi +aojFJkwmFQobsZkMDFnOaMYAzuWsJsa4IbOJ9FLL2U2Ekm7AcH71ZiOWExL1Bkwn44qWs52MUVrK +eEqhDVhPLbWU+WQHF7Kf1NUtY0ARbLUBC4o13oAJBUYtZ0OBvQsZUWZF24AVpeJoE2aUxGAjdpQE +aCOGNAaIL2NJlcQuZUqVom/CluopsgljqqFwm7Cmej5vwJxqerJN2FNtchMGNabXXM6iataB5Uyq +8kvL2VQttwmjOlIUtl3k/3ewVWmmyjT0KzWnaTBSrbFojdU7EwPPdeuUiHZ8nHSVpLYAZ4XQSPRd +mSB4MKtHsvrhlrwjlcPBWDQHJHL5qb+j8lA2XaMXyUI258AOrx79rsQ1vth3dHdw2H+qVR0O6HgT +Pl0OXmPiFarCnuiuCaZycK5FSllBYtB+DdJmg+Nvm9B/dnQ2u8aj+2v0rUy80KK82vtZ9TUrG9XL +S9aWeSY2WF3a4JavrxTbZIUfQHCy2iZjrK+YtqE0GfctRE2Z8MifIw+kGTLxtst5iVzC8c7SEOOB +W7pi2nTBGrid1qrzbCS8Vo0nAGhuUuHxar2hlBKKUnyN1uivgGNYenbrIAkp6W01oLf9ZW2DCzoz +uk2qXg3Iu/wiw0gQlgMABqJD2MDqM7i5jt6EdcMrKOVbE728yTBTMHHREgIxbzLfG8nJDYImoqha +HzIfigy6RawL8B87BB1CGumgnRx+ys2Xvjo6m1vf0X31VVZ9MweV3r/31iCdRuovRTtNJbwY8biN +lqIeqcNy5NPsNIvRj5O0HAFZbDkKPkAgOjUBMoxBP3HVJ9wKDCZXlpLqhiYSpaSUYMBTlfRjHo4U +FVQCVWImDQC+amI8XwsOGMNESg71twIXLUNiQgo+Y+RSxqSGybCkSylTQxQLeqaGjE8gq+l6/qiN +WbTP+hsphxdShno1YLNCtRpqCkvoAuhmqdUyq5M9jDKoUGZExUCawgDVF4zZqJHyN8mtXkVC5uaY +TPZG1EEaqdq61T0K/QQF6SDMM4WuICgm4qngCI7nBoKiG3+LfYxMSv23yCs/t96je+uVXaPJhwcV +P6RQm2BfluNqAf5pqcUYqMWW4mBqbCEWKnu/FA9jqWWYqDO7FBcfIhOk0rWmpHeG7rCgivAdhObN +1cl5GlEpddILAssYxtJCflbHR0viX8shYGJgLVx4cRokXWJ/vXCdTBLUfgENKE2yM62mvaCugKmu +NfwwxOgKaD2Cxjeq6AKukdEVEFqDWU2GtOFmrOHdzn0gM0lXeREIWw5c9oODrzvTGTFPfzX+1Jat +ftF/y604q9aj+2pFPCInZFDrA/twurwKXLrAKm8vXuLU2MJF1mKLl3ktniNrk2z9e/M2fbY8Mh9+ +Ob/7rQaFauLN7w4QBi2EjXKsFxLcUhJuEW7dJZc5nZ+d29YII5Q5aZAalie6UMpGFs5BIxrla1sj +XsTAfKLqprJufAcg+072I0GYadLi1EgQ1iocW6pVnpkGPbZ7jFOCWdwrumVqHu81oGF3T4in3zLI +H4oSau4d410TxKoOHxxTq6mqNbaHGq+qe2bMP28v7r5oRjU0wzY0Is9qHBdn7KSHQHtm2Yre+N7o +F6nV9KyyBfrVfeFHNfhhG8eTsWIOHAU/m42/g8TeSyHj6368wgnq+278NfI+lL6D1KMa6lEb8HZV +SD/+DhJ7n+pMo0ut9uNP/UoQN6rBjdo4nowV4y/GnbvKQLH/BToDdj4NsJjOQYHuVBmaFON5LMbN +a3DeaB6K8TC6itM4i+lUdB3svhlPZzGe8ePpyDkdxMPBbCRIGgYxs8kmg6g5mAtFzZB94kd1+EEr +emQDkk1EgqQRpEq7McZ2s2lIXes/aUZ1NINWjifjjZ7RCAKivQSKEi/y0xXTNJZeVTQpMyLu8tCb +KCgUap5QJjyWZfRq4+ogGA5uPVcnC4UJt9fycvKuJtzhY6CID/EGi6KBNaMNGrBTk6WUl7ULmmzY +lcNH5tgwPaxAOw2iqWx8qOMb4J/FrVMleMMTPtmYqK+rx8XXaCf9JuKqEdBlpQ9DFbANhSmHhthD +JUXP3tbUxOPhlB6D+mSdv4Ivkgk69jSekuylaViq5o0MiMFjBkZU3NAYaFomZ3VRkC4Zgp717vgg +6/3JgY6t7iDZuLMJkULZZJ0c5POYauh6mg8EA4vHLuzkLXOoCX6RD77CRFk69yJphY2HE/LIIN0H +WCtK1cB1aqYjoGQwqq+6UseakjkajKzjpkFkmaUFtMLdAW7VA2okjGhWfaFGk+nF4At6A0S7ChM5 +t5DGBCWQoIj52NUc3QEaTemSyhxnYxU+zQXN6R3kLGf2AdlxdIDoIZDcqHSZzNFxPJtxj5VG/NXQ +PjhNZyd7XmOKCMJ9D16FGhz2yC6TgTzyQ7S1em0lIAQaZtrs6jJdIFxqMEHouOWZOLj/ygvvh+uc ++po6SNZgB+v61dWU+j4e31mKy7jvUpejm5tL3uri/np6d3d+e/3769MfL8//+PHi7fkHvdTF9le/ +dB/9+/3N7d3ff30f730RfJK19dCMlcpWe6ea8N/97fz08s+nd7cX/5bvBpW0319enJ1/f3Z6eXH9 +0x9vL97+v+e/xuqmLf5NmNEPd7en6H7f7mIu9uPl5fndqlgdnZ798q/T27eaD3HhLTKG8fZVTLhs +EVXKZ3qxrxIoPvkUOogzKiarrVZdwWL4eWF8/AXmKv7k7sk+GtbQldMQrBVbGfRk8GXq/HE/jvmX +l6zgv1AiU5FMllBN3HA1TZ0rZyUcCijapQdodysR60INqaj97FeW6GStqAmOWdIw4JVm6mRWqW6S +0hSt0rtURl9Z101Ol5hYXxZZmUI/5uL2S9u3V+QdicvaLeoqXV+gLijEJP0VMxzzN//rn2JrfhUb +o2hYxS/iB5ErX6kEEF+kL7UoyHzscFd/10jsxfFB150N47pY1VX81TWhYNtZuPHzMuVIXcUh552J +9lr297L73Q87vStinfEnPu3ed0Xit2dd/y5HInXtu2CM/4jxGJ2ou/qJWUnUc0QXjDEjeIr3ZhhG +sqhPiN7gBWA0fSsgZU7grVs+5sLmQyqffvRF2Ex8PE6diM9694vpPxhV1zfFAMfUiZODcRdTNYWy +rmmc6eBEIgtPKzPPaV7XiL/IwcJXNt09DRbPpgTy/NDG+Pi27cp2z0mdzmAZky450af0bV/IrFIL +BdszCqSsG+8vZOODpuPYdbof0JQJFyHSPLODtyUJUeWqNXenxvugyugqxsx7ntkeVvENNVmV4boF +y3Rqnqq0ov/AVTEX5kNFK6dXWx6dbdzq0eJWcadUjTTFveZtPQV4OFu4bCDQhG/VkavfN8k/Mu0c +TaY8d+8kBXHcPdnj3P3TdafbQbxkdOYeorWt30XZ42P7SG/WK3taU8WJigTTdATzwS2Wpi9uMvVS +nbXNkq9N2/V9yVaLpNWk5OcPb7c0npP7hy04ZcZQWv59T2DXE1e7GgIiEQE/4AN9g/UqAkcvh8Po +0dMwiQrET0PjTNn9gp15+I6Fm7YrnNcNBWOioVlP8h7Fjj/owgKLBy9/A7GBfyMyF95LayyvPmZa +V4qn+a6FdbvR3IgZiWFM5iFzyq4rAQcW27Y5ZZnZxtHcNsDqIUFgRkc+9WbJf3S8/scht16YeI2m +OdQ+XB00vCma/sxVE2ps9AQydJJO11gNyt17QljHRatDiTyH8YgQiRa6+4eOCDAeVcw9TJ/D/lUw +daU+uEKuK/VYH62ghzanfaywi5fODo+JhS0fbdAyzKYVAnGzowK8vBAHSN2lSPgirzb4UZYNefg6 +NLYiVy/9rgAxfcpI4e9rMPMM3NW1M76Sz686EBSAvqni7SW8CdpwaUclEoMtx6C+gIYMap+rA70D +uiuo76FINNRUTEqsBT0kVv+GV7fKgOvfrn73vYi+1z+tfnN09M3Z2cerv93cUYbNsHpydOqJsKbn +Gtjd9b3/pu/9mnKJCK/p6e/y59Xv/nJz97fzs5vbt4L5/8mOqOWw4j0j0D36YOD9Yidy/fE3f/pj +3Ct/f3dze6Wv4ihlc7+9+fH8zTd/at9IJ76/+/Xy/E3ftH61cNaywyM8ZOj6fDqOJ1dKfHvzrw0u +aPgy1RGOGXBd8FVLlZ2tSs+rfQy8keowJcqeGTjtKqXA5UOhhuamJs8c1GNir5vY6ya2TjfR1JFF +jkkiBtLXZ2eaLRm5nC+uqPRLv4Y8c6XOgpFnZtnPzzKDO3EGjkSJafYNzryHmGbXIJmiuYejRRig +CWOeC1vjviJVUGePIds8q5Wj2a1AAKcR4PMxzmvY5Vq9TmJuZRqRYsLKBDvJYQZGzXgFsAZbrAN1 +JdlAjCONoC6WAtdwl3W6wnfYj8f470amSAjwStlvw5yJD7Df9Jxz9HmwSsJ7LjYEtM35RohtNWK+ +4feOE+Lhoo3j/dtnG7d5tLhNHFPOfn6m26W0Rkh8A9v2VQaSpdblyUBlBPnuirEOBLFKL5TpQPny +l65Jl9WLOOXyz2DkjbeG9TA0+gCsmsLiEE6mo0qnW99r3m5c6R3Ctivf6Md5f7p24Js4BOWja+LF +9/KRsYOvspmagrom14AeljYimpSfIm1MunY1AHY9YRzuZJYG0G5sGjRnx8A1c8WwzfFsrenUp4ky +BWiEqVofNAxWegcRsq6fRJpZtCrZOd+8EmnmDze3ewvr3sK6l2L2Uszewrq3sO4trHsL697Curew +7i2su2lhndhTrw6mxtNijYl1jSH2WW2sRm/muNfGCq7XPlbWIVKsrBaZWCcNHy1v+KksrMUaE2tu +Ty3W2FvvtbEW64ysU9NkbrqcFlkPe3oz67rOMyNUZmZdM5h1BT+PdqIKuL/S7G2tT6qdODl/d7e3 +te5trXstxV5Lsbe17m2tT2hrxeU+zGJ0dVDqFYCacVDkEUPTUYIla+sJWbEY4TsGJWNrVnANqK8+ +a/9zG1cNAu8QCttaJdC9sbJFm0HtnEwuNLStIoANN3Y/WLSheWlkXF3S5tHiNnEseS9M82dmt0ve +6QiNEk2ezhIXEiyZzk4yWDJlAlZNYLjnsHFrQcngmRXMQeW9oGRsy0Cps4pFDMItB73sP0g3D6a+ +0p5XtiSTcYuVeZ/S+wzUdwC5aRu3DjKYq2rN/I3bXw97UKz4HFLFtHOUKqaj6IH9YA== + + + s+Jrgf041MLazW7ebv7RuqnaVFQpEi1AWrNasD7ADvUEIsqGEsqrsZ/+7eKnn/ciyl5E2YsoexFl +L6LsRZSnFFH08tAkR8QQGVvl0kYHymSSVHAdqJdA6O/pVABJr3P5ZNj4MwopQQd0n5CC9DqVe6Ro +YzWNyWwpZdLo2AP08UafSkqhe2Vcuyik0MTjbVo7vs6lAoX0XGqC9PIFffdGECx55deBMoEmFRyC +yvtAPWc7GUZnp0g15sJJBOXFzWHKwTKBDUZaTcZOSM95s5TzafaGja8FPblgMhlwiiobDzmD5kLI +dNg9LBc58qFnrQ5Fl8nc3yuUfPHSwD/e70WBvSiwFwX2osBeFNiLAk8nCiQ2nNx+7VNgGEHIWGz7 +uC344vUgjerwenG2L21YxSgwk3+WBIU1kNjgybQPTxkUxtt7Bjy2DEy5cyRWXxMTFh4p2SDxZ/NA +TNhjTU5Dwh5pEseTHaSs/zziQBeoo2kyOoGgwSEiAF3AxL31kMSdr4NUYwgj/+KyqziwDtSVy0Cp +8iLxohkoBaBloOloOrlg8CoFg6WIpKztvqEpqItl6uZjCumKse68mmkP7gE+KCAI5nkjbM8nCQjj +QV4NgFnI1nSgGawbWgztGkDWjixGiw2nfE1/PsXLqtB8FriPlYldjfSVDtvNU1gwFi3Ha5JZ7u5k +IEKiVt/dnl7/dL5RCBisv7jVAz7S8SBqhB1CJvwEKkJ1GKy3KyTR9bgQKwFKpEtND0X3OlVQdDWk +VjrI8QFBTQY6OWA520MmNeftjjsVC6eyqfq+wclQ7z3vTKiV24HGrO64nbKqHjzwCuE0aoPrRk1T +yZHBQ4HvcEtSGRq9dEg4EnMYTFmN+B6kzdfLAx8uDY9npE8fxVIsbPtok7bBGMl/fnwE2qb0gada +a0scnqbx3ie1msMPUB+vFxeIUKZ3+eFQZB6iDhVc4oZkNS3vW0kgWW4XccHz6t0EKGVp0+/0LpVO +hTtkiM85MriOH2KpqgcV42qLvM1i0qOugq7TGd53LU8G26VQyjZE4gnzfZN1M/ASxAQrEIrIngRB +WaYDSBDtaHzAW94zlWroKsh2xqiXfbvjQuNa8yYnHZr0eTLY4+n47xMve5fiUbd5hE4GNxl+3lMp +0D+e5I/9ZE4nfLIsx3l3sgF89WbNqAQ4rnHS6LCPwy6OBzQe8XjtjrNu5L2YzN+9wFwMrtx6GT+d +PHXNq6OQNb5EvnLZyx4pFdQwEd+mlyeTz+8lyq2NEmhwrV91YQteql4T28as7o2peC2NwUVITc7T +l204dAj0EaYet1MNZFBZF+Sb0GioB8uGSq/uFnK4uMGjTRos46WQI/r7ieoxYdN4q7mLSfJlydxh +jC06SW/Ty5PJ54mA1bXCq0Nmyb9KgPgsJKTKah1+vAbw9DEJkw7LPsm62H3QdWlS5AsIRaj8+v3+ +uS48Ui7WfiIXK+yEM7hsJzGwlQt4Ajnnm3CIW+1cD1DeNT4U3etUtkDhVC0e5IDKnpRZTR9Oqskb +Gfcg613W7ePBIB5lTYUG8qbxyJo6YcDqh6PucMsH7mo2jfArtQ1DDq+GJbXWCCzctjmM8fWNAHnH +1sOFA8jTJBZvWctHm7QsxO6waT43W9qtd0XjDti7Jrj4jLbjmuu1vgkQGSCra67vUlGW7Na5UrPL +4Dnyod3HxbiqIm+nmPSiGPayGA7ieDSojvfsUVvtWENA5Dr1go2avWpiu+2hMby4PEG0W/EBb3lp +aSqupXtMH/QptjX4dlxT3sykE8NODsdwfDAe02PcZd6rjrXsB5H3jHfF5l0DI9k9nuSP/YyNpnTc +3awLqcdyPk0hg1omrQw7NezTeASD8Y3WqG+6a7mYARlwjlV2Y2S2B+/9of8yjLIbNu72bpipFiAm +LYogQZxw2Lo2Awl/xtu1EFNJ3Vmo9aIihtL6Nu5U3KGDGzfJ93bbC9YUhMR2W4z98rwzfrDtKhVw +4j3genl93zt9Pj4Y7ESAsp2eQMWk3mJd68Wkj8VkGMV0qAWnA3d7pukoMGO+zOZ1OtNInLHuSsg1 +SxJxZLgoAtxgWSjlbLAwWm7h0gxGkxZH9/smy6NC5AYLhIKbLdFoo9WRQ2vHsll7qFdRWQ1oFxYd +J3YwHaRqNANxDR2TVJ2ewcik3wVfynykwoWWblap/g5wdtAIJfAmAwmL2+Ie7q6WBCCvFH+n5lPp +1L3xAI4nQ5qfAgrGzBa9LxH6rYOUtQitXcNJQW2GWx01FVR8KIIp/SFyCQhnV+p9473rwmeRzLoJ +NZoF5QoTSvNVB5I583FCXQOnnwTgERl/p3epdCrcTV98PgZG4Lq7DiLCiVOM0BrSM2pPv7umU+Fi +XH/RNxCFxQxV4shqXNnOLHYRJAiXqtd74hKAbTepX/oulU6FM8SIDcvYA5z9EiTYNDdaQ3rmvNlu +UvVlKlyM6y/6Biag+3mMgT9E3/BV9jRuWSu1o4Hp3fTDwdvVeHL6icPXk3mdzPxkJCg2mYLJJPUD +Gd+iWzXd2R/dJ0SS1hsUhQ8tcTwQtX3AbY8dMT3pPsNXts0hXcHPk+gCVitKCPFuYVd2SnBVwggp +Mk2tCpwGQsNIZSRnBDVZDxcGz2VNE1VGC1s82qTFkjlCPntqC9r2dBlwqzhZskrvf45aI75Ob0+m +BTK9URNftK6urGqOGi2tkBPgRl/3uMBa0LPoj/pGmzKyQLGjORL3n7J7pR/AuuJfgDapS2zRfl41 +0h9O/3lze3EXtUf/kWSMz3lvNi4zx7XNhYNfVQVzg/CFNW8TTSDIPTXoJgAwqCF7WQvlhwMrWLXq +lBlqqJpsq1d84k5S49WZsw2OV2prNiurz8cHCdIih406diDDEbwsZVPhNlApKy94eTQtdIp+uG01 +9U3dTi1Y3+4j1tI0XS28ZjY1otfMdr040TtqDa8Djz0tOBhC4mB4Ly+azUZM0bTmpaNxWgrOnKv6 +mSs4vThMsv426S7e7itpV3g1OFjydt0qGycy/NRQEeC+6Hi9Z/oKFSF1TL9Q48U87nwu4wsZWVpl +JOzxtgcF2FJCxRa5px3bhV+dQeK9Y5J2oxMi04YPnA3pAzqOhsMgqBlSHXrLCq8mdeMJSZBj9Q8M +ZZt/VdMNigBeDysAvdnYSautJjOU09wY9UcuQ00vSCQvBQTTx/nUw74Omv8Qj7Qo15W6kx4aWIVl +tr2VUalM1MikrnCEVSZHOLDH7C4/8fETXAnuNckRawHbjDttFa21Jb0aN6J+HagIZVdN11V6gELz +14+GI/YmHzJnxfezgnlrmmzeJst8PF35+91bn9hjpMIc8J5X+etWHlcB87pX662KINt13ev/OL+k +2zzJ7rdPQHqxs22j1yTV9JUykDhCSz/OgHy8h3rJMihWyf9DTZIBi3GJYlwpbgyuFG2AsLjxOgG6 +51SmL5KqTbWmNtkPdiODjD6e1DZqbtydaY/fwY27xH5Pf680rypy/YHIy8YUtosiJ1FHO52BivHn +xbhG+Z7OJfJ9wOlGshEBRQfh16RxfbFUddHVnRou2JmCvQHMcmGa1aREqi2rdtL2uHfTAXAfI+ih +dkohvXN1vO2q5CTIVoPHkk/59IPQAupveG5kEN4PHTMxJhiudw/III165Bgl7Wzp+0jVUV3rdNjD +0jv1/BDxy/KHmv1lhevG6CthxgMvj3ewchzzSntHggcVknDO6g+pAjccBjg/DiqJmlnj4NMNn56U +Rw4pKxxd4AuLHNZWTdS6EKb7ihwdmH2Lw832kLMDw7PJ9CCR81pNUooQvAbWYayhnmM6XAdvRdcQ +Qt5Cpq1kxEcbF7wDBBwPMjFnBx1IVqaqa8SuxXEKTaQWz4B5snQYgBDh9IbwpmxbXF0vgmkdeGs6 +zsnAG8JLqYfTYUpT8UJ23N0t249XhAeGnkAF5K3hxePOe7YD3/lG24E7/SEcLjmJIr9UKISzhecO +CDPuQZdPq/5J9nqFsRwfZKAQfKN+uTI3zRAQKKkfqnpQNgInVhafBmnpV20R3hciGvq44LjKHMsl +E0ReyTCjKf3icDs7UNhFEb6XNg99Y2tqgZpWLziXkxsAmUC4HWMa2uDRDnDUlRxl3cDZgShaE0Ux +oa4HhDjpLKQgtFAL4wWX00pTsbpWTvrJZsQmBV8QyCmhp7U16hYP1sB2IHBTTdUySaCDDbQHYGHK +oEsUQTILQKeuEtmXXpmV1FKECF0RtIQLeIJ4hNOCaGsd3WPXSgeJHekqSD2dDOeMuvRnuSOe9uUt +ZBVurs4jq2CehFVwPmr3BQVMCFAryWkpTLdmUG5lLzAKJoJcqSavE6DsvSBwtGVtk7M4pXr1mXRk +j9mooqYtAxlmmA5W/KJVQHVY2cC9JzJ/2+Qw1sTgHADaNQAtBYDUi/iXvubJgE9SpvNSy9qalV3J +AaiGhgg46QBN380AlhM+ZVNQV6xgzSGsgcCLnPmL9KoWnSgw7A1tKqlL2WejXj6stvl8m0SO11pY +/EqOZBwcHntc8yW3pm63cON8d/vjqlgdXX7k9jFJi2rmbgvKSuQ8SY+vOoizh0oqg17cQ4dnEuQi +AxX8vOo/7wCpRpymCSQoqUd/rMAiwsggdij9OjsYv+t6GAuPe3w2w7Dj3G/jBwiEMB7uIvgXwalk +VhwO3Mqt5PxGUA/0JdD9si2r9BI8qhd6xIs+KI3ito9GeutEFuvNO5uo6Wb26fPr66IW00CMHU6j +fWwap3pyGfzQ6ZO4OMBDIVOtdYHxPcLdIelbAokwdkhOB+maW2BJAgjT1pJ1BSp1MKF8RgNmWQ1E +MpwV6QcRyZRU5RDAknVfsn/uak+g1INUQ+pi3//jbCyzLIvQb2rYjfc0/wrb7PSSGeGymzXxA0K/ +jfyjuJceeMmMkCZ4+Zogh4AwTdOo6GAbR8uhL8GySrNVwJbpPSloVTSgcHKmyi6rWz1LeX8CZMUG +VksXn2VeqsCpkrqhZuoBce6ODxKIbFDVrFINEMKaNHf8dcyLM9q6CR2oYOmqL90BshYyWOxGV492 +M3U/qezwXEdUs7xPIidYwAOZwiqHZG1FGBREenFArMOBV+Z40q9jJVlV/y6RqFQ4PefT1YFiL1Id +hQaWuFq1hVQUbhZNPWn1KgOmro273g9Lg61Ho57Oy2TyWG46yfka6LgYeZ2NejIlkwGMjYdNf6kC +5Jm6pzQQ5iwN2o4GS7ib9zBhu6GZpbcug1o6rTO8rCF1JIAedkL2s28sfKBtVksCpKbODjoQBM/G +p9hqVIPQbUPBM7XVQSifaIf6r7pO91VNxjbnCDT+IeINcSySGv1Z8HaD1tlavcv1lpaO0GC6Qzbd +BtIlI7tEui19uuY7wrwKW2CbjXXRP0Ujzw+ToZIA1ZuRDc4+akQqDVVWTweIjZ0dZLDupo+uojap +NFJrEaCaqNil7qOu111F47F9+nTLOSPUv9IJTw+aCLUWIThYaKxLvZ4yzriG1MLMLw== + + + bE/F+IkO1CIMq1FrcUoRpKozaJlcqDqAzhTEqeybGAff1xIBqaWzgw4kUnoVfXa1FiS3LV3WUgLo +5LI3/Texv30tozF9+sxCHYLAD80lEh+QSwTqDsS5lVDzVDkut3AlKvViHg2y7iDYtFaYi4YESTGO +mjYf4+c7AHRhLrqPRZDs0zYYVYLGejJQbIxaqg7mqf1YdVWJ8FO1LvTNJQC0o7FLCdQPI9YyHten +T24lMiautuPkpgewJGAieCmTMOVoKicUGf8nO7rROLiS3lFXPaSNMSNC6qlwLRgyF4BgqnDqAJhp +TIbrQQbiNeTsVEsHiA1xdToIFIarrhKkS+DVSKmhBIDmJ3YmgfIBsJbxiD4DJYZ/n0+0OD4UmugM +oj4vvnIulzgKQThvQepwxtQaPt/BEKNJv0IotduS6mKjPHSgz5frIYKNrVBdasK6rwzUVeAFu5o6 +SGoPmz3BhIQ5G7gYsSaofklpuvYS5Oyg71X3VdfzrqbJ+D4HBcYZWicKrA+gwE794HhrjAfzf++h +50RArQ0VLKZsKdQkEPT4Vu2YddVSR8mTA+ZHhOimZ2xj1eEniLpw+r6KDtA1c3bQwwxuOXKrVIvq +W9TfgA11gLOD1JcO1PU/VjIZz2dAZplDE4+5+BupVIIcqA7HnLHwMM+JMYXGEdFAxjK/ojrA05Al +J2Zoa+qVqUm3sCm0MSgYJ42QIWU/Ma2QFI5xZyf9MDuDum2Sfzwcm4SSCqBJJIIR5GdwyVCOAybg +hhnWNDFOGw0fFvpkrJEU1H0gS1GDVzVMOeLVKQ6WGNwzxFtvRZh3oW6g2WKQIA2SnhlXeNkUWYFD +p0r86K1F82HDD6g4Pubh71o1FqZtzdAzwgMsJMN5O7s3dKhSd7iypbsXZpG5PMoWxjiZNec0wLJO +fwCkGyaMEXD9rC1S/jQxuIhZd+qYfqcJkQwHq/uAQa9y4FUQ5nSfubbSyCIvqCEzCeuK/BLRsFpT +tqkDrv5zcPRu/GFZt5r+ERORvC982bbzmoXrHNYqVGqVEAndri1ZA4Gc12D3NihlmNdjqonovywE +Rrj+4NvHUgg95te1aFme5nrlppE18DP95JKGaZ1a6UEEfFjPRDNWTyuE6jmYzQq4MbbYmvTSaX1Q +Q78GMFNnXlFRX2Jz1fA6obJDiC5O9WOpqNb4JIBwCtTJLcfB8ojnVs2AeIbHzBnIklHXJZGgYFfl +5dvKK9MyBIN2TSYQN0mQwOLkYWoBOeLIIldwBMfGD9GjCr0l+RBKEBnGlKzTYsfXkT3BEEk+grIw +NUoDgKQOxwekDuAKbXSKSQwRNC5SZDpzm9ELhCDWLVGybWv+pZxQwq4pBLSpcREEFE9GDqwKpUIk +G7CnkQGrSaFpP6zp5YW8HLa1kdVsDVlNj69kl4FuiKxdQZCjSSbIN7LP/JrypoHPTNtAoWFAKCHX +HSn30qjxRqYZxpJ5bYMCVMiWRJMmCATSo6wpKruehy9l6dZ7JR5zux1l8Vp1fvQi/TTysdEqPY23 +KDC4sS9PRZpcmyHbqbHRON2qtrrSJEs4mF2jYhePc3o+GjrKaQIVuIGQztBb7jC0hk4JTLjErzTR +o2NuBr1gknfaFY78L9USFtoM2gkbFSVNrS6McMEM0DnB8Zuij5CfEBo1rQty0rOUvvboILhnGNJ5 +ySu2l/A9SeY+A0sUnHDc4HcoeyFzoLIu9CXAM3oP1h64cAyzo5y2mlKQOgSrJcFuNpU6EAxmbmMi +UsHqBrR0DQ82Y5y6B8rWkYGX0JpjrNLYIUUCFVD9YdStwehJd4XShaBZNowqAkSqCNSxGKRWqOmu +L0e6hXGZOkHv4MTariltZd5KddsxTo5akcob+s/D+OXqJLWW7byGj+iuVsJvXr6vvN5MMi6HsAbf +Iqii9JCDWGxef4XVLmFiJdPSMlTtk+nG4oV5kqtJRFYqTfnSVGOYw10N41SVwZOFufrq0CpD2gRH +OaWWPUgRjKpc7CfbqvaMumTdYqZSBzF1qQLHyoorlXIA8F4LtRC5KdtZ+uswi1PgzUFqVIO/HL2+ +aNCu9RM6DaquNSo9g2Y5LMhSBOVhVRsirdFJDFIhL8A6I1mjR4EgHPTPhl8ZeiB6evZqObXk+BiA +ruSQIgo9z1Rt0plXGr3DczqPm8otwZEl1tvA498IFTz1DMAEr4Y88DzxyYRUYAqcKi0Ek0mojadD +vUy7UTWtBxmW1ZKt3Ao70WqWGCEGNTPvyFwFCKJ6p9ioNG4COqQHXwglfjnNVQlm1DWMvbIyoHVF +1zV8pGeTdXWj3lrG2bVFZWemPDPom/Iu87qst+C2FWgQp8WYTxZflq7O0zAfroY34cuSEXiJqUei +VRceOiZVZCxw5MsO1tBTxEro+c5dDy93iDFqfiR5kdOYt+QGoRwVn9W6FfUtkIvh5iT0oobClvoo +71VPRZ2IRmY4+vK1ulOdvoHfpi/pIgrmxEQDFmOdHbwlS92yUePcHEaHP8AiEWwUhwBpK6NfOY0R +KRFmQu9fpU3HdIpVFZecrWUto4CqCJ7/oCJ15amMGU7cxsyGp8/jocaiH8IuI8QImcBtLfy2KtJk +EqRd50Ov5GiRXEsIhoW3F7wK4KwGKl051RiAj7I+Cv04IH+gMdrjnIYo5tsYhTspXDtwfNCVVjVM +F42vk46jBVVykPVxT8WcVo/UVGQrQ3HPlsasKygEAEKvquWoYDua212hEIKlUCLSBFC2Zfh0TmPZ +qjwFgYA3c9m4F+YzQN+ZEKAw2QUx8Lptood6VUWtZdXE2K1KfXVFemzVmcLCdYo+45U6xwKGo98j +w43Vj6iBhhszv9ZP6jaqHFqc19iMTGlomujLCtNWS2qA2HzqpOXT6IDNcJugOeOUhyn1xjoQCDq4 +y2FDqmbhIN9GX3SRsuE2C4LR0vCN1AjMwaxOyJZqGkcADIzHMFuU5DLoLlhGYy88vkHJSHXGk7gx +X8FcgaX6eOJPSyV9C0rkQ+2RxA1cfoixbdGqY5sSLHodN3PMte41Z5MGFwSRuw+phQnCu0mVVmUT +6ImhI2idQF1Z31Pa0UQEZ8WmappDhlwd0VhQw76oug1y7/PaPsIdma5pyhCVG97dVxSsaktPAUEZ +ea8yysx+o7gUpHYj8rGfzF0sXKMnIB5MIyGc1UvLKAPNRht5eMgf2OJQYON0lX1Cj2Ln4z4WLBGe +QA16OMEtHZQYIqJxg9yIuJaD4oM8QzmKwBq1qQojgKgJXCiiagAy+FA7SDsaReJjtATkRPxtofVy +DGbiwU/ri6vAvzRMrw73r5oxm60BOZAzkIYNQ/sH6I2L8VBCAGtQEFdqovHykBpNOuxZupFrvAzj +Z6neFWoGokVjChRgUMcKvRvP18YcRluVDG+smO9S2mw0xMaAXbPCzghfj4iBNtiolFZ9BqyCJUMN +vEhRK9z3ab06vjmSf/LmDMFkrjNX10o0ELEIleYKnn9CfOXInxYWjgC2OEhZVmi/LswR59HDDAJT +mZfjd16z2PMeHAdiTkwTqFWeFqwhIqYEBFAvHc3tLuWfgHmSsiBwvvl0LmP5yjyJQqNFaP7cxPFP +RCw69/H8/pKWrjkx1IGOXR0IHla0ZbcxTkwONubTSD9Vsd5GDwqCCpb2Xen+OTWgMkOENUk9EKtB +AAQMX2X/k+FLGuoWIX2fY/HJIO7dx40as2PyRJGqmPUixAkR6UjmVA61KIIJQ20RCGgnWRUpYMHG +5OVApAd5dm9EhcSH2Do4adnjLmOIofHROjiy+AdKN0KbfBM0on6YVnFh00dLm2ZpSmdqO4nb7x9D +fdjUNXWKSBlwBirBG3UDZNJrgpagE6+EXoxQG2fomIVfT+T5n+XfcE+Tf0PDU/oMruUTBaggO8Yo +QEVBnxCggoP/vgCV7N0+QGVnA1T2sSkp692zxaZ8YuK7fYjKPkRll0JUavtgiApcfUYRKgA9EqBi +njFAxcwJUKFb0yA+JR/YZwpPKeMNoemhC1Ex80NUbBY1cpXD8hAVMwlRqVbjEBVbfqYQFa1oEKJS +rSYhKmYSomIHFY3H9plCVGyc8vTQhah8aoxKM45RaSYxKgy7HsSoiAA7jFGxzSRGRUCDGBXUMoxR +aaYxKs0LxKjY6BadHroYlepzBqmoV/QgRuWzRagM41PY0u6Hp6hYmYenEJKHpzAdzLaEp7AzeXhK +GkAXnpKP6DOFp8QMIkV66MJTqmcJT+GYh+Ep7SQ8pV0TntKOw1N09rY1PKU1ifrqQwpPqc1nDE9B +vvVtCU9h7vdXEZ5ClHk4PKWZEZ5iZ4SnRK6hC08xo/CUuv1MASpIGvWpASp10IN+SyNUGo3Z4KUd +D0aoVF28h11TNkWoNA9HqIR5zT4UoTIo+WCEysM93keovHSESqOM2m5EqEiZ5QEqjXs0QAW8yj5A +ZR+gsg9Q2SxARaZmGKACLWceoFK29TRApdwwQAXeVYMAFbM8QKUdBai0kwCVNjwcoFJOAlTslgeo +NF2ASogxG7wcFJ76upkWx6gMyqcolbA2SiUkWbU2cxtPcSomxanovazTogxVCfNDVUbFGazSpFiV +z+BBuo9VuT9WBbvjs8Sq+HilYBerEnV6fayK2yRWhXzDKFbFlpNYlWYSq+LWxKq0k1iVMCtWxTwe +qzKYxxeIVbFR4WE0Xe/6kBEbUshIyGNVWCYGftwfqgJ7noaq2DxUpYqhKmUzs90+VKWOoSp2fXgN +QlVwF8qaUJVHehwjVep9pMozRqqUZhirYh6NVfGjWBU/ilWpJrEqdhSrUj8eq8KLU54mVKV5PFIl +cVzbEqliNFDFp0AVPwkZMW0KGTHtIFClC/yYFo1hKsJYxTCVSCEYpiLkX8NU1hRc12YfpuJimIpf +V5BhKmVIYSpNMwhTeaCz4yAVHFT7IJXPGaTStE8YpAL15TBIhX6KjwapmEmQSjUnSKUNLxSkMpjE +bQhSMV24hjOzg1R8s770wiCVR9u+P0hlUnRWkMp9/d4HqTxrkAoUiaMgFTibDINUzONBKuUoSKVq +lwep4LqRpw5S8YuDVPwgSCWfrxcIUhG5sIlBKjFapEqBG+HRGBVZ1xj1UZpp4RSjIlsvxqjUpotR +KdsYo+LntdqFqJgYorKuGANUwtr4lIe7muJTmn18yrbFp6gfz33xKdnbT4lPaR6KT8le7uNTdjk+ +5T5USvEpC5Hp/viU+9ApxqcsRKh9fMra+JS/ff/9ICzl8146pHekIpAAzux0KetB/jChhvOecbAt +VxXKe3j4J8AZr9nEvX79J82wju45NqMWGoJ4tSDTZmgdaH7QTALEOwvRle6b1NeukvF4sL3WY9UP +fz75x5++FYz6zdnF7ZkssH3z29XXvACnxKrLy2yhQ8xCQOnJqEELPjKaKoCgE4CEcARyOsLxNGq1 +cjAZ0WZJ15W21msfW/ggRQ9PDBMXCJZRg1OVMBEJN0XHfDRQGh5CdR3ULBZBBUJ4kA== + + + NeCEfjOGHtP0hal4rSBuWBV45QIeh0M4ngwKXvJcltplA6U+u8m/gt8quBX4RoRSRUnPq6PxJjSq +j4oQ3JEXmthphSU0OTmw6TbeBrcHstXGVPTVbjVj5Kg7x5MOnjzH1WRYHLfyBpf4Gv6lnxDAlbq0 +bdelS9+fn96e/ax3Smsk0WenHFCyIwwa8gVSPl0RFKAAp9KVig4YWeGEZaLdA/o2bxmvzr0N9Ida +TH5WuLJMjuVL7giRe+ji3PpSvTHo+yPCVFVXCoBr1gquA7hDgY7/pkHj/FYW5RJSmXe+IgVpakNp +SQZeUpPCNnn1GK69hFt8E+mS1WsZKAbJ2XXJWARKQLhgDYIZbvYt4zMzKsI+AwrZHnLjnU1n55JY +Ook+ae+PQ/kY/8PSURqfsXiIGpksiwIXLwzO/cnSALjB4kix6fIIcJMFkmLTJQJw8SKtmS3UhAPj +H5x4rshXb/o1WboWULFZanoD7NpcC3gzQgPgUKZEaBK+hL6tpKnA29AoEN6T4EghXjchfjiq8l7g +O5KX1PF/5JfShCisPMll8y1kbEOEqmEDo+VWPe0TyHjViAJggYVQlrQ8BqDxaHDzqA2HlhwqzJwO +k8CLYw1PeIqwuKUdiloqBSujJwOzdOEMgg4Xt9zCIAx3ILh8omtUuLjkAgqvsqquO4hHElPLZRD+ +PvBizJoXdnoRB1VD6jRLXbqsltfkGibGNK0LGgHl6aDCW8QbhsLJaLhHgJVtiRgxEQ5UYSyTgryX +43lLAXgJTk5Kvrs6QAQflbMJJNhTeR8z54vIxW3TqNIa95kGvcsVs8Oco8J7a5xOzftC9fpHzWkI +O7PmpcdcaTmnd6/CdbdlZKTsJl9je+tFv/DWgQOHiE0OWpDjA/jsaMCHg4scOBCqnpvokJ4WIj3z +2nP+ShBY16CPV29yw9DlUi/DtfTJOYbZTf0LG0T51EwQE6/BMaq0lv0TXZarw6ouWcjSV4+qNY1R +VRdEaKw8ctHyPky9f50Ekrerx7tOAGqcXq9ZmqAsq6N5UZDQO9svyXjVjifr+PB9kXAOlSUxtp2p +0Xjue96bVpgz3+AMaHDPewtkgQMCLsvdQn7o7vR2VaxE5Pv1t5Ehine4ziRrJVBDtrVKSHCS4uHJ +u6RPDuKeD+oEWhIEE6OteMuviABVZNFL+osBZ70hpS4pA9dtjYc179dUM21s0qG+u3MCrBFfLdva +1Di1oSz1cKeDBqeuWmi/xlovi2uJ1Wm4iL+hl0QksnDmtGOW9SA8LAZXy/6kLcFBSwmVsisdIlqg +JBHCCgViFS9/roQRaEAoRSgUET7GVkM4gr776gB+/a2GgzpqtE8E1FT0Eexvp24iDwJQqdNneV0W +jXZ1Cys8Z9Th9ij4ZliWY4ASzMYwcvA6WXj9GYbZwanHKxlQXTt8QANvjvU1Nd1YD4hiXAhEmTaV +XsE7eV9MKimmDRXT3hTTLhdrBlasGX+xZpqKNbOZzfZJHw0OvwhEJlyhbm8YEdPQf4btaSJeOTtr +VmswDMcw5hPum5QG1PJS4pLO01aJ6vjloOyw3jUtZ10bPcyO/NaQ78EYv3qzpimhkYPeCN3KuyqP +46Gg1n6kylmPvyhGlRTjRtbN96C7JwfD0G7fREYPhE5OfUEOISQIwm5jFgnZdlDR1nRtSZjGsJk2 +MgsnkKI0Hge3xsO6g3FYT79FpyF/NPQ0IdojYeY6ppKbcSDUa1jHVTN0LimQiD4wKr9miLvvnPZP +DuDEBzJU0Mu+1D0ELQJNnyeQ82qNSe4/QIAbVTF9NQi205DPvjHqMXFFVdYnRi8h5EAWhJFIJ9OZ +OnlA2Y0hC6PFuwmLpobblzodw6lwQjcRmtyAmHswamD/PBKX1IzXDE0VtcSIPBUsAJurDPIPiKYV +hoXZj+G3hoiVdUXroAqVYJtoBDo627jVo7mtwqrUqB2rhl5rqNa+jxdJJ325Oru5en/z8frt6sPP +p+/PV1c3b/Nj/mG1+Bq8VkX3CLMVOMJtiqCbYLdq3kf4DWIxwXARHyc4/tWbNVjOrdzjOUXmCaYL +dIrrJA0TbI96+xG+6zSMMH7NLJ7cr49fsHSZetw8D2f6xAxknyfq46eyj+39/KN7iH+kP+8a/rGK +/OPo/aP8o+v4x3ZjBtKoybSFIAimzjTWBDKQXvbSmvw8VDP5lLwhPsRI+NYgLVTrIIrm+Xk+U3ae +AQdp6eIy5CAtPYwGHKSN3NJyDtKRZ4MD1r0cpP8cHKSfxUHmvVnCQY7GX6yZpmLNbM7jINt2IQfp +HuIg3QIOctjyUg7yIYZxWPM8htE9yjC6TRjGcVceYBjrcswwYiNtxDAikuWpGMa6NQ8zjGqPb5tm +FuM4rG4Z42gnjGM+Y5+ZcYSrrrJw7VLGEfuSLJyfxTeanm/coNGjmY2+ONs4xO7FbONyHF/KNg5R +8x62cS22P8g+jqtdzj7aNezjEPOfk31czsxdnP1yDn7ub+dvN2HmYE9r1IMcVmgk71RIEf8mcHou +o02Q33Qvp1+lX2cH43fjwlnF8Sf8zAPgNcLQYMoATjijYfCCBGUZ4K0pPF5Zl/wyINTpBMl9jHfM +YBK86twq4RG6JuKP437ks5hCY0jmbOsRSAPepaxgVSrp2gBqMKFzNbAqXS6dHgpyg0Q2JNfW5CcT +1WJdVUJhoMeUYXd+V87kP5wVGafl+ELQMClqF1PiRlhFNXNjVdYhAfT/RYLqY6l+rzrvTBWA/C8l +zKAaosfUCI5puVpDE4Chb4ThEiEQCxNvahzQTHdQVuRrEY+TmtC/muwxazv2a9TNksaaYV+LyTdF +qrPP72gjIqc0kvpfDtCqmea9ZuBQesl3DmaiknI0HYzh+Wdgz3Pwl+AtgXpnKJ4dszIC0mgOHUIM +Y/KtPht9blz3yKlmltiaeaNAijhnxgPR6XTsmIKKAdqxx/ko+JfhfHalYz6OY99EQehsPC8enjQ1 +MT8wbWe0Ji+ZOGS6XTh1X72ZTt69sAenFN19eFIn2SXbjKPc081ZdBNRlMpG8JxGXjAGFpeUbY1Z +Y4/xQRPFkmymh4J8lZBFp7xZ3ShvNkp3611Jk38r0nbDHyZUzKQlrKgSSWHSgBYlAuERl1IiNArh +SnuyuSebe7L5+clmMxDEsSXAE4n8EVq6ESVQdssVmHxobtBB6sN8xY8T4EwEZaPRwxGC9IAQGuCF +g8ARZs1hUHI4ZBZISICa+Kygs01owfQzjwDqqFa94MFHjU9ypFoE4P90UMnBACSyjt/G6j1yMCS3 +rWFih0qTzzl4wDpkcqLVU7MCaw4mF+Ml40SgknSODObqoUAFkFYncw2OtKgs7plE1BO829awps6L +qEfdGNKJIxiyAkkwKh8j2SCDf61eexlsHf1TRASvkcCOV0khBTR8hNYUtb7S1HUihyNvgV50s2Gj +RzMblcWFLR7Su2VI54KAhDV42QMXYSYE28W4+dWbpdiplGcufupYlmJodNtbiKOj3W8GTNNgDdJZ +q0kn9VRs1LmxATWEFyT0rZgTejYaHPFlzZMIspEc6C0dIqmxsvLb+2YAwlceiZKamhmJWiQ9karr +CEA2XMecCi7m0oUm2eqNsEEzm7eHXepSJn1imhWGLgdN2cjcLPSwAogq7ROAYhQ2vnLU2rbqQ0e3 +P2XLmL+6plrZpOfIzvFSUdnAiJYmX9HCPY1X+mLSXQnC3TB2mmdjaTRDM5OSnRzQCTaA9wheLSWI +buMZQffAE/IicC0kL9IoL6J5cAHBGQSIZXQ3+mMD8LAu6Z43Zk/Sr3vVhL6mX45U1jLhex1kaRhS +1ZbrSBQwrOaZCs8dJkBxCIzjTVqI0VW1m9PUZQF5j5gE8gfmBBWhWTdlgCFwbdGqxiXNSMIm5JI7 +5uhs41aP5rbqkB0UCZ9M4GVgAxplhkll1zAfacuo7/LCTQMqMNk22OSTjQPg8q0jjMkmm+erN2u2 +D4HjDSTA+VtIeZklm4glRttIYOONRP5ruJUAGm8mwkbbCbCZG6pf7bFlo7H3kdQxQ8ckxHTmrOON +CXyu4N+qtwXwGdbTQBaPKWOwIThpJWPk6wqp6aAC5vI/FSM/gjxIRUrZVRAQDTPjwdUVGTXX6eCI +GCVyGMg+RWZYJwcaQ9sDPbJ5eU9jIFYa5EltWs08iyQyiPThpe3AnXGx2tIyKMUqBBCVzMG4SWtH +c1oLzPHJ/C0WCXmWkY0pWihsEWLwbo6lqPGkospgT7hle2JYFzKBVKofYcoRDxMRrtxs6CH/NDh/ +D4Y7SwyvLNQD0IDUmoMY9LOkLWaiMJEjiylH6YcXYxEqA54OMQg0xpA5Zto1Rsu7VkapJ6UQqJbk +tGFgybqiVRMTk1nwv41in/n/2Xvv/FSSpAFwL8AdkEGAcOWrQBLCgyRkQd7iJCGsMN3T88f+9gJ7 +nL3GXmOvsWnK+wLetPo133zzBlVlRWZGRobLiAx4JwS6jBIwt6QY7W/slcVMFl1SCC98FyWli16h +kBXwJakUPndX07xrItdTjfe1XhkRawiWWeUhUL3RBLSgLf3m/gyIY2FtAwpd1kFAtwYnXnYBwypI +eFFtVfWIxTdPwcukUVEt8St48TVugP8GOrr+ETyj1n0VM8CNGTqH1xVrR1jVD9lyNyXxbiKTJAzm +8ScJFGWDEkWNskJOm6d5HEIEi66hux/ENxwybWk8PqTBgRGTSsI+/BaeL8MUE4dvwXZkgMWnTdf3 +2G/Oe78UuoMW6J/KXprDm4fRoahCADF0yy+Pr0BHcbpV9TMGX1oc42BKPI+rohAUDMZUllx8kvcZ +HoHV03+HQKM2Imjlgdh/3ocGaUsDP59s9Zi21nOS+O4JdPUEgXIB7egVZjUzjmTDI6eIllohdMcv +gQxCLF5LrF46zXnulII5UTQpeNJ0jJQMnxlpWfPUEzUHXk3oOfC6EEWDz/Q0DR7paQY8MtK1+qFr +yoZxFAbahqhYiLoxDvVjNVK4Vu6xpKpEm0o8QYsV3hINI/EGcK/L3Yl7m1HwiS6x50h80T66Rkoz +Xd64kXl5/+m+ihngxrR9M+iKAvXoqj7tX7Y+WVipHbrg4B0yFMzDhOqy1UbGV2YSBLrTF96rp9sc +JCHgfShQyJtHU+rNjPNL0TUF9t+yHK5HoNrNC/Sc894zmQRCD6qwypZWrREn7lj9EyQu8NKIT6Bf +JYmLm9HAovIrKwZFPcNhYfHDCEg9RA7H6+mmEdPP04Cc/GqJDV2UKTiuOLycAlYg0NIauv+Voxy/ +hsweFm3UUpvHrnMLdQ3T84EIcY7EW0TdppZTt0m9us0JBr2FE3TcHQkYFXfnBIPeonok6S2qr2IG +uDFD55LeQupVLdKduh2DjkOBRAHx+OosEmY/2ukvMWAmMiy6bgHpBDSnXVGoftDQEqRppcqH6mvo +NWQox68FCrtGtVdkee07t0jfUGcneI7X6t3KinES4+PxX1hHFutW+iU1Ad0IBC9RRw== + + + ygSDIlBJ5FbN+zT6BTRwqz6NDgINU42WIhERL8h/a4hIULE8dEOO9ChmgBszdJ4XzQX1GCX1Vz0R +BJwV8DQ1+HDgdTS8EJaVSQxY7kkbEsMOYwJfRk0zJkyDV7EcHhruOm7HwHpotOPX8KI08eRxib5z +C/UNM9lh3SIPp55aAhR1W5kEsVrrhQiR+qonQ/VD14SoGZxEilC9XIgYJX1fS46StuqWIHXhYLyV +yxFDJQ32tGBiTwsGC0QwWCASDlT2tPqRaE9zeuuDU4FWHmjtaVsm//Plkh7Tv8Ke1rJ0bKCCcbmw +py2/dLannTq1tqetvlzCniZN7GktLWueeqJmkedo6Vm0p71StGhPk0Z7mjTa01q6Vj90TdkaHqW3 +pz1Tt2RPkyb2NOlkTy+o2LLwz9ez0fBi0h3OusOPWAw/Ruqu+oXvbAzfCPjNRX8O/j1vfnVaMx++ +YNKfm8ynn/7TxrDx0ZkA1bjdmYTt3/nxy3yj3++CnTr+7LbElvXRqJ8AKvZ4Fvef/9EAv41NgRoA +QKjbs7btTZoiEKV+Y+bYnkbtr2B6h7YtAmHyAW/1gbEtngjJGr8AC3o+vGjMPjWg85+NSWukTBK0 +QiBMmtY7/5n5C90/ugDh9kDrCERj3JkAtlmbTUa9DhhYHK85IBLNiq+YciwQAyhEjRT4J8QS/H+C +wP9Ff4khyHajXahzhfxQ1xT8D+dHRS5wt+Qv6ZbWTZkG/5EmrPrPyvvFqIa7AXXL+llJYiZ/dacy +jmGnJOoQ8EI/jZFM/oJ+eR2SeT/vFcmr3AFmexKMS9rpiBgTfkmrwW1Acz+V8Ev/gZhK+BG6yDgl +azaLos5iRHUNh9CNiyLMh/PLBqPiblYogrcm+DllXDDihuQ5GEME8yPRbUwwLpNH/A+aDWjUhNtR +e6aCJH4jXcU89SVOhqM/h+gPILORXA/7E2dgGv6oL5EF8vyPjvQ2kRdzDEvdPpgZbA9opDv04wb4 +KdZ0E2KTKFAWEjfdabfZRwCNEGqzRqu3FASvY8g1pt2W8jleZExS/vP392kHCDTS+nvxg6N+f44u +wxhN4o3xGCANLw74qCOiL6QB6q8CVPqL7+9g7UDreneGwFGon/75RGwMBmh3S3foaDjtwtRO+S67 +Qnc67jf+wn/ClM8EhiSuGpjIlQ8QG0+QqJKWABP/0FUOPCNwmpw+QUrlg7l9AqqERtIwAfAua+5e +BA2MDkYSq/GJQufdv+f3+UOq4YQxMvENJfg5Ro40q6hvz4/m79/zAYw2JjOTFcv1O8O2hwW3w2cC +AVNw5c6JqkxO+dxi8DbzyI+G7Xl35mYOaigr3wGQ/laETvn6metpp/hHZ3jebiOShF0oSPZ024tY +YEKV6mVaawLZ2LAuC/JQoYv3YJAeDYvXUpxFuQllHeUB/uY0+PtMyZco/qfTmsMhoBfoWzN5Bu9v +49ZC7TcTam75x1oYrYXRyoWRmQTCJ0MkPARBh48cD4scwloT+LbntQT6GyUQ9bdLIH4tgX4zCXS1 +5C3MFkaVCVWuTaq1FPvfm1Se7zJfC7R/+JQ8CTRhLdB+Q4HGCbSAsuso8L8s9AEmBZbGd7+yDLxL +Ad4QIHqwWXx3DQHzRmDBOWs/IbV2FK6l2o+QakkBX6XHUDy6Y5KFlW5QFArMoU6uPYX/crGWXIu1 +30ysrT2Fa2n00zyFhChe1sLm3yxsYPjkWtishc1a2KyFza8SNm5yD9ZC5383JUPSw98gduifLXb+ +dUIDOt4onoBlc9ENeei8iOQZhtHE5/E8xTK4pjRBI08cD6P52J91lLQgx/5d+C0p4EvHCVgGBN01 +iTkvy5oU7/LIeH8fHuyJXTFrdvXj2NVS1ePW7OrHsCvxzgSCFmh47IO4FbxylGPMru9Y8ys3/Ipd +86sfx6/W6tXvwa8k9Qre708q6hXNo6J/a361CL/64cHx/zp+9VN8iP9cVqMwdcsf+D+o7JInvrTm +Jg7c5IcHOv/ruMnaWvsRLGnVcUwkDs8FrCwpoNp2LJ9kCFwSlBCSK0h5/Jfyr3Vc65oDuuOA6/T3 +9dHuD5MGSQanIVE8Dy8WRDfxJinW5HLK9ZnvP3xKnoTaOqr1dxNqP8VJ8A/bNWtp9Gvz3ymBphlU +BhbeJy8AxQqVwWPWoa7/7vx3jvjZEuhfJz/WbqF/Jut1MgRobAeQPCw5Bkt7UCR2CjEUw61DkBbk +XutA/d+N/63157X+/AP1Z5pK8jC33h/jOSBzYVBDnCcY2qS68Fp//jfpz9RaAv1mEmh9LPEj+Mla +kP3iYwlUKoZkGAZdHUPCMjPIHiEFfnl75Hehwt9nSp6k2g/PRFtLtbVdtRZH/xxxZHPbhhgnTgnr +m3j/5ZbUD08nXMucH2NJra/iXQuun2NHgfdxhgHUjO0njqK49V0e/3L76Yenmq5l2dp+Wouhf44Y +srKf4hRHAAXLL90PwHIsza4NqX+5IfXDM/3WwmctfNbC5x8vfGBQBLDgOdYvO/HYZHKd0fIvFz4/ +PE3zXyc6oA9OYHlCgMe8HCvwJIw/5QiCR743TuApVOyagFfqwCekUjyE4YkfV2T4XxRSbFr8CccR +cwKBo9HwtWAUwxDL+5x+HybsiWOtc/B+R57HsSzJcOhiMR7WSje7coaGBdWTmC/iCusCKgK4Lpi0 +1rv/fvbvdPZAkjizL8kwpAB/MQTLMjiphEwy3Do0+d8t2Pgfntq3FmyLHagzNJGEQivJChyPfpAC +y0CtnmBoLMZ4gaFJ+IOEujylaPVrwbYWbD9dsHHiTaJ0kkuiG7QYgaQI1ElcYEhyXeH2Xy7X1kmf +v5tcW59vrMXRj3Kz4fMNhgZKNDpdZ6k4QRHAoopTZJJaW1b/7kMOfp30uZZAawm0lkC/UAIxHDzo +IQWCTKJyCpwQJ5MCPKBLEmsB9PcKIPLvrxXIrzM01yJoLYLWIuiXiyCC5HgaLh3FxxleIFHRRGJ9 +urQWQT88YXMtQNb1if4OtklTiG2ylCCg2FiGg/esoLp1MAyPWcdpLcZu1jl1vxvDQrGpFE+j5G+G +YKCeEYc54CgoSwrTQonhwAqGIo/HEVs/LCb1H7br1hrz/yI8i1tfsfWD9ee/X5z98Oqea3G2vu7k +H7T11jLtf3SJPYzMEhgWUDKMPWYJRoo4JukVXGP/u1Dh7zMlTzLth2ee/ysl0jr57x/Jim2S/3iB +ZKFnCef+AaOCWNcPWZBh/dJsZVN2cwVh+vOjybAzma6K3eiAyizGdi0A/7nqNADtQvKaT6224MrZ +rsjuXH/vkU/+Irf478udFsTPmqNoOcpk0vjLXxlNuv8dDWdgWz2FeMo/nj2F/1E60Xpz/ts3J5Y6 +9UljOH0fTQarElEqgO7Ek4yfmfTlRWMGxjBEkoqQhNdg9Efn5vViJj3F30w6732gbd9pHzaG7dGg ++9+OWdN7+JDxJ46AnhUad4cXo+5wBp8lxWfD+SA/Gnc7qCOeUvdfUfUvitTRrDHrvF4BydrAAyYJ ++eW01ejDMXcmrQ7uQx4MelXtDjum4Aqdj0kHvyJ1wEqNFsC+WUcVdUek7pXy2e9njLti22WA0KGa +bZdFZVvFtWvdwbgvc20v6jzW43EfCmD4HboxyUJrF40AMBNAgtZDPxoCbc9f7o/+9LNA0KzFzFrM +/OPEjELD9nKmMBmNa5+N9ujPeKNrLmDUoFwbQIizN/tDhBMizrMSfxyNGy34TH7Q7M8n5qa9ycUi ++h/4P3cNr34ABdMfrf5EZOBozB+zv8b/YrZ90R32/LnOH53+v9iAZ/9XBvwvwqToHQVq3eeq8KgB +6Y0LfA1naEfxMgt4n85EpVBU9frdgcs993e4GBWuw7E0gY8cqSSv5kIwl1709HI8wy7Hkn7OWc4v +SQi0nMdad1kflSK9HtppjYlasY8TFLxqzE/SLNx0NMwX5tnV34mKGWJp/t///uU/bUx7q2KfpQ5g +nBDf7lgnKVuaV7YS6J+tkPxCSl/LwR+7laGNzqBdTFka6gsZQr/PxnClqWOrbe2cWAv4n6Id/0Ir +fTE5Dp0bfmmfLOkF0cByaUbKUrzdmPTUTobWdIKcIFSc5KQ2f3QmkicZI37c6CLPREzd6nM0+a/F +OlAsA4MfKYHDwZB4BeBfvcURP9W5R+xcOhwwgvRenTXLVrHsR/C0Me/Pnu194N52FApFgpFHLFr1 +JIfuMOSFJLyyVJ6plwhYcyd5IHuUfC0O29nJDI12Cp+w8Mnr2Wh4MQGtu8OPWAw/znXA/rlo9Duz +WQdx2Iumm3GGHq/Ah0gJA5h8DqPFuvuvT//cd9HyhqfQ7Wd31hG/c0ZXAxIgkHX6jpIMx9IwsjhJ +8yRNa1wA4ndX5Zz/qtOWvkzSyaTmkuQkzVAwXUE9ROXL+04fOlrxxxzL86TWzSDn7qg/Qucg4jcs +TyQZXt0hSTMsxWi/JeVv8381pE8FgUZeDZ4nSHg7kxGteDnEL3P9uYRQGvwfKSA8EnSSMl0I9aen +jQ+gDDbEr0me4jFSGTIpoHVhWfyD4DgBoY9nOczXlEA6nmN4EeQBDAAvH9BJf+6AYY2LRtJ4uQUB +XvGBXjEUjy54l67xhKHi6GJPhgSQRbAUzQOwlADA0pweLM8BzCYRWMB5tWvMsAAezE2RR6sBCx6V +D5KEKViWZEkK3z5KMknNMiQ5eI02bIPnDsAiLMhg4WhJ8C+AS+jh0jzD8hCcQCY5TR5YPCndasol +8a0ocYoGKKMluCwcLhx+7oBNSnB5iqY0oxNYnmUoLVzoFEM0D/9PuTZVgktB7NIIvbQIF0AlNIOD +2OU4bUcYuQIvCjktVBKtGaB4FVSW4nUMQuCSGJcK4pkkgZNJReRSOJ9ApDCGgEhIwsFyElhAuLqd +IrBgE2lGS1GQCCBcicQojGUMl0VrJgDb54BnpI1Icyh9AcyLRvgTkiTF4S2cpNHFaZAGJIHPw3QH +ERwaJANXipNWSuBpAQ2SBrsADg10zyM3JkUTtIATARmCx/kVMA9Q4NTQCIhJVtpVPMPRKP9CcYry +LM9opkxKyy1PGe8HDBQwP2nGJCmDhYhEMwSMBGUkMjTFcioOC0fJ4VvkwQ/DKDm490mWl+ARAo+o +BqwbwZsyM6BVwUmjGSAMQloDHbAiWAZTPRwnRUnbFNAeBQPzwTZlMPpNmGScYeD+gQigwSqx6nGS +NBynIIjwkuAnvnyIBGvLmI9TYqpkEqwOr6y9OE4OwGXQ9BlpmEmOJCgkz2AFcIHGX9McgVAip8dI +G4jGgMUNhPYPZE5gSBI6aY5GMiQJWDVhfuk/ozBlmKaDWJW4dwi40cHCwSGy8pYEhIQgsizBmkJU +2JzERlm8ZNKW5CWmTzLSlqRBv7hYUhxQN4t2NAEQgBca7Dtx+9BiHDaGxAoAEpxyUoJDEoBBcJjp +ouBuIJtoHi84ZFlwlyIeqUajeBe0yIcoCY9JAzNOkkkGLwpAK69lxrJIwrwd9CydKA== + + + yBKJRqtDkRLP5AC7o9CMKQLRHVA6CFZDTbJk5nBOFPghy84kInQBbSBp/gwNeI+AaJkDrB7+SAKe +iYUyk0TdQfSwIhdicKUHCZ9QHMOsTLjHpT0JSyii9WAhf0ObiGcwM6HgspEyo4DLKIoOWi044R3F +QHDCFRckqIAiGBKOBBA3Yg0EIGYOMxAOKRG0zCjFdaIwq8cwBThUtMs5iTQpVqBINGWCA7wYDjQp +IBwQJCAkQS0kODg82AtDqZYJygmAAJZDu0jixDRLiklsQMES8wR4Hu1IGm8GTpw+gxmRXElDhMrB +rU4i0SZQEtAkx6LdDNqxCDqf5NGgAU3QaBqSZKMlOS/KJLVkQ4JNZp/gS7wecDMJHOZPHM9gIAJi +7oxU24OSKIrUrhWkVKQ0yEoOA9gh4ulckgZanx/rO0lRP5HErrhJwb5SEJqEM8folLDJAO2dwIoY +vLkdjhHwFLRngW6O11kcoXxbO4EZM4aJsEkjfox3kiFRqzZ6n/mRIeC/6X4MoTETFhtYuS5NvxGB +A4ilRrvjn4382BxxgqVtrUAx9arawNG3VyCZhVDZANI1N0UatAv8KECv7x6w6UcQfKj2PW9MOlN/ +dvjRB2aVBgz+z6MK5rN/bPgEkQtcfMynoJl5kT2rn58V/YCHsv48BPofn/6h9BnuTHkLwBi+QM+k +DygOETb4HxVIs27kXsBW5ThSI1Z5QLlaQSsg8YK0FPGomca3N0jyhkZ6L5SygKlIsoHgCBKxB6BJ +CpS5sZwUGSQv8glBpa0BRoD0XqQGkSq4sn4L9DYkKFjAs7QjBpYvIZscBOZraOiS/s8gCYkEOGCv +EmiGpygaA+IZxlzZYCVBIWC2C+W0WjWgoUyjSDRqsOSkvDjYHtEsKGAIhrVBzyTVNMmjHigBSBYr +lU9WxwVFNZWgUUl5qUm45Rp/ofiWiw+3vgisO0KhLytkHIP1UJ4EijMSfxwHlHg0AKBLs0iqiJd7 +6H+I6IcLS0GWKmu3PFBLcCYbQ9MElqYMgUU1sGuQNkLJ/xUNGKgmsxDRrLSAHBgAWjcW2G6I74Ll +AswZcXkSW3O0NCb9DwyVR8KDR7QsQQX6OlKVWYrEG4EB1hYaExC3JNZR5P+qNU/4L5TDksgEo0Hr +yACVBhEaUCDA7kCqjSjvpUHpf4hgKSTekWMA/CvRLcfi+ygIHkl3GkhIDpMJwAgjKkycWvXCehJL +a1QvmgF0JiCFBexeZJSxJKs2hYB5I93bovshwuWxSod2Fi8JTAq6opAVznN8EvtQSNyBwmTk/4pE +QuA9ClUO8K+kHJNAK0DfCWwS+xIEoH1p9VhpZPofEl8hkPEPiZpSvBWsgNsSDEVgjQvYb1qHQFLk +Utr/lVwgSOlmKLTvKWnL3Xaa/vyoP4IicDQfy5sP1jIjsb+DYwRz64uSbhWQjU8Np+Fo2fqkFNuG +B5qYFq8cXlLFWpKUUV7SdCmxRJpIYdh6QHopr+e5LEVhDRyYdiyvcSZaOodY1sY5lBSVMIEABEFp +4QGTFfA2+ENtxWN4FJw3bRifpzgpZXAU2ge8rNlKdipgGQLOogU7Quvc5LHKKRKt2mtFCkmFckkM +8yInO60l37TirVa7sX1nY+zwRm8kl3e1O52pvfh2Ue7yAa0mptIYXG6b4GRwuqMROPrdTWZCEvhV +7a9Bc9SHYP4PX6gyGgCtMlTp9Mfgf3KNaa+DBg50xdZnGKqff4BRQc0zdFWrwSbzPsCaP+a/6n58 +ztQPCqM/h+q/q513zfvrsfqvHNCO/2xM2upnpdFEfHQ+aYK/zyeN4QfsujYDqqvq79x8NhsNATEZ +n1HqZ/VGU9sIPtC0wB1hPzaYfvujgz6A6yU/0HyAH9HgkehyB4PrtnodOD7k85cGC2V8WMQ7WCk1 +1q1XT6S2wqg1HwASKjRmDV/gNSH97U+hv1TnXPDvu9Pq2ajdMX255w/9Z9Afgtexxmw26TbnM5zk +AppiqvtfgFgBfFWr1me3354A3KM2UmyN9Bb+M/tr3MFvQzvD6esfjcl0T5Xcr276RwOuPW4Ln08t +2sF0cdxMHMlU89c/FDvD0bDjAjH9EaDwthvMSC2jf++8mt1hGwyUdDE3QBy1zuwMTcJ5furWK1r+ +JTFB2mLC1fy7jWa/44bwHVf1n7TRU3+43uqw6d9M0XB6rfl0Nhr8vZzs19FhatqAcRBQ5oEt5pYc +f/m+qMGba37MUH6HXTp9//MHS+O/eRtM+93WP50XxwRSCQ2zXF5XS/t38104Fc5pKn+5mcpff/dU +SI4WaKep/Nlto7B2x+mIDf8BU/rsIEvVxZykln/zpKToT6sJNUfA0h1A8/p80gXWopupGb/5ASIf +8braaD5pdXIwCHolbO8fbZARJm/VGJs1Jh+dGdADoMtgelRws/TGb/5mVfbirEwxpdFk0LDaleop +v3f7HdvGmsmqW//jzXPCiRO8o0Bod5a50vbvXX7HSXWHYJz9RsvdtNStfzjfRpftjBsAXMuVxqBt +/zdv2q0S+j8XG3YArxJCRy1uJqlu/cMJczg69TQ1bfsfIG+dGe//zKTVCqW/ezSj8aw76P4XZRb8 +lDEBK/nvHsKgM2u0G7PGsuNILjmOrbZ4/uFm16kao4/xSSFB+KUfKiC1m/LrTbfzZ270n7t7sf3j +aafdnQ/8V53pqD8Xc1DkL7JHJOmXj2MArczH/lIfbnN4pncx6cDUYMU9zLEszYqzzx4l/Y3JrDlq +TNr+FjqKJv1NeZYy+0FdSJPwd8EoGrMOaNhBLm3bxr3hqNUbzWf+D3zGjYhAyUGDIzjtTD/9V40p +kJoiwatmir9gKYYSrAdN+T/QyZe7trLGQROacZzPZ2MwUPuRUCrIamkIRtBt+6fidXMuRqGg2XFF +VJNzbCtPjtSsByKDyR8df73zn5m/2O7OGs1uvzsTpTjJyDCNxFRtDD/mjY+O/2I0lpZQLwZ5CS/t +cTeOm0ggwcgmOhIZoEsMNI8a/e5U92g6Hok7hpb9HeNGuy3vq+yRPzufjeQVM5Jt0j9ujMEumHYH +835DWUV53XP9TqcNbdAbZXOTlvjVWkT5yWicnXQaOMXZIDNDSiwgqd/wfpoy/iLiYfSZjiWIk5V7 +gx1ofA3iYKVVyzeGfzSmNRkdakIg/O8yZwCbst8ddvxTlFg8tW88luhn9EdnMoYHxFPtKkNkiVwH +Dvpy3oDU5a/iS5v0DMJsHDNAmbglr1C4puUErXPsjw68xdDfbPQbw5bDJFv97hisHfTi/wfsjQ9A +AeLAQyQTB8uhYqS97FFp3u9LeLzpTKZQ+M4mhi5qpVt/HkKuj/xZkULM94X+b0ILpFI/rfqvpx3/ +0QBusOwUBSFAVjls64lRbq80EcOHavC6SIkkeB5WzXL+Si/pzJviceGLJeRdZ9ZQ0VHM0MAYxyN9 +4K+Ngak0mQJ0z7qtRl9PVpYfKLEpBvoyfgNwnK/VtPvXFDZKIlWb66Qd2KNhqz9vA316AClGz8DM +viiPYHkAmGMP2FGz33ExJDzd4mA8+yvf6fenloQhf1Iv3EJfaEXlPLTrAS3yaWNclxUgykXr6qil +4qj6FdfvltH4LwNt6xAlItN/d3phDlPXHiUrY0z6T3Gyt6FfdZvrYfc/ph2rG912h+3Rn1Mdtata +dNVyUz/CpAZvtcYfcGvBhH0FwmgIKcWv4c+uvvHD5fET4gIRnr4izZbV6SNKHJ/bSeGvaFFR8fQR +I46P8fQVu9BX3EJf8eJX3lAo6OjIhiLMCUqHRuiddqInwt0neIDmS2z/zRNBSPQkePyOMse943f0 +gt9Z0JXjd6x+3SwRb8p1FIlemzffR/12ZyJ5EuHTaVgvdnWNVeaaljsU5mMwEmh8KWPJdT4BVan8 +ObgpaiDSm1Y475nydd07tQ2geq/jnMX/jEeTGVSD1NJVpVrn0CGPSrk2KEgaJ1Ot0680ZqBvKFz6 +cHpTlb5r0fYI+luPCuqW6td1GKcAezUbHwoZVQ1P+7Y+GqveyefH5f4IKJ9XnfG8P5UF4B58K1/u +oZuo/u4PRcEB9j7SOYyyF7wpDlsjEwsbvIFm3PlQ0cvU79A1Mwh3UHMQLSgFKDAFW11l3KTypgS0 +qbrReQxBAjPrpDMZmg0E6Nay+qke+6AJ0Is0dtOOALFPMWkZtlDSPxwphoa/O0Qa/Gjalbpx9ohQ +fmAc2nhB1PYCaovU+bxoKFypDQW1NYKa4kklbrAZktOYIWrPBm4txV77G0BLxq4OnUtB44bAH8HU +OGhZoI+Qya7/yI1TqHhRc4sD3NgaCca256LZVlObj2pc4WY2yNLOGzd3nrgWxfgrZxw77EY5fN5/ +22kmbrrtzihxOgKaXgciFSiOYB92JNwmFEd5ojXqw3ICALKRZavbTWf9eBt3gYhaFgj24OFnYnvF +o+jmm3F7AF73h64HNW67Bo5j/uQvSPl6JXXD8XgSR8Iu3odB965azkaid4nlefuWE8WwEQjSvi2O +M9Cxd80awrZ/jsSKcPbNPnXNDDj9GjUBTqfdj2HD6DTUN0RL2xTjDOwgooYjeJLsol1j2uzOBo2x +fVPcZqLbJ2atW/1JvDUawqvAoEvOZqiwpcy3m+iqIjx/3rT1pB0HNjy8c8dhAKDhO2BN0jVjSBSb +tkJCwujlM/T6BzygHcc/Xbb7w3ps449BL94ZQh3D3Q5CH+AtpKynm2/Aos3gBW/iWOIUa0r3sCnY +1JA3qwKiLIc+BlukO3wfOTSbqC66cmiKPKXNxmRqg1zUsAlVLLCfVBzCRWOZSbhoO9H4P5xaqxkF +Z9l80Jj0ptpRu2gsj9pFW9WoXbRWj9qMyWvnOJ92gEqMlFubffw+nMXb/fHkfTS02+7jaRwqZoCH +TO3JYhoHPBM6ZYegqUr4G1r+Zxyf6FkSEvhmLT/cMC/QTuRdin/ZDE1KO+wPt4Y4aU+m2h1vKoBQ +M8kRPZ1a99waxCXvemvwV8+GDSoNR/jeZq0H19A75jK2PUMtQWRB1/Fa3I9zUoE+3/Y/hWq35xdP +Yf8flIMOBMelEk5m0g60gVpMd2gjOqF8dRoybCOqLKIkSJqzQSjSFfYnMJRVK3WEZQhogYBvtv3N +v/yFSfcPdDe2HV8G3ysqlo1yoWHEVqqFibfW0AgdObqSGVDGa8ZmKq2V9bcWgpMPZ0EJ2ohCUlWQ +St8KVaGSYDm2sxG6uNG4LwUhmRI3atMaTu1QCtrMun21hW3OP6fSNZs2bRCPdZKNE0kOmA0Zs13N +kpi2mQLTWToZNWe3fc2xm1mLZhfaQrZNhp2PhnKyaSkAgGI6tG/TJ1vIdW4w+/RC4rPR7kxUR5Gm +rbRyhDdTBQEz158OmjL8ftdGSQYNRuOWjWKEGkxtpo4atOe2BrvNDgaf229gLGLmw5YrhoBaN4bD +kRKHKoYGQCdLVmroV1xlnqMCSHV75CTQnRYb3C6mXgTCqlVdFuEO9ry5UEQWEhgyTg== + + + nLakDMWQ6vftW0173TEwc4Y2Qhs2m4DdOJl24PAm7rqVwg7cs3rpC9XcrIYDfRayx05LBcej5hEw +BtQ0oHN+6VeUsHQMKYslXnx9USiJTihoy8AAt9FwqnfbgRH4z/ErlatK7XZu/NE5BeK/O+53slo0 +OTp5VLUU/Kpbj1fg34GzB/N7hSn2eUUnFsMgbL9zE5Nh9h0F+7vAihc6OoUdXoz6XUkqmhoP0kBx +yYjSZDQASPxzNOnVJcnE2EzvdDQctT7BRx3VJE+6Q3emrzRoHGgF3fbDmTgBd9iVopiyQI42G7Nq +46+OZGbCK6bslwVeBoHzOdFpS7Y5+sNFlyhWwmpF7TtFn1r36m15rhTl0NwgMp+qwW3sZYVgAQHk +Tjlqg5Xqvncl9sV5QJhCHS7o3zpch7GdNKRLa0x7F70SXCWiCTMuRzKlVCiA1qR+T6q819ovXYVB +eiOZquJ4tRmsxWZUD9pUx3Ifm2Vu6htZijXVept3zsEjYtezQq0WaqrrQFH7XarjDYaPXTBBlTCD +8ZyARvONMY7q7DqIDgbCkfxA1sqC0iM6gThtACmhpF+44ySFzhQMreFegkqsIzuxJ14TZregIJLZ +nAtMAMZypHhLLXywUuv6pDuASLtVWfaOssZsOnZDuup8wD6mzpxZp5s4Mmb0EQ6Q7apUXOv5Kifq +zsMugc1z22nCUHdnHqUiIjVfch5M3c7clvECGRhQiOuf80Fz2OhKEXah+ifYaf7GpOOffXb8otvJ +P5UC4f787Az9Uxxh0RiqC3X5IRf1N6bwsaL7SjHxcRQfMkPAtcD+Gs39Y8A5/YCfdPCeRl1jcB+w +Ck9X01HUDzqTPx2CGcOLWccw+czfRSfnDX+/8ReMv2+McegI5FXTeesTDu9oWEBHVQoY3NsQIHUO +Rjd6V7rvTv3zYQ9WDom73vmtSXfsuLFQY4ARxGXqKm+M3ZrJZogLSsMyqm5IXXPkzzn5EINinTYW +GHjHGINlNlUwkPFYxXYdSFglxW3lKI6ngJEVV3CRrd1DakarC2e0gy8xMxdGSW3WGLblkGiXvFgs +pfLXma3LwzF23BmhavXAfl0REWgXFpjL4A1WBvOybejK/DSbDuCr/ekMWORzOTno//u//5/Z//t/ +2eNM/Azsr/fJt9aOPxr2/PBKN5UJz/NJJSZQZ2IrM0vkutLIs7X80ZHAFjqwf/iSOTzfeYzs3x4E +9xp30WN65zyWy0zKg8/Ux3DjuLQRDQXz3UZ8us1dV4rcVipzXU6fMoep6lPwNDOZt/hSkToVAiTD +bBHEtPBV+IgS25m9l/huZj86nmamJ1TCF8jsVTcmUqPjWe6jclnN7DOdWr57kG4V4vHgh6Gravse +9McXSoEU/1CeFb6ec8xDLJodjKrT7FFt9hlJc1vzUoHZvs199YO3vkDhnThumgLb5pPv/M3l41O2 +no/fWHeqbpd6zuz3Ss+Z1DQ+iBSigXkpVG6/+wIIWaU3oGEU3p9v+Vw/079Lvec+Z/lP/oHUoONt +p9Aiq9+Z/cPgLYYDhjzNv3y8jMCvne/CUftoIxcTvraztdjWEI/hrtGe+wLJr1CkVWyxl6H8J/O6 +t58N0DuR3Fn0LZLJB69L+c58N31zvPW512o1evBXN1J8r37inkki0eAn3e23VPfluJ3rBw6DsUnk +aZ6t1na+4fjDmb3jT9oX4PZunjPZYSs4iByc7iX4wdNBl+cT03c6O2kdkZFeipQhtgrH0xuANj7Y +4W9pop3q5hMNsL7k6UEoFu3k+vzFAM/gvhrI5I/2t26L0SQ7Bety9Mhtpfn86CWyf9N+TFHNrWcE +Nj0MgAmlud0tuCSP3C13OYR4Sud6YS4mkuZNu0qQz1unhURjf6e0EXmYwF44+OIFQUFNfAGiuXnE +oN+RdGlf/LV/WzzBzfPR4hsGRt1TR4B074hIOl2MUoXDjwMRzu3B/l776+wFraQ8YADvPMeKvYBG +uWN5AM/KAMjQwRVs1GHQM3YjV3hFqAbC8pDhHrivVrZe+IoU3hMn38VGI7id45rXl/uVwms6W/9s +zbIX263TbJ2iwepn+ef7LfBN+6F493Y4l1GEqVZDpi89BZjQj08q0oLdjwrvtWIb4ROAbYQj6a29 +W7xCELIvUHwlIzc55u64lJlMPq+Z1OntIVohge1OOLB4u9FIbpR80aNSO3E13iU84YWFoHyBvcjB +PFQq9MkcccymwD9loovhpLnmKLNXn21m68ezuRGVupVU4V1a+LvJBnxWB3zsO97N6vE0v0p2SqGd +cTj/yV09FJvE/m6hM5lEic7FwZ48EIwOGRnVcvb1mETUth97K8GdehIvHH3xDbz38YIKte/BSfb8 +JXdayr8fCwR50myX8u3BPWKeJmtQzvW5g1sFNjerHjzkKvWtA90YfAEwis55odwLdEBXl/uQw9DE +e+p2ZBytvl0L/IrOyuPNZjIZ2WPOdBjZO5qO3vPdaZeD3DL2eEGFt44qyqz2OqmdAdjJV2FIXqeR +g+OHY6nTjyfAx2jwNlDdLc9e24Ns7e24kOgehEoYwHuwwmXrp6OPzE39qFEqCpd3vsB+hCg+yegY +F6OjM6q0w6XuwJrPk8VW73tH6gBtkH4DM+adx2AVsMeDYPaqP95Vt7tsVAD7CzL81eduPHtyXxv6 +AioWLr1/zdT5nfN89btOakTG7k7hPRt80ciAq1LpNbzxiaYBeO6wA7YU29S9FVcfvu9pJI3q610g +RMujYrTeOgBYvLwFG/tuO5I+4Gj0NluLZob5bveyDae2AZvUCycnlVhpv8iG0Vs4l4/dIW5eP80E +cv1jIg7X6lHZn7xw2N1lMjfNBH9ROb0imy/XWXpnY7tIhbdf8mQ5X83AX2lA4uQB0WmmDsloKH8o +P0v7AtpvcEv0DP6Zg0wxjz5Ef3K1KnUJ3x6gr+UO8vBZDoPK7sdKPBsrXFGvD+MibLIPeDJsDh8U +5K5ysNGZAgf3AvvTgsjIg0/LX+yhJnA0F2hIaAxgLgBOFg8FThNPGA4KYqcOn+0hYEovCIQeRXDI +Zp2iP0WMQYg1LTLRN3vwLZrGoYJK3BgODmNx+LF3KaOghvAp97KvmouyeGnbpXW9ELpl8AV0C4G/ +gchSYKNpIDxp0XGAZqX8iUDJPZeVMfgC2rVMm5Gc7ZLgIaNf8qxwp8qfmMZMCcMFWcDGVXlWCqno +aRbPxRJZB3imaOdI6DhQ5gwbn5shVbdTfQEZhQe6aco4SWlBHGpHk1e+RW91nYrrouw7FcVoVjWt +UC1qDDGRNdkqe/IIL2TmgYkUz6WE8IjAukW1agy29IJQDlYf4lGGnTZjgGhq8tb0RoZoQTDG9uUO +0BivOIEMn6NfGP3yTHnuJv4OGPgXLcq9ZHaYvXr/OAFq5clYJzCy9ZuTYSlDkj1foBwovwKcsCFO +pZvMLwP7pddZfTezR1xsRIo3dxVJlMW2VeqESivQW0nqdoCSoWGA1RcggiMq04xMAoPlJMcFgeoX +frS0pvi9h2opS/e2j5EdoJ1QBBkIvoAwOib4Yiz6zhRODr8ZdS+51072ali7ztZmR4NipJoIad/2 +S5lkYCwZFVdhxfjCHRw91r+z5/ncBdRhRO1qoEEMsEChFqadqUrZ4Pda11dZ/un4qnA82X0zA5Bl +K89H2ZPbS6AniyO7DvTK0/PORFT9qlwOiO2nuGw7xO1tB3vLAWoXku0AgfH89XPnpPB+Oa0luheP +QG0ufuexvk1Tm4/2xpClKeQLqI0hhULh1LCFfZc9LxW+bl/z3S8usfc+CHwA/XaXBDhJv/H8VXsE +BxdT9CNRja31nxVQgJJFYL+TZcHtyv6AdOEjFj7EHVzS6TegqJ0H85+R+3yimz5IiWulxZPGFukB +so+XFEMY8DH1GlxUEPpBp/QWdB5UMc2LxKkaiJVRsZPGdK5sgItKH1gWiv6v1f5VA032Oid5MKF2 +pPT2mk4Wyvf8OzDHixRBlZlTPdjLjfCTzkjBNFaUun27LLxfR8qAT5cKVLhdxDsQWapQBiQx43rZ +3+lZ7Su+9PK8u1UqDudvVCA5EMTV349uJx4FvlU9zl1eZMBc7gdnooE/vw9kL89qN6VCuC29UIh9 +tEPwvXnzgqieNMeKjaz3OVAPPbAu+c+njVQkXX59lSjrOQ5WMH6S651GgGp/8a7s2RT0tLzketTB +hvJCdgQQqfagT0Ahcgax/aB4O4DFZ9L3qnvGmtKZeuuO45eRw5vGt9RBnc/sndxvAvPxc0ML+zxb +K7e/wLocTKjM9UYSrQFagYPQnOpAkntHLwAfO/ycztEiJy8BUwW9vDQAiPq0+Domm5m962Bc5SSj +2P7m3vv84itbv27cgw5SfaL0lKHBaCoxmTvrHRi+QLJfGr1bUQwpt6xLu1cNzOXupdUeRfv9S1Bc +dqfQZDo1x92rGgjcvR+Akkvhi/5eqcA+UJH0/fOuEaILK18Ftqravbnq6yfCJ1iXNHc8L8Sv2rFM +6uyrJ4uoOrdZGuZF1yAgvtj4e9QtJO72MhI+g53EZ+flDeJzKg6uXDgQOejtAQvFPJUbnKeBFNMo +HmdM7nxOPwBUX02LkV3uXSWxFLqDpMRtb30LmdTtd3fvvdL8yKTuSmpQmGNj2z3Z9AWQxN6P3nMV +BFslu8WWRAjY6bMWWL+HvUJnfF5F6gS3VWW24DOqcFI/3VS652/61ToQdIfbxVdi+Fx4rxfefYFi +dHQ6z7KZ7GOxddEP69Ql0TP5EegBhprc5KeJs5tsvZqB2zAZMw5+P5SZxJLz7MVV4jnVfRHewYrf +7oJ1Uak3WBwdJADFVHeBgvJ0XXrd+0zoO6XS3wOwyB8bme/DVkd5AddqnhWa4484WbmJis/AEgN9 +rL79HSuFRsmw7hXZrB5RCghZvsIhn8Vy/QHxDuil98ClU+f3mb1xkjROTWwH1wW05IXL0a5lI9Qk +1W43v41NHmIFIvkQLOU7XC9bLzTIXF/YEggq+t3NpM4v+2jBVBzGQEXofOKgdfcINk3hNHtVz3wb +aWNrmu8enE4zqVKgwR1yd+X8Wf7mUNYOOVG+8Pvd1mPhqHV1kWNuqZlh4V+2NoDwIC5LoePDarLy +VJqJSrC4iHFAaCfc3sl29r3wsfXM8KlxPA/Uoe6uAgppfRDYe2cEie5xP7wdeIXUvV9sJh7GWs0b +j0yo72zXSq9bOzUwv8hT8eVr1kI+SCM+y7NiM7cb8gVSpxH6MVuv72xoiOXwSAZbFb1UIllUMROW +/nyyIJDKVimffQYqYuboDvCxQrTOyj5DPNpkL1usZ/nk1UeSecsNwCRzhGUTKAga0FQKx4bRuqye +ASusfnPYy+ynx7dAVvaHxI4JiE6uF5wd55j7zevKwRMTdDVTUc3TQAnFn2AvvaMzYH4UR+p9x2VG +UBoeQ18nmC5LbwET4SGpgEiRwsZZKXx/Mcue3JNtVacHJ2ftQnuQjKrPLMDIQoDLnw== + + + 9z4U/ouZ8Ojtk1XtVPn0AjPcyNnoq/CePO4XmrvdQLL6NtkvZfvDTeQO1dELWH14lJc6yyeeCicn ++wmsqlGXtVipSL6HSqns1aa0oLchwPnrCe6glE3nuMCYLRw1+gED/+lfhAFunq8gL40XTo4284Bb +ajfQfnR+cV/KELNXsObDZmljN0oCE/YafpOkwM6h38A2PBRUYOndUBgbl3ydf5HOrjIB7embiIS9 +UuhokE1+Pp1tlQoXp7VSYMwA5nLb+cjQuQdG2YuiGgR+KQoWOsPL8rWtfBb8t5LZj8XDpr3ARjtl +6Cx+Ao2KtHGPbfWyTCh3XQxNm8+QkZB6ZBHT6ANaAbBxY/eWvdSqOSr8XjcFQQaP29BkPsmOPs93 +1ZaT3U5FZC9ZfLaELzvfH9EpAFwrqtColZ/KgfKzAOilN1c1nlVLz2D1M9tIFUFnlFBP5jKnhfj5 +576KatNcdFTaDUc5oAYxAWBKZProsHGvk2zdiEdw3PG1eqZqF8QhVdqLbioGvIHG1GJ73H4vhU7K +SfUiI1q9fNqCL/rZWnP8jq1Fitv8yA02hS+VppSpjL+lXanIF9TLLb3f4Pcuzy+ytfk1ZRQo7KRw +NOhOgdjKDcAI+1zp7TSQtNYAzlP7VwBjp+3qlvlySzqFkBwlWsXmqBJzaFffuX0uNt6ONnODyI5K +QEs0ptI+Ds/uwEp3Vef2OmCqfWeYKRQo769gESu730DlPjqTJDJin1+T4F1pZz7u5Jh5Dlg6wNJW +2eSoySAkAA4aL/ZzX18XmcJR+3JWOA6FSvAY9AifG2X7jQFSjYqznaMNqefjOdDGjcpr1UyDFdXY +yVYb0l00e7n7CiRka0Cq2fHxfEYcPZb3dftBnAtQUFr11NlLc156e6EGkMZo+TD9QU1KB52civ3D +fY7xECB6j0A43IUK7zvjLW52MjsovfbjCU0v3ZfoB1iN6S6feonU4HlQRL8udHhIA4WAaWSZYHCU +JG9PElmhPJ3BsAGg0B017jLT8N1m4eT4+bvQ2X/ZVBYM6fxvDBDR72PAPp4SXKp5vuP2a/htEhhX +lUrpdfYcK2WCnbr2MI5DGwVzGMkwuACiORP7FEB/0XL5Qag/FZv17G3hg93p6riXzLgkniVLacyn +xCUporXwBdARZP7zcf+7lL3IjFOn0/lI6xrkuG8yeVVo5Ru9wm430eL36WKn+PB+VJTdk6hJDez4 +WgnKpkZWiMU3oS+kjNgWwtjFA19/qyRKhXkWHUteAo0jGCuUhtlTID/r4Vxvbz8mKig6iB+AwdXm +9bYSuIG5oQj0cjPHhksJwMfaqcKHiluK7+tbIpZF3F1nr0bVNy79He6pTWaI41xwv1qMPueAvc9R +A8U5i5AFZO9TF2As/b17XGjeda7AbktXyvev4zfEI+XtY4F5eXFEP+EBYOCx0hY3uawcAtXnELDo +k+8cGpLkHaUuQzNIT/vc9UU7AXbqdbQUIEPAbr68ihaON94J9Qxw4zHJ3Xy/Z5FIKAWqfEoHW24M +aKy08/AxLLyPniPIdWTqvxZZfU6A3uF6eR4fv2RPHsKCsvowBCBYbM03X4TzCl1P0tHjvdJr9Cal +m4sMp14c6cS2Fs5b/uOzFISn3oJmyDKAMVfOjr6nCRjdcV547t5vqU+rFQaQOm7cnCrz15jRl0D/ +PS0Fy4FSZSCbRcBAut2OF44jW6y65/5su9hqRtswiuCWOhSfDjZ34MK/Qn1tX+PpfuYzey+xebae +51+B1dkGFnYi1siOsp2SMjgMhQ5l9zJ7z9c5fnhUJwvPH88UsPdr/UxCAgb4xUUb7L/uPpiwRhUt +lnbK1bESjhTf2EnecNxx94Orx+4fqOJGLJf4HLYb28mP2wkYawVe05Uj892NxyDYL5Hd1neB2I4N +kXhnN/K7JLAJBptA3b9ulqHnNEDS/2dajpbThsIV0LXi2py3pD7rcdwYdnRJgeJ9VtrrMNVXZN3p +r2IBzwr1gi4jEt7M9fEuBfMZogf35Kq72kqsMOgPV2iF+XbSOx+KYVQ/MY3ri6TZNx6Yx80EkYic +RgCnntHwF8XsX6Zo+cWl/Au92KMP67McsCzKvcrW1UED0Mt9Wn5LRQ6uuM+NMF052IglgkCHAdyn +t78RPntIbkQ/u+DV23t8IzJP1Taip3eFjRhxShGJg/sQ6h6sWviSmVLTUzC4Qg+s5Fuazgm0AJjs +4AHF2qADJeUtUXntAMtiMkkfNLPR8dlx5iQ5TQuV/dt4afTA3BQnTw9E4aF0Xy8dZA9a5G6WH4q9 +0NuXkXxs9wr0V+WsposnFKeryW2o9ekbVaeTyd60DjqJHhEJpoanoYxsKpRmN9TLqLdDtHdI1PO5 +AnbyTEz3AWxhHkmXN3bQxNG6FHrxxFQoM8L33hf4s9wHX98XtJ0+TZ5Pny7NOy3zL2zq6CVu2unL +9hmQ+7pulU657kk5YN7p/kZoMiUDE/NOL8gnZpNK7Sqd+gJKt9Ng9DRm0Sn7GWoE74vmnTLhp8g+ +9WE+083SC+MLbF2P+1WzuRKl3EnGolNua3s4CR9YdHr/QpTez2pKpygOVu62vLG/Qx6/1k07LVeo +uiV6qYd0/Q11CmixWdSu6S2g5Kd5ugq7DRtXNXRPP/bJMOiUGRlIqUrkxE4vgkFdpyw7eB0rnSqU +jLt9nTx/DusWnWYaHF/aJk07fTl8u7LqtAK0Pjq092Q+1/2N5+nWZ+fKvNPLfDj9vT2omnUa2eun +0kqnYF20pLR7+JA5N++Uub8nSknizLTTzdIHv301oM7NOvUFiNLzc8lirtxWoDc8zVt12iDK0bcb +807LRDbYCfH3qFNfQI/g2Vb0UOz0PhbSIfjwjDkQ0Vt86pU0nT7sE1U+RsJOd3Wd+gLTzUpnxF01 +YhTolh/r6bf6+NCw6JTb4nvt0otVpwXidPc5iTpFNrJ2rkffqczX5OzKtNPaXpC27PSkU6MJs04h +52ceY0TtNbxpNtfp5kmlc/b4EA6ZdnoTHH5Ydlr7vHxrok59AeNcH8vEzcl437zTKh24LmX2D8w7 +HR9vmnUKeDLs9ua1vDmzQPDjOXF7eFIw7/Q0XXx9uXx+Nu30+bx3hDqF8sU41697tl2y6PRJIJ6n +/Zh5p2df48F5UqB1nYJeULevR7GhJYIngVpkw6LT+2ui2B0cm3YqnMU2NzLPMcDHQLepb/2mmb/y +r2KnTTqs2zThh2pjF3VKBdOhinamVeJtN5WFnUaVTkEvsFsA9utbYvoHE32n09HOgdjp7DCim+nG +U+MxjDvN3ZNHWkYYnUyv0xugF9Bt3MiVjmJorqDT/MzACiubHO70kDyJ6RhhdMycYUlDb6fyJ6hT +2IvY7fZk0mgOYaeErtPJJNsZSfR7vKHrdMp+pURJc5i6jOvQuznqvNV9ov7Qabxy2kFVrndeRinL +t/eX5ODG6u0nUXkLzJW3Bs4PWG9hx+JrsAY7kbw0rq8Or3vLCeRrXXw77QmGXckNPzfvzN5jpnhx +lHqyfCtQu1dv1m8/Gy9BGWPG91lq56Fl+bYaGR5S1m+b5+97ylsdxrit881Ws2LxtVDZqexfT/Hb +9+B3UvftdaQrKafv5GbKgLHr5nFtaPYec7lCpDexfHsbaCY2rN8+FVIHEsZM3r8FXvhty7dfs4tx +xfJt74bKXSpvDRgb9ErpF6uvwZAu91jLt8cUk76zxligNWzWqlZf72zsHD3tWr4tZk+bHcu3x9Th +JmmNsewGtR1OWbxlK0TxYFeacyq0p3sbqV9OD8W3+fi+fldW6m/l3azynpky0SutBZYn2sHHvMh/ +3gJ9+HYsmqOlVxazntxoeoZ/afgYNduGFmZ+I3acvAcW5lcd/hOHz0ob0cJVHv5zi+w32XrDPELs +r3GVkzjfZJMKHlzERH4O7ByNPpbeooPgw+MB2hvQ0lHtiMSpMAwCO/ZuDljr5g7o731f7m8r0T1o +hgF32ixO5m/xmIbdTjZ9AaVbZOlYdMptQTvn0bxT5v7BslMgRL5InT6mniuydCw7hSKvZdVpW90p +UwM2sqpb4SxXU3Xa3tnZUjpF2r/cKa1DL9T+5ZmW+5pOw/fIelV3q0HwAWXZKdL+LToF9iDQ/l+U +TsFcNHN9tuwUIHjKWHcKtX/LTn0BqP9/ms91fyNu12k1aNkp0imUTuHe13QLdYq6ZlU7Sal79Etc +iHD+oT1w0+5lPhiq975FS27r+6V4d+7Yjv0U6U7kFjkw56esyC0NW/ctNIDYuVI5aNKl+URkLju1 +jG7HJ7pbqajyT3ocatdFYx3yJGzvp8fh/bEMMYRApJOV7S80inSy/FgAjKtRhD3TCmsSu08XA+I/ +0dOR2AFSgaUOZN0SjAdM7mCMG+m8T4Dt5RKfnUJA/udKrTGLPrNzuXEB9lJWT/ft+FD0KYEhX1+A +BztQoZ3vStjBervIjlUzuNjRIlD2uIEBE8dsIID+gQR5q7WSzAbVSx7pBqUe0us8CEj3NEoFDwmV +H03nDkQoB9zyeZ47cUI6/EccPDbmTeYX3LCcny+gzBD9Y7mC0vrVNp3Xb0ue365IY2YzhMrrtQ2y +3K/fCNEntixcIssGGLmb+ypZgvK5IXcJWXsxT5Sl0JVGImPKKj99e8e8Kd6BcvMgUvLSmKdyD8lj +e7z7rJGlZT1hI+t5KWpZD23JenxOpFt8OpqoESgPWYPAHcx6zHH3AvPFJARbjCdajOJ/RNyRQ3Pc +3cc2LNm21a5E/jjTqd1vep+aWoqhydGHN/VTJ1SXT3bE0wTTgRQiulmppZhqVp2L+I64+gY2WgS9 +3Iw8TciMwwDaAebcnQq38jZU0/lbeAcM7q5gsUzRMdnYDlbQGLCff0HEENZS+nMUOZAoR0XJyKlj +Dox0C8wMFMK76pRn17jvGiW3+85+1wFZ2di8m9uu5RYZvSaj8J/HiOqQwkAWgDOGiidmywkwpl5Q ++A9YUMURbaQNMD+ZCxpp4/xSHpJqXGgus7LpyNLl5tRqkhmiM7tOGLQw45IoFt9pxLgk7bKTFuaW +9fSEqS9gKZhc6IxKY6DNPM4sxZIv4GV9yxAnFe/ak9neb5e1fNoEWacjRfDaDGl2eGwpK8+vxPG4 +UenAkKwVOmnpfAF3KwisfFvFwknn16zgMGCrWHhYv/LFQAGFKXkJYLWhi3GBXekKmFageB2XdMIr +Aru3N2K8TFKt1S2NsdfJCjGm5WgexzXW+mHe+InBcJ2lpwtqx5rzFzCeipkxaKXQmgpoKnf3ueHA +x1QKtvmunB1urmxX5u6+t70Zyvg81rCSFXhkUlVwAy1x79i539xxa3zIuqUeO+mpLJYd3QjmimFF +xxRM94vzMqWn9iaebiAiJRuH4sAFXA1Ep1suhhOHba8aCLaRIxYi6qMCXdePHmxyfCipDTKSY3uo +52kzrnJog19HkOaLHjqwcGoATXDDRocxZR8WG+TIXu3wBbwMamtBBqDllnDLPc8C9g== + + + YtktAzhSGIBbe996fkEXKPe5Q7pGV3D2Z+g1ecXX93UED/VuV0FUhRlZfJ6WFc6giYUzNXwsbHJA ++5+0W/oUT6zskOV+i1uaPchKAsjyuMU1yJK3OPqC3k72EtoNfgznot3ipla3s3cJUO2mOw+JnS/h +WO+S1Y/GziWr85AMjrUavIVR7OySBVNTbSRx9T27SY5hXMKpW/eGbCXph3I814rlBdwbgA6+KTQh +FKliWC33a6WTqRZ+H1/Azks3OIaHu/dL+X0gWpx9fTpWYOGvgdjhXFGyim9qPA1jjSqdmetVaUAH +1s5EkSe7UKYhlk/0qrQX3GF9DI0nYD8et/4F+vCaD+ooQmWLeRKEJzpNeLH9kroM20/Nmc5PFOEn +y5cFvNHjE73cs5qQL2BD6YB2tEJvEQZweB1gfQ5r7g4xrw5Oep9O1FnpsgA7OkHnJIfUuiyei0rU +wcOqoDp+A84KPHNDDJa7TkXJeTCeuDeft3HOdzUzaac9FXV9BAmAWflbzbyt2LKw8rdCYB42n7m9 +BDaNL7D0IQVaNXuR53MNR2tIehuNeCaO4Sy7AzEU2ZpUoEg82Qsc73JPtvdNgGlOCL0JUe35YBBp +F9GQVuPMozDVlZww5FHwqS/gvA1diBsIjIp7PuOzUCJgLOeuK1Sq1M/Ut0aK6TnatBc2cLRpT3+A +54KjmXpI8gAxme9lOdq1wtEk69WLBq8H5szRfC5PkCCwxTmavCvLN6MVcDSwamYczfPeB3C8czSD +7wLDWZ6jQSjLn70iODanQdFcSD7FSfgCZtqARgjdjOwsaPXRobmOwkSvtPGWwOYx+Mbhs2UPYCX5 +8h78tmZDLjWzPNjn5zOzzYw98N7YLAB2s+GJyfoClmx2wegH7Wa+Qba0xhJfREEBq6YLarLiMM5w +3Kn2llCQHwbAWT4EAkGxMKh1J+/OcLSH7i7dyyanCQjYKnzVWBaC+UWgdqGVhuBpbBn9XkWkjc2r +6dIW392tW2+WyndhKQ1vPen39j5YCGx5/f7p20wWepVicNW8u7SMUgzCWUa/V0GRZeHiUgzBMdHv +zaDI1qsFHLfS0F4WIg7z9L20NNTIwlf9OTHqBTxdSTgS5D+mcViirNQETylhGJa6wOvEZknUqIy6 +OH27u1vGV63z8wNgy+5u1bhM9rZ9rLUNxlypu9JKwl6sLCKwlnFX+9zm9DQP8HmTsPFcuQin0w3J +kiJQbI/j9tILpnw8ZhBL+XjClV3pQjBRubu2ZXiedeSahb0PRka5Q6WLzdWcri7aFgCzPLuRvT1u +A+oBMHp776S6Cg8JwBjvTcWwiEGEK/kad+WDxcAsNvu9bfAtpgif5L93NSiXFGHYXKJExltXkWdp +9nRoalmIa4Cy5aYfG7Hh5etG9OaluBHL0i8wb65olkGHb25ZPodOLcWMGXS6jKGFc+jsM+gQT15B +Dp1lpyiDzjJb0GMOnX0GnTpbcJkcOvsMOo3Wt0QOnX0GnSZbcIkcOvsMOptsQU85dPYZdChbcAU5 +dPbtxNzqpXPoDBtXk0EnWxZL5tDZZ9Ahfcw5h04TkGyTYXYRLJlp29Yx8NaZQLpgFxdDMvX0FpwD +t3fd5UuVdDbywsGwBb32a+IccOvpfSxopb23pVOd8RX0ARsL42lvV0Ou2lxRWcaH3CSDdb46N05O +FO0Znx0w+zgsd/NDvj6nzDnX89N5roz7xT3SE96HZJH56OC5shuSWcocnIunpDlXvKaoCwVRYnu8 +JVDNPIWC4Pgx02AQ725jK6cxuhlsaX/VfWzLfmo+l8lu2khIr45BRMlgzZf1GONkN6tjG62V5JTs +Zm2f2h84qLhl0TYYRGOaOpkhRV02gyZT2B0wbQgWaTyxaVLfTpmP7nhWo+TJ6EW70srsbdLWIZSe +UkxR7tupy6xDZ9seIMvsLFvWx4yuMyfHYU8Y69wk4Ntr06DZBU6sypZql2UWmEpT0ueBOapdrvP4 +5k4x8B7y+JpO+S9bGqeVdWqadRKMvSptjIEPHnxuWQ0qY5aiab1+jjHwrqMI2mWtB9N0/dzm8QkT +p5wYO2LQRqdDYCvLEJ0oJx9WmSlegDlTvHuMaR2sS2LMMU3U/SQVjrYQxrSOXyp3dx/TBjpVdIH1 +Jplc7nRZg8/XaGbJW/3K3G9pny+nA2EBoLeplcgmIN6oFxL+82a7uysujD3Z4nMw9j4qro09KwD6 +GMUFQDhdjQLWWb5Vw12q3EIr9Eo4yxdJpTHfFjDFzdnJ4LN1ScOsNAsjzkD2djlyPoc0ZxdHnmhC +9lee+AzmlY0emZoaQvlDhZkLlKtORqwo+evIm3vHxFTCmpJDgpyB61hnRM1MpfkC+tiR2x2v7HdL +fezryJt7xzrNTh9BtDCePh08DT6dKWFNAh49MpohafKRwaAoL+4PmyFpN7OzFLPBE+N2SPbR6c5J +cXZD0t/dEdf5f3FK0io8MsfII7NklBrQhLddeGTEMz6H9JztVHxnGY+Myt4/Xt4jAwCEbKI7PKSh +LeKRMWQLLu+RgWloOo+MVUaqU34e48kjY+rnP3aRnuMuOQem6IEN50zJ7sL3YKkOQqssnyjKsnXc +uBtlmT68jmy5IAb7nMTxyWoiGeC6pC6Dq3HqgKmlQg4xvW7S0BYMYFfLF5hAZu1d8pA+ZghdMM0W +dMqr8xw0a4xQRXl1LuP1bPPqVKmjNpnCzk7QE9tLqlS7V6Vb2obqXRjvIoXPXAo6KefdKjBpNflw +sJdVxNTZ58N5v39skXw4syjoi8Gq8+GWyLPwkA9nF6G6unw46LVecge6yIczuRHUMolr8Xw4TTSU +9E1w1flw+ntHcUbcqvPhHG8JWEk+nObEykWo5WL5cHpbzOpYB2ayLZ9ZDwXcymIiAShtTKSVbukm +JvJm5Com0mnvT3v0smpAHgVILJ+NjuBEnVbfJRw3eSSWULA+huCsIJPLEMlgEwPvzNFgcp21Q8wY +76yqZWMR8Rz83jVEPAe/HRZCtwktvT13N8tsQyX5SOVVWHYbAmC218qY8THLbXg/drsNbbRxiG9v +9qIpoa3mNmAEx9v2schHBnBWkghZSLiTYo5wrK8EtrhNyyrM2nglsONtaFqvtO62xnDU6MOCyWf2 +Fzs5GtRyRiq5uWiAiGrOVhcLL5SR2th8dZFE6jIjtbHZdOMycEj1W0lG6tP3ajJSIZxVZKTCfLHl +M1IhlFVkpEI47q6B1pnEZnF9aINYX5rqOcgoHBNXX7sN75behrpUOHM+tupUOBTPbxvRs4pUONN1 +WXkq3OJ+Sy3G7G13D3blEqlw6juIUDLcL0mFM/Eq/IJUOHP/mEv77N5OMVSzAvX9yXaJT5+Wsapu +boTX6mP5uINZ5DbQC4JiXXkUXTiQITDrm+086jCGS4a9Hi6ostHvXR7h2N3OC1i5mchTenFObtbn +1T1ZXoejFw6Sd9REPCj7F1aNi5r1J64BKnGZPv8s928ar4Wt9rxYSm5nXkr19EUxk5gFAecv1Q/5 +e1Q2vPBQnGSyFa5+nM/FW/l8LnECixDUxpI4CvS1QxY9TtpcLLOsM2gliTlKj9Z5Z8Jl6kJNXtpk +t73W+ana+azqlP3cDexvjKwy7Jj7O7tkt3bCslOiVM/ZZdgFzrunDatO32w6LceSqk71uVipyFTl +hdMnuzF3n1W5MqEuBWwzZJfsRsZ1nWrr8e0NrDLsuK2tb27+ZJXs9miXdTawz7Ab1euWne5UO59t +q0479vX4Lu+sOy2ePZYt0bs9pPderTq91GbYoVUFG1acNfol0nnKZbs9s3bYq6BpyTxVXUFkwhe4 +nSg6q5yJInomWUnp0ryvF6h2vmMXIbdaDTYyxHPRnBFd7IxWk9rjHKGq95pY17H6djEk1bmYzaCc +glOd4jyw9brKSnJmZUdM7lRx4V2yqyTnyQv3WHAdIumQDYnuhPQQ1+dURM42rs89PTkUkbOcn1nd +N6diI27n51xrwDXSneqM6O5SW6J+nPv9Uu5YFyKyDHd1W4DO3tO7SDbdYn4Yr9l0ZnaAVItzddl0 +Lu+HWTKbzswnqN8vy2fTmeXSLZr5aJ1NZ+aLN4+0XyabToMWcc+a3j+2VDadGSiHG0IWyKZbUCJ7 +zKYzO6eRZeXKsunMcunU9v5qsunMculcxvZ4yKYz87VLFdhXl01ntrrI07vSbDoz5UYdO7qabDqz +XDqL2+aXyKYzDulzy1pTWjSbzkw59QVWnU1ntn4m0VBLZtPpQTnWFF4om85Kt1xtNp17jC2TTacD +pT8TX1E23UIY85xNZ5tjtbJsOvPc6lVn05kBAL2sOJvO7LREFwO/gmw6M/agtV5XkU3ncDKyomw6 +Z/myimw6M2Qo2viqsumcMrlWk01nlktnWY9veQMwphiAmvpinq5usq7iZSxSqa/N4TLx6dths2uQ +z4ysatksXq/OMKQZPOVZdb06a+3CHZ5mkaAnPClY0kRCwpxMR8XCJQloEhQssp6tBqUbkltW4KK6 +nPZgaqEhQYyBQXkqu2w3JPNACksOY4Mnm7LLFiwTSjGtRXRIHk91FhG9nRw7FDa398zJ1bLsCt0t +XeZOdc+VS5V8kTJ3ltXlTlzlKrksc2eVyeUukc5VgIR9fLJS6G65tSrfj91UmbH1Urkqc+foUYSI +WbrMnajD2Be6W7rMHc59cyh05+7waHyygnuu6MNr0n4R3edZnKwsRGl8oqjcC+fygKkdhN3Sp+Up +DyxQ5xh76ESfMI0OGs+2HnhXiXRuIpp9zhmG1kEcrvMLQS82YYcegsggdixdf1pKdldhC/S8FdTn +E8FLUy3nbHY3lNV5T/lisGBilyYaChCVQzy462goAMoxfsx1NBQA5i6i2z6wGfG+lWQ+Ln8UAisK +2lwHLq6+SziuaruaQVFFdtVWsQMRFEMmu2mmsHMuOwLmKrHWqgaEPrG2NjQm1taGq7sVEAJbSSFj +RGNgtG6YmVp2WaKyboZKx3qvdjHUu8YjXZiJZ4ygtrXErWKoO9PeSjJT5JuPvWsSRlDV+aoqGIIX +F9ZHxK73/rWnQtVWp2+w8NrS6gSGYhfV6QHOCm4JwHCWrVaNoUib0OyGQ2+xqtcuEhk8nfCGIybb +8MZFIoMrD/zSFe6k/EqrGncLbEOT4IpF61Z7q3Bnl/m4xDaUCE2scLeSSnmO+UTuKuUtm08kV8pb +fhvaVLjT5iW5yQ9ZpMKdXb1XWOPOe4U7t7eaw+yn5RNrn74VNcfKenWdWAuAOas5PjeKDq5Nt1hi +rT7zkV3WfwTzC09N06G93XOF4CzANw13REA4K8nnPCXc2WKOcKxzYXVJTD6nayZQuTwv+e1mSUzq +U1HIIKKGbZgKOSyEC7+WVPfNZRqTmySm4MGL3hJVSTE3aUzaSTr4ThVQ8rpYpjGlQq4y1G3NdnlX +pkJudqWbJKbgwVCvfC9qV955SmKyiiCCtRNtJK03xfBOzOFd4lZ+nWJoclni3T2uAQ== + + + sYoc13zc+lYxaL94rUjnqdwjQqW1Pna/uqup7tHp24pyXO8tr6byrsM0p57KPTpUykssmOOq2p9y +GIaLrGfnHFcwJNdZz3Y5rqIHCC5ElTfvT1L9YMZb5aBe6JH5XOL4trDVOa75AoXDSK1+MHqLcOBX ++QJl95XunkptKpjeLGDBg1y7Kt+x+EuThHd2eKXuVJMP5wtMt27uL9SuKm0dtlT+8d4iHy5snYQ3 +mb+lSC1P1qXhEbtWuX/c1jZ/FX62SsJ7suwUzGWzNKYt50qUtx6uLTsNHjXjH1Z12MJKp3Iml4Lg +C5ZSdapNTZsG+R2ljiCty3IMhw4f+2ad+gIQwfqac5o0vIY+90+N3pP9C4tOua0Ac1Z4U3yw+oy4 +V5tOy9ucdafly60Hs05R3Tehokmt1Hd6ZVdH8OTGutNi8bqkiewC3W7D91H5l5iEOd89SGhX36Id +nScs26nzK4m33VTWBcRIajQrKmISzPme0Sud8mGN6O3RCs+8jZ9YFnQuwyYBUtkwOg3SVDFzDpx0 +IZsB7AN9YpOjh8Q6JckYWmU5JEjJ1oPKu0ltck5smq6qMgty6DpUZnHrSSrYh1ZZLp2hMgvooOYl +BM0u60538+QSWWkOEZoYSz539KQ79PI6P9lrDfPuPFdZtBiSIUpLv19cI91TlJYvYDcoaz+xtyEB +bmkdpyWOxxAbq2NXxaf0rvbwumismbKYKQFgH7m4+trBB/tSXNXljfexDXc3HLrIRrJ1L7s95Xkp +LnMTrZKTaLgybqFkN/Mja0/3Wr8UF/Qsa2/RhFmAy15Ca3ZXnGW+mJPVYrwrzsYAMvePaYNGTI5Y +GyVP9Q6sOUxpZTZyo6TnMIueeuOEO6t9jE6snMvXaUam9/M7u+xQPT5LrwrzbQgg6AkT7/qIRe2n +4MGd9eGgt0QyQz2LJcqy2WcyecqxSnq650A1JF3+S7ts5zt21MY1Q1KF6oun1apd6zEVsLftIpVT +fc+VTSqgU0ljh/VTTt7bZedEHdfEoKtrbFplxgMwpyo6QX12rQ0wnVRZDmOOuTzuJ6k9uVwSY471 +dDxhrMo8WQAzpAubaYcixhbMAnSbA+j6HhKrBDFXOYA20ekusgDd5gAa/clesgDd5gCqbzj0ngXo +NgcQea0XzgLUkIqNhamPg/WWBeg2BxBibPEsQAWf9nxDm2PlNQvQbQ6gbCMvlAVoMSRDDqD6vBKP +xzir5Yvyua/ItkxRPtVcfmFRPoNX4ZcU5XOqyLaaonw4Z8ReQVm+KJ8vYKIVrrwon7E+8q8oymdd +H3mVRflc1a9cpiif2qsAB8VZDkpEkVNqsHVVv+Xvhjpexd1QLuv6ubobaum6fqqpreBuKKu6ft7i +lBat62df1W+hu6FM6vrZe4XMLXHvdf3Mic/2bqgF6vo5U/Iq6vrZR4bInqsl6/o5ZXKtyKFrW9XP +F/Dk0LWs62c/NZ3vYuG6fpqBGKr6LVABxLSun/2EzCJUF6nrZ5qOaHeruXvEuM6UNb0LeoG6fvY3 +f8ln4kvW9bMVdHkkxVZQ18/eLezpBiqbun72pq5pFPQCdf3M0iSVrbdcPb4V5Lx7qutnDwX6+VdR +18/+QMXnGs4yie/6jNRF6/qZqJqqqn7q6gzEEnX9dNuQ0Fb109zZ5Tk9hZDr+jnmva6krp99VT+Z +kpes62cfcK3KSF2qrp+Sv2VGi7p7rhau62ePQKTBrqCun81em/boFdXj27WH4roen0M5Odf1+Jaq +6ydDMd0+XrM5DHX9bPIeHKNtO17r+tlr8vDGg1XU9bOS4TfGk8TF8rdcqPPSSaLTNnSq62d/3qyN +Ili8rp8W23prcdF6fN6CNKzr8a1g+8hV/Zavx+cmicnp9gZjrIa3Unz6jNTl6vppHNuGqn44Y2j5 +un5yqpRdXdGl6/rZqzkWNOa5rp99Vb+lb20S6/ot6etzWdfPRd7rCur62Vf181yPb6EsXB23NNb1 +WzwZXlXVT9XLUnX9jK5kdVU/q1vOvNb1sw/v0kmxhev62Qc66XxKC9f1M1kXVVU/+3vh3Nf1W9xv +qcWY95wnC7tyibp+CuMyq+q3cPSgrq6fLUWoKoAsV9fPXjHE1uvydf3sE2JFibx0XT/tJPVV/Qz6 +mOubrLR1/ayVIKzDONxk5bKunysdZum6fuqVNB7g2GTXWuxP87p+9sLBNotzZQmxWO4nTMTDg52O +dn5tHvGhv1fqE9+oqJOV4Km1a9c+8F6XtqihJonGlNOb9MFYnQePfVNiVyGNhIyPFMQQifMOJ+Pz +TGOJVqcw942afm4AsXK8EXk82yYSdz0eN4L5VBvbp+mjOBEabiRaj2OGnnwel9L95+Tl9W4oNggH +c985ovJxlt36nue4jadGmwa/3jIBVtir7Jyef1+x3737R1+AZ+NMSzgt3cVP4pMNtlpm3nJXvevD +du2Uu/2sd87Y75tQ5337NhtmCl+b9auTXqq/fzfqHIaG36/8d2CSGXJnG7dnh8FtOlTmAu+PR0fh ++efWIzN66qTEvY9yO9PX9drNRjzyktmgPr5vIvt0MEOUcic5ovTeOibK3M7VZPKWDE2mwu3RdOuF +a07Z5uOFnGlZjxwkYrdxuprclNLevhKT6dMIFptLbuHcaiMP0eSX7j1UX5PZ1uUYGtRyCUhYT3L+ +RgZ2s5nqsRmyEDLAdGc7cF3o7Q3LuaKMxlAj2LnYunmop7eHk0Rph2I+5lv99kYbZpIeS8mhG/Po +mDmD8WqnQ5STuJEt1esBYrvTRvb+xUirso912wdM7SKvSppT/K2qqQG2ZoaHNBfIz32BwkOpc4cK +aOafy1d33Fm+vZlJzPaPM4lpe6+U3OpdFG8z9AtA2zBd7t/cPWUr3EYTwLn5lsDi8pkhMtLjYSrj +/Utmr7oxQbPKDkaQkrMnt7evkeLNXQX+AhO+6Mdh0m4Um/Vp9n6CLCciMQvBaITXGebECTYelH6R +IeQ7Bhjhh+BPfhdl/QKGczQGfx5EEYfZCgIp9jgBD/Jx6cNSolSkTgUAtkJECtHAvBSqHB2R0eDn +oNjqfSeJRJoPo4HCwT2Tu3lyL99tJEjw4iCietHYzh/4AtKrfEx5ReUerg+lF0cJ5QW9vfeRlV6c +k/KLFxFt5YNd5ZnSM5T75XxU9Qr2LcIpg10PMLELZvoUgXMOU8/TL8AAy1ckugmHrBxe0WC6l7uq +6TY/IhCzlwDlB6Me2drmU/K5GGCFkLxyZCt2QMJGCZi3NCBbh0cQbZek+M3lNQILk1r3t2DPEZhb +jMTSNhWOMVD7r8eUTqnwYWYP97IHD7yvcv34x272ovVeLZwcbdQUkpSPBfJawzWgNThzVLhS2jeD +Byh5UYiX1QMZYo6dXWx3ys8Pwke2Nt/uFh/aFwScFYmoF1PyG/U8f8mIq3H/QkvkVWdUUy8c8i1p +H9zGEAKpwmUeSsDbhET2twB28xnWZrslRXWXvRW1ixH8Tcu/GAyiuDfgwJ8PIsTXVgkuyUNC+vqB +kH+RqtG8US9daTQPNHrhC4ivCr1tcR/0vlg8F62k1Z6Z7mjYjMwFLNgMkJWQ0ejYTOr5fBQq3uZO +j3Ph/gTm9HOVXJGI141sRl+lN4ioDXABAd3oGpbPxQC3FHf8XS+CSTJ39zIFs9qMJ7qbFzv0dnIw +I4hQfCpOFzAXFDeN3JPgTyaMsoLJ4lMG/pkCG2n7Kw35RlS1+k/gmxtIE5U4UoNgpEocGe5k+SUO +DfNKwsIFUyFkgtxRuVPS7EkIhop+k1Fi+OYLSAt1sov3XTQfaMrPxP0LdDi4nU/AwvM3lfxbL9vW +MKEqQbDNE7gQJyo6IMu5b6hxfJwjjJ2BDu5HiBPDqT9lRbUEsB78DDNXyHCwpLGVQ4pz1jTSXlrG +kPYMvjqFak4GCHBhjvWaHXZUUil36NlmPrsJPruawcY3mrsPJE0prAYR7RZ1ICL57cOiLKArVCh5 +TysqG3q2uZk+LBPtwLAwmRyMdtUqBNAP0L0KpYACguhssgkdiLu7i6wMohvSbJVyHyI1hNev+LQX +o3f2HkmA40IUUo5kV6KnkMbi+Onz9BVu8aepxGZeZxrMbwXFMsfUx6WsKT0rShIqMA1VzU344h7h +TqUnBxWlZTdzu9uQdJMDSlJL8P0MQPxtMmV9sWVYCFdal/kG7HQDrwAzfdyBUqz0uiHdkZHcEsfT +vz5TK+/30aGIsVwYOj3wpRCV5/jm1zXAU6QEOo3H0AY33hYBvXBgZOWIiITCtCYj4UmNhPnjuYwE +3Y0dERUKHid0U3V3h4wCXyCcf2i/SEgA41EjgZ9YIkFCwe62CgWH+e+RCgWHocIEoQBQstitVP8b +LYkzEgAT6iVwpzR/3hNRQM1JMzrAt2rca5GQUAj7bmOUKGIkTHL3jwoSQs3tqycLOhCvo5WrlgM+ +ZkZKtiAi3mlRGzksnQMoo/A8hpgZALQurkHEF9xSSnxymFhyNaLWNI04vzQKG5qORi1AuMID4vzR +uItp0JnLUEgE0Tg8146BtB8Dtitt+VOUkkBwW8pqTDfLJ3lNu8Su0g6WSr+wqPMOFie0LI2Fl6ex +xIJjUNEYuSyNhZensV1LEC4AYBqLuSBTDQj9NBxQKdKYLSaIJSkiEfEFXGDCFoQbzucL2IKwQqWr +1YAA4mpvz0JElXBN2Ejum4Iglp2Gamf4AotNg/I0BrT39aOgnfdnhTk4zUfwGCZpVnPp1xullwGK +RHaLCSrqfQw6bkktS1RU3IwiPHFLyo1yYyaHFG5JLbvFKVL7J6XjYxQtGguhdh0YpJkp9sggq0zR +9NPl2xC2IhSbrviS2hfNvvPOULRt73ox6rXSjhKJxncMWcPwjojpZwx+HUc2CH14vYlsv6B0nLgV +REE/yBTG3jXZFMa+teDB1Tf4MxPDfz5PO8hQDNLb+/tvpdfwI6r/8pL5kM3VkOz1eybaoVBKsk9T +uyrHmmoG6UxU5VYLHlbT0otSXHmB7ruQXTDA2FV53A5vxjnJU5ZC0wirey5nIiq3mqrncklx6L2g +mtDIC1dNiF6F8jkB3QMRnJkCjGcKW3LNl0BDmu5lBDvOmmMSkv1lTFavt6lgOgSTGi/jom+Ny0PK +uSRwdbkJ2aqcowci2NbDIyn6RO9LkcRprQf5QR2b/1SYS7WlTutx3AsR3hYIql8LFKPJ8Etmj7jZ +VgxvRGOS6Y29T4Y4Ldl6ryf+/96ufS+NXQs/Ae8w1KpcZzKZa7xVBRFaVCqiglYEmaKFgnI5e/ef +/exnrSTMDCNatvac+ismmcwiWbck31ozLkFxEb3YixRJiKKurYy30rXNkb1TM4/3nG+dhITiGtW4 +1N/6FfWlcRuoF01OO70AIbnIhBG34ja6igtVgm2Nki5goPzdiSVL/RqVpenVDQ8D0oNkqylLtGsh +AYsTAB1rNnaRYkPF96IMabNfJuLu5vRU0r5NXt77wBoNI26bnR/+BdO3grY/lwYPLQ== + + + hU7iawIjENq2XU8IoOvgeo9bfGqG61UfZRcw7LREzs1EgJz7YPc6x5Qw61jsLopJrnmYzoIrQzHt +gz9g2Lvxb5zBGB/N8Nf3gYVtlbSHy4kqoKqHzEaaeyfj4+bB50VP7cRWwfiOvwit9T/wUk2ekSNA +O0fyIxg7R5x2ctzDJMDDtHv7/Q+Dgp65cTzOTz6XLyTAvSIWj8p5xHkLzswVYtIPawmX415ouBJC +O+yayLFjVYbvQFP/2Ym5umMpLiWOop1O+97oZPTQfRgomdhmTNsr6Xpt0BkWRp535v09yQ/vpj+9 +wUTZULS9aq5Ucq28dzfseArPQbFunRDGIKA1mV4TjkTO5d0IFDr/nR32iiun2638d1LfCWXl8CP+ ++uPZUzxz/wN2J/H0nboazzQ7V/EMLVTjieI4g9W6gCH8mT2Ph92Cktiplbw32p8epI/KFxEAna+W +7PbscDu2enCx753uauPullbca3zJNwrn1V1tQoYcqYiCg2KmfrByQWxzNKKTtXhy69iMZ7X1c4xx +5mEuH/OuFs8kd3ex9XM8/fXDMc7vGC98imf3jE48c3RZjKeeVkao/65EkApTTJSjaQkNB/GbQrM5 +s8HKkBtGTJiQnul2Edk9f5I+FkFivNsHiTVexUy0hCz98FLSikB7wlbEqxsJtMZiVvoOfLGHJPG9 +tjGZIc6l0EpFiq0Jmy1hy0eggvhTbPV/F4EK4k8C9V4+AoVV2FrEoVrZDWg3JcpeKfAtQwocm7fP +FQ2j8C7Ppiq7YP8nINrKiYZrbQa+4OkjVGucbEoIR6tcGf56mA7FojprKixI9XKwjt/OvoUrewM4 +ltdaW2sb3cF6rbB1YP6IwKCYj/A1nFw1y7DycwEYjHCQCyguoieebVia4uw9xpxi8rP7lbmHhd11 +7yxf6mzHpTXVL3U/zETn4jfJfnNltmi2TH/qrbB6tU+4P81Il9uuaVLt25dEb5dLSSjBdkOsK+0b +usNKFGTVbmGugyx3TE5CirZ3yilmeQIUVC9n26TeFZmVbgJta4e3cr2OEbpwEzeaMBe+ut8ePa3y +ucznY+TCOVSgtWE343uB37sZ9JbgaNCbbMm0ip3eJ+FrMk+PJ4vdjO/HuJ131rQ1CeOL5fhoIKd7 +4qVm++z17WpKhrfBNfFtN6ozkdvui4OWWGvBueAKVEyIhdkb9/C8VUxJl6J/0Gg+e5Xm4W1/Wc/K +Z4B5jBtTZC7l/uvwS1I+g2YVtMVpguB/ZgqJeaazZFPwDGYCQ2FqZI8uYuqJyAZdLM3iLAC+xg80 +qeHo+mOO5D9vDclzrwPriwwzbad4hE3EotJcbuLUc3jDse7jrFypHze0pWOSgvazJzv8d38IMQb6 +hKkfo23tR3BEXBTYwbdFf50FdkbpSGxoNNr6VA1jH6R0nVHnSdzv1JqpAz+IVYsEsbBtJRzCatDP +kRAWOdg6EQRExOvrcxLTORLFtWLYVMzq+my9xrhp5pjia0VRn4ppLKl+m8bb+LsLd0BrM9Un3F+O +hJuBxbER2bS+/Vic+MlzHJEnMmoVl5GczZ+nfvio/kr4CC3n9+EjGSFeFDsR71ZdMnayIHISwjBj +q2+COPhLDQULbsIs4BE9yYJGwAKYC44nzATc6P+GCa2t44AFxlVfdwMW4D5bjYQRg3evL8OEZZD+ +1/Fo/keRX4+hvRpGxD8UN+PidUSRloxE4t+leocuzp46eGkUy42hOXqdgJDLqyTa4/eZ1OH91LfK +N0qjcv24hE6DtwyRiOh0pfmCWSzLyoo3DrzlmwKzO5Vh/PdjqM+yDxePYjTLXDDrPwMSpHhUv5sL +g1/7+lsPCZ4UvhVPIzrGX2PwHh2rDt6tY97knWPox9+tY+eDd+tYffivXO9zAu2Rr2OvqEjjtWnc +L83KF3WsN32fNOrNkLkKji3ixKsk2v/O8+EqFiXhjd4njfr9OKJSkmPLK1W99wbFnnsf0059MH3n +NEbxRZYB55flpzH98MYx+PvkxsrK7+yTjq8DEvH18/tqeAzt9strQGhFfo0Tbe/pPWNAb9m+f6dS +tXvj93rL9mDyW1f36jrUfpqG9slvMvH2NB6u3q18mKuurfCjgkCKMR3xUxrRCTuCkBBvsuvyDWZw +pgsd+1off16Lo/z6dt2aZWE2+ZExO8t6vR6Lc6WftIpQtSwlBJoHR+HU/FGYn4wzsppT+blZ9W/T +fID9OoCDkWNwsA0hbn8uAhXEn/i3/I8iUEH8KTYfgUIY7LBGOSoWBnoquTQHziTQUyllZ4fUaUqe +AitlVWBr+K5zqJ4S3P3r8NFBuWiVS0HW+HQ2UGVq90c1OYtFlbgs02GksH6i8m8x9l3D3fRukt9z +93bhZL/vrrgh6FrAtHDwls+ZPwshBKf3+qn2ryguohebp1gjAUW7tr2R26utbd7m7p0vj3tne4ML +AcXtX6VuZKDp7tLPmD4zgmcXwtJtlzMhDLYlAcj2qXi2AZ9wT4pS68O5AOACaIjuN4wixkbqPNDC +S1Kw7a4lsDWB0PZqqshx1P2s56wfFsqGcdlei4aAtRAi3OuaM/yoYcm5XJIVfjQLYDXxtOHCBOv0 +n0uv5qjC4gTrP5heHVt9McH6D6ZXi1jUwgTr9FvSq8f/7MQ2QaVKut48GHTCMabY6iq0VL3J9BE7 +WM19r/swKLd+eaOYrogfAj/wmym6ZfAKUSz8KLdjicOR5w2afe/7JKmUB7HVprY3muQf7iYPw0Fr +9EvZgCZd0faHw76S2CtVCxfKwd+Pw9FE4d+hnA2VXLWaxMjWq/3OH8YP7b4311+7PCrXSnllQ5HD ++NsqyKFsIhGdNGEw0EN0Bw40Y0TZg/+Xf8HHSYyoBP4ZMMOXC+LnshUjkhNw9y+ofIbCD2j6SzGV +I+XqG1E6SPg0plOVEeoquqFatmEpP2O6rro6ATKm6tiWrehEpcS2gJ2qZRhUcVWLGdTGuslsW8nF +DJVSU6d4h2HajpLVVcIcuOQCJWaYCtQd09EV7MhMBrfYqq4z21CyVHUNA7/NUW2bAA2VUdvh1HUL +hUhUw7JNuAWom4w6CozPtJmDI3YNC4hT1TZ1W4nOJBcrvCBgDG5qpcEEuN4Ztj2l0m/BRSV3/9Dv +KGetrhAAeaXPr0cvLCXVcR3G5uQBDpaEG6Bo29QxLSgYuuEAA0FKMBdqijnZjuMg94nKp01V04EL +TDUtZjp8cg6zgKMGM4ioW5YOkzRV1+TioKrOQOOBga7tcjGZOjDUUE1KDVvBfpbDWe9YDsgRx2gz +3eRicx3syYCUi5QcyuCrLcsWnKcqZcBR1ARm4GBdy2X4m9iOqUQn8f9jfGoKvHdtQhxkqwvqyJiC +0mCW6QYGANag2oyYhgJc06muA5+hhTAD7jNUYjJXKUOLDtwgyCnoQxj6DWgyQX+JYqvUsLhSBWW8 +heiWTTlnwBRcIOaCOiNHGTN1kIHpMoebDnMdF+6OtpShBdisixYG5oYtNhgcmAQakG1bKFReZMzh +rUjGr5RRZUyTMJ8CaoKOcoThI0PAICgKFH4zQrhAIy3lRS2mSi2UNvLM5O6AUUZRyo4uvs1ydT51 +W6cGUo20lLHFBoPHFhMGwhs4gxiYrGvCBRsMhJroKECFqJgCV3NiMGILonMtnAZzYagGzA7myf0B +A5NAWwOWMsUBb2OD9yFwe1Aug6U4huWaShZ7cluhqmHbeKfLdHQ+UTXJPVOccuw7LDR5n66OBg7q +w90mgenzFtN1hQ7oDqoEKAufGnSNTG2uhfOcMRdbHCJZDtTRCYBDtrEOo+E+EXyj9IlzLZwEMYEo +GqVlc29ocq+IcwUjh9+WiWIFgRNXGHe4ocwbYHfIG6hwNRZ1XFEHSWBdx4kaKpeZIBFuKSMzLIPx +ERu6sA+duEwwgctb6q8VVmZLKL9rEfT/2EmwgRdtAr5o1n9WQaGaLgoV581A6cEQJb/Bz3K3AOpD +QBtDFhxtKgdNlmoYDMkBP12bgS8whQ3BDCnFFcx0bYNre6SlHAMdweUO+jo28FrBuaKjRY1AvxnV +mdwzLULtStVi5X2xuYGtDt9OZLOw76m0ut7ZqPXQh61Od9z6j6e0BoPhpDXxHuGK0h1548lw5Cnj +++Ff2AK3zLrDpumkEPsvm0goug== + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/originals/SVG_Left_overlays/New_showstate_left.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/originals/SVG_Left_overlays/New_showstate_left.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,1594 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + + + + + + + + eJzsvWuTHMlxIPgL8j/0faAZaXdoZcYzg7d2ZvVqLW8hksYhJcpka2PgDDjELhqYw2DE4/3683d4 +ZFUDDaAkUdzuBBoN7yhPD48ID3+Fx0/+t19/9Wz37ds/vHwWb+eb6Sc/Obx7+eL923c/vyHozS9e +v/7xh/fvEPTT3/zsZkm3MzTa/WL9Whr+48t3P7x6++bn9Cv65R1++qdfvfjDy5dvXtzsfnj94v5n +Nz/9Gfzmt6/ev34Jv/vlyz9//cOf3v75h/cv3r/8+vXLP76//eFfv/uZvh3QHeEXgHL5uzn8XZiX ++WZuP88ZG7x4868vfvjh1f+Hvy5xjQDbv/3xzbev3ny3f/v//vwGmsIv4A/84r+++s3LHx787fHt +Nz/ev3zz/tfv3n7z8ocfDm9fv333w89vDn958ebmH158B795cfPPL1+/fvvnm/3rF9/8zwm6nb++ +e/X6JfTw/sX7m4X6u/vFEr7e//jq9be//PH+Dy+h77FUBMevCeXvfgBcgBZ/RnD9+hf3APnq5fv3 +QBW8EHl2+Id//m8HYPTbe2pHhN4uNwv8+9Nf737521/98gSvazcHZNL/Tr+F/823KQ8twpJ9k1AQ +A/7jmgwtInz+tg04YuUGv/n7vecM8w4a/stvXn73iqYEjNN//5n09N3b7+9fvPufP3CzGOAP/+a3 +L++/fw2jSexfym2+WTJ+05+kFXCVWjyLa715FkqEX8dWbkKzNn28Xv7rq5d//vnNL9++ecmDsnv3 +/iueEinNM3/n3/zmx9cv3/3uzav3QFlBUONR+Ye33758De3t83evX3z3g3Zy6d+5wW9fvPvu5XuY +TW9f//iepvuqb4BRf/7iLy9x6iz8gl99//LNb9/+I9H4rC63MQKbc+N/YUhiWW9KhNFd6RVphl7O +N7N7N408o0dkiErfAVPrJ7+G+fOrd6++e/Xm50Jh/frv3736ts+pGm5W/kaduF3d36Z/mVro+Pv3 +L98I9TCXD//g5uZ8+w9fwRtPb749vL1H7v+ACw5mwBuYHK/ffse/s5/pN/DxH79n6un/X8NA/frd +qzeIc/ol/Wb9+tevf4Rf/f27tz9+/4s3f3w7/ZTlzW/fvfgGmt386g//4+U370FuCKD/9NWPr96/ +vH3x6vuffRDRr1+/ePPi3Q3B4cMMfP7qX+E3L4CUG/4Y/KbDPo70+PKPsPT7Zxl6evOvL1+//f5l +hxvkxZtvb/7pxbvvP44ahuGdw0D/1X8f0dsX7/8EUurlm29/MLL4v2NHGfZxfF99g5Pi3c3+3Y8/ +/Onmt2/fvja0468Mu4AJiu3/Ot7xa/rAm1+9YQadv0kabN8EAuGv7i3Q+uE3wC//mrEfXrx+/eq7 +dy++/9Orby694MLv7U38u0+ZWH+5/8Pb169+uO/zyUF+/eLd+1ffvH751V9+eP/y/kPYkBt/fPXm +W5iIJHQ6tW/vv0et4uarP734/iXhfP+nO2r5lSHMX4Ng9KLv2bMPyMQQb/Zv3O///t2Lb1+BuAVt +af/6x5c3v4H/vnh9o+CfTZfBIO4B0bfTv0z/ZZrxa5njnOY8V3jWuc27eT8f59N8tyygLcQlLXkp +S13aslv2y2E5LqcwhyWEkEIJFZ41tLAL+3CYwjGcwl2c4xID7mWxxAoaWIu7uI8HeI7xFO/SnJYU +4cnwlFRTS7u0T4d0TKd0l4GWvOSQY05TzrnAU/OaW97lfT7kU74rc1kKaAAFPg2/LtP/pZ3pX4v9 +XS7+D3XGYN+j/AXSiB1xzhNxBf/q9yJ/k/xUgGMFeKbfV+If/m3upx383cP33UT/HIi9B/iLTObv +wGxgNxIHX9AZUN3gKy79h/8y3d3dne6Od4e7/d3ursGz3tW7cpfv0l28C3fL3Xy6O51Ox9PhtD/t +Tu20nuqpnPIpneIpnBZ4F3z8eDoej4fj/ribju24HuuxHPMxHeMxHBcg6+5wOhwPh8P+sDu0w3qo +h3LIhwRDFw4LkH63P+2P+8N+v9/t237d133Z533ax32Y9gv072532h13h91+t9u13bqru7LLu7SL +u7BbgBV3NFZ3d9Qd7NCROoXdwo7trHPYvUpdxE5iNxN1FTuL3YUO44NITqeJeo59P1D/kQPIg0Z8 +QE4gL5AbmTiCPEGuIF/wmY07yB/4moBJyCZgFDyNeLUSv5BjyDPkWuqdOf86PfI5bp/pHCQ8esyz +P3+mC8Dd+QOdSTc/+Xr/DvpU8KvSs8LT5IHBLHt6YF4AH5Cpd5VERwURAcIg0pMqLFn4MH+ttU21 +wbOr+wpTCpkII3K30opZF3hAhqwgKNa0wkpf6Z1rXfGrrTCLVphq64GG4IRTo80TLC0QSS202FID +4QDk1QatW2s7emB+NpjDOHY0EWBWwSIEIQYzMcB8jDArE8xN7BRQRkOJ64/WYaBnIRHITwJRGEEU +ZvoJvycQi5meQg9yoGBnSFg2+Hc30Q97fCl838v3Az2w3uD7CaUpzuZAcojeFQN+gQQFCYsPyEKQ +siDwwjqRsG0kcHcBFiVI3CN8P8F3Whgge1H6LiB9EQOKWRCkMCZoCVeSxiv0vYE8Jon8gLRBbvHy +If4hH5GfyNdGXMbxLMT3BCMQgSLs6oyDA0N0hME6wJDtsCkMYp1oRDOMb6SxXkBe3uGqhJlwgFmB +I9BgolSYNBmmTwJSAzB0huWPk+wI020PI9UATYWpmSeQ+wl2gACcn0E+nGBFHmB/2AFJK04+2DUy +7C8RmLeAyL6DRX+ELWYPg97SCm8osPkk4E+AkZwjyyVc0/REe4I8NF7HmR9ZbCJvDiQsDvy1p2dH +T5uQcQdixoFmPi4bEKiZhGoiwYqiNZB4xWcmIXtHghZF7ZHELQpc/NpNJHcbyV6UvpVXI8hglMKJ +JDHIYnhopu1nEskolFEsH0k0o3BG8YwCurEEuyANLjztsc80/Hf9pKdeeqaL4PLIJ58/Xdb9i037 +mw/8wE+Av+Umz7e1xQpWMyAA0/frz0ew/wHenmYQnwGbltRqvIilBJjIaJKvsLSpTVtnWHWKsd7G +tsSbmG9bzp2u66MmimFpLUtBvxGoYGu6iDakOmdEW0BJTOREAn0JGgva5RbVrRtQxTq5V8YLtO6P +pmirBnxZhb578e3Lm/dvb/7pT6jGT5v/w1AFVpqRkgwiiH6IFVTUc/EJJLWw5Dr+gFSOkw7x3Cie +i53lj48/IB6bSCP/roeShvkL0c2Aruab69FnCD9lYP/+3cuXb7xVtAEQVrGHTIgmE6LzRoSq+DQB +6nTcRFpFIB1jJl1XNtCD2zr7tgkbJ0lf2KJxs55h+8ZtfA8be4P9PpMesIBugHrCDrZXVDci6Cd3 +sAOhKYGWSJjPvraW0HkDkvldgmZRsMEyuwuiXge0SAYlG62Lk+nZ+8HKAM16EpV6GUyNI22N9J2N +tCb2Uha7Ck2tKIaYPp/w9bi+kvWI9iNbkAfQFdAQuBNLkm1JsyZF811F491ou6jvTk7ZTaTsFlJ2 +V1R1Uc+ltzrtlHXTRlrpgfRR1kUDaaGZNNAVZsgO5tUB5tkdzLoF5l+EmZiBgAqbfcO9fw+qwBF4 +fweKwgJKQwQVIgN1FRQM3stNAVxIAUQzHL+SqYLUVVbTSRlE87yRib4jM10UQzLW4ZlwWCMZXonG +K5Hqy5op4vRmg+vITpYJLpgjLZ476tYsXQv0Jl5smefGSpbykTwPkdTqlTTmI0zHQHpwFU+Duhmw +d2yE0bTkL5iqPG1pAi8ynUk5JhuSxp0e1CwuuA76F89HdhBE6n02yx+opQ+TTspaaUFfBamlrJgu +2JKUU1ZPUUFlFRWUVPrwB23lLjq64Eisa/NQ70iTx2cV7b7K8OJA85DzF04EnhTQDz9iwkZipFgK +q0yG/eCvwRFP5rEBRZ68NqPfBsZsIsdNhHaZtHBeeX3VjWuurze2Mtm+HGzLiUzLYKutG5a82nZb +q1LsSrYq2aZUqxI/sk5kVKpZeSCzkpwEaFbSw3ZlIM4msy4LreIqViauZrY099OZqakPm5yzmJ1s +eLLpycYnG6D+IQ5M8s8Hp+Znfv2tIlzs38UcewvvLRP59aL490g+uu2n/1RsW6q0RRVZ6NX9n1x7 +E/staHxoTRRZDXu3EnAZZOe6tE3HOS+LbDM86WHKw3SHOc9bS5Itpdn0PtG0Djal2UWCMxlt7aPM +YJ27su9MNGF3NkNPMid588m2+exk8zmStL4j6zGIhOYtqMI036EJuieLlLYh2IgWsl4jWbOFbNyV +rN4dGcL4dUJjmQznhUxp3FYyudFwza7TcSUP2150hSOI8jt0yZEuEehBlx2yj6QCufN4zdLGQsrI +Xo3x05E3g6N3bYBpvzdHnrrwkpj3ixj0JzHi2fmp7s8itnoUG52doKfJDPOd2ONVvKF5VB83quNO +hD2L+644homlPuqN5Hs5ivQfvS5l43UZ/S4ncpEdyF22m8z9ssJEYf9LpqkTzQuz4Ewma5p9MUea +anvxyOxI3q3kl6lg85Cak81BE8lJE8hRs8gq4Z31JE6bIzlu+BFPRdnZ0yaWqqyPmjPX+XL3gy9X +Pbndl6ue3O7LndWXOx1P5s5VX2735jbz5nZ/bnaen8Hjw96eyTl7Lrh6Lvh5zj09g69nQmfP4O7x +Dh/n9KGnOb+P+n7U+8OzLo/2SzRXUHAOoUVtGrNr9DkND3Fqkn9wfD4xKGBhgYeiAtM2MCDqzlbh +MZWHJvlJnIvsWtSZTX7FiSb1YtP5aBO56QSmmRvVtSjOxaM5F9W9WFmRm5wmd67H7cTVuJKrEZ2N +7G5EhyO5HMnpyG7HI82A/UTeR/Y/ogcSfZCFVKpEnshI3shAyhabRqh28wTnecmTSAd3xxrg4Lg3 +oTAPQuGgQsHxrZpPNp3JA2PfJEJAxYBf/7r258FN63kpzlrPyOkCHz0XkzhtA7nWPQ/34rxtA/PS +1L24xjHm1d4U5FVU42wqMSvEaHPfbfaJg+wU67BLPD44tgmNTbQI5o+FxsTd3md/V/j73D+wWNfB +U3e6OtPH+c6zXWQzjQ+OzY5E7mqjEkqYxIXeR6S50eCxYAf6iUZBp7BN3pGBpI/vWWGxKM+yie9U +U11GJfxOFHBVvoGUSfRu1bi7IuNVmbCJ56zODHUmKA7EZPan6jas3awkX3ckcw8kh09iac+m5LC9 +nU3RQVVnN5mug3sD7hGq7XR9J9EGYzqPqDwoXeE9LGBZaeJnb8rTQdAeLdpwZ+qUvkRfFCxqgbFJ +eae+V99dJZS5ykbIVOxkg2QlTBWxo2yiJ95R70QvU92s62dBtuEkT5anOI2ta20rm0cT/bMblDin +xtnTvyxoygY+a+BRdPBqWvhho4enQRPfqynqNPHcdfFJlPGjxDZVG8+mj+9set89qJHvZUpTqHKj +kg+uoEvOoNEdpBq5uoTi5LxCq0xZnbDsGFpMI89OJ9eJdfAbhoQsXXaH5HcsEn8slA== + + + 4bFayPHI3pfBcZDIcUCug0myPfY0EU/iN1L/Qfcg8GipD+FII9azPxZzI7gckCpevL35E7xHIZgX +L9twrkPUmv0Kx0ndeBK0XmQjU2+e+hi8l6FJ/HrnpJvIt3o3uUC2BrO762EMaeuzSnBbPRG7dd+f +aRVdUlaqLpshUCbOiu6yWMxx0R9xD030bRDTlMETQbYXIpfyd5xXTVN31A10J64/dgLpUusLLUzm +9imPW2cwIEcbCRwD70dFH6owetxC+gaCX8M6k+4n8db0bAB2zxwnt9Ie2i72bsXJdmGeymx2sCy7 +STYL2SgubBW6Wfjtwq1Dv2OgSJ+GbUM3juQ2j0L2ylaE7+zZj2J8Ese7G3fnwd+JB998+GJPXXLi +7wf7uVoKTJxEPVJL6TSY0d2QrmIOqSndjWkNdYvFM5lBPZrUGto+D2tvQtpiXKt5nScLzLjQzAfS +G3yCQ/HRGjW5J7a5BxVbLW+vaO9kfau6XUUKZDPE2RQX00U18EXEyWyRbt0+j/Yc7NkPD0uo3UTf +yKz2MfUxHN4zqjSrSjOrJOxjgR8X+plcntXB9mzdw5vLuerWejU1ILsMLLHdJzPfg0vIWlTPcClQ +J2fRH82u77a92PeTLIVmz2pP52CxJ7snXUgAgRke3LO4Z+7PJg3rNDzH8ZkO51/7s2f3wNPOH9Id +OQxynvNnGX8PJPx90KqZxEPxcQN/a92M9o3Z+JP5tXSpqZmThiyi7slSk3Vrri5s90wui2hvHqvq +TNU4mKne5N+bOVQtfpOmCwEczi/yIRwJ4liukToAvAtAnACT2LAnmVvkCxBrlu1ZdgiwVauWLdtW +2dwDqTsJpjHshskEQAPYtT6OvpawrB6Q6proB9g6A53qCZxBwYH/EG5RBxoTCq6LlpIK6jJDA2w2 +p9wo3aS0RrkAZJrjkaOU54YvyTAyAVMAFsZtKQot3gaYCZ3Qq2KVHJcAMxMRhAa4EGNo85KHvi9L +LQgpyoSAXe95Pjcl3EaYJz7F5ZpoidJlBZwDglAKoBiGLUNfkR2NkNM5H8YW2y1uazcxYQKQo/S6 +aInSL59OqdxSitCCzEnhmjN1i5pTYNYax7ypJaxp4EojfxL+UENONKIzskUZUW/hDZi2tDSXCXNd +vJ+SEPP81ZuXdOzJMmK2kJ7ttDkigNEwPiBwsAMCeDygDgbknRwPiBSyL/14ABqOU4/bbyyMk9gX +cRNSu2TMu6DalE9iX2yti8OZCa+2xbkJ7/xTkyUft60lP7imup3hfVP7dpZxPF20ONTm6LkSh27r +u0yJs1wJ9POry0pNEXZc7SRg4JxXZpN0q0QtkyTRiXJYUX9g99VJgnTssCpkYezEQSVTIchkyJoF +IROCz4zMcmqknxtZyS513gWdIJOkOGdxMbhZ4s6QpOEUyTYrIXjvz2Q26aPcPxcN09Xl/JCn4GSe +guCyfepZ7sHJcg96Prs6hWw6TVt3p5tVYZNtsM1mH3LZNalgcsnseWPNenv25DxIwVmzW8/ncaKI +boR5gfYq2qlHcjYGmhD12D42FcbJMLtDRH06aBr8USbDPA0CY5wM3du0uESVov4mmxLDpJge8AmO +02I7MfabKH1PDMvThTyVUcQsmxSVISFs6zRa52krd2ymeNFzebJcnC6Ty0o5O/sw+Mn7ZBkdH85T +jm4PjFzgHMHZgULlJMH+JJOj/e0kqPTcw/BAtle101x0jut8hnO62vkhuWguVElco4ms2x9O38NE +/rWFRBnueyzD7mCaRtrrMH/qCFNygamICbRNXWcw5yLMtRXm16GeYDJFmEQVQ0SH9QTURpgbFabD +ASbAAsNeKM/jCJIggASoNK4n2B4CjegOUzXcUl9B8h+OJ7DCwwQrp1C6xQG98HcLpdIVmJE7dFzd +2akuf0Ttcw6oDcbqdM3jaWimTh8/nvahpDszTC3+PF2Mw+mRFh+H88dZzg6z9JMs04WjLJ94kIXC +nxz8bHGdLO4ZLeJ5oiNDnGe80smiDJOUso3pLNKJMo73lHO80qEmPvSEB6JgOd3RucUDpSD3dN5E ++VWLZhc/TYWnqfA0FZ6mgpsKzl21lnkm3wJoZ6U1sslbTlKLhOzPS+dbPu1jcobl005mfcmprk88 +mfLV2z++57pBN//46rs3L9/TwaNL0H5mX3kwKQ8m5cG0TDM9wubHt3zkgOA5mbLegtaZbmq8BcU2 +fNLIXPo8DdFjPntb8hIS1saJC34g3qzrbY2hfRoJD6N5PCUtf97MHD/5KRPld2/evLh/+e3NdwK6 +gRUHM+UimKaj+G421Rcu2swXXSwPmMzTmb1c7YyMPw2+bHImxqwJlzcxWUi3uNQJ53JxYd3ucqlm +Fp+lAm1dLfksF2gI74qbhYzih40ZXzvivF5ElL9aLKIXjShYQ6JbD9WqQbCRvCMPz4FMiV4OgotB +0F94550cRsfzMPg3TCByg51A17PnfO4cT51XPndOdsiOxHU/ZH6yA+ZBDpmDeJ/odHmhszWa58GZ +Hnuyv/loOeb3wB5Bx0f0TFF+4Oj4NbZkvyNP19iS/Y48XWNL9jvy9Plbcj+7tC1csS1bsS1asS1Z +4epVTEOCsytXMaQ2zxb96znN+yFor2H7MrnIvYvdD9H7fkx9dxbA34bwqVbI+eH0j8TxOVGedcqx +iMWls+bnh8TzJvLdY99x2oS/XQj8LAiu+enHi5FwiYVPLhjew+HnAfEeEh+C4i6pXcZ7GsPiLjB+ ++lhgfFS9YOm3NX9IqYFNbGllXjk2BfIGf8DQSbqoJV0LIUfdGsivRHG8dV4uIwuwxumUeNEfJAx1 +WWm8Hsov27PDenHPBrDfs3lsSY/e22axkzQvSgqRs0jqmrp0lDb0Q1CT82190sla/3Vpb2TfL0eE +KB5EG1VypaI4EqRlopokD6Ijl7xfE6kme4n8BCoH1YtBgUJC6kiP9+zIC8auWTs+RZSZZzJaslU/ +guSTrE6WN7sMybk9PZf0k0nCHjtLpNI82DuX/KpJr5rw6hNd11Mbs64+qTrQpfI/m0JA06fU/3mo +6A+L0s80wy9Y4bThT1++40tVEpd0frDk/9V2Ut1LdTdVE1eNXM76L2bnxolNXTN21dxVg1dNXjV6 +1exVw5dM303hkFzmFrwkqSkHju+rhYh6P0o9TEFYQLsol23NL8U0WruwotZMcnZZsGyHjytzdQ9X +QGMm0IM1Ja6F8svEZ7woPeNYz66pj3545LCT+9k/h+HxOV3HafyvqOfuGRe5Hb+MQxLqpWP/48H/ +0TC507jvZOf/y+XjCf71JGUuVLo5U3o+4ZlGLen8oXU6atefoFx/rrfLp68/7ZdP++XTfvmfZr+M +GSSE3zoyLHCft0XbCRd0gl9yCtTF/fJLMfF++WW7blwAtNar7eKK7299L0+XN/MUR1MIv55Sz55S +z55Sz55Sz55Sz55Sz55Sz55Sz55Sz56STJ7yjZ6mwtNUeJoKn5V6hnvuJyV1LWgTty/IChMEj80w +0sOI+XbGY1+fkfymH/1CI71dNtKbM9Kdx45UZFWPSbcwwzq6mhHdqFZNmMtFiP5rZhFpvWpQe12X +tdwxpehuKA/hi7C4oojT4yvx/ufVLjlPKch3NpPg+8a5+qFrQM7L+X+0Rv/0QC3+x8QgzoMKIA96 +OsY2KeMsOYOvbfiYp/UThfT0gK/1s0X09FAu0rmI5oygDxXnCJb9c5KOf6A8BzNhGs76Hy3T57w4 +RxzqXN5Zak9P7FmVQ8Vyej5Y6/IB8QucKUu5KEYlNwQkXcUTr5Q2suTSPpyk+4UIR59rKfPCftw1 +jg5dO+mc6Ei2+Uk/4nH9QoRfJsrzZX8rgPEmzid/65O/9cnf+uRvffK3Pvlbn/ytT/7WJ3/rk2fl +ycn2NBWepsLTVPgyf6vdurFuhlEHEYfw0i0JDx4ymoZbEcabMMeTRuNNmP4at+Go0XTxrFFyZQsX +Vy7U38mh1Qv1Tg4pETq56vt+qowlDKMvYTjMGJ0zNmOmB6cMH0Tj2aJz5UMzRebJJBOlTxNO/Buv +oevzYzs7xrkBM2PCiUGzQudEnxGUQ8tOugarGSdBkORHXMO4gjMM9wJDrKXz29m5MfMwOf/SfpI1 +PF6mki8Wex0Lve4u36gyyTJ/6PaE81Ec7k1wt6hwXdbd9NCltptrbXVcLx0yHKTB9KA4wGH+uDjY +WZKnyIPpIwLBiwQvFEaxIIIBZ8B0QTA40SBTQUQ3rvlAQ3+iZY0Dj0NOFyZcuG/RlxUdxnm6OMx9 +kY4X5/RRfvCWjMmG2l+c4xatu754W3qUx7sXH6Uxnzayf3tFxnhJxjLcNrI/2wpg9Cc3/I/ZD9yO +4O7CcPdgTJss3ws7w7A3jLuD2x94IuDhiYOcuvjQVACVARWGHQxCIUVhISXhAKO/wgpJoBjMoBQc +QGivTn6cYPvY0RQK8JYTTZ4KkiLgDn+EubICfyNdq3GAaVBh4COQgVdo7GCIMozkQjdm7GC8MjBk +sTMJDQYkw0AsdCXGfqLbMDKstwWYzesMRSkyeAHmImORrSpBkZl6jSdzsMtO4t1krOP7PAemOZ61 +zeGF8wMLckbhb8AuV/dC9zN9yOGYNv6l7l0aXEvTIx2NH3Azjn7p6fMulLjonybP4vSB6yQeuEzi +w5eKTh+4VXS8RMLdK/qha0UnuThCXMbkH/RO46puYzn0cUeHPQId88h0vGOlKz72dKHH6XQ30bWc +fBVnpis4V/Sdo/cabxcR98LTVHiaCk9T4Wkq+KnwWeWj2ny7zO3zsmjko59XRqrMtym28gVpQ4rh +E/OGPqtc1pcGmMvl2gZl/VA9ovM48OZaGfKLf2BpTR9ZW351be9w8gvMIsOTC9Fcrkh08YayTQRv +byvvNGlg2IVjxrjweVR4rEy0iQlPFszrN9GsFhPWw8GHj4VrluEnLW40ljni/4X+v0l+jPZd4yaR +1NPCNY9EYS10jy7HU/inVcogFTqXS/fo7jY1kbZVkU5WF0nqIVFlJK2KxN97OaQ0STWkSteo7KQW +koYguRqSxKXpYnCthxSlIlKUYkho9aDuvpsolrOjOkh7Mo44PDlLHaRENyU9VUK6QiWkwT59tINC +3BOXyyh9xq2xro7OYeoVlSy3antn7PmNsfNZYSUrrTRt7ortN8X68kqD73NTYmkssrSbzuosjZWW +Lvs/5XLXodySONIm5wV1NZe2HrVLNZg+VofpoVpM2RcbGLIAP1STyVVlulyXCWbCdKE4U7+q6HJ9 +pl6h6UKNpmko0+QLNV26wGjxlSIuXGMEz3ShZJO/zUjm3n+mAk4gNea1UrWlGtJ6EdnCyXfzbQmS +8rbm1ObwQA7d9VB+mZKzlotKDoAffWEGl3xQG+WShUIJMQ8l3mhegho/l0ygwQh6CFExS4rRbRO6 +ENVgT51VZ/hYnO+jUb7HBgw/GjJ8CNHHYo9nqMZlBjsbXyizzKAM0HVB81xqG1YFJQ== + + + ClFeqUw6vmLm8jy+Gsa/9sK2Z2skXMw/DXFYOB/LrbxY2vOh1EoY42nQokc9erzIcUyo3KZUWkLl +NNz/W+wKvnWonjLaw2ANc42c8/yvukk83RoYWxNjMDKmbdaX45Hn1aOTBSeXLVgG7uzEE8DZQ2lM +F6TOuWTJXu51TJk8WsrkQ0mTVS5E3WH0pWfDbfPhLidOjobXGUumISW37rbXQ2Oa1EKdL9JlnATc +OZfZvL0hVVOa+XbUQCldlc64HOV8C59uweTlE1XhSaVM0F050QKmUaSzLA34dCLOJODFSudW7qCz +ZLZDp47QkQDUV6B5Txl7mK63Ep13EyVxFmAXJ3AuPYETJvLxeAeyLYKcq8CUPUhAvDs53CUeuU/S +7j+u3E8f1O43uv1jVPvpY9kIl5MRqHPX7RrmHD/ctQumy8e7N3082eJS93jkPtEy+1gHp0+1zD7W +vekxuSTn3ds4+vCNuEGCqtJKono6tQUuopMDVftRzXQO0C3aTDeX5Y2Fuq+FkS+0a3EhJKBWgZzA +QxwZdnfa20nXuiEnHpcUTYgNGwN/l1gv7szXQvhl2/VFb962UOmo565nem6k4maoPZ774rep36c4 +T+aFv1S1/EEfoSt65vyDXu/1uq+PIfg4glek/bGGrgPD1J1caMF1aeiWz2r3cQYfa6B4g/fQLZKG +HM2JVsVyaLPPs5cShFIXfJG64MliH2USdb1aDfC9S78/OY9XoL/JKM6O5kbLef/JKv+npPbV6ZqJ +fd4E8DR6Kj2dnlJPq6f2zp8q9OcKHdUD3Z5yTztR3ylULo40bqjc0Lm/cBaQrk4+Pwq4t4y71dxU +dgxwc0V3pxmo/sJT0l9sXcy3EVQhto9agUWAP5SWxyJvBU/LrSS10brHiAaVK7ss7K+G8YvEaQyX +xClAv/CezZOTO2eHqiYX1KxSOdIHNEWcfulpr93ZAZ8F9ZqHDvgM4dbHHC/aUuBDvWVz3owomM4E +nNKgVPDZxOsJtwuVHh8p3P4jc6Yf8+5Pfvt0SUiev3/jz0TTkeuzw6DRagWzbhmrKOqVzVXvwv3g +ur8eys8M/uKlxzl8SfBXMHyZ4LnodoljlcVHJfpSmu+jsnwflSz6gNV2IT3wMQmHZ5lzD6HzobnH +JCdQasKjklT+mtF5nyZKwkTu8tzoJm/kYBgOzYvf/PwHf4NRu12X4Vrzq2P+xIU3f+js/ad8+osW +XLoYIUgXAgT61StPB0vu5DTP7Fz1RRJBOSG0Uvx8VfOgR9F7fXMJHW6Klt9Z7Jy30kXuFlooiq6e +/ziR4RNlkRVZbsVi63zb0CqxdbUxOMJ+oMXKu7HG2k+Thu+4n/yyEKRoMH9FOSHOTyZJxIF4vpmI +7ybifXydxFaR/9J3vbao0cVFeoERb/hsgR3kjPH4nX43WZOj+7c/pwvPHXk/hkAljpvXauKgyx0H +XU5N46PV/Y7S5VX6wOoSKUvTR8xivcjrSJ7HB8onuFy0NFm6zDYRLZJPUtNktvV14kP1dSZLQMsX +K+ywM/pC9tkDuWe7SVzxd3IUOWjymeSeHaRGefe1fyT7bDqToZqAppJUZalKU5anLFF3ZLIdSK4e +/Rir7prs/PBqgbVm6SxHS1xZBj06W75Km2QxmSora0WVfE1O0Vu6dk6rPklWij82nzXfaiXXnU6c +bgR8OK9RfSs6leDvdCEJa5vhOOZgbWty6MSS3KuJUq96biPPK3T9n8j/HWhC4XTa0VTiiRRkIvG9 +CUeKXwSaPnUS530/6YzVLvSkc5FzznckldAnzsec79AfDqPdYISPWnD+b+fE+785wuWBhybwJLub +urjU0ZXO9rdxX7u0oR30Uo5xP1vcHubj17zA/Oa1isnIZuNOjaC7zVUC480APrdlzGoZs1mkoNU0 +ZLAMeSubfBV/g9iYnjKkpUxDPsp4W9iYfjKknQzpJkOWyTSml1BqE3uMxgQnNuQ0zUkTnaJsiktP +d5ok4+lOEm6OLu+J3Ux6sRwnP7HLaUyB0mOglAg1DblQmg+16CyQkTm5vKijvKUfDpUDok8Hk//2 +DyZfLZfksjNjHOXPHufJ5XN++UjDWE+Pqyj3gbHejPb0WbHDD4z39Ojo4UdHfGPJrnVeMBjWGmwm +ga7VgJ0gruTaEYfOLDk0C0b0HszK+VJM/+mycS4X9sS6nmalOk+J7fK6hfdCOcWpujuzN090tdFs +ezHvxJaYPW1ysiUbm1QEzcJOZAnplbSVbkNaxbbbmXkmRthk2diRNF/SfWmuserLtcR2FKQ/kuV0 +IhV/JvsJFWBUgRPdkFOwKM9ESRyoC+9ofh+lyhifSMD+B3kSVe1BpRjVYlSMV1otXF5K1WO6N3km +LZkrTXGdKTyxkOnoLxea8qWmDlyNzOqRLXKGgdNs8kSZNuuQZ8OZNrjsz/NsKNNmNEyjudp57NQ4 +XWjMPnySKvcqR9PFM1QrJcbsLgUctqen5IxHFE7WyezVA7LOWRbetjg8cHZKD04Nd0wnyqoZrdaj +3S2tZiuy8iNlYTl3ahrOTXnLVW9nOw6npgJldhfK0DlPEgPTdRos11Uu0rrs/mPj9ePXZT3u4qwH +r9OaPnKn1sU7tj70nN+/9aF7tx5xG9d0oXTtY4rZPvhMD1a7/dhTLz/TQ794oFouPaNFoqzV3it9 +ikKtDjU3Fosdq5lhifCfeLX0w5dLo60wPeZy6cdfL33I04Xrpa9wwfRnXjEthx18AZG76UJxCV9e +YltggkpMPNkef0u2xwMZEhk4EDHQ0TBENpb2LalS2kFWRRJL/ab6gCp6PZT/6XTScjFyAtCLteZJ +oeENfWfuwsuHoCUf+MJmrh7oI6WKP/IItN6ZWYfN3Od80ynoyTmiuyuaNnTZ0hd3G2YWr7Rs7eaZ +5sPRJxTmE/u6OPWzV5/tbnlNptbccubOeIB1bxnVd/4gK9c9SrSmC63uRut8Ryv+sMkuj5SJjNKh +UD7y5vZalLcTJVOLS1ZSqtkve5Cs+s7KSnrRjitSiqeWfbXord3zLaITO2z/13bJ8mbysQr7H77r +9/wC3wvH7T5cef/CUTz/TA/qlQ99HR94xJcop/io959ytvUx+86npYg/YteZrpc/LQdbpWYQrfuV +Dlf0ylLhQjWxgystVaU756WlqFsTGVnYM95TuX9WYYr6yL3sNca218pyd+Vi2Qn7vKk45e+W5d4P +daeEByeJum6ul504EPzgxosllzD9uaW6tsu7JBb6x3SExJX/P7jXfSHCcdNt0EvKNFzx1IokQvCO +3XTnxptVKWmCrwD4iFbwpRi/aIOul/bn+qUpjE/3BzzdH/B0f8DT/QFP9wc83R/w2Yrxvy/Cp/sD +nu4PeHKKPRWNf5oKT1PhaSr829/X+vgihuM570/62H86f3m7eKawbc4UnozReyuyt5PsynVTXrrY +T5dKTdO/05Dd+bk61gVNMMjRZ3QZkMNACiWhEcBqkubIs4LUKAvkSJo+qUeTnHBk1wBaellqcXBW +/MkdE6+UpLG3zGXLWybKTHWNVuXFV3dRb79mns8SxFfPv2ahs/u/4lFAtot3FD89SFj/JKH92WIB +PRqggf4iaZ8fD/Z/JJj/sbj9eWz+MTH6Taid5fdnyukLYpqE9PTlNRN3bHpsKuWPTsxs8k8loMrA +w+C/LCYI4zS4L49naWwqE1Uqbi9RINn4gF8TZvCa6UzUsrQ8FGZrfETR7giFXxHoY67DL0bJAjKX +eby7FD4QWvFCDk9yYYk4+AFrUoRyWVx+KaYvE54X61u0sb6FFQRVgcMuhjs9kuN8Td7PNB6o2JSJ +3nqYLpWIHt2SD5SIRl/BZD6lrW/SPEmj3LhQKmpbkZbDebsLtWgXCY/2+lllsvJQO+dHHGOlyZ3a +4YjpjrJALGoqUpTk50RpJJlif5wK1SwZSuKnY4++SMJcOhR9QcY8QsI8rAZOH9cD9b7n/SbxfyxZ +ui1aeilR57TN8B8Ll66bvP40JO1s03Y25Usnl8PfDhcLmHKMak+zUq8x6tGqbbyK1diHL0ORmNWk +QavhRpR+JworuNu41aXIFSu8UucI5b6X/Kz7SvRqk2kc52UIBYFSEsaj5Bp9aVqEMq0BxMNFyXcd +dFx8CBW0QZavddmki0AHQZzfuFPuAQNXD20Y10P5IQENgK9/+fbNr9+9evP+1Zvvnj1zctv/Yvrl +9/ibyL/59Yv371++ewMC/av/58cX717+cLN7893rl9+CLN8AbpblNqW6yr/xppRbjOjJvxG6+iN2 +12yB3/+F/vt/w4//A4B/vkk3/3DzL/99vvmW4L//DfyzxXnvYIL35jnANu8aYPrZ5xfwIewNve5X +NBRgOYF+QTnotRKb07zCjoPbYS20Lc48L7CCq1SsipwL9PsX+AJ4KdZ1zbdgaCamV0D8L72Sftsu +QORjz88xIeiP8DesWMAStswVVIZa6Q0Ki+12aWsYPn4Jpp99fgGfvoc+B5zK0FGQovQehZXlNjaw +8/znL8H0s88v4NP3KE36ec+xGm5Tq4swqM1zuwTyb95i07fQx0rxw6IgNwj8qQsQNwYbTPoC6lZN ++tl7B/KcVS5cgvnZMGLTlxA1MEt0TO8djD/Sho9fgvn5sMU3cGszJgrzA6CfvwTzI7DFp+8BQRdg +W8BllucK2zXG0CMINpbVCenF6kGSBSAF10B68w+04Oab33D1kQDLkwvJ1TSWQOhiFZVuVshhX6Tj +Jyuu5pvf77jm8c2f/Uztc+XSsF1aTBfW7AYbgv7AUr9mLkzbySthGaokJS5Di14UIhN6yeYC9Xw7 +v+4fGPlhNW5gnvhL85VJhV1+odp3IWL44yJvZTtyFg1IR6CfaR1mqUiTS7NHuXUJ5iXHFl+ntYKy +H2l/rAtPLWiXCzG6YZwTBbYmbGQ2caiSBu6qgwh3S/mSMMVCVxuZKyC3ai/I/j9caeJvhbGfpxWG +MAlbTJhegPkFeUm4X3X4aRMF2dkHfxC1F8SgguRzz88wXXPYN/uB3yL8GF+SoxfE9YXdhQlNCazI +sRZaymsbtVMtgbkqVyXviQnFgXQU3DsYr4t0Lok3ME/9Fp/SutUqvKbhcYrqcgHkMV7SUfAtv5tO +rG6CfirK5mfpqyv/Zv/uxx/+pHjM3RDmn03zzQ7+/v7P04/wDFroZR2UNNBnCXTz23wDkjph5c8F +uPAMVML1FiP5Dvx8BIdyixcTElgxXIL1j7+ZUAfFiTwvNPYVj4XhJAWLbCXhXwuYCXQgEncvhFgB +/kXnsUONhkUORHBoMB3XnBAcb+cAnwHgmm/B9hMyIix5gNV4W+e5OtK+wc8XpAcmIIGx4dLgw635 +hn+BhmBoAU4guzdc6rbhv2LDOQPGkPzLYXnizlwGKj2vpUeHaWiL+xXgvRmQIrMbqOkDAToC34yU +AjgX6NzQK237l7H7va1jlbbFjjmudhoc/zu124E6TH+cfje1m5/+7Ob3/wQ/0aSGVQ== + + + MEzpj810gt4A+CYMU/7RE34F9el2XUEzWcNcsDwvzfl1XiOKiebAzzfgcFtqXgnskTwANiTXmvmE +vRSQoIA9wUaQE1G+wOQiSEygXnGztC6JgRl21JuRMmi5rhWnGYMjdw9RgpnOQDTDGYhXit5cfDkO +KHII2hSlIaUlCT/zLTqrEQw/zbBDIbDwpOS2MRYC1ls8Ls3AtsBaOBACmEnoE2BwDou2jUleludw +ww0X3LcJVmYgnD/fYEecVyZgoYm6zm25Bd4Hbrsyw2aYvRkaKG/SyghwUsckxIZSCs8IAAO1deAO +7MGwoFdhb64hCjAuixKLqbOMF8FRGRZblrYhzII1zUURhLUoz1G5NQS52gDnIG1h442KYFUgmPxK +wZrk8+kWI3HSFE0GAXYmwJwX4IJuASZgnoMhgNUvXASlqwpncN6UJhyH/xKKfJvCLDMshcwcL0CB +dqzmrB0DMHadR7JFRdBSVmBKWYFNCesdg0VnM7/VwH1Yb8NSZB6BqGWkMDmCTg4QWPL5BjO7CK0t +CQ8bKoby/ooTXz4vkwvXxWqfx4wpnbKLfr40/jy8KoQswIaMZ2BdF16OMy14QVDXinMeganxyGRY +5HEV4JpKFV6voRgCmJE6BEtjKbbMC7wkyutSEBQLqp9Re0vcRmCas1AbYcEK3gX3BVnN8zp3vGWd +hQoqu8dAzPwShpfKwHCL8XrtcAmCF8ApSd8WWLyCN0BHk9AbclsFRcIxYRQ5VgGWGHWVh2hoy/g2 +RgurFLepzjQGRhOBJLMFCKq2EMDSjsGwGQi587IWIaHNOsBLXoMgWFIfyaT9RemgAwGygdvCtE+5 +6WSU3laQ4lG7kIsOBOz2qegUC7VK24pl3JnjKNwFuFZdY8UhaFEFzRqZgBV6u0pTLNkpQNDc9U1t +1h4AGLos4FVmzXoLjItnCNBYEiAoL4aASOSls5L4QyCoO4vOg8CD0FjmdG4zgoajqAPGmwgBky7d +FbbaG2spFFT4ryGI0TacAmAGllyrMtaA5G9lCowFAJ2DLRwZ8IbcVHYtStSadNNdF51Fy8xTnbE2 +nkUA7HKSRCIDS1uV2bgZKYIMdGlbntwLrPFku00gOYUtwRQswtdYaGYsuAkGFX4Ylj0oAn1Vou2S +QDnoZKkG67JbNyUEx1Z0JUcWMQBsfb2w7INXA/vX5mhiBAE9zbo4F1ZbEBh0vWC85uafpS3awbrT +CF5YciHZhF0FBgJZ1xtKGn5XRC1MV1yxz2dkht99ENh30FqWagjaHHXN4wkaBMLHQjBFhlQeBMZa +5VVgDMjnAVlUAkDV5nfBjy1sWZhhMNfoRCEjAGSl6YJBQc9AUtl5uOZSBJjmYf9SBCWs0tucmmiw ++LqWBQUZvPIytFFEw1oMbzWNZdHFgXgXnbKy34PKZVq0qUcIXGD+qHpkrC0gd1TRxAxlaVvnZPJB +WFthSHXKBVve6JOIq066UpK0xRM6yhrWlBFBUE0Mw+6CACRnsl0trbJ7ABjkloJLVhSqK6PwL1GA +zfaZgL4OxdtqksUYsXY8AkHNLTrtsRyyAEEarrqvBuXtipWFsiOMgTUpa7IMGMjYedXta6mrfR4W +sXKmFv1839qXFJSqGm0D7WPTUArqugHm3wgQ9nZFMCswrNWAJRuCPsXFDcvgVJfa1TGGrWGJjokM +LEGHPOFmrWjzvOTN0EDbqqoBDHMSYILtR5WpZTUEZVE5kUW3AGCLiwALLEgEBiwArjsVJlgwgoBn +5uekCFimBzLkipLFe0rAGJuqPKTHK4KUmrBA1FwErlHVuSpdCMttSMrvFfVNRgDgzDyA1RZ43QAQ +DBbpbo4sJhAYg74q6roBMGayCWFr4y4Et1eISo3AnFSmge0qowDgVHWzyStLYGwrZlw2bRCBi64E +vKHKEJCiwt1Fx7cA0QZmrMAjAYJYVgpAwBqCFrPOA9FHQzSlGn0XOQswtJSUs6qcADiuuvCI9QKM +ukKKKHiItekKKUkVcADDz4KAOoPA5IQ12S0M7CoP7BAifBAsygVQwPpdyOiAXnhol2jAWIMCg3Ig +uw1TQjIMTlElB21jDKxJjZDGIhFhRT9fg6EtZjJqj2DTUqm1stgLuKR1AlVTlwLq2qoE0FxgYG5N +qJ+LTHfc63QZV5ObSJPJWCMePrYURSCqOABDVk16RSNWqV9WlRpi9ROCrL1PotwQAptsphqhq2vR +QbE5WGD5Fp0BKh6K6eeZtVtFsAYVyBXV7ucKjrw40PRlpS/gtlY9Fxg4y4opXRNFKMqavo4YmMGi +kYkhNgYAKeLESFNZDEEyBTep1wvBtM0zuMosrjyo4zBUJ6VXFBqKl/gsq154gxuoTW12MRCwJuut +blUIRludOkECF4Fgyqc+OecqQF1xMpMYwWo2EU5uEQWw/aSmMlIsLQAmW3G1qooWmrMh27wqArw8 +U19WieFxZpOly0hCEOlSTqUgMrVxNkeRrTmELToT16BGLH6+6ZZSUNYwMNjCQ4eaACmmJYOgAh3B +RZ0c68JrDIA1Ry+7GUgeNtmodOFF9BA03RVxaQtwSTqKkecsAqO2bFi1XxHEYtsq7+sAU5cjjGzJ +3INAtf3dLsGfDyB29POq0AKCmnVHoSFiYMN9X9602OfxtKJoIWInADAFBa5FqIJdRlxtiDRFQ4A5 +ZE7KPBcwWKC6e/BWG2FHiVFnbGRXasRdQn0D9BFGiy5A3VGa7FMA7LoNaaMMzGLsFgz1yfKI6HpM +ZSQAVacgkzuwowqBaq77jRLBzbrbqiKopsMUMRYBiLlzOol0m4ooqqPShb5NwVpUmmBGqVGg+ikK +c0fBYpOeHRGIda6qbYgRjsBFacWTpoagzjpn1ekRUb6bQBS5g12oqrXmohpXBMJXVa5iEmoLx/FY +eNalCVA9GbgPqjqO4DnassuKAKaUUiCOCACSpSzTICoPQHw32VVZVjwXcBK9s7BXg4FhVZdYFU89 +Ak2dpq1T8SYzNLJsrrHyQIuGyppcrHRDjZtzjAB976ZPBw1vxGrblVt5q/PsZTEqABiiqkHFbPzz +ts8VbLOZ/MkMjE3Fp3i5EZhnjSpktO0Ub9c8dWNAGooaFVVcXfgqczjSlqwIQlTmNIrXMQW2XzUx +zYgCW5Cpfx6Pzo6aa0QrTPVsVX0B2F1KqxkgGDde1KFQV1bUERiTbW0y5gBcoyo+2Xab5mzDJnY3 +AFNO2lZCQRF936meTUbYG8vq16lgbeoObqIIINC0AxKghmCZ22aGSjxc5HIzsoIK6+6XA3Bu6tPW +8WqmkMMSEacMAOtsuh9aNfr5YptIq6sSUGwXpr1R3hRVITfVO3Z3HQk9mZwANTWP5IyB+55rxK6m +5zsWdrcBTUN9GZE4CNCEKTbBm3YMVM9gYVcPIUiYY5VESqjdnmbnDGg4Ixm4trno5FadNFFKlk3v +1rhjqfsR+0wEYEA+MWG8PACWQhM9cw7qWCKwbq80ZRStBtkAzFpDWryOJnYRANVJgXaNEosKwqwd +Y1ELLVvWjYGEIzcMwawNUwcTRqhV7rD/CUDqruumLQDVBBHlWT/ezEFhfI3moi/sQGcgpW1uNCEE +i34CzFIKABh0fS/ojUNgMp2+cHyREaAH27jd2DmYRGknYBKnbcoWBUNTQTXqhDNdB1tYjX1RZ0hV +BgozRMivygG0PGfbwljzRWBRGzZxwAuBYVFPhi0uhJoHz8a6N8VOsTqccE2b/VJVGQVwCqvMd2A2 +97WaOj0Au7ncdSYAk+0sjC1Z24YgwCDjWjnyxeNqMTBsantlE4MRgLkutnE0RVqbuWJMRKfK2r29 +67lA3czgFDYEwxacu27QmN8IVKs5ySqAratWxVpsdQN41aYqOAEYZ5OmC+/VCEyL32UUQS5N8cqe +mlYTJUVDx0tqjrEUGGYEGGYx4zaJaQnQJOFctxAaJYUpZ2RyNPNZbNCq7g19EKMizzY7i/njMW+t +mJcJ9TNCkLEsu6pXavjnYDG4ws5oBrre4kphBAAWqwYJC5F7liP62nTExM8EbZvJiFxZRmQMDi6K +t2poDhEUNS6jOJ8ymgpJBVINCgSdUjVE9QYAlJyMolqwQpsxApJ0gktcCYAVLa/eA0WgamphB50g +EK9OYXOQgaTVieBRmxnBomk7LiaL1wEFbKsArHdA4/cIJWe18Lvpx2mUxw4kc7eKR0wR9JVLG9Zz +AWt4si9S7Kz5iopo+kjroq7/7rnH1zUNxkqWsbyuWHhOZBri1RiQRJPx40VjLSs6/g8PfxxTOlQN +SxxqoYazGbepU0XxHO4BaxvUVZNnYkTmxPmwDFzUq5Wz7alFve4Zcyx0atp0S3hgxDwZsdPfzKlY +dGZky8bpjr2MoS+ltG+KREA145bFP7ado64usapydrIgmQqTUU9T/TbOhkCnoEaKsN2y6NKMuiM8 +9HE8Aiavkgh7zhZ/Kn4E0IZQIa1Kd8b9a10crQwMi5JFrlNGUCzoWSxwgVhXEyTiwEMEjoVLR7DU +pruiRMsAWOpsgkQ/D8qKEtDnQDElCA1X9u4isK9usYYAmKMq3cH29YzdUQG3iD8pVwsJlVv5eOW8 +kT4x+ePk7FSJofkfAFWadAmgpasbvcbOABidk7AZSs2xKJp5hsAmszpLSBBBSQXLUnROrB0d/ddc +a4Ud/gwMSWcDjZq+uDXVO4rEb92L1dmVvR7QfTLDx2PUN4FAlJFQjwrSFHQ298gBgpNKehQHzwXa +tXSNfmRMzcjSKzXkEWjv6kEZBC+a01jFr4XApGxR0bNaUB5luiYGZLSC1U5Z+24JSkPSsTOZvPI+ +LSPPfjFoCTNUgWgzKd5Wiu4LTfUmaE2JBsJF2S4aJxoMeg/itd1uMVc9gEHY6pKc2YWUMUBp/S1G +GKVXSs9UQQFwlVS+wnYVA8vSN7wsMPUPFBetQLRmAOTkOtYtE/XJ07viRsvLaFoWAzahq8xOTdOc +AwDGVQddQlvUMMpAFv/5ULRfVVzyAExRtxa1rBCpuXiTWjBldpNOg3OItKmSSJETBmYTCn2CIwKb +MuqfLLNTnyWldCkLx+K5q6F0CpzNXjSwD63nYsZtSTJDi0+xU9UNMWPiGO95Su/CGVorexJ1e8G2 +VT3lQZxCeI7AMvQipyMiMEXLOLApjnhXdT20EhQBDrGMrkhsAFYTXWazlWA+ITdiwak45G1loPrV +hinTXeWF1VAGlqwCoeQ5CVCDYUBAULMd29qQkU9SXpZ1lTfZ9Apm0anV2t0khMAklaSeFFB/qw6v +rnFoSRGC1QwLRbDGRfedxbpbupdXEgGRrGSOB4voYtuSNm4CbLuon1n95/gq8+oTkBFE50zVhBYA +9vToynYnwhZ1i7U+CwA8m/YWF+V3i8XcKWx545uyWs4ogvTzabHPNw5eFp/JqOGxglq96Q0WrQCw +pv8Uji4LMOkmJmknBFMx22N5iHbRjZac8s8FnItKajpJoGBNjS3s4RIUEkNm/ieLrQ== + + + SaI9vylZWi5uS4oRc5d1A1G7CjE2tUNZRSloFanmFyxnEz6uPNEdHF8fmtNa5N2rbn/kszSSgmqD +mqKPFInjq3AuoiBtZuisrfcpmDPBxDa+rJqThuPvJXH4kleA5psjWB06xfJTi+RpjisgubXSU1NK +5o4Pu3LJ5p6X3Z6BpSpTi3nPELz0nYcjUwWVLuPhqkjXouMXTEsumc+njDI+u+BJEo8W9lWWBUZ3 +NFuO2qrLu4jrB9qCnm8O1A60AEMPiBSx2xgc1mzs0viPqNkIW5s0dFIIc2UtCVzyi0o2lbgntZVs +u7Scm9AeqCLYU78QQU9hEPcfApOmMDgplJlzDI6zjlfPE9NslVKcBkVJCYwAJ49F71cRWYVTNWU7 +nHVkWja70FKkCg5TU8Ik8RerGFh00CYy6PVZGdt3s+q2abKAGOh89lX2kup2ne4BBbBGIgsnnzEw +LLbFrYsi6C6xbC4xRLDqPNSQFLaVHK1uryKwmSsHRZIi6NHcLEkrSO3atqK8Oi84CW2jIKvvain6 +efU29pQABC4a5qdQL39+5Sj26p0epVraaE9GxZa2EIJlRRT0IGabh7LxdcvBUhBLs/wciRXy59Gp +p5MgSoSjzrxWB6UKgKlopkT3Q9fZxaO1YY66Cpb+6Zo032XWrbSi68/ykcXhgJ8vugzVBseWtlyi +6ebVa5AkoPjc1+J0qriwgAMgUG35yLy8AViaxaLVc4dNa9U0bTu2gY0tE2heFWtPXdYANQKL9ov8 +DIq2J07NIqMBuGZNem2ikmHLpNnfa1Pdp2L+tub4FglQVIyw6NkbSkpnoIacJX2cEQQ76yTUPhdw +zzyjo84IjJy2yG3ZpgRYSqZCmzREcNRzZORPei7gPg/JcWJgS0mWE0AIXJPl0Es2EwBhdLVrSSdt +xQRAZVm0pDoAL1lPJmXxbAIw20kwkahI7qKHNlY9YEZoLXdK03FrcE41TbEFIOjximBeOgKV1Lj1 +17hhYz+LgaRKVkLi0yqKQPNjcDNkiYgUSFQIs72FXZjxoofsyCrW8dWEy6SuGiRANqDEzmUBlsUa +ttY/b6dJKHghsyNXISBgrhoDNe6enP+o4vFLzW4nlVUm46Ip5OT90Bmq5xTtNB6Bs4Ldy/qZMT2O +goth1uF2FOAZKH2Z5lUAUM+XJT4uITJFhsBOKkHDZS7JTS0GwggKTUWS+1FGLHoWo2esYls7I0g2 +rQCLrlvK4hQhJXE1bLnELhND1OGWHRjlXLJjAKkLyqznBoN5zEj+puCG9rmAgyTzpi4TPVBnN+wJ +TdIBkteZmm3CySRdWS03fwDSFsnArvJgZEyXIpnaz3UPlFzW2M1P3Fj17Ib6UQG4mOCg0JwqMo4P +KZjqKup/ZAHLwNyUt5TFqNpgbnpcShN80PpYDEHrtnYtq9KqESi0NLPKv4AFnJ6bqaqr0fAGni08 +PKo89wzuxLneirevPI2tAbBzV3Yh9CzILiwnYdRhoW7yZGE4dINIrAY6phrWbDpHZL3NXDySCRQx +07KZK4YOJxNYkkjQ9VVZIERNwECXnqQGCg/VoxbsZZoYgj7BWY+nUXjmGTsVs8rJfmyBXKNR8Uqe +LQBhtcs80qxidNguRftliU/o8hWvTzTXFbqv5Rwajn1VfzHlUghWC1pmUzwi25nPOC6TclEmNgv4 +ifs7cmKrBQdFd42sqbNXMVjGSeQQ6jOOkEraUOQJ/Izirk0CCJGsHQ2mzqK5RHZuaJRXTdFoOZYY +EF5TVCYERQtCV9Ga7wxjyln5SKHXZxR97pNGNT2MU8+6RJIFRgCsmUsYAeWNGIHigowaisSofCnC +ry7WKYkgCDg2Sa+ppufJGexnkpgQpK+Ug6D5CnquJnLc8rmAqevSX4nhI3AVvGoXJImwM9BiTpgz +IUpdZK/hM0ra6OumyMLFTA45pBZ7gCPJgVb+vFiSKZkbN/Q0Bhg6OQQr+aqaykIrk9FKRAGANSgB +izjIAVjkoCNs/3WOhmCZFYGGCCnxpkWdXpIgFMwwiJwEwQiC2SboCWQJ7hJ/RgRzstmlco5yjHTW +UxDgQayYrayjSFlvjGC2Q+nBpD0A+8ais4Oy4nTdBUs1qxa6jaYfRMnfEB5yrh0qjLoOTGuI/ZCI +1A14LuAkJ6+DJQDEaP7iyOURGJhSEQQ9izGaKRvtAGLspQ3o+LTAaDT4/WYcYhJ10uUxy0kPzOGu +OosogvGM0rWpoJHMIZWzCG66OBZNIF4srS/y7i7AWquuWuNrz0OPnBr1jLLb1YPb5yYm3UtaQ2RD +lBHMIHd0zVDkj4GgnwhQQ8IItCHMlv6GeLPirYuc3mh2hilynicDS9QN33IgAh5lWw3KrkEEpj6N +5QBQs9AtAE2fC6sdOI39rErl4w7MLkmwwXM1nSrbq0Jyyz7ZsSA9iIw5a7zT4FGlopMoWxGDkOw8 +PK5/3lgRGIL2QPRcdwQqOidFQFuzaVvZPACoRwRBC5FpFJIbg362Fc9bSTAi9tNJyTJ/Yz+ug2qK +Cl6KdDOCaFldUcObeLIr6w6s2d4hWpGSeGtn7BEqkQRRF/hUTQ8aRI66PaNTd2oBRdP1AaiJ9G7V +40nNqquD0tCf8ZlfCYyL8vaMzkdrBDC4k1h48FzOQQFYIgFYaEByCINF8OZ+lDnwIQ9CgIMvNQGi +HakkDVB5GELSqgp6uDfyCWtFEGYTcWyX0PZo0zBZVYYgKb7Rac60gJuU45E8VCz20HRqqUmAQMko +C+7gBdaxqLzZB4vNzrNlhwRN2ccKHXqKKvREcQSrhhv0gAEBxelrShQhWE2Y6t5FNULElA/sjHiu +4MQGY+D4h4LDrOMgNToQOGelt3LSIwI1ehC6Qo0lUSjFjcCixmBZmDUk3ZdZn6bSOJK7Ffoxi7nN +FhWLbKpybR11TAV1xWIdHopRCm9lU8GaP+oiiJq5gdWBYOIJc6pWB+q1lkRGMIJoEVOz0C9UHfpH +KkeEdYqCcx6EIEWSEqsq3H4u6pRoSU+gk/yRllELQfREGQSXRc38YpWSwhrEQNQVfU4BV0pCc7IV +y4xGIXqv4GwnRiRDnfy/lpwspCEwa2LM3IOslbExWN3S3X/bE7kQWDSZcLYUjdLPqxdzRBVKR9Gs +8aZW8qYH2rViZgRSRqWMBVw1HGNEFJcfESTBHOMAQXMO4mwR+zO8z+WFybGCPJP3Aq6WzluzhmRq +1tQhOsH0TAJFoShQd46STK8rdgaLYjoavtI8t3MCDkaZGmVFq4EyWLUYy4JEP4Cl88bKO2VJXE12 +5eQi9eVyYErDDBrETFbjpdCpt4vvV8JgU1k1oZdG4F7BixJWZ80xCEkjphbcWyyLkSKmavH3SKbl +ZCx81GPl3J6kKQqb1wtdQ7pKZqIQBlaOwGaz+NtsQFGaMYkm94xk1SHQO2DJKlkzlBofqmBi1eTv +p/wxQUpd3xuqZNrR2UH1MJOMuxdwbnaUAhUOPSbYSyuQh+D5ZSSCPcxW2CuzDnUvYBXt/Rwn1iGw +HDRJ3kTYcuEo7MxalKx6USn9oVUN550TIGO0RHeujhTzewU3qx0BYyzlHMTPs7K/W/t9juQ51QT8 +skqACL4pn18NUKQ/BhGocF3EpJu5OPDzAQzdZLfKc/38OcR99A3RQwUAK+ovWLoVZSLWaQ4rJePi +SOJ1MPhDmxe6sWSBiUPlXSPfV8IVAEGvK/h7eKXkV9+LXteWQGAsg0Q6zSqHvJYWbMwpTI3iHwtB +kj3+jSgZa2K7dda1gjoCKK5WViSIiqCxN9DBS1aVJlioT3yYWigv1ibckF2FytQl9RdJHRZSUkTk +LSx/la55ZtkyW+b3jC9D3QUswV4+iqJADYFyTOYb4suCx9+IL5ixuWqZH65JtKzRAuFLlENPy4ra +pJWSwQBGOxv0JUutPGytYcQF9RDcwRAvapo3FwfsG1lQeCoM1yRSnDA9417AcW3BgZ9vwJGtGKEZ +JxTe+om1GVVvXvPaHJBZCWzBq8t8W1TYYqQp3bF6oFCgWhy8cN0Q5sGBK6ZJGb+mhIE8ymeEEVCH +CDbPNLZ1zDGsFzgmBSjxdWEVxpMPidZxw5pkqOovK4Vqefagg4GBmIQrNeSwhGAhGmaWr9/IqgIV +lTghx4Bk6KVuRbCDYFg5arXglqW3L+jSquqZDFbsBh2aRVRyPX+ChbpkgKrtoxSKyKsyJy5M2IzR +Hdz1cVoDN3gNwQzPMXF3iaVcJrFSlhmyhtx6PBuiLCyav31tR9zCcKqDoFMge6SwIY2O2gRcFIva +oneLF/yC4cLGYErsl2KVYZUlBCKn3FwcMlwWP07Lze57Gbs5VpmEZBLeb8AYgmnlRkspEjE44r0m +X6JyGQZkziUp0ja0xcPZMQ9YPVAoYAQdvLDDc8C6otaRNhQoUGWaUNvb+n4Z1gs8QB795Ou/2717 +f3z1zftXb9+8ePeXm58D6Kf/7Wc3f/fV+3ev3nx389Ov/vTi+5f71y+p3vSffvuX71/+7Ob/wEb7 +Bxv94shN/k/4i/vo9xPVpEVvKhYgAk2LyqODgkrlaheKKruC40ELeifep5B2UK4rSxayZu83YMte +mWcTFtU8S8C8UFTIE1CHj5NHhrZUH6SMSDtM3q+jp2CctyISOtKZD+uNBAiQEXRira3vlWG9wAEc +PTqdW6jCL/wwUyF5MGoCFUFfYgblHfmKOz7rByXQfZOJC6UbczmbDlGTVnm/AUsZEyaYd3HkGJ3G +487BblUdULk7JxaDri1mcIV1g7UDhQJG0MGL5ZQ6rDOfTxgpEKCyV6m1tr5fhvUCD4S9Aa9twtrK +oMbqlRJ85Q2Yu5G4GvWuoUhJ6Fhdle6mM+6C4iuYqerK/QaMdZfMccT1YnHqVdthWsmxw74RvxWo +fOvYUkoijig7UF6vrFVw4BJsI9KZXcnj+wWorFVSra3vlGG9wABh7YwVrPF6gRXvCqL7EnKka0bA +/Kikvka70gEvR0BIduor+6iqzJssxpOHSpYk0ws2rq5qLaoq66sDlbmhzHHTFpd1WDZYO5AJ6GKF +oYGDAiPSmU9pjwQIUJmrxFpb3y3Des4B5i2YnW2pdF3GHOgqDNC6W6RrXkCxJ4sAQ6dLossSUuZL +vtBG6KwF00oQRzy0er8BJ4vkYkHhQqpCk3oo3LVSeMcUIHcNvZw6760trrkQN1g7UCjQwVFw4FM2 +I9YFDyRuKRCgMleptba+X4b1Ag+Eu5g4hBI2NlK30LpqmNdBd1JEupss+UvICstd4yzejchYAybJ +3W/AUhqbaeVyozTpJNEAdU6xWASonE01Lpu2UYr4DVg7UCiwaS/gwG7IEevCBcxGCgSonFVqra3v +l2G9wAPh7EJn/0i2xEoV7EHnWetwyw9PU3ftR7WrU2RLLbUxarxCmA2hAayVn9BRn1Yx86IUx5ux +xpRaJgRU9oq97ttigoxaPIbVA4kCRaDgcBst1KBIlx5A6QQIULmrxLq2vVsd6RkHmA== + + + uXldK13AtuQlkHSYQTsdeRtEFlR0G9AlS3aFjsilrG9rWprfg6Nlzs+okiwi9rWCzSwrrgPVAClr +zZu2GOed1w3WDhQKbHAMrNkdDmvQQLMjgGHKWqW1t/R9NZRnDEDWLqzh5hRYVzi/7qczWK8m6ndr +sWPGGFyS4q9tMf4qFGPns9K3iu8l3sopFizLXjzMzDuxMXxLvtNhQNmB/Hb9eIdqoMLh7POuv51h +ylul08/Q3k1Due37F5onu8eZJ78T796i3j3459upyLUiP17N2zb4EJ9RTBcUdZE9ZDreb8Clh2/x +rAXrsatlwFpZRgMSvy0LwLfFunmxbLA6YHI2rQMHTr8cseKFI3VLgQCZgk6ta9v75bCe8YAk1Zcb +jFSVMDFpko94vwEHTvanCo5s7WM2bbPilnNcHVA7xon9Q1v0XKbmUXaIvJs/3cGF80hHlPUW/Rib +1wtQR1ZJ7W1djzrW895fy1jkfJZZOkdhyfsNOKDvSstrAg7ZyLTiC3QOXtocUHlb1rxs2iY5LD9g +7UChQNmr4F5xzWGtdmLWUSBARtCp7W1dv1wdtzMeXMlYpLycbD4ai0I6MCoRQbmbKA8KOQY6mk6d +JUUPVO6iO23TFmObLW+wdqBQoNxVcK/c6bAWK/fkKBCgclepdW17vxzWMx5cy15EIsjFurITReau +g8oxEgZ2n3MNWbnLhVUNqNxtUeeutc1yQGHA2oFMgH5eob0yuUNa7CYlR4AAlblKrGvbu+Wwbjlw +JXuRs8QW1YSxNuH9Bhw4R+SZFP5Vw6xVWapFLpQyIHeNSkgtm7Z4VjQuG6wdKBQocxWcrOiiw5ot +yclRIEBG0Kl1bXu/HNYzHlzBXqT311WGrEZNhXDgwGm5DIyLAmn75H6J016BytlFZKNri6dRFWhY +O1AoUM4qGC9hmLVetWLNdvzFUSBA5axS69r2fjmsZzy4mr2I8opy2Mg9hQn89xtw4GQW7keLOu+S +nBjFCt1BpzgBlb1xmc/bzrkuZ1gVKBTYzBcw7DJyRNhhxUM7YUuBABWBUuva9n45rGc8uJbFiPf/ +NXXiUJGR+zOwXqmBwFTV/Oh9g42yOqD2LUUdHte2RzUd1g4kCmx4DGzZlx1r6kpIpyB5haVTO7Tt +/XJYNzy4rtGIO0VrMnp0AuD+DOxqzC/mm8CxFVYUNbSruivo5sZ52basIYQzlB1Ir9fPd7CerXBI +h/mv7xegySfzl1hb3ynDesaAbzgP5N8htvUh05ENmX8T6zFmi2x469GBC+cXPONi0XReyke5sOxw +iz5MRkzH2rCUpeTbJnHmD1gd0FuPDhws7uywytmtkQIBsvnZqXVte7+CryS+4YEoil9kONItRJow +gRvg/QaMyQhFS3PzSQhklisz3TlIQGUsV4zybbG07cr7YsfqgEIBI+jgoGl1DuliR1QcAQJUviqx +rm3vliE958D1jEdUoIr4+akgyv0GnMnzw+Q2qhSE/LKjH6BgSc6HALlrDctMprEtnqgpoQ1IHUze +r2OjYMt/9kgXS/hzBAhQeavEura9Vw7rGQeuZTpi9fkU1HArapd3KF5Kkng1VU59pWlnNbRXOZ9m +QOUt39rn2+J6TspbxeqATIAJlKS81YNNDikYTKtcOtEJECAT0Il1bXu3HNYtB65mN8aiOSd4q2le +OnMVnPvposoHVXlNr8ZcPidoQGUunwce2jY52TJg7UChQBEoOPgi7Yo12JloR4EAlbtKrWvb++Ww +nvHgWqYj3nAgwfvI2b33GzDeFcjOH7ygIKrJoMl2dLvAAOS+rbjtxk1bupxl3WDtQKHA5v6szGlN +36VIA0euRgKCC6g5Yl3b3q2O9IwD1zAcUSrNs4a88NTQ/Qac/GUOfEEqTTrJZMbrGVpYHFD5yqcC +h7ZYaVH5alg7UChQBB2sJZsdVoy3lHVDgQCVsUqta+u7a1jPeHA1wxGXTg9azbNuZh2c7KpZvECD +DoZwPums7K1V/cQEVO7wjSFDW9h4irLXsHagUKAIOliTOx1WOt6UNhQIUNmr1A5te3cN6xkPrmU4 +0pUjQZZEtrnroabEVE3MRMpiVjHM168aULtWJQtjaMs1nzZYOzCvnTUdqrc0dJxYm8OA+n4B6ueV +1qFt79V6AZZt3l7BXERyc1NztJim4MF6igZ7QYeUNoOe0+xngs2aMKeztnx93AZrB46r2sBatWnA +Wls4I6C2ztpOa2/ZO+VQbhjA5uLHjLl/CzuODurrfOh2nAP30u9Y2H8tYrJptbBEt4o1ByRmZKwK +WtvYNqObX3U5V1Begd6Oc+CuYTmsPRnEUeCTQRy1rm3vlzvmfsaDK9hxgHSt6srBQkL3G6i7tWLF +7UICP3ZrBp6QXqMDKl/nkNrYNqP/dAkjVgdkApStCg16XZvDaRnN/v0CZK52Wl3b3itDetb/qxlx +eO3FosMVsa7W/Qbc7xvF+hi5yTzWukF0Y0NaHZBZM8sVxr5tXmyH6lgdUCjQsem7GRXxGrEuXONg +pECAylyl1rXt/epYz3lwLTMO7wrJRd2KczPmKhRTO6PwNqSkxwkW9nYmqnEUHVB5q8pVb4urOWj0 +TZA6GL/epIlAo9UBcjiD3YXn3i9A5azS6tr2TnWsZ/2/mhGHN6s0HTMq9nq/AWcuyMH0xqgROb2r +EfpG5Vw6UHm7pLxpC0A6eTtgdUChQBEoONrNLA5rsKsEHAUCVO4qta5t71fHes6DaxlxWPUmZjVQ +VRkeoFQKlslNi0bqpdgtXfmSY4dxx5qciXUtadqp109RDkBThB0UD/Jb2SHFGfwepq8Pfg/rlLq2 +vU8O67b71zDgSNjrENK5yPsNuJ8cp6pFmoOrOcfQLVAJqwMqW+lYyrYt3UE0Yu1AoUARdLBeCuKw +BisO7igQoDJWqXVtfXcN6xkPrmbA4bJZdCArXiF2vwEnU1mRYCochEA9JQjAFtbggMqdUMqyadtM +Z3VY26DIqqt2APu1L1hD35w6BWHcyJTaoW3vrmE948G1DDikgerWcNp/6JPXgeeq10hx0UUydqKx +fA3qFCGg9q1VDfNb24b3csUN1gFo1u0A1iKXA9a134TVKVgtsjVQ69r2fjmsGx5czYrD0mVNBw5G +q0/eDqaSpgIsFqHrI19FE43jXlLW+bwtX0K9wdqBRIEhMLAUoh+QrrWcvR9h+ulOqmtpfeoYN93/ +j7PhMoiodU3OfrnfgOVavGdcOVD6V602DdYutABdPxuINRFzq5u20R25VqwO6G04B5ZyaSPWhUsA +jhQIkDfQTm1v6/rVsZ7z4Ao2HF6Lsy7iQ0lW38SBs8X+8ZaV0HPRml4mwjUyDMh8WaRM1NAWj9/O +acTqgEKBjoyCreqQQxo6szsBoR+Q98QGz0LtliE958DVzLjcw4SJT+fdb8DZVcaMrYj1kLT8BlZp +nVcHVN7ykf6hbbAD0YbUwZI7NOjAsd8j0JEGqzbmCBCg8bZt27pedaznHLiWEYflPUtTIyYbZxWY ++SJhpjYViwDbdTkwqq3DlLFc7d63xLLCYYPSAenlylYFdt3KocScbCkX098uQGWrEtrbui51rNvO +X82Aw8uc7GAOld2734Azlzp9JpcbNQ0p6/0KKMWXxQGVs1yoamhLdRrbiNUBhQJFoGCrAuqQYi0X +K1KrBAhQeavE9rauW4b0nAPXMt/wlitLNiOJdH8GliB6bs5gjrZ/wPRzMOYLHl7UuL62XORia4dx +gHUp6cDRiro7nIHvnBxfL0DjaythbOu61LGed/8a9htVD7Zs33XutYj6mbwsd3fgfV4lLjrfZmXr +UpfkgMpXKs47tl2wckgcsTqgUKCc7WAtXuaw9pKtjoLQCz54anvbobuK9ZwHV7PfcvfiRb5X9X4D +Rt9cUzLUti12z9e8LkuHKWuT5Uz2llRMeUDogPJy/XwH0+WpI9JerdO9X4DKWTWsteXQT8V53vlr +GW44tlTCkjDPeoByBFerdUXH9Xh002LXxTXV7PsZvTK7JFNtixIxqZRTrCNw1ozEAawO4gFryS2c +UUBA461R69r2fpnb+YwHVzPcsGZY1AP5FN69PwNr1UwE2h7gRr6HtAmonWtRkyB929LqGdYO7HHn +AWy3/XqsJiv7+1sXtZ1Sa9d75PBtev8Yu235t0ukLOhrcWbL/QDMWvOP7iRYxdnOO5ndkSIg4kPV +u9lcuw2m0UgyCIZH+UpAhwMr5S+blzGMP9mpspZGe0e47eO1DtkB3mKpDnRp8/0GnC1lDEldsyi6 +KTW9VqK06IHcLbx5T4MY1jZyqcQRawcKBToKCu4BfYc12CW0jgIBGmOF2t7W9atjPefB1Sy0gmtF +By7akRoHxhuP5I4ULMIRtWRFsms/ymLlcZJ6b/GKk1mtYmsrFVJHrB0oFCh7FRztiiuHNeiFpI4A +hilzlVZr6TrVUZ4z4FoGGt4QYvXdgp6zdtCMJ/z0hhH1XfVL0PHulORAytc0a8zHWuIR/Bo2ODsw +udXcoXG4ZWZWc4zuefavF5CxdbVcXmnputRxnvX+aiZaxdmtSiiJ5fszcJNATp3lEnBe0EUvk0ol +NgdU1lLxirFtsO3cYfVAokAR9K0/yTEyhzVYoVxHgQCVu0qta9v75bCe8eBaRlol6azmHyZ+35+B +jYYeNrdLiBasWxEcUFizaRa47KlH50H0YpvwTb0qWWxkncCz3l/V3ypA46dQ6Nr2njiEZ72+hm2G +t8EFLWQzF7XNBrDbu/h+bZpoci0i9mtRK85qTNJG3TRQZG0D3h2yxeqBRIEyVcFdZXNY+1USjgIB +KmeVWte298thPePB1Wwz3EBr1IzWVVUDB079njYgWKodJcvxwBunUIZ1oLIXBv287dpy3mDtQKFA +EXSwvwpLsGJ1wRQ2FAjQ2FvO2vruGtYzHlzLRCNhpK5iSjm434BT39ixtmI15kSdOlTXqgOVObCx +t7O2uWm5IadaKDC6XIgBLOazQxo5p3EkQIDKXCXWtfW9VaRnHLjumbphlDEl8/4M2uSqG7qFzbxX +Keou0r0LBFT+LG2tZ217fRbD6oFr7PztUKqMOyIdpnR3LxDQGGw+NTdRe7cM65YDX3ym7pEFWT5k +Cv7u360+CzAPVsC6PWHnwVZJZa7NYp5Wc2WumKXKapqrzzJXull33bSNroqHYY2uioeZix5slVQ8 +Vqu54ilw9Vk8tb2t61fHes6DK5mOc8WIi0V/tD6LB3MxFezYKrlNVnMFO6YReFefBTuWw9hyXaSU +tCF0EFedxYOtjkpHaPVW/KtdbRZPpmvbe+NwnvX8aoU8K96Jo9aw1WbxYKuiMle6vF7yS+X4MnYO +vvkiLMrXKHtmb7vOck2lx+qArjaLB1sVFY/V6q14ClxtFk+ta9v75bCe8eBahTxhiHOw42Vam8WD +rYoK0ltmLesr9Vawb3wT61CbBfkQ6thy9XEixemArjKLB1sNlY7Taq34t7u6LJ5S1w== + + + tvfJ4Tzr/9XqeFas+q15MlqXxUOtggoC27pqAjTXWgGceNy/OaByVnMoe9t11lrrDqsD9rosHmoV +VDxSq7XiCXB1WTyxrm3vlsO65cC16nhWvINjVT1CnUgebBVUcIrwVUKu1gp2TSuMurosyIY5bFo2 +V2/PcHqnmVVl8WCrn9JxWp0V/3ZXk8VT6tr2PjmcZ/2/Rg1PfP+shr/VZPFgq56CwGrBSamzgv3S +jGpXkwXBap24tiAos1bQM6wd6GqyeLBVT/FYzcz3FDhvgKfWte39cljPeHAt65F2gW6kaU0WD7aK +EDRDks46qbOCQD1g7GqyILjWTcvmCiEbzuaLJmtFFg+22ikdp9VY8W939Vg8pa5tdbar4Tzr/5Us +RyLNStpaPZYRLJVTEAhy3JdeEeDafJEW7VuxdHXXtqytnWHtQKvHMoKlcorHmrqS0ilIXknp1A5t +e78c1g0Prmo70jRZtcaK1WMZwVI8BWmRmw+aVlmhGbVo9ELrsVD/wrZdL7vqEHagVWMZwVI3paMc +VpO+29Vi8WSOq2Tt132UfAb8X6IWy4xhClvC3VJ0YKuaMpfVKntbfRVYGTYhXS2WGW/4mlPetI1y +P/KAtQO9pejAVjXFY7X6Kp4CV4vFU+vaNieFDesZD748/xORyv0fzdVi8WCrmoKk9hsepL4Kdqtz +0GqxzHQpm9bXtLZ4M7Ua9oa1A10tFg/WsikeqdVX8QS4WiyeWNe2d6sjPePA1YzFgjmo6l2wWiwe +rGVTkNxFzjJbfZWZbt1bggNy1zKupm1bMBj6VRKCtMNcLRYP7ndROqRWX8UT4GqxeGJd294rh/WM +A9cyFUvzV63ICWsPtaopSO6coy+7wl3jS6KHWizIBq3z5trCeo4awzGsHdhrsXionb71SK2+iifA +1WLxxLq2vVsO65YDV7MVgYZq2XNWi8WDrWrKjNdLpjLWYsG+taznJq0WC/IB9KW0aZvl1vgBawe6 +WiwebFVTPFarr+IpcLVYPLWube+Xw3rGg2uZi4A5yW0frhaLB1vVFKR3lbOeVl8FgXNdtrVYsMtq +LLi2Ge/cDhusHehqsXiwlk3xSK2+iifA1WLxxLq2vVsd6RkHrmEwolSqVm5Qa7F4sFVNQVKr3NJl +9VUQuKyrL7qifC1JvT/WtoDRbEFMxdqBrhbLCJaqKR6r1VfxFLhaLJ5a19Z317Ce8eBqBiOOrtV+ +tVosHtxvDCx4H9psDlibtjCEwQGVO01q37u2hb3mI9YOdLVYRnAM1laxRrYoRwoEqOxVaoe2vbuG +9YwH1zIakYbZDA2bux7aclCZkEO00thKWAr9QEJfkHHRQHlvGaJORoeyA7PNWw8NS9Ypqji1EIJ/ +O8P040qnb9k75FCOfb9WIigRG+x+i2JaggfLQVHqhJmJerMi9iG24oA2Y7Lmcbq2NduJ3Y61A8cV +bWApmjJi5eoqIwFah2WktbfsnXIoNwz4DzvDN+NZoKQnK7oN58BWMWXOsMM0NTWktgosKbyD1wOJ +GTnaeUbXFiNsqscZ1g70NpwDd+3KYe0X7TgKXB0WT61r2/vlsJ7x4Ao2HJ5gkyvyeh0WD7WKKUTp +rEEeqa2CvcpygNzVYZkz6j0am7O2wa4EdVg7sNdh8VBb/w5nv1nSvd/VYfG0ura9Vx3ptv9XM+Ay +3p0edW/SOiwebBVT5owFKmdRbiXJHbtWot0sp3VYkA09wm1to+1ODmv0m6bWYfFgq5jisVptFU+B +q8PiqXVte78c1jMeXMuEA8w1aEUJrcPioVoyBanVLFWrrYI9q1EjP1aHBbmgipVrG111dEXaYb0O +i4daxRSP02qr+Pe7OiyeVte2d8ph3fb/agYcYE6rqghWh8WDrWIK0luTar1SWwX7pjfAuTosyIcW +dWysLbyi6VEpw9qBrg6LB1vFFI/Vaqt4ClwdFk+ta9v75bCe8eBaBhxg1ko7vQ7LCJWiKUhuKUFv +35iVty2p7aF1WBBKoYmhZbIsEofSA00JdlCrmOJxBr+H6euD38M6pa5t75PDuu3+NYw3EvaaCWh1 +WDzYKqYgqbmqx0BvacxYmVYrB1kdFtpbgvosrC3+aHchKtYOdHVYRrCcv/VYrbaKp8DVYfHUura+ +u4b1jAdXM95w2RRNGrQ6LCMYerlKP3oxfkkbRuAiFehSTzGmVbpoLNTaZqezGtY8KLLqph3AYtk6 +pNHci46A6FyRjtihbe+WIj3jwLVMNxzgoNLHqrB4MLBmqSps9dop9IfGIMCQ9QxG0ERE6vFsafba +NmPJv3WDtQNdFZYRTGc7Rqyxb0+dgjhuZUrt0LZ312Hd8OBqNhzStmqKr1VhGcFSLwWBWjwx9t2h +WEHxOO4ksbXztr2clcPagVaFZQRzzZQR6Wpj3t+vVVhGUnvL3qeOcdP9/zgLLhU88+mzJe83YKuX +Ago3LGKtjimVVUC4udCcVWGZUzBl1LUFpR8s1g3WDvQWnANbvRSP1SqreApcFRZPrWvb++WwnvHg +ChZcKlYI31Vh8WCrl4Kk1jxbNhm7GaBbKTcP5G5FvF192xYv8tbSZIa1A10VFg/Wgikeaehs6QS4 +Kiye2OBZqN3qSM84cDUjLvUAoavC4sFaMAXJLf1uD66sgl3LqUUHVN6mRe+wt7Z4XEdDe4q0w1wV +Fg+2eikeqVVW8QS4KiyeWNe298phPePAtUw4wJwWvbFXzWMHtJIpRK0EHbW2CnasRC1dakZGinaJ +b2+Jl09rdNNQdqBVYfHArlk5lFZZxb/dVWHxhLq2vUsO66bzVzPfEqbi6g0WVoXFg61eCpKbs0Z9 +pLIKdq1fJWhVWJANek28a0u3Q9cN1g50VVg8WAumeKRWWcUT4KqweGJd296tjvSMA9cy3gDz3G95 +0CosI1jC5yk7czna/rHafWrRtg8gMsd1bImHP3IdMXqYk5IdbPVSPE6rrOJf76qweEpd294lh/Ws ++9ew3nD7lIsrXBUWD7Z6KUTrovWhpbIK9qvNqy+3onztx32tbbSMX4e1A10VlhEs9VI8Vqus4ilw +VVg8ta6t765hPePB1ay31H14rgrLCK6S+pzwaLneKVb4aCJ1rmm8oOgxRpKAqeaztqDArBusHmil +WDwYXQFVERTLwVSrwVGQnIXhqHVte78c1jMeXMt+wyFOallaMRYPBipWFbaqjKMvNCq5vS4fAZU3 +a7NNV9tiVqqZb4K0w1wplhEMmo6t/2a3j6912RAgQOVttxxc295Zw3rGgatZb0hE0rLWVoplBMtZ +WQIuPVbGkeCUXUTbSrEQOOnZO992VuvLYe1AK8UygqWSwIi1lbP3ty5vO6XWrvfI4dv0/j+2FMsc +u7vFW3AOrEVU5oha51BmZY7RTkNbOZY5omI/lG2BiWEJqh1dh3nLzYGtmIpHqTVX/Lt7dRZPZG/p +XUqG8qzj1zpmF/Hy26D5i1qhxYOtlgqSm5rmRUnVFeqZnN53FVqQCXom37XFk/6q7RnWDnQVWjzY +aql4rFZ1xVPgKrR4al3b3i+H9YwHV7PeYnbeZqvQ4sFWS4UItlw0OUaNnUtFC+BYhRZkRKpqMVvb +BTXMZYO1A12FFg+2cioeq9Zd8QT0Ci2e1t4yO3e7oTxjwLWMt5g3JVLuN1CrpoLUql/L6q5gx7rU +sBotyINS9cygtV3O6754YHJrejmvp+KRWuUVT4Cr0uKJdW3zeeWXcw5czYSLmKqsp9CtSssIlnoq +RG8vwS/BwdhtAlelBfmwVq1wam2DU0sMqwdalRYPtnoqHqtVXvEUuCotnlrXtvfLYT3jwbWMOMC8 +2mEpq9Iygo2GHlTXs1aRfNS+dAv3LLpty9ri6lQ1zrjVQVaqxYOtsorHaTVY/PtdvRZPq2vb++Sw +nvX/GlYcYAUdY1uvZQS7nSzkdazXgv3SCmquXguCQ93Ua6Eph+tmxOqBVq/Fg7te57BaDRZPgavX +4ql1bXu/HNYzHlzNikNdZVY/h9Vr8WCrrEIEL5pAqbkgERVLvZTC6rXQ/mIJlK6t3hHvsHagq9cy +grUygsNqNVg8Ba5ei6fWtfXdNaxnPLiWFUdiyVIltV6LB6e+zaNPKeiWyjVYsG/NUiitXgut1VXv +mHJt06p1hbyisWpVoZ4zMYC5tIpHajVYPAGuXosn1rX1vVWkZxy47pm7YZS1XssIlcoqRHP3c3EN +FuqfuQCsXgvNKdNeXVswAMoGqwdamHSASmUVj3SY0s4Lsjgbop8LdxO1d8uwbjnwV1mvxR3D+9JR +PyvYgrcgqRFHc/F+A87sPwAgbpdz1doTcjfzHC0nUIA4BMsC+93/z967LkduXGuiT8B3qD+KsHds +0MgLgMTWL5GyPT6HthyWPaOIExMdFJstccRLD5ttW/vpz/q+lQkkgCIJVDfJKnZJIbGwgLyvXLnu +aUo3/Na0yN1hB7XmwNiD4wMF9wcHwScjcJfzxRhh3G2I1sZ0jcigYwQSNxinljoWvy0DEgkkj9WE +MBkw69iaGTsRnEEvPCQfvAhGgwyv0kyoQBtwL6hwVzoQm0IzBMyYcgVa9YUKSN6vF9WVLRLGsV7w +CzZmRSphtqQUESpNU6+Djk7yAaPTiy5KZGmxMccLfa10JgI2Z5cWSZ0qYORqmuTH6FRXiPeh4pBx +l1YKDIefocUQbGmU9CuwrpAryUpfksDF0BzkiQGQe+84VqA3FNgSR7NwQicE4xYvrJwtbccRa6RG +VDJTW4iRlZ2LEziklIi0dOlyRZmFlFNb5qtuFRhV7jq3ViN3g+tDOIFQ0dAs6xAVbVjIaF0KyABk +mIZquujHxAaMzSrfIuvLnl/FsUXbioDpI6vfGk1CGUDnVZQCx6iikCCisIGRuLadHSa0crZ64i/z +u3Qeinqzb1l24ZJVln6wrGPkCRatjjecyXgr6huxEK7WZFqCjJVt4krKWZ02JpwWTFw0D5fShM9l +7blodcRE4ZiC4kzSA8vP1iQZ34MkpT3ZWp+SzLaq12y7lD8BF58ro47gWUuxJtSasuYszirshLq2 +KR9AW2oyCJ3qUplvzL9JO4xYcLx+tU54ELQdSf7qmz+FN7+/fnt0+/HDz0LO785vrwGsAHzzl5vr +vwrNvxOyXxQKPjr/6eI6f3Hwl/d4Y0p99f3//OMfLi6lmoPfdT/lnPndD38++cvN23P8HBxA9774 +evWbf19dXsurQrp1e/Hjx7vzDzhq5Ay7PR19cfbzxeXb2/NrvLer3/3p+q5/h//dxZPsN+VXcpD9 +4/riTIDpPMs//Ofp5Uf98t8Pf3h9esXv0An2alvH8evscfz6AuOQ/Tx7JP+6eHv38+zRxK+3ekQ/ +n1/89PPd7CGlz599TDc//p/zs7ujm4/Xb6V/RzeP7I1+gO+4/+XTuw+zRzko8+xD/eZPb765fP/z +6Rszd4wXbzPe+J4x4Zv/nNHjbSGTdx9vf/woHP7Z+dxZ0KIzlzi189xEU4T1ueP58Q== + + + 9MP5H27P/+9HmYT5JHRU6tlHeH3z/d3F3dkjVLIf5Qd+/feLy/P5+3NQ5tlHaOcO7frj1Xdnd6f/ +XDCyvMizDwxbbu7Ybs8/fLycf26kz+dQoHu6bh7o+nrqlx0C53/PycnDnX1g3p95QS6u5y7Hzfvz +29O7m9vZC9IXeHY0+/7m4+3Z+R9vT9//fHE2+4h7ZCryk+56y/fOxfUjJGQwGPuCu+b45ur9zYeL +uzmb5ik6QD7s0bZ/9+35u9XXe2lvO8axl/a2d0R7aW/NKLdE2vNfsrT37vZU2N7Lv9xcfHhl8t5s +IX4v7m2nuDd7X+7Fvb24txf3JqPai3t7ce+LEfcK+1oEviUj2XKRz786kW/BiHZF5BM56Oj8n+eX +3/98+vbmX1+27UuPTIqFr+XA/PHy4yPcymdgNrdVMvhw9/bb839enKJDC6SevNCL8QR/PP344cPF +6fWRLuCu8NKz1+bt/GP47Uucw/MHMv8UfvsSx/ASCrDt1Ozm3bsP53dHz0HTXmjbf8cR7tCGvwTf +Ai/Bs5vLm9v/+tfPKsbMpM+/Xs5XJcav9xvoE8by4f352XcfH9kPu8cRzPbt+fDx9t3p2fn3Z6dL +EG9Q6PmljtmDk8X9eHl6e3xz/eHu9Hr+uk0LvoA1bekof//v9zfX5xuMsi+4S7JJUZXl7DnachWH +KReMZbuVHIVdMpb/nj2W/35BHuSvNxfXdydRffES+sjz7+NWPYnMxQ7xQ6/TmLCQb9h2NmgjRc9i +a8J2r9GuSUZLjCTbQgxOby/ufr46v5tvgNslojD72PvlEWVKNhx8usUDeYQXzwditllU+MXNH4jb +6oHMp8q/vARRfpVW+MXcwLYfnZcXd389vXhMlvzCz87dkZWXq4kX77gXWsg/n9/+dI6Z3CEmaOnm +eo1r8XQd2LsMbaxQ++qVqNMWeKVstzLNmL3H0PZ7DH1ZQSLHNzeXR7fn5/8926r5Gj2j3l5cns63 +6+6SEsMczo4rvz19e/FxPuqmz3dDu7ndEuf8gbydP5C32zyQXRMx/3xz+/7nm8ubn37dIdFkT9Z2 +iKy9GmI2P4Jly4nZqw1j20liVrwel9VXs9OXhVNs81afPZJd2+s753H7emP2Z7Ms+5j9+8b4sjH7 +s/1wdy1mfwEh3/YjafYm2/ojab6Es2NH0k5mUXjEoyQja8uc71/I6/6L3PFb76jx42ws23rqNXsk +uxKE87fZ5tTjn0+vr88vvz+/PD9bok+bFnx+i9BsS+umg5wWfLFz6NuLD+8vT8/Or86v7/58+n6H +DqOrU6lqtmFyJ6SjVfp3NflpBj/njpq/5vPf6fMtppRbfxIvyzW4zafX7JHsGu99jDDmPyfysSv0 +bgFmbfsema1D2Po9Mnsku8LhzY9Efp7EK9uy+94t8g96d3F5ucT/6XKbV/rd7c3V/MHw4+fXSj7C +5GSGscc8xnPL2McXibmaPZYfcSfXfN24fv38Rv3Lf53+OntMQvnuTm8XUUr9fns14Xc38yWPmxcY +yO05RcC5wzl9+/bi7uKf88WpvsAL2GOu54/r7Ozj1cfHvYXykWVFXiCi6fr8dHb4y9np5dmfb97O +H1tf4PmDz2bzFtnqpeb/wiHMXcBhqRcSSU6vL65OXyw17K7moSvC3hlmyyS7s1fjDDN/JLum/dg7 +w2yLund/YeFEp7Br3jDzc5rtmjvMAlK+7YfSq3GHmT+SXTuUdtIdZjb/uRvuMF/kjt96d5izV+MO +M38ku2Is2bvD7N1htuUw+gLcYcyX4g6zgOZv+0n8atxh5o9k13jv3XSHWYBZ275HXo07zPyR7AqH +t23uMFtt/9kdb54FW24p8XihNdzFrIEL/AD3q/Bkq/B0OTd2YBGergMv1PjuJ2385k9vvmXOnjfL +NF+zGKLdOaJeb96i+WrAHcla9DwJwF+Kmi7Jk7OnaA9TtHpP0V4jRZu9rHuKtqdor4Si/f5WAF82 +i3aOKXiN9GzPoe3p2ZdJz75oBu3V0rM9f7anZ18aPcuNOm+WWeFfGVmbPfgvyIa33zZztk3zJW+b +2YPfb5svfNt8WbcF/fXi3+eXf708/fXNsmDHbXTYqcpVNdt7Umf+bwscKLMSu0T5bs+vbh5Lb7Bj +uV7m5xTZ50fZ50f5TEi3Ml/bcmUq+X+5kv++lt/y92t5sXptLtsX12/P311cX8w3cN2evz8/vft2 +wXbLSjz7+PY5YnRcO5Yj5sN7ZImZO7pdyhEzkxv50hLEbAsP9QovKPxxyWXjW+6pv2Qsu+Krv1dY +bC85eGxv76ZdaRFF2HLqtqFJaevD52+u3t98ELb8u4+PkLBdDuCLY9whgnB6e3H389X53Xxc2yXC +MFun9ssjxqlsOPh0iwfyiDI0H4h5CWXE7IE84vyUD8Rt9UDmk+ZfdoUy78YhulDq2aUj9NVmRfws +Z+jumDg2WtOdcSDaBwDuzcm7Z05elqZwG7VKe3PyulnZm5P35uRnHM9rNSeTuMCgbMuvFxGavQl5 +b0Lem5D314xMRrY3Ia/p7vaoiPcm5L0JeW9C/vzaiR01Ib8mY+vbi3fvPs6/zWTbScHC4ewKNZid +nu7Dx9t3wtl+vyzN/6DQ9tqRdPqXjW1Q5tmH9uv55eXNv+aO7/Lip5/v5H1xhjy4s4c4Lra9Cxh3 +5/HNtYju1/P33aTcXun2okq3/R23j49mr3R7ClL69U+35+fXXwsHdv71xfXbi59uvv7nxc3l+d3X +t+dvv765Pb3+afZW22vj9tq4vTZur41bM7L5fNheJfcyXJUJs60up/99cfXx7pGrH/MlSd8/O+LV +s8d0fikPi1Q+WYkX0/d8e0H+/QT766U8Yr5VWeIk7vEdQvnXpHb68P78TA6u2+fwhX926ehVK2tm +k6i0xIul/WnBbV7D2Nnf//u98HobjLIv+AKM9yPa3CdQTe31Nnu9zV5v8wXpbaKWRvU2UYlD9c1e +b7PX2+z1Nnu9zV5vs9fb7Lje5jIqNF6FC8VeCfX0Sqjvo/C3g1qo15k/YwN91Lar2F5lBPBz6g1f +iD7tc2hsG3F4NTk05mds2PIcGvNXZMtzaMwfyJbn0Hiee0C225t4+4/Py4u7v55ePGal2J+d+7Nz +f3ZuPJAtPzv3+ae27excSpW3/djcSJjelaNzn3fq0+Z+W47dxeu5zzm1pAMv1Pg+59Ru5Zz6/ufT +tzf/eor7i3aHEn3h2QV2xa9zdlK0fUT+s2+h2Rdrvn2EnOZubf9+ASSbP5Bf5w/k1y2nANtOzW7e +vftwfoctcXv+dhGd3jUZ4DuO9MsQADZf1dcoCWzLqrzu+8T3otkui2aFqb6ai5Lz+YyXYDOWjGQ+ +o/ESfIbx5eyR/Ovi7QJ3wvj184/IzR/Rz+ePex5mQ0qfPz8H9SUqNZ4gi/bucFd7pcZOKDXqvVJj +a1nh8FqUGvMHsldq7ID4u1dqbO+xu1dqbCMl3ys19kqNbVVqfGGi2d3pAkfL1yiYvbs9Pbs7vfzL +zcV8x2YtPHONU0vP7Z95ODtny4+nH87/cHv+fz+eX5/N5zhHpV4gJv37u4u7s0cUWLnEhq//fnG5 +IFfCoMzza75m+9hef7z6TrD4nwuGlhd59pGdPZ2X2XOPZJlWa4vjnOeP5AkFnm05FV5fsqMF58G7 +25ur+cPhx88+nNeUuum1pjoqD2ff2nJ3M5+funmBoexzFw0Gt89dtM9d9MSq5fkyyZeWuuhJlEZ/ +/3j748dLmexd0iO+ztwrC0SKLReOniflygvpeZfEh+1VrWv5w69eh/fY/HFsue9Y+ep8xxaMaO87 +tmaUL26g6PmSN4+E379uM8Vdzp+9IiNFubdS3Oy2lWK2N9OuGSmw5bZAJb4X9163uLcEzfYC317g +2wt8e4FvL/DtBb7XL/DNFg1eo8D3ev3SZud02Et82ynxzV7AvcS3l/j2Et8nodle4ttLfDss8RXm +tch8S0ay5VJf9eqkvgUj2kt9a0b54lLf/7q5efvT7en88/41inyv8s6IRTHiWx4i8RozXswW5vYZ +L56dIOzTeD40kH3Gi0/kMFIeiFdBm/f5O7aWjL27FO5OLyH+rx8vT89++XqloJv3p2cXd7/+1wKd +8Ie7Xy/n67jj18/vwr3kwuVt31mLBrNrm+kPQMQd2kuvUyO6bL/sxLm6Wc6hbb/15wNTOR6/JvL2 +5TAOu3gb4GtiuJden7nlG2fhcHZFITLb6+TDx9t3p2fn35+dLuFIB4WeX1O+bLWWjW1Q5tmH9q+f +F0TnX0KrL++LGZxHNsJxse1dv7g5j2+uP9ydPnaVYq5VGZfbJQW6cbM37+l/X1x9XGDa6r5/9iUn +zr2aLEP17JxW55fysEjZnJV4MR7r2wvum5NoZHwJrwHpA/fwSSRWe25vV2593bNIu8QipQVefMZO +C76An/zSUf7+3+9vrs83GGVf8AthCff80svzS3t2ac8uze3D95FQ7SC/9DqtARtwTtvODD6Pm/T2 +r9NeZf4M6URvL+5+vjpfkNd9l4jD7APxl0d8CrLh4NPtlTN+eeTLfCBmq1fkkQw++UDcVg9kPmX+ +5SUI86t0JF5qPdv64/Py4u6vpxePSdT7s3N/du7Pzo0HsuVn53wmYMvPzvkD2fKzcylV3vZjcyNh +en90voKjc3f00PtbGreRF3pySrgDa/F0HdghRHitqYj2yWdHo9y9VESv94q8jSwG282K/n1xDutd +49t2MsnS1alUNTu9xC4QdrMq47/rfnWQuUPmr/lkI32+A/tr2ynGH6Xoh8edx3aXYDCS6s9pA+4K +xXiFZ9Ozxn9ta/aFfYqP50+Q9mpyfBSzhaltT/LxLIqoZx7Td19MlOvOpcd4nU58i1m317uDtt+e +AnsDRvb3V5wAeRfdETZZl23fR/mYZoc17gqrbQ7nx0btme39mfQZ9tIP785v/3Bxuw0qkm1Z57vT +H+ev8S4oNO1qtp2DY/+fyzSWgzIvl4rr4/XZ33aImrw6LDtsVuXqy8CzP+7x7AXxzHwp5OzopVxM +KOwg6vrvt6fXH97NuEVie/D9depDNmHVtp393DDOZBe0ITq0LeGr9/qQuDL0nPvm8nIL1mRbpmQz +ZN37ai7pwAs1vuj6p6+++ZMp3/z++m13DRRAFSBv/nJz/VepgmlKCgUfnf90cZ2/OPjLe9bh9dX3 +v179eHN58Juj07c/na/Mqlj99eL6l98efJR/y9V3B71DzQ+/ysP/Iz/+j4D+tfKrP6/+v/9drt4K +9Ie/HZSHZVm2YWWrw6ZaXR0U5rD0pq4ioLDyvjL1yvrDqnINAK2rW3nvDl1bN6uzg8IdBuPtytpD +V6KMP6y9lSrNoW2CFKkOa2fkhQBK4z2KVIfBBi/flIdtbeSbWpqtqoYAV+HZNnVo07MUaQ5NqFrb +fREOrQ+etTrv6lXRokhpAGhcYM9MiY8adM0YK80Y6VMlXRCAb1svABmgb5sOgEIyjg== + + + JjSDb2qPIQvAVZaA0DS1jtgZFnIyXaVn4zKdeG6DY/9daWR9jD+0mGgTDkOlIxKQN61ZmeawMpgE +AdSuqlemPjTWo6EKXZFC+Nu2LIR3Mlz9FhWjtCXAm4DuooWqXbFFKSyF2AtbrbRXUki76QFoMPyC +Q7F2xaHp5AmoaSuCStsYfmMrGbbMam1brcQ1zYoT33JIWHNZk+awbasa1ZbyiYyoPqwb4gZxwPkV +cMLWPpVpmrAi2rjUl8avgFeuRCHgGhAIK186FiI+yhIIfmKxC+Crl0EDfUvTPZf8WH8X/ctYuuiL +xyaKvI3Yj6LvSOxq0fc1jodILugeZ5uDLvJRY1qKfl7i1BX53MXpLbr5jQtQ5CvAVSryZYpLWfRr +GVe76JY7oUSR4UTCm6JHnIhaRY9bxL82/mhDxNraeRM/96kCzBOrxGSwGcwTG9ZlZmesSd0LscOh +SdhY9RtLB+ps3I7cfUW+/bhBi8kuLvJtzK1e5V9FalB05ICzb+J+iDSDdKXyhClhUcoT2PMBcSp6 +6pToV/dNonBFR+JIBuu0B5QOAo+Mj4gl60JUk6mLM4BVAUL6bhcERRVBW8sOAJG5BtK+oLLifbVK +ZD0+nh0Q9ds2AVCBx4ynCkjWuTW6VkjWWWXsCjrrXNX3FiNyzWBEMmzZKa4fNiam4Tc6MZi7Fijc +zR2mN7h+emUBhBzatACe9CUkPHEBzWApK9MtpRAprHaTVhskU4ZYAcsSQArJOAJnu/+mrkwbUcs3 +Sv3akPAPZUjX6x5Hica+32SJrsc9xnZI1/2ANNeuNv0Ow3YKZbevgHe6m1zafG412p+VnhyVyTex +diJudD1ypZM20QKjJxQ2HUdW4wQZUpWK39gqmEh39JzmZuD2qAILgYDViYKVPNcaLr3SOD3bse49 +YSeWYFOSWMrQFI8ikjvjlIdIOF4ZFiI+RsLc1qsh6W5WGVnPKb6LDErEbKHMStC9nhmN14E7ECW2 +LgUTf8LuCbkeHE3yzOltXB1PL89BChmvebz5Rg97WT4iaOWNtiFoGPSIDCuda69HaN2spqfs+CAe +n9TTw3x83o8ZgkSze5I9ZivGfMeUNRlzLyPuRsl0k/E/YxZpzENN2awxJ6bEuY6sWq1z2kZcRJ9I +l5s28nvgMUyoO4YRZCVg+RNVId0x3XvSJWs7hpOkq8p50kTdEnFL5C9Rv0QhewKZiGiioYnGDkmw +Ph2POO2Tg6MfD5Kn+9HPIoj85h/XEBrern66PX17cS5SifHtb6UaWRsT8LcVPHfyuTv0jQMGZI7z +ZnX004GvDstaSBAARXoogqllgbGxg6y6LLHQg6Org3fS/NGRiAv/8RF9a0ojFKo8DME6mSdAZDmM +DgOLLK8qeenRE1PVslQlTvtGOvLDaRxdo4wYBAmZZyto6SJA2uVy4MBxFCgE343VA8fKL5khd1iX +Vaunv6nBEMajpZLGpJI6BD1HmsZiRmUiQ2OUo2iMnLU1CFrQk6QOvtbDxvXPx3LYWAc060Dh0JnW +6REsvCEQz8ngtGXB+VYKCW46y5NQhiEThdPGlWDQsd9Bg3DYuP75mGeNq33+RVVXetSYFuRdJgD4 +D0AZapZxh5XVc0+4glppQq3js2XNbdiSM8ROBcd1jL1tyAvJZpYjTMlCiTNNdnuJ7gsdkL7XPGss +FvL4IL0q9GO/0sJ6tBjsbDZQK1Mp+wW9YyfA1bJbFeUsdrNgv0tu/jKQy8TY0JBAeL4aMiwtvxCy +rkdNbVlHVYLeY9Yr67SdFoxKwAYO3NEeteGkEXmPO7ppUAlRwmFViSRC0eSoEWJSUhYVDKpw1AhO +eR4HgmWUXxtfakMREwvgZl1zZ3q0DNQ1oakSoMTH8Wf3ioXNqiuL+nE+RbTm2E0tX3Y9ICKbVddF +4vEqGwQGKouQjbMVeoF5EMzXqfJ+lc0UZ5OksxbWchVnm5Pt2245uBqu1WlKiCVEgFOb8IormtCq +X/QMqxQviDlesUwOBOIUjpAet/imXXXoRwS1imKu7nCYbflK0Z5ozt54s4rboOssum/9Ktsn2EuO ++GbamlvJOX1Om9G3YdXvRezWsgNgN5uaBwnJR5rQfr+DJlD5EEkCiIZt2UNBKj1s5LRZ9WSFlEcP +TEJAmgTBV4kyYZVBZXriBeKWaFsifJHuJRzqKWOingllO+JK2trRXj4dHwwQuFL87kqTl5UGrKyv +Ii0aKAZdaOJG0k3OLnKzRYVMHEGBQXo9gjlICEHWtf28REGpziaq4Fx6238znmwlBY3N1qMYL1kx +WtJisubFCCmKMdIUU7wqRphXjDGzmCJvMcbvYrwBlO5ak+2RYryNivE+K6ZbsRjv1mK8nYvBjrda +aEgT+AkoMWmGN+mUU7JSk3BRDmubepUocEHK5HrKVExolx7TTU/dipz8ebacUUglwEVORCtlHRKR +LUOUXhMBLnLqHN/G4kVXPjZR5G3EfhR9R2JXi76vOpwiH08ccpGPmbNS9NMSp67I5y7Ob9FPcH4G +piXoj0nXxunLzlJT9Wd+d9x2KJGdyR3eFD3iRNQqetyK+FfkCChTx1OWn0fNkJG9GlGxitqjuhxw +G9oZb4bdqzKepdtWRb6v4t4r8s3nXIQMNnCR7eC4x/tvQAUaH9kwLHwiFRmv1tGTjqHrSE4xoUsZ +Y9gRr/6rRN86/pII0kRVRaKCwKJQZpyqYlrHxQIZXQtBvqfnirHW9OyworU3kV0esdPHB38QCeHb +nMuuoayXFoRlqPkozTbGJTVJqIjPdZs0tRZSJIm2CFEuwkrVvIs0ERng0exECMk2jgObfYXVqFod +ZzNewqYjwoqD2TeNtUoe6hARXjeM7pNEUyGFsDFfY+IFUjaNartLVQLKvFDhxh91HXeD8EM2fh5M +rKDSCoKNHHtlQmo47j7BYdW8Yk5Ur9cQuxtoKJPmt/Ktzmljm7hpBUGszrynHqNS3hXrEnwPSAQM +v/t3sXhfOraRNxE70vcjdrXraRxOPpo45m7IaVq6WUlzl08d3qlOIM4vSlc8DOMSuI6H79YpriYX +0+rm53qPUSLDiIg16YuEVxPky3CPGNq4/puEwwmFE55naI5JrQLr1b2AaRcBemXrjF8i292/GBdC +vZB4+3ql5WCikqCkcrOp+s6rEsJmfVeFv1GIENXR8CfzM5rAwQSbuMqDNRgv03gdp0s9xoYxukwx +aoRzxMnQoeQUazl9MuiE2CPEz/bEeL+kkt2OYuV1yLddbL7bmsPN26yGG9xqf4ZEYEInODtNnROT +NJG6e5xdpZnuiBLr9wPKxfWKh74uGNbTuY4Aqla6yWgkMKK2/RfAmKbKiG+nw+iQiljHkyWCElYm +mp7wNqP7CbW7wyGhfZFviII7YvB4cvDu4D/+cfAPKqt+eHtQr37z29UP/2sK+OqNWX3zXv6UclB9 +9aZb5av+YbzMg1XOUOgMRUZYNsLBEZKyxAiRx4g+3gooM9ku4+002nAsgy4E7VGo2UNqwNHhZkIz +UGJMV+6hRfg0p1NTIjYmdCwx6kAx6t+EcLPQlLxPDoA10zU9SiaHzbqVmZ5ak2NtDQasOSDHJ2jC +Mf18cvhOz+fxKa4Fp6f9hCEYcw2pgyPuYsqBTPiUNP1jfmbK84w5Iy2pq1t0y5uWv0jrP+H6WG7K +HebM42DLczNl5GFCOyb0BSXQj06akn6goyb2s66n1DJuvxFNnVDdMWVmsfEsTxZifAhwSOODYnyQ +jM+aSFRGJ9L4yMpx8Bp6/G+uEfslFBGeOEIR4Y5DGQbaPJFTGi8n+pWKzA6dP6yCGvBb+A3A76F2 +MG0A4IATlZB5E63oIovBXFIfNiLVBn4jRQKUD5XuLFP6SsT5tvQueiMYW0LN1frKqehmYFproV4s +VdQ0kKLkKIIEEsVDGk1UMyYyjsjCHmJJA4mVmgAVGzGsEJwadEpYDmSmqhILDANUZekP5OoWWub2 +0Bs+twaGQTn8ZIChIs5iVxl8our5ijIyyzirpM80Ff0r0hQUmIMK+j+ZAkxkkWaBk1BTMI+zAEMW +RTkZY2VVRYUhERkqbEAAKtUscUDHWiYoV2vLip1T8wKtWw5aoAoSLtnehiYhEadbRURIfVYVpPpF +C6s3pGwftUTGl7Wazqhpo3geMAco6tQfo+WmQPXwgGCD3G7sAWV66ZPIwvjGtFbt0t5h9oXTcKWK +s4LfqgatfHRjECHWUQfUWEUacp2t8BFVo5WUbdXQ6hbJhjRUA/8bWV1MIAAmKUOpEkgAOgG0qkKI +INm7Nn1j4UkDjC7rOqK4dXQ3qOkRw12AjSVjTVZ/xQ3ZOibSQxst+oLaVRQ5pR0gqEPLSsKbGh46 +GWlzh22j4g6+MzWpVfoOdfmouSLqFXmDrrTqbSO98q2yZxTX0W3OWeo3MFWEIZuPrZhMAGSY1tT9 +FBVr5rGAgbaMletXsh6WWgWsB/dmy90Q93UZPctKmDd1qSMpEQpZxbUvXcTz1kVyDYqk8pyeLVLK +JUcbbZ3abUX0ZoCJxRBd6xCR3SkLYdtoVVLlEH547SKwPZj4dfQnyvaO96kVbRaUCsWkK23sWt3q +qL0PCjGhjQbCKm66Uo77JEcrTBYV5lSOkcpwUATVC0bSSaphnY/NwTrVkdcB7Un0lzS6yIl0JORF +R8kTrS86Yp8OhCKdCOoBRm8p4mLCYU/lkEvEGzgsBKSMegu+z17HGlBBHZ2mBufOGezO64zNzW/R +jAFhsDAf182hhc7O0JfFTY3N8CqoeTJ6iCxwiqsFbVpFfG+Cmp6lfdlXKzmV3aGRzffDFSRQR62Q +lxM3YOnXlWxa+Dk0K7hRCe7Kzjw627TRo7mNetlxXhY6yD6g9k7ajIbyf8j5/rtvbu8GPuOQdtSD +GO69qzP47H+8frv68PPp+/PVFR2j/1O++lr+O7BDn9yR9LSGRVAWczGTAC5xKZugbPBSRkE52cWs +AmWoxcyClNqEXZBiGzAMFEAXswyx1EKmQXq4nG2QQpswDiy2mHXggi1nHr56sxH78NWbjRgIyNnL +WQgZ2oZMhCD/pmwE5fxNGAkpuBkrQT3BRswE9vhG7AQKbsBQaLENWAoU3IipQMGN2IqoO9iAsdAm +l7MWWm4T5kIPmCXsheptljMYEIM/9aiMYvRKZquO6sa1VfLjNp2hXYiNBsfcGy4jU7r67vb0+qfz +5QEzciAJwjv6NFihroyZwbkIPZ1XR6gTGi99XdGzSlauJShgMullw78nNFjxbfr6RAMbsNdTnSdq ++IcJWltmXbaWI6hGPoDuPaMStGupmlKd3lM9qbUiay51psh7FV8XeedjNV3/TtJMKIKzgycyRV3X +Tg5Sd7oOnhwMqynRhWFrqFi7kroEwLTja8a3ZhryaUqvs7exjr6K2IW+mdgF/qnarLfapXxI/cSk +eemnpei8KPvZmSDSLJdQG+ASWrbCY8BJ0zZ0pi9X2IUW2toxm+5auO4qoEgP4JFbEA== + + + RgefUPgsTz1C5dwWTqiE5R4MWimEwcBrWFo3wrLhVfANOLsSPnwh0GlUGEUZORxCiQkwLcsOEVKl +pzUPghJYps4Fehbw+MK8CaugikyS3JMD6WOA4zXQhV6wXABDEzwYejrSQp1HMia0Psg5paCGzAnI +P3ScXEnhoPSk4Y8TKmuaWhWCjRwOCgo11bGxUuKEMBXK9rFlIg57U6T+Ebv0mIiDODnguCwPdh0p +P+LoizQfxFDOUZm97t+mOgZVsJ2umdSXvis6MdWq7y9HZcMqG1Scl2zknJYV/4Qqm8M0S/1Ep0nq +F0PnKFsw9optx472a0rnFU8mPK57Gm+PHOUqzcvJQTF4HSE6HazCV7qZumYgPQhk0BWiTjHpbjEd +UjEdd4cyPeoU6W0/gUWqo5/lIuFOvxSKyYKk/XoVkzUtputeTJGjyHGnWINbxRoULKaIWqxB52IN +1hdrNkexZg8Va7ZaMdyRsXuDjdvNfra9m3whix6piimpKBJeZQSlWEN3Mrp0krxqBNTgHPdwGKr0 +86pt63jwRZFZJFF4Kmgna465UauFTrXOYfqhcxgtOfq9TnXryWjGanVF2FjXPGD90c53+avYj6yG +1FDfTupF3ht9mfc51pA6ddLPAHygSs6hbEU9y7sXcWby0jovkxYGvVBKhHe27Xua2u5HMx2y7Q7w +8Tytmc7ppK9ZmsEC2jYbTdFPxhpsUEzp/25oGm+SWXwyVIFNJoT2ruGsURUymlrK6MP5F9Bkkb56 +M11KdIzjEZZ/igEqAI4wRS2R4+bW4J0ajYfoCcligsUqTE3mI22F7HUxfD/FgazNIm90DSb04yiG +A5lu+2xyiuHcFXHy1r5eg1ndUmUI2C/poHfrxrF2xGsnp5u760yiqsLUOukOoZQpKcy0MTgAQb1t +OgwYpOxEYjWljTSezqEV4gJLpWNGDbvyxljTyTeGh51aVPXAaKxF0Ljq4k7gsak6QAtUbnAOwk2V +ukRPPUynsGigoPEMl2wRKBsDEmm9LaPbaqBw2zljIpoUP+gGxP4V6CCUaMrvo39F30GDsCkI61By +1hTmYHrW+Hyrmi3yT2p0xw9EZ5wcpJe0VCPQi0SlrBmIHSsFg1RTo9dNzclB6o5OYIN+YVapcU3T +DCap8rbVQB8uhlA/qOajAptLpoQJa6lCGz6gdqr/AApX15Z1Xk+RFjFrrljTq26Wss5305SNsVgz +Fd1EZTPWvdYCLsHG86/NgfHI8GiwmvUQKYs0fxnuFjnytsnJusfxbgucPGwhscE5H2ghMcKESBFD +h2czFb3gpmygE3TQoENz7OFkzfBWsDIgCiKINdIZmY8gsqL6sf9whYNNOluzRKN69TVFW3PYQmEb +bIvdLwzR0dnGrR7NbVUK0Bs62LLSgNHcSPKYkaOnNFEHNqQ1SrpH1EYNGiN6o8aREcXR4iOaA+CE +6ghwE7pDMr2U8tCNZEx7SNvH1EeAU/wncEyBaDQY0yBq98dbj0fQmA599WYNJYK+frLroY2fUCPo +2if0CF5DE4qk52NHk6j5nlAl+idN6BKV3RPKxIVb08t11EkP8jF9Ug3zdJrW0ShVKo+plEKn67SO +UmV4mtGqDKUzapVhfzFE/ynFyjfT5IhvP7/SVPB09cfb8/PrT0oyFFKWIWFSfAdBuH9gcJA/rCsO +vnSeCQIY+6lJhtrgNIK8jIZGIUX0CnchqE9fDcsLvGKdFgJ9Kq2G9gdkJxDJr6pjMGadZRnioyYZ +qpFpJb6XLWy8OnMKF8adap0x3ORCEVzKMWQ0kN2q0cLgI3Xatn6YY4iAsxgYMfqmbi3D00hpaMGI +4edesDlmUAmx86GpNVWEoWcnjI6txvw4+YfxaerBBlBFo54Q/KrUJEMNEmMgG0BwugV8Dcsk/gaX +kgwF9XnWc4ClNVVA5ULMdtGow6xzNjmauaqkD59hvJH2s1lpv2kqEIxmMgCEskePh5Ydhskx5t1A +1hRYnIxRx9BQMTzNOnhiasIbh0UT+lu3Xi0zAVaiGmGw0U/RIJyZGNElJkK/iTTRodMjHwDQqrFq +wPNIOADMsy7EHEM1vEWBnDbG4oSGto+yDK57TjmGQqO2lfgyli764rGJIm8j9qPoO6I9LfquxtEQ +wavSxrnmkIt8zJyVop+WOHVFPndxfot+guMKFNkScJWKfJniShbdUsa1LrrFTghRZBiRsKbo0SYi +VtFjVsQ+/RFsxNmmMjEjUYiOnpVrQkREm1Adh7U2nHDdlDEhQIwMRH/dKhsAt5WNw4z7intP8w50 +m0+2pzrlD/dwkW9ibvTBV6QF0SrG+DYSDJtWo/Ixw5DxTnslZMWvItmJprw6TzCUCFMiXOmLRNmK +jrQBO1zbRHyprKYXaoxLqXRCq1hWx+g8jwRLxEXjTcTOuo3pheB/E3G40vQrLTM0RYKd5xcKMcGQ +TH0wHQR1aG6gWAcaYoBs3xBpesq/g96gvyRSsb/E+DbtAdJ0DNzGFGYceE12q04z0+cXilOHudUk +PwRg8uu2m3xLyuJTcgfayrmKTbeKVOi6mKqhxr7NcwvVupE10KMdfFO3yd+58k6pXpp6xTzdTW1G +KYHAbpWTUqebk0huNJmL0PMwIMlNxW8S0cZGagc7SvdR2nXxMOg3pgY0N97nu1f7kE4ZE+KxU6VN +palbOkrhSGeH1EQz5BE7SW9WaRPotqDxHSvdoBnQraAB5oFMGElb0+h5XsfzvU1lAtCCNNLoIckc +F0pF21XCMSW15NwVD32kx+rJnVHssMqoeUbojZARJeVBcdo2kS0JitJl0HH7kq7y0n7ddEwJO+g0 +/gse6zoGo9MbatljHKXn7DKvIqehilPlmQfHlSRvOpd6NJac2hYkhjOtyQhHp+vo/B2fz9MjfHzK +j9mAIadgFRsHzMSY25gyJGOeZczUTPmeRJ4TdU7EOVHdKXs15sDGLJpin4voaDW5kPGaA4pEgXZg +nxjDLrlQJCkkOWWIz6RIyneSIJFoxYQGSocTWYtULZG9RPUSZewJYyKeiXYm4jqivvHxeMxgz7Ek +t0HVGd429ACpBOlqpg6CH1e7LruQRWKsaElOD0UwQdYa0mWwrjm0QWjvxJYsbGVomTlI/lbMXyEz +pRZjiJH4ITjsG5iXZUXgulPC/1JOxUl2IUoQa/PZaU4AIolma/KrIuUYO2Y+O9em5IKh1nx2VZfP +zsV8dvGoMIy103x2MfwfQfd1lhShdcMcQ3w+1oR2KfWfY44hqxKkZe6qEDPadXkHncYBaiQM81+5 +mNAu5a8bphjC83FMZ+fyL/JsdnXMZudXnePZcUxnp0NumAIvZvqK+ew0GViXMTJGmObZ7JqYzc6u +YgLIcTK7VhMMGSa81NRjzSqVjcns2pjXbBXTosZoi9KkzKk25Rpzq5jLrsudFpNEav4bZlfrPLIs +M9nF08Y2KXtYiIkeXQxOtb6us8hjZrJzMZNdGzPZmZjJLphYhmkBNVVc0L60Jmay82GUyY7zppjI +OCt1Vh2msrN9KrvjQSq70nbJdruSef5TrZy57OpV135MWtZ1kLns7CobA3PZhVU/yi6VXYy/bsBg +M+2aRv3mqeyadpTLzo9y2cX0QlwxItmqQyhimNcVr1fdgmfo5E2IaewqxS4fRmnsWkVExaWIdgmT +six2psthdzzMYVeGVUJ99rJpYxK7NI5GN1TtNTibdEGT2LWrbAfGYO24AQcp7GIGu2qVdnCayn6P +p9SiiQwwhV2VUhpXffx4R0qyTEOEnDCvHdNBRQgJVJkyKbcdDetJWCJzicolOpjIYCKVPaVM1DQR +03WJ7TTdUKN5APB+mDLaNcOU0U3KnFdXGp6f9aGps50VO6nZUjU2OI5DU6pqOh4OVZOuetPNRZ5v +KE4gk7dydOmb8SLELJchW6divJSjvNFJHMxwoRghSzFGpki22gzfijFKFmOcLcZIXYyxvhjtimK6 +b4rx1ipGW68Yb81ivHeL4dYupnu/GJCHRk+lLBVmly5aSQw8RY5TumhDKlSnwGA4t0YqVUzpmB7W +TU/qijEtHKSLhmXjOKWL7ilqMaK4RUaMizGhLjJMTsXzdNGpjYTLfUcG6aKr0I+nyAcUx1xkg+as +FP20xKkr8rmL81v0Ezw4DxvXr1ORL1R+rlb9wV90ix3RoT+bi9HxvepQquhxapgquo3IWjsfRVNb +xeJ092am6Ca2kSWK1l0RtQJZzxofMq6lSMS7yHdT3HFFvuW0T+NtW2T7Nu7s/pu49ztOrCMQGbc2 +zhIdVh2hKSbUKGMNO5LVf5WoWsdhdqQvY0M1UXTds6oxUXTKCc5WmCg64X9QJGEIuev54pgo2q+K +ETEvEjXfZxraZxraZxraZxraZxqy+0xD+0xDYyTdZxraZxraZxraZxralkxDCJFMDr0Dl94KdhYw ++LVpkN3gqoch4FO1SAz4pDwCk4lGWYhoRYHGUmZT679gkAq7IVhVbDPhLaSQYEO0uOvdX23lTPIH +UcyTU4RpdXsHbqSYZXp5nCu85SbA4t+5atQMxmeagVoX0lgb0z6ngG69DQDhua67CMkyXT5MSGUd +I0HKuDaGIjIiUqxRTQvldvVSoBHTqRkD6x8j02QlkrNCDDb3fdoTn1LZV7FP+JznJ8JZUvL8Sn3E +wiH94tSJJ6YVaKWuqPQxEcUZHUyxtYqzw1VSHwUTjdxVKGPAtYvXFECVQIgGcSeIOie1ZUyQq1+1 +h220KyQDQzhsmzbGKYfWRj+o1rhIPz03oIxJ44uwrHXwyhvXMTKaEDpccQqzb2RuYgpd3fVIzBAr +NpVmqIJFsIxZKTyvQ3LYNtEmX9HPRKbEq4cEbHq6bozQVhNPw5smSg2NV3dVmmBKXgJTmx4CTwWR +romOEWSpbrF9RQ44VafGHC14SY6OHfIw9Pq673PFOHObD6yOYdvd4OvkHpnmBxofEy+siFPYUNvu +elAA7YgTz/EyhjOmYkhDKkk4ezIJXNCWsO4l2UHva9cDaFdt0q1m6ZuYkKAiFyPTUJUDNBSQpa0E +IEOmxZnoa8Q0xgCkDQpNlerhrQ2pmUClIg0IALTQipmYB1tTRnvtWpYwuoop/mNguya2yLJFBzX5 +qq4ofVHyXo+VulZolv8qpf/W62Scempa+rZokn8T3clIruqov+8ANPxGT5AIQopopm8GiUeSh5To +nwAQTeBOVSbrX4mDxZG+xdHFfP8kSikf/xkT/qvjUpbx36ir5Jr80GcHxSBpekz675ushlEeas04 +hK64ZHasg+ZEb6IHDjs7ynnNERWTYTN7tok2TyX2mL7BXJGsWJtIjX4VYEirmn4ZkNO7qeJ0Ec+V +jDEBhq6m6uNdGe8KtFUU/0NIz0ownXP5B0rdiVFNl/8/x7ruIhOiKh2MqXmMaS2YzmWUFT3me6KX +vCrW80sA1IMt5lePyde7H+pm2SVfz+4BqFVTml0EEK/3I7N1djDoTEzHjg5b7XB+Fw== + + + wKpLMn92kLGW6RoWO81WHxOpM7V6Y1JzsjJGM9/XkVz5RhdZljGSbuURBF2aODybPOH7FOkRy9Kd +KB3Gdxn7z+KtAJz84bUAQHGjLuvdRQFlSfJwdtCDXDrfkAukgmcBDvFSd4Le3nCoHJFqykrPEPY2 +MTId3xSgQ/erKSf1UA6tMvpLTOPwZR1httY4fCTPwY4PtizZb+HIcSPID1cHdaM5VsYfChwJdtKX +R2czqzy6t0pTGziBuqzKLoxjTeTGlKHMoMtYyihyLWcqVYbahK3UJjdhLLXkJqxlFGMXM5dRbNuA +vUTJjRhMjYnYgMXUEItNmEwqFDZiMxkYspzRjAGcy1lNjHFDZhPppZazmwgl3YDh/OrNRiwnJOoN +mE7GFS1nOxmjtJTxlEIbsJ5aainzyQ4uZD+pq1vGgCLYagMWFGu8ARMKjFrOhgJ7FzKizIq2AStK +xdEmzCiJwUbsKAnQRgxpDBBfxpIqiV3KlCpF34Qt1VNkE8ZUQ+E2YU31fN6AOdX0ZJuwp9rkJgxq +TK+5nEXVrAPLmVTll5azqVpuE0Z1pChsu8j/72Cr0kyVaehXak7TYKRaY9Eaq3cmBp7r1ikR7fg4 +6SpJbQHOCqGR6LsyQfBgVo9k9cMteUcqh4OxaA5I5PJTf0floWy6Ri+ShWzOgR1ePfpdiWt8se/o +7uCw/1SrOhzQ8SZ8uhy8xsQrVIU90V0TTOXgXIuUsoLEoP0apM0Gx982of/s6Gx2jUf31+hbmXih +RXm197Pqa1Y2qpeXrC3zTGywurTBLV9fKbbJCj+A4GS1TcZYXzFtQ2ky7luImjLhkT9HHkgzZOJt +l/MSuYTjnaUhxgO3dMW06YI1cDutVefZSHitGk8A0NykwuPVekMpJRSl+Bqt0V8Bx7D07NZBElLS +22pAb/vL2gYXdGZ0m1S9GpB3+UWGkSAsBwAMRIewgdVncHMdvQnrhldQyrcmenmTYaZg4qIlBGLe +ZL43kpMbBE1EUbU+ZD4UGXSLWBfgP3YIOoQ00kE7OfyUmy99dXQ2t76j++qrrPpmDiq9f++tQTqN +1F+KdppKeDHicRstRT1Sh+XIp9lpFqMfJ2k5ArLYchR8gEB0agJkGIN+4qpPuBUYTK4sJdUNTSRK +SSnBgKcq6cc8HCkqqASqxEwaAHzVxHi+FhwwhomUHOpvBS5ahsSEFHzGyKWMSQ2TYUmXUqaGKBb0 +TA0Zn0BW0/X8URuzaJ/1N1IOL6QM9WrAZoVqNdQUltAF0M1Sq2VWJ3sYZVChzIiKgTSFAaovGLNR +I+Vvklu9ioTMzTGZ7I2ogzRStXWrexT6CQrSQZhnCl1BUEzEU8ERHM8NBEU3/hb7GJmU+m+RV35u +vUf31iu7RpMPDyp+SKE2wb4sx9UC/NNSizFQiy3FwdTYQixU9n4pHsZSyzBRZ3YpLj5EJkila01J +7wzdYUEV4TsIzZurk/M0olLqpBcEljGMpYX8rI6PlsS/lkPAxMBauPDiNEi6xP564TqZJKj9AhpQ +mmRnWk17QV0BU11r+GGI0RXQegSNb1TRBVwjoysgtAazmgxpw81Yw7ud+0Bmkq7yIhC2HLjsBwdf +d6YzYp7+avypLVv9ov+WW3FWrUf31Yp4RE7IoNYH9uF0eRW4dIFV3l68xKmxhYusxRYv81o8R9Ym +2fr35m36bHlkPvxyfvdbDQrVxJvfHSAMWggb5VgvJLilJNwi3LpLLnM6Pzu3rRFGKHPSIDUsT3Sh +lI0snINGNMrXtka8iIH5RNVNZd34DkD2nexHgjDTpMWpkSCsVTi2VKs8Mw16bPcYpwSzuFd0y9Q8 +3mtAw+6eEE+/ZZA/FCXU3DvGuyaIVR0+OKZWU1VrbA81XlX3zJh/3l7cfdGMamiGbWhEntU4Ls7Y +SQ+B9syyFb3xvdEvUqvpWWUL9Kv7wo9q8MM2jidjxRw4Cn42G38Hib2XQsbX/XiFE9T33fhr5H0o +fQepRzXUozbg7aqQfvwdJPY+1ZlGl1rtx5/6lSBuVIMbtXE8GSvGX4w7d5WBYv8LdAbsfBpgMZ2D +At2pMjQpxvNYjJvX4LzRPBTjYXQVp3EW06noOth9M57OYjzjx9ORczqIh4PZSJA0DGJmk00GUXMw +F4qaIfvEj+rwg1b0yAYkm4gESSNIlXZjjO1m05C61n/SjOpoBq0cT8YbPaMRBER7CRQlXuSnK6Zp +LL2qaFJmRNzloTdRUCjUPKFMeCzL6NXG1UEwHNx6rk4WChNur+Xl5F1NuMPHQBEf4g0WRQNrRhs0 +YKcmSykvaxc02bArh4/MsWF6WIF2GkRT2fhQxzfAP4tbp0rwhid8sjFRX1ePi6/RTvpNxFUjoMtK +H4YqYBsKUw4NsYdKip69ramJx8MpPQb1yTp/BV8kE3TsaTwl2UvTsFTNGxkQg8cMjKi4oTHQtEzO +6qIgXTIEPevd8UHW+5MDHVvdQbJxZxMihbLJOjnI5zHV0PU0HwgGFo9d2Mlb5lAT/CIffIWJsnTu +RdIKGw8n5JFBug+wVpSqgevUTEdAyWBUX3WljjUlczQYWcdNg8gySwtohbsD3KoH1EgY0az6Qo0m +04vBF/QGiHYVJnJuIY0JSiBBEfOxqzm6AzSa0iWVOc7GKnyaC5rTO8hZzuwDsuPoANFDILlR6TKZ +o+N4NuMeK434q6F9cJrOTva8xhQRhPsevAo1OOyRXSYDeeSHaGv12kpACDTMtNnVZbpAuNRggtBx +yzNxcP+VF94P1zn1NXWQrMEO1vWrqyn1fTy+sxSXcd+lLkc3N5e81cX99fTu7vz2+vfXpz9env/x +48Xb8w96qYvtr37pPvr3+5vbu7//+j7e+yL4JGvroRkrla32TjXhv/vb+enln0/vbi/+Ld8NKmm/ +v7w4O//+7PTy4vqnP95evP1/z3+N1U1b/Jswox/ubk/R/b7dxVzsx8vL87tVsTo6PfvlX6e3bzUf +4sJbZAzj7auYcNkiqpTP9GJfJVB88il0EGdUTFZbrbqCxfDzwvj4C8xV/Mndk300rKErpyFYK7Yy +6Mngy9T5434c8y8vWcF/oUSmIpksoZq44WqaOlfOSjgUULRLD9DuViLWhRpSUfvZryzRyVpRExyz +pGHAK83UyaxS3SSlKVqld6mMvrKum5wuMbG+LLIyhX7Mxe2Xtm+vyDsSl7Vb1FW6vkBdUIhJ+itm +OOZv/tc/xdb8KjZG0bCKX8QPIle+UgkgvkhfalGQ+djhrv6ukdiL44OuOxvGdbGqq/ira0LBtrNw +4+dlypG6ikPOOxPttezvZfe7H3Z6V8Q640982r3visRvz7r+XY5E6tp3wRj/EeMxOlF39ROzkqjn +iC4YY0bwFO/NMIxkUZ8QvcELwGj6VkDKnMBbt3zMhc2HVD796Iuwmfh4nDoRn/XuF9N/MKqub4oB +jqkTJwfjLqZqCmVd0zjTwYlEFp5WZp7TvK4Rf5GDha9sunsaLJ5NCeT5oY3x8W3ble2ekzqdwTIm +XXKiT+nbvpBZpRYKtmcUSFk33l/IxgdNx7HrdD+gKRMuQqR5ZgdvSxKiylVr7k6N90GV0VWMmfc8 +sz2s4htqsirDdQuW6dQ8VWlF/4GrYi7Mh4pWTq+2PDrbuNWjxa3iTqkaaYp7zdt6CvBwtnDZQKAJ +36ojV79vkn9k2jmaTHnu3kkK4rh7sse5+6frTreDeMnozD1Ea1u/i7LHx/aR3qxX9rSmihMVCabp +COaDWyxNX9xk6qU6a5slX5u26/uSrRZJq0nJzx/ebmk8J/cPW3DKjKG0/PuewK4nrnY1BEQiAn7A +B/oG61UEjl4Oh9Gjp2ESFYifhsaZsvsFO/PwHQs3bVc4rxsKxkRDs57kPYodf9CFBRYPXv4GYgP/ +RmQuvJfWWF59zLSuFE/zXQvrdqO5ETMSw5jMQ+aUXVcCDiy2bXPKMrONo7ltgNVDgsCMjnzqzZL/ +6Hj9j0NuvTDxGk1zqH24Omh4UzT9masm1NjoCWToJJ2usRqUu/eEsI6LVocSeQ7jESESLXT3Dx0R +YDyqmHuYPof9q2DqSn1whVxX6rE+WkEPbU77WGEXL50dHhMLWz7aoGWYTSsE4mZHBXh5IQ6QukuR +8EVebfCjLBvy8HVobEWuXvpdAWL6lJHC39dg5hm4q2tnfCWfX3UgKAB9U8XbS3gTtOHSjkokBluO +QX0BDRnUPlcHegd0V1DfQ5FoqKmYlFgLekis/g2vbpUB179d/e57EX2vf1r95ujom7Ozj1d/u7mj +DJth9eTo1BNhTc81sLvre/9N3/s15RIRXtPT3+XPq9/95ebub+dnN7dvBfP/kx1Ry2HFe0age/TB +wPvFTuT642/+9Me4V/7+7ub2Sl/FUcrmfnvz4/mbb/7UvpFOfH/36+X5m75p/WrhrGWHR3jI0PX5 +dBxPrpT49uZfG1zQ8GWqIxwz4Lrgq5YqO1uVnlf7GHgj1WFKlD0zcNpVSoHLh0INzU1Nnjmox8Re +N7HXTWydbqKpI4sck0QMpK/PzjRbMnI5X1xR6Zd+DXnmSp0FI8/Msp+fZQZ34gwciRLT7BuceQ8x +za5BMkVzD0eLMEATxjwXtsZ9Raqgzh5DtnlWK0ezW4EATiPA52Oc17DLtXqdxNzKNCLFhJUJdpLD +DIya8QpgDbZYB+pKsoEYRxpBXSwFruEu63SF77Afj/HfjUyREOCVst+GORMfYL/pOefo82CVhPdc +bAhom/ONENtqxHzD7x0nxMNFG8f7t882bvNocZs4ppz9/Ey3S2mNkPgGtu2rDCRLrcuTgcoI8t0V +Yx0IYpVeKNOB8uUvXZMuqxdxyuWfwcgbbw3rYWj0AVg1hcUhnExHlU63vte83bjSO4RtV77Rj/P+ +dO3AN3EIykfXxIvv5SNjB19lMzUFdU2uAT0sbUQ0KT9F2ph07WoA7HrCONzJLA2g3dg0aM6OgWvm +imGb49la06lPE2UK0AhTtT5oGKz0DiJkXT+JNLNoVbJzvnkl0swfbm73Fta9hXUvxeylmL2FdW9h +3VtY9xbWvYV1b2HdW1h308I6sadeHUyNp8UaE+saQ+yz2liN3sxxr40VXK99rKxDpFhZLTKxTho+ +Wt7wU1lYizUm1tyeWqyxt95rYy3WGVmnpsncdDktsh729GbWdZ1nRqjMzLpmMOsKfh7tRBVwf6XZ +21qfVDtxcv7ubm9r3dta91qKvZZib2vd21qf0NaKy32YxejqoNQrADXjoMgjhqajBEvW1hOyYjHC +dwxKxtas4BpQX33W/uc2rhoE3iEUtrVKoHtjZYs2g9o5mVxoaFtFABtu7H6waEPz0si4uqTNo8Vt +4ljyXpjmz8xul7zTERolmjydJS4kWDKdnWSwZMoErJrAcM9h49aCksEzK5iDyntBydiWgVJnFYsY +hFsOetl/kG4eTH2lPa9sSSbjFivzPqX3GajvAHLTNm4dZDBX1Zr5G7e/HvagWPE5pA== + + + imnnKFVMR9ED+8FmxdcC+3GohbWb3bzd/KN1U7WpqFIkWoC0ZrVgfYAd6glElA0llFdjP/3bxU8/ +70WUvYiyF1H2IspeRNmLKE8poujloUmOiCEytsqljQ6UySSp4DpQL4HQ39OpAJJe5/LJsPFnFFKC +Dug+IQXpdSr3SNHGahqT2VLKpNGxB+jjjT6VlEL3yrh2UUihicfbtHZ8nUsFCum51ATp5Qv67o0g +WPLKrwNlAk0qOASV94F6znYyjM5OkWrMhZMIyoubw5SDZQIbjLSajJ2QnvNmKefT7A0bXwt6csFk +MuAUVTYecgbNhZDpsHtYLnLkQ89aHYouk7m/Vyj54qWBf7zfiwJ7UWAvCuxFgb0osBcFnk4USGw4 +uf3ap8AwgpCx2PZxW/DF60Ea1eH14mxf2rCKUWAm/ywJCmsgscGTaR+eMiiMt/cMeGwZmHLnSKy+ +JiYsPFKyQeLP5oGYsMeanIaEPdIkjic7SFn/ecSBLlBH02R0AkGDQ0QAuoCJe+shiTtfB6nGEEb+ +xWVXcWAdqCuXgVLlReJFM1AKQMtA09F0csHgVQoGSxFJWdt9Q1NQF8vUzccU0hVj3Xk10x7cA3xQ +QBDM80bYnk8SEMaDvBoAs5Ct6UAzWDe0GNo1gKwdWYwWG075mv58ipdVofkscB8rE7sa6Ssdtpun +sGAsWo7XJLPc3clAhEStvrs9vf7pfKMQMFh/casHfKTjQdQIO4RM+AlUhOowWG9XSKLrcSFWApRI +l5oeiu51qqDoakitdJDjA4KaDHRywHK2h0xqztsddyoWTmVT9X2Dk6Hee96ZUCu3A41Z3XE7ZVU9 +eOAVwmnUBteNmqaSI4OHAt/hlqQyNHrpkHAk5jCYshrxPUibr5cHPlwaHs9Inz6KpVjY9tEmbYMx +kv/8+Ai0TekDT7XWljg8TeO9T2o1hx+gPl4vLhChTO/yw6HIPEQdKrjEDclqWt63kkCy3C7igufV +uwlQytKm3+ldKp0Kd8gQn3NkcB0/xFJVDyrG1RZ5m8WkR10FXaczvO9angy2S6GUbYjEE+b7Jutm +4CWICVYgFJE9CYKyTAeQINrR+IC3vGcq1dBVkO2MUS/7dseFxrXmTU46NOnzZLDH0/HfJ172LsWj +bvMInQxuMvy8p1KgfzzJH/vJnE74ZFmO8+5kA/jqzZpRCXBc46TRYR+HXRwPaDzi8dodZ93IezGZ +v3uBuRhcufUyfjp56ppXRyFrfIl85bKXPVIqqGEivk0vTyaf30uUWxsl0OBav+rCFrxUvSa2jVnd +G1PxWhqDi5CanKcv23DoEOgjTD1upxrIoLIuyDeh0VAPlg2VXt0t5HBxg0ebNFjGSyFH9PcT1WPC +pvFWcxeT5MuSucMYW3SS3qaXJ5PPEwGra4VXh8ySf5UA8VlISJXVOvx4DeDpYxImHZZ9knWx+6Dr +0qTIFxCKUPn1+/1zXXikXKz9RC5W2AlncNlOYmArF/AEcs434RC32rkeoLxrfCi616lsgcKpWjzI +AZU9KbOaPpxUkzcy7kHWu6zbx4NBPMqaCg3kTeORNXXCgNUPR93hlg/c1Wwa4VdqG4YcXg1Laq0R +WLhtcxjj6xsB8o6thwsHkKdJLN6ylo82aVmI3WHTfG62tFvvisYdsHdNcPEZbcc112t9EyAyQFbX +XN+loizZrXOlZpfBc+RDu4+LcVVF3k4x6UUx7GUxHMTxaFAd79mjttqxhoDIdeoFGzV71cR220Nj +eHF5gmi34gPe8tLSVFxL95g+6FNsa/DtuKa8mUknhp0cjuH4YDymx7jLvFcda9kPIu8Z74rNuwZG +sns8yR/7GRtN6bi7WRdSj+V8mkIGtUxaGXZq2KfxCAbjG61R33TXcjEDMuAcq+zGyGwP3vtD/2UY +ZTds3O3dMFMtQExaFEGCOOGwdW0GEv6Mt2shppK6s1DrRUUMpfVt3Km4Qwc3bpLv7bYXrCkIie22 +GPvleWf8YNtVKuDEe8D18vq+d/p8fDDYiQBlOz2Bikm9xbrWi0kfi8kwiulQC04H7vZM01FgxnyZ +zet0ppE4Y92VkGuWJOLIcFEEuMGyUMrZYGG03MKlGYwmLY7u902WR4XIDRYIBTdbotFGqyOH1o5l +s/ZQr6KyGtAuLDpO7GA6SNVoBuIaOiapOj2DkUm/C76U+UiFCy3drFL9HeDsoBFK4E0GEha3xT3c +XS0JQF4p/k7Np9Kpe+MBHE+GND8FFIyZLXpfIvRbBylrEVq7hpOC2gy3OmoqqPhQBFP6Q+QSEM6u +1PvGe9eFzyKZdRNqNAvKFSaU5qsOJHPm44S6Bk4/CcAjMv5O71LpVLibvvh8DIzAdXcdRIQTpxih +NaRn1J5+d02nwsW4/qJvIAqLGarEkdW4sp1Z7CJIEC5Vr/fEJQDbblK/9F0qnQpniBEblrEHOPsl +SLBpbrSG9Mx5s92k6stUuBjXX/QNTED38xgDf4i+4avsadyyVmpHA9O76YeDt6vx5PQTh68n8zqZ ++clIUGwyBZNJ6gcyvkW3arqzP7pPiCStNygKH1rieCBq+4DbHjtietJ9hq9sm0O6gp8n0QWsVpQQ +4t3CruyU4KqEEVJkmloVOA2EhpHKSM4IarIeLgyey5omqowWtni0SYslc4R89tQWtO3pMuBWcbJk +ld7/HLVGfJ3enkwLZHqjJr5oXV1Z1Rw1WlohJ8CNvu5xgbWgZ9Ef9Y02ZWSBYkdzJO4/ZfdKP4B1 +xb8AbVKX2KL9vGqkP5z+8+b24i5qj/4jyRif895sXGaOa5sLB7+qCuYG4Qtr3iaaQJB7atBNAGBQ +Q/ayFsoPB1awatUpM9RQNdlWr/jEnaTGqzNnGxyv1NZsVlafjw8SpEUOG3XsQIYjeFnKpsJtoFJW +XvDyaFroFP1w22rqm7qdWrC+3UespWm6WnjNbGpEr5ntenGid9QaXgcee1pwMITEwfBeXjSbjZii +ac1LR+O0FJw5V/UzV3B6cZhk/W3SXbzdV9Ku8GpwsOTtulU2TmT4qaEiwH3R8XrP9BUqQuqYfqHG +i3nc+VzGFzKytMpI2ONtDwqwpYSKLXJPO7YLvzqDxHvHJO1GJ0SmDR84G9IHdBwNh0FQM6Q69JYV +Xk3qxhOSIMfqHxjKNv+qphsUAbweVgB6s7GTVltNZiinuTHqj1yGml6QSF4KCKaP86mHfR00/yEe +aVGuK3UnPTSwCstseyujUpmokUld4QirTI5wYI/ZXX7i4ye4EtxrkiPWArYZd9oqWmtLejVuRP06 +UBHKrpquq/QAheavHw1H7E0+ZM6K72cF89Y02bxNlvl4uvL3u7c+scdIhTngPa/y1608rgLmda/W +WxVBtuu61/9xfkm3eZLdb5+A9GJn20avSarpK2UgcYSWfpwB+XgP9ZJlUKyS/4eaJAMW4xLFuFLc +GFwp2gBhceN1AnTPqUxfJFWbak1tsh/sRgYZfTypbdTcuDvTHr+DG3eJ/Z7+XmleVeT6A5GXjSls +F0VOoo52OgMV48+LcY3yPZ1L5PuA041kIwKKDsKvSeP6Yqnqoqs7NVywMwV7A5jlwjSrSYlUW1bt +pO1x76YD4D5G0EPtlEJ65+p421XJSZCtBo8ln/LpB6EF1N/w3MggvB86ZmJMMFzvHpBBGvXIMUra +2dL3kaqjutbpsIeld+r5IeKX5Q81+8sK143RV8KMB14e72DlOOaV9o4EDyok4ZzVH1IFbjgMcH4c +VBI1s8bBpxs+PSmPHFJWOLrAFxY5rK2aqHUhTPcVOTow+xaHm+0hZweGZ5PpQSLntZqkFCF4DazD +WEM9x3S4Dt6KriGEvIVMW8mIjzYueAcIOB5kYs4OOpCsTFXXiF2L4xSaSC2eAfNk6TAAIcLpDeFN +2ba4ul4E0zrw1nSck4E3hJdSD6fDlKbihey4u1u2H68IDww9gQrIW8OLx533bAe+8422A3f6Qzhc +chJFfqlQCGcLzx0QZtyDLp9W/ZPs9QpjOT7IQCH4Rv1yZW6aISBQUj9U9aBsBE6sLD4N0tKv2iK8 +L0Q09HHBcZU5lksmiLySYUZT+sXhdnagsIsifC9tHvrG1tQCNa1ecC4nNwAygXA7xjS0waMd4Kgr +Ocq6gbMDUbQmimJCXQ8IcdJZSEFooRbGCy6nlaZida2c9JPNiE0KviCQU0JPa2vULR6sge1A4Kaa +qmWSQAcbaA/AwpRBlyiCZBaATl0lsi+9MiuppQgRuiJoCRfwBPEIpwXR1jq6x66VDhI70lWQejoZ +zhl16c9yRzzty1vIKtxcnUdWwTwJq+B81O4LCpgQoFaS01KYbs2g3MpeYBRMBLlSTV4nQNl7QeBo +y9omZ3FK9eoz6cges1FFTVsGMswwHaz4RauA6rCygXtPZP62yWGsicE5ALRrAFoKAKkX8S99zZMB +n6RM56WWtTUru5IDUA0NEXDSAZq+mwEsJ3zKpqCuWMGaQ1gDgRc58xfpVS06UWDYG9pUUpeyz0a9 +fFht8/k2iRyvtbD4lRzJODg89rjmS25N3W7hxvnu9sdVsTq6/MjtY5IW1czdFpSVyHmSHl91EGcP +lVQGvbiHDs8kyEUGKvh51X/eAVKNOE0TSFBSj/5YgUWEkUHsUPp1djB+1/UwFh73+GyGYce538YP +EAhhPNxF8C+CU8msOBy4lVvJ+Y2gHuhLoPtlW1bpJXhUL/SIF31QGsVtH4301oks1pt3NlHTzezT +59fXRS2mgRg7nEb72DRO9eQy+KHTJ3FxgIdCplrrAuN7hLtD0rcEEmHskJwO0jW3wJIEEKatJesK +VOpgQvmMBsyyGohkOCvSDyKSKanKIYAl675k/9zVnkCpB6mG1MW+/8fZWGZZFqHf1LAb72n+FbbZ +6SUzwmU3a+IHhH4b+UdxLz3wkhkhTfDyNUEOAWGaplHRwTaOlkNfgmWVZquALdN7UtCqaEDh5EyV +XVa3epby/gTIig2sli4+y7xUgVMldUPN1APi3B0fJBDZoKpZpRoghDVp7vjrmBdntHUTOlDB0lVf +ugNkLWSw2I2uHu1m6n5S2eG5jqhmeZ9ETrCABzKFVQ7J2oowKIj04oBYhwOvzPGkX8dKsqr+XSJR +qXB6zqerA8VepDoKDSxxtWoLqSjcLJp60upVBkxdG3e9H5YGW49GPZ2XyeSx3HSS8zXQcTHyOhv1 +ZEomAxgbD5v+UgXIM3VPaSDMWRq0HQ2WcDfvYcJ2QzNLb10GtXRaZ3hZQ+pIAD3shOxn31j4QNus +lgRITZ0ddCAIno1PsdWoBqHbhoJnaquDUD7RDvVfdZ3uq5qMbc4RaPxDxBviWCQ1+rPg7Qats7V6 +l+stLR2hwXSHbLoNpEtGdol0W/p0zXeEeRW2wDYb66J/ikaeHyZDJQGqNyMbnH3UiFQaqqyeDhAb +OzvIYN1NH11FbVJppNYiQDVRsUvdR12vu4rGY/v06ZZzRqh/pROeHjQRai1CcLDQWA== + + + l3o9ZZxxDamFmV/YnorxEx2oRRhWo9bilCJIVWfQMrlQdQCdKYhT2TcxDr6vJQJSS2cHHUik9Cr6 +7GotSG5buqylBNDJZW/6b2J/+1pGY/r0mYU6BIEfmkskPiCXCNQdiHMroeapclxu4UpU6sU8GmTd +QbBprTAXDQmSYhw1bT7Gz3cA6MJcdB+LINmnbTCqBI31ZKDYGLVUHcxT+7HqqhLhp2pd6JtLAGhH +Y5cSqB9GrGU8rk+f3EpkTFxtx8lND2BJwETwUiZhytFUTigy/k92dKNxcCW9o656SBtjRoTUU+Fa +MGQuAMFU4dQBMNOYDNeDDMRryNmplg4QG+LqdBAoDFddJUiXwKuRUkMJAM1P7EwC5QNgLeMRfQZK +DP8+n2hxfCg00RlEfV585VwucRSCcN6C1OGMqTV8voMhRpN+hVBqtyXVxUZ56ECfL9dDBBtbobrU +hHVfGairwAt2NXWQ1B42e4IJCXM2cDFiTVD9ktJ07SXI2UHfq+6rruddTZPxfQ4KjDO0ThRYH0CB +nfrB8dYYD+b/3kPPiYBaGypYTNlSqEkg6PGt2jHrqqWOkicHzI8I0U3P2Maqw08QdeH0fRUdoGvm +7KCHGdxy5FapFtW3qL8BG+oAZwepLx2o63+sZDKez4DMMocmHnPxN1KpBDlQHY45Y+FhnhNjCo0j +ooGMZX5FdYCnIUtOzNDW1CtTk25hU2hjUDBOGiFDyn5iWiEpHOPOTvphdgZ12yT/eDg2CSUVQJNI +BCPIz+CSoRwHTMANM6xpYpw2Gj4s9MlYIymo+0CWogavaphyxKtTHCwxuGeIt96KMO9C3UCzxSBB +GiQ9M67wsimyAodOlfjRW4vmw4YfUHF8zMPftWosTNuaoWeEB1hIhvN2dm/oUKXucGVLdy/MInN5 +lC2McTJrzmmAZZ3+AEg3TBgj4PpZW6T8aWJwEbPu1DH9ThMiGQ5W9wGDXuXAqyDM6T5zbaWRRV5Q +Q2YS1hX5JaJhtaZsUwdc/efg6N34w7JuNf0jJiJ5X/iybec1C9c5rFWo1CohErpdW7IGAjmvwe5t +UMowr8dUE9F/WQiMcP3Bt4+lEHrMr2vRsjzN9cpNI2vgZ/rJJQ3TOrXSgwj4sJ6JZqyeVgjVczCb +FXBjbLE16aXT+qCGfg1gps68oqK+xOaq4XVCZYcQXZzqx1JRrfFJAOEUqJNbjoPlEc+tmgHxDI+Z +M5Alo65LIkHBrsrLt5VXpmUIBu2aTCBukiCBxcnD1AJyxJFFruAIjo0fokcVekvyIZQgMowpWafF +jq8je4IhknwEZWFqlAYASR2OD0gdwBXa6BSTGCJoXKTIdOY2oxcIQaxbomTb1vxLOaGEXVMIaFPj +IggonowcWBVKhUg2YE8jA1aTQtN+WNPLC3k5bGsjq9kaspoeX8kuA90QWbuCIEeTTJBvZJ/5NeVN +A5+ZtoFCw4BQQq47Uu6lUeONTDOMJfPaBgWokC2JJk0QCKRHWVNUdj0PX8rSrfdKPOZ2O8riter8 +6EX6aeRjo1V6Gm9RYHBjX56KNLk2Q7ZTY6NxulVtdaVJlnAwu0bFLh7n9Hw0dJTTBCpwAyGdobfc +YWgNnRKYcIlfaaJHx9wMesEk77QrHPlfqiUstBm0EzYqSppaXRjhghmgc4LjN0UfIT8hNGpaF+Sk +Zyl97dFBcM8wpPOSV2wv4XuSzH0Glig44bjB71D2QuZAZV3oS4Bn9B6sPXDhGGZHOW01pSB1CFZL +gt1sKnUgGMzcxkSkgtUNaOkaHmzGOHUPlK0jAy+hNcdYpbFDigQqoPrDqFuD0ZPuCqULQbNsGFUE +iFQRqGMxSK1Q011fjnQL4zJ1gt7BibVdU9rKvJXqtmOcHLUilTf0n4fxy9VJai3beQ0f0V2thN+8 +fF95vZlkXA5hDb5FUEXpIQex2Lz+CqtdwsRKpqVlqNon043FC/MkV5OIrFSa8qWpxjCHuxrGqSqD +Jwtz9dWhVYa0CY5ySi17kCIYVbnYT7ZV7Rl1ybrFTKUOYupSBY6VFVcq5QDgvRZqIXJTtrP012EW +p8Cbg9SoBn85en3RoF3rJ3QaVF1rVHoGzXJYkKUIysOqNkRao5MYpEJegHVGskaPAkE46J8NvzL0 +QPT07NVyasnxMQBdySFFFHqeqdqkM680eofndB43lVuCI0ust4HHvxEqeOoZgAleDXngeeKTCanA +FDhVWggmk1AbT4d6mXajaloPMiyrJVu5FXai1SwxQgxqZt6RuQoQRPVOsVFp3AR0SA++EEr8cpqr +Esyoaxh7ZWVA64qua/hIzybr6ka9tYyza4vKzkx5ZtA35V3mdVlvwW0r0CBOizGfLL4sXZ2nYT5c +DW/ClyUj8BJTj0SrLjx0TKrIWODIlx2soaeIldDznbseXu4QY9T8SPIipzFvyQ1COSo+q3Ur6lsg +F8PNSehFDYUt9VHeq56KOhGNzHD05Wt1pzp9A79NX9JFFMyJiQYsxjo7eEuWumWjxrk5jA5/gEUi +2CgOAdJWRr9yGiNSIsyE3r9Km47pFKsqLjlby1pGAVURPP9BRerKUxkznLiNmQ1Pn8dDjUU/hF1G +iBEygdta+G1VpMkkSLvOh17J0SK5lhAMC28veBXAWQ1UunKqMQAfZX0U+nFA/kBjtMc5DVHMtzEK +d1K4duD4oCutapguGl8nHUcLquQg6+OeijmtHqmpyFaG4p4tjVlXUAgAhF5Vy1HBdjS3u0IhBEuh +RKQJoGzL8OmcxrJVeQoCAW/msnEvzGeAvjMhQGGyC2LgddtED/WqilrLqomxW5X66or02KozhYXr +FH3GK3WOBQxHv0eGG6sfUQMNN2Z+rZ/UbVQ5tDivsRmZ0tA00ZcVpq2W1ACx+dRJy6fRAZvhNkFz +xikPU+qNdSAQdHCXw4ZUzcJBvo2+6CJlw20WBKOl4RupEZiDWZ2QLdU0jgAYGI9htijJZdBdsIzG +Xnh8g5KR6owncWO+grkCS/XxxJ+WSvoWlMiH2iOJG7j8EGPbolXHNiVY9Dpu5phr3WvOJg0uCCJ3 +H1ILE4R3kyqtyibQE0NH0DqBurK+p7SjiQjOik3VNIcMuTqisaCGfVF1G+Te57V9hDsyXdOUISo3 +vLuvKFjVlp4CgjLyXmWUmf1GcSlI7UbkYz+Zu1i4Rk9APJhGQjirl5ZRBpqNNvLwkD+wxaHAxukq ++4Qexc7HfSxYIjyBGvRwgls6KDFEROMGuRFxLQfFB3mGchSBNWpTFUYAURO4UETVAGTwoXaQdjSK +xMdoCciJ+NtC6+UYzMSDn9YXV4F/aZheHe5fNWM2WwNyIGcgDRuG9g/QGxfjoYQA1qAgrtRE4+Uh +NZp02LN0I9d4GcbPUr0r1AxEi8YUKMCgjhV6N56vjTmMtioZ3lgx36W02WiIjQG7ZoWdEb4eEQNt +sFEprfoMWAVLhhp4kaJWuO/TenV8cyT/5M0ZgslcZ66ulWggYhEqzRU8/4T4ypE/LSwcAWxxkLKs +0H5dmCPOo4cZBKYyL8fvvGax5z04DsScmCZQqzwtWENETAkIoF46mttdyj8B8yRlQeB88+lcxvKV +eRKFRovQ/LmJ45+IWHTu4/n9JS1dc2KoAx27OhA8rGjLbmOcmBxszKeRfqpivY0eFAQVLO270v1z +akBlhghrknogVoMACBi+yv4nw5c01C1C+j7H4pNB3LuPGzVmx+SJIlUx60WIEyLSkcypHGpRBBOG +2iIQ0E6yKlLAgo3Jy4FID/Ls3ogKiQ+xdXDSssddxhBD46N1cGTxD5RuhDb5JmhE/TCt4sKmj5Y2 +zdKUztR2ErffP4b6sKlr6hSRMuAMVII36gbIpNcELUEnXgm9GKE2ztAxC7+eyPM/y7/hnib/hoan +9BlcyycKUEF2jFGAioI+IUAFB/99ASrZu32Ays4GqOxjU1LWu2eLTfnExHf7EJV9iMouhajU9sEQ +Fbj6jCJUAHokQMU8Y4CKmROgQremQXxKPrDPFJ5SxhtC00MXomLmh6jYLGrkKoflISpmEqJSrcYh +Krb8TCEqWtEgRKVaTUJUzCRExQ4qGo/tM4Wo2Djl6aELUfnUGJVmHKPSTGJUGHY9iFERAXYYo2Kb +SYyKgAYxKqhlGKPSTGNUmheIUbHRLTo9dDEq1ecMUlGv6EGMymeLUBnGp7Cl3Q9PUbEyD08hJA9P +YTqYbQlPYWfy8JQ0gC48JR/RZwpPiRlEivTQhadUzxKewjEPw1PaSXhKuyY8pR2Hp+jsbWt4SmsS +9dWHFJ5Sm88YnoJ869sSnsLc768iPIUo83B4SjMjPMXOCE+JXEMXnmJG4Sl1+5kCVJA06lMDVOqg +B/2WRqg0GrPBSzsejFCpungPu6ZsilBpHo5QCfOafShCZVDywQiVh3u8j1B56QiVRhm13YhQkTLL +A1Qa92iACniVfYDKPkBlH6CyWYCKTM0wQAVazjxApWzraYBKuWGACryrBgEqZnmASjsKUGknASpt +eDhApZwEqNgtD1BpugCVEGM2eDkoPPV1My2OURmUT1EqYW2USkiyam3mNp7iVEyKU9F7WadFGaoS +5oeqjIozWKVJsSqfwYN0H6tyf6wKdsdniVXx8UrBLlYl6vT6WBW3SawK+YZRrIotJ7EqzSRWxa2J +VWknsSphVqyKeTxWZTCPLxCrYqPCw2i63vUhIzakkJGQx6qwTAz8uD9UBfY8DVWxeahKFUNVymZm +u32oSh1DVez68BqEquAulDWhKo/0OEaq1PtIlWeMVCnNMFbFPBqr4kexKn4Uq1JNYlXsKFalfjxW +hRenPE2oSvN4pEriuLYlUsVooIpPgSp+EjJi2hQyYtpBoEoX+DEtGsNUhLGKYSqRQjBMRci/hqms +KbiuzT5MxcUwFb+uIMNUypDCVJpmEKbyQGfHQSo4qPZBKp8zSKVpnzBIBerLYZAK/RQfDVIxkyCV +ak6QShteKEhlMInbEKRiunANZ2YHqfhmfemFQSqPtn1/kMqk6Kwglfv6vQ9SedYgFSgSR0EqcDYZ +BqmYx4NUylGQStUuD1LBdSNPHaTiFwep+EGQSj5fLxCkInJhE4NUYrRIlQI3wqMxKrKuMeqjNNPC +KUZFtl6MUalNF6NStjFGxc9rtQtRMTFEZV0xBqiEtfEpD3c1xac0+/iUbYtPUT+e++JTsrefEp/S +PBSfkr3cx6fscnzKfaiU4lMWItP98Sn3oVOMT1mIUPv4lLXxKX/7/vtBWMrnvXRI70hFIAGc2elS +1oP8YUIN5z3jYFuuKpT38PBPgDNes4l7/fpPmmEd3XNsRi00BPFqQabN0DrQ/KCZBIh3FqIr3Tep +r10l4/Fge63Hqh/+fPKPP30rGPWbs4vbM1lg++a3q695AU6JVZeX2UKHmIWA0pNRgxZ8ZDRVAEEn +AAnhCOR0hONp1GrlYDKizZKuK22t1z628EGKHp4YJi4QLKMGpyphIhJuio75aKA0PA== + + + hOo6qFksggqE8CBrwAn9Zgw9pukLU/FaQdywKvDKBTwOh3A8GRS85LkstcsGSn12k38Fv1VwK/CN +CKWKkp5XR+NNaFQfFSG4Iy80sdMKS2hycmDTbbwNbg9kq42p6KvdasbIUXeOJx08eY6rybA4buUN +LvE1/Es/IYArdWnbrkuXvj8/vT37We+U1kiiz045oGRHGDTkC6R8uiIoQAFOpSsVHTCywgnLRLsH +9G3eMl6dexvoD7WY/KxwZZkcy5fcESL30MW59aV6Y9D3R4Spqq4UANesFVwHcIcCHf9Ng8b5rSzK +JaQy73xFCtLUhtKSDLykJoVt8uoxXHsJt/gm0iWr1zJQDJKz65KxCJSAcMEaBDPc7FvGZ2ZUhH0G +FLI95MY7m87OJbF0En3S3h+H8jH+h6WjND5j8RA1MlkWBS5eGJz7k6UBcIPFkWLT5RHgJgskxaZL +BODiRVozW6gJB8Y/OPFcka/e9GuydC2gYrPU9AbYtbkW8GaEBsChTInQJHwJfVtJU4G3oVEgvCfB +kUK8bkL8cFTlvcB3JC+p4//IL6UJUVh5ksvmW8jYhghVwwZGy6162ieQ8aoRBcACC6EsaXkMQOPR +4OZRGw4tOVSYOR0mgRfHGp7wFGFxSzsUtVQKVkZPBmbpwhkEHS5uuYVBGO5AcPlE16hwcckFFF5l +VV13EI8kppbLIPx94MWYNS/s9CIOqobUaZa6dFktr8k1TIxpWhc0AsrTQYW3iDcMhZPRcI8AK9sS +MWIiHKjCWCYFeS/H85YC8BKcnJR8d3WACD4qZxNIsKfyPmbOF5GL26ZRpTXuMw16lytmhzlHhffW +OJ2a94Xq9Y+a0xB2Zs1Lj7nSck7vXoXrbsvISNlNvsb21ot+4a0DBw4Rmxy0IMcH8NnRgA8HFzlw +IFQ9N9EhPS1Eeua15/yVILCuQR+v3uSGoculXoZr6ZNzDLOb+hc2iPKpmSAmXoNjVGkt+ye6LFeH +VV2ykKWvHlVrGqOqLojQWHnkouV9mHr/Ogkkb1ePd50A1Di9XrM0QVlWR/OiIKF3tl+S8aodT9bx +4fsi4RwqS2JsO1Oj8dz3vDetMGe+wRnQ4J73FsgCBwRclruF/NDd6e2qWInI9+tvI0MU73CdSdZK +oIZsa5WQ4CTFw5N3SZ8cxD0f1Am0JAgmRlvxll8RAarIopf0FwPOekNKXVIGrtsaD2ver6lm2tik +Q3135wRYI75atrWpcWpDWerhTgcNTl210H6NtV4W1xKr03ARf0MviUhk4cxpxyzrQXhYDK6W/Ulb +goOWEiplVzpEtEBJIoQVCsQqXv5cCSPQgFCKUCgifIythnAEfffVAfz6Ww0HddRonwioqegj2N9O +3UQeBKBSp8/yuiwa7eoWVnjOqMPtUfDNsCzHACWYjWHk4HWy8PozDLODU49XMqC6dviABt4c62tq +urEeEMW4EIgybSq9gnfyvphUUkwbKqa9KaZdLtYMrFgz/mLNNBVrZjOb7ZM+Ghx+EYhMuELd3jAi +pqH/DNvTRLxydtas1mAYjmHMJ9w3KQ2o5aXEJZ2nrRLV8ctB2WG9a1rOujZ6mB35rSHfgzF+9WZN +U0IjB70RupV3VR7HQ0Gt/UiVsx5/UYwqKcaNrJvvQXdPDoah3b6JjB4InZz6ghxCSBCE3cYsErLt +oKKt6dqSMI1hM21kFk4gRWk8Dm6Nh3UH47CefotOQ/5o6GlCtEfCzHVMJTfjQKjXsI6rZuhcUiAR +fWBUfs0Qd9857Z8cwIkPZKigl32pewhaBJo+TyDn1RqT3H+AADeqYvpqEGynIZ99Y9Rj4oqqrE+M +XkLIgSwII5FOpjN18oCyG0MWRot3ExZNDbcvdTqGU+GEbiI0uQEx92DUwP55JC6pGa8ZmipqiRF5 +KlgANlcZ5B8QTSsMC7Mfw28NESvritZBFSrBNtEIdHS2catHc1uFValRO1YNvdZQrX0fL5JO+nJ1 +dnP1/ubj9dvVh59P35+vrm7e5sf8w2rxNXitiu4RZitwhNsUQTfBbtW8j/AbxGKC4SI+TnD8qzdr +sJxbucdziswTTBfoFNdJGibYHvX2I3zXaRhh/JpZPLlfH79g6TL1uHkezvSJGcg+T9THT2Uf2/v5 +R/cQ/0h/3jX8YxX5x9H7R/lH1/GP7cYMpFGTaQtBEEydaawJZCC97KU1+XmoZvIpeUN8iJHwrUFa +qNZBFM3z83ym7DwDDtLSxWXIQVp6GA04SBu5peUcpCPPBgesezlI/zk4SD+Lg8x7s4SDHI2/WDNN +xZrZnMdBtu1CDtI9xEG6BRzksOWlHORDDOOw5nkMo3uUYXSbMIzjrjzAMNblmGHERtqIYUQky1Mx +jHVrHmYY1R7fNs0sxnFY3TLG0U4Yx3zGPjPjCFddZeHapYwj9iVZOD+LbzQ937hBo0czG31xtnGI +3YvZxuU4vpRtHKLmPWzjWmx/kH0cV7ucfbRr2Mch5j8n+7icmbs4++Uc/Nzfzt9uwszBntaoBzms +0EjeqZAi/k3g9FxGmyC/6V5Ov0q/zg7G78aFs4rjT/iZB8BrhKHBlAGccEbD4AUJyjLAW1N4vLIu ++WVAqNMJkvsY75jBJHjVuVXCI3RNxB/H/chnMYXGkMzZ1iOQBrxLWcGqVNK1AdRgQudqYFW6XDo9 +FOQGiWxIrq3JTyaqxbqqhMJAjynD7vyunMl/OCsyTsvxhaBhUtQupsSNsIpq5saqrEMC6P+LBNXH +Uv1edd6ZKgD5X0qYQTVEj6kRHNNytYYmAEPfCMMlQiAWJt7UOKCZ7qCsyNciHic1oX812WPWduzX +qJsljTXDvhaTb4pUZ5/f0UZETmkk9b8coFUzzXvNwKH0ku8czEQl5Wg6GMPzz8Ce5+AvwVsC9c5Q +PDtmZQSk0Rw6hBjG5Ft9NvrcuO6RU80ssTXzRoEUcc6MB6LT6dgxBRUDtGOP81HwL8P57ErHfBzH +vomC0Nl4Xjw8aWpifmDazmhNXjJxyHS7cOq+ejOdvHthD04puvvwpE6yS7YZR7mnm7PoJqIolY3g +OY28YAwsLinbGrPGHuODJool2UwPBfkqIYtOebO6Ud5slO7Wu5Im/1ak7YY/TKiYSUtYUSWSwqQB +LUoEwiMupURoFMKV9mRzTzb3ZPPzk81mIIhjS4AnEvkjtHQjSqDslisw+dDcoIPUh/mKHyfAmQjK +RqOHIwTpASE0wAsHgSPMmsOg5HDILJCQADXxWUFnm9CC6WceAdRRrXrBg48an+RItQjA/+mgkoMB +SGQdv43Ve+RgSG5bw8QOlSafc/CAdcjkRKunZgXWHEwuxkvGiUAl6RwZzNVDgQogrU7mGhxpUVnc +M4moJ3i3rWFNnRdRj7oxpBNHMGQFkmBUPkayQQb/Wr32Mtg6+qeICF4jgR2vkkIKaPgIrSlqfaWp +60QOR94Cvehmw0aPZjYqiwtbPKR3y5DOBQEJa/CyBy7CTAi2i3HzqzdLsVMpz1z81LEsxdDotrcQ +R0e73wyYpsEapLNWk07qqdioc2MDaggvSOhbMSf0bDQ44suaJxFkIznQWzpEUmNl5bf3zQCErzwS +JTU1MxK1SHoiVdcRgGy4jjkVXMylC02y1Rthg2Y2bw+71KVM+sQ0KwxdDpqykblZ6GEFEFXaJwDF +KGx85ai1bdWHjm5/ypYxf3VNtbJJz5Gd46WisoERLU2+ooV7Gq/0xaS7EoS7Yew0z8bSaIZmJiU7 +OaATbADvEbxaShDdxjOC7oEn5EXgWkhepFFeRPPgAoIzCBDL6G70xwbgYV3SPW/MnqRf96oJfU2/ +HKmsZcL3OsjSMKSqLdeRKGBYzTMVnjtMgOIQGMebtBCjq2o3p6nLAvIeMQnkD8wJKkKzbsoAQ+Da +olWNS5qRhE3IJXfM0dnGrR7NbdUhOygSPpnAy8AGNMoMk8quYT7SllHf5YWbBlRgsm2wyScbB8Dl +W0cYk002z1dv1mwfAscbSIDzt5DyMks2EUuMtpHAxhuJ/NdwKwE03kyEjbYTYDM3VL/aY8tGY+8j +qWOGjkmI6cxZxxsT+FzBv1VvC+AzrKeBLB5TxmBDcNJKxsjXFVLTQQXM5X8qRn4EeZCKlLKrICAa +ZsaDqysyaq7TwRExSuQwkH2KzLBODjSGtgd6ZPPynsZArDTIk9q0mnkWSWQQ6cNL24E742K1pWVQ +ilUIICqZg3GT1o7mtBaY45P5WywS8iwjG1O0UNgixODdHEtR40lFlcGecMv2xLAuZAKpVD/ClCMe +JiJcudnQQ/5pcP4eDHeWGF5ZqAegAak1BzHoZ0lbzERhIkcWU47SDy/GIlQGPB1iEGiMIXPMtGuM +lnetjFJPSiFQLclpw8CS/5+9985PJUkaAPcC3AEZBAhXvgokITxIQhbkLU4SwgrTPT1/7G8vsMfZ +a+w19hqbprwv4E2rX/PNN29QVVZkZmRkuIzIMPuU5cWLySio//KY+kh4JwS6jBIwt6QY7W/slcVM +Fl1SCC98FyWli16hkBXwJakUPndX07xrItdTjfe1XhkRawiWWeUhUL3RBLSgLf3m/gyIY2FtAwpd +1kFAtwYnXnYBwypIeFFtVfWIxTdPwcukUVEt8St48TVugP8GOrr+ETyj1n0VM8CNGTqH1xVrR1jV +D9lyNyXxbiKTJAzm8ScJFGWDEkWNskJOm6d5HEIEi66hux/ENxwybWk8PqTBgRGTSsI+/BaeL8MU +E4dvwXZkgMWnTdf32G/Oe78UuoMW6J/KXprDm4fRoahCADF0yy+Pr0BHcbpV9TMGX1oc42BKPI+r +ohAUDMZUllx8kvcZHoHV03+HQKM2Imjlgdh/3ocGaUsDP59s9Zi21nOS+O4JdPUEgXIB7egVZjUz +jmTDI6eIllohdMcvgQxCLF5LrF46zXnulII5UTQpeNJ0jJQMnxlpWfPUEzUHXk3oOfC6EEWDz/Q0 +DR7paQY8MtK1+qFryoZxFAbahqhYiLoxDvVjNVK4Vu6xpKpEm0o8QYsV3hINI/EGcK/L3Yl7m1Hw +iS6x50h80T66RkozXd64kXl5/+m+ihngxrR9M+iKAvXoqj7tX7Y+WVipHbrg4B0yFMzDhOqy1UbG +V2YSBLrTF96rp9scJCHgfShQyJtHU+rNjPNL0TUF9t+yHK5HoNrNC/Sc894zmQRCD6qwypZWrREn +7lj9EyQu8NKIT6BfJYmLm9HAovIrKwZFPcNhYfHDCEg9RA7H6+mmEdPP04Cc/GqJDV2UKTiuOLyc +AlYg0NIauv+Voxy/hsweFm3UUpvHrnMLdQ3T84EIcY7EW0TdppZTt0m9us0JBr2FE3TcHQkYFXfn +BIPeonok6S2qr2IGuDFD55LeQupVLdKduh2DjkOBRAHx+OosEmY/2ukvMWAmMiy6bgHpBDSnXVGo +ftDQEqRppcqH6mvoNWQox68FCrtGtVdkee07t0jfUGcneI7X6t3KinES4+PxX1hHFg== + + + 61b6JTUB3QgEL1FHygSDIlBJ5FbN+zT6BTRwqz6NDgINU42WIhERL8h/a4hIULE8dEOO9ChmgBsz +dJ4XzQX1GCX1Vz0RBJwV8DQ1+HDgdTS8EJaVSQxY7kkbEsMOYwJfRk0zJkyDV7EcHhruOm7HwHpo +tOPX8KI08eRxib5zC/UNM9lh3SIPp55aAhR1W5kEsVrrhQiR+qonQ/VD14SoGZxEilC9XIgYJX1f +S46StuqWIHXhYLyVyxFDJQ32tGBiTwsGC0QwWCASDlT2tPqRaE9zeuuDU4FWHmjtaVsm//Plkh7T +v8Ke1rJ0bKCCcbmwpy2/dLannTq1tqetvlzCniZN7GktLWueeqJmkedo6Vm0p71StGhPk0Z7mjTa +01q6Vj90TdkaHqW3pz1Tt2RPkyb2NOlkTy+o2LLwz9ez0fBi0h3OusOPWAw/Ruqu+oXvbAzfCPjN +RX8O/j1vfnVaMx++YNKfm8ynn/7TxrDx0ZkA1bjdmYTt3/nxy3yj3++CnTr+7LbElvXRqJ8AKvZ4 +Fvef/9EAv41NgRoAQKjbs7btTZoiEKV+Y+bYnkbtr2B6h7YtAmHyAW/1gbEtngjJGr8AC3o+vGjM +PjWg85+NSWukTBK0QiBMmtY7/5n5C90/ugDh9kDrCERj3JkAtlmbTUa9DhhYHK85IBLNiq+YciwQ +AyhEjRT4J8QS/H+CwP9Ff4khyHajXahzhfxQ1xT8D+dHRS5wt+Qv6ZbWTZkG/5EmrPrPyvvFqIa7 +AXXL+llJYiZ/dacyjmGnJOoQ8EI/jZFM/oJ+eR2SeT/vFcmr3AFmexKMS9rpiBgTfkmrwW1Acz+V +8Ev/gZhK+BG6yDglazaLos5iRHUNh9CNiyLMh/PLBqPiblYogrcm+DllXDDihuQ5GEME8yPRbUww +LpNH/A+aDWjUhNtRe6aCJH4jXcU89SVOhqM/h+gPILORXA/7E2dgGv6oL5EF8vyPjvQ2kRdzDEvd +PpgZbA9opDv04wb4KdZ0E2KTKFAWEjfdabfZRwCNEGqzRqu3FASvY8g1pt2W8jleZExS/vP392kH +CDTS+nvxg6N+f44uwxhN4o3xGCANLw74qCOiL6QB6q8CVPqL7+9g7UDreneGwFGon/75RGwMBmh3 +S3foaDjtwtRO+S67Qnc67jf+wn/ClM8EhiSuGpjIlQ8QG0+QqJKWABP/0FUOPCNwmpw+QUrlg7l9 +AqqERtIwAfAua+5eBA2MDkYSq/GJQufdv+f3+UOq4YQxMvENJfg5Ro40q6hvz4/m79/zAYw2JjOT +Fcv1O8O2hwW3w2cCAVNw5c6JqkxO+dxi8DbzyI+G7Xl35mYOaigr3wGQ/laETvn6metpp/hHZ3je +biOShF0oSPZ024tYYEKV6mVaawLZ2LAuC/JQoYv3YJAeDYvXUpxFuQllHeUB/uY0+PtMyZco/qfT +msMhoBfoWzN5Bu9v49ZC7TcTam75x1oYrYXRyoWRmQTCJ0MkPARBh48cD4scwloT+LbntQT6GyUQ +9bdLIH4tgX4zCXS15C3MFkaVCVWuTaq1FPvfm1Se7zJfC7R/+JQ8CTRhLdB+Q4HGCbSAsuso8L8s +9AEmBZbGd7+yDLxLAd4QIHqwWXx3DQHzRmDBOWs/IbV2FK6l2o+QakkBX6XHUDy6Y5KFlW5QFArM +oU6uPYX/crGWXIu130ysrT2Fa2n00zyFhChe1sLm3yxsYPjkWtishc1a2KyFza8SNm5yD9ZC5383 +JUPSw98gduifLXb+dUIDOt4onoBlc9ENeei8iOQZhtHE5/E8xTK4pjRBI08cD6P52J91lLQgx/5d ++C0p4EvHCVgGBN01iTkvy5oU7/LIeH8fHuyJXTFrdvXj2NVS1ePW7OrHsCvxzgSCFmh47IO4Fbxy +lGPMru9Y8ys3/Ipd86sfx6/W6tXvwa8k9Qre708q6hXNo6J/a361CL/64cHx/zp+9VN8iP9cVqMw +dcsf+D+o7JInvrTmJg7c5IcHOv/ruMnaWvsRLGnVcUwkDs8FrCwpoNp2LJ9kCFwSlBCSK0h5/Jfy +r3Vc65oDuuOA6/T39dHuD5MGSQanIVE8Dy8WRDfxJinW5HLK9ZnvP3xKnoTaOqr1dxNqP8VJ8A/b +NWtp9Gvz3ymBphlUBhbeJy8AxQqVwWPWoa7/7vx3jvjZEuhfJz/WbqF/Jut1MgRobAeQPCw5Bkt7 +UCR2CjEUw61DkBbkXutA/d+N/63157X+/AP1Z5pK8jC33h/jOSBzYVBDnCcY2qS68Fp//jfpz9Ra +Av1mEmh9LPEj+MlakP3iYwlUKoZkGAZdHUPCMjPIHiEFfnl75Hehwt9nSp6k2g/PRFtLtbVdtRZH +/xxxZHPbhhgnTgnrm3j/5ZbUD08nXMucH2NJra/iXQuun2NHgfdxhgHUjO0njqK49V0e/3L76Yen +mq5l2dp+Wouhf44YsrKf4hRHAAXLL90PwHIsza4NqX+5IfXDM/3WwmctfNbC5x8vfGBQBLDgOdYv +O/HYZHKd0fIvFz4/PE3zXyc6oA9OYHlCgMe8HCvwJIw/5QiCR743TuApVOyagFfqwCekUjyE4Ykf +V2T4XxRSbFr8CccRcwKBo9HwtWAUwxDL+5x+HybsiWOtc/B+R57HsSzJcOhiMR7WSje7coaGBdWT +mC/iCusCKgK4Lpi01rv/fvbvdPZAkjizL8kwpAB/MQTLMjiphEwy3Do0+d8t2Pgfntq3FmyLHagz +NJGEQivJChyPfpACy0CtnmBoLMZ4gaFJ+IOEujylaPVrwbYWbD9dsHHiTaJ0kkuiG7QYgaQI1Elc +YEhyXeH2Xy7X1kmfv5tcW59vrMXRj3Kz4fMNhgZKNDpdZ6k4QRHAoopTZJJaW1b/7kMOfp30uZZA +awm0lkC/UAIxHDzoIQWCTKJyCpwQJ5MCPKBLEmsB9PcKIPLvrxXIrzM01yJoLYLWIuiXiyCC5Hga +Lh3FxxleIFHRRGJ9urQWQT88YXMtQNb1if4OtklTiG2ylCCg2FiGg/esoLp1MAyPWcdpLcZu1jl1 +vxvDQrGpFE+j5G+GYKCeEYc54CgoSwrTQonhwAqGIo/HEVs/LCb1H7br1hrz/yI8i1tfsfWD9ee/ +X5z98Oqea3G2vu7kH7T11jLtf3SJPYzMEhgWUDKMPWYJRoo4JukVXGP/u1Dh7zMlTzLth2ee/ysl +0jr57x/Jim2S/3iBZKFnCef+AaOCWNcPWZBh/dJsZVN2cwVh+vOjybAzma6K3eiAyizGdi0A/7nq +NADtQvKaT6224MrZrsjuXH/vkU/+Irf478udFsTPmqNoOcpk0vjLXxlNuv8dDWdgWz2FeMo/nj2F +/1E60Xpz/ts3J5Y69UljOH0fTQarElEqgO7Ek4yfmfTlRWMGxjBEkoqQhNdg9Efn5vViJj3F30w6 +732gbd9pHzaG7dGg+9+OWdN7+JDxJ46AnhUad4cXo+5wBp8lxWfD+SA/Gnc7qCOeUvdfUfUvitTR +rDHrvF4BydrAAyYJ+eW01ejDMXcmrQ7uQx4MelXtDjum4Aqdj0kHvyJ1wEqNFsC+WUcVdUek7pXy +2e9njLti22WA0KGabZdFZVvFtWvdwbgvc20v6jzW43EfCmD4HboxyUJrF40AMBNAgtZDPxoCbc9f +7o/+9LNA0KzFzFrM/OPEjELD9nKmMBmNa5+N9ujPeKNrLmDUoFwbQIizN/tDhBMizrMSfxyNGy34 +TH7Q7M8n5qa9ycUi+h/4P3cNr34ABdMfrf5EZOBozB+zv8b/YrZ90R32/LnOH53+v9iAZ/9XBvwv +wqToHQVq3eeq8KgB6Y0LfA1naEfxMgt4n85EpVBU9frdgcs993e4GBWuw7E0gY8cqSSv5kIwl170 +9HI8wy7Hkn7OWc4vSQi0nMdad1kflSK9HtppjYlasY8TFLxqzE/SLNx0NMwX5tnV34mKGWJp/t// +/uU/bUx7q2KfpQ5gnBDf7lgnKVuaV7YS6J+tkPxCSl/LwR+7laGNzqBdTFka6gsZQr/PxnClqWOr +be2cWAv4n6Id/0IrfTE5Dp0bfmmfLOkF0cByaUbKUrzdmPTUTobWdIKcIFSc5KQ2f3QmkicZI37c +6CLPREzd6nM0+a/FOlAsA4MfKYHDwZB4BeBfvcURP9W5R+xcOhwwgvRenTXLVrHsR/C0Me/Pnu19 +4N52FApFgpFHLFr1JIfuMOSFJLyyVJ6plwhYcyd5IHuUfC0O29nJDI12Cp+w8Mnr2Wh4MQGtu8OP +WAw/znXA/rlo9DuzWQdx2Iumm3GGHq/Ah0gJA5h8DqPFuvuvT//cd9HyhqfQ7Wd31hG/c0ZXAxIg +kHX6jpIMx9IwsjhJ8yRNa1wA4ndX5Zz/qtOWvkzSyaTmkuQkzVAwXUE9ROXL+04fOlrxxxzL86TW +zSDn7qg/Qucg4jcsTyQZXt0hSTMsxWi/JeVv8381pE8FgUZeDZ4nSHg7kxGteDnEL3P9uYRQGvwf +KSA8EnSSMl0I9aenjQ+gDDbEr0me4jFSGTIpoHVhWfyD4DgBoY9nOczXlEA6nmN4EeQBDAAvH9BJ +f+6AYY2LRtJ4uQUBXvGBXjEUjy54l67xhKHi6GJPhgSQRbAUzQOwlADA0pweLM8BzCYRWMB5tWvM +sAAezE2RR6sBCx6VD5KEKViWZEkK3z5KMknNMiQ5eI02bIPnDsAiLMhg4WhJ8C+AS+jh0jzD8hCc +QCY5TR5YPCndasol8a0ocYoGKKMluCwcLhx+7oBNSnB5iqY0oxNYnmUoLVzoFEM0D/9PuTZVgktB +7NIIvbQIF0AlNIOD2OU4bUcYuQIvCjktVBKtGaB4FVSW4nUMQuCSGJcK4pkkgZNJReRSOJ9ApDCG +gEhIwsFyElhAuLqdIrBgE2lGS1GQCCBcicQojGUMl0VrJgDb54BnpI1Icyh9AcyLRvgTkiTF4S2c +pNHFaZAGJIHPw3QHERwaJANXipNWSuBpAQ2SBrsADg10zyM3JkUTtIATARmCx/kVMA9Q4NTQCIhJ +VtpVPMPRKP9CcYryLM9opkxKyy1PGe8HDBQwP2nGJCmDhYhEMwSMBGUkMjTFcioOC0fJ4VvkwQ/D +KDm490mWl+ARAo+oBqwbwZsyM6BVwUmjGSAMQloDHbAiWAZTPRwnRUnbFNAeBQPzwTZlMPpNmGSc +YeD+gQigwSqx6nGSNBynIIjwkuAnvnyIBGvLmI9TYqpkEqwOr6y9OE4OwGXQ9BlpmEmOJCgkz2AF +cIHGX9McgVAip8dIG4jGgMUNhPYPZE5gSBI6aY5GMiQJWDVhfuk/ozBlmKaDWJW4dwi40cHCwSGy +8pYEhIQgsizBmkJU2JzERlm8ZNKW5CWmTzLSlqRBv7hYUhxQN4t2NAEQgBca7Dtx+9BiHDaGxAoA +EpxyUoJDEoBBcJjpouBuIJtoHi84ZFlwlyIeqUajeBe0yIcoCY9JAzNOkkkGLwpAKw== + + + r2XGskjCvB30LJ0oyBKJRqtDkRLP5AC7o9CMKQLRHVA6CFZDTbJk5nBOFPghy84kInQBbSBp/gwN +eI+AaJkDrB7+SAKeiYUyk0TdQfSwIhdicKUHCZ9QHMOsTLjHpT0JSyii9WAhf0ObiGcwM6HgspEy +o4DLKIoOWi044R3FQHDCFRckqIAiGBKOBBA3Yg0EIGYOMxAOKRG0zCjFdaIwq8cwBThUtMs5iTQp +VqBINGWCA7wYDjQpIBwQJCAkQS0kODg82AtDqZYJygmAAJZDu0jixDRLiklsQMES8wR4Hu1IGm8G +Tpw+gxmRXElDhMrBrU4i0SZQEtAkx6LdDNqxCDqf5NGgAU3QaBqSZKMlOS/KJLVkQ4JNZp/gS7we +cDMJHOZPHM9gIAJi7oxU24OSKIrUrhWkVKQ0yEoOA9gh4ulckgZanx/rO0lRP5HErrhJwb5SEJqE +M8folLDJAO2dwIoYvLkdjhHwFLRngW6O11kcoXxbO4EZM4aJsEkjfox3kiFRqzZ6n/mRIeC/6X4M +oTETFhtYuS5NvxGBA4ilRrvjn4382BxxgqVtrUAx9arawNG3VyCZhVDZANI1N0UatAv8KECv7x6w +6UcQfKj2PW9MOlN/dvjRB2aVBgz+z6MK5rN/bPgEkQtcfMynoJl5kT2rn58V/YCHsv48BPofn/6h +9BnuTHkLwBi+QM+kDygOETb4HxVIs27kXsBW5ThSI1Z5QLlaQSsg8YK0FPGomca3N0jyhkZ6L5Sy +gKlIsoHgCBKxB6BJCpS5sZwUGSQv8glBpa0BRoD0XqQGkSq4sn4L9DYkKFjAs7QjBpYvIZscBOZr +aOiS/s8gCYkEOGCvEmiGpygaA+IZxlzZYCVBIWC2C+W0WjWgoUyjSDRqsOSkvDjYHtEsKGAIhrVB +zyTVNMmjHigBSBYrlU9WxwVFNZWgUUl5qUm45Rp/ofiWiw+3vgisO0KhLytkHIP1UJ4EijMSfxwH +lHg0AKBLs0iqiJd76H+I6IcLS0GWKmu3PFBLcCYbQ9MElqYMgUU1sGuQNkLJ/xUNGKgmsxDRrLSA +HBgAWjcW2G6I74LlAswZcXkSW3O0NCb9DwyVR8KDR7QsQQX6OlKVWYrEG4EB1hYaExC3JNZR5P+q +NU/4L5TDksgEo0HryACVBhEaUCDA7kCqjSjvpUHpf4hgKSTekWMA/CvRLcfi+ygIHkl3GkhIDpMJ +wAgjKkycWvXCehJLa1QvmgF0JiCFBexeZJSxJKs2hYB5I93bovshwuWxSod2Fi8JTAq6opAVznN8 +EvtQSNyBwmTk/4pEQuA9ClUO8K+kHJNAK0DfCWwS+xIEoH1p9VhpZPofEl8hkPEPiZpSvBWsgNsS +DEVgjQvYb1qHQFLkUtr/lVwgSOlmKLTvKWnL3Xaa/vyoP4IicDQfy5sP1jIjsb+DYwRz64uSbhWQ +jU8Np+Fo2fqkFNuGB5qYFq8cXlLFWpKUUV7SdCmxRJpIYdh6QHopr+e5LEVhDRyYdiyvcSZaOodY +1sY5lBSVMIEABEFp4QGTFfA2+ENtxWN4FJw3bRifpzgpZXAU2ge8rNlKdipgGQLOogU7Quvc5LHK +KRKt2mtFCkmFckkM8yInO60l37TirVa7sX1nY+zwRm8kl3e1O52pvfh2Ue7yAa0mptIYXG6b4GRw +uqMROPrdTWZCEvhV7a9Bc9SHYP4PX6gyGgCtMlTp9Mfgf3KNaa+DBg50xdZnGKqff4BRQc0zdFWr +wSbzPsCaP+a/6n58ztQPCqM/h+q/q513zfvrsfqvHNCO/2xM2upnpdFEfHQ+aYK/zyeN4QfsujYD +qqvq79x8NhsNATEZn1HqZ/VGU9sIPtC0wB1hPzaYfvujgz6A6yU/0HyAH9HgkehyB4PrtnodOD7k +85cGC2V8WMQ7WCk11q1XT6S2wqg1HwASKjRmDV/gNSH97U+hv1TnXPDvu9Pq2ajdMX255w/9Z9Af +gtexxmw26TbnM5zkAppiqvtfgFgBfFWr1me3354A3KM2UmyN9Bb+M/tr3MFvQzvD6esfjcl0T5Xc +r276RwOuPW4Ln08t2sF0cdxMHMlU89c/FDvD0bDjAjH9EaDwthvMSC2jf++8mt1hGwyUdDE3QBy1 +zuwMTcJ5furWK1r+JTFB2mLC1fy7jWa/44bwHVf1n7TRU3+43uqw6d9M0XB6rfl0Nhr8vZzs19Fh +atqAcRBQ5oEt5pYcf/m+qMGba37MUH6HXTp9//MHS+O/eRtM+93WP50XxwRSCQ2zXF5XS/t38104 +Fc5pKn+5mcpff/dUSI4WaKep/Nlto7B2x+mIDf8BU/rsIEvVxZykln/zpKToT6sJNUfA0h1A8/p8 +0gXWopupGb/5ASIf8braaD5pdXIwCHolbO8fbZARJm/VGJs1Jh+dGdADoMtgelRws/TGb/5mVfbi +rEwxpdFk0LDaleopv3f7HdvGmsmqW//jzXPCiRO8o0Bod5a50vbvXX7HSXWHYJz9RsvdtNStfzjf +RpftjBsAXMuVxqBt/zdv2q0S+j8XG3YArxJCRy1uJqlu/cMJczg69TQ1bfsfIG+dGe//zKTVCqW/ +ezSj8aw76P4XZRb8lDEBK/nvHsKgM2u0G7PGsuNILjmOrbZ4/uFm16kao4/xSSFB+KUfKiC1m/Lr +TbfzZ270n7t7sf3jaafdnQ/8V53pqD8Xc1DkL7JHJOmXj2MArczH/lIfbnN4pncx6cDUYMU9zLEs +zYqzzx4l/Y3JrDlqTNr+FjqKJv1NeZYy+0FdSJPwd8EoGrMOaNhBLm3bxr3hqNUbzWf+D3zGjYhA +yUGDIzjtTD/9V40pkJoiwatmir9gKYYSrAdN+T/QyZe7trLGQROacZzPZ2MwUPuRUCrIamkIRtBt ++6fidXMuRqGg2XFFVJNzbCtPjtSsByKDyR8df73zn5m/2O7OGs1uvzsTpTjJyDCNxFRtDD/mjY+O +/2I0lpZQLwZ5CS/tcTeOm0ggwcgmOhIZoEsMNI8a/e5U92g6Hok7hpb9HeNGuy3vq+yRPzufjeQV +M5Jt0j9ujMEumHYH835DWUV53XP9TqcNbdAbZXOTlvjVWkT5yWicnXQaOMXZIDNDSiwgqd/wfpoy +/iLiYfSZjiWIk5V7gx1ofA3iYKVVyzeGfzSmNRkdakIg/O8yZwCbst8ddvxTlFg8tW88luhn9Edn +MoYHxFPtKkNkiVwHDvpy3oDU5a/iS5v0DMJsHDNAmbglr1C4puUErXPsjw68xdDfbPQbw5bDJFv9 +7hisHfTi/wfsjQ9AAeLAQyQTB8uhYqS97FFp3u9LeLzpTKZQ+M4mhi5qpVt/HkKuj/xZkULM94X+ +b0ILpFI/rfqvpx3/0QBusOwUBSFAVjls64lRbq80EcOHavC6SIkkeB5WzXL+Si/pzJviceGLJeRd +Z9ZQ0VHM0MAYxyN94K+Ngak0mQJ0z7qtRl9PVpYfKLEpBvoyfgNwnK/VtPvXFDZKIlWb66Qd2KNh +qz9vA316AClGz8DMviiPYHkAmGMP2FGz33ExJDzd4mA8+yvf6fenloQhf1Iv3EJfaEXlPLTrAS3y +aWNclxUgykXr6qil4qj6FdfvltH4LwNt6xAlItN/d3phDlPXHiUrY0z6T3Gyt6FfdZvrYfc/ph2r +G912h+3Rn1MdtatadNVyUz/CpAZvtcYfcGvBhH0FwmgIKcWv4c+uvvHD5fET4gIRnr4izZbV6SNK +HJ/bSeGvaFFR8fQRI46P8fQVu9BX3EJf8eJX3lAo6OjIhiLMCUqHRuiddqInwt0neIDmS2z/zRNB +SPQkePyOMse943f0gt9Z0JXjd6x+3SwRb8p1FIlemzffR/12ZyJ5EuHTaVgvdnWNVeaaljsU5mMw +Emh8KWPJdT4BVan8ObgpaiDSm1Y475nydd07tQ2geq/jnMX/jEeTGVSD1NJVpVrn0CGPSrk2KEga +J1Ot0680ZqBvKFz6cHpTlb5r0fYI+luPCuqW6td1GKcAezUbHwoZVQ1P+7Y+GqveyefH5f4IKJ9X +nfG8P5UF4B58K1/uoZuo/u4PRcEB9j7SOYyyF7wpDlsjEwsbvIFm3PlQ0cvU79A1Mwh3UHMQLSgF +KDAFW11l3KTypgS0qbrReQxBAjPrpDMZmg0E6Nay+qke+6AJ0Is0dtOOALFPMWkZtlDSPxwphoa/ +O0Qa/Gjalbpx9ohQfmAc2nhB1PYCaovU+bxoKFypDQW1NYKa4kklbrAZktOYIWrPBm4txV77G0BL +xq4OnUtB44bAH8HUOGhZoI+Qya7/yI1TqHhRc4sD3NgaCca256LZVlObj2pc4WY2yNLOGzd3nrgW +xfgrZxw77EY5fN5/22kmbrrtzihxOgKaXgciFSiOYB92JNwmFEd5ojXqw3ICALKRZavbTWf9eBt3 +gYhaFgj24OFnYnvFo+jmm3F7AF73h64HNW67Bo5j/uQvSPl6JXXD8XgSR8Iu3odB965azkaid4nl +efuWE8WwEQjSvi2OM9Cxd80awrZ/jsSKcPbNPnXNDDj9GjUBTqfdj2HD6DTUN0RL2xTjDOwgooYj +eJLsol1j2uzOBo2xfVPcZqLbJ2atW/1JvDUawqvAoEvOZqiwpcy3m+iqIjx/3rT1pB0HNjy8c8dh +AKDhO2BN0jVjSBSbtkJCwujlM/T6BzygHcc/Xbb7w3ps449BL94ZQh3D3Q5CH+AtpKynm2/Aos3g +BW/iWOIUa0r3sCnY1JA3qwKiLIc+BlukO3wfOTSbqC66cmiKPKXNxmRqg1zUsAlVLLCfVBzCRWOZ +SbhoO9H4P5xaqxkFZ9l80Jj0ptpRu2gsj9pFW9WoXbRWj9qMyWvnOJ92gEqMlFubffw+nMXb/fHk +fTS02+7jaRwqZoCHTO3JYhoHPBM6ZYegqUr4G1r+Zxyf6FkSEvhmLT/cMC/QTuRdin/ZDE1KO+wP +t4Y4aU+m2h1vKoBQM8kRPZ1a99waxCXvemvwV8+GDSoNR/jeZq0H19A75jK2PUMtQWRB1/Fa3I9z +UoE+3/Y/hWq35xdPYf8flIMOBMelEk5m0g60gVpMd2gjOqF8dRoybCOqLKIkSJqzQSjSFfYnMJRV +K3WEZQhogYBvtv3Nv/yFSfcPdDe2HV8G3ysqlo1yoWHEVqqFibfW0AgdObqSGVDGa8ZmKq2V9bcW +gpMPZ0EJ2ohCUlWQSt8KVaGSYDm2sxG6uNG4LwUhmRI3atMaTu1QCtrMun21hW3OP6fSNZs2bRCP +dZKNE0kOmA0Zs13Nkpi2mQLTWToZNWe3fc2xm1mLZhfaQrZNhp2PhnKyaSkAgGI6tG/TJ1vIdW4w ++/RC4rPR7kxUR5GmrbRyhDdTBQEz158OmjL8ftdGSQYNRuOWjWKEGkxtpo4atOe2BrvNDgaf229g +LGLmw5YrhoBaN4bDkRKHKoYGQCdLVmroV1xlnqMCSHV75CTQnRYb3C6mXgTCqlVdFg== + + + 4Q72vLlQRBYSGDJOnLakDMWQ6vftW0173TEwc4Y2Qhs2m4DdOJl24PAm7rqVwg7cs3rpC9XcrIYD +fRayx05LBcej5hEwBtQ0oHN+6VeUsHQMKYslXnx9USiJTihoy8AAt9FwqnfbgRH4z/ErlatK7XZu +/NE5BeK/O+53slo0OTp5VLUU/Kpbj1fg34GzB/N7hSn2eUUnFsMgbL9zE5Nh9h0F+7vAihc6OoUd +Xoz6XUkqmhoP0kBxyYjSZDQASPxzNOnVJcnE2EzvdDQctT7BRx3VJE+6Q3emrzRoHGgF3fbDmTgB +d9iVopiyQI42G7Nq46+OZGbCK6bslwVeBoHzOdFpS7Y5+sNFlyhWwmpF7TtFn1r36m15rhTl0Nwg +Mp+qwW3sZYVgAQHkTjlqg5Xqvncl9sV5QJhCHS7o3zpch7GdNKRLa0x7F70SXCWiCTMuRzKlVCiA +1qR+T6q819ovXYVBeiOZquJ4tRmsxWZUD9pUx3Ifm2Vu6htZijXVept3zsEjYtezQq0WaqrrQFH7 +XarjDYaPXTBBlTCD8ZyARvONMY7q7DqIDgbCkfxA1sqC0iM6gThtACmhpF+44ySFzhQMreFegkqs +IzuxJ14TZregIJLZnAtMAMZypHhLLXywUuv6pDuASLtVWfaOssZsOnZDuup8wD6mzpxZp5s4Mmb0 +EQ6Q7apUXOv5KifqzsMugc1z22nCUHdnHqUiIjVfch5M3c7clvECGRhQiOuf80Fz2OhKEXah+ifY +af7GpOOffXb8otvJP5UC4f787Az9Uxxh0RiqC3X5IRf1N6bwsaL7SjHxcRQfMkPAtcD+Gs39Y8A5 +/YCfdPCeRl1jcB+wCk9X01HUDzqTPx2CGcOLWccw+czfRSfnDX+/8ReMv2+McegI5FXTeesTDu9o +WEBHVQoY3NsQIHUORjd6V7rvTv3zYQ9WDom73vmtSXfsuLFQY4ARxGXqKm+M3ZrJZogLSsMyqm5I +XXPkzzn5EINinTYWGHjHGINlNlUwkPFYxXYdSFglxW3lKI6ngJEVV3CRrd1DakarC2e0gy8xMxdG +SW3WGLblkGiXvFgspfLXma3LwzF23BmhavXAfl0REWgXFpjL4A1WBvOybejK/DSbDuCr/ekMWORz +OTno//u//5/Z//t/2eNM/Azsr/fJt9aOPxr2/PBKN5UJz/NJJSZQZ2IrM0vkutLIs7X80ZHAFjqw +f/iSOTzfeYzs3x4E9xp30WN65zyWy0zKg8/Ux3DjuLQRDQXz3UZ8us1dV4rcVipzXU6fMoep6lPw +NDOZt/hSkToVAiTDbBHEtPBV+IgS25m9l/huZj86nmamJ1TCF8jsVTcmUqPjWe6jclnN7DOdWr57 +kG4V4vHgh6Gravse9McXSoEU/1CeFb6ec8xDLJodjKrT7FFt9hlJc1vzUoHZvs199YO3vkDhnThu +mgLb5pPv/M3l41O2no/fWHeqbpd6zuz3Ss+Z1DQ+iBSigXkpVG6/+wIIWaU3oGEU3p9v+Vw/079L +vec+Z/lP/oHUoONtp9Aiq9+Z/cPgLYYDhjzNv3y8jMCvne/CUftoIxcTvraztdjWEI/hrtGe+wLJ +r1CkVWyxl6H8J/O6t58N0DuR3Fn0LZLJB69L+c58N31zvPW512o1evBXN1J8r37inkki0eAn3e23 +VPfluJ3rBw6DsUnkaZ6t1na+4fjDmb3jT9oX4PZunjPZYSs4iByc7iX4wdNBl+cT03c6O2kdkZFe +ipQhtgrH0xuANj7Y4W9pop3q5hMNsL7k6UEoFu3k+vzFAM/gvhrI5I/2t26L0SQ7Bety9Mhtpfn8 +6CWyf9N+TFHNrWcENj0MgAmlud0tuCSP3C13OYR4Sud6YS4mkuZNu0qQz1unhURjf6e0EXmYwF44 ++OIFQUFNfAGiuXnEoN+RdGlf/LV/WzzBzfPR4hsGRt1TR4B074hIOl2MUoXDjwMRzu3B/l776+wF +raQ8YADvPMeKvYBGuWN5AM/KAMjQwRVs1GHQM3YjV3hFqAbC8pDhHrivVrZe+IoU3hMn38VGI7id +45rXl/uVwms6W/9szbIX263TbJ2iwepn+ef7LfBN+6F493Y4l1GEqVZDpi89BZjQj08q0oLdjwrv +tWIb4ROAbYQj6a29W7xCELIvUHwlIzc55u64lJlMPq+Z1OntIVohge1OOLB4u9FIbpR80aNSO3E1 +3iU84YWFoHyBvcjBPFQq9MkcccymwD9loovhpLnmKLNXn21m68ezuRGVupVU4V1a+LvJBnxWB3zs +O97N6vE0v0p2SqGdcTj/yV09FJvE/m6hM5lEic7FwZ48EIwOGRnVcvb1mETUth97K8GdehIvHH3x +Dbz38YIKte/BSfb8JXdayr8fCwR50myX8u3BPWKeJmtQzvW5g1sFNjerHjzkKvWtA90YfAEwis55 +odwLdEBXl/uQw9DEe+p2ZBytvl0L/IrOyuPNZjIZ2WPOdBjZO5qO3vPdaZeD3DL2eEGFt44qyqz2 +OqmdAdjJV2FIXqeRg+OHY6nTjyfAx2jwNlDdLc9e24Ns7e24kOgehEoYwHuwwmXrp6OPzE39qFEq +Cpd3vsB+hCg+yegYF6OjM6q0w6XuwJrPk8VW73tH6gBtkH4DM+adx2AVsMeDYPaqP95Vt7tsVAD7 +CzL81eduPHtyXxv6AioWLr1/zdT5nfN89btOakTG7k7hPRt80ciAq1LpNbzxiaYBeO6wA7YU29S9 +FVcfvu9pJI3q610gRMujYrTeOgBYvLwFG/tuO5I+4Gj0NluLZob5bveyDae2AZvUCycnlVhpv8iG +0Vs4l4/dIW5eP80Ecv1jIg7X6lHZn7xw2N1lMjfNBH9ROb0imy/XWXpnY7tIhbdf8mQ5X83AX2lA +4uQB0WmmDsloKH8oP0v7AtpvcEv0DP6Zg0wxjz5Ef3K1KnUJ3x6gr+UO8vBZDoPK7sdKPBsrXFGv +D+MibLIPeDJsDh8U5K5ysNGZAgf3AvvTgsjIg0/LX+yhJnA0F2hIaAxgLgBOFg8FThNPGA4KYqcO +n+0hYEovCIQeRXDIZp2iP0WMQYg1LTLRN3vwLZrGoYJK3BgODmNx+LF3KaOghvAp97KvmouyeGnb +pXW9ELpl8AV0C4G/gchSYKNpIDxp0XGAZqX8iUDJPZeVMfgC2rVMm5Gc7ZLgIaNf8qxwp8qfmMZM +CcMFWcDGVXlWCqnoaRbPxRJZB3imaOdI6DhQ5gwbn5shVbdTfQEZhQe6aco4SWlBHGpHk1e+RW91 +nYrrouw7FcVoVjWtUC1qDDGRNdkqe/IIL2TmgYkUz6WE8IjAukW1agy29IJQDlYf4lGGnTZjgGhq +8tb0RoZoQTDG9uUO0BivOIEMn6NfGP3yTHnuJv4OGPgXLcq9ZHaYvXr/OAFq5clYJzCy9ZuTYSlD +kj1foBwovwKcsCFOpZvMLwP7pddZfTezR1xsRIo3dxVJlMW2VeqESivQW0nqdoCSoWGA1RcggiMq +04xMAoPlJMcFgeoXfrS0pvi9h2opS/e2j5EdoJ1QBBkIvoAwOib4Yiz6zhRODr8ZdS+51072ali7 +ztZmR4NipJoIad/2S5lkYCwZFVdhxfjCHRw91r+z5/ncBdRhRO1qoEEMsEChFqadqUrZ4Pda11dZ +/un4qnA82X0zA5BlK89H2ZPbS6AniyO7DvTK0/PORFT9qlwOiO2nuGw7xO1tB3vLAWoXku0AgfH8 +9XPnpPB+Oa0luhePQG0ufuexvk1Tm4/2xpClKeQLqI0hhULh1LCFfZc9LxW+bl/z3S8usfc+CHwA +/XaXBDhJv/H8VXsEBxdT9CNRja31nxVQgJJFYL+TZcHtyv6AdOEjFj7EHVzS6TegqJ0H85+R+3yi +mz5IiWulxZPGFukBso+XFEMY8DH1GlxUEPpBp/QWdB5UMc2LxKkaiJVRsZPGdK5sgItKH1gWiv6v +1f5VA032Oid5MKF2pPT2mk4Wyvf8OzDHixRBlZlTPdjLjfCTzkjBNFaUun27LLxfR8qAT5cKVLhd +xDsQWapQBiQx43rZ3+lZ7Su+9PK8u1UqDudvVCA5EMTV349uJx4FvlU9zl1eZMBc7gdnooE/vw9k +L89qN6VCuC29UIh9tEPwvXnzgqieNMeKjaz3OVAPPbAu+c+njVQkXX59lSjrOQ5WMH6S651GgGp/ +8a7s2RT0tLzketTBhvJCdgQQqfagT0Ahcgax/aB4O4DFZ9L3qnvGmtKZeuuO45eRw5vGt9RBnc/s +ndxvAvPxc0ML+zxbK7e/wLocTKjM9UYSrQFagYPQnOpAkntHLwAfO/ycztEiJy8BUwW9vDQAiPq0 ++Domm5m962Bc5SSj2P7m3vv84itbv27cgw5SfaL0lKHBaCoxmTvrHRi+QLJfGr1bUQwpt6xLu1cN +zOXupdUeRfv9S1BcdqfQZDo1x92rGgjcvR+Akkvhi/5eqcA+UJH0/fOuEaILK18Ftqravbnq6yfC +J1iXNHc8L8Sv2rFM6uyrJ4uoOrdZGuZF1yAgvtj4e9QtJO72MhI+g53EZ+flDeJzKg6uXDgQOejt +AQvFPJUbnKeBFNMoHmdM7nxOPwBUX02LkV3uXSWxFLqDpMRtb30LmdTtd3fvvdL8yKTuSmpQmGNj +2z3Z9AWQxN6P3nMVBFslu8WWRAjY6bMWWL+HvUJnfF5F6gS3VWW24DOqcFI/3VS652/61ToQdIfb +xVdi+Fx4rxfefYFidHQ6z7KZ7GOxddEP69Ql0TP5EegBhprc5KeJs5tsvZqB2zAZMw5+P5SZxJLz +7MVV4jnVfRHewYrf7oJ1Uak3WBwdJADFVHeBgvJ0XXrd+0zoO6XS3wOwyB8bme/DVkd5AddqnhWa +4484WbmJis/AEgN9rL79HSuFRsmw7hXZrB5RCghZvsIhn8Vy/QHxDuil98ClU+f3mb1xkjROTWwH +1wW05IXL0a5lI9Qk1W43v41NHmIFIvkQLOU7XC9bLzTIXF/YEggq+t3NpM4v+2jBVBzGQEXofOKg +dfcINk3hNHtVz3wbaWNrmu8enE4zqVKgwR1yd+X8Wf7mUNYOOVG+8Pvd1mPhqHV1kWNuqZlh4V+2 +NoDwIC5LoePDarLyVJqJSrC4iHFAaCfc3sl29r3wsfXM8KlxPA/Uoe6uAgppfRDYe2cEie5xP7wd +eIXUvV9sJh7GWs0bj0yo72zXSq9bOzUwv8hT8eVr1kI+SCM+y7NiM7cb8gVSpxH6MVuv72xoiOXw +SAZbFb1UIllUMROW/nyyIJDKVimffQYqYuboDvCxQrTOyj5DPNpkL1usZ/nk1UeSecsNwCRzhGUT +KAga0FQKx4bRuqyeASusfnPYy+ynx7dAVvaHxI4JiE6uF5wd55j7zevKwRMTdDVTUc3TQAnFn2Av +vaMzYH4UR+p9x2VGUBoeQ18nmC5LbwET4SGpgEiRwsZZKXx/Mcue3JNtVacHJ2ftQg== + + + e5CMqs8swMhCgMuf9z4U/ouZ8Ojtk1XtVPn0AjPcyNnoq/CePO4XmrvdQLL6NtkvZfvDTeQO1dEL +WH14lJc6yyeeCicn+wmsqlGXtVipSL6HSqns1aa0oLchwPnrCe6glE3nuMCYLRw1+gED/+lfhAFu +nq8gL40XTo4284BbajfQfnR+cV/KELNXsObDZmljN0oCE/YafpOkwM6h38A2PBRUYOndUBgbl3yd +f5HOrjIB7embiIS9UuhokE1+Pp1tlQoXp7VSYMwA5nLb+cjQuQdG2YuiGgR+KQoWOsPL8rWtfBb8 +t5LZj8XDpr3ARjtl6Cx+Ao2KtHGPbfWyTCh3XQxNm8+QkZB6ZBHT6ANaAbBxY/eWvdSqOSr8XjcF +QQaP29BkPsmOPs931ZaT3U5FZC9ZfLaELzvfH9EpAFwrqtColZ/KgfKzAOilN1c1nlVLz2D1M9tI +FUFnlFBP5jKnhfj5576KatNcdFTaDUc5oAYxAWBKZProsHGvk2zdiEdw3PG1eqZqF8QhVdqLbioG +vIHG1GJ73H4vhU7KSfUiI1q9fNqCL/rZWnP8jq1Fitv8yA02hS+VppSpjL+lXanIF9TLLb3f4Pcu +zy+ytfk1ZRQo7KRwNOhOgdjKDcAI+1zp7TSQtNYAzlP7VwBjp+3qlvlySzqFkBwlWsXmqBJzaFff +uX0uNt6ONnODyI5KQEs0ptI+Ds/uwEp3Vef2OmCqfWeYKRQo769gESu730DlPjqTJDJin1+T4F1p +Zz7u5Jh5Dlg6wNJW2eSoySAkAA4aL/ZzX18XmcJR+3JWOA6FSvAY9AifG2X7jQFSjYqznaMNqefj +OdDGjcpr1UyDFdXYyVYb0l00e7n7CiRka0Cq2fHxfEYcPZb3dftBnAtQUFr11NlLc156e6EGkMZo ++TD9QU1KB52civ3DfY7xECB6j0A43IUK7zvjLW52MjsovfbjCU0v3ZfoB1iN6S6feonU4HlQRL8u +dHhIA4WAaWSZYHCUJG9PElmhPJ3BsAGg0B017jLT8N1m4eT4+bvQ2X/ZVBYM6fxvDBDR72PAPp4S +XKp5vuP2a/htEhhXlUrpdfYcK2WCnbr2MI5DGwVzGMkwuACiORP7FEB/0XL5Qag/FZv17G3hg93p +6riXzLgkniVLacynxCUporXwBdARZP7zcf+7lL3IjFOn0/lI6xrkuG8yeVVo5Ru9wm430eL36WKn ++PB+VJTdk6hJDez4WgnKpkZWiMU3oS+kjNgWwtjFA19/qyRKhXkWHUteAo0jGCuUhtlTID/r4Vxv +bz8mKig6iB+AwdXm9bYSuIG5oQj0cjPHhksJwMfaqcKHiluK7+tbIpZF3F1nr0bVNy79He6pTWaI +41xwv1qMPueAvc9RA8U5i5AFZO9TF2As/b17XGjeda7AbktXyvev4zfEI+XtY4F5eXFEP+EBYOCx +0hY3uawcAtXnELDok+8cGpLkHaUuQzNIT/vc9UU7AXbqdbQUIEPAbr68ihaON94J9Qxw4zHJ3Xy/ +Z5FIKAWqfEoHW24MaKy08/AxLLyPniPIdWTqvxZZfU6A3uF6eR4fv2RPHsKCsvowBCBYbM03X4Tz +Cl1P0tHjvdJr9Calm4sMp14c6cS2Fs5b/uOzFISn3oJmyDKAMVfOjr6nCRjdcV547t5vqU+rFQaQ +Om7cnCrz15jRl0D/PS0Fy4FSZSCbRcBAut2OF44jW6y65/5su9hqRtswiuCWOhSfDjZ34MK/Qn1t +X+PpfuYzey+xebae51+B1dkGFnYi1siOsp2SMjgMhQ5l9zJ7z9c5fnhUJwvPH88UsPdr/UxCAgb4 +xUUb7L/uPpiwRhUtlnbK1bESjhTf2EnecNxx94Orx+4fqOJGLJf4HLYb28mP2wkYawVe05Uj892N +xyDYL5Hd1neB2I4NkXhnN/K7JLAJBptA3b9ulqHnNEDS/2dajpbThsIV0LXi2py3pD7rcdwYdnRJ +geJ9VtrrMNVXZN3pr2IBzwr1gi4jEt7M9fEuBfMZogf35Kq72kqsMOgPV2iF+XbSOx+KYVQ/MY3r +i6TZNx6Yx80EkYicRgCnntHwF8XsX6Zo+cWl/Au92KMP67McsCzKvcrW1UED0Mt9Wn5LRQ6uuM+N +MF052IglgkCHAdynt78RPntIbkQ/u+DV23t8IzJP1Taip3eFjRhxShGJg/sQ6h6sWviSmVLTUzC4 +Qg+s5Fuazgm0AJjs4AHF2qADJeUtUXntAMtiMkkfNLPR8dlx5iQ5TQuV/dt4afTA3BQnTw9E4aF0 +Xy8dZA9a5G6WH4q90NuXkXxs9wr0V+WsposnFKeryW2o9ekbVaeTyd60DjqJHhEJpoanoYxsKpRm +N9TLqLdDtHdI1PO5AnbyTEz3AWxhHkmXN3bQxNG6FHrxxFQoM8L33hf4s9wHX98XtJ0+TZ5Pny7N +Oy3zL2zq6CVu2unL9hmQ+7pulU657kk5YN7p/kZoMiUDE/NOL8gnZpNK7Sqd+gJKt9Ng9DRm0Sn7 +GWoE74vmnTLhp8g+9WE+083SC+MLbF2P+1WzuRKl3EnGolNua3s4CR9YdHr/QpTez2pKpygOVu62 +vLG/Qx6/1k07LVeouiV6qYd0/Q11CmixWdSu6S2g5Kd5ugq7DRtXNXRPP/bJMOiUGRlIqUrkxE4v +gkFdpyw7eB0rnSqUjLt9nTx/DusWnWYaHF/aJk07fTl8u7LqtAK0Pjq092Q+1/2N5+nWZ+fKvNPL +fDj9vT2omnUa2eun0kqnYF20pLR7+JA5N++Uub8nSknizLTTzdIHv301oM7NOvUFiNLzc8lirtxW +oDc8zVt12iDK0bcb807LRDbYCfH3qFNfQI/g2Vb0UOz0PhbSIfjwjDkQ0Vt86pU0nT7sE1U+RsJO +d3Wd+gLTzUpnxF01YhTolh/r6bf6+NCw6JTb4nvt0otVpwXidPc5iTpFNrJ2rkffqczX5OzKtNPa +XpC27PSkU6MJs04h52ceY0TtNbxpNtfp5kmlc/b4EA6ZdnoTHH5Ydlr7vHxrok59AeNcH8vEzcl4 +37zTKh24LmX2D8w7HR9vmnUKeDLs9ua1vDmzQPDjOXF7eFIw7/Q0XXx9uXx+Nu30+bx3hDqF8sU4 +1697tl2y6PRJIJ6n/Zh5p2df48F5UqB1nYJeULevR7GhJYIngVpkw6LT+2ui2B0cm3YqnMU2NzLP +McDHQLepb/2mmb/yr2KnTTqs2zThh2pjF3VKBdOhinamVeJtN5WFnUaVTkEvsFsA9utbYvoHE32n +09HOgdjp7DCim+nGU+MxjDvN3ZNHWkYYnUyv0xugF9Bt3MiVjmJorqDT/MzACiubHO70kDyJ6Rhh +dMycYUlDb6fyJ6hT2IvY7fZk0mgOYaeErtPJJNsZSfR7vKHrdMp+pURJc5i6jOvQuznqvNV9ov7Q +abxy2kFVrndeRinLt/eX5ODG6u0nUXkLzJW3Bs4PWG9hx+JrsAY7kbw0rq8Or3vLCeRrXXw77QmG +XckNPzfvzN5jpnhxlHqyfCtQu1dv1m8/Gy9BGWPG91lq56Fl+bYaGR5S1m+b5+97ylsdxrit881W +s2LxtVDZqexfT/Hb9+B3UvftdaQrKafv5GbKgLHr5nFtaPYec7lCpDexfHsbaCY2rN8+FVIHEsZM +3r8FXvhty7dfs4txxfJt74bKXSpvDRgb9ErpF6uvwZAu91jLt8cUk76zxligNWzWqlZf72zsHD3t +Wr4tZk+bHcu3x9ThJmmNsewGtR1OWbxlK0TxYFeacyq0p3sbqV9OD8W3+fi+fldW6m/l3azynpky +0SutBZYn2sHHvMh/3gJ9+HYsmqOlVxazntxoeoZ/afgYNduGFmZ+I3acvAcW5lcd/hOHz0ob0cJV +Hv5zi+w32XrDPELsr3GVkzjfZJMKHlzERH4O7ByNPpbeooPgw+MB2hvQ0lHtiMSpMAwCO/ZuDljr +5g7o731f7m8r0T1ohgF32ixO5m/xmIbdTjZ9AaVbZOlYdMptQTvn0bxT5v7BslMgRL5InT6mniuy +dCw7hSKvZdVpW90pUwM2sqpb4SxXU3Xa3tnZUjpF2r/cKa1DL9T+5ZmW+5pOw/fIelV3q0HwAWXZ +KdL+LToF9iDQ/l+UTsFcNHN9tuwUIHjKWHcKtX/LTn0BqP9/ms91fyNu12k1aNkp0imUTuHe13QL +dYq6ZlU7Sal79EtciHD+oT1w0+5lPhiq975FS27r+6V4d+7Yjv0U6U7kFjkw56esyC0NW/ctNIDY +uVI5aNKl+URkLju1jG7HJ7pbqajyT3ocatdFYx3yJGzvp8fh/bEMMYRApJOV7S80inSy/FgAjKtR +hD3TCmsSu08XA+I/0dOR2AFSgaUOZN0SjAdM7mCMG+m8T4Dt5RKfnUJA/udKrTGLPrNzuXEB9lJW +T/ft+FD0KYEhX1+ABztQoZ3vStjBervIjlUzuNjRIlD2uIEBE8dsIID+gQR5q7WSzAbVSx7pBqUe +0us8CEj3NEoFDwmVH03nDkQoB9zyeZ47cUI6/EccPDbmTeYX3LCcny+gzBD9Y7mC0vrVNp3Xb0ue +365IY2YzhMrrtQ2y3K/fCNEntixcIssGGLmb+ypZgvK5IXcJWXsxT5Sl0JVGImPKKj99e8e8Kd6B +cvMgUvLSmKdyD8lje7z7rJGlZT1hI+t5KWpZD23JenxOpFt8OpqoESgPWYPAHcx6zHH3AvPFJARb +jCdajOJ/RNyRQ3Pc3cc2LNm21a5E/jjTqd1vep+aWoqhydGHN/VTJ1SXT3bE0wTTgRQiulmppZhq +Vp2L+I64+gY2WgS93Iw8TciMwwDaAebcnQq38jZU0/lbeAcM7q5gsUzRMdnYDlbQGLCff0HEENZS ++nMUOZAoR0XJyKljDox0C8wMFMK76pRn17jvGiW3+85+1wFZ2di8m9uu5RYZvSaj8J/HiOqQwkAW +gDOGiidmywkwpl5Q+A9YUMURbaQNMD+ZCxpp4/xSHpJqXGgus7LpyNLl5tRqkhmiM7tOGLQw45Io +Ft9pxLgk7bKTFuaW9fSEqS9gKZhc6IxKY6DNPM4sxZIv4GV9yxAnFe/ak9neb5e1fNoEWacjRfDa +DGl2eGwpK8+vxPG4UenAkKwVOmnpfAF3KwisfFvFwknn16zgMGCrWHhYv/LFQAGFKXkJYLWhi3GB +XekKmFageB2XdMIrAru3N2K8TFKt1S2NsdfJCjGm5WgexzXW+mHe+InBcJ2lpwtqx5rzFzCeipkx +aKXQmgpoKnf3ueHAx1QKtvmunB1urmxX5u6+t70Zyvg81rCSFXhkUlVwAy1x79i539xxa3zIuqUe +O+mpLJYd3QjmimFFxxRM94vzMqWn9iaebiAiJRuH4sAFXA1Ep1suhhOHba8aCLaRIxYi6qMCXdeP +HmxyfCipDTKSY3uo52kzrnJog19HkOaLHjqwcGoATXDDRocxZR8WG+TIXu3wBbwMag== + + + a0EGoOWWcMs9zwL2YtktAzhSGIBbe996fkEXKPe5Q7pGV3D2Z+g1ecXX93UED/VuV0FUhRlZfJ6W +Fc6giYUzNXwsbHJA+5+0W/oUT6zskOV+i1uaPchKAsjyuMU1yJK3OPqC3k72EtoNfgznot3ipla3 +s3cJUO2mOw+JnS/hWO+S1Y/GziWr85AMjrUavIVR7OySBVNTbSRx9T27SY5hXMKpW/eGbCXph3I8 +14rlBdwbgA6+KTQhFKliWC33a6WTqRZ+H1/Azks3OIaHu/dL+X0gWpx9fTpWYOGvgdjhXFGyim9q +PA1jjSqdmetVaUAH1s5EkSe7UKYhlk/0qrQX3GF9DI0nYD8et/4F+vCaD+ooQmWLeRKEJzpNeLH9 +kroM20/Nmc5PFOEny5cFvNHjE73cs5qQL2BD6YB2tEJvEQZweB1gfQ5r7g4xrw5Oep9O1FnpsgA7 +OkHnJIfUuiyei0rUwcOqoDp+A84KPHNDDJa7TkXJeTCeuDeft3HOdzUzaac9FXV9BAmAWflbzbyt +2LKw8rdCYB42n7m9BDaNL7D0IQVaNXuR53MNR2tIehuNeCaO4Sy7AzEU2ZpUoEg82Qsc73JPtvdN +gGlOCL0JUe35YBBpF9GQVuPMozDVlZww5FHwqS/gvA1diBsIjIp7PuOzUCJgLOeuK1Sq1M/Ut0aK +6TnatBc2cLRpT3+A54KjmXpI8gAxme9lOdq1wtEk69WLBq8H5szRfC5PkCCwxTmavCvLN6MVcDSw +amYczfPeB3C8czSD7wLDWZ6jQSjLn70iODanQdFcSD7FSfgCZtqARgjdjOwsaPXRobmOwkSvtPGW +wOYx+Mbhs2UPYCX58h78tmZDLjWzPNjn5zOzzYw98N7YLAB2s+GJyfoClmx2wegH7Wa+Qba0xhJf +REEBq6YLarLiMM5w3Kn2llCQHwbAWT4EAkGxMKh1J+/OcLSH7i7dyyanCQjYKnzVWBaC+UWgdqGV +huBpbBn9XkWkjc2r6dIW392tW2+WyndhKQ1vPen39j5YCGx5/f7p20wWepVicNW8u7SMUgzCWUa/ +V0GRZeHiUgzBMdHvzaDI1qsFHLfS0F4WIg7z9L20NNTIwlf9OTHqBTxdSTgS5D+mcViirNQETylh +GJa6wOvEZknUqIy6OH27u1vGV63z8wNgy+5u1bhM9rZ9rLUNxlypu9JKwl6sLCKwlnFX+9zm9DQP +8HmTsPFcuQin0w3JkiJQbI/j9tILpnw8ZhBL+XjClV3pQjBRubu2ZXiedeSahb0PRka5Q6WLzdWc +ri7aFgCzPLuRvT1uA+oBMHp776S6Cg8JwBjvTcWwiEGEK/kad+WDxcAsNvu9bfAtpgif5L93NSiX +FGHYXKJExltXkWdp9nRoalmIa4Cy5aYfG7Hh5etG9OaluBHL0i8wb65olkGHb25ZPodOLcWMGXS6 +jKGFc+jsM+gQT15BDp1lpyiDzjJb0GMOnX0GnTpbcJkcOvsMOo3Wt0QOnX0GnSZbcIkcOvsMOpts +QU85dPYZdChbcAU5dPbtxNzqpXPoDBtXk0EnWxZL5tDZZ9Ahfcw5h04TkGyTYXYRLJlp29Yx8NaZ +QLpgFxdDMvX0FpwDt3fd5UuVdDbywsGwBb32a+IccOvpfSxopb23pVOd8RX0ARsL42lvV0Ou2lxR +WcaH3CSDdb46N05OFO0Znx0w+zgsd/NDvj6nzDnX89N5roz7xT3SE96HZJH56OC5shuSWcocnIun +pDlXvKaoCwVRYnu8JVDNPIWC4Pgx02AQ725jK6cxuhlsaX/VfWzLfmo+l8lu2khIr45BRMlgzZf1 +GONkN6tjG62V5JTsZm2f2h84qLhl0TYYRGOaOpkhRV02gyZT2B0wbQgWaTyxaVLfTpmP7nhWo+TJ +6EW70srsbdLWIZSeUkxR7tupy6xDZ9seIMvsLFvWx4yuMyfHYU8Y69wk4Ntr06DZBU6sypZql2UW +mEpT0ueBOapdrvP45k4x8B7y+JpO+S9bGqeVdWqadRKMvSptjIEPHnxuWQ0qY5aiab1+jjHwrqMI +2mWtB9N0/dzm8QkTp5wYO2LQRqdDYCvLEJ0oJx9WmSlegDlTvHuMaR2sS2LMMU3U/SQVjrYQxrSO +Xyp3dx/TBjpVdIH1Jplc7nRZg8/XaGbJW/3K3G9pny+nA2EBoLeplcgmIN6oFxL+82a7uysujD3Z +4nMw9j4qro09KwD6GMUFQDhdjQLWWb5Vw12q3EIr9Eo4yxdJpTHfFjDFzdnJ4LN1ScOsNAsjzkD2 +djlyPoc0ZxdHnmhC9lee+AzmlY0emZoaQvlDhZkLlKtORqwo+evIm3vHxFTCmpJDgpyB61hnRM1M +pfkC+tiR2x2v7HdLfezryJt7xzrNTh9BtDCePh08DT6dKWFNAh49MpohafKRwaAoL+4PmyFpN7Oz +FLPBE+N2SPbR6c5JcXZD0t/dEdf5f3FK0io8MsfII7NklBrQhLddeGTEMz6H9JztVHxnGY+Myt4/ +Xt4jAwCEbKI7PKShLeKRMWQLLu+RgWloOo+MVUaqU34e48kjY+rnP3aRnuMuOQem6IEN50zJ7sL3 +YKkOQqssnyjKsnXcuBtlmT68jmy5IAb7nMTxyWoiGeC6pC6Dq3HqgKmlQg4xvW7S0BYMYFfLF5hA +Zu1d8pA+ZghdMM0WdMqr8xw0a4xQRXl1LuP1bPPqVKmjNpnCzk7QE9tLqlS7V6Vb2obqXRjvIoXP +XAo6KefdKjBpNflwsJdVxNTZ58N5v39skXw4syjoi8Gq8+GWyLPwkA9nF6G6unw46LVecge6yIcz +uRHUMolr8Xw4TTSU9E1w1flw+ntHcUbcqvPhHG8JWEk+nObEykWo5WL5cHpbzOpYB2ayLZ9ZDwXc +ymIiAShtTKSVbukmJvJm5Com0mnvT3v0smpAHgVILJ+NjuBEnVbfJRw3eSSWULA+huCsIJPLEMlg +EwPvzNFgcp21Q8wY76yqZWMR8Rz83jVEPAe/HRZCtwktvT13N8tsQyX5SOVVWHYbAmC218qY8THL +bXg/drsNbbRxiG9v9qIpoa3mNmAEx9v2schHBnBWkghZSLiTYo5wrK8EtrhNyyrM2nglsONtaFqv +tO62xnDU6MOCyWf2Fzs5GtRyRiq5uWiAiGrOVhcLL5SR2th8dZFE6jIjtbHZdOMycEj1W0lG6tP3 +ajJSIZxVZKTCfLHlM1IhlFVkpEI47q6B1pnEZnF9aINYX5rqOcgoHBNXX7sN75behrpUOHM+tupU +OBTPbxvRs4pUONN1WXkq3OJ+Sy3G7G13D3blEqlw6juIUDLcL0mFM/Eq/IJUOHP/mEv77N5OMVSz +AvX9yXaJT5+WsapuboTX6mP5uINZ5DbQC4JiXXkUXTiQITDrm+086jCGS4a9Hi6ostHvXR7h2N3O +C1i5mchTenFObtbn1T1ZXoejFw6Sd9REPCj7F1aNi5r1J64BKnGZPv8s928ar4Wt9rxYSm5nXkr1 +9EUxk5gFAecv1Q/5e1Q2vPBQnGSyFa5+nM/FW/l8LnECixDUxpI4CvS1QxY9TtpcLLOsM2gliTlK +j9Z5Z8Jl6kJNXtpkt73W+ana+azqlP3cDexvjKwy7Jj7O7tkt3bCslOiVM/ZZdgFzrunDatO32w6 +LceSqk71uVipyFTlhdMnuzF3n1W5MqEuBWwzZJfsRsZ1nWrr8e0NrDLsuK2tb27+ZJXs9miXdTaw +z7Ab1euWne5UO59tq0479vX4Lu+sOy2ePZYt0bs9pPderTq91GbYoVUFG1acNfol0nnKZbs9s3bY +q6BpyTxVXUFkwhe4nSg6q5yJInomWUnp0ryvF6h2vmMXIbdaDTYyxHPRnBFd7IxWk9rjHKGq95pY +17H6djEk1bmYzaCcglOd4jyw9brKSnJmZUdM7lRx4V2yqyTnyQv3WHAdIumQDYnuhPQQ1+dURM42 +rs89PTkUkbOcn1ndN6diI27n51xrwDXSneqM6O5SW6J+nPv9Uu5YFyKyDHd1W4DO3tO7SDbdYn4Y +r9l0ZnaAVItzddl0Lu+HWTKbzswnqN8vy2fTmeXSLZr5aJ1NZ+aLN4+0XyabToMWcc+a3j+2VDad +GSiHG0IWyKZbUCJ7zKYzO6eRZeXKsunMcunU9v5qsunMculcxvZ4yKYz87VLFdhXl01ntrrI07vS +bDoz5UYdO7qabDqzXDqL2+aXyKYzDulzy1pTWjSbzkw59QVWnU1ntn4m0VBLZtPpQTnWFF4om85K +t1xtNp17jC2TTacDpT8TX1E23UIY85xNZ5tjtbJsOvPc6lVn05kBAL2sOJvO7LREFwO/gmw6M/ag +tV5XkU3ncDKyomw6Z/myimw6M2Qo2viqsumcMrlWk01nlktnWY9veQMwphiAmvpinq5usq7iZSxS +qa/N4TLx6dths2uQz4ysatksXq/OMKQZPOVZdb06a+3CHZ5mkaAnPClY0kRCwpxMR8XCJQloEhQs +sp6tBqUbkltW4KK6nPZgaqEhQYyBQXkqu2w3JPNACksOY4Mnm7LLFiwTSjGtRXRIHk91FhG9nRw7 +FDa398zJ1bLsCt0tXeZOdc+VS5V8kTJ3ltXlTlzlKrksc2eVyeUukc5VgIR9fLJS6G65tSrfj91U +mbH1Urkqc+foUYSIWbrMnajD2Be6W7rMHc59cyh05+7waHyygnuu6MNr0n4R3edZnKwsRGl8oqjc +C+fygKkdhN3Sp+UpDyxQ5xh76ESfMI0OGs+2HnhXiXRuIpp9zhmG1kEcrvMLQS82YYcegsggdixd +f1pKdldhC/S8FdTnE8FLUy3nbHY3lNV5T/lisGBilyYaChCVQzy462goAMoxfsx1NBQA5i6i2z6w +GfG+lWQ+Ln8UAisK2lwHLq6+SziuaruaQVFFdtVWsQMRFEMmu2mmsHMuOwLmKrHWqgaEPrG2NjQm +1taGq7sVEAJbSSFjRGNgtG6YmVp2WaKyboZKx3qvdjHUu8YjXZiJZ4ygtrXErWKoO9PeSjJT5JuP +vWsSRlDV+aoqGIIXF9ZHxK73/rWnQtVWp2+w8NrS6gSGYhfV6QHOCm4JwHCWrVaNoUib0OyGQ2+x +qtcuEhk8nfCGIybb8MZFIoMrD/zSFe6k/EqrGncLbEOT4IpF61Z7q3Bnl/m4xDaUCE2scLeSSnmO ++UTuKuUtm08kV8pbfhvaVLjT5iW5yQ9ZpMKdXb1XWOPOe4U7t7eaw+yn5RNrn74VNcfKenWdWAuA +Oas5PjeKDq5Nt1hirT7zkV3WfwTzC09N06G93XOF4CzANw13REA4K8nnPCXc2WKOcKxzYXVJTD6n +ayZQuTwv+e1mSUzqU1HIIKKGbZgKOSyEC7+WVPfNZRqTmySm4MGL3hJVSTE3aUzaSTr4ThVQ8rpY +pjGlQq4y1G3NdnlXpkJudqWbJKbgwVCvfC9qV955SmKyiiCCtRNtJK03xfBOzOFd4g== + + + Vn6dYmhyWeLdPa4BsYoc13zc+lYxaL94rUjnqdwjQqW1Pna/uqup7tHp24pyXO8tr6byrsM0p57K +PTpUykssmOOq2p9yGIaLrGfnHFcwJNdZz3Y5rqIHCC5ElTfvT1L9YMZb5aBe6JH5XOL4trDVOa75 +AoXDSK1+MHqLcOBX+QJl95XunkptKpjeLGDBg1y7Kt+x+EuThHd2eKXuVJMP5wtMt27uL9SuKm0d +tlT+8d4iHy5snYQ3mb+lSC1P1qXhEbtWuX/c1jZ/FX62SsJ7suwUzGWzNKYt50qUtx6uLTsNHjXj +H1Z12MJKp3Iml4LgC5ZSdapNTZsG+R2ljiCty3IMhw4f+2ad+gIQwfqac5o0vIY+90+N3pP9C4tO +ua0Ac1Z4U3yw+oy4V5tOy9ucdafly60Hs05R3Tehokmt1Hd6ZVdH8OTGutNi8bqkiewC3W7D91H5 +l5iEOd89SGhX36IdnScs26nzK4m33VTWBcRIajQrKmISzPme0Sud8mGN6O3RCs+8jZ9YFnQuwyYB +UtkwOg3SVDFzDpx0IZsB7AN9YpOjh8Q6JckYWmU5JEjJ1oPKu0ltck5smq6qMgty6DpUZnHrSSrY +h1ZZLp2hMgvooOYlBM0u60538+QSWWkOEZoYSz539KQ79PI6P9lrDfPuPFdZtBiSIUpLv19cI91T +lJYvYDcoaz+xtyEBbmkdpyWOxxAbq2NXxaf0rvbwumismbKYKQFgH7m4+trBB/tSXNXljfexDXc3 +HLrIRrJ1L7s95XkpLnMTrZKTaLgybqFkN/Mja0/3Wr8UF/Qsa2/RhFmAy15Ca3ZXnGW+mJPVYrwr +zsYAMvePaYNGTI5YGyVP9Q6sOUxpZTZyo6TnMIueeuOEO6t9jE6snMvXaUam9/M7u+xQPT5Lrwrz +bQgg6AkT7/qIRe2n4MGd9eGgt0QyQz2LJcqy2WcyecqxSnq650A1JF3+S7ts5zt21MY1Q1KF6oun +1apd6zEVsLftIpVTfc+VTSqgU0ljh/VTTt7bZedEHdfEoKtrbFplxgMwpyo6QX12rQ0wnVRZDmOO +uTzuJ6k9uVwSY471dDxhrMo8WQAzpAubaYcixhbMAnSbA+j6HhKrBDFXOYA20ekusgDd5gAa/cle +sgDd5gCqbzj0ngXoNgcQea0XzgLUkIqNhamPg/WWBeg2BxBibPEsQAWf9nxDm2PlNQvQbQ6gbCMv +lAVoMSRDDqD6vBKPxzir5Yvyua/ItkxRPtVcfmFRPoNX4ZcU5XOqyLaaonw4Z8ReQVm+KJ8vYKIV +rrwon7E+8q8oymddH3mVRflc1a9cpiif2qsAB8VZDkpEkVNqsHVVv+Xvhjpexd1QLuv6ubobaum6 +fqqpreBuKKu6ft7ilBat62df1W+hu6FM6vrZe4XMLXHvdf3Mic/2bqgF6vo5U/Iq6vrZR4bInqsl +6/o5ZXKtyKFrW9XPF/Dk0LWs62c/NZ3vYuG6fpqBGKr6LVABxLSun/2EzCJUF6nrZ5qOaHeruXvE +uM6UNb0LeoG6fvY3f8ln4kvW9bMVdHkkxVZQ18/eLezpBiqbun72pq5pFPQCdf3M0iSVrbdcPb4V +5Lx7qutnDwX6+VdR18/+QMXnGs4yie/6jNRF6/qZqJqqqn7q6gzEEnX9dNuQ0Fb109zZ5Tk9hZDr ++jnmva6krp99VT+Zkpes62cfcK3KSF2qrp+Sv2VGi7p7rhau62ePQKTBrqCun81em/boFdXj27WH +4roen0M5Odf1+Jaq6ydDMd0+XrM5DHX9bPIeHKNtO17r+tlr8vDGg1XU9bOS4TfGk8TF8rdcqPPS +SaLTNnSq62d/3qyNIli8rp8W23prcdF6fN6CNKzr8a1g+8hV/Zavx+cmicnp9gZjrIa3Unz6jNTl +6vppHNuGqn44Y2j5un5yqpRdXdGl6/rZqzkWNOa5rp99Vb+lb20S6/ot6etzWdfPRd7rCur62Vf1 +81yPb6EsXB23NNb1WzwZXlXVT9XLUnX9jK5kdVU/q1vOvNb1sw/v0kmxhev62Qc66XxKC9f1M1kX +VVU/+3vh3Nf1W9xvqcWY95wnC7tyibp+CuMyq+q3cPSgrq6fLUWoKoAsV9fPXjHE1uvydf3sE2JF +ibx0XT/tJPVV/Qz6mOubrLR1/ayVIKzDONxk5bKunysdZum6fuqVNB7g2GTXWuxP87p+9sLBNotz +ZQmxWO4nTMTDg52Odn5tHvGhv1fqE9+oqJOV4Km1a9c+8F6XtqihJonGlNOb9MFYnQePfVNiVyGN +hIyPFMQQifMOJ+PzTGOJVqcw942afm4AsXK8EXk82yYSdz0eN4L5VBvbp+mjOBEabiRaj2OGnnwe +l9L95+Tl9W4oNggHc985ovJxlt36nue4jadGmwa/3jIBVtir7Jyef1+x3737R1+AZ+NMSzgt3cVP +4pMNtlpm3nJXvevDdu2Uu/2sd87Y75tQ5337NhtmCl+b9auTXqq/fzfqHIaG36/8d2CSGXJnG7dn +h8FtOlTmAu+PR0fh+efWIzN66qTEvY9yO9PX9drNRjzyktmgPr5vIvt0MEOUcic5ovTeOibK3M7V +ZPKWDE2mwu3RdOuFa07Z5uOFnGlZjxwkYrdxuprclNLevhKT6dMIFptLbuHcaiMP0eSX7j1UX5PZ +1uUYGtRyCUhYT3L+RgZ2s5nqsRmyEDLAdGc7cF3o7Q3LuaKMxlAj2LnYunmop7eHk0Rph2I+5lv9 +9kYbZpIeS8mhG/PomDmD8WqnQ5STuJEt1esBYrvTRvb+xUirso912wdM7SKvSppT/K2qqQG2ZoaH +NBfIz32BwkOpc4cKaOafy1d33Fm+vZlJzPaPM4lpe6+U3OpdFG8z9AtA2zBd7t/cPWUr3EYTwLn5 +lsDi8pkhMtLjYSrj/Utmr7oxQbPKDkaQkrMnt7evkeLNXQX+AhO+6Mdh0m4Um/Vp9n6CLCciMQvB +aITXGebECTYelH6RIeQ7Bhjhh+BPfhdl/QKGczQGfx5EEYfZCgIp9jgBD/Jx6cNSolSkTgUAtkJE +CtHAvBSqHB2R0eDnoNjqfSeJRJoPo4HCwT2Tu3lyL99tJEjw4iCietHYzh/4AtKrfEx5ReUerg+l +F0cJ5QW9vfeRlV6ck/KLFxFt5YNd5ZnSM5T75XxU9Qr2LcIpg10PMLELZvoUgXMOU8/TL8AAy1ck +ugmHrBxe0WC6l7uq6TY/IhCzlwDlB6Me2drmU/K5GGCFkLxyZCt2QMJGCZi3NCBbh0cQbZek+M3l +NQILk1r3t2DPEZhbjMTSNhWOMVD7r8eUTqnwYWYP97IHD7yvcv34x272ovVeLZwcbdQUkpSPBfJa +wzWgNThzVLhS2jeDByh5UYiX1QMZYo6dXWx3ys8Pwke2Nt/uFh/aFwScFYmoF1PyG/U8f8mIq3H/ +QkvkVWdUUy8c8i1pH9zGEAKpwmUeSsDbhET2twB28xnWZrslRXWXvRW1ixH8Tcu/GAyiuDfgwJ8P +IsTXVgkuyUNC+vqBkH+RqtG8US9daTQPNHrhC4ivCr1tcR/0vlg8F62k1Z6Z7mjYjMwFLNgMkJWQ +0ejYTOr5fBQq3uZOj3Ph/gTm9HOVXJGI141sRl+lN4ioDXABAd3oGpbPxQC3FHf8XS+CSTJ39zIF +s9qMJ7qbFzv0dnIwI4hQfCpOFzAXFDeN3JPgTyaMsoLJ4lMG/pkCG2n7Kw35RlS1+k/gmxtIE5U4 +UoNgpEocGe5k+SUODfNKwsIFUyFkgtxRuVPS7EkIhop+k1Fi+OYLSAt1sov3XTQfaMrPxP0LdDi4 +nU/AwvM3lfxbL9vWMKEqQbDNE7gQJyo6IMu5b6hxfJwjjJ2BDu5HiBPDqT9lRbUEsB78DDNXyHCw +pLGVQ4pz1jTSXlrGkPYMvjqFak4GCHBhjvWaHXZUUil36NlmPrsJPruawcY3mrsPJE0prAYR7RZ1 +ICL57cOiLKArVCh5TysqG3q2uZk+LBPtwLAwmRyMdtUqBNAP0L0KpYACguhssgkdiLu7i6wMohvS +bJVyHyI1hNev+LQXo3f2HkmA40IUUo5kV6KnkMbi+Onz9BVu8aepxGZeZxrMbwXFMsfUx6WsKT0r +ShIqMA1VzU344h7hTqUnBxWlZTdzu9uQdJMDSlJL8P0MQPxtMmV9sWVYCFdal/kG7HQDrwAzfdyB +Uqz0uiHdkZHcEsfTvz5TK+/30aGIsVwYOj3wpRCV5/jm1zXAU6QEOo3H0AY33hYBvXBgZOWIiITC +tCYj4UmNhPnjuYwE3Y0dERUKHid0U3V3h4wCXyCcf2i/SEgA41EjgZ9YIkFCwe62CgWH+e+RCgWH +ocIEoQBQstitVP8bLYkzEgAT6iVwpzR/3hNRQM1JMzrAt2rca5GQUAj7bmOUKGIkTHL3jwoSQs3t +qycLOhCvo5WrlgM+ZkZKtiAi3mlRGzksnQMoo/A8hpgZALQurkHEF9xSSnxymFhyNaLWNI04vzQK +G5qORi1AuMID4vzRuItp0JnLUEgE0Tg8146BtB8Dtitt+VOUkkBwW8pqTDfLJ3lNu8Su0g6WSr+w +qPMOFie0LI2Fl6exxIJjUNEYuSyNhZensV1LEC4AYBqLuSBTDQj9NBxQKdKYLSaIJSkiEfEFXGDC +FoQbzucL2IKwQqWr1YAA4mpvz0JElXBN2Ejum4Iglp2Gamf4AotNg/I0BrT39aOgnfdnhTk4zUfw +GCZpVnPp1xullwGKRHaLCSrqfQw6bkktS1RU3IwiPHFLyo1yYyaHFG5JLbvFKVL7J6XjYxQtGguh +dh0YpJkp9sggq0zR9NPl2xC2IhSbrviS2hfNvvPOULRt73ox6rXSjhKJxncMWcPwjojpZwx+HUc2 +CH14vYlsv6B0nLgVREE/yBTG3jXZFMa+teDB1Tf4MxPDfz5PO8hQDNLb+/tvpdfwI6r/8pL5kM3V +kOz1eybaoVBKsk9TuyrHmmoG6UxU5VYLHlbT0otSXHmB7ruQXTDA2FV53A5vxjnJU5ZC0wirey5n +Iiq3mqrncklx6L2gmtDIC1dNiF6F8jkB3QMRnJkCjGcKW3LNl0BDmu5lBDvOmmMSkv1lTFavt6lg +OgSTGi/jom+Ny0PKuSRwdbkJ2aqcowci2NbDIyn6RO9LkcRprQf5QR2b/1SYS7WlTutx3AsR3hYI +ql8LFKPJ8Etmj7j5/2u79r40dib8CfY7LLUqCi5J9pb1VhVUbPFSERW1IshWrQqK8Pb0n/PZ35lJ +9gJS66lt/bUmQ3aSTJ6ZSWbC9n1y8CaMRUdvFX16dk8rPr0fFF7BcRw/46ccWYojL0w8LeZqCz1v +uebsrPpf2lkdijupZjR+66ciXo2LBF5iZtC+TSIkR/l0xK28hKbiyNLBtpMtrsJApctdV5fuakKX +BqfnlAYU6zPNhi6JKxcZuMQAMNY4WUGOJxa+F6UrGncVpp5uDPY174uZ4+s4sCbSEQ== + + + t4X2t/gDJ9aCVjyXE0otpU7iUypGoNC2VM+qQNf62Spp/GwU16s+6Cag2DkdOXeySeQ8DnZPU0wJ +bx2r3UV5hpCH11nQM5RzcfAHFHsl84UEjPnRPL2+DzRscatwc9y3VKjqJj+fI+tkv19Y/zjuWzvG +JCjfzieF2vgf/Kimz8gjgXaK5I/E2CnitFwkC5MFC9O6Xbt719ng+XM/JHnSXD6xJO41ovEIzm2S +LRgzqZaJb9aykuJeqLg6hLZ55aDEdiydvgOk/rtsSO67phTMNwv7g7uwt9u7ubrpmHljwSisbnFe +67S7G70wPAj/6Ze6l4P7sNM3583CarW4tSXdUnjZbYcm3UFxL/xUjEGF1vT1mnQmcujejYpCl74G +m7flif2lZukrqy+nbuXQEX/64eAxk7/+BruTTO7SmszkG+3TTF5sVDPZ8lMeq3UVhohn9jwfdgEg +8WYnSmFvbbCe264cjQTQyVsGFwebS8bk+tFauL9SeLpaLJRXTz6VTjYOqyuFPutSpGI0OKhmGicr +x+Q2ez3Rn8rMLO44mbnC9CHmOEswl/clWcjkZ1ZWkPoxk/v8bgfnt4MffMjMrdrtTH77uJyZfZzo +If6ljiBtDPCinMjp0HCSv9loNCId3OuSYhhKhXj+6goju4eP2sZikBifjoPEBariTbSsLn0LZ7UW +AXrSWkTV+SxqY3lO2w58sYdm8bU2348izlspT8XKzX4QubDXZ6CS/JMx+fcyUEn+SUW9X5+Bwips +LTJQ3VtJeDd0lH1vg7YMs2DYwjUCGmbhJd2mqkjQ/11Y2r3dAvraPHTw+B6qNWI7qxansHdqx/4w +l8pFtacscEj1SuLHL6JeCOwnILFSobk4NX/Vma5tLK4730bCoHgf4XP6clV0wyq+CxDACDvFhOM4 +fuq7Da/mGL3HmDjOfJSfA7m5sTIdHpS22ksZrU31Yx6nmcRQ/mbmrjEROc2mE0+9mYZXa5fsaV6b +3FatoGHfOma8VdmagRJsN5RfaZ2L5WBLwFq1mnjXQZfbDrHQS3u7Txzn6AIUVI+jbdLtKYtK5wna +Wumt3G3bTn1wnrEbMBfy7hfbj5M0l+H7GMX0HSpAbdrMxFbg12YGrSUYGrQmi/paxfLtB2Vr8o8P +u+PNTGzHSM/bU4UpHcZX7ni7o6e7G85G++zppeqsTm+DaaJtN8KZ6W330XpT+VowLuiBylnlmMOn +WzxvlWe1SeHvCqI0d5qj9Hbs1uf0d4Apx41XZI71/mvz04z+Dpq7URh/TRDsTwRIvGcaXTYFy+Bk +MRVmjezRVU49O7JBV65ZnQXA1sSJJiudXX8ostLHxS57bnXAv+g009IsZdhULipH66ZOPZvnFOve +mdOe+mG+8OqcpOL97Jsd8bs/1DImeMKrH72lwrfkiDgusYNvi/4cJXZ6uZHcUK+3+KGajn2wrbO8 +NcziernWmF2Pk1i1kSQW0ibSKawT8XEkhcXWF3cVA5Xx+vycxWCIRXmqnFYVpzod+WvMm+Z3BL5W +FPFUzmHJimkFotG7C5cBtfnqI+4ve8rMgHM8Gdm0/v6xOHtPdxxRJjprldGZnIX7/Th9VH8hfYSa +8+v0kc4Qj8udqHervjJ3MiZzkophGpO/FeKglxoqEZynRUAZPS2Ck0QEMBccT1oIuNH/hRCaizuJ +COzTOy4TEeA+2xpJIybvXn+NEF4T6X85Hk3/KfLLObQX04j4H8VFUjwbAdIrM5H4/1K9AYvRtw5+ +NorXjaHRe5mBWpcXWbSe3qZSm9eDWCt/czX2zh5egWmwlikWI5jea/xELV4ryr3wKbGWv5WYXd7r +Zn49hnp0+3D8KHrRzQWnfp+wYOXt+uVQGvwsxm89tfBs40t5fwRj9BqDt2Cs2nkzxsL+G8dwl3kz +xg47b8ZYvfufTO9zBq1ejLEXIHLy0jSuXy3Kn2LsdvC21ag3UuqqJDZOEi+yaP03y4debJRF2Hvb +atSvn0YgpSX2elDVb38D2EPvY1qudwZvnEYvM04z4Pzy+mkM3v3mGOJ98snExK/0UzydJSwy04fX +1fQYWq2f+4CUR35JEq3w8S1jQGvZun4jqFq3T2+1lq1O/5em7kU/1HocpPbJv6XirUEmXb2ceDdU +nZqgo4KKFON1xA85jE54IxESFvZXJG0wkzNd6tjXfH9/po7y00t1N7qF2aAj41x06/XsSZ0r40ur +GKrWpayK5sFReHb4KEwn47yuFi06N1vxY4U4wH6WhINRYnCwTUXc/lwGKsk/US9/KQOV5J+M4QwU +hsE2a4KiYulAz14xR4EzHejZ25qLDqmDWX0K3KtYKraG7zqH6j7D3T+Hf9q4LoW9Y8XW/nDQsfTV +7vfWTJSL2qK1zKUjhfVdi3qx16QtF8Lzma/Fa29jd+1OTshU6FqFaeHgrb9n/iyFkJze6/uF/8Rx +HD9jmGONJRy92tJ8cbU2tXBRvPY/PawerHaOVChu7XT2XCeaLo/jG9MHdvLdhfTqtir5VAy2qQOQ +rX313Qb8hvuMKjXfHaoAXBIaEmsndhlzI3VKtFBJL2zrylWxNRWhva1Z6o4jj289z8Vpobl0XPa2 +KVKBtVRE+PbKieJHJ66eyzGboKNZElZT3zYce8E69+euV1NUYfwF6z94vdqY/OkF6z94vVrlosZe +sM79zvXqp3+XjQWA1BbnjfVOO51jMiYngVIN+4MHbOA21sKrm06l+SPsGdxUPwx+4LdvCtc1uWub +gjlAcpFeaRnZnfC7+XTd/f7Ub/bDRmV942DGrHSMyUZhtdcv3Vz2b7qdZu+HOQ8kbhbWut07M7u6 +Vd04Mtf/eej2+ib1Zx50zWK1OoNZrhfbHd483bTuwqH2hePtSm2rZM6bOJxGMpx/3A09pAVkxlkD +BgUt1WMglYbBzFX4e/zdGMAPM3cNZjH4Y8PMf15QP8dNg5GEBPw9/gGVj1D4BqTvpmNum6dfmNlG +5vuGZwnXDrgZWI4ruGveG67FXNfzTNfybdsxK4ZtBT7zoYUdOCDmCgxEOA53oCcGbXw7acOFxaSA +OjDxGK2L5TseBwp0xKXvUhPPQ76BJX2bucTFEUK1GRpMxfg6fr08s7DV6ZvZ6uFmo3rdfAgPfjyE +KdnNgsQs6TEGHULBCbwggIIvA9eRGjsMxYST5T5O1pHM8WH6jhU4ngiIIhxhOpZ0hetA3SWxQF0I +4UPdc2GqRWOEgLLwfQ7dBBYPgAUJjHsO82ycqhNIojDPdYjg2jYuE5Q8mwWq5NvSBtZJuaLK0vF8 +M/Vs4AD/NPfAly4+OEpSo7IdB+UvJEeOOHAswRpJEVHcwJZICYSPcw9cG1uggJgbuD4Wi0aqgkvN +PRQv9wCEAhoKj/kO8bAZikUEduCqXjxBTw9TcN0d7jI1Ns/2CRu6Zxi/JBRCCZZKqln79AnnIG+U +isu8dJ3QVDRGKRVF8YSStUO8mMukWgXCXdyry+wAeIxSaKwIDGgLqJCSBCCkzzkBwBW+otBniBkB +Y0URcW7HmEL5oQ5EdSXRNIU0yHW8IEYm1hWvpJ5GbvEZllF7uFmCVRVqlqB5DNCHGOcSAGJyDmvE +EdNcuFiTPuNQUz1h3QE0IMSHKYjfQAbClSmAYiPmI+xBtr5PFC5QwYHCEFZRt4EFM5NYB5NN2u4F +vk39DBGUGUGoexZKR5kRBrPBNq4thK0oDsIJe4F1hrYc/FWAdc9jVPdJG71A0GxGCAg2mH6g5uLY +CpDc9kABcMIRRBmNACkuiAzB7kklQk6LH0jPJhFhgZZjmKJm46N6gV4xT8lseGnGUb4as7XxVtD/ +hRWsaS/AIi8Av9qGZ2ZnzOMjciol7ViE43kwqZQ/8QGGbIgibVcEaG2kFDb4AWbZjAfec29DYvRQ +JA5DnbkHATMZSHwW7TtDq+FbLpplaGQLpZzCcgTYadMHlICp1W3AZMNKqRXGlWKB55EEQZ9spdJg +fAS2ATOEBPA4rqvYcE9bjqHx/H2vgvP1AiTcGxJWH7WRJBmAXkgQIGILCD7OHQmuSy24H6BeFI1n +JBSGjc+hLRF+YJPAbAfl76FBJLsD5tPFKlpMocXoQzcwlKSqfheNUUolRRGBCGBjheygXwJr1JsP +y+T6khgMU2iMAcAITKPDSDdhHh4UcLkkeSEgBDbuCxx0AiYKB5wQVm3Po1VUxh3rviADPExBDAjG +YdtHFInPCBIRsfQQLbaACWOfAdhpZDFEIECA8aJxgp92FGikTdhzOKKJKDRQFDtaM5gWiEVKFqii +Ahc4GS+NNI/EDauq3J+DdiIgOFIPtDi0cyoaIwQaFRhJFx0mza9CA+ciIBTYKCaaPI0BwcPQMeEm +A7crzIyVTElNl0lnpJS+bpGUFECLKbBGDsMHo4dzgNUhO3wPFB8WCtdLWX2oO1xwrNuC2VAHrQQN +hTqzfZzeKAU3INxHmKT126OdA7hJTyiCmicQbPSo2K1HftTROi05rFOsydjNMEWZCDS3XE+LBOty +2ycusJfTFFvyeE+HdXRQ4MG5I6ju0Q7YswPPVVuJNIHgwUCYNBnH9bUhwt2GhH2WH+1YXAdGHYkA +N3+SQA/jE+RuHNgyophtX/eSJpBjYmB1TW5bQvEcXZpxlL/lMGqjhMqaOpzBUY2OQHNzcG7ba16F +B73mzR0c1a6emv8LzWan08VDzwN8Yl71wqd+txfS0Qwp8EjUHA59uxvG/wFAmhe1 + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/originals/SVG_Left_overlays/Not_downloaded_left.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/originals/SVG_Left_overlays/Not_downloaded_left.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,1570 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + + + + eJzsvWuTHMlxIPgL8j/0faAZaXdoZcYzg7d2ZvVqrW7Bh3FIiTLZ2hg4Aw6xiwbmMBjxeL/+/B0e +WdVAAyhJFLc7gUbDO8rTwyPCw1/h8ZP/7ddfPdt9+/YPL5/F2/lm+slPDu9evnj/9t3Pbwh68w+v +X//4w/t3CPrpb352s6TbGRrt/mH9Whr+48t3P7x6++bn9Cv65R1++qdfvfjDy5dvXtzsfnj94v5n +Nz/9Gfzmt6/ev34Jv/vl2/dff/v2z29ev33x7ctvv3798o/vb3/41+9+pq8HfMcX76HlsvzdHP4u +zMt8M7ef54wNXrz51xc//PDq/8Nfl7hGgO3f/vjm21dvvtu//X9/fgNN4RfwB37xX1/95uUP57/N +t621zE2Ob7/58f7lm/e/fvf2m5c//HB4+/rtux9+fnP4y4s3N7948R385sXNP798/frtn2/2r198 +8z8n6Hz++u7V65fQz/sX728W6vXuH5bw9f7HV6+//eWP9394CRyIpSI4fk0of/cD4AK0+DOC69f/ +cA+Qr16+fw+kwQuRc4df/PN/OwC7395TO6L2drlZ4N+f/nr3y9/+6pcneF27OSCn/nf6Lfxvvk15 +aBGW7JuEghjwH9dkaBHh87dtwBErN/jN3+89Z5iB0PBffvPyu1c0MWCw/vvPpKfv3n5//+Ld//yB +m8UAf/g3v315//1rGFIag6XcZhyE3H+SVsBVavEsrvXmWSgRfh1buQnN2vTxevmvr17++ec3v3z7 +5iUPyu7d+694XqQ0z/ydf/ObH1+/fPe7N6/eA2UFQY1H5Rdvv335Gtrb5+9ev/juB+3k0r9zg9++ +ePfdy/cwpd6+/vE9TfpV3wCj/vzFX17i1Fn4Bb/6/uWb3779R6LxWV1uYwQ258b/wpDEst6UCKO7 +0ivSDL2cb2b3bhp5Ro/IEJW+A6bWT34N8+dX71599+rNz4XC+vXfv3v1bZ9TNdys/I06cbu6v03/ +MrXQ8ffvX74R6mEuH37h5uZ8+4uv4I2nN98e3t4j93/AVQcz4A1Mjtdvv+Pf2c/0G/j4j98z9fT/ +r2Ggfv3u1RvEOf2SfrN+/evXP8Kv/v7d2x+//4c3f3w7/ZSlzm/fvfgGmt386g//4+U370F6CKD/ +9NWPr96/vH3x6vuffRDRr1+/ePPi3Q3B4cMMfP7qX+E3L4CUG/4Y/KbDPo70+PKPsPT7Zxl6evOv +L1+//f5lhxvkxZtvb/7pxbvvP44ahuGdw0D/1X8f0dsX7/8EUurlm29/MLL4v2NHGfZxfF99g5Pi +3c3+3Y8//Onmt2/fvja0468Mu4AJiu3/Ot7xa/rAm1+9YQadv0kabN8EAuGv7i3Q+uE3wC//mrEf +Xrx+/eq7dy++/9Orby694MLv7U38u0+ZWH+5/8Pb169+uO/zyUF+/eLd+1ffvH751V9+eP/y/kPY +kBt/fPXmW5iIJHQ6tW/vv0fV4uarP734/iXhfP+nO2r5lSHMX4Ng9KLv2bMPyMQQb/Zv3O///t2L +b1+BuAWdaf/6x5c3v4H/vnh9o+CfTZfBIO4B0bfTv0z/ZZrxa5njnOY8V3jWuc27eT8f59N8tyyg +LcQlLXkpS13aslv2y2E5LqcwhyWEkEIJFZ41tLAL+3CYwjGcwl2c4xID7mWxxApqWIu7uI8HeI7x +FO/SnJYU4cnwlFRTS7u0T4d0TKd0l4GWvOSQY05TzrnAU/OaW97lfT7kU74rc1kKaAAFPg2/LtP/ +pZ3pX4v9XS7+DxXHYN+j/AXSiB1xzhNxBf/q9yJ/k/xUgGMFeKbfV+If/m3upx383cP33UT/HIi9 +B/iLTObvwGxgNxIHX9AZUN3gKy79h/8y3d3dne6Od4e7/d3ursGz3tW7cpfv0l28C3fL3Xy6O51O +x9PhtD/tTu20nuqpnPIpneIpnBZ4F3z8eDoej4fj/ribju24HuuxHPMxHeMxHBcg6+5wOhwPh8P+ +sDu0w3qoh3LIhwRDFw4LkH63P+2P+8N+v9/t237d133Z533ax32Y9gv072532h13h91+t9u13bqr +u7LLu7SLu7BbgBV3NFZ3d9Qd7NCROoXdwo7trHPYvUpdxE5iNxN1FTuL3YUO44NITqeJeo59P1D/ +kQPIg0Z8QE4gL5AbmTiCPEGuIF/wmY07yB/4moBJyCZgFDyNeLUSv5BjyDPkWuqdOf86PfI5bp/p +HCQ8esyzP3+mC8Dd+QOdSTc/+Xr/DvpU8KvSs8LT5IHBLHt6YF4AH5Cpd5VERwURAcIg0pMqLFn4 +MH+ttU21wbOr+wpTCpkII3K30opZF3hAhqwgKNa0wkpf6Z1rXfGrrTCLVphq64GG4IRTo80TLC0Q +SS202FID4QDk1QatwXrb0QPzs8EcxrGjiQCzChYhCDGYiQHmY4RZmWBuYqeAMhpKXH+0DgM9C4lA +fhKIwgiiMNNP+D2BWMz0FHqQAwU7Q8Kywb+7iX7Y40vh+16+H+iB9QbfTyhNcTYHkkP0rhjwCyQo +SFh8QBaClAWBF9aJhG0jgbsLsChB4h7h+wm+08IA2YvSdwHpixhQzIIghTFBc7iSNF6h7w3kMUnk +B6QNcouXD/EP+Yj8RL424jKOZyG+JxiBCBRhV2ccHBiiIwzWAYZsh01hEOtEI5phfCON9QLy8g5X +JcyEA8wKHIEGE6XCpMkwfRKQGoChMyx/nGRHmG57GKkGaCpMzTyB3E+wAwTg/Azy4QQr8gD7ww5I +WnHywa6RYX+JwLwFRPYdLPojbDF7GPSWVnhDgc0nAX8CjOQcWS7hmqYn2hPkofE6zvzIYhN5cyBh +ceCvPT07etqEjDsQMw4083HZgEDNJFQTCVYUrYHEKz4zCdk7ErQoao8kblHg4tduIrnbSPai9K28 +GkEGoxROJIlBFsNDM20/k0hGoYxi+UiiGYUzimcU0I0l2AVpcOFpj32m4b/rJz310jNdBJdHPvn8 +6bLuX2za33zgB34C/C03eb6tLVawmgEBmL5ffz6C/Q/w9jSD+AzYtKRW40UsJcBERpN8haVNbdo6 +w6pTjPU2tiXexHzbcu50XR81UQxLa1kK+o1ABVvTRbQh1Tkj2gJKYiInEuhL0FjQLreobt2AKtbJ +vTJeoHV/NEVbNeDLKvTdi29f3rx/e/NPf0I1ftr8H4YqsNKMlGQQQfRDrKCinotPIKmFJdfxB6Ry +nHSI50bxXOwsf3z8AfHYRBr5dz2UNMxfiG4GdDXfXI8+Q/gpA/v3716+fOOtog2AsIo9ZEI0mRCd +NyJUxacJUKfjJtIqAukYM+m6soEe3NbZt03YOEn6whaNm/UM2zdu43vY2Bvs95n0gAV0A9QTdrC9 +oroRQT+5gx0ITQm0RMJ89rW1hM4bkMzvEjSLgg2W2V0Q9TqgRTIo2WhdnEzP3g9WBmjWk6jUy2Bq +HGlrpO9spDWxl7LYVWhqRTHE9PmEr8f1laxHtB/ZgjyAroCGwJ1YkmxLmjUpmu8qGu9G20V9d3LK +biJlt5Cyu6Kqi3ouvdVpp6ybNtJKD6SPsi4aSAvNpIGuMEN2MK8OMM/uYNYtMP8izMQMBFTY7Bvu +/XtQBY7A+ztQFBZQGiKoEBmoq6Bg8F5uCuBCCiCa4fiVTBWkrrKaTsogmueNTPQdmemiGJKxDs+E +wxrJ8Eo0XolUX9ZMEac3G1xHdrJMcMEcafHcUbdm6VqgN/Fiyzw3VrKUj+R5iKRWr6QxH2E6BtKD +q3ga1M2AvWMjjKYlf8FU5WlLE3iR6UzKMdmQNO70oGZxwXXQv3g+soMgUu+zWf5ALX2YdFLWSgv6 +KkgtZcV0wZaknLJ6igoqq6igpNKHP2grd9HRBUdiXZuHekeaPD6raPdVhhcHmoecv3Ai8KSAfvgR +EzYSI8VSWGUy7Ad/DY54Mo8NKPLktRn9NjBmEzluIrTLpIXzyuurblxzfb2xlcn25WBbTmRaBltt +3bDk1bbbWpViV7JVyTalWpX4kXUio1LNygOZleQkQLOSHrYrA3E2mXVZaBVXsTJxNbOluZ/OTE19 +2OScxexkw5NNTzY+2QD1D3Fgkn8+ODU/8+tvFeFi/y7m2Ft4b5nIrxfFv0fy0W0//adi21KlLarI +Qq/u/+Tam9hvQeNDa6LIati7lYDLIDvXpW06znlZZJvhSQ9THqY7zHneWpJsKc2m94mmdbApzS4S +nMloax9lBuvclX1nogm7sxl6kjnJm0+2zWcnm8+RpPUdWY9BJDRvQRWm+Q5N0D1ZpLQNwUa0kPUa +yZotZOOuZPXuyBDGrxMay2Q4L2RK47aSyY2Ga3adjit52PaiKxxBlN+hS450iUAPuuyQfSQVyJ3H +a5Y2FlJG9mqMn468GRy9awNM+7058tSFl8S8X8SgP4kRz85PdX8WsdWj2OjsBD1NZpjvxB6v4g3N +o/q4UR13IuxZ3HfFMUws9VFvJN/LUaT/6HUpG6/L6Hc5kYvsQO6y3WTulxUmCvtfMk2daF6YBWcy +WdPsiznSVNuLR2ZH8m4lv0wFm4fUnGwOmkhOmkCOmkVWCe+sJ3HaHMlxw494KsrOnjaxVGV91Jy5 +zpe7H3y56sntvlz15HZf7qy+3Ol4Mneu+nK7N7eZN7f7c7Pz/AweH/b2TM7Zc8HVc8HPc+7pGXw9 +Ezp7BnePd/g4pw89zfl91Pej3h+edXm0X6K5goJzCC1q05hdo89peIhTk/yD4/OJQQELCzwUFZi2 +gQFRd7YKj6k8NMlP4lxk16LObPIrTjSpF5vOR5vITScwzdyorkVxLh7NuajuxcqK3OQ0uXM9bieu +xpVcjehsZHcjOhzJ5UhOR3Y7HmkG7CfyPrL/ET2Q6IMspFIl8kRG8kYGUrbYNEK1myc4z0ueRDq4 +O9YAB8e9CYV5EAoHFQqOb9V8sulMHhj7JhECKgb8+te1Pw9uWs9LcdZ6Rk4X+Oi5mMRpG8i17nm4 +F+dtG5iXpu7FNY4xr/amIK+iGmdTiVkhRpv7brNPHGSnWIdd4vHBsU1obKJFMH8sNCbu9j77u8Lf +5/6BxboOnrrT1Zk+znee7SKbaXxwbHYkclcblVDCJC70PiLNjQaPBTvQTzQKOoVt8o4MJH18zwqL +RXmWTXynmuoyKuF3ooCr8g2kTKJ3q8bdFRmvyoRNPGd1ZqgzQXEgJrM/Vbdh7WYl+bojmXsgOXwS +S3s2JYft7WyKDqo6u8l0HdwbcI9QbafrO4k2GNN5ROVB6QrvYQHLShM/e1OeDoL2aNGGO1On9CX6 +omBRC4xNyjv1vfruKqHMVTZCpmInGyQrYaqIHWUTPfGOeid6mepmXT8Lsg0nebI8xWlsXWtb2Tya +6J/doMQ5Nc6e/mVBUzbwWQOPooNX08IPGz08DZr4Xk1Rp4nnrotPoowfJbap2ng2fXxn0/vuQY18 +L1OaQpUblXxwBV1yBo3uINXI1SUUJ+cVWmXK6oRlx9BiGnl2OrlOrIPfMCRk6bI7JA== + + + v2OR+GOhDI/VQo5H9r4MjoNEjgNyHUyS7bGniXgSv5H6D7oHgUdLfQhHGrGe/bGYG8HlgFTx4u3N +n+A9CsG8eNmGcx2i1uxXOE7qxpOg9SIbmXrz1MfgvQxN4tc7J91EvtW7yQWyNZjdXQ9jSFufVYLb +6onYrfv+TKvokrJSddkMgTJxVnSXxWKOi/6Ie2iib4OYpgyeCLK9ELmUv+O8apq6o26gO3H9sRNI +l1pfaGEyt0953DqDATnaSOAYeD8q+lCF0eMW0jcQ/BrWmXQ/ibemZwOwe+Y4uZX20HaxdytOtgvz +VGazg2XZTbJZyEZxYavQzcJvF24d+h0DRfo0bBu6cSS3eRSyV7YifGfPfhTjkzje3bg7D/5OPPjm +wxd76pITfz/Yz9VSYOIk6pFaSqfBjO6GdBVzSE3pbkxrqFssnskM6tGk1tD2eVh7E9IW41rN6zxZ +YMaFZj6Q3uATHIqP1qjJPbHNPajYanl7RXsn61vV7SpSIJshzqa4mC6qgS8iTmaLdOv2ebTnYM9+ +eFhC7Sb6Rma1j6mP4fCeUaVZVZpZJWEfC/y40M/k8qwOtmfrHt5czlW31qupAdllYIntPpn5HlxC +1qJ6hkuBOjmL/mh2fbftxb6fZCk0e1Z7OgeLPdk96UICCMzw4J7FPXN/NmlYp+E5js90OP/anz27 +B552/pDuyGGQ85w/y/h7IOHvg1bNJB6Kjxv4W+tmtG/Mxp/Mr6VLTc2cNGQRdU+Wmqxbc3Vhu2dy +WUR781hVZ6rGwUz1Jv/ezKFq8Zs0XQjgcH6RD+FIEMdyjdQB4F0A4gSYxIY9ydwiX4BYs2zPskOA +rVq1bNm2yuYeSN1JMI1hN0wmABrArvVx9LWEZfWAVNdEP8DWGehUT+AMCg78h3CLOtCYUHBdtJRU +UJcZGmCzOeVG6SalNcoFINMcjxylPDd8SYaRCZgCsDBuS1Fo8TbATOiEXhWr5LgEmJmIIDTAhRhD +m5c89H1ZakFIUSYE7HrP87kp4TbCPPEpLtdES5QuK+AcEIRSAMUwbBn6iuxohJzO+TC22G5xW7uJ +CROAHKXXRUuUfvl0SuWWUoQWZE4K15ypW9ScArPWOOZNLWFNA1ca+ZPwhxpyohGdkS3KiHoLb8C0 +paW5TJjr4v2UhJjnr968pGNPlhGzhfRsp80RAYyG8QGBgx0QwOMBdTAg7+R4QKSQfenHA9BwnHrc +fmNhnMS+iJuQ2iVj3gXVpnwS+2JrXRzOTHi1Lc5NeOefmiz5uG0t+cE11e0M75vat7OM4+mixaE2 +R8+VOHRb32VKnOVKoJ9fXVZqirDjaicBA+e8MpukWyVqmSSJTpTDivoDu69OEqRjh1UhC2MnDiqZ +CkEmQ9YsCJkQfGZkllMj/dzISnap8y7oBJkkxTmLi8HNEneGJA2nSLZZCcF7fyazSR/l/rlomK4u +54c8BSfzFASX7VPPcg9OlnvQ89nVKWTTadq6O92sCptsg202+5DLrkkFk0tmzxtr1tuzJ+dBCs6a +3Xo+jxNFdCPMC7RX0U49krMx0ISox/axqTBOhtkdIurTQdPgjzIZ5mkQGONk6N6mxSWqFPU32ZQY +JsX0gE9wnBbbibHfROl7YlieLuSpjCJm2aSoDAlhW6fROk9buWMzxYuey5Pl4nSZXFbK2dmHwU/e +J8vo+HCecnR7YOQC5wjODhQqJwn2J5kc7W8nQaXnHoYHsr2qneaic1znM5zT1c4PyUVzoUriGk1k +3f5w+h4m8q8tJMpw32MZdgfTNNJeh/lTR5iSC0xFTKBt6jqDORdhrq0wvw71BJMpwiSqGCI6rCeg +NsLcqDAdDjABFhj2QnkeR5AEASRApXE9wfYQaER3mKrhlvoKkv9wPIEVHiZYOYXSLQ7ohb9bKJWu +wIzcoePqzk51+SNqn3NAbTBWp2seT0Mzdfr48bQPJd2ZYWrx5+liHE6PtPg4nD/OcnaYpZ9kmS4c +ZfnEgywU/uTgZ4vrZHHPaBHPEx0Z4jzjlU4WZZiklG1MZ5FOlHG8p5zjlQ418aEnPBAFy+mOzi0e +KAW5p/Mmyq9aNLv4aSo8TYWnqfA0FdxUcO6qtcwz+RZAOyutkU3ecpJaJGR/Xjrf8mkfkzMsn3Yy +60tOdX3iyZSv3v7xPdcNuvnHV9+9efmeDh5dgvYz+8qDSXkwKQ+mZZrpETY/vuUjBwTPyZT1FrTO +dFPjLSi24ZNG5tLnaYge89nbkpeQsDZOXPAD8WZdb2sM7dNIeBjN4ylp+fNm5vjJT5kov3vz5sX9 +y29vvhPQDaw4mCkXwTQdxXezqb5w0Wa+6GJ5wGSezuzlamdk/GnwZZMzMWZNuLyJyUK6xaVOOJeL +C+t2l0s1s/gsFWjraslnuUBDeFfcLGQUP2zM+NoR5/UiovzVYhG9aETBGhLdeqhWDYKN5B15eA5k +SvRyEFwMgv7CO+/kMDqeh8G/YQKRG+wEup4953PneOq88rlzskN2JK77IfOTHTAPcsgcxPtEp8sL +na3RPA/O9NiT/c1HyzG/B/YIOj6iZ4ryA0fHr7El+x15usaW7Hfk6Rpbst+Rp8/fkvvZpW3him3Z +im3Rim3JClevYhoSnF25iiG1ebboX89p3g9Bew3bl8lF7l3sfoje92Pqu7MA/jaET7VCzg+nfySO +z4nyrFOORSwunTU/PySeN5HvHvuO0yb87ULgZ0FwzU8/XoyESyx8csHwHg4/D4j3kPgQFHdJ7TLe +0xgWd4Hx08cC46PqBUu/rflDSg1sYksr88qxKZA3+AOGTtJFLelaCDnq1kB+JYrjrfNyGVmANU6n +xIv+IGGoy0rj9VB+2Z4d1ot7NoD9ns1jS3r03jaLnaR5UVKInEVS19Slo7ShH4KanG/rk07W+q9L +eyP7fjkiRPEg2qiSKxXFkSAtE9UkeRAdueT9mkg12UvkJ1A5qF4MChQSUkd6vGdHXjB2zdrxKaLM +PJPRkq36ESSfZHWyvNllSM7t6bmkn0wS9thZIpXmwd655FdNetWEV5/oup7amHX1SdWBLpX/2RQC +mj6l/s9DRX9YlH6mGX7BCqcNf/ryHV+qkrik84Ml/6+2k+peqrupmrhq5HLWfzE7N05s6pqxq+au +Grxq8qrRq2avGr5k+m4Kh+Qyt+AlSU05cHxfLUTU+1HqYQrCAtpFuWxrfimm0dqFFbVmkrPLgmU7 +fFyZq3u4AhozgR6sKXEtlF8mPuNF6RnHenZNffTDI4ed3M/+OQyPz+k6TuN/RT13z7jI7fhlHJJQ +Lx37Hw/+j4bJncZ9Jzv/Xy4fT/CvJylzodLNmdLzCc80aknnD63TUbv+BOX6c71dPn39ab982i+f +9sv/NPtlzCAh/NaRYYH7vC3aTrigE/ySU6Au7pdfion3yy/bdeMCoLVebRdXfH/re3m6vJmnOJpC ++PWUevaUevaUevaUevaUevaUevaUevaUevaUevaUZPKUb/Q0FZ6mwtNU+KzUM9xzPympa0GbuH1B +VpggeGyGkR5GzLczHvv6jOQ3/egXGuntspHenJHuPHakIqt6TLqFGdbR1YzoRrVqwlwuQvRfM4tI +61WD2uu6rOWOKUV3Q3kIX4TFFUWcHl+J9z+vdsl5SkG+s5kE3zfO1Q9dA3Jezv+jNfqnB2rxPyYG +cR5UAHnQ0zG2SRlnyRl8bcPHPK2fKKSnB3ytny2ip4dykc5FNGcEfag4R7Dsn5N0/APlOZgJ03DW +/2iZPufFOeJQ5/LOUnt6Ys+qHCqW0/PBWpcPiF/gTFnKRTEquSEg6SqeeKW0kSWX9uEk3S9EOPpc +S5kX9uOucXTo2knnREeyzU/6EY/rFyL8MlGeL/tbAYw3cT75W5/8rU/+1id/65O/9cnf+uRvffK3 +PvlbnzwrT062p6nwNBWepsKX+Vvt1o11M4w6iDiEl25JePCQ0TTcijDehDmeNBpvwvTXuA1HjaaL +Z42SK1u4uHKh/k4OrV6od3JIidDJVd/3U2UsYRh9CcNhxuicsRkzPThl+CAazxadKx+aKTJPJpko +fZpw4t94DV2fH9vZMc4NmBkTTgyaFTon+oygHFp20jVYzTgJgiQ/4hrGFZxhuBcYYi2d387OjZmH +yfmX9pOs4fEylXyx2OtY6HV3+UaVSZb5Q7cnnI/icG+Cu0WF67Lupocutd1ca6vjeumQ4SANpgfF +AQ7zx8XBzpI8RR5MHxEIXiR4oTCKBREMOAOmC4LBiQaZCiK6cc0HGvoTLWsceBxyujDhwn2Lvqzo +MM7TxWHui3S8OKeP8oO3ZEw21P7iHLdo3fXF29KjPN69+CiN+bSR/dsrMsZLMpbhtpH92VYAoz+5 +4X/MfuB2BHcXhrsHY9pk+V7YGYa9Ydwd3P7AEwEPTxzk1MWHpgKoDKgw7GAQCikKCykJBxj9FVZI +AsVgBqXgAEJ7dfLjBNvHjqZQgLecaPJUkBQBd/gjzJUV+BvpWo0DTIMKAx+BDLxCYwdDlGEkF7ox +YwfjlYEhi51JaDAgGQZioSsx9hPdhpFhvS3AbF5nKEqRwQswFxmLbFUJiszUazyZg112Eu8mYx3f +5zkwzfGsbQ4vnB9YkDMKfwN2uboXup/pQw7HtPEvde/S4FqaHulo/ICbcfRLT593ocRF/zR5FqcP +XCfxwGUSH75UdPrAraLjJRLuXtEPXSs6ycUR4jIm/6B3Gld1G8uhjzs67BHomEem4x0rXfGxpws9 +Tqe7ia7l5Ks4M13BuaLvHL3XeLuIuBeepsLTVHiaCk9TwU+Fzyof1ebbZW6fl0UjH/28MlJlvk2x +lS9IG1IMn5g39Fnlsr40wFwu1zYo64fqEZ3HgTfXypBf/ANLa/rI2vKra3uHk19gFhmeXIjmckWi +izeUbSJ4e1t5p0kDwy4cM8aFz6PCY2WiTUx4smBev4lmtZiwHg4+fCxcsww/aXGjscwR/y/0/03y +Y7TvGjeJpJ4WrnkkCmuhe3Q5nsI/rVIGqdC5XLpHd7epibStinSyukhSD4kqI2lVJP7eyyGlSaoh +VbpGZSe1kDQEydWQJC5NF4NrPaQoFZGiFENCqwd1991EsZwd1UHak3HE4clZ6iAluinpqRLSFSoh +Dfbpox0U4p64XEbpM26NdXV0DlOvqGS5Vds7Y89vjJ3PCitZaaVpc1dsvynWl1cafJ+bEktjkaXd +dFZnaay0dNn/KZe7DuWWxJE2OS+oq7m09ahdqsH0sTpMD9Viyr7YwJAF+KGaTK4q0+W6TDATpgvF +mfpVRZfrM/UKTRdqNE1DmSZfqOnSBUaLrxRx4RojeKYLJZv8bUYy9/4zFXACqTGvlaot1ZDWi8gW +Tr6bb0uQlLc1pzaHB3Lorofyy5SctVxUcgD86AszuOSD2iiXLBRKiHko8UbzEtT4uWQCDUbQQ4iK +WVKMbpvQhagGe+qsOsPH4nwfjfI9NmD40ZDhQ4g+Fns8QzUuM9jZ+EKZZQZlgK4Lmg== + + + 51LbsCooUYjySmXS8RUzl+fx1TD+tRe2PVsj4WL+aYjDwvlYbuXF0p4PpVbCGE+DFj3q0eNFjmNC +5Tal0hIqp+H+32JX8K1D9ZTRHgZrmGvknOd/1U3i6dbA2JoYg5ExbbO+HI88rx6dLDi5bMEycGcn +ngDOHkpjuiB1ziVL9nKvY8rk0VImH0qarHIh6g6jLz0bbpsPdzlxcjS8zlgyDSm5dbe9HhrTpBbq +fJEu4yTgzrnM5u0NqZrSzLejBkrpqnTG5SjnW/h0CyYvn6gKTyplgu7KiRYwjSKdZWnApxNxJgEv +Vjq3cgedJbMdOnWEjgSgvgLNe8rYw3S9lei8myiJswC7OIFz6QmcMJGPxzuQbRHkXAWm7EEC4t3J +4S7xyH2Sdv9x5X76oHa/0e0fo9pPH8tGuJyMQJ27btcw5/jhrl0wXT7evenjyRaXuscj94mW2cc6 +OH2qZfax7k2PySU5797G0YdvxA0SVJVWEtXTqS1wEZ0cqNqPaqZzgG7RZrq5LG8s1H0tjHyhXYsL +IQG1CuQEHuLIsLvT3k661g058bikaEJs2Bj4u8R6cWe+FsIv264vevO2hUpHPXc903MjFTdD7fHc +F79N/T7FeTIv/KWq5Q/6CF3RM+cf9Hqv1319DMHHEbwi7Y81dB0Ypu7kQguuS0O3fFa7jzP4WAPF +G7yHbpE05GhOtCqWQ5t9nr2UIJS64IvUBU8W+yiTqOvVaoDvXfr9yXm8Av1NRnF2NDdazvtPVvk/ +JbWvTtdM7PMmgKfRU+np9JR6Wj21d/5UoT9X6Kge6PaUe9qJ+k6hcnGkcUPlhs79hbOAdHXy+VHA +vWXcreamsmOAmyu6O81A9Reekv5i62K+jaAKsX3UCiwC/KG0PBZ5K3habiWpjdY9RjSoXNllYX81 +jF8kTmO4JE4B+oX3bJ6c3Dk7VDW5oGaVypE+oCni9EtPe+3ODvgsqNc8dMBnCLc+5njRlgIf6i2b +82ZEwXQm4JQGpYLPJl5PuF2o9PhI4fYfmTP9mHd/8tunS0Ly/P0bfyaajlyfHQaNViuYdctYRVGv +bK56F+4H1/31UH5m8BcvPc7hS4K/guHLBM9Ft0scqyw+KtGX0nwfleX7qGTRB6y2C+mBj0k4PMuc +ewidD809JjmBUhMelaTy14zO+zRREiZyl+dGN3kjB8NwaF785uc/+BuM2u26DNeaXx3zJy68+UNn +7z/l01+04NLFCEG6ECDQr155OlhyJ6d5ZueqL5IIygmhleLnq5oHPYre65tL6HBTtPzOYue8lS5y +t9BCUXT1/MeJDJ8oi6zIcisWW+fbhlaJrauNwRH2Ay1W3o011n6aNHzH/eSXhSBFg/kryglxfjJJ +Ig7E881EfDcR7+PrJLaK/Je+67VFjS4u0guMeMNnC+wgZ4zH7/S7yZoc3b/9OV147sj7MQQqcdy8 +VhMHXe446HJqGh+t7neULq/SB1aXSFmaPmIW60VeR/I8PlA+weWipcnSZbaJaJF8kpoms62vEx+q +rzNZAlq+WGGHndEXss8eyD3bTeKKv5OjyEGTzyT37CA1yruv/SPZZ9OZDNUENJWkKktVmrI8ZYm6 +I5PtQHL16MdYdddk54dXC6w1S2c5WuLKMujR2fJV2iSLyVRZWSuq5Gtyit7StXNa9UmyUvyx+az5 +Viu57nTidCPgw3mN6lvRqQR/pwtJWNsMxzEHa1uTQyeW5F5NlHrVcxt5XqHr/0T+70ATCqfTjqYS +T6QgE4nvTThS/CLQ9KmTOO/7SWesdqEnnYucc74jqYQ+cT7mfIf+cBjtBiN81ILzfzsn3v/NES4P +PDSBJ9nd1MWljq50tr+N+9qlDe2gl3KM+9ni9jAfv+YF5jevVUxGNht3agTdba4SGG8G8LktY1bL +mM0iBa2mIYNlyFvZ5Kv4G8TG9JQhLWUa8lHG28LG9JMh7WRINxmyTKYxvYRSm9hjNCY4sSGnaU6a +6BRlU1x6utMkGU93knBzdHlP7GbSi+U4+YldTmMKlB4DpUSoaciF0nyoRWeBjMzJ5UUd5S39cKgc +EH06mPy3fzD5arkkl50Z4yh/9jhPLp/zy0caxnp6XEW5D4z1ZrSnz4odfmC8p0dHDz864htLdq3z +gsGw1mAzCXStBuwEcSXXjjh0ZsmhWTCi92BWzpdi+k+XjXO5sCfW9TQr1XlKbJfXLbwXyilO1d2Z +vXmiq41m24t5J7bE7GmTky3Z2KQiaBZ2IktIr6StdBvSKrbdzswzMcImy8aOpPmS7ktzjVVfriW2 +oyD9kSynE6n4M9lPqACjCpzohpyCRXkmSuJAXXhH8/soVcb4RAL2P8iTqGoPKsWoFqNivNJq4fJS +qh7TvckzaclcaYrrTOGJhUxHf7nQlC81deBqZFaPbJEzDJxmkyfKtFmHPBvOtMFlf55nQ5k2o2Ea +zdXOY6fG6UJj9uGTVLlXOZounqFaKTFmdyngsD09JWc8onCyTmavHpB1zrLwtsXhgbNTenBquGM6 +UVbNaLUe7W5pNVuRlR8pC8u5U9Nwbspbrno723E4NRUos7tQhs55khiYrtNgua5ykdZl9x8brx+/ +LutxF2c9eJ3W9JE7tS7esfWh5/z+rQ/du/WI27imC6VrH1PM9sFnerDa7ceeevmZHvrFA9Vy6Rkt +EmWt9l7pUxRqdai5sVjsWM0MS4T/xKulH75cGm2F6TGXSz/+eulDni5cL32FC6Y/84ppOezgC4jc +TReKS/jyEtsCE1Ri4sn2+FuyPR7IkMjAgYiBjoYhsrG0b0mV0g6yKpJY6jfVB1TR66H8T6eTlouR +E4BerDVPCg1v6DtzF14+BC35wBc2c/VAHylV/JFHoPXOzDps5j7nm05BT84R3V3RtKHLlr642zCz +eKVlazfPNB+OPqEwn9jXxamfvfpsd8trMrXmljN3xgOse8uovvMHWbnuUaI1XWh1N1rnO1rxh012 +eaRMZJQOhfKRN7fXorydKJlaXLKSUs1+2YNk1XdWVtKLdlyRUjy17KtFb+2ebxGd2GH7v7ZLljeT +j1XY//Bdv+cX+F44bvfhyvsXjuL5Z3pQr3zo6/jAI75EOcVHvf+Us62P2Xc+LUX8EbvOdL38aTnY +KjWDaN2vdLiiV5YKF6qJHVxpqSrdOS8tRd2ayMjCnvGeyv2zClPUR+5lrzG2vVaWuysXy07Y503F +KX+3LPd+qDslPDhJ1HVzvezEgeAHN14suYTpzy3VtV3eJbHQP6YjJK78/8G97gsRjptug15SpuGK +p1YkEYJ37KY7N96sSkkTfAXAR7SCL8X4RRt0vbQ/1y9NYXy6P+Dp/oCn+wOe7g94uj/g6f6Az1aM +/30RPt0f8HR/wJNT7Klo/NNUeJoKT1Ph3/6+1scXMRzPeX/Sx/7T+cvbxTOFbXOm8GSM3luRvZ1k +V66b8tLFfrpUapr+nYbszs/VsS5ogkGOPqPLgBwGUigJjQBWkzRHnhWkRlkgR9L0ST2a5IQjuwbQ +0stSi4Oz4k/umHilJI29ZS5b3jJRZqprtCovvrqLevs183yWIL56/jULnd3/FY8Csl28o/jpQcL6 +JwntzxYL6NEADfQXSfv8eLD/I8H8j8Xtz2Pzj4nRb0LtLL8/U05fENMkpKcvr5m4Y9NjUyl/dGJm +k38qAVUGHgb/ZTFBGKfBfXk8S2NTmahScXuJAsnGB/yaMIPXTGeilqXloTBb4yOKdkco/IpAH3Md +fjFKFpC5zOPdpfCB0IoXcniSC0vEwQ9YkyKUy+LySzF9mfC8WN+ijfUtrCCoChx2MdzpkRzna/J+ +pvFAxaZM9NbDdKlE9OiWfKBENPoKJvMpbX2T5kka5caFUlHbirQczttdqEW7SHi0188qk5WH2jk/ +4hgrTe7UDkdMd5QFYlFTkaIkPydKI8kU++NUqGbJUBI/HXv0RRLm0qHoCzLmERLmYTVw+rgeqPc9 +7zeJ/2PJ0m3R0kuJOqdthv9YuHTd5PWnIWlnm7azKV86uRz+drhYwJRjVHualXqNUY9WbeNVrMY+ +fBmKxKwmDVoNN6L0O1FYwd3GrS5FrljhlTpHKPe95GfdV6JXm0zjOC9DKAiUkjAeJdfoS9MilGkN +IB4uSr7roOPiQ6igDbJ8rcsmXQQ6COL8xp1yDxi4emjDuB7KDwloAHz9y7dvfv3u1Zv3r9589+yZ +k9v+F9Mvv8ffRP7Nr1+8f//y3RsQ6F/9Pz++ePfyh5vdm+9ev/wWZPkGcLMstynVVf6NN6XcYkRP +/o3Q1R+xu2YL/P4v9N//G378HwD88026+cXNv/z3+eZbgv/+N/DPFue9gwnem+cA27xrgOlnn1/A +h7A39Lpf0VCA5QT6BeWg10psTvMKOw5uh7XQtjjzvMAKrlKxKnIu0O9f4AvgpVjXNd+CoZmYXgHx +v/RK+m27AJGPPT/HhKA/wt+wYgFL2DJXUBlqpTcoLLbbpa1h+PglmH72+QV8+h76HHAqQ0dBitJ7 +FFaW29jAzvOfvwTTzz6/gE/fozTp5z3HarhNrS7CoDbP7RLIv3mLTd9CHyvFD4uC3CDwpy5A3Bhs +MOkLqFs16WfvHchzVrlwCeZnw4hNX0LUwCzRMb13MP5IGz5+CebnwxbfwK3NmCjMD4B+/hLMj8AW +n74HBF2AbQGXWZ4rbNcYQ48g2FhWJ6QXqwdJFoAUXAPpzT/QgptvfsPVRwIsTy4kV9NYAqGLVVS6 +WSGHfZGOn6y4mm9+v+Oaxzd/9jO1z5VLw3ZpMV1YsxtsCPoDS/2auTBtJ6+EZaiSlLgMLXpRiEzo +JZsL1PPt/Lp/YOSH1biBeeIvzVcmFXb5hWrfhYjhj4u8le3IWTQgHYF+pnWYpSJNLs0e5dYlmJcc +W3yd1grKfqT9sS48taBdLsTohnFOFNiasJHZxKFKGrirDiLcLeVLwhQLXW1kroDcqr0g+/9wpYm/ +FcZ+nlYYwiRsMWF6AeYX5CXhftXhp00UZGcf/EHUXhCDCpLPPT/DdM1h3+wHfovwY3xJjl4Q1xd2 +FyY0JbAix1poKa9t1E61BOaqXJW8JyYUB9JRcO9gvC7SuSTewDz1W3xK61ar8JqGxymqywWQx3hJ +R8G3/G46sboJ+qkom5+lr678m/27H3/4k+Ixd0OYfzbNNzv4+/s/Tz/CM2ihl3VQ0kCfJdDNb/MN +SOqElT8X4MIzUAnXW4zkO/DzERzKLV5MSGDFcAnWP/5mQh0UJ/K80NhXPBaGkxQsspWEfy1gJtCB +SNy9EGIF+Bedxw41GhY5EMGhwXRcc0JwvJ0DfAaAa74F20/IiLDkAVbjbZ3n6kj7Bj9fkB6YgATG +hkuDD7fmG/4FGoKhBTiB7N5wqduG/4oN5wwYQ/Ivh+WJO3MZqPS8lh4dpqEt7leA92ZAisxuoKYP +BOgIfDNSCuBcoHNDr7TtX8bu97aOVdoWO+a42mlw/O/UbgfqMP1x+t3Ubn76s5vf/w== + + + E/xEkxpWwTClPzbTCXoD4JswTPlHT/gV1KfbdQXNZA1zwfK8NOfXeY0oJpoDP9+Aw22peSWwR/IA +2JBca+YT9lJAggL2BBtBTkT5ApOLIDGBesXN0rokBmbYUW9GyqDlulacZgyO3D1ECWY6A9EMZyBe +KXpz8eU4oMghaFOUhpSWJPzMt+isRjD8NMMOhcDCk5LbxlgIWG/xuDQD2wJr4UAIYCahT4DBOSza +NiZ5WZ7DDTdccN8mWJmBcP58gx1xXpmAhSbqOrflFngfuO3KDJth9mZooLxJKyPASR2TEBtKKTwj +AAzU1oE7sAfDgl6FvbmGKMC4LEosps4yXgRHZVhsWdqGMAvWNBdFENaiPEfl1hDkagOcg7SFjTcq +glWBYPIrBWuSz6dbjMRJUzQZBNiZAHNegAu6BZiAeQ6GAFa/cBGUriqcwXlTmnAc/kso8m0Ks8yw +FDJzvAAF2rGas3YMwNh1HskWFUFLWYEpZQU2Jax3DBadzfxWA/dhvQ1LkXkEopaRwuQIOjlAYMnn +G8zsIrS2JDxsqBjK+ytOfPm8TC5cF6t9HjOmdMou+vnS+PPwqhCyABsynoF1XXg5zrTgBUFdK855 +BKbGI5NhkcdVgGsqVXi9hmIIYEbqECyNpdgyL/CSKK9LQVAsqH5G7S1xG4FpzkJthAUreBfcF2Q1 +z+vc8ZZ1Fiqo7B4DMfNLGF4qA8Mtxuu1wyUIXgCnJH1bYPEK3gAdTUJvyG0VFAnHhFHkWAVYYtRV +HqKhLePbGC2sUtymOtMYGE0EkswWIKjaQgBLOwbDZiDkzstahIQ26wAveQ2CYEl9JJP2F6WDDgTI +Bm4L0z7lppNReltBikftQi46ELDbp6JTLNQqbSuWcWeOo3AX4Fp1jRWHoEUVNGtkAlbo7SpNsWSn +AEFz1ze1WXsAYOiygFeZNestMC6eIUBjSYCgvBgCIpGXzkriD4Gg7iw6DwIPQmOZ07nNCBqOog4Y +byIETLp0V9hqb6ylUFDhv4YgRttwCoAZWHKtylgDkr+VKTAWAHQOtnBkwBtyU9m1KFFr0k13XXQW +LTNPdcbaeBYBsMtJEokMLG1VZuNmpAgy0KVteXIvsMaT7TaB5BS2BFOwCF9joZmx4CYYVPhhWPag +CPRVibZLAuWgk6UarMtu3ZQQHFvRlRxZxACw9fXCsg9eDexfm6OJEQT0NOviXFhtQWDQ9YLxmpt/ +lrZoB+tOI3hhyYVkE3YVGAhkXW8oafhdEbUwXXHFPp+RGX73QWDfQWtZqiFoc9Q1jydoEAgfC8EU +GVJ5EBhrlVeBMSCfB2RRCQBVm98FP7awZWGGwVyjE4WMAJCVpgsGBT0DSWXn4ZpLEWCah/1LEZSw +Sm9zaqLB4utaFhRk8MrL0EYRDWsxvNU0lkUXB+JddMrKfg8ql2nRph4hcIH5o+qRsbaA3FFFEzOU +pW2dk8kHYW2FIdUpF2x5o08irjrpSknSFk/oKGtYU0YEQTUxDLsLApCcyXa1tMruAWCQWwouWVGo +rozCv0QBNttnAvo6FG+rSRZjxNrxCAQ1t+i0x3LIAgRpuOq+GpS3K1YWyo4wBtakrMkyYCBj51W3 +r6Wu9nlYxMqZWvTzfWtfUlCqarQNtI9NQymo6waYfyNA2NsVwazAsFYDlmwI+hQXNyyDU11qV8cY +toYlOiYysAQd8oSbtaLN85I3QwNtq6oGMMxJgAm2H1WmltUQlEXlRBbdAoAtLgIssCARGLAAuO5U +mGDBCAKemZ+TImCZHsiQK0oW7ykBY2yq8pAerwhSasICUXMRuEZV56p0ISy3ISm/V9Q3GQGAM/MA +VlvgdQNAMFikuzmymEBgDPqqqOsGwJjJJoStjbsQ3F4hKjUCc1KZBrarjAKAU9XNJq8sgbGtmHHZ +tEEELroS8IYqQ0CKCncXHd8CRBuYsQKPBAhiWSkAAWsIWsw6D0QfDdGUavRd5CzA0FJSzqpyAuC4 +6sIj1gsw6gopouAh1qYrpCRVwAEMPwsC6gwCkxPWZLcwsKs8sEOI8EGwKBdAAet3IaMDeuGhXaIB +Yw0KDMqB7DZMCckwOEWVHLSNMbAmNUIai0SEFf18DYa2mMmoPYJNS6XWymIv4JLWCVRNXQqoa6sS +QHOBgbk1oX4uMt1xr9NlXE1uIk0mY414+NhSFIGo4gAMWTXpFY1YpX5ZVWqI1U8IsvY+iXJDCGyy +mWqErq5FB8XmYIHlW3QGqHgopp9n1m4VwRpUIFdUu58rOPLiQNOXlb6A21r1XGDgLCumdE0UoShr ++jpiYAaLRiaG2BgApIgTI01lMQTJFNykXi8E0zbP4CqzuPKgjsNQnZReUWgoXuKzrHrhDW6gNrXZ +xUDAmqy3ulUhGG116gQJXASCKZ/65JyrAHXFyUxiBKvZRDi5RRTA9pOaykixtACYbMXVqipaaM6G +bPOqCPDyTH1ZJYbHmU2WLiMJQaRLOZWCyNTG2RxFtuYQtuhMXIMasfj5pltKQVnDwGALDx1qAqSY +lgyCCnQEF3VyrAuvMQDWHL3sZiB52GSj0oUX0UPQdFfEpS3AJekoRp6zCIzasmHVfkUQi22rvK8D +TF2OMLIlcw8C1fZ3uwR/PoDY0c+rQgsIatYdhYaIgQ33fXnTYp/H04qihYidAMAUFLgWoQp2GXG1 +IdIUDQHmkDkp81zAYIHq7sFbbYQdJUadsZFdqRF3CfUN0EcYLboAdUdpsk8BsOs2pI0yMIuxWzDU +J8sjousxlZEAVJ2CTO7AjioEqrnuN0oEN+tuq4qgmg5TxFgEIObO6STSbSqiqI5KF/o2BWtRaYIZ +pUaB6qcozB0Fi016dkQg1rmqtiFGOAIXpRVPmhqCOuucVadHRPluAlHkDnahqtaai2pcEQhfVbmK +SagtHMdj4VmXJkD1ZOA+qOo4gudoyy4rAphSSoE4IgBIlrJMg6g8APHdZFdlWfFcwEn0zsJeDQaG +VV1iVTz1CDR1mrZOxZvM0MiyucbKAy0aKmtysdINNW7OMQL0vZs+HTS8EattV27lrc6zl8WoAGCI +qgYVs/HP2z5XsM1m8iczMDYVn+LlRmCeNaqQ0bZTvF3z1I0BaShqVFRxdeGrzOFIW7IiCFGZ0yhe +xxTYftXENCMKbEGm/nk8OjtqrhGtMNWzVfUFYHcprWaAYNx4UYdCXVlRR2BMtrXJmANwjar4ZNtt +mrMNm9jdAEw5aVsJBUX0fad6NhlhbyyrX6eCtak7uIkigEDTDkiAGoJlbpsZKvFwkcvNyAoqrLtf +DsC5qU9bx6uZQg5LRJwyAKyz6X5o1ejni20ira5KQLFdmPZGeVNUhdxU79jddST0ZHIC1NQ8kjMG +7nuuEbuanu9Y2N0GNA31ZUTiIEATptgEb9oxUD2DhV09hCBhjlUSKaF2e5qdM6DhjGTg2uaik1t1 +0kQpWTa9W+OOpe5H7DMRgAH5xITx8gBYCk30zDmoY4nAur3SlFG0GmQDMGsNafE6mthFAFQnBdo1 +SiwqCLN2jEUttGxZNwYSjtwwBLM2TB1MGKFWucP+JwCpu66btgBUE0SUZ/14MweF8TWai76wA52B +lLa50YQQLPoJMEspAGDQ9b2gNw6ByXT6wvFFRoAebON2Y+dgEqWdgEmctilbFAxNBdWoE850HWxh +NfZFnSFVGSjMECG/KgfQ8pxtC2PNF4FFbdjEAS8EhkU9Gba4EGoePBvr3hQ7xepwwjVt9ktVZRTA +Kawy34HZ3Ndq6vQA7OZy15kATLazMLZkbRuCAIOMa+XIF4+rxcCwqe2VTQxGAOa62MbRFGlt5oox +EZ0qa/f2rucCdTODU9gQDFtw7rpBY34jUK3mJKsAtq5aFWux1Q3gVZuq4ARgnE2aLrxXIzAtfpdR +BLk0xSt7alpNlBQNHS+pOcZSYJgRYJjFjNskpiVAk4Rz3UJolBSmnJHJ0cxnsUGrujf0QYyKPNvs +LOaPx7y1Yl4m1M8IQcay7KpeqeGfg8XgCjujGeh6iyuFEQBYrBokLETuWY7oa9MREz8TtG0mI3Jl +GZExOLgo3qqhOURQ1LiM4nzKaCokFUg1KBB0StUQ1RsAUHIyimrBCm3GCEjSCS5xJQBWtLx6DxSB +qqmFHXSCQLw6hc1BBpJWJ4JHbWYEi6btuJgsXgcUsK0CsN4Bjd8jlJzVwu+mH6dRHjuQzN0qHjFF +0FcubVjPBazhyb5IsbPmKyqi6SOti7r+u+ceX9c0GCtZxvK6YuE5kWmIV2NAEk3GjxeNtazo+D88 +/HFM6VA1LHGohRrOZtymThXFc7gHrG1QV02eiRGZE+fDMnBRr1bOtqcW9bpnzLHQqWnTLeGBEfNk +xE5/M6di0ZmRLRunO/Yyhr6U0r4pEgHVjFsW/9h2jrq6xKrK2cmCZCpMRj1N9ds4GwKdghopwnbL +oksz6o7w0MfxCJi8SiLsOVv8qfgRQBtChbQq3Rn3r3VxtDIwLEoWuU4ZQbGgZ7HABWJdTZCIAw8R +OBYuHcFSm+6KEi0DYKmzCRL9PCgrSkCfA8WUIDRc2buLwL66xRoCYI6qdAfb1zN2RwXcIv6kXC0k +VG7l45XzRvrE5I+Ts1MlhuZ/AFRp0iWAlq5u9Bo7A2B0TsJmKDXHomjmGQKbzOosIUEEJRUsS9E5 +sXZ09F9zrRV2+DMwJJ0NNGr64tZU7ygSv3UvVmdX9npA98kMH49R3wQCUUZCPSpIU9DZ3CMHCE4q +6VEcPBdo19I1+pExNSNLr9SQR6C9qwdlELxoTmMVvxYCk7JFRc9qQXmU6ZoYkNEKVjtl7bslKA1J +x85k8sr7tIw8+8WgJcxQBaLNpHhbKbovNNWboDUlGggXZbtonGgw6D2I13a7xVz1AAZhq0tyZhdS +xgCl9bcYYZReKT1TBQXAVVL5CttVDCxL3/CywNQ/UFy0AtGaAZCT61i3TNQnT++KGy0vo2lZDNiE +rjI7NU1zDgAYVx10CW1RwygDWfznQ9F+VXHJAzBF3VrUskKk5uJNasGU2U06Dc4h0qZKIkVOGJhN +KPQJjghsyqh/ssxOfZaU0qUsHIvnrobSKXA2e9HAPrSeixm3JckMLT7FTlU3xIyJY7znKb0LZ2it +7EnU7QXbVvWUB3EK4TkCy9CLnI6IwBQt48CmOOJd1fXQSlAEOMQyuiKxAVhNdJnNVoL5hNyIBafi +kLeVgepXG6ZMd5UXVkMZWLIKhJLnJEANhgEBQc12bGtDRj5JeVnWVd5k0yuYRadWa3eTEAKTVJJ6 +UkD9rTq8usahJUUIVjMsFMEaF913Futu6V5eSQREspI5Hiyii21L2rgJsO2ifmb1n+OrzKtPQEYQ +nTNVE1oA2NOjK9udCFvULdb6LADwbNpbXJTfLRZzp7DljW/KajmjCNLPp8U+3zh4WXwmo4bHCmr1 +pjdYtALAmv5TOLoswKSbmKSdEEzFbI/lIdpFN1pyyj8XcC4qqekkgYI1Nbawh0tQSA== + + + DJn5nyy2Jon2/KZkabm4LSlGzF3WDUTtKsTY1A5lFaWgVaSaX7CcTfi48kR3cHx9aE5rkXevuv2R +z9JICqoNaoo+UiSOr8K5iIK0maGztt6nYM4EE9v4smpOGo6/l8ThS14Bmm+OYHXoFMtPLZKnOa6A +5NZKT00pmTs+7Molm3tednsGlqpMLeY9Q/DSdx6OTBVUuoyHqyJdi45fMC25ZD6fMsr47IInSTxa +2FdZFhjd0Ww5aqsu7yKuH2gLer45UDvQAgw9IFLEbmNwWLOxS+M/omYjbG3S0EkhzJW1JHDJLyrZ +VOKe1Fay7dJybkJ7oIpgT/1CBD2FQdx/CEyawuCkUGbOMTjOOl49T0yzVUpxGhQlJTACnDwWvV9F +ZBVO1ZTtcNaRadnsQkuRKjhMTQmTxF+sYmDRQZvIoNdnZWzfzarbpskCYqDz2VfZS6rbdboHFMAa +iSycfMbAsNgWty6KoLvEsrnEEMGq81BDUthWcrS6vYrAZq4cFEmKoEdzsyStILVr24ry6rzgJLSN +gqy+q6Xo59Xb2FMCELhomJ9Cvfz5laPYq3d6lGppoz0ZFVvaQgiWFVHQg5htHsrG1y0HS0EszfJz +JFbIn0ennk6CKBGOOvNaHZQqAKaimRLdD11nF4/WhjnqKlj6p2vSfJdZt9KKrj/LRxaHA36+6DJU +Gxxb2nKJpptXr0GSgOJzX4vTqeLCAg6AQLXlI/PyBmBpFotWzx02rVXTtO3YBja2TKB5Vaw9dVkD +1Ags2i/yMyjanjg1i4wG4Jo16bWJSoYtk2Z/r011n4r525rjWyRAUTHComdvKCmdgRpylvRxRhDs +rJNQ+1zAPfOMjjojMHLaIrdlmxJgKZkKbdIQwVHPkZE/6bmA+zwkx4mBLSVZTgAhcE2WQy/ZTACE +0dWuJZ20FRMAlWXRkuoAvGQ9mZTFswnAbCfBRKIiuYse2lj1gBmhtdwpTcetwTnVNMUWgKDHK4J5 +6QhUUuPWX+OGjf0sBpIqWQmJT6soAs2Pwc2QJSJSIFEhzPYWdmHGix6yI6tYx1cTLpO6apAA2YAS +O5cFWBZr2Fr/vJ0moeCFzI5chYCAuWoM1Lh7cv6jiscvNbudVFaZjIumkJP3Q2eonlO003gEzgp2 +L+tnxvQ4Ci6GWYfbUYBnoPRlmlcBQD1flvi4hMgUGQI7qQQNl7kkN7UYCCMoNBVJ7kcZsehZjJ6x +im3tjCDZtAIsum4pi1OElMTVsOUSu0wMUYdbdmCUc8mOAaQuKLOeGwzmMSP5m4Ib2ucCDpLMm7pM +9ECd3bAnNEkHSF5narYJJ5N0ZbXc/AFIWyQDu8qDkTFdimRqP9c9UHJZYzc/cWPVsxvqRwXgYoKD +QnOqyDg+pGCqq6j/kQUsA3NT3lIWo2qDuelxKU3wQetjMQSt29q1rEqrRqDQ0swq/wIWcHpupqqu +RsMbeLbw8Kjy3DO4E+d6K96+8jS2BsDOXdmF0LMgu7CchFGHhbrJk4Xh0A0isRromGpYs+kckfU2 +c/FIJlDETMtmrhg6nExgSSJB11dlgRA1AQNdepIaKDxUj1qwl2liCPoEZz2eRuGZZ+xUzCon+7EF +co1GxSt5tgCE1S7zSLOK0WG7FO2XJT6hy1e8PtFcV+i+lnNoOPZV/cWUSyFYLWiZTfGIbGc+47hM +ykWZ2CzgJ+7vyImtFhwU3TWyps5exWAZJ5FDqM84QippQ5En8DOKuzYJIESydjSYOovmEtm5oVFe +NUWj5VhiQHhNUZkQFC0IXUVrvjOMKWflI4Ven1H0uU8a1fQwTj3rEkkWGAGwZi5hBJQ3YgSKCzJq +KBKj8qUIv7pYpySCIODYJL2mmp4nZ7CfSWJCkL5SDoLmK+i5mshxy+cCpq5LfyWGj8BV8KpdkCTC +zkCLOWHOhCh1kb2Gzyhpo6+bIgsXMznkkFrsAY4kB1r582JJpmRu3NDTGGDo5BCs5KtqKgutTEYr +EQUA1qAELOIgB2CRg46w/dc5GoJlVgQaIqTEmxZ1ekmCUDDDIHISBCMIZpugJ5AluEv8GRHMyWaX +yjnKMdJZT0GAB7FitrKOImW9MYLZDqUHk/YA7BuLzg7KitN1FyzVrFroNpp+ECV/Q3jIuXaoMOo6 +MK0h9kMiUjfguYCTnLwOlgAQo/mLI5dHYGBKRRD0LMZopmy0A4ixlzag49MCo9Hg95txiEnUSZfH +LCc9MIe76iyiCMYzStemgkYyh1TOIrjp4lg0gXixtL7Iu7sAa626ao2vPQ89cmrUM8puVw9un5uY +dC9pDZENUUYwg9zRNUORPwaCfiJADQkj0IYwW/ob4s2Kty5yeqPZGabIeZ4MLFE3fMuBCHiUbTUo +uwYRmPo0lgNAzUK3ADR9Lqx24DT2syqVjzswuyTBBs/VdKpsrwrJLftkx4L0IDLmrPFOg0eVik6i +bEUMQrLz8Lj+eWNFYAjaA9Fz3RGo6JwUAW3Npm1l8wCgHhEELUSmUUhuDPrZVjxvJcGI2E8nJcv8 +jf24DqopKngp0s0IomV1RQ1v4smurDuwZnuHaEVK4q2dsUeoRBJEXeBTNT1oEDnq9oxO3akFFE3X +B6Am0rtVjyc1q64OSkN/xmd+JTAuytszOh+tEcDgTmLhwXM5BwVgiQRgoQHJIQwWwZv7UebAhzwI +AQ6+1ASIdqSSNEDlYQhJqyro4d7IJ6wVQZhNxLFdQtujTcNkVRmCpPhGpznTAm5SjkfyULHYQ9Op +pSYBAiWjLLiDF1jHovJmHyw2O8+WHRI0ZR8rdOgpqtATxRGsGm7QAwYEFKevKVGEYDVhqnsX1QgR +Uz6wM+K5ghMbjIHjHwoOs46D1OhA4JyV3spJjwjU6EHoCjWWRKEUNwKLGoNlYdaQdF9mfZpK40ju +VujHLOY2W1QssqnKtXXUMRXUFYt1eChGKbyVTQVr/qiLIGrmBlYHgoknzKlaHajXWhIZwQiiRUzN +Qr9QdegfqRwR1ikKznkQghRJSqyqcPu5qFOiJT2BTvJHWkYtBNETZRBcFjXzi1VKCmsQA1FX9DkF +XCkJzclWLDMahei9grOdGJEMdfL/WnKykIbArIkxcw+yVsbGYHVLd/9tT+RCYNFkwtlSNEo/r17M +EVUoHUWzxptayZseaNeKmRFIGZUyFnDVcIwRUVx+RJAEc4wDBM05iLNF7M/wPpcXJscK8kzeC7ha +Om/NGpKpWVOH6ATTMwkUhaJA3TlKMr2u2Bksiulo+Erz3M4JOBhlapQVrQbKYNViLAsS/QCWzhsr +75QlcTXZlZOL1JfLgSkNM2gQM1mNl0Kn3i6+XwmDTWXVhF4agXsFL0pYnTXHICSNmFpwb7EsRoqY +qsXfI5mWk7HwUY+Vc3uSpihsXi90DekqmYlCGFg5ApvN4m+zAUVpxiSa3DOSVYdA74Alq2TNUGp8 +qIKJVZO/n/LHBCl1fW+okmlHZwfVw0wy7l7AudlRClQ49JhgL61AHoLnl5EI9jBbYa/MOtS9gFW0 +93OcWIfActAkeRNhy4WjsDNrUbLqRaX0h1Y1nHdOgIzREt25OlLM7xXcrHYEjLGUcxA/z8r+bu33 +OZLnVBPwyyoBIvimfH41QJH+GESgwnURk27m4sDPBzB0k90qz/Xz5xD30TdEDxUArKi/YOlWlIlY +pzmslIyLI4nXweAPbV7oxpIFJg6Vd418XwlXAAS9ruDv4ZWSX30vel1bAoGxDBLpNKsc8lpasDGn +MDWKfywESfb4N6JkrInt1lnXCuoIoLhaWZEgKoLG3kAHL1lVmmChPvFhaqG8WJtwQ3YVKlOX1F8k +dVhISRGRt7D8VbrmmWXLbJnfM74MdRewBHv5KIoCNQTKMZlviC8LHn8jvmDG5qplfrgm0bJGC4Qv +UQ49LStqk1ZKBgMY7WzQlyy18rC1hhEX1ENwB0O8qGneXBywb2RB4akwXJNIccL0jHsBx7UFB36+ +AUe2YoRmnFB46yfWZlS9ec1rc0BmJbAFry7zbVFhi5GmdMfqgUKBanHwwnVDmAcHrpgmZfyaEgby +KJ8RRkAdItg809jWMcewXuCYFKDE14VVGE8+JFrHDWuSoaq/rBSq5dmDDgYGYhKu1JDDEoKFaJhZ +vn4jqwpUVOKEHAOSoZe6FcEOgmHlqNWCW5bevqBLq6pnMlixG3RoFlHJ9fwJFuqSAaq2j1IoIq/K +nLgwYTNGd3DXx2kN3OA1BDM8x8TdJZZymcRKWWbIGnLr8WyIsrBo/va1HXELw6kOgk6B7JHChjQ6 +ahNwUSxqi94tXvALhgsbgymxX4pVhlWWEIiccnNxyHBZ/DgtN7vvZezmWGUSkkl4vwFjCKaVGy2l +SMTgiPeafInKZRiQOZekSNvQFg9nxzxg9UChgBF08MIOzwHrilpH2lCgQJVpQm1v6/tlWC/wAHn0 +k6//bvfu/fHVN+9fvX3z4t1fbn4OoJ/+t5/d/N1X79+9evPdzU+/+tOL71/uX7+ketN/+u1fvn/5 +s5v/AxvtH2z0D0du8n/CX9xHv5+oJi16U7EAEWhaVB4dFFQqV7tQVNkVHA9a0DvxPoW0g3JdWbKQ +NXu/AVv2yjybsKjmWQLmhaJCnoA6fJw8MrSl+iBlRNph8n4dPQXjvBWR0JHOfFhvJECAjKATa219 +rwzrBQ7g6NHp3EIVfuGHmQrJg1ETqAj6EjMo78hX3PFZPyiB7ptMXCjdmMvZdIiatMr7DVjKmDDB +vIsjx+g0HncOdqvqgMrdObEYdG0xgyusG6wdKBQwgg5eLKfUYZ35fMJIgQCVvUqttfX9MqwXeCDs +DXhtE9ZWBjVWr5TgK2/A3I3E1ah3DUVKQsfqqnQ3nXEXFF/BTFVX7jdgrLtkjiOuF4tTr9oO00qO +HfaN+K1A5VvHllIScUTZgfJ6Za2CA5dgG5HO7Eoe3y9AZa2Sam19pwzrBQYIa2esYI3XC6x4VxDd +l5AjXTMC5kcl9TXalQ54OQJCslNf2UdVZd5kMZ48VLIkmV6wcXVVa1FVWV8dqMwNZY6btrisw7LB +2oFMQBcrDA0cFBiRznxKeyRAgMpcJdba+m4Z1nMOMG/B7GxLpesy5kBXYYDW3SJd8wKKPVkEGDpd +El2WkDJf8oU2QmctmFaCOOKh1fsNOFkkFwsKF1IVmtRD4a6VwjumALlr6OXUeW9tcc2FuMHagUKB +Do6CA5+yGbEueCBxS4EAlblKrbX1/TKsF3gg3MXEIZSwsZG6hdZVw7wOupMi0t1kyV9CVljuGmfx +bkTGGjBJ7n4DltLYTCuXG6VJJ4kGqHOKxSJA5Wyqcdm0jVLEb8DagUKBTXsBB3ZDjlgXLmA2UiBA +5axSa219vwzrBR4IZxc6+0eyJVaqYA86z1qHW354mrprP6pdnSJbaqmNUeMVwmwIDWCt/ISO+rSK +mRelON6MNabUMiGgslfsdd8WE2TU4jGsHkgUKAIFh9tooQZFuvQASidAgMpdJda17Q== + + + 3epIzzjAzM3rWukCtiUvgaTDDNrpyNsgsqCi24AuWbIrdEQuZX1b09L8Hhwtc35GlWQRsa8VbGZZ +cR2oBkhZa960xTjvvG6wdqBQYINjYM3ucFiDBpodAQxT1iqtvaXvq6E8YwCydmENN6fAusL5dT+d +wXo1Ub9bix0zxuCSFH9ti/FXoRg7n5W+VXwv8VZOsWBZ9uJhZt6JjeFb8p0OA8oO5LfrxztUAxUO +Z593/e0MU94qnX6G9m4aym3fv9A82T3OPPmdePcW9e7BP99ORa4V+fFq3rbBh/iMYrqgqIvsIdPx +fgMuPXyLZy1Yj10tA9bKMhqQ+G1ZAL4t1s2LZYPVAZOzaR04cPrliBUvHKlbCgTIFHRqXdveL4f1 +jAckqb7cYKSqhIlJk3zE+w04cLI/VXBkax+zaZsVt5zj6oDaMU7sH9qi5zI1j7JD5N386Q4unEc6 +oqy36MfYvF6AOrJKam/retSxnvf+WsYi57PM0jkKS95vwAF9V1peE3DIRqYVX6Bz8NLmgMrbsuZl +0zbJYfkBawcKBcpeBfeKaw5rtROzjgIBMoJObW/r+uXquJ3x4ErGIuXlZPPRWBTSgVGJCMrdRHlQ +yDHQ0XTqLCl6oHIX3WmbthjbbHmDtQOFAuWugnvlToe1WLknR4EAlbtKrWvb++WwnvHgWvYiEkEu +1pWdKDJ3HVSOkTCw+5xryMpdLqxqQOVuizp3rW2WAwoD1g5kAvTzCu2VyR3SYjcpOQIEqMxVYl3b +3i2HdcuBK9mLnCW2qCaMtQnvN+DAOSLPpPCvGmatylItcqGUAblrVEJq2bTFs6Jx2WDtQKFAmavg +ZEUXHdZsSU6OAgEygk6ta9v75bCe8eAK9iK9v64yZDVqKoQDB07LZWBcFEjbJ/dLnPYKVM4uIhtd +WzyNqkDD2oFCgXJWwXgJw6z1qhVrtuMvjgIBKmeVWte298thPePB1exFlFeUw0buKUzgv9+AAyez +cD9a1HmX5MQoVugOOsUJqOyNy3zeds51OcOqQKHAZr6AYZeRI8IOKx7aCVsKBKgIlFrXtvfLYT3j +wbUsRrz/r6kTh4qM3J+B9UoNBKaq5kfvG2yU1QG1bynq8Li2ParpsHYgUWDDY2DLvuxYU1dCOgXJ +Kyyd2qFt75fDuuHBdY1G3Clak9GjEwD3Z2BXY34x3wSOrbCiqKFd1V1BNzfOy7ZlDSGcoexAer1+ +voP1bIVDOsx/fb8ATT6Zv8Ta+k4Z1jMGfMN5IP8Osa0PmY5syPybWI8xW2TDW48OXDi/4BkXi6bz +Uj7KhWWHW/RhMmI61oalLCXfNokzf8DqgN56dOBgcWeHVc5ujRQIkM3PTq1r2/sVfCXxDQ9EUfwi +w5FuIdKECdwA7zdgTEYoWpqbT0Igs1yZ6c5BAipjuWKUb4ulbVfeFztWBxQKGEEHB02rc0gXO6Li +CBCg8lWJdW17twzpOQeuZzyiAlXEz08FUe434EyeHya3UaUg5Jcd/QAFS3I+BMhda1hmMo1t8URN +CW1A6mDyfh0bBVv+s0e6WMKfI0CAylsl1rXtvXJYzzhwLdMRq8+noIZbUbu8Q/FSksSrqXLqK007 +q6G9yvk0Aypv+dY+3xbXc1LeKlYHZAJMoCTlrR5sckjBYFrl0olOgACZgE6sa9u75bBuOXA1uzEW +zTnBW03z0pmr4NxPF1U+qMprejXm8jlBAypz+Tzw0LbJyZYBawcKBYpAwcEXaVeswc5EOwoEqNxV +al3b3i+H9YwH1zId8YYDCd5Hzu6934DxrkB2/uAFBVFNBk22o9sFBiD3bcVtN27a0uUs6wZrBwoF +NvdnZU5r+i5FGjhyNRIQXEDNEeva9m51pGccuIbhiFJpnjXkhaeG7jfg5C9z4AtSadJJJjNez9DC +4oDKVz4VOLTFSovKV8PagUKBIuhgLdnssGK8pawbCgSojFVqXVvfXcN6xoOrGY64dHrQap51M+vg +ZFfN4gUadDCE80lnZW+t6icmoHKHbwwZ2sLGU5S9hrUDhQJF0MGa3Omw0vGmtKFAgMpepXZo27tr +WM94cC3Dka4cCbIkss1dDzUlpmpiJlIWs4phvn7VgNq1KlkYQ1uu+bTB2oF57azpUL2loePE2hwG +1PcLUD+vtA5te6/WC7Bs8/YK5iKSm5uao8U0BQ/WUzTYCzqktBn0nGY/E2zWhDmdteXr4zZYO3Bc +1QbWqk0D1trCGQG1ddZ2WnvL3imHcsMANhc/Zsz9W9hxdFBf50O34xy4l37Hwv5rEZNNq4UlulWs +OSAxI2NV0NrGthnd/KrLuYLyCvR2nAN3Dcth7ckgjgKfDOKodW17v9wx9zMeXMGOA6RrVVcOFhK6 +30DdrRUrbhcS+LFbM/CE9BodUPk6h9TGthn9p0sYsTogE6BsVWjQ69ocTsto9u8XIHO10+ra9l4Z +0rP+X82Iw2svFh2uiHW17jfgft8o1sfITeax1g2iGxvS6oDMmlmuMPZt82I7VMfqgEKBjk3fzaiI +14h14RoHIwUCVOYqta5t71fHes6Da5lxeFdILupWnJsxV6GY2hmFtyElPU6wsLczUY2j6IDKW1Wu +eltczUGjb4LUwfj1Jk0EGq0OkMMZ7C48934BKmeVVte2d6pjPev/1Yw4vFml6ZhRsdf7DThzQQ6m +N0aNyOldjdA3KufSgcrbJeVNWwDSydsBqwMKBYpAwdFuZnFYg10l4CgQoHJXqXVte7861nMeXMuI +w6o3MauBqsrwAKVSsExuWjRSL8Vu6cqXHDuMO9bkTKxrSdNOvX6KcgCaIuygeJDfyg4pzuD3MH19 +8HtYp9S17X1yWLfdv4YBR8Jeh5DORd5vwP3kOFUt0hxczTmGboFKWB1Q2UrHUrZt6Q6iEWsHCgWK +oIP1UhCHNVhxcEeBAJWxSq1r67trWM94cDUDDpfNogNZ8Qqx+w04mcqKBFPhIATqKUEAtrAGB1Tu +hFKWTdtmOqvD2gZFVl21A9ivfcEa+ubUKQjjRqbUDm17dw3rGQ+uZcAhDVS3htP+Q5+8DjxXvUaK +iy6SsRON5WtQpwgBtW+tapjf2ja8lytusA5As24HsBa5HLCu/SasTsFqka2BWte298th3fDgalYc +li5rOnAwWn3ydjCVNBVgsQhdH/kqmmgc95Kyzudt+RLqDdYOJAoMgYGlEP2AdK3l7P0I0093Ul1L +61PHuOn+f5wNl0FErWty9sv9BizX4j3jyoHSv2q1abB2oQXo+tlArImYW920je7ItWJ1QG/DObCU +SxuxLlwCcKRAgLyBdmp7W9evjvWcB1ew4fBanHURH0qy+iYOnC32j7eshJ6L1vQyEa6RYUDmyyJl +ooa2ePx2TiNWBxQKdGQUbFWHHNLQmd0JCP2AvCc2eBZqtwzpOQeuZsblHiZMfDrvfgPOrjJmbEWs +h6TlN7BK67w6oPKWj/QPbYMdiDakDpbcoUEHjv0egY40WLUxR4AAjbdt29b1qmM958C1jDgs71ma +GjHZOKvAzBcJM7WpWATYrsuBUW0dpozlave+JZYVDhuUDkgvV7YqsOtWDiXmZEu5mP52ASpbldDe +1nWpY912/moGHF7mZAdzqOze/QacudTpM7ncqGlIWe9XQCm+LA6onOVCVUNbqtPYRqwOKBQoAgVb +FVCHFGu5WJFaJUCAylsltrd13TKk5xy4lvmGt1xZshlJpPszsATRc3MGc7T9A6afgzFf8PCixvW1 +5SIXWzuMA6xLSQeOVtTd4Qx85+T4egEaX1sJY1vXpY71vPvXsN+oerBl+65zr0XUz+RlubsD7/Mq +cdH5Nitbl7okB1S+UnHese2ClUPiiNUBhQLlbAdr8TKHtZdsdRSEXvDBU9vbDt1VrOc8uJr9lrsX +L/K9qvcbMPrmmpKhtm2xe77mdVk6TFmbLGeyt6RiygNCB5SX6+c7mC5PHZH2ap3u/QJUzqphrS2H +firO885fy3DDsaUSloR51gOUI7harSs6rsejmxa7Lq6pZt/P6JXZJZlqW5SISaWcYh2Bs2YkDmB1 +EA9YS27hjAICGm+NWte298vczmc8uJrhhjXDoh7Ip/Du/RlYq2Yi0PYAN/I9pE1A7VyLmgTp25ZW +z7B2YI87D2C77ddjNVnZ39+6qO2UWrveI4dv0/vH2G3Lv10iZUFfizNb7gdg1pp/dCfBKs523sns +jhQBER+q3s3m2m0wjUaSQTA8ylcCOhxYKX/ZvIxh/MlOlbU02jvCbR+vdcgO8BZLdaBLm+834Gwp +Y0jqmkXRTanptRKlRQ/kbuHNexrEsLaRSyWOWDtQKNBRUHAP6DuswS6hdRQI0Bgr1Pa2rl8d6zkP +rmahFVwrOnDRjtQ4MN54JHekYBGOqCUrkl37URYrj5PUe4tXnMxqFVtbqZA6Yu1AoUDZq+BoV1w5 +rEEvJHUEMEyZq7RaS9epjvKcAdcy0PCGEKvvFvSctYNmPOGnN4yo76pfgo53pyQHUr6mWWM+1hKP +4NewwdmBya3mDo3DLTOzmmN0z7N/vYCMravl8kpL16WO86z3VzPRKs5uVUJJLN+fgZsEcuosl4Dz +gi56mVQqsTmgspaKV4xtg23nDqsHEgWKoG/9SY6ROazBCuU6CgSo3FVqXdveL4f1jAfXMtIqSWc1 +/zDx+/4MbDT0sLldQrRg3YrggMKaTbPAZU89Og+iF9uEb+pVyWIj6wSe9f6q/lYBGj+FQte298Qh +POv1NWwzvA0uaCGbuahtNoDd3sX3a9NEk2sRsV+LWnFWY5I26qaBImsb8O6QLVYPJAqUqQruKpvD +2q+ScBQIUDmr1Lq2vV8O6xkPrmab4QZao2a0rqoaOHDq97QBwVLtKFmOB944hTKsA5W9MOjnbdeW +8wZrBwoFiqCD/VVYghWrC6awoUCAxt5y1tZ317Ce8eBaJhoJI3UVU8rB/Qac+saOtRWrMSfq1KG6 +Vh2ozIGNvZ21zU3LDTnVQoHR5UIMYDGfHdLIOY0jAQJU5iqxrq3vrSI948B1z9QNo4wpmfdn0CZX +3dAtbOa9SlF3ke5dIKDyZ2lrPWvb67MYVg9cY+dvh1Jl3BHpMKW7e4GAxmDzqbmJ2rtlWLcc+OIz +dY8syPIhU/B3/271WYB5sALW7Qk7D7ZKKnNtFvO0mitzxSxVVtNcfZa50s2666ZtdFU8DGt0VTzM +XPRgq6TisVrNFU+Bq8/iqe1tXb861nMeXMl0nCtGXCz6o/VZPJiLqWDHVsltspor2DGNwLv6LNix +HMaW6yKlpA2hg7jqLB5sdVQ6Qqu34l/tarN4Ml3b3huH86znVyvkWfFOHLWGrTaLB1sVlbnS5fWS +XyrHl7Fz8M0XYVG+Rtkze9t1lmsqPVYHdLVZPNiqqHisVm/FU+Bqs3hqXdveL4f1jAfXKuQJQ5yD +HS/T2iwebFVUkN4ya1lfqbeCfeObWIfaLMiHUMeWq48TKU4HdJVZPNhqqHScVmvFvw== + + + 3dVl8ZS6tr1PDudZ/69Wx7Ni1W/Nk9G6LB5qFVQQ2NZVE6C51grgxOP+zQGVs5pD2duus9Zad1gd +sNdl8VCroOKRWq0VT4Cry+KJdW17txzWLQeuVcez4h0cq+oR6kTyYKugglOErxJytVawa1ph1NVl +QTbMYdOyuXp7htM7zawqiwdb/ZSO0+qs+Le7miyeUte298nhPOv/NWp44vtnNfytJosHW/UUBFYL +TkqdFeyXZlS7miwIVuvEtQVBmbWCnmHtQFeTxYOteorHama+p8B5Azy1rm3vl8N6xoNrWY+0C3Qj +TWuyeLBVhKAZknTWSZ0VBOoBY1eTBcG1blo2VwjZcDZfNFkrsniw1U7pOK3Gin+7q8fiKXVtq7Nd +DedZ/69kORJpVtLW6rGMYKmcgkCQ4770igDX5ou0aN+Kpau7tmVt7QxrB1o9lhEslVM81tSVlE5B +8kpKp3Zo2/vlsG54cFXbkabJqjVWrB7LCJbiKUiL3HzQtMoKzahFoxdaj4X6F7btetlVh7ADrRrL +CJa6KR3lsJr03a4WiydzXCVrv+6j5DPg/xK1WGYMU9gS7paiA1vVlLmsVtnb6qvAyrAJ6WqxzHjD +15zypm2U+5EHrB3oLUUHtqopHqvVV/EUuFosnlrXtjkpbFjPePDl+Z+IVO7/aK4Wiwdb1RQktd/w +IPVVsFudg1aLZaZL2bS+prXFm6nVsDesHehqsXiwlk3xSK2+iifA1WLxxLq2vVsd6RkHrmYsFsxB +Ve+C1WLxYC2bguQucpbZ6qvMdOveEhyQu5ZxNW3bgsHQr5IQpB3marF4cL+L0iG1+iqeAFeLxRPr +2vZeOaxnHLiWqViav2pFTlh7qFVNQXLnHH3ZFe4aXxI91GJBNmidN9cW1nPUGI5h7cBei8VD7fSt +R2r1VTwBrhaLJ9a17d1yWLccuJqtCDRUy56zWiwebFVTZrxeMpWxFgv2rWU9N2m1WJAPoC+lTdss +t8YPWDvQ1WLxYKua4rFafRVPgavF4ql1bXu/HNYzHlzLXATMSW77cLVYPNiqpiC9q5z1tPoqCJzr +sq3Fgl1WY8G1zXjndthg7UBXi8WDtWyKR2r1VTwBrhaLJ9a17d3qSM84cA2DEaVStXKDWovFg61q +CpJa5ZYuq6+CwGVdfdEV5WtJ6v2xtgWMZgtiKtYOdLVYRrBUTfFYrb6Kp8DVYvHUura+u4b1jAdX +MxhxdK32q9Vi8eB+Y2DB+9Bmc8DatIUhDA6o3GlS+961Lew1H7F2oKvFMoJjsLaKNbJFOVIgQGWv +Uju07d01rGc8uJbRiDTMZmjY3PXQloPKhByilcZWwlLoBxL6goyLBsp7yxB1MjqUHZht3npoWLJO +UcWphRD82xmmH1c6fcveIYdy7Pu1EkGJ2GD3WxTTEjxYDopSJ8xM1JsVsQ+xFQe0GZM1j9O1rdlO +7HasHTiuaANL0ZQRK1dXGQnQOiwjrb1l75RDuWHAf9gZvhnPAiU9WdFtOAe2iilzhh2mqakhtVVg +SeEdvB5IzMjRzjO6thhhUz3OsHagt+EcuGtXDmu/aMdR4OqweGpd294vh/WMB1ew4fAEm1yR1+uw +eKhVTCFKZw3ySG0V7FWWA+SuDsucUe/R2Jy1DXYlqMPagb0Oi4fa+nc4+82S7v2uDoun1bXtvepI +t/2/mgGX8e70qHuT1mHxYKuYMmcsUDmLcitJ7ti1Eu1mOa3DgmzoEW5rG213clij3zS1DosHW8UU +j9Vqq3gKXB0WT61r2/vlsJ7x4FomHGCuQStKaB0WD9WSKUitZqlabRXsWY0a+bE6LMgFVaxc2+iq +oyvSDut1WDzUKqZ4nFZbxb/f1WHxtLq2vVMO67b/VzPgAHNaVUWwOiwebBVTkN6aVOuV2irYN70B +ztVhQT60qGNjbeEVTY9KGdYOdHVYPNgqpnisVlvFU+DqsHhqXdveL4f1jAfXMuAAs1ba6XVYRqgU +TUFySwl6+8asvG1JbQ+tw4JQCk0MLZNlkTiUHmhKsINaxRSPM/g9TF8f/B7WKXVte58c1m33r2G8 +kbDXTECrw+LBVjEFSc1VPQZ6S2PGyrRaOcjqsNDeEtRnYW3xR7sLUbF2oKvDMoLl/K3HarVVPAWu +Doun1rX13TWsZzy4mvGGy6Zo0qDVYRnB0MtV+tGL8UvaMAIXqUCXeooxrdJFY6HWNjud1bDmQZFV +N+0AFsvWIY3mXnQEROeKdMQObXu3FOkZB65luuEAB5U+VoXFg4E1S1Vhq9dOoT80BgGGrGcwgiYi +Uo9nS7PXthlL/q0brB3oqrCMYDrbMWKNfXvqFMRxK1Nqh7a9uw7rhgdXs+GQtlVTfK0KywiWeikI +1OKJse8OxQqKx3Enia2dt+3lrBzWDrQqLCOYa6aMSFcb8/5+rcIyktpb9j51jJvu/8dZcKngmU+f +LXm/AVu9FFC4YRFrdUyprALCzYXmrArLnIIpo64tKP1gsW6wdqC34BzY6qV4rFZZxVPgqrB4al3b +3i+H9YwHV7DgUrFC+K4KiwdbvRQktebZssnYzQDdSrl5IHcr4u3q27Z4kbeWJjOsHeiqsHiwFkzx +SENnSyfAVWHxxAbPQu1WR3rGgasZcakHCF0VFg/WgilIbul3e3BlFexaTi06oPI2LXqHvbXF4zoa +2lOkHeaqsHiw1UvxSK2yiifAVWHxxLq2vVcO6xkHrmXCAea06I29ah47oJVMIWol6Ki1VbBjJWrp +UjMyUrRLfHtLvHxao5uGsgOtCosHds3KobTKKv7trgqLJ9S17V1yWDedv5r5ljAVV2+wsCosHmz1 +UpDcnDXqI5VVsGv9KkGrwoJs0GviXVu6HbpusHagq8LiwVowxSO1yiqeAFeFxRPr2vZudaRnHLiW +8QaY537Lg1ZhGcESPk/ZmcvR9o/V7lOLtn0AkTmuY0s8/JHriNHDnJTsYKuX4nFaZRX/eleFxVPq +2vYuOaxn3b+G9Ybbp1xc4aqweLDVSyFaF60PLZVVsF9tXn25FeVrP+5rbaNl/DqsHeiqsIxgqZfi +sVplFU+Bq8LiqXVtfXcN6xkPrma9pe7Dc1VYRnCV1OeER8v1TrHCRxOpc03jBUWPMZIETDWftQUF +Zt1g9UArxeLB6AqoiqBYDqZaDY6C5CwMR61r2/vlsJ7x4Fr2Gw5xUsvSirF4MFCxqrBVZRx9oVHJ +7XX5CKi8WZttutoWs1LNfBOkHeZKsYxg0HRs/Te7fXyty4YAASpvu+Xg2vbOGtYzDlzNekMikpa1 +tlIsI1jOyhJw6bEyjgSn7CLaVoqFwEnP3vm2s1pfDmsHWimWESyVBEasrZy9v3V52ym1dr1HDt+m +9/+xpVjm2N0t3oJzYC2iMkfUOocyK3OMdhrayrHMERX7oWwLTAxLUO3oOsxbbg5sxVQ8Sq254t/d +q7N4IntL71IylGcdv9Yxu4iX3wbNX9QKLR5stVSQ3NQ0L0qqrlDP5PS+q9CCTNAz+a4tnvRXbc+w +dqCr0OLBVkvFY7WqK54CV6HFU+va9n45rGc8uJr1FrPzNluFFg+2WipEsOWiyTFq7FwqWgDHKrQg +I1JVi9naLqhhLhusHegqtHiwlVPxWLXuiiegV2jxtPaW2bnbDeUZA65lvMW8KZFyv4FaNRWkVv1a +VncFO9alhtVoQR6UqmcGre1yXvfFA5Nb08t5PRWP1CqveAJclRZPrGubzyu/nHPgaiZcxFRlPYVu +VVpGsNRTIXp7CX4JDsZuE7gqLciHtWqFU2sbnFpiWD3QqrR4sNVT8Vit8oqnwFVp8dS6tr1fDusZ +D65lxAHm1Q5LWZWWEWw09KC6nrWK5KP2pVu4Z9FtW9YWV6eqccatDrJSLR5slVU8TqvB4t/v6rV4 +Wl3b3ieH9az/17DiACvoGNt6LSPY7WQhr2O9FuyXVlBz9VoQHOqmXgtNOVw3I1YPtHotHtz1OofV +arB4Cly9Fk+ta9v75bCe8eBqVhzqKrP6OaxeiwdbZRUieNEESs0FiahY6qUUVq+F9hdLoHRt9Y54 +h7UDXb2WEayVERxWq8HiKXD1Wjy1rq3vrmE948G1rDgSS5YqqfVaPDj1bR59SkG3VK7Bgn1rlkJp +9Vpora56x5Rrm1atK+QVjVWrCvWciQHMpVU8UqvB4glw9Vo8sa6t760iPePAdc/cDaOs9VpGqFRW +IZq7n4trsFD/zAVg9VpoTpn26tqCAVA2WD3QwqQDVCqreKTDlHZekMXZEP1cuJuovVuGdcuBv8p6 +Le4Y3peO+lnBFrwFSY04mov3G3Bm/wEAcbucq9aekLuZ5/j/s/euy5Eb15roE/Ad6o8i7B0bNPIC +ILH1S6Rsj8+hLYdlzyjixEQHxWZLHPHSw2bb1n76s75vZQIJoEgC1U2yil1SSCwsIO8rV657dj6B +EYglMEbOO1O64bemRe4OO6g1B8YeHB8ouD84CD4ZgbucL8YI425DtDama0QGHSOQuME4tdSx+G0Z +kEggeawmhMmAWcfWzNiJ4Ax64SH54EUwGmR4lWZCBdqAe0GFu9KB2BSaIWDGlCvQqi9UQPJ+vaiu +bJEwjvWCX7AxK1IJsyWliFBpmnoddHSSDxidXnRRIkuLjTle6GulMxGwObu0SOpUASNX0yQ/Rqe6 +QrwPFYeMu7RSYDj8DC2GYEujpF+BdYVcSVb6kgQuhuYgTwyA3HvHsQK9ocCWOJqFEzohGLd4YeVs +aTuOWCM1opKZ2kKMrOxcnMAhpUSkpUuXK8ospJzaMl91q8Cocte5tRq5G1wfwgmEioZmWYeoaMNC +RutSQAYgwzRU00U/JjZgbFb5Fllf9vwqji3aVgRMH1n91mgSygA6r6IUOEYVhQQRhQ2MxLXt7DCh +lbPVE3+Z36XzUNSbfcuyC5essvSDZR0jT7BodbzhTMZbUd+IhXC1JtMSZKxsE1dSzuq0MeG0YOKi +ebiUJnwua89FqyMmCscUFGeSHlh+tibJ+B4kKe3J1vqUZLZVvWbbpfwJuPhcGXUEz1qKNaHWlDVn +cVZhJ9S1TfkA2lKTQehUl8p8Y/5N2mHEguP1q3XCg6DtSPJX3/wpvPn99duj248ffhZyfnd+ew1g +BeCbv9xc/1Vo/p2Q/aJQ8NH5TxfX+YuDv7zHG1Pqq+//5x//cHEp1Rz8rvsp58zvfvjzyV9u3p7j +5+AAuvfF16vf/Pvq8lpeFdKt24sfP96df8BRI2fY7enoi7OfLy7f3p5f471d/e5P13f9O/zvLp5k +vym/koPsH9cXZwJM51n+4T9PLz/ql/9++MPr0yt+h06wV9s6jl9nj+PXFxiH7OfZI/nXxdu7n2eP +Jn691SP6+fzip5/vZg8pff7sY7r58f+cn90d3Xy8fiv9O7p5ZG/0A3zH/S+f3n2YPcpBmWcf6jd/ +evPN5fufT9+YuWO8eJvxxveMCd/854webwuZvPt4++NH4fDPzufOghaducSpnecmmg== + + + IqzPHc+Ppx/O/3B7/n8/yiTMJ6GjUs8+wuub7+8u7s4eoZL9KD/w679fXJ7P35+DMs8+Qjt3aNcf +r747uzv954KR5UWefWDYcnPHdnv+4ePl/HMjfT6HAt3TdfNA19dTv+wQOP97Tk4e7uwD8/7MC3Jx +PXc5bt6f357e3dzOXpC+wLOj2fc3H2/Pzv94e/r+54uz2UfcI1ORn3TXW753Lq4fISGDwdgX3DXH +N1fvbz5c3M3ZNE/RAfJhj7b9u2/P362+3kt72zGOvbS3vSPaS3trRrkl0p7/kqW9d7enwvZe/uXm +4sMrk/dmC/F7cW87xb3Z+3Iv7u3Fvb24NxnVXtzbi3tfjLhX2Nci8C0ZyZaLfP7ViXwLRrQrIp/I +QUfn/zy//P7n07c3//qybV96ZFIsfC0H5o+XHx/hVj4Ds7mtksGHu7ffnv/z4hQdWiD15IVejCf4 +4+nHDx8uTq+PdAF3hZeevTZv5x/Db1/iHJ4/kPmn8NuXOIaXUIBtp2Y37959OL87eg6a9kLb/juO +cIc2/CX4FngJnt1c3tz+179+VjFmJn3+9XK+KjF+vd9AnzCWD+/Pz777+Mh+2D2OYLZvz4ePt+9O +z86/PztdgniDQs8vdcwenCzux8vT2+Ob6w93p9fz121a8AWsaUtH+ft/v7+5Pt9glH3BXZJNiqos +Z8/Rlqs4TLlgLNut5CjskrH89+yx/PcL8iB/vbm4vjuJ6ouX0Eeefx+36klkLnaIH3qdxoSFfMO2 +s0EbKXoWWxO2e412TTJaYiTZFmJwentx9/PV+d18A9wuEYXZx94vjyhTsuHg0y0eyCO8eD4Qs82i +wi9u/kDcVg9kPlX+5SWI8qu0wi/mBrb96Ly8uPvr6cVjsuQXfnbujqy8XE28eMe90EL++fz2p3PM +5A4xQUs312tci6frwN5laGOF2levRJ22wCtlu5Vpxuw9hrbfY+jLChI5vrm5PLo9P//v2VbN1+gZ +9fbi8nS+XXeXlBjmcHZc+e3p24uP81E3fb4b2s3tljjnD+Tt/IG83eaB7JqI+eeb2/c/31ze/PTr +Dokme7K2Q2Tt1RCz+REsW07MXm0Y204Ss+L1uKy+mp2+LJxim7f67JHs2l7fOY/b1xuzP5tl2cfs +3zfGl43Zn+2Hu2sx+wsI+bYfSbM32dYfSfMlnB07knYyi8IjHiUZWVvmfP9CXvdf5I7fekeNH2dj +2dZTr9kj2ZUgnL/NNqce/3x6fX1++f355fnZEn3atODzW4RmW1o3HeS04IudQ99efHh/eXp2fnV+ +fffn0/c7dBhdnUpVsw2TOyEdrdK/q8lPM/g5d9T8NZ//Tp9vMaXc+pN4Wa7BbT69Zo9k13jvY4Qx +/zmRj12hdwswa9v3yGwdwtbvkdkj2RUOb34k8vMkXtmW3fdukX/Qu4vLyyX+T5fbvNLvbm+u5g+G +Hz+/VvIRJiczjD3mMZ5bxj6+SMzV7LH8iDu55uvG9evnN+pf/uv019ljEsp3d3q7iFLq99urCb+7 +mS953LzAQG7PKQLOHc7p27cXdxf/nC9O9QVewB5zPX9cZ2cfrz4+7i2Ujywr8gIRTdfnp7PDX85O +L8/+fPN2/tj6As8ffDabt8hWLzX/Fw5h7gIOS72QSHJ6fXF1+mKpYXc1D10R9s4wWybZnb0aZ5j5 +I9k17cfeGWZb1L37CwsnOoVd84aZn9Ns19xhFpDybT+UXo07zPyR7NqhtJPuMLP5z91wh/kid/zW +u8OcvRp3mPkj2RVjyd4dZu8Osy2H0RfgDmO+FHeYBTR/20/iV+MOM38ku8Z776Y7zALM2vY98mrc +YeaPZFc4vG1zh9lq+8/uePMs2HJLiccLreEuZg1c4Ae4X4UnW4Wny7mxA4vwdB14ocZ3P2njN396 +8y1z9rxZpvmaxRDtzhH1evMWzVcD7kjWoudJAP5S1HRJnpw9RXuYotV7ivYaKdrsZd1TtD1FeyUU +7fe3AviyWbRzTMFrpGd7Dm1Pz75MevZFM2ivlp7t+bM9PfvS6Flu1HmzzAr/ysja7MF/QTa8/baZ +s22aL3nbzB78ftt84dvmy7ot6K8X/z6//Ovl6a9vlgU7bqPDTlWuqtnekzrzf1vgQJmV2CXKd3t+ +dfNYeoMdy/UyP6fIPj/KPj/KZ0K6lfnalitTyf/Llfz3tfyWv1/Li9Vrc9m+uH57/u7i+mK+gev2 +/P356d23C7ZbVuLZx7fPEaPj2rEcMR/eI0vM3NHtUo6YmdzIl5YgZlt4qFd4QeGPSy4b33JP/SVj +2RVf/b3CYnvJwWN7ezftSosowpZTtw1NSlsfPn9z9f7mg7Dl3318hITtcgBfHOMOEYTT24u7n6/O +7+bj2i4Rhtk6tV8eMU5lw8GnWzyQR5Sh+UDMSygjZg/kEeenfCBuqwcynzT/siuUeTcO0YVSzy4d +oa82K+JnOUN3x8Sx0ZrujAPRPgBwb07ePXPysjSF26hV2puT183K3py8Nyc/43heqzmZxAUGZVt+ +vYjQ7E3IexPy3oS8v2ZkMrK9CXlNd7dHRbw3Ie9NyHsT8ufXTuyoCfk1GVvfXrx793H+bSbbTgoW +DmdXqMHs9HQfPt6+E872+2Vp/geFtteOpNO/bGyDMs8+tF/PLy9v/jV3fJcXP/18J++LM+TBnT3E +cbHtXcC4O49vrkV0v56/7ybl9kq3F1W67e+4fXw0e6XbU5DSr3+6PT+//lo4sPOvL67fXvx08/U/ +L24uz+++vj1/+/XN7en1T7O32l4bt9fG7bVxe23cmpHN58P2KrmX4apMmG11Of3vi6uPd49c/Zgv +Sfr+2RGvnj2m80t5WKTyyUq8mL7n2wvy7yfYXy/lEfOtyhIncY/vEMq/JrXTh/fnZ3Jw3T6HL/yz +S0evWlkzm0SlJV4s7U8LbvMaxs7+/t/vhdfbYJR9wRdgvB/R5j6Bamqvt9nrbfZ6my9IbxO1NKq3 +iUocqm/2epu93mavt9nrbfZ6m73eZsf1NpdRofEqXCj2SqinV0J9H4W/HdRCvc78GRvoo7ZdxfYq +I4CfU2/4QvRpn0Nj24jDq8mhMT9jw5bn0Ji/IlueQ2P+QLY8h8bz3AOy3d7E2398Xl7c/fX04jEr +xf7s3J+d+7Nz44Fs+dm5zz+1bWfnUqq87cfmRsL0rhyd+7xTnzb323LsLl7Pfc6pJR14ocb3Oad2 +K+fU9z+fvr3511PcX7Q7lOgLzy6wK36ds5Oi7SPyn30Lzb5Y8+0j5DR3a/v3CyDZ/IH8On8gv245 +Bdh2anbz7t2H8ztsidvzt4vo9K7JAN9xpF+GALD5qr5GSWBbVuV13ye+F812WTQrTPXVXJScz2e8 +BJuxZCTzGY2X4DOML2eP5F8Xbxe4E8avn39Ebv6Ifj5/3PMwG1L6/Pk5qC9RqfEEWbR3h7vaKzV2 +QqlR75UaW8sKh9ei1Jg/kL1SYwfE371SY3uP3b1SYxsp+V6psVdqbKtS4wsTze5OFzhavkbB7N3t +6dnd6eVfbi7mOzZr4ZlrnFp6bv/Mw9k5W348/XD+h9vz//vx/PpsPsc5KvUCMenf313cnT2iwMol +Nnz994vLBbkSBmWeX/M128f2+uPVd4LF/1wwtLzIs4/s7Om8zJ57JMu0Wlsc5zx/JE8o8GzLqfD6 +kh0tOA/e3d5czR8OP3724bym1E2vNdVReTj71pa7m/n81M0LDGWfu2gwuH3uon3uoidWLc+XSb60 +1EVPojT6+8fbHz9eymTvkh7xdeZeWSBSbLlw9DwpV15Iz7skPmyval3LH371OrzH5o9jy33Hylfn +O7ZgRHvfsTWjfHEDRc+XvHkk/P51mynucv7sFRkpyr2V4ma3rRSzvZl2zUiBLbcFKvG9uPe6xb0l +aLYX+PYC317g2wt8e4FvL/C9foFvtmjwGgW+1+uXNjunw17i206Jb/YC7iW+vcS3l/g+Cc32Et9e +4tthia8wr0XmWzKSLZf6qlcn9S0Y0V7qWzPKF5f6/tfNzdufbk/nn/evUeR7lXdGLIoR3/IQideY +8WK2MLfPePHsBGGfxvOhgewzXnwih5HyQLwK2rzP37G1ZOzdpXB3egnxf/14eXr2y9crBd28Pz27 +uPv1vxbohD/c/Xo5X8cdv35+F+4lFy5v+85aNJhd20x/ACLu0F56nRrRZftlJ87VzXIObfutPx+Y +yvH4NZG3L4dx2MXbAF8Tw730+swt3zgLh7MrCpHZXicfPt6+Oz07//7sdAlHOij0/JryZau1bGyD +Ms8+tH/9vCA6/xJafXlfzOA8shGOi23v+sXNeXxz/eHu9LGrFHOtyrjcLinQjZu9eU//++Lq4wLT +Vvf9sy85ce7VZBmqZ+e0Or+Uh0XK5qzEi/FY315w35xEI+NLeA1IH7iHTyKx2nN7u3Lr655F2iUW +KS3w4jN2WvAF/OSXjvL3/35/c32+wSj7gl8IS7jnl16eX9qzS3t2aW4fvo+Eagf5pddpDdiAc9p2 +ZvB53KS3f532KvNnSCd6e3H389X5grzuu0QcZh+IvzziU5ANB59ur5zxyyNf5gMxW70ij2TwyQfi +tnog8ynzLy9BmF+lI/FS69nWH5+XF3d/Pb14TKLen537s3N/dm48kC0/O+czAVt+ds4fyJafnUup +8rYfmxsJ0/uj8xUcnbujh97f0riNvNCTU8IdWIun68AOIcJrTUW0Tz47GuXupSJ6vVfkbWQx2G5W +9O+Lc1jvGt+2k0mWrk6lqtnpJXaBsJtVGf9d96uDzB0yf80nG+nzHdhf204x/ihFPzzuPLa7BIOR +VH9OG3BXKMYrPJueNf5rW7Mv7FN8PH+CtFeT46OYLUxte5KPZ1FEPfOYvvtiolx3Lj3G63TiW8y6 +vd4dtP32FNgbMLK/v+IEyLvojrDJumz7PsrHNDuscVdYbXM4PzZqz2zvz6TPsJd+eHd++4eL221Q +kWzLOt+d/jh/jXdBoWlXs+0cHPv/XKaxHJR5uVRcH6/P/rZD1OTVYdlhsypXXwae/XGPZy+IZ+ZL +IWdHL+ViQmEHUdd/vz29/vBuxi0S24Pvr1Mfsgmrtu3s54ZxJrugDdGhbQlfvdeHxJWh59w3l5db +sCbbMiWbIeveV3NJB16o8UXXP331zZ9M+eb312+7a6AAqgB585eb679KFUxTUij46Pyni+v8xcFf +3rMOr6++//Xqx5vLg98cnb796XxlVsXqrxfXv/z24KP8W66+O+gdan74VR7+H/nxfwT0r5Vf/Xn1 +//3vcvVWoD/87aA8LMuyDStbHTbV6uqgMIelN3UVAYWV95WpV9YfVpVrAGhd3cp7d+jaulmdHRTu +MBhvV9YeuhJl/GHtrVRpDm0TpEh1WDsjLwRQGu9RpDoMNnj5pjxsayPf1NJsVTUEuArPtqlDm56l +SHNoQtXa7otwaH3wrNV5V6+KFkVKA0DjAntmSnzUoGvGWGnGSJ8q6YIAfNt6AcgAfQ== + + + 23QAFJJxNKEZfFN7DFkArrIEhKapdcTOsJCT6So9G5fpxHMbHPvvSiPrY/yhxUSbcBgqHZGAvGnN +yjSHlcEkCKB2Vb0y9aGxHg1V6IoUwt+2ZSG8k+Hqt6gYpS0B3gR0Fy1U7YotSmEpxF7YaqW9kkLa +TQ9Ag+EXHIq1Kw5NJ09ATVsRVNrG8BtbybBlVmvbaiWuaVac+JZDwprLmjSHbVvVqLaUT2RE9WHd +EDeIA86vgBO29qlM04QV0calvjR+BbxyJQoB14BAWPnSsRDxUZZA8BOLXQBfvQwa6Fua7rnkx/q7 +6F/G0kVfPDZR5G3EfhR9R2JXi76vcTxEckH3ONscdJGPGtNS9PMSp67I5y5Ob9HNb1yAIl8BrlKR +L1NcyqJfy7jaRbfcCSWKDCcS3hQ94kTUKnrcIv618UcbItbWzpv4uU8VYJ5YJSaDzWCe2LAuMztj +TepeiB0OTcLGqt9YOlBn43bk7ivy7ccNWkx2cZFvY271Kv8qUoOiIwecfRP3Q6QZpCuVJ0wJi1Ke +wJ4PiFPRU6dEv7pvEoUrOhJHMlinPaB0EHhkfEQsWReimkxdnAGsChDSd7sgKKoI2lp2AIjMNZD2 +BZUV76tVIuvx8eyAqN+2CYAKPGY8VUCyzq3RtUKyzipjV9BZ56q+txiRawYjkmHLTnH9sDExDb/R +icHctUDhbu4wvcH10ysLIOTQpgXwpC8h4YkLaAZLWZluKYVIYbWbtNogmTLECliWAFJIxhE42/03 +dWXaiFq+UerXhoR/KEO6Xvc4SjT2/SZLdD3uMbZDuu4HpLl2tel3GLZTKLt9BbzT3eTS5nOr0f6s +9OSoTL6JtRNxo+uRK520iRYYPaGw6TiyGifIkKpU/MZWwUS6o+c0NwO3RxVYCASsThSs5LnWcOmV +xunZjnXvCTuxBJuSxFKGpngUkdwZpzxEwvHKsBDxMRLmtl4NSXezysh6TvFdZFAiZgtlVoLu9cxo +vA7cgSixdSmY+BN2T8j14GiSZ05v4+p4enkOUsh4zePNN3rYy/IRQStvtA1Bw6BHZFjpXHs9Qutm +NT1lxwfx+KSeHubj837MECSa3ZPsMVsx5jumrMmYexlxN0qmm4z/GbNIYx5qymaNOTElznVk1Wqd +0zbiIvpEuty0kd8Dj2FC3TGMICsBy5+oCumO6d6TLlnbMZwkXVXOkybqlohbIn+J+iUK2RPIREQT +DU00dkiC9el4xGmfHBz9eJA83Y9+FkHkN/+4htDwdvXT7enbi3ORSoxvfyvVyNqYgL+t4LmTz92h +bxwwIHOcN6ujnw58dVjWQoIAKNJDEUwtC4yNHWTVZYmFHhxdHbyT5o+ORFz4j4/oW1MaoVDlYQjW +yTwBIsthdBhYZHlVyUuPnpiqlqUqcdo30pEfTuPoGmXEIEjIPFtBSxcB0i6XAweOo0Ah+G6sHjhW +fskMucO6rFo9/U0NhjAeLZU0JpXUIeg50jQWMyoTGRqjHEVj5KytQdCCniR18LUeNq5/PpbDxjqg +WQcKh860To9g4Q2BeE4Gpy0LzrdSSHDTWZ6EMgyZKJw2rgSDjv0OGoTDxvXPxzxrXO3zL6q60qPG +tCDvMgHAfwDKULOMO6ysnnvCFdRKE2odny1rbsOWnCF2KjiuY+xtQ15INrMcYUoWSpxpsttLdF/o +gPS95lljsZDHB+lVoR/7lRbWo8VgZ7OBWplK2S/oHTsBrpbdqihnsZsF+11y85eBXCbGhoYEwvPV +kGFp+YWQdT1qass6qhL0HrNeWafttGBUAjZw4I72qA0njch73NFNg0qIEg6rSiQRiiZHjRCTkrKo +YFCFo0ZwyvM4ECyj/Nr4UhuKmFgAN+uaO9OjZaCuCU2VACU+jj+7VyxsVl1Z1I/zKaI1x25q+bLr +ARHZrLouEo9X2SAwUFmEbJyt0AvMg2C+TpX3q2ymOJsknbWwlqs425xs33bLwdVwrU5TQiwhApza +hFdc0YRW/aJnWKV4QczximVyIBCncIT0uMU37apDPyKoVRRzdYfDbMtXivZEc/bGm1XcBl1n0X3r +V9k+wV5yxDfT1txKzulz2oy+Dat+L2K3lh0Au9nUPEhIPtKE9vsdNIHKh0gSQDRsyx4KUulhI6fN +qicrpDx6YBIC0iQIvkqUCasMKtMTLxC3RNsS4Yt0L+FQTxkT9Uwo2xFX0taO9vLp+GCAwJXid1ea +vKw0YGV9FWnRQDHoQhM3km5ydpGbLSpk4ggKDNLrEcxBQgiyru3nJQpKdTZRBefS2/6b8WQrKWhs +th7FeMmK0ZIWkzUvRkhRjJGmmOJVMcK8YoyZxRR5izF+F+MNoHTXmmyPFONtVIz3WTHdisV4txbj +7VwMdrzVQkOawE9AiUkzvEmnnJKVmoSLcljb1KtEgQtSJtdTpmJCu/SYbnrqVuTkz7PljEIqAS5y +Ilop65CIbBmi9JoIcJFT5/g2Fi+68rGJIm8j9qPoOxK7WvR91eEU+XjikIt8zJyVop+WOHVFPndx +fot+gvMzMC1Bf0y6Nk5fdpaaqj/zu+O2Q4nsTO7wpugRJ6JW0eNWxL8iR0CZOp6y/Dxqhozs1YiK +VdQe1eWA29DOeDPsXpXxLN22KvJ9FfdekW8+5yJksIGLbAfHPd5/AyrQ+MiGYeETqch4tY6edAxd +R3KKCV3KGMOOePVfJfrW8ZdEkCaqKhIVBBaFMuNUFdM6LhbI6FoI8j09V4y1pmeHFa29iezyiJ0+ +PviDSAjf5lx2DWW9tCAsQ81HabYxLqlJQkV8rtukqbWQIkm0RYhyEVaq5l2kicgAj2YnQki2cRzY +7CusRtXqOJvxEjYdEVYczL5prFXyUIeI8LphdJ8kmgophI35GhMvkLJpVNtdqhJQ5oUKN/6o67gb +hB+y8fNgYgWVVhBs5NgrE1LDcfcJDqvmFXOier2G2N1AQ5k0v5VvdU4b28RNKwhideY99RiV8q5Y +l+B7QCJg+N2/i8X70rGNvInYkb4fsatdT+Nw8tHEMXdDTtPSzUqau3zq8E51AnF+UbriYRiXwHU8 +fLdOcTW5mFY3P9d7jBIZRkSsSV8kvJogX4Z7xNDG9d8kHE4onPA8Q3NMahVYr+4FTLsI0CtbZ/wS +2e7+xbgQ6oXE29crLQcTlQQllZtN1XdelRA267sq/I1ChKiOhj+Zn9EEDibYxFUerMF4mcbrOF3q +MTaM0WWKUSOcI06GDiWnWMvpk0EnxB4hfrYnxvsllex2FCuvQ77tYvPd1hxu3mY13OBW+zMkAhM6 +wdlp6pyYpInU3ePsKs10R5RYvx9QLq5XPPR1wbCeznUEULXSTUYjgRG17b8AxjRVRnw7HUaHVMQ6 +niwRlLAy0fSEtxndT6jdHQ4J7Yt8QxTcEYPHk4N3B//xj4N/UFn1w9uDevWb365++F9TwFdvzOqb +9/KnlIPqqzfdKl/1D+NlHqxyhkJnKDLCshEOjpCUJUaIPEb08VZAmcl2GW+n0YZjGXQhaI9CzR5S +A44ONxOagRJjunIPLcKnOZ2aErExoWOJUQeKUf8mhJuFpuR9cgCsma7pUTI5bNatzPTUmhxrazBg +zQE5PkETjunnk8N3ej6PT3EtOD3tJwzBmGtIHRxxF1MOZMKnpOkf8zNTnmfMGWlJXd2iW960/EVa +/wnXx3JT7jBnHgdbnpspIw8T2jGhLyiBfnTSlPQDHTWxn3U9pZZx+41o6oTqjikzi41nebIQ40OA +QxofFOODZHzWRKIyOpHGR1aOg9fQ439zjdgvoYjwxBGKCHccyjDQ5omc0ng50a9UZHbo/GEV1IDf +wm8Afg+1g2kDAAecqITMm2hFF1kM5pL6sBGpNvAbKRKgfKh0Z5nSVyLOt6V30RvB2BJqrtZXTkU3 +A9NaC/ViqaKmgRQlRxEkkCge0miimjGRcUQW9hBLGkis1ASo2IhhheDUoFPCciAzVZVYYBigKkt/ +IFe30DK3h97wuTUwDMrhJwMMFXEWu8rgE1XPV5SRWcZZJX2mqehfkaagwBxU0P/JFGAiizQLnISa +gnmcBRiyKMrJGCurKioMichQYQMCUKlmiQM61jJBuVpbVuycmhdo3XLQAlWQcMn2NjQJiTjdKiJC +6rOqINUvWli9IWX7qCUyvqzVdEZNG8XzgDlAUaf+GC03BaqHBwQb5HZjDyjTS59EFsY3prVql/YO +sy+chitVnBX8VjVo5aMbgwixjjqgxirSkOtshY+oGq2kbKuGVrdINqShGvjfyOpiAgEwSRlKlUAC +0AmgVRVCBMnetekbC08aYHRZ1xHFraO7QU2PGO4CbCwZa7L6K27I1jGRHtpo0RfUrqLIKe0AQR1a +VhLe1PDQyUibO2wbFXfwnalJrdJ3qMtHzRVRr8gbdKVVbxvplW+VPaO4jm5zzlK/gakiDNl8bMVk +AiDDtKbup6hYM48FDLRlrFy/kvWw1CpgPbg3W+6GuK/L6FlWwrypSx1JiVDIKq596SKety6Sa1Ak +lef0bJFSLjnaaOvUbiuiNwNMLIboWoeI7E5ZCNtGq5Iqh/DDaxeB7cHEr6M/UbZ3vE+taLOgVCgm +XWlj1+pWR+19UIgJbTQQVnHTlXLcJzlaYbKoMKdyjFSGgyKoXjCSTlIN63xsDtapjrwOaE+iv6TR +RU6kIyEvOkqeaH3REft0IBTpRFAPMHpLERcTDnsqh1wi3sBhISBl1FvwffY61oAK6ug0NTh3zmB3 +Xmdsbn6LZgwIg4X5uG4OLXR2hr4sbmpshldBzZPRQ2SBU1wtaNMq4nsT1PQs7cu+Wsmp7A6NbL4f +riCBOmqFvJy4AUu/rmTTws+hWcGNSnBXdubR2aaNHs1t1MuO87LQQfYBtXfSZjSU/0PO9999c3s3 +8BmHtKMexHDvXZ3BZ//j9dvVh59P35+vrugY/Z/y1dfy34Ed+uSOpKc1LIKymIuZBHCJS9kEZYOX +MgrKyS5mFShDLWYWpNQm7IIU24BhoAC6mGWIpRYyDdLD5WyDFNqEcWCxxawDF2w58/DVm43Yh6/e +bMRAQM5ezkLI0DZkIgT5N2UjKOdvwkhIwc1YCeoJNmImsMc3YidQcAOGQottwFKg4EZMBQpuxFZE +3cEGjIU2uZy10HKbMBd6wCxhL1Rvs5zBgBj8qUdlFKNXMlt1VDeurZIft+kM7UJsNDjm3nAZmdLV +d7en1z+dLw+YkQNJEN7Rp8EKdWXMDM5F6Om8OkKd0Hjp64qeVbJyLUEBk0kvG/49ocGKb9PXJxrY +gL2e6jxRwz9M0Noy67K1HEE18gF07xmVoF1L1ZTq9J7qSa0VWXOpM0Xeq/i6yDsfq+n6d5JmQhGc +HTyRKeq6dnKQutN18ORgWE2JLgxbQ8XaldQlAKYdXzO+NdOQT1N6nb2NdfRVxC70zcQu8E/VZr3V +LuVD6icmzUs/LUXnRdnPzgSRZrmE2gCX0LIVHgNOmrahM325wi600NaO2XTXwnVXAQ== + + + RXoAj9yCMDr4hMJneeoRKue2cEIlLPdg0EohDAZew9K6EZYNr4JvwNmV8OELgU6jwijKyOEQSkyA +aVl2iJAqPa15EJTAMnUu0LOAxxfmTVgFVWSS5J4cSB8DHK+BLvSC5QIYmuDB0NORFuo8kjGh9UHO +KQU1ZE5A/qHj5EoKB6UnDX+cUFnT1KoQbORwUFCoqY6NlRInhKlQto8tE3HYmyL1j9ilx0QcxMkB +x2V5sOtI+RFHX6T5IIZyjsrsdf821TGogu10zaS+9F3RialWfX85KhtW2aDivGQj57Ss+CdU2Rym +WeonOk1Svxg6R9mCsVdsO3a0X1M6r3gy4XHd03h75ChXaV5ODorB6wjR6WAVvtLN1DUD6UEgg64Q +dYpJd4vpkIrpuDuU6VGnSG/7CSxSHf0sFwl3+qVQTBYk7dermKxpMV33YoocRY47xRrcKtagYDFF +1GINOhdrsL5YszmKNXuoWLPViuGOjN0bbNxu9rPt3eQLWfRIVUxJRZHwKiMoxRq6k9Glk+RVI6AG +57iHw1Cln1dtW8eDL4rMIonCU0E7WXPMjVotdKp1DtMPncNoydHvdapbT0YzVqsrwsa65gHrj3a+ +y1/FfmQ1pIb6dlIv8t7oy7zPsYbUqZN+BuADVXIOZSvqWd69iDOTl9Z5mbQw6IVSIryzbd/T1HY/ +mumQbXeAj+dpzXROJ33N0gwW0LbZaIp+MtZgg2JK/3dD03iTzOKToQpsMiG0dw1njaqQ0dRSRh/O +v4Ami/TVm+lSomMcj7D8UwxQAXCEKWqJHDe3Bu/UaDxET0gWEyxWYWoyH2krZK+L4fspDmRtFnmj +azChH0cxHMh022eTUwznroiTt/b1GszqlipDwH5JB71bN461I147Od3cXWcSVRWm1kl3CKVMSWGm +jcEBCOpt02HAIGUnEqspbaTxdA6tEBdYKh0zatiVN8aaTr4xPOzUoqoHRmMtgsZVF3cCj03VAVqg +coNzEG6q1CV66mE6hUUDBY1nuGSLQNkYkEjrbRndVgOF284ZE9Gk+EE3IPavQAehRFN+H/0r+g4a +hE1BWIeSs6YwB9Ozxudb1WyRf1KjO34gOuPkIL2kpRqBXiQqZc1A7FgpGKSaGr1uak4OUnd0Ahv0 +C7NKjWuaZjBJlbetBvpwMYT6QTUfFdhcMiVMWEsV2vABtVP9B1C4uras83qKtIhZc8WaXnWzlHW+ +m6ZsjMWaqegmKpux7rUWcAk2nn9tDoxHhkeD1ayHSFmk+ctwt8iRt01O1j2Od1vg5GELiQ3O+UAL +iREmRIoYOjybqegFN2UDnaCDBh2aYw8na4a3gpUBURBBrJHOyHwEkRXVj/2HKxxs0tmaJRrVq68p +2prDFgrbYFvsfmGIjs42bvVobqtSgN7QwZaVBozmRpLHjBw9pYk6sCGtUdI9ojZq0BjRGzWOjCiO +Fh/RHAAnVEeAm9AdkumllIduJGPaQ9o+pj4CnOI/gWMKRKPBmAZRuz/eejyCxnToqzdrKBH09ZNd +D238hBpB1z6hR/AamlAkPR87mkTN94Qq0T9pQpeo7J5QJi7cml6uo056kI/pk2qYp9O0jkapUnlM +pRQ6Xad1lCrD04xWZSidUasM+4sh+k8pVr6ZJkd8+/mVpoKnqz/enp9ff1KSoZCyDAmT4jsIwv0D +g4P8YV1x8KXzTBDA2E9NMtQGpxHkZTQ0CimiV7gLQX36alhe4BXrtBDoU2k1tD8gO4FIflUdgzHr +LMsQHzXJUI1MK/G9bGHj1ZlTuDDuVOuM4SYXiuBSjiGjgexWjRYGH6nTtvXDHEMEnMXAiNE3dWsZ +nkZKQwtGDD/3gs0xg0qInQ9NrakiDD07YXRsNebHyT+MT1MPNoAqGvWE4FelJhlqkBgD2QCC0y3g +a1gm8Te4lGQoqM+zngMsrakCKhditotGHWads8nRzFUlffgM4420n81K+01TgWA0kwEglD16PLTs +MEyOMe8GsqbA4mSMOoaGiuFp1sETUxPeOCya0N+69WqZCbAS1QiDjX6KBuHMxIguMRH6TaSJDp0e ++QCAVo1VA55HwgFgnnUh5hiq4S0K5LQxFic0tH2UZXDdc8oxFBq1rcSXsXTRF49NFHkbsR9F3xHt +adF3NY6GCF6VNs41h1zkY+asFP20xKkr8rmL81v0ExxXoMiWgKtU5MsUV7LoljKuddEtdkKIIsOI +hDVFjzYRsYoesyL26Y9gI842lYkZiUJ09KxcEyIi2oTqOKy14YTrpowJAWJkIPrrVtkAuK1sHGbc +V9x7mneg23yyPdUpf7iHi3wTc6MPviItiFYxxreRYNi0GpWPGYaMd9orISt+FclONOXVeYKhRJgS +4UpfJMpWdKQN2OHaJuJLZTW9UGNcSqUTWsWyOkbneSRYIi4abyJ21m1MLwT/m4jDlaZfaZmhKRLs +PL9QiAmGZOqD6SCoQ3MDxTrQEANk+4ZI01P+HfQG/SWRiv0lxrdpD5CmY+A2pjDjwGuyW3WamT6/ +UJw6zK0m+SEAk1+33eRbUhafkjvQVs5VbLpVpELXxVQNNfZtnluo1o2sgR7t4Ju6Tf7OlXdK9dLU +K+bpbmozSgkEdquclDrdnERyo8lchJ6HAUluKn6TiDY2UjvYUbqP0q6Lh0G/MTWgufE+373ah3TK +mBCPnSptKk3d0lEKRzo7pCaaIY/YSXqzSptAtwWN71jpBs2AbgUNMA9kwkjamkbP8zqe720qE4AW +pJFGD0nmuFAq2q4SjimpJeeueOgjPVZP7oxih1VGzTNCb4SMKCkPitO2iWxJUJQug47bl3SVl/br +pmNK2EGn8V/wWNcxGJ3eUMse4yg9Z5d5FTkNVZwqzzw4riR507nUo7Hk1LYgMZxpTUY4Ol1H5+/4 +fJ4e4eNTfswGDDkFq9g4YCbG3MaUIRnzLGOmZsr3JPKcqHMizonqTtmrMQc2ZtEU+1xER6vJhYzX +HFAkCrQD+8QYdsmFIkkhySlDfCZFUr6TBIlEKyY0UDqcyFqkaonsJaqXKGNPGBPxTLQzEdcR9Y2P +x2MGe44luQ2qzvC2oQdIJUhXM3UQ/LjaddmFLBJjRUtyeiiCCbLWkC6Ddc2hDUJ7J7ZkYStDy8xB +8rdi/gqZKbUYQ4zED8Fh38C8LCsC150S/pdyKk6yC1GCWJvPTnMCEEk0W5NfFSnH2DHz2bk2JRcM +teazq7p8di7ms4tHhWGsneazi+H/CLqvs6QIrRvmGOLzsSa0S6n/HHMMWZUgLXNXhZjRrss76DQO +UCNhmP/KxYR2KX/dMMUQno9jOjuXf5Fns6tjNju/6hzPjmM6Ox1ywxR4MdNXzGenycC6jJExwjTP +ZtfEbHZ2FRNAjpPZtZpgyDDhpaYea1apbExm18a8ZquYFjVGW5QmZU61KdeYW8Vcdl3utJgkUvPf +MLta55Flmckunja2SdnDQkz06GJwqvV1nUUeM5Odi5ns2pjJzsRMdsHEMkwLqKnigvalNTGTnQ+j +THacN8VExlmps+owlZ3tU9kdD1LZlbZLttuVzPOfauXMZVevuvZj0rKug8xlZ1fZGJjLLqz6UXap +7GL8dQMGm2nXNOo3T2XXtKNcdn6Uyy6mF+KKEclWHUIRw7yueL3qFjxDJ29CTGNXKXb5MEpj1yoi +Ki5FtEuYlGWxM10Ou+NhDrsyrBLqs5dNG5PYpXE0uqFqr8HZpAuaxK5dZTswBmvHDThIYRcz2FWr +tIPTVPZ7PKUWTWSAKeyqlNK46uPHO1KSZRoi5IR57ZgOKkJIoMqUSbntaFhPwhKZS1Qu0cFEBhOp +7ClloqaJmK5LbKfphhrNA4D3w5TRrhmmjG5S5ry60vD8rA9Nne2s2EnNlqqxwXEcmlJV0/FwqJp0 +1ZtuLvJ8Q3ECmbyVo0vfjBchZrkM2ToV46Uc5Y1O4mCGC8UIWYoxMkWy1Wb4VoxRshjjbDFG6mKM +9cVoVxTTfVOMt1Yx2nrFeGsW471bDLd2Md37xYA8NHoqZakwu3TRSmLgKXKc0kUbUqE6BQbDuTVS +qWJKx/SwbnpSV4xp4SBdNCwbxylddE9RixHFLTJiXIwJdZFhciqep4tObSRc7jsySBddhX48RT6g +OOYiGzRnpeinJU5dkc9dnN+in+DBedi4fp2KfKHyc7XqD/6iW+yIDv3ZXIyO71WHUkWPU8NU0W1E +1tr5KJraKhanuzczRTexjSxRtO6KqBXIetb4kHEtRSLeRb6b4o4r8i2nfRpv2yLbt3Fn99/Evd9x +Yh2ByLi1cZbosOoITTGhRhlr2JGs/qtE1ToOsyN9GRuqiaLrnlWNiaJTTnC2wkTRCf+DIglDyF3P +F8dE0X5VjIh5kaj5PtPQPtPQPtPQPtPQPtOQ3Wca2mcaGiPpPtPQPtPQPtPQPtPQtmQaQohkcugd +uPRWsLOAwa9Ng+wGVz0MAZ+qRWLAJ+URmEw0ykJEKwo0ljKbWv8Fg1TYDcGqYpsJbyGFBBuixV3v +/morZ5I/iGKenCJMq9s7cCPFLNPL41zhLTcBFv/OVaNmMD7TDNS6kMbamPY5BXTrbQAIz3XdRUiW +6fJhQirrGAlSxrUxFJERkWKNaloot6uXAo2YTs0YWP8YmSYrkZwVYrC579Oe+JTKvop9wuc8PxHO +kpLnV+ojFg7pF6dOPDGtQCt1RaWPiSjO6GCKrVWcHa6S+iiYaOSuQhkDrl28pgCqBEI0iDtB1Dmp +LWOCXP2qPWyjXSEZGMJh27QxTjm0NvpBtcZF+um5AWVMGl+EZa2DV964jpHRhNDhilOYfSNzE1Po +6q5HYoZYsak0QxUsgmXMSuF5HZLDtok2+Yp+JjIlXj0kYNPTdWOEtpp4Gt40UWpovLqr0gRT8hKY +2vQQeCqIdE10jCBLdYvtK3LAqTo15mjBS3J07JCHodfXfZ8rxpnbfGB1DNvuBl8n98g0P9D4mHhh +RZzChtp214MCaEeceI6XMZwxFUMaUknC2ZNJ4IK2hHUvyQ56X7seQLtqk241S9/EhAQVuRiZhqoc +oKGALG0lABkyLc5EXyOmMQYgbVBoqlQPb21IzQQqFWlAAKCFVszEPNiaMtpr17KE0VVM8R8D2zWx +RZYtOqjJV3VF6YuS93qs1LVCs/xXKf23Xifj1FPT0rdFk/yb6E5GclVH/X0HoOE3eoJEEFJEM30z +SDySPKRE/wSAaAJ3qjJZ/0ocLI70LY4u5vsnUUr5+M+Y8F8dl7KM/0ZdJdfkhz47KAZJ02PSf99k +NYzyUGvGIXTFJbNjHTQnehM9cNjZUc5rjqiYDJvZs020eSqxx/QN5opkxdpEavSrAENa1fTLgJze +TRWni3iuZIwJMHQ1VR/vynhXoK2i+B9CelaC6ZzLP1DqToxquvz/OdZ1F5kQVelgTM1jTGvBdC6j +rOgx3xO95FWxnl8CoB5sMb96TL7e/VA3yy75enYPQK2a0uwigHi9H5mts4NBZ2I6dg== + + + dNhqh/O7AFZdkvmzg4y1TNew2Gm2+phInanVG5Oak5Uxmvm+juTKN7rIsoyRdCuPIOjSxOHZ5Anf +p0iPWJbuROkwvsvYfxZvBeDkD68FAIobdVnvLgooS5KHs4Me5NL5hlwgFTwLcIiXuhP09oZD5YhU +U1Z6hrC3iZHp+KYAHbpfTTmph3JoldFfYhqHL+sIs7XG4SN5DnZ8sGXJfgtHjhtBfrg6qBvNsTL+ +UOBIsJO+PDqbWeXRvVWa2sAJ1GVVdmEcayI3pgxlBl3GUkaRazlTqTLUJmylNrkJY6klN2Etoxi7 +mLmMYtsG7CVKbsRgakzEBiymhlhswmRSobARm8nAkOWMZgzgXM5qYowbMptIL7Wc3UQo6QYM51dv +NmI5IVFvwHQyrmg528kYpaWMpxTagPXUUkuZT3ZwIftJXd0yBhTBVhuwoFjjDZhQYNRyNhTYu5AR +ZVa0DVhRKo42YUZJDDZiR0mANmJIY4D4MpZUSexSplQp+iZsqZ4imzCmGgq3CWuq5/MGzKmmJ9uE +PdUmN2FQY3rN5SyqZh1YzqQqv7ScTdVymzCqI0Vh20X+fwdblWaqTEO/UnOaBiPVGovWWL0zMfBc +t06JaMfHSVdJagtwVgiNRN+VCYIHs3okqx9uyTtSORyMRXNAIpef+jsqD2XTNXqRLGRzDuzw6tHv +Slzji31HdweH/ada1eGAjjfh0+XgNSZeoSrsie6aYCoH51qklBUkBu3XIG02OP62Cf1nR2ezazy6 +v0bfysQLLcqrvZ9VX7OyUb28ZG2ZZ2KD1aUNbvn6SrFNVvgBBCerbTLG+oppG0qTcd9C1JQJj/w5 +8kCaIRNvu5yXyCUc7ywNMR64pSumTResgdtprTrPRsJr1XgCgOYmFR6v1htKKaEoxddojf4KOIal +Z7cOkpCS3lYDettf1ja4oDOj26Tq1YC8yy8yjARhOQBgIDqEDaw+g5vr6E1YN7yCUr410cubDDMF +ExctIRDzJvO9kZzcIGgiiqr1IfOhyKBbxLoA/7FD0CGkkQ7ayeGn3Hzpq6OzufUd3VdfZdU3c1Dp +/XtvDdJppP5StNNUwosRj9toKeqROixHPs1Osxj9OEnLEZDFlqPgAwSiUxMgwxj0E1d9wq3AYHJl +KaluaCJRSkoJBjxVST/m4UhRQSVQJWbSAOCrJsbzteCAMUyk5FB/K3DRMiQmpOAzRi5lTGqYDEu6 +lDI1RLGgZ2rI+ASymq7nj9qYRfusv5FyeCFlqFcDNitUq6GmsIQugG6WWi2zOtnDKIMKZUZUDKQp +DFB9wZiNGil/k9zqVSRkbo7JZG9EHaSRqq1b3aPQT1CQDsI8U+gKgmIingqO4HhuICi68bfYx8ik +1H+LvPJz6z26t17ZNZp8eFDxQwq1CfZlOa4W4J+WWoyBWmwpDqbGFmKhsvdL8TCWWoaJOrNLcfEh +MkEqXWtKemfoDguqCN9BaN5cnZynEZVSJ70gsIxhLC3kZ3V8tCT+tRwCJgbWwoUXp0HSJfbXC9fJ +JEHtF9CA0iQ702raC+oKmOpaww9DjK6A1iNofKOKLuAaGV0BoTWY1WRIG27GGt7t3Acyk3SVF4Gw +5cBlPzj4ujOdEfP0V+NPbdnqF/233Iqzaj26r1bEI3JCBrU+sA+ny6vApQus8vbiJU6NLVxkLbZ4 +mdfiObI2yda/N2/TZ8sj8+GX87vfalCoJt787gBh0ELYKMd6IcEtJeEW4dZdcpnT+dm5bY0wQpmT +BqlheaILpWxk4Rw0olG+tjXiRQzMJ6puKuvGdwCy72Q/EoSZJi1OjQRhrcKxpVrlmWnQY7vHOCWY +xb2iW6bm8V4DGnb3hHj6LYP8oSih5t4x3jVBrOrwwTG1mqpaY3uo8aq6Z8b88/bi7otmVEMzbEMj +8qzGcXHGTnoItGeWreiN741+kVpNzypboF/dF35Ugx+2cTwZK+bAUfCz2fg7SOy9FDK+7scrnKC+ +78ZfI+9D6TtIPaqhHrUBb1eF9OPvILH3qc40utRqP/7UrwRxoxrcqI3jyVgx/mLcuasMFPtfoDNg +59MAi+kcFOhOlaFJMZ7HYty8BueN5qEYD6OrOI2zmE5F18Hum/F0FuMZP56OnNNBPBzMRoKkYRAz +m2wyiJqDuVDUDNknflSHH7SiRzYg2UQkSBpBqrQbY2w3m4bUtf6TZlRHM2jleDLe6BmNICDaS6Ao +8SI/XTFNY+lVRZMyI+IuD72JgkKh5gllwmNZRq82rg6C4eDWc3WyUJhwey0vJ+9qwh0+Bor4EG+w +KBpYM9qgATs1WUp5WbugyYZdOXxkjg3Twwq00yCaysaHOr4B/lncOlWCNzzhk42J+rp6XHyNdtJv +Iq4aAV1W+jBUAdtQmHJoiD1UUvTsbU1NPB5O6TGoT9b5K/gimaBjT+MpyV6ahqVq3siAGDxmYETF +DY2BpmVyVhcF6ZIh6Fnvjg+y3p8c6NjqDpKNO5sQKZRN1slBPo+phq6n+UAwsHjswk7eMoea4Bf5 +4CtMlKVzL5JW2Hg4IY8M0n2AtaJUDVynZjoCSgaj+qordawpmaPByDpuGkSWWVpAK9wd4FY9oEbC +iGbVF2o0mV4MvqA3QLSrMJFzC2lMUAIJipiPXc3RHaDRlC6pzHE2VuHTXNCc3kHOcmYfkB1HB4ge +AsmNSpfJHB3Hsxn3WGnEXw3tg9N0drLnNaaIINz34FWowWGP7DIZyCM/RFur11YCQqBhps2uLtMF +wqUGE4SOW56Jg/uvvPB+uM6pr6mDZA12sK5fXU2p7+PxnaW4jPsudTm6ubnkrS7ur6d3d+e317+/ +Pv3x8vyPHy/enn/QS11sf/VL99G/39/c3v391/fx3hfBJ1lbD81YqWy1d6oJ/93fzk8v/3x6d3vx +b/luUEn7/eXF2fn3Z6eXF9c//fH24u3/e/5rrG7a4t+EGf1wd3uK7vftLuZiP15ent+titXR6dkv +/zq9fav5EBfeImMYb1/FhMsWUaV8phf7KoHik0+hgzijYrLaatUVLIafF8bHX2Cu4k/unuyjYQ1d +OQ3BWrGVQU8GX6bOH/fjmH95yQr+CyUyFclkCdXEDVfT1LlyVsKhgKJdeoB2txKxLtSQitrPfmWJ +TtaKmuCYJQ0DXmmmTmaV6iYpTdEqvUtl9JV13eR0iYn1ZZGVKfRjLm6/tH17Rd6RuKzdoq7S9QXq +gkJM0l8xwzF/87/+KbbmV7ExioZV/CJ+ELnylUoA8UX6UouCzMcOd/V3jcReHB903dkwrotVXcVf +XRMKtp2FGz8vU47UVRxy3plor2V/L7vf/bDTuyLWGX/i0+59VyR+e9b173IkUte+C8b4jxiP0Ym6 +q5+YlUQ9R3TBGDOCp3hvhmEki/qE6A1eAEbTtwJS5gTeuuVjLmw+pPLpR1+EzcTH49SJ+Kx3v5j+ +g1F1fVMMcEydODkYdzFVUyjrmsaZDk4ksvC0MvOc5nWN+IscLHxl093TYPFsSiDPD22Mj2/brmz3 +nNTpDJYx6ZITfUrf9oXMKrVQsD2jQMq68f5CNj5oOo5dp/sBTZlwESLNMzt4W5IQVa5ac3dqvA+q +jK5izLznme1hFd9Qk1UZrluwTKfmqUor+g9cFXNhPlS0cnq15dHZxq0eLW4Vd0rVSFPca97WU4CH +s4XLBgJN+FYdufp9k/wj087RZMpz905SEMfdkz3O3T9dd7odxEtGZ+4hWtv6XZQ9PraP9Ga9sqc1 +VZyoSDBNRzAf3GJp+uImUy/VWdss+dq0Xd+XbLVIWk1Kfv7wdkvjObl/2IJTZgyl5d/3BHY9cbWr +ISASEfADPtA3WK8icPRyOIwePQ2TqED8NDTOlN0v2JmH71i4abvCed1QMCYamvUk71Hs+IMuLLB4 +8PI3EBv4NyJz4b20xvLqY6Z1pXia71pYtxvNjZiRGMZkHjKn7LoScGCxbZtTlpltHM1tA6weEgRm +dORTb5b8R8frfxxy64WJ12iaQ+3D1UHDm6Lpz1w1ocZGTyBDJ+l0jdWg3L0nhHVctDqUyHMYjwiR +aKG7f+iIAONRxdzD9DnsXwVTV+qDK+S6Uo/10Qp6aHPaxwq7eOns8JhY2PLRBi3DbFohEDc7KsDL +C3GA1F2KhC/yaoMfZdmQh69DYyty9dLvChDTp4wU/r4GM8/AXV074yv5/KoDQQHomyreXsKboA2X +dlQiMdhyDOoLaMig9rk60Dugu4L6HopEQ03FpMRa0ENi9W94dasMuP7t6nffi+h7/dPqN0dH35yd +fbz6280dZdgMqydHp54Ia3qugd1d3/tv+t6vKZeI8Jqe/i5/Xv3uLzd3fzs/u7l9K5j/n+yIWg4r +3jMC3aMPBt4vdiLXH3/zpz/GvfL3dze3V/oqjlI299ubH8/ffPOn9o104vu7Xy/P3/RN61cLZy07 +PMJDhq7Pp+N4cqXEtzf/2uCChi9THeGYAdcFX7VU2dmq9Lzax8AbqQ5TouyZgdOuUgpcPhRqaG5q +8sxBPSb2uom9bmLrdBNNHVnkmCRiIH19dqbZkpHL+eKKSr/0a8gzV+osGHlmlv38LDO4E2fgSJSY +Zt/gzHuIaXYNkimaezhahAGaMOa5sDXuK1IFdfYYss2zWjma3QoEcBoBPh/jvIZdrtXrJOZWphEp +JqxMsJMcZmDUjFcAa7DFOlBXkg3EONII6mIpcA13WacrfIf9eIz/bmSKhACvlP02zJn4APtNzzlH +nwerJLznYkNA25xvhNhWI+Ybfu84IR4u2jjev322cZtHi9vEMeXs52e6XUprhMQ3sG1fZSBZal2e +DFRGkO+uGOtAEKv0QpkOlC9/6Zp0Wb2IUy7/DEbeeGtYD0OjD8CqKSwO4WQ6qnS69b3m7caV3iFs +u/KNfpz3p2sHvolDUD66Jl58Lx8ZO/gqm6kpqGtyDehhaSOiSfkp0saka1cDYNcTxuFOZmkA7cam +QXN2DFwzVwzbHM/Wmk59mihTgEaYqvVBw2CldxAh6/pJpJlFq5Kd880rkWb+cHO7t7DuLax7KWYv +xewtrHsL697Curew7i2sewvr3sK6mxbWiT316mBqPC3WmFjXGGKf1cZq9GaOe22s4HrtY2UdIsXK +apGJddLw0fKGn8rCWqwxseb21GKNvfVeG2uxzsg6NU3mpstpkfWwpzezrus8M0JlZtY1g1lX8PNo +J6qA+yvN3tb6pNqJk/N3d3tb697WutdS7LUUe1vr3tb6hLZWXO7DLEZXB6VeAagZB0UeMTQdJViy +tp6QFYsRvmNQMrZmBdeA+uqz9j+3cdUg8A6hsK1VAt0bK1u0GdTOyeRCQ9sqAthwY/eDRRual0bG +1SVtHi1uE8eS98I0f2Z2u+SdjtAo0eTpLHEhwZLp7CSDJVMmYNUEhnsOG7cWlAyeWcEcVN4LSsa2 +DJQ6q1jEINxy0Mv+g3TzYOor7XllSzIZt1iZ9ym9z0B9B5CbtnHrIIO5qtbM37j99Q== + + + sAfFis8hVUw7R6liOooe2A82K74W2I9DLazd7Obt5h+tm6pNRZUi0QKkNasF6wPsUE8gomwoobwa +++nfLn76eS+i7EWUvYiyF1H2IspeRHlKEUUvD01yRAyRsVUubXSgTCZJBdeBegmE/p5OBZD0OpdP +ho0/o5ASdED3CSlIr1O5R4o2VtOYzJZSJo2OPUAfb/SppBS6V8a1i0IKTTzeprXj61wqUEjPpSZI +L1/Qd28EwZJXfh0oE2hSwSGovA/Uc7aTYXR2ilRjLpxEUF7cHKYcLBPYYKTVZOyE9Jw3SzmfZm/Y ++FrQkwsmkwGnqLLxkDNoLoRMh93DcpEjH3rW6lB0mcz9vULJFy8N/OP9XhTYiwJ7UWAvCuxFgb0o +8HSiQGLDye3XPgWGEYSMxbaP24IvXg/SqA6vF2f70oZVjAIz+WdJUFgDiQ2eTPvwlEFhvL1nwGPL +wJQ7R2L1NTFh4ZGSDRJ/Ng/EhD3W5DQk7JEmcTzZQcr6zyMOdIE6miajEwgaHCIC0AVM3FsPSdz5 +Okg1hjDyLy67igPrQF25DJQqLxIvmoFSAFoGmo6mkwsGr1IwWIpIytruG5qCulimbj6mkK4Y686r +mfbgHuCDAoJgnjfC9nySgDAe5NUAmIVsTQeawbqhxdCuAWTtyGK02HDK1/TnU7ysCs1ngftYmdjV +SF/psN08hQVj0XK8Jpnl7k4GIiRq9d3t6fVP5xuFgMH6i1s94CMdD6JG2CFkwk+gIlSHwXq7QhJd +jwuxEqBEutT0UHSvUwVFV0NqpYMcHxDUZKCTA5azPWRSc97uuFOxcCqbqu8bnAz13vPOhFq5HWjM +6o7bKavqwQOvEE6jNrhu1DSVHBk8FPgOtySVodFLh4QjMYfBlNWI70HafL088OHS8HhG+vRRLMXC +to82aRuMkfznx0egbUofeKq1tsThaRrvfVKrOfwA9fF6cYEIZXqXHw5F5iHqUMElbkhW0/K+lQSS +5XYRFzyv3k2AUpY2/U7vUulUuEOG+Jwjg+v4IZaqelAxrrbI2ywmPeoq6Dqd4X3X8mSwXQqlbEMk +njDfN1k3Ay9BTLACoYjsSRCUZTqABNGOxge85T1TqYaugmxnjHrZtzsuNK41b3LSoUmfJ4M9no7/ +PvGydykedZtH6GRwk+HnPZUC/eNJ/thP5nTCJ8tynHcnG8BXb9aMSoDjGieNDvs47OJ4QOMRj9fu +OOtG3ovJ/N0LzMXgyq2X8dPJU9e8OgpZ40vkK5e97JFSQQ0T8W16eTL5/F6i3NoogQbX+lUXtuCl +6jWxbczq3piK19IYXITU5Dx92YZDh0AfYepxO9VABpV1Qb4JjYZ6sGyo9OpuIYeLGzzapMEyXgo5 +or+fqB4TNo23mruYJF+WzB3G2KKT9Da9PJl8nghYXSu8OmSW/KsEiM9CQqqs1uHHawBPH5Mw6bDs +k6yL3QddlyZFvoBQhMqv3++f68Ij5WLtJ3Kxwk44g8t2EgNbuYAnkHO+CYe41c71AOVd40PRvU5l +CxRO1eJBDqjsSZnV9OGkmryRcQ+y3mXdPh4M4lHWVGggbxqPrKkTBqx+OOoOt3zgrmbTCL9S2zDk +8GpYUmuNwMJtm8MYX98IkHdsPVw4gDxNYvGWtXy0SctC7A6b5nOzpd16VzTugL1rgovPaDuuuV7r +mwCRAbK65vouFWXJbp0rNbsMniMf2n1cjKsq8naKSS+KYS+L4SCOR4PqeM8etdWONQRErlMv2KjZ +qya22x4aw4vLE0S7FR/wlpeWpuJausf0QZ9iW4NvxzXlzUw6MezkcAzHB+MxPcZd5r3qWMt+EHnP +eFds3jUwkt3jSf7Yz9hoSsfdzbqQeizn0xQyqGXSyrBTwz6NRzAY32iN+qa7losZkAHnWGU3RmZ7 +8N4f+i/DKLth427vhplqAWLSoggSxAmHrWszkPBnvF0LMZXUnYVaLypiKK1v407FHTq4cZN8b7e9 +YE1BSGy3xdgvzzvjB9uuUgEn3gOul9f3vdPn44PBTgQo2+kJVEzqLda1Xkz6WEyGUUyHWnA6cLdn +mo4CM+bLbF6nM43EGeuuhFyzJBFHhosiwA2WhVLOBguj5RYuzWA0aXF0v2+yPCpEbrBAKLjZEo02 +Wh05tHYsm7WHehWV1YB2YdFxYgfTQapGMxDX0DFJ1ekZjEz6XfClzEcqXGjpZpXq7wBnB41QAm8y +kLC4Le7h7mpJAPJK8XdqPpVO3RsP4HgypPkpoGDMbNH7EqHfOkhZi9DaNZwU1Ga41VFTQcWHIpjS +HyKXgHB2pd433rsufBbJrJtQo1lQrjChNF91IJkzHyfUNXD6SQAekfF3epdKp8Ld9MXnY2AErrvr +ICKcOMUIrSE9o/b0u2s6FS7G9Rd9A1FYzFAljqzGle3MYhdBgnCper0nLgHYdpP6pe9S6VQ4Q4zY +sIw9wNkvQYJNc6M1pGfOm+0mVV+mwsW4/qJvYAK6n8cY+EP0DV9lT+OWtVI7GpjeTT8cvF2NJ6ef +OHw9mdfJzE9GgmKTKZhMUj+Q8S26VdOd/dF9QiRpvUFR+NASxwNR2wfc9tgR05PuM3xl2xzSFfw8 +iS5gtaKEEO8WdmWnBFcljJAi09SqwGkgNIxURnJGUJP1cGHwXNY0UWW0sMWjTVosmSPks6e2oG1P +lwG3ipMlq/T+56g14uv09mRaINMbNfFF6+rKquao0dIKOQFu9HWPC6wFPYv+qG+0KSMLFDuaI3H/ +KbtX+gGsK/4FaJO6xBbt51Uj/eH0nze3F3dRe/QfScb4nPdm4zJzXNtcOPhVVTA3CF9Y8zbRBILc +U4NuAgCDGrKXtVB+OLCCVatOmaGGqsm2esUn7iQ1Xp052+B4pbZms7L6fHyQIC1y2KhjBzIcwctS +NhVuA5Wy8oKXR9NCp+iH21ZT39Tt1IL17T5iLU3T1cJrZlMjes1s14sTvaPW8Drw2NOCgyEkDob3 +8qLZbMQUTWteOhqnpeDMuaqfuYLTi8Mk62+T7uLtvpJ2hVeDgyVv162ycSLDTw0VAe6Ljtd7pq9Q +EVLH9As1XszjzucyvpCRpVVGwh5ve1CALSVUbJF72rFd+NUZJN47Jmk3OiEybfjA2ZA+oONoOAyC +miHVobes8GpSN56QBDlW/8BQtvlXNd2gCOD1sALQm42dtNpqMkM5zY1Rf+Qy1PSCRPJSQDB9nE89 +7Oug+Q/xSItyXak76aGBVVhm21sZlcpEjUzqCkdYZXKEA3vM7vITHz/BleBekxyxFrDNuNNW0Vpb +0qtxI+rXgYpQdtV0XaUHKDR//Wg4Ym/yIXNWfD8rmLemyeZtsszH05W/3731iT1GKswB73mVv27l +cRUwr3u13qoIsl3Xvf6P80u6zZPsfvsEpBc72zZ6TVJNXykDiSO09OMMyMd7qJcsg2KV/D/UJBmw +GJcoxpXixuBK0QYIixuvE6B7TmX6IqnaVGtqk/1gNzLI6ONJbaPmxt2Z9vgd3LhL7Pf090rzqiLX +H4i8bExhuyhyEnW00xmoGH9ejGuU7+lcIt8HnG4kGxFQdBB+TRrXF0tVF13dqeGCnSnYG8AsF6ZZ +TUqk2rJqJ22PezcdAPcxgh5qpxTSO1fH265KToJsNXgs+ZRPPwgtoP6G50YG4f3QMRNjguF694AM +0qhHjlHSzpa+j1Qd1bVOhz0svVPPDxG/LH+o2V9WuG6MvhJmPPDyeAcrxzGvtHckeFAhCees/pAq +cMNhgPPjoJKomTUOPt3w6Ul55JCywtEFvrDIYW3VRK0LYbqvyNGB2bc43GwPOTswPJtMDxI5r9Uk +pQjBa2AdxhrqOabDdfBWdA0h5C1k2kpGfLRxwTtAwPEgE3N20IFkZaq6RuxaHKfQRGrxDJgnS4cB +CBFObwhvyrbF1fUimNaBt6bjnAy8IbyUejgdpjQVL2TH3d2y/XhFeGDoCVRA3hpePO68ZzvwnW+0 +HbjTH8LhkpMo8kuFQjhbeO6AMOMedPm06p9kr1cYy/FBBgrBN+qXK3PTDAGBkvqhqgdlI3BiZfFp +kJZ+1RbhfSGioY8LjqvMsVwyQeSVDDOa0i8Ot7MDhV0U4Xtp89A3tqYWqGn1gnM5uQGQCYTbMaah +DR7tAEddyVHWDZwdiKI1URQT6npAiJPOQgpCC7UwXnA5rTQVq2vlpJ9sRmxS8AWBnBJ6WlujbvFg +DWwHAjfVVC2TBDrYQHsAFqYMukQRJLMAdOoqkX3plVlJLUWI0BVBS7iAJ4hHOC2IttbRPXatdJDY +ka6C1NPJcM6oS3+WO+JpX95CVuHm6jyyCuZJWAXno3ZfUMCEALWSnJbCdGsG5Vb2AqNgIsiVavI6 +AcreCwJHW9Y2OYtTqlefSUf2mI0qatoykGGG6WDFL1oFVIeVDdx7IvO3TQ5jTQzOAaBdA9BSAEi9 +iH/pa54M+CRlOi+1rK1Z2ZUcgGpoiICTDtD03QxgOeFTNgV1xQrWHMIaCLzImb9Ir2rRiQLD3tCm +krqUfTbq5cNqm8+3SeR4rYXFr+RIxsHhscc1X3Jr6nYLN853tz+uitXR5UduH5O0qGbutqCsRM6T +9Piqgzh7qKQy6MU9dHgmQS4yUMHPq/7zDpBqxGmaQIKSevTHCiwijAxih9Kvs4Pxu66HsfC4x2cz +DDvO/TZ+gEAI4+Eugn8RnEpmxeHArdxKzm8E9UBfAt0v27JKL8GjeqFHvOiD0ihu+2ikt05ksd68 +s4mabmafPr++LmoxDcTY4TTax6ZxqieXwQ+dPomLAzwUMtVaFxjfI9wdkr4lkAhjh+R0kK65BZYk +gDBtLVlXoFIHE8pnNGCW1UAkw1mRfhCRTElVDgEsWfcl++eu9gRKPUg1pC72/T/OxjLLsgj9pobd +eE/zr7DNTi+ZES67WRM/IPTbyD+Ke+mBl8wIaYKXrwlyCAjTNI2KDrZxtBz6EiyrNFsFbJnek4JW +RQMKJ2eq7LK61bOU9ydAVmxgtXTxWealCpwqqRtqph4Q5+74IIHIBlXNKtUAIaxJc8dfx7w4o62b +0IEKlq760h0gayGDxW509Wg3U/eTyg7PdUQ1y/skcoIFPJAprHJI1laEQUGkFwfEOhx4ZY4n/TpW +klX17xKJSoXTcz5dHSj2ItVRaGCJq1VbSEXhZtHUk1avMmDq2rjr/bA02Ho06um8TCaP5aaTnK+B +jouR19moJ1MyGcDYeNj0lypAnql7SgNhztKg7WiwhLt5DxO2G5pZeusyqKXTOsPLGlJHAuhhJ2Q/ ++8bCB9pmtSRAaursoANB8Gx8iq1GNQjdNhQ8U1sdhPKJdqj/qut0X9VkbHOOQOMfIt4QxyKp0Z8F +bzdona3Vu1xvaekIDaY7ZNNtIF0yskuk29Kna74jzKuwBbbZWBf9UzTy/DAZKglQvRnZ4OyjRqTS +UGX1dIDY2NlBButu+ugqapNKI7UWAaqJil3qPup63VU0HtunT7ecM0L9K53w9KCJUA== + + + axGCg4XGutTrKeOMa0gtzPzC9lSMn+hALcKwGrUWpxRBqjqDlsmFqgPoTEGcyr6JcfB9LRGQWjo7 +6EAipVfRZ1drQXLb0mUtJYBOLnvTfxP729cyGtOnzyzUIQj80Fwi8QG5RKDuQJxbCTVPleNyC1ei +Ui/m0SDrDoJNa4W5aEiQFOOoafMxfr4DQBfmovtYBMk+bYNRJWisJwPFxqil6mCe2o9VV5UIP1Xr +Qt9cAkA7GruUQP0wYi3jcX365FYiY+JqO05uegBLAiaClzIJU46mckKR8X+yoxuNgyvpHXXVQ9oY +MyKkngrXgiFzAQimCqcOgJnGZLgeZCBeQ85OtXSA2BBXp4NAYbjqKkG6BF6NlBpKAGh+YmcSKB8A +axmP6DNQYvj3+USL40Ohic4g6vPiK+dyiaMQhPMWpA5nTK3h8x0MMZr0K4RSuy2pLjbKQwf6fLke +ItjYCtWlJqz7ykBdBV6wq6mDpPaw2RNMSJizgYsRa4Lql5Smay9Bzg76XnVfdT3vapqM73NQYJyh +daLA+gAK7NQPjrfGeDD/9x56TgTU2lDBYsqWQk0CQY9v1Y5ZVy11lDw5YH5EiG56xjZWHX6CqAun +76voAF0zZwc9zOCWI7dKtai+Rf0N2FAHODtIfelAXf9jJZPxfAZkljk08ZiLv5FKJciB6nDMGQsP +85wYU2gcEQ1kLPMrqgM8DVlyYoa2pl6ZmnQLm0Ibg4Jx0ggZUvYT0wpJ4Rh3dtIPszOo2yb5x8Ox +SSipAJpEIhhBfgaXDOU4YAJumGFNE+O00fBhoU/GGklB3QeyFDV4VcOUI16d4mCJwT1DvPVWhHkX +6gaaLQYJ0iDpmXGFl02RFTh0qsSP3lo0Hzb8gIrjYx7+rlVjYdrWDD0jPMBCMpy3s3tDhyp1hytb +unthFpnLo2xhjJNZc04DLOv0B0C6YcIYAdfP2iLlTxODi5h1p47pd5oQyXCwug8Y9CoHXgVhTveZ +ayuNLPKCGjKTsK7ILxENqzVlmzrg6j8HR+/GH5Z1q+kfMRHJ+8KXbTuvWbjOYa1CpVYJkdDt2pI1 +EMh5DXZvg1KGeT2mmoj+y0JghOsPvn0shdBjfl2LluVprlduGlkDP9NPLmmY1qmVHkTAh/VMNGP1 +tEKonoPZrIAbY4utSS+d1gc19GsAM3XmFRX1JTZXDa8TKjuE6OJUP5aKao1PAginQJ3cchwsj3hu +1QyIZ3jMnIEsGXVdEgkKdlVevq28Mi1DMGjXZAJxkwQJLE4ephaQI44scgVHcGz8ED2q0FuSD6EE +kWFMyTotdnwd2RMMkeQjKAtTozQASOpwfEDqAK7QRqeYxBBB4yJFpjO3Gb1ACGLdEiXbtuZfygkl +7JpCQJsaF0FA8WTkwKpQKkSyAXsaGbCaFJr2w5peXsjLYVsbWc3WkNX0+Ep2GeiGyNoVBDmaZIJ8 +I/vMrylvGvjMtA0UGgaEEnLdkXIvjRpvZJphLJnXNihAhWxJNGmCQCA9ypqisut5+FKWbr1X4jG3 +21EWr1XnRy/STyMfG63S03iLAoMb+/JUpMm1GbKdGhuN061qqytNsoSD2TUqdvE4p+ejoaOcJlCB +GwjpDL3lDkNr6JTAhEv8ShM9OuZm0Asmeadd4cj/Ui1hoc2gnbBRUdLU6sIIF8wAnRMcvyn6CPkJ +oVHTuiAnPUvpa48OgnuGIZ2XvGJ7Cd+TZO4zsETBCccNfoeyFzIHKutCXwI8o/dg7YELxzA7ymmr +KQWpQ7BaEuxmU6kDwWDmNiYiFaxuQEvX8GAzxql7oGwdGXgJrTnGKo0dUiRQAdUfRt0ajJ50Vyhd +CJplw6giQKSKQB2LQWqFmu76cqRbGJepE/QOTqztmtJW5q1Utx3j5KgVqbyh/zyMX65OUmvZzmv4 +iO5qJfzm5fvK680k43IIa/AtgipKDzmIxeb1V1jtEiZWMi0tQ9U+mW4sXpgnuZpEZKXSlC9NNYY5 +3NUwTlUZPFmYq68OrTKkTXCUU2rZgxTBqMrFfrKtas+oS9YtZip1EFOXKnCsrLhSKQcA77VQC5Gb +sp2lvw6zOAXeHKRGNfjL0euLBu1aP6HToOpao9IzaJbDgixFUB5WtSHSGp3EIBXyAqwzkjV6FAjC +Qf9s+JWhB6KnZ6+WU0uOjwHoSg4potDzTNUmnXml0Ts8p/O4qdwSHFlivQ08/o1QwVPPAEzwasgD +zxOfTEgFpsCp0kIwmYTaeDrUy7QbVdN6kGFZLdnKrbATrWaJEWJQM/OOzFWAIKp3io1K4yagQ3rw +hVDil9NclWBGXcPYKysDWld0XcNHejZZVzfqrWWcXVtUdmbKM4O+Ke8yr8t6C25bgQZxWoz5ZPFl +6eo8DfPhangTviwZgZeYeiRadeGhY1JFxgJHvuxgDT1FrISe79z18HKHGKPmR5IXOY15S24QylHx +Wa1bUd8CuRhuTkIvaihsqY/yXvVU1IloZIajL1+rO9XpG/ht+pIuomBOTDRgMdbZwVuy1C0bNc7N +YXT4AywSwUZxCJC2MvqV0xiREmEm9P5V2nRMp1hVccnZWtYyCqiK4PkPKlJXnsqY4cRtzGx4+jwe +aiz6IewyQoyQCdzWwm+rIk0mQdp1PvRKjhbJtYRgWHh7wasAzmqg0pVTjQH4KOuj0I8D8gcaoz3O +aYhivo1RuJPCtQPHB11pVcN00fg66ThaUCUHWR/3VMxp9UhNRbYyFPdsacy6gkIAIPSqWo4KtqO5 +3RUKIVgKJSJNAGVbhk/nNJatylMQCHgzl417YT4D9J0JAQqTXRADr9smeqhXVdRaVk2M3arUV1ek +x1adKSxcp+gzXqlzLGA4+j0y3Fj9iBpouDHza/2kbqPKocV5jc3IlIamib6sMG21pAaIzadOWj6N +DtgMtwmaM055mFJvrAOBoIO7HDakahYO8m30RRcpG26zIBgtDd9IjcAczOqEbKmmcQTAwHgMs0VJ +LoPugmU09sLjG5SMVGc8iRvzFcwVWKqPJ/60VNK3oEQ+1B5J3MDlhxjbFq06tinBotdxM8dc615z +NmlwQRC5+5BamCC8m1RpVTaBnhg6gtYJ1JX1PaUdTURwVmyqpjlkyNURjQU17Iuq2yD3Pq/tI9yR +6ZqmDFG54d19RcGqtvQUEJSR9yqjzOw3iktBajciH/vJ3MXCNXoC4sE0EsJZvbSMMtBstJGHh/yB +LQ4FNk5X2Sf0KHY+7mPBEuEJ1KCHE9zSQYkhIho3yI2IazkoPsgzlKMIrFGbqjACiJrAhSKqBiCD +D7WDtKNRJD5GS0BOxN8WWi/HYCYe/LS+uAr8S8P06nD/qhmz2RqQAzkDadgwtH+A3rgYDyUEsAYF +caUmGi8PqdGkw56lG7nGyzB+lupdoWYgWjSmQAEGdazQu/F8bcxhtFXJ8MaK+S6lzUZDbAzYNSvs +jPD1iBhog41KadVnwCpYMtTAixS1wn2f1qvjmyP5J2/OEEzmOnN1rUQDEYtQaa7g+SfEV478aWHh +CGCLg5RlhfbrwhxxHj3MIDCVeTl+5zWLPe/BcSDmxDSBWuVpwRoiYkpAAPXS0dzuUv4JmCcpCwLn +m0/nMpavzJMoNFqE5s9NHP9ExKJzH8/vL2npmhNDHejY1YHgYUVbdhvjxORgYz6N9FMV6230oCCo +YGnfle6fUwMqM0RYk9QDsRoEQMDwVfY/Gb6koW4R0vc5Fp8M4t593KgxOyZPFKmKWS9CnBCRjmRO +5VCLIpgw1BaBgHaSVZECFmxMXg5EepBn90ZUSHyIrYOTlj3uMoYYGh+tgyOLf6B0I7TJN0Ej6odp +FRc2fbS0aZamdKa2k7j9/jHUh01dU6eIlAFnoBK8UTdAJr0maAk68UroxQi1cYaOWfj1RJ7/Wf4N +9zT5NzQ8pc/gWj5RgAqyY4wCVBT0CQEqOPjvC1DJ3u0DVHY2QGUfm5Ky3j1bbMonJr7bh6jsQ1R2 +KUSltg+GqMDVZxShAtAjASrmGQNUzJwAFbo1DeJT8oF9pvCUMt4Qmh66EBUzP0TFZlEjVzksD1Ex +kxCVajUOUbHlZwpR0YoGISrVahKiYiYhKnZQ0XhsnylExcYpTw9diMqnxqg04xiVZhKjwrDrQYyK +CLDDGBXbTGJUBDSIUUEtwxiVZhqj0rxAjIqNbtHpoYtRqT5nkIp6RQ9iVD5bhMowPoUt7X54ioqV +eXgKIXl4CtPBbEt4CjuTh6ekAXThKfmIPlN4SswgUqSHLjylepbwFI55GJ7STsJT2jXhKe04PEVn +b1vDU1qTqK8+pPCU2nzG8BTkW9+W8BTmfn8V4SlEmYfDU5oZ4Sl2RnhK5Bq68BQzCk+p288UoIKk +UZ8aoFIHPei3NEKl0ZgNXtrxYIRK1cV72DVlU4RK83CESpjX7EMRKoOSD0aoPNzjfYTKS0eoNMqo +7UaEipRZHqDSuEcDVMCr7ANU9gEq+wCVzQJUZGqGASrQcuYBKmVbTwNUyg0DVOBdNQhQMcsDVNpR +gEo7CVBpw8MBKuUkQMVueYBK0wWohBizwctB4amvm2lxjMqgfIpSCWujVEKSVWszt/EUp2JSnIre +yzotylCVMD9UZVScwSpNilX5DB6k+1iV+2NVsDs+S6yKj1cKdrEqUafXx6q4TWJVyDeMYlVsOYlV +aSaxKm5NrEo7iVUJs2JVzOOxKoN5fIFYFRsVHkbT9a4PGbEhhYyEPFaFZWLgx/2hKrDnaaiKzUNV +qhiqUjYz2+1DVeoYqmLXh9cgVAV3oawJVXmkxzFSpd5HqjxjpEpphrEq5tFYFT+KVfGjWJVqEqti +R7Eq9eOxKrw45WlCVZrHI1USx7UtkSpGA1V8ClTxk5AR06aQEdMOAlW6wI9p0RimIoxVDFOJFIJh +KkL+NUxlTcF1bfZhKi6Gqfh1BRmmUoYUptI0gzCVBzo7DlLBQbUPUvmcQSpN+4RBKlBfDoNU6Kf4 +aJCKmQSpVHOCVNrwQkEqg0nchiAV04VrODM7SMU360svDFJ5tO37g1QmRWcFqdzX732QyrMGqUCR +OApSgbPJMEjFPB6kUo6CVKp2eZAKrht56iAVvzhIxQ+CVPL5eoEgFZELmxikEqNFqhS4ER6NUZF1 +jVEfpZkWTjEqsvVijEptuhiVso0xKn5eq12IiokhKuuKMUAlrI1PebirKT6l2cenbFt8ivrx3Bef +kr39lPiU5qH4lOzlPj5ll+NT7kOlFJ+yEJnuj0+5D51ifMpChNrHp6yNT/nb998PwlI+76VDekcq +AgngzE6Xsh7kDxNqOO8ZB9tyVaG8h4d/Apzxmk3c69d/0gzr6J5jM2qhIYhXCzJthtaB5gfNJEC8 +sxBd6b5Jfe0qGY8H22s9Vv3w55N//OlbwajfnF3cnskC2ze/XX3NC3BKrLq8zBY6xCwElJ6MGrTg +I6OpAgg6AUgIRyCnIxxPo1YrB5MRbZZ0XWlrvfaxhQ9S9PDEMHGBYBk1OFUJE5FwUw== + + + dMxHA6XhIVTXQc1iEVQghAdZA07oN2PoMU1fmIrXCuKGVYFXLuBxOITjyaDgJc9lqV02UOqzm/wr ++K2CW4FvRChVlPS8OhpvQqP6qAjBHXmhiZ1WWEKTkwObbuNtcHsgW21MRV/tVjNGjrpzPOngyXNc +TYbFcStvcImv4V/6CQFcqUvbdl269P356e3Zz3qntEYSfXbKASU7wqAhXyDl0xVBAQpwKl2p6ICR +FU5YJto9oG/zlvHq3NtAf6jF5GeFK8vkWL7kjhC5hy7OrS/VG4O+PyJMVXWlALhmreA6gDsU6Phv +GjTOb2VRLiGVeecrUpCmNpSWZOAlNSlsk1eP4dpLuMU3kS5ZvZaBYpCcXZeMRaAEhAvWIJjhZt8y +PjOjIuwzoJDtITfe2XR2Lomlk+iT9v44lI/xPywdpfEZi4eokcmyKHDxwuDcnywNgBssjhSbLo8A +N1kgKTZdIgAXL9Ka2UJNODD+wYnninz1pl+TpWsBFZulpjfArs21gDcjNAAOZUqEJuFL6NtKmgq8 +DY0C4T0JjhTidRPih6Mq7wW+I3lJHf9HfilNiMLKk1w230LGNkSoGjYwWm7V0z6BjFeNKAAWWAhl +SctjABqPBjeP2nBoyaHCzOkwCbw41vCEpwiLW9qhqKVSsDJ6MjBLF84g6HBxyy0MwnAHgssnukaF +i0suoPAqq+q6g3gkMbVcBuHvAy/GrHlhpxdxUDWkTrPUpctqeU2uYWJM07qgEVCeDiq8RbxhKJyM +hnsEWNmWiBET4UAVxjIpyHs5nrcUgJfg5KTku6sDRPBROZtAgj2V9zFzvohc3DaNKq1xn2nQu1wx +O8w5Kry3xunUvC9Ur3/UnIawM2teesyVlnN69ypcd1tGRspu8jW2t170C28dOHCI2OSgBTk+gM+O +Bnw4uMiBA6HquYkO6Wkh0jOvPeevBIF1Dfp49SY3DF0u9TJcS5+cY5jd1L+wQZRPzQQx8Roco0pr +2T/RZbk6rOqShSx99aha0xhVdUGExsojFy3vw9T710kgebt6vOsEoMbp9ZqlCcqyOpoXBQm9s/2S +jFfteLKOD98XCedQWRJj25kajee+571phTnzDc6ABve8t0AWOCDgstwt5IfuTm9XxUpEvl9/Gxmi +eIfrTLJWAjVkW6uEBCcpHp68S/rkIO75oE6gJUEwMdqKt/yKCFBFFr2kvxhw1htS6pIycN3WeFjz +fk0108YmHeq7OyfAGvHVsq1NjVMbylIPdzpocOqqhfZrrPWyuJZYnYaL+Bt6SUQiC2dOO2ZZD8LD +YnC17E/aEhy0lFApu9IhogVKEiGsUCBW8fLnShiBBoRShEIR4WNsNYQj6LuvDuDX32o4qKNG+0RA +TUUfwf526ibyIACVOn2W12XRaFe3sMJzRh1uj4JvhmU5BijBbAwjB6+ThdefYZgdnHq8kgHVtcMH +NPDmWF9T0431gCjGhUCUaVPpFbyT98WkkmLaUDHtTTHtcrFmYMWa8RdrpqlYM5vZbJ/00eDwi0Bk +whXq9oYRMQ39Z9ieJuKVs7NmtQbDcAxjPuG+SWlALS8lLuk8bZWojl8Oyg7rXdNy1rXRw+zIbw35 +HozxqzdrmhIaOeiN0K28q/I4Hgpq7UeqnPX4i2JUSTFuZN18D7p7cjAM7fZNZPRA6OTUF+QQQoIg +7DZmkZBtBxVtTdeWhGkMm2kjs3ACKUrjcXBrPKw7GIf19Ft0GvJHQ08Toj0SZq5jKrkZB0K9hnVc +NUPnkgKJ6AOj8muGuPvOaf/kAE58IEMFvexL3UPQItD0eQI5r9aY5P4DBLhRFdNXg2A7DfnsG6Me +E1dUZX1i9BJCDmRBGIl0Mp2pkweU3RiyMFq8m7Boarh9qdMxnAondBOhyQ2IuQejBvbPI3FJzXjN +0FRRS4zIU8ECsLnKIP+AaFphWJj9GH5riFhZV7QOqlAJtolGoKOzjVs9mtsqrEqN2rFq6LWGau37 +eJF00pers5ur9zcfr9+uPvx8+v58dXXzNj/mH1aLr8FrVXSPMFuBI9ymCLoJdqvmfYTfIBYTDBfx +cYLjX71Zg+Xcyj2eU2SeYLpAp7hO0jDB9qi3H+G7TsMI49fM4sn9+vgFS5epx83zcKZPzED2eaI+ +fir72N7PP7qH+Ef6867hH6vIP47eP8o/uo5/bDdmII2aTFsIgmDqTGNNIAPpZS+tyc9DNZNPyRvi +Q4yEbw3SQrUOomien+czZecZcJCWLi5DDtLSw2jAQdrILS3nIB15Njhg3ctB+s/BQfpZHGTemyUc +5Gj8xZppKtbM5jwOsm0XcpDuIQ7SLeAghy0v5SAfYhiHNc9jGN2jDKPbhGEcd+UBhrEuxwwjNtJG +DCMiWZ6KYaxb8zDDqPb4tmlmMY7D6pYxjnbCOOYz9pkZR7jqKgvXLmUcsS/JwvlZfKPp+cYNGj2a +2eiLs41D7F7MNi7H8aVs4xA172Eb12L7g+zjuNrl7KNdwz4OMf852cflzNzF2S/n4Of+dv52E2YO +9rRGPchhhUbyToUU8W8Cp+cy2gT5Tfdy+lX6dXYwfjcunFUcf8LPPABeIwwNpgzghDMaBi9IUJYB +3prC45V1yS8DQp1OkNzHeMcMJsGrzq0SHqFrIv447kc+iyk0hmTOth6BNOBdygpWpZKuDaAGEzpX +A6vS5dLpoSA3SGRDcm1NfjJRLdZVJRQGekwZdud35Uz+w1mRcVqOLwQNk6J2MSVuhFVUMzdWZR0S +QP9fJKg+lur3qvPOVAHI/1LCDKohekyN4JiWqzU0ARj6RhguEQKxMPGmxgHNdAdlRb4W8TipCf2r +yR6ztmO/Rt0saawZ9rWYfFOkOvv8jjYickojqf/lAK2aad5rBg6ll3znYCYqKUfTwRiefwb2PAd/ +Cd4SqHeG4tkxKyMgjebQIcQwJt/qs9HnxnWPnGpmia2ZNwqkiHNmPBCdTseOKagYoB17nI+CfxnO +Z1c65uM49k0UhM7G8+LhSVMT8wPTdkZr8pKJQ6bbhVP31Zvp5N0Le3BK0d2HJ3WSXbLNOMo93ZxF +NxFFqWwEz2nkBWNgcUnZ1pg19hgfNFEsyWZ6KMhXCVl0ypvVjfJmo3S33pU0+bcibTf8YULFTFrC +iiqRFCYNaFEiEB5xKSVCoxCutCebe7K5J5ufn2w2A0EcWwI8kcgfoaUbUQJlt1yByYfmBh2kPsxX +/DgBzkRQNho9HCFIDwihAV44CBxh1hwGJYdDZoGEBKiJzwo624QWTD/zCKCOatULHnzU+CRHqkUA +/k8HlRwMQCLr+G2s3iMHQ3LbGiZ2qDT5nIMHrEMmJ1o9NSuw5mByMV4yTgQqSefIYK4eClQAaXUy +1+BIi8rinklEPcG7bQ1r6ryIetSNIZ04giErkASj8jGSDTL41+q1l8HW0T9FRPAaCex4lRRSQMNH +aE1R6ytNXSdyOPIW6EU3GzZ6NLNRWVzY4iG9W4Z0LghIWIOXPXARZkKwXYybX71Zip1Keebip45l +KYZGt72FODra/WbANA3WIJ21mnRST8VGnRsbUEN4QULfijmhZ6PBEV/WPIkgG8mB3tIhkhorK7+9 +bwYgfOWRKKmpmZGoRdITqbqOAGTDdcyp4GIuXWiSrd4IGzSzeXvYpS5l0iemWWHoctCUjczNQg8r +gKjSPgEoRmHjK0etbas+dHT7U7aM+atrqpVNeo7sHC8VlQ2MaGnyFS3c03ilLybdlSDcDWOneTaW +RjM0MynZyQGdYAN4j+DVUoLoNp4RdA88IS8C10LyIo3yIpoHFxCcQYBYRnejPzYAD+uS7nlj9iT9 +uldN6Gv65UhlLRO+10GWhiFVbbmORAHDap6p8NxhAhSHwDjepIUYXVW7OU1dFpD3iEkgf2BOUBGa +dVMGGALXFq1qXNKMJGxCLrljjs42bvVobqsO2UGR8MkEXgY2oFFmmFR2DfORtoz6Li/cNKACk22D +TT7ZOAAu3zrCmGyyeb56s2b7EDjeQAKcv4WUl1myiVhitI0ENt5I5L+GWwmg8WYibLSdAJu5ofrV +Hls2GnsfSR0zdExCTGfOOt6YwOcK/q16WwCfYT0NZPGYMgYbgpNWMka+rpCaDipgLv9TMfIjyINU +pJRdBQHRMDMeXF2RUXOdDo6IUSKHgexTZIZ1cqAxtD3QI5uX9zQGYqVBntSm1cyzSCKDSB9e2g7c +GRerLS2DUqxCAFHJHIybtHY0p7XAHJ/M32KRkGcZ2ZiihcIWIQbv5liKGk8qqgz2hFu2J4Z1IRNI +pfoRphzxMBHhys2GHvJPg/P3YLizxPDKQj0ADUitOYhBP0vaYiYKEzmymHKUfngxFqEy4OkQg0Bj +DJljpl1jtLxrZZT/P3vvnZ9KkjQA7gW4AzIIEK58FUhCeJCELMhbnCSEFaZ7ev7Y315gj7PX2Gvs +NTZNeV/Am1a/5ptv3qCqrMjMyMhwGZGBJSVgUEnETnmUWGL2KcuLF5NRUP/lMfWR8E4IdBklYG5J +Mdrf2CuLmSy6pBBe+C5KShe9QiEr4EtSKXzurqZ510Supxrva70yItYQLLPKQ6B6owloQVv6zf0Z +EMfC2gYUuqyDgG4NTrzsAoZVkPCi2qrqEYtvnoKXSaOiWuJX8OJr3AD/DXR0/SN4Rq37KmaAGzN0 +Dq8r1o6wqh+y5W5K4t1EJkkYzONPEijKBiWKGmWFnDZP8ziECBZdQ3c/iG84ZNrSeHxIgwMjJpWE +ffgtPF+GKSYO34LtyACLT5uu77HfnPd+KXQHLdA/lb00hzcPo0NRhQBi6JZfHl+BjuJ0q+pnDL60 +OMbBlHgeV0UhKBiMqSy5+CTvMzwCq6f/DoFGbUTQygOx/7wPDdKWBn4+2eoxba3nJPHdE+jqCQLl +AtrRK8xqZhzJhkdOES21QuiOXwIZhFi8lli9dJrz3CkFc6JoUvCk6RgpGT4z0rLmqSdqDrya0HPg +dSGKBp/paRo80tMMeGSka/VD15QN4ygMtA1RsRB1Yxzqx2qkcK3cY0lViTaVeIIWK7wlGkbiDeBe +l7sT9zaj4BNdYs+R+KJ9dI2UZrq8cSPz8v7TfRUzwI1p+2bQFQXq0VV92r9sfbKwUjt0wcE7ZCiY +hwnVZauNjK/MJAh0py+8V0+3OUhCwPtQoJA3j6bUmxnnl6JrCuy/ZTlcj0C1mxfoOee9ZzIJhB5U +YZUtrVojTtyx+idIXOClEZ9Av0oSFzejgUXlV1YMinqGw8LihxGQeogcjtfTTSOmn6cBOfnVEhu6 +KFNwXHF4OQWsQKClNXT/K0c5fg2ZPSzaqKU2j13nFuoapucDEeIcibeIuk0tp26TenWbEwx6Cyfo +uDsSMCruzgkGvUX1SNJbVF/FDHBjhs4lvYXUq1qkO3U7Bh2HAokC4vHVWSTMfrTTX2LATGRYdN0C +0gloTruiUP2goSVI00qVD9XX0GvIUI5fCxR2jWqvyPLad26RvqHOTvAcr9W7lRXjJA== + + + xsfjv7COLNat9EtqAroRCF6ijpQJBkWgksitmvdp9Ato4FZ9Gh0EGqYaLUUiIl6Q/9YQkaBieeiG +HOlRzAA3Zug8L5oL6jFK6q96Igg4K+BpavDhwOtoeCEsK5MYsNyTNiSGHcYEvoyaZkyYBq9iOTw0 +3HXcjoH10GjHr+FFaeLJ4xJ95xbqG2ayw7pFHk49tQQo6rYyCWK11gsRIvVVT4bqh64JUTM4iRSh +erkQMUr6vpYcJW3VLUHqwsF4K5cjhkoa7GnBxJ4WDBaIYLBAJByo7Gn1I9Ge5vTWB6cCrTzQ2tO2 +TP7nyyU9pn+FPa1l6dhABeNyYU9bfulsTzt1am1PW325hD1NmtjTWlrWPPVEzSLP0dKzaE97pWjR +niaN9jRptKe1dK1+6JqyNTxKb097pm7JniZN7GnSyZ5eULFl4Z+vZ6PhxaQ7nHWHH7EYfozUXfUL +39kYvhHwm4v+HPx73vzqtGY+fMGkPzeZTz/9p41h46MzAapxuzMJ27/z45f5Rr/fBTt1/NltiS3r +o1E/AVTs8SzuP/+jAX4bmwI1AIBQt2dt25s0RSBK/cbMsT2N2l/B9A5tWwTC5APe6gNjWzwRkjV+ +ARb0fHjRmH1qQOc/G5PWSJkkaIVAmDStd/4z8xe6f3QBwu2B1hGIxrgzAWyzNpuMeh0wsDhec0Ak +mhVfMeVYIAZQiBop8E+IJfj/BIH/i/4SQ5DtRrtQ5wr5oa4p+B/Oj4pc4G7JX9ItrZsyDf4jTVj1 +n5X3i1ENdwPqlvWzksRM/upOZRzDTknUIeCFfhojmfwF/fI6JPN+3iuSV7kDzPYkGJe00xExJvyS +VoPbgOZ+KuGX/gMxlfAjdJFxStZsFkWdxYjqGg6hGxdFmA/nlw1Gxd2sUARvTfBzyrhgxA3JczCG +COZHotuYYFwmj/gfNBvQqAm3o/ZMBUn8RrqKeepLnAxHfw7RH0BmI7ke9ifOwDT8UV8iC+T5Hx3p +bSIv5hiWun0wM9ge0Eh36McN8FOs6SbEJlGgLCRuutNus48AGiHUZo1WbykIXseQa0y7LeVzvMiY +pPzn7+/TDhBopPX34gdH/f4cXYYxmsQb4zFAGl4c8FFHRF9IA9RfBaj0F9/fwdqB1vXuDIGjUD/9 +84nYGAzQ7pbu0NFw2oWpnfJddoXudNxv/IX/hCmfCQxJXDUwkSsfIDaeIFElLQEm/qGrHHhG4DQ5 +fYKUygdz+wRUCY2kYQLgXdbcvQgaGB2MJFbjE4XOu3/P7/OHVMMJY2TiG0rwc4wcaVZR354fzd+/ +5wMYbUxmJiuW63eGbQ8LbofPBAKm4MqdE1WZnPK5xeBt5pEfDdvz7szNHNRQVr4DIP2tCJ3y9TPX +007xj87wvN1GJAm7UJDs6bYXscCEKtXLtNYEsrFhXRbkoUIX78EgPRoWr6U4i3ITyjrKA/zNafD3 +mZIvUfxPpzWHQ0Av0Ldm8gze38athdpvJtTc8o+1MFoLo5ULIzMJhE+GSHgIgg4fOR4WOYS1JvBt +z2sJ9DdKIOpvl0D8WgL9ZhLoaslbmC2MKhOqXJtUayn2vzepPN9lvhZo//ApeRJowlqg/YYCjRNo +AWXXUeB/WegDTAosje9+ZRl4lwK8IUD0YLP47hoC5o3AgnPWfkJq7ShcS7UfIdWSAr5Kj6F4dMck +CyvdoCgUmEOdXHsK/+ViLbkWa7+ZWFt7CtfS6Kd5CglRvKyFzb9Z2MDwybWwWQubtbBZC5tfJWzc +5B6shc7/bkqGpIe/QezQP1vs/OuEBnS8UTwBy+aiG/LQeRHJMwyjic/jeYplcE1pgkaeOB5G87E/ +6yhpQY79u/BbUsCXjhOwDAi6axJzXpY1Kd7lkfH+PjzYE7ti1uzqx7GrparHrdnVj2FX4p0JBC3Q +8NgHcSt45SjHmF3fseZXbvgVu+ZXP45frdWr34NfSeoVvN+fVNQrmkdF/9b8ahF+9cOD4/91/Oqn ++BD/uaxGYeqWP/B/UNklT3xpzU0cuMkPD3T+13GTtbX2I1jSquOYSByeC1hZUkC17Vg+yRC4JCgh +JFeQ8vgv5V/ruNY1B3THAdfp7+uj3R8mDZIMTkOieB5eLIhu4k1SrMnllOsz33/4lDwJtXVU6+8m +1H6Kk+AftmvW0ujX5r9TAk0zqAwsvE9eAIoVKoPHrENd/9357xzxsyXQv05+rN1C/0zW62QI0NgO +IHlYcgyW9qBI7BRiKIZbhyAtyL3Wgfq/G/9b689r/fkH6s80leRhbr0/xnNA5sKghjhPMLRJdeG1 +/vxv0p+ptQT6zSTQ+ljiR/CTtSD7xccSqFQMyTAMujqGhGVmkD1CCvzy9sjvQoW/z5Q8SbUfnom2 +lmpru2otjv454sjmtg0xTpwS1jfx/sstqR+eTriWOT/GklpfxbsWXD/HjgLv4wwDqBnbTxxFceu7 +PP7l9tMPTzVdy7K1/bQWQ/8cMWRlP8UpjgAKll+6H4DlWJpdG1L/ckPqh2f6rYXPWvishc8/XvjA +oAhgwXOsX3biscnkOqPlXy58fnia5r9OdEAfnMDyhACPeTlW4EkYf8oRBI98b5zAU6jYNQGv1IFP +SKV4CMMTP67I8L8opNi0+BOOI+YEAkej4WvBKIYhlvc5/T5M2BPHWufg/Y48j2NZkuHQxWI8rJVu +duUMDQuqJzFfxBXWBVQEcF0waa13//3s3+nsgSRxZl+SYUgB/mIIlmVwUgmZZLh1aPK/W7DxPzy1 +by3YFjtQZ2giCYVWkhU4Hv0gBZaBWj3B0FiM8QJDk/AHCXV5StHq14JtLdh+umDjxJtE6SSXRDdo +MQJJEaiTuMCQ5LrC7b9crq2TPn83ubY+31iLox/lZsPnGwwNlGh0us5ScYIigEUVp8gktbas/t2H +HPw66XMtgdYSaC2BfqEEYjh40EMKBJlE5RQ4IU4mBXhAlyTWAujvFUDk318rkF9naK5F0FoErUXQ +LxdBBMnxNFw6io8zvECioonE+nRpLYJ+eMLmWoCs6xP9HWyTphDbZClBQLGxDAfvWUF162AYHrOO +01qM3axz6n43hoViUymeRsnfDMFAPSMOc8BRUJYUpoUSw4EVDEUejyO2flhM6j9s16015v9FeBa3 +vmLrB+vPf784++HVPdfibH3dyT9o661l2v/oEnsYmSUwLKBkGHvMEowUcUzSK7jG/nehwt9nSp5k +2g/PPP9XSqR18t8/khXbJP/xAslCzxLO/QNGBbGuH7Igw/ql2cqm7OYKwvTnR5NhZzJdFbvRAZVZ +jO1aAP5z1WkA2oXkNZ9abcGVs12R3bn+3iOf/EVu8d+XOy2InzVH0XKUyaTxl78ymnT/OxrOwLZ6 +CvGUfzx7Cv+jdKL15vy3b04sdeqTxnD6PpoMViWiVADdiScZPzPpy4vGDIxhiCQVIQmvweiPzs3r +xUx6ir+ZdN77QNu+0z5sDNujQfe/HbOm9/Ah408cAT0rNO4OL0bd4Qw+S4rPhvNBfjTudlBHPKXu +v6LqXxSpo1lj1nm9ApK1gQdMEvLLaavRh2PuTFod3Ic8GPSq2h12TMEVOh+TDn5F6oCVGi2AfbOO +KuqOSN0r5bPfzxh3xbbLAKFDNdsui8q2imvXuoNxX+baXtR5rMfjPhTA8Dt0Y5KF1i4aAWAmgASt +h340BNqev9wf/elngaBZi5m1mPnHiRmFhu3lTGEyGtc+G+3Rn/FG11zAqEG5NoAQZ2/2hwgnRJxn +Jf44Gjda8Jn8oNmfT8xNe5OLRfQ/8H/uGl79AAqmP1r9icjA0Zg/Zn+N/8Vs+6I77PlznT86/X+x +Ac/+rwz4X4RJ0TsK1LrPVeFRA9IbF/gaztCO4mUW8D6diUqhqOr1uwOXe+7vcDEqXIdjaQIfOVJJ +Xs2FYC696OnleIZdjiX9nLOcX5IQaDmPte6yPipFej200xoTtWIfJyh41ZifpFm46WiYL8yzq78T +FTPE0vy///3Lf9qY9lbFPksdwDghvt2xTlK2NK9sJdA/WyH5hZS+loM/ditDG51Bu5iyNNQXMoR+ +n43hSlPHVtvaObEW8D9FO/6FVvpichw6N/zSPlnSC6KB5dKMlKV4uzHpqZ0MrekEOUGoOMlJbf7o +TCRPMkb8uNFFnomYutXnaPJfi3WgWAYGP1ICh4Mh8QrAv3qLI36qc4/YuXQ4YATpvTprlq1i2Y/g +aWPenz3b+8C97SgUigQjj1i06kkO3WHIC0l4Zak8Uy8RsOZO8kD2KPlaHLazkxka7RQ+YeGT17PR +8GICWneHH7EYfpzrgP1z0eh3ZrMO4rAXTTfjDD1egQ+REgYw+RxGi3X3X5/+ue+i5Q1PodvP7qwj +fueMrgYkQCDr9B0lGY6lYWRxkuZJmta4AMTvrso5/1WnLX2ZpJNJzSXJSZqhYLqCeojKl/edPnS0 +4o85ludJrZtBzt1Rf4TOQcRvWJ5IMry6Q5JmWIrRfkvK3+b/akifCgKNvBo8T5DwdiYjWvFyiF/m ++nMJoTT4P1JAeCToJGW6EOpPTxsfQBlsiF+TPMVjpDJkUkDrwrL4B8FxAkIfz3KYrymBdDzH8CLI +AxgAXj6gk/7cAcMaF42k8XILArziA71iKB5d8C5d4wlDxdHFngwJIItgKZoHYCkBgKU5PVieA5hN +IrCA82rXmGEBPJibIo9WAxY8Kh8kCVOwLMmSFL59lGSSmmVIcvAabdgGzx2ARViQwcLRkuBfAJfQ +w6V5huUhOIFMcpo8sHhSutWUS+JbUeIUDVBGS3BZOFw4/NwBm5Tg8hRNaUYnsDzLUFq40CmGaB7+ +n3JtqgSXgtilEXppES6ASmgGB7HLcdqOMHIFXhRyWqgkWjNA8SqoLMXrGITAJTEuFcQzSQInk4rI +pXA+gUhhDAGRkISD5SSwgHB1O0VgwSbSjJaiIBFAuBKJURjLGC6L1kwAts8Bz0gbkeZQ+gKYF43w +JyRJisNbOEmji9MgDUgCn4fpDiI4NEgGrhQnrZTA0wIaJA12ARwa6J5HbkyKJmgBJwIyBI/zK2Ae +oMCpoREQk6y0q3iGo1H+heIU5Vme0UyZlJZbnjLeDxgoYH7SjElSBgsRiWYIGAnKSGRoiuVUHBaO +ksO3yIMfhlFycO+TLC/BIwQeUQ1YN4I3ZWZAq4KTRjNAGIS0BjpgRbAMpno4ToqStimgPQoG5oNt +ymD0mzDJOMPA/QMRQINVYtXjJGk4TkEQ4SXBT3z5EAnWljEfp8RUySRYHV5Ze3GcHIDLoOkz0jCT +HElQSJ7BCuACjb+mOQKhRE6PkTYQjQGLGwjtH8icwJAkdNIcjWRIErBqwvzSf0ZhyjBNB7Eqce8Q +cKODhYNDZOUtCQgJQWRZgjWFqLA5iY2yeMmkLclLTJ9kpC1Jg35xsaQ4oG4W7WgCIAAvNNh34vah +xThsDIkVACQ45aQEhyQAg+Aw00XB3UA20TxecMiy4C5FPFKNRvEuaJEPURIekwZmnA== + + + JJMMXhSAVl7LjGWRhHk76Fk6UZAlEo1WhyIlnskBdkehGVMEojugdBCshppkyczhnCjwQ5adSUTo +AtpA0vwZGvAeAdEyB1g9/JEEPBMLZSaJuoPoYUUuxOBKDxI+oTiGWZlwj0t7EpZQROvBQv6GNhHP +YGZCwWUjZUYBl1EUHbRacMI7ioHghCsuSFABRTAkHAkgbsQaCEDMHGYgHFIiaJlRiutEYVaPYQpw +qGiXcxJpUqxAkWjKBAd4MRxoUkA4IEhASIJaSHBweLAXhlItE5QTAAEsh3aRxIlplhST2ICCJeYJ +8DzakTTeDJw4fQYzIrmShgiVg1udRKJNoCSgSY5Fuxm0YxF0PsmjQQOaoNE0JMlGS3JelElqyYYE +m8w+wZd4PeBmEjjMnziewUAExNwZqbYHJVEUqV0rSKlIaZCVHAawQ8TTuSQNtD4/1neSon4iiV1x +k4J9pSA0CWeO0SlhkwHaO4EVMXhzOxwj4ClozwLdHK+zOEL5tnYCM2YME2GTRvwY7yRDolZt9D7z +I0PAf9P9GEJjJiw2sHJdmn4jAgcQS412xz8b+bE54gRL21qBYupVtYGjb69AMguhsgGka26KNGgX ++FGAXt89YNOPIPhQ7XvemHSm/uzwow/MKg0Y/J9HFcxn/9jwCSIXuPiYT0Ez8yJ7Vj8/K/oBD2X9 +eQj0Pz79Q+kz3JnyFoAxfIGeSR9QHCJs8D8qkGbdyL2ArcpxpEas8oBytYJWQOIFaSniUTONb2+Q +5A2N9F4oZQFTkWQDwREkYg9AkxQoc2M5KTJIXuQTgkpbA4wA6b1IDSJVcGX9FuhtSFCwgGdpRwws +X0I2OQjM19DQJf2fQRISCXDAXiXQDE9RNAbEM4y5ssFKgkLAbBfKabVqQEOZRpFo1GDJSXlxsD2i +WVDAEAxrg55JqmmSRz1QApAsViqfrI4LimoqQaOS8lKTcMs1/kLxLRcfbn0RWHeEQl9WyDgG66E8 +CRRnJP44DijxaABAl2aRVBEv99D/ENEPF5aCLFXWbnmgluBMNoamCSxNGQKLamDXIG2Ekv8rGjBQ +TWYhollpATkwALRuLLDdEN8FywWYM+LyJLbmaGlM+h8YKo+EB49oWYIK9HWkKrMUiTcCA6wtNCYg +bkmso8j/VWue8F8ohyWRCUaD1pEBKg0iNKBAgN2BVBtR3kuD0v8QwVJIvCPHAPhXoluOxfdREDyS +7jSQkBwmE4ARRlSYOLXqhfUkltaoXjQD6ExACgvYvcgoY0lWbQoB80a6t0X3Q4TLY5UO7SxeEpgU +dEUhK5zn+CT2oZC4A4XJyP8ViYTAexSqHOBfSTkmgVaAvhPYJPYlCED70uqx0sj0PyS+QiDjHxI1 +pXgrWAG3JRiKwBoXsN+0DoGkyKW0/yu5QJDSzVBo31PSlrvtNP35UX8EReBoPpY3H6xlRmJ/B8cI +5tYXJd0qIBufGk7D0bL1SSm2DQ80MS1eObykirUkKaO8pOlSYok0kcKw9YD0Ul7Pc1mKwho4MO1Y +XuNMtHQOsayNcygpKmECAQiC0sIDJivgbfCH2orH8Cg4b9owPk9xUsrgKLQPeFmzlexUwDIEnEUL +doTWucljlVMkWrXXihSSCuWSGOZFTnZaS75pxVutdmP7zsbY4Y3eSC7vanc6U3vx7aLc5QNaTUyl +MbjcNsHJ4HRHI3D0u5vMhCTwq9pfg+aoD8H8H75QZTQAWmWo0umPwf/kGtNeBw0c6IqtzzBUP/8A +o4KaZ+iqVoNN5n2ANX/Mf9X9+JypHxRGfw7Vf1c775r312P1XzmgHf/ZmLTVz0qjifjofNIEf59P +GsMP2HVtBlRX1d+5+Ww2GgJiMj6j1M/qjaa2EXygaYE7wn5sMP32Rwd9ANdLfqD5AD+iwSPR5Q4G +1231OnB8yOcvDRbK+LCId7BSaqxbr55IbYVRaz4AJFRozBq+wGtC+tufQn+pzrng33en1bNRu2P6 +cs8f+s+gPwSvY43ZbNJtzmc4yQU0xVT3vwCxAviqVq3Pbr89AbhHbaTYGukt/Gf217iD34Z2htPX +PxqT6Z4quV/d9I8GXHvcFj6fWrSD6eK4mTiSqeavfyh2hqNhxwVi+iNA4W03mJFaRv/eeTW7wzYY +KOliboA4ap3ZGZqE8/zUrVe0/EtigrTFhKv5dxvNfscN4Tuu6j9po6f+cL3VYdO/maLh9Frz6Ww0 ++Hs52a+jw9S0AeMgoMwDW8wtOf7yfVGDN9f8mKH8Drt0+v7nD5bGf/M2mPa7rX86L44JpBIaZrm8 +rpb27+a7cCqc01T+cjOVv/7uqZAcLdBOU/mz20Zh7Y7TERv+A6b02UGWqos5SS3/5klJ0Z9WE2qO +gKU7gOb1+aQLrEU3UzN+8wNEPuJ1tdF80urkYBD0StjeP9ogI0zeqjE2a0w+OjOgB0CXwfSo4Gbp +jd/8zarsxVmZYkqjyaBhtSvVU37v9ju2jTWTVbf+x5vnhBMneEeB0O4sc6Xt37v8jpPqDsE4+42W +u2mpW/9wvo0u2xk3ALiWK41B2/5v3rRbJfR/LjbsAF4lhI5a3ExS3fqHE+ZwdOppatr2P0DeOjPe +/5lJqxVKf/doRuNZd9D9L8os+CljAlby3z2EQWfWaDdmjWXHkVxyHFtt8fzDza5TNUYf45NCgvBL +P1RAajfl15tu58/c6D9392L7x9NOuzsf+K8601F/LuagyF9kj0jSLx/HAFqZj/2lPtzm8EzvYtKB +qcGKe5hjWZoVZ589Svobk1lz1Ji0/S10FE36m/IsZfaDupAm4e+CUTRmHdCwg1zato17w1GrN5rP +/B/4jBsRgZKDBkdw2pl++q8aUyA1RYJXzRR/wVIMJVgPmvJ/oJMvd21ljYMmNOM4n8/GYKD2I6FU +kNXSEIyg2/ZPxevmXIxCQbPjiqgm59hWnhypWQ9EBpM/Ov565z8zf7HdnTWa3X53JkpxkpFhGomp +2hh+zBsfHf/FaCwtoV4M8hJe2uNuHDeRQIKRTXQkMkCXGGgeNfrdqe7RdDwSdwwt+zvGjXZb3lfZ +I392PhvJK2Yk26R/3BiDXTDtDub9hrKK8rrn+p1OG9qgN8rmJi3xq7WI8pPRODvpNHCKs0FmhpRY +QFK/4f00ZfxFxMPoMx1LECcr9wY70PgaxMFKq5ZvDP9oTGsyOtSEQPjfZc4ANmW/O+z4pyixeGrf +eCzRz+iPzmQMD4in2lWGyBK5Dhz05bwBqctfxZc26RmE2ThmgDJxS16hcE3LCVrn2B8deIuhv9no +N4Yth0m2+t0xWDvoxf8P2BsfgALEgYdIJg6WQ8VIe9mj0rzfl/B405lMofCdTQxd1Eq3/jyEXB/5 +syKFmO8L/d+EFkilflr1X087/qMB3GDZKQpCgKxy2NYTo9xeaSKGD9XgdZESSfA8rJrl/JVe0pk3 +xePCF0vIu86soaKjmKGBMY5H+sBfGwNTaTIF6J51W42+nqwsP1BiUwz0ZfwG4Dhfq2n3rylslESq +NtdJO7BHw1Z/3gb69ABSjJ6BmX1RHsHyADDHHrCjZr/jYkh4usXBePZXvtPvTy0JQ/6kXriFvtCK +ynlo1wNa5NPGuC4rQJSL1tVRS8VR9Suu3y2j8V8G2tYhSkSm/+70whymrj1KVsaY9J/iZG9Dv+o2 +18Puf0w7Vje67Q7boz+nOmpXteiq5aZ+hEkN3mqNP+DWggn7CoTREFKKX8OfXX3jh8vjJ8QFIjx9 +RZotq9NHlDg+t5PCX9GiouLpI0YcH+PpK3ahr7iFvuLFr7yhUNDRkQ1FmBOUDo3QO+1ET4S7T/AA +zZfY/psngpDoSfD4HWWOe8fv6AW/s6Arx+9Y/bpZIt6U6ygSvTZvvo/67c5E8iTCp9OwXuzqGqvM +NS13KMzHYCTQ+FLGkut8AqpS+XNwU9RApDetcN4z5eu6d2obQPVexzmL/xmPJjOoBqmlq0q1zqFD +HpVybVCQNE6mWqdfacxA31C49OH0pip916LtEfS3HhXULdWv6zBOAfZqNj4UMqoanvZtfTRWvZPP +j8v9EVA+rzrjeX8qC8A9+Fa+3EM3Uf3dH4qCA+x9pHMYZS94Uxy2RiYWNngDzbjzoaKXqd+ha2YQ +7qDmIFpQClBgCra6yrhJ5U0JaFN1o/MYggRm1klnMjQbCNCtZfVTPfZBE6AXaeymHQFin2LSMmyh +pH84UgwNf3eINPjRtCt14+wRofzAOLTxgqjtBdQWqfN50VC4UhsKamsENcWTStxgMySnMUPUng3c +Woq99jeAloxdHTqXgsYNgT+CqXHQskAfIZNd/5Ebp1DxouYWB7ixNRKMbc9Fs62mNh/VuMLNbJCl +nTdu7jxxLYrxV844dtiNcvi8/7bTTNx0251R4nQENL0ORCpQHME+7Ei4TSiO8kRr1IflBABkI8tW +t5vO+vE27gIRtSwQ7MHDz8T2ikfRzTfj9gC87g9dD2rcdg0cx/zJX5Dy9UrqhuPxJI6EXbwPg+5d +tZyNRO8Sy/P2LSeKYSMQpH1bHGegY++aNYRt/xyJFeHsm33qmhlw+jVqApxOux/DhtFpqG+IlrYp +xhnYQUQNR/Ak2UW7xrTZnQ0aY/umuM1Et0/MWrf6k3hrNIRXgUGXnM1QYUuZbzfRVUV4/rxp60k7 +Dmx4eOeOwwBAw3fAmqRrxpAoNm2FhITRy2fo9Q94QDuOf7ps94f12MYfg168M4Q6hrsdhD7AW0hZ +TzffgEWbwQvexLHEKdaU7mFTsKkhb1YFRFkOfQy2SHf4PnJoNlFddOXQFHlKm43J1Aa5qGETqlhg +P6k4hIvGMpNw0Xai8X84tVYzCs6y+aAx6U21o3bRWB61i7aqUbtorR61GZPXznE+7QCVGCm3Nvv4 +fTiLt/vjyftoaLfdx9M4VMwAD5nak8U0DngmdMoOQVOV8De0/M84PtGzJCTwzVp+uGFeoJ3IuxT/ +shmalHbYH24NcdKeTLU73lQAoWaSI3o6te65NYhL3vXW4K+eDRtUGo7wvc1aD66hd8xlbHuGWoLI +gq7jtbgf56QCfb7tfwrVbs8vnsL+PygHHQiOSyWczKQdaAO1mO7QRnRC+eo0ZNhGVFlESZA0Z4NQ +pCvsT2Aoq1bqCMsQ0AIB32z7m3/5C5PuH+hubDu+DL5XVCwb5ULDiK1UCxNvraEROnJ0JTOgjNeM +zVRaK+tvLQQnH86CErQRhaSqIJW+FapCJcFybGcjdHGjcV8KQjIlbtSmNZzaoRS0mXX7agvbnH9O +pWs2bdogHuskGyeSHDAbMma7miUxbTMFprN0MmrObvuaYzezFs0utIVsmww7Hw3lZNNSAADFdGjf +pk+2kOvcYPbphcRno92ZqI4iTVtp5QhvpgoCZq4/HTRl+P2ujZIMGozGLRvFCDWY2kwdNWjPbQ12 +mx0MPrffwFjEzIctVwwBtW4MhyMlDlUMDYBOlqzU0K+4yjxHBZDq9shJoDstNrhdTA== + + + vQiEVau6LMId7HlzoYgsJDBknDhtSRmKIdXv27ea9rpjYOYMbYQ2bDYBu3Ey7cDhTdx1K4UduGf1 +0hequVkNB/osZI+dlgqOR80jYAyoaUDn/NKvKGHpGFIWS7z4+qJQEp1Q0JaBAW6j4VTvtgMj8J/j +VypXldrt3PijcwrEf3fc72S1aHJ08qhqKfhVtx6vwL8DZw/m9wpT7POKTiyGQdh+5yYmw+w7CvZ3 +gRUvdHQKO7wY9buSVDQ1HqSB4pIRpcloAJD452jSq0uSibGZ3uloOGp9go86qkmedIfuTF9p0DjQ +CrrthzNxAu6wK0UxZYEcbTZm1cZfHcnMhFdM2S8LvAwC53Oi05Zsc/SHiy5RrITVitp3ij617tXb +8lwpyqG5QWQ+VYPb2MsKwQICyJ1y1AYr1X3vSuyL84AwhTpc0L91uA5jO2lIl9aY9i56JbhKRBNm +XI5kSqlQAK1J/Z5Uea+1X7oKg/RGMlXF8WozWIvNqB60qY7lPjbL3NQ3shRrqvU275yDR8SuZ4Va +LdRU14Gi9rtUxxsMH7tggiphBuM5AY3mG2Mc1dl1EB0MhCP5gayVBaVHdAJx2gBSQkm/cMdJCp0p +GFrDvQSVWEd2Yk+8JsxuQUEkszkXmACM5Ujxllr4YKXW9Ul3AJF2q7LsHWWN2XTshnTV+YB9TJ05 +s043cWTM6CMcINtVqbjW81VO1J2HXQKb57bThKHuzjxKRURqvuQ8mLqduS3jBTIwoBDXP+eD5rDR +lSLsQvVPsNP8jUnHP/vs+EW3k38qBcL9+dkZ+qc4wqIxVBfq8kMu6m9M4WNF95Vi4uMoPmSGgGuB +/TWa+8eAc/oBP+ngPY26xuA+YBWerqajqB90Jn86BDOGF7OOYfKZv4tOzhv+fuMvGH/fGOPQEcir +pvPWJxze0bCAjqoUMLi3IUDqHIxu9K50353658MerBwSd73zW5Pu2HFjocYAI4jL1FXeGLs1k80Q +F5SGZVTdkLrmyJ9z8iEGxTptLDDwjjEGy2yqYCDjsYrtOpCwSorbylEcTwEjK67gIlu7h9SMVhfO +aAdfYmYujJLarDFsyyHRLnmxWErlrzNbl4dj7LgzQtXqgf26IiLQLiwwl8EbrAzmZdvQlflpNh3A +V/vTGbDI53Jy0P/3f/8/s//3/7LHmfgZ2F/vk2+tHX807PnhlW4qE57nk0pMoM7EVmaWyHWlkWdr ++aMjgS10YP/wJXN4vvMY2b89CO417qLH9M55LJeZlAefqY/hxnFpIxoK5ruN+HSbu64Uua1U5rqc +PmUOU9Wn4GlmMm/xpSJ1KgRIhtkiiGnhq/ARJbYzey/x3cx+dDzNTE+ohC+Q2atuTKRGx7PcR+Wy +mtlnOrV89yDdKsTjwQ9DV9X2PeiPL5QCKf6hPCt8PeeYh1g0OxhVp9mj2uwzkua25qUCs32b++oH +b32Bwjtx3DQFts0n3/mby8enbD0fv7HuVN0u9ZzZ75WeM6lpfBApRAPzUqjcfvcFELJKb0DDKLw/ +3/K5fqZ/l3rPfc7yn/wDqUHH206hRVa/M/uHwVsMBwx5mn/5eBmBXzvfhaP20UYuJnxtZ2uxrSEe +w12jPfcFkl+hSKvYYi9D+U/mdW8/G6B3Irmz6Fskkw9el/Kd+W765njrc6/VavTgr26k+F79xD2T +RKLBT7rbb6nuy3E71w8cBmOTyNM8W63tfMPxhzN7x5+0L8Dt3TxnssNWcBA5ON1L8IOngy7PJ6bv +dHbSOiIjvRQpQ2wVjqc3AG18sMPf0kQ71c0nGmB9ydODUCzayfX5iwGewX01kMkf7W/dFqNJdgrW +5eiR20rz+dFLZP+m/ZiimlvPCGx6GAATSnO7W3BJHrlb7nII8ZTO9cJcTCTNm3aVIJ+3TguJxv5O +aSPyMIG9cPDFC4KCmvgCRHPziEG/I+nSvvhr/7Z4gpvno8U3DIy6p44A6d4RkXS6GKUKhx8HIpzb +g/299tfZC1pJecAA3nmOFXsBjXLH8gCelQGQoYMr2KjDoGfsRq7wilANhOUhwz1wX61svfAVKbwn +Tr6LjUZwO8c1ry/3K4XXdLb+2ZplL7Zbp9k6RYPVz/LP91vgm/ZD8e7tcC6jCFOthkxfegowoR+f +VKQFux8V3mvFNsInANsIR9Jbe7d4hSBkX6D4SkZucszdcSkzmXxeM6nT20O0QgLbnXBg8Xajkdwo ++aJHpXbiarxLeMILC0H5AnuRg3moVOiTOeKYTYF/ykQXw0lzzVFmrz7bzNaPZ3MjKnUrqcK7tPB3 +kw34rA742He8m9XjaX6V7JRCO+Nw/pO7eig2if3dQmcyiRKdi4M9eSAYHTIyquXs6zGJqG0/9laC +O/UkXjj64ht47+MFFWrfg5Ps+UvutJR/PxYI8qTZLuXbg3vEPE3WoJzrcwe3CmxuVj14yFXqWwe6 +MfgCYBSd80K5F+iAri73IYehiffU7cg4Wn27FvgVnZXHm81kMrLHnOkwsnc0Hb3nu9MuB7ll7PGC +Cm8dVZRZ7XVSOwOwk6/CkLxOIwfHD8dSpx9PgI/R4G2guluevbYH2drbcSHRPQiVMID3YIXL1k9H +H5mb+lGjVBQu73yB/QhRfJLRMS5GR2dUaYdL3YE1nyeLrd73jtQB2iD9BmbMO4/BKmCPB8HsVX+8 +q2532agA9hdk+KvP3Xj25L429AVULFx6/5qp8zvn+ep3ndSIjN2dwns2+KKRAVel0mt44xNNA/Dc +YQdsKbapeyuuPnzf00ga1de7QIiWR8VovXUAsHh5Czb23XYkfcDR6G22Fs0M893uZRtObQM2qRdO +Tiqx0n6RDaO3cC4fu0PcvH6aCeT6x0QcrtWjsj954bC7y2Rumgn+onJ6RTZfrrP0zsZ2kQpvv+TJ +cr6agb/SgMTJA6LTTB2S0VD+UH6W9gW03+CW6Bn8MweZYh59iP7kalXqEr49QF/LHeThsxwGld2P +lXg2VriiXh/GRdhkH/Bk2Bw+KMhd5WCjMwUO7gX2pwWRkQeflr/YQ03gaC7QkNAYwFwAnCweCpwm +njAcFMROHT7bQ8CUXhAIPYrgkM06RX+KGIMQa1pkom/24Fs0jUMFlbgxHBzG4vBj71JGQQ3hU+5l +XzUXZfHStkvreiF0y+AL6BYCfwORpcBG00B40qLjAM1K+ROBknsuK2PwBbRrmTYjOdslwUNGv+RZ +4U6VPzGNmRKGC7KAjavyrBRS0dMsnoslsg7wTNHOkdBxoMwZNj43Q6pup/oCMgoPdNOUcZLSgjjU +jiavfIve6joV10XZdyqK0axqWqFa1BhiImuyVfbkEV7IzAMTKZ5LCeERgXWLatUYbOkFoRysPsSj +DDttxgDR1OSt6Y0M0YJgjO3LHaAxXnECGT5HvzD65Zny3E38HTDwL1qUe8nsMHv1/nEC1MqTsU5g +ZOs3J8NShiR7vkA5UH4FOGFDnEo3mV8G9kuvs/puZo+42IgUb+4qkiiLbavUCZVWoLeS1O0AJUPD +AKsvQARHVKYZmQQGy0mOCwLVL/xoaU3xew/VUpbubR8jO0A7oQgyEHwBYXRM8MVY9J0pnBx+M+pe +cq+d7NWwdp2tzY4GxUg1EdK+7ZcyycBYMiquworxhTs4eqx/Z8/zuQuow4ja1UCDGGCBQi1MO1OV +ssHvta6vsvzT8VXheLL7ZgYgy1aej7Int5dATxZHdh3olafnnYmo+lW5HBDbT3HZdojb2w72lgPU +LiTbAQLj+evnzknh/XJaS3QvHoHaXPzOY32bpjYf7Y0hS1PIF1AbQwqFwqlhC/sue14qfN2+5rtf +XGLvfRD4APrtLglwkn7j+av2CA4upuhHohpb6z8roAAli8B+J8uC25X9AenCRyx8iDu4pNNvQFE7 +D+Y/I/f5RDd9kBLXSosnjS3SA2QfLymGMOBj6jW4qCD0g07pLeg8qGKaF4lTNRAro2Injelc2QAX +lT6wLBT9X6v9qwaa7HVO8mBC7Ujp7TWdLJTv+Xdgjhcpgiozp3qwlxvhJ52RgmmsKHX7dll4v46U +AZ8uFahwu4h3ILJUoQxIYsb1sr/Ts9pXfOnleXerVBzO36hAciCIq78f3U48Cnyrepy7vMiAudwP +zkQDf34fyF6e1W5KhXBbeqEQ+2iH4Hvz5gVRPWmOFRtZ73OgHnpgXfKfTxupSLr8+ipR1nMcrGD8 +JNc7jQDV/uJd2bMp6Gl5yfWogw3lhewIIFLtQZ+AQuQMYvtB8XYAi8+k71X3jDWlM/XWHccvI4c3 +jW+pgzqf2Tu53wTm4+eGFvZ5tlZuf4F1OZhQmeuNJFoDtAIHoTnVgST3jl4APnb4OZ2jRU5eAqYK +enlpABD1afF1TDYze9fBuMpJRrH9zb33+cVXtn7duAcdpPpE6SlDg9FUYjJ31jswfIFkvzR6t6IY +Um5Zl3avGpjL3UurPYr2+5eguOxOocl0ao67VzUQuHs/ACWXwhf9vVKBfaAi6fvnXSNEF1a+CmxV +tXtz1ddPhE+wLmnueF6IX7VjmdTZV08WUXVuszTMi65BQHyx8feoW0jc7WUkfAY7ic/OyxvE51Qc +XLlwIHLQ2wMWinkqNzhPAymmUTzOmNz5nH4AqL6aFiO73LtKYil0B0mJ2976FjKp2+/u3nul+ZFJ +3ZXUoDDHxrZ7sukLIIm9H73nKgi2SnaLLYkQsNNnLbB+D3uFzvi8itQJbqvKbMFnVOGkfrqpdM/f +9Kt1IOgOt4uvxPC58F4vvPsCxejodJ5lM9nHYuuiH9apS6Jn8iPQAww1uclPE2c32Xo1A7dhMmYc +/H4oM4kl59mLq8RzqvsivIMVv90F66JSb7A4OkgAiqnuAgXl6br0uveZ0HdKpb8HYJE/NjLfh62O +8gKu1TwrNMcfcbJyExWfgSUG+lh9+ztWCo2SYd0rslk9ohQQsnyFQz6L5foD4h3QS++BS6fO7zN7 +4yRpnJrYDq4LaMkLl6Ndy0aoSardbn4bmzzECkTyIVjKd7hetl5okLm+sCUQVPS7m0mdX/bRgqk4 +jIGK0PnEQevuEWyawmn2qp75NtLG1jTfPTidZlKlQIM75O7K+bP8zaGsHXKifOH3u63HwlHr6iLH +3FIzw8K/bG0A4UFclkLHh9Vk5ak0E5VgcRHjgNBOuL2T7ex74WPrmeFT43geqEPdXQUU0vogsPfO +CBLd4354O/AKqXu/2Ew8jLWaNx6ZUN/ZrpVet3ZqYH6Rp+LL16yFfJBGfJZnxWZuN+QLpE4j9GO2 +Xt/Z0BDL4ZEMtip6qUSyqGImLP35ZEEgla1SPvsMVMTM0R3gY4VonZV9hni0yV62WM/yyauPJPOW +G4BJ5gjLJlAQNKCpFI4No3VZPQNWWP3msJfZT49vgazsD4kdExCdXC84O84x95vXlYMnJuhqpqKa +p4ESij/BXnpHZ8D8KI7U+47LjKA0PIa+TjBdlt4CJsJDUgGRIoWNs1L4/mKWPbkn2w== + + + qk4PTs7ahfYgGVWfWYCRhQCXP+99KPwXM+HR2yer2qny6QVmuJGz0VfhPXncLzR3u4Fk9W2yX8r2 +h5vIHaqjF7D68CgvdZZPPBVOTvYTWFWjLmuxUpF8D5VS2atNaUFvQ4Dz1xPcQSmbznGBMVs4avQD +Bv7TvwgD3DxfQV4aL5wcbeYBt9RuoP3o/OK+lCFmr2DNh83Sxm6UBCbsNfwmSYGdQ7+BbXgoqMDS +u6EwNi75Ov8inV1lAtrTNxEJe6XQ0SCb/Hw62yoVLk5rpcCYAczltvORoXMPjLIXRTUI/FIULHSG +l+VrW/ks+G8lsx+Lh017gY12ytBZ/AQaFWnjHtvqZZlQ7roYmjafISMh9cgiptEHtAJg48buLXup +VXNU+L1uCoIMHrehyXySHX2e76otJ7udishesvhsCV92vj+iUwC4VlShUSs/lQPlZwHQS2+uajyr +lp7B6me2kSqCziihnsxlTgvx8899FdWmueiotBuOckANYgLAlMj00WHjXifZuhGP4Ljja/VM1S6I +Q6q0F91UDHgDjanF9rj9XgqdlJPqRUa0evm0BV/0s7Xm+B1bixS3+ZEbbApfKk0pUxl/S7tSkS+o +l1t6v8HvXZ5fZGvza8ooUNhJ4WjQnQKxlRuAEfa50ttpIGmtAZyn9q8Axk7b1S3z5ZZ0CiE5SrSK +zVEl5tCuvnP7XGy8HW3mBpEdlYCWaEylfRye3YGV7qrO7XXAVPvOMFMoUN5fwSJWdr+Byn10Jklk +xD6/JsG70s583Mkx8xywdIClrbLJUZNBSAAcNF7s576+LjKFo/blrHAcCpXgMegRPjfK9hsDpBoV +ZztHG1LPx3OgjRuV16qZBiuqsZOtNqS7aPZy9xVIyNaAVLPj4/mMOHos7+v2gzgXoKC06qmzl+a8 +9PZCDSCN0fJh+oOalA46ORX7h/sc4yFA9B6BcLgLFd53xlvc7GR2UHrtxxOaXrov0Q+wGtNdPvUS +qcHzoIh+XejwkAYKAdPIMsHgKEneniSyQnk6g2EDQKE7atxlpuG7zcLJ8fN3obP/sqksGNL53xgg +ot/HgH08JbhU83zH7dfw2yQwriqV0uvsOVbKBDt17WEchzYK5jCSYXABRHMm9imA/qLl8oNQfyo2 +69nbwge709VxL5lxSTxLltKYT4lLUkRr4QugI8j85+P+dyl7kRmnTqfzkdY1yHHfZPKq0Mo3eoXd +bqLF79PFTvHh/agouydRkxrY8bUSlE2NrBCLb0JfSBmxLYSxiwe+/lZJlArzLDqWvAQaRzBWKA2z +p0B+1sO53t5+TFRQdBA/AIOrzettJXADc0MR6OVmjg2XEoCPtVOFDxW3FN/Xt0Qsi7i7zl6Nqm9c ++jvcU5vMEMe54H61GH3OAXufowaKcxYhC8jepy7AWPp797jQvOtcgd2WrpTvX8dviEfK28cC8/Li +iH7CA8DAY6UtbnJZOQSqzyFg0SffOTQkyTtKXYZmkJ72ueuLdgLs1OtoKUCGgN18eRUtHG+8E+oZ +4MZjkrv5fs8ikVAKVPmUDrbcGNBYaefhY1h4Hz1HkOvI1H8tsvqcAL3D9fI8Pn7JnjyEBWX1YQhA +sNiab74I5xW6nqSjx3ul1+hNSjcXGU69ONKJbS2ct/zHZykIT70FzZBlAGOunB19TxMwuuO88Ny9 +31KfVisMIHXcuDlV5q8xoy+B/ntaCpYDpcpANouAgXS7HS8cR7ZYdc/92Xax1Yy2YRTBLXUoPh1s +7sCFf4X62r7G0/3MZ/ZeYvNsPc+/AquzDSzsRKyRHWU7JWVwGAodyu5l9p6vc/zwqE4Wnj+eKWDv +1/qZhAQM8IuLNth/3X0wYY0qWiztlKtjJRwpvrGTvOG44+4HV4/dP1DFjVgu8TlsN7aTH7cTMNYK +vKYrR+a7G49BsF8iu63vArEdGyLxzm7kd0lgEww2gbp/3SxDz2mApP/PtBwtpw2FK6BrxbU5b0l9 +1uO4MezokgLF+6y012Gqr8i601/FAp4V6gVdRiS8mevjXQrmM0QP7slVd7WVWGHQH67QCvPtpHc+ +FMOofmIa1xdJs288MI+bCSIROY0ATj2j4S+K2b9M0fKLS/kXerFHH9ZnOWBZlHuVrauDBqCX+7T8 +loocXHGfG2G6crARSwSBDgO4T29/I3z2kNyIfnbBq7f3+EZknqptRE/vChsx4pQiEgf3IdQ9WLXw +JTOlpqdgcIUeWMm3NJ0TaAEw2cEDirVBB0rKW6Ly2gGWxWSSPmhmo+Oz48xJcpoWKvu38dLogbkp +Tp4eiMJD6b5eOsgetMjdLD8Ue6G3LyP52O4V6K/KWU0XTyhOV5PbUOvTN6pOJ5O9aR10Ej0iEkwN +T0MZ2VQozW6ol1Fvh2jvkKjncwXs5JmY7gPYwjySLm/soImjdSn04ompUGaE770v8Ge5D76+L2g7 +fZo8nz5dmnda5l/Y1NFL3LTTl+0zIPd13Sqdct2TcsC80/2N0GRKBibmnV6QT8wmldpVOvUFlG6n +wehpzKJT9jPUCN4XzTtlwk+RferDfKabpRfGF9i6HverZnMlSrmTjEWn3Nb2cBI+sOj0/oUovZ/V +lE5RHKzcbXljf4c8fq2bdlquUHVL9FIP6fob6hTQYrOoXdNbQMlP83QVdhs2rmronn7sk2HQKTMy +kFKVyImdXgSDuk5ZdvA6VjpVKBl3+zp5/hzWLTrNNDi+tE2advpy+HZl1WkFaH10aO/JfK77G8/T +rc/OlXmnl/lw+nt7UDXrNLLXT6WVTsG6aElp9/Ahc27eKXN/T5SSxJlpp5ulD377akCdm3XqCxCl +5+eSxVy5rUBveJq36rRBlKNvN+adlolssBPi71GnvoAewbOt6KHY6X0spEPw4RlzIKK3+NQraTp9 +2CeqfIyEne7qOvUFppuVzoi7asQo0C0/1tNv9fGhYdEpt8X32qUXq04LxOnucxJ1imxk7VyPvlOZ +r8nZlWmntb0gbdnpSadGE2adQs7PPMaI2mt402yu082TSufs8SEcMu30Jjj8sOy09nn51kSd+gLG +uT6WiZuT8b55p1U6cF3K7B+Ydzo+3jTrFPBk2O3Na3lzZoHgx3Pi9vCkYN7pabr4+nL5/Gza6fN5 +7wh1CuWLca5f92y7ZNHpk0A8T/sx807PvsaD86RA6zoFvaBuX49iQ0sETwK1yIZFp/fXRLE7ODbt +VDiLbW5knmOAj4FuU9/6TTN/5V/FTpt0WLdpwg/Vxi7qlAqmQxXtTKvE224qCzuNKp2CXmC3AOzX +t8T0Dyb6TqejnQOx09lhRDfTjafGYxh3mrsnj7SMMDqZXqc3QC+g27iRKx3F0FxBp/mZgRVWNjnc +6SF5EtMxwuiYOcOSht5O5U9Qp7AXsdvtyaTRHMJOCV2nk0m2M5Lo93hD1+mU/UqJkuYwdRnXoXdz +1Hmr+0T9odN45bSDqlzvvIxSlm/vL8nBjdXbT6LyFpgrbw2cH7Dewo7F12ANdiJ5aVxfHV73lhPI +17r4dtoTDLuSG35u3pm9x0zx4ij1ZPlWoHav3qzffjZegjLGjO+z1M5Dy/JtNTI8pKzfNs/f95S3 +OoxxW+ebrWbF4muhslPZv57it+/B76Tu2+tIV1JO38nNlAFj183j2tDsPeZyhUhvYvn2NtBMbFi/ +fSqkDiSMmbx/C7zw25Zvv2YX44rl294NlbtU3howNuiV0i9WX4MhXe6xlm+PKSZ9Z42xQGvYrFWt +vt7Z2Dl62rV8W8yeNjuWb4+pw03SGmPZDWo7nLJ4y1aI4sGuNOdUaE/3NlK/nB6Kb/Pxff2urNTf +yrtZ5T0zZaJXWgssT7SDj3mR/7wF+vDtWDRHS68sZj250fQM/9LwMWq2DS3M/EbsOHkPLMyvOvwn +Dp+VNqKFqzz85xbZb7L1hnmE2F/jKidxvskmFTy4iIn8HNg5Gn0svUUHwYfHA7Q3oKWj2hGJU2EY +BHbs3Ryw1s0d0N/7vtzfVqJ70AwD7rRZnMzf4jENu51s+gJKt8jSseiU24J2zqN5p8z9g2WnQIh8 +kTp9TD1XZOlYdgpFXsuq07a6U6YGbGRVt8JZrqbqtL2zs6V0irR/uVNah16o/cszLfc1nYbvkfWq +7laD4APKslOk/Vt0CuxBoP2/KJ2CuWjm+mzZKUDwlLHuFGr/lp36AlD//zSf6/5G3K7TatCyU6RT +KJ3Cva/pFuoUdc2qdpJS9+iXuBDh/EN74Kbdy3wwVO99i5bc1vdL8e7csR37KdKdyC1yYM5PWZFb +GrbuW2gAsXOlctCkS/OJyFx2ahndjk90t1JR5Z/0ONSui8Y65EnY3k+Pw/tjGWIIgUgnK9tfaBTp +ZPmxABhXowh7phXWJHafLgbEf6KnI7EDpAJLHci6JRgPmNzBGDfSeZ8A28slPjuFgPzPlVpjFn1m +53LjAuylrJ7u2/Gh6FMCQ76+AA92oEI735Wwg/V2kR2rZnCxo0Wg7HEDAyaO2UAA/QMJ8lZrJZkN +qpc80g1KPaTXeRCQ7mmUCh4SKj+azh2IUA645fM8d+KEdPiPOHhszJvML7hhOT9fQJkh+sdyBaX1 +q206r9+WPL9dkcbMZgiV12sbZLlfvxGiT2xZuESWDTByN/dVsgTlc0PuErL2Yp4oS6ErjUTGlFV+ ++vaOeVO8A+XmQaTkpTFP5R6Sx/Z491kjS8t6wkbW81LUsh7akvX4nEi3+HQ0USNQHrIGgTuY9Zjj +7gXmi0kIthhPtBjF/4i4I4fmuLuPbViybatdifxxplO73/Q+NbUUQ5OjD2/qp06oLp/siKcJpgMp +RHSzUksx1aw6F/EdcfUNbLQIerkZeZqQGYcBtAPMuTsVbuVtqKbzt/AOGNxdwWKZomOysR2soDFg +P/+CiCGspfTnKHIgUY6KkpFTxxwY6RaYGSiEd9Upz65x3zVKbved/a4DsrKxeTe3XcstMnpNRuE/ +jxHVIYWBLABnDBVPzJYTYEy9oPAfsKCKI9pIG2B+Mhc00sb5pTwk1bjQXGZl05Gly82p1SQzRGd2 +nTBoYcYlUSy+04hxSdplJy3MLevpCVNfwFIwudAZlcZAm3mcWYolX8DL+pYhTiretSezvd8ua/m0 +CbJOR4rgtRnS7PDYUlaeX4njcaPSgSFZK3TS0vkC7lYQWPm2ioWTzq9ZwWHAVrHwsH7li4ECClPy +EsBqQxfjArvSFTCtQPE6LumEVwR2b2/EeJmkWqtbGmOvkxViTMvRPI5rrPXDvPETg+E6S08X1I41 +5y9gPBUzY9BKoTUV0FTu7nPDgY+pFGzzXTk73FzZrszdfW97M5TxeaxhJSvwyKSq4AZa4t6xc7+5 +49b4kHVLPXbSU1ksO7oRzBXDio4pmO4X52VKT+1NPN1AREo2DsWBC7gaiE63XAwnDtteNRBsI0cs +RNRHBbquHz3Y5PhQUhtkJMf2UM/TZlzl0Aa/jiDNFz10YOHUAJrgho0OY8o+LDbIkQ== + + + vdrhC3gZ1NaCDEDLLeGWe54F7MWyWwZwpDAAt/a+9fyCLlDuc4d0ja7g7M/Qa/KKr+/rCB7q3a6C +qAozsvg8LSucQRMLZ2r4WNjkgPY/abf0KZ5Y2SHL/Ra3NHuQlQSQ5XGLa5Alb3H0Bb2d7CW0G/wY +zkW7xU2tbmfvEqDaTXceEjtfwrHeJasfjZ1LVuchGRxrNXgLo9jZJQumptpI4up7dpMcw7iEU7fu +DdlK0g/leK4Vywu4NwAdfFNoQihSxbBa7tdKJ1Mt/D6+gJ2XbnAMD3fvl/L7QLQ4+/p0rMDCXwOx +w7miZBXf1HgaxhpVOjPXq9KADqydiSJPdqFMQyyf6FVpL7jD+hgaT8B+PG79C/ThNR/UUYTKFvMk +CE90mvBi+yV1GbafmjOdnyjCT5YvC3ijxyd6uWc1IV/AhtIB7WiF3iIM4PA6wPoc1twdYl4dnPQ+ +naiz0mUBdnSCzkkOqXVZPBeVqIOHVUF1/AacFXjmhhgsd52KkvNgPHFvPm/jnO9qZtJOeyrq+ggS +ALPyt5p5W7FlYeVvhcA8bD5zewlsGl9g6UMKtGr2Is/nGo7WkPQ2GvFMHMNZdgdiKLI1qUCReLIX +ON7lnmzvmwDTnBB6E6La88Eg0i6iIa3GmUdhqis5Ycij4FNfwHkbuhA3EBgV93zGZ6FEwFjOXVeo +VKmfqW+NFNNztGkvbOBo057+AM8FRzP1kOQBYjLfy3K0a4WjSdarFw1eD8yZo/lcniBBYItzNHlX +lm9GK+BoYNXMOJrnvQ/geOdoBt8FhrM8R4NQlj97RXBsToOiuZB8ipPwBcy0AY0QuhnZWdDqo0Nz +HYWJXmnjLYHNY/CNw2fLHsBK8uU9+G3NhlxqZnmwz89nZpsZe+C9sVkA7GbDE5P1BSzZ7ILRD9rN +fINsaY0lvoiCAlZNF9RkxWGc4bhT7S2hID8MgLN8CASCYmFQ607eneFoD91dupdNThMQsFX4qrEs +BPOLQO1CKw3B09gy+r2KSBubV9OlLb67W7feLJXvwlIa3nrS7+19sBDY8vr907eZLPQqxeCqeXdp +GaUYhLOMfq+CIsvCxaUYgmOi35tBka1XCzhupaG9LEQc5ul7aWmokYWv+nNi1At4upJwJMh/TOOw +RFmpCZ5SwjAsdYHXic2SqFEZdXH6dne3jK9a5+cHwJbd3apxmext+1hrG4y5UnellYS9WFlEYC3j +rva5zelpHuDzJmHjuXIRTqcbkiVFoNgex+2lF0z5eMwglvLxhCu70oVgonJ3bcvwPOvINQt7H4yM +codKF5urOV1dtC0AZnl2I3t73AbUA2D09t5JdRUeEoAx3puKYRGDCFfyNe7KB4uBWWz2e9vgW0wR +Psl/72pQLinCsLlEiYy3riLP0uzp0NSyENcAZctNPzZiw8vXjejNS3EjlqVfYN5c0SyDDt/csnwO +nVqKGTPodBlDC+fQ2WfQIZ68ghw6y05RBp1ltqDHHDr7DDp1tuAyOXT2GXQarW+JHDr7DDpNtuAS +OXT2GXQ22YKecujsM+hQtuAKcujs24m51Uvn0Bk2riaDTrYslsyhs8+gQ/qYcw6dJiDZJsPsIlgy +07atY+CtM4F0wS4uhmTq6S04B27vusuXKuls5IWDYQt67dfEOeDW0/tY0Ep7b0unOuMr6AM2FsbT +3q6GXLW5orKMD7lJBut8dW6cnCjaMz47YPZxWO7mh3x9Tplzruen81wZ94t7pCe8D8ki89HBc2U3 +JLOUOTgXT0lzrnhNURcKosT2eEugmnkKBcHxY6bBIN7dxlZOY3Qz2NL+qvvYlv3UfC6T3bSRkF4d +g4iSwZov6zHGyW5WxzZaK8kp2c3aPrU/cFBxy6JtMIjGNHUyQ4q6bAZNprA7YNoQLNJ4YtOkvp0y +H93xrEbJk9GLdqWV2dukrUMoPaWYoty3U5dZh862PUCW2Vm2rI8ZXWdOjsOeMNa5ScC316ZBswuc +WJUt1S7LLDCVpqTPA3NUu1zn8c2dYuA95PE1nfJftjROK+vUNOskGHtV2hgDHzz43LIaVMYsRdN6 +/Rxj4F1HEbTLWg+m6fq5zeMTJk45MXbEoI1Oh8BWliE6UU4+rDJTvABzpnj3GNM6WJfEmGOaqPtJ +KhxtIYxpHb9U7u4+pg10qugC600yudzpsgafr9HMkrf6lbnf0j5fTgfCAkBvUyuRTUC8US8k/OfN +dndXXBh7ssXnYOx9VFwbe1YA9DGKC4BwuhoFrLN8q4a7VLmFVuiVcJYvkkpjvi1gipuzk8Fn65KG +WWkWRpyB7O1y5HwOac4ujjzRhOyvPPEZzCsbPTI1NYTyhwozFyhXnYxYUfLXkTf3jomphDUlhwQ5 +A9exzoiamUrzBfSxI7c7XtnvlvrY15E39451mp0+gmhhPH06eBp8OlPCmgQ8emQ0Q9LkI4NBUV7c +HzZD0m5mZylmgyfG7ZDso9Odk+LshqS/uyOu8//ilKRVeGSOkUdmySg1oAlvu/DIiGd8Duk526n4 +zjIeGZW9f7y8RwYACNlEd3hIQ1vEI2PIFlzeIwPT0HQeGauMVKf8PMaTR8bUz3/sIj3HXXIOTNED +G86Zkt2F78FSHYRWWT5RlGXruHE3yjJ9eB3ZckEM9jmJ45PVRDLAdUldBlfj1AFTS4UcYnrdpKEt +GMCuli8wgczau+QhfcwQumCaLeiUV+c5aNYYoYry6lzG69nm1alSR20yhZ2doCe2l1Spdq9Kt7QN +1bsw3kUKn7kUdFLOu1Vg0mry4WAvq4ips8+H837/2CL5cGZR0BeDVefDLZFn4SEfzi5CdXX5cNBr +veQOdJEPZ3IjqGUS1+L5cJpoKOmb4Krz4fT3juKMuFXnwzneErCSfDjNiZWLUMvF8uH0tpjVsQ7M +ZFs+sx4KuJXFRAJQ2phIK93STUzkzchVTKTT3p/26GXVgDwKkFg+Gx3BiTqtvks4bvJILKFgfQzB +WUEmlyGSwSYG3pmjweQ6a4eYMd5ZVcvGIuI5+L1riHgOfjsshG4TWnp77m6W2YZK8pHKq7DsNgTA +bK+VMeNjltvwfux2G9po4xDf3uxFU0JbzW3ACI637WORjwzgrCQRspBwJ8Uc4VhfCWxxm5ZVmLXx +SmDH29C0XmndbY3hqNGHBZPP7C92cjSo5YxUcnPRABHVnK0uFl4oI7Wx+eoiidRlRmpjs+nGZeCQ +6reSjNSn79VkpEI4q8hIhfliy2ekQiiryEiFcNxdA60zic3i+tAGsb401XOQUTgmrr52G94tvQ11 +qXDmfGzVqXAont82omcVqXCm67LyVLjF/ZZajNnb7h7syiVS4dR3EKFkuF+SCmfiVfgFqXDm/jGX +9tm9nWKoZgXq+5PtEp8+LWNV3dwIr9XH8nEHs8htoBcExbryKLpwIENg1jfbedRhDJcMez1cUGWj +37s8wrG7nRewcjORp/TinNysz6t7srwORy8cJO+oiXhQ9i+sGhc1609cA1TiMn3+We7fNF4LW+15 +sZTczryU6umLYiYxCwLOX6of8veobHjhoTjJZCtc/Tifi7fy+VziBBYhqI0lcRToa4csepy0uVhm +WWfQShJzlB6t886Ey9SFmry0yW57rfNTtfNZ1Sn7uRvY3xhZZdgx93d2yW7thGWnRKmes8uwC5x3 +TxtWnb7ZdFqOJVWd6nOxUpGpygunT3Zj7j6rcmVCXQrYZsgu2Y2M6zrV1uPbG1hl2HFbW9/c/Mkq +2e3RLutsYJ9hN6rXLTvdqXY+21adduzr8V3eWXdaPHssW6J3e0jvvVp1eqnNsEOrCjasOGv0S6Tz +lMt2e2btsFdB05J5qrqCyIQvcDtRdFY5E0X0TLKS0qV5Xy9Q7XzHLkJutRpsZIjnojkjutgZrSa1 +xzlCVe81sa5j9e1iSKpzMZtBOQWnOsV5YOt1lZXkzMqOmNyp4sK7ZFdJzpMX7rHgOkTSIRsS3Qnp +Ia7PqYicbVyfe3pyKCJnOT+zum9OxUbczs+51oBrpDvVGdHdpbZE/Tj3+6XcsS5EZBnu6rYAnb2n +d5FsusX8MF6z6czsAKkW5+qy6VzeD7NkNp2ZT1C/X5bPpjPLpVs089E6m87MF28eab9MNp0GLeKe +Nb1/bKlsOjNQDjeELJBNt6BE9phNZ3ZOI8vKlWXTmeXSqe391WTTmeXSuYzt8ZBNZ+Zrlyqwry6b +zmx1kad3pdl0ZsqNOnZ0Ndl0Zrl0FrfNL5FNZxzS55a1prRoNp2ZcuoLrDqbzmz9TKKhlsym04Ny +rCm8UDadlW652mw69xhbJptOB0p/Jr6ibLqFMOY5m842x2pl2XTmudWrzqYzAwB6WXE2ndlpiS4G +fgXZdGbsQWu9riKbzuFkZEXZdM7yZRXZdGbIULTxVWXTOWVyrSabziyXzrIe3/IGYEwxADX1xTxd +3WRdxctYpFJfm8Nl4tO3w2bXIJ8ZWdWyWbxenWFIM3jKs+p6ddbahTs8zSJBT3hSsKSJhIQ5mY6K +hUsS0CQoWGQ9Ww1KNyS3rMBFdTntwdRCQ4IYA4PyVHbZbkjmgRSWHMYGTzZlly1YJpRiWovokDye +6iwiejs5dihsbu+Zk6tl2RW6W7rMneqeK5cq+SJl7iyry524ylVyWebOKpPLXSKdqwAJ+/hkpdDd +cmtVvh+7qTJj66VyVebO0aMIEbN0mTtRh7EvdLd0mTuc++ZQ6M7d4dH4ZAX3XNGH16T9IrrPszhZ +WYjS+ERRuRfO5QFTOwi7pU/LUx5YoM4x9tCJPmEaHTSebT3wrhLp3EQ0+5wzDK2DOFznF4JebMIO +PQSRQexYuv60lOyuwhboeSuozyeCl6Zaztnsbiir857yxWDBxC5NNBQgKod4cNfRUACUY/yY62go +AMxdRLd9YDPifSvJfFz+KARWFLS5DlxcfZdwXNV2NYOiiuyqrWIHIiiGTHbTTGHnXHYEzFVirVUN +CH1ibW1oTKytDVd3KyAEtpJCxojGwGjdMDO17LJEZd0MlY71Xu1iqHeNR7owE88YQW1riVvFUHem +vZVkpsg3H3vXJIygqvNVVTAELy6sj4hd7/1rT4WqrU7fYOG1pdUJDMUuqtMDnBXcEoDhLFutGkOR +NqHZDYfeYlWvXSQyeDrhDUdMtuGNi0QGVx74pSvcSfmVVjXuFtiGJsEVi9at9lbhzi7zcYltKBGa +WOFuJZXyHPOJ3FXKWzafSK6Ut/w2tKlwp81LcpMfskiFO7t6r7DGnfcKd25vNYfZT8sn1j59K2qO +lfXqOrEWAHNWc3xuFB1cm26xxFp95iO7rP8I5heemqZDe7vnCsFZgG8a7oiAcFaSz3lKuLPFHOFY +58Lqkph8TtdMoHJ5XvLbzZKY1KeikEFEDdswFXJYCBd+Lanum8s0JjdJTMGDF70lqpJibtKYtJN0 +8J0qoOR1sUxjSoVcZajbmu3yrkyF3OxKN0lMwYOhXvle1K6885TEZBVBBGsn2khabw== + + + iuGdmMO7xK38OsXQ5LLEu3tcA2IVOa75uPWtYtB+8VqRzlO5R4RKa33sfnVXU92j07cV5bjeW15N +5V2HaU49lXt0qJSXWDDHVbU/5TAMF1nPzjmuYEius57tclxFDxBciCpv3p+k+sGMt8pBvdAj87nE +8W1hq3Nc8wUKh5Fa/WD0FuHAr/IFyu4r3T2V2lQwvVnAgge5dlW+Y/GXJgnv7PBK3akmH84XmG7d +3F+oXVXaOmyp/OO9RT5c2DoJbzJ/S5FanqxLwyN2rXL/uK1t/ir8bJWE92TZKZjLZmlMW86VKG89 +XFt2Gjxqxj+s6rCFlU7lTC4FwRcspepUm5o2DfI7Sh1BWpflGA4dPvbNOvUFIIL1Nec0aXgNfe6f +Gr0n+xcWnXJbAeas8Kb4YPUZca82nZa3OetOy5dbD2adorpvQkWTWqnv9MqujuDJjXWnxeJ1SRPZ +Bbrdhu+j8i8xCXO+e5DQrr5FOzpPWLZT51cSb7uprAuIkdRoVlTEJJjzPaNXOuXDGtHboxWeeRs/ +sSzoXIZNAqSyYXQapKli5hw46UI2A9gH+sQmRw+JdUqSMbTKckiQkq0HlXeT2uSc2DRdVWUW5NB1 +qMzi1pNUsA+tslw6Q2UW0EHNSwiaXdad7ubJJbLSHCI0MZZ87uhJd+jldX6y1xrm3XmusmgxJEOU +ln6/uEa6pygtX8BuUNZ+Ym9DAtzSOk5LHI8hNlbHropP6V3t4XXRWDNlMVMCwD5ycfW1gw/2pbiq +yxvvYxvubjh0kY1k6152e8rzUlzmJlolJ9FwZdxCyW7mR9ae7rV+KS7oWdbeogmzAJe9hNbsrjjL +fDEnq8V4V5yNAWTuH9MGjZgcsTZKnuodWHOY0sps5EZJz2EWPfXGCXdW+xidWDmXr9OMTO/nd3bZ +oXp8ll4V5tsQQNATJt71EYvaT8GDO+vDQW+JZIZ6FkuUZbPPZPKUY5X0dM+Baki6/Jd22c537KiN +a4akCtUXT6tVu9ZjKmBv20Uqp/qeK5tUQKeSxg7rp5y8t8vOiTquiUFX19i0yowHYE5VdIL67Fob +YDqpshzGHHN53E9Se3K5JMYc6+l4wliVebIAZkgXNtMORYwtmAXoNgfQ9T0kVglirnIAbaLTXWQB +us0BNPqTvWQBus0BVN9w6D0L0G0OIPJaL5wFqCEVGwtTHwfrLQvQbQ4gxNjiWYAKPu35hjbHymsW +oNscQNlGXigL0GJIhhxA9XklHo9xVssX5XNfkW2ZonyqufzConwGr8IvKcrnVJFtNUX5cM6IvYKy +fFE+X8BEK1x5UT5jfeRfUZTPuj7yKovyuapfuUxRPrVXAQ6KsxyUiCKn1GDrqn7L3w11vIq7oVzW +9XN1N9TSdf1UU1vB3VBWdf28xSktWtfPvqrfQndDmdT1s/cKmVvi3uv6mROf7d1QC9T1c6bkVdT1 +s48MkT1XS9b1c8rkWpFD17aqny/gyaFrWdfPfmo638XCdf00AzFU9VugAohpXT/7CZlFqC5S1880 +HdHuVnP3iHGdKWt6F/QCdf3sb/6Sz8SXrOtnK+jySIqtoK6fvVvY0w1UNnX97E1d0yjoBer6maVJ +KltvuXp8K8h591TXzx4K9POvoq6f/YGKzzWcZRLf9Rmpi9b1M1E1VVX91NUZiCXq+um2IaGt6qe5 +s8tzegoh1/VzzHtdSV0/+6p+MiUvWdfPPuBalZG6VF0/JX/LjBZ191wtXNfPHoFIg11BXT+bvTbt +0Suqx7drD8V1PT6HcnKu6/EtVddPhmK6fbxmcxjq+tnkPThG23a81vWz1+ThjQerqOtnJcNvjCeJ +i+VvuVDnpZNEp23oVNfP/rxZG0WweF0/Lbb11uKi9fi8BWlY1+NbwfaRq/otX4/PTRKT0+0NxlgN +b6X49Bmpy9X10zi2DVX9cMbQ8nX95FQpu7qiS9f1s1dzLGjMc10/+6p+S9/aJNb1W9LX57Kun4u8 +1xXU9bOv6ue5Ht9CWbg6bmms67d4Mryqqp+ql6Xq+hldyeqqfla3nHmt62cf3qWTYgvX9bMPdNL5 +lBau62eyLqqqfvb3wrmv67e431KLMe85TxZ25RJ1/RTGZVbVb+HoQV1dP1uKUFUAWa6un71iiK3X +5ev62SfEihJ56bp+2knqq/oZ9DHXN1lp6/pZK0FYh3G4ycplXT9XOszSdf3UK2k8wLHJrrXYn+Z1 +/eyFg20W58oSYrHcT5iIhwc7He382jziQ3+v1Ce+UVEnK8FTa9eufeC9Lm1RQ00SjSmnN+mDsToP +HvumxK5CGgkZHymIIRLnHU7G55nGEq1OYe4bNf3cAGLleCPyeLZNJO56PG4E86k2tk/TR3EiNNxI +tB7HDD35PC6l+8/Jy+vdUGwQDua+c0Tl4yy79T3PcRtPjTYNfr1lAqywV9k5Pf++Yr9794++AM/G +mZZwWrqLn8QnG2y1zLzlrnrXh+3aKXf7We+csd83oc779m02zBS+NutXJ71Uf/9u1DkMDb9f+e/A +JDPkzjZuzw6D23SozAXeH4+OwvPPrUdm9NRJiXsf5Xamr+u1m4145CWzQX1830T26WCGKOVOckTp +vXVMlLmdq8nkLRmaTIXbo+nWC9ecss3HCznTsh45SMRu43Q1uSmlvX0lJtOnESw2l9zCudVGHqLJ +L917qL4ms63LMTSo5RKQsJ7k/I0M7GYz1WMzZCFkgOnOduC60NsblnNFGY2hRrBzsXXzUE9vDyeJ +0g7FfMy3+u2NNswkPZaSQzfm0TFzBuPVTocoJ3EjW6rXA8R2p43s/YuRVmUf67YPmNpFXpU0p/hb +VVMDbM0MD2kukJ/7AoWHUucOFdDMP5ev7rizfHszk5jtH2cS0/ZeKbnVuyjeZugXgLZhuty/uXvK +VriNJoBz8y2BxeUzQ2Skx8NUxvuXzF51Y4JmlR2MICVnT25vXyPFm7sK/AUmfNGPw6TdKDbr0+z9 +BFlORGIWgtEIrzPMiRNsPCj9IkPIdwwwwg/Bn/wuyvoFDOdoDP48iCIOsxUEUuxxAh7k49KHpUSp +SJ0KAGyFiBSigXkpVDk6IqPBz0Gx1ftOEok0H0YDhYN7Jnfz5F6+20iQ4MVBRPWisZ0/8AWkV/mY +8orKPVwfSi+OEsoLenvvIyu9OCflFy8i2soHu8ozpWco98v5qOoV7FuEUwa7HmBiF8z0KQLnHKae +p1+AAZavSHQTDlk5vKLBdC93VdNtfkQgZi8Byg9GPbK1zafkczHACiF55chW7ICEjRIwb2lAtg6P +INouSfGby2sEFia17m/BniMwtxiJpW0qHGOg9l+PKZ1S4cPMHu5lDx54X+X68Y/d7EXrvVo4Odqo +KSQpHwvktYZrQGtw5qhwpbRvBg9Q8qIQL6sHMsQcO7vY7pSfH4SPbG2+3S0+tC8IOCsSUS+m5Dfq +ef6SEVfj/oWWyKvOqKZeOORb0j64jSEEUoXLPJSAtwmJ7G8B7OYzrM12S4rqLnsrahcj+JuWfzEY +RHFvwIE/H0SIr60SXJKHhPT1AyH/IlWjeaNeutJoHmj0whcQXxV62+I+6H2xeC5aSas9M93RsBmZ +C1iwGSArIaPRsZnU8/koVLzNnR7nwv0JzOnnKrkiEa8b2Yy+Sm8QURvgAgK60TUsn4sBbinu+Lte +BJNk7u5lCma1GU90Ny926O3kYEYQofhUnC5gLihuGrknwZ9MGGUFk8WnDPwzBTbS9lca8o2oavWf +wDc3kCYqcaQGwUiVODLcyfJLHBrmlYSFC6ZCyAS5o3KnpNmTEAwV/SajxPDNF5AW6mQX77toPtCU +n4n7F+hwcDufgIXnbyr5t162rWFCVYJgmydwIU5UdECWc99Q4/g4Rxg7Ax3cjxAnhlN/yopqCWA9 ++BlmrpDhYEljK4cU56xppL20jCHtGXx1CtWcDBDgwhzrNTvsqKRS7tCzzXx2E3x2NYONbzR3H0ia +UlgNItot6kBE8tuHRVlAV6hQ8p5WVDb0bHMzfVgm2oFhYTI5GO2qVQigH6B7FUoBBQTR2WQTOhB3 +dxdZGUQ3pNkq5T5EagivX/FpL0bv7D2SAMeFKKQcya5ETyGNxfHT5+kr3OJPU4nNvM40mN8KimWO +qY9LWVN6VpQkVGAaqpqb8MU9wp1KTw4qSstu5na3IekmB5SkluD7GYD422TK+mLLsBCutC7zDdjp +Bl4BZvq4A6VY6XVDuiMjuSWOp399plbe76NDEWO5MHR64EshKs/xza9rgKdICXQaj6ENbrwtAnrh +wMjKEREJhWlNRsKTGgnzx3MZCbobOyIqFDxO6Kbq7g4ZBb5AOP/QfpGQAMajRgI/sUSChILdbRUK +DvPfIxUKDkOFCUIBoGSxW6n+N1oSZyQAJtRL4E5p/rwnooCak2Z0gG/VuNciIaEQ9t3GKFHESJjk +7h8VJISa21dPFnQgXkcrVy0HfMyMlGxBRLzTojZyWDoHUEbheQwxMwBoXVyDiC+4pZT45DCx5GpE +rWkacX5pFDY0HY1agHCFB8T5o3EX06Azl6GQCKJxeK4dA2k/BmxX2vKnKCWB4LaU1Zhulk/ymnaJ +XaUdLJV+YVHnHSxOaFkaCy9PY4kFx6CiMXJZGgsvT2O7liBcAMA0FnNBphoQ+mk4oFKkMVtMEEtS +RCLiC7jAhC0IN5zPF7AFYYVKV6sBAcTV3p6FiCrhmrCR3DcFQSw7DdXO8AUWmwblaQxo7+tHQTvv +zwpzcJqP4DFM0qzm0q83Si8DFInsFhNU1PsYdNySWpaoqLgZRXjilpQb5cZMDincklp2i1Ok9k9K +x8coWjQWQu06MEgzU+yRQVaZoumny7chbEUoNl3xJbUvmn3nnaFo2971YtRrpR0lEo3vGLKG4R0R +088Y/DqObBD68HoT2X5B6ThxK4iCfpApjL1rsimMfWvBg6tv8Gcmhv98nnaQoRikt/f330qv4UdU +/+Ul8yGbqyHZ6/dMtEOhlGSfpnZVjjXVDNKZqMqtFjyspqUXpbjyAt13IbtggLGr8rgd3oxzkqcs +haYRVvdczkRUbjVVz+WS4tB7QTWhkReumhC9CuVzAroHIjgzBRjPFLbkmi+BhjTdywh2nDXHJCT7 +y5isXm9TwXQIJjVexkXfGpeHlHNJ4OpyE7JVOUcPRLCth0dS9InelyKJ01oP8oM6Nv+pMJdqS53W +47gXIrwtEFS/FihGk/9/bVe61rbOhK/A9+CUAtmwLXmT2coSQtIGSAmBJFBCQszSQAJZvrZ/zrV/ +M5K8JKQ0B3oeHoil2OPRaDSS3ndsUpdba8bpx2jjzX0s2HoL9OlFnla4ez/R55A4S57yW4lGTCLR +F4brmerawNmsWofb7rdOUkJxjUpC+m/9nIa9cRW5F02NO90IITnLxhG3wgaGijNNgm2NIhEwUO76 +yJZHD1Uqj8bnl5wGpHupVlMe0VsbBdhcAPhYs7GFEhsavhelT5sPJUNc3RwfS9lXqQ== + + + 2l0IrNE44rbW+R5+YYWjoB22pcGppdhOfElgBMLbNupJAXTtXWzzEZ8OcL3KkzwFBnZGIudWMkLO +Q7B7mWNKmHUsVheFFPc8TGfBmaGQCcEfGNhbiW/cwMiPZvnr+2CErRf1+9pIE1DVfXY1w6OT+XFt +7/Osp3aURRh8h1+E14Z/8Kuq3CNPAe0cyZ/C2DnitLnLI0wSIky7u/PwoZcn2UvX5/bkbfliRLjX +1IhH5zzgtoVgxkQ3kf1qknHcCweuhND2by202KEm6Tvw1H82FUZcW2XUcFX9ePzgD44G97f3PTWr +rCn6dpGQaq/Tzw98/8T/Ocr1r8ePfm+krqr6dmW3WGR2zr/ud3yV56DYV24MYxDQmkyviTORE3k3 +AoXO3Xj73cLC8UYrd2PUN2NZOXyLv/x08pzI3n2H1Ukic60tJrLNznkiS/OVRLIwzGKxLmCIsGUv ++bArcBInvZDzBzvjvcxB6WwKQOezpXd1sr+hLO6d7fjHW/rwdl0vbDe+5Br508qWPjL6HKmYBgdF +S0Oycga3ORjQ0VIitX5oJVb05VPkOHPQlo85pieyqa0trP2cyHz9cIjtO8QvPiVWts1OIntQKyTS +zwsD9H8mEaT8GBPlaEZCwxF/k282gzFY7vOBoYghRLK3t4jsnj7LGIsgMV4dgsQ6L2ImWlIefffT +chSB98RHES+uJnE0FlZk7MAXe0gRN9XVUYA4F2MzlVFojbxgCpufgYr4J2Xxv2OgIv5JoN7zM1BY +hKVFAorlrUh2U6Ls5TxfMqQhsPk73NGQhWc8m6rEYPwfQdeWj3Sca7Nwg+ePUKxysWnROXr53Azn +w0yMi+osaTAh1UvRPH4V3IU7ewMsltNb60urt73lan59z/o+BYNiPsLXeHJVkGEV5gJ4oGFvN5I4 +S554tmFuicF7jLnE1Gf21WP7+a1l/yRX7Gwk5Giq10hIM9EJ/ib10FwIJs2WFTa9FXev9hGPp1kZ +cttVXbp9u2aQdqmYgiNYboh5pX1JN70ihb5qtzDXQR53LC5Cdm33mEtc4QlQUKwFy6TuuREcXUbe +1o4v5bodM/bFZcJsQlv47H518LzI2zKZj7Ebz6ECr42HmTAK/DnMYLSEQIPRZF2mVWx2P4lYk31+ +OpodZsI4xsd5Z0lfkjC+mI4PerK5R346WGcvb1TSkt6G0MSX3ejOhlx2n+21xFwLwQVnoEJSTMz+ +sIv7rUJahhTyQae5lfMMp7fDaX1FPgPMOW5MkanJ9df+l5R8Bs3O67PTBCH+BA6JeaZBsilEBiuJ +VJg2tUYXnHpyaoEupmaxF4BYExJNWpxdf9o1cp/X+8bLqAPzi6SZNtKcYRNcVIb3m9j17F9yrPtw +Rc7UT6v63JykkP3iyY7w3R+iGyN/wtSPwYb+PdoiziJ28G3RXwNiZ5CZ4oYGg/VPlTj2YRQvstqk +iLvNajO9F5JY1SkSC+sW4hRWg36eorCMvfUjIUAwXl9fihhPiCgsFeJDxaosB/M18qbZQ4qvFUV/ +KmTwSAvrdF7H3124CV6brTzj+nIgwgxMjo2pRevbt8XJR57jiDaRrFVCMjlrj8chfVR/hT7CkfNn ++kgyxLO4E/Fu1Tm5kxnMSQzDVBbfBHHwlxoKE1zGTcAZPWmCRmQCaAvqEzcCLvT/YITW+mFkAvP8 +gbDIBLjO1qZoxOjd6/MYYR6k/3U8mv9T5Nc5tFdpRPxHcYEVL6YcaU4mEv8v1Tt8MXjq4HdazKdD +c/C6ANEvr4poD983pPbvxuGofGNvlC+e5vBpiJYxEVM+XW7+ZljMa8qyP4yi5ZuI2c1yP/FnHepB +9uFsLQZB5oJVf4xEGIWD+vUEDX4R+m891vFG/lvheMrH+GsM3uNjld67fcwfvVOHh8S7fey0924f +q/f/Veh9KaA9CH3sFRdpvNaMu7lN+Vsf647f1xv1Zmy4CovNssSrItr/LvLhLDYtwh+8rzfqd8Mp +l5IWm9+p6t03OPbE+5g2673xO5sxSMwaGbB/mb8Z4w9v1CFcJzcWFv40PunwIhKRWD69q8R1aLd/ +PwfEZuTXLNH2n9+jA0bL9t07nardHb43WrZ7oz+GulfnofbzOLZOftMQb48T8eL1woeJ4tIC3yoI +pBjTET9lEJ1wphASwx9tMb7AjPZ0sW1f6+PjhdjKL2/U7SALs8m3jCtB1uvFUOwrw6RVhKrlUVKg +ebAVTk9uhfnOOCuLuxrfN2vhZXoIsF9EcDBaDDa2McTt7zFQEf/E7/IfMVAR/6RMMlAIg+1XKUfF +4kBPeTfDgTMJ9JSLK8EmdZyWu8BySRPYGr7rHIrHBq7+CfzpYL/o5ZoQa3466Wkytfujlgq4qCLv +y0wcKawfafwu5g4z2Zp/mbrZvXPyRzsPbIHFoGsB08LGWz5n/oJCiHbv9WP9X0mcJU+ZlFg1IolO +dWN1d7u6tHa1e+d+edo+2e6dCShu5zx9KYmm61qYMX1iRs8uxHu3XcrGMNiWBCDbx+LZBnzCPSWO +Wh9OBQAXQUN0p2EWkBupc6KFH8mObd/aAlsTCG23qokcRxJmPa+EtNBKHJfttmgMWIshwt1bK8CP +GrZsS81Y4FuzCFYTTxvOTLDO/L30ao4qzE6w/ovp1cribxOs/2J6teCiZiZYZ96SXj38Z1NZA5cq +EtLc63XiHJOyuAg1FX80fsIT7OaOf3vfK7V++QOFqOLHgB/4tFVq2/Bh8gob/5TaSvKwP2p2+j96 +D/1Wx+80S3v5k5Ra6imLTX17MMrdX4/u+73W4Je6ClVE1Xf6/Qc1uV2s5M/UvZ9P/cFI5bdTT/rq +bqWSQpLr1fNO74f37Qd/4ny9dlCqFnPqqsr1+Wnn4zphUei1hhKJ0QTN4HRxLVimqRjqNvzWfihj ++CFqDgpHiqFZLqWmoxqaYbiWJQ4MwyTxA9uyDY/BAaOuZWON5xgus9RaSzG4+Sj81n5B4TMcfIeq +H6qlHqjn3wy1g3c9VhzNZDYF61qaywxTfYQaAvcjpmY6NlVtjTomYaqrEZualloH3VxGXBOrTIPZ +nlpS4Mg24WJQiYC6FKqIrRGTUdXRGIErocbTPIsyF2o8jxKP11DQnOC9XAP0h7JpMQd1cRh11FM4 +g3iGR6HvNcd28VqHYksJKOmBCtPa7yo3s7vfVfVib6QmK6f7zcpd68k/+fXkx3ohPQZzgO015oDB +bbSp5Tmep2JrPdti0hsNYVtXczwK939ULGiVjbawKTahpEC7DdtzoDGEmWAdG3qHuAwbaVumByob +FuEaM8tgoPFURYlXGODs8RrCDOgENANjNprQMeH2YAaDOA6qI8xig209G4RO15QUBi4F3sFrXOqC +fpZjgYehTMKwbDPLcrkpDYOCjOka7DCHOsI5YNbxVGKAV4BtPM2gLjgHlEEyeIMJRgMJk2XuFFwb +F33DcYXncOvAiI6ZdfL4hg8LOJNRE1wB7kVBh0cF9AK/R4tazDZtoR+xXLSPY4HqvMb2bEq4xZhr +T9a4YA6meaZt8CY5rsOgzJhDufEdsOyuMlVR4hUe4V7qgoUZOIjLSx7By23TcriVDZsRfv1kDQqg +HnY4eIrnout4lvRxCreKdyYvT3Qmr0GzCSfDGhfb4oKP8hMIITgsXOpBZEAVwbzcySZrSi8Gfmni +HMKE38EgsLnvmnAEvuxAwEEVCXU9M14mjKCq0zU4HmDgOhbqxByC9yGaDYPMwR6gtsuEF0z07aya +GyVdfdvYrspgaATBED46iqMmU2rtjH87UVHaEfMRzE487K+swFRVbt36J4PW/QPMTrfD1v98tdXr +9Uetkf8E36i3A3846g98dXjX/4E1cElwOsxzR3nl/7UvuTI= + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/originals/SVG_Left_overlays/Queue_downloaded_left.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/originals/SVG_Left_overlays/Queue_downloaded_left.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,1596 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + + + + + + + + + + + + eJzsvWlzHcmRIPgL8j9gP7SZZLtEZ8aZoR1bs3eht3cotVYl9WFtY2VUFVTiDEHWslit1f769Ts8 +8j2QYPH1pQGSBEFHPE8PjwgPv8Ljr/6XX3/1Yvftu9/fv4i38830V391eH//6sO797+4IejN3755 +8+MPH94j6Ge/+fnNkm5naLT72/Vrafj39+9/eP3u7S/oV/TLO/z0z7569fv7+7evbnY/vHn18POb +n/0cfvPb1x/e3MPv/u8f73+8//rbd396++bdq2/vv/36zf0fPtz+8C/f/VwJAIzHVx+g7bL89Rz+ +OszLfDO3X+SMDV69/ZdXP/zw+v/DX5e4RoDt3/349tvXb7/bv/t/f3EDTeEX8Ad+8X++/s39D4/+ +9vjumx8f7t9++PX7d9/c//DD4d2bd+9/+MXN4c+v3t788tV38JtXN/90/+bNuz/d7N+8+uZ/TNDz +/PXd6zf30MmHVx9uFury7m+X8PX+x9dvvv3Vjw+/v4fux1IRHL8mlL/7AXABWvwZwfXrv30AyFf3 +Hz4AVfBCZNvhl//0Xw/A63cP1I4IvV1uFvj3Z7/e/eq3f/erE7yu3RyQSf8r/Rb+N9+mPLQIS/ZN +QkEM+I9rMrSI8PnbNuCIlRv85m/2njPMO2j4z7+5/+41zQoYp//2c+np+3ffP7x6/z9+4GYxwB/+ +zW/vH75/A6NJ7F/Kbb5ZMn7Tn6QVcJVavIhrvXkRSoRfx1ZuQrM2fbzu/+X1/Z9+cfOrd2/veVB2 +7z98xVMipXnm7/yb3/z45v79796+/gCUFQQ1HpVfvvv2/g20t8/fvXn13Q/ayaV/5wa/ffX+u/sP +MJvevfnxA834Vd8Ao/7y1Z/vceos/IK/+/7+7W/f/T3R+KIutzECm3Pjf2FIYllvSoTRXekVaYZe +zjezezeNPKNHZIhK3wFT669+DfPn796//u71218IhfXrv3n/+ts+p2q4WfkbdeJ2dX+b/mVqoeMf +Pty/FephLh9+6ebmfPvLr+CNp7ffHt49IPd/wAUHM+AtTI43777j39nP9Bv4+I/fM/X0/69hoH79 +/vVbxDn9in6zfv3rNz/Cr/7m/bsfv//bt394N/2MRc5v37/6Bprd/N3v//v9Nx9AdAig//TVj68/ +3N++ev39zz+K6NdvXr199f6G4PBhBr58/S/wm1dAyg1/DH7TYZ9Gerz/Ayz9/lmGnt7+y/2bd9/f +d7hBXr399uYfXr3//tOoYRjeOwz0X/33Cb199eGPIKXu3377g5HF/x07yrBP4/vqG5wU72/273/8 +4Y83v3337o2hHX9l2AVMUGz/H+Mdv6YPvP27t8yg8zdJg+2bQCD8h3sLtH78DfDL/8jYD6/evHn9 +3ftX3//x9TeXXnDh9/Ym/t3nTKw/P/z+3ZvXPzz0+eQgv371/sPrb97cf/XnHz7cP3wMG3LjD6/f +fgsTkYROp/bdw/eoVdx89cdX398Tzg9/vKOWXxnC/DUIRi/6Xrz4iEwM8Wb/1v3+b96/+vY1iFtQ +mPZvfry/+Q3899WbGwX/fLoMBnEPiL6d/nn6L9OMX8sc5zTnucKzzm3ezfv5OJ/mu2UBbSEuaclL +WerSlt2yXw7LcTmFOSwhhBRKqPCsoYVd2IfDFI7hFO7iHJcYcC+LJVbQwFrcxX08wHOMp3iX5rSk +CE+Gp6SaWtqlfTqkYzqluwy05CWHHHOacs4FnprX3PIu7/Mhn/JdmctSQAMo8Gn4dZn+D+1M/1rs +73Lxf6gzBvse5S+QRuyIc56IK/hXvxf5m+SnAhwrwDP9vhL/8G9zP+3g7x6+7yb650DsPcBfZDJ/ +B2YDu5E4+ILOgOoGX3HpP/yX6e7u7nR3vDvc7e92dw2e9a7elbt8l+7iXbhb7ubT3el0Op4Op/1p +d2qn9VRP5ZRP6RRP4bTAu+Djx9PxeDwc98fddGzH9ViP5ZiP6RiP4bgAWXeH0+F4OBz2h92hHdZD +PZRDPiQYunBYgPS7/Wl/3B/2+/1u3/brvu7LPu/TPu7DtF+gf3e70+64O+z2u92u7dZd3ZVd3qVd +3IXdAqy4o7G6u6PuYIeO1CnsFnZsZ53D7lXqInYSu5moq9hZ7C50GB9EcjpN1HPs+4H6jxxAHjTi +A3ICeYHcyMQR5AlyBfmCz2zcQf7A1wRMQjYBo+BpxKuV+IUcQ54h11LvzPnX6YnPcftM5yDh0VOe +/fkzXQDuzh/oTLr5q6/376FPBb8qPSs8TR4YzLKnB+YF8AGZeldJdFQQESAMIj2pwpKFD/PXWttU +Gzy7uq8wpZCJMCJ3K62YdYEHZMgKgmJNK6z0ld651hW/2gqzaIWpth5oCE44Ndo8wdICkdRCiy01 +EA5AXm3QurW2owfmZ4M5jGNHEwFmFSxCEGIwEwPMxwizMsHcxE4BZTSUuP5oHQZ6FhKB/CQQhRFE +Yaaf8HsCsZjpKfQgBwp2hoRlg393E/2wx5fC9718P9AD6w2+n1Ca4mwOJIfoXTHgF0hQkLD4gCwE +KQsCL6wTCdtGAncXYFGCxD3C9xN8p4UBshel7wLSFzGgmAVBCmOClnAlabxC3xvIY5LIj0gb5BYv +H+If8hH5iXxtxGUcz0J8TzACESjCrs44ODBERxisAwzZDpvCINaJRjTD+EYa6wXk5R2uSpgJB5gV +OAINJkqFSZNh+iQgNQBDZ1j+OMmOMN32MFIN0FSYmnkCuZ9gBwjA+RnkwwlW5AH2hx2QtOLkg10j +w/4SgXkLiOw7WPRH2GL2MOgtrfCGAptPAv4EGMk5slzCNU1PtCfIQ+N1nPmRxSby5kDC4sBfe3p2 +9LQJGXcgZhxo5uOyAYGaSagmEqwoWgOJV3xmErJ3JGhR1B5J3KLAxa/dRHK3kexF6Vt5NYIMRimc +SBKDLIaHZtp+JpGMQhnF8pFEMwpnFM8ooBtLsAvS4MLTnvpMw3/Xz3rqpWe6CC5PfPL502XdP9u0 +v/nID/wE+Ftu8nxbW6xgNQMCMH2//ukI9j/A29MM4jNg05JajRexlAATGU3yFZY2tWnrDKtOMdbb +2JZ4E/Nty7nTdX3URDEsrWUp6DcCFWxNF9GGVOeMaAsoiYmcSKAvQWNBu9yiunUDqlgn98p4gdb9 +0RRt1YAvq9B3r769v/nw7uYf/ohq/LT5PwxVYKUZKckgguiHWEFFPRefQFILS67jD0jlOOkQz43i +udhZ/vj4A+KxiTTy73ooaZi/EN0M6Gq+uR59hvBzBvZv3t/fv/VW0QZAWMUeMiGaTIjOGxGq4tME +qNNxE2kVgXSMmXRd2UAPbuvs2yZsnCR9YYvGzXqG7Ru38T1s7A32+0x6wAK6AeoJO9heUd2IoJ/c +wQ6EpgRaImE++9paQucNSOZ3CZpFwQbL7C6Ieh3QIhmUbLQuTqZn7wcrAzTrSVTqZTA1jrQ10nc2 +0prYS1nsKjS1ohhi+nzG19P6StYj2o9sQR5AV0BD4E4sSbYlzZoUzXcVjXej7aK+OzllN5GyW0jZ +XVHVRT2X3uq0U9ZNG2mlB9JHWRcNpIVm0kBXmCE7mFcHmGd3MOsWmH8RZmIGAips9g33/j2oAkfg +/R0oCgsoDRFUiAzUVVAweC83BXAhBRDNcPxKpgpSV1lNJ2UQzfNGJvqOzHRRDMlYh2fCYY1keCUa +r0SqL2umiNObDa4jO1kmuGCOtHjuqFuzdC3Qm3ixZZ4bK1nKR/I8RFKrV9KYjzAdA+nBVTwN6mbA +3rERRtOSv2Cq8rSlCbzIdCblmGxIGnd6ULO44DroXzwf2UEQqffZLH+glj5MOilrpQV9FaSWsmK6 +YEtSTlk9RQWVVVRQUunDH7WVu+jogiOxrs1DvSNNHp9VtPsqw4sDzUPOXzgReFJAP/yICRuJkWIp +rDIZ9oO/Bkc8mccGFHny2ox+GxiziRw3Edpl0sJ55fVVN665vt7YymT7crAtJzItg622bljyattt +rUqxK9mqZJtSrUr8yDqRUalm5YHMSnISoFlJD9uVgTibzLostIqrWJm4mtnS3E9npqY+bHLOYnay +4cmmJxufbID6hzgwyT8fnZo/8esvFeFi/y7m2Ft4b5nIrxfFv0fy0W0//adi21KlLarIQq/u/+Ta +m9hvQeNDa6LIati7lYDLIDvXpW06znlZZJvhSQ9THqY7zHneWpJsKc2m94mmdbApzS4SnMloax9l +BuvclX1nogm7sxl6kjnJm0+2zWcnm8+RpPUdWY9BJDRvQRWm+Q5N0D1ZpLQNwUa0kPUayZotZOOu +ZPXuyBDGrxMay2Q4L2RK47aSyY2Ga3adjit52PaiKxxBlN+hS450iUAPuuyQfSQVyJ3Ha5Y2FlJG +9mqMn468GRy9awNM+7058tSFl8S8X8SgP4kRz85PdX8WsdWj2OjsBD1NZpjvxB6v4g3No/q4UR13 +IuxZ3HfFMUws9VFvJN/LUaT/6HUpG6/L6Hc5kYvsQO6y3WTulxUmCvtfMk2daF6YBWcyWdPsiznS +VNuLR2ZH8m4lv0wFm4fUnGwOmkhOmkCOmkVWCe+sJ3HaHMlxw494KsrOnjaxVGV91Jy5zpe7H3y5 +6sntvlz15HZf7qy+3Ol4Mneu+nK7N7eZN7f7c7Pz/AweH/b2TM7Zc8HVc8HPc+7pGXw9Ezp7BneP +d/g4pw89zfl91Pej3h+edXm0X6K5goJzCC1q05hdo89peIhTk/yD4/OZQQELCzwWFZi2gQFRd7YK +j6k8NMlP4lxk16LObPIrTjSpF5vOR5vITScwzdyorkVxLh7NuajuxcqK3OQ0uXM9bieuxpVcjehs +ZHcjOhzJ5UhOR3Y7HmkG7CfyPrL/ET2Q6IMspFIl8kRG8kYGUrbYNEK1myc4z0ueRDq4O9YAB8e9 +CYV5EAoHFQqOb9V8sulMHhj7JhECKgb8+te1Pw9uWs9LcdZ6Rk4X+Oi5mMRpG8i17nm4F+dtG5iX +pu7FNY4xr/amIK+iGmdTiVkhRpv7brNPHGSnWIdd4unBsU1obKJFMH8qNCbu9j77u8Lf5/6BxboO +nrrT1Zk+znee7SKbaXxwbHYkclcblVDCJC70PiLNjQaPBTvQTzQKOoVt8o4MJH18zwqLRXmWTXyn +muoyKuF3ooCr8g2kTKJ3q8bdFRmvyoRNPGd1ZqgzQXEgJrM/Vbdh7WYl+bojmXsgOXwSS3s2JYft +7WyKDqo6u8l0HdwbcI9QbafrO4k2GNN5ROVB6QrvYQHLShM/e1OeDoL2aNGGO1On9CX6omBRC4xN +yjv1vfruKqHMVTZCpmInGyQrYaqIHWUTPfGOeid6mepmXT8Lsg0nebI8xWlsXWtb2Tya6J/doMQ5 +Nc6e/mVBUzbwWQOPooNX08IPGz08DZr4Xk1Rp4nnrotPoowfJbap2ng2fXxn0/vuUY18L1OaQpUb +lXxwBV1yBo3uINXI1SUUJ+cVWmXK6oRlx9BiGnl2OrlOrIPfMCRk6bI7JL9jkfhjoQ== + + + DI/VQo5H9r4MjoNEjgNyHUyS7bGniXgSv5H6D7oHgUdLfQhHGrGe/bGYG8HlgFTx4u3Nn+A9CsG8 +eNmGcx2i1uxXOE7qxpOg9SIbmXrz1MfgvQxN4tc7J91EvtW7yQWyNZjdXQ9jSFufVYLb6onYrfv+ +TKvokrJSddkMgTJxVnSXxWKOi/6Ie2iib4OYpgyeCLK9ELmUv+O8apq6o26gO3H9sRNIl1pfaGEy +t0952jqDATnaSOAYeD8q+lCF0eMW0jcQ/BrWmXQ/ibemZwOwe+Y4uZX22HaxdytOtgvzVGazg2XZ +TbJZyEZxYavQzcJvF24d+h0DRfo0bBu6cSS3eRSyV7YifGfPfhTjkzje3bg7D/5OPPjmwxd76pIT +fz/Yz9VSYOIk6pFaSqfBjO6GdBVzSE3pbkxrqFssnskM6tGk1tD2eVh7E9IW41rN6zxZYMaFZj6S +3uATHIqP1qjJPbHNPajYanl7RXsn61vV7SpSIJshzqa4mC6qgS8iTmaLdOv2ebTnYM9+eFhC7Sb6 +Rma1j6mP4fCeUaVZVZpZJWEfC/y40M/k8qwOtmfrHt5czlW31qupAdllYIntPpn5HlxC1qJ6hkuB +OjmL/mh2fbftxb6fZCk0e1Z7OgeLPdk96UICCMzw4J7FPXN/NmlYp+E5js90OP/anz27R552/pDu +yGGQ85w/y/h7JOHvo1bNJB6KTxv4W+tmtG/Mxp/Mr6VLTc2cNGQRdU+Wmqxbc3Vhu2dyWUR781hV +Z6rGwUz1Jv/ezKFq8Zs0XQjgcH6RD+FIEMdyjdQB4F0A4gSYxIY9ydwiX4BYs2zPskOArVq1bNm2 +yuYeSN1JMI1hN0wmABrArvVx9LWEZfWAVNdEP8DWGehUT+AMCg78h3CLOtCYUHBdtJRUUJcZGmCz +OeVG6SalNcoFINMcjxylPDd8SYaRCZgCsDBuS1Fo8TbATOiEXhWr5LgEmJmIIDTAhRhDm5c89H1Z +akFIUSYE7HrP87kp4TbCPPEpLtdES5QuK+AcEIRSAMUwbBn6iuxohJzO+TC22G5xW7uJCROAHKXX +RUuUfvl0SuWWUoQWZE4K15ypW9ScArPWOOZNLWFNA1ca+ZPwhxpyohGdkS3KiHoLb8C0paW5TJjr +4v2chJiXr9/e07Eny4jZQnq20+aIAEbD+IDAwQ4I4PGAOhiQd3I8IFLIvvTjAWg4Tj1uv7EwTmJf +xE1I7ZIx74JqUz6JfbG1Lg5nJrzaFucmvPNPTZZ83LaW/OCa6naG903t21nG8XTR4lCbo+dKHLqt +7zIlznIl0M+vLis1RdhxtZOAgXNemU3SrRK1TJJEJ8phRf2B3VcnCdKxw6qQhbETB5VMhSCTIWsW +hEwIPjMyy6mRfm5kJbvUeRd0gkyS4pzFxeBmiTtDkoZTJNushOC9P5PZpE9y/1w0TFeX80OegpN5 +CoLL9qlnuQcnyz3o+ezqFLLpNG3dnW5WhU22wTabfchl16SCySWz54016+3Zk/MgBWfNbj2fx4ki +uhHmBdqraKceydkYaELUY/vUVBgnw+wOEfXpoGnwR5kM8zQIjHEydG/T4hJVivqbbEoMk2J6xCc4 +TovtxNhvovQ9MSxPF/JURhGzbFJUhoSwrdNonaet3LGZ4kXP5clycbpMLivl7OzD4Cfvk2V0fDhP +Obo9MHKBcwRnBwqVkwT7k0yO9peToNJzD8Mj2V7VTnPROa7zGc7paueH5KK5UCVxjSaybn84fQ8T ++dcWEmW477EMu4NpGmmvw/ypI0zJBaYiJtA2dZ3BnIsw11aYX4d6gskUYRJVDBEd1hNQG2FuVJgO +B5gACwx7oTyPI0iCABKg0rieYHsINKI7TNVwS30FyX84nsAKDxOsnELpFgf0wt8tlEpXYEbu0HF1 +Z6e6/BG1n3JAbTBWp2seT0Mzdfr08bSPJd2ZYWrx5+liHE6PtPg4nD/OcnaYpZ9kmS4cZfnMgywU +/uTgZ4vrZHHPaBHPEx0Z4jzjlU4WZZiklG1MZ5FOlHG8p5zjlQ418aEnPBAFy+mOzi0eKAW5p/Mm +yq9aNLv4eSo8T4XnqfA8FdxUcO6qtcwz+RZAOyutkU3ecpJaJGR/Xjrf8nkfkzMsn3cy60tOdX3m +yZSv3v3hA9cNuvn719+9vf9AB48uQfuZfeXBpDyYlAfTMs30CJuf3vKJA4LnZMp6C1pnuqnxFhTb +8Fkjc+nzNERP+extyUtIWBsnLviBeLOutzWG9nkkPI7m6ZS0/NNm5vjJz5kov3v79tXD/bc33wno +BlYczJSLYJqO4rvZVF+4aDNfdLE8YjJPZ/ZytTMy/jT4ssmZGLMmXN7EZCHd4lInnMvFhXW7y6Wa +WXyWCrR1teSzXKAhvCtuFjKKHzdmfO2I83oRUf5qsYheNKJgDYluPVSrBsFG8o48PAcyJXo5CC4G +QX/hnXdyGB3Pw+DfMIHIDXYCXc+e87lzPHVe+dw52SE7Etf9kPnJDpgHOWQO4n2i0+WFztZongdn +euzJ/uaj5ZjfA3sEHR/RM0X5kaPj19iS/Y48XWNL9jvydI0t2e/I00/fkvvZpW3him3Zim3Rim3J +ClevYhoSnF25iiG1ebboX89p3g9Bew3bl8lF7l3sfoje92Pqu7MA/jaET7VCzg+nfyKOz4nyrFOO +RSwunTU/PySeN5HvHvuO0yb87ULgZ0FwzU8/XoyESyx8csHwHg4/D4j3kPgQFHdJ7TLe0xgWd4Hx +06cC46PqBUu/rfljSg1sYksr88qxKZA3+AOGTtJFLelaCDnq1kB+JYrjrfNyGVmANU6nxIv+IGGo +y0rj9VB+2Z4d1ot7NoD9ns1jS3r03jaLnaR5UVKInEVS19Slo7ShH4KanG/rs07W+q9LeyP7fjki +RPEg2qiSKxXFkSAtE9UkeRAdueT9mkg12UvkJ1A5qF4MChQSUkd6vGdHXjB2zdrxKaLMPJPRkq36 +ESSfZHWyvNllSM7t6bmkn0wS9thZIpXmwd655FdNetWEV5/oup7amHX1WdWBLpX/2RQCmj6n/s9j +RX9YlP5EM/yCFU4b/vTlO75UJXFJ5wdL/l9tJ9W9VHdTNXHVyOWs/2J2bpzY1DVjV81dNXjV5FWj +V81eNXzJ9N0UDsllbsFLkppy4Pi+Woio96PUwxSEBbSLctnW/FJMo7ULK2rNJGeXBct2+LgyV/dw +BTRmAj1aU+JaKL9MfMaL0jOO9eya+uiHRw47uZ/9cxgen9N1nMb/inrunnGR2/HLOCShXjr2Px78 +Hw2TO437Tnb+v1w+nuBfT1LmQqWbM6XnM55p1JLOH1qno3b9Gcr1T/V2+fT15/3yeb983i//0+yX +MYOE8FtHhgXu87ZoO+GCTvBLToG6uF9+KSbeL79s140LgNZ6tV1c8f2l7+Xp8mae4mgK4ddz6tlz +6tlz6tlz6tlz6tlz6tlz6tlz6tlz6tlzkslzvtHzVHieCs9T4SelnuGe+1lJXQvaxO0LssIEwVMz +jPQwYr6d8djXT0h+049+oZHeLhvpzRnpzmNHKrKqx6RbmGEdXc2IblSrJszlIkT/NbOItF41qL2u +y1rumFJ0N5SH8EVYXFHE6emVeP/zapecpxTkO5tJ8H3jXP3YNSDn5fw/WaN/eqQW/1NiEOdBBZAH +PR1jm5RxlpzB1zZ8ytP6mUJ6esTX+pNF9PRYLtK5iOaMoI8V5wiW/XOSjn+kPAczYRrO+h8t0+e8 +OEcc6lzeWWpPT+xZlUPFcno+WuvyEfELnClLuShGJTcEJF3FE6+UNrLk0j6epPuFCEefaynzwn7c +NY4OXTvpnOhItvlJP+Fx/UKEXybK82V/K4DxJs5nf+uzv/XZ3/rsb332tz77W5/9rc/+1md/67Nn +5dnJ9jwVnqfC81T4Mn+r3bqxboZRBxGH8NItCY8eMpqGWxHGmzDHk0bjTZj+GrfhqNF08axRcmUL +F1cu1N/JodUL9U4OKRE6uer7fqqMJQyjL2E4zBidMzZjpkenDB9E49mic+VjM0XmySQTpU8TTvwb +r6Hr82M7O8a5ATNjwolBs0LnRJ8RlEPLTroGqxknQZDkR1zDuIIzDPcCQ6yl89vZuTHzMDn/0n6S +NTxeppIvFnsdC73uLt+oMskyf+z2hPNRHO5NcLeocF3W3fTYpbaba211XC8dMhykwfSoOMBh/rQ4 +2FmSp8iD6RMCwYsELxRGsSCCAWfAdEEwONEgU0FEN675QEN/omWNA49DThcmXLhv0ZcVHcZ5ujjM +fZGOF+f0UX70lozJhtpfnOMWrbu+eFt6lMe7Fx+lMZ82sn97RcZ4ScYy3DayP9sKYPQnN/xP2Q/c +juDuwnD3YEybLN8LO8OwN4y7g9sfeCLg4YmDnLr42FQAlQEVhh0MQiFFYSEl4QCjv8IKSaAYzKAU +HEBor05+nGD72NEUCvCWE02eCpIi4A5/hLmyAn8jXatxgGlQYeAjkIFXaOxgiDKM5EI3ZuxgvDIw +ZLEzCQ0GJMNALHQlxn6i2zAyrLcFmM3rDEUpMngB5iJjka0qQZGZeo0nc7DLTuLdZKzj+zwHpjme +tc3hhfMDC3JG4S/ALlf3QvczfczhmDb+pe5dGlxL0xMdjR9xM45+6emnXShx0T9NnsXpI9dJPHKZ +xMcvFZ0+cqvoeImEu1f0Y9eKTnJxhLiMyT/oncZV3cZy6OOODnsEOuaR6XjHSld87OlCj9PpbqJr +OfkqzkxXcK7oO0fvNd4uIu6F56nwPBWep8LzVPBT4SeVj2rz7TK3n5ZFIx/9aWWkynybYitfkDak +GD4zb+gnlcv60gBzuVzboKwfq0d0HgfeXCtDfvGPLK3pE2vLr67tHU5+gVlkeHIhmssViS7eULaJ +4O1t5Z0mDQy7cMwYFz6PCo+ViTYx4cmCef0mmtViwno4+PCpcM0y/KTFjcYyR/y/0P83yY/Rvmvc +JJJ6WrjmkSishe7R5XgK/7RKGaRC53LpHt3dpibStirSyeoiST0kqoykVZH4ey+HlCaphlTpGpWd +1ELSECRXQ5K4NF0MrvWQolREilIMCa0e1N13E8VydlQHaU/GEYcnZ6mDlOimpOdKSFeohDTYp092 +UIh74nIZpZ9wa6yro3OYekUly63a3hl7fmPsfFZYyUorTZu7YvtNsb680uD73JRYGoss7aazOktj +paXL/k+53HUotySOtMl5QV3Npa1H7VINpk/VYXqsFlP2xQaGLMCP1WRyVZku12WCmTBdKM7Uryq6 +XJ+pV2i6UKNpGso0+UJNly4wWnyliAvXGMEzXSjZ5G8zkrn3n6mAE0iNea1UbamGtF5EtnDy3Xxb +gqS8rTm1OTySQ3c9lF+m5KzlopID4CdfmMElH9RGuWShUELMY4k3mpegxs8lE2gwgh5DVMySYnTb +hC5ENdhTZ9UZPhXn+2SU76kBw0+GDB9D9KnY4xmqcZnBzsYXyiwzKAN0XdA8l9qGVQ== + + + QYlClFcqk46vmLk8j6+G8T96YduzNRIu5p+GOCycT+VWXizt+VhqJYzxNGjRox49XuQ4JlRuUyot +oXIa7v8tdgXfOlRPGe1hsIa5Rs55/lfdJJ5uDYytiTEYGdM268vxyPPqycmCk8sWLAN3duIJ4Oyh +NKYLUudcsmQv9zqmTB4tZfKxpMkqF6LuMPrSs+G2+XCXEydHw+uMJdOQklt32+uhMU1qoc4X6TJO +Au6cy2ze3pCqKc18O2qglK5KZ1yOcr6FT7dg8vKJqvCkUiborpxoAdMo0lmWBnw6EWcS8GKlcyt3 +0Fky26FTR+hIAOor0LynjD1M11uJzruJkjgLsIsTOJeewAkT+Xi8A9kWQc5VYMoeJCDenRzuEo/c +Z2n3n1bup49q9xvd/imq/fSpbITLyQjUuet2DXOOH+/aBdPl092bPp1scal7PHKfaZl9qoPT51pm +n+re9JRckvPubRx9+EbcIEFVaSVRPZ3aAhfRyYGq/ahmOgfoFm2mm8vyxkLd18LIF9q1uBASUKtA +TuAhjgy7O+3tpGvdkBOPS4omxIaNgb9LrBd35msh/LLt+qI3b1uodNRz1zM9N1JxM9Qez33x29Tv +U5wn88Jfqlr+qI/QFT1z/kGv93rd18cQfBzBK9L+WEPXgWHqTi604Lo0dMtntfs4g481ULzBe+gW +SUOO5kSrYjm02efZSwlCqQu+SF3wZLGPMom6Xq0G+N6l35+cxyvQ32QUZ0dzo+W8/2yV/3NS++p0 +zcQ+bwJ4Gj2Vnk5PqafVU3vnTxX6c4WO6oFuT7mnnajvFCoXRxo3VG7o3F84C0hXJ58fBdxbxt1q +bio7Bri5orvTDFR/4SnpL7Yu5tsIqhDbR63AIsAfSstjkbeCp+VWktpo3WNEg8qVXRb2V8P4ReI0 +hkviFKBfeM/mycmds0NVkwtqVqkc6QOaIk6/9LTX7uyAz4J6zWMHfIZw61OOF20p8KHesjlvRhRM +ZwJOaVAq+Gzi9YTbhUqPTxRu/545009592e/fbokJM/fv/FnounI9dlh0Gi1glm3jFUU9crmqnfh +fnTdXw/lTwz+4qXHOXxJ8FcwfJngueh2iWOVxScl+lKa75OyfJ+ULPqI1XYhPfApCYdnmXOPofOh +uackJ1BqwpOSVP4jo/M+TZSEidzludFN3sjBMByaF7/5+Q/+BqN2uy7DteZXx/yZC2/+2Nn7z/n0 +Fy24dDFCkC4ECPSrV54OltzJaZ7ZueqLJIJyQmil+Pmq5kGPovf65hI63BQtv7PYOW+li9wttFAU +XT3/cSLDJ8oiK7LcisXW+bahVWLramNwhP1Ai5V3Y421nyYN33E/+WUhSNFg/opyQpyfTJKIA/F8 +MxHfTcT7+DqJrSL/pe96bVGji4v0AiPe8NkCO8gZ4/E7/W6yJkf3b39OF5478n4MgUocN6/VxEGX +Ow66nJrGR6v7HaXLq/SB1SVSlqZPmMV6kdeRPI+PlE9wuWhpsnSZbSJaJJ+kpsls6+vEx+rrTJaA +li9W2GFn9IXss0dyz3aTuOLv5Chy0OQzyT07SI3y7mv/RPbZdCZDNQFNJanKUpWmLE9Zou7IZDuQ +XD36MVbdNdn54dUCa83SWY6WuLIMenS2fJU2yWIyVVbWiir5mpyit3TtnFZ9kqwUf2w+a77VSq47 +nTjdCPh4XqP6VnQqwd/pQhLWNsNxzMHa1uTQiSW5VxOlXvXcRp5X6Po/kf870ITC6bSjqcQTKchE +4nsTjhS/CDR96iTO+37SGatd6EnnIuec70gqoU+cjznfoT8cRrvBCB+14Pxfzon3f3WEyyMPTeBJ +djd1camjK53tb+O+dmlDO+ilHON+trg9zMeveYH5zWsVk5HNxp0aQXebqwTGmwF8bsuY1TJms0hB +q2nIYBnyVjb5Kv4GsTE9ZUhLmYZ8lPG2sDH9ZEg7GdJNhiyTaUwvodQm9hiNCU5syGmakyY6RdkU +l57uNEnG050k3Bxd3hO7mfRiOU5+YpfTmAKlx0ApEWoacqE0H2rRWSAjc3J5UUd5Sz8cKgdEnw8m +/+UfTL5aLsllZ8Y4yj95nCeXz/nlIw1jPT2totxHxnoz2tNPih1+ZLynJ0cPPzniG0t2rfOCwbDW +YDMJdK0G7ARxJdeOOHRmyaFZMKL3aFbOl2L6T5eNc7mwJ9b1NCvVeUpsl9ctvBfKKU7V3Zm9eaKr +jWbbi3kntsTsaZOTLdnYpCJoFnYiS0ivpK10G9Iqtt3OzDMxwibLxo6k+ZLuS3ONVV+uJbajIP2R +LKcTqfgz2U+oAKMKnOiGnIJFeSZK4kBdeEfz+yhVxvhEAvY/yJOoag8qxagWo2K80mrh8lKqHtO9 +yTNpyVxpiutM4YmFTEd/udCULzV14GpkVo9skTMMnGaTJ8q0WYc8G860wWV/nmdDmTajYRrN1c5j +p8bpQmP28ZNUuVc5mi6eoVopMWZ3KeCwPT0lZzyicLJOZq8ekHXOsvC2xeGRs1N6cGq4YzpRVs1o +tR7tbmk1W5GVnygLy7lT03BuyluuejvbcTg1FSizu1CGznmSGJiu02C5rnKR1mX3Hxuvn74u62kX +Zz16ndb0iTu1Lt6x9bHn/P6tj9279YTbuKYLpWufUsz20Wd6tNrtp556+Zke+8Uj1XLpGS0SZa32 +XulTFGp1qLmxWOxYzQxLhP/Mq6Ufv1wabYXpKZdLP/166UOeLlwvfYULpn/iFdNy2MEXELmbLhSX +8OUltgUmqMTEs+3xl2R7PJIhkYEDEQMdDUNkY2nfkiqlHWRVJLHUb6qPqKLXQ/mfTictFyMnAL1Y +a54UGt7Qd+YuvHwIWvKBL2zm6oE+Uqr4E49A652ZddjMfc43nYKenCO6u6JpQ5ctfXG3YWbxSsvW +bp5pPhx9QmE+sa+LUz979dnultdkas0tZ+6MB1j3llF95w+yct2jRGu60OputM53tOIPm+zySJnI +KB0K5SNvbq9FeTtRMrW4ZCWlmv2yB8mq76yspBftuCKleGrZV4ve2j3fIjqxw/Z/bpcsbyafqrD/ +8bt+zy/wvXDc7uOV9y8cxfPP9Khe+djX8ZFHfIlyio96/zlnW5+y73xeivgTdp3pevnTcrBVagbR +ul/pcEWvLBUuVBM7uNJSVbpzXlqKujWRkYU94z2V+2cVpqiP3MteY2x7rSx3Vy6WnbDPm4pT/m5Z +7v1Qd0p4cJKo6+Z62YkDwY9uvFhyCdOfW6pru7xLYqF/TEdIXPn/o3vdFyIcN90GvaRMwxVPrUgi +BO/YTXduvFmVkib4CoBPaAVfivGLNuh6aX+uX5rC+Hx/wPP9Ac/3BzzfH/B8f8Dz/QE/WTH+t0X4 +fH/A8/0Bz06x56Lxz1PheSo8T4V//ftan17EcDzn/Vkf+0/nL28XzxS2zZnCkzF6b0X2dpJduW7K +Sxf76VKpafp3GrI7f6qOdUETDHL0GV0G5DCQQkloBLCapDnyrCA1ygI5kqZP6tEkJxzZNYCWXpZa +HJwVf3LHxCslaewtc9nylokyU12jVXnx1V3U26+Z57ME8dXzr1no7P6veBSQ7eIdxU8PEtY/SWh/ +tlhAjwZooL9I2ueng/2fCOZ/Km5/Hpt/Sox+E2pn+f0T5fQFMU1Cevrymok7Nj02lfJHJ2Y2+acS +UGXgYfBfFhOEcRrcl8ezNDaViSoVt5cokGx8xK8JM3jNdCZqWVoeCrM1PqJod4TCrwj0KdfhF6Nk +AZnLPN5dCh8IrXghhye5sEQc/IA1KUK5LC6/FNOXCc+L9S3aWN/CCoKqwGEXw50eyXG+Ju9nGg9U +bMpEbz1Ml0pEj27JR0pEo69gMp/S1jdpnqRRblwoFbWtSMvhvN2FWrSLhEd7/awyWXmonfMjjrHS +5E7tcMR0R1kgFjUVKUryc6I0kkyxP06FapYMJfHTsUdfJGEuHYq+IGOeIGEeVwOnT+uBet/zfpP4 +P5Ys3RYtvZSoc9pm+I+FS9dNXn8akna2aTub8qWTy+Fvh4sFTDlGtadZqdcY9WjVNl7Fauzjl6FI +zGrSoNVwI0q/E4UV3G3c6lLkihVeqXOEct9LftZ9JXq1yTSO8zKEgkApCeNRco2+NC1CmdYA4uGi +5LsOOi4+hAraIMvXumzSRaCDIM5v3Cn3gIGrxzaM66H8mIAGwNe/evf21+9fv/3w+u13L144ue1/ +Mf3qe/xN5N/8+tWHD/fv34JA/+r/+fHV+/sfbnZvv3tz/y3I8g3gZlluU6qr/BtvSrnFiJ78G6Gr +P2J3zRb4xz/Tf/8v+PG/A/BPN+nmlzf//N/mm28J/o+/gX+2OB8cTPDevATY5l0DTD/78gI+hL2l +1/0dDQVYTqBfUA56rcTmNK+w4+B2WAttizPPC6zgKhWrIucC/eMrfAG8FOu65lswNBPTKyD+l15J +v20XIPKxl+eYEPQH+BtWLGAJW+YKKkOt9AaFxXa7tDUMH78E08++vIBP30OfA05l6ChIUXqPwspy +GxvYef7zl2D62ZcX8Ol7lCb9vOdYDbep1UUY1Oa5XQL5N2+x6VvoY6X4YVGQGwT+1AWIG4MNJn0B +dasm/eyDA3nOKhcuwfxsGLHpS4gamCU6pg8Oxh9pw8cvwfx82OIbuLUZE4X5AdDPX4L5Edji0/eA +oAuwLeAyy3OF7Rpj6BEEG8vqhPRi9SDJApCCayC9+QdacPPNb7j6SIDlyYXkahpLIHSxiko3K+Sw +L9LxkxVX880/7rjm8c2f/Eztc+XSsF1aTBfW7AYbgn7PUr9mLkzbySthGaokJS5Di14UIhN6yeYC +9Xw7vx4eGflhNW5gnvhL85VJhV1+odp3IWL44yJvZTtyFg1IR6CfaR1mqUiTS7NHuXUJ5iXHFl+n +tYKyH2l/rAtPLWiXCzG6YZwTBbYmbGQ2caiSBu6qgwh3S/mSMMVCVxuZKyC3ai/I/t9faeJvhbGf +pxWGMAlbTJhegPkFeUm4X3X4aRMF2dkHfxC1F8SgguRzL88wXXPYN/uB3yL8GF+SoxfE9YXdhQlN +CazIsRZaymsbtVMtgbkqVyXviQnFgXQUPDgYr4t0Lok3ME/9Fp/SutUqvKbhcYrqcgHkMV7SUfAt +v5tOrG6CfirK5k/SV1f+zf79jz/8UfGYuyHMP5/mmx38/cc/TT/CM2ihl3VQ0kBfJNDNb/MNSOqE +lT8X4MILUAnXW4zkO/DLERzKLV5MSGDFcAnWP/52Qh0UJ/K80NhXPBaGkxQsspWEfy1gJtCBSNy9 +EGIF+Bedxw41GhY5EMGhwXRcc0JwvJ0DfAaAa74F20/IiLDkAVbjbZ3n6kj7Bj9fkB6YgATGhkuD +D7fmG/4ZGoKhBTiB7N5wqduG/4IN5wwYQ/Ivh+WJO3MZqPS8lh4dpqEt7leA92ZAisxuoKYPBOgI +fDNSCuBcoHNDr7Ttn8fu97aOVdoWO+a42mlw/O/UbgfqMP1h+t3Ubn7285t//Af4iQ== + + + JjWsgmFKf2qmE/QGwDdhmPJPnvArqE+36wqayRrmguV5ac6v8xpRTDQHfrkBh9tS80pgj+QRsCG5 +1swn7KWABAXsCTaCnIjyBSYXQWIC9YqbpXVJDMywo96MlEHLda04zRgcuXuIEsx0BqIZzkC8UvTm +4stxQJFD0KYoDSktSfiZb9FZjWD4aYYdCoGFJyW3jbEQsN7icWkGtgXWwoEQwExCnwCDc1i0bUzy +sjyHG2644L5NsDID4fz5BjvivDIBC03UdW7LLfA+cNuVGTbD7M3QQHmTVkaAkzomITaUUnhGABio +rQN3YA+GBb0Ke3MNUYBxWZRYTJ1lvAiOyrDYsrQNYRasaS6KIKxFeY7KrSHI1QY4B2kLG29UBKsC +weRXCtYkn0+3GImTpmgyCLAzAea8ABd0CzAB8xwMAax+4SIoXVU4g/OmNOE4/JdQ5NsUZplhKWTm +eAEKtGM1Z+0YgLHrPJItKoKWsgJTygpsSljvGCw6m/mtBu7DehuWIvMIRC0jhckRdHKAwJLPN5jZ +RWhtSXjYUDGU91ec+PJ5mVy4Llb7PGZM6ZRd9POl8efhVSFkATZkPAPruvBynGnBC4K6VpzzCEyN +RybDIo+rANdUqvB6DcUQwIzUIVgaS7FlXuAlUV6XgqBYUP2M2lviNgLTnIXaCAtW8C64L8hqnte5 +4y3rLFRQ2T0GYuaXMLxUBoZbjNdrh0sQvABOSfq2wOIVvAE6moTekNsqKBKOCaPIsQqwxKirPERD +W8a3MVpYpbhNdaYxMJoIJJktQFC1hQCWdgyGzUDInZe1CAlt1gFe8hoEwZL6SCbtL0oHHQiQDdwW +pn3KTSej9LaCFI/ahVx0IGC3T0WnWKhV2lYs484cR+EuwLXqGisOQYsqaNbIBKzQ21WaYslOAYLm +rm9qs/YAwNBlAa8ya9ZbYFw8Q4DGkgBBeTEERCIvnZXEHwJB3Vl0HgQehMYyp3ObETQcRR0w3kQI +mHTprrDV3lhLoaDCfw1BjLbhFAAzsORalbEGJH8rU2AsAOgcbOHIgDfkprJrUaLWpJvuuugsWmae +6oy18SwCYJeTJBIZWNqqzMbNSBFkoEvb8uReYI0n220CySlsCaZgEb7GQjNjwU0wqPDDsOxBEeir +Em2XBMpBJ0s1WJfduikhOLaiKzmyiAFg6+uFZR+8Gti/NkcTIwjoadbFubDagsCg6wXjNTf/JG3R +DtadRvDCkgvJJuwqMBDIut5Q0vC7ImphuuKKfT4jM/zug8C+g9ayVEPQ5qhrHk/QIBA+FoIpMqTy +IDDWKq8CY0A+D8iiEgCqNr8Lfmxhy8IMg7lGJwoZASArTRcMCnoGksrOwzWXIsA0D/uXIihhld7m +1ESDxde1LCjI4JWXoY0iGtZieKtpLIsuDsS76JSV/R5ULtOiTT1C4ALzR9UjY20BuaOKJmYoS9s6 +J5MPwtoKQ6pTLtjyRp9EXHXSlZKkLZ7QUdawpowIgmpiGHYXBCA5k+1qaZXdA8AgtxRcsqJQXRmF +f4kCbLbPBPR1KN5WkyzGiLXjEQhqbtFpj+WQBQjScNV9NShvV6wslB1hDKxJWZNlwEDGzqtuX0td +7fOwiJUztejn+9a+pKBU1WgbaB+bhlJQ1w0w/0aAsLcrglmBYa0GLNkQ9CkublgGp7rUro4xbA1L +dExkYAk65Ak3a0Wb5yVvhgbaVlUNYJiTABNsP6pMLashKIvKiSy6BQBbXARYYEEiMGABcN2pMMGC +EQQ8Mz8nRcAyPZAhV5Qs3lMCxthU5SE9XhGk1IQFouYicI2qzlXpQlhuQ1J+r6hvMgIAZ+YBrLbA +6waAYLBId3NkMYHAGPRVUdcNgDGTTQhbG3chuL1CVGoE5qQyDWxXGQUAp6qbTV5ZAmNbMeOyaYMI +XHQl4A1VhoAUFe4uOr4FiDYwYwUeCRDEslIAAtYQtJh1Hog+GqIp1ei7yFmAoaWknFXlBMBx1YVH +rBdg1BVSRMFDrE1XSEmqgAMYfhYE1BkEJiesyW5hYFd5YIcQ4YNgUS6AAtbvQkYH9MJDu0QDxhoU +GJQD2W2YEpJhcIoqOWgbY2BNaoQ0FokIK/r5GgxtMZNRewSblkqtlcVewCWtE6iauhRQ11YlgOYC +A3NrQv1cZLrjXqfLuJrcRJpMxhrx8LGlKAJRxQEYsmrSKxqxSv2yqtQQq58QZO19EuWGENhkM9UI +XV2LDorNwQLLt+gMUPFQTD/PrN0qgjWoQK6odr9UcOTFgaYvK30Bt7XqucDAWVZM6ZooQlHW9HXE +wAwWjUwMsTEASBEnRprKYgiSKbhJvV4Ipm2ewVVmceVBHYehOim9otBQvMRnWfXCG9xAbWqzi4GA +NVlvdatCMNrq1AkSuAgEUz71yTlXAeqKk5nECFaziXByiyiA7Sc1lZFiaQEw2YqrVVW00JwN2eZV +EeDlmfqySgyPM5ssXUYSgkiXcioFkamNszmKbM0hbNGZuAY1YvHzTbeUgrKGgcEWHjrUBEgxLRkE +FegILurkWBdeYwCsOXrZzUDysMlGpQsvooeg6a6IS1uAS9JRjDxnERi1ZcOq/YogFttWeV8HmLoc +YWRL5h4Equ3vdgn+fACxo59XhRYQ1Kw7Cg0RAxvu+/KmxT6PpxVFCxE7AYApKHAtQhXsMuJqQ6Qp +GgLMIXNS5qWAwQLV3YO32gg7Sow6YyO7UiPuEuoboI8wWnQB6o7SZJ8CYNdtSBtlYBZjt2CoT5ZH +RNdjKiMBqDoFmdyBHVUIVHPdb5QIbtbdVhVBNR2miLEIQMyd00mk21REUR2VLvRtCtai0gQzSo0C +1U9RmDsKFpv07IhArHNVbUOMcAQuSiueNDUEddY5q06PiPLdBKLIHexCVa01F9W4IhC+qnIVk1Bb +OI7HwrMuTYDqycB9UNVxBM/Rll1WBDCllAJxRACQLGWZBlF5AOK7ya7KsuKlgJPonYW9GgwMq7rE +qnjqEWjqNG2dijeZoZFlc42VB1o0VNbkYqUbatycYwToezd9Omh4I1bbrtzKW51nL4tRAcAQVQ0q +ZuOft32pYJvN5E9mYGwqPsXLjcA8a1Qho22neLvmqRsD0lDUqKji6sJXmcORtmRFEKIyp1G8jimw +/aqJaUYU2IJM/fN4dHbUXCNaYapnq+oLwO5SWs0Awbjxog6FurKijsCYbGuTMQfgGlXxybbbNGcb +NrG7AZhy0rYSCoro+071bDLC3lhWv04Fa1N3cBNFAIGmHZAANQTL3DYzVOLhIpebkRVUWHe/HIBz +U5+2jlczhRyWiDhlAFhn0/3QqtHPF9tEWl2VgGK7MO2N8qaoCrmp3rG760joyeQEqKl5JGcM3Pdc +I3Y1Pd+xsLsNaBrqy4jEQYAmTLEJ3rRjoHoGC7t6CEHCHKskUkLt9jQ7Z0DDGcnAtc1FJ7fqpIlS +smx6t8YdS92P2GciAAPyiQnj5QGwFJromXNQxxKBdXulKaNoNcgGYNYa0uJ1NLGLAKhOCrRrlFhU +EGbtGItaaNmybgwkHLlhCGZtmDqYMEKtcof9TwBSd103bQGoJogoz/rxZg4K42s0F31hBzoDKW1z +owkhWPQTYJZSAMCg63tBbxwCk+n0heOLjAA92Mbtxs7BJEo7AZM4bVO2KBiaCqpRJ5zpOtjCauyL +OkOqMlCYIUJ+VQ6g5TnbFsaaLwKL2rCJA14IDIt6MmxxIdQ8eDbWvSl2itXhhGva7JeqyiiAU1hl +vgOzua/V1OkB2M3lrjMBmGxnYWzJ2jYEAQYZ18qRLx5Xi4FhU9srmxiMAMx1sY2jKdLazBVjIjpV +1u7tXS8F6mYGp7AhGLbg3HWDxvxGoFrNSVYBbF21KtZiqxvAqzZVwQnAOJs0XXivRmBa/C6jCHJp +ilf21LSaKCkaOl5Sc4ylwDAjwDCLGbdJTEuAJgnnuoXQKClMOSOTo5nPYoNWdW/ogxgVebbZWcwf +j3lrxbxMqJ8Rgoxl2VW9UsM/B4vBFXZGM9D1FlcKIwCwWDVIWIjcsxzR16YjJn4maNtMRuTKMiJj +cHBRvFVDc4igqHEZxfmU0VRIKpBqUCDolKohqjcAoORkFNWCFdqMEZCkE1ziSgCsaHn1HigCVVML +O+gEgXh1CpuDDCStTgSP2swIFk3bcTFZvA4oYFsFYL0DGr9HKDmrhd9NP06jPHYgmbtVPGKKoK9c +2rBeCljDk32RYmfNV1RE00daF3X9d889vq5pMFayjOV1xcJzItMQr8aAJJqMHy8aa1nR8X94/OOY +0qFqWOJQCzWczbhNnSqK53APWNugrpo8EyMyJ86HZeCiXq2cbU8t6nXPmGOhU9OmW8IDI+bJiJ3+ +Zk7FojMjWzZOd+xlDH0ppX1TJAKqGbcs/rHtHHV1iVWVs5MFyVSYjHqa6rdxNgQ6BTVShO2WRZdm +1B3hsY/jETB5lUTYc7b4U/EjgDaECmlVujPuX+viaGVgWJQscp0ygmJBz2KBC8S6miARBx4icCxc +OoKlNt0VJVoGwFJnEyT6eVBWlIA+B4opQWi4sncXgX11izUEwBxV6Q62r2fsjgq4RfxJuVpIqNzK +xyvnjfSJyR8nZ6dKDM3/AKjSpEsALV3d6DV2BsDonITNUGqORdHMMwQ2mdVZQoIISipYlqJzYu3o +6L/mWivs8GdgSDobaNT0xa2p3lEkfuterM6u7PWA7pMZPh6jvgkEooyEelSQpqCzuUcOEJxU0qM4 +eCnQrqVr9CNjakaWXqkhj0B7Vw/KIHjRnMYqfi0EJmWLip7VgvIo0zUxIKMVrHbK2ndLUBqSjp3J +5JX3aRl59otBS5ihCkSbSfG2UnRfaKo3QWtKNBAuynbRONFg0HsQr+12i7nqAQzCVpfkzC6kjAFK +628xwii9UnqmCgqAq6TyFbarGFiWvuFlgal/oLhoBaI1AyAn17FumahPnt4VN1peRtOyGLAJXWV2 +aprmHAAwrjroEtqihlEGsvjPh6L9quKSB2CKurWoZYVIzcWb1IIps5t0GpxDpE2VRIqcMDCbUOgT +HBHYlFH/ZJmd+iwppUtZOBbPXQ2lU+Bs9qKBfWg9FzNuS5IZWnyKnapuiBkTx3jPU3oXztBa2ZOo +2wu2reopD+IUwnMElqEXOR0RgSlaxoFNccS7quuhlaAIcIhldEViA7Ca6DKbrQTzCbkRC07FIW8r +A9WvNkyZ7iovrIYysGQVCCXPSYAaDAMCgprt2NaGjHyS8rKsq7zJplcwi06t1u4mIQQmqST1pID6 +W3V4dY1DS4oQrGZYKII1LrrvLNbd0r28kgiIZCVzPFhEF9uWtHETYNtF/czqP8dXmVefgIwgOmeq +JrQAsKdHV7Y7EbaoW6z1WQDg2bS3uCi/WyzmTmHLG9+U1XJGEaSfT4t9vnHwsvhMRg2PFdTqTW+w +aAWANf2ncHRZgEk3MUk7IZiK2R7LQ7SLbrTklH8p4FxUUtNJAgVramxhD5egkBgy8w== + + + P1lsTRLt+U3J0nJxW1KMmLusG4jaVYixqR3KKkpBq0g1v2A5m/Bx5Ynu4Pj60JzWIu9edfsjn6WR +FFQb1BR9pEgcX4VzEQVpM0Nnbb1PwZwJJrbxZdWcNBx/L4nDl7wCNN8cwerQKZafWiRPc1wBya2V +nppSMnd82JVLNve87PYMLFWZWsx7huCl7zwcmSqodBkPV0W6Fh2/YFpyyXw+ZZTx2QVPkni0sK+y +LDC6o9ly1FZd3kVcP9AW9HxzoHagBRh6QKSI3cbgsGZjl8Z/RM1G2NqkoZNCmCtrSeCSX1SyqcQ9 +qa1k26Xl3IT2QBXBnvqFCHoKg7j/EJg0hcFJocycY3Ccdbx6nphmq5TiNChKSmAEOHkser+KyCqc +qinb4awj07LZhZYiVXCYmhImib9YxcCigzaRQa/Pyti+m1W3TZMFxEDns6+yl1S363QPKIA1Elk4 ++YyBYbEtbl0UQXeJZXOJIYJV56GGpLCt5Gh1exWBzVw5KJIUQY/mZklaQWrXthXl1XnBSWgbBVl9 +V0vRz6u3sacEIHDRMD+FevnzK0exV+/0KNXSRnsyKra0hRAsK6KgBzHbPJSNr1sOloJYmuXnSKyQ +P49OPZ0EUSIcdea1OihVAExFMyW6H7rOLh6tDXPUVbD0T9ek+S6zbqUVXX+WjywOB/x80WWoNji2 +tOUSTTevXoMkAcXnvhanU8WFBRwAgWrLR+blDcDSLBatnjtsWqumaduxDWxsmUDzqlh76rIGqBFY +tF/kZ1C0PXFqFhkNwDVr0msTlQxbJs3+XpvqPhXztzXHt0iAomKERc/eUFI6AzXkLOnjjCDYWSeh +9qWAe+YZHXVGYOS0RW7LNiXAUjIV2qQhgqOeIyN/0ksB93lIjhMDW0qynABC4Josh16ymQAIo6td +SzppKyYAKsuiJdUBeMl6MimLZxOA2U6CiURFchc9tLHqATNCa7lTmo5bg3OqaYotAEGPVwTz0hGo +pMatv8YNG/tZDCRVshISn1ZRBJofg5shS0SkQKJCmO0t7MKMFz1kR1axjq8mXCZ11SABsgEldi4L +sCzWsLX+eTtNQsELmR25CgEBc9UYqHH35PxHFY9fanY7qawyGRdNISfvh85QPadop/EInBXsXtbP +jOlxFFwMsw63owDPQOnLNK8CgHq+LPFxCZEpMgR2UgkaLnNJbmoxEEZQaCqS3I8yYtGzGD1jFdva +GUGyaQVYdN1SFqcIKYmrYcsldpkYog637MAo55IdA0hdUGY9NxjMY0byNwU3tC8FHCSZN3WZ6IE6 +u2FPaJIOkLzO1GwTTibpymq5+QOQtkgGdpUHI2O6FMnUfql7oOSyxm5+4saqZzfUjwrAxQQHheZU +kXF8SMFUV1H/IwtYBuamvKUsRtUGc9PjUprgg9bHYghat7VrWZVWjUChpZlV/gUs4PTSTFVdjYY3 +8Gzh4VHluWdwJ871Vrx95WlsDYCdu7ILoWdBdmE5CaMOC3WTJwvDoRtEYjXQMdWwZtM5Iutt5uKR +TKCImZbNXDF0OJnAkkSCrq/KAiFqAga69CQ1UHioHrVgL9PEEPQJzno8jcIzL9ipmFVO9mML5BqN +ilfybAEIq13mkWYVo8N2KdovS3xCl694faK5rtB9LefQcOyr+ospl0KwWtAym+IR2c58wXGZlIsy +sVnAT9zfkRNbLTgoumtkTZ29isEyTiKHUF9whFTShiJP4BcUd20SQIhk7WgwdRbNJbJzQ6O8aopG +y7HEgPCaojIhKFoQuorWfGcYU87KRwq9vqDoc580qulhnHrWJZIsMAJgzVzCCChvxAgUF2TUUCRG +5UsRfnWxTkkEQcCxSXpNNT1PzmC/kMSEIH2lHATNV9BzNZHjli8FTF2X/koMH4Gr4FW7IEmEnYEW +c8KcCVHqInsNX1DSRl83RRYuZnLIIbXYAxxJDrTy58WSTMncuKGnMcDQySFYyVfVVBZamYxWIgoA +rEEJWMRBDsAiBx1h+69zNATLrAg0REiJNy3q9JIEoWCGQeQkCEYQzDZBTyBLcJf4MyKYk80ulXOU +Y6SznoIAj2LFbGUdRcp6YwSzHUoPJu0B2DcWnR2UFafrLliqWbXQbTT9IEr+hvCQc+1QYdR1YFpD +7IdEpG7ASwEnOXkdLAEgRvMXRy6PwMCUiiDoWYzRTNloBxBjL21Ax6cFRqPB7zfjEJOoky6PWU56 +YA531VlEEYwXlK5NBY1kDqmcRXDTxbFoAvFiaX2Rd3cB1lp11Rpfex565NSoF5Tdrh7cPjcx6V7S +GiIbooxgBrmja4YifwwE/USAGhJGoA1htvQ3xJsVb13k9EazM0yR8zwZWKJu+JYDEfAo22pQdg0i +MPVpLAeAmoVuAWj6XFjtwGnsZ1UqH3dgdkmCDZ6r6VTZXhWSW/bJjgXpQWTMWeOdBo8qFZ1E2YoY +hGTn4XH988aKwBC0B6LnuiNQ0TkpAtqaTdvK5gFAPSIIWohMo5DcGPSzrXjeSoIRsZ9OSpb5G/tx +HVRTVPBSpJsRRMvqihrexJNdWXdgzfYO0YqUxFs7Y49QiSSIusCnanrQIHLU7QWdulMLKJquD0BN +pHerHk9qVl0dlIb+gs/8SmBclLcXdD5aI4DBncTCg+dyDgrAEgnAQgOSQxgsgjf3o8yBD3kQAhx8 +qQkQ7UglaYDKwxCSVlXQw72RT1grgjCbiGO7hLZHm4bJqjIESfGNTnOmBdykHI/koWKxh6ZTS00C +BEpGWXAHL7COReXNPlhsdp4tOyRoyj5W6NBTVKEniiNYNdygBwwIKE5fU6IIwWrCVPcuqhEipnxg +Z8RLBSc2GAPHPxQcZh0HqdGBwDkrvZWTHhGo0YPQFWosiUIpbgQWNQbLwqwh6b7M+jSVxpHcrdCP +WcxttqhYZFOVa+uoYyqoKxbr8FCMUngrmwrW/FEXQdTMDawOBBNPmFO1OlCvtSQyghFEi5iahX6h +6tDfUzkirFMUnPMgBCmSlFhV4fZzUadES3oCneSPtIxaCKInyiC4LGrmF6uUFNYgBqKu6HMKuFIS +mpOtWGY0CtEHBWc7MSIZ6uT/teRkIQ2BWRNj5h5krYyNweqW7v7bnsiFwKLJhLOlaJR+Xr2YI6pQ +OopmjTe1kjc90K4VMyOQMiplLOCq4Rgjorj8iCAJ5hgHCJpzEGeL2J/hfSkvTI4V5Jl8EHC1dN6a +NSRTs6YO0QmmFxIoCkWBunOUZHpdsTNYFNPR8JXmuZ0TcDDK1CgrWg2UwarFWBYk+gEsnTdW3ilL +4mqyKycXqS+XA1MaZtAgZrIaL4VOvV18vxIGm8qqCb00Ag8KXpSwOmuOQUgaMbXg3mJZjBQxVYu/ +RzItJ2Phox4r5/YkTVHYvF7oGtJVMhOFMLByBDabxd9mA4rSjEk0uWckqw6B3gFLVsmaodT4UAUT +qyZ/P+WPCVLq+t5QJdOOzg6qh5lk3IOAc7OjFKhw6DHBXlqBPAQvLyMR7GG2wl6ZdagHAato7+c4 +sQ6B5aBJ8ibClgtHYWfWomTVi0rpD61qOO+cABmjJbpzdaSYPyi4We0IGGMp5yB+npX93drvcyQv +qSbgl1UCRPBN+enVAEX6YxCBCtdFTLqZiwO/HMDQTXarvNTPn0PcR98SPVQAsKL+gqVbUSZineaw +UjIujiReB4M/tHmhG0sWmDhU3jXyfSVcARD0uoK/h1dKfvWD6HVtCQTGMkik06xyyGtpwcacwtQo +/rEQJNnj34iSsSa2W2ddK6gjgOJqZUWCqAgaewMdvGRVaYKF+sSHqYXyYm3CDdlVqExdUn+R1GEh +JUVE3sLyV+maZ5Yts2V+z/gy1F3AEuzloygK1BAox2S+Ib4sePyN+IIZm6uW+eGaRMsaLRC+RDn0 +tKyoTVopGQxgtLNBX7LUysPWGkZcUA/BHQzxoqZ5c3HAvpEFhafCcE0ixQnTMx4EHNcWHPjlBhzZ +ihGacULhrZ9Ym1H15jWvzQGZlcAWvLrMt0WFLUaa0h2rBwoFqsXBC9cNYR4cuGKalPFrShjIo3xG +GAF1iGDzTGNbxxzDeoFjUoASXxdWYTz5kGgdN6xJhqr+slKolmcPOhgYiEm4UkMOSwgWomFm+fqN +rCpQUYkTcgxIhl7qVgQ7CIaVo1YLbll6+4IuraqeyWDFbtChWUQl1/MnWKhLBqjaPkqhiLwqc+LC +hM0Y3cFdH6c1cIPXEMzwHBN3l1jKZRIrZZkha8itx7MhysKi+dvXdsQtDKc6CDoFskcKG9LoqE3A +RbGoLXq3eMEvGC5sDKbEfilWGVZZQiByys3FIcNl8eO03Oy+l7GbY5VJSCbhwwaMIZhWbrSUIhGD +I95r8iUql2FA5lySIm1DWzycHfOA1QOFAkbQwQs7PAesK2odaUOBAlWmCbW9re+XYb3AA+TRX339 +17v3H46vv/nw+t3bV+//fPMLAP3sv/785q+/+vD+9dvvbn721R9ffX+/f3NP9ab/+Ns/f3//85v/ +DRvtH230t0du8r/DX9xHv5+oJi16U7EAEWhaVB4dFFQqV7tQVNkVHA9a0DvxPoW0g3JdWbKQNfuw +AVv2yjybsKjmWQLmhaJCnoA6fJw8MrSl+iBlRNph8n4dPQXjvBWR0JHOfFhvJECAjKATa219rwzr +BQ7g6NHp3EIVfuGHmQrJg1ETqAj6EjMo78hX3PFZPyiB7ptMXCjdmMvZdIiatMqHDVjKmDDBvIsj +x+g0HncOdqvqgMrdObEYdG0xgyusG6wdKBQwgg5eLKfUYZ35fMJIgQCVvUqttfX9MqwXeCDsDXht +E9ZWBjVWr5TgK2/A3I3E1ah3DUVKQsfqqnQ3nXEXFF/BTFVXHjZgrLtkjiOuF4tTr9oO00qOHfaN ++K1A5VvHllIScUTZgfJ6Za2CA5dgG5HO7Eoe3y9AZa2Sam19pwzrBQYIa2esYI3XC6x4VxDdl5Aj +XTMC5kcl9TXalQ54OQJCslNf2UdVZd5kMZ48VLIkmV6wcXVVa1FVWV8dqMwNZY6btrisw7LB2oFM +QBcrDA0cFBiRznxKeyRAgMpcJdba+m4Z1nMOMG/B7GxLpesy5kBXYYDW3SJd8wKKPVkEGDpdEl2W +kDJf8oU2QmctmFaCOOKh1YcNOFkkFwsKF1IVmtRD4a6VwjumALlr6OXUeW9tcc2FuMHagUKBDo6C +A5+yGbEueCBxS4EAlblKrbX1/TKsF3gg3MXEIZSwsZG6hdZVw7wOupMi0t1kyV9CVljuGmfxbkTG +GjBJ7mEDltLYTCuXG6VJJ4kGqHOKxSJA5Wyqcdm0jVLEb8DagUKBTXsBB3ZDjlgXLmA2UiBA5axS +a219vwzrBR4IZxc6+0eyJVaqYA86z1qHW354mrprP6pdnSJbaqmNUeMVwmwIDWCt/ISO+rSKmRel +ON6MNabUMiGgslfsdd8WE2TU4jGsHkgUKAIFh9tooQZFuvQASidAgMpdJda17d3qSA== + + + zzjAzM3rWukCtiUvgaTDDNrpyNsgsqCi24AuWbIrdEQuZX1b09L8Hhwtc35GlWQRsa8VbGZZcR2o +BkhZa960xTjvvG6wdqBQYINjYM3ucFiDBpodAQxT1iqtvaXvq6E8YwCydmENN6fAusL5dT+dwXo1 +Ub9bix0zxuCSFH9ti/FXoRg7n5W+VXwv8VZOsWBZ9uJhZt6JjeFb8p0OA8oO5LfrxztUAxUOZ593 +/e0MU94qnX6G9m4aym3fv9A82T3NPPmdePcW9e7BP99ORa4V+fFq3rbBh/iCYrqgqIvsIdPxYQMu +PXyLZy1Yj10tA9bKMhqQ+G1ZAL4t1s2LZYPVAZOzaR04cPrliBUvHKlbCgTIFHRqXdveL4f1jAck +qb7cYKSqhIlJk3zEhw04cLI/VXBkax+zaZsVt5zj6oDaMU7sH9qi5zI1j7JD5N386Q4unEc6oqy3 +6MfYvF6AOrJKam/retSxnvf+WsYi57PM0jkKSz5swAF9V1peE3DIRqYVX6Bz8NLmgMrbsuZl0zbJ +YfkBawcKBcpeBfeKaw5rtROzjgIBMoJObW/r+uXquJ3x4ErGIuXlZPPRWBTSgVGJCMrdRHlQyDHQ +0XTqLCl6oHIX3WmbthjbbHmDtQOFAuWugnvlToe1WLknR4EAlbtKrWvb++WwnvHgWvYiEkEu1pWd +KDJ3HVSOkTCw+5xryMpdLqxqQOVuizp3rW2WAwoD1g5kAvTzCu2VyR3SYjcpOQIEqMxVYl3b3i2H +dcuBK9mLnCW2qCaMtQkfNuDAOSIvpPCvGmatylItcqGUAblrVEJq2bTFs6Jx2WDtQKFAmavgZEUX +HdZsSU6OAgEygk6ta9v75bCe8eAK9iK9v64yZDVqKoQDB07LZWBcFEjbJ/dLnPYKVM4uIhtdWzyN +qkDD2oFCgXJWwXgJw6z1qhVrtuMvjgIBKmeVWte298thPePB1exFlFeUw0buKUzgf9iAAyezcD9a +1HmX5MQoVugOOsUJqOyNy3zeds51OcOqQKHAZr6AYZeRI8IOKx7aCVsKBKgIlFrXtvfLYT3jwbUs +Rrz/r6kTh4qMPJyB9UoNBKaq5kfvG2yU1QG1bynq8Li2ParpsHYgUWDDY2DLvuxYU1dCOgXJKyyd +2qFt75fDuuHBdY1G3Clak9GjEwAPZ2BXY34x3wSOrbCiqKFd1V1BNzfOy7ZlDSGcoexAer1+voP1 +bIVDOsx/fb8ATT6Zv8Ta+k4Z1jMGfMN5IP8Gsa2PmY5syPyrWI8xW2TDW48OXDi/4AUXi6bzUj7K +hWWHW/RhMmI61oalLCXfNokzf8DqgN56dOBgcWeHVc5ujRQIkM3PTq1r2/sVfCXxDQ9EUfwiw5Fu +IdKECdwAHzZgTEYoWpqbT0Igs1yZ6c5BAipjuWKUb4ulbVfeFztWBxQKGEEHB02rc0gXO6LiCBCg +8lWJdW17twzpOQeuZzyiAlXEz08FUR424EyeHya3UaUg5Jcd/QAFS3I+BMhda1hmMo1t8URNCW1A +6mDyfh0bBVv+s0e6WMKfI0CAylsl1rXtvXJYzzhwLdMRq8+noIZbUbu8Q/FSksSrqXLqK007q6G9 +yvk0Aypv+dY+3xbXc1LeKlYHZAJMoCTlrR5sckjBYFrl0olOgACZgE6sa9u75bBuOXA1uzEWzTnB +W03z0pmr4NxPF1U+qMprejXm8jlBAypz+Tzw0LbJyZYBawcKBYpAwcEXaVeswc5EOwoEqNxVal3b +3i+H9YwH1zId8YYDCd5Hzu592IDxrkB2/uAFBVFNBk22o9sFBiD3bcVtN27a0uUs6wZrBwoFNvdn +ZU5r+i5FGjhyNRIQXEDNEeva9m51pGccuIbhiFJpnjXkhaeGHjbg5C9z4AtSadJJJjNez9DC4oDK +Vz4VOLTFSovKV8PagUKBIuhgLdnssGK8pawbCgSojFVqXVvfXcN6xoOrGY64dHrQap51M+vgZFfN +4gUadDCE80lnZW+t6icmoHKHbwwZ2sLGU5S9hrUDhQJF0MGa3Omw0vGmtKFAgMpepXZo27trWM94 +cC3Dka4cCbIkss1dDzUlpmpiJlIWs4phvn7VgNq1KlkYQ1uu+bTB2oF57azpUL2loePE2hwG1PcL +UD+vtA5te6/WC7Bs8/YK5iKSm5uao8U0BQ/WUzTYCzqktBn0nGY/E2zWhDmdteXr4zZYO3Bc1QbW +qk0D1trCGQG1ddZ2WnvL3imHcsMANhc/Zcz9a9hxdFBf50O34xy4l37Hwv5rEZNNq4UlulWsOSAx +I2NV0NrGthnd/KrLuYLyCvR2nAN3Dcth7ckgjgKfDOKodW17v9wx9zMeXMGOA6RrVVcOFhJ62EDd +rRUrbhcS+LFbM/CE9BodUPk6h9TGthn9p0sYsTogE6BsVWjQ69ocTsto9u8XIHO10+ra9l4Z0rP+ +X82Iw2svFh2uiHW1Hjbgft8o1sfITeax1g2iGxvS6oDMmlmuMPZt82I7VMfqgEKBjk3fzaiI14h1 +4RoHIwUCVOYqta5t71fHes6Da5lxeFdILupWnJsxV6GY2hmFtyElPU6wsLczUY2j6IDKW1Wueltc +zUGjb4LUwfj1Jk0EGq0OkMMZ7C48934BKmeVVte2d6pjPev/1Yw4vFml6ZhRsdeHDThzQQ6mN0aN +yOldjdA3KufSgcrbJeVNWwDSydsBqwMKBYpAwdFuZnFYg10l4CgQoHJXqXVte7861nMeXMuIw6o3 +MauBqsrwAKVSsExuWjRSL8Vu6cqXHDuMO9bkTKxrSdNOvX6KcgCaIuygeJDfyg4pzuD3MH198HtY +p9S17X1yWLfdv4YBR8Jeh5DORT5swP3kOFUt0hxczTmGboFKWB1Q2UrHUrZt6Q6iEWsHCgWKoIP1 +UhCHNVhxcEeBAJWxSq1r67trWM94cDUDDpfNogNZ8Qqxhw04mcqKBFPhIATqKUEAtrAGB1TuhFKW +TdtmOqvD2gZFVl21A9ivfcEa+ubUKQjjRqbUDm17dw3rGQ+uZcAhDVS3htP+Q5+8DjxXvUaKiy6S +sRON5WtQpwgBtW+tapjf2ja8lytusA5As24HsBa5HLCu/SasTsFqka2BWte298th3fDgalYcli5r +OnAwWn3ydjCVNBVgsQhdH/kqmmgc95Kyzudt+RLqDdYOJAoMgYGlEP2AdK3l7P0I0093Ul1L61PH +uOn+v58Nl0FErWty9svDBizX4r3gyoHSv2q1abB2oQXo+tlArImYW920je7ItWJ1QG/DObCUSxux +LlwCcKRAgLyBdmp7W9evjvWcB1ew4fBanHURH0qy+iYOnC32j7eshJ6L1vQyEa6RYUDmyyJlooa2 +ePx2TiNWBxQKdGQUbFWHHNLQmd0JCP2AvCc2eBZqtwzpOQeuZsblHiZMfDrvYQPOrjJmbEWsh6Tl +N7BK67w6oPKWj/QPbYMdiDakDpbcoUEHjv0egY40WLUxR4AAjbdt29b1qmM958C1jDgs71maGjHZ +OKvAzBcJM7WpWATYrsuBUW0dpozlave+JZYVDhuUDkgvV7YqsOtWDiXmZEu5mP52ASpbldDe1nWp +Y912/moGHF7mZAdzqOzewwacudTpC7ncqGlIWe9XQCm+LA6onOVCVUNbqtPYRqwOKBQoAgVbFVCH +FGu5WJFaJUCAylsltrd13TKk5xy4lvmGt1xZshlJpIczsATRc3MGc7T9A6afgzFf8PCixvW15SIX +WzuMA6xLSQeOVtTd4Qx85+T4egEaX1sJY1vXpY71vPvXsN+oerBl+65zr0XUz+RlubsD7/MqcdH5 +Nitbl7okB1S+UnHese2ClUPiiNUBhQLlbAdr8TKHtZdsdRSEXvDBU9vbDt1VrOc8uJr9lrsXL/K9 +qg8bMPrmmpKhtm2xe77mdVk6TFmbLGeyt6RiygNCB5SX6+c7mC5PHZH2ap3u/QJUzqphrS2HfirO +885fy3DDsaUSloR51gOUI7harSs6rsejmxa7Lq6pZt/P6JXZJZlqW5SISaWcYh2Bs2YkDmB1EA9Y +S27hjAICGm+NWte298vczmc8uJrhhjXDoh7Ip/DuwxlYq2Yi0PYAN/I9pE1A7VyLmgTp25ZWz7B2 +YI87D2C77ddjNVnZ39+6qO2UWrveI4dv0/un2G3Lv14iZUFfizNbHgZg1pp/dCfBKs523snsjhQB +ER+q3s3m2m0wjUaSQTA8ylcCOhxYKX/ZvIxh/MlOlbU02jvCbR+vdcgO8BZLdaBLmx824GwpY0jq +mkXRTanptRKlRQ/kbuHNexrEsLaRSyWOWDtQKNBRUHAP6DuswS6hdRQI0Bgr1Pa2rl8d6zkPrmah +FVwrOnDRjtQ4MN54JHekYBGOqCUrkl37URYrj5PUe4tXnMxqFVtbqZA6Yu1AoUDZq+BoV1w5rEEv +JHUEMEyZq7RaS9epjvKcAdcy0PCGEKvvFvSctYNmPOGnN4yo76pfgo53pyQHUr6mWWM+1hKP4New +wdmBya3mDo3DLTOzmmN0z7N/vYCMravl8kpL16WO86z3VzPRKs5uVUJJLD+cgZsEcuosl4Dzgi56 +mVQqsTmgspaKV4xtg23nDqsHEgWKoG/9SY6ROazBCuU6CgSo3FVqXdveL4f1jAfXMtIqSWc1/zDx +++EMbDT0sLldQrRg3YrggMKaTbPAZU89Og+iF9uEb+pVyWIj6wSe9f6q/lYBGj+FQte298QhPOv1 +NWwzvA0uaCGbuahtNoDd3sX3a9NEk2sRsV+LWnFWY5I26qaBImsb8O6QLVYPJAqUqQruKpvD2q+S +cBQIUDmr1Lq2vV8O6xkPrmab4QZao2a0rqoaOHDq97QBwVLtKFmOB944hTKsA5W9MOjnbdeW8wZr +BwoFiqCD/VVYghWrC6awoUCAxt5y1tZ317Ce8eBaJhoJI3UVU8rBwwac+saOtRWrMSfq1KG6Vh2o +zIGNvZ21zU3LDTnVQoHR5UIMYDGfHdLIOY0jAQJU5iqxrq3vrSI948B1z9QNo4wpmQ9n0CZX3dAt +bOa9SlF3ke5dIKDyZ2lrPWvb67MYVg9cY+dvh1Jl3BHpMKW7e4GAxmDzqbmJ2rtlWLcc+OIzdU8s +yPIxU/B3/2b1WYB5sALW7Qk7D7ZKKnNtFvO0mitzxSxVVtNcfZa50s2666ZtdFU8DGt0VTzMXPRg +q6TisVrNFU+Bq8/iqe1tXb861nMeXMl0nCtGXCz6o/VZPJiLqWDHVsltspor2DGNwLv6LNixHMaW +6yKlpA2hg7jqLB5sdVQ6Qqu34l/tarN4Ml3b3huH86znVyvkWfFOHLWGrTaLB1sVlbnS5fWSXyrH +l7Fz8M0XYVG+Rtkze9t1lmsqPVYHdLVZPNiqqHisVm/FU+Bqs3hqXdveL4f1jAfXKuQJQ5yDHS/T +2iwebFVUkN4ya1lfqbeCfeObWIfaLMiHUMeWq48TKU4HdJVZPNhqqHScVmvFv93VZQ== + + + 8ZS6tr1PDudZ/69Wx7Ni1W/Nk9G6LB5qFVQQ2NZVE6C51grgxOP+zQGVs5pD2duus9Zad1gdsNdl +8VCroOKRWq0VT4Cry+KJdW17txzWLQeuVcez4h0cq+oR6kTyYKugglOErxJytVawa1ph1NVlQTbM +YdOyuXp7htM7zawqiwdb/ZSO0+qs+Le7miyeUte298nhPOv/NWp44vtnNfytJosHW/UUBFYLTkqd +FeyXZlS7miwIVuvEtQVBmbWCnmHtQFeTxYOteorHama+p8B5Azy1rm3vl8N6xoNrWY+0C3QjTWuy +eLBVhKAZknTWSZ0VBOoBY1eTBcG1blo2VwjZcDZfNFkrsniw1U7pOK3Gin+7q8fiKXVtq7NdDedZ +/69kORJpVtLW6rGMYKmcgkCQ4770igDX5ou0aN+Kpau7tmVt7QxrB1o9lhEslVM81tSVlE5B8kpK +p3Zo2/vlsG54cFXbkabJqjVWrB7LCJbiKUiL3HzQtMoKzahFoxdaj4X6F7btetlVh7ADrRrLCJa6 +KR3lsJr03a4WiydzXCVrv+6j5DPg/xS1WGYMU9gS7paiA1vVlLmsVtnb6qvAyrAJ6WqxzHjD15zy +pm2U+5EHrB3oLUUHtqopHqvVV/EUuFosnlrXtjkpbFjPePDl+Z+IVO7/aK4Wiwdb1RQktd/wIPVV +sFudg1aLZaZL2bS+prXFm6nVsDesHehqsXiwlk3xSK2+iifA1WLxxLq2vVsd6RkHrmYsFsxBVe+C +1WLxYC2bguQucpbZ6qvMdOveEhyQu5ZxNW3bgsHQr5IQpB3marF4cL+L0iG1+iqeAFeLxRPr2vZe +OaxnHLiWqViav2pFTlh7qFVNQXLnHH3ZFe4aXxI91GJBNmidN9cW1nPUGI5h7cBei8VD7fStR2r1 +VTwBrhaLJ9a17d1yWLccuJqtCDRUy56zWiwebFVTZrxeMpWxFgv2rWU9N2m1WJAPoC+lTdsst8YP +WDvQ1WLxYKua4rFafRVPgavF4ql1bXu/HNYzHlzLXATMSW77cLVYPNiqpiC9q5z1tPoqCJzrsq3F +gl1WY8G1zXjndthg7UBXi8WDtWyKR2r1VTwBrhaLJ9a17d3qSM84cA2DEaVStXKDWovFg61qCpJa +5ZYuq6+CwGVdfdEV5WtJ6v2xtgWMZgtiKtYOdLVYRrBUTfFYrb6Kp8DVYvHUura+u4b1jAdXMxhx +dK32q9Vi8eB+Y2DB+9Bmc8DatIUhDA6o3GlS+961Lew1H7F2oKvFMoJjsLaKNbJFOVIgQGWvUju0 +7d01rGc8uJbRiDTMZmjY3PXQloPKhByilcZWwlLoBxL6goyLBsp7yxB1MjqUHZht3npoWLJOUcWp +hRD82xmmH1c6fcveIYdy7Pu1EkGJ2GD3WxTTEjxYDopSJ8xM1JsVsQ+xFQe0GZM1j9O1rdlO7Has +HTiuaANL0ZQRK1dXGQnQOiwjrb1l75RDuWHAv9sZvhnPAiU9WdFtOAe2iilzhh2mqakhtVVgSeEd +vB5IzMjRzjO6thhhUz3OsHagt+EcuGtXDmu/aMdR4OqweGpd294vh/WMB1ew4fAEm1yR1+uweKhV +TCFKZw3ySG0V7FWWA+SuDsucUe/R2Jy1DXYlqMPagb0Oi4fa+nc4+82S7v2uDoun1bXtvepIt/2/ +mgGX8e70qHuT1mHxYKuYMmcsUDmLcitJ7ti1Eu1mOa3DgmzoEW5rG213clij3zS1DosHW8UUj9Vq +q3gKXB0WT61r2/vlsJ7x4FomHGCuQStKaB0WD9WSKUitZqlabRXsWY0a+bE6LMgFVaxc2+iqoyvS +Dut1WDzUKqZ4nFZbxb/f1WHxtLq2vVMO67b/VzPgAHNaVUWwOiwebBVTkN6aVOuV2irYN70BztVh +QT60qGNjbeEVTY9KGdYOdHVYPNgqpnisVlvFU+DqsHhqXdveL4f1jAfXMuAAs1ba6XVYRqgUTUFy +Swl6+8asvG1JbQ+tw4JQCk0MLZNlkTiUHmhKsINaxRSPM/g9TF8f/B7WKXVte58c1m33r2G8kbDX +TECrw+LBVjEFSc1VPQZ6S2PGyrRaOcjqsNDeEtRnYW3xR7sLUbF2oKvDMoLl/K3HarVVPAWuDoun +1rX13TWsZzy4mvGGy6Zo0qDVYRnB0MtV+tGL8UvaMAIXqUCXeooxrdJFY6HWNjud1bDmQZFVN+0A +FsvWIY3mXnQEROeKdMQObXu3FOkZB65luuEAB5U+VoXFg4E1S1Vhq9dOoT80BgGGrGcwgiYiUo9n +S7PXthlL/q0brB3oqrCMYDrbMWKNfXvqFMRxK1Nqh7a9uw7rhgdXs+GQtlVTfK0KywiWeikI1OKJ +se8OxQqKx3Enia2dt+3lrBzWDrQqLCOYa6aMSFcb8/5+rcIyktpb9j51jJvu//tZcKngmU+fLfmw +AVu9FFC4YRFrdUyprALCzYXmrArLnIIpo64tKP1gsW6wdqC34BzY6qV4rFZZxVPgqrB4al3b3i+H +9YwHV7DgUrFC+K4KiwdbvRQktebZssnYzQDdSrl5IHcr4u3q27Z4kbeWJjOsHeiqsHiwFkzxSENn +SyfAVWHxxAbPQu1WR3rGgasZcakHCF0VFg/WgilIbul3e3BlFexaTi06oPI2LXqHvbXF4zoa2lOk +HeaqsHiw1UvxSK2yiifAVWHxxLq2vVcO6xkHrmXCAea06I29ah47oJVMIWol6Ki1VbBjJWrpUjMy +UrRLfHtLvHxao5uGsgOtCosHds3KobTKKv7trgqLJ9S17V1yWDedv5r5ljAVV2+wsCosHmz1UpDc +nDXqI5VVsGv9KkGrwoJs0GviXVu6HbpusHagq8LiwVowxSO1yiqeAFeFxRPr2vZudaRnHLiW8QaY +537Lg1ZhGcESPk/ZmcvR9o/V7lOLtn0AkTmuY0s8/JHriNHDnJTsYKuX4nFaZRX/eleFxVPq2vYu +Oaxn3b+G9Ybbp1xc4aqweLDVSyFaF60PLZVVsF9tXn25FeVrP+5rbaNl/DqsHeiqsIxgqZfisVpl +FU+Bq8LiqXVtfXcN6xkPrma9pe7Dc1VYRnCV1OeER8v1TrHCRxOpc03jBUWPMZIETDWftQUFZt1g +9UArxeLB6AqoiqBYDqZaDY6C5CwMR61r2/vlsJ7x4Fr2Gw5xUsvSirF4MFCxqrBVZRx9oVHJ7XX5 +CKi8WZttutoWs1LNfBOkHeZKsYxg0HRs/Te7fXyty4YAASpvu+Xg2vbOGtYzDlzNekMikpa1tlIs +I1jOyhJw6bEyjgSn7CLaVoqFwEnP3vm2s1pfDmsHWimWESyVBEasrZy9v3V52ym1dr1HDt+m9/++ +pVjm2N0t3oJzYC2iMkfUOocyK3OMdhrayrHMERX7oWwLTAxLUO3oOsxbbg5sxVQ8Sq254t/dq7N4 +IntL71IylGcdv9Yxu4iX3wbNX9QKLR5stVSQ3NQ0L0qqrlDP5PS+q9CCTNAz+a4tnvRXbc+wdqCr +0OLBVkvFY7WqK54CV6HFU+va9n45rGc8uJr1FrPzNluFFg+2WipEsOWiyTFq7FwqWgDHKrQgI1JV +i9naLqhhLhusHegqtHiwlVPxWLXuiiegV2jxtPaW2bnbDeUZA65lvMW8KZHysIFaNRWkVv1aVncF +O9alhtVoQR6UqmcGre1yXvfFA5Nb08t5PRWP1CqveAJclRZPrGubzyu/nHPgaiZcxFRlPYVuVVpG +sNRTIXp7CX4JDsZuE7gqLciHtWqFU2sbnFpiWD3QqrR4sNVT8Vit8oqnwFVp8dS6tr1fDusZD65l +xAHm1Q5LWZWWEWw09KC6nrWK5KP2pVu4Z9FtW9YWV6eqccatDrJSLR5slVU8TqvB4t/v6rV4Wl3b +3ieH9az/17DiACvoGNt6LSPY7WQhr2O9FuyXVlBz9VoQHOqmXgtNOVw3I1YPtHotHtz1OofVarB4 +Cly9Fk+ta9v75bCe8eBqVhzqKrP6OaxeiwdbZRUieNEESs0FiahY6qUUVq+F9hdLoHRt9Y54h7UD +Xb2WEayVERxWq8HiKXD1Wjy1rq3vrmE948G1rDgSS5YqqfVaPDj1bR59SkG3VK7Bgn1rlkJp9Vpo +ra56x5Rrm1atK+QVjVWrCvWciQHMpVU8UqvB4glw9Vo8sa6t760iPePAdc/cDaOs9VpGqFRWIZq7 +n4trsFD/zAVg9VpoTpn26tqCAVA2WD3QwqQDVCqreKTDlHZekMXZEP1cuJuovVuGdcuB/5D1Wtwx +vC8d9bOCLXgLkhpxNBcfNuDM/gMA4nY5V609IXczz9FyAv9/9t51OXLjWhN9Ar5D/VGEvWODRl4A +JLZ+iZTt8Tm05bDsGUWcmOig2GyJI1562Gzb2k9/1vetTCABFEmguklWsUsKiYUF5H3lynXPCMQS +GCPnnSnd8FvTIneHHdSaA2MPjg8U3B8cBJ+MwF3OF2OEcbchWhvTNSKDjhFI3GCcWupY/LYMSCSQ +PFYTwmTArGNrZuxEcAa98JB88CIYDTK8SjOhAm3AvaDCXelAbArNEDBjyhVo1RcqIHm/XlRXtkgY +x3rBL9iYFamE2ZJSRKg0Tb0OOjrJB4xOL7ookaXFxhwv9LXSmQjYnF1aJHWqgJGraZIfo1NdId6H +ikPGXVopMBx+hhZDsKVR0q/AukKuJCt9SQIXQ3OQJwZA7r3jWIHeUGBLHM3CCZ0QjFu8sHK2tB1H +rJEaUclMbSFGVnYuTuCQUiLS0qXLFWUWUk5tma+6VWBUuevcWo3cDa4P4QRCRUOzrENUtGEho3Up +IAOQYRqq6aIfExswNqt8i6wve34VxxZtKwKmj6x+azQJZQCdV1EKHKOKQoKIwgZG4tp2dpjQytnq +ib/M79J5KOrNvmXZhUtWWfrBso6RJ1i0Ot5wJuOtqG/EQrhak2kJMla2iSspZ3XamHBaMHHRPFxK +Ez6Xteei1REThWMKijNJDyw/W5NkfA+SlPZka31KMtuqXrPtUv4EXHyujDqCZy3FmlBrypqzOKuw +E+rapnwAbanJIHSqS2W+Mf8m7TBiwfH61TrhQdB2JPmrb/4U3vz++u3R7ccPPws5vzu/vQawAvDN +X26u/yo0/07IflEo+Oj8p4vr/MXBX97jjSn11ff/849/uLiUag5+1/2Uc+Z3P/z55C83b8/xc3AA +3fvi69Vv/n11eS2vCunW7cWPH+/OP+CokTPs9nT0xdnPF5dvb8+v8d6ufven67v+Hf53F0+y35Rf +yUH2j+uLMwGm8yz/8J+nlx/1y38//OH16RW/QyfYq20dx6+zx/HrC4xD9vPskfzr4u3dz7NHE7/e +6hH9fH7x0893s4eUPn/2Md38+H/Oz+6Obj5ev5X+Hd08sjf6Ab7j/pdP7z7MHuWgzLMP9Zs/vfnm +8v3Pp2/M3DFevM1443vGhG/+c0aPt4VM3n28/fGjcPhn53NnQYvOXOLUznMTTRHW5w== + + + jufH0w/nf7g9/78fZRLmk9BRqWcf4fXN93cXd2ePUMl+lB/49d8vLs/n789BmWcfoZ07tOuPV9+d +3Z3+c8HI8iLPPjBsubljuz3/8PFy/rmRPp9Dge7punmg6+upX3YInP89JycPd/aBeX/mBbm4nrsc +N+/Pb0/vbm5nL0hf4NnR7Pubj7dn53+8PX3/88XZ7CPukanIT7rrLd87F9ePkJDBYOwL7prjm6v3 +Nx8u7uZsmqfoAPmwR9v+3bfn71Zf76W97RjHXtrb3hHtpb01o9wSac9/ydLeu9tTYXsv/3Jz8eGV +yXuzhfi9uLed4t7sfbkX9/bi3l7cm4xqL+7txb0vRtwr7GsR+JaMZMtFPv/qRL4FI9oVkU/koKPz +f55ffv/z6dubf33Zti89MikWvpYD88fLj49wK5+B2dxWyeDD3dtvz/95cYoOLZB68kIvxhP88fTj +hw8Xp9dHuoC7wkvPXpu384/hty9xDs8fyPxT+O1LHMNLKMC2U7Obd+8+nN8dPQdNe6Ft/x1HuEMb +/hJ8C7wEz24ub27/618/qxgzkz7/ejlflRi/3m+gTxjLh/fnZ999fGQ/7B5HMNu358PH23enZ+ff +n50uQbxBoeeXOmYPThb34+Xp7fHN9Ye70+v56zYt+ALWtKWj/P2/399cn28wyr7gLskmRVWWs+do +y1Ucplwwlu1WchR2yVj+e/ZY/vsFeZC/3lxc351E9cVL6CPPv49b9SQyFzvED71OY8JCvmHb2aCN +FD2LrQnbvUa7JhktMZJsCzE4vb24+/nq/G6+AW6XiMLsY++XR5Qp2XDw6RYP5BFePB+I2WZR4Rc3 +fyBuqwcynyr/8hJE+VVa4RdzA9t+dF5e3P319OIxWfILPzt3R1ZeriZevONeaCH/fH770zlmcoeY +oKWb6zWuxdN1YO8ytLFC7atXok5b4JWy3co0Y/YeQ9vvMfRlBYkc39xcHt2en//3bKvma/SMentx +eTrfrrtLSgxzODuu/Pb07cXH+aibPt8N7eZ2S5zzB/J2/kDebvNAdk3E/PPN7fufby5vfvp1h0ST +PVnbIbL2aojZ/AiWLSdmrzaMbSeJWfF6XFZfzU5fFk6xzVt99kh2ba/vnMft643Zn82y7GP27xvj +y8bsz/bD3bWY/QWEfNuPpNmbbOuPpPkSzo4dSTuZReERj5KMrC1zvn8hr/svcsdvvaPGj7OxbOup +1+yR7EoQzt9mm1OPfz69vj6//P788vxsiT5tWvD5LUKzLa2bDnJa8MXOoW8vPry/PD07vzq/vvvz +6fsdOoyuTqWq2YbJnZCOVunf1eSnGfycO2r+ms9/p8+3mFJu/Um8LNfgNp9es0eya7z3McKY/5zI +x67QuwWYte17ZLYOYev3yOyR7AqHNz8S+XkSr2zL7nu3yD/o3cXl5RL/p8ttXul3tzdX8wfDj59f +K/kIk5MZxh7zGM8tYx9fJOZq9lh+xJ1c83Xj+vXzG/Uv/3X66+wxCeW7O71dRCn1++3VhN/dzJc8 +bl5gILfnFAHnDuf07duLu4t/zhen+gIvYI+5nj+us7OPVx8f9xbKR5YVeYGIpuvz09nhL2enl2d/ +vnk7f2x9gecPPpvNW2Srl5r/C4cwdwGHpV5IJDm9vrg6fbHUsLuah64Ie2eYLZPszl6NM8z8keya +9mPvDLMt6t79hYUTncKuecPMz2m2a+4wC0j5th9Kr8YdZv5Idu1Q2kl3mNn85264w3yRO37r3WHO +Xo07zPyR7IqxZO8Os3eH2ZbD6AtwhzFfijvMApq/7Sfxq3GHmT+SXeO9d9MdZgFmbfseeTXuMPNH +sisc3ra5w2y1/Wd3vHkWbLmlxOOF1nAXswYu8APcr8KTrcLT5dzYgUV4ug68UOO7n7Txmz+9+ZY5 +e94s03zNYoh254h6vXmL5qsBdyRr0fMkAH8parokT86eoj1M0eo9RXuNFG32su4p2p6ivRKK9vtb +AXzZLNo5puA10rM9h7anZ18mPfuiGbRXS8/2/Nmenn1p9Cw36rxZZoV/ZWRt9uC/IBveftvM2TbN +l7xtZg9+v22+8G3zZd0W9NeLf59f/vXy9Nc3y4Idt9FhpypX1WzvSZ35vy1woMxK7BLluz2/unks +vcGO5XqZn1Nknx9lnx/lMyHdynxty5Wp5P/lSv77Wn7L36/lxeq1uWxfXL89f3dxfTHfwHV7/v78 +9O7bBdstK/Hs49vniNFx7ViOmA/vkSVm7uh2KUfMTG7kS0sQsy081Cu8oPDHJZeNb7mn/pKx7Iqv +/l5hsb3k4LG9vZt2pUUUYcup24Ympa0Pn7+5en/zQdjy7z4+QsJ2OYAvjnGHCMLp7cXdz1fnd/Nx +bZcIw2yd2i+PGKey4eDTLR7II8rQfCDmJZQRswfyiPNTPhC31QOZT5p/2RXKvBuH6EKpZ5eO0Feb +FfGznKG7Y+LYaE13xoFoHwC4Nyfvnjl5WZrCbdQq7c3J62Zlb07em5OfcTyv1ZxM4gKDsi2/XkRo +9ibkvQl5b0LeXzMyGdnehLymu9ujIt6bkPcm5L0J+fNrJ3bUhPyajK1vL969+zj/NpNtJwULh7Mr +1GB2eroPH2/fCWf7/bI0/4NC22tH0ulfNrZBmWcf2q/nl5c3/5o7vsuLn36+k/fFGfLgzh7iuNj2 +LmDcncc31yK6X8/fd5Nye6Xbiyrd9nfcPj6avdLtKUjp1z/dnp9ffy0c2PnXF9dvL366+fqfFzeX +53df356//frm9vT6p9lbba+N22vj9tq4vTZuzcjm82F7ldzLcFUmzLa6nP73xdXHu0eufsyXJH3/ +7IhXzx7T+aU8LFL5ZCVeTN/z7QX59xPsr5fyiPlWZYmTuMd3COVfk9rpw/vzMzm4bp/DF/7ZpaNX +rayZTaLSEi+W9qcFt3kNY2d//+/3wuttMMq+4Asw3o9oc59ANbXX2+z1Nnu9zRekt4laGtXbRCUO +1Td7vc1eb7PX2+z1Nnu9zV5vs+N6m8uo0HgVLhR7JdTTK6G+j8LfDmqhXmf+jA30UduuYnuVEcDP +qTd8Ifq0z6GxbcTh1eTQmJ+xYctzaMxfkS3PoTF/IFueQ+N57gHZbm/i7T8+Ly/u/np68ZiVYn92 +7s/O/dm58UC2/Ozc55/atrNzKVXe9mNzI2F6V47Ofd6pT5v7bTl2F6/nPufUkg68UOP7nFO7lXPq ++59P39786ynuL9odSvSFZxfYFb/O2UnR9hH5z76FZl+s+fYRcpq7tf37BZBs/kB+nT+QX7ecAmw7 +Nbt59+7D+R22xO3520V0etdkgO840i9DANh8VV+jJLAtq/K67xPfi2a7LJoVpvpqLkrO5zNegs1Y +MpL5jMZL8BnGl7NH8q+LtwvcCePXzz8iN39EP58/7nmYDSl9/vwc1Jeo1HiCLNq7w13tlRo7odSo +90qNrWWFw2tRaswfyF6psQPi716psb3H7l6psY2UfK/U2Cs1tlWp8YWJZnenCxwtX6Ng9u729Ozu +9PIvNxfzHZu18Mw1Ti09t3/m4eycLT+efjj/w+35//14fn02n+MclXqBmPTv7y7uzh5RYOUSG77+ ++8XlglwJgzLPr/ma7WN7/fHqO8Hify4YWl7k2Ud29nReZs89kmVarS2Oc54/kicUeLblVHh9yY4W +nAfvbm+u5g+HHz/7cF5T6qbXmuqoPJx9a8vdzXx+6uYFhrLPXTQY3D530T530ROrlufLJF9a6qIn +URr9/ePtjx8vZbJ3SY/4OnOvLBAptlw4ep6UKy+k510SH7ZXta7lD796Hd5j88ex5b5j5avzHVsw +or3v2JpRvriBoudL3jwSfv+6zRR3OX/2iowU5d5KcbPbVorZ3ky7ZqTAltsClfhe3Hvd4t4SNNsL +fHuBby/w7QW+vcC3F/hev8A3WzR4jQLf6/VLm53TYS/xbafEN3sB9xLfXuLbS3yfhGZ7iW8v8e2w +xFeY1yLzLRnJlkt91auT+haMaC/1rRnli0t9/+vm5u1Pt6fzz/vXKPK9yjsjFsWIb3mIxGvMeDFb +mNtnvHh2grBP4/nQQPYZLz6Rw0h5IF4Fbd7n79haMvbuUrg7vYT4v368PD375euVgm7en55d3P36 +Xwt0wh/ufr2cr+OOXz+/C/eSC5e3fWctGsyubaY/ABF3aC+9To3osv2yE+fqZjmHtv3Wnw9M5Xj8 +msjbl8M47OJtgK+J4V56feaWb5yFw9kVhchsr5MPH2/fnZ6df392uoQjHRR6fk35stVaNrZBmWcf +2r9+XhCdfwmtvrwvZnAe2QjHxbZ3/eLmPL65/nB3+thVirlWZVxulxToxs3evKf/fXH1cYFpq/v+ +2ZecOPdqsgzVs3NanV/KwyJlc1bixXisby+4b06ikfElvAakD9zDJ5FY7bm9Xbn1dc8i7RKLlBZ4 +8Rk7LfgCfvJLR/n7f7+/uT7fYJR9wS+EJdzzSy/PL+3ZpT27NLcP30dCtYP80uu0BmzAOW07M/g8 +btLbv057lfkzpBO9vbj7+ep8QV73XSIOsw/EXx7xKciGg0+3V8745ZEv84GYrV6RRzL45ANxWz2Q ++ZT5l5cgzK/SkXip9Wzrj8/Li7u/nl48JlHvz8792bk/OzceyJafnfOZgC0/O+cPZMvPzqVUeduP +zY2E6f3R+QqOzt3RQ+9vadxGXujJKeEOrMXTdWCHEOG1piLaJ58djXL3UhG93ivyNrIYbDcr+vfF +Oax3jW/bySRLV6dS1ez0ErtA2M2qjP+u+9VB5g6Zv+aTjfT5DuyvbacYf5SiHx53HttdgsFIqj+n +DbgrFOMVnk3PGv+1rdkX9ik+nj9B2qvJ8VHMFqa2PcnHsyiinnlM330xUa47lx7jdTrxLWbdXu8O +2n57CuwNGNnfX3EC5F10R9hkXbZ9H+Vjmh3WuCustjmcHxu1Z7b3Z9Jn2Es/vDu//cPF7TaoSLZl +ne9Of5y/xrug0LSr2XYOjv1/LtNYDsq8XCquj9dnf9shavLqsOywWZWrLwPP/rjHsxfEM/OlkLOj +l3IxobCDqOu/355ef3g34xaJ7cH316kP2YRV23b2c8M4k13QhujQtoSv3utD4srQc+6by8stWJNt +mZLNkHXvq7mkAy/U+KLrn7765k+mfPP767fdNVAAVYC8+cvN9V+lCqYpKRR8dP7TxXX+4uAv71mH +11ff/3r1483lwW+OTt/+dL4yq2L114vrX3578FH+LVffHfQONT/8Kg//j/z4PwL618qv/rz6//53 +uXor0B/+dlAelmXZhpWtDptqdXVQmMPSm7qKgMLK+8rUK+sPq8o1ALSubuW9O3Rt3azODgp3GIy3 +K2sPXYky/rD2Vqo0h7YJUqQ6rJ2RFwIojfcoUh0GG7x8Ux62tZFvamm2qhoCXIVn29ShTc9SpDk0 +oWpt90U4tD541uq8q1dFiyKlAaBxgT0zJT5q0DVjrDRjpE+VdEEAvm29AGSAvm06AA== + + + Csk4mtAMvqk9hiwAV1kCQtPUOmJnWMjJdJWejct04rkNjv13pZH1Mf7QYqJNOAyVjkhA3rRmZZrD +ymASBFC7ql6Z+tBYj4YqdEUK4W/bshDeyXD1W1SM0pYAbwK6ixaqdsUWpbAUYi9stdJeSSHtpgeg +wfALDsXaFYemkyegpq0IKm1j+I2tZNgyq7VttRLXNCtOfMshYc1lTZrDtq1qVFvKJzKi+rBuiBvE +AedXwAlb+1SmacKKaONSXxq/Al65EoWAa0AgrHzpWIj4KEsg+InFLoCvXgYN9C1N91zyY/1d9C9j +6aIvHpso8jZiP4q+I7GrRd/XOB4iuaB7nG0OushHjWkp+nmJU1fkcxent+jmNy5Aka8AV6nIlyku +ZdGvZVztolvuhBJFhhMJb4oecSJqFT1uEf/a+KMNEWtr50383KcKME+sEpPBZjBPbFiXmZ2xJnUv +xA6HJmFj1W8sHaizcTty9xX59uMGLSa7uMi3Mbd6lX8VqUHRkQPOvon7IdIM0pXKE6aERSlPYM8H +xKnoqVOiX903icIVHYkjGazTHlA6CDwyPiKWrAtRTaYuzgBWBQjpu10QFFUEbS07AETmGkj7gsqK +99UqkfX4eHZA1G/bBEAFHjOeKiBZ59boWiFZZ5WxK+isc1XfW4zINYMRybBlp7h+2JiYht/oxGDu +WqBwN3eY3uD66ZUFEHJo0wJ40peQ8MQFNIOlrEy3lEKksNpNWm2QTBliBSxLACkk4wic7f6bujJt +RC3fKPVrQ8I/lCFdr3scJRr7fpMluh73GNshXfcD0ly72vQ7DNsplN2+At7pbnJp87nVaH9WenJU +Jt/E2om40fXIlU7aRAuMnlDYdBxZjRNkSFUqfmOrYCLd0XOam4HbowosBAJWJwpW8lxruPRK4/Rs +x7r3hJ1Ygk1JYilDUzyKSO6MUx4i4XhlWIj4GAlzW6+GpLtZZWQ9p/guMigRs4UyK0H3emY0Xgfu +QJTYuhRM/Am7J+R6cDTJM6e3cXU8vTwHKWS85vHmGz3sZfmIoJU32oagYdAjMqx0rr0eoXWzmp6y +44N4fFJPD/PxeT9mCBLN7kn2mK0Y8x1T1mTMvYy4GyXTTcb/jFmkMQ81ZbPGnJgS5zqyarXOaRtx +EX0iXW7ayO+BxzCh7hhGkJWA5U9UhXTHdO9Jl6ztGE6SrirnSRN1S8Qtkb9E/RKF7AlkIqKJhiYa +OyTB+nQ84rRPDo5+PEie7kc/iyDym39cQ2h4u/rp9vTtxblIJca3v5VqZG1MwN9W8NzJ5+7QNw4Y +kDnOm9XRTwe+OixrIUEAFOmhCKaWBcbGDrLqssRCD46uDt5J80dHIi78x0f0rSmNUKjyMATrZJ4A +keUwOgwssryq5KVHT0xVy1KVOO0b6cgPp3F0jTJiECRknq2gpYsAaZfLgQPHUaAQfDdWDxwrv2SG +3GFdVq2e/qYGQxiPlkoak0rqEPQcaRqLGZWJDI1RjqIxctbWIGhBT5I6+FoPG9c/H8thYx3QrAOF +Q2dap0ew8IZAPCeD05YF51spJLjpLE9CGYZMFE4bV4JBx34HDcJh4/rnY541rvb5F1Vd6VFjWpB3 +mQDgPwBlqFnGHVZWzz3hCmqlCbWOz5Y1t2FLzhA7FRzXMfa2IS8km1mOMCULJc402e0lui90QPpe +86yxWMjjg/Sq0I/9Sgvr0WKws9lArUyl7Bf0jp0AV8tuVZSz2M2C/S65+ctALhNjQ0MC4flqyLC0 +/ELIuh41tWUdVQl6j1mvrNN2WjAqARs4cEd71IaTRuQ97uimQSVECYdVJZIIRZOjRohJSVlUMKjC +USM45XkcCJZRfm18qQ1FTCyAm3XNnenRMlDXhKZKgBIfx5/dKxY2q64s6sf5FNGaYze1fNn1gIhs +Vl0XicerbBAYqCxCNs5W6AXmQTBfp8r7VTZTnE2SzlpYy1WcbU62b7vl4Gq4VqcpIZYQAU5twiuu +aEKrftEzrFK8IOZ4xTI5EIhTOEJ63OKbdtWhHxHUKoq5usNhtuUrRXuiOXvjzSpug66z6L71q2yf +YC854ptpa24l5/Q5bUbfhlW/F7Fbyw6A3WxqHiQkH2lC+/0OmkDlQyQJIBq2ZQ8FqfSwkdNm1ZMV +Uh49MAkBaRIEXyXKhFUGlemJF4hbom2J8EW6l3Cop4yJeiaU7YgraWtHe/l0fDBA4ErxuytNXlYa +sLK+irRooBh0oYkbSTc5u8jNFhUycQQFBun1COYgIQRZ1/bzEgWlOpuognPpbf/NeLKVFDQ2W49i +vGTFaEmLyZoXI6QoxkhTTPGqGGFeMcbMYoq8xRi/i/EGULprTbZHivE2Ksb7rJhuxWK8W4vxdi4G +O95qoSFN4CegxKQZ3qRTTslKTcJFOaxt6lWiwAUpk+spUzGhXXpMNz11K3Ly59lyRiGVABc5Ea2U +dUhEtgxRek0EuMipc3wbixdd+dhEkbcR+1H0HYldLfq+6nCKfDxxyEU+Zs5K0U9LnLoin7s4v0U/ +wfkZmJagPyZdG6cvO0tN1Z/53XHboUR2Jnd4U/SIE1Gr6HEr4l+RI6BMHU9Zfh41Q0b2akTFKmqP +6nLAbWhnvBl2r8p4lm5bFfm+inuvyDefcxEy2MBFtoPjHu+/ARVofGTDsPCJVGS8WkdPOoauIznF +hC5ljGFHvPqvEn3r+EsiSBNVFYkKAotCmXGqimkdFwtkdC0E+Z6eK8Za07PDitbeRHZ5xE4fH/xB +JIRvcy67hrJeWhCWoeajNNsYl9QkoSI+123S1FpIkSTaIkS5CCtV8y7SRGSAR7MTISTbOA5s9hVW +o2p1nM14CZuOCCsOZt801ip5qENEeN0wuk8STYUUwsZ8jYkXSNk0qu0uVQko80KFG3/UddwNwg/Z ++HkwsYJKKwg2cuyVCanhuPsEh1XzijlRvV5D7G6goUya38q3OqeNbeKmFQSxOvOeeoxKeVesS/A9 +IBEw/O7fxeJ96dhG3kTsSN+P2NWup3E4+WjimLshp2npZiXNXT51eKc6gTi/KF3xMIxL4Doevlun +uJpcTKubn+s9RokMIyLWpC8SXk2QL8M9Ymjj+m8SDicUTnieoTkmtQqsV/cCpl0E6JWtM36JbHf/ +YlwI9ULi7euVloOJSoKSys2m6juvSgib9V0V/kYhQlRHw5/Mz2gCBxNs4ioP1mC8TON1nC71GBvG +6DLFqBHOESdDh5JTrOX0yaATYo8QP9sT4/2SSnY7ipXXId92sfluaw43b7MabnCr/RkSgQmd4Ow0 +dU5M0kTq7nF2lWa6I0qs3w8oF9crHvq6YFhP5zoCqFrpJqORwIja9l8AY5oqI76dDqNDKmIdT5YI +SliZaHrC24zuJ9TuDoeE9kW+IQruiMHjycG7g//4x8E/qKz64e1BvfrNb1c//K8p4Ks3ZvXNe/lT +ykH11Ztula/6h/EyD1Y5Q6EzFBlh2QgHR0jKEiNEHiP6eCugzGS7jLfTaMOxDLoQtEehZg+pAUeH +mwnNQIkxXbmHFuHTnE5NidiY0LHEqAPFqH8Tws1CU/I+OQDWTNf0KJkcNutWZnpqTY61NRiw5oAc +n6AJx/TzyeE7PZ/Hp7gWnJ72E4ZgzDWkDo64iykHMuFT0vSP+ZkpzzPmjLSkrm7RLW9a/iKt/4Tr +Y7kpd5gzj4Mtz82UkYcJ7ZjQF5RAPzppSvqBjprYz7qeUsu4/UY0dUJ1x5SZxcazPFmI8SHAIY0P +ivFBMj5rIlEZnUjjIyvHwWvo8b+5RuyXUER44ghFhDsOZRho80ROabyc6FcqMjt0/rAKasBv4TcA +v4fawbQBgANOVELmTbSiiywGc0l92IhUG/iNFAlQPlS6s0zpKxHn29K76I1gbAk1V+srp6KbgWmt +hXqxVFHTQIqSowgSSBQPaTRRzZjIOCILe4glDSRWagJUbMSwQnBq0ClhOZCZqkosMAxQlaU/kKtb +aJnbQ2/43BoYBuXwkwGGijiLXWXwiarnK8rILOOskj7TVPSvSFNQYA4q6P9kCjCRRZoFTkJNwTzO +AgxZFOVkjJVVFRWGRGSosAEBqFSzxAEda5mgXK0tK3ZOzQu0bjlogSpIuGR7G5qERJxuFREh9VlV +kOoXLazekLJ91BIZX9ZqOqOmjeJ5wBygqFN/jJabAtXDA4INcruxB5TppU8iC+Mb01q1S3uH2RdO +w5Uqzgp+qxq08tGNQYRYRx1QYxVpyHW2wkdUjVZStlVDq1skG9JQDfxvZHUxgQCYpAylSiAB6ATQ +qgohgmTv2vSNhScNMLqs64ji1tHdoKZHDHcBNpaMNVn9FTdk65hID2206AtqV1HklHaAoA4tKwlv +anjoZKTNHbaNijv4ztSkVuk71OWj5oqoV+QNutKqt430yrfKnlFcR7c5Z6nfwFQRhmw+tmIyAZBh +WlP3U1SsmccCBtoyVq5fyXpYahWwHtybLXdD3Ndl9CwrYd7UpY6kRChkFde+dBHPWxfJNSiSynN6 +tkgplxxttHVqtxXRmwEmFkN0rUNEdqcshG2jVUmVQ/jhtYvA9mDi19GfKNs73qdWtFlQKhSTrrSx +a3Wro/Y+KMSENhoIq7jpSjnukxytMFlUmFM5RirDQRFULxhJJ6mGdT42B+tUR14HtCfRX9LoIifS +kZAXHSVPtL7oiH06EIp0IqgHGL2liIsJhz2VQy4Rb+CwEJAy6i34Pnsda0AFdXSaGpw7Z7A7rzM2 +N79FMwaEwcJ8XDeHFjo7Q18WNzU2w6ug5snoIbLAKa4WtGkV8b0JanqW9mVfreRUdodGNt8PV5BA +HbVCXk7cgKVfV7Jp4efQrOBGJbgrO/PobNNGj+Y26mXHeVnoIPuA2jtpMxrK/yHn++++ub0b+IxD +2lEPYrj3rs7gs//x+u3qw8+n789XV3SM/k/56mv578AOfXJH0tMaFkFZzMVMArjEpWyCssFLGQXl +ZBezCpShFjMLUmoTdkGKbcAwUABdzDLEUguZBunhcrZBCm3COLDYYtaBC7acefjqzUbsw1dvNmIg +IGcvZyFkaBsyEYL8m7IRlPM3YSSk4GasBPUEGzET2OMbsRMouAFDocU2YClQcCOmAgU3Yiui7mAD +xkKbXM5aaLlNmAs9YJawF6q3Wc5gQAz+1KMyitErma06qhvXVsmP23SGdiE2Ghxzb7iMTOnqu9vT +65/OlwfMyIEkCO/o02CFujJmBuci9HReHaFOaLz0dUXPKlm5lqCAyaSXDf+e0GDFt+nrEw1swF5P +dZ6o4R8maG2ZddlajqAa+QC694xK0K6lakp1ek/1pNaKrLnUmSLvVXxd5J2P1XT9O0kzoQjODp7I +FHVdOzlI3ek6eHIwrKZEF4atoWLtSuoSANOOrxnfmmnIpym9zt7GOvoqYhf6ZmIX+Kdqs95ql/Ih +9ROT5qWflqLzouxnZ4JIs1xCbYBLaNkKjwEnTdvQmb5cYRdaaGvHbLpr4bqrgCI9gA== + + + R25BGB18QuGzPPUIlXNbOKESlnswaKUQBgOvYWndCMuGV8E34OxK+PCFQKdRYRRl5HAIJSbAtCw7 +REiVntY8CEpgmToX6FnA4wvzJqyCKjJJck8OpI8BjtdAF3rBcgEMTfBg6OlIC3UeyZjQ+iDnlIIa +Micg/9BxciWFg9KThj9OqKxpalUINnI4KCjUVMfGSokTwlQo28eWiTjsTZH6R+zSYyIO4uSA47I8 +2HWk/IijL9J8EEM5R2X2un+b6hhUwXa6ZlJf+q7oxFSrvr8clQ2rbFBxXrKRc1pW/BOqbA7TLPUT +nSapXwydo2zB2Cu2HTvarymdVzyZ8Ljuabw9cpSrNC8nB8XgdYTodLAKX+lm6pqB9CCQQVeIOsWk +u8V0SMV03B3K9KhTpLf9BBapjn6Wi4Q7/VIoJguS9utVTNa0mK57MUWOIsedYg1uFWtQsJgiarEG +nYs1WF+s2RzFmj1UrNlqxXBHxu4NNm43+9n2bvKFLHqkKqakokh4lRGUYg3dyejSSfKqEVCDc9zD +YajSz6u2rePBF0VmkUThqaCdrDnmRq0WOtU6h+mHzmG05Oj3OtWtJ6MZq9UVYWNd84D1Rzvf5a9i +P7IaUkN9O6kXeW/0Zd7nWEPq1Ek/A/CBKjmHshX1LO9exJnJS+u8TFoY9EIpEd7Ztu9parsfzXTI +tjvAx/O0Zjqnk75maQYLaNtsNEU/GWuwQTGl/7uhabxJZvHJUAU2mRDau4azRlXIaGopow/nX0CT +RfrqzXQp0TGOR1j+KQaoADjCFLVEjptbg3dqNB6iJySLCRarMDWZj7QVstfF8P0UB7I2i7zRNZjQ +j6MYDmS67bPJKYZzV8TJW/t6DWZ1S5UhYL+kg96tG8faEa+dnG7urjOJqgpT66Q7hFKmpDDTxuAA +BPW26TBgkLITidWUNtJ4OodWiAsslY4ZNezKG2NNJ98YHnZqUdUDo7EWQeOqizuBx6bqAC1QucE5 +CDdV6hI99TCdwqKBgsYzXLJFoGwMSKT1toxuq4HCbeeMiWhS/KAbEPtXoINQoim/j/4VfQcNwqYg +rEPJWVOYg+lZ4/OtarbIP6nRHT8QnXFykF7SUo1ALxKVsmYgdqwUDFJNjV43NScHqTs6gQ36hVml +xjVNM5ikyttWA324GEL9oJqPCmwumRImrKUKbfiA2qn+AyhcXVvWeT1FWsSsuWJNr7pZyjrfTVM2 +xmLNVHQTlc1Y91oLuAQbz782B8Yjw6PBatZDpCzS/GW4W+TI2yYn6x7Huy1w8rCFxAbnfKCFxAgT +IkUMHZ7NVPSCm7KBTtBBgw7NsYeTNcNbwcqAKIgg1khnZD6CyIrqx/7DFQ426WzNEo3q1dcUbc1h +C4VtsC12vzBER2cbt3o0t1UpQG/oYMtKA0ZzI8ljRo6e0kQd2JDWKOkeURs1aIzojRpHRhRHi49o +DoATqiPATegOyfRSykM3kjHtIW0fUx8BTvGfwDEFotFgTIOo3R9vPR5BYzr01Zs1lAj6+smuhzZ+ +Qo2ga5/QI3gNTSiSno8dTaLme0KV6J80oUtUdk8oExduTS/XUSc9yMf0STXM02laR6NUqTymUgqd +rtM6SpXhaUarMpTOqFWG/cUQ/acUK99MkyO+/fxKU8HT1R9vz8+vPynJUEhZhoRJ8R0E4f6BwUH+ +sK44+NJ5Jghg7KcmGWqD0wjyMhoahRTRK9yFoD59NSwv8Ip1Wgj0qbQa2h+QnUAkv6qOwZh1lmWI +j5pkqEamlfhetrDx6swpXBh3qnXGcJMLRXApx5DRQHarRguDj9Rp2/phjiECzmJgxOiburUMTyOl +oQUjhp97weaYQSXEzoem1lQRhp6dMDq2GvPj5B/Gp6kHG0AVjXpC8KtSkww1SIyBbADB6RbwNSyT ++BtcSjIU1OdZzwGW1lQBlQsx20WjDrPO2eRo5qqSPnyG8Ubaz2al/aapQDCayQAQyh49Hlp2GCbH +mHcDWVNgcTJGHUNDxfA06+CJqQlvHBZN6G/derXMBFiJaoTBRj9Fg3BmYkSXmAj9JtJEh06PfABA +q8aqAc8j4QAwz7oQcwzV8BYFctoYixMa2j7KMrjuOeUYCo3aVuLLWLroi8cmiryN2I+i74j2tOi7 +GkdDBK9KG+eaQy7yMXNWin5a4tQV+dzF+S36CY4rUGRLwFUq8mWKK1l0SxnXuugWOyFEkWFEwpqi +R5uIWEWPWRH79EewEWebysSMRCE6elauCRERbUJ1HNbacMJ1U8aEADEyEP11q2wA3FY2DjPuK+49 +zTvQbT7ZnuqUP9zDRb6JudEHX5EWRKsY49tIMGxajcrHDEPGO+2VkBW/imQnmvLqPMFQIkyJcKUv +EmUrOtIG7HBtE/GlsppeqDEupdIJrWJZHaPzPBIsEReNNxE76zamF4L/TcThStOvtMzQFAl2nl8o +xARDMvXBdBDUobmBYh1oiAGyfUOk6Sn/DnqD/pJIxf4S49u0B0jTMXAbU5hx4DXZrTrNTJ9fKE4d +5laT/BCAya/bbvItKYtPyR1oK+cqNt0qUqHrYqqGGvs2zy1U60bWQI928E3dJn/nyjulemnqFfN0 +N7UZpQQCu1VOSp1uTiK50WQuQs/DgCQ3Fb9JRBsbqR3sKN1HadfFw6DfmBrQ3Hif717tQzplTIjH +TpU2laZu6SiFI50dUhPNkEfsJL1ZpU2g24LGd6x0g2ZAt4IGmAcyYSRtTaPneR3P9zaVCUAL0kij +hyRzXCgVbVcJx5TUknNXPPSRHqsnd0axwyqj5hmhN0JGlJQHxWnbRLYkKEqXQcftS7rKS/t10zEl +7KDT+C94rOsYjE5vqGWPcZSes8u8ipyGKk6VZx4cV5K86Vzq0VhyaluQGM60JiMcna6j83d8Pk+P +8PEpP2YDhpyCVWwcMBNjbmPKkIx5ljFTM+V7EnlO1DkR50R1p+zVmAMbs2iKfS6io9XkQsZrDigS +BdqBfWIMu+RCkaSQ5JQhPpMiKd9JgkSiFRMaKB1OZC1StUT2EtVLlLEnjIl4JtqZiOuI+sbH4zGD +PceS3AZVZ3jb0AOkEqSrmToIflztuuxCFomxoiU5PRTBBFlrSJfBuubQBqG9E1uysJWhZeYg+Vsx +f4XMlFqMIUbih+Cwb2BelhWB604J/0s5FSfZhShBrM1npzkBiCSarcmvipRj7Jj57FybkguGWvPZ +VV0+Oxfz2cWjwjDWTvPZxfB/BN3XWVKE1g1zDPH5WBPapdR/jjmGrEqQlrmrQsxo1+UddBoHqJEw +zH/lYkK7lL9umGIIz8cxnZ3Lv8iz2dUxm51fdY5nxzGdnQ65YQq8mOkr5rPTZGBdxsgYYZpns2ti +Nju7igkgx8nsWk0wZJjwUlOPNatUNiaza2Nes1VMixqjLUqTMqfalGvMrWIuuy53WkwSqflvmF2t +88iyzGQXTxvbpOxhISZ6dDE41fq6ziKPmcnOxUx2bcxkZ2Imu2BiGaYF1FRxQfvSmpjJzodRJjvO +m2Ii46zUWXWYys72qeyOB6nsStsl2+1K5vlPtXLmsqtXXfsxaVnXQeays6tsDMxlF1b9KLtUdjH+ +ugGDzbRrGvWbp7Jr2lEuOz/KZRfTC3HFiGSrDqGIYV5XvF51C56hkzchprGrFLt8GKWxaxURFZci +2iVMyrLYmS6H3fEwh10ZVgn12cumjUns0jga3VC11+Bs0gVNYteush0Yg7XjBhyksIsZ7KpV2sFp +Kvs9nlKLJjLAFHZVSmlc9fHjHSnJMg0RcsK8dkwHFSEkUGXKpNx2NKwnYYnMJSqX6GAig4lU9pQy +UdNETNclttN0Q43mAcD7Ycpo1wxTRjcpc15daXh+1oemznZW7KRmS9XY4DgOTamq6Xg4VE266k03 +F3m+oTiBTN7K0aVvxosQs1yGbJ2K8VKO8kYncTDDhWKELMUYmSLZajN8K8YoWYxxthgjdTHG+mK0 +K4rpvinGW6sYbb1ivDWL8d4thlu7mO79YkAeGj2VslSYXbpoJTHwFDlO6aINqVCdAoPh3BqpVDGl +Y3pYNz2pK8a0cJAuGpaN45QuuqeoxYjiFhkxLsaEusgwORXP00WnNhIu9x0ZpIuuQj+eIh9QHHOR +DZqzUvTTEqeuyOcuzm/RT/DgPGxcv05FvlD5uVr1B3/RLXZEh/5sLkbH96pDqaLHqWGq6DYia+18 +FE1tFYvT3ZuZopvYRpYoWndF1ApkPWt8yLiWIhHvIt9NcccV+ZbTPo23bZHt27iz+2/i3u84sY5A +ZNzaOEt0WHWEpphQo4w17EhW/1Wiah2H2ZG+jA3VRNF1z6rGRNEpJzhbYaLohP9BkYQh5K7ni2Oi +aL8qRsS8SNR8n2lon2lon2lon2lon2nI7jMN7TMNjZF0n2lon2lon2lon2loWzINIUQyOfQOXHor +2FnA4NemQXaDqx6GgE/VIjHgk/IITCYaZSGiFQUaS5lNrf+CQSrshmBVsc2Et5BCgg3R4q53f7WV +M8kfRDFPThGm1e0duJFilunlca7wlpsAi3/nqlEzGJ9pBmpdSGNtTPucArr1NgCE57ruIiTLdPkw +IZV1jAQp49oYisiISLFGNS2U29VLgUZMp2YMrH+MTJOVSM4KMdjc92lPfEplX8U+4XOenwhnScnz +K/URC4f0i1MnnphWoJW6otLHRBRndDDF1irODldJfRRMNHJXoYwB1y5eUwBVAiEaxJ0g6pzUljFB +rn7VHrbRrpAMDOGwbdoYpxxaG/2gWuMi/fTcgDImjS/CstbBK29cx8hoQuhwxSnMvpG5iSl0ddcj +MUOs2FSaoQoWwTJmpfC8Dslh20SbfEU/E5kSrx4SsOnpujFCW008DW+aKDU0Xt1VaYIpeQlMbXoI +PBVEuiY6RpClusX2FTngVJ0ac7TgJTk6dsjD0Ovrvs8V48xtPrA6hm13g6+Te2SaH2h8TLywIk5h +Q22760EBtCNOPMfLGM6YiiENqSTh7MkkcEFbwrqXZAe9r10PoF21SbeapW9iQoKKXIxMQ1UO0FBA +lrYSgAyZFmeirxHTGAOQNig0VaqHtzakZgKVijQgANBCK2ZiHmxNGe21a1nC6Cqm+I+B7ZrYIssW +HdTkq7qi9EXJez1W6lqhWf6rlP5br5Nx6qlp6duiSf5NdCcjuaqj/r4D0PAbPUEiCCmimb4ZJB5J +HlKifwJANIE7VZmsfyUOFkf6FkcX8/2TKKV8/GdM+K+OS1nGf6OukmvyQ58dFIOk6THpv2+yGkZ5 +qDXjELriktmxDpoTvYkeOOzsKOc1R1RMhs3s2SbaPJXYY/oGc0WyYm0iNfpVgCGtavplQE7vporT +RTxXMsYEGLqaqo93Zbwr0FZR/A8hPSvBdM7lHyh1J0Y1Xf7/HOu6i0yIqnQwpuYxprVgOpdRVvSY +74le8qpYzy8BUA+2mF89Jl/vfqibZZd8PbsHoFZNaXYRQLzej8zW2cGgMzEdOzpstQ== + + + w/ldAKsuyfzZQcZapmtY7DRbfUykztTqjUnNycoYzXxfR3LlG11kWcZIupVHEHRp4vBs8oTvU6RH +LEt3onQY32XsP4u3AnDyh9cCAMWNuqx3FwWUJcnD2UEPcul8Qy6QCp4FOMRL3Ql6e8OhckSqKSs9 +Q9jbxMh0fFOADt2vppzUQzm0yugvMY3Dl3WE2Vrj8JE8Bzs+2LJkv4Ujx40gP1wd1I3mWBl/KHAk +2ElfHp3NrPLo3ipNbeAE6rIquzCONZEbU4Yygy5jKaPItZypVBlqE7ZSm9yEsdSSm7CWUYxdzFxG +sW0D9hIlN2IwNSZiAxZTQyw2YTKpUNiIzWRgyHJGMwZwLmc1McYNmU2kl1rObiKUdAOG86s3G7Gc +kKg3YDoZV7Sc7WSM0lLGUwptwHpqqaXMJzu4kP2krm4ZA4pgqw1YUKzxBkwoMGo5GwrsXciIMiva +BqwoFUebMKMkBhuxoyRAGzGkMUB8GUuqJHYpU6oUfRO2VE+RTRhTDYXbhDXV83kD5lTTk23CnmqT +mzCoMb3mchZVsw4sZ1KVX1rOpmq5TRjVkaKw7SL/v4OtSjNVpqFfqTlNg5FqjUVrrN6ZGHiuW6dE +tOPjpKsktQU4K4RGou/KBMGDWT2S1Q+35B2pHA7GojkgkctP/R2Vh7LpGr1IFrI5B3Z49eh3Ja7x +xb6ju4PD/lOt6nBAx5vw6XLwGhOvUBX2RHdNMJWDcy1SygoSg/ZrkDYbHH/bhP6zo7PZNR7dX6Nv +ZeKFFuXV3s+qr1nZqF5esrbMM7HB6tIGt3x9pdgmK/wAgpPVNhljfcW0DaXJuG8hasqER/4ceSDN +kIm3Xc5L5BKOd5aGGA/c0hXTpgvWwO20Vp1nI+G1ajwBQHOTCo9X6w2llFCU4mu0Rn8FHMPSs1sH +SUhJb6sBve0vaxtc0JnRbVL1akDe5RcZRoKwHAAwEB3CBlafwc119CasG15BKd+a6OVNhpmCiYuW +EIh5k/neSE5uEDQRRdX6kPlQZNAtYl2A/9gh6BDSSAft5PBTbr701dHZ3PqO7quvsuqbOaj0/r23 +Buk0Un8p2mkq4cWIx220FPVIHZYjn2anWYx+nKTlCMhiy1HwAQLRqQmQYQz6ias+4VZgMLmylFQ3 +NJEoJaUEA56qpB/zcKSooBKoEjNpAPBVE+P5WnDAGCZScqi/FbhoGRITUvAZI5cyJjVMhiVdSpka +oljQMzVkfAJZTdfzR23Mon3W30g5vJAy1KsBmxWq1VBTWEIXQDdLrZZZnexhlEGFMiMqBtIUBqi+ +YMxGjZS/SW71KhIyN8dksjeiDtJI1dat7lHoJyhIB2GeKXQFQTERTwVHcDw3EBTd+FvsY2RS6r9F +Xvm59R7dW6/sGk0+PKj4IYXaBPuyHFcL8E9LLcZALbYUB1NjC7FQ2fuleBhLLcNEndmluPgQmSCV +rjUlvTN0hwVVhO8gNG+uTs7TiEqpk14QWMYwlhbyszo+WhL/Wg4BEwNr4cKL0yDpEvvrhetkkqD2 +C2hAaZKdaTXtBXUFTHWt4YchRldA6xE0vlFFF3CNjK6A0BrMajKkDTdjDe927gOZSbrKi0DYcuCy +Hxx83ZnOiHn6q/Gntmz1i/5bbsVZtR7dVyviETkhg1of2IfT5VXg0gVWeXvxEqfGFi6yFlu8zGvx +HFmbZOvfm7fps+WR+fDL+d1vNShUE29+d4AwaCFslGO9kOCWknCLcOsuuczp/OzctkYYocxJg9Sw +PNGFUjaycA4a0Shf2xrxIgbmE1U3lXXjOwDZd7IfCcJMkxanRoKwVuHYUq3yzDTosd1jnBLM4l7R +LVPzeK8BDbt7Qjz9lkH+UJRQc+8Y75ogVnX44JhaTVWtsT3UeFXdM2P+eXtx90UzqqEZtqEReVbj +uDhjJz0E2jPLVvTG90a/SK2mZ5Ut0K/uCz+qwQ/bOJ6MFXPgKPjZbPwdJPZeChlf9+MVTlDfd+Ov +kfeh9B2kHtVQj9qAt6tC+vF3kNj7VGcaXWq1H3/qV4K4UQ1u1MbxZKwYfzHu3FUGiv0v0Bmw82mA +xXQOCnSnytCkGM9jMW5eg/NG81CMh9FVnMZZTKei62D3zXg6i/GMH09HzukgHg5mI0HSMIiZTTYZ +RM3BXChqhuwTP6rDD1rRIxuQbCISJI0gVdqNMbabTUPqWv9JM6qjGbRyPBlv9IxGEBDtJVCUeJGf +rpimsfSqokmZEXGXh95EQaFQ84Qy4bEso1cbVwfBcHDruTpZKEy4vZaXk3c14Q4fA0V8iDdYFA2s +GW3QgJ2aLKW8rF3QZMOuHD4yx4bpYQXaaRBNZeNDHd8A/yxunSrBG57wycZEfV09Lr5GO+k3EVeN +gC4rfRiqgG0oTDk0xB4qKXr2tqYmHg+n9BjUJ+v8FXyRTNCxp/GUZC9Nw1I1b2RADB4zMKLihsZA +0zI5q4uCdMkQ9Kx3xwdZ708OdGx1B8nGnU2IFMom6+Qgn8dUQ9fTfCAYWDx2YSdvmUNN8It88BUm +ytK5F0krbDyckEcG6T7AWlGqBq5TMx0BJYNRfdWVOtaUzNFgZB03DSLLLC2gFe4OcKseUCNhRLPq +CzWaTC8GX9AbINpVmMi5hTQmKIEERczHruboDtBoSpdU5jgbq/BpLmhO7yBnObMPyI6jA0QPgeRG +pctkjo7j2Yx7rDTir4b2wWk6O9nzGlNEEO578CrU4LBHdpkM5JEfoq3VaysBIdAw02ZXl+kC4VKD +CULHLc/Ewf1XXng/XOfU19RBsgY7WNevrqbU9/H4zlJcxn2Xuhzd3FzyVhf319O7u/Pb699fn/54 +ef7Hjxdvzz/opS62v/ql++jf729u7/7+6/t474vgk6yth2asVLbaO9WE/+5v56eXfz69u734t3w3 +qKT9/vLi7Pz7s9PLi+uf/nh78fb/Pf81Vjdt8W/CjH64uz1F9/t2F3OxHy8vz+9Wxero9OyXf53e +vtV8iAtvkTGMt69iwmWLqFI+04t9lUDxyafQQZxRMVltteoKFsPPC+PjLzBX8Sd3T/bRsIaunIZg +rdjKoCeDL1Pnj/txzL+8ZAX/hRKZimSyhGrihqtp6lw5K+FQQNEuPUC7W4lYF2pIRe1nv7JEJ2tF +TXDMkoYBrzRTJ7NKdZOUpmiV3qUy+sq6bnK6xMT6ssjKFPoxF7df2r69Iu9IXNZuUVfp+gJ1QSEm +6a+Y4Zi/+V//FFvzq9gYRcMqfhE/iFz5SiWA+CJ9qUVB5mOHu/q7RmIvjg+67mwY18WqruKvrgkF +287CjZ+XKUfqKg4570y017K/l93vftjpXRHrjD/xafe+KxK/Pev6dzkSqWvfBWP8R4zH6ETd1U/M +SqKeI7pgjBnBU7w3wzCSRX1C9AYvAKPpWwEpcwJv3fIxFzYfUvn0oy/CZuLjcepEfNa7X0z/wai6 +vikGOKZOnByMu5iqKZR1TeNMBycSWXhamXlO87pG/EUOFr6y6e5psHg2JZDnhzbGx7dtV7Z7Tup0 +BsuYdMmJPqVv+0JmlVoo2J5RIGXdeH8hGx80Hceu0/2Apky4CJHmmR28LUmIKletuTs13gdVRlcx +Zt7zzPawim+oyaoM1y1YplPzVKUV/QeuirkwHypaOb3a8uhs41aPFreKO6VqpCnuNW/rKcDD2cJl +A4EmfKuOXP2+Sf6RaedoMuW5eycpiOPuyR7n7p+uO90O4iWjM/cQrW39LsoeH9tHerNe2dOaKk5U +JJimI5gPbrE0fXGTqZfqrG2WfG3aru9LtlokrSYlP394u6XxnNw/bMEpM4bS8u97ArueuNrVEBCJ +CPgBH+gbrFcROHo5HEaPnoZJVCB+Ghpnyu4X7MzDdyzctF3hvG4oGBMNzXqS9yh2/EEXFlg8ePkb +iA38G5G58F5aY3n1MdO6UjzNdy2s243mRsxIDGMyD5lTdl0JOLDYts0py8w2jua2AVYPCQIzOvKp +N0v+o+P1Pw659cLEazTNofbh6qDhTdH0Z66aUGOjJ5Chk3S6xmpQ7t4TwjouWh1K5DmMR4RItNDd +P3REgPGoYu5h+hz2r4KpK/XBFXJdqcf6aAU9tDntY4VdvHR2eEwsbPlog5ZhNq0QiJsdFeDlhThA +6i5Fwhd5tcGPsmzIw9ehsRW5eul3BYjpU0YKf1+DmWfgrq6d8ZV8ftWBoAD0TRVvL+FN0IZLOyqR +GGw5BvUFNGRQ+1wd6B3QXUF9D0WioaZiUmIt6CGx+je8ulUGXP929bvvRfS9/mn1m6Ojb87OPl79 +7eaOMmyG1ZOjU0+ENT3XwO6u7/03fe/XlEtEeE1Pf5c/r373l5u7v52f3dy+Fcz/T3ZELYcV7xmB +7tEHA+8XO5Hrj7/50x/jXvn7u5vbK30VRymb++3Nj+dvvvlT+0Y68f3dr5fnb/qm9auFs5YdHuEh +Q9fn03E8uVLi25t/bXBBw5epjnDMgOuCr1qq7GxVel7tY+CNVIcpUfbMwGlXKQUuHwo1NDc1eeag +HhN73cReN7F1uommjixyTBIxkL4+O9NsycjlfHFFpV/6NeSZK3UWjDwzy35+lhnciTNwJEpMs29w +5j3ENLsGyRTNPRwtwgBNGPNc2Br3FamCOnsM2eZZrRzNbgUCOI0An49xXsMu1+p1EnMr04gUE1Ym +2EkOMzBqxiuANdhiHagryQZiHGkEdbEUuIa7rNMVvsN+PMZ/NzJFQoBXyn4b5kx8gP2m55yjz4NV +Et5zsSGgbc43QmyrEfMNv3ecEA8XbRzv3z7buM2jxW3imHL28zPdLqU1QuIb2LavMpAstS5PBioj +yHdXjHUgiFV6oUwHype/dE26rF7EKZd/BiNvvDWsh6HRB2DVFBaHcDIdVTrd+l7zduNK7xC2XflG +P87707UD38QhKB9dEy++l4+MHXyVzdQU1DW5BvSwtBHRpPwUaWPStasBsOsJ43AnszSAdmPToDk7 +Bq6ZK4ZtjmdrTac+TZQpQCNM1fqgYbDSO4iQdf0k0syiVcnO+eaVSDN/uLndW1j3Fta9FLOXYvYW +1r2FdW9h3VtY9xbWvYV1b2HdTQvrxJ56dTA1nhZrTKxrDLHPamM1ejPHvTZWcL32sbIOkWJltcjE +Omn4aHnDT2VhLdaYWHN7arHG3nqvjbVYZ2SdmiZz0+W0yHrY05tZ13WeGaEyM+uawawr+Hm0E1XA +/ZVmb2t9Uu3Eyfm7u72tdW9r3Wsp9lqKva11b2t9QlsrLvdhFqOrg1KvANSMgyKPGJqOEixZW0/I +isUI3zEoGVuzgmtAffVZ+5/buGoQeIdQ2NYqge6NlS3aDGrnZHKhoW0VAWy4sfvBog3NSyPj6pI2 +jxa3iWPJe2GaPzO7XfJOR2iUaPJ0lriQYMl0dpLBkikTsGoCwz2HjVsLSgbPrGAOKu8FJWNbBkqd +VSxiEG456GX/Qbp5MPWV9ryyJZmMW6zM+5TeZ6C+A8hN27h1kMFcVWvmb9z+etiDYg== + + + xeeQKqado1QxHUUP7AebFV8L7MehFtZudvN284/WTdWmokqRaAHSmtWC9QF2qCcQUTaUUF6N/fRv +Fz/9vBdR9iLKXkTZiyh7EWUvojyliKKXhyY5IobI2CqXNjpQJpOkgutAvQRCf0+nAkh6ncsnw8af +UUgJOqD7hBSk16ncI0Ubq2lMZkspk0bHHqCPN/pUUgrdK+PaRSGFJh5v09rxdS4VKKTnUhOkly/o +uzeCYMkrvw6UCTSp4BBU3gfqOdvJMDo7RaoxF04iKC9uDlMOlglsMNJqMnZCes6bpZxPszdsfC3o +yQWTyYBTVNl4yBk0F0Kmw+5huciRDz1rdSi6TOb+XqHki5cG/vF+LwrsRYG9KLAXBfaiwF4UeDpR +ILHh5PZrnwLDCELGYtvHbcEXrwdpVIfXi7N9acMqRoGZ/LMkKKyBxAZPpn14yqAw3t4z4LFlYMqd +I7H6mpiw8EjJBok/mwdiwh5rchoS9kiTOJ7sIGX95xEHukAdTZPRCQQNDhEB6AIm7q2HJO58HaQa +Qxj5F5ddxYF1oK5cBkqVF4kXzUApAC0DTUfTyQWDVykYLEUkZW33DU1BXSxTNx9TSFeMdefVTHtw +D/BBAUEwzxthez5JQBgP8moAzEK2pgPNYN3QYmjXALJ2ZDFabDjla/rzKV5WheazwH2sTOxqpK90 +2G6ewoKxaDlek8xydycDERK1+u729Pqn841CwGD9xa0e8JGOB1Ej7BAy4SdQEarDYL1dIYmux4VY +CVAiXWp6KLrXqYKiqyG10kGODwhqMtDJAcvZHjKpOW933KlYOJVN1fcNToZ673lnQq3cDjRmdcft +lFX14IFXCKdRG1w3appKjgweCnyHW5LK0OilQ8KRmMNgymrE9yBtvl4e+HBpeDwjffoolmJh20eb +tA3GSP7z4yPQNqUPPNVaW+LwNI33PqnVHH6A+ni9uECEMr3LD4ci8xB1qOASNySraXnfSgLJcruI +C55X7yZAKUubfqd3qXQq3CFDfM6RwXX8EEtVPagYV1vkbRaTHnUVdJ3O8L5reTLYLoVStiEST5jv +m6ybgZcgJliBUET2JAjKMh1AgmhH4wPe8p6pVENXQbYzRr3s2x0XGteaNznp0KTPk8EeT8d/n3jZ +uxSPus0jdDK4yfDznkqB/vEkf+wnczrhk2U5zruTDeCrN2tGJcBxjZNGh30cdnE8oPGIx2t3nHUj +78Vk/u4F5mJw5dbL+OnkqWteHYWs8SXylcte9kipoIaJ+Da9PJl8fi9Rbm2UQINr/aoLW/BS9ZrY +NmZ1b0zFa2kMLkJqcp6+bMOhQ6CPMPW4nWogg8q6IN+ERkM9WDZUenW3kMPFDR5t0mAZL4Uc0d9P +VI8Jm8ZbzV1Mki9L5g5jbNFJeptenkw+TwSsrhVeHTJL/lUCxGchIVVW6/DjNYCnj0mYdFj2SdbF +7oOuS5MiX0AoQuXX7/fPdeGRcrH2E7lYYSecwWU7iYGtXMATyDnfhEPcaud6gPKu8aHoXqeyBQqn +avEgB1T2pMxq+nBSTd7IuAdZ77JuHw8G8ShrKjSQN41H1tQJA1Y/HHWHWz5wV7NphF+pbRhyeDUs +qbVGYOG2zWGMr28EyDu2Hi4cQJ4msXjLWj7apGUhdodN87nZ0m69Kxp3wN41wcVntB3XXK/1TYDI +AFldc32XirJkt86Vml0Gz5EP7T4uxlUVeTvFpBfFsJfFcBDHo0F1vGeP2mrHGgIi16kXbNTsVRPb +bQ+N4cXlCaLdig94y0tLU3Et3WP6oE+xrcG345ryZiadGHZyOIbjg/GYHuMu8151rGU/iLxnvCs2 +7xoYye7xJH/sZ2w0pePuZl1IPZbzaQoZ1DJpZdipYZ/GIxiMb7RGfdNdy8UMyIBzrLIbI7M9eO8P +/ZdhlN2wcbd3w0y1ADFpUQQJ4oTD1rUZSPgz3q6FmErqzkKtFxUxlNa3cafiDh3cuEm+t9tesKYg +JLbbYuyX553xg21XqYAT7wHXy+v73unz8cFgJwKU7fQEKib1FutaLyZ9LCbDKKZDLTgduNszTUeB +GfNlNq/TmUbijHVXQq5Zkogjw0UR4AbLQilng4XRcguXZjCatDi63zdZHhUiN1ggFNxsiUYbrY4c +WjuWzdpDvYrKakC7sOg4sYPpIFWjGYhr6Jik6vQMRib9LvhS5iMVLrR0s0r1d4Czg0YogTcZSFjc +Fvdwd7UkAHml+Ds1n0qn7o0HcDwZ0vwUUDBmtuh9idBvHaSsRWjtGk4KajPc6qipoOJDEUzpD5FL +QDi7Uu8b710XPotk1k2o0SwoV5hQmq86kMyZjxPqGjj9JACPyPg7vUulU+Fu+uLzMTAC1911EBFO +nGKE1pCeUXv63TWdChfj+ou+gSgsZqgSR1bjynZmsYsgQbhUvd4TlwBsu0n90nepdCqcIUZsWMYe +4OyXIMGmudEa0jPnzXaTqi9T4WJcf9E3MAHdz2MM/CH6hq+yp3HLWqkdDUzvph8O3q7Gk9NPHL6e +zOtk5icjQbHJFEwmqR/I+BbdqunO/ug+IZK03qAofGiJ44Go7QNue+yI6Un3Gb6ybQ7pCn6eRBew +WlFCiHcLu7JTgqsSRkiRaWpV4DQQGkYqIzkjqMl6uDB4LmuaqDJa2OLRJi2WzBHy2VNb0Lany4Bb +xcmSVXr/c9Qa8XV6ezItkOmNmviidXVlVXPUaGmFnAA3+rrHBdaCnkV/1DfalJEFih3Nkbj/lN0r +/QDWFf8CtEldYov286qR/nD6z5vbi7uoPfqPJGN8znuzcZk5rm0uHPyqKpgbhC+seZtoAkHuqUE3 +AYBBDdnLWig/HFjBqlWnzFBD1WRbveITd5Iar86cbXC8UluzWVl9Pj5IkBY5bNSxAxmO4GUpmwq3 +gUpZecHLo2mhU/TDbaupb+p2asH6dh+xlqbpauE1s6kRvWa268WJ3lFreB147GnBwRASB8N7edFs +NmKKpjUvHY3TUnDmXNXPXMHpxWGS9bdJd/F2X0m7wqvBwZK361bZOJHhp4aKAPdFx+s901eoCKlj ++oUaL+Zx53MZX8jI0iojYY+3PSjAlhIqtsg97dgu/OoMEu8dk7QbnRCZNnzgbEgf0HE0HAZBzZDq +0FtWeDWpG09Ighyrf2Ao2/yrmm5QBPB6WAHozcZOWm01maGc5saoP3IZanpBInkpIJg+zqce9nXQ +/Id4pEW5rtSd9NDAKiyz7a2MSmWiRiZ1hSOsMjnCgT1md/mJj5/gSnCvSY5YC9hm3GmraK0t6dW4 +EfXrQEUou2q6rtIDFJq/fjQcsTf5kDkrvp8VzFvTZPM2Webj6crf7976xB4jFeaA97zKX7fyuAqY +171ab1UE2a7rXv/H+SXd5kl2v30C0oudbRu9Jqmmr5SBxBFa+nEG5OM91EuWQbFK/h9qkgxYjEsU +40pxY3ClaAOExY3XCdA9pzJ9kVRtqjW1yX6wGxlk9PGktlFz4+5Me/wObtwl9nv6e6V5VZHrD0Re +NqawXRQ5iTra6QxUjD8vxjXK93Quke8DTjeSjQgoOgi/Jo3ri6Wqi67u1HDBzhTsDWCWC9OsJiVS +bVm1k7bHvZsOgPsYQQ+1UwrpnavjbVclJ0G2GjyWfMqnH4QWUH/DcyOD8H7omIkxwXC9e0AGadQj +xyhpZ0vfR6qO6lqnwx6W3qnnh4hflj/U7C8rXDdGXwkzHnh5vIOV45hX2jsSPKiQhHNWf0gVuOEw +wPlxUEnUzBoHn2749KQ8ckhZ4egCX1jksLZqotaFMN1X5OjA7FscbraHnB0Ynk2mB4mc12qSUoTg +NbAOYw31HNPhOngruoYQ8hYybSUjPtq44B0g4HiQiTk76ECyMlVdI3YtjlNoIrV4BsyTpcMAhAin +N4Q3Zdvi6noRTOvAW9NxTgbeEF5KPZwOU5qKF7Lj7m7ZfrwiPDD0BCogbw0vHnfesx34zjfaDtzp +D+FwyUkU+aVCIZwtPHdAmHEPunxa9U+y1yuM5fggA4XgG/XLlblphoBASf1Q1YOyETixsvg0SEu/ +aovwvhDR0McFx1XmWC6ZIPJKhhlN6ReH29mBwi6K8L20eegbW1ML1LR6wbmc3ADIBMLtGNPQBo92 +gKOu5CjrBs4ORNGaKIoJdT0gxElnIQWhhVoYL7icVpqK1bVy0k82IzYp+IJATgk9ra1Rt3iwBrYD +gZtqqpZJAh1soD0AC1MGXaIIklkAOnWVyL70yqykliJE6IqgJVzAE8QjnBZEW+voHrtWOkjsSFdB +6ulkOGfUpT/LHfG0L28hq3BzdR5ZBfMkrILzUbsvKGBCgFpJTkthujWDcit7gVEwEeRKNXmdAGXv +BYGjLWubnMUp1avPpCN7zEYVNW0ZyDDDdLDiF60CqsPKBu49kfnbJoexJgbnANCuAWgpAKRexL/0 +NU8GfJIynZda1tas7EoOQDU0RMBJB2j6bgawnPApm4K6YgVrDmENBF7kzF+kV7XoRIFhb2hTSV3K +Phv18mG1zefbJHK81sLiV3Ik4+Dw2OOaL7k1dbuFG+e72x9Xxero8iO3j0laVDN3W1BWIudJenzV +QZw9VFIZ9OIeOjyTIBcZqODnVf95B0g14jRNIEFJPfpjBRYRRgaxQ+nX2cH4XdfDWHjc47MZhh3n +fhs/QCCE8XAXwb8ITiWz4nDgVm4l5zeCeqAvge6XbVmll+BRvdAjXvRBaRS3fTTSWyeyWG/e2URN +N7NPn19fF7WYBmLscBrtY9M41ZPL4IdOn8TFAR4KmWqtC4zvEe4OSd8SSISxQ3I6SNfcAksSQJi2 +lqwrUKmDCeUzGjDLaiCS4axIP4hIpqQqhwCWrPuS/XNXewKlHqQaUhf7/h9nY5llWYR+U8NuvKf5 +V9hmp5fMCJfdrIkfEPpt5B/FvfTAS2aENMHL1wQ5BIRpmkZFB9s4Wg59CZZVmq0CtkzvSUGrogGF +kzNVdlnd6lnK+xMgKzawWrr4LPNSBU6V1A01Uw+Ic3d8kEBkg6pmlWqAENakueOvY16c0dZN6EAF +S1d96Q6QtZDBYje6erSbqftJZYfnOqKa5X0SOcECHsgUVjkkayvCoCDSiwNiHQ68MseTfh0ryar6 +d4lEpcLpOZ+uDhR7keooNLDE1aotpKJws2jqSatXGTB1bdz1flgabD0a9XReJpPHctNJztdAx8XI +62zUkymZDGBsPGz6SxUgz9Q9pYEwZ2nQdjRYwt28hwnbDc0svXUZ1NJpneFlDakjAfSwE7KffWPh +A22zWhIgNXV20IEgeDY+xVajGoRuGwqeqa0OQvlEO9R/1XW6r2oytjlHoPEPEW+IY5HU6M+Ctxu0 +ztbqXa63tHSEBtMdsuk2kC4Z2SXSbenTNd8R5lXYAttsrIv+KRp5fpgMlQSo3oxscPZRI1JpqLJ6 +OkBs7Owgg3U3fXQVtUmlkVqLANVExS51H3W97ioaj+3Tp1vOGaH+lU54etBEqLUIwQ== + + + wUJjXer1lHHGNaQWZn5heyrGT3SgFmFYjVqLU4ogVZ1By+RC1QF0piBOZd/EOPi+lghILZ0ddCCR +0qvos6u1ILlt6bKWEkAnl73pv4n97WsZjenTZxbqEAR+aC6R+IBcIlB3IM6thJqnynG5hStRqRfz +aJB1B8GmtcJcNCRIinHUtPkYP98BoAtz0X0sgmSftsGoEjTWk4FiY9RSdTBP7ceqq0qEn6p1oW8u +AaAdjV1KoH4YsZbxuD59ciuRMXG1HSc3PYAlARPBS5mEKUdTOaHI+D/Z0Y3GwZX0jrrqIW2MGRFS +T4VrwZC5AARThVMHwExjMlwPMhCvIWenWjpAbIir00GgMFx1lSBdAq9GSg0lADQ/sTMJlA+AtYxH +9BkoMfz7fKLF8aHQRGcQ9XnxlXO5xFEIwnkLUoczptbw+Q6GGE36FUKp3ZZUFxvloQN9vlwPEWxs +hepSE9Z9ZaCuAi/Y1dRBUnvY7AkmJMzZwMWINUH1S0rTtZcgZwd9r7qvup53NU3G9zkoMM7QOlFg +fQAFduoHx1tjPJj/ew89JwJqbahgMWVLoSaBoMe3asesq5Y6Sp4cMD8iRDc9YxurDj9B1IXT91V0 +gK6Zs4MeZnDLkVulWlTfov4GbKgDnB2kvnSgrv+xksl4PgMyyxyaeMzF30ilEuRAdTjmjIWHeU6M +KTSOiAYylvkV1QGehiw5MUNbU69MTbqFTaGNQcE4aYQMKfuJaYWkcIw7O+mH2RnUbZP84+HYJJRU +AE0iEYwgP4NLhnIcMAE3zLCmiXHaaPiw0CdjjaSg7gNZihq8qmHKEa9OcbDE4J4h3norwrwLdQPN +FoMEaZD0zLjCy6bIChw6VeJHby2aDxt+QMXxMQ9/16qxMG1rhp4RHmAhGc7b2b2hQ5W6w5Ut3b0w +i8zlUbYwxsmsOacBlnX6AyDdMGGMgOtnbZHyp4nBRcy6U8f0O02IZDhY3QcMepUDr4Iwp/vMtZVG +FnlBDZlJWFfkl4iG1ZqyTR1w9Z+Do3fjD8u61fSPmIjkfeHLtp3XLFznsFahUquESOh2bckaCOS8 +Bru3QSnDvB5TTUT/ZSEwwvUH3z6WQugxv65Fy/I01ys3jayBn+knlzRM69RKDyLgw3ommrF6WiFU +z8FsVsCNscXWpJdO64Ma+jWAmTrzior6EpurhtcJlR1CdHGqH0tFtcYnAYRToE5uOQ6WRzy3agbE +MzxmzkCWjLouiQQFuyov31ZemZYhGLRrMoG4SYIEFicPUwvIEUcWuYIjODZ+iB5V6C3Jh1CCyDCm +ZJ0WO76O7AmGSPIRlIWpURoAJHU4PiB1AFdoo1NMYoigcZEi05nbjF4gBLFuiZJtW/Mv5YQSdk0h +oE2NiyCgeDJyYFUoFSLZgD2NDFhNCk37YU0vL+TlsK2NrGZryGp6fCW7DHRDZO0KghxNMkG+kX3m +15Q3DXxm2gYKDQNCCbnuSLmXRo03Ms0wlsxrGxSgQrYkmjRBIJAeZU1R2fU8fClLt94r8Zjb7SiL +16rzoxfpp5GPjVbpabxFgcGNfXkq0uTaDNlOjY3G6Va11ZUmWcLB7BoVu3ic0/PR0FFOE6jADYR0 +ht5yh6E1dEpgwiV+pYkeHXMz6AWTvNOucOR/qZaw0GbQTtioKGlqdWGEC2aAzgmO3xR9hPyE0Khp +XZCTnqX0tUcHwT3DkM5LXrG9hO9JMvcZWKLghOMGv0PZC5kDlXWhLwGe0Xuw9sCFY5gd5bTVlILU +IVgtCXazqdSBYDBzGxORClY3oKVreLAZ49Q9ULaODLyE1hxjlcYOKRKogOoPo24NRk+6K5QuBM2y +YVQRIFJFoI7FILVCTXd9OdItjMvUCXoHJ9Z2TWkr81aq245xctSKVN7Qfx7GL1cnqbVs5zV8RHe1 +En7z8n3l9WaScTmENfgWQRWlhxzEYvP6K6x2CRMrmZaWoWqfTDcWL8yTXE0islJpypemGsMc7moY +p6oMnizM1VeHVhnSJjjKKbXsQYpgVOViP9lWtWfUJesWM5U6iKlLFThWVlyplAOA91qohchN2c7S +X4dZnAJvDlKjGvzl6PVFg3atn9BpUHWtUekZNMthQZYiKA+r2hBpjU5ikAp5AdYZyRo9CgThoH82 +/MrQA9HTs1fLqSXHxwB0JYcUUeh5pmqTzrzS6B2e03ncVG4Jjiyx3gYe/0ao4KlnACZ4NeSB54lP +JqQCU+BUaSGYTEJtPB3qZdqNqmk9yLCslmzlVtiJVrPECDGomXlH5ipAENU7xUalcRPQIT34Qijx +y2muSjCjrmHslZUBrSu6ruEjPZusqxv11jLOri0qOzPlmUHflHeZ12W9BbetQIM4LcZ8sviydHWe +hvlwNbwJX5aMwEtMPRKtuvDQMakiY4EjX3awhp4iVkLPd+56eLlDjFHzI8mLnMa8JTcI5aj4rNat +qG+BXAw3J6EXNRS21Ed5r3oq6kQ0MsPRl6/Vner0Dfw2fUkXUTAnJhqwGOvs4C1Z6paNGufmMDr8 +ARaJYKM4BEhbGf3KaYxIiTATev8qbTqmU6yquORsLWsZBVRF8PwHFakrT2XMcOI2ZjY8fR4PNRb9 +EHYZIUbIBG5r4bdVkSaTIO06H3olR4vkWkIwLLy94FUAZzVQ6cqpxgB8lPVR6McB+QON0R7nNEQx +38Yo3Enh2oHjg660qmG6aHyddBwtqJKDrI97Kua0eqSmIlsZinu2NGZdQSEAEHpVLUcF29Hc7gqF +ECyFEpEmgLItw6dzGstW5SkIBLyZy8a9MJ8B+s6EAIXJLoiB120TPdSrKmotqybGblXqqyvSY6vO +FBauU/QZr9Q5FjAc/R4Zbqx+RA003Jj5tX5St1Hl0OK8xmZkSkPTRF9WmLZaUgPE5lMnLZ9GB2yG +2wTNGac8TKk31oFA0MFdDhtSNQsH+Tb6oouUDbdZEIyWhm+kRmAOZnVCtlTTOAJgYDyG2aIkl0F3 +wTIae+HxDUpGqjOexI35CuYKLNXHE39aKulbUCIfao8kbuDyQ4xti1Yd25Rg0eu4mWOuda85mzS4 +IIjcfUgtTBDeTaq0KptATwwdQesE6sr6ntKOJiI4KzZV0xwy5OqIxoIa9kXVbZB7n9f2Ee7IdE1T +hqjc8O6+omBVW3oKCMrIe5VRZvYbxaUgtRuRj/1k7mLhGj0B8WAaCeGsXlpGGWg22sjDQ/7AFocC +G6er7BN6FDsf97FgifAEatDDCW7poMQQEY0b5EbEtRwUH+QZylEE1qhNVRgBRE3gQhFVA5DBh9pB +2tEoEh+jJSAn4m8LrZdjMBMPflpfXAX+pWF6dbh/1YzZbA3IgZyBNGwY2j9Ab1yMhxICWIOCuFIT +jZeH1GjSYc/SjVzjZRg/S/WuUDMQLRpToACDOlbo3Xi+NuYw2qpkeGPFfJfSZqMhNgbsmhV2Rvh6 +RAy0wUaltOozYBUsGWrgRYpa4b5P69XxzZH8kzdnCCZznbm6VqKBiEWoNFfw/BPiK0f+tLBwBLDF +QcqyQvt1YY44jx5mEJjKvBy/85rFnvfgOBBzYppArfK0YA0RMSUggHrpaG53Kf8EzJOUBYHzzadz +GctX5kkUGi1C8+cmjn8iYtG5j+f3l7R0zYmhDnTs6kDwsKItu41xYnKwMZ9G+qmK9TZ6UBBUsLTv +SvfPqQGVGSKsSeqBWA0CIGD4KvufDF/SULcI6fsci08Gce8+btSYHZMnilTFrBchTohIRzKncqhF +EUwYaotAQDvJqkgBCzYmLwciPcizeyMqJD7E1sFJyx53GUMMjY/WwZHFP1C6Edrkm6AR9cO0igub +PlraNEtTOlPbSdx+/xjqw6auqVNEyoAzUAneqBsgk14TtASdeCX0YoTaOEPHLPx6Is//LP+Ge5r8 +Gxqe0mdwLZ8oQAXZMUYBKgr6hAAVHPz3Bahk7/YBKjsboLKPTUlZ754tNuUTE9/tQ1T2ISq7FKJS +2wdDVODqM4pQAeiRABXzjAEqZk6ACt2aBvEp+cA+U3hKGW8ITQ9diIqZH6Jis6iRqxyWh6iYSYhK +tRqHqNjyM4WoaEWDEJVqNQlRMZMQFTuoaDy2zxSiYuOUp4cuROVTY1SacYxKM4lRYdj1IEZFBNhh +jIptJjEqAhrEqKCWYYxKM41RaV4gRsVGt+j00MWoVJ8zSEW9ogcxKp8tQmUYn8KWdj88RcXKPDyF +kDw8helgtiU8hZ3Jw1PSALrwlHxEnyk8JWYQKdJDF55SPUt4Csc8DE9pJ+Ep7ZrwlHYcnqKzt63h +Ka1J1FcfUnhKbT5jeAryrW9LeApzv7+K8BSizMPhKc2M8BQ7Izwlcg1deIoZhafU7WcKUEHSqE8N +UKmDHvRbGqHSaMwGL+14MEKl6uI97JqyKUKleThCJcxr9qEIlUHJByNUHu7xPkLlpSNUGmXUdiNC +RcosD1Bp3KMBKuBV9gEq+wCVfYDKZgEqMjXDABVoOfMAlbKtpwEq5YYBKvCuGgSomOUBKu0oQKWd +BKi04eEAlXISoGK3PECl6QJUQozZ4OWg8NTXzbQ4RmVQPkWphLVRKiHJqrWZ23iKUzEpTkXvZZ0W +ZahKmB+qMirOYJUmxap8Bg/SfazK/bEq2B2fJVbFxysFu1iVqNPrY1XcJrEq5BtGsSq2nMSqNJNY +FbcmVqWdxKqEWbEq5vFYlcE8vkCsio0KD6PpeteHjNiQQkZCHqvCMjHw4/5QFdjzNFTF5qEqVQxV +KZuZ7fahKnUMVbHrw2sQqoK7UNaEqjzS4xipUu8jVZ4xUqU0w1gV82isih/FqvhRrEo1iVWxo1iV ++vFYFV6c8jShKs3jkSqJ49qWSBWjgSo+Bar4SciIaVPIiGkHgSpd4Me0aAxTEcYqhqlECsEwFSH/ +GqaypuC6NvswFRfDVPy6ggxTKUMKU2maQZjKA50dB6ngoNoHqXzOIJWmfcIgFagvh0Eq9FN8NEjF +TIJUqjlBKm14oSCVwSRuQ5CK6cI1nJkdpOKb9aUXBqk82vb9QSqTorOCVO7r9z5I5VmDVKBIHAWp +wNlkGKRiHg9SKUdBKlW7PEgF1408dZCKXxyk4gdBKvl8vUCQisiFTQxSidEiVQrcCI/GqMi6xqiP +0kwLpxgV2XoxRqU2XYxK2cYYFT+v1S5ExcQQlXXFGKAS1sanPNzVFJ/S7ONTti0+Rf147otPyd5+ +SnxK81B8SvZyH5+yy/Ep96FSik9ZiEz3x6fch04xPmUhQu3jU9bGp/zt++8HYSmf99IhvSMVgQRw +ZqdLWQ/yhwk1nPeMg225qlDew8M/Ac54zSbu9es/aYZ1dM+xGbXQEMSrBZk2Q+tA84NmEiDeWYiu +dN+kvnaVjMeD7bUeq37488k//vStYNRvzi5uz2SB7Zvfrr7mBTglVl1eZgsdYhYCSk9GDVrwkdFU +AQSdACSEI5DTEY6nUauVg8mINku6rrS1XvvYwgcpenhimLhAsIwanKqEiUi4KTrmow== + + + gdLwEKrroGaxCCoQwoOsASf0mzH0mKYvTMVrBXHDqsArF/A4HMLxZFDwkuey1C4bKPXZTf4V/FbB +rcA3IpQqSnpeHY03oVF9VITgjrzQxE4rLKHJyYFNt/E2uD2QrTamoq92qxkjR905nnTw5DmuJsPi +uJU3uMTX8C/9hACu1KVtuy5d+v789PbsZ71TWiOJPjvlgJIdYdCQL5Dy6YqgAAU4la5UdMDICics +E+0e0Ld5y3h17m2gP9Ri8rPClWVyLF9yR4jcQxfn1pfqjUHfHxGmqrpSAFyzVnAdwB0KdPw3DRrn +t7Iol5DKvPMVKUhTG0pLMvCSmhS2yavHcO0l3OKbSJesXstAMUjOrkvGIlACwgVrEMxws28Zn5lR +EfYZUMj2kBvvbDo7l8TSSfRJe38cysf4H5aO0viMxUPUyGRZFLh4YXDuT5YGwA0WR4pNl0eAmyyQ +FJsuEYCLF2nNbKEmHBj/4MRzRb5606/J0rWAis1S0xtg1+ZawJsRGgCHMiVCk/Al9G0lTQXehkaB +8J4ERwrxugnxw1GV9wLfkbykjv8jv5QmRGHlSS6bbyFjGyJUDRsYLbfqaZ9AxqtGFAALLISypOUx +AI1Hg5tHbTi05FBh5nSYBF4ca3jCU4TFLe1Q1FIpWBk9GZilC2cQdLi45RYGYbgDweUTXaPCxSUX +UHiVVXXdQTySmFoug/D3gRdj1ryw04s4qBpSp1nq0mW1vCbXMDGmaV3QCChPBxXeIt4wFE5Gwz0C +rGxLxIiJcKAKY5kU5L0cz1sKwEtwclLy3dUBIvionE0gwZ7K+5g5X0QubptGlda4zzToXa6YHeYc +Fd5b43Rq3heq1z9qTkPYmTUvPeZKyzm9exWuuy0jI2U3+RrbWy/6hbcOHDhEbHLQghwfwGdHAz4c +XOTAgVD13ESH9LQQ6ZnXnvNXgsC6Bn28epMbhi6XehmupU/OMcxu6l/YIMqnZoKYeA2OUaW17J/o +slwdVnXJQpa+elStaYyquiBCY+WRi5b3Yer96ySQvF093nUCUOP0es3SBGVZHc2LgoTe2X5Jxqt2 +PFnHh++LhHOoLImx7UyNxnPf8960wpz5BmdAg3veWyALHBBwWe4W8kN3p7erYiUi36+/jQxRvMN1 +JlkrgRqyrVVCgpMUD0/eJX1yEPd8UCfQkiCYGG3FW35FBKgii17SXww46w0pdUkZuG5rPKx5v6aa +aWOTDvXdnRNgjfhq2damxqkNZamHOx00OHXVQvs11npZXEusTsNF/A29JCKRhTOnHbOsB+FhMbha +9idtCQ5aSqiUXekQ0QIliRBWKBCrePlzJYxAA0IpQqGI8DG2GsIR9N1XB/DrbzUc1FGjfSKgpqKP +YH87dRN5EIBKnT7L67JotKtbWOE5ow63R8E3w7IcA5RgNoaRg9fJwuvPMMwOTj1eyYDq2uEDGnhz +rK+p6cZ6QBTjQiDKtKn0Ct7J+2JSSTFtqJj2pph2uVgzsGLN+Is101Ssmc1stk/6aHD4RSAy4Qp1 +e8OImIb+M2xPE/HK2VmzWoNhOIYxn3DfpDSglpcSl3SetkpUxy8HZYf1rmk569roYXbkt4Z8D8b4 +1Zs1TQmNHPRG6FbeVXkcDwW19iNVznr8RTGqpBg3sm6+B909ORiGdvsmMnogdHLqC3IIIUEQdhuz +SMi2g4q2pmtLwjSGzbSRWTiBFKXxOLg1HtYdjMN6+i06DfmjoacJ0R4JM9cxldyMA6FewzqumqFz +SYFE9IFR+TVD3H3ntH9yACc+kKGCXval7iFoEWj6PIGcV2tMcv8BAtyoiumrQbCdhnz2jVGPiSuq +sj4xegkhB7IgjEQ6mc7UyQPKbgxZGC3eTVg0Ndy+1OkYToUTuonQ5AbE3INRA/vnkbikZrxmaKqo +JUbkqWAB2FxlkH9ANK0wLMx+DL81RKysK1oHVagE20Qj0NHZxq0ezW0VVqVG7Vg19FpDtfZ9vEg6 +6cvV2c3V+5uP129XH34+fX++urp5mx/zD6vF1+C1KrpHmK3AEW5TBN0Eu1XzPsJvEIsJhov4OMHx +r96swXJu5R7PKTJPMF2gU1wnaZhge9Tbj/Bdp2GE8Wtm8eR+ffyCpcvU4+Z5ONMnZiD7PFEfP5V9 +bO/nH91D/CP9edfwj1XkH0fvH+UfXcc/thszkEZNpi0EQTB1prEmkIH0spfW5Oehmsmn5A3xIUbC +twZpoVoHUTTPz/OZsvMMOEhLF5chB2npYTTgIG3klpZzkI48Gxyw7uUg/efgIP0sDjLvzRIOcjT+ +Ys00FWtmcx4H2bYLOUj3EAfpFnCQw5aXcpAPMYzDmucxjO5RhtFtwjCOu/IAw1iXY4YRG2kjhhGR +LE/FMNateZhhVHt82zSzGMdhdcsYRzthHPMZ+8yMI1x1lYVrlzKO2Jdk4fwsvtH0fOMGjR7NbPTF +2cYhdi9mG5fj+FK2cYia97CNa7H9QfZxXO1y9tGuYR+HmP+c7ONyZu7i7Jdz8HN/O3+7CTMHe1qj +HuSwQiN5p0KK+DeB03MZbYL8pns5/Sr9OjsYvxsXziqOP+FnHgCvEYYGUwZwwhkNgxckKMsAb03h +8cq65JcBoU4nSO5jvGMGk+BV51YJj9A1EX8c9yOfxRQaQzJnW49AGvAuZQWrUknXBlCDCZ2rgVXp +cun0UJAbJLIhubYmP5moFuuqEgoDPaYMu/O7cib/4azIOC3HF4KGSVG7mBI3wiqqmRursg4JoP8v +ElQfS/V71XlnqgDkfylhBtUQPaZGcEzL1RqaAAx9IwyXCIFYmHhT44BmuoOyIl+LeJzUhP7VZI9Z +27Ffo26WNNYM+1pMvilSnX1+RxsROaWR1P9ygFbNNO81A4fSS75zMBOVlKPpYAzPPwN7noO/BG8J +1DtD8eyYlRGQRnPoEGIYk2/12ehz47pHTjWzxNbMGwVSxDkzHohOp2PHFFQM0I49zkfBvwznsysd +83Ec+yYKQmfjefHwpKmJ+YFpO6M1ecnEIdPtwqn76s108u6FPTil6O7DkzrJLtlmHOWebs6im4ii +VDaC5zTygjGwuKRsa8wae4wPmiiWZDM9FOSrhCw65c3qRnmzUbpb70qa/FuRthv+MKFiJi1hRZVI +CpMGtCgRCI+4lBKhUQhX2pPNPdnck83PTzabgSCOLQGeSOSP0NKNKIGyW67A5ENzgw5SH+YrfpwA +ZyIoG40ejhCkB4TQAC8cBI4waw6DksMhs0BCAtTEZwWdbUILpp95BFBHteoFDz5qfJIj1SIA/6eD +Sg4GIJF1/DZW75GDIbltDRM7VJp8zsED1iGTE62emhVYczC5GC8ZJwKVpHNkMFcPBSqAtDqZa3Ck +RWVxzySinuDdtoY1dV5EPerGkE4cwZAVSIJR+RjJBhn8a/Xay2Dr6J8iIniNBHa8SgopoOEjtKao +9ZWmrhM5HHkL9KKbDRs9mtmoLC5s8ZDeLUM6FwQkrMHLHrgIMyHYLsbNr94sxU6lPHPxU8eyFEOj +295CHB3tfjNgmgZrkM5aTTqpp2Kjzo0NqCG8IKFvxZzQs9HgiC9rnkSQjeRAb+kQSY2Vld/eNwMQ +vvJIlNTUzEjUIumJVF1HALLhOuZUcDGXLjTJVm+EDZrZvD3sUpcy6RPTrDB0OWjKRuZmoYcVQFRp +nwAUo7DxlaPWtlUfOrr9KVvG/NU11comPUd2jpeKygZGtDT5ihbuabzSF5PuShDuhrHTPBtLoxma +mZTs5IBOsAG8R/BqKUF0G88IugeekBeBayF5kUZ5Ec2DCwjOIEAso7vRHxuAh3VJ97wxe5J+3asm +9DX9cqSylgnf6yBLw5CqtlxHooBhNc9UeO4wAYpDYBxv0kKMrqrdnKYuC8h7xCSQPzAnqAjNuikD +DIFri1Y1LmlGEjYhl9wxR2cbt3o0t1WH7KBI+GQCLwMb0CgzTCq7hvlIW0Z9lxduGlCBybbBJp9s +HACXbx1hTDbZPF+9WbN9CBxvIAHO30LKyyzZRCwx2kYCG28k8l/DrQTQeDMRNtpOgM3cUP1qjy0b +jb2PpI4ZOiYhpjNnHW9M4HMF/1a9LYDPsJ4GsnhMGYMNwUkrGSNfV0hNBxUwl/+pGPkR5EEqUsqu +goBomBkPrq7IqLlOB0fEKJHDQPYpMsM6OdAY2h7okc3LexoDsdIgT2rTauZZJJFBpA8vbQfujIvV +lpZBKVYhgKhkDsZNWjua01pgjk/mb7FIyLOMbEzRQmGLEIN3cyxFjScVVQZ7wi3bE8O6kAmkUv0I +U454mIhw5WZDD/mnwfl7MNxZYnhloR6ABqTWHMSgnyVtMROFiRxZTDlKP7wYi1AZ8HSIQaAxhswx +064xWt61Mko9Kf9/9t47P5UkaQDcC3AHZBAgXPkqkITwIAlZkLc4SQgrTPf0/LG/vcAeZ6+x19hr +bJryvoA3rX7NN9+8QVVZkZmRkeEyIgMwqCRipzxKLDH7lOXFi8koqP/ymPpIeCcEuowSMLekGO1v +7JXFTBZdUggvfBclpYteoZAV8CWpFD53V9O8ayLXU433tV4ZEWsIllnlIVC90QS0oC395v4MiGNh +bQMKXdZBQLcGJ152AcMqSHhRbVX1iMU3T8HLpFFRLfErePE1boD/Bjq6/hE8o9Z9FTPAjRk6h9cV +a0dY1Q/Zcjcl8W4ikyQM5vEnCRRlgxJFjbJCTpuneRxCBIuuobsfxDccMm1pPD6kwYERk0rCPvwW +ni/DFBOHb8F2ZIDFp03X99hvznu/FLqDFuifyl6aw5uH0aGoQgAxdMsvj69AR3G6VfUzBl9aHONg +SjyPq6IQFAzGVJZcfJL3GR6B1dN/h0CjNiJo5YHYf96HBmlLAz+fbPWYttZzkvjuCXT1BIFyAe3o +FWY1M45kwyOniJZaIXTHL4EMQixeS6xeOs157pSCOVE0KXjSdIyUDJ8ZaVnz1BM1B15N6DnwuhBF +g8/0NA0e6WkGPDLStfqha8qGcRQG2oaoWIi6MQ71YzVSuFbusaSqRJtKPEGLFd4SDSPxBnCvy92J +e5tR8IkusedIfNE+ukZKM13euJF5ef/pvooZ4Ma0fTPoigL16Ko+7V+2PllYqR264OAdMhTMw4Tq +stVGxldmEgS60xfeq6fbHCQh4H0oUMibR1PqzYzzS9E1BfbfshyuR6DazQv0nPPeM5kEQg+qsMqW +Vq0RJ+5Y/RMkLvDSiE+gXyWJi5vRwKLyKysGRT3DYWHxwwhIPUQOx+vpphHTz9OAnPxqiQ1dlCk4 +rji8nAJWINDSGrr/laMcv4bMHhZt1FKbx65zC3UN0/OBCHGOxFtE3aaWU7dJvbrNCQa9hRN03B0J +GBV35wSD3qJ6JOktqq9iBrgxQ+eS3kLqVS3Snbodg45DgUQB8fjqLBJmP9rpLzFgJjIsum4B6QQ0 +p11RqH7Q0BKkaaXKh+pr6DVkKMevBQq7RrVXZHntO7dI31BnJ3iO1+rdyopxEuPj8Q== + + + X1hHFutW+iU1Ad0IBC9RR8oEgyJQSeRWzfs0+gU0cKs+jQ4CDVONliIRES/If2uISFCxPHRDjvQo +ZoAbM3SeF80F9Rgl9Vc9EQScFfA0Nfhw4HU0vBCWlUkMWO5JGxLDDmMCX0ZNMyZMg1exHB4a7jpu +x8B6aLTj1/CiNPHkcYm+cwv1DTPZYd0iD6eeWgIUdVuZBLFa64UIkfqqJ0P1Q9eEqBmcRIpQvVyI +GCV9X0uOkrbqliB14WC8lcsRQyUN9rRgYk8LBgtEMFggEg5U9rT6kWhPc3rrg1OBVh5o7WlbJv/z +5ZIe07/CntaydGyggnG5sKctv3S2p506tbanrb5cwp4mTexpLS1rnnqiZpHnaOlZtKe9UrRoT5NG +e5o02tNaulY/dE3ZGh6lt6c9U7dkT5Mm9jTpZE8vqNiy8M/Xs9HwYtIdzrrDj1gMP0bqrvqF72wM +3wj4zUV/Dv49b351WjMfvmDSn5vMp5/+08aw8dGZANW43ZmE7d/58ct8o9/vgp06/uy2xJb10aif +ACr2eBb3n//RAL+NTYEaAECo27O27U2aIhClfmPm2J5G7a9geoe2LQJh8gFv9YGxLZ4IyRq/AAt6 +PrxozD41oPOfjUlrpEwStEIgTJrWO/+Z+QvdP7oA4fZA6whEY9yZALZZm01GvQ4YWByvOSASzYqv +mHIsEAMoRI0U+CfEEvx/gsD/RX+JIch2o12oc4X8UNcU/A/nR0UucLfkL+mW1k2ZBv+RJqz6z8r7 +xaiGuwF1y/pZSWImf3WnMo5hpyTqEPBCP42RTP6Cfnkdknk/7xXJq9wBZnsSjEva6YgYE35Jq8Ft +QHM/lfBL/4GYSvgRusg4JWs2i6LOYkR1DYfQjYsizIfzywaj4m5WKIK3Jvg5ZVww4obkORhDBPMj +0W1MMC6TR/wPmg1o1ITbUXumgiR+I13FPPUlToajP4foDyCzkVwP+xNnYBr+qC+RBfL8j470NpEX +cwxL3T6YGWwPaKQ79OMG+CnWdBNikyhQFhI33Wm32UcAjRBqs0artxQEr2PINabdlvI5XmRMUv7z +9/dpBwg00vp78YOjfn+OLsMYTeKN8RggDS8O+Kgjoi+kAeqvAlT6i+/vYO1A63p3hsBRqJ/++URs +DAZod0t36Gg47cLUTvkuu0J3Ou43/sJ/wpTPBIYkrhqYyJUPEBtPkKiSlgAT/9BVDjwjcJqcPkFK +5YO5fQKqhEbSMAHwLmvuXgQNjA5GEqvxiULn3b/n9/lDquGEMTLxDSX4OUaONKuob8+P5u/f8wGM +NiYzkxXL9TvDtocFt8NnAgFTcOXOiapMTvncYvA288iPhu15d+ZmDmooK98BkP5WhE75+pnraaf4 +R2d43m4jkoRdKEj2dNuLWGBCleplWmsC2diwLgvyUKGL92CQHg2L11KcRbkJZR3lAf7mNPj7TMmX +KP6n05rDIaAX6FszeQbvb+PWQu03E2pu+cdaGK2F0cqFkZkEwidDJDwEQYePHA+LHMJaE/i257UE ++hslEPW3SyB+LYF+Mwl0teQtzBZGlQlVrk2qtRT735tUnu8yXwu0f/iUPAk0YS3QfkOBxgm0gLLr +KPC/LPQBJgWWxne/sgy8SwHeECB6sFl8dw0B80ZgwTlrPyG1dhSupdqPkGpJAV+lx1A8umOShZVu +UBQKzKFOrj2F/3KxllyLtd9MrK09hWtp9NM8hYQoXtbC5t8sbGD45FrYrIXNWtishc2vEjZucg/W +Qud/NyVD0sPfIHbony12/nVCAzreKJ6AZXPRDXnovIjkGYbRxOfxPMUyuKY0QSNPHA+j+difdZS0 +IMf+XfgtKeBLxwlYBgTdNYk5L8uaFO/yyHh/Hx7siV0xa3b149jVUtXj1uzqx7Ar8c4EghZoeOyD +uBW8cpRjzK7vWPMrN/yKXfOrH8ev1urV78GvJPUK3u9PKuoVzaOif2t+tQi/+uHB8f86fvVTfIj/ +XFajMHXLH/g/qOySJ7605iYO3OSHBzr/67jJ2lr7ESxp1XFMJA7PBawsKaDadiyfZAhcEpQQkitI +efyX8q91XOuaA7rjgOv09/XR7g+TBkkGpyFRPA8vFkQ38SYp1uRyyvWZ7z98Sp6E2jqq9XcTaj/F +SfAP2zVrafRr898pgaYZVAYW3icvAMUKlcFj1qGu/+78d4742RLoXyc/1m6hfybrdTIEaGwHkDws +OQZLe1AkdgoxFMOtQ5AW5F7rQP3fjf+t9ee1/vwD9WeaSvIwt94f4zkgc2FQQ5wnGNqkuvBaf/43 +6c/UWgL9ZhJofSzxI/jJWpD94mMJVCqGZBgGXR1DwjIzyB4hBX55e+R3ocLfZ0qepNoPz0RbS7W1 +XbUWR/8ccWRz24YYJ04J65t4/+WW1A9PJ1zLnB9jSa2v4l0Lrp9jR4H3cYYB1IztJ46iuPVdHv9y +++mHp5quZdnaflqLoX+OGLKyn+IURwAFyy/dD8ByLM2uDal/uSH1wzP91sJnLXzWwucfL3xgUASw +4DnWLzvx2GRyndHyLxc+PzxN818nOqAPTmB5QoDHvBwr8CSMP+UIgke+N07gKVTsmoBX6sAnpFI8 +hOGJH1dk+F8UUmxa/AnHEXMCgaPR8LVgFMMQy/ucfh8m7IljrXPwfkeex7EsyXDoYjEe1ko3u3KG +hgXVk5gv4grrAioCuC6YtNa7/37273T2QJI4sy/JMKQAfzEEyzI4qYRMMtw6NPnfLdj4H57atxZs +ix2oMzSRhEIryQocj36QAstArZ5gaCzGeIGhSfiDhLo8pWj1a8G2Fmw/XbBx4k2idJJLohu0GIGk +CNRJXGBIcl3h9l8u19ZJn7+bXFufb6zF0Y9ys+HzDYYGSjQ6XWepOEERwKKKU2SSWltW/+5DDn6d +9LmWQGsJtJZAv1ACMRw86CEFgkyicgqcECeTAjygSxJrAfT3CiDy768VyK8zNNciaC2C1iLol4sg +guR4Gi4dxccZXiBR0URifbq0FkE/PGFzLUDW9Yn+DrZJU4htspQgoNhYhoP3rKC6dTAMj1nHaS3G +btY5db8bw0KxqRRPo+RvhmCgnhGHOeAoKEsK00KJ4cAKhiKPxxFbPywm9R+269Ya8/8iPItbX7H1 +g/Xnv1+c/fDqnmtxtr7u5B+09dYy7X90iT2MzBIYFlAyjD1mCUaKOCbpFVxj/7tQ4e8zJU8y7Ydn +nv8rJdI6+e8fyYptkv94gWShZwnn/gGjgljXD1mQYf3SbGVTdnMFYfrzo8mwM5muit3ogMosxnYt +AP+56jQA7ULymk+ttuDK2a7I7lx/75FP/iK3+O/LnRbEz5qjaDnKZNL4y18ZTbr/HQ1nYFs9hXjK +P549hf9ROtF6c/7bNyeWOvVJYzh9H00GqxJRKoDuxJOMn5n05UVjBsYwRJKKkITXYPRH5+b1YiY9 +xd9MOu99oG3faR82hu3RoPvfjlnTe/iQ8SeOgJ4VGneHF6PucAafJcVnw/kgPxp3O6gjnlL3X1H1 +L4rU0awx67xeAcnawAMmCfnltNXowzF3Jq0O7kMeDHpV7Q47puAKnY9JB78idcBKjRbAvllHFXVH +pO6V8tnvZ4y7YttlgNChmm2XRWVbxbVr3cG4L3NtL+o81uNxHwpg+B26MclCaxeNADATQILWQz8a +Am3PX+6P/vSzQNCsxcxazPzjxIxCw/ZypjAZjWufjfboz3ijay5g1KBcG0CIszf7Q4QTIs6zEn8c +jRst+Ex+0OzPJ+amvcnFIvof+D93Da9+AAXTH63+RGTgaMwfs7/G/2K2fdEd9vy5zh+d/r/YgGf/ +Vwb8L8Kk6B0Fat3nqvCoAemNC3wNZ2hH8TILeJ/ORKVQVPX63YHLPfd3uBgVrsOxNIGPHKkkr+ZC +MJde9PRyPMMux5J+zlnOL0kItJzHWndZH5UivR7aaY2JWrGPExS8asxP0izcdDTMF+bZ1d+Jihli +af7f//7lP21Me6tin6UOYJwQ3+5YJylbmle2EuifrZD8Qkpfy8Efu5Whjc6gXUxZGuoLGUK/z8Zw +paljq23tnFgL+J+iHf9CK30xOQ6dG35pnyzpBdHAcmlGylK83Zj01E6G1nSCnCBUnOSkNn90JpIn +GSN+3Ogiz0RM3epzNPmvxTpQLAODHymBw8GQeAXgX73FET/VuUfsXDocMIL0Xp01y1ax7EfwtDHv +z57tfeDedhQKRYKRRyxa9SSH7jDkhSS8slSeqZcIWHMneSB7lHwtDtvZyQyNdgqfsPDJ69loeDEB +rbvDj1gMP851wP65aPQ7s1kHcdiLpptxhh6vwIdICQOYfA6jxbr7r0//3HfR8oan0O1nd9YRv3NG +VwMSIJB1+o6SDMfSMLI4SfMkTWtcAOJ3V+Wc/6rTlr5M0smk5pLkJM1QMF1BPUTly/tOHzpa8ccc +y/Ok1s0g5+6oP0LnIOI3LE8kGV7dIUkzLMVovyXlb/N/NaRPBYFGXg2eJ0h4O5MRrXg5xC9z/bmE +UBr8HykgPBJ0kjJdCPWnp40PoAw2xK9JnuIxUhkyKaB1YVn8g+A4AaGPZznM15RAOp5jeBHkAQwA +Lx/QSX/ugGGNi0bSeLkFAV7xgV4xFI8ueJeu8YSh4uhiT4YEkEWwFM0DsJQAwNKcHizPAcwmEVjA +ebVrzLAAHsxNkUerAQselQ+ShClYlmRJCt8+SjJJzTIkOXiNNmyD5w7AIizIYOFoSfAvgEvo4dI8 +w/IQnEAmOU0eWDwp3WrKJfGtKHGKBiijJbgsHC4cfu6ATUpweYqmNKMTWJ5lKC1c6BRDNA//T7k2 +VYJLQezSCL20CBdAJTSDg9jlOG1HGLkCLwo5LVQSrRmgeBVUluJ1DELgkhiXCuKZJIGTSUXkUjif +QKQwhoBISMLBchJYQLi6nSKwYBNpRktRkAggXInEKIxlDJdFayYA2+eAZ6SNSHMofQHMi0b4E5Ik +xeEtnKTRxWmQBiSBz8N0BxEcGiQDV4qTVkrgaQENkga7AA4NdM8jNyZFE7SAEwEZgsf5FTAPUODU +0AiISVbaVTzD0Sj/QnGK8izPaKZMSsstTxnvBwwUMD9pxiQpg4WIRDMEjARlJDI0xXIqDgtHyeFb +5MEPwyg5uPdJlpfgEQKPqAasG8GbMjOgVcFJoxkgDEJaAx2wIlgGUz0cJ0VJ2xTQHgUD88E2ZTD6 +TZhknGHg/oEIoMEqsepxkjQcpyCI8JLgJ758iARry5iPU2KqZBKsDq+svThODsBl0PQZaZhJjiQo +JM9gBXCBxl/THIFQIqfHSBuIxoDFDYT2D2ROYEgSOmmORjIkCVg1YX7pP6MwZZimg1iVuHcIuNHB +wsEhsvKWBISEILIswZpCVNicxEZZvGTSluQlpk8y0pakQb+4WFIcUDeLdjQBEIAXGuw7cfvQYhw2 +hsQKABKcclKCQxKAQXCY6aLgbiCbaB4vOGRZcJciHqlGo3gXtMiHKAmPSQMzTpJJBg== + + + LwpAK69lxrJIwrwd9CydKMgSiUarQ5ESz+QAu6PQjCkC0R1QOghWQ02yZOZwThT4IcvOJCJ0AW0g +af4MDXiPgGiZA6we/kgCnomFMpNE3UH0sCIXYnClBwmfUBzDrEy4x6U9CUsoovVgIX9Dm4hnMDOh +4LKRMqOAyyiKDlotOOEdxUBwwhUXJKiAIhgSjgQQN2INBCBmDjMQDikRtMwoxXWiMKvHMAU4VLTL +OYk0KVagSDRlggO8GA40KSAcECQgJEEtJDg4PNgLQ6mWCcoJgACWQ7tI4sQ0S4pJbEDBEvMEeB7t +SBpvBk6cPoMZkVxJQ4TKwa1OItEmUBLQJMei3QzasQg6n+TRoAFN0GgakmSjJTkvyiS1ZEOCTWaf +4Eu8HnAzCRzmTxzPYCACYu6MVNuDkiiK1K4VpFSkNMhKDgPYIeLpXJIGWp8f6ztJUT+RxK64ScG+ +UhCahDPH6JSwyQDtncCKGLy5HY4R8BS0Z4FujtdZHKF8WzuBGTOGibBJI36Md5IhUas2ep/5kSHg +v+l+DKExExYbWLkuTb8RgQOIpUa745+N/NgccYKlba1AMfWq2sDRt1cgmYVQ2QDSNTdFGrQL/ChA +r+8esOlHEHyo9j1vTDpTf3b40QdmlQYM/s+jCuazf2z4BJELXHzMp6CZeZE9q5+fFf2Ah7L+PAT6 +H5/+ofQZ7kx5C8AYvkDPpA8oDhE2+B8VSLNu5F7AVuU4UiNWeUC5WkErIPGCtBTxqJnGtzdI8oZG +ei+UsoCpSLKB4AgSsQegSQqUubGcFBkkL/IJQaWtAUaA9F6kBpEquLJ+C/Q2JChYwLO0IwaWLyGb +HATma2jokv7PIAmJBDhgrxJohqcoGgPiGcZc2WAlQSFgtgvltFo1oKFMo0g0arDkpLw42B7RLChg +CIa1Qc8k1TTJox4oAUgWK5VPVscFRTWVoFFJealJuOUaf6H4losPt74IrDtCoS8rZByD9VCeBIoz +En8cB5R4NACgS7NIqoiXe+h/iOiHC0tBliprtzxQS3AmG0PTBJamDIFFNbBrkDZCyf8VDRioJrMQ +0ay0gBwYAFo3FthuiO+C5QLMGXF5EltztDQm/Q8MlUfCg0e0LEEF+jpSlVmKxBuBAdYWGhMQtyTW +UeT/qjVP+C+Uw5LIBKNB68gAlQYRGlAgwO5Aqo0o76VB6X+IYCkk3pFjAPwr0S3H4vsoCB5JdxpI +SA6TCcAIIypMnFr1wnoSS2tUL5oBdCYghQXsXmSUsSSrNoWAeSPd26L7IcLlsUqHdhYvCUwKuqKQ +Fc5zfBL7UEjcgcJk5P+KRELgPQpVDvCvpByTQCtA3wlsEvsSBKB9afVYaWT6HxJfIZDxD4maUrwV +rIDbEgxFYI0L2G9ah0BS5FLa/5VcIEjpZii07ylpy912mv78qD+CInA0H8ubD9YyI7G/g2MEc+uL +km4VkI1PDafhaNn6pBTbhgeamBavHF5SxVqSlFFe0nQpsUSaSGHYekB6Ka/nuSxFYQ0cmHYsr3Em +WjqHWNbGOZQUlTCBAARBaeEBkxXwNvhDbcVjeBScN20Yn6c4KWVwFNoHvKzZSnYqYBkCzqIFO0Lr +3OSxyikSrdprRQpJhXJJDPMiJzutJd+04q1Wu7F9Z2Ps8EZvJJd3tTudqb34dlHu8gGtJqbSGFxu +m+BkcLqjETj63U1mQhL4Ve2vQXPUh2D+D1+oMhoArTJU6fTH4H9yjWmvgwYOdMXWZxiqn3+AUUHN +M3RVq8Em8z7Amj/mv+p+fM7UDwqjP4fqv6udd83767H6rxzQjv9sTNrqZ6XRRHx0PmmCv88njeEH +7Lo2A6qr6u/cfDYbDQExGZ9R6mf1RlPbCD7QtMAdYT82mH77o4M+gOslP9B8gB/R4JHocgeD67Z6 +HTg+5POXBgtlfFjEO1gpNdatV0+ktsKoNR8AEio0Zg1f4DUh/e1Pob9U51zw77vT6tmo3TF9uecP +/WfQH4LXscZsNuk25zOc5AKaYqr7X4BYAXxVq9Znt9+eANyjNlJsjfQW/jP7a9zBb0M7w+nrH43J +dE+V3K9u+kcDrj1uC59PLdrBdHHcTBzJVPPXPxQ7w9Gw4wIx/RGg8LYbzEgto3/vvJrdYRsMlHQx +N0Actc7sDE3CeX7q1ita/iUxQdpiwtX8u41mv+OG8B1X9Z+00VN/uN7qsOnfTNFweq35dDYa/L2c +7NfRYWragHEQUOaBLeaWHH/5vqjBm2t+zFB+h106ff/zB0vjv3kbTPvd1j+dF8cEUgkNs1xeV0v7 +d/NdOBXOaSp/uZnKX3/3VEiOFminqfzZbaOwdsfpiA3/AVP67CBL1cWcpJZ/86Sk6E+rCTVHwNId +QPP6fNIF1qKbqRm/+QEiH/G62mg+aXVyMAh6JWzvH22QESZv1RibNSYfnRnQA6DLYHpUcLP0xm/+ +ZlX24qxMMaXRZNCw2pXqKb93+x3bxprJqlv/481zwokTvKNAaHeWudL2711+x0l1h2Cc/UbL3bTU +rX8430aX7YwbAFzLlcagbf83b9qtEvo/Fxt2AK8SQkctbiapbv3DCXM4OvU0NW37HyBvnRnv/8yk +1Qqlv3s0o/GsO+j+F2UW/JQxASv57x7CoDNrtBuzxrLjSC45jq22eP7hZtepGqOP8UkhQfilHyog +tZvy602382du9J+7e7H942mn3Z0P/Fed6ag/F3NQ5C+yRyTpl49jAK3Mx/5SH25zeKZ3MenA1GDF +PcyxLM2Ks88eJf2Nyaw5akza/hY6iib9TXmWMvtBXUiT8HfBKBqzDmjYQS5t28a94ajVG81n/g98 +xo2IQMlBgyM47Uw//VeNKZCaIsGrZoq/YCmGEqwHTfk/0MmXu7ayxkETmnGcz2djMFD7kVAqyGpp +CEbQbfun4nVzLkahoNlxRVSTc2wrT47UrAcig8kfHX+985+Zv9juzhrNbr87E6U4ycgwjcRUbQw/ +5o2Pjv9iNJaWUC8GeQkv7XE3jptIIMHIJjoSGaBLDDSPGv3uVPdoOh6JO4aW/R3jRrst76vskT87 +n43kFTOSbdI/bozBLph2B/N+Q1lFed1z/U6nDW3QG2Vzk5b41VpE+clonJ10GjjF2SAzQ0osIKnf +8H6aMv4i4mH0mY4liJOVe4MdaHwN4mClVcs3hn80pjUZHWpCIPzvMmcAm7LfHXb8U5RYPLVvPJbo +Z/RHZzKGB8RT7SpDZIlcBw76ct6A1OWv4kub9AzCbBwzQJm4Ja9QuKblBK1z7I8OvMXQ32z0G8OW +wyRb/e4YrB304v8H7I0PQAHiwEMkEwfLoWKkvexRad7vS3i86UymUPjOJoYuaqVbfx5Cro/8WZFC +zPeF/m9CC6RSP636r6cd/9EAbrDsFAUhQFY5bOuJUW6vNBHDh2rwukiJJHgeVs1y/kov6cyb4nHh +iyXkXWfWUNFRzNDAGMcjfeCvjYGpNJkCdM+6rUZfT1aWHyixKQb6Mn4DcJyv1bT71xQ2SiJVm+uk +HdijYas/bwN9egApRs/AzL4oj2B5AJhjD9hRs99xMSQ83eJgPPsr3+n3p5aEIX9SL9xCX2hF5Ty0 +6wEt8mljXJcVIMpF6+qopeKo+hXX75bR+C8DbesQJSLTf3d6YQ5T1x4lK2NM+k9xsrehX3Wb62H3 +P6Ydqxvddoft0Z9THbWrWnTVclM/wqQGb7XGH3BrwYR9BcJoCCnFr+HPrr7xw+XxE+ICEZ6+Is2W +1ekjShyf20nhr2hRUfH0ESOOj/H0FbvQV9xCX/HiV95QKOjoyIYizAlKh0bonXaiJ8LdJ3iA5kts +/80TQUj0JHj8jjLHveN39ILfWdCV43esft0sEW/KdRSJXps330f9dmcieRLh02lYL3Z1jVXmmpY7 +FOZjMBJofCljyXU+AVWp/Dm4KWog0ptWOO+Z8nXdO7UNoHqv45zF/4xHkxlUg9TSVaVa59Ahj0q5 +NihIGidTrdOvNGagbyhc+nB6U5W+a9H2CPpbjwrqlurXdRinAHs1Gx8KGVUNT/u2Phqr3snnx+X+ +CCifV53xvD+VBeAefCtf7qGbqP7uD0XBAfY+0jmMshe8KQ5bIxMLG7yBZtz5UNHL1O/QNTMId1Bz +EC0oBSgwBVtdZdyk8qYEtKm60XkMQQIz66QzGZoNBOjWsvqpHvugCdCLNHbTjgCxTzFpGbZQ0j8c +KYaGvztEGvxo2pW6cfaIUH5gHNp4QdT2AmqL1Pm8aChcqQ0FtTWCmuJJJW6wGZLTmCFqzwZuLcVe ++xtAS8auDp1LQeOGwB/B1DhoWaCPkMmu/8iNU6h4UXOLA9zYGgnGtuei2VZTm49qXOFmNsjSzhs3 +d564FsX4K2ccO+xGOXzef9tpJm667c4ocToCml4HIhUojmAfdiTcJhRHeaI16sNyAgCykWWr201n +/Xgbd4GIWhYI9uDhZ2J7xaPo5ptxewBe94euBzVuuwaOY/7kL0j5eiV1w/F4EkfCLt6HQfeuWs5G +oneJ5Xn7lhPFsBEI0r4tjjPQsXfNGsK2f47EinD2zT51zQw4/Ro1AU6n3Y9hw+g01DdES9sU4wzs +IKKGI3iS7KJdY9rszgaNsX1T3Gai2ydmrVv9Sbw1GsKrwKBLzmaosKXMt5voqiI8f9609aQdBzY8 +vHPHYQCg4TtgTdI1Y0gUm7ZCQsLo5TP0+gc8oB3HP122+8N6bOOPQS/eGUIdw90OQh/gLaSsp5tv +wKLN4AVv4ljiFGtK97Ap2NSQN6sCoiyHPgZbpDt8Hzk0m6guunJoijylzcZkaoNc1LAJVSywn1Qc +wkVjmUm4aDvR+D+cWqsZBWfZfNCY9KbaUbtoLI/aRVvVqF20Vo/ajMlr5zifdoBKjJRbm338PpzF +2/3x5H00tNvu42kcKmaAh0ztyWIaBzwTOmWHoKlK+Bta/mccn+hZEhL4Zi0/3DAv0E7kXYp/2QxN +SjvsD7eGOGlPptodbyqAUDPJET2dWvfcGsQl73pr8FfPhg0qDUf43matB9fQO+Yytj1DLUFkQdfx +WtyPc1KBPt/2P4Vqt+cXT2H/H5SDDgTHpRJOZtIOtIFaTHdoIzqhfHUaMmwjqiyiJEias0Eo0hX2 +JzCUVSt1hGUIaIGAb7b9zb/8hUn3D3Q3th1fBt8rKpaNcqFhxFaqhYm31tAIHTm6khlQxmvGZiqt +lfW3FoKTD2dBCdqIQlJVkErfClWhkmA5trMRurjRuC8FIZkSN2rTGk7tUArazLp9tYVtzj+n0jWb +Nm0Qj3WSjRNJDpgNGbNdzZKYtpkC01k6GTVnt33NsZtZi2YX2kK2TYadj4ZysmkpAIBiOrRv0ydb +yHVuMPv0QuKz0e5MVEeRpq20coQ3UwUBM9efDpoy/H7XRkkGDUbjlo1ihBpMbaaOGrTntga7zQ4G +n9tvYCxi5sOWK4aAWjeGw5EShyqGBkAnS1Zq6FdcZZ6jAkh1e+Qk0J0WG9wupl4Ewg== + + + qlVdFuEO9ry5UEQWEhgyTpy2pAzFkOr37VtNe90xMHOGNkIbNpuA3TiZduDwJu66lcIO3LN66QvV +3KyGA30WssdOSwXHo+YRMAbUNKBzfulXlLB0DCmLJV58fVEoiU4oaMvAALfRcKp324ER+M/xK5Wr +Su12bvzROQXivzvud7JaNDk6eVS1FPyqW49X4N+Bswfze4Up9nlFJxbDIGy/cxOTYfYdBfu7wIoX +OjqFHV6M+l1JKpoaD9JAccmI0mQ0AEj8czTp1SXJxNhM73Q0HLU+wUcd1SRPukN3pq80aBxoBd32 +w5k4AXfYlaKYskCONhuzauOvjmRmwium7JcFXgaB8znRaUu2OfrDRZcoVsJqRe07RZ9a9+ptea4U +5dDcIDKfqsFt7GWFYAEB5E45aoOV6r53JfbFeUCYQh0u6N86XIexnTSkS2tMexe9ElwlogkzLkcy +pVQogNakfk+qvNfaL12FQXojmarieLUZrMVmVA/aVMdyH5tlbuobWYo11Xqbd87BI2LXs0KtFmqq +60BR+12q4w2Gj10wQZUwg/GcgEbzjTGO6uw6iA4GwpH8QNbKgtIjOoE4bQApoaRfuOMkhc4UDK3h +XoJKrCM7sSdeE2a3oCCS2ZwLTADGcqR4Sy18sFLr+qQ7gEi7VVn2jrLGbDp2Q7rqfMA+ps6cWaeb +ODJm9BEOkO2qVFzr+Son6s7DLoHNc9tpwlB3Zx6lIiI1X3IeTN3O3JbxAhkYUIjrn/NBc9joShF2 +ofon2Gn+xqTjn312/KLbyT+VAuH+/OwM/VMcYdEYqgt1+SEX9Tem8LGi+0ox8XEUHzJDwLXA/hrN +/WPAOf2An3TwnkZdY3AfsApPV9NR1A86kz8dghnDi1nHMPnM30Un5w1/v/EXjL9vjHHoCORV03nr +Ew7vaFhAR1UKGNzbECB1DkY3ele6707982EPVg6Ju975rUl37LixUGOAEcRl6ipvjN2ayWaIC0rD +MqpuSF1z5M85+RCDYp02Fhh4xxiDZTZVMJDxWMV2HUhYJcVt5SiOp4CRFVdwka3dQ2pGqwtntIMv +MTMXRklt1hi25ZBol7xYLKXy15mty8MxdtwZoWr1wH5dERFoFxaYy+ANVgbzsm3oyvw0mw7gq/3p +DFjkczk56P/7v/+f2f/7f9njTPwM7K/3ybfWjj8a9vzwSjeVCc/zSSUmUGdiKzNL5LrSyLO1/NGR +wBY6sH/4kjk833mM7N8eBPcad9Fjeuc8lstMyoPP1Mdw47i0EQ0F891GfLrNXVeK3FYqc11OnzKH +qepT8DQzmbf4UpE6FQIkw2wRxLTwVfiIEtuZvZf4bmY/Op5mpidUwhfI7FU3JlKj41nuo3JZzewz +nVq+e5BuFeLx4Iehq2r7HvTHF0qBFP9QnhW+nnPMQyyaHYyq0+xRbfYZSXNb81KB2b7NffWDt75A +4Z04bpoC2+aT7/zN5eNTtp6P31h3qm6Xes7s90rPmdQ0PogUooF5KVRuv/sCCFmlN6BhFN6fb/lc +P9O/S73nPmf5T/6B1KDjbafQIqvfmf3D4C2GA4Y8zb98vIzAr53vwlH7aCMXE762s7XY1hCP4a7R +nvsCya9QpFVssZeh/CfzurefDdA7kdxZ9C2SyQevS/nOfDd9c7z1uddqNXrwVzdSfK9+4p5JItHg +J93tt1T35bid6wcOg7FJ5GmerdZ2vuH4w5m940/aF+D2bp4z2WErOIgcnO4l+MHTQZfnE9N3Ojtp +HZGRXoqUIbYKx9MbgDY+2OFvaaKd6uYTDbC+5OlBKBbt5Pr8xQDP4L4ayOSP9rdui9EkOwXrcvTI +baX5/Oglsn/TfkxRza1nBDY9DIAJpbndLbgkj9wtdzmEeErnemEuJpLmTbtKkM9bp4VEY3+ntBF5 +mMBeOPjiBUFBTXwBorl5xKDfkXRpX/y1f1s8wc3z0eIbBkbdU0eAdO+ISDpdjFKFw48DEc7twf5e +++vsBa2kPGAA7zzHir2ARrljeQDPygDI0MEVbNRh0DN2I1d4RagGwvKQ4R64r1a2XviKFN4TJ9/F +RiO4neOa15f7lcJrOlv/bM2yF9ut02ydosHqZ/nn+y3wTfuhePd2OJdRhKlWQ6YvPQWY0I9PKtKC +3Y8K77ViG+ETgG2EI+mtvVu8QhCyL1B8JSM3OebuuJSZTD6vmdTp7SFaIYHtTjiweLvRSG6UfNGj +UjtxNd4lPOGFhaB8gb3IwTxUKvTJHHHMpsA/ZaKL4aS55iizV59tZuvHs7kRlbqVVOFdWvi7yQZ8 +Vgd87DvezerxNL9KdkqhnXE4/8ldPRSbxP5uoTOZRInOxcGePBCMDhkZ1XL29ZhE1LYfeyvBnXoS +Lxx98Q289/GCCrXvwUn2/CV3Wsq/HwsEedJsl/LtwT1iniZrUM71uYNbBTY3qx485Cr1rQPdGHwB +MIrOeaHcC3RAV5f7kMPQxHvqdmQcrb5dC/yKzsrjzWYyGdljznQY2Tuajt7z3WmXg9wy9nhBhbeO +Ksqs9jqpnQHYyVdhSF6nkYPjh2Op048nwMdo8DZQ3S3PXtuDbO3tuJDoHoRKGMB7sMJl66ejj8xN +/ahRKgqXd77AfoQoPsnoGBejozOqtMOl7sCaz5PFVu97R+oAbZB+AzPmncdgFbDHg2D2qj/eVbe7 +bFQA+wsy/NXnbjx7cl8b+gIqFi69f83U+Z3zfPW7TmpExu5O4T0bfNHIgKtS6TW88YmmAXjusAO2 +FNvUvRVXH77vaSSN6utdIETLo2K03joAWLy8BRv7bjuSPuBo9DZbi2aG+W73sg2ntgGb1AsnJ5VY +ab/IhtFbOJeP3SFuXj/NBHL9YyIO1+pR2Z+8cNjdZTI3zQR/UTm9Ipsv11l6Z2O7SIW3X/JkOV/N +wF9pQOLkAdFppg7JaCh/KD9L+wLab3BL9Az+mYNMMY8+RH9ytSp1Cd8eoK/lDvLwWQ6Dyu7HSjwb +K1xRrw/jImyyD3gybA4fFOSucrDRmQIH9wL704LIyINPy1/soSZwNBdoSGgMYC4AThYPBU4TTxgO +CmKnDp/tIWBKLwiEHkVwyGadoj9FjEGINS0y0Td78C2axqGCStwYDg5jcfixdymjoIbwKfeyr5qL +snhp26V1vRC6ZfAFdAuBv4HIUmCjaSA8adFxgGal/IlAyT2XlTH4Atq1TJuRnO2S4CGjX/KscKfK +n5jGTAnDBVnAxlV5Vgqp6GkWz8USWQd4pmjnSOg4UOYMG5+bIVW3U30BGYUHumnKOElpQRxqR5NX +vkVvdZ2K66LsOxXFaFY1rVAtagwxkTXZKnvyCC9k5oGJFM+lhPCIwLpFtWoMtvSCUA5WH+JRhp02 +Y4BoavLW9EaGaEEwxvblDtAYrziBDJ+jXxj98kx57ib+Dhj4Fy3KvWR2mL16/zgBauXJWCcwsvWb +k2EpQ5I9X6AcKL8CnLAhTqWbzC8D+6XXWX03s0dcbESKN3cVSZTFtlXqhEor0FtJ6naAkqFhgNUX +IIIjKtOMTAKD5STHBYHqF360tKb4vYdqKUv3to+RHaCdUAQZCL6AMDom+GIs+s4UTg6/GXUvuddO +9mpYu87WZkeDYqSaCGnf9kuZZGAsGRVXYcX4wh0cPda/s+f53AXUYUTtaqBBDLBAoRamnalK2eD3 +WtdXWf7p+KpwPNl9MwOQZSvPR9mT20ugJ4sjuw70ytPzzkRU/apcDojtp7hsO8TtbQd7ywFqF5Lt +AIHx/PVz56TwfjmtJboXj0BtLn7nsb5NU5uP9saQpSnkC6iNIYVC4dSwhX2XPS8Vvm5f890vLrH3 +Pgh8AP12lwQ4Sb/x/FV7BAcXU/QjUY2t9Z8VUICSRWC/k2XB7cr+gHThIxY+xB1c0uk3oKidB/Of +kft8ops+SIlrpcWTxhbpAbKPlxRDGPAx9RpcVBD6Qaf0FnQeVDHNi8SpGoiVUbGTxnSubICLSh9Y +For+r9X+VQNN9joneTChdqT09ppOFsr3/Dswx4sUQZWZUz3Yy43wk85IwTRWlLp9uyy8X0fKgE+X +ClS4XcQ7EFmqUAYkMeN62d/pWe0rvvTyvLtVKg7nb1QgORDE1d+PbiceBb5VPc5dXmTAXO4HZ6KB +P78PZC/PajelQrgtvVCIfbRD8L1584KonjTHio2s9zlQDz2wLvnPp41UJF1+fZUo6zkOVjB+kuud +RoBqf/Gu7NkU9LS85HrUwYbyQnYEEKn2oE9AIXIGsf2geDuAxWfS96p7xprSmXrrjuOXkcObxrfU +QZ3P7J3cbwLz8XNDC/s8Wyu3v8C6HEyozPVGEq0BWoGD0JzqQJJ7Ry8AHzv8nM7RIicvAVMFvbw0 +AIj6tPg6JpuZvetgXOUko9j+5t77/OIrW79u3IMOUn2i9JShwWgqMZk76x0YvkCyXxq9W1EMKbes +S7tXDczl7qXVHkX7/UtQXHan0GQ6NcfdqxoI3L0fgJJL4Yv+XqnAPlCR9P3zrhGiCytfBbaq2r25 +6usnwidYlzR3PC/Er9qxTOrsqyeLqDq3WRrmRdcgIL7Y+HvULSTu9jISPoOdxGfn5Q3icyoOrlw4 +EDno7QELxTyVG5yngRTTKB5nTO58Tj8AVF9Ni5Fd7l0lsRS6g6TEbW99C5nU7Xd3773S/Mik7kpq +UJhjY9s92fQFkMTej95zFQRbJbvFlkQI2OmzFli/h71CZ3xeReoEt1VltuAzqnBSP91Uuudv+tU6 +EHSH28VXYvhceK8X3n2BYnR0Os+ymexjsXXRD+vUJdEz+RHoAYaa3OSnibObbL2agdswGTMOfj+U +mcSS8+zFVeI51X0R3sGK3+6CdVGpN1gcHSQAxVR3gYLydF163ftM6Dul0t8DsMgfG5nvw1ZHeQHX +ap4VmuOPOFm5iYrPwBIDfay+/R0rhUbJsO4V2aweUQoIWb7CIZ/Fcv0B8Q7opffApVPn95m9cZI0 +Tk1sB9cFtOSFy9GuZSPUJNVuN7+NTR5iBSL5ECzlO1wvWy80yFxf2BIIKvrdzaTOL/towVQcxkBF +6HzioHX3CDZN4TR7Vc98G2lja5rvHpxOM6lSoMEdcnfl/Fn+5lDWDjlRvvD73dZj4ah1dZFjbqmZ +YeFftjaA8CAuS6Hjw2qy8lSaiUqwuIhxQGgn3N7Jdva98LH1zPCpcTwP1KHurgIKaX0Q2HtnBInu +cT+8HXiF1L1fbCYexlrNG49MqO9s10qvWzs1ML/IU/Hla9ZCPkgjPsuzYjO3G/IFUqcR+jFbr+9s +aIjl8EgGWxW9VCJZVDETlv58siCQylYpn30GKmLm6A7wsUK0zso+QzzaZC9brGf55NVHknnLDcAk +c4RlEygIGtBUCseG0bqsngErrH5z2Mvsp8e3QFb2h8SOCYhOrhecHeeY+83rysETE3Q1U1HN00AJ +xZ9gL72jM2B+FEfqfcdlRlAaHkNfJ5guS28BE+EhqYBIkcLGWSl8fzHLntyTbVWnBw== + + + J2ftQnuQjKrPLMDIQoDLn/c+FP6LmfDo7ZNV7VT59AIz3MjZ6KvwnjzuF5q73UCy+jbZL2X7w03k +DtXRC1h9eJSXOssnngonJ/sJrKpRl7VYqUi+h0qp7NWmtKC3IcD56wnuoJRN57jAmC0cNfoBA//p +X4QBbp6vIC+NF06ONvOAW2o30H50fnFfyhCzV7Dmw2ZpYzdKAhP2Gn6TpMDOod/ANjwUVGDp3VAY +G5d8nX+Rzq4yAe3pm4iEvVLoaJBNfj6dbZUKF6e1UmDMAOZy2/nI0LkHRtmLohoEfikKFjrDy/K1 +rXwW/LeS2Y/Fw6a9wEY7ZegsfgKNirRxj231skwod10MTZvPkJGQemQR0+gDWgGwcWP3lr3Uqjkq +/F43BUEGj9vQZD7Jjj7Pd9WWk91ORWQvWXy2hC873x/RKQBcK6rQqJWfyoHyswDopTdXNZ5VS89g +9TPbSBVBZ5RQT+Yyp4X4+ee+imrTXHRU2g1HOaAGMQFgSmT66LBxr5Ns3YhHcNzxtXqmahfEIVXa +i24qBryBxtRie9x+L4VOykn1IiNavXzagi/62Vpz/I6tRYrb/MgNNoUvlaaUqYy/pV2pyBfUyy29 +3+D3Ls8vsrX5NWUUKOykcDToToHYyg3ACPtc6e00kLTWAM5T+1cAY6ft6pb5cks6hZAcJVrF5qgS +c2hX37l9LjbejjZzg8iOSkBLNKbSPg7P7sBKd1Xn9jpgqn1nmCkUKO+vYBEru99A5T46kyQyYp9f +k+BdaWc+7uSYeQ5YOsDSVtnkqMkgJAAOGi/2c19fF5nCUftyVjgOhUrwGPQInxtl+40BUo2Ks52j +Dann4znQxo3Ka9VMgxXV2MlWG9JdNHu5+wokZGtAqtnx8XxGHD2W93X7QZwLUFBa9dTZS3Neenuh +BpDGaPkw/UFNSgednIr9w32O8RAgeo9AONyFCu874y1udjI7KL324wlNL92X6AdYjekun3qJ1OB5 +UES/LnR4SAOFgGlkmWBwlCRvTxJZoTydwbABoNAdNe4y0/DdZuHk+Pm70Nl/2VQWDOn8bwwQ0e9j +wD6eElyqeb7j9mv4bRIYV5VK6XX2HCtlgp269jCOQxsFcxjJMLgAojkT+xRAf9Fy+UGoPxWb9ext +4YPd6eq4l8y4JJ4lS2nMp8QlKaK18AXQEWT+83H/u5S9yIxTp9P5SOsa5LhvMnlVaOUbvcJuN9Hi +9+lip/jwflSU3ZOoSQ3s+FoJyqZGVojFN6EvpIzYFsLYxQNff6skSoV5Fh1LXgKNIxgrlIbZUyA/ +6+Fcb28/JiooOogfgMHV5vW2EriBuaEI9HIzx4ZLCcDH2qnCh4pbiu/rWyKWRdxdZ69G1Tcu/R3u +qU1miONccL9ajD7ngL3PUQPFOYuQBWTvUxdgLP29e1xo3nWuwG5LV8r3r+M3xCPl7WOBeXlxRD/h +AWDgsdIWN7msHALV5xCw6JPvHBqS5B2lLkMzSE/73PVFOwF26nW0FCBDwG6+vIoWjjfeCfUMcOMx +yd18v2eRSCgFqnxKB1tuDGistPPwMSy8j54jyHVk6r8WWX1OgN7henkeH79kTx7CgrL6MAQgWGzN +N1+E8wpdT9LR473Sa/QmpZuLDKdeHOnEthbOW/7jsxSEp96CZsgygDFXzo6+pwkY3XFeeO7eb6lP +qxUGkDpu3Jwq89eY0ZdA/z0tBcuBUmUgm0XAQLrdjheOI1usuuf+bLvYakbbMIrgljoUnw42d+DC +v0J9bV/j6X7mM3svsXm2nudfgdXZBhZ2ItbIjrKdkjI4DIUOZfcye8/XOX54VCcLzx/PFLD3a/1M +QgIG+MVFG+y/7j6YsEYVLZZ2ytWxEo4U39hJ3nDccfeDq8fuH6jiRiyX+By2G9vJj9sJGGsFXtOV +I/Pdjccg2C+R3dZ3gdiODZF4ZzfyuySwCQabQN2/bpah5zRA0v9nWo6W04bCFdC14tqct6Q+63Hc +GHZ0SYHifVba6zDVV2Td6a9iAc8K9YIuIxLezPXxLgXzGaIH9+Squ9pKrDDoD1dohfl20jsfimFU +PzGN64uk2TcemMfNBJGInEYAp57R8BfF7F+maPnFpfwLvdijD+uzHLAsyr3K1tVBA9DLfVp+S0UO +rrjPjTBdOdiIJYJAhwHcp7e/ET57SG5EP7vg1dt7fCMyT9U2oqd3hY0YcUoRiYP7EOoerFr4kplS +01MwuEIPrORbms4JtACY7OABxdqgAyXlLVF57QDLYjJJHzSz0fHZceYkOU0Llf3beGn0wNwUJ08P +ROGhdF8vHWQPWuRulh+KvdDbl5F8bPcK9FflrKaLJxSnq8ltqPXpG1Wnk8netA46iR4RCaaGp6GM +bCqUZjfUy6i3Q7R3SNTzuQJ28kxM9wFsYR5Jlzd20MTRuhR68cRUKDPC994X+LPcB1/fF7SdPk2e +T58uzTst8y9s6uglbtrpy/YZkPu6bpVOue5JOWDe6f5GaDIlAxPzTi/IJ2aTSu0qnfoCSrfTYPQ0 +ZtEp+xlqBO+L5p0y4afIPvVhPtPN0gvjC2xdj/tVs7kSpdxJxqJTbmt7OAkfWHR6/0KU3s9qSqco +Dlbutryxv0Mev9ZNOy1XqLoleqmHdP0NdQposVnUruktoOSneboKuw0bVzV0Tz/2yTDolBkZSKlK +5MROL4JBXacsO3gdK50qlIy7fZ08fw7rFp1mGhxf2iZNO305fLuy6rQCtD46tPdkPtf9jefp1mfn +yrzTy3w4/b09qJp1Gtnrp9JKp2BdtKS0e/iQOTfvlLm/J0pJ4sy0083SB799NaDOzTr1BYjS83PJ +Yq7cVqA3PM1bddogytG3G/NOy0Q22Anx96hTX0CP4NlW9FDs9D4W0iH48Iw5ENFbfOqVNJ0+7BNV +PkbCTnd1nfoC081KZ8RdNWIU6JYf6+m3+vjQsOiU2+J77dKLVacF4nT3OYk6RTaydq5H36nM1+Ts +yrTT2l6Qtuz0pFOjCbNOIednHmNE7TW8aTbX6eZJpXP2+BAOmXZ6Exx+WHZa+7x8a6JOfQHjXB/L +xM3JeN+80yoduC5l9g/MOx0fb5p1Cngy7Pbmtbw5s0Dw4zlxe3hSMO/0NF18fbl8fjbt9Pm8d4Q6 +hfLFONeve7Zdsuj0SSCep/2YeadnX+PBeVKgdZ2CXlC3r0exoSWCJ4FaZMOi0/trotgdHJt2KpzF +NjcyzzHAx0C3qW/9ppm/8q9ip006rNs04YdqYxd1SgXToYp2plXibTeVhZ1GlU5BL7BbAPbrW2L6 +BxN9p9PRzoHY6ewwopvpxlPjMYw7zd2TR1pGGJ1Mr9MboBfQbdzIlY5iaK6g0/zMwAormxzu9JA8 +iekYYXTMnGFJQ2+n8ieoU9iL2O32ZNJoDmGnhK7TySTbGUn0e7yh63TKfqVESXOYuozr0Ls56rzV +faL+0Gm8ctpBVa53XkYpy7f3l+TgxurtJ1F5C8yVtwbOD1hvYcfia7AGO5G8NK6vDq97ywnka118 +O+0Jhl3JDT8378zeY6Z4cZR6snwrULtXb9ZvPxsvQRljxvdZauehZfm2GhkeUtZvm+fve8pbHca4 +rfPNVrNi8bVQ2ansX0/x2/fgd1L37XWkKymn7+RmyoCx6+ZxbWj2HnO5QqQ3sXx7G2gmNqzfPhVS +BxLGTN6/BV74bcu3X7OLccXybe+Gyl0qbw0YG/RK6Rerr8GQLvdYy7fHFJO+s8ZYoDVs1qpWX+9s +7Bw97Vq+LWZPmx3Lt8fU4SZpjbHsBrUdTlm8ZStE8WBXmnMqtKd7G6lfTg/Ft/n4vn5XVupv5d2s +8p6ZMtErrQWWJ9rBx7zIf94Cffh2LJqjpVcWs57caHqGf2n4GDXbhhZmfiN2nLwHFuZXHf4Th89K +G9HCVR7+c4vsN9l6wzxC7K9xlZM432STCh5cxER+DuwcjT6W3qKD4MPjAdob0NJR7YjEqTAMAjv2 +bg5Y6+YO6O99X+5vK9E9aIYBd9osTuZv8ZiG3U42fQGlW2TpWHTKbUE759G8U+b+wbJTIES+SJ0+ +pp4rsnQsO4Uir2XVaVvdKVMDNrKqW+EsV1N12t7Z2VI6Rdq/3CmtQy/U/uWZlvuaTsP3yHpVd6tB +8AFl2SnS/i06BfYg0P5flE7BXDRzfbbsFCB4ylh3CrV/y059Aaj/f5rPdX8jbtdpNWjZKdIplE7h +3td0C3WKumZVO0mpe/RLXIhw/qE9cNPuZT4Yqve+RUtu6/uleHfu2I79FOlO5BY5MOenrMgtDVv3 +LTSA2LlSOWjSpflEZC47tYxuxye6W6mo8k96HGrXRWMd8iRs76fH4f2xDDGEQKSTle0vNIp0svxY +AIyrUYQ90wprErtPFwPiP9HTkdgBUoGlDmTdEowHTO5gjBvpvE+A7eUSn51CQP7nSq0xiz6zc7lx +AfZSVk/37fhQ9CmBIV9fgAc7UKGd70rYwXq7yI5VM7jY0SJQ9riBARPHbCCA/oEEeau1kswG1Use +6QalHtLrPAhI9zRKBQ8JlR9N5w5EKAfc8nmeO3FCOvxHHDw25k3mF9ywnJ8voMwQ/WO5gtL61Tad +129Lnt+uSGNmM4TK67UNstyv3wjRJ7YsXCLLBhi5m/sqWYLyuSF3CVl7MU+UpdCVRiJjyio/fXvH +vCnegXLzIFLy0pincg/JY3u8+6yRpWU9YSPreSlqWQ9tyXp8TqRbfDqaqBEoD1mDwB3Mesxx9wLz +xSQEW4wnWozif0TckUNz3N3HNizZttWuRP4406ndb3qfmlqKocnRhzf1UydUl092xNME04EUIrpZ +qaWYaladi/iOuPoGNloEvdyMPE3IjMMA2gHm3J0Kt/I2VNP5W3gHDO6uYLFM0THZ2A5W0Biwn39B +xBDWUvpzFDmQKEdFycipYw6MdAvMDBTCu+qUZ9e47xolt/vOftcBWdnYvJvbruUWGb0mo/Cfx4jq +kMJAFoAzhoonZssJMKZeUPgPWFDFEW2kDTA/mQsaaeP8Uh6SalxoLrOy6cjS5ebUapIZojO7Thi0 +MOOSKBbfacS4JO2ykxbmlvX0hKkvYCmYXOiMSmOgzTzOLMWSL+BlfcsQJxXv2pPZ3m+XtXzaBFmn +I0Xw2gxpdnhsKSvPr8TxuFHpwJCsFTpp6XwBdysIrHxbxcJJ59es4DBgq1h4WL/yxUABhSl5CWC1 +oYtxgV3pCphWoHgdl3TCKwK7tzdivExSrdUtjbHXyQoxpuVoHsc11vph3viJwXCdpacLasea8xcw +noqZMWil0JoKaCp397nhwMdUCrb5rpwdbq5sV+buvre9Gcr4PNawkhV4ZFJVcAMtce/Yud/ccWt8 +yLqlHjvpqSyWHd0I5ophRccUTPeL8zKlp/Ymnm4gIiUbh+LABVwNRKdbLoYTh22vGgi2kSMWIuqj +Al3Xjx5scnwoqQ0ykmN7qOdpM65yaINfR5Dmix46sHBqAE1ww0aHMWUfFhvkyF7t8A== + + + BbwMamtBBqDllnDLPc8C9mLZLQM4UhiAW3vfen5BFyj3uUO6Rldw9mfoNXnF1/d1BA/1bldBVIUZ +WXyelhXOoImFMzV8LGxyQPuftFv6FE+s7JDlfotbmj3ISgLI8rjFNciStzj6gt5O9hLaDX4M56Ld +4qZWt7N3CVDtpjsPiZ0v4VjvktWPxs4lq/OQDI61GryFUezskgVTU20kcfU9u0mOYVzCqVv3hmwl +6YdyPNeK5QXcG4AOvik0IRSpYlgt92ulk6kWfh9fwM5LNziGh7v3S/l9IFqcfX06VmDhr4HY4VxR +sopvajwNY40qnZnrVWlAB9bORJEnu1CmIZZP9Kq0F9xhfQyNJ2A/Hrf+Bfrwmg/qKEJli3kShCc6 +TXix/ZK6DNtPzZnOTxThJ8uXBbzR4xO93LOakC9gQ+mAdrRCbxEGcHgdYH0Oa+4OMa8OTnqfTtRZ +6bIAOzpB5ySH1LosnotK1MHDqqA6fgPOCjxzQwyWu05FyXkwnrg3n7dxznc1M2mnPRV1fQQJgFn5 +W828rdiysPK3QmAeNp+5vQQ2jS+w9CEFWjV7kedzDUdrSHobjXgmjuEsuwMxFNmaVKBIPNkLHO9y +T7b3TYBpTgi9CVHt+WAQaRfRkFbjzKMw1ZWcMORR8Kkv4LwNXYgbCIyKez7js1AiYCznritUqtTP +1LdGiuk52rQXNnC0aU9/gOeCo5l6SPIAMZnvZTnatcLRJOvViwavB+bM0XwuT5AgsMU5mrwryzej +FXA0sGpmHM3z3gdwvHM0g+8Cw1meo0Eoy5+9Ijg2p0HRXEg+xUn4AmbagEYI3YzsLGj10aG5jsJE +r7TxlsDmMfjG4bNlD2Al+fIe/LZmQy41szzY5+czs82MPfDe2CwAdrPhicn6ApZsdsHoB+1mvkG2 +tMYSX0RBAaumC2qy4jDOcNyp9pZQkB8GwFk+BAJBsTCodSfvznC0h+4u3csmpwkI2Cp81VgWgvlF +oHahlYbgaWwZ/V5FpI3Nq+nSFt/drVtvlsp3YSkNbz3p9/Y+WAhsef3+6dtMFnqVYnDVvLu0jFIM +wllGv1dBkWXh4lIMwTHR782gyNarBRy30tBeFiIO8/S9tDTUyMJX/Tkx6gU8XUk4EuQ/pnFYoqzU +BE8pYRiWusDrxGZJ1KiMujh9u7tbxlet8/MDYMvubtW4TPa2fay1DcZcqbvSSsJerCwisJZxV/vc +5vQ0D/B5k7DxXLkIp9MNyZIiUGyP4/bSC6Z8PGYQS/l4wpVd6UIwUbm7tmV4nnXkmoW9D0ZGuUOl +i83VnK4u2hYAszy7kb09bgPqATB6e++kugoPCcAY703FsIhBhCv5Gnflg8XALDb7vW3wLaYIn+S/ +dzUolxRh2FyiRMZbV5FnafZ0aGpZiGuAsuWmHxux4eXrRvTmpbgRy9IvMG+uaJZBh29uWT6HTi3F +jBl0uoyhhXPo7DPoEE9eQQ6dZacog84yW9BjDp19Bp06W3CZHDr7DDqN1rdEDp19Bp0mW3CJHDr7 +DDqbbEFPOXT2GXQoW3AFOXT27cTc6qVz6AwbV5NBJ1sWS+bQ2WfQIX3MOYdOE5Bsk2F2ESyZadvW +MfDWmUC6YBcXQzL19BacA7d33eVLlXQ28sLBsAW99mviHHDr6X0saKW9t6VTnfEV9AEbC+Npb1dD +rtpcUVnGh9wkg3W+OjdOThTtGZ8dMPs4LHfzQ74+p8w51/PTea6M+8U90hPeh2SR+ejgubIbklnK +HJyLp6Q5V7ymqAsFUWJ7vCVQzTyFguD4MdNgEO9uYyunMboZbGl/1X1sy35qPpfJbtpISK+OQUTJ +YM2X9RjjZDerYxutleSU7GZtn9ofOKi4ZdE2GERjmjqZIUVdNoMmU9gdMG0IFmk8sWlS306Zj+54 +VqPkyehFu9LK7G3S1iGUnlJMUe7bqcusQ2fbHiDL7Cxb1seMrjMnx2FPGOvcJODba9Og2QVOrMqW +apdlFphKU9LngTmqXa7z+OZOMfAe8viaTvkvWxqnlXVqmnUSjL0qbYyBDx58blkNKmOWomm9fo4x +8K6jCNplrQfTdP3c5vEJE6ecGDti0EanQ2AryxCdKCcfVpkpXoA5U7x7jGkdrEtizDFN1P0kFY62 +EMa0jl8qd3cf0wY6VXSB9SaZXO50WYPP12hmyVv9ytxvaZ8vpwNhAaC3qZXIJiDeqBcS/vNmu7sr +Low92eJzMPY+Kq6NPSsA+hjFBUA4XY0C1lm+VcNdqtxCK/RKOMsXSaUx3xYwxc3ZyeCzdUnDrDQL +I85A9nY5cj6HNGcXR55oQvZXnvgM5pWNHpmaGkL5Q4WZC5SrTkasKPnryJt7x8RUwpqSQ4KcgetY +Z0TNTKX5AvrYkdsdr+x3S33s68ibe8c6zU4fQbQwnj4dPA0+nSlhTQIePTKaIWnykcGgKC/uD5sh +aTezsxSzwRPjdkj20enOSXF2Q9Lf3RHX+X9xStIqPDLHyCOzZJQa0IS3XXhkxDM+h/Sc7VR8ZxmP +jMreP17eIwMAhGyiOzykoS3ikTFkCy7vkYFpaDqPjFVGqlN+HuPJI2Pq5z92kZ7jLjkHpuiBDedM +ye7C92CpDkKrLJ8oyrJ13LgbZZk+vI5suSAG+5zE8clqIhnguqQug6tx6oCppUIOMb1u0tAWDGBX +yxeYQGbtXfKQPmYIXTDNFnTKq/McNGuMUEV5dS7j9Wzz6lSpozaZws5O0BPbS6pUu1elW9qG6l0Y +7yKFz1wKOinn3SowaTX5cLCXVcTU2efDeb9/bJF8OLMo6IvBqvPhlsiz8JAPZxehurp8OOi1XnIH +usiHM7kR1DKJa/F8OE00lPRNcNX5cPp7R3FG3Krz4RxvCVhJPpzmxMpFqOVi+XB6W8zqWAdmsi2f +WQ8F3MpiIgEobUyklW7pJibyZuQqJtJp70979LJqQB4FSCyfjY7gRJ1W3yUcN3kkllCwPobgrCCT +yxDJYBMD78zRYHKdtUPMGO+sqmVjEfEc/N41RDwHvx0WQrcJLb09dzfLbEMl+UjlVVh2GwJgttfK +mPExy214P3a7DW20cYhvb/aiKaGt5jZgBMfb9rHIRwZwVpIIWUi4k2KOcKyvBLa4TcsqzNp4JbDj +bWhar7TutsZw1OjDgsln9hc7ORrUckYqublogIhqzlYXCy+UkdrYfHWRROoyI7Wx2XTjMnBI9VtJ +RurT92oyUiGcVWSkwnyx5TNSIZRVZKRCOO6ugdaZxGZxfWiDWF+a6jnIKBwTV1+7De+W3oa6VDhz +PrbqVDgUz28b0bOKVDjTdVl5Ktzifkstxuxtdw925RKpcOo7iFAy3C9JhTPxKvyCVDhz/5hL++ze +TjFUswL1/cl2iU+flrGqbm6E1+pj+biDWeQ20AuCYl15FF04kCEw65vtPOowhkuGvR4uqLLR710e +4djdzgtYuZnIU3pxTm7W59U9WV6HoxcOknfURDwo+xdWjYua9SeuASpxmT7/LPdvGq+Frfa8WEpu +Z15K9fRFMZOYBQHnL9UP+XtUNrzwUJxkshWufpzPxVv5fC5xAosQ1MaSOAr0tUMWPU7aXCyzrDNo +JYk5So/WeWfCZepCTV7aZLe91vmp2vms6pT93A3sb4ysMuyY+zu7ZLd2wrJTolTP2WXYBc67pw2r +Tt9sOi3HkqpO9blYqchU5YXTJ7sxd59VuTKhLgVsM2SX7EbGdZ1q6/HtDawy7LitrW9u/mSV7PZo +l3U2sM+wG9Xrlp3uVDufbatOO/b1+C7vrDstnj2WLdG7PaT3Xq06vdRm2KFVBRtWnDX6JdJ5ymW7 +PbN22Kugack8VV1BZMIXuJ0oOquciSJ6JllJ6dK8rxeodr5jFyG3Wg02MsRz0ZwRXeyMVpPa4xyh +qveaWNex+nYxJNW5mM2gnIJTneI8sPW6ykpyZmVHTO5UceFdsqsk58kL91hwHSLpkA2J7oT0ENfn +VETONq7PPT05FJGznJ9Z3TenYiNu5+dca8A10p3qjOjuUluifpz7/VLuWBcisgx3dVuAzt7Tu0g2 +3WJ+GK/ZdGZ2gFSLc3XZdC7vh1kym87MJ6jfL8tn05nl0i2a+WidTWfmizePtF8mm06DFnHPmt4/ +tlQ2nRkohxtCFsimW1Aie8ymMzunkWXlyrLpzHLp1Pb+arLpzHLpXMb2eMimM/O1SxXYV5dNZ7a6 +yNO70mw6M+VGHTu6mmw6s1w6i9vml8imMw7pc8taU1o0m85MOfUFVp1NZ7Z+JtFQS2bT6UE51hRe +KJvOSrdcbTade4wtk02nA6U/E19RNt1CGPOcTWebY7WybDrz3OpVZ9OZAQC9rDibzuy0RBcDv4Js +OjP2oLVeV5FN53AysqJsOmf5sopsOjNkKNr4qrLpnDK5VpNNZ5ZLZ1mPb3kDMKYYgJr6Yp6ubrKu +4mUsUqmvzeEy8enbYbNrkM+MrGrZLF6vzjCkGTzlWXW9Omvtwh2eZpGgJzwpWNJEQsKcTEfFwiUJ +aBIULLKerQalG5JbVuCiupz2YGqhIUGMgUF5KrtsNyTzQApLDmODJ5uyyxYsE0oxrUV0SB5PdRYR +vZ0cOxQ2t/fMydWy7ArdLV3mTnXPlUuVfJEyd5bV5U5c5Sq5LHNnlcnlLpHOVYCEfXyyUuhuubUq +34/dVJmx9VK5KnPn6FGEiFm6zJ2ow9gXulu6zB3OfXModOfu8Gh8soJ7rujDa9J+Ed3nWZysLERp +fKKo3Avn8oCpHYTd0qflKQ8sUOcYe+hEnzCNDhrPth54V4l0biKafc4ZhtZBHK7zC0EvNmGHHoLI +IHYsXX9aSnZXYQv0vBXU5xPBS1Mt52x2N5TVeU/5YrBgYpcmGgoQlUM8uOtoKADKMX7MdTQUAOYu +ots+sBnxvpVkPi5/FAIrCtpcBy6uvks4rmq7mkFRRXbVVrEDERRDJrtpprBzLjsC5iqx1qoGhD6x +tjY0JtbWhqu7FRACW0khY0RjYLRumJladlmism6GSsd6r3Yx1LvGI12YiWeMoLa1xK1iqDvT3koy +U+Sbj71rEkZQ1fmqKhiCFxfWR8Su9/61p0LVVqdvsPDa0uoEhmIX1ekBzgpuCcBwlq1WjaFIm9Ds +hkNvsarXLhIZPJ3whiMm2/DGRSKDKw/80hXupPxKqxp3C2xDk+CKRetWe6twZ5f5uMQ2lAhNrHC3 +kkp5jvlE7irlLZtPJFfKW34b2lS40+YluckPWaTCnV29V1jjznuFO7e3msPsp+UTa5++FTXHynp1 +nVgLgDmrOT43ig6uTbdYYq0+85Fd1n8E8wtPTdOhvd1zheAswDcNd0RAOCvJ5zwl3NlijnCsc2F1 +SUw+p2smULk8L/ntZklM6lNRyCCihm2YCjkshAu/llT3zWUak5skpuDBi94SVUkxN2lM2kk6+E4V +UPK6WKYxpUKuMtRtzXZ5V6ZCbnalmySm4MFQr3wvalfeeUpisooggrUTbSStN8XwTg== + + + zOFd4lZ+nWJoclni3T2uAbGKHNd83PpWMWi/eK1I56ncI0KltT52v7qrqe7R6duKclzvLa+m8q7D +NKeeyj06VMpLLJjjqtqfchiGi6xn5xxXMCTXWc92Oa6iBwguRJU3709S/WDGW+WgXuiR+Vzi+Law +1Tmu+QKFw0itfjB6i3DgV/kCZfeV7p5KbSqY3ixgwYNcuyrfsfhLk4R3dnil7lSTD+cLTLdu7i/U +riptHbZU/vHeIh8ubJ2EN5m/pUgtT9al4RG7Vrl/3NY2fxV+tkrCe7LsFMxlszSmLedKlLceri07 +DR414x9WddjCSqdyJpeC4AuWUnWqTU2bBvkdpY4grctyDIcOH/tmnfoCEMH6mnOaNLyGPvdPjd6T +/QuLTrmtAHNWeFN8sPqMuFebTsvbnHWn5cutB7NOUd03oaJJrdR3emVXR/DkxrrTYvG6pInsAt1u +w/dR+ZeYhDnfPUhoV9+iHZ0nLNup8yuJt91U1gXESGo0KypiEsz5ntErnfJhjejt0QrPvI2fWBZ0 +LsMmAVLZMDoN0lQxcw6cdCGbAewDfWKTo4fEOiXJGFplOSRIydaDyrtJbXJObJquqjILcug6VGZx +60kq2IdWWS6doTIL6KDmJQTNLutOd/PkEllpDhGaGEs+d/SkO/TyOj/Zaw3z7jxXWbQYkiFKS79f +XCPdU5SWL2A3KGs/sbchAW5pHacljscQG6tjV8Wn9K728LporJmymCkBYB+5uPrawQf7UlzV5Y33 +sQ13Nxy6yEaydS+7PeV5KS5zE62Sk2i4Mm6hZDfzI2tP91q/FBf0LGtv0YRZgMteQmt2V5xlvpiT +1WK8K87GADL3j2mDRkyOWBslT/UOrDlMaWU2cqOk5zCLnnrjhDurfYxOrJzL12lGpvfzO7vsUD0+ +S68K820IIOgJE+/6iEXtp+DBnfXhoLdEMkM9iyXKstlnMnnKsUp6uudANSRd/ku7bOc7dtTGNUNS +heqLp9WqXesxFbC37SKVU33PlU0qoFNJY4f1U07e22XnRB3XxKCra2xaZcYDMKcqOkF9dq0NMJ1U +WQ5jjrk87iepPblcEmOO9XQ8YazKPFkAM6QLm2mHIsYWzAJ0mwPo+h4SqwQxVzmANtHpLrIA3eYA +Gv3JXrIA3eYAqm849J4F6DYHEHmtF84C1JCKjYWpj4P1lgXoNgcQYmzxLEAFn/Z8Q5tj5TUL0G0O +oGwjL5QFaDEkQw6g+rwSj8c4q+WL8rmvyLZMUT7VXH5hUT6DV+GXFOVzqsi2mqJ8OGfEXkFZviif +L2CiFa68KJ+xPvKvKMpnXR95lUX5XNWvXKYon9qrAAfFWQ5KRJFTarB1Vb/l74Y6XsXdUC7r+rm6 +G2rpun6qqa3gbiirun7e4pQWretnX9VvobuhTOr62XuFzC1x73X9zInP9m6oBer6OVPyKur62UeG +yJ6rJev6OWVyrciha1vVzxfw5NC1rOtnPzWd72Lhun6agRiq+i1QAcS0rp/9hMwiVBep62eajmh3 +q7l7xLjOlDW9C3qBun72N3/JZ+JL1vWzFXR5JMVWUNfP3i3s6QYqm7p+9qauaRT0AnX9zNIkla23 +XD2+FeS8e6rrZw8F+vlXUdfP/kDF5xrOMonv+ozURev6maiaqqp+6uoMxBJ1/XTbkNBW9dPc2eU5 +PYWQ6/o55r2upK6ffVU/mZKXrOtnH3Ctykhdqq6fkr9lRou6e64Wrutnj0Ckwa6grp/NXpv26BXV +49u1h+K6Hp9DOTnX9fiWqusnQzHdPl6zOQx1/WzyHhyjbTte6/rZa/LwxoNV1PWzkuE3xpPExfK3 +XKjz0kmi0zZ0qutnf96sjSJYvK6fFtt6a3HRenzegjSs6/GtYPvIVf2Wr8fnJonJ6fYGY6yGt1J8 ++ozU5er6aRzbhqp+OGNo+bp+cqqUXV3Rpev62as5FjTmua6ffVW/pW9tEuv6Lenrc1nXz0Xe6wrq ++tlX9fNcj2+hLFwdtzTW9Vs8GV5V1U/Vy1J1/YyuZHVVP6tbzrzW9bMP79JJsYXr+tkHOul8SgvX +9TNZF1VVP/t74dzX9Vvcb6nFmPecJwu7com6fgrjMqvqt3D0oK6uny1FqCqALFfXz14xxNbr8nX9 +7BNiRYm8dF0/7ST1Vf0M+pjrm6y0df2slSCswzjcZOWyrp8rHWbpun7qlTQe4Nhk11rsT/O6fvbC +wTaLc2UJsVjuJ0zEw4OdjnZ+bR7xob9X6hPfqKiTleCptWvXPvBel7aooSaJxpTTm/TBWJ0Hj31T +YlchjYSMjxTEEInzDifj80xjiVanMPeNmn5uALFyvBF5PNsmEnc9HjeC+VQb26fpozgRGm4kWo9j +hp58HpfS/efk5fVuKDYIB3PfOaLycZbd+p7nuI2nRpsGv94yAVbYq+ycnn9fsd+9+0dfgGfjTEs4 +Ld3FT+KTDbZaZt5yV73rw3btlLv9rHfO2O+bUOd9+zYbZgpfm/Wrk16qv3836hyGht+v/Hdgkhly +Zxu3Z4fBbTpU5gLvj0dH4fnn1iMzeuqkxL2PcjvT1/XazUY88pLZoD6+byL7dDBDlHInOaL03jom +ytzO1WTylgxNpsLt0XTrhWtO2ebjhZxpWY8cJGK3cbqa3JTS3r4Sk+nTCBabS27h3GojD9Hkl+49 +VF+T2dblGBrUcglIWE9y/kYGdrOZ6rEZshAywHRnO3Bd6O0Ny7mijMZQI9i52Lp5qKe3h5NEaYdi +PuZb/fZGG2aSHkvJoRvz6Jg5g/Fqp0OUk7iRLdXrAWK700b2/sVIq7KPddsHTO0ir0qaU/ytqqkB +tmaGhzQXyM99gcJDqXOHCmjmn8tXd9xZvr2ZScz2jzOJaXuvlNzqXRRvM/QLQNswXe7f3D1lK9xG +E8C5+ZbA4vKZITLS42Eq4/1LZq+6MUGzyg5GkJKzJ7e3r5HizV0F/gITvujHYdJuFJv1afZ+giwn +IjELwWiE1xnmxAk2HpR+kSHkOwYY4YfgT34XZf0ChnM0Bn8eRBGH2QoCKfY4AQ/ycenDUqJUpE4F +ALZCRArRwLwUqhwdkdHg56DY6n0niUSaD6OBwsE9k7t5ci/fbSRI8OIgonrR2M4f+ALSq3xMeUXl +Hq4PpRdHCeUFvb33kZVenJPyixcRbeWDXeWZ0jOU++V8VPUK9i3CKYNdDzCxC2b6FIFzDlPP0y/A +AMtXJLoJh6wcXtFgupe7quk2PyIQs5cA5QejHtna5lPyuRhghZC8cmQrdkDCRgmYtzQgW4dHEG2X +pPjN5TUCC5Na97dgzxGYW4zE0jYVjjFQ+6/HlE6p8GFmD/eyBw+8r3L9+Mdu9qL1Xi2cHG3UFJKU +jwXyWsM1oDU4c1S4Uto3gwcoeVGIl9UDGWKOnV1sd8rPD8JHtjbf7hYf2hcEnBWJqBdT8hv1PH/J +iKtx/0JL5FVnVFMvHPItaR/cxhACqcJlHkrA24RE9rcAdvMZ1ma7JUV1l70VtYsR/E3LvxgMorg3 +4MCfDyLE11YJLslDQvr6gZB/karRvFEvXWk0DzR64QuIrwq9bXEf9L5YPBetpNWeme5o2IzMBSzY +DJCVkNHo2Ezq+XwUKt7mTo9z4f4E5vRzlVyRiNeNbEZfpTeIqA1wAQHd6BqWz8UAtxR3/F0vgkky +d/cyBbPajCe6mxc79HZyMCOIUHwqThcwFxQ3jdyT4E8mjLKCyeJTBv6ZAhtp+ysN+UZUtfpP4Jsb +SBOVOFKDYKRKHBnuZPklDg3zSsLCBVMhZILcUblT0uxJCIaKfpNRYvjmC0gLdbKL9100H2jKz8T9 +C3Q4uJ1PwMLzN5X8Wy/b1jChKkGwzRO4ECcqOiDLuW+ocXycI4ydgQ7uR4gTw6k/ZUW1BLAe/Awz +V8hwsKSxlUOKc9Y00l5axpD2DL46hWpOBghwYY71mh12VFIpd+jZZj67CT67msHGN5q7DyRNKawG +Ee0WdSAi+e3DoiygK1QoeU8rKht6trmZPiwT7cCwMJkcjHbVKgTQD9C9CqWAAoLobLIJHYi7u4us +DKIb0myVch8iNYTXr/i0F6N39h5JgONCFFKOZFeip5DG4vjp8/QVbvGnqcRmXmcazG8FxTLH1Mel +rCk9K0oSKjANVc1N+OIe4U6lJwcVpWU3c7vbkHSTA0pSS/D9DED8bTJlfbFlWAhXWpf5Bux0A68A +M33cgVKs9Loh3ZGR3BLH078+Uyvv99GhiLFcGDo98KUQlef45tc1wFOkBDqNx9AGN94WAb1wYGTl +iIiEwrQmI+FJjYT547mMBN2NHREVCh4ndFN1d4eMAl8gnH9ov0hIAONRI4GfWCJBQsHutgoFh/nv +kQoFh6HCBKEAULLYrVT/Gy2JMxIAE+olcKc0f94TUUDNSTM6wLdq3GuRkFAI+25jlChiJExy948K +EkLN7asnCzoQr6OVq5YDPmZGSrYgIt5pURs5LJ0DKKPwPIaYGQC0Lq5BxBfcUkp8cphYcjWi1jSN +OL80ChuajkYtQLjCA+L80biLadCZy1BIBNE4PNeOgbQfA7YrbflTlJJAcFvKakw3yyd5TbvErtIO +lkq/sKjzDhYntCyNhZenscSCY1DRGLksjYWXp7FdSxAuAGAai7kgUw0I/TQcUCnSmC0miCUpIhHx +BVxgwhaEG87nC9iCsEKlq9WAAOJqb89CRJVwTdhI7puCIJadhmpn+AKLTYPyNAa09/WjoJ33Z4U5 +OM1H8BgmaVZz6dcbpZcBikR2iwkq6n0MOm5JLUtUVNyMIjxxS8qNcmMmhxRuSS27xSlS+yel42MU +LRoLoXYdGKSZKfbIIKtM0fTT5dsQtiIUm674ktoXzb7zzlC0be96Meq10o4SicZ3DFnD8I6I6WcM +fh1HNgh9eL2JbL+gdJy4FURBP8gUxt412RTGvrXgwdU3+DMTw38+TzvIUAzS2/v7b6XX8COq//KS ++ZDN1ZDs9Xsm2qFQSrJPU7sqx5pqBulMVOVWCx5W09KLUlx5ge67kF0wwNhVedwOb8Y5yVOWQtMI +q3suZyIqt5qq53JJcei9oJrQyAtXTYhehfI5Ad0DEZyZAoxnCltyzZdAQ5ruZQQ7zppjEpL9ZUxW +r7epYDoEkxov46JvjctDyrkkcHW5CdmqnKMHItjWwyMp+kTvS5HEaa0H+UEdm/9UmEu1pU7rcdwL +Ed4WCKpfCxSjyfD/39u196XRK+FPsN9hqVW5uWSzd29VQYUWLxVRUCuCbNVqQRFO3/5zPvuZSbLZ +sFLLK+2pv0oy7E6SJzOTZGZ2vdxYISfv44M3k7Ho6M29Ty/ytOTp/bgwBcdJ/LRfciQKR7Mw97ya +q68M3PW6vb/pfemmhSvurJYS8ts8p3I2rmLxoplR9z72kJzmVY9beQ1NxakhnG1nFZO7gUrXB44o +PdSpKI3OL1kYkG5n2i1RojcOMnAYA5Cx1tkGcjwz8L0ofdp6qBJ+d2t0JHhfZRq30g== + + + sUZVj9tK95v8wpZa0JFjOWOhJeUkvsB9BFza1ppp7ujavthkGp+N/Hq1R3EJKHZOeM7tdOw5l87u +ReZTwqxjvrsoZ5jkYToLrgzlnHT+gGJvpL4wgDE+mmev7wMNW60U7hpDg7uq7vLLOWadrPcr2x8n +PbWjzYPy7X/iUit/4Vd1cUZOONqZJz/hY2cep/UiszBpsDCd+62Hd70dM3/phQxPNpZPJPZ7JTQe +hXOPYQvGzOfTZO7W0z7ze6HiChfa7o2NiO0bInwHkvrfdc03PUf3KfH0wtHoIRwcDO5u7np6XlvR +CpsV06z3uv2dQRgeh/8MS/3r0fewN9SX9cJmrVip+E4pvO53Q53loDhXnuJj4K41kV6jRiLH8m64 +F7r0Ndi9L88drbVLX0lzXcnKYUf8xcfjp1T+9hvsTlK5a2M+lW91z1N5ulNLpcvPeaw2uRtCjuxl +POwKhMTNzpXCwdZoO7dXPU040NlqGVwd765p89unW+HRRuH5ZrVQ3jz7VDrbOaltFIakzzwVSecg +H6kMVk6IbQ4GdLiQyqzu26mlwuIJxjhLMJb3Jb+Qymc2NpD6MZX7/G4fx7ePX3xILW1a3VR+r1FO +ZZ/mBij/vvAg7YwwUY7mhGs4jt/stFqRDh72mWJoXIXM/M0NenZPnoSNRScx3i2dxAVWxUy0tCh9 +C7NCi0B6VC1i1eU0amN5SdgOfLGHYPG1vjyMPM4VZaUi5fYwiJaw6SNQcfxJm/97Eag4/sS93tNH +oLAKW4sUVA83Yt4t4WU/3GFbhiwYtnCLCRpG4X2WTVX1Qf8PYGoPDwq41uahgaf3UK0ztlk+OYXD +c0uuhzklFtVdMGBBalbjdfwqaoUJ+xkgViq0VxeWb3qL9Z3Vbftbwg2K+Qif1eSqKMNK5gIE0MNe +MeY4iR9/tmFqjtF7jBnHzEf/c+Dv7mwshselSnctJbSp2TBlmImOxW8yD625aNFs23LobVW8OgfM +nuaFye3UC0LsOw1idqqVDJRgu8HXlc4lXQ8qFOaq08ZcB1Hu2oyFmNr7I8ZxiSVAQbURbZPuz0lU +uoylraNu5e67lvLFZcpqwVjY6n619zTPxjKej1FUc6hAalUzI63A780MWkswNGhNVkVaxfr9B25r +8k+PB5PNjLRjTM+7C4UF4cbny/FeTwz3IMxG++zFtVpWhLfBNLFtN4ozEdvu0+02X2vBuOAKVE7z +hTl8vsfzVjkrTIr5rkBLS+c5Ft6Wy/qSeAaYxbgxRaYh9l+7nzLiGTRnpzA5TRDsTySQmGcaJZuC +ZbDTGAozEnt0HlNPJzbofGnmZwGwNTLQZKjR9cciKX1c7ZOXVgfWFxFmWsuyCBuPReXYvPFTz+4l +83XvL4mV+nG5MHVMkvN+8WSHfPcHn8ZYnjD1Y7BW+BYfEScFdvBt0Z+jwM4gl4gNDQarH2qq74NU +LvLGOIvb9Xoruy2DWPVEEAtpc2oI64x+TISwyPbqAWfAI16fX7IYjbEoL5RVVbFri9F6jXHT/D7F +14qiPJVzWDIkrcBo7N2F6yC1+doT7i8H3MzA4niW2LS+/Vic/s5yHBETEbVKiUjOyvcjGT5qvhI+ +Qs35ffhIRIgnxU74u1WnjJ1MiJwoPkxt/k0uDvZSQw7BpQoBi+gJCM5iCGAs2B8VBNzo/waE9up+ +DIF1/mD6MQS4zzYSYcT43evTgDCNp/91fzT7o8ivx9BeDSPiH4qLULxICNKUkUj8u1QzyGL01MGv +ejFdH1qD1xnweXmVRed5NpXavR1JrXzjbBxePE4h02AtFRYJmT5s/UItpoXyMHyOreWbArPrh/3U +7/vQjLIPJ/diEGUu2M3vMQtS3mtej4XBL6T8NpWJJztfykcJGWOvMZhFxmq9mWUsHM7Yh4fUzDJ2 +0ptZxpr9f2V6XzLoDKSMvSIiZ68N43ZqKH8pY/ej2Waj2VLUlSM2CYlXWXT+neXDVSzJIhzMNhvN +2+eESAnEpheq5v0bBHvsfUzrzd5oxmEMUpM0A84v0w9j9O6NfZD75LO5ud/pJ32+iFmkFk9ua2of +Op1frwHKivwaEp3waZY+oLXs3M4oVJ3751mtZac3/K2pe3Ud6jyNlH3ym1S8M0qp1eu5d2PVhTl2 +VOCeYkxH/JBD74Sb8JCQcLjhsw1mfKZTjn3t998v+FF+ca3pRFmYLXZkXIqyXi+e+blSJq2iq1qU +0tybB0fh7PhRmJ2M86JaNNi52ZC3FaSD/SJ2ByNicLBVPG5/LgIVx59YK38pAhXHn7TxCBS6wXbr +lHnFVEfPYTHHHGfC0XNYWYoOqaOsOAUeVg3uW8N3nUP1iODu34RfXZyXwmGDs7U+HPcMkdr93shE +sagKm8uc6ilsHhisFWvLt/yV8DLztXjr7hxsPfhzvuK65m5aOHiL58xfhBDi03vzqPCvOE7ip41z +rJOYo1tfWy5u1hdWroq33qfHzePN3il3xW2dZy9FoOm6ITOmj6342QV1djvVvOKDbQsHZOeIP9uA +T7hneKn97oQ74GLXEN06s8oYG2myQAsriYnt3Djct8Y9tPd1g+c4mjLreUmGhZZUv+x9myqONcUj +fH9jR/6jM0eMpUHm2NEsdqvxpw0nJljn/lx6NfMqTE6w/oPp1dr8LxOs/2B6NY9FTUywzr0lvfr5 +v+vaCohUxTRb272uGmPS5ueBUguHo0e8wGlthTd3vWr7ZzjQTJ3/EPiBT5cXLPx0sFjtaOnPo3AU +trr9H72Hfrvbegi/DjN6tafNtwqbg2Hp7np41++1Bz/1ZSCZemGr33/Q05uV2s6pvv3PY38w1Flj ++nFfL9ZqGQxxvXrdyd3zXechHLu+0Nir1islfVkX/fnH2Yn7hBXerxXkaJIW9Awu5/cCLi2N6Jvw +v/FDG8HHgUYMAv8sGPmvC/yn0dYIQ4jC/8ZPqHyEwjcg/dBtfU8//0L0LrI+0kzH8FzP1W3D8jAO ++F1SLMP2HcvRoW66fqBTIPsO1G3DpoEn60XNNBwPG48oVeiqb1GVRAxq0cCUTKM6NmuSAJhEFJMY +jhtYjImgmIbt2DhIwdSkhunBTVG7UR16IvoWUapa1Ht5jxhdxFTWRbPFF4hUta+T5cbTC5XeUE/X +TnZbtdv2Y3j88zFUpi87QhxcQjwcr28HbhBAwfMDx/aFABOcqxg/2w+oC3MAVxHqWp4kEUDOwtFD +ScFMlqs44TFyODyXBLYuGcH4bYdQFTNWj2cvolRVFCOKYwAhiLm4sgVzDDtX6YXJMbSIwyvRCCJm +0dhigeL1eBojSvUFRJMoX8E0lAA623V8KvvxXVIUrIDietCAZbg2WhAjcILARfEktuc7EqWoHqMU +UWKUFIoDxZiHYzgw4KgNVnWohIQJ2hilKikKhoIJoG0R4uu8CaiNIRfVFQUQlBinmCJHG5EkHFEr +SQyLL1BFtLP1t+lFXRgnEhkn+Ohqrp7O6I1TZutKM9o7qdSG75u+rRg1GHvAxVbYBTAyno8AC+Ci +ejzjEUWxahEpslCSqzRZ0DDxXcWs+Qbx4KOqEALX8r3YqgWG6xPXlbIX1eNJjSixVZP3iOFFTOM6 +a7X4ApH/n1Ejqjlj38JdJkobUWGSZbReMVgwQtMMTMWQBVx6FZh4PZ6wiFJVgJMUYXskF1e2YKpw +uXEfTI4a9UVF9j/iRWLhUSaLKLqXLI9bKtFSbKgUKKRmGqZjIoCR7oIeOp5renospoKgSq4gxUio +JGZKYj6RpREtSVskxh7bKwUNQYmxEkx8wzeJ4whzFRg2oZatx9PB66pkc0pVmcSIIocckSQoUSsJ +IItJZP+msYq2ZhT6xIRDWijPpzYZo/iAFTMSgJ/lwFIO1tbEkSXtl2u4FFcEgAf0OQDRcA1YQ0DT +TAv0GDYlgLNDPUv3DNOyPU9vAnAeMWEePYO6zEZ4hmX7Liy3hh1YplAHYgEeLkiwgyIQANg2pUAI +Ao9wimlSCxsmduAD5MQzaYB1EMlAP4ELCJMSsCdQB04gCXC9C/YItuDJjhdnMTNMRaYzNYQGiIUT +UA+3sKCYHiPYtktxwXcMrrI+8oPtJ3TXgisBzcCkCIhFPZOLK0g/dDtJqTKK0BNJsW2PcmNrwWA9 +aUjgCptC3fU9xiIIAlzwE4Sq5kO3YDSM4jko4ZRvsR3D9UBAArEFRfgDG1kkKThjNvHZ+gUzgCw8 +x/NxeYGuOah7wNBmYhGYbL+XpDC58DheJuU7XpAdyubdII7vsH30OMYTCNyowZ2ezfaZSMbtF4DM +zKQLOwfP8lmXoeUAKR5xCR8E9WwbJyKArRNl0PimbTNJArtv43g80DE2cNelIIlJSpVRkAtKnwU7 +MB/wdh0mrASWSajbbuCxDSg0j1gkKciDgn6x/YFlwqcH1scP2MbLQsDjObT4jCQIiB21qclOGpbH +Rhl4tstOGhTkEet80m0ufChs45TqCwNQHb+GzRqgZ3pciD3bM8Ek+A5xuBha1FfrBOe7qCUpqBdg +iajN9Bg/qxoVm2Roz6ZstpIzOonyt+xrPUmobnF/wHavyw7eS0va/Pxh+yY8HrTvHsKBdvPc/k+o +t3u9/rA9DB/hG/1mED4P+4NQf77t/0AK3BJdPj+/fbCj/Q8dSJx2 + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/originals/SVG_Left_overlays/Red_left.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/originals/SVG_Left_overlays/Red_left.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,1574 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + eJzsvWmTHbmRIPgL4j/kfpCZZLvMjsAZ0I6t2buyRzvUYSqpW21tY2VUFVXiDJOsZbHUq/316zcc +8V6SSfL1pckMMpn0xPNwOACHX3D85H/7zVfPdt++/ePLZ/F2vpl+8pPDu5cv3r999/Mbgt784vXr +H394/w5BP/3tz26WdDtDo90v1q+l4T+8fPfDq7dvfk6/ol/e4ad/+tWLP758+ebFze6H1y/uf3bz +05/Bb3736v3rl/C737789uvXL//0/vaHv3z3M30nIDm+eA+/Xpa/m8PfhXmZb+b285yxwYs3f3nx +ww+v/j/8dYlrBNj+7Y9vvn315rv92//35zfQFH4Bf+AX//XVb1/+cP7bfNtay9zk+PabH+9fvnn/ +m3dvv3n5ww+Ht6/fvvvh5zeHv754c/PLF9/Bb17c/NPL16/f/svN/vWLb/7nBD3OX9+9ev0SOnf/ +4v3NQl3d/WIJX+9/fPX621/9eP/Hl9DtWCqC49eE8vc/AC5Aiz8juH79i3uAfPXy/XsgDV6I7Dr8 +8p/+2wF4/Pae2hG1t8vNAv/+9De7X/3u1786wevazQE59b/Tb+F/823KQ4uwZN8kFMSA/7gmQ4sI +n79tA45YucFv/37vOcMMhIb//NuX372i2QCD9d9/Jj199/b7+xfv/ucP3CwG+MO/+d3L++9fw5DS +GCzlNuMg5P6TtAKuUotnca03z0KJ8OvYyk1o1qaP18u/vHr5Lz+/+dXbNy95UHbv3n/F8yKleebv +/Jvf/vj65bvfv3n1HigrCGo8Kr98++3L19DePn/3+sV3P2gnl/6dG/zuxbvvXr6HKfX29Y/vaaav ++gYY9ecv/voSp87CL/j19y/f/O7tPxCNz+pyGyOwOTf+F4YklvWmRBjdlV6RZujlfDO7d9PIM3pE +hqj0HTC1fvIbmD+/fvfqu1dvfi4U1q///t2rb/ucquFm5W/UidvV/W36l6mFjr9///KNUA9z+fBL +Nzfn219+BW88vfn28PYeuf8DrjqYAW9gcrx++x3/zn6m38DHf/yeqaf/fw0D9Zt3r94gzulX9Jv1 +69+8/hF+9ffv3v74/S/e/Ont9FMWNb979+IbaHbz6z/+j5ffvAeRIYD+01c/vnr/8vbFq+9/9kFE +v3n94s2LdzcEhw8z8Pmrv8BvXgApN/wx+E2HfRzp8eWfYOn3zzL09OYvL1+//f5lhxvkxZtvb/7x +xbvvP44ahuGdw0D/1X8f0dsX7/8MUurlm29/MLL4v2NHGfZxfF99g5Pi3c3+3Y8//Pnmd2/fvja0 +468Mu4AJiu3/Y7zjN/SBN79+www6f5M02L4JBMJ/uLdA64ffAL/8j4z98OL161ffvXvx/Z9ffXPp +BRd+b2/i333KxPrr/R/fvn71w32fTw7ymxfv3r/65vXLr/76w/uX9x/Chtz406s338JEJKHTqX17 +/z2qFjdf/fnF9y8J5/s/31HLrwxh/hoEoxd9z559QCaGeLN/437/9+9efPsKxC0oSvvXP768+S38 +98XrGwX/bLoMBnEPiL6d/nn6L9OMX8sc5zTnucKzzm3ezfv5OJ/mu2UBbSEuaclLWerSlt2yXw7L +cTmFOSwhhBRKqPCsoYVd2IfDFI7hFO7iHJcYcC+LJVZQw1rcxX08wHOMp3iX5rSkCE+Gp6SaWtql +fTqkYzqluwy05CWHHHOacs4FnprX3PIu7/Mhn/JdmctSQAMo8Gn4dZn+L+1M/1rs73Lxf6g4Bvse +5S+QRuyIc56IK/hXvxf5m+SnAhwrwDP9vhL/8G9zP+3g7x6+7yb650DsPcBfZDJ/B2YDu5E4+ILO +gOoGX3HpP/yX6e7u7nR3vDvc7e92dw2e9a7elbt8l+7iXbhb7ubT3el0Op4Op/1pd2qn9VRP5ZRP +6RRP4bTAu+Djx9PxeDwc98fddGzH9ViP5ZiP6RiP4bgAWXeH0+F4OBz2h92hHdZDPZRDPiQYunBY +gPS7/Wl/3B/2+/1u3/brvu7LPu/TPu7DtF+gf3e70+64O+z2u92u7dZd3ZVd3qVd3IXdAqy4o7G6 +u6PuYIeO1CnsFnZsZ53D7lXqInYSu5moq9hZ7C50GB9EcjpN1HPs+4H6jxxAHjTiA3ICeYHcyMQR +5AlyBfmCz2zcQf7A1wRMQjYBo+BpxKuV+IUcQ54h11LvzPnX6ZHPcftM5yDh0WOe/fkzXQDuzh/o +TLr5ydf7d9Cngl+VnhWeJg8MZtnTA/MC+IBMvaskOiqICBAGkZ5UYcnCh/lrrW2qDZ5d3VeYUshE +GJG7lVbMusADMmQFQbGmFVb6Su9c64pfbYVZtMJUWw80BCecGm2eYGmBSGqhxZYaCAcgrzZoDdbb +jh6Ynw3mMI4dTQSYVbAIQYjBTAwwHyPMygRzEzsFlNFQ4vqjdRjoWUgE8pNAFEYQhZl+wu8JxGKm +p9CDHCjYGRKWDf7dTfTDHl8K3/fy/UAPrDf4fkJpirM5kByid8WAXyBBQcLiA7IQpCwIvLBOJGwb +CdxdgEUJEvcI30/wnRYGyF6UvgtIX8SAYhYEKYwJmsOVpPEKfW8gj0kiPyBtkFu8fIh/yEfkJ/K1 +EZdxPAvxPcEIRKAIuzrj4MAQHWGwDjBkO2wKg1gnGtEM4xtprBeQl3e4KmEmHGBW4Ag0mCgVJk2G +6ZOA1AAMnWH54yQ7wnTbw0g1QFNhauYJ5H6CHSAA52eQDydYkQfYH3ZA0oqTD3aNDPtLBOYtILLv +YNEfYYvZw6C3tMIbCmw+CfgTYCTnyHIJ1zQ90Z4gD43XceZHFpvImwMJiwN/7enZ0dMmZNyBmHGg +mY/LBgRqJqGaSLCiaA0kXvGZScjekaBFUXskcYsCF792E8ndRrIXpW/l1QgyGKVwIkkMshgemmn7 +mUQyCmUUy0cSzSicUTyjgG4swS5IgwtPe+wzDf9dP+mpl57pIrg88snnT5d1/2zT/uYDP/AT4G+5 +yfNtbbGC1QwIwPT9+vMR7H+At6cZxGfApiW1Gi9iKQEmMprkKyxtatPWGVadYqy3sS3xJubblnOn +6/qoiWJYWstS0G8EKtiaLqINqc4Z0RZQEhM5kUBfgsaCdrlFdesGVLFO7pXxAq37oynaqgFfVqHv +Xnz78ub925t//DOq8dPm/zBUgZVmpCSDCKIfYgUV9Vx8AkktLLmOPyCV46RDPDeK52Jn+ePjD4jH +JtLIv+uhpGH+QnQzoKv55nr0GcJPGdi/f/fy5RtvFW0AhFXsIROiyYTovBGhKj5NgDodN5FWEUjH +mEnXlQ304LbOvm3CxknSF7Zo3Kxn2L5xG9/Dxt5gv8+kByygG6CesIPtFdWNCPrJHexAaEqgJRLm +s6+tJXTegGR+l6BZFGywzO6CqNcBLZJByUbr4mR69n6wMkCznkSlXgZT40hbI31nI62JvZTFrkJT +K4ohps8nfD2ur2Q9ov3IFuQBdAU0BO7EkmRb0qxJ0XxX0Xg32i7qu5NTdhMpu4WU3RVVXdRz6a1O +O2XdtJFWeiB9lHXRQFpoJg10hRmyg3l1gHl2B7NugfkXYSZmIKDCZt9w79+DKnAE3t+BorCA0hBB +hchAXQUFg/dyUwAXUgDRDMevZKogdZXVdFIG0TxvZKLvyEwXxZCMdXgmHNZIhlei8Uqk+rJmiji9 +2eA6spNlggvmSIvnjro1S9cCvYkXW+a5sZKlfCTPQyS1eiWN+QjTMZAeXMXToG4G7B0bYTQt+Qum +Kk9bmsCLTGdSjsmGpHGnBzWLC66D/sXzkR0EkXqfzfIHaunDpJOyVlrQV0FqKSumC7Yk5ZTVU1RQ +WUUFJZU+/EFbuYuOLjgS69o81DvS5PFZRbuvMrw40Dzk/IUTgScF9MOPmLCRGCmWwiqTYT/4a3DE +k3lsQJEnr83ot4Exm8hxE6FdJi2cV15fdeOa6+uNrUy2LwfbciLTMthq64Ylr7bd1qoUu5KtSrYp +1arEj6wTGZVqVh7IrCQnAZqV9LBdGYizyazLQqu4ipWJq5ktzf10ZmrqwybnLGYnG55serLxyQao +f4gDk/zzwan5mV9/qwgX+3cxx97Ce8tEfr0o/j2Sj2776T8V25YqbVFFFnp1/yfX3sR+CxofWhNF +VsPerQRcBtm5Lm3Tcc7LItsMT3qY8jDdYc7z1pJkS2k2vU80rYNNaXaR4ExGW/soM1jnruw7E03Y +nc3Qk8xJ3nyybT472XyOJK3vyHoMIqF5C6owzXdogu7JIqVtCDaihazXSNZsIRt3Jat3R4Ywfp3Q +WCbDeSFTGreVTG40XLPrdFzJw7YXXeEIovwOXXKkSwR60GWH7COpQO48XrO0sZAysldj/HTkzeDo +XRtg2u/NkacuvCTm/SIG/UmMeHZ+qvuziK0exUZnJ+hpMsN8J/Z4FW9oHtXHjeq4E2HP4r4rjmFi +qY96I/lejiL9R69L2XhdRr/LiVxkB3KX7SZzv6wwUdj/kmnqRPPCLDiTyZpmX8yRptpePDI7kncr ++WUq2Dyk5mRz0ERy0gRy1CyySnhnPYnT5kiOG37EU1F29rSJpSrro+bMdb7c/eDLVU9u9+WqJ7f7 +cmf15U7Hk7lz1ZfbvbnNvLndn5ud52fw+LC3Z3LOnguungt+nnNPz+DrmdDZM7h7vMPHOX3oac7v +o74f9f7wrMuj/RLNFRScQ2hRm8bsGn1Ow0OcmuQfHJ9PDApYWOChqMC0DQyIurNVeEzloUl+Euci +uxZ1ZpNfcaJJvdh0PtpEbjqBaeZGdS2Kc/FozkV1L1ZW5CanyZ3rcTtxNa7kakRnI7sb0eFILkdy +OrLb8UgzYD+R95H9j+iBRB9kIZUqkScykjcykLLFphGq3TzBeV7yJNLB3bEGODjuTSjMg1A4qFBw +fKvmk01n8sDYN4kQUDHg17+u/Xlw03peirPWM3K6wEfPxSRO20Cudc/DvThv28C8NHUvrnGMebU3 +BXkV1TibSswKMdrcd5t94iA7xTrsEo8Pjm1CYxMtgvljoTFxt/fZ3xX+PvcPLNZ18NSdrs70cb7z +bBfZTOODY7MjkbvaqIQSJnGh9xFpbjR4LNiBfqJR0Clsk3dkIOnje1ZYLMqzbOI71VSXUQm/EwVc +lW8gZRK9WzXursh4VSZs4jmrM0OdCYoDMZn9qboNazcrydcdydwDyeGTWNqzKTlsb2dTdFDV2U2m +6+DegHuEajtd30m0wZjOIyoPSld4DwtYVpr42ZvydBC0R4s23Jk6pS/RFwWLWmBsUt6p79V3Vwll +rrIRMhU72SBZCVNF7Cib6Il31DvRy1Q36/pZkG04yZPlKU5j61rbyubRRP/sBiXOqXH29C8LmrKB +zxp4FB28mhZ+2OjhadDE92qKOk08d118EmX8KLFN1caz6eM7m953D2rke5nSFKrcqOSDK+iSM2h0 +B6lGri6hODmv0CpTVicsO4YW08iz08l1Yh38hiEhS5fdIfkdi8QfC2V4rBZyPLL3ZQ== + + + cBwkchyQ62CSbI89TcST+I3Uf9A9CDxa6kM40oj17I/F3AguB6SKF29v/gTvUQjmxcs2nOsQtWa/ +wnFSN54ErRfZyNSbpz4G72VoEr/eOekm8q3eTS6QrcHs7noYQ9r6rBLcVk/Ebt33Z1pFl5SVqstm +CJSJs6K7LBZzXPRH3EMTfRvENGXwRJDthcil/B3nVdPUHXUD3Ynrj51AutT6QguTuX3K49YZDMjR +RgLHwPtR0YcqjB63kL6B4NewzqT7Sbw1PRuA3TPHya20h7aLvVtxsl2YpzKbHSzLbpLNQjaKC1uF +bhZ+u3Dr0O8YKNKnYdvQjSO5zaOQvbIV4Tt79qMYn8Tx7sbdefB34sE3H77YU5ec+PvBfq6WAhMn +UY/UUjoNZnQ3pKuYQ2pKd2NaQ91i8UxmUI8mtYa2z8Pam5C2GNdqXufJAjMuNPOB9Aaf4FB8tEZN +7olt7kHFVsvbK9o7Wd+qbleRAtkMcTbFxXRRDXwRcTJbpFu3z6M9B3v2w8MSajfRNzKrfUx9DIf3 +jCrNqtLMKgn7WODHhX4ml2d1sD1b9/Dmcq66tV5NDcguA0ts98nM9+ASshbVM1wK1MlZ9Eez67tt +L/b9JEuh2bPa0zlY7MnuSRcSQGCGB/cs7pn7s0nDOg3PcXymw/nX/uzZPfC084d0Rw6DnOf8Wcbf +Awl/H7RqJvFQfNzA31o3o31jNv5kfi1damrmpCGLqHuy1GTdmqsL2z2TyyLam8eqOlM1DmaqN/n3 +Zg5Vi9+k6UIAh/OLfAhHgjiWa6QOAO8CECfAJDbsSeYW+QLEmmV7lh0CbNWqZcu2VTb3QOpOgmkM +u2EyAdAAdq2Po68lLKsHpLom+gG2zkCnegJnUHDgP4Rb1IHGhILroqWkgrrM0ACbzSk3SjcprVEu +AJnmeOQo5bnhSzKMTMAUgIVxW4pCi7cBZkIn9KpYJcclwMxEBKEBLsQY2rzkoe/LUgtCijIhYNd7 +ns9NCbcR5olPcbkmWqJ0WQHngCCUAiiGYcvQV2RHI+R0zoexxXaL29pNTJgA5Ci9Llqi9MunUyq3 +lCK0IHNSuOZM3aLmFJi1xjFvaglrGrjSyJ+EP9SQE43ojGxRRtRbeAOmLS3NZcJcF++nJMQ8f/Xm +JR17soyYLaRnO22OCGA0jA8IHOyAAB4PqIMBeSfHAyKF7Es/HoCG49Tj9hsL4yT2RdyE1C4Z8y6o +NuWT2Bdb6+JwZsKrbXFuwjv/1GTJx21ryQ+uqW5neN/Uvp1lHE8XLQ61OXquxKHb+i5T4ixXAv38 +6rJSU4QdVzsJGDjnldkk3SpRyyRJdKIcVtQf2H11kiAdO6wKWRg7cVDJVAgyGbJmQciE4DMjs5wa +6edGVrJLnXdBJ8gkKc5ZXAxulrgzJGk4RbLNSgje+zOZTfoo989Fw3R1OT/kKTiZpyC4bJ96lntw +styDns+uTiGbTtPW3elmVdhkG2yz2Ydcdk0qmFwye95Ys96ePTkPUnDW7NbzeZwoohthXqC9inbq +kZyNgSZEPbaPTYVxMszuEFGfDpoGf5TJME+DwBgnQ/c2LS5Rpai/yabEMCmmB3yC47TYToz9Jkrf +E8PydCFPZRQxyyZFZUgI2zqN1nnayh2bKV70XJ4sF6fL5LJSzs4+DH7yPllGx4fzlKPbAyMXOEdw +dqBQOUmwP8nkaH87CSo99zA8kO1V7TQXneM6n+GcrnZ+SC6aC1US12gi6/aH0/cwkX9tIVGG+x7L +sDuYppH2OsyfOsKUXGAqYgJtU9cZzLkIc22F+XWoJ5hMESZRxRDRYT0BtRHmRoXpcIAJsMCwF8rz +OIIkCCABKo3rCbaHQCO6w1QNt9RXkPyH4wms8DDByimUbnFAL/zdQql0BWbkDh1Xd3aqyx9R+5wD +aoOxOl3zeBqaqdPHj6d9KOnODFOLP08X43B6pMXH4fxxlrPDLP0ky3ThKMsnHmSh8CcHP1tcJ4t7 +Rot4nujIEOcZr3SyKMMkpWxjOot0oozjPeUcr3SoiQ894YEoWE53dG7xQCnIPZ03UX7VotnFT1Ph +aSo8TYWnqeCmgnNXrWWeybcA2llpjWzylpPUIiH789L5lk/7mJxh+bSTWV9yqusTT6Z89fZP77lu +0M0/vPruzcv3dPDoErSf2VceTMqDSXkwLdNMj7D58S0fOSB4Tqast6B1ppsab0GxDZ80Mpc+T0P0 +mM/elryEhLVx4oIfiDfreltjaJ9GwsNoHk9Jy583M8dPfspE+f2bNy/uX357852AbmDFwUy5CKbp +KL6bTfWFizbzRRfLAybzdGYvVzsj40+DL5uciTFrwuVNTBbSLS51wrlcXFi3u1yqmcVnqUBbV0s+ +ywUawrviZiGj+GFjxteOOK8XEeWvFovoRSMK1pDo1kO1ahBsJO/Iw3MgU6KXg+BiEPQX3nknh9Hx +PAz+DROI3GAn0PXsOZ87x1Pnlc+dkx2yI3HdD5mf7IB5kEPmIN4nOl1e6GyN5nlwpsee7G8+Wo75 +PbBH0PERPVOUHzg6fo0t2e/I0zW2ZL8jT9fYkv2OPH3+ltzPLm0LV2zLVmyLVmxLVrh6FdOQ4OzK +VQypzbNF/3pO834I2mvYvkwucu9i90P0vh9T350F8LchfKoVcn44/SNxfE6UZ51yLGJx6az5+SHx +vIl899h3nDbhbxcCPwuCa3768WIkXGLhkwuG93D4eUC8h8SHoLhLapfxnsawuAuMnz4WGB9VL1j6 +bc0fUmpgE1tamVeOTYG8wR8wdJIuaknXQshRtwbyK1Ecb52Xy8gCrHE6JV70BwlDXVYar4fyy/bs +sF7cswHs92weW9Kj97ZZ7CTNi5JC5CySuqYuHaUN/RDU5Hxbn3Sy1n9d2hvZ98sRIYoH0UaVXKko +jgRpmagmyYPoyCXv10SqyV4iP4HKQfViUKCQkDrS4z078oKxa9aOTxFl5pmMlmzVjyD5JKuT5c0u +Q3JuT88l/WSSsMfOEqk0D/bOJb9q0qsmvPpE1/XUxqyrT6oOdKn8z6YQ0PQp9X8eKvrDovQzzfAL +Vjht+NOX7/hSlcQlnR8s+X+1nVT3Ut1N1cRVI5ez/ovZuXFiU9eMXTV31eBVk1eNXjV71fAl03dT +OCSXuQUvSWrKgeP7aiGi3o9SD1MQFtAuymVb80sxjdYurKg1k5xdFizb4ePKXN3DFdCYCfRgTYlr +ofwy8RkvSs841rNr6qMfHjns5H72z2F4fE7XcRr/K+q5e8ZFbscv45CEeunY/3jwfzRM7jTuO9n5 +/3L5eIJ/PUmZC5VuzpSeT3imUUs6f2idjtr1JyjXn+vt8unrT/vl0375tF/+p9kvYwYJ4beODAvc +523RdsIFneCXnAJ1cb/8Uky8X37ZrhsXAK31aru44vtb38vT5c08xdEUwq+n1LOn1LOn1LOn1LOn +1LOn1LOn1LOn1LOn1LOnJJOnfKOnqfA0FZ6mwmelnuGe+0lJXQvaxO0LssIEwWMzjPQwYr6d8djX +ZyS/6Ue/0Ehvl4305ox057EjFVnVY9ItzLCOrmZEN6pVE+ZyEaL/mllEWq8a1F7XZS13TCm6G8pD ++CIsriji9PhKvP95tUvOUwrync0k+L5xrn7oGpDzcv4frdE/PVCL/zExiPOgAsiDno6xTco4S87g +axs+5mn9RCE9PeBr/WwRPT2Ui3Quojkj6EPFOYJl/5yk4x8oz8FMmIaz/kfL9DkvzhGHOpd3ltrT +E3tW5VCxnJ4P1rp8QPwCZ8pSLopRyQ0BSVfxxCuljSy5tA8n6X4hwtHnWsq8sB93jaND1046JzqS +bX7Sj3hcvxDhl4nyfNnfCmC8ifPJ3/rkb33ytz75W5/8rU/+1id/65O/9cnf+uRZeXKyPU2Fp6nw +NBW+zN9qt26sm2HUQcQhvHRLwoOHjKbhVoTxJszxpNF4E6a/xm04ajRdPGuUXNnCxZUL9XdyaPVC +vZNDSoROrvq+nypjCcPoSxgOM0bnjM2Y6cEpwwfReLboXPnQTJF5MslE6dOEE//Ga+j6/NjOjnFu +wMyYcGLQrNA50WcE5dCyk67BasZJECT5EdcwruAMw73AEGvp/HZ2bsw8TM6/tJ9kDY+XqeSLxV7H +Qq+7yzeqTLLMH7o94XwUh3sT3C0qXJd1Nz10qe3mWlsd10uHDAdpMD0oDnCYPy4OdpbkKfJg+ohA +8CLBC4VRLIhgwBkwXRAMTjTIVBDRjWs+0NCfaFnjwOOQ04UJF+5b9GVFh3GeLg5zX6TjxTl9lB+8 +JWOyofYX57hF664v3pYe5fHuxUdpzKeN7N9ekTFekrEMt43sz7YCGP3JDf9j9gO3I7i7MNw9GNMm +y/fCzjDsDePu4PYHngh4eOIgpy4+NBVAZUCFYQeDUEhRWEhJOMDor7BCEigGMygFBxDaq5MfJ9g+ +djSFArzlRJOngqQIuMMfYa6swN9I12ocYBpUGPgIZOAVGjsYogwjudCNGTsYrwwMWexMQoMByTAQ +C12JsZ/oNowM620BZvM6Q1GKDF6AuchYZKtKUGSmXuPJHOyyk3g3Gev4Ps+BaY5nbXN44fzAgpxR ++Buwy9W90P1MH3I4po1/qXuXBtfS9EhH4wfcjKNfevq8CyUu+qfJszh94DqJBy6T+PClotMHbhUd +L5Fw94p+6FrRSS6OEJcx+Qe907iq21gOfdzRYY9AxzwyHe9Y6YqPPV3ocTrdTXQtJ1/FmekKzhV9 +5+i9xttFxL3wNBWepsLTVHiaCn4qfFb5qDbfLnP7vCwa+ejnlZEq822KrXxB2pBi+MS8oc8ql/Wl +AeZyubZBWT9Uj+g8Dry5Vob84h9YWtNH1pZfXds7nPwCs8jw5EI0lysSXbyhbBPB29vKO00aGHbh +mDEufB4VHisTbWLCkwXz+k00q8WE9XDw4WPhmmX4SYsbjWWO+H+h/2+SH6N917hJJPW0cM0jUVgL +3aPL8RT+aZUySIXO5dI9urtNTaRtVaST1UWSekhUGUmrIvH3Xg4pTVINqdI1KjuphaQhSK6GJHFp +uhhc6yFFqYgUpRgSWj2ou+8miuXsqA7SnowjDk/OUgcp0U1JT5WQrlAJabBPH+2gEPfE5TJKn3Fr +rKujc5h6RSXLrdreGXt+Y+x8VljJSitNm7ti+02xvrzS4PvclFgaiyztprM6S2Olpcv+T7ncdSi3 +JI60yXlBXc2lrUftUg2mj9VheqgWU/bFBoYswA/VZHJVmS7XZYKZMF0oztSvKrpcn6lXaLpQo2ka +yjT5Qk2XLjBafKWIC9cYwTNdKNnkbzOSufefqYATSI15rVRtqYa0XkS2cPLdfFuCpLytObU5PJBD +dz2UX6bkrOWikgPgR1+YwSUf1Ea5ZKFQQsxDiTeal6DGzyUTaDCCHkJUzJJidNuELkQ12FNn1Rk+ +Fuf7aJTvsQHDj4YMH0L0sdjjGapxmcHOxhfKLDMoA3Rd0DyX2oZVQYlClFcqk46vmA== + + + uTyPr4bxP3ph27M1Ei7mn4Y4LJyP5VZeLO35UGoljPE0aNGjHj1e5DgmVG5TKi2hchru/y12Bd86 +VE8Z7WGwhrlGznn+V90knm4NjK2JMRgZ0zbry/HI8+rRyYKTyxYsA3d24gng7KE0pgtS51yyZC/3 +OqZMHi1l8qGkySoXou4w+tKz4bb5cJcTJ0fD64wl05CSW3fb66ExTWqhzhfpMk4C7pzLbN7ekKop +zXw7aqCUrkpnXI5yvoVPt2Dy8omq8KRSJuiunGgB0yjSWZYGfDoRZxLwYqVzK3fQWTLboVNH6EgA +6ivQvKeMPUzXW4nOu4mSOAuwixM4l57ACRP5eLwD2RZBzlVgyh4kIN6dHO4Sj9wnafcfV+6nD2r3 +G93+Mar99LFshMvJCNS563YNc44f7toF0+Xj3Zs+nmxxqXs8cp9omX2sg9OnWmYf6970mFyS8+5t +HH34RtwgQVVpJVE9ndoCF9HJgar9qGY6B+gWbaaby/LGQt3XwsgX2rW4EBJQq0BO4CGODLs77e2k +a92QE49LiibEho2Bv0usF3fmayH8su36ojdvW6h01HPXMz03UnEz1B7PffHb1O9TnCfzwl+qWv6g +j9AVPXP+Qa/3et3XxxB8HMEr0v5YQ9eBYepOLrTgujR0y2e1+ziDjzVQvMF76BZJQ47mRKtiObTZ +59lLCUKpC75IXfBksY8yibperQb43qXfn5zHK9DfZBRnR3Oj5bz/ZJX/U1L76nTNxD5vAngaPZWe +Tk+pp9VTe+dPFfpzhY7qgW5PuaedqO8UKhdHGjdUbujcXzgLSFcnnx8F3FvG3WpuKjsGuLmiu9MM +VH/hKekvti7m2wiqENtHrcAiwB9Ky2ORt4Kn5VaS2mjdY0SDypVdFvZXw/hF4jSGS+IUoF94z+bJ +yZ2zQ1WTC2pWqRzpA5oiTr/0tNfu7IDPgnrNQwd8hnDrY44XbSnwod6yOW9GFExnAk5pUCr4bOL1 +hNuFSo+PFG7/njnTj3n3J799uiQkz9+/8Wei6cj12WHQaLWCWbeMVRT1yuaqd+F+cN1fD+VnBn/x +0uMcviT4Kxi+TPBcdLvEscrioxJ9Kc33UVm+j0oWfcBqu5Ae+JiEw7PMuYfQ+dDcY5ITKDXhUUkq +/5HReZ8mSsJE7vLc6CZv5GAYDs2L3/z8B3+DUbtdl+Fa86tj/sSFN3/o7P2nfPqLFly6GCFIFwIE ++tUrTwdL7uQ0z+xc9UUSQTkhtFL8fFXzoEfRe31zCR1uipbfWeyct9JF7hZaKIqunv84keETZZEV +WW7FYut829AqsXW1MTjCfqDFyruxxtpPk4bvuJ/8shCkaDB/RTkhzk8mScSBeL6ZiO8m4n18ncRW +kf/Sd722qNHFRXqBEW/4bIEd5Izx+J1+N1mTo/u3P6cLzx15P4ZAJY6b12rioMsdB11OTeOj1f2O +0uVV+sDqEilL00fMYr3I60iexwfKJ7hctDRZusw2ES2ST1LTZLb1deJD9XUmS0DLFyvssDP6QvbZ +A7lnu0lc8XdyFDlo8pnknh2kRnn3tX8k+2w6k6GagKaSVGWpSlOWpyxRd2SyHUiuHv0Yq+6a7Pzw +aoG1ZuksR0tcWQY9Olu+SptkMZkqK2tFlXxNTtFbunZOqz5JVoo/Np8132ol151OnG4EfDivUX0r +OpXg73QhCWub4TjmYG1rcujEktyriVKvem4jzyt0/Z/I/x1oQuF02tFU4okUZCLxvQlHil8Emj51 +Eud9P+mM1S70pHORc853JJXQJ87HnO/QHw6j3WCEj1pw/m/nxPu/OsLlgYcm8CS7m7q41NGVzva3 +cV+7tKEd9FKOcT9b3B7m49e8wPzmtYrJyGbjTo2gu81VAuPNAD63ZcxqGbNZpKDVNGSwDHkrm3wV +f4PYmJ4ypKVMQz7KeFvYmH4ypJ0M6SZDlsk0ppdQahN7jMYEJzbkNM1JE52ibIpLT3eaJOPpThJu +ji7vid1MerEcJz+xy2lMgdJjoJQINQ25UJoPtegskJE5ubyoo7ylHw6VA6JPB5P/9g8mXy2X5LIz +Yxzlzx7nyeVzfvlIw1hPj6so94Gx3oz29Fmxww+M9/To6OFHR3xjya51XjAY1hpsJoGu1YCdIK7k +2hGHziw5NAtG9B7MyvlSTP/psnEuF/bEup5mpTpPie3yuoX3QjnFqbo7szdPdLXRbHsx78SWmD1t +crIlG5tUBM3CTmQJ6ZW0lW5DWsW225l5JkbYZNnYkTRf0n1prrHqy7XEdhSkP5LldCIVfyb7CRVg +VIET3ZBTsCjPREkcqAvvaH4fpcoYn0jA/gd5ElXtQaUY1WJUjFdaLVxeStVjujd5Ji2ZK01xnSk8 +sZDp6C8XmvKlpg5cjczqkS1yhoHTbPJEmTbrkGfDmTa47M/zbCjTZjRMo7naeezUOF1ozD58kir3 +KkfTxTNUKyXG7C4FHLanp+SMRxRO1sns1QOyzlkW3rY4PHB2Sg9ODXdMJ8qqGa3Wo90trWYrsvIj +ZWE5d2oazk15y1VvZzsOp6YCZXYXytA5TxID03UaLNdVLtK67P5j4/Xj12U97uKsB6/Tmj5yp9bF +O7Y+9Jzfv/Whe7cecRvXdKF07WOK2T74TA9Wu/3YUy8/00O/eKBaLj2jRaKs1d4rfYpCrQ41NxaL +HauZYYnwn3i19MOXS6OtMD3mcunHXy99yNOF66WvcMH0Z14xLYcdfAGRu+lCcQlfXmJbYIJKTDzZ +Hn9LtscDGRIZOBAx0NEwRDaW9i2pUtpBVkUSS/2m+oAqej2U/+l00nIxcgLQi7XmSaHhDX1n7sLL +h6AlH/jCZq4e6COlij/yCLTemVmHzdznfNMp6Mk5orsrmjZ02dIXdxtmFq+0bO3mmebD0ScU5hP7 +ujj1s1ef7W55TabW3HLmzniAdW8Z1Xf+ICvXPUq0pgut7kbrfEcr/rDJLo+UiYzSoVA+8ub2WpS3 +EyVTi0tWUqrZL3uQrPrOykp60Y4rUoqnln216K3d8y2iEzts/9d2yfJm8rEK+x++6/f8At8Lx+0+ +XHn/wlE8/0wP6pUPfR0feMSXKKf4qPefcrb1MfvOp6WIP2LXma6XPy0HW6VmEK37lQ5X9MpS4UI1 +sYMrLVWlO+elpahbExlZ2DPeU7l/VmGK+si97DXGttfKcnflYtkJ+7ypOOXvluXeD3WnhAcnibpu +rpedOBD84MaLJZcw/bmlurbLuyQW+sd0hMSV/z+4130hwnHTbdBLyjRc8dSKJELwjt1058abVSlp +gq8A+IhW8KUYv2iDrpf25/qlKYxP9wc83R/wdH/A0/0BT/cHPN0f8NmK8b8twqf7A57uD3hyij0V +jX+aCk9T4Wkq/Ovf1/r4IobjOe9P+th/On95u3imsG3OFJ6M0XsrsreT7Mp1U1662E+XSk3Tv9OQ +3fm5OtYFTTDI0Wd0GZDDQAoloRHAapLmyLOC1CgL5EiaPqlHk5xwZNcAWnpZanFwVvzJHROvlKSx +t8xly1smykx1jVblxVd3UW+/Zp7PEsRXz79mobP7v+JRQLaLdxQ/PUhY/ySh/dliAT0aoIH+Immf +Hw/2fySY/7G4/Xls/jEx+k2oneX3Z8rpC2KahPT05TUTd2x6bCrlj07MbPJPJaDKwMPgvywmCOM0 +uC+PZ2lsKhNVKm4vUSDZ+IBfE2bwmulM1LK0PBRma3xE0e4IhV8R6GOuwy9GyQIyl3m8uxQ+EFrx +Qg5PcmGJOPgBa1KEcllcfimmLxOeF+tbtLG+hRUEVYHDLoY7PZLjfE3ezzQeqNiUid56mC6ViB7d +kg+UiEZfwWQ+pa1v0jxJo9y4UCpqW5GWw3m7C7VoFwmP9vpZZbLyUDvnRxxjpcmd2uGI6Y6yQCxq +KlKU5OdEaSSZYn+cCtUsGUrip2OPvkjCXDoUfUHGPELCPKwGTh/XA/W+5/0m8X8sWbotWnopUee0 +zfAfC5eum7z+NCTtbNN2NuVLJ5fD3w4XC5hyjGpPs1KvMerRqm28itXYhy9DkZjVpEGr4UaUficK +K7jbuNWlyBUrvFLnCOW+l/ys+0r0apNpHOdlCAWBUhLGo+QafWlahDKtAcTDRcl3HXRcfAgVtEGW +r3XZpItAB0Gc37hT7gEDVw9tGNdD+SEBDYCvf/X2zW/evXrz/tWb7549c3Lb/2L61ff4m8i/+c2L +9+9fvnsDAv2r/+fHF+9e/nCze/Pd65ffgizfAG6W5Talusq/8aaUW4zoyb8RuvojdtdsgT/8lf77 +f8OP/wOA/3KTbn5588//fb75luB/+C38s8V572CC9+Y5wDbvGmD62ecX8CHsDb3u1zQUYDmBfkE5 +6LUSm9O8wo6D22EttC3OPC+wgqtUrIqcC/SHF/gCeCnWdc23YGgmpldA/C+9kn7bLkDkY8/PMSHo +T/A3rFjAErbMFVSGWukNCovtdmlrGD5+CaaffX4Bn76HPgecytBRkKL0HoWV5TY2sPP85y/B9LPP +L+DT9yhN+nnPsRpuU6uLMKjNc7sE8m/eYtO30MdK8cOiIDcI/KkLEDcGG0z6AupWTfrZewfynFUu +XIL52TBi05cQNTBLdEzvHYw/0oaPX4L5+bDFN3BrMyYK8wOgn78E8yOwxafvAUEXYFvAZZbnCts1 +xtAjCDaW1QnpxepBkgUgBddAevMPtODmm99y9ZEAy5MLydU0lkDoYhWVblbIYV+k4ycrruabP+y4 +5vHNv/iZ2ufKpWG7tJgurNkNNgT9kaV+zVyYtpNXwjJUSUpchha9KEQm9JLNBer5dn7dPzDyw2rc +wDzxl+Yrkwq7/EK170LE8MdF3sp25CwakI5AP9M6zFKRJpdmj3LrEsxLji2+TmsFZT/S/lgXnlrQ +LhdidMM4JwpsTdjIbOJQJQ3cVQcR7pbyJWGKha42MldAbtVekP1/vNLE3wpjP08rDGEStpgwvQDz +C/KScL/q8NMmCrKzD/4gai+IQQXJ556fYbrmsG/2A79F+DG+JEcviOsLuwsTmhJYkWMttJTXNmqn +WgJzVa5K3hMTigPpKLh3MF4X6VwSb2Ce+i0+pXWrVXhNw+MU1eUCyGO8pKPgW34/nVjdBP1UlM3P +0ldX/s3+3Y8//FnxmLshzD+b5psd/P3Dv0w/wjNooZd1UNJAnyXQzW/zDUjqhJU/F+DCM1AJ11uM +5Dvw8xEcyi1eTEhgxXAJ1j/+ZkIdFCfyvNDYVzwWhpMULLKVhH8tYCbQgUjcvRBiBfgXnccONRoW +ORDBocF0XHNCcLydA3wGgGu+BdtPyIiw5AFW422d5+pI+wY/X5AemIAExoZLgw+35hv+FRqCoQU4 +gezecKnbhn/BhnMGjCH5l8PyxJ25DFR6XkuPDtPQFvcrwHszIEVmN1DTBwJ0BL4ZKQVwLtC5oVfa +9q9j93tbxyptix1zXO00OP53arcDdZj+NP1+ajc//dnNH/4RfqJJDatgmNIfm+kEvQ== + + + AfBNGKb8oyf8CurT7bqCZrKGuWB5Xprz67xGFBPNgZ9vwOG21LwS2CN5AGxIrjXzCXspIEEBe4KN +ICeifIHJRZCYQL3iZmldEgMz7Kg3I2XQcl0rTjMGR+4eogQznYFohjMQrxS9ufhyHFDkELQpSkNK +SxJ+5lt0ViMYfpphh0Jg4UnJbWMsBKy3eFyagW2BtXAgBDCT0CfA4BwWbRuTvCzP4YYbLrhvE6zM +QDh/vsGOOK9MwEITdZ3bcgu8D9x2ZYbNMHszNFDepJUR4KSOSYgNpRSeEQAGauvAHdiDYUGvwt5c +QxRgXBYlFlNnGS+CozIstixtQ5gFa5qLIghrUZ6jcmsIcrUBzkHawsYbFcGqQDD5lYI1yefTLUbi +pCmaDALsTIA5L8AF3QJMwDwHQwCrX7gISlcVzuC8KU04Dv8lFPk2hVlmWAqZOV6AAu1YzVk7BmDs +Oo9ki4qgpazAlLICmxLWOwaLzmZ+q4H7sN6Gpcg8AlHLSGFyBJ0cILDk8w1mdhFaWxIeNlQM5f0V +J758XiYXrovVPo8ZUzplF/18afx5eFUIWYANGc/Aui68HGda8IKgrhXnPAJT45HJsMjjKsA1lSq8 +XkMxBDAjdQiWxlJsmRd4SZTXpSAoFlQ/o/aWuI3ANGehNsKCFbwL7guymud17njLOgsVVHaPgZj5 +JQwvlYHhFuP12uESBC+AU5K+LbB4BW+AjiahN+S2CoqEY8IocqwCLDHqKg/R0JbxbYwWViluU51p +DIwmAklmCxBUbSGApR2DYTMQcudlLUJCm3WAl7wGQbCkPpJJ+4vSQQcCZAO3hWmfctPJKL2tIMWj +diEXHQjY7VPRKRZqlbYVy7gzx1G4C3CtusaKQ9CiCpo1MgEr9HaVpliyU4Cgueub2qw9ADB0WcCr +zJr1FhgXzxCgsSRAUF4MAZHIS2cl8YdAUHcWnQeBB6GxzOncZgQNR1EHjDcRAiZduitstTfWUiio +8F9DEKNtOAXADCy5VmWsAcnfyhQYCwA6B1s4MuANuansWpSoNemmuy46i5aZpzpjbTyLANjlJIlE +Bpa2KrNxM1IEGejStjy5F1jjyXabQHIKW4IpWISvsdDMWHATDCr8MCx7UAT6qkTbJYFy0MlSDdZl +t25KCI6t6EqOLGIA2Pp6YdkHrwb2r83RxAgCepp1cS6stiAw6HrBeM3NP0lbtIN1pxG8sORCsgm7 +CgwEsq43lDT8rohamK64Yp/PyAy/+yCw76C1LNUQtDnqmscTNAiEj4VgigypPAiMtcqrwBiQzwOy +qASAqs3vgh9b2LIww2Cu0YlCRgDIStMFg4KegaSy83DNpQgwzcP+pQhKWKW3OTXRYPF1LQsKMnjl +ZWijiIa1GN5qGsuiiwPxLjplZb8Hlcu0aFOPELjA/FH1yFhbQO6oookZytK2zsnkg7C2wpDqlAu2 +vNEnEVeddKUkaYsndJQ1rCkjgqCaGIbdBQFIzmS7Wlpl9wAwyC0Fl6woVFdG4V+iAJvtMwF9HYq3 +1SSLMWLteASCmlt02mM5ZAGCNFx1Xw3K2xUrC2VHGANrUtZkGTCQsfOq29dSV/s8LGLlTC36+b61 +LykoVTXaBtrHpqEU1HUDzL8RIOztimBWYFirAUs2BH2KixuWwakutatjDFvDEh0TGViCDnnCzVrR +5nnJm6GBtlVVAxjmJMAE248qU8tqCMqiciKLbgHAFhcBFliQCAxYAFx3KkywYAQBz8zPSRGwTA9k +yBUli/eUgDE2VXlIj1cEKTVhgai5CFyjqnNVuhCW25CU3yvqm4wAwJl5AKst8LoBIBgs0t0cWUwg +MAZ9VdR1A2DMZBPC1sZdCG6vEJUagTmpTAPbVUYBwKnqZpNXlsDYVsy4bNogAhddCXhDlSEgRYW7 +i45vAaINzFiBRwIEsawUgIA1BC1mnQeij4ZoSjX6LnIWYGgpKWdVOQFwXHXhEesFGHWFFFHwEGvT +FVKSKuAAhp8FAXUGgckJa7JbGNhVHtghRPggWJQLoID1u5DRAb3w0C7RgLEGBQblQHYbpoRkGJyi +Sg7axhhYkxohjUUiwop+vgZDW8xk1B7BpqVSa2WxF3BJ6wSqpi4F1LVVCaC5wMDcmlA/F5nuuNfp +Mq4mN5Emk7FGPHxsKYpAVHEAhqya9IpGrFK/rCo1xOonBFl7n0S5IQQ22Uw1QlfXooNic7DA8i06 +A1Q8FNPPM2u3imANKpArqt3PFRx5caDpy0pfwG2tei4wcJYVU7omilCUNX0dMTCDRSMTQ2wMAFLE +iZGmshiCZApuUq8XgmmbZ3CVWVx5UMdhqE5Kryg0FC/xWVa98AY3UJva7GIgYE3WW92qEIy2OnWC +BC4CwZRPfXLOVYC64mQmMYLVbCKc3CIKYPtJTWWkWFoATLbialUVLTRnQ7Z5VQR4eaa+rBLD48wm +S5eRhCDSpZxKQWRq42yOIltzCFt0Jq5BjVj8fNMtpaCsYWCwhYcONQFSTEsGQQU6gos6OdaF1xgA +a45edjOQPGyyUenCi+ghaLor4tIW4JJ0FCPPWQRGbdmwar8iiMW2Vd7XAaYuRxjZkrkHgWr7u12C +Px9A7OjnVaEFBDXrjkJDxMCG+768abHP42lF0ULETgBgCgpci1AFu4y42hBpioYAc8iclHkuYLBA +dffgrTbCjhKjztjIrtSIu4T6BugjjBZdgLqjNNmnANh1G9JGGZjF2C0Y6pPlEdH1mMpIAKpOQSZ3 +YEcVAtVc9xslgpt1t1VFUE2HKWIsAhBz53QS6TYVUVRHpQt9m4K1qDTBjFKjQPVTFOaOgsUmPTsi +EOtcVdsQIxyBi9KKJ00NQZ11zqrTI6J8N4Eocge7UFVrzUU1rgiEr6pcxSTUFo7jsfCsSxOgejJw +H1R1HMFztGWXFQFMKaVAHBEAJEtZpkFUHoD4brKrsqx4LuAkemdhrwYDw6ousSqeegSaOk1bp+JN +Zmhk2Vxj5YEWDZU1uVjphho35xgB+t5Nnw4a3ojVtiu38lbn2ctiVAAwRFWDitn4522fK9hmM/mT +GRibik/xciMwzxpVyGjbKd6ueerGgDQUNSqquLrwVeZwpC1ZEYSozGkUr2MKbL9qYpoRBbYgU/88 +Hp0dNdeIVpjq2ar6ArC7lFYzQDBuvKhDoa6sqCMwJtvaZMwBuEZVfLLtNs3Zhk3sbgCmnLSthIIi ++r5TPZuMsDeW1a9TwdrUHdxEEUCgaQckQA3BMrfNDJV4uMjlZmQFFdbdLwfg3NSnrePVTCGHJSJO +GQDW2XQ/tGr088U2kVZXJaDYLkx7o7wpqkJuqnfs7joSejI5AWpqHskZA/c914hdTc93LOxuA5qG ++jIicRCgCVNsgjftGKiewcKuHkKQMMcqiZRQuz3NzhnQcEYycG1z0cmtOmmilCyb3q1xx1L3I/aZ +CMCAfGLCeHkALIUmeuYc1LFEYN1eacooWg2yAZi1hrR4HU3sIgCqkwLtGiUWFYRZO8aiFlq2rBsD +CUduGIJZG6YOJoxQq9xh/xOA1F3XTVsAqgkiyrN+vJmDwvgazUVf2IHOQErb3GhCCBb9BJilFAAw +6Ppe0BuHwGQ6feH4IiNAD7Zxu7FzMInSTsAkTtuULQqGpoJq1Alnug62sBr7os6QqgwUZoiQX5UD +aHnOtoWx5ovAojZs4oAXAsOingxbXAg1D56NdW+KnWJ1OOGaNvulqjIK4BRWme/AbO5rNXV6AHZz +uetMACbbWRhbsrYNQYBBxrVy5IvH1WJg2NT2yiYGIwBzXWzjaIq0NnPFmIhOlbV7e9dzgbqZwSls +CIYtOHfdoDG/EahWc5JVAFtXrYq12OoG8KpNVXACMM4mTRfeqxGYFr/LKIJcmuKVPTWtJkqKho6X +1BxjKTDMCDDMYsZtEtMSoEnCuW4hNEoKU87I5Gjms9igVd0b+iBGRZ5tdhbzx2PeWjEvE+pnhCBj +WXZVr9Twz8FicIWd0Qx0vcWVwggALFYNEhYi9yxH9LXpiImfCdo2kxG5sozIGBxcFG/V0BwiKGpc +RnE+ZTQVkgqkGhQIOqVqiOoNACg5GUW1YIU2YwQk6QSXuBIAK1pevQeKQNXUwg46QSBencLmIANJ +qxPBozYzgkXTdlxMFq8DCthWAVjvgMbvEUrOauF304/TKI8dSOZuFY+YIugrlzas5wLW8GRfpNhZ +8xUV0fSR1kVd/91zj69rGoyVLGN5XbHwnMg0xKsxIIkm48eLxlpWdPwfHv44pnSoGpY41EINZzNu +U6eK4jncA9Y2qKsmz8SIzInzYRm4qFcrZ9tTi3rdM+ZY6NS06ZbwwIh5MmKnv5lTsejMyJaN0x17 +GUNfSmnfFImAasYti39sO0ddXWJV5exkQTIVJqOepvptnA2BTkGNFGG7ZdGlGXVHeOjjeARMXiUR +9pwt/lT8CKANoUJale6M+9e6OFoZGBYli1ynjKBY0LNY4AKxriZIxIGHCBwLl45gqU13RYmWAbDU +2QSJfh6UFSWgz4FiShAaruzdRWBf3WINATBHVbqD7esZu6MCbhF/Uq4WEiq38vHKeSN9YvLHydmp +EkPzPwCqNOkSQEtXN3qNnQEwOidhM5SaY1E08wyBTWZ1lpAggpIKlqXonFg7OvqvudYKO/wZGJLO +Bho1fXFrqncUid+6F6uzK3s9oPtkho/HqG8CgSgjoR4VpCnobO6RAwQnlfQoDp4LtGvpGv3ImJqR +pVdqyCPQ3tWDMgheNKexil8LgUnZoqJntaA8ynRNDMhoBaudsvbdEpSGpGNnMnnlfVpGnv1i0BJm +qALRZlK8rRTdF5rqTdCaEg2Ei7JdNE40GPQexGu73WKuegCDsNUlObMLKWOA0vpbjDBKr5SeqYIC +4CqpfIXtKgaWpW94WWDqHyguWoFozQDIyXWsWybqk6d3xY2Wl9G0LAZsQleZnZqmOQcAjKsOuoS2 +qGGUgSz+86Fov6q45AGYom4talkhUnPxJrVgyuwmnQbnEGlTJZEiJwzMJhT6BEcENmXUP1lmpz5L +SulSFo7Fc1dD6RQ4m71oYB9az8WM25JkhhafYqeqG2LGxDHe85TehTO0VvYk6vaCbat6yoM4hfAc +gWXoRU5HRGCKlnFgUxzxrup6aCUoAhxiGV2R2ACsJrrMZivBfEJuxIJTccjbykD1qw1TprvKC6uh +DCxZBULJcxKgBsOAgKBmO7a1ISOfpLws6ypvsukVzKJTq7W7SQiBSSpJPSmg/lYdXl3j0JIiBKsZ +FopgjYvuO4t1t3QvryQCIlnJHA8W0cW2JW3cBNh2UT+z+s/xVebVJyAjiM6ZqgktAOzp0ZXtToQt +6hZrfRYAeDbtLS7K7xaLuVPY8sY3ZbWcUQTp59Nin28cvCw+k1HDYwW1etMbLFoBYE3/KRxdFmDS +TUzSTgimYrbH8hDtohstOeWfCzgXldR0kkDBmhpb2MMlKCSGzPxPFluTRHt+U7K0XA== + + + 3JYUI+Yu6waidhVibGqHsopS0CpSzS9YziZ8XHmiOzi+PjSntci7V93+yGdpJAXVBjVFHykSx1fh +XERB2szQWVvvUzBngoltfFk1Jw3H30vi8CWvAM03R7A6dIrlpxbJ0xxXQHJrpaemlMwdH3blks09 +L7s9A0tVphbzniF46TsPR6YKKl3Gw1WRrkXHL5iWXDKfTxllfHbBkyQeLeyrLAuM7mi2HLVVl3cR +1w+0BT3fHKgdaAGGHhApYrcxOKzZ2KXxH1GzEbY2aeikEObKWhK45BeVbCpxT2or2XZpOTehPVBF +sKd+IYKewiDuPwQmTWFwUigz5xgcZx2vniem2SqlOA2KkhIYAU4ei96vIrIKp2rKdjjryLRsdqGl +SBUcpqaESeIvVjGw6KBNZNDrszK272bVbdNkATHQ+eyr7CXV7TrdAwpgjUQWTj5jYFhsi1sXRdBd +YtlcYohg1XmoISlsKzla3V5FYDNXDookRdCjuVmSVpDatW1FeXVecBLaRkFW39VS9PPqbewpAQhc +NMxPoV7+/MpR7NU7PUq1tNGejIotbSEEy4oo6EHMNg9l4+uWg6Uglmb5ORIr5M+jU08nQZQIR515 +rQ5KFQBT0UyJ7oeus4tHa8McdRUs/dM1ab7LrFtpRdef5SOLwwE/X3QZqg2OLW25RNPNq9cgSUDx +ua/F6VRxYQEHQKDa8pF5eQOwNItFq+cOm9aqadp2bAMbWybQvCrWnrqsAWoEFu0X+RkUbU+cmkVG +A3DNmvTaRCXDlkmzv9emuk/F/G3N8S0SoKgYYdGzN5SUzkANOUv6OCMIdtZJqH0u4J55RkedERg5 +bZHbsk0JsJRMhTZpiOCo58jIn/RcwH0ekuPEwJaSLCeAELgmy6GXbCYAwuhq15JO2ooJgMqyaEl1 +AF6ynkzK4tkEYLaTYCJRkdxFD22sesCM0FrulKbj1uCcappiC0DQ4xXBvHQEKqlx669xw8Z+FgNJ +layExKdVFIHmx+BmyBIRKZCoEGZ7C7sw40UP2ZFVrOOrCZdJXTVIgGxAiZ3LAiyLNWytf95Ok1Dw +QmZHrkJAwFw1BmrcPTn/UcXjl5rdTiqrTMZFU8jJ+6EzVM8p2mk8AmcFu5f1M2N6HAUXw6zD7SjA +M1D6Ms2rAKCeL0t8XEJkigyBnVSChstckptaDIQRFJqKJPejjFj0LEbPWMW2dkaQbFoBFl23lMUp +QkriathyiV0mhqjDLTswyrlkxwBSF5RZzw0G85iR/E3BDe1zAQdJ5k1dJnqgzm7YE5qkAySvMzXb +hJNJurJabv4ApC2SgV3lwciYLkUytZ/rHii5rLGbn7ix6tkN9aMCcDHBQaE5VWQcH1Iw1VXU/8gC +loG5KW8pi1G1wdz0uJQm+KD1sRiC1m3tWlalVSNQaGlmlX8BCzg9N1NVV6PhDTxbeHhUee4Z3Ilz +vRVvX3kaWwNg567sQuhZkF1YTsKow0Ld5MnCcOgGkVgNdEw1rNl0jsh6m7l4JBMoYqZlM1cMHU4m +sCSRoOurskCImoCBLj1JDRQeqkct2Ms0MQR9grMeT6PwzDN2KmaVk/3YArlGo+KVPFsAwmqXeaRZ +xeiwXYr2yxKf0OUrXp9orit0X8s5NBz7qv5iyqUQrBa0zKZ4RLYzn3FcJuWiTGwW8BP3d+TEVgsO +iu4aWVNnr2KwjJPIIdRnHCGVtKHIE/gZxV2bBBAiWTsaTJ1Fc4ns3NAor5qi0XIsMSC8pqhMCIoW +hK6iNd8ZxpSz8pFCr88o+twnjWp6GKeedYkkC4wAWDOXMALKGzECxQUZNRSJUflShF9drFMSQRBw +bJJeU03PkzPYzyQxIUhfKQdB8xX0XE3kuOVzAVPXpb8Sw0fgKnjVLkgSYWegxZwwZ0KUushew2eU +tNHXTZGFi5kcckgt9gBHkgOt/HmxJFMyN27oaQwwdHIIVvJVNZWFViajlYgCAGtQAhZxkAOwyEFH +2P7rHA3BMisCDRFS4k2LOr0kQSiYYRA5CYIRBLNN0BPIEtwl/owI5mSzS+Uc5RjprKcgwINYMVtZ +R5Gy3hjBbIfSg0l7APaNRWcHZcXpuguWalYtdBtNP4iSvyE85Fw7VBh1HZjWEPshEakb8FzASU5e +B0sAiNH8xZHLIzAwpSIIehZjNFM22gHE2Esb0PFpgdFo8PvNOMQk6qTLY5aTHpjDXXUWUQTjGaVr +U0EjmUMqZxHcdHEsmkC8WFpf5N1dgLVWXbXG156HHjk16hllt6sHt89NTLqXtIbIhigjmEHu6Jqh +yB8DQT8RoIaEEWhDmC39DfFmxVsXOb3R7AxT5DxPBpaoG77lQAQ8yrYalF2DCEx9GssBoGahWwCa +PhdWO3Aa+1mVyscdmF2SYIPnajpVtleF5JZ9smNBehAZc9Z4p8GjSkUnUbYiBiHZeXhc/7yxIjAE +7YHoue4IVHROioC2ZtO2snkAUI8IghYi0ygkNwb9bCuet5JgROynk5Jl/sZ+XAfVFBW8FOlmBNGy +uqKGN/FkV9YdWLO9Q7QiJfHWztgjVCIJoi7wqZoeNIgcdXtGp+7UAoqm6wNQE+ndqseTmlVXB6Wh +P+MzvxIYF+XtGZ2P1ghgcCex8OC5nIMCsEQCsNCA5BAGi+DN/Shz4EMehAAHX2oCRDtSSRqg8jCE +pFUV9HBv5BPWiiDMJuLYLqHt0aZhsqoMQVJ8o9OcaQE3KccjeahY7KHp1FKTAIGSURbcwQusY1F5 +sw8Wm51nyw4JmrKPFTr0FFXoieIIVg036AEDAorT15QoQrCaMNW9i2qEiCkf2BnxXMGJDcbA8Q8F +h1nHQWp0IHDOSm/lpEcEavQgdIUaS6JQihuBRY3BsjBrSLovsz5NpXEkdyv0YxZzmy0qFtlU5do6 +6pgK6orFOjwUoxTeyqaCNX/URRA1cwOrA8HEE+ZUrQ7Uay2JjGAE0SKmZqFfqDr0D1SOCOsUBec8 +CEGKJCVWVbj9XNQp0ZKeQCf5Iy2jFoLoiTIILoua+cUqJYU1iIGoK/qcAq6UhOZkK5YZjUL0XsHZ +ToxIhjr5fy05WUhDYNbEmLkHWStjY7C6pbv/tidyIbBoMuFsKRqln1cv5ogqlI6iWeNNreRND7Rr +xcwIpIxKGQu4ajjGiCguPyJIgjnGAYLmHMTZIvZneJ/LC5NjBXkm7wVcLZ23Zg3J1KypQ3SC6ZkE +ikJRoO4cJZleV+wMFsV0NHyleW7nBByMMjXKilYDZbBqMZYFiX4AS+eNlXfKkria7MrJRerL5cCU +hhk0iJmsxkuhU28X36+EwaayakIvjcC9ghclrM6aYxCSRkwtuLdYFiNFTNXi75FMy8lY+KjHyrk9 +SVMUNq8XuoZ0lcxEIQysHIHNZvG32YCiNGMSTe4ZyapDoHfAklWyZig1PlTBxKrJ30/5Y4KUur43 +VMm0o7OD6mEmGXcv4NzsKAUqHHpMsJdWIA/B88tIBHuYrbBXZh3qXsAq2vs5TqxDYDlokryJsOXC +UdiZtShZ9aJS+kOrGs47J0DGaInuXB0p5vcKblY7AsZYyjmIn2dlf7f2+xzJc6oJ+GWVABF8Uz6/ +GqBIfwwiUOG6iEk3c3Hg5wMYuslulef6+XOI++gboocKAFbUX7B0K8pErNMcVkrGxZHE62DwhzYv +dGPJAhOHyrtGvq+EKwCCXlfw9/BKya++F72uLYHAWAaJdJpVDnktLdiYU5gaxT8WgiR7/BtRMtbE +duusawV1BFBcraxIEBVBY2+gg5esKk2wUJ/4MLVQXqxNuCG7CpWpS+ovkjospKSIyFtY/ipd88yy +ZbbM7xlfhroLWIK9fBRFgRoC5ZjMN8SXBY+/EV8wY3PVMj9ck2hZowXClyiHnpYVtUkrJYMBjHY2 +6EuWWnnYWsOIC+ohuIMhXtQ0by4O2DeyoPBUGK5JpDhhesa9gOPaggM/34AjWzFCM04ovPUTazOq +3rzmtTkgsxLYgleX+baosMVIU7pj9UChQLU4eOG6IcyDA1dMkzJ+TQkDeZTPCCOgDhFsnmls65hj +WC9wTApQ4uvCKownHxKt44Y1yVDVX1YK1fLsQQcDAzEJV2rIYQnBQjTMLF+/kVUFKipxQo4BydBL +3YpgB8GwctRqwS1Lb1/QpVXVMxms2A06NIuo5Hr+BAt1yQBV20cpFJFXZU5cmLAZozu46+O0Bm7w +GoIZnmPi7hJLuUxipSwzZA259Xg2RFlYNH/72o64heFUB0GnQPZIYUMaHbUJuCgWtUXvFi/4BcOF +jcGU2C/FKsMqSwhETrm5OGS4LH6clpvd9zJ2c6wyCckkvN+AMQTTyo2WUiRicMR7Tb5E5TIMyJxL +UqRtaIuHs2MesHqgUMAIOnhhh+eAdUWtI20oUKDKNKG2t/X9MqwXeIA8+snXf7d79/746pv3r96+ +efHurzc/B9BP/9vPbv7uq/fvXr357uanX/35xfcv969fUr3pP//ur9+//NnN/4GN9g82+sWRm/yf +8Bf30e8nqkmL3lQsQASaFpVHBwWVytUuFFV2BceDFvROvE8h7aBcV5YsZM3eb8CWvTLPJiyqeZaA +eaGokCegDh8njwxtqT5IGZF2mLxfR0/BOG9FJHSkMx/WGwkQICPoxFpb3yvDeoEDOHp0OrdQhV/4 +YaZC8mDUBCqCvsQMyjvyFXd81g9KoPsmExdKN+ZyNh2iJq3yfgOWMiZMMO/iyDE6jcedg92qOqBy +d04sBl1bzOAK6wZrBwoFjKCDF8spdVhnPp8wUiBAZa9Sa219vwzrBR4IewNe24S1lUGN1Ssl+Mob +MHcjcTXqXUORktCxuirdTWfcBcVXMFPVlfsNGOsumeOI68Xi1Ku2w7SSY4d9I34rUPnWsaWURBxR +dqC8Xlmr4MAl2EakM7uSx/cLUFmrpFpb3ynDeoEBwtoZK1jj9QIr3hVE9yXkSNeMgPlRSX2NdqUD +Xo6AkOzUV/ZRVZk3WYwnD5UsSaYXbFxd1VpUVdZXBypzQ5njpi0u67BssHYgE9DFCkMDBwVGpDOf +0h4JEKAyV4m1tr5bhvWcA8xbMDvbUum6jDnQVRigdbdI17yAYk8WAYZOl0SXJaTMl3yhjdBZC6aV +II54aPV+A04WycWCwoVUhSb1ULhrpfCOKUDuGno5dd5bW1xzIW6wdqBQoIOj4MCnbEasCx5I3FIg +QGWuUmttfb8M6wUeCHcxcQglbGykbqF11TCvg+6kiHQ3WfKXkBWWu8ZZvBuRsQZMkrvfgKU0NtPK +5UZp0kmiAeqcYrEIUDmbalw2baMU8RuwdqBQYNNewIHdkCPWhQuYjRQIUDmr1Fpb3y/DeoEHwtmF +zv6RbImVKtiDzrPW4ZYfnqbu2o9qV6fIllpqY9R4hTAbQgNYKz+hoz6tYuZFKY43Y40ptUwIqOwV +e923xQQZtXgMqwcSBYpAweE2WqhBkS49gNIJEKByV4l1bXu3OtIzDjBz87pWuoBtyQ== + + + SyDpMIN2OvI2iCyo6DagS5bsCh2RS1nf1rQ0vwdHy5yfUSVZROxrBZtZVlwHqgFS1po3bTHOO68b +rB0oFNjgGFizOxzWoIFmRwDDlLVKa2/p+2oozxiArF1Yw80psK5wft1PZ7BeTdTv1mLHjDG4JMVf +22L8VSjGzmelbxXfS7yVUyxYlr14mJl3YmP4lnynw4CyA/nt+vEO1UCFw9nnXX87w5S3Sqefob2b +hnLb9y80T3aPM09+L969Rb178M+3U5FrRX68mrdt8CE+o5guKOoie8h0vN+ASw/f4lkL1mNXy4C1 +sowGJH5bFoBvi3XzYtlgdcDkbFoHDpx+OWLFC0fqlgIBMgWdWte298thPeMBSaovNxipKmFi0iQf +8X4DDpzsTxUc2drHbNpmxS3nuDqgdowT+4e26LlMzaPsEHk3f7qDC+eRjijrLfoxNq8XoI6sktrb +uh51rOe9v5axyPkss3SOwpL3G3BA35WW1wQcspFpxRfoHLy0OaDytqx52bRNclh+wNqBQoGyV8G9 +4prDWu3ErKNAgIygU9vbun65Om5nPLiSsUh5Odl8NBaFdGBUIoJyN1EeFHIMdDSdOkuKHqjcRXfa +pi3GNlveYO1AoUC5q+BeudNhLVbuyVEgQOWuUuva9n45rGc8uJa9iESQi3VlJ4rMXQeVYyQM7D7n +GrJylwurGlC526LOXWub5YDCgLUDmQD9vEJ7ZXKHtNhNSo4AASpzlVjXtnfLYd1y4Er2ImeJLaoJ +Y23C+w04cI7IMyn8q4ZZq7JUi1woZUDuGpWQWjZt8axoXDZYO1AoUOYqOFnRRYc1W5KTo0CAjKBT +69r2fjmsZzy4gr1I76+rDFmNmgrhwIHTchkYFwXS9sn9Eqe9ApWzi8hG1xZPoyrQsHagUKCcVTBe +wjBrvWrFmu34i6NAgMpZpda17f1yWM94cDV7EeUV5bCRewoT+O834MDJLNyPFnXeJTkxihW6g05x +Aip74zKft51zXc6wKlAosJkvYNhl5Iiww4qHdsKWAgEqAqXWte39cljPeHAtixHv/2vqxKEiI/dn +YL1SA4GpqvnR+wYbZXVA7VuKOjyubY9qOqwdSBTY8BjYsi871tSVkE5B8gpLp3Zo2/vlsG54cF2j +EXeK1mT06ATA/RnY1ZhfzDeBYyusKGpoV3VX0M2N87JtWUMIZyg7kF6vn+9gPVvhkA7zX98vQJNP +5i+xtr5ThvWMAd9wHsi/QWzrQ6YjGzL/KtZjzBbZ8NajAxfOL3jGxaLpvJSPcmHZ4RZ9mIyYjrVh +KUvJt03izB+wOqC3Hh04WNzZYZWzWyMFAmTzs1Pr2vZ+BV9JfMMDURS/yHCkW4g0YQI3wPsNGJMR +ipbm5pMQyCxXZrpzkIDKWK4Y5dtiaduV98WO1QGFAkbQwUHT6hzSxY6oOAIEqHxVYl3b3i1Des6B +6xmPqEAV8fNTQZT7DTiT54fJbVQpCPllRz9AwZKcDwFy1xqWmUxjWzxRU0IbkDqYvF/HRsGW/+yR +Lpbw5wgQoPJWiXVte68c1jMOXMt0xOrzKajhVtQu71C8lCTxaqqc+krTzmpor3I+zYDKW761z7fF +9ZyUt4rVAZkAEyhJeasHmxxSMJhWuXSiEyBAJqAT69r2bjmsWw5czW6MRXNO8FbTvHTmKjj300WV +D6ryml6NuXxO0IDKXD4PPLRtcrJlwNqBQoEiUHDwRdoVa7Az0Y4CASp3lVrXtvfLYT3jwbVMR7zh +QIL3kbN77zdgvCuQnT94QUFUk0GT7eh2gQHIfVtx242btnQ5y7rB2oFCgc39WZnTmr5LkQaOXI0E +BBdQc8S6tr1bHekZB65hOKJUmmcNeeGpofsNOPnLHPiCVJp0ksmM1zO0sDig8pVPBQ5tsdKi8tWw +dqBQoAg6WEs2O6wYbynrhgIBKmOVWtfWd9ewnvHgaoYjLp0etJpn3cw6ONlVs3iBBh0M4XzSWdlb +q/qJCajc4RtDhraw8RRlr2HtQKFAEXSwJnc6rHS8KW0oEKCyV6kd2vbuGtYzHlzLcKQrR4IsiWxz +10NNiamamImUxaximK9fNaB2rUoWxtCWaz5tsHZgXjtrOlRvaeg4sTaHAfX9AtTPK61D296r9QIs +27y9grmI5Oam5mgxTcGD9RQN9oIOKW0GPafZzwSbNWFOZ235+rgN1g4cV7WBtWrTgLW2cEZAbZ21 +ndbesnfKodwwgM3Fjxlz/xp2HB3U1/nQ7TgH7qXfsbD/WsRk02phiW4Vaw5IzMhYFbS2sW1GN7/q +cq6gvAK9HefAXcNyWHsyiKPAJ4M4al3b3i93zP2MB1ew4wDpWtWVg4WE7jdQd2vFituFBH7s1gw8 +Ib1GB1S+ziG1sW1G/+kSRqwOyAQoWxUa9Lo2h9Mymv37Bchc7bS6tr1XhvSs/1cz4vDai0WHK2Jd +rfsNuN83ivUxcpN5rHWD6MaGtDogs2aWK4x927zYDtWxOqBQoGPTdzMq4jViXbjGwUiBAJW5Sq1r +2/vVsZ7z4FpmHN4Vkou6FedmzFUopnZG4W1ISY8TLOztTFTjKDqg8laVq94WV3PQ6JsgdTB+vUkT +gUarA+RwBrsLz71fgMpZpdW17Z3qWM/6fzUjDm9WaTpmVOz1fgPOXJCD6Y1RI3J6VyP0jcq5dKDy +dkl50xaAdPJ2wOqAQoEiUHC0m1kc1mBXCTgKBKjcVWpd296vjvWcB9cy4rDqTcxqoKoyPECpFCyT +mxaN1EuxW7ryJccO4441ORPrWtK0U6+fohyApgg7KB7kt7JDijP4PUxfH/we1il1bXufHNZt969h +wJGw1yGkc5H3G3A/OU5VizQHV3OOoVugElYHVLbSsZRtW7qDaMTagUKBIuhgvRTEYQ1WHNxRIEBl +rFLr2vruGtYzHlzNgMNls+hAVrxC7H4DTqayIsFUOAiBekoQgC2swQGVO6GUZdO2mc7qsLZBkVVX +7QD2a1+whr45dQrCuJEptUPb3l3DesaDaxlwSAPVreG0/9AnrwPPVa+R4qKLZOxEY/ka1ClCQO1b +qxrmt7YN7+WKG6wD0KzbAaxFLgesa78Jq1OwWmRroNa17f1yWDc8uJoVh6XLmg4cjFafvB1MJU0F +WCxC10e+iiYax72krPN5W76EeoO1A4kCQ2BgKUQ/IF1rOXs/wvTTnVTX0vrUMW66/+9nw2UQUeua +nP1yvwHLtXjPuHKg9K9abRqsXWgBun42EGsi5lY3baM7cq1YHdDbcA4s5dJGrAuXABwpECBvoJ3a +3tb1q2M958EVbDi8FmddxIeSrL6JA2eL/eMtK6HnojW9TIRrZBiQ+bJImaihLR6/ndOI1QGFAh0Z +BVvVIYc0dGZ3AkI/IO+JDZ6F2i1Des6Bq5lxuYcJE5/Ou9+As6uMGVsR6yFp+Q2s0jqvDqi85SP9 +Q9tgB6INqYMld2jQgWO/R6AjDVZtzBEgQONt27Z1vepYzzlwLSMOy3uWpkZMNs4qMPNFwkxtKhYB +tutyYFRbhyljudq9b4llhcMGpQPSy5WtCuy6lUOJOdlSLqa/XYDKViW0t3Vd6li3nb+aAYeXOdnB +HCq7d78BZy51+kwuN2oaUtb7FVCKL4sDKme5UNXQluo0thGrAwoFikDBVgXUIcVaLlakVgkQoPJW +ie1tXbcM6TkHrmW+4S1XlmxGEun+DCxB9NycwRxt/4Dp52DMFzy8qHF9bbnIxdYO4wDrUtKBoxV1 +dzgD3zk5vl6AxtdWwtjWdaljPe/+New3qh5s2b7r3GsR9TN5We7uwPu8Slx0vs3K1qUuyQGVr1Sc +d2y7YOWQOGJ1QKFAOdvBWrzMYe0lWx0FoRd88NT2tkN3Fes5D65mv+XuxYt8r+r9Boy+uaZkqG1b +7J6veV2WDlPWJsuZ7C2pmPKA0AHl5fr5DqbLU0ekvVqne78AlbNqWGvLoZ+K87zz1zLccGyphCVh +nvUA5QiuVuuKjuvx6KbFrotrqtn3M3pldkmm2hYlYlIpp1hH4KwZiQNYHcQD1pJbOKOAgMZbo9a1 +7f0yt/MZD65muGHNsKgH8im8e38G1qqZCLQ9wI18D2kTUDvXoiZB+ral1TOsHdjjzgPYbvv1WE1W +9ve3Lmo7pdau98jh2/T+MXbb8q+XSFnQ1+LMlvsBmLXmH91JsIqznXcyuyNFQMSHqnezuXYbTKOR +ZBAMj/KVgA4HVspfNi9jGH+yU2UtjfaOcNvHax2yA7zFUh3o0ub7DThbyhiSumZRdFNqeq1EadED +uVt4854GMaxt5FKJI9YOFAp0FBTcA/oOa7BLaB0FAjTGCrW9retXx3rOg6tZaAXXig5ctCM1Dow3 +HskdKViEI2rJimTXfpTFyuMk9d7iFSezWsXWViqkjlg7UChQ9io42hVXDmvQC0kdAQxT5iqt1tJ1 +qqM8Z8C1DDS8IcTquwU9Z+2gGU/46Q0j6rvql6Dj3SnJgZSvadaYj7XEI/g1bHB2YHKruUPjcMvM +rOYY3fPsXy8gY+tqubzS0nWp4zzr/dVMtIqzW5VQEsv3Z+AmgZw6yyXgvKCLXiaVSmwOqKyl4hVj +22DbucPqgUSBIuhbf5JjZA5rsEK5jgIBKneVWte298thPePBtYy0StJZzT9M/L4/AxsNPWxulxAt +WLciOKCwZtMscNlTj86D6MU24Zt6VbLYyDqBZ72/qr9VgMZPodC17T1xCM96fQ3bDG+DC1rIZi5q +mw1gt3fx/do00eRaROzXolac1ZikjbppoMjaBrw7ZIvVA4kCZaqCu8rmsParJBwFAlTOKrWube+X +w3rGg6vZZriB1qgZrauqBg6c+j1tQLBUO0qW44E3TqEM60BlLwz6edu15bzB2oFCgSLoYH8VlmDF +6oIpbCgQoLG3nLX13TWsZzy4lolGwkhdxZRycL8Bp76xY23FasyJOnWorlUHKnNgY29nbXPTckNO +tVBgdLkQA1jMZ4c0ck7jSIAAlblKrGvre6tIzzhw3TN1wyhjSub9GbTJVTd0C5t5r1LUXaR7Fwio +/FnaWs/a9voshtUD19j526FUGXdEOkzp7l4goDHYfGpuovZuGdYtB774TN0jC7J8yBT8/b9ZfRZg +HqyAdXvCzoOtkspcm8U8rebKXDFLldU0V59lrnSz7rppG10VD8MaXRUPMxc92CqpeKxWc8VT4Oqz +eGp7W9evjvWcB1cyHeeKEReL/mh9Fg/mYirYsVVym6zmCnZMI/CuPgt2LIex5bpIKWlD6CCuOosH +Wx2VjtDqrfhXu9osnkzXtvfG4Tzr+dUKeVa8E0etYavN4sFWRWWudHm95JfK8WXsHHzzRViUr1H2 +zN52neWaSo/VAV1tFg+2Kioeq9Vb8RS42iyeWte298thPePBtQp5whDnYMfLtDaLB1sVFaS3zFrW +V+qtYN/4JtahNgvyIdSx5erjRIrTAV1lFg+2Giodp9Va8W93dVk8pa5t75PDedb/qw== + + + 1fGsWPVb82S0LouHWgUVBLZ11QRorrUCOPG4f3NA5azmUPa266y11h1WB+x1WTzUKqh4pFZrxRPg +6rJ4Yl3b3i2HdcuBa9XxrHgHx6p6hDqRPNgqqOAU4auEXK0V7JpWGHV1WZANc9i0bK7enuH0TjOr +yuLBVj+l47Q6K/7triaLp9S17X1yOM/6f40anvj+WQ1/q8niwVY9BYHVgpNSZwX7pRnVriYLgtU6 +cW1BUGatoGdYO9DVZPFgq57isZqZ7ylw3gBPrWvb++WwnvHgWtYj7QLdSNOaLB5sFSFohiSddVJn +BYF6wNjVZEFwrZuWzRVCNpzNF03WiiwebLVTOk6rseLf7uqxeEpd2+psV8N51v8rWY5EmpW0tXos +I1gqpyAQ5LgvvSLAtfkiLdq3Yunqrm1ZWzvD2oFWj2UES+UUjzV1JaVTkLyS0qkd2vZ+OawbHlzV +dqRpsmqNFavHMoKleArSIjcfNK2yQjNq0eiF1mOh/oVtu1521SHsQKvGMoKlbkpHOawmfberxeLJ +HFfJ2q/7KPkM+L9ELZYZwxS2hLul6MBWNWUuq1X2tvoqsDJsQrpaLDPe8DWnvGkb5X7kAWsHekvR +ga1qisdq9VU8Ba4Wi6fWtW1OChvWMx58ef4nIpX7P5qrxeLBVjUFSe03PEh9FexW56DVYpnpUjat +r2lt8WZqNewNawe6WiwerGVTPFKrr+IJcLVYPLGube9WR3rGgasZiwVzUNW7YLVYPFjLpiC5i5xl +tvoqM926twQH5K5lXE3btmAw9KskBGmHuVosHtzvonRIrb6KJ8DVYvHEura9Vw7rGQeuZSqW5q9a +kRPWHmpVU5DcOUdfdoW7xpdED7VYkA1a5821hfUcNYZjWDuw12LxUDt965FafRVPgKvF4ol1bXu3 +HNYtB65mKwIN1bLnrBaLB1vVlBmvl0xlrMWCfWtZz01aLRbkA+hLadM2y63xA9YOdLVYPNiqpnis +Vl/FU+BqsXhqXdveL4f1jAfXMhcBc5LbPlwtFg+2qilI7ypnPa2+CgLnumxrsWCX1VhwbTPeuR02 +WDvQ1WLxYC2b4pFafRVPgKvF4ol1bXu3OtIzDlzDYESpVK3coNZi8WCrmoKkVrmly+qrIHBZV190 +Rflaknp/rG0Bo9mCmIq1A10tlhEsVVM8Vquv4ilwtVg8ta6t765hPePB1QxGHF2r/Wq1WDy43xhY +8D602RywNm1hCIMDKnea1L53bQt7zUesHehqsYzgGKytYo1sUY4UCFDZq9QObXt3DesZD65lNCIN +sxkaNnc9tOWgMiGHaKWxlbAU+oGEviDjooHy3jJEnYwOZQdmm7ceGpasU1RxaiEE/3aG6ceVTt+y +d8ihHPt+rURQIjbY/RbFtAQPloOi1AkzE/VmRexDbMUBbcZkzeN0bWu2E7sdaweOK9rAUjRlxMrV +VUYCtA7LSGtv2TvlUG4Y8O92hm/Gs0BJT1Z0G86BrWLKnGGHaWpqSG0VWFJ4B68HEjNytPOMri1G +2FSPM6wd6G04B+7alcPaL9pxFLg6LJ5a17b3y2E948EVbDg8wSZX5PU6LB5qFVOI0lmDPFJbBXuV +5QC5q8MyZ9R7NDZnbYNdCeqwdmCvw+Khtv4dzn6zpHu/q8PiaXVte6860m3/r2bAZbw7PerepHVY +PNgqpswZC1TOotxKkjt2rUS7WU7rsCAbeoTb2kbbnRzW6DdNrcPiwVYxxWO12iqeAleHxVPr2vZ+ +OaxnPLiWCQeYa9CKElqHxUO1ZApSq1mqVlsFe1ajRn6sDgtyQRUr1za66uiKtMN6HRYPtYopHqfV +VvHvd3VYPK2ube+Uw7rt/9UMOMCcVlURrA6LB1vFFKS3JtV6pbYK9k1vgHN1WJAPLerYWFt4RdOj +Uoa1A10dFg+2iikeq9VW8RS4OiyeWte298thPePBtQw4wKyVdnodlhEqRVOQ3FKC3r4xK29bUttD +67AglEITQ8tkWSQOpQeaEuygVjHF4wx+D9PXB7+HdUpd294nh3Xb/WsYbyTsNRPQ6rB4sFVMQVJz +VY+B3tKYsTKtVg6yOiy0twT1WVhb/NHuQlSsHejqsIxgOX/rsVptFU+Bq8PiqXVtfXcN6xkPrma8 +4bIpmjRodVhGMPRylX70YvySNozARSrQpZ5iTKt00Viotc1OZzWseVBk1U07gMWydUijuRcdAdG5 +Ih2xQ9veLUV6xoFrmW44wEGlj1Vh8WBgzVJV2Oq1U+gPjUGAIesZjKCJiNTj2dLstW3Gkn/rBmsH +uiosI5jOdoxYY9+eOgVx3MqU2qFt767DuuHB1Ww4pG3VFF+rwjKCpV4KArV4Yuy7Q7GC4nHcSWJr +5217OSuHtQOtCssI5popI9LVxry/X6uwjKT2lr1PHeOm+/9+FlwqeObTZ0veb8BWLwUUbljEWh1T +KquAcHOhOavCMqdgyqhrC0o/WKwbrB3oLTgHtnopHqtVVvEUuCosnlrXtvfLYT3jwRUsuFSsEL6r +wuLBVi8FSa15tmwydjNAt1JuHsjdini7+rYtXuStpckMawe6KiwerAVTPNLQ2dIJcFVYPLHBs1C7 +1ZGeceBqRlzqAUJXhcWDtWAKklv63R5cWQW7llOLDqi8TYveYW9t8biOhvYUaYe5KiwebPVSPFKr +rOIJcFVYPLGube+Vw3rGgWuZcIA5LXpjr5rHDmglU4haCTpqbRXsWIlautSMjBTtEt/eEi+f1uim +oexAq8LigV2zciitsop/u6vC4gl1bXuXHNZN569mviVMxdUbLKwKiwdbvRQkN2eN+khlFexav0rQ +qrAgG/SaeNeWboeuG6wd6KqweLAWTPFIrbKKJ8BVYfHEura9Wx3pGQeuZbwB5rnf8qBVWEawhM9T +duZytP1jtfvUom0fQGSO69gSD3/kOmL0MCclO9jqpXicVlnFv95VYfGUura9Sw7rWfevYb3h9ikX +V7gqLB5s9VKI1kXrQ0tlFexXm1dfbkX52o/7WttoGb8Oawe6KiwjWOqleKxWWcVT4KqweGpdW99d +w3rGg6tZb6n78FwVlhFcJfU54dFyvVOs8NFE6lzTeEHRY4wkAVPNZ21BgVk3WD3QSrF4MLoCqiIo +loOpVoOjIDkLw1Hr2vZ+OaxnPLiW/YZDnNSytGIsHgxUrCpsVRlHX2hUcntdPgIqb9Zmm662xaxU +M98EaYe5UiwjGDQdW//Nbh9f67IhQIDK2245uLa9s4b1jANXs96QiKRlra0UywiWs7IEXHqsjCPB +KbuItpViIXDSs3e+7azWl8PagVaKZQRLJYERaytn729d3nZKrV3vkcO36f2/bymWOXZ3i7fgHFiL +qMwRtc6hzMoco52GtnIsc0TFfijbAhPDElQ7ug7zlpsDWzEVj1Jrrvh39+osnsje0ruUDOVZx691 +zC7i5bdB8xe1QosHWy0VJDc1zYuSqivUMzm97yq0IBP0TL5riyf9VdszrB3oKrR4sNVS8Vit6oqn +wFVo8dS6tr1fDusZD65mvcXsvM1WocWDrZYKEWy5aHKMGjuXihbAsQotyIhU1WK2tgtqmMsGawe6 +Ci0ebOVUPFatu+IJ6BVaPK29ZXbudkN5xoBrGW8xb0qk3G+gVk0FqVW/ltVdwY51qWE1WpAHpeqZ +QWu7nNd98cDk1vRyXk/FI7XKK54AV6XFE+va5vPKL+ccuJoJFzFVWU+hW5WWESz1VIjeXoJfgoOx +2wSuSgvyYa1a4dTaBqeWGFYPtCotHmz1VDxWq7ziKXBVWjy1rm3vl8N6xoNrGXGAebXDUlalZQQb +DT2ormetIvmofekW7ll025a1xdWpapxxq4OsVIsHW2UVj9NqsPj3u3otnlbXtvfJYT3r/zWsOMAK +Osa2XssIdjtZyOtYrwX7pRXUXL0WBIe6qddCUw7XzYjVA61eiwd3vc5htRosngJXr8VT69r2fjms +Zzy4mhWHusqsfg6r1+LBVlmFCF40gVJzQSIqlnophdVrof3FEihdW70j3mHtQFevZQRrZQSH1Wqw +eApcvRZPrWvru2tYz3hwLSuOxJKlSmq9Fg9OfZtHn1LQLZVrsGDfmqVQWr0WWqur3jHl2qZV6wp5 +RWPVqkI9Z2IAc2kVj9RqsHgCXL0WT6xr63urSM84cN0zd8Moa72WESqVVYjm7ufiGizUP3MBWL0W +mlOmvbq2YACUDVYPtDDpAJXKKh7pMKWdF2RxNkQ/F+4mau+WYd1y4D9kvRZ3DO9LR/2sYAvegqRG +HM3F+w04s/8AgLhdzlVrT8jdzHO0nEAB4hAsC+x3yxzHtsv/z967LkduXGuiT8B3qD+KsHds0MgL +gMTWL5GyPT6HthyWPaOIExMdFJstccRLD5ttW/vpz/q+lQkkgCIJVDfJKnZJIbGwgLyvXLnu2SJ3 +hx3UmgNjD44PFNwfHASfjMBdzhdjhHG3IVob0zUig44RSNxgnFrqWPy2DEgkkDxWE8JkwKxja2bs +RHAGvfCQfPAiGA0yvEozoQJtwL2gwl3pQGwKzRAwY8oVaNUXKiB5v15UV7ZIGMd6wS/YmBWphNmS +UkSoNE29Djo6yQeMTi+6KJGlxcYcL/S10pkI2JxdWiR1qoCRq2mSH6NTXSHeh4pDxl1aKTAcfoYW +Q7ClUdKvwLpCriQrfUkCF0NzkCcGQO6941iB3lBgSxzNwgmdEIxbvLBytrQdR6yRGlHJTG0hRlZ2 +Lk7gkFIi0tKlyxVlFlJObZmvulVgVLnr3FqN3A2uD+EEQkVDs6xDVLRhIaN1KSADkGEaqumiHxMb +MDarfIusL3t+FccWbSsCpo+sfms0CWUAnVdRChyjikKCiMIGRuLadnaY0MrZ6om/zO/SeSjqzb5l +2YVLVln6wbKOkSdYtDrecCbjrahvxEK4WpNpCTJWtokrKWd12phwWjBx0TxcShM+l7XnotURE4Vj +CoozSQ8sP1uTZHwPkpT2ZGt9SjLbql6z7VL+BFx8row6gmctxZpQa8qaszirsBPq2qZ8AG2pySB0 +qktlvjH/Ju0wYsHx+tU64UHQdiT5q2/+FN78/vrt0e3HDz8LOb87v70GsALwzV9urv8qNP9OyH5R +KPjo/KeL6/zFwV/e440p9dX3//OPf7i4lGoOftf9lHPmdz/8+eQvN2/P8XNwAN374uvVb/59dXkt +rwrp1u3Fjx/vzj/gqJEz7PZ09MXZzxeXb2/Pr/Hern73p+u7/h3+dxdPst+UX8lB9o/rizMBpvMs +//Cfp5cf9ct/P/zh9ekVv0Mn2KttHcevs8fx6wuMQ/bz7JH86+Lt3c+zRxO/3uoR/Xx+8dPPd7OH +lD5/9jHd/Ph/zs/ujm4+Xr+V/h3dPLI3+gG+4/6XT+8+zB7loMyzD/WbP7355vL9z6dvzNwxXrzN +eON7xoRv/nNGj7eFTN59vP3xo3D4Z+dzZ0GLzlzi1M5zE00R1ueO58fTD+d/uD3/vw== + + + H2US5pPQUalnH+H1zfd3F3dnj1DJfpQf+PXfLy7P5+/PQZlnH6GdO7Trj1ffnd2d/nPByPIizz4w +bLm5Y7s9//Dxcv65kT6fQ4Hu6bp5oOvrqV92CJz/PScnD3f2gXl/5gW5uJ67HDfvz29P725uZy9I +X+DZ0ez7m4+3Z+d/vD19//PF2ewj7pGpyE+66y3fOxfXj5CQwWDsC+6a45ur9zcfLu7mbJqn6AD5 +sEfb/t235+9WX++lve0Yx17a294R7aW9NaPcEmnPf8nS3rvbU2F7L/9yc/Hhlcl7s4X4vbi3neLe +7H25F/f24t5e3JuMai/u7cW9L0bcK+xrEfiWjGTLRT7/6kS+BSPaFZFP5KCj83+eX37/8+nbm399 +2bYvPTIpFr6WA/PHy4+PcCufgdncVsngw93bb8//eXGKDi2QevJCL8YT/PH044cPF6fXR7qAu8JL +z16bt/OP4bcvcQ7PH8j8U/jtSxzDSyjAtlOzm3fvPpzfHT0HTXuhbf8dR7hDG/4SfAu8BM9uLm9u +/+tfP6sYM5M+/3o5X5UYv95voE8Yy4f352fffXxkP+weRzDbt+fDx9t3p2fn35+dLkG8QaHnlzpm +D04W9+Pl6e3xzfWHu9Pr+es2LfgC1rSlo/z9v9/fXJ9vMMq+4C7JJkVVlrPnaMtVHKZcMJbtVnIU +dslY/nv2WP77BXmQv95cXN+dRPXFS+gjz7+PW/UkMhc7xA+9TmPCQr5h29mgjRQ9i60J271GuyYZ +LTGSbAsxOL29uPv56vxuvgFul4jC7GPvl0eUKdlw8OkWD+QRXjwfiNlmUeEXN38gbqsHMp8q//IS +RPlVWuEXcwPbfnReXtz99fTiMVnyCz87d0dWXq4mXrzjXmgh/3x++9M5ZnKHmKClm+s1rsXTdWDv +MrSxQu2rV6JOW+CVst3KNGP2HkPb7zH0ZQWJHN/cXB7dnp//92yr5mv0jHp7cXk63667S0oMczg7 +rvz29O3Fx/momz7fDe3mdkuc8wfydv5A3m7zQHZNxPzzze37n28ub376dYdEkz1Z2yGy9mqI2fwI +li0nZq82jG0niVnxelxWX81OXxZOsc1bffZIdm2v75zH7euN2Z/Nsuxj9u8b48vG7M/2w921mP0F +hHzbj6TZm2zrj6T5Es6OHUk7mUXhEY+SjKwtc75/Ia/7L3LHb72jxo+zsWzrqdfskexKEM7fZptT +j38+vb4+v/z+/PL8bIk+bVrw+S1Csy2tmw5yWvDFzqFvLz68vzw9O786v7778+n7HTqMrk6lqtmG +yZ2Qjlbp39Xkpxn8nDtq/prPf6fPt5hSbv1JvCzX4DafXrNHsmu89zHCmP+cyMeu0LsFmLXte2S2 +DmHr98jskewKhzc/Evl5Eq9sy+57t8g/6N3F5eUS/6fLbV7pd7c3V/MHw4+fXyv5CJOTGcYe8xjP +LWMfXyTmavZYfsSdXPN14/r18xv1L/91+uvsMQnluzu9XUQp9fvt1YTf3cyXPG5eYCC35xQB5w7n +9O3bi7uLf84Xp/oCL2CPuZ4/rrOzj1cfH/cWykeWFXmBiKbr89PZ4S9np5dnf755O39sfYHnDz6b +zVtkq5ea/wuHMHcBh6VeSCQ5vb64On2x1LC7moeuCHtnmC2T7M5ejTPM/JHsmvZj7wyzLere/YWF +E53CrnnDzM9ptmvuMAtI+bYfSq/GHWb+SHbtUNpJd5jZ/OduuMN8kTt+691hzl6NO8z8keyKsWTv +DrN3h9mWw+gLcIcxX4o7zAKav+0n8atxh5k/kl3jvXfTHWYBZm37Hnk17jDzR7IrHN62ucNstf1n +d7x5Fmy5pcTjhdZwF7MGLvAD3K/Ck63C0+Xc2IFFeLoOvFDju5+08Zs/vfmWOXveLNN8zWKIdueI +er15i+arAXcka9HzJAB/KWq6JE/OnqI9TNHqPUV7jRRt9rLuKdqeor0Sivb7WwF82SzaOabgNdKz +PYe2p2dfJj37ohm0V0vP9vzZnp59afQsN+q8WWaFf2VkbfbgvyAb3n7bzNk2zZe8bWYPfr9tvvBt +82XdFvTXi3+fX/718vTXN8uCHbfRYacqV9Vs70md+b8tcKDMSuwS5bs9v7p5LL3BjuV6mZ9TZJ8f +ZZ8f5TMh3cp8bcuVqeT/5Ur++1p+y9+v5cXqtblsX1y/PX93cX0x38B1e/7+/PTu2wXbLSvx7OPb +54jRce1YjpgP75ElZu7odilHzExu5EtLELMtPNQrvKDwxyWXjW+5p/6SseyKr/5eYbG95OCxvb2b +dqVFFGHLqduGJqWtD5+/uXp/80HY8u8+PkLCdjmAL45xhwjC6e3F3c9X53fzcW2XCMNsndovjxin +suHg0y0eyCPK0Hwg5iWUEbMH8ojzUz4Qt9UDmU+af9kVyrwbh+hCqWeXjtBXmxXxs5yhu2Pi2GhN +d8aBaB8AuDcn7545eVmawm3UKu3NyetmZW9O3puTn3E8r9WcTOICg7Itv15EaPYm5L0JeW9C3l8z +MhnZ3oS8prvboyLem5D3JuS9Cfnzayd21IT8moytby/evfs4/zaTbScFC4ezK9Rgdnq6Dx9v3wln ++/2yNP+DQttrR9LpXza2QZlnH9qv55eXN/+aO77Li59+vpP3xRny4M4e4rjY9i5g3J3HN9ciul/P +33eTcnul24sq3fZ33D4+mr3S7SlI6dc/3Z6fX38tHNj51xfXby9+uvn6nxc3l+d3X9+ev/365vb0 ++qfZW22vjdtr4/bauL02bs3I5vNhe5Xcy3BVJsy2upz+98XVx7tHrn7MlyR9/+yIV88e0/mlPCxS ++WQlXkzf8+0F+fcT7K+X8oj5VmWJk7jHdwjlX5Pa6cP78zM5uG6fwxf+2aWjV62smU2i0hIvlvan +Bbd5DWNnf//v98LrbTDKvuALMN6PaHOfQDW119vs9TZ7vc0XpLeJWhrV20QlDtU3e73NXm+z19vs +9TZ7vc1eb7PjepvLqNB4FS4UeyXU0yuhvo/C3w5qoV5n/owN9FHbrmJ7lRHAz6k3fCH6tM+hsW3E +4dXk0JifsWHLc2jMX5Etz6ExfyBbnkPjee4B2W5v4u0/Pi8v7v56evGYlWJ/du7Pzv3ZufFAtvzs +3Oef2razcylV3vZjcyNheleOzn3eqU+b+205dhev5z7n1JIOvFDj+5xTu5Vz6vufT9/e/Osp7i/a +HUr0hWcX2BW/ztlJ0fYR+c++hWZfrPn2EXKau7X9+wWQbP5Afp0/kF+3nAJsOzW7effuw/kdtsTt ++dtFdHrXZIDvONIvQwDYfFVfoySwLavyuu8T34tmuyyaFab6ai5KzuczXoLNWDKS+YzGS/AZxpez +R/Kvi7cL3Anj188/Ijd/RD+fP+55mA0pff78HNSXqNR4gizau8Nd7ZUaO6HUqPdKja1lhcNrUWrM +H8heqbED4u9eqbG9x+5eqbGNlHyv1NgrNbZVqfGFiWZ3pwscLV+jYPbu9vTs7vTyLzcX8x2btfDM +NU4tPbd/5uHsnC0/nn44/8Pt+f/9eH59Np/jHJV6gZj07+8u7s4eUWDlEhu+/vvF5YJcCYMyz6/5 +mu1je/3x6jvB4n8uGFpe5NlHdvZ0XmbPPZJlWq0tjnOeP5InFHi25VR4fcmOFpwH725vruYPhx8/ ++3BeU+qm15rqqDycfWvL3c18furmBYayz100GNw+d9E+d9ETq5bnyyRfWuqiJ1Ea/f3j7Y8fL2Wy +d0mP+DpzrywQKbZcOHqelCsvpOddEh+2V7Wu5Q+/eh3eY/PHseW+Y+Wr8x1bMKK979iaUb64gaLn +S948En7/us0Udzl/9oqMFOXeSnGz21aK2d5Mu2akwJbbApX4Xtx73eLeEjTbC3x7gW8v8O0Fvr3A +txf4Xr/AN1s0eI0C3+v1S5ud02Ev8W2nxDd7AfcS317i20t8n4Rme4lvL/HtsMRXmNci8y0ZyZZL +fdWrk/oWjGgv9a0Z5YtLff/r5ubtT7en88/71yjyvco7IxbFiG95iMRrzHgxW5jbZ7x4doKwT+P5 +0ED2GS8+kcNIeSBeBW3e5+/YWjL27lK4O72E+L9+vDw9++XrlYJu3p+eXdz9+l8LdMIf7n69nK/j +jl8/vwv3kguXt31nLRrMrm2mPwARd2gvvU6N6LL9shPn6mY5h7b91p8PTOV4/JrI25fDOOzibYCv +ieFeen3mlm+chcPZFYXIbK+TDx9v352enX9/drqEIx0Uen5N+bLVWja2QZlnH9q/fl4QnX8Jrb68 +L2ZwHtkIx8W2d/3i5jy+uf5wd/rYVYq5VmVcbpcU6MbN3ryn/31x9XGBaav7/tmXnDj3arIM1bNz +Wp1fysMiZXNW4sV4rG8vuG9OopHxJbwGpA/cwyeRWO25vV259XXPIu0Si5QWePEZOy34An7yS0f5 ++3+/v7k+32CUfcEvhCXc80svzy/t2aU9uzS3D99HQrWD/NLrtAZswDltOzP4PG7S279Oe5X5M6QT +vb24+/nqfEFe910iDrMPxF8e8SnIhoNPt1fO+OWRL/OBmK1ekUcy+OQDcVs9kPmU+ZeXIMyv0pF4 +qfVs64/Py4u7v55ePCZR78/O/dm5Pzs3HsiWn53zmYAtPzvnD2TLz86lVHnbj82NhOn90fkKjs7d +0UPvb2ncRl7oySnhDqzF03VghxDhtaYi2iefHY1y91IRvd4r8jayGGw3K/r3xTmsd41v28kkS1en +UtXs9BK7QNjNqoz/rvvVQeYOmb/mk430+Q7sr22nGH+Uoh8edx7bXYLBSKo/pw24KxTjFZ5Nzxr/ +ta3ZF/YpPp4/QdqryfFRzBamtj3Jx7Moop55TN99MVGuO5ce43U68S1m3V7vDtp+ewrsDRjZ319x +AuRddEfYZF22fR/lY5od1rgrrLY5nB8btWe292fSZ9hLP7w7v/3Dxe02qEi2ZZ3vTn+cv8a7oNC0 +q9l2Do79fy7TWA7KvFwqro/XZ3/bIWry6rDssFmVqy8Dz/64x7MXxDPzpZCzo5dyMaGwg6jrv9+e +Xn94N+MWie3B99epD9mEVdt29nPDOJNd0Ibo0LaEr97rQ+LK0HPum8vLLViTbZmSzZB176u5pAMv +1Pii65+++uZPpnzz++u33TVQAFWAvPnLzfVfpQqmKSkUfHT+08V1/uLgL+9Zh9dX3/969ePN5cFv +jk7f/nS+Mqti9deL619+e/BR/i1X3x30DjU//CoP/4/8+D8C+tfKr/68+v/+d7l6K9Af/nZQHpZl +2YaVrQ6banV1UJjD0pu6ioDCyvvK1CvrD6vKNQC0rm7lvTt0bd2szg4KdxiMtytrD12JMv6w9laq +NIe2CVKkOqydkRcCKI33KFIdBhu8fFMetrWRb2pptqoaAlyFZ9vUoU3PUqQ5NKFqbfdFOLQ+eNbq +vKtXRYsipQGgcYE9MyU+atA1Y6w0Y6RPlXRBAL5tvQBkgL5tOgAKyTia0Ay+qT2GLA== + + + AFdZAkLT1DpiZ1jIyXSVno3LdOK5DY79d6WR9TH+0GKiTTgMlY5IQN60ZmWaw8pgEgRQu6pemfrQ +WI+GKnRFCuFv27IQ3slw9VtUjNKWAG8CuosWqnbFFqWwFGIvbLXSXkkh7aYHoMHwCw7F2hWHppMn +oKatCCptY/iNrWTYMqu1bbUS1zQrTnzLIWHNZU2aw7atalRbyicyovqwbogbxAHnV8AJW/tUpmnC +imjjUl8avwJeuRKFgGtAIKx86ViI+ChLIPiJxS6Ar14GDfQtTfdc8mP9XfQvY+miLx6bKPI2Yj+K +viOxq0Xf1zgeIrmge5xtDrrIR41pKfp5iVNX5HMXp7fo5jcuQJGvAFepyJcpLmXRr2Vc7aJb7oQS +RYYTCW+KHnEiahU9bhH/2vijDRFra+dN/NynCjBPrBKTwWYwT2xYl5mdsSZ1L8QOhyZhY9VvLB2o +s3E7cvcV+fbjBi0mu7jItzG3epV/FalB0ZEDzr6J+yHSDNKVyhOmhEUpT2DPB8Sp6KlTol/dN4nC +FR2JIxms0x5QOgg8Mj4ilqwLUU2mLs4AVgUI6btdEBRVBG0tOwBE5hpI+4LKivfVKpH1+Hh2QNRv +2wRABR4zniogWefW6FohWWeVsSvorHNV31uMyDWDEcmwZae4ftiYmIbf6MRg7lqgcDd3mN7g+umV +BRByaNMCeNKXkPDEBTSDpaxMt5RCpLDaTVptkEwZYgUsSwApJOMInO3+m7oybUQt3yj1a0PCP5Qh +Xa97HCUa+36TJboe9xjbIV33A9Jcu9r0OwzbKZTdvgLe6W5yafO51Wh/VnpyVCbfxNqJuNH1yJVO +2kQLjJ5Q2HQcWY0TZEhVKn5jq2Ai3dFzmpuB26MKLAQCVicKVvJca7j0SuP0bMe694SdWIJNSWIp +Q1M8ikjujFMeIuF4ZViI+BgJc1uvhqS7WWVkPaf4LjIoEbOFMitB93pmNF4H7kCU2LoUTPwJuyfk +enA0yTOnt3F1PL08BylkvObx5hs97GX5iKCVN9qGoGHQIzKsdK69HqF1s5qesuODeHxSTw/z8Xk/ +ZggSze5J9pitGPMdU9ZkzL2MuBsl003G/4xZpDEPNWWzxpyYEuc6smq1zmkbcRF9Il1u2sjvgccw +oe4YRpCVgOVPVIV0x3TvSZes7RhOkq4q50kTdUvELZG/RP0ShewJZCKiiYYmGjskwfp0POK0Tw6O +fjxInu5HP4sg8pt/XENoeLv66fb07cW5SCXGt7+VamRtTMDfVvDcyefu0DcOGJA5zpvV0U8Hvjos +ayFBABTpoQimlgXGxg6y6rLEQg+Org7eSfNHRyIu/MdH9K0pjVCo8jAE62SeAJHlMDoMLLK8quSl +R09MVctSlTjtG+nID6dxdI0yYhAkZJ6toKWLAGmXy4EDx1GgEHw3Vg8cK79khtxhXVatnv6mBkMY +j5ZKGpNK6hD0HGkaixmViQyNUY6iMXLW1iBoQU+SOvhaDxvXPx/LYWMd0KwDhUNnWqdHsPCGQDwn +g9OWBedbKSS46SxPQhmGTBROG1eCQcd+Bw3CYeP652OeNa72+RdVXelRY1qQd5kA4D8AZahZxh1W +Vs894QpqpQm1js+WNbdhS84QOxUc1zH2tiEvJJtZjjAlCyXONNntJbovdED6XvOssVjI44P0qtCP +/UoL69FisLPZQK1MpewX9I6dAFfLblWUs9jNgv0uufnLQC4TY0NDAuH5asiwtPxCyLoeNbVlHVUJ +eo9Zr6zTdlowKgEbOHBHe9SGk0bkPe7opkElRAmHVSWSCEWTo0aISUlZVDCowlEjOOV5HAiWUX5t +fKkNRUwsgJt1zZ3p0TJQ14SmSoASH8ef3SsWNquuLOrH+RTRmmM3tXzZ9YCIbFZdF4nHq2wQGKgs +QjbOVugF5kEwX6fK+1U2U5xNks5aWMtVnG1Otm+75eBquFanKSGWEAFObcIrrmhCq37RM6xSvCDm +eMUyORCIUzhCetzim3bVoR8R1CqKubrDYbblK0V7ojl7480qboOus+i+9atsn2AvOeKbaWtuJef0 +OW1G34ZVvxexW8sOgN1sah4kJB9pQvv9DppA5UMkCSAatmUPBan0sJHTZtWTFVIePTAJAWkSBF8l +yoRVBpXpiReIW6JtifBFupdwqKeMiXomlO2IK2lrR3v5dHwwQOBK8bsrTV5WGrCyvoq0aKAYdKGJ +G0k3ObvIzRYVMnEEBQbp9QjmICEEWdf28xIFpTqbqIJz6W3/zXiylRQ0NluPYrxkxWhJi8maFyOk +KMZIU0zxqhhhXjHGzGKKvMUYv4vxBlC6a022R4rxNirG+6yYbsVivFuL8XYuBjveaqEhTeAnoMSk +Gd6kU07JSk3CRTmsbepVosAFKZPrKVMxoV16TDc9dSty8ufZckYhlQAXORGtlHVIRLYMUXpNBLjI +qXN8G4sXXfnYRJG3EftR9B2JXS36vupwinw8cchFPmbOStFPS5y6Ip+7OL9FP8H5GZiWoD8mXRun +LztLTdWf+d1x26FEdiZ3eFP0iBNRq+hxK+JfkSOgTB1PWX4eNUNG9mpExSpqj+pywG1oZ7wZdq/K +eJZuWxX5vop7r8g3n3MRMtjARbaD4x7vvwEVaHxkw7DwiVRkvFpHTzqGriM5xYQuZYxhR7z6rxJ9 +6/hLIkgTVRWJCgKLQplxqoppHRcLZHQtBPmenivGWtOzw4rW3kR2ecROHx/8QSSEb3Muu4ayXloQ +lqHmozTbGJfUJKEiPtdt0tRaSJEk2iJEuQgrVfMu0kRkgEezEyEk2zgObPYVVqNqdZzNeAmbjggr +DmbfNNYqeahDRHjdMLpPEk2FFMLGfI2JF0jZNKrtLlUJKPNChRt/1HXcDcIP2fh5MLGCSisINnLs +lQmp4bj7BIdV84o5Ub1eQ+xuoKFMmt/KtzqnjW3iphUEsTrznnqMSnlXrEvwPSARMPzu38XifenY +Rt5E7Ejfj9jVrqdxOPlo4pi7Iadp6WYlzV0+dXinOoE4vyhd8TCMS+A6Hr5bp7iaXEyrm5/rPUaJ +DCMi1qQvEl5NkC/DPWJo4/pvEg4nFE54nqE5JrUKrFf3AqZdBOiVrTN+iWx3/2JcCPVC4u3rlZaD +iUqCksrNpuo7r0oIm/VdFf5GIUJUR8OfzM9oAgcTbOIqD9ZgvEzjdZwu9RgbxugyxagRzhEnQ4eS +U6zl9MmgE2KPED/bE+P9kkp2O4qV1yHfdrH5bmsON2+zGm5wq/0ZEoEJneDsNHVOTNJE6u5xdpVm +uiNKrN8PKBfXKx76umBYT+c6Aqha6SajkcCI2vZfAGOaKiO+nQ6jQypiHU+WCEpYmWh6wtuM7ifU +7g6HhPZFviEK7ojB48nBu4P/+MfBP6is+uHtQb36zW9XP/yvKeCrN2b1zXv5U8pB9dWbbpWv+ofx +Mg9WOUOhMxQZYdkIB0dIyhIjRB4j+ngroMxku4y302jDsQy6ELRHoWYPqQFHh5sJzUCJMV25hxbh +05xOTYnYmNCxxKgDxah/E8LNQlPyPjkA1kzX9CiZHDbrVmZ6ak2OtTUYsOaAHJ+gCcf088nhOz2f +x6e4Fpye9hOGYMw1pA6OuIspBzLhU9L0j/mZKc8z5oy0pK5u0S1vWv4irf+E62O5KXeYM4+DLc/N +lJGHCe2Y0BeUQD86aUr6gY6a2M+6nlLLuP1GNHVCdceUmcXGszxZiPEhwCGND4rxQTI+ayJRGZ1I +4yMrx8Fr6PG/uUbsl1BEeOIIRYQ7DmUYaPNETmm8nOhXKjI7dP6wCmrAb+E3AL+H2sG0AYADTlRC +5k20oossBnNJfdiIVBv4jRQJUD5UurNM6SsR59vSu+iNYGwJNVfrK6eim4FprYV6sVRR00CKkqMI +EkgUD2k0Uc2YyDgiC3uIJQ0kVmoCVGzEsEJwatApYTmQmapKLDAMUJWlP5CrW2iZ20Nv+NwaGAbl +8JMBhoo4i11l8Imq5yvKyCzjrJI+01T0r0hTUGAOKuj/ZAowkUWaBU5CTcE8zgIMWRTlZIyVVRUV +hkRkqLABAahUs8QBHWuZoFytLSt2Ts0LtG45aIEqSLhkexuahEScbhURIfVZVZDqFy2s3pCyfdQS +GV/Wajqjpo3iecAcoKhTf4yWmwLVwwOCDXK7sQeU6aVPIgvjG9NatUt7h9kXTsOVKs4KfqsatPLR +jUGEWEcdUGMVach1tsJHVI1WUrZVQ6tbJBvSUA38b2R1MYEAmKQMpUogAegE0KoKIYJk79r0jYUn +DTC6rOuI4tbR3aCmRwx3ATaWjDVZ/RU3ZOuYSA9ttOgLaldR5JR2gKAOLSsJb2p46GSkzR22jYo7 ++M7UpFbpO9Tlo+aKqFfkDbrSqreN9Mq3yp5RXEe3OWep38BUEYZsPrZiMgGQYVpT91NUrJnHAgba +MlauX8l6WGoVsB7cmy13Q9zXZfQsK2He1KWOpEQoZBXXvnQRz1sXyTUokspzerZIKZccbbR1arcV +0ZsBJhZDdK1DRHanLIRto1VJlUP44bWLwPZg4tfRnyjbO96nVrRZUCoUk660sWt1q6P2PijEhDYa +CKu46Uo57pMcrTBZVJhTOUYqw0ERVC8YSSephnU+NgfrVEdeB7Qn0V/S6CIn0pGQFx0lT7S+6Ih9 +OhCKdCKoBxi9pYiLCYc9lUMuEW/gsBCQMuot+D57HWtABXV0mhqcO2ewO68zNje/RTMGhMHCfFw3 +hxY6O0NfFjc1NsOroObJ6CGywCmuFrRpFfG9CWp6lvZlX63kVHaHRjbfD1eQQB21Ql5O3IClX1ey +aeHn0KzgRiW4Kzvz6GzTRo/mNuplx3lZ6CD7gNo7aTMayv8h5/vvvrm9G/iMQ9pRD2K4967O4LP/ +8frt6sPPp+/PV1d0jP5P+epr+e/ADn1yR9LTGhZBWczFTAK4xKVsgrLBSxkF5WQXswqUoRYzC1Jq +E3ZBim3AMFAAXcwyxFILmQbp4XK2QQptwjiw2GLWgQu2nHn46s1G7MNXbzZiICBnL2chZGgbMhGC +/JuyEZTzN2EkpOBmrAT1BBsxE9jjG7ETKLgBQ6HFNmApUHAjpgIFN2Irou5gA8ZCm1zOWmi5TZgL +PWCWsBeqt1nOYEAM/tSjMorRK5mtOqob11bJj9t0hnYhNhocc2+4jEzp6rvb0+ufzpcHzMiBJAjv +6NNghboyZgbnIvR0Xh2hTmi89HVFzypZuZaggMmklw3/ntBgxbfp6xMNbMBeT3WeqOEfJmhtmXXZ +Wo6gGvkAuveMStCupWpKdXpP9aTWiqy51Jki71V8XeSdj9V0/TtJM6EIzg6eyBR1XTs5SN3pOnhy +MKymRBeGraFi7UrqEgDTjq8Z35ppyKcpvc7exjr6KmIX+mZiF/inarPeapfyIfUTk+aln5ai86Ls +Z2eCSLNcQm2AS2jZCo8BJ03b0Jm+XGEXWmhrx2y6a+G6q4AiPYBHbkEYHXxC4bM89Q== + + + CJVzWzihEpZ7MGilEAYDr2Fp3QjLhlfBN+DsSvjwhUCnUWEUZeRwCCUmwLQsO0RIlZ7WPAhKYJk6 +F+hZwOML8yasgioySXJPDqSPAY7XQBd6wXIBDE3wYOjpSAt1HsmY0Pog55SCGjInIP/QcXIlhYPS +k4Y/TqisaWpVCDZyOCgo1FTHxkqJE8JUKNvHlok47E2R+kfs0mMiDuLkgOOyPNh1pPyIoy/SfBBD +OUdl9rp/m+oYVMF2umZSX/qu6MRUq76/HJUNq2xQcV6ykXNaVvwTqmwO0yz1E50mqV8MnaNswdgr +th072q8pnVc8mfC47mm8PXKUqzQvJwfF4HWE6HSwCl/pZuqagfQgkEFXiDrFpLvFdEjFdNwdyvSo +U6S3/QQWqY5+louEO/1SKCYLkvbrVUzWtJiuezFFjiLHnWINbhVrULCYImqxBp2LNVhfrNkcxZo9 +VKzZasVwR8buDTZuN/vZ9m7yhSx6pCqmpKJIeJURlGIN3cno0knyqhFQg3Pcw2Go0s+rtq3jwRdF +ZpFE4amgnaw55katFjrVOofph85htOTo9zrVrSejGavVFWFjXfOA9Uc73+WvYj+yGlJDfTupF3lv +9GXe51hD6tRJPwPwgSo5h7IV9SzvXsSZyUvrvExaGPRCKRHe2bbvaWq7H810yLY7wMfztGY6p5O+ +ZmkGC2jbbDRFPxlrsEExpf+7oWm8SWbxyVAFNpkQ2ruGs0ZVyGhqKaMP519Ak0X66s10KdExjkdY +/ikGqAA4whS1RI6bW4N3ajQeoickiwkWqzA1mY+0FbLXxfD9FAeyNou80TWY0I+jGA5kuu2zySmG +c1fEyVv7eg1mdUuVIWC/pIPerRvH2hGvnZxu7q4ziaoKU+ukO4RSpqQw08bgAAT1tukwYJCyE4nV +lDbSeDqHVogLLJWOGTXsyhtjTSffGB52alHVA6OxFkHjqos7gcem6gAtULnBOQg3VeoSPfUwncKi +gYLGM1yyRaBsDEik9baMbquBwm3njIloUvygGxD7V6CDUKIpv4/+FX0HDcKmIKxDyVlTmIPpWePz +rWq2yD+p0R0/EJ1xcpBe0lKNQC8SlbJmIHasFAxSTY1eNzUnB6k7OoEN+oVZpcY1TTOYpMrbVgN9 +uBhC/aCajwpsLpkSJqylCm34gNqp/gMoXF1b1nk9RVrErLliTa+6Wco6301TNsZizVR0E5XNWPda +C7gEG8+/NgfGI8OjwWrWQ6Qs0vxluFvkyNsmJ+sex7stcPKwhcQG53yghcQIEyJFDB2ezVT0gpuy +gU7QQYMOzbGHkzXDW8HKgCiIINZIZ2Q+gsiK6sf+wxUONulszRKN6tXXFG3NYQuFbbAtdr8wREdn +G7d6NLdVKUBv6GDLSgNGcyPJY0aOntJEHdiQ1ijpHlEbNWiM6I0aR0YUR4uPaA6AE6ojwE3oDsn0 +UspDN5Ix7SFtH1MfAU7xn8AxBaLRYEyDqN0fbz0eQWM69NWbNZQI+vrJroc2fkKNoGuf0CN4DU0o +kp6PHU2i5ntCleifNKFLVHZPKBMXbk0v11EnPcjH9Ek1zNNpWkejVKk8plIKna7TOkqV4WlGqzKU +zqhVhv3FEP2nFCvfTJMjvv38SlPB09Ufb8/Prz8pyVBIWYaESfEdBOH+gcFB/rCuOPjSeSYIYOyn +Jhlqg9MI8jIaGoUU0SvchaA+fTUsL/CKdVoI9Km0GtofkJ1AJL+qjsGYdZZliI+aZKhGppX4Xraw +8erMKVwYd6p1xnCTC0VwKceQ0UB2q0YLg4/Uadv6YY4hAs5iYMTom7q1DE8jpaEFI4afe8HmmEEl +xM6HptZUEYaenTA6thrz4+QfxqepBxtAFY16QvCrUpMMNUiMgWwAwekW8DUsk/gbXEoyFNTnWc8B +ltZUAZULMdtFow6zztnkaOaqkj58hvFG2s9mpf2mqUAwmskAEMoePR5adhgmx5h3A1lTYHEyRh1D +Q8XwNOvgiakJbxwWTehv3Xq1zARYiWqEwUY/RYNwZmJEl5gI/SbSRIdOj3wAQKvGqgHPI+EAMM+6 +EHMM1fAWBXLaGIsTGto+yjK47jnlGAqN2lbiy1i66IvHJoq8jdiPou+I9rTouxpHQwSvShvnmkMu +8jFzVop+WuLUFfncxfkt+gmOK1BkS8BVKvJliitZdEsZ17roFjshRJFhRMKaokebiFhFj1kR+/RH +sBFnm8rEjEQhOnpWrgkREW1CdRzW2nDCdVPGhAAxMhD9datsANxWNg4z7ivuPc070G0+2Z7qlD/c +w0W+ibnRB1+RFkSrGOPbSDBsWo3KxwxDxjvtlZAVv4pkJ5ry6jzBUCJMiXClLxJlKzrSBuxwbRPx +pbKaXqgxLqXSCa1iWR2j8zwSLBEXjTcRO+s2pheC/03E4UrTr7TM0BQJdp5fKMQEQzL1wXQQ1KG5 +gWIdaIgBsn1DpOkp/w56g/6SSMX+EuPbtAdI0zFwG1OYceA12a06zUyfXyhOHeZWk/wQgMmv227y +LSmLT8kdaCvnKjbdKlKh62Kqhhr7Ns8tVOtG1kCPdvBN3SZ/58o7pXpp6hXzdDe1GaUEArtVTkqd +bk4iudFkLkLPw4AkNxW/SUQbG6kd7CjdR2nXxcOg35ga0Nx4n+9e7UM6ZUyIx06VNpWmbukohSOd +HVITzZBH7CS9WaVNoNuCxnesdINmQLeCBpgHMmEkbU2j53kdz/c2lQlAC9JIo4ckc1woFW1XCceU +1JJzVzz0kR6rJ3dGscMqo+YZoTdCRpSUB8Vp20S2JChKl0HH7Uu6ykv7ddMxJeyg0/gveKzrGIxO +b6hlj3GUnrPLvIqchipOlWceHFeSvOlc6tFYcmpbkBjOtCYjHJ2uo/N3fD5Pj/DxKT9mA4acglVs +HDATY25jypCMeZYxUzPlexJ5TtQ5EedEdafs1ZgDG7Noin0uoqPV5ELGaw4oEgXagX1iDLvkQpGk +kOSUIT6TIinfSYJEohUTGigdTmQtUrVE9hLVS5SxJ4yJeCbamYjriPrGx+Mxgz3HktwGVWd429AD +pBKkq5k6CH5c7brsQhaJsaIlOT0UwQRZa0iXwbrm0AahvRNbsrCVoWXmIPlbMX+FzJRajCFG4ofg +sG9gXpYVgetOCf9LORUn2YUoQazNZ6c5AYgkmq3Jr4qUY+yY+excm5ILhlrz2VVdPjsX89nFo8Iw +1k7z2cXwfwTd11lShNYNcwzx+VgT2qXUf445hqxKkJa5q0LMaNflHXQaB6iRMMx/5WJCu5S/bphi +CM/HMZ2dy7/Is9nVMZudX3WOZ8cxnZ0OuWEKvJjpK+az02RgXcbIGGGaZ7NrYjY7u4oJIMfJ7FpN +MGSY8FJTjzWrVDYms2tjXrNVTIsaoy1KkzKn2pRrzK1iLrsud1pMEqn5b5hdrfPIssxkF08b26Ts +YSEmenQxONX6us4ij5nJzsVMdm3MZGdiJrtgYhmmBdRUcUH70pqYyc6HUSY7zptiIuOs1Fl1mMrO +9qnsjgep7ErbJdvtSub5T7Vy5rKrV137MWlZ10HmsrOrbAzMZRdW/Si7VHYx/roBg820axr1m6ey +a9pRLjs/ymUX0wtxxYhkqw6hiGFeV7xedQueoZM3IaaxqxS7fBilsWsVERWXItolTMqy2Jkuh93x +MIddGVYJ9dnLpo1J7NI4Gt1QtdfgbNIFTWLXrrIdGIO14wYcpLCLGeyqVdrBaSr7PZ5SiyYywBR2 +VUppXPXx4x0pyTINEXLCvHZMBxUhJFBlyqTcdjSsJ2GJzCUql+hgIoOJVPaUMlHTREzXJbbTdEON +5gHA+2HKaNcMU0Y3KXNeXWl4ftaHps52VuykZkvV2OA4Dk2pqul4OFRNuupNNxd5vqE4gUzeytGl +b8aLELNchmydivFSjvJGJ3Eww4VihCzFGJki2WozfCvGKFmMcbYYI3UxxvpitCuK6b4pxlurGG29 +Yrw1i/HeLYZbu5ju/WJAHho9lbJUmF26aCUx8BQ5TumiDalQnQKD4dwaqVQxpWN6WDc9qSvGtHCQ +LhqWjeOULrqnqMWI4hYZMS7GhLrIMDkVz9NFpzYSLvcdGaSLrkI/niIfUBxzkQ2as1L00xKnrsjn +Ls5v0U/w4DxsXL9ORb5Q+bla9Qd/0S12RIf+bC5Gx/eqQ6mix6lhqug2ImvtfBRNbRWL092bmaKb +2EaWKFp3RdQKZD1rfMi4liIR7yLfTXHHFfmW0z6Nt22R7du4s/tv4t7vOLGOQGTc2jhLdFh1hKaY +UKOMNexIVv9Vomodh9mRvowN1UTRdc+qxkTRKSc4W2Gi6IT/QZGEIeSu54tjomi/KkbEvEjUfJ9p +aJ9paJ9paJ9paJ9pyO4zDe0zDY2RdJ9paJ9paJ9paJ9paFsyDSFEMjn0Dlx6K9hZwODXpkF2g6se +hoBP1SIx4JPyCEwmGmUhohUFGkuZTa3/gkEq7IZgVbHNhLeQQoIN0eKud3+1lTPJH0QxT04RptXt +HbiRYpbp5XGu8JabAIt/56pRMxifaQZqXUhjbUz7nAK69TYAhOe67iIky3T5MCGVdYwEKePaGIrI +iEixRjUtlNvVS4FGTKdmDKx/jEyTlUjOCjHY3PdpT3xKZV/FPuFznp8IZ0nJ8yv1EQuH9ItTJ56Y +VqCVuqLSx0QUZ3QwxdYqzg5XSX0UTDRyV6GMAdcuXlMAVQIhGsSdIOqc1JYxQa5+1R620a6QDAzh +sG3aGKccWhv9oFrjIv303IAyJo0vwrLWwStvXMfIaELocMUpzL6RuYkpdHXXIzFDrNhUmqEKFsEy +ZqXwvA7JYdtEm3xFPxOZEq8eErDp6boxQltNPA1vmig1NF7dVWmCKXkJTG16CDwVRLomOkaQpbrF +9hU54FSdGnO04CU5OnbIw9Dr677PFePMbT6wOoZtd4Ovk3tkmh9ofEy8sCJOYUNtu+tBAbQjTjzH +yxjOmIohDakk4ezJJHBBW8K6l2QHva9dD6BdtUm3mqVvYkKCilyMTENVDtBQQJa2EoAMmRZnoq8R +0xgDkDYoNFWqh7c2pGYClYo0IADQQitmYh5sTRnttWtZwugqpviPge2a2CLLFh3U5Ku6ovRFyXs9 +VupaoVn+q5T+W6+Tceqpaenbokn+TXQnI7mqo/6+A9DwGz1BIggpopm+GSQeSR5Son8CQDSBO1WZ +rH8lDhZH+hZHF/P9kyilfPxnTPivjktZxn+jrpJr8kOfHRSDpOkx6b9vshpGeag14xC64pLZsQ6a +E72JHjjs7CjnNUdUTIbN7Nkm2jyV2GP6BnNFsmJtIjX6VYAhrWr6ZUBO76aK00U8VzLGBBi6mqqP +d2W8K9BWUfwPIT0rwXTO5R8odSdGNV3+/xzruotMiKp0MKbmMaa1YDqXUVb0mO+JXvKqWM8vAVAP +tphfPSZf736om2WXfD27B6BWTWl2EUC83o/M1tnBoDMxHTs6bLXD+V0Aqy7J/NlBxg== + + + WqZrWOw0W31MpM7U6o1JzcnKGM18X0dy5RtdZFnGSLqVRxB0aeLwbPKE71OkRyxLd6J0GN9l7D+L +twJw8ofXAgDFjbqsdxcFlCXJw9lBD3LpfEMukAqeBTjES90JenvDoXJEqikrPUPY28TIdHxTgA7d +r6ac1EM5tMroLzGNw5d1hNla4/CRPAc7PtiyZL+FI8eNID9cHdSN5lgZfyhwJNhJXx6dzazy6N4q +TW3gBOqyKrswjjWRG1OGMoMuYymjyLWcqVQZahO2UpvchLHUkpuwllGMXcxcRrFtA/YSJTdiMDUm +YgMWU0MsNmEyqVDYiM1kYMhyRjMGcC5nNTHGDZlNpJdazm4ilHQDhvOrNxuxnJCoN2A6GVe0nO1k +jNJSxlMKbcB6aqmlzCc7uJD9pK5uGQOKYKsNWFCs8QZMKDBqORsK7F3IiDIr2gasKBVHmzCjJAYb +saMkQBsxpDFAfBlLqiR2KVOqFH0TtlRPkU0YUw2F24Q11fN5A+ZU05Ntwp5qk5swqDG95nIWVbMO +LGdSlV9azqZquU0Y1ZGisO0i/7+DrUozVaahX6k5TYORao1Fa6zemRh4rlunRLTj46SrJLUFOCuE +RqLvygTBg1k9ktUPt+QdqRwOxqI5IJHLT/0dlYey6Rq9SBayOQd2ePXodyWu8cW+o7uDw/5Trepw +QMeb8Oly8BoTr1AV9kR3TTCVg3MtUsoKEoP2a5A2Gxx/24T+s6Oz2TUe3V+jb2XihRbl1d7Pqq9Z +2aheXrK2zDOxwerSBrd8faXYJiv8AIKT1TYZY33FtA2lybhvIWrKhEf+HHkgzZCJt13OS+QSjneW +hhgP3NIV06YL1sDttFadZyPhtWo8AUBzkwqPV+sNpZRQlOJrtEZ/BRzD0rNbB0lISW+rAb3tL2sb +XNCZ0W1S9WpA3uUXGUaCsBwAMBAdwgZWn8HNdfQmrBteQSnfmujlTYaZgomLlhCIeZP53khObhA0 +EUXV+pD5UGTQLWJdgP/YIegQ0kgH7eTwU26+9NXR2dz6ju6rr7Lqmzmo9P69twbpNFJ/KdppKuHF +iMdttBT1SB2WI59mp1mMfpyk5QjIYstR8AEC0akJkGEM+omrPuFWYDC5spRUNzSRKCWlBAOeqqQf +83CkqKASqBIzaQDwVRPj+VpwwBgmUnKovxW4aBkSE1LwGSOXMiY1TIYlXUqZGqJY0DM1ZHwCWU3X +80dtzKJ91t9IObyQMtSrAZsVqtVQU1hCF0A3S62WWZ3sYZRBhTIjKgbSFAaovmDMRo2Uv0lu9SoS +MjfHZLI3og7SSNXWre5R6CcoSAdhnil0BUExEU8FR3A8NxAU3fhb7GNkUuq/RV75ufUe3Vuv7BpN +Pjyo+CGF2gT7shxXC/BPSy3GQC22FAdTYwuxUNn7pXgYSy3DRJ3Zpbj4EJkgla41Jb0zdIcFVYTv +IDRvrk7O04hKqZNeEFjGMJYW8rM6PloS/1oOARMDa+HCi9Mg6RL764XrZJKg9gtoQGmSnWk17QV1 +BUx1reGHIUZXQOsRNL5RRRdwjYyugNAazGoypA03Yw3vdu4DmUm6yotA2HLgsh8cfN2Zzoh5+qvx +p7Zs9Yv+W27FWbUe3Vcr4hE5IYNaH9iH0+VV4NIFVnl78RKnxhYushZbvMxr8RxZm2Tr35u36bPl +kfnwy/ndbzUoVBNvfneAMGghbJRjvZDglpJwi3DrLrnM6fzs3LZGGKHMSYPUsDzRhVI2snAOGtEo +X9sa8SIG5hNVN5V14zsA2XeyHwnCTJMWp0aCsFbh2FKt8sw06LHdY5wSzOJe0S1T83ivAQ27e0I8 +/ZZB/lCUUHPvGO+aIFZ1+OCYWk1VrbE91HhV3TNj/nl7cfdFM6qhGbahEXlW47g4Yyc9BNozy1b0 +xvdGv0itpmeVLdCv7gs/qsEP2ziejBVz4Cj42Wz8HST2XgoZX/fjFU5Q33fjr5H3ofQdpB7VUI/a +gLerQvrxd5DY+1RnGl1qtR9/6leCuFENbtTG8WSsGH8x7txVBor9L9AZsPNpgMV0Dgp0p8rQpBjP +YzFuXoPzRvNQjIfRVZzGWUynoutg9814OovxjB9PR87pIB4OZiNB0jCImU02GUTNwVwoaobsEz+q +ww9a0SMbkGwiEiSNIFXajTG2m01D6lr/STOqoxm0cjwZb/SMRhAQ7SVQlHiRn66YprH0qqJJmRFx +l4feREGhUPOEMuGxLKNXG1cHwXBw67k6WShMuL2Wl5N3NeEOHwNFfIg3WBQNrBlt0ICdmiylvKxd +0GTDrhw+MseG6WEF2mkQTWXjQx3fAP8sbp0qwRue8MnGRH1dPS6+RjvpNxFXjYAuK30YqoBtKEw5 +NMQeKil69ramJh4Pp/QY1Cfr/BV8kUzQsafxlGQvTcNSNW9kQAweMzCi4obGQNMyOauLgnTJEPSs +d8cHWe9PDnRsdQfJxp1NiBTKJuvkIJ/HVEPX03wgGFg8dmEnb5lDTfCLfPAVJsrSuRdJK2w8nJBH +Buk+wFpRqgauUzMdASWDUX3VlTrWlMzRYGQdNw0iyywtoBXuDnCrHlAjYUSz6gs1mkwvBl/QGyDa +VZjIuYU0JiiBBEXMx67m6A7QaEqXVOY4G6vwaS5oTu8gZzmzD8iOowNED4HkRqXLZI6O49mMe6w0 +4q+G9sFpOjvZ8xpTRBDue/Aq1OCwR3aZDOSRH6Kt1WsrASHQMNNmV5fpAuFSgwlCxy3PxMH9V154 +P1zn1NfUQbIGO1jXr66m1Pfx+M5SXMZ9l7oc3dxc8lYX99fTu7vz2+vfX5/+eHn+x48Xb88/6KUu +tr/6pfvo3+9vbu/+/uv7eO+L4JOsrYdmrFS22jvVhP/ub+enl38+vbu9+Ld8N6ik/f7y4uz8+7PT +y4vrn/54e/H2/z3/NVY3bfFvwox+uLs9Rff7dhdzsR8vL8/vVsXq6PTsl3+d3r7VfIgLb5ExjLev +YsJli6hSPtOLfZVA8cmn0EGcUTFZbbXqChbDzwvj4y8wV/End0/20bCGrpyGYK3YyqAngy9T54/7 +ccy/vGQF/4USmYpksoRq4oaraepcOSvhUEDRLj1Au1uJWBdqSEXtZ7+yRCdrRU1wzJKGAa80Uyez +SnWTlKZold6lMvrKum5yusTE+rLIyhT6MRe3X9q+vSLvSFzWblFX6foCdUEhJumvmOGYv/lf/xRb +86vYGEXDKn4RP4hc+UolgPgifalFQeZjh7v6u0ZiL44Puu5sGNfFqq7ir64JBdvOwo2flylH6ioO +Oe9MtNeyv5fd737Y6V0R64w/8Wn3visSvz3r+nc5Eqlr3wVj/EeMx+hE3dVPzEqiniO6YIwZwVO8 +N8MwkkV9QvQGLwCj6VsBKXMCb93yMRc2H1L59KMvwmbi43HqRHzWu19M/8Gour4pBjimTpwcjLuY +qimUdU3jTAcnEll4Wpl5TvO6RvxFDha+sunuabB4NiWQ54c2xse3bVe2e07qdAbLmHTJiT6lb/tC +ZpVaKNieUSBl3Xh/IRsfNB3HrtP9gKZMuAiR5pkdvC1JiCpXrbk7Nd4HVUZXMWbe88z2sIpvqMmq +DNctWKZT81SlFf0Hroq5MB8qWjm92vLobONWjxa3ijulaqQp7jVv6ynAw9nCZQOBJnyrjlz9vkn+ +kWnnaDLluXsnKYjj7ske5+6frjvdDuIlozP3EK1t/S7KHh/bR3qzXtnTmipOVCSYpiOYD26xNH1x +k6mX6qxtlnxt2q7vS7ZaJK0mJT9/eLul8ZzcP2zBKTOG0vLvewK7nrja1RAQiQj4AR/oG6xXETh6 +ORxGj56GSVQgfhoaZ8ruF+zMw3cs3LRd4bxuKBgTDc16kvcodvxBFxZYPHj5G4gN/BuRufBeWmN5 +9THTulI8zXctrNuN5kbMSAxjMg+ZU3ZdCTiw2LbNKcvMNo7mtgFWDwkCMzryqTdL/qPj9T8OufXC +xGs0zaH24eqg4U3R9GeumlBjoyeQoZN0usZqUO7eE8I6LlodSuQ5jEeESLTQ3T90RIDxqGLuYfoc +9q+CqSv1wRVyXanH+mgFPbQ57WOFXbx0dnhMLGz5aIOWYTatEIibHRXg5YU4QOouRcIXebXBj7Js +yMPXobEVuXrpdwWI6VNGCn9fg5ln4K6unfGVfH7VgaAA9E0Vby/hTdCGSzsqkRhsOQb1BTRkUPtc +Hegd0F1BfQ9FoqGmYlJiLeghsfo3vLpVBlz/dvW770X0vf5p9Zujo2/Ozj5e/e3mjjJshtWTo1NP +hDU918Duru/9N33v15RLRHhNT3+XP69+95ebu7+dn93cvhXM/092RC2HFe8Zge7RBwPvFzuR64+/ ++dMf4175+7ub2yt9FUcpm/vtzY/nb775U/tGOvH93a+X52/6pvWrhbOWHR7hIUPX59NxPLlS4tub +f21wQcOXqY5wzIDrgq9aquxsVXpe7WPgjVSHKVH2zMBpVykFLh8KNTQ3NXnmoB4Te93EXjexdbqJ +po4sckwSMZC+PjvTbMnI5XxxRaVf+jXkmSt1Fow8M8t+fpYZ3IkzcCRKTLNvcOY9xDS7BskUzT0c +LcIATRjzXNga9xWpgjp7DNnmWa0czW4FAjiNAJ+PcV7DLtfqdRJzK9OIFBNWJthJDjMwasYrgDXY +Yh2oK8kGYhxpBHWxFLiGu6zTFb7DfjzGfzcyRUKAV8p+G+ZMfID9pueco8+DVRLec7EhoG3ON0Js +qxHzDb93nBAPF20c798+27jNo8Vt4phy9vMz3S6lNULiG9i2rzKQLLUuTwYqI8h3V4x1IIhVeqFM +B8qXv3RNuqxexCmXfwYjb7w1rIeh0Qdg1RQWh3AyHVU63fpe83bjSu8Qtl35Rj/O+9O1A9/EISgf +XRMvvpePjB18lc3UFNQ1uQb0sLQR0aT8FGlj0rWrAbDrCeNwJ7M0gHZj06A5OwaumSuGbY5na02n +Pk2UKUAjTNX6oGGw0juIkHX9JNLMolXJzvnmlUgzf7i53VtY9xbWvRSzl2L2Fta9hXVvYd1bWPcW +1r2FdW9h3U0L68SeenUwNZ4Wa0ysawyxz2pjNXozx702VnC99rGyDpFiZbXIxDpp+Gh5w09lYS3W +mFhze2qxxt56r421WGdknZomc9PltMh62NObWdd1nhmhMjPrmsGsK/h5tBNVwP2VZm9rfVLtxMn5 +u7u9rXVva91rKfZair2tdW9rfUJbKy73YRajq4NSrwDUjIMijxiajhIsWVtPyIrFCN8xKBlbs4Jr +QH31Wfuf27hqEHiHUNjWKoHujZUt2gxq52RyoaFtFQFsuLH7waINzUsj4+qSNo8Wt4ljyXthmj8z +u13yTkdolGjydJa4kGDJdHaSwZIpE7BqAsM9h41bC0oGz6xgDirvBSVjWwZKnVUsYhBuOehl/0G6 +eTD1lfa8siWZjFuszPuU3megvgPITdu4dZDBXFVr5m/c/nrYg2LF55Aqpp2jVDEdRQ== + + + D+wHmxVfC+zHoRbWbnbzdvOP1k3VpqJKkWgB0prVgvUBdqgnEFE2lFBejf30bxc//bwXUfYiyl5E +2YsoexFlL6I8pYiil4cmOSKGyNgqlzY6UCaTpILrQL0EQn9PpwJIep3LJ8PGn1FICTqg+4QUpNep +3CNFG6tpTGZLKZNGxx6gjzf6VFIK3Svj2kUhhSYeb9Pa8XUuFSik51ITpJcv6Ls3gmDJK78OlAk0 +qeAQVN4H6jnbyTA6O0WqMRdOIigvbg5TDpYJbDDSajJ2QnrOm6WcT7M3bHwt6MkFk8mAU1TZeMgZ +NBdCpsPuYbnIkQ89a3Uoukzm/l6h5IuXBv7xfi8K7EWBvSiwFwX2osBeFHg6USCx4eT2a58CwwhC +xmLbx23BF68HaVSH14uzfWnDKkaBmfyzJCisgcQGT6Z9eMqgMN7eM+CxZWDKnSOx+pqYsPBIyQaJ +P5sHYsIea3IaEvZIkzie7CBl/ecRB7pAHU2T0QkEDQ4RAegCJu6thyTufB2kGkMY+ReXXcWBdaCu +XAZKlReJF81AKQAtA01H08kFg1cpGCxFJGVt9w1NQV0sUzcfU0hXjHXn1Ux7cA/wQQFBMM8bYXs+ +SUAYD/JqAMxCtqYDzWDd0GJo1wCydmQxWmw45Wv68yleVoXms8B9rEzsaqSvdNhunsKCsWg5XpPM +cncnAxEStfru9vT6p/ONQsBg/cWtHvCRjgdRI+wQMuEnUBGqw2C9XSGJrseFWAlQIl1qeii616mC +oqshtdJBjg8IajLQyQHL2R4yqTlvd9ypWDiVTdX3DU6Geu95Z0Kt3A40ZnXH7ZRV9eCBVwinURtc +N2qaSo4MHgp8h1uSytDopUPCkZjDYMpqxPcgbb5eHvhwaXg8I336KJZiYdtHm7QNxkj+8+Mj0Dal +DzzVWlvi8DSN9z6p1Rx+gPp4vbhAhDK9yw+HIvMQdajgEjckq2l530oCyXK7iAueV+8mQClLm36n +d6l0KtwhQ3zOkcF1/BBLVT2oGFdb5G0Wkx51FXSdzvC+a3ky2C6FUrYhEk+Y75usm4GXICZYgVBE +9iQIyjIdQIJoR+MD3vKeqVRDV0G2M0a97NsdFxrXmjc56dCkz5PBHk/Hf5942bsUj7rNI3QyuMnw +855Kgf7xJH/sJ3M64ZNlOc67kw3gqzdrRiXAcY2TRod9HHZxPKDxiMdrd5x1I+/FZP7uBeZicOXW +y/jp5KlrXh2FrPEl8pXLXvZIqaCGifg2vTyZfH4vUW5tlECDa/2qC1vwUvWa2DZmdW9MxWtpDC5C +anKevmzDoUOgjzD1uJ1qIIPKuiDfhEZDPVg2VHp1t5DDxQ0ebdJgGS+FHNHfT1SPCZvGW81dTJIv +S+YOY2zRSXqbXp5MPk8ErK4VXh0yS/5VAsRnISFVVuvw4zWAp49JmHRY9knWxe6DrkuTIl9AKELl +1+/3z3XhkXKx9hO5WGEnnMFlO4mBrVzAE8g534RD3GrneoDyrvGh6F6nsgUKp2rxIAdU9qTMavpw +Uk3eyLgHWe+ybh8PBvEoayo0kDeNR9bUCQNWPxx1h1s+cFezaYRfqW0Ycng1LKm1RmDhts1hjK9v +BMg7th4uHECeJrF4y1o+2qRlIXaHTfO52dJuvSsad8DeNcHFZ7Qd11yv9U2AyABZXXN9l4qyZLfO +lZpdBs+RD+0+LsZVFXk7xaQXxbCXxXAQx6NBdbxnj9pqxxoCItepF2zU7FUT220PjeHF5Qmi3YoP +eMtLS1NxLd1j+qBPsa3Bt+Oa8mYmnRh2cjiG44PxmB7jLvNedaxlP4i8Z7wrNu8aGMnu8SR/7Gds +NKXj7mZdSD2W82kKGdQyaWXYqWGfxiMYjG+0Rn3TXcvFDMiAc6yyGyOzPXjvD/2XYZTdsHG3d8NM +tQAxaVEECeKEw9a1GUj4M96uhZhK6s5CrRcVMZTWt3Gn4g4d3LhJvrfbXrCmICS222Lsl+ed8YNt +V6mAE+8B18vr+97p8/HBYCcClO30BCom9RbrWi8mfSwmwyimQy04HbjbM01HgRnzZTav05lG4ox1 +V0KuWZKII8NFEeAGy0IpZ4OF0XILl2YwmrQ4ut83WR4VIjdYIBTcbIlGG62OHFo7ls3aQ72KympA +u7DoOLGD6SBVoxmIa+iYpOr0DEYm/S74UuYjFS60dLNK9XeAs4NGKIE3GUhY3Bb3cHe1JAB5pfg7 +NZ9Kp+6NB3A8GdL8FFAwZrbofYnQbx2krEVo7RpOCmoz3OqoqaDiQxFM6Q+RS0A4u1LvG+9dFz6L +ZNZNqNEsKFeYUJqvOpDMmY8T6ho4/SQAj8j4O71LpVPhbvri8zEwAtfddRARTpxihNaQnlF7+t01 +nQoX4/qLvoEoLGaoEkdW48p2ZrGLIEG4VL3eE5cAbLtJ/dJ3qXQqnCFGbFjGHuDslyDBprnRGtIz +5812k6ovU+FiXH/RNzAB3c9jDPwh+oavsqdxy1qpHQ1M76YfDt6uxpPTTxy+nszrZOYnI0GxyRRM +JqkfyPgW3arpzv7oPiGStN6gKHxoieOBqO0DbnvsiOlJ9xm+sm0O6Qp+nkQXsFpRQoh3C7uyU4Kr +EkZIkWlqVeA0EBpGKiM5I6jJergweC5rmqgyWtji0SYtlswR8tlTW9C2p8uAW8XJklV6/3PUGvF1 +ensyLZDpjZr4onV1ZVVz1GhphZwAN/q6xwXWgp5Ff9Q32pSRBYodzZG4/5TdK/0A1hX/ArRJXWKL +9vOqkf5w+s+b24u7qD36jyRjfM57s3GZOa5tLhz8qiqYG4QvrHmbaAJB7qlBNwGAQQ3Zy1ooPxxY +wapVp8xQQ9VkW73iE3eSGq/OnG1wvFJbs1lZfT4+SJAWOWzUsQMZjuBlKZsKt4FKWXnBy6NpoVP0 +w22rqW/qdmrB+nYfsZam6WrhNbOpEb1mtuvFid5Ra3gdeOxpwcEQEgfDe3nRbDZiiqY1Lx2N01Jw +5lzVz1zB6cVhkvW3SXfxdl9Ju8KrwcGSt+tW2TiR4aeGigD3RcfrPdNXqAipY/qFGi/mcedzGV/I +yNIqI2GPtz0owJYSKrbIPe3YLvzqDBLvHZO0G50QmTZ84GxIH9BxNBwGQc2Q6tBbVng1qRtPSIIc +q39gKNv8q5puUATwelgB6M3GTlptNZmhnObGqD9yGWp6QSJ5KSCYPs6nHvZ10PyHeKRFua7UnfTQ +wCoss+2tjEplokYmdYUjrDI5woE9Znf5iY+f4Epwr0mOWAvYZtxpq2itLenVuBH160BFKLtquq7S +AxSav340HLE3+ZA5K76fFcxb02TzNlnm4+nK3+/e+sQeIxXmgPe8yl+38rgKmNe9Wm9VBNmu617/ +x/kl3eZJdr99AtKLnW0bvSappq+UgcQRWvpxBuTjPdRLlkGxSv4fapIMWIxLFONKcWNwpWgDhMWN +1wnQPacyfZFUbao1tcl+sBsZZPTxpLZRc+PuTHv8Dm7cJfZ7+nuleVWR6w9EXjamsF0UOYk62ukM +VIw/L8Y1yvd0LpHvA043ko0IKDoIvyaN64ulqouu7tRwwc4U7A1glgvTrCYlUm1ZtZO2x72bDoD7 +GEEPtVMK6Z2r421XJSdBtho8lnzKpx+EFlB/w3Mjg/B+6JiJMcFwvXtABmnUI8coaWdL30eqjupa +p8Melt6p54eIX5Y/1OwvK1w3Rl8JMx54ebyDleOYV9o7EjyokIRzVn9IFbjhMMD5cVBJ1MwaB59u ++PSkPHJIWeHoAl9Y5LC2aqLWhTDdV+TowOxbHG62h5wdGJ5NpgeJnNdqklKE4DWwDmMN9RzT4Tp4 +K7qGEPIWMm0lIz7auOAdIOB4kIk5O+hAsjJVXSN2LY5TaCK1eAbMk6XDAIQIpzeEN2Xb4up6EUzr +wFvTcU4G3hBeSj2cDlOaihey4+5u2X68Ijww9AQqIG8NLx533rMd+M432g7c6Q/hcMlJFPmlQiGc +LTx3QJhxD7p8WvVPstcrjOX4IAOF4Bv1y5W5aYaAQEn9UNWDshE4sbL4NEhLv2qL8L4Q0dDHBcdV +5lgumSDySoYZTekXh9vZgcIuivC9tHnoG1tTC9S0esG5nNwAyATC7RjT0AaPdoCjruQo6wbODkTR +miiKCXU9IMRJZyEFoYVaGC+4nFaaitW1ctJPNiM2KfiCQE4JPa2tUbd4sAa2A4GbaqqWSQIdbKA9 +AAtTBl2iCJJZADp1lci+9MqspJYiROiKoCVcwBPEI5wWRFvr6B67VjpI7EhXQerpZDhn1KU/yx3x +tC9vIatwc3UeWQXzJKyC81G7LyhgQoBaSU5LYbo1g3Ire4FRMBHkSjV5nQBl7wWBoy1rm5zFKdWr +z6Qje8xGFTVtGcgww3Sw4hetAqrDygbuPZH52yaHsSYG5wDQrgFoKQCkXsS/9DVPBnySMp2XWtbW +rOxKDkA1NETASQdo+m4GsJzwKZuCumIFaw5hDQRe5MxfpFe16ESBYW9oU0ldyj4b9fJhtc3n2yRy +vNbC4ldyJOPg8Njjmi+5NXW7hRvnu9sfV8Xq6PIjt49JWlQzd1tQViLnSXp81UGcPVRSGfTiHjo8 +kyAXGajg51X/eQdINeI0TSBBST36YwUWEUYGsUPp19nB+F3Xw1h43OOzGYYd534bP0AghPFwF8G/ +CE4ls+Jw4FZuJec3gnqgL4Hul21ZpZfgUb3QI170QWkUt3000lsnslhv3tlETTezT59fXxe1mAZi +7HAa7WPTONWTy+CHTp/ExQEeCplqrQuM7xHuDknfEkiEsUNyOkjX3AJLEkCYtpasK1CpgwnlMxow +y2ogkuGsSD+ISKakKocAlqz7kv1zV3sCpR6kGlIX+/4fZ2OZZVmEflPDbryn+VfYZqeXzAiX3ayJ +HxD6beQfxb30wEtmhDTBy9cEOQSEaZpGRQfbOFoOfQmWVZqtArZM70lBq6IBhZMzVXZZ3epZyvsT +ICs2sFq6+CzzUgVOldQNNVMPiHN3fJBAZIOqZpVqgBDWpLnjr2NenNHWTehABUtXfekOkLWQwWI3 +unq0m6n7SWWH5zqimuV9EjnBAh7IFFY5JGsrwqAg0osDYh0OvDLHk34dK8mq+neJRKXC6Tmfrg4U +e5HqKDSwxNWqLaSicLNo6kmrVxkwdW3c9X5YGmw9GvV0XiaTx3LTSc7XQMfFyOts1JMpmQxgbDxs ++ksVIM/UPaWBMGdp0HY0WMLdvIcJ2w3NLL11GdTSaZ3hZQ2pIwH0sBOyn31j4QNts1oSIDV1dtCB +IHg2PsVWoxqEbhsKnqmtDkL5RDvUf9V1uq9qMrY5R6DxDxFviGOR1OjPgrcbtM7W6l2ut7R0hAbT +HbLpNpAuGdkl0m3p0zXfEeZV2ALbbKyL/ikaeX6YDJUEqN6MbHD2USNSaaiyejpAbOzsIIN1N310 +FbVJpZFaiwDVRMUudR91ve4qGo/t06dbzhmh/pVOeHrQRKi1CMHBQmNd6vWUccY1pA== + + + FmZ+YXsqxk90oBZhWI1ai1OKIFWdQcvkQtUBdKYgTmXfxDj4vpYISC2dHXQgkdKr6LOrtSC5bemy +lhJAJ5e96b+J/e1rGY3p02cW6hAEfmgukfiAXCJQdyDOrYSap8pxuYUrUakX82iQdQfBprXCXDQk +SIpx1LT5GD/fAaALc9F9LIJkn7bBqBI01pOBYmPUUnUwT+3HqqtKhJ+qdaFvLgGgHY1dSqB+GLGW +8bg+fXIrkTFxtR0nNz2AJQETwUuZhClHUzmhyPg/2dGNxsGV9I666iFtjBkRUk+Fa8GQuQAEU4VT +B8BMYzJcDzIQryFnp1o6QGyIq9NBoDBcdZUgXQKvRkoNJQA0P7EzCZQPgLWMR/QZKDH8+3yixfGh +0ERnEPV58ZVzucRRCMJ5C1KHM6bW8PkOhhhN+hVCqd2WVBcb5aEDfb5cDxFsbIXqUhPWfWWgrgIv +2NXUQVJ72OwJJiTM2cDFiDVB9UtK07WXIGcHfa+6r7qedzVNxvc5KDDO0DpRYH0ABXbqB8dbYzyY +/3sPPScCam2oYDFlS6EmgaDHt2rHrKuWOkqeHDA/IkQ3PWMbqw4/QdSF0/dVdICumbODHmZwy5Fb +pVpU36L+BmyoA5wdpL50oK7/sZLJeD4DMsscmnjMxd9IpRLkQHU45oyFh3lOjCk0jogGMpb5FdUB +noYsOTFDW1OvTE26hU2hjUHBOGmEDCn7iWmFpHCMOzvph9kZ1G2T/OPh2CSUVABNIhGMID+DS4Zy +HDABN8ywpolx2mj4sNAnY42koO4DWYoavKphyhGvTnGwxOCeId56K8K8C3UDzRaDBGmQ9My4wsum +yAocOlXiR28tmg8bfkDF8TEPf9eqsTBta4aeER5gIRnO29m9oUOVusOVLd29MIvM5VG2MMbJrDmn +AZZ1+gMg3TBhjIDrZ22R8qeJwUXMulPH9DtNiGQ4WN0HDHqVA6+CMKf7zLWVRhZ5QQ2ZSVhX5JeI +htWask0dcPWfg6N34w/LutX0j5iI5H3hy7ad1yxc57BWoVKrhEjodm3JGgjkvAa7t0Epw7weU01E +/2UhMML1B98+lkLoMb+uRcvyNNcrN42sgZ/pJ5c0TOvUSg8i4MN6JpqxelohVM/BbFbAjbHF1qSX +TuuDGvo1gJk684qK+hKbq4bXCZUdQnRxqh9LRbXGJwGEU6BObjkOlkc8t2oGxDM8Zs5Aloy6LokE +BbsqL99WXpmWIRi0azKBuEmCBBYnD1MLyBFHFrmCIzg2fogeVegtyYdQgsgwpmSdFju+juwJhkjy +EZSFqVEaACR1OD4gdQBXaKNTTGKIoHGRItOZ24xeIASxbomSbVvzL+WEEnZNIaBNjYsgoHgycmBV +KBUi2YA9jQxYTQpN+2FNLy/k5bCtjaxma8hqenwluwx0Q2TtCoIcTTJBvpF95teUNw18ZtoGCg0D +Qgm57ki5l0aNNzLNMJbMaxsUoEK2JJo0QSCQHmVNUdn1PHwpS7feK/GY2+0oi9eq86MX6aeRj41W +6Wm8RYHBjX15KtLk2gzZTo2NxulWtdWVJlnCwewaFbt4nNPz0dBRThOowA2EdIbecoehNXRKYMIl +fqWJHh1zM+gFk7zTrnDkf6mWsNBm0E7YqChpanVhhAtmgM4Jjt8UfYT8hNCoaV2Qk56l9LVHB8E9 +w5DOS16xvYTvSTL3GVii4ITjBr9D2QuZA5V1oS8BntF7sPbAhWOYHeW01ZSC1CFYLQl2s6nUgWAw +cxsTkQpWN6Cla3iwGePUPVC2jgy8hNYcY5XGDikSqIDqD6NuDUZPuiuULgTNsmFUESBSRaCOxSC1 +Qk13fTnSLYzL1Al6ByfWdk1pK/NWqtuOcXLUilTe0H8exi9XJ6m1bOc1fER3tRJ+8/J95fVmknE5 +hDX4FkEVpYccxGLz+iusdgkTK5mWlqFqn0w3Fi/Mk1xNIrJSacqXphrDHO5qGKeqDJ4szNVXh1YZ +0iY4yim17EGKYFTlYj/ZVrVn1CXrFjOVOoipSxU4VlZcqZQDgPdaqIXITdnO0l+HWZwCbw5Soxr8 +5ej1RYN2rZ/QaVB1rVHpGTTLYUGWIigPq9oQaY1OYpAKeQHWGckaPQoE4aB/NvzK0APR07NXy6kl +x8cAdCWHFFHoeaZqk8680ugdntN53FRuCY4ssd4GHv9GqOCpZwAmeDXkgeeJTyakAlPgVGkhmExC +bTwd6mXajappPciwrJZs5VbYiVazxAgxqJl5R+YqQBDVO8VGpXET0CE9+EIo8ctprkowo65h7JWV +Aa0ruq7hIz2brKsb9dYyzq4tKjsz5ZlB35R3mddlvQW3rUCDOC3GfLL4snR1nob5cDW8CV+WjMBL +TD0Srbrw0DGpImOBI192sIaeIlZCz3fueni5Q4xR8yPJi5zGvCU3COWo+KzWrahvgVwMNyehFzUU +ttRHea96KupENDLD0Zev1Z3q9A38Nn1JF1EwJyYasBjr7OAtWeqWjRrn5jA6/AEWiWCjOARIWxn9 +ymmMSIkwE3r/Km06plOsqrjkbC1rGQVURfD8BxWpK09lzHDiNmY2PH0eDzUW/RB2GSFGyARua+G3 +VZEmkyDtOh96JUeL5FpCMCy8veBVAGc1UOnKqcYAfJT1UejHAfkDjdEe5zREMd/GKNxJ4dqB44Ou +tKphumh8nXQcLaiSg6yPeyrmtHqkpiJbGYp7tjRmXUEhABB6VS1HBdvR3O4KhRAshRKRJoCyLcOn +cxrLVuUpCAS8mcvGvTCfAfrOhACFyS6IgddtEz3UqypqLasmxm5V6qsr0mOrzhQWrlP0Ga/UORYw +HP0eGW6sfkQNNNyY+bV+UrdR5dDivMZmZEpD00RfVpi2WlIDxOZTJy2fRgdshtsEzRmnPEypN9aB +QNDBXQ4bUjULB/k2+qKLlA23WRCMloZvpEZgDmZ1QrZU0zgCYGA8htmiJJdBd8EyGnvh8Q1KRqoz +nsSN+QrmCizVxxN/WirpW1AiH2qPJG7g8kOMbYtWHduUYNHruJljrnWvOZs0uCCI3H1ILUwQ3k2q +tCqbQE8MHUHrBOrK+p7SjiYiOCs2VdMcMuTqiMaCGvZF1W2Qe5/X9hHuyHRNU4ao3PDuvqJgVVt6 +CgjKyHuVUWb2G8WlILUbkY/9ZO5i4Ro9AfFgGgnhrF5aRhloNtrIw0P+wBaHAhunq+wTehQ7H/ex +YInwBGrQwwlu6aDEEBGNG+RGxLUcFB/kGcpRBNaoTVUYAURN4EIRVQOQwYfaQdrRKBIfoyUgJ+Jv +C62XYzATD35aX1wF/qVhenW4f9WM2WwNyIGcgTRsGNo/QG9cjIcSAliDgrhSE42Xh9Ro0mHP0o1c +42UYP0v1rlAzEC0aU6AAgzpW6N14vjbmMNqqZHhjxXyX0majITYG7JoVdkb4ekQMtMFGpbTqM2AV +LBlq4EWKWuG+T+vV8c2R/JM3Zwgmc525ulaigYhFqDRX8PwT4itH/rSwcASwxUHKskL7dWGOOI8e +ZhCYyrwcv/OaxZ734DgQc2KaQK3ytGANETElIIB66Whudyn/BMyTlAWB882ncxnLV+ZJFBotQvPn +Jo5/ImLRuY/n95e0dM2JoQ507OpA8LCiLbuNcWJysDGfRvqpivU2elAQVLC070r3z6kBlRkirEnq +gVgNAiBg+Cr7nwxf0lC3COn7HItPBnHvPm7UmB2TJ4pUxawXIU6ISEcyp3KoRRFMGGqLQEA7yapI +AQs2Ji8HIj3Is3sjKiQ+xNbBScsedxlDDI2P1sGRxT9QuhHa5JugEfXDtIoLmz5a2jRLUzpT20nc +fv8Y6sOmrqlTRMqAM1AJ3qgbIJNeE7QEnXgl9GKE2jhDxyz8eiLP/yz/hnua/BsantJncC2fKEAF +2TFGASoK+oQAFRz89wWoZO/2ASo7G6Cyj01JWe+eLTblExPf7UNU9iEquxSiUtsHQ1Tg6jOKUAHo +kQAV84wBKmZOgArdmgbxKfnAPlN4ShlvCE0PXYiKmR+iYrOokascloeomEmISrUah6jY8jOFqGhF +gxCVajUJUTGTEBU7qGg8ts8UomLjlKeHLkTlU2NUmnGMSjOJUWHY9SBGRQTYYYyKbSYxKgIaxKig +lmGMSjONUWleIEbFRrfo9NDFqFSfM0hFvaIHMSqfLUJlGJ/ClnY/PEXFyjw8hZA8PIXpYLYlPIWd +ycNT0gC68JR8RJ8pPCVmECnSQxeeUj1LeArHPAxPaSfhKe2a8JR2HJ6is7et4SmtSdRXH1J4Sm0+ +Y3gK8q1vS3gKc7+/ivAUoszD4SnNjPAUOyM8JXINXXiKGYWn1O1nClBB0qhPDVCpgx70Wxqh0mjM +Bi/teDBCperiPeyasilCpXk4QiXMa/ahCJVByQcjVB7u8T5C5aUjVBpl1HYjQkXKLA9QadyjASrg +VfYBKvsAlX2AymYBKjI1wwAVaDnzAJWyracBKuWGASrwrhoEqJjlASrtKEClnQSotOHhAJVyEqBi +tzxApekCVEKM2eDloPDU1820OEZlUD5FqYS1USohyaq1mdt4ilMxKU5F72WdFmWoSpgfqjIqzmCV +JsWqfAYP0n2syv2xKtgdnyVWxccrBbtYlajT62NV3CaxKuQbRrEqtpzEqjSTWBW3JlalncSqhFmx +KubxWJXBPL5ArIqNCg+j6XrXh4zYkEJGQh6rwjIx8OP+UBXY8zRUxeahKlUMVSmbme32oSp1DFWx +68NrEKqCu1DWhKo80uMYqVLvI1WeMVKlNMNYFfNorIofxar4UaxKNYlVsaNYlfrxWBVenPI0oSrN +45EqiePalkgVo4EqPgWq+EnIiGlTyIhpB4EqXeDHtGgMUxHGKoapRArBMBUh/xqmsqbgujb7MBUX +w1T8uoIMUylDClNpmkGYygOdHQep4KDaB6l8ziCVpn3CIBWoL4dBKvRTfDRIxUyCVKo5QSpteKEg +lcEkbkOQiunCNZyZHaTim/WlFwapPNr2/UEqk6KzglTu6/c+SOVZg1SgSBwFqcDZZBikYh4PUilH +QSpVuzxIBdeNPHWQil8cpOIHQSr5fL1AkIrIhU0MUonRIlUK3AiPxqjIusaoj9JMC6cYFdl6MUal +Nl2MStnGGBU/r9UuRMXEEJV1xRigEtbGpzzc1RSf0uzjU7YtPkX9eO6LT8nefkp8SvNQfEr2ch+f +ssvxKfehUopPWYhM98en3IdOMT5lIULt41PWxqf87fvvB2Epn/fSIb0jFYEEcGanS1kP8ocJNZz3 +jINtuapQ3sPDPwHOeM0m7vXrP2mGdXTPsRm10BDEqwWZNkPrQPODZhIg3lmIrnTfpL52lYzHg+21 +Hqt++PPJP/70rWDUb84ubs9kge2b366+5gU4JVZdXmYLHWIWAkpPRg1a8JHRVAEEnQAkhCOQ0xGO +p1GrlYPJiDZLuq60tV772MIHKXp4Ypi4QLCMGpyqhIlIuCk65qOB0vAQquugZrEIKg== + + + EMKDrAEn9Jsx9JimL0zFawVxw6rAKxfwOBzC8WRQ8JLnstQuGyj12U3+FfxWwa3ANyKUKkp6Xh2N +N6FRfVSE4I680MROKyyhycmBTbfxNrg9kK02pqKvdqsZI0fdOZ508OQ5ribD4riVN7jE1/Av/YQA +rtSlbbsuXfr+/PT27Ge9U1ojiT475YCSHWHQkC+Q8umKoAAFOJWuVHTAyAonLBPtHtC3ect4de5t +oD/UYvKzwpVlcixfckeI3EMX59aX6o1B3x8Rpqq6UgBcs1ZwHcAdCnT8Nw0a57eyKJeQyrzzFSlI +UxtKSzLwkpoUtsmrx3DtJdzim0iXrF7LQDFIzq5LxiJQAsIFaxDMcLNvGZ+ZURH2GVDI9pAb72w6 +O5fE0kn0SXt/HMrH+B+WjtL4jMVD1MhkWRS4eGFw7k+WBsANFkeKTZdHgJsskBSbLhGAixdpzWyh +JhwY/+DEc0W+etOvydK1gIrNUtMbYNfmWsCbERoAhzIlQpPwJfRtJU0F3oZGgfCeBEcK8boJ8cNR +lfcC35G8pI7/I7+UJkRh5Ukum28hYxsiVA0bGC236mmfQMarRhQACyyEsqTlMQCNR4ObR204tORQ +YeZ0mAReHGt4wlOExS3tUNRSKVgZPRmYpQtnEHS4uOUWBmG4A8HlE12jwsUlF1B4lVV13UE8kpha +LoPw94EXY9a8sNOLOKgaUqdZ6tJltbwm1zAxpmld0AgoTwcV3iLeMBRORsM9AqxsS8SIiXCgCmOZ +FOS9HM9bCsBLcHJS8t3VASL4qJxNIMGeyvuYOV9ELm6bRpXWuM806F2umB3mHBXeW+N0at4Xqtc/ +ak5D2Jk1Lz3mSss5vXsVrrstIyNlN/ka21sv+oW3Dhw4RGxy0IIcH8BnRwM+HFzkwIFQ9dxEh/S0 +EOmZ157zV4LAugZ9vHqTG4Yul3oZrqVPzjHMbupf2CDKp2aCmHgNjlGlteyf6LJcHVZ1yUKWvnpU +rWmMqrogQmPlkYuW92Hq/eskkLxdPd51AlDj9HrN0gRlWR3Ni4KE3tl+ScardjxZx4fvi4RzqCyJ +se1MjcZz3/PetMKc+QZnQIN73lsgCxwQcFnuFvJDd6e3q2IlIt+vv40MUbzDdSZZK4Easq1VQoKT +FA9P3iV9chD3fFAn0JIgmBhtxVt+RQSoIote0l8MOOsNKXVJGbhuazyseb+mmmljkw713Z0TYI34 +atnWpsapDWWphzsdNDh11UL7NdZ6WVxLrE7DRfwNvSQikYUzpx2zrAfhYTG4WvYnbQkOWkqolF3p +ENECJYkQVigQq3j5cyWMQANCKUKhiPAxthrCEfTdVwfw6281HNRRo30ioKaij2B/O3UTeRCASp0+ +y+uyaLSrW1jhOaMOt0fBN8OyHAOUYDaGkYPXycLrzzDMDk49XsmA6trhAxp4c6yvqenGekAU40Ig +yrSp9AreyftiUkkxbaiY9qaYdrlYM7BizfiLNdNUrJnNbLZP+mhw+EUgMuEKdXvDiJiG/jNsTxPx +ytlZs1qDYTiGMZ9w36Q0oJaXEpd0nrZKVMcvB2WH9a5pOeva6GF25LeGfA/G+NWbNU0JjRz0RuhW +3lV5HA8FtfYjVc56/EUxqqQYN7JuvgfdPTkYhnb7JjJ6IHRy6gtyCCFBEHYbs0jItoOKtqZrS8I0 +hs20kVk4gRSl8Ti4NR7WHYzDevotOg35o6GnCdEeCTPXMZXcjAOhXsM6rpqhc0mBRPSBUfk1Q9x9 +57R/cgAnPpChgl72pe4haBFo+jyBnFdrTHL/AQLcqIrpq0GwnYZ89o1Rj4krqrI+MXoJIQeyIIxE +OpnO1MkDym4MWRgt3k1YNDXcvtTpGE6FE7qJ0OQGxNyDUQP755G4pGa8ZmiqqCVG5KlgAdhcZZB/ +QDStMCzMfgy/NUSsrCtaB1WoBNtEI9DR2catHs1tFValRu1YNfRaQ7X2fbxIOunL1dnN1fubj9dv +Vx9+Pn1/vrq6eZsf8w+rxdfgtSq6R5itwBFuUwTdBLtV8z7CbxCLCYaL+DjB8a/erMFybuUezyky +TzBdoFNcJ2mYYHvU24/wXadhhPFrZvHkfn38gqXL1OPmeTjTJ2Yg+zxRHz+VfWzv5x/dQ/wj/XnX +8I9V5B9H7x/lH13HP7YbM5BGTaYtBEEwdaaxJpCB9LKX1uTnoZrJp+QN8SFGwrcGaaFaB1E0z8/z +mbLzDDhISxeXIQdp6WE04CBt5JaWc5COPBscsO7lIP3n4CD9LA4y780SDnI0/mLNNBVrZnMeB9m2 +CzlI9xAH6RZwkMOWl3KQDzGMw5rnMYzuUYbRbcIwjrvyAMNYl2OGERtpI4YRkSxPxTDWrXmYYVR7 +fNs0sxjHYXXLGEc7YRzzGfvMjCNcdZWFa5cyjtiXZOH8LL7R9HzjBo0ezWz0xdnGIXYvZhuX4/hS +tnGImvewjWux/UH2cVztcvbRrmEfh5j/nOzjcmbu4uyXc/Bzfzt/uwkzB3taox7ksEIjeadCivg3 +gdNzGW2C/KZ7Of0q/To7GL8bF84qjj/hZx4ArxGGBlMGcMIZDYMXJCjLAG9N4fHKuuSXAaFOJ0ju +Y7xjBpPgVedWCY/QNRF/HPcjn8UUGkMyZ1uPQBrwLmUFq1JJ1wZQgwmdq4FV6XLp9FCQGySyIbm2 +Jj+ZqBbrqhIKAz2mDLvzu3Im/+GsyDgtxxeChklRu5gSN8Iqqpkbq7IOCaD/LxJUH0v1e9V5Z6oA +5H8pYQbVED2mRnBMy9UamgAMfSMMlwiBWJh4U+OAZrqDsiJfi3ic1IT+1WSPWduxX6NuljTWDPta +TL4pUp19fkcbETmlkdT/coBWzTTvNQOH0ku+czATlZSj6WAMzz8De56DvwRvCdQ7Q/HsmJURkEZz +6BBiGJNv9dnoc+O6R041s8TWzBsFUsQ5Mx6ITqdjxxRUDNCOPc5Hwb8M57MrHfNxHPsmCkJn43nx +8KSpifmBaTujNXnJxCHT7cKp++rNdPLuhT04pejuw5M6yS7ZZhzlnm7OopuIolQ2guc08oIxsLik +bGvMGnuMD5oolmQzPRTkq4QsOuXN6kZ5s1G6W+9KmvxbkbYb/jChYiYtYUWVSAqTBrQoEQiPuJQS +oVEIV9qTzT3Z3JPNz082m4Egji0Bnkjkj9DSjSiBsluuwORDc4MOUh/mK36cAGciKBuNHo4QpAeE +0AAvHASOMGsOg5LDIbNAQgLUxGcFnW1CC6afeQRQR7XqBQ8+anySI9UiAP+ng0oOBiCRdfw2Vu+R +gyG5bQ0TO1SafM7BA9YhkxOtnpoVWHMwuRgvGScClaRzZDBXDwUqgLQ6mWtwpEVlcc8kop7g3baG +NXVeRD3qxpBOHMGQFUiCUfkYyQYZ/Gv12stg6+ifIiJ4jQR2vEoKKaDhI7SmqPWVpq4TORx5C/Si +mw0bPZrZqCwubPGQ3i1DOhcEJKzByx64CDMh2C7Gza/eLMVOpTxz8VPHshRDo9veQhwd7X4zYJoG +a5DOWk06qadio86NDaghvCChb8Wc0LPR4Igva55EkI3kQG/pEEmNlZXf3jcDEL7ySJTU1MxI1CLp +iVRdRwCy4TrmVHAxly40yVZvhA2a2bw97FKXMukT06wwdDloykbmZqGHFUBUaZ8AFKOw8ZWj1rZV +Hzq6/SlbxvzVNdXKJj1Hdo6XisoGRrQ0+YoW7mm80heT7koQ7oax0zwbS6MZmpmU7OSATrABvEfw +ailBdBvPCLoHnpAXgWsheZFGeRHNgwsIziBALKO70R8bgId1Sfe8MXuSft2rJvQ1/XKkspYJ3+sg +S8OQqrZcR6KAYTXPVHjuMAGKQ2Acb9JCjK6q3ZymLgvIe8QkkD8wJ6gIzbopAwyBa4tWNS5pRhI2 +IZfcMUdnG7d6NLdVh+ygSPhkAi8DG9AoM0wqu4b5SFtGfZcXbhpQgcm2wSafbBwAl28dYUw22Txf +vVmzfQgcbyABzt9Cysss2UQsMdpGAhtvJPJfw60E0HgzETbaToDN3FD9ao8tG429j6SOGTomIaYz +Zx1vTOBzBf9WvS2Az7CeBrJ4TBmDDcFJKxkjX1dITQcVMJf/qRj5EeRBKlLKroKAaJgZD66uyKi5 +TgdHxCiRw0D2KTLDOjnQGNoe6JHNy3saA7HSIE9q02rmWSSRQaQPL20H7oyL1ZaWQSlWIYCoZA7G +TVo7mtNaYI5P5m+xSMizjGxM0UJhixCDd3MsRY0nFVUGe8It2xPDupAJpFL9CFOOeJiIcOVmQw/5 +p8H5ezDcWWJ4ZaEegAak1hzEoJ8lbTEThYkcWUw5Sj+8GItQGfB0iEGgMYbMMdOuMVretTJKPSmF +QLUkpw0DS9YVrZqYmMz+/+y9d34qSdIAuBfgDsggQLjyVSAJ4UESsiBvcZIQVpju6fljf3uBPc5e +Y6+x19g05X0Bb1r9mm++eYOqsiIzIyPDZUQG1H95TH0kvBMCXUYJmFtSjPY39spiJosuKYQXvouS +0kWvUMgK+JJUCp+7q2neNZHrqcb7Wq+MiDUEy6zyEKjeaAJa0JZ+c38GxLGwtgGFLusgoFuDEy+7 +gGEVJLyotqp6xOKbp+Bl0qiolvgVvPgaN8B/Ax1d/wieUeu+ihngxgydw+uKtSOs6odsuZuSeDeR +SRIG8/iTBIqyQYmiRlkhp83TPA4hgkXX0N0P4hsOmbY0Hh/S4MCISSVhH34Lz5dhionDt2A7MsDi +06bre+w3571fCt1BC/RPZS/N4c3D6FBUIYAYuuWXx1egozjdqvoZgy8tjnEwJZ7HVVEICgZjKksu +Psn7DI/A6um/Q6BRGxG08kDsP+9Dg7SlgZ9PtnpMW+s5SXz3BLp6gkC5gHb0CrOaGUey4ZFTREut +ELrjl0AGIRavJVYvneY8d0rBnCiaFDxpOkZKhs+MtKx56omaA68m9Bx4XYiiwWd6mgaP9DQDHhnp +Wv3QNWXDOAoDbUNULETdGIf6sRopXCv3WFJVok0lnqDFCm+JhpF4A7jX5e7Evc0o+ESX2HMkvmgf +XSOlmS5v3Mi8vP90X8UMcGPavhl0RYF6dFWf9i9bnyys1A5dcPAOGQrmYUJ12Woj4yszCQLd6Qvv +1dNtDpIQ8D4UKOTNoyn1Zsb5peiaAvtvWQ7XI1Dt5gV6znnvmUwCoQdVWGVLq9aIE3es/gkSF3hp +xCfQr5LExc1oYFH5lRWDop7hsLD4YQSkHiKH4/V004jp52lATn61xIYuyhQcVxxeTgErEGhpDd3/ +ylGOX0NmD4s2aqnNY9e5hbqG6flAhDhH4i2iblPLqdukXt3mBIPewgk67o4EjIq7c4JBb1E9kvQW +1VcxA9yYoXNJbyH1qhbpTt2OQcehQKKAeHx1FgmzH+30lxgwExkWXbeAdAKa064oVD9oaAnStFLl +Q/U19BoylOPXAoVdo9orsrz2nVukb6izEzzHa/VuZcU4ifHx+C+sI4t1K/2SmoBuBA== + + + gpeoI2WCQRGoJHKr5n0a/QIauFWfRgeBhqlGS5GIiBfkvzVEJKhYHrohR3oUM8CNGTrPi+aCeoyS ++queCALOCniaGnw48DoaXgjLyiQGLPekDYlhhzGBL6OmGROmwatYDg8Ndx23Y2A9NNrxa3hRmnjy +uETfuYX6hpnssG6Rh1NPLQGKuq1Mglit9UKESH3Vk6H6oWtC1AxOIkWoXi5EjJK+ryVHSVt1S5C6 +cDDeyuWIoZIGe1owsacFgwUiGCwQCQcqe1r9SLSnOb31walAKw+09rQtk//5ckmP6V9hT2tZOjZQ +wbhc2NOWXzrb006dWtvTVl8uYU+TJva0lpY1Tz1Rs8hztPQs2tNeKVq0p0mjPU0a7WktXasfuqZs +DY/S29OeqVuyp0kTe5p0sqcXVGxZ+Ofr2Wh4MekOZ93hRyyGHyN1V/3CdzaGbwT85qI/B/+eN786 +rZkPXzDpz03m00//aWPY+OhMgGrc7kzC9u/8+GW+0e93wU4df3ZbYsv6aNRPABV7PIv7z/9ogN/G +pkANACDU7Vnb9iZNEYhSvzFzbE+j9lcwvUPbFoEw+YC3+sDYFk+EZI1fgAU9H140Zp8a0PnPxqQ1 +UiYJWiEQJk3rnf/M/IXuH12AcHugdQSiMe5MANuszSajXgcMLI7XHBCJZsVXTDkWiAEUokYK/BNi +Cf4/QeD/or/EEGS70S7UuUJ+qGsK/ofzoyIXuFvyl3RL66ZMg/9IE1b9Z+X9YlTD3YC6Zf2sJDGT +v7pTGcewUxJ1CHihn8ZIJn9Bv7wOybyf94rkVe4Asz0JxiXtdESMCb+k1eA2oLmfSvil/0BMJfwI +XWSckjWbRVFnMaK6hkPoxkUR5sP5ZYNRcTcrFMFbE/ycMi4YcUPyHIwhgvmR6DYmGJfJI/4HzQY0 +asLtqD1TQRK/ka5invoSJ8PRn0P0B5DZSK6H/YkzMA1/1JfIAnn+R0d6m8iLOYalbh/MDLYHNNId ++nED/BRrugmxSRQoC4mb7rTb7COARgi1WaPVWwqC1zHkGtNuS/kcLzImKf/5+/u0AwQaaf29+MFR +vz9Hl2GMJvHGeAyQhhcHfNQR0RfSAPVXASr9xfd3sHagdb07Q+Ao1E//fCI2BgO0u6U7dDScdmFq +p3yXXaE7Hfcbf+E/YcpnAkMSVw1M5MoHiI0nSFRJS4CJf+gqB54ROE1OnyCl8sHcPgFVQiNpmAB4 +lzV3L4IGRgcjidX4RKHz7t/z+/wh1XDCGJn4hhL8HCNHmlXUt+dH8/fv+QBGG5OZyYrl+p1h28OC +2+EzgYApuHLnRFUmp3xuMXibeeRHw/a8O3MzBzWUle8ASH8rQqd8/cz1tFP8ozM8b7cRScIuFCR7 +uu1FLDChSvUyrTWBbGxYlwV5qNDFezBIj4bFaynOotyEso7yAH9zGvx9puRLFP/Tac3hENAL9K2Z +PIP3t3FrofabCTW3/GMtjNbCaOXCyEwC4ZMhEh6CoMNHjodFDmGtCXzb81oC/Y0SiPrbJRC/lkC/ +mQS6WvIWZgujyoQq1ybVWor9700qz3eZrwXaP3xKngSasBZov6FA4wRaQNl1FPhfFvoAkwJL47tf +WQbepQBvCBA92Cy+u4aAeSOw4Jy1n5BaOwrXUu1HSLWkgK/SYyge3THJwko3KAoF5lAn157Cf7lY +S67F2m8m1taewrU0+mmeQkIUL2th828WNjB8ci1s1sJmLWzWwuZXCRs3uQdrofO/m5Ih6eFvEDv0 +zxY7/zqhAR1vFE/Asrnohjx0XkTyDMNo4vN4nmIZXFOaoJEnjofRfOzPOkpakGP/LvyWFPCl4wQs +A4LumsScl2VNind5ZLy/Dw/2xK6YNbv6cexqqepxa3b1Y9iVeGcCQQs0PPZB3ApeOcoxZtd3rPmV +G37FrvnVj+NXa/Xq9+BXknoF7/cnFfWK5lHRvzW/WoRf/fDg+H8dv/opPsR/LqtRmLrlD/wfVHbJ +E19acxMHbvLDA53/ddxkba39CJa06jgmEofnAlaWFFBtO5ZPMgQuCUoIyRWkPP5L+dc6rnXNAd1x +wHX6+/po94dJgySD05AonocXC6KbeJMUa3I55frM9x8+JU9CbR3V+rsJtZ/iJPiH7Zq1NPq1+e+U +QNMMKgML75MXgGKFyuAx61DXf3f+O0f8bAn0r5Mfa7fQP5P1OhkCNLYDSB6WHIOlPSgSO4UYiuHW +IUgLcq91oP7vxv/W+vNaf/6B+jNNJXmYW++P8RyQuTCoIc4TDG1SXXitP/+b9GdqLYF+Mwm0Ppb4 +EfxkLch+8bEEKhVDMgyDro4hYZkZZI+QAr+8PfK7UOHvMyVPUu2HZ6KtpdrarlqLo3+OOLK5bUOM +E6eE9U28/3JL6oenE65lzo+xpNZX8a4F18+xo8D7OMMAasb2E0dR3Pouj3+5/fTDU03XsmxtP63F +0D9HDFnZT3GKI4CC5ZfuB2A5lmbXhtS/3JD64Zl+a+GzFj5r4fOPFz4wKAJY8Bzrl514bDK5zmj5 +lwufH56m+a8THdAHJ7A8IcBjXo4VeBLGn3IEwSPfGyfwFCp2TcArdeATUikewvDEjysy/C8KKTYt +/oTjiDmBwNFo+FowimGI5X1Ovw8T9sSx1jl4vyPP41iWZDh0sRgPa6WbXTlDw4LqScwXcYV1ARUB +XBdMWuvdfz/7dzp7IEmc2ZdkGFKAvxiCZRmcVEImGW4dmvzvFmz8D0/tWwu2xQ7UGZpIQqGVZAWO +Rz9IgWWgVk8wNBZjvMDQJPxBQl2eUrT6tWBbC7afLtg48SZROskl0Q1ajEBSBOokLjAkua5w+y+X +a+ukz99Nrq3PN9bi6Ee52fD5BkMDJRqdrrNUnKAIYFHFKTJJrS2rf/chB79O+lxLoLUEWkugXyiB +GA4e9JACQSZROQVOiJNJAR7QJYm1APp7BRD599cK5NcZmmsRtBZBaxH0y0UQQXI8DZeO4uMML5Co +aCKxPl1ai6AfnrC5FiDr+kR/B9ukKcQ2WUoQUGwsw8F7VlDdOhiGx6zjtBZjN+ucut+NYaHYVIqn +UfI3QzBQz4jDHHAUlCWFaaHEcGAFQ5HH44itHxaT+g/bdWuN+X8RnsWtr9j6wfrz3y/Ofnh1z7U4 +W1938g/aemuZ9j+6xB5GZgkMCygZxh6zBCNFHJP0Cq6x/12o8PeZkieZ9sMzz/+VEmmd/PePZMU2 +yX+8QLLQs4Rz/4BRQazrhyzIsH5ptrIpu7mCMP350WTYmUxXxW50QGUWY7sWgP9cdRqAdiF5zadW +W3DlbFdkd66/98gnf5Fb/PflTgviZ81RtBxlMmn85a+MJt3/joYzsK2eQjzlH8+ewv8onWi9Of/t +mxNLnfqkMZy+jyaDVYkoFUB34knGz0z68qIxA2MYIklFSMJrMPqjc/N6MZOe4m8mnfc+0LbvtA8b +w/Zo0P1vx6zpPXzI+BNHQM8KjbvDi1F3OIPPkuKz4XyQH427HdQRT6n7r6j6F0XqaNaYdV6vgGRt +4AGThPxy2mr04Zg7k1YH9yEPBr2qdocdU3CFzsekg1+ROmClRgtg36yjirojUvdK+ez3M8Zdse0y +QOhQzbbLorKt4tq17mDcl7m2F3Ue6/G4DwUw/A7dmGShtYtGAJgJIEHroR8NgbbnL/dHf/pZIGjW +YmYtZv5xYkahYXs5U5iMxrXPRnv0Z7zRNRcwalCuDSDE2Zv9IcIJEedZiT+Oxo0WfCY/aPbnE3PT +3uRiEf0P/J+7hlc/gILpj1Z/IjJwNOaP2V/jfzHbvugOe/5c549O/19swLP/KwP+F2FS9I4Cte5z +VXjUgPTGBb6GM7SjeJkFvE9nolIoqnr97sDlnvs7XIwK1+FYmsBHjlSSV3MhmEsveno5nmGXY0k/ +5yznlyQEWs5jrbusj0qRXg/ttMZErdjHCQpeNeYnaRZuOhrmC/Ps6u9ExQyxNP/vf//ynzamvVWx +z1IHME6Ib3esk5QtzStbCfTPVkh+IaWv5eCP3crQRmfQLqYsDfWFDKHfZ2O40tSx1bZ2TqwF/E/R +jn+hlb6YHIfODb+0T5b0gmhguTQjZSnebkx6aidDazpBThAqTnJSmz86E8mTjBE/bnSRZyKmbvU5 +mvzXYh0oloHBj5TA4WBIvALwr97iiJ/q3CN2Lh0OGEF6r86aZatY9iN42pj3Z8/2PnBvOwqFIsHI +IxatepJDdxjyQhJeWSrP1EsErLmTPJA9Sr4Wh+3sZIZGO4VPWPjk9Ww0vJiA1t3hRyyGH+c6YP9c +NPqd2ayDOOxF0804Q49X4EOkhAFMPofRYt3916d/7rtoecNT6PazO+uI3zmjqwEJEMg6fUdJhmNp +GFmcpHmSpjUuAPG7q3LOf9VpS18m6WRSc0lykmYomK6gHqLy5X2nDx2t+GOO5XlS62aQc3fUH6Fz +EPEblieSDK/ukKQZlmK035Lyt/m/GtKngkAjrwbPEyS8ncmIVrwc4pe5/lxCKA3+jxQQHgk6SZku +hPrT08YHUAYb4tckT/EYqQyZFNC6sCz+QXCcgNDHsxzma0ogHc8xvAjyAAaAlw/opD93wLDGRSNp +vNyCAK/4QK8YikcXvEvXeMJQcXSxJ0MCyCJYiuYBWEoAYGlOD5bnAGaTCCzgvNo1ZlgAD+amyKPV +gAWPygdJwhQsS7IkhW8fJZmkZhmSHLxGG7bBcwdgERZksHC0JPgXwCX0cGmeYXkITiCTnCYPLJ6U +bjXlkvhWlDhFA5TRElwWDhcOP3fAJiW4PEVTmtEJLM8ylBYudIohmof/p1ybKsGlIHZphF5ahAug +EprBQexynLYjjFyBF4WcFiqJ1gxQvAoqS/E6BiFwSYxLBfFMksDJpCJyKZxPIFIYQ0AkJOFgOQks +IFzdThFYsIk0o6UoSAQQrkRiFMYyhsuiNROA7XPAM9JGpDmUvgDmRSP8CUmS4vAWTtLo4jRIA5LA +52G6gwgODZKBK8VJKyXwtIAGSYNdAIcGuueRG5OiCVrAiYAMweP8CpgHKHBqaATEJCvtKp7haJR/ +oThFeZZnNFMmpeWWp4z3AwYKmJ80Y5KUwUJEohkCRoIyEhmaYjkVh4Wj5PAt8uCHYZQc3Psky0vw +CIFHVAPWjeBNmRnQquCk0QwQBiGtgQ5YESyDqR6Ok6KkbQpoj4KB+WCbMhj9JkwyzjBw/0AE0GCV +WPU4SRqOUxBEeEnwE18+RIK1ZczHKTFVMglWh1fWXhwnB+AyaPqMNMwkRxIUkmewArhA469pjkAo +kdNjpA1EY8DiBkL7BzInMCQJnTRHIxmSBKyaML/0n1GYMkzTQaxK3DsE3Ohg4eAQWXlLAkJCEFmW +YE0hKmxOYqMsXjJpS/IS0ycZaUvSoF9cLCkOqJtFO5oACMALDfaduH1oMQ4bQ2IFAAlOOSnBIQnA +IDjMdFFwN5BNNI8XHLIsuEsRj1SjUbwLWuRDlITHpIEZJ8kkgxcFoJXXMmNZJGHeDg== + + + epZOFGSJRKPVoUiJZ3KA3VFoxhSB6A4oHQSroSZZMnM4Jwr8kGVnEhG6gDaQNH+GBrxHQLTMAVYP +fyQBz8RCmUmi7iB6WJELMbjSg4RPKI5hVibc49KehCUU0XqwkL+hTcQzmJlQcNlImVHAZRRFB60W +nPCOYiA44YoLElRAEQwJRwKIG7EGAhAzhxkIh5QIWmaU4jpRmNVjmAIcKtrlnESaFCtQJJoywQFe +DAeaFBAOCBIQkqAWEhwcHuyFoVTLBOUEQADLoV0kcWKaJcUkNqBgiXkCPI92JI03AydOn8GMSK6k +IULl4FYnkWgTKAlokmPRbgbtWASdT/Jo0IAmaDQNSbLRkpwXZZJasiHBJrNP8CVeD7iZBA7zJ45n +MBABMXdGqu1BSRRFatcKUipSGmQlhwHsEPF0LkkDrc+P9Z2kqJ9IYlfcpGBfKQhNwpljdErYZID2 +TmBFDN7cDscIeAras0A3x+ssjlC+rZ3AjBnDRNikET/GO8mQqFUbvc/8yBDw33Q/htCYCYsNrFyX +pt+IwAHEUqPd8c9GfmyOOMHStlagmHpVbeDo2yuQzEKobADpmpsiDdoFfhSg13cP2PQjCD5U+543 +Jp2pPzv86AOzSgMG/+dRBfPZPzZ8gsgFLj7mU9DMvMie1c/Pin7AQ1l/HgL9j0//UPoMd6a8BWAM +X6Bn0gcUhwgb/I8KpFk3ci9gq3IcqRGrPKBcraAVkHhBWop41Ezj2xskeUMjvRdKWcBUJNlAcASJ +2APQJAXK3FhOigySF/mEoNLWACNAei9Sg0gVXFm/BXobEhQs4FnaEQPLl5BNDgLzNTR0Sf9nkIRE +AhywVwk0w1MUjQHxDGOubLCSoBAw24VyWq0a0FCmUSQaNVhyUl4cbI9oFhQwBMPaoGeSaprkUQ+U +ACSLlconq+OCoppK0KikvNQk3HKNv1B8y8WHW18E1h2h0JcVMo7BeihPAsUZiT+OA0o8GgDQpVkk +VcTLPfQ/RPTDhaUgS5W1Wx6oJTiTjaFpAktThsCiGtg1SBuh5P+KBgxUk1mIaFZaQA4MAK0bC2w3 +xHfBcgHmjLg8ia05WhqT/geGyiPhwSNalqACfR2pyixF4o3AAGsLjQmIWxLrKPJ/1Zon/BfKYUlk +gtGgdWSASoMIDSgQYHcg1UaU99Kg9D9EsBQS78gxAP6V6JZj8X0UBI+kOw0kJIfJBGCEERUmTq16 +YT2JpTWqF80AOhOQwgJ2LzLKWJJVm0LAvJHubdH9EOHyWKVDO4uXBCYFXVHICuc5Pol9KCTuQGEy +8n9FIiHwHoUqB/hXUo5JoBWg7wQ2iX0JAtC+tHqsNDL9D4mvEMj4h0RNKd4KVsBtCYYisMYF7Det +QyApcint/0ouEKR0MxTa95S05W47TX9+1B9BETiaj+XNB2uZkdjfwTGCufVFSbcKyManhtNwtGx9 +UoptwwNNTItXDi+pYi1JyigvabqUWCJNpDBsPSC9lNfzXJaisAYOTDuW1zgTLZ1DLGvjHEqKSphA +AIKgtPCAyQp4G/yhtuIxPArOmzaMz1OclDI4Cu0DXtZsJTsVsAwBZ9GCHaF1bvJY5RSJVu21IoWk +QrkkhnmRk53Wkm9a8Var3di+szF2eKM3ksu72p3O1F58uyh3+YBWE1NpDC63TXAyON3RCBz97iYz +IQn8qvbXoDnqQzD/hy9UGQ2AVhmqdPpj8D+5xrTXQQMHumLrMwzVzz/AqKDmGbqq1WCTeR9gzR/z +X3U/PmfqB4XRn0P139XOu+b99Vj9Vw5ox382Jm31s9JoIj46nzTB3+eTxvADdl2bAdVV9XduPpuN +hoCYjM8o9bN6o6ltBB9oWuCOsB8bTL/90UEfwPWSH2g+wI9o8Eh0uYPBdVu9Dhwf8vlLg4UyPizi +HayUGuvWqydSW2HUmg8ACRUas4Yv8JqQ/van0F+qcy74991p9WzU7pi+3POH/jPoD8HrWGM2m3Sb +8xlOcgFNMdX9L0CsAL6qVeuz229PAO5RGym2RnoL/5n9Ne7gt6Gd4fT1j8ZkuqdK7lc3/aMB1x63 +hc+nFu1gujhuJo5kqvnrH4qd4WjYcYGY/ghQeNsNZqSW0b93Xs3usA0GSrqYGyCOWmd2hibhPD91 +6xUt/5KYIG0x4Wr+3Uaz33FD+I6r+k/a6Kk/XG912PRvpmg4vdZ8OhsN/l5O9uvoMDVtwDgIKPPA +FnNLjr98X9TgzTU/Zii/wy6dvv/5g6Xx37wNpv1u65/Oi2MCqYSGWS6vq6X9u/kunArnNJW/3Ezl +r797KiRHC7TTVP7stlFYu+N0xIb/gCl9dpCl6mJOUsu/eVJS9KfVhJojYOkOoHl9PukCa9HN1Izf +/ACRj3hdbTSftDo5GAS9Erb3jzbICJO3aozNGpOPzgzoAdBlMD0quFl64zd/syp7cVammNJoMmhY +7Ur1lN+7/Y5tY81k1a3/8eY54cQJ3lEgtDvLXGn79y6/46S6QzDOfqPlblrq1j+cb6PLdsYNAK7l +SmPQtv+bN+1WCf2fiw07gFcJoaMWN5NUt/7hhDkcnXqamrb9D5C3zoz3f2bSaoXS3z2a0XjWHXT/ +izILfsqYgJX8dw9h0Jk12o1ZY9lxJJccx1ZbPP9ws+tUjdHH+KSQIPzSDxWQ2k359abb+TM3+s/d +vdj+8bTT7s4H/qvOdNSfizko8hfZI5L0y8cxgFbmY3+pD7c5PNO7mHRgarDiHuZYlmbF2WePkv7G +ZNYcNSZtfwsdRZP+pjxLmf2gLqRJ+LtgFI1ZBzTsIJe2bePecNTqjeYz/wc+40ZEoOSgwRGcdqaf +/qvGFEhNkeBVM8VfsBRDCdaDpvwf6OTLXVtZ46AJzTjO57MxGKj9SCgVZLU0BCPotv1T8bo5F6NQ +0Oy4IqrJObaVJ0dq1gORweSPjr/e+c/MX2x3Z41mt9+diVKcZGSYRmKqNoYf88ZHx38xGktLqBeD +vISX9rgbx00kkGBkEx2JDNAlBppHjX53qns0HY/EHUPL/o5xo92W91X2yJ+dz0byihnJNukfN8Zg +F0y7g3m/oayivO65fqfThjbojbK5SUv8ai2i/GQ0zk46DZzibJCZISUWkNRveD9NGX8R8TD6TMcS +xMnKvcEONL4GcbDSquUbwz8a05qMDjUhEP53mTOATdnvDjv+KUosnto3Hkv0M/qjMxnDA+KpdpUh +skSuAwd9OW9A6vJX8aVNegZhNo4ZoEzcklcoXNNygtY59kcH3mLobzb6jWHLYZKtfncM1g568f8D +9sYHoABx4CGSiYPlUDHSXvaoNO/3JTzedCZTKHxnE0MXtdKtPw8h10f+rEgh5vtC/zehBVKpn1b9 +19OO/2gAN1h2ioIQIKsctvXEKLdXmojhQzV4XaREEjwPq2Y5f6WXdOZN8bjwxRLyrjNrqOgoZmhg +jOORPvDXxsBUmkwBumfdVqOvJyvLD5TYFAN9Gb8BOM7Xatr9awobJZGqzXXSDuzRsNWft4E+PYAU +o2dgZl+UR7A8AMyxB+yo2e+4GBKebnEwnv2V7/T7U0vCkD+pF26hL7Sich7a9YAW+bQxrssKEOWi +dXXUUnFU/Yrrd8to/JeBtnWIEpHpvzu9MIepa4+SlTEm/ac42dvQr7rN9bD7H9OO1Y1uu8P26M+p +jtpVLbpquakfYVKDt1rjD7i1YMK+AmE0hJTi1/BnV9/44fL4CXGBCE9fkWbL6vQRJY7P7aTwV7So +qHj6iBHHx3j6il3oK26hr3jxK28oFHR0ZEMR5gSlQyP0TjvRE+HuEzxA8yW2/+aJICR6Ejx+R5nj +3vE7esHvLOjK8TtWv26WiDflOopEr82b76N+uzORPInw6TSsF7u6xipzTcsdCvMxGAk0vpSx5Dqf +gKpU/hzcFDUQ6U0rnPdM+brundoGUL3Xcc7if8ajyQyqQWrpqlKtc+iQR6VcGxQkjZOp1ulXGjPQ +NxQufTi9qUrftWh7BP2tRwV1S/XrOoxTgL2ajQ+FjKqGp31bH41V7+Tz43J/BJTPq8543p/KAnAP +vpUv99BNVH/3h6LgAHsf6RxG2QveFIetkYmFDd5AM+58qOhl6nfomhmEO6g5iBaUAhSYgq2uMm5S +eVMC2lTd6DyGIIGZddKZDM0GAnRrWf1Uj33QBOhFGrtpR4DYp5i0DFso6R+OFEPD3x0iDX407Urd +OHtEKD8wDm28IGp7AbVF6nxeNBSu1IaC2hpBTfGkEjfYDMlpzBC1ZwO3lmKv/Q2gJWNXh86loHFD +4I9gahy0LNBHyGTXf+TGKVS8qLnFAW5sjQRj23PRbKupzUc1rnAzG2Rp542bO09ci2L8lTOOHXaj +HD7vv+00EzfddmeUOB0BTa8DkQoUR7APOxJuE4qjPNEa9WE5AQDZyLLV7aazfryNu0BELQsEe/Dw +M7G94lF08824PQCv+0PXgxq3XQPHMX/yF6R8vZK64Xg8iSNhF+/DoHtXLWcj0bvE8rx9y4li2AgE +ad8Wxxno2LtmDWHbP0diRTj7Zp+6Zgacfo2aAKfT7sewYXQa6huipW2KcQZ2EFHDETxJdtGuMW12 +Z4PG2L4pbjPR7ROz1q3+JN4aDeFVYNAlZzNU2FLm2010VRGeP2/aetKOAxse3rnjMADQ8B2wJuma +MSSKTVshIWH08hl6/QMe0I7jny7b/WE9tvHHoBfvDKGO4W4HoQ/wFlLW0803YNFm8II3cSxxijWl +e9gUbGrIm1UBUZZDH4Mt0h2+jxyaTVQXXTk0RZ7SZmMytUEuatiEKhbYTyoO4aKxzCRctJ1o/B9O +rdWMgrNsPmhMelPtqF00lkftoq1q1C5aq0dtxuS1c5xPO0AlRsqtzT5+H87i7f548j4a2m338TQO +FTPAQ6b2ZDGNA54JnbJD0FQl/A0t/zOOT/QsCQl8s5YfbpgXaCfyLsW/bIYmpR32h1tDnLQnU+2O +NxVAqJnkiJ5OrXtuDeKSd701+KtnwwaVhiN8b7PWg2voHXMZ256hliCyoOt4Le7HOalAn2/7n0K1 +2/OLp7D/D8pBB4LjUgknM2kH2kAtpju0EZ1QvjoNGbYRVRZREiTN2SAU6Qr7ExjKqpU6wjIEtEDA +N9v+5l/+wqT7B7ob244vg+8VFctGudAwYivVwsRba2iEjhxdyQwo4zVjM5XWyvpbC8HJh7OgBG1E +IakqSKVvhapQSbAc29kIXdxo3JeCkEyJG7VpDad2KAVtZt2+2sI2559T6ZpNmzaIxzrJxokkB8yG +jNmuZklM20yB6SydjJqz277m2M2sRbMLbSHbJsPOR0M52bQUAEAxHdq36ZMt5Do3mH16IfHZaHcm +qqNI01ZaOcKbqYKAmetPB00Zfr9roySDBqNxy0YxQg2mNlNHDdpzW4PdZgeDz+03MBYx82HLFUNA +rRvD4UiJQxVDA6CTJSs19CuuMs9RAaS6PXIS6E6LDW4XUy8CYdWqLotwB3veXCgiCw== + + + CQwZJ05bUoZiSPX79q2mve4YmDlDG6ENm03AbpxMO3B4E3fdSmEH7lm99IVqblbDgT4L2WOnpYLj +UfMIGANqGtA5v/QrSlg6hpTFEi++viiURCcUtGVggNtoONW77cAI/Of4lcpVpXY7N/7onALx3x33 +O1ktmhydPKpaCn7Vrccr8O/A2YP5vcIU+7yiE4thELbfuYnJMPuOgv1dYMULHZ3CDi9G/a4kFU2N +B2mguGREaTIaACT+OZr06pJkYmymdzoajlqf4KOOapIn3aE701caNA60gm774UycgDvsSlFMWSBH +m41ZtfFXRzIz4RVT9ssCL4PA+ZzotCXbHP3hoksUK2G1ovadok+te/W2PFeKcmhuEJlP1eA29rJC +sIAAcqcctcFKdd+7EvviPCBMoQ4X9G8drsPYThrSpTWmvYteCa4S0YQZlyOZUioUQGtSvydV3mvt +l67CIL2RTFVxvNoM1mIzqgdtqmO5j80yN/WNLMWaar3NO+fgEbHrWaFWCzXVdaCo/S7V8QbDxy6Y +oEqYwXhOQKP5xhhHdXYdRAcD4Uh+IGtlQekRnUCcNoCUUNIv3HGSQmcKhtZwL0El1pGd2BOvCbNb +UBDJbM4FJgBjOVK8pRY+WKl1fdIdQKTdqix7R1ljNh27IV11PmAfU2fOrNNNHBkz+ggHyHZVKq71 +fJUTdedhl8Dmue00Yai7M49SEZGaLzkPpm5nbst4gQwMKMT1z/mgOWx0pQi7UP0T7DR/Y9Lxzz47 +ftHt5J9KgXB/fnaG/imOsGgM1YW6/JCL+htT+FjRfaWY+DiKD5kh4Fpgf43m/jHgnH7ATzp4T6Ou +MbgPWIWnq+ko6gedyZ8OwYzhxaxjmHzm76KT84a/3/gLxt83xjh0BPKq6bz1CYd3NCygoyoFDO5t +CJA6B6MbvSvdd6f++bAHK4fEXe/81qQ7dtxYqDHACOIydZU3xm7NZDPEBaVhGVU3pK458uecfIhB +sU4bCwy8Y4zBMpsqGMh4rGK7DiSskuK2chTHU8DIiiu4yNbuITWj1YUz2sGXmJkLo6Q2awzbcki0 +S14sllL568zW5eEYO+6MULV6YL+uiAi0CwvMZfAGK4N52TZ0ZX6aTQfw1f50BizyuZwc9P/93//P +7P/9v+xxJn4G9tf75Ftrxx8Ne354pZvKhOf5pBITqDOxlZklcl1p5Nla/uhIYAsd2D98yRye7zxG +9m8PgnuNu+gxvXMey2Um5cFn6mO4cVzaiIaC+W4jPt3mritFbiuVuS6nT5nDVPUpeJqZzFt8qUid +CgGSYbYIYlr4KnxEie3M3kt8N7MfHU8z0xMq4Qtk9qobE6nR8Sz3UbmsZvaZTi3fPUi3CvF48MPQ +VbV9D/rjC6VAin8ozwpfzznmIRbNDkbVafaoNvuMpLmteanAbN/mvvrBW1+g8E4cN02BbfPJd/7m +8vEpW8/Hb6w7VbdLPWf2e6XnTGoaH0QK0cC8FCq3330BhKzSG9AwCu/Pt3yun+nfpd5zn7P8J/9A +atDxtlNokdXvzP5h8BbDAUOe5l8+Xkbg18534ah9tJGLCV/b2Vpsa4jHcNdoz32B5Fco0iq22MtQ +/pN53dvPBuidSO4s+hbJ5IPXpXxnvpu+Od763Gu1Gj34qxspvlc/cc8kkWjwk+72W6r7ctzO9QOH +wdgk8jTPVms733D84cze8SftC3B7N8+Z7LAVHEQOTvcS/ODpoMvziek7nZ20jshIL0XKEFuF4+kN +QBsf7PC3NNFOdfOJBlhf8vQgFIt2cn3+YoBncF8NZPJH+1u3xWiSnYJ1OXrkttJ8fvQS2b9pP6ao +5tYzApseBsCE0tzuFlySR+6WuxxCPKVzvTAXE0nzpl0lyOet00Kisb9T2og8TGAvHHzxgqCgJr4A +0dw8YtDvSLq0L/7avy2e4Ob5aPENA6PuqSNAundEJJ0uRqnC4ceBCOf2YH+v/XX2glZSHjCAd55j +xV5Ao9yxPIBnZQBk6OAKNuow6Bm7kSu8IlQDYXnIcA/cVytbL3xFCu+Jk+9ioxHcznHN68v9SuE1 +na1/tmbZi+3WabZO0WD1s/zz/Rb4pv1QvHs7nMsowlSrIdOXngJM6McnFWnB7keF91qxjfAJwDbC +kfTW3i1eIQjZFyi+kpGbHHN3XMpMJp/XTOr09hCtkMB2JxxYvN1oJDdKvuhRqZ24Gu8SnvDCQlC+ +wF7kYB4qFfpkjjhmU+CfMtHFcNJcc5TZq882s/Xj2dyISt1KqvAuLfzdZAM+qwM+9h3vZvV4ml8l +O6XQzjic/+SuHopNYn+30JlMokTn4mBPHghGh4yMajn7ekwiatuPvZXgTj2JF46++Abe+3hBhdr3 +4CR7/pI7LeXfjwWCPGm2S/n24B4xT5M1KOf63MGtApubVQ8ecpX61oFuDL4AGEXnvFDuBTqgq8t9 +yGFo4j11OzKOVt+uBX5FZ+XxZjOZjOwxZzqM7B1NR+/57rTLQW4Ze7ygwltHFWVWe53UzgDs5Ksw +JK/TyMHxw7HU6ccT4GM0eBuo7pZnr+1BtvZ2XEh0D0IlDOA9WOGy9dPRR+amftQoFYXLO19gP0IU +n2R0jIvR0RlV2uFSd2DN58liq/e9I3WANki/gRnzzmOwCtjjQTB71R/vqttdNiqA/QUZ/upzN549 +ua8NfQEVC5fev2bq/M55vvpdJzUiY3en8J4NvmhkwFWp9Bre+ETTADx32AFbim3q3oqrD9/3NJJG +9fUuEKLlUTFabx0ALF7ego19tx1JH3A0eputRTPDfLd72YZT24BN6oWTk0qstF9kw+gtnMvH7hA3 +r59mArn+MRGHa/Wo7E9eOOzuMpmbZoK/qJxekc2X6yy9s7FdpMLbL3mynK9m4K80IHHygOg0U4dk +NJQ/lJ+lfQHtN7glegb/zEGmmEcfoj+5WpW6hG8P0NdyB3n4LIdBZfdjJZ6NFa6o14dxETbZBzwZ +NocPCnJXOdjoTIGDe4H9aUFk5MGn5S/2UBM4mgs0JDQGMBcAJ4uHAqeJJwwHBbFTh8/2EDClFwRC +jyI4ZLNO0Z8ixiDEmhaZ6Js9+BZN41BBJW4MB4exOPzYu5RRUEP4lHvZV81FWby07dK6XgjdMvgC +uoXA30BkKbDRNBCetOg4QLNS/kSg5J7Lyhh8Ae1aps1IznZJ8JDRL3lWuFPlT0xjpoThgixg46o8 +K4VU9DSL52KJrAM8U7RzJHQcKHOGjc/NkKrbqb6AjMID3TRlnKS0IA61o8kr36K3uk7FdVH2nYpi +NKuaVqgWNYaYyJpslT15hBcy88BEiudSQnhEYN2iWjUGW3pBKAerD/Eow06bMUA0NXlreiNDtCAY +Y/tyB2iMV5xAhs/RL4x+eaY8dxN/Bwz8ixblXjI7zF69f5wAtfJkrBMY2frNybCUIcmeL1AOlF8B +TtgQp9JN5peB/dLrrL6b2SMuNiLFm7uKJMpi2yp1QqUV6K0kdTtAydAwwOoLEMERlWlGJoHBcpLj +gkD1Cz9aWlP83kO1lKV728fIDtBOKIIMBF9AGB0TfDEWfWcKJ4ffjLqX3GsnezWsXWdrs6NBMVJN +hLRv+6VMMjCWjIqrsGJ84Q6OHuvf2fN87gLqMKJ2NdAgBligUAvTzlSlbPB7reurLP90fFU4nuy+ +mQHIspXno+zJ7SXQk8WRXQd65el5ZyKqflUuB8T2U1y2HeL2toO95QC1C8l2gMB4/vq5c1J4v5zW +Et2LR6A2F7/zWN+mqc1He2PI0hTyBdTGkEKhcGrYwr7LnpcKX7ev+e4Xl9h7HwQ+gH67SwKcpN94 +/qo9goOLKfqRqMbW+s8KKEDJIrDfybLgdmV/QLrwEQsf4g4u6fQbUNTOg/nPyH0+0U0fpMS10uJJ +Y4v0ANnHS4ohDPiYeg0uKgj9oFN6CzoPqpjmReJUDcTKqNhJYzpXNsBFpQ8sC0X/12r/qoEme52T +PJhQO1J6e00nC+V7/h2Y40WKoMrMqR7s5Ub4SWekYBorSt2+XRberyNlwKdLBSrcLuIdiCxVKAOS +mHG97O/0rPYVX3p53t0qFYfzNyqQHAji6u9HtxOPAt+qHucuLzJgLveDM9HAn98HspdntZtSIdyW +XijEPtoh+N68eUFUT5pjxUbW+xyohx5Yl/zn00Yqki6/vkqU9RwHKxg/yfVOI0C1v3hX9mwKelpe +cj3qYEN5ITsCiFR70CegEDmD2H5QvB3A4jPpe9U9Y03pTL11x/HLyOFN41vqoM5n9k7uN4H5+Lmh +hX2erZXbX2BdDiZU5nojidYArcBBaE51IMm9oxeAjx1+TudokZOXgKmCXl4aAER9Wnwdk83M3nUw +rnKSUWx/c+99fvGVrV837kEHqT5ResrQYDSVmMyd9Q4MXyDZL43erSiGlFvWpd2rBuZy99Jqj6L9 +/iUoLrtTaDKdmuPuVQ0E7t4PQMml8EV/r1RgH6hI+v551wjRhZWvAltV7d5c9fUT4ROsS5o7nhfi +V+1YJnX21ZNFVJ3bLA3zomsQEF9s/D3qFhJ3exkJn8FO4rPz8gbxORUHVy4ciBz09oCFYp7KDc7T +QIppFI8zJnc+px8Aqq+mxcgu966SWArdQVLitre+hUzq9ru7915pfmRSdyU1KMyxse2ebPoCSGLv +R++5CoKtkt1iSyIE7PRZC6zfw16hMz6vInWC26oyW/AZVTipn24q3fM3/WodCLrD7eIrMXwuvNcL +775AMTo6nWfZTPax2Lroh3XqkuiZ/Aj0AENNbvLTxNlNtl7NwG2YjBkHvx/KTGLJefbiKvGc6r4I +72DFb3fBuqjUGyyODhKAYqq7QEF5ui697n0m9J1S6e8BWOSPjcz3YaujvIBrNc8KzfFHnKzcRMVn +YImBPlbf/o6VQqNkWPeKbFaPKAWELF/hkM9iuf6AeAf00nvg0qnz+8zeOEkapya2g+sCWvLC5WjX +shFqkmq3m9/GJg+xApF8CJbyHa6XrRcaZK4vbAkEFf3uZlLnl320YCoOY6AidD5x0Lp7BJumcJq9 +qme+jbSxNc13D06nmVQp0OAOubty/ix/cyhrh5woX/j9buuxcNS6usgxt9TMsPAvWxtAeBCXpdDx +YTVZeSrNRCVYXMQ4ILQTbu9kO/te+Nh6ZvjUOJ4H6lB3VwGFtD4I7L0zgkT3uB/eDrxC6t4vNhMP +Y63mjUcm1He2a6XXrZ0amF/kqfjyNWshH6QRn+VZsZnbDfkCqdMI/Zit13c2NMRyeCSDrYpeKpEs +qpgJS38+WRBIZauUzz4DFTFzdAf4WCFaZ2WfIR5tspct1rN88uojybzlBmCSOcKyCRQEDWgqhWPD +aF1Wz4AVVr857GX20+NbICv7Q2LHBEQn1wvOjnPM/eZ15eCJCbqaqajmaaCE4k+wl97RGTA/iiP1 +vuMyIygNj6GvE0yXpbeAifCQVECkSGHjrBS+v5hlT+7JtqrTg5OzdqE9SEbVZxZgZA== + + + IcDlz3sfCv/FTHj09smqdqp8eoEZbuRs9FV4Tx73C83dbiBZfZvsl7L94SZyh+roBaw+PMpLneUT +T4WTk/0EVtWoy1qsVCTfQ6VU9mpTWtDbEOD89QR3UMqmc1xgzBaOGv2Agf/0L8IAN89XkJfGCydH +m3nALbUbaD86v7gvZYjZK1jzYbO0sRslgQl7Db9JUmDn0G9gGx4KKrD0biiMjUu+zr9IZ1eZgPb0 +TUTCXil0NMgmP5/OtkqFi9NaKTBmAHO57Xxk6NwDo+xFUQ0CvxQFC53hZfnaVj4L/lvJ7MfiYdNe +YKOdMnQWP4FGRdq4x7Z6WSaUuy6Gps1nyEhIPbKIafQBrQDYuLF7y15q1RwVfq+bgiCDx21oMp9k +R5/nu2rLyW6nIrKXLD5bwped74/oFACuFVVo1MpP5UD5WQD00purGs+qpWew+pltpIqgM0qoJ3OZ +00L8/HNfRbVpLjoq7YajHFCDmAAwJTJ9dNi410m2bsQjOO74Wj1TtQvikCrtRTcVA95AY2qxPW6/ +l0In5aR6kRGtXj5twRf9bK05fsfWIsVtfuQGm8KXSlPKVMbf0q5U5Avq5Zbeb/B7l+cX2dr8mjIK +FHZSOBp0p0Bs5QZghH2u9HYaSFprAOep/SuAsdN2dct8uSWdQkiOEq1ic1SJObSr79w+FxtvR5u5 +QWRHJaAlGlNpH4dnd2Clu6pzex0w1b4zzBQKlPdXsIiV3W+gch+dSRIZsc+vSfCutDMfd3LMPAcs +HWBpq2xy1GQQEgAHjRf7ua+vi0zhqH05KxyHQiV4DHqEz42y/cYAqUbF2c7RhtTz8Rxo40bltWqm +wYpq7GSrDekumr3cfQUSsjUg1ez4eD4jjh7L+7r9IM4FKCiteurspTkvvb1QA0hjtHyY/qAmpYNO +TsX+4T7HeAgQvUcgHO5Chfed8RY3O5kdlF778YSml+5L9AOsxnSXT71EavA8KKJfFzo8pIFCwDSy +TDA4SpK3J4msUJ7OYNgAUOiOGneZafhus3By/Pxd6Oy/bCoLhnT+NwaI6PcxYB9PCS7VPN9x+zX8 +NgmMq0ql9Dp7jpUywU5dexjHoY2COYxkGFwA0ZyJfQqgv2i5/CDUn4rNeva28MHudHXcS2ZcEs+S +pTTmU+KSFNFa+ALoCDL/+bj/XcpeZMap0+l8pHUNctw3mbwqtPKNXmG3m2jx+3SxU3x4PyrK7knU +pAZ2fK0EZVMjK8Tim9AXUkZsC2Hs4oGvv1USpcI8i44lL4HGEYwVSsPsKZCf9XCut7cfExUUHcQP +wOBq83pbCdzA3FAEermZY8OlBOBj7VThQ8Utxff1LRHLIu6us1ej6huX/g731CYzxHEuuF8tRp9z +wN7nqIHinEXIArL3qQswlv7ePS407zpXYLelK+X71/Eb4pHy9rHAvLw4op/wADDwWGmLm1xWDoHq +cwhY9Ml3Dg1J8o5Sl6EZpKd97vqinQA79TpaCpAhYDdfXkULxxvvhHoGuPGY5G6+37NIJJQCVT6l +gy03BjRW2nn4GBbeR88R5Doy9V+LrD4nQO9wvTyPj1+yJw9hQVl9GAIQLLbmmy/CeYWuJ+no8V7p +NXqT0s1FhlMvjnRiWwvnLf/xWQrCU29BM2QZwJgrZ0ff0wSM7jgvPHfvt9Sn1QoDSB03bk6V+WvM +6Eug/56WguVAqTKQzSJgIN1uxwvHkS1W3XN/tl1sNaNtGEVwSx2KTwebO3DhX6G+tq/xdD/zmb2X +2Dxbz/OvwOpsAws7EWtkR9lOSRkchkKHsnuZvefrHD88qpOF549nCtj7tX4mIQED/OKiDfZfdx9M +WKOKFks75epYCUeKb+wkbzjuuPvB1WP3D1RxI5ZLfA7bje3kx+0EjLUCr+nKkfnuxmMQ7JfIbuu7 +QGzHhki8sxv5XRLYBINNoO5fN8vQcxog6f8zLUfLaUPhCuhacW3OW1Kf9ThuDDu6pEDxPivtdZjq +K7Lu9FexgGeFekGXEQlv5vp4l4L5DNGDe3LVXW0lVhj0hyu0wnw76Z0PxTCqn5jG9UXS7BsPzONm +gkhETiOAU89o+Iti9i9TtPziUv6FXuzRh/VZDlgW5V5l6+qgAejlPi2/pSIHV9znRpiuHGzEEkGg +wwDu09vfCJ89JDein13w6u09vhGZp2ob0dO7wkaMOKWIxMF9CHUPVi18yUyp6SkYXKEHVvItTecE +WgBMdvCAYm3QgZLylqi8doBlMZmkD5rZ6PjsOHOSnKaFyv5tvDR6YG6Kk6cHovBQuq+XDrIHLXI3 +yw/FXujty0g+tnsF+qtyVtPFE4rT1eQ21Pr0jarTyWRvWgedRI+IBFPD01BGNhVKsxvqZdTbIdo7 +JOr5XAE7eSam+wC2MI+kyxs7aOJoXQq9eGIqlBnhe+8L/Fnug6/vC9pOnybPp0+X5p2W+Rc2dfQS +N+30ZfsMyH1dt0qnXPekHDDvdH8jNJmSgYl5pxfkE7NJpXaVTn0BpdtpMHoas+iU/Qw1gvdF806Z +8FNkn/own+lm6YXxBbaux/2q2VyJUu4kY9Ept7U9nIQPLDq9fyFK72c1pVMUByt3W97Y3yGPX+um +nZYrVN0SvdRDuv6GOgW02Cxq1/QWUPLTPF2F3YaNqxq6px/7ZBh0yowMpFQlcmKnF8GgrlOWHbyO +lU4VSsbdvk6eP4d1i04zDY4vbZOmnb4cvl1ZdVoBWh8d2nsyn+v+xvN067NzZd7pZT6c/t4eVM06 +jez1U2mlU7AuWlLaPXzInJt3ytzfE6UkcWba6Wbpg9++GlDnZp36AkTp+blkMVduK9AbnuatOm0Q +5ejbjXmnZSIb7IT4e9SpL6BH8Gwreih2eh8L6RB8eMYciOgtPvVKmk4f9okqHyNhp7u6Tn2B6Wal +M+KuGjEKdMuP9fRbfXxoWHTKbfG9dunFqtMCcbr7nESdIhtZO9ej71Tma3J2ZdppbS9IW3Z60qnR +hFmnkPMzjzGi9hreNJvrdPOk0jl7fAiHTDu9CQ4/LDutfV6+NVGnvoBxro9l4uZkvG/eaZUOXJcy ++wfmnY6PN806BTwZdnvzWt6cWSD48Zy4PTwpmHd6mi6+vlw+P5t2+nzeO0KdQvlinOvXPdsuWXT6 +JBDP037MvNOzr/HgPCnQuk5BL6jb16PY0BLBk0AtsmHR6f01UewOjk07Fc5imxuZ5xjgY6Db1Ld+ +08xf+Vex0yYd1m2a8EO1sYs6pYLpUEU70yrxtpvKwk6jSqegF9gtAPv1LTH9g4m+0+lo50DsdHYY +0c1046nxGMad5u7JIy0jjE6m1+kN0AvoNm7kSkcxNFfQaX5mYIWVTQ53ekiexHSMMDpmzrCkobdT ++RPUKexF7HZ7Mmk0h7BTQtfpZJLtjCT6Pd7QdTplv1KipDlMXcZ16N0cdd7qPlF/6DReOe2gKtc7 +L6OU5dv7S3JwY/X2k6i8BebKWwPnB6y3sGPxNViDnUheGtdXh9e95QTytS6+nfYEw67khp+bd2bv +MVO8OEo9Wb4VqN2rN+u3n42XoIwx4/sstfPQsnxbjQwPKeu3zfP3PeWtDmPc1vlmq1mx+Fqo7FT2 +r6f47XvwO6n79jrSlZTTd3IzZcDYdfO4NjR7j7lcIdKbWL69DTQTG9ZvnwqpAwljJu/fAi/8tuXb +r9nFuGL5tndD5S6VtwaMDXql9IvV12BIl3us5dtjiknfWWMs0Bo2a1Wrr3c2do6edi3fFrOnzY7l +22PqcJO0xlh2g9oOpyzeshWieLArzTkV2tO9jdQvp4fi23x8X78rK/W38m5Wec9MmeiV1gLLE+3g +Y17kP2+BPnw7Fs3R0iuLWU9uND3DvzR8jJptQwszvxE7Tt4DC/OrDv+Jw2eljWjhKg//uUX2m2y9 +YR4h9te4ykmcb7JJBQ8uYiI/B3aORh9Lb9FB8OHxAO0NaOmodkTiVBgGgR17NwesdXMH9Pe+L/e3 +legeNMOAO20WJ/O3eEzDbiebvoDSLbJ0LDrltqCd82jeKXP/YNkpECJfpE4fU88VWTqWnUKR17Lq +tK3ulKkBG1nVrXCWq6k6be/sbCmdIu1f7pTWoRdq//JMy31Np+F7ZL2qu9Ug+ICy7BRp/xadAnsQ +aP8vSqdgLpq5Plt2ChA8Zaw7hdq/Zae+ANT/P83nur8Rt+u0GrTsFOkUSqdw72u6hTpFXbOqnaTU +PfolLkQ4/9AeuGn3Mh8M1XvfoiW39f1SvDt3bMd+inQncoscmPNTVuSWhq37FhpA7FypHDTp0nwi +MpedWka34xPdrVRU+Sc9DrXrorEOeRK299Pj8P5YhhhCINLJyvYXGkU6WX4sAMbVKMKeaYU1id2n +iwHxn+jpSOwAqcBSB7JuCcYDJncwxo103ifA9nKJz04hIP9zpdaYRZ/Zudy4AHspq6f7dnwo+pTA +kK8vwIMdqNDOdyXsYL1dZMeqGVzsaBEoe9zAgIljNhBA/0CCvNVaSWaD6iWPdINSD+l1HgSkexql +goeEyo+mcwcilANu+TzPnTghHf4jDh4b8ybzC25Yzs8XUGaI/rFcQWn9apvO67clz29XpDGzGULl +9doGWe7Xb4ToE1sWLpFlA4zczX2VLEH53JC7hKy9mCfKUuhKI5ExZZWfvr1j3hTvQLl5ECl5acxT +uYfksT3efdbI0rKesJH1vBS1rIe2ZD0+J9ItPh1N1AiUh6xB4A5mPea4e4H5YhKCLcYTLUbxPyLu +yKE57u5jG5Zs22pXIn+c6dTuN71PTS3F0OTow5v6qROqyyc74mmC6UAKEd2s1FJMNavORXxHXH0D +Gy2CXm5GniZkxmEA7QBz7k6FW3kbqun8LbwDBndXsFim6JhsbAcraAzYz78gYghrKf05ihxIlKOi +ZOTUMQdGugVmBgrhXXXKs2vcd42S231nv+uArGxs3s1t13KLjF6TUfjPY0R1SGEgC8AZQ8UTs+UE +GFMvKPwHLKjiiDbSBpifzAWNtHF+KQ9JNS40l1nZdGTpcnNqNckM0ZldJwxamHFJFIvvNGJcknbZ +SQtzy3p6wtQXsBRMLnRGpTHQZh5nlmLJF/CyvmWIk4p37cls77fLWj5tgqzTkSJ4bYY0Ozy2lJXn +V+J43Kh0YEjWCp20dL6AuxUEVr6tYuGk82tWcBiwVSw8rF/5YqCAwpS8BLDa0MW4wK50BUwrULyO +SzrhFYHd2xsxXiap1uqWxtjrZIUY03I0j+Maa/0wb/zEYLjO0tMFtWPN+QsYT8XMGLRSaE0FNJW7 ++9xw4GMqBdt8V84ON1e2K3N339veDGV8HmtYyQo8MqkquIGWuHfs3G/uuDU+ZN1Sj530VBbLjm4E +c8WwomMKpvvFeZnSU3sTTzcQkZKNQ3HgAq4GotMtF8OJw7ZXDQTbyBELEfVRga7rRw82OT6U1AYZ +ybE91PO0GVc5tMGvI0jzRQ8dWDg1gCa4YaPDmLIPiw1yZK92+AJeBrW1IAPQcku45Q== + + + nmcBe7HslgEcKQzArb1vPb+gC5T73CFdoys4+zP0mrzi6/s6god6t6sgqsKMLD5Pywpn0MTCmRo+ +FjY5oP1P2i19iidWdshyv8UtzR5kJQFkedziGmTJWxx9QW8newntBj+Gc9FucVOr29m7BKh2052H +xM6XcKx3yepHY+eS1XlIBsdaDd7CKHZ2yYKpqTaSuPqe3STHMC7h1K17Q7aS9EM5nmvF8gLuDUAH +3xSaEIpUMayW+7XSyVQLv48vYOelGxzDw937pfw+EC3Ovj4dK7Dw10DscK4oWcU3NZ6GsUaVzsz1 +qjSgA2tnosiTXSjTEMsnelXaC+6wPobGE7Afj1v/An14zQd1FKGyxTwJwhOdJrzYfkldhu2n5kzn +J4rwk+XLAt7o8Yle7llNyBewoXRAO1qhtwgDOLwOsD6HNXeHmFcHJ71PJ+qsdFmAHZ2gc5JDal0W +z0Ul6uBhVVAdvwFnBZ65IQbLXaei5DwYT9ybz9s457uambTTnoq6PoIEwKz8rWbeVmxZWPlbITAP +m8/cXgKbxhdY+pACrZq9yPO5hqM1JL2NRjwTx3CW3YEYimxNKlAknuwFjne5J9v7JsA0J4TehKj2 +fDCItItoSKtx5lGY6kpOGPIo+NQXcN6GLsQNBEbFPZ/xWSgRMJZz1xUqVepn6lsjxfQcbdoLGzja +tKc/wHPB0Uw9JHmAmMz3shztWuFokvXqRYPXA3PmaD6XJ0gQ2OIcTd6V5ZvRCjgaWDUzjuZ57wM4 +3jmawXeB4SzP0SCU5c9eERyb06BoLiSf4iR8ATNtQCOEbkZ2FrT66NBcR2GiV9p4S2DzGHzj8Nmy +B7CSfHkPfluzIZeaWR7s8/OZ2WbGHnhvbBYAu9nwxGR9AUs2u2D0g3Yz3yBbWmOJL6KggFXTBTVZ +cRhnOO5Ue0soyA8D4CwfAoGgWBjUupN3ZzjaQ3eX7mWT0wQEbBW+aiwLwfwiULvQSkPwNLaMfq8i +0sbm1XRpi+/u1q03S+W7sJSGt570e3sfLAS2vH7/9G0mC71KMbhq3l1aRikG4Syj36ugyLJwcSmG +4Jjo92ZQZOvVAo5baWgvCxGHefpeWhpqZOGr/pwY9QKeriQcCfIf0zgsUVZqgqeUMAxLXeB1YrMk +alRGXZy+3d0t46vW+fkBsGV3t2pcJnvbPtbaBmOu1F1pJWEvVhYRWMu4q31uc3qaB/i8Sdh4rlyE +0+mGZEkRKLbHcXvpBVM+HjOIpXw84cqudCGYqNxd2zI8zzpyzcLeByOj3KHSxeZqTlcXbQuAWZ7d +yN4etwH1ABi9vXdSXYWHBGCM96ZiWMQgwpV8jbvywWJgFpv93jb4FlOET/LfuxqUS4owbC5RIuOt +q8izNHs6NLUsxDVA2XLTj43Y8PJ1I3rzUtyIZekXmDdXNMugwze3LJ9Dp5Zixgw6XcbQwjl09hl0 +iCevIIfOslOUQWeZLegxh84+g06dLbhMDp19Bp1G61sih84+g06TLbhEDp19Bp1NtqCnHDr7DDqU +LbiCHDr7dmJu9dI5dIaNq8mgky2LJXPo7DPokD7mnEOnCUi2yTC7CJbMtG3rGHjrTCBdsIuLIZl6 +egvOgdu77vKlSjobeeFg2IJe+zVxDrj19D4WtNLe29KpzvgK+oCNhfG0t6shV22uqCzjQ26SwTpf +nRsnJ4r2jM8OmH0clrv5IV+fU+ac6/npPFfG/eIe6QnvQ7LIfHTwXNkNySxlDs7FU9KcK15T1IWC +KLE93hKoZp5CQXD8mGkwiHe3sZXTGN0MtrS/6j62ZT81n8tkN20kpFfHIKJksObLeoxxspvVsY3W +SnJKdrO2T+0PHFTcsmgbDKIxTZ3MkKIum0GTKewOmDYEizSe2DSpb6fMR3c8q1HyZPSiXWll9jZp +6xBKTymmKPft1GXWobNtD5BldpYt62NG15mT47AnjHVuEvDttWnQ7AInVmVLtcsyC0ylKenzwBzV +Ltd5fHOnGHgPeXxNp/yXLY3Tyjo1zToJxl6VNsbABw8+t6wGlTFL0bReP8cYeNdRBO2y1oNpun5u +8/iEiVNOjB0xaKPTIbCVZYhOlJMPq8wUL8CcKd49xrQO1iUx5pgm6n6SCkdbCGNaxy+Vu7uPaQOd +KrrAepNMLne6rMHnazSz5K1+Ze63tM+X04GwANDb1EpkExBv1AsJ/3mz3d0VF8aebPE5GHsfFdfG +nhUAfYziAiCcrkYB6yzfquEuVW6hFXolnOWLpNKYbwuY4ubsZPDZuqRhVpqFEWcge7scOZ9DmrOL +I080IfsrT3wG88pGj0xNDaH8ocLMBcpVJyNWlPx15M29Y2IqYU3JIUHOwHWsM6JmptJ8AX3syO2O +V/a7pT72deTNvWOdZqePIFoYT58OngafzpSwJgGPHhnNkDT5yGBQlBf3h82QtJvZWYrZ4IlxOyT7 +6HTnpDi7Ienv7ojr/L84JWkVHplj5JFZMkoNaMLbLjwy4hmfQ3rOdiq+s4xHRmXvHy/vkQEAQjbR +HR7S0BbxyBiyBZf3yMA0NJ1Hxioj1Sk/j/HkkTH18x+7SM9xl5wDU/TAhnOmZHfhe7BUB6FVlk8U +Zdk6btyNskwfXke2XBCDfU7i+GQ1kQxwXVKXwdU4dcDUUiGHmF43aWgLBrCr5QtMILP2LnlIHzOE +LphmCzrl1XkOmjVGqKK8OpfxerZ5darUUZtMYWcn6IntJVWq3avSLW1D9S6Md5HCZy4FnZTzbhWY +tJp8ONjLKmLq7PPhvN8/tkg+nFkU9MVg1flwS+RZeMiHs4tQXV0+HPRaL7kDXeTDmdwIapnEtXg+ +nCYaSvomuOp8OP29ozgjbtX5cI63BKwkH05zYuUi1HKxfDi9LWZ1rAMz2ZbPrIcCbmUxkQCUNibS +Srd0ExN5M3IVE+m096c9elk1II8CJJbPRkdwok6r7xKOmzwSSyhYH0NwVpDJZYhksImBd+ZoMLnO +2iFmjHdW1bKxiHgOfu8aIp6D3w4LoduElt6eu5tltqGSfKTyKiy7DQEw22tlzPiY5Ta8H7vdhjba +OMS3N3vRlNBWcxswguNt+1jkIwM4K0mELCTcSTFHONZXAlvcpmUVZm28EtjxNjStV1p3W2M4avRh +weQz+4udHA1qOSOV3Fw0QEQ1Z6uLhRfKSG1svrpIInWZkdrYbLpxGTik+q0kI/XpezUZqRDOKjJS +Yb7Y8hmpEMoqMlIhHHfXQOtMYrO4PrRBrC9N9RxkFI6Jq6/dhndLb0NdKpw5H1t1KhyK57eN6FlF +Kpzpuqw8FW5xv6UWY/a2uwe7colUOPUdRCgZ7pekwpl4FX5BKpy5f8ylfXZvpxiqWYH6/mS7xKdP +y1hVNzfCa/WxfNzBLHIb6AVBsa48ii4cyBCY9c12HnUYwyXDXg8XVNno9y6PcOxu5wWs3EzkKb04 +Jzfr8+qeLK/D0QsHyTtqIh6U/QurxkXN+hPXAJW4TJ9/lvs3jdfCVnteLCW3My+levqimEnMgoDz +l+qH/D0qG154KE4y2QpXP87n4q18Ppc4gUUIamNJHAX62iGLHidtLpZZ1hm0ksQcpUfrvDPhMnWh +Ji9tstte6/xU7XxWdcp+7gb2N0ZWGXbM/Z1dsls7YdkpUarn7DLsAufd04ZVp282nZZjSVWn+lys +VGSq8sLpk92Yu8+qXJlQlwK2GbJLdiPjuk619fj2BlYZdtzW1jc3f7JKdnu0yzob2GfYjep1y053 +qp3PtlWnHft6fJd31p0Wzx7LlujdHtJ7r1adXmoz7NCqgg0rzhr9Euk85bLdnlk77FXQtGSeqq4g +MuEL3E4UnVXORBE9k6ykdGne1wtUO9+xi5BbrQYbGeK5aM6ILnZGq0ntcY5Q1XtNrOtYfbsYkupc +zGZQTsGpTnEe2HpdZSU5s7IjJnequPAu2VWS8+SFeyy4DpF0yIZEd0J6iOtzKiJnG9fnnp4cishZ +zs+s7ptTsRG383OuNeAa6U51RnR3qS1RP879fil3rAsRWYa7ui1AZ+/pXSSbbjE/jNdsOjM7QKrF +ubpsOpf3wyyZTWfmE9Tvl+Wz6cxy6RbNfLTOpjPzxZtH2i+TTadBi7hnTe8fWyqbzgyUww0hC2TT +LSiRPWbTmZ3TyLJyZdl0Zrl0ant/Ndl0Zrl0LmN7PGTTmfnapQrsq8umM1td5OldaTadmXKjjh1d +TTadWS6dxW3zS2TTGYf0uWWtKS2aTWemnPoCq86mM1s/k2ioJbPp9KAcawovlE1npVuuNpvOPcaW +yabTgdKfia8om24hjHnOprPNsVpZNp15bvWqs+nMAIBeVpxNZ3ZaoouBX0E2nRl70Fqvq8imczgZ +WVE2nbN8WUU2nRkyFG18Vdl0Tplcq8mmM8uls6zHt7wBGFMMQE19MU9XN1lX8TIWqdTX5nCZ+PTt +sNk1yGdGVrVsFq9XZxjSDJ7yrLpenbV24Q5Ps0jQE54ULGkiIWFOpqNi4ZIENAkKFlnPVoPSDckt +K3BRXU57MLXQkCDGwKA8lV22G5J5IIUlh7HBk03ZZQuWCaWY1iI6JI+nOouI3k6OHQqb23vm5GpZ +doXuli5zp7rnyqVKvkiZO8vqcieucpVclrmzyuRyl0jnKkDCPj5ZKXS33FqV78duqszYeqlclblz +9ChCxCxd5k7UYewL3S1d5g7nvjkUunN3eDQ+WcE9V/ThNWm/iO7zLE5WFqI0PlFU7oVzecDUDsJu +6dPylAcWqHOMPXSiT5hGB41nWw+8q0Q6NxHNPucMQ+sgDtf5haAXm7BDD0FkEDuWrj8tJbursAV6 +3grq84ngpamWcza7G8rqvKd8MVgwsUsTDQWIyiEe3HU0FADlGD/mOhoKAHMX0W0f2Ix430oyH5c/ +CoEVBW2uAxdX3yUcV7VdzaCoIrtqq9iBCIohk900U9g5lx0Bc5VYa1UDQp9YWxsaE2trw9XdCgiB +raSQMaIxMFo3zEwtuyxRWTdDpWO9V7sY6l3jkS7MxDNGUNta4lYx1J1pbyWZKfLNx941CSOo6nxV +FQzBiwvrI2LXe//aU6Fqq9M3WHhtaXUCQ7GL6vQAZwW3BGA4y1arxlCkTWh2w6G3WNVrF4kMnk54 +wxGTbXjjIpHBlQd+6Qp3Un6lVY27BbahSXDFonWrvVW4s8t8XGIbSoQmVrhbSaU8x3wid5Xyls0n +kivlLb8NbSrcafOS3OSHLFLhzq7eK6xx573CndtbzWH20/KJtU/fippjZb26TqwFwJzVHJ8bRQfX +plsssVaf+cgu6z+C+YWnpunQ3u65QnAW4JuGOyIgnJXkc54S7mwxRzjWubC6JCaf0zUTqFyel/x2 +syQm9akoZBBRwzZMhRwWwoVfS6r75jKNyU0SU/DgRW+JqqSYmzQm7SQdfKcKKHldLNOYUiFXGeq2 +Zru8K1MhN7vSTRJT8GCoV74XtSvvPCUxWUUQwdqJNpLWm2J4J+bwLnErv04xNLks8Q== + + + 7h7XgFhFjms+bn2rGLRfvFak81TuEaHSWh+7X93VVPfo9G1FOa73lldTeddhmlNP5R4dKuUlFsxx +Ve1POQzDRdazc44rGJLrrGe7HFfRAwQXosqb9yepfjDjrXJQL/TIfC5xfFvY6hzXfIHCYaRWPxi9 +RTjwq3yBsvtKd0+lNhVMbxaw4EGuXZXvWPylScI7O7xSd6rJh/MFpls39xdqV5W2Dlsq/3hvkQ8X +tk7Cm8zfUqSWJ+vS8Ihdq9w/bmubvwo/WyXhPVl2CuayWRrTlnMlylsP15adBo+a8Q+rOmxhpVM5 +k0tB8AVLqTrVpqZNg/yOUkeQ1mU5hkOHj32zTn0BiGB9zTlNGl5Dn/unRu/J/oVFp9xWgDkrvCk+ +WH1G3KtNp+VtzrrT8uXWg1mnqO6bUNGkVuo7vbKrI3hyY91psXhd0kR2gW634fuo/EtMwpzvHiS0 +q2/Rjs4Tlu3U+ZXE224q6wJiJDWaFRUxCeZ8z+iVTvmwRvT2aIVn3sZPLAs6l2GTAKlsGJ0GaaqY +OQdOupDNAPaBPrHJ0UNinZJkDK2yHBKkZOtB5d2kNjknNk1XVZkFOXQdKrO49SQV7EOrLJfOUJkF +dFDzEoJml3Wnu3lyiaw0hwhNjCWfO3rSHXp5nZ/stYZ5d56rLFoMyRClpd8vrpHuKUrLF7AblLWf +2NuQALe0jtMSx2OIjdWxq+JTeld7eF001kxZzJQAsI9cXH3t4IN9Ka7q8sb72Ia7Gw5dZCPZupfd +nvK8FJe5iVbJSTRcGbdQspv5kbWne61figt6lrW3aMIswGUvoTW7K84yX8zJajHeFWdjAJn7x7RB +IyZHrI2Sp3oH1hymtDIbuVHSc5hFT71xwp3VPkYnVs7l6zQj0/v5nV12qB6fpVeF+TYEEPSEiXd9 +xKL2U/Dgzvpw0FsimaGexRJl2ewzmTzlWCU93XOgGpIu/6VdtvMdO2rjmiGpQvXF02rVrvWYCtjb +dpHKqb7nyiYV0KmkscP6KSfv7bJzoo5rYtDVNTatMuMBmFMVnaA+u9YGmE6qLIcxx1we95PUnlwu +iTHHejqeMFZlniyAGdKFzbRDEWMLZgG6zQF0fQ+JVYKYqxxAm+h0F1mAbnMAjf5kL1mAbnMA1Tcc +es8CdJsDiLzWC2cBakjFxsLUx8F6ywJ0mwMIMbZ4FqCCT3u+oc2x8poF6DYHULaRF8oCtBiSIQdQ +fV6Jx2Oc1fJF+dxXZFumKJ9qLr+wKJ/Bq/BLivI5VWRbTVE+nDNir6AsX5TPFzDRCldelM9YH/lX +FOWzro+8yqJ8rupXLlOUT+1VgIPiLAclosgpNdi6qt/yd0Mdr+JuKJd1/VzdDbV0XT/V1FZwN5RV +XT9vcUqL1vWzr+q30N1QJnX97L1C5pa497p+5sRnezfUAnX9nCl5FXX97CNDZM/VknX9nDK5VuTQ +ta3q5wt4cuha1vWzn5rOd7FwXT/NQAxV/RaoAGJa189+QmYRqovU9TNNR7S71dw9YlxnypreBb1A +XT/7m7/kM/El6/rZCro8kmIrqOtn7xb2dAOVTV0/e1PXNAp6gbp+ZmmSytZbrh7fCnLePdX1s4cC +/fyrqOtnf6Dicw1nmcR3fUbqonX9TFRNVVU/dXUGYom6frptSGir+mnu7PKcnkLIdf0c815XUtfP +vqqfTMlL1vWzD7hWZaQuVddPyd8yo0XdPVcL1/WzRyDSYFdQ189mr0179Irq8e3aQ3Fdj8+hnJzr +enxL1fWToZhuH6/ZHIa6fjZ5D47Rth2vdf3sNXl448Eq6vpZyfAb40niYvlbLtR56STRaRs61fWz +P2/WRhEsXtdPi229tbhoPT5vQRrW9fhWsH3kqn7L1+Nzk8TkdHuDMVbDWyk+fUbqcnX9NI5tQ1U/ +nDG0fF0/OVXKrq7o0nX97NUcCxrzXNfPvqrf0rc2iXX9lvT1uazr5yLvdQV1/eyr+nmux7dQFq6O +Wxrr+i2eDK+q6qfqZam6fkZXsrqqn9UtZ17r+tmHd+mk2MJ1/ewDnXQ+pYXr+pmsi6qqn/29cO7r ++i3ut9RizHvOk4VduURdP4VxmVX1Wzh6UFfXz5YiVBVAlqvrZ68YYut1+bp+9gmxokReuq6fdpL6 +qn4Gfcz1TVbaun7WShDWYRxusnJZ18+VDrN0XT/1ShoPcGyyay32p3ldP3vhYJvFubKEWCz3Eybi +4cFORzu/No/40N8r9YlvVNTJSvDU2rVrH3ivS1vUUJNEY8rpTfpgrM6Dx74psauQRkLGRwpiiMR5 +h5PxeaaxRKtTmPtGTT83gFg53og8nm0TibsejxvBfKqN7dP0UZwIDTcSrccxQ08+j0vp/nPy8no3 +FBuEg7nvHFH5OMtufc9z3MZTo02DX2+ZACvsVXZOz7+v2O/e/aMvwLNxpiWclu7iJ/HJBlstM2+5 +q971Ybt2yt1+1jtn7PdNqPO+fZsNM4WvzfrVSS/V378bdQ5Dw+9X/jswyQy5s43bs8PgNh0qc4H3 +x6Oj8Pxz65EZPXVS4t5HuZ3p63rtZiMeeclsUB/fN5F9OpghSrmTHFF6bx0TZW7najJ5S4YmU+H2 +aLr1wjWnbPPxQs60rEcOErHbOF1Nbkppb1+JyfRpBIvNJbdwbrWRh2jyS/ceqq/JbOtyDA1quQQk +rCc5fyMDu9lM9dgMWQgZYLqzHbgu9PaG5VxRRmOoEexcbN081NPbw0mitEMxH/OtfnujDTNJj6Xk +0I15dMycwXi10yHKSdzIlur1ALHdaSN7/2KkVdnHuu0DpnaRVyXNKf5W1dQAWzPDQ5oL5Oe+QOGh +1LlDBTTzz+WrO+4s397MJGb7x5nEtL1XSm71Loq3GfoFoG2YLvdv7p6yFW6jCeDcfEtgcfnMEBnp +8TCV8f4ls1fdmKBZZQcjSMnZk9vb10jx5q4Cf4EJX/TjMGk3is36NHs/QZYTkZiFYDTC6wxz4gQb +D0q/yBDyHQOM8EPwJ7+Lsn4Bwzkagz8PoojDbAWBFHucgAf5uPRhKVEqUqcCAFshIoVoYF4KVY6O +yGjwc1Bs9b6TRCLNh9FA4eCeyd08uZfvNhIkeHEQUb1obOcPfAHpVT6mvKJyD9eH0oujhPKC3t77 +yEovzkn5xYuItvLBrvJM6RnK/XI+qnoF+xbhlMGuB5jYBTN9isA5h6nn6RdggOUrEt2EQ1YOr2gw +3ctd1XSbHxGI2UuA8oNRj2xt8yn5XAywQkheObIVOyBhowTMWxqQrcMjiLZLUvzm8hqBhUmt+1uw +5wjMLUZiaZsKxxio/ddjSqdU+DCzh3vZgwfeV7l+/GM3e9F6rxZOjjZqCknKxwJ5reEa0BqcOSpc +Ke2bwQOUvCjEy+qBDDHHzi62O+XnB+EjW5tvd4sP7QsCzopE1Isp+Y16nr9kxNW4f6El8qozqqkX +DvmWtA9uYwiBVOEyDyXgbUIi+1sAu/kMa7PdkqK6y96K2sUI/qblXwwGUdwbcODPBxHia6sEl+Qh +IX39QMi/SNVo3qiXrjSaBxq98AXEV4XetrgPel8snotW0mrPTHc0bEbmAhZsBshKyGh0bCb1fD4K +FW9zp8e5cH8Cc/q5Sq5IxOtGNqOv0htE1Aa4gIBudA3L52KAW4o7/q4XwSSZu3uZglltxhPdzYsd +ejs5mBFEKD4VpwuYC4qbRu5J8CcTRlnBZPEpA/9MgY20/ZWGfCOqWv0n8M0NpIlKHKlBMFIljgx3 +svwSh4Z5JWHhgqkQMkHuqNwpafYkBENFv8koMXzzBaSFOtnF+y6aDzTlZ+L+BToc3M4nYOH5m0r+ +rZdta5hQlSDY5glciBMVHZDl3DfUOD7OEcbOQAf3I8SJ4dSfsqJaAlgPfoaZK2Q4WNLYyiHFOWsa +aS8tY0h7Bl+dQjUnAwS4MMd6zQ47KqmUO/RsM5/dBJ9dzWDjG83dB5KmFFaDiHaLOhCR/PZhURbQ +FSqUvKcVlQ0929xMH5aJdmBYmEwORrtqFQLoB+hehVJAAUF0NtmEDsTd3UVWBtENabZKuQ+RGsLr +V3zai9E7e48kwHEhCilHsivRU0hjcfz0efoKt/jTVGIzrzMN5reCYplj6uNS1pSeFSUJFZiGquYm +fHGPcKfSk4OK0rKbud1tSLrJASWpJfh+BiD+NpmyvtgyLIQrrct8A3a6gVeAmT7uQClWet2Q7shI +bonj6V+fqZX3++hQxFguDJ0e+FKIynN88+sa4ClSAp3GY2iDG2+LgF44MLJyRERCYVqTkfCkRsL8 +8VxGgu7GjogKBY8Tuqm6u0NGgS8Qzj+0XyQkgPGokcBPLJEgoWB3W4WCw/z3SIWCw1BhglAAKFns +Vqr/jZbEGQmACfUSuFOaP++JKKDmpBkd4Fs17rVISCiEfbcxShQxEia5+0cFCaHm9tWTBR2I19HK +VcsBHzMjJVsQEe+0qI0cls4BlFF4HkPMDABaF9cg4gtuKSU+OUwsuRpRa5pGnF8ahQ1NR6MWIFzh +AXH+aNzFNOjMZSgkgmgcnmvHQNqPAduVtvwpSkkguC1lNaab5ZO8pl1iV2kHS6VfWNR5B4sTWpbG +wsvTWGLBMahojFyWxsLL09iuJQgXADCNxVyQqQaEfhoOqBRpzBYTxJIUkYj4Ai4wYQvCDefzBWxB +WKHS1WpAAHG1t2chokq4Jmwk901BEMtOQ7UzfIHFpkF5GgPa+/pR0M77s8IcnOYjeAyTNKu59OuN +0ssARSK7xQQV9T4GHbekliUqKm5GEZ64JeVGuTGTQwq3pJbd4hSp/ZPS8TGKFo2FULsODNLMFHtk +kFWmaPrp8m0IWxGKTVd8Se2LZt95Zyjatne9GPVaaUeJROM7hqxheEfE9DMGv44jG4Q+vN5Etl9Q +Ok7cCqKgH2QKY++abApj31rw4Oob/JmJ4T+fpx1kKAbp7f39t9Jr+BHVf3nJfMjmakj2+j0T7VAo +JdmnqV2VY001g3QmqnKrBQ+raelFKa68QPddyC4YYOyqPG6HN+Oc5ClLoWmE1T2XMxGVW03Vc7mk +OPReUE1o5IWrJkSvQvmcgO6BCM5MAcYzhS255kugIU33MoIdZ80xCcn+Miar19tUMB2CSY2XcdG3 +xuUh5VwSuLrchGxVztEDEWzr4ZEUfaL3pUjitNaD/KCOzX8qzKXaUqf1OO6FCG8LBNWvBYrRZPgl +s0fcbCuGN6IxyfTG3qf/v7drb0hjV+KfgO+w1Ko8d7PZV+KrKojQolKRVtCKIFu1WlAe95z+cz77 +nUnC7rKi5WjvrVWTbHZI5pXkN7Prkzyt4PR+YixAcR69xLMUSYSiaSyNNrKN9aG71bAPd7xvvZSC +4lr1pNLf5hkNpHEZqhdNT3p3IULyNRdF3Mqb6Cq+6gpsa1VMCQMVr44cVbpvUFWanF2IMCDdS3fa +qkSvHSTgCAKgY+3WNlJs6fhelAFt31eJvLs9OVa0L9OnNwGwRqOI23rvR3DBDqygGw== + + + zKUlQkuRk/iKxAiktm02UxLo2jvfERafmeJ69QfVBQw7q5BzOxUi5wHYvSowJcw6lruLclpoHqaz +4MpQzgbgDxj2dvKbYDDGR3Pi9X1gYRsV4/Z0rEuo6ja3lhXeyXq/vvdx3lM7iWUwvsNPUmuDH3ip +oc7IMaBdIPkxjF0gTlsF4WFS4GG6d7v37/olM3fh+YKfYi6fSIh7xSwelfNA8BacGZNiMvcbKSZw +LzRcBaHtX9vIsUNdhe9AU//ZSjDTczRGiacZx5N7f3g0vL2+7Wu5xHrC2KmYZqPfG5SGvn/i/z0u +Dq4mP/3+WFvTjJ16oVJhTtG/GvR8TeSgOJdeBGOQ0JpKr4lGImfybiQKXfzO9+/KS8ebneJ30tyK +ZOWII/7qw8ljMnfzA3YnyeyVvpzMtXtnyRwt1ZOp8iiH1aaEIYKZPY2HXYKSuJmloj/cnexlD6pf +YwC6WC355cn+ZmJ57+uuf7xtjK43jPJO61OxVfpS3zbGZCCQijg4KGcaBCvnxDaHQzpeSaY3Du1k +3lj9gjHOIszlfZEZyVx6extbPyazn98d4vwO8cKHZH7H6iVzB6flZOZxaYj6zxSCVJpgohzNKmg4 +jN+U2u2pDdYGwjAS0oTM3PU1IrtfHpWPRZAY7w5AYkNUMRMtpUo//IyyItCeqBWJ6loKrbGcV74D +X+yhSHxvrI2niHMlslKRcmfMp0vY4hGoMP6UWP7fRaDC+JNEvRePQGEVthZJqNa2Q9pthbLXSmLL +kAHH5u8KRcMoPBPZVFUG9n8Eoq0dGbjW5uADHt9DtSHIZqRwjNqZFayH2Ugsqreiw4LUrIbr+OX0 +U4Syt4BjRaOzsbJ23V9tlDb27B8xGBTzET5Hk6umGVZBLgCHEfYLIcV59OSzDQtTnL7HWFBMf2Sf +Odsvba/6J8VKbzOprKl5agZhJjoTv0nft5emi2bHDqbeiapX90j405xyud2GodS+e0rMbrWShhJs +N+S60r2gW7xCQVbdDuY6qHLPFiSUaO+OBcW8SICC6ul0m3R3Rqali1DbutGt3F3Pily4SFptmItY +3S8PHpfFXGbzMQrRHCrQ2qibCbzA790MektwNOhNNlRaxdbdB+lrco8PR/PdTODHhJ33VowVBePL +5figr6Z75Gem++zVzXpGhbfBNYltN6ozUdvur3sdudaCc8EVqJySC7M/usPzVjmjXIr5zqDF/FlW +hLeDZT2vngEWMW5MkTlV+6/9T2n1DJpTMuanCYL/mSok5plOk03BM9gpDIXpsT26jKmnYht0uTTL +swD4miDQpEej6w8FUvy4MSBPvQ6sLyrMtJkRETYZi8oKuclTz/6FwLoP82qlflgzFo5JStpPnuwI +3v0hxRjqE6Z+DDeNH+ERcV5gB98W/Xka2BlmY7Gh4XDjQz2KfZDKeU6fJXGz1Whn9oIgViMWxMK2 +pWgIq0U/xkJYZG/jSBKQEa/PT0lMZkiUV8pRU7Hrq9P1GuOmuUOKrxVFfSpnsaQHbYZoE+8u3AKt +zdUfcX85lG4GFsdWbNP6+mNx6qfIcUSeqKhVUkVy1n8eB+Gj5gvhI7Sc34ePVIR4XuxEvlt1wdjJ +nMhJBMNMLL8K4hAvNZQsuIiyQET0FAtaIQtgLjieKBNwo/8bJnQ2DkMWWGf3JgtZgPtsPRZGDN+9 +vggTFkH6X8ajxR9FfjmG9mIYEf9Q3JSL5zFFWjASiX+X6g26OH3q4LlRLDaG9vBlAlIuL5Lojt5m +Uvs3k8AqXymN2vnDAjoN3jJCIqbTtfYzZrEoK2v+KPSWrwrMbtUGyd+PoTnNPpw/iuE0c8Fu/gxJ +kPJB82omDH4e6G8zInhS+lY+jumYeI3BW3Ss3n+zjvnjN47hPvlmHfvSf7OONQf/yvU+JdAdBjr2 +goq0XprGzcKsfFbH7iZvk0azHTFXybF5nHiRRPffeT5cxeIk/OHbpNG8GcVUSnFscaVq3r1CsWfe +x7TV7E/eOI1hcp5lwPll8WlM3r1yDME+ubW09Dv7pKPzkERy9ctNPTqGbvf5NSCyIr/Eia7/+JYx +oLfs3rxRqbp3o7d6y25//FtX9+I61H2cRPbJrzLx7iQZrV4tvZupriyJo4JEijEd8UMW0Qk3hpAQ +f7zNxAYzPNNFjn2d9z/P5VF+dbPpTLMw2+LImJ9mvZ6P5LkySFpFqFqVUhLNg6NwZvYoLE7GOVUt +6OLcrAe3GQHAfh7CwcgxONhGELc/F4EK40/iU/5HEagw/pSYjUAhDLbfoAIViwI9tUJWAGcK6KlV +8tND6iSjToG1qi6xNXzXOVSPCe7+TfjRQ7kYtVNJ1vpw0tdVavd7PT2NRVWELLNRpLB5pItPsXaZ +xdb9i/T3wo1bOtq9Z0ssAl1LmBYO3uo58ychhPD03jw2/hXFefQSsxQbJKToNjbXCjuNlfXLwo33 +6WHnZKf/VUJxu2eZCxVoujoNMqZPrPDZhah0u9VcBIPtKACyeyyfbcAn3NOy1Hn3RQJwITREd1tW +GWMjTRFoESUl2O61I7E1idDeNXSZ42gGWc/5ICyUj+Kydx0aAdYiiPDdtT3Fj1qOmsspWRJHsxBW +k08bzk2wzv659GqBKsxPsP6D6dWJ5WcTrP9gerWMRc1NsM6+Jr169M9WYh1UqmKa7b1+LxpjSiwv +Q0vdH08esIPT3vWvb/vVzi9/mDA1+UXgy9Qo/HcczXQs8U00B9ur3URq6Pfa9/73cVqr9hPLbWNn +OC7eXo1vB/3O8Je2Bk2mZuwOBvdaaqdSL33V9v5+GAzHmvgU7WSgFer1NMa2Xuz35XZ02733Z/ob +pwfVRqWorWliEH87JTWQdSRhkjYMBa7LzsCBdoJoO/B9+hf8OEoQncA/C2b4fEF+nXYSRHEC7v4F +lY9Q+AFNf2m2dqCdfSNaDwkfJ0yqc0KZZlq641qO9jNhmjozCZCxdc91XM0kOiUuslJ3LItqTHe4 +RV2s29x1tULC0im1TYp3WLbraXlTJ9yDSwwoccvWoO7ZnqlhR25zuMXVTZO7lpanOrMs/DRPd10C +NHROXU9QNx2T46dbjmvDLUDd5tTTYHy2yz0cMbMcIE511zZdLT6TQqL0jHgxuGlU+mPgem/Q9bXa +fQcuaoWb2/uedtK5lgIgL/T59eBHpRSKgZuU2B4UTJgWpVEJcQv/4SXLQ9Ukuu0wRm2UFsyJ2nJu +rud5KAWii+lT3fbgAofOHAjjJD3uAGctbhFZdxwTJmvrzBZiobrJUet1zlwmxGWbwFhLtym1XA37 +OZ4Qged4Fg6RWS43bSE+5mFPDqQYUvIoh492HFdKgOqUA2dRI7iFg2UO4/ibuJ6txSfx/xNAZgIy +YC4hHrKVgVpyDgWPccdmoSGAVeguJ7alURSUaQKfoYVwC+6zdGJzplWhxQRuEOQU9CEcfQc02aDH +RHN1ajlCucIy3kJMx6WCM2ASDIgxkD9ylHPbBBnYjHvChDjzGNwdb6lCC7DZlC0czA5bXDA8MA00 +JNd1UKiiyLknWpFMUKmiytg2jHdKATXBRDnC8JEhYBgUBQq/OSFCoLGW6rwWW6cOSht5Zgu3wCmn +KGXPlJ/mMFNM3TWphVRjLVVsccHwscWGgYgGwSAOpstsuOCCnYApgMMAFaJyCkLNicWJK4nOtAga +nMFQLZgdzFP4BU48YXLAUq554HVc8EIEbg/LVbAUz3KYreWxp7AVqluui3cybqITiqtJ4YniVBPf +YcEpBnRNtHNQH+E+CUxftNiMSR0wPVQJUBYxNegam9pMi+A55wxbPKJYDtTRCYBjdrEOoxG+EXyk +8o0zLYIEsYEoGqXjCq9oC++IcwUjh9+OjWIFgRMmjTvaUBUNsEsUDVS6God6TNZBElg3caKWLmQm +SURbqsgMx+JixJYp7cMkjEsmCHkr/XWiyuxI5WcOwXUAO0k2iKJLwBdN+08rKFSboVBx3hyUHgxR +8RsWEOEWQH0IaGPEguNN1bDJ0S2LIzngJ3M5+AJb2hDMkFJcyWzmWkLbYy3VBOgILnvQ13OB1xrO +FR0tagT6zbjOFJ5oEWpXppGo7spNDmx5xKYin4f9T61z7Z8MO7f3sOW5HnX+42udfn8w7oz9B7ii +XQ/90Xgw9LXRzeAvbIFbpt1h83RUSvwXgaUoyw== + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/originals/SVG_Right_overlays/Blue_right.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/originals/SVG_Right_overlays/Blue_right.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,1574 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + eJzsvWuTHMlxIPgL8j/0faAZaXdoZcYzg7d2ZvVqLW/Bh3FIiTLZ2hg4Aw2xiwbmMBjqeL/+/B0e +WdVAAyhJFLc7Dd0N7yhPD48ID3+Fx0/+t9989Wz37ds/vnwWb+eb6Sc/Obx7+eL923c/vyHozS9e +v/7xh/fvEPTT3/7sZkm3MzTa/WL9Whr+w8t3P7x6++bn9Cf64x1++qdfvfjjy5dvXtzsfnj94v5n +Nz/9Gfzld6/ev34Jf9u//vHl1+9effen97c//Pm7n+lbAc3xxXtosCx/N4e/C/My38zt57lggxdv +/vzihx9e/X/45xLXCLD92x/ffPvqzXf7t/8vAm/mmxjgJ/zlv7767csfNn++nec5uzbHt9/8eP/y +zfvfvHv7zcsffji8ff323Q8/vzn85cWbm1+++A7+8uLmn16+fv32X2/2r1988z8n6HX++u7V65fQ +wfsX728W6u7uF0v4ev/jq9ff/urH+z++hK7HUhEcvyaUv/8BcAFa/B3B9etf3APkq5fv3wNt8EJk +2eGX//TfDsDnt/fUDoA38+1ys8DPn/5m96vf/fpXJ3hduzkgr/53+iv8b75NeWgRluybhIIY8Idr +MrSI8PnbNuCIlRv89u/3njNEEjb859++/O4VzQgYrv/+M+npu7ff37949z9/4GbA4hj4L797ef/9 +axhUHYR8s2T8pr9JK+AqtXgW13rzLJQIf46t3IRmbfp4vfzzq5f/+vObX71985IHZffu/Vc8M1Ka +Z/7Of/ntj69fvvv9m1fvgbKCoMaj8su33758De3t83evX3z3g3Zy6d+5we9evPvu5XuYU29f//ie +Zvuqb4BRf/7iLy9x6iz8gl9///LN797+A9H4rC63MQKbc+OfMCSxrDclwuiu9Io0Qy/nm9m9m0ae +0SMyRKXvgKn1k9/A/Pk1LJ9Xb34uFNav//7dq2/7nKrhZuVv1Inb1f1r+o+phY6/f//yjVAPc/nw +Szc359tffgVvPL359vD2Hrn/A647mAFvYHK8fvsd/81+p7/Ax3/8nqmn/38NA/Wbd6/eIM7pV/SX +9evfvP4R/vT3797++P0v3vzL2+mnLG5+9+7FN9Ds5td//B8vv3kPYkMA/bevfnz1/uXti1ff/+yD +iH7z+sWbF+9uCA4fZuDzV3+Gv7wAUm74Y/CXDvs40uPLf4Gl3z/L0NObP798/fb7lx1ukBdvvr35 +xxfvvv84ahiGdw4D/Vd/PqK3L97/CaTUyzff/mBk8X/HjjLs4/i++gYnxbub/bsff/jTze/evn1t +aMc/GXYBExTb/3W84zf0gTe/fsMMOn+TNNi+CQTCX91boPXDb4A//jVjP7x4/frVd+9efP+nV99c +esGFv9ub+G+fMrH+cv/Ht69f/XDf55OD/ObFu/evvnn98qu//PD+5f2HsCE3/uXVm29hIpLQ6dS+ +vf8edYubr/704vuXhPP9n+6o5VeGMH8NgtGLvmfPPiATQ7zZv3F///t3L759BeJWlKWb38J/X7y+ +UfDPpstgEPeA6Nvpn6f/Ms34tcxxTnOeKzzr3ObdvJ+P82m+WxbQFuKSlryUpS5t2S375bAcl1OY +wxJCSKGECs8aWtiFfThM4RhO4S7OcYkB97JYYgVFrMVd3McDPMd4indpTkuK8GR4SqqppV3ap0M6 +plO6y0BLXnLIMacp51zgqXnNLe/yPh/yKd+VuSwFNIACn4Y/l+n/0s70r8X+LRf/h6pjsO9R/gFp +xI4454m4gv/0e5F/SX4rwLECPNPvK/EP/zX32w7+7eH7bqIfB2LvAf4hk/k7MBvYjcTBF3RmRkUU +mNh/+S/T3d3d6e54d7jb3+3uGjzrXb0rd/ku3cW7cLfczae70+l0PB1O+9Pu1E7rqZ7KKZ/SKZ7C +aYF3wcePp+PxeDjuj7vp2I7rsR7LMR/TMR7DcQGy7g6nw/FwOOwPu0M7rId6KId8SDB04bAA6Xf7 +0/64P+z3+92+7dd93Zd93qd93Idpv0D/7nan3XF32O13u13brbu6K7u8S7u4C7sFWHFHY3V3R93B +Dh2pU9gt7NjOOofdq9RF7CR2M1FXsbPYXegwPojkdJqo59j3A/UfOYA8aMQH5ATyArmRiSPIE+QK +8gWf2biD/IGvCZiEbAJGwdOIVyvxCzmGPEOupd6Z86/TI5/j9pnOQcKjxzz782e6ANydP9CZdPOT +r/fvoE8Fvyo9KzxNHhjMsqcH5gXwAZl6V0l0VBARIAwiPanCkoUP89da21QbPLu6rzClkIkwIncr +rZh1gQdkyAqCYk0rrPSV3rnWFb/aCrNoham2HmgITjg12jzB0gKR1EKLLTUQDkBebdC6tbajB+Zn +gzmMY0cTAWYVLEIQYjATA8zHCLMywdzETgFlNJS4/mgdBnoWEoH8JBCFEURhpt/wewKxmOkp9CAH +CnaGhGWDn7uJftnjS+H7Xr4f6IH1Bt9PKE1xNgeSQ/SuGPALJChIWHxAFoKUBYEX1omEbSOBuwuw +KEHiHuH7Cb7TwgDZi9J3AemLGFDMgiCFMUGDuJI0XqHvDeQxSeQHpA1yi5cP8Q/5iPxEvjbiMo5n +Ib4nGIEIFGFXZxwcGKIjDNYBhmyHTWEQ60QjmmF8I431AvLyDlclzIQDzAocgQYTpcKkyTB9EpAa +gKEzLH+cZEeYbnsYqQZoKkzNPIHcT7ADBOD8DPLhBCvyAPvDDkhacfLBrpFhf4nAvAVE9h0s+iNs +MXsY9JZWeEOBzScBfwKM5BxZLuGapifaE+Sh8TrO/MhiE3lzIGFx4K89PTt62oSMOxAzDjTzcdmA +QM0kVBMJVhStgcQrPjMJ2TsStChqjyRuUeDi124iudtI9qL0rbwaQQajFE4kiUEWw0MzbT+TSEah +jGL5SKIZhTOKZxTQjSXYBWlw4WmPfabhv+snPfXSM10El0c++fzpsu6fbdrffOAXfgL8Kzd5vq0t +VrCaAQGYvl9/PoL9D/D2NIP4DNi0pFbjRSwlwERGk3yFpU1t2jrDqlOM9Ta2Jd7EfNty7nRdHzVR +DEtrQWfabQAVbE0X0YZU54xoCyiJiZxIoC9BY0G73KK6dQOqWCf3yniB1v3RFG3VgC+r0Hcvvn15 +8/7tzT/+CdX4afN/GKrASjNSkkEE0S+xgop6Lj6BpBaWXMdfkMpx0iGeG8VzsbP88fEXxGMTaeTf +9VDSMH8huhnQ1XxzPfoM4acM7N+/e/nyjbeKNgDCKvaQCdFkQnTeiFAVnyZAnY6bSKsIpGPMpOvK +BnpwW2ffNmHjJOkLWzRu1jNs37iN72Fjb7DfZ9IDFtANUE/YwfaK6kYE/eQOdiA0JdASCfPZ19YS +Om9AMr9L0CwKNlhmd0HU64AWyaBko3VxMj17P1gZoFlPolIvg6lxpK2RvrOR1sReymJXoakVxRDT +5xO+HtdXsh7RfmQL8gC6AhoCd2JJsi1p1qRovqtovBttF/XdySm7iZTdQsruiqou6rn0Vqedsm7a +SCs9kD7KumggLTSTBrrCDNnBvDrAPLuDWbfA/IswEzMQUGGzb7j370EVOALv70BRWEBpiKBCZKCu +goLBe7kpgAspgGiG41cyVZC6ymo6KYNonjcy0XdkpotiSMY6PBMOayTDK9F4JVJ9WTNFnN5scB3Z +yTLBBXOkxXNH3Zqla4HexIst89xYyVI+kuchklq9ksZ8hOkYSA+u4mlQNwP2jo0wmpb8BVOVpy1N +4EWmMynHZEPSuNODmsUF10H/4vnIDoJIvc9m+QO19GHSSVkrLeirILWUFdMFW5JyyuopKqisooKS +Sh/+oK3cRUcXHIl1bR7qHWny+Kyi3VcZXhxoHnL+wonAkwL64UdM2EiMFEthlcmwH/w1OOLJPDag +yJPXZvTbwJhN5LiJ0C6TFs4rr6+6cc319cZWJtuXg205kWkZbLV1w5JX225rVYpdyVYl25RqVeJH +1omMSjUrD2RWkpMAzUp62K4MxNlk1mWhVVzFysTVzJbmfjozNfVhk3MWs5MNTzY92fhkA9Q/xIFJ +fnxwan7m198qwsV+LubYW3hvmcivF8W/R/LRbT/9t2LbUqUtqshCr+7/5Nqb2G9B40Nroshq2LuV +gMsgO9elbTrOeVlkm+FJD1MepjvMed5akmwpzab3iaZ1sCnNLhKcyWhrH2UG69yVfWeiCbuzGXqS +OcmbT7bNZyebz5Gk9R1Zj0EkNG9BFab5Dk3QPVmktA3BRrSQ9RrJmi1k465k9e7IEMavExrLZDgv +ZErjtpLJjYZrdp2OK3nY9qIrHEGU36FLjnSJQA+67JB9JBXIncdrljYWUkb2aoyfjrwZHL1rA0z7 +vTny1IWXxLxfxKA/iRHPzk91fxax1aPY6OwEPU1mmO/EHq/iDc2j+rhRHXci7Fncd8UxTCz1UW8k +38tRpP/odSkbr8vodzmRi+xA7rLdZO6XFSYK+18yTZ1oXpgFZzJZ0+yLOdJU24tHZkfybiW/TAWb +h9ScbA6aSE6aQI6aRVYJ76wncdocyXHDj3gqys6eNrFUZX3UnLnOl7sffLnqye2+XPXkdl/urL7c +6Xgyd676crs3t5k3t/tzs/P8DB4f9vZMztlzwdVzwc9z7ukZfD0TOnsGd493+DinDz3N+X3U96Pe +H551ebRformCgnMILWrTmF2jz2l4iFOT/MDx+cSggIUFHooKTNvAgKg7W4XHVB6a5CdxLrJrUWc2 ++RUnmtSLTeejTeSmE5hmblTXojgXj+ZcVPdiZUVucprcuR63E1fjSq5GdDayuxEdjuRyJKcjux2P +NAP2E3kf2f+IHkj0QRZSqRJ5IiN5IwMpW2waodrNE5znJU8iHdwda4CD496EwjwIhYMKBce3aj7Z +dCYPjH2TCAEVA37969qfBzet56U4az0jpwt89FxM4rQN5Fr3PNyL87YNzEtT9+Iax5hXe1OQV1GN +s6nErBCjzX232ScOslOswy7x+ODYJjQ20SKYPxYaE3d7n/1d4e9z/8BiXQdP3enqTB/nO892kc00 +Pjg2OxK5q41KKGESF3ofkeZGg8eCHegnGgWdwjZ5RwaSPr5nhcWiPMsmvlNNdRmV8DtRwFX5BlIm +0btV4+6KjFdlwiaeszoz1JmgOBCT2Z+q27B2s5J83ZHMPZAcPomlPZuSw/Z2NkUHVZ3dZLoO7g24 +R6i20/WdRBuM6Tyi8qB0hfewgGWliZ+9KU8HQXu0aMOdqVP6En1RsKgFxiblnfpefXeVUOYqGyFT +sZMNkpUwVcSOsomeeEe9E71MdbOunwXZhpM8WZ7iNLauta1sHk30YzcocU6Ns6d/WdCUDXzWwKPo +4NW08MNGD0+DJr5XU9Rp4rnr4pMo40eJbao2nk0f39n0vntQI9/LlKZQ5UYlH1xBl5xBoztINXJ1 +CcXJeYVWmbI6YdkxtJhGnp1OrhPr4DcMCVm67A7J71gk/lgow2O1kOORvS+D4yCR4w== + + + gFwHk2R77GkinsRvpP6D7kHg0VIfwpFGrGd/LOZGcDkgVbx4e/MneI9CMC9etuFch6g1+xWOk7rx +JGi9yEam3jz1MXgvQ5P49c5JN5Fv9W5ygWwNZnfXwxjS1meV4LZ6Inbrvj/TKrqkrFRdNkOgTJwV +3WWxmOOiP+IemujbIKYpgyeCbC9ELuXvOK+apu6oG+hOXH/sBNKl1hdamMztUx63zmBAjjYSOAbe +j4o+VGH0uIX0DQS/hnUm3U/irenZAOyeOU5upT20XezdipPtwjyV2exgWXaTbBayUVzYKnSz8NuF +W4d+x0CRPg3bhm4cyW0eheyVrQjf2bMfxfgkjnc37s6DvxMPvvnwxZ665MTfD/ZztRSYOIl6pJbS +aTCjuyFdxRxSU7ob0xrqFotnMoN6NKk1tH0e1t6EtMW4VvM6TxaYcaGZD6Q3+ASH4qM1anJPbHMP +KrZa3l7R3sn6VnW7ihTIZoizKS6mi2rgi4iT2SLdun0e7TnYsx8ellC7ib6RWe1j6mM4vGdUaVaV +ZlZJ2McCPy70M7k8q4Pt2bqHN5dz1a31ampAdhlYYrtPZr4Hl5C1qJ7hUqBOzqI/ml3fbXux7ydZ +Cs2e1Z7OwWJPdk+6kAACMzy4Z3HP3J9NGtZpeI7jMx3Ov/Znz+6Bp50/pDtyGOQ8588y/h5I+Pug +VTOJh+LjBv7WuhntG7PxJ/Nr6VJTMycNWUTdk6Um69ZcXdjumVwW0d48VtWZqnEwU73JvzdzqFr8 +Jk0XAjicX+RDOBLEsVwjdQB4F4A4ASaxYU8yt8gXINYs27PsEGCrVi1btq2yuQdSdxJMY9gNkwmA +BrBrfRx9LWFZPSDVNdEvsHUGOtUTOIOCA/8h3KIONCYUXBctJRXUZYYG2GxOuVG6SWmNcgHINMcj +RynPDV+SYWQCpgAsjNtSFFq8DTATOqFXxSo5LgFmJiIIDXAhxtDmJQ99X5ZaEFKUCQG73vN8bkq4 +jTBPfIrLNdESpcsKOAcEoRRAMQxbhr4iOxohp3M+jC22W9zWbmLCBCBH6XXREqVfPp1SuaUUoQWZ +k8I1Z+oWNafArDWOeVNLWNPAlUb+JPylhpxoRGdkizKi3sIbMG1paS4T5rp4PyUh5vmrNy/p2JNl +xGwhPdtpc0QAo2F8QOBgBwTweEAdDMg7OR4QKWRf+vEANBynHrffWBgnsS/iJqR2yZh3QbUpn8S+ +2FoXhzMTXm2LcxPe+acmSz5uW0t+cE11O8P7pvbtLON4umhxqM3RcyUO3dZ3mRJnuRLo51eXlZoi +7LjaScDAOa/MJulWiVomSaIT5bCi/sDuq5ME6dhhVcjC2ImDSqZCkMmQNQtCJgSfGZnl1Eg/N7KS +Xeq8CzpBJklxzuJicLPEnSFJwymSbVZC8N6fyWzSR7l/Lhqmq8v5IU/ByTwFwWX71LPcg5PlHvR8 +dnUK2XSatu5ON6vCJttgm80+5LJrUsHkktnzxpr19uzJeZCCs2a3ns/jRBHdCPMC7VW0U4/kbAw0 +IeqxfWwqjJNhdoeI+nTQNPijTIZ5GgTGOBm6t2lxiSpF/U02JYZJMT3gExynxXZi7DdR+p4YlqcL +eSqjiFk2KSpDQtjWabTO01bu2EzxoufyZLk4XSaXlXJ29mHwk/fJMjo+nKcc3R4YucA5grMDhcpJ +gv1JJkf720lQ6bmH4YFsr2qnuegc1/kM53S180Ny0VyokrhGE1m3P5y+h4n8awuJMtz3WIbdwTSN +tNdh/tQRpuQCUxETaJu6zmDORZhrK8yvQz3BZIowiSqGiA7rCaiNMDcqTIcDTIAFhr1QnscRJEEA +CVBpXE+wPQQa0R2marilvoLkPxxPYIWHCVZOoXSLA3rh7xZKpSswI3fouLqzU13+iNrnHFAbjNXp +msfT0EydPn487UNJd2aYWvx5uhiH0yMtPg7nj7OcHWbpJ1mmC0dZPvEgC4U/OfjZ4jpZ3DNaxPNE +R4Y4z3ilk0UZJillG9NZpBNlHO8p53ilQ0186AkPRMFyuqNziwdKQe7pvInyqxbNLn6aCk9T4Wkq +PE0FNxWcu2ot80y+BdDOSmtkk7ecpBYJ2Z+Xzrd82sfkDMunncz6klNdn3gy5au3//Ke6wbd/MOr +7968fE8Hjy5B+5l95cGkPJiUB9MyzfQImx/f8pEDgudkynoLWme6qfEWFNvwSSNz6fM0RI/57G3J +S0hYGycu+IF4s663NYb2aSQ8jObxlLT8eTNz/OSnTJTfv3nz4v7ltzffCegGVhzMlItgmo7iu9lU +X7hoM190sTxgMk9n9nK1MzL+NPiyyZkYsyZc3sRkId3iUiecy8WFdbvLpZpZfJYKtHW15LNcoCG8 +K24WMoofNmZ87YjzehFR/mmxiF40omANiW49VKsGwUbyjjw8BzIlejkILgZB/+Cdd3IYHc/D4L8w +gcgNdgJdz57zuXM8dV753DnZITsS1/2Q+ckOmAc5ZA7ifaLT5YXO1mieB2d67Mn+5qPlmN8DewQd +H9EzRfmBo+PX2JL9jjxdY0v2O/J0jS3Z78jT52/J/ezStnDFtmzFtmjFtmSFq1cxDQnOrlzFkNo8 +W/Sv5zTvh6C9hu3L5CL3LnY/RO/7MfXdWQB/G8KnWiHnh9M/EsfnRHnWKcciFpfOmp8fEs+byHeP +fcdpE/52IfCzILjmpx8vRsIlFj65YHgPh58HxHtIfAiKu6R2Ge9pDIu7wPjpY4HxUfWCpd/W/CGl +BjaxpZV55dgUyBv8BUMn6aKWdC2EHHVrIL8SxfHWebmMLMAap1PiRX+RMNRlpfF6KL9szw7rxT0b +wH7P5rElPXpvm8VO0rwoKUTOIqlr6tJR2tAPQU3Ot/VJJ2v916W9kX2/HBGieBBtVMmViuJIkJaJ +apI8iI5c8n5NpJrsJfITqBxULwYFCgmpIz3esyMvGLtm7fgUUWaeyWjJVv0Ikk+yOlne7DIk5/b0 +XNJPJgl77CyRSvNg71zyqya9asKrT3RdT23Muvqk6kCXyv9sCgFNn1L/56GiPyxKP9MMv2CF04Y/ +ffmOL1VJXNL5wZL/V9tJdS/V3VRNXDVyOeu/mJ0bJzZ1zdhVc1cNXjV51ehVs1cNXzJ9N4VDcplb +8JKkphw4vq8WIur9KPUwBWEB7aJctjW/FNNo7cKKWjPJ2WXBsh0+rszVPVwBjZlAD9aUuBbKLxOf +8aL0jGM9u6Y++uGRw07ud/8chsfndB2n8b+inrtnXOR2/DIOSaiXjv2PB/9Hw+RO476Tnf8vl48n ++NeTlLlQ6eZM6fmEZxq1pPOH1umoXX+Ccv253i6fvv60Xz7tl0/75X+a/TJmkBB+68iwwH3eFm0n +XNAJ/sgpUBf3yy/FxPvll+26cQHQWq+2iyu+v/W9PF3ezFMcTSH8eko9e0o9e0o9e0o9e0o9e0o9 +e0o9e0o9e0o9e0oyeco3epoKT1PhaSp8VuoZ7rmflNS1oE3cviArTBA8NsNIDyPm2xmPfX1G8pt+ +9AuN9HbZSG/OSHceO1KRVT0m3cIM6+hqRnSjWjVhLhch+q+ZRaT1qkHtdV3WcseUoruhPIQvwuKK +Ik6Pr8T7n1e75DylIN/ZTILvG+fqh64BOS/n/9Ea/dMDtfgfE4M4DyqAPOjpGNukjLPkDL624WOe +1k8U0tMDvtbPFtHTQ7lI5yKaM4I+VJwjWPbPSTr+gfIczIRpOOt/tEyf8+IccahzeWepPT2xZ1UO +Fcvp+WCtywfEL3CmLOWiGJXcEJB0FU+8UtrIkkv7cJLuFyIcfa6lzAv7cdc4OnTtpHOiI9nmJ/2I +x/ULEX6ZKM+X/a0Axps4n/ytT/7WJ3/rk7/1yd/65G998rc++Vuf/K1PnpUnJ9vTVHiaCk9T4cv8 +rXbrxroZRh1EHMJLtyQ8eMhoGm5FGG/CHE8ajTdh+mvchqNG08WzRsmVLVxcuVB/J4dWL9Q7OaRE +6OSq7/upMpYwjL6E4TBjdM7YjJkenDJ8EI1ni86VD80UmSeTTJQ+TTjxb7yGrs+P7ewY5wbMjAkn +Bs0KnRN9RlAOLTvpGqxmnARBkh9xDeMKzjDcCwyxls5vZ+fGzMPk/Ev7SdbweJlKvljsdSz0urt8 +o8oky/yh2xPOR3G4N8HdosJ1WXfTQ5fabq611XG9dMhwkAbTg+IAh/nj4mBnSZ4iD6aPCAQvErxQ +GMWCCAacAdMFweBEg0wFEd245gMN/YmWNQ48DjldmHDhvkVfVnQY5+niMPdFOl6c00f5wVsyJhtq +f3GOW7Tu+uJt6VEe7158lMZ82sj+7RUZ4yUZy3DbyP5sK4DRn9zwP2Y/cDuCuwvD3YMxbbJ8L+wM +w94w7g5uf+CJgIcnDnLq4kNTAVQGVBh2MAiFFIWFlIQDjP4KKySBYjCDUnAAob06+XGC7WNHUyjA +W040eSpIioA7/BHmygr8jXStxgGmQYWBj0AGXqGxgyHKMJIL3Zixg/HKwJDFziQ0GJAMA7HQlRj7 +iW7DyLDeFmA2rzMUpcjgBZiLjEW2qgRFZuo1nszBLjuJd5Oxju/zHJjmeNY2hxfODyzIGYW/Abtc +3Qvdz/Qhh2Pa+Je6d2lwLU2PdDR+wM04+qWnz7tQ4qJ/mjyL0weuk3jgMokPXyo6feBW0fESCXev +6IeuFZ3k4ghxGZN/0DuNq7qN5dDHHR32CHTMI9PxjpWu+NjThR6n091E13LyVZyZruBc0XeO3mu8 +XUTcC09T4WkqPE2Fp6ngp8JnlY9q8+0yt8/LopGPfl4ZqTLfptjKF6QNKYZPzBv6rHJZXxpgLpdr +G5T1Q/WIzuPAm2tlyC/+gaU1fWRt+dW1vcPJLzCLDE8uRHO5ItHFG8o2Eby9rbzTpIFhF44Z48Ln +UeGxMtEmJjxZMK/fRLNaTFgPBx8+Fq5Zht+0uNFY5oj/F/r/Jvk12neNm0RSTwvXPBKFtdA9uhxP +4d9WKYNU6Fwu3aO729RE2lZFOlldJKmHRJWRtCoSf+/lkNIk1ZAqXaOyk1pIGoLkakgSl6aLwbUe +UpSKSFGKIaHVg7r7bqJYzo7qIO3JOOLw5Cx1kBLdlPRUCekKlZAG+/TRDgpxT1wuo/QZt8a6OjqH +qVdUstyq7Z2x5zfGzmeFlay00rS5K7bfFOvLKw2+z02JpbHI0m46q7M0Vlq67P+Uy12HckviSJuc +F9TVXNp61C7VYPpYHaaHajFlX2xgyAL8UE0mV5Xpcl0mmAnTheJM/aqiy/WZeoWmCzWapqFMky/U +dOkCo8VXirhwjRE804WSTf42I5l7/5kKOIHUmNdK1ZZqSOtFZAsn3823JUjK25pTm8MDOXTXQ/ll +Ss5aLio5AH70hRlc8kFtlEsWCiXEPJR4o3kJavxcMoEGI+ghRMUsKUa3TehCVIM9dVad4WNxvo9G ++R4bMPxoyPAhRB+LPZ6hGpcZ7Gx8ocwygzJA1wXNc6ltWBWUKER5pTLp+IqZy/P4ag== + + + GP/aC9uerZFwMf80xGHhfCy38mJpz4dSK2GMp0GLHvXo8SLHMaFym1JpCZXTcP9vsSv41qF6ymgP +gzXMNXLO87/qJvF0a2BsTYzByJi2WV+OR55Xj04WnFy2YBm4sxNPAGcPpTFdkDrnkiV7udcxZfJo +KZMPJU1WuRB1h9GXng23zYe7nDg5Gl5nLJmGlNy6214PjWlSC3W+SJdxEnDnXGbz9oZUTWnm21ED +pXRVOuNylPMtfLoFk5dPVIUnlTJBd+VEC5hGkc6yNODTiTiTgBcrnVu5g86S2Q6dOkJHAlBfgeY9 +Zexhut5KdN5NlMRZgF2cwLn0BE6YyMfjHci2CHKuAlP2IAHx7uRwl3jkPkm7/7hyP31Qu9/o9o9R +7aePZSNcTkagzl23a5hz/HDXLpguH+/e9PFki0vd45H7RMvsYx2cPtUy+1j3psfkkpx3b+Powzfi +BgmqSiuJ6unUFriITg5U7Uc10zlAt2gz3VyWNxbqvhZGvtCuxYWQgFoFcgIPcWTY3WlvJ13rhpx4 +XFI0ITZsDPxdYr24M18L4Zdt1xe9edtCpaOeu57puZGKm6H2eO6L36Z+n+I8mRf+UtXyB32EruiZ +8w96vdfrvj6G4OMIXpH2xxq6DgxTd3KhBdeloVs+q93HGXysgeIN3kO3SBpyNCdaFcuhzT7PXkoQ +Sl3wReqCJ4t9lEnU9Wo1wPcu/f7kPF6B/iWjODuaGy3n/Ser/J+S2lenayb2eRPA0+ip9HR6Sj2t +nto7f6rQnyt0VA90e8o97UR9p1C5ONK4oXJD5/7CWUC6Ovn8KODeMu5Wc1PZMcDNFd2dZqD6C09J +f7F1Md9GUIXYPmoFFgH+Uloei7wVPC23ktRG6x4jGlSu7LKwvxrGLxKnMVwSpwD9wns2T07unB2q +mlxQs0rlSB/QFHH6pae9dmcHfBbUax464DOEWx9zvGhLgQ/1ls15M6JgOhNwSoNSwWcTryfcLlR6 +fKRw+4/MmX7Muz/57dMlIXn+/o0/E01Hrs8Og0arFcy6ZayiqFc2V70L94Pr/nooPzP4i5ce5/Al +wV/B8GWC56LbJY5VFh+V6Etpvo/K8n1UsugDVtuF9MDHJByeZc49hM6H5h6TnECpCY9KUvlrRud9 +migJE7nLc6ObvJGDYTg0L37z81/8DUbtdl2Ga82vjvkTF978obP3n/LpL1pw6WKEIF0IEOhXrzwd +LLmT0zyzc9UXSQTlhNBK8fNVzYMeRe/1zSV0uClafmexc95KF7lbaKEounr+40SGT5RFVmS5FYut +821Dq8TW1cbgCPuBFivvxhprP00avuN+8stCkKLB/BXlhDg/mSQRB+L5ZiK+m4j38XUSW0X+S9/1 +2qJGFxfpBUa84bMFdpAzxuN3+ttkTY7uZ39OF5478n4MgUocN6/VxEGXOw66nJrGR6v7HaXLq/SB +1SVSlqaPmMV6kdeRPI8PlE9wuWhpsnSZbSJaJJ+kpsls6+vEh+rrTJaAli9W2GFn9IXsswdyz3aT +uOLv5Chy0OQzyT07SI3y7mv/SPbZdCZDNQFNJanKUpWmLE9Zou7IZDuQXD36MVbdNdn54dUCa83S +WY6WuLIMenS2fJU2yWIyVVbWiir5mpyit3TtnFZ9kqwUf2w+a77VSq47nTjdCPhwXqP6VnQqwb/p +QhLWNsNxzMHa1uTQiSW5VxOlXvXcRp5X6Po/kf870ITC6bSjqcQTKchE4nsTjhS/CDR96iTO+37S +Gatd6EnnIuec70gqoU+cjznfoT8cRrvBCB+14Pzfzon3f3OEywMPTeBJdjd1camjK53tb+O+dmlD +O+ilHON+trg9zMeveYH5zWsVk5HNxp0aQXebqwTGmwF8bsuY1TJms0hBq2nIYBnyVjb5Kv4GsTE9 +ZUhLmYZ8lPG2sDH9ZEg7GdJNhiyTaUwvodQm9hiNCU5syGmakyY6RdkUl57uNEnG050k3Bxd3hO7 +mfRiOU5+YpfTmAKlx0ApEWoacqE0H2rRWSAjc3J5UUd5Sz8cKgdEnw4m/+0fTL5aLsllZ8Y4yp89 +zpPL5/zykYaxnh5XUe4DY70Z7emzYocfGO/p0dHDj474xpJd67xgMKw12EwCXasBO0FcybUjDp1Z +cmgWjOg9mJXzpZj+02XjXC7siXU9zUp1nhLb5XUL74VyilN1d2Zvnuhqo9n2Yt6JLTF72uRkSzY2 +qQiahZ3IEtIraSvdhrSKbbcz80yMsMmysSNpvqT70lxj1Zdrie0oSH8ky+lEKv5M9hMqwKgCJ7oh +p2BRnomSOFAX3tH8PkqVMT6RgP0P8iSq2oNKMarFqBivtFq4vJSqx3Rv8kxaMlea4jpTeGIh09Ff +LjTlS00duBqZ1SNb5AwDp9nkiTJt1iHPhjNtcNmf59lQps1omEZztfPYqXG60Jh9+CRV7lWOpotn +qFZKjNldCjhsT0/JGY8onKyT2asHZJ2zLLxtcXjg7JQenBrumE6UVTNarUe7W1rNVmTlR8rCcu7U +NJyb8par3s52HE5NBcrsLpShc54kBqbrNFiuq1ykddn9x8brx6/LetzFWQ9epzV95E6ti3dsfeg5 +v3/rQ/duPeI2rulC6drHFLN98JkerHb7sadefqaH/vBAtVx6RotEWau9V/oUhVodam4sFjtWM8MS +4T/xaumHL5dGW2F6zOXSj79e+pCnC9dLX+GC6c+8YloOO/gCInfTheISvrzEtsAElZh4sj3+lmyP +BzIkMnAgYqCjYYhsLO1bUqW0g6yKJJb6TfUBVfR6KP/T6aTlYuQEoBdrzZNCwxv6ztyFlw9BSz7w +hc1cPdBHShV/5BFovTOzDpu5z/mmU9CTc0R3VzRt6LKlL+42zCxeadnazTPNh6NPKMwn9nVx6mev +Ptvd8ppMrbnlzJ3xAOveMqrv/EFWrnuUaE0XWt2N1vmOVvxhk10eKRMZpUOhfOTN7bUobydKphaX +rKRUs1/2IFn1nZWV9KIdV6QUTy37atFbu+dbRCd22P6v7ZLlzeRjFfY/fNfv+QW+F47bfbjy/oWj +eP6ZHtQrH/o6PvCIL1FO8VHvP+Vs62P2nU9LEX/ErjNdL39aDrZKzSBa9ysdruiVpcKFamIHV1qq +SnfOS0tRtyYysrBnvKdy/6zCFPWRe9lrjG2vleXuysWyE/Z5U3HK3y3LvR/qTgkPThJ13VwvO3Eg ++MGNF0suYfpzS3Vtl3dJLPSP6QiJK/9/cK/7QoTjptugl5RpuOKpFUmE4B276c6NN6tS0gRfAfAR +reBLMX7RBl0v7c/1S1MYn+4PeLo/4On+gKf7A57uD3i6P+CzFeN/X4RP9wc83R/w5BR7Khr/NBWe +psLTVPi3v6/18UUMx3Pen/Sx/3T+8nbxTGHbnCk8GaP3VmRvJ9mV66a8dLHfLpWapp/TkN35uTrW +BU0wyNFndBmQw0AKJaERwGqS5sizgtQoC+RImj6pR5OccGTXAFp6WWpxcFb8yR0Tr5SksbfMZctb +JspMdY1W5cVXd1Fvv2aezxLEV8+/ZqGz+7/iUUC2i3cUPz1IWP8kof3ZYgE9GqCB/iJpnx8P9n8k +mP+xuP15bP4xMfpNqJ3l92fK6QtimoT09OU1E3dsemwq5Y9OzGzyTyWgysDD4L8sJgjjNLgvj2dp +bCoTVSpuL1Eg2fiAXxNm8JrpTNSytDwUZmt8RNHuCIU/EehjrsMvRskCMpd5vLsUPhBa8UIOT3Jh +iTj4BWtShHJZXH4ppi8TnhfrW7SxvoUVBFWBwy6GOz2S43xN3s80HqjYlIneepgulYge3ZIPlIhG +X8FkPqWtb9I8SaPcuFAqaluRlsN5uwu1aBcJj/b6WWWy8lA750ccY6XJndrhiOmOskAsaipSlOTn +RGkkmWJ/nArVLBlK4qdjj75Iwlw6FH1BxjxCwjysBk4f1wP1vuf9JvF/LFm6LVp6KVHntM3wHwuX +rpu8/jQk7WzTdjblSyeXw98OFwuYcoxqT7NSrzHq0aptvIrV2IcvQ5GY1aRBq+FGlH4nCiu427jV +pcgVK7xS5wjlvpf8rPtK9GqTaRznZQgFgVISxqPkGn1pWoQyrQHEw0XJdx10XHwIFbRBlq912aSL +QAdBnN+4U+4BA1cPbRjXQ/khAQ2Ar3/19s1v3r168/7Vm++ePXNy2/9h+tX3+JfIf/nNi/fvX757 +AwL9q//nxxfvXv5ws3vz3euX34Is3wBuluU2pbrKz3hTyi1G9ORnhK7+iN01W+APf6H//t/w6/8A +4L/epJtf3vzzf59vviX4H34LP7Y47x1M8N48B9jmXQNMP/v8Aj6EvaHX/ZqGAiwn0C8oB71WYnOa +V9hxcDushbbFmecFVnCVilWRc4H+8AJfAC/Fuq75FgzNxPQKiH/SK+mv7QJEPvb8HBOC/gX+hRUL +WMKWuYLKUCu9QWGx3S5tDcPHL8H0s88v4NP30OeAUxk6ClKU3qOwstzGBnae//wlmH72+QV8+h6l +ST/vOVbDbWp1EQa1eW6XQP7NW2z6FvpYKX5YFOQGgT91AeLGYINJX0Ddqkk/e+9AnrPKhUswPxtG +bPoSogZmiY7pvYPxR9rw8UswPx+2+AZubcZEYX4A9POXYH4Etvj0PSDoAmwLuMzyXGG7xhh6BMHG +sjohvVg9SLIApOAaSG/+hRbcfPNbrj4SYHlyIbmaxhIIXayi0s0KOeyLdPxkxdV884cd1zy++Vc/ +U/tcuTRslxbThTW7wYagP7LUr5kL03bySliGKkmJy9CiF4XIhF6yuUA9386v+wdGfliNG5gn/tJ8 +ZVJhl1+o9l2IGP64yFvZjpxFA9IR6Gdah1kq0uTS7FFuXYJ5ybHF12mtoOxH2h/rwlML2uVCjG4Y +50SBrQkbmU0cqqSBu+ogwt1SviRMsdDVRuYKyK3aC7L/j1ea+Fth7OdphSFMwhYTphdgfkFeEu5X +HX7aREF29sEfRO0FMagg+dzzM0zXHPbNfuC3CD/Gl+ToBXF9YXdhQlMCK3KshZby2kbtVEtgrspV +yXtiQnEgHQX3DsbrIp1L4g3MU7/Fp7RutQqvaXicorpcAHmMl3QUfMvvpxOrm6CfirL5Wfrqyn/Z +v/vxhz8pHnM3hPln03yzg39/+NfpR3gGLfSyDkoa6LMEuvltvgFJnbDy5wJceAYq4XqLkXwHfj6C +Q7nFiwkJrBguwfrH30yog+JEnhca+4rHwnCSgkW2kvCvBcwEOhCJuxdCrAD/ovPYoUbDIgciODSY +jmtOCI63c4DPAHDNt2D7CRkRljzAaryt81wdad/g5wvSAxOQwNhwafDh1nzDv0BDMLQAJ5DdGy51 +2/DP2HDOgDEk/3JYnrgzl4FKz2vp0WEa2uJ+BXhvBqTI7AZq+kCAjsA3I6UAzgU6N/RK2/5l7H5v +61ilbbFjjqudBsf/Tu12oA7Tv0y/n9rNT39284d/hN9oUsMqGKb0x2Y6QW8AfBOGKQ== + + + /+gJv4L6dLuuoJmsYS5Ynpfm/DqvEcVEc+DnG3C4LTWvBPZIHgAbkmvNfMJeCkhQwJ5gI8iJKF9g +chEkJlCvuFlal8TADDvqzUgZtFzXitOMwZG7hyjBTGcgmuEMxCtFby6+HAcUOQRtitKQ0pKEn/kW +ndUIht9m2KEQWHhSctsYCwHrLR6XZmBbYC0cCAHMJPQJMDiHRdvGJC/Lc7jhhgvu2wQrMxDOn2+w +I84rE7DQRF3nttwC7wO3XZlhM8zeDA2UN2llBDipYxJiQymFZwSAgdo6cAf2YFjQq7A31xAFGJdF +icXUWcaL4KgMiy1L2xBmwZrmogjCWpTnqNwaglxtgHOQtrDxRkWwKhBMfqVgTfL5dIuROGmKJoMA +OxNgzgtwQbcAEzDPwRDA6hcugtJVhTM4b0oTjsN/CUW+TWGWGZZCZo4XoEA7VnPWjgEYu84j2aIi +aCkrMKWswKaE9Y7BorOZ32rgPqy3YSkyj0DUMlKYHEEnBwgs+XyDmV2E1paEhw0VQ3l/xYkvn5fJ +hetitc9jxpRO2UU/Xxp/Hl4VQhZgQ8YzsK4LL8eZFrwgqGvFOY/A1HhkMizyuApwTaUKr9dQDAHM +SB2CpbEUW+YFXhLldSkIigXVz6i9JW4jMM1ZqI2wYAXvgvuCrOZ5nTvess5CBZXdYyBmfgnDS2Vg +uMV4vXa4BMEL4JSkbwssXsEboKNJ6A25rYIi4ZgwihyrAEuMuspDNLRlfBujhVWK21RnGgOjiUCS +2QIEVVsIYGnHYNgMhNx5WYuQ0GYd4CWvQRAsqY9k0v6idNCBANnAbWHap9x0MkpvK0jxqF3IRQcC +dvtUdIqFWqVtxTLuzHEU7gJcq66x4hC0qIJmjUzACr1dpSmW7BQgaO76pjZrDwAMXRbwKrNmvQXG +xTMEaCwJEJQXQ0Ak8tJZSfwhENSdRedB4EFoLHM6txlBw1HUAeNNhIBJl+4KW+2NtRQKKvzXEMRo +G04BMANLrlUZa0DytzIFxgKAzsEWjgx4Q24quxYlak266a6LzqJl5qnOWBvPIgB2OUkikYGlrcps +3IwUQQa6tC1P7gXWeLLdJpCcwpZgChbhayw0MxbcBIMKPwzLHhSBvirRdkmgHHSyVIN12a2bEoJj +K7qSI4sYALa+Xlj2wauB/WtzNDGCgJ5mXZwLqy0IDLpeMF5z80/SFu1g3WkELyy5kGzCrgIDgazr +DSUNvyuiFqYrrtjnMzLD7z4I7DtoLUs1BG2OuubxBA0C4WMhmCJDKg8CY63yKjAG5POALCoBoGrz +u+DXFrYszDCYa3SikBEAstJ0waCgZyCp7DxccykCTPOwfymCElbpbU5NNFh8XcuCggxeeRnaKKJh +LYa3msay6OJAvItOWdnvQeUyLdrUIwQuMH9UPTLWFpA7qmhihrK0rXMy+SCsrTCkOuWCLW/0ScRV +J10pSdriCR1lDWvKiCCoJoZhd0EAkjPZrpZW2T0ADHJLwSUrCtWVUfiXKMBm+0xAX4fibTXJYoxY +Ox6BoOYWnfZYDlmAIA1X3VeD8nbFykLZEcbAmpQ1WQYMZOy86va11NU+D4tYOVOLfr5v7UsKSlWN +toH2sWkoBXXdAPNvBAh7uyKYFRjWasCSDUGf4uKGZXCqS+3qGMPWsETHRAaWoEOecLNWtHle8mZo +oG1V1QCGOQkwwfajytSyGoKyqJzIolsAsMVFgAUWJAIDFgDXnQoTLBhBwDPzc1IELNMDGXJFyeI9 +JWCMTVUe0uMVQUpNWCBqLgLXqOpclS6E5TYk5feK+iYjAHBmHsBqC7xuAAgGi3Q3RxYTCIxBXxV1 +3QAYM9mEsLVxF4LbK0SlRmBOKtPAdpVRAHCqutnklSUwthUzLps2iMBFVwLeUGUISFHh7qLjW4Bo +AzNW4JEAQSwrBSBgDUGLWeeB6KMhmlKNvoucBRhaSspZVU4AHFddeMR6AUZdIUUUPMTadIWUpAo4 +gOF3QUCdQWBywprsFgZ2lQd2CBE+CBblAihg/S5kdEAvPLRLNGCsQYFBOZDdhikhGQanqJKDtjEG +1qRGSGORiLCin6/B0BYzGbVHsGmp1FpZ7AVc0jqBqqlLAXVtVQJoLjAwtybUz0WmO+51uoyryU2k +yWSsEQ8fW4oiEFUcgCGrJr2iEavUL6tKDbH6CUHW3idRbgiBTTZTjdDVteig2BwssHyLzgAVD8X0 +88zarSJYgwrkimr3cwVHXhxo+rLSF3Bbq54LDJxlxZSuiSIUZU1fRwzMYNHIxBAbA4AUcWKkqSyG +IJmCm9TrhWDa5hlcZRZXHtRxGKqT0isKDcVLfJZVL7zBDdSmNrsYCFiT9Va3KgSjrU6dIIGLQDDl +U5+ccxWgrjiZSYxgNZsIJ7eIAth+UlMZKZYWAJOtuFpVRQvN2ZBtXhUBXp6pL6vE8DizydJlJCGI +dCmnUhCZ2jibo8jWHMIWnYlrUCMWP990SykoaxgYbOGhQ02AFNOSQVCBjuCiTo514TUGwJqjl90M +JA+bbFS68CJ6CJruiri0BbgkHcXIcxaBUVs2rNqvCGKxbZX3dYCpyxFGtmTuQaDa/m6X4M8HEDv6 +eVVoAUHNuqPQEDGw4b4vb1rs83haUbQQsRMAmIIC1yJUwS4jrjZEmqIhwBwyJ2WeCxgsUN09eKuN +sKPEqDM2sis14i6hvgH6CKNFF6DuKE32KQB23Ya0UQZmMXYLhvpkeUR0PaYyEoCqU5DJHdhRhUA1 +1/1GieBm3W1VEVTTYYoYiwDE3DmdRLpNRRTVUelC36ZgLSpNMKPUKFD9FIW5o2CxSc+OCMQ6V9U2 +xAhH4KK04klTQ1BnnbPq9Igo300gitzBLlTVWnNRjSsC4asqVzEJtYXjeCw869IEqJ4M3AdVHUfw +HG3ZZUUAU0opEEcEAMlSlmkQlQcgvpvsqiwrngs4id5Z2KvBwLCqS6yKpx6Bpk7T1ql4kxkaWTbX +WHmgRUNlTS5WuqHGzTlGgL5306eDhjdite3KrbzVefayGBUADFHVoGI2/nnb5wq22Uz+ZAbGpuJT +vNwIzLNGFTLadoq3a566MSANRY2KKq4ufJU5HGlLVgQhKnMaxeuYAtuvmphmRIEtyNQ/j0dnR801 +ohWmeraqvgDsLqXVDBCMGy/qUKgrK+oIjMm2NhlzAK5RFZ9su01ztmETuxuAKSdtK6GgiL7vVM8m +I+yNZfXrVLA2dQc3UQQQaNoBCVBDsMxtM0MlHi5yuRlZQYV198sBODf1aet4NVPIYYmIUwaAdTbd +D60a/XyxTaTVVQkotgvT3ihviqqQm+odu7uOhJ5MToCamkdyxsB9zzViV9PzHQu724Cmob6MSBwE +aMIUm+BNOwaqZ7Cwq4cQJMyxSiIl1G5Ps3MGNJyRDFzbXHRyq06aKCXLpndr3LHU/Yh9JgIwIJ+Y +MF4eAEuhiZ45B3UsEVi3V5oyilaDbABmrSEtXkcTuwiA6qRAu0aJRQVh1o6xqIWWLevGQMKRG4Zg +1oapgwkj1Cp32P8EIHXXddMWgGqCiPKsH2/moDC+RnPRF3agM5DSNjeaEIJFPwFmKQUADLq+F/TG +ITCZTl84vsgI0INt3G7sHEyitBMwidM2ZYuCoamgGnXCma6DLazGvqgzpCoDhRki5FflAFqes21h +rPkisKgNmzjghcCwqCfDFhdCzYNnY92bYqdYHU64ps1+qaqMAjiFVeY7MJv7Wk2dHoDdXO46E4DJ +dhbGlqxtQxBgkHGtHPnicbUYGDa1vbKJwQjAXBfbOJoirc1cMSaiU2Xt3t71XKBuZnAKG4JhC85d +N2jMbwSq1ZxkFcDWVatiLba6AbxqUxWcAIyzSdOF92oEpsXvMoogl6Z4ZU9Nq4mSoqHjJTXHWAoM +MwIMs5hxm8S0BGiScK5bCI2SwpQzMjma+Sw2aFX3hj6IUZFnm53F/PGYt1bMy4T6GSHIWJZd1Ss1 +/HOwGFxhZzQDXW9xpTACAItVg4SFyD3LEX1tOmLiZ4K2zWREriwjMgYHF8VbNTSHCIoal1GcTxlN +haQCqQYFgk6pGqJ6AwBKTkZRLVihzRgBSTrBJa4EwIqWV++BIlA1tbCDThCIV6ewOchA0upE8KjN +jGDRtB0Xk8XrgAK2VQDWO6Dxe4SSs1r43fTjNMpjB5K5W8Ujpgj6yqUN67mANTzZFyl21nxFRTR9 +pHVR13/33OPrmgZjJctYXlcsPCcyDfFqDEiiyfjxorGWFR3/h4c/jikdqoYlDrVQw9mM29SpongO +94C1DeqqyTMxInPifFgGLurVytn21KJe94w5Fjo1bbolPDBinozY6W/mVCw6M7Jl43THXsbQl1La +N0UioJpxy+If285RV5dYVTk7WZBMhcmop6l+G2dDoFNQI0XYbll0aUbdER76OB4Bk1dJhD1niz8V +PwJoQ6iQVqU74/61Lo5WBoZFySLXKSMoFvQsFrhArKsJEnHgIQLHwqUjWGrTXVGiZQAsdTZBop8H +ZUUJ6HOgmBKEhit7dxHYV7dYQwDMUZXuYPt6xu6ogFvEn5SrhYTKrXy8ct5In5j8cXJ2qsTQ/A+A +Kk26BNDS1Y1eY2cAjM5J2Ayl5lgUzTxDYJNZnSUkiKCkgmUpOifWjo7+a661wg5/Boaks4FGTV/c +muodReK37sXq7MpeD+g+meHjMeqbQCDKSKhHBWkKOpt75ADBSSU9ioPnAu1aukY/MqZmZOmVGvII +tHf1oAyCF81prOLXQmBStqjoWS0ojzJdEwMyWsFqp6x9twSlIenYmUxeeZ+WkWe/GLSEGapAtJkU +bytF94WmehO0pkQD4aJsF40TDQa9B/HabreYqx7AIGx1Sc7sQsoYoLT+FiOM0iulZ6qgALhKKl9h +u4qBZekbXhaY+geKi1YgWjMAcnId65aJ+uTpXXGj5WU0LYsBm9BVZqemac4BAOOqgy6hLWoYZSCL +/3wo2q8qLnkApqhbi1pWiNRcvEktmDK7SafBOUTaVEmkyAkDswmFPsERgU0Z9U+W2anPklK6lIVj +8dzVUDoFzmYvGtiH1nMx47YkmaHFp9ip6oaYMXGM9zyld+EMrZU9ibq9YNuqnvIgTiE8R2AZepHT +ERGYomUc2BRHvKu6HloJigCHWEZXJDYAq4kus9lKMJ+QG7HgVBzytjJQ/WrDlOmu8sJqKANLVoFQ +8pwEqMEwICCo2Y5tbcjIJykvy7rKm2x6BbPo1GrtbhJCYJJKUk8KqL9Vh1fXOLSkCMFqhoUiWOOi ++85i3S3dyyuJgEhWMseDRXSxbUkbNwG2XdTPrP5zfJV59QnICKJzpmpCCwB7enRluxNhi7rFWp8F +AJ5Ne4uL8rvFYu4UtrzxTVktZxRB+vm02OcbBy+Lz2TU8FhBrd70BotWAFjTfwpHlwWYdBOTtBOC +qZjtsTxEu+hGS0755wLORSU1nSRQsKbGFvZwCQqJITP/k8XWJNGe35QsLRe3JcWIuQ== + + + y7qBqF2FGJvaoayiFLSKVPMLlrMJH1ee6A6Orw/NaS3y7lW3P/JZGklBtUFN0UeKxPFVOBdRkDYz +dNbW+xTMmWBiG19WzUnD8feSOHzJK0DzzRGsDp1i+alF8jTHFZDcWumpKSVzx4dduWRzz8tuz8BS +lanFvGcIXvrOw5GpgkqX8XBVpGvR8QumJZfM51NGGZ9d8CSJRwv7KssCozuaLUdt1eVdxPUDbUHP +NwdqB1qAoQdEithtDA5rNnZp/EfUbIStTRo6KYS5spYELvlFJZtK3JPaSrZdWs5NaA9UEeypX4ig +pzCI+w+BSVMYnBTKzDkGx1nHq+eJabZKKU6DoqQERoCTx6L3q4iswqmash3OOjItm11oKVIFh6kp +YZL4i1UMLDpoExn0+qyM7btZdds0WUAMdD77KntJdbtO94ACWCORhZPPGBgW2+LWRRF0l1g2lxgi +WHUeakgK20qOVrdXEdjMlYMiSRH0aG6WpBWkdm1bUV6dF5yEtlGQ1Xe1FP28eht7SgACFw3zU6iX +P79yFHv1To9SLW20J6NiS1sIwbIiCnoQs81D2fi65WApiKVZfo7ECvnz6NTTSRAlwlFnXquDUgXA +VDRTovuh6+zi0dowR10FS/90TZrvMutWWtH1Z/nI4nDAzxddhmqDY0tbLtF08+o1SBJQfO5rcTpV +XFjAARCotnxkXt4ALM1i0eq5w6a1apq2HdvAxpYJNK+Ktacua4AagUX7RX4GRdsTp2aR0QBcsya9 +NlHJsGXS7O+1qe5TMX9bc3yLBCgqRlj07A0lpTNQQ86SPs4Igp11EmqfC7hnntFRZwRGTlvktmxT +AiwlU6FNGiI46jky8ic9F3Cfh+Q4MbClJMsJIASuyXLoJZsJgDC62rWkk7ZiAqCyLFpSHYCXrCeT +sng2AZjtJJhIVCR30UMbqx4wI7SWO6XpuDU4p5qm2AIQ9HhFMC8dgUpq3Ppr3LCxn8VAUiUrIfFp +FUWg+TG4GbJERAokKoTZ3sIuzHjRQ3ZkFev4asJlUlcNEiAbUGLnsgDLYg1b65+30yQUvJDZkasQ +EDBXjYEad0/Of1Tx+KVmt5PKKpNx0RRy8n7oDNVzinYaj8BZwe5l/cyYHkfBxTDrcDsK8AyUvkzz +KgCo58sSH5cQmSJDYCeVoOEyl+SmFgNhBIWmIsn9KCMWPYvRM1axrZ0RJJtWgEXXLWVxipCSuBq2 +XGKXiSHqcMsOjHIu2TGA1AVl1nODwTxmJH9TcEP7XMBBknlTl4keqLMb9oQm6QDJ60zNNuFkkq6s +lps/AGmLZGBXeTAypkuRTO3nugdKLmvs5idurHp2Q/2oAFxMcFBoThUZx4cUTHUV9T+ygGVgbspb +ymJUbTA3PS6lCT5ofSyGoHVbu5ZVadUIFFqaWeVfwAJOz81U1dVoeAPPFh4eVZ57BnfiXG/F21ee +xtYA2LkruxB6FmQXlpMw6rBQN3myMBy6QSRWAx1TDWs2nSOy3mYuHskEiphp2cwVQ4eTCSxJJOj6 +qiwQoiZgoEtPUgOFh+pRC/YyTQxBn+Csx9MoPPOMnYpZ5WQ/tkCu0ah4Jc8WgLDaZR5pVjE6bJei +/bLEJ3T5itcnmusK3ddyDg3Hvqq/mHIpBKsFLbMpHpHtzGccl0m5KBObBfzE/R05sdWCg6K7RtbU +2asYLOMkcgj1GUdIJW0o8gR+RnHXJgGESNaOBlNn0VwiOzc0yqumaLQcSwwIrykqE4KiBaGraM13 +hjHlrHyk0Oszij73SaOaHsapZ10iyQIjANbMJYyA8kaMQHFBRg1FYlS+FOFXF+uURBAEHJuk11TT +8+QM9jNJTAjSV8pB0HwFPVcTOW75XMDUdemvxPARuApetQuSRNgZaDEnzJkQpS6y1/AZJW30dVNk +4WImhxxSiz3AkeRAK39eLMmUzI0behoDDJ0cgpV8VU1loZXJaCWiAMAalIBFHOQALHLQEbb/OkdD +sMyKQEOElHjTok4vSRAKZhhEToJgBMFsE/QEsgR3iT8jgjnZ7FI5RzlGOuspCPAgVsxW1lGkrDdG +MNuh9GDSHoB9Y9HZQVlxuu6CpZpVC91G0w+i5G8IDznXDhVGXQemNcR+SETqBjwXcJKT18ESAGI0 +f3Hk8ggMTKkIgp7FGM2UjXYAMfbSBnR8WmA0Gvx+Mw4xiTrp8pjlpAfmcFedRRTBeEbp2lTQSOaQ +ylkEN10ciyYQL5bWF3l3F2CtVVet8bXnoUdOjXpG2e3qwe1zE5PuJa0hsiHKCGaQO7pmKPLHQNBP +BKghYQTaEGZLf0O8WfHWRU5vNDvDFDnPk4El6oZvORABj7KtBmXXIAJTn8ZyAKhZ6BaAps+F1Q6c +xn5WpfJxB2aXJNjguZpOle1VIblln+xYkB5Expw13mnwqFLRSZStiEFIdh4e1z9vrAgMQXsgeq47 +AhWdkyKgrdm0rWweANQjgqCFyDQKyY1BP9uK560kGBH76aRkmb+xH9dBNUUFL0W6GUG0rK6o4U08 +2ZV1B9Zs7xCtSEm8tTP2CJVIgqgLfKqmBw0iR92e0ak7tYCi6foA1ER6t+rxpGbV1UFp6M/4zK8E +xkV5e0bnozUCGNxJLDx4LuegACyRACw0IDmEwSJ4cz/KHPiQByHAwZeaANGOVJIGqDwMIWlVBT3c +G/mEtSIIs4k4tktoe7RpmKwqQ5AU3+g0Z1rATcrxSB4qFntoOrXUJECgZJQFd/AC61hU3uyDxWbn +2bJDgqbsY4UOPUUVeqI4glXDDXrAgIDi9DUlihCsJkx176IaIWLKB3ZGPFdwYoMxcPxDwWHWcZAa +HQics9JbOekRgRo9CF2hxpIolOJGYFFjsCzMGpLuy6xPU2kcyd0K/ZjF3GaLikU2Vbm2jjqmgrpi +sQ4PxSiFt7KpYM0fdRFEzdzA6kAw8YQ5VasD9VpLIiMYQbSIqVnoF6oO/QOVI8I6RcE5D0KQIkmJ +VRVuPxd1SrSkJ9BJ/kjLqIUgeqIMgsuiZn6xSklhDWIg6oo+p4ArJaE52YplRqMQvVdwthMjkqFO +/l9LThbSEJg1MWbuQdbK2Bisbunuv+2JXAgsmkw4W4pG6efVizmiCqWjaNZ4Uyt50wPtWjEzAimj +UsYCrhqOMSKKy48IkmCOcYCgOQdxtoj9Gd7n8sLkWEGeyXsBV0vnrVlDMjVr6hCdYHomgaJQFKg7 +R0mm1xU7g0UxHQ1faZ7bOQEHo0yNsqLVQBmsWoxlQaIfwNJ5Y+WdsiSuJrtycpH6cjkwpWEGDWIm +q/FS6NTbxfcrYbCprJrQSyNwr+BFCauz5hiEpBFTC+4tlsVIEVO1+Hsk03IyFj7qsXJuT9IUhc3r +ha4hXSUzUQgDK0dgs1n8bTagKM2YRJN7RrLqEOgdsGSVrBlKjQ9VMLFq8vdT/pggpa7vDVUy7ejs +oHqYScbdCzg3O0qBCoceE+ylFchD8PwyEsEeZivslVmHuhewivZ+jhPrEFgOmiRvImy5cBR2Zi1K +Vr2olP7QqobzzgmQMVqiO1dHivm9gpvVjoAxlnIO4udZ2d+t/T5H8pxqAn5ZJUAE35TPrwYo0h+D +CFS4LmLSzVwc+PkAhm6yW+W5fv4c4j76huihAoAV9Rcs3YoyEes0h5WScXEk8ToY/KXNC91YssDE +ofKuke8r4QqAoNcV/Du8UvKr70Wva0sgMJZBIp1mlUNeSws25hSmRvGPhSDJHv9GlIw1sd0661pB +HQEUVysrEkRF0Ngb6OAlq0oTLNQnPkwtlBdrE27IrkJl6pL6i6QOCykpIvIWlr9K1zyzbJkt83vG +l6HuApZgLx9FUaCGQDkm8w3xZcHjb8QXzNhctcwP1yRa1miB8CXKoadlRW3SSslgAKOdDfqSpVYe +ttYw4oJ6CO5giBc1zZuLA/aNLCg8FYZrEilOmJ5xL+C4tuDAzzfgyFaM0IwTCm/9xNqMqjeveW0O +yKwEtuDVZb4tKmwx0pTuWD1QKFAtDl64bgjz4MAV06SMX1PCQB7lM8IIqEMEm2ca2zrmGNYLHJMC +lPi6sArjyYdE67hhTTJU9ZeVQrU8e9DBwEBMwpUaclhCsBANM8vXb2RVgYpKnJBjQDL0Urci2EEw +rBy1WnDL0tsXdGlV9UwGK3aDDs0iKrmeP8FCXTJA1fZRCkXkVZkTFyZsxugO7vo4rYEbvIZghueY +uLvEUi6TWCnLDFlDbj2eDVEWFs3fvrYjbmE41UHQKZA9UtiQRkdtAi6KRW3Ru8ULfsFwYWMwJfZL +scqwyhICkVNuLg4ZLosfp+Vm972M3RyrTEIyCe83YAzBtHKjpRSJGBzxXpMvUbkMAzLnkhRpG9ri +4eyYB6weKBQwgg5e2OE5YF1R60gbChSoMk2o7W19vwzrBR4gj37y9d/t3r0/vvrm/au3b168+8vN +zwH00//2s5u/++r9u1dvvrv56Vd/evH9y/3rl1Rv+k+/+8v3L392839go/2DjX5x5Cb/J/zDffT7 +iWrSojcVCxCBpkXl0UFBpXK1C0WVXcHxoAW9E+9TSDso15UlC1mz9xuwZa/MswmLap4lYF4oKuQJ +qMPHySNDW6oPUkakHSbv19FTMM5bEQkd6cyH9UYCBMgIOrHW1vfKsF7gAI4enc4tVOEXfpmpkDwY +NYGKoC8xg/KOfMUdn/WDEui+ycSF0o25nE2HqEmrvN+ApYwJE8y7OHKMTuNx52C3qg6o3J0Ti0HX +FjO4wrrB2oFCASPo4MVySh3Wmc8njBQIUNmr1Fpb3y/DeoEHwt6A1zZhbWVQY/VKCb7yBszdSFyN +etdQpCR0rK5Kd9MZd0HxFcxUdeV+A8a6S+Y44nqxOPWq7TCt5Nhh34jfClS+dWwpJRFHlB0or1fW +KjhwCbYR6cyu5PH9AlTWKqnW1nfKsF5ggLB2xgrWeL3AincF0X0JOdI1I2B+VFJfo13pgJcjICQ7 +9ZV9VFXmTRbjyUMlS5LpBRtXV7UWVZX11YHK3FDmuGmLyzosG6wdyAR0scLQwEGBEenMp7RHAgSo +zFVira3vlmE95wDzFszOtlS6LmMOdBUGaN0t0jUvoNiTRYCh0yXRZQkp8yVfaCN01oJpJYgjHlq9 +34CTRXKxoHAhVaFJPRTuWim8YwqQu4ZeTp331hbXXIgbrB0oFOjgKDjwKZsR64IHErcUCFCZq9Ra +W98vw3qBB8JdTBxCCRsbqVtoXTXM66A7KSLdTZb8JWSF5a5xFu9GZKwBk+TuN2Apjc20crlRmnSS +aIA6p1gsAlTOphqXTdsoRfwGrB0oFNi0F3BgN+SIdeECZiMFAlTOKrXW1vfLsF7ggXB2obN/JFti +pQr2oPOsdbjlh6epu/aj2tUpsqWW2hg1XiHMhtAA1spP6KhPq5h5UYrjzVhjSi0TAip7xV73bTFB +Ri0ew+qBRIEiUHC4jRZqUKRLD6B0AgSo3FViXdverY70jAPM3LyulS5gW/ISSDrMoA== + + + nY68DSILKroN6JIlu0JH5FLWtzUtze/B0TLnZ1RJFhH7WsFmlhXXgWqAlLXmTVuM887rBmsHCgU2 +OAbW7A6HNWig2RHAMGWt0tpb+r4ayjMGIGsX1nBzCqwrnF/30xmsVxP1u7XYMWMMLknx17YYfxWK +sfNZ6VvF9xJv5RQLlmUvHmbmndgYviXf6TCg7EB+u368QzVQ4XD2edffzjDlrdLpZ2jvpqHc9v0L +zZPd48yT34t3b1HvHvz4dipyrciPV/O2DT7EZxTTBUVdZA+ZjvcbcOnhWzxrwXrsahmwVpbRgMRv +ywLwbbFuXiwbrA6YnE3rwIHTL0eseOFI3VIgQKagU+va9n45rGc8IEn15QYjVSVMTJrkI95vwIGT +/amCI1v7mE3brLjlHFcH1I5xYv/QFj2XqXmUHSLv5k93cOE80hFlvUU/xub1AtSRVVJ7W9ejjvW8 +99cyFjmfZZbOUVjyfgMO6LvS8pqAQzYyrfgCnYOXNgdU3pY1L5u2SQ7LD1g7UChQ9iq4V1xzWKud +mHUUCJARdGp7W9cvV8ftjAdXMhYpLyebj8aikA6MSkRQ7ibKg0KOgY6mU2dJ0QOVu+hO27TF2GbL +G6wdKBQodxXcK3c6rMXKPTkKBKjcVWpd294vh/WMB9eyF5EIcrGu7ESRueugcoyEgd3nXENW7nJh +VQMqd1vUuWttsxxQGLB2IBOgn1dor0zukBa7SckRIEBlrhLr2vZuOaxbDlzJXuQssUU1YaxNeL8B +B84ReSaFf9Uwa1WWapELpQzIXaMSUsumLZ4VjcsGawcKBcpcBScruuiwZktychQIkBF0al3b3i+H +9YwHV7AX6f11lSGrUVMhHDhwWi4D46JA2j65X+K0V6BydhHZ6NriaVQFGtYOFAqUswrGSxhmrVet +WLMdf3EUCFA5q9S6tr1fDusZD65mL6K8ohw2ck9hAv/9Bhw4mYX70aLOuyQnRrFCd9ApTkBlb1zm +87ZzrssZVgUKBTbzBQy7jBwRdljx0E7YUiBARaDUura9Xw7rGQ+uZTHi/X9NnThUZOT+DKxXaiAw +VTU/et9go6wOqH1LUYfHte1RTYe1A4kCGx4DW/Zlx5q6EtIpSF5h6dQObXu/HNYND65rNOJO0ZqM +Hp0AuD8Duxrzi/kmcGyFFUUN7aruCrq5cV62LWsI4QxlB9Lr9fMdrGcrHNJh/uv7BWjyyfwl1tZ3 +yrCeMeAbzgP5d4htfch0ZEPm38R6jNkiG956dODC+QXPuFg0nZfyUS4sO9yiD5MR07E2LGUp+bZJ +nPkDVgf01qMDB4s7O6xydmukQIBsfnZqXdver+AriW94IIriFxmOdAuRJkzgBni/AWMyQtHS3HwS +Apnlykx3DhJQGcsVo3xbLG278r7YsTqgUMAIOjhoWp1DutgRFUeAAJWvSqxr27tlSM85cD3jERWo +In5+KohyvwFn8vwwuY0qBSG/7OgHKFiS8yFA7lrDMpNpbIsnakpoA1IHk/fr2CjY8p890sUS/hwB +AlTeKrGube+Vw3rGgWuZjlh9PgU13Ira5R2Kl5IkXk2VU19p2lkN7VXOpxlQecu39vm2uJ6T8lax +OiATYAIlKW/1YJNDCgbTKpdOdAIEyAR0Yl3b3i2HdcuBq9mNsWjOCd5qmpfOXAXnfrqo8kFVXtOr +MZfPCRpQmcvngYe2TU62DFg7UChQBAoOvki7Yg12JtpRIEDlrlLr2vZ+OaxnPLiW6Yg3HEjwPnJ2 +7/0GjHcFsvMHLyiIajJosh3dLjAAuW8rbrtx05YuZ1k3WDtQKLC5PytzWtN3KdLAkauRgOACao5Y +17Z3qyM948A1DEeUSvOsIS88NXS/ASd/mQNfkEqTTjKZ8XqGFhYHVL7yqcChLVZaVL4a1g4UChRB +B2vJZocV4y1l3VAgQGWsUuva+u4a1jMeXM1wxKXTg1bzrJtZBye7ahYv0KCDIZxPOit7a1U/MQGV +O3xjyNAWNp6i7DWsHSgUKIIO1uROh5WON6UNBQJU9iq1Q9veXcN6xoNrGY505UiQJZFt7nqoKTFV +EzORsphVDPP1qwbUrlXJwhjacs2nDdYOzGtnTYfqLQ0dJ9bmMKC+X4D6eaV1aNt7tV6AZZu3VzAX +kdzc1Bwtpil4sJ6iwV7QIaXNoOc0+5lgsybM6awtXx+3wdqB46o2sFZtGrDWFs4IqK2zttPaW/ZO +OZQbBrC5+DFj7t/CjqOD+jofuh3nwL30Oxb2X4uYbFotLNGtYs0BiRkZq4LWNrbN6OZXXc4VlFeg +t+McuGtYDmtPBnEU+GQQR61r2/vljrmf8eAKdhwgXau6crCQ0P0G6m6tWHG7kMCP3ZqBJ6TX6IDK +1zmkNrbN6D9dwojVAZkAZatCg17X5nBaRrN/vwCZq51W17b3ypCe9f9qRhxee7HocEWsq3W/Aff7 +RrE+Rm4yj7VuEN3YkFYHZNbMcoWxb5sX26E6VgcUCnRs+m5GRbxGrAvXOBgpEKAyV6l1bXu/OtZz +HlzLjMO7QnJRt+LcjLkKxdTOKLwNKelxgoW9nYlqHEUHVN6qctXb4moOGn0TpA7GrzdpItBodYAc +zmB34bn3C1A5q7S6tr1THetZ/69mxOHNKk3HjIq93m/AmQtyML0xakRO72qEvlE5lw5U3i4pb9oC +kE7eDlgdUChQBAqOdjOLwxrsKgFHgQCVu0qta9v71bGe8+BaRhxWvYlZDVRVhgcolYJlctOikXop +dktXvuTYYdyxJmdiXUuadur1U5QD0BRhB8WD/FZ2SHEGv4fp64Pfwzqlrm3vk8O67f41DDgS9jqE +dC7yfgPuJ8epapHm4GrOMXQLVMLqgMpWOpaybUt3EI1YO1AoUAQdrJeCOKzBioM7CgSojFVqXVvf +XcN6xoOrGXC4bBYdyIpXiN1vwMlUViSYCgchUE8JArCFNTigcieUsmzaNtNZHdY2KLLqqh3Afu0L +1tA3p05BGDcypXZo27trWM94cC0DDmmgujWc9h/65HXgueo1Ulx0kYydaCxfgzpFCKh9a1XD/Na2 +4b1ccYN1AJp1O4C1yOWAde03YXUKVotsDdS6tr1fDuuGB1ez4rB0WdOBg9Hqk7eDqaSpAItF6PrI +V9FE47iXlHU+b8uXUG+wdiBRYAgMLIXoB6RrLWfvR5h+upPqWlqfOsZN9//jbLgMImpdk7Nf7jdg +uRbvGVcOlP5Vq02DtQstQNfPBmJNxNzqpm10R64VqwN6G86BpVzaiHXhEoAjBQLkDbRT29u6fnWs +5zy4gg2H1+Ksi/hQktU3ceBssX+8ZSX0XLSml4lwjQwDMl8WKRM1tMXjt3MasTqgUKAjo2CrOuSQ +hs7sTkDoB+Q9scGzULtlSM85cDUzLvcwYeLTefcbcHaVMWMrYj0kLb+BVVrn1QGVt3ykf2gb7EC0 +IXWw5A4NOnDs9wh0pMGqjTkCBGi8bdu2rlcd6zkHrmXEYXnP0tSIycZZBWa+SJipTcUiwHZdDoxq +6zBlLFe79y2xrHDYoHRAermyVYFdt3IoMSdbysX0twtQ2aqE9rauSx3rtvNXM+DwMic7mENl9+43 +4MylTp/J5UZNQ8p6vwJK8WVxQOUsF6oa2lKdxjZidUChQBEo2KqAOqRYy8WK1CoBAlTeKrG9reuW +IT3nwLXMN7zlypLNSCLdn4EliJ6bM5ij7R8w/RyM+YKHFzWury0XudjaYRxgXUo6cLSi7g5n4Dsn +x9cL0PjaShjbui51rOfdv4b9RtWDLdt3nXston4mL8vdHXifV4mLzrdZ2brUJTmg8pWK845tF6wc +EkesDigUKGc7WIuXOay9ZKujIPSCD57a3nbormI958HV7LfcvXiR71W934DRN9eUDLVti93zNa/L +0mHK2mQ5k70lFVMeEDqgvFw/38F0eeqItFfrdO8XoHJWDWttOfRTcZ53/lqGG44tlbAkzLMeoBzB +1Wpd0XE9Ht202HVxTTX7fkavzC7JVNuiREwq5RTrCJw1I3EAq4N4wFpyC2cUENB4a9S6tr1f5nY+ +48HVDDesGRb1QD6Fd+/PwFo1E4G2B7iR7yFtAmrnWtQkSN+2tHqGtQN73HkA222/HqvJyv7+1kVt +p9Ta9R45fJveP8ZuW/7tEikL+lqc2XI/ALPW/KM7CVZxtvNOZnekCIj4UPVuNtdug2k0kgyC4VG+ +EtDhwEr5y+ZlDONPdqqspdHeEW77eK1DdoC3WKoDXdp8vwFnSxlDUtcsim5KTa+VKC16IHcLb97T +IIa1jVwqccTagUKBjoKCe0DfYQ12Ca2jQIDGWKG2t3X96ljPeXA1C63gWtGBi3akxoHxxiO5IwWL +cEQtWZHs2o+yWHmcpN5bvOJkVqvY2kqF1BFrBwoFyl4FR7viymENeiGpI4Bhylyl1Vq6TnWU5wy4 +loGGN4RYfbeg56wdNOMJP71hRH1X/RJ0vDslOZDyNc0a87GWeAS/hg3ODkxuNXdoHG6ZmdUco3ue +/esFZGxdLZdXWroudZxnvb+aiVZxdqsSSmL5/gzcJJBTZ7kEnBd00cukUonNAZW1VLxibBtsO3dY +PZAoUAR9609yjMxhDVYo11EgQOWuUuva9n45rGc8uJaRVkk6q/mHid/3Z2CjoYfN7RKiBetWBAcU +1myaBS576tF5EL3YJnxTr0oWG1kn8Kz3V/W3CtD4KRS6tr0nDuFZr69hm+FtcEEL2cxFbbMB7PYu +vl+bJppci4j9WtSKsxqTtFE3DRRZ24B3h2yxeiBRoExVcFfZHNZ+lYSjQIDKWaXWte39cljPeHA1 +2ww30Bo1o3VV1cCBU7+nDQiWakfJcjzwximUYR2o7IVBP2+7tpw3WDtQKFAEHeyvwhKsWF0whQ0F +AjT2lrO2vruG9YwH1zLRSBipq5hSDu434NQ3dqytWI05UacO1bXqQGUObOztrG1uWm7IqRYKjC4X +YgCL+eyQRs5pHAkQoDJXiXVtfW8V6RkHrnumbhhlTMm8P4M2ueqGbmEz71WKuot07wIBlT9LW+tZ +216fxbB64Bo7fzuUKuOOSIcp3d0LBDQGm0/NTdTeLcO65cAXn6l7ZEGWD5mCv/93q88CzIMVsG5P +2HmwVVKZa7OYp9VcmStmqbKa5uqzzJVu1l03baOr4mFYo6viYeaiB1slFY/Vaq54Clx9Fk9tb+v6 +1bGe8+BKpuNcMeJi0R+tz+LBXEwFO7ZKbpPVXMGOaQTe1WfBjuUwtlwXKSVtCB3EVWfxYKuj0hFa +vRX/alebxZPp2vbeOJxnPb9aIc+Kd+KoNWy1WTzYqqjMlS6vl/xSOb6MnYNvvgiL8jXKntnbrrNc +U+mxOqCrzeLBVkXFY7V6K54CV5vFU+va9n45rGc8uFYhTxjiHOx4mdZm8WCrooL0llnL+kq9Fewb +38Q61GZBPoQ6tlx9nEhxOqCrzOLBVkOl47RaK/7tri6Lp9S17X1yOM/6f7U6nhWrfg== + + + a56M1mXxUKuggsC2rpoAzbVWACce928OqJzVHMredp211rrD6oC9LouHWgUVj9RqrXgCXF0WT6xr +27vlsG45cK06nhXv4FhVj1AnkgdbBRWcInyVkKu1gl3TCqOuLguyYQ6bls3V2zOc3mlmVVk82Oqn +dJxWZ8W/3dVk8ZS6tr1PDudZ/69RwxPfP6vhbzVZPNiqpyCwWnBS6qxgvzSj2tVkQbBaJ64tCMqs +FfQMawe6miwebNVTPFYz8z0FzhvgqXVte78c1jMeXMt6pF2gG2lak8WDrSIEzZCks07qrCBQDxi7 +miwIrnXTsrlCyIaz+aLJWpHFg612SsdpNVb82109Fk+pa1ud7Wo4z/p/JcuRSLOStlaPZQRL5RQE +ghz3pVcEuDZfpEX7Vixd3bUta2tnWDvQ6rGMYKmc4rGmrqR0CpJXUjq1Q9veL4d1w4Or2o40TVat +sWL1WEawFE9BWuTmg6ZVVmhGLRq90Hos1L+wbdfLrjqEHWjVWEaw1E3pKIfVpO92tVg8meMqWft1 +HyWfAf+XqMUyY5jClnC3FB3YqqbMZbXK3lZfBVaGTUhXi2XGG77mlDdto9yPPGDtQG8pOrBVTfFY +rb6Kp8DVYvHUurbNSWHDesaDL8//RKRy/0dztVg82KqmIKn9hgepr4Ld6hy0WiwzXcqm9TWtLd5M +rYa9Ye1AV4vFg7Vsikdq9VU8Aa4WiyfWte3d6kjPOHA1Y7FgDqp6F6wWiwdr2RQkd5GzzFZfZaZb +95bggNy1jKtp2xYMhn6VhCDtMFeLxYP7XZQOqdVX8QS4WiyeWNe298phPePAtUzF0vxVK3LC2kOt +agqSO+foy65w1/iS6KEWC7JB67y5trCeo8ZwDGsH9losHmqnbz1Sq6/iCXC1WDyxrm3vlsO65cDV +bEWgoVr2nNVi8WCrmjLj9ZKpjLVYsG8t67lJq8WCfAB9KW3aZrk1fsDaga4Wiwdb1RSP1eqreApc +LRZPrWvb++WwnvHgWuYiYE5y24erxeLBVjUF6V3lrKfVV0HgXJdtLRbsshoLrm3GO7fDBmsHulos +HqxlUzxSq6/iCXC1WDyxrm3vVkd6xoFrGIwolaqVG9RaLB5sVVOQ1Cq3dFl9FQQu6+qLrihfS1Lv +j7UtYDRbEFOxdqCrxTKCpWqKx2r1VTwFrhaLp9a19d01rGc8uJrBiKNrtV+tFosH9xsDC96HNpsD +1qYtDGFwQOVOk9r3rm1hr/mItQNdLZYRHIO1VayRLcqRAgEqe5XaoW3vrmE948G1jEakYTZDw+au +h7YcVCbkEK00thKWQj+Q0BdkXDRQ3luGqJPRoezAbPPWQ8OSdYoqTi2E4N/OMP240ulb9g45lGPf +r5UISsQGu9+imJbgwXJQlDphZqLerIh9iK04oM2YrHmcrm3NdmK3Y+3AcUUbWIqmjFi5uspIgNZh +GWntLXunHMoNA/7DzvDNeBYo6cmKbsM5sFVMmTPsME1NDamtAksK7+D1QGJGjnae0bXFCJvqcYa1 +A70N58Bdu3JY+0U7jgJXh8VT69r2fjmsZzy4gg2HJ9jkirxeh8VDrWIKUTprkEdqq2Cvshwgd3VY +5ox6j8bmrG2wK0Ed1g7sdVg81Na/w9lvlnTvd3VYPK2ube9VR7rt/9UMuIx3p0fdm7QOiwdbxZQ5 +Y4HKWZRbSXLHrpVoN8tpHRZkQ49wW9tou5PDGv2mqXVYPNgqpnisVlvFU+DqsHhqXdveL4f1jAfX +MuEAcw1aUULrsHiolkxBajVL1WqrYM9q1MiP1WFBLqhi5dpGVx1dkXZYr8PioVYxxeO02ir+/a4O +i6fVte2dcli3/b+aAQeY06oqgtVh8WCrmIL01qRar9RWwb7pDXCuDgvyoUUdG2sLr2h6VMqwdqCr +w+LBVjHFY7XaKp4CV4fFU+va9n45rGc8uJYBB5i10k6vwzJCpWgKkltK0Ns3ZuVtS2p7aB0WhFJo +YmiZLIvEofRAU4Id1CqmeJzB72H6+uD3sE6pa9v75LBuu38N442EvWYCWh0WD7aKKUhqruox0Fsa +M1am1cpBVoeF9pagPgtri7/aXYiKtQNdHZYRLOdvPVarreIpcHVYPLWure+uYT3jwdWMN1w2RZMG +rQ7LCIZertKPXoxf0oYRuEgFutRTjGmVLhoLtbbZ6ayGNQ+KrLppB7BYtg5pNPeiIyA6V6Qjdmjb +u6VIzzhwLdMNBzio9LEqLB4MrFmqClu9dgr9oTEIMGQ9gxE0EZF6PFuavbbNWPJv3WDtQFeFZQTT +2Y4Ra+zbU6cgjluZUju07d11WDc8uJoNh7StmuJrVVhGsNRLQaAWT4x9dyhWUDyOO0ls7bxtL2fl +sHagVWEZwVwzZUS62pj392sVlpHU3rL3qWPcdP8/zoJLBc98+mzJ+w3Y6qWAwg2LWKtjSmUVEG4u +NGdVWOYUTBl1bUHpB4t1g7UDvQXnwFYvxWO1yiqeAleFxVPr2vZ+OaxnPLiCBZeKFcJ3VVg82Oql +IKk1z5ZNxm4G6FbKzQO5WxFvV9+2xYu8tTSZYe1AV4XFg7VgikcaOls6Aa4Kiyc2eBZqtzrSMw5c +zYhLPUDoqrB4sBZMQXJLv9uDK6tg13Jq0QGVt2nRO+ytLR7X0dCeIu0wV4XFg61eikdqlVU8Aa4K +iyfWte29cljPOHAtEw4wp0Vv7FXz2AGtZApRK0FHra2CHStRS5eakZGiXeLbW+Ll0xrdNJQdaFVY +PLBrVg6lVVbxb3dVWDyhrm3vksO66fzVzLeEqbh6g4VVYfFgq5eC5OasUR+prIJd61cJWhUWZINe +E+/a0u3QdYO1A10VFg/WgikeqVVW8QS4KiyeWNe2d6sjPePAtYw3wDz3Wx60CssIlvB5ys5cjrZ/ +rHafWrTtA4jMcR1b4uGPXEeMHuakZAdbvRSP0yqr+Ne7KiyeUte2d8lhPev+Naw33D7l4gpXhcWD +rV4K0bpofWiprIL9avPqy60oX/txX2sbLePXYe1AV4VlBEu9FI/VKqt4ClwVFk+ta+u7a1jPeHA1 +6y11H56rwjKCq6Q+JzxarneKFT6aSJ1rGi8oeoyRJGCq+awtKDDrBqsHWikWD0ZXQFUExXIw1Wpw +FCRnYThqXdveL4f1jAfXst9wiJNallaMxYOBilWFrSrj6AuNSm6vy0dA5c3abNPVtpiVauabIO0w +V4plBIOmY+u/2e3ja102BAhQedstB9e2d9awnnHgatYbEpG0rLWVYhnBclaWgEuPlXEkOGUX0bZS +LAROevbOt53V+nJYO9BKsYxgqSQwYm3l7P2ty9tOqbXrPXL4Nr3/jy3FMsfubvEWnANrEZU5otY5 +lFmZY7TT0FaOZY6o2A9lW2BiWIJqR9dh3nJzYCum4lFqzRX/7l6dxRPZW3qXkqE86/i1jtlFvPw2 +aP6iVmjxYKulguSmpnlRUnWFeian912FFmSCnsl3bfGkv2p7hrUDXYUWD7ZaKh6rVV3xFLgKLZ5a +17b3y2E948HVrLeYnbfZKrR4sNVSIYItF02OUWPnUtECOFahBRmRqlrM1nZBDXPZYO1AV6HFg62c +iseqdVc8Ab1Ci6e1t8zO3W4ozxhwLeMt5k2JlPsN1KqpILXq17K6K9ixLjWsRgvyoFQ9M2htl/O6 +Lx6Y3JpezuupeKRWecUT4Kq0eGJd23xe+eWcA1cz4SKmKuspdKvSMoKlngrR20vwS3AwdpvAVWlB +PqxVK5xa2+DUEsPqgValxYOtnorHapVXPAWuSoun1rXt/XJYz3hwLSMOMK92WMqqtIxgo6EH1fWs +VSQftS/dwj2Lbtuytrg6VY0zbnWQlWrxYKus4nFaDRb/flevxdPq2vY+Oaxn/b+GFQdYQcfY1msZ +wW4nC3kd67Vgv7SCmqvXguBQN/VaaMrhuhmxeqDVa/Hgrtc5rFaDxVPg6rV4al3b3i+H9YwHV7Pi +UFeZ1c9h9Vo82CqrEMGLJlBqLkhExVIvpbB6LbS/WAKla6t3xDusHejqtYxgrYzgsFoNFk+Bq9fi +qXVtfXcN6xkPrmXFkViyVEmt1+LBqW/z6FMKuqVyDRbsW7MUSqvXQmt11TumXNu0al0hr2isWlWo +50wMYC6t4pFaDRZPgKvX4ol1bX1vFekZB6575m4YZa3XMkKlsgrR3P1cXIOF+mcuAKvXQnPKtFfX +FgyAssHqgRYmHaBSWcUjHaa084Iszobo58LdRO3dMqxbDvxV1mtxx/C+dNTPCrbgLUhqxNFcvN+A +M/sPAIjb5Vy19oTczTxHywkUIA7BssB+t8xxbLu0/5+9d12O3LjWRJ+A71B/FGHv2KCRFwCJrV8i +ZXt8Dm05LHtGEScmOig2W+KIlx4227b205/1fSsTSABFEqhuklXskkJiYQF5X7ly3RO5O+yg1hwY +e3B8oOD+4CD4ZATucr4YI4y7DdHamK4RGXSMQOIG49RSx+K3ZUAigeSxmhAmA2YdWzNjJ4Iz6IWH +5IMXwWiQ4VWaCRVoA+4FFe5KB2JTaIaAGVOuQKu+UAHJ+/WiurJFwjjWC37BxqxIJcyWlCJCpWnq +ddDRST5gdHrRRYksLTbmeKGvlc5EwObs0iKpUwWMXE2T/Bid6grxPlQcMu7SSoHh8DO0GIItjZJ+ +BdYVciVZ6UsSuBiagzwxAHLvHccK9IYCW+JoFk7ohGDc4oWVs6XtOGKN1IhKZmoLMbKyc3ECh5QS +kZYuXa4os5Byast81a0Co8pd59Zq5G5wfQgnECoammUdoqINCxmtSwEZgAzTUE0X/ZjYgLFZ5Vtk +fdnzqzi2aFsRMH1k9VujSSgD6LyKUuAYVRQSRBQ2MBLXtrPDhFbOVk/8ZX6XzkNRb/Ytyy5cssrS +D5Z1jDzBotXxhjMZb0V9IxbC1ZpMS5Cxsk1cSTmr08aE04KJi+bhUprwuaw9F62OmCgcU1CcSXpg ++dmaJON7kKS0J1vrU5LZVvWabZfyJ+Dic2XUETxrKdaEWlPWnMVZhZ1Q1zblA2hLTQahU10q8435 +N2mHEQuO16/WCQ+CtiPJX33zp/Dm99dvj24/fvhZyPnd+e01gBWAb/5yc/1Xofl3QvaLQsFH5z9d +XOcvDv7yHm9Mqa++/59//MPFpVRz8Lvup5wzv/vhzyd/uXl7jp+DA+jeF1+vfvPvq8treVVIt24v +fvx4d/4BR42cYbenoy/Ofr64fHt7fo33dvW7P13f9e/wv7t4kv2m/EoOsn9cX5wJMJ1n+Yf/PL38 +qF/+++EPr0+v+B06wV5t6zh+nT2OX19gHLKfZ4/kXxdv736ePZr49VaP6Ofzi59+vps9pPT5s4/p +5sf/c352d3Tz8fqt9O/o5pG90Q/wHfe/fHr3YfYoB2Wefajf/OnNN5fvfz59Y+aO8eJtxhvfMyZ8 +858zerwtZPLu4+2PH4XDPzufOwtadOYSp3aem2iKsD53PD+efjj/w+35//0okzCfhA== + + + jko9+wivb76/u7g7e4RK9qP8wK//fnF5Pn9/Dso8+wjt3KFdf7z67uzu9J8LRpYXefaBYcvNHdvt ++YePl/PPjfT5HAp0T9fNA11fT/2yQ+D87zk5ebizD8z7My/IxfXc5bh5f357endzO3tB+gLPjmbf +33y8PTv/4+3p+58vzmYfcY9MRX7SXW/53rm4foSEDAZjX3DXHN9cvb/5cHE3Z9M8RQfIhz3a9u++ +PX+3+nov7W3HOPbS3vaOaC/trRnllkh7/kuW9t7dngrbe/mXm4sPr0zemy3E78W97RT3Zu/Lvbi3 +F/f24t5kVHtxby/ufTHiXmFfi8C3ZCRbLvL5VyfyLRjRroh8Igcdnf/z/PL7n0/f3vzry7Z96ZFJ +sfC1HJg/Xn58hFv5DMzmtkoGH+7efnv+z4tTdGiB1JMXejGe4I+nHz98uDi9PtIF3BVeevbavJ1/ +DL99iXN4/kDmn8JvX+IYXkIBtp2a3bx79+H87ug5aNoLbfvvOMId2vCX4FvgJXh2c3lz+1//+lnF +mJn0+dfL+arE+PV+A33CWD68Pz/77uMj+2H3OILZvj0fPt6+Oz07//7sdAniDQo9v9Qxe3CyuB8v +T2+Pb64/3J1ez1+3acEXsKYtHeXv//3+5vp8g1H2BXdJNimqspw9R1uu4jDlgrFst5KjsEvG8t+z +x/LfL8iD/PXm4vruJKovXkIfef593KonkbnYIX7odRoTFvIN284GbaToWWxN2O412jXJaImRZFuI +wentxd3PV+d38w1wu0QUZh97vzyiTMmGg0+3eCCP8OL5QMw2iwq/uPkDcVs9kPlU+ZeXIMqv0gq/ +mBvY9qPz8uLur6cXj8mSX/jZuTuy8nI18eId90IL+efz25/OMZM7xAQt3VyvcS2ergN7l6GNFWpf +vRJ12gKvlO1Wphmz9xjafo+hLytI5Pjm5vLo9vz8v2dbNV+jZ9Tbi8vT+XbdXVJimMPZceW3p28v +Ps5H3fT5bmg3t1vinD+Qt/MH8nabB7JrIuafb27f/3xzefPTrzskmuzJ2g6RtVdDzOZHsGw5MXu1 +YWw7ScyK1+Oy+mp2+rJwim3e6rNHsmt7fec8bl9vzP5slmUfs3/fGF82Zn+2H+6uxewvIOTbfiTN +3mRbfyTNl3B27EjaySwKj3iUZGRtmfP9C3ndf5E7fusdNX6cjWVbT71mj2RXgnD+Ntucevzz6fX1 ++eX355fnZ0v0adOCz28Rmm1p3XSQ04Ivdg59e/Hh/eXp2fnV+fXdn0/f79BhdHUqVc02TO6EdLRK +/64mP83g59xR89d8/jt9vsWUcutP4mW5Brf59Jo9kl3jvY8RxvznRD52hd4twKxt3yOzdQhbv0dm +j2RXOLz5kcjPk3hlW3bfu0X+Qe8uLi+X+D9dbvNKv7u9uZo/GH78/FrJR5iczDD2mMd4bhn7+CIx +V7PH8iPu5JqvG9evn9+of/mv019nj0ko393p7SJKqd9vryb87ma+5HHzAgO5PacIOHc4p2/fXtxd +/HO+ONUXeAF7zPX8cZ2dfbz6+Li3UD6yrMgLRDRdn5/ODn85O708+/PN2/lj6ws8f/DZbN4iW73U +/F84hLkLOCz1QiLJ6fXF1emLpYbd1Tx0Rdg7w2yZZHf2apxh5o9k17Qfe2eYbVH37i8snOgUds0b +Zn5Os11zh1lAyrf9UHo17jDzR7Jrh9JOusPM5j93wx3mi9zxW+8Oc/Zq3GHmj2RXjCV7d5i9O8y2 +HEZfgDuM+VLcYRbQ/G0/iV+NO8z8kewa772b7jALMGvb98ircYeZP5Jd4fC2zR1mq+0/u+PNs2DL +LSUeL7SGu5g1cIEf4H4VnmwVni7nxg4swtN14IUa3/2kjd/86c23zNnzZpnmaxZDtDtH1OvNWzRf +DbgjWYueJwH4S1HTJXly9hTtYYpW7ynaa6Ros5d1T9H2FO2VULTf3wrgy2bRzjEFr5Ge7Tm0PT37 +MunZF82gvVp6tufP9vTsS6NnuVHnzTIr/Csja7MH/wXZ8PbbZs62ab7kbTN78Ptt84Vvmy/rtqC/ +Xvz7/PKvl6e/vlkW7LiNDjtVuapme0/qzP9tgQNlVmKXKN/t+dXNY+kNdizXy/ycIvv8KPv8KJ8J +6Vbma1uuTCX/L1fy39fyW/5+LS9Wr81l++L67fm7i+uL+Qau2/P356d33y7YblmJZx/fPkeMjmvH +csR8eI8sMXNHt0s5YmZyI19agpht4aFe4QWFPy65bHzLPfWXjGVXfPX3CovtJQeP7e3dtCstoghb +Tt02NCltffj8zdX7mw/Cln/38REStssBfHGMO0QQTm8v7n6+Or+bj2u7RBhm69R+ecQ4lQ0Hn27x +QB5RhuYDMS+hjJg9kEecn/KBuK0eyHzS/MuuUObdOEQXSj27dIS+2qyIn+UM3R0Tx0ZrujMORPsA +wL05effMycvSFG6jVmlvTl43K3tz8t6c/Izjea3mZBIXGJRt+fUiQrM3Ie9NyHsT8v6akcnI9ibk +Nd3dHhXx3oS8NyHvTcifXzuxoybk12RsfXvx7t3H+beZbDspWDicXaEGs9PTffh4+0442++Xpfkf +FNpeO5JO/7KxDco8+9B+Pb+8vPnX3PFdXvz08528L86QB3f2EMfFtncB4+48vrkW0f16/r6blNsr +3V5U6ba/4/bx0eyVbk9BSr/+6fb8/Ppr4cDOv764fnvx083X/7y4uTy/+/r2/O3XN7en1z/N3mp7 +bdxeG7fXxu21cWtGNp8P26vkXoarMmG21eX0vy+uPt49cvVjviTp+2dHvHr2mM4v5WGRyicr8WL6 +nm8vyL+fYH+9lEfMtypLnMQ9vkMo/5rUTh/en5/JwXX7HL7wzy4dvWplzWwSlZZ4sbQ/LbjNaxg7 ++/t/vxdeb4NR9gVfgPF+RJv7BKqpvd5mr7fZ622+IL1N1NKo3iYqcai+2ett9nqbvd5mr7fZ6232 +epsd19tcRoXGq3Ch2Cuhnl4J9X0U/nZQC/U682dsoI/adhXbq4wAfk694QvRp30OjW0jDq8mh8b8 +jA1bnkNj/opseQ6N+QPZ8hwaz3MPyHZ7E2//8Xl5cffX04vHrBT7s3N/du7Pzo0HsuVn5z7/1Lad +nUup8rYfmxsJ07tydO7zTn3a3G/Lsbt4Pfc5p5Z04IUa3+ec2q2cU9//fPr25l9PcX/R7lCiLzy7 +wK74dc5OiraPyH/2LTT7Ys23j5DT3K3t3y+AZPMH8uv8gfy65RRg26nZzbt3H87vsCVuz98uotO7 +JgN8x5F+GQLA5qv6GiWBbVmV132f+F4022XRrDDVV3NRcj6f8RJsxpKRzGc0XoLPML6cPZJ/Xbxd +4E4Yv37+Ebn5I/r5/HHPw2xI6fPn56C+RKXGE2TR3h3uaq/U2AmlRr1XamwtKxxei1Jj/kD2So0d +EH/3So3tPXb3So1tpOR7pcZeqbGtSo0vTDS7O13gaPkaBbN3t6dnd6eXf7m5mO/YrIVnrnFq6bn9 +Mw9n52z58fTD+R9uz//vx/Prs/kc56jUC8Skf393cXf2iAIrl9jw9d8vLhfkShiUeX7N12wf2+uP +V98JFv9zwdDyIs8+srOn8zJ77pEs02ptcZzz/JE8ocCzLafC60t2tOA8eHd7czV/OPz42YfzmlI3 +vdZUR+Xh7Ftb7m7m81M3LzCUfe6iweD2uYv2uYueWLU8Xyb50lIXPYnS6O8fb3/8eCmTvUt6xNeZ +e2WBSLHlwtHzpFx5IT3vkviwvap1LX/41evwHps/ji33HStfne/YghHtfcfWjPLFDRQ9X/LmkfD7 +122muMv5s1dkpCj3Voqb3bZSzPZm2jUjBbbcFqjE9+Le6xb3lqDZXuDbC3x7gW8v8O0Fvr3A9/oF +vtmiwWsU+F6vX9rsnA57iW87Jb7ZC7iX+PYS317i+yQ020t8e4lvhyW+wrwWmW/JSLZc6qtendS3 +YER7qW/NKF9c6vtfNzdvf7o9nX/ev0aR71XeGbEoRnzLQyReY8aL2cLcPuPFsxOEfRrPhwayz3jx +iRxGygPxKmjzPn/H1pKxd5fC3eklxP/14+Xp2S9frxR08/707OLu1/9aoBP+cPfr5Xwdd/z6+V24 +l1y4vO07a9Fgdm0z/QGIuEN76XVqRJftl504VzfLObTtt/58YCrH49dE3r4cxmEXbwN8TQz30usz +t3zjLBzOrihEZnudfPh4++707Pz7s9MlHOmg0PNrypet1rKxDco8+9D+9fOC6PxLaPXlfTGD88hG +OC62vesXN+fxzfWHu9PHrlLMtSrjcrukQDdu9uY9/e+Lq48LTFvd98++5MS5V5NlqJ6d0+r8Uh4W +KZuzEi/GY317wX1zEo2ML+E1IH3gHj6JxGrP7e3Kra97FmmXWKS0wIvP2GnBF/CTXzrK3//7/c31 ++Qaj7At+ISzhnl96eX5pzy7t2aW5ffg+Eqod5JdepzVgA85p25nB53GT3v512qvMnyGd6O3F3c9X +5wvyuu8ScZh9IP7yiE9BNhx8ur1yxi+PfJkPxGz1ijySwScfiNvqgcynzL+8BGF+lY7ES61nW398 +Xl7c/fX04jGJen927s/O/dm58UC2/OyczwRs+dk5fyBbfnYupcrbfmxuJEzvj85XcHTujh56f0vj +NvJCT04Jd2Atnq4DO4QIrzUV0T757GiUu5eK6PVekbeRxWC7WdG/L85hvWt8204mWbo6lapmp5fY +BcJuVmX8d92vDjJ3yPw1n2ykz3dgf207xfijFP3wuPPY7hIMRlL9OW3AXaEYr/Bsetb4r23NvrBP +8fH8CdJeTY6PYrYwte1JPp5FEfXMY/rui4ly3bn0GK/TiW8x6/Z6d9D221Ngb8DI/v6KEyDvojvC +Juuy7fsoH9PssMZdYbXN4fzYqD2zvT+TPsNe+uHd+e0fLm63QUWyLet8d/rj/DXeBYWmXc22c3Ds +/3OZxnJQ5uVScX28PvvbDlGTV4dlh82qXH0ZePbHPZ69IJ6ZL4WcHb2UiwmFHURd//329PrDuxm3 +SGwPvr9OfcgmrNq2s58bxpnsgjZEh7YlfPVeHxJXhp5z31xebsGabMuUbIase1/NJR14ocYXXf/0 +1Td/MuWb31+/7a6BAqgC5M1fbq7/KlUwTUmh4KPzny6u8xcHf3nPOry++v7Xqx9vLg9+c3T69qfz +lVkVq79eXP/y24OP8m+5+u6gd6j54Vd5+H/kx/8R0L9WfvXn1f/3v8vVW4H+8LeD8rAsyzasbHXY +VKurg8Iclt7UVQQUVt5Xpl5Zf1hVrgGgdXUr792ha+tmdXZQuMNgvF1Ze+hKlPGHtbdSpTm0TZAi +1WHtjLwQQGm8R5HqMNjg5ZvysK2NfFNLs1XVEOAqPNumDm16liLNoQlVa7svwqH1wbNW5129KloU +KQ0AjQvsmSnxUYOuGWOlGSN9qqQLAvBt6wUgA/Rt0wFQSMbRhGbwTe0xZAG4yhIQmg== + + + ptYRO8NCTqar9GxcphPPbXDsvyuNrI/xhxYTbcJhqHREAvKmNSvTHFYGkyCA2lX1ytSHxno0VKEr +Ugh/25aF8E6Gq9+iYpS2BHgT0F20ULUrtiiFpRB7YauV9koKaTc9AA2GX3Ao1q44NJ08ATVtRVBp +G8NvbCXDllmtbauVuKZZceJbDglrLmvSHLZtVaPaUj6REdWHdUPcIA44vwJO2NqnMk0TVkQbl/rS ++BXwypUoBFwDAmHlS8dCxEdZAsFPLHYBfPUyaKBvabrnkh/r76J/GUsXffHYRJG3EftR9B2JXS36 +vsbxEMkF3eNsc9BFPmpMS9HPS5y6Ip+7OL1FN79xAYp8BbhKRb5McSmLfi3jahfdcieUKDKcSHhT +9IgTUavocYv418YfbYhYWztv4uc+VYB5YpWYDDaDeWLDuszsjDWpeyF2ODQJG6t+Y+lAnY3bkbuv +yLcfN2gx2cVFvo251av8q0gNio4ccPZN3A+RZpCuVJ4wJSxKeQJ7PiBORU+dEv3qvkkUruhIHMlg +nfaA0kHgkfERsWRdiGoydXEGsCpASN/tgqCoImhr2QEgMtdA2hdUVryvVomsx8ezA6J+2yYAKvCY +8VQByTq3RtcKyTqrjF1BZ52r+t5iRK4ZjEiGLTvF9cPGxDT8RicGc9cChbu5w/QG10+vLICQQ5sW +wJO+hIQnLqAZLGVluqUUIoXVbtJqg2TKECtgWQJIIRlH4Gz339SVaSNq+UapXxsS/qEM6Xrd4yjR +2PebLNH1uMfYDum6H5Dm2tWm32HYTqHs9hXwTneTS5vPrUb7s9KTozL5JtZOxI2uR6500iZaYPSE +wqbjyGqcIEOqUvEbWwUT6Y6e09wM3B5VYCEQsDpRsJLnWsOlVxqnZzvWvSfsxBJsShJLGZriUURy +Z5zyEAnHK8NCxMdImNt6NSTdzSoj6znFd5FBiZgtlFkJutczo/E6cAeixNalYOJP2D0h14OjSZ45 +vY2r4+nlOUgh4zWPN9/oYS/LRwStvNE2BA2DHpFhpXPt9Qitm9X0lB0fxOOTenqYj8/7MUOQaHZP +ssdsxZjvmLImY+5lxN0omW4y/mfMIo15qCmbNebElDjXkVWrdU7biIvoE+ly00Z+DzyGCXXHMIKs +BCx/oiqkO6Z7T7pkbcdwknRVOU+aqFsibon8JeqXKGRPIBMRTTQ00dghCdan4xGnfXJw9ONB8nQ/ ++lkEkd/84xpCw9vVT7enby/ORSoxvv2tVCNrYwL+toLnTj53h75xwIDMcd6sjn468NVhWQsJAqBI +D0UwtSwwNnaQVZclFnpwdHXwTpo/OhJx4T8+om9NaYRClYchWCfzBIgsh9FhYJHlVSUvPXpiqlqW +qsRp30hHfjiNo2uUEYMgIfNsBS1dBEi7XA4cOI4CheC7sXrgWPklM+QO67Jq9fQ3NRjCeLRU0phU +Uoeg50jTWMyoTGRojHIUjZGztgZBC3qS1MHXeti4/vlYDhvrgGYdKBw60zo9goU3BOI5GZy2LDjf +SiHBTWd5EsowZKJw2rgSDDr2O2gQDhvXPx/zrHG1z7+o6kqPGtOCvMsEAP8BKEPNMu6wsnruCVdQ +K02odXy2rLkNW3KG2KnguI6xtw15IdnMcoQpWShxpsluL9F9oQPS95pnjcVCHh+kV4V+7FdaWI8W +g53NBmplKmW/oHfsBLhadquinMVuFux3yc1fBnKZGBsaEgjPV0OGpeUXQtb1qKkt66hK0HvMemWd +ttOCUQnYwIE72qM2nDQi73FHNw0qIUo4rCqRRCiaHDVCTErKooJBFY4awSnP40CwjPJr40ttKGJi +Adysa+5Mj5aBuiY0VQKU+Dj+7F6xsFl1ZVE/zqeI1hy7qeXLrgdEZLPqukg8XmWDwEBlEbJxtkIv +MA+C+TpV3q+ymeJsknTWwlqu4mxzsn3bLQdXw7U6TQmxhAhwahNecUUTWvWLnmGV4gUxxyuWyYFA +nMIR0uMW37SrDv2IoFZRzNUdDrMtXynaE83ZG29WcRt0nUX3rV9l+wR7yRHfTFtzKzmnz2kz+jas ++r2I3Vp2AOxmU/MgIflIE9rvd9AEKh8iSQDRsC17KEilh42cNquerJDy6IFJCEiTIPgqUSasMqhM +T7xA3BJtS4Qv0r2EQz1lTNQzoWxHXElbO9rLp+ODAQJXit9dafKy0oCV9VWkRQPFoAtN3Ei6ydlF +braokIkjKDBIr0cwBwkhyLq2n5coKNXZRBWcS2/7b8aTraSgsdl6FOMlK0ZLWkzWvBghRTFGmmKK +V8UI84oxZhZT5C3G+F2MN4DSXWuyPVKMt1Ex3mfFdCsW491ajLdzMdjxVgsNaQI/ASUmzfAmnXJK +VmoSLsphbVOvEgUuSJlcT5mKCe3SY7rpqVuRkz/PljMKqQS4yIlopaxDIrJliNJrIsBFTp3j21i8 +6MrHJoq8jdiPou9I7GrR91WHU+TjiUMu8jFzVop+WuLUFfncxfkt+gnOz8C0BP0x6do4fdlZaqr+ +zO+O2w4lsjO5w5uiR5yIWkWPWxH/ihwBZep4yvLzqBkyslcjKlZRe1SXA25DO+PNsHtVxrN026rI +91Xce0W++ZyLkMEGLrIdHPd4/w2oQOMjG4aFT6Qi49U6etIxdB3JKSZ0KWMMO+LVf5XoW8dfEkGa +qKpIVBBYFMqMU1VM67hYIKNrIcj39Fwx1pqeHVa09iayyyN2+vjgDyIhfJtz2TWU9dKCsAw1H6XZ +xrikJgkV8bluk6bWQook0RYhykVYqZp3kSYiAzyanQgh2cZxYLOvsBpVq+NsxkvYdERYcTD7prFW +yUMdIsLrhtF9kmgqpBA25mtMvEDKplFtd6lKQJkXKtz4o67jbhB+yMbPg4kVVFpBsJFjr0xIDcfd +JzismlfMier1GmJ3Aw1l0vxWvtU5bWwTN60giNWZ99RjVMq7Yl2C7wGJgOF3/y4W70vHNvImYkf6 +fsSudj2Nw8lHE8fcDTlNSzcrae7yqcM71QnE+UXpiodhXALX8fDdOsXV5GJa3fxc7zFKZBgRsSZ9 +kfBqgnwZ7hFDG9d/k3A4oXDC8wzNMalVYL26FzDtIkCvbJ3xS2S7+xfjQqgXEm9fr7QcTFQSlFRu +NlXfeVVC2KzvqvA3ChGiOhr+ZH5GEziYYBNXebAG42Uar+N0qcfYMEaXKUaNcI44GTqUnGItp08G +nRB7hPjZnhjvl1Sy21GsvA75tovNd1tzuHmb1XCDW+3PkAhM6ARnp6lzYpImUnePs6s00x1RYv1+ +QLm4XvHQ1wXDejrXEUDVSjcZjQRG1Lb/AhjTVBnx7XQYHVIR63iyRFDCykTTE95mdD+hdnc4JLQv +8g1RcEcMHk8O3h38xz8O/kFl1Q9vD+rVb367+uF/TQFfvTGrb97Ln1IOqq/edKt81T+Ml3mwyhkK +naHICMtGODhCUpYYIfIY0cdbAWUm22W8nUYbjmXQhaA9CjV7SA04OtxMaAZKjOnKPbQIn+Z0akrE +xoSOJUYdKEb9mxBuFpqS98kBsGa6pkfJ5LBZtzLTU2tyrK3BgDUH5PgETTimn08O3+n5PD7FteD0 +tJ8wBGOuIXVwxF1MOZAJn5Kmf8zPTHmeMWekJXV1i2550/IXaf0nXB/LTbnDnHkcbHlupow8TGjH +hL6gBPrRSVPSD3TUxH7W9ZRaxu03oqkTqjumzCw2nuXJQowPAQ5pfFCMD5LxWROJyuhEGh9ZOQ5e +Q4//zTViv4QiwhNHKCLccSjDQJsnckrj5US/UpHZofOHVVADfgu/Afg91A6mDQAccKISMm+iFV1k +MZhL6sNGpNrAb6RIgPKh0p1lSl+JON+W3kVvBGNLqLlaXzkV3QxMay3Ui6WKmgZSlBxFkECieEij +iWrGRMYRWdhDLGkgsVIToGIjhhWCU4NOCcuBzFRVYoFhgKos/YFc3ULL3B56w+fWwDAoh58MMFTE +Wewqg09UPV9RRmYZZ5X0maaif0WaggJzUEH/J1OAiSzSLHASagrmcRZgyKIoJ2OsrKqoMCQiQ4UN +CEClmiUO6FjLBOVqbVmxc2peoHXLQQtUQcIl29vQJCTidKuICKnPqoJUv2hh9YaU7aOWyPiyVtMZ +NW0UzwPmAEWd+mO03BSoHh4QbJDbjT2gTC99ElkY35jWql3aO8y+cBquVHFW8FvVoJWPbgwixDrq +gBqrSEOusxU+omq0krKtGlrdItmQhmrgfyOriwkEwCRlKFUCCUAngFZVCBEke9embyw8aYDRZV1H +FLeO7gY1PWK4C7CxZKzJ6q+4IVvHRHpoo0VfULuKIqe0AwR1aFlJeFPDQycjbe6wbVTcwXemJrVK +36EuHzVXRL0ib9CVVr1tpFe+VfaM4jq6zTlL/QamijBk87EVkwmADNOaup+iYs08FjDQlrFy/UrW +w1KrgPXg3my5G+K+LqNnWQnzpi51JCVCIau49qWLeN66SK5BkVSe07NFSrnkaKOtU7utiN4MMLEY +omsdIrI7ZSFsG61KqhzCD69dBLYHE7+O/kTZ3vE+taLNglKhmHSljV2rWx2190EhJrTRQFjFTVfK +cZ/kaIXJosKcyjFSGQ6KoHrBSDpJNazzsTlYpzryOqA9if6SRhc5kY6EvOgoeaL1RUfs04FQpBNB +PcDoLUVcTDjsqRxyiXgDh4WAlFFvwffZ61gDKqij09Tg3DmD3Xmdsbn5LZoxIAwW5uO6ObTQ2Rn6 +sripsRleBTVPRg+RBU5xtaBNq4jvTVDTs7Qv+2olp7I7NLL5friCBOqoFfJy4gYs/bqSTQs/h2YF +NyrBXdmZR2ebNno0t1EvO87LQgfZB9TeSZvRUP4POd9/983t3cBnHNKOehDDvXd1Bp/9j9dvVx9+ +Pn1/vrqiY/R/yldfy38HduiTO5Ke1rAIymIuZhLAJS5lE5QNXsooKCe7mFWgDLWYWZBSm7ALUmwD +hoEC6GKWIZZayDRID5ezDVJoE8aBxRazDlyw5czDV282Yh++erMRAwE5ezkLIUPbkIkQ5N+UjaCc +vwkjIQU3YyWoJ9iImcAe34idQMENGAottgFLgYIbMRUouBFbEXUHGzAW2uRy1kLLbcJc6AGzhL1Q +vc1yBgNi8KcelVGMXsls1VHduLZKftymM7QLsdHgmHvDZWRKV9/dnl7/dL48YEYOJEF4R58GK9SV +MTM4F6Gn8+oIdULjpa8relbJyrUEBUwmvWz494QGK75NX59oYAP2eqrzRA3/MEFry6zL1nIE1cgH +0L1nVIJ2LVVTqtN7qie1VmTNpc4Uea/i6yLvfKym699JmglFcHbwRKao69rJQepO18GTg2E1Jbow +bA0Va1dSlwCYdnzN+NZMQz5N6XX2NtbRVxG70DcTu8A/VZv1VruUD6mfmDQv/bQUnRdlPzsTRJrl +EmoDXELLVngMOGnahs705Qq70EJbO2bTXQvXXQUU6QE8cgvC6OATCp/lqUeonNvCCQ== + + + lbDcg0ErhTAYeA1L60ZYNrwKvgFnV8KHLwQ6jQqjKCOHQygxAaZl2SFCqvS05kFQAsvUuUDPAh5f +mDdhFVSRSZJ7ciB9DHC8BrrQC5YLYGiCB0NPR1qo80jGhNYHOacU1JA5AfmHjpMrKRyUnjT8cUJl +TVOrQrCRw0FBoaY6NlZKnBCmQtk+tkzEYW+K1D9ilx4TcRAnBxyX5cGuI+VHHH2R5oMYyjkqs9f9 +21THoAq20zWT+tJ3RSemWvX95ahsWGWDivOSjZzTsuKfUGVzmGapn+g0Sf1i6BxlC8Zese3Y0X5N +6bziyYTHdU/j7ZGjXKV5OTkoBq8jRKeDVfhKN1PXDKQHgQy6QtQpJt0tpkMqpuPuUKZHnSK97Sew +SHX0s1wk3OmXQjFZkLRfr2KypsV03YspchQ57hRrcKtYg4LFFFGLNehcrMH6Ys3mKNbsoWLNViuG +OzJ2b7Bxu9nPtneTL2TRI1UxJRVFwquMoBRr6E5Gl06SV42AGpzjHg5DlX5etW0dD74oMoskCk8F +7WTNMTdqtdCp1jlMP3QOoyVHv9epbj0ZzVitrggb65oHrD/a+S5/FfuR1ZAa6ttJvch7oy/zPsca +UqdO+hmAD1TJOZStqGd59yLOTF5a52XSwqAXSonwzrZ9T1Pb/WimQ7bdAT6epzXTOZ30NUszWEDb +ZqMp+slYgw2KKf3fDU3jTTKLT4YqsMmE0N41nDWqQkZTSxl9OP8CmizSV2+mS4mOcTzC8k8xQAXA +EaaoJXLc3Bq8U6PxED0hWUywWIWpyXykrZC9LobvpziQtVnkja7BhH4cxXAg022fTU4xnLsiTt7a +12swq1uqDAH7JR30bt041o547eR0c3edSVRVmFon3SGUMiWFmTYGByCot02HAYOUnUisprSRxtM5 +tEJcYKl0zKhhV94Yazr5xvCwU4uqHhiNtQgaV13cCTw2VQdogcoNzkG4qVKX6KmH6RQWDRQ0nuGS +LQJlY0AirbdldFsNFG47Z0xEk+IH3YDYvwIdhBJN+X30r+g7aBA2BWEdSs6awhxMzxqfb1WzRf5J +je74geiMk4P0kpZqBHqRqJQ1A7FjpWCQamr0uqk5OUjd0Qls0C/MKjWuaZrBJFXethrow8UQ6gfV +fFRgc8mUMGEtVWjDB9RO9R9A4erass7rKdIiZs0Va3rVzVLW+W6asjEWa6aim6hsxrrXWsAl2Hj+ +tTkwHhkeDVazHiJlkeYvw90iR942OVn3ON5tgZOHLSQ2OOcDLSRGmBApYujwbKaiF9yUDXSCDhp0 +aI49nKwZ3gpWBkRBBLFGOiPzEURWVD/2H65wsElna5ZoVK++pmhrDlsobINtsfuFITo627jVo7mt +SgF6QwdbVhowmhtJHjNy9JQm6sCGtEZJ94jaqEFjRG/UODKiOFp8RHMAnFAdAW5Cd0iml1IeupGM +aQ9p+5j6CHCK/wSOKRCNBmMaRO3+eOvxCBrToa/erKFE0NdPdj208RNqBF37hB7Ba2hCkfR87GgS +Nd8TqkT/pAldorJ7Qpm4cGt6uY466UE+pk+qYZ5O0zoapUrlMZVS6HSd1lGqDE8zWpWhdEatMuwv +hug/pVj5Zpoc8e3nV5oKnq7+eHt+fv1JSYZCyjIkTIrvIAj3DwwO8od1xcGXzjNBAGM/NclQG5xG +kJfR0CikiF7hLgT16atheYFXrNNCoE+l1dD+gOwEIvlVdQzGrLMsQ3zUJEM1Mq3E97KFjVdnTuHC +uFOtM4abXCiCSzmGjAayWzVaGHykTtvWD3MMEXAWAyNG39StZXgaKQ0tGDH83As2xwwqIXY+NLWm +ijD07ITRsdWYHyf/MD5NPdgAqmjUE4JflZpkqEFiDGQDCE63gK9hmcTf4FKSoaA+z3oOsLSmCqhc +iNkuGnWYdc4mRzNXlfThM4w30n42K+03TQWC0UwGgFD26PHQssMwOca8G8iaAouTMeoYGiqGp1kH +T0xNeOOwaEJ/69arZSbASlQjDDb6KRqEMxMjusRE6DeRJjp0euQDAFo1Vg14HgkHgHnWhZhjqIa3 +KJDTxlic0ND2UZbBdc8px1Bo1LYSX8bSRV88NlHkbcR+FH1HtKdF39U4GiJ4Vdo41xxykY+Zs1L0 +0xKnrsjnLs5v0U9wXIEiWwKuUpEvU1zJolvKuNZFt9gJIYoMIxLWFD3aRMQqesyK2Kc/go0421Qm +ZiQK0dGzck2IiGgTquOw1oYTrpsyJgSIkYHor1tlA+C2snGYcV9x72negW7zyfZUp/zhHi7yTcyN +PviKtCBaxRjfRoJh02pUPmYYMt5pr4Ss+FUkO9GUV+cJhhJhSoQrfZEoW9GRNmCHa5uIL5XV9EKN +cSmVTmgVy+oYneeRYIm4aLyJ2Fm3Mb0Q/G8iDleafqVlhqZIsPP8QiEmGJKpD6aDoA7NDRTrQEMM +kO0bIk1P+XfQG/SXRCr2lxjfpj1Amo6B25jCjAOvyW7VaWb6/EJx6jC3muSHAEx+3XaTb0lZfEru +QFs5V7HpVpEKXRdTNdTYt3luoVo3sgZ6tINv6jb5O1feKdVLU6+Yp7upzSglENitclLqdHMSyY0m +cxF6HgYkuan4TSLa2EjtYEfpPkq7Lh4G/cbUgObG+3z3ah/SKWNCPHaqtKk0dUtHKRzp7JCaaIY8 +YifpzSptAt0WNL5jpRs0A7oVNMA8kAkjaWsaPc/reL63qUwAWpBGGj0kmeNCqWi7SjimpJacu+Kh +j/RYPbkzih1WGTXPCL0RMqKkPChO2yayJUFRugw6bl/SVV7ar5uOKWEHncZ/wWNdx2B0ekMte4yj +9Jxd5lXkNFRxqjzz4LiS5E3nUo/GklPbgsRwpjUZ4eh0HZ2/4/N5eoSPT/kxGzDkFKxi44CZGHMb +U4ZkzLOMmZop35PIc6LOiTgnqjtlr8Yc2JhFU+xzER2tJhcyXnNAkSjQDuwTY9glF4okhSSnDPGZ +FEn5ThIkEq2Y0EDpcCJrkaolspeoXqKMPWFMxDPRzkRcR9Q3Ph6PGew5luQ2qDrD24YeIJUgXc3U +QfDjatdlF7JIjBUtyemhCCbIWkO6DNY1hzYI7Z3YkoWtDC0zB8nfivkrZKbUYgwxEj8Eh30D87Ks +CFx3Svhfyqk4yS5ECWJtPjvNCUAk0WxNflWkHGPHzGfn2pRcMNSaz67q8tm5mM8uHhWGsXaazy6G +/yPovs6SIrRumGOIz8ea0C6l/nPMMWRVgrTMXRViRrsu76DTOECNhGH+KxcT2qX8dcMUQ3g+juns +XP5Fns2ujtns/KpzPDuO6ex0yA1T4MVMXzGfnSYD6zJGxgjTPJtdE7PZ2VVMADlOZtdqgiHDhJea +eqxZpbIxmV0b85qtYlrUGG1RmpQ51aZcY24Vc9l1udNikkjNf8Psap1HlmUmu3ja2CZlDwsx0aOL +wanW13UWecxMdi5msmtjJjsTM9kFE8swLaCmigval9bETHY+jDLZcd4UExlnpc6qw1R2tk9ldzxI +ZVfaLtluVzLPf6qVM5ddveraj0nLug4yl51dZWNgLruw6kfZpbKL8dcNGGymXdOo3zyVXdOOctn5 +US67mF6IK0YkW3UIRQzzuuL1qlvwDJ28CTGNXaXY5cMojV2riKi4FNEuYVKWxc50OeyOhznsyrBK +qM9eNm1MYpfG0eiGqr0GZ5MuaBK7dpXtwBisHTfgIIVdzGBXrdIOTlPZ7/GUWjSRAaawq1JK46qP +H+9ISZZpiJAT5rVjOqgIIYEqUybltqNhPQlLZC5RuUQHExlMpLKnlImaJmK6LrGdphtqNA8A3g9T +RrtmmDK6SZnz6krD87M+NHW2s2InNVuqxgbHcWhKVU3Hw6Fq0lVvurnI8w3FCWTyVo4ufTNehJjl +MmTrVIyXcpQ3OomDGS4UI2QpxsgUyVab4VsxRslijLPFGKmLMdYXo11RTPdNMd5axWjrFeOtWYz3 +bjHc2sV07xcD8tDoqZSlwuzSRSuJgafIcUoXbUiF6hQYDOfWSKWKKR3Tw7rpSV0xpoWDdNGwbByn +dNE9RS1GFLfIiHExJtRFhsmpeJ4uOrWRcLnvyCBddBX68RT5gOKYi2zQnJWin5Y4dUU+d3F+i36C +B+dh4/p1KvKFys/Vqj/4i26xIzr0Z3MxOr5XHUoVPU4NU0W3EVlr56NoaqtYnO7ezBTdxDayRNG6 +K6JWIOtZ40PGtRSJeBf5boo7rsi3nPZpvG2LbN/Gnd1/E/d+x4l1BCLj1sZZosOqIzTFhBplrGFH +svqvElXrOMyO9GVsqCaKrntWNSaKTjnB2QoTRSf8D4okDCF3PV8cE0X7VTEi5kWi5vtMQ/tMQ/tM +Q/tMQ/tMQ3afaWifaWiMpPtMQ/tMQ/tMQ/tMQ9uSaQghksmhd+DSW8HOAga/Ng2yG1z1MAR8qhaJ +AZ+UR2Ay0SgLEa0o0FjKbGr9FwxSYTcEq4ptJryFFBJsiBZ3vfurrZxJ/iCKeXKKMK1u78CNFLNM +L49zhbfcBFj8O1eNmsH4TDNQ60Iaa2Pa5xTQrbcBIDzXdRchWabLhwmprGMkSBnXxlBERkSKNapp +odyuXgo0Yjo1Y2D9Y2SarERyVojB5r5Pe+JTKvsq9gmf8/xEOEtKnl+pj1g4pF+cOvHEtAKt1BWV +PiaiOKODKbZWcXa4SuqjYKKRuwplDLh28ZoCqBII0SDuBFHnpLaMCXL1q/awjXaFZGAIh23Txjjl +0NroB9UaF+mn5waUMWl8EZa1Dl554zpGRhNChytOYfaNzE1Moau7HokZYsWm0gxVsAiWMSuF53VI +Dtsm2uQr+pnIlHj1kIBNT9eNEdpq4ml400SpofHqrkoTTMlLYGrTQ+CpINI10TGCLNUttq/IAafq +1JijBS/J0bFDHoZeX/d9rhhnbvOB1TFsuxt8ndwj0/xA42PihRVxChtq210PCqAdceI5XsZwxlQM +aUglCWdPJoEL2hLWvSQ76H3tegDtqk261Sx9ExMSVORiZBqqcoCGArK0lQBkyLQ4E32NmMYYgLRB +oalSPby1ITUTqFSkAQGAFloxE/Nga8por13LEkZXMcV/DGzXxBZZtuigJl/VFaUvSt7rsVLXCs3y +X6X033qdjFNPTUvfFk3yb6I7GclVHfX3HYCG3+gJEkFIEc30zSDxSPKQEv0TAKIJ3KnKZP0rcbA4 +0rc4upjvn0Qp5eM/Y8J/dVzKMv4bdZVckx/67KAYJE2PSf99k9UwykOtGYfQFZfMjnXQnOhN9MBh +Z0c5rzmiYjJsZs820eapxB7TN5grkhVrE6nRrwIMaVXTLwNyejdVnC7iuZIxJsDQ1VR9vCvjXYG2 +iuJ/COlZCaZzLv9AqTsxquny/+dY111kQlSlgzE1jzGtBdO5jLKix3xP9JJXxXp+CYB6sMX86jH5 +evdD3Sy75OvZPQC1akqziwDi9X5kts4OBp2J6djRYasdzu8CWHVJ5s8OMtYyXcNipw== + + + 2epjInWmVm9Mak5Wxmjm+zqSK9/oIssyRtKtPIKgSxOHZ5MnfJ8iPWJZuhOlw/guY/9ZvBWAkz+8 +FgAobtRlvbsooCxJHs4OepBL5xtygVTwLMAhXupO0NsbDpUjUk1Z6RnC3iZGpuObAnTofjXlpB7K +oVVGf4lpHL6sI8zWGoeP5DnY8cGWJfstHDluBPnh6qBuNMfK+EOBI8FO+vLobGaVR/dWaWoDJ1CX +VdmFcayJ3JgylBl0GUsZRa7lTKXKUJuwldrkJoylltyEtYxi7GLmMoptG7CXKLkRg6kxERuwmBpi +sQmTSYXCRmwmA0OWM5oxgHM5q4kxbshsIr3UcnYToaQbMJxfvdmI5YREvQHTybii5WwnY5SWMp5S +aAPWU0stZT7ZwYXsJ3V1yxhQBFttwIJijTdgQoFRy9lQYO9CRpRZ0TZgRak42oQZJTHYiB0lAdqI +IY0B4stYUiWxS5lSpeibsKV6imzCmGoo3CasqZ7PGzCnmp5sE/ZUm9yEQY3pNZezqJp1YDmTqvzS +cjZVy23CqI4UhW0X+f8dbFWaqTIN/UrNaRqMVGssWmP1zsTAc906JaIdHyddJaktwFkhNBJ9VyYI +Hszqkax+uCXvSOVwMBbNAYlcfurvqDyUTdfoRbKQzTmww6tHvytxjS/2Hd0dHPafalWHAzrehE+X +g9eYeIWqsCe6a4KpHJxrkVJWkBi0X4O02eD42yb0nx2dza7x6P4afSsTL7Qor/Z+Vn3Nykb18pK1 +ZZ6JDVaXNrjl6yvFNlnhBxCcrLbJGOsrpm0oTcZ9C1FTJjzy58gDaYZMvO1yXiKXcLyzNMR44Jau +mDZdsAZup7XqPBsJr1XjCQCam1R4vFpvKKWEohRfozX6K+AYlp7dOkhCSnpbDehtf1nb4ILOjG6T +qlcD8i6/yDAShOUAgIHoEDaw+gxurqM3Yd3wCkr51kQvbzLMFExctIRAzJvM90ZycoOgiSiq1ofM +hyKDbhHrAvzHDkGHkEY6aCeHn3Lzpa+OzubWd3RffZVV38xBpffvvTVIp5H6S9FOUwkvRjxuo6Wo +R+qwHPk0O81i9OMkLUdAFluOgg8QiE5NgAxj0E9c9Qm3AoPJlaWkuqGJRCkpJRjwVCX9mIcjRQWV +QJWYSQOAr5oYz9eCA8YwkZJD/a3ARcuQmJCCzxi5lDGpYTIs6VLK1BDFgp6pIeMTyGq6nj9qYxbt +s/5GyuGFlKFeDdisUK2GmsISugC6WWq1zOpkD6MMKpQZUTGQpjBA9QVjNmqk/E1yq1eRkLk5JpO9 +EXWQRqq2bnWPQj9BQToI80yhKwiKiXgqOILjuYGg6MbfYh8jk1L/LfLKz6336N56Zddo8uFBxQ8p +1CbYl+W4WoB/WmoxBmqxpTiYGluIhcreL8XDWGoZJurMLsXFh8gEqXStKemdoTssqCJ8B6F5c3Vy +nkZUSp30gsAyhrG0kJ/V8dGS+NdyCJgYWAsXXpwGSZfYXy9cJ5MEtV9AA0qT7EyraS+oK2Cqaw0/ +DDG6AlqPoPGNKrqAa2R0BYTWYFaTIW24GWt4t3MfyEzSVV4EwpYDl/3g4OvOdEbM01+NP7Vlq1/0 +33Irzqr16L5aEY/ICRnU+sA+nC6vApcusMrbi5c4NbZwkbXY4mVei+fI2iRb/968TZ8tj8yHX87v +fqtBoZp487sDhEELYaMc64UEt5SEW4Rbd8llTudn57Y1wghlThqkhuWJLpSykYVz0IhG+drWiBcx +MJ+ouqmsG98ByL6T/UgQZpq0ODUShLUKx5ZqlWemQY/tHuOUYBb3im6Zmsd7DWjY3RPi6bcM8oei +hJp7x3jXBLGqwwfH1Gqqao3tocar6p4Z88/bi7svmlENzbANjcizGsfFGTvpIdCeWbaiN743+kVq +NT2rbIF+dV/4UQ1+2MbxZKyYA0fBz2bj7yCx91LI+Lofr3CC+r4bf428D6XvIPWohnrUBrxdFdKP +v4PE3qc60+hSq/34U78SxI1qcKM2jidjxfiLceeuMlDsf4HOgJ1PAyymc1CgO1WGJsV4Hotx8xqc +N5qHYjyMruI0zmI6FV0Hu2/G01mMZ/x4OnJOB/FwMBsJkoZBzGyyySBqDuZCUTNkn/hRHX7Qih7Z +gGQTkSBpBKnSboyx3WwaUtf6T5pRHc2glePJeKNnNIKAaC+BosSL/HTFNI2lVxVNyoyIuzz0JgoK +hZonlAmPZRm92rg6CIaDW8/VyUJhwu21vJy8qwl3+Bgo4kO8waJoYM1ogwbs1GQp5WXtgiYbduXw +kTk2TA8r0E6DaCobH+r4BvhncetUCd7whE82Jurr6nHxNdpJv4m4agR0WenDUAVsQ2HKoSH2UEnR +s7c1NfF4OKXHoD5Z56/gi2SCjj2NpyR7aRqWqnkjA2LwmIERFTc0BpqWyVldFKRLhqBnvTs+yHp/ +cqBjqztINu5sQqRQNlknB/k8phq6nuYDwcDisQs7ecscaoJf5IOvMFGWzr1IWmHj4YQ8Mkj3AdaK +UjVwnZrpCCgZjOqrrtSxpmSOBiPruGkQWWZpAa1wd4Bb9YAaCSOaVV+o0WR6MfiC3gDRrsJEzi2k +MUEJJChiPnY1R3eARlO6pDLH2ViFT3NBc3oHOcuZfUB2HB0geggkNypdJnN0HM9m3GOlEX81tA9O +09nJnteYIoJw34NXoQaHPbLLZCCP/BBtrV5bCQiBhpk2u7pMFwiXGkwQOm55Jg7uv/LC++E6p76m +DpI12MG6fnU1pb6Px3eW4jLuu9Tl6Obmkre6uL+e3t2d317//vr0x8vzP368eHv+QS91sf3VL91H +/35/c3v391/fx3tfBJ9kbT00Y6Wy1d6pJvx3fzs/vfzz6d3txb/lu0El7feXF2fn35+dXl5c//TH +24u3/+/5r7G6aYt/E2b0w93tKbrft7uYi/14eXl+typWR6dnv/zr9Pat5kNceIuMYbx9FRMuW0SV +8ple7KsEik8+hQ7ijIrJaqtVV7AYfl4YH3+BuYo/uXuyj4Y1dOU0BGvFVgY9GXyZOn/cj2P+5SUr ++C+UyFQkkyVUEzdcTVPnylkJhwKKdukB2t1KxLpQQypqP/uVJTpZK2qCY5Y0DHilmTqZVaqbpDRF +q/QuldFX1nWT0yUm1pdFVqbQj7m4/dL27RV5R+Kydou6StcXqAsKMUl/xQzH/M3/+qfYml/Fxiga +VvGL+EHkylcqAcQX6UstCjIfO9zV3zUSe3F80HVnw7guVnUVf3VNKNh2Fm78vEw5UldxyHlnor2W +/b3sfvfDTu+KWGf8iU+7912R+O1Z17/LkUhd+y4Y4z9iPEYn6q5+YlYS9RzRBWPMCJ7ivRmGkSzq +E6I3eAEYTd8KSJkTeOuWj7mw+ZDKpx99ETYTH49TJ+Kz3v1i+g9G1fVNMcAxdeLkYNzFVE2hrGsa +Zzo4kcjC08rMc5rXNeIvcrDwlU13T4PFsymBPD+0MT6+bbuy3XNSpzNYxqRLTvQpfdsXMqvUQsH2 +jAIp68b7C9n4oOk4dp3uBzRlwkWINM/s4G1JQlS5as3dqfE+qDK6ijHznme2h1V8Q01WZbhuwTKd +mqcqreg/cFXMhflQ0crp1ZZHZxu3erS4VdwpVSNNca95W08BHs4WLhsINOFbdeTq903yj0w7R5Mp +z907SUEcd0/2OHf/dN3pdhAvGZ25h2ht63dR9vjYPtKb9cqe1lRxoiLBNB3BfHCLpemLm0y9VGdt +s+Rr03Z9X7LVImk1Kfn5w9stjefk/mELTpkxlJZ/3xPY9cTVroaASETAD/hA32C9isDRy+EwevQ0 +TKIC8dPQOFN2v2BnHr5j4abtCud1Q8GYaGjWk7xHseMPurDA4sHL30Bs4N+IzIX30hrLq4+Z1pXi +ab5rYd1uNDdiRmIYk3nInLLrSsCBxbZtTllmtnE0tw2wekgQmNGRT71Z8h8dr/9xyK0XJl6jaQ61 +D1cHDW+Kpj9z1YQaGz2BDJ2k0zVWg3L3nhDWcdHqUCLPYTwiRKKF7v6hIwKMRxVzD9PnsH8VTF2p +D66Q60o91kcr6KHNaR8r7OKls8NjYmHLRxu0DLNphUDc7KgALy/EAVJ3KRK+yKsNfpRlQx6+Do2t +yNVLvytATJ8yUvj7Gsw8A3d17Yyv5POrDgQFoG+qeHsJb4I2XNpRicRgyzGoL6Ahg9rn6kDvgO4K +6nsoEg01FZMSa0EPidW/4dWtMuD6t6vffS+i7/VPq98cHX1zdvbx6m83d5RhM6yeHJ16IqzpuQZ2 +d33vv+l7v6ZcIsJrevq7/Hn1u7/c3P3t/Ozm9q1g/n+yI2o5rHjPCHSPPhh4v9iJXH/8zZ/+GPfK +39/d3F7pqzhK2dxvb348f/PNn9o30onv7369PH/TN61fLZy17PAIDxm6Pp+O48mVEt/e/GuDCxq+ +THWEYwZcF3zVUmVnq9Lzah8Db6Q6TImyZwZOu0opcPlQqKG5qckzB/WY2Osm9rqJrdNNNHVkkWOS +iIH09dmZZktGLueLKyr90q8hz1yps2DkmVn287PM4E6cgSNRYpp9gzPvIabZNUimaO7haBEGaMKY +58LWuK9IFdTZY8g2z2rlaHYrEMBpBPh8jPMadrlWr5OYW5lGpJiwMsFOcpiBUTNeAazBFutAXUk2 +EONII6iLpcA13GWdrvAd9uMx/ruRKRICvFL22zBn4gPsNz3nHH0erJLwnosNAW1zvhFiW42Yb/i9 +44R4uGjjeP/22cZtHi1uE8eUs5+f6XYprRES38C2fZWBZKl1eTJQGUG+u2KsA0Gs0gtlOlC+/KVr +0mX1Ik65/DMYeeOtYT0MjT4Aq6awOIST6ajS6db3mrcbV3qHsO3KN/px3p+uHfgmDkH56Jp48b18 +ZOzgq2ympqCuyTWgh6WNiCblp0gbk65dDYBdTxiHO5mlAbQbmwbN2TFwzVwxbHM8W2s69WmiTAEa +YarWBw2Dld5BhKzrJ5FmFq1Kds43r0Sa+cPN7d7Curew7qWYvRSzt7DuLax7C+vewrq3sO4trHsL +625aWCf21KuDqfG0WGNiXWOIfVYbq9GbOe61sYLrtY+VdYgUK6tFJtZJw0fLG34qC2uxxsSa21OL +NfbWe22sxToj69Q0mZsup0XWw57ezLqu88wIlZlZ1wxmXcHPo52oAu6vNHtb65NqJ07O393tba17 +W+teS7HXUuxtrXtb6xPaWnG5D7MYXR2UegWgZhwUecTQdJRgydp6QlYsRviOQcnYmhVcA+qrz9r/ +3MZVg8A7hMK2Vgl0b6xs0WZQOyeTCw1tqwhgw43dDxZtaF4aGVeXtHm0uE0cS94L0/yZ2e2SdzpC +o0STp7PEhQRLprOTDJZMmYBVExjuOWzcWlAyeGYFc1B5LygZ2zJQ6qxiEYNwy0Ev+w/SzYOpr7Tn +lS3JZNxiZd6n9D4D9R1AbtrGrYMM5qpaM3/j9tfDHhQrPodUMe0cpYrpKHpgP9is+A== + + + WmA/DrWwdrObt5t/tG6qNhVVikQLkNasFqwPsEM9gYiyoYTyauynf7v46ee9iLIXUfYiyl5E2Yso +exHlKUUUvTw0yRExRMZWubTRgTKZJBVcB+olEPp7OhVA0utcPhk2/oxCStAB3SekIL1O5R4p2lhN +YzJbSpk0OvYAfbzRp5JS6F4Z1y4KKTTxeJvWjq9zqUAhPZeaIL18Qd+9EQRLXvl1oEygSQWHoPI+ +UM/ZTobR2SlSjblwEkF5cXOYcrBMYIORVpOxE9Jz3izlfJq9YeNrQU8umEwGnKLKxkPOoLkQMh12 +D8tFjnzoWatD0WUy9/cKJV+8NPCP93tRYC8K7EWBvSiwFwX2osDTiQKJDSe3X/sUGEYQMhbbPm4L +vng9SKM6vF6c7UsbVjEKzOSfJUFhDSQ2eDLtw1MGhfH2ngGPLQNT7hyJ1dfEhIVHSjZI/Nk8EBP2 +WJPTkLBHmsTxZAcp6z+PONAF6miajE4gaHCICEAXMHFvPSRx5+sg1RjCyL+47CoOrAN15TJQqrxI +vGgGSgFoGWg6mk4uGLxKwWApIilru29oCupimbr5mEK6Yqw7r2bag3uADwoIgnneCNvzSQLCeJBX +A2AWsjUdaAbrhhZDuwaQtSOL0WLDKV/Tn0/xsio0nwXuY2ViVyN9pcN28xQWjEXL8Zpklrs7GYiQ +qNV3t6fXP51vFAIG6y9u9YCPdDyIGmGHkAk/gYpQHQbr7QpJdD0uxEqAEulS00PRvU4VFF0NqZUO +cnxAUJOBTg5YzvaQSc15u+NOxcKpbKq+b3Ay1HvPOxNq5XagMas7bqesqgcPvEI4jdrgulHTVHJk +8FDgO9ySVIZGLx0SjsQcBlNWI74HafP18sCHS8PjGenTR7EUC9s+2qRtMEbynx8fgbYpfeCp1toS +h6dpvPdJrebwA9TH68UFIpTpXX44FJmHqEMFl7ghWU3L+1YSSJbbRVzwvHo3AUpZ2vQ7vUulU+EO +GeJzjgyu44dYqupBxbjaIm+zmPSoq6DrdIb3XcuTwXYplLINkXjCfN9k3Qy8BDHBCoQisidBUJbp +ABJEOxof8Jb3TKUaugqynTHqZd/uuNC41rzJSYcmfZ4M9ng6/vvEy96leNRtHqGTwU2Gn/dUCvSP +J/ljP5nTCZ8sy3HenWwAX71ZMyoBjmucNDrs47CL4wGNRzxeu+OsG3kvJvN3LzAXgyu3XsZPJ09d +8+ooZI0vka9c9rJHSgU1TMS36eXJ5PN7iXJrowQaXOtXXdiCl6rXxLYxq3tjKl5LY3ARUpPz9GUb +Dh0CfYSpx+1UAxlU1gX5JjQa6sGyodKru4UcLm7waJMGy3gp5Ij+fqJ6TNg03mruYpJ8WTJ3GGOL +TtLb9PJk8nkiYHWt8OqQWfKvEiA+CwmpslqHH68BPH1MwqTDsk+yLnYfdF2aFPkCQhEqv36/f64L +j5SLtZ/IxQo74Qwu20kMbOUCnkDO+SYc4lY71wOUd40PRfc6lS1QOFWLBzmgsidlVtOHk2ryRsY9 +yHqXdft4MIhHWVOhgbxpPLKmThiw+uGoO9zygbuaTSP8Sm3DkMOrYUmtNQILt20OY3x9I0DesfVw +4QDyNInFW9by0SYtC7E7bJrPzZZ2613RuAP2rgkuPqPtuOZ6rW8CRAbI6prru1SUJbt1rtTsMniO +fGj3cTGuqsjbKSa9KIa9LIaDOB4NquM9e9RWO9YQELlOvWCjZq+a2G57aAwvLk8Q7VZ8wFteWpqK +a+ke0wd9im0Nvh3XlDcz6cSwk8MxHB+Mx/QYd5n3qmMt+0HkPeNdsXnXwEh2jyf5Yz9joykddzfr +QuqxnE9TyKCWSSvDTg37NB7BYHyjNeqb7louZkAGnGOV3RiZ7cF7f+i/DKPsho27vRtmqgWISYsi +SBAnHLauzUDCn/F2LcRUUncWar2oiKG0vo07FXfo4MZN8r3d9oI1BSGx3RZjvzzvjB9su0oFnHgP +uF5e3/dOn48PBjsRoGynJ1AxqbdY13ox6WMxGUYxHWrB6cDdnmk6CsyYL7N5nc40EmesuxJyzZJE +HBkuigA3WBZKORssjJZbuDSD0aTF0f2+yfKoELnBAqHgZks02mh15NDasWzWHupVVFYD2oVFx4kd +TAepGs1AXEPHJFWnZzAy6XfBlzIfqXChpZtVqr8DnB00Qgm8yUDC4ra4h7urJQHIK8XfqflUOnVv +PIDjyZDmp4CCMbNF70uEfusgZS1Ca9dwUlCb4VZHTQUVH4pgSn+IXALC2ZV633jvuvBZJLNuQo1m +QbnChNJ81YFkznycUNfA6ScBeETG3+ldKp0Kd9MXn4+BEbjuroOIcOIUI7SG9Iza0++u6VS4GNdf +9A1EYTFDlTiyGle2M4tdBAnCper1nrgEYNtN6pe+S6VT4QwxYsMy9gBnvwQJNs2N1pCeOW+2m1R9 +mQoX4/qLvoEJ6H4eY+AP0Td8lT2NW9ZK7Whgejf9cPB2NZ6cfuLw9WReJzM/GQmKTaZgMkn9QMa3 +6FZNd/ZH9wmRpPUGReFDSxwPRG0fcNtjR0xPus/wlW1zSFfw8yS6gNWKEkK8W9iVnRJclTBCikxT +qwKngdAwUhnJGUFN1sOFwXNZ00SV0cIWjzZpsWSOkM+e2oK2PV0G3CpOlqzS+5+j1oiv09uTaYFM +b9TEF62rK6uao0ZLK+QEuNHXPS6wFvQs+qO+0aaMLFDsaI7E/afsXukHsK74F6BN6hJbtJ9XjfSH +03/e3F7cRe3RfyQZ43Pem43LzHFtc+HgV1XB3CB8Yc3bRBMIck8NugkADGrIXtZC+eHAClatOmWG +Gqom2+oVn7iT1Hh15myD45Xams3K6vPxQYK0yGGjjh3IcAQvS9lUuA1UysoLXh5NC52iH25bTX1T +t1ML1rf7iLU0TVcLr5lNjeg1s10vTvSOWsPrwGNPCw6GkDgY3suLZrMRUzSteelonJaCM+eqfuYK +Ti8Ok6y/TbqLt/tK2hVeDQ6WvF23ysaJDD81VAS4Lzpe75m+QkVIHdMv1Hgxjzufy/hCRpZWGQl7 +vO1BAbaUULFF7mnHduFXZ5B475ik3eiEyLThA2dD+oCOo+EwCGqGVIfessKrSd14QhLkWP0DQ9nm +X9V0gyKA18MKQG82dtJqq8kM5TQ3Rv2Ry1DTCxLJSwHB9HE+9bCvg+Y/xCMtynWl7qSHBlZhmW1v +ZVQqEzUyqSscYZXJEQ7sMbvLT3z8BFeCe01yxFrANuNOW0VrbUmvxo2oXwcqQtlV03WVHqDQ/PWj +4Yi9yYfMWfH9rGDemiabt8kyH09X/n731if2GKkwB7znVf66lcdVwLzu1XqrIsh2Xff6P84v6TZP +svvtE5Be7Gzb6DVJNX2lDCSO0NKPMyAf76FesgyKVfL/UJNkwGJcohhXihuDK0UbICxuvE6A7jmV +6YukalOtqU32g93IIKOPJ7WNmht3Z9rjd3DjLrHf098rzauKXH8g8rIxhe2iyEnU0U5noGL8eTGu +Ub6nc4l8H3C6kWxEQNFB+DVpXF8sVV10daeGC3amYG8As1yYZjUpkWrLqp20Pe7ddADcxwh6qJ1S +SO9cHW+7KjkJstXgseRTPv0gtID6G54bGYT3Q8dMjAmG690DMkijHjlGSTtb+j5SdVTXOh32sPRO +PT9E/LL8oWZ/WeG6MfpKmPHAy+MdrBzHvNLekeBBhSScs/pDqsANhwHOj4NKombWOPh0w6cn5ZFD +ygpHF/jCIoe1VRO1LoTpviJHB2bf4nCzPeTswPBsMj1I5LxWk5QiBK+BdRhrqOeYDtfBW9E1hJC3 +kGkrGfHRxgXvAAHHg0zM2UEHkpWp6hqxa3GcQhOpxTNgniwdBiBEOL0hvCnbFlfXi2BaB96ajnMy +8IbwUurhdJjSVLyQHXd3y/bjFeGBoSdQAXlrePG4857twHe+0XbgTn8Ih0tOosgvFQrhbOG5A8KM +e9Dl06p/kr1eYSzHBxkoBN+oX67MTTMEBErqh6oelI3AiZXFp0Fa+lVbhPeFiIY+LjiuMsdyyQSR +VzLMaEq/ONzODhR2UYTvpc1D39iaWqCm1QvO5eQGQCYQbseYhjZ4tAMcdSVHWTdwdiCK1kRRTKjr +ASFOOgspCC3UwnjB5bTSVKyulZN+shmxScEXBHJK6GltjbrFgzWwHQjcVFO1TBLoYAPtAViYMugS +RZDMAtCpq0T2pVdmJbUUIUJXBC3hAp4gHuG0INpaR/fYtdJBYke6ClJPJ8M5oy79We6Ip315C1mF +m6vzyCqYJ2EVnI/afUEBEwLUSnJaCtOtGZRb2QuMgokgV6rJ6wQoey8IHG1Z2+QsTqlefSYd2WM2 +qqhpy0CGGaaDFb9oFVAdVjZw74nM3zY5jDUxOAeAdg1ASwEg9SL+pa95MuCTlOm81LK2ZmVXcgCq +oSECTjpA03czgOWET9kU1BUrWHMIayDwImf+Ir2qRScKDHtDm0rqUvbZqJcPq20+3yaR47UWFr+S +IxkHh8ce13zJranbLdw4393+uCpWR5cfuX1M0qKauduCshI5T9Ljqw7i7KGSyqAX99DhmQS5yEAF +P6/6zztAqhGnaQIJSurRHyuwiDAyiB1Kv84Oxu+6HsbC4x6fzTDsOPfb+AECIYyHuwj+RXAqmRWH +A7dyKzm/EdQDfQl0v2zLKr0Ej+qFHvGiD0qjuO2jkd46kcV6884marqZffr8+rqoxTQQY4fTaB+b +xqmeXAY/dPokLg7wUMhUa11gfI9wd0j6lkAijB2S00G65hZYkgDCtLVkXYFKHUwon9GAWVYDkQxn +RfpBRDIlVTkEsGTdl+yfu9oTKPUg1ZC62Pf/OBvLLMsi9JsaduM9zb/CNju9ZEa47GZN/IDQbyP/ +KO6lB14yI6QJXr4myCEgTNM0KjrYxtFy6EuwrNJsFbBlek8KWhUNKJycqbLL6lbPUt6fAFmxgdXS +xWeZlypwqqRuqJl6QJy744MEIhtUNatUA4SwJs0dfx3z4oy2bkIHKli66kt3gKyFDBa70dWj3Uzd +Tyo7PNcR1Szvk8gJFvBAprDKIVlbEQYFkV4cEOtw4JU5nvTrWElW1b9LJCoVTs/5dHWg2ItUR6GB +Ja5WbSEVhZtFU09avcqAqWvjrvfD0mDr0ain8zKZPJabTnK+BjouRl5no55MyWQAY+Nh01+qAHmm +7ikNhDlLg7ajwRLu5j1M2G5oZumty6CWTusML2tIHQmgh52Q/ewbCx9om9WSAKmps4MOBMGz8Sm2 +GtUgdNtQ8ExtdRDKJ9qh/quu031Vk7HNOQKNf4h4QxyLpEZ/FrzdoHW2Vu9yvaWlIzSY7pBNt4F0 +ycgukW5Ln675jjCvwhbYZmNd9E/RyPPDZKgkQPVmZIOzjxqRSkOV1dMBYmNnBxmsu+mjq6hNKo3U +WgSoJip2qfuo63VX0Xhsnz7dcs4I9a90wtODJkKtRQgOFhrrUq+njDOuIbUw8wvbUw== + + + MX6iA7UIw2rUWpxSBKnqDFomF6oOoDMFcSr7JsbB97VEQGrp7KADiZReRZ9drQXJbUuXtZQAOrns +Tf9N7G9fy2hMnz6zUIcg8ENzicQH5BKBugNxbiXUPFWOyy1ciUq9mEeDrDsINq0V5qIhQVKMo6bN +x/j5DgBdmIvuYxEk+7QNRpWgsZ4MFBujlqqDeWo/Vl1VIvxUrQt9cwkA7WjsUgL1w4i1jMf16ZNb +iYyJq+04uekBLAmYCF7KJEw5msoJRcb/yY5uNA6upHfUVQ9pY8yIkHoqXAuGzAUgmCqcOgBmGpPh +epCBeA05O9XSAWJDXJ0OAoXhqqsE6RJ4NVJqKAGg+YmdSaB8AKxlPKLPQInh3+cTLY4PhSY6g6jP +i6+cyyWOQhDOW5A6nDG1hs93MMRo0q8QSu22pLrYKA8d6PPleohgYytUl5qw7isDdRV4wa6mDpLa +w2ZPMCFhzgYuRqwJql9Smq69BDk76HvVfdX1vKtpMr7PQYFxhtaJAusDKLBTPzjeGuPB/N976DkR +UGtDBYspWwo1CQQ9vlU7Zl211FHy5ID5ESG66RnbWHX4CaIunL6vogN0zZwd9DCDW47cKtWi+hb1 +N2BDHeDsIPWlA3X9j5VMxvMZkFnm0MRjLv5GKpUgB6rDMWcsPMxzYkyhcUQ0kLHMr6gO8DRkyYkZ +2pp6ZWrSLWwKbQwKxkkjZEjZT0wrJIVj3NlJP8zOoG6b5B8PxyahpAJoEolgBPkZXDKU44AJuGGG +NU2M00bDh4U+GWskBXUfyFLU4FUNU454dYqDJQb3DPHWWxHmXagbaLYYJEiDpGfGFV42RVbg0KkS +P3pr0XzY8AMqjo95+LtWjYVpWzP0jPAAC8lw3s7uDR2q1B2ubOnuhVlkLo+yhTFOZs05DbCs0x8A +6YYJYwRcP2uLlD9NDC5i1p06pt9pQiTDweo+YNCrHHgVhDndZ66tNLLIC2rITMK6Ir9ENKzWlG3q +gKv/HBy9G39Y1q2mf8REJO8LX7btvGbhOoe1CpVaJURCt2tL1kAg5zXYvQ1KGeb1mGoi+i8LgRGu +P/j2sRRCj/l1LVqWp7leuWlkDfxMP7mkYVqnVnoQAR/WM9GM1dMKoXoOZrMCbowttia9dFof1NCv +AczUmVdU1JfYXDW8TqjsEKKLU/1YKqo1PgkgnAJ1cstxsDziuVUzIJ7hMXMGsmTUdUkkKNhVefm2 +8sq0DMGgXZMJxE0SJLA4eZhaQI44ssgVHMGx8UP0qEJvST6EEkSGMSXrtNjxdWRPMESSj6AsTI3S +ACCpw/EBqQO4QhudYhJDBI2LFJnO3Gb0AiGIdUuUbNuafyknlLBrCgFtalwEAcWTkQOrQqkQyQbs +aWTAalJo2g9renkhL4dtbWQ1W0NW0+Mr2WWgGyJrVxDkaJIJ8o3sM7+mvGngM9M2UGgYEErIdUfK +vTRqvJFphrFkXtugABWyJdGkCQKB9Chrisqu5+FLWbr1XonH3G5HWbxWnR+9SD+NfGy0Sk/jLQoM +buzLU5Em12bIdmpsNE63qq2uNMkSDmbXqNjF45yej4aOcppABW4gpDP0ljsMraFTAhMu8StN9OiY +m0EvmOSddoUj/0u1hIU2g3bCRkVJU6sLI1wwA3ROcPym6CPkJ4RGTeuCnPQspa89OgjuGYZ0XvKK +7SV8T5K5z8ASBSccN/gdyl7IHKisC30J8Izeg7UHLhzD7CinraYUpA7Bakmwm02lDgSDmduYiFSw +ugEtXcODzRin7oGydWTgJbTmGKs0dkiRQAVUfxh1azB60l2hdCFolg2jigCRKgJ1LAapFWq668uR +bmFcpk7QOzixtmtKW5m3Ut12jJOjVqTyhv7zMH65OkmtZTuv4SO6q5Xwm5fvK683k4zLIazBtwiq +KD3kIBab119htUuYWMm0tAxV+2S6sXhhnuRqEpGVSlO+NNUY5nBXwzhVZfBkYa6+OrTKkDbBUU6p +ZQ9SBKMqF/vJtqo9oy5Zt5ip1EFMXarAsbLiSqUcALzXQi1Ebsp2lv46zOIUeHOQGtXgL0evLxq0 +a/2EToOqa41Kz6BZDguyFEF5WNWGSGt0EoNUyAuwzkjW6FEgCAf9s+FXhh6Inp69Wk4tOT4GoCs5 +pIhCzzNVm3TmlUbv8JzO46ZyS3BkifU28Pg3QgVPPQMwwashDzxPfDIhFZgCp0oLwWQSauPpUC/T +blRN60GGZbVkK7fCTrSaJUaIQc3MOzJXAYKo3ik2Ko2bgA7pwRdCiV9Oc1WCGXUNY6+sDGhd0XUN +H+nZZF3dqLeWcXZtUdmZKc8M+qa8y7wu6y24bQUaxGkx5pPFl6Wr8zTMh6vhTfiyZAReYuqRaNWF +h45JFRkLHPmygzX0FLESer5z18PLHWKMmh9JXuQ05i25QShHxWe1bkV9C+RiuDkJvaihsKU+ynvV +U1EnopEZjr58re5Up2/gt+lLuoiCOTHRgMVYZwdvyVK3bNQ4N4fR4Q+wSAQbxSFA2sroV05jREqE +mdD7V2nTMZ1iVcUlZ2tZyyigKoLnP6hIXXkqY4YTtzGz4enzeKix6IewywgxQiZwWwu/rYo0mQRp +1/nQKzlaJNcSgmHh7QWvAjirgUpXTjUG4KOsj0I/DsgfaIz2OKchivk2RuFOCtcOHB90pVUN00Xj +66TjaEGVHGR93FMxp9UjNRXZylDcs6Ux6woKAYDQq2o5KtiO5nZXKIRgKZSINAGUbRk+ndNYtipP +QSDgzVw27oX5DNB3JgQoTHZBDLxum+ihXlVRa1k1MXarUl9dkR5bdaawcJ2iz3ilzrGA4ej3yHBj +9SNqoOHGzK/1k7qNKocW5zU2I1Mamib6ssK01ZIaIDafOmn5NDpgM9wmaM445WFKvbEOBIIO7nLY +kKpZOMi30RddpGy4zYJgtDR8IzUCczCrE7KlmsYRAAPjMcwWJbkMuguW0dgLj29QMlKd8SRuzFcw +V2CpPp7401JJ34IS+VB7JHEDlx9ibFu06timBItex80cc617zdmkwQVB5O5DamGC8G5SpVXZBHpi +6AhaJ1BX1veUdjQRwVmxqZrmkCFXRzQW1LAvqm6D3Pu8to9wR6ZrmjJE5YZ39xUFq9rSU0BQRt6r +jDKz3yguBandiHzsJ3MXC9foCYgH00gIZ/XSMspAs9FGHh7yB7Y4FNg4XWWf0KPY+biPBUuEJ1CD +Hk5wSwclhoho3CA3Iq7loPggz1COIrBGbarCCCBqAheKqBqADD7UDtKORpH4GC0BORF/W2i9HIOZ +ePDT+uIq8C8N06vD/atmzGZrQA7kDKRhw9D+AXrjYjyUEMAaFMSVmmi8PKRGkw57lm7kGi/D+Fmq +d4WagWjRmAIFGNSxQu/G87Uxh9FWJcMbK+a7lDYbDbExYNessDPC1yNioA02KqVVnwGrYMlQAy9S +1Ar3fVqvjm+O5J+8OUMwmevM1bUSDUQsQqW5guefEF858qeFhSOALQ5SlhXarwtzxHn0MIPAVObl ++J3XLPa8B8eBmBPTBGqVpwVriIgpAQHUS0dzu0v5J2CepCwInG8+nctYvjJPotBoEZo/N3H8ExGL +zn08v7+kpWtODHWgY1cHgocVbdltjBOTg435NNJPVay30YOCoIKlfVe6f04NqMwQYU1SD8RqEAAB +w1fZ/2T4koa6RUjf51h8Moh793GjxuyYPFGkKma9CHFCRDqSOZVDLYpgwlBbBALaSVZFCliwMXk5 +EOlBnt0bUSHxIbYOTlr2uMsYYmh8tA6OLP6B0o3QJt8EjagfplVc2PTR0qZZmtKZ2k7i9vvHUB82 +dU2dIlIGnIFK8EbdAJn0mqAl6MQroRcj1MYZOmbh1xN5/mf5N9zT5N/Q8JQ+g2v5RAEqyI4xClBR +0CcEqODgvy9AJXu3D1DZ2QCVfWxKynr3bLEpn5j4bh+isg9R2aUQldo+GKICV59RhApAjwSomGcM +UDFzAlTo1jSIT8kH9pnCU8p4Q2h66EJUzPwQFZtFjVzlsDxExUxCVKrVOETFlp8pREUrGoSoVKtJ +iIqZhKjYQUXjsX2mEBUbpzw9dCEqnxqj0oxjVJpJjArDrgcxKiLADmNUbDOJURHQIEYFtQxjVJpp +jErzAjEqNrpFp4cuRqX6nEEq6hU9iFH5bBEqw/gUtrT74SkqVubhKYTk4SlMB7Mt4SnsTB6ekgbQ +hafkI/pM4Skxg0iRHrrwlOpZwlM45mF4SjsJT2nXhKe04/AUnb1tDU9pTaK++pDCU2rzGcNTkG99 +W8JTmPv9VYSnEGUeDk9pZoSn2BnhKZFr6MJTzCg8pW4/U4AKkkZ9aoBKHfSg39IIlUZjNnhpx4MR +KlUX72HXlE0RKs3DESphXrMPRagMSj4YofJwj/cRKi8dodIoo7YbESpSZnmASuMeDVABr7IPUNkH +qOwDVDYLUJGpGQaoQMuZB6iUbT0NUCk3DFCBd9UgQMUsD1BpRwEq7SRApQ0PB6iUkwAVu+UBKk0X +oBJizAYvB4Wnvm6mxTEqg/IpSiWsjVIJSVatzdzGU5yKSXEqei/rtChDVcL8UJVRcQarNClW5TN4 +kO5jVe6PVcHu+CyxKj5eKdjFqkSdXh+r4jaJVSHfMIpVseUkVqWZxKq4NbEq7SRWJcyKVTGPx6oM +5vEFYlVsVHgYTde7PmTEhhQyEvJYFZaJgR/3h6rAnqehKjYPValiqErZzGy3D1WpY6iKXR9eg1AV +3IWyJlTlkR7HSJV6H6nyjJEqpRnGqphHY1X8KFbFj2JVqkmsih3FqtSPx6rw4pSnCVVpHo9USRzX +tkSqGA1U8SlQxU9CRkybQkZMOwhU6QI/pkVjmIowVjFMJVIIhqkI+dcwlTUF17XZh6m4GKbi1xVk +mEoZUphK0wzCVB7o7DhIBQfVPkjlcwapNO0TBqlAfTkMUqGf4qNBKmYSpFLNCVJpwwsFqQwmcRuC +VEwXruHM7CAV36wvvTBI5dG27w9SmRSdFaRyX7/3QSrPGqQCReIoSAXOJsMgFfN4kEo5ClKp2uVB +Krhu5KmDVPziIBU/CFLJ5+sFglRELmxikEqMFqlS4EZ4NEZF1jVGfZRmWjjFqMjWizEqteliVMo2 +xqj4ea12ISomhqisK8YAlbA2PuXhrqb4lGYfn7Jt8Snqx3NffEr29lPiU5qH4lOyl/v4lF2OT7kP +lVJ8ykJkuj8+5T50ivEpCxFqH5+yNj7lb99/PwhL+byXDukdqQgkgDM7Xcp6kD9MqOG8Zxxsy1WF +8h4e/glwxms2ca9f/0kzrKN7js2ohYYgXi3ItBlaB5ofNJMA8c5CdKX7JvW1q2Q8Hmyv9Vj1w59P +/vGnbwWjfnN2cXsmC2zf/Hb1NS/AKbHq8jJb6BCzEFB6MmrQgo+Mpgog6AQgIRyBnI5wPI1arRxM +RrRZ0nWlrfXaxxY+SNHDE8PEBYJl1OBUJUxEwk3RMR8NlIaHUF0HNYtFUIEQHmQNOA== + + + od+Mocc0fWEqXiuIG1YFXrmAx+EQjieDgpc8l6V22UCpz27yr+C3Cm4FvhGhVFHS8+povAmN6qMi +BHfkhSZ2WmEJTU4ObLqNt8HtgWy1MRV9tVvNGDnqzvGkgyfPcTUZFsetvMElvoZ/6ScEcKUubdt1 +6dL356e3Zz/rndIaSfTZKQeU7AiDhnyBlE9XBAUowKl0paIDRlY4YZlo94C+zVvGq3NvA/2hFpOf +Fa4sk2P5kjtC5B66OLe+VG8M+v6IMFXVlQLgmrWC6wDuUKDjv2nQOL+VRbmEVOadr0hBmtpQWpKB +l9SksE1ePYZrL+EW30S6ZPVaBopBcnZdMhaBEhAuWINghpt9y/jMjIqwz4BCtofceGfT2bkklk6i +T9r741A+xv+wdJTGZyweokYmy6LAxQuDc3+yNABusDhSbLo8AtxkgaTYdIkAXLxIa2YLNeHA+Acn +nivy1Zt+TZauBVRslpreALs21wLejNAAOJQpEZqEL6FvK2kq8DY0CoT3JDhSiNdNiB+OqrwX+I7k +JXX8H/mlNCEKK09y2XwLGdsQoWrYwGi5VU/7BDJeNaIAWGAhlCUtjwFoPBrcPGrDoSWHCjOnwyTw +4ljDE54iLG5ph6KWSsHK6MnALF04g6DDxS23MAjDHQgun+gaFS4uuYDCq6yq6w7ikcTUchmEvw+8 +GLPmhZ1exEHVkDrNUpcuq+U1uYaJMU3rgkZAeTqo8BbxhqFwMhruEWBlWyJGTIQDVRjLpCDv5Xje +UgBegpOTku+uDhDBR+VsAgn2VN7HzPkicnHbNKq0xn2mQe9yxeww56jw3hqnU/O+UL3+UXMaws6s +eekxV1rO6d2rcN1tGRkpu8nX2N560S+8deDAIWKTgxbk+AA+Oxrw4eAiBw6EqucmOqSnhUjPvPac +vxIE1jXo49Wb3DB0udTLcC19co5hdlP/wgZRPjUTxMRrcIwqrWX/RJfl6rCqSxay9NWjak1jVNUF +ERorj1y0vA9T718ngeTt6vGuE4Aap9drliYoy+poXhQk9M72SzJetePJOj58XyScQ2VJjG1najSe ++573phXmzDc4Axrc894CWeCAgMtyt5Afuju9XRUrEfl+/W1kiOIdrjPJWgnUkG2tEhKcpHh48i7p +k4O454M6gZYEwcRoK97yKyJAFVn0kv5iwFlvSKlLysB1W+Nhzfs11Uwbm3So7+6cAGvEV8u2NjVO +bShLPdzpoMGpqxbar7HWy+JaYnUaLuJv6CURiSycOe2YZT0ID4vB1bI/aUtw0FJCpexKh4gWKEmE +sEKBWMXLnythBBoQShEKRYSPsdUQjqDvvjqAX3+r4aCOGu0TATUVfQT726mbyIMAVOr0WV6XRaNd +3cIKzxl1uD0KvhmW5RigBLMxjBy8ThZef4ZhdnDq8UoGVNcOH9DAm2N9TU031gOiGBcCUaZNpVfw +Tt4Xk0qKaUPFtDfFtMvFmoEVa8ZfrJmmYs1sZrN90keDwy8CkQlXqNsbRsQ09J9he5qIV87OmtUa +DMMxjPmE+yalAbW8lLik87RVojp+OSg7rHdNy1nXRg+zI7815Hswxq/erGlKaOSgN0K38q7K43go +qLUfqXLW4y+KUSXFuJF18z3o7snBMLTbN5HRA6GTU1+QQwgJgrDbmEVCth1UtDVdWxKmMWymjczC +CaQojcfBrfGw7mAc1tNv0WnIHw09TYj2SJi5jqnkZhwI9RrWcdUMnUsKJKIPjMqvGeLuO6f9kwM4 +8YEMFfSyL3UPQYtA0+cJ5LxaY5L7DxDgRlVMXw2C7TTks2+MekxcUZX1idFLCDmQBWEk0sl0pk4e +UHZjyMJo8W7Coqnh9qVOx3AqnNBNhCY3IOYejBrYP4/EJTXjNUNTRS0xIk8FC8DmKoP8A6JphWFh +9mP4rSFiZV3ROqhCJdgmGoGOzjZu9Whuq7AqNWrHqqHXGqq17+NF0klfrs5urt7ffLx+u/rw8+n7 +89XVzdv8mH9YLb4Gr1XRPcJsBY5wmyLoJtitmvcRfoNYTDBcxMcJjn/1Zg2Wcyv3eE6ReYLpAp3i +OknDBNuj3n6E7zoNI4xfM4sn9+vjFyxdph43z8OZPjED2eeJ+vip7GN7P//oHuIf6c+7hn+sIv84 +ev8o/+g6/rHdmIE0ajJtIQiCqTONNYEMpJe9tCY/D9VMPiVviA8xEr41SAvVOoiieX6ez5SdZ8BB +Wrq4DDlISw+jAQdpI7e0nIN05NnggHUvB+k/BwfpZ3GQeW+WcJCj8RdrpqlYM5vzOMi2XchBuoc4 +SLeAgxy2vJSDfIhhHNY8j2F0jzKMbhOGcdyVBxjGuhwzjNhIGzGMiGR5Koaxbs3DDKPa49ummcU4 +DqtbxjjaCeOYz9hnZhzhqqssXLuUccS+JAvnZ/GNpucbN2j0aGajL842DrF7Mdu4HMeXso1D1LyH +bVyL7Q+yj+Nql7OPdg37OMT852QflzNzF2e/nIOf+9v5202YOdjTGvUghxUayTsVUsS/CZyey2gT +5Dfdy+lX6dfZwfjduHBWcfwJP/MAeI0wNJgygBPOaBi8IEFZBnhrCo9X1iW/DAh1OkFyH+MdM5gE +rzq3SniEron447gf+Sym0BiSOdt6BNKAdykrWJVKujaAGkzoXA2sSpdLp4eC3CCRDcm1NfnJRLVY +V5VQGOgxZdid35Uz+Q9nRcZpOb4QNEyK2sWUuBFWUc3cWJV1SAD9f5Gg+liq36vOO1MFIP9LCTOo +hugxNYJjWq7W0ARg6BthuEQIxMLEmxoHNNMdlBX5WsTjpCb0ryZ7zNqO/Rp1s6SxZtjXYvJNkers +8zvaiMgpjaT+lwO0aqZ5rxk4lF7ynYOZqKQcTQdjeP4Z2PMc/CV4S6DeGYpnx6yMgDSaQ4cQw5h8 +q89GnxvXPXKqmSW2Zt4okCLOmfFAdDodO6agYoB27HE+Cv5lOJ9d6ZiP49g3URA6G8+LhydNTcwP +TNsZrclLJg6ZbhdO3VdvppN3L+zBKUV3H57USXbJNuMo93RzFt1EFKWyETynkReMgcUlZVtj1thj +fNBEsSSb6aEgXyVk0SlvVjfKm43S3XpX0uTfirTd8IcJFTNpCSuqRFKYNKBFiUB4xKWUCI1CuNKe +bO7J5p5sfn6y2QwEcWwJ8EQif4SWbkQJlN1yBSYfmht0kPowX/HjBDgTQdlo9HCEID0ghAZ44SBw +hFlzGJQcDpkFEhKgJj4r6GwTWjD9zCOAOqpVL3jwUeOTHKkWAfg/HVRyMACJrOO3sXqPHAzJbWuY +2KHS5HMOHrAOmZxo9dSswJqDycV4yTgRqCSdI4O5eihQAaTVyVyDIy0qi3smEfUE77Y1rKnzIupR +N4Z04giGrEASjMrHSDbI4F+r114GW0f/FBHBaySw41VSSAENH6E1Ra2vNHWdyOHIW6AX3WzY6NHM +RmVxYYuH9G4Z0rkgIGENXvbARZgJwXYxbn71Zil2KuWZi586lqUYGt32FuLoaPebAdM0WIN01mrS +ST0VG3VubEAN4QUJfSvmhJ6NBkd8WfMkgmwkB3pLh0hqrKz89r4ZgPCVR6KkpmZGohZJT6TqOgKQ +Ddcxp4KLuXShSbZ6I2zQzObtYZe6lEmfmGaFoctBUzYyNws9rACiSvsEoBiFja8ctbat+tDR7U/Z +MuavrqlWNuk5snO8VFQ2MKKlyVe0cE/jlb6YdFeCcDeMnebZWBrN0MykZCcHdIIN4D2CV0sJott4 +RtA98IS8CFwLyYs0yotoHlxAcAYBYhndjf7YADysS7rnjdmT9OteNaGv6ZcjlbVM+F4HWRqGVLXl +OhIFDKt5psJzhwlQHALjeJMWYnRV7eY0dVlA3iMmgfyBOUFFaNZNGWAIXFu0qnFJM5KwCbnkjjk6 +27jVo7mtOmQHRcInE3gZ2IBGmWFS2TXMR9oy6ru8cNOACky2DTb5ZOMAuHzrCGOyyeb56s2a7UPg +eAMJcP4WUl5mySZiidE2Eth4I5H/Gm4lgMabibDRdgJs5obqV3ts2WjsfSR1zNAxCTGdOet4YwKf +K/i36m0BfIb1NJDFY8oYbAhOWskY+bpCajqogLn8T8XIjyAPUpFSdhUERMPMeHB1RUbNdTo4IkaJ +HAayT5EZ1smBxtD2QI9sXt7TGIiVBnlSm1YzzyKJDCJ9eGk7cGdcrLa0DEqxCgFEJXMwbtLa0ZzW +AnN8Mn+LRUKeZWRjihYKW4QYvJtjKWo8qagy2BNu2Z4Y1oVMIJXqR5hyxMNEhCs3G3rIPw3O34Ph +zhLDKwv1ADQgteYgBv0saYuZKEzkyGLKUfrhxViEyoCnQwwCjTFkjpl2jdHyrpVR6kkpBKolOW0Y +WLKuaNXExGQW/O//z95756eSJA2AewHugAwChCtfBZIQHiQhC/IWJwlhhemenj/2txfY4+w19hp7 +jU1T3hfwptWv+eabN6gqKzIzMjJcRmTwmPpIeCcEuowSMLekGO1v7JXFTBZdUggvfBclpYteoZAV +8CWpFD53V9O8ayLXU433tV4ZEWsIllnlIVC90QS0oC395v4MiGNhbQMKXdZBQLcGJ152AcMqSHhR +bVX1iMU3T8HLpFFRLfErePE1boD/Bjq6/hE8o9Z9FTPAjRk6h9cVa0dY1Q/Zcjcl8W4ikyQM5vEn +CRRlgxJFjbJCTpuneRxCBIuuobsfxDccMm1pPD6kwYERk0rCPvwWni/DFBOHb8F2ZIDFp03X99hv +znu/FLqDFuifyl6aw5uH0aGoQgAxdMsvj69AR3G6VfUzBl9aHONgSjyPq6IQFAzGVJZcfJL3GR6B +1dN/h0CjNiJo5YHYf96HBmlLAz+fbPWYttZzkvjuCXT1BIFyAe3oFWY1M45kwyOniJZaIXTHL4EM +QixeS6xeOs157pSCOVE0KXjSdIyUDJ8ZaVnz1BM1B15N6DnwuhBFg8/0NA0e6WkGPDLStfqha8qG +cRQG2oaoWIi6MQ71YzVSuFbusaSqRJtKPEGLFd4SDSPxBnCvy92Je5tR8IkusedIfNE+ukZKM13e +uJF5ef/pvooZ4Ma0fTPoigL16Ko+7V+2PllYqR264OAdMhTMw4TqstVGxldmEgS60xfeq6fbHCQh +4H0oUMibR1PqzYzzS9E1BfbfshyuR6DazQv0nPPeM5kEQg+qsMqWVq0RJ+5Y/RMkLvDSiE+gXyWJ +i5vRwKLyKysGRT3DYWHxwwhIPUQOx+vpphHTz9OAnPxqiQ1dlCk4rji8nAJWINDSGrr/laMcv4bM +HhZt1FKbx65zC3UN0/OBCHGOxFtE3aaWU7dJvbrNCQa9hRN03B0JGBV35wSD3qJ6JOktqq9iBrgx +Q+eS3kLqVS3Snbodg45DgUQB8fjqLBJmP9rpLzFgJjIsum4B6QQ0p11RqH7Q0BKkaaXKh+pr6DVk +KMevBQq7RrVXZHntO7dI31BnJ3iO1+rdyopxEuPj8V9YRxbrVvolNQHdCAQvUUfKBA== + + + gyJQSeRWzfs0+gU0cKs+jQ4CDVONliIRES/If2uISFCxPHRDjvQoZoAbM3SeF80F9Rgl9Vc9EQSc +FfA0Nfhw4HU0vBCWlUkMWO5JGxLDDmMCX0ZNMyZMg1exHB4a7jpux8B6aLTj1/CiNPHkcYm+cwv1 +DTPZYd0iD6eeWgIUdVuZBLFa64UIkfqqJ0P1Q9eEqBmcRIpQvVyIGCV9X0uOkrbqliB14WC8lcsR +QyUN9rRgYk8LBgtEMFggEg5U9rT6kWhPc3rrg1OBVh5o7WlbJv/z5ZIe07/CntaydGyggnG5sKct +v3S2p506tbanrb5cwp4mTexpLS1rnnqiZpHnaOlZtKe9UrRoT5NGe5o02tNaulY/dE3ZGh6lt6c9 +U7dkT5Mm9jTpZE8vqNiy8M/Xs9HwYtIdzrrDj1gMP0bqrvqF72wM3wj4zUV/Dv49b351WjMfvmDS +n5vMp5/+08aw8dGZANW43ZmE7d/58ct8o9/vgp06/uy2xJb10aifACr2eBb3n//RAL+NTYEaAECo +27O27U2aIhClfmPm2J5G7a9geoe2LQJh8gFv9YGxLZ4IyRq/AAt6PrxozD41oPOfjUlrpEwStEIg +TJrWO/+Z+QvdP7oA4fZA6whEY9yZALZZm01GvQ4YWByvOSASzYqvmHIsEAMoRI0U+CfEEvx/gsD/ +RX+JIch2o12oc4X8UNcU/A/nR0UucLfkL+mW1k2ZBv+RJqz6z8r7xaiGuwF1y/pZSWImf3WnMo5h +pyTqEPBCP42RTP6Cfnkdknk/7xXJq9wBZnsSjEva6YgYE35Jq8FtQHM/lfBL/4GYSvgRusg4JWs2 +i6LOYkR1DYfQjYsizIfzywaj4m5WKIK3Jvg5ZVww4obkORhDBPMj0W1MMC6TR/wPmg1o1ITbUXum +giR+I13FPPUlToajP4foDyCzkVwP+xNnYBr+qC+RBfL8j470NpEXcwxL3T6YGWwPaKQ79OMG+CnW +dBNikyhQFhI33Wm32UcAjRBqs0artxQEr2PINabdlvI5XmRMUv7z9/dpBwg00vp78YOjfn+OLsMY +TeKN8RggDS8O+Kgjoi+kAeqvAlT6i+/vYO1A63p3hsBRqJ/++URsDAZod0t36Gg47cLUTvkuu0J3 +Ou43/sJ/wpTPBIYkrhqYyJUPEBtPkKiSlgAT/9BVDjwjcJqcPkFK5YO5fQKqhEbSMAHwLmvuXgQN +jA5GEqvxiULn3b/n9/lDquGEMTLxDSX4OUaONKuob8+P5u/f8wGMNiYzkxXL9TvDtocFt8NnAgFT +cOXOiapMTvncYvA288iPhu15d+ZmDmooK98BkP5WhE75+pnraaf4R2d43m4jkoRdKEj2dNuLWGBC +leplWmsC2diwLgvyUKGL92CQHg2L11KcRbkJZR3lAf7mNPj7TMmXKP6n05rDIaAX6FszeQbvb+PW +Qu03E2pu+cdaGK2F0cqFkZkEwidDJDwEQYePHA+LHMJaE/i257UE+hslEPW3SyB+LYF+Mwl0teQt +zBZGlQlVrk2qtRT735tUnu8yXwu0f/iUPAk0YS3QfkOBxgm0gLLrKPC/LPQBJgWWxne/sgy8SwHe +ECB6sFl8dw0B80ZgwTlrPyG1dhSupdqPkGpJAV+lx1A8umOShZVuUBQKzKFOrj2F/3KxllyLtd9M +rK09hWtp9NM8hYQoXtbC5t8sbGD45FrYrIXNWtishc2vEjZucg/WQud/NyVD0sPfIHbony12/nVC +AzreKJ6AZXPRDXnovIjkGYbRxOfxPMUyuKY0QSNPHA+j+difdZS0IMf+XfgtKeBLxwlYBgTdNYk5 +L8uaFO/yyHh/Hx7siV0xa3b149jVUtXj1uzqx7Ar8c4EghZoeOyDuBW8cpRjzK7vWPMrN/yKXfOr +H8ev1urV78GvJPUK3u9PKuoVzaOif2t+tQi/+uHB8f86fvVTfIj/XFajMHXLH/g/qOySJ7605iYO +3OSHBzr/67jJ2lr7ESxp1XFMJA7PBawsKaDadiyfZAhcEpQQkitIefyX8q91XOuaA7rjgOv09/XR +7g+TBkkGpyFRPA8vFkQ38SYp1uRyyvWZ7z98Sp6E2jqq9XcTaj/FSfAP2zVrafRr898pgaYZVAYW +3icvAMUKlcFj1qGu/+78d4742RLoXyc/1m6hfybrdTIEaGwHkDwsOQZLe1AkdgoxFMOtQ5AW5F7r +QP3fjf+t9ee1/vwD9WeaSvIwt94f4zkgc2FQQ5wnGNqkuvBaf/436c/UWgL9ZhJofSzxI/jJWpD9 +4mMJVCqGZBgGXR1DwjIzyB4hBX55e+R3ocLfZ0qepNoPz0RbS7W1XbUWR/8ccWRz24YYJ04J65t4 +/+WW1A9PJ1zLnB9jSa2v4l0Lrp9jR4H3cYYB1IztJ46iuPVdHv9y++mHp5quZdnaflqLoX+OGLKy +n+IURwAFyy/dD8ByLM2uDal/uSH1wzP91sJnLXzWwucfL3xgUASw4DnWLzvx2GRyndHyLxc+PzxN +818nOqAPTmB5QoDHvBwr8CSMP+UIgke+N07gKVTsmoBX6sAnpFI8hOGJH1dk+F8UUmxa/AnHEXMC +gaPR8LVgFMMQy/ucfh8m7IljrXPwfkeex7EsyXDoYjEe1ko3u3KGhgXVk5gv4grrAioCuC6YtNa7 +/37273T2QJI4sy/JMKQAfzEEyzI4qYRMMtw6NPnfLdj4H57atxZsix2oMzSRhEIryQocj36QAstA +rZ5gaCzGeIGhSfiDhLo8pWj1a8G2Fmw/XbBx4k2idJJLohu0GIGkCNRJXGBIcl3h9l8u19ZJn7+b +XFufb6zF0Y9ys+HzDYYGSjQ6XWepOEERwKKKU2SSWltW/+5DDn6d9LmWQGsJtJZAv1ACMRw86CEF +gkyicgqcECeTAjygSxJrAfT3CiDy768VyK8zNNciaC2C1iLol4sgguR4Gi4dxccZXiBR0URifbq0 +FkE/PGFzLUDW9Yn+DrZJU4htspQgoNhYhoP3rKC6dTAMj1nHaS3GbtY5db8bw0KxqRRPo+RvhmCg +nhGHOeAoKEsK00KJ4cAKhiKPxxFbPywm9R+269Ya8/8iPItbX7H1g/Xnv1+c/fDqnmtxtr7u5B+0 +9dYy7X90iT2MzBIYFlAyjD1mCUaKOCbpFVxj/7tQ4e8zJU8y7Ydnnv8rJdI6+e8fyYptkv94gWSh +Zwnn/gGjgljXD1mQYf3SbGVTdnMFYfrzo8mwM5muit3ogMosxnYtAP+56jQA7ULymk+ttuDK2a7I +7lx/75FP/iK3+O/LnRbEz5qjaDnKZNL4y18ZTbr/HQ1nYFs9hXjKP549hf9ROtF6c/7bNyeWOvVJ +Yzh9H00GqxJRKoDuxJOMn5n05UVjBsYwRJKKkITXYPRH5+b1YiY9xd9MOu99oG3faR82hu3RoPvf +jlnTe/iQ8SeOgJ4VGneHF6PucAafJcVnw/kgPxp3O6gjnlL3X1H1L4rU0awx67xeAcnawAMmCfnl +tNXowzF3Jq0O7kMeDHpV7Q47puAKnY9JB78idcBKjRbAvllHFXVHpO6V8tnvZ4y7YttlgNChmm2X +RWVbxbVr3cG4L3NtL+o81uNxHwpg+B26MclCaxeNADATQILWQz8aAm3PX+6P/vSzQNCsxcxazPzj +xIxCw/ZypjAZjWufjfboz3ijay5g1KBcG0CIszf7Q4QTIs6zEn8cjRst+Ex+0OzPJ+amvcnFIvof ++D93Da9+AAXTH63+RGTgaMwfs7/G/2K2fdEd9vy5zh+d/r/YgGf/Vwb8L8Kk6B0Fat3nqvCoAemN +C3wNZ2hH8TILeJ/ORKVQVPX63YHLPfd3uBgVrsOxNIGPHKkkr+ZCMJde9PRyPMMux5J+zlnOL0kI +tJzHWndZH5UivR7aaY2JWrGPExS8asxP0izcdDTMF+bZ1d+Jihliaf7f//7lP21Me6tin6UOYJwQ +3+5YJylbmle2EuifrZD8Qkpfy8Efu5Whjc6gXUxZGuoLGUK/z8Zwpaljq23tnFgL+J+iHf9CK30x +OQ6dG35pnyzpBdHAcmlGylK83Zj01E6G1nSCnCBUnOSkNn90JpInGSN+3Ogiz0RM3epzNPmvxTpQ +LAODHymBw8GQeAXgX73FET/VuUfsXDocMIL0Xp01y1ax7EfwtDHvz57tfeDedhQKRYKRRyxa9SSH +7jDkhSS8slSeqZcIWHMneSB7lHwtDtvZyQyNdgqfsPDJ69loeDEBrbvDj1gMP851wP65aPQ7s1kH +cdiLpptxhh6vwIdICQOYfA6jxbr7r0//3HfR8oan0O1nd9YRv3NGVwMSIJB1+o6SDMfSMLI4SfMk +TWtcAOJ3V+Wc/6rTlr5M0smk5pLkJM1QMF1BPUTly/tOHzpa8cccy/Ok1s0g5+6oP0LnIOI3LE8k +GV7dIUkzLMVovyXlb/N/NaRPBYFGXg2eJ0h4O5MRrXg5xC9z/bmEUBr8HykgPBJ0kjJdCPWnp40P +oAw2xK9JnuIxUhkyKaB1YVn8g+A4AaGPZznM15RAOp5jeBHkAQwALx/QSX/ugGGNi0bSeLkFAV7x +gV4xFI8ueJeu8YSh4uhiT4YEkEWwFM0DsJQAwNKcHizPAcwmEVjAebVrzLAAHsxNkUerAQselQ+S +hClYlmRJCt8+SjJJzTIkOXiNNmyD5w7AIizIYOFoSfAvgEvo4dI8w/IQnEAmOU0eWDwp3WrKJfGt +KHGKBiijJbgsHC4cfu6ATUpweYqmNKMTWJ5lKC1c6BRDNA//T7k2VYJLQezSCL20CBdAJTSDg9jl +OG1HGLkCLwo5LVQSrRmgeBVUluJ1DELgkhiXCuKZJIGTSUXkUjifQKQwhoBISMLBchJYQLi6nSKw +YBNpRktRkAggXInEKIxlDJdFayYA2+eAZ6SNSHMofQHMi0b4E5IkxeEtnKTRxWmQBiSBz8N0BxEc +GiQDV4qTVkrgaQENkga7AA4NdM8jNyZFE7SAEwEZgsf5FTAPUODU0AiISVbaVTzD0Sj/QnGK8izP +aKZMSsstTxnvBwwUMD9pxiQpg4WIRDMEjARlJDI0xXIqDgtHyeFb5MEPwyg5uPdJlpfgEQKPqAas +G8GbMjOgVcFJoxkgDEJaAx2wIlgGUz0cJ0VJ2xTQHgUD88E2ZTD6TZhknGHg/oEIoMEqsepxkjQc +pyCI8JLgJ758iARry5iPU2KqZBKsDq+svThODsBl0PQZaZhJjiQoJM9gBXCBxl/THIFQIqfHSBuI +xoDFDYT2D2ROYEgSOmmORjIkCVg1YX7pP6MwZZimg1iVuHcIuNHBwsEhsvKWBISEILIswZpCVNic +xEZZvGTSluQlpk8y0pakQb+4WFIcUDeLdjQBEIAXGuw7cfvQYhw2hsQKABKcclKCQxKAQXCY6aLg +biCbaB4vOGRZcJciHqlGo3gXtMiHKAmPSQMzTpJJBi8KQCuvZcaySMK8HfQsnSjIEg== + + + iUarQ5ESz+QAu6PQjCkC0R1QOghWQ02yZOZwThT4IcvOJCJ0AW0gaf4MDXiPgGiZA6we/kgCnomF +MpNE3UH0sCIXYnClBwmfUBzDrEy4x6U9CUsoovVgIX9Dm4hnMDOh4LKRMqOAyyiKDlotOOEdxUBw +whUXJKiAIhgSjgQQN2INBCBmDjMQDikRtMwoxXWiMKvHMAU4VLTLOYk0KVagSDRlggO8GA40KSAc +ECQgJEEtJDg4PNgLQ6mWCcoJgACWQ7tI4sQ0S4pJbEDBEvMEeB7tSBpvBk6cPoMZkVxJQ4TKwa1O +ItEmUBLQJMei3QzasQg6n+TRoAFN0GgakmSjJTkvyiS1ZEOCTWaf4Eu8HnAzCRzmTxzPYCACYu6M +VNuDkiiK1K4VpFSkNMhKDgPYIeLpXJIGWp8f6ztJUT+RxK64ScG+UhCahDPH6JSwyQDtncCKGLy5 +HY4R8BS0Z4FujtdZHKF8WzuBGTOGibBJI36Md5IhUas2ep/5kSHgv+l+DKExExYbWLkuTb8RgQOI +pUa745+N/NgccYKlba1AMfWq2sDRt1cgmYVQ2QDSNTdFGrQL/ChAr+8esOlHEHyo9j1vTDpTf3b4 +0QdmlQYM/s+jCuazf2z4BJELXHzMp6CZeZE9q5+fFf2Ah7L+PAT6H5/+ofQZ7kx5C8AYvkDPpA8o +DhE2+B8VSLNu5F7AVuU4UiNWeUC5WkErIPGCtBTxqJnGtzdI8oZGei+UsoCpSLKB4AgSsQegSQqU +ubGcFBkkL/IJQaWtAUaA9F6kBpEquLJ+C/Q2JChYwLO0IwaWLyGbHATma2jokv7PIAmJBDhgrxJo +hqcoGgPiGcZc2WAlQSFgtgvltFo1oKFMo0g0arDkpLw42B7RLChgCIa1Qc8k1TTJox4oAUgWK5VP +VscFRTWVoFFJealJuOUaf6H4losPt74IrDtCoS8rZByD9VCeBIozEn8cB5R4NACgS7NIqoiXe+h/ +iOiHC0tBliprtzxQS3AmG0PTBJamDIFFNbBrkDZCyf8VDRioJrMQ0ay0gBwYAFo3FthuiO+C5QLM +GXF5EltztDQm/Q8MlUfCg0e0LEEF+jpSlVmKxBuBAdYWGhMQtyTWUeT/qjVP+C+Uw5LIBKNB68gA +lQYRGlAgwO5Aqo0o76VB6X+IYCkk3pFjAPwr0S3H4vsoCB5JdxpISA6TCcAIIypMnFr1wnoSS2tU +L5oBdCYghQXsXmSUsSSrNoWAeSPd26L7IcLlsUqHdhYvCUwKuqKQFc5zfBL7UEjcgcJk5P+KRELg +PQpVDvCvpByTQCtA3wlsEvsSBKB9afVYaWT6HxJfIZDxD4maUrwVrIDbEgxFYI0L2G9ah0BS5FLa +/5VcIEjpZii07ylpy912mv78qD+CInA0H8ubD9YyI7G/g2MEc+uLkm4VkI1PDafhaNn6pBTbhgea +mBavHF5SxVqSlFFe0nQpsUSaSGHYekB6Ka/nuSxFYQ0cmHYsr3EmWjqHWNbGOZQUlTCBAARBaeEB +kxXwNvhDbcVjeBScN20Yn6c4KWVwFNoHvKzZSnYqYBkCzqIFO0Lr3OSxyikSrdprRQpJhXJJDPMi +JzutJd+04q1Wu7F9Z2Ps8EZvJJd3tTudqb34dlHu8gGtJqbSGFxum+BkcLqjETj63U1mQhL4Ve2v +QXPUh2D+D1+oMhoArTJU6fTH4H9yjWmvgwYOdMXWZxiqn3+AUUHNM3RVq8Em8z7Amj/mv+p+fM7U +DwqjP4fqv6udd83767H6rxzQjv9sTNrqZ6XRRHx0PmmCv88njeEH7Lo2A6qr6u/cfDYbDQExGZ9R +6mf1RlPbCD7QtMAdYT82mH77o4M+gOslP9B8gB/R4JHocgeD67Z6HTg+5POXBgtlfFjEO1gpNdat +V0+ktsKoNR8AEio0Zg1f4DUh/e1Pob9U51zw77vT6tmo3TF9uecP/WfQH4LXscZsNuk25zOc5AKa +Yqr7X4BYAXxVq9Znt9+eANyjNlJsjfQW/jP7a9zBb0M7w+nrH43JdE+V3K9u+kcDrj1uC59PLdrB +dHHcTBzJVPPXPxQ7w9Gw4wIx/RGg8LYbzEgto3/vvJrdYRsMlHQxN0Actc7sDE3CeX7q1ita/iUx +QdpiwtX8u41mv+OG8B1X9Z+00VN/uN7qsOnfTNFweq35dDYa/L2c7NfRYWragHEQUOaBLeaWHH/5 +vqjBm2t+zFB+h106ff/zB0vjv3kbTPvd1j+dF8cEUgkNs1xeV0v7d/NdOBXOaSp/uZnKX3/3VEiO +FminqfzZbaOwdsfpiA3/AVP67CBL1cWcpJZ/86Sk6E+rCTVHwNIdQPP6fNIF1qKbqRm/+QEiH/G6 +2mg+aXVyMAh6JWzvH22QESZv1RibNSYfnRnQA6DLYHpUcLP0xm/+ZlX24qxMMaXRZNCw2pXqKb93 ++x3bxprJqlv/481zwokTvKNAaHeWudL2711+x0l1h2Cc/UbL3bTUrX8430aX7YwbAFzLlcagbf83 +b9qtEvo/Fxt2AK8SQkctbiapbv3DCXM4OvU0NW37HyBvnRnv/8yk1Qqlv3s0o/GsO+j+F2UW/JQx +ASv57x7CoDNrtBuzxrLjSC45jq22eP7hZtepGqOP8UkhQfilHyogtZvy602382du9J+7e7H942mn +3Z0P/Fed6ag/F3NQ5C+yRyTpl49jAK3Mx/5SH25zeKZ3MenA1GDFPcyxLM2Ks88eJf2Nyaw5akza +/hY6iib9TXmWMvtBXUiT8HfBKBqzDmjYQS5t28a94ajVG81n/g98xo2IQMlBgyM47Uw//VeNKZCa +IsGrZoq/YCmGEqwHTfk/0MmXu7ayxkETmnGcz2djMFD7kVAqyGppCEbQbfun4nVzLkahoNlxRVST +c2wrT47UrAcig8kfHX+985+Zv9juzhrNbr87E6U4ycgwjcRUbQw/5o2Pjv9iNJaWUC8GeQkv7XE3 +jptIIMHIJjoSGaBLDDSPGv3uVPdoOh6JO4aW/R3jRrst76vskT87n43kFTOSbdI/bozBLph2B/N+ +Q1lFed1z/U6nDW3QG2Vzk5b41VpE+clonJ10GjjF2SAzQ0osIKnf8H6aMv4i4mH0mY4liJOVe4Md +aHwN4mClVcs3hn80pjUZHWpCIPzvMmcAm7LfHXb8U5RYPLVvPJboZ/RHZzKGB8RT7SpDZIlcBw76 +ct6A1OWv4kub9AzCbBwzQJm4Ja9QuKblBK1z7I8OvMXQ32z0G8OWwyRb/e4YrB304v8H7I0PQAHi +wEMkEwfLoWKkvexRad7vS3i86UymUPjOJoYuaqVbfx5Cro/8WZFCzPeF/m9CC6RSP636r6cd/9EA +brDsFAUhQFY5bOuJUW6vNBHDh2rwukiJJHgeVs1y/kov6cyb4nHhiyXkXWfWUNFRzNDAGMcjfeCv +jYGpNJkCdM+6rUZfT1aWHyixKQb6Mn4DcJyv1bT71xQ2SiJVm+ukHdijYas/bwN9egApRs/AzL4o +j2B5AJhjD9hRs99xMSQ83eJgPPsr3+n3p5aEIX9SL9xCX2hF5Ty06wEt8mljXJcVIMpF6+qopeKo ++hXX75bR+C8DbesQJSLTf3d6YQ5T1x4lK2NM+k9xsrehX3Wb62H3P6Ydqxvddoft0Z9THbWrWnTV +clM/wqQGb7XGH3BrwYR9BcJoCCnFr+HPrr7xw+XxE+ICEZ6+Is2W1ekjShyf20nhr2hRUfH0ESOO +j/H0FbvQV9xCX/HiV95QKOjoyIYizAlKh0bonXaiJ8LdJ3iA5kts/80TQUj0JHj8jjLHveN39ILf +WdCV43esft0sEW/KdRSJXps330f9dmcieRLh02lYL3Z1jVXmmpY7FOZjMBJofCljyXU+AVWp/Dm4 +KWog0ptWOO+Z8nXdO7UNoHqv45zF/4xHkxlUg9TSVaVa59Ahj0q5NihIGidTrdOvNGagbyhc+nB6 +U5W+a9H2CPpbjwrqlurXdRinAHs1Gx8KGVUNT/u2Phqr3snnx+X+CCifV53xvD+VBeAefCtf7qGb +qP7uD0XBAfY+0jmMshe8KQ5bIxMLG7yBZtz5UNHL1O/QNTMId1BzEC0oBSgwBVtdZdyk8qYEtKm6 +0XkMQQIz66QzGZoNBOjWsvqpHvugCdCLNHbTjgCxTzFpGbZQ0j8cKYaGvztEGvxo2pW6cfaIUH5g +HNp4QdT2AmqL1Pm8aChcqQ0FtTWCmuJJJW6wGZLTmCFqzwZuLcVe+xtAS8auDp1LQeOGwB/B1Dho +WaCPkMmu/8iNU6h4UXOLA9zYGgnGtuei2VZTm49qXOFmNsjSzhs3d564FsX4K2ccO+xGOXzef9tp +Jm667c4ocToCml4HIhUojmAfdiTcJhRHeaI16sNyAgCykWWr201n/Xgbd4GIWhYI9uDhZ2J7xaPo +5ptxewBe94euBzVuuwaOY/7kL0j5eiV1w/F4EkfCLt6HQfeuWs5GoneJ5Xn7lhPFsBEI0r4tjjPQ +sXfNGsK2f47EinD2zT51zQw4/Ro1AU6n3Y9hw+g01DdES9sU4wzsIKKGI3iS7KJdY9rszgaNsX1T +3Gai2ydmrVv9Sbw1GsKrwKBLzmaosKXMt5voqiI8f9609aQdBzY8vHPHYQCg4TtgTdI1Y0gUm7ZC +QsLo5TP0+gc8oB3HP122+8N6bOOPQS/eGUIdw90OQh/gLaSsp5tvwKLN4AVv4ljiFGtK97Ap2NSQ +N6sCoiyHPgZbpDt8Hzk0m6guunJoijylzcZkaoNc1LAJVSywn1QcwkVjmUm4aDvR+D+cWqsZBWfZ +fNCY9KbaUbtoLI/aRVvVqF20Vo/ajMlr5zifdoBKjJRbm338PpzF2/3x5H00tNvu42kcKmaAh0zt +yWIaBzwTOmWHoKlK+Bta/mccn+hZEhL4Zi0/3DAv0E7kXYp/2QxNSjvsD7eGOGlPptodbyqAUDPJ +ET2dWvfcGsQl73pr8FfPhg0qDUf43matB9fQO+Yytj1DLUFkQdfxWtyPc1KBPt/2P4Vqt+cXT2H/ +H5SDDgTHpRJOZtIOtIFaTHdoIzqhfHUaMmwjqiyiJEias0Eo0hX2JzCUVSt1hGUIaIGAb7b9zb/8 +hUn3D3Q3th1fBt8rKpaNcqFhxFaqhYm31tAIHTm6khlQxmvGZiqtlfW3FoKTD2dBCdqIQlJVkErf +ClWhkmA5trMRurjRuC8FIZkSN2rTGk7tUArazLp9tYVtzj+n0jWbNm0Qj3WSjRNJDpgNGbNdzZKY +tpkC01k6GTVnt33NsZtZi2YX2kK2TYadj4ZysmkpAIBiOrRv0ydbyHVuMPv0QuKz0e5MVEeRpq20 +coQ3UwUBM9efDpoy/H7XRkkGDUbjlo1ihBpMbaaOGrTntga7zQ4Gn9tvYCxi5sOWK4aAWjeGw5ES +hyqGBkAnS1Zq6FdcZZ6jAkh1e+Qk0J0WG9wupl4EwqpVXRbhDva8uVBEFhIYMk6ctg== + + + pAzFkOr37VtNe90xMHOGNkIbNpuA3TiZduDwJu66lcIO3LN66QvV3KyGA30WssdOSwXHo+YRMAbU +NKBzfulXlLB0DCmLJV58fVEoiU4oaMvAALfRcKp324ER+M/xK5WrSu12bvzROQXivzvud7JaNDk6 +eVS1FPyqW49X4N+Bswfze4Up9nlFJxbDIGy/cxOTYfYdBfu7wIoXOjqFHV6M+l1JKpoaD9JAccmI +0mQ0AEj8czTp1SXJxNhM73Q0HLU+wUcd1SRPukN3pq80aBxoBd32w5k4AXfYlaKYskCONhuzauOv +jmRmwium7JcFXgaB8znRaUu2OfrDRZcoVsJqRe07RZ9a9+ptea4U5dDcIDKfqsFt7GWFYAEB5E45 +aoOV6r53JfbFeUCYQh0u6N86XIexnTSkS2tMexe9ElwlogkzLkcypVQogNakfk+qvNfaL12FQXoj +marieLUZrMVmVA/aVMdyH5tlbuobWYo11Xqbd87BI2LXs0KtFmqq60BR+12q4w2Gj10wQZUwg/Gc +gEbzjTGO6uw6iA4GwpH8QNbKgtIjOoE4bQApoaRfuOMkhc4UDK3hXoJKrCM7sSdeE2a3oCCS2ZwL +TADGcqR4Sy18sFLr+qQ7gEi7VVn2jrLGbDp2Q7rqfMA+ps6cWaebODJm9BEOkO2qVFzr+Son6s7D +LoHNc9tpwlB3Zx6lIiI1X3IeTN3O3JbxAhkYUIjrn/NBc9joShF2ofon2Gn+xqTjn312/KLbyT+V +AuH+/OwM/VMcYdEYqgt1+SEX9Tem8LGi+0ox8XEUHzJDwLXA/hrN/WPAOf2An3TwnkZdY3AfsApP +V9NR1A86kz8dghnDi1nHMPnM30Un5w1/v/EXjL9vjHHoCORV03nrEw7vaFhAR1UKGNzbECB1DkY3 +ele6707982EPVg6Ju975rUl37LixUGOAEcRl6ipvjN2ayWaIC0rDMqpuSF1z5M85+RCDYp02Fhh4 +xxiDZTZVMJDxWMV2HUhYJcVt5SiOp4CRFVdwka3dQ2pGqwtntIMvMTMXRklt1hi25ZBol7xYLKXy +15mty8MxdtwZoWr1wH5dERFoFxaYy+ANVgbzsm3oyvw0mw7gq/3pDFjkczk56P/7v/+f2f/7f9nj +TPwM7K/3ybfWjj8a9vzwSjeVCc/zSSUmUGdiKzNL5LrSyLO1/NGRwBY6sH/4kjk833mM7N8eBPca +d9Fjeuc8lstMyoPP1Mdw47i0EQ0F891GfLrNXVeK3FYqc11OnzKHqepT8DQzmbf4UpE6FQIkw2wR +xLTwVfiIEtuZvZf4bmY/Op5mpidUwhfI7FU3JlKj41nuo3JZzewznVq+e5BuFeLx4Iehq2r7HvTH +F0qBFP9QnhW+nnPMQyyaHYyq0+xRbfYZSXNb81KB2b7NffWDt75A4Z04bpoC2+aT7/zN5eNTtp6P +31h3qm6Xes7s90rPmdQ0PogUooF5KVRuv/sCCFmlN6BhFN6fb/lcP9O/S73nPmf5T/6B1KDjbafQ +Iqvfmf3D4C2GA4Y8zb98vIzAr53vwlH7aCMXE762s7XY1hCP4a7RnvsCya9QpFVssZeh/Cfzuref +DdA7kdxZ9C2SyQevS/nOfDd9c7z1uddqNXrwVzdSfK9+4p5JItHgJ93tt1T35bid6wcOg7FJ5Gme +rdZ2vuH4w5m940/aF+D2bp4z2WErOIgcnO4l+MHTQZfnE9N3OjtpHZGRXoqUIbYKx9MbgDY+2OFv +aaKd6uYTDbC+5OlBKBbt5Pr8xQDP4L4ayOSP9rdui9EkOwXrcvTIbaX5/Oglsn/TfkxRza1nBDY9 +DIAJpbndLbgkj9wtdzmEeErnemEuJpLmTbtKkM9bp4VEY3+ntBF5mMBeOPjiBUFBTXwBorl5xKDf +kXRpX/y1f1s8wc3z0eIbBkbdU0eAdO+ISDpdjFKFw48DEc7twf5e++vsBa2kPGAA7zzHir2ARrlj +eQDPygDI0MEVbNRh0DN2I1d4RagGwvKQ4R64r1a2XviKFN4TJ9/FRiO4neOa15f7lcJrOlv/bM2y +F9ut02ydosHqZ/nn+y3wTfuhePd2OJdRhKlWQ6YvPQWY0I9PKtKC3Y8K77ViG+ETgG2EI+mtvVu8 +QhCyL1B8JSM3OebuuJSZTD6vmdTp7SFaIYHtTjiweLvRSG6UfNGjUjtxNd4lPOGFhaB8gb3IwTxU +KvTJHHHMpsA/ZaKL4aS55iizV59tZuvHs7kRlbqVVOFdWvi7yQZ8Vgd87DvezerxNL9KdkqhnXE4 +/8ldPRSbxP5uoTOZRInOxcGePBCMDhkZ1XL29ZhE1LYfeyvBnXoSLxx98Q289/GCCrXvwUn2/CV3 +Wsq/HwsEedJsl/LtwT1iniZrUM71uYNbBTY3qx485Cr1rQPdGHwBMIrOeaHcC3RAV5f7kMPQxHvq +dmQcrb5dC/yKzsrjzWYyGdljznQY2Tuajt7z3WmXg9wy9nhBhbeOKsqs9jqpnQHYyVdhSF6nkYPj +h2Op048nwMdo8DZQ3S3PXtuDbO3tuJDoHoRKGMB7sMJl66ejj8xN/ahRKgqXd77AfoQoPsnoGBej +ozOqtMOl7sCaz5PFVu97R+oAbZB+AzPmncdgFbDHg2D2qj/eVbe7bFQA+wsy/NXnbjx7cl8b+gIq +Fi69f83U+Z3zfPW7TmpExu5O4T0bfNHIgKtS6TW88YmmAXjusAO2FNvUvRVXH77vaSSN6utdIETL +o2K03joAWLy8BRv7bjuSPuBo9DZbi2aG+W73sg2ntgGb1AsnJ5VYab/IhtFbOJeP3SFuXj/NBHL9 +YyIO1+pR2Z+8cNjdZTI3zQR/UTm9Ipsv11l6Z2O7SIW3X/JkOV/NwF9pQOLkAdFppg7JaCh/KD9L ++wLab3BL9Az+mYNMMY8+RH9ytSp1Cd8eoK/lDvLwWQ6Dyu7HSjwbK1xRrw/jImyyD3gybA4fFOSu +crDRmQIH9wL704LIyINPy1/soSZwNBdoSGgMYC4AThYPBU4TTxgOCmKnDp/tIWBKLwiEHkVwyGad +oj9FjEGINS0y0Td78C2axqGCStwYDg5jcfixdymjoIbwKfeyr5qLsnhp26V1vRC6ZfAFdAuBv4HI +UmCjaSA8adFxgGal/IlAyT2XlTH4Atq1TJuRnO2S4CGjX/KscKfKn5jGTAnDBVnAxlV5Vgqp6GkW +z8USWQd4pmjnSOg4UOYMG5+bIVW3U30BGYUHumnKOElpQRxqR5NXvkVvdZ2K66LsOxXFaFY1rVAt +agwxkTXZKnvyCC9k5oGJFM+lhPCIwLpFtWoMtvSCUA5WH+JRhp02Y4BoavLW9EaGaEEwxvblDtAY +rziBDJ+jXxj98kx57ib+Dhj4Fy3KvWR2mL16/zgBauXJWCcwsvWbk2EpQ5I9X6AcKL8CnLAhTqWb +zC8D+6XXWX03s0dcbESKN3cVSZTFtlXqhEor0FtJ6naAkqFhgNUXIIIjKtOMTAKD5STHBYHqF360 +tKb4vYdqKUv3to+RHaCdUAQZCL6AMDom+GIs+s4UTg6/GXUvuddO9mpYu87WZkeDYqSaCGnf9kuZ +ZGAsGRVXYcX4wh0cPda/s+f53AXUYUTtaqBBDLBAoRamnalK2eD3WtdXWf7p+KpwPNl9MwOQZSvP +R9mT20ugJ4sjuw70ytPzzkRU/apcDojtp7hsO8TtbQd7ywFqF5LtAIHx/PVz56TwfjmtJboXj0Bt +Ln7nsb5NU5uP9saQpSnkC6iNIYVC4dSwhX2XPS8Vvm5f890vLrH3Pgh8AP12lwQ4Sb/x/FV7BAcX +U/QjUY2t9Z8VUICSRWC/k2XB7cr+gHThIxY+xB1c0uk3oKidB/Ofkft8ops+SIlrpcWTxhbpAbKP +lxRDGPAx9RpcVBD6Qaf0FnQeVDHNi8SpGoiVUbGTxnSubICLSh9YFor+r9X+VQNN9joneTChdqT0 +9ppOFsr3/Dswx4sUQZWZUz3Yy43wk85IwTRWlLp9uyy8X0fKgE+XClS4XcQ7EFmqUAYkMeN62d/p +We0rvvTyvLtVKg7nb1QgORDE1d+PbiceBb5VPc5dXmTAXO4HZ6KBP78PZC/PajelQrgtvVCIfbRD +8L1584KonjTHio2s9zlQDz2wLvnPp41UJF1+fZUo6zkOVjB+kuudRoBqf/Gu7NkU9LS85HrUwYby +QnYEEKn2oE9AIXIGsf2geDuAxWfS96p7xprSmXrrjuOXkcObxrfUQZ3P7J3cbwLz8XNDC/s8Wyu3 +v8C6HEyozPVGEq0BWoGD0JzqQJJ7Ry8AHzv8nM7RIicvAVMFvbw0AIj6tPg6JpuZvetgXOUko9j+ +5t77/OIrW79u3IMOUn2i9JShwWgqMZk76x0YvkCyXxq9W1EMKbesS7tXDczl7qXVHkX7/UtQXHan +0GQ6NcfdqxoI3L0fgJJL4Yv+XqnAPlCR9P3zrhGiCytfBbaq2r256usnwidYlzR3PC/Er9qxTOrs +qyeLqDq3WRrmRdcgIL7Y+HvULSTu9jISPoOdxGfn5Q3icyoOrlw4EDno7QELxTyVG5yngRTTKB5n +TO58Tj8AVF9Ni5Fd7l0lsRS6g6TEbW99C5nU7Xd3773S/Mik7kpqUJhjY9s92fQFkMTej95zFQRb +JbvFlkQI2OmzFli/h71CZ3xeReoEt1VltuAzqnBSP91Uuudv+tU6EHSH28VXYvhceK8X3n2BYnR0 +Os+ymexjsXXRD+vUJdEz+RHoAYaa3OSnibObbL2agdswGTMOfj+UmcSS8+zFVeI51X0R3sGK3+6C +dVGpN1gcHSQAxVR3gYLydF163ftM6Dul0t8DsMgfG5nvw1ZHeQHXap4VmuOPOFm5iYrPwBIDfay+ +/R0rhUbJsO4V2aweUQoIWb7CIZ/Fcv0B8Q7opffApVPn95m9cZI0Tk1sB9cFtOSFy9GuZSPUJNVu +N7+NTR5iBSL5ECzlO1wvWy80yFxf2BIIKvrdzaTOL/towVQcxkBF6HzioHX3CDZN4TR7Vc98G2lj +a5rvHpxOM6lSoMEdcnfl/Fn+5lDWDjlRvvD73dZj4ah1dZFjbqmZYeFftjaA8CAuS6Hjw2qy8lSa +iUqwuIhxQGgn3N7Jdva98LH1zPCpcTwP1KHurgIKaX0Q2HtnBInucT+8HXiF1L1fbCYexlrNG49M +qO9s10qvWzs1ML/IU/Hla9ZCPkgjPsuzYjO3G/IFUqcR+jFbr+9saIjl8EgGWxW9VCJZVDETlv58 +siCQylYpn30GKmLm6A7wsUK0zso+QzzaZC9brGf55NVHknnLDcAkc4RlEygIGtBUCseG0bqsngEr +rH5z2Mvsp8e3QFb2h8SOCYhOrhecHeeY+83rysETE3Q1U1HN00AJxZ9gL72jM2B+FEfqfcdlRlAa +HkNfJ5guS28BE+EhqYBIkcLGWSl8fzHLntyTbVWnBydn7UJ7kIyqzyzAyEKAy5/3Pg== + + + FP6LmfDo7ZNV7VT59AIz3MjZ6KvwnjzuF5q73UCy+jbZL2X7w03kDtXRC1h9eJSXOssnngonJ/sJ +rKpRl7VYqUi+h0qp7NWmtKC3IcD56wnuoJRN57jAmC0cNfoBA//pX4QBbp6vIC+NF06ONvOAW2o3 +0H50fnFfyhCzV7Dmw2ZpYzdKAhP2Gn6TpMDOod/ANjwUVGDp3VAYG5d8nX+Rzq4yAe3pm4iEvVLo +aJBNfj6dbZUKF6e1UmDMAOZy2/nI0LkHRtmLohoEfikKFjrDy/K1rXwW/LeS2Y/Fw6a9wEY7Zegs +fgKNirRxj231skwod10MTZvPkJGQemQR0+gDWgGwcWP3lr3Uqjkq/F43BUEGj9vQZD7Jjj7Pd9WW +k91ORWQvWXy2hC873x/RKQBcK6rQqJWfyoHyswDopTdXNZ5VS89g9TPbSBVBZ5RQT+Yyp4X4+ee+ +imrTXHRU2g1HOaAGMQFgSmT66LBxr5Ns3YhHcNzxtXqmahfEIVXai24qBryBxtRie9x+L4VOykn1 +IiNavXzagi/62Vpz/I6tRYrb/MgNNoUvlaaUqYy/pV2pyBfUyy293+D3Ls8vsrX5NWUUKOykcDTo +ToHYyg3ACPtc6e00kLTWAM5T+1cAY6ft6pb5cks6hZAcJVrF5qgSc2hX37l9LjbejjZzg8iOSkBL +NKbSPg7P7sBKd1Xn9jpgqn1nmCkUKO+vYBEru99A5T46kyQyYp9fk+BdaWc+7uSYeQ5YOsDSVtnk +qMkgJAAOGi/2c19fF5nCUftyVjgOhUrwGPQInxtl+40BUo2Ks52jDann4znQxo3Ka9VMgxXV2MlW +G9JdNHu5+wokZGtAqtnx8XxGHD2W93X7QZwLUFBa9dTZS3NeenuhBpDGaPkw/UFNSgednIr9w32O +8RAgeo9AONyFCu874y1udjI7KL324wlNL92X6AdYjekun3qJ1OB5UES/LnR4SAOFgGlkmWBwlCRv +TxJZoTydwbABoNAdNe4y0/DdZuHk+Pm70Nl/2VQWDOn8bwwQ0e9jwD6eElyqeb7j9mv4bRIYV5VK +6XX2HCtlgp269jCOQxsFcxjJMLgAojkT+xRAf9Fy+UGoPxWb9ext4YPd6eq4l8y4JJ4lS2nMp8Ql +KaK18AXQEWT+83H/u5S9yIxTp9P5SOsa5LhvMnlVaOUbvcJuN9Hi9+lip/jwflSU3ZOoSQ3s+FoJ +yqZGVojFN6EvpIzYFsLYxQNff6skSoV5Fh1LXgKNIxgrlIbZUyA/6+Fcb28/JiooOogfgMHV5vW2 +EriBuaEI9HIzx4ZLCcDH2qnCh4pbiu/rWyKWRdxdZ69G1Tcu/R3uqU1miONccL9ajD7ngL3PUQPF +OYuQBWTvUxdgLP29e1xo3nWuwG5LV8r3r+M3xCPl7WOBeXlxRD/hAWDgsdIWN7msHALV5xCw6JPv +HBqS5B2lLkMzSE/73PVFOwF26nW0FCBDwG6+vIoWjjfeCfUMcOMxyd18v2eRSCgFqnxKB1tuDGis +tPPwMSy8j54jyHVk6r8WWX1OgN7henkeH79kTx7CgrL6MAQgWGzNN1+E8wpdT9LR473Sa/QmpZuL +DKdeHOnEthbOW/7jsxSEp96CZsgygDFXzo6+pwkY3XFeeO7eb6lPqxUGkDpu3Jwq89eY0ZdA/z0t +BcuBUmUgm0XAQLrdjheOI1usuuf+bLvYakbbMIrgljoUnw42d+DCv0J9bV/j6X7mM3svsXm2nudf +gdXZBhZ2ItbIjrKdkjI4DIUOZfcye8/XOX54VCcLzx/PFLD3a/1MQgIG+MVFG+y/7j6YsEYVLZZ2 +ytWxEo4U39hJ3nDccfeDq8fuH6jiRiyX+By2G9vJj9sJGGsFXtOVI/Pdjccg2C+R3dZ3gdiODZF4 +ZzfyuySwCQabQN2/bpah5zRA0v9nWo6W04bCFdC14tqct6Q+63HcGHZ0SYHifVba6zDVV2Td6a9i +Ac8K9YIuIxLezPXxLgXzGaIH9+Squ9pKrDDoD1dohfl20jsfimFUPzGN64uk2TcemMfNBJGInEYA +p57R8BfF7F+maPnFpfwLvdijD+uzHLAsyr3K1tVBA9DLfVp+S0UOrrjPjTBdOdiIJYJAhwHcp7e/ +ET57SG5EP7vg1dt7fCMyT9U2oqd3hY0YcUoRiYP7EOoerFr4kplS01MwuEIPrORbms4JtACY7OAB +xdqgAyXlLVF57QDLYjJJHzSz0fHZceYkOU0Llf3beGn0wNwUJ08PROGhdF8vHWQPWuRulh+KvdDb +l5F8bPcK9FflrKaLJxSnq8ltqPXpG1Wnk8netA46iR4RCaaGp6GMbCqUZjfUy6i3Q7R3SNTzuQJ2 +8kxM9wFsYR5Jlzd20MTRuhR68cRUKDPC994X+LPcB1/fF7SdPk2eT58uzTst8y9s6uglbtrpy/YZ +kPu6bpVOue5JOWDe6f5GaDIlAxPzTi/IJ2aTSu0qnfoCSrfTYPQ0ZtEp+xlqBO+L5p0y4afIPvVh +PtPN0gvjC2xdj/tVs7kSpdxJxqJTbmt7OAkfWHR6/0KU3s9qSqcoDlbutryxv0Mev9ZNOy1XqLol +eqmHdP0NdQposVnUruktoOSneboKuw0bVzV0Tz/2yTDolBkZSKlK5MROL4JBXacsO3gdK50qlIy7 +fZ08fw7rFp1mGhxf2iZNO305fLuy6rQCtD46tPdkPtf9jefp1mfnyrzTy3w4/b09qJp1Gtnrp9JK +p2BdtKS0e/iQOTfvlLm/J0pJ4sy0083SB799NaDOzTr1BYjS83PJYq7cVqA3PM1bddogytG3G/NO +y0Q22Anx96hTX0CP4NlW9FDs9D4W0iH48Iw5ENFbfOqVNJ0+7BNVPkbCTnd1nfoC081KZ8RdNWIU +6JYf6+m3+vjQsOiU2+J77dKLVacF4nT3OYk6RTaydq5H36nM1+TsyrTT2l6Qtuz0pFOjCbNOIedn +HmNE7TW8aTbX6eZJpXP2+BAOmXZ6Exx+WHZa+7x8a6JOfQHjXB/LxM3JeN+80yoduC5l9g/MOx0f +b5p1Cngy7Pbmtbw5s0Dw4zlxe3hSMO/0NF18fbl8fjbt9Pm8d4Q6hfLFONeve7Zdsuj0SSCep/2Y +eadnX+PBeVKgdZ2CXlC3r0exoSWCJ4FaZMOi0/trotgdHJt2KpzFNjcyzzHAx0C3qW/9ppm/8q9i +p006rNs04YdqYxd1SgXToYp2plXibTeVhZ1GlU5BL7BbAPbrW2L6BxN9p9PRzoHY6ewwopvpxlPj +MYw7zd2TR1pGGJ1Mr9MboBfQbdzIlY5iaK6g0/zMwAormxzu9JA8iekYYXTMnGFJQ2+n8ieoU9iL +2O32ZNJoDmGnhK7TySTbGUn0e7yh63TKfqVESXOYuozr0Ls56rzVfaL+0Gm8ctpBVa53XkYpy7f3 +l+TgxurtJ1F5C8yVtwbOD1hvYcfia7AGO5G8NK6vDq97ywnka118O+0Jhl3JDT8378zeY6Z4cZR6 +snwrULtXb9ZvPxsvQRljxvdZauehZfm2GhkeUtZvm+fve8pbHca4rfPNVrNi8bVQ2ansX0/x2/fg +d1L37XWkKymn7+RmyoCx6+ZxbWj2HnO5QqQ3sXx7G2gmNqzfPhVSBxLGTN6/BV74bcu3X7OLccXy +be+Gyl0qbw0YG/RK6Rerr8GQLvdYy7fHFJO+s8ZYoDVs1qpWX+9s7Bw97Vq+LWZPmx3Lt8fU4SZp +jbHsBrUdTlm8ZStE8WBXmnMqtKd7G6lfTg/Ft/n4vn5XVupv5d2s8p6ZMtErrQWWJ9rBx7zIf94C +ffh2LJqjpVcWs57caHqGf2n4GDXbhhZmfiN2nLwHFuZXHf4Th89KG9HCVR7+c4vsN9l6wzxC7K9x +lZM432STCh5cxER+DuwcjT6W3qKD4MPjAdob0NJR7YjEqTAMAjv2bg5Y6+YO6O99X+5vK9E9aIYB +d9osTuZv8ZiG3U42fQGlW2TpWHTKbUE759G8U+b+wbJTIES+SJ0+pp4rsnQsO4Uir2XVaVvdKVMD +NrKqW+EsV1N12t7Z2VI6Rdq/3CmtQy/U/uWZlvuaTsP3yHpVd6tB8AFl2SnS/i06BfYg0P5flE7B +XDRzfbbsFCB4ylh3CrV/y059Aaj/f5rPdX8jbtdpNWjZKdIplE7h3td0C3WKumZVO0mpe/RLXIhw +/qE9cNPuZT4Yqve+RUtu6/uleHfu2I79FOlO5BY5MOenrMgtDVv3LTSA2LlSOWjSpflEZC47tYxu +xye6W6mo8k96HGrXRWMd8iRs76fH4f2xDDGEQKSTle0vNIp0svxYAIyrUYQ90wprErtPFwPiP9HT +kdgBUoGlDmTdEowHTO5gjBvpvE+A7eUSn51CQP7nSq0xiz6zc7lxAfZSVk/37fhQ9CmBIV9fgAc7 +UKGd70rYwXq7yI5VM7jY0SJQ9riBARPHbCCA/oEEeau1kswG1Use6QalHtLrPAhI9zRKBQ8JlR9N +5w5EKAfc8nmeO3FCOvxHHDw25k3mF9ywnJ8voMwQ/WO5gtL61Tad129Lnt+uSGNmM4TK67UNstyv +3wjRJ7YsXCLLBhi5m/sqWYLyuSF3CVl7MU+UpdCVRiJjyio/fXvHvCnegXLzIFLy0pincg/JY3u8 ++6yRpWU9YSPreSlqWQ9tyXp8TqRbfDqaqBEoD1mDwB3Mesxx9wLzxSQEW4wnWozif0TckUNz3N3H +NizZttWuRP4406ndb3qfmlqKocnRhzf1UydUl092xNME04EUIrpZqaWYaladi/iOuPoGNloEvdyM +PE3IjMMA2gHm3J0Kt/I2VNP5W3gHDO6uYLFM0THZ2A5W0Biwn39BxBDWUvpzFDmQKEdFycipYw6M +dAvMDBTCu+qUZ9e47xolt/vOftcBWdnYvJvbruUWGb0mo/Cfx4jqkMJAFoAzhoonZssJMKZeUPgP +WFDFEW2kDTA/mQsaaeP8Uh6SalxoLrOy6cjS5ebUapIZojO7Thi0MOOSKBbfacS4JO2ykxbmlvX0 +hKkvYCmYXOiMSmOgzTzOLMWSL+BlfcsQJxXv2pPZ3m+XtXzaBFmnI0Xw2gxpdnhsKSvPr8TxuFHp +wJCsFTpp6XwBdysIrHxbxcJJ59es4DBgq1h4WL/yxUABhSl5CWC1oYtxgV3pCphWoHgdl3TCKwK7 +tzdivExSrdUtjbHXyQoxpuVoHsc11vph3viJwXCdpacLasea8xcwnoqZMWil0JoKaCp397nhwMdU +Crb5rpwdbq5sV+buvre9Gcr4PNawkhV4ZFJVcAMtce/Yud/ccWt8yLqlHjvpqSyWHd0I5ophRccU +TPeL8zKlp/Ymnm4gIiUbh+LABVwNRKdbLoYTh22vGgi2kSMWIuqjAl3Xjx5scnwoqQ0ykmN7qOdp +M65yaINfR5Dmix46sHBqAE1ww0aHMWUfFhvkyF7t8AW8DGprQQag5ZZwyz3PAvZi2Q== + + + LQM4UhiAW3vfen5BFyj3uUO6Rldw9mfoNXnF1/d1BA/1bldBVIUZWXyelhXOoImFMzV8LGxyQPuf +tFv6FE+s7JDlfotbmj3ISgLI8rjFNciStzj6gt5O9hLaDX4M56Ld4qZWt7N3CVDtpjsPiZ0v4Vjv +ktWPxs4lq/OQDI61GryFUezskgVTU20kcfU9u0mOYVzCqVv3hmwl6YdyPNeK5QXcG4AOvik0IRSp +Ylgt92ulk6kWfh9fwM5LNziGh7v3S/l9IFqcfX06VmDhr4HY4VxRsopvajwNY40qnZnrVWlAB9bO +RJEnu1CmIZZP9Kq0F9xhfQyNJ2A/Hrf+Bfrwmg/qKEJli3kShCc6TXix/ZK6DNtPzZnOTxThJ8uX +BbzR4xO93LOakC9gQ+mAdrRCbxEGcHgdYH0Oa+4OMa8OTnqfTtRZ6bIAOzpB5ySH1LosnotK1MHD +qqA6fgPOCjxzQwyWu05FyXkwnrg3n7dxznc1M2mnPRV1fQQJgFn5W828rdiysPK3QmAeNp+5vQQ2 +jS+w9CEFWjV7kedzDUdrSHobjXgmjuEsuwMxFNmaVKBIPNkLHO9yT7b3TYBpTgi9CVHt+WAQaRfR +kFbjzKMw1ZWcMORR8Kkv4LwNXYgbCIyKez7js1AiYCznritUqtTP1LdGiuk52rQXNnC0aU9/gOeC +o5l6SPIAMZnvZTnatcLRJOvViwavB+bM0XwuT5AgsMU5mrwryzejFXA0sGpmHM3z3gdwvHM0g+8C +w1meo0Eoy5+9Ijg2p0HRXEg+xUn4AmbagEYI3YzsLGj10aG5jsJEr7TxlsDmMfjG4bNlD2Al+fIe +/LZmQy41szzY5+czs82MPfDe2CwAdrPhicn6ApZsdsHoB+1mvkG2tMYSX0RBAaumC2qy4jDOcNyp +9pZQkB8GwFk+BAJBsTCodSfvznC0h+4u3csmpwkI2Cp81VgWgvlFoHahlYbgaWwZ/V5FpI3Nq+nS +Ft/drVtvlsp3YSkNbz3p9/Y+WAhsef3+6dtMFnqVYnDVvLu0jFIMwllGv1dBkWXh4lIMwTHR782g +yNarBRy30tBeFiIO8/S9tDTUyMJX/Tkx6gU8XUk4EuQ/pnFYoqzUBE8pYRiWusDrxGZJ1KiMujh9 +u7tbxlet8/MDYMvubtW4TPa2fay1DcZcqbvSSsJerCwisJZxV/vc5vQ0D/B5k7DxXLkIp9MNyZIi +UGyP4/bSC6Z8PGYQS/l4wpVd6UIwUbm7tmV4nnXkmoW9D0ZGuUOli83VnK4u2hYAszy7kb09bgPq +ATB6e++kugoPCcAY703FsIhBhCv5Gnflg8XALDb7vW3wLaYIn+S/dzUolxRh2FyiRMZbV5FnafZ0 +aGpZiGuAsuWmHxux4eXrRvTmpbgRy9IvMG+uaJZBh29uWT6HTi3FjBl0uoyhhXPo7DPoEE9eQQ6d +Zacog84yW9BjDp19Bp06W3CZHDr7DDqN1rdEDp19Bp0mW3CJHDr7DDqbbEFPOXT2GXQoW3AFOXT2 +7cTc6qVz6AwbV5NBJ1sWS+bQ2WfQIX3MOYdOE5Bsk2F2ESyZadvWMfDWmUC6YBcXQzL19BacA7d3 +3eVLlXQ28sLBsAW99mviHHDr6X0saKW9t6VTnfEV9AEbC+Npb1dDrtpcUVnGh9wkg3W+OjdOThTt +GZ8dMPs4LHfzQ74+p8w51/PTea6M+8U90hPeh2SR+ejgubIbklnKHJyLp6Q5V7ymqAsFUWJ7vCVQ +zTyFguD4MdNgEO9uYyunMboZbGl/1X1sy35qPpfJbtpISK+OQUTJYM2X9RjjZDerYxutleSU7GZt +n9ofOKi4ZdE2GERjmjqZIUVdNoMmU9gdMG0IFmk8sWlS306Zj+54VqPkyehFu9LK7G3S1iGUnlJM +Ue7bqcusQ2fbHiDL7Cxb1seMrjMnx2FPGOvcJODba9Og2QVOrMqWapdlFphKU9LngTmqXa7z+OZO +MfAe8viaTvkvWxqnlXVqmnUSjL0qbYyBDx58blkNKmOWomm9fo4x8K6jCNplrQfTdP3c5vEJE6ec +GDti0EanQ2AryxCdKCcfVpkpXoA5U7x7jGkdrEtizDFN1P0kFY62EMa0jl8qd3cf0wY6VXSB9SaZ +XO50WYPP12hmyVv9ytxvaZ8vpwNhAaC3qZXIJiDeqBcS/vNmu7srLow92eJzMPY+Kq6NPSsA+hjF +BUA4XY0C1lm+VcNdqtxCK/RKOMsXSaUx3xYwxc3ZyeCzdUnDrDQLI85A9nY5cj6HNGcXR55oQvZX +nvgM5pWNHpmaGkL5Q4WZC5SrTkasKPnryJt7x8RUwpqSQ4KcgetYZ0TNTKX5AvrYkdsdr+x3S33s +68ibe8c6zU4fQbQwnj4dPA0+nSlhTQIePTKaIWnykcGgKC/uD5shaTezsxSzwRPjdkj20enOSXF2 +Q9Lf3RHX+X9xStIqPDLHyCOzZJQa0IS3XXhkxDM+h/Sc7VR8ZxmPjMreP17eIwMAhGyiOzykoS3i +kTFkCy7vkYFpaDqPjFVGqlN+HuPJI2Pq5z92kZ7jLjkHpuiBDedMye7C92CpDkKrLJ8oyrJ13Lgb +ZZk+vI5suSAG+5zE8clqIhnguqQug6tx6oCppUIOMb1u0tAWDGBXyxeYQGbtXfKQPmYIXTDNFnTK +q/McNGuMUEV5dS7j9Wzz6lSpozaZws5O0BPbS6pUu1elW9qG6l0Y7yKFz1wKOinn3SowaTX5cLCX +VcTU2efDeb9/bJF8OLMo6IvBqvPhlsiz8JAPZxehurp8OOi1XnIHusiHM7kR1DKJa/F8OE00lPRN +cNX5cPp7R3FG3Krz4RxvCVhJPpzmxMpFqOVi+XB6W8zqWAdmsi2fWQ8F3MpiIgEobUyklW7pJiby +ZuQqJtJp70979LJqQB4FSCyfjY7gRJ1W3yUcN3kkllCwPobgrCCTyxDJYBMD78zRYHKdtUPMGO+s +qmVjEfEc/N41RDwHvx0WQrcJLb09dzfLbEMl+UjlVVh2GwJgttfKmPExy214P3a7DW20cYhvb/ai +KaGt5jZgBMfb9rHIRwZwVpIIWUi4k2KOcKyvBLa4TcsqzNp4JbDjbWhar7TutsZw1OjDgsln9hc7 +ORrUckYqublogIhqzlYXCy+UkdrYfHWRROoyI7Wx2XTjMnBI9VtJRurT92oyUiGcVWSkwnyx5TNS +IZRVZKRCOO6ugdaZxGZxfWiDWF+a6jnIKBwTV1+7De+W3oa6VDhzPrbqVDgUz28b0bOKVDjTdVl5 +Ktzifkstxuxtdw925RKpcOo7iFAy3C9JhTPxKvyCVDhz/5hL++zeTjFUswL1/cl2iU+flrGqbm6E +1+pj+biDWeQ20AuCYl15FF04kCEw65vtPOowhkuGvR4uqLLR710e4djdzgtYuZnIU3pxTm7W59U9 +WV6HoxcOknfURDwo+xdWjYua9SeuASpxmT7/LPdvGq+Frfa8WEpuZ15K9fRFMZOYBQHnL9UP+XtU +NrzwUJxkshWufpzPxVv5fC5xAosQ1MaSOAr0tUMWPU7aXCyzrDNoJYk5So/WeWfCZepCTV7aZLe9 +1vmp2vms6pT93A3sb4ysMuyY+zu7ZLd2wrJTolTP2WXYBc67pw2rTt9sOi3HkqpO9blYqchU5YXT +J7sxd59VuTKhLgVsM2SX7EbGdZ1q6/HtDawy7LitrW9u/mSV7PZol3U2sM+wG9Xrlp3uVDufbatO +O/b1+C7vrDstnj2WLdG7PaT3Xq06vdRm2KFVBRtWnDX6JdJ5ymW7PbN22Kugack8VV1BZMIXuJ0o +OquciSJ6JllJ6dK8rxeodr5jFyG3Wg02MsRz0ZwRXeyMVpPa4xyhqveaWNex+nYxJNW5mM2gnIJT +neI8sPW6ykpyZmVHTO5UceFdsqsk58kL91hwHSLpkA2J7oT0ENfnVETONq7PPT05FJGznJ9Z3Ten +YiNu5+dca8A10p3qjOjuUluifpz7/VLuWBcisgx3dVuAzt7Tu0g23WJ+GK/ZdGZ2gFSLc3XZdC7v +h1kym87MJ6jfL8tn05nl0i2a+WidTWfmizePtF8mm06DFnHPmt4/tlQ2nRkohxtCFsimW1Aie8ym +MzunkWXlyrLpzHLp1Pb+arLpzHLpXMb2eMimM/O1SxXYV5dNZ7a6yNO70mw6M+VGHTu6mmw6s1w6 +i9vml8imMw7pc8taU1o0m85MOfUFVp1NZ7Z+JtFQS2bT6UE51hReKJvOSrdcbTade4wtk02nA6U/ +E19RNt1CGPOcTWebY7WybDrz3OpVZ9OZAQC9rDibzuy0RBcDv4JsOjP2oLVeV5FN53AysqJsOmf5 +sopsOjNkKNr4qrLpnDK5VpNNZ5ZLZ1mPb3kDMKYYgJr6Yp6ubrKu4mUsUqmvzeEy8enbYbNrkM+M +rGrZLF6vzjCkGTzlWXW9Omvtwh2eZpGgJzwpWNJEQsKcTEfFwiUJaBIULLKerQalG5JbVuCiupz2 +YGqhIUGMgUF5KrtsNyTzQApLDmODJ5uyyxYsE0oxrUV0SB5PdRYRvZ0cOxQ2t/fMydWy7ArdLV3m +TnXPlUuVfJEyd5bV5U5c5Sq5LHNnlcnlLpHOVYCEfXyyUuhuubUq34/dVJmx9VK5KnPn6FGEiFm6 +zJ2ow9gXulu6zB3OfXModOfu8Gh8soJ7rujDa9J+Ed3nWZysLERpfKKo3Avn8oCpHYTd0qflKQ8s +UOcYe+hEnzCNDhrPth54V4l0biKafc4ZhtZBHK7zC0EvNmGHHoLIIHYsXX9aSnZXYQv0vBXU5xPB +S1Mt52x2N5TVeU/5YrBgYpcmGgoQlUM8uOtoKADKMX7MdTQUAOYuots+sBnxvpVkPi5/FAIrCtpc +By6uvks4rmq7mkFRRXbVVrEDERRDJrtpprBzLjsC5iqx1qoGhD6xtjY0JtbWhqu7FRACW0khY0Rj +YLRumJladlmism6GSsd6r3Yx1LvGI12YiWeMoLa1xK1iqDvT3koyU+Sbj71rEkZQ1fmqKhiCFxfW +R8Su9/61p0LVVqdvsPDa0uoEhmIX1ekBzgpuCcBwlq1WjaFIm9DshkNvsarXLhIZPJ3whiMm2/DG +RSKDKw/80hXupPxKqxp3C2xDk+CKRetWe6twZ5f5uMQ2lAhNrHC3kkp5jvlE7irlLZtPJFfKW34b +2lS40+YluckPWaTCnV29V1jjznuFO7e3msPsp+UTa5++FTXHynp1nVgLgDmrOT43ig6uTbdYYq0+ +85Fd1n8E8wtPTdOhvd1zheAswDcNd0RAOCvJ5zwl3NlijnCsc2F1SUw+p2smULk8L/ntZklM6lNR +yCCihm2YCjkshAu/llT3zWUak5skpuDBi94SVUkxN2lM2kk6+E4VUPK6WKYxpUKuMtRtzXZ5V6ZC +bnalmySm4MFQr3wvalfeeUpisooggrUTbSStN8XwTszhXeJWfp1iaHJZ4t09rgGxig== + + + HNd83PpWMWi/eK1I56ncI0KltT52v7qrqe7R6duKclzvLa+m8q7DNKeeyj06VMpLLJjjqtqfchiG +i6xn5xxXMCTXWc92Oa6iBwguRJU3709S/WDGW+WgXuiR+Vzi+Law1Tmu+QKFw0itfjB6i3DgV/kC +ZfeV7p5KbSqY3ixgwYNcuyrfsfhLk4R3dnil7lSTD+cLTLdu7i/UriptHbZU/vHeIh8ubJ2EN5m/ +pUgtT9al4RG7Vrl/3NY2fxV+tkrCe7LsFMxlszSmLedKlLceri07DR414x9WddjCSqdyJpeC4AuW +UnWqTU2bBvkdpY4grctyDIcOH/tmnfoCEMH6mnOaNLyGPvdPjd6T/QuLTrmtAHNWeFN8sPqMuFeb +TsvbnHWn5cutB7NOUd03oaJJrdR3emVXR/DkxrrTYvG6pInsAt1uw/dR+ZeYhDnfPUhoV9+iHZ0n +LNup8yuJt91U1gXESGo0KypiEsz5ntErnfJhjejt0QrPvI2fWBZ0LsMmAVLZMDoN0lQxcw6cdCGb +AewDfWKTo4fEOiXJGFplOSRIydaDyrtJbXJObJquqjILcug6VGZx60kq2IdWWS6doTIL6KDmJQTN +LutOd/PkEllpDhGaGEs+d/SkO/TyOj/Zaw3z7jxXWbQYkiFKS79fXCPdU5SWL2A3KGs/sbchAW5p +HacljscQG6tjV8Wn9K728LporJmymCkBYB+5uPrawQf7UlzV5Y33sQ13Nxy6yEaydS+7PeV5KS5z +E62Sk2i4Mm6hZDfzI2tP91q/FBf0LGtv0YRZgMteQmt2V5xlvpiT1WK8K87GADL3j2mDRkyOWBsl +T/UOrDlMaWU2cqOk5zCLnnrjhDurfYxOrJzL12lGpvfzO7vsUD0+S68K820IIOgJE+/6iEXtp+DB +nfXhoLdEMkM9iyXKstlnMnnKsUp6uudANSRd/ku7bOc7dtTGNUNSheqLp9WqXesxFbC37SKVU33P +lU0qoFNJY4f1U07e22XnRB3XxKCra2xaZcYDMKcqOkF9dq0NMJ1UWQ5jjrk87iepPblcEmOO9XQ8 +YazKPFkAM6QLm2mHIsYWzAJ0mwPo+h4SqwQxVzmANtHpLrIA3eYAGv3JXrIA3eYAqm849J4F6DYH +EHmtF84C1JCKjYWpj4P1lgXoNgcQYmzxLEAFn/Z8Q5tj5TUL0G0OoGwjL5QFaDEkQw6g+rwSj8c4 +q+WL8rmvyLZMUT7VXH5hUT6DV+GXFOVzqsi2mqJ8OGfEXkFZviifL2CiFa68KJ+xPvKvKMpnXR95 +lUX5XNWvXKYon9qrAAfFWQ5KRJFTarB1Vb/l74Y6XsXdUC7r+rm6G2rpun6qqa3gbiirun7e4pQW +retnX9VvobuhTOr62XuFzC1x73X9zInP9m6oBer6OVPyKur62UeGyJ6rJev6OWVyrciha1vVzxfw +5NC1rOtnPzWd72Lhun6agRiq+i1QAcS0rp/9hMwiVBep62eajmh3q7l7xLjOlDW9C3qBun72N3/J +Z+JL1vWzFXR5JMVWUNfP3i3s6QYqm7p+9qauaRT0AnX9zNIkla23XD2+FeS8e6rrZw8F+vlXUdfP +/kDF5xrOMonv+ozURev6maiaqqp+6uoMxBJ1/XTbkNBW9dPc2eU5PYWQ6/o55r2upK6ffVU/mZKX +rOtnH3Ctykhdqq6fkr9lRou6e64Wrutnj0Ckwa6grp/NXpv26BXV49u1h+K6Hp9DOTnX9fiWqusn +QzHdPl6zOQx1/WzyHhyjbTte6/rZa/LwxoNV1PWzkuE3xpPExfK3XKjz0kmi0zZ0qutnf96sjSJY +vK6fFtt6a3HRenzegjSs6/GtYPvIVf2Wr8fnJonJ6fYGY6yGt1J8+ozU5er6aRzbhqp+OGNo+bp+ +cqqUXV3Rpev62as5FjTmua6ffVW/pW9tEuv6Lenrc1nXz0Xe6wrq+tlX9fNcj2+hLFwdtzTW9Vs8 +GV5V1U/Vy1J1/YyuZHVVP6tbzrzW9bMP79JJsYXr+tkHOul8SgvX9TNZF1VVP/t74dzX9Vvcb6nF +mPecJwu7com6fgrjMqvqt3D0oK6uny1FqCqALFfXz14xxNbr8nX97BNiRYm8dF0/7ST1Vf0M+pjr +m6y0df2slSCswzjcZOWyrp8rHWbpun7qlTQe4Nhk11rsT/O6fvbCwTaLc2UJsVjuJ0zEw4OdjnZ+ +bR7xob9X6hPfqKiTleCptWvXPvBel7aooSaJxpTTm/TBWJ0Hj31TYlchjYSMjxTEEInzDifj80xj +iVanMPeNmn5uALFyvBF5PNsmEnc9HjeC+VQb26fpozgRGm4kWo9jhp58HpfS/efk5fVuKDYIB3Pf +OaLycZbd+p7nuI2nRpsGv94yAVbYq+ycnn9fsd+9+0dfgGfjTEs4Ld3FT+KTDbZaZt5yV73rw3bt +lLv9rHfO2O+bUOd9+zYbZgpfm/Wrk16qv3836hyGht+v/HdgkhlyZxu3Z4fBbTpU5gLvj0dH4fnn +1iMzeuqkxL2PcjvT1/XazUY88pLZoD6+byL7dDBDlHInOaL03jomytzO1WTylgxNpsLt0XTrhWtO +2ebjhZxpWY8cJGK3cbqa3JTS3r4Sk+nTCBabS27h3GojD9Hkl+49VF+T2dblGBrUcglIWE9y/kYG +drOZ6rEZshAywHRnO3Bd6O0Ny7mijMZQI9i52Lp5qKe3h5NEaYdiPuZb/fZGG2aSHkvJoRvz6Jg5 +g/Fqp0OUk7iRLdXrAWK700b2/sVIq7KPddsHTO0ir0qaU/ytqqkBtmaGhzQXyM99gcJDqXOHCmjm +n8tXd9xZvr2ZScz2jzOJaXuvlNzqXRRvM/QLQNswXe7f3D1lK9xGE8C5+ZbA4vKZITLS42Eq4/1L +Zq+6MUGzyg5GkJKzJ7e3r5HizV0F/gITvujHYdJuFJv1afZ+giwnIjELwWiE1xnmxAk2HpR+kSHk +OwYY4YfgT34XZf0ChnM0Bn8eRBGH2QoCKfY4AQ/ycenDUqJUpE4FALZCRArRwLwUqhwdkdHg56DY +6n0niUSaD6OBwsE9k7t5ci/fbSRI8OIgonrR2M4f+ALSq3xMeUXlHq4PpRdHCeUFvb33kZVenJPy +ixcRbeWDXeWZ0jOU++V8VPUK9i3CKYNdDzCxC2b6FIFzDlPP0y/AAMtXJLoJh6wcXtFgupe7quk2 +PyIQs5cA5QejHtna5lPyuRhghZC8cmQrdkDCRgmYtzQgW4dHEG2XpPjN5TUCC5Na97dgzxGYW4zE +0jYVjjFQ+6/HlE6p8GFmD/eyBw+8r3L9+Mdu9qL1Xi2cHG3UFJKUjwXyWsM1oDU4c1S4Uto3gwco +eVGIl9UDGWKOnV1sd8rPD8JHtjbf7hYf2hcEnBWJqBdT8hv1PH/JiKtx/0JL5FVnVFMvHPItaR/c +xhACqcJlHkrA24RE9rcAdvMZ1ma7JUV1l70VtYsR/E3LvxgMorg34MCfDyLE11YJLslDQvr6gZB/ +karRvFEvXWk0DzR64QuIrwq9bXEf9L5YPBetpNWeme5o2IzMBSzYDJCVkNHo2Ezq+XwUKt7mTo9z +4f4E5vRzlVyRiNeNbEZfpTeIqA1wAQHd6BqWz8UAtxR3/F0vgkkyd/cyBbPajCe6mxc79HZyMCOI +UHwqThcwFxQ3jdyT4E8mjLKCyeJTBv6ZAhtp+ysN+UZUtfpP4JsbSBOVOFKDYKRKHBnuZPklDg3z +SsLCBVMhZILcUblT0uxJCIaKfpNRYvjmC0gLdbKL9100H2jKz8T9C3Q4uJ1PwMLzN5X8Wy/b1jCh +KkGwzRO4ECcqOiDLuW+ocXycI4ydgQ7uR4gTw6k/ZUW1BLAe/AwzV8hwsKSxlUOKc9Y00l5axpD2 +DL46hWpOBghwYY71mh12VFIpd+jZZj67CT67msHGN5q7DyRNKawGEe0WdSAi+e3DoiygK1QoeU8r +Kht6trmZPiwT7cCwMJkcjHbVKgTQD9C9CqWAAoLobLIJHYi7u4usDKIb0myVch8iNYTXr/i0F6N3 +9h5JgONCFFKOZFeip5DG4vjp8/QVbvGnqcRmXmcazG8FxTLH1MelrCk9K0oSKjANVc1N+OIe4U6l +JwcVpWU3c7vbkHSTA0pSS/D9DED8bTJlfbFlWAhXWpf5Bux0A68AM33cgVKs9Loh3ZGR3BLH078+ +Uyvv99GhiLFcGDo98KUQlef45tc1wFOkBDqNx9AGN94WAb1wYGTliIiEwrQmI+FJjYT547mMBN2N +HREVCh4ndFN1d4eMAl8gnH9ov0hIAONRI4GfWCJBQsHutgoFh/nvkQoFh6HCBKEAULLYrVT/Gy2J +MxIAE+olcKc0f94TUUDNSTM6wLdq3GuRkFAI+25jlChiJExy948KEkLN7asnCzoQr6OVq5YDPmZG +SrYgIt5pURs5LJ0DKKPwPIaYGQC0Lq5BxBfcUkp8cphYcjWi1jSNOL80ChuajkYtQLjCA+L80biL +adCZy1BIBNE4PNeOgbQfA7YrbflTlJJAcFvKakw3yyd5TbvErtIOlkq/sKjzDhYntCyNhZenscSC +Y1DRGLksjYWXp7FdSxAuAGAai7kgUw0I/TQcUCnSmC0miCUpIhHxBVxgwhaEG87nC9iCsEKlq9WA +AOJqb89CRJVwTdhI7puCIJadhmpn+AKLTYPyNAa09/WjoJ33Z4U5OM1H8BgmaVZz6dcbpZcBikR2 +iwkq6n0MOm5JLUtUVNyMIjxxS8qNcmMmhxRuSS27xSlS+yel42MULRoLoXYdGKSZKfbIIKtM0fTT +5dsQtiIUm674ktoXzb7zzlC0be96Meq10o4SicZ3DFnD8I6I6WcMfh1HNgh9eL2JbL+gdJy4FURB +P8gUxt412RTGvrXgwdU3+DMTw38+TzvIUAzS2/v7b6XX8COq//KS+ZDN1ZDs9Xsm2qFQSrJPU7sq +x5pqBulMVOVWCx5W09KLUlx5ge67kF0wwNhVedwOb8Y5yVOWQtMIq3suZyIqt5qq53JJcei9oJrQ +yAtXTYhehfI5Ad0DEZyZAoxnCltyzZdAQ5ruZQQ7zppjEpL9ZUxWr7epYDoEkxov46JvjctDyrkk +cHW5CdmqnKMHItjWwyMp+kTvS5HEaa0H+UEdm/9UmEu1pU7rcdwLEd4WCKpfCxSjyfBLZo+42VYM +b0RjkumNvU+GOK3/v7dr/0tbWeJ/Qf6HUKvyTLKbbB6+qoIILSoVUUErgqRooaA87jn95fztd2Z3 +SQKi5WjvrZ/K7pBMsvPa3e9MYrB7P9OX4LiIn/IiRyPCkegro61UdXNo71St4z3nWzsuobh6JSbt +t3ZFA23chuZFE5N2N0RILtJRxK2wjaHiQpNgW71IBAyUuzthstWrUtmaXN3wNCA9SDQbskU7DBkw +zgBsrFHfRY51Dd+LMqCNXskQZzcmp5L3beLyPgDWaBRx22z/CL6wAi9oBWOp89RSZA== + + + J74mMAJhbdu1uAC6Dq73uMcnp7he5VEeAo6dksi5FQ+R8wDsXueYElYdi9VFIcEtD8tZcGYopALw +Bxx7N/aNCxjzo2n++j7wsK2i/nA51gRU9ZDeSPHoZH7cPPi86KkdZRWc7/iLsNrgF35VlXvkOaCd +I/lzGDtHnHayPMLEIcK0uvu9D/08Sd84PpcnH8sXI8S95jwejfOIyxaCmSvURA6rcZfjXui4EkI7 +7FgosWNNpu/AUv/ZUVziMNWlhqPqp5OePzwZPnQe+mpa2VT0vSIh1X57kB/6/pn/9zg3uJv89Ptj +dUPV9yrZYtFlOf9u0PZVXoPCbp0IxiCgNVleE81EztTdCBQ699077BZWTrebue9GbSdSlcO3+OuP +Z0+x9P0PWJ3EUnfaaizdaF/F0jRficULozR2awKGCEb2PB92C0ZiJ1dy/nB/cpA6Kl3MAeh8tvRu +zw63ldWDi33/dFcfdbb0wl79S66eP6/s6mNjwJGKeXBQjDRIVi7IbQ6HdLwWS2wdW7GMvn6OOc4c +jOVjztVj6cTuLlI/x1JfPxzj+I7xi0+xzJ7ZjqWPLgux5NPKEO3flQhSfoKFcjQloeEwf5NvNKY+ +WB5wx1CEC5F0p4PI7vmTjLEIEuPZAUis8y5WosVl64eflF4E1hP1It7diKM3FjIyduCLPSSL79WN +8RRxLkZmKqPQHHvTKWz5DFSYf1JW/3cZqDD/JFDv5TNQ2IWlRQy65d2Qd0Oi7OU8XzIkIbD5+9zQ +MAvv8mqqkgv+fwKqLZ/oONem4QJPH6Fb5WyTQjl6+coM5sNUJBfVXtNgQqqVwnn8dnoVbux1kFhO +b26tbXT669X81oH1Yw4GxXqEr9HiqmmFVVAL4MEd9rMhx0X8xLMNS3OcvseYc0x8dr967mF+d90/ +yxXb2zHpTbVLEqSZ6Ez+JtFrrEwnzaYVDL0ZNa/WCY+naRlyW1Vdmn3r0iCtUjEBLVhuiHmldUN3 +vCIFXbWaWOsg222Ls5Cq7Z5yjhleAAXdy+kyqXtlTFs3obW1oku5btuMfHETMxswFj673x49rfKx +zNZjZKM1VGC10TATRIHfhxmMlhBoMJpsybKKne4nEWvST48ni8NMEMe4n7fX9DUJ44vp+Kgvh3vi +J6fr7PXtSlKmtyE08WU3mrMhl90XB00x10JwwRmoEBcTsz/q4n6rkJQhhXzQaS5zleLp7WBaz8hn +gHmOG0tkLuX66/BLQj6DxvL64jJBiD9Tg8Q602mxKUQGK46pMG1ujS5y6vG5BbqYmsVeAGJNkGjS +otn1x6yR+7w1MJ5HHZhfZJppO8kzbCIXleJ6E7uewxuOdR9n5Ez9uKEvnZMUvJ892RG8+0OoMbQn +LP0Ybus/wi3iosQOvi366zSxM0zN5YaGw61PlSj2YRSv09osi/udaiN5ECSxqnNJLKStRFNYdfp5 +LoVlHGydCAYi4/X1OYvJDIvCWiHqKlZlfTpfY940fUzxtaJoT4UUtrSApnMaf3fhDlhtuvKE68uh +CDMwOdbnFq1v3xbHf/IaR5SJzFrFZCZn8+dpkD6qvZI+Qs/5ffpIZogX5U7Eu1WXzJ0syJxEMExl +9U0QB3+poRDBTVQEPKMnRVAPRQBjwfuJCgEX+r8RQnPrOBSBedUjbigCXGdrc2nE8N3rywhhGaT/ +dTya/1Hk13Nor6YR8Q/FTaV4PWdIS2Yi8e9SvcMWp08dvHQXy91DY/g6A6GXV1m0Ru9zqcP7SeCV +b9RG+fpxCZuGaBlhMWfT5cYLbrGsKMv+KIyWb0rM7pQHsd/fQ21afbj4LobTygWr9jNkYRSOancz +afDrwH5rEcUb+W+F0zkb468xeI+NVfrvtjF//M576MXebWPn/XfbWG3wr0LvcwatYWBjr5hI/bVh +3C8tyhdtrDt5nzZqjYi7CoktksSrLFr/LvLhLDbPwh++Txu1+9GcSUmJLW9Ute4bDHvmfUw7tf7k +ncMYxhZ5Buxflh/G5MMb7yFYJ9dXVn7nn3R0HbKIrZ/fV6L30Gq9PAdEZuTXJNHyn95zDxgtW/fv +NKpWd/TeaNnqj38b6l6dh1pPk8g6+U0u3prEot27lQ8z3bUVvlUQSDGWI35KITphzyEkhj/edfkC +M9zTRbZ9zY8/r8VWfn27xqZVmA2+ZcxMq16vR2JfGRStIlQtW3GB5sFWODm7FeY747TsZjW+b9aC +0/QAYL8O4WCUGGxsI4jbn8tAhfknfpX/UQYqzD8psxkohMEOq5SjYlGgp5xNceBMAj3lYma6SZ0k +5S6wXNIEtobvOofuqYGrfwK/2qgXvXwp2JqfzvqaLO3+qCWmuagi12UqihTWTjR+FXPfNd1N/ybx +PXtv50/2e+6KG4GuBUwLG2/5nPmzFEK4e6+d6v+K4yJ+yizHqhFytKvbG9m96trmbfbe+fK4d7bX +vxBQ3P5V8kYmmu4ug4rpMzN8diGq3VYpHcFgmxKAbJ2KZxvwCfeEaDU/nAsALoSG6H7dLGBupMYT +LbwlFdvqMIGtCYS2W9VEjSMJqp4zQVooE8Vlu00aAdYiiHC3Y03xozqTY7k0VvjWLITVxNOGCwus +U3+uvJqjCosLrP9gebWy+mKB9R8srxa5qIUF1qm3lFeP/tlRNsGkioQ0DvrtaI5JWV0FSsUfTx7x +ANbY9zsP/VLzlz9UiCp+DPiBT6pSw1IJM1ViUCAxpJdaSrzVm/gJtdRXVhv63nCce7gbPwz6zeEv +dQNIRNX3B4OeGt8rVvIX6sHfj4PhWOVXUM8GarZSSWBe69Xjzh9GD62eP3O8fnlUqhZz6oYqb2AT +TyVGA24B6OIgGHVDMdQ9+H/5F/w6UQzNgH8mjOrlhvi5bCqGHD2c/Qs6n6HxA0h/qZZ6pF59M9Q2 +Mj5VqKt5hgmCMTVmm0z9qVBHc4nBVGJpjs1sldoaJv8I05hpgiQtjXmmi33Ls201qxBPo9Sy8QTT +sh389Azqqi7w8UyQu6MZDqOqCYd5lgdnUKoRahA1QzXXNKFhmpptg2qI5lHbsVWTaIRRVJdmMtuC +U0wDLgeXJ0SzbM9RqQenMg90q9kWgbucG0dWyb+gVExn6sX+GGTeHrR8tdxrwpdq9v6h11bPmh0h +fuOVY349+lEdaY7jOQyVQF2PEm+RfqDJHMos/NIlzHZtVBKImlpiULbjOCh8W2PEYzgsy6EwTJCy +jT3PASrI3vRM0WdwRZAksLNQGyBRD+3b0TzXMUH2zEJbB91YIHXVgsOYI0TvMMfF2zBtj1gqCNZ0 +4domnIicQJAOhWt5GmM2Fz1QqGd6qAz4VNE+mGfhTRu2Y6nzg/j/ST45AeG7tgHWheMBc/RQvo7r +McsN7b+pEFuzPcNTQWyEEgJyRooBR5uaYXmuWkIC8QgKCo6AQ6EPqmMqA7KFRiz74Awm4/Y1T+E8 +DGITFBR4hovCd11UDjiEZxFUn+WhUhgqyUXRzlFKSEG5c4oH3scpNt40Gjk08Tvecgw80RZcpp0S +WpBlEStgANojxDKxT1A+4DjUwQGBwg2D63eOUlpAASuhzON2BkZD0Go8Cm4ISndQXOCwzKU4cpuA +34K/zhJKSLCpx63Igg9O4NLxwIFdCwyRgjzBVCFsULBZ6EPTMD0Dhxjp8DM9F27PhBERwi3SAsVy +dwMpwhhBrY6DBgCjC9ol9BbHtE01g0cKf3E103bwVNcjPALNmUr2mfGUlO8wv+QCxgTNAETDI6fB +wLORYrkuF5KHIwGHMTEA4hckOqpZAhez56EIHEMK2QBVgg8TMCzsc5cFERJGZFScoXAOeCrohUKU +QW1bPCxSMU6KgQH1CMHYcIVzRwklTjA9wgkY97FPXVP0MQZBn+AgoY9qEiyilBIKgll8PiCU4QQC +JsItEhRshbbLorbLpKm7jGEHmw76oWja6ADy+GmH69NyQZ9wJYPPSTYYBnP5tAExAbvgA7M+O0Mp +BRSmmSYEQAyghHkU4oDF3QX6jFAMj3gltOx5CvCAuQdsFvTu2CBllaJawZsJN2hTnbeU7DPbQZtK +VpXSvljJwLqGrx4yGVjklJsd/2zYfOjBuqYzav7HV5v9/mDcHPuP8I3aGfqj8WDoq6P7wV9IgVOm +h8MK6SSv/Bce3iIe + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/originals/SVG_Right_overlays/Broken_right.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/originals/SVG_Right_overlays/Broken_right.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,1569 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + + eJzsvWuTHMlxIPgL8j/0faAZaXdoZcYzg7d2ZvVqLW/Bh3FIiTLZ2hg4Aw2xiwbmMBjqeL/+/B0e +WdVAAyhJFLc7Dd0N7yhPD48ID3+Fx0/+t9989Wz37ds/vnwWb+eb6Sc/Obx7+eL923c/vyHozS9e +v/7xh/fvEPTT3/7sZkm3MzTa/WL9Whr+w8t3P7x6++bn9Cf64x1++qdfvfjjy5dvXtzsfnj94v5n +Nz/9Gfzld6/ev34Jf9u/e/s/X775+t2r7/70/vaHP3/3M30vIDq+eA9NluXv5vB3YV7mm7n9PBds +8OLNn1/88MOr/w//XOIaAbZ/++Obb1+9+W7/9v9F4M18EwP8hL/811e/ffnDw38+vv3mx/uXb97/ +5t3bb17+8MPh7eu37374+c3hLy/e3PzyxXfwlxc3//Ty9eu3/3qzf/3im/85QZfz13evXr+E3t2/ +eH+zUF93v1jC1/sfX73+9lc/3v/xJfQ7lorg+DWh/P0PgAvQ4u8Irl//4h4gX718/x7Ighcivw6/ +/Kf/dgAmv72ndgC8mW+XmwV+/vQ3u1/97te/OsHr2s0B2fS/01/hf/NtykOLsGTfJBTEgD9ck6FF +hM/ftgFHrNzgt3+/95whkrDhP//25XevaDrASP33n0lP3739/v7Fu//5AzcDFsfAf/ndy/vvX8N4 +Cv9v882S8Zv+Jq2Aq9TiWVzrzbNQIvw5tnITmrXp4/Xyz69e/uvPb3719s1LHpTdu/df8aRIaZ75 +O//ltz++fvnu929evQfKCoIaj8ov33778jW0t8/fvX7x3Q/ayaV/5wa/e/Huu5fvYTq9ff3je5rq +q74BRv35i7+8xKmz8At+/f3LN797+w9E47O63MYIbM6Nf8KQxLLelAiju9Ir0gy9nG9m924aeUaP +yBCVvgOm1k9+A/Pn17ByXr35uVBYv/77d6++7XOqhpuVv1Enblf3r+k/phY6/v79yzdCPczlwy/d +3Jxvf/kVvPH05tvD23vk/g+45GAGvIHJ8frtd/w3+53+Ah//8Xumnv7/NQzUb969eoM4p1/RX9av +f/P6R/jT3797++P3v3jzL2+nn7Ks+d27F99As5tf//F/vPzmPcgMAfTfvvrx1fuXty9eff+zDyL6 +zesXb168uyE4fJiBz1/9Gf7yAki54Y/BXzrs40iPL/8Fln7/LENPb/788vXb7192uEFevPn25h9f +vPv+46hhGN45DPRf/fmI3r54/yeQUi/ffPuDkcX/HTvKsI/j++obnBTvbvbvfvzhTze/e/v2taEd +/2TYBUxQbP/X8Y7f0Afe/PoNM+j8TdJg+yYQCH91b4HWD78B/vjXjP3w4vXrV9+9e/H9n159c+kF +F/5ub+K/fcrE+sv9H9++fvXDfZ9PDvKbF+/ev/rm9cuv/vLD+5f3H8KG3PiXV2++hYlIQqdT+/b+ +e1Qrbr7604vvXxLO93+6o5ZfGcL8NQhGL/qePfuATAzxZv/G/f3v37349hWIW9SUXv/48ua38N8X +r28U/LPpMhjEPSD6dvrn6b9MM34tc5zTnOcKzzq3eTfv5+N8mu+WBbSFuKQlL2WpS1t2y345LMfl +FOawhBBSKKHCs4YWdmEfDlM4hlO4i3NcYsC9LJZYQQdrcRf38QDPMZ7iXZrTkiI8GZ6Samppl/bp +kI7plO4y0JKXHHLMaco5F3hqXnPLu7zPh3zKd2UuSwENoMCn4c9l+r+0M/1rsX/Lxf+h1hjse5R/ +QBqxI855Iq7gP/1e5F+S3wpwrADP9PtK/MN/zf22g397+L6b6MeB2HuAf8hk/g7MBnYjcfAFnQHV +Db7i0n/5L9Pd3d3p7nh3uNvf7e4aPOtdvSt3+S7dxbtwt9zNp7vT6XQ8HU770+7UTuupnsopn9Ip +nsJpgXfBx4+n4/F4OO6Pu+nYjuuxHssxH9MxHsNxAbLuDqfD8XA47A+7Qzush3ooh3xIMHThsADp +d/vT/rg/7Pf73b7t133dl33ep33ch2m/QP/udqfdcXfY7Xe7Xdutu7oru7xLu7gLuwVYcUdjdXdH +3cEOHalT2C3s2M46h92r1EXsJHYzUVexs9hd6DA+iOR0mqjn2PcD9R85gDxoxAfkBPICuZGJI8gT +5AryBZ/ZuIP8ga8JmIRsAkbB04hXK/ELOYY8Q66l3pnzr9Mjn+P2mc5BwqPHPPvzZ7oA3J0/0Jl0 +85Ov9++gTwW/Kj0rPE0eGMyypwfmBfABmXpXSXRUEBEgDCI9qcKShQ/z11rbVBs8u7qvMKWQiTAi +dyutmHWBB2TICoJiTSus9JXeudYVv9oKs2iFqbYeaAhOODXaPMHSApHUQostNRAOQF5t0Lq1tqMH +5meDOYxjRxMBZhUsQhBiMBMDzMcIszLB3MROAWU0lLj+aB0GehYSgfwkEIURRGGm3/B7ArGY6Sn0 +IAcKdoaEZYOfu4l+2eNL4ftevh/ogfUG308oTXE2B5JD9K4Y8AskKEhYfEAWgpQFgRfWiYRtI4G7 +C7AoQeIe4fsJvtPCANmL0ncB6YsYUMyCIIUxQVu4kjReoe8N5DFJ5AekDXKLlw/xD/mI/ES+NuIy +jmchvicYgQgUYVdnHBwYoiMM1gGGbIdNYRDrRCOaYXwjjfUC8vIOVyXMhAPMChyBBhOlwqTJMH0S +kBqAoTMsf5xkR5huexipBmgqTM08gdxPsAME4PwM8uEEK/IA+8MOSFpx8sGukWF/icC8BUT2HSz6 +I2wxexj0llZ4Q4HNJwF/AozkHFku4ZqmJ9oT5KHxOs78yGITeXMgYXHgrz09O3rahIw7EDMONPNx +2YBAzSRUEwlWFK2BxCs+MwnZOxK0KGqPJG5R4OLXbiK520j2ovStvBpBBqMUTiSJQRbDQzNtP5NI +RqGMYvlIohmFM4pnFNCNJdgFaXDhaY99puG/6yc99dIzXQSXRz75/Omy7p9t2t984Bd+AvwrN3m+ +rS1WsJoBAZi+X38+gv0P8PY0g/gM2LSkVuNFLCXAREaTfIWlTW3aOsOqU4z1NrYl3sR823LudF0f +NVEMS2tBR9ltABVsTRfRhlTnjGgLKImJnEigL0FjQbvcorp1A6pYJ/fKeIHW/dEUbdWAL6vQdy++ +fXnz/u3NP/4J1fhp838YqsBKM1KSQQTRL7GCinouPoGkFpZcx1+QynHSIZ4bxXOxs/zx8RfEYxNp +5N/1UNIwfyG6GdDVfHM9+gzhpwzs3797+fKNt4o2AMIq9pAJ0WRCdN6IUBWfJkCdjptIqwikY8yk +68oGenBbZ982YeMk6QtbNG7WM2zfuI3vYWNvsN9n0gMW0A1QT9jB9orqRgT95A52IDQl0BIJ89nX +1hI6b0Ayv0vQLAo2WGZ3QdTrgBbJoGSjdXEyPXs/WBmgWU+iUi+DqXGkrZG+s5HWxF7KYlehqRXF +ENPnE74e11eyHtF+ZAvyALoCGgJ3YkmyLWnWpGi+q2i8G20X9d3JKbuJlN1Cyu6Kqi7qufRWp52y +btpIKz2QPsq6aCAtNJMGusIM2cG8OsA8u4NZt8D8izATMxBQYbNvuPfvQRU4Au/vQFFYQGmIoEJk +oK6CgsF7uSmACymAaIbjVzJVkLrKajopg2ieNzLRd2Smi2JIxjo8Ew5rJMMr0XglUn1ZM0Wc3mxw +HdnJMsEFc6TFc0fdmqVrgd7Eiy3z3FjJUj6S5yGSWr2SxnyE6RhID67iaVA3A/aOjTCalvwFU5Wn +LU3gRaYzKcdkQ9K404OaxQXXQf/i+cgOgki9z2b5A7X0YdJJWSst6KsgtZQV0wVbknLK6ikqqKyi +gpJKH/6grdxFRxcciXVtHuodafL4rKLdVxleHGgecv7CicCTAvrhR0zYSIwUS2GVybAf/DU44sk8 +NqDIk9dm9NvAmE3kuInQLpMWziuvr7pxzfX1xlYm25eDbTmRaRlstXXDklfbbmtVil3JViXblGpV +4kfWiYxKNSsPZFaSkwDNSnrYrgzE2WTWZaFVXMXKxNXMluZ+OjM19WGTcxazkw1PNj3Z+GQD1D/E +gUl+fHBqfubX3yrCxX4u5thbeG+ZyK8Xxb9H8tFtP/23YttSpS2qyEKv7v/k2pvYb0HjQ2uiyGrY +u5WAyyA716VtOs55WWSb4UkPUx6mO8x53lqSbCnNpveJpnWwKc0uEpzJaGsfZQbr3JV9Z6IJu7MZ +epI5yZtPts1nJ5vPkaT1HVmPQSQ0b0EVpvkOTdA9WaS0DcFGtJD1GsmaLWTjrmT17sgQxq8TGstk +OC9kSuO2ksmNhmt2nY4redj2oiscQZTfoUuOdIlAD7rskH0kFcidx2uWNhZSRvZqjJ+OvBkcvWsD +TPu9OfLUhZfEvF/EoD+JEc/OT3V/FrHVo9jo7AQ9TWaY78Qer+INzaP6uFEddyLsWdx3xTFMLPVR +byTfy1Gk/+h1KRuvy+h3OZGL7EDust1k7pcVJgr7XzJNnWhemAVnMlnT7Is50lTbi0dmR/JuJb9M +BZuH1JxsDppITppAjppFVgnvrCdx2hzJccOPeCrKzp42sVRlfdScuc6Xux98uerJ7b5c9eR2X+6s +vtzpeDJ3rvpyuze3mTe3+3Oz8/wMHh/29kzO2XPB1XPBz3Pu6Rl8PRM6ewZ3j3f4OKcPPc35fdT3 +o94fnnV5tF+iuYKCcwgtatOYXaPPaXiIU5P8wPH5xKCAhQUeigpM28CAqDtbhcdUHprkJ3EusmtR +Zzb5FSea1ItN56NN5KYTmGZuVNeiOBeP5lxU92JlRW5ymty5HrcTV+NKrkZ0NrK7ER2O5HIkpyO7 +HY80A/YTeR/Z/4geSPRBFlKpEnkiI3kjAylbbBqh2s0TnOclTyId3B1rgIPj3oTCPAiFgwoFx7dq +Ptl0Jg+MfZMIARUDfv3r2p8HN63npThrPSOnC3z0XEzitA3kWvc83Ivztg3MS1P34hrHmFd7U5BX +UY2zqcSsEKPNfbfZJw6yU6zDLvH44NgmNDbRIpg/FhoTd3uf/V3h73P/wGJdB0/d6epMH+c7z3aR +zTQ+ODY7ErmrjUooYRIXeh+R5kaDx4Id6CcaBZ3CNnlHBpI+vmeFxaI8yya+U011GZXwO1HAVfkG +UibRu1Xj7oqMV2XCJp6zOjPUmaA4EJPZn6rbsHazknzdkcw9kBw+iaU9m5LD9nY2RQdVnd1kug7u +DbhHqLbT9Z1EG4zpPKLyoHSF97CAZaWJn70pTwdBe7Row52pU/oSfVGwqAXGJuWd+l59d5VQ5iob +IVOxkw2SlTBVxI6yiZ54R70TvUx1s66fBdmGkzxZnuI0tq61rWweTfRjNyhxTo2zp39Z0JQNfNbA +o+jg1bTww0YPT4MmvldT1GniuevikyjjR4ltqjaeTR/f2fS+e1Aj38uUplDlRiUfXEGXnEGjO0g1 +cnUJxcl5hVaZsjph2TG0mEaenU6uE+vgNwwJWbrsDsnvWCT+WCjDY7WQ45G9L4PjIA== + + + keOAXAeTZHvsaSKexG+k/oPuQeDRUh/CkUasZ38s5kZwOSBVvHh78yd4j0IwL1624VyHqDX7FY6T +uvEkaL3IRqbePPUxeC9Dk/j1zkk3kW/1bnKBbA1md9fDGNLWZ5Xgtnoiduu+P9MquqSsVF02Q6BM +nBXdZbGY46I/4h6a6NsgpimDJ4JsL0Qu5e84r5qm7qgb6E5cf+wE0qXWF1qYzO1THrfOYECONhI4 +Bt6Pij5UYfS4hfQNBL+GdSbdT+Kt6dkA7J45Tm6lPbRd7N2Kk+3CPJXZ7GBZdpNsFrJRXNgqdLPw +24Vbh37HQJE+DduGbhzJbR6F7JWtCN/Zsx/F+CSOdzfuzoO/Ew+++fDFnrrkxN8P9nO1FJg4iXqk +ltJpMKO7IV3FHFJTuhvTGuoWi2cyg3o0qTW0fR7W3oS0xbhW8zpPFphxoZkPpDf4BIfiozVqck9s +cw8qtlreXtHeyfpWdbuKFMhmiLMpLqaLauCLiJPZIt26fR7tOdizHx6WULuJvpFZ7WPqYzi8Z1Rp +VpVmVknYxwI/LvQzuTyrg+3Zuoc3l3PVrfVqakB2GVhiu09mvgeXkLWonuFSoE7Ooj+aXd9te7Hv +J1kKzZ7Vns7BYk92T7qQAAIzPLhncc/cn00a1ml4juMzHc6/9mfP7oGnnT+kO3IY5DznzzL+Hkj4 ++6BVM4mH4uMG/ta6Ge0bs/En82vpUlMzJw1ZRN2TpSbr1lxd2O6ZXBbR3jxW1ZmqcTBTvcm/N3Oo +WvwmTRcCOJxf5EM4EsSxXCN1AHgXgDgBJrFhTzK3yBcg1izbs+wQYKtWLVu2rbK5B1J3Ekxj2A2T +CYAGsGt9HH0tYVk9INU10S+wdQY61RM4g4ID/yHcog40JhRcFy0lFdRlhgbYbE65UbpJaY1yAcg0 +xyNHKc8NX5JhZAKmACyM21IUWrwNMBM6oVfFKjkuAWYmIggNcCHG0OYlD31flloQUpQJAbve83xu +SriNME98iss10RKlywo4BwShFEAxDFuGviI7GiGncz6MLbZb3NZuYsIEIEfpddESpV8+nVK5pRSh +BZmTwjVn6hY1p8CsNY55U0tY08CVRv4k/KWGnGhEZ2SLMqLewhswbWlpLhPmung/JSHm+as3L+nY +k2XEbCE922lzRACjYXxA4GAHBPB4QB0MyDs5HhApZF/68QA0HKcet99YGCexL+ImpHbJmHdBtSmf +xL7YWheHMxNebYtzE975pyZLPm5bS35wTXU7w/um9u0s43i6aHGozdFzJQ7d1neZEme5EujnV5eV +miLsuNpJwMA5r8wm6VaJWiZJohPlsKL+wO6rkwTp2GFVyMLYiYNKpkKQyZA1C0ImBJ8ZmeXUSD83 +spJd6rwLOkEmSXHO4mJws8SdIUnDKZJtVkLw3p/JbNJHuX8uGqary/khT8HJPAXBZfvUs9yDk+Ue +9Hx2dQrZdJq27k43q8Im22CbzT7ksmtSweSS2fPGmvX27Ml5kIKzZreez+NEEd0I8wLtVbRTj+Rs +DDQh6rF9bCqMk2F2h4j6dNA0+KNMhnkaBMY4Gbq3aXGJKkX9TTYlhkkxPeATHKfFdmLsN1H6nhiW +pwt5KqOIWTYpKkNC2NZptM7TVu7YTPGi5/JkuThdJpeVcnb2YfCT98kyOj6cpxzdHhi5wDmCswOF +ykmC/UkmR/vbSVDpuYfhgWyvaqe56BzX+QzndLXzQ3LRXKiSuEYTWbc/nL6HifxrC4ky3PdYht3B +NI2012H+1BGm5AJTERNom7rOYM5FmGsrzK9DPcFkijCJKoaIDusJqI0wNypMhwNMgAWGvVCexxEk +QQAJUGlcT7A9BBrRHaZquKW+guQ/HE9ghYcJVk6hdIsDeuHvFkqlKzAjd+i4urNTXf6I2uccUBuM +1emax9PQTJ0+fjztQ0l3Zpha/Hm6GIfTIy0+DuePs5wdZuknWaYLR1k+8SALhT85+NniOlncM1rE +80RHhjjPeKWTRRkmKWUb01mkE2Uc7ynneKVDTXzoCQ9EwXK6o3OLB0pB7um8ifKrFs0ufpoKT1Ph +aSo8TQU3FZy7ai3zTL4F0M5Ka2STt5ykFgnZn5fOt3zax+QMy6edzPqSU12feDLlq7f/8p7rBt38 +w6vv3rx8TwePLkH7mX3lwaQ8mJQH0zLN9AibH9/ykQOC52TKegtaZ7qp8RYU2/BJI3Pp8zREj/ns +bclLSFgbJy74gXizrrc1hvZpJDyM5vGUtPx5M3P85KdMlN+/efPi/uW3N98J6AZWHMyUi2CajuK7 +2VRfuGgzX3SxPGAyT2f2crUzMv40+LLJmRizJlzexGQh3eJSJ5zLxYV1u8ulmll8lgq0dbXks1yg +IbwrbhYyih82ZnztiPN6EVH+abGIXjSiYA2Jbj1UqwbBRvKOPDwHMiV6OQguBkH/4J13chgdz8Pg +vzCByA12Al3PnvO5czx1XvncOdkhOxLX/ZD5yQ6YBzlkDuJ9otPlhc7WaJ4HZ3rsyf7mo+WY3wN7 +BB0f0TNF+YGj49fYkv2OPF1jS/Y78nSNLdnvyNPnb8n97NK2cMW2bMW2aMW2ZIWrVzENCc6uXMWQ +2jxb9K/nNO+HoL2G7cvkIvcudj9E7/sx9d1ZAH8bwqdaIeeH0z8Sx+dEedYpxyIWl86anx8Sz5vI +d499x2kT/nYh8LMguOanHy9GwiUWPrlgeA+HnwfEe0h8CIq7pHYZ72kMi7vA+OljgfFR9YKl39b8 +IaUGNrGllXnl2BTIG/wFQyfpopZ0LYQcdWsgvxLF8dZ5uYwswBqnU+JFf5Ew1GWl8Xoov2zPDuvF +PRvAfs/msSU9em+bxU7SvCgpRM4iqWvq0lHa0A9BTc639Ukna/3Xpb2Rfb8cEaJ4EG1UyZWK4kiQ +lolqkjyIjlzyfk2kmuwl8hOoHFQvBgUKCakjPd6zIy8Yu2bt+BRRZp7JaMlW/QiST7I6Wd7sMiTn +9vRc0k8mCXvsLJFK82DvXPKrJr1qwqtPdF1Pbcy6+qTqQJfK/2wKAU2fUv/noaI/LEo/0wy/YIXT +hj99+Y4vVUlc0vnBkv9X20l1L9XdVE1cNXI567+YnRsnNnXN2FVzVw1eNXnV6FWzVw1fMn03hUNy +mVvwkqSmHDi+rxYi6v0o9TAFYQHtoly2Nb8U02jtwopaM8nZZcGyHT6uzNU9XAGNmUAP1pS4Fsov +E5/xovSMYz27pj764ZHDTu53/xyGx+d0Hafxv6Keu2dc5Hb8Mg5JqJeO/Y8H/0fD5E7jvpOd/y+X +jyf415OUuVDp5kzp+YRnGrWk84fW6ahdf4Jy/bneLp++/rRfPu2XT/vlf5r9MmaQEH7ryLDAfd4W +bSdc0An+yClQF/fLL8XE++WX7bpxAdBar7aLK76/9b08Xd7MUxxNIfx6Sj17Sj17Sj17Sj17Sj17 +Sj17Sj17Sj17Sj17SjJ5yjd6mgpPU+FpKnxW6hnuuZ+U1LWgTdy+ICtMEDw2w0gPI+bbGY99fUby +m370C430dtlIb85Idx47UpFVPSbdwgzr6GpGdKNaNWEuFyH6r5lFpPWqQe11XdZyx5Siu6E8hC/C +4ooiTo+vxPufV7vkPKUg39lMgu8b5+qHrgE5L+f/0Rr90wO1+B8TgzgPKoA86OkY26SMs+QMvrbh +Y57WTxTS0wO+1s8W0dNDuUjnIpozgj5UnCNY9s9JOv6B8hzMhGk463+0TJ/z4hxxqHN5Z6k9PbFn +VQ4Vy+n5YK3LB8QvcKYs5aIYldwQkHQVT7xS2siSS/twku4XIhx9rqXMC/tx1zg6dO2kc6Ij2eYn +/YjH9QsRfpkoz5f9rQDGmzif/K1P/tYnf+uTv/XJ3/rkb33ytz75W5/8rU+elScn29NUeJoKT1Ph +y/ytduvGuhlGHUQcwku3JDx4yGgabkUYb8IcTxqNN2H6a9yGo0bTxbNGyZUtXFy5UH8nh1Yv1Ds5 +pETo5Krv+6kyljCMvoThMGN0ztiMmR6cMnwQjWeLzpUPzRSZJ5NMlD5NOPFvvIauz4/t7BjnBsyM +CScGzQqdE31GUA4tO+karGacBEGSH3EN4wrOMNwLDLGWzm9n58bMw+T8S/tJ1vB4mUq+WOx1LPS6 +u3yjyiTL/KHbE85Hcbg3wd2iwnVZd9NDl9purrXVcb10yHCQBtOD4gCH+ePiYGdJniIPpo8IBC8S +vFAYxYIIBpwB0wXB4ESDTAUR3bjmAw39iZY1DjwOOV2YcOG+RV9WdBjn6eIw90U6XpzTR/nBWzIm +G2p/cY5btO764m3pUR7vXnyUxnzayP7tFRnjJRnLcNvI/mwrgNGf3PA/Zj9wO4K7C8PdgzFtsnwv +7AzD3jDuDm5/4ImAhycOcuriQ1MBVAZUGHYwCIUUhYWUhAOM/gorJIFiMINScAChvTr5cYLtY0dT +KMBbTjR5KkiKgDv8EebKCvyNdK3GAaZBhYGPQAZeobGDIcowkgvdmLGD8crAkMXOJDQYkAwDsdCV +GPuJbsPIsN4WYDavMxSlyOAFmIuMRbaqBEVm6jWezMEuO4l3k7GO7/McmOZ41jaHF84PLMgZhb8B +u1zdC93P9CGHY9r4l7p3aXAtTY90NH7AzTj6pafPu1Dion+aPIvTB66TeOAyiQ9fKjp94FbR8RIJ +d6/oh64VneTiCHEZk3/QO42ruo3l0McdHfYIdMwj0/GOla742NOFHqfT3UTXcvJVnJmu4FzRd47e +a7xdRNwLT1PhaSo8TYWnqeCnwmeVj2rz7TK3z8uikY9+XhmpMt+m2MoXpA0phk/MG/qscllfGmAu +l2sblPVD9YjO48Cba2XIL/6BpTV9ZG351bW9w8kvMIsMTy5Ec7ki0cUbyjYRvL2tvNOkgWEXjhnj +wudR4bEy0SYmPFkwr99Es1pMWA8HHz4WrlmG37S40VjmiP8X+v8m+TXad42bRFJPC9c8EoW10D26 +HE/h31Ypg1ToXC7do7vb1ETaVkU6WV0kqYdElZG0KhJ/7+WQ0iTVkCpdo7KTWkgaguRqSBKXpovB +tR5SlIpIUYohodWDuvtuoljOjuog7ck44vDkLHWQEt2U9FQJ6QqVkAb79NEOCnFPXC6j9Bm3xro6 +OoepV1Sy3KrtnbHnN8bOZ4WVrLTStLkrtt8U68srDb7PTYmlscjSbjqrszRWWrrs/5TLXYdyS+JI +m5wX1NVc2nrULtVg+lgdpodqMWVfbGDIAvxQTSZXlelyXSaYCdOF4kz9qqLL9Zl6haYLNZqmoUyT +L9R06QKjxVeKuHCNETzThZJN/jYjmXv/mQo4gdSY10rVlmpI60VkCyffzbclSMrbmlObwwM5dNdD ++WVKzlouKjkAfvSFGVzyQW2USxYKJcQ8lHijeQlq/FwygQYj6CFExSwpRrdN6EJUgz11Vp3hY3G+ +j0b5Hhsw/GjI8CFEH4s9nqEalxnsbHyhzDKDMkDXBc1zqW1YFZQoRHmlMun4ipnL8w== + + + +GoY/9oL256tkXAx/zTEYeF8LLfyYmnPh1IrYYynQYse9ejxIscxoXKbUmkJldNw/2+xK/jWoXrK +aA+DNcw1cs7zv+om8XRrYGxNjMHImLZZX45HnlePThacXLZgGbizE08AZw+lMV2QOueSJXu51zFl +8mgpkw8lTVa5EHWH0ZeeDbfNh7ucODkaXmcsmYaU3LrbXg+NaVILdb5Il3EScOdcZvP2hlRNaebb +UQOldFU643KU8y18ugWTl09UhSeVMkF35UQLmEaRzrI04NOJOJOAFyudW7mDzpLZDp06QkcCUF+B +5j1l7GG63kp03k2UxFmAXZzAufQETpjIx+MdyLYIcq4CU/YgAfHu5HCXeOQ+Sbv/uHI/fVC73+j2 +j1Htp49lI1xORqDOXbdrmHP8cNcumC4f79708WSLS93jkftEy+xjHZw+1TL7WPemx+SSnHdv4+jD +N+IGCapKK4nq6dQWuIhODlTtRzXTOUC3aDPdXJY3Fuq+Fka+0K7FhZCAWgVyAg9xZNjdaW8nXeuG +nHhcUjQhNmwM/F1ivbgzXwvhl23XF71520Klo567num5kYqbofZ47ovfpn6f4jyZF/5S1fIHfYSu +6JnzD3q91+u+Pobg4whekfbHGroODFN3cqEF16WhWz6r3ccZfKyB4g3eQ7dIGnI0J1oVy6HNPs9e +ShBKXfBF6oIni32USdT1ajXA9y79/uQ8XoH+JaM4O5obLef9J6v8n5LaV6drJvZ5E8DT6Kn0dHpK +Pa2e2jt/qtCfK3RUD3R7yj3tRH2nULk40rihckPn/sJZQLo6+fwo4N4y7lZzU9kxwM0V3Z1moPoL +T0l/sXUx30ZQhdg+agUWAf5SWh6LvBU8LbeS1EbrHiMaVK7ssrC/GsYvEqcxXBKnAP3CezZPTu6c +HaqaXFCzSuVIH9AUcfqlp712Zwd8FtRrHjrgM4RbH3O8aEuBD/WWzXkzomA6E3BKg1LBZxOvJ9wu +VHp8pHD7j8yZfsy7P/nt0yUhef7+jT8TTUeuzw6DRqsVzLplrKKoVzZXvQv3g+v+eig/M/iLlx7n +8CXBX8HwZYLnotsljlUWH5XoS2m+j8ryfVSy6ANW24X0wMckHJ5lzj2EzofmHpOcQKkJj0pS+WtG +532aKAkTuctzo5u8kYNhODQvfvPzX/wNRu12XYZrza+O+RMX3vyhs/ef8ukvWnDpYoQgXQgQ6Fev +PB0suZPTPLNz1RdJBOWE0Erx81XNgx5F7/XNJXS4KVp+Z7Fz3koXuVtooSi6ev7jRIZPlEVWZLkV +i63zbUOrxNbVxuAI+4EWK+/GGms/TRq+437yy0KQosH8FeWEOD+ZJBEH4vlmIr6biPfxdRJbRf5L +3/XaokYXF+kFRrzhswV2kDPG43f622RNju5nf04XnjvyfgyBShw3r9XEQZc7DrqcmsZHq/sdpcur +9IHVJVKWpo+YxXqR15E8jw+UT3C5aGmydJltIlokn6SmyWzr68SH6utMloCWL1bYYWf0heyzB3LP +dpO44u/kKHLQ5DPJPTtIjfLua/9I9tl0JkM1AU0lqcpSlaYsT1mi7shkO5BcPfoxVt012fnh1QJr +zdJZjpa4sgx6dLZ8lTbJYjJVVtaKKvmanKK3dO2cVn2SrBR/bD5rvtVKrjudON0I+HBeo/pWdCrB +v+lCEtY2w3HMwdrW5NCJJblXE6Ve9dxGnlfo+j+R/zvQhMLptKOpxBMpyETiexOOFL8INH3qJM77 +ftIZq13oSeci55zvSCqhT5yPOd+hPxxGu8EIH7Xg/N/Oifd/c4TLAw9N4El2N3VxqaMrne1v4752 +aUM76KUc4362uD3Mx695gfnNaxWTkc3GnRpBd5urBMabAXxuy5jVMmazSEGrachgGfJWNvkq/gax +MT1lSEuZhnyU8bawMf1kSDsZ0k2GLJNpTC+h1Cb2GI0JTmzIaZqTJjpF2RSXnu40ScbTnSTcHF3e +E7uZ9GI5Tn5il9OYAqXHQCkRahpyoTQfatFZICNzcnlRR3lLPxwqB0SfDib/7R9MvlouyWVnxjjK +nz3Ok8vn/PKRhrGeHldR7gNjvRnt6bNihx8Y7+nR0cOPjvjGkl3rvGAwrDXYTAJdqwE7QVzJtSMO +nVlyaBaM6D2YlfOlmP7TZeNcLuyJdT3NSnWeEtvldQvvhXKKU3V3Zm+e6Gqj2fZi3oktMXva5GRL +NjapCJqFncgS0itpK92GtIpttzPzTIywybKxI2m+pPvSXGPVl2uJ7ShIfyTL6UQq/kz2EyrAqAIn +uiGnYFGeiZI4UBfe0fw+SpUxPpGA/Q/yJKrag0oxqsWoGK+0Wri8lKrHdG/yTFoyV5riOlN4YiHT +0V8uNOVLTR24GpnVI1vkDAOn2eSJMm3WIc+GM21w2Z/n2VCmzWiYRnO189ipcbrQmH34JFXuVY6m +i2eoVkqM2V0KOGxPT8kZjyicrJPZqwdknbMsvG1xeODslB6cGu6YTpRVM1qtR7tbWs1WZOVHysJy +7tQ0nJvylqveznYcTk0FyuwulKFzniQGpus0WK6rXKR12f3HxuvHr8t63MVZD16nNX3kTq2Ld2x9 +6Dm/f+tD92494jau6ULp2scUs33wmR6sdvuxp15+pof+8EC1XHpGi0RZq71X+hSFWh1qbiwWO1Yz +wxLhP/Fq6Ycvl0ZbYXrM5dKPv176kKcL10tf4YLpz7xiWg47+AIid9OF4hK+vMS2wASVmHiyPf6W +bI8HMiQycCBioKNhiGws7VtSpbSDrIoklvpN9QFV9Hoo/9PppOVi5ASgF2vNk0LDG/rO3IWXD0FL +PvCFzVw90EdKFX/kEWi9M7MOm7nP+aZT0JNzRHdXNG3osqUv7jbMLF5p2drNM82Ho08ozCf2dXHq +Z68+293ymkytueXMnfEA694yqu/8QVaue5RoTRda3Y3W+Y5W/GGTXR4pExmlQ6F85M3ttShvJ0qm +FpespFSzX/YgWfWdlZX0oh1XpBRPLftq0Vu751tEJ3bY/q/tkuXN5GMV9j981+/5Bb4Xjtt9uPL+ +haN4/pke1Csf+jo+8IgvUU7xUe8/5WzrY/adT0sRf8SuM10vf1oOtkrNIFr3Kx2u6JWlwoVqYgdX +WqpKd85LS1G3JjKysGe8p3L/rMIU9ZF72WuMba+V5e7KxbIT9nlTccrfLcu9H+pOCQ9OEnXdXC87 +cSD4wY0XSy5h+nNLdW2Xd0ks9I/pCIkr/39wr/tChOOm26CXlGm44qkVSYTgHbvpzo03q1LSBF8B +8BGt4EsxftEGXS/tz/VLUxif7g94uj/g6f6Ap/sDnu4PeLo/4LMV439fhE/3BzzdH/DkFHsqGv80 +FZ6mwtNU+Le/r/XxRQzHc96f9LH/dP7ydvFMYducKTwZo/dWZG8n2ZXrprx0sd8ulZqmn9OQ3fm5 +OtYFTTDI0Wd0GZDDQAoloRHAapLmyLOC1CgL5EiaPqlHk5xwZNcAWnpZanFwVvzJHROvlKSxt8xl +y1smykx1jVblxVd3UW+/Zp7PEsRXz79mobP7v+JRQLaLdxQ/PUhY/ySh/dliAT0aoIH+ImmfHw/2 +fySY/7G4/Xls/jEx+k2oneX3Z8rpC2KahPT05TUTd2x6bCrlj07MbPJPJaDKwMPgvywmCOM0uC+P +Z2lsKhNVKm4vUSDZ+IBfE2bwmulM1LK0PBRma3xE0e4IhT8R6GOuwy9GyQIyl3m8uxQ+EFrxQg5P +cmGJOPgFa1KEcllcfimmLxOeF+tbtLG+hRUEVYHDLoY7PZLjfE3ezzQeqNiUid56mC6ViB7dkg+U +iEZfwWQ+pa1v0jxJo9y4UCpqW5GWw3m7C7VoFwmP9vpZZbLyUDvnRxxjpcmd2uGI6Y6yQCxqKlKU +5OdEaSSZYn+cCtUsGUrip2OPvkjCXDoUfUHGPELCPKwGTh/XA/W+5/0m8X8sWbotWnopUee0zfAf +C5eum7z+NCTtbNN2NuVLJ5fD3w4XC5hyjGpPs1KvMerRqm28itXYhy9DkZjVpEGr4UaUficKK7jb +uNWlyBUrvFLnCOW+l/ys+0r0apNpHOdlCAWBUhLGo+QafWlahDKtAcTDRcl3HXRcfAgVtEGWr3XZ +pItAB0Gc37hT7gEDVw9tGNdD+SEBDYCvf/X2zW/evXrz/tWb7549c3Lb/2H61ff4l8h/+c2L9+9f +vnsDAv2r/+fHF+9e/nCze/Pd65ffgizfAG6W5TalusrPeFPKLUb05GeErv6I3TVb4A9/of/+3/Dr +/wDgv96km1/e/PN/n2++Jfgffgs/tjjvHUzw3jwH2OZdA0w/+/wCPoS9odf9moYCLCfQLygHvVZi +c5pX2HFwO6yFtsWZ5wVWcJWKVZFzgf7wAl8AL8W6rvkWDM3E9AqIf9Ir6a/tAkQ+9vwcE4L+Bf6F +FQtYwpa5gspQK71BYbHdLm0Nw8cvwfSzzy/g0/fQ54BTGToKUpTeo7Cy3MYGdp7//CWYfvb5BXz6 +HqVJP+85VsNtanURBrV5bpdA/s1bbPoW+lgpflgU5AaBP3UB4sZgg0lfQN2qST9770Ces8qFSzA/ +G0Zs+hKiBmaJjum9g/FH2vDxSzA/H7b4Bm5txkRhfgD085dgfgS2+PQ9IOgCbAu4zPJcYbvGGHoE +wcayOiG9WD1IsgCk4BpIb/6FFtx881uuPhJgeXIhuZrGEghdrKLSzQo57It0/GTF1Xzzhx3XPL75 +Vz9T+1y5NGyXFtOFNbvBhqA/stSvmQvTdvJKWIYqSYnL0KIXhciEXrK5QD3fzq/7B0Z+WI0bmCf+ +0nxlUmGXX6j2XYgY/rjIW9mOnEUD0hHoZ1qHWSrS5NLsUW5dgnnJscXXaa2g7EfaH+vCUwva5UKM +bhjnRIGtCRuZTRyqpIG76iDC3VK+JEyx0NVG5grIrdoLsv+PV5r4W2Hs52mFIUzCFhOmF2B+QV4S +7lcdftpEQXb2wR9E7QUxqCD53PMzTNcc9s1+4LcIP8aX5OgFcX1hd2FCUwIrcqyFlvLaRu1US2Cu +ylXJe2JCcSAdBfcOxusinUviDcxTv8WntG61Cq9peJyiulwAeYyXdBR8y++nE6uboJ+KsvlZ+urK +f9m/+/GHPykeczeE+WfTfLODf3/41+lHeAYt9LIOShroswS6+W2+AUmdsPLnAlx4BirheouRfAd+ +PoJDucWLCQmsGC7B+sffTKiD4kSeFxr7isfCcJKCRbaS8K8FzAQ6EIm7F0KsAP+i89ihRsMiByI4 +NJiOa04IjrdzgM8AcM23YPsJGRGWPMBqvK3zXB1p3+DnC9IDE5DA2HBp8OHWfMO/QEMwtAAnkN0b +LnXb8M/YcM6AMST/clieuDOXgUrPa+nRYRra4n4FeG8GpMjsBmr6QICOwDcjpQDOBTo39Erb/mXs +fm/rWKVtsWOOq50Gx/9O7XagDtO/TL+f2s1Pf3bzh3+E32hSwyoYpvTHZjpBbwB8Ew== + + + hin/6Am/gvp0u66gmaxhLliel+b8Oq8RxURz4OcbcLgtNa8E9kgeABuSa818wl4KSFDAnmAjyIko +X2ByESQmUK+4WVqXxMAMO+rNSBm0XNeK04zBkbuHKMFMZyCa4QzEK0VvLr4cBxQ5BG2K0pDSkoSf ++Rad1QiG32bYoRBYeFJy2xgLAestHpdmYFtgLRwIAcwk9AkwOIdF28YkL8tzuOGGC+7bBCszEM6f +b7AjzisTsNBEXee23ALvA7ddmWEzzN4MDZQ3aWUEOKljEmJDKYVnBICB2jpwB/ZgWNCrsDfXEAUY +l0WJxdRZxovgqAyLLUvbEGbBmuaiCMJalOeo3BqCXG2Ac5C2sPFGRbAqEEx+pWBN8vl0i5E4aYom +gwA7E2DOC3BBtwATMM/BEMDqFy6C0lWFMzhvShOOw38JRb5NYZYZlkJmjhegQDtWc9aOARi7ziPZ +oiJoKSswpazApoT1jsGis5nfauA+rLdhKTKPQNQyUpgcQScHCCz5fIOZXYTWloSHDRVDeX/FiS+f +l8mF62K1z2PGlE7ZRT9fGn8eXhVCFmBDxjOwrgsvx5kWvCCoa8U5j8DUeGQyLPK4CnBNpQqv11AM +AcxIHYKlsRRb5gVeEuV1KQiKBdXPqL0lbiMwzVmojbBgBe+C+4Ks5nmdO96yzkIFld1jIGZ+CcNL +ZWC4xXi9drgEwQvglKRvCyxewRugo0noDbmtgiLhmDCKHKsAS4y6ykM0tGV8G6OFVYrbVGcaA6OJ +QJLZAgRVWwhgacdg2AyE3HlZi5DQZh3gJa9BECypj2TS/qJ00IEA2cBtYdqn3HQySm8rSPGoXchF +BwJ2+1R0ioVapW3FMu7McRTuAlyrrrHiELSogmaNTMAKvV2lKZbsFCBo7vqmNmsPAAxdFvAqs2a9 +BcbFMwRoLAkQlBdDQCTy0llJ/CEQ1J1F50HgQWgsczq3GUHDUdQB402EgEmX7gpb7Y21FAoq/NcQ +xGgbTgEwA0uuVRlrQPK3MgXGAoDOwRaODHhDbiq7FiVqTbrprovOomXmqc5YG88iAHY5SSKRgaWt +ymzcjBRBBrq0LU/uBdZ4st0mkJzClmAKFuFrLDQzFtwEgwo/DMseFIG+KtF2SaAcdLJUg3XZrZsS +gmMrupIjixgAtr5eWPbBq4H9a3M0MYKAnmZdnAurLQgMul4wXnPzT9IW7WDdaQQvLLmQbMKuAgOB +rOsNJQ2/K6IWpiuu2OczMsPvPgjsO2gtSzUEbY665vEEDQLhYyGYIkMqDwJjrfIqMAbk84AsKgGg +avO74NcWtizMMJhrdKKQEQCy0nTBoKBnIKnsPFxzKQJM87B/KYISVultTk00WHxdy4KCDF55Gdoo +omEthreaxrLo4kC8i05Z2e9B5TIt2tQjBC4wf1Q9MtYWkDuqaGKGsrStczL5IKytMKQ65YItb/RJ +xFUnXSlJ2uIJHWUNa8qIIKgmhmF3QQCSM9mullbZPQAMckvBJSsK1ZVR+JcowGb7TEBfh+JtNcli +jFg7HoGg5had9lgOWYAgDVfdV4PydsXKQtkRxsCalDVZBgxk7Lzq9rXU1T4Pi1g5U4t+vm/tSwpK +VY22gfaxaSgFdd0A828ECHu7IpgVGNZqwJINQZ/i4oZlcKpL7eoYw9awRMdEBpagQ55ws1a0eV7y +ZmigbVXVAIY5CTDB9qPK1LIagrKonMiiWwCwxUWABRYkAgMWANedChMsGEHAM/NzUgQs0wMZckXJ +4j0lYIxNVR7S4xVBSk1YIGouAteo6lyVLoTlNiTl94r6JiMAcGYewGoLvG4ACAaLdDdHFhMIjEFf +FXXdABgz2YSwtXEXgtsrRKVGYE4q08B2lVEAcKq62eSVJTC2FTMumzaIwEVXAt5QZQhIUeHuouNb +gGgDM1bgkQBBLCsFIGANQYtZ54HooyGaUo2+i5wFGFpKyllVTgAcV114xHoBRl0hRRQ8xNp0hZSk +CjiA4XdBQJ1BYHLCmuwWBnaVB3YIET4IFuUCKGD9LmR0QC88tEs0YKxBgUE5kN2GKSEZBqeokoO2 +MQbWpEZIY5GIsKKfr8HQFjMZtUewaanUWlnsBVzSOoGqqUsBdW1VAmguMDC3JtTPRaY77nW6jKvJ +TaTJZKwRDx9biiIQVRyAIasmvaIRq9Qvq0oNsfoJQdbeJ1FuCIFNNlON0NW16KDYHCywfIvOABUP +xfTzzNqtIliDCuSKavdzBUdeHGj6stIXcFurngsMnGXFlK6JIhRlTV9HDMxg0cjEEBsDgBRxYqSp +LIYgmYKb1OuFYNrmGVxlFlce1HEYqpPSKwoNxUt8llUvvMEN1KY2uxgIWJP1VrcqBKOtTp0ggYtA +MOVTn5xzFaCuOJlJjGA1mwgnt4gC2H5SUxkplhYAk624WlVFC83ZkG1eFQFenqkvq8TwOLPJ0mUk +IYh0KadSEJnaOJujyNYcwhadiWtQIxY/33RLKShrGBhs4aFDTYAU05JBUIGO4KJOjnXhNQbAmqOX +3QwkD5tsVLrwInoImu6KuLQFuCQdxchzFoFRWzas2q8IYrFtlfd1gKnLEUa2ZO5BoNr+bpfgzwcQ +O/p5VWgBQc26o9AQMbDhvi9vWuzzeFpRtBCxEwCYggLXIlTBLiOuNkSaoiHAHDInZZ4LGCxQ3T14 +q42wo8SoMzayKzXiLqG+AfoIo0UXoO4oTfYpAHbdhrRRBmYxdguG+mR5RHQ9pjISgKpTkMkd2FGF +QDXX/UaJ4GbdbVURVNNhihiLAMTcOZ1Euk1FFNVR6ULfpmAtKk0wo9QoUP0UhbmjYLFJz44IxDpX +1TbECEfgorTiSVNDUGeds+r0iCjfTSCK3MEuVNVac1GNKwLhqypXMQm1heN4LDzr0gSongzcB1Ud +R/AcbdllRQBTSikQRwQAyVKWaRCVByC+m+yqLCueCziJ3lnYq8HAsKpLrIqnHoGmTtPWqXiTGRpZ +NtdYeaBFQ2VNLla6ocbNOUaAvnfTp4OGN2K17cqtvNV59rIYFQAMUdWgYjb+edvnCrbZTP5kBsam +4lO83AjMs0YVMtp2irdrnroxIA1FjYoqri58lTkcaUtWBCEqcxrF65gC26+amGZEgS3I1D+PR2dH +zTWiFaZ6tqq+AOwupdUMEIwbL+pQqCsr6giMybY2GXMArlEVn2y7TXO2YRO7G4ApJ20roaCIvu9U +zyYj7I1l9etUsDZ1BzdRBBBo2gEJUEOwzG0zQyUeLnK5GVlBhXX3ywE4N/Vp63g1U8hhiYhTBoB1 +Nt0PrRr9fLFNpNVVCSi2C9PeKG+KqpCb6h27u46EnkxOgJqaR3LGwH3PNWJX0/MdC7vbgKahvoxI +HARowhSb4E07BqpnsLCrhxAkzLFKIiXUbk+zcwY0nJEMXNtcdHKrTpooJcumd2vcsdT9iH0mAjAg +n5gwXh4AS6GJnjkHdSwRWLdXmjKKVoNsAGatIS1eRxO7CIDqpEC7RolFBWHWjrGohZYt68ZAwpEb +hmDWhqmDCSPUKnfY/wQgddd10xaAaoKI8qwfb+agML5Gc9EXdqAzkNI2N5oQgkU/AWYpBQAMur4X +9MYhMJlOXzi+yAjQg23cbuwcTKK0EzCJ0zZli4KhqaAadcKZroMtrMa+qDOkKgOFGSLkV+UAWp6z +bWGs+SKwqA2bOOCFwLCoJ8MWF0LNg2dj3Ztip1gdTrimzX6pqowCOIVV5jswm/taTZ0egN1c7joT +gMl2FsaWrG1DEGCQca0c+eJxtRgYNrW9sonBCMBcF9s4miKtzVwxJqJTZe3e3vVcoG5mcAobgmEL +zl03aMxvBKrVnGQVwNZVq2IttroBvGpTFZwAjLNJ04X3agSmxe8yiiCXpnhlT02riZKioeMlNcdY +CgwzAgyzmHGbxLQEaJJwrlsIjZLClDMyOZr5LDZoVfeGPohRkWebncX88Zi3VszLhPoZIchYll3V +KzX8c7AYXGFnNANdb3GlMAIAi1WDhIXIPcsRfW06YuJngrbNZESuLCMyBgcXxVs1NIcIihqXUZxP +GU2FpAKpBgWCTqkaonoDAEpORlEtWKHNGAFJOsElrgTAipZX74EiUDW1sINOEIhXp7A5yEDS6kTw +qM2MYNG0HReTxeuAArZVANY7oPF7hJKzWvjd9OM0ymMHkrlbxSOmCPrKpQ3ruYA1PNkXKXbWfEVF +NH2kdVHXf/fc4+uaBmMly1heVyw8JzIN8WoMSKLJ+PGisZYVHf+Hhz+OKR2qhiUOtVDD2Yzb1Kmi +eA73gLUN6qrJMzEic+J8WAYu6tXK2fbUol73jDkWOjVtuiU8MGKejNjpb+ZULDozsmXjdMdextCX +Uto3RSKgmnHL4h/bzlFXl1hVOTtZkEyFyainqX4bZ0OgU1AjRdhuWXRpRt0RHvo4HgGTV0mEPWeL +PxU/AmhDqJBWpTvj/rUujlYGhkXJItcpIygW9CwWuECsqwkSceAhAsfCpSNYatNdUaJlACx1NkGi +nwdlRQnoc6CYEoSGK3t3EdhXt1hDAMxRle5g+3rG7qiAW8SflKuFhMqtfLxy3kifmPxxcnaqxND8 +D4AqTboE0NLVjV5jZwCMzknYDKXmWBTNPENgk1mdJSSIoKSCZSk6J9aOjv5rrrXCDn8GhqSzgUZN +X9ya6h1F4rfuxersyl4P6D6Z4eMx6ptAIMpIqEcFaQo6m3vkAMFJJT2Kg+cC7Vq6Rj8ypmZk6ZUa +8gi0d/WgDIIXzWms4tdCYFK2qOhZLSiPMl0TAzJawWqnrH23BKUh6diZTF55n5aRZ78YtIQZqkC0 +mRRvK0X3haZ6E7SmRAPhomwXjRMNBr0H8dput5irHsAgbHVJzuxCyhigtP4WI4zSK6VnqqAAuEoq +X2G7ioFl6RteFpj6B4qLViBaMwBych3rlon65OldcaPlZTQtiwGb0FVmp6ZpzgEA46qDLqEtahhl +IIv/fCjaryoueQCmqFuLWlaI1Fy8SS2YMrtJp8E5RNpUSaTICQOzCYU+wRGBTRn1T5bZqc+SUrqU +hWPx3NVQOgXOZi8a2IfWczHjtiSZocWn2KnqhpgxcYz3PKV34QytlT2Jur1g26qe8iBOITxHYBl6 +kdMREZiiZRzYFEe8q7oeWgmKAIdYRlckNgCriS6z2Uown5AbseBUHPK2MlD9asOU6a7ywmooA0tW +gVDynASowTAgIKjZjm1tyMgnKS/LusqbbHoFs+jUau1uEkJgkkpSTwqov1WHV9c4tKQIwWqGhSJY +46L7zmLdLd3LK4mASFYyx4NFdLFtSRs3AbZd1M+s/nN8lXn1CcgIonOmakILAHt6dGW7E2GLusVa +nwUAnk17i4vyu8Vi7hS2vPFNWS1nFEH6+bTY5xsHL4vPZNTwWEGt3vQGi1YAWNN/CkeXBZh0E5O0 +E4KpmO2xPES76EZLTvnnAs5FJTWdJFCwpsYW9nAJCokhM/+TxdYk0Z7flCwtF7clxQ== + + + iLnLuoGoXYUYm9qhrKIUtIpU8wuWswkfV57oDo6vD81pLfLuVbc/8lkaSUG1QU3RR4rE8VU4F1GQ +NjN01tb7FMyZYGIbX1bNScPx95I4fMkrQPPNEawOnWL5qUXyNMcVkNxa6akpJXPHh125ZHPPy27P +wFKVqcW8Zwhe+s7DkamCSpfxcFWka9HxC6Yll8znU0YZn13wJIlHC/sqywKjO5otR23V5V3E9QNt +Qc83B2oHWoChB0SK2G0MDms2dmn8R9RshK1NGjophLmylgQu+UUlm0rck9pKtl1azk1oD1QR7Klf +iKCnMIj7D4FJUxicFMrMOQbHWcer54lptkopToOipARGgJPHoveriKzCqZqyHc46Mi2bXWgpUgWH +qSlhkviLVQwsOmgTGfT6rIztu1l12zRZQAx0Pvsqe0l1u073gAJYI5GFk88YGBbb4tZFEXSXWDaX +GCJYdR5qSArbSo5Wt1cR2MyVgyJJEfRobpakFaR2bVtRXp0XnIS2UZDVd7UU/bx6G3tKAAIXDfNT +qJc/v3IUe/VOj1ItbbQno2JLWwjBsiIKehCzzUPZ+LrlYCmIpVl+jsQK+fPo1NNJECXCUWdeq4NS +BcBUNFOi+6Hr7OLR2jBHXQVL/3RNmu8y61Za0fVn+cjicMDPF12GaoNjS1su0XTz6jVIElB87mtx +OlVcWMABEKi2fGRe3gAszWLR6rnDprVqmrYd28DGlgk0r4q1py5rgBqBRftFfgZF2xOnZpHRAFyz +Jr02UcmwZdLs77Wp7lMxf1tzfIsEKCpGWPTsDSWlM1BDzpI+zgiCnXUSap8LuGee0VFnBEZOW+S2 +bFMCLCVToU0aIjjqOTLyJz0XcJ+H5DgxsKUkywkgBK7JcuglmwmAMLrataSTtmICoLIsWlIdgJes +J5OyeDYBmO0kmEhUJHfRQxurHjAjtJY7pem4NTinmqbYAhD0eEUwLx2BSmrc+mvcsLGfxUBSJSsh +8WkVRaD5MbgZskRECiQqhNnewi7MeNFDdmQV6/hqwmVSVw0SIBtQYueyAMtiDVvrn7fTJBS8kNmR +qxAQMFeNgRp3T85/VPH4pWa3k8oqk3HRFHLyfugM1XOKdhqPwFnB7mX9zJgeR8HFMOtwOwrwDJS+ +TPMqAKjnyxIflxCZIkNgJ5Wg4TKX5KYWA2EEhaYiyf0oIxY9i9EzVrGtnREkm1aARdctZXGKkJK4 +GrZcYpeJIepwyw6Mci7ZMYDUBWXWc4PBPGYkf1NwQ/tcwEGSeVOXiR6osxv2hCbpAMnrTM024WSS +rqyWmz8AaYtkYFd5MDKmS5FM7ee6B0oua+zmJ26senZD/agAXExwUGhOFRnHhxRMdRX1P7KAZWBu +ylvKYlRtMDc9LqUJPmh9LIagdVu7llVp1QgUWppZ5V/AAk7PzVTV1Wh4A88WHh5VnnsGd+Jcb8Xb +V57G1gDYuSu7EHoWZBeWkzDqsFA3ebIwHLpBJFYDHVMNazadI7LeZi4eyQSKmGnZzBVDh5MJLEkk +6PqqLBCiJmCgS09SA4WH6lEL9jJNDEGf4KzH0yg884ydilnlZD+2QK7RqHglzxaAsNplHmlWMTps +l6L9ssQndPmK1yea6wrd13IODce+qr+YcikEqwUtsykeke3MZxyXSbkoE5sF/MT9HTmx1YKDortG +1tTZqxgs4yRyCPUZR0glbSjyBH5GcdcmAYRI1o4GU2fRXCI7NzTKq6ZotBxLDAivKSoTgqIFoato +zXeGMeWsfKTQ6zOKPvdJo5oexqlnXSLJAiMA1swljIDyRoxAcUFGDUViVL4U4VcX65REEAQcm6TX +VNPz5Az2M0lMCNJXykHQfAU9VxM5bvlcwNR16a/E8BG4Cl61C5JE2BloMSfMmRClLrLX8BklbfR1 +U2ThYiaHHFKLPcCR5EArf14syZTMjRt6GgMMnRyClXxVTWWhlcloJaIAwBqUgEUc5AAsctARtv86 +R0OwzIpAQ4SUeNOiTi9JEApmGEROgmAEwWwT9ASyBHeJPyOCOdnsUjlHOUY66ykI8CBWzFbWUaSs +N0Yw26H0YNIegH1j0dlBWXG67oKlmlUL3UbTD6LkbwgPOdcOFUZdB6Y1xH5IROoGPBdwkpPXwRIA +YjR/ceTyCAxMqQiCnsUYzZSNdgAx9tIGdHxaYDQa/H4zDjGJOunymOWkB+ZwV51FFMF4RunaVNBI +5pDKWQQ3XRyLJhAvltYXeXcXYK1VV63xteehR06NekbZ7erB7XMTk+4lrSGyIcoIZpA7umYo8sdA +0E8EqCFhBNoQZkt/Q7xZ8dZFTm80O8MUOc+TgSXqhm85EAGPsq0GZdcgAlOfxnIAqFnoFoCmz4XV +DpzGflal8nEHZpck2OC5mk6V7VUhuWWf7FiQHkTGnDXeafCoUtFJlK2IQUh2Hh7XP2+sCAxBeyB6 +rjsCFZ2TIqCt2bStbB4A1COCoIXINArJjUE/24rnrSQYEfvppGSZv7Ef10E1RQUvRboZQbSsrqjh +TTzZlXUH1mzvEK1ISby1M/YIlUiCqAt8qqYHDSJH3Z7RqTu1gKLp+gDURHq36vGkZtXVQWnoz/jM +rwTGRXl7RuejNQIY3EksPHgu56AALJEALDQgOYTBInhzP8oc+JAHIcDBl5oA0Y5UkgaoPAwhaVUF +Pdwb+YS1IgiziTi2S2h7tGmYrCpDkBTf6DRnWsBNyvFIHioWe2g6tdQkQKBklAV38ALrWFTe7IPF +ZufZskOCpuxjhQ49RRV6ojiCVcMNesCAgOL0NSWKEKwmTHXvohohYsoHdkY8V3BigzFw/EPBYdZx +kBodCJyz0ls56RGBGj0IXaHGkiiU4kZgUWOwLMwaku7LrE9TaRzJ3Qr9mMXcZouKRTZVubaOOqaC +umKxDg/FKIW3sqlgzR91EUTN3MDqQDDxhDlVqwP1WksiIxhBtIipWegXqg79A5UjwjpFwTkPQpAi +SYlVFW4/F3VKtKQn0En+SMuohSB6ogyCy6JmfrFKSWENYiDqij6ngCsloTnZimVGoxC9V3C2EyOS +oU7+X0tOFtIQmDUxZu5B1srYGKxu6e6/7YlcCCyaTDhbikbp59WLOaIKpaNo1nhTK3nTA+1aMTMC +KaNSxgKuGo4xIorLjwiSYI5xgKA5B3G2iP0Z3ufywuRYQZ7JewFXS+etWUMyNWvqEJ1geiaBolAU +qDtHSabXFTuDRTEdDV9pnts5AQejTI2yotVAGaxajGVBoh/A0nlj5Z2yJK4mu3JykfpyOTClYQYN +Yiar8VLo1NvF9ythsKmsmtBLI3Cv4EUJq7PmGISkEVML7i2WxUgRU7X4eyTTcjIWPuqxcm5P0hSF +zeuFriFdJTNRCAMrR2CzWfxtNqAozZhEk3tGsuoQ6B2wZJWsGUqND1UwsWry91P+mCClru8NVTLt +6OygephJxt0LODc7SoEKhx4T7KUVyEPw/DISwR5mK+yVWYe6F7CK9n6OE+sQWA6aJG8ibLlwFHZm +LUpWvaiU/tCqhvPOCZAxWqI7V0eK+b2Cm9WOgDGWcg7i51nZ3639PkfynGoCflklQATflM+vBijS +H4MIVLguYtLNXBz4+QCGbrJb5bl+/hziPvqG6KECgBX1FyzdijIR6zSHlZJxcSTxOhj8pc0L3Viy +wMSh8q6R7yvhCoCg1xX8O7xS8qvvRa9rSyAwlkEinWaVQ15LCzbmFKZG8Y+FIMke/0aUjDWx3Trr +WkEdARRXKysSREXQ2Bvo4CWrShMs1Cc+TC2UF2sTbsiuQmXqkvqLpA4LKSki8haWv0rXPLNsmS3z +e8aXoe4ClmAvH0VRoIZAOSbzDfFlweNvxBfM2Fy1zA/XJFrWaIHwJcqhp2VFbdJKyWAAo50N+pKl +Vh621jDignoI7mCIFzXNm4sD9o0sKDwVhmsSKU6YnnEv4Li24MDPN+DIVozQjBMKb/3E2oyqN695 +bQ7IrAS24NVlvi0qbDHSlO5YPVAoUC0OXrhuCPPgwBXTpIxfU8JAHuUzwgioQwSbZxrbOuYY1gsc +kwKU+LqwCuPJh0TruGFNMlT1l5VCtTx70MHAQEzClRpyWEKwEA0zy9dvZFWBikqckGNAMvRStyLY +QTCsHLVacMvS2xd0aVX1TAYrdoMOzSIquZ4/wUJdMkDV9lEKReRVmRMXJmzG6A7u+jitgRu8hmCG +55i4u8RSLpNYKcsMWUNuPZ4NURYWzd++tiNuYTjVQdApkD1S2JBGR20CLopFbdG7xQt+wXBhYzAl +9kuxyrDKEgKRU24uDhkuix+n5Wb3vYzdHKtMQjIJ7zdgDMG0cqOlFIkYHPFeky9RuQwDMueSFGkb +2uLh7JgHrB4oFDCCDl7Y4TlgXVHrSBsKFKgyTajtbX2/DOsFHiCPfvL13+3evT+++ub9q7dvXrz7 +y83PAfTT//azm7/76v27V2++u/npV3968f3L/euXVG/6T7/7y/cvf3bzf2Cj/YONfnHkJv8n/MN9 +9PuJatKiNxULEIGmReXRQUGlcrULRZVdwfGgBb0T71NIOyjXlSULWbP3G7Blr8yzCYtqniVgXigq +5Amow8fJI0Nbqg9SRqQdJu/X0VMwzlsRCR3pzIf1RgIEyAg6sdbW98qwXuAAjh6dzi1U4Rd+mamQ +PBg1gYqgLzGD8o58xR2f9YMS6L7JxIXSjbmcTYeoSau834CljAkTzLs4coxO43HnYLeqDqjcnROL +QdcWM7jCusHagUIBI+jgxXJKHdaZzyeMFAhQ2avUWlvfL8N6gQfC3oDXNmFtZVBj9UoJvvIGzN1I +XI1611CkJHSsrkp30xl3QfEVzFR15X4DxrpL5jjierE49artMK3k2GHfiN8KVL51bCklEUeUHSiv +V9YqOHAJthHpzK7k8f0CVNYqqdbWd8qwXmCAsHbGCtZ4vcCKdwXRfQk50jUjYH5UUl+jXemAlyMg +JDv1lX1UVeZNFuPJQyVLkukFG1dXtRZVlfXVgcrcUOa4aYvLOiwbrB3IBHSxwtDAQYER6cyntEcC +BKjMVWKtre+WYT3nAPMWzM62VLouYw50FQZo3S3SNS+g2JNFgKHTJdFlCSnzJV9oI3TWgmkliCMe +Wr3fgJNFcrGgcCFVoUk9FO5aKbxjCpC7hl5OnffWFtdciBusHSgU6OAoOPApmxHrggcStxQIUJmr +1Fpb3y/DeoEHwl1MHEIJGxupW2hdNczroDspIt1NlvwlZIXlrnEW70ZkrAGT5O43YCmNzbRyuVGa +dJJogDqnWCwCVM6mGpdN2yhF/AasHSgU2LQXcGA35Ih14QJmIwUCVM4qtdbW98uwXuCBcHahs38k +W2KlCvag86x1uOWHp6m79qPa1SmypZbaGDVeIcyG0ADWyk/oqE+rmHlRiuPNWGNKLRMCKnvFXvdt +MUFGLR7D6oFEgSJQcLiNFmpQpEsPoHQCBKjcVWJd296tjvSMA8zcvK6VLmBb8hJIOg== + + + zKCdjrwNIgsqug3okiW7QkfkUta3NS3N78HRMudnVEkWEftawWaWFdeBaoCUteZNW4zzzusGawcK +BTY4BtbsDoc1aKDZEcAwZa3S2lv6vhrKMwYgaxfWcHMKrCucX/fTGaxXE/W7tdgxYwwuSfHXthh/ +FYqx81npW8X3Em/lFAuWZS8eZuad2Bi+Jd/pMKDsQH67frxDNVDhcPZ519/OMOWt0ulnaO+modz2 +/QvNk93jzJPfi3dvUe8e/Ph2KnKtyI9X87YNPsRnFNMFRV1kD5mO9xtw6eFbPGvBeuxqGbBWltGA +xG/LAvBtsW5eLBusDpicTevAgdMvR6x44UjdUiBApqBT69r2fjmsZzwgSfXlBiNVJUxMmuQj3m/A +gZP9qYIjW/uYTdusuOUcVwfUjnFi/9AWPZepeZQdIu/mT3dw4TzSEWW9RT/G5vUC1JFVUntb16OO +9bz31zIWOZ9lls5RWPJ+Aw7ou9LymoBDNjKt+AKdg5c2B1TeljUvm7ZJDssPWDtQKFD2KrhXXHNY +q52YdRQIkBF0antb1y9Xx+2MB1cyFikvJ5uPxqKQDoxKRFDuJsqDQo6BjqZTZ0nRA5W76E7btMXY +ZssbrB0oFCh3Fdwrdzqsxco9OQoEqNxVal3b3i+H9YwH17IXkQhysa7sRJG566ByjISB3edcQ1bu +cmFVAyp3W9S5a22zHFAYsHYgE6CfV2ivTO6QFrtJyREgQGWuEuva9m45rFsOXMle5CyxRTVhrE14 +vwEHzhF5JoV/1TBrVZZqkQulDMhdoxJSy6YtnhWNywZrBwoFylwFJyu66LBmS3JyFAiQEXRqXdve +L4f1jAdXsBfp/XWVIatRUyEcOHBaLgPjokDaPrlf4rRXoHJ2Edno2uJpVAUa1g4UCpSzCsZLGGat +V61Ysx1/cRQIUDmr1Lq2vV8O6xkPrmYvoryiHDZyT2EC//0GHDiZhfvRos67JCdGsUJ30ClOQGVv +XObztnOuyxlWBQoFNvMFDLuMHBF2WPHQTthSIEBFoNS6tr1fDusZD65lMeL9f02dOFRk5P4MrFdq +IDBVNT9632CjrA6ofUtRh8e17VFNh7UDiQIbHgNb9mXHmroS0ilIXmHp1A5te78c1g0Prms04k7R +mowenQC4PwO7GvOL+SZwbIUVRQ3tqu4KurlxXrYtawjhDGUH0uv18x2sZysc0mH+6/sFaPLJ/CXW +1nfKsJ4x4BvOA/l3iG19yHRkQ+bfxHqM2SIb3np04ML5Bc+4WDSdl/JRLiw73KIPkxHTsTYsZSn5 +tkmc+QNWB/TWowMHizs7rHJ2a6RAgGx+dmpd296v4CuJb3ggiuIXGY50C5EmTOAGeL8BYzJC0dLc +fBICmeXKTHcOElAZyxWjfFssbbvyvtixOqBQwAg6OGhanUO62BEVR4AAla9KrGvbu2VIzzlwPeMR +Fagifn4qiHK/AWfy/DC5jSoFIb/s6AcoWJLzIUDuWsMyk2lsiydqSmgDUgeT9+vYKNjynz3SxRL+ +HAECVN4qsa5t75XDesaBa5mOWH0+BTXcitrlHYqXkiReTZVTX2naWQ3tVc6nGVB5y7f2+ba4npPy +VrE6IBNgAiUpb/Vgk0MKBtMql050AgTIBHRiXdveLYd1y4Gr2Y2xaM4J3mqal85cBed+uqjyQVVe +06sxl88JGlCZy+eBh7ZNTrYMWDtQKFAECg6+SLtiDXYm2lEgQOWuUuva9n45rGc8uJbpiDccSPA+ +cnbv/QaMdwWy8wcvKIhqMmiyHd0uMAC5bytuu3HTli5nWTdYO1AosLk/K3Na03cp0sCRq5GA4AJq +jljXtnerIz3jwDUMR5RK86whLzw1dL8BJ3+ZA1+QSpNOMpnxeoYWFgdUvvKpwKEtVlpUvhrWDhQK +FEEHa8lmhxXjLWXdUCBAZaxS69r67hrWMx5czXDEpdODVvOsm1kHJ7tqFi/QoIMhnE86K3trVT8x +AZU7fGPI0BY2nqLsNawdKBQogg7W5E6HlY43pQ0FAlT2KrVD295dw3rGg2sZjnTlSJAlkW3ueqgp +MVUTM5GymFUM8/WrBtSuVcnCGNpyzacN1g7Ma2dNh+otDR0n1uYwoL5fgPp5pXVo23u1XoBlm7dX +MBeR3NzUHC2mKXiwnqLBXtAhpc2g5zT7mWCzJszprC1fH7fB2oHjqjawVm0asNYWzgiorbO209pb +9k45lBsGsLn4MWPu38KOo4P6Oh+6HefAvfQ7FvZfi5hsWi0s0a1izQGJGRmrgtY2ts3o5lddzhWU +V6C34xy4a1gOa08GcRT4ZBBHrWvb++WOuZ/x4Ap2HCBdq7pysJDQ/Qbqbq1YcbuQwI/dmoEnpNfo +gMrXOaQ2ts3oP13CiNUBmQBlq0KDXtfmcFpGs3+/AJmrnVbXtvfKkJ71/2pGHF57sehwRayrdb8B +9/tGsT5GbjKPtW4Q3diQVgdk1sxyhbFvmxfboTpWBxQKdGz6bkZFvEasC9c4GCkQoDJXqXVte786 +1nMeXMuMw7tCclG34tyMuQrF1M4ovA0p6XGChb2diWocRQdU3qpy1dviag4afROkDsavN2ki0Gh1 +gBzOYHfhufcLUDmrtLq2vVMd61n/r2bE4c0qTceMir3eb8CZC3IwvTFqRE7vaoS+UTmXDlTeLilv +2gKQTt4OWB1QKFAECo52M4vDGuwqAUeBAJW7Sq1r2/vVsZ7z4FpGHFa9iVkNVFWGByiVgmVy06KR +eil2S1e+5Nhh3LEmZ2JdS5p26vVTlAPQFGEHxYP8VnZIcQa/h+nrg9/DOqWube+Tw7rt/jUMOBL2 +OoR0LvJ+A+4nx6lqkebgas4xdAtUwuqAylY6lrJtS3cQjVg7UChQBB2sl4I4rMGKgzsKBKiMVWpd +W99dw3rGg6sZcLhsFh3IileI3W/AyVRWJJgKByFQTwkCsIU1OKByJ5SybNo201kd1jYosuqqHcB+ +7QvW0DenTkEYNzKldmjbu2tYz3hwLQMOaaC6NZz2H/rkdeC56jVSXHSRjJ1oLF+DOkUIqH1rVcP8 +1rbhvVxxg3UAmnU7gLXI5YB17TdhdQpWi2wN1Lq2vV8O64YHV7PisHRZ04GD0eqTt4OppKkAi0Xo ++shX0UTjuJeUdT5vy5dQb7B2IFFgCAwshegHpGstZ+9HmH66k+paWp86xk33/+NsuAwial2Ts1/u +N2C5Fu8ZVw6U/lWrTYO1Cy1A188GYk3E3OqmbXRHrhWrA3obzoGlXNqIdeESgCMFAuQNtFPb27p+ +daznPLiCDYfX4qyL+FCS1Tdx4Gyxf7xlJfRctKaXiXCNDAMyXxYpEzW0xeO3cxqxOqBQoCOjYKs6 +5JCGzuxOQOgH5D2xwbNQu2VIzzlwNTMu9zBh4tN59xtwdpUxYytiPSQtv4FVWufVAZW3fKR/aBvs +QLQhdbDkDg06cOz3CHSkwaqNOQIEaLxt27auVx3rOQeuZcRhec/S1IjJxlkFZr5ImKlNxSLAdl0O +jGrrMGUsV7v3LbGscNigdEB6ubJVgV23cigxJ1vKxfS3C1DZqoT2tq5LHeu281cz4PAyJzuYQ2X3 +7jfgzKVOn8nlRk1Dynq/AkrxZXFA5SwXqhraUp3GNmJ1QKFAESjYqoA6pFjLxYrUKgECVN4qsb2t +65YhPefAtcw3vOXKks1IIt2fgSWInpszmKPtHzD9HIz5gocXNa6vLRe52NphHGBdSjpwtKLuDmfg +OyfH1wvQ+NpKGNu6LnWs592/hv1G1YMt23edey2ifiYvy90deJ9XiYvOt1nZutQlOaDylYrzjm0X +rBwSR6wOKBQoZztYi5c5rL1kq6Mg9IIPntreduiuYj3nwdXst9y9eJHvVb3fgNE315QMtW2L3fM1 +r8vSYcraZDmTvSUVUx4QOqC8XD/fwXR56oi0V+t07xegclYNa2059FNxnnf+WoYbji2VsCTMsx6g +HMHVal3RcT0e3bTYdXFNNft+Rq/MLslU26JETCrlFOsInDUjcQCrg3jAWnILZxQQ0Hhr1Lq2vV/m +dj7jwdUMN6wZFvVAPoV378/AWjUTgbYHuJHvIW0Cauda1CRI37a0eoa1A3vceQDbbb8eq8nK/v7W +RW2n1Nr1Hjl8m94/xm5b/u0SKQv6WpzZcj8As9b8ozsJVnG2805md6QIiPhQ9W42126DaTSSDILh +Ub4S0OHASvnL5mUM4092qqyl0d4Rbvt4rUN2gLdYqgNd2ny/AWdLGUNS1yyKbkpNr5UoLXogdwtv +3tMghrWNXCpxxNqBQoGOgoJ7QN9hDXYJraNAgMZYoba3df3qWM95cDULreBa0YGLdqTGgfHGI7kj +BYtwRC1Zkezaj7JYeZyk3lu84mRWq9jaSoXUEWsHCgXKXgVHu+LKYQ16IakjgGHKXKXVWrpOdZTn +DLiWgYY3hFh9t6DnrB004wk/vWFEfVf9EnS8OyU5kPI1zRrzsZZ4BL+GDc4OTG41d2gcbpmZ1Ryj +e5796wVkbF0tl1daui51nGe9v5qJVnF2qxJKYvn+DNwkkFNnuQScF3TRy6RSic0BlbVUvGJsG2w7 +d1g9kChQBH3rT3KMzGENVijXUSBA5a5S69r2fjmsZzy4lpFWSTqr+YeJ3/dnYKOhh83tEqIF61YE +BxTWbJoFLnvq0XkQvdgmfFOvShYbWSfwrPdX9bcK0PgpFLq2vScO4Vmvr2Gb4W1wQQvZzEVtswHs +9i6+X5smmlyLiP1a1IqzGpO0UTcNFFnbgHeHbLF6IFGgTFVwV9kc1n6VhKNAgMpZpda17f1yWM94 +cDXbDDfQGjWjdVXVwIFTv6cNCJZqR8lyPPDGKZRhHajshUE/b7u2nDdYO1AoUAQd7K/CEqxYXTCF +DQUCNPaWs7a+u4b1jAfXMtFIGKmrmFIO7jfg1Dd2rK1YjTlRpw7VtepAZQ5s7O2sbW5absipFgqM +LhdiAIv57JBGzmkcCRCgMleJdW19bxXpGQeue6ZuGGVMybw/gza56oZuYTPvVYq6i3TvAgGVP0tb +61nbXp/FsHrgGjt/O5Qq445Ihynd3QsENAabT81N1N4tw7rlwBefqXtkQZYPmYK//3erzwLMgxWw +bk/YebBVUplrs5in1VyZK2apsprm6rPMlW7WXTdto6viYVijq+Jh5qIHWyUVj9VqrngKXH0WT21v +6/rVsZ7z4Eqm41wx4mLRH63P4sFcTAU7tkpuk9VcwY5pBN7VZ8GO5TC2XBcpJW0IHcRVZ/Fgq6PS +EVq9Ff9qV5vFk+na9t44nGc9v1ohz4p34qg1bLVZPNiqqMyVLq+X/FI5voydg2++CIvyNcqe2duu +s1xT6bE6oKvN4sFWRcVjtXorngJXm8VT69r2fjmsZzy4ViFPGOIc7HiZ1mbxYKuigvSWWcv6Sr0V +7BvfxDrUZkE+hDq2XH2cSHE6oKvM4sFWQ6XjtFor/u2uLoun1LXtfXI4z/p/tTqeFQ== + + + q35rnozWZfFQq6CCwLaumgDNtVYAJx73bw6onNUcyt52nbXWusPqgL0ui4daBRWP1GqteAJcXRZP +rGvbu+WwbjlwrTqeFe/gWFWPUCeSB1sFFZwifJWQq7WCXdMKo64uC7JhDpuWzdXbM5zeaWZVWTzY +6qd0nFZnxb/d1WTxlLq2vU8O51n/r1HDE98/q+FvNVk82KqnILBacFLqrGC/NKPa1WRBsFonri0I +yqwV9AxrB7qaLB5s1VM8VjPzPQXOG+CpdW17vxzWMx5cy3qkXaAbaVqTxYOtIgTNkKSzTuqsIFAP +GLuaLAiuddOyuULIhrP5oslakcWDrXZKx2k1VvzbXT0WT6lrW53tajjP+n8ly5FIs5K2Vo9lBEvl +FASCHPelVwS4Nl+kRftWLF3dtS1ra2dYO9DqsYxgqZzisaaupHQKkldSOrVD294vh3XDg6vajjRN +Vq2xYvVYRrAUT0Fa5OaDplVWaEYtGr3QeizUv7Bt18uuOoQdaNVYRrDUTekoh9Wk73a1WDyZ4ypZ ++3UfJZ8B/5eoxTJjmMKWcLcUHdiqpsxltcreVl8FVoZNSFeLZcYbvuaUN22j3I88YO1Abyk6sFVN +8VitvoqnwNVi8dS6ts1JYcN6xoMvz/9EpHL/R3O1WDzYqqYgqf2GB6mvgt3qHLRaLDNdyqb1Na0t +3kythr1h7UBXi8WDtWyKR2r1VTwBrhaLJ9a17d3qSM84cDVjsWAOqnoXrBaLB2vZFCR3kbPMVl9l +plv3luCA3LWMq2nbFgyGfpWEIO0wV4vFg/tdlA6p1VfxBLhaLJ5Y17b3ymE948C1TMXS/FUrcsLa +Q61qCpI75+jLrnDX+JLooRYLskHrvLm2sJ6jxnAMawf2WiweaqdvPVKrr+IJcLVYPLGube+Ww7rl +wNVsRaChWvac1WLxYKuaMuP1kqmMtViwby3ruUmrxYJ8AH0pbdpmuTV+wNqBrhaLB1vVFI/V6qt4 +ClwtFk+ta9v75bCe8eBa5iJgTnLbh6vF4sFWNQXpXeWsp9VXQeBcl20tFuyyGguubcY7t8MGawe6 +WiwerGVTPFKrr+IJcLVYPLGube9WR3rGgWsYjCiVqpUb1FosHmxVU5DUKrd0WX0VBC7r6ouuKF9L +Uu+PtS1gNFsQU7F2oKvFMoKlaorHavVVPAWuFoun1rX13TWsZzy4msGIo2u1X60Wiwf3GwML3oc2 +mwPWpi0MYXBA5U6T2veubWGv+Yi1A10tlhEcg7VVrJEtypECASp7ldqhbe+uYT3jwbWMRqRhNkPD +5q6HthxUJuQQrTS2EpZCP5DQF2RcNFDeW4aok9Gh7MBs89ZDw5J1iipOLYTg384w/bjS6Vv2DjmU +Y9+vlQhKxAa736KYluDBclCUOmFmot6siH2IrTigzZiseZyubc12Yrdj7cBxRRtYiqaMWLm6ykiA +1mEZae0te6ccyg0D/sPO8M14FijpyYpuwzmwVUyZM+wwTU0Nqa0CSwrv4PVAYkaOdp7RtcUIm+px +hrUDvQ3nwF27clj7RTuOAleHxVPr2vZ+OaxnPLiCDYcn2OSKvF6HxUOtYgpROmuQR2qrYK+yHCB3 +dVjmjHqPxuasbbArQR3WDux1WDzU1r/D2W+WdO93dVg8ra5t71VHuu3/1Qy4jHenR92btA6LB1vF +lDljgcpZlFtJcseulWg3y2kdFmRDj3Bb22i7k8Ma/aapdVg82CqmeKxWW8VT4OqweGpd294vh/WM +B9cy4QBzDVpRQuuweKiWTEFqNUvVaqtgz2rUyI/VYUEuqGLl2kZXHV2Rdlivw+KhVjHF47TaKv79 +rg6Lp9W17Z1yWLf9v5oBB5jTqiqC1WHxYKuYgvTWpFqv1FbBvukNcK4OC/KhRR0bawuvaHpUyrB2 +oKvD4sFWMcVjtdoqngJXh8VT69r2fjmsZzy4lgEHmLXSTq/DMkKlaAqSW0rQ2zdm5W1LantoHRaE +UmhiaJksi8Sh9EBTgh3UKqZ4nMHvYfr64PewTqlr2/vksG67fw3jjYS9ZgJaHRYPtoopSGqu6jHQ +WxozVqbVykFWh4X2lqA+C2uLv9pdiIq1A10dlhEs5289Vqut4ilwdVg8ta6t765hPePB1Yw3XDZF +kwatDssIhl6u0o9ejF/ShhG4SAW61FOMaZUuGgu1ttnprIY1D4qsumkHsFi2Dmk096IjIDpXpCN2 +aNu7pUjPOHAt0w0HOKj0sSosHgysWaoKW712Cv2hMQgwZD2DETQRkXo8W5q9ts1Y8m/dYO1AV4Vl +BNPZjhFr7NtTpyCOW5lSO7Tt3XVYNzy4mg2HtK2a4mtVWEaw1EtBoBZPjH13KFZQPI47SWztvG0v +Z+WwdqBVYRnBXDNlRLramPf3axWWkdTesvepY9x0/z/OgksFz3z6bMn7DdjqpYDCDYtYq2NKZRUQ +bi40Z1VY5hRMGXVtQekHi3WDtQO9BefAVi/FY7XKKp4CV4XFU+va9n45rGc8uIIFl4oVwndVWDzY +6qUgqTXPlk3GbgboVsrNA7lbEW9X37bFi7y1NJlh7UBXhcWDtWCKRxo6WzoBrgqLJzZ4Fmq3OtIz +DlzNiEs9QOiqsHiwFkxBcku/24Mrq2DXcmrRAZW3adE77K0tHtfR0J4i7TBXhcWDrV6KR2qVVTwB +rgqLJ9a17b1yWM84cC0TDjCnRW/sVfPYAa1kClErQUetrYIdK1FLl5qRkaJd4ttb4uXTGt00lB1o +VVg8sGtWDqVVVvFvd1VYPKGube+Sw7rp/NXMt4SpuHqDhVVh8WCrl4Lk5qxRH6msgl3rVwlaFRZk +g14T79rS7dB1g7UDXRUWD9aCKR6pVVbxBLgqLJ5Y17Z3qyM948C1jDfAPPdbHrQKywiW8HnKzlyO +tn+sdp9atO0DiMxxHVvi4Y9cR4we5qRkB1u9FI/TKqv417sqLJ5S17Z3yWE96/41rDfcPuXiCleF +xYOtXgrRumh9aKmsgv1q8+rLrShf+3Ffaxst49dh7UBXhWUES70Uj9Uqq3gKXBUWT61r67trWM94 +cDXrLXUfnqvCMoKrpD4nPFqud4oVPppInWsaLyh6jJEkYKr5rC0oMOsGqwdaKRYPRldAVQTFcjDV +anAUJGdhOGpd294vh/WMB9ey33CIk1qWVozFg4GKVYWtKuPoC41Kbq/LR0Dlzdps09W2mJVq5psg +7TBXimUEg6Zj67/Z7eNrXTYECFB52y0H17Z31rCeceBq1hsSkbSstZViGcFyVpaAS4+VcSQ4ZRfR +tlIsBE569s63ndX6clg70EqxjGCpJDBibeXs/a3L206ptes9cvg2vf+PLcUyx+5u8RacA2sRlTmi +1jmUWZljtNPQVo5ljqjYD2VbYGJYgmpH12HecnNgK6biUWrNFf/uXp3FE9lbepeSoTzr+LWO2UW8 +/DZo/qJWaPFgq6WC5KameVFSdYV6Jqf3XYUWZIKeyXdt8aS/anuGtQNdhRYPtloqHqtVXfEUuAot +nlrXtvfLYT3jwdWst5idt9kqtHiw1VIhgi0XTY5RY+dS0QI4VqEFGZGqWszWdkENc9lg7UBXocWD +rZyKx6p1VzwBvUKLp7W3zM7dbijPGHAt4y3mTYmU+w3UqqkgterXsror2LEuNaxGC/KgVD0zaG2X +87ovHpjcml7O66l4pFZ5xRPgqrR4Yl3bfF755ZwDVzPhIqYq6yl0q9IygqWeCtHbS/BLcDB2m8BV +aUE+rFUrnFrb4NQSw+qBVqXFg62eisdqlVc8Ba5Ki6fWte39cljPeHAtIw4wr3ZYyqq0jGCjoQfV +9axVJB+1L93CPYtu27K2uDpVjTNudZCVavFgq6zicVoNFv9+V6/F0+ra9j45rGf9v4YVB1hBx9jW +axnBbicLeR3rtWC/tIKaq9eC4FA39VpoyuG6GbF6oNVr8eCu1zmsVoPFU+DqtXhqXdveL4f1jAdX +s+JQV5nVz2H1WjzYKqsQwYsmUGouSETFUi+lsHottL9YAqVrq3fEO6wd6Oq1jGCtjOCwWg0WT4Gr +1+KpdW19dw3rGQ+uZcWRWLJUSa3X4sGpb/PoUwq6pXINFuxbsxRKq9dCa3XVO6Zc27RqXSGvaKxa +VajnTAxgLq3ikVoNFk+Aq9fiiXVtfW8V6RkHrnvmbhhlrdcyQqWyCtHc/Vxcg4X6Zy4Aq9dCc8q0 +V9cWDICyweqBFiYdoFJZxSMdprTzgizOhujnwt1E7d0yrFsO/FXWa3HH8L501M8KtuAtSGrE0Vy8 +34Az+w8AiNvlXLX2hNzNPEfLCRQgDsGywH63zHFsu/z/7L3rcuTGtSb6BHyH+qMIe8cGjbwASGz9 +Einb43Noy2HZM4o4MdFBsdkSR7z0sNm2tZ/+rO9bmUACKJJAdZOsYpcUEgsLyPvKleueLXJ32EGt +OTD24PhAwf3BQfDJCNzlfDFGGHcborUxXSMy6BiBxA3GqaWOxW/LgEQCyWM1IUwGzDq2ZsZOBGfQ +Cw/JBy+C0SDDqzQTKtAG3Asq3JUOxKbQDAEzplyBVn2hApL360V1ZYuEcawX/IKNWZFKmC0pRYRK +09TroKOTfMDo9KKLEllabMzxQl8rnYmAzdmlRVKnChi5mib5MTrVFeJ9qDhk3KWVAsPhZ2gxBFsa +Jf0KrCvkSrLSlyRwMTQHeWIA5N47jhXoDQW2xNEsnNAJwbjFCytnS9txxBqpEZXM1BZiZGXn4gQO +KSUiLV26XFFmIeXUlvmqWwVGlbvOrdXI3eD6EE4gVDQ0yzpERRsWMlqXAjIAGaahmi76MbEBY7PK +t8j6sudXcWzRtiJg+sjqt0aTUAbQeRWlwDGqKCSIKGxgJK5tZ4cJrZytnvjL/C6dh6Le7FuWXbhk +laUfLOsYeYJFq+MNZzLeivpGLISrNZmWIGNlm7iSclanjQmnBRMXzcOlNOFzWXsuWh0xUTimoDiT +9MDyszVJxvcgSWlPttanJLOt6jXbLuVPwMXnyqgjeNZSrAm1pqw5i7MKO6GubcoH0JaaDEKnulTm +G/Nv0g4jFhyvX60THgRtR5K/+uZP4c3vr98e3X788LOQ87vz22sAKwDf/OXm+q9C8++E7BeFgo/O +f7q4zl8c/OU93phSX33/P//4h4tLqebgd91POWd+98OfT/5y8/YcPwcH0L0vvl795t9Xl9fyqpBu +3V78+PHu/AOOGjnDbk9HX5z9fHH59vb8Gu/t6nd/ur7r3+F/d/Ek+035lRxk/7i+OBNgOs/yD/95 +evlRv/z3wx9en17xO3SCvdrWcfw6exy/vsA4ZD/PHsm/Lt7e/Tx7NPHrrR7Rz+cXP/18N3tI6fNn +H9PNj//n/Ozu6Obj9Vvp39HNI3ujH+A77n/59O7D7FEOyjz7UL/505tvLt//fPrGzB3jxduMN75n +TPjmP2f0eFvI5N3H2x8/Cod/dj53FrTozCVO7Tw30RRhfe54fjz9cP6H2/P/+1EmYQ== + + + PgkdlXr2EV7ffH93cXf2CJXsR/mBX//94vJ8/v4clHn2Edq5Q7v+ePXd2d3pPxeMLC/y7APDlps7 +ttvzDx8v558b6fM5FOierpsHur6e+mWHwPnfc3LycGcfmPdnXpCL67nLcfP+/Pb07uZ29oL0BZ4d +zb6/+Xh7dv7H29P3P1+czT7iHpmK/KS73vK9c3H9CAkZDMa+4K45vrl6f/Ph4m7OpnmKDpAPe7Tt +3317/m719V7a245x7KW97R3RXtpbM8otkfb8lyztvbs9Fbb38i83Fx9embw3W4jfi3vbKe7N3pd7 +cW8v7u3Fvcmo9uLeXtz7YsS9wr4WgW/JSLZc5POvTuRbMKJdEflEDjo6/+f55fc/n769+deXbfvS +I5Ni4Ws5MH+8/PgIt/IZmM1tlQw+3L399vyfF6fo0AKpJy/0YjzBH08/fvhwcXp9pAu4K7z07LV5 +O/8YfvsS5/D8gcw/hd++xDG8hAJsOzW7effuw/nd0XPQtBfa9t9xhDu04S/Bt8BL8Ozm8ub2v/71 +s4oxM+nzr5fzVYnx6/0G+oSxfHh/fvbdx0f2w+5xBLN9ez58vH13enb+/dnpEsQbFHp+qWP24GRx +P16e3h7fXH+4O72ev27Tgi9gTVs6yt//+/3N9fkGo+wL7pJsUlRlOXuOtlzFYcoFY9luJUdhl4zl +v2eP5b9fkAf5683F9d1JVF+8hD7y/Pu4VU8ic7FD/NDrNCYs5Bu2nQ3aSNGz2Jqw3Wu0a5LREiPJ +thCD09uLu5+vzu/mG+B2iSjMPvZ+eUSZkg0Hn27xQB7hxfOBmG0WFX5x8wfitnog86nyLy9BlF+l +FX4xN7DtR+flxd1fTy8ekyW/8LNzd2Tl5WrixTvuhRbyz+e3P51jJneICVq6uV7jWjxdB/YuQxsr +1L56Jeq0BV4p261MM2bvMbT9HkNfVpDI8c3N5dHt+fl/z7ZqvkbPqLcXl6fz7bq7pMQwh7Pjym9P +3158nI+66fPd0G5ut8Q5fyBv5w/k7TYPZNdEzD/f3L7/+eby5qdfd0g02ZO1HSJrr4aYzY9g2XJi +9mrD2HaSmBWvx2X11ez0ZeEU27zVZ49k1/b6znncvt6Y/dksyz5m/74xvmzM/mw/3F2L2V9AyLf9 +SJq9ybb+SJov4ezYkbSTWRQe8SjJyNoy5/sX8rr/Inf81jtq/Dgby7aees0eya4E4fxttjn1+OfT +6+vzy+/PL8/PlujTpgWf3yI029K66SCnBV/sHPr24sP7y9Oz86vz67s/n77focPo6lSqmm2Y3Anp +aJX+XU1+msHPuaPmr/n8d/p8iynl1p/Ey3INbvPpNXsku8Z7HyOM+c+JfOwKvVuAWdu+R2brELZ+ +j8weya5wePMjkZ8n8cq27L53i/yD3l1cXi7xf7rc5pV+d3tzNX8w/Pj5tZKPMDmZYewxj/HcMvbx +RWKuZo/lR9zJNV83rl8/v1H/8l+nv84ek1C+u9PbRZRSv99eTfjdzXzJ4+YFBnJ7ThFw7nBO3769 +uLv453xxqi/wAvaY6/njOjv7ePXxcW+hfGRZkReIaLo+P50d/nJ2enn255u388fWF3j+4LPZvEW2 +eqn5v3AIcxdwWOqFRJLT64ur0xdLDbureeiKsHeG2TLJ7uzVOMPMH8muaT/2zjDbou7dX1g40Sns +mjfM/Jxmu+YOs4CUb/uh9GrcYeaPZNcOpZ10h5nNf+6GO8wXueO33h3m7NW4w8wfya4YS/buMHt3 +mG05jL4AdxjzpbjDLKD5234Svxp3mPkj2TXeezfdYRZg1rbvkVfjDjN/JLvC4W2bO8xW2392x5tn +wZZbSjxeaA13MWvgAj/A/So82So8Xc6NHViEp+vACzW++0kbv/nTm2+Zs+fNMs3XLIZod46o15u3 +aL4acEeyFj1PAvCXoqZL8uTsKdrDFK3eU7TXSNFmL+ueou0p2iuhaL+/FcCXzaKdYwpeIz3bc2h7 +evZl0rMvmkF7tfRsz5/t6dmXRs9yo86bZVb4V0bWZg/+C7Lh7bfNnG3TfMnbZvbg99vmC982X9Zt +QX+9+Pf55V8vT399syzYcRsddqpyVc32ntSZ/9sCB8qsxC5Rvtvzq5vH0hvsWK6X+TlF9vlR9vlR +PhPSrczXtlyZSv5fruS/r+W3/P1aXqxem8v2xfXb83cX1xfzDVy35+/PT+++XbDdshLPPr59jhgd +147liPnwHlli5o5ul3LEzORGvrQEMdvCQ73CCwp/XHLZ+JZ76i8Zy6746u8VFttLDh7b27tpV1pE +Ebacum1oUtr68Pmbq/c3H4Qt/+7jIyRslwP44hh3iCCc3l7c/Xx1fjcf13aJMMzWqf3yiHEqGw4+ +3eKBPKIMzQdiXkIZMXsgjzg/5QNxWz2Q+aT5l12hzLtxiC6UenbpCH21WRE/yxm6OyaOjdZ0ZxyI +9gGAe3Py7pmTl6Up3Eat0t6cvG5W9ubkvTn5GcfzWs3JJC4wKNvy60WEZm9C3puQ9ybk/TUjk5Ht +Tchrurs9KuK9CXlvQt6bkD+/dmJHTcivydj69uLdu4/zbzPZdlKwcDi7Qg1mp6f78PH2nXC23y9L +8z8otL12JJ3+ZWMblHn2of16fnl586+547u8+OnnO3lfnCEP7uwhjott7wLG3Xl8cy2i+/X8fTcp +t1e6vajSbX/H7eOj2SvdnoKUfv3T7fn59dfCgZ1/fXH99uKnm6//eXFzeX739e35269vbk+vf5q9 +1fbauL02bq+N22vj1oxsPh+2V8m9DFdlwmyry+l/X1x9vHvk6sd8SdL3z4549ewxnV/KwyKVT1bi +xfQ9316Qfz/B/nopj5hvVZY4iXt8h1D+NamdPrw/P5OD6/Y5fOGfXTp61cqa2SQqLfFiaX9acJvX +MHb29/9+L7zeBqPsC74A4/2INvcJVFN7vc1eb7PX23xBepuopVG9TVTiUH2z19vs9TZ7vc1eb7PX +2+z1Njuut7mMCo1X4UKxV0I9vRLq+yj87aAW6nXmz9hAH7XtKrZXGQH8nHrDF6JP+xwa20YcXk0O +jfkZG7Y8h8b8FdnyHBrzB7LlOTSe5x6Q7fYm3v7j8/Li7q+nF49ZKfZn5/7s3J+dGw9ky8/Off6p +bTs7l1LlbT82NxKmd+Xo3Oed+rS535Zjd/F67nNOLenACzW+zzm1Wzmnvv/59O3Nv57i/qLdoURf +eHaBXfHrnJ0UbR+R/+xbaPbFmm8fIae5W9u/XwDJ5g/k1/kD+XXLKcC2U7Obd+8+nN9hS9yev11E +p3dNBviOI/0yBIDNV/U1SgLbsiqv+z7xvWi2y6JZYaqv5qLkfD7jJdiMJSOZz2i8BJ9hfDl7JP+6 +eLvAnTB+/fwjcvNH9PP5456H2ZDS58/PQX2JSo0nyKK9O9zVXqmxE0qNeq/U2FpWOLwWpcb8geyV +Gjsg/u6VGtt77O6VGttIyfdKjb1SY1uVGl+YaHZ3usDR8jUKZu9uT8/uTi//cnMx37FZC89c49TS +c/tnHs7O2fLj6YfzP9ye/9+P59dn8znOUakXiEn//u7i7uwRBVYuseHrv19cLsiVMCjz/Jqv2T62 +1x+vvhMs/ueCoeVFnn1kZ0/nZfbcI1mm1driOOf5I3lCgWdbToXXl+xowXnw7vbmav5w+PGzD+c1 +pW56ramOysPZt7bc3cznp25eYCj73EWDwe1zF+1zFz2xanm+TPKlpS56EqXR3z/e/vjxUiZ7l/SI +rzP3ygKRYsuFo+dJufJCet4l8WF7Veta/vCr1+E9Nn8cW+47Vr4637EFI9r7jq0Z5YsbKHq+5M0j +4fev20xxl/Nnr8hIUe6tFDe7baWY7c20a0YKbLktUInvxb3XLe4tQbO9wLcX+PYC317g2wt8e4Hv +9Qt8s0WD1yjwvV6/tNk5HfYS33ZKfLMXcC/x7SW+vcT3SWi2l/j2Et8OS3yFeS0y35KRbLnUV706 +qW/BiPZS35pRvrjU979ubt7+dHs6/7x/jSLfq7wzYlGM+JaHSLzGjBezhbl9xotnJwj7NJ4PDWSf +8eITOYyUB+JV0OZ9/o6tJWPvLoW700uI/+vHy9OzX75eKejm/enZxd2v/7VAJ/zh7tfL+Tru+PXz +u3AvuXB523fWosHs2mb6AxBxh/bS69SILtsvO3GubpZzaNtv/fnAVI7Hr4m8fTmMwy7eBviaGO6l +12du+cZZOJxdUYjM9jr58PH23enZ+fdnp0s40kGh59eUL1utZWMblHn2of3r5wXR+ZfQ6sv7Ygbn +kY1wXGx71y9uzuOb6w93p49dpZhrVcbldkmBbtzszXv63xdXHxeYtrrvn33JiXOvJstQPTun1fml +PCxSNmclXozH+vaC++YkGhlfwmtA+sA9fBKJ1Z7b25VbX/cs0i6xSGmBF5+x04Iv4Ce/dJS///f7 +m+vzDUbZF/xCWMI9v/Ty/NKeXdqzS3P78H0kVDvIL71Oa8AGnNO2M4PP4ya9/eu0V5k/QzrR24u7 +n6/OF+R13yXiMPtA/OURn4JsOPh0e+WMXx75Mh+I2eoVeSSDTz4Qt9UDmU+Zf3kJwvwqHYmXWs+2 +/vi8vLj76+nFYxL1/uzcn537s3PjgWz52TmfCdjys3P+QLb87FxKlbf92NxImN4fna/g6NwdPfT+ +lsZt5IWenBLuwFo8XQd2CBFeayqiffLZ0Sh3LxXR670ibyOLwXazon9fnMN61/i2nUyydHUqVc1O +L7ELhN2syvjvul8dZO6Q+Ws+2Uif78D+2naK8Ucp+uFx57HdJRiMpPpz2oC7QjFe4dn0rPFf25p9 +YZ/i4/kTpL2aHB/FbGFq25N8PIsi6pnH9N0XE+W6c+kxXqcT32LW7fXuoO23p8DegJH9/RUnQN5F +d4RN1mXb91E+ptlhjbvCapvD+bFRe2Z7fyZ9hr30w7vz2z9c3G6DimRb1vnu9Mf5a7wLCk27mm3n +4Nj/5zKN5aDMy6Xi+nh99rcdoiavDssOm1W5+jLw7I97PHtBPDNfCjk7eikXEwo7iLr+++3p9Yd3 +M26R2B58f536kE1YtW1nPzeMM9kFbYgObUv46r0+JK4MPee+ubzcgjXZlinZDFn3vppLOvBCjS+6 +/umrb/5kyje/v37bXQMFUAXIm7/cXP9VqmCakkLBR+c/XVznLw7+8p51eH31/a9XP95cHvzm6PTt +T+crsypWf724/uW3Bx/l33L13UHvUPPDr/Lw/8iP/yOgf6386s+r/+9/l6u3Av3hbwflYVmWbVjZ +6rCpVlcHhTksvamrCCisvK9MvbL+sKpcA0Dr6lbeu0PX1s3q7KBwh8F4u7L20JUo4w9rb6VKc2ib +IEWqw9oZeSGA0niPItVhsMHLN+VhWxv5ppZmq6ohwFV4tk0d2vQsRZpDE6rWdl+EQ+uDZ63Ou3pV +tChSGgAaF9gzU+KjBl0zxkozRvpUSRcE4NvWC0AG6NumA6CQjKMJzeCb2mPIAnCVJQ== + + + IDRNrSN2hoWcTFfp2bhMJ57b4Nh/VxpZH+MPLSbahMNQ6YgE5E1rVqY5rAwmQQC1q+qVqQ+N9Wio +QlekEP62LQvhnQxXv0XFKG0J8Cagu2ihaldsUQpLIfbCVivtlRTSbnoAGgy/4FCsXXFoOnkCatqK +oNI2ht/YSoYts1rbVitxTbPixLccEtZc1qQ5bNuqRrWlfCIjqg/rhrhBHHB+BZywtU9lmiasiDYu +9aXxK+CVK1EIuAYEwsqXjoWIj7IEgp9Y7AL46mXQQN/SdM8lP9bfRf8yli764rGJIm8j9qPoOxK7 +WvR9jeMhkgu6x9nmoIt81JiWop+XOHVFPndxeotufuMCFPkKcJWKfJniUhb9WsbVLrrlTihRZDiR +8KboESeiVtHjFvGvjT/aELG2dt7Ez32qAPPEKjEZbAbzxIZ1mdkZa1L3QuxwaBI2Vv3G0oE6G7cj +d1+Rbz9u0GKyi4t8G3OrV/lXkRoUHTng7Ju4HyLNIF2pPGFKWJTyBPZ8QJyKnjol+tV9kyhc0ZE4 +ksE67QGlg8Aj4yNiyboQ1WTq4gxgVYCQvtsFQVFF0NayA0BkroG0L6iseF+tElmPj2cHRP22TQBU +4DHjqQKSdW6NrhWSdVYZu4LOOlf1vcWIXDMYkQxbdorrh42JafiNTgzmrgUKd3OH6Q2un15ZACGH +Ni2AJ30JCU9cQDNYysp0SylECqvdpNUGyZQhVsCyBJBCMo7A2e6/qSvTRtTyjVK/NiT8QxnS9brH +UaKx7zdZoutxj7Ed0nU/IM21q02/w7CdQtntK+Cd7iaXNp9bjfZnpSdHZfJNrJ2IG12PXOmkTbTA +6AmFTceR1ThBhlSl4je2CibSHT2nuRm4ParAQiBgdaJgJc+1hkuvNE7Pdqx7T9iJJdiUJJYyNMWj +iOTOOOUhEo5XhoWIj5Ewt/VqSLqbVUbWc4rvIoMSMVsosxJ0r2dG43XgDkSJrUvBxJ+we0KuB0eT +PHN6G1fH08tzkELGax5vvtHDXpaPCFp5o20IGgY9IsNK59rrEVo3q+kpOz6Ixyf19DAfn/djhiDR +7J5kj9mKMd8xZU3G3MuIu1Ey3WT8z5hFGvNQUzZrzIkpca4jq1brnLYRF9En0uWmjfweeAwT6o5h +BFkJWP5EVUh3TPeedMnajuEk6apynjRRt0TcEvlL1C9RyJ5AJiKaaGiisUMSrE/HI0775ODox4Pk +6X70swgiv/nHNYSGt6ufbk/fXpyLVGJ8+1upRtbGBPxtBc+dfO4OfeOAAZnjvFkd/XTgq8OyFhIE +QJEeimBqWWBs7CCrLkss9ODo6uCdNH90JOLCf3xE35rSCIUqD0OwTuYJEFkOo8PAIsurSl569MRU +tSxVidO+kY78cBpH1ygjBkFC5tkKWroIkHa5HDhwHAUKwXdj9cCx8ktmyB3WZdXq6W9qMITxaKmk +MamkDkHPkaaxmFGZyNAY5SgaI2dtDYIW9CSpg6/1sHH987EcNtYBzTpQOHSmdXoEC28IxHMyOG1Z +cL6VQoKbzvIklGHIROG0cSUYdOx30CAcNq5/PuZZ42qff1HVlR41pgV5lwkA/gNQhppl3GFl9dwT +rqBWmlDr+GxZcxu25AyxU8FxHWNvG/JCspnlCFOyUOJMk91eovtCB6TvNc8ai4U8PkivCv3Yr7Sw +Hi0GO5sN1MpUyn5B79gJcLXsVkU5i90s2O+Sm78M5DIxNjQkEJ6vhgxLyy+ErOtRU1vWUZWg95j1 +yjptpwWjErCBA3e0R204aUTe445uGlRClHBYVSKJUDQ5aoSYlJRFBYMqHDWCU57HgWAZ5dfGl9pQ +xMQCuFnX3JkeLQN1TWiqBCjxcfzZvWJhs+rKon6cTxGtOXZTy5ddD4jIZtV1kXi8ygaBgcoiZONs +hV5gHgTzdaq8X2Uzxdkk6ayFtVzF2eZk+7ZbDq6Ga3WaEmIJEeDUJrziiia06hc9wyrFC2KOVyyT +A4E4hSOkxy2+aVcd+hFBraKYqzscZlu+UrQnmrM33qziNug6i+5bv8r2CfaSI76ZtuZWck6f02b0 +bVj1exG7tewA2M2m5kFC8pEmtN/voAlUPkSSAKJhW/ZQkEoPGzltVj1ZIeXRA5MQkCZB8FWiTFhl +UJmeeIG4JdqWCF+kewmHesqYqGdC2Y64krZ2tJdPxwcDBK4Uv7vS5GWlASvrq0iLBopBF5q4kXST +s4vcbFEhE0dQYJBej2AOEkKQdW0/L1FQqrOJKjiX3vbfjCdbSUFjs/UoxktWjJa0mKx5MUKKYow0 +xRSvihHmFWPMLKbIW4zxuxhvAKW71mR7pBhvo2K8z4rpVizGu7UYb+disOOtFhrSBH4CSkya4U06 +5ZSs1CRclMPapl4lClyQMrmeMhUT2qXHdNNTtyInf54tZxRSCXCRE9FKWYdEZMsQpddEgIucOse3 +sXjRlY9NFHkbsR9F35HY1aLvqw6nyMcTh1zkY+asFP20xKkr8rmL81v0E5yfgWkJ+mPStXH6srPU +VP2Z3x23HUpkZ3KHN0WPOBG1ih63Iv4VOQLK1PGU5edRM2Rkr0ZUrKL2qC4H3IZ2xpth96qMZ+m2 +VZHvq7j3inzzORchgw1cZDs47vH+G1CBxkc2DAufSEXGq3X0pGPoOpJTTOhSxhh2xKv/KtG3jr8k +gjRRVZGoILAolBmnqpjWcbFARtdCkO/puWKsNT07rGjtTWSXR+z08cEfREL4NueyayjrpQVhGWo+ +SrONcUlNEiric90mTa2FFEmiLUKUi7BSNe8iTUQGeDQ7EUKyjePAZl9hNapWx9mMl7DpiLDiYPZN +Y62ShzpEhNcNo/sk0VRIIWzM15h4gZRNo9ruUpWAMi9UuPFHXcfdIPyQjZ8HEyuotIJgI8demZAa +jrtPcFg1r5gT1es1xO4GGsqk+a18q3Pa2CZuWkEQqzPvqceolHfFugTfAxIBw+/+XSzel45t5E3E +jvT9iF3tehqHk48mjrkbcpqWblbS3OVTh3eqE4jzi9IVD8O4BK7j4bt1iqvJxbS6+bneY5TIMCJi +Tfoi4dUE+TLcI4Y2rv8m4XBC4YTnGZpjUqvAenUvYNpFgF7ZOuOXyHb3L8aFUC8k3r5eaTmYqCQo +qdxsqr7zqoSwWd9V4W8UIkR1NPzJ/IwmcDDBJq7yYA3GyzRex+lSj7FhjC5TjBrhHHEydCg5xVpO +nww6IfYI8bM9Md4vqWS3o1h5HfJtF5vvtuZw8zar4Qa32p8hEZjQCc5OU+fEJE2k7h5nV2mmO6LE ++v2AcnG94qGvC4b1dK4jgKqVbjIaCYyobf8FMKapMuLb6TA6pCLW8WSJoISViaYnvM3ofkLt7nBI +aF/kG6Lgjhg8nhy8O/iPfxz8g8qqH94e1Kvf/Hb1w/+aAr56Y1bfvJc/pRxUX73pVvmqfxgv82CV +MxQ6Q5ERlo1wcISkLDFC5DGij7cCyky2y3g7jTYcy6ALQXsUavaQGnB0uJnQDJQY05V7aBE+zenU +lIiNCR1LjDpQjPo3IdwsNCXvkwNgzXRNj5LJYbNuZaan1uRYW4MBaw7I8QmacEw/nxy+0/N5fIpr +welpP2EIxlxD6uCIu5hyIBM+JU3/mJ+Z8jxjzkhL6uoW3fKm5S/S+k+4Ppabcoc58zjY8txMGXmY +0I4JfUEJ9KOTpqQf6KiJ/azrKbWM229EUydUd0yZWWw8y5OFGB8CHNL4oBgfJOOzJhKV0Yk0PrJy +HLyGHv+ba8R+CUWEJ45QRLjjUIaBNk/klMbLiX6lIrND5w+roAb8Fn4D8HuoHUwbADjgRCVk3kQr +ushiMJfUh41ItYHfSJEA5UOlO8uUvhJxvi29i94IxpZQc7W+ciq6GZjWWqgXSxU1DaQoOYoggUTx +kEYT1YyJjCOysIdY0kBipSZAxUYMKwSnBp0SlgOZqarEAsMAVVn6A7m6hZa5PfSGz62BYVAOPxlg +qIiz2FUGn6h6vqKMzDLOKukzTUX/ijQFBeaggv5PpgATWaRZ4CTUFMzjLMCQRVFOxlhZVVFhSESG +ChsQgEo1SxzQsZYJytXasmLn1LxA65aDFqiChEu2t6FJSMTpVhERUp9VBal+0cLqDSnbRy2R8WWt +pjNq2iieB8wBijr1x2i5KVA9PCDYILcbe0CZXvoksjC+Ma1Vu7R3mH3hNFyp4qzgt6pBKx/dGESI +ddQBNVaRhlxnK3xE1WglZVs1tLpFsiEN1cD/RlYXEwiAScpQqgQSgE4AraoQIkj2rk3fWHjSAKPL +uo4obh3dDWp6xHAXYGPJWJPVX3FDto6J9NBGi76gdhVFTmkHCOrQspLwpoaHTkba3GHbqLiD70xN +apW+Q10+aq6IekXeoCutettIr3yr7BnFdXSbc5b6DUwVYcjmYysmEwAZpjV1P0XFmnksYKAtY+X6 +layHpVYB68G92XI3xH1dRs+yEuZNXepISoRCVnHtSxfxvHWRXIMiqTynZ4uUcsnRRlundlsRvRlg +YjFE1zpEZHfKQtg2WpVUOYQfXrsIbA8mfh39ibK9431qRZsFpUIx6Uobu1a3Omrvg0JMaKOBsIqb +rpTjPsnRCpNFhTmVY6QyHBRB9YKRdJJqWOdjc7BOdeR1QHsS/SWNLnIiHQl50VHyROuLjtinA6FI +J4J6gNFbiriYcNhTOeQS8QYOCwEpo96C77PXsQZUUEenqcG5cwa78zpjc/NbNGNAGCzMx3VzaKGz +M/RlcVNjM7wKap6MHiILnOJqQZtWEd+boKZnaV/21UpOZXdoZPP9cAUJ1FEr5OXEDVj6dSWbFn4O +zQpuVIK7sjOPzjZt9Ghuo152nJeFDrIPqL2TNqOh/B9yvv/um9u7gc84pB31IIZ77+oMPvsfr9+u +Pvx8+v58dUXH6P+Ur76W/w7s0Cd3JD2tYRGUxVzMJIBLXMomKBu8lFFQTnYxq0AZajGzIKU2YRek +2AYMAwXQxSxDLLWQaZAeLmcbpNAmjAOLLWYduGDLmYev3mzEPnz1ZiMGAnL2chZChrYhEyHIvykb +QTl/E0ZCCm7GSlBPsBEzgT2+ETuBghswFFpsA5YCBTdiKlBwI7Yi6g42YCy0yeWshZbbhLnQA2YJ +e6F6m+UMBsTgTz0qoxi9ktmqo7pxbZX8uE1naBdio8Ex94bLyJSuvrs9vf7pfHnAjBxIgvCOPg1W +qCtjZnAuQk/n1RHqhMZLX1f0rJKVawkKmEx62fDvCQ1WfJu+PtHABuz1VOeJGv5hgtaWWZet5Qiq +kQ+ge8+oBO1aqqZUp/dUT2qtyJpLnSnyXsXXRd75WE3Xv5M0E4rg7OCJTFHXtZOD1J2ugycHw2pK +dGHYGirWrqQuATDt+JrxrZmGfJrS6+xtrKOvInahbyZ2gX+qNuutdikfUj8xaV76aSk6L8p+diaI +NMsl1Aa4hJat8Bhw0rQNnenLFXahhbZ2zKa7Fq67CijSA3jkFoTRwScUPstTj1A5tw== + + + hRMqYbkHg1YKYTDwGpbWjbBseBV8A86uhA9fCHQaFUZRRg6HUGICTMuyQ4RU6WnNg6AElqlzgZ4F +PL4wb8IqqCKTJPfkQPoY4HgNdKEXLBfA0AQPhp6OtFDnkYwJrQ9yTimoIXMC8g8dJ1dSOCg9afjj +hMqaplaFYCOHg4JCTXVsrJQ4IUyFsn1smYjD3hSpf8QuPSbiIE4OOC7Lg11Hyo84+iLNBzGUc1Rm +r/u3qY5BFWynayb1pe+KTky16vvLUdmwygYV5yUbOadlxT+hyuYwzVI/0WmS+sXQOcoWjL1i27Gj +/ZrSecWTCY/rnsbbI0e5SvNyclAMXkeITger8JVupq4ZSA8CGXSFqFNMultMh1RMx92hTI86RXrb +T2CR6uhnuUi40y+FYrIgab9exWRNi+m6F1PkKHLcKdbgVrEGBYspohZr0LlYg/XFms1RrNlDxZqt +Vgx3ZOzeYON2s59t7yZfyKJHqmJKKoqEVxlBKdbQnYwunSSvGgE1OMc9HIYq/bxq2zoefFFkFkkU +ngrayZpjbtRqoVOtc5h+6BxGS45+r1PdejKasVpdETbWNQ9Yf7TzXf4q9iOrITXUt5N6kfdGX+Z9 +jjWkTp30MwAfqJJzKFtRz/LuRZyZvLTOy6SFQS+UEuGdbfueprb70UyHbLsDfDxPa6ZzOulrlmaw +gLbNRlP0k7EGGxRT+r8bmsabZBafDFVgkwmhvWs4a1SFjKaWMvpw/gU0WaSv3kyXEh3jeITln2KA +CoAjTFFL5Li5NXinRuMhekKymGCxClOT+UhbIXtdDN9PcSBrs8gbXYMJ/TiK4UCm2z6bnGI4d0Wc +vLWv12BWt1QZAvZLOujdunGsHfHayenm7jqTqKowtU66QyhlSgozbQwOQFBvmw4DBik7kVhNaSON +p3NohbjAUumYUcOuvDHWdPKN4WGnFlU9MBprETSuurgTeGyqDtAClRucg3BTpS7RUw/TKSwaKGg8 +wyVbBMrGgERab8vothoo3HbOmIgmxQ+6AbF/BToIJZry++hf0XfQIGwKwjqUnDWFOZieNT7fqmaL +/JMa3fED0RknB+klLdUI9CJRKWsGYsdKwSDV1Oh1U3NykLqjE9igX5hValzTNINJqrxtNdCHiyHU +D6r5qMDmkilhwlqq0IYPqJ3qP4DC1bVlnddTpEXMmivW9Kqbpazz3TRlYyzWTEU3UdmMda+1gEuw +8fxrc2A8MjwarGY9RMoizV+Gu0WOvG1ysu5xvNsCJw9bSGxwzgdaSIwwIVLE0OHZTEUvuCkb6AQd +NOjQHHs4WTO8FawMiIIIYo10RuYjiKyofuw/XOFgk87WLNGoXn1N0dYctlDYBtti9wtDdHS2catH +c1uVAvSGDrasNGA0N5I8ZuToKU3UgQ1pjZLuEbVRg8aI3qhxZERxtPiI5gA4oToC3ITukEwvpTx0 +IxnTHtL2MfUR4BT/CRxTIBoNxjSI2v3x1uMRNKZDX71ZQ4mgr5/semjjJ9QIuvYJPYLX0IQi6fnY +0SRqvidUif5JE7pEZfeEMnHh1vRyHXXSg3xMn1TDPJ2mdTRKlcpjKqXQ6Tqto1QZnma0KkPpjFpl +2F8M0X9KsfLNNDni28+vNBU8Xf3x9vz8+pOSDIWUZUiYFN9BEO4fGBzkD+uKgy+dZ4IAxn5qkqE2 +OI0gL6OhUUgRvcJdCOrTV8PyAq9Yp4VAn0qrof0B2QlE8qvqGIxZZ1mG+KhJhmpkWonvZQsbr86c +woVxp1pnDDe5UASXcgwZDWS3arQw+Eidtq0f5hgi4CwGRoy+qVvL8DRSGlowYvi5F2yOGVRC7Hxo +ak0VYejZCaNjqzE/Tv5hfJp6sAFU0agnBL8qNclQg8QYyAYQnG4BX8Myib/BpSRDQX2e9RxgaU0V +ULkQs1006jDrnE2OZq4q6cNnGG+k/WxW2m+aCgSjmQwAoezR46Flh2FyjHk3kDUFFidj1DE0VAxP +sw6emJrwxmHRhP7WrVfLTICVqEYYbPRTNAhnJkZ0iYnQbyJNdOj0yAcAtGqsGvA8Eg4A86wLMcdQ +DW9RIKeNsTihoe2jLIPrnlOOodCobSW+jKWLvnhsosjbiP0o+o5oT4u+q3E0RPCqtHGuOeQiHzNn +peinJU5dkc9dnN+in+C4AkW2BFylIl+muJJFt5RxrYtusRNCFBlGJKwperSJiFX0mBWxT38EG3G2 +qUzMSBSio2flmhAR0SZUx2GtDSdcN2VMCBAjA9Fft8oGwG1l4zDjvuLe07wD3eaT7alO+cM9XOSb +mBt98BVpQbSKMb6NBMOm1ah8zDBkvNNeCVnxq0h2oimvzhMMJcKUCFf6IlG2oiNtwA7XNhFfKqvp +hRrjUiqd0CqW1TE6zyPBEnHReBOxs25jeiH430QcrjT9SssMTZFg5/mFQkwwJFMfTAdBHZobKNaB +hhgg2zdEmp7y76A36C+JVOwvMb5Ne4A0HQO3MYUZB16T3arTzPT5heLUYW41yQ8BmPy67SbfkrL4 +lNyBtnKuYtOtIhW6LqZqqLFv89xCtW5kDfRoB9/UbfJ3rrxTqpemXjFPd1ObUUogsFvlpNTp5iSS +G03mIvQ8DEhyU/GbRLSxkdrBjtJ9lHZdPAz6jakBzY33+e7VPqRTxoR47FRpU2nqlo5SONLZITXR +DHnETtKbVdoEui1ofMdKN2gGdCtogHkgE0bS1jR6ntfxfG9TmQC0II00ekgyx4VS0XaVcExJLTl3 +xUMf6bF6cmcUO6wyap4ReiNkREl5UJy2TWRLgqJ0GXTcvqSrvLRfNx1Twg46jf+Cx7qOwej0hlr2 +GEfpObvMq8hpqOJUeebBcSXJm86lHo0lp7YFieFMazLC0ek6On/H5/P0CB+f8mM2YMgpWMXGATMx +5jamDMmYZxkzNVO+J5HnRJ0TcU5Ud8pejTmwMYum2OciOlpNLmS85oAiUaAd2CfGsEsuFEkKSU4Z +4jMpkvKdJEgkWjGhgdLhRNYiVUtkL1G9RBl7wpiIZ6KdibiOqG98PB4z2HMsyW1QdYa3DT1AKkG6 +mqmD4MfVrssuZJEYK1qS00MRTJC1hnQZrGsObRDaO7ElC1sZWmYOkr8V81fITKnFGGIkfggO+wbm +ZVkRuO6U8L+UU3GSXYgSxNp8dpoTgEii2Zr8qkg5xo6Zz861KblgqDWfXdXls3Mxn108Kgxj7TSf +XQz/R9B9nSVFaN0wxxCfjzWhXUr955hjyKoEaZm7KsSMdl3eQadxgBoJw/xXLia0S/nrhimG8Hwc +09m5/Is8m10ds9n5Ved4dhzT2emQG6bAi5m+Yj47TQbWZYyMEaZ5NrsmZrOzq5gAcpzMrtUEQ4YJ +LzX1WLNKZWMyuzbmNVvFtKgx2qI0KXOqTbnG3Crmsutyp8UkkZr/htnVOo8sy0x28bSxTcoeFmKi +RxeDU62v6yzymJnsXMxk18ZMdiZmsgsmlmFaQE0VF7QvrYmZ7HwYZbLjvCkmMs5KnVWHqexsn8ru +eJDKrrRdst2uZJ7/VCtnLrt61bUfk5Z1HWQuO7vKxsBcdmHVj7JLZRfjrxsw2Ey7plG/eSq7ph3l +svOjXHYxvRBXjEi26hCKGOZ1xetVt+AZOnkTYhq7SrHLh1Eau1YRUXEpol3CpCyLnely2B0Pc9iV +YZVQn71s2pjELo2j0Q1Vew3OJl3QJHbtKtuBMVg7bsBBCruYwa5apR2cprLf4ym1aCIDTGFXpZTG +VR8/3pGSLNMQISfMa8d0UBFCAlWmTMptR8N6EpbIXKJyiQ4mMphIZU8pEzVNxHRdYjtNN9RoHgC8 +H6aMds0wZXSTMufVlYbnZ31o6mxnxU5qtlSNDY7j0JSqmo6HQ9Wkq950c5HnG4oTyOStHF36ZrwI +MctlyNapGC/lKG90EgczXChGyFKMkSmSrTbDt2KMksUYZ4sxUhdjrC9Gu6KY7ptivLWK0dYrxluz +GO/dYri1i+neLwbkodFTKUuF2aWLVhIDT5HjlC7akArVKTAYzq2RShVTOqaHddOTumJMCwfpomHZ +OE7ponuKWowobpER42JMqIsMk1PxPF10aiPhct+RQbroKvTjKfIBxTEX2aA5K0U/LXHqinzu4vwW +/QQPzsPG9etU5AuVn6tVf/AX3WJHdOjP5mJ0fK86lCp6nBqmim4jstbOR9HUVrE43b2ZKbqJbWSJ +onVXRK1A1rPGh4xrKRLxLvLdFHdckW857dN42xbZvo07u/8m7v2OE+sIRMatjbNEh1VHaIoJNcpY +w45k9V8lqtZxmB3py9hQTRRd96xqTBSdcoKzFSaKTvgfFEkYQu56vjgmivarYkTMi0TN95mG9pmG +9pmG9pmG9pmG7D7T0D7T0BhJ95mG9pmG9pmG9pmGtiXTEEIkk0PvwKW3gp0FDH5tGmQ3uOphCPhU +LRIDPimPwGSiURYiWlGgsZTZ1PovGKTCbghWFdtMeAspJNgQLe5691dbOZP8QRTz5BRhWt3egRsp +ZpleHucKb7kJsPh3rho1g/GZZqDWhTTWxrTPKaBbbwNAeK7rLkKyTJcPE1JZx0iQMq6NoYiMiBRr +VNNCuV29FGjEdGrGwPrHyDRZieSsEIPNfZ/2xKdU9lXsEz7n+YlwlpQ8v1IfsXBIvzh14olpBVqp +Kyp9TERxRgdTbK3i7HCV1EfBRCN3FcoYcO3iNQVQJRCiQdwJos5JbRkT5OpX7WEb7QrJwBAO26aN +ccqhtdEPqjUu0k/PDShj0vgiLGsdvPLGdYyMJoQOV5zC7BuZm5hCV3c9EjPEik2lGapgESxjVgrP +65Actk20yVf0M5Ep8eohAZuerhsjtNXE0/CmiVJD49VdlSaYkpfA1KaHwFNBpGuiYwRZqltsX5ED +TtWpMUcLXpKjY4c8DL2+7vtcMc7c5gOrY9h2N/g6uUem+YHGx8QLK+IUNtS2ux4UQDvixHO8jOGM +qRjSkEoSzp5MAhe0Jax7SXbQ+9r1ANpVm3SrWfomJiSoyMXINFTlAA0FZGkrAciQaXEm+hoxjTEA +aYNCU6V6eGtDaiZQqUgDAgAttGIm5sHWlNFeu5YljK5iiv8Y2K6JLbJs0UFNvqorSl+UvNdjpa4V +muW/Sum/9ToZp56alr4tmuTfRHcykqs66u87AA2/0RMkgpAimumbQeKR5CEl+icARBO4U5XJ+lfi +YHGkb3F0Md8/iVLKx3/GhP/quJRl/DfqKrkmP/TZQTFImh6T/vsmq2GUh1ozDqErLpkd66A50Zvo +gcPOjnJec0TFZNjMnm2izVOJPaZvMFckK9YmUqNfBRjSqqZfBuT0bqo4XcRzJWNMgKGrqfp4V8a7 +Am0Vxf8Q0rMSTOdc/oFSd2JU0+X/z7Guu8iEqEoHY2oeY1oLpnMZZUWP+Z7oJa+K9fwSAPVgi/nV +Y/L17oe6WXbJ17N7AGrVlGYXAcTr/chsnR0MOhPTsaPDVjuc3wWw6pLMnx1krGW6hg== + + + xU6z1cdE6kyt3pjUnKyM0cz3dSRXvtFFlmWMpFt5BEGXJg7PJk/4PkV6xLJ0J0qH8V3G/rN4KwAn +f3gtAFDcqMt6d1FAWZI8nB30IJfON+QCqeBZgEO81J2gtzccKkekmrLSM4S9TYxMxzcF6ND9aspJ +PZRDq4z+EtM4fFlHmK01Dh/Jc7Djgy1L9ls4ctwI8sPVQd1ojpXxhwJHgp305dHZzCqP7q3S1AZO +oC6rsgvjWBO5MWUoM+gyljKKXMuZSpWhNmErtclNGEstuQlrGcXYxcxlFNs2YC9RciMGU2MiNmAx +NcRiEyaTCoWN2EwGhixnNGMA53JWE2PckNlEeqnl7CZCSTdgOL96sxHLCYl6A6aTcUXL2U7GKC1l +PKXQBqynllrKfLKDC9lP6uqWMaAIttqABcUab8CEAqOWs6HA3oWMKLOibcCKUnG0CTNKYrARO0oC +tBFDGgPEl7GkSmKXMqVK0TdhS/UU2YQx1VC4TVhTPZ83YE41Pdkm7Kk2uQmDGtNrLmdRNevAciZV ++aXlbKqW24RRHSkK2y7y/zvYqjRTZRr6lZrTNBip1li0xuqdiYHnunVKRDs+TrpKUluAs0JoJPqu +TBA8mNUjWf1wS96RyuFgLJoDErn81N9ReSibrtGLZCGbc2CHV49+V+IaX+w7ujs47D/Vqg4HdLwJ +ny4HrzHxClVhT3TXBFM5ONcipawgMWi/BmmzwfG3Teg/OzqbXePR/TX6ViZeaFFe7f2s+pqVjerl +JWvLPBMbrC5tcMvXV4ptssIPIDhZbZMx1ldM21CajPsWoqZMeOTPkQfSDJl42+W8RC7heGdpiPHA +LV0xbbpgDdxOa9V5NhJeq8YTADQ3qfB4td5QSglFKb5Ga/RXwDEsPbt1kISU9LYa0Nv+srbBBZ0Z +3SZVrwbkXX6RYSQIywEAA9EhbGD1GdxcR2/CuuEVlPKtiV7eZJgpmLhoCYGYN5nvjeTkBkETUVSt +D5kPRQbdItYF+I8dgg4hjXTQTg4/5eZLXx2dza3v6L76Kqu+mYNK7997a5BOI/WXop2mEl6MeNxG +S1GP1GE58ml2msXox0lajoAsthwFHyAQnZoAGcagn7jqE24FBpMrS0l1QxOJUlJKMOCpSvoxD0eK +CiqBKjGTBgBfNTGerwUHjGEiJYf6W4GLliExIQWfMXIpY1LDZFjSpZSpIYoFPVNDxieQ1XQ9f9TG +LNpn/Y2UwwspQ70asFmhWg01hSV0AXSz1GqZ1ckeRhlUKDOiYiBNYYDqC8Zs1Ej5m+RWryIhc3NM +Jnsj6iCNVG3d6h6FfoKCdBDmmUJXEBQT8VRwBMdzA0HRjb/FPkYmpf5b5JWfW+/RvfXKrtHkw4OK +H1KoTbAvy3G1AP+01GIM1GJLcTA1thALlb1fioex1DJM1JldiosPkQlS6VpT0jtDd1hQRfgOQvPm +6uQ8jaiUOukFgWUMY2khP6vjoyXxr+UQMDGwFi68OA2SLrG/XrhOJglqv4AGlCbZmVbTXlBXwFTX +Gn4YYnQFtB5B4xtVdAHXyOgKCK3BrCZD2nAz1vBu5z6QmaSrvAiELQcu+8HB153pjJinvxp/astW +v+i/5VacVevRfbUiHpETMqj1gX04XV4FLl1glbcXL3FqbOEia7HFy7wWz5G1Sbb+vXmbPlsemQ+/ +nN/9VoNCNfHmdwcIgxbCRjnWCwluKQm3CLfuksuczs/ObWuEEcqcNEgNyxNdKGUjC+egEY3yta0R +L2JgPlF1U1k3vgOQfSf7kSDMNGlxaiQIaxWOLdUqz0yDHts9xinBLO4V3TI1j/ca0LC7J8TTbxnk +D0UJNfeO8a4JYlWHD46p1VTVGttDjVfVPTPmn7cXd180oxqaYRsakWc1joszdtJDoD2zbEVvfG/0 +i9RqelbZAv3qvvCjGvywjePJWDEHjoKfzcbfQWLvpZDxdT9e4QT1fTf+GnkfSt9B6lEN9agNeLsq +pB9/B4m9T3Wm0aVW+/GnfiWIG9XgRm0cT8aK8Rfjzl1loNj/Ap0BO58GWEznoEB3qgxNivE8FuPm +NThvNA/FeBhdxWmcxXQqug5234ynsxjP+PF05JwO4uFgNhIkDYOY2WSTQdQczIWiZsg+8aM6/KAV +PbIBySYiQdIIUqXdGGO72TSkrvWfNKM6mkErx5PxRs9oBAHRXgJFiRf56YppGkuvKpqUGRF3eehN +FBQKNU8oEx7LMnq1cXUQDAe3nquThcKE22t5OXlXE+7wMVDEh3iDRdHAmtEGDdipyVLKy9oFTTbs +yuEjc2yYHlagnQbRVDY+1PEN8M/i1qkSvOEJn2xM1NfV4+JrtJN+E3HVCOiy0oehCtiGwpRDQ+yh +kqJnb2tq4vFwSo9BfbLOX8EXyQQdexpPSfbSNCxV80YGxOAxAyMqbmgMNC2Ts7ooSJcMQc96d3yQ +9f7kQMdWd5Bs3NmESKFssk4O8nlMNXQ9zQeCgcVjF3byljnUBL/IB19hoiyde5G0wsbDCXlkkO4D +rBWlauA6NdMRUDIY1VddqWNNyRwNRtZx0yCyzNICWuHuALfqATUSRjSrvlCjyfRi8AW9AaJdhYmc +W0hjghJIUMR87GqO7gCNpnRJZY6zsQqf5oLm9A5yljP7gOw4OkD0EEhuVLpM5ug4ns24x0oj/mpo +H5yms5M9rzFFBOG+B69CDQ57ZJfJQB75IdpavbYSEAINM212dZkuEC41mCB03PJMHNx/5YX3w3VO +fU0dJGuwg3X96mpKfR+P7yzFZdx3qcvRzc0lb3Vxfz29uzu/vf799emPl+d//Hjx9vyDXupi+6tf +uo/+/f7m9u7vv76P974IPsnaemjGSmWrvVNN+O/+dn56+efTu9uLf8t3g0ra7y8vzs6/Pzu9vLj+ +6Y+3F2//3/NfY3XTFv8mzOiHu9tTdL9vdzEX+/Hy8vxuVayOTs9++dfp7VvNh7jwFhnDePsqJly2 +iCrlM73YVwkUn3wKHcQZFZPVVquuYDH8vDA+/gJzFX9y92QfDWvoymkI1oqtDHoy+DJ1/rgfx/zL +S1bwXyiRqUgmS6gmbriaps6VsxIOBRTt0gO0u5WIdaGGVNR+9itLdLJW1ATHLGkY8EozdTKrVDdJ +aYpW6V0qo6+s6yanS0ysL4usTKEfc3H7pe3bK/KOxGXtFnWVri9QFxRikv6KGY75m//1T7E1v4qN +UTSs4hfxg8iVr1QCiC/Sl1oUZD52uKu/ayT24vig686GcV2s6ir+6ppQsO0s3Ph5mXKkruKQ885E +ey37e9n97oed3hWxzvgTn3bvuyLx27Ouf5cjkbr2XTDGf8R4jE7UXf3ErCTqOaILxpgRPMV7Mwwj +WdQnRG/wAjCavhWQMifw1i0fc2HzIZVPP/oibCY+HqdOxGe9+8X0H4yq65tigGPqxMnBuIupmkJZ +1zTOdHAikYWnlZnnNK9rxF/kYOErm+6eBotnUwJ5fmhjfHzbdmW756ROZ7CMSZec6FP6ti9kVqmF +gu0ZBVLWjfcXsvFB03HsOt0PaMqEixBpntnB25KEqHLVmrtT431QZXQVY+Y9z2wPq/iGmqzKcN2C +ZTo1T1Va0X/gqpgL86GildOrLY/ONm71aHGruFOqRpriXvO2ngI8nC1cNhBowrfqyNXvm+QfmXaO +JlOeu3eSgjjunuxx7v7putPtIF4yOnMP0drW76Ls8bF9pDfrlT2tqeJERYJpOoL54BZL0xc3mXqp +ztpmydem7fq+ZKtF0mpS8vOHt1saz8n9wxacMmMoLf++J7DriatdDQGRiIAf8IG+wXoVgaOXw2H0 +6GmYRAXip6Fxpux+wc48fMfCTdsVzuuGgjHR0KwneY9ixx90YYHFg5e/gdjAvxGZC++lNZZXHzOt +K8XTfNfCut1obsSMxDAm85A5ZdeVgAOLbducssxs42huG2D1kCAwoyOferPkPzpe/+OQWy9MvEbT +HGofrg4a3hRNf+aqCTU2egIZOkmna6wG5e49IazjotWhRJ7DeESIRAvd/UNHBBiPKuYeps9h/yqY +ulIfXCHXlXqsj1bQQ5vTPlbYxUtnh8fEwpaPNmgZZtMKgbjZUQFeXogDpO5SJHyRVxv8KMuGPHwd +GluRq5d+V4CYPmWk8Pc1mHkG7uraGV/J51cdCApA31Tx9hLeBG24tKMSicGWY1BfQEMGtc/Vgd4B +3RXU91AkGmoqJiXWgh4Sq3/Dq1tlwPVvV7/7XkTf659Wvzk6+ubs7OPV327uKMNmWD05OvVEWNNz +Dezu+t5/0/d+TblEhNf09Hf58+p3f7m5+9v52c3tW8H8/2RH1HJY8Z4R6B59MPB+sRO5/vibP/0x +7pW/v7u5vdJXcZSyud/e/Hj+5ps/tW+kE9/f/Xp5/qZvWr9aOGvZ4REeMnR9Ph3Hkyslvr351wYX +NHyZ6gjHDLgu+Kqlys5WpefVPgbeSHWYEmXPDJx2lVLg8qFQQ3NTk2cO6jGx103sdRNbp5to6sgi +xyQRA+nrszPNloxczhdXVPqlX0OeuVJnwcgzs+znZ5nBnTgDR6LENPsGZ95DTLNrkEzR3MPRIgzQ +hDHPha1xX5EqqLPHkG2e1crR7FYggNMI8PkY5zXscq1eJzG3Mo1IMWFlgp3kMAOjZrwCWIMt1oG6 +kmwgxpFGUBdLgWu4yzpd4Tvsx2P8dyNTJAR4pey3Yc7EB9hves45+jxYJeE9FxsC2uZ8I8S2GjHf +8HvHCfFw0cbx/u2zjds8WtwmjilnPz/T7VJaIyS+gW37KgPJUuvyZKAygnx3xVgHglilF8p0oHz5 +S9eky+pFnHL5ZzDyxlvDehgafQBWTWFxCCfTUaXTre81bzeu9A5h25Vv9OO8P1078E0cgvLRNfHi +e/nI2MFX2UxNQV2Ta0APSxsRTcpPkTYmXbsaALueMA53MksDaDc2DZqzY+CauWLY5ni21nTq00SZ +AjTCVK0PGgYrvYMIWddPIs0sWpXsnG9eiTTzh5vbvYV1b2HdSzF7KWZvYd1bWPcW1r2FdW9h3VtY +9xbW3bSwTuypVwdT42mxxsS6xhD7rDZWozdz3GtjBddrHyvrEClWVotMrJOGj5Y3/FQW1mKNiTW3 +pxZr7K332liLdUbWqWkyN11Oi6yHPb2ZdV3nmREqM7OuGcy6gp9HO1EF3F9p9rbWJ9VOnJy/u9vb +Wve21r2WYq+l2Nta97bWJ7S14nIfZjG6Oij1CkDNOCjyiKHpKMGStfWErFiM8B2DkrE1K7gG1Fef +tf+5jasGgXcIhW2tEujeWNmizaB2TiYXGtpWEcCGG7sfLNrQvDQyri5p82hxmziWvBem+TOz2yXv +dIRGiSZPZ4kLCZZMZycZLJkyAasmMNxz2Li1oGTwzArmoPJeUDK2ZaDUWcUiBuGWg172H6SbB1Nf +ac8rW5LJuMXKvE/pfQbqO4DctI1bBxnMVbVm/sbtr4c9KFZ8Dqli2jlKFdNR9MB+sA== + + + WfG1wH4camHtZjdvN/9o3VRtKqoUiRYgrVktWB9gh3oCEWVDCeXV2E//dvHTz3sRZS+i7EWUvYiy +F1H2IspTiih6eWiSI2KIjK1yaaMDZTJJKrgO1Esg9Pd0KoCk17l8Mmz8GYWUoAO6T0hBep3KPVK0 +sZrGZLaUMml07AH6eKNPJaXQvTKuXRRSaOLxNq0dX+dSgUJ6LjVBevmCvnsjCJa88utAmUCTCg5B +5X2gnrOdDKOzU6Qac+EkgvLi5jDlYJnABiOtJmMnpOe8Wcr5NHvDxteCnlwwmQw4RZWNh5xBcyFk +Ouwelosc+dCzVoeiy2Tu7xVKvnhp4B/v96LAXhTYiwJ7UWAvCuxFgacTBRIbTm6/9ikwjCBkLLZ9 +3BZ88XqQRnV4vTjblzasYhSYyT9LgsIaSGzwZNqHpwwK4+09Ax5bBqbcORKrr4kJC4+UbJD4s3kg +JuyxJqchYY80iePJDlLWfx5xoAvU0TQZnUDQ4BARgC5g4t56SOLO10GqMYSRf3HZVRxYB+rKZaBU +eZF40QyUAtAy0HQ0nVwweJWCwVJEUtZ239AU1MUydfMxhXTFWHdezbQH9wAfFBAE87wRtueTBITx +IK8GwCxkazrQDNYNLYZ2DSBrRxajxYZTvqY/n+JlVWg+C9zHysSuRvpKh+3mKSwYi5bjNcksd3cy +ECFRq+9uT69/Ot8oBAzWX9zqAR/peBA1wg4hE34CFaE6DNbbFZLoelyIlQAl0qWmh6J7nSoouhpS +Kx3k+ICgJgOdHLCc7SGTmvN2x52KhVPZVH3f4GSo9553JtTK7UBjVnfcTllVDx54hXAatcF1o6ap +5MjgocB3uCWpDI1eOiQciTkMpqxGfA/S5uvlgQ+Xhscz0qePYikWtn20SdtgjOQ/Pz4CbVP6wFOt +tSUOT9N475NazeEHqI/XiwtEKNO7/HAoMg9RhwoucUOympb3rSSQLLeLuOB59W4ClLK06Xd6l0qn +wh0yxOccGVzHD7FU1YOKcbVF3mYx6VFXQdfpDO+7lieD7VIoZRsi8YT5vsm6GXgJYoIVCEVkT4Kg +LNMBJIh2ND7gLe+ZSjV0FWQ7Y9TLvt1xoXGteZOTDk36PBns8XT894mXvUvxqNs8QieDmww/76kU +6B9P8sd+MqcTPlmW47w72QC+erNmVAIc1zhpdNjHYRfHAxqPeLx2x1k38l5M5u9eYC4GV269jJ9O +nrrm1VHIGl8iX7nsZY+UCmqYiG/Ty5PJ5/cS5dZGCTS41q+6sAUvVa+JbWNW98ZUvJbG4CKkJufp +yzYcOgT6CFOP26kGMqisC/JNaDTUg2VDpVd3Czlc3ODRJg2W8VLIEf39RPWYsGm81dzFJPmyZO4w +xhadpLfp5cnk80TA6lrh1SGz5F8lQHwWElJltQ4/XgN4+piESYdln2Rd7D7oujQp8gWEIlR+/X7/ +XBceKRdrP5GLFXbCGVy2kxjYygU8gZzzTTjErXauByjvGh+K7nUqW6BwqhYPckBlT8qspg8n1eSN +jHuQ9S7r9vFgEI+ypkIDedN4ZE2dMGD1w1F3uOUDdzWbRviV2oYhh1fDklprBBZu2xzG+PpGgLxj +6+HCAeRpEou3rOWjTVoWYnfYNJ+bLe3Wu6JxB+xdE1x8RttxzfVa3wSIDJDVNdd3qShLdutcqdll +8Bz50O7jYlxVkbdTTHpRDHtZDAdxPBpUx3v2qK12rCEgcp16wUbNXjWx3fbQGF5cniDarfiAt7y0 +NBXX0j2mD/oU2xp8O64pb2bSiWEnh2M4PhiP6THuMu9Vx1r2g8h7xrti866BkeweT/LHfsZGUzru +btaF1GM5n6aQQS2TVoadGvZpPILB+EZr1DfdtVzMgAw4xyq7MTLbg/f+0H8ZRtkNG3d7N8xUCxCT +FkWQIE44bF2bgYQ/4+1aiKmk7izUelERQ2l9G3cq7tDBjZvke7vtBWsKQmK7LcZ+ed4ZP9h2lQo4 +8R5wvby+750+Hx8MdiJA2U5PoGJSb7Gu9WLSx2IyjGI61ILTgbs903QUmDFfZvM6nWkkzlh3JeSa +JYk4MlwUAW6wLJRyNlgYLbdwaQajSYuj+32T5VEhcoMFQsHNlmi00erIobVj2aw91KuorAa0C4uO +EzuYDlI1moG4ho5Jqk7PYGTS74IvZT5S4UJLN6tUfwc4O2iEEniTgYTFbXEPd1dLApBXir9T86l0 +6t54AMeTIc1PAQVjZovelwj91kHKWoTWruGkoDbDrY6aCio+FMGU/hC5BISzK/W+8d514bNIZt2E +Gs2CcoUJpfmqA8mc+TihroHTTwLwiIy/07tUOhXupi8+HwMjcN1dBxHhxClGaA3pGbWn313TqXAx +rr/oG4jCYoYqcWQ1rmxnFrsIEoRL1es9cQnAtpvUL32XSqfCGWLEhmXsAc5+CRJsmhutIT1z3mw3 +qfoyFS7G9Rd9AxPQ/TzGwB+ib/gqexq3rJXa0cD0bvrh4O1qPDn9xOHrybxOZn4yEhSbTMFkkvqB +jG/RrZru7I/uEyJJ6w2KwoeWOB6I2j7gtseOmJ50n+Er2+aQruDnSXQBqxUlhHi3sCs7JbgqYYQU +maZWBU4DoWGkMpIzgpqshwuD57KmiSqjhS0ebdJiyRwhnz21BW17ugy4VZwsWaX3P0etEV+ntyfT +ApneqIkvWldXVjVHjZZWyAlwo697XGAt6Fn0R32jTRlZoNjRHIn7T9m90g9gXfEvQJvUJbZoP68a +6Q+n/7y5vbiL2qP/SDLG57w3G5eZ49rmwsGvqoK5QfjCmreJJhDknhp0EwAY1JC9rIXyw4EVrFp1 +ygw1VE221Ss+cSep8erM2QbHK7U1m5XV5+ODBGmRw0YdO5DhCF6WsqlwG6iUlRe8PJoWOkU/3Laa ++qZupxasb/cRa2marhZeM5sa0Wtmu16c6B21hteBx54WHAwhcTC8lxfNZiOmaFrz0tE4LQVnzlX9 +zBWcXhwmWX+bdBdv95W0K7waHCx5u26VjRMZfmqoCHBfdLzeM32FipA6pl+o8WIedz6X8YWMLK0y +EvZ424MCbCmhYovc047twq/OIPHeMUm70QmRacMHzob0AR1Hw2EQ1AypDr1lhVeTuvGEJMix+geG +ss2/qukGRQCvhxWA3mzspNVWkxnKaW6M+iOXoaYXJJKXAoLp43zqYV8HzX+IR1qU60rdSQ8NrMIy +297KqFQmamRSVzjCKpMjHNhjdpef+PgJrgT3muSItYBtxp22itbakl6NG1G/DlSEsqum6yo9QKH5 +60fDEXuTD5mz4vtZwbw1TTZvk2U+nq78/e6tT+wxUmEOeM+r/HUrj6uAed2r9VZFkO267vV/nF/S +bZ5k99snIL3Y2bbRa5Jq+koZSByhpR9nQD7eQ71kGRSr5P+hJsmAxbhEMa4UNwZXijZAWNx4nQDd +cyrTF0nVplpTm+wHu5FBRh9Pahs1N+7OtMfv4MZdYr+nv1eaVxW5/kDkZWMK20WRk6ijnc5Axfjz +YlyjfE/nEvk+4HQj2YiAooPwa9K4vliquujqTg0X7EzB3gBmuTDNalIi1ZZVO2l73LvpALiPEfRQ +O6WQ3rk63nZVchJkq8Fjyad8+kFoAfU3PDcyCO+HjpkYEwzXuwdkkEY9coySdrb0faTqqK51Ouxh +6Z16foj4ZflDzf6ywnVj9JUw44GXxztYOY55pb0jwYMKSThn9YdUgRsOA5wfB5VEzaxx8OmGT0/K +I4eUFY4u8IVFDmurJmpdCNN9RY4OzL7F4WZ7yNmB4dlkepDIea0mKUUIXgPrMNZQzzEdroO3omsI +IW8h01Yy4qONC94BAo4HmZizgw4kK1PVNWLX4jiFJlKLZ8A8WToMQIhwekN4U7Ytrq4XwbQOvDUd +52TgDeGl1MPpMKWpeCE77u6W7ccrwgNDT6AC8tbw4nHnPduB73yj7cCd/hAOl5xEkV8qFMLZwnMH +hBn3oMunVf8ke73CWI4PMlAIvlG/XJmbZggIlNQPVT0oG4ETK4tPg7T0q7YI7wsRDX1ccFxljuWS +CSKvZJjRlH5xuJ0dKOyiCN9Lm4e+sTW1QE2rF5zLyQ2ATCDcjjENbfBoBzjqSo6ybuDsQBStiaKY +UNcDQpx0FlIQWqiF8YLLaaWpWF0rJ/1kM2KTgi8I5JTQ09oadYsHa2A7ELippmqZJNDBBtoDsDBl +0CWKIJkFoFNXiexLr8xKailChK4IWsIFPEE8wmlBtLWO7rFrpYPEjnQVpJ5OhnNGXfqz3BFP+/IW +sgo3V+eRVTBPwio4H7X7ggImBKiV5LQUplszKLeyFxgFE0GuVJPXCVD2XhA42rK2yVmcUr36TDqy +x2xUUdOWgQwzTAcrftEqoDqsbODeE5m/bXIYa2JwDgDtGoCWAkDqRfxLX/NkwCcp03mpZW3Nyq7k +AFRDQwScdICm72YAywmfsimoK1aw5hDWQOBFzvxFelWLThQY9oY2ldSl7LNRLx9W23y+TSLHay0s +fiVHMg4Ojz2u+ZJbU7dbuHG+u/1xVayOLj9y+5ikRTVztwVlJXKepMdXHcTZQyWVQS/uocMzCXKR +gQp+XvWfd4BUI07TBBKU1KM/VmARYWQQO5R+nR2M33U9jIXHPT6bYdhx7rfxAwRCGA93EfyL4FQy +Kw4HbuVWcn4jqAf6Euh+2ZZVegke1Qs94kUflEZx20cjvXUii/XmnU3UdDP79Pn1dVGLaSDGDqfR +PjaNUz25DH7o9ElcHOChkKnWusD4HuHukPQtgUQYOySng3TNLbAkAYRpa8m6ApU6mFA+owGzrAYi +Gc6K9IOIZEqqcghgybov2T93tSdQ6kGqIXWx7/9xNpZZlkXoNzXsxnuaf4VtdnrJjHDZzZr4AaHf +Rv5R3EsPvGRGSBO8fE2QQ0CYpmlUdLCNo+XQl2BZpdkqYMv0nhS0KhpQODlTZZfVrZ6lvD8BsmID +q6WLzzIvVeBUSd1QM/WAOHfHBwlENqhqVqkGCGFNmjv+OubFGW3dhA5UsHTVl+4AWQsZLHajq0e7 +mbqfVHZ4riOqWd4nkRMs4IFMYZVDsrYiDAoivTgg1uHAK3M86dexkqyqf5dIVCqcnvPp6kCxF6mO +QgNLXK3aQioKN4umnrR6lQFT18Zd74elwdajUU/nZTJ5LDed5HwNdFyMvM5GPZmSyQDGxsOmv1QB +8kzdUxoIc5YGbUeDJdzNe5iw3dDM0luXQS2d1hle1pA6EkAPOyH72TcWPtA2qyUBUlNnBx0Igmfj +U2w1qkHotqHgmdrqIJRPtEP9V12n+6omY5tzBBr/EPGGOBZJjf4seLtB62yt3uV6S0tHaDDdIZtu +A+mSkV0i3ZY+XfMdYV6FLbDNxrron6KR54fJUEmA6s3IBmcfNSKVhiqrpwPExs4OMlh300dXUZtU +Gqm1CFBNVOxS91HX666i8dg+fbrlnBHqX+mEpwdNhFqLEBwsNNalXk8ZZ1xDamHmFw== + + + tqdi/EQHahGG1ai1OKUIUtUZtEwuVB1AZwriVPZNjIPva4mA1NLZQQcSKb2KPrtaC5Lbli5rKQF0 +ctmb/pvY376W0Zg+fWahDkHgh+YSiQ/IJQJ1B+LcSqh5qhyXW7gSlXoxjwZZdxBsWivMRUOCpBhH +TZuP8fMdALowF93HIkj2aRuMKkFjPRkoNkYtVQfz1H6suqpE+KlaF/rmEgDa0dilBOqHEWsZj+vT +J7cSGRNX23Fy0wNYEjARvJRJmHI0lROKjP+THd1oHFxJ76irHtLGmBEh9VS4FgyZC0AwVTh1AMw0 +JsP1IAPxGnJ2qqUDxIa4Oh0ECsNVVwnSJfBqpNRQAkDzEzuTQPkAWMt4RJ+BEsO/zydaHB8KTXQG +UZ8XXzmXSxyFIJy3IHU4Y2oNn+9giNGkXyGU2m1JdbFRHjrQ58v1EMHGVqguNWHdVwbqKvCCXU0d +JLWHzZ5gQsKcDVyMWBNUv6Q0XXsJcnbQ96r7qut5V9NkfJ+DAuMMrRMF1gdQYKd+cLw1xoP5v/fQ +cyKg1oYKFlO2FGoSCHp8q3bMumqpo+TJAfMjQnTTM7ax6vATRF04fV9FB+iaOTvoYQa3HLlVqkX1 +LepvwIY6wNlB6ksH6vofK5mM5zMgs8yhicdc/I1UKkEOVIdjzlh4mOfEmELjiGggY5lfUR3gaciS +EzO0NfXK1KRb2BTaGBSMk0bIkLKfmFZICse4s5N+mJ1B3TbJPx6OTUJJBdAkEsEI8jO4ZCjHARNw +wwxrmhinjYYPC30y1kgK6j6QpajBqxqmHPHqFAdLDO4Z4q23Isy7UDfQbDFIkAZJz4wrvGyKrMCh +UyV+9Nai+bDhB1QcH/Pwd60aC9O2ZugZ4QEWkuG8nd0bOlSpO1zZ0t0Ls8hcHmULY5zMmnMaYFmn +PwDSDRPGCLh+1hYpf5oYXMSsO3VMv9OESIaD1X3AoFc58CoIc7rPXFtpZJEX1JCZhHVFfoloWK0p +29QBV/85OHo3/rCsW03/iIlI3he+bNt5zcJ1DmsVKrVKiIRu15asgUDOa7B7G5QyzOsx1UT0XxYC +I1x/8O1jKYQe8+tatCxPc71y08ga+Jl+cknDtE6t9CACPqxnohmrpxVC9RzMZgXcGFtsTXrptD6o +oV8DmKkzr6ioL7G5anidUNkhRBen+rFUVGt8EkA4BerkluNgecRzq2ZAPMNj5gxkyajrkkhQsKvy +8m3llWkZgkG7JhOImyRIYHHyMLWAHHFkkSs4gmPjh+hRhd6SfAgliAxjStZpsePryJ5giCQfQVmY +GqUBQFKH4wNSB3CFNjrFJIYIGhcpMp25zegFQhDrlijZtjX/Uk4oYdcUAtrUuAgCiicjB1aFUiGS +DdjTyIDVpNC0H9b08kJeDtvayGq2hqymx1eyy0A3RNauIMjRJBPkG9lnfk1508Bnpm2g0DAglJDr +jpR7adR4I9MMY8m8tkEBKmRLokkTBALpUdYUlV3Pw5eydOu9Eo+53Y6yeK06P3qRfhr52GiVnsZb +FBjc2JenIk2uzZDt1NhonG5VW11pkiUczK5RsYvHOT0fDR3lNIEK3EBIZ+gtdxhaQ6cEJlziV5ro +0TE3g14wyTvtCkf+l2oJC20G7YSNipKmVhdGuGAG6Jzg+E3RR8hPCI2a1gU56VlKX3t0ENwzDOm8 +5BXbS/ieJHOfgSUKTjhu8DuUvZA5UFkX+hLgGb0Haw9cOIbZUU5bTSlIHYLVkmA3m0odCAYztzER +qWB1A1q6hgebMU7dA2XryMBLaM0xVmnskCKBCqj+MOrWYPSku0LpQtAsG0YVASJVBOpYDFIr1HTX +lyPdwrhMnaB3cGJt15S2Mm+luu0YJ0etSOUN/edh/HJ1klrLdl7DR3RXK+E3L99XXm8mGZdDWINv +EVRReshBLDavv8JqlzCxkmlpGar2yXRj8cI8ydUkIiuVpnxpqjHM4a6GcarK4MnCXH11aJUhbYKj +nFLLHqQIRlUu9pNtVXtGXbJuMVOpg5i6VIFjZcWVSjkAeK+FWojclO0s/XWYxSnw5iA1qsFfjl5f +NGjX+gmdBlXXGpWeQbMcFmQpgvKwqg2R1ugkBqmQF2CdkazRo0AQDvpnw68MPRA9PXu1nFpyfAxA +V3JIEYWeZ6o26cwrjd7hOZ3HTeWW4MgS623g8W+ECp56BmCCV0MeeJ74ZEIqMAVOlRaCySTUxtOh +XqbdqJrWgwzLaslWboWdaDVLjBCDmpl3ZK4CBFG9U2xUGjcBHdKDL4QSv5zmqgQz6hrGXlkZ0Lqi +6xo+0rPJurpRby3j7NqisjNTnhn0TXmXeV3WW3DbCjSI02LMJ4svS1fnaZgPV8Ob8GXJCLzE1CPR +qgsPHZMqMhY48mUHa+gpYiX0fOeuh5c7xBg1P5K8yGnMW3KDUI6Kz2rdivoWyMVwcxJ6UUNhS32U +96qnok5EIzMcffla3alO38Bv05d0EQVzYqIBi7HODt6SpW7ZqHFuDqPDH2CRCDaKQ4C0ldGvnMaI +lAgzofev0qZjOsWqikvO1rKWUUBVBM9/UJG68lTGDCduY2bD0+fxUGPRD2GXEWKETOC2Fn5bFWky +CdKu86FXcrRIriUEw8LbC14FcFYDla6cagzAR1kfhX4ckD/QGO1xTkMU822Mwp0Urh04PuhKqxqm +i8bXScfRgio5yPq4p2JOq0dqKrKVobhnS2PWFRQCAKFX1XJUsB3N7a5QCMFSKBFpAijbMnw6p7Fs +VZ6CQMCbuWzcC/MZoO9MCFCY7IIYeN020UO9qqLWsmpi7FalvroiPbbqTGHhOkWf8UqdYwHD0e+R +4cbqR9RAw42ZX+sndRtVDi3Oa2xGpjQ0TfRlhWmrJTVAbD510vJpdMBmuE3QnHHKw5R6Yx0IBB3c +5bAhVbNwkG+jL7pI2XCbBcFoafhGagTmYFYnZEs1jSMABsZjmC1Kchl0FyyjsRce36BkpDrjSdyY +r2CuwFJ9PPGnpZK+BSXyofZI4gYuP8TYtmjVsU0JFr2OmznmWveas0mDC4LI3YfUwgTh3aRKq7IJ +9MTQEbROoK6s7yntaCKCs2JTNc0hQ66OaCyoYV9U3Qa593ltH+GOTNc0ZYjKDe/uKwpWtaWngKCM +vFcZZWa/UVwKUrsR+dhP5i4WrtETEA+mkRDO6qVllIFmo408POQPbHEosHG6yj6hR7HzcR8LlghP +oAY9nOCWDkoMEdG4QW5EXMtB8UGeoRxFYI3aVIURQNQELhRRNQAZfKgdpB2NIvExWgJyIv620Ho5 +BjPx4Kf1xVXgXxqmV4f7V82YzdaAHMgZSMOGof0D9MbFeCghgDUoiCs10Xh5SI0mHfYs3cg1Xobx +s1TvCjUD0aIxBQowqGOF3o3na2MOo61KhjdWzHcpbTYaYmPArllhZ4SvR8RAG2xUSqs+A1bBkqEG +XqSoFe77tF4d3xzJP3lzhmAy15mrayUaiFiESnMFzz8hvnLkTwsLRwBbHKQsK7RfF+aI8+hhBoGp +zMvxO69Z7HkPjgMxJ6YJ1CpPC9YQEVMCAqiXjuZ2l/JPwDxJWRA433w6l7F8ZZ5EodEiNH9u4vgn +Ihad+3h+f0lL15wY6kDHrg4EDyvastsYJyYHG/NppJ+qWG+jBwVBBUv7rnT/nBpQmSHCmqQeiNUg +AAKGr7L/yfAlDXWLkL7PsfhkEPfu40aN2TF5okhVzHoR4oSIdCRzKodaFMGEobYIBLSTrIoUsGBj +8nIg0oM8uzeiQuJDbB2ctOxxlzHE0PhoHRxZ/AOlG6FNvgkaUT9Mq7iw6aOlTbM0pTO1ncTt94+h +PmzqmjpFpAw4A5XgjboBMuk1QUvQiVdCL0aojTN0zMKvJ/L8z/JvuKfJv6HhKX0G1/KJAlSQHWMU +oKKgTwhQwcF/X4BK9m4foLKzASr72JSU9e7ZYlM+MfHdPkRlH6KySyEqtX0wRAWuPqMIFYAeCVAx +zxigYuYEqNCtaRCfkg/sM4WnlPGG0PTQhaiY+SEqNosaucpheYiKmYSoVKtxiIotP1OIilY0CFGp +VpMQFTMJUbGDisZj+0whKjZOeXroQlQ+NUalGceoNJMYFYZdD2JURIAdxqjYZhKjIqBBjApqGcao +NNMYleYFYlRsdItOD12MSvU5g1TUK3oQo/LZIlSG8SlsaffDU1SszMNTCMnDU5gOZlvCU9iZPDwl +DaALT8lH9JnCU2IGkSI9dOEp1bOEp3DMw/CUdhKe0q4JT2nH4Sk6e9santKaRH31IYWn1OYzhqcg +3/q2hKcw9/urCE8hyjwcntLMCE+xM8JTItfQhaeYUXhK3X6mABUkjfrUAJU66EG/pREqjcZs8NKO +ByNUqi7ew64pmyJUmocjVMK8Zh+KUBmUfDBC5eEe7yNUXjpCpVFGbTciVKTM8gCVxj0aoAJeZR+g +sg9Q2QeobBagIlMzDFCBljMPUCnbehqgUm4YoALvqkGAilkeoNKOAlTaSYBKGx4OUCknASp2ywNU +mi5AJcSYDV4OCk993UyLY1QG5VOUSlgbpRKSrFqbuY2nOBWT4lT0XtZpUYaqhPmhKqPiDFZpUqzK +Z/Ag3ceq3B+rgt3xWWJVfLxSsItViTq9PlbFbRKrQr5hFKtiy0msSjOJVXFrYlXaSaxKmBWrYh6P +VRnM4wvEqtio8DCarnd9yIgNKWQk5LEqLBMDP+4PVYE9T0NVbB6qUsVQlbKZ2W4fqlLHUBW7PrwG +oSq4C2VNqMojPY6RKvU+UuUZI1VKM4xVMY/GqvhRrIofxapUk1gVO4pVqR+PVeHFKU8TqtI8HqmS +OK5tiVQxGqjiU6CKn4SMmDaFjJh2EKjSBX5Mi8YwFWGsYphKpBAMUxHyr2Eqawqua7MPU3ExTMWv +K8gwlTKkMJWmGYSpPNDZcZAKDqp9kMrnDFJp2icMUoH6chikQj/FR4NUzCRIpZoTpNKGFwpSGUzi +NgSpmC5cw5nZQSq+WV96YZDKo23fH6QyKTorSOW+fu+DVJ41SAWKxFGQCpxNhkEq5vEglXIUpFK1 +y4NUcN3IUwep+MVBKn4QpJLP1wsEqYhc2MQglRgtUqXAjfBojIqsa4z6KM20cIpRka0XY1Rq08Wo +lG2MUfHzWu1CVEwMUVlXjAEqYW18ysNdTfEpzT4+ZdviU9SP5774lOztp8SnNA/Fp2Qv9/Epuxyf +ch8qpfiUhch0f3zKfegU41MWItQ+PmVtfMrfvv9+EJbyeS8d0jtSEUgAZ3a6lPUgf5hQw3nPONiW +qwrlPTz8E+CM12ziXr/+k2ZYR/ccm1ELDUG8WpBpM7QOND9oJgHinYXoSvdN6mtXyXg82F7rseqH +P5/840/fCkb95uzi9kwW2L757eprXoBTYtXlZbbQIWYhoPRk1KAFHxlNFUDQCUBCOAI5HeF4GrVa +OZiMaLOk60pb67WPLXyQoocnhokLBMuowalKmIiEm6JjPhooDQ+hug5qFougAiE8yA== + + + GnBCvxlDj2n6wlS8VhA3rAq8cgGPwyEcTwYFL3kuS+2ygVKf3eRfwW8V3Ap8I0KpoqTn1dF4ExrV +R0UI7sgLTey0whKanBzYdBtvg9sD2WpjKvpqt5oxctSd40kHT57jajIsjlt5g0t8Df/STwjgSl3a +tuvSpe/PT2/PftY7pTWS6LNTDijZEQYN+QIpn64IClCAU+lKRQeMrHDCMtHuAX2bt4xX594G+kMt +Jj8rXFkmx/Ild4TIPXRxbn2p3hj0/RFhqqorBcA1awXXAdyhQMd/06BxfiuLcgmpzDtfkYI0taG0 +JAMvqUlhm7x6DNdewi2+iXTJ6rUMFIPk7LpkLAIlIFywBsEMN/uW8ZkZFWGfAYVsD7nxzqazc0ks +nUSftPfHoXyM/2HpKI3PWDxEjUyWRYGLFwbn/mRpANxgcaTYdHkEuMkCSbHpEgG4eJHWzBZqwoHx +D048V+SrN/2aLF0LqNgsNb0Bdm2uBbwZoQFwKFMiNAlfQt9W0lTgbWgUCO9JcKQQr5sQPxxVeS/w +HclL6vg/8ktpQhRWnuSy+RYytiFC1bCB0XKrnvYJZLxqRAGwwEIoS1oeA9B4NLh51IZDSw4VZk6H +SeDFsYYnPEVY3NIORS2VgpXRk4FZunAGQYeLW25hEIY7EFw+0TUqXFxyAYVXWVXXHcQjianlMgh/ +H3gxZs0LO72Ig6ohdZqlLl1Wy2tyDRNjmtYFjYDydFDhLeINQ+FkNNwjwMq2RIyYCAeqMJZJQd7L +8bylALwEJycl310dIIKPytkEEuypvI+Z80Xk4rZpVGmN+0yD3uWK2WHOUeG9NU6n5n2hev2j5jSE +nVnz0mOutJzTu1fhutsyMlJ2k6+xvfWiX3jrwIFDxCYHLcjxAXx2NODDwUUOHAhVz010SE8LkZ55 +7Tl/JQisa9DHqze5YehyqZfhWvrkHMPspv6FDaJ8aiaIidfgGFVay/6JLsvVYVWXLGTpq0fVmsao +qgsiNFYeuWh5H6bev04CydvV410nADVOr9csTVCW1dG8KEjone2XZLxqx5N1fPi+SDiHypIY287U +aDz3Pe9NK8yZb3AGNLjnvQWywAEBl+VuIT90d3q7KlYi8v3628gQxTtcZ5K1Eqgh21olJDhJ8fDk +XdInB3HPB3UCLQmCidFWvOVXRIAqsugl/cWAs96QUpeUgeu2xsOa92uqmTY26VDf3TkB1oivlm1t +apzaUJZ6uNNBg1NXLbRfY62XxbXE6jRcxN/QSyISWThz2jHLehAeFoOrZX/SluCgpYRK2ZUOES1Q +kghhhQKxipc/V8IINCCUIhSKCB9jqyEcQd99dQC//lbDQR012icCair6CPa3UzeRBwGo1OmzvC6L +Rru6hRWeM+pwexR8MyzLMUAJZmMYOXidLLz+DMPs4NTjlQyorh0+oIE3x/qamm6sB0QxLgSiTJtK +r+CdvC8mlRTThoppb4ppl4s1AyvWjL9YM03FmtnMZvukjwaHXwQiE65QtzeMiGnoP8P2NBGvnJ01 +qzUYhmMY8wn3TUoDankpcUnnaatEdfxyUHZY75qWs66NHmZHfmvI92CMX71Z05TQyEFvhG7lXZXH +8VBQaz9S5azHXxSjSopxI+vme9Ddk4NhaLdvIqMHQienviCHEBIEYbcxi4RsO6hoa7q2JExj2Ewb +mYUTSFEaj4Nb42HdwTisp9+i05A/GnqaEO2RMHMdU8nNOBDqNazjqhk6lxRIRB8YlV8zxN13Tvsn +B3DiAxkq6GVf6h6CFoGmzxPIebXGJPcfIMCNqpi+GgTbachn3xj1mLiiKusTo5cQciALwkikk+lM +nTyg7MaQhdHi3YRFU8PtS52O4VQ4oZsITW5AzD0YNbB/HolLasZrhqaKWmJEngoWgM1VBvkHRNMK +w8Lsx/BbQ8TKuqJ1UIVKsE00Ah2dbdzq0dxWYVVq1I5VQ681VGvfx4ukk75cnd1cvb/5eP129eHn +0/fnq6ubt/kx/7BafA1eq6J7hNkKHOE2RdBNsFs17yP8BrGYYLiIjxMc/+rNGiznVu7xnCLzBNMF +OsV1koYJtke9/QjfdRpGGL9mFk/u18cvWLpMPW6ehzN9YgayzxP18VPZx/Z+/tE9xD/Sn3cN/1hF +/nH0/lH+0XX8Y7sxA2nUZNpCEARTZxprAhlIL3tpTX4eqpl8St4QH2IkfGuQFqp1EEXz/DyfKTvP +gIO0dHEZcpCWHkYDDtJGbmk5B+nIs8EB614O0n8ODtLP4iDz3izhIEfjL9ZMU7FmNudxkG27kIN0 +D3GQbgEHOWx5KQf5EMM4rHkew+geZRjdJgzjuCsPMIx1OWYYsZE2YhgRyfJUDGPdmocZRrXHt00z +i3EcVreMcbQTxjGfsc/MOMJVV1m4dinjiH1JFs7P4htNzzdu0OjRzEZfnG0cYvditnE5ji9lG4eo +eQ/buBbbH2Qfx9UuZx/tGvZxiPnPyT4uZ+Yuzn45Bz/3t/O3mzBzsKc16kEOKzSSdyqkiH8TOD2X +0SbIb7qX06/Sr7OD8btx4azi+BN+5gHwGmFoMGUAJ5zRMHhBgrIM8NYUHq+sS34ZEOp0guQ+xjtm +MAledW6V8AhdE/HHcT/yWUyhMSRztvUIpAHvUlawKpV0bQA1mNC5GliVLpdODwW5QSIbkmtr8pOJ +arGuKqEw0GPKsDu/K2fyH86KjNNyfCFomBS1iylxI6yimrmxKuuQAPr/IkH1sVS/V513pgpA/pcS +ZlAN0WNqBMe0XK2hCcDQN8JwiRCIhYk3NQ5opjsoK/K1iMdJTehfTfaYtR37NepmSWPNsK/F5Jsi +1dnnd7QRkVMaSf0vB2jVTPNeM3AoveQ7BzNRSTmaDsbw/DOw5zn4S/CWQL0zFM+OWRkBaTSHDiGG +MflWn40+N6575FQzS2zNvFEgRZwz44HodDp2TEHFAO3Y43wU/MtwPrvSMR/HsW+iIHQ2nhcPT5qa +mB+YtjNak5dMHDLdLpy6r95MJ+9e2INTiu4+PKmT7JJtxlHu6eYsuokoSmUjeE4jLxgDi0vKtsas +scf4oIliSTbTQ0G+SsiiU96sbpQ3G6W79a6kyb8VabvhDxMqZtISVlSJpDBpQIsSgfCISykRGoVw +pT3Z3JPNPdn8/GSzGQji2BLgiUT+CC3diBIou+UKTD40N+gg9WG+4scJcCaCstHo4QhBekAIDfDC +QeAIs+YwKDkcMgskJEBNfFbQ2Sa0YPqZRwB1VKte8OCjxic5Ui0C8H86qORgABJZx29j9R45GJLb +1jCxQ6XJ5xw8YB0yOdHqqVmBNQeTi/GScSJQSTpHBnP1UKACSKuTuQZHWlQW90wi6gnebWtYU+dF +1KNuDOnEEQxZgSQYlY+RbJDBv1avvQy2jv4pIoLXSGDHq6SQAho+QmuKWl9p6jqRw5G3QC+62bDR +o5mNyuLCFg/p3TKkc0FAwhq87IGLMBOC7WLc/OrNUuxUyjMXP3UsSzE0uu0txNHR7jcDpmmwBums +1aSTeio26tzYgBrCCxL6VswJPRsNjviy5kkE2UgO9JYOkdRYWfntfTMA4SuPRElNzYxELZKeSNV1 +BCAbrmNOBRdz6UKTbPVG2KCZzdvDLnUpkz4xzQpDl4OmbGRuFnpYAUSV9glAMQobXzlqbVv1oaPb +n7JlzF9dU61s0nNk53ipqGxgREuTr2jhnsYrfTHprgThbhg7zbOxNJqhmUnJTg7oBBvAewSvlhJE +t/GMoHvgCXkRuBaSF2mUF9E8uIDgDALEMrob/bEBeFiXdM8bsyfp171qQl/TL0cqa5nwvQ6yNAyp +ast1JAoYVvNMhecOE6A4BMbxJi3E6KrazWnqsoC8R0wC+QNzgorQrJsywBC4tmhV45JmJGETcskd +c3S2catHc1t1yA6KhE8m8DKwAY0yw6Sya5iPtGXUd3nhpgEVmGwbbPLJxgFw+dYRxmSTzfPVmzXb +h8DxBhLg/C2kvMySTcQSo20ksPFGIv813EoAjTcTYaPtBNjMDdWv9tiy0dj7SOqYoWMSYjpz1vHG +BD5X8G/V2wL4DOtpIIvHlDHYEJy0kjHydYXUdFABc/mfipEfQR6kIqXsKgiIhpnx4OqKjJrrdHBE +jBI5DGSfIjOskwONoe2BHtm8vKcxECsN8qQ2rWaeRRIZRPrw0nbgzrhYbWkZlGIVAohK5mDcpLWj +Oa0F5vhk/haLhDzLyMYULRS2CDF4N8dS1HhSUWWwJ9yyPTGsC5lAKtWPMOWIh4kIV2429JB/Gpy/ +B8OdJYZXFuoBaEBqzUEM+lnSFjNRmMiRxZSj9MOLsQiVAU+HGAQaY8gcM+0ao+VdK6PUk1IIVEty +2jCwZF3RqomJyez/z95756eSJA2AewHugAwChCtfBZIQHiQhC/IWJwlhhemenj/2txfY4+w19hp7 +jU1T3hfwptWv+eabN6gqKzIzMjJcRmRA/ZfH1EfCOyHQZZSAuSXFaH9jryxmsuiSQnjhuygpXfQK +hayAL0ml8Lm7muZdE7mearyv9cqIWEOwzCoPgeqNJqAFbek392dAHAtrG1Dosg4CujU48bILGFZB +wotqq6pHLL55Cl4mjYpqiV/Bi69xA/w30NH1j+AZte6rmAFuzNA5vK5YO8KqfsiWuymJdxOZJGEw +jz9JoCgblChqlBVy2jzN4xAiWHQN3f0gvuGQaUvj8SENDoyYVBL24bfwfBmmmDh8C7YjAyw+bbq+ +x35z3vul0B20QP9U9tIc3jyMDkUVAoihW355fAU6itOtqp8x+NLiGAdT4nlcFYWgYDCmsuTik7zP +8Aisnv47BBq1EUErD8T+8z40SFsa+Plkq8e0tZ6TxHdPoKsnCJQLaEevMKuZcSQbHjlFtNQKoTt+ +CWQQYvFaYvXSac5zpxTMiaJJwZOmY6Rk+MxIy5qnnqg58GpCz4HXhSgafKanafBITzPgkZGu1Q9d +UzaMozDQNkTFQtSNcagfq5HCtXKPJVUl2lTiCVqs8JZoGIk3gHtd7k7c24yCT3SJPUfii/bRNVKa +6fLGjczL+0/3VcwAN6btm0FXFKhHV/Vp/7L1ycJK7dAFB++QoWAeJlSXrTYyvjKTINCdvvBePd3m +IAkB70OBQt48mlJvZpxfiq4psP+W5XA9AtVuXqDnnPeeySQQelCFVba0ao04ccfqnyBxgZdGfAL9 +Kklc3IwGFpVfWTEo6hkOC4sfRkDqIXI4Xk83jZh+ngbk5FdLbOiiTMFxxeHlFLACgZbW0P2vHOX4 +NWT2sGijlto8dp1bqGuYng9EiHMk3iLqNrWcuk3q1W1OMOgtnKDj7kjAqLg7Jxj0FtUjSW9RfRUz +wI0ZOpf0FlKvapHu1O0YdBwKJAqIx1dnkTD70U5/iQEzkWHRdQtIJ6A57YpC9YOGliBNK1U+VF9D +ryFDOX4tUNg1qr0iy2vfuUX6hjo7wXO8Vu9WVoyTGB+P/8I6sli30i+pCehGIHiJOg== + + + UiYYFIFKIrdq3qfRL6CBW/VpdBBomGq0FImIeEH+W0NEgorloRtypEcxA9yYofO8aC6oxyipv+qJ +IOCsgKepwYcDr6PhhbCsTGLAck/akBh2GBP4MmqaMWEavIrl8NBw13E7BtZDox2/hheliSePS/Sd +W6hvmMkO6xZ5OPXUEqCo28okiNVaL0SI1Fc9GaofuiZEzeAkUoTq5ULEKOn7WnKUtFW3BKkLB+Ot +XI4YKmmwpwUTe1owWCCCwQKRcKCyp9WPRHua01sfnAq08kBrT9sy+Z8vl/SY/hX2tJalYwMVjMuF +PW35pbM97dSptT1t9eUS9jRpYk9raVnz1BM1izxHS8+iPe2VokV7mjTa06TRntbStfqha8rW8Ci9 +Pe2ZuiV7mjSxp0kne3pBxZaFf76ejYYXk+5w1h1+xGL4MVJ31S98Z2P4RsBvLvpz8O9586vTmvnw +BZP+3GQ+/fSfNoaNj84EqMbtziRs/86PX+Yb/X4X7NTxZ7cltqyPRv0EULHHs7j//I8G+G1sCtQA +AELdnrVtb9IUgSj1GzPH9jRqfwXTO7RtEQiTD3irD4xt8URI1vgFWNDz4UVj9qkBnf9sTFojZZKg +FQJh0rTe+c/MX+j+0QUItwdaRyAa484EsM3abDLqdcDA4njNAZFoVnzFlGOBGEAhaqTAPyGW4P8T +BP4v+ksMQbYb7UKdK+SHuqbgfzg/KnKBuyV/Sbe0bso0+I80YdV/Vt4vRjXcDahb1s9KEjP5qzuV +cQw7JVGHgBf6aYxk8hf0y+uQzPt5r0he5Q4w25NgXNJOR8SY8EtaDW4DmvuphF/6D8RUwo/QRcYp +WbNZFHUWI6prOIRuXBRhPpxfNhgVd7NCEbw1wc8p44IRNyTPwRgimB+JbmOCcZk84n/QbECjJtyO +2jMVJPEb6SrmqS9xMhz9OUR/AJmN5HrYnzgD0/BHfYkskOd/dKS3ibyYY1jq9sHMYHtAI92hHzfA +T7GmmxCbRIGykLjpTrvNPgJohFCbNVq9pSB4HUOuMe22lM/xImOS8p+/v087QKCR1t+LHxz1+3N0 +GcZoEm+MxwBpeHHARx0RfSENUH8VoNJffH8Hawda17szBI5C/fTPJ2JjMEC7W7pDR8NpF6Z2ynfZ +FbrTcb/xF/4TpnwmMCRx1cBErnyA2HiCRJW0BJj4h65y4BmB0+T0CVIqH8ztE1AlNJKGCYB3WXP3 +ImhgdDCSWI1PFDrv/j2/zx9SDSeMkYlvKMHPMXKkWUV9e340f/+eD2C0MZmZrFiu3xm2PSy4HT4T +CJiCK3dOVGVyyucWg7eZR340bM+7MzdzUENZ+Q6A9LcidMrXz1xPO8U/OsPzdhuRJOxCQbKn217E +AhOqVC/TWhPIxoZ1WZCHCl28B4P0aFi8luIsyk0o6ygP8Denwd9nSr5E8T+d1hwOAb1A35rJM3h/ +G7cWar+ZUHPLP9bCaC2MVi6MzCQQPhki4SEIOnzkeFjkENaawLc9ryXQ3yiBqL9dAvFrCfSbSaCr +JW9htjCqTKhybVKtpdj/3qTyfJf5WqD9w6fkSaAJa4H2Gwo0TqAFlF1Hgf9loQ8wKbA0vvuVZeBd +CvCGANGDzeK7awiYNwILzln7Cam1o3At1X6EVEsK+Co9huLRHZMsrHSDolBgDnVy7Sn8l4u15Fqs +/WZibe0pXEujn+YpJETxshY2/2ZhA8Mn18JmLWzWwmYtbH6VsHGTe7AWOv+7KRmSHv4GsUP/bLHz +rxMa0PFG8QQsm4tuyEPnRSTPMIwmPo/nKZbBNaUJGnnieBjNx/6so6QFOfbvwm9JAV86TsAyIOiu +Scx5WdakeJdHxvv78GBP7IpZs6sfx66Wqh63Zlc/hl2JdyYQtEDDYx/EreCVoxxjdn3Hml+54Vfs +ml/9OH61Vq9+D34lqVfwfn9SUa9oHhX9W/OrRfjVDw+O/9fxq5/iQ/znshqFqVv+wP9BZZc88aU1 +N3HgJj880Plfx03W1tqPYEmrjmMicXguYGVJAdW2Y/kkQ+CSoISQXEHK47+Uf63jWtcc0B0HXKe/ +r492f5g0SDI4DYnieXixILqJN0mxJpdTrs98/+FT8iTU1lGtv5tQ+ylOgn/YrllLo1+b/04JNM2g +MrDwPnkBKFaoDB6zDnX9d+e/c8TPlkD/Ovmxdgv9M1mvkyFAYzuA5GHJMVjagyKxU4ihGG4dgrQg +91oH6v9u/G+tP6/15x+oP9NUkoe59f4YzwGZC4Ma4jzB0CbVhdf6879Jf6bWEug3k0DrY4kfwU/W +guwXH0ugUjEkwzDo6hgSlplB9ggp8MvbI78LFf4+U/Ik1X54Jtpaqq3tqrU4+ueII5vbNsQ4cUpY +38T7L7ekfng64Vrm/BhLan0V71pw/Rw7CryPMwygZmw/cRTFre/y+JfbTz881XQty9b201oM/XPE +kJX9FKc4AihYful+AJZjaXZtSP3LDakfnum3Fj5r4bMWPv944QODIoAFz7F+2YnHJpPrjJZ/ufD5 +4Wma/zrRAX1wAssTAjzm5ViBJ2H8KUcQPPK9cQJPoWLXBLxSBz4hleIhDE/8uCLD/6KQYtPiTziO +mBMIHI2GrwWjGIZY3uf0+zBhTxxrnYP3O/I8jmVJhkMXi/GwVrrZlTM0LKiexHwRV1gXUBHAdcGk +td7997N/p7MHksSZfUmGIQX4iyFYlsFJJWSS4dahyf9uwcb/8NS+tWBb7ECdoYkkFFpJVuB49IMU +WAZq9QRDYzHGCwxNwh8k1OUpRatfC7a1YPvpgo0TbxKlk1wS3aDFCCRFoE7iAkOS6wq3/3K5tk76 +/N3k2vp8Yy2OfpSbDZ9vMDRQotHpOkvFCYoAFlWcIpPU2rL6dx9y8Oukz7UEWkugtQT6hRKI4eBB +DykQZBKVU+CEOJkU4AFdklgLoL9XAJF/f61Afp2huRZBaxG0FkG/XAQRJMfTcOkoPs7wAomKJhLr +06W1CPrhCZtrAbKuT/R3sE2aQmyTpQQBxcYyHLxnBdWtg2F4zDpOazF2s86p+90YFopNpXgaJX8z +BAP1jDjMAUdBWVKYFkoMB1YwFHk8jtj6YTGp/7Bdt9aY/xfhWdz6iq0frD///eLsh1f3XIuz9XUn +/6Ctt5Zp/6NL7GFklsCwgJJh7DFLMFLEMUmv4Br734UKf58peZJpPzzz/F8pkdbJf/9IVmyT/McL +JAs9Szj3DxgVxLp+yIIM65dmK5uymysI058fTYadyXRV7EYHVGYxtmsB+M9VpwFoF5LXfGq1BVfO +dkV25/p7j3zyF7nFf1/utCB+1hxFy1Emk8Zf/spo0v3vaDgD2+opxFP+8ewp/I/Sidab89++ObHU +qU8aw+n7aDJYlYhSAXQnnmT8zKQvLxozMIYhklSEJLwGoz86N68XM+kp/mbSee8DbftO+7AxbI8G +3f92zJrew4eMP3EE9KzQuDu8GHWHM/gsKT4bzgf50bjbQR3xlLr/iqp/UaSOZo1Z5/UKSNYGHjBJ +yC+nrUYfjrkzaXVwH/Jg0Ktqd9gxBVfofEw6+BWpA1ZqtAD2zTqqqDsida+Uz34/Y9wV2y4DhA7V +bLssKtsqrl3rDsZ9mWt7UeexHo/7UADD79CNSRZau2gEgJkAErQe+tEQaHv+cn/0p58FgmYtZtZi +5h8nZhQatpczhcloXPtstEd/xhtdcwGjBuXaAEKcvdkfIpwQcZ6V+ONo3GjBZ/KDZn8+MTftTS4W +0f/A/7lrePUDKJj+aPUnIgNHY/6Y/TX+F7Pti+6w5891/uj0/8UGPPu/MuB/ESZF7yhQ6z5XhUcN +SG9c4Gs4QzuKl1nA+3QmKoWiqtfvDlzuub/DxahwHY6lCXzkSCV5NReCufSip5fjGXY5lvRzznJ+ +SUKg5TzWusv6qBTp9dBOa0zUin2coOBVY36SZuGmo2G+MM+u/k5UzBBL8//+9y//aWPaWxX7LHUA +44T4dsc6SdnSvLKVQP9sheQXUvpaDv7YrQxtdAbtYsrSUF/IEPp9NoYrTR1bbWvnxFrA/xTt+Bda +6YvJcejc8Ev7ZEkviAaWSzNSluLtxqSndjK0phPkBKHiJCe1+aMzkTzJGPHjRhd5JmLqVp+jyX8t +1oFiGRj8SAkcDobEKwD/6i2O+KnOPWLn0uGAEaT36qxZtoplP4KnjXl/9mzvA/e2o1AoEow8YtGq +Jzl0hyEvJOGVpfJMvUTAmjvJA9mj5Gtx2M5OZmi0U/iEhU9ez0bDiwlo3R1+xGL4ca4D9s9Fo9+Z +zTqIw1403Ywz9HgFPkRKGMDkcxgt1t1/ffrnvouWNzyFbj+7s474nTO6GpAAgazTd5RkOJaGkcVJ +midpWuMCEL+7Kuf8V5229GWSTiY1lyQnaYaC6QrqISpf3nf60NGKP+ZYnie1bgY5d0f9EToHEb9h +eSLJ8OoOSZphKUb7LSl/m/+rIX0qCDTyavA8QcLbmYxoxcshfpnrzyWE0uD/SAHhkaCTlOlCqD89 +bXwAZbAhfk3yFI+RypBJAa0Ly+IfBMcJCH08y2G+pgTS8RzDiyAPYAB4+YBO+nMHDGtcNJLGyy0I +8IoP9IqheHTBu3SNJwwVRxd7MiSALIKlaB6ApQQAlub0YHkOYDaJwALOq11jhgXwYG6KPFoNWPCo +fJAkTMGyJEtS+PZRkklqliHJwWu0YRs8dwAWYUEGC0dLgn8BXEIPl+YZlofgBDLJafLA4knpVlMu +iW9FiVM0QBktwWXhcOHwcwdsUoLLUzSlGZ3A8ixDaeFCpxiiefh/yrWpElwKYpdG6KVFuAAqoRkc +xC7HaTvCyBV4UchpoZJozQDFq6CyFK9jEAKXxLhUEM8kCZxMKiKXwvkEIoUxBERCEg6Wk8ACwtXt +FIEFm0gzWoqCRADhSiRGYSxjuCxaMwHYPgc8I21EmkPpC2BeNMKfkCQpDm/hJI0uToM0IAl8HqY7 +iODQIBm4Upy0UgJPC2iQNNgFcGigex65MSmaoAWcCMgQPM6vgHmAAqeGRkBMstKu4hmORvkXilOU +Z3lGM2VSWm55yng/YKCA+UkzJkkZLEQkmiFgJCgjkaEpllNxWDhKDt8iD34YRsnBvU+yvASPEHhE +NWDdCN6UmQGtCk4azQBhENIa6IAVwTKY6uE4KUrapoD2KBiYD7Ypg9FvwiTjDAP3D0QADVaJVY+T +pOE4BUGElwQ/8eVDJFhbxnycElMlk2B1eGXtxXFyAC6Dps9Iw0xyJEEheQYrgAs0/prmCIQSOT1G +2kA0BixuILR/IHMCQ5LQSXM0kiFJwKoJ80v/GYUpwzQdxKrEvUPAjQ4WDg6RlbckICQEkWUJ1hSi +wuYkNsriJZO2JC8xfZKRtiQN+sXFkuKAulm0owmAALzQYN+J24cW47AxJFYAkOCUkxIckgAMgsNM +FwV3A9lE83jBIcuCuxTxSDUaxbugRT5ESXhMGphxkkwyeFEAWnktM5ZFEubtoGfpRA== + + + QZZINFodipR4JgfYHYVmTBGI7oDSQbAaapIlM4dzosAPWXYmEaELaANJ82dowHsERMscYPXwRxLw +TCyUmSTqDqKHFbkQgys9SPiE4hhmZcI9Lu1JWEIRrQcL+RvaRDyDmQkFl42UGQVcRlF00GrBCe8o +BoITrrggQQUUwZBwJIC4EWsgADFzmIFwSImgZUYprhOFWT2GKcChol3OSaRJsQJFoikTHODFcKBJ +AeGAIAEhCWohwcHhwV4YSrVMUE4ABLAc2kUSJ6ZZUkxiAwqWmCfA82hH0ngzcOL0GcyI5EoaIlQO +bnUSiTaBkoAmORbtZtCORdD5JI8GDWiCRtOQJBstyXlRJqklGxJsMvsEX+L1gJtJ4DB/4ngGAxEQ +c2ek2h6URFGkdq0gpSKlQVZyGMAOEU/nkjTQ+vxY30mK+okkdsVNCvaVgtAknDlGp4RNBmjvBFbE +4M3tcIyAp6A9C3RzvM7iCOXb2gnMmDFMhE0a8WO8kwyJWrXR+8yPDAH/TfdjCI2ZsNjAynVp+o0I +HEAsNdod/2zkx+aIEyxtawWKqVfVBo6+vQLJLITKBpCuuSnSoF3gRwF6ffeATT+C4EO173lj0pn6 +s8OPPjCrNGDwfx5VMJ/9Y8MniFzg4mM+Bc3Mi+xZ/fys6Ac8lPXnIdD/+PQPpc9wZ8pbAMbwBXom +fUBxiLDB/6hAmnUj9wK2KseRGrHKA8rVCloBiRekpYhHzTS+vUGSNzTSe6GUBUxFkg0ER5CIPQBN +UqDMjeWkyCB5kU8IKm0NMAKk9yI1iFTBlfVboLchQcECnqUdMbB8CdnkIDBfQ0OX9H8GSUgkwAF7 +lUAzPEXRGBDPMObKBisJCgGzXSin1aoBDWUaRaJRgyUn5cXB9ohmQQFDMKwNeiappkke9UAJQLJY +qXyyOi4oqqkEjUrKS03CLdf4C8W3XHy49UVg3REKfVkh4xish/IkUJyR+OM4oMSjAQBdmkVSRbzc +Q/9DRD9cWAqyVFm75YFagjPZGJomsDRlCCyqgV2DtBFK/q9owEA1mYWIZqUF5MAA0LqxwHZDfBcs +F2DOiMuT2JqjpTHpf2CoPBIePKJlCSrQ15GqzFIk3ggMsLbQmIC4JbGOIv9XrXnCf6EclkQmGA1a +RwaoNIjQgAIBdgdSbUR5Lw1K/0MESyHxjhwD4F+JbjkW30dB8Ei600BCcphMAEYYUWHi1KoX1pNY +WqN60QygMwEpLGD3IqOMJVm1KQTMG+neFt0PES6PVTq0s3hJYFLQFYWscJ7jk9iHQuIOFCYj/1ck +EgLvUahygH8l5ZgEWgH6TmCT2JcgAO1Lq8dKI9P/kPgKgYx/SNSU4q1gBdyWYCgCa1zAftM6BJIi +l9L+r+QCQUo3Q6F9T0lb7rbT9OdH/REUgaP5WN58sJYZif0dHCOYW1+UdKuAbHxqOA1Hy9Ynpdg2 +PNDEtHjl8JIq1pKkjPKSpkuJJdJECsPWA9JLeT3PZSkKa+DAtGN5jTPR0jnEsjbOoaSohAkEIAhK +Cw+YrIC3wR9qKx7Do+C8acP4PMVJKYOj0D7gZc1WslMByxBwFi3YEVrnJo9VTpFo1V4rUkgqlEti +mBc52Wkt+aYVb7Xaje07G2OHN3ojubyr3elM7cW3i3KXD2g1MZXG4HLbBCeD0x2NwNHvbjITksCv +an8NmqM+BPN/+EKV0QBolaFKpz8G/5NrTHsdNHCgK7Y+w1D9/AOMCmqeoataDTaZ9wHW/DH/Vffj +c6Z+UBj9OVT/Xe28a95fj9V/5YB2/Gdj0lY/K40m4qPzSRP8fT5pDD9g17UZUF1Vf+fms9loCIjJ ++IxSP6s3mtpG8IGmBe4I+7HB9NsfHfQBXC/5geYD/IgGj0SXOxhct9XrwPEhn780WCjjwyLewUqp +sW69eiK1FUat+QCQUKExa/gCrwnpb38K/aU654J/351Wz0btjunLPX/oP4P+ELyONWazSbc5n+Ek +F9AUU93/AsQK4KtatT67/fYE4B61kWJrpLfwn9lf4w5+G9oZTl//aEyme6rkfnXTPxpw7XFb+Hxq +0Q6mi+Nm4kimmr/+odgZjoYdF4jpjwCFt91gRmoZ/Xvn1ewO22CgpIu5AeKodWZnaBLO81O3XtHy +L4kJ0hYTrubfbTT7HTeE77iq/6SNnvrD9VaHTf9miobTa82ns9Hg7+Vkv44OU9MGjIOAMg9sMbfk ++Mv3RQ3eXPNjhvI77NLp+58/WBr/zdtg2u+2/um8OCaQSmiY5fK6Wtq/m+/CqXBOU/nLzVT++run +QnK0QDtN5c9uG4W1O05HbPgPmNJnB1mqLuYktfybJyVFf1pNqDkClu4Amtfnky6wFt1MzfjNDxD5 +iNfVRvNJq5ODQdArYXv/aIOMMHmrxtisMfnozIAeAF0G06OCm6U3fvM3q7IXZ2WKKY0mg4bVrlRP ++b3b79g21kxW3fofb54TTpzgHQVCu7PMlbZ/7/I7Tqo7BOPsN1rupqVu/cP5NrpsZ9wA4FquNAZt ++795026V0P+52LADeJUQOmpxM0l16x9OmMPRqaepadv/AHnrzHj/ZyatVij93aMZjWfdQfe/KLPg +p4wJWMl/9xAGnVmj3Zg1lh1HcslxbLXF8w83u07VGH2MTwoJwi/9UAGp3ZRfb7qdP3Oj/9zdi+0f +Tzvt7nzgv+pMR/25mIMif5E9Ikm/fBwDaGU+9pf6cJvDM72LSQemBivuYY5laVacffYo6W9MZs1R +Y9L2t9BRNOlvyrOU2Q/qQpqEvwtG0Zh1QMMOcmnbNu4NR63eaD7zf+AzbkQESg4aHMFpZ/rpv2pM +gdQUCV41U/wFSzGUYD1oyv+BTr7ctZU1DprQjON8PhuDgdqPhFJBVktDMIJu2z8Vr5tzMQoFzY4r +opqcY1t5cqRmPRAZTP7o+Oud/8z8xXZ31mh2+92ZKMVJRoZpJKZqY/gxb3x0/BejsbSEejHIS3hp +j7tx3EQCCUY20ZHIAF1ioHnU6HenukfT8UjcMbTs7xg32m15X2WP/Nn5bCSvmJFsk/5xYwx2wbQ7 +mPcbyirK657rdzptaIPeKJubtMSv1iLKT0bj7KTTwCnOBpkZUmIBSf2G99OU8RcRD6PPdCxBnKzc +G+xA42sQByutWr4x/KMxrcnoUBMC4X+XOQPYlP3usOOfosTiqX3jsUQ/oz86kzE8IJ5qVxkiS+Q6 +cNCX8wakLn8VX9qkZxBm45gBysQteYXCNS0naJ1jf3TgLYb+ZqPfGLYcJtnqd8dg7aAX/z9gb3wA +ChAHHiKZOFgOFSPtZY9K835fwuNNZzKFwnc2MXRRK9368xByfeTPihRivi/0fxNaIJX6adV/Pe34 +jwZwg2WnKAgBssphW0+McnuliRg+VIPXRUokwfOwapbzV3pJZ94UjwtfLCHvOrOGio5ihgbGOB7p +A39tDEylyRSge9ZtNfp6srL8QIlNMdCX8RuA43ytpt2/prBREqnaXCftwB4NW/15G+jTA0gxegZm +9kV5BMsDwBx7wI6a/Y6LIeHpFgfj2V/5Tr8/tSQM+ZN64Rb6Qisq56FdD2iRTxvjuqwAUS5aV0ct +FUfVr7h+t4zGfxloW4coEZn+u9MLc5i69ihZGWPSf4qTvQ39qttcD7v/Me1Y3ei2O2yP/pzqqF3V +oquWm/oRJjV4qzX+gFsLJuwrEEZDSCl+DX929Y0fLo+fEBeI8PQVabasTh9R4vjcTgp/RYuKiqeP +GHF8jKev2IW+4hb6ihe/8oZCQUdHNhRhTlA6NELvtBM9Ee4+wQM0X2L7b54IQqInweN3lDnuHb+j +F/zOgq4cv2P162aJeFOuo0j02rz5Puq3OxPJkwifTsN6satrrDLXtNyhMB+DkUDjSxlLrvMJqErl +z8FNUQOR3rTCec+Ur+veqW0A1Xsd5yz+ZzyazKAapJauKtU6hw55VMq1QUHSOJlqnX6lMQN9Q+HS +h9ObqvRdi7ZH0N96VFC3VL+uwzgF2KvZ+FDIqGp42rf10Vj1Tj4/LvdHQPm86ozn/aksAPfgW/ly +D91E9Xd/KAoOsPeRzmGUveBNcdgamVjY4A00486Hil6mfoeumUG4g5qDaEEpQIEp2Ooq4yaVNyWg +TdWNzmMIEphZJ53J0GwgQLeW1U/12AdNgF6ksZt2BIh9iknLsIWS/uFIMTT83SHS4EfTrtSNs0eE +8gPj0MYLorYXUFukzudFQ+FKbSiorRHUFE8qcYPNkJzGDFF7NnBrKfba3wBaMnZ16FwKGjcE/gim +xkHLAn2ETHb9R26cQsWLmlsc4MbWSDC2PRfNtprafFTjCjezQZZ23ri588S1KMZfOePYYTfK4fP+ +204zcdNtd0aJ0xHQ9DoQqUBxBPuwI+E2oTjKE61RH5YTAJCNLFvdbjrrx9u4C0TUskCwBw8/E9sr +HkU334zbA/C6P3Q9qHHbNXAc8yd/QcrXK6kbjseTOBJ28T4MunfVcjYSvUssz9u3nCiGjUCQ9m1x +nIGOvWvWELb9cyRWhLNv9qlrZsDp16gJcDrtfgwbRqehviFa2qYYZ2AHETUcwZNkF+0a02Z3NmiM +7ZviNhPdPjFr3epP4q3REF4FBl1yNkOFLWW+3URXFeH586atJ+04sOHhnTsOAwAN3wFrkq4ZQ6LY +tBUSEkYvn6HXP+AB7Tj+6bLdH9ZjG38MevHOEOoY7nYQ+gBvIWU93XwDFm0GL3gTxxKnWFO6h03B +poa8WRUQZTn0Mdgi3eH7yKHZRHXRlUNT5CltNiZTG+Sihk2oYoH9pOIQLhrLTMJF24nG/+HUWs0o +OMvmg8akN9WO2kVjedQu2qpG7aK1etRmTF47x/m0A1RipNza7OP34Sze7o8n76Oh3XYfT+NQMQM8 +ZGpPFtM44JnQKTsETVXC39DyP+P4RM+SkMA3a/nhhnmBdiLvUvzLZmhS2mF/uDXESXsy1e54UwGE +mkmO6OnUuufWIC5511uDv3o2bFBpOML3Nms9uIbeMZex7RlqCSILuo7X4n6ckwr0+bb/KVS7Pb94 +Cvv/oBx0IDgulXAyk3agDdRiukMb0Qnlq9OQYRtRZRElQdKcDUKRrrA/gaGsWqkjLENACwR8s+1v +/uUvTLp/oLux7fgy+F5RsWyUCw0jtlItTLy1hkboyNGVzIAyXjM2U2mtrL+1EJx8OAtK0EYUkqqC +VPpWqAqVBMuxnY3QxY3GfSkIyZS4UZvWcGqHUtBm1u2rLWxz/jmVrtm0aYN4rJNsnEhywGzImO1q +lsS0zRSYztLJqDm77WuO3cxaNLvQFrJtMux8NJSTTUsBABTToX2bPtlCrnOD2acXEp+NdmeiOoo0 +baWVI7yZKgiYuf500JTh97s2SjJoMBq3bBQj1GBqM3XUoD23NdhtdjD43H4DYxEzH7ZcMQTUujEc +jpQ4VDE0ADpZslJDv+Iq8xwVQKrbIyeB7rTY4HYx9SIQVq3qsgh3sOfNhSKykMCQcQ== + + + 4rQlZSiGVL9v32ra646BmTO0Edqw2QTsxsm0A4c3cdetFHbgntVLX6jmZjUc6LOQPXZaKjgeNY+A +MaCmAZ3zS7+ihKVjSFks8eLri0JJdEJBWwYGuI2GU73bDozAf45fqVxVardz44/OKRD/3XG/k9Wi +ydHJo6ql4FfderwC/w6cPZjfK0yxzys6sRgGYfudm5gMs+8o2N8FVrzQ0Sns8GLU70pS0dR4kAaK +S0aUJqMBQOKfo0mvLkkmxmZ6p6PhqPUJPuqoJnnSHbozfaVB40Ar6LYfzsQJuMOuFMWUBXK02ZhV +G391JDMTXjFlvyzwMgicz4lOW7LN0R8uukSxElYrat8p+tS6V2/Lc6Uoh+YGkflUDW5jLysECwgg +d8pRG6xU970rsS/OA8IU6nBB/9bhOoztpCFdWmPau+iV4CoRTZhxOZIppUIBtCb1e1LlvdZ+6SoM +0hvJVBXHq81gLTajetCmOpb72CxzU9/IUqyp1tu8cw4eEbueFWq1UFNdB4ra71IdbzB87IIJqoQZ +jOcENJpvjHFUZ9dBdDAQjuQHslYWlB7RCcRpA0gJJf3CHScpdKZgaA33ElRiHdmJPfGaMLsFBZHM +5lxgAjCWI8VbauGDlVrXJ90BRNqtyrJ3lDVm07Eb0lXnA/YxdebMOt3EkTGjj3CAbFel4lrPVzlR +dx52CWye204Thro78ygVEan5kvNg6nbmtowXyMCAQlz/nA+aw0ZXirAL1T/BTvM3Jh3/7LPjF91O +/qkUCPfnZ2fon+IIi8ZQXajLD7movzGFjxXdV4qJj6P4kBkCrgX212juHwPO6Qf8pIP3NOoag/uA +VXi6mo6iftCZ/OkQzBhezDqGyWf+Ljo5b/j7jb9g/H1jjENHIK+azlufcHhHwwI6qlLA4N6GAKlz +MLrRu9J9d+qfD3uwckjc9c5vTbpjx42FGgOMIC5TV3lj7NZMNkNcUBqWUXVD6pojf87JhxgU67Sx +wMA7xhgss6mCgYzHKrbrQMIqKW4rR3E8BYysuIKLbO0eUjNaXTijHXyJmbkwSmqzxrAth0S75MVi +KZW/zmxdHo6x484IVasH9uuKiEC7sMBcBm+wMpiXbUNX5qfZdABf7U9nwCKfy8lB/9///f/M/t// +yx5n4mdgf71PvrV2/NGw54dXuqlMeJ5PKjGBOhNbmVki15VGnq3lj44EttCB/cOXzOH5zmNk//Yg +uNe4ix7TO+exXGZSHnymPoYbx6WNaCiY7zbi023uulLktlKZ63L6lDlMVZ+Cp5nJvMWXitSpECAZ +ZosgpoWvwkeU2M7svcR3M/vR8TQzPaESvkBmr7oxkRodz3IflctqZp/p1PLdg3SrEI8HPwxdVdv3 +oD++UAqk+IfyrPD1nGMeYtHsYFSdZo9qs89ImtualwrM9m3uqx+89QUK78Rx0xTYNp98528uH5+y +9Xz8xrpTdbvUc2a/V3rOpKbxQaQQDcxLoXL73RdAyCq9AQ2j8P58y+f6mf5d6j33Oct/8g+kBh1v +O4UWWf3O7B8GbzEcMORp/uXjZQR+7XwXjtpHG7mY8LWdrcW2hngMd4323BdIfoUirWKLvQzlP5nX +vf1sgN6J5M6ib5FMPnhdynfmu+mb463PvVar0YO/upHie/UT90wSiQY/6W6/pbovx+1cP3AYjE0i +T/NstbbzDccfzuwdf9K+ALd385zJDlvBQeTgdC/BD54OujyfmL7T2UnriIz0UqQMsVU4nt4AtPHB +Dn9LE+1UN59ogPUlTw9CsWgn1+cvBngG99VAJn+0v3VbjCbZKViXo0duK83nRy+R/Zv2Y4pqbj0j +sOlhAEwoze1uwSV55G65yyHEUzrXC3MxkTRv2lWCfN46LSQa+zuljcjDBPbCwRcvCApq4gsQzc0j +Bv2OpEv74q/92+IJbp6PFt8wMOqeOgKke0dE0ulilCocfhyIcG4P9vfaX2cvaCXlAQN45zlW7AU0 +yh3LA3hWBkCGDq5gow6DnrEbucIrQjUQlocM98B9tbL1wlek8J44+S42GsHtHNe8vtyvFF7T2fpn +a5a92G6dZusUDVY/yz/fb4Fv2g/Fu7fDuYwiTLUaMn3pKcCEfnxSkRbsflR4rxXbCJ8AbCMcSW/t +3eIVgpB9geIrGbnJMXfHpcxk8nnNpE5vD9EKCWx3woHF241GcqPkix6V2omr8S7hCS8sBOUL7EUO +5qFSoU/miGM2Bf4pE10MJ801R5m9+mwzWz+ezY2o1K2kCu/Swt9NNuCzOuBj3/FuVo+n+VWyUwrt +jMP5T+7qodgk9ncLnckkSnQuDvbkgWB0yMiolrOvxySitv3YWwnu1JN44eiLb+C9jxdUqH0PTrLn +L7nTUv79WCDIk2a7lG8P7hHzNFmDcq7PHdwqsLlZ9eAhV6lvHejG4AuAUXTOC+VeoAO6utyHHIYm +3lO3I+No9e1a4Fd0Vh5vNpPJyB5zpsPI3tF09J7vTrsc5JaxxwsqvHVUUWa110ntDMBOvgpD8jqN +HBw/HEudfjwBPkaDt4Hqbnn22h5ka2/HhUT3IFTCAN6DFS5bPx19ZG7qR41SUbi88wX2I0TxSUbH +uBgdnVGlHS51B9Z8niy2et87Ugdog/QbmDHvPAargD0eBLNX/fGuut1lowLYX5Dhrz5349mT+9rQ +F1CxcOn9a6bO75znq991UiMydncK79ngi0YGXJVKr+GNTzQNwHOHHbCl2Kburbj68H1PI2lUX+8C +IVoeFaP11gHA4uUt2Nh325H0AUejt9laNDPMd7uXbTi1DdikXjg5qcRK+0U2jN7CuXzsDnHz+mkm +kOsfE3G4Vo/K/uSFw+4uk7lpJviLyukV2Xy5ztI7G9tFKrz9kifL+WoG/koDEicPiE4zdUhGQ/lD ++VnaF9B+g1uiZ/DPHGSKefQh+pOrValL+PYAfS13kIfPchhUdj9W4tlY4Yp6fRgXYZN9wJNhc/ig +IHeVg43OFDi4F9ifFkRGHnxa/mIPNYGjuUBDQmMAcwFwsngocJp4wnBQEDt1+GwPAVN6QSD0KIJD +NusU/SliDEKsaZGJvtmDb9E0DhVU4sZwcBiLw4+9SxkFNYRPuZd91VyUxUvbLq3rhdAtgy+gWwj8 +DUSWAhtNA+FJi44DNCvlTwRK7rmsjMEX0K5l2ozkbJcEDxn9kmeFO1X+xDRmShguyAI2rsqzUkhF +T7N4LpbIOsAzRTtHQseBMmfY+NwMqbqd6gvIKDzQTVPGSUoL4lA7mrzyLXqr61RcF2XfqShGs6pp +hWpRY4iJrMlW2ZNHeCEzD0ykeC4lhEcE1i2qVWOwpReEcrD6EI8y7LQZA0RTk7emNzJEC4Ixti93 +gMZ4xQlk+Bz9wuiXZ8pzN/F3wMC/aFHuJbPD7NX7xwlQK0/GOoGRrd+cDEsZkuz5AuVA+RXghA1x +Kt1kfhnYL73O6ruZPeJiI1K8uatIoiy2rVInVFqB3kpStwOUDA0DrL4AERxRmWZkEhgsJzkuCFS/ +8KOlNcXvPVRLWbq3fYzsAO2EIshA8AWE0THBF2PRd6ZwcvjNqHvJvXayV8PadbY2OxoUI9VESPu2 +X8okA2PJqLgKK8YX7uDosf6dPc/nLqAOI2pXAw1igAUKtTDtTFXKBr/Xur7K8k/HV4Xjye6bGYAs +W3k+yp7cXgI9WRzZdaBXnp53JqLqV+VyQGw/xWXbIW5vO9hbDlC7kGwHCIznr587J4X3y2kt0b14 +BGpz8TuP9W2a2ny0N4YsTSFfQG0MKRQKp4Yt7Lvseanwdfua735xib33QeAD6Le7JMBJ+o3nr9oj +OLiYoh+Jamyt/6yAApQsAvudLAtuV/YHpAsfsfAh7uCSTr8BRe08mP+M3OcT3fRBSlwrLZ40tkgP +kH28pBjCgI+p1+CigtAPOqW3oPOgimleJE7VQKyMip00pnNlA1xU+sCyUPR/rfavGmiy1znJgwm1 +I6W313SyUL7n34E5XqQIqsyc6sFeboSfdEYKprGi1O3bZeH9OlIGfLpUoMLtIt6ByFKFMiCJGdfL +/k7Pal/xpZfn3a1ScTh/owLJgSCu/n50O/Eo8K3qce7yIgPmcj84Ew38+X0ge3lWuykVwm3phULs +ox2C782bF0T1pDlWbGS9z4F66IF1yX8+baQi6fLrq0RZz3GwgvGTXO80AlT7i3dlz6agp+Ul16MO +NpQXsiOASLUHfQIKkTOI7QfF2wEsPpO+V90z1pTO1Ft3HL+MHN40vqUO6nxm7+R+E5iPnxta2OfZ +Wrn9BdblYEJlrjeSaA3QChyE5lQHktw7egH42OHndI4WOXkJmCro5aUBQNSnxdcx2czsXQfjKicZ +xfY3997nF1/Z+nXjHnSQ6hOlpwwNRlOJydxZ78DwBZL90ujdimJIuWVd2r1qYC53L632KNrvX4Li +sjuFJtOpOe5e1UDg7v0AlFwKX/T3SgX2gYqk7593jRBdWPkqsFXV7s1VXz8RPsG6pLnjeSF+1Y5l +UmdfPVlE1bnN0jAvugYB8cXG36NuIXG3l5HwGewkPjsvbxCfU3Fw5cKByEFvD1go5qnc4DwNpJhG +8Thjcudz+gGg+mpajOxy7yqJpdAdJCVue+tbyKRuv7t775XmRyZ1V1KDwhwb2+7Jpi+AJPZ+9J6r +INgq2S22JELATp+1wPo97BU64/MqUie4rSqzBZ9RhZP66abSPX/Tr9aBoDvcLr4Sw+fCe73w7gsU +o6PTeZbNZB+LrYt+WKcuiZ7Jj0APMNTkJj9NnN1k69UM3IbJmHHw+6HMJJacZy+uEs+p7ovwDlb8 +dhesi0q9weLoIAEoproLFJSn69Lr3mdC3ymV/h6ARf7YyHwftjrKC7hW86zQHH/EycpNVHwGlhjo +Y/Xt71gpNEqGda/IZvWIUkDI8hUO+SyW6w+Id0AvvQcunTq/z+yNk6RxamI7uC6gJS9cjnYtG6Em +qXa7+W1s8hArEMmHYCnf4XrZeqFB5vrClkBQ0e9uJnV+2UcLpuIwBipC5xMHrbtHsGkKp9mreubb +SBtb03z34HSaSZUCDe6Quyvnz/I3h7J2yInyhd/vth4LR62rixxzS80MC/+ytQGEB3FZCh0fVpOV +p9JMVILFRYwDQjvh9k62s++Fj61nhk+N43mgDnV3FVBI64PA3jsjSHSP++HtwCuk7v1iM/Ew1mre +eGRCfWe7Vnrd2qmB+UWeii9fsxbyQRrxWZ4Vm7ndkC+QOo3Qj9l6fWdDQyyHRzLYquilEsmiipmw +9OeTBYFUtkr57DNQETNHd4CPFaJ1VvYZ4tEme9liPcsnrz6SzFtuACaZIyybQEHQgKZSODaM1mX1 +DFhh9ZvDXmY/Pb4FsrI/JHZMQHRyveDsOMfcb15XDp6YoKuZimqeBkoo/gR76R2dAfOjOFLvOy4z +gtLwGPo6wXRZeguYCA9JBUSKFDbOSuH7i1n25J5sqzo9ODlrF9qDZFR9ZgFGFgJc/g== + + + vPeh8F/MhEdvn6xqp8qnF5jhRs5GX4X35HG/0NztBpLVt8l+KdsfbiJ3qI5ewOrDo7zUWT7xVDg5 +2U9gVY26rMVKRfI9VEplrzalBb0NAc5fT3AHpWw6xwXGbOGo0Q8Y+E//Igxw83wFeWm8cHK0mQfc +UruB9qPzi/tShpi9gjUfNksbu1ESmLDX8JskBXYO/Qa24aGgAkvvhsLYuOTr/It0dpUJaE/fRCTs +lUJHg2zy8+lsq1S4OK2VAmMGMJfbzkeGzj0wyl4U1SDwS1Gw0Blelq9t5bPgv5XMfiweNu0FNtop +Q2fxE2hUpI17bKuXZUK562Jo2nyGjITUI4uYRh/QCoCNG7u37KVWzVHh97opCDJ43IYm80l29Hm+ +q7ac7HYqInvJ4rMlfNn5/ohOAeBaUYVGrfxUDpSfBUAvvbmq8axaegarn9lGqgg6o4R6Mpc5LcTP +P/dVVJvmoqPSbjjKATWICQBTItNHh417nWTrRjyC446v1TNVuyAOqdJedFMx4A00phbb4/Z7KXRS +TqoXGdHq5dMWfNHP1prjd2wtUtzmR26wKXypNKVMZfwt7UpFvqBebun9Br93eX6Rrc2vKaNAYSeF +o0F3CsRWbgBG2OdKb6eBpLUGcJ7avwIYO21Xt8yXW9IphOQo0So2R5WYQ7v6zu1zsfF2tJkbRHZU +AlqiMZX2cXh2B1a6qzq31wFT7TvDTKFAeX8Fi1jZ/QYq99GZJJER+/yaBO9KO/NxJ8fMc8DSAZa2 +yiZHTQYhAXDQeLGf+/q6yBSO2pezwnEoVILHoEf43CjbbwyQalSc7RxtSD0fz4E2blReq2YarKjG +TrbakO6i2cvdVyAhWwNSzY6P5zPi6LG8r9sP4lyAgtKqp85emvPS2ws1gDRGy4fpD2pSOujkVOwf +7nOMhwDRewTC4S5UeN8Zb3Gzk9lB6bUfT2h66b5EP8BqTHf51EukBs+DIvp1ocNDGigETCPLBIOj +JHl7ksgK5ekMhg0Ahe6ocZeZhu82CyfHz9+Fzv7LprJgSOd/Y4CIfh8D9vGU4FLN8x23X8Nvk8C4 +qlRKr7PnWCkT7NS1h3Ec2iiYw0iGwQUQzZnYpwD6i5bLD0L9qdisZ28LH+xOV8e9ZMYl8SxZSmM+ +JS5JEa2FL4COIPOfj/vfpexFZpw6nc5HWtcgx32TyatCK9/oFXa7iRa/Txc7xYf3o6LsnkRNamDH +10pQNjWyQiy+CX0hZcS2EMYuHvj6WyVRKsyz6FjyEmgcwVihNMyeAvlZD+d6e/sxUUHRQfwADK42 +r7eVwA3MDUWgl5s5NlxKAD7WThU+VNxSfF/fErEs4u46ezWqvnHp73BPbTJDHOeC+9Vi9DkH7H2O +GijOWYQsIHufugBj6e/d40LzrnMFdlu6Ur5/Hb8hHilvHwvMy4sj+gkPAAOPlba4yWXlEKg+h4BF +n3zn0JAk7yh1GZpBetrnri/aCbBTr6OlABkCdvPlVbRwvPFOqGeAG49J7ub7PYtEQilQ5VM62HJj +QGOlnYePYeF99BxBriNT/7XI6nMC9A7Xy/P4+CV78hAWlNWHIQDBYmu++SKcV+h6ko4e75Veozcp +3VxkOPXiSCe2tXDe8h+fpSA89RY0Q5YBjLlydvQ9TcDojvPCc/d+S31arTCA1HHj5lSZv8aMvgT6 +72kpWA6UKgPZLAIG0u12vHAc2WLVPfdn28VWM9qGUQS31KH4dLC5Axf+Fepr+xpP9zOf2XuJzbP1 +PP8KrM42sLATsUZ2lO2UlMFhKHQou5fZe77O8cOjOll4/nimgL1f62cSEjDALy7aYP9198GENapo +sbRTro6VcKT4xk7yhuOOux9cPXb/QBU3YrnE57Dd2E5+3E7AWCvwmq4cme9uPAbBfonstr4LxHZs +iMQ7u5HfJYFNMNgE6v51sww9pwGS/j/TcrScNhSugK4V1+a8JfVZj+PGsKNLChTvs9Jeh6m+IutO +fxULeFaoF3QZkfBmro93KZjPED24J1fd1VZihUF/uEIrzLeT3vlQDKP6iWlcXyTNvvHAPG4miETk +NAI49YyGvyhm/zJFyy8u5V/oxR59WJ/lgGVR7lW2rg4agF7u0/JbKnJwxX1uhOnKwUYsEQQ6DOA+ +vf2N8NlDciP62QWv3t7jG5F5qrYRPb0rbMSIU4pIHNyHUPdg1cKXzJSanoLBFXpgJd/SdE6gBcBk +Bw8o1gYdKClvicprB1gWk0n6oJmNjs+OMyfJaVqo7N/GS6MH5qY4eXogCg+l+3rpIHvQInez/FDs +hd6+jORju1egvypnNV08oThdTW5DrU/fqDqdTPamddBJ9IhIMDU8DWVkU6E0u6FeRr0dor1Dop7P +FbCTZ2K6D2AL80i6vLGDJo7WpdCLJ6ZCmRG+977An+U++Pq+oO30afJ8+nRp3mmZf2FTRy9x005f +ts+A3Nd1q3TKdU/KAfNO9zdCkykZmJh3ekE+MZtUalfp1BdQup0Go6cxi07Zz1AjeF8075QJP0X2 +qQ/zmW6WXhhfYOt63K+azZUo5U4yFp1yW9vDSfjAotP7F6L0flZTOkVxsHK35Y39HfL4tW7aablC +1S3RSz2k62+oU0CLzaJ2TW8BJT/N01XYbdi4qqF7+rFPhkGnzMhASlUiJ3Z6EQzqOmXZwetY6VSh +ZNzt6+T5c1i36DTT4PjSNmna6cvh25VVpxWg9dGhvSfzue5vPE+3PjtX5p1e5sPp7+1B1azTyF4/ +lVY6BeuiJaXdw4fMuXmnzP09UUoSZ6adbpY++O2rAXVu1qkvQJSen0sWc+W2Ar3had6q0wZRjr7d +mHdaJrLBToi/R536AnoEz7aih2Kn97GQDsGHZ8yBiN7iU6+k6fRhn6jyMRJ2uqvr1BeYblY6I+6q +EaNAt/xYT7/Vx4eGRafcFt9rl16sOi0Qp7vPSdQpspG1cz36TmW+JmdXpp3W9oK0ZacnnRpNmHUK +OT/zGCNqr+FNs7lON08qnbPHh3DItNOb4PDDstPa5+VbE3XqCxjn+lgmbk7G++adVunAdSmzf2De +6fh406xTwJNhtzev5c2ZBYIfz4nbw5OCeaen6eLry+Xzs2mnz+e9I9QplC/GuX7ds+2SRadPAvE8 +7cfMOz37Gg/OkwKt6xT0grp9PYoNLRE8CdQiGxad3l8Txe7g2LRT4Sy2uZF5jgE+BrpNfes3zfyV +fxU7bdJh3aYJP1Qbu6hTKpgOVbQzrRJvu6ks7DSqdAp6gd0CsF/fEtM/mOg7nY52DsROZ4cR3Uw3 +nhqPYdxp7p480jLC6GR6nd4AvYBu40audBRDcwWd5mcGVljZ5HCnh+RJTMcIo2PmDEsaejuVP0Gd +wl7Ebrcnk0ZzCDsldJ1OJtnOSKLf4w1dp1P2KyVKmsPUZVyH3s1R563uE/WHTuOV0w6qcr3zMkpZ +vr2/JAc3Vm8/icpbYK68NXB+wHoLOxZfgzXYieSlcX11eN1bTiBf6+LbaU8w7Epu+Ll5Z/YeM8WL +o9ST5VuB2r16s3772XgJyhgzvs9SOw8ty7fVyPCQsn7bPH/fU97qMMZtnW+2mhWLr4XKTmX/eorf +vge/k7pvryNdSTl9JzdTBoxdN49rQ7P3mMsVIr2J5dvbQDOxYf32qZA6kDBm8v4t8MJvW779ml2M +K5ZvezdU7lJ5a8DYoFdKv1h9DYZ0ucdavj2mmPSdNcYCrWGzVrX6emdj5+hp1/JtMXva7Fi+PaYO +N0lrjGU3qO1wyuItWyGKB7vSnFOhPd3bSP1yeii+zcf39buyUn8r72aV98yUiV5pLbA80Q4+5kX+ +8xbow7dj0RwtvbKY9eRG0zP8S8PHqNk2tDDzG7Hj5D2wML/q8J84fFbaiBau8vCfW2S/ydYb5hFi +f42rnMT5JptU8OAiJvJzYOdo9LH0Fh0EHx4P0N6Alo5qRyROhWEQ2LF3c8BaN3dAf+/7cn9bie5B +Mwy402ZxMn+LxzTsdrLpCyjdIkvHolNuC9o5j+adMvcPlp0CIfJF6vQx9VyRpWPZKRR5LatO2+pO +mRqwkVXdCme5mqrT9s7OltIp0v7lTmkdeqH2L8+03Nd0Gr5H1qu6Ww2CDyjLTpH2b9EpsAeB9v+i +dArmopnrs2WnAMFTxrpTqP1bduoLQP3/03yu+xtxu06rQctOkU6hdAr3vqZbqFPUNavaSUrdo1/i +QoTzD+2Bm3Yv88FQvfctWnJb3y/Fu3PHduynSHcit8iBOT9lRW5p2LpvoQHEzpXKQZMuzScic9mp +ZXQ7PtHdSkWVf9LjULsuGuuQJ2F7Pz0O749liCEEIp2sbH+hUaST5ccCYFyNIuyZVliT2H26GBD/ +iZ6OxA6QCix1IOuWYDxgcgdj3EjnfQJsL5f47BQC8j9Xao1Z9Jmdy40LsJeyerpvx4eiTwkM+foC +PNiBCu18V8IO1ttFdqyawcWOFoGyxw0MmDhmAwH0DyTIW62VZDaoXvJINyj1kF7nQUC6p1EqeEio +/Gg6dyBCOeCWz/PciRPS4T/i4LExbzK/4Ibl/HwBZYboH8sVlNavtum8flvy/HZFGjObIVRer22Q +5X79Rog+sWXhElk2wMjd3FfJEpTPDblLyNqLeaIsha40EhlTVvnp2zvmTfEOlJsHkZKXxjyVe0ge +2+PdZ40sLesJG1nPS1HLemhL1uNzIt3i09FEjUB5yBoE7mDWY467F5gvJiHYYjzRYhT/I+KOHJrj +7j62Ycm2rXYl8seZTu1+0/vU1FIMTY4+vKmfOqG6fLIjniaYDqQQ0c1KLcVUs+pcxHfE1Tew0SLo +5WbkaUJmHAbQDjDn7lS4lbehms7fwjtgcHcFi2WKjsnGdrCCxoD9/AsihrCW0p+jyIFEOSpKRk4d +c2CkW2BmoBDeVac8u8Z91yi53Xf2uw7Iysbm3dx2LbfI6DUZhf88RlSHFAayAJwxVDwxW06AMfWC +wn/AgiqOaCNtgPnJXNBIG+eX8pBU40JzmZVNR5YuN6dWk8wQndl1wqCFGZdEsfhOI8YlaZedtDC3 +rKcnTH0BS8HkQmdUGgNt5nFmKZZ8AS/rW4Y4qXjXnsz2frus5dMmyDodKYLXZkizw2NLWXl+JY7H +jUoHhmSt0ElL5wu4W0Fg5dsqFk46v2YFhwFbxcLD+pUvBgooTMlLAKsNXYwL7EpXwLQCxeu4pBNe +Edi9vRHjZZJqrW5pjL1OVogxLUfzOK6x1g/zxk8MhussPV1QO9acv4DxVMyMQSuF1lRAU7m7zw0H +PqZSsM135exwc2W7Mnf3ve3NUMbnsYaVrMAjk6qCG2iJe8fO/eaOW+ND1i312ElPZbHs6EYwVwwr +OqZgul+clyk9tTfxdAMRKdk4FAcu4GogOt1yMZw4bHvVQLCNHLEQUR8V6Lp+9GCT40NJbZCRHNtD +PU+bcZVDG/w6gjRf9NCBhVMDaIIbNjqMKfuw2CBH9mqHL+BlUFsLMgAtt4Rb7nkWsA== + + + F8tuGcCRwgDc2vvW8wu6QLnPHdI1uoKzP0OvySu+vq8jeKh3uwqiKszI4vO0rHAGTSycqeFjYZMD +2v+k3dKneGJlhyz3W9zS7EFWEkCWxy2uQZa8xdEX9Hayl9Bu8GM4F+0WN7W6nb1LgGo33XlI7HwJ +x3qXrH40di5ZnYdkcKzV4C2MYmeXLJiaaiOJq+/ZTXIM4xJO3bo3ZCtJP5TjuVYsL+DeAHTwTaEJ +oUgVw2q5XyudTLXw+/gCdl66wTE83L1fyu8D0eLs69OxAgt/DcQO54qSVXxT42kYa1TpzFyvSgM6 +sHYmijzZhTINsXyiV6W94A7rY2g8AfvxuPUv0IfXfFBHESpbzJMgPNFpwovtl9Rl2H5qznR+ogg/ +Wb4s4I0en+jlntWEfAEbSge0oxV6izCAw+sA63NYc3eIeXVw0vt0os5KlwXY0Qk6Jzmk1mXxXFSi +Dh5WBdXxG3BW4JkbYrDcdSpKzoPxxL35vI1zvquZSTvtqajrI0gAzMrfauZtxZaFlb8VAvOw+czt +JbBpfIGlDynQqtmLPJ9rOFpD0ttoxDNxDGfZHYihyNakAkXiyV7geJd7sr1vAkxzQuhNiGrPB4NI +u4iGtBpnHoWpruSEIY+CT30B523oQtxAYFTc8xmfhRIBYzl3XaFSpX6mvjVSTM/Rpr2wgaNNe/oD +PBcczdRDkgeIyXwvy9GuFY4mWa9eNHg9MGeO5nN5ggSBLc7R5F1ZvhmtgKOBVTPjaJ73PoDjnaMZ +fBcYzvIcDUJZ/uwVwbE5DYrmQvIpTsIXMNMGNELoZmRnQauPDs11FCZ6pY23BDaPwTcOny17ACvJ +l/fgtzUbcqmZ5cE+P5+ZbWbsgffGZgGwmw1PTNYXsGSzC0Y/aDfzDbKlNZb4IgoKWDVdUJMVh3GG +4061t4SC/DAAzvIhEAiKhUGtO3l3hqM9dHfpXjY5TUDAVuGrxrIQzC8CtQutNARPY8vo9yoibWxe +TZe2+O5u3XqzVL4LS2l460m/t/fBQmDL6/dP32ay0KsUg6vm3aVllGIQzjL6vQqKLAsXl2IIjol+ +bwZFtl4t4LiVhvayEHGYp++lpaFGFr7qz4lRL+DpSsKRIP8xjcMSZaUmeEoJw7DUBV4nNkuiRmXU +xenb3d0yvmqdnx8AW3Z3q8ZlsrftY61tMOZK3ZVWEvZiZRGBtYy72uc2p6d5gM+bhI3nykU4nW5I +lhSBYnsct5deMOXjMYNYyscTruxKF4KJyt21LcPzrCPXLOx9MDLKHSpdbK7mdHXRtgCY5dmN7O1x +G1APgNHbeyfVVXhIAMZ4byqGRQwiXMnXuCsfLAZmsdnvbYNvMUX4JP+9q0G5pAjD5hIlMt66ijxL +s6dDU8tCXAOULTf92IgNL183ojcvxY1Yln6BeXNFsww6fHPL8jl0ailmzKDTZQwtnENnn0GHePIK +cugsO0UZdJbZgh5z6Owz6NTZgsvk0Nln0Gm0viVy6Owz6DTZgkvk0Nln0NlkC3rKobPPoEPZgivI +obNvJ+ZWL51DZ9i4mgw62bJYMofOPoMO6WPOOXSagGSbDLOLYMlM27aOgbfOBNIFu7gYkqmnt+Ac +uL3rLl+qpLORFw6GLei1XxPngFtP72NBK+29LZ3qjK+gD9hYGE97uxpy1eaKyjI+5CYZrPPVuXFy +omjP+OyA2cdhuZsf8vU5Zc65np/Oc2XcL+6RnvA+JIvMRwfPld2QzFLm4Fw8Jc254jVFXSiIEtvj +LYFq5ikUBMePmQaDeHcbWzmN0c1gS/ur7mNb9lPzuUx200ZCenUMIkoGa76sxxgnu1kd22itJKdk +N2v71P7AQcUti7bBIBrT1MkMKeqyGTSZwu6AaUOwSOOJTZP6dsp8dMezGiVPRi/alVZmb5O2DqH0 +lGKKct9OXWYdOtv2AFlmZ9myPmZ0nTk5DnvCWOcmAd9emwbNLnBiVbZUuyyzwFSakj4PzFHtcp3H +N3eKgfeQx9d0yn/Z0jitrFPTrJNg7FVpYwx88OBzy2pQGbMUTev1c4yBdx1F0C5rPZim6+c2j0+Y +OOXE2BGDNjodAltZhuhEOfmwykzxAsyZ4t1jTOtgXRJjjmmi7iepcLSFMKZ1/FK5u/uYNtCpogus +N8nkcqfLGny+RjNL3upX5n5L+3w5HQgLAL1NrUQ2AfFGvZDwnzfb3V1xYezJFp+DsfdRcW3sWQHQ +xyguAMLpahSwzvKtGu5S5RZaoVfCWb5IKo35toApbs5OBp+tSxpmpVkYcQayt8uR8zmkObs48kQT +sr/yxGcwr2z0yNTUEMofKsxcoFx1MmJFyV9H3tw7JqYS1pQcEuQMXMc6I2pmKs0X0MeO3O54Zb9b +6mNfR97cO9ZpdvoIooXx9OngafDpTAlrEvDokdEMSZOPDAZFeXF/2AxJu5mdpZgNnhi3Q7KPTndO +irMbkv7ujrjO/4tTklbhkTlGHpklo9SAJrztwiMjnvE5pOdsp+I7y3hkVPb+8fIeGQAgZBPd4SEN +bRGPjCFbcHmPDExD03lkrDJSnfLzGE8eGVM//7GL9Bx3yTkwRQ9sOGdKdhe+B0t1EFpl+URRlq3j +xt0oy/ThdWTLBTHY5ySOT1YTyQDXJXUZXI1TB0wtFXKI6XWThrZgALtavsAEMmvvkof0MUPogmm2 +oFNeneegWWOEKsqrcxmvZ5tXp0odtckUdnaCntheUqXavSrd0jZU78J4Fyl85lLQSTnvVoFJq8mH +g72sIqbOPh/O+/1ji+TDmUVBXwxWnQ+3RJ6Fh3w4uwjV1eXDQa/1kjvQRT6cyY2glklci+fDaaKh +pG+Cq86H0987ijPiVp0P53hLwEry4TQnVi5CLRfLh9PbYlbHOjCTbfnMeijgVhYTCUBpYyKtdEs3 +MZE3I1cxkU57f9qjl1UD8ihAYvlsdAQn6rT6LuG4ySOxhIL1MQRnBZlchkgGmxh4Z44Gk+usHWLG +eGdVLRuLiOfg964h4jn47bAQuk1o6e25u1lmGyrJRyqvwrLbEACzvVbGjI9ZbsP7sdttaKONQ3x7 +sxdNCW01twEjON62j0U+MoCzkkTIQsKdFHOEY30lsMVtWlZh1sYrgR1vQ9N6pXW3NYajRh8WTD6z +v9jJ0aCWM1LJzUUDRFRztrpYeKGM1Mbmq4skUpcZqY3NphuXgUOq30oyUp++V5ORCuGsIiMV5ost +n5EKoawiIxXCcXcNtM4kNovrQxvE+tJUz0FG4Zi4+tpteLf0NtSlwpnzsVWnwqF4ftuInlWkwpmu +y8pT4Rb3W2oxZm+7e7Arl0iFU99BhJLhfkkqnIlX4Rekwpn7x1zaZ/d2iqGaFajvT7ZLfPq0jFV1 +cyO8Vh/Lxx3MIreBXhAU68qj6MKBDIFZ32znUYcxXDLs9XBBlY1+7/IIx+52XsDKzUSe0otzcrM+ +r+7J8jocvXCQvKMm4kHZv7BqXNSsP3ENUInL9PlnuX/TeC1stefFUnI781Kqpy+KmcQsCDh/qX7I +36Oy4YWH4iSTrXD143wu3srnc4kTWISgNpbEUaCvHbLocdLmYpllnUErScxRerTOOxMuUxdq8tIm +u+21zk/VzmdVp+znbmB/Y2SVYcfc39klu7UTlp0SpXrOLsMucN49bVh1+mbTaTmWVHWqz8VKRaYq +L5w+2Y25+6zKlQl1KWCbIbtkNzKu61Rbj29vYJVhx21tfXPzJ6tkt0e7rLOBfYbdqF637HSn2vls +W3Xasa/Hd3ln3Wnx7LFsid7tIb33atXppTbDDq0q2LDirNEvkc5TLtvtmbXDXgVNS+ap6goiE77A +7UTRWeVMFNEzyUpKl+Z9vUC18x27CLnVarCRIZ6L5ozoYme0mtQe5whVvdfEuo7Vt4shqc7FbAbl +FJzqFOeBrddVVpIzKzticqeKC++SXSU5T164x4LrEEmHbEh0J6SHuD6nInK2cX3u6cmhiJzl/Mzq +vjkVG3E7P+daA66R7lRnRHeX2hL149zvl3LHuhCRZbir2wJ09p7eRbLpFvPDeM2mM7MDpFqcq8um +c3k/zJLZdGY+Qf1+WT6bziyXbtHMR+tsOjNfvHmk/TLZdBq0iHvW9P6xpbLpzEA53BCyQDbdghLZ +Yzad2TmNLCtXlk1nlkuntvdXk01nlkvnMrbHQzadma9dqsC+umw6s9VFnt6VZtOZKTfq2NHVZNOZ +5dJZ3Da/RDadcUifW9aa0qLZdGbKqS+w6mw6s/UziYZaMptOD8qxpvBC2XRWuuVqs+ncY2yZbDod +KP2Z+Iqy6RbCmOdsOtscq5Vl05nnVq86m84MAOhlxdl0Zqcluhj4FWTTmbEHrfW6imw6h5ORFWXT +OcuXVWTTmSFD0cZXlU3nlMm1mmw6s1w6y3p8yxuAMcUA1NQX83R1k3UVL2ORSn1tDpeJT98Om12D +fGZkVctm8Xp1hiHN4CnPquvVWWsX7vA0iwQ94UnBkiYSEuZkOioWLklAk6BgkfVsNSjdkNyyAhfV +5bQHUwsNCWIMDMpT2WW7IZkHUlhyGBs82ZRdtmCZUIppLaJD8niqs4jo7eTYobC5vWdOrpZlV+hu +6TJ3qnuuXKrki5S5s6wud+IqV8llmTurTC53iXSuAiTs45OVQnfLrVX5fuymyoytl8pVmTtHjyJE +zNJl7kQdxr7Q3dJl7nDum0OhO3eHR+OTFdxzRR9ek/aL6D7P4mRlIUrjE0XlXjiXB0ztIOyWPi1P +eWCBOsfYQyf6hGl00Hi29cC7SqRzE9Hsc84wtA7icJ1fCHqxCTv0EEQGsWPp+tNSsrsKW6DnraA+ +nwhemmo5Z7O7oazOe8oXgwUTuzTRUICoHOLBXUdDAVCO8WOuo6EAMHcR3faBzYj3rSTzcfmjEFhR +0OY6cHH1XcJxVdvVDIoqsqu2ih2IoBgy2U0zhZ1z2REwV4m1VjUg9Im1taExsbY2XN2tgBDYSgoZ +IxoDo3XDzNSyyxKVdTNUOtZ7tYuh3jUe6cJMPGMEta0lbhVD3Zn2VpKZIt987F2TMIKqzldVwRC8 +uLA+Ina99689Faq2On2DhdeWVicwFLuoTg9wVnBLAIazbLVqDEXahGY3HHqLVb12kcjg6YQ3HDHZ +hjcuEhlceeCXrnAn5Vda1bhbYBuaBFcsWrfaW4U7u8zHJbahRGhihbuVVMpzzCdyVylv2XwiuVLe +8tvQpsKdNi/JTX7IIhXu7Oq9whp33ivcub3VHGY/LZ9Y+/StqDlW1qvrxFoAzFnN8blRdHBtusUS +a/WZj+yy/iOYX3hqmg7t7Z4rBGcBvmm4IwLCWUk+5ynhzhZzhGOdC6tLYvI5XTOByuV5yW83S2JS +n4pCBhE1bMNUyGEhXPi1pLpvLtOY3CQxBQ9e9JaoSoq5SWPSTtLBd6qAktfFMo0pFXKVoW5rtsu7 +MhVysyvdJDEFD4Z65XtRu/LOUxKTVQQRrJ1oI2m9KYZ3Yg7vErfy6xRDk8sS7+5xDQ== + + + iFXkuObj1reKQfvFa0U6T+UeESqt9bH71V1NdY9O31aU43pveTWVdx2mOfVU7tGhUl5iwRxX1f6U +wzBcZD0757iCIbnOerbLcRU9QHAhqrx5f5LqBzPeKgf1Qo/M5xLHt4WtznHNFygcRmr1g9FbhAO/ +yhcou69091RqU8H0ZgELHuTaVfmOxV+aJLyzwyt1p5p8OF9gunVzf6F2VWnrsKXyj/cW+XBh6yS8 +yfwtRWp5si4Nj9i1yv3jtrb5q/CzVRLek2WnYC6bpTFtOVeivPVwbdlp8KgZ/7CqwxZWOpUzuRQE +X7CUqlNtato0yO8odQRpXZZjOHT42Dfr1BeACNbXnNOk4TX0uX9q9J7sX1h0ym0FmLPCm+KD1WfE +vdp0Wt7mrDstX249mHWK6r4JFU1qpb7TK7s6gic31p0Wi9clTWQX6HYbvo/Kv8QkzPnuQUK7+hbt +6Dxh2U6dX0m87aayLiBGUqNZURGTYM73jF7plA9rRG+PVnjmbfzEsqBzGTYJkMqG0WmQpoqZc+Ck +C9kMYB/oE5scPSTWKUnG0CrLIUFKth5U3k1qk3Ni03RVlVmQQ9ehMotbT1LBPrTKcukMlVlABzUv +IWh2WXe6myeXyEpziNDEWPK5oyfdoZfX+clea5h357nKosWQDFFa+v3iGumeorR8AbtBWfuJvQ0J +cEvrOC1xPIbYWB27Kj6ld7WH10VjzZTFTAkA+8jF1dcOPtiX4qoub7yPbbi74dBFNpKte9ntKc9L +cZmbaJWcRMOVcQslu5kfWXu61/qluKBnWXuLJswCXPYSWrO74izzxZysFuNdcTYGkLl/TBs0YnLE +2ih5qndgzWFKK7ORGyU9h1n01Bsn3FntY3Ri5Vy+TjMyvZ/f2WWH6vFZelWYb0MAQU+YeNdHLGo/ +BQ/urA8HvSWSGepZLFGWzT6TyVOOVdLTPQeqIenyX9plO9+xozauGZIqVF88rVbtWo+pgL1tF6mc +6nuubFIBnUoaO6yfcvLeLjsn6rgmBl1dY9MqMx6AOVXRCeqza22A6aTKchhzzOVxP0ntyeWSGHOs +p+MJY1XmyQKYIV3YTDsUMbZgFqDbHEDX95BYJYi5ygG0iU53kQXoNgfQ6E/2kgXoNgdQfcOh9yxA +tzmAyGu9cBaghlRsLEx9HKy3LEC3OYAQY4tnASr4tOcb2hwrr1mAbnMAZRt5oSxAiyEZcgDV55V4 +PMZZLV+Uz31FtmWK8qnm8guL8hm8Cr+kKJ9TRbbVFOXDOSP2CsryRfl8AROtcOVF+Yz1kX9FUT7r ++sirLMrnqn7lMkX51F4FOCjOclAiipxSg62r+i1/N9TxKu6GclnXz9XdUEvX9VNNbQV3Q1nV9fMW +p7RoXT/7qn4L3Q1lUtfP3itkbol7r+tnTny2d0MtUNfPmZJXUdfPPjJE9lwtWdfPKZNrRQ5d26p+ +voAnh65lXT/7qel8FwvX9dMMxFDVb4EKIKZ1/ewnZBahukhdP9N0RLtbzd0jxnWmrOld0AvU9bO/ ++Us+E1+yrp+toMsjKbaCun72bmFPN1DZ1PWzN3VNo6AXqOtnliapbL3l6vGtIOfdU10/eyjQz7+K +un72Byo+13CWSXzXZ6QuWtfPRNVUVfVTV2cglqjrp9uGhLaqn+bOLs/pKYRc188x73Uldf3sq/rJ +lLxkXT/7gGtVRupSdf2U/C0zWtTdc7VwXT97BCINdgV1/Wz22rRHr6ge3649FNf1+BzKybmux7dU +XT8Ziun28ZrNYajrZ5P34Bht2/Fa189ek4c3Hqyirp+VDL8xniQulr/lQp2XThKdtqFTXT/782Zt +FMHidf202NZbi4vW4/MWpGFdj28F20eu6rd8PT43SUxOtzcYYzW8leLTZ6QuV9dP49g2VPXDGUPL +1/WTU6Xs6oouXdfPXs2xoDHPdf3sq/otfWuTWNdvSV+fy7p+LvJeV1DXz76qn+d6fAtl4eq4pbGu +3+LJ8KqqfqpelqrrZ3Qlq6v6Wd1y5rWun314l06KLVzXzz7QSedTWriun8m6qKr62d8L576u3+J+ +Sy3GvOc8WdiVS9T1UxiXWVW/haMHdXX9bClCVQFkubp+9oohtl6Xr+tnnxArSuSl6/ppJ6mv6mfQ +x1zfZKWt62etBGEdxuEmK5d1/VzpMEvX9VOvpPEAxya71mJ/mtf1sxcOtlmcK0uIxXI/YSIeHux0 +tPNr84gP/b1Sn/hGRZ2sBE+tXbv2gfe6tEUNNUk0ppzepA/G6jx47JsSuwppJGR8pCCGSJx3OBmf +ZxpLtDqFuW/U9HMDiJXjjcjj2TaRuOvxuBHMp9rYPk0fxYnQcCPRehwz9OTzuJTuPycvr3dDsUE4 +mPvOEZWPs+zW9zzHbTw12jT49ZYJsMJeZef0/PuK/e7dP/oCPBtnWsJp6S5+Ep9ssNUy85a76l0f +tmun3O1nvXPGft+EOu/bt9kwU/jarF+d9FL9/btR5zA0/H7lvwOTzJA727g9Owxu06EyF3h/PDoK +zz+3HpnRUycl7n2U25m+rtduNuKRl8wG9fF9E9mngxmilDvJEaX31jFR5nauJpO3ZGgyFW6Pplsv +XHPKNh8v5EzLeuQgEbuN09XkppT29pWYTJ9GsNhccgvnVht5iCa/dO+h+prMti7H0KCWS0DCepLz +NzKwm81Uj82QhZABpjvbgetCb29YzhVlNIYawc7F1s1DPb09nCRKOxTzMd/qtzfaMJP0WEoO3ZhH +x8wZjFc7HaKcxI1sqV4PENudNrL3L0ZalX2s2z5gahd5VdKc4m9VTQ2wNTM8pLlAfu4LFB5KnTtU +QDP/XL66487y7c1MYrZ/nElM23ul5FbvoniboV8A2obpcv/m7ilb4TaaAM7NtwQWl88MkZEeD1MZ +718ye9WNCZpVdjCClJw9ub19jRRv7irwF5jwRT8Ok3aj2KxPs/cTZDkRiVkIRiO8zjAnTrDxoPSL +DCHfMcAIPwR/8rso6xcwnKMx+PMgijjMVhBIsccJeJCPSx+WEqUidSoAsBUiUogG5qVQ5eiIjAY/ +B8VW7ztJJNJ8GA0UDu6Z3M2Te/luI0GCFwcR1YvGdv7AF5Be5WPKKyr3cH0ovThKKC/o7b2PrPTi +nJRfvIhoKx/sKs+UnqHcL+ejqlewbxFOGex6gIldMNOnCJxzmHqefgEGWL4i0U04ZOXwigbTvdxV +Tbf5EYGYvQQoPxj1yNY2n5LPxQArhOSVI1uxAxI2SsC8pQHZOjyCaLskxW8urxFYmNS6vwV7jsDc +YiSWtqlwjIHafz2mdEqFDzN7uJc9eOB9levHP3azF633auHkaKOmkKR8LJDXGq4BrcGZo8KV0r4Z +PEDJi0K8rB7IEHPs7GK7U35+ED6ytfl2t/jQviDgrEhEvZiS36jn+UtGXI37F1oirzqjmnrhkG9J +++A2hhBIFS7zUALeJiSyvwWwm8+wNtstKaq77K2oXYzgb1r+xWAQxb0BB/58ECG+tkpwSR4S0tcP +hPyLVI3mjXrpSqN5oNELX0B8Vehti/ug98XiuWglrfbMdEfDZmQuYMFmgKyEjEbHZlLP56NQ8TZ3 +epwL9ycwp5+r5IpEvG5kM/oqvUFEbYALCOhG17B8Lga4pbjj73oRTJK5u5cpmNVmPNHdvNiht5OD +GUGE4lNxuoC5oLhp5J4EfzJhlBVMFp8y8M8U2EjbX2nIN6Kq1X8C39xAmqjEkRoEI1XiyHAnyy9x +aJhXEhYumAohE+SOyp2SZk9CMFT0m4wSwzdfQFqok12876L5QFN+Ju5foMPB7XwCFp6/qeTfetm2 +hglVCYJtnsCFOFHRAVnOfUON4+McYewMdHA/QpwYTv0pK6olgPXgZ5i5QoaDJY2tHFKcs6aR9tIy +hrRn8NUpVHMyQIALc6zX7LCjkkq5Q88289lN8NnVDDa+0dx9IGlKYTWIaLeoAxHJbx8WZQFdoULJ +e1pR2dCzzc30YZloB4aFyeRgtKtWIYB+gO5VKAUUEERnk03oQNzdXWRlEN2QZquU+xCpIbx+xae9 +GL2z90gCHBeikHIkuxI9hTQWx0+fp69wiz9NJTbzOtNgfisoljmmPi5lTelZUZJQgWmoam7CF/cI +dyo9OagoLbuZ292GpJscUJJagu9nAOJvkynriy3DQrjSusw3YKcbeAWY6eMOlGKl1w3pjozkljie +/vWZWnm/jw5FjOXC0OmBL4WoPMc3v64BniIl0Gk8hja48bYI6IUDIytHRCQUpjUZCU9qJMwfz2Uk +6G7siKhQ8Dihm6q7O2QU+ALh/EP7RUICGI8aCfzEEgkSCna3VSg4zH+PVCg4DBUmCAWAksVupfrf +aEmckQCYUC+BO6X5856IAmpOmtEBvlXjXouEhELYdxujRBEjYZK7f1SQEGpuXz1Z0IF4Ha1ctRzw +MTNSsgUR8U6L2shh6RxAGYXnMcTMAKB1cQ0ivuCWUuKTw8SSqxG1pmnE+aVR2NB0NGoBwhUeEOeP +xl1Mg85chkIiiMbhuXYMpP0YsF1py5+ilASC21JWY7pZPslr2iV2lXawVPqFRZ13sDihZWksvDyN +JRYcg4rGyGVpLLw8je1agnABANNYzAWZakDop+GASpHGbDFBLEkRiYgv4AITtiDccD5fwBaEFSpd +rQYEEFd7exYiqoRrwkZy3xQEsew0VDvDF1hsGpSnMaC9rx8F7bw/K8zBaT6CxzBJs5pLv94ovQxQ +JLJbTFBR72PQcUtqWaKi4mYU4YlbUm6UGzM5pHBLatktTpHaPykdH6No0VgItevAIM1MsUcGWWWK +pp8u34awFaHYdMWX1L5o9p13hqJte9eLUa+VdpRINL5jyBqGd0RMP2Pw6ziyQejD601k+wWl48St +IAr6QaYw9q7JpjD2rQUPrr7Bn5kY/vN52kGGYpDe3t9/K72GH1H9l5fMh2yuhmSv3zPRDoVSkn2a +2lU51lQzSGeiKrda8LCall6U4soLdN+F7IIBxq7K43Z4M85JnrIUmkZY3XM5E1G51VQ9l0uKQ+8F +1YRGXrhqQvQqlM8J6B6I4MwUYDxT2JJrvgQa0nQvI9hx1hyTkOwvY7J6vU0F0yGY1HgZF31rXB5S +ziWBq8tNyFblHD0QwbYeHknRJ3pfiiROaz3ID+rY/KfCXKotdVqP416I8LZAUP1aoBhNhl8ye8TN +tmJ4IxqTTG/sffr/a7v2trSVJv4J8h1Crco12dwg8Va5iNCiUhEVtCKRFC0KGuDt6T/ns78zu5tk +QbRUex6f2t1NdrJz2dnd30ziszyt8PR+oi5BcRE96UWKRKCoqSvjrVRz08/uNM3DfO5bL86huHYj +xu23daGH2riOzEtPTHuDCCE5S4uIW2UbXcWZwsG2dlVjMFDp5sjipfumzkvTiysaBtT3Et0OL+l9 +CwlYlADYWKe9ixTbCn4XZaR37muE9e5Mjznt68T5bQis6SLittn7EV4ww1nghry0aQ== + + + aEk4ia8xjIBZ23YrzoCuvcs8nfHJANdrPPJbYGKnOHJuxiPkPAS71ymmhFnHbHdRSVDLw3QWXBkq +qRD8gYm9G/tGBYzx0TT9fB/MsK2qenc+URhUdZfeSFHvZHzc3Pu86K0daRUm3+EXZrXhL7zU5Gfk +OaCdIvlzGDtFnHaK1MPEwcO4g8L9h2FZS1/lPCpPyssXEuFeczMejfOAyhacmc3UpO034zbFvXDi +cghtv2+ixA4VHr4DS/13R7K1nCXbOsnJ6vH03vOP/Lv+3VBOS5uSmq9qWnPYG5V9zzvx/pmURjfT +B284kTdkNd8oVqu2VfJuRj1Ppjko1nVOwBgYtMbTa8RI5EzeDUOhS9+d/UFl5Xi7W/pOWjtCVg49 +4q8/njzF0rc/YHcSS90oq7F0p3cRS+vlRixeGaex2mIwRMjZ83jYNRhJNrlS8vzCdC91UDubA9Dp +aulcn+xvS6t7ZwXveFcd97fUSr79pdQunzZ21QkZUaRiHhxknIbBygWxTd/XJ2uxxNahGcuo66cY +4ywBLx9LthpLJ3Z3sfVzLPX1wyHyd4gXPsUyeaMXSx+cV2LJpxUf7d/mCFJ5iolyeopDw1H8ptzp +BHOwPqITQ2JTSEv3+4jsnj5xH4sgMfYOQWKVVjETLc5LP7wkn0VgPeIsotWNOM7GSob7DvywByfx +vbkxCRDnqrBSkUp34gRL2PIRqCj+JK3+dxGoKP7EUO/lI1BYha1FDKr13Yh2h6Ps9TLdMiTBsXkF +amgYhbdpNlXNhvl/BKqtH6m41qbhAU8fodqkZJNMOWr9wgjXw5QQi+qtKbAgtWrROn4dPIUaexsk +VlK7W2sb/eF6s7y1Z/6Yg0ExH+GrmFwVZFiFuQAOjHBYjCguosfebViaYvAdY0ox8dn+6tj75d11 +76RU7W3H+GxqnWthmEmfid8k7jsrwaLZNUPWu6J5uUfUn6a5y3WbKjd795xobq2agBJsN9i64l7p +O05VB125Xcx14OWeSUlw1Q6OKcUMTYCC6nmwTRpckKB0FVmbK27lBj1DuHAVMzrAC13drw+eVikv +s/kYRTGHCqxWdDOhF/i9m0FvCY4GvckWT6vYGXxivib99Hi02M2EfozO896ausZhfLYcHww5u0de +Mthnr283kjy8Da6JbrvRnAnfdp/tddlaC84FV6BKnC3M3niA561KkrsU7YOqlzIXKRreDpf1DH8H +mMa4MUXmnO+/9r8k+DtoVlldnCYI/icwSMwzDZJNwTOYcQyFKXN7dBZTj89t0NnSzM4C4GvCQJMi +Rtcfi6T0eWtEnnsdWF94mGk7SSNsLBaVonpjp579K4p1H2b4Sv24oS4dk2S0n73ZEX77g6kxsidM +/fC31R/REXFRYAe/Fv01COz4qbnYkO9vfWqI2AepXqaVWRK3O81Oci8MYjXngljYtiKGsNr657kQ +FtnbOmIEWMTr63MS0xkSlbWKOFXMxnqwXmPcNH2o42dF0Z4qKSwpYZtK2+i3C3fAatONJ9xf+szN +wOLYntu0vv1YHH+gOY4oEx61ivFIzubDcRg+ar0SPsKZ8/vwEY8QL4qdsG+rLhk7WRA5ETBMafVN +EAf9qCETwZUoAhrR4yJoRyIAXnA8ohBwo/8bIXS3DiMRGBf3mh2JAPfZylwYMfr2+jJCWAbpfx2P +pn8U+fUY2qthRPxDcYEUL+cMaclIJP5dqnfYYvDWwUujWG4MHf91Akwvr5Jwx++bUvu303BWvlEb +9cvHJWwavKVAYs6m650XpsWyoqx748hbvikwu1MfxX4/hlaQfbh4FH6QuWC2HiISpHLQupkJg1+G +9tsSFE/K3yrHczZGP2PwHhtrDN9tY97knWO4j73bxk6H77ax1uiPXO9zAq4f2tgrJtJ+jY3bpUX5 +oo0Npu/TRqsjTFcmsUWSeJWE+2eeD1exeRKe/z5ttG7HcybFJba8UbUGbzDsme8x7bSG03ey4ccW +zQw4vyzPxvTDG8cQ7pPbKyu/m5/6+DIiEVs/vW2IY3Ddl9cAYUV+TRKu9/SeMaC3dG/faVTuYPxe +b+kOJ791da+uQ+7TVNgnv2mKu9OYWL1Z+TBTXVuhRwWGFGM64qcUohPZOYSEeJNdm24wozOdcOzr +fny4ZEf59e2WFWRhduiRMRNkvV6O2bkyTFpFqJqX4gzNg6NwcvYoTE/GaV4tKvTcrITd1BBgv4zg +YJQYHGwFxO3vRaCi+BN9yn8UgYriT9JsBAphsP2mTlExEeipF1MUOONAT72aCQ6p0yQ/BdZrCsPW +8FvnUD0muPvX4FcP9aLWzxlZ49PJUOGp3R+VRBCLqlJdpkSksHWk0KcYBduwN72rxPfibbZ8VLi3 +V2wBumYwLRy8+Xvmz0II0em9daz+EcVF9KRZik0SUcw2tzeK+eba5nXxNvflMX+SH54xKK5wkbzi +gaab8zBj+sSI3l0QtevW0gIG2+UApHvM3m3AN9wTrNT9cMoAuAga0gtto4KxkRYNtNASV6zbtxi2 +xhDaQVNhOY5amPWcCcNCGRGXHXR1AVgTEOFB3wzwo7bFeTknK/RoFsFq7G3DhQnWqb+XXk1RhcUJ +1n8xvVpafTHB+i+mV7NY1MIE69Rb0qvH/+5Im2BSVU3r7A17YoxJWl2FloY3mT7iDVan4PXvhrXu +L8+XNJn9EPjRZEfWLUvWiE7rFv6quVLc9UcDb5iQa0NptaPm/Unp7mZyNxp2/V/yBjRpsloYje7l +eL7aKJ/Je/88jvyJTB8gn4zkYqORwLDWq/ed3o3v3Htv5n71/KDWrJbkDTkcwiZ21kgHBgFX2G3A +dkcich7+nf+UCOcGKr+g8hkKP6Dpp2zKB/LFNyL38L5jKUPDdVpWfpBsndhYqknxw4SclJJTuOVI +IoqdJQRugoLpZB0HCjnbsUw7ekRXgn62QojuGEAJKpqumFpO1hzFytkaktVNvI6lohSVa5Juw530 +wYYedINSQK0oCZUaVgzFsjViybwjgWvEyeWCB5CIPuhNCkYQ3oYP4hSEQRdFDmrSdzCJkqTlFNvI +OiJn2OLYsqlYjgWPJPC/DdyCaMycEfIIN1mOKTDKG4DbnGISYoY9DKJolqMHBLGaJTPcz7XUpKCL +pgEpEx4akDShPRsNAqpZUxMGwRtgEMGweY+Aq4DiPN/FZ5JACSWbIKT8IxhJCYyEZIlmg8gVw7Bs +ncubGDMFR7dMaj6mg9pRbIvAU8F6gCVLIznZBhEHZRPGohk5ZA9EB3pTTMfUzEjGrHqD3JiapoUt +MFZKPyAQ1G24NygDp5YDxhP2BfmTrC3IjlZvpPDpvCUYXUAgGvkNiIRQeSw1YXRd0WywOVPJag6M ++kHSNSVn6Q60aA7Vq6YQy8zRugXyg7FmdQs76AYYb1Gaa6B61RwwKgs66miOWDdMqOdMG2cMdgBu +s4qWs3NaQEJoARqWkoXBIoO6qevYAhc1w8CWbBbmcVaxNZPekM0RB/Wjm2BWtANMz6I030KtPptD +/kEkGgyZ1qEv1DUC84L2gMc78GyYKAENoaX2TGCLWr4v9sxxVIAFFp6Q1cbEvxv25XihkL+BheF4 +NOnirYIPDR4dyOSBDR+Uj3LMkZwc1bmcOcPBQCIRCIPlYgu1C+RR8mGdy11Q71xLLVA4ysSyeINO +YLKFckSF44QO5MzVGygzUrigXm5mVJ+GLVMztO1Q3ShkIyuSmGupPZPYopaXVKMrhgUyMpdSTa3A +lm5YyOl6mcnAql7v9r0Tv3t3Dwt5f9z9nyd3h0Ps6z3CFbnve+PJyPfk8e3oJ7ZAl+B22BIclaX/ +A58C56U= + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/originals/SVG_Right_overlays/Download_right.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/originals/SVG_Right_overlays/Download_right.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,1626 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + + + + + + + + eJzsvWlzHcmRIPgL8j9gP8hMsl2iM+PM0I6t2bvQox3qMJXUrba2sTKqil3iDEHWsljSan/9+h0e ++R5IkHx9aYA0AqAjnqeHR4SHX+Hxk//tN18923379o8vn8Xb+Wb6yU8O716+eP/23c9vCHrzi9ev +f/zh/TsE/fS3P7tZ0u0MjXa/WL+Whv/w8t0Pr96++Tn9if54h5/+6Vcv/vjy5ZsXN7sfXr+4/9nN +T38Gf/ndq/evX8Lfjm//8ub12xfffv3u1Xd/en/7w5+/+5m+GVAdX7yHRsvyd3P4uzAv883cfp4a +Nnjx5s8vfvjh1f+Hfy5xjQDbv/3xzbev3ny3f/v/IvBmvokBfsJf/uur37784eE/H99+8+P9yzfv +f/Pu7Tcvf/jh8Pb123c//Pzm8NcXb25++eI7+MuLm396+fr127/c7F+/+OZ/TtDp/PXdq9cvoX/3 +L97fLNTb3S+W8PX+x1evv/3Vj/d/fAk9j6UiOH5NKH//A+ACtPg7guvXv7gHyFcv378HsuCFyLHD +L//pvx2AzW/vqR0Ab+bb5WaBnz/9ze5Xv/v1r07wunZzQDb97/RX+N98m/LQIizZNwkFMeAP12Ro +EeHzt23AESs3+O3f7z1niCRs+M+/ffndK5oQMFL//WfS03dvv79/8e5//sDNgMUx8F9+9/L++9cw +nsL/23yzZPymv0kr4Cq1eBbXevMslAh/jq3chGZt+ni9/POrl3/5+c2v3r55yYOye/f+K54UKc0z +f+e//PbH1y/f/f7Nq/dAWUFQ41H55dtvX76G9vb5u9cvvvtBO7n079zgdy/efffyPUynt69/fE+T +fdU3wKg/f/HXlzh1Fn7Br79/+eZ3b/+BaHxW420pJd+URX4Ch8t6UyKM7kqviA0Y0eTN/FYaeUaP +yBCVvgOm1k9+A/Pn17ByXr35uVBYv/77d6++7XOqhpuVv1Enblf3r+k/phY6/v79yzdCPczlwy/d +3Jxvf/kVvPH05tvD23vk/g+45GAGvIHJ8frtd/w3+53+Ah//8Xumnv7/NQzUb969eoM4p1/RX9av +f/P6R/jT3797++P3v3jzL2+nn7K0+d27F99As5tf//F/vPzmPUgNAfTfvvrx1fuXty9eff+zDyL6 +zesXb168uyE4fJiBz1/9Gf7yAki54Y/BXzrs40iPL/8Fln7/LENPb/788vXb7192uEFevPn25h9f +vPv+46hhGN45DPRf/fmI3r54/yeQUi/ffPuDkcX/HTvKsI/j++obnBTvbvbvfvzhTze/e/v2taEd +/2TYBUxQbP8f4x2/oQ+8+fUbZtD5m6TB9k0gEP7DvQVaP/wG+ON/ZOyHF69fv/ru3Yvv//Tqm0sv +uPB3exP/7VMm1l/v//j29asf7vt8cpDfvHj3/tU3r19+9dcf3r+8/xA25Ma/vHrzLUxEEjqd2rf3 +36NacfPVn158/5Jwvv/THbX8yhDmr0EwetH37NkHZGKIN/s37u9//+7Ft69A3IKutH/948ub38J/ +X7y+UfDPpstgEPeA6Nvpn6f/Ms34tcxxTnOeKzzr3ObdvJ+P82m+WxbQFuKSlryUpS5t2S375bAc +l1OYwxJCSKGECs8aWtiFfThM4RhO4S7OcYkhxphjiRV0sBZ3cR8P8BzjKd6lOS0pwpPhKammlnZp +nw7pmE7pLgMteckhx5ymnHOBp+Y1t7zL+3zIp3xX5rIU0AAKfBr+XKb/SzvTvxb7t1z8H2qNwb5H ++QekETvinCfiCv7T70X+JfmtAMcK8Ey/r8Q//Nfcbzv4t4fvu4l+HIi9B/iHTObvwGxgNxIHX9AZ +UN3gKy79l/8y3d3dne6Od4e7/d3ursGz3tW7cpfv0l28C3fL3Xy6O51Ox9PhtD/tTu20nuqpnPIp +neIpnBZ4F3z8eDoej4fj/ribju24HuuxHPMxHeMxHBcg6+5wOhwPh8P+sDu0w3qoh3LIhwRDFw4L +kH63P+2P+8N+v9/t237d133Z533ax32Y9gv072532h13h91+t9u13bqru7LLu7SLu7BbgBV3NFZ3 +d9Qd7NCROoXdwo7trHPYvUpdxE5iNxN1FTuL3YUO44NITqeJeo59P1D/kQPIg0Z8QE4gL5AbmTiC +PEGuIF/wmY07yB/4moBJyCZgFDyNeLUSv5BjyDPkWuqdOf86PfI5bp/pHCQ8esyzP3+mC8Dd+QOd +STc/+Xr/DvpU8KvSs8LT5IHBLHt6YF4AH5Cpd5VERwURAcIg0pMqLFn4MH+ttU21wbOr+wpTCpkI +I3K30opZF3hAhqwgKNa0wkpf6Z1rXfGrrTCLVphq64GG4IRTo80TLC0QSS202FID4QDk1QatW2s7 +emB+NpjDOHY0EWBWwSIEIQYzMcB8jDArE8xN7BRQRkOJ64/WYaBnIRHITwJRGEEUZvoNvycQi5me +Qg9yoGBnSFg2+Lmb6Jc9vhS+7+X7gR5Yb/D9hNIUZ3MgOUTvigG/QIKChMUHZCFIWRB4YZ1I2DYS +uLsAixIk7hG+n+A7LQyQvSh9F5C+iAHFLAhSGBO0hStJ4xX63kAek0R+QNogt3j5EP+Qj8hP5Gsj +LuN4FuJ7ghGIQBF2dcbBgSE6wmAdYMh22BQGsU40ohnGN9JYLyAv73BVwkw4wKzAEWgwUSpMmgzT +JwGpARg6w/LHSXaE6baHkWqApqKVNIHcT7ADBOD8DPLhBCvyAPvDDkhacfLBrpFhf4nAvAVE9h0s ++iNsMXsY9JZWeEOBzScBfwKM5BxZLuGapifaE+Sh8TrO/MhiE3lzIGFx4K89PTt62oSMOxAzDjTz +cdmAQM0kVBMJVhStgcQrPjMJ2TsStChqjyRuUeDi124iudtI9qL0rbwaQQajFE4kiUEWw0MzbT+T +SEahjGL5SKIZhTOKZxTQjSXYBWlw4WmPfabhv+snPfXSM10El0c++fzpsu6fbdrffOAXfgL8Kzd5 +vq0tVrCaAQGYvl9/PoL9D/D2NIP4DNi0pFbjRSwlwERGk3yFpU1t2jrDqlOM9Ta2Jd7EfNty7nRd +HzVRDEtrQUfZbQAVbE0X0YZUZ/RZ3BZQEhM5kUBfgsaCdrlFdesGVLFO7pXxAq37oynaqgFfVqHv +Xnz78ub925t//BOq8dPm/zBUgZVmpCSDCKJfYgUV9Vx8AkktLLmOvyCV46RDPDeK52Jn+ePjL4jH +JtLIv+uhpGH+QnQzoKv55nr0GcJPGdi/f/fy5RtvFW0AhFXsIROiyYTovBGhKj5NgDodN5FWEUjH +mEnXlQ304LbOvm3CxknSF7Zo3Kxn2L5xG9/Dxt5gv8+kByygG6CesIPtFdWNCPrJHexAaEqgJRLm +s6+tJXTegGR+l6BZFGywzO6CqNcBLZJByUbr4mR69n6wMkCznkSlXgZT40hbI31nI62JvZTFrkJT +K4ohps8nfD2ur2Q9ov3IFuQBdAU0BO7EkmRb0qxJ0XxX0Xg32i7qu5NTdhMpu4WU3RVVXdRz6a1O +O2XdtJFWeiB9lHXRQFpoJg10hRmyg3l1gHl2B7NugfkXYSZmIKDCZt9w79+DKnAE3t+BorCA0hBB +hchAXQUFg/dyUwAXUgDRDMevZKogdZXVdFIG0TxvZKLvyEwXxZCMdXgmHNZIhlei8Uqk+rJmiji9 +2eA6spNlggvmSIvnjro1S9cCvYkXW+a5sZKlfCTPQyS1eiWN+QjTMZAeXMXToG4G7B0bYTQt+Qum +Kk9bmsCLTGdSjsmGpHGnBzWLC66D/sXzkR0EkXqfzfIHaunDpJOyVlrQV0FqKSumC7Yk5ZTVU1RQ +WUUFJZU+/EFbuYuOLjgS69o81DvS5PFZRbuvMrw40Dzk/IUTgScF9MOPmLCRGCmWwiqTYT/4a3DE +k3lsQJEnr83ot4Exm8hxE6FdJi2cV15fdeOa6+uNrUy2LwfbciLTMthq64Ylr7bd1qoUu5KtSrYp +1arEj6wTGZVqVh7IrCQnAZqV9LBdGYizyazLQqu4ipWJq5ktzf10ZmrqwybnLGYnG55serLxyQao +f4gDk/z44NT8zK+/VYSL/VzMsbfw3jKRXy+Kf4/ko9t++m/FtqVKW1SRhV7d/8m1N7HfgsaH1kSR +1bB3KwGXQXauS9t0nPOyyDbDkx6mPEx3mPO8tSTZUppN7xNN62BTml0kOJPR1j7KDNa5K/vORBN2 +ZzP0JHOSN59sm89ONp8jSes7sh6DSGjegipM8x2aoHuySGkbgo1oIes1kjVbyMZdyerdkSGMXyc0 +lslwXsiUxm0lkxsN1+w6HVfysO1FVziCKL9DlxzpEoEedNkh+0gqkDuP1yxtLKSM7NUYPx15Mzh6 +1waY9ntz5KkLL4l5v4hBfxIjnp2f6v4sYqtHsdHZCXqazDDfiT1exRuaR/VxozruRNizuO+KY5hY +6qPeSL6Xo0j/0etSNl6X0e9yIhfZgdxlu8ncLytMFPa/ZJo60bwwC85ksqbZF3OkqbYXj8yO5N1K +fpkKNg+pOdkcNJGcNIEcNYusEt5ZT+K0OZLjhh/xVJSdPW1iqcr6qDlznS93P/hy1ZPbfbnqye2+ +3Fl9udPxZO5c9eV2b24zb27352bn+Rk8PuztmZyz54Kr54Kf59zTM/h6JnT2DO4e7/BxTh96mvP7 +qO9HvT886/Jov0RzBQXnEFrUpjG7Rp/T8BCnJvmB4/OJQQELCzwUFZi2gQFRd7YKj6k8NMlP4lxk +16LObPIrTjSpF5vOR5vITScwzdyorkVxLh7NuajuxcqK3OQ0uXM9bieuxpVcjehsZHcjOhzJ5UhO +R3Y7HmkG7CfyPrL/ET2Q6IMspFIl8kRG8kYGUrbYNEK1myc4z0ueRDq4O9YAB8e9CYV5EAoHFQqO +b9V8sulMHhj7JhECKgb8+te1Pw9uWs9LcdZ6Rk4X+Oi5mMRpG8i17nm4F+dtG5iXpu7FNY4xr/am +IK+iGmdTiVkhRpv7brNPHGSnWIdd4vHBsU1obKJFMH8sNCbu9j77u8Lf5/6BxboOnrrT1Zk+znee +7SKbaXxwbHYkclcblVDCJC70PiLNjQaPBTvQTzQKOoVt8o4MJH18zwqLRXmWTXynmuoyKuF3ooCr +8g2kTKJ3q8bdFRmvyoRNPGd1ZqgzQXEgJrM/Vbdh7WYl+bojmXsgOXwSS3s2JYft7WyKDqo6u8l0 +HdwbcI9QbafrO4k2GNN5ROVB6QrvYQHLShM/e1OeDoL2aNGGO1On9CX6omBRC4xNyjv1vfruKqHM +VTZCpmInGyQrYaqIHWUTPfGOeid6mepmXT8Lsg0nebI8xWlsXWtb2Tya6MduUOKcGmdP/7KgKRv4 +rIFH0cGraeGHjR6eBk18r6ao08Rz18UnUcaPEttUbTybPr6z6X33oEa+lylNocqNSj64gi45g0Z3 +kGrk6hKKk/MKrTJldcKyY2gxjTw7nVwn1sFvGBKydNkdkt+xSPyxUIbHaiHHI3tfBg== + + + x0EixwG5DibJ9tjTRDyJ30j9B92DwKOlPoQjjVjP/ljMjeByQKp48fbmT/AehWBevGzDuQ5Ra/Yr +HCd140nQepGNTL156mPwXoYm8eudk24i3+rd5ALZGszurocxpK3PKsFt9UTs1n1/plV0SVmpumyG +QJk4K7rLYjHHRX/EPTTRt0FMUwZPBNleiFzK33FeNU3dUTfQnbj+2AmkS60vtDCZ26c8bp3BgBxt +JHAMvB8VfajC6HEL6RsIfg3rTLqfxFvTswHYPXOc3Ep7aLvYuxUn24V5KrPZwbLsJtksZKO4sFXo +ZuG3C7cO/Y6BIn0atg3dOJLbPArZK1sRvrNnP4rxSRzvbtydB38nHnzz4Ys9dcmJvx/s52opMHES +9UgtpdNgRndDuoo5pKZ0N6Y11C0Wz2QG9WhSa2j7PKy9CWmLca3mdZ4sMONCMx9Ib/AJDsVHa9Tk +ntjmHlRstby9or2T9a3qdhUpkM0QZ1NcTBfVwBcRJ7NFunX7PNpzsGc/PCyhdhN9I7Pax9THcHjP +qNKsKs2skrCPBX5c6GdyeVYH27N1D28u56pb69XUgOwysMR2n8x8Dy4ha1E9w6VAnZxFfzS7vtv2 +Yt9PshSaPas9nYPFnuyedCEBBGZ4cM/inrk/mzSs0/Acx2c6nH/tz57dA087f0h35DDIec6fZfw9 +kPD3QatmEg/Fxw38rXUz2jdm40/m19KlpmZOGrKIuidLTdatubqw3TO5LKK9eayqM1XjYKZ6k39v +5lC1+E2aLgRwOL/Ih3AkiGO5RuoA8C4AcQJMYsOeZG6RL0CsWbZn2SHAVq1atmxbZXMPpO4kmMaw +GyYTAA1g1/o4+lrCsnpAqmuiX2DrDHSqJ3AGBQf+Q7hFHWhMKLguWkoqqMsMDbDZnHKjdJPSGuUC +kGmOR45Snhu+JMPIBEwBWBi3pSi0eBtgJnRCr4pVclwCzExEEBrgQoyhzUse+r4stSCkKBMCdr3n ++dyUcBthnvgUl2uiJUqXFXAOCEIpgGIYtgx9RXY0Qk7nfBhbbLe4rd3EhAlAjtLroiVKv3w6pXJL +KUILMieFa87ULWpOgVlrHPOmlrCmgSuN/En4Sw050YjOyBZlRL2FN2Da0tJcJsx18X5KQszzV29e +0rEny4jZQnq20+aIAEbD+IDAwQ4I4PGAOhiQd3I8IFLIvvTjAWg4Tj1uv7EwTmJfxE1I7ZIx74Jq +Uz6JfbG1Lg5nJrzaFucmvPNPTZZ83LaW/OCa6naG903t21nG8XTR4lCbo+dKHLqt7zIlznIl0M+v +Lis1RdhxtZOAgXNemU3SrRK1TJJEJ8phRf2B3VcnCdKxw6qQhbETB5VMhSCTIWsWhEwIPjMyy6mR +fm5kJbvUeRd0gkyS4pzFxeBmiTtDkoZTJNushOC9P5PZpI9y/1w0TFeX80OegpN5CoLL9qlnuQcn +yz3o+ezqFLLpNG3dnW5WhU22wTabfchl16SCySWz54016+3Zk/MgBWfNbj2fx4kiuhHmBdqraKce +ydkYaELUY/vYVBgnw+wOEfXpoGnwR5kM8zQIjHEydG/T4hJVivqbbEoMk2J6wCc4TovtxNhvovQ9 +MSxPF/JURhGzbFJUhoSwrdNonaet3LGZ4kXP5clycbpMLivl7OzD4Cfvk2V0fDhPObo9MHKBcwRn +BwqVkwT7k0yO9reToNJzD8MD2V7VTnPROa7zGc7paueH5KK5UCVxjSaybn84fQ8T+dcWEmW477EM +u4NpGmmvw/ypI0zJBaYiJtA2dZ3BnIsw11aYX4d6gskUYRJVDBEd1hNQG2FuVJgOB5gACwx7oTyP +I0iCABKg0rieYHsINKI7TNVwS30FyX84nsAKDxOsnELpFgf0wt8tlEpXYEbu0HF1Z6e6/BG1zzmg +Nhir0zWPp6GZOn38eNqHku7MMLX483QxDqdHWnwczh9nOTvM0k+yTBeOsnziQRYKf3Lws8V1srhn +tIjniY4McZ7xSieLMkxSyjams0gnyjjeU87xSoea+NATHoiC5XRH5xYPlILc03kT5Vctml38NBWe +psLTVHiaCm4qOHfVWuaZfAugnZXWyCZvOUktErI/L51v+bSPyRmWTzuZ9SWnuj7xZMpXb//lPdcN +uvmHV9+9efmeDh5dgvYz+8qDSXkwKQ+mZZrpETY/vuUjBwTPyZT1FrTOdFPjLSi24ZNG5tLnaYge +89nbkpeQsDZOXPAD8WZdb2sM7dNIeBjN4ylp+fNm5vjJT5kov3/z5sX9y29vvhPQDaw4mCkXwTQd +xXezqb5w0Wa+6GJ5wGSezuzlamdk/GnwZZMzMWZNuLyJyUK6xaVOOJeLC+t2l0s1s/gsFWjrasln +uUBDeFfcLGQUP2zM+NoR5/UiovzTYhG9aETBGhLdeqhWDYKN5B15eA5kSvRyEFwMgv7BO+/kMDqe +h8F/YQKRG+wEup4953PneOq88rlzskN2JK77IfOTHTAPcsgcxPtEp8sLna3RPA/O9NiT/c1HyzG/ +B/YIOj6iZ4ryA0fHr7El+x15usaW7Hfk6Rpbst+Rp8/fkvvZpW3him3Zim3Rim3JClevYhoSnF25 +iiG1ebboX89p3g9Bew3bl8lF7l3sfoje92Pqu7MA/jaET7VCzg+nfySOz4nyrFOORSwunTU/PySe +N5HvHvuO0yb87ULgZ0FwzU8/XoyESyx8csHwHg4/D4j3kPgQFHdJ7TLe0xgWd4Hx08cC46PqBUu/ +rflDSg1sYksr88qxKZA3+AuGTtJFLelaCDnq1kB+JYrjrfNyGVmANU6nxIv+ImGoy0rj9VB+2Z4d +1ot7NoD9ns1jS3r03jaLnaR5UVKInEVS19Slo7ShH4KanG/rk07W+q9LeyP7fjkiRPEg2qiSKxXF +kSAtE9UkeRAdueT9mkg12UvkJ1A5qF4MChQSUkd6vGdHXjB2zdrxKaLMPJPRkq36ESSfZHWyvNll +SM7t6bmkn0wS9thZIpXmwd655FdNetWEV5/oup7amHX1SdWBLpX/2RQCmj6l/s9DRX9YlH6mGX7B +CqcNf/ryHV+qkrik84Ml/6+2k+peqrupmrhq5HLWfzE7N05s6pqxq+auGrxq8qrRq2avGr5k+m4K +h+Qyt+AlSU05cHxfLUTU+1HqYQrCAtpFuWxrfimm0dqFFbVmkrPLgmU7fFyZq3u4AhozgR6sKXEt +lF8mPuNF6RnHenZNffTDI4ed3O/+OQyPz+k6TuN/RT13z7jI7fhlHJJQLx37Hw/+j4bJncZ9Jzv/ +Xy4fT/CvJylzodLNmdLzCc80aknnD63TUbv+BOX6c71dPn39ab982i+f9sv/NPtlzCAh/NaRYYH7 +vC3aTrigE/yRU6Au7pdfion3yy/bdeMCoLVebRdXfH/re3m6vJmnOJpC+PWUevaUevaUevaUevaU +evaUevaUevaUevaUevaUZPKUb/Q0FZ6mwtNU+KzUM9xzPympa0GbuH1BVpggeGyGkR5GzLczHvv6 +jOQ3/egXGuntspHenJHuPHakIqt6TLqFGdbR1YzoRrVqwlwuQvRfM4tI61WD2uu6rOWOKUV3Q3kI +X4TFFUWcHl+J9z+vdsl5SkG+s5kE3zfO1Q9dA3Jezv+jNfqnB2rxPyYGcR5UAHnQ0zG2SRlnyRl8 +bcPHPK2fKKSnB3ytny2ip4dykc5FNGcEfag4R7Dsn5N0/APlOZgJ03DW/2iZPufFOeJQ5/LOUnt6 +Ys+qHCqW0/PBWpcPiF/gTFnKRTEquSEg6SqeeKW0kSWX9uEk3S9EOPpcS5kX9uOucXTo2knnREey +zU/6EY/rFyL8MlGeL/tbAYyXSz75W5/8rU/+1id/65O/9cnf+uRvffK3PvlbnzwrT062p6nwNBWe +psKX+Vvt1o11M4w6iDiEl25JePCQ0TTcijDehDmeNBpvwvTXuA1HjaaLZ42SK1u4uHKh/k4OrV6o +d3JIidDJVd/3U2UsYRh9CcNhxuicsRkzPThl+CAazxadKx+aKTJPJpkofZpw4t94DV2fH9vZMc4N +mBkTTgyaFTon+oygHFp20jVYzTgJgiQ/4hrGFZxhuBcYYi2d387OjZmHyfmX9pOs4fEylXyx2OtY +6HV3+UaVSZb5Q7cnnI/icG+Cu0WF67Lupocutd1ca6vjeumQ4SANpgfFAQ7zx8XBzpI8RR5MHxEI +XiR4oTCKBREMOAOmC4LBiQaZCiK6cc0HGvoTLWsceBxyujDhwn2LvqzoMM7TxWHui3S8OKeP8oO3 +ZEw21P7iHLdo3fXF29KjPN69+CiN+bSR/dsrMsZLMpbhtpH92VYAoz+54X/MfuB2BHcXhrsHY9pk ++V7YGYa9Ydwd3P7AEwEPTxzk1MWHpgKoDKgw7GAQCikKCykJBxj9FVZIAsVgBqXgAEJ7dfLjBNvH +jqZQgLecaPJUkBQBd/gjzJUV+BvpWo0DTIMKAx+BDLxCYwdDlGEkF7oxYwfjlYEhi51JaDAgGQZi +oSsx9hPdhpFhvS3AbF5nKEqRwQswFxmLbFUJiszUazyZg112Eu8mYx3f5zkwzfGsbQ4vnB9YkDMK +fwN2uboXup/pQw7HtPEvde/S4FqaHulo/ICbcfRLT593ocRF/zR5FqcPXCfxwGUSH75UdPrAraLj +JRLuXtEPXSs6ycUR4jIm/6B3Gld1G8uhjzs67BHomEem4x0rXfGxpws9Tqe7ia7l5Ks4M13BuaLv +HL3XeLuIuBeepsLTVHiaCk9TwU+Fzyof1ebbZW6fl0UjH/28MlJlvk2xlS9IG1IMn5g39Fnlsr40 +wFwu1zYo64fqEZ3HgTfXypBf/ANLa/rI2vKra3uHk19gFhmeXIjmckWiizeUbSJ4e1t5p0kDwy4c +M8aFz6PCY2WiTUx4smBev4lmtZiwHg4+fCxcswy/aXGjscwR/y/0/03ya7TvGjeJpJ4WrnkkCmuh +e3Q5nsK/rVIGqdC5XLpHd7epibStinSyukhSD4kqI2lVJP7eyyGlSaohVbpGZSe1kDQEydWQJC5N +F4NrPaQoFZGiFENCqwd1991EsZwd1UHak3HE4clZ6iAluinpqRLSFSohDfbpox0U4p64XEbpM26N +dXV0DlOvqGS5Vds7Y89vjJ3PCitZaaVpc1dsvynWl1cafJ+bEktjkaXddFZnaay0dNn/KZe7DuWW +xJE2OS+oq7m09ahdqsH0sTpMD9Viyr7YwJAF+KGaTK4q0+W6TDATpgvFmfpVRZfrM/UKTRdqNE1D +mSZfqOnSBUaLrxRx4RojeKYLJZv8bUYy9/4zFXACqTGvlaot1ZDWi8gWTr6bb0uQlLc1pzaHB3Lo +rofyy5SctVxUcgD86AszuOSD2iiXLBRKiHko8UbzEtT4uWQCDUbQQ4iKWVKMbpvQhagGe+qsOsPH +4nwfjfI9NmD40ZDhQ4g+Fns8QzUuM9jZ+EKZZQZlgK4LmudS27AqKFGI8kpl0vEVMw== + + + l+fx1TD+Ry9se7ZGwsX80xCHhfOx3MqLpT0fSq2EMZ4GLXrUo8eLHMeEym1KpSVUTsP9v8Wu4FuH +6imjPQzWMNfIOc//qpvE062BsTUxBiNj2mZ9OR55Xj06WXBy2YJl4M5OPAGcPZTGdEHqnEuW7OVe +x5TJo6VMPpQ0WeVC1B1GX3o23DYf7nLi5Gh4nbFkGlJy6257PTSmSS3U+SJdxknAnXOZzdsbUjWl +mW9HDZTSVemMy1HOt/DpFkxePlEVnlTKBN2VEy1gGkU6y9KATyfiTAJerHRu5Q46S2Y7dOoIHQlA +fQWa95Sxh+l6K9F5N1ESZwF2cQLn0hM4YSIfj3cg2yLIuQpM2YMExLuTw13ikfsk7f7jyv30Qe1+ +o9s/RrWfPpaNcDkZgTp33a5hzvHDXbtguny8e9PHky0udY9H7hMts491cPpUy+xj3Zsek0ty3r2N +ow/fiBskqCqtJKqnU1vgIjo5ULUf1UznAN2izXRzWd5YqPtaGPlCuxYXQgJqFcgJPMSRYXenvZ10 +rRty4nFJ0YTYsDHwd4n14s58LYRftl1f9OZtC5WOeu56pudGKm6G2uO5L36b+n2K82Re+EtVyx/0 +EbqiZ84/6PVer/v6GIKPI3hF2h9r6DowTN3JhRZcl4Zu+ax2H2fwsQaKN3gP3SJpyNGcaFUshzb7 +PHspQSh1wRepC54s9lEmUder1QDfu/T7k/N4BfqXjOLsaG60nPefrPJ/Smpfna6Z2OdNAE+jp9LT +6Sn1tHpq7/ypQn+u0FE90O0p97QT9Z1C5eJI44bKDZ37C2cB6erk86OAe8u4W81NZccAN1d0d5qB +6i88Jf3F1sV8G0EVYvuoFVgE+EtpeSzyVvC03EpSG617jGhQubLLwv5qGL9InMZwSZwC9Avv2Tw5 +uXN2qGpyQc0qlSN9QFPE6Zee9tqdHfBZUK956IDPEG59zPGiLQU+1Fs2582IgulMwCkNSgWfTbye +cLtQ6fGRwu3fM2f6Me/+5LdPl4Tk+fs3/kw0Hbk+OwwarVYw65axiqJe2Vz1LtwPrvvrofzM4C9e +epzDlwR/BcOXCZ6Lbpc4Vll8VKIvpfk+Ksv3UcmiD1htF9IDH5NweJY59xA6H5p7THICpSY8Kknl +PzI679NESZjIXZ4b3eSNHAzDoXnxm5//4m8warfrMlxrfnXMn7jw5g+dvf+UT3/RgksXIwTpQoBA +v3rl6WDJnZzmmZ2rvkgiKCeEVoqfr2oe9Ch6r28uocNN0fI7i53zVrrI3UILRdHV8x8nMnyiLLIi +y61YbJ1vG1oltq42BkfYD7RYeTfWWPtp0vAd95NfFoIUDeavKCfE+ckkiTgQzzcT8d1EvI+vk9gq +8l/6rtcWNbq4SC8w4g2fLbCDnDEev9PfJmtydD/7c7rw3JH3YwhU4rh5rSYOutxx0OXUND5a3e8o +XV6lD6wukbI0fcQs1ou8juR5fKB8gstFS5Oly2wT0SL5JDVNZltfJz5UX2eyBLR8scIOO6MvZJ89 +kHu2m8QVfydHkYMmn0nu2UFqlHdf+0eyz6YzGaoJaCpJVZaqNGV5yhJ1RybbgeTq0Y+x6q7Jzg+v +Flhrls5ytMSVZdCjs+WrtEkWk6myslZUydfkFL2la+e06pNkpfhj81nzrVZy3enE6UbAh/Ma1bei +Uwn+TReSsLYZjmMO1rYmh04syb2aKPWq5zbyvELX/4n834EmFE6nHU0lnkhBJhLfm3Ck+EWg6VMn +cd73k85Y7UJPOhc553xHUgl94nzM+Q794TDaDUb4qAXn/3ZOvP+rI1weeGgCT7K7qYtLHV3pbH8b +97VLG9pBL+UY97PF7WE+fs0LzG9eq5iMbDbu1Ai621wlMN4M4HNbxqyWMZtFClpNQwbLkLeyyVfx +N4iN6SlDWso05KOMt4WN6SdD2smQbjJkmUxjegmlNrHHaExwYkNO05w00SnKprj0dKdJMp7uJOHm +6PKe2M2kF8tx8hO7nMYUKD0GSolQ05ALpflQi84CGZmTy4s6ylv64VA5IPp0MPlv/2Dy1XJJLjsz +xlH+7HGeXD7nl480jPX0uIpyHxjrzWhPnxU7/MB4T4+OHn50xDeW7FrnBYNhrcFmEuhaDdgJ4kqu +HXHozJJDs2BE78GsnC/F9J8uG+dyYU+s62lWqvOU2C6vW3gvlFOcqrsze/NEVxvNthfzTmyJ2dMm +J1uysUlF0CzsRJaQXklb6TakVWy7nZlnYoRNlo0dSfMl3ZfmGqu+XEtsR0H6I1lOJ1LxZ7KfUAFG +FTjRDTkFi/JMlMSBuvCO5vdRqozxiQTsf5AnUdUeVIpRLUbFeKXVwuWlVD2me5Nn0pK50hTXmcIT +C5mO/nKhKV9q6sDVyKwe2SJnGDjNJk+UabMOeTacaYPL/jzPhjJtRsM0mqudx06N04XG7MMnqXKv +cjRdPEO1UmLM7lLAYXt6Ss54ROFkncxePSDrnGXhbYvDA2en9ODUcMd0oqya0Wo92t3SarYiKz9S +FpZzp6bh3JS3XPV2tuNwaipQZnehDJ3zJDEwXafBcl3lIq3L7j82Xj9+XdbjLs568Dqt6SN3al28 +Y+tDz/n9Wx+6d+sRt3FNF0rXPqaY7YPP9GC124899fIzPfSHB6rl0jNaJMpa7b3SpyjU6lBzY7HY +sZoZlgj/iVdLP3y5NNoK02Mul3789dKHPF24XvoKF0x/5hXTctjBFxC5my4Ul/DlJbYFJqjExJPt +8bdkezyQIZGBAxEDHQ1DZGNp35IqpR1kVSSx1G+qD6ii10P5n04nLRcjJwC9WGueFBre0HfmLrx8 +CFrygS9s5uqBPlKq+COPQOudmXXYzH3ON52CnpwjuruiaUOXLX1xt2Fm8UrL1m6eaT4cfUJhPrGv +i1M/e/XZ7pbXZGrNLWfujAdY95ZRfecPsnLdo0RrutDqbrTOd7TiD5vs8kiZyCgdCuUjb26vRXk7 +UTK1uGQlpZr9sgfJqu+srKQX7bgipXhq2VeL3to93yI6scP2f22XLG8mH6uw/+G7fs8v8L1w3O7D +lfcvHMXzz/SgXvnQ1/GBR3yJcoqPev8pZ1sfs+98Wor4I3ad6Xr503KwVWoG0bpf6XBFrywVLlQT +O7jSUlW6c15airo1kZGFPeM9lftnFaaoj9zLXmNse60sd1culp2wz5uKU/5uWe79UHdKeHCSqOvm +etmJA8EPbrxYcgnTn1uqa7u8S2Khf0xHSFz5/4N73RciHDfdBr2kTMMVT61IIgTv2E13brxZlZIm ++AqAj2gFX4rxizboeml/rl+awvh0f8DT/QFP9wc83R/wdH/A0/0Bn60Y/9sifLo/4On+gCen2FPR ++Kep8DQVnqbCv/59rY8vYjie8/6kj/2n85e3i2cK2+ZM4ckYvbciezvJrlw35aWL/Xap1DT9nIbs +zs/VsS5ogkGOPqPLgBwGUigJjQBWkzRHnhWkRlkgR9L0ST2a5IQjuwbQ0stSi4Oz4k/umHilJI29 +ZS5b3jJRZqprtCovvrqLevs183yWIL56/jULnd3/FY8Csl28o/jpQcL6JwntzxYL6NEADfQXSfv8 +eLD/I8H8j8Xtz2Pzj4nRb0LtLL8/U05fENMkpKcvr5m4Y9NjUyl/dGJmk38qAVUGHgb/ZTFBGKfB +fXk8S2NTmahScXuJAsnGB/yaMIPXTGeilqXloTBb4yOKdkco/IlAH3MdfjFKFpC5zOPdpfCB0IoX +cniSC0vEwS9YkyKUy+LySzF9mfC8WN+ijfUtrCCoChx2MdzpkRzna/J+pvFAxaZM9NbDdKlE9OiW +fKBENPoKJvMpbX2T5kka5caFUlHbirQczttdqEW7SHi0188qk5WH2jk/4hgrTe7UDkdMd5QFYlFT +kaIkPydKI8kU++NUqGbJUBI/HXv0RRLm0qHoCzLmERLmYTVw+rgeqPc97zeJ/2PJ0m3R0kuJOqdt +hv9YuHTd5PWnIWlnm7azKV86uRz+drhYwJRjVHualXqNUY9WbeNVrMY+fBmKxKwmDVoNN6L0O1FY +wd3GrS5FrljhlTpHKPe95GfdV6JXm0zjOC9DKAiUkjAeJdfoS9MilGkNIB4uSr7roOPiQ6igDbJ8 +rcsmXQQ6COL8xp1yDxi4emjDuB7KDwloAHz9q7dvfvPu1Zv3r9589+yZk9v+D9Ovvse/RP7Lb168 +f//y3RsQ6F/9Pz++ePfyh5vdm+9ev/wWZPkGcLMstynVVX7Gm1JuMaInPyN09UfsrtkCf/gr/ff/ +hl//BwD/cpNufnnzz/99vvmW4H/4LfzY4rx3MMF78xxgm3cNMP3s8wv4EPaGXvdrGgqwnEC/oBz0 +WonNaV5hx8HtsBbaFmeeF1jBVSpWRc4F+sMLfAG8FOu65lswNBPTKyD+Sa+kv7YLEPnY83NMCPoX ++BdWLGAJW+YKKkOt9AaFxXa7tDUMH78E088+v4BP30OfA05l6ChIUXqPwspyGxvYef7zl2D62ecX +8Ol7lCb9vOdYDbep1UUY1Oa5XQL5N2+x6VvoY6X4YVGQGwT+1AWIG4MNJn0Bdasm/ey9A3nOKhcu +wfxsGLHpS4gamCU6pvcOxh9pw8cvwfx82OIbuLUZE4X5AdDPX4L5Edji0/eAoAuwLeAyy3OF7Rpj +6BEEG8vqhPRi9SDJApCCayC9+RdacPPNb7n6SIDlyYXkahpLIHSxiko3K+SwL9LxkxVX880fdlzz ++OYvfqb2uXJp2C4tpgtrdoMNQX9kqV8zF6bt5JWwDFWSEpehRS8KkQm9ZHOBer6dX/cPjPywGjcw +T/yl+cqkwi6/UO27EDH8cZG3sh05iwakI9DPtA6zVKTJpdmj3LoE85Jji6/TWkHZj7Q/1oWnFrTL +hRjdMM6JAlsTNjKbOFRJA3fVQYS7pXxJmGKhq43MFZBbtRdk/x+vNPG3wtjP0wpDmIQtJkwvwPyC +vCTcrzr8tImC7OyDP4jaC2JQQfK552eYrjnsm/3AbxF+jC/J0Qvi+sLuwoSmBFbkWAst5bWN2qmW +wFyVq5L3xITiQDoK7h2M10U6l8QbmKd+i09p3WoVXtPwOEV1uQDyGC/pKPiW308nVjdBPxVl87P0 +1ZX/sn/34w9/Ujzmbgjzz6b5Zgf//vCX6Ud4Bi30sg5KGuizBLr5bb4BSZ2w8ucCXHgGKuF6i5F8 +B34+gkO5xYsJCawYLsH6x99MqIPiRJ4XGvuKx8JwkoJFtpLwrwXMBDoQibsXQqwA/6Lz2KFGwyIH +Ijg0mI5rTgiOt3OAzwBwzbdg+wkZEZY8wGq8rfNcHWnf4OcL0gMTkMDYcGnw4dZ8w79CQzC0ACeQ +3Rsuddvwz9hwzoAxJP9yWJ64M5eBSs9r6dFhGtrifgV4bwakyOwGavpAgI7ANyOlAM4FOjf0Stv+ +dex+b+tYpW2xY46rnQbH/07tdqAO079Mv5/azU9/dvOHf4TfaFLDKhim9MdmOkFvAA== + + + fBOGKf/oCb+C+nS7rqCZrGEuWJ6X5vw6rxHFRHPg5xtwuC01rwT2SB4AG5JrzXzCXgpIUMCeYCPI +iShfYHIRJCZQr7hZWpfEwAw76s1IGbRc14rTjMGRu4cowUxnIJrhDMQrRW8uvhwHFDkEbYrSkNKS +hJ/5Fp3VCIbfZtihEFh4UnLbGAsB6y0el2ZgW2AtHAgBzCT0CTA4h0XbxiQvy3O44YYL7tsEKzMQ +zp9vsCPOKxOw0ERd57bcAu8Dt12ZYTPM3gwNlDdpZQQ4qWMSYkMphWcEgIHaOnAH9mBY0KuwN9cQ +BRiXRYnF1FnGi+CoDIstS9sQZsGa5qIIwlqU56jcGoJcbYBzkLaw8UZFsCoQTH6lYE3y+XSLkThp +iiaDADsTYM4LcEG3ABMwz8EQwOoXLoLSVYUzOG9KE47DfwlFvk1hlhmWQmaOF6BAO1Zz1o4BGLvO +I9miImgpKzClrMCmhPWOwaKzmd9q4D6st2EpMo9A1DJSmBxBJwcILPl8g5ldhNaWhIcNFUN5f8WJ +L5+XyYXrYrXPY8aUTtlFP18afx5eFUIWYEPGM7CuCy/HmRa8IKhrxTmPwNR4ZDIs8rgKcE2lCq/X +UAwBzEgdgqWxFFvmBV4S5XUpCIoF1c+ovSVuIzDNWaiNsGAF74L7gqzmeZ073rLOQgWV3WMgZn4J +w0tlYLjFeL12uATBC+CUpG8LLF7BG6CjSegNua2CIuGYMIocqwBLjLrKQzS0ZXwbo4VVittUZxoD +o4lAktkCBFVbCGBpx2DYDITceVmLkNBmHeAlr0EQLKmPZNL+onTQgQDZwG1h2qfcdDJKbytI8ahd +yEUHAnb7VHSKhVqlbcUy7sxxFO4CXKuuseIQtKiCZo1MwAq9XaUpluwUIGju+qY2aw8ADF0W8Cqz +Zr0FxsUzBGgsCRCUF0NAJPLSWUn8IRDUnUXnQeBBaCxzOrcZQcNR1AHjTYSASZfuClvtjbUUCir8 +1xDEaBtOATADS65VGWtA8rcyBcYCgM7BFo4MeENuKrsWJWpNuumui86iZeapzlgbzyIAdjlJIpGB +pa3KbNyMFEEGurQtT+4F1niy3SaQnMKWYAoW4WssNDMW3ASDCj8Myx4Ugb4q0XZJoBx0slSDddmt +mxKCYyu6kiOLGAC2vl5Y9sGrgf1rczQxgoCeZl2cC6stCAy6XjBec/NP0hbtYN1pBC8suZBswq4C +A4Gs6w0lDb8rohamK67Y5zMyw+8+COw7aC1LNQRtjrrm8QQNAuFjIZgiQyoPAmOt8iowBuTzgCwq +AaBq87vg1xa2LMwwmGt0opARALLSdMGgoGcgqew8XHMpAkzzsH8pghJW6W1OTTRYfF3LgoIMXnkZ +2iiiYS2Gt5rGsujiQLyLTlnZ70HlMi3a1CMELjB/VD0y1haQO6poYoaytK1zMvkgrK0wpDrlgi1v +9EnEVSddKUna4gkdZQ1ryoggqCaGYXdBAJIz2a6WVtk9AAxyS8ElKwrVlVH4lyjAZvtMQF+H4m01 +yWKMWDsegaDmFp32WA5ZgCANV91Xg/J2xcpC2RHGwJqUNVkGDGTsvOr2tdTVPg+LWDlTi36+b+1L +CkpVjbaB9rFpKAV13QDzbwQIe7simBUY1mrAkg1Bn+LihmVwqkvt6hjD1rBEx0QGlqBDnnCzVrR5 +XvJmaKBtVdUAhjkJMMH2o8rUshqCsqicyKJbALDFRYAFFiQCAxYA150KEywYQcAz83NSBCzTAxly +RcniPSVgjE1VHtLjFUFKTVggai4C16jqXJUuhOU2JOX3ivomIwBwZh7Aagu8bgAIBot0N0cWEwiM +QV8Vdd0AGDPZhLC1cReC2ytEpUZgTirTwHaVUQBwqrrZ5JUlMLYVMy6bNojARVcC3lBlCEhR4e6i +41uAaAMzVuCRAEEsKwUgYA1Bi1nngeijIZpSjb6LnAUYWkrKWVVOABxXXXjEegFGXSFFFDzE2nSF +lKQKOIDhd0FAnUFgcsKa7BYGdpUHdggRPggW5QIoYP0uZHRALzy0SzRgrEGBQTmQ3YYpIRkGp6iS +g7YxBtakRkhjkYiwop+vwdAWMxm1R7BpqdRaWewFXNI6gaqpSwF1bVUCaC4wMLcm1M9FpjvudbqM +q8lNpMlkrBEPH1uKIhBVHIAhqya9ohGr1C+rSg2x+glB1t4nUW4IgU02U43Q1bXooNgcLLB8i84A +FQ/F9PPM2q0iWIMK5Ipq93MFR14caPqy0hdwW6ueCwycZcWUrokiFGVNX0cMzGDRyMQQGwOAFHFi +pKkshiCZgpvU64Vg2uYZXGUWVx7UcRiqk9IrCg3FS3yWVS+8wQ3Upja7GAhYk/VWtyoEo61OnSCB +i0Aw5VOfnHMVoK44mUmMYDWbCCe3iALYflJTGSmWFgCTrbhaVUULzdmQbV4VAV6eqS+rxPA4s8nS +ZSQhiHQpp1IQmdo4m6PI1hzCFp2Ja1AjFj/fdEspKGsYGGzhoUNNgBTTkkFQgY7gok6OdeE1BsCa +o5fdDCQPm2xUuvAiegia7oq4tAW4JB3FyHMWgVFbNqzarwhisW2V93WAqcsRRrZk7kGg2v5ul+DP +BxA7+nlVaAFBzbqj0BAxsOG+L29a7PN4WlG0ELETAJiCAtciVMEuI642RJqiIcAcMidlngsYLFDd +PXirjbCjxKgzNrIrNeIuob4B+gijRReg7ihN9ikAdt2GtFEGZjF2C4b6ZHlEdD2mMhKAqlOQyR3Y +UYVANdf9RongZt1tVRFU02GKGIsAxNw5nUS6TUUU1VHpQt+mYC0qTTCj1ChQ/RSFuaNgsUnPjgjE +OlfVNsQIR+CitOJJU0NQZ52z6vSIKN9NIIrcwS5U1VpzUY0rAuGrKlcxCbWF43gsPOvSBKieDNwH +VR1H8Bxt2WVFAFNKKRBHBADJUpZpEJUHIL6b7KosK54LOIneWdirwcCwqkusiqcegaZO09apeJMZ +Glk211h5oEVDZU0uVrqhxs05RoC+d9Ong4Y3YrXtyq281Xn2shgVAAxR1aBiNv552+cKttlM/mQG +xqbiU7zcCMyzRhUy2naKt2ueujEgDUWNiiquLnyVORxpS1YEISpzGsXrmALbr5qYZkSBLcjUP49H +Z0fNNaIVpnq2qr4A7C6l1QwQjBsv6lCoKyvqCIzJtjYZcwCuURWfbLtNc7ZhE7sbgCknbSuhoIi+ +71TPJiPsjWX161SwNnUHN1EEEGjaAQlQQ7DMbTNDJR4ucrkZWUGFdffLATg39WnreDVTyGGJiFMG +gHU23Q+tGv18sU2k1VUJKLYL094ob4qqkJvqHbu7joSeTE6AmppHcsbAfc81YlfT8x0Lu9uApqG+ +jEgcBGjCFJvgTTsGqmewsKuHECTMsUoiJdRuT7NzBjSckQxc21x0cqtOmigly6Z3a9yx1P2IfSYC +MCCfmDBeHgBLoYmeOQd1LBFYt1eaMopWg2wAZq0hLV5HE7sIgOqkQLtGiUUFYdaOsaiFli3rxkDC +kRuGYNaGqYMJI9Qqd9j/BCB113XTFoBqgojyrB9v5qAwvkZz0Rd2oDOQ0jY3mhCCRT8BZikFAAy6 +vhf0xiEwmU5fOL7ICNCDbdxu7BxMorQTMInTNmWLgqGpoBp1wpmugy2sxr6oM6QqA4UZIuRX5QBa +nrNtYaz5IrCoDZs44IXAsKgnwxYXQs2DZ2Pdm2KnWB1OuKbNfqmqjAI4hVXmOzCb+1pNnR6A3Vzu +OhOAyXYWxpasbUMQYJBxrRz54nG1GBg2tb2yicEIwFwX2ziaIq3NXDEmolNl7d7e9VygbmZwChuC +YQvOXTdozG8EqtWcZBXA1lWrYi22ugG8alMVnACMs0nThfdqBKbF7zKKIJemeGVPTauJkqKh4yU1 +x1gKDDMCDLOYcZvEtARoknCuWwiNksKUMzI5mvksNmhV94Y+iFGRZ5udxfzxmLdWzMuE+hkhyFiW +XdUrNfxzsBhcYWc0A11vcaUwAgCLVYOEhcg9yxF9bTpi4meCts1kRK4sIzIGBxfFWzU0hwiKGpdR +nE8ZTYWkAqkGBYJOqRqiegMASk5GUS1Yoc0YAUk6wSWuBMCKllfvgSJQNbWwg04QiFensDnIQNLq +RPCozYxg0bQdF5PF64ACtlUA1jug8XuEkrNa+N304zTKYweSuVvFI6YI+sqlDeu5gDU82RcpdtZ8 +RUU0faR1Udd/99zj65oGYyXLWF5XLDwnMg3xagxIosn48aKxlhUd/4eHP44pHaqGJQ61UMPZjNvU +qaJ4DveAtQ3qqskzMSJz4nxYBi7q1crZ9tSiXveMORY6NW26JTwwYp6M2Olv5lQsOjOyZeN0x17G +0JdS2jdFIqCaccviH9vOUVeXWFU5O1mQTIXJqKepfhtnQ6BTUCNF2G5ZdGlG3REe+jgeAZNXSYQ9 +Z4s/FT8CaEOokFalO+P+tS6OVgaGRcki1ykjKBb0LBa4QKyrCRJx4CECx8KlI1hq011RomUALHU2 +QaKfB2VFCehzoJgShIYre3cR2Fe3WEMAzFGV7mD7esbuqIBbxJ+Uq4WEyq18vHLeSJ+Y/HFydqrE +0PwPgCpNugTQ0tWNXmNnAIzOSdgMpeZYFM08Q2CTWZ0lJIigpIJlKTon1o6O/muutcIOfwaGpLOB +Rk1f3JrqHUXit+7F6uzKXg/oPpnh4zHqm0AgykioRwVpCjqbe+QAwUklPYqD5wLtWrpGPzKmZmTp +lRryCLR39aAMghfNaazi10JgUrao6FktKI8yXRMDMlrBaqesfbcEpSHp2JlMXnmflpFnvxi0hBmq +QLSZFG8rRfeFpnoTtKZEA+GibBeNEw0GvQfx2m63mKsewCBsdUnO7ELKGKC0/hYjjNIrpWeqoAC4 +SipfYbuKgWXpG14WmPoHiotWIFozAHJyHeuWifrk6V1xo+VlNC2LAZvQVWanpmnOAQDjqoMuoS1q +GGUgi/98KNqvKi55AKaoW4taVojUXLxJLZgyu0mnwTlE2lRJpMgJA7MJhT7BEYFNGfVPltmpz5JS +upSFY/Hc1VA6Bc5mLxrYh9ZzMeO2JJmhxafYqeqGmDFxjPc8pXfhDK2VPYm6vWDbqp7yIE4hPEdg +GXqR0xERmKJlHNgUR7yruh5aCYoAh1hGVyQ2AKuJLrPZSjCfkBux4FQc8rYyUP1qw5TprvLCaigD +S1aBUPKcBKjBMCAgqNmObW3IyCcpL8u6yptsegWz6NRq7W4SQmCSSlJPCqi/VYdX1zi0pAjBaoaF +IljjovvOYt0t3csriYBIVjLHg0V0sW1JGzcBtl3Uz6z+c3yVefUJyAiic6ZqQgsAe3p0ZbsTYYu6 +xVqfBQCeTXuLi/K7xWLuFLa88U1ZLWcUQfr5tNjnGwcvi89k1PBYQa3e9AaLVgBY038KR5cFmHQT +k7QTgqmY7bE8RLvoRktO+ecCzkUlNZ0kULCmxhb2cAkKiSEz/5PF1iTRnt+ULC0Xtw== + + + JcWIucu6gahdhRib2qGsohS0ilTzC5azCR9XnugOjq8PzWkt8u5Vtz/yWRpJQbVBTdFHisTxVTgX +UZA2M3TW1vsUzJlgYhtfVs1Jw/H3kjh8yStA880RrA6dYvmpRfI0xxWQ3FrpqSklc8eHXblkc8/L +bs/AUpWpxbxnCF76zsORqYJKl/FwVaRr0fELpiWXzOdTRhmfXfAkiUcL+yrLAqM7mi1HbdXlXcT1 +A21BzzcHagdagKEHRIrYbQwOazZ2afxH1GyErU0aOimEubKWBC75RSWbStyT2kq2XVrOTWgPVBHs +qV+IoKcwiPsPgUlTGJwUysw5BsdZx6vniWm2SilOg6KkBEaAk8ei96uIrMKpmrIdzjoyLZtdaClS +BYepKWGS+ItVDCw6aBMZ9PqsjO27WXXbNFlADHQ++yp7SXW7TveAAlgjkYWTzxgYFtvi1kURdJdY +NpcYIlh1HmpICttKjla3VxHYzJWDIkkR9GhulqQVpHZtW1FenRechLZRkNV3tRT9vHobe0oAAhcN +81Oolz+/chR79U6PUi1ttCejYktbCMGyIgp6ELPNQ9n4uuVgKYilWX6OxAr58+jU00kQJcJRZ16r +g1IFwFQ0U6L7oevs4tHaMEddBUv/dE2a7zLrVlrR9Wf5yOJwwM8XXYZqg2NLWy7RdPPqNUgSUHzu +a3E6VVxYwAEQqLZ8ZF7eACzNYtHqucOmtWqath3bwMaWCTSvirWnLmuAGoFF+0V+BkXbE6dmkdEA +XLMmvTZRybBl0uzvtanuUzF/W3N8iwQoKkZY9OwNJaUzUEPOkj7OCIKddRJqnwu4Z57RUWcERk5b +5LZsUwIsJVOhTRoiOOo5MvInPRdwn4fkODGwpSTLCSAErsly6CWbCYAwutq1pJO2YgKgsixaUh2A +l6wnk7J4NgGY7SSYSFQkd9FDG6seMCO0ljul6bg1OKeaptgCEPR4RTAvHYFKatz6a9ywsZ/FQFIl +KyHxaRVFoPkxuBmyREQKJCqE2d7CLsx40UN2ZBXr+GrCZVJXDRIgG1Bi57IAy2INW+uft9MkFLyQ +2ZGrEBAwV42BGndPzn9U8filZreTyiqTcdEUcvJ+6AzVc4p2Go/AWcHuZf3MmB5HwcUw63A7CvAM +lL5M8yoAqOfLEh+XEJkiQ2AnlaDhMpfkphYDYQSFpiLJ/SgjFj2L0TNWsa2dESSbVoBF1y1lcYqQ +krgatlxil4kh6nDLDoxyLtkxgNQFZdZzg8E8ZiR/U3BD+1zAQZJ5U5eJHqizG/aEJukAyetMzTbh +ZJKurJabPwBpi2RgV3kwMqZLkUzt57oHSi5r7OYnbqx6dkP9qABcTHBQaE4VGceHFEx1FfU/soBl +YG7KW8piVG0wNz0upQk+aH0shqB1W7uWVWnVCBRamlnlX8ACTs/NVNXVaHgDzxYeHlWeewZ34lxv +xdtXnsbWANi5K7sQehZkF5aTMOqwUDd5sjAcukEkVgMdUw1rNp0jst5mLh7JBIqYadnMFUOHkwks +SSTo+qosEKImYKBLT1IDhYfqUQv2Mk0MQZ/grMfTKDzzjJ2KWeVkP7ZArtGoeCXPFoCw2mUeaVYx +OmyXov2yxCd0+YrXJ5rrCt3Xcg4Nx76qv5hyKQSrBS2zKR6R7cxnHJdJuSgTmwX8xP0dObHVgoOi +u0bW1NmrGCzjJHII9RlHSCVtKPIEfkZx1yYBhEjWjgZTZ9FcIjs3NMqrpmi0HEsMCK8pKhOCogWh +q2jNd4Yx5ax8pNDrM4o+90mjmh7GqWddIskCIwDWzCWMgPJGjEBxQUYNRWJUvhThVxfrlEQQBByb +pNdU0/PkDPYzSUwI0lfKQdB8BT1XEzlu+VzA1HXpr8TwEbgKXrULkkTYGWgxJ8yZEKUustfwGSVt +9HVTZOFiJoccUos9wJHkQCt/XizJlMyNG3oaAwydHIKVfFVNZaGVyWglogDAGpSARRzkACxy0BG2 +/zpHQ7DMikBDhJR406JOL0kQCmYYRE6CYATBbBP0BLIEd4k/I4I52exSOUc5RjrrKQjwIFbMVtZR +pKw3RjDbofRg0h6AfWPR2UFZcbrugqWaVQvdRtMPouRvCA851w4VRl0HpjXEfkhE6gY8F3CSk9fB +EgBiNH9x5PIIDEypCIKexRjNlI12ADH20gZ0fFpgNBr8fjMOMYk66fKY5aQH5nBXnUUUwXhG6dpU +0EjmkMpZBDddHIsmEC+W1hd5dxdgrVVXrfG156FHTo16Rtnt6sHtcxOT7iWtIbIhyghmkDu6Zijy +x0DQTwSoIWEE2hBmS39DvFnx1kVObzQ7wxQ5z5OBJeqGbzkQAY+yrQZl1yACU5/GcgCoWegWgKbP +hdUOnMZ+VqXycQdmlyTY4LmaTpXtVSG5ZZ/sWJAeRMacNd5p8KhS0UmUrYhBSHYeHtc/b6wIDEF7 +IHquOwIVnZMioK3ZtK1sHgDUI4Kghcg0CsmNQT/biuetJBgR++mkZJm/sR/XQTVFBS9FuhlBtKyu +qOFNPNmVdQfWbO8QrUhJvLUz9giVSIKoC3yqpgcNIkfdntGpO7WAoun6ANREerfq8aRm1dVBaejP ++MyvBMZFeXtG56M1AhjcSSw8eC7noAAskQAsNCA5hMEieHM/yhz4kAchwMGXmgDRjlSSBqg8DCFp +VQU93Bv5hLUiCLOJOLZLaHu0aZisKkOQFN/oNGdawE3K8UgeKhZ7aDq11CRAoGSUBXfwAutYVN7s +g8Vm59myQ4Km7GOFDj1FFXqiOIJVww16wICA4vQ1JYoQrCZMde+iGiFiygd2RjxXcGKDMXD8Q8Fh +1nGQGh0InLPSWznpEYEaPQhdocaSKJTiRmBRY7AszBqS7susT1NpHMndCv2Yxdxmi4pFNlW5to46 +poK6YrEOD8UohbeyqWDNH3URRM3cwOpAMPGEOVWrA/VaSyIjGEG0iKlZ6BeqDv0DlSPCOkXBOQ9C +kCJJiVUVbj8XdUq0pCfQSf5Iy6iFIHqiDILLomZ+sUpJYQ1iIOqKPqeAKyWhOdmKZUajEL1XcLYT +I5KhTv5fS04W0hCYNTFm7kHWytgYrG7p7r/tiVwILJpMOFuKRunn1Ys5ogqlo2jWeFMredMD7Vox +MwIpo1LGAq4ajjEiisuPCJJgjnGAoDkHcbaI/Rne5/LC5FhBnsl7AVdL561ZQzI1a+oQnWB6JoGi +UBSoO0dJptcVO4NFMR0NX2me2zkBB6NMjbKi1UAZrFqMZUGiH8DSeWPlnbIkria7cnKR+nI5MKVh +Bg1iJqvxUujU28X3K2Gwqaya0EsjcK/gRQmrs+YYhKQRUwvuLZbFSBFTtfh7JNNyMhY+6rFybk/S +FIXN64WuIV0lM1EIAytHYLNZ/G02oCjNmESTe0ay6hDoHbBklawZSo0PVTCxavL3U/6YIKWu7w1V +Mu3o7KB6mEnG3Qs4NztKgQqHHhPspRXIQ/D8MhLBHmYr7JVZh7oXsIr2fo4T6xBYDpokbyJsuXAU +dmYtSla9qJT+0KqG884JkDFaojtXR4r5vYKb1Y6AMZZyDuLnWdnfrf0+R/KcagJ+WSVABN+Uz68G +KNIfgwhUuC5i0s1cHPj5AIZuslvluX7+HOI++obooQKAFfUXLN2KMhHrNIeVknFxJPE6GPylzQvd +WLLAxKHyrpHvK+EKgKDXFfw7vFLyq+9Fr2tLIDCWQSKdZpVDXksLNuYUpkbxj4UgyR7/RpSMNbHd +OutaQR0BFFcrKxJERdDYG+jgJatKEyzUJz5MLZQXaxNuyK5CZeqS+oukDgspKSLyFpa/Stc8s2yZ +LfN7xpeh7gKWYC8fRVGghkA5JvMN8WXB42/EF8zYXLXMD9ckWtZogfAlyqGnZUVt0krJYACjnQ36 +kqVWHrbWMOKCegjuYIgXNc2biwP2jSwoPBWGaxIpTpiecS/guLbgwM834MhWjNCMEwpv/cTajKo3 +r3ltDsisBLbg1WW+LSpsMdKU7lg9UChQLQ5euG4I8+DAFdOkjF9TwkAe5TPCCKhDBJtnGts65hjW +CxyTApT4urAK48mHROu4YU0yVPWXlUK1PHvQwcBATMKVGnJYQrAQDVg+Lwll6NmkoWtyCkhGXspW +BDsHhoWjVottWXb7gh6tqo7JYLVu0J9ZRCPX4ydYp0vGp9o2SpGIvCpv4sKEzRjcwU0fZzUwg5cQ +TPAcE/eWOMpVEislmSFnQMLIXIiyrGj2rrLcF3RLRp7pIOd0vbNDClvS4KhJwDWxqC06t3i9Lxgt +bAymvH6pVRlWWUEgccrNxRHDVfHjtNzsvpehm2OVOUgW4f0GjBGYVm60kiIRgwPeS/IlqpZhQOZc +khptQ1s8mx3zgNUDhQJG0MEL+zsHrCsqHWlDgQJVpAm1va3vl2G9wAPk0U++/rvdu/fHV9+8f/X2 +zYt3f735OYB++t9+dvN3X71/9+rNdzc//epPL75/uX/9kspN/+l3f/3+5c9u/g9stH+w0S+O3OT/ +hH+4jX4/UUladKZi/SFQtKg6OuinVK12oaCyqzcetJ534m0KaQfdurJgIWP2fgO25JV5NllRzbEE +zAtFZTwBdfg4d2RoS+VByoi0w+T9OnoKxnkrEqEjnfms3kiAABlBJ9ba+l4Z1gscwNGjw7mFCvzC +LzPVkQebJlAN9CVm0N2Rr7jhs3pQAl03mbhOujGXk+kQNSmV9xuwVDFhgnkTR47RYTzuHGxW1QGV +u3NiKejaYgJXWDdYO1AoYAQdvFhKqcM68/GEkQIBKnuVWmvr+2VYL/BA2Bvw1iYsrQxarN4owTfe +gLUbiatRrxqKlIOOxVXpajrjLui9gpmKrtxvwFh2yfxGXC4Wp161DaaVHDvsG3Fbgca3ji2lIuKI +sgPl9cpaBQeuwDYindmTPL5fgMpaJdXa+k4Z1gsMENbOWMAabxdY8aogui4hR7plBKyPStprtBsd +8G4EhGSnvbKLqsq8yWI7eagkSTK9YOLqqtaaqrK+OlCZG8ocN21xWYdlg7UDmYAuVhgaOCYwIp35 +kPZIgACVuUqstfXdMqznHGDegtXZlkq3ZcyBbsIApbtFuuUF9HoyCDByuiS6KyFlvuMLTYTOWrCs +BHHEM6v3G3CyQC7WEy6kKjQph8JdK4V3TAFy19DJqfPe2uKaC3GDtQOFAh0cBQc+ZDNiXfA84pYC +ASpzlVpr6/tlWC/wQLiLeUMoYWMjdQuNq4ZpHXQlRaSryZK/g6yw3DXO4tWIjDVgjtz9BiyVsZlW +rjZKk07yDFDlFINFgMrZVOOyaRulht+AtQOFApv2Ag7shRyxLly/bKRAgMpZpdba+n4Z1gs8EM4u +dPSPZEusVMAedJ61Dpf88DR1t35UuzlFttRSG6PGG4TZDhrAWvgJ/fRpFSsvSm28GUtMqWFCQGWv +mOu+LebHqMFjWD2QKFAECg630SINinTp8ZNOgACVu0qsa9u71ZGecYCZm9e10v1rSw== + + + XgJJhxm005G3QWRBRa8B3bFkN+iIXMr6tqaV+T04WuL8jCrJImJfC9jMsuI6UA2Qsta8aYth3nnd +YO1AocAGx8Ca3OGwBo0zOwIYpqxVWntL31dDecYAZO3CGm5OgXWF89t+OoP1ZqJ+tRb7ZYzBJSn+ +2hbjr0IxdD4rfau4XuKtHGLBquzFw8y8ExvDt+QrHQaUHchv1493qMYpHM4+7/rbGaa8VTr9DO3d +NJTbvn+hebJ7nHnye3HuLercgx/fTkVuFfnxas62wYX4jEK6oKiL7CHT8X4DLj16i0ctWI9dLQHW +qjIakPhtSQC+LZbNi2WD1QGTs2kdOHD25YgV7xupWwoEyBR0al3b3i+H9YwHJKm+3GCkooSJSZN0 +xPsNOHCuPxVwZGsfk2mb1bac4+qA2jHO6x/aouMyNY+yQ+Td/OkOLpxGOqKst+jH2LxegDqySmpv +63rUsZ73/lrGIqezzNI5ikreb8ABfVdaXRNwyEamBV+gc/DS5oDK27LmZdM2yVn5AWsHCgXKXgX3 +gmsOa7UDs44CATKCTm1v6/rlyrid8eBKxiKl5WTz0VgQ0oFRiQjK3URpUMgx0NF06iwpeqByF91p +m7YY2mx5g7UDhQLlroJ74U6HtVi1J0eBAJW7Sq1r2/vlsJ7x4Fr2IhJBLtaVnSgydx1UTpEwsLuc +a8jKXa6rakDlbos6d61tlvMJA9YOZAL08wrthckd0mIXKTkCBKjMVWJd294th3XLgSvZi5wktqgm +jKUJ7zfgwCkiz6TurxpmrcpSLXKflAG5a1RBatm0xaOicdlg7UChQJmr4GQ1Fx3WbDlOjgIBMoJO +rWvb++WwnvHgCvYivb+uMmQ1aiaEAwfOymVgXBRI2yf3S5z2ClTOLiIbXVs8jKpAw9qBQoFyVsF4 +B8Os5aoVa7bTL44CASpnlVrXtvfLYT3jwdXsRZRXlMJG7inM37/fgAPnsnA/WtR5l+TAKBboDjrF +k0V7sJj3Mp+3nXNdzrAqUCiwmS9g2GXkhLDDimd2wpYCASoCpda17f1yWM94cC2LEa//a+rEoRoj +92dgvVEDgamq+dH7BhtldUDtW4o6PK5tD2o6rB1IFNjwGNiSLzvW1JWQTkHyCkundmjb++Wwbnhw +XaMRd4rWZPToAMD9GdiVmF/MN4FjK6woamhXdVfQxY3zsm1ZQwhnKDuQXq+f72A9WuGQDvNf3y9A +k0/mL7G2vlOG9YwB33AayL9BbOtDpiMbMv8q1mPMFtnw1qMDF04veMa1oum4lI9yYdXhFn2YjJiO +pWEpScm3TeLMH7A6oLceHThY3NlhlaNbIwUCZPOzU+va9n4FX0h8wwNRFL/IcKRLiDRfAjfA+w0Y +cxGKVubmgxDILFdlunOQgMpYLhjl22Jl25X3xY7VAYUCRtDBQbPqHNLFTqg4AgSofFViXdveLUN6 +zoHrGY+oQBXx81M9lPsNOJPnh8ltVCgI+WUnP0DBkpQPAXLXGlaZTGNbPFBTQhuQOpi8X8dGwZb+ +7JHiVYVh836GKWeV1N6yd8mhPOv+texGrDyfglptRY3yDsULSRIvpcpprzTnrH72KmfTDKiM5Rv7 +fFtczEkZq1gdkAkwaZKUsXqoySEFa2mVCyc6AQJkAjqxrm3vlsO65cDVjMZYNOEEbzTNS2eugnM/ +WVT5kCov6NWYy2cEDajM5bPAQ9smp1oGrB0oFCgCBQdfoF2xBjsP7SgQoHJXqXVte78c1jMeXMtu +xNsNJHIfObP3fgPGewLZ84OXE0S1FzTRjm4WGIDctxX33LhpSxezrBusHSgU2NyflTmt6bsUaeCw +1UhAcNE0R6xr27vVkZ5x4BpWIwqledZ4F54Yut+Ak7/IgS9HpUknWcx4NUMLiwMqX/lE4NAWqywq +Xw1rBwoFiqCDtVyzw4rBlrJuKBCgMlapdW19dw3rGQ+uZjXi0ukRq3nWnayDk10zi5dn0KEQziWd +lb21qpOYgModvi1kaAvbTlH2GtYOFAoUQQdrYqfDSkeb0oYCASp7ldqhbe+uYT3jwbWsRrpuJMiS +yDZ3PdQ0mKpJmUhZzCqG+epVA2rXqqRgDG253tMGawfmtbOmQ/WGho4T63IYUN8vQP280jq07b1a +L8Cyzdsr2IpIbm5qixbTFDxYT9BgL+iA0mbQc5r9TLBZE+Z01pavjttg7cBxVRtYKzYNWGsLZwTU +1lnbae0te6ccyg0D2Fb8mCX3r2HE0SF9nQ/diHPgXvYdi/qvRew1rRSW6Eax5oDEjIwVQWsb22b0 +8asu54rJK9AbcQ7cNSyHtWeCOAp8Joij1rXt/XJH3M94cAUjDpCuVf04WETofgN1N1asuF1I1Mdu +zMDT0Wt0QOXrHFIb22Z0ni5hxOqATICyVaFBr2pzOC2d2b9fgMzVTqtr23tlSM/6fzULDq+8WHS4 +ItbUut+A+12jWBsjN5nHWjOIbmtIqwMya2a5vti3zYvtUB2rAwoFOjZ9N6MCXiPWhesbjBQIUJmr +1Lq2vV8d6zkPrmXG4T0huahPcW7GXIViXmcU3oaU9CzBwq7ORPWNogMqb1W56m1xNQcNvQlSB+PX +mzQRaLQaQA5nsHvw3PsFqJxVWl3b3qmO9az/VzPi8FaVpmNGhV7vN+DMxTiY3hg1HKf3NELfqJRL +Bypvl5Q3bQFIp24HrA4oFCgCBUe7lcVhDXaNgKNAgMpdpda17f3qWM95cC0jDivexKwGqirDA5TK +wDK5adEwvRS6petecuww7liT87CuJU07dfkpygFoirCD4iF+KzmkOIPfw/T1we9hnVLXtvfJYd12 +/xoGHAl7HUI6E3m/AfdT41SxSBNwNeEYugUqYXVAZSudSdm2pfuHRqwdKBQogg7WC0Ec1mCFwR0F +AlTGKrWure+uYT3jwdUMOFw2iw5kxevD7jfgZCorEkxFgxCoJwQB2MIaHFC5E0pZNm2b6awOaxsU +WfXTDmC/9gVr6JtTpyCMG5lSO7Tt3TWsZzy4lgGHNFDNGs75D33yOvBc9QopLrhIxk40lq9BnSIE +1L61qjF+a9vwTq64wToAzbodwFrgcsC69luwOgWrhbUGal3b3i+HdcODq1lxWLas6cDBaPXJ28FU +zlSAxcJzfeSraKJx3EvKOp+35QuoN1g7kCgwBAaWIvQD0rWWs/cjTD/dSXUtrU8d46b7/342XAYR +ta7J2S/3G7BcifeMqwZK/6rVpcG6hRad6wcDsR5ibnXTNrrj1orVAb0N58BSKm3EunD5v5ECAfIG +2qntbV2/OtZzHlzBhsMrcdZFfCjJaps4cLbAP96wEnoiWtOLRLg+hgGZL4uUiBra4tnbOY1YHVAo +0JFRsFUcckhDZ3YnIPTD8Z7Y4Fmo3TKk5xy4mhmXe4ww8dG8+w04u6qYsRWxHpKW3sAKrfPqgMpb +Ps4/tA12GNqQOlhyJwYdOPY7BDrSYJXGHAECNN62bVvXq471nAPXMuKwtGdpasRk46wCM18izNSm +YuFfuyoHRrV1mDKWK937llhSOGxQOiC9XNmqwK5bOZSYkC2lYvrbBahsVUJ7W9eljnXb+asZcHiR +k53KoZJ79xtw5jKnz+Rio6bxZL1bAaX4sjigcpaLVA1tqUZjG7E6oFCgCBRsFUAdUqzjYgVqlQAB +Km+V2N7WdcuQnnPgWuYb3nBlmWYkke7PwBJBz80ZzNH2D5h+DsZ8wZOLGtTXlotcau0wDrAuJR04 +WkF3hzPwfZPj6wVofG0ljG1dlzrW8+5fw36jysGW6rvOvQ5RP5CX5d4OvMurxEXn26xsXeqSHFD5 +SoV5x7YLVg2JI1YHFAqUsx2shcsc1l6u1VEgQOWsUtvbDt1VrOc8uJr9lrsXL/KdqvcbMPrmmpKh +tm2xO77mdVk6TFmbLGGyt6RCygNCB5SX6+c7mC5OHZH2Sp3u/QJUzqphrS2HfirO885fy3DDsaXy +lYR51tOTI7hanSs6q8ejmxa7Kq6pZt8P6JXZZZhqW5SISaWcYh2Bs6YjDmB1EA9YS27hjAICGm+N +Wte298vczmc8uJrhhvXCop7Gp/Du/RlYK2Yi0PYAN/I9pE1A7VyLmgHp25ZWz7B2YI87D2C76ddj +NVnZ39+6qO2UWrveI4dv0/vH2G3Lv14WZUFfizNb7gdg1np/dB/BKs523snsfhQBER+q3svm2m0w +jUaSQTA8ytcBOhxYJX/ZvIxh/MlOlbU02jvCbR+vdcIO8BZLdaALm+834GwpY0jqmkXRTanplRKl +RQ/kbuGtexrEsLaRyySOWDtQKNBRUHAP6DuswS6gdRQI0Bgr1Pa2rl8d6zkPrmahFVwrOnDRztM4 +MN52JPejYAWOqPUqkl35URarjZPUe4vXm8xqFVtbqY46Yu1AoUDZq+Bo11s5rEEvI3UEMEyZq7Ra +S9epjvKcAdcy0PB2EKvtFvSQtYNmPN6nt4uo76pfgI73piQHUr6mWWM+1hLP39ewwdmBya3mDo3D +DTOzmmN0x7N/vYCMrasl8kpL16WO86z3VzPRKs5uVUJJLN+fgZsEcuosF4Dzgi56kVQqsTmgspYq +V4xtg23nDqsHEgWKoG/9Sc6QOazBiuQ6CgSo3FVqXdveL4f1jAfXMtIqSWc1/zDr+/4MbDT0sLld +QLRg0YrggMKaTbPAJU89Og+iF9uEb+pVyWIj6wSe9e6q/lYBGj+FQte298QhPOv1NWwzvAkuaBWb +uahtNoDd3sV3a9NEkysRsV+LWnFWX5I26qaBImsb8N6QLVYPJAqUqQruKpvD2q+RcBQIUDmr1Lq2 +vV8O6xkPrmab4QZao2a0rqoaOHDqd7QBwVLqKFmOB942hTKsA5W9MOjnbdeW8wZrBwoFiqCD/TVY +ghVLC6awoUCAxt5y1tZ317Ce8eBaJhoJI3UVU8rB/Qac+saOhRWrMSfq1KGiVh2ozIGNvZ21zU1r +DTnVQoHR5UIMYDGfHdLIOY0jAQJU5iqxrq3vrSI948B1D9QNo4wpmfdn0CbX3NANbOa9SlF3ke5d +IKDyZ2lrPWvbi7MYVg9cY+dvh1JV3BHpMKW7e4GAxmDzqbmJ2rtlWLcc+OIDdY+sxvIhU/D3/2bF +WYB5sALW7fE6D7YyKnNtFvO0gitzxSxVVtNccZa50q2666ZtdCU8DGt0JTzMXPRgK6PisVrBFU+B +K87iqe1tXb861nMeXMl0nCtGXCz6o8VZPJgrqWDHVsltsoIr2DGNwLviLNixHMaW6yJlpA2hg7jS +LB5sRVQ6Qiu24l/tCrN4Ml3b3huH86znV6viWfE+HLWGrTCLB1sJlbnSxfWSXypnl7Fz8M1XYFG+ +Rtkze9t1lisqPVYHdIVZPNhKqHisVmzFU+AKs3hqXdveL4f1jAfXquIJQ5yDHS/TwiwebCVUkN4y +a01fKbaCfeNbWIfCLMiHUMeWq48TKU4HdGVZPNgKqHScVmjFv90VZfGUura9Tw7nWQ== + + + /69WxLNixW/Nk9GiLB5q5VMQ2NZVE6C50ArgxLP+zQGVs5pD2duus9ZZd1gdsBdl8VArn+KRWqEV +T4AryuKJdW17txzWLQeuVcSz4v0bq+oR6kTyYCufglOErxFyhVawa1pe1BVlQTbMYdOyuWJ7htM7 +zawkiwdb8ZSO04qs+Le7giyeUte298nhPOv/NQp44vtnNfytIIsHW+kUBFYLTkqRFeyXZlS7giwI +VuvEtQVBmbV8nmHtQFeQxYOtdIrHama+p8B5Azy1rm3vl8N6xoNrWY+0C3QjTQuyeLCVg6AZknTW +SZEVBOoBY1eQBcG1blo2VwXZcDZfMVnLsXiwFU7pOK3Ain+7K8biKXVtq7NdDedZ/69kORJpVs/W +irGMYCmbgkCQ477uigDX5iu0aN+Kpau7tmVt7QxrB1oxlhEsZVM81tSVlE5B8kpKp3Zo2/vlsG54 +cFXbkabJqgVWrBjLCJbKKUiLXHvQtMQKzahFoxdajIX6F7btes1Vh7ADrRTLCJaiKR3lsJr03a4Q +iydzXCVrv+qj5DPg/xKFWGYMU9gS7paiA1vJlLmsVtbbiqvAyrAJ6QqxzHi715zypm2Uu5EHrB3o +LUUHtpIpHqsVV/EUuEIsnlrXtjkpbFjPePDl+Z+IVC7/aK4QiwdbyRQktV/vIMVVsFudg1aIZaYL +2bS4prXFW6nVsDesHegKsXiw1kzxSK24iifAFWLxxLq2vVsd6RkHrmYsFsxBVe+CFWLxYK2ZguQu +cpbZiqvMdOPeEhyQu5ZxNW3bgsHQ75EQpB3mCrF4cL+H0iHV8ir+/b0Qiye1t+xdcijPun8tO7E0 +f8mKHK/2UCuZgtTOOfqaK9wxvh16KMSCPNAKb64tLOaoARzD2oG9EIuH2tFbj9SKq3gCXCEWT6xr +27vlsG45cDVDEWioljpnhVg82EqmzHivZCpjIRbsW8t6aNIKsSAfQFlKm7ZZrosfsHagK8TiwVYy +xWO14iqeAleIxVPr2vZ+OaxnPLiWrQiYk9zz4QqxeLCVTEF6VznoacVVEDjXZVuIBbusloJrm/Gy +7bDB2oGuEIsHa80Uj9SKq3gCXCEWT6xr27vVkZ5x4BrWIgqlaoUGtRCLB1vJFCS1yv1cVlwFgcu6 ++ooryteS1PVjbQtYzBbBVKwd6AqxjGApmeKxWnEVT4ErxOKpdW19dw3rGQ+uZi3i6FrVVyvE4sH9 +qsCCN6HN5n21aQtDGBxQudOk6r1rW9hlPmLtQFeIZQTHYG0Va2RzcqRAgMpepXZo27trWM94cC2L +EWmYzcqwueuhLQeVCTlEK4qthKXQTyP0BRkXjZL3liHqZHQoOzDbvPXQsGSdoopTqyD4tzNMP650 ++pa9Qw7l2PdrZYESscFutiimJXiwnBKlTpiNqFcqYh9iKw5oMyZrEqdrW7Md1+1YO3Bc0QaWiikj +Vi6tMhKgRVhGWnvL3imHcsOAf7cDfDMeBEp6rKIbcA5s5VLmDDtMUztDCqvAksLLdz2QmJGjHWZ0 +bTG8pnqcYe1Ab8A5cNeuHNZ+xY6jwBVh8dS6tr1fDusZD65gwOHxNbkcrxdh8VArl0KUzhrhkcIq +2Kssp8ddEZY5o96jgTlrG+wuUIe1A3sRFg+19e9w9jsl3ftdERZPq2vbe9WRbvt/Nest46XpUfcm +LcLiwVYuZc5YnHIW5VYy3LFrJdqdclqEBdnQw9vWNtru5LBGv2lqERYPtnIpHqsVVvEUuCIsnlrX +tvfLYT3jwbVMOMBcg5aT0CIsHqr1UpBaTVG1wirYsxo17GNFWJALqli5ttHVRVekHdaLsHiolUvx +OK2win+/K8LiaXVte6cc1m3/r2bAAea0qopgRVg82MqlIL01qdYrhVWwb3r3myvCgnxoUcfG2sIr +mp6TMqwd6IqweLCVS/FYrbCKp8AVYfHUura9Xw7rGQ+uZcABZi2z04uwjFCpmILklhL03o1ZeduS +2h5ahAWhFJcYWiZLIXEoPdCUYAe1cikeZ/B7mL4++D2sU+ra9j45rNvuX8N4I2GvaYBWhMWDrVwK +kpqregz0fsaMZWm1bJAVYaG9JajPwtrir3YLomLtQFeEZQTL4VuP1QqreApcERZPrWvru2tYz3hw +NeMNl03RjEErwjKCoZer9KOX4ZecYQQuUn4u9fxiWqWLBkKtbXY6q2HNgyKrPtoBLJatQxrtUntH +gACVu0rs0LZ3S5GeceBaphsOcFDpYyVYPBhYs1QVtnrhFPpDYxBgyHoAI2gWIvV4thx7bZux3t+6 +wdqBrgTLCKaDHSPW2LenTkEctzKldmjbu+uwbnhwNRsOaVs1v9dKsIxgKZaCQK2cGPvuUKyWeBx3 +ktjaedtey8ph7UArwTKCuWDKiHS1Me/v1xIsI6m9Ze9Tx7jp/r+fBZcKHvj0qZL3G7AVSwGFGxax +lsaUsiog3FxczkqwzCmYMuragtIPFusGawd6C86BrViKx2plVTwFrgSLp9a17f1yWM94cAULLhUr +ge9KsHiwFUtBUmueLZWM3QzQrZSbB3K3It6rvm2LV3hrXTLD2oGuBIsHa7UUjzR0tnQCXAkWT2zw +LNRudaRnHLiaEZd6dNCVYPFgrZaC5JZ+qweXVcGu5dSiAypv06K311tbPKujcT1F2mGuBIsHW7EU +j9TKqngCXAkWT6xr23vlsJ5x4FomHGBOi97Vq+axA1q9FKJWIo5aWAU7VqLWLTUjI0W7vre3xGun +NbRpKDvQSrB4YNesHEorq+Lf7kqweEJd294lh3XT+auZbwnzcPX6CivB4sFWLAXJzVmjPlJWBbvW +LxG0EizIBr0g3rWle6HrBmsHuhIsHqzVUjxSK6viCXAlWDyxrm3vVkd6xoFrGW+Aee5XPGgJlhEs +sfOUnbkcbf9Y7Sa1aNsHEJnjOrbEkx+5jhg9zEnJDrZiKR6nlVXxr3clWDylrm3vksN61v1rWG+4 +fcqtFa4EiwdbsRSiddHi0FJWBfvV5tXXWlG+9rO+1jZauq/D2oGuBMsIlmIpHquVVfEUuBIsnlrX +1nfXsJ7x4GrWW+o+PFeCZQRXyXtOeK5cbxMrfC6ROtc0XlD0DCNJwFTzWVtQYNYNVg+0OiwejK6A +qgiKJWCq1eAoSM7CcNS6tr1fDusZD65lv+EQJ7UsrRKLBwMVqwpbVcbRFxqV3F6Uj4DKm7XZpqtt +MSXVzDdB2mGuDssIBk3H1n+ze8fXumwIEKDytlsOrm3vrGE948DVrDckImlNa6vDMoLloCwBlx4r +40hwyi6ibXVYCJz04J1vO6v15bB2oNVhGcFSRmDE2srZ+1uXt51Sa9d75PBtev/vW4dljt3d4i04 +B9YKKnNErXOosTLHaEehrRbLHFGxH2q2wMSw7NSOrsO85ebAVknFo9SCK/7dvTSLJ7K39C4lQ3nW +8WudsYt47W3Q5EUtz+LBVkgFyU1N86Kk5Ar1TI7uu/IsyAQ9kO/a4jF/1fYMawe68iwebIVUPFYr +ueIpcOVZPLWube+Xw3rGg6tZbzE7b7OVZ/FgK6RCBFsumpyhxs6lotVvrDwLMiJVtZit7YIa5rLB +2oGuPIsHWy0Vj1WLrngCenkWT2tvmZ273VCeMeBaxlvMm/oo9xuolVJBatWvZUVXsGNdaliBFuRB +qXpg0Nou50VfPDC5Nb2cF1PxSK3siifAlWjxxLq2+bzsyzkHrmbCRcxT1iPoVqJlBEsxFaK319+X +4GDsNoEr0YJ8WKuWN7W2waklhtUDrUSLB1sxFY/Vyq54ClyJFk+ta9v75bCe8eBaRhxgXu2klJVo +GcFGQw+q60GrSD5qX7eFexbdtmVtcXWqGmfc6iCr0+LBVlbF47QCLP79rliLp9W17X1yWM/6fw0r +DrCCjrEt1jKC3U4W8joWa8F+afk0V6wFwaFuirXQlMN1M2L1QCvW4sFdr3NYrQCLp8AVa/HUura9 +Xw7rGQ+uZsWhrjKrn8OKtXiwlVUhghdNoNRckIiKpd5IYcVaaH+xBErXVm+Hd1g70BVrGcFaFsFh +tQIsngJXrMVT69r67hrWMx5cy4ojsWSpklqsxYNT3+bRpxR0S+UCLNi3ZimUVqyF1uqqF0y5tmnV +okJe0Vi1pFDPmRjAXFfFI7UCLJ4AV6zFE+va+t4q0jMOXPfA3TDKWqxlhEpZFaK5+7m4AAv1z1wA +VqyF5pRpr64tGABlg9UDLUw6QKWsikc6TGnnBVmcDdEPhbuJ2rtlWLcc+A9ZrMWdwfvSUT+r1oJX +IKkRR3PxfgPO7D8AIG6Xc9XCE3Ix8xwtJ1CAOATL/8/euy5Hblxrok/Ad6g/irB3bNDIC4DE1i+R +sj0+h7Yclj2jiBMTHRSbLXHESw+bbVv76c/6vpUJJIAiCVQ3ySp2SSGxsIC8r1y57mnkvDOlG35r +WiTusINac2DswfGBgvuDg+CTEbhL+GKMMO42RGtjukNk0DECiRsMUksdi9+WAVkEksdqQpgMmHVs +zYydCM6gFx6SD14EoxGGV2kmVKANuBRUuCsdiE2hGQJmQLkCrfpCBWTu11vqyhbZ4lgv+AUbUyKV +MFtSigiV5qjXQUcn+YDR6S0XJVK02Jjghb5WOhMBm7PLiaROFTByNU3yY3SqK8T7UHHIuEgrRYXD +z9BiCLY0SvoVWFdIlGSlL0ngYmgOksQAyL13HCvQ6wlsiaNZOKETgnGFF1bOlrbjiDVSIyqZqS3E +yMrOxQkcUspCWrp0s6LMQkqoLfNVtwqMKnedW6thu8H18ZtAqGholnWIijYsZLQuBaT/McxBNV30 +Y2IDxmaVb5H1Zc+v4tiibUXA9JHVb41moAyg8ypKgWNUUUgQUdjASFzbzg4TWjlbPfGXyV06D0W9 +1rcsu1jJKss9WNYx8gSLVsfrzWS8FfWNWAhXayYtQcbKNnEl5axOGxNOCyYumodLacLnsvZctDpi +onBMQXEm6YHlZ2uSjO9BktKebK1PGWZb1Wu2Xb6fgFvPlVFH5KylWBNqzVdzFmcVdkJd25QMoC01 +E4ROdanMN+bfpB1GLDhev1onPAjajiR/9c2fwpvfX789uv344Wch53fnt9cAVgC++cvN9V+F5t8J +2S8KBR+d/3Rxnb84+Mt7vDGlvvr+f/7xDxeXUs3B77qfcs787oc/n/zl5u05fg4OoHtffL36zb+v +Lq/lVSHdur348ePd+QccNXKG3Z6Ovjj7+eLy7e35Nd7b1e/+dH3Xv8P/7uJJ9pvyKznI/nF9cSbA +dJ7lH/7z9PKjfvnvhz+8Pr3id+gEe7Wt4/h19jh+fYFxyH6ePZJ/Xby9+3n2aOLXWz2in88vfvr5 +bvaQ0ufPPqabH//P+dnd0c3H67fSv6ObR/ZGP8B33P/y6d2H2aMclHn2oX7zpzffXL7/+fSNmTvG +i7cZb3zPmPDNf87o8baQybuPtz9+FA7/7HzuLGjRmUuc2nluoinC+tzx/Hj64fwPtw== + + + 5//3o0zCfBI6KvXsI7y++f7u4u7sESrZj/IDv/77xeX5/P05KPPsI7Rzh3b98eq7s7vTfy4YWV7k +2QeGLTd3bLfnHz5ezj830udzKNA9XTcPdH099csOgfO/5+Tk4c4+MO/PvCAX13OX4+b9+e3p3c3t +7AXpCzw7mn1/8/H27PyPt6fvf744m33EPTIV+Ul3veV75+L6ERIyGIx9wV1zfHP1/ubDxd2cTfMU +HSAf9mjbv/v2/N3q6720tx3j2Et72zuivbS3ZpRbIu35L1nae3d7Kmzv5V9uLj68MnlvthC/F/e2 +U9ybvS/34t5e3NuLe5NR7cW9vbj3xYh7hX0tAt+SkWy5yOdfnci3YES7IvKJHHR0/s/zy+9/Pn17 +868v2/alRybFwtdyYP54+fERbuUzMJvbKhl8uHv77fk/L07RoQVST17oxXiCP55+/PDh4vT6SBdw +V3jp2Wvzdv4x/PYlzuH5A5l/Cr99iWN4CQXYdmp28+7dh/O7o+egaS+07b/jCHdow1+Cb4GX4NnN +5c3tf/3rZxVjZtLnXy/nqxLj1/sN9Alj+fD+/Oy7j4/sh93jCGb79nz4ePvu9Oz8+7PTJYg3KPT8 +Usfswcnifrw8vT2+uf5wd3o9f92mBV/AmrZ0lL//9/ub6/MNRtkX3CXZpKjKcvYcbbmKw5QLxrLd +So7CLhnLf88ey3+/IA/y15uL67uTqL54CX3k+fdxq55E5mKH+KHXaUxYyDdsOxu0kaJnsTVhu9do +1ySjJUaSbSEGp7cXdz9fnd/NN8DtElGYfez98ogyJRsOPt3igTzCi+cDMdssKvzi5g/EbfVA5lPl +X16CKL9KK/xibmDbj87Li7u/nl48Jkt+4Wfn7sjKy9XEi3fcCy3kn89vfzrHTO4QE7R0c73GtXi6 +DuxdhjZWqH31StRpC7xStluZZszeY2j7PYa+rCCR45uby6Pb8/P/nm3VfI2eUW8vLk/n23V3SYlh +DmfHld+evr34OB910+e7od3cbolz/kDezh/I220eyK6JmH++uX3/883lzU+/7pBosidrO0TWXg0x +mx/BsuXE7NWGse0kMStej8vqq9npy8Iptnmrzx7Jru31nfO4fb0x+7NZln3M/n1jfNmY/dl+uLsW +s7+AkG/7kTR7k239kTRfwtmxI2knsyg84lGSkbVlzvcv5HX/Re74rXfU+HE2lm099Zo9kl0Jwvnb +bHPq8c+n19fnl9+fX56fLdGnTQs+v0VotqV100FOC77YOfTtxYf3l6dn51fn13d/Pn2/Q4fR1alU +NdswuRPS0Sr9u5r8NIOfc0fNX/P57/T5FlPKrT+Jl+Ua3ObTa/ZIdo33PkYY858T+dgVercAs7Z9 +j8zWIWz9Hpk9kl3h8OZHIj9P4pVt2X3vFvkHvbu4vFzi/3S5zSv97vbmav5g+PHzayUfYXIyw9hj +HuO5Zezji8RczR7Lj7iTa75uXL9+fqP+5b9Of509JqF8d6e3iyilfr+9mvC7m/mSx80LDOT2nCLg +3OGcvn17cXfxz/niVF/gBewx1/PHdXb28erj495C+ciyIi8Q0XR9fjo7/OXs9PLszzdv54+tL/D8 +wWezeYts9VLzf+EQ5i7gsNQLiSSn1xdXpy+WGnZX89AVYe8Ms2WS3dmrcYaZP5Jd037snWG2Rd27 +v7BwolPYNW+Y+TnNds0dZgEp3/ZD6dW4w8wfya4dSjvpDjOb/9wNd5gvcsdvvTvM2atxh5k/kl0x +luzdYfbuMNtyGH0B7jDmS3GHWUDzt/0kfjXuMPNHsmu89266wyzArG3fI6/GHWb+SHaFw9s2d5it +tv/sjjfPgi23lHi80BruYtbABX6A+1V4slV4upwbO7AIT9eBF2p895M2fvOnN98yZ8+bZZqvWQzR +7hxRrzdv0Xw14I5kLXqeBOAvRU2X5MnZU7SHKVq9p2ivkaLNXtY9RdtTtFdC0X5/K4Avm0U7xxS8 +Rnq259D29OzLpGdfNIP2aunZnj/b07MvjZ7lRp03y6zwr4yszR78F2TD22+bOdum+ZK3zezB77fN +F75tvqzbgv568e/zy79env76Zlmw4zY67FTlqprtPakz/7cFDpRZiV2ifLfnVzePpTfYsVwv83OK +7POj7POjfCakW5mvbbkylfy/XMl/X8tv+fu1vFi9Npfti+u35+8uri/mG7huz9+fn959u2C7ZSWe +fXz7HDE6rh3LEfPhPbLEzB3dLuWImcmNfGkJYraFh3qFFxT+uOSy8S331F8yll3x1d8rLLaXHDy2 +t3fTrrSIImw5ddvQpLT14fM3V+9vPghb/t3HR0jYLgfwxTHuEEE4vb24+/nq/G4+ru0SYZitU/vl +EeNUNhx8usUDeUQZmg/EvIQyYvZAHnF+ygfitnog80nzL7tCmXfjEF0o9ezSEfpqsyJ+ljN0d0wc +G63pzjgQ7QMA9+bk3TMnL0tTuI1apb05ed2s7M3Je3PyM47ntZqTSVxgULbl14sIzd6EvDch703I ++2tGJiPbm5DXdHd7VMR7E/LehLw3IX9+7cSOmpBfk7H17cW7dx/n32ay7aRg4XB2hRrMTk/34ePt +O+Fsv1+W5n9QaHvtSDr9y8Y2KPPsQ/v1/PLy5l9zx3d58dPPd/K+OEMe3NlDHBfb3gWMu/P45lpE +9+v5+25Sbq90e1Gl2/6O28dHs1e6PQUp/fqn2/Pz66+FAzv/+uL67cVPN1//8+Lm8vzu69vzt1/f +3J5e/zR7q+21cXtt3F4bt9fGrRnZfD5sr5J7Ga7KhNlWl9P/vrj6ePfI1Y/5kqTvnx3x6tljOr+U +h0Uqn6zEi+l7vr0g/36C/fVSHjHfqixxEvf4DqH8a1I7fXh/fiYH1+1z+MI/u3T0qpU1s0lUWuLF +0v604DavYezs7//9Xni9DUbZF3wBxvsRbe4TqKb2epu93mavt/mC9DZRS6N6m6jEofpmr7fZ6232 +epu93mavt9nrbXZcb3MZFRqvwoVir4R6eiXU91H420Et1OvMn7GBPmrbVWyvMgL4OfWGL0Sf9jk0 +to04vJocGvMzNmx5Do35K7LlOTTmD2TLc2g8zz0g2+1NvP3H5+XF3V9PLx6zUuzPzv3ZuT87Nx7I +lp+d+/xT23Z2LqXK235sbiRM78rRuc879Wlzvy3H7uL13OecWtKBF2p8n3Nqt3JOff/z6dubfz3F +/UW7Q4m+8OwCu+LXOTsp2j4i/9m30OyLNd8+Qk5zt7Z/vwCSzR/Ir/MH8uuWU4Btp2Y37959OL/D +lrg9f7uITu+aDPAdR/plCACbr+prlAS2ZVVe933ie9Fsl0WzwlRfzUXJ+XzGS7AZS0Yyn9F4CT7D ++HL2SP518XaBO2H8+vlH5OaP6Ofzxz0PsyGlz5+fg/oSlRpPkEV7d7irvVJjJ5Qa9V6psbWscHgt +So35A9krNXZA/N0rNbb32N0rNbaRku+VGnulxrYqNb4w0ezudIGj5WsUzN7dnp7dnV7+5eZivmOz +Fp65xqml5/bPPJyds+XH0w/nf7g9/78fz6/P5nOco1IvEJP+/d3F3dkjCqxcYsPXf7+4XJArYVDm ++TVfs31srz9efSdY/M8FQ8uLPPvIzp7Oy+y5R7JMq7XFcc7zR/KEAs+2nAqvL9nRgvPg3e3N1fzh +8ONnH85rSt30WlMdlYezb225u5nPT928wFD2uYsGg9vnLtrnLnpi1fJ8meRLS130JEqjv3+8/fHj +pUz2LukRX2fulQUixZYLR8+TcuWF9LxL4sP2qta1/OFXr8N7bP44ttx3rHx1vmMLRrT3HVszyhc3 +UPR8yZtHwu9ft5niLufPXpGRotxbKW5220ox25tp14wU2HJboBLfi3uvW9xbgmZ7gW8v8O0Fvr3A +txf49gLf6xf4ZosGr1Hge71+abNzOuwlvu2U+GYv4F7i20t8e4nvk9BsL/HtJb4dlvgK81pkviUj +2XKpr3p1Ut+CEe2lvjWjfHGp73/d3Lz96fZ0/nn/GkW+V3lnxKIY8S0PkXiNGS9mC3P7jBfPThD2 +aTwfGsg+48UnchgpD8SroM37/B1bS8beXQp3p5cQ/9ePl6dnv3y9UtDN+9Ozi7tf/2uBTvjD3a+X +83Xc8evnd+FecuHytu+sRYPZtc30ByDiDu2l16kRXbZfduJc3Szn0Lbf+vOBqRyPXxN5+3IYh128 +DfA1MdxLr8/c8o2zcDi7ohCZ7XXy4ePtu9Oz8+/PTpdwpINCz68pX7Zay8Y2KPPsQ/vXzwui8y+h +1Zf3xQzOIxvhuNj2rl/cnMc31x/uTh+7SjHXqozL7ZIC3bjZm/f0vy+uPi4wbXXfP/uSE+deTZah +enZOq/NLeVikbM5KvBiP9e0F981JNDK+hNeA9IF7+CQSqz23tyu3vu5ZpF1ikdICLz5jpwVfwE9+ +6Sh//+/3N9fnG4yyL/iFsIR7funl+aU9u7Rnl+b24ftIqHaQX3qd1oANOKdtZwafx016+9dprzJ/ +hnSitxd3P1+dL8jrvkvEYfaB+MsjPgXZcPDp9soZvzzyZT4Qs9Ur8kgGn3wgbqsHMp8y//IShPlV +OhIvtZ5t/fF5eXH319OLxyTq/dm5Pzv3Z+fGA9nys3M+E7DlZ+f8gWz52bmUKm/7sbmRML0/Ol/B +0bk7euj9LY3byAs9OSXcgbV4ug7sECK81lRE++Szo1HuXiqi13tF3kYWg+1mRf++OIf1rvFtO5lk +6epUqpqdXmIXCLtZlfHfdb86yNwh89d8spE+34H9te0U449S9MPjzmO7SzAYSfXntAF3hWK8wrPp +WeO/tjX7wj7Fx/MnSHs1OT6K2cLUtif5eBZF1DOP6bsvJsp159JjvE4nvsWs2+vdQdtvT4G9ASP7 ++ytOgLyL7gibrMu276N8TLPDGneF1TaH82Oj9sz2/kz6DHvph3fnt3+4uN0GFcm2rPPd6Y/z13gX +FJp2NdvOwbH/z2Uay0GZl0vF9fH67G87RE1eHZYdNqty9WXg2R/3ePaCeGa+FHJ29FIuJhR2EHX9 +99vT6w/vZtwisT34/jr1IZuwatvOfm4YZ7IL2hAd2pbw1Xt9SFwZes59c3m5BWuyLVOyGbLufTWX +dOCFGl90/dNX3/zJlG9+f/22uwYKoAqQN3+5uf6rVME0JYWCj85/urjOXxz85T3r8Prq+1+vfry5 +PPjN0enbn85XZlWs/npx/ctvDz7Kv+Xqu4PeoeaHX+Xh/5Ef/0dA/1r51Z9X/9//LldvBfrD3w7K +w7Is27Cy1WFTra4OCnNYelNXEVBYeV+ZemX9YVW5BoDW1a28d4eurZvV2UHhDoPxdmXtoStRxh/W +3kqV5tA2QYpUh7Uz8kIApfEeRarDYIOXb8rDtjbyTS3NVlVDgKvwbJs6tOlZijSHJlSt7b4Ih9YH +z1qdd/WqaFGkNAA0LrBnpsRHDbpmjJVmjPSpki4IwLetF4AM0LdNB0AhGUcTmsE3tQ== + + + x5AF4CpLQGiaWkfsDAs5ma7Ss3GZTjy3wbH/rjSyPsYfWky0CYeh0hEJyJvWrExzWBlMggBqV9Ur +Ux8a69FQha5IIfxtWxbCOxmufouKUdoS4E1Ad9FC1a7YohSWQuyFrVbaKymk3fQANBh+waFYu+LQ +dPIE1LQVQaVtDL+xlQxbZrW2rVbimmbFiW85JKy5rElz2LZVjWpL+URGVB/WDXGDOOD8Cjhha5/K +NE1YEW1c6kvjV8ArV6IQcA0IhJUvHQsRH2UJBD+x2AXw1cuggb6l6Z5Lfqy/i/5lLF30xWMTRd5G +7EfRdyR2tej7GsdDJBd0j7PNQRf5qDEtRT8vceqKfO7i9Bbd/MYFKPIV4CoV+TLFpSz6tYyrXXTL +nVCiyHAi4U3RI05EraLHLeJfG3+0IWJt7byJn/tUAeaJVWIy2AzmiQ3rMrMz1qTuhdjh0CRsrPqN +pQN1Nm5H7r4i337coMVkFxf5NuZWr/KvIjUoOnLA2TdxP0SaQbpSecKUsCjlCez5gDgVPXVK9Kv7 +JlG4oiNxJIN12gNKB4FHxkfEknUhqsnUxRnAqgAhfbcLgqKKoK1lB4DIXANpX1BZ8b5aJbIeH88O +iPptmwCowGPGUwUk69waXSsk66wydgWdda7qe4sRuWYwIhm27BTXDxsT0/AbnRjMXQsU7uYO0xtc +P72yAEIObVoAT/oSEp64gGawlJXpllKIFFa7SasNkilDrIBlCSCFZByBs91/U1emjajlG6V+bUj4 +hzKk63WPo0Rj32+yRNfjHmM7pOt+QJprV5t+h2E7hbLbV8A73U0ubT63Gu3PSk+OyuSbWDsRN7oe +udJJm2iB0RMKm44jq3GCDKlKxW9sFUykO3pOczNwe1SBhUDA6kTBSp5rDZdeaZye7Vj3nrATS7Ap +SSxlaIpHEcmdccpDJByvDAsRHyNhbuvVkHQ3q4ys5xTfRQYlYrZQZiXoXs+MxuvAHYgSW5eCiT9h +94RcD44meeb0Nq6Op5fnIIWM1zzefKOHvSwfEbTyRtsQNAx6RIaVzrXXI7RuVtNTdnwQj0/q6WE+ +Pu/HDEGi2T3JHrMVY75jypqMuZcRd6Nkusn4nzGLNOahpmzWmBNT4lxHVq3WOW0jLqJPpMtNG/k9 +8Bgm1B3DCLISsPyJqpDumO496ZK1HcNJ0lXlPGmibom4JfKXqF+ikD2BTEQ00dBEY4ckWJ+OR5z2 +ycHRjwfJ0/3oZxFEfvOPawgNb1c/3Z6+vTgXqcT49rdSjayNCfjbCp47+dwd+sYBAzLHebM6+unA +V4dlLSQIgCI9FMHUssDY2EFWXZZY6MHR1cE7af7oSMSF//iIvjWlEQpVHoZgncwTILIcRoeBRZZX +lbz06ImpalmqEqd9Ix354TSOrlFGDIKEzLMVtHQRIO1yOXDgOAoUgu/G6oFj5ZfMkDusy6rV09/U +YAjj0VJJY1JJHYKeI01jMaMykaExylE0Rs7aGgQt6ElSB1/rYeP652M5bKwDmnWgcOhM6/QIFt4Q +iOdkcNqy4HwrhQQ3neVJKMOQicJp40ow6NjvoEE4bFz/fMyzxtU+/6KqKz1qTAvyLhMA/AegDDXL +uMPK6rknXEGtNKHW8dmy5jZsyRlip4LjOsbeNuSFZDPLEaZkocSZJru9RPeFDkjfa541Fgt5fJBe +FfqxX2lhPVoMdjYbqJWplP2C3rET4GrZrYpyFrtZsN8lN38ZyGVibGhIIDxfDRmWll8IWdejpras +oypB7zHrlXXaTgtGJWADB+5oj9pw0oi8xx3dNKiEKOGwqkQSoWhy1AgxKSmLCgZVOGoEpzyPA8Ey +yq+NL7WhiIkFcLOuuTM9WgbqmtBUCVDi4/ize8XCZtWVRf04nyJac+ymli+7HhCRzarrIvF4lQ0C +A5VFyMbZCr3APAjm61R5v8pmirNJ0lkLa7mKs83J9m23HFwN1+o0JcQSIsCpTXjFFU1o1S96hlWK +F8Qcr1gmBwJxCkdIj1t806469COCWkUxV3c4zLZ8pWhPNGdvvFnFbdB1Ft23fpXtE+wlR3wzbc2t +5Jw+p83o27Dq9yJ2a9kBsJtNzYOE5CNNaL/fQROofIgkAUTDtuyhIJUeNnLarHqyQsqjByYhIE2C +4KtEmbDKoDI98QJxS7QtEb5I9xIO9ZQxUc+Esh1xJW3taC+fjg8GCFwpfnelyctKA1bWV5EWDRSD +LjRxI+kmZxe52aJCJo6gwCC9HsEcJIQg69p+XqKgVGcTVXAuve2/GU+2koLGZutRjJesGC1pMVnz +YoQUxRhpiileFSPMK8aYWUyRtxjjdzHeAEp3rcn2SDHeRsV4nxXTrViMd2sx3s7FYMdbLTSkCfwE +lJg0w5t0yilZqUm4KIe1Tb1KFLggZXI9ZSomtEuP6aanbkVO/jxbziikEuAiJ6KVsg6JyJYhSq+J +ABc5dY5vY/GiKx+bKPI2Yj+KviOxq0XfVx1OkY8nDrnIx8xZKfppiVNX5HMX57foJzg/A9MS9Mek +a+P0ZWepqfozvztuO5TIzuQOb4oecSJqFT1uRfwrcgSUqeMpy8+jZsjIXo2oWEXtUV0OuA3tjDfD +7lUZz9JtqyLfV3HvFfnmcy5CBhu4yHZw3OP9N6ACjY9sGBY+kYqMV+voScfQdSSnmNCljDHsiFf/ +VaJvHX9JBGmiqiJRQWBRKDNOVTGt42KBjK6FIN/Tc8VYa3p2WNHam8guj9jp44M/iITwbc5l11DW +SwvCMtR8lGYb45KaJFTE57pNmloLKZJEW4QoF2Glat5FmogM8Gh2IoRkG8eBzb7CalStjrMZL2HT +EWHFweybxlolD3WICK8bRvdJoqmQQtiYrzHxAimbRrXdpSoBZV6ocOOPuo67QfghGz8PJlZQaQXB +Ro69MiE1HHef4LBqXjEnqtdriN0NNJRJ81v5Vue0sU3ctIIgVmfeU49RKe+KdQm+ByQCht/9u1i8 +Lx3byJuIHen7Ebva9TQOJx9NHHM35DQt3aykucunDu9UJxDnF6UrHoZxCVzHw3frFFeTi2l183O9 +xyiRYUTEmvRFwqsJ8mW4RwxtXP9NwuGEwgnPMzTHpFaB9epewLSLAL2ydcYvke3uX4wLoV5IvH29 +0nIwUUlQUrnZVH3nVQlhs76rwt8oRIjqaPiT+RlN4GCCTVzlwRqMl2m8jtOlHmPDGF2mGDXCOeJk +6FByirWcPhl0QuwR4md7YrxfUsluR7HyOuTbLjbfbc3h5m1Www1utT9DIjChE5ydps6JSZpI3T3O +rtJMd0SJ9fsB5eJ6xUNfFwzr6VxHAFUr3WQ0EhhR2/4LYExTZcS302F0SEWs48kSQQkrE01PeJvR +/YTa3eGQ0L7IN0TBHTF4PDl4d/Af/zj4B5VVP7w9qFe/+e3qh/81BXz1xqy+eS9/SjmovnrTrfJV +/zBe5sEqZyh0hiIjLBvh4AhJWWKEyGNEH28FlJlsl/F2Gm04lkEXgvYo1OwhNeDocDOhGSgxpiv3 +0CJ8mtOpKREbEzqWGHWgGPVvQrhZaEreJwfAmumaHiWTw2bdykxPrcmxtgYD1hyQ4xM04Zh+Pjl8 +p+fz+BTXgtPTfsIQjLmG1MERdzHlQCZ8Spr+MT8z5XnGnJGW1NUtuuVNy1+k9Z9wfSw35Q5z5nGw +5bmZMvIwoR0T+oIS6EcnTUk/0FET+1nXU2oZt9+Ipk6o7pgys9h4licLMT4EOKTxQTE+SMZnTSQq +oxNpfGTlOHgNPf4314j9EooITxyhiHDHoQwDbZ7IKY2XE/1KRWaHzh9WQQ34LfwG4PdQO5g2AHDA +iUrIvIlWdJHFYC6pDxuRagO/kSIByodKd5YpfSXifFt6F70RjC2h5mp95VR0MzCttVAvlipqGkhR +chRBAoniIY0mqhkTGUdkYQ+xpIHESk2Aio0YVghODTolLAcyU1WJBYYBqrL0B3J1Cy1ze+gNn1sD +w6AcfjLAUBFnsasMPlH1fEUZmWWcVdJnmor+FWkKCsxBBf2fTAEmskizwEmoKZjHWYAhi6KcjLGy +qqLCkIgMFTYgAJVqljigYy0TlKu1ZcXOqXmB1i0HLVAFCZdsb0OTkIjTrSIipD6rClL9ooXVG1K2 +j1oi48taTWfUtFE8D5gDFHXqj9FyU6B6eECwQW439oAyvfRJZGF8Y1qrdmnvMPvCabhSxVnBb1WD +Vj66MYgQ66gDaqwiDbnOVviIqtFKyrZqaHWLZEMaqoH/jawuJhAAk5ShVAkkAJ0AWlUhRJDsXZu+ +sfCkAUaXdR1R3Dq6G9T0iOEuwMaSsSarv+KGbB0T6aGNFn1B7SqKnNIOENShZSXhTQ0PnYy0ucO2 +UXEH35ma1Cp9h7p81FwR9Yq8QVda9baRXvlW2TOK6+g25yz1G5gqwpDNx1ZMJgAyTGvqfoqKNfNY +wEBbxsr1K1kPS60C1oN7s+VuiPu6jJ5lJcybutSRlAiFrOLaly7ieesiuQZFUnlOzxYp5ZKjjbZO +7bYiejPAxGKIrnWIyO6UhbBttCqpcgg/vHYR2B5M/Dr6E2V7x/vUijYLSoVi0pU2dq1uddTeB4WY +0EYDYRU3XSnHfZKjFSaLCnMqx0hlOCiC6gUj6STVsM7H5mCd6sjrgPYk+ksaXeREOhLyoqPkidYX +HbFPB0KRTgT1AKO3FHEx4bCncsgl4g0cFgJSRr0F32evYw2ooI5OU4Nz5wx253XG5ua3aMaAMFiY +j+vm0EJnZ+jL4qbGZngV1DwZPUQWOMXVgjatIr43QU3P0r7sq5Wcyu7QyOb74QoSqKNWyMuJG7D0 +60o2LfwcmhXcqAR3ZWcenW3a6NHcRr3sOC8LHWQfUHsnbUZD+T/kfP/dN7d3A59xSDvqQQz33tUZ +fPY/Xr9dffj59P356oqO0f8pX30t/x3YoU/uSHpawyIoi7mYSQCXuJRNUDZ4KaOgnOxiVoEy1GJm +QUptwi5IsQ0YBgqgi1mGWGoh0yA9XM42SKFNGAcWW8w6cMGWMw9fvdmIffjqzUYMBOTs5SyEDG1D +JkKQf1M2gnL+JoyEFNyMlaCeYCNmAnt8I3YCBTdgKLTYBiwFCm7EVKDgRmxF1B1swFhok8tZCy23 +CXOhB8wS9kL1NssZDIjBn3pURjF6JbNVR3Xj2ir5cZvO0C7ERoNj7g2XkSldfXd7ev3T+fKAGTmQ +BOEdfRqsUFfGzOBchJ7OqyPUCY2Xvq7oWSUr1xIUMJn0suHfExqs+DZ9faKBDdjrqc4TNfzDBK0t +sy5byxFUIx9A955RCdq1VE2pTu+pntRakTWXOlPkvYqvi7zzsZqufydpJhTB2cETmaKuaycHqTtd +B08OhtWU6MKwNVSsXUldAmDa8TXjWzMN+TSl19nbWEdfRexC30zsAv9UbdZb7VI+pH5i0rz001J0 +XpT97EwQaZZLqA1wCS1b4THgpGkbOtOXK+xCC23tmE13LVx3FVCkB/DILQijg08ofA== + + + lqceoXJuCydUwnIPBq0UwmDgNSytG2HZ8Cr4BpxdCR++EOg0KoyijBwOocQEmJZlhwip0tOaB0EJ +LFPnAj0LeHxh3oRVUEUmSe7JgfQxwPEa6EIvWC6AoQkeDD0daaHOIxkTWh/knFJQQ+YE5B86Tq6k +cFB60vDHCZU1Ta0KwUYOBwWFmurYWClxQpgKZfvYMhGHvSlS/4hdekzEQZwccFyWB7uOlB9x9EWa +D2Io56jMXvdvUx2DKthO10zqS98VnZhq1feXo7JhlQ0qzks2ck7Lin9Clc1hmqV+otMk9Yuhc5Qt +GHvFtmNH+zWl84onEx7XPY23R45ylebl5KAYvI4QnQ5W4SvdTF0zkB4EMugKUaeYdLeYDqmYjrtD +mR51ivS2n8Ai1dHPcpFwp18KxWRB0n69ismaFtN1L6bIUeS4U6zBrWINChZTRC3WoHOxBuuLNZuj +WLOHijVbrRjuyNi9wcbtZj/b3k2+kEWPVMWUVBQJrzKCUqyhOxldOkleNQJqcI57OAxV+nnVtnU8 ++KLILJIoPBW0kzXH3KjVQqda5zD90DmMlhz9Xqe69WQ0Y7W6Imysax6w/mjnu/xV7EdWQ2qobyf1 +Iu+Nvsz7HGtInTrpZwA+UCXnULainuXdizgzeWmdl0kLg14oJcI72/Y9TW33o5kO2XYH+Hie1kzn +dNLXLM1gAW2bjaboJ2MNNiim9H83NI03ySw+GarAJhNCe9dw1qgKGU0tZfTh/AtoskhfvZkuJTrG +8QjLP8UAFQBHmKKWyHFza/BOjcZD9IRkMcFiFaYm85G2Qva6GL6f4kDWZpE3ugYT+nEUw4FMt302 +OcVw7oo4eWtfr8GsbqkyBOyXdNC7deNYO+K1k9PN3XUmUVVhap10h1DKlBRm2hgcgKDeNh0GDFJ2 +IrGa0kYaT+fQCnGBpdIxo4ZdeWOs6eQbw8NOLap6YDTWImhcdXEn8NhUHaAFKjc4B+GmSl2ipx6m +U1g0UNB4hku2CJSNAYm03pbRbTVQuO2cMRFNih90A2L/CnQQSjTl99G/ou+gQdgUhHUoOWsKczA9 +a3y+Vc0W+Sc1uuMHojNODtJLWqoR6EWiUtYMxI6VgkGqqdHrpubkIHVHJ7BBvzCr1LimaQaTVHnb +aqAPF0OoH1TzUYHNJVPChLVUoQ0fUDvVfwCFq2vLOq+nSIuYNVes6VU3S1nnu2nKxlismYpuorIZ +615rAZdg4/nX5sB4ZHg0WM16iJRFmr8Md4scedvkZN3jeLcFTh62kNjgnA+0kBhhQqSIocOzmYpe +cFM20Ak6aNChOfZwsmZ4K1gZEAURxBrpjMxHEFlR/dh/uMLBJp2tWaJRvfqaoq05bKGwDbbF7heG +6Ohs41aP5rYqBegNHWxZacBobiR5zMjRU5qoAxvSGiXdI2qjBo0RvVHjyIjiaPERzQFwQnUEuAnd +IZleSnnoRjKmPaTtY+ojwCn+EzimQDQajGkQtfvjrccjaEyHvnqzhhJBXz/Z9dDGT6gRdO0TegSv +oQlF0vOxo0nUfE+oEv2TJnSJyu4JZeLCrenlOuqkB/mYPqmGeTpN62iUKpXHVEqh03VaR6kyPM1o +VYbSGbXKsL8Yov+UYuWbaXLEt59faSp4uvrj7fn59SclGQopy5AwKb6DINw/MDjIH9YVB186zwQB +jP3UJENtcBpBXkZDo5AieoW7ENSnr4blBV6xTguBPpVWQ/sDshOI5FfVMRizzrIM8VGTDNXItBLf +yxY2Xp05hQvjTrXOGG5yoQgu5RgyGshu1Whh8JE6bVs/zDFEwFkMjBh9U7eW4WmkNLRgxPBzL9gc +M6iE2PnQ1JoqwtCzE0bHVmN+nPzD+DT1YAOoolFPCH5VapKhBokxkA0gON0CvoZlEn+DS0mGgvo8 +6znA0poqoHIhZrto1GHWOZsczVxV0ofPMN5I+9mstN80FQhGMxkAQtmjx0PLDsPkGPNuIGsKLE7G +qGNoqBieZh08MTXhjcOiCf2tW6+WmQArUY0w2OinaBDOTIzoEhOh30Sa6NDpkQ8AaNVYNeB5JBwA +5lkXYo6hGt6iQE4bY3FCQ9tHWQbXPaccQ6FR20p8GUsXffHYRJG3EftR9B3RnhZ9V+NoiOBVaeNc +c8hFPmbOStFPS5y6Ip+7OL9FP8FxBYpsCbhKRb5McSWLbinjWhfdYieEKDKMSFhT9GgTEavoMSti +n/4INuJsU5mYkShER8/KNSEiok2ojsNaG064bsqYECBGBqK/bpUNgNvKxmHGfcW9p3kHus0n21Od +8od7uMg3MTf64CvSgmgVY3wbCYZNq1H5mGHIeKe9ErLiV5HsRFNenScYSoQpEa70RaJsRUfagB2u +bSK+VFbTCzXGpVQ6oVUsq2N0nkeCJeKi8SZiZ93G9ELwv4k4XGn6lZYZmiLBzvMLhZhgSKY+mA6C +OjQ3UKwDDTFAtm+IND3l30Fv0F8SqdhfYnyb9gBpOgZuYwozDrwmu1WnmenzC8Wpw9xqkh8CMPl1 +202+JWXxKbkDbeVcxaZbRSp0XUzVUGPf5rmFat3IGujRDr6p2+TvXHmnVC9NvWKe7qY2o5RAYLfK +SanTzUkkN5rMReh5GJDkpuI3iWhjI7WDHaX7KO26eBj0G1MDmhvv892rfUinjAnx2KnSptLULR2l +cKSzQ2qiGfKInaQ3q7QJdFvQ+I6VbtAM6FbQAPNAJoykrWn0PK/j+d6mMgFoQRpp9JBkjgulou0q +4ZiSWnLuioc+0mP15M4odlhl1Dwj9EbIiJLyoDhtm8iWBEXpMui4fUlXeWm/bjqmhB10Gv8Fj3Ud +g9HpDbXsMY7Sc3aZV5HTUMWp8syD40qSN51LPRpLTm0LEsOZ1mSEo9N1dP6Oz+fpET4+5cdswJBT +sIqNA2ZizG1MGZIxzzJmaqZ8TyLPiTon4pyo7pS9GnNgYxZNsc9FdLSaXMh4zQFFokA7sE+MYZdc +KJIUkpwyxGdSJOU7SZBItGJCA6XDiaxFqpbIXqJ6iTL2hDERz0Q7E3EdUd/4eDxmsOdYktug6gxv +G3qAVIJ0NVMHwY+rXZddyCIxVrQkp4cimCBrDekyWNcc2iC0d2JLFrYytMwcJH8r5q+QmVKLMcRI +/BAc9g3My7IicN0p4X8pp+IkuxAliLX57DQnAJFEszX5VZFyjB0zn51rU3LBUGs+u6rLZ+diPrt4 +VBjG2mk+uxj+j6D7OkuK0LphjiE+H2tCu5T6zzHHkFUJ0jJ3VYgZ7bq8g07jADUShvmvXExol/LX +DVMM4fk4prNz+Rd5Nrs6ZrPzq87x7Dims9MhN0yBFzN9xXx2mgysyxgZI0zzbHZNzGZnVzEB5DiZ +XasJhgwTXmrqsWaVysZkdm3Ma7aKaVFjtEVpUuZUm3KNuVXMZdflTotJIjX/DbOrdR5Zlpns4mlj +m5Q9LMREjy4Gp1pf11nkMTPZuZjJro2Z7EzMZBdMLMO0gJoqLmhfWhMz2fkwymTHeVNMZJyVOqsO +U9nZPpXd8SCVXWm7ZLtdyTz/qVbOXHb1qms/Ji3rOshcdnaVjYG57MKqH2WXyi7GXzdgsJl2TaN+ +81R2TTvKZedHuexieiGuGJFs1SEUMczriterbsEzdPImxDR2lWKXD6M0dq0iouJSRLuESVkWO9Pl +sDse5rArwyqhPnvZtDGJXRpHoxuq9hqcTbqgSezaVbYDY7B23ICDFHYxg121Sjs4TWW/x1Nq0UQG +mMKuSimNqz5+vCMlWaYhQk6Y147poCKEBKpMmZTbjob1JCyRuUTlEh1MZDCRyp5SJmqaiOm6xHaa +bqjRPAB4P0wZ7ZphyugmZc6rKw3Pz/rQ1NnOip3UbKkaGxzHoSlVNR0Ph6pJV73p5iLPNxQnkMlb +Obr0zXgRYpbLkK1TMV7KUd7oJA5muFCMkKUYI1MkW22Gb8UYJYsxzhZjpC7GWF+MdkUx3TfFeGsV +o61XjLdmMd67xXBrF9O9XwzIQ6OnUpYKs0sXrSQGniLHKV20IRWqU2AwnFsjlSqmdEwP66YndcWY +Fg7SRcOycZzSRfcUtRhR3CIjxsWYUBcZJqfiebro1EbC5b4jg3TRVejHU+QDimMuskFzVop+WuLU +Ffncxfkt+gkenIeN69epyBcqP1er/uAvusWO6NCfzcXo+F51KFX0ODVMFd1GZK2dj6KprWJxunsz +U3QT28gSReuuiFqBrGeNDxnXUiTiXeS7Ke64It9y2qfxti2yfRt3dv9N3PsdJ9YRiIxbG2eJDquO +0BQTapSxhh3J6r9KVK3jMDvSl7Ghmii67lnVmCg65QRnK0wUnfA/KJIwhNz1fHFMFO1XxYiYF4ma +7zMN7TMN7TMN7TMN7TMN2X2moX2moTGS7jMN7TMN7TMN7TMNbUumIYRIJofegUtvBTsLGPzaNMhu +cNXDEPCpWiQGfFIegclEoyxEtKJAYymzqfVfMEiF3RCsKraZ8BZSSLAhWtz17q+2cib5gyjmySnC +tLq9AzdSzDK9PM4V3nITYPHvXDVqBuMzzUCtC2msjWmfU0C33gaA8FzXXYRkmS4fJqSyjpEgZVwb +QxEZESnWqKaFcrt6KdCI6dSMgfWPkWmyEslZIQab+z7tiU+p7KvYJ3zO8xPhLCl5fqU+YuGQfnHq +xBPTCrRSV1T6mIjijA6m2FrF2eEqqY+CiUbuKpQx4NrFawqgSiBEg7gTRJ2T2jImyNWv2sM22hWS +gSEctk0b45RDa6MfVGtcpJ+eG1DGpPFFWNY6eOWN6xgZTQgdrjiF2TcyNzGFru56JGaIFZtKM1TB +IljGrBSe1yE5bJtok6/oZyJT4tVDAjY9XTdGaKuJp+FNE6WGxqu7Kk0wJS+BqU0PgaeCSNdExwiy +VLfYviIHnKpTY44WvCRHxw55GHp93fe5Ypy5zQdWx7DtbvB1co9M8wONj4kXVsQpbKhtdz0ogHbE +ied4GcMZUzGkIZUknD2ZBC5oS1j3kuyg97XrAbSrNulWs/RNTEhQkYuRaajKARoKyNJWApAh0+JM +9DViGmMA0gaFpkr18NaG1EygUpEGBABaaMVMzIOtKaO9di1LGF3FFP8xsF0TW2TZooOafFVXlL4o +ea/HSl0rNMt/ldJ/63UyTj01LX1bNMm/ie5kJFd11N93ABp+oydIBCFFNNM3g8QjyUNK9E8AiCZw +pyqT9a/EweJI3+LoYr5/EqWUj/+MCf/VcSnL+G/UVXJNfuizg2KQND0m/fdNVsMoD7VmHEJXXDI7 +1kFzojfRA4edHeW85oiKybCZPdtEm6cSe0zfYK5IVqxNpEa/CjCkVU2/DMjp3VRxuojnSsaYAENX +U/Xxrox3Bdoqiv8hpGclmM65/AOl7sSopsv/n2Ndd5EJUZUOxtQ8xrQWTOcyyooe8z3RS14V6/kl +AOrBFvOrx+Tr3Q91s+ySr2f3ANSqKc0uAojX+5HZOjsYdCamY0eHrXY4vwtg1SWZPw== + + + O8hYy3QNi51mq4+J1JlavTGpOVkZo5nv60iufKOLLMsYSbfyCIIuTRyeTZ7wfYr0iGXpTpQO47uM +/WfxVgBO/vBaAKC4UZf17qKAsiR5ODvoQS6db8gFUsGzAId4qTtBb284VI5INWWlZwh7mxiZjm8K +0KH71ZSTeiiHVhn9JaZx+LKOMFtrHD6S52DHB1uW7Ldw5LgR5Ierg7rRHCvjDwWOBDvpy6OzmVUe +3VulqQ2cQF1WZRfGsSZyY8pQZtBlLGUUuZYzlSpDbcJWapObMJZachPWMoqxi5nLKLZtwF6i5EYM +psZEbMBiaojFJkwmFQobsZkMDFnOaMYAzuWsJsa4IbOJ9FLL2U2Ekm7AcH71ZiOWExL1Bkwn44qW +s52MUVrKeEqhDVhPLbWU+WQHF7Kf1NUtY0ARbLUBC4o13oAJBUYtZ0OBvQsZUWZF24AVpeJoE2aU +xGAjdpQEaCOGNAaIL2NJlcQuZUqVom/CluopsgljqqFwm7Cmej5vwJxqerJN2FNtchMGNabXXM6i +ataB5Uyq8kvL2VQttwmjOlIUtl3k/3ewVWmmyjT0KzWnaTBSrbFojdU7EwPPdeuUiHZ8nHSVpLYA +Z4XQSPRdmSB4MKtHsvrhlrwjlcPBWDQHJHL5qb+j8lA2XaMXyUI258AOrx79rsQ1vth3dHdw2H+q +VR0O6HgTPl0OXmPiFarCnuiuCaZycK5FSllBYtB+DdJmg+Nvm9B/dnQ2u8aj+2v0rUy80KK82vtZ +9TUrG9XLS9aWeSY2WF3a4JavrxTbZIUfQHCy2iZjrK+YtqE0GfctRE2Z8MifIw+kGTLxtst5iVzC +8c7SEOOBW7pi2nTBGrid1qrzbCS8Vo0nAGhuUuHxar2hlBKKUnyN1uivgGNYenbrIAkp6W01oLf9 +ZW2DCzozuk2qXg3Iu/wiw0gQlgMABqJD2MDqM7i5jt6EdcMrKOVbE728yTBTMHHREgIxbzLfG8nJ +DYImoqhaHzIfigy6RawL8B87BB1CGumgnRx+ys2Xvjo6m1vf0X31VVZ9MweV3r/31iCdRuovRTtN +JbwY8biNlqIeqcNy5NPsNIvRj5O0HAFZbDkKPkAgOjUBMoxBP3HVJ9wKDCZXlpLqhiYSpaSUYMBT +lfRjHo4UFVQCVWImDQC+amI8XwsOGMNESg71twIXLUNiQgo+Y+RSxqSGybCkSylTQxQLeqaGjE8g +q+l6/qiNWbTP+hsphxdShno1YLNCtRpqCkvoAuhmqdUyq5M9jDKoUGZExUCawgDVF4zZqJHyN8mt +XkVC5uaYTPZG1EEaqdq61T0K/QQF6SDMM4WuICgm4qngCI7nBoKiG3+LfYxMSv23yCs/t96je+uV +XaPJhwcVP6RQm2BfluNqAf5pqcUYqMWW4mBqbCEWKnu/FA9jqWWYqDO7FBcfIhOk0rWmpHeG7rCg +ivAdhObN1cl5GlEpddILAssYxtJCflbHR0viX8shYGJgLVx4cRokXWJ/vXCdTBLUfgENKE2yM62m +vaCugKmuNfwwxOgKaD2Cxjeq6AKukdEVEFqDWU2GtOFmrOHdzn0gM0lXeREIWw5c9oODrzvTGTFP +fzX+1JatftF/y604q9aj+2pFPCInZFDrA/twurwKXLrAKm8vXuLU2MJF1mKLl3ktniNrk2z9e/M2 +fbY8Mh9+Ob/7rQaFauLN7w4QBi2EjXKsFxLcUhJuEW7dJZc5nZ+d29YII5Q5aZAalie6UMpGFs5B +Ixrla1sjXsTAfKLqprJufAcg+072I0GYadLi1EgQ1iocW6pVnpkGPbZ7jFOCWdwrumVqHu81oGF3 +T4in3zLIH4oSau4d410TxKoOHxxTq6mqNbaHGq+qe2bMP28v7r5oRjU0wzY0Is9qHBdn7KSHQHtm +2Yre+N7oF6nV9KyyBfrVfeFHNfhhG8eTsWIOHAU/m42/g8TeSyHj6368wgnq+278NfI+lL6D1KMa +6lEb8HZVSD/+DhJ7n+pMo0ut9uNP/UoQN6rBjdo4nowV4y/GnbvKQLH/BToDdj4NsJjOQYHuVBma +FON5LMbNa3DeaB6K8TC6itM4i+lUdB3svhlPZzGe8ePpyDkdxMPBbCRIGgYxs8kmg6g5mAtFzZB9 +4kd1+EEremQDkk1EgqQRpEq7McZ2s2lIXes/aUZ1NINWjifjjZ7RCAKivQSKEi/y0xXTNJZeVTQp +MyLu8tCbKCgUap5QJjyWZfRq4+ogGA5uPVcnC4UJt9fycvKuJtzhY6CID/EGi6KBNaMNGrBTk6WU +l7ULmmzYlcNH5tgwPaxAOw2iqWx8qOMb4J/FrVMleMMTPtmYqK+rx8XXaCf9JuKqEdBlpQ9DFbAN +hSmHhthDJUXP3tbUxOPhlB6D+mSdv4Ivkgk69jSekuylaViq5o0MiMFjBkZU3NAYaFomZ3VRkC4Z +gp717vgg6/3JgY6t7iDZuLMJkULZZJ0c5POYauh6mg8EA4vHLuzkLXOoCX6RD77CRFk69yJphY2H +E/LIIN0HWCtK1cB1aqYjoGQwqq+6UseakjkajKzjpkFkmaUFtMLdAW7VA2okjGhWfaFGk+nF4At6 +A0S7ChM5t5DGBCWQoIj52NUc3QEaTemSyhxnYxU+zQXN6R3kLGf2AdlxdIDoIZDcqHSZzNFxPJtx +j5VG/NXQPjhNZyd7XmOKCMJ9D16FGhz2yC6TgTzyQ7S1em0lIAQaZtrs6jJdIFxqMEHouOWZOLj/ +ygvvh+uc+po6SNZgB+v61dWU+j4e31mKy7jvUpejm5tL3uri/np6d3d+e/3769MfL8//+PHi7fkH +vdTF9le/dB/9+/3N7d3ff30f730RfJK19dCMlcpWe6ea8N/97fz08s+nd7cX/5bvBpW0319enJ1/ +f3Z6eXH90x9vL97+v+e/xuqmLf5NmNEPd7en6H7f7mIu9uPl5fndqlgdnZ798q/T27eaD3HhLTKG +8fZVTLhsEVXKZ3qxrxIoPvkUOogzKiarrVZdwWL4eWF8/AXmKv7k7sk+GtbQldMQrBVbGfRk8GXq +/HE/jvmXl6zgv1AiU5FMllBN3HA1TZ0rZyUcCijapQdodysR60INqaj97FeW6GStqAmOWdIw4JVm +6mRWqW6S0hSt0rtURl9Z101Ol5hYXxZZmUI/5uL2S9u3V+QdicvaLeoqXV+gLijEJP0VMxzzN//r +n2JrfhUbo2hYxS/iB5ErX6kEEF+kL7UoyHzscFd/10jsxfFB150N47pY1VX81TWhYNtZuPHzMuVI +XcUh552J9lr297L73Q87vStinfEnPu3ed0Xit2dd/y5HInXtu2CM/4jxGJ2ou/qJWUnUc0QXjDEj +eIr3ZhhGsqhPiN7gBWA0fSsgZU7grVs+5sLmQyqffvRF2Ex8PE6diM9694vpPxhV1zfFAMfUiZOD +cRdTNYWyrmmc6eBEIgtPKzPPaV7XiL/IwcJXNt09DRbPpgTy/NDG+Pi27cp2z0mdzmAZky450af0 +bV/IrFILBdszCqSsG+8vZOODpuPYdbof0JQJFyHSPLODtyUJUeWqNXenxvugyugqxsx7ntkeVvEN +NVmV4boFy3Rqnqq0ov/AVTEX5kNFK6dXWx6dbdzq0eJWcadUjTTFveZtPQV4OFu4bCDQhG/Vkavf +N8k/Mu0cTaY8d+8kBXHcPdnj3P3TdafbQbxkdOYeorWt30XZ42P7SG/WK3taU8WJigTTdATzwS2W +pi9uMvVSnbXNkq9N2/V9yVaLpNWk5OcPb7c0npP7hy04ZcZQWv59T2DXE1e7GgIiEQE/4AN9g/Uq +Akcvh8Po0dMwiQrET0PjTNn9gp15+I6Fm7YrnNcNBWOioVlP8h7Fjj/owgKLBy9/A7GBfyMyF95L +ayyvPmZaV4qn+a6FdbvR3IgZiWFM5iFzyq4rAQcW27Y5ZZnZxtHcNsDqIUFgRkc+9WbJf3S8/sch +t16YeI2mOdQ+XB00vCma/sxVE2ps9AQydJJO11gNyt17QljHRatDiTyH8YgQiRa6+4eOCDAeVcw9 +TJ/D/lUwdaU+uEKuK/VYH62ghzanfaywi5fODo+JhS0fbdAyzKYVAnGzowK8vBAHSN2lSPgirzb4 +UZYNefg6NLYiVy/9rgAxfcpI4e9rMPMM3NW1M76Sz686EBSAvqni7SW8CdpwaUclEoMtx6C+gIYM +ap+rA70Duiuo76FINNRUTEqsBT0kVv+GV7fKgOvfrn73vYi+1z+tfnN09M3Z2cerv93cUYbNsHpy +dOqJsKbnGtjd9b3/pu/9mnKJCK/p6e/y59Xv/nJz97fzs5vbt4L5/8mOqOWw4j0j0D36YOD9Yidy +/fE3f/pj3Ct/f3dze6Wv4ihlc7+9+fH8zTd/at9IJ76/+/Xy/E3ftH61cNaywyM8ZOj6fDqOJ1dK +fHvzrw0uaPgy1RGOGXBd8FVLlZ2tSs+rfQy8keowJcqeGTjtKqXA5UOhhuamJs8c1GNir5vY6ya2 +TjfR1JFFjkkiBtLXZ2eaLRm5nC+uqPRLv4Y8c6XOgpFnZtnPzzKDO3EGjkSJafYNzryHmGbXIJmi +uYejRRigCWOeC1vjviJVUGePIds8q5Wj2a1AAKcR4PMxzmvY5Vq9TmJuZRqRYsLKBDvJYQZGzXgF +sAZbrAN1JdlAjCONoC6WAtdwl3W6wnfYj8f470amSAjwStlvw5yJD7Df9Jxz9HmwSsJ7LjYEtM35 +RohtNWK+4feOE+Lhoo3j/dtnG7d5tLhNHFPOfn6m26W0Rkh8A9v2VQaSpdblyUBlBPnuirEOBLFK +L5TpQPnyl65Jl9WLOOXyz2DkjbeG9TA0+gCsmsLiEE6mo0qnW99r3m5c6R3Ctivf6Md5f7p24Js4 +BOWja+LF9/KRsYOvspmagrom14AeljYimpSfIm1MunY1AHY9YRzuZJYG0G5sGjRnx8A1c8WwzfFs +renUp4kyBWiEqVofNAxWegcRsq6fRJpZtCrZOd+8EmnmDze3ewvr3sK6l2L2Uszewrq3sO4trHsL +697Curew7i2su2lhndhTrw6mxtNijYl1jSH2WW2sRm/muNfGCq7XPlbWIVKsrBaZWCcNHy1v+Kks +rMUaE2tuTy3W2FvvtbEW64ysU9NkbrqcFlkPe3oz67rOMyNUZmZdM5h1BT+PdqIKuL/S7G2tT6qd +ODl/d7e3te5trXstxV5Lsbe17m2tT2hrxeU+zGJ0dVDqFYCacVDkEUPTUYIla+sJWbEY4TsGJWNr +VnANqK8+a/9zG1cNAu8QCttaJdC9sbJFm0HtnEwuNLStIoANN3Y/WLSheWlkXF3S5tHiNnEseS9M +82dmt0ve6QiNEk2ezhIXEiyZzk4yWDJlAlZNYLjnsHFrQcngmRXMQeW9oGRsy0Cps4pFDMItB73s +P0g3D6a+0p5XtiSTcYuVeZ/S+wzUdwC5aRu3DjKYq2rN/I3bXw97UKz4HFLFtHOUKg== + + + pqPogf1gs+Jrgf041MLazW7ebv7RuqnaVFQpEi1AWrNasD7ADvUEIsqGEsqrsZ/+7eKnn/ciyl5E +2YsoexFlL6LsRZSnFFH08tAkR8QQGVvl0kYHymSSVHAdqJdA6O/pVABJr3P5ZNj4MwopQQd0n5CC +9DqVe6RoYzWNyWwpZdLo2AP08UafSkqhe2Vcuyik0MTjbVo7vs6lAoX0XGqC9PIFffdGECx55deB +MoEmFRyCyvtAPWc7GUZnp0g15sJJBOXFzWHKwTKBDUZaTcZOSM95s5TzafaGja8FPblgMhlwiiob +DzmD5kLIdNg9LBc58qFnrQ5Fl8nc3yuUfPHSwD/e70WBvSiwFwX2osBeFNiLAk8nCiQ2nNx+7VNg +GEHIWGz7uC344vUgjerwenG2L21YxSgwk3+WBIU1kNjgybQPTxkUxtt7Bjy2DEy5cyRWXxMTFh4p +2SDxZ/NATNhjTU5Dwh5pEseTHaSs/zziQBeoo2kyOoGgwSEiAF3AxL31kMSdr4NUYwgj/+Kyqziw +DtSVy0Cp8iLxohkoBaBloOloOrlg8CoFg6WIpKztvqEpqItl6uZjCumKse68mmkP7gE+KCAI5nkj +bM8nCQjjQV4NgFnI1nSgGawbWgztGkDWjixGiw2nfE1/PsXLqtB8FriPlYldjfSVDtvNU1gwFi3H +a5JZ7u5kIEKiVt/dnl7/dL5RCBisv7jVAz7S8SBqhB1CJvwEKkJ1GKy3KyTR9bgQKwFKpEtND0X3 +OlVQdDWkVjrI8QFBTQY6OWA520MmNeftjjsVC6eyqfq+wclQ7z3vTKiV24HGrO64nbKqHjzwCuE0 +aoPrRk1TyZHBQ4HvcEtSGRq9dEg4EnMYTFmN+B6kzdfLAx8uDY9npE8fxVIsbPtok7bBGMl/fnwE +2qb0gadaa0scnqbx3ie1msMPUB+vFxeIUKZ3+eFQZB6iDhVc4oZkNS3vW0kgWW4XccHz6t0EKGVp +0+/0LpVOhTtkiM85MriOH2KpqgcV42qLvM1i0qOugq7TGd53LU8G26VQyjZE4gnzfZN1M/ASxAQr +EIrIngRBWaYDSBDtaHzAW94zlWroKsh2xqiXfbvjQuNa8yYnHZr0eTLY4+n47xMve5fiUbd5hE4G +Nxl+3lMp0D+e5I/9ZE4nfLIsx3l3sgF89WbNqAQ4rnHS6LCPwy6OBzQe8XjtjrNu5L2YzN+9wFwM +rtx6GT+dPHXNq6OQNb5EvnLZyx4pFdQwEd+mlyeTz+8lyq2NEmhwrV91YQteql4T28as7o2peC2N +wUVITc7Tl204dAj0EaYet1MNZFBZF+Sb0GioB8uGSq/uFnK4uMGjTRos46WQI/r7ieoxYdN4q7mL +SfJlydxhjC06SW/Ty5PJ54mA1bXCq0Nmyb9KgPgsJKTKah1+vAbw9DEJkw7LPsm62H3QdWlS5AsI +Raj8+v3+uS48Ui7WfiIXK+yEM7hsJzGwlQt4Ajnnm3CIW+1cD1DeNT4U3etUtkDhVC0e5IDKnpRZ +TR9OqskbGfcg613W7ePBIB5lTYUG8qbxyJo6YcDqh6PucMsH7mo2jfArtQ1DDq+GJbXWCCzctjmM +8fWNAHnH1sOFA8jTJBZvWctHm7QsxO6waT43W9qtd0XjDti7Jrj4jLbjmuu1vgkQGSCra67vUlGW +7Na5UrPL4Dnyod3HxbiqIm+nmPSiGPayGA7ieDSojvfsUVvtWENA5Dr1go2avWpiu+2hMby4PEG0 +W/EBb3lpaSqupXtMH/QptjX4dlxT3sykE8NODsdwfDAe02PcZd6rjrXsB5H3jHfF5l0DI9k9nuSP +/YyNpnTc3awLqcdyPk0hg1omrQw7NezTeASD8Y3WqG+6a7mYARlwjlV2Y2S2B+/9of8yjLIbNu72 +bpipFiAmLYogQZxw2Lo2Awl/xtu1EFNJ3Vmo9aIihtL6Nu5U3KGDGzfJ93bbC9YUhMR2W4z98rwz +frDtKhVw4j3genl93zt9Pj4Y7ESAsp2eQMWk3mJd68Wkj8VkGMV0qAWnA3d7pukoMGO+zOZ1OtNI +nLHuSsg1SxJxZLgoAtxgWSjlbLAwWm7h0gxGkxZH9/smy6NC5AYLhIKbLdFoo9WRQ2vHsll7qFdR +WQ1oFxYdJ3YwHaRqNANxDR2TVJ2ewcik3wVfynykwoWWblap/g5wdtAIJfAmAwmL2+Ie7q6WBCCv +FH+n5lPp1L3xAI4nQ5qfAgrGzBa9LxH6rYOUtQitXcNJQW2GWx01FVR8KIIp/SFyCQhnV+p9473r +wmeRzLoJNZoF5QoTSvNVB5I583FCXQOnnwTgERl/p3epdCrcTV98PgZG4Lq7DiLCiVOM0BrSM2pP +v7umU+FiXH/RNxCFxQxV4shqXNnOLHYRJAiXqtd74hKAbTepX/oulU6FM8SIDcvYA5z9EiTYNDda +Q3rmvNluUvVlKlyM6y/6Biag+3mMgT9E3/BV9jRuWSu1o4Hp3fTDwdvVeHL6icPXk3mdzPxkJCg2 +mYLJJPUDGd+iWzXd2R/dJ0SS1hsUhQ8tcTwQtX3AbY8dMT3pPsNXts0hXcHPk+gCVitKCPFuYVd2 +SnBVwggpMk2tCpwGQsNIZSRnBDVZDxcGz2VNE1VGC1s82qTFkjlCPntqC9r2dBlwqzhZskrvf45a +I75Ob0+mBTK9URNftK6urGqOGi2tkBPgRl/3uMBa0LPoj/pGmzKyQLGjORL3n7J7pR/AuuJfgDap +S2zRfl410h9O/3lze3EXtUf/kWSMz3lvNi4zx7XNhYNfVQVzg/CFNW8TTSDIPTXoJgAwqCF7WQvl +hwMrWLXqlBlqqJpsq1d84k5S49WZsw2OV2prNiurz8cHCdIih406diDDEbwsZVPhNlApKy94eTQt +dIp+uG019U3dTi1Y3+4j1tI0XS28ZjY1otfMdr040TtqDa8Djz0tOBhC4mB4Ly+azUZM0bTmpaNx +WgrOnKv6mSs4vThMsv426S7e7itpV3g1OFjydt0qGycy/NRQEeC+6Hi9Z/oKFSF1TL9Q48U87nwu +4wsZWVplJOzxtgcF2FJCxRa5px3bhV+dQeK9Y5J2oxMi04YPnA3pAzqOhsMgqBlSHXrLCq8mdeMJ +SZBj9Q8MZZt/VdMNigBeDysAvdnYSautJjOU09wY9UcuQ00vSCQvBQTTx/nUw74Omv8Qj7Qo15W6 +kx4aWIVltr2VUalM1MikrnCEVSZHOLDH7C4/8fETXAnuNckRawHbjDttFa21Jb0aN6J+HagIZVdN +11V6gELz14+GI/YmHzJnxfezgnlrmmzeJst8PF35+91bn9hjpMIc8J5X+etWHlcB87pX662KINt1 +3ev/OL+k2zzJ7rdPQHqxs22j1yTV9JUykDhCSz/OgHy8h3rJMihWyf9DTZIBi3GJYlwpbgyuFG2A +sLjxOgG651SmL5KqTbWmNtkPdiODjD6e1DZqbtydaY/fwY27xH5Pf680rypy/YHIy8YUtosiJ1FH +O52BivHnxbhG+Z7OJfJ9wOlGshEBRQfh16RxfbFUddHVnRou2JmCvQHMcmGa1aREqi2rdtL2uHfT +AXAfI+ihdkohvXN1vO2q5CTIVoPHkk/59IPQAupveG5kEN4PHTMxJhiudw/III165Bgl7Wzp+0jV +UV3rdNjD0jv1/BDxy/KHmv1lhevG6CthxgMvj3ewchzzSntHggcVknDO6g+pAjccBjg/DiqJmlnj +4NMNn56URw4pKxxd4AuLHNZWTdS6EKb7ihwdmH2Lw832kLMDw7PJ9CCR81pNUooQvAbWYayhnmM6 +XAdvRdcQQt5Cpq1kxEcbF7wDBBwPMjFnBx1IVqaqa8SuxXEKTaQWz4B5snQYgBDh9IbwpmxbXF0v +gmkdeGs6zsnAG8JLqYfTYUpT8UJ23N0t249XhAeGnkAF5K3hxePOe7YD3/lG24E7/SEcLjmJIr9U +KISzhecOCDPuQZdPq/5J9nqFsRwfZKAQfKN+uTI3zRAQKKkfqnpQNgInVhafBmnpV20R3hciGvq4 +4LjKHMslE0ReyTCjKf3icDs7UNhFEb6XNg99Y2tqgZpWLziXkxsAmUC4HWMa2uDRDnDUlRxl3cDZ +gShaE0Uxoa4HhDjpLKQgtFAL4wWX00pTsbpWTvrJZsQmBV8QyCmhp7U16hYP1sB2IHBTTdUySaCD +DbQHYGHKoEsUQTILQKeuEtmXXpmV1FKECF0RtIQLeIJ4hNOCaGsd3WPXSgeJHekqSD2dDOeMuvRn +uSOe9uUtZBVurs4jq2CehFVwPmr3BQVMCFAryWkpTLdmUG5lLzAKJoJcqSavE6DsvSBwtGVtk7M4 +pXr1mXRkj9mooqYtAxlmmA5W/KJVQHVY2cC9JzJ/2+Qw1sTgHADaNQAtBYDUi/iXvubJgE9SpvNS +y9qalV3JAaiGhgg46QBN380AlhM+ZVNQV6xgzSGsgcCLnPmL9KoWnSgw7A1tKqlL2WejXj6stvl8 +m0SO11pY/EqOZBwcHntc8yW3pm63cON8d/vjqlgdXX7k9jFJi2rmbgvKSuQ8SY+vOoizh0oqg17c +Q4dnEuQiAxX8vOo/7wCpRpymCSQoqUd/rMAiwsggdij9OjsYv+t6GAuPe3w2w7Dj3G/jBwiEMB7u +IvgXwalkVhwO3Mqt5PxGUA/0JdD9si2r9BI8qhd6xIs+KI3ito9GeutEFuvNO5uo6Wb26fPr66IW +00CMHU6jfWwap3pyGfzQ6ZO4OMBDIVOtdYHxPcLdIelbAokwdkhOB+maW2BJAgjT1pJ1BSp1MKF8 +RgNmWQ1EMpwV6QcRyZRU5RDAknVfsn/uak+g1INUQ+pi3//jbCyzLIvQb2rYjfc0/wrb7PSSGeGy +mzXxA0K/jfyjuJceeMmMkCZ4+Zogh4AwTdOo6GAbR8uhL8GySrNVwJbpPSloVTSgcHKmyi6rWz1L +eX8CZMUGVksXn2VeqsCpkrqhZuoBce6ODxKIbFDVrFINEMKaNHf8dcyLM9q6CR2oYOmqL90BshYy +WOxGV492M3U/qezwXEdUs7xPIidYwAOZwiqHZG1FGBREenFArMOBV+Z40q9jJVlV/y6RqFQ4PefT +1YFiL1IdhQaWuFq1hVQUbhZNPWn1KgOmro273g9Lg61Ho57Oy2TyWG46yfka6LgYeZ2NejIlkwGM +jYdNf6kC5Jm6pzQQ5iwN2o4GS7ib9zBhu6GZpbcug1o6rTO8rCF1JIAedkL2s28sfKBtVksCpKbO +DjoQBM/Gp9hqVIPQbUPBM7XVQSifaIf6r7pO91VNxjbnCDT+IeINcSySGv1Z8HaD1tlavcv1lpaO +0GC6QzbdBtIlI7tEui19uuY7wrwKW2CbjXXRP0Ujzw+ToZIA1ZuRDc4+akQqDVVWTweIjZ0dZLDu +po+uojapNFJrEaCaqNil7qOu111F47F9+nTLOSPUv9IJTw+aCLUWIThYaKxLvZ4yzg== + + + uIbUwswvbE/F+IkO1CIMq1FrcUoRpKozaJlcqDqAzhTEqeybGAff1xIBqaWzgw4kUnoVfXa1FiS3 +LV3WUgLo5LI3/Texv30tozF9+sxCHYLAD80lEh+QSwTqDsS5lVDzVDkut3AlKvViHg2y7iDYtFaY +i4YESTGOmjYf4+c7AHRhLrqPRZDs0zYYVYLGejJQbIxaqg7mqf1YdVWJ8FO1LvTNJQC0o7FLCdQP +I9YyHtenT24lMiautuPkpgewJGAieCmTMOVoKicUGf8nO7rROLiS3lFXPaSNMSNC6qlwLRgyF4Bg +qnDqAJhpTIbrQQbiNeTsVEsHiA1xdToIFIarrhKkS+DVSKmhBIDmJ3YmgfIBsJbxiD4DJYZ/n0+0 +OD4UmugMoj4vvnIulzgKQThvQepwxtQaPt/BEKNJv0IotduS6mKjPHSgz5frIYKNrVBdasK6rwzU +VeAFu5o6SGoPmz3BhIQ5G7gYsSaofklpuvYS5Oyg71X3VdfzrqbJ+D4HBcYZWicKrA+gwE794Hhr +jAfzf++h50RArQ0VLKZsKdQkEPT4Vu2YddVSR8mTA+ZHhOimZ2xj1eEniLpw+r6KDtA1c3bQwwxu +OXKrVIvqW9TfgA11gLOD1JcO1PU/VjIZz2dAZplDE4+5+BupVIIcqA7HnLHwMM+JMYXGEdFAxjK/ +ojrA05AlJ2Zoa+qVqUm3sCm0MSgYJ42QIWU/Ma2QFI5xZyf9MDuDum2Sfzwcm4SSCqBJJIIR5Gdw +yVCOAybghhnWNDFOGw0fFvpkrJEU1H0gS1GDVzVMOeLVKQ6WGNwzxFtvRZh3oW6g2WKQIA2SnhlX +eNkUWYFDp0r86K1F82HDD6g4Pubh71o1FqZtzdAzwgMsJMN5O7s3dKhSd7iypbsXZpG5PMoWxjiZ +Nec0wLJOfwCkGyaMEXD9rC1S/jQxuIhZd+qYfqcJkQwHq/uAQa9y4FUQ5nSfubbSyCIvqCEzCeuK +/BLRsFpTtqkDrv5zcPRu/GFZt5r+ERORvC982bbzmoXrHNYqVGqVEAndri1ZA4Gc12D3NihlmNdj +qonovywERrj+4NvHUgg95te1aFme5nrlppE18DP95JKGaZ1a6UEEfFjPRDNWTyuE6jmYzQq4MbbY +mvTSaX1QQ78GMFNnXlFRX2Jz1fA6obJDiC5O9WOpqNb4JIBwCtTJLcfB8ojnVs2AeIbHzBnIklHX +JZGgYFfl5dvKK9MyBIN2TSYQN0mQwOLkYWoBOeLIIldwBMfGD9GjCr0l+RBKEBnGlKzTYsfXkT3B +EEk+grIwNUoDgKQOxwekDuAKbXSKSQwRNC5SZDpzm9ELhCDWLVGybWv+pZxQwq4pBLSpcREEFE9G +DqwKpUIkG7CnkQGrSaFpP6zp5YW8HLa1kdVsDVlNj69kl4FuiKxdQZCjSSbIN7LP/JrypoHPTNtA +oWFAKCHXHSn30qjxRqYZxpJ5bYMCVMiWRJMmCATSo6wpKruehy9l6dZ7JR5zux1l8Vp1fvQi/TTy +sdEqPY23KDC4sS9PRZpcmyHbqbHRON2qtrrSJEs4mF2jYhePc3o+GjrKaQIVuIGQztBb7jC0hk4J +TLjErzTRo2NuBr1gknfaFY78L9USFtoM2gkbFSVNrS6McMEM0DnB8Zuij5CfEBo1rQty0rOUvvbo +ILhnGNJ5ySu2l/A9SeY+A0sUnHDc4HcoeyFzoLIu9CXAM3oP1h64cAyzo5y2mlKQOgSrJcFuNpU6 +EAxmbmMiUsHqBrR0DQ82Y5y6B8rWkYGX0JpjrNLYIUUCFVD9YdStwehJd4XShaBZNowqAkSqCNSx +GKRWqOmuL0e6hXGZOkHv4MTariltZd5KddsxTo5akcob+s/D+OXqJLWW7byGj+iuVsJvXr6vvN5M +Mi6HsAbfIqii9JCDWGxef4XVLmFiJdPSMlTtk+nG4oV5kqtJRFYqTfnSVGOYw10N41SVwZOFufrq +0CpD2gRHOaWWPUgRjKpc7CfbqvaMumTdYqZSBzF1qQLHyoorlXIA8F4LtRC5KdtZ+uswi1PgzUFq +VIO/HL2+aNCu9RM6DaquNSo9g2Y5LMhSBOVhVRsirdFJDFIhL8A6I1mjR4EgHPTPhl8ZeiB6evZq +ObXk+BiAruSQIgo9z1Rt0plXGr3DczqPm8otwZEl1tvA498IFTz1DMAEr4Y88DzxyYRUYAqcKi0E +k0mojadDvUy7UTWtBxmW1ZKt3Ao70WqWGCEGNTPvyFwFCKJ6p9ioNG4COqQHXwglfjnNVQlm1DWM +vbIyoHVF1zV8pGeTdXWj3lrG2bVFZWemPDPom/Iu87qst+C2FWgQp8WYTxZflq7O0zAfroY34cuS +EXiJqUeiVRceOiZVZCxw5MsO1tBTxEro+c5dDy93iDFqfiR5kdOYt+QGoRwVn9W6FfUtkIvh5iT0 +oobClvoo71VPRZ2IRmY4+vK1ulOdvoHfpi/pIgrmxEQDFmOdHbwlS92yUePcHEaHP8AiEWwUhwBp +K6NfOY0RKRFmQu9fpU3HdIpVFZecrWUto4CqCJ7/oCJ15amMGU7cxsyGp8/jocaiH8IuI8QImcBt +Lfy2KtJkEqRd50Ov5GiRXEsIhoW3F7wK4KwGKl051RiAj7I+Cv04IH+gMdrjnIYo5tsYhTspXDtw +fNCVVjVMF42vk46jBVVykPVxT8WcVo/UVGQrQ3HPlsasKygEAEKvquWoYDua212hEIKlUCLSBFC2 +Zfh0TmPZqjwFgYA3c9m4F+YzQN+ZEKAw2QUx8Lptood6VUWtZdXE2K1KfXVFemzVmcLCdYo+45U6 +xwKGo98jw43Vj6iBhhszv9ZP6jaqHFqc19iMTGlomujLCtNWS2qA2HzqpOXT6IDNcJugOeOUhyn1 +xjoQCDq4y2FDqmbhIN9GX3SRsuE2C4LR0vCN1AjMwaxOyJZqGkcADIzHMFuU5DLoLlhGYy88vkHJ +SHXGk7gxX8FcgaX6eOJPSyV9C0rkQ+2RxA1cfoixbdGqY5sSLHodN3PMte41Z5MGFwSRuw+phQnC +u0mVVmUT6ImhI2idQF1Z31Pa0UQEZ8WmappDhlwd0VhQw76oug1y7/PaPsIdma5pyhCVG97dVxSs +aktPAUEZea8yysx+o7gUpHYj8rGfzF0sXKMnIB5MIyGc1UvLKAPNRht5eMgf2OJQYON0lX1Cj2Ln +4z4WLBGeQA16OMEtHZQYIqJxg9yIuJaD4oM8QzmKwBq1qQojgKgJXCiiagAy+FA7SDsaReJjtATk +RPxtofVyDGbiwU/ri6vAvzRMrw73r5oxm60BOZAzkIYNQ/sH6I2L8VBCAGtQEFdqovHykBpNOuxZ +upFrvAzjZ6neFWoGokVjChRgUMcKvRvP18YcRluVDG+smO9S2mw0xMaAXbPCzghfj4iBNtiolFZ9 +BqyCJUMNvEhRK9z3ab06vjmSf/LmDMFkrjNX10o0ELEIleYKnn9CfOXInxYWjgC2OEhZVmi/LswR +59HDDAJTmZfjd16z2PMeHAdiTkwTqFWeFqwhIqYEBFAvHc3tLuWfgHmSsiBwvvl0LmP5yjyJQqNF +aP7cxPFPRCw69/H8/pKWrjkx1IGOXR0IHla0ZbcxTkwONubTSD9Vsd5GDwqCCpb2Xen+OTWgMkOE +NUk9EKtBAAQMX2X/k+FLGuoWIX2fY/HJIO7dx40as2PyRJGqmPUixAkR6UjmVA61KIIJQ20RCGgn +WRUpYMHG5OVApAd5dm9EhcSH2Do4adnjLmOIofHROjiy+AdKN0KbfBM0on6YVnFh00dLm2ZpSmdq +O4nb7x9DfdjUNXWKSBlwBirBG3UDZNJrgpagE6+EXoxQG2fomIVfT+T5n+XfcE+Tf0PDU/oMruUT +BaggO8YoQEVBnxCggoP/vgCV7N0+QGVnA1T2sSkp692zxaZ8YuK7fYjKPkRll0JUavtgiApcfUYR +KgA9EqBinjFAxcwJUKFb0yA+JR/YZwpPKeMNoemhC1Ex80NUbBY1cpXD8hAVMwlRqVbjEBVbfqYQ +Fa1oEKJSrSYhKmYSomIHFY3H9plCVGyc8vTQhah8aoxKM45RaSYxKgy7HsSoiAA7jFGxzSRGRUCD +GBXUMoxRaaYxKs0LxKjY6BadHroYlepzBqmoV/QgRuWzRagM41PY0u6Hp6hYmYenEJKHpzAdzLaE +p7AzeXhKGkAXnpKP6DOFp8QMIkV66MJTqmcJT+GYh+Ep7SQ8pV0TntKOw1N09rY1PKU1ifrqQwpP +qc1nDE9BvvVtCU9h7vdXEZ5ClHk4PKWZEZ5iZ4SnRK6hC08xo/CUuv1MASpIGvWpASp10IN+SyNU +Go3Z4KUdD0aoVF28h11TNkWoNA9HqIR5zT4UoTIo+WCEysM93keovHSESqOM2m5EqEiZ5QEqjXs0 +QAW8yj5AZR+gsg9Q2SxARaZmGKACLWceoFK29TRApdwwQAXeVYMAFbM8QKUdBai0kwCVNjwcoFJO +AlTslgeoNF2ASogxG7wcFJ76upkWx6gMyqcolbA2SiUkWbU2cxtPcSomxanovazTogxVCfNDVUbF +GazSpFiVz+BBuo9VuT9WBbvjs8Sq+HilYBerEnV6fayK2yRWhXzDKFbFlpNYlWYSq+LWxKq0k1iV +MCtWxTweqzKYxxeIVbFR4WE0Xe/6kBEbUshIyGNVWCYGftwfqgJ7noaq2DxUpYqhKmUzs90+VKWO +oSp2fXgNQlVwF8qaUJVHehwjVep9pMozRqqUZhirYh6NVfGjWBU/ilWpJrEqdhSrUj8eq8KLU54m +VKV5PFIlcVzbEqliNFDFp0AVPwkZMW0KGTHtIFClC/yYFo1hKsJYxTCVSCEYpiLkX8NU1hRc12Yf +puJimIpfV5BhKmVIYSpNMwhTeaCz4yAVHFT7IJXPGaTStE8YpAL15TBIhX6KjwapmEmQSjUnSKUN +LxSkMpjEbQhSMV24hjOzg1R8s770wiCVR9u+P0hlUnRWkMp9/d4HqTxrkAoUiaMgFTibDINUzONB +KuUoSKVqlwep4LqRpw5S8YuDVPwgSCWfrxcIUhG5sIlBKjFapEqBG+HRGBVZ1xj1UZpp4RSjIlsv +xqjUpotRKdsYo+LntdqFqJgYorKuGANUwtr4lIe7muJTmn18yrbFp6gfz33xKdnbT4lPaR6KT8le +7uNTdjk+5T5USvEpC5Hp/viU+9ApxqcsRKh9fMra+JS/ff/9ICzl8146pHekIpAAzux0KetB/jCh +hvOecbAtVxXKe3j4J8AZr9nEvX79J82wju45NqMWGoJ4tSDTZmgdaH7QTALEOwvRle6b1NeukvF4 +sL3WY9UPfz75x5++FYz6zdnF7ZkssH3z29XXvACnxKrLy2yhQ8xCQOnJqEELPjKaKoCgE4CEcARy +OsLxNGq1cjAZ0WZJ15W21msfW/ggRQ9PDBMXCJZRg1OVMBEJN0XHfDRQGh5CdR3ULA== + + + FkEFQniQNeCEfjOGHtP0hal4rSBuWBV45QIeh0M4ngwKXvJcltplA6U+u8m/gt8quBX4RoRSRUnP +q6PxJjSqj4oQ3JEXmthphSU0OTmw6TbeBrcHstXGVPTVbjVj5Kg7x5MOnjzH1WRYHLfyBpf4Gv6l +nxDAlbq0bdelS9+fn96e/ax3Smsk0WenHFCyIwwa8gVSPl0RFKAAp9KVig4YWeGEZaLdA/o2bxmv +zr0N9IdaTH5WuLJMjuVL7giRe+ji3PpSvTHo+yPCVFVXCoBr1gquA7hDgY7/pkHj/FYW5RJSmXe+ +IgVpakNpSQZeUpPCNnn1GK69hFt8E+mS1WsZKAbJ2XXJWARKQLhgDYIZbvYt4zMzKsI+AwrZHnLj +nU1n55JYOok+ae+PQ/kY/8PSURqfsXiIGpksiwIXLwzO/cnSALjB4kix6fIIcJMFkmLTJQJw8SKt +mS3UhAPjH5x4rshXb/o1WboWULFZanoD7NpcC3gzQgPgUKZEaBK+hL6tpKnA29AoEN6T4EghXjch +fjiq8l7gO5KX1PF/5JfShCisPMll8y1kbEOEqmEDo+VWPe0TyHjViAJggYVQlrQ8BqDxaHDzqA2H +lhwqzJwOk8CLYw1PeIqwuKUdiloqBSujJwOzdOEMgg4Xt9zCIAx3ILh8omtUuLjkAgqvsqquO4hH +ElPLZRD+PvBizJoXdnoRB1VD6jRLXbqsltfkGibGNK0LGgHl6aDCW8QbhsLJaLhHgJVtiRgxEQ5U +YSyTgryX43lLAXgJTk5Kvrs6QAQflbMJJNhTeR8z54vIxW3TqNIa95kGvcsVs8Oco8J7a5xOzftC +9fpHzWkIO7PmpcdcaTmnd6/CdbdlZKTsJl9je+tFv/DWgQOHiE0OWpDjA/jsaMCHg4scOBCqnpvo +kJ4WIj3z2nP+ShBY16CPV29yw9DlUi/DtfTJOYbZTf0LG0T51EwQE6/BMaq0lv0TXZarw6ouWcjS +V4+qNY1RVRdEaKw8ctHyPky9f50Ekrerx7tOAGqcXq9ZmqAsq6N5UZDQO9svyXjVjifr+PB9kXAO +lSUxtp2p0Xjue96bVpgz3+AMaHDPewtkgQMCLsvdQn7o7vR2VaxE5Pv1t5Ehine4ziRrJVBDtrVK +SHCS4uHJu6RPDuKeD+oEWhIEE6OteMuviABVZNFL+osBZ70hpS4pA9dtjYc179dUM21s0qG+u3MC +rBFfLdva1Di1oSz1cKeDBqeuWmi/xlovi2uJ1Wm4iL+hl0QksnDmtGOW9SA8LAZXy/6kLcFBSwmV +sisdIlqgJBHCCgViFS9/roQRaEAoRSgUET7GVkM4gr776gB+/a2GgzpqtE8E1FT0Eexvp24iDwJQ +qdNneV0WjXZ1Cys8Z9Th9ij4ZliWY4ASzMYwcvA6WXj9GYbZwanHKxlQXTt8QANvjvU1Nd1YD4hi +XAhEmTaVXsE7eV9MKimmDRXT3hTTLhdrBlasGX+xZpqKNbOZzfZJHw0OvwhEJlyhbm8YEdPQf4bt +aSJeOTtrVmswDMcw5hPum5QG1PJS4pLO01aJ6vjloOyw3jUtZ10bPcyO/NaQ78EYv3qzpimhkYPe +CN3KuyqP46Gg1n6kylmPvyhGlRTjRtbN96C7JwfD0G7fREYPhE5OfUEOISQIwm5jFgnZdlDR1nRt +SZjGsJk2MgsnkKI0Hge3xsO6g3FYT79FpyF/NPQ0IdojYeY6ppKbcSDUa1jHVTN0LimQiD4wKr9m +iLvvnPZPDuDEBzJU0Mu+1D0ELQJNnyeQ82qNSe4/QIAbVTF9NQi205DPvjHqMXFFVdYnRi8h5EAW +hJFIJ9OZOnlA2Y0hC6PFuwmLpobblzodw6lwQjcRmtyAmHswamD/PBKX1IzXDE0VtcSIPBUsAJur +DPIPiKYVhoXZj+G3hoiVdUXroAqVYJtoBDo627jVo7mtwqrUqB2rhl5rqNa+jxdJJ325Oru5en/z +8frt6sPPp+/PV1c3b/Nj/mG1+Bq8VkX3CLMVOMJtiqCbYLdq3kf4DWIxwXARHyc4/tWbNVjOrdzj +OUXmCaYLdIrrJA0TbI96+xG+6zSMMH7NLJ7cr49fsHSZetw8D2f6xAxknyfq46eyj+39/KN7iH+k +P+8a/rGK/OPo/aP8o+v4x3ZjBtKoybSFIAimzjTWBDKQXvbSmvw8VDP5lLwhPsRI+NYgLVTrIIrm ++Xk+U3aeAQdp6eIy5CAtPYwGHKSN3NJyDtKRZ4MD1r0cpP8cHKSfxUHmvVnCQY7GX6yZpmLNbM7j +INt2IQfpHuIg3QIOctjyUg7yIYZxWPM8htE9yjC6TRjGcVceYBjrcswwYiNtxDAikuWpGMa6NQ8z +jGqPb5tmFuM4rG4Z42gnjGM+Y5+ZcYSrrrJw7VLGEfuSLJyfxTeanm/coNGjmY2+ONs4xO7FbONy +HF/KNg5R8x62cS22P8g+jqtdzj7aNezjEPOfk31czsxdnP1yDn7ub+dvN2HmYE9r1IMcVmgk71RI +Ef8mcHouo02Q33Qvp1+lX2cH43fjwlnF8Sf8zAPgNcLQYMoATjijYfCCBGUZ4K0pPF5Zl/wyINTp +BMl9jHfMYBK86twq4RG6JuKP437ks5hCY0jmbOsRSAPepaxgVSrp2gBqMKFzNbAqXS6dHgpyg0Q2 +JNfW5CcT1WJdVUJhoMeUYXd+V87kP5wVGafl+ELQMClqF1PiRlhFNXNjVdYhAfT/RYLqY6l+rzrv +TBWA/C8lzKAaosfUCI5puVpDE4Chb4ThEiEQCxNvahzQTHdQVuRrEY+TmtC/muwxazv2a9TNksaa +YV+LyTdFqrPP72gjIqc0kvpfDtCqmea9ZuBQesl3DmaiknI0HYzh+Wdgz3Pwl+AtgXpnKJ4dszIC +0mgOHUIMY/KtPht9blz3yKlmltiaeaNAijhnxgPR6XTsmIKKAdqxx/ko+JfhfHalYz6OY99EQehs +PC8enjQ1MT8wbWe0Ji+ZOGS6XTh1X72ZTt69sAenFN19eFIn2SXbjKPc081ZdBNRlMpG8JxGXjAG +FpeUbY1ZY4/xQRPFkmymh4J8lZBFp7xZ3ShvNkp3611Jk38r0nbDHyZUzKQlrKgSSWHSgBYlAuER +l1IiNArhSnuyuSebe7L5+clmMxDEsSXAE4n8EVq6ESVQdssVmHxobtBB6sN8xY8T4EwEZaPRwxGC +9IAQGuCFg8ARZs1hUHI4ZBZISICa+Kygs01owfQzjwDqqFa94MFHjU9ypFoE4P90UMnBACSyjt/G +6j1yMCS3rWFih0qTzzl4wDpkcqLVU7MCaw4mF+Ml40SgknSODObqoUAFkFYncw2OtKgs7plE1BO8 +29awps6LqEfdGNKJIxiyAkkwKh8j2SCDf61eexlsHf1TRASvkcCOV0khBTR8hNYUtb7S1HUihyNv +gV50s2GjRzMblcWFLR7Su2VI54KAhDV42QMXYSYE28W4+dWbpdiplGcufupYlmJodNtbiKOj3W8G +TNNgDdJZq0kn9VRs1LmxATWEFyT0rZgTejYaHPFlzZMIspEc6C0dIqmxsvLb+2YAwlceiZKamhmJ +WiQ9karrCEA2XMecCi7m0oUm2eqNsEEzm7eHXepSJn1imhWGLgdN2cjcLPSwAogq7ROAYhQ2vnLU +2rbqQ0e3P2XLmL+6plrZpOfIzvFSUdnAiJYmX9HCPY1X+mLSXQnC3TB2mmdjaTRDM5OSnRzQCTaA +9wheLSWIbuMZQffAE/IicC0kL9IoL6J5cAHBGQSIZXQ3+mMD8LAu6Z43Zk/Sr3vVhL6mX45U1jLh +ex1kaRhS1ZbrSBQwrOaZCs8dJkBxCIzjTVqI0VW1m9PUZQF5j5gE8gfmBBWhWTdlgCFwbdGqxiXN +SMIm5JI75uhs41aP5rbqkB0UCZ9M4GVgAxplhkll1zAfacuo7/LCTQMqMNk22OSTjQPg8q0jjMkm +m+erN2u2D4HjDSTA+VtIeZklm4glRttIYOONRP5ruJUAGm8mwkbbCbCZG6pf7bFlo7H3kdQxQ8ck +xHTmrOONCXyu4N+qtwXwGdbTQBaPKWOwIThpJWPk6wqp6aAC5vI/FSM/gjxIRUrZVRAQDTPjwdUV +GTXX6eCIGCVyGMg+RWZYJwcaQ9sDPbJ5eU9jIFYa5EltWs08iyQyiPThpe3AnXGx2tIyKMUqBBCV +zMG4SWtHc1oLzPHJ/C0WCXmWkY0pWihsEWLwbo6lqPGkospgT7hle2JYFzKBVKofYcoRDxMRrtxs +6CH/NDh/D4Y7SwyvLNQD0IDUmoMY9LOkLWaiMJEjiylH6YcXYxEqA54OMQg0xpA5Zto1Rsu7Vkap +J6UQqJbk9P9n773zU0mSBsC9AHdABgHCla8CSQgPkpAFeYuThLDCdE/PH/vbC+xx9hp7jb3Gpinv +C3jT6td8880bVJUVmRkZGS4jMniUWGL2KcuLF5NRUP/lMfWR8E4IdBklYG5JMdrf2CuLmSy6pBBe ++C5KShe9QiEr4EtSKXzurqZ510Supxrva70yItYQLLPKQ6B6owloQVv6zf0ZEMfC2gYUuqyDgG4N +TrzsAoZVkPCi2qrqEYtvnoKXSaOiWuJX8OJr3AD/DXR0/SN4Rq37KmaAGzN0Dq8r1o6wqh+y5W5K +4t1EJkkYzONPEijKBiWKGmWFnDZP8ziECBZdQ3c/iG84ZNrSeHxIgwMjJpWEffgtPF+GKSYO34Lt +yACLT5uu77HfnPd+KXQHLdA/lb00hzcPo0NRhQBi6JZfHl+BjuJ0q+pnDL60OMbBlHgeV0UhKBiM +qSy5+CTvMzwCq6f/DoFGbUTQygOx/7wPDdKWBn4+2eoxba3nJPHdE+jqCQLlAtrRK8xqZhzJhkdO +ES21QuiOXwIZhFi8lli9dJrz3CkFc6JoUvCk6RgpGT4z0rLmqSdqDrya0HPgdSGKBp/paRo80tMM +eGSka/VD15QN4ygMtA1RsRB1Yxzqx2qkcK3cY0lViTaVeIIWK7wlGkbiDeBel7sT9zaj4BNdYs+R ++KJ9dI2UZrq8cSPz8v7TfRUzwI1p+2bQFQXq0VV92r9sfbKwUjt0wcE7ZCiYhwnVZauNjK/MJAh0 +py+8V0+3OUhCwPtQoJA3j6bUmxnnl6JrCuy/ZTlcj0C1mxfoOee9ZzIJhB5UYZUtrVojTtyx+idI +XOClEZ9Av0oSFzejgUXlV1YMinqGw8LihxGQeogcjtfTTSOmn6cBOfnVEhu6KFNwXHF4OQWsQKCl +NXT/K0c5fg2ZPSzaqKU2j13nFuoapucDEeIcibeIuk0tp26TenWbEwx6CyfouDsSMCruzgkGvUX1 +SNJbVF/FDHBjhs4lvYXUq1qkO3U7Bh2HAokC4vHVWSTMfrTTX2LATGRYdN0C0gloTruiUP2goSVI +00qVD9XX0GvIUI5fCxR2jWqvyPLad26RvqHOTvAcr9W7lRXjJMbH47+wjizWrfRLag== + + + AroRCF6ijpQJBkWgksitmvdp9Ato4FZ9Gh0EGqYaLUUiIl6Q/9YQkaBieeiGHOlRzAA3Zug8L5oL +6jFK6q96Igg4K+BpavDhwOtoeCEsK5MYsNyTNiSGHcYEvoyaZkyYBq9iOTw03HXcjoH10GjHr+FF +aeLJ4xJ95xbqG2ayw7pFHk49tQQo6rYyCWK11gsRIvVVT4bqh64JUTM4iRSherkQMUr6vpYcJW3V +LUHqwsF4K5cjhkoa7GnBxJ4WDBaIYLBAJByo7Gn1I9Ge5vTWB6cCrTzQ2tO2TP7nyyU9pn+FPa1l +6dhABeNyYU9bfulsTzt1am1PW325hD1NmtjTWlrWPPVEzSLP0dKzaE97pWjRniaN9jRptKe1dK1+ +6JqyNTxKb097pm7JniZN7GnSyZ5eULFl4Z+vZ6PhxaQ7nHWHH7EYfozUXfUL39kYvhHwm4v+HPx7 +3vzqtGY+fMGkPzeZTz/9p41h46MzAapxuzMJ27/z45f5Rr/fBTt1/NltiS3ro1E/AVTs8SzuP/+j +AX4bmwI1AIBQt2dt25s0RSBK/cbMsT2N2l/B9A5tWwTC5APe6gNjWzwRkjV+ARb0fHjRmH1qQOc/ +G5PWSJkkaIVAmDStd/4z8xe6f3QBwu2B1hGIxrgzAWyzNpuMeh0wsDhec0AkmhVfMeVYIAZQiBop +8E+IJfj/BIH/i/4SQ5DtRrtQ5wr5oa4p+B/Oj4pc4G7JX9ItrZsyDf4jTVj1n5X3i1ENdwPqlvWz +ksRM/upOZRzDTknUIeCFfhojmfwF/fI6JPN+3iuSV7kDzPYkGJe00xExJvySVoPbgOZ+KuGX/gMx +lfAjdJFxStZsFkWdxYjqGg6hGxdFmA/nlw1Gxd2sUARvTfBzyrhgxA3JczCGCOZHotuYYFwmj/gf +NBvQqAm3o/ZMBUn8RrqKeepLnAxHfw7RH0BmI7ke9ifOwDT8UV8iC+T5Hx3pbSIv5hiWun0wM9ge +0Eh36McN8FOs6SbEJlGgLCRuutNus48AGiHUZo1WbykIXseQa0y7LeVzvMiYpPzn7+/TDhBopPX3 +4gdH/f4cXYYxmsQb4zFAGl4c8FFHRF9IA9RfBaj0F9/fwdqB1vXuDIGjUD/984nYGAzQ7pbu0NFw +2oWpnfJddoXudNxv/IX/hCmfCQxJXDUwkSsfIDaeIFElLQEm/qGrHHhG4DQ5fYKUygdz+wRUCY2k +YQLgXdbcvQgaGB2MJFbjE4XOu3/P7/OHVMMJY2TiG0rwc4wcaVZR354fzd+/5wMYbUxmJiuW63eG +bQ8LbofPBAKm4MqdE1WZnPK5xeBt5pEfDdvz7szNHNRQVr4DIP2tCJ3y9TPX007xj87wvN1GJAm7 +UJDs6bYXscCEKtXLtNYEsrFhXRbkoUIX78EgPRoWr6U4i3ITyjrKA/zNafD3mZIvUfxPpzWHQ0Av +0Ldm8gze38athdpvJtTc8o+1MFoLo5ULIzMJhE+GSHgIgg4fOR4WOYS1JvBtz2sJ9DdKIOpvl0D8 +WgL9ZhLoaslbmC2MKhOqXJtUayn2vzepPN9lvhZo//ApeRJowlqg/YYCjRNoAWXXUeB/WegDTAos +je9+ZRl4lwK8IUD0YLP47hoC5o3AgnPWfkJq7ShcS7UfIdWSAr5Kj6F4dMckCyvdoCgUmEOdXHsK +/+ViLbkWa7+ZWFt7CtfS6Kd5CglRvKyFzb9Z2MDwybWwWQubtbBZC5tfJWzc5B6shc7/bkqGpIe/ +QezQP1vs/OuEBnS8UTwBy+aiG/LQeRHJMwyjic/jeYplcE1pgkaeOB5G87E/6yhpQY79u/BbUsCX +jhOwDAi6axJzXpY1Kd7lkfH+PjzYE7ti1uzqx7GrparHrdnVj2FX4p0JBC3Q8NgHcSt45SjHmF3f +seZXbvgVu+ZXP45frdWr34NfSeoVvN+fVNQrmkdF/9b8ahF+9cOD4/91/Oqn+BD/uaxGYeqWP/B/ +UNklT3xpzU0cuMkPD3T+13GTtbX2I1jSquOYSByeC1hZUkC17Vg+yRC4JCghJFeQ8vgv5V/ruNY1 +B3THAdfp7+uj3R8mDZIMTkOieB5eLIhu4k1SrMnllOsz33/4lDwJtXVU6+8m1H6Kk+AftmvW0ujX +5r9TAk0zqAwsvE9eAIoVKoPHrENd/9357xzxsyXQv05+rN1C/0zW62QI0NgOIHlYcgyW9qBI7BRi +KIZbhyAtyL3Wgfq/G/9b689r/fkH6s80leRhbr0/xnNA5sKghjhPMLRJdeG1/vxv0p+ptQT6zSTQ ++ljiR/CTtSD7xccSqFQMyTAMujqGhGVmkD1CCvzy9sjvQoW/z5Q8SbUfnom2lmpru2otjv454sjm +tg0xTpwS1jfx/sstqR+eTriWOT/GklpfxbsWXD/HjgLv4wwDqBnbTxxFceu7PP7l9tMPTzVdy7K1 +/bQWQ/8cMWRlP8UpjgAKll+6H4DlWJpdG1L/ckPqh2f6rYXPWvishc8/XvjAoAhgwXOsX3biscnk +OqPlXy58fnia5r9OdEAfnMDyhACPeTlW4EkYf8oRBI98b5zAU6jYNQGv1IFPSKV4CMMTP67I8L8o +pNi0+BOOI+YEAkej4WvBKIYhlvc5/T5M2BPHWufg/Y48j2NZkuHQxWI8rJVuduUMDQuqJzFfxBXW +BVQEcF0waa13//3s3+nsgSRxZl+SYUgB/mIIlmVwUgmZZLh1aPK/W7DxPzy1by3YFjtQZ2giCYVW +khU4Hv0gBZaBWj3B0FiM8QJDk/AHCXV5StHq14JtLdh+umDjxJtE6SSXRDdoMQJJEaiTuMCQ5LrC +7b9crq2TPn83ubY+31iLox/lZsPnGwwNlGh0us5ScYIigEUVp8gktbas/t2HHPw66XMtgdYSaC2B +fqEEYjh40EMKBJlE5RQ4IU4mBXhAlyTWAujvFUDk318rkF9naK5F0FoErUXQLxdBBMnxNFw6io8z +vECioonE+nRpLYJ+eMLmWoCs6xP9HWyTphDbZClBQLGxDAfvWUF162AYHrOO01qM3axz6n43hoVi +UymeRsnfDMFAPSMOc8BRUJYUpoUSw4EVDEUejyO2flhM6j9s16015v9FeBa3vmLrB+vPf784++HV +PdfibH3dyT9o661l2v/oEnsYmSUwLKBkGHvMEowUcUzSK7jG/nehwt9nSp5k2g/PPP9XSqR18t8/ +khXbJP/xAslCzxLO/QNGBbGuH7Igw/ql2cqm7OYKwvTnR5NhZzJdFbvRAZVZjO1aAP5z1WkA2oXk +NZ9abcGVs12R3bn+3iOf/EVu8d+XOy2InzVH0XKUyaTxl78ymnT/OxrOwLZ6CvGUfzx7Cv+jdKL1 +5vy3b04sdeqTxnD6PpoMViWiVADdiScZPzPpy4vGDIxhiCQVIQmvweiPzs3rxUx6ir+ZdN77QNu+ +0z5sDNujQfe/HbOm9/Ah408cAT0rNO4OL0bd4Qw+S4rPhvNBfjTudlBHPKXuv6LqXxSpo1lj1nm9 +ApK1gQdMEvLLaavRh2PuTFod3Ic8GPSq2h12TMEVOh+TDn5F6oCVGi2AfbOOKuqOSN0r5bPfzxh3 +xbbLAKFDNdsui8q2imvXuoNxX+baXtR5rMfjPhTA8Dt0Y5KF1i4aAWAmgASth340BNqev9wf/eln +gaBZi5m1mPnHiRmFhu3lTGEyGtc+G+3Rn/FG11zAqEG5NoAQZ2/2hwgnRJxnJf44Gjda8Jn8oNmf +T8xNe5OLRfQ/8H/uGl79AAqmP1r9icjA0Zg/Zn+N/8Vs+6I77PlznT86/X+xAc/+rwz4X4RJ0TsK +1LrPVeFRA9IbF/gaztCO4mUW8D6diUqhqOr1uwOXe+7vcDEqXIdjaQIfOVJJXs2FYC696OnleIZd +jiX9nLOcX5IQaDmPte6yPipFej200xoTtWIfJyh41ZifpFm46WiYL8yzq78TFTPE0vy///3Lf9qY +9lbFPksdwDghvt2xTlK2NK9sJdA/WyH5hZS+loM/ditDG51Bu5iyNNQXMoR+n43hSlPHVtvaObEW +8D9FO/6FVvpichw6N/zSPlnSC6KB5dKMlKV4uzHpqZ0MrekEOUGoOMlJbf7oTCRPMkb8uNFFnomY +utXnaPJfi3WgWAYGP1ICh4Mh8QrAv3qLI36qc4/YuXQ4YATpvTprlq1i2Y/gaWPenz3b+8C97SgU +igQjj1i06kkO3WHIC0l4Zak8Uy8RsOZO8kD2KPlaHLazkxka7RQ+YeGT17PR8GICWneHH7EYfpzr +gP1z0eh3ZrMO4rAXTTfjDD1egQ+REgYw+RxGi3X3X5/+ue+i5Q1PodvP7qwjfueMrgYkQCDr9B0l +GY6lYWRxkuZJmta4AMTvrso5/1WnLX2ZpJNJzSXJSZqhYLqCeojKl/edPnS04o85ludJrZtBzt1R +f4TOQcRvWJ5IMry6Q5JmWIrRfkvK3+b/akifCgKNvBo8T5DwdiYjWvFyiF/m+nMJoTT4P1JAeCTo +JGW6EOpPTxsfQBlsiF+TPMVjpDJkUkDrwrL4B8FxAkIfz3KYrymBdDzH8CLIAxgAXj6gk/7cAcMa +F42k8XILArziA71iKB5d8C5d4wlDxdHFngwJIItgKZoHYCkBgKU5PVieA5hNIrCA82rXmGEBPJib +Io9WAxY8Kh8kCVOwLMmSFL59lGSSmmVIcvAabdgGzx2ARViQwcLRkuBfAJfQw6V5huUhOIFMcpo8 +sHhSutWUS+JbUeIUDVBGS3BZOFw4/NwBm5Tg8hRNaUYnsDzLUFq40CmGaB7+n3JtqgSXgtilEXpp +ES6ASmgGB7HLcdqOMHIFXhRyWqgkWjNA8SqoLMXrGITAJTEuFcQzSQInk4rIpXA+gUhhDAGRkISD +5SSwgHB1O0VgwSbSjJaiIBFAuBKJURjLGC6L1kwAts8Bz0gbkeZQ+gKYF43wJyRJisNbOEmji9Mg +DUgCn4fpDiI4NEgGrhQnrZTA0wIaJA12ARwa6J5HbkyKJmgBJwIyBI/zK2AeoMCpoREQk6y0q3iG +o1H+heIU5Vme0UyZlJZbnjLeDxgoYH7SjElSBgsRiWYIGAnKSGRoiuVUHBaOksO3yIMfhlFycO+T +LC/BIwQeUQ1YN4I3ZWZAq4KTRjNAGIS0BjpgRbAMpno4ToqStimgPQoG5oNtymD0mzDJOMPA/QMR +QINVYtXjJGk4TkEQ4SXBT3z5EAnWljEfp8RUySRYHV5Ze3GcHIDLoOkz0jCTHElQSJ7BCuACjb+m +OQKhRE6PkTYQjQGLGwjtH8icwJAkdNIcjWRIErBqwvzSf0ZhyjBNB7Eqce8QcKODhYNDZOUtCQgJ +QWRZgjWFqLA5iY2yeMmkLclLTJ9kpC1Jg35xsaQ4oG4W7WgCIAAvNNh34vahxThsDIkVACQ45aQE +hyQAg+Aw00XB3UA20TxecMiy4C5FPFKNRvEuaJEPURIekwZmnCSTDF4UgFZey4xlkQ== + + + hHk76Fk6UZAlEo1WhyIlnskBdkehGVMEojugdBCshppkyczhnCjwQ5adSUToAtpA0vwZGvAeAdEy +B1g9/JEEPBMLZSaJuoPoYUUuxOBKDxI+oTiGWZlwj0t7EpZQROvBQv6GNhHPYGZCwWUjZUYBl1EU +HbRacMI7ioHghCsuSFABRTAkHAkgbsQaCEDMHGYgHFIiaJlRiutEYVaPYQpwqGiXcxJpUqxAkWjK +BAd4MRxoUkA4IEhASIJaSHBweLAXhlItE5QTAAEsh3aRxIlplhST2ICCJeYJ8DzakTTeDJw4fQYz +IrmShgiVg1udRKJNoCSgSY5Fuxm0YxF0PsmjQQOaoNE0JMlGS3JelElqyYYEm8w+wZd4PeBmEjjM +nziewUAExNwZqbYHJVEUqV0rSKlIaZCVHAawQ8TTuSQNtD4/1neSon4iiV1xk4J9pSA0CWeO0Slh +kwHaO4EVMXhzOxwj4ClozwLdHK+zOEL5tnYCM2YME2GTRvwY7yRDolZt9D7zI0PAf9P9GEJjJiw2 +sHJdmn4jAgcQS412xz8b+bE54gRL21qBYupVtYGjb69AMguhsgGka26KNGgX+FGAXt89YNOPIPhQ +7XvemHSm/uzwow/MKg0Y/J9HFcxn/9jwCSIXuPiYT0Ez8yJ7Vj8/K/oBD2X9eQj0Pz79Q+kz3Jny +FoAxfIGeSR9QHCJs8D8qkGbdyL2ArcpxpEas8oBytYJWQOIFaSniUTONb2+Q5A2N9F4oZQFTkWQD +wREkYg9AkxQoc2M5KTJIXuQTgkpbA4wA6b1IDSJVcGX9FuhtSFCwgGdpRwwsX0I2OQjM19DQJf2f +QRISCXDAXiXQDE9RNAbEM4y5ssFKgkLAbBfKabVqQEOZRpFo1GDJSXlxsD2iWVDAEAxrg55JqmmS +Rz1QApAsViqfrI4LimoqQaOS8lKTcMs1/kLxLRcfbn0RWHeEQl9WyDgG66E8CRRnJP44DijxaABA +l2aRVBEv99D/ENEPF5aCLFXWbnmgluBMNoamCSxNGQKLamDXIG2Ekv8rGjBQTWYhollpATkwALRu +LLDdEN8FywWYM+LyJLbmaGlM+h8YKo+EB49oWYIK9HWkKrMUiTcCA6wtNCYgbkmso8j/VWue8F8o +hyWRCUaD1pEBKg0iNKBAgN2BVBtR3kuD0v8QwVJIvCPHAPhXoluOxfdREDyS7jSQkBwmE4ARRlSY +OLXqhfUkltaoXjQD6ExACgvYvcgoY0lWbQoB80a6t0X3Q4TLY5UO7SxeEpgUdEUhK5zn+CT2oZC4 +A4XJyP8ViYTAexSqHOBfSTkmgVaAvhPYJPYlCED70uqx0sj0PyS+QiDjHxI1pXgrWAG3JRiKwBoX +sN+0DoGkyKW0/yu5QJDSzVBo31PSlrvtNP35UX8EReBoPpY3H6xlRmJ/B8cI5tYXJd0qIBufGk7D +0bL1SSm2DQ80MS1eObykirUkKaO8pOlSYok0kcKw9YD0Ul7Pc1mKwho4MO1YXuNMtHQOsayNcygp +KmECAQiC0sIDJivgbfCH2orH8Cg4b9owPk9xUsrgKLQPeFmzlexUwDIEnEULdoTWucljlVMkWrXX +ihSSCuWSGOZFTnZaS75pxVutdmP7zsbY4Y3eSC7vanc6U3vx7aLc5QNaTUylMbjcNsHJ4HRHI3D0 +u5vMhCTwq9pfg+aoD8H8H75QZTQAWmWo0umPwf/kGtNeBw0c6IqtzzBUP/8Ao4KaZ+iqVoNN5n2A +NX/Mf9X9+JypHxRGfw7Vf1c775r312P1XzmgHf/ZmLTVz0qjifjofNIEf59PGsMP2HVtBlRX1d+5 ++Ww2GgJiMj6j1M/qjaa2EXygaYE7wn5sMP32Rwd9ANdLfqD5AD+iwSPR5Q4G1231OnB8yOcvDRbK ++LCId7BSaqxbr55IbYVRaz4AJFRozBq+wGtC+tufQn+pzrng33en1bNRu2P6cs8f+s+gPwSvY43Z +bNJtzmc4yQU0xVT3vwCxAviqVq3Pbr89AbhHbaTYGukt/Gf217iD34Z2htPXPxqT6Z4quV/d9I8G +XHvcFj6fWrSD6eK4mTiSqeavfyh2hqNhxwVi+iNA4W03mJFaRv/eeTW7wzYYKOliboA4ap3ZGZqE +8/zUrVe0/EtigrTFhKv5dxvNfscN4Tuu6j9po6f+cL3VYdO/maLh9Frz6Ww0+Hs52a+jw9S0AeMg +oMwDW8wtOf7yfVGDN9f8mKH8Drt0+v7nD5bGf/M2mPa7rX86L44JpBIaZrm8rpb27+a7cCqc01T+ +cjOVv/7uqZAcLdBOU/mz20Zh7Y7TERv+A6b02UGWqos5SS3/5klJ0Z9WE2qOgKU7gOb1+aQLrEU3 +UzN+8wNEPuJ1tdF80urkYBD0StjeP9ogI0zeqjE2a0w+OjOgB0CXwfSo4Gbpjd/8zarsxVmZYkqj +yaBhtSvVU37v9ju2jTWTVbf+x5vnhBMneEeB0O4sc6Xt37v8jpPqDsE4+42Wu2mpW/9wvo0u2xk3 +ALiWK41B2/5v3rRbJfR/LjbsAF4lhI5a3ExS3fqHE+ZwdOppatr2P0DeOjPe/5lJqxVKf/doRuNZ +d9D9L8os+CljAlby3z2EQWfWaDdmjWXHkVxyHFtt8fzDza5TNUYfP5522t35wH/VmY76czGnRAaT +PSJJv3y8AtZ+PvaX+nDbwjO6i0kHpvoq7l6OZWlWnE32KOlvTGbNUWPS9rfQ0TLpb8qjltkJ6kIa +lL8LRtGYdUDDDnJR2zbuDUet3mg+83/gM2u0qEpOGRzBaWf66b9qTIEUFAlYNVP8BUsxlGA9aMr/ +gU6y3LWVNQia0IzjfD4bg4Haj4RSQVZLNzCCbts/Fa+PczEKBc2OK6KanGNbeXKkZj0QGUz+6Pjr +nf/M/MV2d9ZodvvdmSiVSUaGaSSmamP4MW98dPwXo7G0hHqxxkt4aY+7cdxEAglGNtGRyABdSqB5 +1Oh3p7pH0/FI3AG07L8YN9pteZ9kj/zZ+Wwkr5iRbJP+cWMMdsG0O5j3G8oqyuue63c6bWhT3iib +lbTEr9bCyU9G4+yk08ApywYZGFJi+0h01E8Q4pk/+EFTxl9EPIw+Q/+nbHBxsnJvsAON70AcrLRq ++cbwj8a0JqNDTQiE/13mDGBT9rvDjn+KEoWn9o3HEv2M/uhMxvDAd6pdZYgskevAQV/OG5C6/FV8 +CZOeQZiNYwYoE7fkFQrXtJygdY790YG3EvqbjX5j2HKYZKvfHYO1g175/4C98QEoQBx4iGTiYDlU +jLSXPSrN+30JjzedyRQK09nE0EWtdOvPQ8j1kT8rUoj5vtD/TWiBVOqnVf/1tOM/GsANlp2ioALI +KodtPTHK7ZUmYjhQDV7/KJEEz8MqWM5f6SWXeVM8LnxRhLzrzBoqOocZGhjjeKQP/LUxMH0mU4Du +WbfV6OvJyvIDJdbEQF/GbwCO87Wadv+awkZJoWrzm7QDezRs9edtoB8PIMXoGZjZF+URvO4f5swD +dtTsd1wMCU+3OBjP/sp3+v2pJWHIn9QLt9C3WVE5A+16QIt82hjXZYWGctG6OmqpOKp+xfW7ZTT+ +y0DbOkSJyPTfnV6Yw9S1R8nHGJP+U5y8behX3eZ62P2PacfqRrfdYXv051RH7aoWXbXc1I8wqcFb +rfEH3FowAV+BMBpCSvFr+LOrb/xwefyEuECEp69Is2V1+ogSx+d2UvgrWlRUPH3EiONjPH3FLvQV +t9BXvPiVNxQKOjqyoQhzgtKhEXqbneiJcPcJHqD5Ett/80QQEj0JHr+jzHHv+B294HcWdOX4Hatf +N0vEm3IdRaLX5s33Ub/dmUieQfh0GtaLXV1jlbmm5Q6F+RiMBBpfylhynU9AVSr/DG6KGoj0phXO +e6Z8XfdObQOo3us4Z/E/49FkBtUgtXRVqdY5dGijUq4NCpLGaVTr9CuNGegbCpc+nN5Upe9atD2C +/tOjgrql+nUdxh3AXs3Gh0JAVcPTvq2Pxqp38nlwuT8CyudVZzzvT2UBuAffypd16Caqv8tDUXBq +N2WkcxhlL3hTHLZGJhY2eAPNuPOhopep36FrYxDuoOYgWlAKUGAKtrrKuEnlTQloU3WjMxiCBGbW +SWcyNBsI0K1l9VM99kEToBdp7KYdAWKfYtIybKGkfzhSDA1/d4g0+NG0K3Xj7BGh/MA4tPGCqO0F +1Bap83nRULhSGwpqawQ1xZNK3GAzJKcxQ9SeDdxaiqX2N4CWjF0dOpeCxg2BP4KpbtCyQB8hk13/ +kRunUPGi5hYHuLE1Eoxtz0WzraY2H9W4ws1skKWdN27uPHEtivFXzjh22I1yOLz/ttNM3HTbnVHi +dAQ0vQ5EKlAcwT7sSLhNKI7vRGvUh+UBAGQjy1a3m8768TbuAhG1LBDswcPPxPaKh9DNN+P2ALzu +D10Patx2DRzH8MlfkPJ1SeqG4/EkjoRdvA+D6F21nI1E7xLL8/YtJ4phIxCkfVscN6Bj75o1hG3/ +HIkV3uybfeqaGXD6NWoCnE67H8OG0Wmob4iWtinGDdhBRA1H8GTYRbvGtNmdDRpj+6a4zUS3T8xa +t/qTeGs0hFd7QZeczVBhS5lvN9HVQ3j+vGnrSTsObHh4h47DAEDDd8CapGvDkCg2bYWEhNHLZ+j1 +D3jgOo5/umz3h/XYxh+DXrwzhDqGux2EPsBbSFlPN9+ARZvBC9vEscQp1pTuYVOwqSFvVgU4WQ59 +DLZId/g+cmg2UV1c5dAUeUqbjcnUBrmoYROqWGA/qTiEi8Yyk3DRdqLxfzi1VjMKzrL5oDHpTbWj +dtFYHrWLtqpRu2itHrUZk9fOcT7tAJUYKbc2+/h9OIu3++PJ+2hot93H0zhUzAAPmdqTxTQOeCZ0 +yg5BU5XwN7T8zzg+0bMkJPDNWn64YV6gnci7FP+yGZqUdtgfbg1x0p5MtTveVAChZpIjejq17rk1 +iEve9dbgr54NG1QajvA9zFoPrqF3zGVse4ZagsiCruO1uB/nmAJ9vu1/CtVuzy+ewv4/KAcdCI5L +JZzMpB1oA7WY7tBGdEL56jRk2EZUWURJkDRng1CkK+xPYCirVuqIyRDQAgHfbPubf/kLk+4f6K5r +O74MvldULBvlQsOIrVQLE2+toRE6cnQlM6CM14zNVFor628tBCcfzoIStBGFpKrAlL4VqiolwXJs +ZyN0caNxXwoqMiVu1KY1nNqhFLSZdftqC9ucf06lazNt2iAe6yQbJ5IcMBsyZruaJTFtMwWms3Qy +as5u+5pjN7MWzS60hWybDDsfDeVk01IAAMV0aN+mT7aQ69xg9umFxGej3ZmojiJNW2nlCG+mCgJm +rj8dNGX4/a6NkgwajMYtG8UINZjaTB01aM9tDXabHQw+t9/AWMTMhy1XDAG1bgyHIyWuVAwNgE6W +rNTQr7jKPEcFkOr2yEmgOy02uF1MvQiEVau6LMId7HlzoYgsJDBknAhtSRmKIdXv2w== + + + t5r2umNg5gxthDZsNgG7cTLtwOFN3HUrhR24Z/XSF6q5WQ0H+ixkj52WCo5HzSNgDKhpQOf80q8o +YekYUhZLvMj6olASnVDQloEBa6PhVO+2AyPwn+NXKleV2u3c+KNzCsR/d9zvZLVocnTyqGoj+FW3 +GK/AvwNnD+b3ClPm84pOLIZB2H7nJibD7DsK9neBFS90dAo7vBj1u5JUNDUepIHiEhClyWgAkPjn +aNKrS5KJsZne6Wg4an2CjzqqSZ50h+5MX2nQONAKuu2HM3EC7rArRTFlgRxtNmbVxl8dycyEV0bZ +Lwu83AHnZ6LTlmxz9IeLLlGshNWK2neKPrXu1dvyXCnKoblBZD5Vg9vYywrBggDInXLUBivVfe9K +7IvzgDCFOlzQv3W4DmM7aUiX1pj2LnoluEpEE2ZcjmRKqVAArUn9nlR5r7VfugqD9EYyVcXxajNY +i82oHrSpjuU+Nsvc1DeyFGuq9TbvnINHxK5nhVot1FTXgaL2u1THGwwfu2CCKmEG4zkBjeYbYxzV +2XUQHQyEI/mBrJUFpUd0AnHaAFJCSadwx0kKnSkYWsO9BJVYR3ZiT7wmzG5BQSSzOReYAIzlSPGW +Wvhgpdb1SXcAkXarsuwdZY3ZdOyGdNX5gH1MnTmzTjdxZMzoIxwg21WpuNbzVU7UnYddApvnttO8 +6Xb+dOZRKiJS8yXnwdTtzG0ZL5CBAYW4/jkfNIeNrhRhF6p/gp3mb0w6/tlnxy+6nfxTKRDuz8/O +0D/FERaNobrwlh9yUX9jCh8ruq8UEx9H8SEzBFwL7K/R3D8GnNMP+EkH72nUNQb3AavqdDUdRf2g +M/nTIZgxvGh1DJPJ/F10ct7w9xt/wfj7xhiHjkBeNZ23PuHwjoYFdFSlgMG9DQFS52B0o3el++7U +Px/2YCWQuOud35p0x44bCzUGGEFcpq7yxtitmWyGuKA0LKPqhlQ0R/6ckw8xKNZpY4GBd4wxWGZT +BQMZj1Vs14GEVVLcVo7ieAoYWXEFF9naPaRmtLpwRjv4EjNzYZTUZo1hWw6JdsmLxdIof53Zujwc +Y8edEapWD+zXFRGBdmGBuQzeYGUwL9uGrsxPs+kAvtqfzoBFPpeTff6///v/mf2//5c9zsTPwP56 +n3xr7fijYc8Pr2hTmfA8n1RiAnUmtjKzRK4rjTxbyx8dCWyhA/uHL5nD853HyP7tQXCvcRc9pnfO +Y7nMpDz4TH0MN45LG9FQMN9txKfb3HWlyG2lMtfl9ClzmKo+BU8zk3mLLxWpUyFAMswWQUwLX4WP +KLGd2XuJ72b2o+NpZnpCJXyBzF51YyI1Op7lPiqX1cw+06nluwfpViEeD34Yuqq270F/fKEUSPEP +5Vnh6znHPMSi2cGoOs0e1WafkTS3NS8VmO3b3Fc/eOsLFN6J46YpsG0++c7fXD4+Zev5+I11p+p2 +qefMfq/0nElN44NIIRqYl0Ll9rsvgJBVegMaRuH9+ZbP9TP9u9R77nOW/+QfSA063nYKLbL6ndk/ +DN5iOGDI0/zLx8sI/Nr5Lhy1jzZyMeFrO1uLbQ3xGO4a7bkvkPwKRVrFFnsZyn8yr3v72QC9E8md +Rd8imXzwupTvzHfTN8dbn3utVqMHf3UjxffqJ+6ZJBINftLdfkt1X47buX7gMBibRJ7m2Wpt5xuO +P5zZO/6kfQFu7+Y5kx22goPIwelegh88HXR5PjF9p7OT1hEZ6aVIGWKrcDy9AWjjgx3+libaqW4+ +0QDrS54ehGLRTq7PXwzwDO6rgUz+aH/rthhNslOwLkeP3Faaz49eIvs37ccU1dx6RmDTwwCYUJrb +3YJL8sjdcpdDiKd0rhfmYiJp3rSrBPm8dVpINPZ3ShuRhwnshYMvXhAU1MQXIJqbRwz6HUmX9sVf ++7fFE9w8Hy2+YWDUPXUESPeOiKTTxShVOPw4EOHcHuzvtb/OXtBKygMG8M5zrNgLaJQ7lgfwrAyA +DB1cwUYdBj1jN3KFV4RqICwPGe6B+2pl64WvSOE9cfJdbDSC2zmueX25Xym8prP1z9Yse7HdOs3W +KRqsfpZ/vt8C37Qfindvh3MZRZhqNWT60lOACf34pCIt2P2o8F4rthE+AdhGOJLe2rvFKwQh+wLF +VzJyk2PujkuZyeTzmkmd3h6iFRLY7oQDi7cbjeRGyRc9KrUTV+NdwhNeWAjKF9iLHMxDpUKfzBHH +bAr8Uya6GE6aa44ye/XZZrZ+PJsbUalbSRXepYW/m2zAZ3XAx77j3aweT/OrZKcU2hmH85/c1UOx +SezvFjqTSZToXBzsyQPB6JCRUS1nX49JRG37sbcS3Kkn8cLRF9/Aex8vqFD7Hpxkz19yp6X8+7FA +kCfNdinfHtwj5mmyBuVcnzu4VWBzs+rBQ65S3zrQjcEXAKPonBfKvUAHdHW5DzkMTbynbkfG0erb +tcCv6Kw83mwmk5E95kyHkb2j6eg93512OcgtY48XVHjrqKLMaq+T2hmAnXwVhuR1Gjk4fjiWOv14 +AnyMBm8D1d3y7LU9yNbejguJ7kGohAG8Bytctn46+sjc1I8apaJweecL7EeI4pOMjnExOjqjSjtc +6g6s+TxZbPW+d6QO0AbpNzBj3nkMVgF7PAhmr/rjXXW7y0YFsL8gw1997sazJ/e1oS+gYuHS+9dM +nd85z1e/66RGZOzuFN6zwReNDLgqlV7DG59oGoDnDjtgS7FN3Vtx9eH7nkbSqL7eBUK0PCpG660D +gMXLW7Cx77Yj6QOORm+ztWhmmO92L9twahuwSb1wclKJlfaLbBi9hXP52B3i5vXTTCDXPybicK0e +lf3JC4fdXSZz00zwF5XTK7L5cp2ldza2i1R4+yVPlvPVDPyVBiROHhCdZuqQjIbyh/KztC+g/Qa3 +RM/gnznIFPPoQ/QnV6tSl/DtAfpa7iAPn+UwqOx+rMSzscIV9fowLsIm+4Anw+bwQUHuKgcbnSlw +cC+wPy2IjDz4tPzFHmoCR3OBhoTGAOYC4GTxUOA08YThoCB26vDZHgKm9IJA6FEEh2zWKfpTxBiE +WNMiE32zB9+iaRwqqMSN4eAwFocfe5cyCmoIn3Iv+6q5KIuXtl1a1wuhWwZfQLcQ+BuILAU2mgbC +kxYdB2hWyp8IlNxzWRmDL6Bdy7QZydkuCR4y+iXPCneq/IlpzJQwXJAFbFyVZ6WQip5m8VwskXWA +Z4p2joSOA2XOsPG5GVJ1O9UXkFF4oJumjJOUFsShdjR55Vv0VtepuC7KvlNRjGZV0wrVosYQE1mT +rbInj/BCZh6YSPFcSgiPCKxbVKvGYEsvCOVg9SEeZdhpMwaIpiZvTW9kiBYEY2xf7gCN8YoTyPA5 ++oXRL8+U527i74CBf9Gi3Etmh9mr948ToFaejHUCI1u/ORmWMiTZ8wXKgfIrwAkb4lS6yfwysF96 +ndV3M3vExUakeHNXkURZbFulTqi0Ar2VpG4HKBkaBlh9ASI4ojLNyCQwWE5yXBCofuFHS2uK33uo +lrJ0b/sY2QHaCUWQgeALCKNjgi/Gou9M4eTwm1H3knvtZK+GtetsbXY0KEaqiZD2bb+USQbGklFx +FVaML9zB0WP9O3uez11AHUbUrgYaxAALFGph2pmqlA1+r3V9leWfjq8Kx5PdNzMAWbbyfJQ9ub0E +erI4sutArzw970xE1a/K5YDYforLtkPc3nawtxygdiHZDhAYz18/d04K75fTWqJ78QjU5uJ3Huvb +NLX5aG8MWZpCvoDaGFIoFE4NW9h32fNS4ev2Nd/94hJ774PAB9Bvd0mAk/Qbz1+1R3BwMUU/EtXY +Wv9ZAQUoWQT2O1kW3K7sD0gXPmLhQ9zBJZ1+A4raeTD/GbnPJ7rpg5S4Vlo8aWyRHiD7eEkxhAEf +U6/BRQWhH3RKb0HnQRXTvEicqoFYGRU7aUznyga4qPSBZaHo/1rtXzXQZK9zkgcTakdKb6/pZKF8 +z78Dc7xIEVSZOdWDvdwIP+mMFExjRanbt8vC+3WkDPh0qUCF20W8A5GlCmVAEjOul/2dntW+4ksv +z7tbpeJw/kYFkgNBXP396HbiUeBb1ePc5UUGzOV+cCYa+PP7QPbyrHZTKoTb0guF2Ec7BN+bNy+I +6klzrNjIep8D9dAD65L/fNpIRdLl11eJsp7jYAXjJ7neaQSo9hfvyp5NQU/LS65HHWwoL2RHAJFq +D/oEFCJnENsPircDWHwmfa+6Z6wpnam37jh+GTm8aXxLHdT5zN7J/SYwHz83tLDPs7Vy+wusy8GE +ylxvJNEaoBU4CM2pDiS5d/QC8LHDz+kcLXLyEjBV0MtLA4CoT4uvY7KZ2bsOxlVOMortb+69zy++ +svXrxj3oINUnSk8ZGoymEpO5s96B4Qsk+6XRuxXFkHLLurR71cBc7l5a7VG0378ExWV3Ck2mU3Pc +vaqBwN37ASi5FL7o75UK7AMVSd8/7xohurDyVWCrqt2bq75+InyCdUlzx/NC/Kody6TOvnqyiKpz +m6VhXnQNAuKLjb9H3ULibi8j4TPYSXx2Xt4gPqfi4MqFA5GD3h6wUMxTucF5GkgxjeJxxuTO5/QD +QPXVtBjZ5d5VEkuhO0hK3PbWt5BJ3X53994rzY9M6q6kBoU5Nrbdk01fAEns/eg9V0GwVbJbbEmE +gJ0+a4H1e9grdMbnVaROcFtVZgs+owon9dNNpXv+pl+tA0F3uF18JYbPhfd64d0XKEZHp/Msm8k+ +FlsX/bBOXRI9kx+BHmCoyU1+mji7ydarGbgNkzHj4PdDmUksOc9eXCWeU90X4R2s+O0uWBeVeoPF +0UECUEx1FygoT9el173PhL5TKv09AIv8sZH5Pmx1lBdwreZZoTn+iJOVm6j4DCwx0Mfq29+xUmiU +DOtekc3qEaWAkOUrHPJZLNcfEO+AXnoPXDp1fp/ZGydJ49TEdnBdQEteuBztWjZCTVLtdvPb2OQh +ViCSD8FSvsP1svVCg8z1hS2BoKLf3Uzq/LKPFkzFYQxUhM4nDlp3j2DTFE6zV/XMt5E2tqb57sHp +NJMqBRrcIXdXzp/lbw5l7ZAT5Qu/3209Fo5aVxc55paaGRb+ZWsDCA/ishQ6PqwmK0+lmagEi4sY +B4R2wu2dbGffCx9bzwyfGsfzQB3q7iqgkNYHgb13RpDoHvfD24FXSN37xWbiYazVvPHIhPrOdq30 +urVTA/OLPBVfvmYt5IM04rM8KzZzuyFfIHUaoR+z9frOhoZYDo9ksFXRSyWSRRUzYenPJwsCqWyV +8tlnoCJmju4AHytE66zsM8SjTfayxXqWT159JJm33ABMMkdYNoGCoAFNpXBsGK3L6hmwwuo3h73M +fnp8C2Rlf0jsmIDo5HrB2XGOud+8rhw8MUFXMxXVPA2UUPwJ9tI7OgPmR3Gk3ndcZgSl4TH0dYLp +svQWMBEekgqIFClsnJXC9xez7Mk92VZ1enBy1i60B8mo+swCjCwEuPx570Phv5gJjw== + + + 3j5Z1U6VTy8ww42cjb4K78njfqG52w0kq2+T/VK2P9xE7lAdvYDVh0d5qbN84qlwcrKfwKoadVmL +lYrke6iUyl5tSgt6GwKcv57gDkrZdI4LjNnCUaMfMPCf/kUY4Ob5CvLSeOHkaDMPuKV2A+1H5xf3 +pQwxewVrPmyWNnajJDBhr+E3SQrsHPoNbMNDQQWW3g2FsXHJ1/kX6ewqE9CevolI2CuFjgbZ5OfT +2VapcHFaKwXGDGAut52PDJ17YJS9KKpB4JeiYKEzvCxf28pnwX8rmf1YPGzaC2y0U4bO4ifQqEgb +99hWL8uEctfF0LT5DBkJqUcWMY0+oBUAGzd2b9lLrZqjwu91UxBk8LgNTeaT7OjzfFdtOdntVET2 +ksVnS/iy8/0RnQLAtaIKjVr5qRwoPwuAXnpzVeNZtfQMVj+zjVQRdEYJ9WQuc1qIn3/uq6g2zUVH +pd1wlANqEBMApkSmjw4b9zrJ1o14BMcdX6tnqnZBHFKlveimYsAbaEwttsft91LopJxULzKi1cun +Lfiin601x+/YWqS4zY/cYFP4UmlKmcr4W9qVinxBvdzS+w1+7/L8IlubX1NGgcJOCkeD7hSIrdwA +jLDPld5OA0lrDeA8tX8FMHbarm6ZL7ekUwjJUaJVbI4qMYd29Z3b52Lj7WgzN4jsqAS0RGMq7ePw +7A6sdFd1bq8Dptp3hplCgfL+ChaxsvsNVO6jM0kiI/b5NQnelXbm406OmeeApQMsbZVNjpoMQgLg +oPFiP/f1dZEpHLUvZ4XjUKgEj0GP8LlRtt8YINWoONs52pB6Pp4DbdyovFbNNFhRjZ1stSHdRbOX +u69AQrYGpJodH89nxNFjeV+3H8S5AAWlVU+dvTTnpbcXagBpjJYP0x/UpHTQyanYP9znGA8BovcI +hMNdqPC+M97iZiezg9JrP57Q9NJ9iX6A1Zju8qmXSA2eB0X060KHhzRQCJhGlgkGR0ny9iSRFcrT +GQwbAArdUeMuMw3fbRZOjp+/C539l01lwZDO/8YAEf0+BuzjKcGlmuc7br+G3yaBcVWplF5nz7FS +Jtipaw/jOLRRMIeRDIMLIJozsU8B9Bctlx+E+lOxWc/eFj7Yna6Oe8mMS+JZspTGfEpckiJaC18A +HUHmPx/3v0vZi8w4dTqdj7SuQY77JpNXhVa+0SvsdhMtfp8udooP70dF2T2JmtTAjq+VoGxqZIVY +fBP6QsqIbSGMXTzw9bdKolSYZ9Gx5CXQOIKxQmmYPQXysx7O9fb2Y6KCooP4ARhcbV5vK4EbmBuK +QC83c2y4lAB8rJ0qfKi4pfi+viViWcTddfZqVH3j0t/hntpkhjjOBferxehzDtj7HDVQnLMIWUD2 +PnUBxtLfu8eF5l3nCuy2dKV8/zp+QzxS3j4WmJcXR/QTHgAGHittcZPLyiFQfQ4Biz75zqEhSd5R +6jI0g/S0z11ftBNgp15HSwEyBOzmy6to4XjjnVDPADcek9zN93sWiYRSoMqndLDlxoDGSjsPH8PC +++g5glxHpv5rkdXnBOgdrpfn8fFL9uQhLCirD0MAgsXWfPNFOK/Q9SQdPd4rvUZvUrq5yHDqxZFO +bGvhvOU/PktBeOotaIYsAxhz5ezoe5qA0R3nhefu/Zb6tFphAKnjxs2pMn+NGX0J9N/TUrAcKFUG +slkEDKTb7XjhOLLFqnvuz7aLrWa0DaMIbqlD8elgcwcu/CvU1/Y1nu5nPrP3Eptn63n+FVidbWBh +J2KN7CjbKSmDw1DoUHYvs/d8neOHR3Wy8PzxTAF7v9bPJCRggF9ctMH+6+6DCWtU0WJpp1wdK+FI +8Y2d5A3HHXc/uHrs/oEqbsRyic9hu7Gd/LidgLFW4DVdOTLf3XgMgv0S2W19F4jt2BCJd3Yjv0sC +m2CwCdT962YZek4DJP1/puVoOW0oXAFdE67NeUvqsx7HjWFHlxQo3melvQ5TfUXWnf4qFvCsUC/o +MiLhzVwf71IwnyF6cE+uoqutrAqD/nDFVZhvJ73zoRhG9RPTuL5Imn3jgXncTBCJyGkEcOoZDX9R +zP5lipZfXMq/0Is9+rA+ywHLotyrbF0dNAC93Kflt1Tk4Ir73AjTlYONWCIIdBjAfXr7G+Gzh+RG +9LMLXr29xzci81RtI3p6V9iIEacUkTi4D6HuwaqFL5kpNT0Fgyv0wEq+pemcQAuAyQ4eUKwNOlBS +3hKV1w6wLCaT9EEzGx2fHWdOktO0UNm/jZdGD8xNcfL0QBQeSvf10kH2oEXuZvmh2Au9fRnJx3av +QH9Vzmq6eEJxuprchlqfvlF1OpnsTeugk+gRkWBqeBrKyKZCaXZDvYx6O0R7h0Q9nytgJ8/EdB/A +FuaRdHljB00crUuhF09MhTIjfO99gT/LffD1fUHb6dPk+fTp0rzTMv/Cpo5e4qadvmyfAbmv61bp +lOuelAPmne5vhCZTMjAx7/SCfGI2qdSu0qkvoHQ7DUZPYxadsp+hRvC+aN4pE36K7FMf5jPdLL0w +vsDW9bhfNZsrUcqdZCw65ba2h5PwgUWn9y9E6f2spnSK4mDlbssb+zvk8WvdtNNyhapbopd6SNff +UKeAFptF7ZreAkp+mqersNuwcVVD9/RjnwyDTpmRgZSqRE7s9CIY1HXKsoPXsdKpQsm429fJ8+ew +btFppsHxpW3StNOXw7crq04rQOujQ3tP5nPd33iebn12rsw7vcyH09/bg6pZp5G9fiqtdArWRUtK +u4cPmXPzTpn7e6KUJM5MO90sffDbVwPq3KxTX4AoPT+XLObKbQV6w9O8VacNohx9uzHvtExkg50Q +f4869QX0CJ5tRQ/FTu9jIR2CD8+YAxG9xadeSdPpwz5R5WMk7HRX16kvMN2sdEbcVSNGgW75sZ5+ +q48PDYtOuS2+1y69WHVaIE53n5OoU2Qja+d69J3KfE3Orkw7re0FactOTzo1mjDrFHJ+5jFG1F7D +m2ZznW6eVDpnjw/hkGmnN8Hhh2Wntc/Ltybq1BcwzvWxTNycjPfNO63SgetSZv/AvNPx8aZZp4An +w25vXsubMwsEP54Tt4cnBfNOT9PF15fL52fTTp/Pe0eoUyhfjHP9umfbJYtOnwTiedqPmXd69jUe +nCcFWtcp6AV1+3oUG1oieBKoRTYsOr2/JordwbFpp8JZbHMj8xwDfAx0m/rWb5r5K/8qdtqkw7pN +E36oNnZRp1QwHapoZ1ol3nZTWdhpVOkU9AK7BWC/viWmfzDRdzod7RyInc4OI7qZbjw1HsO409w9 +eaRlhNHJ9Dq9AXoB3caNXOkohuYKOs3PDKywssnhTg/Jk5iOEUbHzBmWNPR2Kn+COoW9iN1uTyaN +5hB2Sug6nUyynZFEv8cbuk6n7FdKlDSHqcu4Dr2bo85b3SfqD53GK6cdVOV652WUsnx7f0kObqze +fhKVt8BceWvg/ID1FnYsvgZrsBPJS+P66vC6t5xAvtbFt9OeYNiV3PBz887sPWaKF0epJ8u3ArV7 +9Wb99rPxEpQxZnyfpXYeWpZvq5HhIWX9tnn+vqe81WGM2zrfbDUrFl8LlZ3K/vUUv30Pfid1315H +upJy+k5upgwYu24e14Zm7zGXK0R6E8u3t4FmYsP67VMhdSBhzOT9W+CF37Z8+zW7GFcs3/ZuqNyl +8taAsUGvlH6x+hoM6XKPtXx7TDHpO2uMBVrDZq1q9fXOxs7R067l22L2tNmxfHtMHW6S1hjLblDb +4ZTFW7ZCFA92pTmnQnu6t5H65fRQfJuP7+t3ZaX+Vt7NKu+ZKRO90lpgeaIdfMyL/Oct0Idvx6I5 +WnplMevJjaZn+JeGj1GzbWhh5jdix8l7YGF+1eE/cfistBEtXOXhP7fIfpOtN8wjxP4aVzmJ8002 +qeDBRUzk58DO0ehj6S06CD48HqC9AS0d1Y5InArDILBj7+aAtW7ugP7e9+X+thLdg2YYcKfN4mT+ +Fo9p2O1k0xdQukWWjkWn3Ba0cx7NO2XuHyw7BULki9TpY+q5IkvHslMo8lpWnbbVnTI1YCOruhXO +cjVVp+2dnS2lU6T9y53SOvRC7V+eabmv6TR8j6xXdbcaBB9Qlp0i7d+iU2APAu3/RekUzEUz12fL +TgGCp4x1p1D7t+zUF4D6/6f5XPc34nadVoOWnSKdQukU7n1Nt1CnqGtWtZOUuke/xIUI5x/aAzft +XuaDoXrvW7Tktr5finfnju3YT5HuRG6RA3N+yorc0rB130IDiJ0rlYMmXZpPROayU8vodnyiu5WK +Kv+kx6F2XTTWIU/C9n56HN4fyxBDCEQ6Wdn+QqNIJ8uPBcC4GkXYM62wJrH7dDEg/hM9HYkdIBVY +6kDWLcF4wOQOxriRzvsE2F4u8dkpBOR/rtQas+gzO5cbF2AvZfV0344PRZ8SGPL1BXiwAxXa+a6E +Hay3i+xYNYOLHS0CZY8bGDBxzAYC6B9IkLdaK8lsUL3kkW5Q6iG9zoOAdE+jVPCQUPnRdO5AhHLA +LZ/nuRMnpMN/xMFjY95kfsENy/n5AsoM0T+WKyitX23Tef225PntijRmNkOovF7bIMv9+o0QfWLL +wiWybICRu7mvkiUonxtyl5C1F/NEWQpdaSQypqzy07d3zJviHSg3DyIlL415KveQPLbHu88aWVrW +EzaynpeilvXQlqzH50S6xaejiRqB8pA1CNzBrMccdy8wX0xCsMV4osUo/kfEHTk0x919bMOSbVvt +SuSPM53a/ab3qamlGJocfXhTP3VCdflkRzxNMB1IIaKblVqKqWbVuYjviKtvYKNF0MvNyNOEzDgM +oB1gzt2pcCtvQzWdv4V3wODuChbLFB2Tje1gBY0B+/kXRAxhLaU/R5EDiXJUlIycOubASLfAzEAh +vKtOeXaN+65Rcrvv7HcdkJWNzbu57VpukdFrMgr/eYyoDikMZAE4Y6h4YracAGPqBYX/gAVVHNFG +2gDzk7mgkTbOL+UhqcaF5jIrm44sXW5OrSaZITqz64RBCzMuiWLxnUaMS9IuO2lhbllPT5j6ApaC +yYXOqDQG2szjzFIs+QJe1rcMcVLxrj2Z7f12WcunTZB1OlIEr82QZofHlrLy/EocjxuVDgzJWqGT +ls4XcLeCwMq3VSycdH7NCg4DtoqFh/UrXwwUUJiSlwBWG7oYF9iVroBpBYrXcUknvCKwe3sjxssk +1Vrd0hh7nawQY1qO5nFcY60f5o2fGAzXWXq6oHasOX8B46mYGYNWCq2pgKZyd58bDnxMpWCb78rZ +4ebKdmXu7nvbm6GMz2MNK1mBRyZVBTfQEveOnfvNHbfGh6xb6rGTnspi2dGNYK4YVnRMwXS/OC9T +empv4ukGIlKycSgOXMDVQHS65WI4cdj2qoFgGzliIaI+KtB1/ejBJseHktogIzm2h3qeNuMqhzb4 +dQRpvuihAwunBtAEN2x0GFP2YbFBjuzVDl/Ay6C2FmQAWm4Jt9zzLGAvlt0ygCOFAQ== + + + uLX3recXdIFynzuka3QFZ3+GXpNXfH1fR/BQ73YVRFWYkcXnaVnhDJpYOFPDx8ImB7T/SbulT/HE +yg5Z7re4pdmDrCSALI9bXIMseYujL+jtZC+h3eDHcC7aLW5qdTt7lwDVbrrzkNj5Eo71Lln9aOxc +sjoPyeBYq8FbGMXOLlkwNdVGElffs5vkGMYlnLp1b8hWkn4ox3OtWF7AvQHo4JtCE0KRKobVcr9W +Oplq4ffxBey8dINjeLh7v5TfB6LF2denYwUW/hqIHc4VJav4psbTMNao0pm5XpUGdGDtTBR5sgtl +GmL5RK9Ke8Ed1sfQeAL243HrX6APr/mgjiJUtpgnQXii04QX2y+py7D91Jzp/EQRfrJ8WcAbPT7R +yz2rCfkCNpQOaEcr9BZhAIfXAdbnsObuEPPq4KT36USdlS4LsKMTdE5ySK3L4rmoRB08rAqq4zfg +rMAzN8RguetUlJwH44l783kb53xXM5N22lNR10eQAJiVv9XM24otCyt/KwTmYfOZ20tg0/gCSx9S +oFWzF3k+13C0hqS30Yhn4hjOsjsQQ5GtSQWKxJO9wPEu92R73wSY5oTQmxDVng8GkXYRDWk1zjwK +U13JCUMeBZ/6As7b0IW4gcCouOczPgslAsZy7rpCpUr9TH1rpJieo017YQNHm/b0B3guOJqphyQP +EJP5XpajXSscTbJevWjwemDOHM3n8gQJAluco8m7snwzWgFHA6tmxtE8730AxztHM/guMJzlORqE +svzZK4JjcxoUzYXkU5yEL2CmDWiE0M3IzoJWHx2a6yhM9EobbwlsHoNvHD5b9gBWki/vwW9rNuRS +M8uDfX4+M9vM2APvjc0CYDcbnpisL2DJZheMftBu5htkS2ss8UUUFLBquqAmKw7jDMedam8JBflh +AJzlQyAQFAuDWnfy7gxHe+ju0r1scpqAgK3CV41lIZhfBGoXWmkInsaW0e9VRNrYvJoubfHd3br1 +Zql8F5bS8NaTfm/vg4XAltfvn77NZKFXKQZXzbtLyyjFIJxl9HsVFFkWLi7FEBwT/d4Mimy9WsBx +Kw3tZSHiME/fS0tDjSx81Z8To17A05WEI0H+YxqHJcpKTfCUEoZhqQu8TmyWRI3KqIvTt7u7ZXzV +Oj8/ALbs7laNy2Rv28da22DMlborrSTsxcoiAmsZd7XPbU5P8wCfNwkbz5WLcDrdkCwpAsX2OG4v +vWDKx2MGsZSPJ1zZlS4EE5W7a1uG51lHrlnY+2BklDtUuthczenqom0BMMuzG9nb4zagHgCjt/dO +qqvwkACM8d5UDIsYRLiSr3FXPlgMzGKz39sG32KK8En+e1eDckkRhs0lSmS8dRV5lmZPh6aWhbgG +KFtu+rERG16+bkRvXoobsSz9AvPmimYZdPjmluVz6NRSzJhBp8sYWjiHzj6DDvHkFeTQWXaKMugs +swU95tDZZ9CpswWXyaGzz6DTaH1L5NDZZ9BpsgWXyKGzz6CzyRb0lENnn0GHsgVXkENn307MrV46 +h86wcTUZdLJlsWQOnX0GHdLHnHPoNAHJNhlmF8GSmbZtHQNvnQmkC3ZxMSRTT2/BOXB7112+VEln +Iy8cDFvQa78mzgG3nt7Hglbae1s61RlfQR+wsTCe9nY15KrNFZVlfMhNMljnq3Pj5ETRnvHZAbOP +w3I3P+Trc8qccz0/nefKuF/cIz3hfUgWmY8Oniu7IZmlzMG5eEqac8VrirpQECW2x1sC1cxTKAiO +HzMNBvHuNrZyGqObwZb2V93Htuyn5nOZ7KaNhPTqGESUDNZ8WY8xTnazOrbRWklOyW7W9qn9gYOK +WxZtg0E0pqmTGVLUZTNoMoXdAdOGYJHGE5sm9e2U+eiOZzVKnoxetCutzN4mbR1C6SnFFOW+nbrM +OnS27QGyzM6yZX3M6Dpzchz2hLHOTQK+vTYNml3gxKpsqXZZZoGpNCV9Hpij2uU6j2/uFAPvIY+v +6ZT/sqVxWlmnplknwdir0sYY+ODB55bVoDJmKZrW6+cYA+86iqBd1nowTdfPbR6fMHHKibEjBm10 +OgS2sgzRiXLyYZWZ4gWYM8W7x5jWwbokxhzTRN1PUuFoC2FM6/ilcnf3MW2gU0UXWG+SyeVOlzX4 +fI1mlrzVr8z9lvb5cjoQFgB6m1qJbALijXoh4T9vtru74sLYky0+B2Pvo+La2LMCoI9RXACE09Uo +YJ3lWzXcpcottEKvhLN8kVQa820BU9ycnQw+W5c0zEqzMOIMZG+XI+dzSHN2ceSJJmR/5YnPYF7Z +6JGpqSGUP1SYuUC56mTEipK/jry5d0xMJawpOSTIGbiOdUbUzFSaL6CPHbnd8cp+t9THvo68uXes +0+z0EUQL4+nTwdPg05kS1iTg0SOjGZImHxkMivLi/rAZknYzO0sxGzwxbodkH53unBRnNyT93R1x +nf8XpyStwiNzjDwyS0apAU1424VHRjzjc0jP2U7Fd5bxyKjs/ePlPTIAQMgmusNDGtoiHhlDtuDy +HhmYhqbzyFhlpDrl5zGePDKmfv5jF+k57pJzYIoe2HDOlOwufA+W6iC0yvKJoixbx427UZbpw+vI +lgtisM9JHJ+sJpIBrkvqMrgapw6YWirkENPrJg1twQB2tXyBCWTW3iUP6WOG0AXTbEGnvDrPQbPG +CFWUV+cyXs82r06VOmqTKezsBD2xvaRKtXtVuqVtqN6F8S5S+MyloJNy3q0Ck1aTDwd7WUVMnX0+ +nPf7xxbJhzOLgr4YrDofbok8Cw/5cHYRqqvLh4Ne6yV3oIt8OJMbQS2TuBbPh9NEQ0nfBFedD6e/ +dxRnxK06H87xloCV5MNpTqxchFoulg+nt8WsjnVgJtvymfVQwK0sJhKA0sZEWumWbmIib0auYiKd +9v60Ry+rBuRRgMTy2egITtRp9V3CcZNHYgkF62MIzgoyuQyRDDYx8M4cDSbXWTvEjPHOqlo2FhHP +we9dQ8Rz8NthIXSb0NLbc3ezzDZUko9UXoVltyEAZnutjBkfs9yG92O329BGG4f49mYvmhLaam4D +RnC8bR+LfGQAZyWJkIWEOynmCMf6SmCL27SswqyNVwI73oam9UrrbmsMR40+LJh8Zn+xk6NBLWek +kpuLBoio5mx1sfBCGamNzVcXSaQuM1Ibm003LgOHVL+VZKQ+fa8mIxXCWUVGKswXWz4jFUJZRUYq +hOPuGmidSWwW14c2iPWlqZ6DjMIxcfW12/Bu6W2oS4Uz52OrToVD8fy2ET2rSIUzXZeVp8It7rfU +YszedvdgVy6RCqe+gwglw/2SVDgTr8IvSIUz94+5tM/u7RRDNStQ359sl/j0aRmr6uZGeK0+lo87 +mEVuA70gKNaVR9GFAxkCs77ZzqMOY7hk2Ovhgiob/d7lEY7d7byAlZuJPKUX5+RmfV7dk+V1OHrh +IHlHTcSDsn9h1bioWX/iGqASl+nzz3L/pvFa2GrPi6XkdualVE9fFDOJWRBw/lL9kL9HZcMLD8VJ +Jlvh6sf5XLyVz+cSJ7AIQW0siaNAXztk0eOkzcUyyzqDVpKYo/RonXcmXKYu1OSlTXbba52fqp3P +qk7Zz93A/sbIKsOOub+zS3ZrJyw7JUr1nF2GXeC8e9qw6vTNptNyLKnqVJ+LlYpMVV44fbIbc/dZ +lSsT6lLANkN2yW5kXNepth7f3sAqw47b2vrm5k9WyW6PdllnA/sMu1G9btnpTrXz2bbqtGNfj+/y +zrrT4tlj2RK920N679Wq00tthh1aVbBhxVmjXyKdp1y22zNrh70KmpbMU9UVRCZ8gduJorPKmSii +Z5KVlC7N+3qBauc7dhFyq9VgI0M8F80Z0cXOaDWpPc4RqnqviXUdq28XQ1Kdi9kMyik41SnOA1uv +q6wkZ1Z2xOROFRfeJbtKcp68cI8F1yGSDtmQ6E5ID3F9TkXkbOP63NOTQxE5y/mZ1X1zKjbidn7O +tQZcI92pzojuLrUl6se53y/ljnUhIstwV7cF6Ow9vYtk0y3mh/GaTWdmB0i1OFeXTefyfpgls+nM +fIL6/bJ8Np1ZLt2imY/W2XRmvnjzSPtlsuk0aBH3rOn9Y0tl05mBcrghZIFsugUlssdsOrNzGllW +riybziyXTm3vryabziyXzmVsj4dsOjNfu1SBfXXZdGarizy9K82mM1Nu1LGjq8mmM8uls7htfols +OuOQPresNaVFs+nMlFNfYNXZdGbrZxINtWQ2nR6UY03hhbLprHTL1WbTucfYMtl0OlD6M/EVZdMt +hDHP2XS2OVYry6Yzz61edTadGQDQy4qz6cxOS3Qx8CvIpjNjD1rrdRXZdA4nIyvKpnOWL6vIpjND +hqKNryqbzimTazXZdGa5dJb1+JY3AGOKAaipL+bp6ibrKl7GIpX62hwuE5++HTa7BvnMyKqWzeL1 +6gxDmsFTnlXXq7PWLtzhaRYJesKTgiVNJCTMyXRULFySgCZBwSLr2WpQuiG5ZQUuqstpD6YWGhLE +GBiUp7LLdkMyD6Sw5DA2eLIpu2zBMqEU01pEh+TxVGcR0dvJsUNhc3vPnFwty67Q3dJl7lT3XLlU +yRcpc2dZXe7EVa6SyzJ3Vplc7hLpXAVI2McnK4Xullur8v3YTZUZWy+VqzJ3jh5FiJily9yJOox9 +obuly9zh3DeHQnfuDo/GJyu454o+vCbtF9F9nsXJykKUxieKyr1wLg+Y2kHYLX1anvLAAnWOsYdO +9AnT6KDxbOuBd5VI5yai2eecYWgdxOE6vxD0YhN26CGIDGLH0vWnpWR3FbZAz1tBfT4RvDTVcs5m +d0NZnfeULwYLJnZpoqEAUTnEg7uOhgKgHOPHXEdDAWDuIrrtA5sR71tJ5uPyRyGwoqDNdeDi6ruE +46q2qxkUVWRXbRU7EEExZLKbZgo757IjYK4Sa61qQOgTa2tDY2Jtbbi6WwEhsJUUMkY0Bkbrhpmp +ZZclKutmqHSs92oXQ71rPNKFmXjGCGpbS9wqhroz7a0kM0W++di7JmEEVZ2vqoIheHFhfUTseu9f +eypUbXX6BguvLa1OYCh2UZ0e4KzglgAMZ9lq1RiKtAnNbjj0Fqt67SKRwdMJbzhisg1vXCQyuPLA +L13hTsqvtKpxt8A2NAmuWLRutbcKd3aZj0tsQ4nQxAp3K6mU55hP5K5S3rL5RHKlvOW3oU2FO21e +kpv8kEUq3NnVe4U17rxXuHN7qznMflo+sfbpW1FzrKxX14m1AJizmuNzo+jg2nSLJdbqMx/ZZf1H +ML/w1DQd2ts9VwjOAnzTcEcEhLOSfM5Twp0t5gjHOhdWl8Tkc7pmApXL85LfbpbEpD4VhQwiatiG +qZDDQrjwa0l131ymMblJYgoevOgtUZUUc5PGpJ2kg+9UASWvi2UaUyrkKkPd1myXd2Uq5GZXukli +Ch4M9cr3onblnackJqsIIlg70UbSelMM78Qc3iVu5dcphiaXJd7d4xoQq8hxzcetbw== + + + FYP2i9eKdJ7KPSJUWutj96u7muoenb6tKMf13vJqKu86THPqqdyjQ6W8xII5rqr9KYdhuMh6ds5x +BUNynfVsl+MqeoDgQlR58/4k1Q9mvFUO6oUemc8ljm8LW53jmi9QOIzU6gejtwgHfpUvUHZf6e6p +1KaC6c0CFjzItavyHYu/NEl4Z4dX6k41+XC+wHTr5v5C7arS1mFL5R/vLfLhwtZJeJP5W4rU8mRd +Gh6xa5X7x21t81fhZ6skvCfLTsFcNktj2nKuRHnr4dqy0+BRM/5hVYctrHQqZ3IpCL5gKVWn2tS0 +aZDfUeoI0rosx3Do8LFv1qkvABGsrzmnScNr6HP/1Og92b+w6JTbCjBnhTfFB6vPiHu16bS8zVl3 +Wr7cejDrFNV9Eyqa1Ep9p1d2dQRPbqw7LRavS5rILtDtNnwflX+JSZjz3YOEdvUt2tF5wrKdOr+S +eNtNZV1AjKRGs6IiJsGc7xm90ikf1ojeHq3wzNv4iWVB5zJsEiCVDaPTIE0VM+fASReyGcA+0Cc2 +OXpIrFOSjKFVlkOClGw9qLyb1CbnxKbpqiqzIIeuQ2UWt56kgn1oleXSGSqzgA5qXkLQ7LLudDdP +LpGV5hChibHkc0dPukMvr/OTvdYw785zlUWLIRmitPT7xTXSPUVp+QJ2g7L2E3sbEuCW1nFa4ngM +sbE6dlV8Su9qD6+Lxpopi5kSAPaRi6uvHXywL8VVXd54H9twd8Ohi2wkW/ey21Oel+IyN9EqOYmG +K+MWSnYzP7L2dK/1S3FBz7L2Fk2YBbjsJbRmd8VZ5os5WS3Gu+JsDCBz/5g2aMTkiLVR8lTvwJrD +lFZmIzdKeg6z6Kk3Triz2sfoxMq5fJ1mZHo/v7PLDtXjs/SqMN+GAIKeMPGuj1jUfgoe3FkfDnpL +JDPUs1iiLJt9JpOnHKukp3sOVEPS5b+0y3a+Y0dtXDMkVai+eFqt2rUeUwF72y5SOdX3XNmkAjqV +NHZYP+XkvV12TtRxTQy6usamVWY8AHOqohPUZ9faANNJleUw5pjL436S2pPLJTHmWE/HE8aqzJMF +MEO6sJl2KGJswSxAtzmAru8hsUoQc5UDaBOd7iIL0G0OoNGf7CUL0G0OoPqGQ+9ZgG5zAJHXeuEs +QA2p2FiY+jhYb1mAbnMAIcYWzwJU8GnPN7Q5Vl6zAN3mAMo28kJZgBZDMuQAqs8r8XiMs1q+KJ/7 +imzLFOVTzeUXFuUzeBV+SVE+p4psqynKh3NG7BWU5Yvy+QImWuHKi/IZ6yP/iqJ81vWRV1mUz1X9 +ymWK8qm9CnBQnOWgRBQ5pQZbV/Vb/m6o41XcDeWyrp+ru6GWruunmtoK7oayquvnLU5p0bp+9lX9 +FrobyqSun71XyNwS917Xz5z4bO+GWqCunzMlr6Kun31kiOy5WrKun1Mm14ocurZV/XwBTw5dy7p+ +9lPT+S4WruunGYihqt8CFUBM6/rZT8gsQnWRun6m6Yh2t5q7R4zrTFnTu6AXqOtnf/OXfCa+ZF0/ +W0GXR1JsBXX97N3Cnm6gsqnrZ2/qmkZBL1DXzyxNUtl6y9XjW0HOu6e6fvZQoJ9/FXX97A9UfK7h +LJP4rs9IXbSun4mqqarqp67OQCxR10+3DQltVT/NnV2e01MIua6fY97rSur62Vf1kyl5ybp+9gHX +qozUper6KflbZrSou+dq4bp+9ghEGuwK6vrZ7LVpj15RPb5deyiu6/E5lJNzXY9vqbp+MhTT7eM1 +m8NQ188m78Ex2rbjta6fvSYPbzxYRV0/Kxl+YzxJXCx/y4U6L50kOm1Dp7p+9ufN2iiCxev6abGt +txYXrcfnLUjDuh7fCraPXNVv+Xp8bpKYnG5vMMZqeCvFp89IXa6un8axbajqhzOGlq/rJ6dK2dUV +Xbqun72aY0Fjnuv62Vf1W/rWJrGu35K+Ppd1/Vzkva6grp99VT/P9fgWysLVcUtjXb/Fk+FVVf1U +vSxV18/oSlZX9bO65cxrXT/78C6dFFu4rp99oJPOp7RwXT+TdVFV9bO/F859Xb/F/ZZajHnPebKw +K5eo66cwLrOqfgtHD+rq+tlShKoCyHJ1/ewVQ2y9Ll/Xzz4hVpTIS9f1005SX9XPoI+5vslKW9fP +WgnCOozDTVYu6/q50mGWruunXknjAY5Ndq3F/jSv62cvHGyzOFeWEIvlfsJEPDzY6Wjn1+YRH/p7 +pT7xjYo6WQmeWrt27QPvdWmLGmqSaEw5vUkfjNV58Ng3JXYV0kjI+EhBDJE473AyPs80lmh1CnPf +qOnnBhArxxuRx7NtInHX43EjmE+1sX2aPooToeFGovU4ZujJ53Ep3X9OXl7vhmKDcDD3nSMqH2fZ +re95jtt4arRp8OstE2CFvcrO6fn3Ffvdu3/0BXg2zrSE09Jd/CQ+2WCrZeYtd9W7PmzXTrnbz3rn +jP2+CXXet2+zYabwtVm/Ouml+vt3o85haPj9yn8HJpkhd7Zxe3YY3KZDZS7w/nh0FJ5/bj0yo6dO +Stz7KLczfV2v3WzEIy+ZDerj+yayTwczRCl3kiNK761josztXE0mb8nQZCrcHk23XrjmlG0+XsiZ +lvXIQSJ2G6eryU0p7e0rMZk+jWCxueQWzq028hBNfuneQ/U1mW1djqFBLZeAhPUk529kYDebqR6b +IQshA0x3tgPXhd7esJwrymgMNYKdi62bh3p6ezhJlHYo5mO+1W9vtGEm6bGUHLoxj46ZMxivdjpE +OYkb2VK9HiC2O21k71+MtCr7WLd9wNQu8qqkOcXfqpoaYGtmeEhzgfzcFyg8lDp3qIBm/rl8dced +5dubmcRs/ziTmLb3Ssmt3kXxNkO/ALQN0+X+zd1TtsJtNAGcm28JLC6fGSIjPR6mMt6/ZPaqGxM0 +q+xgBCk5e3J7+xop3txV4C8w4Yt+HCbtRrFZn2bvJ8hyIhKzEIxGeJ1hTpxg40HpFxlCvmOAEX4I +/uR3UdYvYDhHY/DnQRRxmK0gkGKPE/AgH5c+LCVKRepUAGArRKQQDcxLocrRERkNfg6Krd53kkik ++TAaKBzcM7mbJ/fy3UaCBC8OIqoXje38gS8gvcrHlFdU7uH6UHpxlFBe0Nt7H1npxTkpv3gR0VY+ +2FWeKT1DuV/OR1WvYN8inDLY9QATu2CmTxE45zD1PP0CDLB8RaKbcMjK4RUNpnu5q5pu8yMCMXsJ +UH4w6pGtbT4ln4sBVgjJK0e2YgckbJSAeUsDsnV4BNF2SYrfXF4jsDCpdX8L9hyBucVILG1T4RgD +tf96TOmUCh9m9nAve/DA+yrXj3/sZi9a79XCydFGTSFJ+VggrzVcA1qDM0eFK6V9M3iAkheFeFk9 +kCHm2NnFdqf8/CB8ZGvz7W7xoX1BwFmRiHoxJb9Rz/OXjLga9y+0RF51RjX1wiHfkvbBbQwhkCpc +5qEEvE1IZH8LYDefYW22W1JUd9lbUbsYwd+0/IvBIIp7Aw78+SBCfG2V4JI8JKSvHwj5F6kazRv1 +0pVG80CjF76A+KrQ2xb3Qe+LxXPRSlrtmemOhs3IXMCCzQBZCRmNjs2kns9HoeJt7vQ4F+5PYE4/ +V8kViXjdyGb0VXqDiNoAFxDQja5h+VwMcEtxx9/1Ipgkc3cvUzCrzXiiu3mxQ28nBzOCCMWn4nQB +c0Fx08g9Cf5kwigrmCw+ZeCfKbCRtr/SkG9EVav/BL65gTRRiSM1CEaqxJHhTpZf4tAwryQsXDAV +QibIHZU7Jc2ehGCo6DcZJYZvvoC0UCe7eN9F84Gm/Ezcv0CHg9v5BCw8f1PJv/WybQ0TqhIE2zyB +C3GiogOynPuGGsfHOcLYGejgfoQ4MZz6U1ZUSwDrwc8wc4UMB0saWzmkOGdNI+2lZQxpz+CrU6jm +ZIAAF+ZYr9lhRyWVcoeebeazm+CzqxlsfKO5+0DSlMJqENFuUQcikt8+LMoCukKFkve0orKhZ5ub +6cMy0Q4MC5PJwWhXrUIA/QDdq1AKKCCIziab0IG4u7vIyiC6Ic1WKfchUkN4/YpPezF6Z++RBDgu +RCHlSHYlegppLI6fPk9f4RZ/mkps5nWmwfxWUCxzTH1cyprSs6IkoQLTUNXchC/uEe5UenJQUVp2 +M7e7DUk3OaAktQTfzwDE3yZT1hdbhoVwpXWZb8BON/AKMNPHHSjFSq8b0h0ZyS1xPP3rM7Xyfh8d +ihjLhaHTA18KUXmOb35dAzxFSqDTeAxtcONtEdALB0ZWjohIKExrMhKe1EiYP57LSNDd2BFRoeBx +QjdVd3fIKPAFwvmH9ouEBDAeNRL4iSUSJBTsbqtQcJj/HqlQcBgqTBAKACWL3Ur1v9GSOCMBMKFe +AndK8+c9EQXUnDSjA3yrxr0WCQmFsO82RokiRsIkd/+oICHU3L56sqAD8TpauWo54GNmpGQLIuKd +FrWRw9I5gDIKz2OImQFA6+IaRHzBLaXEJ4eJJVcjak3TiPNLo7Ch6WjUAoQrPCDOH427mAaduQyF +RBCNw3PtGEj7MWC70pY/RSkJBLelrMZ0s3yS17RL7CrtYKn0C4s672BxQsvSWHh5GkssOAYVjZHL +0lh4eRrbtQThAgCmsZgLMtWA0E/DAZUijdligliSIhIRX8AFJmxBuOF8voAtCCtUuloNCCCu9vYs +RFQJ14SN5L4pCGLZaah2hi+w2DQoT2NAe18/Ctp5f1aYg9N8BI9hkmY1l369UXoZoEhkt5igot7H +oOOW1LJERcXNKMITt6TcKDdmckjhltSyW5witX9SOj5G0aKxEGrXgUGamWKPDLLKFE0/Xb4NYStC +semKL6l90ew77wxF2/auF6NeK+0okWh8x5A1DO+ImH7G4NdxZIPQh9ebyPYLSseJW0EU9INMYexd +k01h7FsLHlx9gz8zMfzn87SDDMUgvb2//1Z6DT+i+i8vmQ/ZXA3JXr9noh0KpST7NLWrcqypZpDO +RFVuteBhNS29KMWVF+i+C9kFA4xdlcft8GackzxlKTSNsLrnciaicqupei6XFIfeC6oJjbxw1YTo +VSifE9A9EMGZKcB4prAl13wJNKTpXkaw46w5JiHZX8Zk9XqbCqZDMKnxMi761rg8pJxLAleXm5Ct +yjl6IIJtPTySok/0vhRJnNZ6kB/UsflPhblUW+q0Hse9EOFtgaD6tUAxmgy/ZPaIm23F8EY0Jpne +2PtkiNOSrfd64v+v7cr3mki28BPkHToiyhI6tXRVVymg7KBREAgSdIyJiYBgwAB37vxzn/2epbrT +CREZmZGf0nXSfWo75ztbpb0Hx3H8Sj/lKAocZXXian62/rxvF+vJ26X0j85USMUd7ZWD/DY+qHw3 +Pg/ES03fdM4GGZL3lWLGbXMBoeJ9HJJtR1uS00CrX7ZNuDqvq3B18+ETlQHV2nSrGa7UsUEGhhiA +jDWPXiLHoxjfi3Khmuc1wU83b3YD78/Thyd5Yk0VM27PO9/yD5JcC9r5XI6otFSIxA== + + + n3COgKVtoTHFia61j0uk8TNZXm/vMtwCij0bMufJ1CBznie7n1JOCU8ds3exOU2Sh8dZ0DJszubJ +H1Dsl+U/aIGxPlqh1/eBhs1vVU8Pr2NOVZ1Wns0SOunHz9dejfvWTmkSlO/ta5ba/B/8qB5i5JFE +O2XyR3LslHFaXCGEmQKEaZ8tnz/qrcvKp7RL60lzeS0Gea8RjUfhfENrC2DmeJvkRn3KUd4LFTek +0DaOE1yxt3Eo34Gk/m+x5GRqIqdEGlV3b867/e3+6fFpL6qUnpeqS1tS1nudi/V+t7vf/e/16sWX +m+/d3nX0LKou7a1sbTmz2v1y0elGdAbFfE4LOQZOrYXjNcVK5NC5G85Cr371G2ebE7sLrdWvorFY +OJVDIf7Ty/0f5crJN/BOyrNf4slypdn5UK6o9b3y1OZVBZsNTkPkM7tdD/sMQmJnJla7/eWbtdk3 +tfcjCXSylv7z/sZCaXLt/XJ392X16ni+url09Hr1aP1g72X1WlxQpmI0OcgzzYuVY2qb/b66flKe +nn+blOeqTw+wxrkKc3m86qrlyvTLl0h9VZ599+gtzu8tfvCiPLekO+XKm8PN8syPiT7KvwsZpPUb +PCinZkNqeFC/WW82Mx3cuSDFKLEKycrxMWZ2D34EjMUkMT6dJ4mr1MSTaFPh6lt3JmgRSE9Ri6j5 +bAq1cXMuYAe+2COw+Fp/dp1lnLcKlkpstq59ZsLuX4Ea1J9Kk/9eBWpQf+Ks9/0rUNgE16IMzZ2X +A97NkGXfWSeXYQaArbtMgoZVeEenqWoO9H8btnZnu4q2tgId/HgMzTqxneHNqe580Lk9nC3UojpP +YjBIjdrAjn/OeiFhP4IVW6225p88O+49ra/PryXfRtKgeB7hXfFwVXbCKj8L4GGEvZUBx3H8+LsN +9+aYvceYOE6/cu+821h/+bS7v7rVWSgHbWocyrzMpIbqN9PnzYnMaLaSfOqtoni1twlPKwFy2/Vq +EPv2oZDt2tY0XIG7wXal/Ukt+i0Fe9Vu4VmHcN1JiEXY2rNd4jhHB6CgeZi5SWcfRHb1aSBt7aIr +d9bRhQ8+lXUT5kLW/fObH5M0l+HzGCvFM1QgtUWYyVHg1zCDaAlAg2gyH45VLJ69YKyp/LjcHg8z +OY6RnneeVJ+END6b4ze9MN3t7kzmZz9d2JsJ5W2AJnK7UZxFcLvfr7XY1gK4oAXanGLD3L06w3hr +cyZAinxUVatzH2apvJ2b9bnwHWCqceMRmcPgf228ng7fQTPr1fHHBAF/MoHEc6bZYVNAhmQKS2Hx +iI/ONfWpEQedTTPHAoA1eaEpLlbXL1fE6qv5C3EbdcC+hDLTwgxV2LgWNUv7xlHPxifKdb+dC5b6 +8ln13jVJ5n3rmx35uz94GwfyhEc/+gvVb4MQcVxhB98W/S4r7PRnR2pD/f78i71i7kNsfazEwyxO +FuvNmbW8iFUfKWIhbaJYwjpSr0ZKWGJtfpsZcMXr3W0WN0MsNp9sFlUl2Xua2Wusm1beKnytKMrT +5ixexTmtSjR6d+EiSG1l7wf6l32GGTCORyNO6++HxVPf6YwjrkmoWpVDJef59928fNS4o3yEmvPr +8lGoEI+rnfC7Ve9ZOxlTOSnkMEuTv5XioJca8hJ8Ki4BVfTCEhwNlgDmguMpLgI6+r9YhNb828ES +6A/n0g2WAP3seKSMOHj3+n0W4T6Z/rvz0fSfIt9dQ7uzjIj/UVy2ih9HBOmelUj8f6keIIvZtw5+ +Nor7jaHZv5sB78udLNpXD1OpjZObXCt/czd2Pl7eQ6YBLQssRmR6p/kTtbjvUu50rwZo+VuF2cWd +i/Kvx9DITh+OH0U/O7mQNL4PWIjNN40vQ2Xwj7n8NgobL9b/2NwdkTF6jcFDZGyv92AZ614/cAzn +5QfL2EHvwTLWuPhb0HubQbufy9gdInJ01zRO7r2UP5Wxs5uH7UajWVBXXrFxK3Eni/bfQz60YqMs +uv2H7Ubj5GpEpMKK3V+oGme/IdhD72NabPRuHjiNfnmcZkD8cv9p3Dz6zTHkfvLRxMSv9FNdfRyw +KD89ONkrjqHd/rkNKFjku1ai3f3xkDEgWrZPHihU7bOrh6Jlu3f9S6i70w61f9wU/OTfUvH2TbnY +/DLxaKj5ZIJCBc4U43HEF7OYnbAjGRLRvX7pyMEcxHSFsK/1+PtHDuWfLjRMdgqzSSHjXHbq9eMV +x5X5oVVMVYerKc7mQSg8MxwKU2RcCc2VmOLmOH+smifYPw7SwbhiENgWMm7/XAVqUH+iXv6lCtSg +/lQarkBhGmyjrigrVkz07KzMUuIsJHp2tuayIPVmJkSBO7WYc2v4rnNo7gr0/iX808F9qe4cMlv9 +Yr8Xh6Pdj+PprBa1RXs5W8wUNrZj6kUvO+2edz9Nf105sevby+duwhVS15ymhcA7fM/8VglhEL03 +dqt/i+M4fqVhjnUx4GjrC89WlupPnn9eOUlfXy7tL/Xecypu+cPMp1Bo+nKYn5je14PvLhR3t12r +FHKwrZCAbO/ydxvwG+7TfNV6dMAJuEFqSC0f6U2sjTSo0EJXYWPbx4Zza5yhPavHfMZR5qee5/Ky +0FwxL3vWUoXEWiEjfHacZPmjIxPmcigmKDQbpNX424ZjD1jP/nPHqymrMP6A9T94vLo0+dMD1v/g +8WquRY09YD37O8err/63WHoOIrUlZXOt1ynWmEqTk0DZ617fXOINprncPT7t1Vp/dfslGfGPgB8Z +2Sj1kTKG/orIILXWLk11Lv7snV+0Ot3OdFTrlSab1aX+9erpl+vTi16r/1f0DEgyqi5fXJxHU0tb +e+vvo7X/Xl70ryPqJdq/iFb29qaxtnXnfQenV6ft8+7Q/dXDN7X61mr0LBoaxnNkIEUTBgKf8q0w +/2ZJREvw9/DP0g38iGi7JGKVWCttJGIBfzRMNk6dSsQQxWmjfIIXTmmj4UIL6a2MDlslERYI2P4F +jVdw8Q1If0ZJ9Cb68IeIOtjjbkn52BhrIxUbZXUafUeK8NIR29R6WNg01k65aA66tl5ruNnEaaIU +duilFSpaKSkdS5/qSMZSwGeRggstPLSts0ZFByWgCJlaoKRYb1Qi9hIehaaR2Av0J4TDttPIUXru +VsWJkg4+SOMk0Qm0tfKw/za2qUwiHbs09RofsLGB4UUJ9GOsxjtgTh7a0qSK2kkKo05gmRKg0xPK +CAMU512S4B1KwqBNDM8nDtvapyZCsoPf3Ic2FiipcIJGkSYyjWBsWsAyHuAdsFNIMWkqDd7hlMV2 +Ct2m1E5hZ1PoU1gad5iYj61yODP4SHvoXULvsOPSxdrAPktYYgsbD0+4OJGJRIqWMHdsW1wiDb+t +w7ZRmp4AIVL8hKHx6ji1MF5o8wx17IUiDrDV8BsWL6yNg5mBLAEFuqJR8P4kMbBOqG01PaGVCRsm +ksQjxXi808fKwlpBG1ZAYduQABjYIG/4CZsookiZ0h1piuM2sRJGYttLJantFIkZyKDBVTSxBmmD +JkudgSW01NaJdtiGfU34gcQ5usPYBG/geZvYgpxiO02ZAUh/ig+AmHpPYwLBRDmGOSluklinxvPz +SuBeKBV7r+gGpVCOYX2UMzhrFEtQFaNSWiabgOrAA/goE3DOqEuoD9mqQdspQZ/DgHGVQP+sdnSH +MKCioKBJCrIGe2e0k1GjpEHZpKfdFSB0kVbwG/sACQKxhY9psrC6tDort7S+Vvo6HiHTqLrVu46m +9g42mnsnrcvu/l+X3QJyzQBegRwIAd3AReKt94RV3uAqZxCU4ZFiPMIlsAhlUhlEHBBspQnQUlQA +3AJDUJAo0EaGjgKhhrvqNSw2EIyWtO8IGtB0OEHcVQU6KEHgrGUpKBKIQYogCgQlYaREsc4gS+AI +w6oxAEF3CvBDaI96qRWMUyGOGUKHBMQSECjVXllGhyFKDSmw5BpRirQdEQZRAdUsdYYRRyXQVgIw +KGBSkUI8YPdSoJjUSeQBlz5VKAI2QkWwrE2DRo0b1gm6CTqT0PQOBwVNqWCXoB+PoEFdDlGoS8As +gjlnpGXohOUCUEN4Z5gbotAzRgLyg7Qy+EDbeLzDCcPDsAJxzwNPxd0WCTUEQplKj3Iq0DIAb+sS +lOLEIBI50EzQUZByZXTAqCFKDSnSoOQDEkpNz5ByaVYmbBIkwQ5J65jFEIVYaFJA2DPL0IjIgNon +GFuThBWapIDRuEghFiwxsIm0Y9C2gD6IlS5xjL6KsDRxMmEeQxTiQSINMEJmxAeVBvAkPPE50oFb +kNnLIoUEOIG1J7BMcApoYQyDJUgYoi3ZAoAo6ZlDkUAM0BNAsCOoAvBNLUGd9Y7aSjO2plYHeB6i +kFqRKkiENUNm35AqQzvgLyE9SKdwgcUQhVg4dASQYlNH8EByYfGSNl5aRu6sUcNGYoUPN1mEJXoe +9VnGLiyUw92gJ4coNYQk7ByXCiwQgbp3dANosSFUN45Mm0dEIlQfotSIQquV0CIygSxLwlaNKJnV +pX7RFnhuosFHU0AOQBKzSzRCqKFpSEF12QgjDvqwuiC76Gw0SqOUGhoLoVGywHlwMBy8VGy58VIQ +ykBnhUYtNFQKNhWe9waV1KOrAS1wZyQ6L1ZKdGdGKTUcAzkA4MkB2hqmJIIgHwAHTIcCRQYzjRbC +cpcCp5tf1/Caehe4KoRSAlFNSPJGB9ZkZdi4oGGT0SrJBkkVjB0NBhkdQmI0kaguuLZSoBWjYWsm +2IQI6FCG9R8i0bgEWBIgGcfGCxAfJ4tyrnEd8llkhMLEMhLtJIH14DEHJi6l8REywJKRd6gANDXh +5yiFtlZr2hsnQIKYkpAgs++O20W+JrS1Qk9h0M62fYRSG1DA90El0CL4I+D5gMuDIwN3lbxNMho0 +siFKjSnWMIVjCgZkHRP4U0SRkLepULporYcorC1GBY9TsGtFeAbtBKHFoH9PSK2tC/oyRAEegNHB +lzIKxAm8N+cT4pFhi00ceaAavVvChiEKQQs9i+Ag6ZEM4Tg+yWAotAvAFCjEQmZIrAkFPcZtxBGQ +ChHPeslermFQLBIYE8kw46i8DBStmJDozMVhINWg6IS8Ab0Jy9AzTtj1VYyCwwTGbslTlz5hb9t5 +GrZUzJGCBUTF4GsX2sF8eM+L6yggyEIIh8iD9gi1n1xldn5GKGzDDLGwbLLAiLCZpOAxxKpoem0a +YpACgZ4XoE9kvh05AN5ZjnMEuQfeSMJC8ifJEA9R2BD7IKo+9RT4aPytEQUUtkmE0cdgb3OUQjzY +X9O8XWjuyYUEdYBIn9qK3BQ2gsNtdmvQy0KHHl1QibgvUNHB6BhyTUmsAUSkSUJQOUQh70p4MHLo +nyXEgiAXFJGuRYrX2mB0RY8PUci9cwLiHEuOCsffVqOLyOFhoRnC2hEKe4geFBetbJqygwgCabK4 +N29rirE42i5SagWK4NjYomuCvjGuBzmdqVYY8ydC6pR5DFFqeYQOwGLZL3UJpQ2k5g== + + + UYHQov8thMhGMUShpTQWbAUgb5IYdsYwyaHInEvSX4QENKsMZsMEDmC8o1ACUxWIB4DhaJ44gBkx +Vyu3DBgatpn67wVt9dHsEPzqlGw0NR0dvqcM1GrIQuWppp9e8M9ogIda51KMKGwKYvo99+FShC0T +HDSH4ALiIRBNgQKuOMXiEJXyKmnBxhVdD4yp2a1T4JtqCngDyAh0vCAe0aimtdL6+FUx/1QoSwAA +4IEeCULudxyDBMcgshTrB++dMmWW0itJ2HF0xmGSYSLk8lm0gzRsmL4Wis2qpTACpo/hLU5fYmhK +T2mLnjiIOxql2q3BjKPkLhClDQCUFBpWyvRZB4Mkz06GMSD0wxCkSrm/FNqgoYnMwmb0UNPck6Oo +w9PUKRSr3epnHOXfkt36KKG2zOnjtV6H0rVzc6XJyZ3WcXe/3zo97/ZLx1et/3SjVq93cd267l7C +J9Fxv3t1fdHvRlcnF38iBR7Jbp+cXNteL/0f2+SmUA== + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/originals/SVG_Right_overlays/Green_right.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/originals/SVG_Right_overlays/Green_right.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,1574 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + eJzsvWuTHMlxIPgL8j/0faAZaXdoZcYzg7d2ZvVqLW/Bh3FIiTLZ2hg4Aw2xiwbmMBjqeL/+/B0e +WdVAAyhJFLc7Dd0N7yhPD48ID3+Fx0/+t9989Wz37ds/vnwWb+eb6Sc/Obx7+eL923c/vyHozS9e +v/7xh/fvEPTT3/7sZkm3MzTa/WL9Whr+w8t3P7x6++bn9Cf64x1++qdfvfjjy5dvXtzsfnj94v5n +Nz/9Gfzld6/ev34Jf/v7d/Cnr9+9+u5P729/+PN3P9PXAp7ji/fQYln+bg5/F+Zlvpnbz3PBBi/e +/PnFDz+8+v/wzyWuEWD7tz+++fbVm+/2b/9fBN7MNzHAT/jLf33125c/bP58O89zdm2Ob7/58f7l +m/e/eff2m5c//HB4+/rtux9+fnP4y4s3N7988R385cXNP718/frtv97sX7/45n9O0O389d2r1y+h +h/cv3t8s1N/dL5bw9f7HV6+//dWP9398CX2PpSI4fk0of/8D4AK0+DuC69e/uAfIVy/fvwfa4IXI +s8Mv/+m/HYDRb++pHQBv5tvlZoGfP/3N7le/+/WvTvC6dnNAXv3v9Ff433yb8tAiLNk3CQUx4A/X +ZGgR4fO3bcARKzf47d/vPWeIJGz4z799+d0rmhIwXP/9Z9LTd2+/v3/x7n/+wM2AxTHwX3738v77 +1zCoOgj5Zsn4TX+TVsBVavEsrvXmWSgR/hxbuQnN2vTxevnnVy//9ec3v3r75iUPyu7d+694ZqQ0 +z/yd//LbH1+/fPf7N6/eA2UFQY1H5Zdvv335Gtrb5+9ev/juB+3k0r9zg9+9ePfdy/cwp96+/vE9 +TfdV3wCj/vzFX17i1Fn4Bb/+/uWb3739B6LxWV1uYwQ258Y/YUhiWW9KhNFd6RVphl7ON7N7N408 +o0dkiErfAVPrJ7+B+fNrWD6v3vxcKKxf//27V9/2OVXDzcrfqBO3q/vX9B9TCx1///7lG6Ee5vLh +l25uzre//AreeHrz7eHtPXL/B1x3MAPewOR4/fY7/pv9Tn+Bj//4PVNP//8aBuo37169QZzTr+gv +69e/ef0j/Onv37398ftfvPmXt9NPWd787t2Lb6DZza//+D9efvMe5IYA+m9f/fjq/cvbF6++/9kH +Ef3m9Ys3L97dEBw+zMDnr/4Mf3kBpNzwx+AvHfZxpMeX/wJLv3+Woac3f375+u33LzvcIC/efHvz +jy/eff9x1DAM7xwG+q/+fERvX7z/E0ipl2++/cHI4v+OHWXYx/F99Q1Oinc3+3c//vCnm9+9ffva +0I5/MuwCJii2/+t4x2/oA29+/YYZdP4mabB9EwiEv7q3QOuH3wB//GvGfnjx+vWr7969+P5Pr765 +9IILf7c38d8+ZWL95f6Pb1+/+uG+zycH+c2Ld+9fffP65Vd/+eH9y/sPYUNu/MurN9/CRCSh06l9 +e/896hY3X/3pxfcvCef7P91Ry68MYf4aBKMXfc+efUAmhnizf+P+/vfvXnz7CsQtaEv71z++vPkt +/PfF6xsF/2y6DAZxD4i+nf55+i/TjF/LHOc057nCs85t3s37+Tif5rtlAW0hLmnJS1nq0pbdsl8O +y3E5hTksIYQUSqjwrKGFXdiHwxSO4RTu4hyXGHAviyVWUMRa3MV9PMBzjKd4l+a0pAhPhqekmlra +pX06pGM6pbsMtOQlhxxzmnLOBZ6a19zyLu/zIZ/yXZnLUkADKPBp+HOZ/i/tTP9a7N9y8X+oOgb7 +HuUfkEbsiHOeiCv4T78X+ZfktwIcK8Az/b4S//Bfc7/t4N8evu8m+nEg9h7gHzKZvwOzgd1IHHxB +Z2ZURIGJ/Zf/Mt3d3Z3ujneHu/3d7q7Bs97Vu3KX79JdvAt3y918ujudTsfT4bQ/7U7ttJ7qqZzy +KZ3iKZwWeBd8/Hg6Ho+H4/64m47tuB7rsRzzMR3jMRwXIOvucDocD4fD/rA7tMN6qIdyyIcEQxcO +C5B+tz/tj/vDfr/f7dt+3dd92ed92sd9mPYL9O9ud9odd4fdfrfbtd26q7uyy7u0i7uwW4AVdzRW +d3fUHezQkTqF3cKO7axz2L1KXcROYjcTdRU7i92FDuODSE6niXqOfT9Q/5EDyINGfEBOIC+QG5k4 +gjxBriBf8JmNO8gf+JqAScgmYBQ8jXi1Er+QY8gz5FrqnTn/Oj3yOW6f6RwkPHrMsz9/pgvA3fkD +nUk3P/l6/w76VPCr0rPC0+SBwSx7emBeAB+QqXeVREcFEQHCINKTKixZ+DB/rbVNtcGzq/sKUwqZ +CCNyt9KKWRd4QIasICjWtMJKX+mda13xq60wi1aYauuBhuCEU6PNEywtEEkttNhSA+EA5NUGrVtr +O3pgfjaYwzh2NBFgVsEiBCEGMzHAfIwwKxPMTewUUEZDieuP1mGgZyERyE8CURhBFGb6Db8nEIuZ +nkIPcqBgZ0hYNvi5m+iXPb4Uvu/l+4EeWG/w/YTSFGdzIDlE74oBv0CCgoTFB2QhSFkQeGGdSNg2 +Eri7AIsSJO4Rvp/gOy0MkL0ofReQvogBxSwIUhgTNIgrSeMV+t5AHpNEfkDaILd4+RD/kI/IT+Rr +Iy7jeBbie4IRiEARdnXGwYEhOsJgHWDIdtgUBrFONKIZxjfSWC8gL+9wVcJMOMCswBFoMFEqTJoM +0ycBqQEYOsPyx0l2hOm2h5FqgKbC1MwTyP0EO0AAzs8gH06wIg+wP+yApBUnH+waGfaXCMxbQGTf +waI/whazh0FvaYU3FNh8EvAnwEjOkeUSrml6oj1BHhqv48yPLDaRNwcSFgf+2tOzo6dNyLgDMeNA +Mx+XDQjUTEI1kWBF0RpIvOIzk5C9I0GLovZI4hYFLn7tJpK7jWQvSt/KqxFkMErhRJIYZDE8NNP2 +M4lkFMoolo8kmlE4o3hGAd1Ygl2QBhee9thnGv67ftJTLz3TRXB55JPPny7r/tmm/c0HfuEnwL9y +k+fb2mIFqxkQgOn79ecj2P8Ab08ziM+ATUtqNV7EUgJMZDTJV1ja1KatM6w6xVhvY1viTcy3LedO +1/VRE8WwtBZ0pt0GUMHWdBFtSHXOiLaAkpjIiQT6EjQWtMstqls3oIp1cq+MF2jdH03RVg34sgp9 +9+Lblzfv3978459QjZ82/4ehCqw0IyUZRBD9EiuoqOfiE0hqYcl1/AWpHCcd4rlRPBc7yx8ff0E8 +NpFG/l0PJQ3zF6KbAV3NN9ejzxB+ysCSJ9lbRRsAYRV7yIRoMiE6b0Soik8ToE7HTaRVBNIxZtJ1 +ZQM9uK2zb5uwcZL0hS0aN+sZtm/cxvewsTfY7zPpAQvoBqgn7GB7RXUjgn5yBzsQmhJoiYT57Gtr +CZ03IJnfJWgWBRsss7sg6nVAi2RQstG6OJmevR+sDNCsJ1Gpl8HUONLWSN/ZSGtiL2Wxq9DUimKI +6fMJX4/rK1mPaD+yBXkAXQENgTuxJNmWNGtSNN9VNN6Ntov67uSU3UTKbiFld0VVF/VceqvTTlk3 +baSVHkgfZV00kBaaSQNdYYbsYF4dYJ7dwaxbYP5FmIkZCKiw2Tfc+/egChyB93egKCygNERQITJQ +V0HB4L3cFMCFFEA0w/ErmSpIXWU1nZRBNM8bmeg7MtNFMSRjHZ4JhzWS4ZVovBKpvqyZIk5vNriO +7GSZ4II50uK5o27N0rVAb+LFlnlurGQpH8nzEEmtXkljPsJ0DKQHV/E0qJsBe8dGGE1L/oKpytOW +JvAi05mUY7IhadzpQc3iguugf/F8ZAdBpN5ns/yBWvow6aSslRb0VZBayorpgi1JOWX1FBVUVlFB +SaUPf9BW7qKjC47EujYP9Y40eXxW0e6rDC8ONA85f+FE4EkB/fAjJmwkRoqlsMpk2A/+GhzxZB4b +UOTJazP6bWDMJnLcRGiXSQvnlddX3bjm+npjK5Pty8G2nMi0DLbaumHJq223tSrFrmSrkm1KtSrx +I+tERqWalQcyK8lJgGYlPWxXBuJsMuuy0CquYmXiamZLcz+dmZr6sMk5i9nJhiebnmx8sgHqH+LA +JD8+ODU/8+tvFeFiPxdz7C28t0zk14vi3yP56Laf/luxbanSFlVkoVf3f3LtTey3oPGhNVFkNezd +SsBlkJ3r0jYd57wsss3wpIcpD9Md5jxvLUm2lGbT+0TTOtiUZhcJzmS0tY8yg3Xuyr4z0YTd2Qw9 +yZzkzSfb5rOTzedI0vqOrMcgEpq3oArTfIcm6J4sUtqGYCNayHqNZM0WsnFXsnp3ZAjj1wmNZTKc +FzKlcVvJ5EbDNbtOx5U8bHvRFY4gyu/QJUe6RKAHXXbIPpIK5M7jNUsbCykjezXGT0feDI7etQGm +/d4ceerCS2LeL2LQn8SIZ+enuj+L2OpRbHR2gp4mM8x3Yo9X8YbmUX3cqI47EfYs7rviGCaW+qg3 +ku/lKNJ/9LqUjddl9LucyEV2IHfZbjL3ywoThf0vmaZONC/MgjOZrGn2xRxpqu3FI7MjebeSX6aC +zUNqTjYHTSQnTSBHzSKrhHfWkzhtjuS44Uc8FWVnT5tYqrI+as5c58vdD75c9eR2X656crsvd1Zf +7nQ8mTtXfbndm9vMm9v9udl5fgaPD3t7JufsueDqueDnOff0DL6eCZ09g7vHO3yc04ee5vw+6vtR +7w/PujzaL9FcQcE5hBa1acyu0ec0PMSpSX7g+HxiUMDCAg9FBaZtYEDUna3CYyoPTfKTOBfZtagz +m/yKE03qxabz0SZy0wlMMzeqa1Gci0dzLqp7sbIiNzlN7lyP24mrcSVXIzob2d2IDkdyOZLTkd2O +R5oB+4m8j+x/RA8k+iALqVSJPJGRvJGBlC02jVDt5gnO85InkQ7ujjXAwXFvQmEehMJBhYLjWzWf +bDqTB8a+SYSAigG//nXtz4Ob1vNSnLWekdMFPnouJnHaBnKtex7uxXnbBualqXtxjWPMq70pyKuo +xtlUYlaI0ea+2+wTB9kp1mGXeHxwbBMam2gRzB8LjYm7vc/+rvD3uX9gsa6Dp+50daaP851nu8hm +Gh8cmx2J3NVGJZQwiQu9j0hzo8FjwQ70E42CTmGbvCMDSR/fs8JiUZ5lE9+pprqMSvidKOCqfAMp +k+jdqnF3RcarMmETz1mdGepMUByIyexP1W1Yu1lJvu5I5h5IDp/E0p5NyWF7O5uig6rObjJdB/cG +3CNU2+n6TqINxnQeUXlQusJ7WMCy0sTP3pSng6A9WrThztQpfYm+KFjUAmOT8k59r767SihzlY2Q +qdjJBslKmCpiR9lET7yj3oleprpZ18+CbMNJnixPcRpb19pWNo8m+rEblDinxtnTvyxoygY+a+BR +dPBqWvhho4enQRPfqynqNPHcdfFJlPGjxDZVG8+mj+9set89qJHvZUpTqHKjkg+uoEvOoNEdpBq5 +uoTi5LxCq0xZnbDsGFpMI89OJ9eJdfAbhoQsXXaH5HcsEn8slOGxWsjxyN6XwXGQyA== + + + cUCug0myPfY0EU/iN1L/Qfcg8GipD+FII9azPxZzI7gckCpevL35E7xHIZgXL9twrkPUmv0Kx0nd +eBK0XmQjU2+e+hi8l6FJ/HrnpJvIt3o3uUC2BrO762EMaeuzSnBbPRG7dd+faRVdUlaqLpshUCbO +iu6yWMxx0R9xD030bRDTlMETQbYXIpfyd5xXTVN31A10J64/dgLpUusLLUzm9imPW2cwIEcbCRwD +70dFH6owetxC+gaCX8M6k+4n8db0bAB2zxwnt9Ie2i72bsXJdmGeymx2sCy7STYL2SgubBW6Wfjt +wq1Dv2OgSJ+GbUM3juQ2j0L2ylaE7+zZj2J8Ese7G3fnwd+JB998+GJPXXLi7wf7uVoKTJxEPVJL +6TSY0d2QrmIOqSndjWkNdYvFM5lBPZrUGto+D2tvQtpiXKt5nScLzLjQzAfSG3yCQ/HRGjW5J7a5 +BxVbLW+vaO9kfau6XUUKZDPE2RQX00U18EXEyWyRbt0+j/Yc7NkPD0uo3UTfyKz2MfUxHN4zqjSr +SjOrJOxjgR8X+plcntXB9mzdw5vLuerWejU1ILsMLLHdJzPfg0vIWlTPcClQJ2fRH82u77a92PeT +LIVmz2pP52CxJ7snXUgAgRke3LO4Z+7PJg3rNDzH8ZkO51/7s2f3wNPOH9IdOQxynvNnGX8PJPx9 +0KqZxEPxcQN/a92M9o3Z+JP5tXSpqZmThiyi7slSk3Vrri5s90wui2hvHqvqTNU4mKne5N+bOVQt +fpOmCwEczi/yIRwJ4liukToAvAtAnACT2LAnmVvkCxBrlu1ZdgiwVauWLdtW2dwDqTsJpjHshskE +QAPYtT6OvpawrB6Q6proF9g6A53qCZxBwYH/EG5RBxoTCq6LlpIK6jJDA2w2p9wo3aS0RrkAZJrj +kaOU54YvyTAyAVMAFsZtKQot3gaYCZ3Qq2KVHJcAMxMRhAa4EGNo85KHvi9LLQgpyoSAXe95Pjcl +3EaYJz7F5ZpoidJlBZwDglAKoBiGLUNfkR2NkNM5H8YW2y1uazcxYQKQo/S6aInSL59OqdxSitCC +zEnhmjN1i5pTYNYax7ypJaxp4EojfxL+UkNONKIzskUZUW/hDZi2tDSXCXNdvJ+SEPP81ZuXdOzJ +MmK2kJ7ttDkigNEwPiBwsAMCeDygDgbknRwPiBSyL/14ABqOU4/bbyyMk9gXcRNSu2TMu6DalE9i +X2yti8OZCa+2xbkJ7/xTkyUft60lP7imup3hfVP7dpZxPF20ONTm6LkSh27ru0yJs1wJ9POry0pN +EXZc7SRg4JxXZpN0q0QtkyTRiXJYUX9g99VJgnTssCpkYezEQSVTIchkyJoFIROCz4zMcmqknxtZ +yS513gWdIJOkOGdxMbhZ4s6QpOEUyTYrIXjvz2Q26aPcPxcN09Xl/JCn4GSeguCyfepZ7sHJcg96 +Prs6hWw6TVt3p5tVYZNtsM1mH3LZNalgcsnseWPNenv25DxIwVmzW8/ncaKIboR5gfYq2qlHcjYG +mhD12D42FcbJMLtDRH06aBr8USbDPA0CY5wM3du0uESVov4mmxLDpJge8AmO02I7MfabKH1PDMvT +hTyVUcQsmxSVISFs6zRa52krd2ymeNFzebJcnC6Ty0o5O/sw+Mn7ZBkdH85Tjm4PjFzgHMHZgULl +JMH+JJOj/e0kqPTcw/BAtle101x0jut8hnO62vkhuWguVElco4ms2x9O38NE/rWFRBnueyzD7mCa +RtrrMH/qCFNygamICbRNXWcw5yLMtRXm16GeYDJFmEQVQ0SH9QTURpgbFabDASbAAsNeKM/jCJIg +gASoNK4n2B4CjegOUzXcUl9B8h+OJ7DCwwQrp1C6xQG98HcLpdIVmJE7dFzd2akuf0Ttcw6oDcbq +dM3jaWimTh8/nvahpDszTC3+PF2Mw+mRFh+H88dZzg6z9JMs04WjLJ94kIXCnxz8bHGdLO4ZLeJ5 +oiNDnGe80smiDJOUso3pLNKJMo73lHO80qEmPvSEB6JgOd3RucUDpSD3dN5E+VWLZhc/TYWnqfA0 +FZ6mgpsKzl21lnkm3wJoZ6U1sslbTlKLhOzPS+dbPu1jcobl005mfcmprk88mfLV2395z3WDbv7h +1XdvXr6ng0eXoP3MvvJgUh5MyoNpmWZ6hM2Pb/nIAcFzMmW9Ba0z3dR4C4pt+KSRufR5GqLHfPa2 +5CUkrI0TF/xAvFnX2xpD+zQSHkbzeEpa/ryZOX7yUybK79+8eXH/8tub7wR0AysOZspFME1H8d1s +qi9ctJkvulgeMJmnM3u52hkZfxp82eRMjFkTLm9ispBucakTzuXiwrrd5VLNLD5LBdq6WvJZLtAQ +3hU3CxnFDxszvnbEeb2IKP+0WEQvGlGwhkS3HqpVg2AjeUcengOZEr0cBBeDoH/wzjs5jI7nYfBf +mEDkBjuBrmfP+dw5njqvfO6c7JAdiet+yPxkB8yDHDIH8T7R6fJCZ2s0z4MzPfZkf/PRcszvgT2C +jo/omaL8wNHxa2zJfkeerrEl+x15usaW7Hfk6fO35H52aVu4Ylu2Ylu0YluywtWrmIYEZ1euYkht +ni3613Oa90PQXsP2ZXKRexe7H6L3/Zj67iyAvw3hU62Q88PpH4njc6I865RjEYtLZ83PD4nnTeS7 +x77jtAl/uxD4WRBc89OPFyPhEgufXDC8h8PPA+I9JD4ExV1Su4z3NIbFXWD89LHA+Kh6wdJva/6Q +UgOb2NLKvHJsCuQN/oKhk3RRS7oWQo66NZBfieJ467xcRhZgjdMp8aK/SBjqstJ4PZRftmeH9eKe +DWC/Z/PYkh69t81iJ2lelBQiZ5HUNXXpKG3oh6Am59v6pJO1/uvS3si+X44IUTyINqrkSkVxJEjL +RDVJHkRHLnm/JlJN9hL5CVQOqheDAoWE1JEe79mRF4xds3Z8iigzz2S0ZKt+BMknWZ0sb3YZknN7 +ei7pJ5OEPXaWSKV5sHcu+VWTXjXh1Se6rqc2Zl19UnWgS+V/NoWApk+p//NQ0R8WpZ9phl+wwmnD +n758x5eqJC7p/GDJ/6vtpLqX6m6qJq4auZz1X8zOjRObumbsqrmrBq+avGr0qtmrhi+ZvpvCIbnM +LXhJUlMOHN9XCxH1fpR6mIKwgHZRLtuaX4pptHZhRa2Z5OyyYNkOH1fm6h6ugMZMoAdrSlwL5ZeJ +z3hResaxnl1TH/3wyGEn97t/DsPjc7qO0/hfUc/dMy5yO34ZhyTUS8f+x4P/o2Fyp3Hfyc7/l8vH +E/zrScpcqHRzpvR8wjONWtL5Q+t01K4/Qbn+XG+XT19/2i+f9sun/fI/zX4ZM0gIv3VkWOA+b4u2 +Ey7oBH/kFKiL++WXYuL98st23bgAaK1X28UV39/6Xp4ub+YpjqYQfj2lnj2lnj2lnj2lnj2lnj2l +nj2lnj2lnj2lnj0lmTzlGz1Nhaep8DQVPiv1DPfcT0rqWtAmbl+QFSYIHpthpIcR8+2Mx74+I/lN +P/qFRnq7bKQ3Z6Q7jx2pyKoek25hhnV0NSO6Ua2aMJeLEP3XzCLSetWg9roua7ljStHdUB7CF2Fx +RRGnx1fi/c+rXXKeUpDvbCbB941z9UPXgJyX8/9ojf7pgVr8j4lBnAcVQB70dIxtUsZZcgZf2/Ax +T+snCunpAV/rZ4vo6aFcpHMRzRlBHyrOESz75yQd/0B5DmbCNJz1P1qmz3lxjjjUubyz1J6e2LMq +h4rl9Hyw1uUD4hc4U5ZyUYxKbghIuoonXiltZMmlfThJ9wsRjj7XUuaF/bhrHB26dtI50ZFs85N+ +xOP6hQi/TJTny/5WAONNnE/+1id/65O/9cnf+uRvffK3Pvlbn/ytT/7WJ8/Kk5PtaSo8TYWnqfBl +/la7dWPdDKMOIg7hpVsSHjxkNA23Iow3YY4njcabMP01bsNRo+niWaPkyhYurlyov5NDqxfqnRxS +InRy1ff9VBlLGEZfwnCYMTpnbMZMD04ZPojGs0XnyodmisyTSSZKnyac+DdeQ9fnx3Z2jHMDZsaE +E4Nmhc6JPiMoh5addA1WM06CIMmPuIZxBWcY7gWGWEvnt7NzY+Zhcv6l/SRreLxMJV8s9joWet1d +vlFlkmX+0O0J56M43JvgblHhuqy76aFLbTfX2uq4XjpkOEiD6UFxgMP8cXGwsyRPkQfTRwSCFwle +KIxiQQQDzoDpgmBwokGmgohuXPOBhv5EyxoHHoecLky4cN+iLys6jPN0cZj7Ih0vzumj/OAtGZMN +tb84xy1ad33xtvQoj3cvPkpjPm1k//aKjPGSjGW4bWR/thXA6E9u+B+zH7gdwd2F4e7BmDZZvhd2 +hmFvGHcHtz/wRMDDEwc5dfGhqQAqAyoMOxiEQorCQkrCAUZ/hRWSQDGYQSk4gNBenfw4wfaxoykU +4C0nmjwVJEXAHf4Ic2UF/ka6VuMA06DCwEcgA6/Q2MEQZRjJhW7M2MF4ZWDIYmcSGgxIhoFY6EqM +/US3YWRYbwswm9cZilJk8ALMRcYiW1WCIjP1Gk/mYJedxLvJWMf3eQ5Mczxrm8ML5wcW5IzC34Bd +ru6F7mf6kMMxbfxL3bs0uJamRzoaP+BmHP3S0+ddKHHRP02exekD10k8cJnEhy8VnT5wq+h4iYS7 +V/RD14pOcnGEuIzJP+idxlXdxnLo444OewQ65pHpeMdKV3zs6UKP0+luoms5+SrOTFdwrug7R+81 +3i4i7oWnqfA0FZ6mwtNU8FPhs8pHtfl2mdvnZdHIRz+vjFSZb1Ns5QvShhTDJ+YNfVa5rC8NMJfL +tQ3K+qF6ROdx4M21MuQX/8DSmj6ytvzq2t7h5BeYRYYnF6K5XJHo4g1lmwje3lbeadLAsAvHjHHh +86jwWJloExOeLJjXb6JZLSash4MPHwvXLMNvWtxoLHPE/wv9f5P8Gu27xk0iqaeFax6JwlroHl2O +p/Bvq5RBKnQul+7R3W1qIm2rIp2sLpLUQ6LKSFoVib/3ckhpkmpIla5R2UktJA1BcjUkiUvTxeBa +DylKRaQoxZDQ6kHdfTdRLGdHdZD2ZBxxeHKWOkiJbkp6qoR0hUpIg336aAeFuCcul1H6jFtjXR2d +w9QrKllu1fbO2PMbY+ezwkpWWmna3BXbb4r15ZUG3+emxNJYZGk3ndVZGistXfZ/yuWuQ7klcaRN +zgvqai5tPWqXajB9rA7TQ7WYsi82MGQBfqgmk6vKdLkuE8yE6UJxpn5V0eX6TL1C04UaTdNQpskX +arp0gdHiK0VcuMYInulCySZ/m5HMvf9MBZxAasxrpWpLNaT1IrKFk+/m2xIk5W3Nqc3hgRy666H8 +MiVnLReVHAA/+sIMLvmgNsolC4USYh5KvNG8BDV+LplAgxH0EKJilhSj2yZ0IarBnjqrzvCxON9H +o3yPDRh+NGT4EKKPxR7PUI3LDHY2vlBmmUEZoOuC5rnUNqwKShSivFKZdHzFzOV5fA== + + + NYx/7YVtz9ZIuJh/GuKwcD6WW3mxtOdDqZUwxtOgRY969HiR45hQuU2ptITKabj/t9gVfOtQPWW0 +h8Ea5ho55/lfdZN4ujUwtibGYGRM26wvxyPPq0cnC04uW7AM3NmJJ4Czh9KYLkidc8mSvdzrmDJ5 +tJTJh5Imq1yIusPoS8+G2+bDXU6cHA2vM5ZMQ0pu3W2vh8Y0qYU6X6TLOAm4cy6zeXtDqqY08+2o +gVK6Kp1xOcr5Fj7dgsnLJ6rCk0qZoLtyogVMo0hnWRrw6UScScCLlc6t3EFnyWyHTh2hIwGor0Dz +njL2MF1vJTrvJkriLMAuTuBcegInTOTj8Q5kWwQ5V4Epe5CAeHdyuEs8cp+k3X9cuZ8+qN1vdPvH +qPbTx7IRLicjUOeu2zXMOX64axdMl493b/p4ssWl7vHIfaJl9rEOTp9qmX2se9NjcknOu7dx9OEb +cYMEVaWVRPV0agtcRCcHqvajmukcoFu0mW4uyxsLdV8LI19o1+JCSECtAjmBhzgy7O60t5OudUNO +PC4pmhAbNgb+LrFe3JmvhfDLtuuL3rxtodJRz13P9NxIxc1Qezz3xW9Tv09xnswLf6lq+YM+Qlf0 +zPkHvd7rdV8fQ/BxBK9I+2MNXQeGqTu50ILr0tAtn9Xu4ww+1kDxBu+hWyQNOZoTrYrl0GafZy8l +CKUu+CJ1wZPFPsok6nq1GuB7l35/ch6vQP+SUZwdzY2W8/6TVf5PSe2r0zUT+7wJ4Gn0VHo6PaWe +Vk/tnT9V6M8VOqoHuj3lnnaivlOoXBxp3FC5oXN/4SwgXZ18fhRwbxl3q7mp7Bjg5oruTjNQ/YWn +pL/YuphvI6hCbB+1AosAfyktj0XeCp6WW0lqo3WPEQ0qV3ZZ2F8N4xeJ0xguiVOAfuE9mycnd84O +VU0uqFmlcqQPaIo4/dLTXruzAz4L6jUPHfAZwq2POV60pcCHesvmvBlRMJ0JOKVBqeCzidcTbhcq +PT5SuP1H5kw/5t2f/PbpkpA8f//Gn4mmI9dnh0Gj1Qpm3TJWUdQrm6vehfvBdX89lJ8Z/MVLj3P4 +kuCvYPgywXPR7RLHKouPSvSlNN9HZfk+Kln0AavtQnrgYxIOzzLnHkLnQ3OPSU6g1IRHJan8NaPz +Pk2UhInc5bnRTd7IwTAcmhe/+fkv/gajdrsuw7XmV8f8iQtv/tDZ+0/59BctuHQxQpAuBAj0q1ee +DpbcyWme2bnqiySCckJopfj5quZBj6L3+uYSOtwULb+z2DlvpYvcLbRQFF09/3EiwyfKIiuy3IrF +1vm2oVVi62pjcIT9QIuVd2ONtZ8mDd9xP/llIUjRYP6KckKcn0ySiAPxfDMR303E+/g6ia0i/6Xv +em1Ro4uL9AIj3vDZAjvIGePxO/1tsiZH97M/pwvPHXk/hkAljpvXauKgyx0HXU5N46PV/Y7S5VX6 +wOoSKUvTR8xivcjrSJ7HB8onuFy0NFm6zDYRLZJPUtNktvV14kP1dSZLQMsXK+ywM/pC9tkDuWe7 +SVzxd3IUOWjymeSeHaRGefe1fyT7bDqToZqAppJUZalKU5anLFF3ZLIdSK4e/Rir7prs/PBqgbVm +6SxHS1xZBj06W75Km2QxmSora0WVfE1O0Vu6dk6rPklWij82nzXfaiXXnU6cbgR8OK9RfSs6leDf +dCEJa5vhOOZgbWty6MSS3KuJUq96biPPK3T9n8j/HWhC4XTa0VTiiRRkIvG9CUeKXwSaPnUS530/ +6YzVLvSkc5FzznckldAnzsec79AfDqPdYISPWnD+b+fE+785wuWBhybwJLuburjU0ZXO9rdxX7u0 +oR30Uo5xP1vcHubj17zA/Oa1isnIZuNOjaC7zVUC480APrdlzGoZs1mkoNU0ZLAMeSubfBV/g9iY +njKkpUxDPsp4W9iYfjKknQzpJkOWyTSml1BqE3uMxgQnNuQ0zUkTnaJsiktPd5ok4+lOEm6OLu+J +3Ux6sRwnP7HLaUyB0mOglAg1DblQmg+16CyQkTm5vKijvKUfDpUDok8Hk//2DyZfLZfksjNjHOXP +HufJ5XN++UjDWE+Pqyj3gbHejPb0WbHDD4z39Ojo4UdHfGPJrnVeMBjWGmwmga7VgJ0gruTaEYfO +LDk0C0b0HszK+VJM/+mycS4X9sS6nmalOk+J7fK6hfdCOcWpujuzN090tdFsezHvxJaYPW1ysiUb +m1QEzcJOZAnplbSVbkNaxbbbmXkmRthk2diRNF/SfWmuserLtcR2FKQ/kuV0IhV/JvsJFWBUgRPd +kFOwKM9ESRyoC+9ofh+lyhifSMD+B3kSVe1BpRjVYlSMV1otXF5K1WO6N3kmLZkrTXGdKTyxkOno +Lxea8qWmDlyNzOqRLXKGgdNs8kSZNuuQZ8OZNrjsz/NsKNNmNEyjudp57NQ4XWjMPnySKvcqR9PF +M1QrJcbsLgUctqen5IxHFE7WyezVA7LOWRbetjg8cHZKD04Nd0wnyqoZrdaj3S2tZiuy8iNlYTl3 +ahrOTXnLVW9nOw6npgJldhfK0DlPEgPTdRos11Uu0rrs/mPj9ePXZT3u4qwHr9OaPnKn1sU7tj70 +nN+/9aF7tx5xG9d0oXTtY4rZPvhMD1a7/dhTLz/TQ394oFouPaNFoqzV3it9ikKtDjU3Fosdq5lh +ifCfeLX0w5dLo60wPeZy6cdfL33I04Xrpa9wwfRnXjEthx18AZG76UJxCV9eYltggkpMPNkef0u2 +xwMZEhk4EDHQ0TBENpb2LalS2kFWRRJL/ab6gCp6PZT/6XTScjFyAtCLteZJoeENfWfuwsuHoCUf ++MJmrh7oI6WKP/IItN6ZWYfN3Od80ynoyTmiuyuaNnTZ0hd3G2YWr7Rs7eaZ5sPRJxTmE/u6OPWz +V5/tbnlNptbccubOeIB1bxnVd/4gK9c9SrSmC63uRut8Ryv+sMkuj5SJjNKhUD7y5vZalLcTJVOL +S1ZSqtkve5Cs+s7KSnrRjitSiqeWfbXord3zLaITO2z/13bJ8mbysQr7H77r9/wC3wvH7T5cef/C +UTz/TA/qlQ99HR94xJcop/io959ytvUx+86npYg/YteZrpc/LQdbpWYQrfuVDlf0ylLhQjWxgyst +VaU756WlqFsTGVnYM95TuX9WYYr6yL3sNca218pyd+Vi2Qn7vKk45e+W5d4PdaeEByeJum6ul504 +EPzgxosllzD9uaW6tsu7JBb6x3SExJX/P7jXfSHCcdNt0EvKNFzx1IokQvCO3XTnxptVKWmCrwD4 +iFbwpRi/aIOul/bn+qUpjE/3BzzdH/B0f8DT/QFP9wc83R/w2Yrxvy/Cp/sDnu4PeHKKPRWNf5oK +T1PhaSr829/X+vgihuM570/62H86f3m7eKawbc4UnozReyuyt5PsynVTXrrYb5dKTdPPacju/Fwd +64ImGOToM7oMyGEghZLQCGA1SXPkWUFqlAVyJE2f1KNJTjiyawAtvSy1ODgr/uSOiVdK0thb5rLl +LRNlprpGq/Liq7uot18zz2cJ4qvnX7PQ2f1f8Sgg28U7ip8eJKx/ktD+bLGAHg3QQH+RtM+PB/s/ +Esz/WNz+PDb/mBj9JtTO8vsz5fQFMU1Cevrymok7Nj02lfJHJ2Y2+acSUGXgYfBfFhOEcRrcl8ez +NDaViSoVt5cokGx8wK8JM3jNdCZqWVoeCrM1PqJod4TCnwj0MdfhF6NkAZnLPN5dCh8IrXghhye5 +sEQc/II1KUK5LC6/FNOXCc+L9S3aWN/CCoKqwGEXw50eyXG+Ju9nGg9UbMpEbz1Ml0pEj27JB0pE +o69gMp/S1jdpnqRRblwoFbWtSMvhvN2FWrSLhEd7/awyWXmonfMjjrHS5E7tcMR0R1kgFjUVKUry +c6I0kkyxP06FapYMJfHTsUdfJGEuHYq+IGMeIWEeVgOnj+uBet/zfpP4P5Ys3RYtvZSoc9pm+I+F +S9dNXn8akna2aTub8qWTy+Fvh4sFTDlGtadZqdcY9WjVNl7FauzDl6FIzGrSoNVwI0q/E4UV3G3c +6lLkihVeqXOEct9LftZ9JXq1yTSO8zKEgkApCeNRco2+NC1CmdYA4uGi5LsOOi4+hAraIMvXumzS +RaCDIM5v3Cn3gIGrhzaM66H8kIAGwNe/evvmN+9evXn/6s13z545ue3/MP3qe/xL5L/85sX79y/f +vQGB/tX/8+OLdy9/uNm9+e71y29Blm8AN8tym1Jd5We8KeUWI3ryM0JXf8Tumi3wh7/Qf/9v+PV/ +APBfb9LNL2/++b/PN98S/A+/hR9bnPcOJnhvngNs864Bpp99fgEfwt7Q635NQwGWE+gXlINeK7E5 +zSvsOLgd1kLb4szzAiu4SsWqyLlAf3iBL4CXYl3XfAuGZmJ6BcQ/6ZX013YBIh97fo4JQf8C/8KK +BSxhy1xBZaiV3qCw2G6Xtobh45dg+tnnF/Dpe+hzwKkMHQUpSu9RWFluYwM7z3/+Ekw/+/wCPn2P +0qSf9xyr4Ta1ugiD2jy3SyD/5i02fQt9rBQ/LApyg8CfugBxY7DBpC+gbtWkn713IM9Z5cIlmJ8N +IzZ9CVEDs0TH9N7B+CNt+PglmJ8PW3wDtzZjojA/APr5SzA/Alt8+h4QdAG2BVxmea6wXWMMPYJg +Y1mdkF6sHiRZAFJwDaQ3/0ILbr75LVcfCbA8uZBcTWMJhC5WUelmhRz2RTp+suJqvvnDjmse3/yr +n6l9rlwatkuL6cKa3WBD0B9Z6tfMhWk7eSUsQ5WkxGVo0YtCZEIv2Vygnm/n1/0DIz+sxg3ME39p +vjKpsMsvVPsuRAx/XOStbEfOogHpCPQzrcMsFWlyafYoty7BvOTY4uu0VlD2I+2PdeGpBe1yIUY3 +jHOiwNaEjcwmDlXSwF11EOFuKV8SpljoaiNzBeRW7QXZ/8crTfytMPbztMIQJmGLCdMLML8gLwn3 +qw4/baIgO/vgD6L2ghhUkHzu+Rmmaw77Zj/wW4Qf40ty9IK4vrC7MKEpgRU51kJLeW2jdqolMFfl +quQ9MaE4kI6CewfjdZHOJfEG5qnf4lNat1qF1zQ8TlFdLoA8xks6Cr7l99OJ1U3QT0XZ/Cx9deW/ +7N/9+MOfFI+5G8L8s2m+2cG/P/zr9CM8gxZ6WQclDfRZAt38Nt+ApE5Y+XMBLjwDlXC9xUi+Az8f +waHc4sWEBFYMl2D9428m1EFxIs8LjX3FY2E4ScEiW0n41wJmAh2IxN0LIVaAf9F57FCjYZEDERwa +TMc1JwTH2znAZwC45luw/YSMCEseYDXe1nmujrRv8PMF6YEJSGBsuDT4cGu+4V+gIRhagBPI7g2X +um34Z2w4Z8AYkn85LE/cmctApee19OgwDW1xvwK8NwNSZHYDNX0gQEfgm5FSAOcCnRt6pW3/Mna/ +t3Ws0rbYMcfVToPjf6d2O1CH6V+m30/t5qc/u/nDP8JvNKlhFQxT+mMznaA3AL4Jww== + + + lH/0hF9BfbpdV9BM1jAXLM9Lc36d14hiojnw8w043JaaVwJ7JA+ADcm1Zj5hLwUkKGBPsBHkRJQv +MLkIEhOoV9wsrUtiYIYd9WakDFqua8VpxuDI3UOUYKYzEM1wBuKVojcXX44DihyCNkVpSGlJws98 +i85qBMNvM+xQCCw8KbltjIWA9RaPSzOwLbAWDoQAZhL6BBicw6JtY5KX5TnccMMF922ClRkI5883 +2BHnlQlYaKKuc1tugfeB267MsBlmb4YGypu0MgKc1DEJsaGUwjMCwEBtHbgDezAs6FXYm2uIAozL +osRi6izjRXBUhsWWpW0Is2BNc1EEYS3Kc1RuDUGuNsA5SFvYeKMiWBUIJr9SsCb5fLrFSJw0RZNB +gJ0JMOcFuKBbgAmY52AIYPULF0HpqsIZnDelCcfhv4Qi36YwywxLITPHC1CgHas5a8cAjF3nkWxR +EbSUFZhSVmBTwnrHYNHZzG81cB/W27AUmUcgahkpTI6gkwMElny+wcwuQmtLwsOGiqG8v+LEl8/L +5MJ1sdrnMWNKp+yiny+NPw+vCiELsCHjGVjXhZfjTAteENS14pxHYGo8MhkWeVwFuKZShddrKIYA +ZqQOwdJYii3zAi+J8roUBMWC6mfU3hK3EZjmLNRGWLCCd8F9QVbzvM4db1lnoYLK7jEQM7+E4aUy +MNxivF47XILgBXBK0rcFFq/gDdDRJPSG3FZBkXBMGEWOVYAlRl3lIRraMr6N0cIqxW2qM42B0UQg +yWwBgqotBLC0YzBsBkLuvKxFSGizDvCS1yAIltRHMml/UTroQIBs4LYw7VNuOhmltxWkeNQu5KID +Abt9KjrFQq3StmIZd+Y4CncBrlXXWHEIWlRBs0YmYIXertIUS3YKEDR3fVObtQcAhi4LeJVZs94C +4+IZAjSWBAjKiyEgEnnprCT+EAjqzqLzIPAgNJY5nduMoOEo6oDxJkLApEt3ha32xloKBRX+awhi +tA2nAJiBJdeqjDUg+VuZAmMBQOdgC0cGvCE3lV2LErUm3XTXRWfRMvNUZ6yNZxEAu5wkkcjA0lZl +Nm5GiiADXdqWJ/cCazzZbhNITmFLMAWL8DUWmhkLboJBhR+GZQ+KQF+VaLskUA46WarBuuzWTQnB +sRVdyZFFDABbXy8s++DVwP61OZoYQUBPsy7OhdUWBAZdLxivufknaYt2sO40gheWXEg2YVeBgUDW +9YaSht8VUQvTFVfs8xmZ4XcfBPYdtJalGoI2R13zeIIGgfCxEEyRIZUHgbFWeRUYA/J5QBaVAFC1 ++V3wawtbFmYYzDU6UcgIAFlpumBQ0DOQVHYerrkUAaZ52L8UQQmr9DanJhosvq5lQUEGr7wMbRTR +sBbDW01jWXRxIN5Fp6zs96BymRZt6hECF5g/qh4ZawvIHVU0MUNZ2tY5mXwQ1lYYUp1ywZY3+iTi +qpOulCRt8YSOsoY1ZUQQVBPDsLsgAMmZbFdLq+weAAa5peCSFYXqyij8SxRgs30moK9D8baaZDFG +rB2PQFBzi057LIcsQJCGq+6rQXm7YmWh7AhjYE3KmiwDBjJ2XnX7Wupqn4dFrJypRT/ft/YlBaWq +RttA+9g0lIK6boD5NwKEvV0RzAoMazVgyYagT3FxwzI41aV2dYxha1iiYyIDS9AhT7hZK9o8L3kz +NNC2qmoAw5wEmGD7UWVqWQ1BWVROZNEtANjiIsACCxKBAQuA606FCRaMIOCZ+TkpApbpgQy5omTx +nhIwxqYqD+nxiiClJiwQNReBa1R1rkoXwnIbkvJ7RX2TEQA4Mw9gtQVeNwAEg0W6myOLCQTGoK+K +um4AjJlsQtjauAvB7RWiUiMwJ5VpYLvKKAA4Vd1s8soSGNuKGZdNG0TgoisBb6gyBKSocHfR8S1A +tIEZK/BIgCCWlQIQsIagxazzQPTREE2pRt9FzgIMLSXlrConAI6rLjxivQCjrpAiCh5ibbpCSlIF +HMDwuyCgziAwOWFNdgsDu8oDO4QIHwSLcgEUsH4XMjqgFx7aJRow1qDAoBzIbsOUkAyDU1TJQdsY +A2tSI6SxSERY0c/XYGiLmYzaI9i0VGqtLPYCLmmdQNXUpYC6tioBNBcYmFsT6uci0x33Ol3G1eQm +0mQy1oiHjy1FEYgqDsCQVZNe0YhV6pdVpYZY/YQga++TKDeEwCabqUbo6lp0UGwOFli+RWeAiodi ++nlm7VYRrEEFckW1+7mCIy8ONH1Z6Qu4rVXPBQbOsmJK10QRirKmryMGZrBoZGKIjQFAijgx0lQW +Q5BMwU3q9UIwbfMMrjKLKw/qOAzVSekVhYbiJT7Lqhfe4AZqU5tdDASsyXqrWxWC0VanTpDARSCY +8qlPzrkKUFeczCRGsJpNhJNbRAFsP6mpjBRLC4DJVlytqqKF5mzINq+KAC/P1JdVYnic2WTpMpIQ +RLqUUymITG2czVFkaw5hi87ENagRi59vuqUUlDUMDLbw0KEmQIppySCoQEdwUSfHuvAaA2DN0ctu +BpKHTTYqXXgRPQRNd0Vc2gJcko5i5DmLwKgtG1btVwSx2LbK+zrA1OUII1sy9yBQbX+3S/DnA4gd +/bwqtICgZt1RaIgY2HDflzct9nk8rShaiNgJAExBgWsRqmCXEVcbIk3REGAOmZMyzwUMFqjuHrzV +RthRYtQZG9mVGnGXUN8AfYTRogtQd5Qm+xQAu25D2igDsxi7BUN9sjwiuh5TGQlA1SnI5A7sqEKg +mut+o0Rws+62qgiq6TBFjEUAYu6cTiLdpiKK6qh0oW9TsBaVJphRahSoforC3FGw2KRnRwRinatq +G2KEI3BRWvGkqSGos85ZdXpElO8mEEXuYBeqaq25qMYVgfBVlauYhNrCcTwWnnVpAlRPBu6Dqo4j +eI627LIigCmlFIgjAoBkKcs0iMoDEN9NdlWWFc8FnETvLOzVYGBY1SVWxVOPQFOnaetUvMkMjSyb +a6w80KKhsiYXK91Q4+YcI0Dfu+nTQcMbsdp25Vbe6jx7WYwKAIaoalAxG/+87XMF22wmfzIDY1Px +KV5uBOZZowoZbTvF2zVP3RiQhqJGRRVXF77KHI60JSuCEJU5jeJ1TIHtV01MM6LAFmTqn8ejs6Pm +GtEKUz1bVV8AdpfSagYIxo0XdSjUlRV1BMZkW5uMOQDXqIpPtt2mOduwid0NwJSTtpVQUETfd6pn +kxH2xrL6dSpYm7qDmygCCDTtgASoIVjmtpmhEg8XudyMrKDCuvvlAJyb+rR1vJop5LBExCkDwDqb +7odWjX6+2CbS6qoEFNuFaW+UN0VVyE31jt1dR0JPJidATc0jOWPgvucasavp+Y6F3W1A01BfRiQO +AjRhik3wph0D1TNY2NVDCBLmWCWREmq3p9k5AxrOSAaubS46uVUnTZSSZdO7Ne5Y6n7EPhMBGJBP +TBgvD4Cl0ETPnIM6lgis2ytNGUWrQTYAs9aQFq+jiV0EQHVSoF2jxKKCMGvHWNRCy5Z1YyDhyA1D +MGvD1MGEEWqVO+x/ApC667ppC0A1QUR51o83c1AYX6O56As70BlIaZsbTQjBop8As5QCAAZd3wt6 +4xCYTKcvHF9kBOjBNm43dg4mUdoJmMRpm7JFwdBUUI064UzXwRZWY1/UGVKVgcIMEfKrcgAtz9m2 +MNZ8EVjUhk0c8EJgWNSTYYsLoebBs7HuTbFTrA4nXNNmv1RVRgGcwirzHZjNfa2mTg/Abi53nQnA +ZDsLY0vWtiEIMMi4Vo588bhaDAyb2l7ZxGAEYK6LbRxNkdZmrhgT0amydm/vei5QNzM4hQ3BsAXn +rhs05jcC1WpOsgpg66pVsRZb3QBetakKTgDG2aTpwns1AtPidxlFkEtTvLKnptVESdHQ8ZKaYywF +hhkBhlnMuE1iWgI0STjXLYRGSWHKGZkczXwWG7Sqe0MfxKjIs83OYv54zFsr5mVC/YwQZCzLruqV +Gv45WAyusDOaga63uFIYAYDFqkHCQuSe5Yi+Nh0x8TNB22YyIleWERmDg4virRqaQwRFjcsozqeM +pkJSgVSDAkGnVA1RvQEAJSejqBas0GaMgCSd4BJXAmBFy6v3QBGomlrYQScIxKtT2BxkIGl1InjU +ZkawaNqOi8nidUAB2yoA6x3Q+D1CyVkt/G76cRrlsQPJ3K3iEVMEfeXShvVcwBqe7IsUO2u+oiKa +PtK6qOu/e+7xdU2DsZJlLK8rFp4TmYZ4NQYk0WT8eNFYy4qO/8PDH8eUDlXDEodaqOFsxm3qVFE8 +h3vA2gZ11eSZGJE5cT4sAxf1auVse2pRr3vGHAudmjbdEh4YMU9G7PQ3cyoWnRnZsnG6Yy9j6Esp +7ZsiEVDNuGXxj23nqKtLrKqcnSxIpsJk1NNUv42zIdApqJEibLcsujSj7ggPfRyPgMmrJMKes8Wf +ih8BtCFUSKvSnXH/WhdHKwPDomSR65QRFAt6FgtcINbVBIk48BCBY+HSESy16a4o0TIAljqbINHP +g7KiBPQ5UEwJQsOVvbsI7KtbrCEA5qhKd7B9PWN3VMAt4k/K1UJC5VY+XjlvpE9M/jg5O1ViaP4H +QJUmXQJo6epGr7EzAEbnJGyGUnMsimaeIbDJrM4SEkRQUsGyFJ0Ta0dH/zXXWmGHPwND0tlAo6Yv +bk31jiLxW/didXZlrwd0n8zw8Rj1TSAQZSTUo4I0BZ3NPXKA4KSSHsXBc4F2LV2jHxlTM7L0Sg15 +BNq7elAGwYvmNFbxayEwKVtU9KwWlEeZrokBGa1gtVPWvluC0pB07Ewmr7xPy8izXwxawgxVINpM +ireVovtCU70JWlOigXBRtovGiQaD3oN4bbdbzFUPYBC2uiRndiFlDFBaf4sRRumV0jNVUABcJZWv +sF3FwLL0DS8LTP0DxUUrEK0ZADm5jnXLRH3y9K640fIympbFgE3oKrNT0zTnAIBx1UGX0BY1jDKQ +xX8+FO1XFZc8AFPUrUUtK0RqLt6kFkyZ3aTT4BwibaokUuSEgdmEQp/giMCmjPony+zUZ0kpXcrC +sXjuaiidAmezFw3sQ+u5mHFbkszQ4lPsVHVDzJg4xnue0rtwhtbKnkTdXrBtVU95EKcQniOwDL3I +6YgITNEyDmyKI95VXQ+tBEWAQyyjKxIbgNVEl9lsJZhPyI1YcCoOeVsZqH61Ycp0V3lhNZSBJatA +KHlOAtRgGBAQ1GzHtjZk5JOUl2Vd5U02vYJZdGq1djcJITBJJaknBdTfqsOraxxaUoRgNcNCEaxx +0X1nse6W7uWVREAkK5njwSK62LakjZsA2y7qZ1b/Ob7KvPoEZATROVM1oQWAPT26st2JsEXdYq3P +AgDPpr3FRfndYjF3Clve+KasljOKIP18WuzzjYOXxWcyanisoFZveoNFKwCs6T+Fo8sCTLqJSdoJ +wVTM9lgeol10oyWn/HMB56KSmk4SKFhTYwt7uASFxJCZ/8lia5Joz29KlpaL25JixA== + + + 3GXdQNSuQoxN7VBWUQpaRar5BcvZhI8rT3QHx9eH5rQWefeq2x/5LI2koNqgpugjReL4KpyLKEib +GTpr630K5kwwsY0vq+ak4fh7SRy+5BWg+eYIVodOsfzUInma4wpIbq301JSSuePDrlyyuedlt2dg +qcrUYt4zBC995+HIVEGly3i4KtK16PgF05JL5vMpo4zPLniSxKOFfZVlgdEdzZajturyLuL6gbag +55sDtQMtwNADIkXsNgaHNRu7NP4jajbC1iYNnRTCXFlLApf8opJNJe5JbSXbLi3nJrQHqgj21C9E +0FMYxP2HwKQpDE4KZeYcg+Os49XzxDRbpRSnQVFSAiPAyWPR+1VEVuFUTdkOZx2Zls0utBSpgsPU +lDBJ/MUqBhYdtIkMen1WxvbdrLptmiwgBjqffZW9pLpdp3tAAayRyMLJZwwMi21x66IIukssm0sM +Eaw6DzUkhW0lR6vbqwhs5spBkaQIejQ3S9IKUru2rSivzgtOQtsoyOq7Wop+Xr2NPSUAgYuG+SnU +y59fOYq9eqdHqZY22pNRsaUthGBZEQU9iNnmoWx83XKwFMTSLD9HYoX8eXTq6SSIEuGoM6/VQakC +YCqaKdH90HV28WhtmKOugqV/uibNd5l1K63o+rN8ZHE44OeLLkO1wbGlLZdounn1GiQJKD73tTid +Ki4s4AAIVFs+Mi9vAJZmsWj13GHTWjVN245tYGPLBJpXxdpTlzVAjcCi/SI/g6LtiVOzyGgArlmT +XpuoZNgyafb32lT3qZi/rTm+RQIUFSMsevaGktIZqCFnSR9nBMHOOgm1zwXcM8/oqDMCI6ctclu2 +KQGWkqnQJg0RHPUcGfmTngu4z0NynBjYUpLlBBAC12Q59JLNBEAYXe1a0klbMQFQWRYtqQ7AS9aT +SVk8mwDMdhJMJCqSu+ihjVUPmBFay53SdNwanFNNU2wBCHq8IpiXjkAlNW79NW7Y2M9iIKmSlZD4 +tIoi0PwY3AxZIiIFEhXCbG9hF2a86CE7sop1fDXhMqmrBgmQDSixc1mAZbGGrfXP22kSCl7I7MhV +CAiYq8ZAjbsn5z+qePxSs9tJZZXJuGgKOXk/dIbqOUU7jUfgrGD3sn5mTI+j4GKYdbgdBXgGSl+m +eRUA1PNliY9LiEyRIbCTStBwmUtyU4uBMIJCU5HkfpQRi57F6Bmr2NbOCJJNK8Ci65ayOEVISVwN +Wy6xy8QQdbhlB0Y5l+wYQOqCMuu5wWAeM5K/KbihfS7gIMm8qctED9TZDXtCk3SA5HWmZptwMklX +VsvNH4C0RTKwqzwYGdOlSKb2c90DJZc1dvMTN1Y9u6F+VAAuJjgoNKeKjONDCqa6ivofWcAyMDfl +LWUxqjaYmx6X0gQftD4WQ9C6rV3LqrRqBAotzazyL2ABp+dmqupqNLyBZwsPjyrPPYM7ca634u0r +T2NrAOzclV0IPQuyC8tJGHVYqJs8WRgO3SASq4GOqYY1m84RWW8zF49kAkXMtGzmiqHDyQSWJBJ0 +fVUWCFETMNClJ6mBwkP1qAV7mSaGoE9w1uNpFJ55xk7FrHKyH1sg12hUvJJnC0BY7TKPNKsYHbZL +0X5Z4hO6fMXrE811he5rOYeGY1/VX0y5FILVgpbZFI/IduYzjsukXJSJzQJ+4v6OnNhqwUHRXSNr +6uxVDJZxEjmE+owjpJI2FHkCP6O4a5MAQiRrR4Ops2gukZ0bGuVVUzRajiUGhNcUlQlB0YLQVbTm +O8OYclY+Uuj1GUWf+6RRTQ/j1LMukWSBEQBr5hJGQHkjRqC4IKOGIjEqX4rwq4t1SiIIAo5N0muq +6XlyBvuZJCYE6SvlIGi+gp6riRy3fC5g6rr0V2L4CFwFr9oFSSLsDLSYE+ZMiFIX2Wv4jJI2+rop +snAxk0MOqcUe4EhyoJU/L5ZkSubGDT2NAYZODsFKvqqmstDKZLQSUQBgDUrAIg5yABY56Ajbf52j +IVhmRaAhQkq8aVGnlyQIBTMMIidBMIJgtgl6AlmCu8SfEcGcbHapnKMcI531FAR4ECtmK+soUtYb +I5jtUHowaQ/AvrHo7KCsOF13wVLNqoVuo+kHUfI3hIeca4cKo64D0xpiPyQidQOeCzjJyetgCQAx +mr84cnkEBqZUBEHPYoxmykY7gBh7aQM6Pi0wGg1+vxmHmESddHnMctIDc7irziKKYDyjdG0qaCRz +SOUsgpsujkUTiBdL64u8uwuw1qqr1vja89Ajp0Y9o+x29eD2uYlJ95LWENkQZQQzyB1dMxT5YyDo +JwLUkDACbQizpb8h3qx46yKnN5qdYYqc58nAEnXDtxyIgEfZVoOyaxCBqU9jOQDULHQLQNPnwmoH +TmM/q1L5uAOzSxJs8FxNp8r2qpDcsk92LEgPImPOGu80eFSp6CTKVsQgJDsPj+ufN1YEhqA9ED3X +HYGKzkkR0NZs2lY2DwDqEUHQQmQaheTGoJ9txfNWEoyI/XRSsszf2I/roJqigpci3YwgWlZX1PAm +nuzKugNrtneIVqQk3toZe4RKJEHUBT5V04MGkaNuz+jUnVpA0XR9AGoivVv1eFKz6uqgNPRnfOZX +AuOivD2j89EaAQzuJBYePJdzUACWSAAWGpAcwmARvLkfZQ58yIMQ4OBLTYBoRypJA1QehpC0qoIe +7o18wloRhNlEHNsltD3aNExWlSFIim90mjMt4CbleCQPFYs9NJ1aahIgUDLKgjt4gXUsKm/2wWKz +82zZIUFT9rFCh56iCj1RHMGq4QY9YEBAcfqaEkUIVhOmundRjRAx5QM7I54rOLHBGDj+oeAw6zhI +jQ4EzlnprZz0iECNHoSuUGNJFEpxI7CoMVgWZg1J92XWp6k0juRuhX7MYm6zRcUim6pcW0cdU0Fd +sViHh2KUwlvZVLDmj7oIomZuYHUgmHjCnKrVgXqtJZERjCBaxNQs9AtVh/6ByhFhnaLgnAchSJGk +xKoKt5+LOiVa0hPoJH+kZdRCED1RBsFlUTO/WKWksAYxEHVFn1PAlZLQnGzFMqNRiN4rONuJEclQ +J/+vJScLaQjMmhgz9yBrZWwMVrd099/2RC4EFk0mnC1Fo/Tz6sUcUYXSUTRrvKmVvOmBdq2YGYGU +USljAVcNxxgRxeVHBEkwxzhA0JyDOFvE/gzvc3lhcqwgz+S9gKul89asIZmaNXWITjA9k0BRKArU +naMk0+uKncGimI6GrzTP7ZyAg1GmRlnRaqAMVi3GsiDRD2DpvLHyTlkSV5NdOblIfbkcmNIwgwYx +k9V4KXTq7eL7lTDYVFZN6KURuFfwooTVWXMMQtKIqQX3FstipIipWvw9kmk5GQsf9Vg5tydpisLm +9ULXkK6SmSiEgZUjsNks/jYbUJRmTKLJPSNZdQj0DliyStYMpcaHKphYNfn7KX9MkFLX94YqmXZ0 +dlA9zCTj7gWcmx2lQIVDjwn20grkIXh+GYlgD7MV9sqsQ90LWEV7P8eJdQgsB02SNxG2XDgKO7MW +JateVEp/aFXDeecEyBgt0Z2rI8X8XsHNakfAGEs5B/HzrOzv1n6fI3lONQG/rBIggm/K51cDFOmP +QQQqXBcx6WYuDvx8AEM32a3yXD9/DnEffUP0UAHAivoLlm5FmYh1msNKybg4kngdDP7S5oVuLFlg +4lB518j3lXAFQNDrCv4dXin51fei17UlEBjLIJFOs8ohr6UFG3MKU6P4x0KQZI9/I0rGmthunXWt +oI4AiquVFQmiImjsDXTwklWlCRbqEx+mFsqLtQk3ZFehMnVJ/UVSh4WUFBF5C8tfpWueWbbMlvk9 +48tQdwFLsJePoihQQ6Ack/mG+LLg8TfiC2Zsrlrmh2sSLWu0QPgS5dDTsqI2aaVkMIDRzgZ9yVIr +D1trGHFBPQR3MMSLmubNxQH7RhYUngrDNYkUJ0zPuBdwXFtw4OcbcGQrRmjGCYW3fmJtRtWb17w2 +B2RWAlvw6jLfFhW2GGlKd6weKBSoFgcvXDeEeXDgimlSxq8pYSCP8hlhBNQhgs0zjW0dcwzrBY5J +AUp8XViF8eRDonXcsCYZqvrLSqFanj3oYGAgJuFKDTksIViIhpnl6zeyqkBFJU7IMSAZeqlbEewg +GFaOWi24ZentC7q0qnomgxW7QYdmEZVcz59goS4ZoGr7KIUi8qrMiQsTNmN0B3d9nNbADV5DMMNz +TNxdYimXSayUZYasIbcez4YoC4vmb1/bEbcwnOog6BTIHilsSKOjNgEXxaK26N3iBb9guLAxmBL7 +pVhlWGUJgcgpNxeHDJfFj9Nys/texm6OVSYhmYT3GzCGYFq50VKKRAyOeK/Jl6hchgGZc0mKtA1t +8XB2zANWDxQKGEEHL+zwHLCuqHWkDQUKVJkm1Pa2vl+G9QIPkEc/+frvdu/eH1998/7V2zcv3v3l +5ucA+ul/+9nN3331/t2rN9/d/PSrP734/uX+9UuqN/2n3/3l+5c/u/k/sNH+wUa/OHKT/xP+4T76 +/UQ1adGbigWIQNOi8uigoFK52oWiyq7geNCC3on3KaQdlOvKkoWs2fsN2LJX5tmERTXPEjAvFBXy +BNTh4+SRoS3VBykj0g6T9+voKRjnrYiEjnTmw3ojAQJkBJ1Ya+t7ZVgvcABHj07nFqrwC7/MVEge +jJpARdCXmEF5R77ijs/6QQl032TiQunGXM6mQ9SkVd5vwFLGhAnmXRw5RqfxuHOwW1UHVO7OicWg +a4sZXGHdYO1AoYARdPBiOaUO68znE0YKBKjsVWqtre+XYb3AA2FvwGubsLYyqLF6pQRfeQPmbiSu +Rr1rKFISOlZXpbvpjLug+ApmqrpyvwFj3SVzHHG9WJx61XaYVnLssG/EbwUq3zq2lJKII8oOlNcr +axUcuATbiHRmV/L4fgEqa5VUa+s7ZVgvMEBYO2MFa7xeYMW7gui+hBzpmhEwPyqpr9GudMDLERCS +nfrKPqoq8yaL8eShkiXJ9IKNq6tai6rK+upAZW4oc9y0xWUdlg3WDmQCulhhaOCgwIh05lPaIwEC +VOYqsdbWd8uwnnOAeQtmZ1sqXZcxB7oKA7TuFumaF1DsySLA0OmS6LKElPmSL7QROmvBtBLEEQ+t +3m/AySK5WFC4kKrQpB4Kd60U3jEFyF1DL6fOe2uLay7EDdYOFAp0cBQc+JTNiHXBA4lbCgSozFVq +ra3vl2G9wAPhLiYOoYSNjdQttK4a5nXQnRSR7iZL/hKywnLXOIt3IzLWgEly9xuwlMZmWrncKE06 +STRAnVMsFgEqZ1ONy6ZtlCJ+A9YOFAps2gs4sBtyxLpwAbORAgEqZ5Vaa+v7ZVgv8EA4u9DZP5It +sVIFe9B51jrc8sPT1F37Ue3qFNlSS22MGq8QZkNoAGvlJ3TUp1XMvCjF8WasMaWWCQGVvWKv+7aY +IKMWj2H1QKJAESg43EYLNSjSpQdQOgECVO4qsa5t71ZHesYBZm5e10oXsC15CSQdZg== + + + 0E5H3gaRBRXdBnTJkl2hI3Ip69ualub34GiZ8zOqJIuIfa1gM8uK60A1QMpa86YtxnnndYO1A4UC +GxwDa3aHwxo00OwIYJiyVmntLX1fDeUZA5C1C2u4OQXWFc6v++kM1quJ+t1a7JgxBpek+GtbjL8K +xdj5rPSt4nuJt3KKBcuyFw8z805sDN+S73QYUHYgv10/3qEaqHA4+7zrb2eY8lbp9DO0d9NQbvv+ +hebJ7nHmye/Fu7eodw9+fDsVuVbkx6t52wYf4jOK6YKiLrKHTMf7Dbj08C2etWA9drUMWCvLaEDi +t2UB+LZYNy+WDVYHTM6mdeDA6ZcjVrxwpG4pECBT0Kl1bXu/HNYzHpCk+nKDkaoSJiZN8hHvN+DA +yf5UwZGtfcymbVbcco6rA2rHOLF/aIuey9Q8yg6Rd/OnO7hwHumIst6iH2PzegHqyCqpva3rUcd6 +3vtrGYuczzJL5ygseb8BB/RdaXlNwCEbmVZ8gc7BS5sDKm/LmpdN2ySH5QesHSgUKHsV3CuuOazV +Tsw6CgTICDq1va3rl6vjdsaDKxmLlJeTzUdjUUgHRiUiKHcT5UEhx0BH06mzpOiByl10p23aYmyz +5Q3WDhQKlLsK7pU7HdZi5Z4cBQJU7iq1rm3vl8N6xoNr2YtIBLlYV3aiyNx1UDlGwsDuc64hK3e5 +sKoBlbst6ty1tlkOKAxYO5AJ0M8rtFcmd0iL3aTkCBCgMleJdW17txzWLQeuZC9yltiimjDWJrzf +gAPniDyTwr9qmLUqS7XIhVIG5K5RCall0xbPisZlg7UDhQJlroKTFV10WLMlOTkKBMgIOrWube+X +w3rGgyvYi/T+usqQ1aipEA4cOC2XgXFRIG2f3C9x2itQObuIbHRt8TSqAg1rBwoFylkF4yUMs9ar +VqzZjr84CgSonFVqXdveL4f1jAdXsxdRXlEOG7mnMIH/fgMOnMzC/WhR512SE6NYoTvoFCegsjcu +83nbOdflDKsChQKb+QKGXUaOCDuseGgnbCkQoCJQal3b3i+H9YwH17IY8f6/pk4cKjJyfwbWKzUQ +mKqaH71vsFFWB9S+pajD49r2qKbD2oFEgQ2PgS37smNNXQnpFCSvsHRqh7a9Xw7rhgfXNRpxp2hN +Ro9OANyfgV2N+cV8Ezi2woqihnZVdwXd3Dgv25Y1hHCGsgPp9fr5DtazFQ7pMP/1/QI0+WT+Emvr +O2VYzxjwDeeB/DvEtj5kOrIh829iPcZskQ1vPTpw4fyCZ1wsms5L+SgXlh1u0YfJiOlYG5aylHzb +JM78AasDeuvRgYPFnR1WObs1UiBANj87ta5t71fwlcQ3PBBF8YsMR7qFSBMmcAO834AxGaFoaW4+ +CYHMcmWmOwcJqIzlilG+LZa2XXlf7FgdUChgBB0cNK3OIV3siIojQIDKVyXWte3dMqTnHLie8YgK +VBE/PxVEud+AM3l+mNxGlYKQX3b0AxQsyfkQIHetYZnJNLbFEzUltAGpg8n7dWwUbPnPHuliCX+O +AAEqb5VY17b3ymE948C1TEesPp+CGm5F7fIOxUtJEq+myqmvNO2shvYq59MMqLzlW/t8W1zPSXmr +WB2QCTCBkpS3erDJIQWDaZVLJzoBAmQCOrGube+Ww7rlwNXsxlg05wRvNc1LZ66Ccz9dVPmgKq/p +1ZjL5wQNqMzl88BD2yYnWwasHSgUKAIFB1+kXbEGOxPtKBCgclepdW17vxzWMx5cy3TEGw4keB85 +u/d+A8a7Atn5gxcURDUZNNmObhcYgNy3FbfduGlLl7OsG6wdKBTY3J+VOa3puxRp4MjVSEBwATVH +rGvbu9WRnnHgGoYjSqV51pAXnhq634CTv8yBL0ilSSeZzHg9QwuLAypf+VTg0BYrLSpfDWsHCgWK +oIO1ZLPDivGWsm4oEKAyVql1bX13DesZD65mOOLS6UGredbNrIOTXTWLF2jQwRDOJ52VvbWqn5iA +yh2+MWRoCxtPUfYa1g4UChRBB2typ8NKx5vShgIBKnuV2qFt765hPePBtQxHunIkyJLINnc91JSY +qomZSFnMKob5+lUDateqZGEMbbnm0wZrB+a1s6ZD9ZaGjhNrcxhQ3y9A/bzSOrTtvVovwLLN2yuY +i0hubmqOFtMUPFhP0WAv6JDSZtBzmv1MsFkT5nTWlq+P22DtwHFVG1irNg1YawtnBNTWWdtp7S17 +pxzKDQPYXPyYMfdvYcfRQX2dD92Oc+Be+h0L+69FTDatFpboVrHmgMSMjFVBaxvbZnTzqy7nCsor +0NtxDtw1LIe1J4M4CnwyiKPWte39csfcz3hwBTsOkK5VXTlYSOh+A3W3Vqy4XUjgx27NwBPSa3RA +5escUhvbZvSfLmHE6oBMgLJVoUGva3M4LaPZv1+AzNVOq2vbe2VIz/p/NSMOr71YdLgi1tW634D7 +faNYHyM3mcdaN4hubEirAzJrZrnC2LfNi+1QHasDCgU6Nn03oyJeI9aFaxyMFAhQmavUura9Xx3r +OQ+uZcbhXSG5qFtxbsZchWJqZxTehpT0OMHC3s5ENY6iAypvVbnqbXE1B42+CVIH49ebNBFotDpA +Dmewu/Dc+wWonFVaXdveqY71rP9XM+LwZpWmY0bFXu834MwFOZjeGDUip3c1Qt+onEsHKm+XlDdt +AUgnbwesDigUKAIFR7uZxWENdpWAo0CAyl2l1rXt/epYz3lwLSMOq97ErAaqKsMDlErBMrlp0Ui9 +FLulK19y7DDuWJMzsa4lTTv1+inKAWiKsIPiQX4rO6Q4g9/D9PXB72GdUte298lh3Xb/GgYcCXsd +QjoXeb8B95PjVLVIc3A15xi6BSphdUBlKx1L2balO4hGrB0oFCiCDtZLQRzWYMXBHQUCVMYqta6t +765hPePB1Qw4XDaLDmTFK8TuN+BkKisSTIWDEKinBAHYwhocULkTSlk2bZvprA5rGxRZddUOYL/2 +BWvom1OnIIwbmVI7tO3dNaxnPLiWAYc0UN0aTvsPffI68Fz1GikuukjGTjSWr0GdIgTUvrWqYX5r +2/BerrjBOgDNuh3AWuRywLr2m7A6BatFtgZqXdveL4d1w4OrWXFYuqzpwMFo9cnbwVTSVIDFInR9 +5KtoonHcS8o6n7flS6g3WDuQKDAEBpZC9APStZaz9yNMP91JdS2tTx3jpvv/cTZcBhG1rsnZL/cb +sFyL94wrB0r/qtWmwdqFFqDrZwOxJmJuddM2uiPXitUBvQ3nwFIubcS6cAnAkQIB8gbaqe1tXb86 +1nMeXMGGw2tx1kV8KMnqmzhwttg/3rISei5a08tEuEaGAZkvi5SJGtri8ds5jVgdUCjQkVGwVR1y +SENndicg9APyntjgWajdMqTnHLiaGZd7mDDx6bz7DTi7ypixFbEekpbfwCqt8+qAyls+0j+0DXYg +2pA6WHKHBh049nsEOtJg1cYcAQI03rZtW9erjvWcA9cy4rC8Z2lqxGTjrAIzXyTM1KZiEWC7LgdG +tXWYMpar3fuWWFY4bFA6IL1c2arArls5lJiTLeVi+tsFqGxVQntb16WOddv5qxlweJmTHcyhsnv3 +G3DmUqfP5HKjpiFlvV8BpfiyOKBylgtVDW2pTmMbsTqgUKAIFGxVQB1SrOViRWqVAAEqb5XY3tZ1 +y5Cec+Ba5hvecmXJZiSR7s/AEkTPzRnM0fYPmH4OxnzBw4sa19eWi1xs7TAOsC4lHThaUXeHM/Cd +k+PrBWh8bSWMbV2XOtbz7l/DfqPqwZbtu869FlE/k5fl7g68z6vERefbrGxd6pIcUPlKxXnHtgtW +DokjVgcUCpSzHazFyxzWXrLVURB6wQdPbW87dFexnvPgavZb7l68yPeq3m/A6JtrSobatsXu+ZrX +ZekwZW2ynMnekoopDwgdUF6un+9gujx1RNqrdbr3C1A5q4a1thz6qTjPO38tww3HlkpYEuZZD1CO +4Gq1rui4Ho9uWuy6uKaafT+jV2aXZKptUSImlXKKdQTOmpE4gNVBPGAtuYUzCghovDVqXdveL3M7 +n/HgaoYb1gyLeiCfwrv3Z2CtmolA2wPcyPeQNgG1cy1qEqRvW1o9w9qBPe48gO22X4/VZGV/f+ui +tlNq7XqPHL5N7x9jty3/domUBX0tzmy5H4BZa/7RnQSrONt5J7M7UgREfKh6N5trt8E0GkkGwfAo +XwnocGCl/GXzMobxJztV1tJo7wi3fbzWITvAWyzVgS5tvt+As6WMIalrFkU3pabXSpQWPZC7hTfv +aRDD2kYulThi7UChQEdBwT2g77AGu4TWUSBAY6xQ29u6fnWs5zy4moVWcK3owEU7UuPAeOOR3JGC +RTiilqxIdu1HWaw8TlLvLV5xMqtVbG2lQuqItQOFAmWvgqNdceWwBr2Q1BHAMGWu0motXac6ynMG +XMtAwxtCrL5b0HPWDprxhJ/eMKK+q34JOt6dkhxI+ZpmjflYSzyCX8MGZwcmt5o7NA63zMxqjtE9 +z/71AjK2rpbLKy1dlzrOs95fzUSrOLtVCSWxfH8GbhLIqbNcAs4LuuhlUqnE5oDKWipeMbYNtp07 +rB5IFCiCvvUnOUbmsAYrlOsoEKByV6l1bXu/HNYzHlzLSKskndX8w8Tv+zOw0dDD5nYJ0YJ1K4ID +Cms2zQKXPfXoPIhebBO+qVcli42sE3jW+6v6WwVo/BQKXdveE4fwrNfXsM3wNrighWzmorbZAHZ7 +F9+vTRNNrkXEfi1qxVmNSdqomwaKrG3Au0O2WD2QKFCmKrirbA5rv0rCUSBA5axS69r2fjmsZzy4 +mm2GG2iNmtG6qmrgwKnf0wYES7WjZDkeeOMUyrAOVPbCoJ+3XVvOG6wdKBQogg72V2EJVqwumMKG +AgEae8tZW99dw3rGg2uZaCSM1FVMKQf3G3DqGzvWVqzGnKhTh+padaAyBzb2dtY2Ny035FQLBUaX +CzGAxXx2SCPnNI4ECFCZq8S6tr63ivSMA9c9UzeMMqZk3p9Bm1x1Q7ewmfcqRd1FuneBgMqfpa31 +rG2vz2JYPXCNnb8dSpVxR6TDlO7uBQIag82n5iZq75Zh3XLgi8/UPbIgy4dMwd//u9VnAebBCli3 +J+w82CqpzLVZzNNqrswVs1RZTXP1WeZKN+uum7bRVfEwrNFV8TBz0YOtkorHajVXPAWuPountrd1 +/epYz3lwJdNxrhhxseiP1mfxYC6mgh1bJbfJaq5gxzQC7+qzYMdyGFuui5SSNoQO4qqzeLDVUekI +rd6Kf7WrzeLJdG17bxzOs55frZBnxTtx1Bq22iwebFVU5kqX10t+qRxfxs7BN1+ERfkaZc/sbddZ +rqn0WB3Q1WbxYKui4rFavRVPgavN4ql1bXu/HNYzHlyrkCcMcQ52vExrs3iwVVFBesusZX2l3gr2 +jW9iHWqzIB9CHVuuPk6kOB3QVWbxYKuh0nFarRX/dleXxVPq2vY+OZxn/b9aHc+KVQ== + + + vzVPRuuyeKhVUEFgW1dNgOZaK4ATj/s3B1TOag5lb7vOWmvdYXXAXpfFQ62CikdqtVY8Aa4uiyfW +te3dcli3HLhWHc+Kd3CsqkeoE8mDrYIKThG+SsjVWsGuaYVRV5cF2TCHTcvm6u0ZTu80s6osHmz1 +UzpOq7Pi3+5qsnhKXdveJ4fzrP/XqOGJ75/V8LeaLB5s1VMQWC04KXVWsF+aUe1qsiBYrRPXFgRl +1gp6hrUDXU0WD7bqKR6rmfmeAucN8NS6tr1fDusZD65lPdIu0I00rcniwVYRgmZI0lkndVYQqAeM +XU0WBNe6adlcIWTD2XzRZK3I4sFWO6XjtBor/u2uHoun1LWtznY1nGf9v5LlSKRZSVurxzKCpXIK +AkGO+9IrAlybL9KifSuWru7alrW1M6wdaPVYRrBUTvFYU1dSOgXJKymd2qFt75fDuuHBVW1Hmiar +1lixeiwjWIqnIC1y80HTKis0oxaNXmg9Fupf2LbrZVcdwg60aiwjWOqmdJTDatJ3u1osnsxxlaz9 +uo+Sz4D/S9RimTFMYUu4W4oObFVT5rJaZW+rrwIrwyakq8Uy4w1fc8qbtlHuRx6wdqC3FB3YqqZ4 +rFZfxVPgarF4al3b5qSwYT3jwZfnfyJSuf+juVosHmxVU5DUfsOD1FfBbnUOWi2WmS5l0/qa1hZv +plbD3rB2oKvF4sFaNsUjtfoqngBXi8UT69r2bnWkZxy4mrFYMAdVvQtWi8WDtWwKkrvIWWarrzLT +rXtLcEDuWsbVtG0LBkO/SkKQdpirxeLB/S5Kh9Tqq3gCXC0WT6xr23vlsJ5x4FqmYmn+qhU5Ye2h +VjUFyZ1z9GVXuGt8SfRQiwXZoHXeXFtYz1FjOIa1A3stFg+107ceqdVX8QS4WiyeWNe2d8th3XLg +arYi0FAte85qsXiwVU2Z8XrJVMZaLNi3lvXcpNViQT6AvpQ2bbPcGj9g7UBXi8WDrWqKx2r1VTwF +rhaLp9a17f1yWM94cC1zETAnue3D1WLxYKuagvSuctbT6qsgcK7LthYLdlmNBdc2453bYYO1A10t +Fg/WsikeqdVX8QS4WiyeWNe2d6sjPePANQxGlErVyg1qLRYPtqopSGqVW7qsvgoCl3X1RVeUryWp +98faFjCaLYipWDvQ1WIZwVI1xWO1+iqeAleLxVPr2vruGtYzHlzNYMTRtdqvVovFg/uNgQXvQ5vN +AWvTFoYwOKByp0nte9e2sNd8xNqBrhbLCI7B2irWyBblSIEAlb1K7dC2d9ewnvHgWkYj0jCboWFz +10NbDioTcohWGlsJS6EfSOgLMi4aKO8tQ9TJ6FB2YLZ566FhyTpFFacWQvBvZ5h+XOn0LXuHHMqx +79dKBCVig91vUUxL8GA5KEqdMDNRb1bEPsRWHNBmTNY8Tte2Zjux27F24LiiDSxFU0asXF1lJEDr +sIy09pa9Uw7lhgH/YWf4ZjwLlPRkRbfhHNgqpswZdpimpobUVoElhXfweiAxI0c7z+jaYoRN9TjD +2oHehnPgrl05rP2iHUeBq8PiqXVte78c1jMeXMGGwxNsckVer8PioVYxhSidNcgjtVWwV1kOkLs6 +LHNGvUdjc9Y22JWgDmsH9josHmrr3+HsN0u697s6LJ5W17b3qiPd9v9qBlzGu9Oj7k1ah8WDrWLK +nLFA5SzKrSS5Y9dKtJvltA4LsqFHuK1ttN3JYY1+09Q6LB5sFVM8Vqut4ilwdVg8ta5t75fDesaD +a5lwgLkGrSihdVg8VEumILWapWq1VbBnNWrkx+qwIBdUsXJto6uOrkg7rNdh8VCrmOJxWm0V/35X +h8XT6tr2Tjms2/5fzYADzGlVFcHqsHiwVUxBemtSrVdqq2Df9AY4V4cF+dCijo21hVc0PSplWDvQ +1WHxYKuY4rFabRVPgavD4ql1bXu/HNYzHlzLgAPMWmmn12EZoVI0BcktJejtG7PytiW1PbQOC0Ip +NDG0TJZF4lB6oCnBDmoVUzzO4PcwfX3we1in1LXtfXJYt92/hvFGwl4zAa0OiwdbxRQkNVf1GOgt +jRkr02rlIKvDQntLUJ+FtcVf7S5ExdqBrg7LCJbztx6r1VbxFLg6LJ5a19Z317Ce8eBqxhsum6JJ +g1aHZQRDL1fpRy/GL2nDCFykAl3qKca0SheNhVrb7HRWw5oHRVbdtANYLFuHNJp70REQnSvSETu0 +7d1SpGccuJbphgMcVPpYFRYPBtYsVYWtXjuF/tAYBBiynsEImohIPZ4tzV7bZiz5t26wdqCrwjKC +6WzHiDX27alTEMetTKkd2vbuOqwbHlzNhkPaVk3xtSosI1jqpSBQiyfGvjsUKygex50ktnbetpez +clg70KqwjGCumTIiXW3M+/u1CstIam/Z+9Qxbrr/H2fBpYJnPn225P0GbPVSQOGGRazVMaWyCgg3 +F5qzKixzCqaMurag9IPFusHagd6Cc2Crl+KxWmUVT4GrwuKpdW17vxzWMx5cwYJLxQrhuyosHmz1 +UpDUmmfLJmM3A3Qr5eaB3K2It6tv2+JF3lqazLB2oKvC4sFaMMUjDZ0tnQBXhcUTGzwLtVsd6RkH +rmbEpR4gdFVYPFgLpiC5pd/twZVVsGs5teiAytu06B321haP62hoT5F2mKvC4sFWL8UjtcoqngBX +hcUT69r2XjmsZxy4lgkHmNOiN/aqeeyAVjKFqJWgo9ZWwY6VqKVLzchI0S7x7S3x8mmNbhrKDrQq +LB7YNSuH0iqr+Le7KiyeUNe2d8lh3XT+auZbwlRcvcHCqrB4sNVLQXJz1qiPVFbBrvWrBK0KC7JB +r4l3bel26LrB2oGuCosHa8EUj9Qqq3gCXBUWT6xr27vVkZ5x4FrGG2Ce+y0PWoVlBEv4PGVnLkfb +P1a7Ty3a9gFE5riOLfHwR64jRg9zUrKDrV6Kx2mVVfzrXRUWT6lr27vksJ51/xrWG26fcnGFq8Li +wVYvhWhdtD60VFbBfrV59eVWlK/9uK+1jZbx67B2oKvCMoKlXorHapVVPAWuCoun1rX13TWsZzy4 +mvWWug/PVWEZwVVSnxMeLdc7xQofTaTONY0XFD3GSBIw1XzWFhSYdYPVA60UiwejK6AqgmI5mGo1 +OAqSszActa5t75fDesaDa9lvOMRJLUsrxuLBQMWqwlaVcfSFRiW31+UjoPJmbbbpalvMSjXzTZB2 +mCvFMoJB07H13+z28bUuGwIEqLztloNr2ztrWM84cDXrDYlIWtbaSrGMYDkrS8Clx8o4Epyyi2hb +KRYCJz1759vOan05rB1opVhGsFQSGLG2cvb+1uVtp9Ta9R45fJve/8eWYpljd7d4C86BtYjKHFHr +HMqszDHaaWgrxzJHVOyHsi0wMSxBtaPrMG+5ObAVU/EoteaKf3evzuKJ7C29S8lQnnX8WsfsIl5+ +GzR/USu0eLDVUkFyU9O8KKm6Qj2T0/uuQgsyQc/ku7Z40l+1PcPaga5CiwdbLRWP1aqueApchRZP +rWvb++WwnvHgatZbzM7bbBVaPNhqqRDBlosmx6ixc6loARyr0IKMSFUtZmu7oIa5bLB2oKvQ4sFW +TsVj1bornoBeocXT2ltm5243lGcMuJbxFvOmRMr9BmrVVJBa9WtZ3RXsWJcaVqMFeVCqnhm0tst5 +3RcPTG5NL+f1VDxSq7ziCXBVWjyxrm0+r/xyzoGrmXARU5X1FLpVaRnBUk+F6O0l+CU4GLtN4Kq0 +IB/WqhVOrW1waolh9UCr0uLBVk/FY7XKK54CV6XFU+va9n45rGc8uJYRB5hXOyxlVVpGsNHQg+p6 +1iqSj9qXbuGeRbdtWVtcnarGGbc6yEq1eLBVVvE4rQaLf7+r1+JpdW17nxzWs/5fw4oDrKBjbOu1 +jGC3k4W8jvVasF9aQc3Va0FwqJt6LTTlcN2MWD3Q6rV4cNfrHFarweIpcPVaPLWube+Xw3rGg6tZ +cairzOrnsHotHmyVVYjgRRMoNRckomKpl1JYvRbaXyyB0rXVO+Id1g509VpGsFZGcFitBounwNVr +8dS6tr67hvWMB9ey4kgsWaqk1mvx4NS3efQpBd1SuQYL9q1ZCqXVa6G1uuodU65tWrWukFc0Vq0q +1HMmBjCXVvFIrQaLJ8DVa/HEura+t4r0jAPXPXM3jLLWaxmhUlmFaO5+Lq7BQv0zF4DVa6E5Zdqr +awsGQNlg9UALkw5QqazikQ5T2nlBFmdD9HPhbqL2bhnWLQf+Kuu1uGN4XzrqZwVb8BYkNeJoLt5v +wJn9BwDE7XKuWntC7maeo+UEChCHYFlgv1vmOLZdGtbu+P/Ze9flyI1rTfQJ+A71RxH2jg0aeQGQ +2PolUrbH59CWw7JnFHFiooNisyWOeOlhs21rP/1Z37cygQRQJIHqJlnFLikkFhaQ95Ur1z3toNYc +GHtwfKDg/uAg+GQE7nK+GCOMuw3R2piuERl0jEDiBuPUUsfit2VAIoHksZoQJgNmHVszYyeCM+iF +h+SDF8FokOFVmgkVaAPuBRXuSgdiU2iGgBlTrkCrvlAByfv1orqyRcI41gt+wcasSCXMlpQiQqVp +6nXQ0Uk+YHR60UWJLC025nihr5XORMDm7NIiqVMFjFxNk/wYneoK8T5UHDLu0kqB4fAztBiCLY2S +fgXWFXIlWelLErgYmoM8MQBy7x3HCvSGAlviaBZO6IRg3OKFlbOl7ThijdSISmZqCzGysnNxAoeU +EpGWLl2uKLOQcmrLfNWtAqPKXefWauRucH0IJxAqGpplHaKiDQsZrUsBGYAM01BNF/2Y2ICxWeVb +ZH3Z86s4tmhbETB9ZPVbo0koA+i8ilLgGFUUEkQUNjAS17azw4RWzlZP/GV+l85DUW/2LcsuXLLK +0g+WdYw8waLV8YYzGW9FfSMWwtWaTEuQsbJNXEk5q9PGhNOCiYvm4VKa8LmsPRetjpgoHFNQnEl6 +YPnZmiTje5CktCdb61OS2Vb1mm2X8ifg4nNl1BE8aynWhFpT1pzFWYWdUNc25QNoS00GoVNdKvON ++TdphxELjtev1gkPgrYjyV9986fw5vfXb49uP374Wcj53fntNYAVgG/+cnP9V6H5d0L2i0LBR+c/ +XVznLw7+8h5vTKmvvv+ff/zDxaVUc/C77qecM7/74c8nf7l5e46fgwPo3hdfr37z76vLa3lVSLdu +L378eHf+AUeNnGG3p6Mvzn6+uHx7e36N93b1uz9d3/Xv8L+7eJL9pvxKDrJ/XF+cCTCdZ/mH/zy9 +/Khf/vvhD69Pr/gdOsFebes4fp09jl9fYByyn2eP5F8Xb+9+nj2a+PVWj+jn84uffr6bPaT0+bOP +6ebH/3N+dnd08/H6rfTv6OaRvdEP8B33v3x692H2KAdlnn2o3/zpzTeX738+fWPmjvHibcYb3zMm +fPOfM3q8LWTy7uPtjx+Fwz87nzsLWnTmEqd2nptoirA+dzw/nn44/8Pt+f/9KJMwnw== + + + hI5KPfsIr2++v7u4O3uESvaj/MCv/35xeT5/fw7KPPsI7dyhXX+8+u7s7vSfC0aWF3n2gWHLzR3b +7fmHj5fzz430+RwKdE/XzQNdX0/9skPg/O85OXm4sw/M+zMvyMX13OW4eX9+e3p3czt7QfoCz45m +3998vD07/+Pt6fufL85mH3GPTEV+0l1v+d65uH6EhAwGY19w1xzfXL2/+XBxN2fTPEUHyIc92vbv +vj1/t/p6L+1txzj20t72jmgv7a0Z5ZZIe/5Llvbe3Z4K23v5l5uLD69M3pstxO/Fve0U92bvy724 +txf39uLeZFR7cW8v7n0x4l5hX4vAt2QkWy7y+Vcn8i0Y0a6IfCIHHZ3/8/zy+59P397868u2femR +SbHwtRyYP15+fIRb+QzM5rZKBh/u3n57/s+LU3RogdSTF3oxnuCPpx8/fLg4vT7SBdwVXnr22ryd +fwy/fYlzeP5A5p/Cb1/iGF5CAbadmt28e/fh/O7oOWjaC2377zjCHdrwl+Bb4CV4dnN5c/tf//pZ +xZiZ9PnXy/mqxPj1fgN9wlg+vD8/++7jI/th9ziC2b49Hz7evjs9O//+7HQJ4g0KPb/UMXtwsrgf +L09vj2+uP9ydXs9ft2nBF7CmLR3l7//9/ub6fINR9gV3STYpqrKcPUdbruIw5YKxbLeSo7BLxvLf +s8fy3y/Ig/z15uL67iSqL15CH3n+fdyqJ5G52CF+6HUaExbyDdvOBm2k6FlsTdjuNdo1yWiJkWRb +iMHp7cXdz1fnd/MNcLtEFGYfe788okzJhoNPt3ggj/Di+UDMNosKv7j5A3FbPZD5VPmXlyDKr9IK +v5gb2Paj8/Li7q+nF4/Jkl/42bk7svJyNfHiHfdCC/nn89ufzjGTO8QELd1cr3Etnq4De5ehjRVq +X70SddoCr5TtVqYZs/cY2n6PoS8rSOT45uby6Pb8/L9nWzVfo2fU24vL0/l23V1SYpjD2XHlt6dv +Lz7OR930+W5oN7db4pw/kLfzB/J2mweyayLmn29u3/98c3nz0687JJrsydoOkbVXQ8zmR7BsOTF7 +tWFsO0nMitfjsvpqdvqycIpt3uqzR7Jre33nPG5fb8z+bJZlH7N/3xhfNmZ/th/ursXsLyDk234k +zd5kW38kzZdwduxI2sksCo94lGRkbZnz/Qt53X+RO37rHTV+nI1lW0+9Zo9kV4Jw/jbbnHr88+n1 +9fnl9+eX52dL9GnTgs9vEZptad10kNOCL3YOfXvx4f3l6dn51fn13Z9P3+/QYXR1KlXNNkzuhHS0 +Sv+uJj/N4OfcUfPXfP47fb7FlHLrT+JluQa3+fSaPZJd472PEcb850Q+doXeLcCsbd8js3UIW79H +Zo9kVzi8+ZHIz5N4ZVt237tF/kHvLi4vl/g/XW7zSr+7vbmaPxh+/PxayUeYnMww9pjHeG4Z+/gi +MVezx/Ij7uSarxvXr5/fqH/5r9NfZ49JKN/d6e0iSqnfb68m/O5mvuRx8wIDuT2nCDh3OKdv317c +XfxzvjjVF3gBe8z1/HGdnX28+vi4t1A+sqzIC0Q0XZ+fzg5/OTu9PPvzzdv5Y+sLPH/w2WzeIlu9 +1PxfOIS5Czgs9UIiyen1xdXpi6WG3dU8dEXYO8NsmWR39mqcYeaPZNe0H3tnmG1R9+4vLJzoFHbN +G2Z+TrNdc4dZQMq3/VB6Ne4w80eya4fSTrrDzOY/d8Md5ovc8VvvDnP2atxh5o9kV4wle3eYvTvM +thxGX4A7jPlS3GEW0PxtP4lfjTvM/JHsGu+9m+4wCzBr2/fIq3GHmT+SXeHwts0dZqvtP7vjzbNg +yy0lHi+0hruYNXCBH+B+FZ5sFZ4u58YOLMLTdeCFGt/9pI3f/OnNt8zZ82aZ5msWQ7Q7R9TrzVs0 +Xw24I1mLnicB+EtR0yV5cvYU7WGKVu8p2mukaLOXdU/R9hTtlVC0398K4Mtm0c4xBa+Rnu05tD09 ++zLp2RfNoL1aerbnz/b07EujZ7lR580yK/wrI2uzB/8F2fD222bOtmm+5G0ze/D7bfOFb5sv67ag +v178+/zyr5env75ZFuy4jQ47VbmqZntP6sz/bYEDZVZilyjf7fnVzWPpDXYs18v8nCL7/Cj7/Cif +CelW5mtbrkwl/y9X8t/X8lv+fi0vVq/NZfvi+u35u4vri/kGrtvz9+end98u2G5ZiWcf3z5HjI5r +x3LEfHiPLDFzR7dLOWJmciNfWoKYbeGhXuEFhT8uuWx8yz31l4xlV3z19wqL7SUHj+3t3bQrLaII +W07dNjQpbX34/M3V+5sPwpZ/9/ERErbLAXxxjDtEEE5vL+5+vjq/m49ru0QYZuvUfnnEOJUNB59u +8UAeUYbmAzEvoYyYPZBHnJ/ygbitHsh80vzLrlDm3ThEF0o9u3SEvtqsiJ/lDN0dE8dGa7ozDkT7 +AMC9OXn3zMnL0hRuo1Zpb05eNyt7c/LenPyM43mt5mQSFxiUbfn1IkKzNyHvTch7E/L+mpHJyPYm +5DXd3R4V8d6EvDch703In187saMm5NdkbH178e7dx/m3mWw7KVg4nF2hBrPT0334ePtOONvvl6X5 +HxTaXjuSTv+ysQ3KPPvQfj2/vLz519zxXV789POdvC/OkAd39hDHxbZ3AePuPL65FtH9ev6+m5Tb +K91eVOm2v+P28dHslW5PQUq//un2/Pz6a+HAzr++uH578dPN1/+8uLk8v/v69vzt1ze3p9c/zd5q +e23cXhu318bttXFrRjafD9ur5F6GqzJhttXl9L8vrj7ePXL1Y74k6ftnR7x69pjOL+VhkconK/Fi ++p5vL8i/n2B/vZRHzLcqS5zEPb5DKP+a1E4f3p+fycF1+xy+8M8uHb1qZc1sEpWWeLG0Py24zWsY +O/v7f78XXm+DUfYFX4DxfkSb+wSqqb3eZq+32ettviC9TdTSqN4mKnGovtnrbfZ6m73eZq+32ett +9nqbHdfbXEaFxqtwodgroZ5eCfV9FP52UAv1OvNnbKCP2nYV26uMAH5OveEL0ad9Do1tIw6vJofG +/IwNW55DY/6KbHkOjfkD2fIcGs9zD8h2exNv//F5eXH319OLx6wU+7Nzf3buz86NB7LlZ+c+/9S2 +nZ1LqfK2H5sbCdO7cnTu80592txvy7G7eD33OaeWdOCFGt/nnNqtnFPf/3z69uZfT3F/0e5Qoi88 +u8Cu+HXOToq2j8h/9i00+2LNt4+Q09yt7d8vgGTzB/Lr/IH8uuUUYNup2c27dx/O77Albs/fLqLT +uyYDfMeRfhkCwOar+holgW1Zldd9n/heNNtl0aww1VdzUXI+n/ESbMaSkcxnNF6CzzC+nD2Sf128 +XeBOGL9+/hG5+SP6+fxxz8NsSOnz5+egvkSlxhNk0d4d7mqv1NgJpUa9V2psLSscXotSY/5A9kqN +HRB/90qN7T1290qNbaTke6XGXqmxrUqNL0w0uztd4Gj5GgWzd7enZ3enl3+5uZjv2KyFZ65xaum5 +/TMPZ+ds+fH0w/kfbs//78fz67P5HOeo1AvEpH9/d3F39ogCK5fY8PXfLy4X5EoYlHl+zddsH9vr +j1ffCRb/c8HQ8iLPPrKzp/Mye+6RLNNqbXGc8/yRPKHAsy2nwutLdrTgPHh3e3M1fzj8+NmH85pS +N73WVEfl4exbW+5u5vNTNy8wlH3uosHg9rmL9rmLnli1PF8m+dJSFz2J0ujvH29//Hgpk71LesTX +mXtlgUix5cLR86RceSE975L4sL2qdS1/+NXr8B6bP44t9x0rX53v2IIR7X3H1ozyxQ0UPV/y5pHw ++9dtprjL+bNXZKQo91aKm922Usz2Zto1IwW23BaoxPfi3usW95ag2V7g2wt8e4FvL/DtBb69wPf6 +Bb7ZosFrFPher1/a7JwOe4lvOyW+2Qu4l/j2Et9e4vskNNtLfHuJb4clvsK8FplvyUi2XOqrXp3U +t2BEe6lvzShfXOr7Xzc3b3+6PZ1/3r9Gke9V3hmxKEZ8y0MkXmPGi9nC3D7jxbMThH0az4cGss94 +8YkcRsoD8Spo8z5/x9aSsXeXwt3pJcT/9ePl6dkvX68UdPP+9Ozi7tf/WqAT/nD36+V8HXf8+vld +uJdcuLztO2vRYHZtM/0BiLhDe+l1akSX7ZedOFc3yzm07bf+fGAqx+PXRN6+HMZhF28DfE0M99Lr +M7d84ywczq4oRGZ7nXz4ePvu9Oz8+7PTJRzpoNDza8qXrdaysQ3KPPvQ/vXzguj8S2j15X0xg/PI +Rjgutr3rFzfn8c31h7vTx65SzLUq43K7pEA3bvbmPf3vi6uPC0xb3ffPvuTEuVeTZaiendPq/FIe +FimbsxIvxmN9e8F9cxKNjC/hNSB94B4+icRqz+3tyq2vexZpl1iktMCLz9hpwRfwk186yt//+/3N +9fkGo+wLfiEs4Z5fenl+ac8u7dmluX34PhKqHeSXXqc1YAPOaduZwedxk97+ddqrzJ8hnejtxd3P +V+cL8rrvEnGYfSD+8ohPQTYcfLq9csYvj3yZD8Rs9Yo8ksEnH4jb6oHMp8y/vARhfpWOxEutZ1t/ +fF5e3P319OIxiXp/du7Pzv3ZufFAtvzsnM8EbPnZOX8gW352LqXK235sbiRM74/OV3B07o4een9L +4zbyQk9OCXdgLZ6uAzuECK81FdE++exolLuXiuj1XpG3kcVgu1nRvy/OYb1rfNtOJlm6OpWqZqeX +2AXCblZl/Hfdrw4yd8j8NZ9spM93YH9tO8X4oxT98Ljz2O4SDEZS/TltwF2hGK/wbHrW+K9tzb6w +T/Hx/AnSXk2Oj2K2MLXtST6eRRH1zGP67ouJct259Biv04lvMev2enfQ9ttTYG/AyP7+ihMg76I7 +wibrsu37KB/T7LDGXWG1zeH82Kg9s70/kz7DXvrh3fntHy5ut0FFsi3rfHf64/w13gWFpl3NtnNw +7P9zmcZyUOblUnF9vD772w5Rk1eHZYfNqlx9GXj2xz2evSCemS+FnB29lIsJhR1EXf/99vT6w7sZ +t0hsD76/Tn3IJqzatrOfG8aZ7II2RIe2JXz1Xh8SV4aec99cXm7BmmzLlGyGrHtfzSUdeKHGF13/ +9NU3fzLlm99fv+2ugQKoAuTNX26u/ypVME1JoeCj858urvMXB395zzq8vvr+16sfby4PfnN0+van +85VZFau/Xlz/8tuDj/JvufruoHeo+eFXefh/5Mf/EdC/Vn7159X/97/L1VuB/vC3g/KwLMs2rGx1 +2FSrq4PCHJbe1FUEFFbeV6ZeWX9YVa4BoHV1K+/doWvrZnV2ULjDYLxdWXvoSpTxh7W3UqU5tE2Q +ItVh7Yy8EEBpvEeR6jDY4OWb8rCtjXxTS7NV1RDgKjzbpg5tepYizaEJVWu7L8Kh9cGzVuddvSpa +FCkNAI0L7Jkp8VGDrhljpRkjfaqkCwLwbesFIAP0bdMBUEjG0YRm8E3tMWQBuMoSEA== + + + mqbWETvDQk6mq/RsXKYTz21w7L8rjayP8YcWE23CYah0RALypjUr0xxWBpMggNpV9crUh8Z6NFSh +K1IIf9uWhfBOhqvfomKUtgR4E9BdtFC1K7YohaUQe2GrlfZKCmk3PQANhl9wKNauODSdPAE1bUVQ +aRvDb2wlw5ZZrW2rlbimWXHiWw4Jay5r0hy2bVWj2lI+kRHVh3VD3CAOOL8CTtjapzJNE1ZEG5f6 +0vgV8MqVKARcAwJh5UvHQsRHWQLBTyx2AXz1Mmigb2m655If6++ifxlLF33x2ESRtxH7UfQdiV0t ++r7G8RDJBd3jbHPQRT5qTEvRz0ucuiKfuzi9RTe/cQGKfAW4SkW+THEpi34t42oX3XInlCgynEh4 +U/SIE1Gr6HGL+NfGH22IWFs7b+LnPlWAeWKVmAw2g3liw7rM7Iw1qXshdjg0CRurfmPpQJ2N25G7 +r8i3HzdoMdnFRb6NudWr/KtIDYqOHHD2TdwPkWaQrlSeMCUsSnkCez4gTkVPnRL96r5JFK7oSBzJ +YJ32gNJB4JHxEbFkXYhqMnVxBrAqQEjf7YKgqCJoa9kBIDLXQNoXVFa8r1aJrMfHswOiftsmACrw +mPFUAck6t0bXCsk6q4xdQWedq/reYkSuGYxIhi07xfXDxsQ0/EYnBnPXAoW7ucP0BtdPryyAkEOb +FsCTvoSEJy6gGSxlZbqlFCKF1W7SaoNkyhArYFkCSCEZR+Bs99/UlWkjavlGqV8bEv6hDOl63eMo +0dj3myzR9bjH2A7puh+Q5trVpt9h2E6h7PYV8E53k0ubz61G+7PSk6My+SbWTsSNrkeudNImWmD0 +hMKm48hqnCBDqlLxG1sFE+mOntPcDNweVWAhELA6UbCS51rDpVcap2c71r0n7MQSbEoSSxma4lFE +cmec8hAJxyvDQsTHSJjbejUk3c0qI+s5xXeRQYmYLZRZCbrXM6PxOnAHosTWpWDiT9g9IdeDo0me +Ob2Nq+Pp5TlIIeM1jzff6GEvy0cErbzRNgQNgx6RYaVz7fUIrZvV9JQdH8Tjk3p6mI/P+zFDkGh2 +T7LHbMWY75iyJmPuZcTdKJluMv5nzCKNeagpmzXmxJQ415FVq3VO24iL6BPpctNGfg88hgl1xzCC +rAQsf6IqpDume0+6ZG3HcJJ0VTlPmqhbIm6J/CXqlyhkTyATEU00NNHYIQnWp+MRp31ycPTjQfJ0 +P/pZBJHf/OMaQsPb1U+3p28vzkUqMb79rVQja2MC/raC504+d4e+ccCAzHHerI5+OvDVYVkLCQKg +SA9FMLUsMDZ2kFWXJRZ6cHR18E6aPzoSceE/PqJvTWmEQpWHIVgn8wSILIfRYWCR5VUlLz16Yqpa +lqrEad9IR344jaNrlBGDICHzbAUtXQRIu1wOHDiOAoXgu7F64Fj5JTPkDuuyavX0NzUYwni0VNKY +VFKHoOdI01jMqExkaIxyFI2Rs7YGQQt6ktTB13rYuP75WA4b64BmHSgcOtM6PYKFNwTiORmctiw4 +30ohwU1neRLKMGSicNq4Egw69jtoEA4b1z8f86xxtc+/qOpKjxrTgrzLBAD/AShDzTLusLJ67glX +UCtNqHV8tqy5DVtyhtip4LiOsbcNeSHZzHKEKVkocabJbi/RfaED0veaZ43FQh4fpFeFfuxXWliP +FoOdzQZqZSplv6B37AS4WnaropzFbhbsd8nNXwZymRgbGhIIz1dDhqXlF0LW9aipLeuoStB7zHpl +nbbTglEJ2MCBO9qjNpw0Iu9xRzcNKiFKOKwqkUQomhw1QkxKyqKCQRWOGsEpz+NAsIzya+NLbShi +YgHcrGvuTI+WgbomNFUClPg4/uxesbBZdWVRP86niNYcu6nly64HRGSz6rpIPF5lg8BAZRGycbZC +LzAPgvk6Vd6vspnibJJ01sJaruJsc7J92y0HV8O1Ok0JsYQIcGoTXnFFE1r1i55hleIFMccrlsmB +QJzCEdLjFt+0qw79iKBWUczVHQ6zLV8p2hPN2RtvVnEbdJ1F961fZfsEe8kR30xbcys5p89pM/o2 +rPq9iN1adgDsZlPzICH5SBPa73fQBCofIkkA0bAteyhIpYeNnDarnqyQ8uiBSQhIkyD4KlEmrDKo +TE+8QNwSbUuEL9K9hEM9ZUzUM6FsR1xJWzvay6fjgwECV4rfXWnystKAlfVVpEUDxaALTdxIusnZ +RW62qJCJIygwSK9HMAcJIci6tp+XKCjV2UQVnEtv+2/Gk62koLHZehTjJStGS1pM1rwYIUUxRppi +ilfFCPOKMWYWU+QtxvhdjDeA0l1rsj1SjLdRMd5nxXQrFuPdWoy3czHY8VYLDWkCPwElJs3wJp1y +SlZqEi7KYW1TrxIFLkiZXE+Zignt0mO66albkZM/z5YzCqkEuMiJaKWsQyKyZYjSayLARU6d49tY +vOjKxyaKvI3Yj6LvSOxq0fdVh1Pk44lDLvIxc1aKflri1BX53MX5LfoJzs/AtAT9MenaOH3ZWWqq +/szvjtsOJbIzucObokeciFpFj1sR/4ocAWXqeMry86gZMrJXIypWUXtUlwNuQzvjzbB7VcazdNuq +yPdV3HtFvvmci5DBBi6yHRz3eP8NqEDjIxuGhU+kIuPVOnrSMXQdySkmdCljDDvi1X+V6FvHXxJB +mqiqSFQQWBTKjFNVTOu4WCCjayHI9/RcMdaanh1WtPYmsssjdvr44A8iIXybc9k1lPXSgrAMNR+l +2ca4pCYJFfG5bpOm1kKKJNEWIcpFWKmad5EmIgM8mp0IIdnGcWCzr7AaVavjbMZL2HREWHEw+6ax +VslDHSLC64bRfZJoKqQQNuZrTLxAyqZRbXepSkCZFyrc+KOu424QfsjGz4OJFVRaQbCRY69MSA3H +3Sc4rJpXzInq9RpidwMNZdL8Vr7VOW1sEzetIIjVmffUY1TKu2Jdgu8BiYDhd/8uFu9LxzbyJmJH ++n7ErnY9jcPJRxPH3A05TUs3K2nu8qnDO9UJxPlF6YqHYVwC1/Hw3TrF1eRiWt38XO8xSmQYEbEm +fZHwaoJ8Ge4RQxvXf5NwOKFwwvMMzTGpVWC9uhcw7SJAr2yd8Utku/sX40KoFxJvX6+0HExUEpRU +bjZV33lVQtis76rwNwoRojoa/mR+RhM4mGATV3mwBuNlGq/jdKnH2DBGlylGjXCOOBk6lJxiLadP +Bp0Qe4T42Z4Y75dUsttRrLwO+baLzXdbc7h5m9Vwg1vtz5AITOgEZ6epc2KSJlJ3j7OrNNMdUWL9 +fkC5uF7x0NcFw3o61xFA1Uo3GY0ERtS2/wIY01QZ8e10GB1SEet4skRQwspE0xPeZnQ/oXZ3OCS0 +L/INUXBHDB5PDt4d/Mc/Dv5BZdUPbw/q1W9+u/rhf00BX70xq2/ey59SDqqv3nSrfNU/jJd5sMoZ +Cp2hyAjLRjg4QlKWGCHyGNHHWwFlJttlvJ1GG45l0IWgPQo1e0gNODrcTGgGSozpyj20CJ/mdGpK +xMaEjiVGHShG/ZsQbhaakvfJAbBmuqZHyeSwWbcy01NrcqytwYA1B+T4BE04pp9PDt/p+Tw+xbXg +9LSfMARjriF1cMRdTDmQCZ+Spn/Mz0x5njFnpCV1dYtuedPyF2n9J1wfy025w5x5HGx5bqaMPExo +x4S+oAT60UlT0g901MR+1vWUWsbtN6KpE6o7pswsNp7lyUKMDwEOaXxQjA+S8VkTicroRBofWTkO +XkOP/801Yr+EIsITRygi3HEow0CbJ3JK4+VEv1KR2aHzh1VQA34LvwH4PdQOpg0AHHCiEjJvohVd +ZDGYS+rDRqTawG+kSIDyodKdZUpfiTjflt5FbwRjS6i5Wl85Fd0MTGst1IulipoGUpQcRZBAonhI +o4lqxkTGEVnYQyxpILFSE6BiI4YVglODTgnLgcxUVWKBYYCqLP2BXN1Cy9weesPn1sAwKIefDDBU +xFnsKoNPVD1fUUZmGWeV9Jmmon9FmoICc1BB/ydTgIks0ixwEmoK5nEWYMiiKCdjrKyqqDAkIkOF +DQhApZolDuhYywTlam1ZsXNqXqB1y0ELVEHCJdvb0CQk4nSriAipz6qCVL9oYfWGlO2jlsj4slbT +GTVtFM8D5gBFnfpjtNwUqB4eEGyQ2409oEwvfRJZGN+Y1qpd2jvMvnAarlRxVvBb1aCVj24MIsQ6 +6oAaq0hDrrMVPqJqtJKyrRpa3SLZkIZq4H8jq4sJBMAkZShVAglAJ4BWVQgRJHvXpm8sPGmA0WVd +RxS3ju4GNT1iuAuwsWSsyeqvuCFbx0R6aKNFX1C7iiKntAMEdWhZSXhTw0MnI23usG1U3MF3pia1 +St+hLh81V0S9Im/QlVa9baRXvlX2jOI6us05S/0GpoowZPOxFZMJgAzTmrqfomLNPBYw0Jaxcv1K +1sNSq4D14N5suRvivi6jZ1kJ86YudSQlQiGruPali3jeukiuQZFUntOzRUq55GijrVO7rYjeDDCx +GKJrHSKyO2UhbButSqocwg+vXQS2BxO/jv5E2d7xPrWizYJSoZh0pY1dq1sdtfdBISa00UBYxU1X +ynGf5GiFyaLCnMoxUhkOiqB6wUg6STWs87E5WKc68jqgPYn+kkYXOZGOhLzoKHmi9UVH7NOBUKQT +QT3A6C1FXEw47Kkccol4A4eFgJRRb8H32etYAyqoo9PU4Nw5g915nbG5+S2aMSAMFubjujm00NkZ ++rK4qbEZXgU1T0YPkQVOcbWgTauI701Q07O0L/tqJaeyOzSy+X64ggTqqBXycuIGLP26kk0LP4dm +BTcqwV3ZmUdnmzZ6NLdRLzvOy0IH2QfU3kmb0VD+Dznff/fN7d3AZxzSjnoQw713dQaf/Y/Xb1cf +fj59f766omP0f8pXX8t/B3bokzuSntawCMpiLmYSwCUuZROUDV7KKCgnu5hVoAy1mFmQUpuwC1Js +A4aBAuhiliGWWsg0SA+Xsw1SaBPGgcUWsw5csOXMw1dvNmIfvnqzEQMBOXs5CyFD25CJEOTflI2g +nL8JIyEFN2MlqCfYiJnAHt+InUDBDRgKLbYBS4GCGzEVKLgRWxF1BxswFtrkctZCy23CXOgBs4S9 +UL3NcgYDYvCnHpVRjF7JbNVR3bi2Sn7cpjO0C7HR4Jh7w2VkSlff3Z5e/3S+PGBGDiRBeEefBivU +lTEzOBehp/PqCHVC46WvK3pWycq1BAVMJr1s+PeEBiu+TV+faGAD9nqq80QN/zBBa8usy9ZyBNXI +B9C9Z1SCdi1VU6rTe6ontVZkzaXOFHmv4usi73yspuvfSZoJRXB28ESmqOvayUHqTtfBk4NhNSW6 +MGwNFWtXUpcAmHZ8zfjWTEM+Tel19jbW0VcRu9A3E7vAP1Wb9Va7lA+pn5g0L/20FJ0XZT87E0Sa +5RJqA1xCy1Z4DDhp2obO9OUKu9BCWztm010L110FFOkBPHILwujgEwqf5alHqJzbwg== + + + CZWw3INBK4UwGHgNS+tGWDa8Cr4BZ1fChy8EOo0Koygjh0MoMQGmZdkhQqr0tOZBUALL1LlAzwIe +X5g3YRVUkUmSe3IgfQxwvAa60AuWC2BoggdDT0daqPNIxoTWBzmnFNSQOQH5h46TKykclJ40/HFC +ZU1Tq0KwkcNBQaGmOjZWSpwQpkLZPrZMxGFvitQ/YpceE3EQJwccl+XBriPlRxx9keaDGMo5KrPX +/dtUx6AKttM1k/rSd0Unplr1/eWobFhlg4rzko2c07Lin1Blc5hmqZ/oNEn9YugcZQvGXrHt2NF+ +Tem84smEx3VP4+2Ro1yleTk5KAavI0Sng1X4SjdT1wykB4EMukLUKSbdLaZDKqbj7lCmR50ive0n +sEh19LNcJNzpl0IxWZC0X69isqbFdN2LKXIUOe4Ua3CrWIOCxRRRizXoXKzB+mLN5ijW7KFizVYr +hjsydm+wcbvZz7Z3ky9k0SNVMSUVRcKrjKAUa+hORpdOkleNgBqc4x4OQ5V+XrVtHQ++KDKLJApP +Be1kzTE3arXQqdY5TD90DqMlR7/XqW49Gc1Yra4IG+uaB6w/2vkufxX7kdWQGurbSb3Ie6Mv8z7H +GlKnTvoZgA9UyTmUrahnefcizkxeWudl0sKgF0qJ8M62fU9T2/1opkO23QE+nqc10zmd9DVLM1hA +22ajKfrJWIMNiin93w1N400yi0+GKrDJhNDeNZw1qkJGU0sZfTj/Apos0ldvpkuJjnE8wvJPMUAF +wBGmqCVy3NwavFOj8RA9IVlMsFiFqcl8pK2QvS6G76c4kLVZ5I2uwYR+HMVwINNtn01OMZy7Ik7e +2tdrMKtbqgwB+yUd9G7dONaOeO3kdHN3nUlUVZhaJ90hlDIlhZk2BgcgqLdNhwGDlJ1IrKa0kcbT +ObRCXGCpdMyoYVfeGGs6+cbwsFOLqh4YjbUIGldd3Ak8NlUHaIHKDc5BuKlSl+iph+kUFg0UNJ7h +ki0CZWNAIq23ZXRbDRRuO2dMRJPiB92A2L8CHYQSTfl99K/oO2gQNgVhHUrOmsIcTM8an29Vs0X+ +SY3u+IHojJOD9JKWagR6kaiUNQOxY6VgkGpq9LqpOTlI3dEJbNAvzCo1rmmawSRV3rYa6MPFEOoH +1XxUYHPJlDBhLVVowwfUTvUfQOHq2rLO6ynSImbNFWt61c1S1vlumrIxFmumopuobMa611rAJdh4 +/rU5MB4ZHg1Wsx4iZZHmL8PdIkfeNjlZ9zjebYGThy0kNjjnAy0kRpgQKWLo8GymohfclA10gg4a +dGiOPZysGd4KVgZEQQSxRjoj8xFEVlQ/9h+ucLBJZ2uWaFSvvqZoaw5bKGyDbbH7hSE6Otu41aO5 +rUoBekMHW1YaMJobSR4zcvSUJurAhrRGSfeI2qhBY0Rv1DgyojhafERzAJxQHQFuQndIppdSHrqR +jGkPafuY+ghwiv8EjikQjQZjGkTt/njr8Qga06Gv3qyhRNDXT3Y9tPETagRd+4QewWtoQpH0fOxo +EjXfE6pE/6QJXaKye0KZuHBrermOOulBPqZPqmGeTtM6GqVK5TGVUuh0ndZRqgxPM1qVoXRGrTLs +L4boP6VY+WaaHPHt51eaCp6u/nh7fn79SUmGQsoyJEyK7yAI9w8MDvKHdcXBl84zQQBjPzXJUBuc +RpCX0dAopIhe4S4E9emrYXmBV6zTQqBPpdXQ/oDsBCL5VXUMxqyzLEN81CRDNTKtxPeyhY1XZ07h +wrhTrTOGm1wogks5howGsls1Whh8pE7b1g9zDBFwFgMjRt/UrWV4GikNLRgx/NwLNscMKiF2PjS1 +poow9OyE0bHVmB8n/zA+TT3YAKpo1BOCX5WaZKhBYgxkAwhOt4CvYZnE3+BSkqGgPs96DrC0pgqo +XIjZLhp1mHXOJkczV5X04TOMN9J+NivtN00FgtFMBoBQ9ujx0LLDMDnGvBvImgKLkzHqGBoqhqdZ +B09MTXjjsGhCf+vWq2UmwEpUIww2+ikahDMTI7rEROg3kSY6dHrkAwBaNVYNeB4JB4B51oWYY6iG +tyiQ08ZYnNDQ9lGWwXXPKcdQaNS2El/G0kVfPDZR5G3EfhR9R7SnRd/VOBoieFXaONcccpGPmbNS +9NMSp67I5y7Ob9FPcFyBIlsCrlKRL1NcyaJbyrjWRbfYCSGKDCMS1hQ92kTEKnrMitinP4KNONtU +JmYkCtHRs3JNiIhoE6rjsNaGE66bMiYEiJGB6K9bZQPgtrJxmHFfce9p3oFu88n2VKf84R4u8k3M +jT74irQgWsUY30aCYdNqVD5mGDLeaa+ErPhVJDvRlFfnCYYSYUqEK32RKFvRkTZgh2ubiC+V1fRC +jXEplU5oFcvqGJ3nkWCJuGi8idhZtzG9EPxvIg5Xmn6lZYamSLDz/EIhJhiSqQ+mg6AOzQ0U60BD +DJDtGyJNT/l30Bv0l0Qq9pcY36Y9QJqOgduYwowDr8lu1Wlm+vxCceowt5rkhwBMft12k29JWXxK +7kBbOVex6VaRCl0XUzXU2Ld5bqFaN7IGerSDb+o2+TtX3inVS1OvmKe7qc0oJRDYrXJS6nRzEsmN +JnMReh4GJLmp+E0i2thI7WBH6T5Kuy4eBv3G1IDmxvt892of0iljQjx2qrSpNHVLRykc6eyQmmiG +PGIn6c0qbQLdFjS+Y6UbNAO6FTTAPJAJI2lrGj3P63i+t6lMAFqQRho9JJnjQqlou0o4pqSWnLvi +oY/0WD25M4odVhk1zwi9ETKipDwoTtsmsiVBUboMOm5f0lVe2q+bjilhB53Gf8FjXcdgdHpDLXuM +o/ScXeZV5DRUcao88+C4kuRN51KPxpJT24LEcKY1GeHodB2dv+PzeXqEj0/5MRsw5BSsYuOAmRhz +G1OGZMyzjJmaKd+TyHOizok4J6o7Za/GHNiYRVPscxEdrSYXMl5zQJEo0A7sE2PYJReKJIUkpwzx +mRRJ+U4SJBKtmNBA6XAia5GqJbKXqF6ijD1hTMQz0c5EXEfUNz4ejxnsOZbkNqg6w9uGHiCVIF3N +1EHw42rXZReySIwVLcnpoQgmyFpDugzWNYc2CO2d2JKFrQwtMwfJ34r5K2Sm1GIMMRI/BId9A/Oy +rAhcd0r4X8qpOMkuRAlibT47zQlAJNFsTX5VpBxjx8xn59qUXDDUms+u6vLZuZjPLh4VhrF2ms8u +hv8j6L7OkiK0bphjiM/HmtAupf5zzDFkVYK0zF0VYka7Lu+g0zhAjYRh/isXE9ql/HXDFEN4Po7p +7Fz+RZ7Nro7Z7Pyqczw7junsdMgNU+DFTF8xn50mA+syRsYI0zybXROz2dlVTAA5TmbXaoIhw4SX +mnqsWaWyMZldG/OarWJa1BhtUZqUOdWmXGNuFXPZdbnTYpJIzX/D7GqdR5ZlJrt42tgmZQ8LMdGj +i8Gp1td1FnnMTHYuZrJrYyY7EzPZBRPLMC2gpooL2pfWxEx2Powy2XHeFBMZZ6XOqsNUdrZPZXc8 +SGVX2i7Zblcyz3+qlTOXXb3q2o9Jy7oOMpedXWVjYC67sOpH2aWyi/HXDRhspl3TqN88lV3TjnLZ ++VEuu5heiCtGJFt1CEUM87ri9apb8AydvAkxjV2l2OXDKI1dq4iouBTRLmFSlsXOdDnsjoc57Mqw +SqjPXjZtTGKXxtHohqq9BmeTLmgSu3aV7cAYrB034CCFXcxgV63SDk5T2e/xlFo0kQGmsKtSSuOq +jx/vSEmWaYiQE+a1YzqoCCGBKlMm5bajYT0JS2QuUblEBxMZTKSyp5SJmiZiui6xnaYbajQPAN4P +U0a7ZpgyukmZ8+pKw/OzPjR1trNiJzVbqsYGx3FoSlVNx8OhatJVb7q5yPMNxQlk8laOLn0zXoSY +5TJk61SMl3KUNzqJgxkuFCNkKcbIFMlWm+FbMUbJYoyzxRipizHWF6NdUUz3TTHeWsVo6xXjrVmM +924x3NrFdO8XA/LQ6KmUpcLs0kUriYGnyHFKF21IheoUGAzn1kiliikd08O66UldMaaFg3TRsGwc +p3TRPUUtRhS3yIhxMSbURYbJqXieLjq1kXC578ggXXQV+vEU+YDimIts0JyVop+WOHVFPndxfot+ +ggfnYeP6dSryhcrP1ao/+ItusSM69GdzMTq+Vx1KFT1ODVNFtxFZa+ejaGqrWJzu3swU3cQ2skTR +uiuiViDrWeNDxrUUiXgX+W6KO67It5z2abxti2zfxp3dfxP3fseJdQQi49bGWaLDqiM0xYQaZaxh +R7L6rxJV6zjMjvRlbKgmiq57VjUmik45wdkKE0Un/A+KJAwhdz1fHBNF+1UxIuZFoub7TEP7TEP7 +TEP7TEP7TEN2n2lon2lojKT7TEP7TEP7TEP7TEPbkmkIIZLJoXfg0lvBzgIGvzYNshtc9TAEfKoW +iQGflEdgMtEoCxGtKNBYymxq/RcMUmE3BKuKbSa8hRQSbIgWd737q62cSf4ginlyijCtbu/AjRSz +TC+Pc4W33ARY/DtXjZrB+EwzUOtCGmtj2ucU0K23ASA813UXIVmmy4cJqaxjJEgZ18ZQREZEijWq +aaHcrl4KNGI6NWNg/WNkmqxEclaIwea+T3viUyr7KvYJn/P8RDhLSp5fqY9YOKRfnDrxxLQCrdQV +lT4mojijgym2VnF2uErqo2CikbsKZQy4dvGaAqgSCNEg7gRR56S2jAly9av2sI12hWRgCIdt08Y4 +5dDa6AfVGhfpp+cGlDFpfBGWtQ5eeeM6RkYTQocrTmH2jcxNTKGrux6JGWLFptIMVbAIljErhed1 +SA7bJtrkK/qZyJR49ZCATU/XjRHaauJpeNNEqaHx6q5KE0zJS2Bq00PgqSDSNdExgizVLbavyAGn +6tSYowUvydGxQx6GXl/3fa4YZ27zgdUxbLsbfJ3cI9P8QONj4oUVcQobattdDwqgHXHiOV7GcMZU +DGlIJQlnTyaBC9oS1r0kO+h97XoA7apNutUsfRMTElTkYmQaqnKAhgKytJUAZMi0OBN9jZjGGIC0 +QaGpUj28tSE1E6hUpAEBgBZaMRPzYGvKaK9dyxJGVzHFfwxs18QWWbbooCZf1RWlL0re67FS1wrN +8l+l9N96nYxTT01L3xZN8m+iOxnJVR319x2Aht/oCRJBSBHN9M0g8UjykBL9EwCiCdypymT9K3Gw +ONK3OLqY759EKeXjP2PCf3VcyjL+G3WVXJMf+uygGCRNj0n/fZPVMMpDrRmH0BWXzI510JzoTfTA +YWdHOa85omIybGbPNtHmqcQe0zeYK5IVaxOp0a8CDGlV0y8Dcno3VZwu4rmSMSbA0NVUfbwr412B +torifwjpWQmmcy7/QKk7Marp8v/nWNddZEJUpYMxNY8xrQXTuYyyosd8T/SSV8V6fgmAerDF/Oox ++Xr3Q90su+Tr2T0AtWpKs4sA4vV+ZLbODgadienY0WGrHc7vAlh1SebPDjLWMl3DYg== + + + p9nqYyJ1plZvTGpOVsZo5vs6kivf6CLLMkbSrTyCoEsTh2eTJ3yfIj1iWboTpcP4LmP/WbwVgJM/ +vBYAKG7UZb27KKAsSR7ODnqQS+cbcoFU8CzAIV7qTtDbGw6VI1JNWekZwt4mRqbjmwJ06H415aQe +yqFVRn+JaRy+rCPM1hqHj+Q52PHBliX7LRw5bgT54eqgbjTHyvhDgSPBTvry6GxmlUf3VmlqAydQ +l1XZhXGsidyYMpQZdBlLGUWu5UylylCbsJXa5CaMpZbchLWMYuxi5jKKbRuwlyi5EYOpMREbsJga +YrEJk0mFwkZsJgNDljOaMYBzOauJMW7IbCK91HJ2E6GkGzCcX73ZiOWERL0B08m4ouVsJ2OUljKe +UmgD1lNLLWU+2cGF7Cd1dcsYUARbbcCCYo03YEKBUcvZUGDvQkaUWdE2YEWpONqEGSUx2IgdJQHa +iCGNAeLLWFIlsUuZUqXom7CleopswphqKNwmrKmezxswp5qebBP2VJvchEGN6TWXs6iadWA5k6r8 +0nI2VcttwqiOFIVtF/n/HWxVmqkyDf1KzWkajFRrLFpj9c7EwHPdOiWiHR8nXSWpLcBZITQSfVcm +CB7M6pGsfrgl70jlcDAWzQGJXH7q76g8lE3X6EWykM05sMOrR78rcY0v9h3dHRz2n2pVhwM63oRP +l4PXmHiFqrAnumuCqRyca5FSVpAYtF+DtNng+Nsm9J8dnc2u8ej+Gn0rEy+0KK/2flZ9zcpG9fKS +tWWeiQ1Wlza45esrxTZZ4QcQnKy2yRjrK6ZtKE3GfQtRUyY88ufIA2mGTLztcl4il3C8szTEeOCW +rpg2XbAGbqe16jwbCa9V4wkAmptUeLxabyilhKIUX6M1+ivgGJae3TpIQkp6Ww3obX9Z2+CCzoxu +k6pXA/Iuv8gwEoTlAICB6BA2sPoMbq6jN2Hd8ApK+dZEL28yzBRMXLSEQMybzPdGcnKDoIkoqtaH +zIcig24R6wL8xw5Bh5BGOmgnh59y86Wvjs7m1nd0X32VVd/MQaX37701SKeR+kvRTlMJL0Y8bqOl +qEfqsBz5NDvNYvTjJC1HQBZbjoIPEIhOTYAMY9BPXPUJtwKDyZWlpLqhiUQpKSUY8FQl/ZiHI0UF +lUCVmEkDgK+aGM/XggPGMJGSQ/2twEXLkJiQgs8YuZQxqWEyLOlSytQQxYKeqSHjE8hqup4/amMW +7bP+RsrhhZShXg3YrFCthprCEroAullqtczqZA+jDCqUGVExkKYwQPUFYzZqpPxNcqtXkZC5OSaT +vRF1kEaqtm51j0I/QUE6CPNMoSsIiol4KjiC47mBoOjG32IfI5NS/y3yys+t9+jeemXXaPLhQcUP +KdQm2JfluFqAf1pqMQZqsaU4mBpbiIXK3i/Fw1hqGSbqzC7FxYfIBKl0rSnpnaE7LKgifAeheXN1 +cp5GVEqd9ILAMoaxtJCf1fHRkvjXcgiYGFgLF16cBkmX2F8vXCeTBLVfQANKk+xMq2kvqCtgqmsN +PwwxugJaj6DxjSq6gGtkdAWE1mBWkyFtuBlreLdzH8hM0lVeBMKWA5f94ODrznRGzNNfjT+1Zatf +9N9yK86q9ei+WhGPyAkZ1PrAPpwurwKXLrDK24uXODW2cJG12OJlXovnyNokW//evE2fLY/Mh1/O +736rQaGaePO7A4RBC2GjHOuFBLeUhFuEW3fJZU7nZ+e2NcIIZU4apIbliS6UspGFc9CIRvna1ogX +MTCfqLqprBvfAci+k/1IEGaatDg1EoS1CseWapVnpkGP7R7jlGAW94pumZrHew1o2N0T4um3DPKH +ooSae8d41wSxqsMHx9RqqmqN7aHGq+qeGfPP24u7L5pRDc2wDY3IsxrHxRk76SHQnlm2oje+N/pF +ajU9q2yBfnVf+FENftjG8WSsmANHwc9m4+8gsfdSyPi6H69wgvq+G3+NvA+l7yD1qIZ61Aa8XRXS +j7+DxN6nOtPoUqv9+FO/EsSNanCjNo4nY8X4i3HnrjJQ7H+BzoCdTwMspnNQoDtVhibFeB6LcfMa +nDeah2I8jK7iNM5iOhVdB7tvxtNZjGf8eDpyTgfxcDAbCZKGQcxssskgag7mQlEzZJ/4UR1+0Ioe +2YBkE5EgaQSp0m6Msd1sGlLX+k+aUR3NoJXjyXijZzSCgGgvgaLEi/x0xTSNpVcVTcqMiLs89CYK +CoWaJ5QJj2UZvdq4OgiGg1vP1clCYcLttbycvKsJd/gYKOJDvMGiaGDNaIMG7NRkKeVl7YImG3bl +8JE5NkwPK9BOg2gqGx/q+Ab4Z3HrVAne8IRPNibq6+px8TXaSb+JuGoEdFnpw1AFbENhyqEh9lBJ +0bO3NTXxeDilx6A+Weev4Itkgo49jacke2kalqp5IwNi8JiBERU3NAaalslZXRSkS4agZ707Psh6 +f3KgY6s7SDbubEKkUDZZJwf5PKYaup7mA8HA4rELO3nLHGqCX+SDrzBRls69SFph4+GEPDJI9wHW +ilI1cJ2a6QgoGYzqq67UsaZkjgYj67hpEFlmaQGtcHeAW/WAGgkjmlVfqNFkejH4gt4A0a7CRM4t +pDFBCSQoYj52NUd3gEZTuqQyx9lYhU9zQXN6BznLmX1AdhwdIHoIJDcqXSZzdBzPZtxjpRF/NbQP +TtPZyZ7XmCKCcN+DV6EGhz2yy2Qgj/wQba1eWwkIgYaZNru6TBcIlxpMEDpueSYO7r/ywvvhOqe+ +pg6SNdjBun51NaW+j8d3luIy7rvU5ejm5pK3uri/nt7dnd9e//769MfL8z9+vHh7/kEvdbH91S/d +R/9+f3N79/df38d7XwSfZG09NGOlstXeqSb8d387P7388+nd7cW/5btBJe33lxdn59+fnV5eXP/0 +x9uLt//v+a+xummLfxNm9MPd7Sm637e7mIv9eHl5frcqVkenZ7/86/T2reZDXHiLjGG8fRUTLltE +lfKZXuyrBIpPPoUO4oyKyWqrVVewGH5eGB9/gbmKP7l7so+GNXTlNARrxVYGPRl8mTp/3I9j/uUl +K/gvlMhUJJMlVBM3XE1T58pZCYcCinbpAdrdSsS6UEMqaj/7lSU6WStqgmOWNAx4pZk6mVWqm6Q0 +Rav0LpXRV9Z1k9MlJtaXRVam0I+5uP3S9u0VeUfisnaLukrXF6gLCjFJf8UMx/zN//qn2JpfxcYo +Glbxi/hB5MpXKgHEF+lLLQoyHzvc1d81EntxfNB1Z8O4LlZ1FX91TSjYdhZu/LxMOVJXcch5Z6K9 +lv297H73w07vilhn/IlPu/ddkfjtWde/y5FIXfsuGOM/YjxGJ+qufmJWEvUc0QVjzAie4r0ZhpEs +6hOiN3gBGE3fCkiZE3jrlo+5sPmQyqcffRE2Ex+PUyfis979YvoPRtX1TTHAMXXi5GDcxVRNoaxr +Gmc6OJHIwtPKzHOa1zXiL3Kw8JVNd0+DxbMpgTw/tDE+vm27st1zUqczWMakS070KX3bFzKr1ELB +9owCKevG+wvZ+KDpOHad7gc0ZcJFiDTP7OBtSUJUuWrN3anxPqgyuoox855ntodVfENNVmW4bsEy +nZqnKq3oP3BVzIX5UNHK6dWWR2cbt3q0uFXcKVUjTXGveVtPAR7OFi4bCDThW3Xk6vdN8o9MO0eT +Kc/dO0lBHHdP9jh3/3Td6XYQLxmduYdobet3Ufb42D7Sm/XKntZUcaIiwTQdwXxwi6Xpi5tMvVRn +bbPka9N2fV+y1SJpNSn5+cPbLY3n5P5hC06ZMZSWf98T2PXE1a6GgEhEwA/4QN9gvYrA0cvhMHr0 +NEyiAvHT0DhTdr9gZx6+Y+Gm7QrndUPBmGho1pO8R7HjD7qwwOLBy99AbODfiMyF99Iay6uPmdaV +4mm+a2HdbjQ3YkZiGJN5yJyy60rAgcW2bU5ZZrZxNLcNsHpIEJjRkU+9WfIfHa//ccitFyZeo2kO +tQ9XBw1viqY/c9WEGhs9gQydpNM1VoNy954Q1nHR6lAiz2E8IkSihe7+oSMCjEcVcw/T57B/FUxd +qQ+ukOtKPdZHK+ihzWkfK+zipbPDY2Jhy0cbtAyzaYVA3OyoAC8vxAFSdykSvsirDX6UZUMevg6N +rcjVS78rQEyfMlL4+xrMPAN3de2Mr+Tzqw4EBaBvqnh7CW+CNlzaUYnEYMsxqC+gIYPa5+pA74Du +Cup7KBINNRWTEmtBD4nVv+HVrTLg+rer330vou/1T6vfHB19c3b28epvN3eUYTOsnhydeiKs6bkG +dnd977/pe7+mXCLCa3r6u/x59bu/3Nz97fzs5vatYP5/siNqOax4zwh0jz4YeL/YiVx//M2f/hj3 +yt/f3dxe6as4Stncb29+PH/zzZ/aN9KJ7+9+vTx/0zetXy2ctezwCA8Zuj6fjuPJlRLf3vxrgwsa +vkx1hGMGXBd81VJlZ6vS82ofA2+kOkyJsmcGTrtKKXD5UKihuanJMwf1mNjrJva6ia3TTTR1ZJFj +koiB9PXZmWZLRi7niysq/dKvIc9cqbNg5JlZ9vOzzOBOnIEjUWKafYMz7yGm2TVIpmju4WgRBmjC +mOfC1rivSBXU2WPINs9q5Wh2KxDAaQT4fIzzGna5Vq+TmFuZRqSYsDLBTnKYgVEzXgGswRbrQF1J +NhDjSCOoi6XANdxlna7wHfbjMf67kSkSArxS9tswZ+ID7Dc95xx9HqyS8J6LDQFtc74RYluNmG/4 +veOEeLho43j/9tnGbR4tbhPHlLOfn+l2Ka0REt/Atn2VgWSpdXkyUBlBvrtirANBrNILZTpQvvyl +a9Jl9SJOufwzGHnjrWE9DI0+AKumsDiEk+mo0unW95q3G1d6h7Dtyjf6cd6frh34Jg5B+eiaePG9 +fGTs4Ktspqagrsk1oIeljYgm5adIG5OuXQ2AXU8YhzuZpQG0G5sGzdkxcM1cMWxzPFtrOvVpokwB +GmGq1gcNg5XeQYSs6yeRZhatSnbON69EmvnDze3ewrq3sO6lmL0Us7ew7i2sewvr3sK6t7DuLax7 +C+tuWlgn9tSrg6nxtFhjYl1jiH1WG6vRmznutbGC67WPlXWIFCurRSbWScNHyxt+KgtrscbEmttT +izX21nttrMU6I+vUNJmbLqdF1sOe3sy6rvPMCJWZWdcMZl3Bz6OdqALurzR7W+uTaidOzt/d7W2t +e1vrXkux11Lsba17W+sT2lpxuQ+zGF0dlHoFoGYcFHnE0HSUYMnaekJWLEb4jkHJ2JoVXAPqq8/a +/9zGVYPAO4TCtlYJdG+sbNFmUDsnkwsNbasIYMON3Q8WbWheGhlXl7R5tLhNHEveC9P8mdntknc6 +QqNEk6ezxIUES6azkwyWTJmAVRMY7jls3FpQMnhmBXNQeS8oGdsyUOqsYhGDcMtBL/sP0s2Dqa+0 +55UtyWTcYmXep/Q+A/UdQG7axq2DDOaqWjN/4/bXwx4UKz6HVDHtHKWK6Sh6YD/YrA== + + + +FpgPw61sHazm7ebf7RuqjYVVYpEC5DWrBasD7BDPYGIsqGE8mrsp3+7+OnnvYiyF1H2IspeRNmL +KHsR5SlFFL08NMkRMUTGVrm00YEymSQVXAfqJRD6ezoVQNLrXD4ZNv6MQkrQAd0npCC9TuUeKdpY +TWMyW0qZNDr2AH280aeSUuheGdcuCik08Xib1o6vc6lAIT2XmiC9fEHfvREES175daBMoEkFh6Dy +PlDP2U6G0dkpUo25cBJBeXFzmHKwTGCDkVaTsRPSc94s5XyavWHja0FPLphMBpyiysZDzqC5EDId +dg/LRY586FmrQ9FlMvf3CiVfvDTwj/d7UWAvCuxFgb0osBcF9qLA04kCiQ0nt1/7FBhGEDIW2z5u +C754PUijOrxenO1LG1YxCszknyVBYQ0kNngy7cNTBoXx9p4Bjy0DU+4cidXXxISFR0o2SPzZPBAT +9liT05CwR5rE8WQHKes/jzjQBepomoxOIGhwiAhAFzBxbz0kcefrINUYwsi/uOwqDqwDdeUyUKq8 +SLxoBkoBaBloOppOLhi8SsFgKSIpa7tvaArqYpm6+ZhCumKsO69m2oN7gA8KCIJ53gjb80kCwniQ +VwNgFrI1HWgG64YWQ7sGkLUji9Fiwylf059P8bIqNJ8F7mNlYlcjfaXDdvMUFoxFy/GaZJa7OxmI +kKjVd7en1z+dbxQCBusvbvWAj3Q8iBphh5AJP4GKUB0G6+0KSXQ9LsRKgBLpUtND0b1OFRRdDamV +DnJ8QFCTgU4OWM72kEnNebvjTsXCqWyqvm9wMtR7zzsTauV2oDGrO26nrKoHD7xCOI3a4LpR01Ry +ZPBQ4DvcklSGRi8dEo7EHAZTViO+B2nz9fLAh0vD4xnp00exFAvbPtqkbTBG8p8fH4G2KX3gqdba +Eoenabz3Sa3m8APUx+vFBSKU6V1+OBSZh6hDBZe4IVlNy/tWEkiW20Vc8Lx6NwFKWdr0O71LpVPh +Dhnic44MruOHWKrqQcW42iJvs5j0qKug63SG913Lk8F2KZSyDZF4wnzfZN0MvAQxwQqEIrInQVCW +6QASRDsaH/CW90ylGroKsp0x6mXf7rjQuNa8yUmHJn2eDPZ4Ov77xMvepXjUbR6hk8FNhp/3VAr0 +jyf5Yz+Z0wmfLMtx3p1sAF+9WTMqAY5rnDQ67OOwi+MBjUc8XrvjrBt5Lybzdy8wF4Mrt17GTydP +XfPqKGSNL5GvXPayR0oFNUzEt+nlyeTze4lya6MEGlzrV13Ygpeq18S2Mat7YypeS2NwEVKT8/Rl +Gw4dAn2EqcftVAMZVNYF+SY0GurBsqHSq7uFHC5u8GiTBst4KeSI/n6iekzYNN5q7mKSfFkydxhj +i07S2/TyZPJ5ImB1rfDqkFnyrxIgPgsJqbJahx+vATx9TMKkw7JPsi52H3RdmhT5AkIRKr9+v3+u +C4+Ui7WfyMUKO+EMLttJDGzlAp5AzvkmHOJWO9cDlHeND0X3OpUtUDhViwc5oLInZVbTh5Nq8kbG +Pch6l3X7eDCIR1lToYG8aTyypk4YsPrhqDvc8oG7mk0j/Eptw5DDq2FJrTUCC7dtDmN8fSNA3rH1 +cOEA8jSJxVvW8tEmLQuxO2yaz82Wdutd0bgD9q4JLj6j7bjmeq1vAkQGyOqa67tUlCW7da7U7DJ4 +jnxo93ExrqrI2ykmvSiGvSyGgzgeDarjPXvUVjvWEBC5Tr1go2avmthue2gMLy5PEO1WfMBbXlqa +imvpHtMHfYptDb4d15Q3M+nEsJPDMRwfjMf0GHeZ96pjLftB5D3jXbF518BIdo8n+WM/Y6MpHXc3 +60LqsZxPU8iglkkrw04N+zQewWB8ozXqm+5aLmZABpxjld0Yme3Be3/ovwyj7IaNu70bZqoFiEmL +IkgQJxy2rs1Awp/xdi3EVFJ3Fmq9qIihtL6NOxV36ODGTfK93faCNQUhsd0WY78874wfbLtKBZx4 +D7heXt/3Tp+PDwY7EaBspydQMam3WNd6MeljMRlGMR1qwenA3Z5pOgrMmC+zeZ3ONBJnrLsScs2S +RBwZLooAN1gWSjkbLIyWW7g0g9GkxdH9vsnyqBC5wQKh4GZLNNpodeTQ2rFs1h7qVVRWA9qFRceJ +HUwHqRrNQFxDxyRVp2cwMul3wZcyH6lwoaWbVaq/A5wdNEIJvMlAwuK2uIe7qyUByCvF36n5VDp1 +bzyA48mQ5qeAgjGzRe9LhH7rIGUtQmvXcFJQm+FWR00FFR+KYEp/iFwCwtmVet9477rwWSSzbkKN +ZkG5woTSfNWBZM58nFDXwOknAXhExt/pXSqdCnfTF5+PgRG47q6DiHDiFCO0hvSM2tPvrulUuBjX +X/QNRGExQ5U4shpXtjOLXQQJwqXq9Z64BGDbTeqXvkulU+EMMWLDMvYAZ78ECTbNjdaQnjlvtptU +fZkKF+P6i76BCeh+HmPgD9E3fJU9jVvWSu1oYHo3/XDwdjWenH7i8PVkXiczPxkJik2mYDJJ/UDG +t+hWTXf2R/cJkaT1BkXhQ0scD0RtH3DbY0dMT7rP8JVtc0hX8PMkuoDVihJCvFvYlZ0SXJUwQopM +U6sCp4HQMFIZyRlBTdbDhcFzWdNEldHCFo82abFkjpDPntqCtj1dBtwqTpas0vufo9aIr9Pbk2mB +TG/UxBetqyurmqNGSyvkBLjR1z0usBb0LPqjvtGmjCxQ7GiOxP2n7F7pB7Cu+BegTeoSW7SfV430 +h9N/3txe3EXt0X8kGeNz3puNy8xxbXPh4FdVwdwgfGHN20QTCHJPDboJAAxqyF7WQvnhwApWrTpl +hhqqJtvqFZ+4k9R4deZsg+OV2prNyurz8UGCtMhho44dyHAEL0vZVLgNVMrKC14eTQudoh9uW019 +U7dTC9a3+4i1NE1XC6+ZTY3oNbNdL070jlrD68BjTwsOhpA4GN7Li2azEVM0rXnpaJyWgjPnqn7m +Ck4vDpOsv026i7f7StoVXg0Olrxdt8rGiQw/NVQEuC86Xu+ZvkJFSB3TL9R4MY87n8v4QkaWVhkJ +e7ztQQG2lFCxRe5px3bhV2eQeO+YpN3ohMi04QNnQ/qAjqPhMAhqhlSH3rLCq0ndeEIS5Fj9A0PZ +5l/VdIMigNfDCkBvNnbSaqvJDOU0N0b9kctQ0wsSyUsBwfRxPvWwr4PmP8QjLcp1pe6khwZWYZlt +b2VUKhM1MqkrHGGVyREO7DG7y098/ARXgntNcsRawDbjTltFa21Jr8aNqF8HKkLZVdN1lR6g0Pz1 +o+GIvcmHzFnx/axg3pomm7fJMh9PV/5+99Yn9hipMAe851X+upXHVcC87tV6qyLIdl33+j/OL+k2 +T7L77ROQXuxs2+g1STV9pQwkjtDSjzMgH++hXrIMilXy/1CTZMBiXKIYV4obgytFGyAsbrxOgO45 +lemLpGpTralN9oPdyCCjjye1jZobd2fa43dw4y6x39PfK82rilx/IPKyMYXtoshJ1NFOZ6Bi/Hkx +rlG+p3OJfB9wupFsREDRQfg1aVxfLFVddHWnhgt2pmBvALNcmGY1KZFqy6qdtD3u3XQA3McIeqid +UkjvXB1vuyo5CbLV4LHkUz79ILSA+hueGxmE90PHTIwJhuvdAzJIox45Rkk7W/o+UnVU1zod9rD0 +Tj0/RPyy/KFmf1nhujH6SpjxwMvjHawcx7zS3pHgQYUknLP6Q6rADYcBzo+DSqJm1jj4dMOnJ+WR +Q8oKRxf4wiKHtVUTtS6E6b4iRwdm3+Jwsz3k7MDwbDI9SOS8VpOUIgSvgXUYa6jnmA7XwVvRNYSQ +t5BpKxnx0cYF7wABx4NMzNlBB5KVqeoasWtxnEITqcUzYJ4sHQYgRDi9Ibwp2xZX14tgWgfemo5z +MvCG8FLq4XSY0lS8kB13d8v24xXhgaEnUAF5a3jxuPOe7cB3vtF24E5/CIdLTqLILxUK4WzhuQPC +jHvQ5dOqf5K9XmEsxwcZKATfqF+uzE0zBARK6oeqHpSNwImVxadBWvpVW4T3hYiGPi44rjLHcskE +kVcyzGhKvzjczg4UdlGE76XNQ9/YmlqgptULzuXkBkAmEG7HmIY2eLQDHHUlR1k3cHYgitZEUUyo +6wEhTjoLKQgt1MJ4weW00lSsrpWTfrIZsUnBFwRySuhpbY26xYM1sB0I3FRTtUwS6GAD7QFYmDLo +EkWQzALQqatE9qVXZiW1FCFCVwQt4QKeIB7htCDaWkf32LXSQWJHugpSTyfDOaMu/VnuiKd9eQtZ +hZur88gqmCdhFZyP2n1BARMC1EpyWgrTrRmUW9kLjIKJIFeqyesEKHsvCBxtWdvkLE6pXn0mHdlj +NqqoactAhhmmgxW/aBVQHVY2cO+JzN82OYw1MTgHgHYNQEsBIPUi/qWveTLgk5TpvNSytmZlV3IA +qqEhAk46QNN3M4DlhE/ZFNQVK1hzCGsg8CJn/iK9qkUnCgx7Q5tK6lL22aiXD6ttPt8mkeO1Fha/ +kiMZB4fHHtd8ya2p2y3cON/d/rgqVkeXH7l9TNKimrnbgrISOU/S46sO4uyhksqgF/fQ4ZkEuchA +BT+v+s87QKoRp2kCCUrq0R8rsIgwMogdSr/ODsbvuh7GwuMen80w7Dj32/gBAiGMh7sI/kVwKpkV +hwO3cis5vxHUA30JdL9syyq9BI/qhR7xog9Ko7jto5HeOpHFevPOJmq6mX36/Pq6qMU0EGOH02gf +m8apnlwGP3T6JC4O8FDIVGtdYHyPcHdI+pZAIowdktNBuuYWWJIAwrS1ZF2BSh1MKJ/RgFlWA5EM +Z0X6QUQyJVU5BLBk3Zfsn7vaEyj1INWQutj3/zgbyyzLIvSbGnbjPc2/wjY7vWRGuOxmTfyA0G8j +/yjupQdeMiOkCV6+JsghIEzTNCo62MbRcuhLsKzSbBWwZXpPCloVDSicnKmyy+pWz1LenwBZsYHV +0sVnmZcqcKqkbqiZekCcu+ODBCIbVDWrVAOEsCbNHX8d8+KMtm5CBypYuupLd4CshQwWu9HVo91M +3U8qOzzXEdUs75PICRbwQKawyiFZWxEGBZFeHBDrcOCVOZ7061hJVtW/SyQqFU7P+XR1oNiLVEeh +gSWuVm0hFYWbRVNPWr3KgKlr4673w9Jg69Gop/MymTyWm05yvgY6LkZeZ6OeTMlkAGPjYdNfqgB5 +pu4pDYQ5S4O2o8ES7uY9TNhuaGbprcuglk7rDC9rSB0JoIedkP3sGwsfaJvVkgCpqbODDgTBs/Ep +thrVIHTbUPBMbXUQyifaof6rrtN9VZOxzTkCjX+IeEMci6RGfxa83aB1tlbvcr2lpSM0mO6QTbeB +dMnILpFuS5+u+Y4wr8IW2GZjXfRP0cjzw2SoJED1ZmSDs48akUpDldXTAWJjZwcZrLvpo6uoTSqN +1FoEqCYqdqn7qOt1V9F4bJ8+3XLOCPWvdMLTgyZCrUUIDhYa61Kvp4wzriG1MPML2w== + + + UzF+ogO1CMNq1FqcUgSp6gxaJheqDqAzBXEq+ybGwfe1REBq6eygA4mUXkWfXa0FyW1Ll7WUADq5 +7E3/TexvX8toTJ8+s1CHIPBDc4nEB+QSgboDcW4l1DxVjsstXIlKvZhHg6w7CDatFeaiIUFSjKOm +zcf4+Q4AXZiL7mMRJPu0DUaVoLGeDBQbo5aqg3lqP1ZdVSL8VK0LfXMJAO1o7FIC9cOItYzH9emT +W4mMiavtOLnpASwJmAheyiRMOZrKCUXG/8mObjQOrqR31FUPaWPMiJB6KlwLhswFIJgqnDoAZhqT +4XqQgXgNOTvV0gFiQ1ydDgKF4aqrBOkSeDVSaigBoPmJnUmgfACsZTyiz0CJ4d/nEy2OD4UmOoOo +z4uvnMsljkIQzluQOpwxtYbPdzDEaNKvEErttqS62CgPHejz5XqIYGMrVJeasO4rA3UVeMGupg6S +2sNmTzAhYc4GLkasCapfUpquvQQ5O+h71X3V9byraTK+z0GBcYbWiQLrAyiwUz843hrjwfzfe+g5 +EVBrQwWLKVsKNQkEPb5VO2ZdtdRR8uSA+REhuukZ21h1+AmiLpy+r6IDdM2cHfQwg1uO3CrVovoW +9TdgQx3g7CD1pQN1/Y+VTMbzGZBZ5tDEYy7+RiqVIAeqwzFnLDzMc2JMoXFENJCxzK+oDvA0ZMmJ +GdqaemVq0i1sCm0MCsZJI2RI2U9MKySFY9zZST/MzqBum+QfD8cmoaQCaBKJYAT5GVwylOOACbhh +hjVNjNNGw4eFPhlrJAV1H8hS1OBVDVOOeHWKgyUG9wzx1lsR5l2oG2i2GCRIg6RnxhVeNkVW4NCp +Ej96a9F82PADKo6Pefi7Vo2FaVsz9IzwAAvJcN7O7g0dqtQdrmzp7oVZZC6PsoUxTmbNOQ2wrNMf +AOmGCWMEXD9ri5Q/TQwuYtadOqbfaUIkw8HqPmDQqxx4FYQ53WeurTSyyAtqyEzCuiK/RDSs1pRt +6oCr/xwcvRt/WNatpn/ERCTvC1+27bxm4TqHtQqVWiVEQrdrS9ZAIOc12L0NShnm9ZhqIvovC4ER +rj/49rEUQo/5dS1alqe5XrlpZA38TD+5pGFap1Z6EAEf1jPRjNXTCqF6DmazAm6MLbYmvXRaH9TQ +rwHM1JlXVNSX2Fw1vE6o7BCii1P9WCqqNT4JIJwCdXLLcbA84rlVMyCe4TFzBrJk1HVJJCjYVXn5 +tvLKtAzBoF2TCcRNEiSwOHmYWkCOOLLIFRzBsfFD9KhCb0k+hBJEhjEl67TY8XVkTzBEko+gLEyN +0gAgqcPxAakDuEIbnWISQwSNixSZztxm9AIhiHVLlGzbmn8pJ5SwawoBbWpcBAHFk5EDq0KpEMkG +7GlkwGpSaNoPa3p5IS+HbW1kNVtDVtPjK9lloBsia1cQ5GiSCfKN7DO/prxp4DPTNlBoGBBKyHVH +yr00aryRaYaxZF7boAAVsiXRpAkCgfQoa4rKrufhS1m69V6Jx9xuR1m8Vp0fvUg/jXxstEpP4y0K +DG7sy1ORJtdmyHZqbDROt6qtrjTJEg5m16jYxeOcno+GjnKaQAVuIKQz9JY7DK2hUwITLvErTfTo +mJtBL5jknXaFI/9LtYSFNoN2wkZFSVOrCyNcMAN0TnD8pugj5CeERk3rgpz0LKWvPToI7hmGdF7y +iu0lfE+Suc/AEgUnHDf4HcpeyByorAt9CfCM3oO1By4cw+wop62mFKQOwWpJsJtNpQ4Eg5nbmIhU +sLoBLV3Dg80Yp+6BsnVk4CW05hirNHZIkUAFVH8YdWswetJdoXQhaJYNo4oAkSoCdSwGqRVquuvL +kW5hXKZO0Ds4sbZrSluZt1LddoyTo1ak8ob+8zB+uTpJrWU7r+EjuquV8JuX7yuvN5OMyyGswbcI +qig95CAWm9dfYbVLmFjJtLQMVftkurF4YZ7kahKRlUpTvjTVGOZwV8M4VWXwZGGuvjq0ypA2wVFO +qWUPUgSjKhf7ybaqPaMuWbeYqdRBTF2qwLGy4kqlHAC810ItRG7Kdpb+OsziFHhzkBrV4C9Hry8a +tGv9hE6DqmuNSs+gWQ4LshRBeVjVhkhrdBKDVMgLsM5I1uhRIAgH/bPhV4YeiJ6evVpOLTk+BqAr +OaSIQs8zVZt05pVG7/CczuOmcktwZIn1NvD4N0IFTz0DMMGrIQ88T3wyIRWYAqdKC8FkEmrj6VAv +025UTetBhmW1ZCu3wk60miVGiEHNzDsyVwGCqN4pNiqNm4AO6cEXQolfTnNVghl1DWOvrAxoXdF1 +DR/p2WRd3ai3lnF2bVHZmSnPDPqmvMu8LustuG0FGsRpMeaTxZelq/M0zIer4U34smQEXmLqkWjV +hYeOSRUZCxz5soM19BSxEnq+c9fDyx1ijJofSV7kNOYtuUEoR8VntW5FfQvkYrg5Cb2oobClPsp7 +1VNRJ6KRGY6+fK3uVKdv4LfpS7qIgjkx0YDFWGcHb8lSt2zUODeH0eEPsEgEG8UhQNrK6FdOY0RK +hJnQ+1dp0zGdYlXFJWdrWcsooCqC5z+oSF15KmOGE7cxs+Hp83ioseiHsMsIMUImcFsLv62KNJkE +adf50Cs5WiTXEoJh4e0FrwI4q4FKV041BuCjrI9CPw7IH2iM9jinIYr5NkbhTgrXDhwfdKVVDdNF +4+uk42hBlRxkfdxTMafVIzUV2cpQ3LOlMesKCgGA0KtqOSrYjuZ2VyiEYCmUiDQBlG0ZPp3TWLYq +T0Eg4M1cNu6F+QzQdyYEKEx2QQy8bpvooV5VUWtZNTF2q1JfXZEeW3WmsHCdos94pc6xgOHo98hw +Y/UjaqDhxsyv9ZO6jSqHFuc1NiNTGpom+rLCtNWSGiA2nzpp+TQ6YDPcJmjOOOVhSr2xDgSCDu5y +2JCqWTjIt9EXXaRsuM2CYLQ0fCM1AnMwqxOypZrGEQAD4zHMFiW5DLoLltHYC49vUDJSnfEkbsxX +MFdgqT6e+NNSSd+CEvlQeyRxA5cfYmxbtOrYpgSLXsfNHHOte83ZpMEFQeTuQ2phgvBuUqVV2QR6 +YugIWidQV9b3lHY0EcFZsama5pAhV0c0FtSwL6pug9z7vLaPcEema5oyROWGd/cVBava0lNAUEbe +q4wys98oLgWp3Yh87CdzFwvX6AmIB9NICGf10jLKQLPRRh4e8ge2OBTYOF1ln9Cj2Pm4jwVLhCdQ +gx5OcEsHJYaIaNwgNyKu5aD4IM9QjiKwRm2qwgggagIXiqgagAw+1A7SjkaR+BgtATkRf1tovRyD +mXjw0/riKvAvDdOrw/2rZsxma0AO5AykYcPQ/gF642I8lBDAGhTElZpovDykRpMOe5Zu5Bovw/hZ +qneFmoFo0ZgCBRjUsULvxvO1MYfRViXDGyvmu5Q2Gw2xMWDXrLAzwtcjYqANNiqlVZ8Bq2DJUAMv +UtQK931ar45vjuSfvDlDMJnrzNW1Eg1ELEKluYLnnxBfOfKnhYUjgC0OUpYV2q8Lc8R59DCDwFTm +5fid1yz2vAfHgZgT0wRqlacFa4iIKQEB1EtHc7tL+SdgnqQsCJxvPp3LWL4yT6LQaBGaPzdx/BMR +i859PL+/pKVrTgx1oGNXB4KHFW3ZbYwTk4ON+TTST1Wst9GDgqCCpX1Xun9ODajMEGFNUg/EahAA +AcNX2f9k+JKGukVI3+dYfDKIe/dxo8bsmDxRpCpmvQhxQkQ6kjmVQy2KYMJQWwQC2klWRQpYsDF5 +ORDpQZ7dG1Eh8SG2Dk5a9rjLGGJofLQOjiz+gdKN0CbfBI2oH6ZVXNj00dKmWZrSmdpO4vb7x1Af +NnVNnSJSBpyBSvBG3QCZ9JqgJejEK6EXI9TGGTpm4dcTef5n+Tfc0+Tf0PCUPoNr+UQBKsiOMQpQ +UdAnBKjg4L8vQCV7tw9Q2dkAlX1sSsp692yxKZ+Y+G4forIPUdmlEJXaPhiiAlefUYQKQI8EqJhn +DFAxcwJU6NY0iE/JB/aZwlPKeENoeuhCVMz8EBWbRY1c5bA8RMVMQlSq1ThExZafKURFKxqEqFSr +SYiKmYSo2EFF47F9phAVG6c8PXQhKp8ao9KMY1SaSYwKw64HMSoiwA5jVGwziVER0CBGBbUMY1Sa +aYxK8wIxKja6RaeHLkal+pxBKuoVPYhR+WwRKsP4FLa0++EpKlbm4SmE5OEpTAezLeEp7EwenpIG +0IWn5CP6TOEpMYNIkR668JTqWcJTOOZheEo7CU9p14SntOPwFJ29bQ1PaU2ivvqQwlNq8xnDU5Bv +fVvCU5j7/VWEpxBlHg5PaWaEp9gZ4SmRa+jCU8woPKVuP1OACpJGfWqASh30oN/SCJVGYzZ4aceD +ESpVF+9h15RNESrNwxEqYV6zD0WoDEo+GKHycI/3ESovHaHSKKO2GxEqUmZ5gErjHg1QAa+yD1DZ +B6jsA1Q2C1CRqRkGqEDLmQeolG09DVApNwxQgXfVIEDFLA9QaUcBKu0kQKUNDweolJMAFbvlASpN +F6ASYswGLweFp75upsUxKoPyKUolrI1SCUlWrc3cxlOciklxKnov67QoQ1XC/FCVUXEGqzQpVuUz +eJDuY1Xuj1XB7vgssSo+XinYxapEnV4fq+I2iVUh3zCKVbHlJFalmcSquDWxKu0kViXMilUxj8eq +DObxBWJVbFR4GE3Xuz5kxIYUMhLyWBWWiYEf94eqwJ6noSo2D1WpYqhK2cxstw9VqWOoil0fXoNQ +FdyFsiZU5ZEex0iVeh+p8oyRKqUZxqqYR2NV/ChWxY9iVapJrIodxarUj8eq8OKUpwlVaR6PVEkc +17ZEqhgNVPEpUMVPQkZMm0JGTDsIVOkCP6ZFY5iKMFYxTCVSCIapCPnXMJU1Bde12YepuBim4tcV +ZJhKGVKYStMMwlQe6Ow4SAUH1T5I5XMGqTTtEwapQH05DFKhn+KjQSpmEqRSzQlSacMLBakMJnEb +glRMF67hzOwgFd+sL70wSOXRtu8PUpkUnRWkcl+/90EqzxqkAkXiKEgFzibDIBXzeJBKOQpSqdrl +QSq4buSpg1T84iAVPwhSyefrBYJURC5sYpBKjBapUuBGeDRGRdY1Rn2UZlo4xajI1osxKrXpYlTK +Nsao+HmtdiEqJoaorCvGAJWwNj7l4a6m+JRmH5+ybfEp6sdzX3xK9vZT4lOah+JTspf7+JRdjk+5 +D5VSfMpCZLo/PuU+dIrxKQsRah+fsjY+5W/ffz8IS/m8lw7pHakIJIAzO13KepA/TKjhvGccbMtV +hfIeHv4JcMZrNnGvX/9JM6yje47NqIWGIF4tyLQZWgeaHzSTAPHOQnSl+yb1tatkPB5sr/VY9cOf +T/7xp28Fo35zdnF7Jgts3/x29TUvwCmx6vIyW+gQsxBQejJq0IKPjKYKIOgEICEcgZyOcDyNWq0c +TEa0WdJ1pa312scWPkjRwxPDxAWCZdTgVCVMRMJN0TEfDZSGh1BdBzWLRVCBEB5kDQ== + + + OKHfjKHHNH1hKl4riBtWBV65gMfhEI4ng4KXPJeldtlAqc9u8q/gtwpuBb4RoVRR0vPqaLwJjeqj +IgR35IUmdlphCU1ODmy6jbfB7YFstTEVfbVbzRg56s7xpIMnz3E1GRbHrbzBJb6Gf+knBHClLm3b +denS9+ent2c/653SGkn02SkHlOwIg4Z8gZRPVwQFKMCpdKWiA0ZWOGGZaPeAvs1bxqtzbwP9oRaT +nxWuLJNj+ZI7QuQeuji3vlRvDPr+iDBV1ZUC4Jq1gusA7lCg479p0Di/lUW5hFTmna9IQZraUFqS +gZfUpLBNXj2Gay/hFt9EumT1WgaKQXJ2XTIWgRIQLliDYIabfcv4zIyKsM+AQraH3Hhn09m5JJZO +ok/a++NQPsb/sHSUxmcsHqJGJsuiwMULg3N/sjQAbrA4Umy6PALcZIGk2HSJAFy8SGtmCzXhwPgH +J54r8tWbfk2WrgVUbJaa3gC7NtcC3ozQADiUKRGahC+hbytpKvA2NAqE9yQ4UojXTYgfjqq8F/iO +5CV1/B/5pTQhCitPctl8CxnbEKFq2MBouVVP+wQyXjWiAFhgIZQlLY8BaDwa3Dxqw6Elhwozp8Mk +8OJYwxOeIixuaYeilkrByujJwCxdOIOgw8UttzAIwx0ILp/oGhUuLrmAwqusqusO4pHE1HIZhL8P +vBiz5oWdXsRB1ZA6zVKXLqvlNbmGiTFN64JGQHk6qPAW8YahcDIa7hFgZVsiRkyEA1UYy6Qg7+V4 +3lIAXoKTk5Lvrg4QwUflbAIJ9lTex8z5InJx2zSqtMZ9pkHvcsXsMOeo8N4ap1PzvlC9/lFzGsLO +rHnpMVdazundq3DdbRkZKbvJ19jeetEvvHXgwCFik4MW5PgAPjsa8OHgIgcOhKrnJjqkp4VIz7z2 +nL8SBNY16OPVm9wwdLnUy3AtfXKOYXZT/8IGUT41E8TEa3CMKq1l/0SX5eqwqksWsvTVo2pNY1TV +BREaK49ctLwPU+9fJ4Hk7erxrhOAGqfXa5YmKMvqaF4UJPTO9ksyXrXjyTo+fF8knENlSYxtZ2o0 +nvue96YV5sw3OAMa3PPeAlnggIDLcreQH7o7vV0VKxH5fv1tZIjiHa4zyVoJ1JBtrRISnKR4ePIu +6ZODuOeDOoGWBMHEaCve8isiQBVZ9JL+YsBZb0ipS8rAdVvjYc37NdVMG5t0qO/unABrxFfLtjY1 +Tm0oSz3c6aDBqasW2q+x1sviWmJ1Gi7ib+glEYksnDntmGU9CA+LwdWyP2lLcNBSQqXsSoeIFihJ +hLBCgVjFy58rYQQaEEoRCkWEj7HVEI6g7746gF9/q+GgjhrtEwE1FX0E+9upm8iDAFTq9Flel0Wj +Xd3CCs8Zdbg9Cr4ZluUYoASzMYwcvE4WXn+GYXZw6vFKBlTXDh/QwJtjfU1NN9YDohgXAlGmTaVX +8E7eF5NKimlDxbQ3xbTLxZqBFWvGX6yZpmLNbGazfdJHg8MvApEJV6jbG0bENPSfYXuaiFfOzprV +GgzDMYz5hPsmpQG1vJS4pPO0VaI6fjkoO6x3TctZ10YPsyO/NeR7MMav3qxpSmjkoDdCt/KuyuN4 +KKi1H6ly1uMvilElxbiRdfM96O7JwTC02zeR0QOhk1NfkEMICYKw25hFQrYdVLQ1XVsSpjFspo3M +wgmkKI3Hwa3xsO5gHNbTb9FpyB8NPU2I9kiYuY6p5GYcCPUa1nHVDJ1LCiSiD4zKrxni7jun/ZMD +OPGBDBX0si91D0GLQNPnCeS8WmOS+w8Q4EZVTF8Ngu005LNvjHpMXFGV9YnRSwg5kAVhJNLJdKZO +HlB2Y8jCaPFuwqKp4falTsdwKpzQTYQmNyDmHowa2D+PxCU14zVDU0UtMSJPBQvA5iqD/AOiaYVh +YfZj+K0hYmVd0TqoQiXYJhqBjs42bvVobquwKjVqx6qh1xqqte/jRdJJX67Obq7e33y8frv68PPp ++/PV1c3b/Jh/WC2+Bq9V0T3CbAWOcJsi6CbYrZr3EX6DWEwwXMTHCY5/9WYNlnMr93hOkXmC6QKd +4jpJwwTbo95+hO86DSOMXzOLJ/fr4xcsXaYeN8/DmT4xA9nnifr4qexjez//6B7iH+nPu4Z/rCL/ +OHr/KP/oOv6x3ZiBNGoybSEIgqkzjTWBDKSXvbQmPw/VTD4lb4gPMRK+NUgL1TqIonl+ns+UnWfA +QVq6uAw5SEsPowEHaSO3tJyDdOTZ4IB1LwfpPwcH6WdxkHlvlnCQo/EXa6apWDOb8zjItl3IQbqH +OEi3gIMctryUg3yIYRzWPI9hdI8yjG4ThnHclQcYxrocM4zYSBsxjIhkeSqGsW7Nwwyj2uPbppnF +OA6rW8Y42gnjmM/YZ2Yc4aqrLFy7lHHEviQL52fxjabnGzdo9Ghmoy/ONg6xezHbuBzHl7KNQ9S8 +h21ci+0Pso/japezj3YN+zjE/OdkH5czcxdnv5yDn/vb+dtNmDnY0xr1IIcVGsk7FVLEvwmcnsto +E+Q33cvpV+nX2cH43bhwVnH8CT/zAHiNMDSYMoATzmgYvCBBWQZ4awqPV9YlvwwIdTpBch/jHTOY +BK86t0p4hK6J+OO4H/ksptAYkjnbegTSgHcpK1iVSro2gBpM6FwNrEqXS6eHgtwgkQ3JtTX5yUS1 +WFeVUBjoMWXYnd+VM/kPZ0XGaTm+EDRMitrFlLgRVlHN3FiVdUgA/X+RoPpYqt+rzjtTBSD/Swkz +qIboMTWCY1qu1tAEYOgbYbhECMTCxJsaBzTTHZQV+VrE46Qm9K8me8zajv0adbOksWbY12LyTZHq +7PM72ojIKY2k/pcDtGqmea8ZOJRe8p2DmaikHE0HY3j+GdjzHPwleEug3hmKZ8esjIA0mkOHEMOY +fKvPRp8b1z1yqpkltmbeKJAizpnxQHQ6HTumoGKAduxxPgr+ZTifXemYj+PYN1EQOhvPi4cnTU3M +D0zbGa3JSyYOmW4XTt1Xb6aTdy/swSlFdx+e1El2yTbjKPd0cxbdRBSlshE8p5EXjIHFJWVbY9bY +Y3zQRLEkm+mhIF8lZNEpb1Y3ypuN0t16V9Lk34q03fCHCRUzaQkrqkRSmDSgRYlAeMSllAiNQrjS +nmzuyeaebH5+stkMBHFsCfBEIn+Elm5ECZTdcgUmH5obdJD6MF/x4wQ4E0HZaPRwhCA9IIQGeOEg +cIRZcxiUHA6ZBRISoCY+K+hsE1ow/cwjgDqqVS948FHjkxypFgH4Px1UcjAAiazjt7F6jxwMyW1r +mNih0uRzDh6wDpmcaPXUrMCag8nFeMk4EagknSODuXooUAGk1clcgyMtKot7JhH1BO+2Nayp8yLq +UTeGdOIIhqxAEozKx0g2yOBfq9deBltH/xQRwWsksONVUkgBDR+hNUWtrzR1ncjhyFugF91s2OjR +zEZlcWGLh/RuGdK5ICBhDV72wEWYCcF2MW5+9WYpdirlmYufOpalGBrd9hbi6Gj3mwHTNFiDdNZq +0kk9FRt1bmxADeEFCX0r5oSejQZHfFnzJIJsJAd6S4dIaqys/Pa+GYDwlUeipKZmRqIWSU+k6joC +kA3XMaeCi7l0oUm2eiNs0Mzm7WGXupRJn5hmhaHLQVM2MjcLPawAokr7BKAYhY2vHLW2rfrQ0e1P +2TLmr66pVjbpObJzvFRUNjCipclXtHBP45W+mHRXgnA3jJ3m2VgazdDMpGQnB3SCDeA9gldLCaLb +eEbQPfCEvAhcC8mLNMqLaB5cQHAGAWIZ3Y3+2AA8rEu6543Zk/TrXjWhr+mXI5W1TPheB1kahlS1 +5ToSBQyreabCc4cJUBwC43iTFmJ0Ve3mNHVZQN4jJoH8gTlBRWjWTRlgCFxbtKpxSTOSsAm55I45 +Otu41aO5rTpkB0XCJxN4GdiARplhUtk1zEfaMuq7vHDTgApMtg02+WTjALh86whjssnm+erNmu1D +4HgDCXD+FlJeZskmYonRNhLYeCOR/xpuJYDGm4mw0XYCbOaG6ld7bNlo7H0kdczQMQkxnTnreGMC +nyv4t+ptAXyG9TSQxWPKGGwITlrJGPm6Qmo6qIC5/E/FyI8gD1KRUnYVBETDzHhwdUVGzXU6OCJG +iRwGsk+RGdbJgcbQ9kCPbF7e0xiIlQZ5UptWM88iiQwifXhpO3BnXKy2tAxKsQoBRCVzMG7S2tGc +1gJzfDJ/i0VCnmVkY4oWCluEGLybYylqPKmoMtgTbtmeGNaFTCCV6keYcsTDRIQrNxt6yD8Nzt+D +4c4SwysL9QA0ILXmIAb9LGmLmShM5MhiylH64cVYhMqAp0MMAo0xZI6Zdo3R8q6VUepJKQSqJTlt +GFiyrmjVxMRkFvxv8/+z9975qSRJA+BegDsggwDhyleBJIQHSciCvMVJQlhhuqfnj/3tBfY4e429 +xl5j05T3Bbxp9Wu++eYNqsqKzIyMDJcRGZj6SHgnBLqMEjC3pBjtb+yVxUwWXVIIL3wXJaWLXqGQ +FfAlqRQ+d1fTvGsi11ON97VeGRFrCJZZ5SFQvdEEtKAt/eb+DIhjYW0DCl3WQUC3BidedgHDKkh4 +UW1V9YjFN0/By6RRUS3xK3jxNW6A/wY6uv4RPKPWfRUzwI0ZOofXFWtHWNUP2XI3JfFuIpMkDObx +JwkUZYMSRY2yQk6bp3kcQgSLrqG7H8Q3HDJtaTw+pMGBEZNKwj78Fp4vwxQTh2/BdmSAxadN1/fY +b857vxS6gxbon8pemsObh9GhqEIAMXTLL4+vQEdxulX1MwZfWhzjYEo8j6uiEBQMxlSWXHyS9xke +gdXTf4dAozYiaOWB2H/ehwZpSwM/n2z1mLbWc5L47gl09QSBcgHt6BVmNTOOZMMjp4iWWiF0xy+B +DEIsXkusXjrNee6UgjlRNCl40nSMlAyfGWlZ89QTNQdeTeg58LoQRYPP9DQNHulpBjwy0rX6oWvK +hnEUBtqGqFiIujEO9WM1UrhW7rGkqkSbSjxBixXeEg0j8QZwr8vdiXubUfCJLrHnSHzRPrpGSjNd +3riReXn/6b6KGeDGtH0z6IoC9eiqPu1ftj5ZWKkduuDgHTIUzMOE6rLVRsZXZhIEutMX3qun2xwk +IeB9KFDIm0dT6s2M80vRNQX237Icrkeg2s0L9Jzz3jOZBEIPqrDKllatESfuWP0TJC7w0ohPoF8l +iYub0cCi8isrBkU9w2Fh8cMISD1EDsfr6aYR08/TgJz8aokNXZQpOK44vJwCViDQ0hq6/5WjHL+G +zB4WbdRSm8eucwt1DdPzgQhxjsRbRN2mllO3Sb26zQkGvYUTdNwdCRgVd+cEg96ieiTpLaqvYga4 +MUPnkt5C6lUt0p26HYOOQ4FEAfH46iwSZj/a6S8xYCYyLLpuAekENKddUah+0NASpGmlyofqa+g1 +ZCjHrwUKu0a1V2R57Tu3SN9QZyd4jtfq3cqKcRLj4/FfWEcW61b6JTUB3QgEL1FHyg== + + + BIMiUEnkVs37NPoFNHCrPo0OAg1TjZYiEREvyH9riEhQsTx0Q470KGaAGzN0nhfNBfUYJfVXPREE +nBXwNDX4cOB1NLwQlpVJDFjuSRsSww5jAl9GTTMmTINXsRweGu46bsfAemi049fwojTx5HGJvnML +9Q0z2WHdIg+nnloCFHVbmQSxWuuFCJH6qidD9UPXhKgZnESKUL1ciBglfV9LjpK26pYgdeFgvJXL +EUMlDfa0YGJPCwYLRDBYIBIOVPa0+pFoT3N664NTgVYeaO1pWyb/8+WSHtO/wp7WsnRsoIJxubCn +Lb90tqedOrW2p62+XMKeJk3saS0ta556omaR52jpWbSnvVK0aE+TRnuaNNrTWrpWP3RN2Roepben +PVO3ZE+TJvY06WRPL6jYsvDP17PR8GLSHc66w49YDD9G6q76he9sDN8I+M1Ffw7+PW9+dVozH75g +0p+bzKef/tPGsPHRmQDVuN2ZhO3f+fHLfKPf74KdOv7stsSW9dGonwAq9ngW95//0QC/jU2BGgBA +qNuztu1NmiIQpX5j5tieRu2vYHqHti0CYfIBb/WBsS2eCMkavwALej68aMw+NaDzn41Ja6RMErRC +IEya1jv/mfkL3T+6AOH2QOsIRGPcmQC2WZtNRr0OGFgcrzkgEs2Kr5hyLBADKESNFPgnxBL8f4LA +/0V/iSHIdqNdqHOF/FDXFPwP50dFLnC35C/pltZNmQb/kSas+s/K+8WohrsBdcv6WUliJn91pzKO +Yack6hDwQj+NkUz+gn55HZJ5P+8VyavcAWZ7EoxL2umIGBN+SavBbUBzP5XwS/+BmEr4EbrIOCVr +NouizmJEdQ2H0I2LIsyH88sGo+JuViiCtyb4OWVcMOKG5DkYQwTzI9FtTDAuk0f8D5oNaNSE21F7 +poIkfiNdxTz1JU6Goz+H6A8gs5FcD/sTZ2Aa/qgvkQXy/I+O9DaRF3MMS90+mBlsD2ikO/TjBvgp +1nQTYpMoUBYSN91pt9lHAI0QarNGq7cUBK9jyDWm3ZbyOV5kTFL+8/f3aQcINNL6e/GDo35/ji7D +GE3ijfEYIA0vDvioI6IvpAHqrwJU+ovv72DtQOt6d4bAUaif/vlEbAwGaHdLd+hoOO3C1E75LrtC +dzruN/7Cf8KUzwSGJK4amMiVDxAbT5CokpYAE//QVQ48I3CanD5BSuWDuX0CqoRG0jAB8C5r7l4E +DYwORhKr8YlC592/5/f5Q6rhhDEy8Q0l+DlGjjSrqG/Pj+bv3/MBjDYmM5MVy/U7w7aHBbfDZwIB +U3DlzomqTE753GLwNvPIj4bteXfmZg5qKCvfAZD+VoRO+fqZ62mn+EdneN5uI5KEXShI9nTbi1hg +QpXqZVprAtnYsC4L8lChi/dgkB4Ni9dSnEW5CWUd5QH+5jT4+0zJlyj+p9OawyGgF+hbM3kG72/j +1kLtNxNqbvnHWhithdHKhZGZBMInQyQ8BEGHjxwPixzCWhP4tue1BPobJRD1t0sgfi2BfjMJdLXk +LcwWRpUJVa5NqrUU+9+bVJ7vMl8LtH/4lDwJNGEt0H5DgcYJtICy6yjwvyz0ASYFlsZ3v7IMvEsB +3hAgerBZfHcNAfNGYME5az8htXYUrqXaj5BqSQFfpcdQPLpjkoWVblAUCsyhTq49hf9ysZZci7Xf +TKytPYVrafTTPIWEKF7WwubfLGxg+ORa2KyFzVrYrIXNrxI2bnIP1kLnfzclQ9LD3yB26J8tdv51 +QgM63iiegGVz0Q156LyI5BmG0cTn8TzFMrimNEEjTxwPo/nYn3WUtCDH/l34LSngS8cJWAYE3TWJ +OS/LmhTv8sh4fx8e7IldMWt29ePY1VLV49bs6sewK/HOBIIWaHjsg7gVvHKUY8yu71jzKzf8il3z +qx/Hr9bq1e/BryT1Ct7vTyrqFc2jon9rfrUIv/rhwfH/On71U3yI/1xWozB1yx/4P6jskie+tOYm +Dtzkhwc6/+u4ydpa+xEsadVxTCQOzwWsLCmg2nYsn2QIXBKUEJIrSHn8l/KvdVzrmgO644Dr9Pf1 +0e4PkwZJBqchUTwPLxZEN/EmKdbkcsr1me8/fEqehNo6qvV3E2o/xUnwD9s1a2n0a/PfKYGmGVQG +Ft4nLwDFCpXBY9ahrv/u/HeO+NkS6F8nP9ZuoX8m63UyBGhsB5A8LDkGS3tQJHYKMRTDrUOQFuRe +60D9343/rfXntf78A/VnmkryMLfeH+M5IHNhUEOcJxjapLrwWn/+N+nP1FoC/WYSaH0s8SP4yVqQ +/eJjCVQqhmQYBl0dQ8IyM8geIQV+eXvkd6HC32dKnqTaD89EW0u1tV21Fkf/HHFkc9uGGCdOCeub +eP/lltQPTydcy5wfY0mtr+JdC66fY0eB93GGAdSM7SeOorj1XR7/cvvph6earmXZ2n5ai6F/jhiy +sp/iFEcABcsv3Q/AcizNrg2pf7kh9cMz/dbCZy181sLnHy98YFAEsOA51i878dhkcp3R8i8XPj88 +TfNfJzqgD05geUKAx7wcK/AkjD/lCIJHvjdO4ClU7JqAV+rAJ6RSPIThiR9XZPhfFFJsWvwJxxFz +AoGj0fC1YBTDEMv7nH4fJuyJY61z8H5HnsexLMlw6GIxHtZKN7tyhoYF1ZOYL+IK6wIqArgumLTW +u/9+9u909kCSOLMvyTCkAH8xBMsyOKmETDLcOjT53y3Y+B+e2rcWbIsdqDM0kYRCK8kKHI9+kALL +QK2eYGgsxniBoUn4g4S6PKVo9WvBthZsP12wceJNonSSS6IbtBiBpAjUSVxgSHJd4fZfLtfWSZ+/ +m1xbn2+sxdGPcrPh8w2GBko0Ol1nqThBEcCiilNkklpbVv/uQw5+nfS5lkBrCbSWQL9QAjEcPOgh +BYJMonIKnBAnkwI8oEsSawH09wog8u+vFcivMzTXImgtgtYi6JeLIILkeBouHcXHGV4gUdFEYn26 +tBZBPzxhcy1A1vWJ/g62SVOIbbKUIKDYWIaD96ygunUwDI9Zx2ktxm7WOXW/G8NCsakUT6Pkb4Zg +oJ4RhzngKChLCtNCieHACoYij8cRWz8sJvUftuvWGvP/IjyLW1+x9YP1579fnP3w6p5rcba+7uQf +tPXWMu1/dIk9jMwSGBZQMow9ZglGijgm6RVcY/+7UOHvMyVPMu2HZ57/KyXSOvnvH8mKbZL/eIFk +oWcJ5/4Bo4JY1w9ZkGH90mxlU3ZzBWH686PJsDOZrord6IDKLMZ2LQD/ueo0AO1C8ppPrbbgytmu +yO5cf++RT/4it/jvy50WxM+ao2g5ymTS+MtfGU26/x0NZ2BbPYV4yj+ePYX/UTrRenP+2zcnljr1 +SWM4fR9NBqsSUSqA7sSTjJ+Z9OVFYwbGMESSipCE12D0R+fm9WImPcXfTDrvfaBt32kfNobt0aD7 +345Z03v4kPEnjoCeFRp3hxej7nAGnyXFZ8P5ID8adzuoI55S919R9S+K1NGsMeu8XgHJ2sADJgn5 +5bTV6MMxdyatDu5DHgx6Ve0OO6bgCp2PSQe/InXASo0WwL5ZRxV1R6TulfLZ72eMu2LbZYDQoZpt +l0VlW8W1a93BuC9zbS/qPNbjcR8KYPgdujHJQmsXjQAwE0CC1kM/GgJtz1/uj/70s0DQrMXMWsz8 +48SMQsP2cqYwGY1rn4326M94o2suYNSgXBtAiLM3+0OEEyLOsxJ/HI0bLfhMftDszyfmpr3JxSL6 +H/g/dw2vfgAF0x+t/kRk4GjMH7O/xv9itn3RHfb8uc4fnf6/2IBn/1cG/C/CpOgdBWrd56rwqAHp +jQt8DWdoR/EyC3ifzkSlUFT1+t2Byz33d7gYFa7DsTSBjxypJK/mQjCXXvT0cjzDLseSfs5Zzi9J +CLScx1p3WR+VIr0e2mmNiVqxjxMUvGrMT9Is3HQ0zBfm2dXfiYoZYmn+3//+5T9tTHurYp+lDmCc +EN/uWCcpW5pXthLon62Q/EJKX8vBH7uVoY3OoF1MWRrqCxlCv8/GcKWpY6tt7ZxYC/ifoh3/Qit9 +MTkOnRt+aZ8s6QXRwHJpRspSvN2Y9NROhtZ0gpwgVJzkpDZ/dCaSJxkjftzoIs9ETN3qczT5r8U6 +UCwDgx8pgcPBkHgF4F+9xRE/1blH7Fw6HDCC9F6dNctWsexH8LQx78+e7X3g3nYUCkWCkUcsWvUk +h+4w5IUkvLJUnqmXCFhzJ3kge5R8LQ7b2ckMjXYKn7DwyevZaHgxAa27w49YDD/OdcD+uWj0O7NZ +B3HYi6abcYYer8CHSAkDmHwOo8W6+69P/9x30fKGp9DtZ3fWEb9zRlcDEiCQdfqOkgzH0jCyOEnz +JE1rXADid1flnP+q05a+TNLJpOaS5CTNUDBdQT1E5cv7Th86WvHHHMvzpNbNIOfuqD9C5yDiNyxP +JBle3SFJMyzFaL8l5W/zfzWkTwWBRl4NnidIeDuTEa14OcQvc/25hFAa/B8pIDwSdJIyXQj1p6eN +D6AMNsSvSZ7iMVIZMimgdWFZ/IPgOAGhj2c5zNeUQDqeY3gR5AEMAC8f0El/7oBhjYtG0ni5BQFe +8YFeMRSPLniXrvGEoeLoYk+GBJBFsBTNA7CUAMDSnB4szwHMJhFYwHm1a8ywAB7MTZFHqwELHpUP +koQpWJZkSQrfPkoySc0yJDl4jTZsg+cOwCIsyGDhaEnwL4BL6OHSPMPyEJxAJjlNHlg8Kd1qyiXx +rShxigYooyW4LBwuHH7ugE1KcHmKpjSjE1ieZSgtXOgUQzQP/0+5NlWCS0Hs0gi9tAgXQCU0g4PY +5ThtRxi5Ai8KOS1UEq0ZoHgVVJbidQxC4JIYlwrimSSBk0lF5FI4n0CkMIaASEjCwXISWEC4up0i +sGATaUZLUZAIIFyJxCiMZQyXRWsmANvngGekjUhzKH0BzItG+BOSJMXhLZyk0cVpkAYkgc/DdAcR +HBokA1eKk1ZK4GkBDZIGuwAODXTPIzcmRRO0gBMBGYLH+RUwD1Dg1NAIiElW2lU8w9Eo/0JxivIs +z2imTErLLU8Z7wcMFDA/acYkKYOFiEQzBIwEZSQyNMVyKg4LR8nhW+TBD8MoObj3SZaX4BECj6gG +rBvBmzIzoFXBSaMZIAxCWgMdsCJYBlM9HCdFSdsU0B4FA/PBNmUw+k2YZJxh4P6BCKDBKrHqcZI0 +HKcgiPCS4Ce+fIgEa8uYj1NiqmQSrA6vrL04Tg7AZdD0GWmYSY4kKCTPYAVwgcZf0xyBUCKnx0gb +iMaAxQ2E9g9kTmBIEjppjkYyJAlYNWF+6T+jMGWYpoNYlbh3CLjRwcLBIbLylgSEhCCyLMGaQlTY +nMRGWbxk0pbkJaZPMtKWpEG/uFhSHFA3i3Y0ARCAFxrsO3H70GIcNobECgASnHJSgkMSgEFwmOmi +4G4gm2geLzhkWXCXIh6pRqN4F7TIhygJj0kDM06SSQYvCkArr2XGskjCvB30LJ0oyA== + + + EolGq0OREs/kALuj0IwpAtEdUDoIVkNNsmTmcE4U+CHLziQidAFtIGn+DA14j4BomQOsHv5IAp6J +hTKTRN1B9LAiF2JwpQcJn1Acw6xMuMelPQlLKKL1YCF/Q5uIZzAzoeCykTKjgMsoig5aLTjhHcVA +cMIVFySogCIYEo4EEDdiDQQgZg4zEA4pEbTMKMV1ojCrxzAFOFS0yzmJNClWoEg0ZYIDvBgONCkg +HBAkICRBLSQ4ODzYC0OplgnKCYAAlkO7SOLENEuKSWxAwRLzBHge7UgabwZOnD6DGZFcSUOEysGt +TiLRJlAS0CTHot0M2rEIOp/k0aABTdBoGpJkoyU5L8oktWRDgk1mn+BLvB5wMwkc5k8cz2AgAmLu +jFTbg5IoitSuFaRUpDTISg4D2CHi6VySBlqfH+s7SVE/kcSuuEnBvlIQmoQzx+iUsMkA7Z3Aihi8 +uR2OEfAUtGeBbo7XWRyhfFs7gRkzhomwSSN+jHeSIVGrNnqf+ZEh4L/pfgyhMRMWG1i5Lk2/EYED +iKVGu+OfjfzYHHGCpW2tQDH1qtrA0bdXIJmFUNkA0jU3RRq0C/woQK/vHrDpRxB8qPY9b0w6U392 ++NEHZpUGDP7Powrms39s+ASRC1x8zKegmXmRPaufnxX9gIey/jwE+h+f/qH0Ge5MeQvAGL5Az6QP +KA4RNvgfFUizbuRewFblOFIjVnlAuVpBKyDxgrQU8aiZxrc3SPKGRnovlLKAqUiygeAIErEHoEkK +lLmxnBQZJC/yCUGlrQFGgPRepAaRKriyfgv0NiQoWMCztCMGli8hmxwE5mto6JL+zyAJiQQ4YK8S +aIanKBoD4hnGXNlgJUEhYLYL5bRaNaChTKNINGqw5KS8ONge0SwoYAiGtUHPJNU0yaMeKAFIFiuV +T1bHBUU1laBRSXmpSbjlGn+h+JaLD7e+CKw7QqEvK2Qcg/VQngSKMxJ/HAeUeDQAoEuzSKqIl3vo +f4johwtLQZYqa7c8UEtwJhtD0wSWpgyBRTWwa5A2Qsn/FQ0YqCazENGstIAcGABaNxbYbojvguUC +zBlxeRJbc7Q0Jv0PDJVHwoNHtCxBBfo6UpVZisQbgQHWFhoTELck1lHk/6o1T/gvlMOSyASjQevI +AJUGERpQIMDuQKqNKO+lQel/iGApJN6RYwD8K9Etx+L7KAgeSXcaSEgOkwnACCMqTJxa9cJ6Ektr +VC+aAXQmIIUF7F5klLEkqzaFgHkj3dui+yHC5bFKh3YWLwlMCrqikBXOc3wS+1BI3IHCZOT/ikRC +4D0KVQ7wr6Qck0ArQN8JbBL7EgSgfWn1WGlk+h8SXyGQ8Q+JmlK8FayA2xIMRWCNC9hvWodAUuRS +2v+VXCBI6WYotO8pacvddpr+/Kg/giJwNB/Lmw/WMiOxv4NjBHPri5JuFZCNTw2n4WjZ+qQU24YH +mpgWrxxeUsVakpRRXtJ0KbFEmkhh2HpAeimv57ksRWENHJh2LK9xJlo6h1jWxjmUFJUwgQAEQWnh +AZMV8Db4Q23FY3gUnDdtGJ+nOCllcBTaB7ys2Up2KmAZAs6iBTtC69zkscopEq3aa0UKSYVySQzz +Iic7rSXftOKtVruxfWdj7PBGbySXd7U7nam9+HZR7vIBrSam0hhcbpvgZHC6oxE4+t1NZkIS+FXt +r0Fz1Idg/g9fqDIaAK0yVOn0x+B/co1pr4MGDnTF1mcYqp9/gFFBzTN0VavBJvM+wJo/5r/qfnzO +1A8Koz+H6r+rnXfN++ux+q8c0I7/bEza6mel0UR8dD5pgr/PJ43hB+y6NgOqq+rv3Hw2Gw0BMRmf +Uepn9UZT2wg+0LTAHWE/Nph++6ODPoDrJT/QfIAf0eCR6HIHg+u2eh04PuTzlwYLZXxYxDtYKTXW +rVdPpLbCqDUfABIqNGYNX+A1If3tT6G/VOdc8O+70+rZqN0xfbnnD/1n0B+C17HGbDbpNucznOQC +mmKq+1+AWAF8VavWZ7ffngDcozZSbI30Fv4z+2vcwW9DO8Pp6x+NyXRPldyvbvpHA649bgufTy3a +wXRx3EwcyVTz1z8UO8PRsOMCMf0RoPC2G8xILaN/77ya3WEbDJR0MTdAHLXO7AxNwnl+6tYrWv4l +MUHaYsLV/LuNZr/jhvAdV/WftNFTf7je6rDp30zRcHqt+XQ2Gvy9nOzX0WFq2oBxEFDmgS3mlhx/ ++b6owZtrfsxQfoddOn3/8wdL4795G0z73dY/nRfHBFIJDbNcXldL+3fzXTgVzmkqf7mZyl9/91RI +jhZop6n82W2jsHbH6YgN/wFT+uwgS9XFnKSWf/OkpOhPqwk1R8DSHUDz+nzSBdaim6kZv/kBIh/x +utpoPml1cjAIeiVs7x9tkBEmb9UYmzUmH50Z0AOgy2B6VHCz9MZv/mZV9uKsTDGl0WTQsNqV6im/ +d/sd28aayapb/+PNc8KJE7yjQGh3lrnS9u9dfsdJdYdgnP1Gy9201K1/ON9Gl+2MGwBcy5XGoG3/ +N2/arRL6PxcbdgCvEkJHLW4mqW79wwlzODr1NDVt+x8gb50Z7//MpNUKpb97NKPxrDvo/hdlFvyU +MQEr+e8ewqAza7Qbs8ay40guOY6ttnj+4WbXqRqjj/FJIUH4pR8qILWb8utNt/NnbvSfu3ux/eNp +p92dD/xXnemoPxdzUOQvskck6ZePYwCtzMf+Uh9uc3imdzHpwNRgxT3MsSzNirPPHiX9jcmsOWpM +2v4WOoom/U15ljL7QV1Ik/B3wSgasw5o2EEubdvGveGo1RvNZ/4PfMaNiEDJQYMjOO1MP/1XjSmQ +miLBq2aKv2AphhKsB035P9DJl7u2ssZBE5pxnM9nYzBQ+5FQKshqaQhG0G37p+J1cy5GoaDZcUVU +k3NsK0+O1KwHIoPJHx1/vfOfmb/Y7s4azW6/OxOlOMnIMI3EVG0MP+aNj47/YjSWllAvBnkJL+1x +N46bSCDByCY6EhmgSww0jxr97lT3aDoeiTuGlv0d40a7Le+r7JE/O5+N5BUzkm3SP26MwS6Ydgfz +fkNZRXndc/1Opw1t0Btlc5OW+NVaRPnJaJyddBo4xdkgM0NKLCCp3/B+mjL+IuJh9JmOJYiTlXuD +HWh8DeJgpVXLN4Z/NKY1GR1qQiD87zJnAJuy3x12/FOUWDy1bzyW6Gf0R2cyhgfEU+0qQ2SJXAcO ++nLegNTlr+JLm/QMwmwcM0CZuCWvULim5QStc+yPDrzF0N9s9BvDlsMkW/3uGKwd9OL/B+yND0AB +4sBDJBMHy6FipL3sUWne70t4vOlMplD4ziaGLmqlW38eQq6P/FmRQsz3hf5vQgukUj+t+q+nHf/R +AG6w7BQFIUBWOWzriVFurzQRw4dq8LpIiSR4HlbNcv5KL+nMm+Jx4Ysl5F1n1lDRUczQwBjHI33g +r42BqTSZAnTPuq1GX09Wlh8osSkG+jJ+A3Ccr9W0+9cUNkoiVZvrpB3Yo2GrP28DfXoAKUbPwMy+ +KI9geQCYYw/YUbPfcTEkPN3iYDz7K9/p96eWhCF/Ui/cQl9oReU8tOsBLfJpY1yXFSDKRevqqKXi +qPoV1++W0fgvA23rECUi0393emEOU9ceJStjTPpPcbK3oV91m+th9z+mHasb3XaH7dGfUx21q1p0 +1XJTP8KkBm+1xh9wa8GEfQXCaAgpxa/hz66+8cPl8RPiAhGeviLNltXpI0ocn9tJ4a9oUVHx9BEj +jo/x9BW70FfcQl/x4lfeUCjo6MiGIswJSodG6J12oifC3Sd4gOZLbP/NE0FI9CR4/I4yx73jd/SC +31nQleN3rH7dLBFvynUUiV6bN99H/XZnInkS4dNpWC92dY1V5pqWOxTmYzASaHwpY8l1PgFVqfw5 +uClqINKbVjjvmfJ13Tu1DaB6r+Ocxf+MR5MZVIPU0lWlWufQIY9KuTYoSBonU63TrzRmoG8oXPpw +elOVvmvR9gj6W48K6pbq13UYpwB7NRsfChlVDU/7tj4aq97J58fl/ggon1ed8bw/lQXgHnwrX+6h +m6j+7g9FwQH2PtI5jLIXvCkOWyMTCxu8gWbc+VDRy9Tv0DUzCHdQcxAtKAUoMAVbXWXcpPKmBLSp +utF5DEECM+ukMxmaDQTo1rL6qR77oAnQizR2044AsU8xaRm2UNI/HCmGhr87RBr8aNqVunH2iFB+ +YBzaeEHU9gJqi9T5vGgoXKkNBbU1gpriSSVusBmS05ghas8Gbi3FXvsbQEvGrg6dS0HjhsAfwdQ4 +aFmgj5DJrv/IjVOoeFFziwPc2BoJxrbnotlWU5uPalzhZjbI0s4bN3eeuBbF+CtnHDvsRjl83n/b +aSZuuu3OKHE6AppeByIVKI5gH3Yk3CYUR3miNerDcgIAspFlq9tNZ/14G3eBiFoWCPbg4Wdie8Wj +6OabcXsAXveHrgc1brsGjmP+5C9I+XoldcPxeBJHwi7eh0H3rlrORqJ3ieV5+5YTxbARCNK+LY4z +0LF3zRrCtn+OxIpw9s0+dc0MOP0aNQFOp92PYcPoNNQ3REvbFOMM7CCihiN4kuyiXWPa7M4GjbF9 +U9xmotsnZq1b/Um8NRrCq8CgS85mqLClzLeb6KoiPH/etPWkHQc2PLxzx2EAoOE7YE3SNWNIFJu2 +QkLC6OUz9PoHPKAdxz9dtvvDemzjj0Ev3hlCHcPdDkIf4C2krKebb8CizeAFb+JY4hRrSvewKdjU +kDerAqIshz4GW6Q7fB85NJuoLrpyaIo8pc3GZGqDXNSwCVUssJ9UHMJFY5lJuGg70fg/nFqrGQVn +2XzQmPSm2lG7aCyP2kVb1ahdtFaP2ozJa+c4n3aASoyUW5t9/D6cxdv98eR9NLTb7uNpHCpmgIdM +7cliGgc8Ezplh6CpSvgbWv5nHJ/oWRIS+GYtP9wwL9BO5F2Kf9kMTUo77A+3hjhpT6baHW8qgFAz +yRE9nVr33BrEJe96a/BXz4YNKg1H+N5mrQfX0DvmMrY9Qy1BZEHX8Vrcj3NSgT7f9j+FarfnF09h +/x+Ugw4Ex6USTmbSDrSBWkx3aCM6oXx1GjJsI6osoiRImrNBKNIV9icwlFUrdYRlCGiBgG+2/c2/ +/IVJ9w90N7YdXwbfKyqWjXKhYcRWqoWJt9bQCB05upIZUMZrxmYqrZX1txaCkw9nQQnaiEJSVZBK +3wpVoZJgObazEbq40bgvBSGZEjdq0xpO7VAK2sy6fbWFbc4/p9I1mzZtEI91ko0TSQ6YDRmzXc2S +mLaZAtNZOhk1Z7d9zbGbWYtmF9pCtk2GnY+GcrJpKQCAYjq0b9MnW8h1bjD79ELis9HuTFRHkaat +tHKEN1MFATPXnw6aMvx+10ZJBg1G45aNYoQaTG2mjhq057YGu80OBp/bb2AsYubDliuGgFo3hsOR +EocqhgZAJ0tWauhXXGWeowJIdXvkJNCdFhvcLqZeBMKqVV0W4Q72vLlQRBYSGDJOnA== + + + tqQMxZDq9+1bTXvdMTBzhjZCGzabgN04mXbg8CbuupXCDtyzeukL1dyshgN9FrLHTksFx6PmETAG +1DSgc37pV5SwdAwpiyVefH1RKIlOKGjLwAC30XCqd9uBEfjP8SuVq0rtdm780TkF4r877neyWjQ5 +OnlUtRT8qluPV+DfgbMH83uFKfZ5RScWwyBsv3MTk2H2HQX7u8CKFzo6hR1ejPpdSSqaGg/SQHHJ +iNJkNABI/HM06dUlycTYTO90NBy1PsFHHdUkT7pDd6avNGgcaAXd9sOZOAF32JWimLJAjjYbs2rj +r45kZsIrpuyXBV4GgfM50WlLtjn6w0WXKFbCakXtO0WfWvfqbXmuFOXQ3CAyn6rBbexlhWABAeRO +OWqDleq+dyX2xXlAmEIdLujfOlyHsZ00pEtrTHsXvRJcJaIJMy5HMqVUKIDWpH5PqrzX2i9dhUF6 +I5mq4ni1GazFZlQP2lTHch+bZW7qG1mKNdV6m3fOwSNi17NCrRZqqutAUftdquMNho9dMEGVMIPx +nIBG840xjursOogOBsKR/EDWyoLSIzqBOG0AKaGkX7jjJIXOFAyt4V6CSqwjO7EnXhNmt6Agktmc +C0wAxnKkeEstfLBS6/qkO4BIu1VZ9o6yxmw6dkO66nzAPqbOnFmnmzgyZvQRDpDtqlRc6/kqJ+rO +wy6BzXPbacJQd2cepSIiNV9yHkzdztyW8QIZGFCI65/zQXPY6EoRdqH6J9hp/sak4599dvyi28k/ +lQLh/vzsDP1THGHRGKoLdfkhF/U3pvCxovtKMfFxFB8yQ8C1wP4azf1jwDn9gJ908J5GXWNwH7AK +T1fTUdQPOpM/HYIZw4tZxzD5zN9FJ+cNf7/xF4y/b4xx6AjkVdN56xMO72hYQEdVChjc2xAgdQ5G +N3pXuu9O/fNhD1YOibve+a1Jd+y4sVBjgBHEZeoqb4zdmslmiAtKwzKqbkhdc+TPOfkQg2KdNhYY +eMcYg2U2VTCQ8VjFdh1IWCXFbeUojqeAkRVXcJGt3UNqRqsLZ7SDLzEzF0ZJbdYYtuWQaJe8WCyl +8teZrcvDMXbcGaFq9cB+XRERaBcWmMvgDVYG87Jt6Mr8NJsO4Kv96QxY5HM5Oej/+7//n9n/+3/Z +40z8DOyv98m31o4/Gvb88Eo3lQnP80klJlBnYiszS+S60siztfzRkcAWOrB/+JI5PN95jOzfHgT3 +GnfRY3rnPJbLTMqDz9THcOO4tBENBfPdRny6zV1XitxWKnNdTp8yh6nqU/A0M5m3+FKROhUCJMNs +EcS08FX4iBLbmb2X+G5mPzqeZqYnVMIXyOxVNyZSo+NZ7qNyWc3sM51avnuQbhXi8eCHoatq+x70 +xxdKgRT/UJ4Vvp5zzEMsmh2MqtPsUW32GUlzW/NSgdm+zX31g7e+QOGdOG6aAtvmk+/8zeXjU7ae +j99Yd6pul3rO7PdKz5nUND6IFKKBeSlUbr/7AghZpTegYRTen2/5XD/Tv0u95z5n+U/+gdSg422n +0CKr35n9w+AthgOGPM2/fLyMwK+d78JR+2gjFxO+trO12NYQj+Gu0Z77AsmvUKRVbLGXofwn87q3 +nw3QO5HcWfQtkskHr0v5znw3fXO89bnXajV68Fc3UnyvfuKeSSLR4Cfd7bdU9+W4nesHDoOxSeRp +nq3Wdr7h+MOZveNP2hfg9m6eM9lhKziIHJzuJfjB00GX5xPTdzo7aR2RkV6KlCG2CsfTG4A2Ptjh +b2minermEw2wvuTpQSgW7eT6/MUAz+C+Gsjkj/a3bovRJDsF63L0yG2l+fzoJbJ/035MUc2tZwQ2 +PQyACaW53S24JI/cLXc5hHhK53phLiaS5k27SpDPW6eFRGN/p7QReZjAXjj44gVBQU18AaK5ecSg +35F0aV/8tX9bPMHN89HiGwZG3VNHgHTviEg6XYxShcOPAxHO7cH+Xvvr7AWtpDxgAO88x4q9gEa5 +Y3kAz8oAyNDBFWzUYdAzdiNXeEWoBsLykOEeuK9Wtl74ihTeEyffxUYjuJ3jmteX+5XCazpb/2zN +shfbrdNsnaLB6mf55/st8E37oXj3djiXUYSpVkOmLz0FmNCPTyrSgt2PCu+1YhvhE4BthCPprb1b +vEIQsi9QfCUjNznm7riUmUw+r5nU6e0hWiGB7U44sHi70UhulHzRo1I7cTXeJTzhhYWgfIG9yME8 +VCr0yRxxzKbAP2Wii+GkueYos1efbWbrx7O5EZW6lVThXVr4u8kGfFYHfOw73s3q8TS/SnZKoZ1x +OP/JXT0Um8T+bqEzmUSJzsXBnjwQjA4ZGdVy9vWYRNS2H3srwZ16Ei8cffENvPfxggq178FJ9vwl +d1rKvx8LBHnSbJfy7cE9Yp4ma1DO9bmDWwU2N6sePOQq9a0D3Rh8ATCKznmh3At0QFeX+5DD0MR7 +6nZkHK2+XQv8is7K481mMhnZY850GNk7mo7e891pl4PcMvZ4QYW3jirKrPY6qZ0B2MlXYUhep5GD +44djqdOPJ8DHaPA2UN0tz17bg2zt7biQ6B6EShjAe7DCZeuno4/MTf2oUSoKl3e+wH6EKD7J6BgX +o6MzqrTDpe7Ams+TxVbve0fqAG2QfgMz5p3HYBWwx4Ng9qo/3lW3u2xUAPsLMvzV5248e3JfG/oC +KhYuvX/N1Pmd83z1u05qRMbuTuE9G3zRyICrUuk1vPGJpgF47rADthTb1L0VVx++72kkjerrXSBE +y6NitN46AFi8vAUb+247kj7gaPQ2W4tmhvlu97INp7YBm9QLJyeVWGm/yIbRWziXj90hbl4/zQRy +/WMiDtfqUdmfvHDY3WUyN80Ef1E5vSKbL9dZemdju0iFt1/yZDlfzcBfaUDi5AHRaaYOyWgofyg/ +S/sC2m9wS/QM/pmDTDGPPkR/crUqdQnfHqCv5Q7y8FkOg8rux0o8GytcUa8P4yJssg94MmwOHxTk +rnKw0ZkCB/cC+9OCyMiDT8tf7KEmcDQXaEhoDGAuAE4WDwVOE08YDgpipw6f7SFgSi8IhB5FcMhm +naI/RYxBiDUtMtE3e/AtmsahgkrcGA4OY3H4sXcpo6CG8Cn3sq+ai7J4aduldb0QumXwBXQLgb+B +yFJgo2kgPGnRcYBmpfyJQMk9l5Ux+ALatUybkZztkuAho1/yrHCnyp+YxkwJwwVZwMZVeVYKqehp +Fs/FElkHeKZo50joOFDmDBufmyFVt1N9ARmFB7ppyjhJaUEcakeTV75Fb3Wdiuui7DsVxWhWNa1Q +LWoMMZE12Sp78ggvZOaBiRTPpYTwiMC6RbVqDLb0glAOVh/iUYadNmOAaGry1vRGhmhBMMb25Q7Q +GK84gQyfo18Y/fJMee4m/g4Y+Bctyr1kdpi9ev84AWrlyVgnMLL1m5NhKUOSPV+gHCi/ApywIU6l +m8wvA/ul11l9N7NHXGxEijd3FUmUxbZV6oRKK9BbSep2gJKhYYDVFyCCIyrTjEwCg+UkxwWB6hd+ +tLSm+L2HailL97aPkR2gnVAEGQi+gDA6JvhiLPrOFE4Ovxl1L7nXTvZqWLvO1mZHg2Kkmghp3/ZL +mWRgLBkVV2HF+MIdHD3Wv7Pn+dwF1GFE7WqgQQywQKEWpp2pStng91rXV1n+6fiqcDzZfTMDkGUr +z0fZk9tLoCeLI7sO9MrT885EVP2qXA6I7ae4bDvE7W0He8sBaheS7QCB8fz1c+ek8H45rSW6F49A +bS5+57G+TVObj/bGkKUp5AuojSGFQuHUsIV9lz0vFb5uX/PdLy6x9z4IfAD9dpcEOEm/8fxVewQH +F1P0I1GNrfWfFVCAkkVgv5Nlwe3K/oB04SMWPsQdXNLpN6ConQfzn5H7fKKbPkiJa6XFk8YW6QGy +j5cUQxjwMfUaXFQQ+kGn9BZ0HlQxzYvEqRqIlVGxk8Z0rmyAi0ofWBaK/q/V/lUDTfY6J3kwoXak +9PaaThbK9/w7MMeLFEGVmVM92MuN8JPOSME0VpS6fbssvF9HyoBPlwpUuF3EOxBZqlAGJDHjetnf +6VntK7708ry7VSoO529UIDkQxNXfj24nHgW+VT3OXV5kwFzuB2eigT+/D2Qvz2o3pUK4Lb1QiH20 +Q/C9efOCqJ40x4qNrPc5UA89sC75z6eNVCRdfn2VKOs5DlYwfpLrnUaAan/xruzZFPS0vOR61MGG +8kJ2BBCp9qBPQCFyBrH9oHg7gMVn0veqe8aa0pl6647jl5HDm8a31EGdz+yd3G8C8/FzQwv7PFsr +t7/AuhxMqMz1RhKtAVqBg9Cc6kCSe0cvAB87/JzO0SInLwFTBb28NACI+rT4Oiabmb3rYFzlJKPY +/ube+/ziK1u/btyDDlJ9ovSUocFoKjGZO+sdGL5Asl8avVtRDCm3rEu7Vw3M5e6l1R5F+/1LUFx2 +p9BkOjXH3asaCNy9H4CSS+GL/l6pwD5QkfT9864RogsrXwW2qtq9uerrJ8InWJc0dzwvxK/asUzq +7Ksni6g6t1ka5kXXICC+2Ph71C0k7vYyEj6DncRn5+UN4nMqDq5cOBA56O0BC8U8lRucp4EU0yge +Z0zufE4/AFRfTYuRXe5dJbEUuoOkxG1vfQuZ1O13d++90vzIpO5KalCYY2PbPdn0BZDE3o/ecxUE +WyW7xZZECNjpsxZYv4e9Qmd8XkXqBLdVZbbgM6pwUj/dVLrnb/rVOhB0h9vFV2L4XHivF959gWJ0 +dDrPspnsY7F10Q/r1CXRM/kR6AGGmtzkp4mzm2y9moHbMBkzDn4/lJnEkvPsxVXiOdV9Ed7Bit/u +gnVRqTdYHB0kAMVUd4GC8nRdet37TOg7pdLfA7DIHxuZ78NWR3kB12qeFZrjjzhZuYmKz8ASA32s +vv0dK4VGybDuFdmsHlEKCFm+wiGfxXL9AfEO6KX3wKVT5/eZvXGSNE5NbAfXBbTkhcvRrmUj1CTV +bje/jU0eYgUi+RAs5TtcL1svNMhcX9gSCCr63c2kzi/7aMFUHMZAReh84qB19wg2TeE0e1XPfBtp +Y2ua7x6cTjOpUqDBHXJ35fxZ/uZQ1g45Ub7w+93WY+GodXWRY26pmWHhX7Y2gPAgLkuh48NqsvJU +molKsLiIcUBoJ9zeyXb2vfCx9czwqXE8D9Sh7q4CCml9ENh7ZwSJ7nE/vB14hdS9X2wmHsZazRuP +TKjvbNdKr1s7NTC/yFPx5WvWQj5IIz7Ls2IztxvyBVKnEfoxW6/vbGiI5fBIBlsVvVQiWVQxE5b+ +fLIgkMpWKZ99Bipi5ugO8LFCtM7KPkM82mQvW6xn+eTVR5J5yw3AJHOEZRMoCBrQVArHhtG6rJ4B +K6x+c9jL7KfHt0BW9ofEjgmITq4XnB3nmPvN68rBExN0NVNRzdNACcWfYC+9ozNgfhRH6n3HZUZQ +Gh5DXyeYLktvARPhIamASJHCxlkpfH8xy57ck21VpwcnZ+1Ce5CMqs8swMhCgMuf9w== + + + PhT+i5nw6O2TVe1U+fQCM9zI2eir8J487heau91Asvo22S9l+8NN5A7V0QtYfXiUlzrLJ54KJyf7 +CayqUZe1WKlIvodKqezVprSgtyHA+esJ7qCUTee4wJgtHDX6AQP/6V+EAW6eryAvjRdOjjbzgFtq +N9B+dH5xX8oQs1ew5sNmaWM3SgIT9hp+k6TAzqHfwDY8FFRg6d1QGBuXfJ1/kc6uMgHt6ZuIhL1S +6GiQTX4+nW2VChentVJgzADmctv5yNC5B0bZi6IaBH4pChY6w8vyta18Fvy3ktmPxcOmvcBGO2Xo +LH4CjYq0cY9t9bJMKHddDE2bz5CRkHpkEdPoA1oBsHFj95a91Ko5KvxeNwVBBo/b0GQ+yY4+z3fV +lpPdTkVkL1l8toQvO98f0SkAXCuq0KiVn8qB8rMA6KU3VzWeVUvPYPUz20gVQWeUUE/mMqeF+Pnn +vopq01x0VNoNRzmgBjEBYEpk+uiwca+TbN2IR3Dc8bV6pmoXxCFV2otuKga8gcbUYnvcfi+FTspJ +9SIjWr182oIv+tlac/yOrUWK2/zIDTaFL5WmlKmMv6VdqcgX1Mstvd/g9y7PL7K1+TVlFCjspHA0 +6E6B2MoNwAj7XOntNJC01gDOU/tXAGOn7eqW+XJLOoWQHCVaxeaoEnNoV9+5fS423o42c4PIjkpA +SzSm0j4Oz+7ASndV5/Y6YKp9Z5gpFCjvr2ARK7vfQOU+OpMkMmKfX5PgXWlnPu7kmHkOWDrA0lbZ +5KjJICQADhov9nNfXxeZwlH7clY4DoVK8Bj0CJ8bZfuNAVKNirOdow2p5+M50MaNymvVTIMV1djJ +VhvSXTR7ufsKJGRrQKrZ8fF8Rhw9lvd1+0GcC1BQWvXU2UtzXnp7oQaQxmj5MP1BTUoHnZyK/cN9 +jvEQIHqPQDjchQrvO+MtbnYyOyi99uMJTS/dl+gHWI3pLp96idTgeVBEvy50eEgDhYBpZJlgcJQk +b08SWaE8ncGwAaDQHTXuMtPw3Wbh5Pj5u9DZf9lUFgzp/G8MENHvY8A+nhJcqnm+4/Zr+G0SGFeV +Sul19hwrZYKduvYwjkMbBXMYyTC4AKI5E/sUQH/RcvlBqD8Vm/XsbeGD3enquJfMuCSeJUtpzKfE +JSmitfAF0BFk/vNx/7uUvciMU6fT+UjrGuS4bzJ5VWjlG73CbjfR4vfpYqf48H5UlN2TqEkN7Pha +CcqmRlaIxTehL6SM2BbC2MUDX3+rJEqFeRYdS14CjSMYK5SG2VMgP+vhXG9vPyYqKDqIH4DB1eb1 +thK4gbmhCPRyM8eGSwnAx9qpwoeKW4rv61silkXcXWevRtU3Lv0d7qlNZojjXHC/Wow+54C9z1ED +xTmLkAVk71MXYCz9vXtcaN51rsBuS1fK96/jN8Qj5e1jgXl5cUQ/4QFg4LHSFje5rBwC1ecQsOiT +7xwakuQdpS5DM0hP+9z1RTsBdup1tBQgQ8BuvryKFo433gn1DHDjMcndfL9nkUgoBap8Sgdbbgxo +rLTz8DEsvI+eI8h1ZOq/Fll9ToDe4Xp5Hh+/ZE8ewoKy+jAEIFhszTdfhPMKXU/S0eO90mv0JqWb +iwynXhzpxLYWzlv+47MUhKfegmbIMoAxV86OvqcJGN1xXnju3m+pT6sVBpA6btycKvPXmNGXQP89 +LQXLgVJlIJtFwEC63Y4XjiNbrLrn/my72GpG2zCK4JY6FJ8ONnfgwr9CfW1f4+l+5jN7L7F5tp7n +X4HV2QYWdiLWyI6ynZIyOAyFDmX3MnvP1zl+eFQnC88fzxSw92v9TEICBvjFRRvsv+4+mLBGFS2W +dsrVsRKOFN/YSd5w3HH3g6vH7h+o4kYsl/gcthvbyY/bCRhrBV7TlSPz3Y3HINgvkd3Wd4HYjg2R +eGc38rsksAkGm0Ddv26Woec0QNL/Z1qOltOGwhXQteLanLekPutx3Bh2dEmB4n1W2usw1Vdk3emv +YgHPCvWCLiMS3sz18S4F8xmiB/fkqrvaSqww6A9XaIX5dtI7H4phVD8xjeuLpNk3HpjHzQSRiJxG +AKee0fAXxexfpmj5xaX8C73Yow/rsxywLMq9ytbVQQPQy31afktFDq64z40wXTnYiCWCQIcB3Ke3 +vxE+e0huRD+74NXbe3wjMk/VNqKnd4WNGHFKEYmD+xDqHqxa+JKZUtNTMLhCD6zkW5rOCbQAmOzg +AcXaoAMl5S1Ree0Ay2IySR80s9Hx2XHmJDlNC5X923hp9MDcFCdPD0ThoXRfLx1kD1rkbpYfir3Q +25eRfGz3CvRX5aymiycUp6vJbaj16RtVp5PJ3rQOOokeEQmmhqehjGwqlGY31Muot0O0d0jU87kC +dvJMTPcBbGEeSZc3dtDE0boUevHEVCgzwvfeF/iz3Adf3xe0nT5Nnk+fLs07LfMvbOroJW7a6cv2 +GZD7um6VTrnuSTlg3un+RmgyJQMT804vyCdmk0rtKp36Akq302D0NGbRKfsZagTvi+adMuGnyD71 +YT7TzdIL4wtsXY/7VbO5EqXcScaiU25rezgJH1h0ev9ClN7PakqnKA5W7ra8sb9DHr/WTTstV6i6 +JXqph3T9DXUKaLFZ1K7pLaDkp3m6CrsNG1c1dE8/9skw6JQZGUipSuTETi+CQV2nLDt4HSudKpSM +u32dPH8O6xadZhocX9omTTt9OXy7suq0ArQ+OrT3ZD7X/Y3n6dZn58q808t8OP29PaiadRrZ66fS +SqdgXbSktHv4kDk375S5vydKSeLMtNPN0ge/fTWgzs069QWI0vNzyWKu3FagNzzNW3XaIMrRtxvz +TstENtgJ8feoU19Aj+DZVvRQ7PQ+FtIh+PCMORDRW3zqlTSdPuwTVT5Gwk53dZ36AtPNSmfEXTVi +FOiWH+vpt/r40LDolNvie+3Si1WnBeJ09zmJOkU2snauR9+pzNfk7Mq009pekLbs9KRTowmzTiHn +Zx5jRO01vGk21+nmSaVz9vgQDpl2ehMcflh2Wvu8fGuiTn0B41wfy8TNyXjfvNMqHbguZfYPzDsd +H2+adQp4Muz25rW8ObNA8OM5cXt4UjDv9DRdfH25fH427fT5vHeEOoXyxTjXr3u2XbLo9Ekgnqf9 +mHmnZ1/jwXlSoHWdgl5Qt69HsaElgieBWmTDotP7a6LYHRybdiqcxTY3Ms8xwMdAt6lv/aaZv/Kv +YqdNOqzbNOGHamMXdUoF06GKdqZV4m03lYWdRpVOQS+wWwD261ti+gcTfafT0c6B2OnsMKKb6cZT +4zGMO83dk0daRhidTK/TG6AX0G3cyJWOYmiuoNP8zMAKK5sc7vSQPInpGGF0zJxhSUNvp/InqFPY +i9jt9mTSaA5hp4Su08kk2xlJ9Hu8oet0yn6lRElzmLqM69C7Oeq81X2i/tBpvHLaQVWud15GKcu3 +95fk4Mbq7SdReQvMlbcGzg9Yb2HH4muwBjuRvDSurw6ve8sJ5GtdfDvtCYZdyQ0/N+/M3mOmeHGU +erJ8K1C7V2/Wbz8bL0EZY8b3WWrnoWX5thoZHlLWb5vn73vKWx3GuK3zzVazYvG1UNmp7F9P8dv3 +4HdS9+11pCspp+/kZsqAsevmcW1o9h5zuUKkN7F8extoJjas3z4VUgcSxkzevwVe+G3Lt1+zi3HF +8m3vhspdKm8NGBv0SukXq6/BkC73WMu3xxSTvrPGWKA1bNaqVl/vbOwcPe1avi1mT5sdy7fH1OEm +aY2x7Aa1HU5ZvGUrRPFgV5pzKrSnexupX04Pxbf5+L5+V1bqb+XdrPKemTLRK60Flifawce8yH/e +An34diyao6VXFrOe3Gh6hn9p+Bg124YWZn4jdpy8BxbmVx3+E4fPShvRwlUe/nOL7DfZesM8Quyv +cZWTON9kkwoeXMREfg7sHI0+lt6ig+DD4wHaG9DSUe2IxKkwDAI79m4OWOvmDujvfV/ubyvRPWiG +AXfaLE7mb/GYht1ONn0BpVtk6Vh0ym1BO+fRvFPm/sGyUyBEvkidPqaeK7J0LDuFIq9l1Wlb3SlT +AzayqlvhLFdTddre2dlSOkXav9wprUMv1P7lmZb7mk7D98h6VXerQfABZdkp0v4tOgX2IND+X5RO +wVw0c3227BQgeMpYdwq1f8tOfQGo/3+az3V/I27XaTVo2SnSKZRO4d7XdAt1irpmVTtJqXv0S1yI +cP6hPXDT7mU+GKr3vkVLbuv7pXh37tiO/RTpTuQWOTDnp6zILQ1b9y00gNi5Ujlo0qX5RGQuO7WM +bscnulupqPJPehxq10VjHfIkbO+nx+H9sQwxhECkk5XtLzSKdLL8WACMq1GEPdMKaxK7TxcD4j/R +05HYAVKBpQ5k3RKMB0zuYIwb6bxPgO3lEp+dQkD+50qtMYs+s3O5cQH2UlZP9+34UPQpgSFfX4AH +O1Chne9K2MF6u8iOVTO42NEiUPa4gQETx2wggP6BBHmrtZLMBtVLHukGpR7S6zwISPc0SgUPCZUf +TecORCgH3PJ5njtxQjr8Rxw8NuZN5hfcsJyfL6DMEP1juYLS+tU2nddvS57frkhjZjOEyuu1DbLc +r98I0Se2LFwiywYYuZv7KlmC8rkhdwlZezFPlKXQlUYiY8oqP317x7wp3oFy8yBS8tKYp3IPyWN7 +vPuskaVlPWEj63kpalkPbcl6fE6kW3w6mqgRKA9Zg8AdzHrMcfcC88UkBFuMJ1qM4n9E3JFDc9zd +xzYs2bbVrkT+ONOp3W96n5paiqHJ0Yc39VMnVJdPdsTTBNOBFCK6WamlmGpWnYv4jrj6BjZaBL3c +jDxNyIzDANoB5tydCrfyNlTT+Vt4BwzurmCxTNEx2dgOVtAYsJ9/QcQQ1lL6cxQ5kChHRcnIqWMO +jHQLzAwUwrvqlGfXuO8aJbf7zn7XAVnZ2Lyb267lFhm9JqPwn8eI6pDCQBaAM4aKJ2bLCTCmXlD4 +D1hQxRFtpA0wP5kLGmnj/FIekmpcaC6zsunI0uXm1GqSGaIzu04YtDDjkigW32nEuCTtspMW5pb1 +9ISpL2ApmFzojEpjoM08zizFki/gZX3LECcV79qT2d5vl7V82gRZpyNF8NoMaXZ4bCkrz6/E8bhR +6cCQrBU6ael8AXcrCKx8W8XCSefXrOAwYKtYeFi/8sVAAYUpeQlgtaGLcYFd6QqYVqB4HZd0wisC +u7c3YrxMUq3VLY2x18kKMablaB7HNdb6Yd74icFwnaWnC2rHmvMXMJ6KmTFopdCaCmgqd/e54cDH +VAq2+a6cHW6ubFfm7r63vRnK+DzWsJIVeGRSVXADLXHv2Lnf3HFrfMi6pR476akslh3dCOaKYUXH +FEz3i/Mypaf2Jp5uICIlG4fiwAVcDUSnWy6GE4dtrxoItpEjFiLqowJd148ebHJ8KKkNMpJje6jn +aTOucmiDX0eQ5oseOrBwagBNcMNGhzFlHxYb5Mhe7fAFvAxqa0EGoOWWcMs9zwL2Yg== + + + 2S0DOFIYgFt733p+QRco97lDukZXcPZn6DV5xdf3dQQP9W5XQVSFGVl8npYVzqCJhTM1fCxsckD7 +n7Rb+hRPrOyQ5X6LW5o9yEoCyPK4xTXIkrc4+oLeTvYS2g1+DOei3eKmVrezdwlQ7aY7D4mdL+FY +75LVj8bOJavzkAyOtRq8hVHs7JIFU1NtJHH1PbtJjmFcwqlb94ZsJemHcjzXiuUF3BuADr4pNCEU +qWJYLfdrpZOpFn4fX8DOSzc4hoe790v5fSBanH19OlZg4a+B2OFcUbKKb2o8DWONKp2Z61VpQAfW +zkSRJ7tQpiGWT/SqtBfcYX0MjSdgPx63/gX68JoP6ihCZYt5EoQnOk14sf2SugzbT82Zzk8U4SfL +lwW80eMTvdyzmpAvYEPpgHa0Qm8RBnB4HWB9DmvuDjGvDk56n07UWemyADs6Qeckh9S6LJ6LStTB +w6qgOn4Dzgo8c0MMlrtORcl5MJ64N5+3cc53NTNppz0VdX0ECYBZ+VvNvK3YsrDyt0JgHjafub0E +No0vsPQhBVo1e5Hncw1Ha0h6G414Jo7hLLsDMRTZmlSgSDzZCxzvck+2902AaU4IvQlR7flgEGkX +0ZBW48yjMNWVnDDkUfCpL+C8DV2IGwiMins+47NQImAs564rVKrUz9S3RorpOdq0FzZwtGlPf4Dn +gqOZekjyADGZ72U52rXC0STr1YsGrwfmzNF8Lk+QILDFOZq8K8s3oxVwNLBqZhzN894HcLxzNIPv +AsNZnqNBKMufvSI4NqdB0VxIPsVJ+AJm2oBGCN2M7Cxo9dGhuY7CRK+08ZbA5jH4xuGzZQ9gJfny +Hvy2ZkMuNbM82OfnM7PNjD3w3tgsAHaz4YnJ+gKWbHbB6AftZr5BtrTGEl9EQQGrpgtqsuIwznDc +qfaWUJAfBsBZPgQCQbEwqHUn785wtIfuLt3LJqcJCNgqfNVYFoL5RaB2oZWG4GlsGf1eRaSNzavp +0hbf3a1bb5bKd2EpDW896ff2PlgIbHn9/unbTBZ6lWJw1by7tIxSDMJZRr9XQZFl4eJSDMEx0e/N +oMjWqwUct9LQXhYiDvP0vbQ01MjCV/05MeoFPF1JOBLkP6ZxWKKs1ARPKWEYlrrA68RmSdSojLo4 +fbu7W8ZXrfPzA2DL7m7VuEz2tn2stQ3GXKm70krCXqwsIrCWcVf73Ob0NA/weZOw8Vy5CKfTDcmS +IlBsj+P20gumfDxmEEv5eMKVXelCMFG5u7ZleJ515JqFvQ9GRrlDpYvN1ZyuLtoWALM8u5G9PW4D +6gEwenvvpLoKDwnAGO9NxbCIQYQr+Rp35YPFwCw2+71t8C2mCJ/kv3c1KJcUYdhcokTGW1eRZ2n2 +dGhqWYhrgLLlph8bseHl60b05qW4EcvSLzBvrmiWQYdvblk+h04txYwZdLqMoYVz6Owz6BBPXkEO +nWWnKIPOMlvQYw6dfQadOltwmRw6+ww6jda3RA6dfQadJltwiRw6+ww6m2xBTzl09hl0KFtwBTl0 +9u3E3Oqlc+gMG1eTQSdbFkvm0Nln0CF9zDmHThOQbJNhdhEsmWnb1jHw1plAumAXF0My9fQWnAO3 +d93lS5V0NvLCwbAFvfZr4hxw6+l9LGilvbelU53xFfQBGwvjaW9XQ67aXFFZxofcJIN1vjo3Tk4U +7RmfHTD7OCx380O+PqfMOdfz03mujPvFPdIT3odkkfno4LmyG5JZyhyci6ekOVe8pqgLBVFie7wl +UM08hYLg+DHTYBDvbmMrpzG6GWxpf9V9bMt+aj6XyW7aSEivjkFEyWDNl/UY42Q3q2MbrZXklOxm +bZ/aHziouGXRNhhEY5o6mSFFXTaDJlPYHTBtCBZpPLFpUt9OmY/ueFaj5MnoRbvSyuxt0tYhlJ5S +TFHu26nLrENn2x4gy+wsW9bHjK4zJ8dhTxjr3CTg22vToNkFTqzKlmqXZRaYSlPS54E5ql2u8/jm +TjHwHvL4mk75L1sap5V1app1Eoy9Km2MgQ8efG5ZDSpjlqJpvX6OMfCuowjaZa0H03T93ObxCROn +nBg7YtBGp0NgK8sQnSgnH1aZKV6AOVO8e4xpHaxLYswxTdT9JBWOthDGtI5fKnd3H9MGOlV0gfUm +mVzudFmDz9doZslb/crcb2mfL6cDYQGgt6mVyCYg3qgXEv7zZru7Ky6MPdniczD2PiqujT0rAPoY +xQVAOF2NAtZZvlXDXarcQiv0SjjLF0mlMd8WMMXN2cngs3VJw6w0CyPOQPZ2OXI+hzRnF0eeaEL2 +V574DOaVjR6ZmhpC+UOFmQuUq05GrCj568ibe8fEVMKakkOCnIHrWGdEzUyl+QL62JHbHa/sd0t9 +7OvIm3vHOs1OH0G0MJ4+HTwNPp0pYU0CHj0ymiFp8pHBoCgv7g+bIWk3s7MUs8ET43ZI9tHpzklx +dkPS390R1/l/cUrSKjwyx8gjs2SUGtCEt114ZMQzPof0nO1UfGcZj4zK3j9e3iMDAIRsojs8pKEt +4pExZAsu75GBaWg6j4xVRqpTfh7jySNj6uc/dpGe4y45B6bogQ3nTMnuwvdgqQ5CqyyfKMqyddy4 +G2WZPryObLkgBvucxPHJaiIZ4LqkLoOrceqAqaVCDjG9btLQFgxgV8sXmEBm7V3ykD5mCF0wzRZ0 +yqvzHDRrjFBFeXUu4/Vs8+pUqaM2mcLOTtAT20uqVLtXpVvahupdGO8ihc9cCjop590qMGk1+XCw +l1XE1Nnnw3m/f2yRfDizKOiLwarz4ZbIs/CQD2cXobq6fDjotV5yB7rIhzO5EdQyiWvxfDhNNJT0 +TXDV+XD6e0dxRtyq8+EcbwlYST6c5sTKRajlYvlwelvM6lgHZrItn1kPBdzKYiIBKG1MpJVu6SYm +8mbkKibSae9Pe/SyakAeBUgsn42O4ESdVt8lHDd5JJZQsD6G4Kwgk8sQyWATA+/M0WBynbVDzBjv +rKplYxHxHPzeNUQ8B78dFkK3CS29PXc3y2xDJflI5VVYdhsCYLbXypjxMctteD92uw1ttHGIb2/2 +oimhreY2YATH2/axyEcGcFaSCFlIuJNijnCsrwS2uE3LKszaeCWw421oWq+07rbGcNTow4LJZ/YX +Ozka1HJGKrm5aICIas5WFwsvlJHa2Hx1kUTqMiO1sdl04zJwSPVbSUbq0/dqMlIhnFVkpMJ8seUz +UiGUVWSkQjjuroHWmcRmcX1og1hfmuo5yCgcE1dfuw3vlt6GulQ4cz626lQ4FM9vG9GzilQ403VZ +eSrc4n5LLcbsbXcPduUSqXDqO4hQMtwvSYUz8Sr8glQ4c/+YS/vs3k4xVLMC9f3JdolPn5axqm5u +hNfqY/m4g1nkNtALgmJdeRRdOJAhMOub7TzqMIZLhr0eLqiy0e9dHuHY3c4LWLmZyFN6cU5u1ufV +PVleh6MXDpJ31EQ8KPsXVo2LmvUnrgEqcZk+/yz3bxqvha32vFhKbmdeSvX0RTGTmAUB5y/VD/l7 +VDa88FCcZLIVrn6cz8Vb+XwucQKLENTGkjgK9LVDFj1O2lwss6wzaCWJOUqP1nlnwmXqQk1e2mS3 +vdb5qdr5rOqU/dwN7G+MrDLsmPs7u2S3dsKyU6JUz9ll2AXOu6cNq07fbDotx5KqTvW5WKnIVOWF +0ye7MXefVbkyoS4FbDNkl+xGxnWdauvx7Q2sMuy4ra1vbv5klez2aJd1NrDPsBvV65ad7lQ7n22r +Tjv29fgu76w7LZ49li3Ruz2k916tOr3UZtihVQUbVpw1+iXSecpluz2zdtiroGnJPFVdQWTCF7id +KDqrnIkieiZZSenSvK8XqHa+Yxcht1oNNjLEc9GcEV3sjFaT2uMcoar3mljXsfp2MSTVuZjNoJyC +U53iPLD1uspKcmZlR0zuVHHhXbKrJOfJC/dYcB0i6ZANie6E9BDX51REzjauzz09ORSRs5yfWd03 +p2IjbufnXGvANdKd6ozo7lJbon6c+/1S7lgXIrIMd3VbgM7e07tINt1ifhiv2XRmdoBUi3N12XQu +74dZMpvOzCeo3y/LZ9OZ5dItmvlonU1n5os3j7RfJptOgxZxz5reP7ZUNp0ZKIcbQhbIpltQInvM +pjM7p5Fl5cqy6cxy6dT2/mqy6cxy6VzG9njIpjPztUsV2FeXTWe2usjTu9JsOjPlRh07uppsOrNc +Oovb5pfIpjMO6XPLWlNaNJvOTDn1BVadTWe2fibRUEtm0+lBOdYUXiibzkq3XG02nXuMLZNNpwOl +PxNfUTbdQhjznE1nm2O1smw689zqVWfTmQEAvaw4m87stEQXA7+CbDoz9qC1XleRTedwMrKibDpn ++bKKbDozZCja+Kqy6ZwyuVaTTWeWS2dZj295AzCmGICa+mKerm6yruJlLFKpr83hMvHp22Gza5DP +jKxq2Sxer84wpBk85Vl1vTpr7cIdnmaRoCc8KVjSRELCnExHxcIlCWgSFCyynq0GpRuSW1bgorqc +9mBqoSFBjIFBeSq7bDck80AKSw5jgyebsssWLBNKMa1FdEgeT3UWEb2dHDsUNrf3zMnVsuwK3S1d +5k51z5VLlXyRMneW1eVOXOUquSxzZ5XJ5S6RzlWAhH18slLobrm1Kt+P3VSZsfVSuSpz5+hRhIhZ +usydqMPYF7pbuswdzn1zKHTn7vBofLKCe67ow2vSfhHd51mcrCxEaXyiqNwL5/KAqR2E3dKn5SkP +LFDnGHvoRJ8wjQ4az7YeeFeJdG4imn3OGYbWQRyu8wtBLzZhhx6CyCB2LF1/Wkp2V2EL9LwV1OcT +wUtTLedsdjeU1XlP+WKwYGKXJhoKEJVDPLjraCgAyjF+zHU0FADmLqLbPrAZ8b6VZD4ufxQCKwra +XAcurr5LOK5qu5pBUUV21VaxAxEUQya7aaawcy47AuYqsdaqBoQ+sbY2NCbW1oaruxUQAltJIWNE +Y2C0bpiZWnZZorJuhkrHeq92MdS7xiNdmIlnjKC2tcStYqg7095KMlPkm4+9axJGUNX5qioYghcX +1kfErvf+tadC1Vanb7Dw2tLqBIZiF9XpAc4KbgnAcJatVo2hSJvQ7IZDb7Gq1y4SGTyd8IYjJtvw +xkUigysP/NIV7qT8SqsadwtsQ5PgikXrVnurcGeX+bjENpQITaxwt5JKeY75RO4q5S2bTyRXylt+ +G9pUuNPmJbnJD1mkwp1dvVdY4857hTu3t5rD7KflE2ufvhU1x8p6dZ1YC4A5qzk+N4oOrk23WGKt +PvORXdZ/BPMLT03Tob3dc4XgLMA3DXdEQDgryec8JdzZYo5wrHNhdUlMPqdrJlC5PC/57WZJTOpT +UcggooZtmAo5LIQLv5ZU981lGpObJKbgwYveElVJMTdpTNpJOvhOFVDyulimMaVCrjLUbc12eVem +Qm52pZskpuDBUK98L2pX3nlKYrKKIIK1E20krTfF8E7M4V3iVn6dYmhyWeLdPa4BsQ== + + + ihzXfNz6VjFov3itSOep3CNCpbU+dr+6q6nu0enbinJc7y2vpvKuwzSnnso9OlTKSyyY46ran3IY +housZ+ccVzAk11nPdjmuogcILkSVN+9PUv1gxlvloF7okflc4vi2sNU5rvkChcNIrX4weotw4Ff5 +AmX3le6eSm0qmN4sYMGDXLsq37H4S5OEd3Z4pe5Ukw/nC0y3bu4v1K4qbR22VP7x3iIfLmydhDeZ +v6VILU/WpeERu1a5f9zWNn8VfrZKwnuy7BTMZbM0pi3nSpS3Hq4tOw0eNeMfVnXYwkqnciaXguAL +llJ1qk1Nmwb5HaWOIK3LcgyHDh/7Zp36AhDB+ppzmjS8hj73T43ek/0Li065rQBzVnhTfLD6jLhX +m07L25x1p+XLrQezTlHdN6GiSa3Ud3plV0fw5Ma602LxuqSJ7ALdbsP3UfmXmIQ53z1IaFffoh2d +JyzbqfMribfdVNYFxEhqNCsqYhLM+Z7RK53yYY3o7dEKz7yNn1gWdC7DJgFS2TA6DdJUMXMOnHQh +mwHsA31ik6OHxDolyRhaZTkkSMnWg8q7SW1yTmyarqoyC3LoOlRmcetJKtiHVlkunaEyC+ig5iUE +zS7rTnfz5BJZaQ4RmhhLPnf0pDv08jo/2WsN8+48V1m0GJIhSku/X1wj3VOUli9gNyhrP7G3IQFu +aR2nJY7HEBurY1fFp/Su9vC6aKyZspgpAWAfubj62sEH+1Jc1eWN97ENdzccushGsnUvuz3leSku +cxOtkpNouDJuoWQ38yNrT/davxQX9Cxrb9GEWYDLXkJrdlecZb6Yk9VivCvOxgAy949pg0ZMjlgb +JU/1Dqw5TGllNnKjpOcwi55644Q7q32MTqycy9dpRqb38zu77FA9PkuvCvNtCCDoCRPv+ohF7afg +wZ314aC3RDJDPYslyrLZZzJ5yrFKerrnQDUkXf5Lu2znO3bUxjVDUoXqi6fVql3rMRWwt+0ilVN9 +z5VNKqBTSWOH9VNO3ttl50Qd18Sgq2tsWmXGAzCnKjpBfXatDTCdVFkOY465PO4nqT25XBJjjvV0 +PGGsyjxZADOkC5tphyLGFswCdJsD6PoeEqsEMVc5gDbR6S6yAN3mABr9yV6yAN3mAKpvOPSeBeg2 +BxB5rRfOAtSQio2FqY+D9ZYF6DYHEGJs8SxABZ/2fEObY+U1C9BtDqBsIy+UBWgxJEMOoPq8Eo/H +OKvli/K5r8i2TFE+1Vx+YVE+g1fhlxTlc6rItpqifDhnxF5BWb4ony9gohWuvCifsT7yryjKZ10f +eZVF+VzVr1ymKJ/aqwAHxVkOSkSRU2qwdVW/5e+GOl7F3VAu6/q5uhtq6bp+qqmt4G4oq7p+3uKU +Fq3rZ1/Vb6G7oUzq+tl7hcwtce91/cyJz/ZuqAXq+jlT8irq+tlHhsieqyXr+jllcq3IoWtb1c8X +8OTQtazrZz81ne9i4bp+moEYqvotUAHEtK6f/YTMIlQXqetnmo5od6u5e8S4zpQ1vQt6gbp+9jd/ +yWfiS9b1sxV0eSTFVlDXz94t7OkGKpu6fvamrmkU9AJ1/czSJJWtt1w9vhXkvHuq62cPBfr5V1HX +z/5AxecazjKJ7/qM1EXr+pmomqqqfurqDMQSdf1025DQVvXT3NnlOT2FkOv6Oea9rqSun31VP5mS +l6zrZx9wrcpIXaqun5K/ZUaLunuuFq7rZ49ApMGuoK6fzV6b9ugV1ePbtYfiuh6fQzk51/X4lqrr +J0Mx3T5eszkMdf1s8h4co207Xuv62Wvy8MaDVdT1s5LhN8aTxMXyt1yo89JJotM2dKrrZ3/erI0i +WLyunxbbemtx0Xp83oI0rOvxrWD7yFX9lq/H5yaJyen2BmOshrdSfPqM1OXq+mkc24aqfjhjaPm6 +fnKqlF1d0aXr+tmrORY05rmun31Vv6VvbRLr+i3p63NZ189F3usK6vrZV/XzXI9voSxcHbc01vVb +PBleVdVP1ctSdf2MrmR1VT+rW8681vWzD+/SSbGF6/rZBzrpfEoL1/UzWRdVVT/7e+Hc1/Vb3G+p +xZj3nCcLu3KJun4K4zKr6rdw9KCurp8tRagqgCxX189eMcTW6/J1/ewTYkWJvHRdP+0k9VX9DPqY +65ustHX9rJUgrMM43GTlsq6fKx1m6bp+6pU0HuDYZNda7E/zun72wsE2i3NlCbFY7idMxMODnY52 +fm0e8aG/V+oT36iok5XgqbVr1z7wXpe2qKEmicaU05v0wVidB499U2JXIY2EjI8UxBCJ8w4n4/NM +Y4lWpzD3jZp+bgCxcrwReTzbJhJ3PR43gvlUG9un6aM4ERpuJFqPY4aefB6X0v3n5OX1big2CAdz +3zmi8nGW3fqe57iNp0abBr/eMgFW2KvsnJ5/X7HfvftHX4Bn40xLOC3dxU/ikw22Wmbecle968N2 +7ZS7/ax3ztjvm1Dnffs2G2YKX5v1q5Neqr9/N+ochobfr/x3YJIZcmcbt2eHwW06VOYC749HR+H5 +59YjM3rqpMS9j3I709f12s1GPPKS2aA+vm8i+3QwQ5RyJzmi9N46JsrcztVk8pYMTabC7dF064Vr +Ttnm44WcaVmPHCRit3G6mtyU0t6+EpPp0wgWm0tu4dxqIw/R5JfuPVRfk9nW5Rga1HIJSFhPcv5G +BnazmeqxGbIQMsB0ZztwXejtDcu5oozGUCPYudi6eaint4eTRGmHYj7mW/32Rhtmkh5LyaEb8+iY +OYPxaqdDlJO4kS3V6wFiu9NG9v7FSKuyj3XbB0ztIq9KmlP8raqpAbZmhoc0F8jPfYHCQ6lzhwpo +5p/LV3fcWb69mUnM9o8ziWl7r5Tc6l0UbzP0C0DbMF3u39w9ZSvcRhPAufmWwOLymSEy0uNhKuP9 +S2avujFBs8oORpCSsye3t6+R4s1dBf4CE77ox2HSbhSb9Wn2foIsJyIxC8FohNcZ5sQJNh6UfpEh +5DsGGOGH4E9+F2X9AoZzNAZ/HkQRh9kKAin2OAEP8nHpw1KiVKROBQC2QkQK0cC8FKocHZHR4Oeg +2Op9J4lEmg+jgcLBPZO7eXIv320kSPDiIKJ60djOH/gC0qt8THlF5R6uD6UXRwnlBb2995GVXpyT +8osXEW3lg13lmdIzlPvlfFT1CvYtwimDXQ8wsQtm+hSBcw5Tz9MvwADLVyS6CYesHF7RYLqXu6rp +Nj8iELOXAOUHox7Z2uZT8rkYYIWQvHJkK3ZAwkYJmLc0IFuHRxBtl6T4zeU1AguTWve3YM8RmFuM +xNI2FY4xUPuvx5ROqfBhZg/3sgcPvK9y/fjHbvai9V4tnBxt1BSSlI8F8lrDNaA1OHNUuFLaN4MH +KHlRiJfVAxlijp1dbHfKzw/CR7Y23+4WH9oXBJwViagXU/Ib9Tx/yYircf9CS+RVZ1RTLxzyLWkf +3MYQAqnCZR5KwNuERPa3AHbzGdZmuyVFdZe9FbWLEfxNy78YDKK4N+DAnw8ixNdWCS7JQ0L6+oGQ +f5Gq0bxRL11pNA80euELiK8KvW1xH/S+WDwXraTVnpnuaNiMzAUs2AyQlZDR6NhM6vl8FCre5k6P +c+H+BOb0c5VckYjXjWxGX6U3iKgNcAEB3egals/FALcUd/xdL4JJMnf3MgWz2ownupsXO/R2cjAj +iFB8Kk4XMBcUN43ck+BPJoyygsniUwb+mQIbafsrDflGVLX6T+CbG0gTlThSg2CkShwZ7mT5JQ4N +80rCwgVTIWSC3FG5U9LsSQiGin6TUWL45gtIC3Wyi/ddNB9oys/E/Qt0OLidT8DC8zeV/Fsv29Yw +oSpBsM0TuBAnKjogy7lvqHF8nCOMnYEO7keIE8OpP2VFtQSwHvwMM1fIcLCksZVDinPWNNJeWsaQ +9gy+OoVqTgYIcGGO9ZoddlRSKXfo2WY+uwk+u5rBxjeauw8kTSmsBhHtFnUgIvntw6IsoCtUKHlP +Kyobera5mT4sE+3AsDCZHIx21SoE0A/QvQqlgAKC6GyyCR2Iu7uLrAyiG9JslXIfIjWE16/4tBej +d/YeSYDjQhRSjmRXoqeQxuL46fP0FW7xp6nEZl5nGsxvBcUyx9THpawpPStKEiowDVXNTfjiHuFO +pScHFaVlN3O725B0kwNKUkvw/QxA/G0yZX2xZVgIV1qX+QbsdAOvADN93IFSrPS6Id2RkdwSx9O/ +PlMr7/fRoYixXBg6PfClEJXn+ObXNcBTpAQ6jcfQBjfeFgG9cGBk5YiIhMK0JiPhSY2E+eO5jATd +jR0RFQoeJ3RTdXeHjAJfIJx/aL9ISADjUSOBn1giQULB7rYKBYf575EKBYehwgShAFCy2K1U/xst +iTMSABPqJXCnNH/eE1FAzUkzOsC3atxrkZBQCPtuY5QoYiRMcvePChJCze2rJws6EK+jlauWAz5m +Rkq2ICLeaVEbOSydAyij8DyGmBkAtC6uQcQX3FJKfHKYWHI1otY0jTi/NAobmo5GLUC4wgPi/NG4 +i2nQmctQSATRODzXjoG0HwO2K235U5SSQHBbympMN8sneU27xK7SDpZKv7Co8w4WJ7QsjYWXp7HE +gmNQ0Ri5LI2Fl6exXUsQLgBgGou5IFMNCP00HFAp0pgtJoglKSIR8QVcYMIWhBvO5wvYgrBCpavV +gADiam/PQkSVcE3YSO6bgiCWnYZqZ/gCi02D8jQGtPf1o6Cd92eFOTjNR/AYJmlWc+nXG6WXAYpE +dosJKup9DDpuSS1LVFTcjCI8cUvKjXJjJocUbkktu8UpUvsnpeNjFC0aC6F2HRikmSn2yCCrTNH0 +0+XbELYiFJuu+JLaF82+885QtG3vejHqtdKOEonGdwxZw/COiOlnDH4dRzYIfXi9iWy/oHScuBVE +QT/IFMbeNdkUxr614MHVN/gzE8N/Pk87yFAM0tv7+2+l1/Ajqv/ykvmQzdWQ7PV7JtqhUEqyT1O7 +KseaagbpTFTlVgseVtPSi1JceYHuu5BdMMDYVXncDm/GOclTlkLTCKt7LmciKreaqudySXHovaCa +0MgLV02IXoXyOQHdAxGcmQKMZwpbcs2XQEOa7mUEO86aYxKS/WVMVq+3qWA6BJMaL+Oib43LQ8q5 +JHB1uQnZqpyjByLY1sMjKfpE70uRxGmtB/lBHZv/VJhLtaVO63HcCxHeFgiqXwsUo8nwS2aPuNlW +DG9EY5Lpjb1Phjgt2Xr//3u79r+0lSX+F+R/CLUqzyS7yebhqyqI0KJSEStoRZAUrQrK457TX87f +fmd2Nw8QLUd7b/1Udodkkp3X7n5nEk/0BTjO46e8yNGIcST60mgjU18f2lt163DH+d5NSiiuWUtI ++22c01AbV5F50dSkexchJN+yccSttImh4psmwbZmmQgYqHB9xGTrvk5la3J+ydOAdC/VbskW7TFk +wDgDsLFWcxs5NjV8L8qAtu4rhji7NTmWvK9SZzchsEbjiNt692f4hRV6QSccS5Onlg== + + + YjvxFYERCGvbbCQF0LV3scM9Ph3gerVHeQg4dkYi51YyQs5DsHuVY0pYdSxWF6UUtzwsZ8GZoZQJ +wR9w7O3Edy5gzI9m+ev7wMM2yvrt2VgTUNVtdi3Do5P5cX3v87yndpRlcL7DL8Jqw1/4VV3ukWeA +do7kz2DsHHHayvMIk4QI07nbvf/QL5LspeNzefKxfDEi3GvG49E4D7hsIZi5Qk1kv550Oe6Fjish +tP2ehRI71GT6Diz1ny3FJQ5TXWo4qn48ufeHR8Pb3m1fzSrrir5TJqTe7w6KQ98/8f8eFwbXkwe/ +P1bXVH2nli+XXVbwrwddX+U1KOzKiWEMAlqT5TXxTORU3Y1AoQs/vP270tLxZrvww2hsxapy+BZ/ +9fHkKZG9+Qmrk0TmWltOZFvd80SWFmuJZGmUxW5DwBDhyJ7nw67ASOz0UsEf7k72MgeVbzMAOp8t +vauT/U1lee/brn+8rY96G3ppp/ml0Cye1rb1sTHgSMUsOChGGiYr5+Q2h0M6XkmkNg6tRE5fPcUc +ZwHG8rHg6olsansbqZ8Tma8fDnF8h/jFp0Rux+wmsgdnpUT6aWmI9u9KBKk4wUI5mpHQcJS/KbZa +gQ9WB9wxFOFCJNvrIbJ7+iRjLILEeHYIEuu8i5VoSdn66aelF4H1xL2Id9eS6I2lnIwd+GIPyeJH +fW0cIM7l2ExllNpjL5jCFs9ARfknZfl/l4GK8k8C9V48A4VdWFokoFvdjni3JMpeLfIlQxoCm7/L +DQ2z8C6vpqq44P9HoNrqkY5zbRYu8PQRunXONi2Uo1fPzXA+zMRyUd0VDSakRiWax6+Cq3Bjb4LE +Cnp7Y2Wt11+tFzf2rJ8zMCjWI3yNF1cFFVZhLYAHd9jPRxzn8RPPNizMMXiPMeeY+ux+9dz94vaq +f1IodzcT0psaZyRMM9Gp/E3qvrUUTJptKxx6O25enSMeT7My5HbqujT7zplBOpVyClqw3BDzSueS +bnllCrrqtLHWQba7FmchVXt3zDnmeAEUdM+CZdLduRG0LiNr68SXcnddM/bFZcJswVj47H518LTM +xzJdj5GP11CB1cbDTBgFfh9mMFpCoMFosiHLKrbuPolYk316PJofZsI4xv28u6KvSBhfTMcHfTnc +Iz8drLNXN2tpmd6G0MSX3WjOhlx2f9tri7kWggvOQKWkmJj90R3ut0ppGVLIB50WcucZnt4Op/Wc +fAaY57ixROZMrr/2v6TkM2isqM8vE4T4Exgk1pkGxaYQGawkpsK0mTW6yKknZxboYmoWewGINWGi +SYtn1x/zRuHzxsB4HnVgfpFpps00z7CJXFSG603sevYvOdZ9mJMz9eOavnBOUvB+9mRH+O4PocbI +nrD0Y7ip/4y2iPMSO/i26K9BYmeYmckNDYcbn2px7MMoX2S1aRY3W/VWei9MYtVnklhIW4qnsJr0 +80wKy9jbOBIMRMbr63MWkykWpZVS3FWs2mowX2PeNHtI8bWiaE+lDLa0kKZzGn934RZYbbb2hOvL +oQgzMDk2Zxatb98WJx94jSPKRGatEjKTs/5wHKaPGq+kj9Bzfp8+khniebkT8W7VBXMnczInMQxT +WX4TxMFfaihEcBkXAc/oSRE0IxHAWPB+4kLAhf5vhNDeOIxEYJ7fEzcSAa6ztZk0YvTu9UWEsAjS +/zoezf8o8us5tFfTiPiH4gIpXswY0oKZSPy7VO+wxeCpg5fuYrF7aA1fZyD08iqLzuh9LrV/Mwm9 +8o3aqF48LmDTEC1jLGZsutp6wS0WFWXVH0XR8k2J2a3qIPH7e2gE1Yfz72IYVC5YjYeIhVE6aFxP +pcEvQvttxBRvFL+XjmdsjL/G4D02Vuu/28b88Tvv4T7xbhs77b/bxhqDfxV6nzPoDEMbe8VEmq8N +42ZhUb5oY3eT92mj0Yq5q5DYPEm8yqLz7yIfzmKzLPzh+7TRuBnNmJSU2OJG1bh7g2FPvY9pq9Gf +vHMYw8Q8z4D9y+LDmHx44z2E6+Tm0tLv/JOOLiIWidXTm1r8Hjqdl+eA2Iz8miQ6/tN77gGjZefm +nUbVuRu9N1p2+uPfhrpX56HO0yS2Tn6Ti3cmiXj3eunDVHdliW8VBFKM5YifMohO2DMIieGPt12+ +wIz2dLFtX/vjw4XYyq9uNlhQhdniW8ZcUPV6MRL7yrBoFaFq2UoKNA+2wunprTDfGWdlN6/xfbMW +nqaHAPtFBAejxGBjG0Pc/lwGKso/8av8jzJQUf5Jmc5AIQy2X6ccFYsDPdV8hgNnEuiplnPBJnWS +lrvAakUT2Bq+6xy6xwau/gn86qJe9OqZYGt+OulrsrT7o5YKclFlrstMHClsHGn8Kuaua7rr/mXq +R/7GLh7t3rtLbgy6FjAtbLzlc+bPUgjR7r1xrP8rjvP4KdMc60bE0a5vruV36ivrV/kb58vjzslO +/5uA4nbP05cy0XR9FlZMn5jRswtx7XYq2RgG25YAZOdYPNuAT7inRKv94VQAcBE0RHebZglzIw2e +aOEtqdhOjwlsTSC0d3VN1DiSsOo5F6aFcnFc9q5NY8BaDBG+61kBftRkcixnxhLfmkWwmnjacG6B +debPlVdzVGF+gfUfLK9Wll8ssP6D5dUiFzW3wDrzlvLq0T9byjqYVJmQ1l6/G88xKcvLQKn548kj +HsBau37vtl9p//KHClHFjwE/8IkNwkz+31AZUisdJbk/9P1+Sq30leWWvjMcF26vx7eDfnv4S10D +ElH13cHgXk3ulGvFb+re34+D4VjlF1BPBmq+VkthWuvV405vR7ede3/qeP3soFIvF9Q1NbiDdTyX +GC24B/hCHAWjbimGugP/z/6CX0eKoRnwz4TBvNwQP2dtxZCjh7N/QeczNH4C6S/VUg/U8++G2kXG +xwp1Nc8wQTSmxmyTqQ8KdTSXGEwllubYzFaprWHyjzCNmSZVqaUxz3Sxb3m2reYV4mmUWjaeYFq2 +g5+eQV3VBT6eaanE0QyHUdWEwzzLgzMo1Qg1iJqjmmua0DBNzbYNqhLNo7ZjqybRCKNwV4ZmMtuC +U0wDLgeXJ0SzbM9RqQenMk8lVLMtAnc5M468UnxBq5jO1Mv9Mci8O+j4avW+DV+q+Zvb+6560u4J +8RuvHPPr0Y/rSHNcx/OmtAEh1YgToGnb1LEYNExiOtRGHYGkqSXGZDuOg7K3NUY8hqOyHAqjBCHb +2PMcoILoTc8UfcYIChIuZaEyQKAeGrijea5jguiZRVCenmaB0FULDmOOkLzDHJffou0RSwW5mi5c +24QTkRPI0aFwLU9jzOaSBwr1TA91AZ8qmgfzLLxpw3YsdXYQ/z/Bpycge9c2wLhwPGCNnqeiNjxm +uZH5txVia7ZneCqIjVAIBg+cYsDRpmZYnqtWkEA8goKCI+BQ6IPqmMqAbKENyz74gsm4ec1SOA+D +2AQFBY7hovBdF5UD/uBZBNVneagUhkpyUbQzlApSUO6c4oHzcYqNN402Dk38jrccA0+0BZegU0EL +sizQa8AAtEeIhaFPIygf8Bvq4IBA4YbB9TtDqcyhgJVQ5nE7A6MhaDUeBS8EpTsoLvBX5lIcuU3A +bcFdpwkVJNjU41ZkwQcncOl44L+uBYZIQZ5gqhA1KNgs9KFpmJ6BQ4x1+JmeC7dnwogI4RZpgWK5 +u4EUYYygVsdBA4DRhe0Keotj2qaawyOFv7iaaTt4qusRHoBmTCX/zHgqyg+YXgohY4JmAKLhgdNg +rs0plutyIXk4EnAYE+MffkHio5omcDF7HorAMaSQDVAl+DABw8I+d1kQIWFEBsUpCueAp4JeKAMT +BE1aPCpSMU6KgQH1CLHYcIVzxwkVTjAhmCEBwz72qWuKPsYg6BMcJPRRTYJFnFJBQTCLTweEMpw/ +wES4RYKCrch2Wdx2mTR1lzHsYNNBPxRNGx1AHh90uD4tF/QJVzL4lGSDYTCXzxoQE7ALPjDts1OU +SkhhmmlCAMQASphHIQ5Y3F2gzwjF8IhXQsuepQAPmHrAZkHvjg1SVimqFbyZcIM21VlLyT+zHbSp +dF2p7IqFDCxr+Oohl4M1TrXd80+G7dt7WNb0Ru3/+Gq73x+M22P/Eb5Re0N/NB4MfXV0M/gLKXBK +cDgskI6Kyn8BfL8idA== + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/originals/SVG_Right_overlays/New_showstate_right.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/originals/SVG_Right_overlays/New_showstate_right.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,1594 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + + + + + + + + eJzsvWlzHcmRIPgL8j9gP8hMsl2iM+PM0I6t2bvQox3qMJXUrba2sTKqil3iDEHWsljSan/9+h0e ++R5IkHx9aYA0AqAjnqeHR4SHX+Hxk//tN18923379o8vn8Xb+Wb6yU8O716+eP/23c9vCHrzi9ev +f/zh/TsE/fS3P7tZ0u0MjXa/WL+Whv/w8t0Pr96++Tn9if54h5/+6Vcv/vjy5ZsXN7sfXr+4/9nN +T38Gf/ndq/evX8LffvXyL1//8Ke3f/nh/Yv3L79+9+q7P72//eHP3/1MXw/4jvAXwLn83Rz+LszL +fDO3n+eCDV68+fOLH3549f/hn0tcI8D2b3988+2rN9/t3/6/CLyZb2KAn/CX//rqty9/ePjPx7ff +/Hj/8s3737x7+83LH344vH399t0PP785/PXFm5tfvvgO/vLi5p9evn799i83+9cvvvmfE/Q8f333 +6vVL6OT9i/c3C3V594slfL3/8dXrb3/14/0fX0L3Y6kIjl8Tyt//ALgALf6O4Pr1L+4B8tXL9++B +LHghsu3wy3/6bwfg9dt7agfAm/l2uVng509/s/vV7379qxO8rt0ckE3/O/0V/jffpjy0CEv2TUJB +DPjDNRlaRPj8bRtwxMoNfvv3e88ZIgkb/vNvX373imYFjNR//5n09N3b7+9fvPufP3AzYHEM/Jff +vbz//jWMp/D/Nt8sGb/pb9IKuEotnsW13jwLJcKfYys3oVmbPl4v//zq5V9+fvOrt29e8qDs3r3/ +iidFSvPM3/kvv/3x9ct3v3/z6j1QVhDUeFR++fbbl6+hvX3+7vWL737QTi79Ozf43Yt33718D9Pp +7esf39OMX/UNMOrPX/z1JU6dhV/w6+9fvvnd238gGp/V5TZGYHNu/BOGJJb1pkQY3ZVekWbo5Xwz +u3fTyDN6RIao9B0wtX7yG5g/v4aV8+rNz4XC+vXfv3v1bZ9TNdys/I06cbu6f03/MbXQ8ffvX74R +6mEuH37p5uZ8+8uv4I2nN98e3t4j93/AJQcz4A1Mjtdvv+O/2e/0F/j4j98z9fT/r2GgfvPu1RvE +Of2K/rJ+/ZvXP8Kf/v7d2x+//8Wbf3k7/ZRFzu/evfgGmt38+o//4+U370F0CKD/9tWPr96/vH3x +6vuffRDRb16/ePPi3Q3B4cMMfP7qz/CXF0DKDX8M/tJhH0d6fPkvsPT7Zxl6evPnl6/ffv+yww3y +4s23N//44t33H0cNw/DOYaD/6s9H9PbF+z+BlHr55tsfjCz+79hRhn0c31ff4KR4d7N/9+MPf7r5 +3du3rw3t+CfDLmCCYvv/GO/4DX3gza/fMIPO3yQNtm8CgfAf7i3Q+uE3wB//I2M/vHj9+tV37158 +/6dX31x6wYW/25v4b58ysf56/8e3r1/9cN/nk4P85sW796++ef3yq7/+8P7l/YewITf+5dWbb2Ei +ktDp1L69/x7Vipuv/vTi+5eE8/2f7qjlV4Ywfw2C0Yu+Z88+IBNDvNm/cX//+3cvvn0F4hYUpv3r +H1/e/Bb+++L1jYJ/Nl0Gg7gHRN9O/zz9l2nGr2WOc5rzXOFZ5zbv5v18nE/z3bKAthCXtOSlLHVp +y27ZL4fluJzCHJYQQgolVHjW0MIu7MNhCsdwCndxjksMuJfFEivoYC3u4j4e4DnGU7xLc1pShCfD +U1JNLe3SPh3SMZ3SXQZa8pJDjjlNOecCT81rbnmX9/mQT/muzGUpoAEU+DT8uUz/l3amfy32b7n4 +P9Qag32P8g9II3bEOU/EFfyn34v8S/JbAY4V4Jl+X4l/+K+533bwbw/fdxP9OBB7D/APmczfgdnA +biQOvqAzoLrBV1z6L/9luru7O90d7w53+7vdXYNnvat35S7fpbt4F+6Wu/l0dzqdjqfDaX/andpp +PdVTOeVTOsVTOC3wLvj48XQ8Hg/H/XE3HdtxPdZjOeZjOsZjOC5A1t3hdDgeDof9YXdoh/VQD+WQ +DwmGLhwWIP1uf9of94f9fr/bt/26r/uyz/u0j/sw7Rfo393utDvuDrv9brdru3VXd2WXd2kXd2G3 +ACvuaKzu7qg72KEjdQq7hR3bWeewe5W6iJ3EbibqKnYWuwsdxgeRnE4T9Rz7fqD+IweQB434gJxA +XiA3MnEEeYJcQb7gMxt3kD/wNQGTkE3AKHga8WolfiHHkGfItdQ7c/51euRz3D7TOUh49Jhnf/5M +F4C78wc6k25+8vX+HfSp4FelZ4WnyQODWfb0wLwAPiBT7yqJjgoiAoRBpCdVWLLwYf5aa5tqg2dX +9xWmFDIRRuRupRWzLvCADFlBUKxphZW+0jvXuuJXW2EWrTDV1gMNwQmnRpsnWFogklposaUGwgHI +qw1at9Z29MD8bDCHcexoIsCsgkUIQgxmYoD5GGFWJpib2CmgjIYS1x+tw0DPQiKQnwSiMIIozPQb +fk8gFjM9hR7kQMHOkLBs8HM30S97fCl838v3Az2w3uD7CaUpzuZAcojeFQN+gQQFCYsPyEKQsiDw +wjqRsG0kcHcBFiVI3CN8P8F3Whgge1H6LiB9EQOKWRCkMCZoC1eSxiv0vYE8Jon8gLRBbvHyIf4h +H5GfyNdGXMbxLMT3BCMQgSLs6oyDA0N0hME6wJDtsCkMYp1oRDOMb6SxXkBe3uGqhJlwgFmBI9Bg +olSYNBmmTwJSAzB0huWPk+wI020PI9UATYWpmSeQ+wl2gACcn0E+nGBFHmB/2AFJK04+2DUy7C8R +mLeAyL6DRX+ELWYPg97SCm8osPkk4E+AkZwjyyVc0/REe4I8NF7HmR9ZbCJvDiQsDvy1p2dHT5uQ +cQdixoFmPi4bEKiZhGoiwYqiNZB4xWcmIXtHghZF7ZHELQpc/NpNJHcbyV6UvpVXI8hglMKJJDHI +Ynhopu1nEskolFEsH0k0o3BG8YwCurEEuyANLjztsc80/Hf9pKdeeqaL4PLIJ58/Xdb9s037mw/8 +wk+Af+Umz7e1xQpWMyAA0/frz0ew/wHenmYQnwGbltRqvIilBJjIaJKvsLSpTVtnWHWKsd7GtsSb +mG9bzp2u66MmimFpLegouw2ggq3pItqQ6pwRbQElMZETCfQlaCxol1tUt25AFevkXhkv0Lo/mqKt +GvBlFfruxbcvb96/vfnHP6EaP23+D0MVWGlGSjKIIPolVlBRz8UnkNTCkuv4C1I5TjrEc6N4LnaW +Pz7+gnhsIo38ux5KGuYvRDcDuppvrkefIfyUgf37dy9fvvFW0QZAWMUeMiGaTIjOGxGq4tMEqNNx +E2kVgXSMmXRd2UAPbuvs2yZsnCR9YYvGzXqG7Ru38T1s7A32+0x6wAK6AeoJO9heUd2IoJ/cwQ6E +pgRaImE++9paQucNSOZ3CZpFwQbL7C6Ieh3QIhmUbLQuTqZn7wcrAzTrSVTqZTA1jrQ10nc20prY +S1nsKjS1ohhi+nzC1+P6StYj2o9sQR5AV0BD4E4sSbYlzZoUzXcVjXej7aK+OzllN5GyW0jZXVHV +RT2X3uq0U9ZNG2mlB9JHWRcNpIVm0kBXmCE7mFcHmGd3MOsWmH8RZmIGAips9g33/j2oAkfg/R0o +CgsoDRFUiAzUVVAweC83BXAhBRDNcPxKpgpSV1lNJ2UQzfNGJvqOzHRRDMlYh2fCYY1keCUar0Sq +L2umiNObDa4jO1kmuGCOtHjuqFuzdC3Qm3ixZZ4bK1nKR/I8RFKrV9KYjzAdA+nBVTwN6mbA3rER +RtOSv2Cq8rSlCbzIdCblmGxIGnd6ULO44DroXzwf2UEQqffZLH+glj5MOilrpQV9FaSWsmK6YEtS +Tlk9RQWVVVRQUunDH7SVu+jogiOxrs1DvSNNHp9VtPsqw4sDzUPOXzgReFJAP/yICRuJkWIprDIZ +9oO/Bkc8mccGFHny2ox+GxiziRw3Edpl0sJ55fVVN665vt7YymT7crAtJzItg622bljyatttrUqx +K9mqZJtSrUr8yDqRUalm5YHMSnISoFlJD9uVgTibzLostIqrWJm4mtnS3E9npqY+bHLOYnay4cmm +JxufbID6hzgwyY8PTs3P/PpbRbjYz8UcewvvLRP59aL490g+uu2n/1ZsW6q0RRVZ6NX9n1x7E/st +aHxoTRRZDXu3EnAZZOe6tE3HOS+LbDM86WHKw3SHOc9bS5Itpdn0PtG0Djal2UWCMxlt7aPMYJ27 +su9MNGF3NkNPMid588m2+exk8zmStL4j6zGIhOYtqMI036EJuieLlLYh2IgWsl4jWbOFbNyVrN4d +GcL4dUJjmQznhUxp3FYyudFwza7TcSUP2150hSOI8jt0yZEuEehBlx2yj6QCufN4zdLGQsrIXo3x +05E3g6N3bYBpvzdHnrrwkpj3ixj0JzHi2fmp7s8itnoUG52doKfJDPOd2ONVvKF5VB83quNOhD2L ++644homlPuqN5Hs5ivQfvS5l43UZ/S4ncpEdyF22m8z9ssJEYf9LpqkTzQuz4Ewma5p9MUeaanvx +yOxI3q3kl6lg85Cak81BE8lJE8hRs8gq4Z31JE6bIzlu+BFPRdnZ0yaWqqyPmjPX+XL3gy9XPbnd +l6ue3O7LndWXOx1P5s5VX2735jbz5nZ/bnaen8Hjw96eyTl7Lrh6Lvh5zj09g69nQmfP4O7xDh/n +9KGnOb+P+n7U+8OzLo/2SzRXUHAOoUVtGrNr9DkND3Fqkh84Pp8YFLCwwENRgWkbGBB1Z6vwmMpD +k/wkzkV2LerMJr/iRJN6sel8tIncdALTzI3qWhTn4tGci+perKzITU6TO9fjduJqXMnViM5Gdjei +w5FcjuR0ZLfjkWbAfiLvI/sf0QOJPshCKlUiT2Qkb2QgZYtNI1S7eYLzvORJpIO7Yw1wcNybUJgH +oXBQoeD4Vs0nm87kgbFvEiGgYsCvf1378+Cm9bwUZ61n5HSBj56LSZy2gVzrnod7cd62gXlp6l5c +4xjzam8K8iqqcTaVmBVitLnvNvvEQXaKddglHh8c24TGJloE88dCY+Ju77O/K/x97h9YrOvgqTtd +nenjfOfZLrKZxgfHZkcid7VRCSVM4kLvI9LcaPBYsAP9RKOgU9gm78hA0sf3rLBYlGfZxHeqqS6j +En4nCrgq30DKJHq3atxdkfGqTNjEc1ZnhjoTFAdiMvtTdRvWblaSrzuSuQeSwyextGdTctjezqbo +oKqzm0zXwb0B9wjVdrq+k2iDMZ1HVB6UrvAeFrCsNPGzN+XpIGiPFm24M3VKX6IvCha1wNikvFPf +q++uEspcZSNkKnayQbISporYUTbRE++od6KXqW7W9bMg23CSJ8tTnMbWtbaVzaOJfuwGJc6pcfb0 +LwuasoHPGngUHbyaFn7Y6OFp0MT3aoo6TTx3XXwSZfwosU3VxrPp4zub3ncPauR7mdIUqtyo5IMr +6JIzaHQHqUauLqE4Oa/QKlNWJyw7hhbTyLPTyXViHfyGISFLl90h+R2LxB8LZXisFg== + + + cjyy92VwHCRyHJDrYJJsjz1NxJP4jdR/0D0IPFrqQzjSiPXsj8XcCC4HpIoXb2/+BO9RCObFyzac +6xC1Zr/CcVI3ngStF9nI1JunPgbvZWgSv9456Sbyrd5NLpCtwezuehhD2vqsEtxWT8Ru3fdnWkWX +lJWqy2YIlImzorssFnNc9EfcQxN9G8Q0ZfBEkO2FyKX8HedV09QddQPdieuPnUC61PpCC5O5fcrj +1hkMyNFGAsfA+1HRhyqMHreQvoHg17DOpPtJvDU9G4DdM8fJrbSHtou9W3GyXZinMpsdLMtuks1C +NooLW4VuFn67cOvQ7xgo0qdh29CNI7nNo5C9shXhO3v2oxifxPHuxt158HfiwTcfvthTl5z4+8F+ +rpYCEydRj9RSOg1mdDekq5hDakp3Y1pD3WLxTGZQjya1hrbPw9qbkLYY12pe58kCMy4084H0Bp/g +UHy0Rk3uiW3uQcVWy9sr2jtZ36puV5EC2QxxNsXFdFENfBFxMlukW7fPoz0He/bDwxJqN9E3Mqt9 +TH0Mh/eMKs2q0swqCftY4MeFfiaXZ3WwPVv38OZyrrq1Xk0NyC4DS2z3ycz34BKyFtUzXArUyVn0 +R7Pru20v9v0kS6HZs9rTOVjsye5JFxJAYIYH9yzumfuzScM6Dc9xfKbD+df+7Nk98LTzh3RHDoOc +5/xZxt8DCX8ftGom8VB83MDfWjejfWM2/mR+LV1qauakIYuoe7LUZN2aqwvbPZPLItqbx6o6UzUO +Zqo3+fdmDlWL36TpQgCH84t8CEeCOJZrpA4A7wIQJ8AkNuxJ5hb5AsSaZXuWHQJs1aply7ZVNvdA +6k6CaQy7YTIB0AB2rY+jryUsqwekuib6BbbOQKd6AmdQcOA/hFvUgcaEguuipaSCuszQAJvNKTdK +NymtUS4AmeZ45CjlueFLMoxMwBSAhXFbikKLtwFmQif0qlglxyXAzEQEoQEuxBjavOSh78tSC0KK +MiFg13uez00JtxHmiU9xuSZaonRZAeeAIJQCKIZhy9BXZEcj5HTOh7HFdovb2k1MmADkKL0uWqL0 +y6dTKreUIrQgc1K45kzdouYUmLXGMW9qCWsauNLIn4S/1JATjeiMbFFG1Ft4A6YtLc1lwlwX76ck +xDx/9eYlHXuyjJgtpGc7bY4IYDSMDwgc7IAAHg+ogwF5J8cDIoXsSz8egIbj1OP2GwvjJPZF3ITU +LhnzLqg25ZPYF1vr4nBmwqttcW7CO//UZMnHbWvJD66pbmd439S+nWUcTxctDrU5eq7Eodv6LlPi +LFcC/fzqslJThB1XOwkYOOeV2STdKlHLJEl0ohxW1B/YfXWSIB07rApZGDtxUMlUCDIZsmZByITg +MyOznBrp50ZWskudd0EnyCQpzllcDG6WuDMkaThFss1KCN77M5lN+ij3z0XDdHU5P+QpOJmnILhs +n3qWe3Cy3IOez65OIZtO09bd6WZV2GQbbLPZh1x2TSqYXDJ73liz3p49OQ9ScNbs1vN5nCiiG2Fe +oL2KduqRnI2BJkQ9to9NhXEyzO4QUZ8OmgZ/lMkwT4PAGCdD9zYtLlGlqL/JpsQwKaYHfILjtNhO +jP0mSt8Tw/J0IU9lFDHLJkVlSAjbOo3WedrKHZspXvRcniwXp8vkslLOzj4MfvI+WUbHh/OUo9sD +Ixc4R3B2oFA5SbA/yeRofzsJKj33MDyQ7VXtNBed4zqf4Zyudn5ILpoLVRLXaCLr9ofT9zCRf20h +UYb7HsuwO5imkfY6zJ86wpRcYCpiAm1T1xnMuQhzbYX5dagnmEwRJlHFENFhPQG1EeZGhelwgAmw +wLAXyvM4giQIIAEqjesJtodAI7rDVA231FeQ/IfjCazwMMHKKZRucUAv/N1CqXQFZuQOHVd3dqrL +H1H7nANqg7E6XfN4Gpqp08ePp30o6c4MU4s/TxfjcHqkxcfh/HGWs8Ms/STLdOEoyyceZKHwJwc/ +W1wni3tGi3ie6MgQ5xmvdLIowySlbGM6i3SijOM95RyvdKiJDz3hgShYTnd0bvFAKcg9nTdRftWi +2cVPU+FpKjxNhaep4KaCc1etZZ7JtwDaWWmNbPKWk9QiIfvz0vmWT/uYnGH5tJNZX3Kq6xNPpnz1 +9l/ec92gm3949d2bl+/p4NElaD+zrzyYlAeT8mBappkeYfPjWz5yQPCcTFlvQetMNzXegmIbPmlk +Ln2ehugxn70teQkJa+PEBT8Qb9b1tsbQPo2Eh9E8npKWP29mjp/8lIny+zdvXty//PbmOwHdwIqD +mXIRTNNRfDeb6gsXbeaLLpYHTObpzF6udkbGnwZfNjkTY9aEy5uYLKRbXOqEc7m4sG53uVQzi89S +gbaulnyWCzSEd8XNQkbxw8aMrx1xXi8iyj8tFtGLRhSsIdGth2rVINhI3pGH50CmRC8HwcUg6B+8 +804Oo+N5GPwXJhC5wU6g69lzPneOp84rnzsnO2RH4rofMj/ZAfMgh8xBvE90urzQ2RrN8+BMjz3Z +33y0HPN7YI+g4yN6pig/cHT8Gluy35Gna2zJfkeerrEl+x15+vwtuZ9d2hau2Jat2Bat2JascPUq +piHB2ZWrGFKbZ4v+9Zzm/RC017B9mVzk3sXuh+h9P6a+Owvgb0P4VCvk/HD6R+L4nCjPOuVYxOLS +WfPzQ+J5E/nuse84bcLfLgR+FgTX/PTjxUi4xMInFwzv4fDzgHgPiQ9BcZfULuM9jWFxFxg/fSww +PqpesPTbmj+k1MAmtrQyrxybAnmDv2DoJF3Ukq6FkKNuDeRXojjeOi+XkQVY43RKvOgvEoa6rDRe +D+WX7dlhvbhnA9jv2Ty2pEfvbbPYSZoXJYXIWSR1TV06Shv6IajJ+bY+6WSt/7q0N7LvlyNCFA+i +jSq5UlEcCdIyUU2SB9GRS96viVSTvUR+ApWD6sWgQCEhdaTHe3bkBWPXrB2fIsrMMxkt2aofQfJJ +VifLm12G5Nyenkv6ySRhj50lUmke7J1LftWkV0149Ymu66mNWVefVB3oUvmfTSGg6VPq/zxU9IdF +6Wea4RescNrwpy/f8aUqiUs6P1jy/2o7qe6lupuqiatGLmf9F7Nz48Smrhm7au6qwasmrxq9avaq +4Uum76ZwSC5zC16S1JQDx/fVQkS9H6UepiAsoF2Uy7bml2IarV1YUWsmObssWLbDx5W5uocroDET +6MGaEtdC+WXiM16UnnGsZ9fURz88ctjJ/e6fw/D4nK7jNP5X1HP3jIvcjl/GIQn10rH/8eD/aJjc +adx3svP/5fLxBP96kjIXKt2cKT2f8EyjlnT+0DodtetPUK4/19vl09ef9sun/fJpv/xPs1/GDBLC +bx0ZFrjP26LthAs6wR85BerifvmlmHi//LJdNy4AWuvVdnHF97e+l6fLm3mKoymEX0+pZ0+pZ0+p +Z0+pZ0+pZ0+pZ0+pZ0+pZ0+pZ09JJk/5Rk9T4WkqPE2Fz0o9wz33k5K6FrSJ2xdkhQmCx2YY6WHE +fDvjsa/PSH7Tj36hkd4uG+nNGenOY0cqsqrHpFuYYR1dzYhuVKsmzOUiRP81s4i0XjWova7LWu6Y +UnQ3lIfwRVhcUcTp8ZV4//Nql5ynFOQ7m0nwfeNc/dA1IOfl/D9ao396oBb/Y2IQ50EFkAc9HWOb +lHGWnMHXNnzM0/qJQnp6wNf62SJ6eigX6VxEc0bQh4pzBMv+OUnHP1Ceg5kwDWf9j5bpc16cIw51 +Lu8stacn9qzKoWI5PR+sdfmA+AXOlKVcFKOSGwKSruKJV0obWXJpH07S/UKEo8+1lHlhP+4aR4eu +nXROdCTb/KQf8bh+IcIvE+X5sr8VwHgT55O/9cnf+uRvffK3Pvlbn/ytT/7WJ3/rk7/1ybPy5GR7 +mgpPU+FpKnyZv9Vu3Vg3w6iDiEN46ZaEBw8ZTcOtCONNmONJo/EmTH+N23DUaLp41ii5soWLKxfq +7+TQ6oV6J4eUCJ1c9X0/VcYShtGXMBxmjM4ZmzHTg1OGD6LxbNG58qGZIvNkkonSpwkn/o3X0PX5 +sZ0d49yAmTHhxKBZoXOizwjKoWUnXYPVjJMgSPIjrmFcwRmGe4Eh1tL57ezcmHmYnH9pP8kaHi9T +yReLvY6FXneXb1SZZJk/dHvC+SgO9ya4W1S4LutueuhS2821tjqulw4ZDtJgelAc4DB/XBzsLMlT +5MH0EYHgRYIXCqNYEMGAM2C6IBicaJCpIKIb13ygoT/RssaBxyGnCxMu3Lfoy4oO4zxdHOa+SMeL +c/ooP3hLxmRD7S/OcYvWXV+8LT3K492Lj9KYTxvZv70iY7wkYxluG9mfbQUw+pMb/sfsB25HcHdh +uHswpk2W74WdYdgbxt3B7Q88EfDwxEFOXXxoKoDKgArDDgahkKKwkJJwgNFfYYUkUAxmUAoOILRX +Jz9OsH3saAoFeMuJJk8FSRFwhz/CXFmBv5Gu1TjANKgw8BHIwCs0djBEGUZyoRszdjBeGRiy2JmE +BgOSYSAWuhJjP9FtGBnW2wLM5nWGohQZvABzkbHIVpWgyEy9xpM52GUn8W4y1vF9ngPTHM/a5vDC ++YEFOaPwN2CXq3uh+5k+5HBMG/9S9y4NrqXpkY7GD7gZR7/09HkXSlz0T5NncfrAdRIPXCbx4UtF +pw/cKjpeIuHuFf3QtaKTXBwhLmPyD3qncVW3sRz6uKPDHoGOeWQ63rHSFR97utDjdLqb6FpOvooz +0xWcK/rO0XuNt4uIe+FpKjxNhaep8DQV/FT4rPJRbb5d5vZ5WTTy0c8rI1Xm2xRb+YK0IcXwiXlD +n1Uu60sDzOVybYOyfqge0XkceHOtDPnFP7C0po+sLb+6tnc4+QVmkeHJhWguVyS6eEPZJoK3t5V3 +mjQw7MIxY1z4PCo8VibaxIQnC+b1m2hWiwnr4eDDx8I1y/CbFjcayxzx/0L/3yS/RvuucZNI6mnh +mkeisBa6R5fjKfzbKmWQCp3LpXt0d5uaSNuqSCeriyT1kKgyklZF4u+9HFKapBpSpWtUdlILSUOQ +XA1J4tJ0MbjWQ4pSESlKMSS0elB3300Uy9lRHaQ9GUccnpylDlKim5KeKiFdoRLSYJ8+2kEh7onL +ZZQ+49ZYV0fnMPWKSpZbtb0z9vzG2PmssJKVVpo2d8X2m2J9eaXB97kpsTQWWdpNZ3WWxkpLl/2f +crnrUG5JHGmT84K6mktbj9qlGkwfq8P0UC2m7IsNDFmAH6rJ5KoyXa7LBDNhulCcqV9VdLk+U6/Q +dKFG0zSUafKFmi5dYLT4ShEXrjGCZ7pQssnfZiRz7z9TASeQGvNaqdpSDWm9iGzh5Lv5tgRJeVtz +anN4IIfueii/TMlZy0UlB8CPvjCDSz6ojXLJQqGEmIcSbzQvQY2fSybQYAQ9hKiYJcXotgldiGqw +p86qM3wszvfRKN9jA4YfDRk+hOhjscczVOMyg52NL5RZZlAG6LqgeS61DauCEoUorw== + + + VCYdXzFzeR5fDeN/9MK2Z2skXMw/DXFYOB/LrbxY2vOh1EoY42nQokc9erzIcUyo3KZUWkLlNNz/ +W+wKvnWonjLaw2ANc42c8/yvukk83RoYWxNjMDKmbdaX45Hn1aOTBSeXLVgG7uzEE8DZQ2lMF6TO +uWTJXu51TJk8WsrkQ0mTVS5E3WH0pWfDbfPhLidOjobXGUumISW37rbXQ2Oa1EKdL9JlnATcOZfZ +vL0hVVOa+XbUQCldlc64HOV8C59uweTlE1XhSaVM0F050QKmUaSzLA34dCLOJODFSudW7qCzZLZD +p47QkQDUV6B5Txl7mK63Ep13EyVxFmAXJ3AuPYETJvLxeAeyLYKcq8CUPUhAvDs53CUeuU/S7j+u +3E8f1O43uv1jVPvpY9kIl5MRqHPX7RrmHD/ctQumy8e7N3082eJS93jkPtEy+1gHp0+1zD7Wvekx +uSTn3ds4+vCNuEGCqtJKono6tQUuopMDVftRzXQO0C3aTDeX5Y2Fuq+FkS+0a3EhJKBWgZzAQxwZ +dnfa20nXuiEnHpcUTYgNGwN/l1gv7szXQvhl2/VFb962UOmo565nem6k4maoPZ774rep36c4T+aF +v1S1/EEfoSt65vyDXu/1uq+PIfg4glek/bGGrgPD1J1caMF1aeiWz2r3cQYfa6B4g/fQLZKGHM2J +VsVyaLPPs5cShFIXfJG64MliH2USdb1aDfC9S78/OY9XoH/JKM6O5kbLef/JKv+npPbV6ZqJfd4E +8DR6Kj2dnlJPq6f2zp8q9OcKHdUD3Z5yTztR3ylULo40bqjc0Lm/cBaQrk4+Pwq4t4y71dxUdgxw +c0V3pxmo/sJT0l9sXcy3EVQhto9agUWAv5SWxyJvBU/LrSS10brHiAaVK7ss7K+G8YvEaQyXxClA +v/CezZOTO2eHqiYX1KxSOdIHNEWcfulpr93ZAZ8F9ZqHDvgM4dbHHC/aUuBDvWVz3owomM4EnNKg +VPDZxOsJtwuVHh8p3P49c6Yf8+5Pfvt0SUiev3/jz0TTkeuzw6DRagWzbhmrKOqVzVXvwv3gur8e +ys8M/uKlxzl8SfBXMHyZ4LnodoljlcVHJfpSmu+jsnwflSz6gNV2IT3wMQmHZ5lzD6HzobnHJCdQ +asKjklT+I6PzPk2UhInc5bnRTd7IwTAcmhe/+fkv/gajdrsuw7XmV8f8iQtv/tDZ+0/59BctuHQx +QpAuBAj0q1eeDpbcyWme2bnqiySCckJopfj5quZBj6L3+uYSOtwULb+z2DlvpYvcLbRQFF09/3Ei +wyfKIiuy3IrF1vm2oVVi62pjcIT9QIuVd2ONtZ8mDd9xP/llIUjRYP6KckKcn0ySiAPxfDMR303E ++/g6ia0i/6Xvem1Ro4uL9AIj3vDZAjvIGePxO/1tsiZH97M/pwvPHXk/hkAljpvXauKgyx0HXU5N +46PV/Y7S5VX6wOoSKUvTR8xivcjrSJ7HB8onuFy0NFm6zDYRLZJPUtNktvV14kP1dSZLQMsXK+yw +M/pC9tkDuWe7SVzxd3IUOWjymeSeHaRGefe1fyT7bDqToZqAppJUZalKU5anLFF3ZLIdSK4e/Rir +7prs/PBqgbVm6SxHS1xZBj06W75Km2QxmSora0WVfE1O0Vu6dk6rPklWij82nzXfaiXXnU6cbgR8 +OK9RfSs6leDfdCEJa5vhOOZgbWty6MSS3KuJUq96biPPK3T9n8j/HWhC4XTa0VTiiRRkIvG9CUeK +XwSaPnUS530/6YzVLvSkc5FzznckldAnzsec79AfDqPdYISPWnD+b+fE+786wuWBhybwJLuburjU +0ZXO9rdxX7u0oR30Uo5xP1vcHubj17zA/Oa1isnIZuNOjaC7zVUC480APrdlzGoZs1mkoNU0ZLAM +eSubfBV/g9iYnjKkpUxDPsp4W9iYfjKknQzpJkOWyTSml1BqE3uMxgQnNuQ0zUkTnaJsiktPd5ok +4+lOEm6OLu+J3Ux6sRwnP7HLaUyB0mOglAg1DblQmg+16CyQkTm5vKijvKUfDpUDok8Hk//2DyZf +LZfksjNjHOXPHufJ5XN++UjDWE+Pqyj3gbHejPb0WbHDD4z39Ojo4UdHfGPJrnVeMBjWGmwmga7V +gJ0gruTaEYfOLDk0C0b0HszK+VJM/+mycS4X9sS6nmalOk+J7fK6hfdCOcWpujuzN090tdFsezHv +xJaYPW1ysiUbm1QEzcJOZAnplbSVbkNaxbbbmXkmRthk2diRNF/SfWmuserLtcR2FKQ/kuV0IhV/ +JvsJFWBUgRPdkFOwKM9ESRyoC+9ofh+lyhifSMD+B3kSVe1BpRjVYlSMV1otXF5K1WO6N3kmLZkr +TXGdKTyxkOnoLxea8qWmDlyNzOqRLXKGgdNs8kSZNuuQZ8OZNrjsz/NsKNNmNEyjudp57NQ4XWjM +PnySKvcqR9PFM1QrJcbsLgUctqen5IxHFE7WyezVA7LOWRbetjg8cHZKD04Nd0wnyqoZrdaj3S2t +Ziuy8iNlYTl3ahrOTXnLVW9nOw6npgJldhfK0DlPEgPTdRos11Uu0rrs/mPj9ePXZT3u4qwHr9Oa +PnKn1sU7tj70nN+/9aF7tx5xG9d0oXTtY4rZPvhMD1a7/dhTLz/TQ394oFouPaNFoqzV3it9ikKt +DjU3Fosdq5lhifCfeLX0w5dLo60wPeZy6cdfL33I04Xrpa9wwfRnXjEthx18AZG76UJxCV9eYltg +gkpMPNkef0u2xwMZEhk4EDHQ0TBENpb2LalS2kFWRRJL/ab6gCp6PZT/6XTScjFyAtCLteZJoeEN +fWfuwsuHoCUf+MJmrh7oI6WKP/IItN6ZWYfN3Od80ynoyTmiuyuaNnTZ0hd3G2YWr7Rs7eaZ5sPR +JxTmE/u6OPWzV5/tbnlNptbccubOeIB1bxnVd/4gK9c9SrSmC63uRut8Ryv+sMkuj5SJjNKhUD7y +5vZalLcTJVOLS1ZSqtkve5Cs+s7KSnrRjitSiqeWfbXord3zLaITO2z/13bJ8mbysQr7H77r9/wC +3wvH7T5cef/CUTz/TA/qlQ99HR94xJcop/io959ytvUx+86npYg/YteZrpc/LQdbpWYQrfuVDlf0 +ylLhQjWxgystVaU756WlqFsTGVnYM95TuX9WYYr6yL3sNca218pyd+Vi2Qn7vKk45e+W5d4PdaeE +ByeJum6ul504EPzgxosllzD9uaW6tsu7JBb6x3SExJX/P7jXfSHCcdNt0EvKNFzx1IokQvCO3XTn +xptVKWmCrwD4iFbwpRi/aIOul/bn+qUpjE/3BzzdH/B0f8DT/QFP9wc83R/w2Yrxvy3Cp/sDnu4P +eHKKPRWNf5oKT1PhaSr869/X+vgihuM570/62H86f3m7eKawbc4UnozReyuyt5PsynVTXrrYb5dK +TdPPacju/Fwd64ImGOToM7oMyGEghZLQCGA1SXPkWUFqlAVyJE2f1KNJTjiyawAtvSy1ODgr/uSO +iVdK0thb5rLlLRNlprpGq/Liq7uot18zz2cJ4qvnX7PQ2f1f8Sgg28U7ip8eJKx/ktD+bLGAHg3Q +QH+RtM+PB/s/Esz/WNz+PDb/mBj9JtTO8vsz5fQFMU1Cevrymok7Nj02lfJHJ2Y2+acSUGXgYfBf +FhOEcRrcl8ezNDaViSoVt5cokGx8wK8JM3jNdCZqWVoeCrM1PqJod4TCnwj0MdfhF6NkAZnLPN5d +Ch8IrXghhye5sEQc/II1KUK5LC6/FNOXCc+L9S3aWN/CCoKqwGEXw50eyXG+Ju9nGg9UbMpEbz1M +l0pEj27JB0pEo69gMp/S1jdpnqRRblwoFbWtSMvhvN2FWrSLhEd7/awyWXmonfMjjrHS5E7tcMR0 +R1kgFjUVKUryc6I0kkyxP06FapYMJfHTsUdfJGEuHYq+IGMeIWEeVgOnj+uBet/zfpP4P5Ys3RYt +vZSoc9pm+I+FS9dNXn8akna2aTub8qWTy+Fvh4sFTDlGtadZqdcY9WjVNl7FauzDl6FIzGrSoNVw +I0q/E4UV3G3c6lLkihVeqXOEct9LftZ9JXq1yTSO8zKEgkApCeNRco2+NC1CmdYA4uGi5LsOOi4+ +hAraIMvXumzSRaCDIM5v3Cn3gIGrhzaM66H8kIAGwNe/evvmN+9evXn/6s13z545ue3/MP3qe/xL +5L/85sX79y/fvQGB/tX/8+OLdy9/uNm9+e71y29Blm8AN8tym1Jd5We8KeUWI3ryM0JXf8Tumi3w +h7/Sf/9v+PV/APAvN+nmlzf//N/nm28J/offwo8tznsHE7w3zwG2edcA088+v4APYW/odb+moQDL +CfQLykGvldic5hV2HNwOa6FtceZ5gRVcpWJV5FygP7zAF8BLsa5rvgVDMzG9AuKf9Er6a7sAkY89 +P8eEoH+Bf2HFApawZa6gMtRKb1BYbLdLW8Pw8Usw/ezzC/j0PfQ54FSGjoIUpfcorCy3sYGd5z9/ +CaaffX4Bn75HadLPe47VcJtaXYRBbZ7bJZB/8xabvoU+VoofFgW5QeBPXYC4Mdhg0hdQt2rSz947 +kOescuESzM+GEZu+hKiBWaJjeu9g/JE2fPwSzM+HLb6BW5sxUZgfAP38JZgfgS0+fQ8IugDbAi6z +PFfYrjGGHkGwsaxOSC9WD5IsACm4BtKbf6EFN9/8lquPBFieXEiuprEEQherqHSzQg77Ih0/WXE1 +3/xhxzWPb/7iZ2qfK5eG7dJiurBmN9gQ9EeW+jVzYdpOXgnLUCUpcRla9KIQmdBLNheo59v5df/A +yA+rcQPzxF+ar0wq7PIL1b4LEcMfF3kr25GzaEA6Av1M6zBLRZpcmj3KrUswLzm2+DqtFZT9SPtj +XXhqQbtciNEN45wosDVhI7OJQ5U0cFcdRLhbypeEKRa62shcAblVe0H2//FKE38rjP08rTCESdhi +wvQCzC/IS8L9qsNPmyjIzj74g6i9IAYVJJ97fobpmsO+2Q/8FuHH+JIcvSCuL+wuTGhKYEWOtdBS +XtuonWoJzFW5KnlPTCgOpKPg3sF4XaRzSbyBeeq3+JTWrVbhNQ2PU1SXCyCP8ZKOgm/5/XRidRP0 +U1E2P0tfXfkv+3c//vAnxWPuhjD/bJpvdvDvD3+ZfoRn0EIv66CkgT5LoJvf5huQ1Akrfy7AhWeg +Eq63GMl34OcjOJRbvJiQwIrhEqx//M2EOihO5Hmhsa94LAwnKVhkKwn/WsBMoAORuHshxArwLzqP +HWo0LHIggkOD6bjmhOB4Owf4DADXfAu2n5ARYckDrMbbOs/VkfYNfr4gPTABCYwNlwYfbs03/Cs0 +BEMLcALZveFStw3/jA3nDBhD8i+H5Yk7cxmo9LyWHh2moS3uV4D3ZkCKzG6gpg8E6Ah8M1IK4Fyg +c0OvtO1fx+73to5V2hY75rjaaXD879RuB+ow/cv0+6nd/PRnN3/4R/iNJjWsgmFKfw== + + + bKYT9AbAN2GY8o+e8CuoT7frCprJGuaC5Xlpzq/zGlFMNAd+vgGH21LzSmCP5AGwIbnWzCfspYAE +BewJNoKciPIFJhdBYgL1ipuldUkMzLCj3oyUQct1rTjNGBy5e4gSzHQGohnOQLxS9Obiy3FAkUPQ +pigNKS1J+Jlv0VmNYPhthh0KgYUnJbeNsRCw3uJxaQa2BdbCgRDATEKfAINzWLRtTPKyPIcbbrjg +vk2wMgPh/PkGO+K8MgELTdR1bsst8D5w25UZNsPszdBAeZNWRoCTOiYhNpRSeEYAGKitA3dgD4YF +vQp7cw1RgHFZlFhMnWW8CI7KsNiytA1hFqxpLoogrEV5jsqtIcjVBjgHaQsbb1QEqwLB5FcK1iSf +T7cYiZOmaDIIsDMB5rwAF3QLMAHzHAwBrH7hIihdVTiD86Y04Tj8l1Dk2xRmmWEpZOZ4AQq0YzVn +7RiAses8ki0qgpayAlPKCmxKWO8YLDqb+a0G7sN6G5Yi8whELSOFyRF0coDAks83mNlFaG1JeNhQ +MZT3V5z48nmZXLguVvs8ZkzplF3086Xx5+FVIWQBNmQ8A+u68HKcacELgrpWnPMITI1HJsMij6sA +11Sq8HoNxRDAjNQhWBpLsWVe4CVRXpeCoFhQ/YzaW+I2AtOchdoIC1bwLrgvyGqe17njLessVFDZ +PQZi5pcwvFQGhluM12uHSxC8AE5J+rbA4hW8ATqahN6Q2yooEo4Jo8ixCrDEqKs8RENbxrcxWlil +uE11pjEwmggkmS1AULWFAJZ2DIbNQMidl7UICW3WAV7yGgTBkvpIJu0vSgcdCJAN3BamfcpNJ6P0 +toIUj9qFXHQgYLdPRadYqFXaVizjzhxH4S7AteoaKw5Biypo1sgErNDbVZpiyU4Bguaub2qz9gDA +0GUBrzJr1ltgXDxDgMaSAEF5MQREIi+dlcQfAkHdWXQeBB6ExjKnc5sRNBxFHTDeRAiYdOmusNXe +WEuhoMJ/DUGMtuEUADOw5FqVsQYkfytTYCwA6Bxs4ciAN+SmsmtRotakm+666CxaZp7qjLXxLAJg +l5MkEhlY2qrMxs1IEWSgS9vy5F5gjSfbbQLJKWwJpmARvsZCM2PBTTCo8MOw7EER6KsSbZcEykEn +SzVYl926KSE4tqIrObKIAWDr64VlH7wa2L82RxMjCOhp1sW5sNqCwKDrBeM1N/8kbdEO1p1G8MKS +C8km7CowEMi63lDS8LsiamG64op9PiMz/O6DwL6D1rJUQ9DmqGseT9AgED4WgikypPIgMNYqrwJj +QD4PyKISAKo2vwt+bWHLwgyDuUYnChkBICtNFwwKegaSys7DNZciwDQP+5ciKGGV3ubURIPF17Us +KMjglZehjSIa1mJ4q2ksiy4OxLvolJX9HlQu06JNPULgAvNH1SNjbQG5o4omZihL2zonkw/C2gpD +qlMu2PJGn0RcddKVkqQtntBR1rCmjAiCamIYdhcEIDmT7Wppld0DwCC3FFyyolBdGYV/iQJsts8E +9HUo3laTLMaIteMRCGpu0WmP5ZAFCNJw1X01KG9XrCyUHWEMrElZk2XAQMbOq25fS13t87CIlTO1 +6Of71r6koFTVaBtoH5uGUlDXDTD/RoCwtyuCWYFhrQYs2RD0KS5uWAanutSujjFsDUt0TGRgCTrk +CTdrRZvnJW+GBtpWVQ1gmJMAE2w/qkwtqyEoi8qJLLoFAFtcBFhgQSIwYAFw3akwwYIRBDwzPydF +wDI9kCFXlCzeUwLG2FTlIT1eEaTUhAWi5iJwjarOVelCWG5DUn6vqG8yAgBn5gGstsDrBoBgsEh3 +c2QxgcAY9FVR1w2AMZNNCFsbdyG4vUJUagTmpDINbFcZBQCnqptNXlkCY1sx47JpgwhcdCXgDVWG +gBQV7i46vgWINjBjBR4JEMSyUgAC1hC0mHUeiD4aoinV6LvIWYChpaScVeUEwHHVhUesF2DUFVJE +wUOsTVdISaqAAxh+FwTUGQQmJ6zJbmFgV3lghxDhg2BRLoAC1u9CRgf0wkO7RAPGGhQYlAPZbZgS +kmFwiio5aBtjYE1qhDQWiQgr+vkaDG0xk1F7BJuWSq2VxV7AJa0TqJq6FFDXViWA5gIDc2tC/Vxk +uuNep8u4mtxEmkzGGvHwsaUoAlHFARiyatIrGrFK/bKq1BCrnxBk7X0S5YYQ2GQz1QhdXYsOis3B +Asu36AxQ8VBMP8+s3SqCNahArqh2P1dw5MWBpi8rfQG3teq5wMBZVkzpmihCUdb0dcTADBaNTAyx +MQBIESdGmspiCJIpuEm9XgimbZ7BVWZx5UEdh6E6Kb2i0FC8xGdZ9cIb3EBtarOLgYA1WW91q0Iw +2urUCRK4CARTPvXJOVcB6oqTmcQIVrOJcHKLKIDtJzWVkWJpATDZiqtVVbTQnA3Z5lUR4OWZ+rJK +DI8zmyxdRhKCSJdyKgWRqY2zOYpszSFs0Zm4BjVi8fNNt5SCsoaBwRYeOtQESDEtGQQV6Agu6uRY +F15jAKw5etnNQPKwyUalCy+ih6DprohLW4BL0lGMPGcRGLVlw6r9iiAW21Z5XweYuhxhZEvmHgSq +7e92Cf58ALGjn1eFFhDUrDsKDREDG+778qbFPo+nFUULETsBgCkocC1CFewy4mpDpCkaAswhc1Lm +uYDBAtXdg7faCDtKjDpjI7tSI+4S6hugjzBadAHqjtJknwJg121IG2VgFmO3YKhPlkdE12MqIwGo +OgWZ3IEdVQhUc91vlAhu1t1WFUE1HaaIsQhAzJ3TSaTbVERRHZUu9G0K1qLSBDNKjQLVT1GYOwoW +m/TsiECsc1VtQ4xwBC5KK540NQR11jmrTo+I8t0Eosgd7EJVrTUX1bgiEL6qchWTUFs4jsfCsy5N +gOrJwH1Q1XEEz9GWXVYEMKWUAnFEAJAsZZkGUXkA4rvJrsqy4rmAk+idhb0aDAyrusSqeOoRaOo0 +bZ2KN5mhkWVzjZUHWjRU1uRipRtq3JxjBOh7N306aHgjVtuu3MpbnWcvi1EBwBBVDSpm45+3fa5g +m83kT2ZgbCo+xcuNwDxrVCGjbad4u+apGwPSUNSoqOLqwleZw5G2ZEUQojKnUbyOKbD9qolpRhTY +gkz983h0dtRcI1phqmer6gvA7lJazQDBuPGiDoW6sqKOwJhsa5MxB+AaVfHJtts0Zxs2sbsBmHLS +thIKiuj7TvVsMsLeWFa/TgVrU3dwE0UAgaYdkAA1BMvcNjNU4uEil5uRFVRYd78cgHNTn7aOVzOF +HJaIOGUAWGfT/dCq0c8X20RaXZWAYrsw7Y3ypqgKuanesbvrSOjJ5ASoqXkkZwzc91wjdjU937Gw +uw1oGurLiMRBgCZMsQnetGOgegYLu3oIQcIcqyRSQu32NDtnQMMZycC1zUUnt+qkiVKybHq3xh1L +3Y/YZyIAA/KJCePlAbAUmuiZc1DHEoF1e6Upo2g1yAZg1hrS4nU0sYsAqE4KtGuUWFQQZu0Yi1po +2bJuDCQcuWEIZm2YOpgwQq1yh/1PAFJ3XTdtAagmiCjP+vFmDgrjazQXfWEHOgMpbXOjCSFY9BNg +llIAwKDre0FvHAKT6fSF44uMAD3Yxu3GzsEkSjsBkzhtU7YoGJoKqlEnnOk62MJq7Is6Q6oyUJgh +Qn5VDqDlOdsWxpovAovasIkDXggMi3oybHEh1Dx4Nta9KXaK1eGEa9rsl6rKKIBTWGW+A7O5r9XU +6QHYzeWuMwGYbGdhbMnaNgQBBhnXypEvHleLgWFT2yubGIwAzHWxjaMp0trMFWMiOlXW7u1dzwXq +ZgansCEYtuDcdYPG/EagWs1JVgFsXbUq1mKrG8CrNlXBCcA4mzRdeK9GYFr8LqMIcmmKV/bUtJoo +KRo6XlJzjKXAMCPAMIsZt0lMS4AmCee6hdAoKUw5I5Ojmc9ig1Z1b+iDGBV5ttlZzB+PeWvFvEyo +nxGCjGXZVb1Swz8Hi8EVdkYz0PUWVwojALBYNUhYiNyzHNHXpiMmfiZo20xG5MoyImNwcFG8VUNz +iKCocRnF+ZTRVEgqkGpQIOiUqiGqNwCg5GQU1YIV2owRkKQTXOJKAKxoefUeKAJVUws76ASBeHUK +m4MMJK1OBI/azAgWTdtxMVm8DihgWwVgvQMav0coOauF300/TqM8diCZu1U8Yoqgr1zasJ4LWMOT +fZFiZ81XVETTR1oXdf13zz2+rmkwVrKM5XXFwnMi0xCvxoAkmowfLxprWdHxf3j445jSoWpY4lAL +NZzNuE2dKorncA9Y26CumjwTIzInzodl4KJerZxtTy3qdc+YY6FT06ZbwgMj5smInf5mTsWiMyNb +Nk537GUMfSmlfVMkAqoZtyz+se0cdXWJVZWzkwXJVJiMeprqt3E2BDoFNVKE7ZZFl2bUHeGhj+MR +MHmVRNhztvhT8SOANoQKaVW6M+5f6+JoZWBYlCxynTKCYkHPYoELxLqaIBEHHiJwLFw6gqU23RUl +WgbAUmcTJPp5UFaUgD4HiilBaLiydxeBfXWLNQTAHFXpDravZ+yOCrhF/Em5Wkio3MrHK+eN9InJ +Hydnp0oMzf8AqNKkSwAtXd3oNXYGwOichM1Qao5F0cwzBDaZ1VlCgghKKliWonNi7ejov+ZaK+zw +Z2BIOhto1PTFraneUSR+616szq7s9YDukxk+HqO+CQSijIR6VJCmoLO5Rw4QnFTSozh4LtCupWv0 +I2NqRpZeqSGPQHtXD8ogeNGcxip+LQQmZYuKntWC8ijTNTEgoxWsdsrad0tQGpKOncnklfdpGXn2 +i0FLmKEKRJtJ8bZSdF9oqjdBa0o0EC7KdtE40WDQexCv7XaLueoBDMJWl+TMLqSMAUrrbzHCKL1S +eqYKCoCrpPIVtqsYWJa+4WWBqX+guGgFojUDICfXsW6ZqE+e3hU3Wl5G07IYsAldZXZqmuYcADCu +OugS2qKGUQay+M+Hov2q4pIHYIq6tahlhUjNxZvUgimzm3QanEOkTZVEipwwMJtQ6BMcEdiUUf9k +mZ36LCmlS1k4Fs9dDaVT4Gz2ooF9aD0XM25LkhlafIqdqm6IGRPHeM9TehfO0FrZk6jbC7at6ikP +4hTCcwSWoRc5HRGBKVrGgU1xxLuq66GVoAhwiGV0RWIDsJroMputBPMJuRELTsUhbysD1a82TJnu +Ki+shjKwZBUIJc9JgBoMAwKCmu3Y1oaMfJLysqyrvMmmVzCLTq3W7iYhBCapJPWkgPpbdXh1jUNL +ihCsZlgogjUuuu8s1t3SvbySCIhkJXM8WEQX25a0cRNg20X9zOo/x1eZV5+AjCA6Z6omtACwp0dX +tjsRtqhbrPVZAODZtLe4KL9bLOZOYcsb35TVckYRpJ9Pi32+cfCy+ExGDY8V1OpNb7BoBYA1/adw +dFmASTcxSTshmIrZHstDtItutOSUfy7gXFRS00kCBWtqbGEPl6CQGDLzP1lsTRLt+Q== + + + TcnScnFbUoyYu6wbiNpViLGpHcoqSkGrSDW/YDmb8HHlie7g+PrQnNYi7151+yOfpZEUVBvUFH2k +SBxfhXMRBWkzQ2dtvU/BnAkmtvFl1Zw0HH8vicOXvAI03xzB6tAplp9aJE9zXAHJrZWemlIyd3zY +lUs297zs9gwsVZlazHuG4KXvPByZKqh0GQ9XRboWHb9gWnLJfD5llPHZBU+SeLSwr7IsMLqj2XLU +Vl3eRVw/0Bb0fHOgdqAFGHpApIjdxuCwZmOXxn9EzUbY2qShk0KYK2tJ4JJfVLKpxD2prWTbpeXc +hPZAFcGe+oUIegqDuP8QmDSFwUmhzJxjcJx1vHqemGarlOI0KEpKYAQ4eSx6v4rIKpyqKdvhrCPT +stmFliJVcJiaEiaJv1jFwKKDNpFBr8/K2L6bVbdNkwXEQOezr7KXVLfrdA8ogDUSWTj5jIFhsS1u +XRRBd4llc4khglXnoYaksK3kaHV7FYHNXDkokhRBj+ZmSVpBate2FeXVecFJaBsFWX1XS9HPq7ex +pwQgcNEwP4V6+fMrR7FX7/Qo1dJGezIqtrSFECwroqAHMds8lI2vWw6Wglia5edIrJA/j049nQRR +Ihx15rU6KFUATEUzJbofus4uHq0Nc9RVsPRP16T5LrNupRVdf5aPLA4H/HzRZag2OLa05RJNN69e +gyQBxee+FqdTxYUFHACBastH5uUNwNIsFq2eO2xaq6Zp27ENbGyZQPOqWHvqsgaoEVi0X+RnULQ9 +cWoWGQ3ANWvSaxOVDFsmzf5em+o+FfO3Nce3SICiYoRFz95QUjoDNeQs6eOMINhZJ6H2uYB75hkd +dUZg5LRFbss2JcBSMhXapCGCo54jI3/ScwH3eUiOEwNbSrKcAELgmiyHXrKZAAijq11LOmkrJgAq +y6Il1QF4yXoyKYtnE4DZToKJREVyFz20seoBM0JruVOajluDc6ppii0AQY9XBPPSEaikxq2/xg0b ++1kMJFWyEhKfVlEEmh+DmyFLRKRAokKY7S3swowXPWRHVrGOryZcJnXVIAGyASV2LguwLNawtf55 +O01CwQuZHbkKAQFz1Riocffk/EcVj19qdjuprDIZF00hJ++HzlA9p2in8QicFexe1s+M6XEUXAyz +DrejAM9A6cs0rwKAer4s8XEJkSkyBHZSCRouc0luajEQRlBoKpLcjzJi0bMYPWMV29oZQbJpBVh0 +3VIWpwgpiathyyV2mRiiDrfswCjnkh0DSF1QZj03GMxjRvI3BTe0zwUcJJk3dZnogTq7YU9okg6Q +vM7UbBNOJunKarn5A5C2SAZ2lQcjY7oUydR+rnug5LLGbn7ixqpnN9SPCsDFBAeF5lSRcXxIwVRX +Uf8jC1gG5qa8pSxG1QZz0+NSmuCD1sdiCFq3tWtZlVaNQKGlmVX+BSzg9NxMVV2NhjfwbOHhUeW5 +Z3AnzvVWvH3laWwNgJ27sguhZ0F2YTkJow4LdZMnC8OhG0RiNdAx1bBm0zki623m4pFMoIiZls1c +MXQ4mcCSRIKur8oCIWoCBrr0JDVQeKgetWAv08QQ9AnOejyNwjPP2KmYVU72YwvkGo2KV/JsAQir +XeaRZhWjw3Yp2i9LfEKXr3h9ormu0H0t59Bw7Kv6iymXQrBa0DKb4hHZznzGcZmUizKxWcBP3N+R +E1stOCi6a2RNnb2KwTJOIodQn3GEVNKGIk/gZxR3bRJAiGTtaDB1Fs0lsnNDo7xqikbLscSA8Jqi +MiEoWhC6itZ8ZxhTzspHCr0+o+hznzSq6WGcetYlkiwwAmDNXMIIKG/ECBQXZNRQJEblSxF+dbFO +SQRBwLFJek01PU/OYD+TxIQgfaUcBM1X0HM1keOWzwVMXZf+SgwfgavgVbsgSYSdgRZzwpwJUeoi +ew2fUdJGXzdFFi5mcsghtdgDHEkOtPLnxZJMydy4oacxwNDJIVjJV9VUFlqZjFYiCgCsQQlYxEEO +wCIHHWH7r3M0BMusCDRESIk3Ler0kgShYIZB5CQIRhDMNkFPIEtwl/gzIpiTzS6Vc5RjpLOeggAP +YsVsZR1FynpjBLMdSg8m7QHYNxadHZQVp+suWKpZtdBtNP0gSv6G8JBz7VBh1HVgWkPsh0SkbsBz +ASc5eR0sASBG8xdHLo/AwJSKIOhZjNFM2WgHEGMvbUDHpwVGo8HvN+MQk6iTLo9ZTnpgDnfVWUQR +jGeUrk0FjWQOqZxFcNPFsWgC8WJpfZF3dwHWWnXVGl97Hnrk1KhnlN2uHtw+NzHpXtIaIhuijGAG +uaNrhiJ/DAT9RIAaEkagDWG29DfEmxVvXeT0RrMzTJHzPBlYom74lgMR8CjbalB2DSIw9WksB4Ca +hW4BaPpcWO3AaexnVSofd2B2SYINnqvpVNleFZJb9smOBelBZMxZ450GjyoVnUTZihiEZOfhcf3z +xorAELQHoue6I1DROSkC2ppN28rmAUA9IghaiEyjkNwY9LOteN5KghGxn05Klvkb+3EdVFNU8FKk +mxFEy+qKGt7Ek11Zd2DN9g7RipTEWztjj1CJJIi6wKdqetAgctTtGZ26Uwsomq4PQE2kd6seT2pW +XR2Uhv6Mz/xKYFyUt2d0PlojgMGdxMKD53IOCsASCcBCA5JDGCyCN/ejzIEPeRACHHypCRDtSCVp +gMrDEJJWVdDDvZFPWCuCMJuIY7uEtkebhsmqMgRJ8Y1Oc6YF3KQcj+ShYrGHplNLTQIESkZZcAcv +sI5F5c0+WGx2ni07JGjKPlbo0FNUoSeKI1g13KAHDAgoTl9TogjBasJU9y6qESKmfGBnxHMFJzYY +A8c/FBxmHQep0YHAOSu9lZMeEajRg9AVaiyJQiluBBY1BsvCrCHpvsz6NJXGkdyt0I9ZzG22qFhk +U5Vr66hjKqgrFuvwUIxSeCubCtb8URdB1MwNrA4EE0+YU7U6UK+1JDKCEUSLmJqFfqHq0D9QOSKs +UxSc8yAEKZKUWFXh9nNRp0RLegKd5I+0jFoIoifKILgsauYXq5QU1iAGoq7ocwq4UhKak61YZjQK +0XsFZzsxIhnq5P+15GQhDYFZE2PmHmStjI3B6pbu/tueyIXAosmEs6VolH5evZgjqlA6imaNN7WS +Nz3QrhUzI5AyKmUs4KrhGCOiuPyIIAnmGAcImnMQZ4vYn+F9Li9MjhXkmbwXcLV03po1JFOzpg7R +CaZnEigKRYG6c5Rkel2xM1gU09Hwlea5nRNwMMrUKCtaDZTBqsVYFiT6ASydN1beKUviarIrJxep +L5cDUxpm0CBmshovhU69XXy/EgabyqoJvTQC9wpelLA6a45BSBoxteDeYlmMFDFVi79HMi0nY+Gj +Hivn9iRNUdi8Xuga0lUyE4UwsHIENpvF32YDitKMSTS5ZySrDoHeAUtWyZqh1PhQBROrJn8/5Y8J +Uur63lAl047ODqqHmWTcvYBzs6MUqHDoMcFeWoE8BM8vIxHsYbbCXpl1qHsBq2jv5zixDoHloEny +JsKWC0dhZ9aiZNWLSukPrWo475wAGaMlunN1pJjfK7hZ7QgYYynnIH6elf3d2u9zJM+pJuCXVQJE +8E35/GqAIv0xiECF6yIm3czFgZ8PYOgmu1We6+fPIe6jb4geKgBYUX/B0q0oE7FOc1gpGRdHEq+D +wV/avNCNJQtMHCrvGvm+Eq4ACHpdwb/DKyW/+l70urYEAmMZJNJpVjnktbRgY05hahT/WAiS7PFv +RMlYE9uts64V1BFAcbWyIkFUBI29gQ5esqo0wUJ94sPUQnmxNuGG7CpUpi6pv0jqsJCSIiJvYfmr +dM0zy5bZMr9nfBnqLmAJ9vJRFAVqCJRjMt8QXxY8/kZ8wYzNVcv8cE2iZY0WCF+iHHpaVtQmrZQM +BjDa2aAvWWrlYWsNIy6oh+AOhnhR07y5OGDfyILCU2G4JpHihOkZ9wKOawsO/HwDjmzFCM04ofDW +T6zNqHrzmtfmgMxKYAteXebbosIWI03pjtUDhQLV4uCF64YwDw5cMU3K+DUlDORRPiOMgDpEsHmm +sa1jjmG9wDEpQImvC6swnnxItI4b1iRDVX9ZKVTLswcdDAzEJFypIYclBAvRMLN8/UZWFaioxAk5 +BiRDL3Urgh0Ew8pRqwW3LL19QZdWVc9ksGI36NAsopLr+RMs1CUDVG0fpVBEXpU5cWHCZozu4K6P +0xq4wWsIZniOibtLLOUyiZWyzJA15Nbj2RBlYdH87Ws74haGUx0EnQLZI4UNaXTUJuCiWNQWvVu8 +4BcMFzYGU2K/FKsMqywhEDnl5uKQ4bL4cVpudt/L2M2xyiQkk/B+A8YQTCs3WkqRiMER7zX5EpXL +MCBzLkmRtqEtHs6OecDqgUIBI+jghR2eA9YVtY60oUCBKtOE2t7W98uwXuAB8ugnX//d7t3746tv +3r96++bFu7/e/BxAP/1vP7v5u6/ev3v15rubn371pxffv9y/fkn1pv/0u79+//JnN/8HNto/2OgX +R27yf8I/3Ee/n6gmLXpTsQARaFpUHh0UVCpXu1BU2RUcD1rQO/E+hbSDcl1ZspA1e78BW/bKPJuw +qOZZAuaFokKegDp8nDwytKX6IGVE2mHyfh09BeO8FZHQkc58WG8kQICMoBNrbX2vDOsFDuDo0enc +QhV+4ZeZCsmDUROoCPoSMyjvyFfc8Vk/KIHum0xcKN2Yy9l0iJq0yvsNWMqYMMG8iyPH6DQedw52 +q+qAyt05sRh0bTGDK6wbrB0oFDCCDl4sp9Rhnfl8wkiBAJW9Sq219f0yrBd4IOwNeG0T1lYGNVav +lOArb8DcjcTVqHcNRUpCx+qqdDedcRcUX8FMVVfuN2Csu2SOI64Xi1Ov2g7TSo4d9o34rUDlW8eW +UhJxRNmB8nplrYIDl2Abkc7sSh7fL0BlrZJqbX2nDOsFBghrZ6xgjdcLrHhXEN2XkCNdMwLmRyX1 +NdqVDng5AkKyU1/ZR1Vl3mQxnjxUsiSZXrBxdVVrUVVZXx2ozA1ljpu2uKzDssHagUxAFysMDRwU +GJHOfEp7JECAylwl1tr6bhnWcw4wb8HsbEul6zLmQFdhgNbdIl3zAoo9WQQYOl0SXZaQMl/yhTZC +Zy2YVoI44qHV+w04WSQXCwoXUhWa1EPhrpXCO6YAuWvo5dR5b21xzYW4wdqBQoEOjoIDn7IZsS54 +IHFLgQCVuUqttfX9MqwXeCDcxcQhlLCxkbqF1lXDvA66kyLS3WTJX0JWWO4aZ/FuRMYaMEnufgOW +0thMK5cbpUkniQaoc4rFIkDlbKpx2bSNUsRvwNqBQoFNewEHdkOOWBcuYDZSIEDlrFJrbX2/DOsF +HghnFzr7R7IlVqpgDzrPWodbfniaums/ql2dIltqqY1R4xXCbAgNYK38hI76tIqZF6U43ow1ptQy +IaCyV+x13xYTZNTiMaweSBQoAgWH22ihBkW69ABKJ0CAyl0l1rXt3epIzzjAzM3rWg== + + + 6QK2JS+BpMMM2unI2yCyoKLbgC5Zsit0RC5lfVvT0vweHC1zfkaVZBGxrxVsZllxHagGSFlr3rTF +OO+8brB2oFBgg2Ngze5wWIMGmh0BDFPWKq29pe+roTxjALJ2YQ03p8C6wvl1P53BejVRv1uLHTPG +4JIUf22L8VehGDuflb5VfC/xVk6xYFn24mFm3omN4VvynQ4Dyg7kt+vHO1QDFQ5nn3f97QxT3iqd +fob2bhrKbd+/0DzZPc48+b149xb17sGPb6ci14r8eDVv2+BDfEYxXVDURfaQ6Xi/AZcevsWzFqzH +rpYBa2UZDUj8tiwA3xbr5sWyweqAydm0Dhw4/XLEiheO1C0FAmQKOrWube+Xw3rGA5JUX24wUlXC +xKRJPuL9Bhw42Z8qOLK1j9m0zYpbznF1QO0YJ/YPbdFzmZpH2SHybv50BxfOIx1R1lv0Y2xeL0Ad +WSW1t3U96ljPe38tY5HzWWbpHIUl7zfggL4rLa8JOGQj04ov0Dl4aXNA5W1Z87Jpm+Sw/IC1A4UC +Za+Ce8U1h7XaiVlHgQAZQae2t3X9cnXcznhwJWOR8nKy+WgsCunAqEQE5W6iPCjkGOhoOnWWFD1Q +uYvutE1bjG22vMHagUKBclfBvXKnw1qs3JOjQIDKXaXWte39cljPeHAtexGJIBfryk4UmbsOKsdI +GNh9zjVk5S4XVjWgcrdFnbvWNssBhQFrBzIB+nmF9srkDmmxm5QcAQJU5iqxrm3vlsO65cCV7EXO +EltUE8bahPcbcOAckWdS+FcNs1ZlqRa5UMqA3DUqIbVs2uJZ0bhssHagUKDMVXCyoosOa7YkJ0eB +ABlBp9a17f1yWM94cAV7kd5fVxmyGjUVwoEDp+UyMC4KpO2T+yVOewUqZxeRja4tnkZVoGHtQKFA +OatgvIRh1nrVijXb8RdHgQCVs0qta9v75bCe8eBq9iLKK8phI/cUJvDfb8CBk1m4Hy3qvEtyYhQr +dAed4gRU9sZlPm8757qcYVWgUGAzX8Cwy8gRYYcVD+2ELQUCVARKrWvb++WwnvHgWhYj3v/X1IlD +RUbuz8B6pQYCU1Xzo/cNNsrqgNq3FHV4XNse1XRYO5AosOExsGVfdqypKyGdguQVlk7t0Lb3y2Hd +8OC6RiPuFK3J6NEJgPszsKsxv5hvAsdWWFHU0K7qrqCbG+dl27KGEM5QdiC9Xj/fwXq2wiEd5r++ +X4Amn8xfYm19pwzrGQO+4TyQf4PY1odMRzZk/lWsx5gtsuGtRwcunF/wjItF03kpH+XCssMt+jAZ +MR1rw1KWkm+bxJk/YHVAbz06cLC4s8MqZ7dGCgTI5men1rXt/Qq+kviGB6IofpHhSLcQacIEboD3 +GzAmIxQtzc0nIZBZrsx05yABlbFcMcq3xdK2K++LHasDCgWMoIODptU5pIsdUXEECFD5qsS6tr1b +hvScA9czHlGBKuLnp4Io9xtwJs8Pk9uoUhDyy45+gIIlOR8C5K41LDOZxrZ4oqaENiB1MHm/jo2C +Lf/ZI10s4c8RIEDlrRLr2vZeOaxnHLiW6YjV51NQw62oXd6heClJ4tVUOfWVpp3V0F7lfJoBlbd8 +a59vi+s5KW8VqwMyASZQkvJWDzY5pGAwrXLpRCdAgExAJ9a17d1yWLccuJrdGIvmnOCtpnnpzFVw +7qeLKh9U5TW9GnP5nKABlbl8Hnho2+Rky4C1A4UCRaDg4Iu0K9ZgZ6IdBQJU7iq1rm3vl8N6xoNr +mY54w4EE7yNn995vwHhXIDt/8IKCqCaDJtvR7QIDkPu24rYbN23pcpZ1g7UDhQKb+7MypzV9lyIN +HLkaCQguoOaIdW17tzrSMw5cw3BEqTTPGvLCU0P3G3DylznwBak06SSTGa9naGFxQOUrnwoc2mKl +ReWrYe1AoUARdLCWbHZYMd5S1g0FAlTGKrWure+uYT3jwdUMR1w6PWg1z7qZdXCyq2bxAg06GML5 +pLOyt1b1ExNQucM3hgxtYeMpyl7D2oFCgSLoYE3udFjpeFPaUCBAZa9SO7Tt3TWsZzy4luFIV44E +WRLZ5q6HmhJTNTETKYtZxTBfv2pA7VqVLIyhLdd82mDtwLx21nSo3tLQcWJtDgPq+wWon1dah7a9 +V+sFWLZ5ewVzEcnNTc3RYpqCB+spGuwFHVLaDHpOs58JNmvCnM7a8vVxG6wdOK5qA2vVpgFrbeGM +gNo6azutvWXvlEO5YQCbix8z5v417Dg6qK/zodtxDtxLv2Nh/7WIyabVwhLdKtYckJiRsSpobWPb +jG5+1eVcQXkFejvOgbuG5bD2ZBBHgU8GcdS6tr1f7pj7GQ+uYMcB0rWqKwcLCd1voO7WihW3Cwn8 +2K0ZeEJ6jQ6ofJ1DamPbjP7TJYxYHZAJULYqNOh1bQ6nZTT79wuQudppdW17rwzpWf+vZsThtReL +DlfEulr3G3C/bxTrY+Qm81jrBtGNDWl1QGbNLFcY+7Z5sR2qY3VAoUDHpu9mVMRrxLpwjYORAgEq +c5Va17b3q2M958G1zDi8KyQXdSvOzZirUEztjMLbkJIeJ1jY25moxlF0QOWtKle9La7moNE3Qepg +/HqTJgKNVgfI4Qx2F557vwCVs0qra9s71bGe9f9qRhzerNJ0zKjY6/0GnLkgB9Mbo0bk9K5G6BuV +c+lA5e2S8qYtAOnk7YDVAYUCRaDgaDezOKzBrhJwFAhQuavUura9Xx3rOQ+uZcRh1ZuY1UBVZXiA +UilYJjctGqmXYrd05UuOHcYda3Im1rWkaadeP0U5AE0RdlA8yG9lhxRn8HuYvj74PaxT6tr2Pjms +2+5fw4AjYa9DSOci7zfgfnKcqhZpDq7mHEO3QCWsDqhspWMp27Z0B9GItQOFAkXQwXopiMMarDi4 +o0CAylil1rX13TWsZzy4mgGHy2bRgax4hdj9BpxMZUWCqXAQAvWUIABbWIMDKndCKcumbTOd1WFt +gyKrrtoB7Ne+YA19c+oUhHEjU2qHtr27hvWMB9cy4JAGqlvDaf+hT14HnqteI8VFF8nYicbyNahT +hIDat1Y1zG9tG97LFTdYB6BZtwNYi1wOWNd+E1anYLXI1kCta9v75bBueHA1Kw5LlzUdOBitPnk7 +mEqaCrBYhK6PfBVNNI57SVnn87Z8CfUGawcSBYbAwFKIfkC61nL2foTppzuprqX1qWPcdP/fz4bL +IKLWNTn75X4DlmvxnnHlQOlftdo0WLvQAnT9bCDWRMytbtpGd+RasTqgt+EcWMqljVgXLgE4UiBA +3kA7tb2t61fHes6DK9hweC3OuogPJVl9EwfOFvvHW1ZCz0VrepkI18gwIPNlkTJRQ1s8fjunEasD +CgU6Mgq2qkMOaejM7gSEfkDeExs8C7VbhvScA1cz43IPEyY+nXe/AWdXGTO2ItZD0vIbWKV1Xh1Q +ectH+oe2wQ5EG1IHS+7QoAPHfo9ARxqs2pgjQIDG27Zt63rVsZ5z4FpGHJb3LE2NmGycVWDmi4SZ +2lQsAmzX5cCotg5TxnK1e98SywqHDUoHpJcrWxXYdSuHEnOypVxMf7sAla1KaG/rutSxbjt/NQMO +L3OygzlUdu9+A85c6vSZXG7UNKSs9yugFF8WB1TOcqGqoS3VaWwjVgcUChSBgq0KqEOKtVysSK0S +IEDlrRLb27puGdJzDlzLfMNbrizZjCTS/RlYgui5OYM52v4B08/BmC94eFHj+tpykYutHcYB1qWk +A0cr6u5wBr5zcny9AI2vrYSxretSx3re/WvYb1Q92LJ917nXIupn8rLc3YH3eZW46Hybla1LXZID +Kl+pOO/YdsHKIXHE6oBCgXK2g7V4mcPaS7Y6CkIv+OCp7W2H7irWcx5czX7L3YsX+V7V+w0YfXNN +yVDbttg9X/O6LB2mrE2WM9lbUjHlAaEDysv18x1Ml6eOSHu1Tvd+ASpn1bDWlkM/Fed5569luOHY +UglLwjzrAcoRXK3WFR3X49FNi10X11Sz72f0yuySTLUtSsSkUk6xjsBZMxIHsDqIB6wlt3BGAQGN +t0ata9v7ZW7nMx5czXDDmmFRD+RTePf+DKxVMxFoe4Ab+R7SJqB2rkVNgvRtS6tnWDuwx50HsN32 +67GarOzvb13UdkqtXe+Rw7fp/WPstuVfL5GyoK/FmS33AzBrzT+6k2AVZzvvZHZHioCID1XvZnPt +NphGI8kgGB7lKwEdDqyUv2xexjD+ZKfKWhrtHeG2j9c6ZAd4i6U60KXN9xtwtpQxJHXNouim1PRa +idKiB3K38OY9DWJY28ilEkesHSgU6CgouAf0HdZgl9A6CgRojBVqe1vXr471nAdXs9AKrhUduGhH +ahwYbzySO1KwCEfUkhXJrv0oi5XHSeq9xStOZrWKra1USB2xdqBQoOxVcLQrrhzWoBeSOgIYpsxV +Wq2l61RHec6AaxloeEOI1XcLes7aQTOe8NMbRtR31S9Bx7tTkgMpX9OsMR9riUfwa9jg7MDkVnOH +xuGWmVnNMbrn2b9eQMbW1XJ5paXrUsd51vurmWgVZ7cqoSSW78/ATQI5dZZLwHlBF71MKpXYHFBZ +S8UrxrbBtnOH1QOJAkXQt/4kx8gc1mCFch0FAlTuKrWube+Xw3rGg2sZaZWks5p/mPh9fwY2GnrY +3C4hWrBuRXBAYc2mWeCypx6dB9GLbcI39apksZF1As96f1V/qwCNn0Kha9t74hCe9foathneBhe0 +kM1c1DYbwG7v4vu1aaLJtYjYr0WtOKsxSRt100CRtQ14d8gWqwcSBcpUBXeVzWHtV0k4CgSonFVq +XdveL4f1jAdXs81wA61RM1pXVQ0cOPV72oBgqXaULMcDb5xCGdaByl4Y9PO2a8t5g7UDhQJF0MH+ +KizBitUFU9hQIEBjbzlr67trWM94cC0TjYSRuoop5eB+A059Y8faitWYE3XqUF2rDlTmwMbeztrm +puWGnGqhwOhyIQawmM8OaeScxpEAASpzlVjX1vdWkZ5x4Lpn6oZRxpTM+zNok6tu6BY2816lqLtI +9y4QUPmztLWete31WQyrB66x87dDqTLuiHSY0t29QEBjsPnU3ETt3TKsWw588Zm6RxZk+ZAp+Pt/ +s/oswDxYAev2hJ0HWyWVuTaLeVrNlbliliqraa4+y1zpZt110za6Kh6GNboqHmYuerBVUvFYreaK +p8DVZ/HU9rauXx3rOQ+uZDrOFSMuFv3R+iwezMVUsGOr5DZZzRXsmEbgXX0W7FgOY8t1kVLShtBB +XHUWD7Y6Kh2h1Vvxr3a1WTyZrm3vjcN51vOrFfKseCeOWsNWm8WDrYrKXOnyeskvlePL2Dn45ouw +KF+j7Jm97TrLNZUeqwO62iwebFVUPFart+IpcLVZPLWube+Xw3rGg2sV8oQhzsGOl2ltFg+2KipI +b5m1rK/UW8G+8U2sQ20W5EOoY8vVx4kUpwO6yiwebDVUOk6rteLf7uqyeEpd294nhw== + + + 86z/V6vjWbHqt+bJaF0WD7UKKghs66oJ0FxrBXDicf/mgMpZzaHsbddZa607rA7Y67J4qFVQ8Uit +1oonwNVl8cS6tr1bDuuWA9eq41nxDo5V9Qh1InmwVVDBKcJXCblaK9g1rTDq6rIgG+awadlcvT3D +6Z1mVpXFg61+SsdpdVb8211NFk+pa9v75HCe9f8aNTzx/bMa/laTxYOtegoCqwUnpc4K9kszql1N +FgSrdeLagqDMWkHPsHagq8niwVY9xWM1M99T4LwBnlrXtvfLYT3jwbWsR9oFupGmNVk82CpC0AxJ +OuukzgoC9YCxq8mC4Fo3LZsrhGw4my+arBVZPNhqp3ScVmPFv93VY/GUurbV2a6G86z/V7IciTQr +aWv1WEawVE5BIMhxX3pFgGvzRVq0b8XS1V3bsrZ2hrUDrR7LCJbKKR5r6kpKpyB5JaVTO7Tt/XJY +Nzy4qu1I02TVGitWj2UES/EUpEVuPmhaZYVm1KLRC63HQv0L23a97KpD2IFWjWUES92UjnJYTfpu +V4vFkzmukrVf91HyGfB/iVosM4YpbAl3S9GBrWrKXFar7G31VWBl2IR0tVhmvOFrTnnTNsr9yAPW +DvSWogNb1RSP1eqreApcLRZPrWvbnBQ2rGc8+PL8T0Qq9380V4vFg61qCpLab3iQ+irYrc5Bq8Uy +06VsWl/T2uLN1GrYG9YOdLVYPFjLpnikVl/FE+BqsXhiXdverY70jANXMxYL5qCqd8FqsXiwlk1B +chc5y2z1VWa6dW8JDshdy7iatm3BYOhXSQjSDnO1WDy430XpkFp9FU+Aq8XiiXVte68c1jMOXMtU +LM1ftSInrD3UqqYguXOOvuwKd40viR5qsSAbtM6bawvrOWoMx7B2YK/F4qF2+tYjtfoqngBXi8UT +69r2bjmsWw5czVYEGqplz1ktFg+2qikzXi+ZyliLBfvWsp6btFosyAfQl9KmbZZb4wesHehqsXiw +VU3xWK2+iqfA1WLx1Lq2vV8O6xkPrmUuAuYkt324WiwebFVTkN5VznpafRUEznXZ1mLBLqux4Npm +vHM7bLB2oKvF4sFaNsUjtfoqngBXi8UT69r2bnWkZxy4hsGIUqlauUGtxeLBVjUFSa1yS5fVV0Hg +sq6+6IrytST1/ljbAkazBTEVawe6WiwjWKqmeKxWX8VT4GqxeGpdW99dw3rGg6sZjDi6VvvVarF4 +cL8xsOB9aLM5YG3awhAGB1TuNKl979oW9pqPWDvQ1WIZwTFYW8Ua2aIcKRCgslepHdr27hrWMx5c +y2hEGmYzNGzuemjLQWVCDtFKYythKfQDCX1BxkUD5b1liDoZHcoOzDZvPTQsWaeo4tRCCP7tDNOP +K52+Ze+QQzn2/VqJoERssPstimkJHiwHRakTZibqzYrYh9iKA9qMyZrH6drWbCd2O9YOHFe0gaVo +yoiVq6uMBGgdlpHW3rJ3yqHcMODf7QzfjGeBkp6s6DacA1vFlDnDDtPU1JDaKrCk8A5eDyRm5Gjn +GV1bjLCpHmdYO9DbcA7ctSuHtV+04yhwdVg8ta5t75fDesaDK9hweIJNrsjrdVg81CqmEKWzBnmk +tgr2KssBcleHZc6o92hsztoGuxLUYe3AXofFQ239O5z9Zkn3fleHxdPq2vZedaTb/l/NgMt4d3rU +vUnrsHiwVUyZMxaonEW5lSR37FqJdrOc1mFBNvQIt7WNtjs5rNFvmlqHxYOtYorHarVVPAWuDoun +1rXt/XJYz3hwLRMOMNegFSW0DouHaskUpFazVK22CvasRo38WB0W5IIqVq5tdNXRFWmH9TosHmoV +UzxOq63i3+/qsHhaXdveKYd12/+rGXCAOa2qIlgdFg+2iilIb02q9UptFeyb3gDn6rAgH1rUsbG2 +8IqmR6UMawe6OiwebBVTPFarreIpcHVYPLWube+Xw3rGg2sZcIBZK+30OiwjVIqmILmlBL19Y1be +tqS2h9ZhQSiFJoaWybJIHEoPNCXYQa1iiscZ/B6mrw9+D+uUura9Tw7rtvvXMN5I2GsmoNVh8WCr +mIKk5qoeA72lMWNlWq0cZHVYaG8J6rOwtvir3YWoWDvQ1WEZwXL+1mO12iqeAleHxVPr2vruGtYz +HlzNeMNlUzRp0OqwjGDo5Sr96MX4JW0YgYtUoEs9xZhW6aKxUGubnc5qWPOgyKqbdgCLZeuQRnMv +OgKic0U6Yoe2vVuK9IwD1zLdcICDSh+rwuLBwJqlqrDVa6fQHxqDAEPWMxhBExGpx7Ol2WvbjCX/ +1g3WDnRVWEYwne0Ysca+PXUK4riVKbVD295dh3XDg6vZcEjbqim+VoVlBEu9FARq8cTYd4diBcXj +uJPE1s7b9nJWDmsHWhWWEcw1U0akq415f79WYRlJ7S17nzrGTff//Sy4VPDMp8+WvN+ArV4KKNyw +iLU6plRWAeHmQnNWhWVOwZRR1xaUfrBYN1g70FtwDmz1UjxWq6ziKXBVWDy1rm3vl8N6xoMrWHCp +WCF8V4XFg61eCpJa82zZZOxmgG6l3DyQuxXxdvVtW7zIW0uTGdYOdFVYPFgLpnikobOlE+CqsHhi +g2ehdqsjPePA1Yy41AOErgqLB2vBFCS39Ls9uLIKdi2nFh1QeZsWvcPe2uJxHQ3tKdIOc1VYPNjq +pXikVlnFE+CqsHhiXdveK4f1jAPXMuEAc1r0xl41jx3QSqYQtRJ01Noq2LEStXSpGRkp2iW+vSVe +Pq3RTUPZgVaFxQO7ZuVQWmUV/3ZXhcUT6tr2Ljmsm85fzXxLmIqrN1hYFRYPtnopSG7OGvWRyirY +tX6VoFVhQTboNfGuLd0OXTdYO9BVYfFgLZjikVplFU+Aq8LiiXVte7c60jMOXMt4A8xzv+VBq7CM +YAmfp+zM5Wj7x2r3qUXbPoDIHNexJR7+yHXE6GFOSnaw1UvxOK2yin+9q8LiKXVte5cc1rPuX8N6 +w+1TLq5wVVg82OqlEK2L1oeWyirYrzavvtyK8rUf97W20TJ+HdYOdFVYRrDUS/FYrbKKp8BVYfHU +ura+u4b1jAdXs95S9+G5KiwjuErqc8Kj5XqnWOGjidS5pvGCoscYSQKmms/aggKzbrB6oJVi8WB0 +BVRFUCwHU60GR0FyFoaj1rXt/XJYz3hwLfsNhzipZWnFWDwYqFhV2Koyjr7QqOT2unwEVN6szTZd +bYtZqWa+CdIOc6VYRjBoOrb+m90+vtZlQ4AAlbfdcnBte2cN6xkHrma9IRFJy1pbKZYRLGdlCbj0 +WBlHglN2EW0rxULgpGfvfNtZrS+HtQOtFMsIlkoCI9ZWzt7furztlFq73iOHb9P7f99SLHPs7hZv +wTmwFlGZI2qdQ5mVOUY7DW3lWOaIiv1QtgUmhiWodnQd5i03B7ZiKh6l1lzx7+7VWTyRvaV3KRnK +s45f65hdxMtvg+YvaoUWD7ZaKkhuapoXJVVXqGdyet9VaEEm6Jl81xZP+qu2Z1g70FVo8WCrpeKx +WtUVT4Gr0OKpdW17vxzWMx5czXqL2XmbrUKLB1stFSLYctHkGDV2LhUtgGMVWpARqarFbG0X1DCX +DdYOdBVaPNjKqXisWnfFE9ArtHhae8vs3O2G8owB1zLeYt6USLnfQK2aClKrfi2ru4Id61LDarQg +D0rVM4PWdjmv++KBya3p5byeikdqlVc8Aa5KiyfWtc3nlV/OOXA1Ey5iqrKeQrcqLSNY6qkQvb0E +vwQHY7cJXJUW5MNatcKptQ1OLTGsHmhVWjzY6ql4rFZ5xVPgqrR4al3b3i+H9YwH1zLiAPNqh6Ws +SssINhp6UF3PWkXyUfvSLdyz6LYta4urU9U441YHWakWD7bKKh6n1WDx73f1Wjytrm3vk8N61v9r +WHGAFXSMbb2WEex2spDXsV4L9ksrqLl6LQgOdVOvhaYcrpsRqwdavRYP7nqdw2o1WDwFrl6Lp9a1 +7f1yWM94cDUrDnWVWf0cVq/Fg62yChG8aAKl5oJEVCz1Ugqr10L7iyVQurZ6R7zD2oGuXssI1soI +DqvVYPEUuHotnlrX1nfXsJ7x4FpWHIklS5XUei0enPo2jz6loFsq12DBvjVLobR6LbRWV71jyrVN +q9YV8orGqlWFes7EAObSKh6p1WDxBLh6LZ5Y19b3VpGeceC6Z+6GUdZ6LSNUKqsQzd3PxTVYqH/m +ArB6LTSnTHt1bcEAKBusHmhh0gEqlVU80mFKOy/I4myIfi7cTdTeLcO65cB/yHot7hjel476WcEW +vAVJjTiai/cbcGb/AQBxu5yr1p6Qu5nnaDmBAsQhWJb/n713XY7cuNZEn4DvUH8UYe/YoJEXAImt +XyJle3wObTkse0YRJyY6KDZb4oiXHjbbtvbTn/V9KxNIAEUSqG6SVeySQmJhAXlfuXLdU847U7rh +t6ZF7g47qDUHxh4cHyi4PzgIPhmBu5wvxgjjbkO0NqZrRAYdI5C4wTi11LH4bRmQSCB5rCaEyYBZ +x9bM2IngDHrhIfngRTAaZHiVZkIF2oB7QYW70oHYFJohYMaUK9CqL1RA8n69qK5skTCO9YJfsDEr +UgmzJaWIUGmaeh10dJIPGJ1edFEiS4uNOV7oa6UzEbA5u7RI6lQBI1fTJD9Gp7pCvA8Vh4y7tFJg +OPwMLYZgS6OkX4F1hVxJVvqSBC6G5iBPDIDce8exAr2hwJY4moUTOiEYt3hh5WxpO45YIzWikpna +Qoys7FycwCGlRKSlS5cryiyknNoyX3WrwKhy17m1GrkbXB/CCYSKhmZZh6how0JG61JABiDDNFTT +RT8mNmBsVvkWWV/2/CqOLdpWBEwfWf3WaBLKADqvohQ4RhWFBBGFDYzEte3sMKGVs9UTf5nfpfNQ +1Jt9y7ILl6yy9INlHSNPsGh1vOFMxltR34iFcLUm0xJkrGwTV1LO6rQx4bRg4qJ5uJQmfC5rz0Wr +IyYKxxQUZ5IeWH62Jsn4HiQp7cnW+pRktlW9Ztul/Am4+FwZdQTPWoo1odaUNWdxVmEn1LVN+QDa +UpNB6FSXynxj/k3aYcSC4/WrdcKDoO1I8lff/Cm8+f3126Pbjx9+FnJ+d357DWAF4Ju/3Fz/VWj+ +nZD9olDw0flPF9f5i4O/vMcbU+qr7//nH/9wcSnVHPyu+ynnzO9++PPJX27enuPn4AC698XXq9/8 +++ryWl4V0q3bix8/3p1/wFEjZ9jt6eiLs58vLt/enl/jvV397k/Xd/07/O8unmS/Kb+Sg+wf1xdn +AkznWf7hP08vP+qX/374w+vTK36HTrBX2zqOX2eP49cXGIfs59kj+dfF27ufZ48mfr3VI/r5/OKn +n+9mDyl9/uxjuvnx/5yf3R3dfLx+K/07unlkb/QDfMf9L5/efZg9ykGZZx/qN396883l+59P35i5 +Y7x4m/HG94wJ3/znjB5vC5m8+3j740fh8M/O586CFp25xKmd5yaaIqzPHc+Ppx/O/w== + + + cHv+fz/KJMwnoaNSzz7C65vv7y7uzh6hkv0oP/Drv19cns/fn4Myzz5CO3do1x+vvju7O/3ngpHl +RZ59YNhyc8d2e/7h4+X8cyN9PocC3dN180DX11O/7BA4/3tOTh7u7APz/swLcnE9dzlu3p/fnt7d +3M5ekL7As6PZ9zcfb8/O/3h7+v7ni7PZR9wjU5GfdNdbvncurh8hIYPB2BfcNcc3V+9vPlzczdk0 +T9EB8mGPtv27b8/frb7eS3vbMY69tLe9I9pLe2tGuSXSnv+Spb13t6fC9l7+5ebiwyuT92YL8Xtx +bzvFvdn7ci/u7cW9vbg3GdVe3NuLe1+MuFfY1yLwLRnJlot8/tWJfAtGtCsin8hBR+f/PL/8/ufT +tzf/+rJtX3pkUix8LQfmj5cfH+FWPgOzua2SwYe7t9+e//PiFB1aIPXkhV6MJ/jj6ccPHy5Or490 +AXeFl569Nm/nH8NvX+Icnj+Q+afw25c4hpdQgG2nZjfv3n04vzt6Dpr2Qtv+O45whzb8JfgWeAme +3Vze3P7Xv35WMWYmff71cr4qMX6930CfMJYP78/Pvvv4yH7YPY5gtm/Ph4+3707Pzr8/O12CeINC +zy91zB6cLO7Hy9Pb45vrD3en1/PXbVrwBaxpS0f5+3+/v7k+32CUfcFdkk2Kqixnz9GWqzhMuWAs +263kKOySsfz37LH89wvyIH+9ubi+O4nqi5fQR55/H7fqSWQudogfep3GhIV8w7azQRspehZbE7Z7 +jXZNMlpiJNkWYnB6e3H389X53XwD3C4RhdnH3i+PKFOy4eDTLR7II7x4PhCzzaLCL27+QNxWD2Q+ +Vf7lJYjyq7TCL+YGtv3ovLy4++vpxWOy5Bd+du6OrLxcTbx4x73QQv75/Panc8zkDjFBSzfXa1yL +p+vA3mVoY4XaV69EnbbAK2W7lWnG7D2Gtt9j6MsKEjm+ubk8uj0//+/ZVs3X6Bn19uLydL5dd5eU +GOZwdlz57enbi4/zUTd9vhvaze2WOOcP5O38gbzd5oHsmoj555vb9z/fXN789OsOiSZ7srZDZO3V +ELP5ESxbTsxebRjbThKz4vW4rL6anb4snGKbt/rskezaXt85j9vXG7M/m2XZx+zfN8aXjdmf7Ye7 +azH7Cwj5th9JszfZ1h9J8yWcHTuSdjKLwiMeJRlZW+Z8/0Je91/kjt96R40fZ2PZ1lOv2SPZlSCc +v802px7/fHp9fX75/fnl+dkSfdq04PNbhGZbWjcd5LTgi51D3158eH95enZ+dX599+fT9zt0GF2d +SlWzDZM7IR2t0r+ryU8z+Dl31Pw1n/9On28xpdz6k3hZrsFtPr1mj2TXeO9jhDH/OZGPXaF3CzBr +2/fIbB3C1u+R2SPZFQ5vfiTy8yRe2Zbd926Rf9C7i8vLJf5Pl9u80u9ub67mD4YfP79W8hEmJzOM +PeYxnlvGPr5IzNXssfyIO7nm68b16+c36l/+6/TX2WMSynd3eruIUur326sJv7uZL3ncvMBAbs8p +As4dzunbtxd3F/+cL071BV7AHnM9f1xnZx+vPj7uLZSPLCvyAhFN1+ens8Nfzk4vz/5883b+2PoC +zx98Npu3yFYvNf8XDmHuAg5LvZBIcnp9cXX6YqlhdzUPXRH2zjBbJtmdvRpnmPkj2TXtx94ZZlvU +vfsLCyc6hV3zhpmf02zX3GEWkPJtP5RejTvM/JHs2qG0k+4ws/nP3XCH+SJ3/Na7w5y9GneY+SPZ +FWPJ3h1m7w6zLYfRF+AOY74Ud5gFNH/bT+JX4w4zfyS7xnvvpjvMAsza9j3yatxh5o9kVzi8bXOH +2Wr7z+548yzYckuJxwut4S5mDVzgB7hfhSdbhafLubEDi/B0HXihxnc/aeM3f3rzLXP2vFmm+ZrF +EO3OEfV68xbNVwPuSNai50kA/lLUdEmenD1Fe5ii1XuK9hop2uxl3VO0PUV7JRTt97cC+LJZtHNM +wWukZ3sObU/Pvkx69kUzaK+Wnu35sz09+9LoWW7UebPMCv/KyNrswX9BNrz9tpmzbZovedvMHvx+ +23zh2+bLui3orxf/Pr/86+Xpr2+WBTtuo8NOVa6q2d6TOvN/W+BAmZXYJcp3e35181h6gx3L9TI/ +p8g+P8o+P8pnQrqV+dqWK1PJ/8uV/Pe1/Ja/X8uL1Wtz2b64fnv+7uL6Yr6B6/b8/fnp3bcLtltW +4tnHt88Ro+PasRwxH94jS8zc0e1SjpiZ3MiXliBmW3ioV3hB4Y9LLhvfck/9JWPZFV/9vcJie8nB +Y3t7N+1KiyjCllO3DU1KWx8+f3P1/uaDsOXffXyEhO1yAF8c4w4RhNPbi7ufr87v5uPaLhGG2Tq1 +Xx4xTmXDwadbPJBHlKH5QMxLKCNmD+QR56d8IG6rBzKfNP+yK5R5Nw7RhVLPLh2hrzYr4mc5Q3fH +xLHRmu6MA9E+AHBvTt49c/KyNIXbqFXam5PXzcrenLw3Jz/jeF6rOZnEBQZlW369iNDsTch7E/Le +hLy/ZmQysr0JeU13t0dFvDch703IexPy59dO7KgJ+TUZW99evHv3cf5tJttOChYOZ1eowez0dB8+ +3r4Tzvb7ZWn+B4W2146k079sbIMyzz60X88vL2/+NXd8lxc//Xwn74sz5MGdPcRxse1dwLg7j2+u +RXS/nr/vJuX2SrcXVbrt77h9fDR7pdtTkNKvf7o9P7/+Wjiw868vrt9e/HTz9T8vbi7P776+PX/7 +9c3t6fVPs7faXhu318bttXF7bdyakc3nw/YquZfhqkyYbXU5/e+Lq493j1z9mC9J+v7ZEa+ePabz +S3lYpPLJSryYvufbC/LvJ9hfL+UR863KEidxj+8Qyr8mtdOH9+dncnDdPocv/LNLR69aWTObRKUl +XiztTwtu8xrGzv7+3++F19tglH3BF2C8H9HmPoFqaq+32ett9nqbL0hvE7U0qreJShyqb/Z6m73e +Zq+32ett9nqbvd5mx/U2l1Gh8SpcKPZKqKdXQn0fhb8d1EK9zvwZG+ijtl3F9iojgJ9Tb/hC9Gmf +Q2PbiMOryaExP2PDlufQmL8iW55DY/5AtjyHxvPcA7Ld3sTbf3xeXtz99fTiMSvF/uzcn537s3Pj +gWz52bnPP7VtZ+dSqrztx+ZGwvSuHJ37vFOfNvfbcuwuXs99zqklHXihxvc5p3Yr59T3P5++vfnX +U9xftDuU6AvPLrArfp2zk6LtI/KffQvNvljz7SPkNHdr+/cLINn8gfw6fyC/bjkF2HZqdvPu3Yfz +O2yJ2/O3i+j0rskA33GkX4YAsPmqvkZJYFtW5XXfJ74XzXZZNCtM9dVclJzPZ7wEm7FkJPMZjZfg +M4wvZ4/kXxdvF7gTxq+ff0Ru/oh+Pn/c8zAbUvr8+TmoL1Gp8QRZtHeHu9orNXZCqVHvlRpbywqH +16LUmD+QvVJjB8TfvVJje4/dvVJjGyn5XqmxV2psq1LjCxPN7k4XOFq+RsHs3e3p2d3p5V9uLuY7 +NmvhmWucWnpu/8zD2Tlbfjz9cP6H2/P/+/H8+mw+xzkq9QIx6d/fXdydPaLAyiU2fP33i8sFuRIG +ZZ5f8zXbx/b649V3gsX/XDC0vMizj+zs6bzMnnsky7RaWxznPH8kTyjwbMup8PqSHS04D97d3lzN +Hw4/fvbhvKbUTa811VF5OPvWlrub+fzUzQsMZZ+7aDC4fe6ife6iJ1Ytz5dJvrTURU+iNPr7x9sf +P17KZO+SHvF15l5ZIFJsuXD0PClXXkjPuyQ+bK9qXcsffvU6vMfmj2PLfcfKV+c7tmBEe9+xNaN8 +cQNFz5e8eST8/nWbKe5y/uwVGSnKvZXiZretFLO9mXbNSIEttwUq8b2497rFvSVothf49gLfXuDb +C3x7gW8v8L1+gW+2aPAaBb7X65c2O6fDXuLbTolv9gLuJb69xLeX+D4JzfYS317i22GJrzCvReZb +MpItl/qqVyf1LRjRXupbM8oXl/r+183N259uT+ef969R5HuVd0YsihHf8hCJ15jxYrYwt8948ewE +YZ/G86GB7DNefCKHkfJAvAravM/fsbVk7N2lcHd6CfF//Xh5evbL1ysF3bw/Pbu4+/W/FuiEP9z9 +ejlfxx2/fn4X7iUXLm/7zlo0mF3bTH8AIu7QXnqdGtFl+2UnztXNcg5t+60/H5jK8fg1kbcvh3HY +xdsAXxPDvfT6zC3fOAuHsysKkdleJx8+3r47PTv//ux0CUc6KPT8mvJlq7VsbIMyzz60f/28IDr/ +Elp9eV/M4DyyEY6Lbe/6xc15fHP94e70sasUc63KuNwuKdCNm715T//74urjAtNW9/2zLzlx7tVk +Gapn57Q6v5SHRcrmrMSL8VjfXnDfnEQj40t4DUgfuIdPIrHac3u7cuvrnkXaJRYpLfDiM3Za8AX8 +5JeO8vf/fn9zfb7BKPuCXwhLuOeXXp5f2rNLe3Zpbh++j4RqB/ml12kN2IBz2nZm8HncpLd/nfYq +82dIJ3p7cffz1fmCvO67RBxmH4i/POJTkA0Hn26vnPHLI1/mAzFbvSKPZPDJB+K2eiDzKfMvL0GY +X6Uj8VLr2dYfn5cXd389vXhMot6fnfuzc392bjyQLT875zMBW352zh/Ilp+dS6nyth+bGwnT+6Pz +FRydu6OH3t/SuI280JNTwh1Yi6frwA4hwmtNRbRPPjsa5e6lInq9V+RtZDHYblb074tzWO8a37aT +SZauTqWq2ekldoGwm1UZ/133q4PMHTJ/zScb6fMd2F/bTjH+KEU/PO48trsEg5FUf04bcFcoxis8 +m541/mtbsy/sU3w8f4K0V5Pjo5gtTG17ko9nUUQ985i++2KiXHcuPcbrdOJbzLq93h20/fYU2Bsw +sr+/4gTIu+iOsMm6bPs+ysc0O6xxV1htczg/NmrPbO/PpM+wl354d377h4vbbVCRbMs6353+OH+N +d0GhaVez7Rwc+/9cprEclHm5VFwfr8/+tkPU5NVh2WGzKldfBp79cY9nL4hn5kshZ0cv5WJCYQdR +13+/Pb3+8G7GLRLbg++vUx+yCau27eznhnEmu6AN0aFtCV+914fElaHn3DeXl1uwJtsyJZsh695X +c0kHXqjxRdc/ffXNn0z55vfXb7troACqAHnzl5vrv0oVTFNSKPjo/KeL6/zFwV/esw6vr77/9erH +m8uD3xydvv3pfGVWxeqvF9e//Pbgo/xbrr476B1qfvhVHv4f+fF/BPSvlV/9efX//e9y9VagP/zt +oDwsy7INK1sdNtXq6qAwh6U3dRUBhZX3lalX1h9WlWsAaF3dynt36Nq6WZ0dFO4wGG9X1h66EmX8 +Ye2tVGkObROkSHVYOyMvBFAa71GkOgw2ePmmPGxrI9/U0mxVNQS4Cs+2qUObnqVIc2hC1drui3Bo +ffCs1XlXr4oWRUoDQOMCe2ZKfNSga8ZYacZInyrpggB823oByAB923QAFJJxNKEZfA== + + + U3sMWQCusgSEpql1xM6wkJPpKj0bl+nEcxsc++9KI+tj/KHFRJtwGCodkYC8ac3KNIeVwSQIoHZV +vTL1obEeDVXoihTC37ZlIbyT4eq3qBilLQHeBHQXLVTtii1KYSnEXthqpb2SQtpND0CD4RccirUr +Dk0nT0BNWxFU2sbwG1vJsGVWa9tqJa5pVpz4lkPCmsuaNIdtW9WotpRPZET1Yd0QN4gDzq+AE7b2 +qUzThBXRxqW+NH4FvHIlCgHXgEBY+dKxEPFRlkDwE4tdAF+9DBroW5ruueTH+rvoX8bSRV88NlHk +bcR+FH1HYleLvq9xPERyQfc42xx0kY8a01L08xKnrsjnLk5v0c1vXIAiXwGuUpEvU1zKol/LuNpF +t9wJJYoMJxLeFD3iRNQqetwi/rXxRxsi1tbOm/i5TxVgnlglJoPNYJ7YsC4zO2NN6l6IHQ5Nwsaq +31g6UGfjduTuK/Ltxw1aTHZxkW9jbvUq/ypSg6IjB5x9E/dDpBmkK5UnTAmLUp7Ang+IU9FTp0S/ +um8ShSs6EkcyWKc9oHQQeGR8RCxZF6KaTF2cAawKENJ3uyAoqgjaWnYAiMw1kPYFlRXvq1Ui6/Hx +7ICo37YJgAo8ZjxVQLLOrdG1QrLOKmNX0Fnnqr63GJFrBiOSYctOcf2wMTENv9GJwdy1QOFu7jC9 +wfXTKwsg5NCmBfCkLyHhiQtoBktZmW4phUhhtZu02iCZMsQKWJYAUkjGETjb/Td1ZdqIWr5R6teG +hH8oQ7pe9zhKNPb9Jkt0Pe4xtkO67gekuXa16XcYtlMou30FvNPd5NLmc6vR/qz05KhMvom1E3Gj +65ErnbSJFhg9obDpOLIaJ8iQqlT8xlbBRLqj5zQ3A7dHFVgIBKxOFKzkudZw6ZXG6dmOde8JO7EE +m5LEUoameBSR3BmnPETC8cqwEPExEua2Xg1Jd7PKyHpO8V1kUCJmC2VWgu71zGi8DtyBKLF1KZj4 +E3ZPyPXgaJJnTm/j6nh6eQ5SyHjN4803etjL8hFBK2+0DUHDoEdkWOlcez1C62Y1PWXHB/H4pJ4e +5uPzfswQJJrdk+wxWzHmO6asyZh7GXE3SqabjP8Zs0hjHmrKZo05MSXOdWTVap3TNuIi+kS63LSR +3wOPYULdMYwgKwHLn6gK6Y7p3pMuWdsxnCRdVc6TJuqWiFsif4n6JQrZE8hERBMNTTR2SIL16XjE +aZ8cHP14kDzdj34WQeQ3/7iG0PB29dPt6duLc5FKjG9/K9XI2piAv63guZPP3aFvHDAgc5w3q6Of +Dnx1WNZCggAo0kMRTC0LjI0dZNVliYUeHF0dvJPmj45EXPiPj+hbUxqhUOVhCNbJPAEiy2F0GFhk +eVXJS4+emKqWpSpx2jfSkR9O4+gaZcQgSMg8W0FLFwHSLpcDB46jQCH4bqweOFZ+yQy5w7qsWj39 +TQ2GMB4tlTQmldQh6DnSNBYzKhMZGqMcRWPkrK1B0IKeJHXwtR42rn8+lsPGOqBZBwqHzrROj2Dh +DYF4TganLQvOt1JIcNNZnoQyDJkonDauBIOO/Q4ahMPG9c/HPGtc7fMvqrrSo8a0IO8yAcB/AMpQ +s4w7rKyee8IV1EoTah2fLWtuw5acIXYqOK5j7G1DXkg2sxxhShZKnGmy20t0X+iA9L3mWWOxkMcH +6VWhH/uVFtajxWBns4FamUrZL+gdOwGult2qKGexmwX7XXLzl4FcJsaGhgTC89WQYWn5hZB1PWpq +yzqqEvQes15Zp+20YFQCNnDgjvaoDSeNyHvc0U2DSogSDqtKJBGKJkeNEJOSsqhgUIWjRnDK8zgQ +LKP82vhSG4qYWAA365o706NloK4JTZUAJT6OP7tXLGxWXVnUj/MpojXHbmr5susBEdmsui4Sj1fZ +IDBQWYRsnK3QC8yDYL5OlferbKY4mySdtbCWqzjbnGzfdsvB1XCtTlNCLCECnNqEV1zRhFb9omdY +pXhBzPGKZXIgEKdwhPS4xTftqkM/IqhVFHN1h8Nsy1eK9kRz9sabVdwGXWfRfetX2T7BXnLEN9PW +3ErO6XPajL4Nq34vYreWHQC72dQ8SEg+0oT2+x00gcqHSBJANGzLHgpS6WEjp82qJyukPHpgEgLS +JAi+SpQJqwwq0xMvELdE2xLhi3Qv4VBPGRP1TCjbEVfS1o728un4YIDAleJ3V5q8rDRgZX0VadFA +MehCEzeSbnJ2kZstKmTiCAoM0usRzEFCCLKu7eclCkp1NlEF59Lb/pvxZCspaGy2HsV4yYrRkhaT +NS9GSFGMkaaY4lUxwrxijJnFFHmLMX4X4w2gdNeabI8U421UjPdZMd2KxXi3FuPtXAx2vNVCQ5rA +T0CJSTO8SaeckpWahItyWNvUq0SBC1Im11OmYkK79JhueupW5OTPs+WMQioBLnIiWinrkIhsGaL0 +mghwkVPn+DYWL7rysYkibyP2o+g7Erta9H3V4RT5eOKQi3zMnJWin5Y4dUU+d3F+i36C8zMwLUF/ +TLo2Tl92lpqqP/O747ZDiexM7vCm6BEnolbR41bEvyJHQJk6nrL8PGqGjOzViIpV1B7V5YDb0M54 +M+xelfEs3bYq8n0V916Rbz7nImSwgYtsB8c93n8DKtD4yIZh4ROpyHi1jp50DF1HcooJXcoYw454 +9V8l+tbxl0SQJqoqEhUEFoUy41QV0zouFsjoWgjyPT1XjLWmZ4cVrb2J7PKInT4++INICN/mXHYN +Zb20ICxDzUdptjEuqUlCRXyu26SptZAiSbRFiHIRVqrmXaSJyACPZidCSLZxHNjsK6xG1eo4m/ES +Nh0RVhzMvmmsVfJQh4jwumF0nySaCimEjfkaEy+QsmlU212qElDmhQo3/qjruBuEH7Lx82BiBZVW +EGzk2CsTUsNx9wkOq+YVc6J6vYbY3UBDmTS/lW91ThvbxE0rCGJ15j31GJXyrliX4HtAImD43b+L +xfvSsY28idiRvh+xq11P43Dy0cQxd0NO09LNSpq7fOrwTnUCcX5RuuJhGJfAdTx8t05xNbmYVjc/ +13uMEhlGRKxJXyS8miBfhnvE0Mb13yQcTiic8DxDc0xqFViv7gVMuwjQK1tn/BLZ7v7FuBDqhcTb +1ystBxOVBCWVm03Vd16VEDbruyr8jUKEqI6GP5mf0QQOJtjEVR6swXiZxus4XeoxNozRZYpRI5wj +ToYOJadYy+mTQSfEHiF+tifG+yWV7HYUK69Dvu1i893WHG7eZjXc4Fb7MyQCEzrB2WnqnJikidTd +4+wqzXRHlFi/H1Aurlc89HXBsJ7OdQRQtdJNRiOBEbXtvwDGNFVGfDsdRodUxDqeLBGUsDLR9IS3 +Gd1PqN0dDgnti3xDFNwRg8eTg3cH//GPg39QWfXD24N69Zvfrn74X1PAV2/M6pv38qeUg+qrN90q +X/UP42UerHKGQmcoMsKyEQ6OkJQlRog8RvTxVkCZyXYZb6fRhmMZdCFoj0LNHlIDjg43E5qBEmO6 +cg8twqc5nZoSsTGhY4lRB4pR/yaEm4Wm5H1yAKyZrulRMjls1q3M9NSaHGtrMGDNATk+QROO6eeT +w3d6Po9PcS04Pe0nDMGYa0gdHHEXUw5kwqek6R/zM1OeZ8wZaUld3aJb3rT8RVr/CdfHclPuMGce +B1uemykjDxPaMaEvKIF+dNKU9AMdNbGfdT2llnH7jWjqhOqOKTOLjWd5shDjQ4BDGh8U44NkfNZE +ojI6kcZHVo6D19Djf3ON2C+hiPDEEYoIdxzKMNDmiZzSeDnRr1Rkduj8YRXUgN/CbwB+D7WDaQMA +B5yohMybaEUXWQzmkvqwEak28BspEqB8qHRnmdJXIs63pXfRG8HYEmqu1ldORTcD01oL9WKpoqaB +FCVHESSQKB7SaKKaMZFxRBb2EEsaSKzUBKjYiGGF4NSgU8JyIDNVlVhgGKAqS38gV7fQMreH3vC5 +NTAMyuEnAwwVcRa7yuATVc9XlJFZxlklfaap6F+RpqDAHFTQ/8kUYCKLNAuchJqCeZwFGLIoyskY +K6sqKgyJyFBhAwJQqWaJAzrWMkG5WltW7JyaF2jdctACVZBwyfY2NAmJON0qIkLqs6og1S9aWL0h +ZfuoJTK+rNV0Rk0bxfOAOUBRp/4YLTcFqocHBBvkdmMPKNNLn0QWxjemtWqX9g6zL5yGK1WcFfxW +NWjloxuDCLGOOqDGKtKQ62yFj6garaRsq4ZWt0g2pKEa+N/I6mICATBJGUqVQALQCaBVFUIEyd61 +6RsLTxpgdFnXEcWto7tBTY8Y7gJsLBlrsvorbsjWMZEe2mjRF9Suosgp7QBBHVpWEt7U8NDJSJs7 +bBsVd/CdqUmt0neoy0fNFVGvyBt0pVVvG+mVb5U9o7iObnPOUr+BqSIM2XxsxWQCIMO0pu6nqFgz +jwUMtGWsXL+S9bDUKmA9uDdb7oa4r8voWVbCvKlLHUmJUMgqrn3pIp63LpJrUCSV5/RskVIuOdpo +69RuK6I3A0wshuhah4jsTlkI20arkiqH8MNrF4HtwcSvoz9Rtne8T61os6BUKCZdaWPX6lZH7X1Q +iAltNBBWcdOVctwnOVphsqgwp3KMVIaDIqheMJJOUg3rfGwO1qmOvA5oT6K/pNFFTqQjIS86Sp5o +fdER+3QgFOlEUA8weksRFxMOeyqHXCLewGEhIGXUW/B99jrWgArq6DQ1OHfOYHdeZ2xufotmDAiD +hfm4bg4tdHaGvixuamyGV0HNk9FDZIFTXC1o0yriexPU9Czty75ayansDo1svh+uIIE6aoW8nLgB +S7+uZNPCz6FZwY1KcFd25tHZpo0ezW3Uy47zstBB9gG1d9JmNJT/Q873331zezfwGYe0ox7EcO9d +ncFn/+P129WHn0/fn6+u6Bj9n/LV1/LfgR365I6kpzUsgrKYi5kEcIlL2QRlg5cyCsrJLmYVKEMt +Zhak1CbsghTbgGGgALqYZYilFjIN0sPlbIMU2oRxYLHFrAMXbDnz8NWbjdiHr95sxEBAzl7OQsjQ +NmQiBPk3ZSMo52/CSEjBzVgJ6gk2YiawxzdiJ1BwA4ZCi23AUqDgRkwFCm7EVkTdwQaMhTa5nLXQ +cpswF3rALGEvVG+znMGAGPypR2UUo1cyW3VUN66tkh+36QztQmw0OObecBmZ0tV3t6fXP50vD5iR +A0kQ3tGnwQp1ZcwMzkXo6bw6Qp3QeOnrip5VsnItQQGTSS8b/j2hwYpv09cnGtiAvZ7qPFHDP0zQ +2jLrsrUcQTXyAXTvGZWgXUvVlOr0nupJrRVZc6kzRd6r+LrIOx+r6fp3kmZCEZwdPJEp6rp2cpC6 +03Xw5GBYTYkuDFtDxdqV1CUAph1fM74105BPU3qdvY119FXELvTNxC7wT9VmvdUu5UPqJybNSz8t +RedF2c/OBJFmuYTaAJfQshUeA06atqEzfbnCLrTQ1o7ZdNfCdVcBRXoAj9yCMDr4hA== + + + wmd56hEq57ZwQiUs92DQSiEMBl7D0roRlg2vgm/A2ZXw4QuBTqPCKMrI4RBKTIBpWXaIkCo9rXkQ +lMAydS7Qs4DHF+ZNWAVVZJLknhxIHwMcr4Eu9ILlAhia4MHQ05EW6jySMaH1Qc4pBTVkTkD+oePk +SgoHpScNf5xQWdPUqhBs5HBQUKipjo2VEieEqVC2jy0TcdibIvWP2KXHRBzEyQHHZXmw60j5EUdf +pPkghnKOyux1/zbVMaiC7XTNpL70XdGJqVZ9fzkqG1bZoOK8ZCPntKz4J1TZHKZZ6ic6TVK/GDpH +2YKxV2w7drRfUzqveDLhcd3TeHvkKFdpXk4OisHrCNHpYBW+0s3UNQPpQSCDrhB1ikl3i+mQium4 +O5TpUadIb/sJLFId/SwXCXf6pVBMFiTt16uYrGkxXfdiihxFjjvFGtwq1qBgMUXUYg06F2uwvliz +OYo1e6hYs9WK4Y6M3Rts3G72s+3d5AtZ9EhVTElFkfAqIyjFGrqT0aWT5FUjoAbnuIfDUKWfV21b +x4MviswiicJTQTtZc8yNWi10qnUO0w+dw2jJ0e91qltPRjNWqyvCxrrmAeuPdr7LX8V+ZDWkhvp2 +Ui/y3ujLvM+xhtSpk34G4ANVcg5lK+pZ3r2IM5OX1nmZtDDohVIivLNt39PUdj+a6ZBtd4CP52nN +dE4nfc3SDBbQttloin4y1mCDYkr/d0PTeJPM4pOhCmwyIbR3DWeNqpDR1FJGH86/gCaL9NWb6VKi +YxyPsPxTDFABcIQpaokcN7cG79RoPERPSBYTLFZhajIfaStkr4vh+ykOZG0WeaNrMKEfRzEcyHTb +Z5NTDOeuiJO39vUazOqWKkPAfkkHvVs3jrUjXjs53dxdZxJVFabWSXcIpUxJYaaNwQEI6m3TYcAg +ZScSqyltpPF0Dq0QF1gqHTNq2JU3xppOvjE87NSiqgdGYy2CxlUXdwKPTdUBWqByg3MQbqrUJXrq +YTqFRQMFjWe4ZItA2RiQSOttGd1WA4XbzhkT0aT4QTcg9q9AB6FEU34f/Sv6DhqETUFYh5KzpjAH +07PG51vVbJF/UqM7fiA64+QgvaSlGoFeJCplzUDsWCkYpJoavW5qTg5Sd3QCG/QLs0qNa5pmMEmV +t60G+nAxhPpBNR8V2FwyJUxYSxXa8AG1U/0HULi6tqzzeoq0iFlzxZpedbOUdb6bpmyMxZqp6CYq +m7HutRZwCTaef20OjEeGR4PVrIdIWaT5y3C3yJG3TU7WPY53W+DkYQuJDc75QAuJESZEihg6PJup +6AU3ZQOdoIMGHZpjDydrhreClQFREEGskc7IfASRFdWP/YcrHGzS2ZolGtWrrynamsMWCttgW+x+ +YYiOzjZu9Whuq1KA3tDBlpUGjOZGkseMHD2liTqwIa1R0j2iNmrQGNEbNY6MKI4WH9EcACdUR4Cb +0B2S6aWUh24kY9pD2j6mPgKc4j+BYwpEo8GYBlG7P956PILGdOirN2soEfT1k10PbfyEGkHXPqFH +8BqaUCQ9HzuaRM33hCrRP2lCl6jsnlAmLtyaXq6jTnqQj+mTapin07SORqlSeUylFDpdp3WUKsPT +jFZlKJ1Rqwz7iyH6TylWvpkmR3z7+ZWmgqerP96en19/UpKhkLIMCZPiOwjC/QODg/xhXXHwpfNM +EMDYT00y1AanEeRlNDQKKaJXuAtBffpqWF7gFeu0EOhTaTW0PyA7gUh+VR2DMessyxAfNclQjUwr +8b1sYePVmVO4MO5U64zhJheK4FKOIaOB7FaNFgYfqdO29cMcQwScxcCI0Td1axmeRkpDC0YMP/eC +zTGDSoidD02tqSIMPTthdGw15sfJP4xPUw82gCoa9YTgV6UmGWqQGAPZAILTLeBrWCbxN7iUZCio +z7OeAyytqQIqF2K2i0YdZp2zydHMVSV9+AzjjbSfzUr7TVOBYDSTASCUPXo8tOwwTI4x7waypsDi +ZIw6hoaK4WnWwRNTE944LJrQ37r1apkJsBLVCIONfooG4czEiC4xEfpNpIkOnR75AIBWjVUDnkfC +AWCedSHmGKrhLQrktDEWJzS0fZRlcN1zyjEUGrWtxJexdNEXj00UeRuxH0XfEe1p0Xc1joYIXpU2 +zjWHXORj5qwU/bTEqSvyuYvzW/QTHFegyJaAq1TkyxRXsuiWMq510S12Qogiw4iENUWPNhGxih6z +Ivbpj2AjzjaViRmJQnT0rFwTIiLahOo4rLXhhOumjAkBYmQg+utW2QC4rWwcZtxX3Huad6DbfLI9 +1Sl/uIeLfBNzow++Ii2IVjHGt5Fg2LQalY8Zhox32ishK34VyU405dV5gqFEmBLhSl8kylZ0pA3Y +4dom4ktlNb1QY1xKpRNaxbI6Rud5JFgiLhpvInbWbUwvBP+biMOVpl9pmaEpEuw8v1CICYZk6oPp +IKhDcwPFOtAQA2T7hkjTU/4d9Ab9JZGK/SXGt2kPkKZj4DamMOPAa7JbdZqZPr9QnDrMrSb5IQCT +X7fd5FtSFp+SO9BWzlVsulWkQtfFVA019m2eW6jWjayBHu3gm7pN/s6Vd0r10tQr5uluajNKCQR2 +q5yUOt2cRHKjyVyEnocBSW4qfpOINjZSO9hRuo/SrouHQb8xNaC58T7fvdqHdMqYEI+dKm0qTd3S +UQpHOjukJpohj9hJerNKm0C3BY3vWOkGzYBuBQ0wD2TCSNqaRs/zOp7vbSoTgBakkUYPSea4UCra +rhKOKakl56546CM9Vk/ujGKHVUbNM0JvhIwoKQ+K07aJbElQlC6DjtuXdJWX9uumY0rYQafxX/BY +1zEYnd5Qyx7jKD1nl3kVOQ1VnCrPPDiuJHnTudSjseTUtiAxnGlNRjg6XUfn7/h8nh7h41N+zAYM +OQWr2DhgJsbcxpQhGfMsY6Zmyvck8pyocyLOiepO2asxBzZm0RT7XERHq8mFjNccUCQKtAP7xBh2 +yYUiSSHJKUN8JkVSvpMEiUQrJjRQOpzIWqRqiewlqpcoY08YE/FMtDMR1xH1jY/HYwZ7jiW5DarO +8LahB0glSFczdRD8uNp12YUsEmNFS3J6KIIJstaQLoN1zaENQnsntmRhK0PLzEHyt2L+CpkptRhD +jMQPwWHfwLwsKwLXnRL+l3IqTrILUYJYm89OcwIQSTRbk18VKcfYMfPZuTYlFwy15rOrunx2Luaz +i0eFYayd5rOL4f8Iuq+zpAitG+YY4vOxJrRLqf8ccwxZlSAtc1eFmNGuyzvoNA5QI2GY/8rFhHYp +f90wxRCej2M6O5d/kWezq2M2O7/qHM+OYzo7HXLDFHgx01fMZ6fJwLqMkTHCNM9m18RsdnYVE0CO +k9m1mmDIMOGlph5rVqlsTGbXxrxmq5gWNUZblCZlTrUp15hbxVx2Xe60mCRS898wu1rnkWWZyS6e +NrZJ2cNCTPToYnCq9XWdRR4zk52LmezamMnOxEx2wcQyTAuoqeKC9qU1MZOdD6NMdpw3xUTGWamz +6jCVne1T2R0PUtmVtku225XM859q5cxlV6+69mPSsq6DzGVnV9kYmMsurPpRdqnsYvx1Awabadc0 +6jdPZde0o1x2fpTLLqYX4ooRyVYdQhHDvK54veoWPEMnb0JMY1cpdvkwSmPXKiIqLkW0S5iUZbEz +XQ6742EOuzKsEuqzl00bk9ilcTS6oWqvwdmkC5rErl1lOzAGa8cNOEhhFzPYVau0g9NU9ns8pRZN +ZIAp7KqU0rjq48c7UpJlGiLkhHntmA4qQkigypRJue1oWE/CEplLVC7RwUQGE6nsKWWipomYrkts +p+mGGs0DgPfDlNGuGaaMblLmvLrS8PysD02d7azYSc2WqrHBcRyaUlXT8XComnTVm24u8nxDcQKZ +vJWjS9+MFyFmuQzZOhXjpRzljU7iYIYLxQhZijEyRbLVZvhWjFGyGONsMUbqYoz1xWhXFNN9U4y3 +VjHaesV4axbjvVsMt3Yx3fvFgDw0eiplqTC7dNFKYuApcpzSRRtSoToFBsO5NVKpYkrH9LBuelJX +jGnhIF00LBvHKV10T1GLEcUtMmJcjAl1kWFyKp6ni05tJFzuOzJIF12FfjxFPqA45iIbNGel6Kcl +Tl2Rz12c36Kf4MF52Lh+nYp8ofJzteoP/qJb7IgO/dlcjI7vVYdSRY9Tw1TRbUTW2vkomtoqFqe7 +NzNFN7GNLFG07oqoFch61viQcS1FIt5FvpvijivyLad9Gm/bItu3cWf338S933FiHYHIuLVxluiw +6ghNMaFGGWvYkaz+q0TVOg6zI30ZG6qJouueVY2JolNOcLbCRNEJ/4MiCUPIXc8Xx0TRflWMiHmR +qPk+09A+09A+09A+09A+05DdZxraZxoaI+k+09A+09A+09A+09C2ZBpCiGRy6B249Faws4DBr02D +7AZXPQwBn6pFYsAn5RGYTDTKQkQrCjSWMpta/wWDVNgNwapimwlvIYUEG6LFXe/+aitnkj+IYp6c +Ikyr2ztwI8Us08vjXOEtNwEW/85Vo2YwPtMM1LqQxtqY9jkFdOttAAjPdd1FSJbp8mFCKusYCVLG +tTEUkRGRYo1qWii3q5cCjZhOzRhY/xiZJiuRnBVisLnv0574lMq+in3C5zw/Ec6SkudX6iMWDukX +p048Ma1AK3VFpY+JKM7oYIqtVZwdrpL6KJho5K5CGQOuXbymAKoEQjSIO0HUOaktY4Jc/ao9bKNd +IRkYwmHbtDFOObQ2+kG1xkX66bkBZUwaX4RlrYNX3riOkdGE0OGKU5h9I3MTU+jqrkdihlixqTRD +FSyCZcxK4XkdksO2iTb5in4mMiVePSRg09N1Y4S2mnga3jRRami8uqvSBFPyEpja9BB4Koh0TXSM +IEt1i+0rcsCpOjXmaMFLcnTskIeh19d9nyvGmdt8YHUM2+4GXyf3yDQ/0PiYeGFFnMKG2nbXgwJo +R5x4jpcxnDEVQxpSScLZk0nggraEdS/JDnpfux5Au2qTbjVL38SEBBW5GJmGqhygoYAsbSUAGTIt +zkRfI6YxBiBtUGiqVA9vbUjNBCoVaUAAoIVWzMQ82Joy2mvXsoTRVUzxHwPbNbFFli06qMlXdUXp +i5L3eqzUtUKz/Fcp/bdeJ+PUU9PSt0WT/JvoTkZyVUf9fQeg4Td6gkQQUkQzfTNIPJI8pET/BIBo +AneqMln/ShwsjvQtji7m+ydRSvn4z5jwXx2Xsoz/Rl0l1+SHPjsoBknTY9J/32Q1jPJQa8YhdMUl +s2MdNCd6Ez1w2NlRzmuOqJgMm9mzTbR5KrHH9A3mimTF2kRq9KsAQ1rV9MuAnN5NFaeLeK5kjAkw +dDVVH+/KeFegraL4H0J6VoLpnMs/UOpOjGq6/P851nUXmRBV6WBMzWNMa8F0LqOs6DHfE73kVbGe +XwKgHmwxv3pMvt79UDfLLvl6dg9ArZrS7CKAeL0fma2zg0FnYjp2dNhqh/O7AFZdkg== + + + +bODjLVM17DYabb6mEidqdUbk5qTlTGa+b6O5Mo3usiyjJF0K48g6NLE4dnkCd+nSI9Ylu5E6TC+ +y9h/Fm8F4OQPrwUAiht1We8uCihLkoezgx7k0vmGXCAVPAtwiJe6E/T2hkPliFRTVnqGsLeJken4 +pgAdul9NOamHcmiV0V9iGocv6wiztcbhI3kOdnywZcl+C0eOG0F+uDqoG82xMv5Q4Eiwk748OptZ +5dG9VZrawAnUZVV2YRxrIjemDGUGXcZSRpFrOVOpMtQmbKU2uQljqSU3YS2jGLuYuYxi2wbsJUpu +xGBqTMQGLKaGWGzCZFKhsBGbycCQ5YxmDOBczmpijBsym0gvtZzdRCjpBgznV282YjkhUW/AdDKu +aDnbyRilpYynFNqA9dRSS5lPdnAh+0ld3TIGFMFWG7CgWOMNmFBg1HI2FNi7kBFlVrQNWFEqjjZh +RkkMNmJHSYA2YkhjgPgyllRJ7FKmVCn6JmypniKbMKYaCrcJa6rn8wbMqaYn24Q91SY3YVBjes3l +LKpmHVjOpCq/tJxN1XKbMKojRWHbRf5/B1uVZqpMQ79Sc5oGI9Uai9ZYvTMx8Fy3Tolox8dJV0lq +C3BWCI1E35UJggezeiSrH27JO1I5HIxFc0Ail5/6OyoPZdM1epEsZHMO7PDq0e9KXOOLfUd3B4f9 +p1rV4YCON+HT5eA1Jl6hKuyJ7ppgKgfnWqSUFSQG7dcgbTY4/rYJ/WdHZ7NrPLq/Rt/KxAstyqu9 +n1Vfs7JRvbxkbZlnYoPVpQ1u+fpKsU1W+AEEJ6ttMsb6imkbSpNx30LUlAmP/DnyQJohE2+7nJfI +JRzvLA0xHrilK6ZNF6yB22mtOs9GwmvVeAKA5iYVHq/WG0opoSjF12iN/go4hqVntw6SkJLeVgN6 +21/WNrigM6PbpOrVgLzLLzKMBGE5AGAgOoQNrD6Dm+voTVg3vIJSvjXRy5sMMwUTFy0hEPMm872R +nNwgaCKKqvUh86HIoFvEugD/sUPQIaSRDtrJ4afcfOmro7O59R3dV19l1TdzUOn9e28N0mmk/lK0 +01TCixGP22gp6pE6LEc+zU6zGP04ScsRkMWWo+ADBKJTEyDDGPQTV33CrcBgcmUpqW5oIlFKSgkG +PFVJP+bhSFFBJVAlZtIA4KsmxvO14IAxTKTkUH8rcNEyJCak4DNGLmVMapgMS7qUMjVEsaBnasj4 +BLKarueP2phF+6y/kXJ4IWWoVwM2K1SroaawhC6AbpZaLbM62cMogwplRlQMpCkMUH3BmI0aKX+T +3OpVJGRujslkb0QdpJGqrVvdo9BPUJAOwjxT6AqCYiKeCo7geG4gKLrxt9jHyKTUf4u88nPrPbq3 +Xtk1mnx4UPFDCrUJ9mU5rhbgn5ZajIFabCkOpsYWYqGy90vxMJZahok6s0tx8SEyQSpda0p6Z+gO +C6oI30Fo3lydnKcRlVInvSCwjGEsLeRndXy0JP61HAImBtbChRenQdIl9tcL18kkQe0X0IDSJDvT +atoL6gqY6lrDD0OMroDWI2h8o4ou4BoZXQGhNZjVZEgbbsYa3u3cBzKTdJUXgbDlwGU/OPi6M50R +8/RX409t2eoX/bfcirNqPbqvVsQjckIGtT6wD6fLq8ClC6zy9uIlTo0tXGQttniZ1+I5sjbJ1r83 +b9NnyyPz4Zfzu99qUKgm3vzuAGHQQtgox3ohwS0l4Rbh1l1ymdP52bltjTBCmZMGqWF5ogulbGTh +HDSiUb62NeJFDMwnqm4q68Z3ALLvZD8ShJkmLU6NBGGtwrGlWuWZadBju8c4JZjFvaJbpubxXgMa +dveEePotg/yhKKHm3jHeNUGs6vDBMbWaqlpje6jxqrpnxvzz9uLui2ZUQzNsQyPyrMZxccZOegi0 +Z5at6I3vjX6RWk3PKlugX90XflSDH7ZxPBkr5sBR8LPZ+DtI7L0UMr7uxyucoL7vxl8j70PpO0g9 +qqEetQFvV4X04+8gsfepzjS61Go//tSvBHGjGtyojePJWDH+Yty5qwwU+1+gM2Dn0wCL6RwU6E6V +oUkxnsdi3LwG543moRgPo6s4jbOYTkXXwe6b8XQW4xk/no6c00E8HMxGgqRhEDObbDKImoO5UNQM +2Sd+VIcftKJHNiDZRCRIGkGqtBtjbDebhtS1/pNmVEczaOV4Mt7oGY0gINpLoCjxIj9dMU1j6VVF +kzIj4i4PvYmCQqHmCWXCY1lGrzauDoLh4NZzdbJQmHB7LS8n72rCHT4GivgQb7AoGlgz2qABOzVZ +SnlZu6DJhl05fGSODdPDCrTTIJrKxoc6vgH+Wdw6VYI3POGTjYn6unpcfI120m8irhoBXVb6MFQB +21CYcmiIPVRS9OxtTU08Hk7pMahP1vkr+CKZoGNP4ynJXpqGpWreyIAYPGZgRMUNjYGmZXJWFwXp +kiHoWe+OD7Lenxzo2OoOko07mxAplE3WyUE+j6mGrqf5QDCweOzCTt4yh5rgF/ngK0yUpXMvklbY +eDghjwzSfYC1olQNXKdmOgJKBqP6qit1rCmZo8HIOm4aRJZZWkAr3B3gVj2gRsKIZtUXajSZXgy+ +oDdAtKswkXMLaUxQAgmKmI9dzdEdoNGULqnMcTZW4dNc0JzeQc5yZh+QHUcHiB4CyY1Kl8kcHcez +GfdYacRfDe2D03R2suc1pogg3PfgVajBYY/sMhnIIz9EW6vXVgJCoGGmza4u0wXCpQYThI5bnomD ++6+88H64zqmvqYNkDXawrl9dTanv4/GdpbiM+y51Obq5ueStLu6vp3d357fXv78+/fHy/I8fL96e +f9BLXWx/9Uv30b/f39ze/f3X9/HeF8EnWVsPzVipbLV3qgn/3d/OTy//fHp3e/Fv+W5QSfv95cXZ ++fdnp5cX1z/98fbi7f97/musbtri34QZ/XB3e4ru9+0u5mI/Xl6e362K1dHp2S//Or19q/kQF94i +YxhvX8WEyxZRpXymF/sqgeKTT6GDOKNistpq1RUshp8XxsdfYK7iT+6e7KNhDV05DcFasZVBTwZf +ps4f9+OYf3nJCv4LJTIVyWQJ1cQNV9PUuXJWwqGAol16gHa3ErEu1JCK2s9+ZYlO1oqa4JglDQNe +aaZOZpXqJilN0Sq9S2X0lXXd5HSJifVlkZUp9GMubr+0fXtF3pG4rN2irtL1BeqCQkzSXzHDMX/z +v/4ptuZXsTGKhlX8In4QufKVSgDxRfpSi4LMxw539XeNxF4cH3Td2TCui1VdxV9dEwq2nYUbPy9T +jtRVHHLemWivZX8vu9/9sNO7ItYZf+LT7n1XJH571vXvciRS174LxviPGI/Ribqrn5iVRD1HdMEY +M4KneG+GYSSL+oToDV4ARtO3AlLmBN665WMubD6k8ulHX4TNxMfj1In4rHe/mP6DUXV9UwxwTJ04 +ORh3MVVTKOuaxpkOTiSy8LQy85zmdY34ixwsfGXT3dNg8WxKIM8PbYyPb9uubPec1OkMljHpkhN9 +St/2hcwqtVCwPaNAyrrx/kI2Pmg6jl2n+wFNmXARIs0zO3hbkhBVrlpzd2q8D6qMrmLMvOeZ7WEV +31CTVRmuW7BMp+apSiv6D1wVc2E+VLRyerXl0dnGrR4tbhV3StVIU9xr3tZTgIezhcsGAk34Vh25 ++n2T/CPTztFkynP3TlIQx92TPc7dP113uh3ES0Zn7iFa2/pdlD0+to/0Zr2ypzVVnKhIME1HMB/c +Ymn64iZTL9VZ2yz52rRd35dstUhaTUp+/vB2S+M5uX/YglNmDKXl3/cEdj1xtashIBIR8AM+0DdY +ryJw9HI4jB49DZOoQPw0NM6U3S/YmYfvWLhpu8J53VAwJhqa9STvUez4gy4ssHjw8jcQG/g3InPh +vbTG8upjpnWleJrvWli3G82NmJEYxmQeMqfsuhJwYLFtm1OWmW0czW0DrB4SBGZ05FNvlvxHx+t/ +HHLrhYnXaJpD7cPVQcObounPXDWhxkZPIEMn6XSN1aDcvSeEdVy0OpTIcxiPCJFoobt/6IgA41HF +3MP0OexfBVNX6oMr5LpSj/XRCnpoc9rHCrt46ezwmFjY8tEGLcNsWiEQNzsqwMsLcYDUXYqEL/Jq +gx9l2ZCHr0NjK3L10u8KENOnjBT+vgYzz8BdXTvjK/n8qgNBAeibKt5ewpugDZd2VCIx2HIM6gto +yKD2uTrQO6C7gvoeikRDTcWkxFrQQ2L1b3h1qwy4/u3qd9+L6Hv90+o3R0ffnJ19vPrbzR1l2Ayr +J0ennghreq6B3V3f+2/63q8pl4jwmp7+Ln9e/e4vN3d/Oz+7uX0rmP+f7IhaDiveMwLdow8G3i92 +Itcff/OnP8a98vd3N7dX+iqOUjb325sfz99886f2jXTi+7tfL8/f9E3rVwtnLTs8wkOGrs+n43hy +pcS3N//a4IKGL1Md4ZgB1wVftVTZ2ar0vNrHwBupDlOi7JmB065SClw+FGpobmryzEE9Jva6ib1u +Yut0E00dWeSYJGIgfX12ptmSkcv54opKv/RryDNX6iwYeWaW/fwsM7gTZ+BIlJhm3+DMe4hpdg2S +KZp7OFqEAZow5rmwNe4rUgV19hiyzbNaOZrdCgRwGgE+H+O8hl2u1esk5lamESkmrEywkxxmYNSM +VwBrsMU6UFeSDcQ40gjqYilwDXdZpyt8h/14jP9uZIqEAK+U/TbMmfgA+03POUefB6skvOdiQ0Db +nG+E2FYj5ht+7zghHi7aON6/fbZxm0eL28Qx5eznZ7pdSmuExDewbV9lIFlqXZ4MVEaQ764Y60AQ +q/RCmQ6UL3/pmnRZvYhTLv8MRt54a1gPQ6MPwKopLA7hZDqqdLr1vebtxpXeIWy78o1+nPenawe+ +iUNQPromXnwvHxk7+CqbqSmoa3IN6GFpI6JJ+SnSxqRrVwNg1xPG4U5maQDtxqZBc3YMXDNXDNsc +z9aaTn2aKFOARpiq9UHDYKV3ECHr+kmkmUWrkp3zzSuRZv5wc7u3sO4trHspZi/F7C2sewvr3sK6 +t7DuLax7C+vewrqbFtaJPfXqYGo8LdaYWNcYYp/Vxmr0Zo57bazgeu1jZR0ixcpqkYl10vDR8oaf +ysJarDGx5vbUYo299V4ba7HOyDo1Teamy2mR9bCnN7Ou6zwzQmVm1jWDWVfw82gnqoD7K83e1vqk +2omT83d3e1vr3ta611LstRR7W+ve1vqEtlZc7sMsRlcHpV4BqBkHRR4xNB0lWLK2npAVixG+Y1Ay +tmYF14D66rP2P7dx1SDwDqGwrVUC3RsrW7QZ1M7J5EJD2yoC2HBj94NFG5qXRsbVJW0eLW4Tx5L3 +wjR/Zna75J2O0CjR5OkscSHBkunsJIMlUyZg1QSGew4btxaUDJ5ZwRxU3gtKxrYMlDqrWMQg3HLQ +y/6DdPNg6ivteWVLMhm3WJn3Kb3PQH0HkJu2cesgg7mq1szfuP31sAfFis8hVUw7Rw== + + + qWI6ih7YDzYrvhbYj0MtrN3s5u3mH62bqk1FlSLRAqQ1qwXrA+xQTyCibCihvBr76d8ufvp5L6Ls +RZS9iLIXUfYiyl5EeUoRRS8PTXJEDJGxVS5tdKBMJkkF14F6CYT+nk4FkPQ6l0+GjT+jkBJ0QPcJ +KUivU7lHijZW05jMllImjY49QB9v9KmkFLpXxrWLQgpNPN6mtePrXCpQSM+lJkgvX9B3bwTBkld+ +HSgTaFLBIai8D9RztpNhdHaKVGMunERQXtwcphwsE9hgpNVk7IT0nDdLOZ9mb9j4WtCTCyaTAaeo +svGQM2guhEyH3cNykSMfetbqUHSZzP29QskXLw384/1eFNiLAntRYC8K7EWBvSjwdKJAYsPJ7dc+ +BYYRhIzFto/bgi9eD9KoDq8XZ/vShlWMAjP5Z0lQWAOJDZ5M+/CUQWG8vWfAY8vAlDtHYvU1MWHh +kZINEn82D8SEPdbkNCTskSZxPNlByvrPIw50gTqaJqMTCBocIgLQBUzcWw9J3Pk6SDWGMPIvLruK +A+tAXbkMlCovEi+agVIAWgaajqaTCwavUjBYikjK2u4bmoK6WKZuPqaQrhjrzquZ9uAe4IMCgmCe +N8L2fJKAMB7k1QCYhWxNB5rBuqHF0K4BZO3IYrTYcMrX9OdTvKwKzWeB+1iZ2NVIX+mw3TyFBWPR +crwmmeXuTgYiJGr13e3p9U/nG4WAwfqLWz3gIx0PokbYIWTCT6AiVIfBertCEl2PC7ESoES61PRQ +dK9TBUVXQ2qlgxwfENRkoJMDlrM9ZFJz3u64U7FwKpuq7xucDPXe886EWrkdaMzqjtspq+rBA68Q +TqM2uG7UNJUcGTwU+A63JJWh0UuHhCMxh8GU1YjvQdp8vTzw4dLweEb69FEsxcK2jzZpG4yR/OfH +R6BtSh94qrW2xOFpGu99Uqs5/AD18XpxgQhlepcfDkXmIepQwSVuSFbT8r6VBJLldhEXPK/eTYBS +ljb9Tu9S6VS4Q4b4nCOD6/ghlqp6UDGutsjbLCY96iroOp3hfdfyZLBdCqVsQySeMN83WTcDL0FM +sAKhiOxJEJRlOoAE0Y7GB7zlPVOphq6CbGeMetm3Oy40rjVvctKhSZ8ngz2ejv8+8bJ3KR51m0fo +ZHCT4ec9lQL940n+2E/mdMIny3KcdycbwFdv1oxKgOMaJ40O+zjs4nhA4xGP1+4460bei8n83QvM +xeDKrZfx08lT17w6ClnjS+Qrl73skVJBDRPxbXp5Mvn8XqLc2iiBBtf6VRe24KXqNbFtzOremIrX +0hhchNTkPH3ZhkOHQB9h6nE71UAGlXVBvgmNhnqwbKj06m4hh4sbPNqkwTJeCjmiv5+oHhM2jbea +u5gkX5bMHcbYopP0Nr08mXyeCFhdK7w6ZJb8qwSIz0JCqqzW4cdrAE8fkzDpsOyTrIvdB12XJkW+ +gFCEyq/f75/rwiPlYu0ncrHCTjiDy3YSA1u5gCeQc74Jh7jVzvUA5V3jQ9G9TmULFE7V4kEOqOxJ +mdX04aSavJFxD7LeZd0+HgziUdZUaCBvGo+sqRMGrH446g63fOCuZtMIv1LbMOTwalhSa43Awm2b +wxhf3wiQd2w9XDiAPE1i8Za1fLRJy0LsDpvmc7Ol3XpXNO6AvWuCi89oO665XuubAJEBsrrm+i4V +ZclunSs1uwyeIx/afVyMqyrydopJL4phL4vhII5Hg+p4zx611Y41BESuUy/YqNmrJrbbHhrDi8sT +RLsVH/CWl5am4lq6x/RBn2Jbg2/HNeXNTDox7ORwDMcH4zE9xl3mvepYy34Qec94V2zeNTCS3eNJ +/tjP2GhKx93NupB6LOfTFDKoZdLKsFPDPo1HMBjfaI36pruWixmQAedYZTdGZnvw3h/6L8Mou2Hj +bu+GmWoBYtKiCBLECYetazOQ8Ge8XQsxldSdhVovKmIorW/jTsUdOrhxk3xvt71gTUFIbLfF2C/P +O+MH265SASfeA66X1/e90+fjg8FOBCjb6QlUTOot1rVeTPpYTIZRTIdacDpwt2eajgIz5stsXqcz +jcQZ666EXLMkEUeGiyLADZaFUs4GC6PlFi7NYDRpcXS/b7I8KkRusEAouNkSjTZaHTm0diybtYd6 +FZXVgHZh0XFiB9NBqkYzENfQMUnV6RmMTPpd8KXMRypcaOlmlervAGcHjVACbzKQsLgt7uHuakkA +8krxd2o+lU7dGw/geDKk+SmgYMxs0fsSod86SFmL0No1nBTUZrjVUVNBxYcimNIfIpeAcHal3jfe +uy58Fsmsm1CjWVCuMKE0X3UgmTMfJ9Q1cPpJAB6R8Xd6l0qnwt30xedjYASuu+sgIpw4xQitIT2j +9vS7azoVLsb1F30DUVjMUCWOrMaV7cxiF0GCcKl6vScuAdh2k/ql71LpVDhDjNiwjD3A2S9Bgk1z +ozWkZ86b7SZVX6bCxbj+om9gArqfxxj4Q/QNX2VP45a1UjsamN5NPxy8XY0np584fD2Z18nMT0aC +YpMpmExSP5DxLbpV05390X1CJGm9QVH40BLHA1HbB9z22BHTk+4zfGXbHNIV/DyJLmC1ooQQ7xZ2 +ZacEVyWMkCLT1KrAaSA0jFRGckZQk/VwYfBc1jRRZbSwxaNNWiyZI+Szp7agbU+XAbeKkyWr9P7n +qDXi6/T2ZFog0xs18UXr6sqq5qjR0go5AW70dY8LrAU9i/6ob7QpIwsUO5ojcf8pu1f6Aawr/gVo +k7rEFu3nVSP94fSfN7cXd1F79B9Jxvic92bjMnNc21w4+FVVMDcIX1jzNtEEgtxTg24CAIMaspe1 +UH44sIJVq06ZoYaqybZ6xSfuJDVenTnb4Hiltmazsvp8fJAgLXLYqGMHMhzBy1I2FW4DlbLygpdH +00Kn6IfbVlPf1O3UgvXtPmItTdPVwmtmUyN6zWzXixO9o9bwOvDY04KDISQOhvfyotlsxBRNa146 +Gqel4My5qp+5gtOLwyTrb5Pu4u2+knaFV4ODJW/XrbJxIsNPDRUB7ouO13umr1ARUsf0CzVezOPO +5zK+kJGlVUbCHm97UIAtJVRskXvasV341Rkk3jsmaTc6ITJt+MDZkD6g42g4DIKaIdWht6zwalI3 +npAEOVb/wFC2+Vc13aAI4PWwAtCbjZ202moyQznNjVF/5DLU9IJE8lJAMH2cTz3s66D5D/FIi3Jd +qTvpoYFVWGbbWxmVykSNTOoKR1hlcoQDe8zu8hMfP8GV4F6THLEWsM2401bRWlvSq3Ej6teBilB2 +1XRdpQcoNH/9aDhib/Ihc1Z8PyuYt6bJ5m2yzMfTlb/fvfWJPUYqzAHveZW/buVxFTCve7Xeqgiy +Xde9/o/zS7rNk+x++wSkFzvbNnpNUk1fKQOJI7T04wzIx3uolyyDYpX8P9QkGbAYlyjGleLG4ErR +BgiLG68ToHtOZfoiqdpUa2qT/WA3Msjo40lto+bG3Zn2+B3cuEvs9/T3SvOqItcfiLxsTGG7KHIS +dbTTGagYf16Ma5Tv6Vwi3wecbiQbEVB0EH5NGtcXS1UXXd2p4YKdKdgbwCwXpllNSqTasmonbY97 +Nx0A9zGCHmqnFNI7V8fbrkpOgmw1eCz5lE8/CC2g/obnRgbh/dAxE2OC4Xr3gAzSqEeOUdLOlr6P +VB3VtU6HPSy9U88PEb8sf6jZX1a4boy+EmY88PJ4ByvHMa+0dyR4UCEJ56z+kCpww2GA8+OgkqiZ +NQ4+3fDpSXnkkLLC0QW+sMhhbdVErQthuq/I0YHZtzjcbA85OzA8m0wPEjmv1SSlCMFrYB3GGuo5 +psN18FZ0DSHkLWTaSkZ8tHHBO0DA8SATc3bQgWRlqrpG7Focp9BEavEMmCdLhwEIEU5vCG/KtsXV +9SKY1oG3puOcDLwhvJR6OB2mNBUvZMfd3bL9eEV4YOgJVEDeGl487rxnO/Cdb7QduNMfwuGSkyjy +S4VCOFt47oAw4x50+bTqn2SvVxjL8UEGCsE36pcrc9MMAYGS+qGqB2UjcGJl8WmQln7VFuF9IaKh +jwuOq8yxXDJB5JUMM5rSLw63swOFXRThe2nz0De2phaoafWCczm5AZAJhNsxpqENHu0AR13JUdYN +nB2IojVRFBPqekCIk85CCkILtTBecDmtNBWra+Wkn2xGbFLwBYGcEnpaW6Nu8WANbAcCN9VULZME +OthAewAWpgy6RBEkswB06iqRfemVWUktRYjQFUFLuIAniEc4LYi21tE9dq10kNiRroLU08lwzqhL +f5Y74mlf3kJW4ebqPLIK5klYBeejdl9QwIQAtZKclsJ0awblVvYCo2AiyJVq8joByt4LAkdb1jY5 +i1OqV59JR/aYjSpq2jKQYYbpYMUvWgVUh5UN3Hsi87dNDmNNDM4BoF0D0FIASL2If+lrngz4JGU6 +L7WsrVnZlRyAamiIgJMO0PTdDGA54VM2BXXFCtYcwhoIvMiZv0ivatGJAsPe0KaSupR9Nurlw2qb +z7dJ5HithcWv5EjGweGxxzVfcmvqdgs3zne3P66K1dHlR24fk7SoZu62oKxEzpP0+KqDOHuopDLo +xT10eCZBLjJQwc+r/vMOkGrEaZpAgpJ69McKLCKMDGKH0q+zg/G7roex8LjHZzMMO879Nn6AQAjj +4S6CfxGcSmbF4cCt3ErObwT1QF8C3S/bskovwaN6oUe86IPSKG77aKS3TmSx3ryziZpuZp8+v74u +ajENxNjhNNrHpnGqJ5fBD50+iYsDPBQy1VoXGN8j3B2SviWQCGOH5HSQrrkFliSAMG0tWVegUgcT +ymc0YJbVQCTDWZF+EJFMSVUOASxZ9yX75672BEo9SDWkLvb9P87GMsuyCP2mht14T/OvsM1OL5kR +LrtZEz8g9NvIP4p76YGXzAhpgpevCXIICNM0jYoOtnG0HPoSLKs0WwVsmd6TglZFAwonZ6rssrrV +s5T3J0BWbGC1dPFZ5qUKnCqpG2qmHhDn7vgggcgGVc0q1QAhrElzx1/HvDijrZvQgQqWrvrSHSBr +IYPFbnT1aDdT95PKDs91RDXL+yRyggU8kCmsckjWVoRBQaQXB8Q6HHhljif9OlaSVfXvEolKhdNz +Pl0dKPYi1VFoYImrVVtIReFm0dSTVq8yYOrauOv9sDTYejTq6bxMJo/lppOcr4GOi5HX2agnUzIZ +wNh42PSXKkCeqXtKA2HO0qDtaLCEu3kPE7Ybmll66zKopdM6w8saUkcC6GEnZD/7xsIH2ma1JEBq +6uygA0HwbHyKrUY1CN02FDxTWx2E8ol2qP+q63Rf1WRsc45A4x8i3hDHIqnRnwVvN2idrdW7XG9p +6QgNpjtk020gXTKyS6Tb0qdrviPMq7AFttlYF/1TNPL8MBkqCVC9Gdng7KNGpNJQZfV0gNjY2UEG +62766Cpqk0ojtRYBqomKXeo+6nrdVTQe26dPt5wzQv0rnfD0oIlQaxGCg4XGutTrKQ== + + + 44xrSC3M/ML2VIyf6EAtwrAatRanFEGqOoOWyYWqA+hMQZzKvolx8H0tEZBaOjvoQCKlV9FnV2tB +ctvSZS0lgE4ue9N/E/vb1zIa06fPLNQhCPzQXCLxAblEoO5AnFsJNU+V43ILV6JSL+bRIOsOgk1r +hbloSJAU46hp8zF+vgNAF+ai+1gEyT5tg1ElaKwnA8XGqKXqYJ7aj1VXlQg/VetC31wCQDsau5RA +/TBiLeNxffrkViJj4mo7Tm56AEsCJoKXMglTjqZyQpHxf7KjG42DK+kdddVD2hgzIqSeCteCIXMB +CKYKpw6AmcZkuB5kIF5Dzk61dIDYEFeng0BhuOoqQboEXo2UGkoAaH5iZxIoHwBrGY/oM1Bi+Pf5 +RIvjQ6GJziDq8+Ir53KJoxCE8xakDmdMreHzHQwxmvQrhFK7LakuNspDB/p8uR4i2NgK1aUmrPvK +QF0FXrCrqYOk9rDZE0xImLOBixFrguqXlKZrL0HODvpedV91Pe9qmozvc1BgnKF1osD6AArs1A+O +t8Z4MP/3HnpOBNTaUMFiypZCTQJBj2/VjllXLXWUPDlgfkSIbnrGNlYdfoKoC6fvq+gAXTNnBz3M +4JYjt0q1qL5F/Q3YUAc4O0h96UBd/2Mlk/F8BmSWOTTxmIu/kUolyIHqcMwZCw/znBhTaBwRDWQs +8yuqAzwNWXJihramXpmadAubQhuDgnHSCBlS9hPTCknhGHd20g+zM6jbJvnHw7FJKKkAmkQiGEF+ +BpcM5ThgAm6YYU0T47TR8GGhT8YaSUHdB7IUNXhVw5QjXp3iYInBPUO89VaEeRfqBpotBgnSIOmZ +cYWXTZEVOHSqxI/eWjQfNvyAiuNjHv6uVWNh2tYMPSM8wEIynLeze0OHKnWHK1u6e2EWmcujbGGM +k1lzTgMs6/QHQLphwhgB18/aIuVPE4OLmHWnjul3mhDJcLC6Dxj0KgdeBWFO95lrK40s8oIaMpOw +rsgvEQ2rNWWbOuDqPwdH78YflnWr6R8xEcn7wpdtO69ZuM5hrUKlVgmR0O3akjUQyHkNdm+DUoZ5 +PaaaiP7LQmCE6w++fSyF0GN+XYuW5WmuV24aWQM/008uaZjWqZUeRMCH9Uw0Y/W0Qqieg9msgBtj +i61JL53WBzX0awAzdeYVFfUlNlcNrxMqO4To4lQ/lopqjU8CCKdAndxyHCyPeG7VDIhneMycgSwZ +dV0SCQp2VV6+rbwyLUMwaNdkAnGTBAksTh6mFpAjjixyBUdwbPwQParQW5IPoQSRYUzJOi12fB3Z +EwyR5CMoC1OjNABI6nB8QOoArtBGp5jEEEHjIkWmM7cZvUAIYt0SJdu25l/KCSXsmkJAmxoXQUDx +ZOTAqlAqRLIBexoZsJoUmvbDml5eyMthWxtZzdaQ1fT4SnYZ6IbI2hUEOZpkgnwj+8yvKW8a+My0 +DRQaBoQSct2Rci+NGm9kmmEsmdc2KECFbEk0aYJAID3KmqKy63n4UpZuvVfiMbfbURavVedHL9JP +Ix8brdLTeIsCgxv78lSkybUZsp0aG43TrWqrK02yhIPZNSp28Tin56Oho5wmUIEbCOkMveUOQ2vo +lMCES/xKEz065mbQCyZ5p13hyP9SLWGhzaCdsFFR0tTqwggXzACdExy/KfoI+QmhUdO6ICc9S+lr +jw6Ce4YhnZe8YnsJ35Nk7jOwRMEJxw1+h7IXMgcq60JfAjyj92DtgQvHMDvKaaspBalDsFoS7GZT +qQPBYOY2JiIVrG5AS9fwYDPGqXugbB0ZeAmtOcYqjR1SJFAB1R9G3RqMnnRXKF0ImmXDqCJApIpA +HYtBaoWa7vpypFsYl6kT9A5OrO2a0lbmrVS3HePkqBWpvKH/PIxfrk5Sa9nOa/iI7mol/Obl+8rr +zSTjcghr8C2CKkoPOYjF5vVXWO0SJlYyLS1D1T6ZbixemCe5mkRkpdKUL001hjnc1TBOVRk8WZir +rw6tMqRNcJRTatmDFMGoysV+sq1qz6hL1i1mKnUQU5cqcKysuFIpBwDvtVALkZuynaW/DrM4Bd4c +pEY1+MvR64sG7Vo/odOg6lqj0jNolsOCLEVQHla1IdIancQgFfICrDOSNXoUCMJB/2z4laEHoqdn +r5ZTS46PAehKDimi0PNM1SadeaXROzyn87ip3BIcWWK9DTz+jVDBU88ATPBqyAPPE59MSAWmwKnS +QjCZhNp4OtTLtBtV03qQYVkt2cqtsBOtZokRYlAz847MVYAgqneKjUrjJqBDevCFUOKX01yVYEZd +w9grKwNaV3Rdw0d6NllXN+qtZZxdW1R2Zsozg74p7zKvy3oLbluBBnFajPlk8WXp6jwN8+FqeBO+ +LBmBl5h6JFp14aFjUkXGAke+7GANPUWshJ7v3PXwcocYo+ZHkhc5jXlLbhDKUfFZrVtR3wK5GG5O +Qi9qKGypj/Je9VTUiWhkhqMvX6s71ekb+G36ki6iYE5MNGAx1tnBW7LULRs1zs1hdPgDLBLBRnEI +kLYy+pXTGJESYSb0/lXadEynWFVxydla1jIKqIrg+Q8qUleeypjhxG3MbHj6PB5qLPoh7DJCjJAJ +3NbCb6siTSZB2nU+9EqOFsm1hGBYeHvBqwDOaqDSlVONAfgo66PQjwPyBxqjPc5piGK+jVG4k8K1 +A8cHXWlVw3TR+DrpOFpQJQdZH/dUzGn1SE1FtjIU92xpzLqCQgAg9Kpajgq2o7ndFQohWAolIk0A +ZVuGT+c0lq3KUxAIeDOXjXthPgP0nQkBCpNdEAOv2yZ6qFdV1FpWTYzdqtRXV6THVp0pLFyn6DNe +qXMsYDj6PTLcWP2IGmi4MfNr/aRuo8qhxXmNzciUhqaJvqwwbbWkBojNp05aPo0O2Ay3CZozTnmY +Um+sA4Ggg7scNqRqFg7ybfRFFykbbrMgGC0N30iNwBzM6oRsqaZxBMDAeAyzRUkug+6CZTT2wuMb +lIxUZzyJG/MVzBVYqo8n/rRU0regRD7UHkncwOWHGNsWrTq2KcGi13Ezx1zrXnM2aXBBELn7kFqY +ILybVGlVNoGeGDqC1gnUlfU9pR1NRHBWbKqmOWTI1RGNBTXsi6rbIPc+r+0j3JHpmqYMUbnh3X1F +waq29BQQlJH3KqPM7DeKS0FqNyIf+8ncxcI1egLiwTQSwlm9tIwy0Gy0kYeH/IEtDgU2TlfZJ/Qo +dj7uY8ES4QnUoIcT3NJBiSEiGjfIjYhrOSg+yDOUowisUZuqMAKImsCFIqoGIIMPtYO0o1EkPkZL +QE7E3xZaL8dgJh78tL64CvxLw/TqcP+qGbPZGpADOQNp2DC0f4DeuBgPJQSwBgVxpSYaLw+p0aTD +nqUbucbLMH6W6l2hZiBaNKZAAQZ1rNC78XxtzGG0Vcnwxor5LqXNRkNsDNg1K+yM8PWIGGiDjUpp +1WfAKlgy1MCLFLXCfZ/Wq+ObI/knb84QTOY6c3WtRAMRi1BpruD5J8RXjvxpYeEIYIuDlGWF9uvC +HHEePcwgMJV5OX7nNYs978FxIObENIFa5WnBGiJiSkAA9dLR3O5S/gmYJykLAuebT+cylq/Mkyg0 +WoTmz00c/0TEonMfz+8vaemaE0Md6NjVgeBhRVt2G+PE5GBjPo30UxXrbfSgIKhgad+V7p9TAyoz +RFiT1AOxGgRAwPBV9j8ZvqShbhHS9zkWnwzi3n3cqDE7Jk8UqYpZL0KcEJGOZE7lUIsimDDUFoGA +dpJVkQIWbExeDkR6kGf3RlRIfIitg5OWPe4yhhgaH62DI4t/oHQjtMk3QSPqh2kVFzZ9tLRplqZ0 +praTuP3+MdSHTV1Tp4iUAWegErxRN0AmvSZoCTrxSujFCLVxho5Z+PVEnv9Z/g33NPk3NDylz+Ba +PlGACrJjjAJUFPQJASo4+O8LUMne7QNUdjZAZR+bkrLePVtsyicmvtuHqOxDVHYpRKW2D4aowNVn +FKEC0CMBKuYZA1TMnAAVujUN4lPygX2m8JQy3hCaHroQFTM/RMVmUSNXOSwPUTGTEJVqNQ5RseVn +ClHRigYhKtVqEqJiJiEqdlDReGyfKUTFxilPD12IyqfGqDTjGJVmEqPCsOtBjIoIsMMYFdtMYlQE +NIhRQS3DGJVmGqPSvECMio1u0emhi1GpPmeQinpFD2JUPluEyjA+hS3tfniKipV5eAoheXgK08Fs +S3gKO5OHp6QBdOEp+Yg+U3hKzCBSpIcuPKV6lvAUjnkYntJOwlPaNeEp7Tg8RWdvW8NTWpOorz6k +8JTafMbwFORb35bwFOZ+fxXhKUSZh8NTmhnhKXZGeErkGrrwFDMKT6nbzxSggqRRnxqgUgc96Lc0 +QqXRmA1e2vFghErVxXvYNWVThErzcIRKmNfsQxEqg5IPRqg83ON9hMpLR6g0yqjtRoSKlFkeoNK4 +RwNUwKvsA1T2ASr7AJXNAlRkaoYBKtBy5gEqZVtPA1TKDQNU4F01CFAxywNU2lGASjsJUGnDwwEq +5SRAxW55gErTBaiEGLPBy0Hhqa+baXGMyqB8ilIJa6NUQpJVazO38RSnYlKcit7LOi3KUJUwP1Rl +VJzBKk2KVfkMHqT7WJX7Y1WwOz5LrIqPVwp2sSpRp9fHqrhNYlXIN4xiVWw5iVVpJrEqbk2sSjuJ +VQmzYlXM47Eqg3l8gVgVGxUeRtP1rg8ZsSGFjIQ8VoVlYuDH/aEqsOdpqIrNQ1WqGKpSNjPb7UNV +6hiqYteH1yBUBXehrAlVeaTHMVKl3keqPGOkSmmGsSrm0VgVP4pV8aNYlWoSq2JHsSr147EqvDjl +aUJVmscjVRLHtS2RKkYDVXwKVPGTkBHTppAR0w4CVbrAj2nRGKYijFUMU4kUgmEqQv41TGVNwXVt +9mEqLoap+HUFGaZShhSm0jSDMJUHOjsOUsFBtQ9S+ZxBKk37hEEqUF8Og1Top/hokIqZBKlUc4JU +2vBCQSqDSdyGIBXThWs4MztIxTfrSy8MUnm07fuDVCZFZwWp3NfvfZDKswapQJE4ClKBs8kwSMU8 +HqRSjoJUqnZ5kAquG3nqIBW/OEjFD4JU8vl6gSAVkQubGKQSo0WqFLgRHo1RkXWNUR+lmRZOMSqy +9WKMSm26GJWyjTEqfl6rXYiKiSEq64oxQCWsjU95uKspPqXZx6dsW3yK+vHcF5+Svf2U+JTmofiU +7OU+PmWX41PuQ6UUn7IQme6PT7kPnWJ8ykKE2senrI1P+dv33w/CUj7vpUN6RyoCCeDMTpeyHuQP +E2o47xkH23JVobyHh38CnPGaTdzr13/SDOvonmMzaqEhiFcLMm2G1oHmB80kQLyzEF3pvkl97SoZ +jwfbaz1W/fDnk3/86VvBqN+cXdyeyQLbN79dfc0LcEqsurzMFjrELASUnowatOAjo6kCCDoBSAhH +IKcjHE+jVisHkxFtlnRdaWu99rGFD1L08MQwcYFgGTU4VQkTkXBTdMxHA6XhIVTXQQ== + + + zWIRVCCEB1kDTug3Y+gxTV+YitcK4oZVgVcu4HE4hOPJoOAlz2WpXTZQ6rOb/Cv4rYJbgW9EKFWU +9Lw6Gm9Co/qoCMEdeaGJnVZYQpOTA5tu421weyBbbUxFX+1WM0aOunM86eDJc1xNhsVxK29wia/h +X/oJAVypS9t2Xbr0/fnp7dnPeqe0RhJ9dsoBJTvCoCFfIOXTFUEBCnAqXanogJEVTlgm2j2gb/OW +8erc20B/qMXkZ4Ury+RYvuSOELmHLs6tL9Ubg74/IkxVdaUAuGat4DqAOxTo+G8aNM5vZVEuIZV5 +5ytSkKY2lJZk4CU1KWyTV4/h2ku4xTeRLlm9loFikJxdl4xFoASEC9YgmOFm3zI+M6Mi7DOgkO0h +N97ZdHYuiaWT6JP2/jiUj/E/LB2l8RmLh6iRybIocPHC4NyfLA2AGyyOFJsujwA3WSApNl0iABcv +0prZQk04MP7BieeKfPWmX5OlawEVm6WmN8CuzbWANyM0AA5lSoQm4Uvo20qaCrwNjQLhPQmOFOJ1 +E+KHoyrvBb4jeUkd/0d+KU2IwsqTXDbfQsY2RKgaNjBabtXTPoGMV40oABZYCGVJy2MAGo8GN4/a +cGjJocLM6TAJvDjW8ISnCItb2qGopVKwMnoyMEsXziDocHHLLQzCcAeCyye6RoWLSy6g8Cqr6rqD +eCQxtVwG4e8DL8aseWGnF3FQNaROs9Sly2p5Ta5hYkzTuqARUJ4OKrxFvGEonIyGewRY2ZaIERPh +QBXGMinIezmetxSAl+DkpOS7qwNE8FE5m0CCPZX3MXO+iFzcNo0qrXGfadC7XDE7zDkqvLfG6dS8 +L1Svf9SchrAza156zJWWc3r3Klx3W0ZGym7yNba3XvQLbx04cIjY5KAFOT6Az44GfDi4yIEDoeq5 +iQ7paSHSM689568EgXUN+nj1JjcMXS71MlxLn5xjmN3Uv7BBlE/NBDHxGhyjSmvZP9FluTqs6pKF +LH31qFrTGFV1QYTGyiMXLe/D1PvXSSB5u3q86wSgxun1mqUJyrI6mhcFCb2z/ZKMV+14so4P3xcJ +51BZEmPbmRqN577nvWmFOfMNzoAG97y3QBY4IOCy3C3kh+5Ob1fFSkS+X38bGaJ4h+tMslYCNWRb +q4QEJykenrxL+uQg7vmgTqAlQTAx2oq3/IoIUEUWvaS/GHDWG1LqkjJw3dZ4WPN+TTXTxiYd6rs7 +J8Aa8dWyrU2NUxvKUg93Omhw6qqF9mus9bK4llidhov4G3pJRCILZ047ZlkPwsNicLXsT9oSHLSU +UCm70iGiBUoSIaxQIFbx8udKGIEGhFKEQhHhY2w1hCPou68O4Nffajioo0b7REBNRR/B/nbqJvIg +AJU6fZbXZdFoV7ewwnNGHW6Pgm+GZTkGKMFsDCMHr5OF159hmB2cerySAdW1wwc08OZYX1PTjfWA +KMaFQJRpU+kVvJP3xaSSYtpQMe1NMe1ysWZgxZrxF2umqVgzm9lsn/TR4PCLQGTCFer2hhExDf1n +2J4m4pWzs2a1BsNwDGM+4b5JaUAtLyUu6TxtlaiOXw7KDutd03LWtdHD7MhvDfkejPGrN2uaEho5 +6I3Qrbyr8jgeCmrtR6qc9fiLYlRJMW5k3XwPuntyMAzt9k1k9EDo5NQX5BBCgiDsNmaRkG0HFW1N +15aEaQybaSOzcAIpSuNxcGs8rDsYh/X0W3Qa8kdDTxOiPRJmrmMquRkHQr2GdVw1Q+eSAonoA6Py +a4a4+85p/+QATnwgQwW97EvdQ9Ai0PR5Ajmv1pjk/gMEuFEV01eDYDsN+ewbox4TV1RlfWL0EkIO +ZEEYiXQynamTB5TdGLIwWrybsGhquH2p0zGcCid0E6HJDYi5B6MG9s8jcUnNeM3QVFFLjMhTwQKw +ucog/4BoWmFYmP0YfmuIWFlXtA6qUAm2iUago7ONWz2a2yqsSo3asWrotYZq7ft4kXTSl6uzm6v3 +Nx+v364+/Hz6/nx1dfM2P+YfVouvwWtVdI8wW4Ej3KYIugl2q+Z9hN8gFhMMF/FxguNfvVmD5dzK +PZ5TZJ5gukCnuE7SMMH2qLcf4btOwwjj18ziyf36+AVLl6nHzfNwpk/MQPZ5oj5+KvvY3s8/uof4 +R/rzruEfq8g/jt4/yj+6jn9sN2YgjZpMWwiCYOpMY00gA+llL63Jz0M1k0/JG+JDjIRvDdJCtQ6i +aJ6f5zNl5xlwkJYuLkMO0tLDaMBB2sgtLecgHXk2OGDdy0H6z8FB+lkcZN6bJRzkaPzFmmkq1szm +PA6ybRdykO4hDtIt4CCHLS/lIB9iGIc1z2MY3aMMo9uEYRx35QGGsS7HDCM20kYMIyJZnophrFvz +MMOo9vi2aWYxjsPqljGOdsI45jP2mRlHuOoqC9cuZRyxL8nC+Vl8o+n5xg0aPZrZ6IuzjUPsXsw2 +LsfxpWzjEDXvYRvXYvuD7OO42uXso13DPg4x/znZx+XM3MXZL+fg5/52/nYTZg72tEY9yGGFRvJO +hRTxbwKn5zLaBPlN93L6Vfp1djB+Ny6cVRx/ws88AF4jDA2mDOCEMxoGL0hQlgHemsLjlXXJLwNC +nU6Q3Md4xwwmwavOrRIeoWsi/jjuRz6LKTSGZM62HoE04F3KClalkq4NoAYTOlcDq9Ll0umhIDdI +ZENybU1+MlEt1lUlFAZ6TBl253flTP7DWZFxWo4vBA2TonYxJW6EVVQzN1ZlHRJA/18kqD6W6veq +885UAcj/UsIMqiF6TI3gmJarNTQBGPpGGC4RArEw8abGAc10B2VFvhbxOKkJ/avJHrO2Y79G3Sxp +rBn2tZh8U6Q6+/yONiJySiOp/+UArZpp3msGDqWXfOdgJiopR9PBGJ5/BvY8B38J3hKod4bi2TEr +IyCN5tAhxDAm3+qz0efGdY+camaJrZk3CqSIc2Y8EJ1Ox44pqBigHXucj4J/Gc5nVzrm4zj2TRSE +zsbz4uFJUxPzA9N2RmvykolDptuFU/fVm+nk3Qt7cErR3YcndZJdss04yj3dnEU3EUWpbATPaeQF +Y2BxSdnWmDX2GB80USzJZnooyFcJWXTKm9WN8majdLfelTT5tyJtN/xhQsVMWsKKKpEUJg1oUSIQ +HnEpJUKjEK60J5t7srknm5+fbDYDQRxbAjyRyB+hpRtRAmW3XIHJh+YGHaQ+zFf8OAHORFA2Gj0c +IUgPCKEBXjgIHGHWHAYlh0NmgYQEqInPCjrbhBZMP/MIoI5q1QsefNT4JEeqRQD+TweVHAxAIuv4 +bazeIwdDctsaJnaoNPmcgwesQyYnWj01K7DmYHIxXjJOBCpJ58hgrh4KVABpdTLX4EiLyuKeSUQ9 +wbttDWvqvIh61I0hnTiCISuQBKPyMZINMvjX6rWXwdbRP0VE8BoJ7HiVFFJAw0doTVHrK01dJ3I4 +8hboRTcbNno0s1FZXNjiIb1bhnQuCEhYg5c9cBFmQrBdjJtfvVmKnUp55uKnjmUphka3vYU4Otr9 +ZsA0DdYgnbWadFJPxUadGxtQQ3hBQt+KOaFno8ERX9Y8iSAbyYHe0iGSGisrv71vBiB85ZEoqamZ +kahF0hOpuo4AZMN1zKngYi5daJKt3ggbNLN5e9ilLmXSJ6ZZYehy0JSNzM1CDyuAqNI+AShGYeMr +R61tqz50dPtTtoz5q2uqlU16juwcLxWVDYxoafIVLdzTeKUvJt2VINwNY6d5NpZGMzQzKdnJAZ1g +A3iP4NVSgug2nhF0DzwhLwLXQvIijfIimgcXEJxBgFhGd6M/NgAP65LueWP2JP26V03oa/rlSGUt +E77XQZaGIVVtuY5EAcNqnqnw3GECFIfAON6khRhdVbs5TV0WkPeISSB/YE5QEZp1UwYYAtcWrWpc +0owkbEIuuWOOzjZu9Whuqw7ZQZHwyQReBjagUWaYVHYN85G2jPouL9w0oAKTbYNNPtk4AC7fOsKY +bLJ5vnqzZvsQON5AApy/hZSXWbKJWGK0jQQ23kjkv4ZbCaDxZiJstJ0Am7mh+tUeWzYaex9JHTN0 +TEJMZ8463pjA5wr+rXpbAJ9hPQ1k8ZgyBhuCk1YyRr6ukJoOKmAu/1Mx8iPIg1SklF0FAdEwMx5c +XZFRc50OjohRIoeB7FNkhnVyoDG0PdAjm5f3NAZipUGe1KbVzLNIIoNIH17aDtwZF6stLYNSrEIA +UckcjJu0djSntcAcn8zfYpGQZxnZmKKFwhYhBu/mWIoaTyqqDPaEW7YnhnUhE0il+hGmHPEwEeHK +zYYe8k+D8/dguLPE8MpCPQANSK05iEE/S9piJgoTObKYcpR+eDEWoTLg6RCDQGMMmWOmXWO0vGtl +lHpSCoFqSU6b/5+9985PJUkaAPcC3AEZBAhXvgokITxIQhbkLU4SwgrTPT1/7G8vsMfZa+w19hqb +prwv4E2rX/PNN29QVVZkZmRkuIzIQIklZp+yvHgxGQX1Xx5THwnvhECXUQLmlhSj/Y29spjJoksK +4YXvoqR00SsUsgK+JJXC5+5qmndN5Hqq8b7WKyNiDcEyqzwEqjeagBa0pd/cnwFxLKxtQKHLOgjo +1uDEyy5gWAUJL6qtqh6x+OYpeJk0KqolfgUvvsYN8N9AR9c/gmfUuq9iBrgxQ+fwumLtCKv6IVvu +piTeTWSShME8/iSBomxQoqhRVshp8zSPQ4hg0TV094P4hkOmLY3HhzQ4MGJSSdiH38LzZZhi4vAt +2I4MsPi06foe+81575dCd9AC/VPZS3N48zA6FFUIIIZu+eXxFegoTreqfsbgS4tjHEyJ53FVFIKC +wZjKkotP8j7DI7B6+u8QaNRGBK08EPvP+9AgbWng55OtHtPWek4S3z2Brp4gUC6gHb3CrGbGkWx4 +5BTRUiuE7vglkEGIxWuJ1UunOc+dUjAniiYFT5qOkZLhMyMta556oubAqwk9B14XomjwmZ6mwSM9 +zYBHRrpWP3RN2TCOwkDbEBULUTfGoX6sRgrXyj2WVJVoU4knaLHCW6JhJN4A7nW5O3FvMwo+0SX2 +HIkv2kfXSGmmyxs3Mi/vP91XMQPcmLZvBl1RoB5d1af9y9YnCyu1QxccvEOGgnmYUF222sj4ykyC +QHf6wnv1dJuDJAS8DwUKefNoSr2ZcX4puqbA/luWw/UIVLt5gZ5z3nsmk0DoQRVW2dKqNeLEHat/ +gsQFXhrxCfSrJHFxMxpYVH5lxaCoZzgsLH4YAamHyOF4Pd00Yvp5GpCTXy2xoYsyBccVh5dTwAoE +WlpD979ylOPXkNnDoo1aavPYdW6hrmF6PhAhzpF4i6jb1HLqNqlXtznBoLdwgo67IwGj4u6cYNBb +VI8kvUX1VcwAN2boXNJbSL2qRbpTt2PQcSiQKCAeX51FwuxHO/0lBsxEhkXXLSCdgOa0KwrVDxpa +gjStVPlQfQ29hgzl+LVAYdeo9oosr33nFukb6uwEz/FavVtZMU5ifDz+C+vIYt1Kvw== + + + pCagG4HgJepImWBQBCqJ3Kp5n0a/gAZu1afRQaBhqtFSJCLiBflvDREJKpaHbsiRHsUMcGOGzvOi +uaAeo6T+qieCgLMCnqYGHw68joYXwrIyiQHLPWlDYthhTODLqGnGhGnwKpbDQ8Ndx+0YWA+Ndvwa +XpQmnjwu0Xduob5hJjusW+Th1FNLgKJuK5MgVmu9ECFSX/VkqH7omhA1g5NIEaqXCxGjpO9ryVHS +Vt0SpC4cjLdyOWKopMGeFkzsacFggQgGC0TCgcqeVj8S7WlOb31wKtDKA609bcvkf75c0mP6V9jT +WpaODVQwLhf2tOWXzva0U6fW9rTVl0vY06SJPa2lZc1TT9Qs8hwtPYv2tFeKFu1p0mhPk0Z7WkvX +6oeuKVvDo/T2tGfqluxp0sSeJp3s6QUVWxb++Xo2Gl5MusNZd/gRi+HHSN1Vv/CdjeEbAb+56M/B +v+fNr05r5sMXTPpzk/n003/aGDY+OhOgGrc7k7D9Oz9+mW/0+12wU8ef3ZbYsj4a9RNAxR7P4v7z +Pxrgt7EpUAMACHV71ra9SVMEotRvzBzb06j9FUzv0LZFIEw+4K0+MLbFEyFZ4xdgQc+HF43ZpwZ0 +/rMxaY2USYJWCIRJ03rnPzN/oftHFyDcHmgdgWiMOxPANmuzyajXAQOL4zUHRKJZ8RVTjgViAIWo +kQL/hFiC/08Q+L/oLzEE2W60C3WukB/qmoL/4fyoyAXulvwl3dK6KdPgP9KEVf9Zeb8Y1XA3oG5Z +PytJzOSv7lTGMeyURB0CXuinMZLJX9Avr0My7+e9InmVO8BsT4JxSTsdEWPCL2k1uA1o7qcSfuk/ +EFMJP0IXGadkzWZR1FmMqK7hELpxUYT5cH7ZYFTczQpF8NYEP6eMC0bckDwHY4hgfiS6jQnGZfKI +/0GzAY2acDtqz1SQxG+kq5invsTJcPTnEP0BZDaS62F/4gxMwx/1JbJAnv/Rkd4m8mKOYanbBzOD +7QGNdId+3AA/xZpuQmwSBcpC4qY77Tb7CKARQm3WaPWWguB1DLnGtNtSPseLjEnKf/7+Pu0AgUZa +fy9+cNTvz9FlGKNJvDEeA6ThxQEfdUT0hTRA/VWASn/x/R2sHWhd784QOAr10z+fiI3BAO1u6Q4d +DaddmNop32VX6E7H/cZf+E+Y8pnAkMRVAxO58gFi4wkSVdISYOIfusqBZwROk9MnSKl8MLdPQJXQ +SBomAN5lzd2LoIHRwUhiNT5R6Lz79/w+f0g1nDBGJr6hBD/HyJFmFfXt+dH8/Xs+gNHGZGayYrl+ +Z9j2sOB2+EwgYAqu3DlRlckpn1sM3mYe+dGwPe/O3MxBDWXlOwDS34rQKV8/cz3tFP/oDM/bbUSS +sAsFyZ5uexELTKhSvUxrTSAbG9ZlQR4qdPEeDNKjYfFairMoN6GsozzA35wGf58p+RLF/3RaczgE +9AJ9aybP4P1t3Fqo/WZCzS3/WAujtTBauTAyk0D4ZIiEhyDo8JHjYZFDWGsC3/a8lkB/owSi/nYJ +xK8l0G8mga6WvIXZwqgyocq1SbWWYv97k8rzXeZrgfYPn5IngSasBdpvKNA4gRZQdh0F/peFPsCk +wNL47leWgXcpwBsCRA82i++uIWDeCCw4Z+0npNaOwrVU+xFSLSngq/QYikd3TLKw0g2KQoE51Mm1 +p/BfLtaSa7H2m4m1tadwLY1+mqeQEMXLWtj8m4UNDJ9cC5u1sFkLm7Ww+VXCxk3uwVro/O+mZEh6 ++BvEDv2zxc6/TmhAxxvFE7BsLrohD50XkTzDMJr4PJ6nWAbXlCZo5InjYTQf+7OOkhbk2L8LvyUF +fOk4AcuAoLsmMedlWZPiXR4Z7+/Dgz2xK2bNrn4cu1qqetyaXf0YdiXemUDQAg2PfRC3gleOcozZ +9R1rfuWGX7FrfvXj+NVavfo9+JWkXsH7/UlFvaJ5VPRvza8W4Vc/PDj+X8evfooP8Z/LahSmbvkD +/weVXfLEl9bcxIGb/PBA538dN1lbaz+CJa06jonE4bmAlSUFVNuO5ZMMgUuCEkJyBSmP/1L+tY5r +XXNAdxxwnf6+Ptr9YdIgyeA0JIrn4cWC6CbeJMWaXE65PvP9h0/Jk1BbR7X+bkLtpzgJ/mG7Zi2N +fm3+OyXQNIPKwML75AWgWKEyeMw61PXfnf/OET9bAv3r5MfaLfTPZL1OhgCN7QCShyXHYGkPisRO +IYZiuHUI0oLcax2o/7vxv7X+vNaff6D+TFNJHubW+2M8B2QuDGqI8wRDm1QXXuvP/yb9mVpLoN9M +Aq2PJX4EP1kLsl98LIFKxZAMw6CrY0hYZgbZI6TAL2+P/C5U+PtMyZNU++GZaGuptrar1uLonyOO +bG7bEOPEKWF9E++/3JL64emEa5nzYyyp9VW8a8H1c+wo8D7OMICasf3EURS3vsvjX24//fBU07Us +W9tPazH0zxFDVvZTnOIIoGD5pfsBWI6l2bUh9S83pH54pt9a+KyFz1r4/OOFDwyKABY8x/plJx6b +TK4zWv7lwueHp2n+60QH9MEJLE8I8JiXYwWehPGnHEHwyPfGCTyFil0T8Eod+IRUiocwPPHjigz/ +i0KKTYs/4ThiTiBwNBq+FoxiGGJ5n9Pvw4Q9cax1Dt7vyPM4liUZDl0sxsNa6WZXztCwoHoS80Vc +YV1ARQDXBZPWevffz/6dzh5IEmf2JRmGFOAvhmBZBieVkEmGW4cm/7sFG//DU/vWgm2xA3WGJpJQ +aCVZgePRD1JgGajVEwyNxRgvMDQJf5BQl6cUrX4t2NaC7acLNk68SZROckl0gxYjkBSBOokLDEmu +K9z+y+XaOunzd5Nr6/ONtTj6UW42fL7B0ECJRqfrLBUnKAJYVHGKTFJry+rffcjBr5M+1xJoLYHW +EugXSiCGgwc9pECQSVROgRPiZFKAB3RJYi2A/l4BRP79tQL5dYbmWgStRdBaBP1yEUSQHE/DpaP4 +OMMLJCqaSKxPl9Yi6IcnbK4FyLo+0d/BNmkKsU2WEgQUG8tw8J4VVLcOhuEx6zitxdjNOqfud2NY +KDaV4mmU/M0QDNQz4jAHHAVlSWFaKDEcWMFQ5PE4YuuHxaT+w3bdWmP+X4Rncesrtn6w/vz3i7Mf +Xt1zLc7W1538g7beWqb9jy6xh5FZAsMCSoaxxyzBSBHHJL2Ca+x/Fyr8fabkSab98Mzzf6VEWif/ +/SNZsU3yHy+QLPQs4dw/YFQQ6/ohCzKsX5qtbMpuriBMf340GXYm01WxGx1QmcXYrgXgP1edBqBd +SF7zqdUWXDnbFdmd6+898slf5Bb/fbnTgvhZcxQtR5lMGn/5K6NJ97+j4Qxsq6cQT/nHs6fwP0on +Wm/Of/vmxFKnPmkMp++jyWBVIkoF0J14kvEzk768aMzAGIZIUhGS8BqM/ujcvF7MpKf4m0nnvQ+0 +7Tvtw8awPRp0/9sxa3oPHzL+xBHQs0Lj7vBi1B3O4LOk+Gw4H+RH424HdcRT6v4rqv5FkTqaNWad +1ysgWRt4wCQhv5y2Gn045s6k1cF9yINBr6rdYccUXKHzMengV6QOWKnRAtg366ii7ojUvVI++/2M +cVdsuwwQOlSz7bKobKu4dq07GPdlru1Fncd6PO5DAQy/QzcmWWjtohEAZgJI0HroR0Og7fnL/dGf +fhYImrWYWYuZf5yYUWjYXs4UJqNx7bPRHv0Zb3TNBYwalGsDCHH2Zn+IcELEeVbij6NxowWfyQ+a +/fnE3LQ3uVhE/wP/567h1Q+gYPqj1Z+IDByN+WP21/hfzLYvusOeP9f5o9P/Fxvw7P/KgP9FmBS9 +o0Ct+1wVHjUgvXGBr+EM7SheZgHv05moFIqqXr87cLnn/g4Xo8J1OJYm8JEjleTVXAjm0oueXo5n +2OVY0s85y/klCYGW81jrLuujUqTXQzutMVEr9nGCgleN+UmahZuOhvnCPLv6O1ExQyzN//vfv/yn +jWlvVeyz1AGME+LbHeskZUvzylYC/bMVkl9I6Ws5+GO3MrTRGbSLKUtDfSFD6PfZGK40dWy1rZ0T +awH/U7TjX2ilLybHoXPDL+2TJb0gGlguzUhZircbk57aydCaTpAThIqTnNTmj85E8iRjxI8bXeSZ +iKlbfY4m/7VYB4plYPAjJXA4GBKvAPyrtzjipzr3iJ1LhwNGkN6rs2bZKpb9CJ425v3Zs70P3NuO +QqFIMPKIRaue5NAdhryQhFeWyjP1EgFr7iQPZI+Sr8VhOzuZodFO4RMWPnk9Gw0vJqB1d/gRi+HH +uQ7YPxeNfmc26yAOe9F0M87Q4xX4EClhAJPPYbRYd//16Z/7Llre8BS6/ezOOuJ3zuhqQAIEsk7f +UZLhWBpGFidpnqRpjQtA/O6qnPNfddrSl0k6mdRckpykGQqmK6iHqHx53+lDRyv+mGN5ntS6GeTc +HfVH6BxE/IbliSTDqzskaYalGO23pPxt/q+G9Kkg0MirwfMECW9nMqIVL4f4Za4/lxBKg/8jBYRH +gk5Spguh/vS08QGUwYb4NclTPEYqQyYFtC4si38QHCcg9PEsh/maEkjHcwwvgjyAAeDlAzrpzx0w +rHHRSBovtyDAKz7QK4bi0QXv0jWeMFQcXezJkACyCJaieQCWEgBYmtOD5TmA2SQCCzivdo0ZFsCD +uSnyaDVgwaPyQZIwBcuSLEnh20dJJqlZhiQHr9GGbfDcAViEBRksHC0J/gVwCT1cmmdYHoITyCSn +yQOLJ6VbTbkkvhUlTtEAZbQEl4XDhcPPHbBJCS5P0ZRmdALLswylhQudYojm4f8p16ZKcCmIXRqh +lxbhAqiEZnAQuxyn7QgjV+BFIaeFSqI1AxSvgspSvI5BCFwS41JBPJMkcDKpiFwK5xOIFMYQEAlJ +OFhOAgsIV7dTBBZsIs1oKQoSAYQrkRiFsYzhsmjNBGD7HPCMtBFpDqUvgHnRCH9CkqQ4vIWTNLo4 +DdKAJPB5mO4ggkODZOBKcdJKCTwtoEHSYBfAoYHueeTGpGiCFnAiIEPwOL8C5gEKnBoaATHJSruK +Zzga5V8oTlGe5RnNlElpueUp4/2AgQLmJ82YJGWwEJFohoCRoIxEhqZYTsVh4Sg5fIs8+GEYJQf3 +PsnyEjxC4BHVgHUjeFNmBrQqOGk0A4RBSGugA1YEy2Cqh+OkKGmbAtqjYGA+2KYMRr8Jk4wzDNw/ +EAE0WCVWPU6ShuMUBBFeEvzElw+RYG0Z83FKTJVMgtXhlbUXx8kBuAyaPiMNM8mRBIXkGawALtD4 +a5ojEErk9BhpA9EYsLiB0P6BzAkMSUInzdFIhiQBqybML/1nFKYM03QQqxL3DgE3Olg4OERW3pKA +kBBEliVYU4gKm5PYKIuXTNqSvMT0SUbakjToFxdLigPqZtGOJgAC8EKDfSduH1qMw8aQWAFAglNO +SnBIAjAIDjNdFNwNZBPN4wWHLAvuUsQj1WgU74IW+RAl4TFpYMZJMsngRQFo5bXMWA== + + + FkmYt4OepRMFWSLRaHUoUuKZHGB3FJoxRSC6A0oHwWqoSZbMHM6JAj9k2ZlEhC6gDSTNn6EB7xEQ +LXOA1cMfScAzsVBmkqg7iB5W5EIMrvQg4ROKY5iVCfe4tCdhCUW0Hizkb2gT8QxmJhRcNlJmFHAZ +RdFBqwUnvKMYCE644oIEFVAEQ8KRAOJGrIEAxMxhBsIhJYKWGaW4ThRm9RimAIeKdjknkSbFChSJ +pkxwgBfDgSYFhAOCBIQkqIUEB4cHe2Eo1TJBOQEQwHJoF0mcmGZJMYkNKFhingDPox1J483AidNn +MCOSK2mIUDm41Ukk2gRKAprkWLSbQTsWQeeTPBo0oAkaTUOSbLQk50WZpJZsSLDJ7BN8idcDbiaB +w/yJ4xkMREDMnZFqe1ASRZHatYKUipQGWclhADtEPJ1L0kDr82N9JynqJ5LYFTcp2FcKQpNw5hid +EjYZoL0TWBGDN7fDMQKegvYs0M3xOosjlG9rJzBjxjARNmnEj/FOMiRq1UbvMz8yBPw33Y8hNGbC +YgMr16XpNyJwALHUaHf8s5EfmyNOsLStFSimXlUbOPr2CiSzECobQLrmpkiDdoEfBej13QM2/QiC +D9W+541JZ+rPDj/6wKzSgMH/eVTBfPaPDZ8gcoGLj/kUNDMvsmf187OiH/BQ1p+HQP/j0z+UPsOd +KW8BGMMX6Jn0AcUhwgb/owJp1o3cC9iqHEdqxCoPKFcraAUkXpCWIh410/j2Bkne0EjvhVIWMBVJ +NhAcQSL2ADRJgTI3lpMig+RFPiGotDXACJDei9QgUgVX1m+B3oYEBQt4lnbEwPIlZJODwHwNDV3S +/xkkIZEAB+xVAs3wFEVjQDzDmCsbrCQoBMx2oZxWqwY0lGkUiUYNlpyUFwfbI5oFBQzBsDbomaSa +JnnUAyUAyWKl8snquKCophI0KikvNQm3XOMvFN9y8eHWF4F1Ryj0ZYWMY7AeypNAcUbij+OAEo8G +AHRpFkkV8XIP/Q8R/XBhKchSZe2WB2oJzmRjaJrA0pQhsKgGdg3SRij5v6IBA9VkFiKalRaQAwNA +68YC2w3xXbBcgDkjLk9ia46WxqT/gaHySHjwiJYlqEBfR6oyS5F4IzDA2kJjAuKWxDqK/F+15gn/ +hXJYEplgNGgdGaDSIEIDCgTYHUi1EeW9NCj9DxEshcQ7cgyAfyW65Vh8HwXBI+lOAwnJYTIBGGFE +hYlTq15YT2JpjepFM4DOBKSwgN2LjDKWZNWmEDBvpHtbdD9EuDxW6dDO4iWBSUFXFLLCeY5PYh8K +iTtQmIz8X5FICLxHocoB/pWUYxJoBeg7gU1iX4IAtC+tHiuNTP9D4isEMv4hUVOKt4IVcFuCoQis +cQH7TesQSIpcSvu/kgsEKd0MhfY9JW25207Tnx/1R1AEjuZjefPBWmYk9ndwjGBufVHSrQKy8anh +NBwtW5+UYtvwQBPT4pXDS6pYS5IyykuaLiWWSBMpDFsPSC/l9TyXpSisgQPTjuU1zkRL5xDL2jiH +kqISJhCAICgtPGCyAt4Gf6iteAyPgvOmDePzFCelDI5C+4CXNVvJTgUsQ8BZtGBHaJ2bPFY5RaJV +e61IIalQLolhXuRkp7Xkm1a81Wo3tu9sjB3e6I3k8q52pzO1F98uyl0+oNXEVBqDy20TnAxOdzQC +R7+7yUxIAr+q/TVojvoQzP/hC1VGA6BVhiqd/hj8T64x7XXQwIGu2PoMQ/XzDzAqqHmGrmo12GTe +B1jzx/xX3Y/PmfpBYfTnUP13tfOueX89Vv+VA9rxn41JW/2sNJqIj84nTfD3+aQx/IBd12ZAdVX9 +nZvPZqMhICbjM0r9rN5oahvBB5oWuCPsxwbTb3900AdwveQHmg/wIxo8El3uYHDdVq8Dx4d8/tJg +oYwPi3gHK6XGuvXqidRWGLXmA0BChcas4Qu8JqS//Sn0l+qcC/59d1o9G7U7pi/3/KH/DPpD8DrW +mM0m3eZ8hpNcQFNMdf8LECuAr2rV+uz22xOAe9RGiq2R3sJ/Zn+NO/htaGc4ff2jMZnuqZL71U3/ +aMC1x23h86lFO5gujpuJI5lq/vqHYmc4GnZcIKY/AhTedoMZqWX0751Xsztsg4GSLuYGiKPWmZ2h +STjPT916Rcu/JCZIW0y4mn+30ex33BC+46r+kzZ66g/XWx02/ZspGk6vNZ/ORoO/l5P9OjpMTRsw +DgLKPLDF3JLjL98XNXhzzY8Zyu+wS6fvf/5gafw3b4Npv9v6p/PimEAqoWGWy+tqaf9uvgunwjlN +5S83U/nr754KydEC7TSVP7ttFNbuOB2x4T9gSp8dZKm6mJPU8m+elBT9aTWh5ghYugNoXp9PusBa +dDM14zc/QOQjXlcbzSetTg4GQa+E7f2jDTLC5K0aY7PG5KMzA3oAdBlMjwpult74zd+syl6clSmm +NJoMGla7Uj3l926/Y9tYM1l163+8eU44cYJ3FAjtzjJX2v69y+84qe4QjLPfaLmblrr1D+fb6LKd +cQOAa7nSGLTt/+ZNu1VC/+diww7gVULoqMXNJNWtfzhhDkennqambf8D5K0z4/2fmbRaofR3j2Y0 +nnUH3f+izIKfMiZgJf/dQxh0Zo12Y9ZYdhzJJcex1RbPP9zsOlVj9DE+KSQIv/RDBaR2U3696Xb+ +zI3+c3cvtn887bS784H/qjMd9ediDor8RfaIJP3ycQyglfnYX+rDbQ7P9C4mHZgarLiHOZalWXH2 +2aOkvzGZNUeNSdvfQkfRpL8pz1JmP6gLaRL+LhhFY9YBDTvIpW3buDcctXqj+cz/gc+4EREoOWhw +BKed6af/qjEFUlMkeNVM8RcsxVCC9aAp/wc6+XLXVtY4aEIzjvP5bAwGaj8SSgVZLQ3BCLpt/1S8 +bs7FKBQ0O66IanKObeXJkZr1QGQw+aPjr3f+M/MX291Zo9ntd2eiFCcZGaaRmKqN4ce88dHxX4zG +0hLqxSAv4aU97sZxEwkkGNlERyIDdImB5lGj353qHk3HI3HH0LK/Y9xot+V9lT3yZ+ezkbxiRrJN ++seNMdgF0+5g3m8oqyive67f6bShDXqjbG7SEr9aiyg/GY2zk04DpzgbZGZIiQUk9RveT1PGX0Q8 +jD7TsQRxsnJvsAONr0EcrLRq+cbwj8a0JqNDTQiE/13mDGBT9rvDjn+KEoun9o3HEv2M/uhMxvCA +eKpdZYgskevAQV/OG5C6/FV8aZOeQZiNYwYoE7fkFQrXtJygdY790YG3GPqbjX5j2HKYZKvfHYO1 +g178/4C98QEoQBx4iGTiYDlUjLSXPSrN+30JjzedyRQK39nE0EWtdOvPQ8j1kT8rUoj5vtD/TWiB +VOqnVf/1tOM/GsANlp2iIATIKodtPTHK7ZUmYvhQDV4XKZEEz8OqWc5f6SWdeVM8LnyxhLzrzBoq +OooZGhjjeKQP/LUxMJUmU4DuWbfV6OvJyvIDJTbFQF/GbwCO87Wadv+awkZJpGpznbQDezRs9edt +oE8PIMXoGZjZF+URLA8Ac+wBO2r2Oy6GhKdbHIxnf+U7/f7UkjDkT+qFW+gLraich3Y9oEU+bYzr +sgJEuWhdHbVUHFW/4vrdMhr/ZaBtHaJEZPrvTi/MYerao2RljEn/KU72NvSrbnM97P7HtGN1o9vu +sD36c6qjdlWLrlpu6keY1OCt1vgDbi2YsK9AGA0hpfg1/NnVN364PH5CXCDC01ek2bI6fUSJ43M7 +KfwVLSoqnj5ixPExnr5iF/qKW+grXvzKGwoFHR3ZUIQ5QenQCL3TTvREuPsED9B8ie2/eSIIiZ4E +j99R5rh3/I5e8DsLunL8jtWvmyXiTbmOItFr8+b7qN/uTCRPInw6DevFrq6xylzTcofCfAxGAo0v +ZSy5ziegKpU/BzdFDUR60wrnPVO+rnuntgFU73Wcs/if8Wgyg2qQWrqqVOscOuRRKdcGBUnjZKp1 ++pXGDPQNhUsfTm+q0nct2h5Bf+tRQd1S/boO4xRgr2bjQyGjquFp39ZHY9U7+fy43B8B5fOqM573 +p7IA3INv5cs9dBPV3/2hKDjA3kc6h1H2gjfFYWtkYmGDN9CMOx8qepn6HbpmBuEOag6iBaUABaZg +q6uMm1TelIA2VTc6jyFIYGaddCZDs4EA3VpWP9VjHzQBepHGbtoRIPYpJi3DFkr6hyPF0PB3h0iD +H027UjfOHhHKD4xDGy+I2l5AbZE6nxcNhSu1oaC2RlBTPKnEDTZDchozRO3ZwK2l2Gt/A2jJ2NWh +cylo3BD4I5gaBy0L9BEy2fUfuXEKFS9qbnGAG1sjwdj2XDTbamrzUY0r3MwGWdp54+bOE9eiGH/l +jGOH3SiHz/tvO83ETbfdGSVOR0DT60CkAsUR7MOOhNuE4ihPtEZ9WE4AQDaybHW76awfb+MuEFHL +AsEePPxMbK94FN18M24PwOv+0PWgxm3XwHHMn/wFKV+vpG44Hk/iSNjF+zDo3lXL2Uj0LrE8b99y +ohg2AkHat8VxBjr2rllD2PbPkVgRzr7Zp66ZAadfoybA6bT7MWwYnYb6hmhpm2KcgR1E1HAET5Jd +tGtMm93ZoDG2b4rbTHT7xKx1qz+Jt0ZDeBUYdMnZDBW2lPl2E11VhOfPm7aetOPAhod37jgMADR8 +B6xJumYMiWLTVkhIGL18hl7/gAe04/iny3Z/WI9t/DHoxTtDqGO420HoA7yFlPV08w1YtBm84E0c +S5xiTekeNgWbGvJmVUCU5dDHYIt0h+8jh2YT1UVXDk2Rp7TZmExtkIsaNqGKBfaTikO4aCwzCRdt +Jxr/h1NrNaPgLJsPGpPeVDtqF43lUbtoqxq1i9bqUZsxee0c59MOUImRcmuzj9+Hs3i7P568j4Z2 +2308jUPFDPCQqT1ZTOOAZ0Kn7BA0VQl/Q8v/jOMTPUtCAt+s5Ycb5gXaibxL8S+boUlph/3h1hAn +7clUu+NNBRBqJjmip1PrnluDuORdbw3+6tmwQaXhCN/brPXgGnrHXMa2Z6gliCzoOl6L+3FOKtDn +2/6nUO32/OIp7P+DctCB4LhUwslM2oE2UIvpDm1EJ5SvTkOGbUSVRZQESXM2CEW6wv4EhrJqpY6w +DAEtEPDNtr/5l78w6f6B7sa248vge0XFslEuNIzYSrUw8dYaGqEjR1cyA8p4zdhMpbWy/tZCcPLh +LChBG1FIqgpS6VuhKlQSLMd2NkIXNxr3pSAkU+JGbVrDqR1KQZtZt6+2sM3551S6ZtOmDeKxTrJx +IskBsyFjtqtZEtM2U2A6Syej5uy2rzl2M2vR7EJbyLbJsPPRUE42LQUAUEyH9m36ZAu5zg1mn15I +fDbanYnqKNK0lVaO8GaqIGDm+tNBU4bf79ooyaDBaNyyUYxQg6nN1FGD9tzWYLfZweBz+w2MRcx8 +2HLFEFDrxnA4UuJQxdAA6GTJSg39iqvMc1QAqW6PnAS602KD28XUi0BYtarLItzBng== + + + NxeKyEICQ8aJ05aUoRhS/b59q2mvOwZmztBGaMNmE7AbJ9MOHN7EXbdS2IF7Vi99oZqb1XCgz0L2 +2Gmp4HjUPALGgJoGdM4v/YoSlo4hZbHEi68vCiXRCQVtGRjgNhpO9W47MAL/OX6lclWp3c6NPzqn +QPx3x/1OVosmRyePqpaCX3Xr8Qr8O3D2YH6vMMU+r+jEYhiE7XduYjLMvqNgfxdY8UJHp7DDi1G/ +K0lFU+NBGiguGVGajAYAiX+OJr26JJkYm+mdjoaj1if4qKOa5El36M70lQaNA62g2344EyfgDrtS +FFMWyNFmY1Zt/NWRzEx4xZT9ssDLIHA+JzptyTZHf7joEsVKWK2ofafoU+tevS3PlaIcmhtE5lM1 +uI29rBAsIIDcKUdtsFLd967EvjgPCFOowwX9W4frMLaThnRpjWnvoleCq0Q0YcblSKaUCgXQmtTv +SZX3WvulqzBIbyRTVRyvNoO12IzqQZvqWO5js8xNfSNLsaZab/POOXhE7HpWqNVCTXUdKGq/S3W8 +wfCxCyaoEmYwnhPQaL4xxlGdXQfRwUA4kh/IWllQekQnEKcNICWU9At3nKTQmYKhNdxLUIl1ZCf2 +xGvC7BYURDKbc4EJwFiOFG+phQ9Wal2fdAcQabcqy95R1phNx25IV50P2MfUmTPrdBNHxow+wgGy +XZWKaz1f5UTdedglsHluO00Y6u7Mo1REpOZLzoOp25nbMl4gAwMKcf1zPmgOG10pwi5U/wQ7zd+Y +dPyzz45fdDv5p1Ig3J+fnaF/iiMsGkN1oS4/5KL+xhQ+VnRfKSY+juJDZgi4Fthfo7l/DDinH/CT +Dt7TqGsM7gNW4elqOor6QWfyp0MwY3gx6xgmn/m76OS84e83/oLx940xDh2BvGo6b33C4R0NC+io +SgGDexsCpM7B6EbvSvfdqX8+7MHKIXHXO7816Y4dNxZqDDCCuExd5Y2xWzPZDHFBaVhG1Q2pa478 +OScfYlCs08YCA+8YY7DMpgoGMh6r2K4DCaukuK0cxfEUMLLiCi6ytXtIzWh14Yx28CVm5sIoqc0a +w7YcEu2SF4ulVP46s3V5OMaOOyNUrR7YrysiAu3CAnMZvMHKYF62DV2Zn2bTAXy1P50Bi3wuJwf9 +f//3/zP7f/8ve5yJn4H99T751trxR8OeH17ppjLheT6pxATqTGxlZolcVxp5tpY/OhLYQgf2D18y +h+c7j5H924PgXuMuekzvnMdymUl58Jn6GG4clzaioWC+24hPt7nrSpHbSmWuy+lT5jBVfQqeZibz +Fl8qUqdCgGSYLYKYFr4KH1FiO7P3Et/N7EfH08z0hEr4Apm96sZEanQ8y31ULquZfaZTy3cP0q1C +PB78MHRVbd+D/vhCKZDiH8qzwtdzjnmIRbODUXWaParNPiNpbmteKjDbt7mvfvDWFyi8E8dNU2Db +fPKdv7l8fMrW8/Eb607V7VLPmf1e6TmTmsYHkUI0MC+Fyu13XwAhq/QGNIzC+/Mtn+tn+nep99zn +LP/JP5AadLztFFpk9Tuzfxi8xXDAkKf5l4+XEfi18104ah9t5GLC13a2Ftsa4jHcNdpzXyD5FYq0 +ii32MpT/ZF739rMBeieSO4u+RTL54HUp35nvpm+Otz73Wq1GD/7qRorv1U/cM0kkGvyku/2W6r4c +t3P9wGEwNok8zbPV2s43HH84s3f8SfsC3N7NcyY7bAUHkYPTvQQ/eDro8nxi+k5nJ60jMtJLkTLE +VuF4egPQxgc7/C1NtFPdfKIB1pc8PQjFop1cn78Y4BncVwOZ/NH+1m0xmmSnYF2OHrmtNJ8fvUT2 +b9qPKaq59YzApocBMKE0t7sFl+SRu+UuhxBP6VwvzMVE0rxpVwnyeeu0kGjs75Q2Ig8T2AsHX7wg +KKiJL0A0N48Y9DuSLu2Lv/Zviye4eT5afMPAqHvqCJDuHRFJp4tRqnD4cSDCuT3Y32t/nb2glZQH +DOCd51ixF9AodywP4FkZABk6uIKNOgx6xm7kCq8I1UBYHjLcA/fVytYLX5HCe+Lku9hoBLdzXPP6 +cr9SeE1n65+tWfZiu3WarVM0WP0s/3y/Bb5pPxTv3g7nMoow1WrI9KWnABP68UlFWrD7UeG9Vmwj +fAKwjXAkvbV3i1cIQvYFiq9k5CbH3B2XMpPJ5zWTOr09RCsksN0JBxZvNxrJjZIvelRqJ67Gu4Qn +vLAQlC+wFzmYh0qFPpkjjtkU+KdMdDGcNNccZfbqs81s/Xg2N6JSt5IqvEsLfzfZgM/qgI99x7tZ +PZ7mV8lOKbQzDuc/uauHYpPY3y10JpMo0bk42JMHgtEhI6Nazr4ek4ja9mNvJbhTT+KFoy++gfc+ +XlCh9j04yZ6/5E5L+fdjgSBPmu1Svj24R8zTZA3KuT53cKvA5mbVg4dcpb51oBuDLwBG0TkvlHuB +Dujqch9yGJp4T92OjKPVt2uBX9FZebzZTCYje8yZDiN7R9PRe7477XKQW8YeL6jw1lFFmdVeJ7Uz +ADv5KgzJ6zRycPxwLHX68QT4GA3eBqq75dlre5CtvR0XEt2DUAkDeA9WuGz9dPSRuakfNUpF4fLO +F9iPEMUnGR3jYnR0RpV2uNQdWPN5stjqfe9IHaAN0m9gxrzzGKwC9ngQzF71x7vqdpeNCmB/QYa/ ++tyNZ0/ua0NfQMXCpfevmTq/c56vftdJjcjY3Sm8Z4MvGhlwVSq9hjc+0TQAzx12wJZim7q34urD +9z2NpFF9vQuEaHlUjNZbBwCLl7dgY99tR9IHHI3eZmvRzDDf7V624dQ2YJN64eSkEivtF9kwegvn +8rE7xM3rp5lArn9MxOFaPSr7kxcOu7tM5qaZ4C8qp1dk8+U6S+9sbBep8PZLniznqxn4Kw1InDwg +Os3UIRkN5Q/lZ2lfQPsNbomewT9zkCnm0YfoT65WpS7h2wP0tdxBHj7LYVDZ/ViJZ2OFK+r1YVyE +TfYBT4bN4YOC3FUONjpT4OBeYH9aEBl58Gn5iz3UBI7mAg0JjQHMBcDJ4qHAaeIJw0FB7NThsz0E +TOkFgdCjCA7ZrFP0p4gxCLGmRSb6Zg++RdM4VFCJG8PBYSwOP/YuZRTUED7lXvZVc1EWL227tK4X +QrcMvoBuIfA3EFkKbDQNhCctOg7QrJQ/ESi557IyBl9Au5ZpM5KzXRI8ZPRLnhXuVPkT05gpYbgg +C9i4Ks9KIRU9zeK5WCLrAM8U7RwJHQfKnGHjczOk6naqLyCj8EA3TRknKS2IQ+1o8sq36K2uU3Fd +lH2nohjNqqYVqkWNISayJltlTx7hhcw8MJHiuZQQHhFYt6hWjcGWXhDKwepDPMqw02YMEE1N3pre +yBAtCMbYvtwBGuMVJ5Dhc/QLo1+eKc/dxN8BA/+iRbmXzA6zV+8fJ0CtPBnrBEa2fnMyLGVIsucL +lAPlV4ATNsSpdJP5ZWC/9Dqr72b2iIuNSPHmriKJsti2Sp1QaQV6K0ndDlAyNAyw+gJEcERlmpFJ +YLCc5LggUP3Cj5bWFL/3UC1l6d72MbIDtBOKIAPBFxBGxwRfjEXfmcLJ4Tej7iX32sleDWvX2drs +aFCMVBMh7dt+KZMMjCWj4iqsGF+4g6PH+nf2PJ+7gDqMqF0NNIgBFijUwrQzVSkb/F7r+irLPx1f +FY4nu29mALJs5fkoe3J7CfRkcWTXgV55et6ZiKpflcsBsf0Ul22HuL3tYG85QO1Csh0gMJ6/fu6c +FN4vp7VE9+IRqM3F7zzWt2lq89HeGLI0hXwBtTGkUCicGraw77LnpcLX7Wu++8Ul9t4HgQ+g3+6S +ACfpN56/ao/g4GKKfiSqsbX+swIKULII7HeyLLhd2R+QLnzEwoe4g0s6/QYUtfNg/jNyn0900wcp +ca20eNLYIj1A9vGSYggDPqZeg4sKQj/olN6CzoMqpnmROFUDsTIqdtKYzpUNcFHpA8tC0f+12r9q +oMle5yQPJtSOlN5e08lC+Z5/B+Z4kSKoMnOqB3u5EX7SGSmYxopSt2+XhffrSBnw6VKBCreLeAci +SxXKgCRmXC/7Oz2rfcWXXp53t0rF4fyNCiQHgrj6+9HtxKPAt6rHucuLDJjL/eBMNPDn94Hs5Vnt +plQIt6UXCrGPdgi+N29eENWT5lixkfU+B+qhB9Yl//m0kYqky6+vEmU9x8EKxk9yvdMIUO0v3pU9 +m4KelpdcjzrYUF7IjgAi1R70CShEziC2HxRvB7D4TPpedc9YUzpTb91x/DJyeNP4ljqo85m9k/tN +YD5+bmhhn2dr5fYXWJeDCZW53kiiNUArcBCaUx1Icu/oBeBjh5/TOVrk5CVgqqCXlwYAUZ8WX8dk +M7N3HYyrnGQU29/ce59ffGXr14170EGqT5SeMjQYTSUmc2e9A8MXSPZLo3criiHllnVp96qBudy9 +tNqjaL9/CYrL7hSaTKfmuHtVA4G79wNQcil80d8rFdgHKpK+f941QnRh5avAVlW7N1d9/UT4BOuS +5o7nhfhVO5ZJnX31ZBFV5zZLw7zoGgTEFxt/j7qFxN1eRsJnsJP47Ly8QXxOxcGVCwciB709YKGY +p3KD8zSQYhrF44zJnc/pB4Dqq2kxssu9qySWQneQlLjtrW8hk7r97u69V5ofmdRdSQ0Kc2xsuyeb +vgCS2PvRe66CYKtkt9iSCAE7fdYC6/ewV+iMz6tIneC2qswWfEYVTuqnm0r3/E2/WgeC7nC7+EoM +nwvv9cK7L1CMjk7nWTaTfSy2LvphnbokeiY/Aj3AUJOb/DRxdpOtVzNwGyZjxsHvhzKTWHKevbhK +PKe6L8I7WPHbXbAuKvUGi6ODBKCY6i5QUJ6uS697nwl9p1T6ewAW+WMj833Y6igv4FrNs0Jz/BEn +KzdR8RlYYqCP1be/Y6XQKBnWvSKb1SNKASHLVzjks1iuPyDeAb30Hrh06vw+szdOksapie3guoCW +vHA52rVshJqk2u3mt7HJQ6xAJB+CpXyH62XrhQaZ6wtbAkFFv7uZ1PllHy2YisMYqAidTxy07h7B +pimcZq/qmW8jbWxN892D02kmVQo0uEPurpw/y98cytohJ8oXfr/beiwcta4ucswtNTMs/MvWBhAe +xGUpdHxYTVaeSjNRCRYXMQ4I7YTbO9nOvhc+tp4ZPjWO54E61N1VQCGtDwJ774wg0T3uh7cDr5C6 +94vNxMNYq3njkQn1ne1a6XVrpwbmF3kqvnzNWsgHacRneVZs5nZDvkDqNEI/Zuv1nQ0NsRweyWCr +opdKJIsqZsLSn08WBFLZKuWzz0BFzBzdAT5WiNZZ2WeIR5vsZYv1LJ+8+kgyb7kBmGSOsGwCBUED +mkrh2DBal9UzYIXVbw57mf30+BbIyv6Q2DEB0cn1grPjHHO/eV05eGKCrmYqqnkaKKH4E+yld3QG +zI/iSL3vuMwISsNj6OsE02XpLWAiPCQVEClS2Dgrhe8vZtmTe7Kt6vTg5KxdaA+SUQ== + + + 9ZkFGFkIcPnz3ofCfzETHr19sqqdKp9eYIYbORt9Fd6Tx/1Cc7cbSFbfJvulbH+4idyhOnoBqw+P +8lJn+cRT4eRkP4FVNeqyFisVyfdQKZW92pQW9DYEOH89wR2UsukcFxizhaNGP2DgP/2LMMDN8xXk +pfHCydFmHnBL7Qbaj84v7ksZYvYK1nzYLG3sRklgwl7Db5IU2Dn0G9iGh4IKLL0bCmPjkq/zL9LZ +VSagPX0TkbBXCh0NssnPp7OtUuHitFYKjBnAXG47Hxk698Aoe1FUg8AvRcFCZ3hZvraVz4L/VjL7 +sXjYtBfYaKcMncVPoFGRNu6xrV6WCeWui6Fp8xkyElKPLGIafUArADZu7N6yl1o1R4Xf66YgyOBx +G5rMJ9nR5/mu2nKy26mI7CWLz5bwZef7IzoFgGtFFRq18lM5UH4WAL305qrGs2rpGax+ZhupIuiM +EurJXOa0ED//3FdRbZqLjkq74SgH1CAmAEyJTB8dNu51kq0b8QiOO75Wz1TtgjikSnvRTcWAN9CY +WmyP2++l0Ek5qV5kRKuXT1vwRT9ba47fsbVIcZsfucGm8KXSlDKV8be0KxX5gnq5pfcb/N7l+UW2 +Nr+mjAKFnRSOBt0pEFu5ARhhnyu9nQaS1hrAeWr/CmDstF3dMl9uSacQkqNEq9gcVWIO7eo7t8/F +xtvRZm4Q2VEJaInGVNrH4dkdWOmu6txeB0y17wwzhQLl/RUsYmX3G6jcR2eSREbs82sSvCvtzMed +HDPPAUsHWNoqmxw1GYQEwEHjxX7u6+siUzhqX84Kx6FQCR6DHuFzo2y/MUCqUXG2c7Qh9Xw8B9q4 +UXmtmmmwoho72WpDuotmL3dfgYRsDUg1Oz6ez4ijx/K+bj+IcwEKSqueOntpzktvL9QA0hgtH6Y/ +qEnpoJNTsX+4zzEeAkTvEQiHu1DhfWe8xc1OZgel1348oeml+xL9AKsx3eVTL5EaPA+K6NeFDg9p +oBAwjSwTDI6S5O1JIiuUpzMYNgAUuqPGXWYavtssnBw/fxc6+y+byoIhnf+NASL6fQzYx1OCSzXP +d9x+Db9NAuOqUim9zp5jpUywU9cexnFoo2AOIxkGF0A0Z2KfAugvWi4/CPWnYrOevS18sDtdHfeS +GZfEs2QpjfmUuCRFtBa+ADqCzH8+7n+XsheZcep0Oh9pXYMc900mrwqtfKNX2O0mWvw+XewUH96P +irJ7EjWpgR1fK0HZ1MgKsfgm9IWUEdtCGLt44OtvlUSpMM+iY8lLoHEEY4XSMHsK5Gc9nOvt7cdE +BUUH8QMwuNq83lYCNzA3FIFebubYcCkB+Fg7VfhQcUvxfX1LxLKIu+vs1aj6xqW/wz21yQxxnAvu +V4vR5xyw9zlqoDhnEbKA7H3qAoylv3ePC827zhXYbelK+f51/IZ4pLx9LDAvL47oJzwADDxW2uIm +l5VDoPocAhZ98p1DQ5K8o9RlaAbpaZ+7vmgnwE69jpYCZAjYzZdX0cLxxjuhngFuPCa5m+/3LBIJ +pUCVT+lgy40BjZV2Hj6GhffRcwS5jkz91yKrzwnQO1wvz+Pjl+zJQ1hQVh+GAASLrfnmi3BeoetJ +Onq8V3qN3qR0c5Hh1IsjndjWwnnLf3yWgvDUW9AMWQYw5srZ0fc0AaM7zgvP3fst9Wm1wgBSx42b +U2X+GjP6Eui/p6VgOVCqDGSzCBhIt9vxwnFki1X33J9tF1vNaBtGEdxSh+LTweYOXPhXqK/tazzd +z3xm7yU2z9bz/CuwOtvAwk7EGtlRtlNSBoeh0KHsXmbv+TrHD4/qZOH545kC9n6tn0lIwAC/uGiD +/dfdBxPWqKLF0k65OlbCkeIbO8kbjjvufnD12P0DVdyI5RKfw3ZjO/lxOwFjrcBrunJkvrvxGAT7 +JbLb+i4Q27EhEu/sRn6XBDbBYBOo+9fNMvScBkj6/0zL0XLaULgCulZcm/OW1Gc9jhvDji4pULzP +SnsdpvqKrDv9VSzgWaFe0GVEwpu5Pt6lYD5D9OCeXHVXW4kVBv3hCq0w305650MxjOonpnF9kTT7 +xgPzuJkgEpHTCODUMxr+opj9yxQtv7iUf6EXe/RhfZYDlkW5V9m6OmgAerlPy2+pyMEV97kRpisH +G7FEEOgwgPv09jfCZw/JjehnF7x6e49vROap2kb09K6wESNOKSJxcB9C3YNVC18yU2p6CgZX6IGV +fEvTOYEWAJMdPKBYG3SgpLwlKq8dYFlMJumDZjY6PjvOnCSnaaGyfxsvjR6Ym+Lk6YEoPJTu66WD +7EGL3M3yQ7EXevsyko/tXoH+qpzVdPGE4nQ1uQ21Pn2j6nQy2ZvWQSfRIyLB1PA0lJFNhdLshnoZ +9XaI9g6Jej5XwE6eiek+gC3MI+nyxg6aOFqXQi+emAplRvje+wJ/lvvg6/uCttOnyfPp06V5p2X+ +hU0dvcRNO33ZPgNyX9et0inXPSkHzDvd3whNpmRgYt7pBfnEbFKpXaVTX0DpdhqMnsYsOmU/Q43g +fdG8Uyb8FNmnPsxnull6YXyBretxv2o2V6KUO8lYdMptbQ8n4QOLTu9fiNL7WU3pFMXByt2WN/Z3 +yOPXummn5QpVt0Qv9ZCuv6FOAS02i9o1vQWU/DRPV2G3YeOqhu7pxz4ZBp0yIwMpVYmc2OlFMKjr +lGUHr2OlU4WScbevk+fPYd2i00yD40vbpGmnL4dvV1adVoDWR4f2nsznur/xPN367FyZd3qZD6e/ +twdVs04je/1UWukUrIuWlHYPHzLn5p0y9/dEKUmcmXa6Wfrgt68G1LlZp74AUXp+LlnMldsK9Ian +eatOG0Q5+nZj3mmZyAY7If4edeoL6BE824oeip3ex0I6BB+eMQcieotPvZKm04d9osrHSNjprq5T +X2C6WemMuKtGjALd8mM9/VYfHxoWnXJbfK9derHqtECc7j4nUafIRtbO9eg7lfmanF2ZdlrbC9KW +nZ50ajRh1ink/MxjjKi9hjfN5jrdPKl0zh4fwiHTTm+Cww/LTmufl29N1KkvYJzrY5m4ORnvm3da +pQPXpcz+gXmn4+NNs04BT4bd3ryWN2cWCH48J24PTwrmnZ6mi68vl8/Ppp0+n/eOUKdQvhjn+nXP +tksWnT4JxPO0HzPv9OxrPDhPCrSuU9AL6vb1KDa0RPAkUItsWHR6f00Uu4Nj006Fs9jmRuY5BvgY +6Db1rd8081f+Vey0SYd1myb8UG3sok6pYDpU0c60SrztprKw06jSKegFdgvAfn1LTP9gou90Oto5 +EDudHUZ0M914ajyGcae5e/JIywijk+l1egP0ArqNG7nSUQzNFXSanxlYYWWTw50ekicxHSOMjpkz +LGno7VT+BHUKexG73Z5MGs0h7JTQdTqZZDsjiX6PN3SdTtmvlChpDlOXcR16N0edt7pP1B86jVdO +O6jK9c7LKGX59v6SHNxYvf0kKm+BufLWwPkB6y3sWHwN1mAnkpfG9dXhdW85gXyti2+nPcGwK7nh +5+ad2XvMFC+OUk+WbwVq9+rN+u1n4yUoY8z4PkvtPLQs31Yjw0PK+m3z/H1PeavDGLd1vtlqViy+ +Fio7lf3rKX77HvxO6r69jnQl5fSd3EwZMHbdPK4Nzd5jLleI9CaWb28DzcSG9dunQupAwpjJ+7fA +C79t+fZrdjGuWL7t3VC5S+WtAWODXin9YvU1GNLlHmv59phi0nfWGAu0hs1a1errnY2do6ddy7fF +7GmzY/n2mDrcJK0xlt2gtsMpi7dshSge7EpzToX2dG8j9cvpofg2H9/X78pK/a28m1XeM1MmeqW1 +wPJEO/iYF/nPW6AP345Fc7T0ymLWkxtNz/AvDR+jZtvQwsxvxI6T98DC/KrDf+LwWWkjWrjKw39u +kf0mW2+YR4j9Na5yEuebbFLBg4uYyM+BnaPRx9JbdBB8eDxAewNaOqodkTgVhkFgx97NAWvd3AH9 +ve/L/W0lugfNMOBOm8XJ/C0e07DbyaYvoHSLLB2LTrktaOc8mnfK3D9YdgqEyBep08fUc0WWjmWn +UOS1rDptqztlasBGVnUrnOVqqk7bOztbSqdI+5c7pXXohdq/PNNyX9Np+B5Zr+puNQg+oCw7Rdq/ +RafAHgTa/4vSKZiLZq7Plp0CBE8Z606h9m/ZqS8A9f9P87nub8TtOq0GLTtFOoXSKdz7mm6hTlHX +rGonKXWPfokLEc4/tAdu2r3MB0P13rdoyW19vxTvzh3bsZ8i3YncIgfm/JQVuaVh676FBhA7VyoH +Tbo0n4jMZaeW0e34RHcrFVX+SY9D7bporEOehO399Di8P5YhhhCIdLKy/YVGkU6WHwuAcTWKsGda +YU1i9+liQPwnejoSO0AqsNSBrFuC8YDJHYxxI533CbC9XOKzUwjI/1ypNWbRZ3YuNy7AXsrq6b4d +H4o+JTDk6wvwYAcqtPNdCTtYbxfZsWoGFztaBMoeNzBg4pgNBNA/kCBvtVaS2aB6ySPdoNRDep0H +AemeRqngIaHyo+ncgQjlgFs+z3MnTkiH/4iDx8a8yfyCG5bz8wWUGaJ/LFdQWr/apvP6bcnz2xVp +zGyGUHm9tkGW+/UbIfrEloVLZNkAI3dzXyVLUD435C4hay/mibIUutJIZExZ5adv75g3xTtQbh5E +Sl4a81TuIXlsj3efNbK0rCdsZD0vRS3roS1Zj8+JdItPRxM1AuUhaxC4g1mPOe5eYL6YhGCL8USL +UfyPiDtyaI67+9iGJdu22pXIH2c6tftN71NTSzE0Ofrwpn7qhOryyY54mmA6kEJENyu1FFPNqnMR +3xFX38BGi6CXm5GnCZlxGEA7wJy7U+FW3oZqOn8L74DB3RUslik6JhvbwQoaA/bzL4gYwlpKf44i +BxLlqCgZOXXMgZFugZmBQnhXnfLsGvddo+R239nvOiArG5t3c9u13CKj12QU/vMYUR1SGMgCcMZQ +8cRsOQHG1AsK/wELqjiijbQB5idzQSNtnF/KQ1KNC81lVjYdWbrcnFpNMkN0ZtcJgxZmXBLF4juN +GJekXXbSwtyynp4w9QUsBZMLnVFpDLSZx5mlWPIFvKxvGeKk4l17Mtv77bKWT5sg63SkCF6bIc0O +jy1l5fmVOB43Kh0YkrVCJy2dL+BuBYGVb6tYOOn8mhUcBmwVCw/rV74YKKAwJS8BrDZ0MS6wK10B +0woUr+OSTnhFYPf2RoyXSaq1uqUx9jpZIca0HM3juMZaP8wbPzEYrrP0dEHtWHP+AsZTMTMGrRRa +UwFN5e4+Nxz4mErBNt+Vs8PNle3K3N33tjdDGZ/HGlayAo9MqgpuoCXuHTv3mztujQ9Zt9RjJz2V +xbKjG8FcMazomILpfnFepvTU3sTTDUSkZONQHLiAq4HodMvFcOKw7VUDwTZyxEJEfVSg6/rRg02O +DyW1QUZybA/1PG3GVQ5t8OsI0nzRQwcWTg2gCW7Y6DCm7MNigxzZqx2+gJdBbS3IAA== + + + tNwSbrnnWcBeLLtlAEcKA3Br71vPL+gC5T53SNfoCs7+DL0mr/j6vo7god7tKoiqMCOLz9Oywhk0 +sXCmho+FTQ5o/5N2S5/iiZUdstxvcUuzB1lJAFket7gGWfIWR1/Q28leQrvBj+FctFvc1Op29i4B +qt105yGx8yUc612y+tHYuWR1HpLBsVaDtzCKnV2yYGqqjSSuvmc3yTGMSzh1696QrST9UI7nWrG8 +gHsD0ME3hSaEIlUMq+V+rXQy1cLv4wvYeekGx/Bw934pvw9Ei7OvT8cKLPw1EDucK0pW8U2Np2Gs +UaUzc70qDejA2pko8mQXyjTE8olelfaCO6yPofEE7Mfj1r9AH17zQR1FqGwxT4LwRKcJL7ZfUpdh ++6k50/mJIvxk+bKAN3p8opd7VhPyBWwoHdCOVugtwgAOrwOsz2HN3SHm1cFJ79OJOitdFmBHJ+ic +5JBal8VzUYk6eFgVVMdvwFmBZ26IwXLXqSg5D8YT9+bzNs75rmYm7bSnoq6PIAEwK3+rmbcVWxZW +/lYIzMPmM7eXwKbxBZY+pECrZi/yfK7haA1Jb6MRz8QxnGV3IIYiW5MKFIkne4HjXe7J9r4JMM0J +oTchqj0fDCLtIhrSapx5FKa6khOGPAo+9QWct6ELcQOBUXHPZ3wWSgSM5dx1hUqV+pn61kgxPUeb +9sIGjjbt6Q/wXHA0Uw9JHiAm870sR7tWOJpkvXrR4PXAnDmaz+UJEgS2OEeTd2X5ZrQCjgZWzYyj +ed77AI53jmbwXWA4y3M0CGX5s1cEx+Y0KJoLyac4CV/ATBvQCKGbkZ0FrT46NNdRmOiVNt4S2DwG +3zh8tuwBrCRf3oPf1mzIpWaWB/v8fGa2mbEH3hubBcBuNjwxWV/Aks0uGP2g3cw3yJbWWOKLKChg +1XRBTVYcxhmOO9XeEgrywwA4y4dAICgWBrXu5N0ZjvbQ3aV72eQ0AQFbha8ay0IwvwjULrTSEDyN +LaPfq4i0sXk1Xdriu7t1681S+S4speGtJ/3e3gcLgS2v3z99m8lCr1IMrpp3l5ZRikE4y+j3Kiiy +LFxciiE4Jvq9GRTZerWA41Ya2stCxGGevpeWhhpZ+Ko/J0a9gKcrCUeC/Mc0DkuUlZrgKSUMw1IX +eJ3YLIkalVEXp293d8v4qnV+fgBs2d2tGpfJ3raPtbbBmCt1V1pJ2IuVRQTWMu5qn9ucnuYBPm8S +Np4rF+F0uiFZUgSK7XHcXnrBlI/HDGIpH0+4sitdCCYqd9e2DM+zjlyzsPfByCh3qHSxuZrT1UXb +AmCWZzeyt8dtQD0ARm/vnVRX4SEBGOO9qRgWMYhwJV/jrnywGJjFZr+3Db7FFOGT/PeuBuWSIgyb +S5TIeOsq8izNng5NLQtxDVC23PRjIza8fN2I3rwUN2JZ+gXmzRXNMujwzS3L59CppZgxg06XMbRw +Dp19Bh3iySvIobPsFGXQWWYLesyhs8+gU2cLLpNDZ59Bp9H6lsihs8+g02QLLpFDZ59BZ5Mt6CmH +zj6DDmULriCHzr6dmFu9dA6dYeNqMuhky2LJHDr7DDqkjznn0GkCkm0yzC6CJTNt2zoG3joTSBfs +4mJIpp7egnPg9q67fKmSzkZeOBi2oNd+TZwDbj29jwWttPe2dKozvoI+YGNhPO3tashVmysqy/iQ +m2SwzlfnxsmJoj3jswNmH4flbn7I1+eUOed6fjrPlXG/uEd6wvuQLDIfHTxXdkMyS5mDc/GUNOeK +1xR1oSBKbI+3BKqZp1AQHD9mGgzi3W1s5TRGN4Mt7a+6j23ZT83nMtlNGwnp1TGIKBms+bIeY5zs +ZnVso7WSnJLdrO1T+wMHFbcs2gaDaExTJzOkqMtm0GQKuwOmDcEijSc2TerbKfPRHc9qlDwZvWhX +Wpm9Tdo6hNJTiinKfTt1mXXobNsDZJmdZcv6mNF15uQ47AljnZsEfHttGjS7wIlV2VLtsswCU2lK ++jwwR7XLdR7f3CkG3kMeX9Mp/2VL47SyTk2zToKxV6WNMfDBg88tq0FlzFI0rdfPMQbedRRBu6z1 +YJqun9s8PmHilBNjRwza6HQIbGUZohPl5MMqM8ULMGeKd48xrYN1SYw5pom6n6TC0RbCmNbxS+Xu +7mPaQKeKLrDeJJPLnS5r8PkazSx5q1+Z+y3t8+V0ICwA9Da1EtkExBv1QsJ/3mx3d8WFsSdbfA7G +3kfFtbFnBUAfo7gACKerUcA6y7dquEuVW2iFXgln+SKpNObbAqa4OTsZfLYuaZiVZmHEGcjeLkfO +55Dm7OLIE03I/soTn8G8stEjU1NDKH+oMHOBctXJiBUlfx15c++YmEpYU3JIkDNwHeuMqJmpNF9A +Hztyu+OV/W6pj30deXPvWKfZ6SOIFsbTp4OnwaczJaxJwKNHRjMkTT4yGBTlxf1hMyTtZnaWYjZ4 +YtwOyT463Tkpzm5I+rs74jr/L05JWoVH5hh5ZJaMUgOa8LYLj4x4xueQnrOdiu8s45FR2fvHy3tk +AICQTXSHhzS0RTwyhmzB5T0yMA1N55Gxykh1ys9jPHlkTP38xy7Sc9wl58AUPbDhnCnZXfgeLNVB +aJXlE0VZto4bd6Ms04fXkS0XxGCfkzg+WU0kA1yX1GVwNU4dMLVUyCGm100a2oIB7Gr5AhPIrL1L +HtLHDKELptmCTnl1noNmjRGqKK/OZbyebV6dKnXUJlPY2Ql6YntJlWr3qnRL21C9C+NdpPCZS0En +5bxbBSatJh8O9rKKmDr7fDjv948tkg9nFgV9MVh1PtwSeRYe8uHsIlRXlw8HvdZL7kAX+XAmN4Ja +JnEtng+niYaSvgmuOh9Of+8ozohbdT6c4y0BK8mH05xYuQi1XCwfTm+LWR3rwEy25TProYBbWUwk +AKWNibTSLd3ERN6MXMVEOu39aY9eVg3IowCJ5bPREZyo0+q7hOMmj8QSCtbHEJwVZHIZIhlsYuCd +ORpMrrN2iBnjnVW1bCwinoPfu4aI5+C3w0LoNqGlt+fuZpltqCQfqbwKy25DAMz2WhkzPma5De/H +brehjTYO8e3NXjQltNXcBozgeNs+FvnIAM5KEiELCXdSzBGO9ZXAFrdpWYVZG68EdrwNTeuV1t3W +GI4afVgw+cz+YidHg1rOSCU3Fw0QUc3Z6mLhhTJSG5uvLpJIXWakNjabblwGDql+K8lIffpeTUYq +hLOKjFSYL7Z8RiqEsoqMVAjH3TXQOpPYLK4PbRDrS1M9BxmFY+Lqa7fh3dLbUJcKZ87HVp0Kh+L5 +bSN6VpEKZ7ouK0+FW9xvqcWYve3uwa5cIhVOfQcRSob7JalwJl6FX5AKZ+4fc2mf3dsphmpWoL4/ +2S7x6dMyVtXNjfBafSwfdzCL3AZ6QVCsK4+iCwcyBGZ9s51HHcZwybDXwwVVNvq9yyMcu9t5ASs3 +E3lKL87Jzfq8uifL63D0wkHyjpqIB2X/wqpxUbP+xDVAJS7T55/l/k3jtbDVnhdLye3MS6mevihm +ErMg4Pyl+iF/j8qGFx6Kk0y2wtWP87l4K5/PJU5gEYLaWBJHgb52yKLHSZuLZZZ1Bq0kMUfp0Trv +TLhMXajJS5vsttc6P1U7n1Wdsp+7gf2NkVWGHXN/Z5fs1k5YdkqU6jm7DLvAefe0YdXpm02n5VhS +1ak+FysVmaq8cPpkN+busypXJtSlgG2G7JLdyLiuU209vr2BVYYdt7X1zc2frJLdHu2yzgb2GXaj +et2y051q57Nt1WnHvh7f5Z11p8Wzx7IlereH9N6rVaeX2gw7tKpgw4qzRr9EOk+5bLdn1g57FTQt +maeqK4hM+AK3E0VnlTNRRM8kKyldmvf1AtXOd+wi5FarwUaGeC6aM6KLndFqUnucI1T1XhPrOlbf +LoakOhezGZRTcKpTnAe2XldZSc6s7IjJnSouvEt2leQ8eeEeC65DJB2yIdGdkB7i+pyKyNnG9bmn +J4cicpbzM6v75lRsxO38nGsNuEa6U50R3V1qS9SPc79fyh3rQkSW4a5uC9DZe3oXyaZbzA/jNZvO +zA6QanGuLpvO5f0wS2bTmfkE9ftl+Ww6s1y6RTMfrbPpzHzx5pH2y2TTadAi7lnT+8eWyqYzA+Vw +Q8gC2XQLSmSP2XRm5zSyrFxZNp1ZLp3a3l9NNp1ZLp3L2B4P2XRmvnapAvvqsunMVhd5eleaTWem +3KhjR1eTTWeWS2dx2/wS2XTGIX1uWWtKi2bTmSmnvsCqs+nM1s8kGmrJbDo9KMeawgtl01nplqvN +pnOPsWWy6XSg9GfiK8qmWwhjnrPpbHOsVpZNZ55bvepsOjMAoJcVZ9OZnZboYuBXkE1nxh601usq +sukcTkZWlE3nLF9WkU1nhgxFG19VNp1TJtdqsunMcuks6/EtbwDGFANQU1/M09VN1lW8jEUq9bU5 +XCY+fTtsdg3ymZFVLZvF69UZhjSDpzyrrldnrV24w9MsEvSEJwVLmkhImJPpqFi4JAFNgoJF1rPV +oHRDcssKXFSX0x5MLTQkiDEwKE9ll+2GZB5IYclhbPBkU3bZgmVCKaa1iA7J46nOIqK3k2OHwub2 +njm5WpZdobuly9yp7rlyqZIvUubOsrrciatcJZdl7qwyudwl0rkKkLCPT1YK3S23VuX7sZsqM7Ze +Kldl7hw9ihAxS5e5E3UY+0J3S5e5w7lvDoXu3B0ejU9WcM8VfXhN2i+i+zyLk5WFKI1PFJV74Vwe +MLWDsFv6tDzlgQXqHGMPnegTptFB49nWA+8qkc5NRLPPOcPQOojDdX4h6MUm7NBDEBnEjqXrT0vJ +7ipsgZ63gvp8InhpquWcze6GsjrvKV8MFkzs0kRDAaJyiAd3HQ0FQDnGj7mOhgLA3EV02wc2I963 +kszH5Y9CYEVBm+vAxdV3CcdVbVczKKrIrtoqdiCCYshkN80Uds5lR8BcJdZa1YDQJ9bWhsbE2tpw +dbcCQmArKWSMaAyM1g0zU8suS1TWzVDpWO/VLoZ613ikCzPxjBHUtpa4VQx1Z9pbSWaKfPOxd03C +CKo6X1UFQ/DiwvqI2PXev/ZUqNrq9A0WXltancBQ7KI6PcBZwS0BGM6y1aoxFGkTmt1w6C1W9dpF +IoOnE95wxGQb3rhIZHDlgV+6wp2UX2lV426BbWgSXLFo3WpvFe7sMh+X2IYSoYkV7lZSKc8xn8hd +pbxl84nkSnnLb0ObCnfavCQ3+SGLVLizq/cKa9x5r3Dn9lZzmP20fGLt07ei5lhZr64TawEwZzXH +50bRwbXpFkus1Wc+ssv6j2B+4alpOrS3e64QnAX4puGOCAhnJfmcp4Q7W8wRjnUurC6Jyed0zQQq +l+clv90siUl9KgoZRNSwDVMhh4Vw4deS6r65TGNyk8QUPHjRW6IqKeYmjUk7SQffqQJKXhfLNKZU +yFWGuq3ZLu/KVMjNrnSTxBQ8GOqV70XtyjtPSUxWEUSwdqKNpPWmGN6JObxL3MqvUw== + + + DE0uS7y7xzUgVpHjmo9b3yoG7RevFek8lXtEqLTWx+5XdzXVPTp9W1GO673l1VTedZjm1FO5R4dK +eYkFc1xV+1MOw3CR9eyc4wqG5Drr2S7HVfQAwYWo8ub9SaofzHirHNQLPTKfSxzfFrY6xzVfoHAY +qdUPRm8RDvwqX6DsvtLdU6lNBdObBSx4kGtX5TsWf2mS8M4Or9SdavLhfIHp1s39hdpVpa3Dlso/ +3lvkw4Wtk/Am87cUqeXJujQ8Ytcq94/b2uavws9WSXhPlp2CuWyWxrTlXIny1sO1ZafBo2b8w6oO +W1jpVM7kUhB8wVKqTrWpadMgv6PUEaR1WY7h0OFj36xTXwAiWF9zTpOG19Dn/qnRe7J/YdEptxVg +zgpvig9WnxH3atNpeZuz7rR8ufVg1imq+yZUNKmV+k6v7OoIntxYd1osXpc0kV2g2234Pir/EpMw +57sHCe3qW7Sj84RlO3V+JfG2m8q6gBhJjWZFRUyCOd8zeqVTPqwRvT1a4Zm38RPLgs5l2CRAKhtG +p0GaKmbOgZMuZDOAfaBPbHL0kFinJBlDqyyHBCnZelB5N6lNzolN01VVZkEOXYfKLG49SQX70CrL +pTNUZgEd1LyEoNll3elunlwiK80hQhNjyeeOnnSHXl7nJ3utYd6d5yqLFkMyRGnp94trpHuK0vIF +7AZl7Sf2NiTALa3jtMTxGGJjdeyq+JTe1R5eF401UxYzJQDsIxdXXzv4YF+Kq7q88T624e6GQxfZ +SLbuZbenPC/FZW6iVXISDVfGLZTsZn5k7ele65figp5l7S2aMAtw2Utoze6Ks8wXc7JajHfF2RhA +5v4xbdCIyRFro+Sp3oE1hymtzEZulPQcZtFTb5xwZ7WP0YmVc/k6zcj0fn5nlx2qx2fpVWG+DQEE +PWHiXR+xqP0UPLizPhz0lkhmqGexRFk2+0wmTzlWSU/3HKiGpMt/aZftfMeO2rhmSKpQffG0WrVr +PaYC9rZdpHKq77mySQV0KmnssH7KyXu77Jyo45oYdHWNTavMeADmVEUnqM+utQGmkyrLYcwxl8f9 +JLUnl0tizLGejieMVZknC2CGdGEz7VDE2IJZgG5zAF3fQ2KVIOYqB9AmOt1FFqDbHECjP9lLFqDb +HED1DYfeswDd5gAir/XCWYAaUrGxMPVxsN6yAN3mAEKMLZ4FqODTnm9oc6y8ZgG6zQGUbeSFsgAt +hmTIAVSfV+LxGGe1fFE+9xXZlinKp5rLLyzKZ/Aq/JKifE4V2VZTlA/njNgrKMsX5fMFTLTClRfl +M9ZH/hVF+azrI6+yKJ+r+pXLFOVTexXgoDjLQYkockoNtq7qt/zdUMeruBvKZV0/V3dDLV3XTzW1 +FdwNZVXXz1uc0qJ1/eyr+i10N5RJXT97r5C5Je69rp858dneDbVAXT9nSl5FXT/7yBDZc7VkXT+n +TK4VOXRtq/r5Ap4cupZ1/eynpvNdLFzXTzMQQ1W/BSqAmNb1s5+QWYTqInX9TNMR7W41d48Y15my +pndBL1DXz/7mL/lMfMm6fraCLo+k2Arq+tm7hT3dQGVT18/e1DWNgl6grp9ZmqSy9Zarx7eCnHdP +df3soUA//yrq+tkfqPhcw1km8V2fkbpoXT8TVVNV1U9dnYFYoq6fbhsS2qp+mju7PKenEHJdP8e8 +15XU9bOv6idT8pJ1/ewDrlUZqUvV9VPyt8xoUXfP1cJ1/ewRiDTYFdT1s9lr0x69onp8u/ZQXNfj +cygn57oe31J1/WQoptvHazaHoa6fTd6DY7Rtx2tdP3tNHt54sIq6flYy/MZ4krhY/pYLdV46SXTa +hk51/ezPm7VRBIvX9dNiW28tLlqPz1uQhnU9vhVsH7mq3/L1+NwkMTnd3mCM1fBWik+fkbpcXT+N +Y9tQ1Q9nDC1f109OlbKrK7p0XT97NceCxjzX9bOv6rf0rU1iXb8lfX0u6/q5yHtdQV0/+6p+nuvx +LZSFq+OWxrp+iyfDq6r6qXpZqq6f0ZWsrupndcuZ17p+9uFdOim2cF0/+0AnnU9p4bp+Juuiqupn +fy+c+7p+i/sttRjznvNkYVcuUddPYVxmVf0Wjh7U1fWzpQhVBZDl6vrZK4bYel2+rp99QqwokZeu +66edpL6qn0Efc32Tlbaun7UShHUYh5usXNb1c6XDLF3XT72SxgMcm+xai/1pXtfPXjjYZnGuLCEW +y/2EiXh4sNPRzq/NIz7090p94hsVdbISPLV27doH3uvSFjXUJNGYcnqTPhir8+Cxb0rsKqSRkPGR +ghgicd7hZHyeaSzR6hTmvlHTzw0gVo43Io9n20TirsfjRjCfamP7NH0UJ0LDjUTrcczQk8/jUrr/ +nLy83g3FBuFg7jtHVD7Oslvf8xy38dRo0+DXWybACnuVndPz7yv2u3f/6AvwbJxpCaelu/hJfLLB +VsvMW+6qd33Yrp1yt5/1zhn7fRPqvG/fZsNM4WuzfnXSS/X370adw9Dw+5X/DkwyQ+5s4/bsMLhN +h8pc4P3x6Cg8/9x6ZEZPnZS491FuZ/q6XrvZiEdeMhvUx/dNZJ8OZohS7iRHlN5bx0SZ27maTN6S +oclUuD2abr1wzSnbfLyQMy3rkYNE7DZOV5ObUtrbV2IyfRrBYnPJLZxbbeQhmvzSvYfqazLbuhxD +g1ouAQnrSc7fyMBuNlM9NkMWQgaY7mwHrgu9vWE5V5TRGGoEOxdbNw/19PZwkijtUMzHfKvf3mjD +TNJjKTl0Yx4dM2cwXu10iHISN7Klej1AbHfayN6/GGlV9rFu+4CpXeRVSXOKv1U1NcDWzPCQ5gL5 +uS9QeCh17lABzfxz+eqOO8u3NzOJ2f5xJjFt75WSW72L4m2GfgFoG6bL/Zu7p2yF22gCODffElhc +PjNERno8TGW8f8nsVTcmaFbZwQhScvbk9vY1Ury5q8BfYMIX/ThM2o1isz7N3k+Q5UQkZiEYjfA6 +w5w4wcaD0i8yhHzHACP8EPzJ76KsX8Bwjsbgz4Mo4jBbQSDFHifgQT4ufVhKlIrUqQDAVohIIRqY +l0KVoyMyGvwcFFu97ySRSPNhNFA4uGdyN0/u5buNBAleHERULxrb+QNfQHqVjymvqNzD9aH04iih +vKC39z6y0otzUn7xIqKtfLCrPFN6hnK/nI+qXsG+RThlsOsBJnbBTJ8icM5h6nn6BRhg+YpEN+GQ +lcMrGkz3clc13eZHBGL2EqD8YNQjW9t8Sj4XA6wQkleObMUOSNgoAfOWBmTr8Aii7ZIUv7m8RmBh +Uuv+Fuw5AnOLkVjapsIxBmr/9ZjSKRU+zOzhXvbggfdVrh//2M1etN6rhZOjjZpCkvKxQF5ruAa0 +BmeOCldK+2bwACUvCvGyeiBDzLGzi+1O+flB+MjW5tvd4kP7goCzIhH1Ykp+o57nLxlxNe5faIm8 +6oxq6oVDviXtg9sYQiBVuMxDCXibkMj+FsBuPsPabLekqO6yt6J2MYK/afkXg0EU9wYc+PNBhPja +KsEleUhIXz8Q8i9SNZo36qUrjeaBRi98AfFVobct7oPeF4vnopW02jPTHQ2bkbmABZsBshIyGh2b +ST2fj0LF29zpcS7cn8Ccfq6SKxLxupHN6Kv0BhG1AS4goBtdw/K5GOCW4o6/60UwSebuXqZgVpvx +RHfzYofeTg5mBBGKT8XpAuaC4qaRexL8yYRRVjBZfMrAP1NgI21/pSHfiKpW/wl8cwNpohJHahCM +VIkjw50sv8ShYV5JWLhgKoRMkDsqd0qaPQnBUNFvMkoM33wBaaFOdvG+i+YDTfmZuH+BDge38wlY +eP6mkn/rZdsaJlQlCLZ5AhfiREUHZDn3DTWOj3OEsTPQwf0IcWI49aesqJYA1oOfYeYKGQ6WNLZy +SHHOmkbaS8sY0p7BV6dQzckAAS7MsV6zw45KKuUOPdvMZzfBZ1cz2PhGc/eBpCmF1SCi3aIORCS/ +fViUBXSFCiXvaUVlQ882N9OHZaIdGBYmk4PRrlqFAPoBulehFFBAEJ1NNqEDcXd3kZVBdEOarVLu +Q6SG8PoVn/Zi9M7eIwlwXIhCypHsSvQU0lgcP32evsIt/jSV2MzrTIP5raBY5pj6uJQ1pWdFSUIF +pqGquQlf3CPcqfTkoKK07GZudxuSbnJASWoJvp8BiL9NpqwvtgwL4UrrMt+AnW7gFWCmjztQipVe +N6Q7MpJb4nj612dq5f0+OhQxlgtDpwe+FKLyHN/8ugZ4ipRAp/EY2uDG2yKgFw6MrBwRkVCY1mQk +PKmRMH88l5Ggu7EjokLB44Ruqu7ukFHgC4TzD+0XCQlgPGok8BNLJEgo2N1WoeAw/z1SoeAwVJgg +FABKFruV6n+jJXFGAmBCvQTulObPeyIKqDlpRgf4Vo17LRISCmHfbYwSRYyESe7+UUFCqLl99WRB +B+J1tHLVcsDHzEjJFkTEOy1qI4elcwBlFJ7HEDMDgNbFNYj4gltKiU8OE0uuRtSaphHnl0ZhQ9PR +qAUIV3hAnD8adzENOnMZCokgGofn2jGQ9mPAdqUtf4pSEghuS1mN6Wb5JK9pl9hV2sFS6RcWdd7B +4oSWpbHw8jSWWHAMKhojl6Wx8PI0tmsJwgUATGMxF2SqAaGfhgMqRRqzxQSxJEUkIr6AC0zYgnDD ++XwBWxBWqHS1GhBAXO3tWYioEq4JG8l9UxDEstNQ7QxfYLFpUJ7GgPa+fhS08/6sMAen+QgewyTN +ai79eqP0MkCRyG4xQUW9j0HHLalliYqKm1GEJ25JuVFuzOSQwi2pZbc4RWr/pHR8jKJFYyHUrgOD +NDPFHhlklSmafrp8G8JWhGLTFV9S+6LZd94ZirbtXS9GvVbaUSLR+I4haxjeETH9jMGv48gGoQ+v +N5HtF5SOE7eCKOgHmcLYuyabwti3Fjy4+gZ/ZmL4z+dpBxmKQXp7f/+t9Bp+RPVfXjIfsrkakr1+ +z0Q7FEpJ9mlqV+VYU80gnYmq3GrBw2paelGKKy/QfReyCwYYuyqP2+HNOCd5ylJoGmF1z+VMROVW +U/VcLikOvRdUExp54aoJ0atQPiegeyCCM1OA8UxhS675EmhI072MYMdZc0xCsr+Myer1NhVMh2BS +42Vc9K1xeUg5lwSuLjchW5Vz9EAE23p4JEWf6H0pkjit9SA/qGPznwpzqbbUaT2OeyHC2wJB9WuB +YjQZfsnsEf9/b9f+l8auxP+C/R+WWhUFlyT7yvqqCiq2+KiIinpEkK1aFRTh9vSX+7ffmUn2AVLr +0Z5bP62bYXeSzHxnJpkJ28OPycabMBZtvVX26dk5rXj3flB4Bcdx/IxfcmQpjrww8bSYqy30vOWa +s7Pq/9XO6lTcSTWj8Vs/FbE2LhJ4iZlB+zbJkBzl0xm38hK6iiNLJ9tOtrhKA5Uud119dVcT+mpw +ek5lQLE+02zoK3HlIgOXGADGGicryPHEwveidEXjrsLU043BvuZ9MXN8HSfWRDrjtg== + + + 0P4ef+DEVtCK53JCpaXUTnxK5QgU2pbqWZXoWj9bJYufjfJ61Qd9Cxh2TmfOnWySOY+T3dOUU8JT +x2p1UZ4h5OFxFowM5Vyc/AHDXsn8RQLG+mieXt8HFra4Vbg57lsqVXWTn8+Rd7I/Lqx/HvetHWMS +jG/ni0Jt/A9+VNN75JFEO2XyR3LslHFaLpKHyYKHad2u3X3obPD8uR+SPGkuX1iS9xqxeATnNskW +nJlUauKbtaykvBcark6hbV45KLEdS5fvAKn/XTYk911TCuabhf3BXdjb7d1c3XTMvLFgFFa3OK91 +2t2NXhgehH/3S93LwX3Y6ZvzZmG1Wtzakm4pvOy2Q5POoLgXfirHoFJr+nhNuhI5dO5GZaFL34LN +2/LE/lKz9I3Vl1OncmiLP/1w8JjJX3+H1Ukmd2lNZvKN9mkmLzaqmWz5KY/NukpDxDN7Xg+7AJB4 +sxOlsLc2WM9tV45GEugULYOLg80lY3L9aC3cXyk8XS0WyqsnX0onG4fVlUKfdSlTMZocVDONi5Vj +apu9nuhPZWYWd5zMXGH6EGucJZjLx5IsZPIzKytI/ZzJff2wg/PbwQ8+ZeZW7XYmv31czsw+TvQQ +/1JnkDYGeFBO5HRqOKnfbDQakQ3udckwDGVCPH91hZndw0ftYzFJjE/HSeICNfEkWlZffQ9ntRUB +etJWRM35LFpjeU77Dnyxh2bxrTbfjzLOW6lIxcrNfhCFsNdXoJL6kzH571WgkvqTynq/vgKFTVha +ZKC5t5Lwbugs+94GLRlmwbGFawQ0rMJLOk1VkWD/u6Davd0Cxto8dPD4EZo1YjurlFPYO7XjeJhL +1aLaUxYEpHolieMXUS8E9hOQWKnQXJyav+pM1zYW153vI2lQPI/wNX24KjphFZ8FCGCEnWLCcRw/ +9d2GV3OM3mNMHGc+y6+B3NxYmQ4PSlvtpYy2pvoxj8tMYqh+M3PXmIiCZtOJp95Mw6u1S/40r11u +q1bQsG8dM96qbM3AFSw3VFxpnYvlYEuArlpNPOugr9sOsdCqvd0njnN0AAqax9Ey6faURVfnCdpa +6aXcbdtOfXCesRswF4ruF9uPkzSX4fMYxfQZKkBt2s3EXuD3bga9JTga9CaL+ljF8u0n5Wvyjw+7 +491M7MfIzttThSmdxlfheLujp7sbzkbr7Oml6qwub4NromU3wpnpZffRelPFWnAuGIHKWRWYw6db +3G+VZ7VL4R8KojR3mqPydhzW5/R3gKnGjUdkjvX6a/PLjP4OmrtRGH9MEPxPBEg8ZxodNgXP4GSx +FGaNrNFVTT07skBXoVntBcDXxIUmK11dfyiy0ufFLnvudSC+6DLT0ixV2FQtKkd6U7uezXPKde/M +6Uj9MF94dU1S8X72zY743R9KjQme8OhHb6nwPdkijivs4Nuiv0aFnV5upDbU6y1+qqZzH2zrLG8N +s7herjVm1+MiVm2kiIW0iXQJ60R8HilhsfXFXcVAVby+PmcxGGJRniqnTcWpTkfxGuum+R2BrxVF +PJVzeGXFtALR6N2Fy4DafPUR15c95WYgOJ6MLFrfvi3O3tMZR5SJrlpldCVn4X4/Lh/VXygfoeX8 +vnykK8Tjaifq3aqvrJ2MqZykcpjG5JtSHPRSQyWC87QIqKKnRXCSiADmguNJCwEX+r8RQnNxJxGB +fXrHZSICXGdbI2XE5N3rrxHCazL9L+ej6T9FfrmG9mIZEf+juEiKZyNAemUlEv9fqndgMfrWwa9G +8boxNHovM1B6eZFF6+l9JrV5PYit8o3a2Dt7eAWmwVumWIxgeq/xC7N4rSj3wqfEW76pMLu81838 +fgz16PTh+FH0opMLTv0+YcHK2/XLoTL4WYzfekrxbOOv8v4Ixug1Bu/BWLXzboyF/XeO4S7zbowd +dt6NsXr3H7ne5wxavRhjL0Dk5KVpXL9alL/E2O3gfdqoN1LmqiQ2ThIvsmj9M8+HUWyURdh7nzbq +108jkNISez2o6rdvAPbQ+5iW653BO6fRy4yzDNi/vH4agw9vHEO8Tj6ZmPidfYqns4RFZvrwupoe +Q6v16xiQisgvSaIVPr5nDOgtW9fvBFXr9um93rLV6f/W1b0Yh1qPg9Q6+U0m3hpk0s3LiQ9DzakJ +2iqoTDEeR/yUw+yEN5IhYWF/RdICM9nTpbZ9zY/3Z2orP71Ud6NTmA3aMs5Fp17PntS+Mj60iqlq +fZVV2TzYCs8Ob4VpZ5zXzaJF+2YrfqwQJ9jPknQwSgw2tqmM25+rQCX1J+rlX6pAJfUnY7gChWmw +zZqgrFg60bNXzFHiTCd69rbmok3qYFbvAvcqlsqt4bvOobnPcPXP4Z826qWwd6zY2p8OOpY+2v3R +molqUVuky1w6U1jftagXe03aciE8n/lWvPY2dtfu5IRMpa5VmhY23vp75s9KCMnuvb5f+Eccx/Ez +hjnWWMLRqy3NF1drUwsXxWv/y8PqwWrnSKXi1k5nz3Wh6fI4PjF9YCffXUhrt1XJp3KwTZ2AbO2r +7zbgN9xn1FXzw6FKwCWpIbF2YpexNlKnQgtdacW2rlyVW1MZ2tuapc448vjU81xcFppL52VvmyKV +WEtlhG+vnCh/dOLquRyzCdqaJWk19W3DsQesc3/ueDVlFcYfsP6Dx6uNyV8esP6Dx6tVLWrsAevc +W45XP/132VgASG1x3ljvtNM1JmNyEijVsD94wBvcxlp4ddOpNH+GPYOb6ofBDzddU7iu6Qf0i5ku +UistI7sT/mg8XXd/PPWb/XDGrHSMyUZhtdcv3Vz2b7qdZu+nOQ8kbhbWut07M7u6Vd04Mtf/fuj2 ++iZ1ZB50zWK1OoPlrRfvO7x5umndhUP3F463K7Wtkjlv0kj+djfSo1lAPpw1YDxwk3oCJNEwmLkK +f49/GAP4YeauwSwGf2yY7a8v1M9x02AkFQF/j39C4zNcfAfSD9Mxt83Tv5jZRub7hhCWcO3ADCzH +Fdw17w3BLea6vulavm07ZsXggRX4zIdb7MBxbaR4lnAc6InBPb6duocLi0kBBOTiMdfkwMbxOFKg +Jy4l3eJ5yFi4loSnkYsjhL4lPZiK8W28qjyzsNXpm9nq4Wajet18CA9+PoQp2c2CxCzpMeYDECzp +BF4QwIUvA9eRGi8MxUST5RIm60jm+Dh9ZgWOZxNFOMKEtnSFC23XdT2P2kLg554LMy0aIwSShe/D +6AOLB8BCyYt7Sl5OIBWBea6DBNe2hck9vPRsFuhL35Y28E41KrohHQ/EnDwfONBFqoPAly49OUzR +wwKFgvyF5MiQRi456kiKmOIGDlIC4dPkAxdhBfNGSQUeXhaNVINUzfWYmMD7hIdIABY2/MZ2ADql +TjyhHh6ikN4dEBiOzLN9hQzVL/QvCYTCU4qiGQNooM05iBsl4jIv3SYwFY1RSkVRPKFEDTggnkwq +LQTcTPXqMhhg0RilqKECMEC5AqAk1fSF9Dnp3xW+prhOQJAROFYUEOcJpFB6AKWoreWZoij7cR0/ +Bia1xUg7BdziMyij8XCzhDoV8AHZHQP0EcS5RDRxUBEnSHNAODSlzzg2qStsO7ZUEB+iEIADGdgp +dNI9IMwAZev7isLBLoDAAngo6jWwXMeT1BYMEArG7gW+rboZomgvAjj3LJCOo70Ig+kgFxutTlEc +choAO5SusDhj2I/neUy1fYcGFgg1nREK4Y0LZWuOrRHJbU/NOMYouS2kuCg0FKcnSYgclAtDDST4 +Da5/k0KGKHo6PvBwrIB5WmpDyhlH+WbM1sa7Qf83brCmwwCLwgD8ahuemZ0xj48oqpR0ZBGO58Gk +UgHFByCyIYq0XQG+AS6ksCEOMMtmPPCehxuwK/L5gESGVnOP8mUSJsPIvzPyGrblSnSrtlDWyaXl +iMA3fYAJuNroFh81iwp2lZ5YgGpxwJJtW9k0+Ha0R8Y95Gtzy3fdgNhwT7uOoeH8H6IKTteDz3Dq +oGvJXCXIAAwDCFLCHIDg2+QOgIATBvvwA7SMovGMRMKwpUQHwIUf2EpgNowBjAM8IjkeoIAde8pn +QgMFCYJgPji3pKnEWzRGKZUURQSoCsXPt2xCa9SfD3pyfak4DFHUKAMyckCPMk+YigdXqDJJgQgp +ge0hBeKASQKSdIPtgamRjh1ftX2hvPAQhXAgGBeKIukZAdpQLD1cAAKscNLQaQDxkXgMUQgWMhA0 +VO5IR0FH2h5Cx+GIKaIENgnElujUwDeAbKSEOE2XCmJFI9WoqAbp1qTnHVIRgZJ6IA05HNxZ0Rgh +0KjAWaJdwAS5joU2RmfEgg3xWk9fSlr2+WCbNs4XLNFGE4wsTctNXSvLkTKI7kiuCKbFFGTjuGGD +64O5SCsgb3yPFB9UBRQQnAseHNoOxzukLZiNbc8DztBmto/TG6XQKoT78OyQlXse4tr1hG5TSAEC +PMKpF9QpmC/JEMfFQV+ROVMvQxTtJyRAjCal5epym+InLIf0asC1JU8WdtDGOAVxnDuC2h6FZM8O +PFctKNIEQgcDUdJcHNfX3gjXHBKWWn60bnEdN5EAtB0MnND2bEFrEAfWjShl29e9pAkqNjHACLct +oXmOaGYc5d8KGrVRQmVN7cpgj0ZboLk52LDtNa/Cg17z5g72aFdPzf+EZrPT6eKG5wE+Ma964VO/ +2wtN3AchBR6Jbofd3u6G8T/RBBSI + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/originals/SVG_Right_overlays/Not_downloaded_left.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/originals/SVG_Right_overlays/Not_downloaded_left.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,1570 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + + + + eJzsvWlzHcmRIPgL8j9gP7SZZLtEZ8aZoR1bs3ehRzvUYSqpW21tY2VUFVXiDEHWsljSan/9+h0e ++R5IkHx9aYA0AqAjnqeHR4SHX+Hxd//br796tvv27R9ePou38830d393ePfyxfu37352Q9Cbn79+ +/eMP798h6Ce/+enNkm5naLT7+fq1NPzHl+9+ePX2zc/oT/THO/z0T7568YeXL9+8uNn98PrF/U9v +fvJT+MtvX71//RL+9su377/+9u1f3rx+++Lbl99+/frlH9/f/vDn736qrwd8xxfvoeWy/P0c/j7M +y3wzt5/lig1evPnzix9+ePX/4Z9LXCPA9m9/fPPtqzff7d/+vwi8mW9igJ/wl//66jcvf3j4z8e3 +3/x4//LN+1+/e/vNyx9+OLx9/fbdDz+7Ofz1xZubX7z4Dv7y4uafX75+/fYvN/vXL775nxP0PH99 +9+r1S+jk/Yv3Nwt1effzJXy9//HV629/+eP9H15C92OpCI5fE8rf/QC4AC3+juD69c/vAfLVy/fv +gSx4IbLt8It//m8H4PXbe2oHwJv5drlZ4OdPfr375W9/9csTvK7dHJBN/zv9Ff4336Y8tAhL9k1C +QQz4wzUZWkT4/G0bcMTKDX7zD3vPGSIJG/7Lb15+94pmBYzUf/+p9PTd2+/vX7z7nz9wM2BxDPyX +3768//41jKfw/zbfLBm/6W/SCrhKLZ7Ftd48CyXCn2MrN6FZmz5eL//86uVffnbzy7dvXvKg7N69 +/4onRUrzzN/5L7/58fXLd7978+o9UFYQ1HhUfvH225evob19/u71i+9+0E4u/Ts3+O2Ld9+9fA/T +6e3rH9/TjF/1DTDqz1/89SVOnYVf8KvvX7757dt/JBqf1eU2RmBzbvwThiSW9aZEGN2VXpFm6OV8 +M7t308gzekSGqPQduAx+DfPnV+9efffqzc+Ewvr1P7x79W2fUzXcrPyNOnG7un9N/zG10PH371++ +EephLh9+4ebmfPuLr+CNpzffHt7eI/d/wCUHM+ANTI7Xb7/jv9nv9Bf4+I/fM/X0/69hoH797tUb +xDn9kv6yfv3r1z/Cn/7h3dsfv//5mz++nX7CIue37158A81ufvWH//Hym/cgOgTQf/vqx1fvX96+ +ePX9Tz+I6NevX7x58e6G4PBhBj5/9Wf4ywsg5YY/Bn/psI8jPb78Iyz9/lmGnt78+eXrt9+/7HCD +vHjz7c0/vXj3/cdRwzC8cxjov/rzEb198f5PIKVevvn2ByOL/zt2lGEfx/fVNzgp3t3s3/34w59u +fvv27WtDO/7JsAuYoNj+P8Y7fk0fePOrN8yg8zdJg+2bQCD8h3sLtH74DfDH/8jYDy9ev3713bsX +3//p1TeXXnDh7/Ym/tunTKy/3v/h7etXP9z3+eQgv37x7v2rb16//OqvP7x/ef8hbMiNP7568y1M +RBI6ndq399+jWnHz1Z9efP+ScL7/0x21/MoQ5q9BMHrR9+zZB2RiiDf7N+7v//DuxbevQNyCwrR/ +/ePLm9/Af1+8vlHwT6fLYBD3gOjb6V+m/zLN+LXMcU5znis869zm3byfj/NpvlsW0Bbikpa8lKUu +bdkt++WwHJdTmMMSQkihhArPGlrYhX04TOEYTuEuznGJAfeyWGIFHazFXdzHAzzHeIp3aU5LivBk +eEqqqaVd2qdDOqZTustAS15yyDGnKedc4Kl5zS3v8j4f8inflbksBTSAAp+GP5fp/9LO9K/F/i0X +/4daY7DvUf4BacSOOOeJuIL/9HuRf0l+K8CxAjzT7yvxD/8199sO/u3h+26iHwdi7wH+IZP5OzAb +2I3EwRd0BlQ3+IpL/+W/THd3d6e7493hbn+3u2vwrHf1rtzlu3QX78Ldcjef7k6n0/F0OO1Pu1M7 +rad6Kqd8Sqd4CqcF3gUfP56Ox+PhuD/upmM7rsd6LMd8TMd4DMcFyLo7nA7Hw+GwP+wO7bAe6qEc +8iHB0IXDAqTf7U/74/6w3+93+7Zf93Vf9nmf9nEfpv0C/bvbnXbH3WG33+12bbfu6q7s8i7t4i7s +FmDFHY3V3R11Bzt0pE5ht7BjO+scdq9SF7GT2M1EXcXOYnehw/ggktNpop5j3w/Uf+QA8qARH5AT +yAvkRiaOIE+QK8gXfGbjDvIHviZgErIJGAVPI16txC/kGPIMuZZ6Z86/To98jttnOgcJjx7z7M+f +6QJwd/5AZ9LN3329fwd9KvhV6VnhafLAYJY9PTAvgA/I1LtKoqOCiABhEOlJFZYsfJi/1tqm2uDZ +1X2FKYVMhBG5W2nFrAs8IENWEBRrWmGlr/TOta741VaYRStMtfVAQ3DCqdHmCZYWiKQWWmypgXAA +8mqD1q21HT0wPxvMYRw7mggwq2ARghCDmRhgPkaYlQnmJnYKKKOhxPVH6zDQs5AI5CeBKIwgCjP9 +ht8TiMVMT6EHOVCwMyQsG/zcTfTLHl8K3/fy/UAPrDf4fkJpirM5kByid8WAXyBBQcLiA7IQpCwI +vLBOJGwbCdxdgEUJEvcI30/wnRYGyF6UvgtIX8SAYhYEKYwJ2sKVpPEKfW8gj0kiPyBtkFu8fIh/ +yEfkJ/K1EZdxPAvxPcEIRKAIuzrj4MAQHWGwDjBkO2wKg1gnGtEM4xtprBeQl3e4KmEmHGBW4Ag0 +mCgVJk2G6ZOA1AAMnWH54yQ7wnTbw0g1QFNhauYJ5H6CHSAA52eQDydYkQfYH3ZA0oqTD3aNDPtL +BOYtILLvYNEfYYvZw6C3tMIbCmw+CfgTYCTnyHIJ1zQ90Z4gD43XceZHFpvImwMJiwN/7enZ0dMm +ZNyBmHGgmY/LBgRqJqGaSLCiaA0kXvGZScjekaBFUXskcYsCF792E8ndRrIXpW/l1QgyGKVwIkkM +shgemmn7mUQyCmUUy0cSzSicUTyjgG4swS5IgwtPe+wzDf9dP+mpl57pIrg88snnT5d1/2LT/uYD +v/AT4F+5yfNtbbGC1QwIwPT9+vMR7H+At6cZxGfApiW1Gi9iKQEmMprkKyxtatPWGVadYqy3sS3x +JubblnOn6/qoiWJYWgs6ym4DqGBruog2pDpnRFtASUzkRAJ9CRoL2uUW1a0bUMU6uVfGC7Tuj6Zo +qwZ8WYW+e/Hty5v3b2/+6U+oxk+b/8NQBVaakZIMIoh+iRVU1HPxCSS1sOQ6/oJUjpMO8dwonoud +5Y+PvyAem0gj/66Hkob5C9HNgK7mm+vRZwg/ZWD/4d3Ll2+8VbQBEFaxh0yIJhOi80aEqvg0Aep0 +3ERaRSAdYyZdVzbQg9s6+7YJGydJX9iicbOeYfvGbXwPG3uD/T6THrCAboB6wg62V1Q3Iugnd7AD +oSmBlkiYz762ltB5A5L5XYJmUbDBMrsLol4HtEgGJRuti5Pp2fvBygDNehKVehlMjSNtjfSdjbQm +9lIWuwpNrSiGmD6f8PW4vpL1iPYjW5AH0BXQELgTS5JtSbMmRfNdRePdaLuo705O2U2k7BZSdldU +dVHPpbc67ZR100Za6YH0UdZFA2mhmTTQFWbIDubVAebZHcy6BeZfhJmYgYAKm33DvX8PqsAReH8H +isICSkMEFSIDdRUUDN7LTQFcSAFEMxy/kqmC1FVW00kZRPO8kYm+IzNdFEMy1uGZcFgjGV6JxiuR +6suaKeL0ZoPryE6WCS6YIy2eO+rWLF0L9CZebJnnxkqW8pE8D5HU6pU05iNMx0B6cBVPg7oZsHds +hNG05C+YqjxtaQIvMp1JOSYbksadHtQsLrgO+hfPR3YQROp9NssfqKUPk07KWmlBXwWppayYLtiS +lFNWT1FBZRUVlFT68Adt5S46uuBIrGvzUO9Ik8dnFe2+yvDiQPOQ8xdOBJ4U0A8/YsJGYqRYCqtM +hv3gr8ERT+axAUWevDaj3wbGbCLHTYR2mbRwXnl91Y1rrq83tjLZvhxsy4lMy2CrrRuWvNp2W6tS +7Eq2KtmmVKsSP7JOZFSqWXkgs5KcBGhW0sN2ZSDOJrMuC63iKlYmrma2NPfTmampD5ucs5idbHiy +6cnGJxug/iEOTPLjg1PzM7/+VhEu9nMxx97Ce8tEfr0o/j2Sj2776b8V25YqbVFFFnp1/yfX3sR+ +CxofWhNFVsPerQRcBtm5Lm3Tcc7LItsMT3qY8jDdYc7z1pJkS2k2vU80rYNNaXaR4ExGW/soM1jn +ruw7E03Ync3Qk8xJ3nyybT472XyOJK3vyHoMIqF5C6owzXdogu7JIqVtCDaihazXSNZsIRt3Jat3 +R4Ywfp3QWCbDeSFTGreVTG40XLPrdFzJw7YXXeEIovwOXXKkSwR60GWH7COpQO48XrO0sZAysldj +/HTkzeDoXRtg2u/NkacuvCTm/SIG/UmMeHZ+qvuziK0exUZnJ+hpMsN8J/Z4FW9oHtXHjeq4E2HP +4r4rjmFiqY96I/lejiL9R69L2XhdRr/LiVxkB3KX7SZzv6wwUdj/kmnqRPPCLDiTyZpmX8yRptpe +PDI7kncr+WUq2Dyk5mRz0ERy0gRy1CyySnhnPYnT5kiOG37EU1F29rSJpSrro+bMdb7c/eDLVU9u +9+WqJ7f7cmf15U7Hk7lz1ZfbvbnNvLndn5ud52fw+LC3Z3LOnguungt+nnNPz+DrmdDZM7h7vMPH +OX3oac7vo74f9f7wrMuj/RLNFRScQ2hRm8bsGn1Ow0OcmuQHjs8nBgUsLPBQVGDaBgZE3dkqPKby +0CQ/iXORXYs6s8mvONGkXmw6H20iN53ANHOjuhbFuXg056K6FysrcpPT5M71uJ24GldyNaKzkd2N +6HAklyM5HdnteKQZsJ/I+8j+R/RAog+ykEqVyBMZyRsZSNli0wjVbp7gPC95Eung7lgDHBz3JhTm +QSgcVCg4vlXzyaYzeWDsm0QIqBjw61/X/jy4aT0vxVnrGTld4KPnYhKnbSDXuufhXpy3bWBemroX +1zjGvNqbgryKapxNJWaFGG3uu80+cZCdYh12iccHxzahsYkWwfyx0Ji42/vs7wp/n/sHFus6eOpO +V2f6ON95totspvHBsdmRyF1tVEIJk7jQ+4g0Nxo8FuxAP9Eo6BS2yTsykPTxPSssFuVZNvGdaqrL +qITfiQKuyjeQMonerRp3V2S8KhM28ZzVmaHOBMWBmMz+VN2GtZuV5OuOZO6B5PBJLO3ZlBy2t7Mp +Oqjq7CbTdXBvwD1CtZ2u7yTaYEznEZUHpSu8hwUsK0387E15Ogjao0Ub7kyd0pfoi4JFLTA2Ke/U +9+q7q4QyV9kImYqdbJCshKkidpRN9MQ76p3oZaqbdf0syDac5MnyFKexda1tZfNooh+7QYlzapw9 +/cuCpmzgswYeRQevpoUfNnp4GjTxvZqiThPPXRefRBk/SmxTtfFs+vjOpvfdgxr5XqY0hSo3Kvng +CrrkDBrdQaqRq0soTs4rtMqU1QnLjqHFNPLsdHKdWAe/YUjI0mV3SH7HIvHHQhkeqw== + + + hRyP7H0ZHAeJHAfkOpgk22NPE/EkfiP1H3QPAo+W+hCONGI9+2MxN4LLAanixdubP8F7FIJ58bIN +5zpErdmvcJzUjSdB60U2MvXmqY/BexmaxK93TrqJfKt3kwtkazC7ux7GkLY+qwS31ROxW/f9mVbR +JWWl6rIZAmXirOgui8UcF/0R99BE3wYxTRk8EWR7IXIpf8d51TR1R91Ad+L6YyeQLrW+0MJkbp/y +uHUGA3K0kcAx8H5U9KEKo8ctpG8g+DWsM+l+Em9NzwZg98xxcivtoe1i71acbBfmqcxmB8uym2Sz +kI3iwlahm4XfLtw69DsGivRp2DZ040hu8yhkr2xF+M6e/SjGJ3G8u3F3HvydePDNhy/21CUn/n6w +n6ulwMRJ1CO1lE6DGd0N6SrmkJrS3ZjWULdYPJMZ1KNJraHt87D2JqQtxrWa13mywIwLzXwgvcEn +OBQfrVGTe2Kbe1Cx1fL2ivZO1req21WkQDZDnE1xMV1UA19EnMwW6dbt82jPwZ798LCE2k30jcxq +H1Mfw+E9o0qzqjSzSsI+FvhxoZ/J5VkdbM/WPby5nKturVdTA7LLwBLbfTLzPbiErEX1DJcCdXIW +/dHs+m7bi30/yVJo9qz2dA4We7J70oUEEJjhwT2Le+b+bNKwTsNzHJ/pcP61P3t2Dzzt/CHdkcMg +5zl/lvH3QMLfB62aSTwUHzfwt9bNaN+YjT+ZX0uXmpo5acgi6p4sNVm35urCds/ksoj25rGqzlSN +g5nqTf69mUPV4jdpuhDA4fwiH8KRII7lGqkDwLsAxAkwiQ17krlFvgCxZtmeZYcAW7Vq2bJtlc09 +kLqTYBrDbphMADSAXevj6GsJy+oBqa6JfoGtM9CpnsAZFBz4D+EWdaAxoeC6aCmpoC4zNMBmc8qN +0k1Ka5QLQKY5HjlKeW74kgwjEzAFYGHclqLQ4m2AmdAJvSpWyXEJMDMRQWiACzGGNi956Puy1IKQ +okwI2PWe53NTwm2EeeJTXK6JlihdVsA5IAilAIph2DL0FdnRCDmd82Fssd3itnYTEyYAOUqvi5Yo +/fLplMotpQgtyJwUrjlTt6g5BWatccybWsKaBq408ifhLzXkRCM6I1uUEfUW3oBpS0tzmTDXxfsp +CTHPX715SceeLCNmC+nZTpsjAhgN4wMCBzsggMcD6mBA3snxgEgh+9KPB6DhOPW4/cbCOIl9ETch +tUvGvAuqTfkk9sXWujicmfBqW5yb8M4/NVnycdta8oNrqtsZ3je1b2cZx9NFi0Ntjp4rcei2vsuU +OMuVQD+/uqzUFGHH1U4CBs55ZTZJt0rUMkkSnSiHFfUHdl+dJEjHDqtCFsZOHFQyFYJMhqxZEDIh ++MzILKdG+rmRlexS513QCTJJinMWF4ObJe4MSRpOkWyzEoL3/kxmkz7K/XPRMF1dzg95Ck7mKQgu +26ee5R6cLPeg57OrU8im07R1d7pZFTbZBtts9iGXXZMKJpfMnjfWrLdnT86DFJw1u/V8HieK6EaY +F2ivop16JGdjoAlRj+1jU2GcDLM7RNSng6bBH2UyzNMgMMbJ0L1Ni0tUKepvsikxTIrpAZ/gOC22 +E2O/idL3xLA8XchTGUXMsklRGRLCtk6jdZ62csdmihc9lyfLxekyuayUs7MPg5+8T5bR8eE85ej2 +wMgFzhGcHShUThLsTzI52t9OgkrPPQwPZHtVO81F57jOZzinq50fkovmQpXENZrIuv3h9D1M5F9b +SJThvscy7A6maaS9DvOnjjAlF5iKmEDb1HUGcy7CXFthfh3qCSZThElUMUR0WE9AbYS5UWE6HGAC +LDDshfI8jiAJAkiASuN6gu0h0IjuMFXDLfUVJP/heAIrPEywcgqlWxzQC3+3UCpdgRm5Q8fVnZ3q +8kfUPueA2mCsTtc8noZm6vTx42kfSrozw9Tiz9PFOJweafFxOH+c5ewwSz/JMl04yvKJB1ko/MnB +zxbXyeKe0SKeJzoyxHnGK50syjBJKduYziKdKON4TznHKx1q4kNPeCAKltMdnVs8UApyT+dNlF+1 +aHbx01R4mgpPU+FpKrip4NxVa5ln8i2AdlZaI5u85SS1SMj+vHS+5dM+JmdYPu1k1pec6vrEkylf +vf3je64bdPOPr7578/I9HTy6BO1n9pUHk/JgUh5MyzTTI2x+fMtHDgiekynrLWid6abGW1BswyeN +zKXP0xA95rO3JS8hYW2cuOAH4s263tYY2qeR8DCax1PS8ufNzPGTnzJRfvfmzYv7l9/efCegG1hx +MFMugmk6iu9mU33hos180cXygMk8ndnL1c7I+NPgyyZnYsyacHkTk4V0i0udcC4XF9btLpdqZvFZ +KtDW1ZLPcoGG8K64WcgoftiY8bUjzutFRPmnxSJ60YiCNSS69VCtGgQbyTvy8BzIlOjlILgYBP2D +d97JYXQ8D4P/wgQiN9gJdD17zufO8dR55XPnZIfsSFz3Q+YnO2Ae5JA5iPeJTpcXOlujeR6c6bEn ++5uPlmN+D+wRdHxEzxTlB46OX2NL9jvydI0t2e/I0zW2ZL8jT5+/JfezS9vCFduyFduiFduSFa5e +xTQkOLtyFUNq82zRv57TvB+C9hq2L5OL3LvY/RC978fUd2cB/G0In2qFnB9O/0gcnxPlWacci1hc +Omt+fkg8byLfPfYdp03424XAz4Lgmp9+vBgJl1j45ILhPRx+HhDvIfEhKO6S2mW8pzEs7gLjp48F +xkfVC5Z+W/OHlBrYxJZW5pVjUyBv8BcMnaSLWtK1EHLUrYH8ShTHW+flMrIAa5xOiRf9RcJQl5XG +66H8sj07rBf3bAD7PZvHlvTovW0WO0nzoqQQOYukrqlLR2lDPwQ1Od/WJ52s9V+X9kb2/XJEiOJB +tFElVyqKI0FaJqpJ8iA6csn7NZFqspfIT6ByUL0YFCgkpI70eM+OvGDsmrXjU0SZeSajJVv1I0g+ +yepkebPLkJzb03NJP5kk7LGzRCrNg71zya+a9KoJrz7RdT21Mevqk6oDXSr/sykENH1K/Z+Hiv6w +KP1MM/yCFU4b/vTlO75UJXFJ5wdL/l9tJ9W9VHdTNXHVyOWs/2J2bpzY1DVjV81dNXjV5FWjV81e +NXzJ9N0UDsllbsFLkppy4Pi+Woio96PUwxSEBbSLctnW/FJMo7ULK2rNJGeXBct2+LgyV/dwBTRm +Aj1YU+JaKL9MfMaL0jOO9eya+uiHRw47ud/9cxgen9N1nMb/inrunnGR2/HLOCShXjr2Px78Hw2T +O437Tnb+v1w+nuBfT1LmQqWbM6XnE55p1JLOH1qno3b9Ccr153q7fPr60375tF8+7Zf/afbLmEFC ++K0jwwL3eVu0nXBBJ/gjp0Bd3C+/FBPvl1+268YFQGu92i6u+P7W9/J0eTNPcTSF8Osp9ewp9ewp +9ewp9ewp9ewp9ewp9ewp9ewp9ewpyeQp3+hpKjxNhaep8FmpZ7jnflJS14I2cfuCrDBB8NgMIz2M +mG9nPPb1Gclv+tEvNNLbZSO9OSPdeexIRVb1mHQLM6yjqxnRjWrVhLlchOi/ZhaR1qsGtdd1Wcsd +U4ruhvIQvgiLK4o4Pb4S739e7ZLzlIJ8ZzMJvm+cqx+6BuS8nP9Ha/RPD9Tif0wM4jyoAPKgp2Ns +kzLOkjP42oaPeVo/UUhPD/haP1tETw/lIp2LaM4I+lBxjmDZPyfp+AfKczATpuGs/9Eyfc6Lc8Sh +zuWdpfb0xJ5VOVQsp+eDtS4fEL/AmbKUi2JUckNA0lU88UppI0su7cNJul+IcPS5ljIv7Mdd4+jQ +tZPOiY5km5/0Ix7XL0T4ZaI8X/a3Ahhv4nzytz75W5/8rU/+1id/65O/9cnf+uRvffK3PnlWnpxs +T1PhaSo8TYUv87farRvrZhh1EHEIL92S8OAho2m4FWG8CXM8aTTehOmvcRuOGk0XzxolV7ZwceVC +/Z0cWr1Q7+SQEqGTq77vp8pYwjD6EobDjNE5YzNmenDK8EE0ni06Vz40U2SeTDJR+jThxL/xGro+ +P7azY5wbMDMmnBg0K3RO9BlBObTspGuwmnESBEl+xDWMKzjDcC8wxFo6v52dGzMPk/Mv7SdZw+Nl +Kvlisdex0Ovu8o0qkyzzh25POB/F4d4Ed4sK12XdTQ9daru51lbH9dIhw0EaTA+KAxzmj4uDnSV5 +ijyYPiIQvEjwQmEUCyIYcAZMFwSDEw0yFUR045oPNPQnWtY48DjkdGHChfsWfVnRYZyni8PcF+l4 +cU4f5QdvyZhsqP3FOW7RuuuLt6VHebx78VEa82kj+7dXZIyXZCzDbSP7s60ARn9yw/+Y/cDtCO4u +DHcPxrTJ8r2wMwx7w7g7uP2BJwIenjjIqYsPTQVQGVBh2MEgFFIUFlISDjD6K6yQBIrBDErBAYT2 +6uTHCbaPHU2hAG850eSpICkC7vBHmCsr8DfStRoHmAYVBj4CGXiFxg6GKMNILnRjxg7GKwNDFjuT +0GBAMgzEQldi7Ce6DSPDeluA2bzOUJQigxdgLjIW2aoSFJmp13gyB7vsJN5Nxjq+z3NgmuNZ2xxe +OD+wIGcU/gbscnUvdD/ThxyOaeNf6t6lwbU0PdLR+AE34+iXnj7vQomL/mnyLE4fuE7igcskPnyp +6PSBW0XHSyTcvaIfulZ0kosjxGVM/kHvNK7qNpZDH3d02CPQMY9MxztWuuJjTxd6nE53E13LyVdx +ZrqCc0XfOXqv8XYRcS88TYWnqfA0FZ6mgp8Kn1U+qs23y9w+L4tGPvp5ZaTKfJtiK1+QNqQYPjFv +6LPKZX1pgLlcrm1Q1g/VIzqPA2+ulSG/+AeW1vSRteVX1/YOJ7/ALDI8uRDN5YpEF28o20Tw9rby +TpMGhl04ZowLn0eFx8pEm5jwZMG8fhPNajFhPRx8+Fi4Zhl+0+JGY5kj/l/o/5vk12jfNW4SST0t +XPNIFNZC9+hyPIV/W6UMUqFzuXSP7m5TE2lbFelkdZGkHhJVRtKqSPy9l0NKk1RDqnSNyk5qIWkI +kqshSVyaLgbXekhRKiJFKYaEVg/q7ruJYjk7qoO0J+OIw5Oz1EFKdFPSUyWkK1RCGuzTRzsoxD1x +uYzSZ9wa6+roHKZeUclyq7Z3xp7fGDufFVay0krT5q7YflOsL680+D43JZbGIku76azO0lhp6bL/ +Uy53HcotiSNtcl5QV3Np61G7VIPpY3WYHqrFlH2xgSEL8EM1mVxVpst1mWAmTBeKM/Wrii7XZ+oV +mi7UaJqGMk2+UNOlC4wWXyniwjVG8EwXSjb524xk7v1nKuAEUmNeK1VbqiGtF5EtnHw335YgKW9r +Tm0OD+TQXQ/llyk5a7mo5AD40RdmcMkHtVEuWSiUEPNQ4o3mJajxc8kEGoyghxAVs6QY3TahC1EN +9tRZdYaPxfk+GuV7bMDwoyHDhxB9LPZ4hmpcZrCz8YUyywzKAF0XNM+ltmFVUKIQ5Q== + + + lcqk4ytmLs/jq2H8j17Y9myNhIv5pyEOC+djuZUXS3s+lFoJYzwNWvSoR48XOY4JlduUSkuonIb7 +f4tdwbcO1VNGexisYa6Rc57/VTeJp1sDY2tiDEbGtM36cjzyvHp0suDksgXLwJ2deAI4eyiN6YLU +OZcs2cu9jimTR0uZfChpssqFqDuMvvRsuG0+3OXEydHwOmPJNKTk1t32emhMk1qo80W6jJOAO+cy +m7c3pGpKM9+OGiilq9IZl6Ocb+HTLZi8fKIqPKmUCborJ1rANIp0lqUBn07EmQS8WOncyh10lsx2 +6NQROhKA+go07yljD9P1VqLzbqIkzgLs4gTOpSdwwkQ+Hu9AtkWQcxWYsgcJiHcnh7vEI/dJ2v3H +lfvpg9r9Rrd/jGo/fSwb4XIyAnXuul3DnOOHu3bBdPl496aPJ1tc6h6P3CdaZh/r4PSpltnHujc9 +JpfkvHsbRx++ETdIUFVaSVRPp7bARXRyoGo/qpnOAbpFm+nmsryxUPe1MPKFdi0uhATUKpATeIgj +w+5OezvpWjfkxOOSogmxYWPg7xLrxZ35Wgi/bLu+6M3bFiod9dz1TM+NVNwMtcdzX/w29fsU58m8 +8Jeqlj/oI3RFz5x/0Ou9Xvf1MQQfR/CKtD/W0HVgmLqTCy24Lg3d8lntPs7gYw0Ub/AeukXSkKM5 +0apYDm32efZSglDqgi9SFzxZ7KNMoq5XqwG+d+n3J+fxCvQvGcXZ0dxoOe8/WeX/lNS+Ol0zsc+b +AJ5GT6Wn01PqafXU3vlThf5coaN6oNtT7mkn6juFysWRxg2VGzr3F84C0tXJ50cB95Zxt5qbyo4B +bq7o7jQD1V94SvqLrYv5NoIqxPZRK7AI8JfS8ljkreBpuZWkNlr3GNGgcmWXhf3VMH6ROI3hkjgF +6Bfes3lycufsUNXkgppVKkf6gKaI0y897bU7O+CzoF7z0AGfIdz6mONFWwp8qLdszpsRBdOZgFMa +lAo+m3g94Xah0uMjhdu/Z870Y979yW+fLgnJ8/dv/JloOnJ9dhg0Wq1g1i1jFUW9srnqXbgfXPfX +Q/mZwV+89DiHLwn+CoYvEzwX3S5xrLL4qERfSvN9VJbvo5JFH7DaLqQHPibh8Cxz7iF0PjT3mOQE +Sk14VJLKf2R03qeJkjCRuzw3uskbORiGQ/PiNz//xd9g1G7XZbjW/OqYP3HhzR86e/8pn/6iBZcu +RgjShQCBfvXK08GSOznNMztXfZFEUE4IrRQ/X9U86FH0Xt9cQoebouV3FjvnrXSRu4UWiqKr5z9O +ZPhEWWRFllux2DrfNrRKbF1tDI6wH2ix8m6ssfbTpOE77ie/LAQpGsxfUU6I85NJEnEgnm8m4ruJ +eB9fJ7FV5L/0Xa8tanRxkV5gxBs+W2AHOWM8fqe/Tdbk6H7253ThuSPvxxCoxHHzWk0cdLnjoMup +aXy0ut9RurxKH1hdImVp+ohZrBd5Hcnz+ED5BJeLliZLl9kmokXySWqazLa+Tnyovs5kCWj5YoUd +dkZfyD57IPdsN4kr/k6OIgdNPpPcs4PUKO++9o9kn01nMlQT0FSSqixVacrylCXqjky2A8nVox9j +1V2TnR9eLbDWLJ3laIkry6BHZ8tXaZMsJlNlZa2okq/JKXpL185p1SfJSvHH5rPmW63kutOJ042A +D+c1qm9FpxL8my4kYW0zHMccrG1NDp1Ykns1UepVz23keYWu/xP5vwNNKJxOO5pKPJGCTCS+N+FI +8YtA06dO4rzvJ52x2oWedC5yzvmOpBL6xPmY8x36w2G0G4zwUQvO/+2ceP9XR7g88NAEnmR3UxeX +OrrS2f427muXNrSDXsox7meL28N8/JoXmN+8VjEZ2WzcqRF0t7lKYLwZwOe2jFktYzaLFLSahgyW +IW9lk6/ibxAb01OGtJRpyEcZbwsb00+GtJMh3WTIMpnG9BJKbWKP0ZjgxIacpjlpolOUTXHp6U6T +ZDzdScLN0eU9sZtJL5bj5Cd2OY0pUHoMlBKhpiEXSvOhFp0FMjInlxd1lLf0w6FyQPTpYPLf/sHk +q+WSXHZmjKP82eM8uXzOLx9pGOvpcRXlPjDWm9GePit2+IHxnh4dPfzoiG8s2bXOCwbDWoPNJNC1 +GrATxJVcO+LQmSWHZsGI3oNZOV+K6T9dNs7lwp5Y19OsVOcpsV1et/BeKKc4VXdn9uaJrjaabS/m +ndgSs6dNTrZkY5OKoFnYiSwhvZK20m1Iq9h2OzPPxAibLBs7kuZLui/NNVZ9uZbYjoL0R7KcTqTi +z2Q/oQKMKnCiG3IKFuWZKIkDdeEdze+jVBnjEwnY/yBPoqo9qBSjWoyK8UqrhctLqXpM9ybPpCVz +pSmuM4UnFjId/eVCU77U1IGrkVk9skXOMHCaTZ4o02Yd8mw40waX/XmeDWXajIZpNFc7j50apwuN +2YdPUuVe5Wi6eIZqpcSY3aWAw/b0lJzxiMLJOpm9ekDWOcvC2xaHB85O6cGp4Y7pRFk1o9V6tLul +1WxFVn6kLCznTk3DuSlvuertbMfh1FSgzO5CGTrnSWJguk6D5brKRVqX3X9svH78uqzHXZz14HVa +00fu1Lp4x9aHnvP7tz5079YjbuOaLpSufUwx2wef6cFqtx976uVneugPD1TLpWe0SJS12nulT1Go +1aHmxmKxYzUzLBH+E6+WfvhyabQVpsdcLv3466UPebpwvfQVLpj+zCum5bCDLyByN10oLuHLS2wL +TFCJiSfb42/J9nggQyIDByIGOhqGyMbSviVVSjvIqkhiqd9UH1BFr4fyP51OWi5GTgB6sdY8KTS8 +oe/MXXj5ELTkA1/YzNUDfaRU8UcegdY7M+uwmfucbzoFPTlHdHdF04YuW/ribsPM4pWWrd0803w4 ++oTCfGJfF6d+9uqz3S2vydSaW87cGQ+w7i2j+s4fZOW6R4nWdKHV3Wid72jFHzbZ5ZEykVE6FMpH +3txei/J2omRqcclKSjX7ZQ+SVd9ZWUkv2nFFSvHUsq8WvbV7vkV0Yoft/9ouWd5MPlZh/8N3/Z5f +4HvhuN2HK+9fOIrnn+lBvfKhr+MDj/gS5RQf9f5TzrY+Zt/5tBTxR+w60/Xyp+Vgq9QMonW/0uGK +XlkqXKgmdnClpap057y0FHVrIiMLe8Z7KvfPKkxRH7mXvcbY9lpZ7q5cLDthnzcVp/zdstz7oe6U +8OAkUdfN9bITB4If3Hix5BKmP7dU13Z5l8RC/5iOkLjy/wf3ui9EOG66DXpJmYYrnlqRRAjesZvu +3HizKiVN8BUAH9EKvhTjF23Q9dL+XL80hfHp/oCn+wOe7g94uj/g6f6Ap/sDPlsx/rdF+HR/wNP9 +AU9Osaei8U9T4WkqPE2Ff/37Wh9fxHA85/1JH/tP5y9vF88Uts2ZwpMxem9F9naSXbluyksX++1S +qWn6OQ3ZnZ+rY13QBIMcfUaXATkMpFASGgGsJmmOPCtIjbJAjqTpk3o0yQlHdg2gpZelFgdnxZ/c +MfFKSRp7y1y2vGWizFTXaFVefHUX9fZr5vksQXz1/GsWOrv/Kx4FZLt4R/HTg4T1TxLany0W0KMB +Gugvkvb58WD/R4L5H4vbn8fmHxOj34TaWX5/ppy+IKZJSE9fXjNxx6bHplL+6MTMJv9UAqoMPAz+ +y2KCME6D+/J4lsamMlGl4vYSBZKND/g1YQavmc5ELUvLQ2G2xkcU7Y5Q+BOBPuY6/GKULCBzmce7 +S+EDoRUv5PAkF5aIg1+wJkUol8Xll2L6MuF5sb5FG+tbWEFQFTjsYrjTIznO1+T9TOOBik2Z6K2H +6VKJ6NEt+UCJaPQVTOZT2vomzZM0yo0LpaK2FWk5nLe7UIt2kfBor59VJisPtXN+xDFWmtypHY6Y +7igLxKKmIkVJfk6URpIp9sepUM2SoSR+OvboiyTMpUPRF2TMIyTMw2rg9HE9UO973m8S/8eSpdui +pZcSdU7bDP+xcOm6yetPQ9LONm1nU750cjn87XCxgCnHqPY0K/Uaox6t2sarWI19+DIUiVlNGrQa +bkTpd6KwgruNW12KXLHCK3WOUO57yc+6r0SvNpnGcV6GUBAoJWE8Sq7Rl6ZFKNMaQDxclHzXQcfF +h1BBG2T5WpdNugh0EMT5jTvlHjBw9dCGcT2UHxLQAPj6l2/f/PrdqzfvX7357tkzJ7f9H6Zffo9/ +ifyXX794//7luzcg0L/6f3588e7lDze7N9+9fvktyPIN4GZZblOqq/yMN6XcYkRPfkbo6o/YXbMF +fv9X+u//Db/+DwD+5Sbd/OLmX/77fPMtwX//G/ixxXnvYIL35jnANu8aYPrZ5xfwIewNve5XNBRg +OYF+QTnotRKb07zCjoPbYS20Lc48L7CCq1SsipwL9PsX+AJ4KdZ1zbdgaCamV0D8k15Jf20XIPKx +5+eYEPRH+BdWLGAJW+YKKkOt9AaFxXa7tDUMH78E088+v4BP30OfA05l6ChIUXqPwspyGxvYef7z +l2D62ecX8Ol7lCb9vOdYDbep1UUY1Oa5XQL5N2+x6VvoY6X4YVGQGwT+1AWIG4MNJn0Bdasm/ey9 +A3nOKhcuwfxsGLHpS4gamCU6pvcOxh9pw8cvwfx82OIbuLUZE4X5AdDPX4L5Edji0/eAoAuwLeAy +y3OF7Rpj6BEEG8vqhPRi9SDJApCCayC9+RdacPPNb7j6SIDlyYXkahpLIHSxiko3K+SwL9LxkxVX +883vd1zz+OYvfqb2uXJp2C4tpgtrdoMNQX9gqV8zF6bt5JWwDFWSEpehRS8KkQm9ZHOBer6dX/cP +jPywGjcwT/yl+cqkwi6/UO27EDH8cZG3sh05iwakI9DPtA6zVKTJpdmj3LoE85Jji6/TWkHZj7Q/ +1oWnFrTLhRjdMM6JAlsTNjKbOFRJA3fVQYS7pXxJmGKhq43MFZBbtRdk/x+uNPG3wtjP0wpDmIQt +JkwvwPyCvCTcrzr8tImC7OyDP4jaC2JQQfK552eYrjnsm/3AbxF+jC/J0Qvi+sLuwoSmBFbkWAst +5bWN2qmWwFyVq5L3xITiQDoK7h2M10U6l8QbmKd+i09p3WoVXtPwOEV1uQDyGC/pKPiW300nVjdB +PxVl87P01ZX/sn/34w9/UjzmbgjzT6f5Zgf/fv+X6Ud4Bi30sg5KGuizBLr5bb4BSZ2w8ucCXHgG +KuF6i5F8B34+gkO5xYsJCawYLsH6x99MqIPiRJ4XGvuKx8JwkoJFtpLwrwXMBDoQibsXQqwA/6Lz +2KFGwyIHIjg0mI5rTgiOt3OAzwBwzbdg+wkZEZY8wGq8rfNcHWnf4OcL0gMTkMDYcGnw4dZ8w79C +QzC0ACeQ3Rsuddvwz9hwzoAxJP9yWJ64M5eBSs9r6dFhGtrifgV4bwakyOwGavpAgI7ANyOlAM4F +Ojf0Stv+dex+b+tYpW2xY46rnQbH/07tdqAO0x+n303t5ic/vfn9P8FvNKlhFQxT+g== + + + YzOdoDcAvgnDlH/0hF9BfbpdV9BM1jAXLM9Lc36d14hiojnw8w043JaaVwJ7JA+ADcm1Zj5hLwUk +KGBPsBHkRJQvMLkIEhOoV9wsrUtiYIYd9WakDFqua8VpxuDI3UOUYKYzEM1wBuKVojcXX44DihyC +NkVpSGlJws98i85qBMNvM+xQCCw8KbltjIWA9RaPSzOwLbAWDoQAZhL6BBicw6JtY5KX5TnccMMF +922ClRkI58832BHnlQlYaKKuc1tugfeB267MsBlmb4YGypu0MgKc1DEJsaGUwjMCwEBtHbgDezAs +6FXYm2uIAozLosRi6izjRXBUhsWWpW0Is2BNc1EEYS3Kc1RuDUGuNsA5SFvYeKMiWBUIJr9SsCb5 +fLrFSJw0RZNBgJ0JMOcFuKBbgAmY52AIYPULF0HpqsIZnDelCcfhv4Qi36YwywxLITPHC1CgHas5 +a8cAjF3nkWxREbSUFZhSVmBTwnrHYNHZzG81cB/W27AUmUcgahkpTI6gkwMElny+wcwuQmtLwsOG +iqG8v+LEl8/L5MJ1sdrnMWNKp+yiny+NPw+vCiELsCHjGVjXhZfjTAteENS14pxHYGo8MhkWeVwF +uKZShddrKIYAZqQOwdJYii3zAi+J8roUBMWC6mfU3hK3EZjmLNRGWLCCd8F9QVbzvM4db1lnoYLK +7jEQM7+E4aUyMNxivF47XILgBXBK0rcFFq/gDdDRJPSG3FZBkXBMGEWOVYAlRl3lIRraMr6N0cIq +xW2qM42B0UQgyWwBgqotBLC0YzBsBkLuvKxFSGizDvCS1yAIltRHMml/UTroQIBs4LYw7VNuOhml +txWkeNQu5KIDAbt9KjrFQq3StmIZd+Y4CncBrlXXWHEIWlRBs0YmYIXertIUS3YKEDR3fVObtQcA +hi4LeJVZs94C4+IZAjSWBAjKiyEgEnnprCT+EAjqzqLzIPAgNJY5nduMoOEo6oDxJkLApEt3ha32 +xloKBRX+awhitA2nAJiBJdeqjDUg+VuZAmMBQOdgC0cGvCE3lV2LErUm3XTXRWfRMvNUZ6yNZxEA +u5wkkcjA0lZlNm5GiiADXdqWJ/cCazzZbhNITmFLMAWL8DUWmhkLboJBhR+GZQ+KQF+VaLskUA46 +WarBuuzWTQnBsRVdyZFFDABbXy8s++DVwP61OZoYQUBPsy7OhdUWBAZdLxivuflnaYt2sO40gheW +XEg2YVeBgUDW9YaSht8VUQvTFVfs8xmZ4XcfBPYdtJalGoI2R13zeIIGgfCxEEyRIZUHgbFWeRUY +A/J5QBaVAFC1+V3wawtbFmYYzDU6UcgIAFlpumBQ0DOQVHYerrkUAaZ52L8UQQmr9DanJhosvq5l +QUEGr7wMbRTRsBbDW01jWXRxIN5Fp6zs96BymRZt6hECF5g/qh4ZawvIHVU0MUNZ2tY5mXwQ1lYY +Up1ywZY3+iTiqpOulCRt8YSOsoY1ZUQQVBPDsLsgAMmZbFdLq+weAAa5peCSFYXqyij8SxRgs30m +oK9D8baaZDFGrB2PQFBzi057LIcsQJCGq+6rQXm7YmWh7AhjYE3KmiwDBjJ2XnX7Wupqn4dFrJyp +RT/ft/YlBaWqRttA+9g0lIK6boD5NwKEvV0RzAoMazVgyYagT3FxwzI41aV2dYxha1iiYyIDS9Ah +T7hZK9o8L3kzNNC2qmoAw5wEmGD7UWVqWQ1BWVROZNEtANjiIsACCxKBAQuA606FCRaMIOCZ+Tkp +ApbpgQy5omTxnhIwxqYqD+nxiiClJiwQNReBa1R1rkoXwnIbkvJ7RX2TEQA4Mw9gtQVeNwAEg0W6 +myOLCQTGoK+Kum4AjJlsQtjauAvB7RWiUiMwJ5VpYLvKKAA4Vd1s8soSGNuKGZdNG0TgoisBb6gy +BKSocHfR8S1AtIEZK/BIgCCWlQIQsIagxazzQPTREE2pRt9FzgIMLSXlrConAI6rLjxivQCjrpAi +Ch5ibbpCSlIFHMDwuyCgziAwOWFNdgsDu8oDO4QIHwSLcgEUsH4XMjqgFx7aJRow1qDAoBzIbsOU +kAyDU1TJQdsYA2tSI6SxSERY0c/XYGiLmYzaI9i0VGqtLPYCLmmdQNXUpYC6tioBNBcYmFsT6uci +0x33Ol3G1eQm0mQy1oiHjy1FEYgqDsCQVZNe0YhV6pdVpYZY/YQga++TKDeEwCabqUbo6lp0UGwO +Fli+RWeAiodi+nlm7VYRrEEFckW1+7mCIy8ONH1Z6Qu4rVXPBQbOsmJK10QRirKmryMGZrBoZGKI +jQFAijgx0lQWQ5BMwU3q9UIwbfMMrjKLKw/qOAzVSekVhYbiJT7Lqhfe4AZqU5tdDASsyXqrWxWC +0VanTpDARSCY8qlPzrkKUFeczCRGsJpNhJNbRAFsP6mpjBRLC4DJVlytqqKF5mzINq+KAC/P1JdV +Ynic2WTpMpIQRLqUUymITG2czVFkaw5hi87ENagRi59vuqUUlDUMDLbw0KEmQIppySCoQEdwUSfH +uvAaA2DN0ctuBpKHTTYqXXgRPQRNd0Vc2gJcko5i5DmLwKgtG1btVwSx2LbK+zrA1OUII1sy9yBQ +bX+3S/DnA4gd/bwqtICgZt1RaIgY2HDflzct9nk8rShaiNgJAExBgWsRqmCXEVcbIk3REGAOmZMy +zwUMFqjuHrzVRthRYtQZG9mVGnGXUN8AfYTRogtQd5Qm+xQAu25D2igDsxi7BUN9sjwiuh5TGQlA +1SnI5A7sqEKgmut+o0Rws+62qgiq6TBFjEUAYu6cTiLdpiKK6qh0oW9TsBaVJphRahSoforC3FGw +2KRnRwRinatqG2KEI3BRWvGkqSGos85ZdXpElO8mEEXuYBeqaq25qMYVgfBVlauYhNrCcTwWnnVp +AlRPBu6Dqo4jeI627LIigCmlFIgjAoBkKcs0iMoDEN9NdlWWFc8FnETvLOzVYGBY1SVWxVOPQFOn +aetUvMkMjSyba6w80KKhsiYXK91Q4+YcI0Dfu+nTQcMbsdp25Vbe6jx7WYwKAIaoalAxG/+87XMF +22wmfzIDY1PxKV5uBOZZowoZbTvF2zVP3RiQhqJGRRVXF77KHI60JSuCEJU5jeJ1TIHtV01MM6LA +FmTqn8ejs6PmGtEKUz1bVV8AdpfSagYIxo0XdSjUlRV1BMZkW5uMOQDXqIpPtt2mOduwid0NwJST +tpVQUETfd6pnkxH2xrL6dSpYm7qDmygCCDTtgASoIVjmtpmhEg8XudyMrKDCuvvlAJyb+rR1vJop +5LBExCkDwDqb7odWjX6+2CbS6qoEFNuFaW+UN0VVyE31jt1dR0JPJidATc0jOWPgvucasavp+Y6F +3W1A01BfRiQOAjRhik3wph0D1TNY2NVDCBLmWCWREmq3p9k5AxrOSAaubS46uVUnTZSSZdO7Ne5Y +6n7EPhMBGJBPTBgvD4Cl0ETPnIM6lgis2ytNGUWrQTYAs9aQFq+jiV0EQHVSoF2jxKKCMGvHWNRC +y5Z1YyDhyA1DMGvD1MGEEWqVO+x/ApC667ppC0A1QUR51o83c1AYX6O56As70BlIaZsbTQjBop8A +s5QCAAZd3wt64xCYTKcvHF9kBOjBNm43dg4mUdoJmMRpm7JFwdBUUI064UzXwRZWY1/UGVKVgcIM +EfKrcgAtz9m2MNZ8EVjUhk0c8EJgWNSTYYsLoebBs7HuTbFTrA4nXNNmv1RVRgGcwirzHZjNfa2m +Tg/Abi53nQnAZDsLY0vWtiEIMMi4Vo588bhaDAyb2l7ZxGAEYK6LbRxNkdZmrhgT0amydm/vei5Q +NzM4hQ3BsAXnrhs05jcC1WpOsgpg66pVsRZb3QBetakKTgDG2aTpwns1AtPidxlFkEtTvLKnptVE +SdHQ8ZKaYywFhhkBhlnMuE1iWgI0STjXLYRGSWHKGZkczXwWG7Sqe0MfxKjIs83OYv54zFsr5mVC +/YwQZCzLruqVGv45WAyusDOaga63uFIYAYDFqkHCQuSe5Yi+Nh0x8TNB22YyIleWERmDg4virRqa +QwRFjcsozqeMpkJSgVSDAkGnVA1RvQEAJSejqBas0GaMgCSd4BJXAmBFy6v3QBGomlrYQScIxKtT +2BxkIGl1InjUZkawaNqOi8nidUAB2yoA6x3Q+D1CyVkt/G76cRrlsQPJ3K3iEVMEfeXShvVcwBqe +7IsUO2u+oiKaPtK6qOu/e+7xdU2DsZJlLK8rFp4TmYZ4NQYk0WT8eNFYy4qO/8PDH8eUDlXDEoda +qOFsxm3qVFE8h3vA2gZ11eSZGJE5cT4sAxf1auVse2pRr3vGHAudmjbdEh4YMU9G7PQ3cyoWnRnZ +snG6Yy9j6Esp7ZsiEVDNuGXxj23nqKtLrKqcnSxIpsJk1NNUv42zIdApqJEibLcsujSj7ggPfRyP +gMmrJMKes8Wfih8BtCFUSKvSnXH/WhdHKwPDomSR65QRFAt6FgtcINbVBIk48BCBY+HSESy16a4o +0TIAljqbINHPg7KiBPQ5UEwJQsOVvbsI7KtbrCEA5qhKd7B9PWN3VMAt4k/K1UJC5VY+XjlvpE9M +/jg5O1ViaP4HQJUmXQJo6epGr7EzAEbnJGyGUnMsimaeIbDJrM4SEkRQUsGyFJ0Ta0dH/zXXWmGH +PwND0tlAo6Yvbk31jiLxW/didXZlrwd0n8zw8Rj1TSAQZSTUo4I0BZ3NPXKA4KSSHsXBc4F2LV2j +HxlTM7L0Sg15BNq7elAGwYvmNFbxayEwKVtU9KwWlEeZrokBGa1gtVPWvluC0pB07Ewmr7xPy8iz +XwxawgxVINpMireVovtCU70JWlOigXBRtovGiQaD3oN4bbdbzFUPYBC2uiRndiFlDFBaf4sRRumV +0jNVUABcJZWvsF3FwLL0DS8LTP0DxUUrEK0ZADm5jnXLRH3y9K640fIympbFgE3oKrNT0zTnAIBx +1UGX0BY1jDKQxX8+FO1XFZc8AFPUrUUtK0RqLt6kFkyZ3aTT4BwibaokUuSEgdmEQp/giMCmjPon +y+zUZ0kpXcrCsXjuaiidAmezFw3sQ+u5mHFbkszQ4lPsVHVDzJg4xnue0rtwhtbKnkTdXrBtVU95 +EKcQniOwDL3I6YgITNEyDmyKI95VXQ+tBEWAQyyjKxIbgNVEl9lsJZhPyI1YcCoOeVsZqH61Ycp0 +V3lhNZSBJatAKHlOAtRgGBAQ1GzHtjZk5JOUl2Vd5U02vYJZdGq1djcJITBJJaknBdTfqsOraxxa +UoRgNcNCEaxx0X1nse6W7uWVREAkK5njwSK62LakjZsA2y7qZ1b/Ob7KvPoEZATROVM1oQWAPT26 +st2JsEXdYq3PAgDPpr3FRfndYjF3Clve+KasljOKIP18WuzzjYOXxWcyanisoFZveoNFKwCs6T+F +o8sCTLqJSdoJwVTM9lgeol10oyWn/HMB56KSmk4SKFhTYwt7uASFxJCZ/8lia5Jozw== + + + b0qWlovbkmLE3GXdQNSuQoxN7VBWUQpaRar5BcvZhI8rT3QHx9eH5rQWefeq2x/5LI2koNqgpugj +ReL4KpyLKEibGTpr630K5kwwsY0vq+ak4fh7SRy+5BWg+eYIVodOsfzUInma4wpIbq301JSSuePD +rlyyuedlt2dgqcrUYt4zBC995+HIVEGly3i4KtK16PgF05JL5vMpo4zPLniSxKOFfZVlgdEdzZaj +turyLuL6gbag55sDtQMtwNADIkXsNgaHNRu7NP4jajbC1iYNnRTCXFlLApf8opJNJe5JbSXbLi3n +JrQHqgj21C9E0FMYxP2HwKQpDE4KZeYcg+Os49XzxDRbpRSnQVFSAiPAyWPR+1VEVuFUTdkOZx2Z +ls0utBSpgsPUlDBJ/MUqBhYdtIkMen1WxvbdrLptmiwgBjqffZW9pLpdp3tAAayRyMLJZwwMi21x +66IIukssm0sMEaw6DzUkhW0lR6vbqwhs5spBkaQIejQ3S9IKUru2rSivzgtOQtsoyOq7Wop+Xr2N +PSUAgYuG+SnUy59fOYq9eqdHqZY22pNRsaUthGBZEQU9iNnmoWx83XKwFMTSLD9HYoX8eXTq6SSI +EuGoM6/VQakCYCqaKdH90HV28WhtmKOugqV/uibNd5l1K63o+rN8ZHE44OeLLkO1wbGlLZdounn1 +GiQJKD73tTidKi4s4AAIVFs+Mi9vAJZmsWj13GHTWjVN245tYGPLBJpXxdpTlzVAjcCi/SI/g6Lt +iVOzyGgArlmTXpuoZNgyafb32lT3qZi/rTm+RQIUFSMsevaGktIZqCFnSR9nBMHOOgm1zwXcM8/o +qDMCI6ctclu2KQGWkqnQJg0RHPUcGfmTngu4z0NynBjYUpLlBBAC12Q59JLNBEAYXe1a0klbMQFQ +WRYtqQ7AS9aTSVk8mwDMdhJMJCqSu+ihjVUPmBFay53SdNwanFNNU2wBCHq8IpiXjkAlNW79NW7Y +2M9iIKmSlZD4tIoi0PwY3AxZIiIFEhXCbG9hF2a86CE7sop1fDXhMqmrBgmQDSixc1mAZbGGrfXP +22kSCl7I7MhVCAiYq8ZAjbsn5z+qePxSs9tJZZXJuGgKOXk/dIbqOUU7jUfgrGD3sn5mTI+j4GKY +dbgdBXgGSl+meRUA1PNliY9LiEyRIbCTStBwmUtyU4uBMIJCU5HkfpQRi57F6Bmr2NbOCJJNK8Ci +65ayOEVISVwNWy6xy8QQdbhlB0Y5l+wYQOqCMuu5wWAeM5K/KbihfS7gIMm8qctED9TZDXtCk3SA +5HWmZptwMklXVsvNH4C0RTKwqzwYGdOlSKb2c90DJZc1dvMTN1Y9u6F+VAAuJjgoNKeKjONDCqa6 +ivofWcAyMDflLWUxqjaYmx6X0gQftD4WQ9C6rV3LqrRqBAotzazyL2ABp+dmqupqNLyBZwsPjyrP +PYM7ca634u0rT2NrAOzclV0IPQuyC8tJGHVYqJs8WRgO3SASq4GOqYY1m84RWW8zF49kAkXMtGzm +iqHDyQSWJBJ0fVUWCFETMNClJ6mBwkP1qAV7mSaGoE9w1uNpFJ55xk7FrHKyH1sg12hUvJJnC0BY +7TKPNKsYHbZL0X5Z4hO6fMXrE811he5rOYeGY1/VX0y5FILVgpbZFI/IduYzjsukXJSJzQJ+4v6O +nNhqwUHRXSNr6uxVDJZxEjmE+owjpJI2FHkCP6O4a5MAQiRrR4Ops2gukZ0bGuVVUzRajiUGhNcU +lQlB0YLQVbTmO8OYclY+Uuj1GUWf+6RRTQ/j1LMukWSBEQBr5hJGQHkjRqC4IKOGIjEqX4rwq4t1 +SiIIAo5N0muq6XlyBvuZJCYE6SvlIGi+gp6riRy3fC5g6rr0V2L4CFwFr9oFSSLsDLSYE+ZMiFIX +2Wv4jJI2+ropsnAxk0MOqcUe4EhyoJU/L5ZkSubGDT2NAYZODsFKvqqmstDKZLQSUQBgDUrAIg5y +ABY56Ajbf52jIVhmRaAhQkq8aVGnlyQIBTMMIidBMIJgtgl6AlmCu8SfEcGcbHapnKMcI531FAR4 +ECtmK+soUtYbI5jtUHowaQ/AvrHo7KCsOF13wVLNqoVuo+kHUfI3hIeca4cKo64D0xpiPyQidQOe +CzjJyetgCQAxmr84cnkEBqZUBEHPYoxmykY7gBh7aQM6Pi0wGg1+vxmHmESddHnMctIDc7irziKK +YDyjdG0qaCRzSOUsgpsujkUTiBdL64u8uwuw1qqr1vja89Ajp0Y9o+x29eD2uYlJ95LWENkQZQQz +yB1dMxT5YyDoJwLUkDACbQizpb8h3qx46yKnN5qdYYqc58nAEnXDtxyIgEfZVoOyaxCBqU9jOQDU +LHQLQNPnwmoHTmM/q1L5uAOzSxJs8FxNp8r2qpDcsk92LEgPImPOGu80eFSp6CTKVsQgJDsPj+uf +N1YEhqA9ED3XHYGKzkkR0NZs2lY2DwDqEUHQQmQaheTGoJ9txfNWEoyI/XRSsszf2I/roJqigpci +3YwgWlZX1PAmnuzKugNrtneIVqQk3toZe4RKJEHUBT5V04MGkaNuz+jUnVpA0XR9AGoivVv1eFKz +6uqgNPRnfOZXAuOivD2j89EaAQzuJBYePJdzUACWSAAWGpAcwmARvLkfZQ58yIMQ4OBLTYBoRypJ +A1QehpC0qoIe7o18wloRhNlEHNsltD3aNExWlSFIim90mjMt4CbleCQPFYs9NJ1aahIgUDLKgjt4 +gXUsKm/2wWKz82zZIUFT9rFCh56iCj1RHMGq4QY9YEBAcfqaEkUIVhOmundRjRAx5QM7I54rOLHB +GDj+oeAw6zhIjQ4EzlnprZz0iECNHoSuUGNJFEpxI7CoMVgWZg1J92XWp6k0juRuhX7MYm6zRcUi +m6pcW0cdU0FdsViHh2KUwlvZVLDmj7oIomZuYHUgmHjCnKrVgXqtJZERjCBaxNQs9AtVh/6RyhFh +naLgnAchSJGkxKoKt5+LOiVa0hPoJH+kZdRCED1RBsFlUTO/WKWksAYxEHVFn1PAlZLQnGzFMqNR +iN4rONuJEclQJ/+vJScLaQjMmhgz9yBrZWwMVrd099/2RC4EFk0mnC1Fo/Tz6sUcUYXSUTRrvKmV +vOmBdq2YGYGUUSljAVcNxxgRxeVHBEkwxzhA0JyDOFvE/gzvc3lhcqwgz+S9gKul89asIZmaNXWI +TjA9k0BRKArUnaMk0+uKncGimI6GrzTP7ZyAg1GmRlnRaqAMVi3GsiDRD2DpvLHyTlkSV5NdOblI +fbkcmNIwgwYxk9V4KXTq7eL7lTDYVFZN6KURuFfwooTVWXMMQtKIqQX3FstipIipWvw9kmk5GQsf +9Vg5tydpisLm9ULXkK6SmSiEgZUjsNks/jYbUJRmTKLJPSNZdQj0DliyStYMpcaHKphYNfn7KX9M +kFLX94YqmXZ0dlA9zCTj7gWcmx2lQIVDjwn20grkIXh+GYlgD7MV9sqsQ90LWEV7P8eJdQgsB02S +NxG2XDgKO7MWJateVEp/aFXDeecEyBgt0Z2rI8X8XsHNakfAGEs5B/HzrOzv1n6fI3lONQG/rBIg +gm/K51cDFOmPQQQqXBcx6WYuDvx8AEM32a3yXD9/DnEffUP0UAHAivoLlm5FmYh1msNKybg4kngd +DP7S5oVuLFlg4lB518j3lXAFQNDrCv4dXin51fei17UlEBjLIJFOs8ohr6UFG3MKU6P4x0KQZI9/ +I0rGmthunXWtoI4AiquVFQmiImjsDXTwklWlCRbqEx+mFsqLtQk3ZFehMnVJ/UVSh4WUFBF5C8tf +pWueWbbMlvk948tQdwFLsJePoihQQ6Ack/mG+LLg8TfiC2Zsrlrmh2sSLWu0QPgS5dDTsqI2aaVk +MIDRzgZ9yVIrD1trGHFBPQR3MMSLmubNxQH7RhYUngrDNYkUJ0zPuBdwXFtw4OcbcGQrRmjGCYW3 +fmJtRtWb17w2B2RWAlvw6jLfFhW2GGlKd6weKBSoFgcvXDeEeXDgimlSxq8pYSCP8hlhBNQhgs0z +jW0dcwzrBY5JAUp8XViF8eRDonXcsCYZqvrLSqFanj3oYGAgJuFKDTksIViIhpnl6zeyqkBFJU7I +MSAZeqlbEewgGFaOWi24ZentC7q0qnomgxW7QYdmEZVcz59goS4ZoGr7KIUi8qrMiQsTNmN0B3d9 +nNbADV5DMMNzTNxdYimXSayUZYasIbcez4YoC4vmb1/bEbcwnOog6BTIHilsSKOjNgEXxaK26N3i +Bb9guLAxmBL7pVhlWGUJgcgpNxeHDJfFj9Nys/texm6OVSYhmYT3GzCGYFq50VKKRAyOeK/Jl6hc +hgGZc0mKtA1t8XB2zANWDxQKGEEHL+zwHLCuqHWkDQUKVJkm1Pa2vl+G9QIPkEd/9/Xf7969P776 +5v2rt29evPvrzc8A9JP/9tObv//q/btXb767+clXf3rx/cv965dUb/pPv/3r9y9/evN/YKP9g41+ +fuQm/yf8w330+4lq0qI3FQsQgaZF5dFBQaVytQtFlV3B8aAFvRPvU0g7KNeVJQtZs/cbsGWvzLMJ +i2qeJWBeKCrkCajDx8kjQ1uqD1JGpB0m79fRUzDOWxEJHenMh/VGAgTICDqx1tb3yrBe4ACOHp3O +LVThF36ZqZA8GDWBiqAvMYPyjnzFHZ/1gxLovsnEhdKNuZxNh6hJq7zfgKWMCRPMuzhyjE7jcedg +t6oOqNydE4tB1xYzuMK6wdqBQgEj6ODFckod1pnPJ4wUCFDZq9RaW98vw3qBB8LegNc2YW1lUGP1 +Sgm+8gbM3UhcjXrXUKQkdKyuSnfTGXdB8RXMVHXlfgPGukvmOOJ6sTj1qu0wreTYYd+I3wpUvnVs +KSURR5QdKK9X1io4cAm2EenMruTx/QJU1iqp1tZ3yrBeYICwdsYK1ni9wIp3BdF9CTnSNSNgflRS +X6Nd6YCXIyAkO/WVfVRV5k0W48lDJUuS6QUbV1e1FlWV9dWBytxQ5rhpi8s6LBusHcgEdLHC0MBB +gRHpzKe0RwIEqMxVYq2t75ZhPecA8xbMzrZUui5jDnQVBmjdLdI1L6DYk0WAodMl0WUJKfMlX2gj +dNaCaSWIIx5avd+Ak0VysaBwIVWhST0U7lopvGMKkLuGXk6d99YW11yIG6wdKBTo4Cg48CmbEeuC +BxK3FAhQmavUWlvfL8N6gQfCXUwcQgkbG6lbaF01zOugOyki3U2W/CVkheWucRbvRmSsAZPk7jdg +KY3NtHK5UZp0kmiAOqdYLAJUzqYal03bKEX8BqwdKBTYtBdwYDfkiHXhAmYjBQJUziq11tb3y7Be +4IFwdqGzfyRbYqUK9qDzrHW45Yenqbv2o9rVKbKlltoYNV4hzIbQANbKT+ioT6uYeVGK481YY0ot +EwIqe8Ve920xQUYtHsPqgUSBIlBwuI0WalCkSw+gdAIEqNxVYl3b3q2O9IwDzNy8rg== + + + lS5gW/ISSDrMoJ2OvA0iCyq6DeiSJbtCR+RS1rc1Lc3vwdEy52dUSRYR+1rBZpYV14FqgJS15k1b +jPPO6wZrBwoFNjgG1uwOhzVooNkRwDBlrdLaW/q+GsozBiBrF9ZwcwqsK5xf99MZrFcT9bu12DFj +DC5J8de2GH8VirHzWelbxfcSb+UUC5ZlLx5m5p3YGL4l3+kwoOxAfrt+vEM1UOFw9nnX384w5a3S +6Wdo76ah3Pb9C82T3ePMk9+Jd29R7x78+HYqcq3Ij1fztg0+xGcU0wVFXWQPmY73G3Dp4Vs8a8F6 +7GoZsFaW0YDEb8sC8G2xbl4sG6wOmJxN68CB0y9HrHjhSN1SIECmoFPr2vZ+OaxnPCBJ9eUGI1Ul +TEya5CPeb8CBk/2pgiNb+5hN26y45RxXB9SOcWL/0BY9l6l5lB0i7+ZPd3DhPNIRZb1FP8bm9QLU +kVVSe1vXo471vPfXMhY5n2WWzlFY8n4DDui70vKagEM2Mq34Ap2DlzYHVN6WNS+btkkOyw9YO1Ao +UPYquFdcc1irnZh1FAiQEXRqe1vXL1fH7YwHVzIWKS8nm4/GopAOjEpEUO4myoNCjoGOplNnSdED +lbvoTtu0xdhmyxusHSgUKHcV3Ct3OqzFyj05CgSo3FVqXdveL4f1jAfXsheRCHKxruxEkbnroHKM +hIHd51xDVu5yYVUDKndb1LlrbbMcUBiwdiAToJ9XaK9M7pAWu0nJESBAZa4S69r2bjmsWw5cyV7k +LLFFNWGsTXi/AQfOEXkmhX/VMGtVlmqRC6UMyF2jElLLpi2eFY3LBmsHCgXKXAUnK7rosGZLcnIU +CJARdGpd294vh/WMB1ewF+n9dZUhq1FTIRw4cFouA+OiQNo+uV/itFegcnYR2eja4mlUBRrWDhQK +lLMKxksYZq1XrVizHX9xFAhQOavUura9Xw7rGQ+uZi+ivKIcNnJPYQL//QYcOJmF+9GizrskJ0ax +QnfQKU5AZW9c5vO2c67LGVYFCgU28wUMu4wcEXZY8dBO2FIgQEWg1Lq2vV8O6xkPrmUx4v1/TZ04 +VGTk/gysV2ogMFU1P3rfYKOsDqh9S1GHx7XtUU2HtQOJAhseA1v2ZceauhLSKUheYenUDm17vxzW +DQ+uazTiTtGajB6dALg/A7sa84v5JnBshRVFDe2q7gq6uXFeti1rCOEMZQfS6/XzHaxnKxzSYf7r ++wVo8sn8JdbWd8qwnjHgG84D+TeIbX3IdGRD5l/FeozZIhveenTgwvkFz7hYNJ2X8lEuLDvcog+T +EdOxNixlKfm2SZz5A1YH9NajAweLOzuscnZrpECAbH52al3b3q/gK4lveCCK4hcZjnQLkSZM4AZ4 +vwFjMkLR0tx8EgKZ5cpMdw4SUBnLFaN8Wyxtu/K+2LE6oFDACDo4aFqdQ7rYERVHgACVr0qsa9u7 +ZUjPOXA94xEVqCJ+fiqIcr8BZ/L8MLmNKgUhv+zoByhYkvMhQO5awzKTaWyLJ2pKaANSB5P369go +2PKfPdLFEv4cAQJU3iqxrm3vlcN6xoFrmY5YfT4FNdyK2uUdipeSJF5NlVNfadpZDe1VzqcZUHnL +t/b5triek/JWsTogE2ACJSlv9WCTQwoG0yqXTnQCBMgEdGJd294th3XLgavZjbFozgneapqXzlwF +5366qPJBVV7TqzGXzwkaUJnL54GHtk1OtgxYO1AoUAQKDr5Iu2INdibaUSBA5a5S69r2fjmsZzy4 +lumINxxI8D5ydu/9Box3BbLzBy8oiGoyaLId3S4wALlvK267cdOWLmdZN1g7UCiwuT8rc1rTdynS +wJGrkYDgAmqOWNe2d6sjPePANQxHlErzrCEvPDV0vwEnf5kDX5BKk04ymfF6hhYWB1S+8qnAoS1W +WlS+GtYOFAoUQQdryWaHFeMtZd1QIEBlrFLr2vruGtYzHlzNcMSl04NW86ybWQcnu2oWL9CggyGc +Tzore2tVPzEBlTt8Y8jQFjaeouw1rB0oFCiCDtbkToeVjjelDQUCVPYqtUPb3l3DesaDaxmOdOVI +kCWRbe56qCkxVRMzkbKYVQzz9asG1K5VycIY2nLNpw3WDsxrZ02H6i0NHSfW5jCgvl+A+nmldWjb +e7VegGWbt1cwF5Hc3NQcLaYpeLCeosFe0CGlzaDnNPuZYLMmzOmsLV8ft8HageOqNrBWbRqw1hbO +CKits7bT2lv2TjmUGwawufgxY+5fw46jg/o6H7od58C99DsW9l+LmGxaLSzRrWLNAYkZGauC1ja2 +zejmV13OFZRXoLfjHLhrWA5rTwZxFPhkEEeta9v75Y65n/HgCnYcIF2runKwkND9BupurVhxu5DA +j92agSek1+iAytc5pDa2zeg/XcKI1QGZAGWrQoNe1+ZwWkazf78AmaudVte298qQnvX/akYcXnux +6HBFrKt1vwH3+0axPkZuMo+1bhDd2JBWB2TWzHKFsW+bF9uhOlYHFAp0bPpuRkW8RqwL1zgYKRCg +MlepdW17vzrWcx5cy4zDu0JyUbfi3Iy5CsXUzii8DSnpcYKFvZ2JahxFB1TeqnLV2+JqDhp9E6QO +xq83aSLQaHWAHM5gd+G59wtQOau0ura9Ux3rWf+vZsThzSpNx4yKvd5vwJkLcjC9MWpETu9qhL5R +OZcOVN4uKW/aApBO3g5YHVAoUAQKjnYzi8Ma7CoBR4EAlbtKrWvb+9WxnvPgWkYcVr2JWQ1UVYYH +KJWCZXLTopF6KXZLV77k2GHcsSZnYl1Lmnbq9VOUA9AUYQfFg/xWdkhxBr+H6euD38M6pa5t75PD +uu3+NQw4EvY6hHQu8n4D7ifHqWqR5uBqzjF0C1TC6oDKVjqWsm1LdxCNWDtQKFAEHayXgjiswYqD +OwoEqIxVal1b313DesaDqxlwuGwWHciKV4jdb8DJVFYkmAoHIVBPCQKwhTU4oHInlLJs2jbTWR3W +Niiy6qodwH7tC9bQN6dOQRg3MqV2aNu7a1jPeHAtAw5poLo1nPYf+uR14LnqNVJcdJGMnWgsX4M6 +RQiofWtVw/zWtuG9XHGDdQCadTuAtcjlgHXtN2F1ClaLbA3Uura9Xw7rhgdXs+KwdFnTgYPR6pO3 +g6mkqQCLRej6yFfRROO4l5R1Pm/Ll1BvsHYgUWAIDCyF6Aekay1n70eYfrqT6lpanzrGTff//Wy4 +DCJqXZOzX+43YLkW7xlXDpT+VatNg7ULLUDXzwZiTcTc6qZtdEeuFasDehvOgaVc2oh14RKAIwUC +5A20U9vbun51rOc8uIINh9firIv4UJLVN3HgbLF/vGUl9Fy0ppeJcI0MAzJfFikTNbTF47dzGrE6 +oFCgI6NgqzrkkIbO7E5A6AfkPbHBs1C7ZUjPOXA1My73MGHi03n3G3B2lTFjK2I9JC2/gVVa59UB +lbd8pH9oG+xAtCF1sOQODTpw7PcIdKTBqo05AgRovG3btq5XHes5B65lxGF5z9LUiMnGWQVmvkiY +qU3FIsB2XQ6MauswZSxXu/ctsaxw2KB0QHq5slWBXbdyKDEnW8rF9LcLUNmqhPa2rksd67bzVzPg +8DInO5hDZffuN+DMpU6fyeVGTUPKer8CSvFlcUDlLBeqGtpSncY2YnVAoUARKNiqgDqkWMvFitQq +AQJU3iqxva3rliE958C1zDe85cqSzUgi3Z+BJYiemzOYo+0fMP0cjPmChxc1rq8tF7nY2mEcYF1K +OnC0ou4OZ+A7J8fXC9D42koY27oudazn3b+G/UbVgy3bd517LaJ+Ji/L3R14n1eJi863Wdm61CU5 +oPKVivOObResHBJHrA4oFChnO1iLlzmsvWSroyD0gg+e2t526K5iPefB1ey33L14ke9Vvd+A0TfX +lAy1bYvd8zWvy9JhytpkOZO9JRVTHhA6oLxcP9/BdHnqiLRX63TvF6ByVg1rbTn0U3Ged/5ahhuO +LZWwJMyzHqAcwdVqXdFxPR7dtNh1cU01+35Gr8wuyVTbokRMKuUU6wicNSNxAKuDeMBacgtnFBDQ +eGvUura9X+Z2PuPB1Qw3rBkW9UA+hXfvz8BaNROBtge4ke8hbQJq51rUJEjftrR6hrUDe9x5ANtt +vx6rycr+/tZFbafU2vUeOXyb3j/Gblv+9RIpC/panNlyPwCz1vyjOwlWcbbzTmZ3pAiI+FD1bjbX +boNpNJIMguFRvhLQ4cBK+cvmZQzjT3aqrKXR3hFu+3itQ3aAt1iqA13afL8BZ0sZQ1LXLIpuSk2v +lSgteiB3C2/e0yCGtY1cKnHE2oFCgY6CgntA32ENdgmto0CAxlihtrd1/epYz3lwNQut4FrRgYt2 +pMaB8cYjuSMFi3BELVmR7NqPslh5nKTeW7ziZFar2NpKhdQRawcKBcpeBUe74sphDXohqSOAYcpc +pdVauk51lOcMuJaBhjeEWH23oOesHTTjCT+9YUR9V/0SdLw7JTmQ8jXNGvOxlngEv4YNzg5MbjV3 +aBxumZnVHKN7nv3rBWRsXS2XV1q6LnWcZ72/molWcXarEkpi+f4M3CSQU2e5BJwXdNHLpFKJzQGV +tVS8YmwbbDt3WD2QKFAEfetPcozMYQ1WKNdRIEDlrlLr2vZ+OaxnPLiWkVZJOqv5h4nf92dgo6GH +ze0SogXrVgQHFNZsmgUue+rReRC92CZ8U69KFhtZJ/Cs91f1twrQ+CkUura9Jw7hWa+vYZvhbXBB +C9nMRW2zAez2Lr5fmyaaXIuI/VrUirMak7RRNw0UWduAd4dssXogUaBMVXBX2RzWfpWEo0CAylml +1rXt/XJYz3hwNdsMN9AaNaN1VdXAgVO/pw0IlmpHyXI88MYplGEdqOyFQT9vu7acN1g7UChQBB3s +r8ISrFhdMIUNBQI09paztr67hvWMB9cy0UgYqauYUg7uN+DUN3asrViNOVGnDtW16kBlDmzs7axt +blpuyKkWCowuF2IAi/nskEbOaRwJEKAyV4l1bX1vFekZB657pm4YZUzJvD+DNrnqhm5hM+9VirqL +dO8CAZU/S1vrWdten8WweuAaO387lCrjjkiHKd3dCwQ0BptPzU3U3i3DuuXAF5+pe2RBlg+Zgr/7 +N6vPAsyDFbBuT9h5sFVSmWuzmKfVXJkrZqmymubqs8yVbtZdN22jq+JhWKOr4mHmogdbJRWP1Wqu +eApcfRZPbW/r+tWxnvPgSqbjXDHiYtEfrc/iwVxMBTu2Sm6T1VzBjmkE3tVnwY7lMLZcFyklbQgd +xFVn8WCro9IRWr0V/2pXm8WT6dr23jicZz2/WiHPinfiqDVstVk82KqozJUur5f8Ujm+jJ2Db74I +i/I1yp7Z266zXFPpsTqgq83iwVZFxWO1eiueAlebxVPr2vZ+OaxnPLhWIU8Y4hzseJnWZvFgq6KC +9JZZy/pKvRXsG9/EOtRmQT6EOrZcfZxIcTqgq8ziwVZDpeO0Wiv+7a4ui6fUte19cg== + + + OM/6f7U6nhWrfmuejNZl8VCroILAtq6aAM21VgAnHvdvDqic1RzK3nadtda6w+qAvS6Lh1oFFY/U +aq14AlxdFk+sa9u75bBuOXCtOp4V7+BYVY9QJ5IHWwUVnCJ8lZCrtYJd0wqjri4LsmEOm5bN1dsz +nN5pZlVZPNjqp3ScVmfFv93VZPGUura9Tw7nWf+vUcMT3z+r4W81WTzYqqcgsFpwUuqsYL80o9rV +ZEGwWieuLQjKrBX0DGsHuposHmzVUzxWM/M9Bc4b4Kl1bXu/HNYzHlzLeqRdoBtpWpPFg60iBM2Q +pLNO6qwgUA8Yu5osCK5107K5QsiGs/miyVqRxYOtdkrHaTVW/NtdPRZPqWtbne1qOM/6fyXLkUiz +krZWj2UES+UUBIIc96VXBLg2X6RF+1YsXd21LWtrZ1g70OqxjGCpnOKxpq6kdAqSV1I6tUPb3i+H +dcODq9qONE1WrbFi9VhGsBRPQVrk5oOmVVZoRi0avdB6LNS/sG3Xy646hB1o1VhGsNRN6SiH1aTv +drVYPJnjKln7dR8lnwH/l6jFMmOYwpZwtxQd2KqmzGW1yt5WXwVWhk1IV4tlxhu+5pQ3baPcjzxg +7UBvKTqwVU3xWK2+iqfA1WLx1Lq2zUlhw3rGgy/P/0Skcv9Hc7VYPNiqpiCp/YYHqa+C3eoctFos +M13KpvU1rS3eTK2GvWHtQFeLxYO1bIpHavVVPAGuFosn1rXt3epIzzhwNWOxYA6qehesFosHa9kU +JHeRs8xWX2WmW/eW4IDctYyradsWDIZ+lYQg7TBXi8WD+12UDqnVV/EEuFosnljXtvfKYT3jwLVM +xdL8VStywtpDrWoKkjvn6MuucNf4kuihFguyQeu8ubawnqPGcAxrB/ZaLB5qp289Uquv4glwtVg8 +sa5t75bDuuXA1WxFoKFa9pzVYvFgq5oy4/WSqYy1WLBvLeu5SavFgnwAfSlt2ma5NX7A2oGuFosH +W9UUj9Xqq3gKXC0WT61r2/vlsJ7x4FrmImBOctuHq8XiwVY1Beld5ayn1VdB4FyXbS0W7LIaC65t +xju3wwZrB7paLB6sZVM8Uquv4glwtVg8sa5t71ZHesaBaxiMKJWqlRvUWiwebFVTkNQqt3RZfRUE +Luvqi64oX0tS74+1LWA0WxBTsXagq8UygqVqisdq9VU8Ba4Wi6fWtfXdNaxnPLiawYija7VfrRaL +B/cbAwvehzabA9amLQxhcEDlTpPa965tYa/5iLUDXS2WERyDtVWskS3KkQIBKnuV2qFt765hPePB +tYxGpGE2Q8Pmroe2HFQm5BCtNLYSlkI/kNAXZFw0UN5bhqiT0aHswGzz1kPDknWKKk4thODfzjD9 +uNLpW/YOOZRj36+VCErEBrvfopiW4MFyUJQ6YWai3qyIfYitOKDNmKx5nK5tzXZit2PtwHFFG1iK +poxYubrKSIDWYRlp7S17pxzKDQP+3c7wzXgWKOnJim7DObBVTJkz7DBNTQ2prQJLCu/g9UBiRo52 +ntG1xQib6nGGtQO9DefAXbtyWPtFO44CV4fFU+va9n45rGc8uIINhyfY5Iq8XofFQ61iClE6a5BH +aqtgr7IcIHd1WOaMeo/G5qxtsCtBHdYO7HVYPNTWv8PZb5Z073d1WDytrm3vVUe67f/VDLiMd6dH +3Zu0DosHW8WUOWOBylmUW0lyx66VaDfLaR0WZEOPcFvbaLuTwxr9pql1WDzYKqZ4rFZbxVPg6rB4 +al3b3i+H9YwH1zLhAHMNWlFC67B4qJZMQWo1S9Vqq2DPatTIj9VhQS6oYuXaRlcdXZF2WK/D4qFW +McXjtNoq/v2uDoun1bXtnXJYt/2/mgEHmNOqKoLVYfFgq5iC9NakWq/UVsG+6Q1wrg4L8qFFHRtr +C69oelTKsHagq8PiwVYxxWO12iqeAleHxVPr2vZ+OaxnPLiWAQeYtdJOr8MyQqVoCpJbStDbN2bl +bUtqe2gdFoRSaGJomSyLxKH0QFOCHdQqpnicwe9h+vrg97BOqWvb++Swbrt/DeONhL1mAlodFg+2 +iilIaq7qMdBbGjNWptXKQVaHhfaWoD4La4u/2l2IirUDXR2WESznbz1Wq63iKXB1WDy1rq3vrmE9 +48HVjDdcNkWTBq0OywiGXq7Sj16MX9KGEbhIBbrUU4xplS4aC7W22emshjUPiqy6aQewWLYOaTT3 +oiMgOlekI3Zo27ulSM84cC3TDQc4qPSxKiweDKxZqgpbvXYK/aExCDBkPYMRNBGRejxbmr22zVjy +b91g7UBXhWUE09mOEWvs21OnII5bmVI7tO3ddVg3PLiaDYe0rZria1VYRrDUS0GgFk+MfXcoVlA8 +jjtJbO28bS9n5bB2oFVhGcFcM2VEutqY9/drFZaR1N6y96lj3HT/38+CSwXPfPpsyfsN2OqlgMIN +i1irY0plFRBuLjRnVVjmFEwZdW1B6QeLdYO1A70F58BWL8VjtcoqngJXhcVT69r2fjmsZzy4ggWX +ihXCd1VYPNjqpSCpNc+WTcZuBuhWys0DuVsRb1fftsWLvLU0mWHtQFeFxYO1YIpHGjpbOgGuCosn +NngWarc60jMOXM2ISz1A6KqweLAWTEFyS7/bgyurYNdyatEBlbdp0TvsrS0e19HQniLtMFeFxYOt +XopHapVVPAGuCosn1rXtvXJYzzhwLRMOMKdFb+xV89gBrWQKUStBR62tgh0rUUuXmpGRol3i21vi +5dMa3TSUHWhVWDywa1YOpVVW8W93VVg8oa5t75LDuun81cy3hKm4eoOFVWHxYKuXguTmrFEfqayC +XetXCVoVFmSDXhPv2tLt0HWDtQNdFRYP1oIpHqlVVvEEuCosnljXtnerIz3jwLWMN8A891setArL +CJbwecrOXI62f6x2n1q07QOIzHEdW+Lhj1xHjB7mpGQHW70Uj9Mqq/jXuyosnlLXtnfJYT3r/jWs +N9w+5eIKV4XFg61eCtG6aH1oqayC/Wrz6sutKF/7cV9rGy3j12HtQFeFZQRLvRSP1SqreApcFRZP +rWvru2tYz3hwNestdR+eq8IygqukPic8Wq53ihU+mkidaxovKHqMkSRgqvmsLSgw6warB1opFg9G +V0BVBMVyMNVqcBQkZ2E4al3b3i+H9YwH17LfcIiTWpZWjMWDgYpVha0q4+gLjUpur8tHQOXN2mzT +1baYlWrmmyDtMFeKZQSDpmPrv9nt42tdNgQIUHnbLQfXtnfWsJ5x4GrWGxKRtKy1lWIZwXJWloBL +j5VxJDhlF9G2UiwETnr2zred1fpyWDvQSrGMYKkkMGJt5ez9rcvbTqm16z1y+Da9//ctxTLH7m7x +FpwDaxGVOaLWOZRZmWO009BWjmWOqNgPZVtgYliCakfXYd5yc2ArpuJRas0V/+5encUT2Vt6l5Kh +POv4tY7ZRbz8Nmj+olZo8WCrpYLkpqZ5UVJ1hXomp/ddhRZkgp7Jd23xpL9qe4a1A12FFg+2Wioe +q1Vd8RS4Ci2eWte298thPePB1ay3mJ232Sq0eLDVUiGCLRdNjlFj51LRAjhWoQUZkapazNZ2QQ1z +2WDtQFehxYOtnIrHqnVXPAG9QountbfMzt1uKM8YcC3jLeZNiZT7DdSqqSC16teyuivYsS41rEYL +8qBUPTNobZfzui8emNyaXs7rqXikVnnFE+CqtHhiXdt8XvnlnANXM+EipirrKXSr0jKCpZ4K0dtL +8EtwMHabwFVpQT6sVSucWtvg1BLD6oFWpcWDrZ6Kx2qVVzwFrkqLp9a17f1yWM94cC0jDjCvdljK +qrSMYKOhB9X1rFUkH7Uv3cI9i27bsra4OlWNM251kJVq8WCrrOJxWg0W/35Xr8XT6tr2PjmsZ/2/ +hhUHWEHH2NZrGcFuJwt5Heu1YL+0gpqr14LgUDf1WmjK4boZsXqg1Wvx4K7XOaxWg8VT4Oq1eGpd +294vh/WMB1ez4lBXmdXPYfVaPNgqqxDBiyZQai5IRMVSL6Wwei20v1gCpWurd8Q7rB3o6rWMYK2M +4LBaDRZPgavX4ql1bX13DesZD65lxZFYslRJrdfiwalv8+hTCrqlcg0W7FuzFEqr10JrddU7plzb +tGpdIa9orFpVqOdMDGAureKRWg0WT4Cr1+KJdW19bxXpGQeue+ZuGGWt1zJCpbIK0dz9XFyDhfpn +LgCr10JzyrRX1xYMgLLB6oEWJh2gUlnFIx2mtPOCLM6G6OfC3UTt3TKsWw78h6zX4o7hfemonxVs +wVuQ1IijuXi/AWf2HwAQt8u5au0JuZt5jpYTKMD/n713XY7cuNZEn4DvUH8UYe/YoJEXAImtXyJl +e3wObTkse0YRJyY6KDZb4oiXHjbbtvbTn/V9KxNIAEUSqG6SVeySQmJhAXlfuXLdE0tgjJx3pnTD +b02L3B12UGsOjD04PlBwf3AQfDICdzlfjBHG3YZobUzXiAw6RiBxg3FqqWPx2zIgkUDyWE0IkwGz +jq2ZsRPBGfTCQ/LBi2A0yPAqzYQKtAH3ggp3pQOxKTRDwIwpV6BVX6iA5P16UV3ZImEc6wW/YGNW +pBJmS0oRodI09Tro6CQfMDq96KJElhYbc7zQ10pnImBzdmmR1KkCRq6mSX6MTnWFeB8qDhl3aaXA +cPgZWgzBlkZJvwLrCrmSrPQlCVwMzUGeGAC5945jBXpDgS1xNAsndEIwbvHCytnSdhyxRmpEJTO1 +hRhZ2bk4gUNKiUhLly5XlFlIObVlvupWgVHlrnNrNXI3uD6EEwgVDc2yDlHRhoWM1qWADECGaaim +i35MbMDYrPItsr7s+VUcW7StCJg+svqt0SSUAXReRSlwjCoKCSIKGxiJa9vZYUIrZ6sn/jK/S+eh +qDf7lmUXLlll6QfLOkaeYNHqeMOZjLeivhEL4WpNpiXIWNkmrqSc1WljwmnBxEXzcClN+FzWnotW +R0wUjikoziQ9sPxsTZLxPUhS2pOt9SnJbKt6zbZL+RNw8bky6gietRRrQq0pa87irMJOqGub8gG0 +pSaD0KkulfnG/Ju0w4gFx+tX64QHQduR5K+++VN48/vrt0e3Hz/8LOT87vz2GsAKwDd/ubn+q9D8 +OyH7RaHgo/OfLq7zFwd/eY83ptRX3//PP/7h4lKqOfhd91POmd/98OeTv9y8PcfPwQF074uvV7/5 +99XltbwqpFu3Fz9+vDv/gKNGzrDb09EXZz9fXL69Pb/Ge7v63Z+u7/p3+N9dPMl+U34lB9k/ri/O +BJjOs/zDf55eftQv//3wh9enV/wOnWCvtnUcv84ex68vMA7Zz7NH8q+Lt3c/zx5N/HqrR/Tz+cVP +P9/NHlL6/NnHdPPj/zk/uzu6+Xj9Vvp3dPPI3ugH+I77Xz69+zB7lIMyzz7Ub/705pvL9z+fvjFz +x3jxNuON7xkTvvnPGT3eFjJ59/H2x4/C4Z+dz50FLTpziVM7z000RVifO54fTz+c/w== + + + 4fb8/36USZhPQkelnn2E1zff313cnT1CJftRfuDXf7+4PJ+/Pwdlnn2Edu7Qrj9efXd2d/rPBSPL +izz7wLDl5o7t9vzDx8v550b6fA4Fuqfr5oGur6d+2SFw/vecnDzc2Qfm/ZkX5OJ67nLcvD+/Pb27 +uZ29IH2BZ0ez728+3p6d//H29P3PF2ezj7hHpiI/6a63fO9cXD9CQgaDsS+4a45vrt7ffLi4m7Np +nqID5MMebft3356/W329l/a2Yxx7aW97R7SX9taMckukPf8lS3vvbk+F7b38y83Fh1cm780W4vfi +3naKe7P35V7c24t7e3FvMqq9uLcX974Yca+wr0XgWzKSLRf5/KsT+RaMaFdEPpGDjs7/eX75/c+n +b2/+9WXbvvTIpFj4Wg7MHy8/PsKtfAZmc1slgw93b789/+fFKTq0QOrJC70YT/DH048fPlycXh/p +Au4KLz17bd7OP4bfvsQ5PH8g80/hty9xDC+hANtOzW7evftwfnf0HDTthbb9dxzhDm34S/At8BI8 +u7m8uf2vf/2sYsxM+vzr5XxVYvx6v4E+YSwf3p+ffffxkf2wexzBbN+eDx9v352enX9/droE8QaF +nl/qmD04WdyPl6e3xzfXH+5Or+ev27TgC1jTlo7y9/9+f3N9vsEo+4K7JJsUVVnOnqMtV3GYcsFY +tlvJUdglY/nv2WP57xfkQf56c3F9dxLVFy+hjzz/Pm7Vk8hc7BA/9DqNCQv5hm1ngzZS9Cy2Jmz3 +Gu2aZLTESLItxOD09uLu56vzu/kGuF0iCrOPvV8eUaZkw8GnWzyQR3jxfCBmm0WFX9z8gbitHsh8 +qvzLSxDlV2mFX8wNbPvReXlx99fTi8dkyS/87NwdWXm5mnjxjnuhhfzz+e1P55jJHWKClm6u17gW +T9eBvcvQxgq1r16JOm2BV8p2K9OM2XsMbb/H0JcVJHJ8c3N5dHt+/t+zrZqv0TPq7cXl6Xy77i4p +Mczh7Ljy29O3Fx/no276fDe0m9stcc4fyNv5A3m7zQPZNRHzzze373++ubz56dcdEk32ZG2HyNqr +IWbzI1i2nJi92jC2nSRmxetxWX01O31ZOMU2b/XZI9m1vb5zHrevN2Z/Nsuyj9m/b4wvG7M/2w93 +12L2FxDybT+SZm+yrT+S5ks4O3Yk7WQWhUc8SjKytsz5/oW87r/IHb/1jho/zsayrades0eyK0E4 +f5ttTj3++fT6+vzy+/PL87Ml+rRpwee3CM22tG46yGnBFzuHvr348P7y9Oz86vz67s+n73foMLo6 +lapmGyZ3QjpapX9Xk59m8HPuqPlrPv+dPt9iSrn1J/GyXIPbfHrNHsmu8d7HCGP+cyIfu0LvFmDW +tu+R2TqErd8js0eyKxze/Ejk50m8si27790i/6B3F5eXS/yfLrd5pd/d3lzNHww/fn6t5CNMTmYY +e8xjPLeMfXyRmKvZY/kRd3LN143r189v1L/81+mvs8cklO/u9HYRpdTvt1cTfnczX/K4eYGB3J5T +BJw7nNO3by/uLv45X5zqC7yAPeZ6/rjOzj5efXzcWygfWVbkBSKars9PZ4e/nJ1env355u38sfUF +nj/4bDZvka1eav4vHMLcBRyWeiGR5PT64ur0xVLD7moeuiLsnWG2TLI7ezXOMPNHsmvaj70zzLao +e/cXFk50CrvmDTM/p9muucMsIOXbfii9GneY+SPZtUNpJ91hZvOfu+EO80Xu+K13hzl7Ne4w80ey +K8aSvTvM3h1mWw6jL8Adxnwp7jALaP62n8Svxh1m/kh2jffeTXeYBZi17Xvk1bjDzB/JrnB42+YO +s9X2n93x5lmw5ZYSjxdaw13MGrjAD3C/Ck+2Ck+Xc2MHFuHpOvBCje9+0sZv/vTmW+bsebNM8zWL +IdqdI+r15i2arwbckaxFz5MA/KWo6ZI8OXuK9jBFq/cU7TVStNnLuqdoe4r2Sija728F8GWzaOeY +gtdIz/Yc2p6efZn07Itm0F4tPdvzZ3t69qXRs9yo82aZFf6VkbXZg/+CbHj7bTNn2zRf8raZPfj9 +tvnCt82XdVvQXy/+fX7518vTX98sC3bcRoedqlxVs70ndeb/tsCBMiuxS5Tv9vzq5rH0BjuW62V+ +TpF9fpR9fpTPhHQr87UtV6aS/5cr+e9r+S1/v5YXq9fmsn1x/fb83cX1xXwD1+35+/PTu28XbLes +xLOPb58jRse1YzliPrxHlpi5o9ulHDEzuZEvLUHMtvBQr/CCwh+XXDa+5Z76S8ayK776e4XF9pKD +x/b2btqVFlGELaduG5qUtj58/ubq/c0HYcu/+/gICdvlAL44xh0iCKe3F3c/X53fzce1XSIMs3Vq +vzxinMqGg0+3eCCPKEPzgZiXUEbMHsgjzk/5QNxWD2Q+af5lVyjzbhyiC6WeXTpCX21WxM9yhu6O +iWOjNd0ZB6J9AODenLx75uRlaQq3Uau0Nyevm5W9OXlvTn7G8bxWczKJCwzKtvx6EaHZm5D3JuS9 +CXl/zchkZHsT8prubo+KeG9C3puQ9ybkz6+d2FET8msytr69ePfu4/zbTLadFCwczq5Qg9np6T58 +vH0nnO33y9L8Dwptrx1Jp3/Z2AZlnn1ov55fXt78a+74Li9++vlO3hdnyIM7e4jjYtu7gHF3Ht9c +i+h+PX/fTcrtlW4vqnTb33H7+Gj2SrenIKVf/3R7fn79tXBg519fXL+9+Onm639e3Fye3319e/72 +65vb0+ufZm+1vTZur43ba+P22rg1I5vPh+1Vci/DVZkw2+py+t8XVx/vHrn6MV+S9P2zI149e0zn +l/KwSOWTlXgxfc+3F+TfT7C/Xsoj5luVJU7iHt8hlH9NaqcP78/P5OC6fQ5f+GeXjl61smY2iUpL +vFjanxbc5jWMnf39v98Lr7fBKPuCL8B4P6LNfQLV1F5vs9fb7PU2X5DeJmppVG8TlThU3+z1Nnu9 +zV5vs9fb7PU2e73NjuttLqNC41W4UOyVUE+vhPo+Cn87qIV6nfkzNtBHbbuK7VVGAD+n3vCF6NM+ +h8a2EYdXk0NjfsaGLc+hMX9FtjyHxvyBbHkOjee5B2S7vYm3//i8vLj76+nFY1aK/dm5Pzv3Z+fG +A9nys3Off2rbzs6lVHnbj82NhOldOTr3eac+be635dhdvJ77nFNLOvBCje9zTu1Wzqnvfz59e/Ov +p7i/aHco0ReeXWBX/DpnJ0XbR+Q/+xaafbHm20fIae7W9u8XQLL5A/l1/kB+3XIKsO3U7Obduw/n +d9gSt+dvF9HpXZMBvuNIvwwBYPNVfY2SwLasyuu+T3wvmu2yaFaY6qu5KDmfz3gJNmPJSOYzGi/B +Zxhfzh7Jvy7eLnAnjF8//4jc/BH9fP6452E2pPT583NQX6JS4wmyaO8Od7VXauyEUqPeKzW2lhUO +r0WpMX8ge6XGDoi/e6XG9h67e6XGNlLyvVJjr9TYVqXGFyaa3Z0ucLR8jYLZu9vTs7vTy7/cXMx3 +bNbCM9c4tfTc/pmHs3O2/Hj64fwPt+f/9+P59dl8jnNU6gVi0r+/u7g7e0SBlUts+PrvF5cLciUM +yjy/5mu2j+31x6vvBIv/uWBoeZFnH9nZ03mZPfdIlmm1tjjOef5InlDg2ZZT4fUlO1pwHry7vbma +Pxx+/OzDeU2pm15rqqPycPatLXc38/mpmxcYyj530WBw+9xF+9xFT6xani+TfGmpi55EafT3j7c/ +fryUyd4lPeLrzL2yQKTYcuHoeVKuvJCed0l82F7VupY//Op1eI/NH8eW+46Vr853bMGI9r5ja0b5 +4gaKni9580j4/es2U9zl/NkrMlKUeyvFzW5bKWZ7M+2akQJbbgtU4ntx73WLe0vQbC/w7QW+vcC3 +F/j2At9e4Hv9At9s0eA1Cnyv1y9tdk6HvcS3nRLf7AXcS3x7iW8v8X0Smu0lvr3Et8MSX2Fei8y3 +ZCRbLvVVr07qWzCivdS3ZpQvLvX9r5ubtz/dns4/71+jyPcq74xYFCO+5SESrzHjxWxhbp/x4tkJ +wj6N50MD2We8+EQOI+WBeBW0eZ+/Y2vJ2LtL4e70EuL/+vHy9OyXr1cKunl/enZx9+t/LdAJf7j7 +9XK+jjt+/fwu3EsuXN72nbVoMLu2mf4ARNyhvfQ6NaLL9stOnKub5Rza9lt/PjCV4/FrIm9fDuOw +i7cBviaGe+n1mVu+cRYOZ1cUIrO9Tj58vH13enb+/dnpEo50UOj5NeXLVmvZ2AZlnn1o//p5QXT+ +JbT68r6YwXlkIxwX2971i5vz+Ob6w93pY1cp5lqVcbldUqAbN3vznv73xdXHBaat7vtnX3Li3KvJ +MlTPzml1fikPi5TNWYkX47G+veC+OYlGxpfwGpA+cA+fRGK15/Z25dbXPYu0SyxSWuDFZ+y04Av4 +yS8d5e///f7m+nyDUfYFvxCWcM8vvTy/tGeX9uzS3D58HwnVDvJLr9MasAHntO3M4PO4SW//Ou1V +5s+QTvT24u7nq/MFed13iTjMPhB/ecSnIBsOPt1eOeOXR77MB2K2ekUeyeCTD8Rt9UDmU+ZfXoIw +v0pH4qXWs60/Pi8v7v56evGYRL0/O/dn5/7s3HggW352zmcCtvzsnD+QLT87l1LlbT82NxKm90fn +Kzg6d0cPvb+lcRt5oSenhDuwFk/XgR1ChNeaimiffHY0yt1LRfR6r8jbyGKw3azo3xfnsN41vm0n +kyxdnUpVs9NL7AJhN6sy/rvuVweZO2T+mk820uc7sL+2nWL8UYp+eNx5bHcJBiOp/pw24K5QjFd4 +Nj1r/Ne2Zl/Yp/h4/gRprybHRzFbmNr2JB/Pooh65jF998VEue5ceozX6cS3mHV7vTto++0psDdg +ZH9/xQmQd9EdYZN12fZ9lI9pdljjrrDa5nB+bNSe2d6fSZ9hL/3w7vz2Dxe326Ai2ZZ1vjv9cf4a +74JC065m2zk49v+5TGM5KPNyqbg+Xp/9bYeoyavDssNmVa6+DDz74x7PXhDPzJdCzo5eysWEwg6i +rv9+e3r94d2MWyS2B99fpz5kE1Zt29nPDeNMdkEbokPbEr56rw+JK0PPuW8uL7dgTbZlSjZD1r2v +5pIOvFDji65/+uqbP5nyze+v33bXQAFUAfLmLzfXf5UqmKakUPDR+U8X1/mLg7+8Zx1eX33/69WP +N5cHvzk6ffvT+cqsitVfL65/+e3BR/m3XH130DvU/PCrPPw/8uP/COhfK7/68+r/+9/l6q1Af/jb +QXlYlmUbVrY6bKrV1UFhDktv6ioCCivvK1OvrD+sKtcA0Lq6lffu0LV1szo7KNxhMN6urD10Jcr4 +w9pbqdIc2iZIkeqwdkZeCKA03qNIdRhs8PJNedjWRr6ppdmqaghwFZ5tU4c2PUuR5tCEqrXdF+HQ ++uBZq/OuXhUtipQGgMYF9syU+KhB14yx0oyRPlXSBQH4tvUCkAH6tukAKCTjaEIz+A== + + + pvYYsgBcZQkITVPriJ1hISfTVXo2LtOJ5zY49t+VRtbH+EOLiTbhMFQ6IgF505qVaQ4rg0kQQO2q +emXqQ2M9GqrQFSmEv23LQngnw9VvUTFKWwK8CeguWqjaFVuUwlKIvbDVSnslhbSbHoAGwy84FGtX +HJpOnoCatiKotI3hN7aSYcus1rbVSlzTrDjxLYeENZc1aQ7btqpRbSmfyIjqw7ohbhAHnF8BJ2zt +U5mmCSuijUt9afwKeOVKFAKuAYGw8qVjIeKjLIHgJxa7AL56GTTQtzTdc8mP9XfRv4yli754bKLI +24j9KPqOxK4WfV/jeIjkgu5xtjnoIh81pqXo5yVOXZHPXZzeopvfuABFvgJcpSJfpriURb+WcbWL +brkTShQZTiS8KXrEiahV9LhF/GvjjzZErK2dN/FznyrAPLFKTAabwTyxYV1mdsaa1L0QOxyahI1V +v7F0oM7G7cjdV+Tbjxu0mOziIt/G3OpV/lWkBkVHDjj7Ju6HSDNIVypPmBIWpTyBPR8Qp6KnTol+ +dd8kCld0JI5ksE57QOkg8Mj4iFiyLkQ1mbo4A1gVIKTvdkFQVBG0tewAEJlrIO0LKiveV6tE1uPj +2QFRv20TABV4zHiqgGSdW6NrhWSdVcauoLPOVX1vMSLXDEYkw5ad4vphY2IafqMTg7lrgcLd3GF6 +g+unVxZAyKFNC+BJX0LCExfQDJayMt1SCpHCajdptUEyZYgVsCwBpJCMI3C2+2/qyrQRtXyj1K8N +Cf9QhnS97nGUaOz7TZboetxjbId03Q9Ic+1q0+8wbKdQdvsKeKe7yaXN51aj/VnpyVGZfBNrJ+JG +1yNXOmkTLTB6QmHTcWQ1TpAhVan4ja2CiXRHz2luBm6PKrAQCFidKFjJc63h0iuN07Md694TdmIJ +NiWJpQxN8SgiuTNOeYiE45VhIeJjJMxtvRqS7maVkfWc4rvIoETMFsqsBN3rmdF4HbgDUWLrUjDx +J+yekOvB0STPnN7G1fH08hykkPGax5tv9LCX5SOCVt5oG4KGQY/IsNK59nqE1s1qesqOD+LxST09 +zMfn/ZghSDS7J9ljtmLMd0xZkzH3MuJulEw3Gf8zZpHGPNSUzRpzYkqc68iq1TqnbcRF9Il0uWkj +vwcew4S6YxhBVgKWP1EV0h3TvSddsrZjOEm6qpwnTdQtEbdE/hL1SxSyJ5CJiCYammjskATr0/GI +0z45OPrxIHm6H/0sgshv/nENoeHt6qfb07cX5yKVGN/+VqqRtTEBf1vBcyefu0PfOGBA5jhvVkc/ +HfjqsKyFBAFQpIcimFoWGBs7yKrLEgs9OLo6eCfNHx2JuPAfH9G3pjRCocrDEKyTeQJElsPoMLDI +8qqSlx49MVUtS1XitG+kIz+cxtE1yohBkJB5toKWLgKkXS4HDhxHgULw3Vg9cKz8khlyh3VZtXr6 +mxoMYTxaKmlMKqlD0HOkaSxmVCYyNEY5isbIWVuDoAU9Sergaz1sXP98LIeNdUCzDhQOnWmdHsHC +GwLxnAxOWxacb6WQ4KazPAllGDJROG1cCQYd+x00CIeN65+Peda42udfVHWlR41pQd5lAoD/AJSh +Zhl3WFk994QrqJUm1Do+W9bchi05Q+xUcFzH2NuGvJBsZjnClCyUONNkt5fovtAB6XvNs8ZiIY8P +0qtCP/YrLaxHi8HOZgO1MpWyX9A7dgJcLbtVUc5iNwv2u+TmLwO5TIwNDQmE56shw9LyCyHretTU +lnVUJeg9Zr2yTttpwagEbODAHe1RG04akfe4o5sGlRAlHFaVSCIUTY4aISYlZVHBoApHjeCU53Eg +WEb5tfGlNhQxsQBu1jV3pkfLQF0TmioBSnwcf3avWNisurKoH+dTRGuO3dTyZdcDIrJZdV0kHq+y +QWCgsgjZOFuhF5gHwXydKu9X2UxxNkk6a2EtV3G2Odm+7ZaDq+FanaaEWEIEOLUJr7iiCa36Rc+w +SvGCmOMVy+RAIE7hCOlxi2/aVYd+RFCrKObqDofZlq8U7Ynm7I03q7gNus6i+9avsn2CveSIb6at +uZWc0+e0GX0bVv1exG4tOwB2s6l5kJB8pAnt9ztoApUPkSSAaNiWPRSk0sNGTptVT1ZIefTAJASk +SRB8lSgTVhlUpideIG6JtiXCF+lewqGeMibqmVC2I66krR3t5dPxwQCBK8XvrjR5WWnAyvoq0qKB +YtCFJm4k3eTsIjdbVMjEERQYpNcjmIOEEGRd289LFJTqbKIKzqW3/TfjyVZS0NhsPYrxkhWjJS0m +a16MkKIYI00xxatihHnFGDOLKfIWY/wuxhtA6a412R4pxtuoGO+zYroVi/FuLcbbuRjseKuFhjSB +n4ASk2Z4k045JSs1CRflsLapV4kCF6RMrqdMxYR26THd9NStyMmfZ8sZhVQCXOREtFLWIRHZMkTp +NRHgIqfO8W0sXnTlYxNF3kbsR9F3JHa16Puqwyny8cQhF/mYOStFPy1x6op87uL8Fv0E52dgWoL+ +mHRtnL7sLDVVf+Z3x22HEtmZ3OFN0SNORK2ix62If0WOgDJ1PGX5edQMGdmrERWrqD2qywG3oZ3x +Zti9KuNZum1V5Psq7r0i33zORchgAxfZDo57vP8GVKDxkQ3DwidSkfFqHT3pGLqO5BQTupQxhh3x +6r9K9K3jL4kgTVRVJCoILAplxqkqpnVcLJDRtRDke3quGGtNzw4rWnsT2eURO3188AeREL7Nuewa +ynppQViGmo/SbGNcUpOEivhct0lTayFFkmiLEOUirFTNu0gTkQEezU6EkGzjOLDZV1iNqtVxNuMl +bDoirDiYfdNYq+ShDhHhdcPoPkk0FVIIG/M1Jl4gZdOotrtUJaDMCxVu/FHXcTcIP2Tj58HECiqt +INjIsVcmpIbj7hMcVs0r5kT1eg2xu4GGMml+K9/qnDa2iZtWEMTqzHvqMSrlXbEuwfeARMDwu38X +i/elYxt5E7EjfT9iV7uexuHko4lj7oacpqWblTR3+dThneoE4vyidMXDMC6B63j4bp3ianIxrW5+ +rvcYJTKMiFiTvkh4NUG+DPeIoY3rv0k4nFA44XmG5pjUKrBe3QuYdhGgV7bO+CWy3f2LcSHUC4m3 +r1daDiYqCUoqN5uq77wqIWzWd1X4G4UIUR0NfzI/owkcTLCJqzxYg/EyjddxutRjbBijyxSjRjhH +nAwdSk6xltMng06IPUL8bE+M90sq2e0oVl6HfNvF5rutOdy8zWq4wa32Z0gEJnSCs9PUOTFJE6m7 +x9lVmumOKLF+P6BcXK946OuCYT2d6wigaqWbjEYCI2rbfwGMaaqM+HY6jA6piHU8WSIoYWWi6Qlv +M7qfULs7HBLaF/mGKLgjBo8nB+8O/uMfB/+gsuqHtwf16je/Xf3wv6aAr96Y1Tfv5U8pB9VXb7pV +vuofxss8WOUMhc5QZIRlIxwcISlLjBB5jOjjrYAyk+0y3k6jDccy6ELQHoWaPaQGHB1uJjQDJcZ0 +5R5ahE9zOjUlYmNCxxKjDhSj/k0INwtNyfvkAFgzXdOjZHLYrFuZ6ak1OdbWYMCaA3J8giYc088n +h+/0fB6f4lpwetpPGIIx15A6OOIuphzIhE9J0z/mZ6Y8z5gz0pK6ukW3vGn5i7T+E66P5abcYc48 +DrY8N1NGHia0Y0JfUAL96KQp6Qc6amI/63pKLeP2G9HUCdUdU2YWG8/yZCHGhwCHND4oxgfJ+KyJ +RGV0Io2PrBwHr6HH/+YasV9CEeGJIxQR7jiUYaDNEzml8XKiX6nI7ND5wyqoAb+F3wD8HmoH0wYA +DjhRCZk30YoushjMJfVhI1Jt4DdSJED5UOnOMqWvRJxvS++iN4KxJdRcra+cim4GprUW6sVSRU0D +KUqOIkggUTyk0UQ1YyLjiCzsIZY0kFipCVCxEcMKwalBp4TlQGaqKrHAMEBVlv5Arm6hZW4PveFz +a2AYlMNPBhgq4ix2lcEnqp6vKCOzjLNK+kxT0b8iTUGBOaig/5MpwEQWaRY4CTUF8zgLMGRRlJMx +VlZVVBgSkaHCBgSgUs0SB3SsZYJytbas2Dk1L9C65aAFqiDhku1taBIScbpVRITUZ1VBql+0sHpD +yvZRS2R8WavpjJo2iucBc4CiTv0xWm4KVA8PCDbI7cYeUKaXPoksjG9Ma9Uu7R1mXzgNV6o4K/it +atDKRzcGEWIddUCNVaQh19kKH1E1WknZVg2tbpFsSEM18L+R1cUEAmCSMpQqgQSgE0CrKoQIkr1r +0zcWnjTA6LKuI4pbR3eDmh4x3AXYWDLWZPVX3JCtYyI9tNGiL6hdRZFT2gGCOrSsJLyp4aGTkTZ3 +2DYq7uA7U5Nape9Ql4+aK6JekTfoSqveNtIr3yp7RnEd3eacpX4DU0UYsvnYiskEQIZpTd1PUbFm +HgsYaMtYuX4l62GpVcB6cG+23A1xX5fRs6yEeVOXOpISoZBVXPvSRTxvXSTXoEgqz+nZIqVccrTR +1qndVkRvBphYDNG1DhHZnbIQto1WJVUO4YfXLgLbg4lfR3+ibO94n1rRZkGpUEy60sau1a2O2vug +EBPaaCCs4qYr5bhPcrTCZFFhTuUYqQwHRVC9YCSdpBrW+dgcrFMdeR3QnkR/SaOLnEhHQl50lDzR ++qIj9ulAKNKJoB5g9JYiLiYc9lQOuUS8gcNCQMqot+D77HWsARXU0WlqcO6cwe68ztjc/BbNGBAG +C/Nx3Rxa6OwMfVnc1NgMr4KaJ6OHyAKnuFrQplXE9yao6Vnal321klPZHRrZfD9cQQJ11Ap5OXED +ln5dyaaFn0OzghuV4K7szKOzTRs9mtuolx3nZaGD7ANq76TNaCj/h5zvv/vm9m7gMw5pRz2I4d67 +OoPP/sfrt6sPP5++P19d0TH6P+Wrr+W/Azv0yR1JT2tYBGUxFzMJ4BKXsgnKBi9lFJSTXcwqUIZa +zCxIqU3YBSm2AcNAAXQxyxBLLWQapIfL2QYptAnjwGKLWQcu2HLm4as3G7EPX73ZiIGAnL2chZCh +bchECPJvykZQzt+EkZCCm7ES1BNsxExgj2/ETqDgBgyFFtuApUDBjZgKFNyIrYi6gw0YC21yOWuh +5TZhLvSAWcJeqN5mOYMBMfhTj8ooRq9ktuqoblxbJT9u0xnahdhocMy94TIypavvbk+vfzpfHjAj +B5IgvKNPgxXqypgZnIvQ03l1hDqh8dLXFT2rZOVaggImk142/HtCgxXfpq9PNLABez3VeaKGf5ig +tWXWZWs5gmrkA+jeMypBu5aqKdXpPdWTWiuy5lJnirxX8XWRdz5W0/XvJM2EIjg7eCJT1HXt5CB1 +p+vgycGwmhJdGLaGirUrqUsATDu+ZnxrpiGfpvQ6exvr6KuIXeibiV3gn6rNeqtdyofUT0yal35a +is6Lsp+dCSLNcgm1AS6hZSs8Bpw0bUNn+nKFXWihrR2z6a6F664CivQAHrkFYXTwCQ== + + + hc/y1CNUzm3hhEpY7sGglUIYDLyGpXUjLBteBd+AsyvhwxcCnUaFUZSRwyGUmADTsuwQIVV6WvMg +KIFl6lygZwGPL8ybsAqqyCTJPTmQPgY4XgNd6AXLBTA0wYOhpyMt1HkkY0Lrg5xTCmrInID8Q8fJ +lRQOSk8a/jihsqapVSHYyOGgoFBTHRsrJU4IU6FsH1sm4rA3ReofsUuPiTiIkwOOy/Jg15HyI46+ +SPNBDOUcldnr/m2qY1AF2+maSX3pu6ITU636/nJUNqyyQcV5yUbOaVnxT6iyOUyz1E90mqR+MXSO +sgVjr9h27Gi/pnRe8WTC47qn8fbIUa7SvJwcFIPXEaLTwSp8pZupawbSg0AGXSHqFJPuFtMhFdNx +dyjTo06R3vYTWKQ6+lkuEu70S6GYLEjar1cxWdNiuu7FFDmKHHeKNbhVrEHBYoqoxRp0LtZgfbFm +cxRr9lCxZqsVwx0ZuzfYuN3sZ9u7yRey6JGqmJKKIuFVRlCKNXQno0snyatGQA3OcQ+HoUo/r9q2 +jgdfFJlFEoWngnay5pgbtVroVOscph86h9GSo9/rVLeejGasVleEjXXNA9Yf7XyXv4r9yGpIDfXt +pF7kvdGXeZ9jDalTJ/0MwAeq5BzKVtSzvHsRZyYvrfMyaWHQC6VEeGfbvqep7X400yHb7gAfz9Oa +6ZxO+pqlGSygbbPRFP1krMEGxZT+74am8SaZxSdDFdhkQmjvGs4aVSGjqaWMPpx/AU0W6as306VE +xzgeYfmnGKAC4AhT1BI5bm4N3qnReIiekCwmWKzC1GQ+0lbIXhfD91McyNos8kbXYEI/jmI4kOm2 +zyanGM5dESdv7es1mNUtVYaA/ZIOerduHGtHvHZyurm7ziSqKkytk+4QSpmSwkwbgwMQ1Numw4BB +yk4kVlPaSOPpHFohLrBUOmbUsCtvjDWdfGN42KlFVQ+MxloEjasu7gQem6oDtEDlBucg3FSpS/TU +w3QKiwYKGs9wyRaBsjEgkdbbMrqtBgq3nTMmoknxg25A7F+BDkKJpvw++lf0HTQIm4KwDiVnTWEO +pmeNz7eq2SL/pEZ3/EB0xslBeklLNQK9SFTKmoHYsVIwSDU1et3UnByk7ugENugXZpUa1zTNYJIq +b1sN9OFiCPWDaj4qsLlkSpiwliq04QNqp/oPoHB1bVnn9RRpEbPmijW96mYp63w3TdkYizVT0U1U +NmPday3gEmw8/9ocGI8MjwarWQ+Rskjzl+FukSNvm5ysexzvtsDJwxYSG5zzgRYSI0yIFDF0eDZT +0QtuygY6QQcNOjTHHk7WDG8FKwOiIIJYI52R+QgiK6of+w9XONikszVLNKpXX1O0NYctFLbBttj9 +whAdnW3c6tHcVqUAvaGDLSsNGM2NJI8ZOXpKE3VgQ1qjpHtEbdSgMaI3ahwZURwtPqI5AE6ojgA3 +oTsk00spD91IxrSHtH1MfQQ4xX8CxxSIRoMxDaJ2f7z1eASN6dBXb9ZQIujrJ7se2vgJNYKufUKP +4DU0oUh6PnY0iZrvCVWif9KELlHZPaFMXLg1vVxHnfQgH9Mn1TBPp2kdjVKl8phKKXS6TusoVYan +Ga3KUDqjVhn2F0P0n1KsfDNNjvj28ytNBU9Xf7w9P7/+pCRDIWUZEibFdxCE+wcGB/nDuuLgS+eZ +IICxn5pkqA1OI8jLaGgUUkSvcBeC+vTVsLzAK9ZpIdCn0mpof0B2ApH8qjoGY9ZZliE+apKhGplW +4nvZwsarM6dwYdyp1hnDTS4UwaUcQ0YD2a0aLQw+Uqdt64c5hgg4i4ERo2/q1jI8jZSGFowYfu4F +m2MGlRA7H5paU0UYenbC6NhqzI+Tfxifph5sAFU06gnBr0pNMtQgMQayAQSnW8DXsEzib3ApyVBQ +n2c9B1haUwVULsRsF406zDpnk6OZq0r68BnGG2k/m5X2m6YCwWgmA0Aoe/R4aNlhmBxj3g1kTYHF +yRh1DA0Vw9OsgyemJrxxWDShv3Xr1TITYCWqEQYb/RQNwpmJEV1iIvSbSBMdOj3yAQCtGqsGPI+E +A8A860LMMVTDWxTIaWMsTmho+yjL4LrnlGMoNGpbiS9j6aIvHpso8jZiP4q+I9rTou9qHA0RvCpt +nGsOucjHzFkp+mmJU1fkcxfnt+gnOK5AkS0BV6nIlymuZNEtZVzrolvshBBFhhEJa4oebSJiFT1m +RezTH8FGnG0qEzMShejoWbkmRES0CdVxWGvDCddNGRMCxMhA9NetsgFwW9k4zLivuPc070C3+WR7 +qlP+cA8X+SbmRh98RVoQrWKMbyPBsGk1Kh8zDBnvtFdCVvwqkp1oyqvzBEOJMCXClb5IlK3oSBuw +w7VNxJfKanqhxriUSie0imV1jM7zSLBEXDTeROys25heCP43EYcrTb/SMkNTJNh5fqEQEwzJ1AfT +QVCH5gaKdaAhBsj2DZGmp/w76A36SyIV+0uMb9MeIE3HwG1MYcaB12S36jQzfX6hOHWYW03yQwAm +v267ybekLD4ld6CtnKvYdKtIha6LqRpq7Ns8t1CtG1kDPdrBN3Wb/J0r75TqpalXzNPd1GaUEgjs +Vjkpdbo5ieRGk7kIPQ8DktxU/CYRbWykdrCjdB+lXRcPg35jakBz432+e7UP6ZQxIR47VdpUmrql +oxSOdHZITTRDHrGT9GaVNoFuCxrfsdINmgHdChpgHsiEkbQ1jZ7ndTzf21QmAC1II40eksxxoVS0 +XSUcU1JLzl3x0Ed6rJ7cGcUOq4yaZ4TeCBlRUh4Up20T2ZKgKF0GHbcv6Sov7ddNx5Swg07jv+Cx +rmMwOr2hlj3GUXrOLvMqchqqOFWeeXBcSfKmc6lHY8mpbUFiONOajHB0uo7O3/H5PD3Cx6f8mA0Y +cgpWsXHATIy5jSlDMuZZxkzNlO9J5DlR50ScE9WdsldjDmzMoin2uYiOVpMLGa85oEgUaAf2iTHs +kgtFkkKSU4b4TIqkfCcJEolWTGigdDiRtUjVEtlLVC9Rxp4wJuKZaGciriPqGx+Pxwz2HEtyG1Sd +4W1DD5BKkK5m6iD4cbXrsgtZJMaKluT0UAQTZK0hXQbrmkMbhPZObMnCVoaWmYPkb8X8FTJTajGG +GIkfgsO+gXlZVgSuOyX8L+VUnGQXogSxNp+d5gQgkmi2Jr8qUo6xY+azc21KLhhqzWdXdfnsXMxn +F48Kw1g7zWcXw/8RdF9nSRFaN8wxxOdjTWiXUv855hiyKkFa5q4KMaNdl3fQaRygRsIw/5WLCe1S +/rphiiE8H8d0di7/Is9mV8dsdn7VOZ4dx3R2OuSGKfBipq+Yz06TgXUZI2OEaZ7NronZ7OwqJoAc +J7NrNcGQYcJLTT3WrFLZmMyujXnNVjEtaoy2KE3KnGpTrjG3irnsutxpMUmk5r9hdrXOI8syk108 +bWyTsoeFmOjRxeBU6+s6izxmJjsXM9m1MZOdiZnsgollmBZQU8UF7UtrYiY7H0aZ7DhviomMs1Jn +1WEqO9unsjsepLIrbZdstyuZ5z/VypnLrl517cekZV0HmcvOrrIxMJddWPWj7FLZxfjrBgw2065p +1G+eyq5pR7ns/CiXXUwvxBUjkq06hCKGeV3xetUteIZO3oSYxq5S7PJhlMauVURUXIpolzApy2Jn +uhx2x8McdmVYJdRnL5s2JrFL42h0Q9Veg7NJFzSJXbvKdmAM1o4bcJDCLmawq1ZpB6ep7Pd4Si2a +yABT2FUppXHVx493pCTLNETICfPaMR1UhJBAlSmTctvRsJ6EJTKXqFyig4kMJlLZU8pETRMxXZfY +TtMNNZoHAO+HKaNdM0wZ3aTMeXWl4flZH5o621mxk5otVWOD4zg0paqm4+FQNemqN91c5PmG4gQy +eStHl74ZL0LMchmydSrGSznKG53EwQwXihGyFGNkimSrzfCtGKNkMcbZYozUxRjri9GuKKb7phhv +rWK09Yrx1izGe7cYbu1iuveLAXlo9FTKUmF26aKVxMBT5DilizakQnUKDIZza6RSxZSO6WHd9KSu +GNPCQbpoWDaOU7ronqIWI4pbZMS4GBPqIsPkVDxPF53aSLjcd2SQLroK/XiKfEBxzEU2aM5K0U9L +nLoin7s4v0U/wYPzsHH9OhX5QuXnatUf/EW32BEd+rO5GB3fqw6lih6nhqmi24istfNRNLVVLE53 +b2aKbmIbWaJo3RVRK5D1rPEh41qKRLyLfDfFHVfkW077NN62RbZv487uv4l7v+PEOgKRcWvjLNFh +1RGaYkKNMtawI1n9V4mqdRxmR/oyNlQTRdc9qxoTRaec4GyFiaIT/gdFEoaQu54vjomi/aoYEfMi +UfN9pqF9pqF9pqF9pqF9piG7zzS0zzQ0RtJ9pqF9pqF9pqF9pqFtyTSEEMnk0Dtw6a1gZwGDX5sG +2Q2uehgCPlWLxIBPyiMwmWiUhYhWFGgsZTa1/gsGqbAbglXFNhPeQgoJNkSLu9791VbOJH8QxTw5 +RZhWt3fgRopZppfHucJbbgIs/p2rRs1gfKYZqHUhjbUx7XMK6NbbABCe67qLkCzT5cOEVNYxEqSM +a2MoIiMixRrVtFBuVy8FGjGdmjGw/jEyTVYiOSvEYHPfpz3xKZV9FfuEz3l+IpwlJc+v1EcsHNIv +Tp14YlqBVuqKSh8TUZzRwRRbqzg7XCX1UTDRyF2FMgZcu3hNAVQJhGgQd4Koc1JbxgS5+lV72Ea7 +QjIwhMO2aWOccmht9INqjYv003MDypg0vgjLWgevvHEdI6MJocMVpzD7RuYmptDVXY/EDLFiU2mG +KlgEy5iVwvM6JIdtE23yFf1MZEq8ekjApqfrxghtNfE0vGmi1NB4dVelCabkJTC16SHwVBDpmugY +QZbqFttX5IBTdWrM0YKX5OjYIQ9Dr6/7PleMM7f5wOoYtt0Nvk7ukWl+oPEx8cKKOIUNte2uBwXQ +jjjxHC9jOGMqhjSkkoSzJ5PABW0J616SHfS+dj2AdtUm3WqWvokJCSpyMTINVTlAQwFZ2koAMmRa +nIm+RkxjDEDaoNBUqR7e2pCaCVQq0oAAQAutmIl5sDVltNeuZQmjq5jiPwa2a2KLLFt0UJOv6orS +FyXv9Vipa4Vm+a9S+m+9Tsapp6alb4sm+TfRnYzkqo76+w5Aw2/0BIkgpIhm+maQeCR5SIn+CQDR +BO5UZbL+lThYHOlbHF3M90+ilPLxnzHhvzouZRn/jbpKrskPfXZQDJKmx6T/vslqGOWh1oxD6IpL +Zsc6aE70JnrgsLOjnNccUTEZNrNnm2jzVGKP6RvMFcmKtYnU6FcBhrSq6ZcBOb2bKk4X8VzJGBNg +6GqqPt6V8a5AW0XxP4T0rATTOZd/oNSdGNV0+f9zrOsuMiGq0sGYmseY1oLpXEZZ0WO+J3rJq2I9 +vwRAPdhifvWYfL37oW6WXfL17B6AWjWl2UUA8Xo/MltnB4POxHTs6LDVDud3Aay6JA== + + + 82cHGWuZrmGx02z1MZE6U6s3JjUnK2M0830dyZVvdJFlGSPpVh5B0KWJw7PJE75PkR6xLN2J0mF8 +l7H/LN4KwMkfXgsAFDfqst5dFFCWJA9nBz3IpfMNuUAqeBbgEC91J+jtDYfKEammrPQMYW8TI9Px +TQE6dL+aclIP5dAqo7/ENA5f1hFma43DR/Ic7Phgy5L9Fo4cN4L8cHVQN5pjZfyhwJFgJ315dDaz +yqN7qzS1gROoy6rswjjWRG5MGcoMuoyljCLXcqZSZahN2EptchPGUktuwlpGMXYxcxnFtg3YS5Tc +iMHUmIgNWEwNsdiEyaRCYSM2k4EhyxnNGMC5nNXEGDdkNpFeajm7iVDSDRjOr95sxHJCot6A6WRc +0XK2kzFKSxlPKbQB66mlljKf7OBC9pO6umUMKIKtNmBBscYbMKHAqOVsKLB3ISPKrGgbsKJUHG3C +jJIYbMSOkgBtxJDGAPFlLKmS2KVMqVL0TdhSPUU2YUw1FG4T1lTP5w2YU01Ptgl7qk1uwqDG9JrL +WVTNOrCcSVV+aTmbquU2YVRHisK2i/z/DrYqzVSZhn6l5jQNRqo1Fq2xemdi4LlunRLRjo+TrpLU +FuCsEBqJvisTBA9m9UhWP9ySd6RyOBiL5oBELj/1d1QeyqZr9CJZyOYc2OHVo9+VuMYX+47uDg77 +T7WqwwEdb8Kny8FrTLxCVdgT3TXBVA7OtUgpK0gM2q9B2mxw/G0T+s+OzmbXeHR/jb6ViRdalFd7 +P6u+ZmWjennJ2jLPxAarSxvc8vWVYpus8AMITlbbZIz1FdM2lCbjvoWoKRMe+XPkgTRDJt52OS+R +SzjeWRpiPHBLV0ybLlgDt9NadZ6NhNeq8QQAzU0qPF6tN5RSQlGKr9Ea/RVwDEvPbh0kISW9rQb0 +tr+sbXBBZ0a3SdWrAXmXX2QYCcJyAMBAdAgbWH0GN9fRm7BueAWlfGuilzcZZgomLlpCIOZN5nsj +OblB0EQUVetD5kORQbeIdQH+Y4egQ0gjHbSTw0+5+dJXR2dz6zu6r77Kqm/moNL7994apNNI/aVo +p6mEFyMet9FS1CN1WI58mp1mMfpxkpYjIIstR8EHCESnJkCGMegnrvqEW4HB5MpSUt3QRKKUlBIM +eKqSfszDkaKCSqBKzKQBwFdNjOdrwQFjmEjJof5W4KJlSExIwWeMXMqY1DAZlnQpZWqIYkHP1JDx +CWQ1Xc8ftTGL9ll/I+XwQspQrwZsVqhWQ01hCV0A3Sy1WmZ1sodRBhXKjKgYSFMYoPqCMRs1Uv4m +udWrSMjcHJPJ3og6SCNVW7e6R6GfoCAdhHmm0BUExUQ8FRzB8dxAUHTjb7GPkUmp/xZ55efWe3Rv +vbJrNPnwoOKHFGoT7MtyXC3APy21GAO12FIcTI0txEJl75fiYSy1DBN1Zpfi4kNkglS61pT0ztAd +FlQRvoPQvLk6OU8jKqVOekFgGcNYWsjP6vhoSfxrOQRMDKyFCy9Og6RL7K8XrpNJgtovoAGlSXam +1bQX1BUw1bWGH4YYXQGtR9D4RhVdwDUyugJCazCryZA23Iw1vNu5D2Qm6SovAmHLgct+cPB1Zzoj +5umvxp/astUv+m+5FWfVenRfrYhH5IQMan1gH06XV4FLF1jl7cVLnBpbuMhabPEyr8VzZG2SrX9v +3qbPlkfmwy/nd7/VoFBNvPndAcKghbBRjvVCgltKwi3CrbvkMqfzs3PbGmGEMicNUsPyRBdK2cjC +OWhEo3xta8SLGJhPVN1U1o3vAGTfyX4kCDNNWpwaCcJahWNLtcoz06DHdo9xSjCLe0W3TM3jvQY0 +7O4J8fRbBvlDUULNvWO8a4JY1eGDY2o1VbXG9lDjVXXPjPnn7cXdF82ohmbYhkbkWY3j4oyd9BBo +zyxb0RvfG/0itZqeVbZAv7ov/KgGP2zjeDJWzIGj4Gez8XeQ2HspZHzdj1c4QX3fjb9G3ofSd5B6 +VEM9agPergrpx99BYu9TnWl0qdV+/KlfCeJGNbhRG8eTsWL8xbhzVxko9r9AZ8DOpwEW0zko0J0q +Q5NiPI/FuHkNzhvNQzEeRldxGmcxnYqug9034+ksxjN+PB05p4N4OJiNBEnDIGY22WQQNQdzoagZ +sk/8qA4/aEWPbECyiUiQNIJUaTfG2G42Dalr/SfNqI5m0MrxZLzRMxpBQLSXQFHiRX66YprG0quK +JmVGxF0eehMFhULNE8qEx7KMXm1cHQTDwa3n6mShMOH2Wl5O3tWEO3wMFPEh3mBRNLBmtEEDdmqy +lPKydkGTDbty+MgcG6aHFWinQTSVjQ91fAP8s7h1qgRveMInGxP1dfW4+BrtpN9EXDUCuqz0YagC +tqEw5dAQe6ik6Nnbmpp4PJzSY1CfrPNX8EUyQceexlOSvTQNS9W8kQExeMzAiIobGgNNy+SsLgrS +JUPQs94dH2S9PznQsdUdJBt3NiFSKJusk4N8HlMNXU/zgWBg8diFnbxlDjXBL/LBV5goS+deJK2w +8XBCHhmk+wBrRakauE7NdASUDEb1VVfqWFMyR4ORddw0iCyztIBWuDvArXpAjYQRzaov1GgyvRh8 +QW+AaFdhIucW0pigBBIUMR+7mqM7QKMpXVKZ42yswqe5oDm9g5zlzD4gO44OED0EkhuVLpM5Oo5n +M+6x0oi/GtoHp+nsZM9rTBFBuO/Bq1CDwx7ZZTKQR36ItlavrQSEQMNMm11dpguESw0mCB23PBMH +91954f1wnVNfUwfJGuxgXb+6mlLfx+M7S3EZ913qcnRzc8lbXdxfT+/uzm+vf399+uPl+R8/Xrw9 +/6CXutj+6pfuo3+/v7m9+/uv7+O9L4JPsrYemrFS2WrvVBP+u7+dn17++fTu9uLf8t2gkvb7y4uz +8+/PTi8vrn/64+3F2//3/NdY3bTFvwkz+uHu9hTd79tdzMV+vLw8v1sVq6PTs1/+dXr7VvMhLrxF +xjDevooJly2iSvlML/ZVAsUnn0IHcUbFZLXVqitYDD8vjI+/wFzFn9w92UfDGrpyGoK1YiuDngy+ +TJ0/7scx//KSFfwXSmQqkskSqokbrqapc+WshEMBRbv0AO1uJWJdqCEVtZ/9yhKdrBU1wTFLGga8 +0kydzCrVTVKaolV6l8roK+u6yekSE+vLIitT6Mdc3H5p+/aKvCNxWbtFXaXrC9QFhZikv2KGY/7m +f/1TbM2vYmMUDav4RfwgcuUrlQDii/SlFgWZjx3u6u8aib04Pui6s2FcF6u6ir+6JhRsOws3fl6m +HKmrOOS8M9Fey/5edr/7Yad3Rawz/sSn3fuuSPz2rOvf5Uikrn0XjPEfMR6jE3VXPzEriXqO6IIx +ZgRP8d4Mw0gW9QnRG7wAjKZvBaTMCbx1y8dc2HxI5dOPvgibiY/HqRPxWe9+Mf0Ho+r6phjgmDpx +cjDuYqqmUNY1jTMdnEhk4Wll5jnN6xrxFzlY+Mqmu6fB4tmUQJ4f2hgf37Zd2e45qdMZLGPSJSf6 +lL7tC5lVaqFge0aBlHXj/YVsfNB0HLtO9wOaMuEiRJpndvC2JCGqXLXm7tR4H1QZXcWYec8z28Mq +vqEmqzJct2CZTs1TlVb0H7gq5sJ8qGjl9GrLo7ONWz1a3CrulKqRprjXvK2nAA9nC5cNBJrwrTpy +9fsm+UemnaPJlOfunaQgjrsne5y7f7rudDuIl4zO3EO0tvW7KHt8bB/pzXplT2uqOFGRYJqOYD64 +xdL0xU2mXqqztlnytWm7vi/ZapG0mpT8/OHtlsZzcv+wBafMGErLv+8J7HrialdDQCQi4Ad8oG+w +XkXg6OVwGD16GiZRgfhpaJwpu1+wMw/fsXDTdoXzuqFgTDQ060neo9jxB11YYPHg5W8gNvBvRObC +e2mN5dXHTOtK8TTftbBuN5obMSMxjMk8ZE7ZdSXgwGLbNqcsM9s4mtsGWD0kCMzoyKfeLPmPjtf/ +OOTWCxOv0TSH2oerg4Y3RdOfuWpCjY2eQIZO0ukaq0G5e08I67hodSiR5zAeESLRQnf/0BEBxqOK +uYfpc9i/Cqau1AdXyHWlHuujFfTQ5rSPFXbx0tnhMbGw5aMNWobZtEIgbnZUgJcX4gCpuxQJX+TV +Bj/KsiEPX4fGVuTqpd8VIKZPGSn8fQ1mnoG7unbGV/L5VQeCAtA3Vby9hDdBGy7tqERisOUY1BfQ +kEHtc3Wgd0B3BfU9FImGmopJibWgh8Tq3/DqVhlw/dvV774X0ff6p9Vvjo6+OTv7ePW3mzvKsBlW +T45OPRHW9FwDu7u+99/0vV9TLhHhNT39Xf68+t1fbu7+dn52c/tWMP8/2RG1HFa8ZwS6Rx8MvF/s +RK4//uZPf4x75e/vbm6v9FUcpWzutzc/nr/55k/tG+nE93e/Xp6/6ZvWrxbOWnZ4hIcMXZ9Px/Hk +Solvb/61wQUNX6Y6wjEDrgu+aqmys1XpebWPgTdSHaZE2TMDp12lFLh8KNTQ3NTkmYN6TOx1E3vd +xNbpJpo6ssgxScRA+vrsTLMlI5fzxRWVfunXkGeu1Fkw8sws+/lZZnAnzsCRKDHNvsGZ9xDT7Bok +UzT3cLQIAzRhzHNha9xXpArq7DFkm2e1cjS7FQjgNAJ8PsZ5Dbtcq9dJzK1MI1JMWJlgJznMwKgZ +rwDWYIt1oK4kG4hxpBHUxVLgGu6yTlf4DvvxGP/dyBQJAV4p+22YM/EB9puec44+D1ZJeM/FhoC2 +Od8Isa1GzDf83nFCPFy0cbx/+2zjNo8Wt4ljytnPz3S7lNYIiW9g277KQLLUujwZqIwg310x1oEg +VumFMh0oX/7SNemyehGnXP4ZjLzx1rAehkYfgFVTWBzCyXRU6XTre83bjSu9Q9h25Rv9OO9P1w58 +E4egfHRNvPhePjJ28FU2U1NQ1+Qa0MPSRkST8lOkjUnXrgbArieMw53M0gDajU2D5uwYuGauGLY5 +nq01nfo0UaYAjTBV64OGwUrvIELW9ZNIM4tWJTvnm1cizfzh5nZvYd1bWPdSzF6K2VtY9xbWvYV1 +b2HdW1j3Fta9hXU3LawTe+rVwdR4Wqwxsa4xxD6rjdXozRz32ljB9drHyjpEipXVIhPrpOGj5Q0/ +lYW1WGNize2pxRp767021mKdkXVqmsxNl9Mi62FPb2Zd13lmhMrMrGsGs67g59FOVAH3V5q9rfVJ +tRMn5+/u9rbWva11r6XYayn2tta9rfUJba243IdZjK4OSr0CUDMOijxiaDpKsGRtPSErFiN8x6Bk +bM0KrgH11Wftf27jqkHgHUJhW6sEujdWtmgzqJ2TyYWGtlUEsOHG7geLNjQvjYyrS9o8WtwmjiXv +hWn+zOx2yTsdoVGiydNZ4kKCJdPZSQZLpkzAqgkM9xw2bi0oGTyzgjmovBeUjG0ZKHVWsYhBuOWg +l/0H6ebB1Ffa88qWZDJusTLvU3qfgfoOIDdt49ZBBnNVrZm/cfvrYQ+KFZ9Dqph2jg== + + + UsV0FD2wH2xWfC2wH4daWLvZzdvNP1o3VZuKKkWiBUhrVgvWB9ihnkBE2VBCeTX2079d/PTzXkTZ +iyh7EWUvouxFlL2I8pQiil4emuSIGCJjq1za6ECZTJIKrgP1Egj9PZ0KIOl1Lp8MG39GISXogO4T +UpBep3KPFG2spjGZLaVMGh17gD7e6FNJKXSvjGsXhRSaeLxNa8fXuVSgkJ5LTZBevqDv3giCJa/8 +OlAm0KSCQ1B5H6jnbCfD6OwUqcZcOImgvLg5TDlYJrDBSKvJ2AnpOW+Wcj7N3rDxtaAnF0wmA05R +ZeMhZ9BcCJkOu4flIkc+9KzVoegymft7hZIvXhr4x/u9KLAXBfaiwF4U2IsCe1Hg6USBxIaT2699 +CgwjCBmLbR+3BV+8HqRRHV4vzvalDasYBWbyz5KgsAYSGzyZ9uEpg8J4e8+Ax5aBKXeOxOprYsLC +IyUbJP5sHogJe6zJaUjYI03ieLKDlPWfRxzoAnU0TUYnEDQ4RASgC5i4tx6SuPN1kGoMYeRfXHYV +B9aBunIZKFVeJF40A6UAtAw0HU0nFwxepWCwFJGUtd03NAV1sUzdfEwhXTHWnVcz7cE9wAcFBME8 +b4Tt+SQBYTzIqwEwC9maDjSDdUOLoV0DyNqRxWix4ZSv6c+neFkVms8C97EysauRvtJhu3kKC8ai +5XhNMsvdnQxESNTqu9vT65/ONwoBg/UXt3rARzoeRI2wQ8iEn0BFqA6D9XaFJLoeF2IlQIl0qemh +6F6nCoquhtRKBzk+IKjJQCcHLGd7yKTmvN1xp2LhVDZV3zc4Geq9550JtXI70JjVHbdTVtWDB14h +nEZtcN2oaSo5Mngo8B1uSSpDo5cOCUdiDoMpqxHfg7T5enngw6Xh8Yz06aNYioVtH23SNhgj+c+P +j0DblD7wVGtticPTNN77pFZz+AHq4/XiAhHK9C4/HIrMQ9ShgkvckKym5X0rCSTL7SIueF69mwCl +LG36nd6l0qlwhwzxOUcG1/FDLFX1oGJcbZG3WUx61FXQdTrD+67lyWC7FErZhkg8Yb5vsm4GXoKY +YAVCEdmTICjLdAAJoh2ND3jLe6ZSDV0F2c4Y9bJvd1xoXGve5KRDkz5PBns8Hf994mXvUjzqNo/Q +yeAmw897KgX6x5P8sZ/M6YRPluU47042gK/erBmVAMc1Thod9nHYxfGAxiMer91x1o28F5P5uxeY +i8GVWy/jp5Onrnl1FLLGl8hXLnvZI6WCGibi2/TyZPL5vUS5tVECDa71qy5swUvVa2LbmNW9MRWv +pTG4CKnJefqyDYcOgT7C1ON2qoEMKuuCfBMaDfVg2VDp1d1CDhc3eLRJg2W8FHJEfz9RPSZsGm81 +dzFJviyZO4yxRSfpbXp5Mvk8EbC6Vnh1yCz5VwkQn4WEVFmtw4/XAJ4+JmHSYdknWRe7D7ouTYp8 +AaEIlV+/3z/XhUfKxdpP5GKFnXAGl+0kBrZyAU8g53wTDnGrnesByrvGh6J7ncoWKJyqxYMcUNmT +Mqvpw0k1eSPjHmS9y7p9PBjEo6yp0EDeNB5ZUycMWP1w1B1u+cBdzaYRfqW2Ycjh1bCk1hqBhds2 +hzG+vhEg79h6uHAAeZrE4i1r+WiTloXYHTbN52ZLu/WuaNwBe9cEF5/RdlxzvdY3ASIDZHXN9V0q +ypLdOldqdhk8Rz60+7gYV1Xk7RSTXhTDXhbDQRyPBtXxnj1qqx1rCIhcp16wUbNXTWy3PTSGF5cn +iHYrPuAtLy1NxbV0j+mDPsW2Bt+Oa8qbmXRi2MnhGI4PxmN6jLvMe9Wxlv0g8p7xrti8a2Aku8eT +/LGfsdGUjrubdSH1WM6nKWRQy6SVYaeGfRqPYDC+0Rr1TXctFzMgA86xym6MzPbgvT/0X4ZRdsPG +3d4NM9UCxKRFESSIEw5b12Yg4c94uxZiKqk7C7VeVMRQWt/GnYo7dHDjJvnebnvBmoKQ2G6LsV+e +d8YPtl2lAk68B1wvr+97p8/HB4OdCFC20xOomNRbrGu9mPSxmAyjmA614HTgbs80HQVmzJfZvE5n +Gokz1l0JuWZJIo4MF0WAGywLpZwNFkbLLVyawWjS4uh+32R5VIjcYIFQcLMlGm20OnJo7Vg2aw/1 +KiqrAe3CouPEDqaDVI1mIK6hY5Kq0zMYmfS74EuZj1S40NLNKtXfAc4OGqEE3mQgYXFb3MPd1ZIA +5JXi79R8Kp26Nx7A8WRI81NAwZjZovclQr91kLIWobVrOCmozXCro6aCig9FMKU/RC4B4exKvW+8 +d134LJJZN6FGs6BcYUJpvupAMmc+Tqhr4PSTADwi4+/0LpVOhbvpi8/HwAhcd9dBRDhxihFaQ3pG +7el313QqXIzrL/oGorCYoUocWY0r25nFLoIE4VL1ek9cArDtJvVL36XSqXCGGLFhGXuAs1+CBJvm +RmtIz5w3202qvkyFi3H9Rd/ABHQ/jzHwh+gbvsqexi1rpXY0ML2bfjh4uxpPTj9x+Hoyr5OZn4wE +xSZTMJmkfiDjW3Srpjv7o/uESNJ6g6LwoSWOB6K2D7jtsSOmJ91n+Mq2OaQr+HkSXcBqRQkh3i3s +yk4JrkoYIUWmqVWB00BoGKmM5IygJuvhwuC5rGmiymhhi0ebtFgyR8hnT21B254uA24VJ0tW6f3P +UWvE1+ntybRApjdq4ovW1ZVVzVGjpRVyAtzo6x4XWAt6Fv1R32hTRhYodjRH4v5Tdq/0A1hX/AvQ +JnWJLdrPq0b6w+k/b24v7qL26D+SjPE5783GZea4trlw8KuqYG4QvrDmbaIJBLmnBt0EAAY1ZC9r +ofxwYAWrVp0yQw1Vk231ik/cSWq8OnO2wfFKbc1mZfX5+CBBWuSwUccOZDiCl6VsKtwGKmXlBS+P +poVO0Q+3raa+qdupBevbfcRamqarhdfMpkb0mtmuFyd6R63hdeCxpwUHQ0gcDO/lRbPZiCma1rx0 +NE5LwZlzVT9zBacXh0nW3ybdxdt9Je0KrwYHS96uW2XjRIafGioC3Bcdr/dMX6EipI7pF2q8mMed +z2V8ISNLq4yEPd72oABbSqjYIve0Y7vwqzNIvHdM0m50QmTa8IGzIX1Ax9FwGAQ1Q6pDb1nh1aRu +PCEJcqz+gaFs869qukERwOthBaA3GztptdVkhnKaG6P+yGWo6QWJ5KWAYPo4n3rY10HzH+KRFuW6 +UnfSQwOrsMy2tzIqlYkamdQVjrDK5AgH9pjd5Sc+foIrwb0mOWItYJtxp62itbakV+NG1K8DFaHs +qum6Sg9QaP760XDE3uRD5qz4flYwb02TzdtkmY+nK3+/e+sTe4xUmAPe8yp/3crjKmBe92q9VRFk +u657/R/nl3SbJ9n99glIL3a2bfSapJq+UgYSR2jpxxmQj/dQL1kGxSr5f6hJMmAxLlGMK8WNwZWi +DRAWN14nQPecyvRFUrWp1tQm+8FuZJDRx5PaRs2NuzPt8Tu4cZfY7+nvleZVRa4/EHnZmMJ2UeQk +6minM1Ax/rwY1yjf07lEvg843Ug2IqDoIPyaNK4vlqouurpTwwU7U7A3gFkuTLOalEi1ZdVO2h73 +bjoA7mMEPdROKaR3ro63XZWcBNlq8FjyKZ9+EFpA/Q3PjQzC+6FjJsYEw/XuARmkUY8co6SdLX0f +qTqqa50Oe1h6p54fIn5Z/lCzv6xw3Rh9Jcx44OXxDlaOY15p70jwoEISzln9IVXghsMA58dBJVEz +axx8uuHTk/LIIWWFowt8YZHD2qqJWhfCdF+RowOzb3G42R5ydmB4NpkeJHJeq0lKEYLXwDqMNdRz +TIfr4K3oGkLIW8i0lYz4aOOCd4CA40Em5uygA8nKVHWN2LU4TqGJ1OIZME+WDgMQIpzeEN6UbYur +60UwrQNvTcc5GXhDeCn1cDpMaSpeyI67u2X78YrwwNATqIC8Nbx43HnPduA732g7cKc/hMMlJ1Hk +lwqFcLbw3AFhxj3o8mnVP8lerzCW44MMFIJv1C9X5qYZAgIl9UNVD8pG4MTK4tMgLf2qLcL7QkRD +HxccV5ljuWSCyCsZZjSlXxxuZwcKuyjC99LmoW9sTS1Q0+oF53JyAyATCLdjTEMbPNoBjrqSo6wb +ODsQRWuiKCbU9YAQJ52FFIQWamG84HJaaSpW18pJP9mM2KTgCwI5JfS0tkbd4sEa2A4EbqqpWiYJ +dLCB9gAsTBl0iSJIZgHo1FUi+9Irs5JaihChK4KWcAFPEI9wWhBtraN77FrpILEjXQWpp5PhnFGX +/ix3xNO+vIWsws3VeWQVzJOwCs5H7b6ggAkBaiU5LYXp1gzKrewFRsFEkCvV5HUClL0XBI62rG1y +FqdUrz6TjuwxG1XUtGUgwwzTwYpftAqoDisbuPdE5m+bHMaaGJwDQLsGoKUAkHoR/9LXPBnwScp0 +XmpZW7OyKzkA1dAQAScdoOm7GcBywqdsCuqKFaw5hDUQeJEzf5Fe1aITBYa9oU0ldSn7bNTLh9U2 +n2+TyPFaC4tfyZGMg8Njj2u+5NbU7RZunO9uf1wVq6PLj9w+JmlRzdxtQVmJnCfp8VUHcfZQSWXQ +i3vo8EyCXGSggp9X/ecdINWI0zSBBCX16I8VWEQYGcQOpV9nB+N3XQ9j4XGPz2YYdpz7bfwAgRDG +w10E/yI4lcyKw4FbuZWc3wjqgb4Eul+2ZZVegkf1Qo940QelUdz20UhvnchivXlnEzXdzD59fn1d +1GIaiLHDabSPTeNUTy6DHzp9EhcHeChkqrUuML5HuDskfUsgEcYOyekgXXMLLEkAYdpasq5ApQ4m +lM9owCyrgUiGsyL9ICKZkqocAliy7kv2z13tCZR6kGpIXez7f5yNZZZlEfpNDbvxnuZfYZudXjIj +XHazJn5A6LeRfxT30gMvmRHSBC9fE+QQEKZpGhUdbONoOfQlWFZptgrYMr0nBa2KBhROzlTZZXWr +ZynvT4Cs2MBq6eKzzEsVOFVSN9RMPSDO3fFBApENqppVqgFCWJPmjr+OeXFGWzehAxUsXfWlO0DW +QgaL3ejq0W6m7ieVHZ7riGqW90nkBAt4IFNY5ZCsrQiDgkgvDoh1OPDKHE/6dawkq+rfJRKVCqfn +fLo6UOxFqqPQwBJXq7aQisLNoqknrV5lwNS1cdf7YWmw9WjU03mZTB7LTSc5XwMdFyOvs1FPpmQy +gLHxsOkvVYA8U/eUBsKcpUHb0WAJd/MeJmw3NLP01mVQS6d1hpc1pI4E0MNOyH72jYUPtM1qSYDU +1NlBB4Lg2fgUW41qELptKHimtjoI5RPtUP9V1+m+qsnY5hyBxj9EvCGORVKjPwvebtA6W6t3ud7S +0hEaTHfIpttAumRkl0i3pU/XfEeYV2ELbLOxLvqnaOT5YTJUEqB6M7LB2UeNSKWhyurpALGxs4MM +1t300VXUJpVGai0CVBMVu9R91PW6q2g8tk+fbjlnhPpXOuHpQROh1iIEBwuNdanXUw== + + + xhnXkFqY+YXtqRg/0YFahGE1ai1OKYJUdQYtkwtVB9CZgjiVfRPj4PtaIiC1dHbQgURKr6LPrtaC +5Laly1pKAJ1c9qb/Jva3r2U0pk+fWahDEPihuUTiA3KJQN2BOLcSap4qx+UWrkSlXsyjQdYdBJvW +CnPRkCApxlHT5mP8fAeALsxF97EIkn3aBqNK0FhPBoqNUUvVwTy1H6uuKhF+qtaFvrkEgHY0dimB ++mHEWsbj+vTJrUTGxNV2nNz0AJYETAQvZRKmHE3lhCLj/2RHNxoHV9I76qqHtDFmREg9Fa4FQ+YC +EEwVTh0AM43JcD3IQLyGnJ1q6QCxIa5OB4HCcNVVgnQJvBopNZQA0PzEziRQPgDWMh7RZ6DE8O/z +iRbHh0ITnUHU58VXzuUSRyEI5y1IHc6YWsPnOxhiNOlXCKV2W1JdbJSHDvT5cj1EsLEVqktNWPeV +gboKvGBXUwdJ7WGzJ5iQMGcDFyPWBNUvKU3XXoKcHfS96r7qet7VNBnf56DAOEPrRIH1ARTYqR8c +b43xYP7vPfScCKi1oYLFlC2FmgSCHt+qHbOuWuooeXLA/IgQ3fSMbaw6/ARRF07fV9EBumbODnqY +wS1HbpVqUX2L+huwoQ5wdpD60oG6/sdKJuP5DMgsc2jiMRd/I5VKkAPV4ZgzFh7mOTGm0DgiGshY +5ldUB3gasuTEDG1NvTI16RY2hTYGBeOkETKk7CemFZLCMe7spB9mZ1C3TfKPh2OTUFIBNIlEMIL8 +DC4ZynHABNwww5omxmmj4cNCn4w1koK6D2QpavCqhilHvDrFwRKDe4Z4660I8y7UDTRbDBKkQdIz +4wovmyIrcOhUiR+9tWg+bPgBFcfHPPxdq8bCtK0ZekZ4gIVkOG9n94YOVeoOV7Z098IsMpdH2cIY +J7PmnAZY1ukPgHTDhDECrp+1RcqfJgYXMetOHdPvNCGS4WB1HzDoVQ68CsKc7jPXVhpZ5AU1ZCZh +XZFfIhpWa8o2dcDVfw6O3o0/LOtW0z9iIpL3hS/bdl6zcJ3DWoVKrRIiodu1JWsgkPMa7N4GpQzz +ekw1Ef2XhcAI1x98+1gKocf8uhYty9Ncr9w0sgZ+pp9c0jCtUys9iIAP65loxupphVA9B7NZATfG +FluTXjqtD2ro1wBm6swrKupLbK4aXidUdgjRxal+LBXVGp8EEE6BOrnlOFge8dyqGRDP8Jg5A1ky +6rokEhTsqrx8W3llWoZg0K7JBOImCRJYnDxMLSBHHFnkCo7g2PghelShtyQfQgkiw5iSdVrs+Dqy +JxgiyUdQFqZGaQCQ1OH4gNQBXKGNTjGJIYLGRYpMZ24zeoEQxLolSrZtzb+UE0rYNYWANjUugoDi +yciBVaFUiGQD9jQyYDUpNO2HNb28kJfDtjaymq0hq+nxlewy0A2RtSsIcjTJBPlG9plfU9408Jlp +Gyg0DAgl5Loj5V4aNd7INMNYMq9tUIAK2ZJo0gSBQHqUNUVl1/PwpSzdeq/EY263oyxeq86PXqSf +Rj42WqWn8RYFBjf25alIk2szZDs1NhqnW9VWV5pkCQeza1Ts4nFOz0dDRzlNoAI3ENIZessdhtbQ +KYEJl/iVJnp0zM2gF0zyTrvCkf+lWsJCm0E7YaOipKnVhREumAE6Jzh+U/QR8hNCo6Z1QU56ltLX +Hh0E9wxDOi95xfYSvifJ3GdgiYITjhv8DmUvZA5U1oW+BHhG78HaAxeOYXaU01ZTClKHYLUk2M2m +UgeCwcxtTEQqWN2Alq7hwWaMU/dA2Toy8BJac4xVGjukSKACqj+MujUYPemuULoQNMuGUUWASBWB +OhaD1Ao13fXlSLcwLlMn6B2cWNs1pa3MW6luO8bJUStSeUP/eRi/XJ2k1rKd1/AR3dVK+M3L95XX +m0nG5RDW4FsEVZQechCLzeuvsNolTKxkWlqGqn0y3Vi8ME9yNYnISqUpX5pqDHO4q2GcqjJ4sjBX +Xx1aZUib4Cin1LIHKYJRlYv9ZFvVnlGXrFvMVOogpi5V4FhZcaVSDgDea6EWIjdlO0t/HWZxCrw5 +SI1q8Jej1xcN2rV+QqdB1bVGpWfQLIcFWYqgPKxqQ6Q1OolBKuQFWGcka/QoEISD/tnwK0MPRE/P +Xi2nlhwfA9CVHFJEoeeZqk0680qjd3hO53FTuSU4ssR6G3j8G6GCp54BmODVkAeeJz6ZkApMgVOl +hWAyCbXxdKiXaTeqpvUgw7JaspVbYSdazRIjxKBm5h2ZqwBBVO8UG5XGTUCH9OALocQvp7kqwYy6 +hrFXVga0rui6ho/0bLKubtRbyzi7tqjszJRnBn1T3mVel/UW3LYCDeK0GPPJ4svS1Xka5sPV8CZ8 +WTICLzH1SLTqwkPHpIqMBY582cEaeopYCT3fuevh5Q4xRs2PJC9yGvOW3CCUo+KzWreivgVyMdyc +hF7UUNhSH+W96qmoE9HIDEdfvlZ3qtM38Nv0JV1EwZyYaMBirLODt2SpWzZqnJvD6PAHWCSCjeIQ +IG1l9CunMSIlwkzo/au06ZhOsarikrO1rGUUUBXB8x9UpK48lTHDiduY2fD0eTzUWPRD2GWEGCET +uK2F31ZFmkyCtOt86JUcLZJrCcGw8PaCVwGc1UClK6caA/BR1kehHwfkDzRGe5zTEMV8G6NwJ4Vr +B44PutKqhumi8XXScbSgSg6yPu6pmNPqkZqKbGUo7tnSmHUFhQBA6FW1HBVsR3O7KxRCsBRKRJoA +yrYMn85pLFuVpyAQ8GYuG/fCfAboOxMCFCa7IAZet030UK+qqLWsmhi7VamvrkiPrTpTWLhO0We8 +UudYwHD0e2S4sfoRNdBwY+bX+kndRpVDi/Mam5EpDU0TfVlh2mpJDRCbT520fBodsBluEzRnnPIw +pd5YBwJBB3c5bEjVLBzk2+iLLlI23GZBMFoavpEagTmY1QnZUk3jCICB8Rhmi5JcBt0Fy2jshcc3 +KBmpzngSN+YrmCuwVB9P/GmppG9BiXyoPZK4gcsPMbYtWnVsU4JFr+NmjrnWveZs0uCCIHL3IbUw +QXg3qdKqbAI9MXQErROoK+t7SjuaiOCs2FRNc8iQqyMaC2rYF1W3Qe59XttHuCPTNU0ZonLDu/uK +glVt6SkgKCPvVUaZ2W8Ul4LUbkQ+9pO5i4Vr9ATEg2kkhLN6aRlloNloIw8P+QNbHApsnK6yT+hR +7Hzcx4IlwhOoQQ8nuKWDEkNENG6QGxHXclB8kGcoRxFYozZVYQQQNYELRVQNQAYfagdpR6NIfIyW +gJyIvy20Xo7BTDz4aX1xFfiXhunV4f5VM2azNSAHcgbSsGFo/wC9cTEeSghgDQriSk00Xh5So0mH +PUs3co2XYfws1btCzUC0aEyBAgzqWKF34/namMNoq5LhjRXzXUqbjYbYGLBrVtgZ4esRMdAGG5XS +qs+AVbBkqIEXKWqF+z6tV8c3R/JP3pwhmMx15upaiQYiFqHSXMHzT4ivHPnTwsIRwBYHKcsK7deF +OeI8ephBYCrzcvzOaxZ73oPjQMyJaQK1ytOCNUTElIAA6qWjud2l/BMwT1IWBM43n85lLF+ZJ1Fo +tAjNn5s4/omIRec+nt9f0tI1J4Y60LGrA8HDirbsNsaJycHGfBrppyrW2+hBQVDB0r4r3T+nBlRm +iLAmqQdiNQiAgOGr7H8yfElD3SKk73MsPhnEvfu4UWN2TJ4oUhWzXoQ4ISIdyZzKoRZFMGGoLQIB +7SSrIgUs2Ji8HIj0IM/ujaiQ+BBbBycte9xlDDE0PloHRxb/QOlGaJNvgkbUD9MqLmz6aGnTLE3p +TG0ncfv9Y6gPm7qmThEpA85AJXijboBMek3QEnTildCLEWrjDB2z8OuJPP+z/BvuafJvaHhKn8G1 +fKIAFWTHGAWoKOgTAlRw8N8XoJK92weo7GyAyj42JWW9e7bYlE9MfLcPUdmHqOxSiEptHwxRgavP +KEIFoEcCVMwzBqiYOQEqdGsaxKfkA/tM4SllvCE0PXQhKmZ+iIrNokauclgeomImISrVahyiYsvP +FKKiFQ1CVKrVJETFTEJU7KCi8dg+U4iKjVOeHroQlU+NUWnGMSrNJEaFYdeDGBURYIcxKraZxKgI +aBCjglqGMSrNNEaleYEYFRvdotNDF6NSfc4gFfWKHsSofLYIlWF8Clva/fAUFSvz8BRC8vAUpoPZ +lvAUdiYPT0kD6MJT8hF9pvCUmEGkSA9deEr1LOEpHPMwPKWdhKe0a8JT2nF4is7etoantCZRX31I +4Sm1+YzhKci3vi3hKcz9/irCU4gyD4enNDPCU+yM8JTINXThKWYUnlK3nylABUmjPjVApQ560G9p +hEqjMRu8tOPBCJWqi/ewa8qmCJXm4QiVMK/ZhyJUBiUfjFB5uMf7CJWXjlBplFHbjQgVKbM8QKVx +jwaogFfZB6jsA1T2ASqbBajI1AwDVKDlzANUyraeBqiUGwaowLtqEKBilgeotKMAlXYSoNKGhwNU +ykmAit3yAJWmC1AJMWaDl4PCU1830+IYlUH5FKUS1kaphCSr1mZu4ylOxaQ4Fb2XdVqUoSphfqjK +qDiDVZoUq/IZPEj3sSr3x6pgd3yWWBUfrxTsYlWiTq+PVXGbxKqQbxjFqthyEqvSTGJV3JpYlXYS +qxJmxaqYx2NVBvP4ArEqNio8jKbrXR8yYkMKGQl5rArLxMCP+0NVYM/TUBWbh6pUMVSlbGa224eq +1DFUxa4Pr0GoCu5CWROq8kiPY6RKvY9UecZIldIMY1XMo7EqfhSr4kexKtUkVsWOYlXqx2NVeHHK +04SqNI9HqiSOa1siVYwGqvgUqOInISOmTSEjph0EqnSBH9OiMUxFGKsYphIpBMNUhPxrmMqaguva +7MNUXAxT8esKMkylDClMpWkGYSoPdHYcpIKDah+k8jmDVJr2CYNUoL4cBqnQT/HRIBUzCVKp5gSp +tOGFglQGk7gNQSqmC9dwZnaQim/Wl14YpPJo2/cHqUyKzgpSua/f+yCVZw1SgSJxFKQCZ5NhkIp5 +PEilHAWpVO3yIBVcN/LUQSp+cZCKHwSp5PP1AkEqIhc2MUglRotUKXAjPBqjIusaoz5KMy2cYlRk +68UYldp0MSplG2NU/LxWuxAVE0NU1hVjgEpYG5/ycFdTfEqzj0/ZtvgU9eO5Lz4le/sp8SnNQ/Ep +2ct9fMoux6fch0opPmUhMt0fn3IfOsX4lIUItY9PWRuf8rfvvx+EpXzeS4f0jlQEEsCZnS5lPcgf +JtRw3jMOtuWqQnkPD/8EOOM1m7jXr/+kGdbRPcdm1EJDEK8WZNoMrQPND5pJgHhnIbrSfZP62lUy +Hg+213qs+uHPJ//407eCUb85u7g9kwW2b367+poX4JRYdXmZLXSIWQgoPRk1aMFHRlMFEHQCkBCO +QE5HOJ5GrVYOJiPaLOm60tZ67WMLH6To4Ylh4gLBMmpwqhImIuGm6JiPBkrDQ6iugw== + + + msUiqEAID7IGnNBvxtBjmr4wFa8VxA2rAq9cwONwCMeTQcFLnstSu2yg1Gc3+VfwWwW3At+IUKoo +6Xl1NN6ERvVREYI78kITO62whCYnBzbdxtvg9kC22piKvtqtZowcded40sGT57iaDIvjVt7gEl/D +v/QTArhSl7btunTp+/PT27Of9U5pjST67JQDSnaEQUO+QMqnK4ICFOBUulLRASMrnLBMtHtA3+Yt +49W5t4H+UIvJzwpXlsmxfMkdIXIPXZxbX6o3Bn1/RJiq6koBcM1awXUAdyjQ8d80aJzfyqJcQirz +zlekIE1tKC3JwEtqUtgmrx7DtZdwi28iXbJ6LQPFIDm7LhmLQAkIF6xBMMPNvmV8ZkZF2GdAIdtD +bryz6excEksn0Sft/XEoH+N/WDpK4zMWD1Ejk2VR4OKFwbk/WRoAN1gcKTZdHgFuskBSbLpEAC5e +pDWzhZpwYPyDE88V+epNvyZL1wIqNktNb4Bdm2sBb0ZoABzKlAhNwpfQt5U0FXgbGgXCexIcKcTr +JsQPR1XeC3xH8pI6/o/8UpoQhZUnuWy+hYxtiFA1bGC03KqnfQIZrxpRACywEMqSlscANB4Nbh61 +4dCSQ4WZ02ESeHGs4QlPERa3tENRS6VgZfRkYJYunEHQ4eKWWxiE4Q4El090jQoXl1xA4VVW1XUH +8UhiarkMwt8HXoxZ88JOL+KgakidZqlLl9XymlzDxJimdUEjoDwdVHiLeMNQOBkN9wiwsi0RIybC +gSqMZVKQ93I8bykAL8HJScl3VweI4KNyNoEEeyrvY+Z8Ebm4bRpVWuM+06B3uWJ2mHNUeG+N06l5 +X6he/6g5DWFn1rz0mCst5/TuVbjutoyMlN3ka2xvvegX3jpw4BCxyUELcnwAnx0N+HBwkQMHQtVz +Ex3S00KkZ157zl8JAusa9PHqTW4YulzqZbiWPjnHMLupf2GDKJ+aCWLiNThGldayf6LLcnVY1SUL +WfrqUbWmMarqggiNlUcuWt6Hqfevk0DydvV41wlAjdPrNUsTlGV1NC8KEnpn+yUZr9rxZB0fvi8S +zqGyJMa2MzUaz33Pe9MKc+YbnAEN7nlvgSxwQMBluVvID92d3q6KlYh8v/42MkTxDteZZK0Easi2 +VgkJTlI8PHmX9MlB3PNBnUBLgmBitBVv+RURoIosekl/MeCsN6TUJWXguq3xsOb9mmqmjU061Hd3 +ToA14qtlW5sapzaUpR7udNDg1FUL7ddY62VxLbE6DRfxN/SSiEQWzpx2zLIehIfF4GrZn7QlOGgp +oVJ2pUNEC5QkQlihQKzi5c+VMAINCKUIhSLCx9hqCEfQd18dwK+/1XBQR432iYCaij6C/e3UTeRB +ACp1+iyvy6LRrm5hheeMOtweBd8My3IMUILZGEYOXicLrz/DMDs49XglA6prhw9o4M2xvqamG+sB +UYwLgSjTptIreCfvi0klxbShYtqbYtrlYs3AijXjL9ZMU7FmNrPZPumjweEXgciEK9TtDSNiGvrP +sD1NxCtnZ81qDYbhGMZ8wn2T0oBaXkpc0nnaKlEdvxyUHda7puWsa6OH2ZHfGvI9GONXb9Y0JTRy +0BuhW3lX5XE8FNTaj1Q56/EXxaiSYtzIuvkedPfkYBja7ZvI6IHQyakvyCGEBEHYbcwiIdsOKtqa +ri0J0xg200Zm4QRSlMbj4NZ4WHcwDuvpt+g05I+GniZEeyTMXMdUcjMOhHoN67hqhs4lBRLRB0bl +1wxx953T/skBnPhAhgp62Ze6h6BFoOnzBHJerTHJ/QcIcKMqpq8GwXYa8tk3Rj0mrqjK+sToJYQc +yIIwEulkOlMnDyi7MWRhtHg3YdHUcPtSp2M4FU7oJkKTGxBzD0YN7J9H4pKa8ZqhqaKWGJGnggVg +c5VB/gHRtMKwMPsx/NYQsbKuaB1UoRJsE41AR2cbt3o0t1VYlRq1Y9XQaw3V2vfxIumkL1dnN1fv +bz5ev119+Pn0/fnq6uZtfsw/rBZfg9eq6B5htgJHuE0RdBPsVs37CL9BLCYYLuLjBMe/erMGy7mV +ezynyDzBdIFOcZ2kYYLtUW8/wnedhhHGr5nFk/v18QuWLlOPm+fhTJ+YgezzRH38VPaxvZ9/dA/x +j/TnXcM/VpF/HL1/lH90Hf/YbsxAGjWZthAEwdSZxppABtLLXlqTn4dqJp+SN8SHGAnfGqSFah1E +0Tw/z2fKzjPgIC1dXIYcpKWH0YCDtJFbWs5BOvJscMC6l4P0n4OD9LM4yLw3SzjI0fiLNdNUrJnN +eRxk2y7kIN1DHKRbwEEOW17KQT7EMA5rnscwukcZRrcJwzjuygMMY12OGUZspI0YRkSyPBXDWLfm +YYZR7fFt08xiHIfVLWMc7YRxzGfsMzOOcNVVFq5dyjhiX5KF87P4RtPzjRs0ejSz0RdnG4fYvZht +XI7jS9nGIWrewzauxfYH2cdxtcvZR7uGfRxi/nOyj8uZuYuzX87Bz/3t/O0mzBzsaY16kMMKjeSd +Cini3wROz2W0CfKb7uX0q/Tr7GD8blw4qzj+hJ95ALxGGBpMGcAJZzQMXpCgLAO8NYXHK+uSXwaE +Op0guY/xjhlMgledWyU8QtdE/HHcj3wWU2gMyZxtPQJpwLuUFaxKJV0bQA0mdK4GVqXLpdNDQW6Q +yIbk2pr8ZKJarKtKKAz0mDLszu/KmfyHsyLjtBxfCBomRe1iStwIq6hmbqzKOiSA/r9IUH0s1e9V +552pApD/pYQZVEP0mBrBMS1Xa2gCMPSNMFwiBGJh4k2NA5rpDsqKfC3icVIT+leTPWZtx36NulnS +WDPsazH5pkh19vkdbUTklEZS/8sBWjXTvNcMHEov+c7BTFRSjqaDMTz/DOx5Dv4SvCVQ7wzFs2NW +RkAazaFDiGFMvtVno8+N6x451cwSWzNvFEgR58x4IDqdjh1TUDFAO/Y4HwX/MpzPrnTMx3HsmygI +nY3nxcOTpibmB6btjNbkJROHTLcLp+6rN9PJuxf24JSiuw9P6iS7ZJtxlHu6OYtuIopS2Qie08gL +xsDikrKtMWvsMT5ooliSzfRQkK8SsuiUN6sb5c1G6W69K2nyb0XabvjDhIqZtIQVVSIpTBrQokQg +POJSSoRGIVxpTzb3ZHNPNj8/2WwGgji2BHgikT9CSzeiBMpuuQKTD80NOkh9mK/4cQKciaBsNHo4 +QpAeEEIDvHAQOMKsOQxKDofMAgkJUBOfFXS2CS2YfuYRQB3Vqhc8+KjxSY5UiwD8nw4qORiARNbx +21i9Rw6G5LY1TOxQafI5Bw9Yh0xOtHpqVmDNweRivGScCFSSzpHBXD0UqADS6mSuwZEWlcU9k4h6 +gnfbGtbUeRH1qBtDOnEEQ1YgCUblYyQbZPCv1Wsvg62jf4qI4DUS2PEqKaSAho/QmqLWV5q6TuRw +5C3Qi242bPRoZqOyuLDFQ3q3DOlcEJCwBi974CLMhGC7GDe/erMUO5XyzMVPHctSDI1uewtxdLT7 +zYBpGqxBOms16aSeio06NzaghvCChL4Vc0LPRoMjvqx5EkE2kgO9pUMkNVZWfnvfDED4yiNRUlMz +I1GLpCdSdR0ByIbrmFPBxVy60CRbvRE2aGbz9rBLXcqkT0yzwtDloCkbmZuFHlYAUaV9AlCMwsZX +jlrbVn3o6PanbBnzV9dUK5v0HNk5XioqGxjR0uQrWrin8UpfTLorQbgbxk7zbCyNZmhmUrKTAzrB +BvAewaulBNFtPCPoHnhCXgSuheRFGuVFNA8uIDiDALGM7kZ/bAAe1iXd88bsSfp1r5rQ1/TLkcpa +JnyvgywNQ6rach2JAobVPFPhucMEKA6BcbxJCzG6qnZzmrosIO8Rk0D+wJygIjTrpgwwBK4tWtW4 +pBlJ2IRccsccnW3c6tHcVh2ygyLhkwm8DGxAo8wwqewa5iNtGfVdXrhpQAUm2wabfLJxAFy+dYQx +2WTzfPVmzfYhcLyBBDh/Cykvs2QTscRoGwlsvJHIfw23EkDjzUTYaDsBNnND9as9tmw09j6SOmbo +mISYzpx1vDGBzxX8W/W2AD7DehrI4jFlDDYEJ61kjHxdITUdVMBc/qdi5EeQB6lIKbsKAqJhZjy4 +uiKj5jodHBGjRA4D2afIDOvkQGNoe6BHNi/vaQzESoM8qU2rmWeRRAaRPry0HbgzLlZbWgalWIUA +opI5GDdp7WhOa4E5Ppm/xSIhzzKyMUULhS1CDN7NsRQ1nlRUGewJt2xPDOtCJpBK9SNMOeJhIsKV +mw095J8G5+/BcGeJ4ZWFegAakFpzEIN+lrTFTBQmcmQx5Sj98GIsQmXA0yEGgcYYMsdMu8ZoedfK +KPWkFAL1/7P33vmpJEkD4F6AOyCDAOHKV4EkhAdJyIK8xUlCWGG6p+eP/e0F9jh7jb3GXmPTlPcF +vGn1a7755g2qyorMjIwMlxEZScROeZRYYvYpy4sXk1FQ/+Ux9ZHwTgh0GSVgbkkx2t/YK4uZLLqk +EF74LkpKF71CISvgS1IpfO6upnnXRK6nGu9rvTIi1hAss8pDoHqjCWhBW/rN/RkQx8LaBhS6rIOA +bg1OvOwChlWQ8KLaquoRi2+egpdJo6Ja4lfw4mvcAP8NdHT9I3hGrfsqZoAbM3QOryvWjrCqH7Ll +bkri3UQmSRjM408SKMoGJYoaZYWcNk/zOIQIFl1Ddz+Ibzhk2tJ4fEiDAyMmlYR9+C08X4YpJg7f +gu3IAItPm67vsd+c934pdAct0D+VvTSHNw+jQ1GFAGLoll8eX4GO4nSr6mcMvrQ4xsGUeB5XRSEo +GIypLLn4JO8zPAKrp/8OgUZtRNDKA7H/vA8N0pYGfj7Z6jFtreck8d0T6OoJAuUC2tErzGpmHMmG +R04RLbVC6I5fAhmEWLyWWL10mvPcKQVzomhS8KTpGCkZPjPSsuapJ2oOvJrQc+B1IYoGn+lpGjzS +0wx4ZKRr9UPXlA3jKAy0DVGxEHVjHOrHaqRwrdxjSVWJNpV4ghYrvCUaRuIN4F6XuxP3NqPgE11i +z5H4on10jZRmurxxI/Py/tN9FTPAjWn7ZtAVBerRVX3av2x9srBSO3TBwTtkKJiHCdVlq42Mr8wk +CHSnL7xXT7c5SELA+1CgkDePptSbGeeXomsK7L9lOVyPQLWbF+g5571nMgmEHlRhlS2tWiNO3LH6 +J0hc4KURn0C/ShIXN6OBReVXVgyKeobDwuKHEZB6iByO19NNI6afpwE5+dUSG7ooU3BccXg5BaxA +oKU1dP8rRzl+DZk9LNqopTaPXecW6hqm5wMR4hyJt4i6TS2nbpN6dZsTDHoLJ+i4OxIwKu7OCQa9 +RfVI0ltUX8UMcGOGziW9hdSrWqQ7dTsGHYcCiQLi8dVZJMx+tNNfYsBMZFh03QLSCWhOu6JQ/aCh +JUjTSpUP1dfQa8hQjl8LFHaNaq/I8tp3bpG+oc5O8Byv1buVFeMkxsfjv7COLNat9A== + + + S2oCuhEIXqKOlAkGRaCSyK2a92n0C2jgVn0aHQQaphotRSIiXpD/1hCRoGJ56IYc6VHMADdm6Dwv +mgvqMUrqr3oiCDgr4Glq8OHA62h4ISwrkxiw3JM2JIYdxgS+jJpmTJgGr2I5PDTcddyOgfXQaMev +4UVp4snjEn3nFuobZrLDukUeTj21BCjqtjIJYrXWCxEi9VVPhuqHrglRMziJFKF6uRAxSvq+lhwl +bdUtQerCwXgrlyOGShrsacHEnhYMFohgsEAkHKjsafUj0Z7m9NYHpwKtPNDa07ZM/ufLJT2mf4U9 +rWXp2EAF43JhT1t+6WxPO3VqbU9bfbmEPU2a2NNaWtY89UTNIs/R0rNoT3ulaNGeJo32NGm0p7V0 +rX7omrI1PEpvT3umbsmeJk3sadLJnl5QsWXhn69no+HFpDucdYcfsRh+jNRd9Qvf2Ri+EfCbi/4c +/Hve/Oq0Zj58waQ/N5lPP/2njWHjozMBqnG7Mwnbv/Pjl/lGv98FO3X82W2JLeujUT8BVOzxLO4/ +/6MBfhubAjUAgFC3Z23bmzRFIEr9xsyxPY3aX8H0Dm1bBMLkA97qA2NbPBGSNX4BFvR8eNGYfWpA +5z8bk9ZImSRohUCYNK13/jPzF7p/dAHC7YHWEYjGuDMBbLM2m4x6HTCwOF5zQCSaFV8x5VggBlCI +GinwT4gl+P8Egf+L/hJDkO1Gu1DnCvmhrin4H86Pilzgbslf0i2tmzIN/iNNWPWflfeLUQ13A+qW +9bOSxEz+6k5lHMNOSdQh4IV+GiOZ/AX98jok837eK5JXuQPM9iQYl7TTETEm/JJWg9uA5n4q4Zf+ +AzGV8CN0kXFK1mwWRZ3FiOoaDqEbF0WYD+eXDUbF3axQBG9N8HPKuGDEDclzMIYI5kei25hgXCaP ++B80G9CoCbej9kwFSfxGuop56kucDEd/DtEfQGYjuR72J87ANPxRXyIL5PkfHeltIi/mGJa6fTAz +2B7QSHfoxw3wU6zpJsQmUaAsJG66026zjwAaIdRmjVZvKQhex5BrTLst5XO8yJik/Ofv79MOEGik +9ffiB0f9/hxdhjGaxBvjMUAaXhzwUUdEX0gD1F8FqPQX39/B2oHW9e4MgaNQP/3zidgYDNDulu7Q +0XDahamd8l12he503G/8hf+EKZ8JDElcNTCRKx8gNp4gUSUtASb+oasceEbgNDl9gpTKB3P7BFQJ +jaRhAuBd1ty9CBoYHYwkVuMThc67f8/v84dUwwljZOIbSvBzjBxpVlHfnh/N37/nAxhtTGYmK5br +d4ZtDwtuh88EAqbgyp0TVZmc8rnF4G3mkR8N2/PuzM0c1FBWvgMg/a0InfL1M9fTTvGPzvC83UYk +CbtQkOzpthexwIQq1cu01gSysWFdFuShQhfvwSA9GhavpTiLchPKOsoD/M1p8PeZki9R/E+nNYdD +QC/Qt2byDN7fxq2F2m8m1Nzyj7UwWgujlQsjMwmET4ZIeAiCDh85HhY5hLUm8G3Pawn0N0og6m+X +QPxaAv1mEuhqyVuYLYwqE6pcm1RrKfa/N6k832W+Fmj/8Cl5EmjCWqD9hgKNE2gBZddR4H9Z6ANM +CiyN735lGXiXArwhQPRgs/juGgLmjcCCc9Z+QmrtKFxLtR8h1ZICvkqPoXh0xyQLK92gKBSYQ51c +ewr/5WItuRZrv5lYW3sK19Lop3kKCVG8rIXNv1nYwPDJtbBZC5u1sFkLm18lbNzkHqyFzv9uSoak +h79B7NA/W+z864QGdLxRPAHL5qIb8tB5EckzDKOJz+N5imVwTWmCRp44HkbzsT/rKGlBjv278FtS +wJeOE7AMCLprEnNeljUp3uWR8f4+PNgTu2LW7OrHsaulqset2dWPYVfinQkELdDw2AdxK3jlKMeY +Xd+x5ldu+BW75lc/jl+t1avfg19J6hW8359U1CuaR0X/1vxqEX71w4Pj/3X86qf4EP+5rEZh6pY/ +8H9Q2SVPfGnNTRy4yQ8PdP7XcZO1tfYjWNKq45hIHJ4LWFlSQLXtWD7JELgkKCEkV5Dy+C/lX+u4 +1jUHdMcB1+nv66PdHyYNkgxOQ6J4Hl4siG7iTVKsyeWU6zPff/iUPAm1dVTr7ybUfoqT4B+2a9bS +6Nfmv1MCTTOoDCy8T14AihUqg8esQ13/3fnvHPGzJdC/Tn6s3UL/TNbrZAjQ2A4geVhyDJb2oEjs +FGIohluHIC3IvdaB+r8b/1vrz2v9+QfqzzSV5GFuvT/Gc0DmwqCGOE8wtEl14bX+/G/Sn6m1BPrN +JND6WOJH8JO1IPvFxxKoVAzJMAy6OoaEZWaQPUIK/PL2yO9Chb/PlDxJtR+eibaWamu7ai2O/jni +yOa2DTFOnBLWN/H+yy2pH55OuJY5P8aSWl/FuxZcP8eOAu/jDAOoGdtPHEVx67s8/uX20w9PNV3L +srX9tBZD/xwxZGU/xSmOAAqWX7ofgOVYml0bUv9yQ+qHZ/qthc9a+KyFzz9e+MCgCGDBc6xfduKx +yeQ6o+VfLnx+eJrmv050QB+cwPKEAI95OVbgSRh/yhEEj3xvnMBTqNg1Aa/UgU9IpXgIwxM/rsjw +vyik2LT4E44j5gQCR6Pha8EohiGW9zn9PkzYE8da5+D9jjyPY1mS4dDFYjyslW525QwNC6onMV/E +FdYFVARwXTBprXf//ezf6eyBJHFmX5JhSAH+YgiWZXBSCZlkuHVo8r9bsPE/PLVvLdgWO1BnaCIJ +hVaSFTge/SAFloFaPcHQWIzxAkOT8AcJdXlK0erXgm0t2H66YOPEm0TpJJdEN2gxAkkRqJO4wJDk +usLtv1yurZM+fze5tj7fWIujH+Vmw+cbDA2UaHS6zlJxgiKARRWnyCS1tqz+3Ycc/Drpcy2B1hJo +LYF+oQRiOHjQQwoEmUTlFDghTiYFeECXJNYC6O8VQOTfXyuQX2dorkXQWgStRdAvF0EEyfE0XDqK +jzO8QKKiicT6dGktgn54wuZagKzrE/0dbJOmENtkKUFAsbEMB+9ZQXXrYBges47TWozdrHPqfjeG +hWJTKZ5Gyd8MwUA9Iw5zwFFQlhSmhRLDgRUMRR6PI7Z+WEzqP2zXrTXm/0V4Fre+YusH689/vzj7 +4dU91+Jsfd3JP2jrrWXa/+gSexiZJTAsoGQYe8wSjBRxTNIruMb+d6HC32dKnmTaD888/1dKpHXy +3z+SFdsk//ECyULPEs79A0YFsa4fsiDD+qXZyqbs5grC9OdHk2FnMl0Vu9EBlVmM7VoA/nPVaQDa +heQ1n1ptwZWzXZHduf7eI5/8RW7x35c7LYifNUfRcpTJpPGXvzKadP87Gs7AtnoK8ZR/PHsK/6N0 +ovXm/LdvTix16pPGcPo+mgxWJaJUAN2JJxk/M+nLi8YMjGGIJBUhCa/B6I/OzevFTHqKv5l03vtA +277TPmwM26NB978ds6b38CHjTxwBPSs07g4vRt3hDD5Lis+G80F+NO52UEc8pe6/oupfFKmjWWPW +eb0CkrWBB0wS8stpq9GHY+5MWh3chzwY9KraHXZMwRU6H5MOfkXqgJUaLYB9s44q6o5I3Svls9/P +GHfFtssAoUM12y6LyraKa9e6g3Ff5tpe1Hmsx+M+FMDwO3RjkoXWLhoBYCaABK2HfjQE2p6/3B/9 +6WeBoFmLmbWY+ceJGYWG7eVMYTIa1z4b7dGf8UbXXMCoQbk2gBBnb/aHCCdEnGcl/jgaN1rwmfyg +2Z9PzE17k4tF9D/wf+4aXv0ACqY/Wv2JyMDRmD9mf43/xWz7ojvs+XOdPzr9f7EBz/6vDPhfhEnR +OwrUus9V4VED0hsX+BrO0I7iZRbwPp2JSqGo6vW7A5d77u9wMSpch2NpAh85UklezYVgLr3o6eV4 +hl2OJf2cs5xfkhBoOY+17rI+KkV6PbTTGhO1Yh8nKHjVmJ+kWbjpaJgvzLOrvxMVM8TS/L///ct/ +2pj2VsU+Sx3AOCG+3bFOUrY0r2wl0D9bIfmFlL6Wgz92K0MbnUG7mLI01BcyhH6fjeFKU8dW29o5 +sRbwP0U7/oVW+mJyHDo3/NI+WdILooHl0oyUpXi7MempnQyt6QQ5Qag4yUlt/uhMJE8yRvy40UWe +iZi61edo8l+LdaBYBgY/UgKHgyHxCsC/eosjfqpzj9i5dDhgBOm9OmuWrWLZj+BpY96fPdv7wL3t +KBSKBCOPWLTqSQ7dYcgLSXhlqTxTLxGw5k7yQPYo+VoctrOTGRrtFD5h4ZPXs9HwYgJad4cfsRh+ +nOuA/XPR6Hdmsw7isBdNN+MMPV6BD5ESBjD5HEaLdfdfn/6576LlDU+h28/urCN+54yuBiRAIOv0 +HSUZjqVhZHGS5kma1rgAxO+uyjn/VactfZmkk0nNJclJmqFguoJ6iMqX950+dLTijzmW50mtm0HO +3VF/hM5BxG9YnkgyvLpDkmZYitF+S8rf5v9qSJ8KAo28GjxPkPB2JiNa8XKIX+b6cwmhNPg/UkB4 +JOgkZboQ6k9PGx9AGWyIX5M8xWOkMmRSQOvCsvgHwXECQh/PcpivKYF0PMfwIsgDGABePqCT/twB +wxoXjaTxcgsCvOIDvWIoHl3wLl3jCUPF0cWeDAkgi2ApmgdgKQGApTk9WJ4DmE0isIDzateYYQE8 +mJsij1YDFjwqHyQJU7AsyZIUvn2UZJKaZUhy8Bpt2AbPHYBFWJDBwtGS4F8Al9DDpXmG5SE4gUxy +mjyweFK61ZRL4ltR4hQNUEZLcFk4XDj83AGblODyFE1pRiewPMtQWrjQKYZoHv6fcm2qBJeC2KUR +emkRLoBKaAYHsctx2o4wcgVeFHJaqCRaM0DxKqgsxesYhMAlMS4VxDNJAieTisilcD6BSGEMAZGQ +hIPlJLCAcHU7RWDBJtKMlqIgEUC4EolRGMsYLovWTAC2zwHPSBuR5lD6ApgXjfAnJEmKw1s4SaOL +0yANSAKfh+kOIjg0SAauFCetlMDTAhokDXYBHBronkduTIomaAEnAjIEj/MrYB6gwKmhERCTrLSr +eIajUf6F4hTlWZ7RTJmUllueMt4PGChgftKMSVIGCxGJZggYCcpIZGiK5VQcFo6Sw7fIgx+GUXJw +75MsL8EjBB5RDVg3gjdlZkCrgpNGM0AYhLQGOmBFsAymejhOipK2KaA9Cgbmg23KYPSbMMk4w8D9 +AxFAg1Vi1eMkaThOQRDhJcFPfPkQCdaWMR+nxFTJJFgdXll7cZwcgMug6TPSMJMcSVBInsEK4AKN +v6Y5AqFETo+RNhCNAYsbCO0fyJzAkCR00hyNZEgSsGrC/NJ/RmHKME0HsSpx7xBwo4OFg0Nk5S0J +CAlBZFmCNYWosDmJjbJ4yaQtyUtMn2SkLUmDfnGxpDigbhbtaAIgAC802Hfi9qHFOGwMiRUAJDjl +pASHJACD4DDTRcHdQDbRPF5wyLLgLkU8Uo1G8S5okQ9REh6TBmacJJMMXhSAVl7LjA== + + + ZZGEeTvoWTpRkCUSjVaHIiWeyQF2R6EZUwSiO6B0EKyGmmTJzOGcKPBDlp1JROgC2kDS/Bka8B4B +0TIHWD38kQQ8EwtlJom6g+hhRS7E4EoPEj6hOIZZmXCPS3sSllBE68FC/oY2Ec9gZkLBZSNlRgGX +URQdtFpwwjuKgeCEKy5IUAFFMCQcCSBuxBoIQMwcZiAcUiJomVGK60RhVo9hCnCoaJdzEmlSrECR +aMoEB3gxHGhSQDggSEBIglpIcHB4sBeGUi0TlBMAASyHdpHEiWmWFJPYgIIl5gnwPNqRNN4MnDh9 +BjMiuZKGCJWDW51Eok2gJKBJjkW7GbRjEXQ+yaNBA5qg0TQkyUZLcl6USWrJhgSbzD7Bl3g94GYS +OMyfOJ7BQATE3BmptgclURSpXStIqUhpkJUcBrBDxNO5JA20Pj/Wd5KifiKJXXGTgn2lIDQJZ47R +KWGTAdo7gRUxeHM7HCPgKWjPAt0cr7M4Qvm2dgIzZgwTYZNG/BjvJEOiVm30PvMjQ8B/0/0YQmMm +LDawcl2afiMCBxBLjXbHPxv5sTniBEvbWoFi6lW1gaNvr0AyC6GyAaRrboo0aBf4UYBe3z1g048g ++FDte96YdKb+7PCjD8wqDRj8n0cVzGf/2PAJIhe4+JhPQTPzIntWPz8r+gEPZf15CPQ/Pv1D6TPc +mfIWgDF8gZ5JH1AcImzwPyqQZt3IvYCtynGkRqzygHK1glZA4gVpKeJRM41vb5DkDY30XihlAVOR +ZAPBESRiD0CTFChzYzkpMkhe5BOCSlsDjADpvUgNIlVwZf0W6G1IULCAZ2lHDCxfQjY5CMzX0NAl +/Z9BEhIJcMBeJdAMT1E0BsQzjLmywUqCQsBsF8pptWpAQ5lGkWjUYMlJeXGwPaJZUMAQDGuDnkmq +aZJHPVACkCxWKp+sjguKaipBo5LyUpNwyzX+QvEtFx9ufRFYd4RCX1bIOAbroTwJFGck/jgOKPFo +AECXZpFUES/30P8Q0Q8XloIsVdZueaCW4Ew2hqYJLE0ZAotqYNcgbYSS/ysaMFBNZiGiWWkBOTAA +tG4ssN0Q3wXLBZgz4vIktuZoaUz6Hxgqj4QHj2hZggr0daQqsxSJNwIDrC00JiBuSayjyP9Va57w +XyiHJZEJRoPWkQEqDSI0oECA3YFUG1HeS4PS/xDBUki8I8cA+FeiW47F91EQPJLuNJCQHCYTgBFG +VJg4teqF9SSW1qheNAPoTEAKC9i9yChjSVZtCgHzRrq3RfdDhMtjlQ7tLF4SmBR0RSErnOf4JPah +kLgDhcnI/xWJhMB7FKoc4F9JOSaBVoC+E9gk9iUIQPvS6rHSyPQ/JL5CIOMfEjWleCtYAbclGIrA +Ghew37QOgaTIpbT/K7lAkNLNUGjfU9KWu+00/flRfwRF4Gg+ljcfrGVGYn8Hxwjm1hcl3SogG58a +TsPRsvVJKbYNDzQxLV45vKSKtSQpo7yk6VJiiTSRwrD1gPRSXs9zWYrCGjgw7Vhe40y0dA6xrI1z +KCkqYQIBCILSwgMmK+Bt8IfaisfwKDhv2jA+T3FSyuAotA94WbOV7FTAMgScRQt2hNa5yWOVUyRa +tdeKFJIK5ZIY5kVOdlpLvmnFW612Y/vOxtjhjd5ILu9qdzpTe/HtotzlA1pNTKUxuNw2wcngdEcj +cPS7m8yEJPCr2l+D5qgPwfwfvlBlNABaZajS6Y/B/+Qa014HDRzoiq3PMFQ//wCjgppn6KpWg03m +fYA1f8x/1f34nKkfFEZ/DtV/VzvvmvfXY/VfOaAd/9mYtNXPSqOJ+Oh80gR/n08aww/YdW0GVFfV +37n5bDYaAmIyPqPUz+qNprYRfKBpgTvCfmww/fZHB30A10t+oPkAP6LBI9HlDgbXbfU6cHzI5y8N +Fsr4sIh3sFJqrFuvnkhthVFrPgAkVGjMGr7Aa0L6259Cf6nOueDfd6fVs1G7Y/pyzx/6z6A/BK9j +jdls0m3OZzjJBTTFVPe/ALEC+KpWrc9uvz0BuEdtpNga6S38Z/bXuIPfhnaG09c/GpPpniq5X930 +jwZce9wWPp9atIPp4riZOJKp5q9/KHaGo2HHBWL6I0DhbTeYkVpG/955NbvDNhgo6WJugDhqndkZ +moTz/NStV7T8S2KCtMWEq/l3G81+xw3hO67qP2mjp/5wvdVh07+ZouH0WvPpbDT4eznZr6PD1LQB +4yCgzANbzC05/vJ9UYM31/yYofwOu3T6/ucPlsZ/8zaY9rutfzovjgmkEhpmubyulvbv5rtwKpzT +VP5yM5W//u6pkBwt0E5T+bPbRmHtjtMRG/4DpvTZQZaqizlJLf/mSUnRn1YTao6ApTuA5vX5pAus +RTdTM37zA0Q+4nW10XzS6uRgEPRK2N4/2iAjTN6qMTZrTD46M6AHQJfB9KjgZumN3/zNquzFWZli +SqPJoGG1K9VTfu/2O7aNNZNVt/7Hm+eEEyd4R4HQ7ixzpe3fu/yOk+oOwTj7jZa7aalb/3C+jS7b +GTcAuJYrjUHb/m/etFsl9H8uNuwAXiWEjlrcTFLd+ocT5nB06mlq2vY/QN46M97/mUmrFUp/92hG +41l30P0vyiz4KWMCVvLfPYRBZ9ZoN2aNZceRXHIcW23x/MPNrlM1Rh/jk0KC8Es/VEBqN+XXm27n +z9zoP3f3YvvH0067Ox/4rzrTUX8u5qDIX2SPSNIvH8cAWpmP/aU+3ObwTO9i0oGpwYp7mGNZmhVn +nz1K+huTWXPUmLT9LXQUTfqb8ixl9oO6kCbh74JRNGYd0LCDXNq2jXvDUas3ms/8H/iMGxGBkoMG +R3DamX76rxpTIDVFglfNFH/BUgwlWA+a8n+gky93bWWNgyY04zifz8ZgoPYjoVSQ1dIQjKDb9k/F +6+ZcjEJBs+OKqCbn2FaeHKlZD0QGkz86/nrnPzN/sd2dNZrdfncmSnGSkWEaianaGH7MGx8d/8Vo +LC2hXgzyEl7a424cN5FAgpFNdCQyQJcYaB41+t2p7tF0PBJ3DC37O8aNdlveV9kjf3Y+G8krZiTb +pH/cGINdMO0O5v2Gsoryuuf6nU4b2qA3yuYmLfGrtYjyk9E4O+k0cIqzQWaGlFhAUr/h/TRl/EXE +w+gzHUsQJyv3BjvQ+BrEwUqrlm8M/2hMazI61IRA+N9lzgA2Zb877PinKLF4at94LNHP6I/OZAwP +iKfaVYbIErkOHPTlvAGpy1/FlzbpGYTZOGaAMnFLXqFwTcsJWufYHx14i6G/2eg3hi2HSbb63TFY +O+jF/w/YGx+AAsSBh0gmDpZDxUh72aPSvN+X8HjTmUyh8J1NDF3USrf+PIRcH/mzIoWY7wv934QW +SKV+WvVfTzv+owHcYNkpCkKArHLY1hOj3F5pIoYP1eB1kRJJ8DysmuX8lV7SmTfF48IXS8i7zqyh +oqOYoYExjkf6wF8bA1NpMgXonnVbjb6erCw/UGJTDPRl/AbgOF+rafevKWyURKo210k7sEfDVn/e +Bvr0AFKMnoGZfVEewfIAMMcesKNmv+NiSHi6xcF49le+0+9PLQlD/qReuIW+0IrKeWjXA1rk08a4 +LitAlIvW1VFLxVH1K67fLaPxXwba1iFKRKb/7vTCHKauPUpWxpj0n+Jkb0O/6jbXw+5/TDtWN7rt +DtujP6c6ale16Krlpn6ESQ3eao0/4NaCCfsKhNEQUopfw59dfeOHy+MnxAUiPH1Fmi2r00eUOD63 +k8Jf0aKi4ukjRhwf4+krdqGvuIW+4sWvvKFQ0NGRDUWYE5QOjdA77URPhLtP8ADNl9j+myeCkOhJ +8PgdZY57x+/oBb+zoCvH71j9ulki3pTrKBK9Nm++j/rtzkTyJMKn07Be7Ooaq8w1LXcozMdgJND4 +UsaS63wCqlL5c3BT1ECkN61w3jPl67p3ahtA9V7HOYv/GY8mM6gGqaWrSrXOoUMelXJtUJA0TqZa +p19pzEDfULj04fSmKn3Xou0R9LceFdQt1a/rME4B9mo2PhQyqhqe9m19NFa9k8+Py/0RUD6vOuN5 +fyoLwD34Vr7cQzdR/d0fioID7H2kcxhlL3hTHLZGJhY2eAPNuPOhopep36FrZhDuoOYgWlAKUGAK +trrKuEnlTQloU3Wj8xiCBGbWSWcyNBsI0K1l9VM99kEToBdp7KYdAWKfYtIybKGkfzhSDA1/d4g0 ++NG0K3Xj7BGh/MA4tPGCqO0F1Bap83nRULhSGwpqawQ1xZNK3GAzJKcxQ9SeDdxair32N4CWjF0d +OpeCxg2BP4KpcdCyQB8hk13/kRunUPGi5hYHuLE1Eoxtz0WzraY2H9W4ws1skKWdN27uPHEtivFX +zjh22I1y+Lz/ttNM3HTbnVHidAQ0vQ5EKlAcwT7sSLhNKI7yRGvUh+UEAGQjy1a3m8768TbuAhG1 +LBDswcPPxPaKR9HNN+P2ALzuD10Patx2DRzH/MlfkPL1SuqG4/EkjoRdvA+D7l21nI1E7xLL8/Yt +J4phIxCkfVscZ6Bj75o1hG3/HIkV4eybfeqaGXD6NWoCnE67H8OG0Wmob4iWtinGGdhBRA1H8CTZ +RbvGtNmdDRpj+6a4zUS3T8xat/qTeGs0hFeBQZeczVBhS5lvN9FVRXj+vGnrSTsObHh4547DAEDD +d8CapGvGkCg2bYWEhNHLZ+j1D3hAO45/umz3h/XYxh+DXrwzhDqGux2EPsBbSFlPN9+ARZvBC97E +scQp1pTuYVOwqSFvVgVEWQ59DLZId/g+cmg2UV105dAUeUqbjcnUBrmoYROqWGA/qTiEi8Yyk3DR +dqLxfzi1VjMKzrL5oDHpTbWjdtFYHrWLtqpRu2itHrUZk9fOcT7tAJUYKbc2+/h9OIu3++PJ+2ho +t93H0zhUzAAPmdqTxTQOeCZ0yg5BU5XwN7T8zzg+0bMkJPDNWn64YV6gnci7FP+yGZqUdtgfbg1x +0p5MtTveVAChZpIjejq17rk1iEve9dbgr54NG1QajvC9zVoPrqF3zGVse4ZagsiCruO1uB/npAJ9 +vu1/CtVuzy+ewv4/KAcdCI5LJZzMpB1oA7WY7tBGdEL56jRk2EZUWURJkDRng1CkK+xPYCirVuoI +yxDQAgHfbPubf/kLk+4f6G5sO74MvldULBvlQsOIrVQLE2+toRE6cnQlM6CM14zNVFor628tBCcf +zoIStBGFpKoglb4VqkIlwXJsZyN0caNxXwpCMiVu1KY1nNqhFLSZdftqC9ucf06lazZt2iAe6yQb +J5IcMBsyZruaJTFtMwWms3Qyas5u+5pjN7MWzS60hWybDDsfDeVk01IAAMV0aN+mT7aQ69xg9umF +xGej3ZmojiJNW2nlCG+mCgJmrj8dNGX4/a6NkgwajMYtG8UINZjaTB01aM9tDXabHQw+t9/AWMTM +hy1XDAG1bgyHIyUOVQwNgE6WrNTQr7jKPEcFkOr2yEmgOy02uF1MvQiEVau6LMId7A== + + + eXOhiCwkMGScOG1JGYoh1e/bt5r2umNg5gxthDZsNgG7cTLtwOFN3HUrhR24Z/XSF6q5WQ0H+ixk +j52WCo5HzSNgDKhpQOf80q8oYekYUhZLvPj6olASnVDQloEBbqPhVO+2AyPwn+NXKleV2u3c+KNz +CsR/d9zvZLVocnTyqGop+FW3Hq/AvwNnD+b3ClPs84pOLIZB2H7nJibD7DsK9neBFS90dAo7vBj1 +u5JUNDUepIHikhGlyWgAkPjnaNKrS5KJsZne6Wg4an2CjzqqSZ50h+5MX2nQONAKuu2HM3EC7rAr +RTFlgRxtNmbVxl8dycyEV0zZLwu8DALnc6LTlmxz9IeLLlGshNWK2neKPrXu1dvyXCnKoblBZD5V +g9vYywrBAgLInXLUBivVfe9K7IvzgDCFOlzQv3W4DmM7aUiX1pj2LnoluEpEE2ZcjmRKqVAArUn9 +nlR5r7VfugqD9EYyVcXxajNYi82oHrSpjuU+Nsvc1DeyFGuq9TbvnINHxK5nhVot1FTXgaL2u1TH +Gwwfu2CCKmEG4zkBjeYbYxzV2XUQHQyEI/mBrJUFpUd0AnHaAFJCSb9wx0kKnSkYWsO9BJVYR3Zi +T7wmzG5BQSSzOReYAIzlSPGWWvhgpdb1SXcAkXarsuwdZY3ZdOyGdNX5gH1MnTmzTjdxZMzoIxwg +21WpuNbzVU7UnYddApvnttOEoe7OPEpFRGq+5DyYup25LeMFMjCgENc/54PmsNGVIuxC9U+w0/yN +Scc/++z4RbeTfyoFwv352Rn6pzjCojFUF+ryQy7qb0zhY0X3lWLi4yg+ZIaAa4H9NZr7x4Bz+gE/ +6eA9jbrG4D5gFZ6upqOoH3QmfzoEM4YXs45h8pm/i07OG/5+4y8Yf98Y49ARyKum89YnHN7RsICO +qhQwuLchQOocjG70rnTfnfrnwx6sHBJ3vfNbk+7YcWOhxgAjiMvUVd4YuzWTzRAXlIZlVN2QuubI +n3PyIQbFOm0sMPCOMQbLbKpgIOOxiu06kLBKitvKURxPASMrruAiW7uH1IxWF85oB19iZi6Mktqs +MWzLIdEuebFYSuWvM1uXh2PsuDNC1eqB/boiItAuLDCXwRusDOZl29CV+Wk2HcBX+9MZsMjncnLQ +//d//z+z//f/sseZ+BnYX++Tb60dfzTs+eGVbioTnueTSkygzsRWZpbIdaWRZ2v5oyOBLXRg//Al +c3i+8xjZvz0I7jXuosf0znksl5mUB5+pj+HGcWkjGgrmu434dJu7rhS5rVTmupw+ZQ5T1afgaWYy +b/GlInUqBEiG2SKIaeGr8BEltjN7L/HdzH50PM1MT6iEL5DZq25MpEbHs9xH5bKa2Wc6tXz3IN0q +xOPBD0NX1fY96I8vlAIp/qE8K3w955iHWDQ7GFWn2aPa7DOS5rbmpQKzfZv76gdvfYHCO3HcNAW2 +zSff+ZvLx6dsPR+/se5U3S71nNnvlZ4zqWl8EClEA/NSqNx+9wUQskpvQMMovD/f8rl+pn+Xes99 +zvKf/AOpQcfbTqFFVr8z+4fBWwwHDHmaf/l4GYFfO9+Fo/bRRi4mfG1na7GtIR7DXaM99wWSX6FI +q9hiL0P5T+Z1bz8boHciubPoWySTD16X8p35bvrmeOtzr9Vq9OCvbqT4Xv3EPZNEosFPuttvqe7L +cTvXDxwGY5PI0zxbre18w/GHM3vHn7QvwO3dPGeyw1ZwEDk43Uvwg6eDLs8npu90dtI6IiO9FClD +bBWOpzcAbXyww9/SRDvVzScaYH3J04NQLNrJ9fmLAZ7BfTWQyR/tb90Wo0l2Ctbl6JHbSvP50Utk +/6b9mKKaW88IbHoYABNKc7tbcEkeuVvucgjxlM71wlxMJM2bdpUgn7dOC4nG/k5pI/Iwgb1w8MUL +goKa+AJEc/OIQb8j6dK++Gv/tniCm+ejxTcMjLqnjgDp3hGRdLoYpQqHHwcinNuD/b3219kLWkl5 +wADeeY4VewGNcsfyAJ6VAZChgyvYqMOgZ+xGrvCKUA2E5SHDPXBfrWy98BUpvCdOvouNRnA7xzWv +L/crhdd0tv7ZmmUvtlun2TpFg9XP8s/3W+Cb9kPx7u1wLqMIU62GTF96CjChH59UpAW7HxXea8U2 +wicA2whH0lt7t3iFIGRfoPhKRm5yzN1xKTOZfF4zqdPbQ7RCAtudcGDxdqOR3Cj5okelduJqvEt4 +wgsLQfkCe5GDeahU6JM54phNgX/KRBfDSXPNUWavPtvM1o9ncyMqdSupwru08HeTDfisDvjYd7yb +1eNpfpXslEI743D+k7t6KDaJ/d1CZzKJEp2Lgz15IBgdMjKq5ezrMYmobT/2VoI79SReOPriG3jv +4wUVat+Dk+z5S+60lH8/FgjypNku5duDe8Q8TdagnOtzB7cKbG5WPXjIVepbB7ox+AJgFJ3zQrkX +6ICuLvchh6GJ99TtyDhafbsW+BWdlcebzWQyssec6TCydzQdvee70y4HuWXs8YIKbx1VlFntdVI7 +A7CTr8KQvE4jB8cPx1KnH0+Aj9HgbaC6W569tgfZ2ttxIdE9CJUwgPdghcvWT0cfmZv6UaNUFC7v +fIH9CFF8ktExLkZHZ1Rph0vdgTWfJ4ut3veO1AHaIP0GZsw7j8EqYI8HwexVf7yrbnfZqAD2F2T4 +q8/dePbkvjb0BVQsXHr/mqnzO+f56ned1IiM3Z3Cezb4opEBV6XSa3jjE00D8NxhB2wptql7K64+ +fN/TSBrV17tAiJZHxWi9dQCweHkLNvbddiR9wNHobbYWzQzz3e5lG05tAzapF05OKrHSfpENo7dw +Lh+7Q9y8fpoJ5PrHRByu1aOyP3nhsLvLZG6aCf6icnpFNl+us/TOxnaRCm+/5MlyvpqBv9KAxMkD +otNMHZLRUP5Qfpb2BbTf4JboGfwzB5liHn2I/uRqVeoSvj1AX8sd5OGzHAaV3Y+VeDZWuKJeH8ZF +2GQf8GTYHD4oyF3lYKMzBQ7uBfanBZGRB5+Wv9hDTeBoLtCQ0BjAXACcLB4KnCaeMBwUxE4dPttD +wJReEAg9iuCQzTpFf4oYgxBrWmSib/bgWzSNQwWVuDEcHMbi8GPvUkZBDeFT7mVfNRdl8dK2S+t6 +IXTL4AvoFgJ/A5GlwEbTQHjSouMAzUr5E4GSey4rY/AFtGuZNiM52yXBQ0a/5FnhTpU/MY2ZEoYL +soCNq/KsFFLR0yyeiyWyDvBM0c6R0HGgzBk2PjdDqm6n+gIyCg9005RxktKCONSOJq98i97qOhXX +Rdl3KorRrGpaoVrUGGIia7JV9uQRXsjMAxMpnksJ4RGBdYtq1Rhs6QWhHKw+xKMMO23GANHU5K3p +jQzRgmCM7csdoDFecQIZPke/MPrlmfLcTfwdMPAvWpR7yewwe/X+cQLUypOxTmBk6zcnw1KGJHu+ +QDlQfgU4YUOcSjeZXwb2S6+z+m5mj7jYiBRv7iqSKIttq9QJlVagt5LU7QAlQ8MAqy9ABEdUphmZ +BAbLSY4LAtUv/GhpTfF7D9VSlu5tHyM7QDuhCDIQfAFhdEzwxVj0nSmcHH4z6l5yr53s1bB2na3N +jgbFSDUR0r7tlzLJwFgyKq7CivGFOzh6rH9nz/O5C6jDiNrVQIMYYIFCLUw7U5Wywe+1rq+y/NPx +VeF4svtmBiDLVp6Psie3l0BPFkd2HeiVp+ediaj6VbkcENtPcdl2iNvbDvaWA9QuJNsBAuP56+fO +SeH9clpLdC8egdpc/M5jfZumNh/tjSFLU8gXUBtDCoXCqWEL+y57Xip83b7mu19cYu99EPgA+u0u +CXCSfuP5q/YIDi6m6EeiGlvrPyugACWLwH4ny4Lblf0B6cJHLHyIO7ik029AUTsP5j8j9/lEN32Q +EtdKiyeNLdIDZB8vKYYw4GPqNbioIPSDTukt6DyoYpoXiVM1ECujYieN6VzZABeVPrAsFP1fq/2r +BprsdU7yYELtSOntNZ0slO/5d2COFymCKjOnerCXG+EnnZGCaawodft2WXi/jpQBny4VqHC7iHcg +slShDEhixvWyv9Oz2ld86eV5d6tUHM7fqEByIIirvx/dTjwKfKt6nLu8yIC53A/ORAN/fh/IXp7V +bkqFcFt6oRD7aIfge/PmBVE9aY4VG1nvc6AeemBd8p9PG6lIuvz6KlHWcxysYPwk1zuNANX+4l3Z +synoaXnJ9aiDDeWF7AggUu1Bn4BC5Axi+0HxdgCLz6TvVfeMNaUz9dYdxy8jhzeNb6mDOp/ZO7nf +BObj54YW9nm2Vm5/gXU5mFCZ640kWgO0AgehOdWBJPeOXgA+dvg5naNFTl4Cpgp6eWkAEPVp8XVM +NjN718G4yklGsf3Nvff5xVe2ft24Bx2k+kTpKUOD0VRiMnfWOzB8gWS/NHq3ohhSblmXdq8amMvd +S6s9ivb7l6C47E6hyXRqjrtXNRC4ez8AJZfCF/29UoF9oCLp++ddI0QXVr4KbFW1e3PV10+ET7Au +ae54XohftWOZ1NlXTxZRdW6zNMyLrkFAfLHx96hbSNztZSR8BjuJz87LG8TnVBxcuXAgctDbAxaK +eSo3OE8DKaZRPM6Y3PmcfgCovpoWI7vcu0piKXQHSYnb3voWMqnb7+7ee6X5kUndldSgMMfGtnuy +6Qsgib0fvecqCLZKdostiRCw02ctsH4Pe4XO+LyK1Aluq8pswWdU4aR+uql0z9/0q3Ug6A63i6/E +8LnwXi+8+wLF6Oh0nmUz2cdi66If1qlLomfyI9ADDDW5yU8TZzfZejUDt2EyZhz8figziSXn2Yur +xHOq+yK8gxW/3QXrolJvsDg6SACKqe4CBeXpuvS695nQd0qlvwdgkT82Mt+HrY7yAq7VPCs0xx9x +snITFZ+BJQb6WH37O1YKjZJh3SuyWT2iFBCyfIVDPovl+gPiHdBL74FLp87vM3vjJGmcmtgOrgto +yQuXo13LRqhJqt1ufhubPMQKRPIhWMp3uF62XmiQub6wJRBU9LubSZ1f9tGCqTiMgYrQ+cRB6+4R +bJrCafaqnvk20sbWNN89OJ1mUqVAgzvk7sr5s/zNoawdcqJ84fe7rcfCUevqIsfcUjPDwr9sbQDh +QVyWQseH1WTlqTQTlWBxEeOA0E64vZPt7HvhY+uZ4VPjeB6oQ91dBRTS+iCw984IEt3jfng78Aqp +e7/YTDyMtZo3HplQ39mulV63dmpgfpGn4svXrIV8kEZ8lmfFZm435AukTiP0Y7Ze39nQEMvhkQy2 +KnqpRLKoYiYs/flkQSCVrVI++wxUxMzRHeBjhWidlX2GeLTJXrZYz/LJq48k85YbgEnmCMsmUBA0 +oKkUjg2jdVk9A1ZY/eawl9lPj2+BrOwPiR0TEJ1cLzg7zjH3m9eVgycm6GqmopqngRKKP8Feekdn +wPwojtT7jsuMoDQ8hr5OMF2W3gImwkNSAZEihY2zUvj+YpY9uSfbqk4PTs7ahfYgGQ== + + + VZ9ZgJGFAJc/730o/Bcz4dHbJ6vaqfLpBWa4kbPRV+E9edwvNHe7gWT1bbJfyvaHm8gdqqMXsPrw +KC91lk88FU5O9hNYVaMua7FSkXwPlVLZq01pQW9DgPPXE9xBKZvOcYExWzhq9AMG/tO/CAPcPF9B +XhovnBxt5gG31G6g/ej84r6UIWavYM2HzdLGbpQEJuw1/CZJgZ1Dv4FteCiowNK7oTA2Lvk6/yKd +XWUC2tM3EQl7pdDRIJv8fDrbKhUuTmulwJgBzOW285Ghcw+MshdFNQj8UhQsdIaX5Wtb+Sz4byWz +H4uHTXuBjXbK0Fn8BBoVaeMe2+plmVDuuhiaNp8hIyH1yCKm0Qe0AmDjxu4te6lVc1T4vW4Kggwe +t6HJfJIdfZ7vqi0nu52KyF6y+GwJX3a+P6JTALhWVKFRKz+VA+VnAdBLb65qPKuWnsHqZ7aRKoLO +KKGezGVOC/Hzz30V1aa56Ki0G45yQA1iAsCUyPTRYeNeJ9m6EY/guONr9UzVLohDqrQX3VQMeAON +qcX2uP1eCp2Uk+pFRrR6+bQFX/Szteb4HVuLFLf5kRtsCl8qTSlTGX9Lu1KRL6iXW3q/we9dnl9k +a/NryihQ2EnhaNCdArGVG4AR9rnS22kgaa0BnKf2rwDGTtvVLfPllnQKITlKtIrNUSXm0K6+c/tc +bLwdbeYGkR2VgJZoTKV9HJ7dgZXuqs7tdcBU+84wUyhQ3l/BIlZ2v4HKfXQmSWTEPr8mwbvSznzc +yTHzHLB0gKWtsslRk0FIABw0Xuznvr4uMoWj9uWscBwKleAx6BE+N8r2GwOkGhVnO0cbUs/Hc6CN +G5XXqpkGK6qxk602pLto9nL3FUjI1oBUs+Pj+Yw4eizv6/aDOBegoLTqqbOX5rz09kINII3R8mH6 +g5qUDjo5FfuH+xzjIUD0HoFwuAsV3nfGW9zsZHZQeu3HE5peui/RD7Aa010+9RKpwfOgiH5d6PCQ +BgoB08gyweAoSd6eJLJCeTqDYQNAoTtq3GWm4bvNwsnx83ehs/+yqSwY0vnfGCCi38eAfTwluFTz +fMft1/DbJDCuKpXS6+w5VsoEO3XtYRyHNgrmMJJhcAFEcyb2KYD+ouXyg1B/Kjbr2dvCB7vT1XEv +mXFJPEuW0phPiUtSRGvhC6AjyPzn4/53KXuRGadOp/OR1jXIcd9k8qrQyjd6hd1uosXv08VO8eH9 +qCi7J1GTGtjxtRKUTY2sEItvQl9IGbEthLGLB77+VkmUCvMsOpa8BBpHMFYoDbOnQH7Ww7ne3n5M +VFB0ED8Ag6vN620lcANzQxHo5WaODZcSgI+1U4UPFbcU39e3RCyLuLvOXo2qb1z6O9xTm8wQx7ng +frUYfc4Be5+jBopzFiELyN6nLsBY+nv3uNC861yB3ZaulO9fx2+IR8rbxwLz8uKIfsIDwMBjpS1u +clk5BKrPIWDRJ985NCTJO0pdhmaQnva564t2AuzU62gpQIaA3Xx5FS0cb7wT6hngxmOSu/l+zyKR +UApU+ZQOttwY0Fhp5+FjWHgfPUeQ68jUfy2y+pwAvcP18jw+fsmePIQFZfVhCECw2JpvvgjnFbqe +pKPHe6XX6E1KNxcZTr040oltLZy3/MdnKQhPvQXNkGUAY66cHX1PEzC647zw3L3fUp9WKwwgddy4 +OVXmrzGjL4H+e1oKlgOlykA2i4CBdLsdLxxHtlh1z/3ZdrHVjLZhFMEtdSg+HWzuwIV/hfravsbT +/cxn9l5i82w9z78Cq7MNLOxErJEdZTslZXAYCh3K7mX2nq9z/PCoThaeP54pYO/X+pmEBAzwi4s2 +2H/dfTBhjSpaLO2Uq2MlHCm+sZO84bjj7gdXj90/UMWNWC7xOWw3tpMftxMw1gq8pitH5rsbj0Gw +XyK7re8CsR0bIvHObuR3SWATDDaBun/dLEPPaYCk/8+0HC2nDYUroGvFtTlvSX3W47gx7OiSAsX7 +rLTXYaqvyLrTX8UCnhXqBV1GJLyZ6+NdCuYzRA/uyVV3tZVYYdAfrtAK8+2kdz4Uw6h+YhrXF0mz +bzwwj5sJIhE5jQBOPaPhL4rZv0zR8otL+Rd6sUcf1mc5YFmUe5Wtq4MGoJf7tPyWihxccZ8bYbpy +sBFLBIEOA7hPb38jfPaQ3Ih+dsGrt/f4RmSeqm1ET+8KGzHilCISB/ch1D1YtfAlM6Wmp2BwhR5Y +ybc0nRNoATDZwQOKtUEHSspbovLaAZbFZJI+aGaj47PjzElymhYq+7fx0uiBuSlOnh6IwkPpvl46 +yB60yN0sPxR7obcvI/nY7hXor8pZTRdPKE5Xk9tQ69M3qk4nk71pHXQSPSISTA1PQxnZVCjNbqiX +UW+HaO+QqOdzBezkmZjuA9jCPJIub+ygiaN1KfTiialQZoTvvS/wZ7kPvr4vaDt9mjyfPl2ad1rm +X9jU0UvctNOX7TMg93XdKp1y3ZNywLzT/Y3QZEoGJuadXpBPzCaV2lU69QWUbqfB6GnMolP2M9QI +3hfNO2XCT5F96sN8ppulF8YX2Loe96tmcyVKuZOMRafc1vZwEj6w6PT+hSi9n9WUTlEcrNxteWN/ +hzx+rZt2Wq5QdUv0Ug/p+hvqFNBis6hd01tAyU/zdBV2GzauauiefuyTYdApMzKQUpXIiZ1eBIO6 +Tll28DpWOlUoGXf7Onn+HNYtOs00OL60TZp2+nL4dmXVaQVofXRo78l8rvsbz9Otz86VeaeX+XD6 +e3tQNes0stdPpZVOwbpoSWn38CFzbt4pc39PlJLEmWmnm6UPfvtqQJ2bdeoLEKXn55LFXLmtQG94 +mrfqtEGUo2835p2WiWywE+LvUae+gB7Bs63oodjpfSykQ/DhGXMgorf41CtpOn3YJ6p8jISd7uo6 +9QWmm5XOiLtqxCjQLT/W02/18aFh0Sm3xffapRerTgvE6e5zEnWKbGTtXI++U5mvydmVaae1vSBt +2elJp0YTZp1Czs88xojaa3jTbK7TzZNK5+zxIRwy7fQmOPyw7LT2efnWRJ36Asa5PpaJm5Pxvnmn +VTpwXcrsH5h3Oj7eNOsU8GTY7c1reXNmgeDHc+L28KRg3ulpuvj6cvn8bNrp83nvCHUK5Ytxrl/3 +bLtk0emTQDxP+zHzTs++xoPzpEDrOgW9oG5fj2JDSwRPArXIhkWn99dEsTs4Nu1UOIttbmSeY4CP +gW5T3/pNM3/lX8VOm3RYt2nCD9XGLuqUCqZDFe1Mq8TbbioLO40qnYJeYLcA7Ne3xPQPJvpOp6Od +A7HT2WFEN9ONp8ZjGHeauyePtIwwOplepzdAL6DbuJErHcXQXEGn+ZmBFVY2OdzpIXkS0zHC6Jg5 +w5KG3k7lT1CnsBex2+3JpNEcwk4JXaeTSbYzkuj3eEPX6ZT9SomS5jB1Gdehd3PUeav7RP2h03jl +tIOqXO+8jFKWb+8vycGN1dtPovIWmCtvDZwfsN7CjsXXYA12InlpXF8dXveWE8jXuvh22hMMu5Ib +fm7emb3HTPHiKPVk+Vagdq/erN9+Nl6CMsaM77PUzkPL8m01MjykrN82z9/3lLc6jHFb55utZsXi +a6GyU9m/nuK378HvpO7b60hXUk7fyc2UAWPXzePa0Ow95nKFSG9i+fY20ExsWL99KqQOJIyZvH8L +vPDblm+/ZhfjiuXb3g2Vu1TeGjA26JXSL1ZfgyFd7rGWb48pJn1njbFAa9isVa2+3tnYOXratXxb +zJ42O5Zvj6nDTdIaY9kNajucsnjLVojiwa4051RoT/c2Ur+cHopv8/F9/a6s1N/Ku1nlPTNlolda +CyxPtIOPeZH/vAX68O1YNEdLryxmPbnR9Az/0vAxarYNLcz8Ruw4eQ8szK86/CcOn5U2ooWrPPzn +FtlvsvWGeYTYX+MqJ3G+ySYVPLiIifwc2DkafSy9RQfBh8cDtDegpaPaEYlTYRgEduzdHLDWzR3Q +3/u+3N9WonvQDAPutFmczN/iMQ27nWz6Akq3yNKx6JTbgnbOo3mnzP2DZadAiHyROn1MPVdk6Vh2 +CkVey6rTtrpTpgZsZFW3wlmupuq0vbOzpXSKtH+5U1qHXqj9yzMt9zWdhu+R9aruVoPgA8qyU6T9 +W3QK7EGg/b8onYK5aOb6bNkpQPCUse4Uav+WnfoCUP//NJ/r/kbcrtNq0LJTpFMoncK9r+kW6hR1 +zap2klL36Je4EOH8Q3vgpt3LfDBU732LltzW90vx7tyxHfsp0p3ILXJgzk9ZkVsatu5baACxc6Vy +0KRL84nIXHZqGd2OT3S3UlHln/Q41K6LxjrkSdjeT4/D+2MZYgiBSCcr219oFOlk+bEAGFejCHum +FdYkdp8uBsR/oqcjsQOkAksdyLolGA+Y3MEYN9J5nwDbyyU+O4WA/M+VWmMWfWbncuMC7KWsnu7b +8aHoUwJDvr4AD3agQjvflbCD9XaRHatmcLGjRaDscQMDJo7ZQAD9AwnyVmslmQ2qlzzSDUo9pNd5 +EJDuaZQKHhIqP5rOHYhQDrjl8zx34oR0+I84eGzMm8wvuGE5P19AmSH6x3IFpfWrbTqv35Y8v12R +xsxmCJXXaxtkuV+/EaJPbFm4RJYNMHI391WyBOVzQ+4SsvZinihLoSuNRMaUVX769o55U7wD5eZB +pOSlMU/lHpLH9nj3WSNLy3rCRtbzUtSyHtqS9ficSLf4dDRRI1AesgaBO5j1mOPuBeaLSQi2GE+0 +GMX/iLgjh+a4u49tWLJtq12J/HGmU7vf9D41tRRDk6MPb+qnTqgun+yIpwmmAylEdLNSSzHVrDoX +8R1x9Q1stAh6uRl5mpAZhwG0A8y5OxVu5W2opvO38A4Y3F3BYpmiY7KxHaygMWA//4KIIayl9Oco +ciBRjoqSkVPHHBjpFpgZKIR31SnPrnHfNUpu9539rgOysrF5N7ddyy0yek1G4T+PEdUhhYEsAGcM +FU/MlhNgTL2g8B+woIoj2kgbYH4yFzTSxvmlPCTVuNBcZmXTkaXLzanVJDNEZ3adMGhhxiVRLL7T +iHFJ2mUnLcwt6+kJU1/AUjC50BmVxkCbeZxZiiVfwMv6liFOKt61J7O93y5r+bQJsk5HiuC1GdLs +8NhSVp5fieNxo9KBIVkrdNLS+QLuVhBY+baKhZPOr1nBYcBWsfCwfuWLgQIKU/ISwGpDF+MCu9IV +MK1A8Tou6YRXBHZvb8R4maRaq1saY6+TFWJMy9E8jmus9cO88ROD4TpLTxfUjjXnL2A8FTNj0Eqh +NRXQVO7uc8OBj6kUbPNdOTvcXNmuzN19b3szlPF5rGElK/DIpKrgBlri3rFzv7nj1viQdUs9dtJT +WSw7uhHMFcOKjimY7hfnZUpP7U083UBESjYOxYELuBqITrdcDCcO2141EGwjRyxE1EcFuq4fPdjk ++FBSG2Qkx/ZQz9NmXOXQBr+OIM0XPXRg4dQAmuCGjQ5jyj4sNsiRvdrhC3gZ1NaCDA== + + + QMst4ZZ7ngXsxbJbBnCkMAC39r71/IIuUO5zh3SNruDsz9Br8oqv7+sIHurdroKoCjOy+DwtK5xB +EwtnavhY2OSA9j9pt/QpnljZIcv9Frc0e5CVBJDlcYtrkCVvcfQFvZ3sJbQb/BjORbvFTa1uZ+8S +oNpNdx4SO1/Csd4lqx+NnUtW5yEZHGs1eAuj2NklC6am2kji6nt2kxzDuIRTt+4N2UrSD+V4rhXL +C7g3AB18U2hCKFLFsFru10onUy38Pr6AnZducAwPd++X8vtAtDj7+nSswMJfA7HDuaJkFd/UeBrG +GlU6M9er0oAOrJ2JIk92oUxDLJ/oVWkvuMP6GBpPwH48bv0L9OE1H9RRhMoW8yQIT3Sa8GL7JXUZ +tp+aM52fKMJPli8LeKPHJ3q5ZzUhX8CG0gHtaIXeIgzg8DrA+hzW3B1iXh2c9D6dqLPSZQF2dILO +SQ6pdVk8F5Wog4dVQXX8BpwVeOaGGCx3nYqS82A8cW8+b+Oc72pm0k57Kur6CBIAs/K3mnlbsWVh +5W+FwDxsPnN7CWwaX2DpQwq0avYiz+cajtaQ9DYa8Uwcw1l2B2IosjWpQJF4shc43uWebO+bANOc +EHoTotrzwSDSLqIhrcaZR2GqKzlhyKPgU1/AeRu6EDcQGBX3fMZnoUTAWM5dV6hUqZ+pb40U03O0 +aS9s4GjTnv4AzwVHM/WQ5AFiMt/LcrRrhaNJ1qsXDV4PzJmj+VyeIEFgi3M0eVeWb0Yr4Ghg1cw4 +mue9D+B452gG3wWGszxHg1CWP3tFcGxOg6K5kHyKk/AFzLQBjRC6GdlZ0OqjQ3MdhYleaeMtgc1j +8I3DZ8sewEry5T34bc2GXGpmebDPz2dmmxl74L2xWQDsZsMTk/UFLNnsgtEP2s18g2xpjSW+iIIC +Vk0X1GTFYZzhuFPtLaEgPwyAs3wIBIJiYVDrTt6d4WgP3V26l01OExCwVfiqsSwE84tA7UIrDcHT +2DL6vYpIG5tX06Utvrtbt94sle/CUhreetLv7X2wENjy+v3Tt5ks9CrF4Kp5d2kZpRiEs4x+r4Ii +y8LFpRiCY6Lfm0GRrVcLOG6lob0sRBzm6XtpaaiRha/6c2LUC3i6knAkyH9M47BEWakJnlLCMCx1 +gdeJzZKoURl1cfp2d7eMr1rn5wfAlt3dqnGZ7G37WGsbjLlSd6WVhL1YWURgLeOu9rnN6Wke4PMm +YeO5chFOpxuSJUWg2B7H7aUXTPl4zCCW8vGEK7vShWCicndty/A868g1C3sfjIxyh0oXm6s5XV20 +LQBmeXYje3vcBtQDYPT23kl1FR4SgDHem4phEYMIV/I17soHi4FZbPZ72+BbTBE+yX/valAuKcKw +uUSJjLeuIs/S7OnQ1LIQ1wBly00/NmLDy9eN6M1LcSOWpV9g3lzRLIMO39yyfA6dWooZM+h0GUML +59DZZ9AhnryCHDrLTlEGnWW2oMccOvsMOnW24DI5dPYZdBqtb4kcOvsMOk224BI5dPYZdDbZgp5y +6Owz6FC24Apy6OzbibnVS+fQGTauJoNOtiyWzKGzz6BD+phzDp0mINkmw+wiWDLTtq1j4K0zgXTB +Li6GZOrpLTgHbu+6y5cq6WzkhYNhC3rt18Q54NbT+1jQSntvS6c64yvoAzYWxtPeroZctbmisowP +uUkG63x1bpycKNozPjtg9nFY7uaHfH1OmXOu56fzXBn3i3ukJ7wPySLz0cFzZTcks5Q5OBdPSXOu +eE1RFwqixPZ4S6CaeQoFwfFjpsEg3t3GVk5jdDPY0v6q+9iW/dR8LpPdtJGQXh2DiJLBmi/rMcbJ +blbHNlorySnZzdo+tT9wUHHLom0wiMY0dTJDirpsBk2msDtg2hAs0nhi06S+nTIf3fGsRsmT0Yt2 +pZXZ26StQyg9pZii3LdTl1mHzrY9QJbZWbasjxldZ06Ow54w1rlJwLfXpkGzC5xYlS3VLsssMJWm +pM8Dc1S7XOfxzZ1i4D3k8TWd8l+2NE4r69Q06yQYe1XaGAMfPPjcshpUxixF03r9HGPgXUcRtMta +D6bp+rnN4xMmTjkxdsSgjU6HwFaWITpRTj6sMlO8AHOmePcY0zpYl8SYY5qo+0kqHG0hjGkdv1Tu +7j6mDXSq6ALrTTK53OmyBp+v0cySt/qVud/SPl9OB8ICQG9TK5FNQLxRLyT85812d1dcGHuyxedg +7H1UXBt7VgD0MYoLgHC6GgWss3yrhrtUuYVW6JVwli+SSmO+LWCKm7OTwWfrkoZZaRZGnIHs7XLk +fA5pzi6OPNGE7K888RnMKxs9MjU1hPKHCjMXKFedjFhR8teRN/eOiamENSWHBDkD17HOiJqZSvMF +9LEjtzte2e+W+tjXkTf3jnWanT6CaGE8fTp4Gnw6U8KaBDx6ZDRD0uQjg0FRXtwfNkPSbmZnKWaD +J8btkOyj052T4uyGpL+7I67z/+KUpFV4ZI6RR2bJKDWgCW+78MiIZ3wO6TnbqfjOMh4Zlb1/vLxH +BgAI2UR3eEhDW8QjY8gWXN4jA9PQdB4Zq4xUp/w8xpNHxtTPf+wiPcddcg5M0QMbzpmS3YXvwVId +hFZZPlGUZeu4cTfKMn14HdlyQQz2OYnjk9VEMsB1SV0GV+PUAVNLhRxiet2koS0YwK6WLzCBzNq7 +5CF9zBC6YJot6JRX5zlo1hihivLqXMbr2ebVqVJHbTKFnZ2gJ7aXVKl2r0q3tA3VuzDeRQqfuRR0 +Us67VWDSavLhYC+riKmzz4fzfv/YIvlwZlHQF4NV58MtkWfhIR/OLkJ1dflw0Gu95A50kQ9nciOo +ZRLX4vlwmmgo6ZvgqvPh9PeO4oy4VefDOd4SsJJ8OM2JlYtQy8Xy4fS2mNWxDsxkWz6zHgq4lcVE +AlDamEgr3dJNTOTNyFVMpNPen/boZdWAPAqQWD4bHcGJOq2+Szhu8kgsoWB9DMFZQSaXIZLBJgbe +maPB5Dprh5gx3llVy8Yi4jn4vWuIeA5+OyyEbhNaenvubpbZhkrykcqrsOw2BMBsr5Ux42OW2/B+ +7HYb2mjjEN/e7EVTQlvNbcAIjrftY5GPDOCsJBGykHAnxRzhWF8JbHGbllWYtfFKYMfb0LRead1t +jeGo0YcFk8/sL3ZyNKjljFRyc9EAEdWcrS4WXigjtbH56iKJ1GVGamOz6cZl4JDqt5KM1Kfv1WSk +QjiryEiF+WLLZ6RCKKvISIVw3F0DrTOJzeL60AaxvjTVc5BROCauvnYb3i29DXWpcOZ8bNWpcCie +3zaiZxWpcKbrsvJUuMX9llqM2dvuHuzKJVLh1HcQoWS4X5IKZ+JV+AWpcOb+MZf22b2dYqhmBer7 +k+0Snz4tY1Xd3Aiv1cfycQezyG2gFwTFuvIounAgQ2DWN9t51GEMlwx7PVxQZaPfuzzCsbudF7By +M5Gn9OKc3KzPq3uyvA5HLxwk76iJeFD2L6waFzXrT1wDVOIyff5Z7t80Xgtb7XmxlNzOvJTq6Yti +JjELAs5fqh/y96hseOGhOMlkK1z9OJ+Lt/L5XOIEFiGojSVxFOhrhyx6nLS5WGZZZ9BKEnOUHq3z +zoTL1IWavLTJbnut81O181nVKfu5G9jfGFll2DH3d3bJbu2EZadEqZ6zy7ALnHdPG1advtl0Wo4l +VZ3qc7FSkanKC6dPdmPuPqtyZUJdCthmyC7ZjYzrOtXW49sbWGXYcVtb39z8ySrZ7dEu62xgn2E3 +qtctO92pdj7bVp127OvxXd5Zd1o8eyxbond7SO+9WnV6qc2wQ6sKNqw4a/RLpPOUy3Z7Zu2wV0HT +knmquoLIhC9wO1F0VjkTRfRMspLSpXlfL1DtfMcuQm61GmxkiOeiOSO62BmtJrXHOUJV7zWxrmP1 +7WJIqnMxm0E5Bac6xXlg63WVleTMyo6Y3KniwrtkV0nOkxfuseA6RNIhGxLdCekhrs+piJxtXJ97 +enIoImc5P7O6b07FRtzOz7nWgGukO9UZ0d2ltkT9OPf7pdyxLkRkGe7qtgCdvad3kWy6xfwwXrPp +zOwAqRbn6rLpXN4Ps2Q2nZlPUL9fls+mM8ulWzTz0TqbzswXbx5pv0w2nQYt4p41vX9sqWw6M1AO +N4QskE23oET2mE1ndk4jy8qVZdOZ5dKp7f3VZNOZ5dK5jO3xkE1n5muXKrCvLpvObHWRp3el2XRm +yo06dnQ12XRmuXQWt80vkU1nHNLnlrWmtGg2nZly6gusOpvObP1MoqGWzKbTg3KsKbxQNp2Vbrna +bDr3GFsmm04HSn8mvqJsuoUw5jmbzjbHamXZdOa51avOpjMDAHpZcTad2WmJLgZ+Bdl0ZuxBa72u +IpvO4WRkRdl0zvJlFdl0ZshQtPFVZdM5ZXKtJpvOLJfOsh7f8gZgTDEANfXFPF3dZF3Fy1ikUl+b +w2Xi07fDZtcgnxlZ1bJZvF6dYUgzeMqz6np11tqFOzzNIkFPeFKwpImEhDmZjoqFSxLQJChYZD1b +DUo3JLeswEV1Oe3B1EJDghgDg/JUdtluSOaBFJYcxgZPNmWXLVgmlGJai+iQPJ7qLCJ6Ozl2KGxu +75mTq2XZFbpbusyd6p4rlyr5ImXuLKvLnbjKVXJZ5s4qk8tdIp2rAAn7+GSl0N1ya1W+H7upMmPr +pXJV5s7RowgRs3SZO1GHsS90t3SZO5z75lDozt3h0fhkBfdc0YfXpP0ius+zOFlZiNL4RFG5F87l +AVM7CLulT8tTHligzjH20Ik+YRodNJ5tPfCuEuncRDT7nDMMrYM4XOcXgl5swg49BJFB7Fi6/rSU +7K7CFuh5K6jPJ4KXplrO2exuKKvznvLFYMHELk00FCAqh3hw19FQAJRj/JjraCgAzF1Et31gM+J9 +K8l8XP4oBFYUtLkOXFx9l3Bc1XY1g6KK7KqtYgciKIZMdtNMYedcdgTMVWKtVQ0IfWJtbWhMrK0N +V3crIAS2kkLGiMbAaN0wM7XsskRl3QyVjvVe7WKod41HujATzxhBbWuJW8VQd6a9lWSmyDcfe9ck +jKCq81VVMAQvLqyPiF3v/WtPhaqtTt9g4bWl1QkMxS6q0wOcFdwSgOEsW60aQ5E2odkNh95iVa9d +JDJ4OuENR0y24Y2LRAZXHvilK9xJ+ZVWNe4W2IYmwRWL1q32VuHOLvNxiW0oEZpY4W4llfIc84nc +VcpbNp9IrpS3/Da0qXCnzUtykx+ySIU7u3qvsMad9wp3bm81h9lPyyfWPn0rao6V9eo6sRYAc1Zz +fG4UHVybbrHEWn3mI7us/wjmF56apkN7u+cKwVmAbxruiIBwVpLPeUq4s8Uc4VjnwuqSmHxO10yg +cnle8tvNkpjUp6KQQUQN2zAVclgIF34tqe6byzQmN0lMwYMXvSWqkmJu0pi0k3TwnSqg5HWxTGNK +hVxlqNua7fKuTIXc7Eo3SUzBg6Fe+V7UrrzzlMRkFUEEayfaSFpviuGdmMO7xK38Og== + + + xdDkssS7e1wDYhU5rvm49a1i0H7xWpHOU7lHhEprfex+dVdT3aPTtxXluN5bXk3lXYdpTj2Ve3So +lJdYMMdVtT/lMAwXWc/OOa5gSK6znu1yXEUPEFyIKm/en6T6wYy3ykG90CPzucTxbWGrc1zzBQqH +kVr9YPQW4cCv8gXK7ivdPZXaVDC9WcCCB7l2Vb5j8ZcmCe/s8ErdqSYfzheYbt3cX6hdVdo6bKn8 +471FPlzYOglvMn9LkVqerEvDI3atcv+4rW3+KvxslYT3ZNkpmMtmaUxbzpUobz1cW3YaPGrGP6zq +sIWVTuVMLgXBFyyl6lSbmjYN8jtKHUFal+UYDh0+9s069QUggvU15zRpeA197p8avSf7FxadclsB +5qzwpvhg9Rlxrzadlrc5607Ll1sPZp2ium9CRZNaqe/0yq6O4MmNdafF4nVJE9kFut2G76PyLzEJ +c757kNCuvkU7Ok9YtlPnVxJvu6msC4iR1GhWVMQkmPM9o1c65cMa0dujFZ55Gz+xLOhchk0CpLJh +dBqkqWLmHDjpQjYD2Af6xCZHD4l1SpIxtMpySJCSrQeVd5Pa5JzYNF1VZRbk0HWozOLWk1SwD62y +XDpDZRbQQc1LCJpd1p3u5sklstIcIjQxlnzu6El36OV1frLXGubdea6yaDEkQ5SWfr+4RrqnKC1f +wG5Q1n5ib0MC3NI6TkscjyE2Vseuik/pXe3hddFYM2UxUwLAPnJx9bWDD/aluKrLG+9jG+5uOHSR +jWTrXnZ7yvNSXOYmWiUn0XBl3ELJbuZH1p7utX4pLuhZ1t6iCbMAl72E1uyuOMt8MSerxXhXnI0B +ZO4f0waNmByxNkqe6h1Yc5jSymzkRknPYRY99cYJd1b7GJ1YOZev04xM7+d3dtmhenyWXhXm2xBA +0BMm3vURi9pPwYM768NBb4lkhnoWS5Rls89k8pRjlfR0z4FqSLr8l3bZznfsqI1rhqQK1RdPq1W7 +1mMqYG/bRSqn+p4rm1RAp5LGDuunnLy3y86JOq6JQVfX2LTKjAdgTlV0gvrsWhtgOqmyHMYcc3nc +T1J7crkkxhzr6XjCWJV5sgBmSBc20w5FjC2YBeg2B9D1PSRWCWKucgBtotNdZAG6zQE0+pO9ZAG6 +zQFU33DoPQvQbQ4g8lovnAWoIRUbC1MfB+stC9BtDiDE2OJZgAo+7fmGNsfKaxag2xxA2UZeKAvQ +YkiGHED1eSUej3FWyxflc1+RbZmifKq5/MKifAavwi8pyudUkW01Rflwzoi9grJ8UT5fwEQrXHlR +PmN95F9RlM+6PvIqi/K5ql+5TFE+tVcBDoqzHJSIIqfUYOuqfsvfDXW8iruhXNb1c3U31NJ1/VRT +W8HdUFZ1/bzFKS1a18++qt9Cd0OZ1PWz9wqZW+Le6/qZE5/t3VAL1PVzpuRV1PWzjwyRPVdL1vVz +yuRakUPXtqqfL+DJoWtZ189+ajrfxcJ1/TQDMVT1W6ACiGldP/sJmUWoLlLXzzQd0e5Wc/eIcZ0p +a3oX9AJ1/exv/pLPxJes62cr6PJIiq2grp+9W9jTDVQ2df3sTV3TKOgF6vqZpUkqW2+5enwryHn3 +VNfPHgr086+irp/9gYrPNZxlEt/1GamL1vUzUTVVVf3U1RmIJer66bYhoa3qp7mzy3N6CiHX9XPM +e11JXT/7qn4yJS9Z188+4FqVkbpUXT8lf8uMFnX3XC1c188egUiDXUFdP5u9Nu3RK6rHt2sPxXU9 +Podycq7r8S1V10+GYrp9vGZzGOr62eQ9OEbbdrzW9bPX5OGNB6uo62clw2+MJ4mL5W+5UOelk0Sn +behU18/+vFkbRbB4XT8ttvXW4qL1+LwFaVjX41vB9pGr+i1fj89NEpPT7Q3GWA1vpfj0GanL1fXT +OLYNVf1wxtDydf3kVCm7uqJL1/WzV3MsaMxzXT/7qn5L39ok1vVb0tfnsq6fi7zXFdT1s6/q57ke +30JZuDpuaazrt3gyvKqqn6qXper6GV3J6qp+Vrecea3rZx/epZNiC9f1sw900vmUFq7rZ7Iuqqp+ +9vfCua/rt7jfUosx7zlPFnblEnX9FMZlVtVv4ehBXV0/W4pQVQBZrq6fvWKIrdfl6/rZJ8SKEnnp +un7aSeqr+hn0Mdc3WWnr+lkrQViHcbjJymVdP1c6zNJ1/dQraTzAscmutdif5nX97IWDbRbnyhJi +sdxPmIiHBzsd7fzaPOJDf6/UJ75RUScrwVNr16594L0ubVFDTRKNKac36YOxOg8e+6bErkIaCRkf +KYghEucdTsbnmcYSrU5h7hs1/dwAYuV4I/J4tk0k7no8bgTzqTa2T9NHcSI03Ei0HscMPfk8LqX7 +z8nL691QbBAO5r5zROXjLLv1Pc9xG0+NNg1+vWUCrLBX2Tk9/75iv3v3j74Az8aZlnBauoufxCcb +bLXMvOWueteH7dopd/tZ75yx3zehzvv2bTbMFL4261cnvVR//27UOQwNv1/578AkM+TONm7PDoPb +dKjMBd4fj47C88+tR2b01EmJex/ldqav67WbjXjkJbNBfXzfRPbpYIYo5U5yROm9dUyUuZ2ryeQt +GZpMhduj6dYL15yyzccLOdOyHjlIxG7jdDW5KaW9fSUm06cRLDaX3MK51UYeoskv3Xuoviazrcsx +NKjlEpCwnuT8jQzsZjPVYzNkIWSA6c524LrQ2xuWc0UZjaFGsHOxdfNQT28PJ4nSDsV8zLf67Y02 +zCQ9lpJDN+bRMXMG49VOhygncSNbqtcDxHanjez9i5FWZR/rtg+Y2kVelTSn+FtVUwNszQwPaS6Q +n/sChYdS5w4V0Mw/l6/uuLN8ezOTmO0fZxLT9l4pudW7KN5m6BeAtmG63L+5e8pWuI0mgHPzLYHF +5TNDZKTHw1TG+5fMXnVjgmaVHYwgJWdPbm9fI8Wbuwr8BSZ80Y/DpN0oNuvT7P0EWU5EYhaC0Qiv +M8yJE2w8KP0iQ8h3DDDCD8Gf/C7K+gUM52gM/jyIIg6zFQRS7HECHuTj0oelRKlInQoAbIWIFKKB +eSlUOToio8HPQbHV+04SiTQfRgOFg3smd/PkXr7bSJDgxUFE9aKxnT/wBaRX+Zjyiso9XB9KL44S +ygt6e+8jK704J+UXLyLayge7yjOlZyj3y/mo6hXsW4RTBrseYGIXzPQpAuccpp6nX4ABlq9IdBMO +WTm8osF0L3dV021+RCBmLwHKD0Y9srXNp+RzMcAKIXnlyFbsgISNEjBvaUC2Do8g2i5J8ZvLawQW +JrXub8GeIzC3GImlbSocY6D2X48pnVLhw8we7mUPHnhf5frxj93sReu9Wjg52qgpJCkfC+S1hmtA +a3DmqHCltG8GD1DyohAvqwcyxBw7u9julJ8fhI9sbb7dLT60Lwg4KxJRL6bkN+p5/pIRV+P+hZbI +q86opl445FvSPriNIQRShcs8lIC3CYnsbwHs5jOszXZLiuoueytqFyP4m5Z/MRhEcW/AgT8fRIiv +rRJckoeE9PUDIf8iVaN5o1660mgeaPTCFxBfFXrb4j7ofbF4LlpJqz0z3dGwGZkLWLAZICsho9Gx +mdTz+ShUvM2dHufC/QnM6ecquSIRrxvZjL5KbxBRG+ACArrRNSyfiwFuKe74u14Ek2Tu7mUKZrUZ +T3Q3L3bo7eRgRhCh+FScLmAuKG4auSfBn0wYZQWTxacM/DMFNtL2Vxryjahq9Z/ANzeQJipxpAbB +SJU4MtzJ8kscGuaVhIULpkLIBLmjcqek2ZMQDBX9JqPE8M0XkBbqZBfvu2g+0JSfifsX6HBwO5+A +hedvKvm3XratYUJVgmCbJ3AhTlR0QJZz31Dj+DhHGDsDHdyPECeGU3/KimoJYD34GWaukOFgSWMr +hxTnrGmkvbSMIe0ZfHUK1ZwMEODCHOs1O+yopFLu0LPNfHYTfHY1g41vNHcfSJpSWA0i2i3qQETy +24dFWUBXqFDynlZUNvRsczN9WCbagWFhMjkY7apVCKAfoHsVSgEFBNHZZBM6EHd3F1kZRDek2Srl +PkRqCK9f8WkvRu/sPZIAx4UopBzJrkRPIY3F8dPn6Svc4k9Tic28zjSY3wqKZY6pj0tZU3pWlCRU +YBqqmpvwxT3CnUpPDipKy27mdrch6SYHlKSW4PsZgPjbZMr6YsuwEK60LvMN2OkGXgFm+rgDpVjp +dUO6IyO5JY6nf32mVt7vo0MRY7kwdHrgSyEqz/HNr2uAp0gJdBqPoQ1uvC0CeuHAyMoREQmFaU1G +wpMaCfPHcxkJuhs7IioUPE7opuruDhkFvkA4/9B+kZAAxqNGAj+xRIKEgt1tFQoO898jFQoOQ4UJ +QgGgZLFbqf43WhJnJAAm1EvgTmn+vCeigJqTZnSAb9W41yIhoRD23cYoUcRImOTuHxUkhJrbV08W +dCBeRytXLQd8zIyUbEFEvNOiNnJYOgdQRuF5DDEzAGhdXIOIL7illPjkMLHkakStaRpxfmkUNjQd +jVqAcIUHxPmjcRfToDOXoZAIonF4rh0DaT8GbFfa8qcoJYHgtpTVmG6WT/KadoldpR0slX5hUecd +LE5oWRoLL09jiQXHoKIxclkaCy9PY7uWIFwAwDQWc0GmGhD6aTigUqQxW0wQS1JEIuILuMCELQg3 +nM8XsAVhhUpXqwEBxNXenoWIKuGasJHcNwVBLDsN1c7wBRabBuVpDGjv60dBO+/PCnNwmo/gMUzS +rObSrzdKLwMUiewWE1TU+xh03JJalqiouBlFeOKWlBvlxkwOKdySWnaLU6T2T0rHxyhaNBZC7Tow +SDNT7JFBVpmi6afLtyFsRSg2XfEltS+afeedoWjb3vVi1GulHSUSje8YsobhHRHTzxj8Oo5sEPrw +ehPZfkHpOHEriIJ+kCmMvWuyKYx9a8GDq2/wZyaG/3yedpChGKS39/ffSq/hR1T/5SXzIZurIdnr +90y0Q6GUZJ+mdlWONdUM0pmoyq0WPKympReluPIC3Xchu2CAsavyuB3ejHOSpyyFphFW91zORFRu +NVXP5ZLi0HtBNaGRF66aEL0K5XMCugciODMFGM8UtuSaL4GGNN3LCHacNcckJPvLmKxeb1PBdAgm +NV7GRd8al4eUc0ng6nITslU5Rw9EsK2HR1L0id6XIonTWg/ygzo2/6kwl2pLndbjuBcivC0QVL8W +KEaT4Zf/v7Zrb0tjZ+KfYL/DUqty3d1k796qgggtKhVRQCuCrGhRUC5v23/OZ39nkuwFpJYjPY+P +bTIss8lkLslvZtfdTe38Y3jwZjrmH705+vSqTis4vZ+pC3Ccx0/6LUctwpGoK6OtVHVzaO1UjeM9 ++1snLqC4RiUm9Ld+SYPVuAnViyYmnV6IkFyko4hbYRtdxYUiwLZGkXAYKHd7YorWY5WK1uTymqUB +6UGi1RQt2jWRgckYgI41G7vIsaHge1EGtPlY0vi3m5NTwfsmUbsPgDUaRdw2O9+DDw== + + + jMAK2sFcGiy1FDmJr3GMgGvbdj3Oga6Dqz1m8Ukf16s8i0vAsFMCOTfiIXIegN3rDFPCqmO+uygk +mOZhOQtGhkIqAH/AsHdj35iAMT+aZq/vAwvbKqoPtbHCoaqH9EaKeSf94+bB53lP7UirYHzHX7jW +Bv/gR1VxRp4B2hmSP4OxM8RpJ8s8TBw8TLu3//ihnyfpa9tj8mRz+aKFuNeMxaNyHjHZgjNz+DKR +w2rcYbgXGq6A0A67BkrsWBHpO9DUf3Ykh9im7FDNltXTyaM3PBk+dB/6clralNS9IiHVfmeQH3re +mfdznBvcTp68/ljekNW9SrZYdMycdzvoeDKrQTFv7AjGwKE1UV4TzURO1d1wFDp35x72Ciun263c +nVbfiVTlsCP++vPZSyx9/x12J7HUrbIaSzc7l7E0zVdi8cIojd06hyGCmb3Oh92AkljJlZw33J8c +pI5KFzMAOouW7s3Z4ba0enCx753uqqPullrYa3zJNfLnlV11rA0YUjELDvKZBsnKObnN4ZCO12KJ +rWMjllHXzzHHmYO5fMw5aiyd2N1F6udY6uuHY5zfMX7wKZbZ0zux9FGtEEu+rAxR/x2BIOUnWChH +UwIaDvM3+WbTt8HygBmGxE2IpLtdRHbPX4SPRZAYvx2AxCrrYiVaXLS+e0lhRaA9USti3Y04WmMh +I3wHvthDsLirbox9xLkYiVRaoTV2/RC2eAYqzD9Jq/9dBirMP3HUe/EMFHZhaxGDbnk35N0UKHs5 +z7YMSXBs3j5TNMzCO6yaquSA/Z/A0pZPVIy1abjBy0foVhnbJF8ctXypB/EwFclFddYUCEj1UhjH +b/y7MGVvgMRyamtrbaPbX6/mtw6M7zMwKNYjfI0WV/kVVkEtgAsj7GdDjvP48WcbFubov8eYcUx8 +dr66zmF+d907yxU72zFhTfUaCdJMdCp/k3hsrvhBs2UEU29F1at9wvxpWrjcdlUVat+uaaRdKiag +BdsNHlfa13THLVJYq3YLax1Eu2MwFmJpe6eMY4YVQEG35m+Tepea37oOta0d3cr1Onrkg+uY3oS5 +sOh+c/SyyuYyXY+RjdZQgdZG3UzgBf7sZtBbgqNBb7Ilyip2ep+4r0m/PJ/MdzOBH2N23llT1wSM +z8PxUV9M98RL+vvs9e1KUqS3wTWxbTeqsya23RcHLR5rwblgBCrEeWD2Rj08bxWSwqWQDyrNZS5T +LL0dhPWMeAaY5bixRKYm9l+HXxLiGTQzr84vEwT/4ysk1pn6xabgGYw4psKUmT06z6nHZzboPDTz +swD4miDRpESz689ZLfd5a6C99joQX0SaaTvJMmw8F5Vi68ZPPYfXDOs+zohI/byhLpyT5LxfPdkR +vPuDL2OoT1j6MdxWv4dHxHmJHXxb9Fc/sTNMzeSGhsOtT5Uo9qEVr9LKNIv7nWozeRAksaozSSyk +rURTWA36eSaFpR1snXAGPOP19TWLyRSLwlohaipGZd2P15g3TR9TfK0o6lMhhS0loKmMxt5duANa +m6684P5yyN0MBMfGzKb1/cfi+BOrcUSZiKxVTGRyNp9Og/RR/Y30EVrOn9NHIkM8L3fC3626YO5k +TuYkgmFKq++CONhLDbkIrqMiYBk9IYJGKAKYC44nKgTc6P9BCK2t41AE+uUjcUIR4D5bmUkjhu9e +X0QIiyD9b+PR7I8iv51DezONiH8ozpfi1YwiLZiJxL9LtYQu+k8d/G4Ui42hOXybAV+XN1m0R8uZ +1OH9JLDKd65G+ep5AZ0GbxlhMaPT5eZvzGJRUZa9Uegt35WY3SkPYn8eQ92vPpw/iqFfuWDUn0IW +WuGofjuVBr8K9LceWXgt/61wOqNj7DUGy+hYpb+0jnnjJcfwGFtax877S+tYffCvXO9rBu1hoGNv +qEjjrWncLyzK3+pYb7LcatSbEXPlEpsniTdZtP+d58MoNsvCGy63GvX70YxKCYktrlT13jsUe+p9 +TDv1/mTJaQxj8ywDzi+LT2Py4Z1jCPbJjZWVP9knHV2FLGLr5/eV6Bja7d/HgEhEfksSbe9lmTGg +t2zfL6lU7d5oWW/Z7o//6OrejEPtl0lkn/wuE29PYtHu7cqHqe7aCjsqcKQYyxE/pRCdsGYQEs0b +7zpsgxme6SLHvtbHpyt+lF/frpt+FWaTHRkzftXr1YifK4OiVYSqRSvO0Tw4Cienj8LsZJwW3azC +zs1K8DU1ANivQjgYJQYH2wji9vcyUGH+id3lP8pAhfknaToDhTDYYZUyVCwK9JSzKQacCaCnXMz4 +h9RJUpwCyyWFY2v4rnPonmq4+yfwTwfXRS3XOFv901lfEaXdH5WEn4sqsrVMRZHC+onC7qLvO7qz +6V0n7rL3Vv5k/9FZcSLQNYdp4eAtnjN/lUIIT+/1U/VfcZzHT5rmWNVCjlZ1eyO7V13bvMne21+e +9872+hccitu/TF6LRNNtLaiYPtPDZxeiq9supSMYbEsAkO1T/mwDPuGe4K3Wh3MOwIXQEN1v6AXM +jdRZooW1xMK2uybH1jhC26sqvMaRBFXPmSAtlInisr0WjQBrEUS41zV8/KhhirnUtBV2NAthNf60 +4dwC69TfK69mqML8Auu/WF4trf62wPovllfzXNTcAuvUe8qrR//sSJugUkVCmgf9TjTHJK2uAqXi +jSfPeIHZ3Pe6D/1S65c3lIjMfzT4IbItE+oEv5psIrnUluL9wbiZG/zoPw5aHa+TkEt9abWp7g3H +uYfb8cOg3xr+kjeARGR1fzB4lON7xUr+Qj74+TwYjmV2K/lsIGcrlQQmuN687vxh9NB+9KauV2tH +pWoxJ2/IbCg/zfzUcDaREdGaMCC4in8FhNGUNHkPfms/pAn8EDkHnRNJUwybUt2SNUXTbMPgDU3T +SbRhGqbmghAUh9qGiRTX0mzHkGstSWMSo/Bb+wWdz9D4DqQfsiEfyZffNLmDdz2VKFV0xwBpGort +aLr8hBRiWKZMdEW3TCpTolBLt2VbISbVDbkuEQuuJUjRNcd05ZJE4VpTN3FMBMZLgaQTheiOLVuK +Q+CLeJGpuAYwsBTXpcTlFOroFG9lazAB7OuGgYOxHGrJ53gFcQlQTMUybVuGwVkUxmYBWXfk2dFn +pbv5q27LarE/luOV88Nm5b717J39evYiq5CcgDhA9opjgcBxIo7hWq4LDdtxTbwFU0ANZUssmLrl +UhgAiAukbpg6UEyKc4BZwcw105RdhTg6iAf6DiwmztI0dBcHrRkEx+wYmgNjniGU5hKI7dpMDI5j +IgvXoi7KQSOWJYP8mVhAwq5rIstpAnAwQKXgSqTY1EZRGxZOCzgSh/VNh0ne1jSKHKYJbLEs+CLM +AoIMzAKWAKYDs9SoDasKfWrBrUApdBAZcpihgE5Q1CIIUbbQGRQLmG9UojOdO2YTeK2DNg83o2AN +T5KuKdQ2UZkMBzWPjw8VzVJgXqBEjGK6Jqqgazm2OU2xNZi0obi6yVTdsi0H+w4ODvUPZJWVZggl +TnAYwUaFRb2z2Uq5hH0fxkJRqJppCwZTFMaBugQJxMVb6qA+XMEp3CqykqwbXUlGYHJj6oUUsBrU +Bds1XMaREJ31daDjEClYKdOvKUrpldWXpq4hjtA5MAHC/AA0UI0tzTVwBant6tE+cQgb6gyFmYIJ +rkJGh2ERvA8BO7HgPrACFD4SehBd23mUOylZfZ9hV4Un1HxPCP91JEuOJ+TaBft0ilDa5/EHohFz +9ZkMhKZyq+udDVsPjxCNuqPW/zy51Qcf3xp7z/CJ3B16o/Fg6Mmj+8EPpMBX/Mshrp3kpf8DoNWy +ew== + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/originals/SVG_Right_overlays/Not_downloaded_right.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/originals/SVG_Right_overlays/Not_downloaded_right.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,1570 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + + + + eJzsvWuTHMlxIPgL8j/0fZAZaXdoZcYzg7d2ZvVqLW/Bh3FIiTLZ2hg4Aw2xiwbmMBjyeL/+/B0e +WdVAAyhJFLc7Dd0N7yhPD48ID3+Fx9/9b7/+6tnu27d/ePks3s4309/93eHdyxfv37772Q1Bb37+ ++vWPP7x/h6Cf/OanN0u6naHR7ufr19LwH1++++HV2zc/oz/RH+/w0z/56sUfXr588+Jm98PrF/c/ +vfnJT+Evv331/vVL+Nsv377/+tu3f37z+u2Lb19++/W7V9/98f1/v/3hT9/9VAkAjMcX76Htsvz9 +HP4+zMt8M7ef5YoNXrz504sffnj1/+GfS1wjwPZvf3zz7as33+3f/r8IvJlvYoCf8Jf/+uo3L394 ++M/Ht9/8eP/yzftfv3v7zcsffji8ff323Q8/uzn85cWbm1+8+A7+8uLmn1++fv32zzf71y+++Z8T +9D1/fffq9Uvo5v2L9zcLdXr38yV8vf/x1etvf/nj/R9eAgNiqQiOXxPK3/0AuAAt/o7g+vXP7wHy +1cv374EseCEy7vCLf/5vB+D223tqB8Cb+Xa5WeDnT369++Vvf/XLE7yu3RyQTf87/RX+N9+mPLQI +S/ZNQkEM+MM1GVpE+PxtG3DEyg1+8w97zxkiCRv+y29efveK5gWM1H//qfT03dvv71+8+58/cDNg +cQz8l9++vP/+NYyn8P823ywZv+lv0gq4Si2exbXePAslwp9jKzehWZs+Xi//9Orln39288u3b17y +oOzevf+KJ0VK88zf+S+/+fH1y3e/e/PqPVBWENR4VH7x9tuXr6G9ff7u9YvvftBOLv07N/jti3ff +vXwP0+nt6x/f05xf9Q0w6s9f/OUlTp2FX/Cr71+++e3bfyQan9XlNkZgc278E4YklvWmRBjdlV6R +ZujlfDO7d9PIM3pEhqj0HbgMfg3z51ewdF69+ZlQWL/+h3evvu1zqoablb9RJ25X96/pP6YWOv7+ +/cs3Qj3M5cMv3Nycb3/xFbzx9Obbw9t75P4PuORgBryByfH67Xf8N/ud/gIf//F7pp7+/zUM1K/f +vXqDOKdf0l/Wr3/9+kf40z+8e/vj9z9/869vp5+w0PntuxffQLObX/3hf7z85j0IDwH037768dX7 +l7cvXn3/0w8i+vXrF29evLshOHyYgc9f/Qn+8gJIueGPwV867ONIjy//FZZ+/yxDT2/+9PL12+9f +drhBXrz59uafXrz7/uOoYRjeOQz0X/35iN6+eP9HkFIv33z7g5HF/x07yrCP4/vqG5wU72727378 +4Y83v3379rWhHf9k2AVMUGz/1/GOX9MH3vzqDTPo/E3SYPsmEAh/dW+B1g+/Af7414z98OL161ff +vXvx/R9ffXPpBRf+bm/iv33KxPrL/R/evn71w32fTw7y6xfv3r/65vXLr/7yw/uX9x/Chtz411dv +voWJSEKnU/v2/ntUK26++uOL718Szvd/vKOWXxnC/DUIRi/6nj37gEwM8Wb/xv39H969+PYViFtQ +mfavf3x58xv474vXNwr+6XQZDOIeEH07/cv0X6YZv5Y5zmnOc4Vnndu8m/fzcT7Nd8sC2kJc0pKX +stSlLbtlvxyW43IKc1hCCCmUUOFZQwu7sA+HKRzDKdzFOS4x4F4WS6ygg7W4i/t4gOcYT/EuzWlJ +EZ4MT0k1tbRL+3RIx3RKdxloyUsOOeY05ZwLPDWvueVd3udDPuW7MpelgAZQ4NPw5zL9X9qZ/rXY +v+Xi/1BrDPY9yj8gjdgR5zwRV/Cffi/yL8lvBThWgGf6fSX+4b/mftvBvz18303040DsPcA/ZDJ/ +B2YDu5E4+ILOgOoGX3Hpv/yX6e7u7nR3vDvc7e92dw2e9a7elbt8l+7iXbhb7ubT3el0Op4Op/1p +d2qn9VRP5ZRP6RRP4bTAu+Djx9PxeDwc98fddGzH9ViP5ZiP6RiP4bgAWXeH0+F4OBz2h92hHdZD +PZRDPiQYunBYgPS7/Wl/3B/2+/1u3/brvu7LPu/TPu7DtF+gf3e70+64O+z2u92u7dZd3ZVd3qVd +3IXdAqy4o7G6u6PuYIeO1CnsFnZsZ53D7lXqInYSu5moq9hZ7C50GB9EcjpN1HPs+4H6jxxAHjTi +A3ICeYHcyMQR5AlyBfmCz2zcQf7A1wRMQjYBo+BpxKuV+IUcQ54h11LvzPnX6ZHPcftM5yDh0WOe +/fkzXQDuzh/oTLr5u6/376BPBb8qPSs8TR4YzLKnB+YF8AGZeldJdFQQESAMIj2pwpKFD/PXWttU +Gzy7uq8wpZCJMCJ3K62YdYEHZMgKgmJNK6z0ld651hW/2gqzaIWpth5oCE44Ndo8wdICkdRCiy01 +EA5AXm3QurW2owfmZ4M5jGNHEwFmFSxCEGIwEwPMxwizMsHcxE4BZTSUuP5oHQZ6FhKB/CQQhRFE +Yabf8HsCsZjpKfQgBwp2hoRlg5+7iX7Z40vh+16+H+iB9QbfTyhNcTYHkkP0rhjwCyQoSFh8QBaC +lAWBF9aJhG0jgbsLsChB4h7h+wm+08IA2YvSdwHpixhQzIIghTFBW7iSNF6h7w3kMUnkB6QNcouX +D/EP+Yj8RL424jKOZyG+JxiBCBRhV2ccHBiiIwzWAYZsh01hEOtEI5phfCON9QLy8g5XJcyEA8wK +HIEGE6XCpMkwfRKQGoChMyx/nGRHmG57GKkGaCpMzTyB3E+wAwTg/Azy4QQr8gD7ww5IWnHywa6R +YX+JwLwFRPYdLPojbDF7GPSWVnhDgc0nAX8CjOQcWS7hmqYn2hPkofE6zvzIYhN5cyBhceCvPT07 +etqEjDsQMw4083HZgEDNJFQTCVYUrYHEKz4zCdk7ErQoao8kblHg4tduIrnbSPai9K28GkEGoxRO +JIlBFsNDM20/k0hGoYxi+UiiGYUzimcU0I0l2AVpcOFpj32m4b/rJz310jNdBJdHPvn86bLuX2za +33zgF34C/Cs3eb6tLVawmgEBmL5ffz6C/Q/w9jSD+AzYtKRW40UsJcBERpN8haVNbdo6w6pTjPU2 +tiXexHzbcu50XR81UQxLa0FH2W0AFWxNF9GGVOeMaAsoiYmcSKAvQWNBu9yiunUDqlgn98p4gdb9 +0RRt1YAvq9B3L759efP+7c0//RHV+GnzfxiqwEozUpJBBNEvsYKKei4+gaQWllzHX5DKcdIhnhvF +c7Gz/PHxF8RjE2nk3/VQ0jB/IboZ0NV8cz36DOGnDOw/vHv58o23ijYAwir2kAnRZEJ03ohQFZ8m +QJ2Om0irCKRjzKTrygZ6cFtn3zZh4yTpC1s0btYzbN+4je9hY2+w32fSAxbQDVBP2MH2iupGBP3k +DnYgNCXQEgnz2dfWEjpvQDK/S9AsCjZYZndB1OuAFsmgZKN1cTI9ez9YGaBZT6JSL4OpcaStkb6z +kdbEXspiV6GpFcUQ0+cTvh7XV7Ie0X5kC/IAugIaAndiSbItadakaL6raLwbbRf13ckpu4mU3ULK +7oqqLuq59FannbJu2kgrPZA+yrpoIC00kwa6wgzZwbw6wDy7g1m3wPyLMBMzEFBhs2+49+9BFTgC +7+9AUVhAaYigQmSgroKCwXu5KYALKYBohuNXMlWQuspqOimDaJ43MtF3ZKaLYkjGOjwTDmskwyvR +eCVSfVkzRZzebHAd2ckywQVzpMVzR92apWuB3sSLLfPcWMlSPpLnIZJavZLGfITpGEgPruJpUDcD +9o6NMJqW/AVTlactTeBFpjMpx2RD0rjTg5rFBddB/+L5yA6CSL3PZvkDtfRh0klZKy3oqyC1lBXT +BVuScsrqKSqorKKCkkof/qCt3EVHFxyJdW0e6h1p8visot1XGV4caB5y/sKJwJMC+uFHTNhIjBRL +YZXJsB/8NTjiyTw2oMiT12b028CYTeS4idAukxbOK6+vunHN9fXGVibbl4NtOZFpGWy1dcOSV9tu +a1WKXclWJduUalXiR9aJjEo1Kw9kVpKTAM1KetiuDMTZZNZloVVcxcrE1cyW5n46MzX1YZNzFrOT +DU82Pdn4ZAPUP8SBSX58cGp+5tffKsLFfi7m2Ft4b5nIrxfFv0fy0W0//bdi21KlLarIQq/u/+Ta +m9hvQeNDa6LIati7lYDLIDvXpW06znlZZJvhSQ9THqY7zHneWpJsKc2m94mmdbApzS4SnMloax9l +BuvclX1nogm7sxl6kjnJm0+2zWcnm8+RpPUdWY9BJDRvQRWm+Q5N0D1ZpLQNwUa0kPUayZotZOOu +ZPXuyBDGrxMay2Q4L2RK47aSyY2Ga3adjit52PaiKxxBlN+hS450iUAPuuyQfSQVyJ3Ha5Y2FlJG +9mqMn468GRy9awNM+7058tSFl8S8X8SgP4kRz85PdX8WsdWj2OjsBD1NZpjvxB6v4g3No/q4UR13 +IuxZ3HfFMUws9VFvJN/LUaT/6HUpG6/L6Hc5kYvsQO6y3WTulxUmCvtfMk2daF6YBWcyWdPsiznS +VNuLR2ZH8m4lv0wFm4fUnGwOmkhOmkCOmkVWCe+sJ3HaHMlxw494KsrOnjaxVGV91Jy5zpe7H3y5 +6sntvlz15HZf7qy+3Ol4Mneu+nK7N7eZN7f7c7Pz/AweH/b2TM7Zc8HVc8HPc+7pGXw9Ezp7BneP +d/g4pw89zfl91Pej3h+edXm0X6K5goJzCC1q05hdo89peIhTk/zA8fnEoICFBR6KCkzbwICoO1uF +x1QemuQncS6ya1FnNvkVJ5rUi03no03kphOYZm5U16I4F4/mXFT3YmVFbnKa3LketxNX40quRnQ2 +srsRHY7kciSnI7sdjzQD9hN5H9n/iB5I9EEWUqkSeSIjeSMDKVtsGqHazROc5yVPIh3cHWuAg+Pe +hMI8CIWDCgXHt2o+2XQmD4x9kwgBFQN+/evanwc3reelOGs9I6cLfPRcTOK0DeRa9zzci/O2DcxL +U/fiGseYV3tTkFdRjbOpxKwQo819t9knDrJTrMMu8fjg2CY0NtEimD8WGhN3e5/9XeHvc//AYl0H +T93p6kwf5zvPdpHNND44NjsSuauNSihhEhd6H5HmRoPHgh3oJxoFncI2eUcGkj6+Z4XFojzLJr5T +TXUZlfA7UcBV+QZSJtG7VePuioxXZcImnrM6M9SZoDgQk9mfqtuwdrOSfN2RzD2QHD6JpT2bksP2 +djZFB1Wd3WS6Du4NuEeottP1nUQbjOk8ovKgdIX3sIBlpYmfvSlPB0F7tGjDnalT+hJ9UbCoBcYm +5Z36Xn13lVDmKhshU7GTDZKVMFXEjrKJnnhHvRO9THWzrp8F2YaTPFme4jS2rrWtbB5N9GM3KHFO +jbOnf1nQlA181sCj6ODVtPDDRg9Pgya+V1PUaeK56+KTKONHiW2qNp5NH9/Z9L57UCPfy5SmUOVG +JR9cQZecQaM7SDVydQnFyXmFVpmyOmHZMbSYRp6dTq4T6+A3DAlZuuwOye9YJP5YKA== + + + w2O1kOORvS+D4yCR44BcB5Nke+xpIp7Eb6T+g+5B4NFSH8KRRqxnfyzmRnA5IFW8eHvzJ3iPQjAv +XrbhXIeoNfsVjpO68SRovchGpt489TF4L0OT+PXOSTeRb/VucoFsDWZ318MY0tZnleC2eiJ2674/ +0yq6pKxUXTZDoEycFd1lsZjjoj/iHpro2yCmKYMngmwvRC7l7zivmqbuqBvoTlx/7ATSpdYXWpjM +7VMet85gQI42EjgG3o+KPlRh9LiF9A0Ev4Z1Jt1P4q3p2QDsnjlObqU9tF3s3YqT7cI8ldnsYFl2 +k2wWslFc2Cp0s/DbhVuHfsdAkT4N24ZuHMltHoXsla0I39mzH8X4JI53N+7Og78TD7758MWeuuTE +3w/2c7UUmDiJeqSW0mkwo7shXcUcUlO6G9Ma6haLZzKDejSpNbR9HtbehLTFuFbzOk8WmHGhmQ+k +N/gEh+KjNWpyT2xzDyq2Wt5e0d7J+lZ1u4oUyGaIsykupotq4IuIk9ki3bp9Hu052LMfHpZQu4m+ +kVntY+pjOLxnVGlWlWZWSdjHAj8u9DO5PKuD7dm6hzeXc9Wt9WpqQHYZWGK7T2a+B5eQtaie4VKg +Ts6iP5pd3217se8nWQrNntWezsFiT3ZPupAAAjM8uGdxz9yfTRrWaXiO4zMdzr/2Z8/ugaedP6Q7 +chjkPOfPMv4eSPj7oFUziYfi4wb+1roZ7Ruz8Sfza+lSUzMnDVlE3ZOlJuvWXF3Y7plcFtHePFbV +mapxMFO9yb83c6ha/CZNFwI4nF/kQzgSxLFcI3UAeBeAOAEmsWFPMrfIFyDWLNuz7BBgq1YtW7at +srkHUncSTGPYDZMJgAawa30cfS1hWT0g1TXRL7B1BjrVEziDggP/IdyiDjQmFFwXLSUV1GWGBths +TrlRuklpjXIByDTHI0cpzw1fkmFkAqYALIzbUhRavA0wEzqhV8UqOS4BZiYiCA1wIcbQ5iUPfV+W +WhBSlAkBu97zfG5KuI0wT3yKyzXREqXLCjgHBKEUQDEMW4a+IjsaIadzPowttlvc1m5iwgQgR+l1 +0RKlXz6dUrmlFKEFmZPCNWfqFjWnwKw1jnlTS1jTwJVG/iT8pYacaERnZIsyot7CGzBtaWkuE+a6 +eD8lIeb5qzcv6diTZcRsIT3baXNEAKNhfEDgYAcE8HhAHQzIOzkeEClkX/rxADQcpx6331gYJ7Ev +4iakdsmYd0G1KZ/EvthaF4czE15ti3MT3vmnJks+bltLfnBNdTvD+6b27SzjeLpocajN0XMlDt3W +d5kSZ7kS6OdXl5WaIuy42knAwDmvzCbpVolaJkmiE+Wwov7A7quTBOnYYVXIwtiJg0qmQpDJkDUL +QiYEnxmZ5dRIPzeykl3qvAs6QSZJcc7iYnCzxJ0hScMpkm1WQvDen8ls0ke5fy4apqvL+SFPwck8 +BcFl+9Sz3IOT5R70fHZ1Ctl0mrbuTjerwibbYJvNPuSya1LB5JLZ88aa9fbsyXmQgrNmt57P40QR +3QjzAu1VtFOP5GwMNCHqsX1sKoyTYXaHiPp00DT4o0yGeRoExjgZurdpcYkqRf1NNiWGSTE94BMc +p8V2Yuw3UfqeGJanC3kqo4hZNikqQ0LY1mm0ztNW7thM8aLn8mS5OF0ml5VydvZh8JP3yTI6Ppyn +HN0eGLnAOYKzA4XKSYL9SSZH+9tJUOm5h+GBbK9qp7noHNf5DOd0tfNDctFcqJK4RhNZtz+cvoeJ +/GsLiTLc91iG3cE0jbTXYf7UEabkAlMRE2ibus5gzkWYayvMr0M9wWSKMIkqhogO6wmojTA3KkyH +A0yABYa9UJ7HESRBAAlQaVxPsD0EGtEdpmq4pb6C5D8cT2CFhwlWTqF0iwN64e8WSqUrMCN36Li6 +s1Nd/oja5xxQG4zV6ZrH09BMnT5+PO1DSXdmmFr8eboYh9MjLT4O54+znB1m6SdZpgtHWT7xIAuF +Pzn42eI6WdwzWsTzREeGOM94pZNFGSYpZRvTWaQTZRzvKed4pUNNfOgJD0TBcrqjc4sHSkHu6byJ +8qsWzS5+mgpPU+FpKjxNBTcVnLtqLfNMvgXQzkprZJO3nKQWCdmfl863fNrH5AzLp53M+pJTXZ94 +MuWrt//6nusG3fzjq+/evHxPB48uQfuZfeXBpDyYlAfTMs30CJsf3/KRA4LnZMp6C1pnuqnxFhTb +8Ekjc+nzNESP+extyUtIWBsnLviBeLOutzWG9mkkPIzm8ZS0/Hkzc/zkp0yU37158+L+5bc33wno +BlYczJSLYJqO4rvZVF+4aDNfdLE8YDJPZ/ZytTMy/jT4ssmZGLMmXN7EZCHd4lInnMvFhXW7y6Wa +WXyWCrR1teSzXKAhvCtuFjKKHzZmfO2I83oRUf5psYheNKJgDYluPVSrBsFG8o48PAcyJXo5CC4G +Qf/gnXdyGB3Pw+C/MIHIDXYCXc+e87lzPHVe+dw52SE7Etf9kPnJDpgHOWQO4n2i0+WFztZongdn +euzJ/uaj5ZjfA3sEHR/RM0X5gaPj19iS/Y48XWNL9jvydI0t2e/I0+dvyf3s0rZwxbZsxbZoxbZk +hatXMQ0Jzq5cxZDaPFv0r+c074egvYbty+Qi9y52P0Tv+zH13VkAfxvCp1oh54fTPxLH50R51inH +IhaXzpqfHxLPm8h3j33HaRP+diHwsyC45qcfL0bCJRY+uWB4D4efB8R7SHwIirukdhnvaQyLu8D4 +6WOB8VH1gqXf1vwhpQY2saWVeeXYFMgb/AVDJ+milnQthBx1ayC/EsXx1nm5jCzAGqdT4kV/kTDU +ZaXxeii/bM8O68U9G8B+z+axJT16b5vFTtK8KClEziKpa+rSUdrQD0FNzrf1SSdr/delvZF9vxwR +ongQbVTJlYriSJCWiWqSPIiOXPJ+TaSa7CXyE6gcVC8GBQoJqSM93rMjLxi7Zu34FFFmnsloyVb9 +CJJPsjpZ3uwyJOf29FzSTyYJe+wskUrzYO9c8qsmvWrCq090XU9tzLr6pOpAl8r/bAoBTZ9S/+eh +oj8sSj/TDL9ghdOGP335ji9VSVzS+cGS/1fbSXUv1d1UTVw1cjnrv5idGyc2dc3YVXNXDV41edXo +VbNXDV8yfTeFQ3KZW/CSpKYcOL6vFiLq/Sj1MAVhAe2iXLY1vxTTaO3CilozydllwbIdPq7M1T1c +AY2ZQA/WlLgWyi8Tn/Gi9IxjPbumPvrhkcNO7nf/HIbH53Qdp/G/op67Z1zkdvwyDkmol479jwf/ +R8PkTuO+k53/L5ePJ/jXk5S5UOnmTOn5hGcataTzh9bpqF1/gnL9ud4un77+tF8+7ZdP++V/mv0y +ZpAQfuvIsMB93hZtJ1zQCf7IKVAX98svxcT75ZftunEB0Fqvtosrvr/1vTxd3sxTHE0h/HpKPXtK +PXtKPXtKPXtKPXtKPXtKPXtKPXtKPXtKMnnKN3qaCk9T4WkqfFbqGe65n5TUtaBN3L4gK0wQPDbD +SA8j5tsZj319RvKbfvQLjfR22Uhvzkh3HjtSkVU9Jt3CDOvoakZ0o1o1YS4XIfqvmUWk9apB7XVd +1nLHlKK7oTyEL8LiiiJOj6/E+59Xu+Q8pSDf2UyC7xvn6oeuATkv5//RGv3TA7X4HxODOA8qgDzo +6RjbpIyz5Ay+tuFjntZPFNLTA77WzxbR00O5SOcimjOCPlScI1j2z0k6/oHyHMyEaTjrf7RMn/Pi +HHGoc3lnqT09sWdVDhXL6flgrcsHxC9wpizlohiV3BCQdBVPvFLayJJL+3CS7hciHH2upcwL+3HX +ODp07aRzoiPZ5if9iMf1CxF+mSjPl/2tAMabOJ/8rU/+1id/65O/9cnf+uRvffK3Pvlbn/ytT56V +Jyfb01R4mgpPU+HL/K1268a6GUYdRBzCS7ckPHjIaBpuRRhvwhxPGo03Yfpr3IajRtPFs0bJlS1c +XLlQfyeHVi/UOzmkROjkqu/7qTKWMIy+hOEwY3TO2IyZHpwyfBCNZ4vOlQ/NFJknk0yUPk048W+8 +hq7Pj+3sGOcGzIwJJwbNCp0TfUZQDi076RqsZpwEQZIfcQ3jCs4w3AsMsZbOb2fnxszD5PxL+0nW +8HiZSr5Y7HUs9Lq7fKPKJMv8odsTzkdxuDfB3aLCdVl300OX2m6utdVxvXTIcJAG04PiAIf54+Jg +Z0meIg+mjwgELxK8UBjFgggGnAHTBcHgRINMBRHduOYDDf2JljUOPA45XZhw4b5FX1Z0GOfp4jD3 +RTpenNNH+cFbMiYban9xjlu07vribelRHu9efJTGfNrI/u0VGeMlGctw28j+bCuA0Z/c8D9mP3A7 +grsLw92DMW2yfC/sDMPeMO4Obn/giYCHJw5y6uJDUwFUBlQYdjAIhRSFhZSEA4z+CiskgWIwg1Jw +AKG9Ovlxgu1jR1MowFtONHkqSIqAO/wR5soK/I10rcYBpkGFgY9ABl6hsYMhyjCSC92YsYPxysCQ +xc4kNBiQDAOx0JUY+4luw8iw3hZgNq8zFKXI4AWYi4xFtqoERWbqNZ7MwS47iXeTsY7v8xyY5njW +NocXzg8syBmFvwG7XN0L3c/0IYdj2viXundpcC1Nj3Q0fsDNOPqlp8+7UOKif5o8i9MHrpN44DKJ +D18qOn3gVtHxEgl3r+iHrhWd5OIIcRmTf9A7jau6jeXQxx0d9gh0zCPT8Y6VrvjY04Uep9PdRNdy +8lWcma7gXNF3jt5rvF1E3AtPU+FpKjxNhaep4KfCZ5WPavPtMrfPy6KRj35eGaky36bYyhekDSmG +T8wb+qxyWV8aYC6XaxuU9UP1iM7jwJtrZcgv/oGlNX1kbfnVtb3DyS8wiwxPLkRzuSLRxRvKNhG8 +va2806SBYReOGePC51HhsTLRJiY8WTCv30SzWkxYDwcfPhauWYbftLjRWOaI/xf6/yb5Ndp3jZtE +Uk8L1zwShbXQPbocT+HfVimDVOhcLt2ju9vURNpWRTpZXSSph0SVkbQqEn/v5ZDSJNWQKl2jspNa +SBqC5GpIEpemi8G1HlKUikhRiiGh1YO6+26iWM6O6iDtyTji8OQsdZAS3ZT0VAnpCpWQBvv00Q4K +cU9cLqP0GbfGujo6h6lXVLLcqu2dsec3xs5nhZWstNK0uSu23xTryysNvs9NiaWxyNJuOquzNFZa +uuz/lMtdh3JL4kibnBfU1VzaetQu1WD6WB2mh2oxZV9sYMgC/FBNJleV6XJdJpgJ04XiTP2qosv1 +mXqFpgs1mqahTJMv1HTpAqPFV4q4cI0RPNOFkk3+NiOZe/+ZCjiB1JjXStWWakjrRWQLJ9/NtyVI +ytuaU5vDAzl010P5ZUrOWi4qOQB+9IUZXPJBbZRLFgolxDyUeKN5CWr8XDKBBiPoIUTFLClGt03o +QlSDPXVWneFjcb6PRvkeGzD8aMjwIUQfiz2eoRqXGexsfKHMMoMyQNcFzXOpbVgVlA== + + + KER5pTLp+IqZy/P4ahj/2gvbnq2RcDH/NMRh4Xwst/Jiac+HUithjKdBix716PEixzGhcptSaQmV +03D/b7Er+NahespoD4M1zDVyzvO/6ibxdGtgbE2MwciYtllfjkeeV49OFpxctmAZuLMTTwBnD6Ux +XZA655Ile7nXMWXyaCmTDyVNVrkQdYfRl54Nt82Hu5w4ORpeZyyZhpTcutteD41pUgt1vkiXcRJw +51xm8/aGVE1p5ttRA6V0VTrjcpTzLXy6BZOXT1SFJ5UyQXflRAuYRpHOsjTg04k4k4AXK51buYPO +ktkOnTpCRwJQX4HmPWXsYbreSnTeTZTEWYBdnMC59AROmMjH4x3ItghyrgJT9iAB8e7kcJd45D5J +u/+4cj99ULvf6PaPUe2nj2UjXE5GoM5dt2uYc/xw1y6YLh/v3vTxZItL3eOR+0TL7GMdnD7VMvtY +96bH5JKcd2/j6MM34gYJqkorierp1Ba4iE4OVO1HNdM5QLdoM91cljcW6r4WRr7QrsWFkIBaBXIC +D3Fk2N1pbydd64aceFxSNCE2bAz8XWK9uDNfC+GXbdcXvXnbQqWjnrue6bmRipuh9njui9+mfp/i +PJkX/lLV8gd9hK7omfMPer3X674+huDjCF6R9scaug4MU3dyoQXXpaFbPqvdxxl8rIHiDd5Dt0ga +cjQnWhXLoc0+z15KEEpd8EXqgieLfZRJ1PVqNcD3Lv3+5Dxegf4lozg7mhst5/0nq/yfktpXp2sm +9nkTwNPoqfR0eko9rZ7aO3+q0J8rdFQPdHvKPe1EfadQuTjSuKFyQ+f+wllAujr5/Cjg3jLuVnNT +2THAzRXdnWag+gtPSX+xdTHfRlCF2D5qBRYB/lJaHou8FTwtt5LURuseIxpUruyysL8axi8SpzFc +EqcA/cJ7Nk9O7pwdqppcULNK5Ugf0BRx+qWnvXZnB3wW1GseOuAzhFsfc7xoS4EP9ZbNeTOiYDoT +cEqDUsFnE68n3C5UenykcPuPzJl+zLs/+e3TJSF5/v6NPxNNR67PDoNGqxXMumWsoqhXNle9C/eD +6/56KD8z+IuXHufwJcFfwfBlguei2yWOVRYflehLab6PyvJ9VLLoA1bbhfTAxyQcnmXOPYTOh+Ye +k5xAqQmPSlL5a0bnfZooCRO5y3Ojm7yRg2E4NC9+8/Nf/A1G7XZdhmvNr475Exfe/KGz95/y6S9a +cOlihCBdCBDoV688HSy5k9M8s3PVF0kE5YTQSvHzVc2DHkXv9c0ldLgpWn5nsXPeShe5W2ihKLp6 +/uNEhk+URVZkuRWLrfNtQ6vE1tXG4Aj7gRYr78Yaaz9NGr7jfvLLQpCiwfwV5YQ4P5kkEQfi+WYi +vpuI9/F1EltF/kvf9dqiRhcX6QVGvOGzBXaQM8bjd/rbZE2O7md/TheeO/J+DIFKHDev1cRBlzsO +upyaxker+x2ly6v0gdUlUpamj5jFepHXkTyPD5RPcLloabJ0mW0iWiSfpKbJbOvrxIfq60yWgJYv +VthhZ/SF7LMHcs92k7ji7+QoctDkM8k9O0iN8u5r/0j22XQmQzUBTSWpylKVpixPWaLuyGQ7kFw9 ++jFW3TXZ+eHVAmvN0lmOlriyDHp0tnyVNsliMlVW1ooq+Zqcord07ZxWfZKsFH9sPmu+1UquO504 +3Qj4cF6j+lZ0KsG/6UIS1jbDcczB2tbk0IkluVcTpV713EaeV+j6P5H/O9CEwum0o6nEEynIROJ7 +E44Uvwg0feokzvt+0hmrXehJ5yLnnO9IKqFPnI8536E/HEa7wQgfteD8386J939zhMsDD03gSXY3 +dXGpoyud7W/jvnZpQzvopRzjfra4PczHr3mB+c1rFZORzcadGkF3m6sExpsBfG7LmNUyZrNIQatp +yGAZ8lY2+Sr+BrExPWVIS5mGfJTxtrAx/WRIOxnSTYYsk2lML6HUJvYYjQlObMhpmpMmOkXZFJee +7jRJxtOdJNwcXd4Tu5n0YjlOfmKX05gCpcdAKRFqGnKhNB9q0VkgI3NyeVFHeUs/HCoHRJ8OJv/t +H0y+Wi7JZWfGOMqfPc6Ty+f88pGGsZ4eV1HuA2O9Ge3ps2KHHxjv6dHRw4+O+MaSXeu8YDCsNdhM +Al2rATtBXMm1Iw6dWXJoFozoPZiV86WY/tNl41wu7Il1Pc1KdZ4S2+V1C++FcopTdXdmb57oaqPZ +9mLeiS0xe9rkZEs2NqkImoWdyBLSK2kr3Ya0im23M/NMjLDJsrEjab6k+9JcY9WXa4ntKEh/JMvp +RCr+TPYTKsCoAie6IadgUZ6JkjhQF97R/D5KlTE+kYD9D/IkqtqDSjGqxagYr7RauLyUqsd0b/JM +WjJXmuI6U3hiIdPRXy405UtNHbgamdUjW+QMA6fZ5IkybdYhz4YzbXDZn+fZUKbNaJhGc7Xz2Klx +utCYffgkVe5VjqaLZ6hWSozZXQo4bE9PyRmPKJysk9mrB2Sdsyy8bXF44OyUHpwa7phOlFUzWq1H +u1tazVZk5UfKwnLu1DScm/KWq97OdhxOTQXK7C6UoXOeJAam6zRYrqtcpHXZ/cfG68evy3rcxVkP +Xqc1feROrYt3bH3oOb9/60P3bj3iNq7pQunaxxSzffCZHqx2+7GnXn6mh/7wQLVcekaLRFmrvVf6 +FIVaHWpuLBY7VjPDEuE/8Wrphy+XRltheszl0o+/XvqQpwvXS1/hgunPvGJaDjv4AiJ304XiEr68 +xLbABJWYeLI9/pZsjwcyJDJwIGKgo2GIbCztW1KltIOsiiSW+k31AVX0eij/0+mk5WLkBKAXa82T +QsMb+s7chZcPQUs+8IXNXD3QR0oVf+QRaL0zsw6buc/5plPQk3NEd1c0beiypS/uNswsXmnZ2s0z +zYejTyjMJ/Z1cepnrz7b3fKaTK255cyd8QDr3jKq7/xBVq57lGhNF1rdjdb5jlb8YZNdHikTGaVD +oXzkze21KG8nSqYWl6ykVLNf9iBZ9Z2VlfSiHVekFE8t+2rRW7vnW0Qndtj+r+2S5c3kYxX2P3zX +7/kFvheO23248v6Fo3j+mR7UKx/6Oj7wiC9RTvFR7z/lbOtj9p1PSxF/xK4zXS9/Wg62Ss0gWvcr +Ha7olaXChWpiB1daqkp3zktLUbcmMrKwZ7yncv+swhT1kXvZa4xtr5Xl7srFshP2eVNxyt8ty70f +6k4JD04Sdd1cLztxIPjBjRdLLmH6c0t1bZd3SSz0j+kIiSv/f3Cv+0KE46bboJeUabjiqRVJhOAd +u+nOjTerUtIEXwHwEa3gSzF+0QZdL+3P9UtTGJ/uD3i6P+Dp/oCn+wOe7g94uj/gsxXjf1+ET/cH +PN0f8OQUeyoa/zQVnqbC01T4t7+v9fFFDMdz3p/0sf90/vJ28Uxh25wpPBmj91ZkbyfZleumvHSx +3y6Vmqaf05Dd+bk61gVNMMjRZ3QZkMNACiWhEcBqkubIs4LUKAvkSJo+qUeTnHBk1wBaellqcXBW +/MkdE6+UpLG3zGXLWybKTHWNVuXFV3dRb79mns8SxFfPv2ahs/u/4lFAtot3FD89SFj/JKH92WIB +PRqggf4iaZ8fD/Z/JJj/sbj9eWz+MTH6Taid5fdnyukLYpqE9PTlNRN3bHpsKuWPTsxs8k8loMrA +w+C/LCYI4zS4L49naWwqE1Uqbi9RINn4gF8TZvCa6UzUsrQ8FGZrfETR7giFPxHoY67DL0bJAjKX +eby7FD4QWvFCDk9yYYk4+AVrUoRyWVx+KaYvE54X61u0sb6FFQRVgcMuhjs9kuN8Td7PNB6o2JSJ +3nqYLpWIHt2SD5SIRl/BZD6lrW/SPEmj3LhQKmpbkZbDebsLtWgXCY/2+lllsvJQO+dHHGOlyZ3a +4YjpjrJALGoqUpTk50RpJJlif5wK1SwZSuKnY4++SMJcOhR9QcY8QsI8rAZOH9cD9b7n/SbxfyxZ +ui1aeilR57TN8B8Ll66bvP40JO1s03Y25Usnl8PfDhcLmHKMak+zUq8x6tGqbbyK1diHL0ORmNWk +QavhRpR+JworuNu41aXIFSu8UucI5b6X/Kz7SvRqk2kc52UIBYFSEsaj5Bp9aVqEMq0BxMNFyXcd +dFx8CBW0QZavddmki0AHQZzfuFPuAQNXD20Y10P5IQENgK9/+fbNr9+9evP+1Zvvnj1zctv/Yfrl +9/iXyH/59Yv371++ewMC/av/58cX717+cLN7893rl9+CLN8AbpblNqW6ys94U8otRvTkZ4Su/ojd +NVvg93+h//7f8Ov/AOCfb9LNL27+5b/PN98S/Pe/gR9bnPcOJnhvngNs864Bpp99fgEfwt7Q635F +QwGWE+gXlINeK7E5zSvsOLgd1kLb4szzAiu4SsWqyLlAv3+BL4CXYl3XfAuGZmJ6BcQ/6ZX013YB +Ih97fo4JQf8K/8KKBSxhy1xBZaiV3qCw2G6Xtobh45dg+tnnF/Dpe+hzwKkMHQUpSu9RWFluYwM7 +z3/+Ekw/+/wCPn2P0qSf9xyr4Ta1ugiD2jy3SyD/5i02fQt9rBQ/LApyg8CfugBxY7DBpC+gbtWk +n713IM9Z5cIlmJ8NIzZ9CVEDs0TH9N7B+CNt+PglmJ8PW3wDtzZjojA/APr5SzA/Alt8+h4QdAG2 +BVxmea6wXWMMPYJgY1mdkF6sHiRZAFJwDaQ3/0ILbr75DVcfCbA8uZBcTWMJhC5WUelmhRz2RTp+ +suJqvvn9jmse3/zZz9Q+Vy4N26XFdGHNbrAh6A8s9WvmwrSdvBKWoUpS4jK06EUhMqGXbC5Qz7fz +6/6BkR9W4wbmib80X5lU2OUXqn0XIoY/LvJWtiNn0YB0BPqZ1mGWijS5NHuUW5dgXnJs8XVaKyj7 +kfbHuvDUgna5EKMbxjlRYGvCRmYThypp4K46iHC3lC8JUyx0tZG5AnKr9oLs/8OVJv5WGPt5WmEI +k7DFhOkFmF+Ql4T7VYefNlGQnX3wB1F7QQwqSD73/AzTNYd9sx/4LcKP8SU5ekFcX9hdmNCUwIoc +a6GlvLZRO9USmKtyVfKemFAcSEfBvYPxukjnkngD89Rv8SmtW63Caxoep6guF0Ae4yUdBd/yu+nE +6ibop6Jsfpa+uvJf9u9+/OGPisfcDWH+6TTf7ODf7/88/QjPoIVe1kFJA32WQDe/zTcgqRNW/lyA +C89AJVxvMZLvwM9HcCi3eDEhgRXDJVj/+JsJdVCcyPNCY1/xWBhOUrDIVhL+tYCZQAcicfdCiBXg +X3QeO9RoWORABIcG03HNCcHxdg7wGQCu+RZsPyEjwpIHWI23dZ6rI+0b/HxBemACEhgbLg0+3Jpv ++BdoCIYW4ASye8Olbhv+CRvOGTCG5F8OyxN35jJQ6XktPTpMQ1vcrwDvzYAUmd1ATR8I0BH4ZqQU +wLlA54Zeadu/jN3vbR2rtC12zHG10+D436ndDtRh+tfpd1O7+clPb37/T/AbTWpYBQ== + + + w5T+2Ewn6A2Ab8Iw5R894VdQn27XFTSTNcwFy/PSnF/nNaKYaA78fAMOt6XmlcAeyQNgQ3KtmU/Y +SwEJCtgTbAQ5EeULTC6CxATqFTdL65IYmGFHvRkpg5brWnGaMThy9xAlmOkMRDOcgXil6M3Fl+OA +IoegTVEaUlqS8DPforMawfDbDDsUAgtPSm4bYyFgvcXj0gxsC6yFAyGAmYQ+AQbnsGjbmORleQ43 +3HDBfZtgZQbC+fMNdsR5ZQIWmqjr3JZb4H3gtiszbIbZm6GB8iatjAAndUxCbCil8IwAMFBbB+7A +HgwLehX25hqiAOOyKLGYOst4ERyVYbFlaRvCLFjTXBRBWIvyHJVbQ5CrDXAO0hY23qgIVgWCya8U +rEk+n24xEidN0WQQYGcCzHkBLugWYALmORgCWP3CRVC6qnAG501pwnH4L6HItynMMsNSyMzxAhRo +x2rO2jEAY9d5JFtUBC1lBaaUFdiUsN4xWHQ281sN3If1NixF5hGIWkYKkyPo5ACBJZ9vMLOL0NqS +8LChYijvrzjx5fMyuXBdrPZ5zJjSKbvo50vjz8OrQsgCbMh4BtZ14eU404IXBHWtOOcRmBqPTIZF +HlcBrqlU4fUaiiGAGalDsDSWYsu8wEuivC4FQbGg+hm1t8RtBKY5C7URFqzgXXBfkNU8r3PHW9ZZ +qKCyewzEzC9heKkMDLcYr9cOlyB4AZyS9G2BxSt4A3Q0Cb0ht1VQJBwTRpFjFWCJUVd5iIa2jG9j +tLBKcZvqTGNgNBFIMluAoGoLASztGAybgZA7L2sREtqsA7zkNQiCJfWRTNpflA46ECAbuC1M+5Sb +TkbpbQUpHrULuehAwG6fik6xUKu0rVjGnTmOwl2Aa9U1VhyCFlXQrJEJWKG3qzTFkp0CBM1d39Rm +7QGAocsCXmXWrLfAuHiGAI0lAYLyYgiIRF46K4k/BIK6s+g8CDwIjWVO5zYjaDiKOmC8iRAw6dJd +Yau9sZZCQYX/GoIYbcMpAGZgybUqYw1I/lamwFgA0DnYwpEBb8hNZdeiRK1JN9110Vm0zDzVGWvj +WQTALidJJDKwtFWZjZuRIshAl7blyb3AGk+22wSSU9gSTMEifI2FZsaCm2BQ4Ydh2YMi0Fcl2i4J +lINOlmqwLrt1U0JwbEVXcmQRA8DW1wvLPng1sH9tjiZGENDTrItzYbUFgUHXC8Zrbv5Z2qIdrDuN +4IUlF5JN2FVgIJB1vaGk4XdF1MJ0xRX7fEZm+N0HgX0HrWWphqDNUdc8nqBBIHwsBFNkSOVBYKxV +XgXGgHwekEUlAFRtfhf82sKWhRkGc41OFDICQFaaLhgU9AwklZ2Hay5FgGke9i9FUMIqvc2piQaL +r2tZUJDBKy9DG0U0rMXwVtNYFl0ciHfRKSv7PahcpkWbeoTABeaPqkfG2gJyRxVNzFCWtnVOJh+E +tRWGVKdcsOWNPom46qQrJUlbPKGjrGFNGREE1cQw7C4IQHIm29XSKrsHgEFuKbhkRaG6Mgr/EgXY +bJ8J6OtQvK0mWYwRa8cjENTcotMeyyELEKThqvtqUN6uWFkoO8IYWJOyJsuAgYydV92+lrra52ER +K2dq0c/3rX1JQamq0TbQPjYNpaCuG2D+jQBhb1cEswLDWg1YsiHoU1zcsAxOdaldHWPYGpbomMjA +EnTIE27WijbPS94MDbStqhrAMCcBJth+VJlaVkNQFpUTWXQLALa4CLDAgkRgwALgulNhggUjCHhm +fk6KgGV6IEOuKFm8pwSMsanKQ3q8IkipCQtEzUXgGlWdq9KFsNyGpPxeUd9kBADOzANYbYHXDQDB +YJHu5shiAoEx6KuirhsAYyabELY27kJwe4Wo1AjMSWUa2K4yCgBOVTebvLIExrZixmXTBhG46ErA +G6oMASkq3F10fAsQbWDGCjwSIIhlpQAErCFoMes8EH00RFOq0XeRswBDS0k5q8oJgOOqC49YL8Co +K6SIgodYm66QklQBBzD8LgioMwhMTliT3cLArvLADiHCB8GiXAAFrN+FjA7ohYd2iQaMNSgwKAey +2zAlJMPgFFVy0DbGwJrUCGksEhFW9PM1GNpiJqP2CDYtlVori72AS1onUDV1KaCurUoAzQUG5taE ++rnIdMe9TpdxNbmJNJmMNeLhY0tRBKKKAzBk1aRXNGKV+mVVqSFWPyHI2vskyg0hsMlmqhG6uhYd +FJuDBZZv0Rmg4qGYfp5Zu1UEa1CBXFHtfq7gyIsDTV9W+gJua9VzgYGzrJjSNVGEoqzp64iBGSwa +mRhiYwCQIk6MNJXFECRTcJN6vRBM2zyDq8ziyoM6DkN1UnpFoaF4ic+y6oU3uIHa1GYXAwFrst7q +VoVgtNWpEyRwEQimfOqTc64C1BUnM4kRrGYT4eQWUQDbT2oqI8XSAmCyFVerqmihORuyzasiwMsz +9WWVGB5nNlm6jCQEkS7lVAoiUxtncxTZmkPYojNxDWrE4uebbikFZQ0Dgy08dKgJkGJaMggq0BFc +1MmxLrzGAFhz9LKbgeRhk41KF15ED0HTXRGXtgCXpKMYec4iMGrLhlX7FUEstq3yvg4wdTnCyJbM +PQhU29/tEvz5AGJHP68KLSCoWXcUGiIGNtz35U2LfR5PK4oWInYCAFNQ4FqEKthlxNWGSFM0BJhD +5qTMcwGDBaq7B2+1EXaUGHXGRnalRtwl1DdAH2G06ALUHaXJPgXArtuQNsrALMZuwVCfLI+IrsdU +RgJQdQoyuQM7qhCo5rrfKBHcrLutKoJqOkwRYxGAmDunk0i3qYiiOipd6NsUrEWlCWaUGgWqn6Iw +dxQsNunZEYFY56rahhjhCFyUVjxpagjqrHNWnR4R5bsJRJE72IWqWmsuqnFFIHxV5SomobZwHI+F +Z12aANWTgfugquMInqMtu6wIYEopBeKIACBZyjINovIAxHeTXZVlxXMBJ9E7C3s1GBhWdYlV8dQj +0NRp2joVbzJDI8vmGisPtGiorMnFSjfUuDnHCND3bvp00PBGrLZduZW3Os9eFqMCgCGqGlTMxj9v ++1zBNpvJn8zA2FR8ipcbgXnWqEJG207xds1TNwakoahRUcXVha8yhyNtyYogRGVOo3gdU2D7VRPT +jCiwBZn65/Ho7Ki5RrTCVM9W1ReA3aW0mgGCceNFHQp1ZUUdgTHZ1iZjDsA1quKTbbdpzjZsYncD +MOWkbSUUFNH3nerZZIS9sax+nQrWpu7gJooAAk07IAFqCJa5bWaoxMNFLjcjK6iw7n45AOemPm0d +r2YKOSwRccoAsM6m+6FVo58vtom0uioBxXZh2hvlTVEVclO9Y3fXkdCTyQlQU/NIzhi477lG7Gp6 +vmNhdxvQNNSXEYmDAE2YYhO8acdA9QwWdvUQgoQ5VkmkhNrtaXbOgIYzkoFrm4tObtVJE6Vk2fRu +jTuWuh+xz0QABuQTE8bLA2ApNNEz56COJQLr9kpTRtFqkA3ArDWkxetoYhcBUJ0UaNcosaggzNox +FrXQsmXdGEg4csMQzNowdTBhhFrlDvufAKTuum7aAlBNEFGe9ePNHBTG12gu+sIOdAZS2uZGE0Kw +6CfALKUAgEHX94LeOAQm0+kLxxcZAXqwjduNnYNJlHYCJnHapmxRMDQVVKNOONN1sIXV2Bd1hlRl +oDBDhPyqHEDLc7YtjDVfBBa1YRMHvBAYFvVk2OJCqHnwbKx7U+wUq8MJ17TZL1WVUQCnsMp8B2Zz +X6up0wOwm8tdZwIw2c7C2JK1bQgCDDKulSNfPK4WA8Omtlc2MRgBmOtiG0dTpLWZK8ZEdKqs3du7 +ngvUzQxOYUMwbMG56waN+Y1AtZqTrALYumpVrMVWN4BXbaqCE4BxNmm68F6NwLT4XUYR5NIUr+yp +aTVRUjR0vKTmGEuBYUaAYRYzbpOYlgBNEs51C6FRUphyRiZHM5/FBq3q3tAHMSrybLOzmD8e89aK +eZlQPyMEGcuyq3qlhn8OFoMr7IxmoOstrhRGAGCxapCwELlnOaKvTUdM/EzQtpmMyJVlRMbg4KJ4 +q4bmEEFR4zKK8ymjqZBUINWgQNApVUNUbwBAyckoqgUrtBkjIEknuMSVAFjR8uo9UASqphZ20AkC +8eoUNgcZSFqdCB61mREsmrbjYrJ4HVDAtgrAegc0fo9QclYLv5t+nEZ57EAyd6t4xBRBX7m0YT0X +sIYn+yLFzpqvqIimj7Qu6vrvnnt8XdNgrGQZy+uKhedEpiFejQFJNBk/XjTWsqLj//DwxzGlQ9Ww +xKEWajibcZs6VRTP4R6wtkFdNXkmRmROnA/LwEW9WjnbnlrU654xx0Knpk23hAdGzJMRO/3NnIpF +Z0a2bJzu2MsY+lJK+6ZIBFQzbln8Y9s56uoSqypnJwuSqTAZ9TTVb+NsCHQKaqQI2y2LLs2oO8JD +H8cjYPIqibDnbPGn4kcAbQgV0qp0Z9y/1sXRysCwKFnkOmUExYKexQIXiHU1QSIOPETgWLh0BEtt +uitKtAyApc4mSPTzoKwoAX0OFFOC0HBl7y4C++oWawiAOarSHWxfz9gdFXCL+JNytZBQuZWPV84b +6ROTP07OTpUYmv8BUKVJlwBaurrRa+wMgNE5CZuh1ByLoplnCGwyq7OEBBGUVLAsRefE2tHRf821 +Vtjhz8CQdDbQqOmLW1O9o0j81r1YnV3Z6wHdJzN8PEZ9EwhEGQn1qCBNQWdzjxwgOKmkR3HwXKBd +S9foR8bUjCy9UkMegfauHpRB8KI5jVX8WghMyhYVPasF5VGma2JARitY7ZS175agNCQdO5PJK+/T +MvLsF4OWMEMViDaT4m2l6L7QVG+C1pRoIFyU7aJxosGg9yBe2+0Wc9UDGIStLsmZXUgZA5TW32KE +UXql9EwVFABXSeUrbFcxsCx9w8sCU/9AcdEKRGsGQE6uY90yUZ88vStutLyMpmUxYBO6yuzUNM05 +AGBcddAltEUNowxk8Z8PRftVxSUPwBR1a1HLCpGaizepBVNmN+k0OIdImyqJFDlhYDah0Cc4IrAp +o/7JMjv1WVJKl7JwLJ67GkqnwNnsRQP70HouZtyWJDO0+BQ7Vd0QMyaO8Z6n9C6cobWyJ1G3F2xb +1VMexCmE5wgsQy9yOiICU7SMA5viiHdV10MrQRHgEMvoisQGYDXRZTZbCeYTciMWnIpD3lYGql9t +mDLdVV5YDWVgySoQSp6TADUYBgQENduxrQ0Z+STlZVlXeZNNr2AWnVqt3U1CCExSSepJAfW36vDq +GoeWFCFYzbBQBGtcdN9ZrLule3klERDJSuZ4sIguti1p4ybAtov6mdV/jq8yrz4BGUF0zlRNaAFg +T4+ubHcibFG3WOuzAMCzaW9xUX63WMydwpY3vimr5YwiSD+fFvt84+Bl8ZmMGh4rqNWb3mDRCgBr ++k/h6LIAk25iknZCMBWzPZaHaBfdaMkp/1zAuaikppMECtbU2MIeLkEhMWTmf7LYmg== + + + JNrzm5Kl5eK2pBgxd1k3ELWrEGNTO5RVlIJWkWp+wXI24ePKE93B8fWhOa1F3r3q9kc+SyMpqDao +KfpIkTi+CuciCtJmhs7aep+CORNMbOPLqjlpOP5eEocveQVovjmC1aFTLD+1SJ7muAKSWys9NaVk +7viwK5ds7nnZ7RlYqjK1mPcMwUvfeTgyVVDpMh6uinQtOn7BtOSS+XzKKOOzC54k8WhhX2VZYHRH +s+Worbq8i7h+oC3o+eZA7UALMPSASBG7jcFhzcYujf+Imo2wtUlDJ4UwV9aSwCW/qGRTiXtSW8m2 +S8u5Ce2BKoI99QsR9BQGcf8hMGkKg5NCmTnH4DjrePU8Mc1WKcVpUJSUwAhw8lj0fhWRVThVU7bD +WUemZbMLLUWq4DA1JUwSf7GKgUUHbSKDXp+VsX03q26bJguIgc5nX2UvqW7X6R5QAGsksnDyGQPD +YlvcuiiC7hLL5hJDBKvOQw1JYVvJ0er2KgKbuXJQJCmCHs3NkrSC1K5tK8qr84KT0DYKsvqulqKf +V29jTwlA4KJhfgr18udXjmKv3ulRqqWN9mRUbGkLIVhWREEPYrZ5KBtftxwsBbE0y8+RWCF/Hp16 +OgmiRDjqzGt1UKoAmIpmSnQ/dJ1dPFob5qirYOmfrknzXWbdSiu6/iwfWRwO+Pmiy1BtcGxpyyWa +bl69BkkCis99LU6nigsLOAAC1ZaPzMsbgKVZLFo9d9i0Vk3TtmMb2NgygeZVsfbUZQ1QI7Bov8jP +oGh74tQsMhqAa9ak1yYqGbZMmv29NtV9KuZva45vkQBFxQiLnr2hpHQGashZ0scZQbCzTkLtcwH3 +zDM66ozAyGmL3JZtSoClZCq0SUMERz1HRv6k5wLu85AcJwa2lGQ5AYTANVkOvWQzARBGV7uWdNJW +TABUlkVLqgPwkvVkUhbPJgCznQQTiYrkLnpoY9UDZoTWcqc0HbcG51TTFFsAgh6vCOalI1BJjVt/ +jRs29rMYSKpkJSQ+raIIND8GN0OWiEiBRIUw21vYhRkvesiOrGIdX024TOqqQQJkA0rsXBZgWaxh +a/3zdpqEghcyO3IVAgLmqjFQ4+7J+Y8qHr/U7HZSWWUyLppCTt4PnaF6TtFO4xE4K9i9rJ8Z0+Mo +uBhmHW5HAZ6B0pdpXgUA9XxZ4uMSIlNkCOykEjRc5pLc1GIgjKDQVCS5H2XEomcxesYqtrUzgmTT +CrDouqUsThFSElfDlkvsMjFEHW7ZgVHOJTsGkLqgzHpuMJjHjORvCm5onws4SDJv6jLRA3V2w57Q +JB0geZ2p2SacTNKV1XLzByBtkQzsKg9GxnQpkqn9XPdAyWWN3fzEjVXPbqgfFYCLCQ4Kzaki4/iQ +gqmuov5HFrAMzE15S1mMqg3mpselNMEHrY/FELRua9eyKq0agUJLM6v8C1jA6bmZqroaDW/g2cLD +o8pzz+BOnOutePvK09gaADt3ZRdCz4LswnISRh0W6iZPFoZDN4jEaqBjqmHNpnNE1tvMxSOZQBEz +LZu5YuhwMoEliQRdX5UFQtQEDHTpSWqg8FA9asFepokh6BOc9XgahWeesVMxq5zsxxbINRoVr+TZ +AhBWu8wjzSpGh+1StF+W+IQuX/H6RHNdoftazqHh2Ff1F1MuhWC1oGU2xSOynfmM4zIpF2Vis4Cf +uL8jJ7ZacFB018iaOnsVg2WcRA6hPuMIqaQNRZ7Azyju2iSAEMna0WDqLJpLZOeGRnnVFI2WY4kB +4TVFZUJQtCB0Fa35zjCmnJWPFHp9RtHnPmlU08M49axLJFlgBMCauYQRUN6IESguyKihSIzKlyL8 +6mKdkgiCgGOT9Jpqep6cwX4miQlB+ko5CJqvoOdqIsctnwuYui79lRg+AlfBq3ZBkgg7Ay3mhDkT +otRF9ho+o6SNvm6KLFzM5JBDarEHOJIcaOXPiyWZkrlxQ09jgKGTQ7CSr6qpLLQyGa1EFABYgxKw +iIMcgEUOOsL2X+doCJZZEWiIkBJvWtTpJQlCwQyDyEkQjCCYbYKeQJbgLvFnRDAnm10q5yjHSGc9 +BQEexIrZyjqKlPXGCGY7lB5M2gOwbyw6OygrTtddsFSzaqHbaPpBlPwN4SHn2qHCqOvAtIbYD4lI +3YDnAk5y8jpYAkCM5i+OXB6BgSkVQdCzGKOZstEOIMZe2oCOTwuMRoPfb8YhJlEnXR6znPTAHO6q +s4giGM8oXZsKGskcUjmL4KaLY9EE4sXS+iLv7gKsteqqNb72PPTIqVHPKLtdPbh9bmLSvaQ1RDZE +GcEMckfXDEX+GAj6iQA1JIxAG8Js6W+INyveusjpjWZnmCLneTKwRN3wLQci4FG21aDsGkRg6tNY +DgA1C90C0PS5sNqB09jPqlQ+7sDskgQbPFfTqbK9KiS37JMdC9KDyJizxjsNHlUqOomyFTEIyc7D +4/rnjRWBIWgPRM91R6Cic1IEtDWbtpXNA4B6RBC0EJlGIbkx6Gdb8byVBCNiP52ULPM39uM6qKao +4KVINyOIltUVNbyJJ7uy7sCa7R2iFSmJt3bGHqESSRB1gU/V9KBB5KjbMzp1pxZQNF0fgJpI71Y9 +ntSsujooDf0Zn/mVwLgob8/ofLRGAIM7iYUHz+UcFIAlEoCFBiSHMFgEb+5HmQMf8iAEOPhSEyDa +kUrSAJWHISStqqCHeyOfsFYEYTYRx3YJbY82DZNVZQiS4hud5kwLuEk5HslDxWIPTaeWmgQIlIyy +4A5eYB2Lypt9sNjsPFt2SNCUfazQoaeoQk8UR7BquEEPGBBQnL6mRBGC1YSp7l1UI0RM+cDOiOcK +TmwwBo5/KDjMOg5SowOBc1Z6Kyc9IlCjB6Er1FgShVLcCCxqDJaFWUPSfZn1aSqNI7lboR+zmNts +UbHIpirX1lHHVFBXLNbhoRil8FY2Faz5oy6CqJkbWB0IJp4wp2p1oF5rSWQEI4gWMTUL/ULVoX+k +ckRYpyg450EIUiQpsarC7eeiTomW9AQ6yR9pGbUQRE+UQXBZ1MwvVikprEEMRF3R5xRwpSQ0J1ux +zGgUovcKznZiRDLUyf9ryclCGgKzJsbMPchaGRuD1S3d/bc9kQuBRZMJZ0vRKP28ejFHVKF0FM0a +b2olb3qgXStmRiBlVMpYwFXDMUZEcfkRQRLMMQ4QNOcgzhaxP8P7XF6YHCvIM3kv4GrpvDVrSKZm +TR2iE0zPJFAUigJ15yjJ9LpiZ7AopqPhK81zOyfgYJSpUVa0GiiDVYuxLEj0A1g6b6y8U5bE1WRX +Ti5SXy4HpjTMoEHMZDVeCp16u/h+JQw2lVUTemkE7hW8KGF11hyDkDRiasG9xbIYKWKqFn+PZFpO +xsJHPVbO7UmaorB5vdA1pKtkJgphYOUIbDaLv80GFKUZk2hyz0hWHQK9A5askjVDqfGhCiZWTf5+ +yh8TpNT1vaFKph2dHVQPM8m4ewHnZkcpUOHQY4K9tAJ5CJ5fRiLYw2yFvTLrUPcCVtHez3FiHQLL +QZPkTYQtF47CzqxFyaoXldIfWtVw3jkBMkZLdOfqSDG/V3Cz2hEwxlLOQfw8K/u7td/nSJ5TTcAv +qwSI4Jvy+dUARfpjEIEK10VMupmLAz8fwNBNdqs818+fQ9xH3xA9VACwov6CpVtRJmKd5rBSMi6O +JF4Hg7+0eaEbSxaYOFTeNfJ9JVwBEPS6gn+HV0p+9b3odW0JBMYySKTTrHLIa2nBxpzC1Cj+sRAk +2ePfiJKxJrZbZ10rqCOA4mplRYKoCBp7Ax28ZFVpgoX6xIephfJibcIN2VWoTF1Sf5HUYSElRUTe +wvJX6Zpnli2zZX7P+DLUXcAS7OWjKArUECjHZL4hvix4/I34ghmbq5b54ZpEyxotEL5EOfS0rKhN +WikZDGC0s0FfstTKw9YaRlxQD8EdDPGipnlzccC+kQWFp8JwTSLFCdMz7gUc1xYc+PkGHNmKEZpx +QuGtn1ibUfXmNa/NAZmVwBa8usy3RYUtRprSHasHCgWqxcEL1w1hHhy4YpqU8WtKGMijfEYYAXWI +YPNMY1vHHMN6gWNSgBJfF1ZhPPmQaB03rEmGqv6yUqiWZw86GBiISbhSQw5LCBaiYWb5+o2sKlBR +iRNyDEiGXupWBDsIhpWjVgtuWXr7gi6tqp7JYMVu0KFZRCXX8ydYqEsGqNo+SqGIvCpz4sKEzRjd +wV0fpzVwg9cQzPAcE3eXWMplEitlmSFryK3HsyHKwqL529d2xC0MpzoIOgWyRwob0uioTcBFsagt +erd4wS8YLmwMpsR+KVYZVllCIHLKzcUhw2Xx47Tc7L6XsZtjlUlIJuH9BowhmFZutJQiEYMj3mvy +JSqXYUDmXJIibUNbPJwd84DVA4UCRtDBCzs8B6wrah1pQ4ECVaYJtb2t75dhvcAD5NHfff33u3fv +j6++ef/q7ZsX7/5y8zMA/eS//fTm7796/+7Vm+9ufvLVH198/3L/+iXVm/7jb//y/cuf3vwf2Gj/ +YKOfH7nJ/wn/cB/9fqKatOhNxQJEoGlReXRQUKlc7UJRZVdwPGhB78T7FNIOynVlyULW7P0GbNkr +82zCoppnCZgXigp5AurwcfLI0Jbqg5QRaYfJ+3X0FIzzVkRCRzrzYb2RAAEygk6stfW9MqwXOICj +R6dzC1X4hV9mKiQPRk2gIuhLzKC8I19xx2f9oAS6bzJxoXRjLmfTIWrSKu83YCljwgTzLo4co9N4 +3DnYraoDKnfnxGLQtcUMrrBusHagUMAIOnixnFKHdebzCSMFAlT2KrXW1vfLsF7ggbA34LVNWFsZ +1Fi9UoKvvAFzNxJXo941FCkJHaur0t10xl1QfAUzVV2534Cx7pI5jrheLE69ajtMKzl22DfitwKV +bx1bSknEEWUHyuuVtQoOXIJtRDqzK3l8vwCVtUqqtfWdMqwXGCCsnbGCNV4vsOJdQXRfQo50zQiY +H5XU12hXOuDlCAjJTn1lH1WVeZPFePJQyZJkesHG1VWtRVVlfXWgMjeUOW7a4rIOywZrBzIBXaww +NHBQYEQ68yntkQABKnOVWGvru2VYzznAvAWzsy2VrsuYA12FAVp3i3TNCyj2ZBFg6HRJdFlCynzJ +F9oInbVgWgniiIdW7zfgZJFcLChcSFVoUg+Fu1YK75gC5K6hl1PnvbXFNRfiBmsHCgU6OAoOfMpm +xLrggcQtBQJU5iq11tb3y7Be4IFwFxOHUMLGRuoWWlcN8zroTopId5MlfwlZYblrnMW7ERlrwCS5 ++w1YSmMzrVxulCadJBqgzikWiwCVs6nGZdM2ShG/AWsHCgU27QUc2A05Yl24gNlIgQCVs0qttfX9 +MqwXeCCcXejsH8mWWKmCPeg8ax1u+eFp6q79qHZ1imyppTZGjVcIsyE0gLXyEzrq0ypmXpTieDPW +mFLLhIDKXrHXfVtMkFGLx7B6IFGgCBQcbqOFGhTp0gMonQABKneVWNe2d6sjPeMAMw== + + + N69rpQvYlrwEkg4zaKcjb4PIgopuA7pkya7QEbmU9W1NS/N7cLTM+RlVkkXEvlawmWXFdaAaIGWt +edMW47zzusHagUKBDY6BNbvDYQ0aaHYEMExZq7T2lr6vhvKMAcjahTXcnALrCufX/XQG69VE/W4t +dswYg0tS/LUtxl+FYux8VvpW8b3EWznFgmXZi4eZeSc2hm/JdzoMKDuQ364f71ANVDicfd71tzNM +eat0+hnau2kot33/QvNk9zjz5Hfi3VvUuwc/vp2KXCvy49W8bYMP8RnFdEFRF9lDpuP9Blx6+BbP +WrAeu1oGrJVlNCDx27IAfFusmxfLBqsDJmfTOnDg9MsRK144UrcUCJAp6NS6tr1fDusZD0hSfbnB +SFUJE5Mm+Yj3G3DgZH+q4MjWPmbTNituOcfVAbVjnNg/tEXPZWoeZYfIu/nTHVw4j3REWW/Rj7F5 +vQB1ZJXU3tb1qGM97/21jEXOZ5mlcxSWvN+AA/qutLwm4JCNTCu+QOfgpc0BlbdlzcumbZLD8gPW +DhQKlL0K7hXXHNZqJ2YdBQJkBJ3a3tb1y9VxO+PBlYxFysvJ5qOxKKQDoxIRlLuJ8qCQY6Cj6dRZ +UvRA5S660zZtMbbZ8gZrBwoFyl0F98qdDmuxck+OAgEqd5Va17b3y2E948G17EUkglysKztRZO46 +qBwjYWD3OdeQlbtcWNWAyt0Wde5a2ywHFAasHcgE6OcV2iuTO6TFblJyBAhQmavEura9Ww7rlgNX +shc5S2xRTRhrE95vwIFzRJ5J4V81zFqVpVrkQikDcteohNSyaYtnReOywdqBQoEyV8HJii46rNmS +nBwFAmQEnVrXtvfLYT3jwRXsRXp/XWXIatRUCAcOnJbLwLgokLZP7pc47RWonF1ENrq2eBpVgYa1 +A4UC5ayC8RKGWetVK9Zsx18cBQJUziq1rm3vl8N6xoOr2YsoryiHjdxTmMB/vwEHTmbhfrSo8y7J +iVGs0B10ihNQ2RuX+bztnOtyhlWBQoHNfAHDLiNHhB1WPLQTthQIUBEota5t75fDesaDa1mMeP9f +UycOFRm5PwPrlRoITFXNj9432CirA2rfUtThcW17VNNh7UCiwIbHwJZ92bGmroR0CpJXWDq1Q9ve +L4d1w4PrGo24U7Qmo0cnAO7PwK7G/GK+CRxbYUVRQ7uqu4JubpyXbcsaQjhD2YH0ev18B+vZCod0 +mP/6fgGafDJ/ibX1nTKsZwz4hvNA/h1iWx8yHdmQ+TexHmO2yIa3Hh24cH7BMy4WTeelfJQLyw63 +6MNkxHSsDUtZSr5tEmf+gNUBvfXowMHizg6rnN0aKRAgm5+dWte29yv4SuIbHoii+EWGI91CpAkT +uAHeb8CYjFC0NDefhEBmuTLTnYMEVMZyxSjfFkvbrrwvdqwOKBQwgg4OmlbnkC52RMURIEDlqxLr +2vZuGdJzDlzPeEQFqoifnwqi3G/AmTw/TG6jSkHILzv6AQqW5HwIkLvWsMxkGtviiZoS2oDUweT9 +OjYKtvxnj3SxhD9HgACVt0qsa9t75bCeceBapiNWn09BDbeidnmH4qUkiVdT5dRXmnZWQ3uV82kG +VN7yrX2+La7npLxVrA7IBJhAScpbPdjkkILBtMqlE50AATIBnVjXtnfLYd1y4Gp2Yyyac4K3mual +M1fBuZ8uqnxQldf0aszlc4IGVObyeeChbZOTLQPWDhQKFIGCgy/SrliDnYl2FAhQuavUura9Xw7r +GQ+uZTriDQcSvI+c3Xu/AeNdgez8wQsKopoMmmxHtwsMQO7bittu3LSly1nWDdYOFAps7s/KnNb0 +XYo0cORqJCC4gJoj1rXt3epIzzhwDcMRpdI8a8gLTw3db8DJX+bAF6TSpJNMZryeoYXFAZWvfCpw +aIuVFpWvhrUDhQJF0MFastlhxXhLWTcUCFAZq9S6tr67hvWMB1czHHHp9KDVPOtm1sHJrprFCzTo +YAjnk87K3lrVT0xA5Q7fGDK0hY2nKHsNawcKBYqggzW502Gl401pQ4EAlb1K7dC2d9ewnvHgWoYj +XTkSZElkm7seakpM1cRMpCxmFcN8/aoBtWtVsjCGtlzzaYO1A/PaWdOhektDx4m1OQyo7xegfl5p +Hdr2Xq0XYNnm7RXMRSQ3NzVHi2kKHqynaLAXdEhpM+g5zX4m2KwJczpry9fHbbB24LiqDaxVmwas +tYUzAmrrrO209pa9Uw7lhgFsLn7MmPu3sOPooL7Oh27HOXAv/Y6F/dciJptWC0t0q1hzQGJGxqqg +tY1tM7r5VZdzBeUV6O04B+4alsPak0EcBT4ZxFHr2vZ+uWPuZzy4gh0HSNeqrhwsJHS/gbpbK1bc +LiTwY7dm4AnpNTqg8nUOqY1tM/pPlzBidUAmQNmq0KDXtTmcltHs3y9A5mqn1bXtvTKkZ/2/mhGH +114sOlwR62rdb8D9vlGsj5GbzGOtG0Q3NqTVAZk1s1xh7NvmxXaojtUBhQIdm76bURGvEevCNQ5G +CgSozFVqXdver471nAfXMuPwrpBc1K04N2OuQjG1MwpvQ0p6nGBhb2eiGkfRAZW3qlz1triag0bf +BKmD8etNmgg0Wh0ghzPYXXju/QJUziqtrm3vVMd61v+rGXF4s0rTMaNir/cbcOaCHExvjBqR07sa +oW9UzqUDlbdLypu2AKSTtwNWBxQKFIGCo93M4rAGu0rAUSBA5a5S69r2fnWs5zy4lhGHVW9iVgNV +leEBSqVgmdy0aKReit3SlS85dhh3rMmZWNeSpp16/RTlADRF2EHxIL+VHVKcwe9h+vrg97BOqWvb +++Swbrt/DQOOhL0OIZ2LvN+A+8lxqlqkObiacwzdApWwOqCylY6lbNvSHUQj1g4UChRBB+ulIA5r +sOLgjgIBKmOVWtfWd9ewnvHgagYcLptFB7LiFWL3G3AylRUJpsJBCNRTggBsYQ0OqNwJpSybts10 +Voe1DYqsumoHsF/7gjX0zalTEMaNTKkd2vbuGtYzHlzLgEMaqG4Np/2HPnkdeK56jRQXXSRjJxrL +16BOEQJq31rVML+1bXgvV9xgHYBm3Q5gLXI5YF37TVidgtUiWwO1rm3vl8O64cHVrDgsXdZ04GC0 ++uTtYCppKsBiEbo+8lU00TjuJWWdz9vyJdQbrB1IFBgCA0sh+gHpWsvZ+xGmn+6kupbWp45x0/3/ +OBsug4ha1+Tsl/sNWK7Fe8aVA6V/1WrTYO1CC9D1s4FYEzG3umkb3ZFrxeqA3oZzYCmXNmJduATg +SIEAeQPt1Pa2rl8d6zkPrmDD4bU46yI+lGT1TRw4W+wfb1kJPRet6WUiXCPDgMyXRcpEDW3x+O2c +RqwOKBToyCjYqg45pKEzuxMQ+gF5T2zwLNRuGdJzDlzNjMs9TJj4dN79BpxdZczYilgPSctvYJXW +eXVA5S0f6R/aBjsQbUgdLLlDgw4c+z0CHWmwamOOAAEab9u2retVx3rOgWsZcVjeszQ1YrJxVoGZ +LxJmalOxCLBdlwOj2jpMGcvV7n1LLCscNigdkF6ubFVg160cSszJlnIx/e0CVLYqob2t61LHuu38 +1Qw4vMzJDuZQ2b37DThzqdNncrlR05Cy3q+AUnxZHFA5y4WqhrZUp7GNWB1QKFAECrYqoA4p1nKx +IrVKgACVt0psb+u6ZUjPOXAt8w1vubJkM5JI92dgCaLn5gzmaPsHTD8HY77g4UWN62vLRS62dhgH +WJeSDhytqLvDGfjOyfH1AjS+thLGtq5LHet5969hv1H1YMv2Xedei6ifyctydwfe51XiovNtVrYu +dUkOqHyl4rxj2wUrh8QRqwMKBcrZDtbiZQ5rL9nqKAi94IOntrcduqtYz3lwNfstdy9e5HtV7zdg +9M01JUNt22L3fM3rsnSYsjZZzmRvScWUB4QOKC/Xz3cwXZ46Iu3VOt37BaicVcNaWw79VJznnb+W +4YZjSyUsCfOsByhHcLVaV3Rcj0c3LXZdXFPNvp/RK7NLMtW2KBGTSjnFOgJnzUgcwOogHrCW3MIZ +BQQ03hq1rm3vl7mdz3hwNcMNa4ZFPZBP4d37M7BWzUSg7QFu5HtIm4DauRY1CdK3La2eYe3AHnce +wHbbr8dqsrK/v3VR2ym1dr1HDt+m94+x25Z/u0TKgr4WZ7bcD8CsNf/oToJVnO28k9kdKQIiPlS9 +m82122AajSSDYHiUrwR0OLBS/rJ5GcP4k50qa2m0d4TbPl7rkB3gLZbqQJc232/A2VLGkNQ1i6Kb +UtNrJUqLHsjdwpv3NIhhbSOXShyxdqBQoKOg4B7Qd1iDXULrKBCgMVao7W1dvzrWcx5czUIruFZ0 +4KIdqXFgvPFI7kjBIhxRS1Yku/ajLFYeJ6n3Fq84mdUqtrZSIXXE2oFCgbJXwdGuuHJYg15I6ghg +mDJXabWWrlMd5TkDrmWg4Q0hVt8t6DlrB814wk9vGFHfVb8EHe9OSQ6kfE2zxnysJR7Br2GDswOT +W80dGodbZmY1x+ieZ/96ARlbV8vllZauSx3nWe+vZqJVnN2qhJJYvj8DNwnk1FkuAecFXfQyqVRi +c0BlLRWvGNsG284dVg8kChRB3/qTHCNzWIMVynUUCFC5q9S6tr1fDusZD65lpFWSzmr+YeL3/RnY +aOhhc7uEaMG6FcEBhTWbZoHLnnp0HkQvtgnf1KuSxUbWCTzr/VX9rQI0fgqFrm3viUN41utr2GZ4 +G1zQQjZzUdtsALu9i+/Xpokm1yJivxa14qzGJG3UTQNF1jbg3SFbrB5IFChTFdxVNoe1XyXhKBCg +clapdW17vxzWMx5czTbDDbRGzWhdVTVw4NTvaQOCpdpRshwPvHEKZVgHKnth0M/bri3nDdYOFAoU +QQf7q7AEK1YXTGFDgQCNveWsre+uYT3jwbVMNBJG6iqmlIP7DTj1jR1rK1ZjTtSpQ3WtOlCZAxt7 +O2ubm5YbcqqFAqPLhRjAYj47pJFzGkcCBKjMVWJdW99bRXrGgeueqRtGGVMy78+gTa66oVvYzHuV +ou4i3btAQOXP0tZ61rbXZzGsHrjGzt8Opcq4I9JhSnf3AgGNweZTcxO1d8uwbjnwxWfqHlmQ5UOm +4O/+3eqzAPNgBazbE3YebJVU5tos5mk1V+aKWaqsprn6LHOlm3XXTdvoqngY1uiqeJi56MFWScVj +tZorngJXn8VT29u6fnWs5zy4kuk4V4y4WPRH67N4MBdTwY6tkttkNVewYxqBd/VZsGM5jC3XRUpJ +G0IHcdVZPNjqqHSEVm/Fv9rVZvFkura9Nw7nWc+vVsiz4p04ag1bbRYPtioqc6XL6yW/VI4vY+fg +my/ConyNsmf2tuss11R6rA7oarN4sFVR8Vit3oqnwNVm8dS6tr1fDusZD65VyBOGOAc7Xqa1WTzY +qqggvWXWsr5SbwX7xjexDrVZkA+hji1XHydSnA7oKrN4sNVQ6Tit1op/u6vL4il1bQ== + + + e58czrP+X62OZ8Wq35ono3VZPNQqqCCwrasmQHOtFcCJx/2bAypnNYeyt11nrbXusDpgr8vioVZB +xSO1WiueAFeXxRPr2vZuOaxbDlyrjmfFOzhW1SPUieTBVkEFpwhfJeRqrWDXtMKoq8uCbJjDpmVz +9fYMp3eaWVUWD7b6KR2n1Vnxb3c1WTylrm3vk8N51v9r1PDE989q+FtNFg+26ikIrBaclDor2C/N +qHY1WRCs1olrC4IyawU9w9qBriaLB1v1FI/VzHxPgfMGeGpd294vh/WMB9eyHmkX6Eaa1mTxYKsI +QTMk6ayTOisI1APGriYLgmvdtGyuELLhbL5oslZk8WCrndJxWo0V/3ZXj8VT6tpWZ7sazrP+X8ly +JNKspK3VYxnBUjkFgSDHfekVAa7NF2nRvhVLV3dty9raGdYOtHosI1gqp3isqSspnYLklZRO7dC2 +98th3fDgqrYjTZNVa6xYPZYRLMVTkBa5+aBplRWaUYtGL7QeC/UvbNv1sqsOYQdaNZYRLHVTOsph +Nem7XS0WT+a4StZ+3UfJZ8D/JWqxzBimsCXcLUUHtqopc1mtsrfVV4GVYRPS1WKZ8YavOeVN2yj3 +Iw9YO9Bbig5sVVM8Vquv4ilwtVg8ta5tc1LYsJ7x4MvzPxGp3P/RXC0WD7aqKUhqv+FB6qtgtzoH +rRbLTJeyaX1Na4s3U6thb1g70NVi8WAtm+KRWn0VT4CrxeKJdW17tzrSMw5czVgsmIOq3gWrxeLB +WjYFyV3kLLPVV5np1r0lOCB3LeNq2rYFg6FfJSFIO8zVYvHgfhelQ2r1VTwBrhaLJ9a17b1yWM84 +cC1TsTR/1YqcsPZQq5qC5M45+rIr3DW+JHqoxYJs0Dpvri2s56gxHMPagb0Wi4fa6VuP1OqreAJc +LRZPrGvbu+WwbjlwNVsRaKiWPWe1WDzYqqbMeL1kKmMtFuxby3pu0mqxIB9AX0qbtllujR+wdqCr +xeLBVjXFY7X6Kp4CV4vFU+va9n45rGc8uJa5CJiT3PbharF4sFVNQXpXOetp9VUQONdlW4sFu6zG +gmub8c7tsMHaga4Wiwdr2RSP1OqreAJcLRZPrGvbu9WRnnHgGgYjSqVq5Qa1FosHW9UUJLXKLV1W +XwWBy7r6oivK15LU+2NtCxjNFsRUrB3oarGMYKma4rFafRVPgavF4ql1bX13DesZD65mMOLoWu1X +q8Xiwf3GwIL3oc3mgLVpC0MYHFC506T2vWtb2Gs+Yu1AV4tlBMdgbRVrZItypECAyl6ldmjbu2tY +z3hwLaMRaZjN0LC566EtB5UJOUQrja2EpdAPJPQFGRcNlPeWIepkdCg7MNu89dCwZJ2iilMLIfi3 +M0w/rnT6lr1DDuXY92slghKxwe63KKYleLAcFKVOmJmoNytiH2IrDmgzJmsep2tbs53Y7Vg7cFzR +BpaiKSNWrq4yEqB1WEZae8veKYdyw4D/sDN8M54FSnqyottwDmwVU+YMO0xTU0Nqq8CSwjt4PZCY +kaOdZ3RtMcKmepxh7UBvwzlw164c1n7RjqPA1WHx1Lq2vV8O6xkPrmDD4Qk2uSKv12HxUKuYQpTO +GuSR2irYqywHyF0dljmj3qOxOWsb7EpQh7UDex0WD7X173D2myXd+10dFk+ra9t71ZFu+381Ay7j +3elR9yatw+LBVjFlzligchblVpLcsWsl2s1yWocF2dAj3NY22u7ksEa/aWodFg+2iikeq9VW8RS4 +OiyeWte298thPePBtUw4wFyDVpTQOiweqiVTkFrNUrXaKtizGjXyY3VYkAuqWLm20VVHV6Qd1uuw +eKhVTPE4rbaKf7+rw+JpdW17pxzWbf+vZsAB5rSqimB1WDzYKqYgvTWp1iu1VbBvegOcq8OCfGhR +x8bawiuaHpUyrB3o6rB4sFVM8VittoqnwNVh8dS6tr1fDusZD65lwAFmrbTT67CMUCmaguSWEvT2 +jVl525LaHlqHBaEUmhhaJssicSg90JRgB7WKKR5n8HuYvj74PaxT6tr2Pjms2+5fw3gjYa+ZgFaH +xYOtYgqSmqt6DPSWxoyVabVykNVhob0lqM/C2uKvdheiYu1AV4dlBMv5W4/Vaqt4ClwdFk+ta+u7 +a1jPeHA14w2XTdGkQavDMoKhl6v0oxfjl7RhBC5SgS71FGNapYvGQq1tdjqrYc2DIqtu2gEslq1D +Gs296AiIzhXpiB3a9m4p0jMOXMt0wwEOKn2sCosHA2uWqsJWr51Cf2gMAgxZz2AETUSkHs+WZq9t +M5b8WzdYO9BVYRnBdLZjxBr79tQpiONWptQObXt3HdYND65mwyFtq6b4WhWWESz1UhCoxRNj3x2K +FRSP404SWztv28tZOawdaFVYRjDXTBmRrjbm/f1ahWUktbfsfeoYN93/j7PgUsEznz5b8n4Dtnop +oHDDItbqmFJZBYSbC81ZFZY5BVNGXVtQ+sFi3WDtQG/BObDVS/FYrbKKp8BVYfHUura9Xw7rGQ+u +YMGlYoXwXRUWD7Z6KUhqzbNlk7GbAbqVcvNA7lbE29W3bfEiby1NZlg70FVh8WAtmOKRhs6WToCr +wuKJDZ6F2q2O9IwDVzPiUg8QuiosHqwFU5Dc0u/24Moq2LWcWnRA5W1a9A57a4vHdTS0p0g7zFVh +8WCrl+KRWmUVT4CrwuKJdW17rxzWMw5cy4QDzGnRG3vVPHZAK5lC1ErQUWurYMdK1NKlZmSkaJf4 +9pZ4+bRGNw1lB1oVFg/smpVDaZVV/NtdFRZPqGvbu+Swbjp/NfMtYSqu3mBhVVg82OqlILk5a9RH +Kqtg1/pVglaFBdmg18S7tnQ7dN1g7UBXhcWDtWCKR2qVVTwBrgqLJ9a17d3qSM84cC3jDTDP/ZYH +rcIygiV8nrIzl6PtH6vdpxZt+wAic1zHlnj4I9cRo4c5KdnBVi/F47TKKv71rgqLp9S17V1yWM+6 +fw3rDbdPubjCVWHxYKuXQrQuWh9aKqtgv9q8+nIrytd+3NfaRsv4dVg70FVhGcFSL8VjtcoqngJX +hcVT69r67hrWMx5czXpL3YfnqrCM4CqpzwmPluudYoWPJlLnmsYLih5jJAmYaj5rCwrMusHqgVaK +xYPRFVAVQbEcTLUaHAXJWRiOWte298thPePBtew3HOKklqUVY/FgoGJVYavKOPpCo5Lb6/IRUHmz +Ntt0tS1mpZr5Jkg7zJViGcGg6dj6b3b7+FqXDQECVN52y8G17Z01rGccuJr1hkQkLWttpVhGsJyV +JeDSY2UcCU7ZRbStFAuBk569821ntb4c1g60UiwjWCoJjFhbOXt/6/K2U2rteo8cvk3v/2NLscyx +u1u8BefAWkRljqh1DmVW5hjtNLSVY5kjKvZD2RaYGJag2tF1mLfcHNiKqXiUWnPFv7tXZ/FE9pbe +pWQozzp+rWN2ES+/DZq/qBVaPNhqqSC5qWlelFRdoZ7J6X1XoQWZoGfyXVs86a/anmHtQFehxYOt +lorHalVXPAWuQoun1rXt/XJYz3hwNestZudttgotHmy1VIhgy0WTY9TYuVS0AI5VaEFGpKoWs7Vd +UMNcNlg70FVo8WArp+Kxat0VT0Cv0OJp7S2zc7cbyjMGXMt4i3lTIuV+A7VqKkit+rWs7gp2rEsN +q9GCPChVzwxa2+W87osHJreml/N6Kh6pVV7xBLgqLZ5Y1zafV34558DVTLiIqcp6Ct2qtIxgqadC +9PYS/BIcjN0mcFVakA9r1Qqn1jY4tcSweqBVafFgq6fisVrlFU+Bq9LiqXVte78c1jMeXMuIA8yr +HZayKi0j2GjoQXU9axXJR+1Lt3DPotu2rC2uTlXjjFsdZKVaPNgqq3icVoPFv9/Va/G0ura9Tw7r +Wf+vYcUBVtAxtvVaRrDbyUJex3ot2C+toObqtSA41E29FppyuG5GrB5o9Vo8uOt1DqvVYPEUuHot +nlrXtvfLYT3jwdWsONRVZvVzWL0WD7bKKkTwogmUmgsSUbHUSymsXgvtL5ZA6drqHfEOawe6ei0j +WCsjOKxWg8VT4Oq1eGpdW99dw3rGg2tZcSSWLFVS67V4cOrbPPqUgm6pXIMF+9YshdLqtdBaXfWO +Kdc2rVpXyCsaq1YV6jkTA5hLq3ikVoPFE+DqtXhiXVvfW0V6xoHrnrkbRlnrtYxQqaxCNHc/F9dg +of6ZC8DqtdCcMu3VtQUDoGyweqCFSQeoVFbxSIcp7bwgi7Mh+rlwN1F7twzrlgN/lfVa3DG8Lx31 +s4IteAuSGnE0F+834Mz+AwDidjlXrT0hdzPP0XICBfj/s/euy5Eb15roE/Ad6o8i7B0bNPICILH1 +S6Rsj8+hLYdlzyjixEQHxWZLHPHSw2bb1n76s75vZQIJoEgC1U2yil1SSCwsIO8rV657YgmMkfPO +lG74rWmRu8MOas2BsQfHBwruDw6CT0bgLueLMcK42xCtjekakUHHCCRuME4tdSx+WwYkEkgeqwlh +MmDWsTUzdiI4g154SD54EYwGGV6lmVCBNuBeUOGudCA2hWYImDHlCrTqCxWQvF8vqitbJIxjveAX +bMyKVMJsSSkiVJqmXgcdneQDRqcXXZTI0mJjjhf6WulMBGzOLi2SOlXAyNU0yY/Rqa4Q70PFIeMu +rRQYDj9DiyHY0ijpV2BdIVeSlb4kgYuhOcgTAyD33nGsQG8osCWOZuGETgjGLV5YOVvajiPWSI2o +ZKa2ECMrOxcncEgpEWnp0uWKMgspp7bMV90qMKrcdW6tRu4G14dwAqGioVnWISrasJDRuhSQAcgw +DdV00Y+JDRibVb5F1pc9v4pji7YVAdNHVr81moQygM6rKAWOUUUhQURhAyNxbTs7TGjlbPXEX+Z3 +6TwU9WbfsuzCJass/WBZx8gTLFodbziT8VbUN2IhXK3JtAQZK9vElZSzOm1MOC2YuGgeLqUJn8va +c9HqiInCMQXFmaQHlp+tSTK+B0lKe7K1PiWZbVWv2XYpfwIuPldGHcGzlmJNqDVlzVmcVdgJdW1T +PoC21GQQOtWlMt+Yf5N2GLHgeP1qnfAgaDuS/NU3fwpvfn/99uj244efhZzfnd9eA1gB+OYvN9d/ +FZp/J2S/KBR8dP7TxXX+4uAv7/HGlPrq+//5xz9cXEo1B7/rfso587sf/nzyl5u35/g5OIDuffH1 +6jf/vrq8lleFdOv24sePd+cfcNTIGXZ7Ovri7OeLy7e359d4b1e/+9P1Xf8O/7uLJ9lvyq/kIPvH +9cWZANN5ln/4z9PLj/rlvx/+8Pr0it+hE+zVto7j19nj+PUFxiH7efZI/nXx9u7n2aOJX2/1iH4+ +v/jp57vZQ0qfP/uYbn78P+dnd0c3H6/fSv+Obh7ZG/0A33H/y6d3H2aPclDm2Yf6zZ/efHP5/ufT +N2buGC/eZrzxPWPCN/85o8fbQibvPt7++FE4/LPzubOgRWcucWrnuYmmCOtzx/Pj6Q== + + + h/M/3J7/348yCfNJ6KjUs4/w+ub7u4u7s0eoZD/KD/z67xeX5/P356DMs4/Qzh3a9cer787uTv+5 +YGR5kWcfGLbc3LHdnn/4eDn/3Eifz6FA93TdPND19dQvOwTO/56Tk4c7+8C8P/OCXFzPXY6b9+e3 +p3c3t7MXpC/w7Gj2/c3H27PzP96evv/54mz2EffIVOQn3fWW752L60dIyGAw9gV3zfHN1fubDxd3 +czbNU3SAfNijbf/u2/N3q6/30t52jGMv7W3viPbS3ppRbom0579kae/d7amwvZd/ubn48MrkvdlC +/F7c205xb/a+3It7e3FvL+5NRrUX9/bi3hcj7hX2tQh8S0ay5SKff3Ui34IR7YrIJ3LQ0fk/zy+/ +//n07c2/vmzblx6ZFAtfy4H54+XHR7iVz8Bsbqtk8OHu7bfn/7w4RYcWSD15oRfjCf54+vHDh4vT +6yNdwF3hpWevzdv5x/DblziH5w9k/in89iWO4SUUYNup2c27dx/O746eg6a90Lb/jiPcoQ1/Cb4F +XoJnN5c3t//1r59VjJlJn3+9nK9KjF/vN9AnjOXD+/Oz7z4+sh92jyOY7dvz4ePtu9Oz8+/PTpcg +3qDQ80sdswcni/vx8vT2+Ob6w93p9fx1mxZ8AWva0lH+/t/vb67PNxhlX3CXZJOiKsvZc7TlKg5T +LhjLdis5CrtkLP89eyz//YI8yF9vLq7vTqL64iX0keffx616EpmLHeKHXqcxYSHfsO1s0EaKnsXW +hO1eo12TjJYYSbaFGJzeXtz9fHV+N98At0tEYfax98sjypRsOPh0iwfyCC+eD8Rss6jwi5s/ELfV +A5lPlX95CaL8Kq3wi7mBbT86Ly/u/np68Zgs+YWfnbsjKy9XEy/ecS+0kH8+v/3pHDO5Q0zQ0s31 +Gtfi6TqwdxnaWKH21StRpy3wStluZZoxe4+h7fcY+rKCRI5vbi6Pbs/P/3u2VfM1eka9vbg8nW/X +3SUlhjmcHVd+e/r24uN81E2f74Z2c7slzvkDeTt/IG+3eSC7JmL++eb2/c83lzc//bpDosmerO0Q +WXs1xGx+BMuWE7NXG8a2k8SseD0uq69mpy8Lp9jmrT57JLu213fO4/b1xuzPZln2Mfv3jfFlY/Zn +++HuWsz+AkK+7UfS7E229UfSfAlnx46kncyi8IhHSUbWljnfv5DX/Re547feUePH2Vi29dRr9kh2 +JQjnb7PNqcc/n15fn19+f355frZEnzYt+PwWodmW1k0HOS34YufQtxcf3l+enp1fnV/f/fn0/Q4d +RlenUtVsw+ROSEer9O9q8tMMfs4dNX/N57/T51tMKbf+JF6Wa3CbT6/ZI9k13vsYYcx/TuRjV+jd +Asza9j0yW4ew9Xtk9kh2hcObH4n8PIlXtmX3vVvkH/Tu4vJyif/T5Tav9Lvbm6v5g+HHz6+VfITJ +yQxjj3mM55axjy8SczV7LD/iTq75unH9+vmN+pf/Ov119piE8t2d3i6ilPr99mrC727mSx43LzCQ +23OKgHOHc/r27cXdxT/ni1N9gRewx1zPH9fZ2cerj497C+Ujy4q8QETT9fnp7PCXs9PLsz/fvJ0/ +tr7A8wefzeYtstVLzf+FQ5i7gMNSLySSnF5fXJ2+WGrYXc1DV4S9M8yWSXZnr8YZZv5Idk37sXeG +2RZ17/7CwolOYde8YebnNNs1d5gFpHzbD6VX4w4zfyS7dijtpDvMbP5zN9xhvsgdv/XuMGevxh1m +/kh2xViyd4fZu8Nsy2H0BbjDmC/FHWYBzd/2k/jVuMPMH8mu8d676Q6zALO2fY+8GneY+SPZFQ5v +29xhttr+szvePAu23FLi8UJruItZAxf4Ae5X4clW4elybuzAIjxdB16o8d1P2vjNn958y5w9b5Zp +vmYxRLtzRL3evEXz1YA7krXoeRKAvxQ1XZInZ0/RHqZo9Z6ivUaKNntZ9xRtT9FeCUX7/a0AvmwW +7RxT8Brp2Z5D29OzL5OefdEM2qulZ3v+bE/PvjR6lht13iyzwr8ysjZ78F+QDW+/beZsm+ZL3jaz +B7/fNl/4tvmybgv668W/zy//enn665tlwY7b6LBTlatqtvekzvzfFjhQZiV2ifLdnl/dPJbeYMdy +vczPKbLPj7LPj/KZkG5lvrblylTy/3Il/30tv+Xv1/Ji9dpcti+u356/u7i+mG/guj1/f3569+2C +7ZaVePbx7XPE6Lh2LEfMh/fIEjN3dLuUI2YmN/KlJYjZFh7qFV5Q+OOSy8a33FN/yVh2xVd/r7DY +XnLw2N7eTbvSIoqw5dRtQ5PS1ofP31y9v/kgbPl3Hx8hYbscwBfHuEME4fT24u7nq/O7+bi2S4Rh +tk7tl0eMU9lw8OkWD+QRZWg+EPMSyojZA3nE+SkfiNvqgcwnzb/sCmXejUN0odSzS0foq82K+FnO +0N0xcWy0pjvjQLQPANybk3fPnLwsTeE2apX25uR1s7I3J+/Nyc84ntdqTiZxgUHZll8vIjR7E/Le +hLw3Ie+vGZmMbG9CXtPd7VER703IexPy3oT8+bUTO2pCfk3G1rcX7959nH+bybaTgoXD2RVqMDs9 +3YePt++Es/1+WZr/QaHttSPp9C8b26DMsw/t1/PLy5t/zR3f5cVPP9/J++IMeXBnD3FcbHsXMO7O +45trEd2v5++7Sbm90u1FlW77O24fH81e6fYUpPTrn27Pz6+/Fg7s/OuL67cXP918/c+Lm8vzu69v +z99+fXN7ev3T7K2218bttXF7bdxeG7dmZPP5sL1K7mW4KhNmW11O//vi6uPdI1c/5kuSvn92xKtn +j+n8Uh4WqXyyEi+m7/n2gvz7CfbXS3nEfKuyxEnc4zuE8q9J7fTh/fmZHFy3z+EL/+zS0atW1swm +UWmJF0v704LbvIaxs7//93vh9TYYZV/wBRjvR7S5T6Ca2utt9nqbvd7mC9LbRC2N6m2iEofqm73e +Zq+32ett9nqbvd5mr7fZcb3NZVRovAoXir0S6umVUN9H4W8HtVCvM3/GBvqobVexvcoI4OfUG74Q +fdrn0Ng24vBqcmjMz9iw5Tk05q/IlufQmD+QLc+h8Tz3gGy3N/H2H5+XF3d/Pb14zEqxPzv3Z+f+ +7Nx4IFt+du7zT23b2bmUKm/7sbmRML0rR+c+79Snzf22HLuL13Ofc2pJB16o8X3Oqd3KOfX9z6dv +b/71FPcX7Q4l+sKzC+yKX+fspGj7iPxn30KzL9Z8+wg5zd3a/v0CSDZ/IL/OH8ivW04Btp2a3bx7 +9+H8Dlvi9vztIjq9azLAdxzplyEAbL6qr1ES2JZVed33ie9Fs10WzQpTfTUXJefzGS/BZiwZyXxG +4yX4DOPL2SP518XbBe6E8evnH5GbP6Kfzx/3PMyGlD5/fg7qS1RqPEEW7d3hrvZKjZ1QatR7pcbW +ssLhtSg15g9kr9TYAfF3r9TY3mN3r9TYRkq+V2rslRrbqtT4wkSzu9MFjpavUTB7d3t6dnd6+Zeb +i/mOzVp45hqnlp7bP/Nwds6WH08/nP/h9vz/fjy/PpvPcY5KvUBM+vd3F3dnjyiwcokNX//94nJB +roRBmefXfM32sb3+ePWdYPE/FwwtL/LsIzt7Oi+z5x7JMq3WFsc5zx/JEwo823IqvL5kRwvOg3e3 +N1fzh8OPn304ryl102tNdVQezr615e5mPj918wJD2ecuGgxun7ton7voiVXL82WSLy110ZMojf7+ +8fbHj5cy2bukR3yduVcWiBRbLhw9T8qVF9LzLokP26ta1/KHX70O77H549hy37Hy1fmOLRjR3nds +zShf3EDR8yVvHgm/f91mirucP3tFRopyb6W42W0rxWxvpl0zUmDLbYFKfC/uvW5xbwma7QW+vcC3 +F/j2At9e4NsLfK9f4JstGrxGge/1+qXNzumwl/i2U+KbvYB7iW8v8e0lvk9Cs73Et5f4dljiK8xr +kfmWjGTLpb7q1Ul9C0a0l/rWjPLFpb7/dXPz9qfb0/nn/WsU+V7lnRGLYsS3PETiNWa8mC3M7TNe +PDtB2KfxfGgg+4wXn8hhpDwQr4I27/N3bC0Ze3cp3J1eQvxfP16env3y9UpBN+9Pzy7ufv2vBTrh +D3e/Xs7Xccevn9+Fe8mFy9u+sxYNZtc20x+AiDu0l16nRnTZftmJc3WznEPbfuvPB6ZyPH5N5O3L +YRx28TbA18RwL70+c8s3zsLh7IpCZLbXyYePt+9Oz86/PztdwpEOCj2/pnzZai0b26DMsw/tXz8v +iM6/hFZf3hczOI9shONi27t+cXMe31x/uDt97CrFXKsyLrdLCnTjZm/e0/++uPq4wLTVff/sS06c +ezVZhurZOa3OL+VhkbI5K/FiPNa3F9w3J9HI+BJeA9IH7uGTSKz23N6u3Pq6Z5F2iUVKC7z4jJ0W +fAE/+aWj/P2/399cn28wyr7gF8IS7vmll+eX9uzSnl2a24fvI6HaQX7pdVoDNuCctp0ZfB436e1f +p73K/BnSid5e3P18db4gr/suEYfZB+Ivj/gUZMPBp9srZ/zyyJf5QMxWr8gjGXzygbitHsh8yvzL +SxDmV+lIvNR6tvXH5+XF3V9PLx6TqPdn5/7s3J+dGw9ky8/O+UzAlp+d8wey5WfnUqq87cfmRsL0 +/uh8BUfn7uih97c0biMv9OSUcAfW4uk6sEOI8FpTEe2Tz45GuXupiF7vFXkbWQy2mxX9++Ic1rvG +t+1kkqWrU6lqdnqJXSDsZlXGf9f96iBzh8xf88lG+nwH9te2U4w/StEPjzuP7S7BYCTVn9MG3BWK +8QrPpmeN/9rW7Av7FB/PnyDt1eT4KGYLU9ue5ONZFFHPPKbvvpgo151Lj/E6nfgWs26vdwdtvz0F +9gaM7O+vOAHyLrojbLIu276P8jHNDmvcFVbbHM6Pjdoz2/sz6TPspR/end/+4eJ2G1Qk27LOd6c/ +zl/jXVBo2tVsOwfH/j+XaSwHZV4uFdfH67O/7RA1eXVYdtisytWXgWd/3OPZC+KZ+VLI2dFLuZhQ +2EHU9d9vT68/vJtxi8T24Pvr1IdswqptO/u5YZzJLmhDdGhbwlfv9SFxZeg5983l5RasybZMyWbI +uvfVXNKBF2p80fVPX33zJ1O++f312+4aKIAqQN785eb6r1IF05QUCj46/+niOn9x8Jf3rMPrq+9/ +vfrx5vLgN0enb386X5lVsfrrxfUvvz34KP+Wq+8OeoeaH36Vh/9HfvwfAf1r5Vd/Xv1//7tcvRXo +D387KA/LsmzDylaHTbW6OijMYelNXUVAYeV9ZeqV9YdV5RoAWle38t4durZuVmcHhTsMxtuVtYeu +RBl/WHsrVZpD2wQpUh3WzsgLAZTGexSpDoMNXr4pD9vayDe1NFtVDQGuwrNt6tCmZynSHJpQtbb7 +IhxaHzxrdd7Vq6JFkdIA0LjAnpkSHzXomjFWmjHSp0q6IADftl4AMkDfNh0AhWQcTQ== + + + aAbf1B5DFoCrLAGhaWodsTMs5GS6Ss/GZTrx3AbH/rvSyPoYf2gx0SYchkpHJCBvWrMyzWFlMAkC +qF1Vr0x9aKxHQxW6IoXwt21ZCO9kuPotKkZpS4A3Ad1FC1W7YotSWAqxF7Zaaa+kkHbTA9Bg+AWH +Yu2KQ9PJE1DTVgSVtjH8xlYybJnV2rZaiWuaFSe+5ZCw5rImzWHbVjWqLeUTGVF9WDfEDeKA8yvg +hK19KtM0YUW0cakvjV8Br1yJQsA1IBBWvnQsRHyUJRD8xGIXwFcvgwb6lqZ7Lvmx/i76l7F00ReP +TRR5G7EfRd+R2NWi72scD5Fc0D3ONgdd5KPGtBT9vMSpK/K5i9NbdPMbF6DIV4CrVOTLFJey6Ncy +rnbRLXdCiSLDiYQ3RY84EbWKHreIf2380YaItbXzJn7uUwWYJ1aJyWAzmCc2rMvMzliTuhdih0OT +sLHqN5YO1Nm4Hbn7inz7cYMWk11c5NuYW73Kv4rUoOjIAWffxP0QaQbpSuUJU8KilCew5wPiVPTU +KdGv7ptE4YqOxJEM1mkPKB0EHhkfEUvWhagmUxdnAKsChPTdLgiKKoK2lh0AInMNpH1BZcX7apXI +enw8OyDqt20CoAKPGU8VkKxza3StkKyzytgVdNa5qu8tRuSawYhk2LJTXD9sTEzDb3RiMHctULib +O0xvcP30ygIIObRpATzpS0h44gKawVJWpltKIVJY7SatNkimDLECliWAFJJxBM52/01dmTailm+U ++rUh4R/KkK7XPY4SjX2/yRJdj3uM7ZCu+wFprl1t+h2G7RTKbl8B73Q3ubT53Gq0Pys9OSqTb2Lt +RNzoeuRKJ22iBUZPKGw6jqzGCTKkKhW/sVUwke7oOc3NwO1RBRYCAasTBSt5rjVceqVxerZj3XvC +TizBpiSxlKEpHkUkd8YpD5FwvDIsRHyMhLmtV0PS3awysp5TfBcZlIjZQpmVoHs9MxqvA3cgSmxd +Cib+hN0Tcj04muSZ09u4Op5enoMUMl7zePONHvayfETQyhttQ9Aw6BEZVjrXXo/QullNT9nxQTw+ +qaeH+fi8HzMEiWb3JHvMVoz5jilrMuZeRtyNkukm43/GLNKYh5qyWWNOTIlzHVm1Wue0jbiIPpEu +N23k98BjmFB3DCPISsDyJ6pCumO696RL1nYMJ0lXlfOkibol4pbIX6J+iUL2BDIR0URDE40dkmB9 +Oh5x2icHRz8eJE/3o59FEPnNP64hNLxd/XR7+vbiXKQS49vfSjWyNibgbyt47uRzd+gbBwzIHOfN +6uinA18dlrWQIACK9FAEU8sCY2MHWXVZYqEHR1cH76T5oyMRF/7jI/rWlEYoVHkYgnUyT4DIchgd +BhZZXlXy0qMnpqplqUqc9o105IfTOLpGGTEIEjLPVtDSRYC0y+XAgeMoUAi+G6sHjpVfMkPusC6r +Vk9/U4MhjEdLJY1JJXUIeo40jcWMykSGxihH0Rg5a2sQtKAnSR18rYeN65+P5bCxDmjWgcKhM63T +I1h4QyCek8Fpy4LzrRQS3HSWJ6EMQyYKp40rwaBjv4MG4bBx/fMxzxpX+/yLqq70qDEtyLtMAPAf +gDLULOMOK6vnnnAFtdKEWsdny5rbsCVniJ0KjusYe9uQF5LNLEeYkoUSZ5rs9hLdFzogfa951lgs +5PFBelXox36lhfVoMdjZbKBWplL2C3rHToCrZbcqylnsZsF+l9z8ZSCXibGhIYHwfDVkWFp+IWRd +j5raso6qBL3HrFfWaTstGJWADRy4oz1qw0kj8h53dNOgEqKEw6oSSYSiyVEjxKSkLCoYVOGoEZzy +PA4Eyyi/Nr7UhiImFsDNuubO9GgZqGtCUyVAiY/jz+4VC5tVVxb143yKaM2xm1q+7HpARDarrovE +41U2CAxUFiEbZyv0AvMgmK9T5f0qmynOJklnLazlKs42J9u33XJwNVyr05QQS4gApzbhFVc0oVW/ +6BlWKV4Qc7ximRwIxCkcIT1u8U276tCPCGoVxVzd4TDb8pWiPdGcvfFmFbdB11l03/pVtk+wlxzx +zbQ1t5Jz+pw2o2/Dqt+L2K1lB8BuNjUPEpKPNKH9fgdNoPIhkgQQDduyh4JUetjIabPqyQopjx6Y +hIA0CYKvEmXCKoPK9MQLxC3RtkT4It1LONRTxkQ9E8p2xJW0taO9fDo+GCBwpfjdlSYvKw1YWV9F +WjRQDLrQxI2km5xd5GaLCpk4ggKD9HoEc5AQgqxr+3mJglKdTVTBufS2/2Y82UoKGputRzFesmK0 +pMVkzYsRUhRjpCmmeFWMMK8YY2YxRd5ijN/FeAMo3bUm2yPFeBsV431WTLdiMd6txXg7F4Mdb7XQ +kCbwE1Bi0gxv0imnZKUm4aIc1jb1KlHggpTJ9ZSpmNAuPaabnroVOfnzbDmjkEqAi5yIVso6JCJb +hii9JgJc5NQ5vo3Fi658bKLI24j9KPqOxK4WfV91OEU+njjkIh8zZ6XopyVOXZHPXZzfop/g/AxM +S9Afk66N05edpabqz/zuuO1QIjuTO7wpesSJqFX0uBXxr8gRUKaOpyw/j5ohI3s1omIVtUd1OeA2 +tDPeDLtXZTxLt62KfF/FvVfkm8+5CBls4CLbwXGP99+ACjQ+smFY+EQqMl6toycdQ9eRnGJClzLG +sCNe/VeJvnX8JRGkiaqKRAWBRaHMOFXFtI6LBTK6FoJ8T88VY63p2WFFa28iuzxip48P/iASwrc5 +l11DWS8tCMtQ81GabYxLapJQEZ/rNmlqLaRIEm0RolyElap5F2kiMsCj2YkQkm0cBzb7CqtRtTrO +ZryETUeEFQezbxprlTzUISK8bhjdJ4mmQgphY77GxAukbBrVdpeqBJR5ocKNP+o67gbhh2z8PJhY +QaUVBBs59sqE1HDcfYLDqnnFnKheryF2N9BQJs1v5Vud08Y2cdMKglideU89RqW8K9Yl+B6QCBh+ +9+9i8b50bCNvInak70fsatfTOJx8NHHM3ZDTtHSzkuYunzq8U51AnF+UrngYxiVwHQ/frVNcTS6m +1c3P9R6jRIYREWvSFwmvJsiX4R4xtHH9NwmHEwonPM/QHJNaBdarewHTLgL0ytYZv0S2u38xLoR6 +IfH29UrLwUQlQUnlZlP1nVclhM36rgp/oxAhqqPhT+ZnNIGDCTZxlQdrMF6m8TpOl3qMDWN0mWLU +COeIk6FDySnWcvpk0AmxR4if7Ynxfkklux3FyuuQb7vYfLc1h5u3WQ03uNX+DInAhE5wdpo6JyZp +InX3OLtKM90RJdbvB5SL6xUPfV0wrKdzHQFUrXST0UhgRG37L4AxTZUR306H0SEVsY4nSwQlrEw0 +PeFtRvcTaneHQ0L7It8QBXfE4PHk4N3Bf/zj4B9UVv3w9qBe/ea3qx/+1xTw1Ruz+ua9/CnloPrq +TbfKV/3DeJkHq5yh0BmKjLBshIMjJGWJESKPEX28FVBmsl3G22m04VgGXQjao1Czh9SAo8PNhGag +xJiu3EOL8GlOp6ZEbEzoWGLUgWLUvwnhZqEpeZ8cAGuma3qUTA6bdSszPbUmx9oaDFhzQI5P0IRj ++vnk8J2ez+NTXAtOT/sJQzDmGlIHR9zFlAOZ8Clp+sf8zJTnGXNGWlJXt+iWNy1/kdZ/wvWx3JQ7 +zJnHwZbnZsrIw4R2TOgLSqAfnTQl/UBHTexnXU+pZdx+I5o6obpjysxi41meLMT4EOCQxgfF+CAZ +nzWRqIxOpPGRlePgNfT431wj9ksoIjxxhCLCHYcyDLR5Iqc0Xk70KxWZHTp/WAU14LfwG4DfQ+1g +2gDAAScqIfMmWtFFFoO5pD5sRKoN/EaKBCgfKt1ZpvSViPNt6V30RjC2hJqr9ZVT0c3AtNZCvViq +qGkgRclRBAkkioc0mqhmTGQckYU9xJIGEis1ASo2YlghODXolLAcyExVJRYYBqjK0h/I1S20zO2h +N3xuDQyDcvjJAENFnMWuMvhE1fMVZWSWcVZJn2kq+lekKSgwBxX0fzIFmMgizQInoaZgHmcBhiyK +cjLGyqqKCkMiMlTYgABUqlnigI61TFCu1pYVO6fmBVq3HLRAFSRcsr0NTUIiTreKiJD6rCpI9YsW +Vm9I2T5qiYwvazWdUdNG8TxgDlDUqT9Gy02B6uEBwQa53dgDyvTSJ5GF8Y1prdqlvcPsC6fhShVn +Bb9VDVr56MYgQqyjDqixijTkOlvhI6pGKynbqqHVLZINaagG/jeyuphAAExShlIlkAB0AmhVhRBB +sndt+sbCkwYYXdZ1RHHr6G5Q0yOGuwAbS8aarP6KG7J1TKSHNlr0BbWrKHJKO0BQh5aVhDc1PHQy +0uYO20bFHXxnalKr9B3q8lFzRdQr8gZdadXbRnrlW2XPKK6j25yz1G9gqghDNh9bMZkAyDCtqfsp +KtbMYwEDbRkr169kPSy1ClgP7s2WuyHu6zJ6lpUwb+pSR1IiFLKKa1+6iOeti+QaFEnlOT1bpJRL +jjbaOrXbiujNABOLIbrWISK7UxbCttGqpMoh/PDaRWB7MPHr6E+U7R3vUyvaLCgViklX2ti1utVR +ex8UYkIbDYRV3HSlHPdJjlaYLCrMqRwjleGgCKoXjKSTVMM6H5uDdaojrwPak+gvaXSRE+lIyIuO +kidaX3TEPh0IRToR1AOM3lLExYTDnsohl4g3cFgISBn1FnyfvY41oII6Ok0Nzp0z2J3XGZub36IZ +A8JgYT6um0MLnZ2hL4ubGpvhVVDzZPQQWeAUVwvatIr43gQ1PUv7sq9Wciq7QyOb74crSKCOWiEv +J27A0q8r2bTwc2hWcKMS3JWdeXS2aaNHcxv1suO8LHSQfUDtnbQZDeX/kPP9d9/c3g18xiHtqAcx +3HtXZ/DZ/3j9dvXh59P356srOkb/p3z1tfx3YIc+uSPpaQ2LoCzmYiYBXOJSNkHZ4KWMgnKyi1kF +ylCLmQUptQm7IMU2YBgogC5mGWKphUyD9HA52yCFNmEcWGwx68AFW848fPVmI/bhqzcbMRCQs5ez +EDK0DZkIQf5N2QjK+ZswElJwM1aCeoKNmAns8Y3YCRTcgKHQYhuwFCi4EVOBghuxFVF3sAFjoU0u +Zy203CbMhR4wS9gL1dssZzAgBn/qURnF6JXMVh3VjWur5MdtOkO7EBsNjrk3XEamdPXd7en1T+fL +A2bkQBKEd/RpsEJdGTODcxF6Oq+OUCc0Xvq6omeVrFxLUMBk0suGf09osOLb9PWJBjZgr6c6T9Tw +DxO0tsy6bC1HUI18AN17RiVo11I1pTq9p3pSa0XWXOpMkfcqvi7yzsdquv6dpJlQBGcHT2SKuq6d +HKTudB08ORhWU6ILw9ZQsXYldQmAacfXjG/NNOTTlF5nb2MdfRWxC30zsQv8U7VZb7VL+ZD6iUnz +0k9L0XlR9rMzQaRZLqE2wCW0bIXHgJOmbehMX66wCy20tWM23bVw3VVAkR7AI7cgjA== + + + Dj6h8FmeeoTKuS2cUAnLPRi0UgiDgdewtG6EZcOr4BtwdiV8+EKg06gwijJyOIQSE2Balh0ipEpP +ax4EJbBMnQv0LODxhXkTVkEVmSS5JwfSxwDHa6ALvWC5AIYmeDD0dKSFOo9kTGh9kHNKQQ2ZE5B/ +6Di5ksJB6UnDHydU1jS1KgQbORwUFGqqY2OlxAlhKpTtY8tEHPamSP0jdukxEQdxcsBxWR7sOlJ+ +xNEXaT6IoZyjMnvdv011DKpgO10zqS99V3RiqlXfX47KhlU2qDgv2cg5LSv+CVU2h2mW+olOk9Qv +hs5RtmDsFduOHe3XlM4rnkx4XPc03h45ylWal5ODYvA6QnQ6WIWvdDN1zUB6EMigK0SdYtLdYjqk +YjruDmV61CnS234Ci1RHP8tFwp1+KRSTBUn79Soma1pM172YIkeR406xBreKNShYTBG1WIPOxRqs +L9ZsjmLNHirWbLViuCNj9wYbt5v9bHs3+UIWPVIVU1JRJLzKCEqxhu5kdOkkedUIqME57uEwVOnn +VdvW8eCLIrNIovBU0E7WHHOjVgudap3D9EPnMFpy9Hud6taT0YzV6oqwsa55wPqjne/yV7EfWQ2p +ob6d1Iu8N/oy73OsIXXqpJ8B+ECVnEPZinqWdy/izOSldV4mLQx6oZQI72zb9zS13Y9mOmTbHeDj +eVozndNJX7M0gwW0bTaaop+MNdigmNL/3dA03iSz+GSoAptMCO1dw1mjKmQ0tZTRh/MvoMkiffVm +upToGMcjLP8UA1QAHGGKWiLHza3BOzUaD9ETksUEi1WYmsxH2grZ62L4fooDWZtF3ugaTOjHUQwH +Mt322eQUw7kr4uStfb0Gs7qlyhCwX9JB79aNY+2I105ON3fXmURVhal10h1CKVNSmGljcACCett0 +GDBI2YnEakobaTydQyvEBZZKx4waduWNsaaTbwwPO7Wo6oHRWIugcdXFncBjU3WAFqjc4ByEmyp1 +iZ56mE5h0UBB4xku2SJQNgYk0npbRrfVQOG2c8ZENCl+0A2I/SvQQSjRlN9H/4q+gwZhUxDWoeSs +KczB9Kzx+VY1W+Sf1OiOH4jOODlIL2mpRqAXiUpZMxA7VgoGqaZGr5uak4PUHZ3ABv3CrFLjmqYZ +TFLlbauBPlwMoX5QzUcFNpdMCRPWUoU2fEDtVP8BFK6uLeu8niItYtZcsaZX3Sxlne+mKRtjsWYq +uonKZqx7rQVcgo3nX5sD45Hh0WA16yFSFmn+MtwtcuRtk5N1j+PdFjh52EJig3M+0EJihAmRIoYO +z2YqesFN2UAn6KBBh+bYw8ma4a1gZUAURBBrpDMyH0FkRfVj/+EKB5t0tmaJRvXqa4q25rCFwjbY +FrtfGKKjs41bPZrbqhSgN3SwZaUBo7mR5DEjR09pog5sSGuUdI+ojRo0RvRGjSMjiqPFRzQHwAnV +EeAmdIdkeinloRvJmPaQto+pjwCn+E/gmALRaDCmQdTuj7cej6AxHfrqzRpKBH39ZNdDGz+hRtC1 +T+gRvIYmFEnPx44mUfM9oUr0T5rQJSq7J5SJC7eml+uokx7kY/qkGubpNK2jUapUHlMphU7XaR2l +yvA0o1UZSmfUKsP+Yoj+U4qVb6bJEd9+fqWp4Onqj7fn59eflGQopCxDwqT4DoJw/8DgIH9YVxx8 +6TwTBDD2U5MMtcFpBHkZDY1CiugV7kJQn74alhd4xTotBPpUWg3tD8hOIJJfVcdgzDrLMsRHTTJU +I9NKfC9b2Hh15hQujDvVOmO4yYUiuJRjyGggu1WjhcFH6rRt/TDHEAFnMTBi9E3dWoankdLQghHD +z71gc8ygEmLnQ1NrqghDz04YHVuN+XHyD+PT1IMNoIpGPSH4ValJhhokxkA2gOB0C/galkn8DS4l +GQrq86znAEtrqoDKhZjtolGHWedscjRzVUkfPsN4I+1ns9J+01QgGM1kAAhljx4PLTsMk2PMu4Gs +KbA4GaOOoaFieJp18MTUhDcOiyb0t269WmYCrEQ1wmCjn6JBODMxoktMhH4TaaJDp0c+AKBVY9WA +55FwAJhnXYg5hmp4iwI5bYzFCQ1tH2UZXPeccgyFRm0r8WUsXfTFYxNF3kbsR9F3RHta9F2NoyGC +V6WNc80hF/mYOStFPy1x6op87uL8Fv0ExxUosiXgKhX5MsWVLLqljGtddIudEKLIMCJhTdGjTUSs +osesiH36I9iIs01lYkaiEB09K9eEiIg2oToOa2044bopY0KAGBmI/rpVNgBuKxuHGfcV957mHeg2 +n2xPdcof7uEi38Tc6IOvSAuiVYzxbSQYNq1G5WOGIeOd9krIil9FshNNeXWeYCgRpkS40heJshUd +aQN2uLaJ+FJZTS/UGJdS6YRWsayO0XkeCZaIi8abiJ11G9MLwf8m4nCl6VdaZmiKBDvPLxRigiGZ ++mA6COrQ3ECxDjTEANm+IdL0lH8HvUF/SaRif4nxbdoDpOkYuI0pzDjwmuxWnWamzy8Upw5zq0l+ +CMDk1203+ZaUxafkDrSVcxWbbhWp0HUxVUONfZvnFqp1I2ugRzv4pm6Tv3PlnVK9NPWKebqb2oxS +AoHdKielTjcnkdxoMheh52FAkpuK3ySijY3UDnaU7qO06+Jh0G9MDWhuvM93r/YhnTImxGOnSptK +U7d0lMKRzg6piWbII3aS3qzSJtBtQeM7VrpBM6BbQQPMA5kwkram0fO8jud7m8oEoAVppNFDkjku +lIq2q4RjSmrJuSse+kiP1ZM7o9hhlVHzjNAbISNKyoPitG0iWxIUpcug4/YlXeWl/brpmBJ20Gn8 +FzzWdQxGpzfUssc4Ss/ZZV5FTkMVp8ozD44rSd50LvVoLDm1LUgMZ1qTEY5O19H5Oz6fp0f4+JQf +swFDTsEqNg6YiTG3MWVIxjzLmKmZ8j2JPCfqnIhzorpT9mrMgY1ZNMU+F9HRanIh4zUHFIkC7cA+ +MYZdcqFIUkhyyhCfSZGU7yRBItGKCQ2UDieyFqlaInuJ6iXK2BPGRDwT7UzEdUR94+PxmMGeY0lu +g6ozvG3oAVIJ0tVMHQQ/rnZddiGLxFjRkpweimCCrDWky2Bdc2iD0N6JLVnYytAyc5D8rZi/QmZK +LcYQI/FDcNg3MC/LisB1p4T/pZyKk+xClCDW5rPTnABEEs3W5FdFyjF2zHx2rk3JBUOt+eyqLp+d +i/ns4lFhGGun+exi+D+C7ussKULrhjmG+HysCe1S6j/HHENWJUjL3FUhZrTr8g46jQPUSBjmv3Ix +oV3KXzdMMYTn45jOzuVf5Nns6pjNzq86x7PjmM5Oh9wwBV7M9BXz2WkysC5jZIwwzbPZNTGbnV3F +BJDjZHatJhgyTHipqceaVSobk9m1Ma/ZKqZFjdEWpUmZU23KNeZWMZddlzstJonU/DfMrtZ5ZFlm +sounjW1S9rAQEz26GJxqfV1nkcfMZOdiJrs2ZrIzMZNdMLEM0wJqqrigfWlNzGTnwyiTHedNMZFx +VuqsOkxlZ/tUdseDVHal7ZLtdiXz/KdaOXPZ1auu/Zi0rOsgc9nZVTYG5rILq36UXSq7GH/dgMFm +2jWN+s1T2TXtKJedH+Wyi+mFuGJEslWHUMQwryter7oFz9DJmxDT2FWKXT6M0ti1ioiKSxHtEiZl +WexMl8PueJjDrgyrhPrsZdPGJHZpHI1uqNprcDbpgiaxa1fZDozB2nEDDlLYxQx21Srt4DSV/R5P +qUUTGWAKuyqlNK76+PGOlGSZhgg5YV47poOKEBKoMmVSbjsa1pOwROYSlUt0MJHBRCp7SpmoaSKm +6xLbabqhRvMA4P0wZbRrhimjm5Q5r640PD/rQ1NnOyt2UrOlamxwHIemVNV0PByqJl31ppuLPN9Q +nEAmb+Xo0jfjRYhZLkO2TsV4KUd5o5M4mOFCMUKWYoxMkWy1Gb4VY5QsxjhbjJG6GGN9MdoVxXTf +FOOtVYy2XjHemsV47xbDrV1M934xIA+NnkpZKswuXbSSGHiKHKd00YZUqE6BwXBujVSqmNIxPayb +ntQVY1o4SBcNy8ZxShfdU9RiRHGLjBgXY0JdZJiciufpolMbCZf7jgzSRVehH0+RDyiOucgGzVkp ++mmJU1fkcxfnt+gneHAeNq5fpyJfqPxcrfqDv+gWO6JDfzYXo+N71aFU0ePUMFV0G5G1dj6KpraK +xenuzUzRTWwjSxStuyJqBbKeNT5kXEuRiHeR76a444p8y2mfxtu2yPZt3Nn9N3Hvd5xYRyAybm2c +JTqsOkJTTKhRxhp2JKv/KlG1jsPsSF/Ghmqi6LpnVWOi6JQTnK0wUXTC/6BIwhBy1/PFMVG0XxUj +Yl4kar7PNLTPNLTPNLTPNLTPNGT3mYb2mYbGSLrPNLTPNLTPNLTPNLQtmYYQIpkcegcuvRXsLGDw +a9Mgu8FVD0PAp2qRGPBJeQQmE42yENGKAo2lzKbWf8EgFXZDsKrYZsJbSCHBhmhx17u/2sqZ5A+i +mCenCNPq9g7cSDHL9PI4V3jLTYDFv3PVqBmMzzQDtS6ksTamfU4B3XobAMJzXXcRkmW6fJiQyjpG +gpRxbQxFZESkWKOaFsrt6qVAI6ZTMwbWP0amyUokZ4UYbO77tCc+pbKvYp/wOc9PhLOk5PmV+oiF +Q/rFqRNPTCvQSl1R6WMiijM6mGJrFWeHq6Q+CiYauatQxoBrF68pgCqBEA3iThB1TmrLmCBXv2oP +22hXSAaGcNg2bYxTDq2NflCtcZF+em5AGZPGF2FZ6+CVN65jZDQhdLjiFGbfyNzEFLq665GYIVZs +Ks1QBYtgGbNSeF6H5LBtok2+op+JTIlXDwnY9HTdGKGtJp6GN02UGhqv7qo0wZS8BKY2PQSeCiJd +Ex0jyFLdYvuKHHCqTo05WvCSHB075GHo9XXf54px5jYfWB3DtrvB18k9Ms0PND4mXlgRp7Chtt31 +oADaESee42UMZ0zFkIZUknD2ZBK4oC1h3Uuyg97XrgfQrtqkW83SNzEhQUUuRqahKgdoKCBLWwlA +hkyLM9HXiGmMAUgbFJoq1cNbG1IzgUpFGhAAaKEVMzEPtqaM9tq1LGF0FVP8x8B2TWyRZYsOavJV +XVH6ouS9Hit1rdAs/1VK/63XyTj11LT0bdEk/ya6k5Fc1VF/3wFo+I2eIBGEFNFM3wwSjyQPKdE/ +ASCawJ2qTNa/EgeLI32Lo4v5/kmUUj7+Myb8V8elLOO/UVfJNfmhzw6KQdL0mPTfN1kNozzUmnEI +XXHJ7FgHzYneRA8cdnaU85ojKibDZvZsE22eSuwxfYO5IlmxNpEa/SrAkFY1/TIgp3dTxekinisZ +YwIMXU3Vx7sy3hVoqyj+h5CelWA65/IPlLoTo5ou/3+Odd1FJkRVOhhT8xjTWjCdyygresz3RC95 +VaznlwCoB1vMrx6Tr3c/1M2yS76e3QNQq6Y0uwggXu9HZuvsYNCZmI4dHbba4fwugA== + + + VZdk/uwgYy3TNSx2mq0+JlJnavXGpOZkZYxmvq8jufKNLrIsYyTdyiMIujRxeDZ5wvcp0iOWpTtR +OozvMvafxVsBOPnDawGA4kZd1ruLAsqS5OHsoAe5dL4hF0gFzwIc4qXuBL294VA5ItWUlZ4h7G1i +ZDq+KUCH7ldTTuqhHFpl9JeYxuHLOsJsrXH4SJ6DHR9sWbLfwpHjRpAfrg7qRnOsjD8UOBLspC+P +zmZWeXRvlaY2cAJ1WZVdGMeayI0pQ5lBl7GUUeRazlSqDLUJW6lNbsJYaslNWMsoxi5mLqPYtgF7 +iZIbMZgaE7EBi6khFpswmVQobMRmMjBkOaMZAziXs5oY44bMJtJLLWc3EUq6AcP51ZuNWE5I1Bsw +nYwrWs52MkZpKeMphTZgPbXUUuaTHVzIflJXt4wBRbDVBiwo1ngDJhQYtZwNBfYuZESZFW0DVpSK +o02YURKDjdhREqCNGNIYIL6MJVUSu5QpVYq+CVuqp8gmjKmGwm3Cmur5vAFzqunJNmFPtclNGNSY +XnM5i6pZB5YzqcovLWdTtdwmjOpIUdh2kf/fwValmSrT0K/UnKbBSLXGojVW70wMPNetUyLa8XHS +VZLaApwVQiPRd2WC4MGsHsnqh1vyjlQOB2PRHJDI5af+jspD2XSNXiQL2ZwDO7x69LsS1/hi39Hd +wWH/qVZ1OKDjTfh0OXiNiVeoCnuiuyaYysG5FillBYlB+zVImw2Ov21C/9nR2ewaj+6v0bcy8UKL +8mrvZ9XXrGxULy9ZW+aZ2GB1aYNbvr5SbJMVfgDByWqbjLG+YtqG0mTctxA1ZcIjf448kGbIxNsu +5yVyCcc7S0OMB27pimnTBWvgdlqrzrOR8Fo1ngCguUmFx6v1hlJKKErxNVqjvwKOYenZrYMkpKS3 +1YDe9pe1DS7ozOg2qXo1IO/yiwwjQVgOABiIDmEDq8/g5jp6E9YNr6CUb0308ibDTMHERUsIxLzJ +fG8kJzcImoiian3IfCgy6BaxLsB/7BB0CGmkg3Zy+Ck3X/rq6GxufUf31VdZ9c0cVHr/3luDdBqp +vxTtNJXwYsTjNlqKeqQOy5FPs9MsRj9O0nIEZLHlKPgAgejUBMgwBv3EVZ9wKzCYXFlKqhuaSJSS +UoIBT1XSj3k4UlRQCVSJmTQA+KqJ8XwtOGAMEyk51N8KXLQMiQkp+IyRSxmTGibDki6lTA1RLOiZ +GjI+gaym6/mjNmbRPutvpBxeSBnq1YDNCtVqqCksoQugm6VWy6xO9jDKoEKZERUDaQoDVF8wZqNG +yt8kt3oVCZmbYzLZG1EHaaRq61b3KPQTFKSDMM8UuoKgmIingiM4nhsIim78LfYxMin13yKv/Nx6 +j+6tV3aNJh8eVPyQQm2CfVmOqwX4p6UWY6AWW4qDqbGFWKjs/VI8jKWWYaLO7FJcfIhMkErXmpLe +GbrDgirCdxCaN1cn52lEpdRJLwgsYxhLC/lZHR8tiX8th4CJgbVw4cVpkHSJ/fXCdTJJUPsFNKA0 +yc60mvaCugKmutbwwxCjK6D1CBrfqKILuEZGV0BoDWY1GdKGm7GGdzv3gcwkXeVFIGw5cNkPDr7u +TGfEPP3V+FNbtvpF/y234qxaj+6rFfGInJBBrQ/sw+nyKnDpAqu8vXiJU2MLF1mLLV7mtXiOrE2y +9e/N2/TZ8sh8+OX87rcaFKqJN787QBi0EDbKsV5IcEtJuEW4dZdc5nR+dm5bI4xQ5qRBalie6EIp +G1k4B41olK9tjXgRA/OJqpvKuvEdgOw72Y8EYaZJi1MjQVircGypVnlmGvTY7jFOCWZxr+iWqXm8 +14CG3T0hnn7LIH8oSqi5d4x3TRCrOnxwTK2mqtbYHmq8qu6ZMf+8vbj7ohnV0Azb0Ig8q3FcnLGT +HgLtmWUreuN7o1+kVtOzyhboV/eFH9Xgh20cT8aKOXAU/Gw2/g4Sey+FjK/78QonqO+78dfI+1D6 +DlKPaqhHbcDbVSH9+DtI7H2qM40utdqPP/UrQdyoBjdq43gyVoy/GHfuKgPF/hfoDNj5NMBiOgcF +ulNlaFKM57EYN6/BeaN5KMbD6CpO4yymU9F1sPtmPJ3FeMaPpyPndBAPB7ORIGkYxMwmmwyi5mAu +FDVD9okf1eEHreiRDUg2EQmSRpAq7cYY282mIXWt/6QZ1dEMWjmejDd6RiMIiPYSKEq8yE9XTNNY +elXRpMyIuMtDb6KgUKh5QpnwWJbRq42rg2A4uPVcnSwUJtxey8vJu5pwh4+BIj7EGyyKBtaMNmjA +Tk2WUl7WLmiyYVcOH5ljw/SwAu00iKay8aGOb4B/FrdOleANT/hkY6K+rh4XX6Od9JuIq0ZAl5U+ +DFXANhSmHBpiD5UUPXtbUxOPh1N6DOqTdf4Kvkgm6NjTeEqyl6ZhqZo3MiAGjxkYUXFDY6BpmZzV +RUG6ZAh61rvjg6z3Jwc6trqDZOPOJkQKZZN1cpDPY6qh62k+EAwsHruwk7fMoSb4RT74ChNl6dyL +pBU2Hk7II4N0H2CtKFUD16mZjoCSwai+6koda0rmaDCyjpsGkWWWFtAKdwe4VQ+okTCiWfWFGk2m +F4Mv6A0Q7SpM5NxCGhOUQIIi5mNXc3QHaDSlSypznI1V+DQXNKd3kLOc2Qdkx9EBoodAcqPSZTJH +x/Fsxj1WGvFXQ/vgNJ2d7HmNKSII9z14FWpw2CO7TAbyyA/R1uq1lYAQaJhps6vLdIFwqcEEoeOW +Z+Lg/isvvB+uc+pr6iBZgx2s61dXU+r7eHxnKS7jvktdjm5uLnmri/vr6d3d+e31769Pf7w8/+PH +i7fnH/RSF9tf/dJ99O/3N7d3f//1fbz3RfBJ1tZDM1YqW+2dasJ/97fz08s/n97dXvxbvhtU0n5/ +eXF2/v3Z6eXF9U9/vL14+/+e/xqrm7b4N2FGP9zdnqL7fbuLudiPl5fnd6tidXR69su/Tm/faj7E +hbfIGMbbVzHhskVUKZ/pxb5KoPjkU+ggzqiYrLZadQWL4eeF8fEXmKv4k7sn+2hYQ1dOQ7BWbGXQ +k8GXqfPH/TjmX16ygv9CiUxFMllCNXHD1TR1rpyVcCigaJceoN2tRKwLNaSi9rNfWaKTtaImOGZJ +w4BXmqmTWaW6SUpTtErvUhl9ZV03OV1iYn1ZZGUK/ZiL2y9t316RdyQua7eoq3R9gbqgEJP0V8xw +zN/8r3+KrflVbIyiYRW/iB9ErnylEkB8kb7UoiDzscNd/V0jsRfHB113NozrYlVX8VfXhIJtZ+HG +z8uUI3UVh5x3Jtpr2d/L7nc/7PSuiHXGn/i0e98Vid+edf27HInUte+CMf4jxmN0ou7qJ2YlUc8R +XTDGjOAp3pthGMmiPiF6gxeA0fStgJQ5gbdu+ZgLmw+pfPrRF2Ez8fE4dSI+690vpv9gVF3fFAMc +UydODsZdTNUUyrqmcaaDE4ksPK3MPKd5XSP+IgcLX9l09zRYPJsSyPNDG+Pj27Yr2z0ndTqDZUy6 +5ESf0rd9IbNKLRRszyiQsm68v5CND5qOY9fpfkBTJlyESPPMDt6WJESVq9bcnRrvgyqjqxgz73lm +e1jFN9RkVYbrFizTqXmq0or+A1fFXJgPFa2cXm15dLZxq0eLW8WdUjXSFPeat/UU4OFs4bKBQBO+ +VUeuft8k/8i0czSZ8ty9kxTEcfdkj3P3T9edbgfxktGZe4jWtn4XZY+P7SO9Wa/saU0VJyoSTNMR +zAe3WJq+uMnUS3XWNku+Nm3X9yVbLZJWk5KfP7zd0nhO7h+24JQZQ2n59z2BXU9c7WoIiEQE/IAP +9A3WqwgcvRwOo0dPwyQqED8NjTNl9wt25uE7Fm7arnBeNxSMiYZmPcl7FDv+oAsLLB68/A3EBv6N +yFx4L62xvPqYaV0pnua7FtbtRnMjZiSGMZmHzCm7rgQcWGzb5pRlZhtHc9sAq4cEgRkd+dSbJf/R +8fofh9x6YeI1muZQ+3B10PCmaPozV02osdETyNBJOl1jNSh37wlhHRetDiXyHMYjQiRa6O4fOiLA +eFQx9zB9DvtXwdSV+uAKua7UY320gh7anPaxwi5eOjs8Jha2fLRByzCbVgjEzY4K8PJCHCB1lyLh +i7za4EdZNuTh69DYily99LsCxPQpI4W/r8HMM3BX1874Sj6/6kBQAPqmireX8CZow6UdlUgMthyD ++gIaMqh9rg70DuiuoL6HItFQUzEpsRb0kFj9G17dKgOuf7v63fci+l7/tPrN0dE3Z2cfr/52c0cZ +NsPqydGpJ8Kanmtgd9f3/pu+92vKJSK8pqe/y59Xv/vLzd3fzs9ubt8K5v8nO6KWw4r3jED36IOB +94udyPXH3/zpj3Gv/P3dze2VvoqjlM399ubH8zff/Kl9I534/u7Xy/M3fdP61cJZyw6P8JCh6/Pp +OJ5cKfHtzb82uKDhy1RHOGbAdcFXLVV2tio9r/Yx8Eaqw5Qoe2bgtKuUApcPhRqam5o8c1CPib1u +Yq+b2DrdRFNHFjkmiRhIX5+dabZk5HK+uKLSL/0a8syVOgtGnpllPz/LDO7EGTgSJabZNzjzHmKa +XYNkiuYejhZhgCaMeS5sjfuKVEGdPYZs86xWjma3AgGcRoDPxzivYZdr9TqJuZVpRIoJKxPsJIcZ +GDXjFcAabLEO1JVkAzGONIK6WApcw13W6QrfYT8e478bmSIhwCtlvw1zJj7AftNzztHnwSoJ77nY +ENA25xshttWI+YbfO06Ih4s2jvdvn23c5tHiNnFMOfv5mW6X0hoh8Q1s21cZSJZalycDlRHkuyvG +OhDEKr1QpgPly1+6Jl1WL+KUyz+DkTfeGtbD0OgDsGoKi0M4mY4qnW59r3m7caV3CNuufKMf5/3p +2oFv4hCUj66JF9/LR8YOvspmagrqmlwDeljaiGhSfoq0Mena1QDY9YRxuJNZGkC7sWnQnB0D18wV +wzbHs7WmU58myhSgEaZqfdAwWOkdRMi6fhJpZtGqZOd880qkmT/c3O4trHsL616K2Usxewvr3sK6 +t7DuLax7C+vewrq3sO6mhXViT706mBpPizUm1jWG2Ge1sRq9meNeGyu4XvtYWYdIsbJaZGKdNHy0 +vOGnsrAWa0ysuT21WGNvvdfGWqwzsk5Nk7npclpkPezpzazrOs+MUJmZdc1g1hX8PNqJKuD+SrO3 +tT6pduLk/N3d3ta6t7XutRR7LcXe1rq3tT6hrRWX+zCL0dVBqVcAasZBkUcMTUcJlqytJ2TFYoTv +GJSMrVnBNaC++qz9z21cNQi8Qyhsa5VA98bKFm0GtXMyudDQtooANtzY/WDRhualkXF1SZtHi9vE +seS9MM2fmd0ueacjNEo0eTpLXEiwZDo7yWDJlAlYNYHhnsPGrQUlg2dWMAeV94KSsS0Dpc4qFjEI +txz0sv8g3TyY+kp7XtmSTMYtVuZ9Su8zUN8B5KZt3DrIYK6qNfM3bn897EGx4nNIFQ== + + + 085RqpiOogf2g82KrwX241ALaze7ebv5R+umalNRpUi0AGnNasH6ADvUE4goG0oor8Z++reLn37e +iyh7EWUvouxFlL2IshdRnlJE0ctDkxwRQ2RslUsbHSiTSVLBdaBeAqG/p1MBJL3O5ZNh488opAQd +0H1CCtLrVO6Roo3VNCazpZRJo2MP0McbfSophe6Vce2ikEITj7dp7fg6lwoU0nOpCdLLF/TdG0Gw +5JVfB8oEmlRwCCrvA/Wc7WQYnZ0i1ZgLJxGUFzeHKQfLBDYYaTUZOyE9581SzqfZGza+FvTkgslk +wCmqbDzkDJoLIdNh97Bc5MiHnrU6FF0mc3+vUPLFSwP/eL8XBfaiwF4U2IsCe1FgLwo8nSiQ2HBy ++7VPgWEEIWOx7eO24IvXgzSqw+vF2b60YRWjwEz+WRIU1kBigyfTPjxlUBhv7xnw2DIw5c6RWH1N +TFh4pGSDxJ/NAzFhjzU5DQl7pEkcT3aQsv7ziANdoI6myegEggaHiAB0ARP31kMSd74OUo0hjPyL +y67iwDpQVy4DpcqLxItmoBSAloGmo+nkgsGrFAyWIpKytvuGpqAulqmbjymkK8a682qmPbgH+KCA +IJjnjbA9nyQgjAd5NQBmIVvTgWawbmgxtGsAWTuyGC02nPI1/fkUL6tC81ngPlYmdjXSVzpsN09h +wVi0HK9JZrm7k4EIiVp9d3t6/dP5RiFgsP7iVg/4SMeDqBF2CJnwE6gI1WGw3q6QRNfjQqwEKJEu +NT0U3etUQdHVkFrpIMcHBDUZ6OSA5WwPmdSctzvuVCycyqbq+wYnQ733vDOhVm4HGrO643bKqnrw +wCuE06gNrhs1TSVHBg8FvsMtSWVo9NIh4UjMYTBlNeJ7kDZfLw98uDQ8npE+fRRLsbDto03aBmMk +//nxEWib0geeaq0tcXiaxnuf1GoOP0B9vF5cIEKZ3uWHQ5F5iDpUcIkbktW0vG8lgWS5XcQFz6t3 +E6CUpU2/07tUOhXukCE+58jgOn6IpaoeVIyrLfI2i0mPugq6Tmd437U8GWyXQinbEIknzPdN1s3A +SxATrEAoInsSBGWZDiBBtKPxAW95z1Sqoasg2xmjXvbtjguNa82bnHRo0ufJYI+n479PvOxdikfd +5hE6Gdxk+HlPpUD/eJI/9pM5nfDJshzn3ckG8NWbNaMS4LjGSaPDPg67OB7QeMTjtTvOupH3YjJ/ +9wJzMbhy62X8dPLUNa+OQtb4EvnKZS97pFRQw0R8m16eTD6/lyi3NkqgwbV+1YUteKl6TWwbs7o3 +puK1NAYXITU5T1+24dAh0EeYetxONZBBZV2Qb0KjoR4sGyq9ulvI4eIGjzZpsIyXQo7o7yeqx4RN +463mLibJlyVzhzG26CS9TS9PJp8nAlbXCq8OmSX/KgHis5CQKqt1+PEawNPHJEw6LPsk62L3Qdel +SZEvIBSh8uv3++e68Ei5WPuJXKywE87gsp3EwFYu4AnknG/CIW61cz1Aedf4UHSvU9kChVO1eJAD +KntSZjV9OKkmb2Tcg6x3WbePB4N4lDUVGsibxiNr6oQBqx+OusMtH7ir2TTCr9Q2DDm8GpbUWiOw +cNvmMMbXNwLkHVsPFw4gT5NYvGUtH23SshC7w6b53Gxpt94VjTtg75rg4jPajmuu1/omQGSArK65 +vktFWbJb50rNLoPnyId2Hxfjqoq8nWLSi2LYy2I4iOPRoDres0dttWMNAZHr1As2avaqie22h8bw +4vIE0W7FB7zlpaWpuJbuMX3Qp9jW4NtxTXkzk04MOzkcw/HBeEyPcZd5rzrWsh9E3jPeFZt3DYxk +93iSP/YzNprScXezLqQey/k0hQxqmbQy7NSwT+MRDMY3WqO+6a7lYgZkwDlW2Y2R2R6894f+yzDK +bti427thplqAmLQoggRxwmHr2gwk/Blv10JMJXVnodaLihhK69u4U3GHDm7cJN/bbS9YUxAS220x +9svzzvjBtqtUwIn3gOvl9X3v9Pn4YLATAcp2egIVk3qLda0Xkz4Wk2EU06EWnA7c7Zmmo8CM+TKb +1+lMI3HGuish1yxJxJHhoghwg2WhlLPBwmi5hUszGE1aHN3vmyyPCpEbLBAKbrZEo41WRw6tHctm +7aFeRWU1oF1YdJzYwXSQqtEMxDV0TFJ1egYjk34XfCnzkQoXWrpZpfo7wNlBI5TAmwwkLG6Le7i7 +WhKAvFL8nZpPpVP3xgM4ngxpfgooGDNb9L5E6LcOUtYitHYNJwW1GW511FRQ8aEIpvSHyCUgnF2p +9433rgufRTLrJtRoFpQrTCjNVx1I5szHCXUNnH4SgEdk/J3epdKpcDd98fkYGIHr7jqICCdOMUJr +SM+oPf3umk6Fi3H9Rd9AFBYzVIkjq3FlO7PYRZAgXKpe74lLALbdpH7pu1Q6Fc4QIzYsYw9w9kuQ +YNPcaA3pmfNmu0nVl6lwMa6/6BuYgO7nMQb+EH3DV9nTuGWt1I4GpnfTDwdvV+PJ6ScOX0/mdTLz +k5Gg2GQKJpPUD2R8i27VdGd/dJ8QSVpvUBQ+tMTxQNT2Abc9dsT0pPsMX9k2h3QFP0+iC1itKCHE +u4Vd2SnBVQkjpMg0tSpwGggNI5WRnBHUZD1cGDyXNU1UGS1s8WiTFkvmCPnsqS1o29NlwK3iZMkq +vf85ao34Or09mRbI9EZNfNG6urKqOWq0tEJOgBt93eMCa0HPoj/qG23KyALFjuZI3H/K7pV+AOuK +fwHapC6xRft51Uh/OP3nze3FXdQe/UeSMT7nvdm4zBzXNhcOflUVzA3CF9a8TTSBIPfUoJsAwKCG +7GUtlB8OrGDVqlNmqKFqsq1e8Yk7SY1XZ842OF6prdmsrD4fHyRIixw26tiBDEfwspRNhdtApay8 +4OXRtNAp+uG21dQ3dTu1YH27j1hL03S18JrZ1IheM9v14kTvqDW8Djz2tOBgCImD4b28aDYbMUXT +mpeOxmkpOHOu6meu4PTiMMn626S7eLuvpF3h1eBgydt1q2ycyPBTQ0WA+6Lj9Z7pK1SE1DH9Qo0X +87jzuYwvZGRplZGwx9seFGBLCRVb5J52bBd+dQaJ945J2o1OiEwbPnA2pA/oOBoOg6BmSHXoLSu8 +mtSNJyRBjtU/MJRt/lVNNygCeD2sAPRmYyettprMUE5zY9QfuQw1vSCRvBQQTB/nUw/7Omj+QzzS +olxX6k56aGAVltn2VkalMlEjk7rCEVaZHOHAHrO7/MTHT3AluNckR6wFbDPutFW01pb0atyI+nWg +IpRdNV1X6QEKzV8/Go7Ym3zInBXfzwrmrWmyeZss8/F05e93b31ij5EKc8B7XuWvW3lcBczrXq23 +KoJs13Wv/+P8km7zJLvfPgHpxc62jV6TVNNXykDiCC39OAPy8R7qJcugWCX/DzVJBizGJYpxpbgx +uFK0AcLixusE6J5Tmb5IqjbVmtpkP9iNDDL6eFLbqLlxd6Y9fgc37hL7Pf290ryqyPUHIi8bU9gu +ipxEHe10BirGnxfjGuV7OpfI9wGnG8lGBBQdhF+TxvXFUtVFV3dquGBnCvYGMMuFaVaTEqm2rNpJ +2+PeTQfAfYygh9ophfTO1fG2q5KTIFsNHks+5dMPQguov+G5kUF4P3TMxJhguN49IIM06pFjlLSz +pe8jVUd1rdNhD0vv1PNDxC/LH2r2lxWuG6OvhBkPvDzewcpxzCvtHQkeVEjCOas/pArccBjg/Dio +JGpmjYNPN3x6Uh45pKxwdIEvLHJYWzVR60KY7itydGD2LQ4320PODgzPJtODRM5rNUkpQvAaWIex +hnqO6XAdvBVdQwh5C5m2khEfbVzwDhBwPMjEnB10IFmZqq4RuxbHKTSRWjwD5snSYQBChNMbwpuy +bXF1vQimdeCt6TgnA28IL6UeTocpTcUL2XF3t2w/XhEeGHoCFZC3hhePO+/ZDnznG20H7vSHcLjk +JIr8UqEQzhaeOyDMuAddPq36J9nrFcZyfJCBQvCN+uXK3DRDQKCkfqjqQdkInFhZfBqkpV+1RXhf +iGjo44LjKnMsl0wQeSXDjKb0i8Pt7EBhF0X4Xto89I2tqQVqWr3gXE5uAGQC4XaMaWiDRzvAUVdy +lHUDZweiaE0UxYS6HhDipLOQgtBCLYwXXE4rTcXqWjnpJ5sRmxR8QSCnhJ7W1qhbPFgD24HATTVV +yySBDjbQHoCFKYMuUQTJLACdukpkX3plVlJLESJ0RdASLuAJ4hFOC6KtdXSPXSsdJHakqyD1dDKc +M+rSn+WOeNqXt5BVuLk6j6yCeRJWwfmo3RcUMCFArSSnpTDdmkG5lb3AKJgIcqWavE6AsveCwNGW +tU3O4pTq1WfSkT1mo4qatgxkmGE6WPGLVgHVYWUD957I/G2Tw1gTg3MAaNcAtBQAUi/iX/qaJwM+ +SZnOSy1ra1Z2JQegGhoi4KQDNH03A1hO+JRNQV2xgjWHsAYCL3LmL9KrWnSiwLA3tKmkLmWfjXr5 +sNrm820SOV5rYfErOZJxcHjscc2X3Jq63cKN893tj6tidXT5kdvHJC2qmbstKCuR8yQ9vuogzh4q +qQx6cQ8dnkmQiwxU8POq/7wDpBpxmiaQoKQe/bECiwgjg9ih9OvsYPyu62EsPO7x2QzDjnO/jR8g +EMJ4uIvgXwSnkllxOHArt5LzG0E90JdA98u2rNJL8Khe6BEv+qA0its+GumtE1msN+9soqab2afP +r6+LWkwDMXY4jfaxaZzqyWXwQ6dP4uIAD4VMtdYFxvcId4ekbwkkwtghOR2ka26BJQkgTFtL1hWo +1MGE8hkNmGU1EMlwVqQfRCRTUpVDAEvWfcn+uas9gVIPUg2pi33/j7OxzLIsQr+pYTfe0/wrbLPT +S2aEy27WxA8I/Tbyj+JeeuAlM0Ka4OVrghwCwjRNo6KDbRwth74EyyrNVgFbpvekoFXRgMLJmSq7 +rG71LOX9CZAVG1gtXXyWeakCp0rqhpqpB8S5Oz5IILJBVbNKNUAIa9Lc8dcxL85o6yZ0oIKlq750 +B8hayGCxG1092s3U/aSyw3MdUc3yPomcYAEPZAqrHJK1FWFQEOnFAbEOB16Z40m/jpVkVf27RKJS +4fScT1cHir1IdRQaWOJq1RZSUbhZNPWk1asMmLo27no/LA22Ho16Oi+TyWO56STna6DjYuR1NurJ +lEwGMDYeNv2lCpBn6p7SQJizNGg7Gizhbt7DhO2GZpbeugxq6bTO8LKG1JEAetgJ2c++sfCBtlkt +CZCaOjvoQBA8G59iq1ENQrcNBc/UVgehfKId6r/qOt1XNRnbnCPQ+IeIN8SxSGr0Z8HbDVpna/Uu +11taOkKD6Q7ZdBtIl4zsEum29Oma7wjzKmyBbTbWRf8UjTw/TIZKAlRvRjY4+6gRqTRUWT0dIDZ2 +dpDBups+uorapNJIrUWAaqJil7qPul53FY3H9unTLeeMUP9KJzw9aCLUWoTgYKGxLg== + + + 9XrKOOMaUgszv7A9FeMnOlCLMKxGrcUpRZCqzqBlcqHqADpTEKeyb2IcfF9LBKSWzg46kEjpVfTZ +1VqQ3LZ0WUsJoJPL3vTfxP72tYzG9OkzC3UIAj80l0h8QC4RqDsQ51ZCzVPluNzClajUi3k0yLqD +YNNaYS4aEiTFOGrafIyf7wDQhbnoPhZBsk/bYFQJGuvJQLExaqk6mKf2Y9VVJcJP1brQN5cA0I7G +LiVQP4xYy3hcnz65lciYuNqOk5sewJKAieClTMKUo6mcUGT8n+zoRuPgSnpHXfWQNsaMCKmnwrVg +yFwAgqnCqQNgpjEZrgcZiNeQs1MtHSA2xNXpIFAYrrpKkC6BVyOlhhIAmp/YmQTKB8BaxiP6DJQY +/n0+0eL4UGiiM4j6vPjKuVziKAThvAWpwxlTa/h8B0OMJv0KodRuS6qLjfLQgT5frocINrZCdakJ +674yUFeBF+xq6iCpPWz2BBMS5mzgYsSaoPolpenaS5Czg75X3Vddz7uaJuP7HBQYZ2idKLA+gAI7 +9YPjrTEezP+9h54TAbU2VLCYsqVQk0DQ41u1Y9ZVSx0lTw6YHxGim56xjVWHnyDqwun7KjpA18zZ +QQ8zuOXIrVItqm9RfwM21AHODlJfOlDX/1jJZDyfAZllDk085uJvpFIJcqA6HHPGwsM8J8YUGkdE +AxnL/IrqAE9DlpyYoa2pV6Ym3cKm0MagYJw0QoaU/cS0QlI4xp2d9MPsDOq2Sf7xcGwSSiqAJpEI +RpCfwSVDOQ6YgBtmWNPEOG00fFjok7FGUlD3gSxFDV7VMOWIV6c4WGJwzxBvvRVh3oW6gWaLQYI0 +SHpmXOFlU2QFDp0q8aO3Fs2HDT+g4viYh79r1ViYtjVDzwgPsJAM5+3s3tChSt3hypbuXphF5vIo +WxjjZNac0wDLOv0BkG6YMEbA9bO2SPnTxOAiZt2pY/qdJkQyHKzuAwa9yoFXQZjTfebaSiOLvKCG +zCSsK/JLRMNqTdmmDrj6z8HRu/GHZd1q+kdMRPK+8GXbzmsWrnNYq1CpVUIkdLu2ZA0Ecl6D3dug +lGFej6kmov+yEBjh+oNvH0sh9Jhf16JleZrrlZtG1sDP9JNLGqZ1aqUHEfBhPRPNWD2tEKrnYDYr +4MbYYmvSS6f1QQ39GsBMnXlFRX2JzVXD64TKDiG6ONWPpaJa45MAwilQJ7ccB8sjnls1A+IZHjNn +IEtGXZdEgoJdlZdvK69MyxAM2jWZQNwkQQKLk4epBeSII4tcwREcGz9Ejyr0luRDKEFkGFOyTosd +X0f2BEMk+QjKwtQoDQCSOhwfkDqAK7TRKSYxRNC4SJHpzG1GLxCCWLdEybat+ZdyQgm7phDQpsZF +EFA8GTmwKpQKkWzAnkYGrCaFpv2wppcX8nLY1kZWszVkNT2+kl0GuiGydgVBjiaZIN/IPvNrypsG +PjNtA4WGAaGEXHek3EujxhuZZhhL5rUNClAhWxJNmiAQSI+ypqjseh6+lKVb75V4zO12lMVr1fnR +i/TTyMdGq/Q03qLA4Ma+PBVpcm2GbKfGRuN0q9rqSpMs4WB2jYpdPM7p+WjoKKcJVOAGQjpDb7nD +0Bo6JTDhEr/SRI+OuRn0gkneaVc48r9US1hoM2gnbFSUNLW6MMIFM0DnBMdvij5CfkJo1LQuyEnP +Uvrao4PgnmFI5yWv2F7C9ySZ+wwsUXDCcYPfoeyFzIHKutCXAM/oPVh74MIxzI5y2mpKQeoQrJYE +u9lU6kAwmLmNiUgFqxvQ0jU82Ixx6h4oW0cGXkJrjrFKY4cUCVRA9YdRtwajJ90VSheCZtkwqggQ +qSJQx2KQWqGmu74c6RbGZeoEvYMTa7umtJV5K9Vtxzg5akUqb+g/D+OXq5PUWrbzGj6iu1oJv3n5 +vvJ6M8m4HMIafIugitJDDmKxef0VVruEiZVMS8tQtU+mG4sX5kmuJhFZqTTlS1ONYQ53NYxTVQZP +Fubqq0OrDGkTHOWUWvYgRTCqcrGfbKvaM+qSdYuZSh3E1KUKHCsrrlTKAcB7LdRC5KZsZ+mvwyxO +gTcHqVEN/nL0+qJBu9ZP6DSoutao9Aya5bAgSxGUh1VtiLRGJzFIhbwA64xkjR4FgnDQPxt+ZeiB +6OnZq+XUkuNjALqSQ4oo9DxTtUlnXmn0Ds/pPG4qtwRHllhvA49/I1Tw1DMAE7wa8sDzxCcTUoEp +cKq0EEwmoTaeDvUy7UbVtB5kWFZLtnIr7ESrWWKEGNTMvCNzFSCI6p1io9K4CeiQHnwhlPjlNFcl +mFHXMPbKyoDWFV3X8JGeTdbVjXprGWfXFpWdmfLMoG/Ku8zrst6C21agQZwWYz5ZfFm6Ok/DfLga +3oQvS0bgJaYeiVZdeOiYVJGxwJEvO1hDTxEroec7dz283CHGqPmR5EVOY96SG4RyVHxW61bUt0Au +hpuT0IsaClvqo7xXPRV1IhqZ4ejL1+pOdfoGfpu+pIsomBMTDViMdXbwlix1y0aNc3MYHf4Ai0Sw +URwCpK2MfuU0RqREmAm9f5U2HdMpVlVccraWtYwCqiJ4/oOK1JWnMmY4cRszG54+j4cai34Iu4wQ +I2QCt7Xw26pIk0mQdp0PvZKjRXItIRgW3l7wKoCzGqh05VRjAD7K+ij044D8gcZoj3MaophvYxTu +pHDtwPFBV1rVMF00vk46jhZUyUHWxz0Vc1o9UlORrQzFPVsas66gEAAIvaqWo4LtaG53hUIIlkKJ +SBNA2Zbh0zmNZavyFAQC3sxl416YzwB9Z0KAwmQXxMDrtoke6lUVtZZVE2O3KvXVFemxVWcKC9cp ++oxX6hwLGI5+jww3Vj+iBhpuzPxaP6nbqHJocV5jMzKloWmiLytMWy2pAWLzqZOWT6MDNsNtguaM +Ux6m1BvrQCDo4C6HDamahYN8G33RRcqG2ywIRkvDN1IjMAezOiFbqmkcATAwHsNsUZLLoLtgGY29 +8PgGJSPVGU/ixnwFcwWW6uOJPy2V9C0okQ+1RxI3cPkhxrZFq45tSrDoddzMMde615xNGlwQRO4+ +pBYmCO8mVVqVTaAnho6gdQJ1ZX1PaUcTEZwVm6ppDhlydURjQQ37ouo2yL3Pa/sId2S6pilDVG54 +d19RsKotPQUEZeS9yigz+43iUpDajcjHfjJ3sXCNnoB4MI2EcFYvLaMMNBtt5OEhf2CLQ4GN01X2 +CT2KnY/7WLBEeAI16OEEt3RQYoiIxg1yI+JaDooP8gzlKAJr1KYqjACiJnChiKoByOBD7SDtaBSJ +j9ESkBPxt4XWyzGYiQc/rS+uAv/SML063L9qxmy2BuRAzkAaNgztH6A3LsZDCQGsQUFcqYnGy0Nq +NOmwZ+lGrvEyjJ+leleoGYgWjSlQgEEdK/RuPF8bcxhtVTK8sWK+S2mz0RAbA3bNCjsjfD0iBtpg +o1Ja9RmwCpYMNfAiRa1w36f16vjmSP7JmzMEk7nOXF0r0UDEIlSaK3j+CfGVI39aWDgC2OIgZVmh +/bowR5xHDzMITGVejt95zWLPe3AciDkxTaBWeVqwhoiYEhBAvXQ0t7uUfwLmScqCwPnm07mM5Svz +JAqNFqH5cxPHPxGx6NzH8/tLWrrmxFAHOnZ1IHhY0ZbdxjgxOdiYTyP9VMV6Gz0oCCpY2nel++fU +gMoMEdYk9UCsBgEQMHyV/U+GL2moW4T0fY7FJ4O4dx83asyOyRNFqmLWixAnRKQjmVM51KIIJgy1 +RSCgnWRVpIAFG5OXA5Ee5Nm9ERUSH2Lr4KRlj7uMIYbGR+vgyOIfKN0IbfJN0Ij6YVrFhU0fLW2a +pSmdqe0kbr9/DPVhU9fUKSJlwBmoBG/UDZBJrwlagk68EnoxQm2coWMWfj2R53+Wf8M9Tf4NDU/p +M7iWTxSgguwYowAVBX1CgAoO/vsCVLJ3+wCVnQ1Q2cempKx3zxab8omJ7/YhKvsQlV0KUantgyEq +cPUZRagA9EiAinnGABUzJ0CFbk2D+JR8YJ8pPKWMN4Smhy5ExcwPUbFZ1MhVDstDVMwkRKVajUNU +bPmZQlS0okGISrWahKiYSYiKHVQ0HttnClGxccrTQxei8qkxKs04RqWZxKgw7HoQoyIC7DBGxTaT +GBUBDWJUUMswRqWZxqg0LxCjYqNbdHroYlSqzxmkol7RgxiVzxahMoxPYUu7H56iYmUenkJIHp7C +dDDbEp7CzuThKWkAXXhKPqLPFJ4SM4gU6aELT6meJTyFYx6Gp7ST8JR2TXhKOw5P0dnb1vCU1iTq +qw8pPKU2nzE8BfnWtyU8hbnfX0V4ClHm4fCUZkZ4ip0RnhK5hi48xYzCU+r2MwWoIGnUpwao1EEP ++i2NUGk0ZoOXdjwYoVJ18R52TdkUodI8HKES5jX7UITKoOSDESoP93gfofLSESqNMmq7EaEiZZYH +qDTu0QAV8Cr7AJV9gMo+QGWzABWZmmGACrSceYBK2dbTAJVywwAVeFcNAlTM8gCVdhSg0k4CVNrw +cIBKOQlQsVseoNJ0ASohxmzwclB46utmWhyjMiifolTC2iiVkGTV2sxtPMWpmBSnoveyTosyVCXM +D1UZFWewSpNiVT6DB+k+VuX+WBXsjs8Sq+LjlYJdrErU6fWxKm6TWBXyDaNYFVtOYlWaSayKWxOr +0k5iVcKsWBXzeKzKYB5fIFbFRoWH0XS960NGbEghIyGPVWGZGPhxf6gK7HkaqmLzUJUqhqqUzcx2 ++1CVOoaq2PXhNQhVwV0oa0JVHulxjFSp95EqzxipUpphrIp5NFbFj2JV/ChWpZrEqthRrEr9eKwK +L055mlCV5vFIlcRxbUukitFAFZ8CVfwkZMS0KWTEtINAlS7wY1o0hqkIYxXDVCKFYJiKkH8NU1lT +cF2bfZiKi2Eqfl1BhqmUIYWpNM0gTOWBzo6DVHBQ7YNUPmeQStM+YZAK1JfDIBX6KT4apGImQSrV +nCCVNrxQkMpgErchSMV04RrOzA5S8c360guDVB5t+/4glUnRWUEq9/V7H6TyrEEqUCSOglTgbDIM +UjGPB6mUoyCVql0epILrRp46SMUvDlLxgyCVfL5eIEhF5MImBqnEaJEqBW6ER2NUZF1j1EdppoVT +jIpsvRijUpsuRqVsY4yKn9dqF6JiYojKumIMUAlr41Me7mqKT2n28SnbFp+ifjz3xadkbz8lPqV5 +KD4le7mPT9nl+JT7UCnFpyxEpvvjU+5DpxifshCh9vEpa+NT/vb994OwlM976ZDekYpAAjiz06Ws +B/nDhBrOe8bBtlxVKO/h4Z8AZ7xmE/f69Z80wzq659iMWmgI4tWCTJuhdaD5QTMJEO8sRFe6b1Jf +u0rG48H2Wo9VP/z55B9/+lYw6jdnF7dnssD2zW9XX/MCnBKrLi+zhQ4xCwGlJ6MGLfjIaKoAgk4A +EsIRyOkIx9Oo1crBZESbJV1X2lqvfWzhgxQ9PDFMXCBYRg1OVcJEJNwUHfPRQGl4CA== + + + 1XVQs1gEFQjhQdaAE/rNGHpM0xem4rWCuGFV4JULeBwO4XgyKHjJc1lqlw2U+uwm/wp+q+BW4BsR +ShUlPa+OxpvQqD4qQnBHXmhipxWW0OTkwKbbeBvcHshWG1PRV7vVjJGj7hxPOnjyHFeTYXHcyhtc +4mv4l35CAFfq0rZdly59f356e/az3imtkUSfnXJAyY4waMgXSPl0RVCAApxKVyo6YGSFE5aJdg/o +27xlvDr3NtAfajH5WeHKMjmWL7kjRO6hi3PrS/XGoO+PCFNVXSkArlkruA7gDgU6/psGjfNbWZRL +SGXe+YoUpKkNpSUZeElNCtvk1WO49hJu8U2kS1avZaAYJGfXJWMRKAHhgjUIZrjZt4zPzKgI+wwo +ZHvIjXc2nZ1LYukk+qS9Pw7lY/wPS0dpfMbiIWpksiwKXLwwOPcnSwPgBosjxabLI8BNFkiKTZcI +wMWLtGa2UBMOjH9w4rkiX73p12TpWkDFZqnpDbBrcy3gzQgNgEOZEqFJ+BL6tpKmAm9Do0B4T4Ij +hXjdhPjhqMp7ge9IXlLH/5FfShOisPIkl823kLENEaqGDYyWW/W0TyDjVSMKgAUWQlnS8hiAxqPB +zaM2HFpyqDBzOkwCL441POEpwuKWdihqqRSsjJ4MzNKFMwg6XNxyC4Mw3IHg8omuUeHikgsovMqq +uu4gHklMLZdB+PvAizFrXtjpRRxUDanTLHXpslpek2uYGNO0LmgElKeDCm8RbxgKJ6PhHgFWtiVi +xEQ4UIWxTAryXo7nLQXgJTg5Kfnu6gARfFTOJpBgT+V9zJwvIhe3TaNKa9xnGvQuV8wOc44K761x +OjXvC9XrHzWnIezMmpcec6XlnN69CtfdlpGRspt8je2tF/3CWwcOHCI2OWhBjg/gs6MBHw4ucuBA +qHpuokN6Woj0zGvP+StBYF2DPl69yQ1Dl0u9DNfSJ+cYZjf1L2wQ5VMzQUy8Bseo0lr2T3RZrg6r +umQhS189qtY0RlVdEKGx8shFy/sw9f51Ekjerh7vOgGocXq9ZmmCsqyO5kVBQu9svyTjVTuerOPD +90XCOVSWxNh2pkbjue95b1phznyDM6DBPe8tkAUOCLgsdwv5obvT21WxEpHv199Ghije4TqTrJVA +DdnWKiHBSYqHJ++SPjmIez6oE2hJEEyMtuItvyICVJFFL+kvBpz1hpS6pAxctzUe1rxfU820sUmH ++u7OCbBGfLVsa1Pj1Iay1MOdDhqcumqh/RprvSyuJVan4SL+hl4SkcjCmdOOWdaD8LAYXC37k7YE +By0lVMqudIhogZJECCsUiFW8/LkSRqABoRShUET4GFsN4Qj67qsD+PW3Gg7qqNE+EVBT0Uewv526 +iTwIQKVOn+V1WTTa1S2s8JxRh9uj4JthWY4BSjAbw8jB62Th9WcYZgenHq9kQHXt8AENvDnW19R0 +Yz0ginEhEGXaVHoF7+R9MamkmDZUTHtTTLtcrBlYsWb8xZppKtbMZjbbJ300OPwiEJlwhbq9YURM +Q/8ZtqeJeOXsrFmtwTAcw5hPuG9SGlDLS4lLOk9bJarjl4Oyw3rXtJx1bfQwO/JbQ74HY/zqzZqm +hEYOeiN0K++qPI6Hglr7kSpnPf6iGFVSjBtZN9+D7p4cDEO7fRMZPRA6OfUFOYSQIAi7jVkkZNtB +RVvTtSVhGsNm2sgsnECK0ngc3BoP6w7GYT39Fp2G/NHQ04Roj4SZ65hKbsaBUK9hHVfN0LmkQCL6 +wKj8miHuvnPaPzmAEx/IUEEv+1L3ELQINH2eQM6rNSa5/wABblTF9NUg2E5DPvvGqMfEFVVZnxi9 +hJADWRBGIp1MZ+rkAWU3hiyMFu8mLJoabl/qdAynwgndRGhyA2LuwaiB/fNIXFIzXjM0VdQSI/JU +sABsrjLIPyCaVhgWZj+G3xoiVtYVrYMqVIJtohHo6GzjVo/mtgqrUqN2rBp6raFa+z5eJJ305ers +5ur9zcfrt6sPP5++P19d3bzNj/mH1eJr8FoV3SPMVuAItymCboLdqnkf4TeIxQTDRXyc4PhXb9Zg +Obdyj+cUmSeYLtAprpM0TLA96u1H+K7TMML4NbN4cr8+fsHSZepx8zyc6RMzkH2eqI+fyj629/OP +7iH+kf68a/jHKvKPo/eP8o+u4x/bjRlIoybTFoIgmDrTWBPIQHrZS2vy81DN5FPyhvgQI+Fbg7RQ +rYMomufn+UzZeQYcpKWLy5CDtPQwGnCQNnJLyzlIR54NDlj3cpD+c3CQfhYHmfdmCQc5Gn+xZpqK +NbM5j4Ns24UcpHuIg3QLOMhhy0s5yIcYxmHN8xhG9yjD6DZhGMddeYBhrMsxw4iNtBHDiEiWp2IY +69Y8zDCqPb5tmlmM47C6ZYyjnTCO+Yx9ZsYRrrrKwrVLGUfsS7JwfhbfaHq+cYNGj2Y2+uJs4xC7 +F7ONy3F8Kds4RM172Ma12P4g+ziudjn7aNewj0PMf072cTkzd3H2yzn4ub+dv92EmYM9rVEPclih +kbxTIUX8m8DpuYw2QX7TvZx+lX6dHYzfjQtnFcef8DMPgNcIQ4MpAzjhjIbBCxKUZYC3pvB4ZV3y +y4BQpxMk9zHeMYNJ8Kpzq4RH6JqIP477kc9iCo0hmbOtRyANeJeyglWppGsDqMGEztXAqnS5dHoo +yA0S2ZBcW5OfTFSLdVUJhYEeU4bd+V05k/9wVmScluMLQcOkqF1MiRthFdXMjVVZhwTQ/xcJqo+l ++r3qvDNVAPK/lDCDaogeUyM4puVqDU0Ahr4RhkuEQCxMvKlxQDPdQVmRr0U8TmpC/2qyx6zt2K9R +N0saa4Z9LSbfFKnOPr+jjYic0kjqfzlAq2aa95qBQ+kl3zmYiUrK0XQwhuefgT3PwV+CtwTqnaF4 +dszKCEijOXQIMYzJt/ps9Llx3SOnmllia+aNAininBkPRKfTsWMKKgZoxx7no+BfhvPZlY75OI59 +EwWhs/G8eHjS1MT8wLSd0Zq8ZOKQ6Xbh1H31Zjp598IenFJ09+FJnWSXbDOOck83Z9FNRFEqG8Fz +GnnBGFhcUrY1Zo09xgdNFEuymR4K8lVCFp3yZnWjvNko3a13JU3+rUjbDX+YUDGTlrCiSiSFSQNa +lAiER1xKidAohCvtyeaebO7J5ucnm81AEMeWAE8k8kdo6UaUQNktV2DyoblBB6kP8xU/ToAzEZSN +Rg9HCNIDQmiAFw4CR5g1h0HJ4ZBZICEBauKzgs42oQXTzzwCqKNa9YIHHzU+yZFqEYD/00ElBwOQ +yDp+G6v3yMGQ3LaGiR0qTT7n4AHrkMmJVk/NCqw5mFyMl4wTgUrSOTKYq4cCFUBancw1ONKisrhn +ElFP8G5bw5o6L6IedWNIJ45gyAokwah8jGSDDP61eu1lsHX0TxERvEYCO14lhRTQ8BFaU9T6SlPX +iRyOvAV60c2GjR7NbFQWF7Z4SO+WIZ0LAhLW4GUPXISZEGwX4+ZXb5Zip1KeufipY1mKodFtbyGO +jna/GTBNgzVIZ60mndRTsVHnxgbUEF6Q0LdiTujZaHDElzVPIshGcqC3dIikxsrKb++bAQhfeSRK +ampmJGqR9ESqriMA2XAdcyq4mEsXmmSrN8IGzWzeHnapS5n0iWlWGLocNGUjc7PQwwogqrRPAIpR +2PjKUWvbqg8d3f6ULWP+6ppqZZOeIzvHS0VlAyNamnxFC/c0XumLSXclCHfD2GmejaXRDM1MSnZy +QCfYAN4jeLWUILqNZwTdA0/Ii8C1kLxIo7yI5sEFBGcQIJbR3eiPDcDDuqR73pg9Sb/uVRP6mn45 +UlnLhO91kKVhSFVbriNRwLCaZyo8d5gAxSEwjjdpIUZX1W5OU5cF5D1iEsgfmBNUhGbdlAGGwLVF +qxqXNCMJm5BL7pijs41bPZrbqkN2UCR8MoGXgQ1olBkmlV3DfKQto77LCzcNqMBk22CTTzYOgMu3 +jjAmm2yer96s2T4EjjeQAOdvIeVllmwilhhtI4GNNxL5r+FWAmi8mQgbbSfAZm6ofrXHlo3G3kdS +xwwdkxDTmbOONybwuYJ/q94WwGdYTwNZPKaMwYbgpJWMka8rpKaDCpjL/1SM/AjyIBUpZVdBQDTM +jAdXV2TUXKeDI2KUyGEg+xSZYZ0caAxtD/TI5uU9jYFYaZAntWk18yySyCDSh5e2A3fGxWpLy6AU +qxBAVDIH4yatHc1pLTDHJ/O3WCTkWUY2pmihsEWIwbs5lqLGk4oqgz3hlu2JYV3IBFKpfoQpRzxM +RLhys6GH/NPg/D0Y7iwxvLJQD0ADUmsOYtDPkraYicJEjiymHKUfXoxFqAx4OsQg0BhD5php1xgt +71oZpZ6UQqD+f/beOz+VJGkA3AtwB2QQIFz5KpCE8CAJWZC3OEkIK0z39Pyxv73AHmevsdfYa2ya +8r6AN61+zTffvEFVWZGZkZHhMiIjidgpjxJLzD5lefFiMgrqvzymPhLeCYEuowTMLSlG+xt7ZTGT +RZcUwgvfRUnpolcoZAV8SSqFz93VNO+ayPVU432tV0bEGoJlVnkIVG80AS1oS7+5PwPiWFjbgEKX +dRDQrcGJl13AsAoSXlRbVT1i8c1T8DJpVFRL/ApefI0b4L+Bjq5/BM+odV/FDHBjhs7hdcXaEVb1 +Q7bcTUm8m8gkCYN5/EkCRdmgRFGjrJDT5mkehxDBomvo7gfxDYdMWxqPD2lwYMSkkrAPv4XnyzDF +xOFbsB0ZYPFp0/U99pvz3i+F7qAF+qeyl+bw5mF0KKoQQAzd8svjK9BRnG5V/YzBlxbHOJgSz+Oq +KAQFgzGVJRef5H2GR2D19N8h0KiNCFp5IPaf96FB2tLAzydbPaat9ZwkvnsCXT1BoFxAO3qFWc2M +I9nwyCmipVYI3fFLIIMQi9cSq5dOc547pWBOFE0KnjQdIyXDZ0Za1jz1RM2BVxN6DrwuRNHgMz1N +g0d6mgGPjHStfuiasmEchYG2ISoWom6MQ/1YjRSulXssqSrRphJP0GKFt0TDSLwB3Otyd+LeZhR8 +okvsORJftI+ukdJMlzduZF7ef7qvYga4MW3fDLqiQD26qk/7l61PFlZqhy44eIcMBfMwobpstZHx +lZkEge70hffq6TYHSQh4HwoU8ubRlHoz4/xSdE2B/bcsh+sRqHbzAj3nvPdMJoHQgyqssqVVa8SJ +O1b/BIkLvDTiE+hXSeLiZjSwqPzKikFRz3BYWPwwAlIPkcPxerppxPTzNCAnv1piQxdlCo4rDi+n +gBUItLSG7n/lKMevIbOHRRu11Oax69xCXcP0fCBCnCPxFlG3qeXUbVKvbnOCQW/hBB13RwJGxd05 +waC3qB5Jeovqq5gBbszQuaS3kHpVi3Snbseg41AgUUA8vjqLhNmPdvpLDJiJDIuuW0A6Ac1pVxSq +HzS0BGlaqfKh+hp6DRnK8WuBwq5R7RVZXvvOLdI31NkJnuO1ereyYpzE+Hj8F9aRxQ== + + + upV+SU1ANwLBS9SRMsGgCFQSuVXzPo1+AQ3cqk+jg0DDVKOlSETEC/LfGiISVCwP3ZAjPYoZ4MYM +nedFc0E9Rkn9VU8EAWcFPE0NPhx4HQ0vhGVlEgOWe9KGxLDDmMCXUdOMCdPgVSyHh4a7jtsxsB4a +7fg1vChNPHlcou/cQn3DTHZYt8jDqaeWAEXdViZBrNZ6IUKkvurJUP3QNSFqBieRIlQvFyJGSd/X +kqOkrbolSF04GG/lcsRQSYM9LZjY04LBAhEMFoiEA5U9rX4k2tOc3vrgVKCVB1p72pbJ/3y5pMf0 +r7CntSwdG6hgXC7sacsvne1pp06t7WmrL5ewp0kTe1pLy5qnnqhZ5Dlaehbtaa8ULdrTpNGeJo32 +tJau1Q9dU7aGR+ntac/ULdnTpIk9TTrZ0wsqtiz88/VsNLyYdIez7vAjFsOPkbqrfuE7G8M3An5z +0Z+Df8+bX53WzIcvmPTnJvPpp/+0MWx8dCZANW53JmH7d378Mt/o97tgp44/uy2xZX006ieAij2e +xf3nfzTAb2NToAYAEOr2rG17k6YIRKnfmDm2p1H7K5jeoW2LQJh8wFt9YGyLJ0Kyxi/Agp4PLxqz +Tw3o/Gdj0hopkwStEAiTpvXOf2b+QvePLkC4PdA6AtEYdyaAbdZmk1GvAwYWx2sOiESz4iumHAvE +AApRIwX+CbEE/58g8H/RX2IIst1oF+pcIT/UNQX/w/lRkQvcLflLuqV1U6bBf6QJq/6z8n4xquFu +QN2yflaSmMlf3amMY9gpiToEvNBPYySTv6BfXodk3s97RfIqd4DZngTjknY6IsaEX9JqcBvQ3E8l +/NJ/IKYSfoQuMk7Jms2iqLMYUV3DIXTjogjz4fyywai4mxWK4K0Jfk4ZF4y4IXkOxhDB/Eh0GxOM +y+QR/4NmAxo14XbUnqkgid9IVzFPfYmT4ejPIfoDyGwk18P+xBmYhj/qS2SBPP+jI71N5MUcw1K3 +D2YG2wMa6Q79uAF+ijXdhNgkCpSFxE132m32EUAjhNqs0eotBcHrGHKNabelfI4XGZOU//z9fdoB +Ao20/l784Kjfn6PLMEaTeGM8BkjDiwM+6ojoC2mA+qsAlf7i+ztYO9C63p0hcBTqp38+ERuDAdrd +0h06Gk67MLVTvsuu0J2O+42/8J8w5TOBIYmrBiZy5QPExhMkqqQlwMQ/dJUDzwicJqdPkFL5YG6f +gCqhkTRMALzLmrsXQQOjg5HEanyi0Hn37/l9/pBqOGGMTHxDCX6OkSPNKurb86P5+/d8AKONycxk +xXL9zrDtYcHt8JlAwBRcuXOiKpNTPrcYvM088qNhe96duZmDGsrKdwCkvxWhU75+5nraKf7RGZ63 +24gkYRcKkj3d9iIWmFClepnWmkA2NqzLgjxU6OI9GKRHw+K1FGdRbkJZR3mAvzkN/j5T8iWK/+m0 +5nAI6AX61kyewfvbuLVQ+82Emlv+sRZGa2G0cmFkJoHwyRAJD0HQ4SPHwyKHsNYEvu15LYH+RglE +/e0SiF9LoN9MAl0teQuzhVFlQpVrk2otxf73JpXnu8zXAu0fPiVPAk1YC7TfUKBxAi2g7DoK/C8L +fYBJgaXx3a8sA+9SgDcEiB5sFt9dQ8C8EVhwztpPSK0dhWup9iOkWlLAV+kxFI/umGRhpRsUhQJz +qJNrT+G/XKwl12LtNxNra0/hWhr9NE8hIYqXtbD5NwsbGD65FjZrYbMWNmth86uEjZvcg7XQ+d9N +yZD08DeIHfpni51/ndCAjjeKJ2DZXHRDHjovInmGYTTxeTxPsQyuKU3QyBPHw2g+9mcdJS3IsX8X +fksK+NJxApYBQXdNYs7LsibFuzwy3t+HB3tiV8yaXf04drVU9bg1u/ox7Eq8M4GgBRoe+yBuBa8c +5Riz6zvW/MoNv2LX/OrH8au1evV78CtJvYL3+5OKekXzqOjfml8twq9+eHD8v45f/RQf4j+X1ShM +3fIH/g8qu+SJL625iQM3+eGBzv86brK21n4ES1p1HBOJw3MBK0sKqLYdyycZApcEJYTkClIe/6X8 +ax3XuuaA7jjgOv19fbT7w6RBksFpSBTPw4sF0U28SYo1uZxyfeb7D5+SJ6G2jmr93YTaT3ES/MN2 +zVoa/dr8d0qgaQaVgYX3yQtAsUJl8Jh1qOu/O/+dI362BPrXyY+1W+ifyXqdDAEa2wEkD0uOwdIe +FImdQgzFcOsQpAW51zpQ/3fjf2v9ea0//0D9maaSPMyt98d4DshcGNQQ5wmGNqkuvNaf/036M7WW +QL+ZBFofS/wIfrIWZL/4WAKViiEZhkFXx5CwzAyyR0iBX94e+V2o8PeZkiep9sMz0dZSbW1XrcXR +P0cc2dy2IcaJU8L6Jt5/uSX1w9MJ1zLnx1hS66t414Lr59hR4H2cYQA1Y/uJoyhufZfHv9x++uGp +pmtZtraf1mLonyOGrOynOMURQMHyS/cDsBxLs2tD6l9uSP3wTL+18FkLn7Xw+ccLHxgUASx4jvXL +Tjw2mVxntPzLhc8PT9P814kO6IMTWJ4Q4DEvxwo8CeNPOYLgke+NE3gKFbsm4JU68AmpFA9heOLH +FRn+F4UUmxZ/wnHEnEDgaDR8LRjFMMTyPqffhwl74ljrHLzfkedxLEsyHLpYjIe10s2unKFhQfUk +5ou4wrqAigCuCyat9e6/n/07nT2QJM7sSzIMKcBfDMGyDE4qIZMMtw5N/ncLNv6Hp/atBdtiB+oM +TSSh0EqyAsejH6TAMlCrJxgaizFeYGgS/iChLk8pWv1asK0F208XbJx4kyid5JLoBi1GICkCdRIX +GJJcV7j9l8u1ddLn7ybX1ucba3H0o9xs+HyDoYESjU7XWSpOUASwqOIUmaTWltW/+5CDXyd9riXQ +WgKtJdAvlEAMBw96SIEgk6icAifEyaQAD+iSxFoA/b0CiPz7awXy6wzNtQhai6C1CPrlIoggOZ6G +S0fxcYYXSFQ0kVifLq1F0A9P2FwLkHV9or+DbdIUYpssJQgoNpbh4D0rqG4dDMNj1nFai7GbdU7d +78awUGwqxdMo+ZshGKhnxGEOOArKksK0UGI4sIKhyONxxNYPi0n9h+26tcb8vwjP4tZXbP1g/fnv +F2c/vLrnWpytrzv5B229tUz7H11iDyOzBIYFlAxjj1mCkSKOSXoF19j/LlT4+0zJk0z74Znn/0qJ +tE7++0eyYpvkP14gWehZwrl/wKgg1vVDFmRYvzRb2ZTdXEGY/vxoMuxMpqtiNzqgMouxXQvAf646 +DUC7kLzmU6stuHK2K7I719975JO/yC3++3KnBfGz5ihajjKZNP7yV0aT7n9HwxnYVk8hnvKPZ0/h +f5ROtN6c//bNiaVOfdIYTt9Hk8GqRJQKoDvxJONnJn150ZiBMQyRpCIk4TUY/dG5eb2YSU/xN5PO +ex9o23fah41hezTo/rdj1vQePmT8iSOgZ4XG3eHFqDucwWdJ8dlwPsiPxt0O6oin1P1XVP2LInU0 +a8w6r1dAsjbwgElCfjltNfpwzJ1Jq4P7kAeDXlW7w44puELnY9LBr0gdsFKjBbBv1lFF3RGpe6V8 +9vsZ467YdhkgdKhm22VR2VZx7Vp3MO7LXNuLOo/1eNyHAhh+h25MstDaRSMAzASQoPXQj4ZA2/OX ++6M//SwQNGsxsxYz/zgxo9CwvZwpTEbj2mejPfoz3uiaCxg1KNcGEOLszf4Q4YSI86zEH0fjRgs+ +kx80+/OJuWlvcrGI/gf+z13Dqx9AwfRHqz8RGTga88fsr/G/mG1fdIc9f67zR6f/Lzbg2f+VAf+L +MCl6R4Fa97kqPGpAeuMCX8MZ2lG8zALepzNRKRRVvX534HLP/R0uRoXrcCxN4CNHKsmruRDMpRc9 +vRzPsMuxpJ9zlvNLEgIt57HWXdZHpUivh3ZaY6JW7OMEBa8a85M0CzcdDfOFeXb1d6Jihlia//e/ +f/lPG9PeqthnqQMYJ8S3O9ZJypbmla0E+mcrJL+Q0tdy8MduZWijM2gXU5aG+kKG0O+zMVxp6thq +Wzsn1gL+p2jHv9BKX0yOQ+eGX9onS3pBNLBcmpGyFG83Jj21k6E1nSAnCBUnOanNH52J5EnGiB83 +usgzEVO3+hxN/muxDhTLwOBHSuBwMCReAfhXb3HET3XuETuXDgeMIL1XZ82yVSz7ETxtzPuzZ3sf +uLcdhUKRYOQRi1Y9yaE7DHkhCa8slWfqJQLW3EkeyB4lX4vDdnYyQ6OdwicsfPJ6NhpeTEDr7vAj +FsOPcx2wfy4a/c5s1kEc9qLpZpyhxyvwIVLCACafw2ix7v7r0z/3XbS84Sl0+9mddcTvnNHVgAQI +ZJ2+oyTDsTSMLE7SPEnTGheA+N1VOee/6rSlL5N0Mqm5JDlJMxRMV1APUfnyvtOHjlb8McfyPKl1 +M8i5O+qP0DmI+A3LE0mGV3dI0gxLMdpvSfnb/F8N6VNBoJFXg+cJEt7OZEQrXg7xy1x/LiGUBv9H +CgiPBJ2kTBdC/elp4wMogw3xa5KneIxUhkwKaF1YFv8gOE5A6ONZDvM1JZCO5xheBHkAA8DLB3TS +nztgWOOikTRebkGAV3ygVwzFowvepWs8Yag4utiTIQFkESxF8wAsJQCwNKcHy3MAs0kEFnBe7Roz +LIAHc1Pk0WrAgkflgyRhCpYlWZLCt4+STFKzDEkOXqMN2+C5A7AICzJYOFoS/AvgEnq4NM+wPAQn +kElOkwcWT0q3mnJJfCtKnKIBymgJLguHC4efO2CTElyeoinN6ASWZxlKCxc6xRDNw/9Trk2V4FIQ +uzRCLy3CBVAJzeAgdjlO2xFGrsCLQk4LlURrBiheBZWleB2DELgkxqWCeCZJ4GRSEbkUzicQKYwh +IBKScLCcBBYQrm6nCCzYRJrRUhQkAghXIjEKYxnDZdGaCcD2OeAZaSPSHEpfAPOiEf6EJElxeAsn +aXRxGqQBSeDzMN1BBIcGycCV4qSVEnhaQIOkwS6AQwPd88iNSdEELeBEQIbgcX4FzAMUODU0AmKS +lXYVz3A0yr9QnKI8yzOaKZPScstTxvsBAwXMT5oxScpgISLRDAEjQRmJDE2xnIrDwlFy+BZ58MMw +Sg7ufZLlJXiEwCOqAetG8KbMDGhVcNJoBgiDkNZAB6wIlsFUD8dJUdI2BbRHwcB8sE0ZjH4TJhln +GLh/IAJosEqsepwkDccpCCK8JPiJLx8iwdoy5uOUmCqZBKvDK2svjpMDcBk0fUYaZpIjCQrJM1gB +XKDx1zRHIJTI6THSBqIxYHEDof0DmRMYkoROmqORDEkCVk2YX/rPKEwZpukgViXuHQJudLBwcIis +vCUBISGILEuwphAVNiexURYvmbQleYnpk4y0JWnQLy6WFAfUzaIdTQAE4IUG+07cPrQYh40hsQKA +BKeclOCQBGAQHGa6KLgbyCaaxwsOWRbcpYhHqtEo3gUt8iFKwmPSwIyTZJLBiwLQyg== + + + a5mxLJIwbwc9SycKskSi0epQpMQzOcDuKDRjikB0B5QOgtVQkyyZOZwTBX7IsjOJCF1AG0iaP0MD +3iMgWuYAq4c/koBnYqHMJFF3ED2syIUYXOlBwicUxzArE+5xaU/CEopoPVjI39Am4hnMTCi4bKTM +KOAyiqKDVgtOeEcxEJxwxQUJKqAIhoQjAcSNWAMBiJnDDIRDSgQtM0pxnSjM6jFMAQ4V7XJOIk2K +FSgSTZngAC+GA00KCAcECQhJUAsJDg4P9sJQqmWCcgIggOXQLpI4Mc2SYhIbULDEPAGeRzuSxpuB +E6fPYEYkV9IQoXJwq5NItAmUBDTJsWg3g3Ysgs4neTRoQBM0moYk2WhJzosySS3ZkGCT2Sf4Eq8H +3EwCh/kTxzMYiICYOyPV9qAkiiK1awUpFSkNspLDAHaIeDqXpIHW58f6TlLUTySxK25SsK8UhCbh +zDE6JWwyQHsnsCIGb26HYwQ8Be1ZoJvjdRZHKN/WTmDGjGEibNKIH+OdZEjUqo3eZ35kCPhvuh9D +aMyExQZWrkvTb0TgAGKp0e74ZyM/NkecYGlbK1BMvao2cPTtFUhmIVQ2gHTNTZEG7QI/CtDruwds ++hEEH6p9zxuTztSfHX70gVmlAYP/86iC+ewfGz5B5AIXH/MpaGZeZM/q52dFP+ChrD8Pgf7Hp38o +fYY7U94CMIYv0DPpA4pDhA3+RwXSrBu5F7BVOY7UiFUeUK5W0ApIvCAtRTxqpvHtDZK8oZHeC6Us +YCqSbCA4gkTsAWiSAmVuLCdFBsmLfEJQaWuAESC9F6lBpAqurN8CvQ0JChbwLO2IgeVLyCYHgfka +Grqk/zNIQiIBDtirBJrhKYrGgHiGMVc2WElQCJjtQjmtVg1oKNMoEo0aLDkpLw62RzQLChiCYW3Q +M0k1TfKoB0oAksVK5ZPVcUFRTSVoVFJeahJuucZfKL7l4sOtLwLrjlDoywoZx2A9lCeB4ozEH8cB +JR4NAOjSLJIq4uUe+h8i+uHCUpClytotD9QSnMnG0DSBpSlDYFEN7BqkjVDyf0UDBqrJLEQ0Ky0g +BwaA1o0Fthviu2C5AHNGXJ7E1hwtjUn/A0PlkfDgES1LUIG+jlRlliLxRmCAtYXGBMQtiXUU+b9q +zRP+C+WwJDLBaNA6MkClQYQGFAiwO5BqI8p7aVD6HyJYCol35BgA/0p0y7H4PgqCR9KdBhKSw2QC +MMKIChOnVr2wnsTSGtWLZgCdCUhhAbsXGWUsyapNIWDeSPe26H6IcHms0qGdxUsCk4KuKGSF8xyf +xD4UEnegMBn5vyKREHiPQpUD/CspxyTQCtB3ApvEvgQBaF9aPVYamf6HxFcIZPxDoqYUbwUr4LYE +QxFY4wL2m9YhkBS5lPZ/JRcIUroZCu17Stpyt52mPz/qj6AIHM3H8uaDtcxI7O/gGMHc+qKkWwVk +41PDaThatj4pxbbhgSamxSuHl1SxliRllJc0XUoskSZSGLYekF7K63kuS1FYAwemHctrnImWziGW +tXEOJUUlTCAAQVBaeMBkBbwN/lBb8RgeBedNG8bnKU5KGRyF9gEva7aSnQpYhoCzaMGO0Do3eaxy +ikSr9lqRQlKhXBLDvMjJTmvJN614q9VubN/ZGDu80RvJ5V3tTmdqL75dlLt8QKuJqTQGl9smOBmc +7mgEjn53k5mQBH5V+2vQHPUhmP/DF6qMBkCrDFU6/TH4n1xj2uuggQNdsfUZhurnH2BUUPMMXdVq +sMm8D7Dmj/mvuh+fM/WDwujPofrvaudd8/56rP4rB7TjPxuTtvpZaTQRH51PmuDv80lj+AG7rs2A +6qr6OzefzUZDQEzGZ5T6Wb3R1DaCDzQtcEfYjw2m3/7ooA/geskPNB/gRzR4JLrcweC6rV4Hjg/5 +/KXBQhkfFvEOVkqNdevVE6mtMGrNB4CECo1Zwxd4TUh/+1PoL9U5F/z77rR6Nmp3TF/u+UP/GfSH +4HWsMZtNus35DCe5gKaY6v4XIFYAX9Wq9dnttycA96iNFFsjvYX/zP4ad/Db0M5w+vpHYzLdUyX3 +q5v+0YBrj9vC51OLdjBdHDcTRzLV/PUPxc5wNOy4QEx/BCi87QYzUsvo3zuvZnfYBgMlXcwNEEet +MztDk3Cen7r1ipZ/SUyQtphwNf9uo9nvuCF8x1X9J2301B+utzps+jdTNJxeaz6djQZ/Lyf7dXSY +mjZgHASUeWCLuSXHX74vavDmmh8zlN9hl07f//zB0vhv3gbTfrf1T+fFMYFUQsMsl9fV0v7dfBdO +hXOayl9upvLX3z0VkqMF2mkqf3bbKKzdcTpiw3/AlD47yFJ1MSep5d88KSn602pCzRGwdAfQvD6f +dIG16GZqxm9+gMhHvK42mk9anRwMgl4J2/tHG2SEyVs1xmaNyUdnBvQA6DKYHhXcLL3xm79Zlb04 +K1NMaTQZNKx2pXrK791+x7axZrLq1v9485xw4gTvKBDanWWutP17l99xUt0hGGe/0XI3LXXrH863 +0WU74wYA13KlMWjb/82bdquE/s/Fhh3Aq4TQUYubSapb/3DCHI5OPU1N2/4HyFtnxvs/M2m1Qunv +Hs1oPOsOuv9FmQU/ZUzASv67hzDozBrtxqyx7DiSS45jqy2ef7jZdarG6GN8UkgQfumHCkjtpvx6 +0+38mRv95+5ebP942ml35wP/VWc66s/FHBT5i+wRSfrl4xhAK/Oxv9SH2xye6V1MOjA1WHEPcyxL +s+Lss0dJf2Mya44ak7a/hY6iSX9TnqXMflAX0iT8XTCKxqwDGnaQS9u2cW84avVG85n/A59xIyJQ +ctDgCE4700//VWMKpKZI8KqZ4i9YiqEE60FT/g908uWuraxx0IRmHOfz2RgM1H4klAqyWhqCEXTb +/ql43ZyLUShodlwR1eQc28qTIzXrgchg8kfHX+/8Z+YvtruzRrPb785EKU4yMkwjMVUbw49546Pj +vxiNpSXUi0Fewkt73I3jJhJIMLKJjkQG6BIDzaNGvzvVPZqOR+KOoWV/x7jRbsv7Knvkz85nI3nF +jGSb9I8bY7ALpt3BvN9QVlFe91y/02lDG/RG2dykJX61FlF+MhpnJ50GTnE2yMyQEgtI6je8n6aM +v4h4GH2mYwniZOXeYAcaX4M4WGnV8o3hH41pTUaHmhAI/7vMGcCm7HeHHf8UJRZP7RuPJfoZ/dGZ +jOEB8VS7yhBZIteBg76cNyB1+av40iY9gzAbxwxQJm7JKxSuaTlB6xz7owNvMfQ3G/3GsOUwyVa/ +OwZrB734/wF74wNQgDjwEMnEwXKoGGkve1Sa9/sSHm86kykUvrOJoYta6dafh5DrI39WpBDzfaH/ +m9ACqdRPq/7racd/NIAbLDtFQQiQVQ7bemKU2ytNxPChGrwuUiIJnodVs5y/0ks686Z4XPhiCXnX +mTVUdBQzNDDG8Ugf+GtjYCpNpgDds26r0deTleUHSmyKgb6M3wAc52s17f41hY2SSNXmOmkH9mjY +6s/bQJ8eQIrRMzCzL8ojWB4A5tgDdtTsd1wMCU+3OBjP/sp3+v2pJWHIn9QLt9AXWlE5D+16QIt8 +2hjXZQWIctG6OmqpOKp+xfW7ZTT+y0DbOkSJyPTfnV6Yw9S1R8nKGJP+U5zsbehX3eZ62P2Pacfq +RrfdYXv051RH7aoWXbXc1I8wqcFbrfEH3FowYV+BMBpCSvFr+LOrb/xwefyEuECEp69Is2V1+ogS +x+d2UvgrWlRUPH3EiONjPH3FLvQVt9BXvPiVNxQKOjqyoQhzgtKhEXqnneiJcPcJHqD5Ett/80QQ +Ej0JHr+jzHHv+B294HcWdOX4HatfN0vEm3IdRaLX5s33Ub/dmUieRPh0GtaLXV1jlbmm5Q6F+RiM +BBpfylhynU9AVSp/Dm6KGoj0phXOe6Z8XfdObQOo3us4Z/E/49FkBtUgtXRVqdY5dMijUq4NCpLG +yVTr9CuNGegbCpc+nN5Upe9atD2C/tajgrql+nUdxinAXs3Gh0JGVcPTvq2Pxqp38vlxuT8CyudV +ZzzvT2UBuAffypd76Caqv/tDUXCAvY90DqPsBW+Kw9bIxMIGb6AZdz5U9DL1O3TNDMId1BxEC0oB +CkzBVlcZN6m8KQFtqm50HkOQwMw66UyGZgMBurWsfqrHPmgC9CKN3bQjQOxTTFqGLZT0D0eKoeHv +DpEGP5p2pW6cPSKUHxiHNl4Qtb2A2iJ1Pi8aCldqQ0FtjaCmeFKJG2yG5DRmiNqzgVtLsdf+BtCS +satD51LQuCHwRzA1DloW6CNksus/cuMUKl7U3OIAN7ZGgrHtuWi21dTmoxpXuJkNsrTzxs2dJ65F +Mf7KGccOu1EOn/ffdpqJm267M0qcjoCm14FIBYoj2IcdCbcJxVGeaI36sJwAgGxk2ep201k/3sZd +IKKWBYI9ePiZ2F7xKLr5ZtwegNf9oetBjduugeOYP/kLUr5eSd1wPJ7EkbCL92HQvauWs5HoXWJ5 +3r7lRDFsBIK0b4vjDHTsXbOGsO2fI7EinH2zT10zA06/Rk2A02n3Y9gwOg31DdHSNsU4AzuIqOEI +niS7aNeYNruzQWNs3xS3mej2iVnrVn8Sb42G8Cow6JKzGSpsKfPtJrqqCM+fN209aceBDQ/v3HEY +AGj4DliTdM0YEsWmrZCQMHr5DL3+AQ9ox/FPl+3+sB7b+GPQi3eGUMdwt4PQB3gLKevp5huwaDN4 +wZs4ljjFmtI9bAo2NeTNqoAoy6GPwRbpDt9HDs0mqouuHJoiT2mzMZnaIBc1bEIVC+wnFYdw0Vhm +Ei7aTjT+D6fWakbBWTYfNCa9qXbULhrLo3bRVjVqF63VozZj8to5zqcdoBIj5dZmH78PZ/F2fzx5 +Hw3ttvt4GoeKGeAhU3uymMYBz4RO2SFoqhL+hpb/GccnepaEBL5Zyw83zAu0E3mX4l82Q5PSDvvD +rSFO2pOpdsebCiDUTHJET6fWPbcGccm73hr81bNhg0rDEb63WevBNfSOuYxtz1BLEFnQdbwW9+Oc +VKDPt/1Podrt+cVT2P8H5aADwXGphJOZtANtoBbTHdqITihfnYYM24gqiygJkuZsEIp0hf0JDGXV +Sh1hGQJaIOCbbX/zL39h0v0D3Y1tx5fB94qKZaNcaBixlWph4q01NEJHjq5kBpTxmrGZSmtl/a2F +4OTDWVCCNqKQVBWk0rdCVagkWI7tbIQubjTuS0FIpsSN2rSGUzuUgjazbl9tYZvzz6l0zaZNG8Rj +nWTjRJIDZkPGbFezJKZtpsB0lk5GzdltX3PsZtai2YW2kG2TYeejoZxsWgoAoJgO7dv0yRZynRvM +Pr2Q+Gy0OxPVUaRpK60c4c1UQcDM9aeDpgy/37VRkkGD0bhloxihBlObqaMG7bmtwW6zg8Hn9hsY +i5j5sOWKIaDWjeFwpMShiqEB0MmSlRr6FVeZ56gAUt0eOQl0p8UGt4upF4GwalWXRQ== + + + uIM9by4UkYUEhowTpy0pQzGk+n37VtNedwzMnKGN0IbNJmA3TqYdOLyJu26lsAP3rF76QjU3q+FA +n4XssdNSwfGoeQSMATUN6Jxf+hUlLB1DymKJF19fFEqiEwraMjDAbTSc6t12YAT+c/xK5apSu50b +f3ROgfjvjvudrBZNjk4eVS0Fv+rW4xX4d+DswfxeYYp9XtGJxTAI2+/cxGSYfUfB/i6w4oWOTmGH +F6N+V5KKpsaDNFBcMqI0GQ0AEv8cTXp1STIxNtM7HQ1HrU/wUUc1yZPu0J3pKw0aB1pBt/1wJk7A +HXalKKYskKPNxqza+KsjmZnwiin7ZYGXQeB8TnTakm2O/nDRJYqVsFpR+07Rp9a9elueK0U5NDeI +zKdqcBt7WSFYQAC5U47aYKW6712JfXEeEKZQhwv6tw7XYWwnDenSGtPeRa8EV4lowozLkUwpFQqg +NanfkyrvtfZLV2GQ3kimqjhebQZrsRnVgzbVsdzHZpmb+kaWYk213uadc/CI2PWsUKuFmuo6UNR+ +l+p4g+FjF0xQJcxgPCeg0XxjjKM6uw6ig4FwJD+QtbKg9IhOIE4bQEoo6RfuOEmhMwVDa7iXoBLr +yE7sideE2S0oiGQ25wITgLEcKd5SCx+s1Lo+6Q4g0m5Vlr2jrDGbjt2QrjofsI+pM2fW6SaOjBl9 +hANkuyoV13q+yom687BLYPPcdpow1N2ZR6mISM2XnAdTtzO3ZbxABgYU4vrnfNAcNrpShF2o/gl2 +mr8x6fhnnx2/6HbyT6VAuD8/O0P/FEdYNIbqQl1+yEX9jSl8rOi+Ukx8HMWHzBBwLbC/RnP/GHBO +P+AnHbynUdcY3AeswtPVdBT1g87kT4dgxvBi1jFMPvN30cl5w99v/AXj7xtjHDoCedV03vqEwzsa +FtBRlQIG9zYESJ2D0Y3ele67U/982IOVQ+Kud35r0h07bizUGGAEcZm6yhtjt2ayGeKC0rCMqhtS +1xz5c04+xKBYp40FBt4xxmCZTRUMZDxWsV0HElZJcVs5iuMpYGTFFVxka/eQmtHqwhnt4EvMzIVR +Ups1hm05JNolLxZLqfx1ZuvycIwdd0aoWj2wX1dEBNqFBeYyeIOVwbxsG7oyP82mA/hqfzoDFvlc +Tg76//7v/2f2//5f9jgTPwP7633yrbXjj4Y9P7zSTWXC83xSiQnUmdjKzBK5rjTybC1/dCSwhQ7s +H75kDs93HiP7twfBvcZd9JjeOY/lMpPy4DP1Mdw4Lm1EQ8F8txGfbnPXlSK3lcpcl9OnzGGq+hQ8 +zUzmLb5UpE6FAMkwWwQxLXwVPqLEdmbvJb6b2Y+Op5npCZXwBTJ71Y2J1Oh4lvuoXFYz+0ynlu8e +pFuFeDz4Yeiq2r4H/fGFUiDFP5Rnha/nHPMQi2YHo+o0e1SbfUbS3Na8VGC2b3Nf/eCtL1B4J46b +psC2+eQ7f3P5+JSt5+M31p2q26WeM/u90nMmNY0PIoVoYF4KldvvvgBCVukNaBiF9+dbPtfP9O9S +77nPWf6TfyA16HjbKbTI6ndm/zB4i+GAIU/zLx8vI/Br57tw1D7ayMWEr+1sLbY1xGO4a7TnvkDy +KxRpFVvsZSj/ybzu7WcD9E4kdxZ9i2TywetSvjPfTd8cb33utVqNHvzVjRTfq5+4Z5JINPhJd/st +1X05buf6gcNgbBJ5mmertZ1vOP5wZu/4k/YFuL2b50x22AoOIgenewl+8HTQ5fnE9J3OTlpHZKSX +ImWIrcLx9AagjQ92+FuaaKe6+UQDrC95ehCKRTu5Pn8xwDO4rwYy+aP9rdtiNMlOwbocPXJbaT4/ +eons37QfU1Rz6xmBTQ8DYEJpbncLLskjd8tdDiGe0rlemIuJpHnTrhLk89ZpIdHY3yltRB4msBcO +vnhBUFATX4Bobh4x6HckXdoXf+3fFk9w83y0+IaBUffUESDdOyKSThejVOHw40CEc3uwv9f+OntB +KykPGMA7z7FiL6BR7lgewLMyADJ0cAUbdRj0jN3IFV4RqoGwPGS4B+6rla0XviKF98TJd7HRCG7n +uOb15X6l8JrO1j9bs+zFdus0W6dosPpZ/vl+C3zTfijevR3OZRRhqtWQ6UtPASb045OKtGD3o8J7 +rdhG+ARgG+FIemvvFq8QhOwLFF/JyE2OuTsuZSaTz2smdXp7iFZIYLsTDizebjSSGyVf9KjUTlyN +dwlPeGEhKF9gL3IwD5UKfTJHHLMp8E+Z6GI4aa45yuzVZ5vZ+vFsbkSlbiVVeJcW/m6yAZ/VAR/7 +jnezejzNr5KdUmhnHM5/clcPxSaxv1voTCZRonNxsCcPBKNDRka1nH09JhG17cfeSnCnnsQLR198 +A+99vKBC7Xtwkj1/yZ2W8u/HAkGeNNulfHtwj5inyRqUc33u4FaBzc2qBw+5Sn3rQDcGXwCMonNe +KPcCHdDV5T7kMDTxnrodGUerb9cCv6Kz8nizmUxG9pgzHUb2jqaj93x32uUgt4w9XlDhraOKMqu9 +TmpnAHbyVRiS12nk4PjhWOr04wnwMRq8DVR3y7PX9iBbezsuJLoHoRIG8B6scNn66egjc1M/apSK +wuWdL7AfIYpPMjrGxejojCrtcKk7sObzZLHV+96ROkAbpN/AjHnnMVgF7PEgmL3qj3fV7S4bFcD+ +ggx/9bkbz57c14a+gIqFS+9fM3V+5zxf/a6TGpGxu1N4zwZfNDLgqlR6DW98omkAnjvsgC3FNnVv +xdWH73saSaP6ehcI0fKoGK23DgAWL2/Bxr7bjqQPOBq9zdaimWG+271sw6ltwCb1wslJJVbaL7Jh +9BbO5WN3iJvXTzOBXP+YiMO1elT2Jy8cdneZzE0zwV9UTq/I5st1lt7Z2C5S4e2XPFnOVzPwVxqQ +OHlAdJqpQzIayh/Kz9K+gPYb3BI9g3/mIFPMow/Rn1ytSl3Ctwfoa7mDPHyWw6Cy+7ESz8YKV9Tr +w7gIm+wDngybwwcFuascbHSmwMG9wP60IDLy4NPyF3uoCRzNBRoSGgOYC4CTxUOB08QThoOC2KnD +Z3sImNILAqFHERyyWafoTxFjEGJNi0z0zR58i6ZxqKASN4aDw1gcfuxdyiioIXzKveyr5qIsXtp2 +aV0vhG4ZfAHdQuBvILIU2GgaCE9adBygWSl/IlByz2VlDL6Adi3TZiRnuyR4yOiXPCvcqfInpjFT +wnBBFrBxVZ6VQip6msVzsUTWAZ4p2jkSOg6UOcPG52ZI1e1UX0BG4YFumjJOUloQh9rR5JVv0Vtd +p+K6KPtORTGaVU0rVIsaQ0xkTbbKnjzCC5l5YCLFcykhPCKwblGtGoMtvSCUg9WHeJRhp80YIJqa +vDW9kSFaEIyxfbkDNMYrTiDD5+gXRr88U567ib8DBv5Fi3IvmR1mr94/ToBaeTLWCYxs/eZkWMqQ +ZM8XKAfKrwAnbIhT6Sbzy8B+6XVW383sERcbkeLNXUUSZbFtlTqh0gr0VpK6HaBkaBhg9QWI4IjK +NCOTwGA5yXFBoPqFHy2tKX7voVrK0r3tY2QHaCcUQQaCLyCMjgm+GIu+M4WTw29G3UvutZO9Gtau +s7XZ0aAYqSZC2rf9UiYZGEtGxVVYMb5wB0eP9e/seT53AXUYUbsaaBADLFCohWlnqlI2+L3W9VWW +fzq+KhxPdt/MAGTZyvNR9uT2EujJ4siuA73y9LwzEVW/KpcDYvspLtsOcXvbwd5ygNqFZDtAYDx/ +/dw5KbxfTmuJ7sUjUJuL33msb9PU5qO9MWRpCvkCamNIoVA4NWxh32XPS4Wv29d894tL7L0PAh9A +v90lAU7Sbzx/1R7BwcUU/UhUY2v9ZwUUoGQR2O9kWXC7sj8gXfiIhQ9xB5d0+g0oaufB/GfkPp/o +pg9S4lpp8aSxRXqA7OMlxRAGfEy9BhcVhH7QKb0FnQdVTPMicaoGYmVU7KQxnSsb4KLSB5aFov9r +tX/VQJO9zkkeTKgdKb29ppOF8j3/DszxIkVQZeZUD/ZyI/ykM1IwjRWlbt8uC+/XkTLg06UCFW4X +8Q5EliqUAUnMuF72d3pW+4ovvTzvbpWKw/kbFUgOBHH196PbiUeBb1WPc5cXGTCX+8GZaODP7wPZ +y7PaTakQbksvFGIf7RB8b968IKonzbFiI+t9DtRDD6xL/vNpIxVJl19fJcp6joMVjJ/keqcRoNpf +vCt7NgU9LS+5HnWwobyQHQFEqj3oE1CInEFsPyjeDmDxmfS96p6xpnSm3rrj+GXk8KbxLXVQ5zN7 +J/ebwHz83NDCPs/Wyu0vsC4HEypzvZFEa4BW4CA0pzqQ5N7RC8DHDj+nc7TIyUvAVEEvLw0Aoj4t +vo7JZmbvOhhXOckotr+59z6/+MrWrxv3oINUnyg9ZWgwmkpM5s56B4YvkOyXRu9WFEPKLevS7lUD +c7l7abVH0X7/EhSX3Sk0mU7NcfeqBgJ37weg5FL4or9XKrAPVCR9/7xrhOjCyleBrap2b676+onw +CdYlzR3PC/GrdiyTOvvqySKqzm2WhnnRNQiILzb+HnULibu9jITPYCfx2Xl5g/icioMrFw5EDnp7 +wEIxT+UG52kgxTSKxxmTO5/TDwDVV9NiZJd7V0kshe4gKXHbW99CJnX73d17rzQ/Mqm7khoU5tjY +dk82fQEksfej91wFwVbJbrElEQJ2+qwF1u9hr9AZn1eROsFtVZkt+IwqnNRPN5Xu+Zt+tQ4E3eF2 +8ZUYPhfe64V3X6AYHZ3Os2wm+1hsXfTDOnVJ9Ex+BHqAoSY3+Wni7CZbr2bgNkzGjIPfD2UmseQ8 +e3GVeE51X4R3sOK3u2BdVOoNFkcHCUAx1V2goDxdl173PhP6Tqn09wAs8sdG5vuw1VFewLWaZ4Xm ++CNOVm6i4jOwxEAfq29/x0qhUTKse0U2q0eUAkKWr3DIZ7Fcf0C8A3rpPXDp1Pl9Zm+cJI1TE9vB +dQEteeFytGvZCDVJtdvNb2OTh1iBSD4ES/kO18vWCw0y1xe2BIKKfnczqfPLPlowFYcxUBE6nzho +3T2CTVM4zV7VM99G2tia5rsHp9NMqhRocIfcXTl/lr85lLVDTpQv/H639Vg4al1d5JhbamZY+Jet +DSA8iMtS6Piwmqw8lWaiEiwuYhwQ2gm3d7KdfS98bD0zfGoczwN1qLurgEJaHwT23hlBonvcD28H +XiF17xebiYexVvPGIxPqO9u10uvWTg3ML/JUfPmatZAP0ojP8qzYzO2GfIHUaYR+zNbrOxsaYjk8 +ksFWRS+VSBZVzISlP58sCKSyVcpnn4GKmDm6A3ysEK2zss8QjzbZyxbrWT559ZFk3nIDMMkcYdkE +CoIGNJXCsWG0LqtnwAqr3xz2Mvvp8S2Qlf0hsWMCopPrBWfHOeZ+87py8MQEXc1UVPM0UELxJ9hL +7+gMmB/FkXrfcZkRlIbH0NcJpsvSW8BEeEgqIFKksHFWCt9fzLIn92Rb1enByVm70A== + + + HiSj6jMLMLIQ4PLnvQ+F/2ImPHr7ZFU7VT69wAw3cjb6Krwnj/uF5m43kKy+TfZL2f5wE7lDdfQC +Vh8e5aXO8omnwsnJfgKratRlLVYqku+hUip7tSkt6G0IcP56gjsoZdM5LjBmC0eNfsDAf/oXYYCb +5yvIS+OFk6PNPOCW2g20H51f3JcyxOwVrPmwWdrYjZLAhL2G3yQpsHPoN7ANDwUVWHo3FMbGJV/n +X6Szq0xAe/omImGvFDoaZJOfT2dbpcLFaa0UGDOAudx2PjJ07oFR9qKoBoFfioKFzvCyfG0rnwX/ +rWT2Y/GwaS+w0U4ZOoufQKMibdxjW70sE8pdF0PT5jNkJKQeWcQ0+oBWAGzc2L1lL7Vqjgq/101B +kMHjNjSZT7Kjz/NdteVkt1MR2UsWny3hy873R3QKANeKKjRq5adyoPwsAHrpzVWNZ9XSM1j9zDZS +RdAZJdSTucxpIX7+ua+i2jQXHZV2w1EOqEFMAJgSmT46bNzrJFs34hEcd3ytnqnaBXFIlfaim4oB +b6Axtdget99LoZNyUr3IiFYvn7bgi3621hy/Y2uR4jY/coNN4UulKWUq429pVyryBfVyS+83+L3L +84tsbX5NGQUKOykcDbpTILZyAzDCPld6Ow0krTWA89T+FcDYabu6Zb7ckk4hJEeJVrE5qsQc2tV3 +bp+LjbejzdwgsqMS0BKNqbSPw7M7sNJd1bm9Dphq3xlmCgXK+ytYxMruN1C5j84kiYzY59ckeFfa +mY87OWaeA5YOsLRVNjlqMggJgIPGi/3c19dFpnDUvpwVjkOhEjwGPcLnRtl+Y4BUo+Js52hD6vl4 +DrRxo/JaNdNgRTV2stWGdBfNXu6+AgnZGpBqdnw8nxFHj+V93X4Q5wIUlFY9dfbSnJfeXqgBpDFa +Pkx/UJPSQSenYv9wn2M8BIjeIxAOd6HC+854i5udzA5Kr/14QtNL9yX6AVZjusunXiI1eB4U0a8L +HR7SQCFgGlkmGBwlyduTRFYoT2cwbAAodEeNu8w0fLdZODl+/i509l82lQVDOv8bA0T0+xiwj6cE +l2qe77j9Gn6bBMZVpVJ6nT3HSplgp649jOPQRsEcRjIMLoBozsQ+BdBftFx+EOpPxWY9e1v4YHe6 +Ou4lMy6JZ8lSGvMpcUmKaC18AXQEmf983P8uZS8y49TpdD7SugY57ptMXhVa+UavsNtNtPh9utgp +PrwfFWX3JGpSAzu+VoKyqZEVYvFN6AspI7aFMHbxwNffKolSYZ5Fx5KXQOMIxgqlYfYUyM96ONfb +24+JCooO4gdgcLV5va0EbmBuKAK93Myx4VIC8LF2qvCh4pbi+/qWiGURd9fZq1H1jUt/h3tqkxni +OBfcrxajzzlg73PUQHHOImQB2fvUBRhLf+8eF5p3nSuw29KV8v3r+A3xSHn7WGBeXhzRT3gAGHis +tMVNLiuHQPU5BCz65DuHhiR5R6nL0AzS0z53fdFOgJ16HS0FyBCwmy+vooXjjXdCPQPceExyN9/v +WSQSSoEqn9LBlhsDGivtPHwMC++j5whyHZn6r0VWnxOgd7hensfHL9mTh7CgrD4MAQgWW/PNF+G8 +QteTdPR4r/QavUnp5iLDqRdHOrGthfOW//gsBeGpt6AZsgxgzJWzo+9pAkZ3nBeeu/db6tNqhQGk +jhs3p8r8NWb0JdB/T0vBcqBUGchmETCQbrfjhePIFqvuuT/bLraa0TaMIrilDsWng80duPCvUF/b +13i6n/nM3ktsnq3n+VdgdbaBhZ2INbKjbKekDA5DoUPZvcze83WOHx7VycLzxzMF7P1aP5OQgAF+ +cdEG+6+7DyasUUWLpZ1ydayEI8U3dpI3HHfc/eDqsfsHqrgRyyU+h+3GdvLjdgLGWoHXdOXIfHfj +MQj2S2S39V0gtmNDJN7ZjfwuCWyCwSZQ96+bZeg5DZD0/5mWo+W0oXAFdK24Nuctqc96HDeGHV1S +oHiflfY6TPUVWXf6q1jAs0K9oMuIhDdzfbxLwXyG6ME9uequthIrDPrDFVphvp30zodiGNVPTOP6 +Imn2jQfmcTNBJCKnEcCpZzT8RTH7lylafnEp/0Iv9ujD+iwHLItyr7J1ddAA9HKflt9SkYMr7nMj +TFcONmKJINBhAPfp7W+Ezx6SG9HPLnj19h7fiMxTtY3o6V1hI0acUkTi4D6EugerFr5kptT0FAyu +0AMr+ZamcwItACY7eECxNuhASXlLVF47wLKYTNIHzWx0fHacOUlO00Jl/zZeGj0wN8XJ0wNReCjd +10sH2YMWuZvlh2Iv9PZlJB/bvQL9VTmr6eIJxelqchtqffpG1elksjetg06iR0SCqeFpKCObCqXZ +DfUy6u0Q7R0S9XyugJ08E9N9AFuYR9LljR00cbQuhV48MRXKjPC99wX+LPfB1/cFbadPk+fTp0vz +Tsv8C5s6eombdvqyfQbkvq5bpVOue1IOmHe6vxGaTMnAxLzTC/KJ2aRSu0qnvoDS7TQYPY1ZdMp+ +hhrB+6J5p0z4KbJPfZjPdLP0wvgCW9fjftVsrkQpd5Kx6JTb2h5OwgcWnd6/EKX3s5rSKYqDlbst +b+zvkMevddNOyxWqbole6iFdf0OdAlpsFrVregso+WmersJuw8ZVDd3Tj30yDDplRgZSqhI5sdOL +YFDXKcsOXsdKpwol425fJ8+fw7pFp5kGx5e2SdNOXw7frqw6rQCtjw7tPZnPdX/jebr12bky7/Qy +H05/bw+qZp1G9vqptNIpWBctKe0ePmTOzTtl7u+JUpI4M+10s/TBb18NqHOzTn0BovT8XLKYK7cV +6A1P81adNohy9O3GvNMykQ12Qvw96tQX0CN4thU9FDu9j4V0CD48Yw5E9BafeiVNpw/7RJWPkbDT +XV2nvsB0s9IZcVeNGAW65cd6+q0+PjQsOuW2+F679GLVaYE43X1Ook6Rjayd69F3KvM1Obsy7bS2 +F6QtOz3p1GjCrFPI+ZnHGFF7DW+azXW6eVLpnD0+hEOmnd4Ehx+WndY+L9+aqFNfwDjXxzJxczLe +N++0SgeuS5n9A/NOx8ebZp0Cngy7vXktb84sEPx4TtwenhTMOz1NF19fLp+fTTt9Pu8doU6hfDHO +9euebZcsOn0SiOdpP2be6dnXeHCeFGhdp6AX1O3rUWxoieBJoBbZsOj0/poodgfHpp0KZ7HNjcxz +DPAx0G3qW79p5q/8q9hpkw7rNk34odrYRZ1SwXSoop1plXjbTWVhp1GlU9AL7BaA/fqWmP7BRN/p +dLRzIHY6O4zoZrrx1HgM405z9+SRlhFGJ9Pr9AboBXQbN3KloxiaK+g0PzOwwsomhzs9JE9iOkYY +HTNnWNLQ26n8CeoU9iJ2uz2ZNJpD2Cmh63QyyXZGEv0eb+g6nbJfKVHSHKYu4zr0bo46b3WfqD90 +Gq+cdlCV652XUcry7f0lObixevtJVN4Cc+WtgfMD1lvYsfgarMFOJC+N66vD695yAvlaF99Oe4Jh +V3LDz807s/eYKV4cpZ4s3wrU7tWb9dvPxktQxpjxfZbaeWhZvq1GhoeU9dvm+fue8laHMW7rfLPV +rFh8LVR2KvvXU/z2Pfid1H17HelKyuk7uZkyYOy6eVwbmr3HXK4Q6U0s394GmokN67dPhdSBhDGT +92+BF37b8u3X7GJcsXzbu6Fyl8pbA8YGvVL6xeprMKTLPdby7THFpO+sMRZoDZu1qtXXOxs7R0+7 +lm+L2dNmx/LtMXW4SVpjLLtBbYdTFm/ZClE82JXmnArt6d5G6pfTQ/FtPr6v35WV+lt5N6u8Z6ZM +9EprgeWJdvAxL/Kft0Afvh2L5mjplcWsJzeanuFfGj5GzbahhZnfiB0n74GF+VWH/8Ths9JGtHCV +h//cIvtNtt4wjxD7a1zlJM432aSCBxcxkZ8DO0ejj6W36CD48HiA9ga0dFQ7InEqDIPAjr2bA9a6 +uQP6e9+X+9tKdA+aYcCdNouT+Vs8pmG3k01fQOkWWToWnXJb0M55NO+UuX+w7BQIkS9Sp4+p54os +HctOochrWXXaVnfK1ICNrOpWOMvVVJ22d3a2lE6R9i93SuvQC7V/eablvqbT8D2yXtXdahB8QFl2 +irR/i06BPQi0/xelUzAXzVyfLTsFCJ4y1p1C7d+yU18A6v+f5nPd34jbdVoNWnaKdAqlU7j3Nd1C +naKuWdVOUuoe/RIXIpx/aA/ctHuZD4bqvW/Rktv6finenTu2Yz9FuhO5RQ7M+SkrckvD1n0LDSB2 +rlQOmnRpPhGZy04to9vxie5WKqr8kx6H2nXRWIc8Cdv76XF4fyxDDCEQ6WRl+wuNIp0sPxYA42oU +Yc+0wprE7tPFgPhP9HQkdoBUYKkDWbcE4wGTOxjjRjrvE2B7ucRnpxCQ/7lSa8yiz+xcblyAvZTV +0307PhR9SmDI1xfgwQ5UaOe7Enaw3i6yY9UMLna0CJQ9bmDAxDEbCKB/IEHeaq0ks0H1kke6QamH +9DoPAtI9jVLBQ0LlR9O5AxHKAbd8nudOnJAO/xEHj415k/kFNyzn5wsoM0T/WK6gtH61Tef125Ln +tyvSmNkMofJ6bYMs9+s3QvSJLQuXyLIBRu7mvkqWoHxuyF1C1l7ME2UpdKWRyJiyyk/f3jFvineg +3DyIlLw05qncQ/LYHu8+a2RpWU/YyHpeilrWQ1uyHp8T6RafjiZqBMpD1iBwB7Mec9y9wHwxCcEW +44kWo/gfEXfk0Bx397ENS7ZttSuRP850aveb3qemlmJocvThTf3UCdXlkx3xNMF0IIWIblZqKaaa +VeciviOuvoGNFkEvNyNPEzLjMIB2gDl3p8KtvA3VdP4W3gGDuytYLFN0TDa2gxU0BuznXxAxhLWU +/hxFDiTKUVEycuqYAyPdAjMDhfCuOuXZNe67RsntvrPfdUBWNjbv5rZruUVGr8ko/OcxojqkMJAF +4Iyh4onZcgKMqRcU/gMWVHFEG2kDzE/mgkbaOL+Uh6QaF5rLrGw6snS5ObWaZIbozK4TBi3MuCSK +xXcaMS5Ju+ykhbllPT1h6gtYCiYXOqPSGGgzjzNLseQLeFnfMsRJxbv2ZLb322UtnzZB1ulIEbw2 +Q5odHlvKyvMrcTxuVDowJGuFTlo6X8DdCgIr31axcNL5NSs4DNgqFh7Wr3wxUEBhSl4CWG3oYlxg +V7oCphUoXsclnfCKwO7tjRgvk1RrdUtj7HWyQoxpOZrHcY21fpg3fmIwXGfp6YLaseb8BYynYmYM +Wim0pgKayt19bjjwMZWCbb4rZ4ebK9uVubvvbW+GMj6PNaxkBR6ZVBXcQEvcO3buN3fcGh+ybqnH +Tnoqi2VHN4K5YljRMQXT/eK8TOmpvYmnG4hIycahOHABVwPR6ZaL4cRh26sGgm3kiIWI+qhA1/Wj +B5scH0pqg4zk2B7qedqMqxza4NcRpPmihw4snBpAE9yw0WFM2YfFBjmyVzt8AS+D2g== + + + WpABaLkl3HLPs4C9WHbLAI4UBuDW3reeX9AFyn3ukK7RFZz9GXpNXvH1fR3BQ73bVRBVYUYWn6dl +hTNoYuFMDR8LmxzQ/iftlj7FEys7ZLnf4pZmD7KSALI8bnENsuQtjr6gt5O9hHaDH8O5aLe4qdXt +7F0CVLvpzkNi50s41rtk9aOxc8nqPCSDY60Gb2EUO7tkwdRUG0lcfc9ukmMYl3Dq1r0hW0n6oRzP +tWJ5AfcGoINvCk0IRaoYVsv9WulkqoXfxxew89INjuHh7v1Sfh+IFmdfn44VWPhrIHY4V5Ss4psa +T8NYo0pn5npVGtCBtTNR5MkulGmI5RO9Ku0Fd1gfQ+MJ2I/HrX+BPrzmgzqKUNlingThiU4TXmy/ +pC7D9lNzpvMTRfjJ8mUBb/T4RC/3rCbkC9hQOqAdrdBbhAEcXgdYn8Oau0PMq4OT3qcTdVa6LMCO +TtA5ySG1LovnohJ18LAqqI7fgLMCz9wQg+WuU1FyHown7s3nbZzzXc1M2mlPRV0fQQJgVv5WM28r +tiys/K0QmIfNZ24vgU3jCyx9SIFWzV7k+VzD0RqS3kYjnoljOMvuQAxFtiYVKBJP9gLHu9yT7X0T +YJoTQm9CVHs+GETaRTSk1TjzKEx1JScMeRR86gs4b0MX4gYCo+Kez/gslAgYy7nrCpUq9TP1rZFi +eo427YUNHG3a0x/gueBoph6SPEBM5ntZjnatcDTJevWiweuBOXM0n8sTJAhscY4m78ryzWgFHA2s +mhlH87z3ARzvHM3gu8BwludoEMryZ68Ijs1pUDQXkk9xEr6AmTagEUI3IzsLWn10aK6jMNErbbwl +sHkMvnH4bNkDWEm+vAe/rdmQS80sD/b5+cxsM2MPvDc2C4DdbHhisr6AJZtdMPpBu5lvkC2tscQX +UVDAqumCmqw4jDMcd6q9JRTkhwFwlg+BQFAsDGrdybszHO2hu0v3sslpAgK2Cl81loVgfhGoXWil +IXgaW0a/VxFpY/NqurTFd3fr1pul8l1YSsNbT/q9vQ8WAltev3/6NpOFXqUYXDXvLi2jFINwltHv +VVBkWbi4FENwTPR7Myiy9WoBx600tJeFiMM8fS8tDTWy8FV/Tox6AU9XEo4E+Y9pHJYoKzXBU0oY +hqUu8DqxWRI1KqMuTt/u7pbxVev8/ADYsrtbNS6TvW0fa22DMVfqrrSSsBcriwisZdzVPrc5Pc0D +fN4kbDxXLsLpdEOypAgU2+O4vfSCKR+PGcRSPp5wZVe6EExU7q5tGZ5nHblmYe+DkVHuUOliczWn +q4u2BcAsz25kb4/bgHoAjN7eO6muwkMCMMZ7UzEsYhDhSr7GXflgMTCLzX5vG3yLKcIn+e9dDcol +RRg2lyiR8dZV5FmaPR2aWhbiGqBsuenHRmx4+boRvXkpbsSy9AvMmyuaZdDhm1uWz6FTSzFjBp0u +Y2jhHDr7DDrEk1eQQ2fZKcqgs8wW9JhDZ59Bp84WXCaHzj6DTqP1LZFDZ59Bp8kWXCKHzj6DziZb +0FMOnX0GHcoWXEEOnX07Mbd66Rw6w8bVZNDJlsWSOXT2GXRIH3POodMEJNtkmF0ES2batnUMvHUm +kC7YxcWQTD29BefA7V13+VIlnY28cDBsQa/9mjgH3Hp6Hwtaae9t6VRnfAV9wMbCeNrb1ZCrNldU +lvEhN8lgna/OjZMTRXvGZwfMPg7L3fyQr88pc871/HSeK+N+cY/0hPchWWQ+Oniu7IZkljIH5+Ip +ac4VrynqQkGU2B5vCVQzT6EgOH7MNBjEu9vYymmMbgZb2l91H9uyn5rPZbKbNhLSq2MQUTJY82U9 +xjjZzerYRmslOSW7Wdun9gcOKm5ZtA0G0ZimTmZIUZfNoMkUdgdMG4JFGk9smtS3U+ajO57VKHky +etGutDJ7m7R1CKWnFFOU+3bqMuvQ2bYHyDI7y5b1MaPrzMlx2BPGOjcJ+PbaNGh2gROrsqXaZZkF +ptKU9HlgjmqX6zy+uVMMvIc8vqZT/suWxmllnZpmnQRjr0obY+CDB59bVoPKmKVoWq+fYwy86yiC +dlnrwTRdP7d5fMLEKSfGjhi00ekQ2MoyRCfKyYdVZooXYM4U7x5jWgfrkhhzTBN1P0mFoy2EMa3j +l8rd3ce0gU4VXWC9SSaXO13W4PM1mlnyVr8y91va58vpQFgA6G1qJbIJiDfqhYT/vNnu7ooLY0+2 ++ByMvY+Ka2PPCoA+RnEBEE5Xo4B1lm/VcJcqt9AKvRLO8kVSacy3BUxxc3Yy+Gxd0jArzcKIM5C9 +XY6czyHN2cWRJ5qQ/ZUnPoN5ZaNHpqaGUP5QYeYC5aqTEStK/jry5t4xMZWwpuSQIGfgOtYZUTNT +ab6APnbkdscr+91SH/s68ubesU6z00cQLYynTwdPg09nSliTgEePjGZImnxkMCjKi/vDZkjazews +xWzwxLgdkn10unNSnN2Q9Hd3xHX+X5yStAqPzDHyyCwZpQY04W0XHhnxjM8hPWc7Fd9ZxiOjsveP +l/fIAAAhm+gOD2loi3hkDNmCy3tkYBqaziNjlZHqlJ/HePLImPr5j12k57hLzoEpemDDOVOyu/A9 +WKqD0CrLJ4qybB037kZZpg+vI1suiME+J3F8sppIBrguqcvgapw6YGqpkENMr5s0tAUD2NXyBSaQ +WXuXPKSPGUIXTLMFnfLqPAfNGiNUUV6dy3g927w6VeqoTaawsxP0xPaSKtXuVemWtqF6F8a7SOEz +l4JOynm3CkxaTT4c7GUVMXX2+XDe7x9bJB/OLAr6YrDqfLgl8iw85MPZRaiuLh8Oeq2X3IEu8uFM +bgS1TOJaPB9OEw0lfRNcdT6c/t5RnBG36nw4x1sCVpIPpzmxchFquVg+nN4WszrWgZlsy2fWQwG3 +sphIAEobE2mlW7qJibwZuYqJdNr70x69rBqQRwESy2ejIzhRp9V3CcdNHoklFKyPITgryOQyRDLY +xMA7czSYXGftEDPGO6tq2VhEPAe/dw0Rz8Fvh4XQbUJLb8/dzTLbUEk+UnkVlt2GAJjttTJmfMxy +G96P3W5DG20c4tubvWhKaKu5DRjB8bZ9LPKRAZyVJEIWEu6kmCMc6yuBLW7TsgqzNl4J7HgbmtYr +rbutMRw1+rBg8pn9xU6OBrWckUpuLhogopqz1cXCC2WkNjZfXSSRusxIbWw23bgMHFL9VpKR+vS9 +moxUCGcVGakwX2z5jFQIZRUZqRCOu2ugdSaxWVwf2iDWl6Z6DjIKx8TV127Du6W3oS4VzpyPrToV +DsXz20b0rCIVznRdVp4Kt7jfUosxe9vdg125RCqc+g4ilAz3S1LhTLwKvyAVztw/5tI+u7dTDNWs +QH1/sl3i06dlrKqbG+G1+lg+7mAWuQ30gqBYVx5FFw5kCMz6ZjuPOozhkmGvhwuqbPR7l0c4drfz +AlZuJvKUXpyTm/V5dU+W1+HohYPkHTURD8r+hVXjomb9iWuASlymzz/L/ZvGa2GrPS+WktuZl1I9 +fVHMJGZBwPlL9UP+HpUNLzwUJ5lshasf53PxVj6fS5zAIgS1sSSOAn3tkEWPkzYXyyzrDFpJYo7S +o3XemXCZulCTlzbZba91fqp2Pqs6ZT93A/sbI6sMO+b+zi7ZrZ2w7JQo1XN2GXaB8+5pw6rTN5tO +y7GkqlN9LlYqMlV54fTJbszdZ1WuTKhLAdsM2SW7kXFdp9p6fHsDqww7bmvrm5s/WSW7PdplnQ3s +M+xG9bplpzvVzmfbqtOOfT2+yzvrTotnj2VL9G4P6b1Xq04vtRl2aFXBhhVnjX6JdJ5y2W7PrB32 +KmhaMk9VVxCZ8AVuJ4rOKmeiiJ5JVlK6NO/rBaqd79hFyK1Wg40M8Vw0Z0QXO6PVpPY4R6jqvSbW +day+XQxJdS5mMyin4FSnOA9sva6ykpxZ2RGTO1VceJfsKsl58sI9FlyHSDpkQ6I7IT3E9TkVkbON +63NPTw5F5CznZ1b3zanYiNv5OdcacI10pzojurvUlqgf536/lDvWhYgsw13dFqCz9/Qukk23mB/G +azadmR0g1eJcXTady/thlsymM/MJ6vfL8tl0Zrl0i2Y+WmfTmfnizSPtl8mm06BF3LOm948tlU1n +BsrhhpAFsukWlMges+nMzmlkWbmybDqzXDq1vb+abDqzXDqXsT0esunMfO1SBfbVZdOZrS7y9K40 +m85MuVHHjq4mm84sl87itvklsumMQ/rcstaUFs2mM1NOfYFVZ9OZrZ9JNNSS2XR6UI41hRfKprPS +LVebTeceY8tk0+lA6c/EV5RNtxDGPGfT2eZYrSybzjy3etXZdGYAQC8rzqYzOy3RxcCvIJvOjD1o +rddVZNM5nIysKJvOWb6sIpvODBmKNr6qbDqnTK7VZNOZ5dJZ1uNb3gCMKQagpr6Yp6ubrKt4GYtU +6mtzuEx8+nbY7BrkMyOrWjaL16szDGkGT3lWXa/OWrtwh6dZJOgJTwqWNJGQMCfTUbFwSQKaBAWL +rGerQemG5JYVuKgupz2YWmhIEGNgUJ7KLtsNyTyQwpLD2ODJpuyyBcuEUkxrER2Sx1OdRURvJ8cO +hc3tPXNytSy7QndLl7lT3XPlUiVfpMydZXW5E1e5Si7L3FllcrlLpHMVIGEfn6wUulturcr3YzdV +Zmy9VK7K3Dl6FCFili5zJ+ow9oXuli5zh3PfHArduTs8Gp+s4J4r+vCatF9E93kWJysLURqfKCr3 +wrk8YGoHYbf0aXnKAwvUOcYeOtEnTKODxrOtB95VIp2biGafc4ahdRCH6/xC0ItN2KGHIDKIHUvX +n5aS3VXYAj1vBfX5RPDSVMs5m90NZXXeU74YLJjYpYmGAkTlEA/uOhoKgHKMH3MdDQWAuYvotg9s +RrxvJZmPyx+FwIqCNteBi6vvEo6r2q5mUFSRXbVV7EAExZDJbpop7JzLjoC5Sqy1qgGhT6ytDY2J +tbXh6m4FhMBWUsgY0RgYrRtmppZdlqism6HSsd6rXQz1rvFIF2biGSOobS1xqxjqzrS3kswU+eZj +75qEEVR1vqoKhuDFhfURseu9f+2pULXV6RssvLa0OoGh2EV1eoCzglsCMJxlq1VjKNImNLvh0Fus +6rWLRAZPJ7zhiMk2vHGRyODKA790hTspv9Kqxt0C29AkuGLRutXeKtzZZT4usQ0lQhMr3K2kUp5j +PpG7SnnL5hPJlfKW34Y2Fe60eUlu8kMWqXBnV+8V1rjzXuHO7a3mMPtp+cTap29FzbGyXl0n1gJg +zmqOz42ig2vTLZZYq898ZJf1H8H8wlPTdGhv91whOAvwTcMdERDOSvI5Twl3tpgjHOtcWF0Sk8/p +mglULs9LfrtZEpP6VBQyiKhhG6ZCDgvhwq8l1X1zmcbkJokpePCit0RVUsxNGpN2kg6+UwWUvC6W +aUypkKsMdVuzXd6VqZCbXekmiSl4MNQr34valXeekpisIohg7UQbSetNMbwTc3iXuA== + + + lV+nGJpclnh3j2tArCLHNR+3vlUM2i9eK9J5KveIUGmtj92v7mqqe3T6tqIc13vLq6m86zDNqady +jw6V8hIL5riq9qcchuEi69k5xxUMyXXWs12Oq+gBggtR5c37k1Q/mPFWOagXemQ+lzi+LWx1jmu+ +QOEwUqsfjN4iHPhVvkDZfaW7p1KbCqY3C1jwINeuyncs/tIk4Z0dXqk71eTD+QLTrZv7C7WrSluH +LZV/vLfIhwtbJ+FN5m8pUsuTdWl4xK5V7h+3tc1fhZ+tkvCeLDsFc9ksjWnLuRLlrYdry06DR834 +h1UdtrDSqZzJpSD4gqVUnWpT06ZBfkepI0jrshzDocPHvlmnvgBEsL7mnCYNr6HP/VOj92T/wqJT +bivAnBXeFB+sPiPu1abT8jZn3Wn5cuvBrFNU902oaFIr9Z1e2dURPLmx7rRYvC5pIrtAt9vwfVT+ +JSZhzncPEtrVt2hH5wnLdur8SuJtN5V1ATGSGs2KipgEc75n9EqnfFgjenu0wjNv4yeWBZ3LsEmA +VDaMToM0VcycAyddyGYA+0Cf2OToIbFOSTKGVlkOCVKy9aDyblKbnBObpquqzIIcug6VWdx6kgr2 +oVWWS2eozAI6qHkJQbPLutPdPLlEVppDhCbGks8dPekOvbzOT/Zaw7w7z1UWLYZkiNLS7xfXSPcU +peUL2A3K2k/sbUiAW1rHaYnjMcTG6thV8Sm9qz28LhprpixmSgDYRy6uvnbwwb4UV3V5431sw90N +hy6ykWzdy25PeV6Ky9xEq+QkGq6MWyjZzfzI2tO91i/FBT3L2ls0YRbgspfQmt0VZ5kv5mS1GO+K +szGAzP1j2qARkyPWRslTvQNrDlNamY3cKOk5zKKn3jjhzmofoxMr5/J1mpHp/fzOLjtUj8/Sq8J8 +GwIIesLEuz5iUfspeHBnfTjoLZHMUM9iibJs9plMnnKskp7uOVANSZf/0i7b+Y4dtXHNkFSh+uJp +tWrXekwF7G27SOVU33NlkwroVNLYYf2Uk/d22TlRxzUx6Ooam1aZ8QDMqYpOUJ9dawNMJ1WWw5hj +Lo/7SWpPLpfEmGM9HU8YqzJPFsAM6cJm2qGIsQWzAN3mALq+h8QqQcxVDqBNdLqLLEC3OYBGf7KX +LEC3OYDqGw69ZwG6zQFEXuuFswA1pGJjYerjYL1lAbrNAYQYWzwLUMGnPd/Q5lh5zQJ0mwMo28gL +ZQFaDMmQA6g+r8TjMc5q+aJ87iuyLVOUTzWXX1iUz+BV+CVF+Zwqsq2mKB/OGbFXUJYvyucLmGiF +Ky/KZ6yP/CuK8lnXR15lUT5X9SuXKcqn9irAQXGWgxJR5JQabF3Vb/m7oY5XcTeUy7p+ru6GWrqu +n2pqK7gbyqqun7c4pUXr+tlX9VvobiiTun72XiFzS9x7XT9z4rO9G2qBun7OlLyKun72kSGy52rJ +un5OmVwrcujaVvXzBTw5dC3r+tlPTee7WLiun2Yghqp+C1QAMa3rZz8hswjVRer6maYj2t1q7h4x +rjNlTe+CXqCun/3NX/KZ+JJ1/WwFXR5JsRXU9bN3C3u6gcqmrp+9qWsaBb1AXT+zNEll6y1Xj28F +Oe+e6vrZQ4F+/lXU9bM/UPG5hrNM4rs+I3XRun4mqqaqqp+6OgOxRF0/3TYktFX9NHd2eU5PIeS6 +fo55ryup62df1U+m5CXr+tkHXKsyUpeq66fkb5nRou6eq4Xr+tkjEGmwK6jrZ7PXpj16RfX4du2h +uK7H51BOznU9vqXq+slQTLeP12wOQ10/m7wHx2jbjte6fvaaPLzxYBV1/axk+I3xJHGx/C0X6rx0 +kui0DZ3q+tmfN2ujCBav66fFtt5aXLQen7cgDet6fCvYPnJVv+Xr8blJYnK6vcEYq+GtFJ8+I3W5 +un4ax7ahqh/OGFq+rp+cKmVXV3Tpun72ao4FjXmu62df1W/pW5vEun5L+vpc1vVzkfe6grp+9lX9 +PNfjWygLV8ctjXX9Fk+GV1X1U/WyVF0/oytZXdXP6pYzr3X97MO7dFJs4bp+9oFOOp/SwnX9TNZF +VdXP/l4493X9FvdbajHmPefJwq5coq6fwrjMqvotHD2oq+tnSxGqCiDL1fWzVwyx9bp8XT/7hFhR +Ii9d1087SX1VP4M+5vomK21dP2slCOswDjdZuazr50qHWbqun3oljQc4Ntm1FvvTvK6fvXCwzeJc +WUIslvsJE/HwYKejnV+bR3zo75X6xDcq6mQleGrt2rUPvNelLWqoSaIx5fQmfTBW58Fj35TYVUgj +IeMjBTFE4rzDyfg801ii1SnMfaOmnxtArBxvRB7PtonEXY/HjWA+1cb2afooToSGG4nW45ihJ5/H +pXT/OXl5vRuKDcLB3HeOqHycZbe+5zlu46nRpsGvt0yAFfYqO6fn31fsd+/+0Rfg2TjTEk5Ld/GT ++GSDrZaZt9xV7/qwXTvlbj/rnTP2+ybUed++zYaZwtdm/eqkl+rv3406h6Hh9yv/HZhkhtzZxu3Z +YXCbDpW5wPvj0VF4/rn1yIyeOilx76PczvR1vXazEY+8ZDaoj++byD4dzBCl3EmOKL23jokyt3M1 +mbwlQ5OpcHs03XrhmlO2+XghZ1rWIweJ2G2criY3pbS3r8Rk+jSCxeaSWzi32shDNPmlew/V12S2 +dTmGBrVcAhLWk5y/kYHdbKZ6bIYshAww3dkOXBd6e8NyriijMdQIdi62bh7q6e3hJFHaoZiP+Va/ +vdGGmaTHUnLoxjw6Zs5gvNrpEOUkbmRL9XqA2O60kb1/MdKq7GPd9gFTu8irkuYUf6tqaoCtmeEh +zQXyc1+g8FDq3KECmvnn8tUdd5Zvb2YSs/3jTGLa3islt3oXxdsM/QLQNkyX+zd3T9kKt9EEcG6+ +JbC4fGaIjPR4mMp4/5LZq25M0KyygxGk5OzJ7e1rpHhzV4G/wIQv+nGYtBvFZn2avZ8gy4lIzEIw +GuF1hjlxgo0HpV9kCPmOAUb4IfiT30VZv4DhHI3BnwdRxGG2gkCKPU7Ag3xc+rCUKBWpUwGArRCR +QjQwL4UqR0dkNPg5KLZ630kikebDaKBwcM/kbp7cy3cbCRK8OIioXjS28we+gPQqH1NeUbmH60Pp +xVFCeUFv731kpRfnpPziRURb+WBXeab0DOV+OR9VvYJ9i3DKYNcDTOyCmT5F4JzD1PP0CzDA8hWJ +bsIhK4dXNJju5a5qus2PCMTsJUD5wahHtrb5lHwuBlghJK8c2YodkLBRAuYtDcjW4RFE2yUpfnN5 +jcDCpNb9LdhzBOYWI7G0TYVjDNT+6zGlUyp8mNnDvezBA++rXD/+sZu9aL1XCydHGzWFJOVjgbzW +cA1oDc4cFa6U9s3gAUpeFOJl9UCGmGNnF9ud8vOD8JGtzbe7xYf2BQFnRSLqxZT8Rj3PXzLiaty/ +0BJ51RnV1AuHfEvaB7cxhECqcJmHEvA2IZH9LYDdfIa12W5JUd1lb0XtYgR/0/IvBoMo7g048OeD +CPG1VYJL8pCQvn4g5F+kajRv1EtXGs0DjV74AuKrQm9b3Ae9LxbPRStptWemOxo2I3MBCzYDZCVk +NDo2k3o+H4WKt7nT41y4P4E5/VwlVyTidSOb0VfpDSJqA1xAQDe6huVzMcAtxR1/14tgkszdvUzB +rDbjie7mxQ69nRzMCCIUn4rTBcwFxU0j9yT4kwmjrGCy+JSBf6bARtr+SkO+EVWt/hP45gbSRCWO +1CAYqRJHhjtZfolDw7ySsHDBVAiZIHdU7pQ0exKCoaLfZJQYvvkC0kKd7OJ9F80HmvIzcf8CHQ5u +5xOw8PxNJf/Wy7Y1TKhKEGzzBC7EiYoOyHLuG2ocH+cIY2egg/sR4sRw6k9ZUS0BrAc/w8wVMhws +aWzlkOKcNY20l5YxpD2Dr06hmpMBAlyYY71mhx2VVModeraZz26Cz65msPGN5u4DSVMKq0FEu0Ud +iEh++7AoC+gKFUre04rKhp5tbqYPy0Q7MCxMJgejXbUKAfQDdK9CKaCAIDqbbEIH4u7uIiuD6IY0 +W6Xch0gN4fUrPu3F6J29RxLguBCFlCPZlegppLE4fvo8fYVb/GkqsZnXmQbzW0GxzDH1cSlrSs+K +koQKTENVcxO+uEe4U+nJQUVp2c3c7jYk3eSAktQSfD8DEH+bTFlfbBkWwpXWZb4BO93AK8BMH3eg +FCu9bkh3ZCS3xPH0r8/Uyvt9dChiLBeGTg98KUTlOb75dQ3wFCmBTuMxtMGNt0VALxwYWTkiIqEw +rclIeFIjYf54LiNBd2NHRIWCxwndVN3dIaPAFwjnH9ovEhLAeNRI4CeWSJBQsLutQsFh/nukQsFh +qDBBKACULHYr1f9GS+KMBMCEegncKc2f90QUUHPSjA7wrRr3WiQkFMK+2xglihgJk9z9o4KEUHP7 +6smCDsTraOWq5YCPmZGSLYiId1rURg5L5wDKKDyPIWYGAK2LaxDxBbeUEp8cJpZcjag1TSPOL43C +hqajUQsQrvCAOH807mIadOYyFBJBNA7PtWMg7ceA7Upb/hSlJBDclrIa083ySV7TLrGrtIOl0i8s +6ryDxQktS2Ph5WksseAYVDRGLktj4eVpbNcShAsAmMZiLshUA0I/DQdUijRmiwliSYpIRHwBF5iw +BeGG8/kCtiCsUOlqNSCAuNrbsxBRJVwTNpL7piCIZaeh2hm+wGLToDyNAe19/Sho5/1ZYQ5O8xE8 +hkma1Vz69UbpZYAikd1igop6H4OOW1LLEhUVN6MIT9yScqPcmMkhhVtSy25xitT+Sen4GEWLxkKo +XQcGaWaKPTLIKlM0/XT5NoStCMWmK76k9kWz77wzFG3bu16Meq20o0Si8R1D1jC8I2L6GYNfx5EN +Qh9ebyLbLygdJ24FUdAPMoWxd002hbFvLXhw9Q3+zMTwn8/TDjIUg/T2/v5b6TX8iOq/vGQ+ZHM1 +JHv9nol2KJSS7NPUrsqxpppBOhNVudWCh9W09KIUV16g+y5kFwwwdlUet8ObcU7ylKXQNMLqnsuZ +iMqtpuq5XFIcei+oJjTywlUTolehfE5A90AEZ6YA45nCllzzJdCQpnsZwY6z5piEZH8Zk9XrbSqY +DsGkxsu46Fvj8pByLglcXW5Ctirn6IEItvXwSIo+0ftSJHFa60F+UMfmPxXmUm2p03oc90KEtwWC +6tcCxWgy/PL/13btbWnsTPwT7HdYalWuu5vs3VtVEKFFpSIKaEWQFS0KyuVt+8/57O9Mkr2A1HKk +5/GxTYZlNpnMJfnN7Lq7qZ1/DA/eTMf8ozdHn17VaQWn9zN1AY7z+Em/5ahFOBJ1ZbSVqm4OrZ2q +cbxnf+vEBRTXqMSE/tYvabAaN6F60cSk0wsRkot0FHErbKOruFAE2NYoEg4D5W5PTNF6rFLRmlxe +szQgPUi0mqJFuyYyMBkD0LFmYxc5NhR8L8qANh9LGv92c3IqeN8kavcBsEajiNtm5w== + + + e/CBEVhBO5hLg6WWIifxNY4RcG3brsc50HVwtccsPunjepVncQkYdkog50Y8RM4DsHudYUpYdcx3 +F4UE0zwsZ8HIUEgF4A8Y9m7sGxMw5kfT7PV9YGFbRfWhNlY4VPWQ3kgx76R/3Dz4PO+pHWkVjO/4 +C9fa4B/8qCrOyDNAO0PyZzB2hjjtZJmHiYOHaff2Hz/08yR9bXtMnmwuX7QQ95qxeFTOIyZbcGYO +XyZyWI07DPdCwxUQ2mHXQIkdKyJ9B5r6z47kENuUHarZsno6efSGJ8OH7kNfTkubkrpXJKTa7wzy +Q887836Oc4PbyZPXH8sbsrpXyRaLjpnzbgcdT2Y1KOaNHcEYOLQmymuimcipuhuOQufu3MNeYeV0 +u5W70+o7kaocdsRffz57iaXvv8PuJJa6VVZj6WbnMpam+UosXhilsVvnMEQws9f5sBtQEiu5kvOG ++5OD1FHpYgZAZ9HSvTk73JZWDy72vdNdddTdUgt7jS+5Rv68squOtQFDKmbBQT7TIFk5J7c5HNLx +WiyxdWzEMur6OeY4czCXjzlHjaUTu7tI/RxLff1wjPM7xg8+xTJ7eieWPqoVYsmXlSHqvyMQpPwE +C+VoSkDDYf4m32z6NlgeMMOQuAmRdLeLyO75i/CxCBLjtwOQWGVdrESLi9Z3LymsCLQnakWsuxFH +ayxkhO/AF3sIFnfVjbGPOBcjkUortMauH8IWz0CF+Sdp9b/LQIX5J456L56Bwi5sLWLQLe+GvJsC +ZS/n2ZYhCY7N22eKhll4h1VTlRyw/xNY2vKJirE2DTd4+QjdKmOb5Iujli/1IB6mIrmozpoCAale +CuP4jX8XpuwNkFhObW2tbXT769X81oHxfQYGxXqEr9HiKr/CKqgFcGGE/WzIcR4//mzDwhz99xgz +jonPzlfXOczvrntnuWJnOyasqV4jQZqJTuVvEo/NFT9otoxg6q2oerVPmD9NC5fbrqpC7ds1jbRL +xQS0YLvB40r7mu64RQpr1W5hrYNodwzGQixt75RxzLACKOjW/G1S71LzW9ehtrWjW7leR498cB3T +mzAXFt1vjl5W2Vym6zGy0Roq0Nqomwm8wJ/dDHpLcDToTbZEWcVO7xP3NemX55P5bibwY8zOO2vq +moDxeTg+6ovpnnhJf5+9vl1JivQ2uCa27UZ11sS2++KgxWMtOBeMQIU4D8zeqIfnrUJSuBTyQaW5 +zGWKpbeDsJ4RzwCzHDeWyNTE/uvwS0I8g2bm1fllguB/fIXEOlO/2BQ8gxHHVJgys0fnOfX4zAad +h2Z+FgBfEySalGh2/Tmr5T5vDbTXXgfii0gzbSdZho3nolJs3fip5/CaYd3HGRGpnzfUhXOSnPer +JzuCd3/wZQz1CUs/htvq9/CIOC+xg2+L/uondoapmdzQcLj1qRLFPrTiVVqZZnG/U20mD4IkVnUm +iYW0lWgKq0E/z6SwtIOtE86AZ7y+vmYxmWJRWCtETcWorPvxGvOm6WOKrxVFfSqksKUENJXR2LsL +d0Br05UX3F8OuZuB4NiY2bS+/1gcf2I1jigTkbWKiUzO5tNpkD6qv5E+Qsv5c/pIZIjn5U74u1UX +zJ3MyZxEMExp9V0QB3upIRfBdVQELKMnRNAIRQBzwfFEhYAb/T8IobV1HIpAv3wkTigC3GcrM2nE +8N3riwhhEaT/bTya/VHkt3Nob6YR8Q/F+VK8mlGkBTOR+HepltBF/6mD341isTE0h28z4OvyJov2 +aDmTOryfBFb5ztUoXz0voNPgLSMsZnS63PyNWSwqyrI3Cr3luxKzO+VB7M9jqPvVh/NHMfQrF4z6 +U8hCKxzVb6fS4FeB/tYjC6/lvxVOZ3SMvcZgGR2r9JfWMW+85BgeY0vr2Hl/aR2rD/6V633NoD0M +dOwNFWm8NY37hUX5Wx3rTZZbjXozYq5cYvMk8SaL9r/zfBjFZll4w+VWo34/mlEpIbHFlaree4di +T72Paafenyw5jWFsnmXA+WXxaUw+vHMMwT65sbLyJ/uko6uQRWz9/L4SHUO7/fsYEInIb0mi7b0s +Mwb0lu37JZWq3Rst6y3b/fEfXd2bcaj9Monsk99l4u1JLNq9Xfkw1V1bYUcFjhRjOeKnFKIT1gxC +onnjXYdtMMMzXeTY1/r4dMWP8uvbddOvwmyyI2PGr3q9GvFzZVC0ilC1aMU5mgdH4eT0UZidjNOi +m1XYuVkJvqYGAPtVCAejxOBgG0Hc/l4GKsw/sbv8RxmoMP8kTWegEAY7rFKGikWBnnI2xYAzAfSU +ixn/kDpJilNguaRwbA3fdQ7dUw13/wT+6eC6qOUaZ6t/OusrorT7o5Lwc1FFtpapKFJYP1HYXfR9 +R3c2vevEXfbeyp/sPzorTgS65jAtHLzFc+avUgjh6b1+qv4rjvP4SdMcq1rI0apub2T3qmubN9l7 ++8vz3tle/4JDcfuXyWuRaLqtBRXTZ3r47EJ0dduldASDbQkAsn3Kn23AJ9wTvNX6cM4BuBAaovsN +vYC5kTpLtLCWWNh21+TYGkdoe1WF1ziSoOo5E6SFMlFctteiEWAtggj3uoaPHzVMMZeatsKOZiGs +xp82nFtgnfp75dUMVZhfYP0Xy6ul1d8WWP/F8mqei5pbYJ16T3n16J8daRNUqkhI86DfieaYpNVV +oFS88eQZLzCb+173oV9q/fKGEpH5jwY/RLZlQp3gV5NNJJfaUrw/GDdzgx/9x0Gr43UScqkvrTbV +veE493A7fhj0W8Nf8gaQiKzuDwaPcnyvWMlfyAc/nwfDscxuJZ8N5GylksAE15vXnT+MHtqP3tT1 +au2oVC3m5A2ZDeWnmZ8aziYyIloTBgRX8a+AMJqSJu/Bb+2HNIEfIuegcyJpimFTqluypmiabRi8 +oWk6iTZMw9RcEILiUNswkeJamu0Ycq0laUxiFH5rv6DzGRrfgfRDNuQj+fKbJnfwrqcSpYruGCBN +Q7EdTZefkEIMy5SJruiWSWVKFGrptmwrxKS6IdclYsG1BCm65piuXJIoXGvqJo6JwHgpkHSiEN2x +ZUtxCHwRLzIV1wAGluK6lLicQh2d4q1sDSaAfd0wcDCWQy35HK8gLgGKqVimbcswOIvC2Cwg6448 +O/qsdDd/1W1ZLfbHcrxyftis3LeevbNfz15kFZITEAfIXnEsEDhOxDFcy3WhYTuuibdgCqihbIkF +U7dcCgMAcYHUDVMHiklxDjArmLlmmrKrEEcH8UDfgcXEWZqG7uKgNYPgmB1Dc2DMM4TSXAKxXZuJ +wXFMZOFa1EU5aMSyZJA/EwtI2HVNZDlNAA4GqBRciRSb2ihqw8JpAUfisL7pMMnbmkaRwzSBLZYF +X4RZQJCBWcASwHRglhq1YVWhTy24FSiFDiJDDjMU0AmKWgQhyhY6g2IB841KdKZzx2wCr3XQ5uFm +FKzhSdI1hdomKpPhoObx8aGiWQrMC5SIUUzXRBV0Lcc2pym2BpM2FFc3mapbtuVg38HBof6BrLLS +DKHECQ4j2KiwqHc2WymXsO/DWCgKVTNtwWCKwjhQlyCBuHhLHdSHKziFW0VWknWjK8kITG5MvZAC +VoO6YLuGyzgSorO+DnQcIgUrZfo1RSm9svrS1DXEEToHJkCYH4AGqrGluQauILVdPdonDmFDnaEw +UzDBVcjoMCyC9yFgJxbcB1aAwkdCD6JrO49yJyWr7zPsqvCEmu8J4b+OZMnxhFy7YJ9OEUr7PP5A +NGKuPpOB0FRudb2zYevhEaJRd9T6nye3+uDjW2PvGT6Ru0NvNB4MPXl0P/iBFPiKfznEtZO89H/U +CLNL + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/originals/SVG_Right_overlays/Queue_downloaded_right.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/originals/SVG_Right_overlays/Queue_downloaded_right.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,1598 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + + + + + + + + + + + + eJzsvWtzHElyIPgL8j/gPshsxu4IZcYzY27tzOoFnW6p0dz0jKQ12Vobpxvq4S5B9rHZ0s39+vN3 +eGQVSJAsraRZII0A6Ijy9PCI8PBXePzF//Kbb17svn/3h/sX8Xa+mf7iLw7v7199ePf+VzcEvfnr +N29+/unDewT94re/vFnS7QyNdn+9fisN/+7+/U+v3739Ff2J/niHn/7FN6/+cH//9tXN7qc3rx5+ +efOLX8Jffvf6w5t7+Nv//fP9z/fffv/uX96+effq+/vvv33/+oc/frj96Z9/+KVSACiPrz5A42X5 +yzn8ZZiX+WZuv8oVG7x6+8+vfvrp9f+Hfy5xjQDbv/v57fev3/6wf/f/IvBmvokBfsJf/s/Xv73/ +6fE/H9999/PD/dsPv3n/7rv7n346vHvz7v1Pv7o5/OnV25u/efUD/OXVzX+5f/Pm3b/c7N+8+u6/ +T9D5/O3d6zf30M+HVx9uFur17q+X8O3+59dvvv/1zw9/uAcOxFIRHL8llL//CXABWvwdwfXbv34A +yDf3Hz4AWfBC5Nzhb/7Lfz4Au989UDsA3sy3y80CP3/xm92vf/e3vz7B69rNAdn0v9Jf4X/zbcpD +i7Bk3yQUxIA/XJOhRYTP37YBR6zc4Ld/tfecIZKw4T/+9v6H1zQxYKT+6y+lp+/f/fjw6v1//4mb +AYtj4L/87v7hxzcwnsL/23yzZPymv0kr4Cq1eBHXevMilAh/jq3chGZt+njd//Pr+3/51c2v3729 +50HZvf/wDU+KlOaZv/Nffvvzm/v3v3/7+gNQVhDUeFT+5t3392+gvX3+7s2rH37STi79Ozf43av3 +P9x/gOn07s3PH2jSr/oGGPWXr/50j1Nn4Rf87Y/3b3/37u+Ixhd1uY0R2Jwb/4QhiWW9KRFGd6VX +pBl6Od/M7t008owekSEqfQcug9/A/PlbWDmv3/5KKKzf/tX719/3OVXDzcrfqBO3q/vX9B9TCx3/ +8OH+rVAPc/nwN25uzrd/8w288fT2+8O7B+T+T7jkYAa8hcnx5t0P/Df7nf4CH//5R6ae/v8tDNRv +3r9+izinX9Nf1m9/8+Zn+NNfvX/3849//faf3k2/YKnzu/evvoNmN3/7h/92/90HkB4C6L998/Pr +D/e3r17/+MuPIvrNm1dvX72/ITh8mIEvX/8z/OUVkHLDH4O/dNinkR7v/wmWfv8sQ09v//n+zbsf +7zvcIK/efn/z96/e//hp1DAM7x0G+q/+fEJvX334I0ip+7ff/2Rk8X/HjjLs0/i++Q4nxfub/fuf +f/rjze/evXtjaMc/GXYBExTb//t4x2/oA2//9i0z6PxN0mD7JhAI/+7eAq0ffwP88d8z9sOrN29e +//D+1Y9/fP3dpRdc+Lu9if/2ORPrTw9/ePfm9U8PfT45yG9evf/w+rs399/86acP9w8fw4bc+KfX +b7+HiUhCp1P77uFHVCtuvvnjqx/vCeeHP95Ry28MYf4WBKMXfS9efEQmhnizf+v+/lfvX33/GsQt +6Ez7Nz/f3/wW/vvqzY2CfzldBoO4B0TfT/84/adpxq9ljnOa81zhWec27+b9fJxP892ygLYQl7Tk +pSx1actu2S+H5bicwhyWEEIKJVR41tDCLuzDYQrHcAp3cY5LDLiXxRIr6GAt7uI+HuA5xlO8S3Na +UoQnw1NSTS3t0j4d0jGd0l0GWvKSQ445TTnnAk/Na255l/f5kE/5rsxlKaABFPg0/LlM/4d2pn8t +9m+5+D/UGoN9j/IPSCN2xDlPxBX8p9+L/EvyWwGOFeCZfl+Jf/ivud928G8P33cT/TgQew/wD5nM +34HZwG4kDr6gM6C6wVdc+i//abq7uzvdHe8Od/u73V2DZ72rd+Uu36W7eBfulrv5dHc6nY6nw2l/ +2p3aaT3VUznlUzrFUzgt8C74+PF0PB4Px/1xNx3bcT3WYznmYzrGYzguQNbd4XQ4Hg6H/WF3aIf1 +UA/lkA8Jhi4cFiD9bn/aH/eH/X6/27f9uq/7ss/7tI/7MO0X6N/d7rQ77g67/W63a7t1V3dll3dp +F3dhtwAr7mis7u6oO9ihI3UKu4Ud21nnsHuVuoidxG4m6ip2FrsLHcYHkZxOE/Uc+36g/iMHkAeN ++ICcQF4gNzJxBHmCXEG+4DMbd5A/8DUBk5BNwCh4GvFqJX4hx5BnyLXUO3P+dXric9w+0zlIePSU +Z3/+TBeAu/MHOpNu/uLb/XvoU8GvSs8KT5MHBrPs6YF5AXxApt5VEh0VRAQIg0hPqrBk4cP8tdY2 +1QbPru4rTClkIozI3UorZl3gARmygqBY0worfaV3rnXFr7bCLFphqq0HGoITTo02T7C0QCS10GJL +DYQDkFcbtG6t7eiB+dlgDuPY0USAWQWLEIQYzMQA8zHCrEwwN7FTQBkNJa4/WoeBnoVEID8JRGEE +UZjpN/yeQCxmego9yIGCnSFh2eDnbqJf9vhS+L6X7wd6YL3B9xNKU5zNgeQQvSsG/AIJChIWH5CF +IGVB4IV1ImHbSODuAixKkLhH+H6C77QwQPai9F1A+iIGFLMgSGFM0BauJI1X6HsDeUwS+RFpg9zi +5UP8Qz4iP5GvjbiM41mI7wlGIAJF2NUZBweG6AiDdYAh22FTGMQ60YhmGN9IY72AvLzDVQkz4QCz +AkegwUSpMGkyTJ8EpAZg6AzLHyfZEabbHkaqAZoKUzNPIPcT7AABOD+DfDjBijzA/rADklacfLBr +ZNhfIjBvAZF9B4v+CFvMHga9pRXeUGDzScCfACM5R5ZLuKbpifYEeWi8jjM/sthE3hxIWBz4a0/P +jp42IeMOxIwDzXxcNiBQMwnVRIIVRWsg8YrPTEL2jgQtitojiVsUuPi1m0juNpK9KH0rr0aQwSiF +E0likMXw0EzbzySSUSijWD6SaEbhjOIZBXRjCXZBGlx42lOfafjv+llPvfRMF8HliU8+f7qs+0eb +9jcf+YWfAP/KTZ5va4sVrGZAAKbvt1+OYP8TvD3NID4DNi2p1XgRSwkwkdEkX2FpU5u2zrDqFGO9 +jW2JNzHftpw7XddHTRTD0lrQUXYbQAVb00W0IdU5I9oCSmIiJxLoS9BY0C63qG7dgCrWyb0yXqB1 +fzRFWzXgyyr03avv728+vLv5+z+iGj9t/g9DFVhpRkoyiCD6JVZQUc/FJ5DUwpLr+AtSOU46xHOj +eC52lj8+/oJ4bCKN/LseShrmr0Q3A7qab65HnyH8nIH9q/f392+9VbQBEFaxh0yIJhOi80aEqvg0 +Aep03ERaRSAdYyZdVzbQg9s6+7YJGydJX9iicbOeYfvGbXwPG3uD/T6THrCAboB6wg62V1Q3Iugn +d7ADoSmBlkiYz762ltB5A5L5XYJmUbDBMrsLol4HtEgGJRuti5Pp2fvBygDNehKVehlMjSNtjfSd +jbQm9lIWuwpNrSiGmD6f8fW0vpL1iPYjW5AH0BXQELgTS5JtSbMmRfNdRePdaLuo705O2U2k7BZS +dldUdVHPpbc67ZR100Za6YH0UdZFA2mhmTTQFWbIDubVAebZHcy6BeZfhJmYgYAKm33DvX8PqsAR +eH8HisICSkMEFSIDdRUUDN7LTQFcSAFEMxy/kqmC1FVW00kZRPO8kYm+IzNdFEMy1uGZcFgjGV6J +xiuR6suaKeL0ZoPryE6WCS6YIy2eO+rWLF0L9CZebJnnxkqW8pE8D5HU6pU05iNMx0B6cBVPg7oZ +sHdshNG05C+YqjxtaQIvMp1JOSYbksadHtQsLrgO+hfPR3YQROp9NssfqKUPk07KWmlBXwWppayY +LtiSlFNWT1FBZRUVlFT68Edt5S46uuBIrGvzUO9Ik8dnFe2+yvDiQPOQ8xdOBJ4U0A8/YsJGYqRY +CqtMhv3gr8ERT+axAUWevDaj3wbGbCLHTYR2mbRwXnl91Y1rrq83tjLZvhxsy4lMy2CrrRuWvNp2 +W6tS7Eq2KtmmVKsSP7JOZFSqWXkgs5KcBGhW0sN2ZSDOJrMuC63iKlYmrma2NPfTmampD5ucs5id +bHiy6cnGJxug/iEOTPLjo1PzC7/+XBEu9nMxx97Ce8tEfr0o/j2Sj2776b8V25YqbVFFFnp1/yfX +3sR+CxofWhNFVsPerQRcBtm5Lm3Tcc7LItsMT3qY8jDdYc7z1pJkS2k2vU80rYNNaXaR4ExGW/so +M1jnruw7E03Ync3Qk8xJ3nyybT472XyOJK3vyHoMIqF5C6owzXdogu7JIqVtCDaihazXSNZsIRt3 +Jat3R4Ywfp3QWCbDeSFTGreVTG40XLPrdFzJw7YXXeEIovwOXXKkSwR60GWH7COpQO48XrO0sZAy +sldj/HTkzeDoXRtg2u/NkacuvCTm/SIG/UmMeHZ+qvuziK0exUZnJ+hpMsN8J/Z4FW9oHtXHjeq4 +E2HP4r4rjmFiqY96I/lejiL9R69L2XhdRr/LiVxkB3KX7SZzv6wwUdj/kmnqRPPCLDiTyZpmX8yR +ptpePDI7kncr+WUq2Dyk5mRz0ERy0gRy1CyySnhnPYnT5kiOG37EU1F29rSJpSrro+bMdb7c/eDL +VU9u9+WqJ7f7cmf15U7Hk7lz1ZfbvbnNvLndn5ud52fw+LC3Z3LOnguungt+nnNPz+DrmdDZM7h7 +vMPHOX3oac7vo74f9f7wrMuj/RLNFRScQ2hRm8bsGn1Ow0OcmuQHjs9nBgUsLPBYVGDaBgZE3dkq +PKby0CQ/iXORXYs6s8mvONGkXmw6H20iN53ANHOjuhbFuXg056K6FysrcpPT5M71uJ24GldyNaKz +kd2N6HAklyM5HdnteKQZsJ/I+8j+R/RAog+ykEqVyBMZyRsZSNli0wjVbp7gPC95Eung7lgDHBz3 +JhTmQSgcVCg4vlXzyaYzeWDsm0QIqBjw61/X/jy4aT0vxVnrGTld4KPnYhKnbSDXuufhXpy3bWBe +mroX1zjGvNqbgryKapxNJWaFGG3uu80+cZCdYh12iacHxzahsYkWwfyp0Ji42/vs7wp/n/sHFus6 +eOpOV2f6ON95totspvHBsdmRyF1tVEIJk7jQ+4g0Nxo8FuxAP9Eo6BS2yTsykPTxPSssFuVZNvGd +aqrLqITfiQKuyjeQMonerRp3V2S8KhM28ZzVmaHOBMWBmMz+VN2GtZuV5OuOZO6B5PBJLO3ZlBy2 +t7MpOqjq7CbTdXBvwD1CtZ2u7yTaYEznEZUHpSu8hwUsK0387E15Ogjao0Ub7kyd0pfoi4JFLTA2 +Ke/U9+q7q4QyV9kImYqdbJCshKkidpRN9MQ76p3oZaqbdf0syDac5MnyFKexda1tZfNooh+7QYlz +apw9/cuCpmzgswYeRQevpoUfNnp4GjTxvZqiThPPXRefRBk/SmxTtfFs+vjOpvfdoxr5XqY0hSo3 +KvngCrrkDBrdQaqRq0soTs4rtMqU1QnLjqHFNPLsdHKdWAe/YUjI0mV3SH7HIvHHQg== + + + GR6rhRyP7H0ZHAeJHAfkOpgk22NPE/EkfiP1H3QPAo+W+hCONGI9+2MxN4LLAanixdubP8F7FIJ5 +8bIN5zpErdmvcJzUjSdB60U2MvXmqY/BexmaxK93TrqJfKt3kwtkazC7ux7GkLY+qwS31ROxW/f9 +mVbRJWWl6rIZAmXirOgui8UcF/0R99BE3wYxTRk8EWR7IXIpf8d51TR1R91Ad+L6YyeQLrW+0MJk +bp/ytHUGA3K0kcAx8H5U9KEKo8ctpG8g+DWsM+l+Em9NzwZg98xxcivtse1i71acbBfmqcxmB8uy +m2SzkI3iwlahm4XfLtw69DsGivRp2DZ040hu8yhkr2xF+M6e/SjGJ3G8u3F3HvydePDNhy/21CUn +/n6wn6ulwMRJ1CO1lE6DGd0N6SrmkJrS3ZjWULdYPJMZ1KNJraHt87D2JqQtxrWa13mywIwLzXwk +vcEnOBQfrVGTe2Kbe1Cx1fL2ivZO1req21WkQDZDnE1xMV1UA19EnMwW6dbt82jPwZ798LCE2k30 +jcxqH1Mfw+E9o0qzqjSzSsI+FvhxoZ/J5VkdbM/WPby5nKturVdTA7LLwBLbfTLzPbiErEX1DJcC +dXIW/dHs+m7bi30/yVJo9qz2dA4We7J70oUEEJjhwT2Le+b+bNKwTsNzHJ/pcP61P3t2jzzt/CHd +kcMg5zl/lvH3SMLfR62aSTwUnzbwt9bNaN+YjT+ZX0uXmpo5acgi6p4sNVm35urCds/ksoj25rGq +zlSNg5nqTf69mUPV4jdpuhDA4fwiH8KRII7lGqkDwLsAxAkwiQ17krlFvgCxZtmeZYcAW7Vq2bJt +lc09kLqTYBrDbphMADSAXevj6GsJy+oBqa6JfoGtM9CpnsAZFBz4D+EWdaAxoeC6aCmpoC4zNMBm +c8qN0k1Ka5QLQKY5HjlKeW74kgwjEzAFYGHclqLQ4m2AmdAJvSpWyXEJMDMRQWiACzGGNi956Puy +1IKQokwI2PWe53NTwm2EeeJTXK6JlihdVsA5IAilAIph2DL0FdnRCDmd82Fssd3itnYTEyYAOUqv +i5Yo/frplMotpQgtyJwUrjlTt6g5BWatccybWsKaBq408ifhLzXkRCM6I1uUEfUW3oBpS0tzmTDX +xfs5CTEvX7+9p2NPlhGzhfRsp80RAYyG8QGBgx0QwOMBdTAg7+R4QKSQfenHA9BwnHrcfmNhnMS+ +iJuQ2iVj3gXVpnwS+2JrXRzOTHi1Lc5NeOefmiz5uG0t+cE11e0M75vat7OM4+mixaE2R8+VOHRb +32VKnOVKoJ9fXVZqirDjaicBA+e8MpukWyVqmSSJTpTDivoDu69OEqRjh1UhC2MnDiqZCkEmQ9Ys +CJkQfGZkllMj/dzISnap8y7oBJkkxTmLi8HNEneGJA2nSLZZCcF7fyazSZ/k/rlomK4u54c8BSfz +FASX7VPPcg9OlnvQ89nVKWTTadq6O92sCptsg202+5DLrkkFk0tmzxtr1tuzJ+dBCs6a3Xo+jxNF +dCPMC7RX0U49krMx0ISox/apqTBOhtkdIurTQdPgjzIZ5mkQGONk6N6mxSWqFPU32ZQYJsX0iE9w +nBbbibHfROl7YlieLuSpjCJm2aSoDAlhW6fROk9buWMzxYuey5Pl4nSZXFbK2dmHwU/eJ8vo+HCe +cnR7YOQC5wjODhQqJwn2J5kc7c8nQaXnHoZHsr2qneaic1znM5zT1c4PyUVzoUriGk1k3f5w+h4m +8q8tJMpw32MZdgfTNNJeh/lTR5iSC0xFTKBt6jqDORdhrq0wvw71BJMpwiSqGCI6rCegNsLcqDAd +DjABFhj2QnkeR5AEASRApXE9wfYQaER3mKrhlvoKkv9wPIEVHiZYOYXSLQ7ohb9bKJWuwIzcoePq +zk51+SNqX3JAbTBWp2seT0Mzdfr08bSPJd2ZYWrx5+liHE6PtPg4nD/OcnaYpZ9kmS4cZfnMgywU +/uTgZ4vrZHHPaBHPEx0Z4jzjlU4WZZiklG1MZ5FOlHG8p5zjlQ418aEnPBAFy+mOzi0eKAW5p/Mm +yq9aNLv4eSo8T4XnqfA8FdxUcO6qtcwz+RZAOyutkU3ecpJaJGR/Xjrf8nkfkzMsn3cy62tOdX3m +yZRv3v3TB64bdPN3r394e/+BDh5dgvYz+8qDSXkwKQ+mZZrpETY/veUTBwTPyZT1FrTOdFPjLSi2 +4bNG5tLnaYie8tnbkpeQsDZOXPAD8WZdb2sM7fNIeBzN0ylp+ctm5vjJz5kov3/79tXD/fc3Pwjo +BlYczJSLYJqO4rvZVF+4aDNfdLE8YjJPZ/ZytTMy/jT4ssmZGLMmXN7EZCHd4lInnMvFhXW7y6Wa +WXyWCrR1teSzXKAhvCtuFjKKHzdmfO2I83oRUf5psYheNKJgDYluPVSrBsFG8o48PAcyJXo5CC4G +Qf/gnXdyGB3Pw+C/MIHIDXYCXc+e87lzPHVe+dw52SE7Etf9kPnJDpgHOWQO4n2i0+WFztZongdn +euzJ/uaj5ZjfA3sEHR/RM0X5kaPj19iS/Y48XWNL9jvydI0t2e/I05dvyf3s0rZwxbZsxbZoxbZk +hatXMQ0Jzq5cxZDaPFv0r+c074egvYbty+Qi9y52P0Tv+zH13VkAfxvCp1oh54fTPxHH50R51inH +IhaXzpqfHxLPm8h3j33HaRP+diHwsyC45qcfL0bCJRY+uWB4D4efB8R7SHwIirukdhnvaQyLu8D4 +6VOB8VH1gqXf1vwxpQY2saWVeeXYFMgb/AVDJ+milnQthBx1ayC/EsXx1nm5jCzAGqdT4kV/kTDU +ZaXxeii/bs8O68U9G8B+z+axJT16b5vFTtK8KClEziKpa+rSUdrQD0FNzrf1WSdr/delvZF9vxwR +ongQbVTJlYriSJCWiWqSPIiOXPJ+TaSa7CXyE6gcVC8GBQoJqSM93rMjLxi7Zu34FFFmnsloyVb9 +CJJPsjpZ3uwyJOf29FzSTyYJe+wskUrzYO9c8qsmvWrCq090XU9tzLr6rOpAl8r/bAoBTZ9T/+ex +oj8sSr/QDL9ghdOGP339ji9VSVzS+cGS/1fbSXUv1d1UTVw1cjnrv5idGyc2dc3YVXNXDV41edXo +VbNXDV8yfTeFQ3KZW/CSpKYcOL6vFiLq/Sj1MAVhAe2iXLY1vxbTaO3CilozydllwbIdPq7M1T1c +AY2ZQI/WlLgWyq8Tn/Gi9IxjPbumPvrhkcNO7nf/HIbH53Qdp/G/op67Z1zkdvwyDkmol479jwf/ +R8PkTuO+k53/L5ePJ/jXk5S5UOnmTOn5jGcataTzh9bpqF1/hnL9pd4un77+vF8+75fP++V/mP0y +ZpAQfuvIsMB93hZtJ1zQCf7IKVAX98uvxcT75dftunEB0Fqvtosrvj/3vTxd3sxTHE0h/HpOPXtO +PXtOPXtOPXtOPXtOPXtOPXtOPXtOPXtOMnnON3qeCs9T4XkqfFHqGe65n5XUtaBN3L4iK0wQPDXD +SA8j5tsZj319QfKbfvQrjfR22Uhvzkh3HjtSkVU9Jt3CDOvoakZ0o1o1YS4XIfqvmUWk9apB7XVd +1nLHlKK7oTyEL8LiiiJOT6/E+x9Xu+Q8pSDf2UyC7xvn6seuATkv5//JGv3TI7X4nxKDOA8qgDzo +6RjbpIyz5Ay+tuFTntbPFNLTI77WLxbR02O5SOcimjOCPlacI1j2z0k6/pHyHMyEaTjrf7RMn/Pi +HHGoc3lnqT09sWdVDhXL6florctHxC9wpizlohiV3BCQdBVPvFLayJJL+3iS7lciHH2upcwL+3HX +ODp07aRzoiPZ5if9hMf1KxF+nSjPl/2tAMabOJ/9rc/+1md/67O/9dnf+uxvffa3Pvtbn/2tz56V +Zyfb81R4ngrPU+Hr/K1268a6GUYdRBzCS7ckPHrIaBpuRRhvwhxPGo03Yfpr3IajRtPFs0bJlS1c +XLlQfyeHVi/UOzmkROjkqu/7qTKWMIy+hOEwY3TO2IyZHp0yfBCNZ4vOlY/NFJknk0yUPk048W+8 +hq7Pj+3sGOcGzIwJJwbNCp0TfUZQDi076RqsZpwEQZIfcQ3jCs4w3AsMsZbOb2fnxszD5PxL+0nW +8HiZSr5Y7HUs9Lq7fKPKJMv8sdsTzkdxuDfB3aLCdVl302OX2m6utdVxvXTIcJAG06PiAIf50+Jg +Z0meIg+mTwgELxK8UBjFgggGnAHTBcHgRINMBRHduOYDDf2JljUOPA45XZhw4b5FX1Z0GOfp4jD3 +RTpenNNH+dFbMiYban9xjlu07vribelRHu9efJTGfNrI/u0VGeMlGctw28j+bCuA0Z/c8D9lP3A7 +grsLw92DMW2yfC/sDMPeMO4Obn/giYCHJw5y6uJjUwFUBlQYdjAIhRSFhZSEA4z+CiskgWIwg1Jw +AKG9Ovlxgu1jR1MowFtONHkqSIqAO/wR5soK/I10rcYBpkGFgY9ABl6hsYMhyjCSC92YsYPxysCQ +xc4kNBiQDAOx0JUY+4luw8iw3hZgNq8zFKXI4AWYi4xFtqoERWbqNZ7MwS47iXeTsY7v8xyY5njW +NocXzg8syBmFPwO7XN0L3c/0MYdj2viXundpcC1NT3Q0fsTNOPqlpy+7UOKif5o8i9NHrpN45DKJ +j18qOn3kVtHxEgl3r+jHrhWd5OIIcRmTf9A7jau6jeXQxx0d9gh0zCPT8Y6VrvjY04Uep9PdRNdy +8lWcma7gXNF3jt5rvF1E3AvPU+F5KjxPheep4KfCF5WPavPtMrcvy6KRj35ZGaky36bYylekDSmG +z8wb+qJyWV8bYC6XaxuU9WP1iM7jwJtrZcgv/pGlNX1ibfnVtb3DyS8wiwxPLkRzuSLRxRvKNhG8 +va2806SBYReOGePC51HhsTLRJiY8WTCv30SzWkxYDwcfPhWuWYbftLjRWOaI/xf6/yb5Ndp3jZtE +Uk8L1zwShbXQPbocT+HfVimDVOhcLt2ju9vURNpWRTpZXSSph0SVkbQqEn/v5ZDSJNWQKl2jspNa +SBqC5GpIEpemi8G1HlKUikhRiiGh1YO6+26iWM6O6iDtyTji8OQsdZAS3ZT0XAnpCpWQBvv0yQ4K +cU9cLqP0BbfGujo6h6lXVLLcqu2dsec3xs5nhZWstNK0uSu23xTryysNvs9NiaWxyNJuOquzNFZa +uuz/lMtdh3JL4kibnBfU1VzaetQu1WD6VB2mx2oxZV9sYMgC/FhNJleV6XJdJpgJ04XiTP2qosv1 +mXqFpgs1mqahTJMv1HTpAqPFV4q4cI0RPNOFkk3+NiOZe/+RCjiB1JjXStWWakjrRWQLJ9/NtyVI +ytuaU5vDIzl010P5dUrOWi4qOQB+8oUZXPJBbZRLFgolxDyWeKN5CWr8XDKBBiPoMUTFLClGt03o +QlSDPXVWneFTcb5PRvmeGjD8ZMjwMUSfij2eoRqXGexsfKHMMoMyQNcFzXOpbVgVlA== + + + KER5pTLp+IqZy/P4ahj/vRe2PVsj4WL+aYjDwvlUbuXF0p6PpVbCGE+DFj3q0eNFjmNC5Tal0hIq +p+H+32JX8K1D9ZTRHgZrmGvknOd/1U3i6dbA2JoYg5ExbbO+HI88r56cLDi5bMEycGcnngDOHkpj +uiB1ziVL9nKvY8rk0VImH0uarHIh6g6jLz0bbpsPdzlxcjS8zlgyDSm5dbe9HhrTpBbqfJEu4yTg +zrnM5u0NqZrSzLejBkrpqnTG5SjnW/h0CyYvn6gKTyplgu7KiRYwjSKdZWnApxNxJgEvVjq3cged +JbMdOnWEjgSgvgLNe8rYw3S9lei8myiJswC7OIFz6QmcMJGPxzuQbRHkXAWm7EEC4t3J4S7xyH2W +dv9p5X76qHa/0e2fotpPn8pGuJyMQJ27btcw5/jxrl0wXT7dvenTyRaXuscj95mW2ac6OH2uZfap +7k1PySU5797G0YdvxA0SVJVWEtXTqS1wEZ0cqNqPaqZzgG7RZrq5LG8s1H0tjHyhXYsLIQG1CuQE +HuLIsLvT3k661g058bikaEJs2Bj4u8R6cWe+FsKv264vevO2hUpHPXc903MjFTdD7fHcF79N/T7F +eTIv/KWq5Y/6CF3RM+cf9Hqv1319DMHHEbwi7Y81dB0Ypu7kQguuS0O3fFa7jzP4WAPFG7yHbpE0 +5GhOtCqWQ5t9nr2UIJS64IvUBU8W+yiTqOvVaoDvXfr9yXm8Av1LRnF2NDdazvvPVvk/J7WvTtdM +7PMmgKfRU+np9JR6Wj21d/5UoT9X6Kge6PaUe9qJ+k6hcnGkcUPlhs79hbOAdHXy+VHAvWXcream +smOAmyu6O81A9Veekv5q62K+jaAKsX3UCiwC/KW0PBZ5K3habiWpjdY9RjSoXNllYX81jF8lTmO4 +JE4B+pX3bJ6c3Dk7VDW5oGaVypE+oCni9GtPe+3ODvgsqNc8dsBnCLc+5XjRlgIf6i2b82ZEwXQm +4JQGpYLPJl5PuF2o9PhE4fZvmTP9lHd/9tunS0Ly/P0bfyaajlyfHQaNViuYdctYRVGvbK56F+5H +1/31UH5h8BcvPc7ha4K/guHrBM9Ft0scqyw+KdGX0nyflOX7pGTRR6y2C+mBT0k4PMucewydD809 +JTmBUhOelKTy7xmd92miJEzkLs+NbvJGDobh0Lz4zc9/8TcYtdt1Ga41vzrmz1x488fO3n/Op79q +waWLEYJ0IUCgX73ydLDkTk7zzM5VXyQRlBNCK8XPVzUPehS91zeX0OGmaPmdxc55K13kbqGFoujq ++Y8TGT5RFlmR5VYsts63Da0SW1cbgyPsB1qsvBtrrP00afiO+8kvC0GKBvNXlBPi/GSSRByI55uJ ++G4i3sfXSWwV+S9912uLGl1cpBcY8YbPFthBzhiP3+lvkzU5up/9OV147sj7MQQqcdy8VhMHXe44 +6HJqGh+t7neULq/SB1aXSFmaPmEW60VeR/I8PlI+weWipcnSZbaJaJF8kpoms62vEx+rrzNZAlq+ +WGGHndEXss8eyT3bTeKKv5OjyEGTzyT37CA1yruv/RPZZ9OZDNUENJWkKktVmrI8ZYm6I5PtQHL1 +6MdYdddk54dXC6w1S2c5WuLKMujR2fJV2iSLyVRZWSuq5Gtyit7StXNa9UmyUvyx+az5Viu57nTi +dCPg43mN6lvRqQT/pgtJWNsMxzEHa1uTQyeW5F5NlHrVcxt5XqHr/0T+70ATCqfTjqYST6QgE4nv +TThS/CLQ9KmTOO/7SWesdqEnnYucc74jqYQ+cT7mfIf+cBjtBiN81ILzfz4n3v/VES6PPDSBJ9nd +1MWljq50tr+N+9qlDe2gl3KM+9ni9jAfv+YF5jevVUxGNht3agTdba4SGG8G8LktY1bLmM0iBa2m +IYNlyFvZ5Kv4G8TG9JQhLWUa8lHG28LG9JMh7WRINxmyTKYxvYRSm9hjNCY4sSGnaU6a6BRlU1x6 +utMkGU93knBzdHlP7GbSi+U4+YldTmMKlB4DpUSoaciF0nyoRWeBjMzJ5UUd5S39cKgcEH0+mPzn +fzD5arkkl50Z4yh/8ThPLp/z60caxnp6WkW5j4z1ZrSnL4odfmS8pydHDz854htLdq3zgsGw1mAz +CXStBuwEcSXXjjh0ZsmhWTCi92hWztdi+g+XjXO5sCfW9TQr1XlKbJfXLbwXyilO1d2ZvXmiq41m +24t5J7bE7GmTky3Z2KQiaBZ2IktIr6StdBvSKrbdzswzMcImy8aOpPmS7ktzjVVfriW2oyD9kSyn +E6n4M9lPqACjCpzohpyCRXkmSuJAXXhH8/soVcb4RAL2P8iTqGoPKsWoFqNivNJq4fJSqh7Tvckz +aclcaYrrTOGJhUxHf7nQlC81deBqZFaPbJEzDJxmkyfKtFmHPBvOtMFlf55nQ5k2o2EazdXOY6fG +6UJj9vGTVLlXOZounqFaKTFmdyngsD09JWc8onCyTmavHpB1zrLwtsXhkbNTenBquGM6UVbNaLUe +7W5pNVuRlZ8oC8u5U9Nwbspbrno723E4NRUos7tQhs55khiYrtNgua5ykdZl9x8br5++LutpF2c9 +ep3W9Ik7tS7esfWx5/z+rY/du/WE27imC6Vrn1LM9tFnerTa7aeeevmZHvvDI9Vy6RktEmWt9l7p +UxRqdai5sVjsWM0MS4T/zKulH79cGm2F6SmXSz/9eulDni5cL32FC6a/8IppOezgC4jcTReKS/jy +EtsCE1Ri4tn2+HOyPR7JkMjAgYiBjoYhsrG0b0mV0g6yKpJY6jfVR1TR66H8D6eTlouRE4BerDVP +Cg1v6DtzF14+BC35wBc2c/VAHylV/IlHoPXOzDps5j7nm05BT84R3V3RtKHLlr642zCzeKVlazfP +NB+OPqEwn9jXxamfvfpsd8trMrXmljN3xgOse8uovvMHWbnuUaI1XWh1N1rnO1rxh012eaRMZJQO +hfKRN7fXorydKJlaXLKSUs1+2YNk1XdWVtKLdlyRUjy17KtFb+2ebxGd2GH7P7dLljeTT1XY//hd +v+cX+F44bvfxyvsXjuL5Z3pUr3zs6/jII75EOcVHvf+cs61P2Xc+L0X8CbvOdL38aTnYKjWDaN2v +dLiiV5YKF6qJHVxpqSrdOS8tRd2ayMjCnvGeyv2zClPUR+5lrzG2vVaWuysXy07Y503FKX+3LPd+ +qDslPDhJ1HVzvezEgeBHN14suYTpzy3VtV3eJbHQP6YjJK78/9G97isRjptug15SpuGKp1YkEYJ3 +7KY7N96sSkkTfAXAJ7SCr8X4VRt0vbQ/169NYXy+P+D5/oDn+wOe7w94vj/g+f6AL1aM/8cifL4/ +4Pn+gGen2HPR+Oep8DwVnqfCv/59rU8vYjie8/6sj/2H85e3i2cK2+ZM4ckYvbciezvJrlw35aWL +/Xap1DT9nIbszi/VsS5ogkGOPqPLgBwGUigJjQBWkzRHnhWkRlkgR9L0ST2a5IQjuwbQ0stSi4Oz +4k/umHilJI29ZS5b3jJRZqprtCovvrqLevs183yWIL56/jULnd3/FY8Csl28o/jpQcL6JwntzxYL +6NEADfQXSfv8dLD/E8H8T8Xtz2PzT4nRb0LtLL+/UE5fENMkpKevr5m4Y9NjUyl/dGJmk38qAVUG +Hgb/ZTFBGKfBfXk8S2NTmahScXuJAsnGR/yaMIPXTGeilqXloTBb4yOKdkco/IlAn3IdfjVKFpC5 +zOPdpfCB0IoXcniSC0vEwS9YkyKUy+LyazF9nfC8WN+ijfUtrCCoChx2MdzpkRzna/J+pvFAxaZM +9NbDdKlE9OiWfKRENPoKJvMpbX2T5kka5caFUlHbirQczttdqEW7SHi0188qk5WH2jk/4hgrTe7U +DkdMd5QFYlFTkaIkPydKI8kU++NUqGbJUBI/HXv0VRLm0qHoCzLmCRLmcTVw+rQeqPc97zeJ/2PJ +0m3R0kuJOqdthv9YuHTd5PWnIWlnm7azKV86uRz+drhYwJRjVHualXqNUY9WbeNVrMY+fhmKxKwm +DVoNN6L0O1FYwd3GrS5FrljhlTpHKPe95GfdV6JXm0zjOC9DKAiUkjAeJdfoS9MilGkNIB4uSr7r +oOPiQ6igDbJ8rcsmXQQ6COL8xp1yDxi4emzDuB7KjwloAHz763dvf/P+9dsPr9/+8OKFk9v+D9Ov +f8S/RP7Lb159+HD//i0I9G/+n59fvb//6Wb39oc399+DLN8AbpblNqW6ys94U8otRvTkZ4Su/ozd +NVvgH/5E//2/4Nf/BsB/uUk3f3Pzj/91vvme4P/wW/ixxfngYIL35iXANu8aYPrZlxfwIewtve5v +aSjAcgL9gnLQayU2p3mFHQe3w1poW5x5XmAFV6lYFTkX6B9e4QvgpVjXNd+CoZmYXgHxT3ol/bVd +gMjHXp5jQtA/wb+wYgFL2DJXUBlqpTcoLLbbpa1h+PglmH725QV8+h76HHAqQ0dBitJ7FFaW29jA +zvOfvwTTz768gE/fozTp5z3HarhNrS7CoDbP7RLIv3mLTd9CHyvFD4uC3CDwpy5A3BhsMOkLqFs1 +6WcfHMhzVrlwCeZnw4hNX0LUwCzRMX1wMP5IGz5+CebnwxbfwK3NmCjMD4B+/hLMj8AWn74HBF2A +bQGXWZ4rbNcYQ48g2FhWJ6QXqwdJFoAUXAPpzb/QgptvfsvVRwIsTy4kV9NYAqGLVVS6WSGHfZGO +n6y4mm/+Ycc1j2/+xc/UPlcuDdulxXRhzW6wIegPLPVr5sK0nbwSlqFKUuIytOhFITKhl2wuUM+3 +8+vhkZEfVuMG5om/NF+ZVNjlF6p9FyKGPy7yVrYjZ9GAdAT6mdZhloo0uTR7lFuXYF5ybPF1Wiso ++5H2x7rw1IJ2uRCjG8Y5UWBrwkZmE4cqaeCuOohwt5QvCVMsdLWRuQJyq/aC7P/DlSb+Vhj7eVph +CJOwxYTpBZhfkJeE+1WHnzZRkJ198AdRe0EMKkg+9/IM0zWHfbMf+C3Cj/ElOXpBXF/YXZjQlMCK +HGuhpby2UTvVEpirclXynphQHEhHwYOD8bpI55J4A/PUb/EprVutwmsaHqeoLhdAHuMlHQXf8vvp +xOom6KeibH6RvrryX/bvf/7pj4rH3A1h/uU03+zg3z/8y/QzPIMWelkHJQ30RQLd/DbfgKROWPlz +AS68AJVwvcVIvgO/HMGh3OLFhARWDJdg/eNvJ9RBcSLPC419xWNhOEnBIltJ+NcCZgIdiMTdCyFW +gH/ReexQo2GRAxEcGkzHNScEx9s5wGcAuOZbsP2EjAhLHmA13tZ5ro607/DzBemBCUhgbLg0+HBr +vuGfoCEYWoATyO4Nl7pt+M/YcM6AMST/clieuDOXgUrPa+nRYRra4n4FeG8GpMjsBmr6QICOwHcj +pQDOBTo39Erb/mnsfm/rWKVtsWOOq50Gx/9O7XagDtM/Tb+f2s0vfnnzD38Pv9Gkhg== + + + VTBM6U/NdILeAPgmDFP+yRN+BfXpdl1BM1nDXLA8L835dV4jionmwC834HBbal4J7JE8AjYk15r5 +hL0UkKCAPcFGkBNRvsDkIkhMoF5xs7QuiYEZdtSbkTJoua4VpxmDI3cPUYKZzkA0wxmIV4reXHw5 +DihyCNoUpSGlJQk/8y06qxEMv82wQyGw8KTktjEWAtZbPC7NwLbAWjgQAphJ6BNgcA6Lto1JXpbn +cMMNF9y3CVZmIJw/32BHnFcmYKGJus5tuQXeB267MsNmmL0ZGihv0soIcFLHJMSGUgrPCAADtXXg +DuzBsKBXYW+uIQowLosSi6mzjBfBURkWW5a2IcyCNc1FEYS1KM9RuTUEudoA5yBtYeONimBVIJj8 +SsGa5PPpFiNx0hRNBgF2JsCcF+CCbgEmYJ6DIYDVL1wEpasKZ3DelCYch/8SinybwiwzLIXMHC9A +gXas5qwdAzB2nUeyRUXQUlZgSlmBTQnrHYNFZzO/1cB9WG/DUmQegahlpDA5gk4OEFjy+QYzuwit +LQkPGyqG8v6KE18+L5ML18Vqn8eMKZ2yi36+NP48vCqELMCGjGdgXRdejjMteEFQ14pzHoGp8chk +WORxFeCaShVer6EYApiROgRLYym2zAu8JMrrUhAUC6qfUXtL3EZgmrNQG2HBCt4F9wVZzfM6d7xl +nYUKKrvHQMz8EoaXysBwi/F67XAJghfAKUnfFli8gjdAR5PQG3JbBUXCMWEUOVYBlhh1lYdoaMv4 +NkYLqxS3qc40BkYTgSSzBQiqthDA0o7BsBkIufOyFiGhzTrAS16DIFhSH8mk/UXpoAMBsoHbwrRP +uelklN5WkOJRu5CLDgTs9qnoFAu1StuKZdyZ4yjcBbhWXWPFIWhRBc0amYAVertKUyzZKUDQ3PVN +bdYeABi6LOBVZs16C4yLZwjQWBIgKC+GgEjkpbOS+EMgqDuLzoPAg9BY5nRuM4KGo6gDxpsIAZMu +3RW22htrKRRU+K8hiNE2nAJgBpZcqzLWgORvZQqMBQCdgy0cGfCG3FR2LUrUmnTTXRedRcvMU52x +Np5FAOxykkQiA0tbldm4GSmCDHRpW57cC6zxZLtNIDmFLcEULMLXWGhmLLgJBhV+GJY9KAJ9VaLt +kkA56GSpBuuyWzclBMdWdCVHFjEAbH29sOyDVwP71+ZoYgQBPc26OBdWWxAYdL1gvObmv0hbtIN1 +pxG8sORCsgm7CgwEsq43lDT8rohamK64Yp/PyAy/+yCw76C1LNUQtDnqmscTNAiEj4VgigypPAiM +tcqrwBiQzwOyqASAqs3vgl9b2LIww2Cu0YlCRgDIStMFg4KegaSy83DNpQgwzcP+pQhKWKW3OTXR +YPF1LQsKMnjlZWijiIa1GN5qGsuiiwPxLjplZb8Hlcu0aFOPELjA/FH1yFhbQO6oookZytK2zsnk +g7C2wpDqlAu2vNEnEVeddKUkaYsndJQ1rCkjgqCaGIbdBQFIzmS7Wlpl9wAwyC0Fl6woVFdG4V+i +AJvtMwF9HYq31SSLMWLteASCmlt02mM5ZAGCNFx1Xw3K2xUrC2VHGANrUtZkGTCQsfOq29dSV/s8 +LGLlTC36+b61LykoVTXaBtrHpqEU1HUDzL8RIOztimBWYFirAUs2BH2KixuWwakutatjDFvDEh0T +GViCDnnCzVrR5nnJm6GBtlVVAxjmJMAE248qU8tqCMqiciKLbgHAFhcBFliQCAxYAFx3KkywYAQB +z8zPSRGwTA9kyBUli/eUgDE2VXlIj1cEKTVhgai5CFyjqnNVuhCW25CU3yvqm4wAwJl5AKst8LoB +IBgs0t0cWUwgMAZ9VdR1A2DMZBPC1sZdCG6vEJUagTmpTAPbVUYBwKnqZpNXlsDYVsy4bNogAhdd +CXhDlSEgRYW7i45vAaINzFiBRwIEsawUgIA1BC1mnQeij4ZoSjX6LnIWYGgpKWdVOQFwXHXhEesF +GHWFFFHwEGvTFVKSKuAAht8FAXUGgckJa7JbGNhVHtghRPggWJQLoID1u5DRAb3w0C7RgLEGBQbl +QHYbpoRkGJyiSg7axhhYkxohjUUiwop+vgZDW8xk1B7BpqVSa2WxF3BJ6wSqpi4F1LVVCaC5wMDc +mlA/F5nuuNfpMq4mN5Emk7FGPHxsKYpAVHEAhqya9IpGrFK/rCo1xOonBFl7n0S5IQQ22Uw1QlfX +ooNic7DA8i06A1Q8FNPPM2u3imANKpArqt0vFRx5caDpy0pfwG2tei4wcJYVU7omilCUNX0dMTCD +RSMTQ2wMAFLEiZGmshiCZApuUq8XgmmbZ3CVWVx5UMdhqE5Kryg0FC/xWVa98AY3UJva7GIgYE3W +W92qEIy2OnWCBC4CwZRPfXLOVYC64mQmMYLVbCKc3CIKYPtJTWWkWFoATLbialUVLTRnQ7Z5VQR4 +eaa+rBLD48wmS5eRhCDSpZxKQWRq42yOIltzCFt0Jq5BjVj8fNMtpaCsYWCwhYcONQFSTEsGQQU6 +gos6OdaF1xgAa45edjOQPGyyUenCi+ghaLor4tIW4JJ0FCPPWQRGbdmwar8iiMW2Vd7XAaYuRxjZ +krkHgWr7u12CPx9A7OjnVaEFBDXrjkJDxMCG+768abHP42lF0ULETgBgCgpci1AFu4y42hBpioYA +c8iclHkpYLBAdffgrTbCjhKjztjIrtSIu4T6BugjjBZdgLqjNNmnANh1G9JGGZjF2C0Y6pPlEdH1 +mMpIAKpOQSZ3YEcVAtVc9xslgpt1t1VFUE2HKWIsAhBz53QS6TYVUVRHpQt9m4K1qDTBjFKjQPVT +FOaOgsUmPTsiEOtcVdsQIxyBi9KKJ00NQZ11zqrTI6J8N4Eocge7UFVrzUU1rgiEr6pcxSTUFo7j +sfCsSxOgejJwH1R1HMFztGWXFQFMKaVAHBEAJEtZpkFUHoD4brKrsqx4KeAkemdhrwYDw6ousSqe +egSaOk1bp+JNZmhk2Vxj5YEWDZU1uVjphho35xgB+t5Nnw4a3ojVtiu38lbn2ctiVAAwRFWDitn4 +521fKthmM/mTGRibik/xciMwzxpVyGjbKd6ueerGgDQUNSqquLrwVeZwpC1ZEYSozGkUr2MKbL9q +YpoRBbYgU/88Hp0dNdeIVpjq2ar6ArC7lFYzQDBuvKhDoa6sqCMwJtvaZMwBuEZVfLLtNs3Zhk3s +bgCmnLSthIIi+r5TPZuMsDeW1a9TwdrUHdxEEUCgaQckQA3BMrfNDJV4uMjlZmQFFdbdLwfg3NSn +rePVTCGHJSJOGQDW2XQ/tGr088U2kVZXJaDYLkx7o7wpqkJuqnfs7joSejI5AWpqHskZA/c914hd +Tc93LOxuA5qG+jIicRCgCVNsgjftGKiewcKuHkKQMMcqiZRQuz3NzhnQcEYycG1z0cmtOmmilCyb +3q1xx1L3I/aZCMCAfGLCeHkALIUmeuYc1LFEYN1eacooWg2yAZi1hrR4HU3sIgCqkwLtGiUWFYRZ +O8aiFlq2rBsDCUduGIJZG6YOJoxQq9xh/xOA1F3XTVsAqgkiyrN+vJmDwvgazUVf2IHOQErb3GhC +CBb9BJilFAAw6Ppe0BuHwGQ6feH4IiNAD7Zxu7FzMInSTsAkTtuULQqGpoJq1Alnug62sBr7os6Q +qgwUZoiQX5UDaHnOtoWx5ovAojZs4oAXAsOingxbXAg1D56NdW+KnWJ1OOGaNvulqjIK4BRWme/A +bO5rNXV6AHZzuetMACbbWRhbsrYNQYBBxrVy5IvH1WJg2NT2yiYGIwBzXWzjaIq0NnPFmIhOlbV7 +e9dLgbqZwSlsCIYtOHfdoDG/EahWc5JVAFtXrYq12OoG8KpNVXACMM4mTRfeqxGYFr/LKIJcmuKV +PTWtJkqKho6X1BxjKTDMCDDMYsZtEtMSoEnCuW4hNEoKU87I5Gjms9igVd0b+iBGRZ5tdhbzx2Pe +WjEvE+pnhCBjWXZVr9Twz8FicIWd0Qx0vcWVwggALFYNEhYi9yxH9LXpiImfCdo2kxG5sozIGBxc +FG/V0BwiKGpcRnE+ZTQVkgqkGhQIOqVqiOoNACg5GUW1YIU2YwQk6QSXuBIAK1pevQeKQNXUwg46 +QSBencLmIANJqxPBozYzgkXTdlxMFq8DCthWAVjvgMbvEUrOauF304/TKI8dSOZuFY+YIugrlzas +lwLW8GRfpNhZ8xUV0fSR1kVd/91zj69rGoyVLGN5XbHwnMg0xKsxIIkm48eLxlpWdPwfHv84pnSo +GpY41EINZzNuU6eK4jncA9Y2qKsmz8SIzInzYRm4qFcrZ9tTi3rdM+ZY6NS06ZbwwIh5MmKnv5lT +sejMyJaN0x17GUNfSmnfFImAasYti39sO0ddXWJV5exkQTIVJqOepvptnA2BTkGNFGG7ZdGlGXVH +eOzjeARMXiUR9pwt/lT8CKANoUJale6M+9e6OFoZGBYli1ynjKBY0LNY4AKxriZIxIGHCBwLl45g +qU13RYmWAbDU2QSJfh6UFSWgz4FiShAaruzdRWBf3WINATBHVbqD7esZu6MCbhF/Uq4WEiq38vHK +eSN9YvLHydmpEkPzPwCqNOkSQEtXN3qNnQEwOidhM5SaY1E08wyBTWZ1lpAggpIKlqXonFg7Ovqv +udYKO/wZGJLOBho1fXFrqncUid+6F6uzK3s9oPtkho/HqG8CgSgjoR4VpCnobO6RAwQnlfQoDl4K +tGvpGv3ImJqRpVdqyCPQ3tWDMgheNKexil8LgUnZoqJntaA8ynRNDMhoBaudsvbdEpSGpGNnMnnl +fVpGnv1i0BJmqALRZlK8rRTdF5rqTdCaEg2Ei7JdNE40GPQexGu73WKuegCDsNUlObMLKWOA0vpb +jDBKr5SeqYIC4CqpfIXtKgaWpW94WWDqHyguWoFozQDIyXWsWybqk6d3xY2Wl9G0LAZsQleZnZqm +OQcAjKsOuoS2qGGUgSz+86Fov6q45AGYom4talkhUnPxJrVgyuwmnQbnEGlTJZEiJwzMJhT6BEcE +NmXUP1lmpz5LSulSFo7Fc1dD6RQ4m71oYB9az8WM25JkhhafYqeqG2LGxDHe85TehTO0VvYk6vaC +bat6yoM4hfAcgWXoRU5HRGCKlnFgUxzxrup6aCUoAhxiGV2R2ACsJrrMZivBfEJuxIJTccjbykD1 +qw1TprvKC6uhDCxZBULJcxKgBsOAgKBmO7a1ISOfpLws6ypvsukVzKJTq7W7SQiBSSpJPSmg/lYd +Xl3j0JIiBKsZFopgjYvuO4t1t3QvryQCIlnJHA8W0cW2JW3cBNh2UT+z+s/xVebVJyAjiM6Zqgkt +AOzp0ZXtToQt6hZrfRYAeDbtLS7K7xaLuVPY8sY3ZbWcUQTp59Nin28cvCw+k1HDYwW1etMbLFoB +YE3/KRxdFmDSTUzSTgimYrbH8hDtohstOeVfCjgXldR0kkDBmhpb2MMlKCSGzPxPFg== + + + W5NEe35TsrRc3JYUI+Yu6waidhVibGqHsopS0CpSzS9YziZ8XHmiOzi+PjSntci7V93+yGdpJAXV +BjVFHykSx1fhXERB2szQWVvvUzBngoltfFk1Jw3H30vi8CWvAM03R7A6dIrlpxbJ0xxXQHJrpaem +lMwdH3blks09L7s9A0tVphbzniF46TsPR6YKKl3Gw1WRrkXHL5iWXDKfTxllfHbBkyQeLeyrLAuM +7mi2HLVVl3cR1w+0BT3fHKgdaAGGHhApYrcxOKzZ2KXxH1GzEbY2aeikEObKWhK45BeVbCpxT2or +2XZpOTehPVBFsKd+IYKewiDuPwQmTWFwUigz5xgcZx2vniem2SqlOA2KkhIYAU4ei96vIrIKp2rK +djjryLRsdqGlSBUcpqaESeIvVjGw6KBNZNDrszK272bVbdNkATHQ+eyr7CXV7TrdAwpgjUQWTj5j +YFhsi1sXRdBdYtlcYohg1XmoISlsKzla3V5FYDNXDookRdCjuVmSVpDatW1FeXVecBLaRkFW39VS +9PPqbewpAQhcNMxPoV7+/MpR7NU7PUq1tNGejIotbSEEy4oo6EHMNg9l4+uWg6Uglmb5ORIr5M+j +U08nQZQIR515rQ5KFQBT0UyJ7oeus4tHa8McdRUs/dM1ab7LrFtpRdef5SOLwwE/X3QZqg2OLW25 +RNPNq9cgSUDxua/F6VRxYQEHQKDa8pF5eQOwNItFq+cOm9aqadp2bAMbWybQvCrWnrqsAWoEFu0X ++RkUbU+cmkVGA3DNmvTaRCXDlkmzv9emuk/F/G3N8S0SoKgYYdGzN5SUzkANOUv6OCMIdtZJqH0p +4J55RkedERg5bZHbsk0JsJRMhTZpiOCo58jIn/RSwH0ekuPEwJaSLCeAELgmy6GXbCYAwuhq15JO +2ooJgMqyaEl1AF6ynkzK4tkEYLaTYCJRkdxFD22sesCM0FrulKbj1uCcappiC0DQ4xXBvHQEKqlx +669xw8Z+FgNJlayExKdVFIHmx+BmyBIRKZCoEGZ7C7sw40UP2ZFVrOOrCZdJXTVIgGxAiZ3LAiyL +NWytf95Ok1DwQmZHrkJAwFw1BmrcPTn/UcXjl5rdTiqrTMZFU8jJ+6EzVM8p2mk8AmcFu5f1M2N6 +HAUXw6zD7SjAM1D6Ms2rAKCeL0t8XEJkigyBnVSChstckptaDIQRFJqKJPejjFj0LEbPWMW2dkaQ +bFoBFl23lMUpQkriathyiV0mhqjDLTswyrlkxwBSF5RZzw0G85iR/E3BDe1LAQdJ5k1dJnqgzm7Y +E5qkAySvMzXbhJNJurJabv4ApC2SgV3lwciYLkUytV/qHii5rLGbn7ix6tkN9aMCcDHBQaE5VWQc +H1Iw1VXU/8gCloG5KW8pi1G1wdz0uJQm+KD1sRiC1m3tWlalVSNQaGlmlX8BCzi9NFNVV6PhDTxb +eHhUee4Z3IlzvRVvX3kaWwNg567sQuhZkF1YTsKow0Ld5MnCcOgGkVgNdEw1rNl0jsh6m7l4JBMo +YqZlM1cMHU4msCSRoOurskCImoCBLj1JDRQeqkct2Ms0MQR9grMeT6PwzAt2KmaVk/3YArlGo+KV +PFsAwmqXeaRZxeiwXYr2yxKf0OUrXp9orit0X8s5NBz7qv5iyqUQrBa0zKZ4RLYzX3BcJuWiTGwW +8BP3d+TEVgsOiu4aWVNnr2KwjJPIIdQXHCGVtKHIE/gFxV2bBBAiWTsaTJ1Fc4ns3NAor5qi0XIs +MSC8pqhMCIoWhK6iNd8ZxpSz8pFCry8o+twnjWp6GKeedYkkC4wAWDOXMALKGzECxQUZNRSJUflS +hF9drFMSQRBwbJJeU03PkzPYLyQxIUhfKQdB8xX0XE3kuOVLAVPXpb8Sw0fgKnjVLkgSYWegxZww +Z0KUushewxeUtNHXTZGFi5kcckgt9gBHkgOt/HmxJFMyN27oaQwwdHIIVvJVNZWFViajlYgCAGtQ +AhZxkAOwyEFH2P7rHA3BMisCDRFS4k2LOr0kQSiYYRA5CYIRBLNN0BPIEtwl/owI5mSzS+Uc5Rjp +rKcgwKNYMVtZR5Gy3hjBbIfSg0l7APaNRWcHZcXpuguWalYtdBtNP4iSvyE85Fw7VBh1HZjWEPsh +Eakb8FLASU5eB0sAiNH8xZHLIzAwpSIIehZjNFM22gHE2Esb0PFpgdFo8PvNOMQk6qTLY5aTHpjD +XXUWUQTjBaVrU0EjmUMqZxHcdHEsmkC8WFpf5N1dgLVWXbXG156HHjk16gVlt6sHt89NTLqXtIbI +higjmEHu6JqhyB8DQT8RoIaEEWhDmC39DfFmxVsXOb3R7AxT5DxPBpaoG77lQAQ8yrYalF2DCEx9 +GssBoGahWwCaPhdWO3Aa+1mVyscdmF2SYIPnajpVtleF5JZ9smNBehAZc9Z4p8GjSkUnUbYiBiHZ +eXhc/7yxIjAE7YHoue4IVHROioC2ZtO2snkAUI8IghYi0ygkNwb9bCuet5JgROynk5Jl/sZ+XAfV +FBW8FOlmBNGyuqKGN/FkV9YdWLO9Q7QiJfHWztgjVCIJoi7wqZoeNIgcdXtBp+7UAoqm6wNQE+nd +qseTmlVXB6Whv+AzvxIYF+XtBZ2P1ghgcCex8OC5nIMCsEQCsNCA5BAGi+DN/Shz4EMehAAHX2oC +RDtSSRqg8jCEpFUV9HBv5BPWiiDMJuLYLqHt0aZhsqoMQVJ8o9OcaQE3KccjeahY7KHp1FKTAIGS +URbcwQusY1F5sw8Wm51nyw4JmrKPFTr0FFXoieIIVg036AEDAorT15QoQrCaMNW9i2qEiCkf2Bnx +UsGJDcbA8Q8Fh1nHQWp0IHDOSm/lpEcEavQgdIUaS6JQihuBRY3BsjBrSLovsz5NpXEkdyv0YxZz +my0qFtlU5do66pgK6orFOjwUoxTeyqaCNX/URRA1cwOrA8HEE+ZUrQ7Uay2JjGAE0SKmZqFfqDr0 +d1SOCOsUBec8CEGKJCVWVbj9XNQp0ZKeQCf5Iy2jFoLoiTIILoua+cUqJYU1iIGoK/qcAq6UhOZk +K5YZjUL0QcHZToxIhjr5fy05WUhDYNbEmLkHWStjY7C6pbv/tidyIbBoMuFsKRqln1cv5ogqlI6i +WeNNreRND7RrxcwIpIxKGQu4ajjGiCguPyJIgjnGAYLmHMTZIvZneF/KC5NjBXkmHwRcLZ23Zg3J +1KypQ3SC6YUEikJRoO4cJZleV+wMFsV0NHyleW7nBByMMjXKilYDZbBqMZYFiX4AS+eNlXfKkria +7MrJRerL5cCUhhk0iJmsxkuhU28X36+EwaayakIvjcCDghclrM6aYxCSRkwtuLdYFiNFTNXi75FM +y8lY+KjHyrk9SVMUNq8XuoZ0lcxEIQysHIHNZvG32YCiNGMSTe4ZyapDoHfAklWyZig1PlTBxKrJ +30/5Y4KUur43VMm0o7OD6mEmGfcg4NzsKAUqHHpMsJdWIA/By8tIBHuYrbBXZh3qQcAq2vs5TqxD +YDlokryJsOXCUdiZtShZ9aJS+kOrGs47J0DGaInuXB0p5g8KblY7AsZYyjmIn2dlf7f2+xzJS6oJ ++HWVABF8U768GqBIfwwiUOG6iEk3c3HglwMYuslulZf6+XOI++hboocKAFbUX7B0K8pErNMcVkrG +xZHE62DwlzYvdGPJAhOHyrtGvq+EKwCCXlfw7/BKya9+EL2uLYHAWAaJdJpVDnktLdiYU5gaxT8W +giR7/DtRMtbEduusawV1BFBcraxIEBVBY2+gg5esKk2wUJ/4MLVQXqxNuCG7CpWpS+ovkjospKSI +yFtY/ipd88yyZbbM7xlfhroLWIK9fBRFgRoC5ZjMd8SXBY+/EV8wY3PVMj9ck2hZowXClyiHnpYV +tUkrJYMBjHY26EuWWnnYWsOIC+ohuIMhXtQ0by4O2HeyoPBUGK5JpDhhesaDgOPaggO/3IAjWzFC +M04ovPUTazOq3rzmtTkgsxLYgleX+baosMVIU7pj9UChQLU4eOG6IcyDA1dMkzJ+TQkDeZTPCCOg +DhFsnmls65hjWC9wTApQ4uvCKownHxKt44Y1yVDVX1YK1fLsQQcDAzEJV2rIYQnBQjTMLF+/k1UF +KipxQo4BydBL3YpgB8GwctRqwS1Lb1/QpVXVMxms2A06NIuo5Hr+BAt1yQBV20cpFJFXZU5cmLAZ +ozu46+O0Bm7wGoIZnmPi7hJLuUxipSwzZA259Xg2RFlYNH/72o64heFUB0GnQPZIYUMaHbUJuCgW +tUXvFi/4BcOFjcGU2C/FKsMqSwhETrm5OGS4LH6elpvdjzJ2c6wyCckkfNiAMQTTyo2WUiRicMR7 +Tb5E5TIMyJxLUqRtaIuHs2MesHqgUMAIOnhhh+eAdUWtI20oUKDKNKG2t/X9MqwXeIA8+otv/3L3 +/sPx9XcfXr97++r9n25+BaBf/Odf3vzlNx/ev377w80vvvnjqx/v92/uqd70H3/3px/vf3nzv2Gj +/aON/vrITf53+If76I8T1aRFbyoWIAJNi8qjg4JK5WoXiiq7guNBC3on3qeQdlCuK0sWsmYfNmDL +XplnExbVPEvAvFBUyBNQh4+TR4a2VB+kjEg7TN6vo6dgnLciEjrSmQ/rjQQIkBF0Yq2t75VhvcAB +HD06nVuowi/8MlMheTBqAhVBX2IG5R35ijs+6wcl0H2TiQulG3M5mw5Rk1b5sAFLGRMmmHdx5Bid +xuPOwW5VHVC5OycWg64tZnCFdYO1A4UCRtDBi+WUOqwzn08YKRCgsleptba+X4b1Ag+EvQGvbcLa +yqDG6pUSfOUNmLuRuBr1rqFISehYXZXupjPuguIrmKnqysMGjHWXzHHE9WJx6lXbYVrJscO+E78V +qHzr2FJKIo4oO1Ber6xVcOASbCPSmV3J4/sFqKxVUq2t75RhvcAAYe2MFazxeoEV7wqi+xJypGtG +wPyopL5Gu9IBL0dASHbqK/uoqsybLMaTh0qWJNMLNq6uai2qKuurA5W5ocxx0xaXdVg2WDuQCehi +haGBgwIj0plPaY8ECFCZq8RaW98tw3rOAeYtmJ1tqXRdxhzoKgzQuluka15AsSeLAEOnS6LLElLm +S77QRuisBdNKEEc8tPqwASeL5GJB4UKqQpN6KNy1UnjHFCB3Db2cOu+tLa65EDdYO1Ao0MFRcOBT +NiPWBQ8kbikQoDJXqbW2vl+G9QIPhLuYOIQSNjZSt9C6apjXQXdSRLqbLPlLyArLXeMs3o3IWAMm +yT1swFIam2nlcqM06STRAHVOsVgEqJxNNS6btlGK+A1YO1AosGkv4MBuyBHrwgXMRgoEqJxVaq2t +75dhvcAD4exCZ/9ItsRKFexB51nrcMsPT1N37Ue1q1NkSy21MWq8QpgNoQGslZ/QUZ9WMfOiFMeb +scaUWiYEVPaKve7bYoKMWjyG1QOJAkWg4HAbLdSgSJceQOkECFC5q8S6tr1bHekZBw== + + + mLl5XStdwLbkJZB0mEE7HXkbRBZUdBvQJUt2hY7Ipaxva1qa34OjZc7PqJIsIva1gs0sK64D1QAp +a82bthjnndcN1g4UCmxwDKzZHQ5r0ECzI4Bhylqltbf0fTWUZwxA1i6s4eYUWFc4v+6nM1ivJup3 +a7FjxhhckuKvbTH+KhRj57PSt4rvJd7KKRYsy148zMw7sTF8S77TYUDZgfx2/XiHaqDC4ezzrr+d +YcpbpdPP0N5NQ7nt+1eaJ7unmSe/F+/eot49+PH9VORakZ+v5m0bfIgvKKYLirrIHjIdHzbg0sO3 +eNaC9djVMmCtLKMBid+WBeDbYt28WDZYHTA5m9aBA6dfjljxwpG6pUCATEGn1rXt/XJYz3hAkurr +DUaqSpiYNMlHfNiAAyf7UwVHtvYxm7ZZccs5rg6oHePE/qEtei5T8yg7RN7Nn+7gwnmkI8p6i36M +zesFqCOrpPa2rkcd63nvr2Uscj7LLJ2jsOTDBhzQd6XlNQGHbGRa8QU6By9tDqi8LWteNm2THJYf +sHagUKDsVXCvuOawVjsx6ygQICPo1Pa2rl+ujtsZD65kLFJeTjYfjUUhHRiViKDcTZQHhRwDHU2n +zpKiByp30Z22aYuxzZY3WDtQKFDuKrhX7nRYi5V7chQIULmr1Lq2vV8O6xkPrmUvIhHkYl3ZiSJz +10HlGAkDu8+5hqzc5cKqBlTutqhz19pmOaAwYO1AJkA/r9BemdwhLXaTkiNAgMpcJda17d1yWLcc +uJK9yFlii2rCWJvwYQMOnCPyQgr/qmHWqizVIhdKGZC7RiWklk1bPCsalw3WDhQKlLkKTlZ00WHN +luTkKBAgI+jUura9Xw7rGQ+uYC/S++sqQ1ajpkI4cOC0XAbGRYG0fXK/xGmvQOXsIrLRtcXTqAo0 +rB0oFChnFYyXMMxar1qxZjv+4igQoHJWqXVte78c1jMeXM1eRHlFOWzknsIE/ocNOHAyC/ejRZ13 +SU6MYoXuoFOcgMreuMznbedclzOsChQKbOYLGHYZOSLssOKhnbClQICKQKl1bXu/HNYzHlzLYsT7 +/5o6cajIyMMZWK/UQGCqan70vsFGWR1Q+5aiDo9r26OaDmsHEgU2PAa27MuONXUlpFOQvMLSqR3a +9n45rBseXNdoxJ2iNRk9OgHwcAZ2NeYX803g2AorihraVd0VdHPjvGxb1hDCGcoOpNfr5ztYz1Y4 +pMP81/cL0OST+Uusre+UYT1jwHecB/I/ILb1MdORDZl/FesxZotseOvRgQvnF7zgYtF0XspHubDs +cIs+TEZMx9qwlKXk2yZx5g9YHdBbjw4cLO7ssMrZrZECAbL52al1bXu/gq8kvuGBKIpfZTjSLUSa +MIEb4MMGjMkIRUtz80kIZJYrM905SEBlLFeM8m2xtO3K+2LH6oBCASPo4KBpdQ7pYkdUHAECVL4q +sa5t75YhPefA9YxHVKCK+PmpIMrDBpzJ88PkNqoUhPyyox+gYEnOhwC5aw3LTKaxLZ6oKaENSB1M +3q9jo2DLf/ZIF0v4cwQIUHmrxLq2vVcO6xkHrmU6YvX5FNRwK2qXdyheSpJ4NVVOfaVpZzW0Vzmf +ZkDlLd/a59viek7KW8XqgEyACZSkvNWDTQ4pGEyrXDrRCRAgE9CJdW17txzWLQeuZjfGojkneKtp +XjpzFZz76aLKB1V5Ta/GXD4naEBlLp8HHto2OdkyYO1AoUARKDj4Iu2KNdiZaEeBAJW7Sq1r2/vl +sJ7x4FqmI95wIMH7yNm9Dxsw3hXIzh+8oCCqyaDJdnS7wADkvq247cZNW7qcZd1g7UChwOb+rMxp +Td+lSANHrkYCgguoOWJd296tjvSMA9cwHFEqzbOGvPDU0MMGnPxlDnxBKk06yWTG6xlaWBxQ+cqn +Aoe2WGlR+WpYO1AoUAQdrCWbHVaMt5R1Q4EAlbFKrWvru2tYz3hwNcMRl04PWs2zbmYdnOyqWbxA +gw6GcD7prOytVf3EBFTu8I0hQ1vYeIqy17B2oFCgCDpYkzsdVjrelDYUCFDZq9QObXt3DesZD65l +ONKVI0GWRLa566GmxFRNzETKYlYxzNevGlC7ViULY2jLNZ82WDswr501Haq3NHScWJvDgPp+Aern +ldahbe/VegGWbd5ewVxEcnNTc7SYpuDBeooGe0GHlDaDntPsZ4LNmjCns7Z8fdwGaweOq9rAWrVp +wFpbOCOgts7aTmtv2TvlUG4YwObip4y5fw07jg7q63zodpwD99LvWNh/LWKyabWwRLeKNQckZmSs +Clrb2Dajm191OVdQXoHejnPgrmE5rD0ZxFHgk0Ecta5t75c75n7GgyvYcYB0rerKwUJCDxuou7Vi +xe1CAj92awaekF6jAypf55Da2Daj/3QJI1YHZAKUrQoNel2bw2kZzf79AmSudlpd294rQ3rW/6sZ +cXjtxaLDFbGu1sMG3O8bxfoYuck81rpBdGNDWh2QWTPLFca+bV5sh+pYHVAo0LHpuxkV8RqxLlzj +YKRAgMpcpda17f3qWM95cC0zDu8KyUXdinMz5ioUUzuj8DakpMcJFvZ2JqpxFB1QeavKVW+Lqzlo +9E2QOhi/3qSJQKPVAXI4g92F594vQOWs0ura9k51rGf9v5oRhzerNB0zKvb6sAFnLsjB9MaoETm9 +qxH6RuVcOlB5u6S8aQtAOnk7YHVAoUARKDjazSwOa7CrBBwFAlTuKrWube9Xx3rOg2sZcVj1JmY1 +UFUZHqBUCpbJTYtG6qXYLV35kmOHcceanIl1LWnaqddPUQ5AU4QdFA/yW9khxRn8HqavD34P65S6 +tr1PDuu2+9cw4EjY6xDSuciHDbifHKeqRZqDqznH0C1QCasDKlvpWMq2Ld1BNGLtQKFAEXSwXgri +sAYrDu4oEKAyVql1bX13DesZD65mwOGyWXQgK14h9rABJ1NZkWAqHIRAPSUIwBbW4IDKnVDKsmnb +TGd1WNugyKqrdgD7tS9YQ9+cOgVh3MiU2qFt765hPePBtQw4pIHq1nDaf+iT14HnqtdIcdFFMnai +sXwN6hQhoPatVQ3zW9uG93LFDdYBaNbtANYilwPWtd+E1SlYLbI1UOva9n45rBseXM2Kw9JlTQcO +RqtP3g6mkqYCLBah6yNfRRON415S1vm8LV9CvcHagUSBITCwFKIfkK61nL0fYfrpTqpraX3qGDfd +/7ez4TKIqHVNzn552IDlWrwXXDlQ+letNg3WLrQAXT8biDURc6ubttEduVasDuhtOAeWcmkj1oVL +AI4UCJA30E5tb+v61bGe8+AKNhxei7Mu4kNJVt/EgbPF/vGWldBz0ZpeJsI1MgzIfFmkTNTQFo/f +zmnE6oBCgY6Mgq3qkEMaOrM7AaEfkPfEBs9C7ZYhPefA1cy43MOEiU/nPWzA2VXGjK2I9ZC0/AZW +aZ1XB1Te8pH+oW2wA9GG1MGSOzTowLHfI9CRBqs25ggQoPG2bdu6XnWs5xy4lhGH5T1LUyMmG2cV +mPkiYaY2FYsA23U5MKqtw5SxXO3et8SywmGD0gHp5cpWBXbdyqHEnGwpF9PfLkBlqxLa27oudazb +zl/NgMPLnOxgDpXde9iAM5c6fSGXGzUNKev9CijFl8UBlbNcqGpoS3Ua24jVAYUCRaBgqwLqkGIt +FytSqwQIUHmrxPa2rluG9JwD1zLf8JYrSzYjifRwBpYgem7OYI62f8D0czDmCx5e1Li+tlzkYmuH +cYB1KenA0Yq6O5yB75wcXy9A42srYWzrutSxnnf/GvYbVQ+2bN917rWI+pm8LHd34H1eJS4632Zl +61KX5IDKVyrOO7ZdsHJIHLE6oFCgnO1gLV7msPaSrY6C0As+eGp726G7ivWcB1ez33L34kW+V/Vh +A0bfXFMy1LYtds/XvC5Lhylrk+VM9pZUTHlA6IDycv18B9PlqSPSXq3TvV+Aylk1rLXl0E/Fed75 +axluOLZUwpIwz3qAcgRXq3VFx/V4dNNi18U11ez7Gb0yuyRTbYsSMamUU6wjcNaMxAGsDuIBa8kt +nFFAQOOtUeva9n6Z2/mMB1cz3LBmWNQD+RTefTgDa9VMBNoe4Ea+h7QJqJ1rUZMgfdvS6hnWDuxx +5wFst/16rCYr+/tbF7WdUmvXe+TwbXr/FLtt+ddLpCzoa3Fmy8MAzFrzj+4kWMXZzjuZ3ZEiIOJD +1bvZXLsNptFIMgiGR/lKQIcDK+Uvm5cxjD/ZqbKWRntHuO3jtQ7ZAd5iqQ50afPDBpwtZQxJXbMo +uik1vVaitOiB3C28eU+DGNY2cqnEEWsHCgU6CgruAX2HNdgltI4CARpjhdre1vWrYz3nwdUstIJr +RQcu2pEaB8Ybj+SOFCzCEbVkRbJrP8pi5XGSem/xipNZrWJrKxVSR6wdKBQoexUc7YorhzXohaSO +AIYpc5VWa+k61VGeM+BaBhreEGL13YKes3bQjCf89IYR9V31S9Dx7pTkQMrXNGvMx1riEfwaNjg7 +MLnV3KFxuGVmVnOM7nn2rxeQsXW1XF5p6brUcZ71/momWsXZrUooieWHM3CTQE6d5RJwXtBFL5NK +JTYHVNZS8YqxbbDt3GH1QKJAEfStP8kxMoc1WKFcR4EAlbtKrWvb++WwnvHgWkZaJems5h8mfj+c +gY2GHja3S4gWrFsRHFBYs2kWuOypR+dB9GKb8E29KllsZJ3As95f1d8qQOOnUOja9p44hGe9voZt +hrfBBS1kMxe1zQaw27v4fm2aaHItIvZrUSvOakzSRt00UGRtA94dssXqgUSBMlXBXWVzWPtVEo4C +ASpnlVrXtvfLYT3jwdVsM9xAa9SM1lVVAwdO/Z42IFiqHSXL8cAbp1CGdaCyFwb9vO3act5g7UCh +QBF0sL8KS7BidcEUNhQI0Nhbztr67hrWMx5cy0QjYaSuYko5eNiAU9/YsbZiNeZEnTpU16oDlTmw +sbeztrlpuSGnWigwulyIASzms0MaOadxJECAylwl1rX1vVWkZxy47pm6YZQxJfPhDNrkqhu6hc28 +VynqLtK9CwRU/ixtrWdte30Ww+qBa+z87VCqjDsiHaZ0dy8Q0BhsPjU3UXu3DOuWA199pu6JBVk+ +Zgr+/n9YfRZgHqyAdXvCzoOtkspcm8U8rebKXDFLldU0V59lrnSz7rppG10VD8MaXRUPMxc92Cqp +eKxWc8VT4OqzeGp7W9evjvWcB1cyHeeKEReL/mh9Fg/mYirYsVVym6zmCnZMI/CuPgt2LIex5bpI +KWlD6CCuOosHWx2VjtDqrfhXu9osnkzXtvfG4Tzr+dUKeVa8E0etYavN4sFWRWWudHm95JfK8WXs +HHzzRViUr1H2zN52neWaSo/VAV1tFg+2Kioeq9Vb8RS42iyeWte298thPePBtQp5whDnYMfLtDaL +B1sVFaS3zFrWV+qtYN/4JtahNgvyIdSx5erjRIrTAV1lFg+2Giodp9Va8W93dVk8pQ== + + + rm3vk8N51v+r1fGsWPVb82S0LouHWgUVBLZ11QRorrUCOPG4f3NA5azmUPa266y11h1WB+x1WTzU +Kqh4pFZrxRPg6rJ4Yl3b3i2HdcuBa9XxrHgHx6p6hDqRPNgqqOAU4auEXK0V7JpWGHV1WZANc9i0 +bK7enuH0TjOryuLBVj+l47Q6K/7triaLp9S17X1yOM/6f40anvj+WQ1/q8niwVY9BYHVgpNSZwX7 +pRnVriYLgtU6cW1BUGatoGdYO9DVZPFgq57isZqZ7ylw3gBPrWvb++WwnvHgWtYj7QLdSNOaLB5s +FSFohiSddVJnBYF6wNjVZEFwrZuWzRVCNpzNF03WiiwebLVTOk6rseLf7uqxeEpd2+psV8N51v8r +WY5EmpW0tXosI1gqpyAQ5LgvvSLAtfkiLdq3Yunqrm1ZWzvD2oFWj2UES+UUjzV1JaVTkLyS0qkd +2vZ+OawbHlzVdqRpsmqNFavHMoKleArSIjcfNK2yQjNq0eiF1mOh/oVtu1521SHsQKvGMoKlbkpH +OawmfberxeLJHFfJ2q/7KPkM+D9FLZYZwxS2hLul6MBWNWUuq1X2tvoqsDJsQrpaLDPe8DWnvGkb +5X7kAWsHekvRga1qisdq9VU8Ba4Wi6fWtW1OChvWMx58ff4nIpX7P5qrxeLBVjUFSe03PEh9FexW +56DVYpnpUjatr2lt8WZqNewNawe6WiwerGVTPFKrr+IJcLVYPLGube9WR3rGgasZiwVzUNW7YLVY +PFjLpiC5i5xltvoqM926twQH5K5lXE3btmAw9KskBGmHuVosHtzvonRIrb6KJ8DVYvHEura9Vw7r +GQeuZSqW5q9akRPWHmpVU5DcOUdfdoW7xpdED7VYkA1a5821hfUcNYZjWDuw12LxUDt965FafRVP +gKvF4ol1bXu3HNYtB65mKwIN1bLnrBaLB1vVlBmvl0xlrMWCfWtZz01aLRbkA+hLadM2y63xA9YO +dLVYPNiqpnisVl/FU+BqsXhqXdveL4f1jAfXMhcBc5LbPlwtFg+2qilI7ypnPa2+CgLnumxrsWCX +1VhwbTPeuR02WDvQ1WLxYC2b4pFafRVPgKvF4ol1bXu3OtIzDlzDYESpVK3coNZi8WCrmoKkVrml +y+qrIHBZV190Rflaknp/rG0Bo9mCmIq1A10tlhEsVVM8Vquv4ilwtVg8ta6t765hPePB1QxGHF2r +/Wq1WDy43xhY8D602RywNm1hCIMDKnea1L53bQt7zUesHehqsYzgGKytYo1sUY4UCFDZq9QObXt3 +DesZD65lNCINsxkaNnc9tOWgMiGHaKWxlbAU+oGEviDjooHy3jJEnYwOZQdmm7ceGpasU1RxaiEE +/3aG6ceVTt+yd8ihHPt+rURQIjbY/RbFtAQPloOi1AkzE/VmRexDbMUBbcZkzeN0bWu2E7sdaweO +K9rAUjRlxMrVVUYCtA7LSGtv2TvlUG4Y8G92hm/Gs0BJT1Z0G86BrWLKnGGHaWpqSG0VWFJ4B68H +EjNytPOMri1G2FSPM6wd6G04B+7alcPaL9pxFLg6LJ5a17b3y2E948EVbDg8wSZX5PU6LB5qFVOI +0lmDPFJbBXuV5QC5q8MyZ9R7NDZnbYNdCeqwdmCvw+Khtv4dzn6zpHu/q8PiaXVte6860m3/r2bA +Zbw7PerepHVYPNgqpswZC1TOotxKkjt2rUS7WU7rsCAbeoTb2kbbnRzW6DdNrcPiwVYxxWO12iqe +AleHxVPr2vZ+OaxnPLiWCQeYa9CKElqHxUO1ZApSq1mqVlsFe1ajRn6sDgtyQRUr1za66uiKtMN6 +HRYPtYopHqfVVvHvd3VYPK2ube+Uw7rt/9UMOMCcVlURrA6LB1vFFKS3JtV6pbYK9k1vgHN1WJAP +LerYWFt4RdOjUoa1A10dFg+2iikeq9VW8RS4OiyeWte298thPePBtQw4wKyVdnodlhEqRVOQ3FKC +3r4xK29bUttD67AglEITQ8tkWSQOpQeaEuygVjHF4wx+D9PXB7+HdUpd294nh3Xb/WsYbyTsNRPQ +6rB4sFVMQVJzVY+B3tKYsTKtVg6yOiy0twT1WVhb/NXuQlSsHejqsIxgOX/rsVptFU+Bq8PiqXVt +fXcN6xkPrma84bIpmjRodVhGMPRylX70YvySNozARSrQpZ5iTKt00Viotc1OZzWseVBk1U07gMWy +dUijuRcdAdG5Ih2xQ9veLUV6xoFrmW44wEGlj1Vh8WBgzVJV2Oq1U+gPjUGAIesZjKCJiNTj2dLs +tW3Gkn/rBmsHuiosI5jOdoxYY9+eOgVx3MqU2qFt767DuuHB1Ww4pG3VFF+rwjKCpV4KArV4Yuy7 +Q7GC4nHcSWJr5217OSuHtQOtCssI5popI9LVxry/X6uwjKT2lr1PHeOm+/92FlwqeObTZ0s+bMBW +LwUUbljEWh1TKquAcHOhOavCMqdgyqhrC0o/WKwbrB3oLTgHtnopHqtVVvEUuCosnlrXtvfLYT3j +wRUsuFSsEL6rwuLBVi8FSa15tmwydjNAt1JuHsjdini7+rYtXuStpckMawe6KiwerAVTPNLQ2dIJ +cFVYPLHBs1C71ZGeceBqRlzqAUJXhcWDtWAKklv63R5cWQW7llOLDqi8TYveYW9t8biOhvYUaYe5 +KiwebPVSPFKrrOIJcFVYPLGube+Vw3rGgWuZcIA5LXpjr5rHDmglU4haCTpqbRXsWIlautSMjBTt +Et/eEi+f1uimoexAq8LigV2zciitsop/u6vC4gl1bXuXHNZN569mviVMxdUbLKwKiwdbvRQkN2eN ++khlFexav0rQqrAgG/SaeNeWboeuG6wd6KqweLAWTPFIrbKKJ8BVYfHEura9Wx3pGQeuZbwB5rnf +8qBVWEawhM9TduZytP1jtfvUom0fQGSO69gSD3/kOmL0MCclO9jqpXicVlnFv95VYfGUura9Sw7r +WfevYb3h9ikXV7gqLB5s9VKI1kXrQ0tlFexXm1dfbkX52o/7WttoGb8Oawe6KiwjWOqleKxWWcVT +4KqweGpdW99dw3rGg6tZb6n78FwVlhFcJfU54dFyvVOs8NFE6lzTeEHRY4wkAVPNZ21BgVk3WD3Q +SrF4MLoCqiIoloOpVoOjIDkLw1Hr2vZ+OaxnPLiW/YZDnNSytGIsHgxUrCpsVRlHX2hUcntdPgIq +b9Zmm662xaxUM98EaYe5UiwjGDQdW//Nbh9f67IhQIDK2245uLa9s4b1jANXs96QiKRlra0UywiW +s7IEXHqsjCPBKbuItpViIXDSs3e+7azWl8PagVaKZQRLJYERaytn729d3nZKrV3vkcO36f2/bSmW +OXZ3i7fgHFiLqMwRtc6hzMoco52GtnIsc0TFfijbAhPDElQ7ug7zlpsDWzEVj1Jrrvh39+osnsje +0ruUDOVZx691zC7i5bdB8xe1QosHWy0VJDc1zYuSqivUMzm97yq0IBP0TL5riyf9VdszrB3oKrR4 +sNVS8Vit6oqnwFVo8dS6tr1fDusZD65mvcXsvM1WocWDrZYKEWy5aHKMGjuXihbAsQotyIhU1WK2 +tgtqmMsGawe6Ci0ebOVUPFatu+IJ6BVaPK29ZXbudkN5xoBrGW8xb0qkPGygVk0FqVW/ltVdwY51 +qWE1WpAHpeqZQWu7nNd98cDk1vRyXk/FI7XKK54AV6XFE+va5vPKL+ccuJoJFzFVWU+hW5WWESz1 +VIjeXoJfgoOx2wSuSgvyYa1a4dTaBqeWGFYPtCotHmz1VDxWq7ziKXBVWjy1rm3vl8N6xoNrGXGA +ebXDUlalZQQbDT2ormetIvmofekW7ll025a1xdWpapxxq4OsVIsHW2UVj9NqsPj3u3otnlbXtvfJ +YT3r/zWsOMAKOsa2XssIdjtZyOtYrwX7pRXUXL0WBIe6qddCUw7XzYjVA61eiwd3vc5htRosngJX +r8VT69r2fjmsZzy4mhWHusqsfg6r1+LBVlmFCF40gVJzQSIqlnophdVrof3FEihdW70j3mHtQFev +ZQRrZQSH1WqweApcvRZPrWvru2tYz3hwLSuOxJKlSmq9Fg9OfZtHn1LQLZVrsGDfmqVQWr0WWqur +3jHl2qZV6wp5RWPVqkI9Z2IAc2kVj9RqsHgCXL0WT6xr63urSM84cN0zd8Moa72WESqVVYjm7ufi +GizUP3MBWL0WmlOmvbq2YACUDVYPtDDpAJXKKh7pMKWdF2RxNkQ/F+4mau+WYd1y4N9lvRZ3DO9r +R/2sYAvegqRGHM3Fhw04s/8AgLhdzlVrT8jdzHO0nMD/n713XY7cuNZEn4DvUH8UYe/YoJEXAImt +XyJle3wObTkse0YRJyY6KDZb4oiXHjbbtvbTn/V9KxNIAEUSqG6SVeySQmJhAXlfuXLdMwKxBMbI +eWdKN/zWtMjdYQe15sDYg+MDBfcHB8EnI3CX88UYYdxtiNbGdI3IoGMEEjcYp5Y6Fr8tAxIJJI/V +hDAZMOvYmhk7EZxBLzwkH7wIRoMMr9JMqEAbcC+ocFc6EJtCMwTMmHIFWvWFCkjerxfVlS0SxrFe +8As2ZkUqYbakFBEqTVOvg45O8gGj04suSmRpsTHHC32tdCYCNmeXFkmdKmDkaprkx+hUV4j3oeKQ +cZdWCgyHn6HFEGxplPQrsK6QK8lKX5LAxdAc5IkBkHvvOFagNxTYEkezcEInBOMWL6ycLW3HEWuk +RlQyU1uIkZWdixM4pJSItHTpckWZhZRTW+arbhUYVe46t1Yjd4PrQziBUNHQLOsQFW1YyGhdCsgA +ZJiGarrox8QGjM0q3yLry55fxbFF24qA6SOr3xpNQhlA51WUAseoopAgorCBkbi2nR0mtHK2euIv +87t0Hop6s29ZduGSVZZ+sKxj5AkWrY43nMl4K+obsRCu1mRagoyVbeJKylmdNiacFkxcNA+X0oTP +Ze25aHXEROGYguJM0gPLz9YkGd+DJKU92Vqfksy2qtdsu5Q/ARefK6OO4FlLsSbUmrLmLM4q7IS6 +tikfQFtqMgid6lKZb8y/STuMWHC8frVOeBC0HUn+6ps/hTe/v357dPvxw89Czu/Ob68BrAB885eb +678Kzb8Tsl8UCj46/+niOn9x8Jf3eGNKffX9//zjHy4upZqD33U/5Zz53Q9/PvnLzdtz/BwcQPe+ ++Hr1m39fXV7Lq0K6dXvx48e78w84auQMuz0dfXH288Xl29vza7y3q9/96fquf4f/3cWT7DflV3KQ +/eP64kyA6TzLP/zn6eVH/fLfD394fXrF79AJ9mpbx/Hr7HH8+gLjkP08eyT/unh79/Ps0cSvt3pE +P59f/PTz3ewhpc+ffUw3P/6f87O7o5uP12+lf0c3j+yNfoDvuP/l07sPs0c5KPPsQ/3mT2++uXz/ +8+kbM3eMF28z3vieMeGb/5zR420hk3cfb3/8KBz+2fncWdCiM5c4tfPcRFOE9bnj+Q== + + + 8fTD+R9uz//vR5mE+SR0VOrZR3h98/3dxd3ZI1SyH+UHfv33i8vz+ftzUObZR2jnDu3649V3Z3en +/1wwsrzIsw8MW27u2G7PP3y8nH9upM/nUKB7um4e6Pp66pcdAud/z8nJw519YN6feUEurucux837 +89vTu5vb2QvSF3h2NPv+5uPt2fkfb0/f/3xxNvuIe2Qq8pPuesv3zsX1IyRkMBj7grvm+Obq/c2H +i7s5m+YpOkA+7NG2f/ft+bvV13tpbzvGsZf2tndEe2lvzSi3RNrzX7K09+72VNjey7/cXHx4ZfLe +bCF+L+5tp7g3e1/uxb29uLcX9yaj2ot7e3HvixH3CvtaBL4lI9lykc+/OpFvwYh2ReQTOejo/J/n +l9//fPr25l9ftu1Lj0yKha/lwPzx8uMj3MpnYDa3VTL4cPf22/N/XpyiQwuknrzQi/EEfzz9+OHD +xen1kS7grvDSs9fm7fxj+O1LnMPzBzL/FH77EsfwEgqw7dTs5t27D+d3R89B015o23/HEe7Qhr8E +3wIvwbOby5vb//rXzyrGzKTPv17OVyXGr/cb6BPG8uH9+dl3Hx/ZD7vHEcz27fnw8fbd6dn592en +SxBvUOj5pY7Zg5PF/Xh5ent8c/3h7vR6/rpNC76ANW3pKH//7/c31+cbjLIvuEuySVGV5ew52nIV +hykXjGW7lRyFXTKW/549lv9+QR7krzcX13cnUX3xEvrI8+/jVj2JzMUO8UOv05iwkG/YdjZoI0XP +YmvCdq/RrklGS4wk20IMTm8v7n6+Or+bb4DbJaIw+9j75RFlSjYcfLrFA3mEF88HYrZZVPjFzR+I +2+qBzKfKv7wEUX6VVvjF3MC2H52XF3d/Pb14TJb8ws/O3ZGVl6uJF++4F1rIP5/f/nSOmdwhJmjp +5nqNa/F0Hdi7DG2sUPvqlajTFnilbLcyzZi9x9D2ewx9WUEixzc3l0e35+f/Pduq+Ro9o95eXJ7O +t+vukhLDHM6OK789fXvxcT7qps93Q7u53RLn/IG8nT+Qt9s8kF0TMf98c/v+55vLm59+3SHRZE/W +doisvRpiNj+CZcuJ2asNY9tJYla8HpfVV7PTl4VTbPNWnz2SXdvrO+dx+3pj9mezLPuY/fvG+LIx ++7P9cHctZn8BId/2I2n2Jtv6I2m+hLNjR9JOZlF4xKMkI2vLnO9fyOv+i9zxW++o8eNsLNt66jV7 +JLsShPO32ebU459Pr6/PL78/vzw/W6JPmxZ8fovQbEvrpoOcFnyxc+jbiw/vL0/Pzq/Or+/+fPp+ +hw6jq1OparZhcieko1X6dzX5aQY/546av+bz3+nzLaaUW38SL8s1uM2n1+yR7BrvfYww5j8n8rEr +9G4BZm37HpmtQ9j6PTJ7JLvC4c2PRH6exCvbsvveLfIPendxebnE/+lym1f63e3N1fzB8OPn10o+ +wuRkhrHHPMZzy9jHF4m5mj2WH3En13zduH79/Eb9y3+d/jp7TEL57k5vF1FK/X57NeF3N/Mlj5sX +GMjtOUXAucM5ffv24u7in/PFqb7AC9hjrueP6+zs49XHx72F8pFlRV4goun6/HR2+MvZ6eXZn2/e +zh9bX+D5g89m8xbZ6qXm/8IhzF3AYakXEklOry+uTl8sNeyu5qErwt4ZZssku7NX4wwzfyS7pv3Y +O8Nsi7p3f2HhRKewa94w83Oa7Zo7zAJSvu2H0qtxh5k/kl07lHbSHWY2/7kb7jBf5I7feneYs1fj +DjN/JLtiLNm7w+zdYbblMPoC3GHMl+IOs4Dmb/tJ/GrcYeaPZNd47910h1mAWdu+R16NO8z8kewK +h7dt7jBbbf/ZHW+eBVtuKfF4oTXcxayBC/wA96vwZKvwdDk3dmARnq4DL9T47idt/OZPb75lzp43 +yzRfsxii3TmiXm/eovlqwB3JWvQ8CcBfipouyZOzp2gPU7R6T9FeI0Wbvax7iranaK+Eov3+VgBf +Not2jil4jfRsz6Ht6dmXSc++aAbt1dKzPX+2p2dfGj3LjTpvllnhXxlZmz34L8iGt982c7ZN8yVv +m9mD32+bL3zbfFm3Bf314t/nl3+9PP31zbJgx2102KnKVTXbe1Jn/m8LHCizErtE+W7Pr24eS2+w +Y7le5ucU2edH2edH+UxItzJf23JlKvl/uZL/vpbf8vdrebF6bS7bF9dvz99dXF/MN3Ddnr8/P737 +dsF2y0o8+/j2OWJ0XDuWI+bDe2SJmTu6XcoRM5Mb+dISxGwLD/UKLyj8ccll41vuqb9kLLviq79X +WGwvOXhsb++mXWkRRdhy6rahSWnrw+dvrt7ffBC2/LuPj5CwXQ7gi2PcIYJwentx9/PV+d18XNsl +wjBbp/bLI8apbDj4dIsH8ogyNB+IeQllxOyBPOL8lA/EbfVA5pPmX3aFMu/GIbpQ6tmlI/TVZkX8 +LGfo7pg4NlrTnXEg2gcA7s3Ju2dOXpamcBu1Sntz8rpZ2ZuT9+bkZxzPazUnk7jAoGzLrxcRmr0J +eW9C3puQ99eMTEa2NyGv6e72qIj3JuS9CXlvQv782okdNSG/JmPr24t37z7Ov81k20nBwuHsCjWY +nZ7uw8fbd8LZfr8szf+g0PbakXT6l41tUObZh/br+eXlzb/mju/y4qef7+R9cYY8uLOHOC62vQsY +d+fxzbWI7tfz992k3F7p9qJKt/0dt4+PZq90ewpS+vVPt+fn118LB3b+9cX124ufbr7+58XN5fnd +17fnb7++uT29/mn2Vttr4/bauL02bq+NWzOy+XzYXiX3MlyVCbOtLqf/fXH18e6Rqx/zJUnfPzvi +1bPHdH4pD4tUPlmJF9P3fHtB/v0E++ulPGK+VVniJO7xHUL516R2+vD+/EwOrtvn8IV/dunoVStr +ZpOotMSLpf1pwW1ew9jZ3//7vfB6G4yyL/gCjPcj2twnUE3t9TZ7vc1eb/MF6W2ilkb1NlGJQ/XN +Xm+z19vs9TZ7vc1eb7PX2+y43uYyKjRehQvFXgn19Eqo76Pwt4NaqNeZP2MDfdS2q9heZQTwc+oN +X4g+7XNobBtxeDU5NOZnbNjyHBrzV2TLc2jMH8iW59B4nntAttubePuPz8uLu7+eXjxmpdifnfuz +c392bjyQLT879/mntu3sXEqVt/3Y3EiY3pWjc5936tPmfluO3cXruc85taQDL9T4PufUbuWc+v7n +07c3/3qK+4t2hxJ94dkFdsWvc3ZStH1E/rNvodkXa759hJzmbm3/fgEkmz+QX+cP5NctpwDbTs1u +3r37cH6HLXF7/nYRnd41GeA7jvTLEAA2X9XXKAlsy6q87vvE96LZLotmham+mouS8/mMl2Azloxk +PqPxEnyG8eXskfzr4u0Cd8L49fOPyM0f0c/nj3seZkNKnz8/B/UlKjWeIIv27nBXe6XGTig16r1S +Y2tZ4fBalBrzB7JXauyA+LtXamzvsbtXamwjJd8rNfZKjW1Vanxhotnd6QJHy9comL27PT27O738 +y83FfMdmLTxzjVNLz+2feTg7Z8uPpx/O/3B7/n8/nl+fzec4R6VeICb9+7uLu7NHFFi5xIav/35x +uSBXwqDM82u+ZvvYXn+8+k6w+J8LhpYXefaRnT2dl9lzj2SZVmuL45znj+QJBZ5tORVeX7KjBefB +u9ubq/nD4cfPPpzXlLrptaY6Kg9n39pydzOfn7p5gaHscxcNBrfPXbTPXfTEquX5MsmXlrroSZRG +f/94++PHS5nsXdIjvs7cKwtEii0Xjp4n5coL6XmXxIftVa1r+cOvXof32PxxbLnvWPnqfMcWjGjv +O7ZmlC9uoOj5kjePhN+/bjPFXc6fvSIjRbm3UtzstpVitjfTrhkpsOW2QCW+F/det7i3BM32At9e +4NsLfHuBby/w7QW+1y/wzRYNXqPA93r90mbndNhLfNsp8c1ewL3Et5f49hLfJ6HZXuLbS3w7LPEV +5rXIfEtGsuVSX/XqpL4FI9pLfWtG+eJS3/+6uXn70+3p/PP+NYp8r/LOiEUx4lseIvEaM17MFub2 +GS+enSDs03g+NJB9xotP5DBSHohXQZv3+Tu2loy9uxTuTi8h/q8fL0/Pfvl6paCb96dnF3e//tcC +nfCHu18v5+u449fP78K95MLlbd9Ziwaza5vpD0DEHdpLr1Mjumy/7MS5ulnOoW2/9ecDUzkevyby +9uUwDrt4G+BrYriXXp+55Rtn4XB2RSEy2+vkw8fbd6dn59+fnS7hSAeFnl9Tvmy1lo1tUObZh/av +nxdE519Cqy/vixmcRzbCcbHtXb+4OY9vrj/cnT52lWKuVRmX2yUFunGzN+/pf19cfVxg2uq+f/Yl +J869mixD9eycVueX8rBI2ZyVeDEe69sL7puTaGR8Ca8B6QP38EkkVntub1dufd2zSLvEIqUFXnzG +Tgu+gJ/80lH+/t/vb67PNxhlX/ALYQn3/NLL80t7dmnPLs3tw/eRUO0gv/Q6rQEbcE7bzgw+j5v0 +9q/TXmX+DOlEby/ufr46X5DXfZeIw+wD8ZdHfAqy4eDT7ZUzfnnky3wgZqtX5JEMPvlA3FYPZD5l +/uUlCPOrdCReaj3b+uPz8uLur6cXj0nU+7Nzf3buz86NB7LlZ+d8JmDLz875A9nys3MpVd72Y3Mj +YXp/dL6Co3N39ND7Wxq3kRd6ckq4A2vxdB3YIUR4ramI9slnR6PcvVREr/eKvI0sBtvNiv59cQ7r +XePbdjLJ0tWpVDU7vcQuEHazKuO/6351kLlD5q/5ZCN9vgP7a9spxh+l6IfHncd2l2AwkurPaQPu +CsV4hWfTs8Z/bWv2hX2Kj+dPkPZqcnwUs4WpbU/y8SyKqGce03dfTJTrzqXHeJ1OfItZt9e7g7bf +ngJ7A0b291ecAHkX3RE2WZdt30f5mGaHNe4Kq20O58dG7Znt/Zn0GfbSD+/Ob/9wcbsNKpJtWee7 +0x/nr/EuKDTtaradg2P/n8s0loMyL5eK6+P12d92iJq8Oiw7bFbl6svAsz/u8ewF8cx8KeTs6KVc +TCjsIOr677en1x/ezbhFYnvw/XXqQzZh1bad/dwwzmQXtCE6tC3hq/f6kLgy9Jz75vJyC9ZkW6Zk +M2Td+2ou6cALNb7o+qevvvmTKd/8/vptdw0UQBUgb/5yc/1XqYJpSgoFH53/dHGdvzj4y3vW4fXV +979e/XhzefCbo9O3P52vzKpY/fXi+pffHnyUf8vVdwe9Q80Pv8rD/yM//o+A/rXyqz+v/r//Xa7e +CvSHvx2Uh2VZtmFlq8OmWl0dFOaw9KauIqCw8r4y9cr6w6pyDQCtq1t57w5dWzers4PCHQbj7cra +Q1eijD+svZUqzaFtghSpDmtn5IUASuM9ilSHwQYv35SHbW3km1qaraqGAFfh2TZ1aNOzFGkOTaha +230RDq0PnrU67+pV0aJIaQBoXGDPTImPGnTNGCvNGOlTJV0QgG9bLwAZoG+bDoBCMg== + + + jiY0g29qjyELwFWWgNA0tY7YGRZyMl2lZ+MynXhug2P/XWlkfYw/tJhoEw5DpSMSkDetWZnmsDKY +BAHUrqpXpj401qOhCl2RQvjbtiyEdzJc/RYVo7QlwJuA7qKFql2xRSkshdgLW620V1JIu+kBaDD8 +gkOxdsWh6eQJqGkrgkrbGH5jKxm2zGptW63ENc2KE99ySFhzWZPmsG2rGtWW8omMqD6sG+IGccD5 +FXDC1j6VaZqwItq41JfGr4BXrkQh4BoQCCtfOhYiPsoSCH5isQvgq5dBA31L0z2X/Fh/F/3LWLro +i8cmiryN2I+i70jsatH3NY6HSC7oHmebgy7yUWNain5e4tQV+dzF6S26+Y0LUOQrwFUq8mWKS1n0 +axlXu+iWO6FEkeFEwpuiR5yIWkWPW8S/Nv5oQ8Ta2nkTP/epAswTq8RksBnMExvWZWZnrEndC7HD +oUnYWPUbSwfqbNyO3H1Fvv24QYvJLi7ybcytXuVfRWpQdOSAs2/ifog0g3Sl8oQpYVHKE9jzAXEq +euqU6Ff3TaJwRUfiSAbrtAeUDgKPjI+IJetCVJOpizOAVQFC+m4XBEUVQVvLDgCRuQbSvqCy4n21 +SmQ9Pp4dEPXbNgFQgceMpwpI1rk1ulZI1lll7Ao661zV9xYjcs1gRDJs2SmuHzYmpuE3OjGYuxYo +3M0dpje4fnplAYQc2rQAnvQlJDxxAc1gKSvTLaUQKax2k1YbJFOGWAHLEkAKyTgCZ7v/pq5MG1HL +N0r92pDwD2VI1+seR4nGvt9kia7HPcZ2SNf9gDTXrjb9DsN2CmW3r4B3uptc2nxuNdqflZ4clck3 +sXYibnQ9cqWTNtECoycUNh1HVuMEGVKVit/YKphId/Sc5mbg9qgCC4GA1YmClTzXGi690jg927Hu +PWEnlmBTkljK0BSPIpI745SHSDheGRYiPkbC3NarIeluVhlZzym+iwxKxGyhzErQvZ4ZjdeBOxAl +ti4FE3/C7gm5HhxN8szpbVwdTy/PQQoZr3m8+UYPe1k+ImjljbYhaBj0iAwrnWuvR2jdrKan7Pgg +Hp/U08N8fN6PGYJEs3uSPWYrxnzHlDUZcy8j7kbJdJPxP2MWacxDTdmsMSemxLmOrFqtc9pGXESf +SJebNvJ74DFMqDuGEWQlYPkTVSHdMd170iVrO4aTpKvKedJE3RJxS+QvUb9EIXsCmYhooqGJxg5J +sD4djzjtk4OjHw+Sp/vRzyKI/OYf1xAa3q5+uj19e3EuUonx7W+lGlkbE/C3FTx38rk79I0DBmSO +82Z19NOBrw7LWkgQAEV6KIKpZYGxsYOsuiyx0IOjq4N30vzRkYgL//ERfWtKIxSqPAzBOpknQGQ5 +jA4DiyyvKnnp0RNT1bJUJU77Rjryw2kcXaOMGAQJmWcraOkiQNrlcuDAcRQoBN+N1QPHyi+ZIXdY +l1Wrp7+pwRDGo6WSxqSSOgQ9R5rGYkZlIkNjlKNojJy1NQha0JOkDr7Ww8b1z8dy2FgHNOtA4dCZ +1ukRLLwhEM/J4LRlwflWCgluOsuTUIYhE4XTxpVg0LHfQYNw2Lj++Zhnjat9/kVVV3rUmBbkXSYA ++A9AGWqWcYeV1XNPuIJaaUKt47NlzW3YkjPETgXHdYy9bcgLyWaWI0zJQokzTXZ7ie4LHZC+1zxr +LBby+CC9KvRjv9LCerQY7Gw2UCtTKfsFvWMnwNWyWxXlLHazYL9Lbv4ykMvE2NCQQHi+GjIsLb8Q +sq5HTW1ZR1WC3mPWK+u0nRaMSsAGDtzRHrXhpBF5jzu6aVAJUcJhVYkkQtHkqBFiUlIWFQyqcNQI +TnkeB4JllF8bX2pDERML4GZdc2d6tAzUNaGpEqDEx/Fn94qFzaori/pxPkW05thNLV92PSAim1XX +ReLxKhsEBiqLkI2zFXqBeRDM16nyfpXNFGeTpLMW1nIVZ5uT7dtuObgartVpSoglRIBTm/CKK5rQ +ql/0DKsUL4g5XrFMDgTiFI6QHrf4pl116EcEtYpiru5wmG35StGeaM7eeLOK26DrLLpv/SrbJ9hL +jvhm2ppbyTl9TpvRt2HV70Xs1rIDYDebmgcJyUea0H6/gyZQ+RBJAoiGbdlDQSo9bOS0WfVkhZRH +D0xCQJoEwVeJMmGVQWV64gXilmhbInyR7iUc6iljop4JZTviStra0V4+HR8MELhS/O5Kk5eVBqys +ryItGigGXWjiRtJNzi5ys0WFTBxBgUF6PYI5SAhB1rX9vERBqc4mquBcett/M55sJQWNzdajGC9Z +MVrSYrLmxQgpijHSFFO8KkaYV4wxs5gibzHG72K8AZTuWpPtkWK8jYrxPiumW7EY79ZivJ2LwY63 +WmhIE/gJKDFphjfplFOyUpNwUQ5rm3qVKHBByuR6ylRMaJce001P3Yqc/Hm2nFFIJcBFTkQrZR0S +kS1DlF4TAS5y6hzfxuJFVz42UeRtxH4UfUdiV4u+rzqcIh9PHHKRj5mzUvTTEqeuyOcuzm/RT3B+ +BqYl6I9J18bpy85SU/VnfnfcdiiRnckd3hQ94kTUKnrcivhX5AgoU8dTlp9HzZCRvRpRsYrao7oc +cBvaGW+G3asynqXbVkW+r+LeK/LN51yEDDZwke3guMf7b0AFGh/ZMCx8IhUZr9bRk46h60hOMaFL +GWPYEa/+q0TfOv6SCNJEVUWigsCiUGacqmJax8UCGV0LQb6n54qx1vTssKK1N5FdHrHTxwd/EAnh +25zLrqGslxaEZaj5KM02xiU1SaiIz3WbNLUWUiSJtghRLsJK1byLNBEZ4NHsRAjJNo4Dm32F1aha +HWczXsKmI8KKg9k3jbVKHuoQEV43jO6TRFMhhbAxX2PiBVI2jWq7S1UCyrxQ4cYfdR13g/BDNn4e +TKyg0gqCjRx7ZUJqOO4+wWHVvGJOVK/XELsbaCiT5rfyrc5pY5u4aQVBrM68px6jUt4V6xJ8D0gE +DL/7d7F4Xzq2kTcRO9L3I3a162kcTj6aOOZuyGlaullJc5dPHd6pTiDOL0pXPAzjEriOh+/WKa4m +F9Pq5ud6j1Eiw4iINemLhFcT5MtwjxjauP6bhMMJhROeZ2iOSa0C69W9gGkXAXpl64xfItvdvxgX +Qr2QePt6peVgopKgpHKzqfrOqxLCZn1Xhb9RiBDV0fAn8zOawMEEm7jKgzUYL9N4HadLPcaGMbpM +MWqEc8TJ0KHkFGs5fTLohNgjxM/2xHi/pJLdjmLldci3XWy+25rDzdushhvcan+GRGBCJzg7TZ0T +kzSRunucXaWZ7ogS6/cDysX1ioe+LhjW07mOAKpWusloJDCitv0XwJimyohvp8PokIpYx5MlghJW +Jpqe8Daj+wm1u8MhoX2Rb4iCO2LweHLw7uA//nHwDyqrfnh7UK9+89vVD/9rCvjqjVl9817+lHJQ +ffWmW+Wr/mG8zINVzlDoDEVGWDbCwRGSssQIkceIPt4KKDPZLuPtNNpwLIMuBO1RqNlDasDR4WZC +M1BiTFfuoUX4NKdTUyI2JnQsMepAMerfhHCz0JS8Tw6ANdM1PUomh826lZmeWpNjbQ0GrDkgxydo +wjH9fHL4Ts/n8SmuBaen/YQhGHMNqYMj7mLKgUz4lDT9Y35myvOMOSMtqatbdMublr9I6z/h+lhu +yh3mzONgy3MzZeRhQjsm9AUl0I9OmpJ+oKMm9rOup9Qybr8RTZ1Q3TFlZrHxLE8WYnwIcEjjg2J8 +kIzPmkhURifS+MjKcfAaevxvrhH7JRQRnjhCEeGOQxkG2jyRUxovJ/qViswOnT+sghrwW/gNwO+h +djBtAOCAE5WQeROt6CKLwVxSHzYi1QZ+I0UClA+V7ixT+krE+bb0LnojGFtCzdX6yqnoZmBaa6Fe +LFXUNJCi5CiCBBLFQxpNVDMmMo7Iwh5iSQOJlZoAFRsxrBCcGnRKWA5kpqoSCwwDVGXpD+TqFlrm +9tAbPrcGhkE5/GSAoSLOYlcZfKLq+YoyMss4q6TPNBX9K9IUFJiDCvo/mQJMZJFmgZNQUzCPswBD +FkU5GWNlVUWFIREZKmxAACrVLHFAx1omKFdry4qdU/MCrVsOWqAKEi7Z3oYmIRGnW0VESH1WFaT6 +RQurN6RsH7VExpe1ms6oaaN4HjAHKOrUH6PlpkD18IBgg9xu7AFleumTyML4xrRW7dLeYfaF03Cl +irOC36oGrXx0YxAh1lEH1FhFGnKdrfARVaOVlG3V0OoWyYY0VAP/G1ldTCAAJilDqRJIADoBtKpC +iCDZuzZ9Y+FJA4wu6zqiuHV0N6jpEcNdgI0lY01Wf8UN2Tom0kMbLfqC2lUUOaUdIKhDy0rCmxoe +Ohlpc4dto+IOvjM1qVX6DnX5qLki6hV5g6606m0jvfKtsmcU19FtzlnqNzBVhCGbj62YTABkmNbU +/RQVa+axgIG2jJXrV7IelloFrAf3ZsvdEPd1GT3LSpg3dakjKREKWcW1L13E89ZFcg2KpPKcni1S +yiVHG22d2m1F9GaAicUQXesQkd0pC2HbaFVS5RB+eO0isD2Y+HX0J8r2jvepFW0WlArFpCtt7Frd +6qi9DwoxoY0GwipuulKO+yRHK0wWFeZUjpHKcFAE1QtG0kmqYZ2PzcE61ZHXAe1J9Jc0usiJdCTk +RUfJE60vOmKfDoQinQjqAUZvKeJiwmFP5ZBLxBs4LASkjHoLvs9exxpQQR2dpgbnzhnszuuMzc1v +0YwBYbAwH9fNoYXOztCXxU2NzfAqqHkyeogscIqrBW1aRXxvgpqepX3ZVys5ld2hkc33wxUkUEet +kJcTN2Dp15VsWvg5NCu4UQnuys48Otu00aO5jXrZcV4WOsg+oPZO2oyG8n/I+f67b27vBj7jkHbU +gxjuvasz+Ox/vH67+vDz6fvz1RUdo/9Tvvpa/juwQ5/ckfS0hkVQFnMxkwAucSmboGzwUkZBOdnF +rAJlqMXMgpTahF2QYhswDBRAF7MMsdRCpkF6uJxtkEKbMA4stph14IItZx6+erMR+/DVm40YCMjZ +y1kIGdqGTIQg/6ZsBOX8TRgJKbgZK0E9wUbMBPb4RuwECm7AUGixDVgKFNyIqUDBjdiKqDvYgLHQ +JpezFlpuE+ZCD5gl7IXqbZYzGBCDP/WojGL0SmarjurGtVXy4zadoV2IjQbH3BsuI1O6+u729Pqn +8+UBM3IgCcI7+jRYoa6MmcG5CD2dV0eoExovfV3Rs0pWriUoYDLpZcO/JzRY8W36+kQDG7DXU50n +aviHCVpbZl22liOoRj6A7j2jErRrqZpSnd5TPam1ImsudabIexVfF3nnYzVd/07STCiCs4MnMkVd +104OUne6Dp4cDKsp0YVha6hYu5K6BMC042vGt2Ya8mlKr7O3sY6+itiFvpnYBf6p2qy32qV8SP3E +pHnpp6XovCj72Zkg0iyXUBvgElq2wmPASdM2dKYvV9iFFtraMZvuWrjuKqBID+CRWw== + + + EEYHn1D4LE89QuXcFk6ohOUeDFophMHAa1haN8Ky4VXwDTi7Ej58IdBpVBhFGTkcQokJMC3LDhFS +pac1D4ISWKbOBXoW8PjCvAmroIpMktyTA+ljgOM10IVesFwAQxM8GHo60kKdRzImtD7IOaWghswJ +yD90nFxJ4aD0pOGPEyprmloVgo0cDgoKNdWxsVLihDAVyvaxZSIOe1Ok/hG79JiIgzg54LgsD3Yd +KT/i6Is0H8RQzlGZve7fpjoGVbCdrpnUl74rOjHVqu8vR2XDKhtUnJds5JyWFf+EKpvDNEv9RKdJ +6hdD5yhbMPaKbceO9mtK5xVPJjyuexpvjxzlKs3LyUExeB0hOh2swle6mbpmID0IZNAVok4x6W4x +HVIxHXeHMj3qFOltP4FFqqOf5SLhTr8UismCpP16FZM1LabrXkyRo8hxp1iDW8UaFCymiFqsQedi +DdYXazZHsWYPFWu2WjHckbF7g43bzX62vZt8IYseqYopqSgSXmUEpVhDdzK6dJK8agTU4Bz3cBiq +9POqbet48EWRWSRReCpoJ2uOuVGrhU61zmH6oXMYLTn6vU5168loxmp1RdhY1zxg/dHOd/mr2I+s +htRQ307qRd4bfZn3OdaQOnXSzwB8oErOoWxFPcu7F3Fm8tI6L5MWBr1QSoR3tu17mtruRzMdsu0O +8PE8rZnO6aSvWZrBAto2G03RT8YabFBM6f9uaBpvkll8MlSBTSaE9q7hrFEVMppayujD+RfQZJG+ +ejNdSnSM4xGWf4oBKgCOMEUtkePm1uCdGo2H6AnJYoLFKkxN5iNthex1MXw/xYGszSJvdA0m9OMo +hgOZbvtscorh3BVx8ta+XoNZ3VJlCNgv6aB368axdsRrJ6ebu+tMoqrC1DrpDqGUKSnMtDE4AEG9 +bToMGKTsRGI1pY00ns6hFeICS6VjRg278sZY08k3hoedWlT1wGisRdC46uJO4LGpOkALVG5wDsJN +lbpETz1Mp7BooKDxDJdsESgbAxJpvS2j22qgcNs5YyKaFD/oBsT+FegglGjK76N/Rd9Bg7ApCOtQ +ctYU5mB61vh8q5ot8k9qdMcPRGecHKSXtFQj0ItEpawZiB0rBYNUU6PXTc3JQeqOTmCDfmFWqXFN +0wwmqfK21UAfLoZQP6jmowKbS6aECWupQhs+oHaq/wAKV9eWdV5PkRYxa65Y06tulrLOd9OUjbFY +MxXdRGUz1r3WAi7BxvOvzYHxyPBosJr1ECmLNH8Z7hY58rbJybrH8W4LnDxsIbHBOR9oITHChEgR +Q4dnMxW94KZsoBN00KBDc+zhZM3wVrAyIAoiiDXSGZmPILKi+rH/cIWDTTpbs0SjevU1RVtz2EJh +G2yL3S8M0dHZxq0ezW1VCtAbOtiy0oDR3EjymJGjpzRRBzakNUq6R9RGDRojeqPGkRHF0eIjmgPg +hOoIcBO6QzK9lPLQjWRMe0jbx9RHgFP8J3BMgWg0GNMgavfHW49H0JgOffVmDSWCvn6y66GNn1Aj +6Non9AheQxOKpOdjR5Oo+Z5QJfonTegSld0TysSFW9PLddRJD/IxfVIN83Sa1tEoVSqPqZRCp+u0 +jlJleJrRqgylM2qVYX8xRP8pxco30+SIbz+/0lTwdPXH2/Pz609KMhRSliFhUnwHQbh/YHCQP6wr +Dr50ngkCGPupSYba4DSCvIyGRiFF9Ap3IahPXw3LC7xinRYCfSqthvYHZCcQya+qYzBmnWUZ4qMm +GaqRaSW+ly1svDpzChfGnWqdMdzkQhFcyjFkNJDdqtHC4CN12rZ+mGOIgLMYGDH6pm4tw9NIaWjB +iOHnXrA5ZlAJsfOhqTVVhKFnJ4yOrcb8OPmH8WnqwQZQRaOeEPyq1CRDDRJjIBtAcLoFfA3LJP4G +l5IMBfV51nOApTVVQOVCzHbRqMOsczY5mrmqpA+fYbyR9rNZab9pKhCMZjIAhLJHj4eWHYbJMebd +QNYUWJyMUcfQUDE8zTp4YmrCG4dFE/pbt14tMwFWohphsNFP0SCcmRjRJSZCv4k00aHTIx8A0Kqx +asDzSDgAzLMuxBxDNbxFgZw2xuKEhraPsgyue045hkKjtpX4MpYu+uKxiSJvI/aj6DuiPS36rsbR +EMGr0sa55pCLfMyclaKfljh1RT53cX6LfoLjChTZEnCVinyZ4koW3VLGtS66xU4IUWQYkbCm6NEm +IlbRY1bEPv0RbMTZpjIxI1GIjp6Va0JERJtQHYe1Npxw3ZQxIUCMDER/3SobALeVjcOM+4p7T/MO +dJtPtqc65Q/3cJFvYm70wVekBdEqxvg2EgybVqPyMcOQ8U57JWTFryLZiaa8Ok8wlAhTIlzpi0TZ +io60ATtc20R8qaymF2qMS6l0QqtYVsfoPI8ES8RF403EzrqN6YXgfxNxuNL0Ky0zNEWCnecXCjHB +kEx9MB0EdWhuoFgHGmKAbN8QaXrKv4PeoL8kUrG/xPg27QHSdAzcxhRmHHhNdqtOM9PnF4pTh7nV +JD8EYPLrtpt8S8riU3IH2sq5ik23ilToupiqoca+zXML1bqRNdCjHXxTt8nfufJOqV6aesU83U1t +RimBwG6Vk1Knm5NIbjSZi9DzMCDJTcVvEtHGRmoHO0r3Udp18TDoN6YGNDfe57tX+5BOGRPisVOl +TaWpWzpK4Uhnh9REM+QRO0lvVmkT6Lag8R0r3aAZ0K2gAeaBTBhJW9PoeV7H871NZQLQgjTS6CHJ +HBdKRdtVwjElteTcFQ99pMfqyZ1R7LDKqHlG6I2QESXlQXHaNpEtCYrSZdBx+5Ku8tJ+3XRMCTvo +NP4LHus6BqPTG2rZYxyl5+wyryKnoYpT5ZkHx5UkbzqXejSWnNoWJIYzrckIR6fr6Pwdn8/TI3x8 +yo/ZgCGnYBUbB8zEmNuYMiRjnmXM1Ez5nkSeE3VOxDlR3Sl7NebAxiyaYp+L6Gg1uZDxmgOKRIF2 +YJ8Ywy65UCQpJDlliM+kSMp3kiCRaMWEBkqHE1mLVC2RvUT1EmXsCWMinol2JuI6or7x8XjMYM+x +JLdB1RneNvQAqQTpaqYOgh9Xuy67kEVirGhJTg9FMEHWGtJlsK45tEFo78SWLGxlaJk5SP5WzF8h +M6UWY4iR+CE47BuYl2VF4LpTwv9STsVJdiFKEGvz2WlOACKJZmvyqyLlGDtmPjvXpuSCodZ8dlWX +z87FfHbxqDCMtdN8djH8H0H3dZYUoXXDHEN8PtaEdin1n2OOIasSpGXuqhAz2nV5B53GAWokDPNf +uZjQLuWvG6YYwvNxTGfn8i/ybHZ1zGbnV53j2XFMZ6dDbpgCL2b6ivnsNBlYlzEyRpjm2eyamM3O +rmICyHEyu1YTDBkmvNTUY80qlY3J7NqY12wV06LGaIvSpMypNuUac6uYy67LnRaTRGr+G2ZX6zyy +LDPZxdPGNil7WIiJHl0MTrW+rrPIY2ayczGTXRsz2ZmYyS6YWIZpATVVXNC+tCZmsvNhlMmO86aY +yDgrdVYdprKzfSq740Equ9J2yXa7knn+U62cuezqVdd+TFrWdZC57OwqGwNz2YVVP8oulV2Mv27A +YDPtmkb95qnsmnaUy86PctnF9EJcMSLZqkMoYpjXFa9X3YJn6ORNiGnsKsUuH0Zp7FpFRMWliHYJ +k7IsdqbLYXc8zGFXhlVCffayaWMSuzSORjdU7TU4m3RBk9i1q2wHxmDtuAEHKexiBrtqlXZwmsp+ +j6fUookMMIVdlVIaV338eEdKskxDhJwwrx3TQUUICVSZMim3HQ3rSVgic4nKJTqYyGAilT2lTNQ0 +EdN1ie003VCjeQDwfpgy2jXDlNFNypxXVxqen/WhqbOdFTup2VI1NjiOQ1OqajoeDlWTrnrTzUWe +byhOIJO3cnTpm/EixCyXIVunYryUo7zRSRzMcKEYIUsxRqZIttoM34oxShZjnC3GSF2Msb4Y7Ypi +um+K8dYqRluvGG/NYrx3i+HWLqZ7vxiQh0ZPpSwVZpcuWkkMPEWOU7poQypUp8BgOLdGKlVM6Zge +1k1P6ooxLRyki4Zl4zili+4pajGiuEVGjIsxoS4yTE7F83TRqY2Ey31HBumiq9CPp8gHFMdcZIPm +rBT9tMSpK/K5i/Nb9BM8OA8b169TkS9Ufq5W/cFfdIsd0aE/m4vR8b3qUKrocWqYKrqNyFo7H0VT +W8XidPdmpugmtpElitZdEbUCWc8aHzKupUjEu8h3U9xxRb7ltE/jbVtk+zbu7P6buPc7TqwjEBm3 +Ns4SHVYdoSkm1ChjDTuS1X+VqFrHYXakL2NDNVF03bOqMVF0ygnOVpgoOuF/UCRhCLnr+eKYKNqv +ihExLxI132ca2mca2mca2mca2mcasvtMQ/tMQ2Mk3Wca2mca2mca2mca2pZMQwiRTA69A5feCnYW +MPi1aZDd4KqHIeBTtUgM+KQ8ApOJRlmIaEWBxlJmU+u/YJAKuyFYVWwz4S2kkGBDtLjr3V9t5Uzy +B1HMk1OEaXV7B26kmGV6eZwrvOUmwOLfuWrUDMZnmoFaF9JYG9M+p4BuvQ0A4bmuuwjJMl0+TEhl +HSNByrg2hiIyIlKsUU0L5Xb1UqAR06kZA+sfI9NkJZKzQgw2933aE59S2VexT/ic5yfCWVLy/Ep9 +xMIh/eLUiSemFWilrqj0MRHFGR1MsbWKs8NVUh8FE43cVShjwLWL1xRAlUCIBnEniDontWVMkKtf +tYdttCskA0M4bJs2ximH1kY/qNa4SD89N6CMSeOLsKx18Mob1zEymhA6XHEKs29kbmIKXd31SMwQ +KzaVZqiCRbCMWSk8r0Ny2DbRJl/Rz0SmxKuHBGx6um6M0FYTT8ObJkoNjVd3VZpgSl4CU5seAk8F +ka6JjhFkqW6xfUUOOFWnxhwteEmOjh3yMPT6uu9zxThzmw+sjmHb3eDr5B6Z5gcaHxMvrIhT2FDb +7npQAO2IE8/xMoYzpmJIQypJOHsyCVzQlrDuJdlB72vXA2hXbdKtZumbmJCgIhcj01CVAzQUkKWt +BCBDpsWZ6GvENMYApA0KTZXq4a0NqZlApSINCAC00IqZmAdbU0Z77VqWMLqKKf5jYLsmtsiyRQc1 ++aquKH1R8l6PlbpWaJb/KqX/1utknHpqWvq2aJJ/E93JSK7qqL/vADT8Rk+QCEKKaKZvBolHkoeU +6J8AEE3gTlUm61+Jg8WRvsXRxXz/JEopH/8ZE/6r41KW8d+oq+Sa/NBnB8UgaXpM+u+brIZRHmrN +OISuuGR2rIPmRG+iBw47O8p5zREVk2Eze7aJNk8l9pi+wVyRrFibSI1+FWBIq5p+GZDTu6nidBHP +lYwxAYaupurjXRnvCrRVFP9DSM9KMJ1z+QdK3YlRTZf/P8e67iIToiodjKl5jGktmM5llBU95nui +l7wq1vNLANSDLeZXj8nXux/qZtklX8/uAahVU5pdBBCv9yOzdXYw6ExMx44OW+1wfg== + + + F8CqSzJ/dpCxlukaFjvNVh8TqTO1emNSc7IyRjPf15Fc+UYXWZYxkm7lEQRdmjg8mzzh+xTpEcvS +nSgdxncZ+8/irQCc/OG1AEBxoy7r3UUBZUnycHbQg1w635ALpIJnAQ7xUneC3t5wqByRaspKzxD2 +NjEyHd8UoEP3qykn9VAOrTL6S0zj8GUdYbbWOHwkz8GOD7Ys2W/hyHEjyA9XB3WjOVbGHwocCXbS +l0dnM6s8urdKUxs4gbqsyi6MY03kxpShzKDLWMooci1nKlWG2oSt1CY3YSy15CasZRRjFzOXUWzb +gL1EyY0YTI2J2IDF1BCLTZhMKhQ2YjMZGLKc0YwBnMtZTYxxQ2YT6aWWs5sIJd2A4fzqzUYsJyTq +DZhOxhUtZzsZo7SU8ZRCG7CeWmop88kOLmQ/qatbxoAi2GoDFhRrvAETCoxazoYCexcyosyKtgEr +SsXRJswoicFG7CgJ0EYMaQwQX8aSKoldypQqRd+ELdVTZBPGVEPhNmFN9XzegDnV9GSbsKfa5CYM +akyvuZxF1awDy5lU5ZeWs6labhNGdaQobLvI/+9gq9JMlWnoV2pO02CkWmPRGqt3Jgae69YpEe34 +OOkqSW0Bzgqhkei7MkHwYFaPZPXDLXlHKoeDsWgOSOTyU39H5aFsukYvkoVszoEdXj36XYlrfLHv +6O7gsP9Uqzoc0PEmfLocvMbEK1SFPdFdE0zl4FyLlLKCxKD9GqTNBsffNqH/7Ohsdo1H99foW5l4 +oUV5tfez6mtWNqqXl6wt80xssLq0wS1fXym2yQo/gOBktU3GWF8xbUNpMu5biJoy4ZE/Rx5IM2Ti +bZfzErmE452lIcYDt3TFtOmCNXA7rVXn2Uh4rRpPANDcpMLj1XpDKSUUpfgardFfAcew9OzWQRJS +0ttqQG/7y9oGF3RmdJtUvRqQd/lFhpEgLAcADESHsIHVZ3BzHb0J64ZXUMq3Jnp5k2GmYOKiJQRi +3mS+N5KTGwRNRFG1PmQ+FBl0i1gX4D92CDqENNJBOzn8lJsvfXV0Nre+o/vqq6z6Zg4qvX/vrUE6 +jdRfinaaSngx4nEbLUU9UoflyKfZaRajHydpOQKy2HIUfIBAdGoCZBiDfuKqT7gVGEyuLCXVDU0k +SkkpwYCnKunHPBwpKqgEqsRMGgB81cR4vhYcMIaJlBzqbwUuWobEhBR8xsiljEkNk2FJl1KmhigW +9EwNGZ9AVtP1/FEbs2if9TdSDi+kDPVqwGaFajXUFJbQBdDNUqtlVid7GGVQocyIioE0hQGqLxiz +USPlb5JbvYqEzM0xmeyNqIM0UrV1q3sU+gkK0kGYZwpdQVBMxFPBERzPDQRFN/4W+xiZlPpvkVd+ +br1H99Yru0aTDw8qfkihNsG+LMfVAvzTUosxUIstxcHU2EIsVPZ+KR7GUsswUWd2KS4+RCZIpWtN +Se8M3WFBFeE7CM2bq5PzNKJS6qQXBJYxjKWF/KyOj5bEv5ZDwMTAWrjw4jRIusT+euE6mSSo/QIa +UJpkZ1pNe0FdAVNda/hhiNEV0HoEjW9U0QVcI6MrILQGs5oMacPNWMO7nftAZpKu8iIQthy47AcH +X3emM2Ke/mr8qS1b/aL/lltxVq1H99WKeEROyKDWB/bhdHkVuHSBVd5evMSpsYWLrMUWL/NaPEfW +Jtn69+Zt+mx5ZD78cn73Ww0K1cSb3x0gDFoIG+VYLyS4pSTcIty6Sy5zOj87t60RRihz0iA1LE90 +oZSNLJyDRjTK17ZGvIiB+UTVTWXd+A5A9p3sR4Iw06TFqZEgrFU4tlSrPDMNemz3GKcEs7hXdMvU +PN5rQMPunhBPv2WQPxQl1Nw7xrsmiFUdPjimVlNVa2wPNV5V98yYf95e3H3RjGpohm1oRJ7VOC7O +2EkPgfbMshW98b3RL1Kr6VllC/Sr+8KPavDDNo4nY8UcOAp+Nht/B4m9l0LG1/14hRPU9934a+R9 +KH0HqUc11KM24O2qkH78HST2PtWZRpda7cef+pUgblSDG7VxPBkrxl+MO3eVgWL/C3QG7HwaYDGd +gwLdqTI0KcbzWIyb1+C80TwU42F0FadxFtOp6DrYfTOezmI848fTkXM6iIeD2UiQNAxiZpNNBlFz +MBeKmiH7xI/q8INW9MgGJJuIBEkjSJV2Y4ztZtOQutZ/0ozqaAatHE/GGz2jEQREewkUJV7kpyum +aSy9qmhSZkTc5aE3UVAo1DyhTHgsy+jVxtVBMBzceq5OFgoTbq/l5eRdTbjDx0ARH+INFkUDa0Yb +NGCnJkspL2sXNNmwK4ePzLFheliBdhpEU9n4UMc3wD+LW6dK8IYnfLIxUV9Xj4uv0U76TcRVI6DL +Sh+GKmAbClMODbGHSoqeva2picfDKT0G9ck6fwVfJBN07Gk8JdlL07BUzRsZEIPHDIyouKEx0LRM +zuqiIF0yBD3r3fFB1vuTAx1b3UGycWcTIoWyyTo5yOcx1dD1NB8IBhaPXdjJW+ZQE/wiH3yFibJ0 +7kXSChsPJ+SRQboPsFaUqoHr1ExHQMlgVF91pY41JXM0GFnHTYPIMksLaIW7A9yqB9RIGNGs+kKN +JtOLwRf0Boh2FSZybiGNCUogQRHzsas5ugM0mtIllTnOxip8mgua0zvIWc7sA7Lj6ADRQyC5Ueky +maPjeDbjHiuN+KuhfXCazk72vMYUEYT7HrwKNTjskV0mA3nkh2hr9dpKQAg0zLTZ1WW6QLjUYILQ +ccszcXD/lRfeD9c59TV1kKzBDtb1q6sp9X08vrMUl3HfpS5HNzeXvNXF/fX07u789vr316c/Xp7/ +8ePF2/MPeqmL7a9+6T769/ub27u///o+3vsi+CRr66EZK5Wt9k414b/72/np5Z9P724v/i3fDSpp +v7+8ODv//uz08uL6pz/eXrz9f89/jdVNW/ybMKMf7m5P0f2+3cVc7MfLy/O7VbE6Oj375V+nt281 +H+LCW2QM4+2rmHDZIqqUz/RiXyVQfPIpdBBnVExWW626gsXw88L4+AvMVfzJ3ZN9NKyhK6chWCu2 +MujJ4MvU+eN+HPMvL1nBf6FEpiKZLKGauOFqmjpXzko4FFC0Sw/Q7lYi1oUaUlH72a8s0claURMc +s6RhwCvN1MmsUt0kpSlapXepjL6yrpucLjGxviyyMoV+zMXtl7Zvr8g7Epe1W9RVur5AXVCISfor +Zjjmb/7XP8XW/Co2RtGwil/EDyJXvlIJIL5IX2pRkPnY4a7+rpHYi+ODrjsbxnWxqqv4q2tCwbaz +cOPnZcqRuopDzjsT7bXs72X3ux92elfEOuNPfNq974rEb8+6/l2OROrad8EY/xHjMTpRd/UTs5Ko +54guGGNG8BTvzTCMZFGfEL3BC8Bo+lZAypzAW7d8zIXNh1Q+/eiLsJn4eJw6EZ/17hfTfzCqrm+K +AY6pEycH4y6magplXdM408GJRBaeVmae07yuEX+Rg4WvbLp7GiyeTQnk+aGN8fFt25XtnpM6ncEy +Jl1yok/p276QWaUWCrZnFEhZN95fyMYHTcex63Q/oCkTLkKkeWYHb0sSospVa+5OjfdBldFVjJn3 +PLM9rOIbarIqw3ULlunUPFVpRf+Bq2IuzIeKVk6vtjw627jVo8Wt4k6pGmmKe83begrwcLZw2UCg +Cd+qI1e/b5J/ZNo5mkx57t5JCuK4e7LHufun6063g3jJ6Mw9RGtbv4uyx8f2kd6sV/a0pooTFQmm +6Qjmg1ssTV/cZOqlOmubJV+btuv7kq0WSatJyc8f3m5pPCf3D1twyoyhtPz7nsCuJ652NQREIgJ+ +wAf6ButVBI5eDofRo6dhEhWIn4bGmbL7BTvz8B0LN21XOK8bCsZEQ7Oe5D2KHX/QhQUWD17+BmID +/0ZkLryX1lhefcy0rhRP810L63ajuREzEsOYzEPmlF1XAg4stm1zyjKzjaO5bYDVQ4LAjI586s2S +/+h4/Y9Dbr0w8RpNc6h9uDpoeFM0/ZmrJtTY6Alk6CSdrrEalLv3hLCOi1aHEnkO4xEhEi109w8d +EWA8qph7mD6H/atg6kp9cIVcV+qxPlpBD21O+1hhFy+dHR4TC1s+2qBlmE0rBOJmRwV4eSEOkLpL +kfBFXm3woywb8vB1aGxFrl76XQFi+pSRwt/XYOYZuKtrZ3wln191ICgAfVPF20t4E7Th0o5KJAZb +jkF9AQ0Z1D5XB3oHdFdQ30ORaKipmJRYC3pIrP4Nr26VAde/Xf3uexF9r39a/ebo6Juzs49Xf7u5 +owybYfXk6NQTYU3PNbC763v/Td/7NeUSEV7T09/lz6vf/eXm7m/nZze3bwXz/5MdUcthxXtGoHv0 +wcD7xU7k+uNv/vTHuFf+/u7m9kpfxVHK5n578+P5m2/+1L6RTnx/9+vl+Zu+af1q4axlh0d4yND1 ++XQcT66U+PbmXxtc0PBlqiMcM+C64KuWKjtblZ5X+xh4I9VhSpQ9M3DaVUqBy4dCDc1NTZ45qMfE +Xjex101snW6iqSOLHJNEDKSvz840WzJyOV9cUemXfg155kqdBSPPzLKfn2UGd+IMHIkS0+wbnHkP +Mc2uQTJFcw9HizBAE8Y8F7bGfUWqoM4eQ7Z5VitHs1uBAE4jwOdjnNewy7V6ncTcyjQixYSVCXaS +wwyMmvEKYA22WAfqSrKBGEcaQV0sBa7hLut0he+wH4/x341MkRDglbLfhjkTH2C/6Tnn6PNglYT3 +XGwIaJvzjRDbasR8w+8dJ8TDRRvH+7fPNm7zaHGbOKac/fxMt0tpjZD4BrbtqwwkS63Lk4HKCPLd +FWMdCGKVXijTgfLlL12TLqsXccrln8HIG28N62Fo9AFYNYXFIZxMR5VOt77XvN240juEbVe+0Y/z +/nTtwDdxCMpH18SL7+UjYwdfZTM1BXVNrgE9LG1ENCk/RdqYdO1qAOx6wjjcySwNoN3YNGjOjoFr +5ophm+PZWtOpTxNlCtAIU7U+aBis9A4iZF0/iTSzaFWyc755JdLMH25u9xbWvYV1L8XspZi9hXVv +Yd1bWPcW1r2FdW9h3VtYd9PCOrGnXh1MjafFGhPrGkPss9pYjd7Mca+NFVyvfaysQ6RYWS0ysU4a +Plre8FNZWIs1Jtbcnlqssbfea2Mt1hlZp6bJ3HQ5LbIe9vRm1nWdZ0aozMy6ZjDrCn4e7UQVcH+l +2dtan1Q7cXL+7m5va93bWvdair2WYm9r3dtan9DWist9mMXo6qDUKwA146DII4amowRL1tYTsmIx +wncMSsbWrOAaUF991v7nNq4aBN4hFLa1SqB7Y2WLNoPaOZlcaGhbRQAbbux+sGhD89LIuLqkzaPF +beJY8l6Y5s/Mbpe80xEaJZo8nSUuJFgynZ1ksGTKBKyawHDPYePWgpLBMyuYg8p7QcnYloFSZxWL +GIRbDnrZf5BuHkx9pT2vbEkm4xYr8z6l9xmo7wBy0zZuHWQwV9Wa+Ru3vx72oFjxOQ== + + + pIpp5yhVTEfRA/vBZsXXAvtxqIW1m9283fyjdVO1qahSJFqAtGa1YH2AHeoJRJQNJZRXYz/928VP +P+9FlL2IshdR9iLKXkTZiyhPKaLo5aFJjoghMrbKpY0OlMkkqeA6UC+B0N/TqQCSXufyybDxZxRS +gg7oPiEF6XUq90jRxmoak9lSyqTRsQfo440+lZRC98q4dlFIoYnH27R2fJ1LBQrpudQE6eUL+u6N +IFjyyq8DZQJNKjgElfeBes52MozOTpFqzIWTCMqLm8OUg2UCG4y0moydkJ7zZinn0+wNG18LenLB +ZDLgFFU2HnIGzYWQ6bB7WC5y5EPPWh2KLpO5v1co+eKlgX+834sCe1FgLwrsRYG9KLAXBZ5OFEhs +OLn92qfAMIKQsdj2cVvwxetBGtXh9eJsX9qwilFgJv8sCQprILHBk2kfnjIojLf3DHhsGZhy50is +viYmLDxSskHiz+aBmLDHmpyGhD3SJI4nO0hZ/3nEgS5QR9NkdAJBg0NEALqAiXvrIYk7XwepxhBG +/sVlV3FgHagrl4FS5UXiRTNQCkDLQNPRdHLB4FUKBksRSVnbfUNTUBfL1M3HFNIVY915NdMe3AN8 +UEAQzPNG2J5PEhDGg7waALOQrelAM1g3tBjaNYCsHVmMFhtO+Zr+fIqXVaH5LHAfKxO7GukrHbab +p7BgLFqO1ySz3N3JQIRErb67Pb3+6XyjEDBYf3GrB3yk40HUCDuETPgJVITqMFhvV0ii63EhVgKU +SJeaHorudaqg6GpIrXSQ4wOCmgx0csBytodMas7bHXcqFk5lU/V9g5Oh3nvemVArtwONWd1xO2VV +PXjgFcJp1AbXjZqmkiODhwLf4ZakMjR66ZBwJOYwmLIa8T1Im6+XBz5cGh7PSJ8+iqVY2PbRJm2D +MZL//PgItE3pA0+11pY4PE3jvU9qNYcfoD5eLy4QoUzv8sOhyDxEHSq4xA3Jalret5JAstwu4oLn +1bsJUMrSpt/pXSqdCnfIEJ9zZHAdP8RSVQ8qxtUWeZvFpEddBV2nM7zvWp4MtkuhlG2IxBPm+ybr +ZuAliAlWIBSRPQmCskwHkCDa0fiAt7xnKtXQVZDtjFEv+3bHhca15k1OOjTp82Swx9Px3yde9i7F +o27zCJ0MbjL8vKdSoH88yR/7yZxO+GRZjvPuZAP46s2aUQlwXOOk0WEfh10cD2g84vHaHWfdyHsx +mb97gbkYXLn1Mn46eeqaV0cha3yJfOWylz1SKqhhIr5NL08mn99LlFsbJdDgWr/qwha8VL0mto1Z +3RtT8Voag4uQmpynL9tw6BDoI0w9bqcayKCyLsg3odFQD5YNlV7dLeRwcYNHmzRYxkshR/T3E9Vj +wqbxVnMXk+TLkrnDGFt0kt6mlyeTzxMBq2uFV4fMkn+VAPFZSEiV1Tr8eA3g6WMSJh2WfZJ1sfug +69KkyBcQilD59fv9c114pFys/UQuVtgJZ3DZTmJgKxfwBHLON+EQt9q5HqC8a3woutepbIHCqVo8 +yAGVPSmzmj6cVJM3Mu5B1rus28eDQTzKmgoN5E3jkTV1woDVD0fd4ZYP3NVsGuFXahuGHF4NS2qt +EVi4bXMY4+sbAfKOrYcLB5CnSSzespaPNmlZiN1h03xutrRb74rGHbB3TXDxGW3HNddrfRMgMkBW +11zfpaIs2a1zpWaXwXPkQ7uPi3FVRd5OMelFMexlMRzE8WhQHe/Zo7basYaAyHXqBRs1e9XEdttD +Y3hxeYJot+ID3vLS0lRcS/eYPuhTbGvw7bimvJlJJ4adHI7h+GA8pse4y7xXHWvZDyLvGe+KzbsG +RrJ7PMkf+xkbTem4u1kXUo/lfJpCBrVMWhl2atin8QgG4xutUd9013IxAzLgHKvsxshsD977Q/9l +GGU3bNzt3TBTLUBMWhRBgjjhsHVtBhL+jLdrIaaSurNQ60VFDKX1bdypuEMHN26S7+22F6wpCInt +thj75Xln/GDbVSrgxHvA9fL6vnf6fHww2IkAZTs9gYpJvcW61otJH4vJMIrpUAtOB+72TNNRYMZ8 +mc3rdKaROGPdlZBrliTiyHBRBLjBslDK2WBhtNzCpRmMJi2O7vdNlkeFyA0WCAU3W6LRRqsjh9aO +ZbP2UK+ishrQLiw6TuxgOkjVaAbiGjomqTo9g5FJvwu+lPlIhQst3axS/R3g7KARSuBNBhIWt8U9 +3F0tCUBeKf5OzafSqXvjARxPhjQ/BRSMmS16XyL0WwcpaxFau4aTgtoMtzpqKqj4UART+kPkEhDO +rtT7xnvXhc8imXUTajQLyhUmlOarDiRz5uOEugZOPwnAIzL+Tu9S6VS4m774fAyMwHV3HUSEE6cY +oTWkZ9SefndNp8LFuP6ibyAKixmqxJHVuLKdWewiSBAuVa/3xCUA225Sv/RdKp0KZ4gRG5axBzj7 +JUiwaW60hvTMebPdpOrLVLgY11/0DUxA9/MYA3+IvuGr7GncslZqRwPTu+mHg7er8eT0E4evJ/M6 +mfnJSFBsMgWTSeoHMr5Ft2q6sz+6T4gkrTcoCh9a4nggavuA2x47YnrSfYavbJtDuoKfJ9EFrFaU +EOLdwq7slOCqhBFSZJpaFTgNhIaRykjOCGqyHi4MnsuaJqqMFrZ4tEmLJXOEfPbUFrTt6TLgVnGy +ZJXe/xy1Rnyd3p5MC2R6oya+aF1dWdUcNVpaISfAjb7ucYG1oGfRH/WNNmVkgWJHcyTuP2X3Sj+A +dcW/AG1Sl9ii/bxqpD+c/vPm9uIuao/+I8kYn/PebFxmjmubCwe/qgrmBuELa94mmkCQe2rQTQBg +UEP2shbKDwdWsGrVKTPUUDXZVq/4xJ2kxqszZxscr9TWbFZWn48PEqRFDht17ECGI3hZyqbCbaBS +Vl7w8mha6BT9cNtq6pu6nVqwvt1HrKVpulp4zWxqRK+Z7XpxonfUGl4HHntacDCExMHwXl40m42Y +omnNS0fjtBScOVf1M1dwenGYZP1t0l283VfSrvBqcLDk7bpVNk5k+KmhIsB90fF6z/QVKkLqmH6h +xot53PlcxhcysrTKSNjjbQ8KsKWEii1yTzu2C786g8R7xyTtRidEpg0fOBvSB3QcDYdBUDOkOvSW +FV5N6sYTkiDH6h8Yyjb/qqYbFAG8HlYAerOxk1ZbTWYop7kx6o9chppekEheCgimj/Oph30dNP8h +HmlRrit1Jz00sArLbHsro1KZqJFJXeEIq0yOcGCP2V1+4uMnuBLca5Ij1gK2GXfaKlprS3o1bkT9 +OlARyq6arqv0AIXmrx8NR+xNPmTOiu9nBfPWNNm8TZb5eLry97u3PrHHSIU54D2v8tetPK4C5nWv +1lsVQbbrutf/cX5Jt3mS3W+fgPRiZ9tGr0mq6StlIHGEln6cAfl4D/WSZVCskv+HmiQDFuMSxbhS +3BhcKdoAYXHjdQJ0z6lMXyRVm2pNbbIf7EYGGX08qW3U3Lg70x6/gxt3if2e/l5pXlXk+gORl40p +bBdFTqKOdjoDFePPi3GN8j2dS+T7gNONZCMCig7Cr0nj+mKp6qKrOzVcsDMFewOY5cI0q0mJVFtW +7aTtce+mA+A+RtBD7ZRCeufqeNtVyUmQrQaPJZ/y6QehBdTf8NzIILwfOmZiTDBc7x6QQRr1yDFK +2tnS95Gqo7rW6bCHpXfq+SHil+UPNfvLCteN0VfCjAdeHu9g5TjmlfaOBA8qJOGc1R9SBW44DHB+ +HFQSNbPGwacbPj0pjxxSVji6wBcWOaytmqh1IUz3FTk6MPsWh5vtIWcHhmeT6UEi57WapBQheA2s +w1hDPcd0uA7eiq4hhLyFTFvJiI82LngHCDgeZGLODjqQrExV14hdi+MUmkgtngHzZOkwACHC6Q3h +Tdm2uLpeBNM68NZ0nJOBN4SXUg+nw5Sm4oXsuLtbth+vCA8MPYEKyFvDi8ed92wHvvONtgN3+kM4 +XHISRX6pUAhnC88dEGbcgy6fVv2T7PUKYzk+yEAh+Eb9cmVumiEgUFI/VPWgbAROrCw+DdLSr9oi +vC9ENPRxwXGVOZZLJoi8kmFGU/rF4XZ2oLCLInwvbR76xtbUAjWtXnAuJzcAMoFwO8Y0tMGjHeCo +KznKuoGzA1G0JopiQl0PCHHSWUhBaKEWxgsup5WmYnWtnPSTzYhNCr4gkFNCT2tr1C0erIHtQOCm +mqplkkAHG2gPwMKUQZcogmQWgE5dJbIvvTIrqaUIEboiaAkX8ATxCKcF0dY6useulQ4SO9JVkHo6 +Gc4ZdenPckc87ctbyCrcXJ1HVsE8CavgfNTuCwqYEKBWktNSmG7NoNzKXmAUTAS5Uk1eJ0DZe0Hg +aMvaJmdxSvXqM+nIHrNRRU1bBjLMMB2s+EWrgOqwsoF7T2T+tslhrInBOQC0awBaCgCpF/Evfc2T +AZ+kTOellrU1K7uSA1ANDRFw0gGavpsBLCd8yqagrljBmkNYA4EXOfMX6VUtOlFg2BvaVFKXss9G +vXxYbfP5Nokcr7Ww+JUcyTg4PPa45ktuTd1u4cb57vbHVbE6uvzI7WOSFtXM3RaUlch5kh5fdRBn +D5VUBr24hw7PJMhFBir4edV/3gFSjThNE0hQUo/+WIFFhJFB7FD6dXYwftf1MBYe9/hshmHHud/G +DxAIYTzcRfAvglPJrDgcuJVbyfmNoB7oS6D7ZVtW6SV4VC/0iBd9UBrFbR+N9NaJLNabdzZR083s +0+fX10UtpoEYO5xG+9g0TvXkMvih0ydxcYCHQqZa6wLje4S7Q9K3BBJh7JCcDtI1t8CSBBCmrSXr +ClTqYEL5jAbMshqIZDgr0g8ikimpyiGAJeu+ZP/c1Z5AqQephtTFvv/H2VhmWRah39SwG+9p/hW2 +2eklM8JlN2viB4R+G/lHcS898JIZIU3w8jVBDgFhmqZR0cE2jpZDX4JllWargC3Te1LQqmhA4eRM +lV1Wt3qW8v4EyIoNrJYuPsu8VIFTJXVDzdQD4twdHyQQ2aCqWaUaIIQ1ae7465gXZ7R1EzpQwdJV +X7oDZC1ksNiNrh7tZup+UtnhuY6oZnmfRE6wgAcyhVUOydqKMCiI9OKAWIcDr8zxpF/HSrKq/l0i +Ualwes6nqwPFXqQ6Cg0scbVqC6ko3CyaetLqVQZMXRt3vR+WBluPRj2dl8nksdx0kvM10HEx8job +9WRKJgMYGw+b/lIFyDN1T2kgzFkatB0NlnA372HCdkMzS29dBrV0Wmd4WUPqSAA97ITsZ99Y+EDb +rJYESE2dHXQgCJ6NT7HVqAah24aCZ2qrg1A+0Q71X3Wd7quajG3OEWj8Q8Qb4lgkNfqz4O0GrbO1 +epfrLS0docF0h2y6DaRLRnaJdFv6dM13hHkVtsA2G+uif4pGnh8mQyUBqjcjG5x91IhUGqqsng4Q +Gzs7yGDdTR9dRW1SaaTWIkA1UbFL3Uddr7uKxmP79OmWc0aof6UTnh40EWotQnCw0A== + + + WJd6PWWccQ2phZlf2J6K8RMdqEUYVqPW4pQiSFVn0DK5UHUAnSmIU9k3MQ6+ryUCUktnBx1IpPQq ++uxqLUhuW7qspQTQyWVv+m9if/taRmP69JmFOgSBH5pLJD4glwjUHYhzK6HmqXJcbuFKVOrFPBpk +3UGwaa0wFw0JkmIcNW0+xs93AOjCXHQfiyDZp20wqgSN9WSg2Bi1VB3MU/ux6qoS4adqXeibSwBo +R2OXEqgfRqxlPK5Pn9xKZExcbcfJTQ9gScBE8FImYcrRVE4oMv5PdnSjcXAlvaOuekgbY0aE1FPh +WjBkLgDBVOHUATDTmAzXgwzEa8jZqZYOEBvi6nQQKAxXXSVIl8CrkVJDCQDNT+xMAuUDYC3jEX0G +Sgz/Pp9ocXwoNNEZRH1efOVcLnEUgnDegtThjKk1fL6DIUaTfoVQarcl1cVGeehAny/XQwQbW6G6 +1IR1Xxmoq8ALdjV1kNQeNnuCCQlzNnAxYk1Q/ZLSdO0lyNlB36vuq67nXU2T8X0OCowztE4UWB9A +gZ36wfHWGA/m/95Dz4mAWhsqWEzZUqhJIOjxrdox66qljpInB8yPCNFNz9jGqsNPEHXh9H0VHaBr +5uyghxnccuRWqRbVt6i/ARvqAGcHqS8dqOt/rGQyns+AzDKHJh5z8TdSqQQ5UB2OOWPhYZ4TYwqN +I6KBjGV+RXWApyFLTszQ1tQrU5NuYVNoY1AwThohQ8p+YlohKRzjzk76YXYGddsk/3g4NgklFUCT +SAQjyM/gkqEcB0zADTOsaWKcNho+LPTJWCMpqPtAlqIGr2qYcsSrUxwsMbhniLfeijDvQt1As8Ug +QRokPTOu8LIpsgKHTpX40VuL5sOGH1BxfMzD37VqLEzbmqFnhAdYSIbzdnZv6FCl7nBlS3cvzCJz +eZQtjHEya85pgGWd/gBIN0wYI+D6WVuk/GlicBGz7tQx/U4TIhkOVvcBg17lwKsgzOk+c22lkUVe +UENmEtYV+SWiYbWmbFMHXP3n4Ojd+MOybjX9IyYieV/4sm3nNQvXOaxVqNQqIRK6XVuyBgI5r8Hu +bVDKMK/HVBPRf1kIjHD9wbePpRB6zK9r0bI8zfXKTSNr4Gf6ySUN0zq10oMI+LCeiWasnlYI1XMw +mxVwY2yxNeml0/qghn4NYKbOvKKivsTmquF1QmWHEF2c6sdSUa3xSQDhFKiTW46D5RHPrZoB8QyP +mTOQJaOuSyJBwa7Ky7eVV6ZlCAbtmkwgbpIggcXJw9QCcsSRRa7gCI6NH6JHFXpL8iGUIDKMKVmn +xY6vI3uCIZJ8BGVhapQGAEkdjg9IHcAV2ugUkxgiaFykyHTmNqMXCEGsW6Jk29b8SzmhhF1TCGhT +4yIIKJ6MHFgVSoVINmBPIwNWk0LTfljTywt5OWxrI6vZGrKaHl/JLgPdEFm7giBHk0yQb2Sf+TXl +TQOfmbaBQsOAUEKuO1LupVHjjUwzjCXz2gYFqJAtiSZNEAikR1lTVHY9D1/K0q33SjzmdjvK4rXq +/OhF+mnkY6NVehpvUWBwY1+eijS5NkO2U2OjcbpVbXWlSZZwMLtGxS4e5/R8NHSU0wQqcAMhnaG3 +3GFoDZ0SmHCJX2miR8fcDHrBJO+0Kxz5X6olLLQZtBM2KkqaWl0Y4YIZoHOC4zdFHyE/ITRqWhfk +pGcpfe3RQXDPMKTzkldsL+F7ksx9BpYoOOG4we9Q9kLmQGVd6EuAZ/QerD1w4RhmRzltNaUgdQhW +S4LdbCp1IBjM3MZEpILVDWjpGh5sxjh1D5StIwMvoTXHWKWxQ4oEKqD6w6hbg9GT7gqlC0GzbBhV +BIhUEahjMUitUNNdX450C+MydYLewYm1XVPayryV6rZjnBy1IpU39J+H8cvVSWot23kNH9FdrYTf +vHxfeb2ZZFwOYQ2+RVBF6SEHsdi8/gqrXcLESqalZajaJ9ONxQvzJFeTiKxUmvKlqcYwh7saxqkq +gycLc/XVoVWGtAmOckote5AiGFW52E+2Ve0Zdcm6xUylDmLqUgWOlRVXKuUA4L0WaiFyU7az9Ndh +FqfAm4PUqAZ/OXp90aBd6yd0GlRda1R6Bs1yWJClCMrDqjZEWqOTGKRCXoB1RrJGjwJBOOifDb8y +9ED09OzVcmrJ8TEAXckhRRR6nqnapDOvNHqH53QeN5VbgiNLrLeBx78RKnjqGYAJXg154Hnikwmp +wBQ4VVoIJpNQG0+Hepl2o2paDzIsqyVbuRV2otUsMUIMambekbkKEET1TrFRadwEdEgPvhBK/HKa +qxLMqGsYe2VlQOuKrmv4SM8m6+pGvbWMs2uLys5MeWbQN+Vd5nVZb8FtK9AgTosxnyy+LF2dp2E+ +XA1vwpclI/ASU49Eqy48dEyqyFjgyJcdrKGniJXQ8527Hl7uEGPU/EjyIqcxb8kNQjkqPqt1K+pb +IBfDzUnoRQ2FLfVR3queijoRjcxw9OVrdac6fQO/TV/SRRTMiYkGLMY6O3hLlrplo8a5OYwOf4BF +ItgoDgHSVka/chojUiLMhN6/SpuO6RSrKi45W8taRgFVETz/QUXqylMZM5y4jZkNT5/HQ41FP4Rd +RogRMoHbWvhtVaTJJEi7zodeydEiuZYQDAtvL3gVwFkNVLpyqjEAH2V9FPpxQP5AY7THOQ1RzLcx +CndSuHbg+KArrWqYLhpfJx1HC6rkIOvjnoo5rR6pqchWhuKeLY1ZV1AIAIReVctRwXY0t7tCIQRL +oUSkCaBsy/DpnMayVXkKAgFv5rJxL8xngL4zIUBhsgti4HXbRA/1qopay6qJsVuV+uqK9NiqM4WF +6xR9xit1jgUMR79HhhurH1EDDTdmfq2f1G1UObQ4r7EZmdLQNNGXFaatltQAsfnUScun0QGb4TZB +c8YpD1PqjXUgEHRwl8OGVM3CQb6NvugiZcNtFgSjpeEbqRGYg1mdkC3VNI4AGBiPYbYoyWXQXbCM +xl54fIOSkeqMJ3FjvoK5Akv18cSflkr6FpTIh9ojiRu4/BBj26JVxzYlWPQ6buaYa91rziYNLggi +dx9SCxOEd5Mqrcom0BNDR9A6gbqyvqe0o4kIzopN1TSHDLk6orGghn1RdRvk3ue1fYQ7Ml3TlCEq +N7y7ryhY1ZaeAoIy8l5llJn9RnEpSO1G5GM/mbtYuEZPQDyYRkI4q5eWUQaajTby8JA/sMWhwMbp +KvuEHsXOx30sWCI8gRr0cIJbOigxRETjBrkRcS0HxQd5hnIUgTVqUxVGAFETuFBE1QBk8KF2kHY0 +isTHaAnIifjbQuvlGMzEg5/WF1eBf2mYXh3uXzVjNlsDciBnIA0bhvYP0BsX46GEANagIK7UROPl +ITWadNizdCPXeBnGz1K9K9QMRIvGFCjAoI4Vejeer405jLYqGd5YMd+ltNloiI0Bu2aFnRG+HhED +bbBRKa36DFgFS4YaeJGiVrjv03p1fHMk/+TNGYLJXGeurpVoIGIRKs0VPP+E+MqRPy0sHAFscZCy +rNB+XZgjzqOHGQSmMi/H77xmsec9OA7EnJgmUKs8LVhDREwJCKBeOprbXco/AfMkZUHgfPPpXMby +lXkShUaL0Py5ieOfiFh07uP5/SUtXXNiqAMduzoQPKxoy25jnJgcbMynkX6qYr2NHhQEFSztu9L9 +c2pAZYYIa5J6IFaDAAgYvsr+J8OXNNQtQvo+x+KTQdy7jxs1ZsfkiSJVMetFiBMi0pHMqRxqUQQT +htoiENBOsipSwIKNycuBSA/y7N6ICokPsXVw0rLHXcYQQ+OjdXBk8Q+UboQ2+SZoRP0wreLCpo+W +Ns3SlM7UdhK33z+G+rCpa+oUkTLgDFSCN+oGyKTXBC1BJ14JvRihNs7QMQu/nsjzP8u/4Z4m/4aG +p/QZXMsnClBBdoxRgIqCPiFABQf/fQEq2bt9gMrOBqjsY1NS1rtni035xMR3+xCVfYjKLoWo1PbB +EBW4+owiVAB6JEDFPGOAipkToEK3pkF8Sj6wzxSeUsYbQtNDF6Ji5oeo2Cxq5CqH5SEqZhKiUq3G +ISq2/EwhKlrRIESlWk1CVMwkRMUOKhqP7TOFqNg45emhC1H51BiVZhyj0kxiVBh2PYhREQF2GKNi +m0mMioAGMSqoZRij0kxjVJoXiFGx0S06PXQxKtXnDFJRr+hBjMpni1AZxqewpd0PT1GxMg9PISQP +T2E6mG0JT2Fn8vCUNIAuPCUf0WcKT4kZRIr00IWnVM8SnsIxD8NT2kl4SrsmPKUdh6fo7G1reEpr +EvXVhxSeUpvPGJ6CfOvbEp7C3O+vIjyFKPNweEozIzzFzghPiVxDF55iRuEpdfuZAlSQNOpTA1Tq +oAf9lkaoNBqzwUs7HoxQqbp4D7umbIpQaR6OUAnzmn0oQmVQ8sEIlYd7vI9QeekIlUYZtd2IUJEy +ywNUGvdogAp4lX2Ayj5AZR+gslmAikzNMEAFWs48QKVs62mASrlhgAq8qwYBKmZ5gEo7ClBpJwEq +bXg4QKWcBKjYLQ9QaboAlRBjNng5KDz1dTMtjlEZlE9RKmFtlEpIsmpt5jae4lRMilPRe1mnRRmq +EuaHqoyKM1ilSbEqn8GDdB+rcn+sCnbHZ4lV8fFKwS5WJer0+lgVt0msCvmGUayKLSexKs0kVsWt +iVVpJ7EqYVasink8VmUwjy8Qq2KjwsNout71ISM2pJCRkMeqsEwM/Lg/VAX2PA1VsXmoShVDVcpm +Zrt9qEodQ1Xs+vAahKrgLpQ1oSqP9DhGqtT7SJVnjFQpzTBWxTwaq+JHsSp+FKtSTWJV7ChWpX48 +VoUXpzxNqErzeKRK4ri2JVLFaKCKT4EqfhIyYtoUMmLaQaBKF/gxLRrDVISximEqkUIwTEXIv4ap +rCm4rs0+TMXFMBW/riDDVMqQwlSaZhCm8kBnx0EqOKj2QSqfM0ilaZ8wSAXqy2GQCv0UHw1SMZMg +lWpOkEobXihIZTCJ2xCkYrpwDWdmB6n4Zn3phUEqj7Z9f5DKpOisIJX7+r0PUnnWIBUoEkdBKnA2 +GQapmMeDVMpRkErVLg9SwXUjTx2k4hcHqfhBkEo+Xy8QpCJyYRODVGK0SJUCN8KjMSqyrjHqozTT +wilGRbZejFGpTRejUrYxRsXPa7ULUTExRGVdMQaohLXxKQ93NcWnNPv4lG2LT1E/nvviU7K3nxKf +0jwUn5K93Men7HJ8yn2olOJTFiLT/fEp96FTjE9ZiFD7+JS18Sl/+/77QVjK5710SO9IRSABnNnp +UtaD/GFCDec942BbriqU9/DwT4AzXrOJe/36T5phHd1zbEYtNATxakGmzdA60PygmQSIdxaiK903 +qa9dJePxYHutx6of/nzyjz99Kxj1m7OL2zNZYPvmt6uveQFOiVWXl9lCh5iFgNKTUYMWfGQ0VQBB +JwAJ4QjkdITjadRq5WAyos2Srittrdc+tvBBih6eGCYuECyjBqcqYSISboqO+WigNA== + + + PITqOqhZLIIKhPAga8AJ/WYMPabpC1PxWkHcsCrwygU8DodwPBkUvOS5LLXLBkp9dpN/Bb9VcCvw +jQilipKeV0fjTWhUHxUhuCMvNLHTCktocnJg0228DW4PZKuNqeir3WrGyFF3jicdPHmOq8mwOG7l +DS7xNfxLPyGAK3Vp265Ll74/P709+1nvlNZIos9OOaBkRxg05AukfLoiKEABTqUrFR0wssIJy0S7 +B/Rt3jJenXsb6A+1mPyscGWZHMuX3BEi99DFufWlemPQ90eEqaquFADXrBVcB3CHAh3/TYPG+a0s +yiWkMu98RQrS1IbSkgy8pCaFbfLqMVx7Cbf4JtIlq9cyUAySs+uSsQiUgHDBGgQz3OxbxmdmVIR9 +BhSyPeTGO5vOziWxdBJ90t4fh/Ix/oelozQ+Y/EQNTJZFgUuXhic+5OlAXCDxZFi0+UR4CYLJMWm +SwTg4kVaM1uoCQfGPzjxXJGv3vRrsnQtoGKz1PQG2LW5FvBmhAbAoUyJ0CR8CX1bSVOBt6FRILwn +wZFCvG5C/HBU5b3AdyQvqeP/yC+lCVFYeZLL5lvI2IYIVcMGRsutetonkPGqEQXAAguhLGl5DEDj +0eDmURsOLTlUmDkdJoEXxxqe8BRhcUs7FLVUClZGTwZm6cIZBB0ubrmFQRjuQHD5RNeocHHJBRRe +ZVVddxCPJKaWyyD8feDFmDUv7PQiDqqG1GmWunRZLa/JNUyMaVoXNALK00GFt4g3DIWT0XCPACvb +EjFiIhyowlgmBXkvx/OWAvASnJyUfHd1gAg+KmcTSLCn8j5mzheRi9umUaU17jMNepcrZoc5R4X3 +1jidmveF6vWPmtMQdmbNS4+50nJO716F627LyEjZTb7G9taLfuGtAwcOEZsctCDHB/DZ0YAPBxc5 +cCBUPTfRIT0tRHrmtef8lSCwrkEfr97khqHLpV6Ga+mTcwyzm/oXNojyqZkgJl6DY1RpLfsnuixX +h1VdspClrx5Vaxqjqi6I0Fh55KLlfZh6/zoJJG9Xj3edANQ4vV6zNEFZVkfzoiChd7ZfkvGqHU/W +8eH7IuEcKktibDtTo/Hc97w3rTBnvsEZ0OCe9xbIAgcEXJa7hfzQ3entqliJyPfrbyNDFO9wnUnW +SqCGbGuVkOAkxcOTd0mfHMQ9H9QJtCQIJkZb8ZZfEQGqyKKX9BcDznpDSl1SBq7bGg9r3q+pZtrY +pEN9d+cEWCO+Wra1qXFqQ1nq4U4HDU5dtdB+jbVeFtcSq9NwEX9DL4lIZOHMaccs60F4WAyulv1J +W4KDlhIqZVc6RLRASSKEFQrEKl7+XAkj0IBQilAoInyMrYZwBH331QH8+lsNB3XUaJ8IqKnoI9jf +Tt1EHgSgUqfP8rosGu3qFlZ4zqjD7VHwzbAsxwAlmI1h5OB1svD6Mwyzg1OPVzKgunb4gAbeHOtr +arqxHhDFuBCIMm0qvYJ38r6YVFJMGyqmvSmmXS7WDKxYM/5izTQVa2Yzm+2TPhocfhGITLhC3d4w +Iqah/wzb00S8cnbWrNZgGI5hzCfcNykNqOWlxCWdp60S1fHLQdlhvWtazro2epgd+a0h34MxfvVm +TVNCIwe9EbqVd1Uex0NBrf1IlbMef1GMKinGjayb70F3Tw6God2+iYweCJ2c+oIcQkgQhN3GLBKy +7aCirenakjCNYTNtZBZOIEVpPA5ujYd1B+Ownn6LTkP+aOhpQrRHwsx1TCU340Co17COq2boXFIg +EX1gVH7NEHffOe2fHMCJD2SooJd9qXsIWgSaPk8g59Uak9x/gAA3qmL6ahBspyGffWPUY+KKqqxP +jF5CyIEsCCORTqYzdfKAshtDFkaLdxMWTQ23L3U6hlPhhG4iNLkBMfdg1MD+eSQuqRmvGZoqaokR +eSpYADZXGeQfEE0rDAuzH8NvDREr64rWQRUqwTbRCHR0tnGrR3NbhVWpUTtWDb3WUK19Hy+STvpy +dXZz9f7m4/Xb1YefT9+fr65u3ubH/MNq8TV4rYruEWYrcITbFEE3wW7VvI/wG8RiguEiPk5w/Ks3 +a7CcW7nHc4rME0wX6BTXSRom2B719iN812kYYfyaWTy5Xx+/YOky9bh5Hs70iRnIPk/Ux09lH9v7 ++Uf3EP9If941/GMV+cfR+0f5R9fxj+3GDKRRk2kLQRBMnWmsCWQgveylNfl5qGbyKXlDfIiR8K1B +WqjWQRTN8/N8puw8Aw7S0sVlyEFaehgNOEgbuaXlHKQjzwYHrHs5SP85OEg/i4PMe7OEgxyNv1gz +TcWa2ZzHQbbtQg7SPcRBugUc5LDlpRzkQwzjsOZ5DKN7lGF0mzCM4648wDDW5ZhhxEbaiGFEJMtT +MYx1ax5mGNUe3zbNLMZxWN0yxtFOGMd8xj4z4whXXWXh2qWMI/YlWTg/i280Pd+4QaNHMxt9cbZx +iN2L2cblOL6UbRyi5j1s41psf5B9HFe7nH20a9jHIeY/J/u4nJm7OPvlHPzc387fbsLMwZ7WqAc5 +rNBI3qmQIv5N4PRcRpsgv+leTr9Kv84Oxu/GhbOK40/4mQfAa4ShwZQBnHBGw+AFCcoywFtTeLyy +LvllQKjTCZL7GO+YwSR41blVwiN0TcQfx/3IZzGFxpDM2dYjkAa8S1nBqlTStQHUYELnamBVulw6 +PRTkBolsSK6tyU8mqsW6qoTCQI8pw+78rpzJfzgrMk7L8YWgYVLULqbEjbCKaubGqqxDAuj/iwTV +x1L9XnXemSoA+V9KmEE1RI+pERzTcrWGJgBD3wjDJUIgFibe1Digme6grMjXIh4nNaF/Ndlj1nbs +16ibJY01w74Wk2+KVGef39FGRE5pJPW/HKBVM817zcCh9JLvHMxEJeVoOhjD88/AnufgL8FbAvXO +UDw7ZmUEpNEcOoQYxuRbfTb63LjukVPNLLE180aBFHHOjAei0+nYMQUVA7Rjj/NR8C/D+exKx3wc +x76JgtDZeF48PGlqYn5g2s5oTV4ycch0u3Dqvnoznbx7YQ9OKbr78KROsku2GUe5p5uz6CaiKJWN +4DmNvGAMLC4p2xqzxh7jgyaKJdlMDwX5KiGLTnmzulHebJTu1ruSJv9WpO2GP0yomElLWFElksKk +AS1KBMIjLqVEaBTClfZkc08292Tz85PNZiCIY0uAJxL5I7R0I0qg7JYrMPnQ3KCD1If5ih8nwJkI +ykajhyME6QEhNMALB4EjzJrDoORwyCyQkAA18VlBZ5vQgulnHgHUUa16wYOPGp/kSLUIwP/poJKD +AUhkHb+N1XvkYEhuW8PEDpUmn3PwgHXI5ESrp2YF1hxMLsZLxolAJekcGczVQ4EKIK1O5hocaVFZ +3DOJqCd4t61hTZ0XUY+6MaQTRzBkBZJgVD5GskEG/1q99jLYOvqniAheI4Edr5JCCmj4CK0pan2l +qetEDkfeAr3oZsNGj2Y2KosLWzykd8uQzgUBCWvwsgcuwkwItotx86s3S7FTKc9c/NSxLMXQ6La3 +EEdHu98MmKbBGqSzVpNO6qnYqHNjA2oIL0joWzEn9Gw0OOLLmicRZCM50Fs6RFJjZeW3980AhK88 +EiU1NTMStUh6IlXXEYBsuI45FVzMpQtNstUbYYNmNm8Pu9SlTPrENCsMXQ6aspG5WehhBRBV2icA +xShsfOWotW3Vh45uf8qWMX91TbWySc+RneOlorKBES1NvqKFexqv9MWkuxKEu2HsNM/G0miGZiYl +OzmgE2wA7xG8WkoQ3cYzgu6BJ+RF4FpIXqRRXkTz4AKCMwgQy+hu9McG4GFd0j1vzJ6kX/eqCX1N +vxyprGXC9zrI0jCkqi3XkShgWM0zFZ47TIDiEBjHm7QQo6tqN6epywLyHjEJ5A/MCSpCs27KAEPg +2qJVjUuakYRNyCV3zNHZxq0ezW3VITsoEj6ZwMvABjTKDJPKrmE+0pZR3+WFmwZUYLJtsMknGwfA +5VtHGJNNNs9Xb9ZsHwLHG0iA87eQ8jJLNhFLjLaRwMYbifzXcCsBNN5MhI22E2AzN1S/2mPLRmPv +I6ljho5JiOnMWccbE/hcwb9VbwvgM6yngSweU8ZgQ3DSSsbI1xVS00EFzOV/KkZ+BHmQipSyqyAg +GmbGg6srMmqu08ERMUrkMJB9isywTg40hrYHemTz8p7GQKw0yJPatJp5FklkEOnDS9uBO+NitaVl +UIpVCCAqmYNxk9aO5rQWmOOT+VssEvIsIxtTtFDYIsTg3RxLUeNJRZXBnnDL9sSwLmQCqVQ/wpQj +HiYiXLnZ0EP+aXD+Hgx3lhheWagHoAGpNQcx6GdJW8xEYSJHFlOO0g8vxiJUBjwdYhBojCFzzLRr +jJZ3rYxST8r/n733zk8lSRoA9wLcARkECFe+CiQhPEhCFuQtThLCCtM9PX/sby+wx9lr7DX2Gpum +vC/gTatf8803b1BVVmRmZGS4jMgADCqJ2CmPEkvMPmV58WIyCuq/PKY+Et4JgS6jBMwtKUb7G3tl +MZNFlxTCC99FSemiVyhkBXxJKoXP3dU075rI9VTjfa1XRsQagmVWeQhUbzQBLWhLv7k/A+JYWNuA +Qpd1ENCtwYmXXcCwChJeVFtVPWLxzVPwMmlUVEv8Cl58jRvgv4GOrn8Ez6h1X8UMcGOGzuF1xdoR +VvVDttxNSbybyCQJg3n8SQJF2aBEUaOskNPmaR6HEMGia+juB/ENh0xbGo8PaXBgxKSSsA+/hefL +MMXE4VuwHRlg8WnT9T32m/PeL4XuoAX6p7KX5vDmYXQoqhBADN3yy+Mr0FGcblX9jMGXFsc4mBLP +46ooBAWDMZUlF5/kfYZHYPX03yHQqI0IWnkg9p/3oUHa0sDPJ1s9pq31nCS+ewJdPUGgXEA7eoVZ +zYwj2fDIKaKlVgjd8UsggxCL1xKrl05znjulYE4UTQqeNB0jJcNnRlrWPPVEzYFXE3oOvC5E0eAz +PU2DR3qaAY+MdK1+6JqyYRyFgbYhKhaiboxD/ViNFK6VeyypKtGmEk/QYoW3RMNIvAHc63J34t5m +FHyiS+w5El+0j66R0kyXN25kXt5/uq9iBrgxbd8MuqJAPbqqT/uXrU8WVmqHLjh4hwwF8zChumy1 +kfGVmQSB7vSF9+rpNgdJCHgfChTy5tGUejPj/FJ0TYH9tyyH6xGodvMCPee890wmgdCDKqyypVVr +xIk7Vv8EiQu8NOIT6FdJ4uJmNLCo/MqKQVHPcFhY/DACUg+Rw/F6umnE9PM0ICe/WmJDF2UKjisO +L6eAFQi0tIbuf+Uox68hs4dFG7XU5rHr3EJdw/R8IEKcI/EWUbep5dRtUq9uc4JBb+EEHXdHAkbF +3TnBoLeoHkl6i+qrmAFuzNC5pLeQelWLdKdux6DjUCBRQDy+OouE2Y92+ksMmIkMi65bQDoBzWlX +FKofNLQEaVqp8qH6GnoNGcrxa4HCrlHtFVle+84t0jfU2Qme47V6t7JinMT4ePwX1g== + + + kcW6lX5JTUA3AsFL1JEywaAIVBK5VfM+jX4BDdyqT6ODQMNUo6VIRMQL8t8aIhJULA/dkCM9ihng +xgyd50VzQT1GSf1VTwQBZwU8TQ0+HHgdDS+EZWUSA5Z70obEsMOYwJdR04wJ0+BVLIeHhruO2zGw +Hhrt+DW8KE08eVyi79xCfcNMdli3yMOpp5YARd1WJkGs1nohQqS+6slQ/dA1IWoGJ5EiVC8XIkZJ +39eSo6StuiVIXTgYb+VyxFBJgz0tmNjTgsECEQwWiIQDlT2tfiTa05ze+uBUoJUHWnvalsn/fLmk +x/SvsKe1LB0bqGBcLuxpyy+d7WmnTq3taasvl7CnSRN7WkvLmqeeqFnkOVp6Fu1prxQt2tOk0Z4m +jfa0lq7VD11TtoZH6e1pz9Qt2dOkiT1NOtnTCyq2LPzz9Ww0vJh0h7Pu8CMWw4+Ruqt+4TsbwzcC +fnPRn4N/z5tfndbMhy+Y9Ocm8+mn/7QxbHx0JkA1bncmYft3fvwy3+j3u2Cnjj+7LbFlfTTqJ4CK +PZ7F/ed/NMBvY1OgBgAQ6vasbXuTpghEqd+YObanUfsrmN6hbYtAmHzAW31gbIsnQrLGL8CCng8v +GrNPDej8Z2PSGimTBK0QCJOm9c5/Zv5C948uQLg90DoC0Rh3JoBt1maTUa8DBhbHaw6IRLPiK6Yc +C8QAClEjBf4JsQT/nyDwf9FfYgiy3WgX6lwhP9Q1Bf/D+VGRC9wt+Uu6pXVTpsF/pAmr/rPyfjGq +4W5A3bJ+VpKYyV/dqYxj2CmJOgS80E9jJJO/oF9eh2Tez3tF8ip3gNmeBOOSdjoixoRf0mpwG9Dc +TyX80n8gphJ+hC4yTsmazaKosxhRXcMhdOOiCPPh/LLBqLibFYrgrQl+ThkXjLgheQ7GEMH8SHQb +E4zL5BH/g2YDGjXhdtSeqSCJ30hXMU99iZPh6M8h+gPIbCTXw/7EGZiGP+pLZIE8/6MjvU3kxRzD +UrcPZgbbAxrpDv24AX6KNd2E2CQKlIXETXfabfYRQCOE2qzR6i0FwesYco1pt6V8jhcZk5T//P19 +2gECjbT+XvzgqN+fo8swRpN4YzwGSMOLAz7qiOgLaYD6qwCV/uL7O1g70LrenSFwFOqnfz4RG4MB +2t3SHToaTrswtVO+y67QnY77jb/wnzDlM4EhiasGJnLlA8TGEySqpCXAxD90lQPPCJwmp0+QUvlg +bp+AKqGRNEwAvMuauxdBA6ODkcRqfKLQeffv+X3+kGo4YYxMfEMJfo6RI80q6tvzo/n793wAo43J +zGTFcv3OsO1hwe3wmUDAFFy5c6Iqk1M+txi8zTzyo2F73p25mYMaysp3AKS/FaFTvn7metop/tEZ +nrfbiCRhFwqSPd32IhaYUKV6mdaaQDY2rMuCPFTo4j0YpEfD4rUUZ1FuQllHeYC/OQ3+PlPyJYr/ +6bTmcAjoBfrWTJ7B+9u4tVD7zYSaW/6xFkZrYbRyYWQmgfDJEAkPQdDhI8fDIoew1gS+7Xktgf5G +CUT97RKIX0ug30wCXS15C7OFUWVClWuTai3F/vcmlee7zNcC7R8+JU8CTVgLtN9QoHECLaDsOgr8 +Lwt9gEmBpfHdrywD71KANwSIHmwW311DwLwRWHDO2k9IrR2Fa6n2I6RaUsBX6TEUj+6YZGGlGxSF +AnOok2tP4b9crCXXYu03E2trT+FaGv00TyEhipe1sPk3CxsYPrkWNmthsxY2a2Hzq4SNm9yDtdD5 +303JkPTwN4gd+meLnX+d0ICON4onYNlcdEMeOi8ieYZhNPF5PE+xDK4pTdDIE8fDaD72Zx0lLcix +fxd+Swr40nEClgFBd01izsuyJsW7PDLe34cHe2JXzJpd/Th2tVT1uDW7+jHsSrwzgaAFGh77IG4F +rxzlGLPrO9b8yg2/Ytf86sfxq7V69XvwK0m9gvf7k4p6RfOo6N+aXy3Cr354cPy/jl/9FB/iP5fV +KEzd8gf+Dyq75IkvrbmJAzf54YHO/zpusrbWfgRLWnUcE4nDcwErSwqoth3LJxkClwQlhOQKUh7/ +pfxrHde65oDuOOA6/X19tPvDpEGSwWlIFM/DiwXRTbxJijW5nHJ95vsPn5InobaOav3dhNpPcRL8 +w3bNWhr92vx3SqBpBpWBhffJC0CxQmXwmHWo6787/50jfrYE+tfJj7Vb6J/Jep0MARrbASQPS47B +0h4UiZ1CDMVw6xCkBbnXOlD/d+N/a/15rT//QP2ZppI8zK33x3gOyFwY1BDnCYY2qS681p//Tfoz +tZZAv5kEWh9L/Ah+shZkv/hYApWKIRmGQVfHkLDMDLJHSIFf3h75Xajw95mSJ6n2wzPR1lJtbVet +xdE/RxzZ3LYhxolTwvom3n+5JfXD0wnXMufHWFLrq3jXguvn2FHgfZxhADVj+4mjKG59l8e/3H76 +4amma1m2tp/WYuifI4as7Kc4xRFAwfJL9wOwHEuza0PqX25I/fBMv7XwWQuftfD5xwsfGBQBLHiO +9ctOPDaZXGe0/MuFzw9P0/zXiQ7ogxNYnhDgMS/HCjwJ4085guCR740TeAoVuybglTrwCakUD2F4 +4scVGf4XhRSbFn/CccScQOBoNHwtGMUwxPI+p9+HCXviWOscvN+R53EsSzIculiMh7XSza6coWFB +9STmi7jCuoCKAK4LJq317r+f/TudPZAkzuxLMgwpwF8MwbIMTiohkwy3Dk3+dws2/oen9q0F22IH +6gxNJKHQSrICx6MfpMAyUKsnGBqLMV5gaBL+IKEuTyla/VqwrQXbTxdsnHiTKJ3kkugGLUYgKQJ1 +EhcYklxXuP2Xy7V10ufvJtfW5xtrcfSj3Gz4fIOhgRKNTtdZKk5QBLCo4hSZpNaW1b/7kINfJ32u +JdBaAq0l0C+UQAwHD3pIgSCTqJwCJ8TJpAAP6JLEWgD9vQKI/PtrBfLrDM21CFqLoLUI+uUiiCA5 +noZLR/FxhhdIVDSRWJ8urUXQD0/YXAuQdX2iv4Nt0hRimywlCCg2luHgPSuobh0Mw2PWcVqLsZt1 +Tt3vxrBQbCrF0yj5myEYqGfEYQ44CsqSwrRQYjiwgqHI43HE1g+LSf2H7bq1xvy/CM/i1lds/WD9 ++e8XZz+8uudanK2vO/kHbb21TPsfXWIPI7MEhgWUDGOPWYKRIo5JegXX2P8uVPj7TMmTTPvhmef/ +Som0Tv77R7Jim+Q/XiBZ6FnCuX/AqCDW9UMWZFi/NFvZlN1cQZj+/Ggy7Eymq2I3OqAyi7FdC8B/ +rjoNQLuQvOZTqy24crYrsjvX33vkk7/ILf77cqcF8bPmKFqOMpk0/vJXRpPuf0fDGdhWTyGe8o9n +T+F/lE603pz/9s2JpU590hhO30eTwapElAqgO/Ek42cmfXnRmIExDJGkIiThNRj90bl5vZhJT/E3 +k857H2jbd9qHjWF7NOj+t2PW9B4+ZPyJI6Bnhcbd4cWoO5zBZ0nx2XA+yI/G3Q7qiKfU/VdU/Ysi +dTRrzDqvV0CyNvCASUJ+OW01+nDMnUmrg/uQB4NeVbvDjim4Qudj0sGvSB2wUqMFsG/WUUXdEal7 +pXz2+xnjrth2GSB0qGbbZVHZVnHtWncw7stc24s6j/V43IcCGH6Hbkyy0NpFIwDMBJCg9dCPhkDb +85f7oz/9LBA0azGzFjP/ODGj0LC9nClMRuPaZ6M9+jPe6JoLGDUo1wYQ4uzN/hDhhIjzrMQfR+NG +Cz6THzT784m5aW9ysYj+B/7PXcOrH0DB9EerPxEZOBrzx+yv8b+YbV90hz1/rvNHp/8vNuDZ/5UB +/4swKXpHgVr3uSo8akB64wJfwxnaUbzMAt6nM1EpFFW9fnfgcs/9HS5GhetwLE3gI0cqyau5EMyl +Fz29HM+wy7Gkn3OW80sSAi3nsdZd1kelSK+Hdlpjolbs4wQFrxrzkzQLNx0N84V5dvV3omKGWJr/ +979/+U8b096q2GepAxgnxLc71knKluaVrQT6Zyskv5DS13Lwx25laKMzaBdTlob6QobQ77MxXGnq +2GpbOyfWAv6naMe/0EpfTI5D54Zf2idLekE0sFyakbIUbzcmPbWToTWdICcIFSc5qc0fnYnkScaI +Hze6yDMRU7f6HE3+a7EOFMvA4EdK4HAwJF4B+FdvccRPde4RO5cOB4wgvVdnzbJVLPsRPG3M+7Nn +ex+4tx2FQpFg5BGLVj3JoTsMeSEJryyVZ+olAtbcSR7IHiVfi8N2djJDo53CJyx88no2Gl5MQOvu +8CMWw49zHbB/Lhr9zmzWQRz2oulmnKHHK/AhUsIAJp/DaLHu/uvTP/ddtLzhKXT72Z11xO+c0dWA +BAhknb6jJMOxNIwsTtI8SdMaF4D43VU557/qtKUvk3QyqbkkOUkzFExXUA9R+fK+04eOVvwxx/I8 +qXUzyLk76o/QOYj4DcsTSYZXd0jSDEsx2m9J+dv8Xw3pU0GgkVeD5wkS3s5kRCteDvHLXH8uIZQG +/0cKCI8EnaRMF0L96WnjAyiDDfFrkqd4jFSGTApoXVgW/yA4TkDo41kO8zUlkI7nGF4EeQADwMsH +dNKfO2BY46KRNF5uQYBXfKBXDMWjC96lazxhqDi62JMhAWQRLEXzACwlALA0pwfLcwCzSQQWcF7t +GjMsgAdzU+TRasCCR+WDJGEKliVZksK3j5JMUrMMSQ5eow3b4LkDsAgLMlg4WhL8C+ASerg0z7A8 +BCeQSU6TBxZPSreackl8K0qcogHKaAkuC4cLh587YJMSXJ6iKc3oBJZnGUoLFzrFEM3D/1OuTZXg +UhC7NEIvLcIFUAnN4CB2OU7bEUauwItCTguVRGsGKF4FlaV4HYMQuCTGpYJ4JkngZFIRuRTOJxAp +jCEgEpJwsJwEFhCubqcILNhEmtFSFCQCCFciMQpjGcNl0ZoJwPY54BlpI9IcSl8A86IR/oQkSXF4 +CydpdHEapAFJ4PMw3UEEhwbJwJXipJUSeFpAg6TBLoBDA93zyI1J0QQt4ERAhuBxfgXMAxQ4NTQC +YpKVdhXPcDTKv1CcojzLM5opk9Jyy1PG+wEDBcxPmjFJymAhItEMASNBGYkMTbGcisPCUXL4Fnnw +wzBKDu59kuUleITAI6oB60bwpswMaFVw0mgGCIOQ1kAHrAiWwVQPx0lR0jYFtEfBwHywTRmMfhMm +GWcYuH8gAmiwSqx6nCQNxykIIrwk+IkvHyLB2jLm45SYKpkEq8Mray+OkwNwGTR9RhpmkiMJCskz +WAFcoPHXNEcglMjpMdIGojFgcQOh/QOZExiShE6ao5EMSQJWTZhf+s8oTBmm6SBWJe4dAm50sHBw +iKy8JQEhIYgsS7CmEBU2J7FRFi+ZtCV5iemTjLQladAvLpYUB9TNoh1NAATghQb7Ttw+tBiHjSGx +AoAEp5yU4JAEYBAcZroouBvIJprHCw5ZFtyliEeq0SjeBS3yIUrCY9LAjJNkksGLAg== + + + 0MprmbEskjBvBz1LJwqyRKLR6lCkxDM5wO4oNGOKQHQHlA6C1VCTLJk5nBMFfsiyM4kIXUAbSJo/ +QwPeIyBa5gCrhz+SgGdiocwkUXcQPazIhRhc6UHCJxTHMCsT7nFpT8ISimg9WMjf0CbiGcxMKLhs +pMwo4DKKooNWC054RzEQnHDFBQkqoAiGhCMBxI1YAwGImcMMhENKBC0zSnGdKMzqMUwBDhXtck4i +TYoVKBJNmeAAL4YDTQoIBwQJCElQCwkODg/2wlCqZYJyAiCA5dAukjgxzZJiEhtQsMQ8AZ5HO5LG +m4ETp89gRiRX0hChcnCrk0i0CZQENMmxaDeDdiyCzid5NGhAEzSahiTZaEnOizJJLdmQYJPZJ/gS +rwfcTAKH+RPHMxiIgJg7I9X2oCSKIrVrBSkVKQ2yksMAdoh4Opekgdbnx/pOUtRPJLErblKwrxSE +JuHMMTolbDJAeyewIgZvbodjBDwF7Vmgm+N1Fkco39ZOYMaMYSJs0ogf451kSNSqjd5nfmQI+G+6 +H0NozITFBlauS9NvROAAYqnR7vhnIz82R5xgaVsrUEy9qjZw9O0VSGYhVDaAdM1NkQbtAj8K0Ou7 +B2z6EQQfqn3PG5PO1J8dfvSBWaUBg//zqIL57B8bPkHkAhcf8yloZl5kz+rnZ0U/4KGsPw+B/sen +fyh9hjtT3gIwhi/QM+kDikOEDf5HBdKsG7kXsFU5jtSIVR5QrlbQCki8IC1FPGqm8e0Nkryhkd4L +pSxgKpJsIDiCROwBaJICZW4sJ0UGyYt8QlBpa4ARIL0XqUGkCq6s3wK9DQkKFvAs7YiB5UvIJgeB ++RoauqT/M0hCIgEO2KsEmuEpisaAeIYxVzZYSVAImO1COa1WDWgo0ygSjRosOSkvDrZHNAsKGIJh +bdAzSTVN8qgHSgCSxUrlk9VxQVFNJWhUUl5qEm65xl8ovuXiw60vAuuOUOjLChnHYD2UJ4HijMQf +xwElHg0A6NIskiri5R76HyL64cJSkKXK2i0P1BKcycbQNIGlKUNgUQ3sGqSNUPJ/RQMGqsksRDQr +LSAHBoDWjQW2G+K7YLkAc0ZcnsTWHC2NSf8DQ+WR8OARLUtQgb6OVGWWIvFGYIC1hcYExC2JdRT5 +v2rNE/4L5bAkMsFo0DoyQKVBhAYUCLA7kGojyntpUPofIlgKiXfkGAD/SnTLsfg+CoJH0p0GEpLD +ZAIwwogKE6dWvbCexNIa1YtmAJ0JSGEBuxcZZSzJqk0hYN5I97bofohweazSoZ3FSwKTgq4oZIXz +HJ/EPhQSd6AwGfm/IpEQeI9ClQP8KynHJNAK0HcCm8S+BAFoX1o9VhqZ/ofEVwhk/EOiphRvBSvg +tgRDEVjjAvab1iGQFLmU9n8lFwhSuhkK7XtK2nK3naY/P+qPoAgczcfy5oO1zEjs7+AYwdz6oqRb +BWTjU8NpOFq2PinFtuGBJqbFK4eXVLGWJGWUlzRdSiyRJlIYth6QXsrreS5LUVgDB6Ydy2uciZbO +IZa1cQ4lRSVMIABBUFp4wGQFvA3+UFvxGB4F500bxucpTkoZHIX2AS9rtpKdCliGgLNowY7QOjd5 +rHKKRKv2WpFCUqFcEsO8yMlOa8k3rXir1W5s39kYO7zRG8nlXe1OZ2ovvl2Uu3xAq4mpNAaX2yY4 +GZzuaASOfneTmZAEflX7a9Ac9SGY/8MXqowGQKsMVTr9MfifXGPa66CBA12x9RmG6ucfYFRQ8wxd +1WqwybwPsOaP+a+6H58z9YPC6M+h+u9q513z/nqs/isHtOM/G5O2+llpNBEfnU+a4O/zSWP4Abuu +zYDqqvo7N5/NRkNATMZnlPpZvdHUNoIPNC1wR9iPDabf/uigD+B6yQ80H+BHNHgkutzB4LqtXgeO +D/n8pcFCGR8W8Q5WSo1169UTqa0was0HgIQKjVnDF3hNSH/7U+gv1TkX/PvutHo2andMX+75Q/8Z +9Ifgdawxm026zfkMJ7mAppjq/hcgVgBf1ar12e23JwD3qI0UWyO9hf/M/hp38NvQznD6+kdjMt1T +Jferm/7RgGuP28LnU4t2MF0cNxNHMtX89Q/FznA07LhATH8EKLztBjNSy+jfO69md9gGAyVdzA0Q +R60zO0OTcJ6fuvWKln9JTJC2mHA1/26j2e+4IXzHVf0nbfTUH663Omz6N1M0nF5rPp2NBn8vJ/t1 +dJiaNmAcBJR5YIu5Jcdfvi9q8OaaHzOU32GXTt///MHS+G/eBtN+t/VP58UxgVRCwyyX19XS/t18 +F06Fc5rKX26m8tffPRWSowXaaSp/dtsorN1xOmLDf8CUPjvIUnUxJ6nl3zwpKfrTakLNEbB0B9C8 +Pp90gbXoZmrGb36AyEe8rjaaT1qdHAyCXgnb+0cbZITJWzXGZo3JR2cG9ADoMpgeFdwsvfGbv1mV +vTgrU0xpNBk0rHalesrv3X7HtrFmsurW/3jznHDiBO8oENqdZa60/XuX33FS3SEYZ7/Rcjctdesf +zrfRZTvjBgDXcqUxaNv/zZt2q4T+z8WGHcCrhNBRi5tJqlv/cMIcjk49TU3b/gfIW2fG+z8zabVC +6e8ezWg86w66/0WZBT9lTMBK/ruHMOjMGu3GrLHsOJJLjmOrLZ5/uNl1qsboY3xSSBB+6YcKSO2m +/HrT7fyZG/3n7l5s/3jaaXfnA/9VZzrqz8UcFPmL7BFJ+uXjGEAr87G/1IfbHJ7pXUw6MDVYcQ9z +LEuz4uyzR0l/YzJrjhqTtr+FjqJJf1Oepcx+UBfSJPxdMIrGrAMadpBL27Zxbzhq9Ubzmf8Dn3Ej +IlBy0OAITjvTT/9VYwqkpkjwqpniL1iKoQTrQVP+D3Ty5a6trHHQhGYc5/PZGAzUfiSUCrJaGoIR +dNv+qXjdnItRKGh2XBHV5BzbypMjNeuByGDyR8df7/xn5i+2u7NGs9vvzkQpTjIyTCMxVRvDj3nj +o+O/GI2lJdSLQV7CS3vcjeMmEkgwsomORAboEgPNo0a/O9U9mo5H4o6hZX/HuNFuy/sqe+TPzmcj +ecWMZJv0jxtjsAum3cG831BWUV73XL/TaUMb9EbZ3KQlfrUWUX4yGmcnnQZOcTbIzJASC0jqN7yf +poy/iHgYfaZjCeJk5d5gBxpfgzhYadXyjeEfjWlNRoeaEAj/u8wZwKbsd4cd/xQlFk/tG48l+hn9 +0ZmM4QHxVLvKEFki14GDvpw3IHX5q/jSJj2DMBvHDFAmbskrFK5pOUHrHPujA28x9Dcb/caw5TDJ +Vr87BmsHvfj/AXvjA1CAOPAQycTBcqgYaS97VJr3+xIebzqTKRS+s4mhi1rp1p+HkOsjf1akEPN9 +of+b0AKp1E+r/utpx380gBssO0VBCJBVDtt6YpTbK03E8KEavC5SIgmeh1WznL/SSzrzpnhc+GIJ +edeZNVR0FDM0MMbxSB/4a2NgKk2mAN2zbqvR15OV5QdKbIqBvozfABznazXt/jWFjZJI1eY6aQf2 +aNjqz9tAnx5AitEzMLMvyiNYHgDm2AN21Ox3XAwJT7c4GM/+ynf6/aklYcif1Au30BdaUTkP7XpA +i3zaGNdlBYhy0bo6aqk4qn7F9btlNP7LQNs6RInI9N+dXpjD1LVHycoYk/5TnOxt6Ffd5nrY/Y9p +x+pGt91he/TnVEftqhZdtdzUjzCpwVut8QfcWjBhX4EwGkJK8Wv4s6tv/HB5/IS4QISnr0izZXX6 +iBLH53ZS+CtaVFQ8fcSI42M8fcUu9BW30Fe8+JU3FAo6OrKhCHOC0qEReqed6Ilw9wkeoPkS23/z +RBASPQkev6PMce/4Hb3gdxZ05fgdq183S8Sbch1FotfmzfdRv92ZSJ5E+HQa1otdXWOVuablDoX5 +GIwEGl/KWHKdT0BVKn8ObooaiPSmFc57pnxd905tA6je6zhn8T/j0WQG1SC1dFWp1jl0yKNSrg0K +ksbJVOv0K40Z6BsKlz6c3lSl71q0PYL+1qOCuqX6dR3GKcBezcaHQkZVw9O+rY/Gqnfy+XG5PwLK +51VnPO9PZQG4B9/Kl3voJqq/+0NRcIC9j3QOo+wFb4rD1sjEwgZvoBl3PlT0MvU7dM0Mwh3UHEQL +SgEKTMFWVxk3qbwpAW2qbnQeQ5DAzDrpTIZmAwG6tax+qsc+aAL0Io3dtCNA7FNMWoYtlPQPR4qh +4e8OkQY/mnalbpw9IpQfGIc2XhC1vYDaInU+LxoKV2pDQW2NoKZ4UokbbIbkNGaI2rOBW0ux1/4G +0JKxq0PnUtC4IfBHMDUOWhboI2Sy6z9y4xQqXtTc4gA3tkaCse25aLbV1OajGle4mQ2ytPPGzZ0n +rkUx/soZxw67UQ6f9992mombbrszSpyOgKbXgUgFiiPYhx0JtwnFUZ5ojfqwnACAbGTZ6nbTWT/e +xl0gopYFgj14+JnYXvEouvlm3B6A1/2h60GN266B45g/+QtSvl5J3XA8nsSRsIv3YdC9q5azkehd +YnnevuVEMWwEgrRvi+MMdOxds4aw7Z8jsSKcfbNPXTMDTr9GTYDTafdj2DA6DfUN0dI2xTgDO4io +4QieJLto15g2u7NBY2zfFLeZ6PaJWetWfxJvjYbwKjDokrMZKmwp8+0muqoIz583bT1px4END+/c +cRgAaPgOWJN0zRgSxaatkJAwevkMvf4BD2jH8U+X7f6wHtv4Y9CLd4ZQx3C3g9AHeAsp6+nmG7Bo +M3jBmziWOMWa0j1sCjY15M2qgCjLoY/BFukO30cOzSaqi64cmiJPabMxmdogFzVsQhUL7CcVh3DR +WGYSLtpONP4Pp9ZqRsFZNh80Jr2pdtQuGsujdtFWNWoXrdWjNmPy2jnOpx2gEiPl1mYfvw9n8XZ/ +PHkfDe22+3gah4oZ4CFTe7KYxgHPhE7ZIWiqEv6Glv8Zxyd6loQEvlnLDzfMC7QTeZfiXzZDk9IO ++8OtIU7ak6l2x5sKINRMckRPp9Y9twZxybveGvzVs2GDSsMRvrdZ68E19I65jG3PUEsQWdB1vBb3 +45xUoM+3/U+h2u35xVPY/wfloAPBcamEk5m0A22gFtMd2ohOKF+dhgzbiCqLKAmS5mwQinSF/QkM +ZdVKHWEZAlog4Jttf/Mvf2HS/QPdjW3Hl8H3ioplo1xoGLGVamHirTU0QkeOrmQGlPGasZlKa2X9 +rYXg5MNZUII2opBUFaTSt0JVqCRYju1shC5uNO5LQUimxI3atIZTO5SCNrNuX21hm/PPqXTNpk0b +xGOdZONEkgNmQ8ZsV7Mkpm2mwHSWTkbN2W1fc+xm1qLZhbaQbZNh56OhnGxaCgCgmA7t2/TJFnKd +G8w+vZD4bLQ7E9VRpGkrrRzhzVRBwMz1p4OmDL/ftVGSQYPRuGWjGKEGU5upowbtua3BbrODwef2 +GxiLmPmw5YohoNaN4XCkxKGKoQHQyZKVGvoVV5nnqABS3R45CXSnxQa3i6kXgbBqVQ== + + + l0W4gz1vLhSRhQSGjBOnLSlDMaT6fftW0153DMycoY3Qhs0mYDdOph04vIm7bqWwA/esXvpCNTer +4UCfheyx01LB8ah5BIwBNQ3onF/6FSUsHUPKYokXX18USqITCtoyMMBtNJzq3XZgBP5z/ErlqlK7 +nRt/dE6B+O+O+52sFk2OTh5VLQW/6tbjFfh34OzB/F5hin1e0YnFMAjb79zEZJh9R8H+LrDihY5O +YYcXo35XkoqmxoM0UFwyojQZDQAS/xxNenVJMjE20zsdDUetT/BRRzXJk+7QnekrDRoHWkG3/XAm +TsAddqUopiyQo83GrNr4qyOZmfCKKftlgZdB4HxOdNqSbY7+cNElipWwWlH7TtGn1r16W54rRTk0 +N4jMp2pwG3tZIVhAALlTjtpgpbrvXYl9cR4QplCHC/q3DtdhbCcN6dIa095FrwRXiWjCjMuRTCkV +CqA1qd+TKu+19ktXYZDeSKaqOF5tBmuxGdWDNtWx3MdmmZv6RpZiTbXe5p1z8IjY9axQq4Wa6jpQ +1H6X6niD4WMXTFAlzGA8J6DRfGOMozq7DqKDgXAkP5C1sqD0iE4gThtASijpF+44SaEzBUNruJeg +EuvITuyJ14TZLSiIZDbnAhOAsRwp3lILH6zUuj7pDiDSblWWvaOsMZuO3ZCuOh+wj6kzZ9bpJo6M +GX2EA2S7KhXXer7KibrzsEtg89x2mjDU3ZlHqYhIzZecB1O3M7dlvEAGBhTi+ud80Bw2ulKEXaj+ +CXaavzHp+GefHb/odvJPpUC4Pz87Q/8UR1g0hupCXX7IRf2NKXys6L5STHwcxYfMEHAtsL9Gc/8Y +cE4/4CcdvKdR1xjcB6zC09V0FPWDzuRPh2DG8GLWMUw+83fRyXnD32/8BePvG2McOgJ51XTe+oTD +OxoW0FGVAgb3NgRInYPRjd6V7rtT/3zYg5VD4q53fmvSHTtuLNQYYARxmbrKG2O3ZrIZ4oLSsIyq +G1LXHPlzTj7EoFinjQUG3jHGYJlNFQxkPFaxXQcSVklxWzmK4ylgZMUVXGRr95Ca0erCGe3gS8zM +hVFSmzWGbTkk2iUvFkup/HVm6/JwjB13RqhaPbBfV0QE2oUF5jJ4g5XBvGwbujI/zaYD+Gp/OgMW ++VxODvr//u//Z/b//l/2OBM/A/vrffKtteOPhj0/vNJNZcLzfFKJCdSZ2MrMErmuNPJsLX90JLCF +DuwfvmQOz3ceI/u3B8G9xl30mN45j+Uyk/LgM/Ux3DgubURDwXy3EZ9uc9eVIreVylyX06fMYar6 +FDzNTOYtvlSkToUAyTBbBDEtfBU+osR2Zu8lvpvZj46nmekJlfAFMnvVjYnU6HiW+6hcVjP7TKeW +7x6kW4V4PPhh6Kravgf98YVSIMU/lGeFr+cc8xCLZgej6jR7VJt9RtLc1rxUYLZvc1/94K0vUHgn +jpumwLb55Dt/c/n4lK3n4zfWnarbpZ4z+73ScyY1jQ8ihWhgXgqV2+++AEJW6Q1oGIX351s+18/0 +71Lvuc9Z/pN/IDXoeNsptMjqd2b/MHiL4YAhT/MvHy8j8Gvnu3DUPtrIxYSv7WwttjXEY7hrtOe+ +QPIrFGkVW+xlKP/JvO7tZwP0TiR3Fn2LZPLB61K+M99N3xxvfe61Wo0e/NWNFN+rn7hnkkg0+El3 ++y3VfTlu5/qBw2BsEnmaZ6u1nW84/nBm7/iT9gW4vZvnTHbYCg4iB6d7CX7wdNDl+cT0nc5OWkdk +pJciZYitwvH0BqCND3b4W5pop7r5RAOsL3l6EIpFO7k+fzHAM7ivBjL5o/2t22I0yU7Buhw9cltp +Pj96iezftB9TVHPrGYFNDwNgQmludwsuySN3y10OIZ7SuV6Yi4mkedOuEuTz1mkh0djfKW1EHiaw +Fw6+eEFQUBNfgGhuHjHodyRd2hd/7d8WT3DzfLT4hoFR99QRIN07IpJOF6NU4fDjQIRze7C/1/46 +e0ErKQ8YwDvPsWIvoFHuWB7AszIAMnRwBRt1GPSM3cgVXhGqgbA8ZLgH7quVrRe+IoX3xMl3sdEI +bue45vXlfqXwms7WP1uz7MV26zRbp2iw+ln++X4LfNN+KN69Hc5lFGGq1ZDpS08BJvTjk4q0YPej +wnut2Eb4BGAb4Uh6a+8WrxCE7AsUX8nITY65Oy5lJpPPayZ1enuIVkhguxMOLN5uNJIbJV/0qNRO +XI13CU94YSEoX2AvcjAPlQp9MkccsynwT5noYjhprjnK7NVnm9n68WxuRKVuJVV4lxb+brIBn9UB +H/uOd7N6PM2vkp1SaGcczn9yVw/FJrG/W+hMJlGic3GwJw8Eo0NGRrWcfT0mEbXtx95KcKeexAtH +X3wD7328oELte3CSPX/JnZby78cCQZ4026V8e3CPmKfJGpRzfe7gVoHNzaoHD7lKfetANwZfAIyi +c14o9wId0NXlPuQwNPGeuh0ZR6tv1wK/orPyeLOZTEb2mDMdRvaOpqP3fHfa5SC3jD1eUOGto4oy +q71OamcAdvJVGJLXaeTg+OFY6vTjCfAxGrwNVHfLs9f2IFt7Oy4kugehEgbwHqxw2frp6CNzUz9q +lIrC5Z0vsB8hik8yOsbF6OiMKu1wqTuw5vNksdX73pE6QBuk38CMeecxWAXs8SCYveqPd9XtLhsV +wP6CDH/1uRvPntzXhr6AioVL718zdX7nPF/9rpMakbG7U3jPBl80MuCqVHoNb3yiaQCeO+yALcU2 +dW/F1YfvexpJo/p6FwjR8qgYrbcOABYvb8HGvtuOpA84Gr3N1qKZYb7bvWzDqW3AJvXCyUklVtov +smH0Fs7lY3eIm9dPM4Fc/5iIw7V6VPYnLxx2d5nMTTPBX1ROr8jmy3WW3tnYLlLh7Zc8Wc5XM/BX +GpA4eUB0mqlDMhrKH8rP0r6A9hvcEj2Df+YgU8yjD9GfXK1KXcK3B+hruYM8fJbDoLL7sRLPxgpX +1OvDuAib7AOeDJvDBwW5qxxsdKbAwb3A/rQgMvLg0/IXe6gJHM0FGhIaA5gLgJPFQ4HTxBOGg4LY +qcNnewiY0gsCoUcRHLJZp+hPEWMQYk2LTPTNHnyLpnGooBI3hoPDWBx+7F3KKKghfMq97Kvmoixe +2nZpXS+Ebhl8Ad1C4G8gshTYaBoIT1p0HKBZKX8iUHLPZWUMvoB2LdNmJGe7JHjI6Jc8K9yp8iem +MVPCcEEWsHFVnpVCKnqaxXOxRNYBninaORI6DpQ5w8bnZkjV7VRfQEbhgW6aMk5SWhCH2tHklW/R +W12n4roo+05FMZpVTStUixpDTGRNtsqePMILmXlgIsVzKSE8IrBuUa0agy29IJSD1Yd4lGGnzRgg +mpq8Nb2RIVoQjLF9uQM0xitOIMPn6BdGvzxTnruJvwMG/kWLci+ZHWav3j9OgFp5MtYJjGz95mRY +ypBkzxcoB8qvACdsiFPpJvPLwH7pdVbfzewRFxuR4s1dRRJlsW2VOqHSCvRWkrodoGRoGGD1BYjg +iMo0I5PAYDnJcUGg+oUfLa0pfu+hWsrSve1jZAdoJxRBBoIvIIyOCb4Yi74zhZPDb0bdS+61k70a +1q6ztdnRoBipJkLat/1SJhkYS0bFVVgxvnAHR4/17+x5PncBdRhRuxpoEAMsUKiFaWeqUjb4vdb1 +VZZ/Or4qHE9238wAZNnK81H25PYS6MniyK4DvfL0vDMRVb8qlwNi+yku2w5xe9vB3nKA2oVkO0Bg +PH/93DkpvF9Oa4nuxSNQm4vfeaxv09Tmo70xZGkK+QJqY0ihUDg1bGHfZc9Lha/b13z3i0vsvQ8C +H0C/3SUBTtJvPH/VHsHBxRT9SFRja/1nBRSgZBHY72RZcLuyPyBd+IiFD3EHl3T6DShq58H8Z+Q+ +n+imD1LiWmnxpLFFeoDs4yXFEAZ8TL0GFxWEftApvQWdB1VM8yJxqgZiZVTspDGdKxvgotIHloWi +/2u1f9VAk73OSR5MqB0pvb2mk4XyPf8OzPEiRVBl5lQP9nIj/KQzUjCNFaVu3y4L79eRMuDTpQIV +bhfxDkSWKpQBScy4XvZ3elb7ii+9PO9ulYrD+RsVSA4EcfX3o9uJR4FvVY9zlxcZMJf7wZlo4M/v +A9nLs9pNqRBuSy8UYh/tEHxv3rwgqifNsWIj630O1EMPrEv+82kjFUmXX18lynqOgxWMn+R6pxGg +2l+8K3s2BT0tL7kedbChvJAdAUSqPegTUIicQWw/KN4OYPGZ9L3qnrGmdKbeuuP4ZeTwpvEtdVDn +M3sn95vAfPzc0MI+z9bK7S+wLgcTKnO9kURrgFbgIDSnOpDk3tELwMcOP6dztMjJS8BUQS8vDQCi +Pi2+jslmZu86GFc5ySi2v7n3Pr/4ytavG/egg1SfKD1laDCaSkzmznoHhi+Q7JdG71YUQ8ot69Lu +VQNzuXtptUfRfv8SFJfdKTSZTs1x96oGAnfvB6DkUviiv1cqsA9UJH3/vGuE6MLKV4GtqnZvrvr6 +ifAJ1iXNHc8L8at2LJM6++rJIqrObZaGedE1CIgvNv4edQuJu72MhM9gJ/HZeXmD+JyKgysXDkQO +envAQjFP5QbnaSDFNIrHGZM7n9MPANVX02Jkl3tXSSyF7iApcdtb30Imdfvd3XuvND8yqbuSGhTm +2Nh2TzZ9ASSx96P3XAXBVslusSURAnb6rAXW72Gv0BmfV5E6wW1VmS34jCqc1E83le75m361DgTd +4XbxlRg+F97rhXdfoBgdnc6zbCb7WGxd9MM6dUn0TH4EeoChJjf5aeLsJluvZuA2TMaMg98PZSax +5Dx7cZV4TnVfhHew4re7YF1U6g0WRwcJQDHVXaCgPF2XXvc+E/pOqfT3ACzyx0bm+7DVUV7AtZpn +heb4I05WbqLiM7DEQB+rb3/HSqFRMqx7RTarR5QCQpavcMhnsVx/QLwDeuk9cOnU+X1mb5wkjVMT +28F1AS154XK0a9kINUm1281vY5OHWIFIPgRL+Q7Xy9YLDTLXF7YEgop+dzOp88s+WjAVhzFQETqf +OGjdPYJNUzjNXtUz30ba2Jrmuwen00yqFGhwh9xdOX+WvzmUtUNOlC/8frf1WDhqXV3kmFtqZlj4 +l60NIDyIy1Lo+LCarDyVZqISLC5iHBDaCbd3sp19L3xsPTN8ahzPA3Wou6uAQlofBPbeGUGie9wP +bwdeIXXvF5uJh7FW88YjE+o727XS69ZODcwv8lR8+Zq1kA/SiM/yrNjM7YZ8gdRphH7M1us7Gxpi +OTySwVZFL5VIFlXMhKU/nywIpLJVymefgYqYOboDfKwQrbOyzxCPNtnLFutZPnn1kWTecgMwyRxh +2QQKggY0lcKxYbQuq2fACqvfHPYy++nxLZCV/SGxYwKik+sFZ8c55n7zunLwxARdzVRU8zRQQvEn +2Evv6AyYH8WRet9xmRGUhsfQ1wmmy9JbwER4SCogUqSwcVYK31/Msif3ZFvV6cHJWQ== + + + u9AeJKPqMwswshDg8ue9D4X/YiY8evtkVTtVPr3ADDdyNvoqvCeP+4XmbjeQrL5N9kvZ/nATuUN1 +9AJWHx7lpc7yiafCycl+Aqtq1GUtViqS76FSKnu1KS3obQhw/nqCOyhl0zkuMGYLR41+wMB/+hdh +gJvnK8hL44WTo8084JbaDbQfnV/clzLE7BWs+bBZ2tiNksCEvYbfJCmwc+g3sA0PBRVYejcUxsYl +X+dfpLOrTEB7+iYiYa8UOhpkk59PZ1ulwsVprRQYM4C53HY+MnTugVH2oqgGgV+KgoXO8LJ8bSuf +Bf+tZPZj8bBpL7DRThk6i59AoyJt3GNbvSwTyl0XQ9PmM2QkpB5ZxDT6gFYAbNzYvWUvtWqOCr/X +TUGQweM2NJlPsqPP81215WS3UxHZSxafLeHLzvdHdAoA14oqNGrlp3Kg/CwAeunNVY1n1dIzWP3M +NlJF0Bkl1JO5zGkhfv65r6LaNBcdlXbDUQ6oQUwAmBKZPjps3OskWzfiERx3fK2eqdoFcUiV9qKb +igFvoDG12B6330uhk3JSvciIVi+ftuCLfrbWHL9ja5HiNj9yg03hS6UpZSrjb2lXKvIF9XJL7zf4 +vcvzi2xtfk0ZBQo7KRwNulMgtnIDMMI+V3o7DSStNYDz1P4VwNhpu7plvtySTiEkR4lWsTmqxBza +1Xdun4uNt6PN3CCyoxLQEo2ptI/Dszuw0l3Vub0OmGrfGWYKBcr7K1jEyu43ULmPziSJjNjn1yR4 +V9qZjzs5Zp4Dlg6wtFU2OWoyCAmAg8aL/dzX10WmcNS+nBWOQ6ESPAY9wudG2X5jgFSj4mznaEPq ++XgOtHGj8lo102BFNXay1YZ0F81e7r4CCdkakGp2fDyfEUeP5X3dfhDnAhSUVj119tKcl95eqAGk +MVo+TH9Qk9JBJ6di/3CfYzwEiN4jEA53ocL7zniLm53MDkqv/XhC00v3JfoBVmO6y6deIjV4HhTR +rwsdHtJAIWAaWSYYHCXJ25NEVihPZzBsACh0R427zDR8t1k4OX7+LnT2XzaVBUM6/xsDRPT7GLCP +pwSXap7vuP0afpsExlWlUnqdPcdKmWCnrj2M49BGwRxGMgwugGjOxD4F0F+0XH4Q6k/FZj17W/hg +d7o67iUzLolnyVIa8ylxSYpoLXwBdASZ/3zc/y5lLzLj1Ol0PtK6Bjnum0xeFVr5Rq+w2020+H26 +2Ck+vB8VZfckalIDO75WgrKpkRVi8U3oCykjtoUwdvHA198qiVJhnkXHkpdA4wjGCqVh9hTIz3o4 +19vbj4kKig7iB2BwtXm9rQRuYG4oAr3czLHhUgLwsXaq8KHiluL7+paIZRF319mrUfWNS3+He2qT +GeI4F9yvFqPPOWDvc9RAcc4iZAHZ+9QFGEt/7x4XmnedK7Db0pXy/ev4DfFIeftYYF5eHNFPeAAY +eKy0xU0uK4dA9TkELPrkO4eGJHlHqcvQDNLTPnd90U6AnXodLQXIELCbL6+iheONd0I9A9x4THI3 +3+9ZJBJKgSqf0sGWGwMaK+08fAwL76PnCHIdmfqvRVafE6B3uF6ex8cv2ZOHsKCsPgwBCBZb880X +4bxC15N09Hiv9Bq9SenmIsOpF0c6sa2F85b/+CwF4am3oBmyDGDMlbOj72kCRnecF56791vq02qF +AaSOGzenyvw1ZvQl0H9PS8FyoFQZyGYRMJBut+OF48gWq+65P9sutprRNowiuKUOxaeDzR248K9Q +X9vXeLqf+czeS2yeref5V2B1toGFnYg1sqNsp6QMDkOhQ9m9zN7zdY4fHtXJwvPHMwXs/Vo/k5CA +AX5x0Qb7r7sPJqxRRYulnXJ1rIQjxTd2kjccd9z94Oqx+wequBHLJT6H7cZ28uN2AsZagdd05ch8 +d+MxCPZLZLf1XSC2Y0Mk3tmN/C4JbILBJlD3r5tl6DkNkPT/mZaj5bShcAV0rbg25y2pz3ocN4Yd +XVKgeJ+V9jpM9RVZd/qrWMCzQr2gy4iEN3N9vEvBfIbowT256q62EisM+sMVWmG+nfTOh2IY1U9M +4/oiafaNB+ZxM0EkIqcRwKlnNPxFMfuXKVp+cSn/Qi/26MP6LAcsi3KvsnV10AD0cp+W31KRgyvu +cyNMVw42Yokg0GEA9+ntb4TPHpIb0c8uePX2Ht+IzFO1jejpXWEjRpxSROLgPoS6B6sWvmSm1PQU +DK7QAyv5lqZzAi0AJjt4QLE26EBJeUtUXjvAsphM0gfNbHR8dpw5SU7TQmX/Nl4aPTA3xcnTA1F4 +KN3XSwfZgxa5m+WHYi/09mUkH9u9Av1VOavp4gnF6WpyG2p9+kbV6WSyN62DTqJHRIKp4WkoI5sK +pdkN9TLq7RDtHRL1fK6AnTwT030AW5hH0uWNHTRxtC6FXjwxFcqM8L33Bf4s98HX9wVtp0+T59On +S/NOy/wLmzp6iZt2+rJ9BuS+rlulU657Ug6Yd7q/EZpMycDEvNML8onZpFK7Sqe+gNLtNBg9jVl0 +yn6GGsH7onmnTPgpsk99mM90s/TC+AJb1+N+1WyuRCl3krHolNvaHk7CBxad3r8QpfezmtIpioOV +uy1v7O+Qx691007LFapuiV7qIV1/Q50CWmwWtWt6Cyj5aZ6uwm7DxlUN3dOPfTIMOmVGBlKqEjmx +04tgUNcpyw5ex0qnCiXjbl8nz5/DukWnmQbHl7ZJ005fDt+urDqtAK2PDu09mc91f+N5uvXZuTLv +9DIfTn9vD6pmnUb2+qm00ilYFy0p7R4+ZM7NO2Xu74lSkjgz7XSz9MFvXw2oc7NOfQGi9Pxcspgr +txXoDU/zVp02iHL07ca80zKRDXZC/D3q1BfQI3i2FT0UO72PhXQIPjxjDkT0Fp96JU2nD/tElY+R +sNNdXae+wHSz0hlxV40YBbrlx3r6rT4+NCw65bb4Xrv0YtVpgTjdfU6iTpGNrJ3r0Xcq8zU5uzLt +tLYXpC07PenUaMKsU8j5mccYUXsNb5rNdbp5UumcPT6EQ6ad3gSHH5ad1j4v35qoU1/AONfHMnFz +Mt4377RKB65Lmf0D807Hx5tmnQKeDLu9eS1vziwQ/HhO3B6eFMw7PU0XX18un59NO30+7x2hTqF8 +Mc71655tlyw6fRKI52k/Zt7p2dd4cJ4UaF2noBfU7etRbGiJ4EmgFtmw6PT+mih2B8emnQpnsc2N +zHMM8DHQbepbv2nmr/yr2GmTDus2Tfih2thFnVLBdKiinWmVeNtNZWGnUaVT0AvsFoD9+paY/sFE +3+l0tHMgdjo7jOhmuvHUeAzjTnP35JGWEUYn0+v0BugFdBs3cqWjGJor6DQ/M7DCyiaHOz0kT2I6 +RhgdM2dY0tDbqfwJ6hT2Ina7PZk0mkPYKaHrdDLJdkYS/R5v6Dqdsl8pUdIcpi7jOvRujjpvdZ+o +P3Qar5x2UJXrnZdRyvLt/SU5uLF6+0lU3gJz5a2B8wPWW9ix+BqswU4kL43rq8Pr3nIC+VoX3057 +gmFXcsPPzTuz95gpXhylnizfCtTu1Zv128/GS1DGmPF9ltp5aFm+rUaGh5T12+b5+57yVocxbut8 +s9WsWHwtVHYq+9dT/PY9+J3UfXsd6UrK6Tu5mTJg7Lp5XBuavcdcrhDpTSzf3gaaiQ3rt0+F1IGE +MZP3b4EXftvy7dfsYlyxfNu7oXKXylsDxga9UvrF6mswpMs91vLtMcWk76wxFmgNm7Wq1dc7GztH +T7uWb4vZ02bH8u0xdbhJWmMsu0Fth1MWb9kKUTzYleacCu3p3kbql9ND8W0+vq/flZX6W3k3q7xn +pkz0SmuB5Yl28DEv8p+3QB++HYvmaOmVxawnN5qe4V8aPkbNtqGFmd+IHSfvgYX5VYf/xOGz0ka0 +cJWH/9wi+0223jCPEPtrXOUkzjfZpIIHFzGRnwM7R6OPpbfoIPjweID2BrR0VDsicSoMg8COvZsD +1rq5A/p735f720p0D5phwJ02i5P5WzymYbeTTV9A6RZZOhadclvQznk075S5f7DsFAiRL1Knj6nn +iiwdy06hyGtZddpWd8rUgI2s6lY4y9VUnbZ3draUTpH2L3dK69ALtX95puW+ptPwPbJe1d1qEHxA +WXaKtH+LToE9CLT/F6VTMBfNXJ8tOwUInjLWnULt37JTXwDq/5/mc93fiNt1Wg1adop0CqVTuPc1 +3UKdoq5Z1U5S6h79EhcinH9oD9y0e5kPhuq9b9GS2/p+Kd6dO7ZjP0W6E7lFDsz5KStyS8PWfQsN +IHauVA6adGk+EZnLTi2j2/GJ7lYqqvyTHofaddFYhzwJ2/vpcXh/LEMMIRDpZGX7C40inSw/FgDj +ahRhz7TCmsTu08WA+E/0dCR2gFRgqQNZtwTjAZM7GONGOu8TYHu5xGenEJD/uVJrzKLP7FxuXIC9 +lNXTfTs+FH1KYMjXF+DBDlRo57sSdrDeLrJj1QwudrQIlD1uYMDEMRsIoH8gQd5qrSSzQfWSR7pB +qYf0Og8C0j2NUsFDQuVH07kDEcoBt3ye506ckA7/EQePjXmT+QU3LOfnCygzRP9YrqC0frVN5/Xb +kue3K9KY2Qyh8nptgyz36zdC9IktC5fIsgFG7ua+SpagfG7IXULWXswTZSl0pZHImLLKT9/eMW+K +d6DcPIiUvDTmqdxD8tge7z5rZGlZT9jIel6KWtZDW7IenxPpFp+OJmoEykPWIHAHsx5z3L3AfDEJ +wRbjiRaj+B8Rd+TQHHf3sQ1Ltm21K5E/znRq95vep6aWYmhy9OFN/dQJ1eWTHfE0wXQghYhuVmop +pppV5yK+I66+gY0WQS83I08TMuMwgHaAOXenwq28DdV0/hbeAYO7K1gsU3RMNraDFTQG7OdfEDGE +tZT+HEUOJMpRUTJy6pgDI90CMwOF8K465dk17rtGye2+s991QFY2Nu/mtmu5RUavySj85zGiOqQw +kAXgjKHiidlyAoypFxT+AxZUcUQbaQPMT+aCRto4v5SHpBoXmsusbDqydLk5tZpkhujMrhMGLcy4 +JIrFdxoxLkm77KSFuWU9PWHqC1gKJhc6o9IYaDOPM0ux5At4Wd8yxEnFu/ZktvfbZS2fNkHW6UgR +vDZDmh0eW8rK8ytxPG5UOjAka4VOWjpfwN0KAivfVrFw0vk1KzgM2CoWHtavfDFQQGFKXgJYbehi +XGBXugKmFShexyWd8IrA7u2NGC+TVGt1S2PsdbJCjGk5msdxjbV+mDd+YjBcZ+npgtqx5vwFjKdi +ZgxaKbSmAprK3X1uOPAxlYJtvitnh5sr25W5u+9tb4YyPo81rGQFHplUFdxAS9w7du43d9waH7Ju +qcdOeiqLZUc3grliWNExBdP94rxM6am9iacbiEjJxqE4cAFXA9HplovhxGHbqwaCbeSIhYj6qEDX +9aMHmxwfSmqDjOTYHup52oyrHNrg1xGk+aKHDiycGkAT3LDRYUzZh8UGObJXO3wBLw== + + + g9pakAFouSXccs+zgL1YdssAjhQG4Nbet55f0AXKfe6QrtEVnP0Zek1e8fV9HcFDvdtVEFVhRhaf +p2WFM2hi4UwNHwubHND+J+2WPsUTKztkud/ilmYPspIAsjxucQ2y5C2OvqC3k72EdoMfw7lot7ip +1e3sXQJUu+nOQ2LnSzjWu2T1o7Fzyeo8JINjrQZvYRQ7u2TB1FQbSVx9z26SYxiXcOrWvSFbSfqh +HM+1YnkB9wagg28KTQhFqhhWy/1a6WSqhd/HF7Dz0g2O4eHu/VJ+H4gWZ1+fjhVY+GsgdjhXlKzi +mxpPw1ijSmfmelUa0IG1M1HkyS6UaYjlE70q7QV3WB9D4wnYj8etf4E+vOaDOopQ2WKeBOGJThNe +bL+kLsP2U3Om8xNF+MnyZQFv9PhEL/esJuQL2FA6oB2t0FuEARxeB1ifw5q7Q8yrg5PepxN1Vros +wI5O0DnJIbUui+eiEnXwsCqojt+AswLP3BCD5a5TUXIejCfuzedtnPNdzUzaaU9FXR9BAmBW/lYz +byu2LKz8rRCYh81nbi+BTeMLLH1IgVbNXuT5XMPRGpLeRiOeiWM4y+5ADEW2JhUoEk/2Ase73JPt +fRNgmhNCb0JUez4YRNpFNKTVOPMoTHUlJwx5FHzqCzhvQxfiBgKj4p7P+CyUCBjLuesKlSr1M/Wt +kWJ6jjbthQ0cbdrTH+C54GimHpI8QEzme1mOdq1wNMl69aLB64E5czSfyxMkCGxxjibvyvLNaAUc +DayaGUfzvPcBHO8czeC7wHCW52gQyvJnrwiOzWlQNBeST3ESvoCZNqARQjcjOwtafXRorqMw0Stt +vCWweQy+cfhs2QNYSb68B7+t2ZBLzSwP9vn5zGwzYw+8NzYLgN1seGKyvoAlm10w+kG7mW+QLa2x +xBdRUMCq6YKarDiMMxx3qr0lFOSHAXCWD4FAUCwMat3JuzMc7aG7S/eyyWkCArYKXzWWhWB+Eahd +aKUheBpbRr9XEWlj82q6tMV3d+vWm6XyXVhKw1tP+r29DxYCW16/f/o2k4VepRhcNe8uLaMUg3CW +0e9VUGRZuLgUQ3BM9HszKLL1agHHrTS0l4WIwzx9Ly0NNbLwVX9OjHoBT1cSjgT5j2kcligrNcFT +ShiGpS7wOrFZEjUqoy5O3+7ulvFV6/z8ANiyu1s1LpO9bR9rbYMxV+qutJKwFyuLCKxl3NU+tzk9 +zQN83iRsPFcuwul0Q7KkCBTb47i99IIpH48ZxFI+nnBlV7oQTFTurm0ZnmcduWZh74ORUe5Q6WJz +Naeri7YFwCzPbmRvj9uAegCM3t47qa7CQwIwxntTMSxiEOFKvsZd+WAxMIvNfm8bfIspwif5710N +yiVFGDaXKJHx1lXkWZo9HZpaFuIaoGy56cdGbHj5uhG9eSluxLL0C8ybK5pl0OGbW5bPoVNLMWMG +nS5jaOEcOvsMOsSTV5BDZ9kpyqCzzBb0mENnn0GnzhZcJofOPoNOo/UtkUNnn0GnyRZcIofOPoPO +JlvQUw6dfQYdyhZcQQ6dfTsxt3rpHDrDxtVk0MmWxZI5dPYZdEgfc86h0wQk22SYXQRLZtq2dQy8 +dSaQLtjFxZBMPb0F58DtXXf5UiWdjbxwMGxBr/2aOAfcenofC1pp723pVGd8BX3AxsJ42tvVkKs2 +V1SW8SE3yWCdr86NkxNFe8ZnB8w+Dsvd/JCvzylzzvX8dJ4r435xj/SE9yFZZD46eK7shmSWMgfn +4ilpzhWvKepCQZTYHm8JVDNPoSA4fsw0GMS729jKaYxuBlvaX3Uf27Kfms9lsps2EtKrYxBRMljz +ZT3GONnN6thGayU5JbtZ26f2Bw4qblm0DQbRmKZOZkhRl82gyRR2B0wbgkUaT2ya1LdT5qM7ntUo +eTJ60a60MnubtHUIpacUU5T7duoy69DZtgfIMjvLlvUxo+vMyXHYE8Y6Nwn49to0aHaBE6uypdpl +mQWm0pT0eWCOapfrPL65Uwy8hzy+plP+y5bGaWWdmmadBGOvShtj4IMHn1tWg8qYpWhar59jDLzr +KIJ2WevBNF0/t3l8wsQpJ8aOGLTR6RDYyjJEJ8rJh1VmihdgzhTvHmNaB+uSGHNME3U/SYWjLYQx +reOXyt3dx7SBThVdYL1JJpc7Xdbg8zWaWfJWvzL3W9rny+lAWADobWolsgmIN+qFhP+82e7uigtj +T7b4HIy9j4prY88KgD5GcQEQTlejgHWWb9Vwlyq30Aq9Es7yRVJpzLcFTHFzdjL4bF3SMCvNwogz +kL1djpzPIc3ZxZEnmpD9lSc+g3llo0empoZQ/lBh5gLlqpMRK0r+OvLm3jExlbCm5JAgZ+A61hlR +M1NpvoA+duR2xyv73VIf+zry5t6xTrPTRxAtjKdPB0+DT2dKWJOAR4+MZkiafGQwKMqL+8NmSNrN +7CzFbPDEuB2SfXS6c1Kc3ZD0d3fEdf5fnJK0Co/MMfLILBmlBjThbRceGfGMzyE9ZzsV31nGI6Oy +94+X98gAACGb6A4PaWiLeGQM2YLLe2RgGprOI2OVkeqUn8d48siY+vmPXaTnuEvOgSl6YMM5U7K7 +8D1YqoPQKssnirJsHTfuRlmmD68jWy6IwT4ncXyymkgGuC6py+BqnDpgaqmQQ0yvmzS0BQPY1fIF +JpBZe5c8pI8ZQhdMswWd8uo8B80aI1RRXp3LeD3bvDpV6qhNprCzE/TE9pIq1e5V6Za2oXoXxrtI +4TOXgk7KebcKTFpNPhzsZRUxdfb5cN7vH1skH84sCvpisOp8uCXyLDzkw9lFqK4uHw56rZfcgS7y +4UxuBLVM4lo8H04TDSV9E1x1Ppz+3lGcEbfqfDjHWwJWkg+nObFyEWq5WD6c3hazOtaBmWzLZ9ZD +AbeymEgAShsTaaVbuomJvBm5iol02vvTHr2sGpBHARLLZ6MjOFGn1XcJx00eiSUUrI8hOCvI5DJE +MtjEwDtzNJhcZ+0QM8Y7q2rZWEQ8B793DRHPwW+HhdBtQktvz93NMttQST5SeRWW3YYAmO21MmZ8 +zHIb3o/dbkMbbRzi25u9aEpoq7kNGMHxtn0s8pEBnJUkQhYS7qSYIxzrK4EtbtOyCrM2XgnseBua +1iutu60xHDX6sGDymf3FTo4GtZyRSm4uGiCimrPVxcILZaQ2Nl9dJJG6zEhtbDbduAwcUv1WkpH6 +9L2ajFQIZxUZqTBfbPmMVAhlFRmpEI67a6B1JrFZXB/aINaXpnoOMgrHxNXXbsO7pbehLhXOnI+t +OhUOxfPbRvSsIhXOdF1Wngq3uN9SizF7292DXblEKpz6DiKUDPdLUuFMvAq/IBXO3D/m0j67t1MM +1axAfX+yXeLTp2Wsqpsb4bX6WD7uYBa5DfSCoFhXHkUXDmQIzPpmO486jOGSYa+HC6ps9HuXRzh2 +t/MCVm4m8pRenJOb9Xl1T5bX4eiFg+QdNREPyv6FVeOiZv2Ja4BKXKbPP8v9m8ZrYas9L5aS25mX +Uj19UcwkZkHA+Uv1Q/4elQ0vPBQnmWyFqx/nc/FWPp9LnMAiBLWxJI4Cfe2QRY+TNhfLLOsMWkli +jtKjdd6ZcJm6UJOXNtltr3V+qnY+qzplP3cD+xsjqww75v7OLtmtnbDslCjVc3YZdoHz7mnDqtM3 +m07LsaSqU30uVioyVXnh9MluzN1nVa5MqEsB2wzZJbuRcV2n2np8ewOrDDtua+ubmz9ZJbs92mWd +Dewz7Eb1umWnO9XOZ9uq0459Pb7LO+tOi2ePZUv0bg/pvVerTi+1GXZoVcGGFWeNfol0nnLZbs+s +HfYqaFoyT1VXEJnwBW4nis4qZ6KInklWUro07+sFqp3v2EXIrVaDjQzxXDRnRBc7o9Wk9jhHqOq9 +JtZ1rL5dDEl1LmYzKKfgVKc4D2y9rrKSnFnZEZM7VVx4l+wqyXnywj0WXIdIOmRDojshPcT1ORWR +s43rc09PDkXkLOdnVvfNqdiI2/k51xpwjXSnOiO6u9SWqB/nfr+UO9aFiCzDXd0WoLP39C6STbeY +H8ZrNp2ZHSDV4lxdNp3L+2GWzKYz8wnq98vy2XRmuXSLZj5aZ9OZ+eLNI+2XyabToEXcs6b3jy2V +TWcGyuGGkAWy6RaUyB6z6czOaWRZubJsOrNcOrW9v5psOrNcOpexPR6y6cx87VIF9tVl05mtLvL0 +rjSbzky5UceOriabziyXzuK2+SWy6YxD+tyy1pQWzaYzU059gVVn05mtn0k01JLZdHpQjjWFF8qm +s9ItV5tN5x5jy2TT6UDpz8RXlE23EMY8Z9PZ5litLJvOPLd61dl0ZgBALyvOpjM7LdHFwK8gm86M +PWit11Vk0zmcjKwom85Zvqwim84MGYo2vqpsOqdMrtVk05nl0lnW41veAIwpBqCmvpinq5usq3gZ +i1Tqa3O4THz6dtjsGuQzI6taNovXqzMMaQZPeVZdr85au3CHp1kk6AlPCpY0kZAwJ9NRsXBJApoE +BYusZ6tB6YbklhW4qC6nPZhaaEgQY2BQnsou2w3JPJDCksPY4Mmm7LIFy4RSTGsRHZLHU51FRG8n +xw6Fze09c3K1LLtCd0uXuVPdc+VSJV+kzJ1ldbkTV7lKLsvcWWVyuUukcxUgYR+frBS6W26tyvdj +N1VmbL1UrsrcOXoUIWKWLnMn6jD2he6WLnOHc98cCt25Ozwan6zgniv68Jq0X0T3eRYnKwtRGp8o +KvfCuTxgagdht/RpecoDC9Q5xh460SdMo4PGs60H3lUinZuIZp9zhqF1EIfr/ELQi03YoYcgMogd +S9eflpLdVdgCPW8F9flE8NJUyzmb3Q1ldd5TvhgsmNiliYYCROUQD+46GgqAcowfcx0NBYC5i+i2 +D2xGvG8lmY/LH4XAioI214GLq+8SjqvarmZQVJFdtVXsQATFkMluminsnMuOgLlKrLWqAaFPrK0N +jYm1teHqbgWEwFZSyBjRGBitG2amll2WqKybodKx3qtdDPWu8UgXZuIZI6htLXGrGOrOtLeSzBT5 +5mPvmoQRVHW+qgqG4MWF9RGx671/7alQtdXpGyy8trQ6gaHYRXV6gLOCWwIwnGWrVWMo0iY0u+HQ +W6zqtYtEBk8nvOGIyTa8cZHI4MoDv3SFOym/0qrG3QLb0CS4YtG61d4q3NllPi6xDSVCEyvcraRS +nmM+kbtKecvmE8mV8pbfhjYV7rR5SW7yQxapcGdX7xXWuPNe4c7treYw+2n5xNqnb0XNsbJeXSfW +AmDOao7PjaKDa9Mtllirz3xkl/UfwfzCU9N0aG/3XCE4C/BNwx0REM5K8jlPCXe2mCMc61xYXRKT +z+maCVQuz0t+u1kSk/pUFDKIqGEbpkIOC+HCryXVfXOZxuQmiSl48KK3RFVSzE0ak3aSDr5TBZS8 +LpZpTKmQqwx1W7Nd3pWpkJtd6SaJKXgw1Cvfi9qVd56SmKwiiGDtRBtJ600xvBNzeA== + + + l7iVX6cYmlyWeHePa0CsIsc1H7e+VQzaL14r0nkq94hQaa2P3a/uaqp7dPq2ohzXe8urqbzrMM2p +p3KPDpXyEgvmuKr2pxyG4SLr2TnHFQzJddazXY6r6AGCC1HlzfuTVD+Y8VY5qBd6ZD6XOL4tbHWO +a75A4TBSqx+M3iIc+FW+QNl9pbunUpsKpjcLWPAg167Kdyz+0iThnR1eqTvV5MP5AtOtm/sLtatK +W4ctlX+8t8iHC1sn4U3mbylSy5N1aXjErlXuH7e1zV+Fn62S8J4sOwVz2SyNacu5EuWth2vLToNH +zfiHVR22sNKpnMmlIPiCpVSdalPTpkF+R6kjSOuyHMOhw8e+Wae+AESwvuacJg2voc/9U6P3ZP/C +olNuK8CcFd4UH6w+I+7VptPyNmfdafly68GsU1T3TahoUiv1nV7Z1RE8ubHutFi8Lmkiu0C32/B9 +VP4lJmHOdw8S2tW3aEfnCct26vxK4m03lXUBMZIazYqKmARzvmf0Sqd8WCN6e7TCM2/jJ5YFncuw +SYBUNoxOgzRVzJwDJ13IZgD7QJ/Y5OghsU5JMoZWWQ4JUrL1oPJuUpucE5umq6rMghy6DpVZ3HqS +CvahVZZLZ6jMAjqoeQlBs8u60908uURWmkOEJsaSzx096Q69vM5P9lrDvDvPVRYthmSI0tLvF9dI +9xSl5QvYDcraT+xtSIBbWsdpieMxxMbq2FXxKb2rPbwuGmumLGZKANhHLq6+dvDBvhRXdXnjfWzD +3Q2HLrKRbN3Lbk95XorL3ESr5CQaroxbKNnN/Mja073WL8UFPcvaWzRhFuCyl9Ca3RVnmS/mZLUY +74qzMYDM/WPaoBGTI9ZGyVO9A2sOU1qZjdwo6TnMoqfeOOHOah+jEyvn8nWaken9/M4uO1SPz9Kr +wnwbAgh6wsS7PmJR+yl4cGd9OOgtkcxQz2KJsmz2mUyecqySnu45UA1Jl//SLtv5jh21cc2QVKH6 +4mm1atd6TAXsbbtI5VTfc2WTCuhU0thh/ZST93bZOVHHNTHo6hqbVpnxAMypik5Qn11rA0wnVZbD +mGMuj/tJak8ul8SYYz0dTxirMk8WwAzpwmbaoYixBbMA3eYAur6HxCpBzFUOoE10uossQLc5gEZ/ +spcsQLc5gOobDr1nAbrNAURe64WzADWkYmNh6uNgvWUBus0BhBhbPAtQwac939DmWHnNAnSbAyjb +yAtlAVoMyZADqD6vxOMxzmr5onzuK7ItU5RPNZdfWJTP4FX4JUX5nCqyraYoH84ZsVdQli/K5wuY +aIUrL8pnrI/8K4ryWddHXmVRPlf1K5cpyqf2KsBBcZaDElHklBpsXdVv+buhjldxN5TLun6u7oZa +uq6famoruBvKqq6ftzilRev62Vf1W+huKJO6fvZeIXNL3HtdP3Pis70baoG6fs6UvIq6fvaRIbLn +asm6fk6ZXCty6NpW9fMFPDl0Lev62U9N57tYuK6fZiCGqn4LVAAxretnPyGzCNVF6vqZpiPa3Wru +HjGuM2VN74JeoK6f/c1f8pn4knX9bAVdHkmxFdT1s3cLe7qByqaun72paxoFvUBdP7M0SWXrLVeP +bwU5757q+tlDgX7+VdT1sz9Q8bmGs0ziuz4jddG6fiaqpqqqn7o6A7FEXT/dNiS0Vf00d3Z5Tk8h +5Lp+jnmvK6nrZ1/VT6bkJev62QdcqzJSl6rrp+RvmdGi7p6rhev62SMQabArqOtns9emPXpF9fh2 +7aG4rsfnUE7OdT2+per6yVBMt4/XbA5DXT+bvAfHaNuO17p+9po8vPFgFXX9rGT4jfEkcbH8LRfq +vHSS6LQNner62Z83a6MIFq/rp8W23lpctB6ftyAN63p8K9g+clW/5evxuUlicrq9wRir4a0Unz4j +dbm6fhrHtqGqH84YWr6un5wqZVdXdOm6fvZqjgWNea7rZ1/Vb+lbm8S6fkv6+lzW9XOR97qCun72 +Vf081+NbKAtXxy2Ndf0WT4ZXVfVT9bJUXT+jK1ld1c/qljOvdf3sw7t0Umzhun72gU46n9LCdf1M +1kVV1c/+Xjj3df0W91tqMeY958nCrlyirp/CuMyq+i0cPair62dLEaoKIMvV9bNXDLH1unxdP/uE +WFEiL13XTztJfVU/gz7m+iYrbV0/ayUI6zAON1m5rOvnSodZuq6feiWNBzg22bUW+9O8rp+9cLDN +4lxZQiyW+wkT8fBgp6OdX5tHfOjvlfrENyrqZCV4au3atQ+816UtaqhJojHl9CZ9MFbnwWPflNhV +SCMh4yMFMUTivMPJ+DzTWKLVKcx9o6afG0CsHG9EHs+2icRdj8eNYD7VxvZp+ihOhIYbidbjmKEn +n8eldP85eXm9G4oNwsHcd46ofJxlt77nOW7jqdGmwa+3TIAV9io7p+ffV+x37/7RF+DZONMSTkt3 +8ZP4ZIOtlpm33FXv+rBdO+VuP+udM/b7JtR5377NhpnC12b96qSX6u/fjTqHoeH3K/8dmGSG3NnG +7dlhcJsOlbnA++PRUXj+ufXIjJ46KXHvo9zO9HW9drMRj7xkNqiP75vIPh3MEKXcSY4ovbeOiTK3 +czWZvCVDk6lwezTdeuGaU7b5eCFnWtYjB4nYbZyuJjeltLevxGT6NILF5pJbOLfayEM0+aV7D9XX +ZLZ1OYYGtVwCEtaTnL+Rgd1spnpshiyEDDDd2Q5cF3p7w3KuKKMx1Ah2LrZuHurp7eEkUdqhmI/5 +Vr+90YaZpMdScujGPDpmzmC82ukQ5SRuZEv1eoDY7rSRvX8x0qrsY932AVO7yKuS5hR/q2pqgK2Z +4SHNBfJzX6DwUOrcoQKa+efy1R13lm9vZhKz/eNMYtreKyW3ehfF2wz9AtA2TJf7N3dP2Qq30QRw +br4lsLh8ZoiM9HiYynj/ktmrbkzQrLKDEaTk7Mnt7WukeHNXgb/AhC/6cZi0G8VmfZq9nyDLiUjM +QjAa4XWGOXGCjQelX2QI+Y4BRvgh+JPfRVm/gOEcjcGfB1HEYbaCQIo9TsCDfFz6sJQoFalTAYCt +EJFCNDAvhSpHR2Q0+DkotnrfSSKR5sNooHBwz+RuntzLdxsJErw4iKheNLbzB76A9CofU15RuYfr +Q+nFUUJ5QW/vfWSlF+ek/OJFRFv5YFd5pvQM5X45H1W9gn2LcMpg1wNM7IKZPkXgnMPU8/QLMMDy +FYluwiErh1c0mO7lrmq6zY8IxOwlQPnBqEe2tvmUfC4GWCEkrxzZih2QsFEC5i0NyNbhEUTbJSl+ +c3mNwMKk1v0t2HME5hYjsbRNhWMM1P7rMaVTKnyY2cO97MED76tcP/6xm71ovVcLJ0cbNYUk5WOB +vNZwDWgNzhwVrpT2zeABSl4U4mX1QIaYY2cX253y84Pwka3Nt7vFh/YFAWdFIurFlPxGPc9fMuJq +3L/QEnnVGdXUC4d8S9oHtzGEQKpwmYcS8DYhkf0tgN18hrXZbklR3WVvRe1iBH/T8i8GgyjuDTjw +54MI8bVVgkvykJC+fiDkX6RqNG/US1cazQONXvgC4qtCb1vcB70vFs9FK2m1Z6Y7GjYjcwELNgNk +JWQ0OjaTej4fhYq3udPjXLg/gTn9XCVXJOJ1I5vRV+kNImoDXEBAN7qG5XMxwC3FHX/Xi2CSzN29 +TMGsNuOJ7ubFDr2dHMwIIhSfitMFzAXFTSP3JPiTCaOsYLL4lIF/psBG2v5KQ74RVa3+E/jmBtJE +JY7UIBipEkeGO1l+iUPDvJKwcMFUCJkgd1TulDR7EoKhot9klBi++QLSQp3s4n0XzQea8jNx/wId +Dm7nE7Dw/E0l/9bLtjVMqEoQbPMELsSJig7Icu4bahwf5whjZ6CD+xHixHDqT1lRLQGsBz/DzBUy +HCxpbOWQ4pw1jbSXljGkPYOvTqGakwECXJhjvWaHHZVUyh16tpnPboLPrmaw8Y3m7gNJUwqrQUS7 +RR2ISH77sCgL6AoVSt7TisqGnm1upg/LRDswLEwmB6NdtQoB9AN0r0IpoIAgOptsQgfi7u4iK4Po +hjRbpdyHSA3h9Ss+7cXonb1HEuC4EIWUI9mV6CmksTh++jx9hVv8aSqxmdeZBvNbQbHMMfVxKWtK +z4qShApMQ1VzE764R7hT6clBRWnZzdzuNiTd5ICS1BJ8PwMQf5tMWV9sGRbCldZlvgE73cArwEwf +d6AUK71uSHdkJLfE8fSvz9TK+310KGIsF4ZOD3wpROU5vvl1DfAUKYFO4zG0wY23RUAvHBhZOSIi +oTCtyUh4UiNh/nguI0F3Y0dEhYLHCd1U3d0ho8AXCOcf2i8SEsB41EjgJ5ZIkFCwu61CwWH+e6RC +wWGoMEEoAJQsdivV/0ZL4owEwIR6CdwpzZ/3RBRQc9KMDvCtGvdaJCQUwr7bGCWKGAmT3P2jgoRQ +c/vqyYIOxOto5arlgI+ZkZItiIh3WtRGDkvnAMooPI8hZgYArYtrEPEFt5QSnxwmllyNqDVNI84v +jcKGpqNRCxCu8IA4fzTuYhp05jIUEkE0Ds+1YyDtx4DtSlv+FKUkENyWshrTzfJJXtMusau0g6XS +LyzqvIPFCS1LY+HlaSyx4BhUNEYuS2Ph5Wls1xKECwCYxmIuyFQDQj8NB1SKNGaLCWJJikhEfAEX +mLAF4Ybz+QK2IKxQ6Wo1IIC42tuzEFElXBM2kvumIIhlp6HaGb7AYtOgPI0B7X39KGjn/VlhDk7z +ETyGSZrVXPr1RullgCKR3WKCinofg45bUssSFRU3owhP3JJyo9yYySGFW1LLbnGK1P5J6fgYRYvG +QqhdBwZpZoo9MsgqUzT9dPk2hK0IxaYrvqT2RbPvvDMUbdu7Xox6rbSjRKLxHUPWMLwjYvoZg1/H +kQ1CH15vItsvKB0nbgVR0A8yhbF3TTaFsW8teHD1Df7MxPCfz9MOMhSD9Pb+/lvpNfyI6r+8ZD5k +czUke/2eiXYolJLs09SuyrGmmkE6E1W51YKH1bT0ohRXXqD7LmQXDDB2VR63w5txTvKUpdA0wuqe +y5mIyq2m6rlcUhx6L6gmNPLCVROiV6F8TkD3QARnpgDjmcKWXPMl0JCmexnBjrPmmIRkfxmT1ett +KpgOwaTGy7joW+PykHIuCVxdbkK2KufogQi29fBIij7R+1IkcVrrQX5Qx+Y/FeZSbanTehz3QoS3 +BYLq1wLFaDL8//d2pWtpNEv4CuYehhiVzaG7Z3eLCiomuETEiBoRZKJGBUU4+fLnXPup6mWmGYnx +0+TEJzpVQk33W0t3VxXj2coCOXyfHLy5jamjt8g+PenTik/vB6UXSJwkz/ilRKJJpKWpx8VCY2Hg +LTecnVX/azcrU3HH9Yy03+YJi7VxnpgXy426N0mG5EtRz7hVlzBUfLFksu14i4o0UOVi15VXtw0m +r0YnZ7wMyNZz7Za8YpcuCnC5ALCx1vEKSjy28Lkofda6rRHx7tZoX8o+zx1dxYk1pg== + + + Z9wWut/jXzixF3TiuRzz0pJ2Ep8ROQJhbUvNrEh0rZ+uco/Pq7xe/V6+BBy7IDPnTjbJnMfJ7lme +U8KuY7G7qOa45WE7C64M1UKc/AHHXsl85QBjfbTIH98HHra4Vbo+GloiVXVdnC/w6GS/X1j/OOlT +O8Y0ON/OJ2G18Tf8VUOekVOJdp7JT+XYecZpucwjTBYiTOdm7fZdb4MWz/yI48nn8okkea+Ux6Nx +bnNsIZgFQk10s5ENeN4LHVem0DYvHURsx5LlO7DU/y4bAfVdM2DEN0v7o9tosDu4vrzumUVjwSit +blHa6HX7G4MoOoj+GVb6F6O7qDc0583Sar28tRW4leii341M3oPinvtajkGk1mR7jV6JHOu7EVno +yrdw86Y6tb/UrnwjzWWtK4cf8WfvDx4yxavvsDvJFC6s6Uyx1T3JFNlGPZOtPhaRbIo0RDyzp/Ww +czASLz9ViQZro/XCdu1LKoHOV8vw/GBzyZhe/7IW7a+UHi8XS9XV40+V443D+kppSPo8U5FODoqZ +xsXKCbXNwYANZzK5xR0nM1eaPcQaZwXm8r4SlDLF3MoKcj9mCp/f7eD8dvAXHzJzq3Y3U9w+qmby +D1MDtP9AZpA2RtgoxwoyNZzUbzZaLeWDe33uGIZwIVq8vMTM7uGDjLGYJMZ3x0niEiexEy0rr75H +eelFYD26F3FyPoveWJ2TsQMf7CFFfGvMD1XGeUtbqUi1PQzVEvbyClRSfzKm/14FKqk/iaz3yytQ +SMLWIgPk3koiuyWz7HsbfMuQh8AWrXFDwyp8wLupagH4/y6odm+3hGttEW7w8B7IBhebF8op7Z3Y +8XpY0GpR3RkLFqRmLVnHz9VduLEfA2KVUntxZv6yN9vYWFx3vqfSoNiP8FlvrlIdVnEvQAgj7JUT +iZPkic82vFiieo4xl5j7GHwOg82NldnooLLVXcpIb2oe0bjMxMbqN7nb1pRaNNtOPPW2bl6dXR5P +izLkdholafadI0I7ta0cXMF2Q6wrnTO2HG4x0FWnjb0O8rrrcBFStTf7XOIcb4AC8khtk25OiLo6 +S6yto2/lbrq29ouzjN2CufDV/Xz7YZrPZbwfo6z3UIHV6mEmjgK/DzMYLSHQYDRZlG0VyzcfRKwp +PtzvTg4zcRzjft6dKc3INL5Yjrd7crq7UV7ts2eX6nlZ3obQxLfdaM5Ebru/rLfFWgvBBVegalYs +zNHjDZ63qnkZUui7EqvMnRR4eTte1ufkZ4B5jRtbZI7k/mvzU05+Bs3dKE1uE4T4owwS+0xVsylE +BieLpTArtUcXNfVsaoMulmZxFoBYExeaLL26fl8mlY+LffI06sD6IstMS3leYRO1qALXmzj1bJ7x +XPfOnFyp7+dLL65JCtlPPtkRP/tDqDGxJ2z9GCyVvidHxEmFHXxa9GdV2BkUUrWhwWDxQ13PfZCt +06I1LuJqudHKr8dFrEaqiIW8Kb2Edcw+pkpYZH1xVwgQFa/PT0WMxkRUZ6q6qzj1WbVeY920uMPw +saJoT9UCXlkxr8R5/NmFy2C1xfoD7i8HIszA4nic2rS+/licveM9joiJrFplZCVn4W4/Lh81nykf +oef8vnwkK8STaifi2aovrJ1MqJxoOUxj+lUpDv5QQwHBmQ4Br+hJCI4TCGAuOB4dBNzo/waE9uJO +AoF9ckuDBALcZ1upMmLy7PWXgPCSTP/z+Wj+R5Gfr6E9W0bEPxSnUDxNGdILK5H4d6neYIvqUwe/ +GsXLxtAaPC9A6OVZEZ3Ht7nU5tUo9spXamPv9P4FNg3RUhORsum91i/c4qVQ7kWPSbR8VWF2ea+f ++f0Ymqr7cPIoBqpzwWneJSJIdbt5MVYGP43tt6kpnmx8re6nbIw/xuAtNlbvvdnGouEbx3CbebON +HfbebGPN/r8KvU8FdAaxjT1jIsfPTePqxVD+0sZuRm/TRrOluatAbBISz4ro/LvIh6tYWkQ0eJs2 +mlePKZOSiL3cqJo3rzDssecxLTd7ozdOY5CZ5Blwfnn5NEbvXjmGeJ98PDX1O/9kj6eJiMzs4VVd +H0On8+s1QFuRn0OiEz28ZQwYLTtXbzSqzs3jW6Nlpzf8bah7dh3qPIy0ffKrXLwzyujkxdS7MXJm +ih8VRKYY2xE/FDA74aUyJCQargR8g5mc6bRjX/v93ak4ys8uNV3VhdniR8Y51fV6+ijOlXHTKqaq +5VVWZPPgKJwfPwrzk3FRkmWLn5ut+G2lOMF+mqSDETE42GoZtz9XgUrqT/wuf6kCldSfjPEKFKbB +NhuMZ8X0RM9eucATZzLRs7c1pw6po7w8Be7VLJFbw2edA7lPcPdP4VsX9VLaOxJi7Q8HPUu2dr+3 +cqoWtcV1WdAzhc1di9/FXgvsYCE6y30rX3kbu2u3wVSgpa5FmhYO3vJz5k9KCMnpvblf+lcSJ8kz +xiU2SCLRayzNl1cbMwvn5Sv/0/3qwWrvi0jFrZ3kz2Sh6eIo7pg+sJPPLuja7dSKWg62LROQnX3x +2Qb8hHtOXLXfHYoEXJIaYmvHdhVrI01eaOFXUrGdS1fk1kSG9qZhiR5HGnc9z8VloTk9L3vTZlpi +TcsI31w6Kn907Mq5HJEpfjRL0mri04YTG6wLf669mmcVJjdY/8H2amP6lw3Wf7C9WtSiJjZYF17T +Xv3432VjAUxqi9LWeq+r15iM6Wng1KPh6B5f4LbWosvrXq39MxoY1BRfBL6oGfCf+OXit1rHyD6M +olFkfusPzG7/R++23+7mzFrPmG6VVgfDyvXF8Lrfaw9+mvPAomZprd+/NbOrW/WNL+b6P/f9wdDk +NzIP+ma5Xs9heevZ1x1eP153bqOx15eOtmuNrYo5b4rhtGA4rWQ4CyiIkhYMCF4l3gJQtAxirsL/ +ox/GCH7sGsQi8M+Gyf76QnwdtQ3CQWHw/+gnEB/h4juwfpiOuW2efCVmF0XvGza1fM/3TMeyfSz9 +3cUc23IC13ZNoKkXhCYDduACTSyHhX5Mlw3qW65P7JhTM6hnBTaLGUAym4WxSEXjTSkJUYTkUGK5 +XmgLEYJDLcd1qClFUmZRH96i7qnosqHGpTg1Q41ccdTMlMiYljctP0GjZnybbCq+WdrqDc1s/XCz +Vb9q30cHP+8jTXV5UJkVeIT4LigncEIvDOHCD0LXCaS9EtRTgp0ThMwD/GGiPoErxaGoCttmOFlv +DLKYQLTGoMMpeiR0TCUMIHBcwnTYOJ0oT3FqOpCKQy1ghDEH9SBvgJcJfEwbBRA4Ppu4glCTUMLU +/BJ7EnSiScWpPUFpEucbBIMKoud4bhCP4y7m6GABxwtgRJ6DWHlWiBgTxw/cGCFFJwgpToKQxqFw +GdNAuTafMr8BJ90EDm5nY5xazNHwk0IAaZuQwBS3AGoMNUVr9i85CUYah09V0QoHdYc0duUnaCLK ++cbrXKIhYxJRMQl+dA3PzObMoy88xFXeGOZif7aCgAaOFsuIFYbCXGVIIBbzMZwo0BSdaFtx4mCm +GCowxTLjSAW3JYGnRbPAIn5ItWAWAPx24KtgFlpeQDwvtjlFJ8pUnCSYKY6amhKZ0Pye5Sdo/P9i +GdGiGMGghe+iPtqmN4ZSTPCYpaEFs6Q0pEn8Cq3QDUMdKUEn+lKcmoZdzJEhR3E49OIGcJkgxpIx +oKJhcCyQRDwFJYsktqPpi2hul74eD1DyTkl80rGQfmlRl9q+DFDggq7vUd9MLFQydKOVrAQFncUj +SMyIA4y8TRyC5LyTMKUhITkJTlJIYAWUuK6MUqHlEGY7ZqIKQeuGLTg1TYExh89X0QoNdYcUgOU0 +on8vRmGEYrYV2qpP6i4m5wLqo+qyOzkzb8zxViqKqzm8DgNr/KsRfNE40jGYGfePOMD5AXPIGCcA +vENUG+jAdlHHNqGh9zT8MWZ5DKK9gxEhxMHB4oj2YkMggNEyUJXLfNO3qO34vtlE6H1CGXCYx4MM +TMd2AvRLJ7SpdCZiA6oQsBwXjYi5oC6HASMMfSI5lIobEycMTKCJTzkNFh2ah/gKwi3NtXAfBuPi +5gSKo57tmamBl98SqBDalwYrwmBJA+sLmc91CZ7tc47jeAw3CsBxKLc8j8C2FcYJfsIBDSmjSNvM +pzgtAi4EA09zaoLjsXGO4/g2B8OG6QLmGIoQDUIBWKC9AM3HBYRD3C2kOSDDwYGFnOODVACYeag3 +1/J8sBGgYQNLuQpCh8tIcbjaHBIw5IAWuAzf9XG2PvNdB2nYu7toHCHlW8U0h1uHLyCjTOyX0YIY +Kt8ibuCGwr/HgJ7EEaER3+uDw1vIxa0bC0Ws9WD34duBGDQL0fh84hE5C+Y7Dpoj7LyYwCagMEM0 +R+bBPBwYI+N04IEmDo00pyY4IAVN0IYNHNAAJ0ecwGqLtOPh+gWmHoYcixSHy2DoZsCxKUwDQ4PL +VWQj4JoSbamSFIeDxxzGjcX2Q+4ooe9wtTKwSU5ztTvCALnBjXFq6ShQG38J1xpwfAqaxsDggLWC +mQcuzBK0SG0W6DRxHVxf0hzuGhCOUBP4g0ftADfYGClChwlljetzAuNvRepGmlFbE6mD9V6Xn9Pn +5ozp6b32ZXQwaF/fRgPj8rH9n8hs93r9YXsY3cNvzMtB9DjsDyLz8ar/AznwFvXy6en13Q3jf+if +ohY= + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/originals/SVG_Right_overlays/Red_right.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/originals/SVG_Right_overlays/Red_right.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,1574 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + eJzsvWuTHMlxIPgL8j/0fZAZaXdoZcYzg7d2ZvVqLW/Bh3FIiTLZ2hg4Aw2xiwbmMBjqeL/+/B0e +WdVAAyhJJLc7Dd0N7yhPD48ID3+Fx9/9b7/+6tnu27d/ePks3s4309/93eHdyxfv37772Q1Bb37+ ++vWPP7x/h6Cf/OanN0u6naHR7ufr19LwH1++++HV2zc/oz/RH+/w0z/56sUfXr588+Jm98PrF/c/ +vfnJT+Evv331/vVL+NtvXn779btX3/3x/e0Pf/rup/pSwHJ88R7+vix/P4e/D/My38ztZ7ligxdv +/vTihx9e/X/45xLXCLD92x/ffPvqzXf7t/8vAm/mmxjgJ/zlv776zcsfNn++nec5uzbHt9/8eP/y +zftfv3v7zcsffji8ff323Q8/uzn8+cWbm1+8+A7+8uLmn1++fv323272r1988z8n6HT++u7V65fQ +v/sX728W6u3u50v4ev/jq9ff/vLH+z+8hJ7HUhEcvyaUv/sBcAFa/B3B9euf3wPkq5fv3wNt8ELk +2OEX//zfDsDmt/fUDoA38+1ys8DPn/x698vf/uqXJ3hduzkgr/53+iv8b75NeWgRluybhIIY8Idr +MrSI8PnbNuCIlRv85h/2njNEEjb8l9+8/O4VTQgYrv/+U+npu7ff37949z9/4GbA4hj4L799ef/9 +axhUHYR8s2T8pr9JK+AqtXgW13rzLJQIf46t3IRmbfp4vfzTq5f/9rObX75985IHZffu/Vc8M1Ka +Z/7Of/nNj69fvvvdm1fvgbKCoMaj8ou33758De3t83evX3z3g3Zy6d+5wW9fvPvu5XuYU29f//ie +Jvuqb4BRf/7izy9x6iz8gl99//LNb9/+I9H4rC63MQKbc+OfMCSxrDclwuiu9Io0Qy/nm9m9m0ae +0SMyRKXvwLXwa5g/v4Ll8+rNz4TC+vU/vHv1bZ9TNdys/I06cbu6f03/MbXQ8ffvX74R6mEuH37h +5uZ8+4uv4I2nN98e3t4j93/AdQcz4A1Mjtdvv+O/2e/0F/j4j98z9fT/r2Ggfv3u1RvEOf2S/rJ+ +/evXP8Kf/uHd2x+///mbf307/YSlzW/fvfgGmt386g//4+U370FqCKD/9tWPr96/vH3x6vuffhDR +r1+/ePPi3Q3B4cMMfP7qT/CXF0DKDX8M/tJhH0d6fPmvsPT7Zxl6evOnl6/ffv+yww3y4s23N//0 +4t33H0cNw/DOYaD/6s9H9PbF+z+ClHr55tsfjCz+79hRhn0c31ff4KR4d7N/9+MPf7z57du3rw3t ++CfDLmCCYvu/jHf8mj7w5ldvmEHnb5IG2zeBQPiLewu0fvgN8Me/ZOyHF69fv/ru3Yvv//jqm0sv +uPB3exP/7VMm1p/v//D29asf7vt8cpBfv3j3/tU3r19+9ecf3r+8/xA25Ma/vnrzLUxEEjqd2rf3 +36NucfPVH198/5Jwvv/jHbX8yhDmr0EwetH37NkHZGKIN/s37u//8O7Ft69A3IKutH/948ub38B/ +X7y+UfBPp8tgEPeA6NvpX6b/Ms34tcxxTnOeKzzr3ObdvJ+P82m+WxbQFuKSlryUpS5t2S375bAc +l1OYwxJCSKGECs8aWtiFfThM4RhO4S7OcYkB97JYYgVFrMVd3McDPMd4indpTkuK8GR4SqqppV3a +p0M6plO6y0BLXnLIMacp51zgqXnNLe/yPh/yKd+VuSwFNIACn4Y/l+n/0s70r8X+LRf/h6pjsO9R +/gFpxI4454m4gv/0e5F/SX4rwLECPNPvK/EP/zX32w7+7eH7bqIfB2LvAf4hk/k7MBvYjcTBF3Rm +RkUUmNh/+S/T3d3d6e54d7jb3+3uGjzrXb0rd/ku3cW7cLfczae70+l0PB1O+9Pu1E7rqZ7KKZ/S +KZ7CaYF3wcePp+PxeDjuj7vp2I7rsR7LMR/TMR7DcQGy7g6nw/FwOOwPu0M7rId6KId8SDB04bAA +6Xf70/64P+z3+92+7dd93Zd93qd93Idpv0D/7nan3XF32O13u13brbu6K7u8S7u4C7sFWHFHY3V3 +R93BDh2pU9gt7NjOOofdq9RF7CR2M1FXsbPYXegwPojkdJqo59j3A/UfOYA8aMQH5ATyArmRiSPI +E+QK8gWf2biD/IGvCZiEbAJGwdOIVyvxCzmGPEOupd6Z86/TI5/j9pnOQcKjxzz782e6ANydP9CZ +dPN3X+/fQZ8KflV6VniaPDCYZU8PzAvgAzL1rpLoqCAiQBhEelKFJQsf5q+1tqk2eHZ1X2FKIRNh +RO5WWjHrAg/IkBUExZpWWOkrvXOtK361FWbRClNtPdAQnHBqtHmCpQUiqYUWW2ogHIC82qB1a21H +D8zPBnMYx44mAswqWIQgxGAmBpiPEWZlgrmJnQLKaChx/dE6DPQsJAL5SSAKI4jCTL/h9wRiMdNT +6EEOFOwMCcsGP3cT/bLHl8L3vXw/0APrDb6fUJribA4kh+hdMeAXSFCQsPiALAQpCwIvrBMJ20YC +dxdgUYLEPcL3E3ynhQGyF6XvAtIXMaCYBUEKY4IGcSVpvELfG8hjksgPSBvkFi8f4h/yEfmJfG3E +ZRzPQnxPMAIRKMKuzjg4MERHGKwDDNkOm8Ig1olGNMP4RhrrBeTlHa5KmAkHmBU4Ag0mSoVJk2H6 +JCA1AENnWP44yY4w3fYwUg3QVJiaeQK5n2AHCMD5GeTDCVbkAfaHHZC04uSDXSPD/hKBeQuI7DtY +9EfYYvYw6C2t8IYCm08C/gQYyTmyXMI1TU+0J8hD43Wc+ZHFJvLmQMLiwF97enb0tAkZdyBmHGjm +47IBgZpJqCYSrChaA4lXfGYSsnckaFHUHkncosDFr91EcreR7EXpW3k1ggxGKZxIEoMshodm2n4m +kYxCGcXykUQzCmcUzyigG0uwC9LgwtMe+0zDf9dPeuqlZ7oILo988vnTZd2/2LS/+cAv/AT4V27y +fFtbrGA1AwIwfb/+fAT7H+DtaQbxGbBpSa3Gi1hKgImMJvkKS5vatHWGVacY621sS7yJ+bbl3Om6 +PmqiGJbWgs602wAq2Jouog2pzhnRFlASEzmRQF+CxoJ2uUV16wZUsU7ulfECrfujKdqqAV9Woe9e +fPvy5v3bm3/6I6rx0+b/MFSBlWakJIMIol9iBRX1XHwCSS0suY6/IJXjpEM8N4rnYmf54+MviMcm +0si/66GkYf5CdDOgq/nmevQZwk8Z2H949/LlG28VbQCEVewhE6LJhOi8EaEqPk2AOh03kVYRSMeY +SdeVDfTgts6+bcLGSdIXtmjcrGfYvnEb38PG3mC/z6QHLKAboJ6wg+0V1Y0I+skd7EBoSqAlEuaz +r60ldN6AZH6XoFkUbLDM7oKo1wEtkkHJRuviZHr2frAyQLOeRKVeBlPjSFsjfWcjrYm9lMWuQlMr +iiGmzyd8Pa6vZD2i/cgW5AF0BTQE7sSSZFvSrEnRfFfReDfaLuq7k1N2Eym7hZTdFVVd1HPprU47 +Zd20kVZ6IH2UddFAWmgmDXSFGbKDeXWAeXYHs26B+RdhJmYgoMJm33Dv34MqcATe34GisIDSEEGF +yEBdBQWD93JTABdSANEMx69kqiB1ldV0UgbRPG9kou/ITBfFkIx1eCYc1kiGV6LxSqT6smaKOL3Z +4Dqyk2WCC+ZIi+eOujVL1wK9iRdb5rmxkqV8JM9DJLV6JY35CNMxkB5cxdOgbgbsHRthNC35C6Yq +T1uawItMZ1KOyYakcacHNYsLroP+xfORHQSRep/N8gdq6cOkk7JWWtBXQWopK6YLtiTllNVTVFBZ +RQUllT78QVu5i44uOBLr2jzUO9Lk8VlFu68yvDjQPOT8hROBJwX0w4+YsJEYKZbCKpNhP/hrcMST +eWxAkSevzei3gTGbyHEToV0mLZxXXl9145rr642tTLYvB9tyItMy2GrrhiWvtt3WqhS7kq1KtinV +qsSPrBMZlWpWHsisJCcBmpX0sF0ZiLPJrMtCq7iKlYmrmS3N/XRmaurDJucsZicbnmx6svHJBqh/ +iAOT/Pjg1PzMr79VhIv9XMyxt/DeMpFfL4p/j+Sj2376b8W2pUpbVJGFXt3/ybU3sd+CxofWRJHV +sHcrAZdBdq5L23Sc87LINsOTHqY8THeY87y1JNlSmk3vE03rYFOaXSQ4k9HWPsoM1rkr+85EE3Zn +M/Qkc5I3n2ybz042nyNJ6zuyHoNIaN6CKkzzHZqge7JIaRuCjWgh6zWSNVvIxl3J6t2RIYxfJzSW +yXBeyJTGbSWTGw3X7DodV/Kw7UVXOIIov0OXHOkSgR502SH7SCqQO4/XLG0spIzs1Rg/HXkzOHrX +Bpj2e3PkqQsviXm/iEF/EiOenZ/q/ixiq0ex0dkJeprMMN+JPV7FG5pH9XGjOu5E2LO474pjmFjq +o95IvpejSP/R61I2XpfR73IiF9mB3GW7ydwvK0wU9r9kmjrRvDALzmSyptkXc6SpthePzI7k3Up+ +mQo2D6k52Rw0kZw0gRw1i6wS3llP4rQ5kuOGH/FUlJ09bWKpyvqoOXOdL3c/+HLVk9t9uerJ7b7c +WX250/Fk7lz15XZvbjNvbvfnZuf5GTw+7O2ZnLPngqvngp/n3NMz+HomdPYM7h7v8HFOH3qa8/uo +70e9Pzzr8mi/RHMFBecQWtSmMbtGn9PwEKcm+YHj84lBAQsLPBQVmLaBAVF3tgqPqTw0yU/iXGTX +os5s8itONKkXm85Hm8hNJzDN3KiuRXEuHs25qO7Fyorc5DS5cz1uJ67GlVyN6GxkdyM6HMnlSE5H +djseaQbsJ/I+sv8RPZDogyykUiXyREbyRgZSttg0QrWbJzjPS55EOrg71gAHx70JhXkQCgcVCo5v +1Xyy6UweGPsmEQIqBvz617U/D25az0tx1npGThf46LmYxGkbyLXuebgX520bmJem7sU1jjGv9qYg +r6IaZ1OJWSFGm/tus08cZKdYh13i8cGxTWhsokUwfyw0Ju72Pvu7wt/n/oHFug6eutPVmT7Od57t +IptpfHBsdiRyVxuVUMIkLvQ+Is2NBo8FO9BPNAo6hW3yjgwkfXzPCotFeZZNfKea6jIq4XeigKvy +DaRMonerxt0VGa/KhE08Z3VmqDNBcSAmsz9Vt2HtZiX5uiOZeyA5fBJLezYlh+3tbIoOqjq7yXQd +3Btwj1Btp+s7iTYY03lE5UHpCu9hActKEz97U54OgvZo0YY7U6f0JfqiYFELjE3KO/W9+u4qocxV +NkKmYicbJCthqogdZRM98Y56J3qZ6mZdPwuyDSd5sjzFaWxda1vZPJrox25Q4pwaZ0//sqApG/is +gUfRwatp4YeNHp4GTXyvpqjTxHPXxSdRxo8S21RtPJs+vrPpffegRr6XKU2hyo1KPriCLjmDRneQ +auTqEoqT8wqtMmV1wrJjaDGNPDudXCfWwW8YErJ02R2S37FI/LFQhsdqIccje18Gxw== + + + QSLHAbkOJsn22NNEPInfSP0H3YPAo6U+hCONWM/+WMyN4HJAqnjx9uZP8B6FYF68bMO5DlFr9isc +J3XjSdB6kY1MvXnqY/Behibx652TbiLf6t3kAtkazO6uhzGkrc8qwW31ROzWfX+mVXRJWam6bIZA +mTgrustiMcdFf8Q9NNG3QUxTBk8E2V6IXMrfcV41Td1RN9CduP7YCaRLrS+0MJnbpzxuncGAHG0k +cAy8HxV9qMLocQvpGwh+DetMup/EW9OzAdg9c5zcSntou9i7FSfbhXkqs9nBsuwm2Sxko7iwVehm +4bcLtw79joEifRq2Dd04kts8CtkrWxG+s2c/ivFJHO9u3J0HfycefPPhiz11yYm/H+znaikwcRL1 +SC2l02BGd0O6ijmkpnQ3pjXULRbPZAb1aFJraPs8rL0JaYtxreZ1niww40IzH0hv8AkOxUdr1OSe +2OYeVGy1vL2ivZP1rep2FSmQzRBnU1xMF9XAFxEns0W6dfs82nOwZz88LKF2E30js9rH1MdweM+o +0qwqzaySsI8FflzoZ3J5Vgfbs3UPby7nqlvr1dSA7DKwxHafzHwPLiFrUT3DpUCdnEV/NLu+2/Zi +30+yFJo9qz2dg8We7J50IQEEZnhwz+KeuT+bNKzT8BzHZzqcf+3Pnt0DTzt/SHfkMMh5zp9l/D2Q +8PdBq2YSD8XHDfytdTPaN2bjT+bX0qWmZk4asoi6J0tN1q25urDdM7ksor15rKozVeNgpnqTf2/m +ULX4TZouBHA4v8iHcCSIY7lG6gDwLgBxAkxiw55kbpEvQKxZtmfZIcBWrVq2bFtlcw+k7iSYxrAb +JhMADWDX+jj6WsKyekCqa6JfYOsMdKoncAYFB/5DuEUdaEwouC5aSiqoywwNsNmccqN0k9Ia5QKQ +aY5HjlKeG74kw8gETAFYGLelKLR4G2AmdEKvilVyXALMTEQQGuBCjKHNSx76viy1IKQoEwJ2vef5 +3JRwG2Ge+BSXa6IlSpcVcA4IQimAYhi2DH1FdjRCTud8GFtst7it3cSECUCO0uuiJUq/fDqlcksp +QgsyJ4VrztQtak6BWWsc86aWsKaBK438SfhLDTnRiM7IFmVEvYU3YNrS0lwmzHXxfkpCzPNXb17S +sSfLiNlCerbT5ogARsP4gMDBDgjg8YA6GJB3cjwgUsi+9OMBaDhOPW6/sTBOYl/ETUjtkjHvgmpT +Pol9sbUuDmcmvNoW5ya8809Nlnzctpb84Jrqdob3Te3bWcbxdNHiUJuj50ocuq3vMiXOciXQz68u +KzVF2HG1k4CBc16ZTdKtErVMkkQnymFF/YHdVycJ0rHDqpCFsRMHlUyFIJMhaxaETAg+MzLLqZF+ +bmQlu9R5F3SCTJLinMXF4GaJO0OShlMk26yE4L0/k9mkj3L/XDRMV5fzQ56Ck3kKgsv2qWe5ByfL +Pej57OoUsuk0bd2dblaFTbbBNpt9yGXXpILJJbPnjTXr7dmT8yAFZ81uPZ/HiSK6EeYF2qtopx7J +2RhoQtRj+9hUGCfD7A4R9emgafBHmQzzNAiMcTJ0b9PiElWK+ptsSgyTYnrAJzhOi+3E2G+i9D0x +LE8X8lRGEbNsUlSGhLCt02idp63csZniRc/lyXJxukwuK+Xs7MPgJ++TZXR8OE85uj0wcoFzBGcH +CpWTBPuTTI72t5Og0nMPwwPZXtVOc9E5rvMZzulq54fkorlQJXGNJrJufzh9DxP51xYSZbjvsQy7 +g2kaaa/D/KkjTMkFpiIm0DZ1ncGcizDXVphfh3qCyRRhElUMER3WE1AbYW5UmA4HmAALDHuhPI8j +SIIAEqDSuJ5gewg0ojtM1XBLfQXJfziewAoPE6ycQukWB/TC3y2USldgRu7QcXVnp7r8EbXPOaA2 +GKvTNY+noZk6ffx42oeS7swwtfjzdDEOp0dafBzOH2c5O8zST7JMF46yfOJBFgp/cvCzxXWyuGe0 +iOeJjgxxnvFKJ4syTFLKNqazSCfKON5TzvFKh5r40BMeiILldEfnFg+UgtzTeRPlVy2aXfw0FZ6m +wtNUeJoKbio4d9Va5pl8C6CdldbIJm85SS0Ssj8vnW/5tI/JGZZPO5n1Jae6PvFkyldv//U91w26 ++cdX3715+Z4OHl2C9jP7yoNJeTApD6ZlmukRNj++5SMHBM/JlPUWtM50U+MtKLbhk0bm0udpiB7z +2duSl5CwNk5c8APxZl1vawzt00h4GM3jKWn582bm+MlPmSi/e/Pmxf3Lb2++E9ANrDiYKRfBNB3F +d7OpvnDRZr7oYnnAZJ7O7OVqZ2T8afBlkzMxZk24vInJQrrFpU44l4sL63aXSzWz+CwVaOtqyWe5 +QEN4V9wsZBQ/bMz42hHn9SKi/NNiEb1oRMEaEt16qFYNgo3kHXl4DmRK9HIQXAyC/sE77+QwOp6H +wX9hApEb7AS6nj3nc+d46rzyuXOyQ3Ykrvsh85MdMA9yyBzE+0SnywudrdE8D8702JP9zUfLMb8H +9gg6PqJnivIDR8evsSX7HXm6xpbsd+TpGluy35Gnz9+S+9mlbeGKbdmKbdGKbckKV69iGhKcXbmK +IbV5tuhfz2neD0F7DduXyUXuXex+iN73Y+q7swD+NoRPtULOD6d/JI7PifKsU45FLC6dNT8/JJ43 +ke8e+47TJvztQuBnQXDNTz9ejIRLLHxywfAeDj8PiPeQ+BAUd0ntMt7TGBZ3gfHTxwLjo+oFS7+t ++UNKDWxiSyvzyrEpkDf4C4ZO0kUt6VoIOerWQH4liuOt83IZWYA1TqfEi/4iYajLSuP1UH7Znh3W +i3s2gP2ezWNLevTeNoudpHlRUoicRVLX1KWjtKEfgpqcb+uTTtb6r0t7I/t+OSJE8SDaqJIrFcWR +IC0T1SR5EB255P2aSDXZS+QnUDmoXgwKFBJSR3q8Z0deMHbN2vEposw8k9GSrfoRJJ9kdbK82WVI +zu3puaSfTBL22FkilebB3rnkV0161YRXn+i6ntqYdfVJ1YEulf/ZFAKaPqX+z0NFf1iUfqYZfsEK +pw1/+vIdX6qSuKTzgyX/r7aT6l6qu6mauGrkctZ/MTs3TmzqmrGr5q4avGryqtGrZq8avmT6bgqH +5DK34CVJTTlwfF8tRNT7UephCsIC2kW5bGt+KabR2oUVtWaSs8uCZTt8XJmre7gCGjOBHqwpcS2U +XyY+40XpGcd6dk199MMjh53c7/45DI/P6TpO439FPXfPuMjt+GUcklAvHfsfD/6Phsmdxn0nO/9f +Lh9P8K8nKXOh0s2Z0vMJzzRqSecPrdNRu/4E5fpzvV0+ff1pv3zaL5/2y7+a/TJmkBB+68iwwH3e +Fm0nXNAJ/sgpUBf3yy/FxPvll+26cQHQWq+2iyu+v/W9PF3ezFMcTSH8eko9e0o9e0o9e0o9e0o9 +e0o9e0o9e0o9e0o9e0oyeco3epoKT1PhaSp8VuoZ7rmflNS1oE3cviArTBA8NsNIDyPm2xmPfX1G +8pt+9AuN9HbZSG/OSHceO1KRVT0m3cIM6+hqRnSjWjVhLhch+q+ZRaT1qkHtdV3WcseUoruhPIQv +wuKKIk6Pr8T716tdcp5SkO9sJsH3jXP1Q9eAnJfz/2iN/umBWvyPiUGcBxVAHvR0jG1SxllyBl/b +8DFP6ycK6ekBX+tni+jpoVykcxHNGUEfKs4RLPvnJB3/QHkOZsI0nPU/WqbPeXGOONS5vLPUnp7Y +syqHiuX0fLDW5QPiFzhTlnJRjEpuCEi6iideKW1kyaV9OEn3CxGOPtdS5oX9uGscHbp20jnRkWzz +k37E4/qFCL9MlOfL/lYA402cT/7WJ3/rk7/1yd/65G998rc++Vuf/K1P/tYnz8qTk+1pKjxNhaep +8GX+Vrt1Y90Mow4iDuGlWxIePGQ0DbcijDdhjieNxpsw/TVuw1Gj6eJZo+TKFi6uXKi/k0OrF+qd +HFIidHLV9/1UGUsYRl/CcJgxOmdsxkwPThk+iMazRefKh2aKzJNJJkqfJpz4N15D1+fHdnaMcwNm +xoQTg2aFzok+IyiHlp10DVYzToIgyY+4hnEFZxjuBYZYS+e3s3Nj5mFy/qX9JGt4vEwlXyz2OhZ6 +3V2+UWWSZf7Q7Qnnozjcm+BuUeG6rLvpoUttN9fa6rheOmQ4SIPpQXGAw/xxcbCzJE+RB9NHBIIX +CV4ojGJBBAPOgOmCYHCiQaaCiG5c84GG/kTLGgceh5wuTLhw36IvKzqM83RxmPsiHS/O6aP84C0Z +kw21vzjHLVp3ffG29CiPdy8+SmM+bWT/9oqM8ZKMZbhtZH+2FcDoT274H7MfuB3B3YXh7sGYNlm+ +F3aGYW8Ydwe3P/BEwMMTBzl18aGpACoDKgw7GIRCisJCSsIBRn+FFZJAMZhBKTiA0F6d/DjB9rGj +KRTgLSeaPBUkRcAd/ghzZQX+RrpW4wDToMLARyADr9DYwRBlGMmFbszYwXhlYMhiZxIaDEiGgVjo +Soz9RLdhZFhvCzCb1xmKUmTwAsxFxiJbVYIiM/UaT+Zgl53Eu8lYx/d5DkxzPGubwwvnBxbkjMLf +gF2u7oXuZ/qQwzFt/EvduzS4lqZHOho/4GYc/dLT510ocdE/TZ7F6QPXSTxwmcSHLxWdPnCr6HiJ +hLtX9EPXik5ycYS4jMk/6J3GVd3Gcujjjg57BDrmkel4x0pXfOzpQo/T6W6iazn5Ks5MV3Cu6DtH +7zXeLiLuhaep8DQVnqbC01TwU+Gzyke1+XaZ2+dl0chHP6+MVJlvU2zlC9KGFMMn5g19VrmsLw0w +l8u1Dcr6oXpE53HgzbUy5Bf/wNKaPrK2/Ora3uHkF5hFhicXorlckejiDWWbCN7eVt5p0sCwC8eM +ceHzqPBYmWgTE54smNdvolktJqyHgw8fC9csw29a3Ggsc8T/C/1/k/wa7bvGTSKpp4VrHonCWuge +XY6n8G+rlEEqdC6X7tHdbWoibasinawuktRDospIWhWJv/dySGmSakiVrlHZSS0kDUFyNSSJS9PF +4FoPKUpFpCjFkNDqQd19N1EsZ0d1kPZkHHF4cpY6SIluSnqqhHSFSkiDffpoB4W4Jy6XUfqMW2Nd +HZ3D1CsqWW7V9s7Y8xtj57PCSlZaadrcFdtvivXllQbf56bE0lhkaTed1VkaKy1d9n/K5a5DuSVx +pE3OC+pqLm09apdqMH2sDtNDtZiyLzYwZAF+qCaTq8p0uS4TzITpQnGmflXR5fpMvULThRpN01Cm +yRdqunSB0eIrRVy4xgie6ULJJn+bkcy9v6YCTiA15rVStaUa0noR2cLJd/NtCZLytubU5vBADt31 +UH6ZkrOWi0oOgB99YQaXfFAb5ZKFQgkxDyXeaF6CGj+XTKDBCHoIUTFLitFtE7oQ1WBPnVVn+Fic +76NRvscGDD8aMnwI0cdij2eoxmUGOxtfKLPMoAzQdUHzXGobVgUlClFeqUw6vmLm8g== + + + PL4axr/0wrZnayRczD8NcVg4H8utvFja86HUShjjadCiRz16vMhxTKjcplRaQuU03P9b7Aq+daie +MtrDYA1zjZzz/K+6STzdGhhbE2MwMqZt1pfjkefVo5MFJ5ctWAbu7MQTwNlDaUwXpM65ZMle7nVM +mTxayuRDSZNVLkTdYfSlZ8Nt8+EuJ06OhtcZS6YhJbfuttdDY5rUQp0v0mWcBNw5l9m8vSFVU5r5 +dtRAKV2Vzrgc5XwLn27B5OUTVeFJpUzQXTnRAqZRpLMsDfh0Is4k4MVK51buoLNktkOnjtCRANRX +oHlPGXuYrrcSnXcTJXEWYBcncC49gRMm8vF4B7ItgpyrwJQ9SEC8OzncJR65T9LuP67cTx/U7je6 +/WNU++lj2QiXkxGoc9ftGuYcP9y1C6bLx7s3fTzZ4lL3eOQ+0TL7WAenT7XMPta96TG5JOfd2zj6 +8I24QYKq0kqiejq1BS6ikwNV+1HNdA7QLdpMN5fljYW6r4WRL7RrcSEkoFaBnMBDHBl2d9rbSde6 +IScelxRNiA0bA3+XWC/uzNdC+GXb9UVv3rZQ6ajnrmd6bqTiZqg9nvvit6nfpzhP5oW/VLX8QR+h +K3rm/INe7/W6r48h+DiCV6T9sYauA8PUnVxowXVp6JbPavdxBh9roHiD99AtkoYczYlWxXJos8+z +lxKEUhd8kbrgyWIfZRJ1vVoN8L1Lvz85j1egf8kozo7mRst5/8kq/6ek9tXpmol93gTwNHoqPZ2e +Uk+rp/bOnyr05wod1QPdnnJPO1HfKVQujjRuqNzQub9wFpCuTj4/Cri3jLvV3FR2DHBzRXenGaj+ +wlPSX2xdzLcRVCG2j1qBRYC/lJbHIm8FT8utJLXRuseIBpUruyzsr4bxi8RpDJfEKUC/8J7Nk5M7 +Z4eqJhfUrFI50gc0RZx+6Wmv3dkBnwX1mocO+Azh1sccL9pS4EO9ZXPejCiYzgSc0qBU8NnE6wm3 +C5UeHync/jNzph/z7k9++3RJSJ6/f+PPRNOR67PDoNFqBbNuGaso6pXNVe/C/eC6vx7Kzwz+4qXH +OXxJ8FcwfJngueh2iWOVxUcl+lKa76OyfB+VLPqA1XYhPfAxCYdnmXMPofOhucckJ1BqwqOSVP6S +0XmfJkrCRO7y3Ogmb+RgGA7Ni9/8/Bd/g1G7XZfhWvOrY/7EhTd/6Oz9p3z6ixZcuhghSBcCBPrV +K08HS+7kNM/sXPVFEkE5IbRS/HxV86BH0Xt9cwkdboqW31nsnLfSRe4WWiiKrp7/OJHhE2WRFVlu +xWLrfNvQKrF1tTE4wn6gxcq7scbaT5OG77if/LIQpGgwf0U5Ic5PJknEgXi+mYjvJuJ9fJ3EVpH/ +0ne9tqjRxUV6gRFv+GyBHeSM8fid/jZZk6P72Z/TheeOvB9DoBLHzWs1cdDljoMup6bx0ep+R+ny +Kn1gdYmUpekjZrFe5HUkz+MD5RNcLlqaLF1mm4gWySepaTLb+jrxofo6kyWg5YsVdtgZfSH77IHc +s90krvg7OYocNPlMcs8OUqO8+9o/kn02nclQTUBTSaqyVKUpy1OWqDsy2Q4kV49+jFV3TXZ+eLXA +WrN0lqMlriyDHp0tX6VNsphMlZW1okq+JqfoLV07p1WfJCvFH5vPmm+1kutOJ043Aj6c16i+FZ1K +8G+6kIS1zXAcc7C2NTl0Yknu1USpVz23kecVuv5P5P8ONKFwOu1oKvFECjKR+N6EI8UvAk2fOonz +vp90xmoXetK5yDnnO5JK6BPnY8536A+H0W4wwkctOP+3c+L93x3h8sBDE3iS3U1dXOroSmf727iv +XdrQDnopx7ifLW4P8/FrXmB+81rFZGSzcadG0N3mKoHxZgCf2zJmtYzZLFLQahoyWIa8lU2+ir9B +bExPGdJSpiEfZbwtbEw/GdJOhnSTIctkGtNLKLWJPUZjghMbcprmpIlOUTbFpac7TZLxdCcJN0eX +98RuJr1YjpOf2OU0pkDpMVBKhJqGXCjNh1p0FsjInFxe1FHe0g+HygHRp4PJf/sHk6+WS3LZmTGO +8meP8+TyOb98pGGsp8dVlPvAWG9Ge/qs2OEHxnt6dPTwoyO+sWTXOi8YDGsNNpNA12rAThBXcu2I +Q2eWHJoFI3oPZuV8Kaa/umycy4U9sa6nWanOU2K7vG7hvVBOcaruzuzNE11tNNtezDuxJWZPm5xs +ycYmFUGzsBNZQnolbaXbkFax7XZmnokRNlk2diTNl3Rfmmus+nItsR0F6Y9kOZ1IxZ/JfkIFGFXg +RDfkFCzKM1ESB+rCO5rfR6kyxicSsP9BnkRVe1ApRrUYFeOVVguXl1L1mO5NnklL5kpTXGcKTyxk +OvrLhaZ8qakDVyOzemSLnGHgNJs8UabNOuTZcKYNLvvzPBvKtBkN02iudh47NU4XGrMPn6TKvcrR +dPEM1UqJMbtLAYft6Sk54xGFk3Uye/WArHOWhbctDg+cndKDU8Md04myakar9Wh3S6vZiqz8SFlY +zp2ahnNT3nLV29mOw6mpQJndhTJ0zpPEwHSdBst1lYu0Lrv/2Hj9+HVZj7s468HrtKaP3Kl18Y6t +Dz3n92996N6tR9zGNV0oXfuYYrYPPtOD1W4/9tTLz/TQHx6olkvPaJEoa7X3Sp+iUKtDzY3FYsdq +Zlgi/CdeLf3w5dJoK0yPuVz68ddLH/J04XrpK1ww/ZlXTMthB19A5G66UFzCl5fYFpigEhNPtsff +ku3xQIZEBg5EDHQ0DJGNpX1LqpR2kFWRxFK/qT6gil4P5V+dTlouRk4AerHWPCk0vKHvzF14+RC0 +5ANf2MzVA32kVPFHHoHWOzPrsJn7nG86BT05R3R3RdOGLlv64m7DzOKVlq3dPNN8OPqEwnxiXxen +fvbqs90tr8nUmlvO3BkPsO4to/rOH2TlukeJ1nSh1d1one9oxR822eWRMpFROhTKR97cXovydqJk +anHJSko1+2UPklXfWVlJL9pxRUrx1LKvFr21e75FdGKH7f/aLlneTD5WYf/Dd/2eX+B74bjdhyvv +XziK55/pQb3yoa/jA4/4EuUUH/X+U862Pmbf+bQU8UfsOtP18qflYKvUDKJ1v9Lhil5ZKlyoJnZw +paWqdOe8tBR1ayIjC3vGeyr3zypMUR+5l73G2PZaWe6uXCw7YZ83Faf83bLc+6HulPDgJFHXzfWy +EweCH9x4seQSpj+3VNd2eZfEQv+YjpC48v8H97ovRDhuug16SZmGK55akUQI3rGb7tx4syolTfAV +AB/RCr4U4xdt0PXS/ly/NIXx6f6Ap/sDnu4PeLo/4On+gKf7Az5bMf6PRfh0f8DT/QFPTrGnovFP +U+FpKjxNhX//+1ofX8RwPOf9SR/7q/OXt4tnCtvmTOHJGL23Ins7ya5cN+Wli/12qdQ0/ZyG7M7P +1bEuaIJBjj6jy4AcBlIoCY0AVpM0R54VpEZZIEfS9Ek9muSEI7sG0NLLUouDs+JP7ph4pSSNvWUu +W94yUWaqa7QqL766i3r7NfN8liC+ev41C53d/xWPArJdvKP46UHC+icJ7c8WC+jRAA30F0n7/Hiw +/yPB/I/F7c9j84+J0W9C7Sy/P1NOXxDTJKSnL6+ZuGPTY1Mpf3RiZpN/KgFVBh4G/2UxQRinwX15 +PEtjU5moUnF7iQLJxgf8mjCD10xnopal5aEwW+MjinZHKPyJQB9zHX4xShaQuczj3aXwgdCKF3J4 +kgtLxMEvWJMilMvi8ksxfZnwvFjfoo31LawgqAocdjHc6ZEc52vyfqbxQMWmTPTWw3SpRPTolnyg +RDT6CibzKW19k+ZJGuXGhVJR24q0HM7bXahFu0h4tNfPKpOVh9o5P+IYK03u1A5HTHeUBWJRU5Gi +JD8nSiPJFPvjVKhmyVASPx179EUS5tKh6Asy5hES5mE1cPq4Hqj3Pe83if9jydJt0dJLiTqnbYb/ +WLh03eT1pyFpZ5u2sylfOrkc/na4WMCUY1R7mpV6jVGPVm3jVazGPnwZisSsJg1aDTei9DtRWMHd +xq0uRa5Y4ZU6Ryj3veRn3VeiV5tM4zgvQygIlJIwHiXX6EvTIpRpDSAeLkq+66Dj4kOooA2yfK3L +Jl0EOgji/Madcg8YuHpow7geyg8JaAB8/cu3b3797tWb96/efPfsmZPb/g/TL7/Hv0T+y69fvH// +8t0bEOhf/T8/vnj38oeb3ZvvXr/8FmT5BnCzLLcp1VV+xptSbjGiJz8jdPVH7K7ZAr//M/33/4Zf +/wcA/+0m3fzi5l/++3zzLcF//xv4scV572CC9+Y5wDbvGmD62ecX8CHsDb3uVzQUYDmBfkE56LUS +m9O8wo6D22EttC3OPC+wgqtUrIqcC/T7F/gCeCnWdc23YGgmpldA/JNeSX9tFyDysefnmBD0r/Av +rFjAErbMFVSGWukNCovtdmlrGD5+CaaffX4Bn76HPgecytBRkKL0HoWV5TY2sPP85y/B9LPPL+DT +9yhN+nnPsRpuU6uLMKjNc7sE8m/eYtO30MdK8cOiIDcI/KkLEDcGG0z6AupWTfrZewfynFUuXIL5 +2TBi05cQNTBLdEzvHYw/0oaPX4L5+bDFN3BrMyYK8wOgn78E8yOwxafvAUEXYFvAZZbnCts1xtAj +CDaW1QnpxepBkgUgBddAevMvtODmm99w9ZEAy5MLydU0lkDoYhWVblbIYV+k4ycrruab3++45vHN +v/mZ2ufKpWG7tJgurNkNNgT9gaV+zVyYtpNXwjJUSUpchha9KEQm9JLNBer5dn7dPzDyw2rcwDzx +l+Yrkwq7/EK170LE8MdF3sp25CwakI5AP9M6zFKRJpdmj3LrEsxLji2+TmsFZT/S/lgXnlrQLhdi +dMM4JwpsTdjIbOJQJQ3cVQcR7pbyJWGKha42MldAbtVekP1/uNLE3wpjP08rDGEStpgwvQDzC/KS +cL/q8NMmCrKzD/4gai+IQQXJ556fYbrmsG/2A79F+DG+JEcviOsLuwsTmhJYkWMttJTXNmqnWgJz +Va5K3hMTigPpKLh3MF4X6VwSb2Ce+i0+pXWrVXhNw+MU1eUCyGO8pKPgW343nVjdBP1UlM3P0ldX +/sv+3Y8//FHxmLshzD+d5psd/Pv9v00/wjNooZd1UNJAnyXQzW/zDUjqhJU/F+DCM1AJ11uM5Dvw +8xEcyi1eTEhgxXAJ1j/+ZkIdFCfyvNDYVzwWhpMULLKVhH8tYCbQgUjcvRBiBfgXnccONRoWORDB +ocF0XHNCcLydA3wGgGu+BdtPyIiw5AFW422d5+pI+wY/X5AemIAExoZLgw+35hv+GRqCoQU4geze +cKnbhn/ChnMGjCH5l8PyxJ25DFR6XkuPDtPQFvcrwHszIEVmN1DTBwJ0BL4ZKQVwLtC5oVfa9s9j +93tbxyptix1zXO00OP53arcDdZj+dfrd1G5+8tOb3/8T/EaTGlbBMKU/NtMJegPgmw== + + + MEz5R0/4FdSn23UFzWQNc8HyvDTn13mNKCaaAz/fgMNtqXklsEfyANiQXGvmE/ZSQIIC9gQbQU5E ++QKTiyAxgXrFzdK6JAZm2FFvRsqg5bpWnGYMjtw9RAlmOgPRDGcgXil6c/HlOKDIIWhTlIaUliT8 +zLforEYw/DbDDoXAwpOS28ZYCFhv8bg0A9sCa+FACGAmoU+AwTks2jYmeVmeww03XHDfJliZgXD+ +fIMdcV6ZgIUm6jq35RZ4H7jtygybYfZmaKC8SSsjwEkdkxAbSik8IwAM1NaBO7AHw4Jehb25hijA +uCxKLKbOMl4ER2VYbFnahjAL1jQXRRDWojxH5dYQ5GoDnIO0hY03KoJVgWDyKwVrks+nW4zESVM0 +GQTYmQBzXoALugWYgHkOhgBWv3ARlK4qnMF5U5pwHP5LKPJtCrPMsBQyc7wABdqxmrN2DMDYdR7J +FhVBS1mBKWUFNiWsdwwWnc38VgP3Yb0NS5F5BKKWkcLkCDo5QGDJ5xvM7CK0tiQ8bKgYyvsrTnz5 +vEwuXBerfR4zpnTKLvr50vjz8KoQsgAbMp6BdV14Oc604AVBXSvOeQSmxiOTYZHHVYBrKlV4vYZi +CGBG6hAsjaXYMi/wkiivS0FQLKh+Ru0tcRuBac5CbYQFK3gX3BdkNc/r3PGWdRYqqOweAzHzSxhe +KgPDLcbrtcMlCF4ApyR9W2DxCt4AHU1Cb8htFRQJx4RR5FgFWGLUVR6ioS3j2xgtrFLcpjrTGBhN +BJLMFiCo2kIASzsGw2Yg5M7LWoSENusAL3kNgmBJfSST9helgw4EyAZuC9M+5aaTUXpbQYpH7UIu +OhCw26eiUyzUKm0rlnFnjqNwF+BadY0Vh6BFFTRrZAJW6O0qTbFkpwBBc9c3tVl7AGDosoBXmTXr +LTAuniFAY0mAoLwYAiKRl85K4g+BoO4sOg8CD0JjmdO5zQgajqIOGG8iBEy6dFfYam+spVBQ4b+G +IEbbcAqAGVhyrcpYA5K/lSkwFgB0DrZwZMAbclPZtShRa9JNd110Fi0zT3XG2ngWAbDLSRKJDCxt +VWbjZqQIMtClbXlyL7DGk+02geQUtgRTsAhfY6GZseAmGFT4YVj2oAj0VYm2SwLloJOlGqzLbt2U +EBxb0ZUcWcQAsPX1wrIPXg3sX5ujiREE9DTr4lxYbUFg0PWC8Zqbf5a2aAfrTiN4YcmFZBN2FRgI +ZF1vKGn4XRG1MF1xxT6fkRl+90Fg30FrWaohaHPUNY8naBAIHwvBFBlSeRAYa5VXgTEgnwdkUQkA +VZvfBb+2sGVhhsFcoxOFjACQlaYLBgU9A0ll5+GaSxFgmof9SxGUsEpvc2qiweLrWhYUZPDKy9BG +EQ1rMbzVNJZFFwfiXXTKyn4PKpdp0aYeIXCB+aPqkbG2gNxRRRMzlKVtnZPJB2FthSHVKRdseaNP +Iq466UpJ0hZP6ChrWFNGBEE1MQy7CwKQnMl2tbTK7gFgkFsKLllRqK6Mwr9EATbbZwL6OhRvq0kW +Y8Ta8QgENbfotMdyyAIEabjqvhqUtytWFsqOMAbWpKzJMmAgY+dVt6+lrvZ5WMTKmVr0831rX1JQ +qmq0DbSPTUMpqOsGmH8jQNjbFcGswLBWA5ZsCPoUFzcsg1NdalfHGLaGJTomMrAEHfKEm7WizfOS +N0MDbauqBjDMSYAJth9VppbVEJRF5UQW3QKALS4CLLAgERiwALjuVJhgwQgCnpmfkyJgmR7IkCtK +Fu8pAWNsqvKQHq8IUmrCAlFzEbhGVeeqdCEstyEpv1fUNxkBgDPzAFZb4HUDQDBYpLs5sphAYAz6 +qqjrBsCYySaErY27ENxeISo1AnNSmQa2q4wCgFPVzSavLIGxrZhx2bRBBC66EvCGKkNAigp3Fx3f +AkQbmLECjwQIYlkpAAFrCFrMOg9EHw3RlGr0XeQswNBSUs6qcgLguOrCI9YLMOoKKaLgIdamK6Qk +VcABDL8LAuoMApMT1mS3MLCrPLBDiPBBsCgXQAHrdyGjA3rhoV2iAWMNCgzKgew2TAnJMDhFlRy0 +jTGwJjVCGotEhBX9fA2GtpjJqD2CTUul1spiL+CS1glUTV0KqGurEkBzgYG5NaF+LjLdca/TZVxN +biJNJmONePjYUhSBqOIADFk16RWNWKV+WVVqiNVPCLL2PolyQwhssplqhK6uRQfF5mCB5Vt0Bqh4 +KKafZ9ZuFcEaVCBXVLufKzjy4kDTl5W+gNta9Vxg4CwrpnRNFKEoa/o6YmAGi0YmhtgYAKSIEyNN +ZTEEyRTcpF4vBNM2z+Aqs7jyoI7DUJ2UXlFoKF7is6x64Q1uoDa12cVAwJqst7pVIRhtdeoECVwE +gimf+uScqwB1xclMYgSr2UQ4uUUUwPaTmspIsbQAmGzF1aoqWmjOhmzzqgjw8kx9WSWGx5lNli4j +CUGkSzmVgsjUxtkcRbbmELboTFyDGrH4+aZbSkFZw8BgCw8dagKkmJYMggp0BBd1cqwLrzEA1hy9 +7GYgedhko9KFF9FD0HRXxKUtwCXpKEaeswiM2rJh1X5FEIttq7yvA0xdjjCyJXMPAtX2d7sEfz6A +2NHPq0ILCGrWHYWGiIEN931502Kfx9OKooWInQDAFBS4FqEKdhlxtSHSFA0B5pA5KfNcwGCB6u7B +W22EHSVGnbGRXakRdwn1DdBHGC26AHVHabJPAbDrNqSNMjCLsVsw1CfLI6LrMZWRAFSdgkzuwI4q +BKq57jdKBDfrbquKoJoOU8RYBCDmzukk0m0qoqiOShf6NgVrUWmCGaVGgeqnKMwdBYtNenZEINa5 +qrYhRjgCF6UVT5oagjrrnFWnR0T5bgJR5A52oarWmotqXBEIX1W5ikmoLRzHY+FZlyZA9WTgPqjq +OILnaMsuKwKYUkqBOCIASJayTIOoPADx3WRXZVnxXMBJ9M7CXg0GhlVdYlU89Qg0dZq2TsWbzNDI +srnGygMtGiprcrHSDTVuzjEC9L2bPh00vBGrbVdu5a3Os5fFqABgiKoGFbPxz9s+V7DNZvInMzA2 +FZ/i5UZgnjWqkNG2U7xd89SNAWkoalRUcXXhq8zhSFuyIghRmdMoXscU2H7VxDQjCmxBpv55PDo7 +aq4RrTDVs1X1BWB3Ka1mgGDceFGHQl1ZUUdgTLa1yZgDcI2q+GTbbZqzDZvY3QBMOWlbCQVF9H2n +ejYZYW8sq1+ngrWpO7iJIoBA0w5IgBqCZW6bGSrxcJHLzcgKKqy7Xw7AualPW8ermUIOS0ScMgCs +s+l+aNXo54ttIq2uSkCxXZj2RnlTVIXcVO/Y3XUk9GRyAtTUPJIzBu57rhG7mp7vWNjdBjQN9WVE +4iBAE6bYBG/aMVA9g4VdPYQgYY5VEimhdnuanTOg4Yxk4NrmopNbddJEKVk2vVvjjqXuR+wzEYAB ++cSE8fIAWApN9Mw5qGOJwLq90pRRtBpkAzBrDWnxOprYRQBUJwXaNUosKgizdoxFLbRsWTcGEo7c +MASzNkwdTBihVrnD/icAqbuum7YAVBNElGf9eDMHhfE1mou+sAOdgZS2udGEECz6CTBLKQBg0PW9 +oDcOgcl0+sLxRUaAHmzjdmPnYBKlnYBJnLYpWxQMTQXVqBPOdB1sYTX2RZ0hVRkozBAhvyoH0PKc +bQtjzReBRW3YxAEvBIZFPRm2uBBqHjwb694UO8XqcMI1bfZLVWUUwCmsMt+B2dzXaur0AOzmcteZ +AEy2szC2ZG0bggCDjGvlyBePq8XAsKntlU0MRgDmutjG0RRpbeaKMRGdKmv39q7nAnUzg1PYEAxb +cO66QWN+I1Ct5iSrALauWhVrsdUN4FWbquAEYJxNmi68VyMwLX6XUQS5NMUre2paTZQUDR0vqTnG +UmCYEWCYxYzbJKYlQJOEc91CaJQUppyRydHMZ7FBq7o39EGMijzb7Czmj8e8tWJeJtTPCEHGsuyq +Xqnhn4PF4Ao7oxnoeosrhREAWKwaJCxE7lmO6GvTERM/E7RtJiNyZRmRMTi4KN6qoTlEUNS4jOJ8 +ymgqJBVINSgQdErVENUbAFByMopqwQptxghI0gkucSUAVrS8eg8UgaqphR10gkC8OoXNQQaSVieC +R21mBIum7biYLF4HFLCtArDeAY3fI5Sc1cLvph+nUR47kMzdKh4xRdBXLm1YzwWs4cm+SLGz5isq +oukjrYu6/rvnHl/XNBgrWcbyumLhOZFpiFdjQBJNxo8XjbWs6Pg/PPxxTOlQNSxxqIUazmbcpk4V +xXO4B6xtUFdNnokRmRPnwzJwUa9WzranFvW6Z8yx0Klp0y3hgRHzZMROfzOnYtGZkS0bpzv2Moa+ +lNK+KRIB1YxbFv/Ydo66usSqytnJgmQqTEY9TfXbOBsCnYIaKcJ2y6JLM+qO8NDH8QiYvEoi7Dlb +/Kn4EUAbQoW0Kt0Z9691cbQyMCxKFrlOGUGxoGexwAViXU2QiAMPETgWLh3BUpvuihItA2CpswkS +/TwoK0pAnwPFlCA0XNm7i8C+usUaAmCOqnQH29czdkcF3CL+pFwtJFRu5eOV80b6xOSPk7NTJYbm +fwBUadIlgJaubvQaOwNgdE7CZig1x6Jo5hkCm8zqLCFBBCUVLEvRObF2dPRfc60VdvgzMCSdDTRq ++uLWVO8oEr91L1ZnV/Z6QPfJDB+PUd8EAlFGQj0qSFPQ2dwjBwhOKulRHDwXaNfSNfqRMTUjS6/U +kEegvasHZRC8aE5jFb8WApOyRUXPakF5lOmaGJDRClY7Ze27JSgNScfOZPLK+7SMPPvFoCXMUAWi +zaR4Wym6LzTVm6A1JRoIF2W7aJxoMOg9iNd2u8Vc9QAGYatLcmYXUsYApfW3GGGUXik9UwUFwFVS ++QrbVQwsS9/wssDUP1BctALRmgGQk+tYt0zUJ0/vihstL6NpWQzYhK4yOzVNcw4AGFcddAltUcMo +A1n850PRflVxyQMwRd1a1LJCpObiTWrBlNlNOg3OIdKmSiJFThiYTSj0CY4IbMqof7LMTn2WlNKl +LByL566G0ilwNnvRwD60nosZtyXJDC0+xU5VN8SMiWO85ym9C2dorexJ1O0F21b1lAdxCuE5AsvQ +i5yOiMAULePApjjiXdX10EpQBDjEMroisQFYTXSZzVaC+YTciAWn4pC3lYHqVxumTHeVF1ZDGViy +CoSS5yRADYYBAUHNdmxrQ0Y+SXlZ1lXeZNMrmEWnVmt3kxACk1SSelJA/a06vLrGoSVFCFYzLBTB +GhfddxbrbuleXkkERLKSOR4soottS9q4CbDton5m9Z/jq8yrT0BGEJ0zVRNaANjToyvbnQhb1C3W ++iwA8GzaW1yU3y0Wc6ew5Y1vymo5owjSz6fFPt84eFl8JqOGxwpq9aY3WLQCwJr+Uzi6LMCkm5ik +nRBMxWyP5SHaRTdacso/F3AuKqnpJIGCNTW2sIdLUEgMmfmfLLYmifb8pmRpubgtKQ== + + + Rsxd1g1E7SrE2NQOZRWloFWkml+wnE34uPJEd3B8fWhOa5F3r7r9kc/SSAqqDWqKPlIkjq/CuYiC +tJmhs7bep2DOBBPb+LJqThqOv5fE4UteAZpvjmB16BTLTy2SpzmugOTWSk9NKZk7PuzKJZt7XnZ7 +BpaqTC3mPUPw0ncejkwVVLqMh6siXYuOXzAtuWQ+nzLK+OyCJ0k8WthXWRYY3dFsOWqrLu8irh9o +C3q+OVA70AIMPSBSxG5jcFizsUvjP6JmI2xt0tBJIcyVtSRwyS8q2VTintRWsu3Scm5Ce6CKYE/9 +QgQ9hUHcfwhMmsLgpFBmzjE4zjpePU9Ms1VKcRoUJSUwApw8Fr1fRWQVTtWU7XDWkWnZ7EJLkSo4 +TE0Jk8RfrGJg0UGbyKDXZ2Vs382q26bJAmKg89lX2Uuq23W6BxTAGoksnHzGwLDYFrcuiqC7xLK5 +xBDBqvNQQ1LYVnK0ur2KwGauHBRJiqBHc7MkrSC1a9uK8uq84CS0jYKsvqul6OfV29hTAhC4aJif +Qr38+ZWj2Kt3epRqaaM9GRVb2kIIlhVR0IOYbR7KxtctB0tBLM3ycyRWyJ9Hp55OgigRjjrzWh2U +KgCmopkS3Q9dZxeP1oY56ipY+qdr0nyXWbfSiq4/y0cWhwN+vugyVBscW9pyiaabV69BkoDic1+L +06niwgIOgEC15SPz8gZgaRaLVs8dNq1V07Tt2AY2tkygeVWsPXVZA9QILNov8jMo2p44NYuMBuCa +Nem1iUqGLZNmf69NdZ+K+dua41skQFExwqJnbygpnYEacpb0cUYQ7KyTUPtcwD3zjI46IzBy2iK3 +ZZsSYCmZCm3SEMFRz5GRP+m5gPs8JMeJgS0lWU4AIXBNlkMv2UwAhNHVriWdtBUTAJVl0ZLqALxk +PZmUxbMJwGwnwUSiIrmLHtpY9YAZobXcKU3HrcE51TTFFoCgxyuCeekIVFLj1l/jho39LAaSKlkJ +iU+rKALNj8HNkCUiUiBRIcz2FnZhxosesiOrWMdXEy6TumqQANmAEjuXBVgWa9ha/7ydJqHghcyO +XIWAgLlqDNS4e3L+o4rHLzW7nVRWmYyLppCT90NnqJ5TtNN4BM4Kdi/rZ8b0OAouhlmH21GAZ6D0 +ZZpXAUA9X5b4uITIFBkCO6kEDZe5JDe1GAgjKDQVSe5HGbHoWYyesYpt7Ywg2bQCLLpuKYtThJTE +1bDlErtMDFGHW3ZglHPJjgGkLiiznhsM5jEj+ZuCG9rnAg6SzJu6TPRAnd2wJzRJB0heZ2q2CSeT +dGW13PwBSFskA7vKg5ExXYpkaj/XPVByWWM3P3Fj1bMb6kcF4GKCg0Jzqsg4PqRgqquo/5EFLANz +U95SFqNqg7npcSlN8EHrYzEErdvataxKq0ag0NLMKv8CFnB6bqaqrkbDG3i28PCo8twzuBPneive +vvI0tgbAzl3ZhdCzILuwnIRRh4W6yZOF4dANIrEa6JhqWLPpHJH1NnPxSCZQxEzLZq4YOpxMYEki +QddXZYEQNQEDXXqSGig8VI9asJdpYgj6BGc9nkbhmWfsVMwqJ/uxBXKNRsUrebYAhNUu80izitFh +uxTtlyU+octXvD7RXFfovpZzaDj2Vf3FlEshWC1omU3xiGxnPuO4TMpFmdgs4Cfu78iJrRYcFN01 +sqbOXsVgGSeRQ6jPOEIqaUORJ/Azirs2CSBEsnY0mDqL5hLZuaFRXjVFo+VYYkB4TVGZEBQtCF1F +a74zjCln5SOFXp9R9LlPGtX0ME496xJJFhgBsGYuYQSUN2IEigsyaigSo/KlCL+6WKckgiDg2CS9 +ppqeJ2ewn0liQpC+Ug6C5ivouZrIccvnAqauS38lho/AVfCqXZAkws5AizlhzoQodZG9hs8oaaOv +myILFzM55JBa7AGOJAda+fNiSaZkbtzQ0xhg6OQQrOSraioLrUxGKxEFANagBCziIAdgkYOOsP3X +ORqCZVYEGiKkxJsWdXpJglAwwyByEgQjCGaboCeQJbhL/BkRzMlml8o5yjHSWU9BgAexYrayjiJl +vTGC2Q6lB5P2AOwbi84OyorTdRcs1axa6DaafhAlf0N4yLl2qDDqOjCtIfZDIlI34LmAk5y8DpYA +EKP5iyOXR2BgSkUQ9CzGaKZstAOIsZc2oOPTAqPR4PebcYhJ1EmXxywnPTCHu+osogjGM0rXpoJG +ModUziK46eJYNIF4sbS+yLu7AGutumqNrz0PPXJq1DPKblcPbp+bmHQvaQ2RDVFGMIPc0TVDkT8G +gn4iQA0JI9CGMFv6G+LNircucnqj2RmmyHmeDCxRN3zLgQh4lG01KLsGEZj6NJYDQM1CtwA0fS6s +duA09rMqlY87MLskwQbP1XSqbK8KyS37ZMeC9CAy5qzxToNHlYpOomxFDEKy8/C4/nljRWAI2gPR +c90RqOicFAFtzaZtZfMAoB4RBC1EplFIbgz62VY8byXBiNhPJyXL/I39uA6qKSp4KdLNCKJldUUN +b+LJrqw7sGZ7h2hFSuKtnbFHqEQSRF3gUzU9aBA56vaMTt2pBRRN1wegJtK7VY8nNauuDkpDf8Zn +fiUwLsrbMzofrRHA4E5i4cFzOQcFYIkEYKEBySEMFsGb+1HmwIc8CAEOvtQEiHakkjRA5WEISasq +6OHeyCesFUGYTcSxXULbo03DZFUZgqT4Rqc50wJuUo5H8lCx2EPTqaUmAQIloyy4gxdYx6LyZh8s +NjvPlh0SNGUfK3ToKarQE8URrBpu0AMGBBSnrylRhGA1Yap7F9UIEVM+sDPiuYITG4yB4x8KDrOO +g9ToQOCcld7KSY8I1OhB6Ao1lkShFDcCixqDZWHWkHRfZn2aSuNI7lboxyzmNltULLKpyrV11DEV +1BWLdXgoRim8lU0Fa/6oiyBq5gZWB4KJJ8ypWh2o11oSGcEIokVMzUK/UHXoH6kcEdYpCs55EIIU +SUqsqnD7uahToiU9gU7yR1pGLQTRE2UQXBY184tVSgprEANRV/Q5BVwpCc3JViwzGoXovYKznRiR +DHXy/1pyspCGwKyJMXMPslbGxmB1S3f/bU/kQmDRZMLZUjRKP69ezBFVKB1Fs8abWsmbHmjXipkR +SBmVMhZw1XCMEVFcfkSQBHOMAwTNOYizRezP8D6XFybHCvJM3gu4WjpvzRqSqVlTh+gE0zMJFIWi +QN05SjK9rtgZLIrpaPhK89zOCTgYZWqUFa0GymDVYiwLEv0Als4bK++UJXE12ZWTi9SXy4EpDTNo +EDNZjZdCp94uvl8Jg01l1YReGoF7BS9KWJ01xyAkjZhacG+xLEaKmKrF3yOZlpOx8FGPlXN7kqYo +bF4vdA3pKpmJQhhYOQKbzeJvswFFacYkmtwzklWHQO+AJatkzVBqfKiCiVWTv5/yxwQpdX1vqJJp +R2cH1cNMMu5ewLnZUQpUOPSYYC+tQB6C55eRCPYwW2GvzDrUvYBVtPdznFiHwHLQJHkTYcuFo7Az +a1Gy6kWl9IdWNZx3ToCM0RLduTpSzO8V3Kx2BIyxlHMQP8/K/m7t9zmS51QT8MsqASL4pnx+NUCR +/hhEoMJ1EZNu5uLAzwcwdJPdKs/18+cQ99E3RA8VAKyov2DpVpSJWKc5rJSMiyOJ18HgL21e6MaS +BSYOlXeNfF8JVwAEva7g3+GVkl99L3pdWwKBsQwS6TSrHPJaWrAxpzA1in8sBEn2+DeiZKyJ7dZZ +1wrqCKC4WlmRICqCxt5ABy9ZVZpgoT7xYWqhvFibcEN2FSpTl9RfJHVYSEkRkbew/FW65plly2yZ +3zO+DHUXsAR7+SiKAjUEyjGZb4gvCx5/I75gxuaqZX64JtGyRguEL1EOPS0rapNWSgYDGO1s0Jcs +tfKwtYYRF9RDcAdDvKhp3lwcsG9kQeGpMFyTSHHC9Ix7Ace1BQd+vgFHtmKEZpxQeOsn1mZUvXnN +a3NAZiWwBa8u821RYYuRpnTH6oFCgWpx8MJ1Q5gHB66YJmX8mhIG8iifEUZAHSLYPNPY1jHHsF7g +mBSgxNeFVRhPPiRaxw1rkqGqv6wUquXZgw4GBmISrtSQwxKChWiYWb5+I6sKVFTihBwDkqGXuhXB +DoJh5ajVgluW3r6gS6uqZzJYsRt0aBZRyfX8CRbqkgGqto9SKCKvypy4MGEzRndw18dpDdzgNQQz +PMfE3SWWcpnESllmyBpy6/FsiLKwaP72tR1xC8OpDoJOgeyRwoY0OmoTcFEsaoveLV7wC4YLG4Mp +sV+KVYZVlhCInHJzcchwWfw4LTe772Xs5lhlEpJJeL8BYwimlRstpUjE4Ij3mnyJymUYkDmXpEjb +0BYPZ8c8YPVAoYARdPDCDs8B64paR9pQoECVaUJtb+v7ZVgv8AB59Hdf//3u3fvjq2/ev3r75sW7 +P9/8DEA/+W8/vfn7r96/e/Xmu5uffPXHF9+/3L9+SfWm//jbP3//8qc3/wc22j/Y6OdHbvJ/wj/c +R7+fqCYtelOxABFoWlQeHRRUKle7UFTZFRwPWtA78T6FtINyXVmykDV7vwFb9so8m7Co5lkC5oWi +Qp6AOnycPDK0pfogZUTaYfJ+HT0F47wVkdCRznxYbyRAgIygE2ttfa8M6wUO4OjR6dxCFX7hl5kK +yYNRE6gI+hIzKO/IV9zxWT8oge6bTFwo3ZjL2XSImrTK+w1YypgwwbyLI8foNB53Dnar6oDK3Tmx +GHRtMYMrrBusHSgUMIIOXiyn1GGd+XzCSIEAlb1KrbX1/TKsF3gg7A14bRPWVgY1Vq+U4CtvwNyN +xNWodw1FSkLH6qp0N51xFxRfwUxVV+43YKy7ZI4jrheLU6/aDtNKjh32jfitQOVbx5ZSEnFE2YHy +emWtggOXYBuRzuxKHt8vQGWtkmptfacM6wUGCGtnrGCN1wuseFcQ3ZeQI10zAuZHJfU12pUOeDkC +QrJTX9lHVWXeZDGePFSyJJlesHF1VWtRVVlfHajMDWWOm7a4rMOywdqBTEAXKwwNHBQYkc58Snsk +QIDKXCXW2vpuGdZzDjBvwexsS6XrMuZAV2GA1t0iXfMCij1ZBBg6XRJdlpAyX/KFNkJnLZhWgjji +odX7DThZJBcLChdSFZrUQ+GulcI7pgC5a+jl1HlvbXHNhbjB2oFCgQ6OggOfshmxLnggcUuBAJW5 +Sq219f0yrBd4INzFxCGUsLGRuoXWVcO8DrqTItLdZMlfQlZY7hpn8W5ExhowSe5+A5bS2Ewrlxul +SSeJBqhzisUiQOVsqnHZtI1SxG/A2oFCgU17AQd2Q45YFy5gNlIgQOWsUmttfb8M6wUeCGcXOvtH +siVWqmAPOs9ah1t+eJq6az+qXZ0iW2qpjVHjFcJsCA1grfyEjvq0ipkXpTjejDWm1DIhoLJX7HXf +FhNk1OIxrB5IFCgCBYfbaKEGRbr0AEonQIDKXSXWte3d6kjPOMDMzeta6QK2JS+BpA== + + + wwza6cjbILKgotuALlmyK3RELmV9W9PS/B4cLXN+RpVkEbGvFWxmWXEdqAZIWWvetMU477xusHag +UGCDY2DN7nBYgwaaHQEMU9Yqrb2l76uhPGMAsnZhDTenwLrC+XU/ncF6NVG/W4sdM8bgkhR/bYvx +V6EYO5+VvlV8L/FWTrFgWfbiYWbeiY3hW/KdDgPKDuS368c7VAMVDmefd/3tDFPeKp1+hvZuGspt +37/QPNk9zjz5nXj3FvXuwY9vpyLXivx4NW/b4EN8RjFdUNRF9pDpeL8Blx6+xbMWrMeulgFrZRkN +SPy2LADfFuvmxbLB6oDJ2bQOHDj9csSKF47ULQUCZAo6ta5t75fDesYDklRfbjBSVcLEpEk+4v0G +HDjZnyo4srWP2bTNilvOcXVA7Rgn9g9t0XOZmkfZIfJu/nQHF84jHVHWW/RjbF4vQB1ZJbW3dT3q +WM97fy1jkfNZZukchSXvN+CAvistrwk4ZCPTii/QOXhpc0DlbVnzsmmb5LD8gLUDhQJlr4J7xTWH +tdqJWUeBABlBp7a3df1yddzOeHAlY5HycrL5aCwK6cCoRATlbqI8KOQY6Gg6dZYUPVC5i+60TVuM +bba8wdqBQoFyV8G9cqfDWqzck6NAgMpdpda17f1yWM94cC17EYkgF+vKThSZuw4qx0gY2H3ONWTl +LhdWNaByt0Wdu9Y2ywGFAWsHMgH6eYX2yuQOabGblBwBAlTmKrGube+Ww7rlwJXsRc4SW1QTxtqE +9xtw4ByRZ1L4Vw2zVmWpFrlQyoDcNSohtWza4lnRuGywdqBQoMxVcLKiiw5rtiQnR4EAGUGn1rXt +/XJYz3hwBXuR3l9XGbIaNRXCgQOn5TIwLgqk7ZP7JU57BSpnF5GNri2eRlWgYe1AoUA5q2C8hGHW +etWKNdvxF0eBAJWzSq1r2/vlsJ7x4Gr2IsorymEj9xQm8N9vwIGTWbgfLeq8S3JiFCt0B53iBFT2 +xmU+bzvnupxhVaBQYDNfwLDLyBFhhxUP7YQtBQJUBEqta9v75bCe8eBaFiPe/9fUiUNFRu7PwHql +BgJTVfOj9w02yuqA2rcUdXhc2x7VdFg7kCiw4TGwZV92rKkrIZ2C5BWWTu3QtvfLYd3w4LpGI+4U +rcno0QmA+zOwqzG/mG8Cx1ZYUdTQruquoJsb52XbsoYQzlB2IL1eP9/BerbCIR3mv75fgCafzF9i +bX2nDOsZA77hPJD/gNjWh0xHNmT+XazHmC2y4a1HBy6cX/CMi0XTeSkf5cKywy36MBkxHWvDUpaS +b5vEmT9gdUBvPTpwsLizwypnt0YKBMjmZ6fWte39Cr6S+IYHoih+keFItxBpwgRugPcbMCYjFC3N +zSchkFmuzHTnIAGVsVwxyrfF0rYr74sdqwMKBYygg4Om1Tmkix1RcQQIUPmqxLq2vVuG9JwD1zMe +UYEq4uengij3G3Amzw+T26hSEPLLjn6AgiU5HwLkrjUsM5nGtniipoQ2IHUweb+OjYIt/9kjXSzh +zxEgQOWtEuva9l45rGccuJbpiNXnU1DDrahd3qF4KUni1VQ59ZWmndXQXuV8mgGVt3xrn2+L6zkp +bxWrAzIBJlCS8lYPNjmkYDCtculEJ0CATEAn1rXt3XJYtxy4mt0Yi+ac4K2meenMVXDup4sqH1Tl +Nb0ac/mcoAGVuXweeGjb5GTLgLUDhQJFoODgi7Qr1mBnoh0FAlTuKrWube+Xw3rGg2uZjnjDgQTv +I2f33m/AeFcgO3/wgoKoJoMm29HtAgOQ+7biths3belylnWDtQOFApv7szKnNX2XIg0cuRoJCC6g +5oh1bXu3OtIzDlzDcESpNM8a8sJTQ/cbcPKXOfAFqTTpJJMZr2doYXFA5SufChzaYqVF5ath7UCh +QBF0sJZsdlgx3lLWDQUCVMYqta6t765hPePB1QxHXDo9aDXPupl1cLKrZvECDToYwvmks7K3VvUT +E1C5wzeGDG1h4ynKXsPagUKBIuhgTe50WOl4U9pQIEBlr1I7tO3dNaxnPLiW4UhXjgRZEtnmroea +ElM1MRMpi1nFMF+/akDtWpUsjKEt13zaYO3AvHbWdKje0tBxYm0OA+r7BaifV1qHtr1X6wVYtnl7 +BXMRyc1NzdFimoIH6yka7AUdUtoMek6znwk2a8Kcztry9XEbrB04rmoDa9WmAWtt4YyA2jprO629 +Ze+UQ7lhAJuLHzPm/j3sODqor/Oh23EO3Eu/Y2H/tYjJptXCEt0q1hyQmJGxKmhtY9uMbn7V5VxB +eQV6O86Bu4blsPZkEEeBTwZx1Lq2vV/umPsZD65gxwHStaorBwsJ3W+g7taKFbcLCfzYrRl4QnqN +Dqh8nUNqY9uM/tMljFgdkAlQtio06HVtDqdlNPv3C5C52ml1bXuvDOlZ/69mxOG1F4sOV8S6Wvcb +cL9vFOtj5CbzWOsG0Y0NaXVAZs0sVxj7tnmxHapjdUChQMem72ZUxGvEunCNg5ECASpzlVrXtver +Yz3nwbXMOLwrJBd1K87NmKtQTO2MwtuQkh4nWNjbmajGUXRA5a0qV70truag0TdB6mD8epMmAo1W +B8jhDHYXnnu/AJWzSqtr2zvVsZ71/2pGHN6s0nTMqNjr/QacuSAH0xujRuT0rkboG5Vz6UDl7ZLy +pi0A6eTtgNUBhQJFoOBoN7M4rMGuEnAUCFC5q9S6tr1fHes5D65lxGHVm5jVQFVleIBSKVgmNy0a +qZdit3TlS44dxh1rcibWtaRpp14/RTkATRF2UDzIb2WHFGfwe5i+Pvg9rFPq2vY+Oazb7l/DgCNh +r0NI5yLvN+B+cpyqFmkOruYcQ7dAJawOqGylYynbtnQH0Yi1A4UCRdDBeimIwxqsOLijQIDKWKXW +tfXdNaxnPLiaAYfLZtGBrHiF2P0GnExlRYKpcBAC9ZQgAFtYgwMqd0Ipy6ZtM53VYW2DIquu2gHs +175gDX1z6hSEcSNTaoe2vbuG9YwH1zLgkAaqW8Np/6FPXgeeq14jxUUXydiJxvI1qFOEgNq3VjXM +b20b3ssVN1gHoFm3A1iLXA5Y134TVqdgtcjWQK1r2/vlsG54cDUrDkuXNR04GK0+eTuYSpoKsFiE +ro98FU00jntJWefztnwJ9QZrBxIFhsDAUoh+QLrWcvZ+hOmnO6mupfWpY9x0/z/PhssgotY1Ofvl +fgOWa/GeceVA6V+12jRYu9ACdP1sINZEzK1u2kZ35FqxOqC34RxYyqWNWBcuAThSIEDeQDu1va3r +V8d6zoMr2HB4Lc66iA8lWX0TB84W+8dbVkLPRWt6mQjXyDAg82WRMlFDWzx+O6cRqwMKBToyCraq +Qw5p6MzuBIR+QN4TGzwLtVuG9JwDVzPjcg8TJj6dd78BZ1cZM7Yi1kPS8htYpXVeHVB5y0f6h7bB +DkQbUgdL7tCgA8d+j0BHGqzamCNAgMbbtm3retWxnnPgWkYclvcsTY2YbJxVYOaLhJnaVCwCbNfl +wKi2DlPGcrV73xLLCocNSgeklytbFdh1K4cSc7KlXEx/uwCVrUpob+u61LFuO381Aw4vc7KDOVR2 +734Dzlzq9JlcbtQ0pKz3K6AUXxYHVM5yoaqhLdVpbCNWBxQKFIGCrQqoQ4q1XKxIrRIgQOWtEtvb +um4Z0nMOXMt8w1uuLNmMJNL9GViC6Lk5gzna/gHTz8GYL3h4UeP62nKRi60dxgHWpaQDRyvq7nAG +vnNyfL0Aja+thLGt61LHet79a9hvVD3Ysn3Xudci6mfystzdgfd5lbjofJuVrUtdkgMqX6k479h2 +wcohccTqgEKBcraDtXiZw9pLtjoKQi/44KntbYfuKtZzHlzNfsvdixf5XtX7DRh9c03JUNu22D1f +87osHaasTZYz2VtSMeUBoQPKy/XzHUyXp45Ie7VO934BKmfVsNaWQz8V53nnr2W44dhSCUvCPOsB +yhFcrdYVHdfj0U2LXRfXVLPvZ/TK7JJMtS1KxKRSTrGOwFkzEgewOogHrCW3cEYBAY23Rq1r2/tl +buczHlzNcMOaYVEP5FN49/4MrFUzEWh7gBv5HtImoHauRU2C9G1Lq2dYO7DHnQew3fbrsZqs7O9v +XdR2Sq1d75HDt+n9Y+y25d8vkbKgr8WZLfcDMGvNP7qTYBVnO+9kdkeKgIgPVe9mc+02mEYjySAY +HuUrAR0OrJS/bF7GMP5kp8paGu0d4baP1zpkB3iLpTrQpc33G3C2lDEkdc2i6KbU9FqJ0qIHcrfw +5j0NYljbyKUSR6wdKBToKCi4B/Qd1mCX0DoKBGiMFWp7W9evjvWcB1ez0AquFR24aEdqHBhvPJI7 +UrAIR9SSFcmu/SiLlcdJ6r3FK05mtYqtrVRIHbF2oFCg7FVwtCuuHNagF5I6AhimzFVaraXrVEd5 +zoBrGWh4Q4jVdwt6ztpBM57w0xtG1HfVL0HHu1OSAylf06wxH2uJR/Br2ODswORWc4fG4ZaZWc0x +uufZv15AxtbVcnmlpetSx3nW+6uZaBVntyqhJJbvz8BNAjl1lkvAeUEXvUwqldgcUFlLxSvGtsG2 +c4fVA4kCRdC3/iTHyBzWYIVyHQUCVO4qta5t75fDesaDaxlplaSzmn+Y+H1/BjYaetjcLiFasG5F +cEBhzaZZ4LKnHp0H0Yttwjf1qmSxkXUCz3p/VX+rAI2fQqFr23viEJ71+hq2Gd4GF7SQzVzUNhvA +bu/i+7Vposm1iNivRa04qzFJG3XTQJG1DXh3yBarBxIFylQFd5XNYe1XSTgKBKicVWpd294vh/WM +B1ezzXADrVEzWldVDRw49XvagGCpdpQsxwNvnEIZ1oHKXhj087Zry3mDtQOFAkXQwf4qLMGK1QVT +2FAgQGNvOWvru2tYz3hwLRONhJG6iinl4H4DTn1jx9qK1ZgTdepQXasOVObAxt7O2uam5YacaqHA +6HIhBrCYzw5p5JzGkQABKnOVWNfW91aRnnHgumfqhlHGlMz7M2iTq27oFjbzXqWou0j3LhBQ+bO0 +tZ617fVZDKsHrrHzt0OpMu6IdJjS3b1AQGOw+dTcRO3dMqxbDnzxmbpHFmT5kCn4u/+w+izAPFgB +6/aEnQdbJZW5Not5Ws2VuWKWKqtprj7LXOlm3XXTNroqHoY1uioeZi56sFVS8Vit5oqnwNVn8dT2 +tq5fHes5D65kOs4VIy4W/dH6LB7MxVSwY6vkNlnNFeyYRuBdfRbsWA5jy3WRUtKG0EFcdRYPtjoq +HaHVW/GvdrVZPJmube+Nw3nW86sV8qx4J45aw1abxYOtispc6fJ6yS+V48vYOfjmi7AoX6Psmb3t +Oss1lR6rA7raLB5sVVQ8Vqu34ilwtVk8ta5t75fDesaDaxXyhCHOwY6XaW0WD7YqKkhvmbWsr9Rb +wb7xTaxDbRbkQ6hjy9XHiRSnA7rKLB5sNVQ6Tqu14t/u6rJ4Sl3b3ieH86z/V6vjWQ== + + + seq35sloXRYPtQoqCGzrqgnQXGsFcOJx/+aAylnNoext11lrrTusDtjrsnioVVDxSK3WiifA1WXx +xLq2vVsO65YD16rjWfEOjlX1CHUiebBVUMEpwlcJuVor2DWtMOrqsiAb5rBp2Vy9PcPpnWZWlcWD +rX5Kx2l1VvzbXU0WT6lr2/vkcJ71/xo1PPH9sxr+VpPFg616CgKrBSelzgr2SzOqXU0WBKt14tqC +oMxaQc+wdqCryeLBVj3FYzUz31PgvAGeWte298thPePBtaxH2gW6kaY1WTzYKkLQDEk666TOCgL1 +gLGryYLgWjctmyuEbDibL5qsFVk82GqndJxWY8W/3dVj8ZS6ttXZrobzrP9XshyJNCtpa/VYRrBU +TkEgyHFfekWAa/NFWrRvxdLVXduytnaGtQOtHssIlsopHmvqSkqnIHklpVM7tO39clg3PLiq7UjT +ZNUaK1aPZQRL8RSkRW4+aFplhWbUotELrcdC/Qvbdr3sqkPYgVaNZQRL3ZSOclhN+m5Xi8WTOa6S +tV/3UfIZ8H+JWiwzhilsCXdL0YGtaspcVqvsbfVVYGXYhHS1WGa84WtOedM2yv3IA9YO9JaiA1vV +FI/V6qt4ClwtFk+ta9ucFDasZzz48vxPRCr3fzRXi8WDrWoKktpveJD6KtitzkGrxTLTpWxaX9Pa +4s3Uatgb1g50tVg8WMumeKRWX8UT4GqxeGJd296tjvSMA1czFgvmoKp3wWqxeLCWTUFyFznLbPVV +Zrp1bwkOyF3LuJq2bcFg6FdJCNIOc7VYPLjfRemQWn0VT4CrxeKJdW17rxzWMw5cy1QszV+1Iies +PdSqpiC5c46+7Ap3jS+JHmqxIBu0zptrC+s5agzHsHZgr8XioXb61iO1+iqeAFeLxRPr2vZuOaxb +DlzNVgQaqmXPWS0WD7aqKTNeL5nKWIsF+9aynpu0WizIB9CX0qZtllvjB6wd6GqxeLBVTfFYrb6K +p8DVYvHUura9Xw7rGQ+uZS4C5iS3fbhaLB5sVVOQ3lXOelp9FQTOddnWYsEuq7Hg2ma8cztssHag +q8XiwVo2xSO1+iqeAFeLxRPr2vZudaRnHLiGwYhSqVq5Qa3F4sFWNQVJrXJLl9VXQeCyrr7oivK1 +JPX+WNsCRrMFMRVrB7paLCNYqqZ4rFZfxVPgarF4al1b313DesaDqxmMOLpW+9VqsXhwvzGw4H1o +szlgbdrCEAYHVO40qX3v2hb2mo9YO9DVYhnBMVhbxRrZohwpEKCyV6kd2vbuGtYzHlzLaEQaZjM0 +bO56aMtBZUIO0UpjK2Ep9AMJfUHGRQPlvWWIOhkdyg7MNm89NCxZp6ji1EII/u0M048rnb5l75BD +Ofb9WomgRGyw+y2KaQkeLAdFqRNmJurNitiH2IoD2ozJmsfp2tZsJ3Y71g4cV7SBpWjKiJWrq4wE +aB2WkdbesnfKodww4D/tDN+MZ4GSnqzoNpwDW8WUOcMO09TUkNoqsKTwDl4PJGbkaOcZXVuMsKke +Z1g70NtwDty1K4e1X7TjKHB1WDy1rm3vl8N6xoMr2HB4gk2uyOt1WDzUKqYQpbMGeaS2CvYqywFy +V4dlzqj3aGzO2ga7EtRh7cBeh8VDbf07nP1mSfd+V4fF0+ra9l51pNv+X82Ay3h3etS9SeuweLBV +TJkzFqicRbmVJHfsWol2s5zWYUE29Ai3tY22Ozms0W+aWofFg61iisdqtVU8Ba4Oi6fWte39cljP +eHAtEw4w16AVJbQOi4dqyRSkVrNUrbYK9qxGjfxYHRbkgipWrm101dEVaYf1OiweahVTPE6rreLf +7+qweFpd294ph3Xb/6sZcIA5raoiWB0WD7aKKUhvTar1Sm0V7JveAOfqsCAfWtSxsbbwiqZHpQxr +B7o6LB5sFVM8Vqut4ilwdVg8ta5t75fDesaDaxlwgFkr7fQ6LCNUiqYguaUEvX1jVt62pLaH1mFB +KIUmhpbJskgcSg80JdhBrWKKxxn8HqavD34P65S6tr1PDuu2+9cw3kjYayag1WHxYKuYgqTmqh4D +vaUxY2VarRxkdVhobwnqs7C2+KvdhahYO9DVYRnBcv7WY7XaKp4CV4fFU+va+u4a1jMeXM14w2VT +NGnQ6rCMYOjlKv3oxfglbRiBi1SgSz3FmFbporFQa5udzmpY86DIqpt2AItl65BGcy86AqJzRTpi +h7a9W4r0jAPXMt1wgINKH6vC4sHAmqWqsNVrp9AfGoMAQ9YzGEETEanHs6XZa9uMJf/WDdYOdFVY +RjCd7Rixxr49dQriuJUptUPb3l2HdcODq9lwSNuqKb5WhWUES70UBGrxxNh3h2IFxeO4k8TWztv2 +clYOawdaFZYRzDVTRqSrjXl/v1ZhGUntLXufOsZN9//zLLhU8Mynz5a834CtXgoo3LCItTqmVFYB +4eZCc1aFZU7BlFHXFpR+sFg3WDvQW3AObPVSPFarrOIpcFVYPLWube+Xw3rGgytYcKlYIXxXhcWD +rV4KklrzbNlk7GaAbqXcPJC7FfF29W1bvMhbS5MZ1g50VVg8WAumeKShs6UT4KqweGKDZ6F2qyM9 +48DVjLjUA4SuCosHa8EUJLf0uz24sgp2LacWHVB5mxa9w97a4nEdDe0p0g5zVVg82OqleKRWWcUT +4KqweGJd294rh/WMA9cy4QBzWvTGXjWPHdBKphC1EnTU2irYsRK1dKkZGSnaJb69JV4+rdFNQ9mB +VoXFA7tm5VBaZRX/dleFxRPq2vYuOaybzl/NfEuYiqs3WFgVFg+2eilIbs4a9ZHKKti1fpWgVWFB +Nug18a4t3Q5dN1g70FVh8WAtmOKRWmUVT4CrwuKJdW17tzrSMw5cy3gDzHO/5UGrsIxgCZ+n7Mzl +aPvHavepRds+gMgc17ElHv7IdcToYU5KdrDVS/E4rbKKf72rwuIpdW17lxzWs+5fw3rD7VMurnBV +WDzY6qUQrYvWh5bKKtivNq++3IrytR/3tbbRMn4d1g50VVhGsNRL8VitsoqnwFVh8dS6tr67hvWM +B1ez3lL34bkqLCO4SupzwqPleqdY4aOJ1Lmm8YKixxhJAqaaz9qCArNusHqglWLxYHQFVEVQLAdT +rQZHQXIWhqPWte39cljPeHAt+w2HOKllacVYPBioWFXYqjKOvtCo5Pa6fARU3qzNNl1ti1mpZr4J +0g5zpVhGMGg6tv6b3T6+1mVDgACVt91ycG17Zw3rGQeuZr0hEUnLWlsplhEsZ2UJuPRYGUeCU3YR +bSvFQuCkZ+9821mtL4e1A60UywiWSgIj1lbO3t+6vO2UWrveI4dv0/v/3FIsc+zuFm/BObAWUZkj +ap1DmZU5RjsNbeVY5oiK/VC2BSaGJah2dB3mLTcHtmIqHqXWXPHv7tVZPJG9pXcpGcqzjl/rmF3E +y2+D5i9qhRYPtloqSG5qmhclVVeoZ3J631VoQSbomXzXFk/6q7ZnWDvQVWjxYKul4rFa1RVPgavQ +4ql1bXu/HNYzHlzNeovZeZutQosHWy0VIthy0eQYNXYuFS2AYxVakBGpqsVsbRfUMJcN1g50FVo8 +2MqpeKxad8UT0Cu0eFp7y+zc7YbyjAHXMt5i3pRIud9ArZoKUqt+Lau7gh3rUsNqtCAPStUzg9Z2 +Oa/74oHJrenlvJ6KR2qVVzwBrkqLJ9a1zeeVX845cDUTLmKqsp5CtyotI1jqqRC9vQS/BAdjtwlc +lRbkw1q1wqm1DU4tMaweaFVaPNjqqXisVnnFU+CqtHhqXdveL4f1jAfXMuIA82qHpaxKywg2GnpQ +Xc9aRfJR+9It3LPoti1ri6tT1TjjVgdZqRYPtsoqHqfVYPHvd/VaPK2ube+Tw3rW/2tYcYAVdIxt +vZYR7HaykNexXgv2SyuouXotCA51U6+FphyumxGrB1q9Fg/uep3DajVYPAWuXoun1rXt/XJYz3hw +NSsOdZVZ/RxWr8WDrbIKEbxoAqXmgkRULPVSCqvXQvuLJVC6tnpHvMPaga5eywjWyggOq9Vg8RS4 +ei2eWtfWd9ewnvHgWlYciSVLldR6LR6c+jaPPqWgWyrXYMG+NUuhtHottFZXvWPKtU2r1hXyisaq +VYV6zsQA5tIqHqnVYPEEuHotnljX1vdWkZ5x4Lpn7oZR1notI1QqqxDN3c/FNViof+YCsHotNKdM +e3VtwQAoG6weaGHSASqVVTzSYUo7L8jibIh+LtxN1N4tw7rlwF9kvRZ3DO9LR/2sYAvegqRGHM3F ++w04s/8AgLhdzlVrT8jdzHO0nEAB4hAsC+x3yxzHtv8/e++6HLlxrYk+Ad+h/ijC3rFBIy8AElu/ +RMr2+Bzaclj2jCJOTHRQbLbEES89bLZt7ac/6/tWJpAAiiRQ3SSr2CWFxMIC8r5y5bqnaZG7ww5q +zYGxB8cHCu4PDoJPRuAu54sxwrjbEK2N6RqRQccIJG4wTi11LH5bBiQSSB6rCWEyYNaxNTN2IjiD +XnhIPngRjAYZXqWZUIE24F5Q4a50IDaFZgiYMeUKtOoLFZC8Xy+qK1skjGO94BdszIpUwmxJKSJU +mqZeBx2d5ANGpxddlMjSYmOOF/pa6UwEbM4uLZI6VcDI1TTJj9GprhDvQ8Uh4y6tFBgOP0OLIdjS +KOlXYF0hV5KVviSBi6E5yBMDIPfecaxAbyiwJY5m4YROCMYtXlg5W9qOI9ZIjahkprYQIys7Fydw +SCkRaenS5YoyCymntsxX3Sowqtx1bq1G7gbXh3ACoaKhWdYhKtqwkNG6FJAByDAN1XTRj4kNGJtV +vkXWlz2/imOLthUB00dWvzWahDKAzqsoBY5RRSFBRGEDI3FtOztMaOVs9cRf5nfpPBT1Zt+y7MIl +qyz9YFnHyBMsWh1vOJPxVtQ3YiFcrcm0BBkr28SVlLM6bUw4LZi4aB4upQmfy9pz0eqIicIxBcWZ +pAeWn61JMr4HSUp7srU+JZltVa/Zdil/Ai4+V0YdwbOWYk2oNWXNWZxV2Al1bVM+gLbUZBA61aUy +35h/k3YYseB4/Wqd8CBoO5L81Td/Cm9+f/326Pbjh5+FnN+d314DWAH45i83138Vmn8nZL8oFHx0 +/tPFdf7i4C/v8caU+ur7//nHP1xcSjUHv+t+yjnzux/+fPKXm7fn+Dk4gO598fXqN/++uryWV4V0 +6/bix4935x9w1MgZdns6+uLs54vLt7fn13hvV7/70/Vd/w7/u4sn2W/Kr+Qg+8f1xZkA03mWf/jP +08uP+uW/H/7w+vSK36ET7NW2juPX2eP49QXGIft59kj+dfH27ufZo4lfb/WIfj6/+Onnu9lDSp8/ ++5hufvw/52d3Rzcfr99K/45uHtkb/QDfcf/Lp3cfZo9yUObZh/rNn958c/n+59M3Zu4YL95mvPE9 +Y8I3/zmjx9tCJu8+3v74UTj8s/O5s6BFZy5xaue5iaYI63PH8+Pph/M/3J7/348yCQ== + + + 80noqNSzj/D65vu7i7uzR6hkP8oP/PrvF5fn8/fnoMyzj9DOHdr1x6vvzu5O/7lgZHmRZx8Yttzc +sd2ef/h4Of/cSJ/PoUD3dN080PX11C87BM7/npOThzv7wLw/84JcXM9djpv357endze3sxekL/Ds +aPb9zcfbs/M/3p6+//nibPYR98hU5Cfd9ZbvnYvrR0jIYDD2BXfN8c3V+5sPF3dzNs1TdIB82KNt +/+7b83err/fS3naMYy/tbe+I9tLemlFuibTnv2Rp793tqbC9l3+5ufjwyuS92UL8XtzbTnFv9r7c +i3t7cW8v7k1GtRf39uLeFyPuFfa1CHxLRrLlIp9/dSLfghHtisgnctDR+T/PL7//+fTtzb++bNuX +HpkUC1/Lgfnj5cdHuJXPwGxuq2Tw4e7tt+f/vDhFhxZIPXmhF+MJ/nj68cOHi9PrI13AXeGlZ6/N +2/nH8NuXOIfnD2T+Kfz2JY7hJRRg26nZzbt3H87vjp6Dpr3Qtv+OI9yhDX8JvgVegmc3lze3//Wv +n1WMmUmff72cr0qMX+830CeM5cP787PvPj6yH3aPI5jt2/Ph4+2707Pz789OlyDeoNDzSx2zByeL ++/Hy9Pb45vrD3en1/HWbFnwBa9rSUf7+3+9vrs83GGVfcJdkk6Iqy9lztOUqDlMuGMt2KzkKu2Qs +/z17LP/9gjzIX28uru9OovriJfSR59/HrXoSmYsd4odepzFhId+w7WzQRoqexdaE7V6jXZOMlhhJ +toUYnN5e3P18dX433wC3S0Rh9rH3yyPKlGw4+HSLB/IIL54PxGyzqPCLmz8Qt9UDmU+Vf3kJovwq +rfCLuYFtPzovL+7+enrxmCz5hZ+duyMrL1cTL95xL7SQfz6//ekcM7lDTNDSzfUa1+LpOrB3GdpY +ofbVK1GnLfBK2W5lmjF7j6Ht9xj6soJEjm9uLo9uz8//e7ZV8zV6Rr29uDydb9fdJSWGOZwdV357 ++vbi43zUTZ/vhnZzuyXO+QN5O38gb7d5ILsmYv755vb9zzeXNz/9ukOiyZ6s7RBZezXEbH4Ey5YT +s1cbxraTxKx4PS6rr2anLwun2OatPnsku7bXd87j9vXG7M9mWfYx+/eN8WVj9mf74e5azP4CQr7t +R9LsTbb1R9J8CWfHjqSdzKLwiEdJRtaWOd+/kNf9F7njt95R48fZWLb11Gv2SHYlCOdvs82pxz+f +Xl+fX35/fnl+tkSfNi34/Bah2ZbWTQc5Lfhi59C3Fx/eX56enV+dX9/9+fT9Dh1GV6dS1WzD5E5I +R6v072ry0wx+zh01f83nv9PnW0wpt/4kXpZrcJtPr9kj2TXe+xhhzH9O5GNX6N0CzNr2PTJbh7D1 +e2T2SHaFw5sfifw8iVe2Zfe9W+Qf9O7i8nKJ/9PlNq/0u9ubq/mD4cfPr5V8hMnJDGOPeYznlrGP +LxJzNXssP+JOrvm6cf36+Y36l/86/XX2mITy3Z3eLqKU+v32asLvbuZLHjcvMJDbc4qAc4dz+vbt +xd3FP+eLU32BF7DHXM8f19nZx6uPj3sL5SPLirxARNP1+ens8Jez08uzP9+8nT+2vsDzB5/N5i2y +1UvN/4VDmLuAw1IvJJKcXl9cnb5YathdzUNXhL0zzJZJdmevxhlm/kh2Tfuxd4bZFnXv/sLCiU5h +17xh5uc02zV3mAWkfNsPpVfjDjN/JLt2KO2kO8xs/nM33GG+yB2/9e4wZ6/GHWb+SHbFWLJ3h9m7 +w2zLYfQFuMOYL8UdZgHN3/aT+NW4w8wfya7x3rvpDrMAs7Z9j7wad5j5I9kVDm/b3GG22v6zO948 +C7bcUuLxQmu4i1kDF/gB7lfhyVbh6XJu7MAiPF0HXqjx3U/a+M2f3nzLnD1vlmm+ZjFEu3NEvd68 +RfPVgDuSteh5EoC/FDVdkidnT9Eepmj1nqK9Roo2e1n3FG1P0V4JRfv9rQC+bBbtHFPwGunZnkPb +07Mvk5590Qzaq6Vne/5sT8++NHqWG3XeLLPCvzKyNnvwX5ANb79t5myb5kveNrMHv982X/i2+bJu +C/rrxb/PL/96efrrm2XBjtvosFOVq2q296TO/N8WOFBmJXaJ8t2eX908lt5gx3K9zM8pss+Pss+P +8pmQbmW+tuXKVPL/ciX/fS2/5e/X8mL12ly2L67fnr+7uL6Yb+C6PX9/fnr37YLtlpV49vHtc8To +uHYsR8yH98gSM3d0u5QjZiY38qUliNkWHuoVXlD445LLxrfcU3/JWHbFV3+vsNhecvDY3t5Nu9Ii +irDl1G1Dk9LWh8/fXL2/+SBs+XcfHyFhuxzAF8e4QwTh9Pbi7uer87v5uLZLhGG2Tu2XR4xT2XDw +6RYP5BFlaD4Q8xLKiNkDecT5KR+I2+qBzCfNv+wKZd6NQ3Sh1LNLR+irzYr4Wc7Q3TFxbLSmO+NA +tA8A3JuTd8+cvCxN4TZqlfbm5HWzsjcn783Jzzie12pOJnGBQdmWXy8iNHsT8t6EvDch768ZmYxs +b0Je093tURHvTch7E/LehPz5tRM7akJ+TcbWtxfv3n2cf5vJtpOChcPZFWowOz3dh4+374Sz/X5Z +mv9Boe21I+n0LxvboMyzD+3X88vLm3/NHd/lxU8/38n74gx5cGcPcVxsexcw7s7jm2sR3a/n77tJ +ub3S7UWVbvs7bh8fzV7p9hSk9Oufbs/Pr78WDuz864vrtxc/3Xz9z4uby/O7r2/P3359c3t6/dPs +rbbXxu21cXtt3F4bt2Zk8/mwvUruZbgqE2ZbXU7/++Lq490jVz/mS5K+f3bEq2eP6fxSHhapfLIS +L6bv+faC/PsJ9tdLecR8q7LESdzjO4Tyr0nt9OH9+ZkcXLfP4Qv/7NLRq1bWzCZRaYkXS/vTgtu8 +hrGzv//3e+H1NhhlX/AFGO9HtLlPoJra6232epu93uYL0ttELY3qbaISh+qbvd5mr7fZ6232epu9 +3mavt9lxvc1lVGi8CheKvRLq6ZVQ30fhbwe1UK8zf8YG+qhtV7G9ygjg59QbvhB92ufQ2Dbi8Gpy +aMzP2LDlOTTmr8iW59CYP5Atz6HxPPeAbLc38fYfn5cXd389vXjMSrE/O/dn5/7s3HggW3527vNP +bdvZuZQqb/uxuZEwvStH5z7v1KfN/bYcu4vXc59zakkHXqjxfc6p3co59f3Pp29v/vUU9xftDiX6 +wrML7Ipf5+ykaPuI/GffQrMv1nz7CDnN3dr+/QJINn8gv84fyK9bTgG2nZrdvHv34fwOW+L2/O0i +Or1rMsB3HOmXIQBsvqqvURLYllV53feJ70WzXRbNClN9NRcl5/MZL8FmLBnJfEbjJfgM48vZI/nX +xdsF7oTx6+cfkZs/op/PH/c8zIaUPn9+DupLVGo8QRbt3eGu9kqNnVBq1HulxtaywuG1KDXmD2Sv +1NgB8Xev1NjeY3ev1NhGSr5XauyVGtuq1PjCRLO70wWOlq9RMHt3e3p2d3r5l5uL+Y7NWnjmGqeW +nts/83B2zpYfTz+c/+H2/P9+PL8+m89xjkq9QEz693cXd2ePKLByiQ1f//3ickGuhEGZ59d8zfax +vf549Z1g8T8XDC0v8uwjO3s6L7PnHskyrdYWxznPH8kTCjzbciq8vmRHC86Dd7c3V/OHw4+ffTiv +KXXTa011VB7OvrXl7mY+P3XzAkPZ5y4aDG6fu2ifu+iJVcvzZZIvLXXRkyiN/v7x9sePlzLZu6RH +fJ25VxaIFFsuHD1PypUX0vMuiQ/bq1rX8odfvQ7vsfnj2HLfsfLV+Y4tGNHed2zNKF/cQNHzJW8e +Cb9/3WaKu5w/e0VGinJvpbjZbSvFbG+mXTNSYMttgUp8L+69bnFvCZrtBb69wLcX+PYC317g2wt8 +r1/gmy0avEaB7/X6pc3O6bCX+LZT4pu9gHuJby/x7SW+T0KzvcS3l/h2WOIrzGuR+ZaMZMulvurV +SX0LRrSX+taM8sWlvv91c/P2p9vT+ef9axT5XuWdEYtixLc8ROI1ZryYLcztM148O0HYp/F8aCD7 +jBefyGGkPBCvgjbv83dsLRl7dyncnV5C/F8/Xp6e/fL1SkE370/PLu5+/a8FOuEPd79eztdxx6+f +34V7yYXL276zFg1m1zbTH4CIO7SXXqdGdNl+2YlzdbOcQ9t+688HpnI8fk3k7cthHHbxNsDXxHAv +vT5zyzfOwuHsikJkttfJh4+3707Pzr8/O13CkQ4KPb+mfNlqLRvboMyzD+1fPy+Izr+EVl/eFzM4 +j2yE42Lbu35xcx7fXH+4O33sKsVcqzIut0sKdONmb97T/764+rjAtNV9/+xLTpx7NVmG6tk5rc4v +5WGRsjkr8WI81rcX3Dcn0cj4El4D0gfu4ZNIrPbc3q7c+rpnkXaJRUoLvPiMnRZ8AT/5paP8/b/f +31yfbzDKvuAXwhLu+aWX55f27NKeXZrbh+8jodpBful1WgM24Jy2nRl8Hjfp7V+nvcr8GdKJ3l7c +/Xx1viCv+y4Rh9kH4i+P+BRkw8Gn2ytn/PLIl/lAzFavyCMZfPKBuK0eyHzK/MtLEOZX6Ui81Hq2 +9cfn5cXdX08vHpOo92fn/uzcn50bD2TLz875TMCWn53zB7LlZ+dSqrztx+ZGwvT+6HwFR+fu6KH3 +tzRuIy/05JRwB9bi6TqwQ4jwWlMR7ZPPjka5e6mIXu8VeRtZDLabFf374hzWu8a37WSSpatTqWp2 +eoldIOxmVcZ/1/3qIHOHzF/zyUb6fAf217ZTjD9K0Q+PO4/tLsFgJNWf0wbcFYrxCs+mZ43/2tbs +C/sUH8+fIO3V5PgoZgtT257k41kUUc88pu++mCjXnUuP8Tqd+Bazbq93B22/PQX2Bozs7684AfIu +uiNssi7bvo/yMc0Oa9wVVtsczo+N2jPb+zPpM+ylH96d3/7h4nYbVCTbss53pz/OX+NdUGja1Ww7 +B8f+P5dpLAdlXi4V18frs7/tEDV5dVh22KzK1ZeBZ3/c49kL4pn5UsjZ0Uu5mFDYQdT1329Prz+8 +m3GLxPbg++vUh2zCqm07+7lhnMkuaEN0aFvCV+/1IXFl6Dn3zeXlFqzJtkzJZsi699Vc0oEXanzR +9U9fffMnU775/fXb7hoogCpA3vzl5vqvUgXTlBQKPjr/6eI6f3Hwl/esw+ur73+9+vHm8uA3R6dv +fzpfmVWx+uvF9S+/Pfgo/5ar7w56h5offpWH/0d+/B8B/WvlV39e/X//u1y9FegPfzsoD8uybMPK +VodNtbo6KMxh6U1dRUBh5X1l6pX1h1XlGgBaV7fy3h26tm5WZweFOwzG25W1h65EGX9YeytVmkPb +BClSHdbOyAsBlMZ7FKkOgw1evikP29rIN7U0W1UNAa7Cs23q0KZnKdIcmlC1tvsiHFofPGt13tWr +okWR0gDQuMCemRIfNeiaMVaaMdKnSrogAN+2XgAyQN82HQCFZBxNaAbf1B5DFoCrLA== + + + AaFpah2xMyzkZLpKz8ZlOvHcBsf+u9LI+hh/aDHRJhyGSkckIG9aszLNYWUwCQKoXVWvTH1orEdD +FboihfC3bVkI72S4+i0qRmlLgDcB3UULVbtii1JYCrEXtlppr6SQdtMD0GD4BYdi7YpD08kTUNNW +BJW2MfzGVjJsmdXatlqJa5oVJ77lkLDmsibNYdtWNaot5RMZUX1YN8QN4oDzK+CErX0q0zRhRbRx +qS+NXwGvXIlCwDUgEFa+dCxEfJQlEPzEYhfAVy+DBvqWpnsu+bH+LvqXsXTRF49NFHkbsR9F35HY +1aLvaxwPkVzQPc42B13ko8a0FP28xKkr8rmL01t08xsXoMhXgKtU5MsUl7Lo1zKudtEtd0KJIsOJ +hDdFjzgRtYoet4h/bfzRhoi1tfMmfu5TBZgnVonJYDOYJzasy8zOWJO6F2KHQ5Owseo3lg7U2bgd +ufuKfPtxgxaTXVzk25hbvcq/itSg6MgBZ9/E/RBpBulK5QlTwqKUJ7DnA+JU9NQp0a/um0Thio7E +kQzWaQ8oHQQeGR8RS9aFqCZTF2cAqwKE9N0uCIoqgraWHQAicw2kfUFlxftqlch6fDw7IOq3bQKg +Ao8ZTxWQrHNrdK2QrLPK2BV01rmq7y1G5JrBiGTYslNcP2xMTMNvdGIwdy1QuJs7TG9w/fTKAgg5 +tGkBPOlLSHjiAprBUlamW0ohUljtJq02SKYMsQKWJYAUknEEznb/TV2ZNqKWb5T6tSHhH8qQrtc9 +jhKNfb/JEl2Pe4ztkK77AWmuXW36HYbtFMpuXwHvdDe5tPncarQ/Kz05KpNvYu1E3Oh65EonbaIF +Rk8obDqOrMYJMqQqFb+xVTCR7ug5zc3A7VEFFgIBqxMFK3muNVx6pXF6tmPde8JOLMGmJLGUoSke +RSR3xikPkXC8MixEfIyEua1XQ9LdrDKynlN8FxmUiNlCmZWgez0zGq8DdyBKbF0KJv6E3RNyPTia +5JnT27g6nl6egxQyXvN4840e9rJ8RNDKG21D0DDoERlWOtdej9C6WU1P2fFBPD6pp4f5+LwfMwSJ +Zvcke8xWjPmOKWsy5l5G3I2S6Sbjf8Ys0piHmrJZY05MiXMdWbVa57SNuIg+kS43beT3wGOYUHcM +I8hKwPInqkK6Y7r3pEvWdgwnSVeV86SJuiXilshfon6JQvYEMhHRREMTjR2SYH06HnHaJwdHPx4k +T/ejn0UQ+c0/riE0vF39dHv69uJcpBLj299KNbI2JuBvK3ju5HN36BsHDMgc583q6KcDXx2WtZAg +AIr0UARTywJjYwdZdVlioQdHVwfvpPmjIxEX/uMj+taURihUeRiCdTJPgMhyGB0GFlleVfLSoyem +qmWpSpz2jXTkh9M4ukYZMQgSMs9W0NJFgLTL5cCB4yhQCL4bqweOlV8yQ+6wLqtWT39TgyGMR0sl +jUkldQh6jjSNxYzKRIbGKEfRGDlraxC0oCdJHXyth43rn4/lsLEOaNaBwqEzrdMjWHhDIJ6TwWnL +gvOtFBLcdJYnoQxDJgqnjSvBoGO/gwbhsHH98zHPGlf7/IuqrvSoMS3Iu0wA8B+AMtQs4w4rq+ee +cAW10oRax2fLmtuwJWeInQqO6xh725AXks0sR5iShRJnmuz2Et0XOiB9r3nWWCzk8UF6VejHfqWF +9Wgx2NlsoFamUvYLesdOgKtltyrKWexmwX6X3PxlIJeJsaEhgfB8NWRYWn4hZF2PmtqyjqoEvces +V9ZpOy0YlYANHLijPWrDSSPyHnd006ASooTDqhJJhKLJUSPEpKQsKhhU4agRnPI8DgTLKL82vtSG +IiYWwM265s70aBmoa0JTJUCJj+PP7hULm1VXFvXjfIpozbGbWr7sekBENquui8TjVTYIDFQWIRtn +K/QC8yCYr1Pl/SqbKc4mSWctrOUqzjYn27fdcnA1XKvTlBBLiACnNuEVVzShVb/oGVYpXhBzvGKZ +HAjEKRwhPW7xTbvq0I8IahXFXN3hMNvylaI90Zy98WYVt0HXWXTf+lW2T7CXHPHNtDW3knP6nDaj +b8Oq34vYrWUHwG42NQ8Sko80of1+B02g8iGSBBAN27KHglR62Mhps+rJCimPHpiEgDQJgq8SZcIq +g8r0xAvELdG2RPgi3Us41FPGRD0TynbElbS1o718Oj4YIHCl+N2VJi8rDVhZX0VaNFAMutDEjaSb +nF3kZosKmTiCAoP0egRzkBCCrGv7eYmCUp1NVMG59Lb/ZjzZSgoam61HMV6yYrSkxWTNixFSFGOk +KaZ4VYwwrxhjZjFF3mKM38V4AyjdtSbbI8V4GxXjfVZMt2Ix3q3FeDsXgx1vtdCQJvATUGLSDG/S +KadkpSbhohzWNvUqUeCClMn1lKmY0C49ppueuhU5+fNsOaOQSoCLnIhWyjokIluGKL0mAlzk1Dm+ +jcWLrnxsosjbiP0o+o7ErhZ9X3U4RT6eOOQiHzNnpeinJU5dkc9dnN+in+D8DExL0B+Tro3Tl52l +purP/O647VAiO5M7vCl6xImoVfS4FfGvyBFQpo6nLD+PmiEjezWiYhW1R3U54Da0M94Mu1dlPEu3 +rYp8X8W9V+Sbz7kIGWzgItvBcY/334AKND6yYVj4RCoyXq2jJx1D15GcYkKXMsawI179V4m+dfwl +EaSJqopEBYFFocw4VcW0josFMroWgnxPzxVjrenZYUVrbyK7PGKnjw/+IBLCtzmXXUNZLy0Iy1Dz +UZptjEtqklARn+s2aWotpEgSbRGiXISVqnkXaSIywKPZiRCSbRwHNvsKq1G1Os5mvIRNR4QVB7Nv +GmuVPNQhIrxuGN0niaZCCmFjvsbEC6RsGtV2l6oElHmhwo0/6jruBuGHbPw8mFhBpRUEGzn2yoTU +cNx9gsOqecWcqF6vIXY30FAmzW/lW53TxjZx0wqCWJ15Tz1Gpbwr1iX4HpAIGH7372LxvnRsI28i +dqTvR+xq19M4nHw0cczdkNO0dLOS5i6fOrxTnUCcX5SueBjGJXAdD9+tU1xNLqbVzc/1HqNEhhER +a9IXCa8myJfhHjG0cf03CYcTCic8z9Ack1oF1qt7AdMuAvTK1hm/RLa7fzEuhHoh8fb1SsvBRCVB +SeVmU/WdVyWEzfquCn+jECGqo+FP5mc0gYMJNnGVB2swXqbxOk6XeowNY3SZYtQI54iToUPJKdZy ++mTQCbFHiJ/tifF+SSW7HcXK65Bvu9h8tzWHm7dZDTe41f4MicCETnB2mjonJmkidfc4u0oz3REl +1u8HlIvrFQ99XTCsp3MdAVStdJPRSGBEbfsvgDFNlRHfTofRIRWxjidLBCWsTDQ94W1G9xNqd4dD +Qvsi3xAFd8Tg8eTg3cF//OPgH1RW/fD2oF795rerH/7XFPDVG7P65r38KeWg+upNt8pX/cN4mQer +nKHQGYqMsGyEgyMkZYkRIo8RfbwVUGayXcbbabThWAZdCNqjULOH1ICjw82EZqDEmK7cQ4vwaU6n +pkRsTOhYYtSBYtS/CeFmoSl5nxwAa6ZrepRMDpt1KzM9tSbH2hoMWHNAjk/QhGP6+eTwnZ7P41Nc +C05P+wlDMOYaUgdH3MWUA5nwKWn6x/zMlOcZc0ZaUle36JY3LX+R1n/C9bHclDvMmcfBludmysjD +hHZM6AtKoB+dNCX9QEdN7GddT6ll3H4jmjqhumPKzGLjWZ4sxPgQ4JDGB8X4IBmfNZGojE6k8ZGV +4+A19PjfXCP2SygiPHGEIsIdhzIMtHkipzReTvQrFZkdOn9YBTXgt/AbgN9D7WDaAMABJyoh8yZa +0UUWg7mkPmxEqg38RooEKB8q3Vmm9JWI823pXfRGMLaEmqv1lVPRzcC01kK9WKqoaSBFyVEECSSK +hzSaqGZMZByRhT3EkgYSKzUBKjZiWCE4NeiUsBzITFUlFhgGqMrSH8jVLbTM7aE3fG4NDINy+MkA +Q0Wcxa4y+ETV8xVlZJZxVkmfaSr6V6QpKDAHFfR/MgWYyCLNAiehpmAeZwGGLIpyMsbKqooKQyIy +VNiAAFSqWeKAjrVMUK7WlhU7p+YFWrcctEAVJFyyvQ1NQiJOt4qIkPqsKkj1ixZWb0jZPmqJjC9r +NZ1R00bxPGAOUNSpP0bLTYHq4QHBBrnd2APK9NInkYXxjWmt2qW9w+wLp+FKFWcFv1UNWvnoxiBC +rKMOqLGKNOQ6W+EjqkYrKduqodUtkg1pqAb+N7K6mEAATFKGUiWQAHQCaFWFEEGyd236xsKTBhhd +1nVEcevoblDTI4a7ABtLxpqs/oobsnVMpIc2WvQFtasocko7QFCHlpWENzU8dDLS5g7bRsUdfGdq +Uqv0HeryUXNF1CvyBl1p1dtGeuVbZc8orqPbnLPUb2CqCEM2H1sxmQDIMK2p+ykq1sxjAQNtGSvX +r2Q9LLUKWA/uzZa7Ie7rMnqWlTBv6lJHUiIUsoprX7qI562L5BoUSeU5PVuklEuONto6tduK6M0A +E4shutYhIrtTFsK20aqkyiH88NpFYHsw8evoT5TtHe9TK9osKBWKSVfa2LW61VF7HxRiQhsNhFXc +dKUc90mOVpgsKsypHCOV4aAIqheMpJNUwzofm4N1qiOvA9qT6C9pdJET6UjIi46SJ1pfdMQ+HQhF +OhHUA4zeUsTFhMOeyiGXiDdwWAhIGfUWfJ+9jjWggjo6TQ3OnTPYndcZm5vfohkDwmBhPq6bQwud +naEvi5sam+FVUPNk9BBZ4BRXC9q0ivjeBDU9S/uyr1ZyKrtDI5vvhytIoI5aIS8nbsDSryvZtPBz +aFZwoxLclZ15dLZpo0dzG/Wy47wsdJB9QO2dtBkN5f+Q8/1339zeDXzGIe2oBzHce1dn8Nn/eP12 +9eHn0/fnqys6Rv+nfPW1/Hdghz65I+lpDYugLOZiJgFc4lI2QdngpYyCcrKLWQXKUIuZBSm1Cbsg +xTZgGCiALmYZYqmFTIP0cDnbIIU2YRxYbDHrwAVbzjx89WYj9uGrNxsxEJCzl7MQMrQNmQhB/k3Z +CMr5mzASUnAzVoJ6go2YCezxjdgJFNyAodBiG7AUKLgRU4GCG7EVUXewAWOhTS5nLbTcJsyFHjBL +2AvV2yxnMCAGf+pRGcXolcxWHdWNa6vkx206Q7sQGw2OuTdcRqZ09d3t6fVP58sDZuRAEoR39Gmw +Ql0ZM4NzEXo6r45QJzRe+rqiZ5WsXEtQwGTSy4Z/T2iw4tv09YkGNmCvpzpP1PAPE7S2zLpsLUdQ +jXwA3XtGJWjXUjWlOr2nelJrRdZc6kyR9yq+LvLOx2q6/p2kmVAEZwdPZIq6rp0cpO50HTw5GFZT +ogvD1lCxdiV1CYBpx9eMb8005NOUXmdvYx19FbELfTOxC/xTtVlvtUv5kPqJSfPST0vReVH2szNB +pFkuoTbAJbRshceAk6Zt6ExfrrALLbS1YzbdtXDdVUCRHsAjtyCMDj6h8FmeeoTKuQ== + + + LZxQCcs9GLRSCIOB17C0boRlw6vgG3B2JXz4QqDTqDCKMnI4hBITYFqWHSKkSk9rHgQlsEydC/Qs +4PGFeRNWQRWZJLknB9LHAMdroAu9YLkAhiZ4MPR0pIU6j2RMaH2Qc0pBDZkTkH/oOLmSwkHpScMf +J1TWNLUqBBs5HBQUaqpjY6XECWEqlO1jy0Qc9qZI/SN26TERB3FywHFZHuw6Un7E0RdpPoihnKMy +e92/TXUMqmA7XTOpL31XdGKqVd9fjsqGVTaoOC/ZyDktK/4JVTaHaZb6iU6T1C+GzlG2YOwV244d +7deUziueTHhc9zTeHjnKVZqXk4Ni8DpCdDpYha90M3XNQHoQyKArRJ1i0t1iOqRiOu4OZXrUKdLb +fgKLVEc/y0XCnX4pFJMFSfv1KiZrWkzXvZgiR5HjTrEGt4o1KFhMEbVYg87FGqwv1myOYs0eKtZs +tWK4I2P3Bhu3m/1sezf5QhY9UhVTUlEkvMoISrGG7mR06SR51QiowTnu4TBU6edV29bx4Isis0ii +8FTQTtYcc6NWC51qncP0Q+cwWnL0e53q1pPRjNXqirCxrnnA+qOd7/JXsR9ZDamhvp3Ui7w3+jLv +c6whdeqknwH4QJWcQ9mKepZ3L+LM5KV1XiYtDHqhlAjvbNv3NLXdj2Y6ZNsd4ON5WjOd00lfszSD +BbRtNpqin4w12KCY0v/d0DTeJLP4ZKgCm0wI7V3DWaMqZDS1lNGH8y+gySJ99Wa6lOgYxyMs/xQD +VAAcYYpaIsfNrcE7NRoP0ROSxQSLVZiazEfaCtnrYvh+igNZm0Xe6BpM6MdRDAcy3fbZ5BTDuSvi +5K19vQazuqXKELBf0kHv1o1j7YjXTk43d9eZRFWFqXXSHUIpU1KYaWNwAIJ623QYMEjZicRqShtp +PJ1DK8QFlkrHjBp25Y2xppNvDA87tajqgdFYi6Bx1cWdwGNTdYAWqNzgHISbKnWJnnqYTmHRQEHj +GS7ZIlA2BiTSeltGt9VA4bZzxkQ0KX7QDYj9K9BBKNGU30f/ir6DBmFTENah5KwpzMH0rPH5VjVb +5J/U6I4fiM44OUgvaalGoBeJSlkzEDtWCgappkavm5qTg9QdncAG/cKsUuOaphlMUuVtq4E+XAyh +flDNRwU2l0wJE9ZShTZ8QO1U/wEUrq4t67yeIi1i1lyxplfdLGWd76YpG2OxZiq6icpmrHutBVyC +jedfmwPjkeHRYDXrIVIWaf4y3C1y5G2Tk3WP490WOHnYQmKDcz7QQmKECZEihg7PZip6wU3ZQCfo +oEGH5tjDyZrhrWBlQBREEGukMzIfQWRF9WP/4QoHm3S2ZolG9eprirbmsIXCNtgWu18YoqOzjVs9 +mtuqFKA3dLBlpQGjuZHkMSNHT2miDmxIa5R0j6iNGjRG9EaNIyOKo8VHNAfACdUR4CZ0h2R6KeWh +G8mY9pC2j6mPAKf4T+CYAtFoMKZB1O6Ptx6PoDEd+urNGkoEff1k10MbP6FG0LVP6BG8hiYUSc/H +jiZR8z2hSvRPmtAlKrsnlIkLt6aX66iTHuRj+qQa5uk0raNRqlQeUymFTtdpHaXK8DSjVRlKZ9Qq +w/5iiP5TipVvpskR335+pang6eqPt+fn15+UZCikLEPCpPgOgnD/wOAgf1hXHHzpPBMEMPZTkwy1 +wWkEeRkNjUKK6BXuQlCfvhqWF3jFOi0E+lRaDe0PyE4gkl9Vx2DMOssyxEdNMlQj00p8L1vYeHXm +FC6MO9U6Y7jJhSK4lGPIaCC7VaOFwUfqtG39MMcQAWcxMGL0Td1ahqeR0tCCEcPPvWBzzKASYudD +U2uqCEPPThgdW435cfIP49PUgw2gikY9IfhVqUmGGiTGQDaA4HQL+BqWSfwNLiUZCurzrOcAS2uq +gMqFmO2iUYdZ52xyNHNVSR8+w3gj7Wez0n7TVCAYzWQACGWPHg8tOwyTY8y7gawpsDgZo46hoWJ4 +mnXwxNSENw6LJvS3br1aZgKsRDXCYKOfokE4MzGiS0yEfhNpokOnRz4AoFVj1YDnkXAAmGddiDmG +aniLAjltjMUJDW0fZRlc95xyDIVGbSvxZSxd9MVjE0XeRuxH0XdEe1r0XY2jIYJXpY1zzSEX+Zg5 +K0U/LXHqinzu4vwW/QTHFSiyJeAqFfkyxZUsuqWMa110i50QosgwImFN0aNNRKyix6yIffoj2Iiz +TWViRqIQHT0r14SIiDahOg5rbTjhuiljQoAYGYj+ulU2AG4rG4cZ9xX3nuYd6DafbE91yh/u4SLf +xNzog69IC6JVjPFtJBg2rUblY4Yh4532SsiKX0WyE015dZ5gKBGmRLjSF4myFR1pA3a4ton4UllN +L9QYl1LphFaxrI7ReR4JloiLxpuInXUb0wvB/ybicKXpV1pmaIoEO88vFGKCIZn6YDoI6tDcQLEO +NMQA2b4h0vSUfwe9QX9JpGJ/ifFt2gOk6Ri4jSnMOPCa7FadZqbPLxSnDnOrSX4IwOTXbTf5lpTF +p+QOtJVzFZtuFanQdTFVQ419m+cWqnUja6BHO/imbpO/c+WdUr009Yp5upvajFICgd0qJ6VONyeR +3GgyF6HnYUCSm4rfJKKNjdQOdpTuo7Tr4mHQb0wNaG68z3ev9iGdMibEY6dKm0pTt3SUwpHODqmJ +ZsgjdpLerNIm0G1B4ztWukEzoFtBA8wDmTCStqbR87yO53ubygSgBWmk0UOSOS6UirarhGNKasm5 +Kx76SI/Vkzuj2GGVUfOM0BshI0rKg+K0bSJbEhSly6Dj9iVd5aX9uumYEnbQafwXPNZ1DEanN9Sy +xzhKz9llXkVOQxWnyjMPjitJ3nQu9WgsObUtSAxnWpMRjk7X0fk7Pp+nR/j4lB+zAUNOwSo2DpiJ +MbcxZUjGPMuYqZnyPYk8J+qciHOiulP2asyBjVk0xT4X0dFqciHjNQcUiQLtwD4xhl1yoUhSSHLK +EJ9JkZTvJEEi0YoJDZQOJ7IWqVoie4nqJcrYE8ZEPBPtTMR1RH3j4/GYwZ5jSW6DqjO8begBUgnS +1UwdBD+udl12IYvEWNGSnB6KYIKsNaTLYF1zaIPQ3oktWdjK0DJzkPytmL9CZkotxhAj8UNw2Dcw +L8uKwHWnhP+lnIqT7EKUINbms9OcAEQSzdbkV0XKMXbMfHauTckFQ6357Koun52L+eziUWEYa6f5 +7GL4P4Lu6ywpQuuGOYb4fKwJ7VLqP8ccQ1YlSMvcVSFmtOvyDjqNA9RIGOa/cjGhXcpfN0wxhOfj +mM7O5V/k2ezqmM3OrzrHs+OYzk6H3DAFXsz0FfPZaTKwLmNkjDDNs9k1MZudXcUEkONkdq0mGDJM +eKmpx5pVKhuT2bUxr9kqpkWN0RalSZlTbco15lYxl12XOy0midT8N8yu1nlkWWayi6eNbVL2sBAT +PboYnGp9XWeRx8xk52ImuzZmsjMxk10wsQzTAmqquKB9aU3MZOfDKJMd500xkXFW6qw6TGVn+1R2 +x4NUdqXtku12JfP8p1o5c9nVq679mLSs6yBz2dlVNgbmsgurfpRdKrsYf92AwWbaNY36zVPZNe0o +l50f5bKL6YW4YkSyVYdQxDCvK16vugXP0MmbENPYVYpdPozS2LWKiIpLEe0SJmVZ7EyXw+54mMOu +DKuE+uxl08YkdmkcjW6o2mtwNumCJrFrV9kOjMHacQMOUtjFDHbVKu3gNJX9Hk+pRRMZYAq7KqU0 +rvr48Y6UZJmGCDlhXjumg4oQEqgyZVJuOxrWk7BE5hKVS3QwkcFEKntKmahpIqbrEttpuqFG8wDg +/TBltGuGKaOblDmvrjQ8P+tDU2c7K3ZSs6VqbHAch6ZU1XQ8HKomXfWmm4s831CcQCZv5ejSN+NF +iFkuQ7ZOxXgpR3mjkziY4UIxQpZijEyRbLUZvhVjlCzGOFuMkboYY30x2hXFdN8U461VjLZeMd6a +xXjvFsOtXUz3fjEgD42eSlkqzC5dtJIYeIocp3TRhlSoToHBcG6NVKqY0jE9rJue1BVjWjhIFw3L +xnFKF91T1GJEcYuMGBdjQl1kmJyK5+miUxsJl/uODNJFV6EfT5EPKI65yAbNWSn6aYlTV+RzF+e3 +6Cd4cB42rl+nIl+o/Fyt+oO/6BY7okN/Nhej43vVoVTR49QwVXQbkbV2PoqmtorF6e7NTNFNbCNL +FK27ImoFsp41PmRcS5GId5HvprjjinzLaZ/G27bI9m3c2f03ce93nFhHIDJubZwlOqw6QlNMqFHG +GnYkq/8qUbWOw+xIX8aGaqLoumdVY6LolBOcrTBRdML/oEjCEHLX88UxUbRfFSNiXiRqvs80tM80 +tM80tM80tM80ZPeZhvaZhsZIus80tM80tM80tM80tC2ZhhAimRx6By69FewsYPBr0yC7wVUPQ8Cn +apEY8El5BCYTjbIQ0YoCjaXMptZ/wSAVdkOwqthmwltIIcGGaHHXu7/aypnkD6KYJ6cI0+r2DtxI +Mcv08jhXeMtNgMW/c9WoGYzPNAO1LqSxNqZ9TgHdehsAwnNddxGSZbp8mJDKOkaClHFtDEVkRKRY +o5oWyu3qpUAjplMzBtY/RqbJSiRnhRhs7vu0Jz6lsq9in/A5z0+Es6Tk+ZX6iIVD+sWpE09MK9BK +XVHpYyKKMzqYYmsVZ4erpD4KJhq5q1DGgGsXrymAKoEQDeJOEHVOasuYIFe/ag/baFdIBoZw2DZt +jFMOrY1+UK1xkX56bkAZk8YXYVnr4JU3rmNkNCF0uOIUZt/I3MQUurrrkZghVmwqzVAFi2AZs1J4 +XofksG2iTb6in4lMiVcPCdj0dN0Yoa0mnoY3TZQaGq/uqjTBlLwEpjY9BJ4KIl0THSPIUt1i+4oc +cKpOjTla8JIcHTvkYej1dd/ninHmNh9YHcO2u8HXyT0yzQ80PiZeWBGnsKG23fWgANoRJ57jZQxn +TMWQhlSScPZkErigLWHdS7KD3teuB9Cu2qRbzdI3MSFBRS5GpqEqB2goIEtbCUCGTIsz0deIaYwB +SBsUmirVw1sbUjOBSkUaEABooRUzMQ+2poz22rUsYXQVU/zHwHZNbJFliw5q8lVdUfqi5L0eK3Wt +0Cz/VUr/rdfJOPXUtPRt0ST/JrqTkVzVUX/fAWj4jZ4gEYQU0UzfDBKPJA8p0T8BIJrAnapM1r8S +B4sjfYuji/n+SZRSPv4zJvxXx6Us479RV8k1+aHPDopB0vSY9N83WQ2jPNSacQhdccnsWAfNid5E +Dxx2dpTzmiMqJsNm9mwTbZ5K7DF9g7kiWbE2kRr9KsCQVjX9MiCnd1PF6SKeKxljAgxdTdXHuzLe +FWirKP6HkJ6VYDrn8g+UuhOjmi7/f4513UUmRFU6GFPzGNNaMJ3LKCt6zPdEL3lVrOeXAKgHW8yv +HpOvdz/UzbJLvp7dA1CrpjS7CCBe70dm6+xg0JmYjh0dttrh/C6AVZdk/uwgYy3TNQ== + + + LHaarT4mUmdq9cak5mRljGa+ryO58o0usixjJN3KIwi6NHF4NnnC9ynSI5alO1E6jO8y9p/FWwE4 ++cNrAYDiRl3Wu4sCypLk4eygB7l0viEXSAXPAhzipe4Evb3hUDki1ZSVniHsbWJkOr4pQIfuV1NO +6qEcWmX0l5jG4cs6wmytcfhInoMdH2xZst/CkeNGkB+uDupGc6yMPxQ4EuykL4/OZlZ5dG+VpjZw +AnVZlV0Yx5rIjSlDmUGXsZRR5FrOVKoMtQlbqU1uwlhqyU1YyyjGLmYuo9i2AXuJkhsxmBoTsQGL +qSEWmzCZVChsxGYyMGQ5oxkDOJezmhjjhswm0kstZzcRSroBw/nVm41YTkjUGzCdjCtaznYyRmkp +4ymFNmA9tdRS5pMdXMh+Ule3jAFFsNUGLCjWeAMmFBi1nA0F9i5kRJkVbQNWlIqjTZhREoON2FES +oI0Y0hggvowlVRK7lClVir4JW6qnyCaMqYbCbcKa6vm8AXOq6ck2YU+1yU0Y1JheczmLqlkHljOp +yi8tZ1O13CaM6khR2HaR/9/BVqWZKtPQr9ScpsFItcaiNVbvTAw8161TItrxcdJVktoCnBVCI9F3 +ZYLgwaweyeqHW/KOVA4HY9EckMjlp/6OykPZdI1eJAvZnAM7vHr0uxLX+GLf0d3BYf+pVnU4oONN ++HQ5eI2JV6gKe6K7JpjKwbkWKWUFiUH7NUibDY6/bUL/2dHZ7BqP7q/RtzLxQovyau9n1desbFQv +L1lb5pnYYHVpg1u+vlJskxV+AMHJapuMsb5i2obSZNy3EDVlwiN/jjyQZsjE2y7nJXIJxztLQ4wH +bumKadMFa+B2WqvOs5HwWjWeAKC5SYXHq/WGUkooSvE1WqO/Ao5h6dmtgySkpLfVgN72l7UNLujM +6DapejUg7/KLDCNBWA4AGIgOYQOrz+DmOnoT1g2voJRvTfTyJsNMwcRFSwjEvMl8byQnNwiaiKJq +fch8KDLoFrEuwH/sEHQIaaSDdnL4KTdf+urobG59R/fVV1n1zRxUev/eW4N0Gqm/FO00lfBixOM2 +Wop6pA7LkU+z0yxGP07ScgRkseUo+ACB6NQEyDAG/cRVn3ArMJhcWUqqG5pIlJJSggFPVdKPeThS +VFAJVImZNAD4qonxfC04YAwTKTnU3wpctAyJCSn4jJFLGZMaJsOSLqVMDVEs6JkaMj6BrKbr+aM2 +ZtE+62+kHF5IGerVgM0K1WqoKSyhC6CbpVbLrE72MMqgQpkRFQNpCgNUXzBmo0bK3yS3ehUJmZtj +MtkbUQdppGrrVvco9BMUpIMwzxS6gqCYiKeCIzieGwiKbvwt9jEyKfXfIq/83HqP7q1Xdo0mHx5U +/JBCbYJ9WY6rBfinpRZjoBZbioOpsYVYqOz9UjyMpZZhos7sUlx8iEyQSteakt4ZusOCKsJ3EJo3 +VyfnaUSl1EkvCCxjGEsL+VkdHy2Jfy2HgImBtXDhxWmQdIn99cJ1MklQ+wU0oDTJzrSa9oK6Aqa6 +1vDDEKMroPUIGt+oogu4RkZXQGgNZjUZ0oabsYZ3O/eBzCRd5UUgbDlw2Q8Ovu5MZ8Q8/dX4U1u2 ++kX/LbfirFqP7qsV8YickEGtD+zD6fIqcOkCq7y9eIlTYwsXWYstXua1eI6sTbL1783b9NnyyHz4 +5fzutxoUqok3vztAGLQQNsqxXkhwS0m4Rbh1l1zmdH52blsjjFDmpEFqWJ7oQikbWTgHjWiUr22N +eBED84mqm8q68R2A7DvZjwRhpkmLUyNBWKtwbKlWeWYa9NjuMU4JZnGv6JapebzXgIbdPSGefssg +fyhKqLl3jHdNEKs6fHBMraaq1tgearyq7pkx/7y9uPuiGdXQDNvQiDyrcVycsZMeAu2ZZSt643uj +X6RW07PKFuhX94Uf1eCHbRxPxoo5cBT8bDb+DhJ7L4WMr/vxCieo77vx18j7UPoOUo9qqEdtwNtV +If34O0jsfaozjS612o8/9StB3KgGN2rjeDJWjL8Yd+4qA8X+F+gM2Pk0wGI6BwW6U2VoUoznsRg3 +r8F5o3koxsPoKk7jLKZT0XWw+2Y8ncV4xo+nI+d0EA8Hs5EgaRjEzCabDKLmYC4UNUP2iR/V4Qet +6JENSDYRCZJGkCrtxhjbzaYhda3/pBnV0QxaOZ6MN3pGIwiI9hIoSrzIT1dM01h6VdGkzIi4y0Nv +oqBQqHlCmfBYltGrjauDYDi49VydLBQm3F7Ly8m7mnCHj4EiPsQbLIoG1ow2aMBOTZZSXtYuaLJh +Vw4fmWPD9LAC7TSIprLxoY5vgH8Wt06V4A1P+GRjor6uHhdfo530m4irRkCXlT4MVcA2FKYcGmIP +lRQ9e1tTE4+HU3oM6pN1/gq+SCbo2NN4SrKXpmGpmjcyIAaPGRhRcUNjoGmZnNVFQbpkCHrWu+OD +rPcnBzq2uoNk484mRAplk3VykM9jqqHraT4QDCweu7CTt8yhJvhFPvgKE2Xp3IukFTYeTsgjg3Qf +YK0oVQPXqZmOgJLBqL7qSh1rSuZoMLKOmwaRZZYW0Ap3B7hVD6iRMKJZ9YUaTaYXgy/oDRDtKkzk +3EIaE5RAgiLmY1dzdAdoNKVLKnOcjVX4NBc0p3eQs5zZB2TH0QGih0Byo9JlMkfH8WzGPVYa8VdD +++A0nZ3seY0pIgj3PXgVanDYI7tMBvLID9HW6rWVgBBomGmzq8t0gXCpwQSh45Zn4uD+Ky+8H65z +6mvqIFmDHazrV1dT6vt4fGcpLuO+S12Obm4ueauL++vp3d357fXvr09/vDz/48eLt+cf9FIX21/9 +0n307/c3t3d///V9vPdF8EnW1kMzVipb7Z1qwn/3t/PTyz+f3t1e/Fu+G1TSfn95cXb+/dnp5cX1 +T3+8vXj7/57/Gqubtvg3YUY/3N2eovt9u4u52I+Xl+d3q2J1dHr2y79Ob99qPsSFt8gYxttXMeGy +RVQpn+nFvkqg+ORT6CDOqJistlp1BYvh54Xx8ReYq/iTuyf7aFhDV05DsFZsZdCTwZep88f9OOZf +XrKC/0KJTEUyWUI1ccPVNHWunJVwKKBolx6g3a1ErAs1pKL2s19ZopO1oiY4ZknDgFeaqZNZpbpJ +SlO0Su9SGX1lXTc5XWJifVlkZQr9mIvbL23fXpF3JC5rt6irdH2BuqAQk/RXzHDM3/yvf4qt+VVs +jKJhFb+IH0SufKUSQHyRvtSiIPOxw139XSOxF8cHXXc2jOtiVVfxV9eEgm1n4cbPy5QjdRWHnHcm +2mvZ38vudz/s9K6Idcaf+LR73xWJ3551/bscidS174Ix/iPGY3Si7uonZiVRzxFdMMaM4Cnem2EY +yaI+IXqDF4DR9K2AlDmBt275mAubD6l8+tEXYTPx8Th1Ij7r3S+m/2BUXd8UAxxTJ04Oxl1M1RTK +uqZxpoMTiSw8rcw8p3ldI/4iBwtf2XT3NFg8mxLI80Mb4+PbtivbPSd1OoNlTLrkRJ/St30hs0ot +FGzPKJCybry/kI0Pmo5j1+l+QFMmXIRI88wO3pYkRJWr1tydGu+DKqOrGDPveWZ7WMU31GRVhusW +LNOpearSiv4DV8VcmA8VrZxebXl0tnGrR4tbxZ1SNdIU95q39RTg4WzhsoFAE75VR65+3yT/yLRz +NJny3L2TFMRx92SPc/dP151uB/GS0Zl7iNa2fhdlj4/tI71Zr+xpTRUnKhJM0xHMB7dYmr64ydRL +ddY2S742bdf3JVstklaTkp8/vN3SeE7uH7bglBlDafn3PYFdT1ztagiIRAT8gA/0DdarCBy9HA6j +R0/DJCoQPw2NM2X3C3bm4TsWbtqucF43FIyJhmY9yXsUO/6gCwssHrz8DcQG/o3IXHgvrbG8+php +XSme5rsW1u1GcyNmJIYxmYfMKbuuBBxYbNvmlGVmG0dz2wCrhwSBGR351Jsl/9Hx+h+H3Hph4jWa +5lD7cHXQ8KZo+jNXTaix0RPI0Ek6XWM1KHfvCWEdF60OJfIcxiNCJFro7h86IsB4VDH3MH0O+1fB +1JX64Aq5rtRjfbSCHtqc9rHCLl46OzwmFrZ8tEHLMJtWCMTNjgrw8kIcIHWXIuGLvNrgR1k25OHr +0NiKXL30uwLE9Ckjhb+vwcwzcFfXzvhKPr/qQFAA+qaKt5fwJmjDpR2VSAy2HIP6AhoyqH2uDvQO +6K6gvoci0VBTMSmxFvSQWP0bXt0qA65/u/rd9yL6Xv+0+s3R0TdnZx+v/nZzRxk2w+rJ0aknwpqe +a2B31/f+m773a8olIrymp7/Ln1e/+8vN3d/Oz25u3wrm/yc7opbDiveMQPfog4H3i53I9cff/OmP +ca/8/d3N7ZW+iqOUzf325sfzN9/8qX0jnfj+7tfL8zd90/rVwlnLDo/wkKHr8+k4nlwp8e3Nvza4 +oOHLVEc4ZsB1wVctVXa2Kj2v9jHwRqrDlCh7ZuC0q5QClw+FGpqbmjxzUI+JvW5ir5vYOt1EU0cW +OSaJGEhfn51ptmTkcr64otIv/RryzJU6C0aemWU/P8sM7sQZOBIlptk3OPMeYppdg2SK5h6OFmGA +Jox5LmyN+4pUQZ09hmzzrFaOZrcCAZxGgM/HOK9hl2v1Oom5lWlEigkrE+wkhxkYNeMVwBpssQ7U +lWQDMY40grpYClzDXdbpCt9hPx7jvxuZIiHAK2W/DXMmPsB+03PO0efBKgnvudgQ0DbnGyG21Yj5 +ht87ToiHizaO92+fbdzm0eI2cUw5+/mZbpfSGiHxDWzbVxlIllqXJwOVEeS7K8Y6EMQqvVCmA+XL +X7omXVYv4pTLP4ORN94a1sPQ6AOwagqLQziZjiqdbn2vebtxpXcI2658ox/n/enagW/iEJSProkX +38tHxg6+ymZqCuqaXAN6WNqIaFJ+irQx6drVANj1hHG4k1kaQLuxadCcHQPXzBXDNseztaZTnybK +FKARpmp90DBY6R1EyLp+Emlm0apk53zzSqSZP9zc7i2sewvrXorZSzF7C+vewrq3sO4trHsL697C +urew7qaFdWJPvTqYGk+LNSbWNYbYZ7WxGr2Z414bK7he+1hZh0ixslpkYp00fLS84aeysBZrTKy5 +PbVYY2+918ZarDOyTk2TuelyWmQ97OnNrOs6z4xQmZl1zWDWFfw82okq4P5Ks7e1Pql24uT83d3e +1rq3te61FHstxd7Wure1PqGtFZf7MIvR1UGpVwBqxkGRRwxNRwmWrK0nZMVihO8YlIytWcE1oL76 +rP3PbVw1CLxDKGxrlUD3xsoWbQa1czK50NC2igA23Nj9YNGG5qWRcXVJm0eL28Sx5L0wzZ+Z3S55 +pyM0SjR5OktcSLBkOjvJYMmUCVg1geGew8atBSWDZ1YwB5X3gpKxLQOlzioWMQi3HPSy/yDdPJj6 +Snte2ZJMxi1W5n1K7zNQ3wHkpm3cOshgrqo18zdufz3sQbHic0gV085RqpiOogf2gw== + + + zYqvBfbjUAtrN7t5u/lH66ZqU1GlSLQAac1qwfoAO9QTiCgbSiivxn76t4ufft6LKHsRZS+i7EWU +vYiyF1GeUkTRy0OTHBFDZGyVSxsdKJNJUsF1oF4Cob+nUwEkvc7lk2HjzyikBB3QfUIK0utU7pGi +jdU0JrOllEmjYw/Qxxt9KimF7pVx7aKQQhOPt2nt+DqXChTSc6kJ0ssX9N0bQbDklV8HygSaVHAI +Ku8D9ZztZBidnSLVmAsnEZQXN4cpB8sENhhpNRk7IT3nzVLOp9kbNr4W9OSCyWTAKapsPOQMmgsh +02H3sFzkyIeetToUXSZzf69Q8sVLA/94vxcF9qLAXhTYiwJ7UWAvCjydKJDYcHL7tU+BYQQhY7Ht +47bgi9eDNKrD68XZvrRhFaPATP5ZEhTWQGKDJ9M+PGVQGG/vGfDYMjDlzpFYfU1MWHikZIPEn80D +MWGPNTkNCXukSRxPdpCy/vOIA12gjqbJ6ASCBoeIAHQBE/fWQxJ3vg5SjSGM/IvLruLAOlBXLgOl +yovEi2agFICWgaaj6eSCwasUDJYikrK2+4amoC6WqZuPKaQrxrrzaqY9uAf4oIAgmOeNsD2fJCCM +B3k1AGYhW9OBZrBuaDG0awBZO7IYLTac8jX9+RQvq0LzWeA+ViZ2NdJXOmw3T2HBWLQcr0lmubuT +gQiJWn13e3r90/lGIWCw/uJWD/hIx4OoEXYImfATqAjVYbDerpBE1+NCrAQokS41PRTd61RB0dWQ +WukgxwcENRno5IDlbA+Z1Jy3O+5ULJzKpur7BidDvfe8M6FWbgcas7rjdsqqevDAK4TTqA2uGzVN +JUcGDwW+wy1JZWj00iHhSMxhMGU14nuQNl8vD3y4NDyekT59FEuxsO2jTdoGYyT/+fERaJvSB55q +rS1xeJrGe5/Uag4/QH28XlwgQpne5YdDkXmIOlRwiRuS1bS8byWBZLldxAXPq3cToJSlTb/Tu1Q6 +Fe6QIT7nyOA6foilqh5UjKst8jaLSY+6CrpOZ3jftTwZbJdCKdsQiSfM903WzcBLEBOsQCgiexIE +ZZkOIEG0o/EBb3nPVKqhqyDbGaNe9u2OC41rzZucdGjS58lgj6fjv0+87F2KR93mEToZ3GT4eU+l +QP94kj/2kzmd8MmyHOfdyQbw1Zs1oxLguMZJo8M+Drs4HtB4xOO1O866kfdiMn/3AnMxuHLrZfx0 +8tQ1r45C1vgS+cplL3ukVFDDRHybXp5MPr+XKLc2SqDBtX7VhS14qXpNbBuzujem4rU0BhchNTlP +X7bh0CHQR5h63E41kEFlXZBvQqOhHiwbKr26W8jh4gaPNmmwjJdCjujvJ6rHhE3jreYuJsmXJXOH +MbboJL1NL08mnycCVtcKrw6ZJf8qAeKzkJAqq3X48RrA08ckTDos+yTrYvdB16VJkS8gFKHy6/f7 +57rwSLlY+4lcrLATzuCyncTAVi7gCeScb8IhbrVzPUB51/hQdK9T2QKFU7V4kAMqe1JmNX04qSZv +ZNyDrHdZt48Hg3iUNRUayJvGI2vqhAGrH466wy0fuKvZNMKv1DYMObwaltRaI7Bw2+Ywxtc3AuQd +Ww8XDiBPk1i8ZS0fbdKyELvDpvncbGm33hWNO2DvmuDiM9qOa67X+iZAZICsrrm+S0VZslvnSs0u +g+fIh3YfF+OqirydYtKLYtjLYjiI49GgOt6zR221Yw0BkevUCzZq9qqJ7baHxvDi8gTRbsUHvOWl +pam4lu4xfdCn2Nbg23FNeTOTTgw7ORzD8cF4TI9xl3mvOtayH0TeM94Vm3cNjGT3eJI/9jM2mtJx +d7MupB7L+TSFDGqZtDLs1LBP4xEMxjdao77pruViBmTAOVbZjZHZHrz3h/7LMMpu2Ljbu2GmWoCY +tCiCBHHCYevaDCT8GW/XQkwldWeh1ouKGErr27hTcYcObtwk39ttL1hTEBLbbTH2y/PO+MG2q1TA +ifeA6+X1fe/0+fhgsBMBynZ6AhWTeot1rReTPhaTYRTToRacDtztmaajwIz5MpvX6Uwjcca6KyHX +LEnEkeGiCHCDZaGUs8HCaLmFSzMYTVoc3e+bLI8KkRssEAputkSjjVZHDq0dy2btoV5FZTWgXVh0 +nNjBdJCq0QzENXRMUnV6BiOTfhd8KfORChdaulml+jvA2UEjlMCbDCQsbot7uLtaEoC8Uvydmk+l +U/fGAzieDGl+CigYM1v0vkTotw5S1iK0dg0nBbUZbnXUVFDxoQim9IfIJSCcXan3jfeuC59FMusm +1GgWlCtMKM1XHUjmzMcJdQ2cfhKAR2T8nd6l0qlwN33x+RgYgevuOogIJ04xQmtIz6g9/e6aToWL +cf1F30AUFjNUiSOrcWU7s9hFkCBcql7viUsAtt2kfum7VDoVzhAjNixjD3D2S5Bg09xoDemZ82a7 +SdWXqXAxrr/oG5iA7ucxBv4QfcNX2dO4Za3Ujgamd9MPB29X48npJw5fT+Z1MvOTkaDYZAomk9QP +ZHyLbtV0Z390nxBJWm9QFD60xPFA1PYBtz12xPSk+wxf2TaHdAU/T6ILWK0oIcS7hV3ZKcFVCSOk +yDS1KnAaCA0jlZGcEdRkPVwYPJc1TVQZLWzxaJMWS+YI+eypLWjb02XAreJkySq9/zlqjfg6vT2Z +Fsj0Rk180bq6sqo5arS0Qk6AG33d4wJrQc+iP+obbcrIAsWO5kjcf8rulX4A64p/AdqkLrFF+3nV +SH84/efN7cVd1B79R5IxPue92bjMHNc2Fw5+VRXMDcIX1rxNNIEg99SgmwDAoIbsZS2UHw6sYNWq +U2aooWqyrV7xiTtJjVdnzjY4Xqmt2aysPh8fJEiLHDbq2IEMR/CylE2F20ClrLzg5dG00Cn64bbV +1Dd1O7VgfbuPWEvTdLXwmtnUiF4z2/XiRO+oNbwOPPa04GAIiYPhvbxoNhsxRdOal47GaSk4c67q +Z67g9OIwyfrbpLt4u6+kXeHV4GDJ23WrbJzI8FNDRYD7ouP1nukrVITUMf1CjRfzuPO5jC9kZGmV +kbDH2x4UYEsJFVvknnZsF351Bon3jknajU6ITBs+cDakD+g4Gg6DoGZIdegtK7ya1I0nJEGO1T8w +lG3+VU03KAJ4PawA9GZjJ622msxQTnNj1B+5DDW9IJG8FBBMH+dTD/s6aP5DPNKiXFfqTnpoYBWW +2fZWRqUyUSOTusIRVpkc4cAes7v8xMdPcCW41yRHrAVsM+60VbTWlvRq3Ij6daAilF01XVfpAQrN +Xz8ajtibfMicFd/PCuatabJ5myzz8XTl73dvfWKPkQpzwHte5a9beVwFzOterbcqgmzXda//4/yS +bvMku98+AenFzraNXpNU01fKQOIILf04A/LxHuoly6BYJf8PNUkGLMYlinGluDG4UrQBwuLG6wTo +nlOZvkiqNtWa2mQ/2I0MMvp4UtuouXF3pj1+BzfuEvs9/b3SvKrI9QciLxtT2C6KnEQd7XQGKsaf +F+Ma5Xs6l8j3AacbyUYEFB2EX5PG9cVS1UVXd2q4YGcK9gYwy4VpVpMSqbas2knb495NB8B9jKCH +2imF9M7V8barkpMgWw0eSz7l0w9CC6i/4bmRQXg/dMzEmGC43j0ggzTqkWOUtLOl7yNVR3Wt02EP +S+/U80PEL8sfavaXFa4bo6+EGQ+8PN7BynHMK+0dCR5USMI5qz+kCtxwGOD8OKgkamaNg083fHpS +HjmkrHB0gS8sclhbNVHrQpjuK3J0YPYtDjfbQ84ODM8m04NEzms1SSlC8BpYh7GGeo7pcB28FV1D +CHkLmbaSER9tXPAOEHA8yMScHXQgWZmqrhG7FscpNJFaPAPmydJhAEKE0xvCm7JtcXW9CKZ14K3p +OCcDbwgvpR5OhylNxQvZcXe3bD9eER4YegIVkLeGF48779kOfOcbbQfu9IdwuOQkivxSoRDOFp47 +IMy4B10+rfon2esVxnJ8kIFC8I365crcNENAoKR+qOpB2QicWFl8GqSlX7VFeF+IaOjjguMqcyyX +TBB5JcOMpvSLw+3sQGEXRfhe2jz0ja2pBWpaveBcTm4AZALhdoxpaINHO8BRV3KUdQNnB6JoTRTF +hLoeEOKks5CC0EItjBdcTitNxepaOeknmxGbFHxBIKeEntbWqFs8WAPbgcBNNVXLJIEONtAegIUp +gy5RBMksAJ26SmRfemVWUksRInRF0BIu4AniEU4Loq11dI9dKx0kdqSrIPV0Mpwz6tKf5Y542pe3 +kFW4uTqPrIJ5ElbB+ajdFxQwIUCtJKelMN2aQbmVvcAomAhypZq8ToCy94LA0Za1Tc7ilOrVZ9KR +PWajipq2DGSYYTpY8YtWAdVhZQP3nsj8bZPDWBODcwBo1wC0FABSL+Jf+ponAz5Jmc5LLWtrVnYl +B6AaGiLgpAM0fTcDWE74lE1BXbGCNYewBgIvcuYv0qtadKLAsDe0qaQuZZ+Nevmw2ubzbRI5Xmth +8Ss5knFweOxxzZfcmrrdwo3z3e2Pq2J1dPmR28ckLaqZuy0oK5HzJD2+6iDOHiqpDHpxDx2eSZCL +DFTw86r/vAOkGnGaJpCgpB79sQKLCCOD2KH06+xg/K7rYSw87vHZDMOOc7+NHyAQwni4i+BfBKeS +WXE4cCu3kvMbQT3Ql0D3y7as0kvwqF7oES/6oDSK2z4a6a0TWaw372yippvZp8+vr4taTAMxdjiN +9rFpnOrJZfBDp0/i4gAPhUy11gXG9wh3h6RvCSTC2CE5HaRrboElCSBMW0vWFajUwYTyGQ2YZTUQ +yXBWpB9EJFNSlUMAS9Z9yf65qz2BUg9SDamLff+Ps7HMsixCv6lhN97T/Ctss9NLZoTLbtbEDwj9 +NvKP4l564CUzQprg5WuCHALCNE2jooNtHC2HvgTLKs1WAVum96SgVdGAwsmZKrusbvUs5f0JkBUb +WC1dfJZ5qQKnSuqGmqkHxLk7PkggskFVs0o1QAhr0tzx1zEvzmjrJnSggqWrvnQHyFrIYLEbXT3a +zdT9pLLDcx1RzfI+iZxgAQ9kCqsckrUVYVAQ6cUBsQ4HXpnjSb+OlWRV/btEolLh9JxPVweKvUh1 +FBpY4mrVFlJRuFk09aTVqwyYujbuej8sDbYejXo6L5PJY7npJOdroONi5HU26smUTAYwNh42/aUK +kGfqntJAmLM0aDsaLOFu3sOE7YZmlt66DGrptM7wsobUkQB62AnZz76x8IG2WS0JkJo6O+hAEDwb +n2KrUQ1Ctw0Fz9RWB6F8oh3qv+o63Vc1GducI9D4h4g3xLFIavRnwdsNWmdr9S7XW1o6QoPpDtl0 +G0iXjOwS6bb06ZrvCPMqbIFtNtZF/xSNPD9MhkoCVG9GNjj7qBGpNFRZPR0gNnZ2kMG6mz66itqk +0kitRYBqomKXuo+6XncVjcf26dMt54xQ/0onPD1oItRahOBgobEu9XrKOOMaUgszvw== + + + sD0V4yc6UIswrEatxSlFkKrOoGVyoeoAOlMQp7JvYhx8X0sEpJbODjqQSOlV9NnVWpDctnRZSwmg +k8ve9N/E/va1jMb06TMLdQgCPzSXSHxALhGoOxDnVkLNU+W43MKVqNSLeTTIuoNg01phLhoSJMU4 +atp8jJ/vANCFueg+FkGyT9tgVAka68lAsTFqqTqYp/Zj1VUlwk/VutA3lwDQjsYuJVA/jFjLeFyf +PrmVyJi42o6Tmx7AkoCJ4KVMwpSjqZxQZPyf7OhG4+BKekdd9ZA2xowIqafCtWDIXACCqcKpA2Cm +MRmuBxmI15CzUy0dIDbE1ekgUBiuukqQLoFXI6WGEgCan9iZBMoHwFrGI/oMlBj+fT7R4vhQaKIz +iPq8+Mq5XOIoBOG8BanDGVNr+HwHQ4wm/Qqh1G5LqouN8tCBPl+uhwg2tkJ1qQnrvjJQV4EX7Grq +IKk9bPYEExLmbOBixJqg+iWl6dpLkLODvlfdV13Pu5om4/scFBhnaJ0osD6AAjv1g+OtMR7M/72H +nhMBtTZUsJiypVCTQNDjW7Vj1lVLHSVPDpgfEaKbnrGNVYefIOrC6fsqOkDXzNlBDzO45citUi2q +b1F/AzbUAc4OUl86UNf/WMlkPJ8BmWUOTTzm4m+kUglyoDocc8bCwzwnxhQaR0QDGcv8iuoAT0OW +nJihralXpibdwqbQxqBgnDRChpT9xLRCUjjGnZ30w+wM6rZJ/vFwbBJKKoAmkQhGkJ/BJUM5DpiA +G2ZY08Q4bTR8WOiTsUZSUPeBLEUNXtUw5YhXpzhYYnDPEG+9FWHehbqBZotBgjRIemZc4WVTZAUO +nSrxo7cWzYcNP6Di+JiHv2vVWJi2NUPPCA+wkAzn7eze0KFK3eHKlu5emEXm8ihbGONk1pzTAMs6 +/QGQbpgwRsD1s7ZI+dPE4CJm3alj+p0mRDIcrO4DBr3KgVdBmNN95tpKI4u8oIbMJKwr8ktEw2pN +2aYOuPrPwdG78Ydl3Wr6R0xE8r7wZdvOaxauc1irUKlVQiR0u7ZkDQRyXoPd26CUYV6PqSai/7IQ +GOH6g28fSyH0mF/XomV5muuVm0bWwM/0k0sapnVqpQcR8GE9E81YPa0QqudgNivgxthia9JLp/VB +Df0awEydeUVFfYnNVcPrhMoOIbo41Y+lolrjkwDCKVAntxwHyyOeWzUD4hkeM2cgS0Zdl0SCgl2V +l28rr0zLEAzaNZlA3CRBAouTh6kF5Igji1zBERwbP0SPKvSW5EMoQWQYU7JOix1fR/YEQyT5CMrC +1CgNAJI6HB+QOoArtNEpJjFE0LhIkenMbUYvEIJYt0TJtq35l3JCCbumENCmxkUQUDwZObAqlAqR +bMCeRgasJoWm/bCmlxfyctjWRlazNWQ1Pb6SXQa6IbJ2BUGOJpkg38g+82vKmwY+M20DhYYBoYRc +d6TcS6PGG5lmGEvmtQ0KUCFbEk2aIBBIj7KmqOx6Hr6UpVvvlXjM7XaUxWvV+dGL9NPIx0ar9DTe +osDgxr48FWlybYZsp8ZG43Sr2upKkyzhYHaNil08zun5aOgopwlU4AZCOkNvucPQGjolMOESv9JE +j465GfSCSd5pVzjyv1RLWGgzaCdsVJQ0tbowwgUzQOcEx2+KPkJ+QmjUtC7ISc9S+tqjg+CeYUjn +Ja/YXsL3JJn7DCxRcMJxg9+h7IXMgcq60JcAz+g9WHvgwjHMjnLaakpB6hCslgS72VTqQDCYuY2J +SAWrG9DSNTzYjHHqHihbRwZeQmuOsUpjhxQJVED1h1G3BqMn3RVKF4Jm2TCqCBCpIlDHYpBaoaa7 +vhzpFsZl6gS9gxNru6a0lXkr1W3HODlqRSpv6D8P45erk9RatvMaPqK7Wgm/efm+8nozybgcwhp8 +i6CK0kMOYrF5/RVWu4SJlUxLy1C1T6YbixfmSa4mEVmpNOVLU41hDnc1jFNVBk8W5uqrQ6sMaRMc +5ZRa9iBFMKpysZ9sq9oz6pJ1i5lKHcTUpQocKyuuVMoBwHst1ELkpmxn6a/DLE6BNwepUQ3+cvT6 +okG71k/oNKi61qj0DJrlsCBLEZSHVW2ItEYnMUiFvADrjGSNHgWCcNA/G35l6IHo6dmr5dSS42MA +upJDiij0PFO1SWdeafQOz+k8biq3BEeWWG8Dj38jVPDUMwATvBrywPPEJxNSgSlwqrQQTCahNp4O +9TLtRtW0HmRYVku2civsRKtZYoQY1My8I3MVIIjqnWKj0rgJ6JAefCGU+OU0VyWYUdcw9srKgNYV +XdfwkZ5N1tWNemsZZ9cWlZ2Z8sygb8q7zOuy3oLbVqBBnBZjPll8Wbo6T8N8uBrehC9LRuAlph6J +Vl146JhUkbHAkS87WENPESuh5zt3PbzcIcao+ZHkRU5j3pIbhHJUfFbrVtS3QC6Gm5PQixoKW+qj +vFc9FXUiGpnh6MvX6k51+gZ+m76kiyiYExMNWIx1dvCWLHXLRo1zcxgd/gCLRLBRHAKkrYx+5TRG +pESYCb1/lTYd0ylWVVxytpa1jAKqInj+g4rUlacyZjhxGzMbnj6PhxqLfgi7jBAjZAK3tfDbqkiT +SZB2nQ+9kqNFci0hGBbeXvAqgLMaqHTlVGMAPsr6KPTjgPyBxmiPcxqimG9jFO6kcO3A8UFXWtUw +XTS+TjqOFlTJQdbHPRVzWj1SU5GtDMU9WxqzrqAQAAi9qpajgu1obneFQgiWQolIE0DZluHTOY1l +q/IUBALezGXjXpjPAH1nQoDCZBfEwOu2iR7qVRW1llUTY7cq9dUV6bFVZwoL1yn6jFfqHAsYjn6P +DDdWP6IGGm7M/Fo/qduocmhxXmMzMqWhaaIvK0xbLakBYvOpk5ZPowM2w22C5oxTHqbUG+tAIOjg +LocNqZqFg3wbfdFFyobbLAhGS8M3UiMwB7M6IVuqaRwBMDAew2xRksugu2AZjb3w+AYlI9UZT+LG +fAVzBZbq44k/LZX0LSiRD7VHEjdw+SHGtkWrjm1KsOh13Mwx17rXnE0aXBBE7j6kFiYI7yZVWpVN +oCeGjqB1AnVlfU9pRxMRnBWbqmkOGXJ1RGNBDfui6jbIvc9r+wh3ZLqmKUNUbnh3X1Gwqi09BQRl +5L3KKDP7jeJSkNqNyMd+MnexcI2egHgwjYRwVi8toww0G23k4SF/YItDgY3TVfYJPYqdj/tYsER4 +AjXo4QS3dFBiiIjGDXIj4loOig/yDOUoAmvUpiqMAKImcKGIqgHI4EPtIO1oFImP0RKQE/G3hdbL +MZiJBz+tL64C/9IwvTrcv2rGbLYG5EDOQBo2DO0foDcuxkMJAaxBQVypicbLQ2o06bBn6Uau8TKM +n6V6V6gZiBaNKVCAQR0r9G48XxtzGG1VMryxYr5LabPREBsDds0KOyN8PSIG2mCjUlr1GbAKlgw1 +8CJFrXDfp/Xq+OZI/smbMwSTuc5cXSvRQMQiVJoreP4J8ZUjf1pYOALY4iBlWaH9ujBHnEcPMwhM +ZV6O33nNYs97cByIOTFNoFZ5WrCGiJgSEEC9dDS3u5R/AuZJyoLA+ebTuYzlK/MkCo0WoflzE8c/ +EbHo3Mfz+0tauubEUAc6dnUgeFjRlt3GODE52JhPI/1UxXobPSgIKljad6X759SAygwR1iT1QKwG +ARAwfJX9T4YvaahbhPR9jsUng7h3HzdqzI7JE0WqYtaLECdEpCOZUznUoggmDLVFIKCdZFWkgAUb +k5cDkR7k2b0RFRIfYuvgpGWPu4whhsZH6+DI4h8o3Qht8k3QiPphWsWFTR8tbZqlKZ2p7SRuv38M +9WFT19QpImXAGagEb9QNkEmvCVqCTrwSejFCbZyhYxZ+PZHnf5Z/wz1N/g0NT+kzuJZPFKCC7Bij +ABUFfUKACg7++wJUsnf7AJWdDVDZx6akrHfPFpvyiYnv9iEq+xCVXQpRqe2DISpw9RlFqAD0SICK +ecYAFTMnQIVuTYP4lHxgnyk8pYw3hKaHLkTFzA9RsVnUyFUOy0NUzCREpVqNQ1Rs+ZlCVLSiQYhK +tZqEqJhJiIodVDQe22cKUbFxytNDF6LyqTEqzThGpZnEqDDsehCjIgLsMEbFNpMYFQENYlRQyzBG +pZnGqDQvEKNio1t0euhiVKrPGaSiXtGDGJXPFqEyjE9hS7sfnqJiZR6eQkgensJ0MNsSnsLO5OEp +aQBdeEo+os8UnhIziBTpoQtPqZ4lPIVjHoantJPwlHZNeEo7Dk/R2dvW8JTWJOqrDyk8pTafMTwF ++da3JTyFud9fRXgKUebh8JRmRniKnRGeErmGLjzFjMJT6vYzBaggadSnBqjUQQ/6LY1QaTRmg5d2 +PBihUnXxHnZN2RSh0jwcoRLmNftQhMqg5IMRKg/3eB+h8tIRKo0yarsRoSJllgeoNO7RABXwKvsA +lX2Ayj5AZbMAFZmaYYAKtJx5gErZ1tMAlXLDABV4Vw0CVMzyAJV2FKDSTgJU2vBwgEo5CVCxWx6g +0nQBKiHGbPByUHjq62ZaHKMyKJ+iVMLaKJWQZNXazG08xamYFKei97JOizJUJcwPVRkVZ7BKk2JV +PoMH6T5W5f5YFeyOzxKr4uOVgl2sStTp9bEqbpNYFfINo1gVW05iVZpJrIpbE6vSTmJVwqxYFfN4 +rMpgHl8gVsVGhYfRdL3rQ0ZsSCEjIY9VYZkY+HF/qArseRqqYvNQlSqGqpTNzHb7UJU6hqrY9eE1 +CFXBXShrQlUe6XGMVKn3kSrPGKlSmmGsink0VsWPYlX8KFalmsSq2FGsSv14rAovTnmaUJXm8UiV +xHFtS6SK0UAVnwJV/CRkxLQpZMS0g0CVLvBjWjSGqQhjFcNUIoVgmIqQfw1TWVNwXZt9mIqLYSp+ +XUGGqZQhhak0zSBM5YHOjoNUcFDtg1Q+Z5BK0z5hkArUl8MgFfopPhqkYiZBKtWcIJU2vFCQymAS +tyFIxXThGs7MDlLxzfrSC4NUHm37/iCVSdFZQSr39XsfpPKsQSpQJI6CVOBsMgxSMY8HqZSjIJWq +XR6kgutGnjpIxS8OUvGDIJV8vl4gSEXkwiYGqcRokSoFboRHY1RkXWPUR2mmhVOMimy9GKNSmy5G +pWxjjIqf12oXomJiiMq6YgxQCWvjUx7uaopPafbxKdsWn6J+PPfFp2RvPyU+pXkoPiV7uY9P2eX4 +lPtQKcWnLESm++NT7kOnGJ+yEKH28Slr41P+9v33g7CUz3vpkN6RikACOLPTpawH+cOEGs57xsG2 +XFUo7+HhnwBnvGYT9/r1nzTDOrrn2IxaaAji1YJMm6F1oPlBMwkQ7yxEV7pvUl+7SsbjwfZaj1U/ +/PnkH3/6VjDqN2cXt2eywPbNb1df8wKcEqsuL7OFDjELAaUnowYt+MhoqgCCTgASwhHI6QjH06jV +ysFkRJslXVfaWq99bOGDFD08MUxcIFhGDU5VwkQk3BQd89FAaXgI1XVQs1gEFQjhQQ== + + + 1oAT+s0YekzTF6bitYK4YVXglQt4HA7heDIoeMlzWWqXDZT67Cb/Cn6r4FbgGxFKFSU9r47Gm9Co +PipCcEdeaGKnFZbQ5OTAptt4G9weyFYbU9FXu9WMkaPuHE86ePIcV5NhcdzKG1zia/iXfkIAV+rS +tl2XLn1/fnp79rPeKa2RRJ+dckDJjjBoyBdI+XRFUIACnEpXKjpgZIUTlol2D+jbvGW8Ovc20B9q +MflZ4coyOZYvuSNE7qGLc+tL9cag748IU1VdKQCuWSu4DuAOBTr+mwaN81tZlEtIZd75ihSkqQ2l +JRl4SU0K2+TVY7j2Em7xTaRLVq9loBgkZ9clYxEoAeGCNQhmuNm3jM/MqAj7DChke8iNdzadnUti +6ST6pL0/DuVj/A9LR2l8xuIhamSyLApcvDA49ydLA+AGiyPFpssjwE0WSIpNlwjAxYu0ZrZQEw6M +f3DiuSJfvenXZOlaQMVmqekNsGtzLeDNCA2AQ5kSoUn4Evq2kqYCb0OjQHhPgiOFeN2E+OGoynuB +70heUsf/kV9KE6Kw8iSXzbeQsQ0RqoYNjJZb9bRPIONVIwqABRZCWdLyGIDGo8HNozYcWnKoMHM6 +TAIvjjU84SnC4pZ2KGqpFKyMngzM0oUzCDpc3HILgzDcgeDyia5R4eKSCyi8yqq67iAeSUwtl0H4 ++8CLMWte2OlFHFQNqdMsdemyWl6Ta5gY07QuaASUp4MKbxFvGAono+EeAVa2JWLERDhQhbFMCvJe +juctBeAlODkp+e7qABF8VM4mkGBP5X3MnC8iF7dNo0pr3Gca9C5XzA5zjgrvrXE6Ne8L1esfNach +7Myalx5zpeWc3r0K192WkZGym3yN7a0X/cJbBw4cIjY5aEGOD+CzowEfDi5y4ECoem6iQ3paiPTM +a8/5K0FgXYM+Xr3JDUOXS70M19In5xhmN/UvbBDlUzNBTLwGx6jSWvZPdFmuDqu6ZCFLXz2q1jRG +VV0QobHyyEXL+zD1/nUSSN6uHu86Aahxer1maYKyrI7mRUFC72y/JONVO56s48P3RcI5VJbE2Ham +RuO573lvWmHOfIMzoME97y2QBQ4IuCx3C/mhu9PbVbESke/X30aGKN7hOpOslUAN2dYqIcFJiocn +75I+OYh7PqgTaEkQTIy24i2/IgJUkUUv6S8GnPWGlLqkDFy3NR7WvF9TzbSxSYf67s4JsEZ8tWxr +U+PUhrLUw50OGpy6aqH9Gmu9LK4lVqfhIv6GXhKRyMKZ045Z1oPwsBhcLfuTtgQHLSVUyq50iGiB +kkQIKxSIVbz8uRJGoAGhFKFQRPgYWw3hCPruqwP49bcaDuqo0T4RUFPRR7C/nbqJPAhApU6f5XVZ +NNrVLazwnFGH26Pgm2FZjgFKMBvDyMHrZOH1ZxhmB6cer2RAde3wAQ28OdbX1HRjPSCKcSEQZdpU +egXv5H0xqaSYNlRMe1NMu1ysGVixZvzFmmkq1sxmNtsnfTQ4/CIQmXCFur1hRExD/xm2p4l45eys +Wa3BMBzDmE+4b1IaUMtLiUs6T1slquOXg7LDete0nHVt9DA78ltDvgdj/OrNmqaERg56I3Qr76o8 +joeCWvuRKmc9/qIYVVKMG1k334PunhwMQ7t9Exk9EDo59QU5hJAgCLuNWSRk20FFW9O1JWEaw2ba +yCycQIrSeBzcGg/rDsZhPf0WnYb80dDThGiPhJnrmEpuxoFQr2EdV83QuaRAIvrAqPyaIe6+c9o/ +OYATH8hQQS/7UvcQtAg0fZ5Azqs1Jrn/AAFuVMX01SDYTkM++8aox8QVVVmfGL2EkANZEEYinUxn +6uQBZTeGLIwW7yYsmhpuX+p0DKfCCd1EaHIDYu7BqIH980hcUjNeMzRV1BIj8lSwAGyuMsg/IJpW +GBZmP4bfGiJW1hWtgypUgm2iEejobONWj+a2CqtSo3asGnqtoVr7Pl4knfTl6uzm6v3Nx+u3qw8/ +n74/X13dvM2P+YfV4mvwWhXdI8xW4Ai3KYJugt2qeR/hN4jFBMNFfJzg+Fdv1mA5t3KP5xSZJ5gu +0CmukzRMsD3q7Uf4rtMwwvg1s3hyvz5+wdJl6nHzPJzpEzOQfZ6oj5/KPrb384/uIf6R/rxr+Mcq +8o+j94/yj67jH9uNGUijJtMWgiCYOtNYE8hAetlLa/LzUM3kU/KG+BAj4VuDtFCtgyia5+f5TNl5 +BhykpYvLkIO09DAacJA2ckvLOUhHng0OWPdykP5zcJB+FgeZ92YJBzkaf7Fmmoo1szmPg2zbhRyk +e4iDdAs4yGHLSznIhxjGYc3zGEb3KMPoNmEYx115gGGsyzHDiI20EcOISJanYhjr1jzMMKo9vm2a +WYzjsLpljKOdMI75jH1mxhGuusrCtUsZR+xLsnB+Ft9oer5xg0aPZjb64mzjELsXs43LcXwp2zhE +zXvYxrXY/iD7OK52Ofto17CPQ8x/TvZxOTN3cfbLOfi5v52/3YSZgz2tUQ9yWKGRvFMhRfybwOm5 +jDZBftO9nH6Vfp0djN+NC2cVx5/wMw+A1whDgykDOOGMhsELEpRlgLem8HhlXfLLgFCnEyT3Md4x +g0nwqnOrhEfomog/jvuRz2IKjSGZs61HIA14l7KCVamkawOowYTO1cCqdLl0eijIDRLZkFxbk59M +VIt1VQmFgR5Tht35XTmT/3BWZJyW4wtBw6SoXUyJG2EV1cyNVVmHBND/Fwmqj6X6veq8M1UA8r+U +MINqiB5TIzim5WoNTQCGvhGGS4RALEy8qXFAM91BWZGvRTxOakL/arLHrO3Yr1E3Sxprhn0tJt8U +qc4+v6ONiJzSSOp/OUCrZpr3moFD6SXfOZiJSsrRdDCG55+BPc/BX4K3BOqdoXh2zMoISKM5dAgx +jMm3+mz0uXHdI6eaWWJr5o0CKeKcGQ9Ep9OxYwoqBmjHHuej4F+G89mVjvk4jn0TBaGz8bx4eNLU +xPzAtJ3Rmrxk4pDpduHUffVmOnn3wh6cUnT34UmdZJdsM45yTzdn0U1EUSobwXMaecEYWFxStjVm +jT3GB00US7KZHgryVUIWnfJmdaO82SjdrXclTf6tSNsNf5hQMZOWsKJKJIVJA1qUCIRHXEqJ0CiE +K+3J5p5s7snm5yebzUAQx5YATyTyR2jpRpRA2S1XYPKhuUEHqQ/zFT9OgDMRlI1GD0cI0gNCaIAX +DgJHmDWHQcnhkFkgIQFq4rOCzjahBdPPPAKoo1r1ggcfNT7JkWoRgP/TQSUHA5DIOn4bq/fIwZDc +toaJHSpNPufgAeuQyYlWT80KrDmYXIyXjBOBStI5MpirhwIVQFqdzDU40qKyuGcSUU/wblvDmjov +oh51Y0gnjmDICiTBqHyMZIMM/rV67WWwdfRPERG8RgI7XiWFFNDwEVpT1PpKU9eJHI68BXrRzYaN +Hs1sVBYXtnhI75YhnQsCEtbgZQ9chJkQbBfj5ldvlmKnUp65+KljWYqh0W1vIY6Odr8ZME2DNUhn +rSad1FOxUefGBtQQXpDQt2JO6NlocMSXNU8iyEZyoLd0iKTGyspv75sBCF95JEpqamYkapH0RKqu +IwDZcB1zKriYSxeaZKs3wgbNbN4edqlLmfSJaVYYuhw0ZSNzs9DDCiCqtE8AilHY+MpRa9uqDx3d +/pQtY/7qmmplk54jO8dLRWUDI1qafEUL9zRe6YtJdyUId8PYaZ6NpdEMzUxKdnJAJ9gA3iN4tZQg +uo1nBN0DT8iLwLWQvEijvIjmwQUEZxAgltHd6I8NwMO6pHvemD1Jv+5VE/qafjlSWcuE73WQpWFI +VVuuI1HAsJpnKjx3mADFITCON2khRlfVbk5TlwXkPWISyB+YE1SEZt2UAYbAtUWrGpc0IwmbkEvu +mKOzjVs9mtuqQ3ZQJHwygZeBDWiUGSaVXcN8pC2jvssLNw2owGTbYJNPNg6Ay7eOMCabbJ6v3qzZ +PgSON5AA528h5WWWbCKWGG0jgY03Evmv4VYCaLyZCBttJ8Bmbqh+tceWjcbeR1LHDB2TENOZs443 +JvC5gn+r3hbAZ1hPA1k8pozBhuCklYyRryukpoMKmMv/VIz8CPIgFSllV0FANMyMB1dXZNRcp4Mj +YpTIYSD7FJlhnRxoDG0P9Mjm5T2NgVhpkCe1aTXzLJLIINKHl7YDd8bFakvLoBSrEEBUMgfjJq0d +zWktMMcn87dYJORZRjamaKGwRYjBuzmWosaTiiqDPeGW7YlhXcgEUql+hClHPExEuHKzoYf80+D8 +PRjuLDG8slAPQANSaw5i0M+StpiJwkSOLKYcpR9ejEWoDHg6xCDQGEPmmGnXGC3vWhmlnpRCoFqS +04aBJeuKVk1MTPb/s/fe+akkSQPgXoA7IIMA4cpXgSSEB0nIgrzFSUJYYbqn54/97QX2OHuNvcZe +Y9OU9wW8afVrvvnmDarKisyMjAyXERkU1H95TH0kvBMCXUYJmFtSjPY39spiJosuKYQXvouS0kWv +UMgK+JJUCp+7q2neNZHrqcb7Wq+MiDUEy6zyEKjeaAJa0JZ+c38GxLGwtgGFLusgoFuDEy+7gGEV +JLyotqp6xOKbp+Bl0qiolvgVvPgaN8B/Ax1d/wieUeu+ihngxgydw+uKtSOs6odsuZuSeDeRSRIG +8/iTBIqyQYmiRlkhp83TPA4hgkXX0N0P4hsOmbY0Hh/S4MCISSVhH34Lz5dhionDt2A7MsDi06br +e+w3571fCt1BC/RPZS/N4c3D6FBUIYAYuuWXx1egozjdqvoZgy8tjnEwJZ7HVVEICgZjKksuPsn7 +DI/A6um/Q6BRGxG08kDsP+9Dg7SlgZ9PtnpMW+s5SXz3BLp6gkC5gHb0CrOaGUey4ZFTREutELrj +l0AGIRavJVYvneY8d0rBnCiaFDxpOkZKhs+MtKx56omaA68m9Bx4XYiiwWd6mgaP9DQDHhnpWv3Q +NWXDOAoDbUNULETdGIf6sRopXCv3WFJVok0lnqDFCm+JhpF4A7jX5e7Evc0o+ESX2HMkvmgfXSOl +mS5v3Mi8vP90X8UMcGPavhl0RYF6dFWf9i9bnyys1A5dcPAOGQrmYUJ12Woj4yszCQLd6Qvv1dNt +DpIQ8D4UKOTNoyn1Zsb5peiaAvtvWQ7XI1Dt5gV6znnvmUwCoQdVWGVLq9aIE3es/gkSF3hpxCfQ +r5LExc1oYFH5lRWDop7hsLD4YQSkHiKH4/V004jp52lATn61xIYuyhQcVxxeTgErEGhpDd3/ylGO +X0NmD4s2aqnNY9e5hbqG6flAhDhH4i2iblPLqdukXt3mBIPewgk67o4EjIq7c4JBb1E9kvQW1Vcx +A9yYoXNJbyH1qhbpTt2OQcehQKKAeHx1FgmzH+30lxgwExkWXbeAdAKa064oVD9oaAnStFLlQ/U1 +9BoylOPXAoVdo9orsrz2nVukb6izEzzHa/VuZcU4ifHx+C+sI4t1K/2SmoBuBIKXqA== + + + I2WCQRGoJHKr5n0a/QIauFWfRgeBhqlGS5GIiBfkvzVEJKhYHrohR3oUM8CNGTrPi+aCeoyS+que +CALOCniaGnw48DoaXgjLyiQGLPekDYlhhzGBL6OmGROmwatYDg8Ndx23Y2A9NNrxa3hRmnjyuETf +uYX6hpnssG6Rh1NPLQGKuq1Mglit9UKESH3Vk6H6oWtC1AxOIkWoXi5EjJK+ryVHSVt1S5C6cDDe +yuWIoZIGe1owsacFgwUiGCwQCQcqe1r9SLSnOb31walAKw+09rQtk//5ckmP6V9hT2tZOjZQwbhc +2NOWXzrb006dWtvTVl8uYU+TJva0lpY1Tz1Rs8hztPQs2tNeKVq0p0mjPU0a7WktXasfuqZsDY/S +29OeqVuyp0kTe5p0sqcXVGxZ+Ofr2Wh4MekOZ93hRyyGHyN1V/3CdzaGbwT85qI/B/+eN786rZkP +XzDpz03m00//aWPY+OhMgGrc7kzC9u/8+GW+0e93wU4df3ZbYsv6aNRPABV7PIv7z/9ogN/GpkAN +ACDU7Vnb9iZNEYhSvzFzbE+j9lcwvUPbFoEw+YC3+sDYFk+EZI1fgAU9H140Zp8a0PnPxqQ1UiYJ +WiEQJk3rnf/M/IXuH12AcHugdQSiMe5MANuszSajXgcMLI7XHBCJZsVXTDkWiAEUokYK/BNiCf4/ +QeD/or/EEGS70S7UuUJ+qGsK/ofzoyIXuFvyl3RL66ZMg/9IE1b9Z+X9YlTD3YC6Zf2sJDGTv7pT +GcewUxJ1CHihn8ZIJn9Bv7wOybyf94rkVe4Asz0JxiXtdESMCb+k1eA2oLmfSvil/0BMJfwIXWSc +kjWbRVFnMaK6hkPoxkUR5sP5ZYNRcTcrFMFbE/ycMi4YcUPyHIwhgvmR6DYmGJfJI/4HzQY0asLt +qD1TQRK/ka5invoSJ8PRn0P0B5DZSK6H/YkzMA1/1JfIAnn+R0d6m8iLOYalbh/MDLYHNNId+nED +/BRrugmxSRQoC4mb7rTb7COARgi1WaPVWwqC1zHkGtNuS/kcLzImKf/5+/u0AwQaaf29+MFRvz9H +l2GMJvHGeAyQhhcHfNQR0RfSAPVXASr9xfd3sHagdb07Q+Ao1E//fCI2BgO0u6U7dDScdmFqp3yX +XaE7Hfcbf+E/YcpnAkMSVw1M5MoHiI0nSFRJS4CJf+gqB54ROE1OnyCl8sHcPgFVQiNpmAB4lzV3 +L4IGRgcjidX4RKHz7t/z+/wh1XDCGJn4hhL8HCNHmlXUt+dH8/fv+QBGG5OZyYrl+p1h28OC2+Ez +gYApuHLnRFUmp3xuMXibeeRHw/a8O3MzBzWUle8ASH8rQqd8/cz1tFP8ozM8b7cRScIuFCR7uu1F +LDChSvUyrTWBbGxYlwV5qNDFezBIj4bFaynOotyEso7yAH9zGvx9puRLFP/Tac3hENAL9K2ZPIP3 +t3FrofabCTW3/GMtjNbCaOXCyEwC4ZMhEh6CoMNHjodFDmGtCXzb81oC/Y0SiPrbJRC/lkC/mQS6 +WvIWZgujyoQq1ybVWor9700qz3eZrwXaP3xKngSasBZov6FA4wRaQNl1FPhfFvoAkwJL47tfWQbe +pQBvCBA92Cy+u4aAeSOw4Jy1n5BaOwrXUu1HSLWkgK/SYyge3THJwko3KAoF5lAn157Cf7lYS67F +2m8m1taewrU0+mmeQkIUL2th828WNjB8ci1s1sJmLWzWwuZXCRs3uQdrofO/m5Ih6eFvEDv0zxY7 +/zqhAR1vFE/Asrnohjx0XkTyDMNo4vN4nmIZXFOaoJEnjofRfOzPOkpakGP/LvyWFPCl4wQsA4Lu +msScl2VNind5ZLy/Dw/2xK6YNbv6cexqqepxa3b1Y9iVeGcCQQs0PPZB3ApeOcoxZtd3rPmVG37F +rvnVj+NXa/Xq9+BXknoF7/cnFfWK5lHRvzW/WoRf/fDg+H8dv/opPsR/LqtRmLrlD/wfVHbJE19a +cxMHbvLDA53/ddxkba39CJa06jgmEofnAlaWFFBtO5ZPMgQuCUoIyRWkPP5L+dc6rnXNAd1xwHX6 ++/po94dJgySD05AonocXC6KbeJMUa3I55frM9x8+JU9CbR3V+rsJtZ/iJPiH7Zq1NPq1+e+UQNMM +KgML75MXgGKFyuAx61DXf3f+O0f8bAn0r5Mfa7fQP5P1OhkCNLYDSB6WHIOlPSgSO4UYiuHWIUgL +cq91oP7vxv/W+vNaf/6B+jNNJXmYW++P8RyQuTCoIc4TDG1SXXitP/+b9GdqLYF+Mwm0Ppb4Efxk +Lch+8bEEKhVDMgyDro4hYZkZZI+QAr+8PfK7UOHvMyVPUu2HZ6KtpdrarlqLo3+OOLK5bUOME6eE +9U28/3JL6oenE65lzo+xpNZX8a4F18+xo8D7OMMAasb2E0dR3Pouj3+5/fTDU03XsmxtP63F0D9H +DFnZT3GKI4CC5ZfuB2A5lmbXhtS/3JD64Zl+a+GzFj5r4fOPFz4wKAJY8Bzrl514bDK5zmj5lwuf +H56m+a8THdAHJ7A8IcBjXo4VeBLGn3IEwSPfGyfwFCp2TcArdeATUikewvDEjysy/C8KKTYt/oTj +iDmBwNFo+FowimGI5X1Ovw8T9sSx1jl4vyPP41iWZDh0sRgPa6WbXTlDw4LqScwXcYV1ARUBXBdM +Wuvdfz/7dzp7IEmc2ZdkGFKAvxiCZRmcVEImGW4dmvzvFmz8D0/tWwu2xQ7UGZpIQqGVZAWORz9I +gWWgVk8wNBZjvMDQJPxBQl2eUrT6tWBbC7afLtg48SZROskl0Q1ajEBSBOokLjAkua5w+y+Xa+uk +z99Nrq3PN9bi6Ee52fD5BkMDJRqdrrNUnKAIYFHFKTJJrS2rf/chB79O+lxLoLUEWkugXyiBGA4e +9JACQSZROQVOiJNJAR7QJYm1APp7BRD599cK5NcZmmsRtBZBaxH0y0UQQXI8DZeO4uMML5CoaCKx +Pl1ai6AfnrC5FiDr+kR/B9ukKcQ2WUoQUGwsw8F7VlDdOhiGx6zjtBZjN+ucut+NYaHYVIqnUfI3 +QzBQz4jDHHAUlCWFaaHEcGAFQ5HH44itHxaT+g/bdWuN+X8RnsWtr9j6wfrz3y/Ofnh1z7U4W193 +8g/aemuZ9j+6xB5GZgkMCygZxh6zBCNFHJP0Cq6x/12o8PeZkieZ9sMzz/+VEmmd/PePZMU2yX+8 +QLLQs4Rz/4BRQazrhyzIsH5ptrIpu7mCMP350WTYmUxXxW50QGUWY7sWgP9cdRqAdiF5zadWW3Dl +bFdkd66/98gnf5Fb/PflTgviZ81RtBxlMmn85a+MJt3/joYzsK2eQjzlH8+ewv8onWi9Of/tmxNL +nfqkMZy+jyaDVYkoFUB34knGz0z68qIxA2MYIklFSMJrMPqjc/N6MZOe4m8mnfc+0LbvtA8bw/Zo +0P1vx6zpPXzI+BNHQM8KjbvDi1F3OIPPkuKz4XyQH427HdQRT6n7r6j6F0XqaNaYdV6vgGRt4AGT +hPxy2mr04Zg7k1YH9yEPBr2qdocdU3CFzsekg1+ROmClRgtg36yjirojUvdK+ez3M8Zdse0yQOhQ +zbbLorKt4tq17mDcl7m2F3Ue6/G4DwUw/A7dmGShtYtGAJgJIEHroR8NgbbnL/dHf/pZIGjWYmYt +Zv5xYkahYXs5U5iMxrXPRnv0Z7zRNRcwalCuDSDE2Zv9IcIJEedZiT+Oxo0WfCY/aPbnE3PT3uRi +Ef0P/J+7hlc/gILpj1Z/IjJwNOaP2V/jfzHbvugOe/5c549O/19swLP/KwP+F2FS9I4Cte5zVXjU +gPTGBb6GM7SjeJkFvE9nolIoqnr97sDlnvs7XIwK1+FYmsBHjlSSV3MhmEsveno5nmGXY0k/5yzn +lyQEWs5jrbusj0qRXg/ttMZErdjHCQpeNeYnaRZuOhrmC/Ps6u9ExQyxNP/vf//ynzamvVWxz1IH +ME6Ib3esk5QtzStbCfTPVkh+IaWv5eCP3crQRmfQLqYsDfWFDKHfZ2O40tSx1bZ2TqwF/E/Rjn+h +lb6YHIfODb+0T5b0gmhguTQjZSnebkx6aidDazpBThAqTnJSmz86E8mTjBE/bnSRZyKmbvU5mvzX +Yh0oloHBj5TA4WBIvALwr97iiJ/q3CN2Lh0OGEF6r86aZatY9iN42pj3Z8/2PnBvOwqFIsHIIxat +epJDdxjyQhJeWSrP1EsErLmTPJA9Sr4Wh+3sZIZGO4VPWPjk9Ww0vJiA1t3hRyyGH+c6YP9cNPqd +2ayDOOxF0804Q49X4EOkhAFMPofRYt3916d/7rtoecNT6PazO+uI3zmjqwEJEMg6fUdJhmNpGFmc +pHmSpjUuAPG7q3LOf9VpS18m6WRSc0lykmYomK6gHqLy5X2nDx2t+GOO5XlS62aQc3fUH6FzEPEb +lieSDK/ukKQZlmK035Lyt/m/GtKngkAjrwbPEyS8ncmIVrwc4pe5/lxCKA3+jxQQHgk6SZkuhPrT +08YHUAYb4tckT/EYqQyZFNC6sCz+QXCcgNDHsxzma0ogHc8xvAjyAAaAlw/opD93wLDGRSNpvNyC +AK/4QK8YikcXvEvXeMJQcXSxJ0MCyCJYiuYBWEoAYGlOD5bnAGaTCCzgvNo1ZlgAD+amyKPVgAWP +ygdJwhQsS7IkhW8fJZmkZhmSHLxGG7bBcwdgERZksHC0JPgXwCX0cGmeYXkITiCTnCYPLJ6UbjXl +kvhWlDhFA5TRElwWDhcOP3fAJiW4PEVTmtEJLM8ylBYudIohmof/p1ybKsGlIHZphF5ahAugEprB +QexynLYjjFyBF4WcFiqJ1gxQvAoqS/E6BiFwSYxLBfFMksDJpCJyKZxPIFIYQ0AkJOFgOQksIFzd +ThFYsIk0o6UoSAQQrkRiFMYyhsuiNROA7XPAM9JGpDmUvgDmRSP8CUmS4vAWTtLo4jRIA5LA52G6 +gwgODZKBK8VJKyXwtIAGSYNdAIcGuueRG5OiCVrAiYAMweP8CpgHKHBqaATEJCvtKp7haJR/oThF +eZZnNFMmpeWWp4z3AwYKmJ80Y5KUwUJEohkCRoIyEhmaYjkVh4Wj5PAt8uCHYZQc3Psky0vwCIFH +VAPWjeBNmRnQquCk0QwQBiGtgQ5YESyDqR6Ok6KkbQpoj4KB+WCbMhj9JkwyzjBw/0AE0GCVWPU4 +SRqOUxBEeEnwE18+RIK1ZczHKTFVMglWh1fWXhwnB+AyaPqMNMwkRxIUkmewArhA469pjkAokdNj +pA1EY8DiBkL7BzInMCQJnTRHIxmSBKyaML/0n1GYMkzTQaxK3DsE3Ohg4eAQWXlLAkJCEFmWYE0h +KmxOYqMsXjJpS/IS0ycZaUvSoF9cLCkOqJtFO5oACMALDfaduH1oMQ4bQ2IFAAlOOSnBIQnAIDjM +dFFwN5BNNI8XHLIsuEsRj1SjUbwLWuRDlITHpIEZJ8kkgxcFoJXXMmNZJGHeDnqWTg== + + + FGSJRKPVoUiJZ3KA3VFoxhSB6A4oHQSroSZZMnM4Jwr8kGVnEhG6gDaQNH+GBrxHQLTMAVYPfyQB +z8RCmUmi7iB6WJELMbjSg4RPKI5hVibc49KehCUU0XqwkL+hTcQzmJlQcNlImVHAZRRFB60WnPCO +YiA44YoLElRAEQwJRwKIG7EGAhAzhxkIh5QIWmaU4jpRmNVjmAIcKtrlnESaFCtQJJoywQFeDAea +FBAOCBIQkqAWEhwcHuyFoVTLBOUEQADLoV0kcWKaJcUkNqBgiXkCPI92JI03AydOn8GMSK6kIULl +4FYnkWgTKAlokmPRbgbtWASdT/Jo0IAmaDQNSbLRkpwXZZJasiHBJrNP8CVeD7iZBA7zJ45nMBAB +MXdGqu1BSRRFatcKUipSGmQlhwHsEPF0LkkDrc+P9Z2kqJ9IYlfcpGBfKQhNwpljdErYZID2TmBF +DN7cDscIeAras0A3x+ssjlC+rZ3AjBnDRNikET/GO8mQqFUbvc/8yBDw33Q/htCYCYsNrFyXpt+I +wAHEUqPd8c9GfmyOOMHStlagmHpVbeDo2yuQzEKobADpmpsiDdoFfhSg13cP2PQjCD5U+543Jp2p +Pzv86AOzSgMG/+dRBfPZPzZ8gsgFLj7mU9DMvMie1c/Pin7AQ1l/HgL9j0//UPoMd6a8BWAMX6Bn +0gcUhwgb/I8KpFk3ci9gq3IcqRGrPKBcraAVkHhBWop41Ezj2xskeUMjvRdKWcBUJNlAcASJ2APQ +JAXK3FhOigySF/mEoNLWACNAei9Sg0gVXFm/BXobEhQs4FnaEQPLl5BNDgLzNTR0Sf9nkIREAhyw +Vwk0w1MUjQHxDGOubLCSoBAw24VyWq0a0FCmUSQaNVhyUl4cbI9oFhQwBMPaoGeSaprkUQ+UACSL +lconq+OCoppK0KikvNQk3HKNv1B8y8WHW18E1h2h0JcVMo7BeihPAsUZiT+OA0o8GgDQpVkkVcTL +PfQ/RPTDhaUgS5W1Wx6oJTiTjaFpAktThsCiGtg1SBuh5P+KBgxUk1mIaFZaQA4MAK0bC2w3xHfB +cgHmjLg8ia05WhqT/geGyiPhwSNalqACfR2pyixF4o3AAGsLjQmIWxLrKPJ/1Zon/BfKYUlkgtGg +dWSASoMIDSgQYHcg1UaU99Kg9D9EsBQS78gxAP6V6JZj8X0UBI+kOw0kJIfJBGCEERUmTq16YT2J +pTWqF80AOhOQwgJ2LzLKWJJVm0LAvJHubdH9EOHyWKVDO4uXBCYFXVHICuc5Pol9KCTuQGEy8n9F +IiHwHoUqB/hXUo5JoBWg7wQ2iX0JAtC+tHqsNDL9D4mvEMj4h0RNKd4KVsBtCYYisMYF7DetQyAp +cint/0ouEKR0MxTa95S05W47TX9+1B9BETiaj+XNB2uZkdjfwTGCufVFSbcKyManhtNwtGx9Uopt +wwNNTItXDi+pYi1JyigvabqUWCJNpDBsPSC9lNfzXJaisAYOTDuW1zgTLZ1DLGvjHEqKSphAAIKg +tPCAyQp4G/yhtuIxPArOmzaMz1OclDI4Cu0DXtZsJTsVsAwBZ9GCHaF1bvJY5RSJVu21IoWkQrkk +hnmRk53Wkm9a8Var3di+szF2eKM3ksu72p3O1F58uyh3+YBWE1NpDC63TXAyON3RCBz97iYzIQn8 +qvbXoDnqQzD/hy9UGQ2AVhmqdPpj8D+5xrTXQQMHumLrMwzVzz/AqKDmGbqq1WCTeR9gzR/zX3U/ +PmfqB4XRn0P139XOu+b99Vj9Vw5ox382Jm31s9JoIj46nzTB3+eTxvADdl2bAdVV9XduPpuNhoCY +jM8o9bN6o6ltBB9oWuCOsB8bTL/90UEfwPWSH2g+wI9o8Eh0uYPBdVu9Dhwf8vlLg4UyPiziHayU +GuvWqydSW2HUmg8ACRUas4Yv8JqQ/van0F+qcy74991p9WzU7pi+3POH/jPoD8HrWGM2m3Sb8xlO +cgFNMdX9L0CsAL6qVeuz229PAO5RGym2RnoL/5n9Ne7gt6Gd4fT1j8ZkuqdK7lc3/aMB1x63hc+n +Fu1gujhuJo5kqvnrH4qd4WjYcYGY/ghQeNsNZqSW0b93Xs3usA0GSrqYGyCOWmd2hibhPD916xUt +/5KYIG0x4Wr+3Uaz33FD+I6r+k/a6Kk/XG912PRvpmg4vdZ8OhsN/l5O9uvoMDVtwDgIKPPAFnNL +jr98X9TgzTU/Zii/wy6dvv/5g6Xx37wNpv1u65/Oi2MCqYSGWS6vq6X9u/kunArnNJW/3Ezlr797 +KiRHC7TTVP7stlFYu+N0xIb/gCl9dpCl6mJOUsu/eVJS9KfVhJojYOkOoHl9PukCa9HN1Izf/ACR +j3hdbTSftDo5GAS9Erb3jzbICJO3aozNGpOPzgzoAdBlMD0quFl64zd/syp7cVammNJoMmhY7Ur1 +lN+7/Y5tY81k1a3/8eY54cQJ3lEgtDvLXGn79y6/46S6QzDOfqPlblrq1j+cb6PLdsYNAK7lSmPQ +tv+bN+1WCf2fiw07gFcJoaMWN5NUt/7hhDkcnXqamrb9D5C3zoz3f2bSaoXS3z2a0XjWHXT/izIL +fsqYgJX8dw9h0Jk12o1ZY9lxJJccx1ZbPP9ws+tUjdHH+KSQIPzSDxWQ2k359abb+TM3+s/dvdj+ +8bTT7s4H/qvOdNSfizko8hfZI5L0y8cxgFbmY3+pD7c5PNO7mHRgarDiHuZYlmbF2WePkv7GZNYc +NSZtfwsdRZP+pjxLmf2gLqRJ+LtgFI1ZBzTsIJe2bePecNTqjeYz/wc+40ZEoOSgwRGcdqaf/qvG +FEhNkeBVM8VfsBRDCdaDpvwf6OTLXVtZ46AJzTjO57MxGKj9SCgVZLU0BCPotv1T8bo5F6NQ0Oy4 +IqrJObaVJ0dq1gORweSPjr/e+c/MX2x3Z41mt9+diVKcZGSYRmKqNoYf88ZHx38xGktLqBeDvISX +9rgbx00kkGBkEx2JDNAlBppHjX53qns0HY/EHUPL/o5xo92W91X2yJ+dz0byihnJNukfN8ZgF0y7 +g3m/oayivO65fqfThjbojbK5SUv8ai2i/GQ0zk46DZzibJCZISUWkNRveD9NGX8R8TD6TMcSxMnK +vcEONL4GcbDSquUbwz8a05qMDjUhEP53mTOATdnvDjv+KUosnto3Hkv0M/qjMxnDA+KpdpUhskSu +Awd9OW9A6vJX8aVNegZhNo4ZoEzcklcoXNNygtY59kcH3mLobzb6jWHLYZKtfncM1g568f8D9sYH +oABx4CGSiYPlUDHSXvaoNO/3JTzedCZTKHxnE0MXtdKtPw8h10f+rEgh5vtC/zehBVKpn1b919OO +/2gAN1h2ioIQIKsctvXEKLdXmojhQzV4XaREEjwPq2Y5f6WXdOZN8bjwxRLyrjNrqOgoZmhgjOOR +PvDXxsBUmkwBumfdVqOvJyvLD5TYFAN9Gb8BOM7Xatr9awobJZGqzXXSDuzRsNWft4E+PYAUo2dg +Zl+UR7A8AMyxB+yo2e+4GBKebnEwnv2V7/T7U0vCkD+pF26hL7Sich7a9YAW+bQxrssKEOWidXXU +UnFU/Yrrd8to/JeBtnWIEpHpvzu9MIepa4+SlTEm/ac42dvQr7rN9bD7H9OO1Y1uu8P26M+pjtpV +LbpquakfYVKDt1rjD7i1YMK+AmE0hJTi1/BnV9/44fL4CXGBCE9fkWbL6vQRJY7P7aTwV7SoqHj6 +iBHHx3j6il3oK26hr3jxK28oFHR0ZEMR5gSlQyP0TjvRE+HuEzxA8yW2/+aJICR6Ejx+R5nj3vE7 +esHvLOjK8TtWv26WiDflOopEr82b76N+uzORPInw6TSsF7u6xipzTcsdCvMxGAk0vpSx5DqfgKpU +/hzcFDUQ6U0rnPdM+brundoGUL3Xcc7if8ajyQyqQWrpqlKtc+iQR6VcGxQkjZOp1ulXGjPQNxQu +fTi9qUrftWh7BP2tRwV1S/XrOoxTgL2ajQ+FjKqGp31bH41V7+Tz43J/BJTPq8543p/KAnAPvpUv +99BNVH/3h6LgAHsf6RxG2QveFIetkYmFDd5AM+58qOhl6nfomhmEO6g5iBaUAhSYgq2uMm5SeVMC +2lTd6DyGIIGZddKZDM0GAnRrWf1Uj33QBOhFGrtpR4DYp5i0DFso6R+OFEPD3x0iDX407UrdOHtE +KD8wDm28IGp7AbVF6nxeNBSu1IaC2hpBTfGkEjfYDMlpzBC1ZwO3lmKv/Q2gJWNXh86loHFD4I9g +ahy0LNBHyGTXf+TGKVS8qLnFAW5sjQRj23PRbKupzUc1rnAzG2Rp542bO09ci2L8lTOOHXajHD7v +v+00EzfddmeUOB0BTa8DkQoUR7APOxJuE4qjPNEa9WE5AQDZyLLV7aazfryNu0BELQsEe/DwM7G9 +4lF08824PQCv+0PXgxq3XQPHMX/yF6R8vZK64Xg8iSNhF+/DoHtXLWcj0bvE8rx9y4li2AgEad8W +xxno2LtmDWHbP0diRTj7Zp+6Zgacfo2aAKfT7sewYXQa6huipW2KcQZ2EFHDETxJdtGuMW12Z4PG +2L4pbjPR7ROz1q3+JN4aDeFVYNAlZzNU2FLm2010VRGeP2/aetKOAxse3rnjMADQ8B2wJumaMSSK +TVshIWH08hl6/QMe0I7jny7b/WE9tvHHoBfvDKGO4W4HoQ/wFlLW0803YNFm8II3cSxxijWle9gU +bGrIm1UBUZZDH4Mt0h2+jxyaTVQXXTk0RZ7SZmMytUEuatiEKhbYTyoO4aKxzCRctJ1o/B9OrdWM +grNsPmhMelPtqF00lkftoq1q1C5aq0dtxuS1c5xPO0AlRsqtzT5+H87i7f548j4a2m338TQOFTPA +Q6b2ZDGNA54JnbJD0FQl/A0t/zOOT/QsCQl8s5YfbpgXaCfyLsW/bIYmpR32h1tDnLQnU+2ONxVA +qJnkiJ5OrXtuDeKSd701+KtnwwaVhiN8b7PWg2voHXMZ256hliCyoOt4Le7HOalAn2/7n0K12/OL +p7D/D8pBB4LjUgknM2kH2kAtpju0EZ1QvjoNGbYRVRZREiTN2SAU6Qr7ExjKqpU6wjIEtEDAN9v+ +5l/+wqT7B7ob244vg+8VFctGudAwYivVwsRba2iEjhxdyQwo4zVjM5XWyvpbC8HJh7OgBG1EIakq +SKVvhapQSbAc29kIXdxo3JeCkEyJG7VpDad2KAVtZt2+2sI2559T6ZpNmzaIxzrJxokkB8yGjNmu +ZklM20yB6SydjJqz277m2M2sRbMLbSHbJsPOR0M52bQUAEAxHdq36ZMt5Do3mH16IfHZaHcmqqNI +01ZaOcKbqYKAmetPB00Zfr9roySDBqNxy0YxQg2mNlNHDdpzW4PdZgeDz+03MBYx82HLFUNArRvD +4UiJQxVDA6CTJSs19CuuMs9RAaS6PXIS6E6LDW4XUy8CYdWqLotwB3veXCgiCwkMGQ== + + + J05bUoZiSPX79q2mve4YmDlDG6ENm03AbpxMO3B4E3fdSmEH7lm99IVqblbDgT4L2WOnpYLjUfMI +GANqGtA5v/QrSlg6hpTFEi++viiURCcUtGVggNtoONW77cAI/Of4lcpVpXY7N/7onALx3x33O1kt +mhydPKpaCn7Vrccr8O/A2YP5vcIU+7yiE4thELbfuYnJMPuOgv1dYMULHZ3CDi9G/a4kFU2NB2mg +uGREaTIaACT+OZr06pJkYmymdzoajlqf4KOOapIn3aE701caNA60gm774UycgDvsSlFMWSBHm41Z +tfFXRzIz4RVT9ssCL4PA+ZzotCXbHP3hoksUK2G1ovadok+te/W2PFeKcmhuEJlP1eA29rJCsIAA +cqcctcFKdd+7EvviPCBMoQ4X9G8drsPYThrSpTWmvYteCa4S0YQZlyOZUioUQGtSvydV3mvtl67C +IL2RTFVxvNoM1mIzqgdtqmO5j80yN/WNLMWaar3NO+fgEbHrWaFWCzXVdaCo/S7V8QbDxy6YoEqY +wXhOQKP5xhhHdXYdRAcD4Uh+IGtlQekRnUCcNoCUUNIv3HGSQmcKhtZwL0El1pGd2BOvCbNbUBDJ +bM4FJgBjOVK8pRY+WKl1fdIdQKTdqix7R1ljNh27IV11PmAfU2fOrNNNHBkz+ggHyHZVKq71fJUT +dedhl8Dmue00Yai7M49SEZGaLzkPpm5nbst4gQwMKMT1z/mgOWx0pQi7UP0T7DR/Y9Lxzz47ftHt +5J9KgXB/fnaG/imOsGgM1YW6/JCL+htT+FjRfaWY+DiKD5kh4Fpgf43m/jHgnH7ATzp4T6OuMbgP +WIWnq+ko6gedyZ8OwYzhxaxjmHzm76KT84a/3/gLxt83xjh0BPKq6bz1CYd3NCygoyoFDO5tCJA6 +B6MbvSvdd6f++bAHK4fEXe/81qQ7dtxYqDHACOIydZU3xm7NZDPEBaVhGVU3pK458uecfIhBsU4b +Cwy8Y4zBMpsqGMh4rGK7DiSskuK2chTHU8DIiiu4yNbuITWj1YUz2sGXmJkLo6Q2awzbcki0S14s +llL568zW5eEYO+6MULV6YL+uiAi0CwvMZfAGK4N52TZ0ZX6aTQfw1f50BizyuZwc9P/93//P7P/9 +v+xxJn4G9tf75Ftrxx8Ne354pZvKhOf5pBITqDOxlZklcl1p5Nla/uhIYAsd2D98yRye7zxG9m8P +gnuNu+gxvXMey2Um5cFn6mO4cVzaiIaC+W4jPt3mritFbiuVuS6nT5nDVPUpeJqZzFt8qUidCgGS +YbYIYlr4KnxEie3M3kt8N7MfHU8z0xMq4Qtk9qobE6nR8Sz3UbmsZvaZTi3fPUi3CvF48MPQVbV9 +D/rjC6VAin8ozwpfzznmIRbNDkbVafaoNvuMpLmteanAbN/mvvrBW1+g8E4cN02BbfPJd/7m8vEp +W8/Hb6w7VbdLPWf2e6XnTGoaH0QK0cC8FCq3330BhKzSG9AwCu/Pt3yun+nfpd5zn7P8J/9AatDx +tlNokdXvzP5h8BbDAUOe5l8+Xkbg18534ah9tJGLCV/b2Vpsa4jHcNdoz32B5Fco0iq22MtQ/pN5 +3dvPBuidSO4s+hbJ5IPXpXxnvpu+Od763Gu1Gj34qxspvlc/cc8kkWjwk+72W6r7ctzO9QOHwdgk +8jTPVms733D84cze8SftC3B7N8+Z7LAVHEQOTvcS/ODpoMvziek7nZ20jshIL0XKEFuF4+kNQBsf +7PC3NNFOdfOJBlhf8vQgFIt2cn3+YoBncF8NZPJH+1u3xWiSnYJ1OXrkttJ8fvQS2b9pP6ao5tYz +ApseBsCE0tzuFlySR+6WuxxCPKVzvTAXE0nzpl0lyOet00Kisb9T2og8TGAvHHzxgqCgJr4A0dw8 +YtDvSLq0L/7avy2e4Ob5aPENA6PuqSNAundEJJ0uRqnC4ceBCOf2YH+v/XX2glZSHjCAd55jxV5A +o9yxPIBnZQBk6OAKNuow6Bm7kSu8IlQDYXnIcA/cVytbL3xFCu+Jk+9ioxHcznHN68v9SuE1na1/ +tmbZi+3WabZO0WD1s/zz/Rb4pv1QvHs7nMsowlSrIdOXngJM6McnFWnB7keF91qxjfAJwDbCkfTW +3i1eIQjZFyi+kpGbHHN3XMpMJp/XTOr09hCtkMB2JxxYvN1oJDdKvuhRqZ24Gu8SnvDCQlC+wF7k +YB4qFfpkjjhmU+CfMtHFcNJcc5TZq882s/Xj2dyISt1KqvAuLfzdZAM+qwM+9h3vZvV4ml8lO6XQ +zjic/+SuHopNYn+30JlMokTn4mBPHghGh4yMajn7ekwiatuPvZXgTj2JF46++Abe+3hBhdr34CR7 +/pI7LeXfjwWCPGm2S/n24B4xT5M1KOf63MGtApubVQ8ecpX61oFuDL4AGEXnvFDuBTqgq8t9yGFo +4j11OzKOVt+uBX5FZ+XxZjOZjOwxZzqM7B1NR+/57rTLQW4Ze7ygwltHFWVWe53UzgDs5KswJK/T +yMHxw7HU6ccT4GM0eBuo7pZnr+1BtvZ2XEh0D0IlDOA9WOGy9dPRR+amftQoFYXLO19gP0IUn2R0 +jIvR0RlV2uFSd2DN58liq/e9I3WANki/gRnzzmOwCtjjQTB71R/vqttdNiqA/QUZ/upzN549ua8N +fQEVC5fev2bq/M55vvpdJzUiY3en8J4NvmhkwFWp9Bre+ETTADx32AFbim3q3oqrD9/3NJJG9fUu +EKLlUTFabx0ALF7ego19tx1JH3A0eputRTPDfLd72YZT24BN6oWTk0qstF9kw+gtnMvH7hA3r59m +Arn+MRGHa/Wo7E9eOOzuMpmbZoK/qJxekc2X6yy9s7FdpMLbL3mynK9m4K80IHHygOg0U4dkNJQ/ +lJ+lfQHtN7glegb/zEGmmEcfoj+5WpW6hG8P0NdyB3n4LIdBZfdjJZ6NFa6o14dxETbZBzwZNocP +CnJXOdjoTIGDe4H9aUFk5MGn5S/2UBM4mgs0JDQGMBcAJ4uHAqeJJwwHBbFTh8/2EDClFwRCjyI4 +ZLNO0Z8ixiDEmhaZ6Js9+BZN41BBJW4MB4exOPzYu5RRUEP4lHvZV81FWby07dK6XgjdMvgCuoXA +30BkKbDRNBCetOg4QLNS/kSg5J7Lyhh8Ae1aps1IznZJ8JDRL3lWuFPlT0xjpoThgixg46o8K4VU +9DSL52KJrAM8U7RzJHQcKHOGjc/NkKrbqb6AjMID3TRlnKS0IA61o8kr36K3uk7FdVH2nYpiNKua +VqgWNYaYyJpslT15hBcy88BEiudSQnhEYN2iWjUGW3pBKAerD/Eow06bMUA0NXlreiNDtCAYY/ty +B2iMV5xAhs/RL4x+eaY8dxN/Bwz8ixblXjI7zF69f5wAtfJkrBMY2frNybCUIcmeL1AOlF8BTtgQ +p9JN5peB/dLrrL6b2SMuNiLFm7uKJMpi2yp1QqUV6K0kdTtAydAwwOoLEMERlWlGJoHBcpLjgkD1 +Cz9aWlP83kO1lKV728fIDtBOKIIMBF9AGB0TfDEWfWcKJ4ffjLqX3GsnezWsXWdrs6NBMVJNhLRv ++6VMMjCWjIqrsGJ84Q6OHuvf2fN87gLqMKJ2NdAgBligUAvTzlSlbPB7reurLP90fFU4nuy+mQHI +spXno+zJ7SXQk8WRXQd65el5ZyKqflUuB8T2U1y2HeL2toO95QC1C8l2gMB4/vq5c1J4v5zWEt2L +R6A2F7/zWN+mqc1He2PI0hTyBdTGkEKhcGrYwr7LnpcKX7ev+e4Xl9h7HwQ+gH67SwKcpN94/qo9 +goOLKfqRqMbW+s8KKEDJIrDfybLgdmV/QLrwEQsf4g4u6fQbUNTOg/nPyH0+0U0fpMS10uJJY4v0 +ANnHS4ohDPiYeg0uKgj9oFN6CzoPqpjmReJUDcTKqNhJYzpXNsBFpQ8sC0X/12r/qoEme52TPJhQ +O1J6e00nC+V7/h2Y40WKoMrMqR7s5Ub4SWekYBorSt2+XRberyNlwKdLBSrcLuIdiCxVKAOSmHG9 +7O/0rPYVX3p53t0qFYfzNyqQHAji6u9HtxOPAt+qHucuLzJgLveDM9HAn98HspdntZtSIdyWXijE +Ptoh+N68eUFUT5pjxUbW+xyohx5Yl/zn00Yqki6/vkqU9RwHKxg/yfVOI0C1v3hX9mwKelpecj3q +YEN5ITsCiFR70CegEDmD2H5QvB3A4jPpe9U9Y03pTL11x/HLyOFN41vqoM5n9k7uN4H5+LmhhX2e +rZXbX2BdDiZU5nojidYArcBBaE51IMm9oxeAjx1+TudokZOXgKmCXl4aAER9Wnwdk83M3nUwrnKS +UWx/c+99fvGVrV837kEHqT5ResrQYDSVmMyd9Q4MXyDZL43erSiGlFvWpd2rBuZy99Jqj6L9/iUo +LrtTaDKdmuPuVQ0E7t4PQMml8EV/r1RgH6hI+v551wjRhZWvAltV7d5c9fUT4ROsS5o7nhfiV+1Y +JnX21ZNFVJ3bLA3zomsQEF9s/D3qFhJ3exkJn8FO4rPz8gbxORUHVy4ciBz09oCFYp7KDc7TQIpp +FI8zJnc+px8Aqq+mxcgu966SWArdQVLitre+hUzq9ru7915pfmRSdyU1KMyxse2ebPoCSGLvR++5 +CoKtkt1iSyIE7PRZC6zfw16hMz6vInWC26oyW/AZVTipn24q3fM3/WodCLrD7eIrMXwuvNcL775A +MTo6nWfZTPax2Lroh3XqkuiZ/Aj0AENNbvLTxNlNtl7NwG2YjBkHvx/KTGLJefbiKvGc6r4I72DF +b3fBuqjUGyyODhKAYqq7QEF5ui697n0m9J1S6e8BWOSPjcz3YaujvIBrNc8KzfFHnKzcRMVnYImB +Plbf/o6VQqNkWPeKbFaPKAWELF/hkM9iuf6AeAf00nvg0qnz+8zeOEkapya2g+sCWvLC5WjXshFq +kmq3m9/GJg+xApF8CJbyHa6XrRcaZK4vbAkEFf3uZlLnl320YCoOY6AidD5x0Lp7BJumcJq9qme+ +jbSxNc13D06nmVQp0OAOubty/ix/cyhrh5woX/j9buuxcNS6usgxt9TMsPAvWxtAeBCXpdDxYTVZ +eSrNRCVYXMQ4ILQTbu9kO/te+Nh6ZvjUOJ4H6lB3VwGFtD4I7L0zgkT3uB/eDrxC6t4vNhMPY63m +jUcm1He2a6XXrZ0amF/kqfjyNWshH6QRn+VZsZnbDfkCqdMI/Zit13c2NMRyeCSDrYpeKpEsqpgJ +S38+WRBIZauUzz4DFTFzdAf4WCFaZ2WfIR5tspct1rN88uojybzlBmCSOcKyCRQEDWgqhWPDaF1W +z4AVVr857GX20+NbICv7Q2LHBEQn1wvOjnPM/eZ15eCJCbqaqajmaaCE4k+wl97RGTA/iiP1vuMy +IygNj6GvE0yXpbeAifCQVECkSGHjrBS+v5hlT+7JtqrTg5OzdqE9SEbVZxZgZCHA5Q== + + + z3sfCv/FTHj09smqdqp8eoEZbuRs9FV4Tx73C83dbiBZfZvsl7L94SZyh+roBaw+PMpLneUTT4WT +k/0EVtWoy1qsVCTfQ6VU9mpTWtDbEOD89QR3UMqmc1xgzBaOGv2Agf/0L8IAN89XkJfGCydHm3nA +LbUbaD86v7gvZYjZK1jzYbO0sRslgQl7Db9JUmDn0G9gGx4KKrD0biiMjUu+zr9IZ1eZgPb0TUTC +Xil0NMgmP5/OtkqFi9NaKTBmAHO57Xxk6NwDo+xFUQ0CvxQFC53hZfnaVj4L/lvJ7MfiYdNeYKOd +MnQWP4FGRdq4x7Z6WSaUuy6Gps1nyEhIPbKIafQBrQDYuLF7y15q1RwVfq+bgiCDx21oMp9kR5/n +u2rLyW6nIrKXLD5bwped74/oFACuFVVo1MpP5UD5WQD00purGs+qpWew+pltpIqgM0qoJ3OZ00L8 +/HNfRbVpLjoq7YajHFCDmAAwJTJ9dNi410m2bsQjOO74Wj1TtQvikCrtRTcVA95AY2qxPW6/l0In +5aR6kRGtXj5twRf9bK05fsfWIsVtfuQGm8KXSlPKVMbf0q5U5Avq5Zbeb/B7l+cX2dr8mjIKFHZS +OBp0p0Bs5QZghH2u9HYaSFprAOep/SuAsdN2dct8uSWdQkiOEq1ic1SJObSr79w+FxtvR5u5QWRH +JaAlGlNpH4dnd2Clu6pzex0w1b4zzBQKlPdXsIiV3W+gch+dSRIZsc+vSfCutDMfd3LMPAcsHWBp +q2xy1GQQEgAHjRf7ua+vi0zhqH05KxyHQiV4DHqEz42y/cYAqUbF2c7RhtTz8Rxo40bltWqmwYpq +7GSrDekumr3cfQUSsjUg1ez4eD4jjh7L+7r9IM4FKCiteurspTkvvb1QA0hjtHyY/qAmpYNOTsX+ +4T7HeAgQvUcgHO5Chfed8RY3O5kdlF778YSml+5L9AOsxnSXT71EavA8KKJfFzo8pIFCwDSyTDA4 +SpK3J4msUJ7OYNgAUOiOGneZafhus3By/Pxd6Oy/bCoLhnT+NwaI6PcxYB9PCS7VPN9x+zX8NgmM +q0ql9Dp7jpUywU5dexjHoY2COYxkGFwA0ZyJfQqgv2i5/CDUn4rNeva28MHudHXcS2ZcEs+SpTTm +U+KSFNFa+ALoCDL/+bj/XcpeZMap0+l8pHUNctw3mbwqtPKNXmG3m2jx+3SxU3x4PyrK7knUpAZ2 +fK0EZVMjK8Tim9AXUkZsC2Hs4oGvv1USpcI8i44lL4HGEYwVSsPsKZCf9XCut7cfExUUHcQPwOBq +83pbCdzA3FAEermZY8OlBOBj7VThQ8Utxff1LRHLIu6us1ej6huX/g731CYzxHEuuF8tRp9zwN7n +qIHinEXIArL3qQswlv7ePS407zpXYLelK+X71/Eb4pHy9rHAvLw4op/wADDwWGmLm1xWDoHqcwhY +9Ml3Dg1J8o5Sl6EZpKd97vqinQA79TpaCpAhYDdfXkULxxvvhHoGuPGY5G6+37NIJJQCVT6lgy03 +BjRW2nn4GBbeR88R5Doy9V+LrD4nQO9wvTyPj1+yJw9hQVl9GAIQLLbmmy/CeYWuJ+no8V7pNXqT +0s1FhlMvjnRiWwvnLf/xWQrCU29BM2QZwJgrZ0ff0wSM7jgvPHfvt9Sn1QoDSB03bk6V+WvM6Eug +/56WguVAqTKQzSJgIN1uxwvHkS1W3XN/tl1sNaNtGEVwSx2KTwebO3DhX6G+tq/xdD/zmb2X2Dxb +z/OvwOpsAws7EWtkR9lOSRkchkKHsnuZvefrHD88qpOF549nCtj7tX4mIQED/OKiDfZfdx9MWKOK +Fks75epYCUeKb+wkbzjuuPvB1WP3D1RxI5ZLfA7bje3kx+0EjLUCr+nKkfnuxmMQ7JfIbuu7QGzH +hki8sxv5XRLYBINNoO5fN8vQcxog6f8zLUfLaUPhCuhacW3OW1Kf9ThuDDu6pEDxPivtdZjqK7Lu +9FexgGeFekGXEQlv5vp4l4L5DNGDe3LVXW0lVhj0hyu0wnw76Z0PxTCqn5jG9UXS7BsPzONmgkhE +TiOAU89o+Iti9i9TtPziUv6FXuzRh/VZDlgW5V5l6+qgAejlPi2/pSIHV9znRpiuHGzEEkGgwwDu +09vfCJ89JDein13w6u09vhGZp2ob0dO7wkaMOKWIxMF9CHUPVi18yUyp6SkYXKEHVvItTecEWgBM +dvCAYm3QgZLylqi8doBlMZmkD5rZ6PjsOHOSnKaFyv5tvDR6YG6Kk6cHovBQuq+XDrIHLXI3yw/F +Xujty0g+tnsF+qtyVtPFE4rT1eQ21Pr0jarTyWRvWgedRI+IBFPD01BGNhVKsxvqZdTbIdo7JOr5 +XAE7eSam+wC2MI+kyxs7aOJoXQq9eGIqlBnhe+8L/Fnug6/vC9pOnybPp0+X5p2W+Rc2dfQSN+30 +ZfsMyH1dt0qnXPekHDDvdH8jNJmSgYl5pxfkE7NJpXaVTn0BpdtpMHoas+iU/Qw1gvdF806Z8FNk +n/own+lm6YXxBbaux/2q2VyJUu4kY9Ept7U9nIQPLDq9fyFK72c1pVMUByt3W97Y3yGPX+umnZYr +VN0SvdRDuv6GOgW02Cxq1/QWUPLTPF2F3YaNqxq6px/7ZBh0yowMpFQlcmKnF8GgrlOWHbyOlU4V +Ssbdvk6eP4d1i04zDY4vbZOmnb4cvl1ZdVoBWh8d2nsyn+v+xvN067NzZd7pZT6c/t4eVM06jez1 +U2mlU7AuWlLaPXzInJt3ytzfE6UkcWba6Wbpg9++GlDnZp36AkTp+blkMVduK9AbnuatOm0Q5ejb +jXmnZSIb7IT4e9SpL6BH8Gwreih2eh8L6RB8eMYciOgtPvVKmk4f9okqHyNhp7u6Tn2B6WalM+Ku +GjEKdMuP9fRbfXxoWHTKbfG9dunFqtMCcbr7nESdIhtZO9ej71Tma3J2ZdppbS9IW3Z60qnRhFmn +kPMzjzGi9hreNJvrdPOk0jl7fAiHTDu9CQ4/LDutfV6+NVGnvoBxro9l4uZkvG/eaZUOXJcy+wfm +nY6PN806BTwZdnvzWt6cWSD48Zy4PTwpmHd6mi6+vlw+P5t2+nzeO0KdQvlinOvXPdsuWXT6JBDP +037MvNOzr/HgPCnQuk5BL6jb16PY0BLBk0AtsmHR6f01UewOjk07Fc5imxuZ5xjgY6Db1Ld+08xf ++Vex0yYd1m2a8EO1sYs6pYLpUEU70yrxtpvKwk6jSqegF9gtAPv1LTH9g4m+0+lo50DsdHYY0c10 +46nxGMad5u7JIy0jjE6m1+kN0AvoNm7kSkcxNFfQaX5mYIWVTQ53ekiexHSMMDpmzrCkobdT+RPU +KexF7HZ7Mmk0h7BTQtfpZJLtjCT6Pd7QdTplv1KipDlMXcZ16N0cdd7qPlF/6DReOe2gKtc7L6OU +5dv7S3JwY/X2k6i8BebKWwPnB6y3sGPxNViDnUheGtdXh9e95QTytS6+nfYEw67khp+bd2bvMVO8 +OEo9Wb4VqN2rN+u3n42XoIwx4/sstfPQsnxbjQwPKeu3zfP3PeWtDmPc1vlmq1mx+Fqo7FT2r6f4 +7XvwO6n79jrSlZTTd3IzZcDYdfO4NjR7j7lcIdKbWL69DTQTG9ZvnwqpAwljJu/fAi/8tuXbr9nF +uGL5tndD5S6VtwaMDXql9IvV12BIl3us5dtjiknfWWMs0Bo2a1Wrr3c2do6edi3fFrOnzY7l22Pq +cJO0xlh2g9oOpyzeshWieLArzTkV2tO9jdQvp4fi23x8X78rK/W38m5Wec9MmeiV1gLLE+3gY17k +P2+BPnw7Fs3R0iuLWU9uND3DvzR8jJptQwszvxE7Tt4DC/OrDv+Jw2eljWjhKg//uUX2m2y9YR4h +9te4ykmcb7JJBQ8uYiI/B3aORh9Lb9FB8OHxAO0NaOmodkTiVBgGgR17NwesdXMH9Pe+L/e3lege +NMOAO20WJ/O3eEzDbiebvoDSLbJ0LDrltqCd82jeKXP/YNkpECJfpE4fU88VWTqWnUKR17LqtK3u +lKkBG1nVrXCWq6k6be/sbCmdIu1f7pTWoRdq//JMy31Np+F7ZL2qu9Ug+ICy7BRp/xadAnsQaP8v +SqdgLpq5Plt2ChA8Zaw7hdq/Zae+ANT/P83nur8Rt+u0GrTsFOkUSqdw72u6hTpFXbOqnaTUPfol +LkQ4/9AeuGn3Mh8M1XvfoiW39f1SvDt3bMd+inQncoscmPNTVuSWhq37FhpA7FypHDTp0nwiMped +Wka34xPdrVRU+Sc9DrXrorEOeRK299Pj8P5YhhhCINLJyvYXGkU6WX4sAMbVKMKeaYU1id2niwHx +n+jpSOwAqcBSB7JuCcYDJncwxo103ifA9nKJz04hIP9zpdaYRZ/Zudy4AHspq6f7dnwo+pTAkK8v +wIMdqNDOdyXsYL1dZMeqGVzsaBEoe9zAgIljNhBA/0CCvNVaSWaD6iWPdINSD+l1HgSkexqlgoeE +yo+mcwcilANu+TzPnTghHf4jDh4b8ybzC25Yzs8XUGaI/rFcQWn9apvO67clz29XpDGzGULl9doG +We7Xb4ToE1sWLpFlA4zczX2VLEH53JC7hKy9mCfKUuhKI5ExZZWfvr1j3hTvQLl5ECl5acxTuYfk +sT3efdbI0rKesJH1vBS1rIe2ZD0+J9ItPh1N1AiUh6xB4A5mPea4e4H5YhKCLcYTLUbxPyLuyKE5 +7u5jG5Zs22pXIn+c6dTuN71PTS3F0OTow5v6qROqyyc74mmC6UAKEd2s1FJMNavORXxHXH0DGy2C +Xm5GniZkxmEA7QBz7k6FW3kbqun8LbwDBndXsFim6JhsbAcraAzYz78gYghrKf05ihxIlKOiZOTU +MQdGugVmBgrhXXXKs2vcd42S231nv+uArGxs3s1t13KLjF6TUfjPY0R1SGEgC8AZQ8UTs+UEGFMv +KPwHLKjiiDbSBpifzAWNtHF+KQ9JNS40l1nZdGTpcnNqNckM0ZldJwxamHFJFIvvNGJcknbZSQtz +y3p6wtQXsBRMLnRGpTHQZh5nlmLJF/CyvmWIk4p37cls77fLWj5tgqzTkSJ4bYY0Ozy2lJXnV+J4 +3Kh0YEjWCp20dL6AuxUEVr6tYuGk82tWcBiwVSw8rF/5YqCAwpS8BLDa0MW4wK50BUwrULyOSzrh +FYHd2xsxXiap1uqWxtjrZIUY03I0j+Maa/0wb/zEYLjO0tMFtWPN+QsYT8XMGLRSaE0FNJW7+9xw +4GMqBdt8V84ON1e2K3N339veDGV8HmtYyQo8MqkquIGWuHfs3G/uuDU+ZN1Sj530VBbLjm4Ec8Ww +omMKpvvFeZnSU3sTTzcQkZKNQ3HgAq4GotMtF8OJw7ZXDQTbyBELEfVRga7rRw82OT6U1AYZybE9 +1PO0GVc5tMGvI0jzRQ8dWDg1gCa4YaPDmLIPiw1yZK92+AJeBrW1IAPQcku45Z5nAQ== + + + e7HslgEcKQzArb1vPb+gC5T73CFdoys4+zP0mrzi6/s6god6t6sgqsKMLD5Pywpn0MTCmRo+FjY5 +oP1P2i19iidWdshyv8UtzR5kJQFkedziGmTJWxx9QW8newntBj+Gc9FucVOr29m7BKh2052HxM6X +cKx3yepHY+eS1XlIBsdaDd7CKHZ2yYKpqTaSuPqe3STHMC7h1K17Q7aS9EM5nmvF8gLuDUAH3xSa +EIpUMayW+7XSyVQLv48vYOelGxzDw937pfw+EC3Ovj4dK7Dw10DscK4oWcU3NZ6GsUaVzsz1qjSg +A2tnosiTXSjTEMsnelXaC+6wPobGE7Afj1v/An14zQd1FKGyxTwJwhOdJrzYfkldhu2n5kznJ4rw +k+XLAt7o8Yle7llNyBewoXRAO1qhtwgDOLwOsD6HNXeHmFcHJ71PJ+qsdFmAHZ2gc5JDal0Wz0Ul +6uBhVVAdvwFnBZ65IQbLXaei5DwYT9ybz9s457uambTTnoq6PoIEwKz8rWbeVmxZWPlbITAPm8/c +XgKbxhdY+pACrZq9yPO5hqM1JL2NRjwTx3CW3YEYimxNKlAknuwFjne5J9v7JsA0J4TehKj2fDCI +tItoSKtx5lGY6kpOGPIo+NQXcN6GLsQNBEbFPZ/xWSgRMJZz1xUqVepn6lsjxfQcbdoLGzjatKc/ +wHPB0Uw9JHmAmMz3shztWuFokvXqRYPXA3PmaD6XJ0gQ2OIcTd6V5ZvRCjgaWDUzjuZ57wM43jma +wXeB4SzP0SCU5c9eERyb06BoLiSf4iR8ATNtQCOEbkZ2FrT66NBcR2GiV9p4S2DzGHzj8NmyB7CS +fHkPfluzIZeaWR7s8/OZ2WbGHnhvbBYAu9nwxGR9AUs2u2D0g3Yz3yBbWmOJL6KggFXTBTVZcRhn +OO5Ue0soyA8D4CwfAoGgWBjUupN3ZzjaQ3eX7mWT0wQEbBW+aiwLwfwiULvQSkPwNLaMfq8i0sbm +1XRpi+/u1q03S+W7sJSGt570e3sfLAS2vH7/9G0mC71KMbhq3l1aRikG4Syj36ugyLJwcSmG4Jjo +92ZQZOvVAo5baWgvCxGHefpeWhpqZOGr/pwY9QKeriQcCfIf0zgsUVZqgqeUMAxLXeB1YrMkalRG +XZy+3d0t46vW+fkBsGV3t2pcJnvbPtbaBmOu1F1pJWEvVhYRWMu4q31uc3qaB/i8Sdh4rlyE0+mG +ZEkRKLbHcXvpBVM+HjOIpXw84cqudCGYqNxd2zI8zzpyzcLeByOj3KHSxeZqTlcXbQuAWZ7dyN4e +twH1ABi9vXdSXYWHBGCM96ZiWMQgwpV8jbvywWJgFpv93jb4FlOET/LfuxqUS4owbC5RIuOtq8iz +NHs6NLUsxDVA2XLTj43Y8PJ1I3rzUtyIZekXmDdXNMugwze3LJ9Dp5Zixgw6XcbQwjl09hl0iCev +IIfOslOUQWeZLegxh84+g06dLbhMDp19Bp1G61sih84+g06TLbhEDp19Bp1NtqCnHDr7DDqULbiC +HDr7dmJu9dI5dIaNq8mgky2LJXPo7DPokD7mnEOnCUi2yTC7CJbMtG3rGHjrTCBdsIuLIZl6egvO +gdu77vKlSjobeeFg2IJe+zVxDrj19D4WtNLe29KpzvgK+oCNhfG0t6shV22uqCzjQ26SwTpfnRsn +J4r2jM8OmH0clrv5IV+fU+ac6/npPFfG/eIe6QnvQ7LIfHTwXNkNySxlDs7FU9KcK15T1IWCKLE9 +3hKoZp5CQXD8mGkwiHe3sZXTGN0MtrS/6j62ZT81n8tkN20kpFfHIKJksObLeoxxspvVsY3WSnJK +drO2T+0PHFTcsmgbDKIxTZ3MkKIum0GTKewOmDYEizSe2DSpb6fMR3c8q1HyZPSiXWll9jZp6xBK +TymmKPft1GXWobNtD5BldpYt62NG15mT47AnjHVuEvDttWnQ7AInVmVLtcsyC0ylKenzwBzVLtd5 +fHOnGHgPeXxNp/yXLY3Tyjo1zToJxl6VNsbABw8+t6wGlTFL0bReP8cYeNdRBO2y1oNpun5u8/iE +iVNOjB0xaKPTIbCVZYhOlJMPq8wUL8CcKd49xrQO1iUx5pgm6n6SCkdbCGNaxy+Vu7uPaQOdKrrA +epNMLne6rMHnazSz5K1+Ze63tM+X04GwANDb1EpkExBv1AsJ/3mz3d0VF8aebPE5GHsfFdfGnhUA +fYziAiCcrkYB6yzfquEuVW6hFXolnOWLpNKYbwuY4ubsZPDZuqRhVpqFEWcge7scOZ9DmrOLI080 +IfsrT3wG88pGj0xNDaH8ocLMBcpVJyNWlPx15M29Y2IqYU3JIUHOwHWsM6JmptJ8AX3syO2OV/a7 +pT72deTNvWOdZqePIFoYT58OngafzpSwJgGPHhnNkDT5yGBQlBf3h82QtJvZWYrZ4IlxOyT76HTn +pDi7Ienv7ojr/L84JWkVHplj5JFZMkoNaMLbLjwy4hmfQ3rOdiq+s4xHRmXvHy/vkQEAQjbRHR7S +0BbxyBiyBZf3yMA0NJ1Hxioj1Sk/j/HkkTH18x+7SM9xl5wDU/TAhnOmZHfhe7BUB6FVlk8UZdk6 +btyNskwfXke2XBCDfU7i+GQ1kQxwXVKXwdU4dcDUUiGHmF43aWgLBrCr5QtMILP2LnlIHzOELphm +Czrl1XkOmjVGqKK8OpfxerZ5darUUZtMYWcn6IntJVWq3avSLW1D9S6Md5HCZy4FnZTzbhWYtJp8 +ONjLKmLq7PPhvN8/tkg+nFkU9MVg1flwS+RZeMiHs4tQXV0+HPRaL7kDXeTDmdwIapnEtXg+nCYa +SvomuOp8OP29ozgjbtX5cI63BKwkH05zYuUi1HKxfDi9LWZ1rAMz2ZbPrIcCbmUxkQCUNibSSrd0 +ExN5M3IVE+m096c9elk1II8CJJbPRkdwok6r7xKOmzwSSyhYH0NwVpDJZYhksImBd+ZoMLnO2iFm +jHdW1bKxiHgOfu8aIp6D3w4LoduElt6eu5tltqGSfKTyKiy7DQEw22tlzPiY5Ta8H7vdhjbaOMS3 +N3vRlNBWcxswguNt+1jkIwM4K0mELCTcSTFHONZXAlvcpmUVZm28EtjxNjStV1p3W2M4avRhweQz ++4udHA1qOSOV3Fw0QEQ1Z6uLhRfKSG1svrpIInWZkdrYbLpxGTik+q0kI/XpezUZqRDOKjJSYb7Y +8hmpEMoqMlIhHHfXQOtMYrO4PrRBrC9N9RxkFI6Jq6/dhndLb0NdKpw5H1t1KhyK57eN6FlFKpzp +uqw8FW5xv6UWY/a2uwe7colUOPUdRCgZ7pekwpl4FX5BKpy5f8ylfXZvpxiqWYH6/mS7xKdPy1hV +NzfCa/WxfNzBLHIb6AVBsa48ii4cyBCY9c12HnUYwyXDXg8XVNno9y6PcOxu5wWs3EzkKb04Jzfr +8+qeLK/D0QsHyTtqIh6U/QurxkXN+hPXAJW4TJ9/lvs3jdfCVnteLCW3My+levqimEnMgoDzl+qH +/D0qG154KE4y2QpXP87n4q18Ppc4gUUIamNJHAX62iGLHidtLpZZ1hm0ksQcpUfrvDPhMnWhJi9t +stte6/xU7XxWdcp+7gb2N0ZWGXbM/Z1dsls7YdkpUarn7DLsAufd04ZVp282nZZjSVWn+lysVGSq +8sLpk92Yu8+qXJlQlwK2GbJLdiPjuk619fj2BlYZdtzW1jc3f7JKdnu0yzob2GfYjep1y053qp3P +tlWnHft6fJd31p0Wzx7LlujdHtJ7r1adXmoz7NCqgg0rzhr9Euk85bLdnlk77FXQtGSeqq4gMuEL +3E4UnVXORBE9k6ykdGne1wtUO9+xi5BbrQYbGeK5aM6ILnZGq0ntcY5Q1XtNrOtYfbsYkupczGZQ +TsGpTnEe2HpdZSU5s7IjJnequPAu2VWS8+SFeyy4DpF0yIZEd0J6iOtzKiJnG9fnnp4cishZzs+s +7ptTsRG383OuNeAa6U51RnR3qS1RP879fil3rAsRWYa7ui1AZ+/pXSSbbjE/jNdsOjM7QKrFubps +Opf3wyyZTWfmE9Tvl+Wz6cxy6RbNfLTOpjPzxZtH2i+TTadBi7hnTe8fWyqbzgyUww0hC2TTLSiR +PWbTmZ3TyLJyZdl0Zrl0ant/Ndl0Zrl0LmN7PGTTmfnapQrsq8umM1td5OldaTadmXKjjh1dTTad +WS6dxW3zS2TTGYf0uWWtKS2aTWemnPoCq86mM1s/k2ioJbPp9KAcawovlE1npVuuNpvOPcaWyabT +gdKfia8om24hjHnOprPNsVpZNp15bvWqs+nMAIBeVpxNZ3ZaoouBX0E2nRl70Fqvq8imczgZWVE2 +nbN8WUU2nRkyFG18Vdl0Tplcq8mmM8uls6zHt7wBGFMMQE19MU9XN1lX8TIWqdTX5nCZ+PTtsNk1 +yGdGVrVsFq9XZxjSDJ7yrLpenbV24Q5Ps0jQE54ULGkiIWFOpqNi4ZIENAkKFlnPVoPSDcktK3BR +XU57MLXQkCDGwKA8lV22G5J5IIUlh7HBk03ZZQuWCaWY1iI6JI+nOouI3k6OHQqb23vm5GpZdoXu +li5zp7rnyqVKvkiZO8vqcieucpVclrmzyuRyl0jnKkDCPj5ZKXS33FqV78duqszYeqlclblz9ChC +xCxd5k7UYewL3S1d5g7nvjkUunN3eDQ+WcE9V/ThNWm/iO7zLE5WFqI0PlFU7oVzecDUDsJu6dPy +lAcWqHOMPXSiT5hGB41nWw+8q0Q6NxHNPucMQ+sgDtf5haAXm7BDD0FkEDuWrj8tJbursAV63grq +84ngpamWcza7G8rqvKd8MVgwsUsTDQWIyiEe3HU0FADlGD/mOhoKAHMX0W0f2Ix430oyH5c/CoEV +BW2uAxdX3yUcV7VdzaCoIrtqq9iBCIohk900U9g5lx0Bc5VYa1UDQp9YWxsaE2trw9XdCgiBraSQ +MaIxMFo3zEwtuyxRWTdDpWO9V7sY6l3jkS7MxDNGUNta4lYx1J1pbyWZKfLNx941CSOo6nxVFQzB +iwvrI2LXe//aU6Fqq9M3WHhtaXUCQ7GL6vQAZwW3BGA4y1arxlCkTWh2w6G3WNVrF4kMnk54wxGT +bXjjIpHBlQd+6Qp3Un6lVY27BbahSXDFonWrvVW4s8t8XGIbSoQmVrhbSaU8x3wid5Xyls0nkivl +Lb8NbSrcafOS3OSHLFLhzq7eK6xx573CndtbzWH20/KJtU/fippjZb26TqwFwJzVHJ8bRQfXplss +sVaf+cgu6z+C+YWnpunQ3u65QnAW4JuGOyIgnJXkc54S7mwxRzjWubC6JCaf0zUTqFyel/x2syQm +9akoZBBRwzZMhRwWwoVfS6r75jKNyU0SU/DgRW+JqqSYmzQm7SQdfKcKKHldLNOYUiFXGeq2Zru8 +K1MhN7vSTRJT8GCoV74XtSvvPCUxWUUQwdqJNpLWm2J4J+bwLnErv04xNLks8e4e1w== + + + gFhFjms+bn2rGLRfvFak81TuEaHSWh+7X93VVPfo9G1FOa73lldTeddhmlNP5R4dKuUlFsxxVe1P +OQzDRdazc44rGJLrrGe7HFfRAwQXosqb9yepfjDjrXJQL/TIfC5xfFvY6hzXfIHCYaRWPxi9RTjw +q3yBsvtKd0+lNhVMbxaw4EGuXZXvWPylScI7O7xSd6rJh/MFpls39xdqV5W2Dlsq/3hvkQ8Xtk7C +m8zfUqSWJ+vS8Ihdq9w/bmubvwo/WyXhPVl2CuayWRrTlnMlylsP15adBo+a8Q+rOmxhpVM5k0tB +8AVLqTrVpqZNg/yOUkeQ1mU5hkOHj32zTn0BiGB9zTlNGl5Dn/unRu/J/oVFp9xWgDkrvCk+WH1G +3KtNp+VtzrrT8uXWg1mnqO6bUNGkVuo7vbKrI3hyY91psXhd0kR2gW634fuo/EtMwpzvHiS0q2/R +js4Tlu3U+ZXE224q6wJiJDWaFRUxCeZ8z+iVTvmwRvT2aIVn3sZPLAs6l2GTAKlsGJ0GaaqYOQdO +upDNAPaBPrHJ0UNinZJkDK2yHBKkZOtB5d2kNjknNk1XVZkFOXQdKrO49SQV7EOrLJfOUJkFdFDz +EoJml3Wnu3lyiaw0hwhNjCWfO3rSHXp5nZ/stYZ5d56rLFoMyRClpd8vrpHuKUrLF7AblLWf2NuQ +ALe0jtMSx2OIjdWxq+JTeld7eF001kxZzJQAsI9cXH3t4IN9Ka7q8sb72Ia7Gw5dZCPZupfdnvK8 +FJe5iVbJSTRcGbdQspv5kbWne61figt6lrW3aMIswGUvoTW7K84yX8zJajHeFWdjAJn7x7RBIyZH +rI2Sp3oH1hymtDIbuVHSc5hFT71xwp3VPkYnVs7l6zQj0/v5nV12qB6fpVeF+TYEEPSEiXd9xKL2 +U/Dgzvpw0FsimaGexRJl2ewzmTzlWCU93XOgGpIu/6VdtvMdO2rjmiGpQvXF02rVrvWYCtjbdpHK +qb7nyiYV0KmkscP6KSfv7bJzoo5rYtDVNTatMuMBmFMVnaA+u9YGmE6qLIcxx1we95PUnlwuiTHH +ejqeMFZlniyAGdKFzbRDEWMLZgG6zQF0fQ+JVYKYqxxAm+h0F1mAbnMAjf5kL1mAbnMA1Tcces8C +dJsDiLzWC2cBakjFxsLUx8F6ywJ0mwMIMbZ4FqCCT3u+oc2x8poF6DYHULaRF8oCtBiSIQdQfV6J +x2Oc1fJF+dxXZFumKJ9qLr+wKJ/Bq/BLivI5VWRbTVE+nDNir6AsX5TPFzDRCldelM9YH/lXFOWz +ro+8yqJ8rupXLlOUT+1VgIPiLAclosgpNdi6qt/yd0Mdr+JuKJd1/VzdDbV0XT/V1FZwN5RVXT9v +cUqL1vWzr+q30N1QJnX97L1C5pa497p+5sRnezfUAnX9nCl5FXX97CNDZM/VknX9nDK5VuTQta3q +5wt4cuha1vWzn5rOd7FwXT/NQAxV/RaoAGJa189+QmYRqovU9TNNR7S71dw9YlxnypreBb1AXT/7 +m7/kM/El6/rZCro8kmIrqOtn7xb2dAOVTV0/e1PXNAp6gbp+ZmmSytZbrh7fCnLePdX1s4cC/fyr +qOtnf6Dicw1nmcR3fUbqonX9TFRNVVU/dXUGYom6frptSGir+mnu7PKcnkLIdf0c815XUtfPvqqf +TMlL1vWzD7hWZaQuVddPyd8yo0XdPVcL1/WzRyDSYFdQ189mr0179Irq8e3aQ3Fdj8+hnJzrenxL +1fWToZhuH6/ZHIa6fjZ5D47Rth2vdf3sNXl448Eq6vpZyfAb40niYvlbLtR56STRaRs61fWzP2/W +RhEsXtdPi229tbhoPT5vQRrW9fhWsH3kqn7L1+Nzk8TkdHuDMVbDWyk+fUbqcnX9NI5tQ1U/nDG0 +fF0/OVXKrq7o0nX97NUcCxrzXNfPvqrf0rc2iXX9lvT1uazr5yLvdQV1/eyr+nmux7dQFq6OWxrr ++i2eDK+q6qfqZam6fkZXsrqqn9UtZ17r+tmHd+mk2MJ1/ewDnXQ+pYXr+pmsi6qqn/29cO7r+i3u +t9RizHvOk4VduURdP4VxmVX1Wzh6UFfXz5YiVBVAlqvrZ68YYut1+bp+9gmxokReuq6fdpL6qn4G +fcz1TVbaun7WShDWYRxusnJZ18+VDrN0XT/1ShoPcGyyay32p3ldP3vhYJvFubKEWCz3Eybi4cFO +Rzu/No/40N8r9YlvVNTJSvDU2rVrH3ivS1vUUJNEY8rpTfpgrM6Dx74psauQRkLGRwpiiMR5h5Px +eaaxRKtTmPtGTT83gFg53og8nm0TibsejxvBfKqN7dP0UZwIDTcSrccxQ08+j0vp/nPy8no3FBuE +g7nvHFH5OMtufc9z3MZTo02DX2+ZACvsVXZOz7+v2O/e/aMvwLNxpiWclu7iJ/HJBlstM2+5q971 +Ybt2yt1+1jtn7PdNqPO+fZsNM4WvzfrVSS/V378bdQ5Dw+9X/jswyQy5s43bs8PgNh0qc4H3x6Oj +8Pxz65EZPXVS4t5HuZ3p63rtZiMeeclsUB/fN5F9OpghSrmTHFF6bx0TZW7najJ5S4YmU+H2aLr1 +wjWnbPPxQs60rEcOErHbOF1Nbkppb1+JyfRpBIvNJbdwbrWRh2jyS/ceqq/JbOtyDA1quQQkrCc5 +fyMDu9lM9dgMWQgZYLqzHbgu9PaG5VxRRmOoEexcbN081NPbw0mitEMxH/OtfnujDTNJj6Xk0I15 +dMycwXi10yHKSdzIlur1ALHdaSN7/2KkVdnHuu0DpnaRVyXNKf5W1dQAWzPDQ5oL5Oe+QOGh1LlD +BTTzz+WrO+4s397MJGb7x5nEtL1XSm71Loq3GfoFoG2YLvdv7p6yFW6jCeDcfEtgcfnMEBnp8TCV +8f4ls1fdmKBZZQcjSMnZk9vb10jx5q4Cf4EJX/TjMGk3is36NHs/QZYTkZiFYDTC6wxz4gQbD0q/ +yBDyHQOM8EPwJ7+Lsn4Bwzkagz8PoojDbAWBFHucgAf5uPRhKVEqUqcCAFshIoVoYF4KVY6OyGjw +c1Bs9b6TRCLNh9FA4eCeyd08uZfvNhIkeHEQUb1obOcPfAHpVT6mvKJyD9eH0oujhPKC3t77yEov +zkn5xYuItvLBrvJM6RnK/XI+qnoF+xbhlMGuB5jYBTN9isA5h6nn6RdggOUrEt2EQ1YOr2gw3ctd +1XSbHxGI2UuA8oNRj2xt8yn5XAywQkheObIVOyBhowTMWxqQrcMjiLZLUvzm8hqBhUmt+1uw5wjM +LUZiaZsKxxio/ddjSqdU+DCzh3vZgwfeV7l+/GM3e9F6rxZOjjZqCknKxwJ5reEa0BqcOSpcKe2b +wQOUvCjEy+qBDDHHzi62O+XnB+EjW5tvd4sP7QsCzopE1Isp+Y16nr9kxNW4f6El8qozqqkXDvmW +tA9uYwiBVOEyDyXgbUIi+1sAu/kMa7PdkqK6y96K2sUI/qblXwwGUdwbcODPBxHia6sEl+QhIX39 +QMi/SNVo3qiXrjSaBxq98AXEV4XetrgPel8snotW0mrPTHc0bEbmAhZsBshKyGh0bCb1fD4KFW9z +p8e5cH8Cc/q5Sq5IxOtGNqOv0htE1Aa4gIBudA3L52KAW4o7/q4XwSSZu3uZglltxhPdzYsdejs5 +mBFEKD4VpwuYC4qbRu5J8CcTRlnBZPEpA/9MgY20/ZWGfCOqWv0n8M0NpIlKHKlBMFIljgx3svwS +h4Z5JWHhgqkQMkHuqNwpafYkBENFv8koMXzzBaSFOtnF+y6aDzTlZ+L+BToc3M4nYOH5m0r+rZdt +a5hQlSDY5glciBMVHZDl3DfUOD7OEcbOQAf3I8SJ4dSfsqJaAlgPfoaZK2Q4WNLYyiHFOWsaaS8t +Y0h7Bl+dQjUnAwS4MMd6zQ47KqmUO/RsM5/dBJ9dzWDjG83dB5KmFFaDiHaLOhCR/PZhURbQFSqU +vKcVlQ0929xMH5aJdmBYmEwORrtqFQLoB+hehVJAAUF0NtmEDsTd3UVWBtENabZKuQ+RGsLrV3za +i9E7e48kwHEhCilHsivRU0hjcfz0efoKt/jTVGIzrzMN5reCYplj6uNS1pSeFSUJFZiGquYmfHGP +cKfSk4OK0rKbud1tSLrJASWpJfh+BiD+NpmyvtgyLIQrrct8A3a6gVeAmT7uQClWet2Q7shIbonj +6V+fqZX3++hQxFguDJ0e+FKIynN88+sa4ClSAp3GY2iDG2+LgF44MLJyRERCYVqTkfCkRsL88VxG +gu7GjogKBY8Tuqm6u0NGgS8Qzj+0XyQkgPGokcBPLJEgoWB3W4WCw/z3SIWCw1BhglAAKFnsVqr/ +jZbEGQmACfUSuFOaP++JKKDmpBkd4Fs17rVISCiEfbcxShQxEia5+0cFCaHm9tWTBR2I19HKVcsB +HzMjJVsQEe+0qI0cls4BlFF4HkPMDABaF9cg4gtuKSU+OUwsuRpRa5pGnF8ahQ1NR6MWIFzhAXH+ +aNzFNOjMZSgkgmgcnmvHQNqPAduVtvwpSkkguC1lNaab5ZO8pl1iV2kHS6VfWNR5B4sTWpbGwsvT +WGLBMahojFyWxsLL09iuJQgXADCNxVyQqQaEfhoOqBRpzBYTxJIUkYj4Ai4wYQvCDefzBWxBWKHS +1WpAAHG1t2chokq4Jmwk901BEMtOQ7UzfIHFpkF5GgPa+/pR0M77s8IcnOYjeAyTNKu59OuN0ssA +RSK7xQQV9T4GHbekliUqKm5GEZ64JeVGuTGTQwq3pJbd4hSp/ZPS8TGKFo2FULsODNLMFHtkkFWm +aPrp8m0IWxGKTVd8Se2LZt95Zyjatne9GPVaaUeJROM7hqxheEfE9DMGv44jG4Q+vN5Etl9QOk7c +CqKgH2QKY++abApj31rw4Oob/JmJ4T+fpx1kKAbp7f39t9Jr+BHVf3nJfMjmakj2+j0T7VAoJdmn +qV2VY001g3QmqnKrBQ+raelFKa68QPddyC4YYOyqPG6HN+Oc5ClLoWmE1T2XMxGVW03Vc7mkOPRe +UE1o5IWrJkSvQvmcgO6BCM5MAcYzhS255kugIU33MoIdZ80xCcn+Miar19tUMB2CSY2XcdG3xuUh +5VwSuLrchGxVztEDEWzr4ZEUfaL3pUjitNaD/KCOzX8qzKXaUqf1OO6FCG8LBNWvBYrRZPgls0fc +bCuGN6IxyfT+/3u79r20lS38BHmHUKtyTTKTTC7eqoIILSoVUUErgqRotaBczt79Zz/7WWtmcgHR +srXn1F9xZkhWsq4z862VKNCnZ3Va4e79RF+A4jx6yosUjRhFoi+NNjL19aG9VbcOd5xv3aSE4pq1 +hLTfxgUNtXEdmRdNTbr3EUJylo0jbqVNDBVnmgTbmmUiYKDCzRGTrYc6la3JxRVPA9K9VLslW7TH +kADjBMDGWs1tpNjU8L0oA9p6qBji7NbkWNK+Tp3fhsAajSNu690f4RdW6AWdkJcmTw== + + + LcV24isCIxDWttlICqBr73KHe3w6wPVqj/IQcOyMRM6tZISch2D3KseUsOpYrC5KKW55WM6CM0Mp +E4I/4NjbiW9cwJgfzfLX94GHbZT1u/OxJqCqu+xahkcn8+P63ud5T+0oy+B8h1+E1YYf+FVd7pFn +gHaO5M9g7Bxx2srzCJOECNO533340C+S7JXjc3lyXr4YEe414/FonAdcthDMXKEmsl9Puhz3QseV +ENp+z0KJHWoyfQeW+s+W4hKHqS41HFU/njz4w6PhXe+ur2aVdUXfKRNS73cHxaHvn/h/jwuDm8lP +vz9W11R9p5Yvl11W8G8GXV/lNSjs2olhDAJak+U18UzkVN2NQKEL3739+9LS8Wa78N1obMWqcvgW +f/Xx5CmRvf0Bq5NE5kZbTmRb3YtElhZriWRplMVuQ8AQIWfP82HXYCR2eqngD3cne5mDytkMgM5n +S+/6ZH9TWd472/WPt/VRb0Mv7TS/FJrF09q2PjYGHKmYBQcFp2Gyck5uczik45VEauPQSuT01VPM +cRaAl48FV09kU9vbOPo5kfn64RD5O8QvPiVyO2Y3kT04LyXST0tDtH9XIkjFCRbK0YyEhqP8TbHV +CnywOuCOoQgXItleD5Hd0ycZYxEkxrNDkFjnXaxES8rWDz8tvQisJ+5FvLuWRG8s5WTswBd7SBLf +62vjAHEux2Yqo9Qee8EUtngGKso/Kcv/uwxUlH8SqPfiGSjswtIiAd3qdkS7JVH2apEvGdIQ2Pxd +bmiYhXd5NVXFBf8/AtVWj3Sca7NwgaeP0K1zsmmhHL16YYbzYSaWi+quaDAhNSrRPH4dXIUbexMk +VtDbGytrvf5qvbixZ/2YgUGxHuFrvLgqqLAKawE8uMN+PqI4j554tmFhisF7jDnF1Gf3q+fuF7dX +/ZNCubuZkN7UOCdhmolO5W9SD62lYNJsWyHr7bh5dY54PM3KkNup69LsO+cG6VTKKWjBckPMK50r +uuWVKeiq08ZaB9nuWpyEVO39MaeY4wVQ0D0Plkn3F0bQuoqsrRNfyt13zdgXVwmzBbzw2f364GmZ +8zJdj5GP11CB1cbDTBgFfh9mMFpCoMFosiHLKrbuP4lYk316PJofZsI4xv28u6KvSBhfTMcHfcnu +kZ8O1tmrm7W0TG9DaOLLbjRnQy67z/baYq6F4IIzUCkpJmZ/dI/7rVJahhTyQaeF3EWGp7fDaT0n +nwHmOW4skTmX66/9Lyn5DBor6vPLBCH+BAaJdaZBsSlEBiuJqTBtZo0ucurJmQW6mJrFXgBiTZho +0uLZ9ce8Ufi8MTCeRx2YX2SaaTPNM2wiF5XhehO7nv0rjnUf5uRM/bimL5yTFLSfPdkRvvtDqDGy +Jyz9GG7qP6It4rzEDr4t+muQ2BlmZnJDw+HGp1oc+zDKl1ltmsTtVr2V3guTWPWZJBaOLcVTWE36 +eSaFZextHAkCIuP19TmJyRSJ0kop7ipWbTWYrzFvmj2k+FpRtKdSBltaOKbzMf7uwi2w2mztCdeX +QxFmYHJszixa374tTv7kNY4oE5m1SshMzvrP4zB91HglfYSe8/v0kcwQz8udiHerLpg7mZM5iWGY +yvKbIA7+UkMhgqu4CHhGT4qgGYkAeMH7iQsBF/q/EUJ74zASgXnxQNxIBLjO1mbSiNG71xcRwiJI +/+t4NP+jyK/n0F5NI+IfigukeDljSAtmIvHvUr3DFoOnDl66i8XuoTV8nYDQy6skOqP3udT+7ST0 +yjdqo3r5uIBNQ7SMkZix6WrrBbdYVJRVfxRFyzclZreqg8Tv76ERVB/Ov4thULlgNX5GJIzSQeNm +Kg1+GdpvI6Z4o/itdDxjY/w1Bu+xsVr/3Tbmj995Dw+Jd9vYaf/dNtYY/KvQ+5xAZxja2Csm0nyN +jduFRfmijd1P3qeNRivmrkJi8yTxKonOv4t8OIvNkvCH79NG43Y0Y1JSYosbVeP+DYY99T6mrUZ/ +8k42hol5ngH7l8XZmHx44z2E6+Tm0tLv/JOOLiMSidXT21r8Hjqdl+eA2Iz8miQ6/tN77gGjZef2 +nUbVuR+9N1p2+uPfhrpX56HO0yS2Tn6Ti3cmiXj3ZunDVHdliW8VBFKM5YifMohO2DMIieGPt12+ +wIz2dLFtX/vjz0uxlV/dbLCgCrPFt4y5oOr1ciT2lWHRKkLVspUUaB5shdPTW2G+M87Kbl7j+2Yt +PE0PAfbLCA5GicHGNoa4/bkMVJR/4lf5H2WgovyTMp2BQhhsv045KhYHeqr5DAfOJNBTLeeCTeok +LXeB1YomsDV81zl0jw1c/RP46KJe9Oq5IGt+OulrsrT7o5YKclFlrstMHClsHGn8Kuaua7rr/lXq +e/7WLh7tPrhLbgy6FjAtbLzlc+bPUgjR7r1xrP8rivPoKdMU60ZE0a5vruV36ivr1/lb58vjzslO +/0xAcbsX6SuZaLo5DyumT8zo2YW4djuVbAyDbUsAsnMsnm3AJ9xTotX+cCoAuAgaortNs4S5kQZP +tPCWVGynxwS2JhDa+7omahxJWPWcC9NCuTgue9+mMWAthgjf96wAP2oyycu5scS3ZhGsJp42nFtg +nflz5dUcVZhfYP0Hy6uV5RcLrP9gebXIRc0tsM68pbx69M+Wsg4mVSaktdfvxnNMyvIyjNT88eQR +D2CtXb9316+0f/lDhajix4Af+G2qhJkqE32GH5WOkhz63ZRa6SvLLX1nOC7c3YzvBv328Je6BkNE +1XcHgwc1uVOuFc/Uvb8fB8OxyqmrJwM1X6ulMKf16nGnd6O7zoM/dbx+flCplwvqmiquv45nEqMF +dwDD4hhguKUY6g78P/8LPo4UQzPgnwkMvNwQP+dtxZCMw9m/oPMZGj9g6C/VUg/Ui2+G2kXCxwp1 +Nc8wQTamxmyTqT8V6mguMZhKLM2xma1SW8O8H2EaM02qUktjnuli3/JsW80rxNMotWw8wbRsB397 +BnVVF+h4pqUSRzMcRlUTDvMsD86gVCPUIGqOaq5pQsM0Nds2qEo0j9qOrZpEI4zCXRmayWwLTjEN +uBxcnhDNsj1HpR6cyjyVUM22CNzlDB95pfiCTjGTqZf7Y5B5d9Dx1epDG75U87d3D131pN0T4jde +OebXox/XUaQED7iyHGgQYIvSuH48E//hV6ZDGYOGxVyXWqgrkDi1BG+24zioA1tjxGPIneVQ4BaE +bWPPc2AUVGB6pugzMGgQqKG5FioFBOuBlYPIPdcxQQXMIihXT7NA+KoFhzFHaMBhjgu34Zq2RywV +5Gu6cG0TTkRKIE+HwrU8jTGbawBGqGd6qBP4raKZMM/CmzZsx1Jnmfj/KSA9AR24tgFGhvyAVXoe +NBzXY5YbuUFbIbZme4anUlQUISBnHDHgaFMzLM9VKzhAPIKCgiPgUOiDBpnKYNhCW5Z98AmTcTOb +HeE0DGITFBQ4iIvCd11UDviFZxFUn+WhUhgqyUXRzoxUcATlzkc8cEI+YuNNo61DE7/jLcfAE21B +JehU0IIsC/QaEADtEWJhDNQIygf8hzrIECjcMLh+Z0Yqc0bASijzuJ2B0RC0Go+CN4LSHRQX+C1z +KXJuE3BfcNvpgQoO2NTjVmTBLz7ApeOBH7sWGCIFeYKpQvSgYLPQh6ZhegayGOvwMz0Xbs8Ejgjh +FmmBYrnXgRSBR1Cr46ABAHdhu4Le4pi2qebwSOEvrmbaDp7qeoQHohlTyT8znoryHWaYQkiYoBmA +aHgANZhr8xHLdbmQPOQEHMbEOIhfkDhX0wNczJ6HInAMKWQDVAk+TMCwsM9dFkRIGJHBcWqEU8BT +QS+UgQmCJi0eHangk2JgQD1CTDZc4dzxgQofMD3CBzD8Y5+6puhjDII+QSahj2oSJOIjFRQEs/i0 +QCjDeQRMhFskKNiKbJfFbZdJU3chRhIe6mwH/VA0bXQAeXzQ4fq0XNAnXMngU5MNhsFcPntATMAu ++MC0z06NVMIRppkmBEAMoIR5FOKAxd0F+oxQDI94JbTs2RGgAVMQRnTwBRukrFJUK3gz4QZtqrOW +kn9mO2hT6bpS2RVrGVjZ8DVELgfLnGq7558M23cPsLLpjdr/8dV2vz8Yt8f+I3yj9ob+aDwY+uro +dvAXjsApweGwRjoqKv8FU+chhw== + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/originals/SVG_files/Audio.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/originals/SVG_files/Audio.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,1662 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + + + + + + + + + + + + eJzsvWuTHMlxIPgL8j/0faAZaXdoZcYzg7d2ZvVqLW/Bh3FIiTLZ2hg4Aw2xiwbmMBjqeL/+/B0e +WdVAAyhJFLc7gUbDO8rTwyPCw1/h8ZP/7TdfPdt9+/aPL5/F2/lm+slPDu9evnj/9t3Pbwh684vX +r3/84f07BP30tz+7WdLtDI12v1i/lob/8PLdD6/evvk5/Yp+eYef/ulXL/748uWbFze7H16/uP/Z +zU9/Br/53av3r1/C7+5evvz29oc/f/czfR8gOL54D79alr+bw9+FeZlv5vbzVLDBizd/fvHDD6/+ +P/x1iWsE2P7tj2++ffXmu/3b//fnN/PNs+UmBvgDv/mvr3778oftr+db+OC8Fmq13LbWMjQ9vv3m +x/uXb97/5t3bb17+8MPh7eu37374+c3hLy/e3PzyxXfwmxc3//Ty9eu3/3qzf/3im/85Qbfz13ev +Xr+EHt6/eH+zUH93v1jC1/sfX73+9lc/3v/xJfQ9lorg+DWh/P0PgAvQ4s8Irl//4h4gX718/x5I +hBcizw6//Kf/dgBGv72ndkg1EH2zwL8//c3uV7/79a9O8Lp2c0CW/e/0W/jffJvy0CIs2TcJBTHg +P67J0CLC52/bgCNWbvDbv997zhBJ2PCff/vyu1c0JWDU/vvPpKfv3n5//+Ld//yBm8lo4G9+9/L+ ++9cwtjQWS7nNN0vGb/qTtAKuUotnca03z0KJ8OvYyk1o1qaP18s/v3r5rz+/+dXbNy95UHbv3n/F +EySleebv/Jvf/vj65bvfv3n1HigrCGo8Kr98++3L19DePn/3+sV3P2gnl/6dG/zuxbvvXr6HqfX2 +9Y/vabqv+gYY9ecv/vISp87CL/j19y/f/O7tPxCNz2q8LaXkm7LIv8Dhst6UCKO70itiA0Y0eTO/ +lUae0SMyRKXvgKn1k9/A/Pn1u1ffvXrzc6Gwfv3371592+dUDTcrf6NO3K7ub9O/TC10/P37l2+E +epjLh1+6uTnf/vIreOPpzbeHt/fI/R9w+cEMeAOT4/Xb7/h39jP9Bj7+4/dMPf3/axio37x79QZx +Tr+i36xf/+b1j/Crv3/39sfvf/HmX95OP2V587t3L76BZje//uP/ePnNe5AbAug/ffXjq/cvb1+8 ++v5nH0T0m9cv3rx4d0Nw+DADn7/6M/zmBZBywx+D33TYx5EeX/4LLP3+WYae3vz55eu337/scIO8 +ePPtzT++ePf9x1HDMLxzGOi/+u8jevvi/Z9ASr188+0PRhb/d+wowz6O76tvcFK8u9m/+/GHP938 +7u3b14Z2/JVhFzBBsf1fxzt+Qx948+s3zKDzN0mD7ZtAIPzVvQVaP/wG+OVfM/bDi9evX3337sX3 +f3r1zaUXXPi9vYl/9ykT6y/3f3z7+tUP930+OchvXrx7/+qb1y+/+ssP71/efwgbcuNfXr35FiYi +CZ1O7dv771HFuPnqTy++f0k43//pjlp+ZQjz1yAYveh79uwDMjHEm/0b9/u/f/fi21cgbkFb2r/+ +8eXNb+G/L17fKPhn02UwiHtA9O30z9N/mWb8WuY4pznPFZ51bvNu3s/H+TTfLQtoC3FJS17KUpe2 +7Jb9cliOyynMYQkhpFBChWcNLezCPhymcAyncBfnuMQQY8yxxAr6WIu7uI8HeI7xFO/SnJYU4cnw +lFRTS7u0T4d0TKd0l4GWvOSQY05TzrnAU/OaW97lfT7kU74rc1kKaAAFPg2/LtP/pZ3pX4v9XS7+ +DzXIYN+j/AXSiB1xzhNxBf/q9yJ/k/xUgGMFeKbfV+If/m3upx383cP33UT/HIi9B/iLTObvwGxg +NxIHX9AZUN3gKy79h/8y3d3dne6Od4e7/d3ursGz3tW7cpfv0l28C3fL3Xy6O51Ox9PhtD/tTu20 +nuqpnPIpneIpnBZ4F3z8eDoej4fj/ribju24HuuxHPMxHeMxHBcg6+5wOhwPh8P+sDu0w3qoh3LI +hwRDFw4LkH63P+2P+8N+v9/t237d133Z533ax32Y9gv072532h13h91+t9u13bqru7LLu7SLu7Bb +gBV3NFZ3d9Qd7NCROoXdwo7trHPYvUpdxE5iNxN1FTuL3YUO44NITqeJeo59P1D/kQPIg0Z8QE4g +L5AbmTiCPEGuIF/wmY07yB/4moBJyCZgFDyNeLUSv5BjyDPkWuqdOf86PfI5bp/pHCQ8esyzP3+m +C8Dd+QOdSTc/+Xr/DvpU8KvSs8LT5IHBLHt6YF4AH5Cpd5VERwURAcIg0pMqLFn4MH+ttU21wbOr ++wpTCpkII3K30opZF3hAhqwgKNa0wkpf6Z1rXfGrrTCLVphq64GG4IRTo80TLC0QSS202FID4QDk +1QatwXTb0QPzs8EcxrGjiQCzChYhCDGYiQHmY4RZmWBuYqeAMhpKXH+0DgM9C4lAfhKIwgiiMNNP ++D2BWMz0FHqQAwU7Q8Kywb+7iX7Y40vh+16+H+iB9QbfTyhNcTYHkkP0rhjwCyQoSFh8QBaClAWB +F9aJhG0jgbsLsChB4h7h+wm+08IA2YvSdwHpixhQzIIghTFBu7iSNF6h7w3kMUnkB6QNcouXD/EP ++Yj8RL424jKOZyG+JxiBCBRhV2ccHBiiIwzWAYZsh01hEOtEI5phfCON9QLy8g5XJcyEA8wKHIEG +E6XCpMkwfRKQGoChMyx/nGRHmG57GKkGaCpaSRPI/QQ7QADOzyAfTrAiD7A/7ICkFScf7BoZ9pcI +zFtAZN/Boj/CFrOHQW9phTcU2HwS8CfASM6R5RKuaXqiPUEeGq/jzI8sNpE3BxIWB/7a07Ojp03I +uAMx40AzH5cNCNRMQjWRYEXRGki84jOTkL0jQYui9kjiFgUufu0mkruNZC9K38qrEWQwSuFEkhhk +MTw00/YziWQUyiiWjySaUTijeEYB3ViCXZAGF5722Gca/rt+0lMvPdNFcHnkk8+fLuv+2ab9zQd+ +4CfA33KT59vaYgWrGRCA6fv15yPY/wBvTzOIz4BNS2o1XsRSAkxkNMlXWNrUpq0zrDrFWG9jW+JN +zLct507X9VETxbC0lqWg3whUsDVdRBtSndFncVtASUzkRAJ9CRoL2uUW1a0bUMU6uVfGC7Tuj6Zo +qwZ8WYW+e/Hty5v3b2/+8U+oxk+b/8NQBVaakZIMIoh+iBVU1HPxCSS1sOQ6/oBUjpMO8dwonoud +5Y+PPyAem0gj/66Hkob5C9HNgK7mm+vRZwg/ZWD//t3Ll2+8VbQBEFaxh0yIJhOi80aEqvg0Aep0 +3ERaRSAdYyZdVzbQg9s6+7YJGydJX9iicbOeYfvGbXwPG3uD/T6THrCAboB6wg62V1Q3Iugnd7AD +oSmBlkiYz762ltB5A5L5XYJmUbDBMrsLol4HtEgGJRuti5Pp2fvBygDNehKVehlMjSNtjfSdjbQm +9lIWuwpNrSiGmD6f8PW4vpL1iPYjW5AH0BXQELgTS5JtSbMmRfNdRePdaLuo705O2U2k7BZSdldU +dVHPpbc67ZR100Za6YH0UdZFA2mhmTTQFWbIDubVAebZHcy6BeZfhJmYgYAKm33DvX8PqsAReH8H +isICSkMEFSIDdRUUDN7LTQFcSAFEMxy/kqmC1FVW00kZRPO8kYm+IzNdFEMy1uGZcFgjGV6JxiuR +6suaKeL0ZoPryE6WCS6YIy2eO+rWLF0L9CZebJnnxkqW8pE8D5HU6pU05iNMx0B6cBVPg7oZsHds +hNG05C+YqjxtaQIvMp1JOSYbksadHtQsLrgO+hfPR3YQROp9NssfqKUPk07KWmlBXwWppayYLtiS +lFNWT1FBZRUVlFT68Adt5S46uuBIrGvzUO9Ik8dnFe2+yvDiQPOQ8xdOBJ4U0A8/YsJGYqRYCqtM +hv3gr8ERT+axAUWevDaj3wbGbCLHTYR2mbRwXnl91Y1rrq83tjLZvhxsy4lMy2CrrRuWvNp2W6tS +7Eq2KtmmVKsSP7JOZFSqWXkgs5KcBGhW0sN2ZSDOJrMuC63iKlYmrma2NPfTmampD5ucs5idbHiy +6cnGJxug/iEOTPLPB6fmZ379rSJc7N/FHHsL7y0T+fWi+PdIPrrtp/9UbFuqtEUVWejV/Z9cexP7 +LWh8aE0UWQ17txJwGWTnurRNxzkvi2wzPOlhysN0hznPW0uSLaXZ9D7RtA42pdlFgjMZbe2jzGCd +u7LvTDRhdzZDTzInefPJtvnsZPM5krS+I+sxiITmLajCNN+hCboni5S2IdiIFrJeI1mzhWzclaze +HRnC+HVCY5kM54VMadxWMrnRcM2u03ElD9tedIUjiPI7dMmRLhHoQZcdso+kArnzeM3SxkLKyF6N +8dORN4Ojd22Aab83R5668JKY94sY9Ccx4tn5qe7PIrZ6FBudnaCnyQzzndjjVbyheVQfN6rjToQ9 +i/uuOIaJpT7qjeR7OYr0H70uZeN1Gf0uJ3KRHchdtpvM/bLCRGH/S6apE80Ls+BMJmuafTFHmmp7 +8cjsSN6t5JepYPOQmpPNQRPJSRPIUbPIKuGd9SROmyM5bvgRT0XZ2dMmlqqsj5oz1/ly94MvVz25 +3Zerntzuy53VlzsdT+bOVV9u9+Y28+Z2f252np/B48Pensk5ey64ei74ec49PYOvZ0Jnz+Du8Q4f +5/Shpzm/j/p+1PvDsy6P9ks0V1BwDqFFbRqza/Q5DQ9xapJ/cHw+MShgYYGHogLTNjAg6s5W4TGV +hyb5SZyL7FrUmU1+xYkm9WLT+WgTuekEppkb1bUozsWjORfVvVhZkZucJneux+3E1biSqxGdjexu +RIcjuRzJ6chuxyPNgP1E3kf2P6IHEn2QhVSqRJ7ISN7IQMoWm0aodvME53nJk0gHd8ca4OC4N6Ew +D0LhoELB8a2aTzadyQNj3yRCQMWAX/+69ufBTet5Kc5az8jpAh89F5M4bQO51j0P9+K8bQPz0tS9 +uMYx5tXeFORVVONsKjErxGhz3232iYPsFOuwSzw+OLYJjU20COaPhcbE3d5nf1f4+9w/sFjXwVN3 +ujrTx/nOs11kM40Pjs2ORO5qoxJKmMSF3kekudHgsWAH+olGQaewTd6RgaSP71lhsSjPsonvVFNd +RiX8ThRwVb6BlEn0btW4uyLjVZmwieeszgx1JigOxGT2p+o2rN2sJF93JHMPJIdPYmnPpuSwvZ1N +0UFVZzeZroN7A+4Rqu10fSfRBmM6j6g8KF3hPSxgWWniZ2/K00HQHi3acGfqlL5EXxQsaoGxSXmn +vlffXSWUucpGyFTsZINkJUwVsaNsoifeUe9EL1PdrOtnQbbhJE+WpziNrWttK5tHE/2zG5Q4p8bZ +078saMoGPmvgUXTwalr4YaOHp0ET36sp6jTx3HXxSZTxo8Q2VRvPpo/vbHrfPaiR72VKU6hyo5IP +rqBLzqDRHaQaubqE4uS8QqtMWZ2w7BhaTCPPTifXiXXwG4aELF12h+R3LBJ/LJThsQ== + + + WsjxyN6XwXGQyHFAroNJsj32NBFP4jdS/0H3IPBoqQ/hSCPWsz8WcyO4HJAqXry9+RO8RyGYFy/b +cK5D1Jr9CsdJ3XgStF5kI1NvnvoYvJehSfx656SbyLd6N7lAtgazu+thDGnrs0pwWz0Ru3Xfn2kV +XVJWqi6bIVAmzorusljMcdEfcQ9N9G0Q05TBE0G2FyKX8necV01Td9QNdCeuP3YC6VLrCy1M5vYp +j1tnMCBHGwkcA+9HRR+qMHrcQvoGgl/DOpPuJ/HW9GwAds8cJ7fSHtou9m7FyXZhnspsdrAsu0k2 +C9koLmwVuln47cKtQ79joEifhm1DN47kNo9C9spWhO/s2Y9ifBLHuxt358HfiQfffPhiT11y4u8H ++7laCkycRD1SS+k0mNHdkK5iDqkp3Y1pDXWLxTOZQT2a1BraPg9rb0LaYlyreZ0nC8y40MwH0ht8 +gkPx0Ro1uSe2uQcVWy1vr2jvZH2rul1FCmQzxNkUF9NFNfBFxMlskW7dPo/2HOzZDw9LqN1E38is +9jH1MRzeM6o0q0ozqyTsY4EfF/qZXJ7VwfZs3cOby7nq1no1NSC7DCyx3Scz34NLyFpUz3ApUCdn +0R/Nru+2vdj3kyyFZs9qT+dgsSe7J11IAIEZHtyzuGfuzyYN6zQ8x/GZDudf+7Nn98DTzh/SHTkM +cp7zZxl/DyT8fdCqmcRD8XEDf2vdjPaN2fiT+bV0qamZk4Ysou7JUpN1a64ubPdMLotobx6r6kzV +OJip3uTfmzlULX6TpgsBHM4v8iEcCeJYrpE6ALwLQJwAk9iwJ5lb5AsQa5btWXYIsFWrli3bVtnc +A6k7CaYx7IbJBEAD2LU+jr6WsKwekOqa6AfYOgOd6gmcQcGB/xBuUQcaEwqui5aSCuoyQwNsNqfc +KN2ktEa5AGSa45GjlOeGL8kwMgFTABbGbSkKLd4GmAmd0KtilRyXADMTEYQGuBBjaPOSh74vSy0I +KcqEgF3veT43JdxGmCc+xeWaaInSZQWcA4JQCqAYhi1DX5EdjZDTOR/GFtstbms3MWECkKP0umiJ +0i+fTqncUorQgsxJ4ZozdYuaU2DWGse8qSWsaeBKI38S/lBDTjSiM7JFGVFv4Q2YtrQ0lwlzXbyf +khDz/NWbl3TsyTJitpCe7bQ5IoDRMD4gcLADAng8oA4G5J0cD4gUsi/9eAAajlOP228sjJPYF3ET +UrtkzLug2pRPYl9srYvDmQmvtsW5Ce/8U5MlH7etJT+4prqd4X1T+3aWcTxdtDjU5ui5Eodu67tM +ibNcCfTzq8tKTRF2XO0kYOCcV2aTdKtELZMk0YlyWFF/YPfVSYJ07LAqZGHsxEElUyHIZMiaBSET +gs+MzHJqpJ8bWckudd4FnSCTpDhncTG4WeLOkKThFMk2KyF4789kNumj3D8XDdPV5fyQp+BknoLg +sn3qWe7ByXIPej67OoVsOk1bd6ebVWGTbbDNZh9y2TWpYHLJ7HljzXp79uQ8SMFZs1vP53GiiG6E +eYH2KtqpR3I2BpoQ9dg+NhXGyTC7Q0R9Omga/FEmwzwNAmOcDN3btLhElaL+JpsSw6SYHvAJjtNi +OzH2myh9TwzL04U8lVHELJsUlSEhbOs0WudpK3dspnjRc3myXJwuk8tKOTv7MPjJ+2QZHR/OU45u +D4xc4BzB2YFC5STB/iSTo/3tJKj03MPwQLZXtdNcdI7rfIZzutr5IbloLlRJXKOJrNsfTt/DRP61 +hUQZ7nssw+5gmkba6zB/6ghTcoGpiAm0TV1nMOcizLUV5tehnmAyRZhEFUNEh/UE1EaYGxWmwwEm +wALDXijP4wiSIIAEqDSuJ9geAo3oDlM13FJfQfIfjiewwsMEK6dQusUBvfB3C6XSFZiRO3Rc3dmp +Ln9E7XMOqA3G6nTN42lopk4fP572oaQ7M0wt/jxdjMPpkRYfh/PHWc4Os/STLNOFoyyfeJCFwp8c +/GxxnSzuGS3ieaIjQ5xnvNLJogyTlLKN6SzSiTKO95RzvNKhJj70hAeiYDnd0bnFA6Ug93TeRPlV +i2YXP02Fp6nwNBWepoKbCs5dtZZ5Jt8CaGelNbLJW05Si4Tsz0vnWz7tY3KG5dNOZn3Jqa5PPJny +1dt/ec91g27+4dV3b16+p4NHl6D9zL7yYFIeTMqDaZlmeoTNj2/5yAHBczJlvQWtM93UeAuKbfik +kbn0eRqix3z2tuQlJKyNExf8QLxZ19saQ/s0Eh5G83hKWv68mTl+8lMmyu/fvHlx//Lbm+8EdAMr +DmbKRTBNR/HdbKovXLSZL7pYHjCZpzN7udoZGX8afNnkTIxZEy5vYrKQbnGpE87l4sK63eVSzSw+ +SwXaulryWS7QEN4VNwsZxQ8bM752xHm9iCh/tVhELxpRsIZEtx6qVYNgI3lHHp4DmRK9HAQXg6C/ +8M47OYyO52Hwb5hA5AY7ga5nz/ncOZ46r3zunOyQHYnrfsj8ZAfMgxwyB/E+0enyQmdrNM+DMz32 +ZH/z0XLM74E9go6P6Jmi/MDR8WtsyX5Hnq6xJfsdebrGlux35Onzt+R+dmlbuGJbtmJbtGJbssLV +q5iGBGdXrmJIbZ4t+tdzmvdD0F7D9mVykXsXux+i9/2Y+u4sgL8N4VOtkPPD6R+J43OiPOuUYxGL +S2fNzw+J503ku8e+47QJf7sQ+FkQXPPTjxcj4RILn1wwvIfDzwPiPSQ+BMVdUruM9zSGxV1g/PSx +wPioesHSb2v+kFIDm9jSyrxybArkDf6AoZN0UUu6FkKOujWQX4nieOu8XEYWYI3TKfGiP0gY6rLS +eD2UX7Znh/Xing1gv2fz2JIevbfNYidpXpQUImeR1DV16Sht6IegJufb+qSTtf7r0t7Ivl+OCFE8 +iDaq5EpFcSRIy0Q1SR5ERy55vyZSTfYS+QlUDqoXgwKFhNSRHu/ZkReMXbN2fIooM89ktGSrfgTJ +J1mdLG92GZJze3ou6SeThD12lkilebB3LvlVk1414dUnuq6nNmZdfVJ1oEvlfzaFgKZPqf/zUNEf +FqWfaYZfsMJpw5++fMeXqiQu6fxgyf+r7aS6l+puqiauGrmc9V/Mzo0Tm7pm7Kq5qwavmrxq9KrZ +q4Yvmb6bwiG5zC14SVJTDhzfVwsR9X6UepiCsIB2US7bml+KabR2YUWtmeTssmDZDh9X5uoeroDG +TKAHa0pcC+WXic94UXrGsZ5dUx/98MhhJ/ezfw7D43O6jtP4X1HP3TMucjt+GYck1EvH/seD/6Nh +cqdx38nO/5fLxxP860nKXKh0c6b0fMIzjVrS+UPrdNSuP0G5/lxvl09ff9ovn/bLp/3yP81+GTNI +CL91ZFjgPm+LthMu6AS/5BSoi/vll2Li/fLLdt24AGitV9vFFd/f+l6eLm/mKY6mEH49pZ49pZ49 +pZ49pZ49pZ49pZ49pZ49pZ49pZ49JZk85Rs9TYWnqfA0FT4r9Qz33E9K6lrQJm5fkBUmCB6bYaSH +EfPtjMe+PiP5TT/6hUZ6u2ykN2ekO48dqciqHpNuYYZ1dDUjulGtmjCXixD918wi0nrVoPa6Lmu5 +Y0rR3VAewhdhcUURp8dX4v3Pq11ynlKQ72wmwfeNc/VD14Ccl/P/aI3+6YFa/I+JQZwHFUAe9HSM +bVLGWXIGX9vwMU/rJwrp6QFf62eL6OmhXKRzEc0ZQR8qzhEs++ckHf9AeQ5mwjSc9T9aps95cY44 +1Lm8s9SentizKoeK5fR8sNblA+IXOFOWclGMSm4ISLqKJ14pbWTJpX04SfcLEY4+11Lmhf24axwd +unbSOdGRbPOTfsTj+oUIv0yU58v+VgDj5ZJP/tYnf+uTv/XJ3/rkb33ytz75W5/8rU/+1ifPypOT +7WkqPE2Fp6nwZf5Wu3Vj3QyjDiIO4aVbEh48ZDQNtyKMN2GOJ43GmzD9NW7DUaPp4lmj5MoWLq5c +qL+TQ6sX6p0cUiJ0ctX3/VQZSxhGX8JwmDE6Z2zGTA9OGT6IxrNF58qHZorMk0kmSp8mnPg3XkPX +58d2doxzA2bGhBODZoXOiT4jKIeWnXQNVjNOgiDJj7iGcQVnGO4FhlhL57ezc2PmYXL+pf0ka3i8 +TCVfLPY6FnrdXb5RZZJl/tDtCeejONyb4G5R4bqsu+mhS20319rquF46ZDhIg+lBcYDD/HFxsLMk +T5EH00cEghcJXiiMYkEEA86A6YJgcKJBpoKIblzzgYb+RMsaBx6HnC5MuHDfoi8rOozzdHGY+yId +L87po/zgLRmTDbW/OMctWnd98bb0KI93Lz5KYz5tZP/2iozxkoxluG1kf7YVwOhPbvgfsx+4HcHd +heHuwZg2Wb4XdoZhbxh3B7c/8ETAwxMHOXXxoakAKgMqDDsYhEKKwkJKwgFGf4UVkkAxmEEpOIDQ +Xp38OMH2saMpFOAtJ5o8FSRFwB3+CHNlBf5GulbjANOgwsBHIAOv0NjBEGUYyYVuzNjBeGVgyGJn +EhoMSIaBWOhKjP1Et2FkWG8LMJvXGYpSZPACzEXGIltVgiIz9RpP5mCXncS7yVjH93kOTHM8a5vD +C+cHFuSMwt+AXa7uhe5n+pDDMW38S927NLiWpkc6Gj/gZhz90tPnXShx0T9NnsXpA9dJPHCZxIcv +FZ0+cKvoeImEu1f0Q9eKTnJxhLiMyT/oncZV3cZy6OOODnsEOuaR6XjHSld87OlCj9PpbqJrOfkq +zkxXcK7oO0fvNd4uIu6Fp6nwNBWepsLTVPBT4bPKR7X5dpnb52XRyEc/r4xUmW9TbOUL0oYUwyfm +DX1WuawvDTCXy7UNyvqhekTnceDNtTLkF//A0po+srb86tre4eQXmEWGJxeiuVyR6OINZZsI3t5W +3mnSwLALx4xx4fOo8FiZaBMTniyY12+iWS0mrIeDDx8L1yzDT1rcaCxzxP8L/X+T/Bjtu8ZNIqmn +hWseicJa6B5djqfwT6uUQSp0Lpfu0d1taiJtqyKdrC6S1EOiykhaFYm/93JIaZJqSJWuUdlJLSQN +QXI1JIlL08XgWg8pSkWkKMWQ0OpB3X03USxnR3WQ9mQccXhyljpIiW5KeqqEdIVKSIN9+mgHhbgn +LpdR+oxbY10dncPUKypZbtX2ztjzG2Pns8JKVlpp2twV22+K9eWVBt/npsTSWGRpN53VWRorLV32 +f8rlrkO5JXGkTc4L6moubT1ql2owfawO00O1mLIvNjBkAX6oJpOrynS5LhPMhOlCcaZ+VdHl+ky9 +QtOFGk3TUKbJF2q6dIHR4itFXLjGCJ7pQskmf5uRzL3/TAWcQGrMa6VqSzWk9SKyhZPv5tsSJOVt +zanN4YEcuuuh/DIlZy0XlRwAP/rCDC75oDbKJQuFEmIeSrzRvAQ1fi6ZQIMR9BCiYpYUo9smdCGq +wZ46q87wsTjfR6N8jw0YfjRk+BCij8Uez1CNywx2Nr5QZplBGaDrgua51DasCkoUog== + + + vFKZdHzFzOV5fDWMf+2Fbc/WSLiYfxrisHA+llt5sbTnQ6mVMMbToEWPevR4keOYULlNqbSEymm4 +/7fYFXzrUD1ltIfBGuYaOef5X3WTeLo1MLYmxmBkTNusL8cjz6tHJwtOLluwDNzZiSeAs4fSmC5I +nXPJkr3c65gyebSUyYeSJqtciLrD6EvPhtvmw11OnBwNrzOWTENKbt1tr4fGNKmFOl+kyzgJuHMu +s3l7Q6qmNPPtqIFSuiqdcTnK+RY+3YLJyyeqwpNKmaC7cqIFTKNIZ1ka8OlEnEnAi5XOrdxBZ8ls +h04doSMBqK9A854y9jBdbyU67yZK4izALk7gXHoCJ0zk4/EOZFsEOVeBKXuQgHh3crhLPHKfpN1/ +XLmfPqjdb3T7x6j208eyES4nI1Dnrts1zDl+uGsXTJePd2/6eLLFpe7xyH2iZfaxDk6fapl9rHvT +Y3JJzru3cfThG3GDBFWllUT1dGoLXEQnB6r2o5rpHKBbtJluLssbC3VfCyNfaNfiQkhArQI5gYc4 +MuzutLeTrnVDTjwuKZoQGzYG/i6xXtyZr4Xwy7bri968baHSUc9dz/TcSMXNUHs898VvU79PcZ7M +C3+pavmDPkJX9Mz5B73e63VfH0PwcQSvSPtjDV0Hhqk7udCC69LQLZ/V7uMMPtZA8QbvoVskDTma +E62K5dBmn2cvJQilLvgidcGTxT7KJOp6tRrge5d+f3Ier0B/k1GcHc2NlvP+k1X+T0ntq9M1E/u8 +CeBp9FR6Oj2lnlZP7Z0/VejPFTqqB7o95Z52or5TqFwcadxQuaFzf+EsIF2dfH4UcG8Zd6u5qewY +4OaK7k4zUP2Fp6S/2LqYbyOoQmwftQKLAH8oLY9F3gqelltJaqN1jxENKld2WdhfDeMXidMYLolT +gH7hPZsnJ3fODlVNLqhZpXKkD2iKOP3S0167swM+C+o1Dx3wGcKtjzletKXAh3rL5rwZUTCdCTil +Qangs4nXE24XKj0+Urj9R+ZMP+bdn/z26ZKQPH//xp+JpiPXZ4dBo9UKZt0yVlHUK5ur3oX7wXV/ +PZSfGfzFS49z+JLgr2D4MsFz0e0SxyqLj0r0pTTfR2X5PipZ9AGr7UJ64GMSDs8y5x5C50Nzj0lO +oNSERyWp/DWj8z5NlISJ3OW50U3eyMEwHJoXv/n5D/4Go3a7LsO15lfH/IkLb/7Q2ftP+fQXLbh0 +MUKQLgQI9KtXng6W3Mlpntm56oskgnJCaKX4+armQY+i9/rmEjrcFC2/s9g5b6WL3C20UBRdPf9x +IsMnyiIrstyKxdb5tqFVYutqY3CE/UCLlXdjjbWfJg3fcT/5ZSFI0WD+inJCnJ9MkogD8XwzEd9N +xPv4OomtIv+l73ptUaOLi/QCI97w2QI7yBnj8Tv9brImR/dvf04XnjvyfgyBShw3r9XEQZc7Drqc +msZHq/sdpcur9IHVJVKWpo+YxXqR15E8jw+UT3C5aGmydJltIlokn6SmyWzr68SH6utMloCWL1bY +YWf0heyzB3LPdpO44u/kKHLQ5DPJPTtIjfLua/9I9tl0JkM1AU0lqcpSlaYsT1mi7shkO5BcPfox +Vt012fnh1QJrzdJZjpa4sgx6dLZ8lTbJYjJVVtaKKvmanKK3dO2cVn2SrBR/bD5rvtVKrjudON0I ++HBeo/pWdCrB3+lCEtY2w3HMwdrW5NCJJblXE6Ve9dxGnlfo+j+R/zvQhMLptKOpxBMpyETiexOO +FL8INH3qJM77ftIZq13oSeci55zvSCqhT5yPOd+hPxxGu8EIH7Xg/N/Oifd/c4TLAw9N4El2N3Vx +qaMrne1v4752aUM76KUc4362uD3Mx695gfnNaxWTkc3GnRpBd5urBMabAXxuy5jVMmazSEGrachg +GfJWNvkq/gaxMT1lSEuZhnyU8bawMf1kSDsZ0k2GLJNpTC+h1Cb2GI0JTmzIaZqTJjpF2RSXnu40 +ScbTnSTcHF3eE7uZ9GI5Tn5il9OYAqXHQCkRahpyoTQfatFZICNzcnlRR3lLPxwqB0SfDib/7R9M +vlouyWVnxjjKnz3Ok8vn/PKRhrGeHldR7gNjvRnt6bNihx8Y7+nR0cOPjvjGkl3rvGAwrDXYTAJd +qwE7QVzJtSMOnVlyaBaM6D2YlfOlmP7TZeNcLuyJdT3NSnWeEtvldQvvhXKKU3V3Zm+e6Gqj2fZi +3oktMXva5GRLNjapCJqFncgS0itpK92GtIpttzPzTIywybKxI2m+pPvSXGPVl2uJ7ShIfyTL6UQq +/kz2EyrAqAInuiGnYFGeiZI4UBfe0fw+SpUxPpGA/Q/yJKrag0oxqsWoGK+0Wri8lKrHdG/yTFoy +V5riOlN4YiHT0V8uNOVLTR24GpnVI1vkDAOn2eSJMm3WIc+GM21w2Z/n2VCmzWiYRnO189ipcbrQ +mH34JFXuVY6mi2eoVkqM2V0KOGxPT8kZjyicrJPZqwdknbMsvG1xeODslB6cGu6YTpRVM1qtR7tb +Ws1WZOVHysJy7tQ0nJvylqveznYcTk0FyuwulKFzniQGpus0WK6rXKR12f3HxuvHr8t63MVZD16n +NX3kTq2Ld2x96Dm/f+tD92494jau6ULp2scUs33wmR6sdvuxp15+pod+8UC1XHpGi0RZq71X+hSF +Wh1qbiwWO1YzwxLhP/Fq6Ycvl0ZbYXrM5dKPv176kKcL10tf4YLpz7xiWg47+AIid9OF4hK+vMS2 +wASVmHiyPf6WbI8HMiQycCBioKNhiGws7VtSpbSDrIoklvpN9QFV9Hoo/9PppOVi5ASgF2vNk0LD +G/rO3IWXD0FLPvCFzVw90EdKFX/kEWi9M7MOm7nP+aZT0JNzRHdXNG3osqUv7jbMLF5p2drNM82H +o08ozCf2dXHqZ68+293ymkytueXMnfEA694yqu/8QVaue5RoTRda3Y3W+Y5W/GGTXR4pExmlQ6F8 +5M3ttShvJ0qmFpespFSzX/YgWfWdlZX0oh1XpBRPLftq0Vu751tEJ3bY/q/tkuXN5GMV9j981+/5 +Bb4Xjtt9uPL+haN4/pke1Csf+jo+8IgvUU7xUe8/5WzrY/adT0sRf8SuM10vf1oOtkrNIFr3Kx2u +6JWlwoVqYgdXWqpKd85LS1G3JjKysGe8p3L/rMIU9ZF72WuMba+V5e7KxbIT9nlTccrfLcu9H+pO +CQ9OEnXdXC87cSD4wY0XSy5h+nNLdW2Xd0ks9I/pCIkr/39wr/tChOOm26CXlGm44qkVSYTgHbvp +zo03q1LSBF8B8BGt4EsxftEGXS/tz/VLUxif7g94uj/g6f6Ap/sDnu4PeLo/4LMV439fhE/3Bzzd +H/DkFHsqGv80FZ6mwtNU+Le/r/XxRQzHc96f9LH/dP7ydvFMYducKTwZo/dWZG8n2ZXrprx0sZ8u +lZqmf6chu/NzdawLmmCQo8/oMiCHgRRKQiOA1STNkWcFqVEWyJE0fVKPJjnhyK4BtPSy1OLgrPiT +OyZeKUljb5nLlrdMlJnqGq3Ki6/uot5+zTyfJYivnn/NQmf3f8WjgGwX7yh+epCw/klC+7PFAno0 +QAP9RdI+Px7s/0gw/2Nx+/PY/GNi9JtQO8vvz5TTF8Q0Cenpy2sm7tj02FTKH52Y2eSfSkCVgYfB +f1lMEMZpcF8ez9LYVCaqVNxeokCy8QG/JszgNdOZqGVpeSjM1viIot0RCr8i0Mdch1+MkgVkLvN4 +dyl8ILTihRye5MIScfAD1qQI5bK4/FJMXyY8L9a3aGN9CysIqgKHXQx3eiTH+Zq8n2k8ULEpE731 +MF0qET26JR8oEY2+gsl8SlvfpHmSRrlxoVTUtiIth/N2F2rRLhIe7fWzymTloXbOjzjGSpM7tcMR +0x1lgVjUVKQoyc+J0kgyxf44FapZMpTET8cefZGEuXQo+oKMeYSEeVgNnD6uB+p9z/tN4v9YsnRb +tPRSos5pm+E/Fi5dN3n9aUja2abtbMqXTi6Hvx0uFjDlGNWeZqVeY9SjVdt4FauxD1+GIjGrSYNW +w40o/U4UVnC3catLkStWeKXOEcp9L/lZ95Xo1SbTOM7LEAoCpSSMR8k1+tK0CGVaA4iHi5LvOui4 ++BAqaIMsX+uySReBDoI4v3Gn3AMGrh7aMK6H8kMCGgBf/+rtm9+8e/Xm/as33z175uS2/8X0q+/x +N5F/85sX79+/fPcGBPpX/8+PL969/OFm9+a71y+/BVm+Adwsy21KdZV/400ptxjRk38jdPVH7K7Z +An/4C/33/4Yf/wcA//Um3fzy5p//+3zzLcH/8Fv4Z4vz3sEE781zgG3eNcD0s88v4EPYG3rdr2ko +wHIC/YJy0GslNqd5hR0Ht8NaaFuceV5gBVepWBU5F+gPL/AF8FKs65pvwdBMTK+A+F96Jf22XYDI +x56fY0LQv8DfsGIBS9gyV1AZaqU3KCy226WtYfj4JZh+9vkFfPoe+hxwKkNHQYrSexRWltvYwM7z +n78E088+v4BP36M06ec9x2q4Ta0uwqA2z+0SyL95i03fQh8rxQ+Lgtwg8KcuQNwYbDDpC6hbNeln +7x3Ic1a5cAnmZ8OITV9C1MAs0TG9dzD+SBs+fgnm58MW38CtzZgozA+Afv4SzI/AFp++BwRdgG0B +l1meK2zXGEOPINhYViekF6sHSRaAFFwD6c0/0IKbb37L1UcCLE8uJFfTWAKhi1VUulkhh32Rjp+s +uJpv/rDjmsc3/+pnap8rl4bt0mK6sGY32BD0R5b6NXNh2k5eCctQJSlxGVr0ohCZ0Es2F6jn2/l1 +/8DID6txA/PEX5qvTCrs8gvVvgsRwx8XeSvbkbNoQDoC/UzrMEtFmlyaPcqtSzAvObb4Oq0VlP1I ++2NdeGpBu1yI0Q3jnCiwNWEjs4lDlTRwVx1EuFvKl4QpFrrayFwBuVV7Qfb/8UoTfyuM/TytMIRJ +2GLC9ALML8hLwv2qw0+bKMjOPviDqL0gBhUkn3t+humaw77ZD/wW4cf4khy9IK4v7C5MaEpgRY61 +0FJe26idagnMVbkqeU9MKA6ko+DewXhdpHNJvIF56rf4lNatVuE1DY9TVJcLII/xko6Cb/n9dGJ1 +E/RTUTY/S19d+Tf7dz/+8CfFY+6GMP9smm928PcP/zr9CM+ghV7WQUkDfZZAN7/NNyCpE1b+XIAL +z0AlXG8xku/Az0dwKLd4MSGBFcMlWP/4mwl1UJzI80JjX/FYGE5SsMhWEv61gJlAByJx90KIFeBf +dB471GhY5EAEhwbTcc0JwfF2DvAZAK75Fmw/ISPCkgdYjbd1nqsj7Rv8fEF6YAISGBsuDT7cmm/4 +F2gIhhbgBLJ7w6VuG/4ZG84ZMIbkXw7LE3fmMlDpeS09OkxDW9yvAO/NgBSZ3UBNHwjQEfhmpBTA +uUDnhl5p27+M3e9tHau0LXbMcbXT4Pjfqd0O1GH6l+n3U7v56c9u/vCP8BNNalgFww== + + + lP7YTCfoDYBvwjDlHz3hV1CfbtcVNJM1zAXL89KcX+c1ophoDvx8Aw63peaVwB7JA2BDcq2ZT9hL +AQkK2BNsBDkR5QtMLoLEBOoVN0vrkhiYYUe9GSmDlutacZoxOHL3ECWY6QxEM5yBeKXozcWX44Ai +h6BNURpSWpLwM9+isxrB8NMMOxQCC09KbhtjIWC9xePSDGwLrIUDIYCZhD4BBuewaNuY5GV5Djfc +cMF9m2BlBsL58w12xHllAhaaqOvcllvgfeC2KzNshtmboYHyJq2MACd1TEJsKKXwjAAwUFsH7sAe +DAt6FfbmGqIA47IosZg6y3gRHJVhsWVpG8IsWNNcFEFYi/IclVtDkKsNcA7SFjbeqAhWBYLJrxSs +ST6fbjESJ03RZBBgZwLMeQEu6BZgAuY5GAJY/cJFULqqcAbnTWnCcfgvoci3Kcwyw1LIzPECFGjH +as7aMQBj13kkW1QELWUFppQV2JSw3jFYdDbzWw3ch/U2LEXmEYhaRgqTI+jkAIEln28ws4vQ2pLw +sKFiKO+vOPHl8zK5cF2s9nnMmNIpu+jnS+PPw6tCyAJsyHgG1nXh5TjTghcEda045xGYGo9MhkUe +VwGuqVTh9RqKIYAZqUOwNJZiy7zAS6K8LgVBsaD6GbW3xG0EpjkLtREWrOBdcF+Q1Tyvc8db1lmo +oLJ7DMTML2F4qQwMtxiv1w6XIHgBnJL0bYHFK3gDdDQJvSG3VVAkHBNGkWMVYIlRV3mIhraMb2O0 +sEpxm+pMY2A0EUgyW4CgagsBLO0YDJuBkDsvaxES2qwDvOQ1CIIl9ZFM2l+UDjoQIBu4LUz7lJtO +RultBSketQu56EDAbp+KTrFQq7StWMadOY7CXYBr1TVWHIIWVdCskQlYoberNMWSnQIEzV3f1Gbt +AYChywJeZdast8C4eIYAjSUBgvJiCIhEXjoriT8Egrqz6DwIPAiNZU7nNiNoOIo6YLyJEDDp0l1h +q72xlkJBhf8aghhtwykAZmDJtSpjDUj+VqbAWADQOdjCkQFvyE1l16JErUk33XXRWbTMPNUZa+NZ +BMAuJ0kkMrC0VZmNm5EiyECXtuXJvcAaT7bbBJJT2BJMwSJ8jYVmxoKbYFDhh2HZgyLQVyXaLgmU +g06WarAuu3VTQnBsRVdyZBEDwNbXC8s+eDWwf22OJkYQ0NOsi3NhtQWBQdcLxmtu/knaoh2sO43g +hSUXkk3YVWAgkHW9oaThd0XUwnTFFft8Rmb43QeBfQetZamGoM1R1zyeoEEgfCwEU2RI5UFgrFVe +BcaAfB6QRSUAVG1+F/zYwpaFGQZzjU4UMgJAVpouGBT0DCSVnYdrLkWAaR72L0VQwiq9zamJBouv +a1lQkMErL0MbRTSsxfBW01gWXRyId9EpK/s9qFymRZt6hMAF5o+qR8baAnJHFU3MUJa2dU4mH4S1 +FYZUp1yw5Y0+ibjqpCslSVs8oaOsYU0ZEQTVxDDsLghAcibb1dIquweAQW4puGRFoboyCv8SBdhs +nwno61C8rSZZjBFrxyMQ1Nyi0x7LIQsQpOGq+2pQ3q5YWSg7whhYk7Imy4CBjJ1X3b6WutrnYREr +Z2rRz/etfUlBqarRNtA+Ng2loK4bYP6NAGFvVwSzAsNaDViyIehTXNywDE51qV0dY9galuiYyMAS +dMgTbtaKNs9L3gwNtK2qGsAwJwEm2H5UmVpWQ1AWlRNZdAsAtrgIsMCCRGDAAuC6U2GCBSMIeGZ+ +ToqAZXogQ64oWbynBIyxqcpDerwiSKkJC0TNReAaVZ2r0oWw3Iak/F5R32QEAM7MA1htgdcNAMFg +ke7myGICgTHoq6KuGwBjJpsQtjbuQnB7hajUCMxJZRrYrjIKAE5VN5u8sgTGtmLGZdMGEbjoSsAb +qgwBKSrcXXR8CxBtYMYKPBIgiGWlAASsIWgx6zwQfTREU6rRd5GzAENLSTmrygmA46oLj1gvwKgr +pIiCh1ibrpCSVAEHMPwsCKgzCExOWJPdwsCu8sAOIcIHwaJcAAWs34WMDuiFh3aJBow1KDAoB7Lb +MCUkw+AUVXLQNsbAmtQIaSwSEVb08zUY2mImo/YINi2VWiuLvYBLWidQNXUpoK6tSgDNBQbm1oT6 +uch0x71Ol3E1uYk0mYw14uFjS1EEoooDMGTVpFc0YpX6ZVWpIVY/Icja+yTKDSGwyWaqEbq6Fh0U +m4MFlm/RGaDioZh+nlm7VQRrUIFcUe1+ruDIiwNNX1b6Am5r1XOBgbOsmNI1UYSirOnriIEZLBqZ +GGJjAJAiTow0lcUQJFNwk3q9EEzbPIOrzOLKgzoOQ3VSekWhoXiJz7LqhTe4gdrUZhcDAWuy3upW +hWC01akTJHARCKZ86pNzrgLUFScziRGsZhPh5BZRANtPaiojxdICYLIVV6uqaKE5G7LNqyLAyzP1 +ZZUYHmc2WbqMJASRLuVUCiJTG2dzFNmaQ9iiM3ENasTi55tuKQVlDQODLTx0qAmQYloyCCrQEVzU +ybEuvMYAWHP0spuB5GGTjUoXXkQPQdNdEZe2AJekoxh5ziIwasuGVfsVQSy2rfK+DjB1OcLIlsw9 +CFTb3+0S/PkAYkc/rwotIKhZdxQaIgY23PflTYt9Hk8rihYidgIAU1DgWoQq2GXE1YZIUzQEmEPm +pMxzAYMFqrsHb7URdpQYdcZGdqVG3CXUN0AfYbToAtQdpck+BcCu25A2ysAsxm7BUJ8sj4iux1RG +AlB1CjK5AzuqEKjmut8oEdysu60qgmo6TBFjEYCYO6eTSLepiKI6Kl3o2xSsRaUJZpQaBaqfojB3 +FCw26dkRgVjnqtqGGOEIXJRWPGlqCOqsc1adHhHluwlEkTvYhapaay6qcUUgfFXlKiahtnAcj4Vn +XZoA1ZOB+6Cq4wieoy27rAhgSikF4ogAIFnKMg2i8gDEd5NdlWXFcwEn0TsLezUYGFZ1iVXx1CPQ +1GnaOhVvMkMjy+YaKw+0aKisycVKN9S4OccI0Pdu+nTQ8Eastl25lbc6z14WowKAIaoaVMzGP2/7 +XME2m8mfzMDYVHyKlxuBedaoQkbbTvF2zVM3BqShqFFRxdWFrzKHI23JiiBEZU6jeB1TYPtVE9OM +KLAFmfrn8ejsqLlGtMJUz1bVF4DdpbSaAYJx40UdCnVlRR2BMdnWJmMOwDWq4pNtt2nONmxidwMw +5aRtJRQU0fed6tlkhL2xrH6dCtam7uAmigACTTsgAWoIlrltZqjEw0UuNyMrqLDufjkA56Y+bR2v +Zgo5LBFxygCwzqb7oVWjny+2ibS6KgHFdmHaG+VNURVyU71jd9eR0JPJCVBT80jOGLjvuUbsanq+ +Y2F3G9A01JcRiYMATZhiE7xpx0D1DBZ29RCChDlWSaSE2u1pds6AhjOSgWubi05u1UkTpWTZ9G6N +O5a6H7HPRAAG5BMTxssDYCk00TPnoI4lAuv2SlNG0WqQDcCsNaTF62hiFwFQnRRo1yixqCDM2jEW +tdCyZd0YSDhywxDM2jB1MGGEWuUO+58ApO66btoCUE0QUZ71480cFMbXaC76wg50BlLa5kYTQrDo +J8AspQCAQdf3gt44BCbT6QvHFxkBerCN242dg0mUdgImcdqmbFEwNBVUo04403WwhdXYF3WGVGWg +MEOE/KocQMtzti2MNV8EFrVhEwe8EBgW9WTY4kKoefBsrHtT7BSrwwnXtNkvVZVRAKewynwHZnNf +q6nTA7Cby11nAjDZzsLYkrVtCAIMMq6VI188rhYDw6a2VzYxGAGY62IbR1OktZkrxkR0qqzd27ue +C9TNDE5hQzBswbnrBo35jUC1mpOsAti6alWsxVY3gFdtqoITgHE2abrwXo3AtPhdRhHk0hSv7Klp +NVFSNHS8pOYYS4FhRoBhFjNuk5iWAE0SznULoVFSmHJGJkczn8UGrere0AcxKvJss7OYPx7z1op5 +mVA/IwQZy7KreqWGfw4WgyvsjGag6y2uFEYAYLFqkLAQuWc5oq9NR0z8TNC2mYzIlWVExuDgonir +huYQQVHjMorzKaOpkFQg1aBA0ClVQ1RvAEDJySiqBSu0GSMgSSe4xJUAWNHy6j1QBKqmFnbQCQLx +6hQ2BxlIWp0IHrWZESyatuNisngdUMC2CsB6BzR+j1ByVgu/m36cRnnsQDJ3q3jEFEFfubRhPRew +hif7IsXOmq+oiKaPtC7q+u+ee3xd02CsZBnL64qF50SmIV6NAUk0GT9eNNayouP/8PDHMaVD1bDE +oRZqOJtxmzpVFM/hHrC2QV01eSZGZE6cD8vARb1aOdueWtTrnjHHQqemTbeEB0bMkxE7/c2cikVn +RrZsnO7Yyxj6Ukr7pkgEVDNuWfxj2znq6hKrKmcnC5KpMBn1NNVv42wIdApqpAjbLYsuzag7wkMf +xyNg8iqJsOds8afiRwBtCBXSqnRn3L/WxdHKwLAoWeQ6ZQTFgp7FAheIdTVBIg48ROBYuHQES226 +K0q0DIClziZI9POgrCgBfQ4UU4LQcGXvLgL76hZrCIA5qtIdbF/P2B0VcIv4k3K1kFC5lY9Xzhvp +E5M/Ts5OlRia/wFQpUmXAFq6utFr7AyA0TkJm6HUHIuimWcIbDKrs4QEEZRUsCxF58Ta0dF/zbVW +2OHPwJB0NtCo6YtbU72jSPzWvVidXdnrAd0nM3w8Rn0TCEQZCfWoIE1BZ3OPHCA4qaRHcfBcoF1L +1+hHxtSMLL1SQx6B9q4elEHwojmNVfxaCEzKFhU9qwXlUaZrYkBGK1jtlLXvlqA0JB07k8kr79My +8uwXg5YwQxWINpPibaXovtBUb4LWlGggXJTtonGiwaD3IF7b7RZz1QMYhK0uyZldSBkDlNbfYoRR +eqX0TBUUAFdJ5StsVzGwLH3DywJT/0Bx0QpEawZATq5j3TJRnzy9K260vIymZTFgE7rK7NQ0zTkA +YFx10CW0RQ2jDGTxnw9F+1XFJQ/AFHVrUcsKkZqLN6kFU2Y36TQ4h0ibKokUOWFgNqHQJzgisCmj +/skyO/VZUkqXsnAsnrsaSqfA2exFA/vQei5m3JYkM7T4FDtV3RAzJo7xnqf0LpyhtbInUbcXbFvV +Ux7EKYTnCCxDL3I6IgJTtIwDm+KId1XXQytBEeAQy+iKxAZgNdFlNlsJ5hNyIxacikPeVgaqX22Y +Mt1VXlgNZWDJKhBKnpMANRgGBAQ127GtDRn5JOVlWVd5k02vYBadWq3dTUIITFJJ6kkB9bfq8Ooa +h5YUIVjNsFAEa1x031msu6V7eSUREMlK5niwiC62LWnjJsC2i/qZ1X+OrzKvPgEZQXTOVE1oAWBP +j65sdyJsUbdY67MAwLNpb3FRfrdYzJ3Clje+KavljCJIP58W+3zj4GXxmYwaHiuo1ZveYNEKAGv6 +T+HosgCTbmKSdkIwFbM9lodoF91oySn/XMC5qKSmkwQK1tTYwh4uQSExZOZ/stiaJA== + + + 2vObkqXl4rakGDF3WTcQtasQY1M7lFWUglaRan7Bcjbh48oT3cHx9aE5rUXever2Rz5LIymoNqgp ++kiROL4K5yIK0maGztp6n4I5E0xs48uqOWk4/l4Shy95BWi+OYLVoVMsP7VInua4ApJbKz01pWTu ++LArl2zuedntGViqMrWY9wzBS995ODJVUOkyHq6KdC06fsG05JL5fMoo47MLniTxaGFfZVlgdEez +5aituryLuH6gLej55kDtQAsw9IBIEbuNwWHNxi6N/4iajbC1SUMnhTBX1pLAJb+oZFOJe1JbybZL +y7kJ7YEqgj31CxH0FAZx/yEwaQqDk0KZOcfgOOt49TwxzVYpxWlQlJTACHDyWPR+FZFVOFVTtsNZ +R6ZlswstRargMDUlTBJ/sYqBRQdtIoNen5WxfTerbpsmC4iBzmdfZS+pbtfpHlAAaySycPIZA8Ni +W9y6KILuEsvmEkMEq85DDUlhW8nR6vYqApu5clAkKYIezc2StILUrm0ryqvzgpPQNgqy+q6Wop9X +b2NPCUDgomF+CvXy51eOYq/e6VGqpY32ZFRsaQshWFZEQQ9itnkoG1+3HCwFsTTLz5FYIX8enXo6 +CaJEOOrMa3VQqgCYimZKdD90nV08WhvmqKtg6Z+uSfNdZt1KK7r+LB9ZHA74+aLLUG1wbGnLJZpu +Xr0GSQKKz30tTqeKCws4AALVlo/MyxuApVksWj132LRWTdO2YxvY2DKB5lWx9tRlDVAjsGi/yM+g +aHvi1CwyGoBr1qTXJioZtkya/b021X0q5m9rjm+RAEXFCIuevaGkdAZqyFnSxxlBsLNOQu1zAffM +MzrqjMDIaYvclm1KgKVkKrRJQwRHPUdG/qTnAu7zkBwnBraUZDkBhMA1WQ69ZDMBEEZXu5Z00lZM +AFSWRUuqA/CS9WRSFs8mALOdBBOJiuQuemhj1QNmhNZypzQdtwbnVNMUWwCCHq8I5qUjUEmNW3+N +Gzb2sxhIqmQlJD6togg0PwY3Q5aISIFEhTDbW9iFGS96yI6sYh1fTbhM6qpBAmQDSuxcFmBZrGFr +/fN2moSCFzI7chUCAuaqMVDj7sn5jyoev9TsdlJZZTIumkJO3g+doXpO0U7jETgr2L2snxnT4yi4 +GGYdbkcBnoHSl2leBQD1fFni4xIiU2QI7KQSNFzmktzUYiCMoNBUJLkfZcSiZzF6xiq2tTOCZNMK +sOi6pSxOEVISV8OWS+wyMUQdbtmBUc4lOwaQuqDMem4wmMeM5G8KbmifCzhIMm/qMtEDdXbDntAk +HSB5nanZJpxM0pXVcvMHIG2RDOwqD0bGdCmSqf1c90DJZY3d/MSNVc9uqB8VgIsJDgrNqSLj+JCC +qa6i/kcWsAzMTXlLWYyqDeamx6U0wQetj8UQtG5r17IqrRqBQkszq/wLWMDpuZmquhoNb+DZwsOj +ynPP4E6c6614+8rT2BoAO3dlF0LPguzCchJGHRbqJk8WhkM3iMRqoGOqYc2mc0TW28zFI5lAETMt +m7li6HAygSWJBF1flQVC1AQMdOlJaqDwUD1qwV6miSHoE5z1eBqFZ56xUzGrnOzHFsg1GhWv5NkC +EFa7zCPNKkaH7VK0X5b4hC5f8fpEc12h+1rOoeHYV/UXUy6FYLWgZTbFI7Kd+YzjMikXZWKzgJ+4 +vyMntlpwUHTXyJo6exWDZZxEDqE+4wippA1FnsDPKO7aJIAQydrRYOosmktk54ZGedUUjZZjiQHh +NUVlQlC0IHQVrfnOMKaclY8Uen1G0ec+aVTTwzj1rEskWWAEwJq5hBFQ3ogRKC7IqKFIjMqXIvzq +Yp2SCIKAY5P0mmp6npzBfiaJCUH6SjkImq+g52oixy2fC5i6Lv2VGD4CV8GrdkGSCDsDLeaEOROi +1EX2Gj6jpI2+boosXMzkkENqsQc4khxo5c+LJZmSuXFDT2OAoZNDsJKvqqkstDIZrUQUAFiDErCI +gxyARQ46wvZf52gIllkRaIiQEm9a1OklCULBDIPISRCMIJhtgp5AluAu8WdEMCebXSrnKMdIZz0F +AR7EitnKOoqU9cYIZjuUHkzaA7BvLDo7KCtO112wVLNqodto+kGU/A3hIefaocKo68C0htgPiUjd +gOcCTnLyOlgCQIzmL45cHoGBKRVB0LMYo5my0Q4gxl7agI5PC4xGg99vxiEmUSddHrOc9MAc7qqz +iCIYzyhdmwoayRxSOYvgpotj0QTixdL6Iu/uAqy16qo1vvY89MipUc8ou109uH1uYtK9pDVENkQZ +wQxyR9cMRf4YCPqJADUkjEAbwmzpb4g3K966yOmNZmeYIud5MrBE3fAtByLgUbbVoOwaRGDq01gO +ADUL3QLQ9Lmw2oHT2M+qVD7uwOySBBs8V9Opsr0qJLfskx0L0oPImLPGOw0eVSo6ibIVMQjJzsPj ++ueNFYEhaA9Ez3VHoKJzUgS0NZu2lc0DgHpEELQQmUYhuTHoZ1vxvJUEI2I/nZQs8zf24zqopqjg +pUg3I4iW1RU1vIknu7LuwJrtHaIVKYm3dsYeoRJJEHWBT9X0oEHkqNszOnWnFlA0XR+AmkjvVj2e +1Ky6OigN/Rmf+ZXAuChvz+h8tEYAgzuJhQfP5RwUgCUSgIUGJIcwWARv7keZAx/yIAQ4+FITINqR +StIAlYchJK2qoId7I5+wVgRhNhHHdgltjzYNk1VlCJLiG53mTAu4STkeyUPFYg9Np5aaBAiUjLLg +Dl5gHYvKm32w2Ow8W3ZI0JR9rNChp6hCTxRHsGq4QQ8YEFCcvqZEEYLVhKnuXVQjREz5wM6I5wpO +bDAGjn8oOMw6DlKjA4FzVnorJz0iUKMHoSvUWBKFUtwILGoMloVZQ9J9mfVpKo0juVuhH7OY22xR +scimKtfWUcdUUFcs1uGhGKXwVjYVrPmjLoKomRtYHQgmnjCnanWgXmtJZAQjiBYxNQv9QtWhf6By +RFinKDjnQQhSJCmxqsLt56JOiZb0BDrJH2kZtRBET5RBcFnUzC9WKSmsQQxEXdHnFHClJDQnW7HM +aBSi9wrOdmJEMtTJ/2vJyUIaArMmxsw9yFoZG4PVLd39tz2RC4FFkwlnS9Eo/bx6MUdUoXQUzRpv +aiVveqBdK2ZGIGVUyljAVcMxRkRx+RFBEswxDhA05yDOFrE/w/tcXpgcK8gzeS/gaum8NWtIpmZN +HaITTM8kUBSKAnXnKMn0umJnsCimo+ErzXM7J+BglKlRVrQaKINVi7EsSPQDWDpvrLxTlsTVZFdO +LlJfLgemNMygQcxkNV4KnXq7+H4lDDaVVRN6aQTuFbwoYXXWHIOQNGJqwb3FshgpYqoWf49kWk7G +wkc9Vs7tSZqisHm90DWkq2QmCmFg5QhsNou/zQYUpRmTaHLPSFYdAr0DlqySNUOp8aEKJlZN/n7K +HxOk1PW9oUqmHZ0dVA8zybh7AedmRylQ4dBjgr20AnkInl9GItjDbIW9MutQ9wJW0d7PcWIdAstB +k+RNhC0XjsLOrEXJqheV0h9a1XDeOQEyRkt05+pIMb9XcLPaETDGUs5B/Dwr+7u13+dInlNNwC+r +BIjgm/L51QBF+mMQgQrXRUy6mYsDPx/A0E12qzzXz59D3EffED1UALCi/oKlW1EmYp3msFIyLo4k +XgeDP7R5oRtLFpg4VN418n0lXAEQ9LqCv4dXSn71veh1bQkExjJIpNOscshracHGnMLUKP6xECTZ +49+IkrEmtltnXSuoI4DiamVFgqgIGnsDHbxkVWmChfrEh6mF8mJtwg3ZVahMXVJ/kdRhISVFRN7C +8lfpmmeWLbNlfs/4MtRdwBLs5aMoCtQQKMdkviG+LHj8jfiCGZurlvnhmkTLGi0QvkQ59LSsqE1a +KRkMYLSzQV+y1MrD1hpGXFAPwR0M8aKmeXNxwL6RBYWnwnBNIsUJ0zPuBRzXFhz4+QYc2YoRmnFC +4a2fWJtR9eY1r80BmZXAFry6zLdFhS1GmtIdqwcKBarFwQvXDWEeHLhimpTxa0oYyKN8RhgBdYhg +80xjW8ccw3qBY1KAEl8XVmE8+ZBoHTesSYaq/rJSqJZnDzoYGIhJuFJDDksIFqIBy+cloQw9mzR0 +TU4BychL2Ypg58CwcNRqsS3Lbl/Qo1XVMRms1g36M4to5Hr8BOt0yfhU20YpEpFX5U1cmLAZgzu4 +6eOsBmbwEoIJnmPi3hJHuUpipSQz5AxIGJkLUZYVzd5VlvuCbsnIMx3knK53dkhhSxocNQm4Jha1 +RecWr/cFo4WNwZTXL7UqwyorCCROubk4YrgqfpyWm933MnRzrDIHySK834AxAtPKjVZSJGJwwHtJ +vkTVMgzInEtSo21oi2ezYx6weqBQwAg6eGF/54B1RaUjbShQoIo0oba39f0yrBd4gDz6ydd/t3v3 +/vjqm/ev3r558e4vNz8H0E//289u/u6r9+9evfnu5qdf/enF9y/3r19Suek//e4v37/82c3/gY32 +Dzb6xZGb/J/wF7fR7ycqSYvOVKw/BIoWVUcH/ZSq1S4UVHb1xoPW8068TSHtoFtXFixkzN5vwJa8 +Ms8mK6o5loB5oaiMJ6AOH+eODG2pPEgZkXaYvF9HT8E4b0UidKQzn9UbCRAgI+jEWlvfK8N6gQM4 +enQ4t1CBX/hhpjryYNMEqoG+xAy6O/IVN3xWD0qg6yYT10k35nIyHaImpfJ+A5YqJkwwb+LIMTqM +x52Dzao6oHJ3TiwFXVtM4ArrBmsHCgWMoIMXSyl1WGc+njBSIEBlr1JrbX2/DOsFHgh7A97ahKWV +QYvVGyX4xhuwdiNxNepVQ5Fy0LG4Kl1NZ9wFvVcwU9GV+w0Yyy6Z34jLxeLUq7bBtJJjh30jbivQ ++NaxpVREHFF2oLxeWavgwBXYRqQze5LH9wtQWaukWlvfKcN6gQHC2hkLWOPtAiteFUTXJeRIt4yA +9VFJe412owPejYCQ7LRXdlFVmTdZbCcPlSRJphdMXF3VWlNV1lcHKnNDmeOmLS7rsGywdiAT0MUK +QwPHBEakMx/SHgkQoDJXibW2vluG9ZwDzFuwOttS6baMOdBNGKB0t0i3vIBeTwYBRk6XRHclpMx3 +fKGJ0FkLlpUgjnhm9X4DThbIxXrChVSFJuVQuGul8I4pQO4aOjl13ltbXHMhbrB2oFCgg6PgwIds +RqwLnkfcUiBAZa5Sa219vwzrBR4IdzFvCCVsbKRuoXHVMK2DrqSIdDVZ8neQFZa7xlm8GpGxBsyR +u9+ApTI208rVRmnSSZ4BqpxisAhQOZtqXDZto9TwG7B2oFBg017Agb2QI9aF65eNFAhQOavUWlvf +L8N6gQfC2YWO/pFsiZUK2IPOs9bhkh+epu7Wj2o3p8iWWmpj1HiDMNtBA1gLP6GfPq1i5UWpjTdj +iSk1TAio7BVz3bfF/Bg1eAyrBxIFikDB4TZapEGRLj1+0gkQoHJXiXVte7c60jMOMA== + + + c/O6Vrp/bclLIOkwg3Y68jaILKjoNaA7luwGHZFLWd/WtDK/B0dLnJ9RJVlE7GsBm1lWXAeqAVLW +mjdtMcw7rxusHSgU2OAYWJM7HNagcWZHAMOUtUprb+n7aijPGICsXVjDzSmwrnB+209nsN5M1K/W +Yr+MMbgkxV/bYvxVKIbOZ6VvFddLvJVDLFiVvXiYmXdiY/iWfKXDgLID+e368Q7VOIXD2eddfzvD +lLdKp5+hvZuGctv3LzRPdo8zT34vzr1FnXvwz7dTkVtFfryas21wIT6jkC4o6iJ7yHS834BLj97i +UQvWY1dLgLWqjAYkflsSgG+LZfNi2WB1wORsWgcOnH05YsX7RuqWAgEyBZ1a17b3y2E94wFJqi83 +GKkoYWLSJB3xfgMOnOtPBRzZ2sdk2ma1Lee4OqB2jPP6h7bouEzNo+wQeTd/uoMLp5GOKOst+jE2 +rxegjqyS2tu6HnWs572/lrHI6SyzdI6ikvcbcEDflVbXBByykWnBF+gcvLQ5oPK2rHnZtE1yVn7A +2oFCgbJXwb3gmsNa7cCso0CAjKBT29u6frkybmc8uJKxSGk52Xw0FoR0YFQignI3URoUcgx0NJ06 +S4oeqNxFd9qmLYY2W95g7UChQLmr4F6402EtVu3JUSBA5a5S69r2fjmsZzy4lr2IRJCLdWUnisxd +B5VTJAzsLucasnKX66oaULnbos5da5vlfMKAtQOZAP28Qnthcoe02EVKjgABKnOVWNe2d8th3XLg +SvYiJ4ktqgljacL7DThwisgzqfurhlmrslSL3CdlQO4aVZBaNm3xqGhcNlg7UChQ5io4Wc1FhzVb +jpOjQICMoFPr2vZ+OaxnPLiCvUjvr6sMWY2aCeHAgbNyGRgXBdL2yf0Sp70ClbOLyEbXFg+jKtCw +dqBQoJxVMN7BMGu5asWa7fSLo0CAylml1rXt/XJYz3hwNXsR5RWlsJF7CvP37zfgwLks3I8Wdd4l +OTCKBbqDTvFk0R4s5r3M523nXJczrAoUCmzmCxh2GTkh7LDimZ2wpUCAikCpdW17vxzWMx5cy2LE +6/+aOnGoxsj9GVhv1EBgqmp+9L7BRlkdUPuWog6Pa9uDmg5rBxIFNjwGtuTLjjV1JaRTkLzC0qkd +2vZ+OawbHlzXaMSdojUZPToAcH8GdiXmF/NN4NgKK4oa2lXdFXRx47xsW9YQwhnKDqTX6+c7WI9W +OKTD/Nf3C9Dkk/lLrK3vlGE9Y8A3nAby7xDb+pDpyIbMv4n1GLNFNrz16MCF0wueca1oOi7lo1xY +dbhFHyYjpmNpWEpS8m2TOPMHrA7orUcHDhZ3dljl6NZIgQDZ/OzUura9X8EXEt/wQBTFLzIc6RIi +zZfADfB+A8ZchKKVufkgBDLLVZnuHCSgMpYLRvm2WNl25X2xY3VAoYARdHDQrDqHdLETKo4AASpf +lVjXtnfLkJ5z4HrGIypQRfz8VA/lfgPO5PlhchsVCkJ+2ckPULAk5UOA3LWGVSbT2BYP1JTQBqQO +Ju/XsVGwpT97pHhVYdi8n2HKWSW1t+xdcijPun8tuxErz6egVltRo7xD8UKSxEupctorzTmrn73K +2TQDKmP5xj7fFhdzUsYqVgdkAkyaJGWsHmpySMFaWuXCiU6AAJmATqxr27vlsG45cDWjMRZNOMEb +TfPSmavg3E8WVT6kygt6NebyGUEDKnP5LPDQtsmplgFrBwoFikDBwRdoV6zBzkM7CgSo3FVqXdve +L4f1jAfXshvxdgOJ3EfO7L3fgPGeQPb84OUEUe0FTbSjmwUGIPdtxT03btrSxSzrBmsHCgU292dl +Tmv6LkUaOGw1EhBcNM0R69r2bnWkZxy4htWIQmmeNd6FJ4buN+DkL3Lgy1Fp0kkWM17N0MLigMpX +PhE4tMUqi8pXw9qBQoEi6GAt1+ywYrClrBsKBKiMVWpdW99dw3rGg6tZjbh0esRqnnUn6+Bk18zi +5Rl0KIRzSWdlb63qJCagcodvCxnawrZTlL2GtQOFAkXQwZrY6bDS0aa0oUCAyl6ldmjbu2tYz3hw +LauRrhsJsiSyzV0PNQ2malImUhazimG+etWA2rUqKRhDW673tMHagXntrOlQvaGh48S6HAbU9wtQ +P6+0Dm17r9YLsGzz9gq2IpKbm9qixTQFD9YTNNgLOqC0GfScZj8TbNaEOZ215avjNlg7cFzVBtaK +TQPW2sIZAbV11nZae8veKYdywwC2FT9myf1bGHF0SF/nQzfiHLiXfcei/msRe00rhSW6Uaw5IDEj +Y0XQ2sa2GX38qsu5YvIK9EacA3cNy2HtmSCOAp8J4qh1bXu/3BH3Mx5cwYgDpGtVPw4WEbrfQN2N +FStuFxL1sRsz8HT0Gh1Q+TqH1Ma2GZ2nSxixOiAToGxVaNCr2hxOS2f27xcgc7XT6tr2XhnSs/5f +zYLDKy8WHa6INbXuN+B+1yjWxshN5rHWDKLbGtLqgMyaWa4v9m3zYjtUx+qAQoGOTd/NqIDXiHXh ++gYjBQJU5iq1rm3vV8d6zoNrmXF4T0gu6lOcmzFXoZjXGYW3ISU9S7CwqzNRfaPogMpbVa56W1zN +QUNvgtTB+PUmTQQarQaQwxnsHjz3fgEqZ5VW17Z3qmM96//VjDi8VaXpmFGh1/sNOHMxDqY3Rg3H +6T2N0Dcq5dKBytsl5U1bANKp2wGrAwoFikDB0W5lcViDXSPgKBCgclepdW17vzrWcx5cy4jDijcx +q4GqyvAApTKwTG5aNEwvhW7pupccO4w71uQ8rGtJ005dfopyAJoi7KB4iN9KDinO4PcwfX3we1in +1LXtfXJYt92/hgFHwl6HkM5E3m/A/dQ4VSzSBFxNOIZugUpYHVDZSmdStm3p/qERawcKBYqgg/VC +EIc1WGFwR4EAlbFKrWvru2tYz3hwNQMOl82iA1nx+rD7DTiZyooEU9EgBOoJQQC2sAYHVO6EUpZN +22Y6q8PaBkVW/bQD2K99wRr65tQpCONGptQObXt3DesZD65lwCENVLOGc/5Dn7wOPFe9QooLLpKx +E43la1CnCAG1b61qjN/aNryTK26wDkCzbgewFrgcsK79FqxOwWphrYFa17b3y2Hd8OBqVhyWLWs6 +cDBaffJ2MJUzFWCx8Fwf+SqaaBz3krLO5235AuoN1g4kCgyBgaUI/YB0reXs/QjTT3dSXUvrU8e4 +6f5/nA2XQUSta3L2y/0GLFfiPeOqgdK/anVpsG6hRef6wUCsh5hb3bSN7ri1YnVAb8M5sJRKG7Eu +XP5vpECAvIF2antb16+O9ZwHV7Dh8EqcdREfSrLaJg6cLfCPN6yEnojW9CIRro9hQObLIiWihrZ4 +9nZOI1YHFAp0ZBRsFYcc0tCZ3QkI/XC8JzZ4Fmq3DOk5B65mxuUeI0x8NO9+A86uKmZsRayHpKU3 +sELrvDqg8paP8w9tgx2GNqQOltyJQQeO/Q6BjjRYpTFHgACNt23b1vWqYz3nwLWMOCztWZoaMdk4 +q8DMlwgztalY+NeuyoFRbR2mjOVK974llhQOG5QOSC9Xtiqw61YOJSZkS6mY/nYBKluV0N7Wdalj +3Xb+agYcXuRkp3Ko5N79Bpy5zOkzudioaTxZ71ZAKb4sDqic5SJVQ1uq0dhGrA4oFCgCBVsFUIcU +67hYgVolQIDKWyW2t3XdMqTnHLiW+YY3XFmmGUmk+zOwRNBzcwZztP0Dpp+DMV/w5KIG9bXlIpda +O4wDrEtJB45W0N3hDHzf5Ph6ARpfWwljW9eljvW8+9ew36hysKX6rnOvQ9QP5GW5twPv8ipx0fk2 +K1uXuiQHVL5SYd6x7YJVQ+KI1QGFAuVsB2vhMoe1l2t1FAhQOavU9rZDdxXrOQ+uZr/l7sWLfKfq +/QaMvrmmZKhtW+yOr3ldlg5T1iZLmOwtqZDygNAB5eX6+Q6mi1NHpL1Sp3u/AJWzalhry6GfivO8 +89cy3HBsqXwlYZ719OQIrlbnis7q8eimxa6Ka6rZ9wN6ZXYZptoWJWJSKadYR+Cs6YgDWB3EA9aS +WzijgIDGW6PWte39MrfzGQ+uZrhhvbCop/EpvHt/BtaKmQi0PcCNfA9pE1A716JmQPq2pdUzrB3Y +484D2G769VhNVvb3ty5qO6XWrvfI4dv0/jF22/Jvl0VZ0NfizJb7AZi13h/dR7CKs513MrsfRUDE +h6r3srl2G0yjkWQQDI/ydYAOB1bJXzYvYxh/slNlLY32jnDbx2udsAO8xVId6MLm+w04W8oYkrpm +UXRTanqlRGnRA7lbeOueBjGsbeQyiSPWDhQKdBQU3AP6DmuwC2gdBQI0xgq1va3rV8d6zoOrWWgF +14oOXLTzNA6Mtx3J/ShYgSNqvYpkV36UxWrjJPXe4vUms1rF1laqo45YO1AoUPYqONr1Vg5r0MtI +HQEMU+YqrdbSdaqjPGfAtQw0vB3EarsFPWTtoBmP9+ntIuq76heg470pyYGUr2nWmI+1xPP3NWxw +dmByq7lD43DDzKzmGN3x7F8vIGPraom80tJ1qeM86/3VTLSKs1uVUBLL92fgJoGcOssF4Lygi14k +lUpsDqispcoVY9tg27nD6oFEgSLoW3+SM2QOa7AiuY4CASp3lVrXtvfLYT3jwbWMtErSWc0/zPq+ +PwMbDT1sbhcQLVi0IjigsGbTLHDJU4/Og+jFNuGbelWy2Mg6gWe9u6q/VYDGT6HQte09cQjPen0N +2wxvggtaxWYuapsNYLd38d3aNNHkSkTs16JWnNWXpI26aaDI2ga8N2SL1QOJAmWqgrvK5rD2ayQc +BQJUziq1rm3vl8N6xoOr2Wa4gdaoGa2rqgYOnPodbUCwlDpKluOBt02hDOtAZS8M+nnbteW8wdqB +QoEi6GB/DZZgxdKCKWwoEKCxt5y19d01rGc8uJaJRsJIXcWUcnC/Aae+sWNhxWrMiTp1qKhVBypz +YGNvZ21z01pDTrVQYHS5EANYzGeHNHJO40iAAJW5Sqxr63urSM84cN0DdcMoY0rm/Rm0yTU3dAOb +ea9S1F2kexcIqPxZ2lrP2vbiLIbVA9fY+duhVBV3RDpM6e5eIKAx2HxqbqL2bhnWLQe++EDdI6ux +fMgU/P2/W3EWYB6sgHV7vM6DrYzKXJvFPK3gylwxS5XVNFecZa50q+66aRtdCQ/DGl0JDzMXPdjK +qHisVnDFU+CKs3hqe1vXr471nAdXMh3nihEXi/5ocRYP5koq2LFVcpus4Ap2TCPwrjgLdiyHseW6 +SBlpQ+ggrjSLB1sRlY7Qiq34V7vCLJ5M17b3xuE86/nVqnhWvA9HrWErzOLBVkJlrnRxveSXytll +7Bx88xVYlK9R9szedp3likqP1QFdYRYPthIqHqsVW/EUuMIsnlrXtvfLYT3jwbWqeMIQ52DHy7Qw +iwdbCRWkt8xa01eKrWDf+BbWoTAL8iHUseXq40SK0wFdWRYPtgIqHacVWvFvd0VZPA== + + + pa5t75PDedb/qxXxrFjxW/NktCiLh1r5FAS2ddUEaC60AjjxrH9zQOWs5lD2tuusddYdVgfsRVk8 +1MqneKRWaMUT4IqyeGJd294th3XLgWsV8ax4/8aqeoQ6kTzYyqfgFOFrhFyhFeyalhd1RVmQDXPY +tGyu2J7h9E4zK8niwVY8peO0Iiv+7a4gi6fUte19cjjP+n+NAp74/lkNfyvI4sFWOgWB1YKTUmQF ++6UZ1a4gC4LVOnFtQVBmLZ9nWDvQFWTxYCud4rGame8pcN4AT61r2/vlsJ7x4FrWI+0C3UjTgiwe +bOUgaIYknXVSZAWBesDYFWRBcK2bls1VQTaczVdM1nIsHmyFUzpOK7Di3+6KsXhKXdvqbFfDedb/ +K1mORJrVs7ViLCNYyqYgEOS4r7siwLX5Ci3at2Lp6q5tWVs7w9qBVoxlBEvZFI81dSWlU5C8ktKp +Hdr2fjmsGx5c1XakabJqgRUrxjKCpXIK0iLXHjQtsUIzatHohRZjof6Fbbtec9Uh7EArxTKCpWhK +RzmsJn23K8TiyRxXydqv+ij5DPi/RCGWGcMUtoS7pejAVjJlLquV9bbiKrAybEK6Qiwz3u41p7xp +G+Vu5AFrB3pL0YGtZIrHasVVPAWuEIun1rVtTgob1jMefHn+JyKVyz+aK8TiwVYyBUnt1ztIcRXs +VuegFWKZ6UI2La5pbfFWajXsDWsHukIsHqw1UzxSK67iCXCFWDyxrm3vVkd6xoGrGYsFc1DVu2CF +WDxYa6YguYucZbbiKjPduLcEB+SuZVxN27ZgMPR7JARph7lCLB7c76F0SLW8in9/L8TiSe0te5cc +yrPuX8tOLM1fsiLHqz3USqYgtXOOvuYKd4xvhx4KsSAPtMKbawuLOWoAx7B2YC/E4qF29NYjteIq +ngBXiMUT69r2bjmsWw5czVAEGqqlzlkhFg+2kikz3iuZyliIBfvWsh6atEIsyAdQltKmbZbr4ges +HegKsXiwlUzxWK24iqfAFWLx1Lq2vV8O6xkPrmUrAuYk93y4QiwebCVTkN5VDnpacRUEznXZFmLB +Lqul4NpmvGw7bLB2oCvE4sFaM8UjteIqngBXiMUT69r2bnWkZxy4hrWIQqlaoUEtxOLBVjIFSa1y +P5cVV0Hgsq6+4orytSR1/VjbAhazRTAVawe6QiwjWEqmeKxWXMVT4AqxeGpdW99dw3rGg6tZizi6 +VvXVCrF4cL8qsOBNaLN5X23awhAGB1TuNKl679oWdpmPWDvQFWIZwTFYW8Ua2ZwcKRCgslepHdr2 +7hrWMx5cy2JEGmazMmzuemjLQWVCDtGKYithKfTTCH1BxkWj5L1liDoZHcoOzDZvPTQsWaeo4tQq +CP7tDNOPK52+Ze+QQzn2/VpZoERssJstimkJHiynRKkTZiPqlYrYh9iKA9qMyZrE6drWbMd1O9YO +HFe0gaViyoiVS6uMBGgRlpHW3rJ3yqHcMOA/7ADfjAeBkh6r6AacA1u5lDnDDtPUzpDCKrCk8PJd +DyRm5GiHGV1bDK+pHmdYO9AbcA7ctSuHtV+x4yhwRVg8ta5t75fDesaDKxhweHxNLsfrRVg81Mql +EKWzRniksAr2KsvpcVeEZc6o92hgztoGuwvUYe3AXoTFQ239O5z9Tkn3fleExdPq2vZedaTb/l/N +est4aXrUvUmLsHiwlUuZMxannEW5lQx37FqJdqecFmFBNvTwtrWNtjs5rNFvmlqExYOtXIrHaoVV +PAWuCIun1rXt/XJYz3hwLRMOMNeg5SS0CIuHar0UpFZTVK2wCvasRg37WBEW5IIqVq5tdHXRFWmH +9SIsHmrlUjxOK6zi3++KsHhaXdveKYd12/+rGXCAOa2qIlgRFg+2cilIb02q9UphFeyb3v3mirAg +H1rUsbG28Iqm56QMawe6IiwebOVSPFYrrOIpcEVYPLWube+Xw3rGg2sZcIBZy+z0IiwjVCqmILml +BL13Y1betqS2hxZhQSjFJYaWyVJIHEoPNCXYQa1ciscZ/B6mrw9+D+uUura9Tw7rtvvXMN5I2Gsa +oBVh8WArl4Kk5qoeA72fMWNZWi0bZEVYaG8J6rOwtvij3YKoWDvQFWEZwXL41mO1wiqeAleExVPr +2vruGtYzHlzNeMNlUzRj0IqwjGDo5Sr96GX4JWcYgYuUn0s9v5hW6aKBUGubnc5qWPOgyKqPdgCL +ZeuQRrvU3hEgQOWuEju07d1SpGccuJbphgMcVPpYCRYPBtYsVYWtXjiF/tAYBBiyHsAImoVIPZ4t +x17bZqz3t26wdqArwTKC6WDHiDX27alTEMetTKkd2vbuOqwbHlzNhkPaVs3vtRIsI1iKpSBQKyfG +vjsUqyUex50ktnbetteyclg70EqwjGAumDIiXW3M+/u1BMtIam/Z+9Qxbrr/H2fBpYIHPn2q5P0G +bMVSQOGGRaylMaWsCgg3F5ezEixzCqaMurag9IPFusHagd6Cc2ArluKxWlkVT4ErweKpdW17vxzW +Mx5cwYJLxUrguxIsHmzFUpDUmmdLJWM3A3Qr5eaB3K2I96pv2+IV3lqXzLB2oCvB4sFaLcUjDZ0t +nQBXgsUTGzwLtVsd6RkHrmbEpR4ddCVYPFirpSC5pd/qwWVVsGs5teiAytu06O311hbP6mhcT5F2 +mCvB4sFWLMUjtbIqngBXgsUT69r2XjmsZxy4lgkHmNOid/WqeeyAVi+FqJWIoxZWwY6VqHVLzchI +0a7v7S3x2mkNbRrKDrQSLB7YNSuH0sqq+Le7EiyeUNe2d8lh3XT+auZbwjxcvb7CSrB4sBVLQXJz +1qiPlFXBrvVLBK0EC7JBL4h3bele6LrB2oGuBIsHa7UUj9TKqngCXAkWT6xr27vVkZ5x4FrGG2Ce ++xUPWoJlBEvsPGVnLkfbP1a7SS3a9gFE5riOLfHkR64jRg9zUrKDrViKx2llVfzrXQkWT6lr27vk +sJ51/xrWG26fcmuFK8HiwVYshWhdtDi0lFXBfrV59bVWlK/9rK+1jZbu67B2oCvBMoKlWIrHamVV +PAWuBIun1rX13TWsZzy4mvWWug/PlWAZwVXynhOeK9fbxAqfS6TONY0XFD3DSBIw1XzWFhSYdYPV +A60OiwejK6AqgmIJmGo1OAqSszActa5t75fDesaDa9lvOMRJLUurxOLBQMWqwlaVcfSFRiW3F+Uj +oPJmbbbpaltMSTXzTZB2mKvDMoJB07H13+ze8bUuGwIEqLztloNr2ztrWM84cDXrDYlIWtPa6rCM +YDkoS8Clx8o4Epyyi2hbHRYCJz1459vOan05rB1odVhGsJQRGLG2cvb+1uVtp9Ta9R45fJve/8fW +YZljd7d4C86BtYLKHFHrHGqszDHaUWirxTJHVOyHmi0wMSw7taPrMG+5ObBVUvEoteCKf3cvzeKJ +7C29S8lQnnX8WmfsIl57GzR5UcuzeLAVUkFyU9O8KCm5Qj2To/uuPAsyQQ/ku7Z4zF+1PcPaga48 +iwdbIRWP1UqueApceRZPrWvb++WwnvHgatZbzM7bbOVZPNgKqRDBlosmZ6ixc6lo9Rsrz4KMSFUt +Zmu7oIa5bLB2oCvP4sFWS8Vj1aIrnoBensXT2ltm5243lGcMuJbxFvOmPsr9BmqlVJBa9WtZ0RXs +WJcaVqAFeVCqHhi0tst50RcPTG5NL+fFVDxSK7viCXAlWjyxrm0+L/tyzoGrmXAR85T1CLqVaBnB +UkyF6O319yU4GLtN4Eq0IB/WquVNrW1waolh9UAr0eLBVkzFY7WyK54CV6LFU+va9n45rGc8uJYR +B5hXOyllJVpGsNHQg+p60CqSj9rXbeGeRbdtWVtcnarGGbc6yOq0eLCVVfE4rQCLf78r1uJpdW17 +nxzWs/5fw4oDrKBjbIu1jGC3k4W8jsVasF9aPs0Va0FwqJtiLTTlcN2MWD3QirV4cNfrHFYrwOIp +cMVaPLWube+Xw3rGg6tZcairzOrnsGItHmxlVYjgRRMoNRckomKpN1JYsRbaXyyB0rXV2+Ed1g50 +xVpGsJZFcFitAIunwBVr8dS6tr67hvWMB9ey4kgsWaqkFmvx4NS3efQpBd1SuQAL9q1ZCqUVa6G1 +uuoFU65tWrWokFc0Vi0p1HMmBjDXVfFIrQCLJ8AVa/HEura+t4r0jAPXPXA3jLIWaxmhUlaFaO5+ +Li7AQv0zF4AVa6E5ZdqrawsGQNlg9UALkw5QKavikQ5T2nlBFmdD9EPhbqL2bhnWLQf+Kou1uDN4 +XzrqZ9Va8AokNeJoLt5vwJn9BwDE7XKuWnhCLmae4//P3rsuR25ca6JPwHeoP4qwd2zQyAuAxNYv +kbI9Poe2HJY9o4gTEx0Umy1xxEsPm21b++nP+r6VCSSAIglUN8kqdkkhsbCAvK9cue7Z+QRGIJbA +GDnvTOmG35oWiTvsoNYcGHtwfKDg/uAg+GQE7hK+GCOMuw3R2pjuEBl0jEDiBoPUUsfit2VAFoHk +sZoQJgNmHVszYyeCM+iFh+SDF8FohOFVmgkVaAMuBRXuSgdiU2iGgBlQrkCrvlABmfv1lrqyRbY4 +1gt+wcaUSCXMlpQiQqU56nXQ0Uk+YHR6y0WJFC02Jnihr5XORMDm7HIiqVMFjFxNk/wYneoK8T5U +HDIu0kpR4fAztBiCLY2SfgXWFRIlWelLErgYmoMkMQBy7x3HCvR6AlviaBZO6IRgXOGFlbOl7Thi +jdSISmZqCzGysnNxAoeUspCWLt2sKLOQEmrLfNWtAqPKXefWathucH38JhAqGpplHaKiDQsZrUsB +6X8Mc1BNF/2Y2ICxWeVbZH3Z86s4tmhbETB9ZPVboxkoA+i8ilLgGFUUEkQUNjAS17azw4RWzlZP +/GVyl85DUa/1LcsuVrLKcg+WdYw8waLV8XozGW9FfSMWwtWaSUuQsbJNXEk5q9PGhNOCiYvm4VKa +8LmsPRetjpgoHFNQnEl6YPnZmiTje5CktCdb61OG2Vb1mm2X7yfg1nNl1BE5aynWhFrz1ZzFWYWd +UNc2JQNoS80EoVNdKvON+TdphxELjtev1gkPgrYjyV9986fw5vfXb49uP374Wcj53fntNYAVgG/+ +cnP9V6H5d0L2i0LBR+c/XVznLw7+8h5vTKmvvv+ff/zDxaVUc/C77qecM7/74c8nf7l5e46fgwPo +3hdfr37z76vLa3lVSLduL378eHf+AUeNnGG3p6Mvzn6+uHx7e36N93b1uz9d3/Xv8L+7eJL9pvxK +DrJ/XF+cCTCdZ/mH/zy9/Khf/vvhD69Pr/gdOsFebes4fp09jl9fYByyn2eP5F8Xb+9+nj2a+PVW +j+jn84uffr6bPaT0+bOP6ebH/3N+dnd08/H6rfTv6OaRvdEP8B33v3x692H2KAdlnn2o3/zpzTeX +738+fWPmjvHibcYb3zMmfPOfM3q8LWTy7uPtjx+Fwz87nzsLWnTmEqd2nptoirA+dw== + + + PD+efjj/w+35//0okzCfhI5KPfsIr2++v7u4O3uESvaj/MCv/35xeT5/fw7KPPsI7dyhXX+8+u7s +7vSfC0aWF3n2gWHLzR3b7fmHj5fzz430+RwKdE/XzQNdX0/9skPg/O85OXm4sw/M+zMvyMX13OW4 +eX9+e3p3czt7QfoCz45m3998vD07/+Pt6fufL85mH3GPTEV+0l1v+d65uH6EhAwGY19w1xzfXL2/ ++XBxN2fTPEUHyIc92vbvvj1/t/p6L+1txzj20t72jmgv7a0Z5ZZIe/5Llvbe3Z4K23v5l5uLD69M +3pstxO/Fve0U92bvy724txf39uLeZFR7cW8v7n0x4l5hX4vAt2QkWy7y+Vcn8i0Y0a6IfCIHHZ3/ +8/zy+59P397868u2femRSbHwtRyYP15+fIRb+QzM5rZKBh/u3n57/s+LU3RogdSTF3oxnuCPpx8/ +fLg4vT7SBdwVXnr22rydfwy/fYlzeP5A5p/Cb1/iGF5CAbadmt28e/fh/O7oOWjaC2377zjCHdrw +l+Bb4CV4dnN5c/tf//pZxZiZ9PnXy/mqxPj1fgN9wlg+vD8/++7jI/th9ziC2b49Hz7evjs9O//+ +7HQJ4g0KPb/UMXtwsrgfL09vj2+uP9ydXs9ft2nBF7CmLR3l7//9/ub6fINR9gV3STYpqrKcPUdb +ruIw5YKxbLeSo7BLxvLfs8fy3y/Ig/z15uL67iSqL15CH3n+fdyqJ5G52CF+6HUaExbyDdvOBm2k +6FlsTdjuNdo1yWiJkWRbiMHp7cXdz1fnd/MNcLtEFGYfe788okzJhoNPt3ggj/Di+UDMNosKv7j5 +A3FbPZD5VPmXlyDKr9IKv5gb2Paj8/Li7q+nF4/Jkl/42bk7svJyNfHiHfdCC/nn89ufzjGTO8QE +Ld1cr3Etnq4De5ehjRVqX70SddoCr5TtVqYZs/cY2n6PoS8rSOT45uby6Pb8/L9nWzVfo2fU24vL +0/l23V1SYpjD2XHlt6dvLz7OR930+W5oN7db4pw/kLfzB/J2mweyayLmn29u3/98c3nz0687JJrs +ydoOkbVXQ8zmR7BsOTF7tWFsO0nMitfjsvpqdvqycIpt3uqzR7Jre33nPG5fb8z+bJZlH7N/3xhf +NmZ/th/ursXsLyDk234kzd5kW38kzZdwduxI2sksCo94lGRkbZnz/Qt53X+RO37rHTV+nI1lW0+9 +Zo9kV4Jw/jbbnHr88+n19fnl9+eX52dL9GnTgs9vEZptad10kNOCL3YOfXvx4f3l6dn51fn13Z9P +3+/QYXR1KlXNNkzuhHS0Sv+uJj/N4OfcUfPXfP47fb7FlHLrT+JluQa3+fSaPZJd472PEcb850Q+ +doXeLcCsbd8js3UIW79HZo9kVzi8+ZHIz5N4ZVt237tF/kHvLi4vl/g/XW7zSr+7vbmaPxh+/Pxa +yUeYnMww9pjHeG4Z+/giMVezx/Ij7uSarxvXr5/fqH/5r9NfZ49JKN/d6e0iSqnfb68m/O5mvuRx +8wIDuT2nCDh3OKdv317cXfxzvjjVF3gBe8z1/HGdnX28+vi4t1A+sqzIC0Q0XZ+fzg5/OTu9PPvz +zdv5Y+sLPH/w2WzeIlu91PxfOIS5Czgs9UIiyen1xdXpi6WG3dU8dEXYO8NsmWR39mqcYeaPZNe0 +H3tnmG1R9+4vLJzoFHbNG2Z+TrNdc4dZQMq3/VB6Ne4w80eya4fSTrrDzOY/d8Md5ovc8VvvDnP2 +atxh5o9kV4wle3eYvTvMthxGX4A7jPlS3GEW0PxtP4lfjTvM/JHsGu+9m+4wCzBr2/fIq3GHmT+S +XeHwts0dZqvtP7vjzbNgyy0lHi+0hruYNXCBH+B+FZ5sFZ4u58YOLMLTdeCFGt/9pI3f/OnNt8zZ +82aZ5msWQ7Q7R9TrzVs0Xw24I1mLnicB+EtR0yV5cvYU7WGKVu8p2mukaLOXdU/R9hTtlVC0398K +4Mtm0c4xBa+Rnu05tD09+zLp2RfNoL1aerbnz/b07EujZ7lR580yK/wrI2uzB/8F2fD222bOtmm+ +5G0ze/D7bfOFb5sv67agv178+/zyr5env75ZFuy4jQ47VbmqZntP6sz/bYEDZVZilyjf7fnVzWPp +DXYs18v8nCL7/Cj7/CifCelW5mtbrkwl/y9X8t/X8lv+fi0vVq/NZfvi+u35u4vri/kGrtvz9+en +d98u2G5ZiWcf3z5HjI5rx3LEfHiPLDFzR7dLOWJmciNfWoKYbeGhXuEFhT8uuWx8yz31l4xlV3z1 +9wqL7SUHj+3t3bQrLaIIW07dNjQpbX34/M3V+5sPwpZ/9/ERErbLAXxxjDtEEE5vL+5+vjq/m49r +u0QYZuvUfnnEOJUNB59u8UAeUYbmAzEvoYyYPZBHnJ/ygbitHsh80vzLrlDm3ThEF0o9u3SEvtqs +iJ/lDN0dE8dGa7ozDkT7AMC9OXn3zMnL0hRuo1Zpb05eNyt7c/LenPyM43mt5mQSFxiUbfn1IkKz +NyHvTch7E/L+mpHJyPYm5DXd3R4V8d6EvDch703In187saMm5NdkbH178e7dx/m3mWw7KVg4nF2h +BrPT0334ePtOONvvl6X5HxTaXjuSTv+ysQ3KPPvQfj2/vLz519zxXV789POdvC/OkAd39hDHxbZ3 +AePuPL65FtH9ev6+m5TbK91eVOm2v+P28dHslW5PQUq//un2/Pz6a+HAzr++uH578dPN1/+8uLk8 +v/v69vzt1ze3p9c/zd5qe23cXhu318bttXFrRjafD9ur5F6GqzJhttXl9L8vrj7ePXL1Y74k6ftn +R7x69pjOL+VhkconK/Fi+p5vL8i/n2B/vZRHzLcqS5zEPb5DKP+a1E4f3p+fycF1+xy+8M8uHb1q +Zc1sEpWWeLG0Py24zWsYO/v7f78XXm+DUfYFX4DxfkSb+wSqqb3eZq+32ettviC9TdTSqN4mKnGo +vtnrbfZ6m73eZq+32ett9nqbHdfbXEaFxqtwodgroZ5eCfV9FP52UAv1OvNnbKCP2nYV26uMAH5O +veEL0ad9Do1tIw6vJofG/IwNW55DY/6KbHkOjfkD2fIcGs9zD8h2exNv//F5eXH319OLx6wU+7Nz +f3buz86NB7LlZ+c+/9S2nZ1LqfK2H5sbCdO7cnTu80592txvy7G7eD33OaeWdOCFGt/nnNqtnFPf +/3z69uZfT3F/0e5Qoi88u8Cu+HXOToq2j8h/9i00+2LNt4+Q09yt7d8vgGTzB/Lr/IH8uuUUYNup +2c27dx/O77Albs/fLqLTuyYDfMeRfhkCwOar+holgW1Zldd9n/heNNtl0aww1VdzUXI+n/ESbMaS +kcxnNF6CzzC+nD2Sf128XeBOGL9+/hG5+SP6+fxxz8NsSOnz5+egvkSlxhNk0d4d7mqv1NgJpUa9 +V2psLSscXotSY/5A9kqNHRB/90qN7T1290qNbaTke6XGXqmxrUqNL0w0uztd4Gj5GgWzd7enZ3en +l3+5uZjv2KyFZ65xaum5/TMPZ+ds+fH0w/kfbs//78fz67P5HOeo1AvEpH9/d3F39ogCK5fY8PXf +Ly4X5EoYlHl+zddsH9vrj1ffCRb/c8HQ8iLPPrKzp/Mye+6RLNNqbXGc8/yRPKHAsy2nwutLdrTg +PHh3e3M1fzj8+NmH85pSN73WVEfl4exbW+5u5vNTNy8wlH3uosHg9rmL9rmLnli1PF8m+dJSFz2J +0ujvH29//Hgpk71LesTXmXtlgUix5cLR86RceSE975L4sL2qdS1/+NXr8B6bP44t9x0rX53v2IIR +7X3H1ozyxQ0UPV/y5pHw+9dtprjL+bNXZKQo91aKm922Usz2Zto1IwW23BaoxPfi3usW95ag2V7g +2wt8e4FvL/DtBb69wPf6Bb7ZosFrFPher1/a7JwOe4lvOyW+2Qu4l/j2Et9e4vskNNtLfHuJb4cl +vsK8FplvyUi2XOqrXp3Ut2BEe6lvzShfXOr7Xzc3b3+6PZ1/3r9Gke9V3hmxKEZ8y0MkXmPGi9nC +3D7jxbMThH0az4cGss948YkcRsoD8Spo8z5/x9aSsXeXwt3pJcT/9ePl6dkvX68UdPP+9Ozi7tf/ +WqAT/nD36+V8HXf8+vlduJdcuLztO2vRYHZtM/0BiLhDe+l1akSX7ZedOFc3yzm07bf+fGAqx+PX +RN6+HMZhF28DfE0M99LrM7d84ywczq4oRGZ7nXz4ePvu9Oz8+7PTJRzpoNDza8qXrdaysQ3KPPvQ +/vXzguj8S2j15X0xg/PIRjgutr3rFzfn8c31h7vTx65SzLUq43K7pEA3bvbmPf3vi6uPC0xb3ffP +vuTEuVeTZaiendPq/FIeFimbsxIvxmN9e8F9cxKNjC/hNSB94B4+icRqz+3tyq2vexZpl1iktMCL +z9hpwRfwk186yt//+/3N9fkGo+wLfiEs4Z5fenl+ac8u7dmluX34PhKqHeSXXqc1YAPOaduZwedx +k97+ddqrzJ8hnejtxd3PV+cL8rrvEnGYfSD+8ohPQTYcfLq9csYvj3yZD8Rs9Yo8ksEnH4jb6oHM +p8y/vARhfpWOxEutZ1t/fF5e3P319OIxiXp/du7Pzv3ZufFAtvzsnM8EbPnZOX8gW352LqXK235s +biRM74/OV3B07o4een9L4zbyQk9OCXdgLZ6uAzuECK81FdE++exolLuXiuj1XpG3kcVgu1nRvy/O +Yb1rfNtOJlm6OpWqZqeX2AXCblZl/Hfdrw4yd8j8NZ9spM93YH9tO8X4oxT98Ljz2O4SDEZS/Tlt +wF2hGK/wbHrW+K9tzb6wT/Hx/AnSXk2Oj2K2MLXtST6eRRH1zGP67ouJct259Biv04lvMev2enfQ +9ttTYG/AyP7+ihMg76I7wibrsu37KB/T7LDGXWG1zeH82Kg9s70/kz7DXvrh3fntHy5ut0FFsi3r +fHf64/w13gWFpl3NtnNw7P9zmcZyUOblUnF9vD772w5Rk1eHZYfNqlx9GXj2xz2evSCemS+FnB29 +lIsJhR1EXf/99vT6w7sZt0hsD76/Tn3IJqzatrOfG8aZ7II2RIe2JXz1Xh8SV4aec99cXm7BmmzL +lGyGrHtfzSUdeKHGF13/9NU3fzLlm99fv+2ugQKoAuTNX26u/ypVME1JoeCj858urvMXB395zzq8 +vvr+16sfby4PfnN0+van85VZFau/Xlz/8tuDj/JvufruoHeo+eFXefh/5Mf/EdC/Vn7159X/97/L +1VuB/vC3g/KwLMs2rGx12FSrq4PCHJbe1FUEFFbeV6ZeWX9YVa4BoHV1K+/doWvrZnV2ULjDYLxd +WXvoSpTxh7W3UqU5tE2QItVh7Yy8EEBpvEeR6jDY4OWb8rCtjXxTS7NV1RDgKjzbpg5tepYizaEJ +VWu7L8Kh9cGzVuddvSpaFCkNAI0L7Jkp8VGDrhljpRkjfaqkCwLwbesFIAP0bdMBUA== + + + SMbRhGbwTe0xZAG4yhIQmqbWETvDQk6mq/RsXKYTz21w7L8rjayP8YcWE23CYah0RALypjUr0xxW +BpMggNpV9crUh8Z6NFShK1IIf9uWhfBOhqvfomKUtgR4E9BdtFC1K7YohaUQe2GrlfZKCmk3PQAN +hl9wKNauODSdPAE1bUVQaRvDb2wlw5ZZrW2rlbimWXHiWw4Jay5r0hy2bVWj2lI+kRHVh3VD3CAO +OL8CTtjapzJNE1ZEG5f60vgV8MqVKARcAwJh5UvHQsRHWQLBTyx2AXz1Mmigb2m655If6++ifxlL +F33x2ESRtxH7UfQdiV0t+r7G8RDJBd3jbHPQRT5qTEvRz0ucuiKfuzi9RTe/cQGKfAW4SkW+THEp +i34t42oX3XInlCgynEh4U/SIE1Gr6HGL+NfGH22IWFs7b+LnPlWAeWKVmAw2g3liw7rM7Iw1qXsh +djg0CRurfmPpQJ2N25G7r8i3HzdoMdnFRb6NudWr/KtIDYqOHHD2TdwPkWaQrlSeMCUsSnkCez4g +TkVPnRL96r5JFK7oSBzJYJ32gNJB4JHxEbFkXYhqMnVxBrAqQEjf7YKgqCJoa9kBIDLXQNoXVFa8 +r1aJrMfHswOiftsmACrwmPFUAck6t0bXCsk6q4xdQWedq/reYkSuGYxIhi07xfXDxsQ0/EYnBnPX +AoW7ucP0BtdPryyAkEObFsCTvoSEJy6gGSxlZbqlFCKF1W7SaoNkyhArYFkCSCEZR+Bs99/UlWkj +avlGqV8bEv6hDOl63eMo0dj3myzR9bjH2A7puh+Q5trVpt9h2E6h7PYV8E53k0ubz61G+7PSk6My ++SbWTsSNrkeudNImWmD0hMKm48hqnCBDqlLxG1sFE+mOntPcDNweVWAhELA6UbCS51rDpVcap2c7 +1r0n7MQSbEoSSxma4lFEcmec8hAJxyvDQsTHSJjbejUk3c0qI+s5xXeRQYmYLZRZCbrXM6PxOnAH +osTWpWDiT9g9IdeDo0meOb2Nq+Pp5TlIIeM1jzff6GEvy0cErbzRNgQNgx6RYaVz7fUIrZvV9JQd +H8Tjk3p6mI/P+zFDkGh2T7LHbMWY75iyJmPuZcTdKJluMv5nzCKNeagpmzXmxJQ415FVq3VO24iL +6BPpctNGfg88hgl1xzCCrAQsf6IqpDume0+6ZG3HcJJ0VTlPmqhbIm6J/CXqlyhkTyATEU00NNHY +IQnWp+MRp31ycPTjQfJ0P/pZBJHf/OMaQsPb1U+3p28vzkUqMb79rVQja2MC/raC504+d4e+ccCA +zHHerI5+OvDVYVkLCQKgSA9FMLUsMDZ2kFWXJRZ6cHR18E6aPzoSceE/PqJvTWmEQpWHIVgn8wSI +LIfRYWCR5VUlLz16YqpalqrEad9IR344jaNrlBGDICHzbAUtXQRIu1wOHDiOAoXgu7F64Fj5JTPk +DuuyavX0NzUYwni0VNKYVFKHoOdI01jMqExkaIxyFI2Rs7YGQQt6ktTB13rYuP75WA4b64BmHSgc +OtM6PYKFNwTiORmctiw430ohwU1neRLKMGSicNq4Egw69jtoEA4b1z8f86xxtc+/qOpKjxrTgrzL +BAD/AShDzTLusLJ67glXUCtNqHV8tqy5DVtyhtip4LiOsbcNeSHZzHKEKVkocabJbi/RfaED0vea +Z43FQh4fpFeFfuxXWliPFoOdzQZqZSplv6B37AS4WnaropzFbhbsd8nNXwZymRgbGhIIz1dDhqXl +F0LW9aipLeuoStB7zHplnbbTglEJ2MCBO9qjNpw0Iu9xRzcNKiFKOKwqkUQomhw1QkxKyqKCQRWO +GsEpz+NAsIzya+NLbShiYgHcrGvuTI+WgbomNFUClPg4/uxesbBZdWVRP86niNYcu6nly64HRGSz +6rpIPF5lg8BAZRGycbZCLzAPgvk6Vd6vspnibJJ01sJaruJsc7J92y0HV8O1Ok0JsYQIcGoTXnFF +E1r1i55hleIFMccrlsmBQJzCEdLjFt+0qw79iKBWUczVHQ6zLV8p2hPN2RtvVnEbdJ1F961fZfsE +e8kR30xbcys5p89pM/o2rPq9iN1adgDsZlPzICH5SBPa73fQBCofIkkA0bAteyhIpYeNnDarnqyQ +8uiBSQhIkyD4KlEmrDKoTE+8QNwSbUuEL9K9hEM9ZUzUM6FsR1xJWzvay6fjgwECV4rfXWnystKA +lfVVpEUDxaALTdxIusnZRW62qJCJIygwSK9HMAcJIci6tp+XKCjV2UQVnEtv+2/Gk62koLHZehTj +JStGS1pM1rwYIUUxRppiilfFCPOKMWYWU+QtxvhdjDeA0l1rsj1SjLdRMd5nxXQrFuPdWoy3czHY +8VYLDWkCPwElJs3wJp1ySlZqEi7KYW1TrxIFLkiZXE+Zignt0mO66albkZM/z5YzCqkEuMiJaKWs +QyKyZYjSayLARU6d49tYvOjKxyaKvI3Yj6LvSOxq0fdVh1Pk44lDLvIxc1aKflri1BX53MX5LfoJ +zs/AtAT9MenaOH3ZWWqq/szvjtsOJbIzucObokeciFpFj1sR/4ocAWXqeMry86gZMrJXIypWUXtU +lwNuQzvjzbB7VcazdNuqyPdV3HtFvvmci5DBBi6yHRz3eP8NqEDjIxuGhU+kIuPVOnrSMXQdySkm +dCljDDvi1X+V6FvHXxJBmqiqSFQQWBTKjFNVTOu4WCCjayHI9/RcMdaanh1WtPYmsssjdvr44A8i +IXybc9k1lPXSgrAMNR+l2ca4pCYJFfG5bpOm1kKKJNEWIcpFWKmad5EmIgM8mp0IIdnGcWCzr7Aa +VavjbMZL2HREWHEw+6axVslDHSLC64bRfZJoKqQQNuZrTLxAyqZRbXepSkCZFyrc+KOu424QfsjG +z4OJFVRaQbCRY69MSA3H3Sc4rJpXzInq9RpidwMNZdL8Vr7VOW1sEzetIIjVmffUY1TKu2Jdgu8B +iYDhd/8uFu9LxzbyJmJH+n7ErnY9jcPJRxPH3A05TUs3K2nu8qnDO9UJxPlF6YqHYVwC1/Hw3TrF +1eRiWt38XO8xSmQYEbEmfZHwaoJ8Ge4RQxvXf5NwOKFwwvMMzTGpVWC9uhcw7SJAr2yd8Utku/sX +40KoFxJvX6+0HExUEpRUbjZV33lVQtis76rwNwoRojoa/mR+RhM4mGATV3mwBuNlGq/jdKnH2DBG +lylGjXCOOBk6lJxiLadPBp0Qe4T42Z4Y75dUsttRrLwO+baLzXdbc7h5m9Vwg1vtz5AITOgEZ6ep +c2KSJlJ3j7OrNNMdUWL9fkC5uF7x0NcFw3o61xFA1Uo3GY0ERtS2/wIY01QZ8e10GB1SEet4skRQ +wspE0xPeZnQ/oXZ3OCS0L/INUXBHDB5PDt4d/Mc/Dv5BZdUPbw/q1W9+u/rhf00BX70xq2/ey59S +Dqqv3nSrfNU/jJd5sMoZCp2hyAjLRjg4QlKWGCHyGNHHWwFlJttlvJ1GG45l0IWgPQo1e0gNODrc +TGgGSozpyj20CJ/mdGpKxMaEjiVGHShG/ZsQbhaakvfJAbBmuqZHyeSwWbcy01NrcqytwYA1B+T4 +BE04pp9PDt/p+Tw+xbXg9LSfMARjriF1cMRdTDmQCZ+Spn/Mz0x5njFnpCV1dYtuedPyF2n9J1wf +y025w5x5HGx5bqaMPExox4S+oAT60UlT0g901MR+1vWUWsbtN6KpE6o7pswsNp7lyUKMDwEOaXxQ +jA+S8VkTicroRBofWTkOXkOP/801Yr+EIsITRygi3HEow0CbJ3JK4+VEv1KR2aHzh1VQA34LvwH4 +PdQOpg0AHHCiEjJvohVdZDGYS+rDRqTawG+kSIDyodKdZUpfiTjflt5FbwRjS6i5Wl85Fd0MTGst +1IulipoGUpQcRZBAonhIo4lqxkTGEVnYQyxpILFSE6BiI4YVglODTgnLgcxUVWKBYYCqLP2BXN1C +y9weesPn1sAwKIefDDBUxFnsKoNPVD1fUUZmGWeV9Jmmon9FmoICc1BB/ydTgIks0ixwEmoK5nEW +YMiiKCdjrKyqqDAkIkOFDQhApZolDuhYywTlam1ZsXNqXqB1y0ELVEHCJdvb0CQk4nSriAipz6qC +VL9oYfWGlO2jlsj4slbTGTVtFM8D5gBFnfpjtNwUqB4eEGyQ2409oEwvfRJZGN+Y1qpd2jvMvnAa +rlRxVvBb1aCVj24MIsQ66oAaq0hDrrMVPqJqtJKyrRpa3SLZkIZq4H8jq4sJBMAkZShVAglAJ4BW +VQgRJHvXpm8sPGmA0WVdRxS3ju4GNT1iuAuwsWSsyeqvuCFbx0R6aKNFX1C7iiKntAMEdWhZSXhT +w0MnI23usG1U3MF3pia1St+hLh81V0S9Im/QlVa9baRXvlX2jOI6us05S/0GpoowZPOxFZMJgAzT +mrqfomLNPBYw0Jaxcv1K1sNSq4D14N5suRvivi6jZ1kJ86YudSQlQiGruPali3jeukiuQZFUntOz +RUq55GijrVO7rYjeDDCxGKJrHSKyO2UhbButSqocwg+vXQS2BxO/jv5E2d7xPrWizYJSoZh0pY1d +q1sdtfdBISa00UBYxU1XynGf5GiFyaLCnMoxUhkOiqB6wUg6STWs87E5WKc68jqgPYn+kkYXOZGO +hLzoKHmi9UVH7NOBUKQTQT3A6C1FXEw47Kkccol4A4eFgJRRb8H32etYAyqoo9PU4Nw5g915nbG5 ++S2aMSAMFubjujm00NkZ+rK4qbEZXgU1T0YPkQVOcbWgTauI701Q07O0L/tqJaeyOzSy+X64ggTq +qBXycuIGLP26kk0LP4dmBTcqwV3ZmUdnmzZ6NLdRLzvOy0IH2QfU3kmb0VD+Dznff/fN7d3AZxzS +jnoQw713dQaf/Y/Xb1cffj59f766omP0f8pXX8t/B3bokzuSntawCMpiLmYSwCUuZROUDV7KKCgn +u5hVoAy1mFmQUpuwC1JsA4aBAuhiliGWWsg0SA+Xsw1SaBPGgcUWsw5csOXMw1dvNmIfvnqzEQMB +OXs5CyFD25CJEOTflI2gnL8JIyEFN2MlqCfYiJnAHt+InUDBDRgKLbYBS4GCGzEVKLgRWxF1Bxsw +FtrkctZCy23CXOgBs4S9UL3NcgYDYvCnHpVRjF7JbNVR3bi2Sn7cpjO0C7HR4Jh7w2VkSlff3Z5e +/3S+PGBGDiRBeEefBivUlTEzOBehp/PqCHVC46WvK3pWycq1BAVMJr1s+PeEBiu+TV+faGAD9nqq +80QN/zBBa8usy9ZyBNXIB9C9Z1SCdi1VU6rTe6ontVZkzaXOFHmv4usi73yspuvfSZoJRXB28ESm +qOvayUHqTtfBk4NhNSW6MGwNFWtXUpcAmHZ8zfjWTEM+Tel19jbW0VcRu9A3E7vAP1Wb9Va7lA+p +n5g0L/20FJ0XZT87E0Sa5RJqA1xCy1Z4DDhp2obO9OUKu9BCWztm010L110FFOkBPA== + + + cgvC6OATCp/lqUeonNvCCZWw3INBK4UwGHgNS+tGWDa8Cr4BZ1fChy8EOo0Koygjh0MoMQGmZdkh +Qqr0tOZBUALL1LlAzwIeX5g3YRVUkUmSe3IgfQxwvAa60AuWC2BoggdDT0daqPNIxoTWBzmnFNSQ +OQH5h46TKykclJ40/HFCZU1Tq0KwkcNBQaGmOjZWSpwQpkLZPrZMxGFvitQ/YpceE3EQJwccl+XB +riPlRxx9keaDGMo5KrPX/dtUx6AKttM1k/rSd0Unplr1/eWobFhlg4rzko2c07Lin1Blc5hmqZ/o +NEn9YugcZQvGXrHt2NF+Tem84smEx3VP4+2Ro1yleTk5KAavI0Sng1X4SjdT1wykB4EMukLUKSbd +LaZDKqbj7lCmR50ive0nsEh19LNcJNzpl0IxWZC0X69isqbFdN2LKXIUOe4Ua3CrWIOCxRRRizXo +XKzB+mLN5ijW7KFizVYrhjsydm+wcbvZz7Z3ky9k0SNVMSUVRcKrjKAUa+hORpdOkleNgBqc4x4O +Q5V+XrVtHQ++KDKLJApPBe1kzTE3arXQqdY5TD90DqMlR7/XqW49Gc1Yra4IG+uaB6w/2vkufxX7 +kdWQGurbSb3Ie6Mv8z7HGlKnTvoZgA9UyTmUrahnefcizkxeWudl0sKgF0qJ8M62fU9T2/1opkO2 +3QE+nqc10zmd9DVLM1hA22ajKfrJWIMNiin93w1N400yi0+GKrDJhNDeNZw1qkJGU0sZfTj/Apos +0ldvpkuJjnE8wvJPMUAFwBGmqCVy3NwavFOj8RA9IVlMsFiFqcl8pK2QvS6G76c4kLVZ5I2uwYR+ +HMVwINNtn01OMZy7Ik7e2tdrMKtbqgwB+yUd9G7dONaOeO3kdHN3nUlUVZhaJ90hlDIlhZk2Bgcg +qLdNhwGDlJ1IrKa0kcbTObRCXGCpdMyoYVfeGGs6+cbwsFOLqh4YjbUIGldd3Ak8NlUHaIHKDc5B +uKlSl+iph+kUFg0UNJ7hki0CZWNAIq23ZXRbDRRuO2dMRJPiB92A2L8CHYQSTfl99K/oO2gQNgVh +HUrOmsIcTM8an29Vs0X+SY3u+IHojJOD9JKWagR6kaiUNQOxY6VgkGpq9LqpOTlI3dEJbNAvzCo1 +rmmawSRV3rYa6MPFEOoH1XxUYHPJlDBhLVVowwfUTvUfQOHq2rLO6ynSImbNFWt61c1S1vlumrIx +FmumopuobMa611rAJdh4/rU5MB4ZHg1Wsx4iZZHmL8PdIkfeNjlZ9zjebYGThy0kNjjnAy0kRpgQ +KWLo8GymohfclA10gg4adGiOPZysGd4KVgZEQQSxRjoj8xFEVlQ/9h+ucLBJZ2uWaFSvvqZoaw5b +KGyDbbH7hSE6Otu41aO5rUoBekMHW1YaMJobSR4zcvSUJurAhrRGSfeI2qhBY0Rv1DgyojhafERz +AJxQHQFuQndIppdSHrqRjGkPafuY+ghwiv8EjikQjQZjGkTt/njr8Qga06Gv3qyhRNDXT3Y9tPET +agRd+4QewWtoQpH0fOxoEjXfE6pE/6QJXaKye0KZuHBrermOOulBPqZPqmGeTtM6GqVK5TGVUuh0 +ndZRqgxPM1qVoXRGrTLsL4boP6VY+WaaHPHt51eaCp6u/nh7fn79SUmGQsoyJEyK7yAI9w8MDvKH +dcXBl84zQQBjPzXJUBucRpCX0dAopIhe4S4E9emrYXmBV6zTQqBPpdXQ/oDsBCL5VXUMxqyzLEN8 +1CRDNTKtxPeyhY1XZ07hwrhTrTOGm1wogks5howGsls1Whh8pE7b1g9zDBFwFgMjRt/UrWV4GikN +LRgx/NwLNscMKiF2PjS1poow9OyE0bHVmB8n/zA+TT3YAKpo1BOCX5WaZKhBYgxkAwhOt4CvYZnE +3+BSkqGgPs96DrC0pgqoXIjZLhp1mHXOJkczV5X04TOMN9J+NivtN00FgtFMBoBQ9ujx0LLDMDnG +vBvImgKLkzHqGBoqhqdZB09MTXjjsGhCf+vWq2UmwEpUIww2+ikahDMTI7rEROg3kSY6dHrkAwBa +NVYNeB4JB4B51oWYY6iGtyiQ08ZYnNDQ9lGWwXXPKcdQaNS2El/G0kVfPDZR5G3EfhR9R7SnRd/V +OBoieFXaONcccpGPmbNS9NMSp67I5y7Ob9FPcFyBIlsCrlKRL1NcyaJbyrjWRbfYCSGKDCMS1hQ9 +2kTEKnrMitinP4KNONtUJmYkCtHRs3JNiIhoE6rjsNaGE66bMiYEiJGB6K9bZQPgtrJxmHFfce9p +3oFu88n2VKf84R4u8k3MjT74irQgWsUY30aCYdNqVD5mGDLeaa+ErPhVJDvRlFfnCYYSYUqEK32R +KFvRkTZgh2ubiC+V1fRCjXEplU5oFcvqGJ3nkWCJuGi8idhZtzG9EPxvIg5Xmn6lZYamSLDz/EIh +JhiSqQ+mg6AOzQ0U60BDDJDtGyJNT/l30Bv0l0Qq9pcY36Y9QJqOgduYwowDr8lu1Wlm+vxCceow +t5rkhwBMft12k29JWXxK7kBbOVex6VaRCl0XUzXU2Ld5bqFaN7IGerSDb+o2+TtX3inVS1OvmKe7 +qc0oJRDYrXJS6nRzEsmNJnMReh4GJLmp+E0i2thI7WBH6T5Kuy4eBv3G1IDmxvt892of0iljQjx2 +qrSpNHVLRykc6eyQmmiGPGIn6c0qbQLdFjS+Y6UbNAO6FTTAPJAJI2lrGj3P63i+t6lMAFqQRho9 +JJnjQqlou0o4pqSWnLvioY/0WD25M4odVhk1zwi9ETKipDwoTtsmsiVBUboMOm5f0lVe2q+bjilh +B53Gf8FjXcdgdHpDLXuMo/ScXeZV5DRUcao88+C4kuRN51KPxpJT24LEcKY1GeHodB2dv+PzeXqE +j0/5MRsw5BSsYuOAmRhzG1OGZMyzjJmaKd+TyHOizok4J6o7Za/GHNiYRVPscxEdrSYXMl5zQJEo +0A7sE2PYJReKJIUkpwzxmRRJ+U4SJBKtmNBA6XAia5GqJbKXqF6ijD1hTMQz0c5EXEfUNz4ejxns +OZbkNqg6w9uGHiCVIF3N1EHw42rXZReySIwVLcnpoQgmyFpDugzWNYc2CO2d2JKFrQwtMwfJ34r5 +K2Sm1GIMMRI/BId9A/OyrAhcd0r4X8qpOMkuRAlibT47zQlAJNFsTX5VpBxjx8xn59qUXDDUms+u +6vLZuZjPLh4VhrF2ms8uhv8j6L7OkiK0bphjiM/HmtAupf5zzDFkVYK0zF0VYka7Lu+g0zhAjYRh +/isXE9ql/HXDFEN4Po7p7Fz+RZ7Nro7Z7Pyqczw7junsdMgNU+DFTF8xn50mA+syRsYI0zybXROz +2dlVTAA5TmbXaoIhw4SXmnqsWaWyMZldG/OarWJa1BhtUZqUOdWmXGNuFXPZdbnTYpJIzX/D7Gqd +R5ZlJrt42tgmZQ8LMdGji8Gp1td1FnnMTHYuZrJrYyY7EzPZBRPLMC2gpooL2pfWxEx2Powy2XHe +FBMZZ6XOqsNUdrZPZXc8SGVX2i7Zblcyz3+qlTOXXb3q2o9Jy7oOMpedXWVjYC67sOpH2aWyi/HX +DRhspl3TqN88lV3TjnLZ+VEuu5heiCtGJFt1CEUM87ri9apb8AydvAkxjV2l2OXDKI1dq4iouBTR +LmFSlsXOdDnsjoc57MqwSqjPXjZtTGKXxtHohqq9BmeTLmgSu3aV7cAYrB034CCFXcxgV63SDk5T +2e/xlFo0kQGmsKtSSuOqjx/vSEmWaYiQE+a1YzqoCCGBKlMm5bajYT0JS2QuUblEBxMZTKSyp5SJ +miZiui6xnaYbajQPAN4PU0a7ZpgyukmZ8+pKw/OzPjR1trNiJzVbqsYGx3FoSlVNx8OhatJVb7q5 +yPMNxQlk8laOLn0zXoSY5TJk61SMl3KUNzqJgxkuFCNkKcbIFMlWm+FbMUbJYoyzxRipizHWF6Nd +UUz3TTHeWsVo6xXjrVmM924x3NrFdO8XA/LQ6KmUpcLs0kUriYGnyHFKF21IheoUGAzn1kiliikd +08O66UldMaaFg3TRsGwcp3TRPUUtRhS3yIhxMSbURYbJqXieLjq1kXC578ggXXQV+vEU+YDimIts +0JyVop+WOHVFPndxfot+ggfnYeP6dSryhcrP1ao/+ItusSM69GdzMTq+Vx1KFT1ODVNFtxFZa+ej +aGqrWJzu3swU3cQ2skTRuiuiViDrWeNDxrUUiXgX+W6KO67It5z2abxti2zfxp3dfxP3fseJdQQi +49bGWaLDqiM0xYQaZaxhR7L6rxJV6zjMjvRlbKgmiq57VjUmik45wdkKE0Un/A+KJAwhdz1fHBNF ++1UxIuZFoub7TEP7TEP7TEP7TEP7TEN2n2lon2lojKT7TEP7TEP7TEP7TEPbkmkIIZLJoXfg0lvB +zgIGvzYNshtc9TAEfKoWiQGflEdgMtEoCxGtKNBYymxq/RcMUmE3BKuKbSa8hRQSbIgWd737q62c +Sf4ginlyijCtbu/AjRSzTC+Pc4W33ARY/DtXjZrB+EwzUOtCGmtj2ucU0K23ASA813UXIVmmy4cJ +qaxjJEgZ18ZQREZEijWqaaHcrl4KNGI6NWNg/WNkmqxEclaIwea+T3viUyr7KvYJn/P8RDhLSp5f +qY9YOKRfnDrxxLQCrdQVlT4mojijgym2VnF2uErqo2CikbsKZQy4dvGaAqgSCNEg7gRR56S2jAly +9av2sI12hWRgCIdt08Y45dDa6AfVGhfpp+cGlDFpfBGWtQ5eeeM6RkYTQocrTmH2jcxNTKGrux6J +GWLFptIMVbAIljErhed1SA7bJtrkK/qZyJR49ZCATU/XjRHaauJpeNNEqaHx6q5KE0zJS2Bq00Pg +qSDSNdExgizVLbavyAGn6tSYowUvydGxQx6GXl/3fa4YZ27zgdUxbLsbfJ3cI9P8QONj4oUVcQob +attdDwqgHXHiOV7GcMZUDGlIJQlnTyaBC9oS1r0kO+h97XoA7apNutUsfRMTElTkYmQaqnKAhgKy +tJUAZMi0OBN9jZjGGIC0QaGpUj28tSE1E6hUpAEBgBZaMRPzYGvKaK9dyxJGVzHFfwxs18QWWbbo +oCZf1RWlL0re67FS1wrN8l+l9N96nYxTT01L3xZN8m+iOxnJVR319x2Aht/oCRJBSBHN9M0g8Ujy +kBL9EwCiCdypymT9K3GwONK3OLqY759EKeXjP2PCf3VcyjL+G3WVXJMf+uygGCRNj0n/fZPVMMpD +rRmH0BWXzI510JzoTfTAYWdHOa85omIybGbPNtHmqcQe0zeYK5IVaxOp0a8CDGlV0y8Dcno3VZwu +4rmSMSbA0NVUfbwr412BtorifwjpWQmmcy7/QKk7Marp8v/nWNddZEJUpYMxNY8xrQXTuYyyosd8 +T/SSV8V6fgmAerDF/Oox+Xr3Q90su+Tr2T0AtWpKs4sA4vV+ZLbODgadienY0WGrHQ== + + + zu8CWHVJ5s8OMtYyXcNip9nqYyJ1plZvTGpOVsZo5vs6kivf6CLLMkbSrTyCoEsTh2eTJ3yfIj1i +WboTpcP4LmP/WbwVgJM/vBYAKG7UZb27KKAsSR7ODnqQS+cbcoFU8CzAIV7qTtDbGw6VI1JNWekZ +wt4mRqbjmwJ06H415aQeyqFVRn+JaRy+rCPM1hqHj+Q52PHBliX7LRw5bgT54eqgbjTHyvhDgSPB +Tvry6GxmlUf3VmlqAydQl1XZhXGsidyYMpQZdBlLGUWu5UylylCbsJXa5CaMpZbchLWMYuxi5jKK +bRuwlyi5EYOpMREbsJgaYrEJk0mFwkZsJgNDljOaMYBzOauJMW7IbCK91HJ2E6GkGzCcX73ZiOWE +RL0B08m4ouVsJ2OUljKeUmgD1lNLLWU+2cGF7Cd1dcsYUARbbcCCYo03YEKBUcvZUGDvQkaUWdE2 +YEWpONqEGSUx2IgdJQHaiCGNAeLLWFIlsUuZUqXom7CleopswphqKNwmrKmezxswp5qebBP2VJvc +hEGN6TWXs6iadWA5k6r80nI2VcttwqiOFIVtF/n/HWxVmqkyDf1KzWkajFRrLFpj9c7EwHPdOiWi +HR8nXSWpLcBZITQSfVcmCB7M6pGsfrgl70jlcDAWzQGJXH7q76g8lE3X6EWykM05sMOrR78rcY0v +9h3dHRz2n2pVhwM63oRPl4PXmHiFqrAnumuCqRyca5FSVpAYtF+DtNng+Nsm9J8dnc2u8ej+Gn0r +Ey+0KK/2flZ9zcpG9fKStWWeiQ1Wlza45esrxTZZ4QcQnKy2yRjrK6ZtKE3GfQtRUyY88ufIA2mG +TLztcl4il3C8szTEeOCWrpg2XbAGbqe16jwbCa9V4wkAmptUeLxabyilhKIUX6M1+ivgGJae3TpI +Qkp6Ww3obX9Z2+CCzoxuk6pXA/Iuv8gwEoTlAICB6BA2sPoMbq6jN2Hd8ApK+dZEL28yzBRMXLSE +QMybzPdGcnKDoIkoqtaHzIcig24R6wL8xw5Bh5BGOmgnh59y86Wvjs7m1nd0X32VVd/MQaX37701 +SKeR+kvRTlMJL0Y8bqOlqEfqsBz5NDvNYvTjJC1HQBZbjoIPEIhOTYAMY9BPXPUJtwKDyZWlpLqh +iUQpKSUY8FQl/ZiHI0UFlUCVmEkDgK+aGM/XggPGMJGSQ/2twEXLkJiQgs8YuZQxqWEyLOlSytQQ +xYKeqSHjE8hqup4/amMW7bP+RsrhhZShXg3YrFCthprCEroAullqtczqZA+jDCqUGVExkKYwQPUF +YzZqpPxNcqtXkZC5OSaTvRF1kEaqtm51j0I/QUE6CPNMoSsIiol4KjiC47mBoOjG32IfI5NS/y3y +ys+t9+jeemXXaPLhQcUPKdQm2JfluFqAf1pqMQZqsaU4mBpbiIXK3i/Fw1hqGSbqzC7FxYfIBKl0 +rSnpnaE7LKgifAeheXN1cp5GVEqd9ILAMoaxtJCf1fHRkvjXcgiYGFgLF16cBkmX2F8vXCeTBLVf +QANKk+xMq2kvqCtgqmsNPwwxugJaj6DxjSq6gGtkdAWE1mBWkyFtuBlreLdzH8hM0lVeBMKWA5f9 +4ODrznRGzNNfjT+1Zatf9N9yK86q9ei+WhGPyAkZ1PrAPpwurwKXLrDK24uXODW2cJG12OJlXovn +yNokW//evE2fLY/Mh1/O736rQaGaePO7A4RBC2GjHOuFBLeUhFuEW3fJZU7nZ+e2NcIIZU4apIbl +iS6UspGFc9CIRvna1ogXMTCfqLqprBvfAci+k/1IEGaatDg1EoS1CseWapVnpkGP7R7jlGAW94pu +mZrHew1o2N0T4um3DPKHooSae8d41wSxqsMHx9RqqmqN7aHGq+qeGfPP24u7L5pRDc2wDY3IsxrH +xRk76SHQnlm2oje+N/pFajU9q2yBfnVf+FENftjG8WSsmANHwc9m4+8gsfdSyPi6H69wgvq+G3+N +vA+l7yD1qIZ61Aa8XRXSj7+DxN6nOtPoUqv9+FO/EsSNanCjNo4nY8X4i3HnrjJQ7H+BzoCdTwMs +pnNQoDtVhibFeB6LcfManDeah2I8jK7iNM5iOhVdB7tvxtNZjGf8eDpyTgfxcDAbCZKGQcxssskg +ag7mQlEzZJ/4UR1+0Ioe2YBkE5EgaQSp0m6Msd1sGlLX+k+aUR3NoJXjyXijZzSCgGgvgaLEi/x0 +xTSNpVcVTcqMiLs89CYKCoWaJ5QJj2UZvdq4OgiGg1vP1clCYcLttbycvKsJd/gYKOJDvMGiaGDN +aIMG7NRkKeVl7YImG3bl8JE5NkwPK9BOg2gqGx/q+Ab4Z3HrVAne8IRPNibq6+px8TXaSb+JuGoE +dFnpw1AFbENhyqEh9lBJ0bO3NTXxeDilx6A+Weev4Itkgo49jacke2kalqp5IwNi8JiBERU3NAaa +lslZXRSkS4agZ707Psh6f3KgY6s7SDbubEKkUDZZJwf5PKYaup7mA8HA4rELO3nLHGqCX+SDrzBR +ls69SFph4+GEPDJI9wHWilI1cJ2a6QgoGYzqq67UsaZkjgYj67hpEFlmaQGtcHeAW/WAGgkjmlVf +qNFkejH4gt4A0a7CRM4tpDFBCSQoYj52NUd3gEZTuqQyx9lYhU9zQXN6BznLmX1AdhwdIHoIJDcq +XSZzdBzPZtxjpRF/NbQPTtPZyZ7XmCKCcN+DV6EGhz2yy2Qgj/wQba1eWwkIgYaZNru6TBcIlxpM +EDpueSYO7r/ywvvhOqe+pg6SNdjBun51NaW+j8d3luIy7rvU5ejm5pK3uri/nt7dnd9e//769MfL +8z9+vHh7/kEvdbH91S/dR/9+f3N79/df38d7XwSfZG09NGOlstXeqSb8d387P7388+nd7cW/5btB +Je33lxdn59+fnV5eXP/0x9uLt//v+a+xummLfxNm9MPd7Sm637e7mIv9eHl5frcqVkenZ7/86/T2 +reZDXHiLjGG8fRUTLltElfKZXuyrBIpPPoUO4oyKyWqrVVewGH5eGB9/gbmKP7l7so+GNXTlNARr +xVYGPRl8mTp/3I9j/uUlK/gvlMhUJJMlVBM3XE1T58pZCYcCinbpAdrdSsS6UEMqaj/7lSU6WStq +gmOWNAx4pZk6mVWqm6Q0Rav0LpXRV9Z1k9MlJtaXRVam0I+5uP3S9u0VeUfisnaLukrXF6gLCjFJ +f8UMx/zN//qn2JpfxcYoGlbxi/hB5MpXKgHEF+lLLQoyHzvc1d81EntxfNB1Z8O4LlZ1FX91TSjY +dhZu/LxMOVJXcch5Z6K9lv297H73w07vilhn/IlPu/ddkfjtWde/y5FIXfsuGOM/YjxGJ+qufmJW +EvUc0QVjzAie4r0ZhpEs6hOiN3gBGE3fCkiZE3jrlo+5sPmQyqcffRE2Ex+PUyfis979YvoPRtX1 +TTHAMXXi5GDcxVRNoaxrGmc6OJHIwtPKzHOa1zXiL3Kw8JVNd0+DxbMpgTw/tDE+vm27st1zUqcz +WMakS070KX3bFzKr1ELB9owCKevG+wvZ+KDpOHad7gc0ZcJFiDTP7OBtSUJUuWrN3anxPqgyuoox +855ntodVfENNVmW4bsEynZqnKq3oP3BVzIX5UNHK6dWWR2cbt3q0uFXcKVUjTXGveVtPAR7OFi4b +CDThW3Xk6vdN8o9MO0eTKc/dO0lBHHdP9jh3/3Td6XYQLxmduYdobet3Ufb42D7Sm/XKntZUcaIi +wTQdwXxwi6Xpi5tMvVRnbbPka9N2fV+y1SJpNSn5+cPbLY3n5P5hC06ZMZSWf98T2PXE1a6GgEhE +wA/4QN9gvYrA0cvhMHr0NEyiAvHT0DhTdr9gZx6+Y+Gm7QrndUPBmGho1pO8R7HjD7qwwOLBy99A +bODfiMyF99Iay6uPmdaV4mm+a2HdbjQ3YkZiGJN5yJyy60rAgcW2bU5ZZrZxNLcNsHpIEJjRkU+9 +WfIfHa//ccitFyZeo2kOtQ9XBw1viqY/c9WEGhs9gQydpNM1VoNy954Q1nHR6lAiz2E8IkSihe7+ +oSMCjEcVcw/T57B/FUxdqQ+ukOtKPdZHK+ihzWkfK+zipbPDY2Jhy0cbtAyzaYVA3OyoAC8vxAFS +dykSvsirDX6UZUMevg6NrcjVS78rQEyfMlL4+xrMPAN3de2Mr+Tzqw4EBaBvqnh7CW+CNlzaUYnE +YMsxqC+gIYPa5+pA74DuCup7KBINNRWTEmtBD4nVv+HVrTLg+rer330vou/1T6vfHB19c3b28epv +N3eUYTOsnhydeiKs6bkGdnd977/pe7+mXCLCa3r6u/x59bu/3Nz97fzs5vatYP5/siNqOax4zwh0 +jz4YeL/YiVx//M2f/hj3yt/f3dxe6as4Stncb29+PH/zzZ/aN9KJ7+9+vTx/0zetXy2ctezwCA8Z +uj6fjuPJlRLf3vxrgwsavkx1hGMGXBd81VJlZ6vS82ofA2+kOkyJsmcGTrtKKXD5UKihuanJMwf1 +mNjrJva6ia3TTTR1ZJFjkoiB9PXZmWZLRi7niysq/dKvIc9cqbNg5JlZ9vOzzOBOnIEjUWKafYMz +7yGm2TVIpmju4WgRBmjCmOfC1rivSBXU2WPINs9q5Wh2KxDAaQT4fIzzGna5Vq+TmFuZRqSYsDLB +TnKYgVEzXgGswRbrQF1JNhDjSCOoi6XANdxlna7wHfbjMf67kSkSArxS9tswZ+ID7Dc95xx9HqyS +8J6LDQFtc74RYluNmG/4veOEeLho43j/9tnGbR4tbhPHlLOfn+l2Ka0REt/Atn2VgWSpdXkyUBlB +vrtirANBrNILZTpQvvyla9Jl9SJOufwzGHnjrWE9DI0+AKumsDiEk+mo0unW95q3G1d6h7Dtyjf6 +cd6frh34Jg5B+eiaePG9fGTs4Ktspqagrsk1oIeljYgm5adIG5OuXQ2AXU8YhzuZpQG0G5sGzdkx +cM1cMWxzPFtrOvVpokwBGmGq1gcNg5XeQYSs6yeRZhatSnbON69EmvnDze3ewrq3sO6lmL0Us7ew +7i2sewvr3sK6t7DuLax7C+tuWlgn9tSrg6nxtFhjYl1jiH1WG6vRmznutbGC67WPlXWIFCurRSbW +ScNHyxt+KgtrscbEmttTizX21nttrMU6I+vUNJmbLqdF1sOe3sy6rvPMCJWZWdcMZl3Bz6OdqALu +rzR7W+uTaidOzt/d7W2te1vrXkux11Lsba17W+sT2lpxuQ+zGF0dlHoFoGYcFHnE0HSUYMnaekJW +LEb4jkHJ2JoVXAPqq8/a/9zGVYPAO4TCtlYJdG+sbNFmUDsnkwsNbasIYMON3Q8WbWheGhlXl7R5 +tLhNHEveC9P8mdntknc6QqNEk6ezxIUES6azkwyWTJmAVRMY7jls3FpQMnhmBXNQeS8oGdsyUOqs +YhGDcMtBL/sP0s2Dqa+055UtyWTcYmXep/Q+A/UdQG7axq2DDOaqWjN/4/bXwx4UKw== + + + PodUMe0cpYrpKHpgP9is+FpgPw61sHazm7ebf7RuqjYVVYpEC5DWrBasD7BDPYGIsqGE8mrsp3+7 ++OnnvYiyF1H2IspeRNmLKHsR5SlFFL08NMkRMUTGVrm00YEymSQVXAfqJRD6ezoVQNLrXD4ZNv6M +QkrQAd0npCC9TuUeKdpYTWMyW0qZNDr2AH280aeSUuheGdcuCik08Xib1o6vc6lAIT2XmiC9fEHf +vREES175daBMoEkFh6DyPlDP2U6G0dkpUo25cBJBeXFzmHKwTGCDkVaTsRPSc94s5XyavWHja0FP +LphMBpyiysZDzqC5EDIddg/LRY586FmrQ9FlMvf3CiVfvDTwj/d7UWAvCuxFgb0osBcF9qLA04kC +iQ0nt1/7FBhGEDIW2z5uC754PUijOrxenO1LG1YxCszknyVBYQ0kNngy7cNTBoXx9p4Bjy0DU+4c +idXXxISFR0o2SPzZPBAT9liT05CwR5rE8WQHKes/jzjQBepomoxOIGhwiAhAFzBxbz0kcefrINUY +wsi/uOwqDqwDdeUyUKq8SLxoBkoBaBloOppOLhi8SsFgKSIpa7tvaArqYpm6+ZhCumKsO69m2oN7 +gA8KCIJ53gjb80kCwniQVwNgFrI1HWgG64YWQ7sGkLUji9Fiwylf059P8bIqNJ8F7mNlYlcjfaXD +dvMUFoxFy/GaZJa7OxmIkKjVd7en1z+dbxQCBusvbvWAj3Q8iBphh5AJP4GKUB0G6+0KSXQ9LsRK +gBLpUtND0b1OFRRdDamVDnJ8QFCTgU4OWM72kEnNebvjTsXCqWyqvm9wMtR7zzsTauV2oDGrO26n +rKoHD7xCOI3a4LpR01RyZPBQ4DvcklSGRi8dEo7EHAZTViO+B2nz9fLAh0vD4xnp00exFAvbPtqk +bTBG8p8fH4G2KX3gqdbaEoenabz3Sa3m8APUx+vFBSKU6V1+OBSZh6hDBZe4IVlNy/tWEkiW20Vc +8Lx6NwFKWdr0O71LpVPhDhnic44MruOHWKrqQcW42iJvs5j0qKug63SG913Lk8F2KZSyDZF4wnzf +ZN0MvAQxwQqEIrInQVCW6QASRDsaH/CW90ylGroKsp0x6mXf7rjQuNa8yUmHJn2eDPZ4Ov77xMve +pXjUbR6hk8FNhp/3VAr0jyf5Yz+Z0wmfLMtx3p1sAF+9WTMqAY5rnDQ67OOwi+MBjUc8XrvjrBt5 +Lybzdy8wF4Mrt17GTydPXfPqKGSNL5GvXPayR0oFNUzEt+nlyeTze4lya6MEGlzrV13Ygpeq18S2 +Mat7YypeS2NwEVKT8/RlGw4dAn2EqcftVAMZVNYF+SY0GurBsqHSq7uFHC5u8GiTBst4KeSI/n6i +ekzYNN5q7mKSfFkydxhji07S2/TyZPJ5ImB1rfDqkFnyrxIgPgsJqbJahx+vATx9TMKkw7JPsi52 +H3RdmhT5AkIRKr9+v3+uC4+Ui7WfyMUKO+EMLttJDGzlAp5AzvkmHOJWO9cDlHeND0X3OpUtUDhV +iwc5oLInZVbTh5Nq8kbGPch6l3X7eDCIR1lToYG8aTyypk4YsPrhqDvc8oG7mk0j/Eptw5DDq2FJ +rTUCC7dtDmN8fSNA3rH1cOEA8jSJxVvW8tEmLQuxO2yaz82Wdutd0bgD9q4JLj6j7bjmeq1vAkQG +yOqa67tUlCW7da7U7DJ4jnxo93ExrqrI2ykmvSiGvSyGgzgeDarjPXvUVjvWEBC5Tr1go2avmthu +e2gMLy5PEO1WfMBbXlqaimvpHtMHfYptDb4d15Q3M+nEsJPDMRwfjMf0GHeZ96pjLftB5D3jXbF5 +18BIdo8n+WM/Y6MpHXc360LqsZxPU8iglkkrw04N+zQewWB8ozXqm+5aLmZABpxjld0Yme3Be3/o +vwyj7IaNu70bZqoFiEmLIkgQJxy2rs1Awp/xdi3EVFJ3Fmq9qIihtL6NOxV36ODGTfK93faCNQUh +sd0WY78874wfbLtKBZx4D7heXt/3Tp+PDwY7EaBspydQMam3WNd6MeljMRlGMR1qwenA3Z5pOgrM +mC+zeZ3ONBJnrLsScs2SRBwZLooAN1gWSjkbLIyWW7g0g9GkxdH9vsnyqBC5wQKh4GZLNNpodeTQ +2rFs1h7qVVRWA9qFRceJHUwHqRrNQFxDxyRVp2cwMul3wZcyH6lwoaWbVaq/A5wdNEIJvMlAwuK2 +uIe7qyUByCvF36n5VDp1bzyA48mQ5qeAgjGzRe9LhH7rIGUtQmvXcFJQm+FWR00FFR+KYEp/iFwC +wtmVet9477rwWSSzbkKNZkG5woTSfNWBZM58nFDXwOknAXhExt/pXSqdCnfTF5+PgRG47q6DiHDi +FCO0hvSM2tPvrulUuBjXX/QNRGExQ5U4shpXtjOLXQQJwqXq9Z64BGDbTeqXvkulU+EMMWLDMvYA +Z78ECTbNjdaQnjlvtptUfZkKF+P6i76BCeh+HmPgD9E3fJU9jVvWSu1oYHo3/XDwdjWenH7i8PVk +XiczPxkJik2mYDJJ/UDGt+hWTXf2R/cJkaT1BkXhQ0scD0RtH3DbY0dMT7rP8JVtc0hX8PMkuoDV +ihJCvFvYlZ0SXJUwQopMU6sCp4HQMFIZyRlBTdbDhcFzWdNEldHCFo82abFkjpDPntqCtj1dBtwq +Tpas0vufo9aIr9Pbk2mBTG/UxBetqyurmqNGSyvkBLjR1z0usBb0LPqjvtGmjCxQ7GiOxP2n7F7p +B7Cu+BegTeoSW7SfV430h9N/3txe3EXt0X8kGeNz3puNy8xxbXPh4FdVwdwgfGHN20QTCHJPDboJ +AAxqyF7WQvnhwApWrTplhhqqJtvqFZ+4k9R4deZsg+OV2prNyurz8UGCtMhho44dyHAEL0vZVLgN +VMrKC14eTQudoh9uW019U7dTC9a3+4i1NE1XC6+ZTY3oNbNdL070jlrD68BjTwsOhpA4GN7Li2az +EVM0rXnpaJyWgjPnqn7mCk4vDpOsv026i7f7StoVXg0Olrxdt8rGiQw/NVQEuC86Xu+ZvkJFSB3T +L9R4MY87n8v4QkaWVhkJe7ztQQG2lFCxRe5px3bhV2eQeO+YpN3ohMi04QNnQ/qAjqPhMAhqhlSH +3rLCq0ndeEIS5Fj9A0PZ5l/VdIMigNfDCkBvNnbSaqvJDOU0N0b9kctQ0wsSyUsBwfRxPvWwr4Pm +P8QjLcp1pe6khwZWYZltb2VUKhM1MqkrHGGVyREO7DG7y098/ARXgntNcsRawDbjTltFa21Jr8aN +qF8HKkLZVdN1lR6g0Pz1o+GIvcmHzFnx/axg3pomm7fJMh9PV/5+99Yn9hipMAe851X+upXHVcC8 +7tV6qyLIdl33+j/OL+k2T7L77ROQXuxs2+g1STV9pQwkjtDSjzMgH++hXrIMilXy/1CTZMBiXKIY +V4obgytFGyAsbrxOgO45lemLpGpTralN9oPdyCCjjye1jZobd2fa43dw4y6x39PfK82rilx/IPKy +MYXtoshJ1NFOZ6Bi/HkxrlG+p3OJfB9wupFsREDRQfg1aVxfLFVddHWnhgt2pmBvALNcmGY1KZFq +y6qdtD3u3XQA3McIeqidUkjvXB1vuyo5CbLV4LHkUz79ILSA+hueGxmE90PHTIwJhuvdAzJIox45 +Rkk7W/o+UnVU1zod9rD0Tj0/RPyy/KFmf1nhujH6SpjxwMvjHawcx7zS3pHgQYUknLP6Q6rADYcB +zo+DSqJm1jj4dMOnJ+WRQ8oKRxf4wiKHtVUTtS6E6b4iRwdm3+Jwsz3k7MDwbDI9SOS8VpOUIgSv +gXUYa6jnmA7XwVvRNYSQt5BpKxnx0cYF7wABx4NMzNlBB5KVqeoasWtxnEITqcUzYJ4sHQYgRDi9 +Ibwp2xZX14tgWgfemo5zMvCG8FLq4XSY0lS8kB13d8v24xXhgaEnUAF5a3jxuPOe7cB3vtF24E5/ +CIdLTqLILxUK4WzhuQPCjHvQ5dOqf5K9XmEsxwcZKATfqF+uzE0zBARK6oeqHpSNwImVxadBWvpV +W4T3hYiGPi44rjLHcskEkVcyzGhKvzjczg4UdlGE76XNQ9/YmlqgptULzuXkBkAmEG7HmIY2eLQD +HHUlR1k3cHYgitZEUUyo6wEhTjoLKQgt1MJ4weW00lSsrpWTfrIZsUnBFwRySuhpbY26xYM1sB0I +3FRTtUwS6GAD7QFYmDLoEkWQzALQqatE9qVXZiW1FCFCVwQt4QKeIB7htCDaWkf32LXSQWJHugpS +TyfDOaMu/VnuiKd9eQtZhZur88gqmCdhFZyP2n1BARMC1EpyWgrTrRmUW9kLjIKJIFeqyesEKHsv +CBxtWdvkLE6pXn0mHdljNqqoactAhhmmgxW/aBVQHVY2cO+JzN82OYw1MTgHgHYNQEsBIPUi/qWv +eTLgk5TpvNSytmZlV3IAqqEhAk46QNN3M4DlhE/ZFNQVK1hzCGsg8CJn/iK9qkUnCgx7Q5tK6lL2 +2aiXD6ttPt8mkeO1Fha/kiMZB4fHHtd8ya2p2y3cON/d/rgqVkeXH7l9TNKimrnbgrISOU/S46sO +4uyhksqgF/fQ4ZkEuchABT+v+s87QKoRp2kCCUrq0R8rsIgwMogdSr/ODsbvuh7GwuMen80w7Dj3 +2/gBAiGMh7sI/kVwKpkVhwO3cis5vxHUA30JdL9syyq9BI/qhR7xog9Ko7jto5HeOpHFevPOJmq6 +mX36/Pq6qMU0EGOH02gfm8apnlwGP3T6JC4O8FDIVGtdYHyPcHdI+pZAIowdktNBuuYWWJIAwrS1 +ZF2BSh1MKJ/RgFlWA5EMZ0X6QUQyJVU5BLBk3Zfsn7vaEyj1INWQutj3/zgbyyzLIvSbGnbjPc2/ +wjY7vWRGuOxmTfyA0G8j/yjupQdeMiOkCV6+JsghIEzTNCo62MbRcuhLsKzSbBWwZXpPCloVDSic +nKmyy+pWz1LenwBZsYHV0sVnmZcqcKqkbqiZekCcu+ODBCIbVDWrVAOEsCbNHX8d8+KMtm5CBypY +uupLd4CshQwWu9HVo91M3U8qOzzXEdUs75PICRbwQKawyiFZWxEGBZFeHBDrcOCVOZ7061hJVtW/ +SyQqFU7P+XR1oNiLVEehgSWuVm0hFYWbRVNPWr3KgKlr4673w9Jg69Gop/MymTyWm05yvgY6LkZe +Z6OeTMlkAGPjYdNfqgB5pu4pDYQ5S4O2o8ES7uY9TNhuaGbprcuglk7rDC9rSB0JoIedkP3sGwsf +aJvVkgCpqbODDgTBs/EpthrVIHTbUPBMbXUQyifaof6rrtN9VZOxzTkCjX+IeEMci6RGfxa83aB1 +tlbvcr2lpSM0mO6QTbeBdMnILpFuS5+u+Y4wr8IW2GZjXfRP0cjzw2SoJED1ZmSDs48akUpDldXT +AWJjZwcZrLvpo6uoTSqN1FoEqCYqdqn7qOt1V9F4bJ8+3XLOCPWvdMLTgyZCrUUIDg== + + + FhrrUq+njDOuIbUw8wvbUzF+ogO1CMNq1FqcUgSp6gxaJheqDqAzBXEq+ybGwfe1REBq6eygA4mU +XkWfXa0FyW1Ll7WUADq57E3/TexvX8toTJ8+s1CHIPBDc4nEB+QSgboDcW4l1DxVjsstXIlKvZhH +g6w7CDatFeaiIUFSjKOmzcf4+Q4AXZiL7mMRJPu0DUaVoLGeDBQbo5aqg3lqP1ZdVSL8VK0LfXMJ +AO1o7FIC9cOItYzH9emTW4mMiavtOLnpASwJmAheyiRMOZrKCUXG/8mObjQOrqR31FUPaWPMiJB6 +KlwLhswFIJgqnDoAZhqT4XqQgXgNOTvV0gFiQ1ydDgKF4aqrBOkSeDVSaigBoPmJnUmgfACsZTyi +z0CJ4d/nEy2OD4UmOoOoz4uvnMsljkIQzluQOpwxtYbPdzDEaNKvEErttqS62CgPHejz5XqIYGMr +VJeasO4rA3UVeMGupg6S2sNmTzAhYc4GLkasCapfUpquvQQ5O+h71X3V9byraTK+z0GBcYbWiQLr +AyiwUz843hrjwfzfe+g5EVBrQwWLKVsKNQkEPb5VO2ZdtdRR8uSA+REhuukZ21h1+AmiLpy+r6ID +dM2cHfQwg1uO3CrVovoW9TdgQx3g7CD1pQN1/Y+VTMbzGZBZ5tDEYy7+RiqVIAeqwzFnLDzMc2JM +oXFENJCxzK+oDvA0ZMmJGdqaemVq0i1sCm0MCsZJI2RI2U9MKySFY9zZST/MzqBum+QfD8cmoaQC +aBKJYAT5GVwylOOACbhhhjVNjNNGw4eFPhlrJAV1H8hS1OBVDVOOeHWKgyUG9wzx1lsR5l2oG2i2 +GCRIg6RnxhVeNkVW4NCpEj96a9F82PADKo6Pefi7Vo2FaVsz9IzwAAvJcN7O7g0dqtQdrmzp7oVZ +ZC6PsoUxTmbNOQ2wrNMfAOmGCWMEXD9ri5Q/TQwuYtadOqbfaUIkw8HqPmDQqxx4FYQ53WeurTSy +yAtqyEzCuiK/RDSs1pRt6oCr/xwcvRt/WNatpn/ERCTvC1+27bxm4TqHtQqVWiVEQrdrS9ZAIOc1 +2L0NShnm9ZhqIvovC4ERrj/49rEUQo/5dS1alqe5XrlpZA38TD+5pGFap1Z6EAEf1jPRjNXTCqF6 +DmazAm6MLbYmvXRaH9TQrwHM1JlXVNSX2Fw1vE6o7BCii1P9WCqqNT4JIJwCdXLLcbA84rlVMyCe +4TFzBrJk1HVJJCjYVXn5tvLKtAzBoF2TCcRNEiSwOHmYWkCOOLLIFRzBsfFD9KhCb0k+hBJEhjEl +67TY8XVkTzBEko+gLEyN0gAgqcPxAakDuEIbnWISQwSNixSZztxm9AIhiHVLlGzbmn8pJ5SwawoB +bWpcBAHFk5EDq0KpEMkG7GlkwGpSaNoPa3p5IS+HbW1kNVtDVtPjK9lloBsia1cQ5GiSCfKN7DO/ +prxp4DPTNlBoGBBKyHVHyr00aryRaYaxZF7boAAVsiXRpAkCgfQoa4rKrufhS1m69V6Jx9xuR1m8 +Vp0fvUg/jXxstEpP4y0KDG7sy1ORJtdmyHZqbDROt6qtrjTJEg5m16jYxeOcno+GjnKaQAVuIKQz +9JY7DK2hUwITLvErTfTomJtBL5jknXaFI/9LtYSFNoN2wkZFSVOrCyNcMAN0TnD8pugj5CeERk3r +gpz0LKWvPToI7hmGdF7yiu0lfE+Suc/AEgUnHDf4HcpeyByorAt9CfCM3oO1By4cw+wop62mFKQO +wWpJsJtNpQ4Eg5nbmIhUsLoBLV3Dg80Yp+6BsnVk4CW05hirNHZIkUAFVH8YdWswetJdoXQhaJYN +o4oAkSoCdSwGqRVquuvLkW5hXKZO0Ds4sbZrSluZt1LddoyTo1ak8ob+8zB+uTpJrWU7r+EjuquV +8JuX7yuvN5OMyyGswbcIqig95CAWm9dfYbVLmFjJtLQMVftkurF4YZ7kahKRlUpTvjTVGOZwV8M4 +VWXwZGGuvjq0ypA2wVFOqWUPUgSjKhf7ybaqPaMuWbeYqdRBTF2qwLGy4kqlHAC810ItRG7Kdpb+ +OsziFHhzkBrV4C9Hry8atGv9hE6DqmuNSs+gWQ4LshRBeVjVhkhrdBKDVMgLsM5I1uhRIAgH/bPh +V4YeiJ6evVpOLTk+BqArOaSIQs8zVZt05pVG7/CczuOmcktwZIn1NvD4N0IFTz0DMMGrIQ88T3wy +IRWYAqdKC8FkEmrj6VAv025UTetBhmW1ZCu3wk60miVGiEHNzDsyVwGCqN4pNiqNm4AO6cEXQolf +TnNVghl1DWOvrAxoXdF1DR/p2WRd3ai3lnF2bVHZmSnPDPqmvMu8LustuG0FGsRpMeaTxZelq/M0 +zIer4U34smQEXmLqkWjVhYeOSRUZCxz5soM19BSxEnq+c9fDyx1ijJofSV7kNOYtuUEoR8VntW5F +fQvkYrg5Cb2oobClPsp71VNRJ6KRGY6+fK3uVKdv4LfpS7qIgjkx0YDFWGcHb8lSt2zUODeH0eEP +sEgEG8UhQNrK6FdOY0RKhJnQ+1dp0zGdYlXFJWdrWcsooCqC5z+oSF15KmOGE7cxs+Hp83ioseiH +sMsIMUImcFsLv62KNJkEadf50Cs5WiTXEoJh4e0FrwI4q4FKV041BuCjrI9CPw7IH2iM9jinIYr5 +NkbhTgrXDhwfdKVVDdNF4+uk42hBlRxkfdxTMafVIzUV2cpQ3LOlMesKCgGA0KtqOSrYjuZ2VyiE +YCmUiDQBlG0ZPp3TWLYqT0Eg4M1cNu6F+QzQdyYEKEx2QQy8bpvooV5VUWtZNTF2q1JfXZEeW3Wm +sHCdos94pc6xgOHo98hwY/UjaqDhxsyv9ZO6jSqHFuc1NiNTGpom+rLCtNWSGiA2nzpp+TQ6YDPc +JmjOOOVhSr2xDgSCDu5y2JCqWTjIt9EXXaRsuM2CYLQ0fCM1AnMwqxOypZrGEQAD4zHMFiW5DLoL +ltHYC49vUDJSnfEkbsxXMFdgqT6e+NNSSd+CEvlQeyRxA5cfYmxbtOrYpgSLXsfNHHOte83ZpMEF +QeTuQ2phgvBuUqVV2QR6YugIWidQV9b3lHY0EcFZsama5pAhV0c0FtSwL6pug9z7vLaPcEema5oy +ROWGd/cVBava0lNAUEbeq4wys98oLgWp3Yh87CdzFwvX6AmIB9NICGf10jLKQLPRRh4e8ge2OBTY +OF1ln9Cj2Pm4jwVLhCdQgx5OcEsHJYaIaNwgNyKu5aD4IM9QjiKwRm2qwgggagIXiqgagAw+1A7S +jkaR+BgtATkRf1tovRyDmXjw0/riKvAvDdOrw/2rZsxma0AO5AykYcPQ/gF642I8lBDAGhTElZpo +vDykRpMOe5Zu5Bovw/hZqneFmoFo0ZgCBRjUsULvxvO1MYfRViXDGyvmu5Q2Gw2xMWDXrLAzwtcj +YqANNiqlVZ8Bq2DJUAMvUtQK931ar45vjuSfvDlDMJnrzNW1Eg1ELEKluYLnnxBfOfKnhYUjgC0O +UpYV2q8Lc8R59DCDwFTm5fid1yz2vAfHgZgT0wRqlacFa4iIKQEB1EtHc7tL+SdgnqQsCJxvPp3L +WL4yT6LQaBGaPzdx/BMRi859PL+/pKVrTgx1oGNXB4KHFW3ZbYwTk4ON+TTST1Wst9GDgqCCpX1X +un9ODajMEGFNUg/EahAAAcNX2f9k+JKGukVI3+dYfDKIe/dxo8bsmDxRpCpmvQhxQkQ6kjmVQy2K +YMJQWwQC2klWRQpYsDF5ORDpQZ7dG1Eh8SG2Dk5a9rjLGGJofLQOjiz+gdKN0CbfBI2oH6ZVXNj0 +0dKmWZrSmdpO4vb7x1AfNnVNnSJSBpyBSvBG3QCZ9JqgJejEK6EXI9TGGTpm4dcTef5n+Tfc0+Tf +0PCUPoNr+UQBKsiOMQpQUdAnBKjg4L8vQCV7tw9Q2dkAlX1sSsp692yxKZ+Y+G4forIPUdmlEJXa +PhiiAlefUYQKQI8EqJhnDFAxcwJU6NY0iE/JB/aZwlPKeENoeuhCVMz8EBWbRY1c5bA8RMVMQlSq +1ThExZafKURFKxqEqFSrSYiKmYSo2EFF47F9phAVG6c8PXQhKp8ao9KMY1SaSYwKw64HMSoiwA5j +VGwziVER0CBGBbUMY1SaaYxK8wIxKja6RaeHLkal+pxBKuoVPYhR+WwRKsP4FLa0++EpKlbm4SmE +5OEpTAezLeEp7EwenpIG0IWn5CP6TOEpMYNIkR668JTqWcJTOOZheEo7CU9p14SntOPwFJ29bQ1P +aU2ivvqQwlNq8xnDU5BvfVvCU5j7/VWEpxBlHg5PaWaEp9gZ4SmRa+jCU8woPKVuP1OACpJGfWqA +Sh30oN/SCJVGYzZ4aceDESpVF+9h15RNESrNwxEqYV6zD0WoDEo+GKHycI/3ESovHaHSKKO2GxEq +UmZ5gErjHg1QAa+yD1DZB6jsA1Q2C1CRqRkGqEDLmQeolG09DVApNwxQgXfVIEDFLA9QaUcBKu0k +QKUNDweolJMAFbvlASpNF6ASYswGLweFp75upsUxKoPyKUolrI1SCUlWrc3cxlOciklxKnov67Qo +Q1XC/FCVUXEGqzQpVuUzeJDuY1Xuj1XB7vgssSo+XinYxapEnV4fq+I2iVUh3zCKVbHlJFalmcSq +uDWxKu0kViXMilUxj8eqDObxBWJVbFR4GE3Xuz5kxIYUMhLyWBWWiYEf94eqwJ6noSo2D1WpYqhK +2cxstw9VqWOoil0fXoNQFdyFsiZU5ZEex0iVeh+p8oyRKqUZxqqYR2NV/ChWxY9iVapJrIodxarU +j8eq8OKUpwlVaR6PVEkc17ZEqhgNVPEpUMVPQkZMm0JGTDsIVOkCP6ZFY5iKMFYxTCVSCIapCPnX +MJU1Bde12YepuBim4tcVZJhKGVKYStMMwlQe6Ow4SAUH1T5I5XMGqTTtEwapQH05DFKhn+KjQSpm +EqRSzQlSacMLBakMJnEbglRMF67hzOwgFd+sL70wSOXRtu8PUpkUnRWkcl+/90EqzxqkAkXiKEgF +zibDIBXzeJBKOQpSqdrlQSq4buSpg1T84iAVPwhSyefrBYJURC5sYpBKjBapUuBGeDRGRdY1Rn2U +Zlo4xajI1osxKrXpYlTKNsao+HmtdiEqJoaorCvGAJWwNj7l4a6m+JRmH5+ybfEp6sdzX3xK9vZT +4lOah+JTspf7+JRdjk+5D5VSfMpCZLo/PuU+dIrxKQsRah+fsjY+5W/ffz8IS/m8lw7pHakIJIAz +O13KepA/TKjhvGccbMtVhfIeHv4JcMZrNnGvX/9JM6yje47NqIWGIF4tyLQZWgeaHzSTAPHOQnSl ++yb1tatkPB5sr/VY9cOfT/7xp28Fo35zdnF7Jgts3/x29TUvwCmx6vIyW+gQsxBQejJq0IKPjKYK +IOgEICEcgZyOcDyNWq0cTEa0WdJ1pa312scWPkjRwxPDxAWCZdTgVCVMRMJN0TEfDQ== + + + lIaHUF0HNYtFUIEQHmQNOKHfjKHHNH1hKl4riBtWBV65gMfhEI4ng4KXPJeldtlAqc9u8q/gtwpu +Bb4RoVRR0vPqaLwJjeqjIgR35IUmdlphCU1ODmy6jbfB7YFstTEVfbVbzRg56s7xpIMnz3E1GRbH +rbzBJb6Gf+knBHClLm3bdenS9+ent2c/653SGkn02SkHlOwIg4Z8gZRPVwQFKMCpdKWiA0ZWOGGZ +aPeAvs1bxqtzbwP9oRaTnxWuLJNj+ZI7QuQeuji3vlRvDPr+iDBV1ZUC4Jq1gusA7lCg479p0Di/ +lUW5hFTmna9IQZraUFqSgZfUpLBNXj2Gay/hFt9EumT1WgaKQXJ2XTIWgRIQLliDYIabfcv4zIyK +sM+AQraH3Hhn09m5JJZOok/a++NQPsb/sHSUxmcsHqJGJsuiwMULg3N/sjQAbrA4Umy6PALcZIGk +2HSJAFy8SGtmCzXhwPgHJ54r8tWbfk2WrgVUbJaa3gC7NtcC3ozQADiUKRGahC+hbytpKvA2NAqE +9yQ4UojXTYgfjqq8F/iO5CV1/B/5pTQhCitPctl8CxnbEKFq2MBouVVP+wQyXjWiAFhgIZQlLY8B +aDwa3Dxqw6Elhwozp8Mk8OJYwxOeIixuaYeilkrByujJwCxdOIOgw8UttzAIwx0ILp/oGhUuLrmA +wqusqusO4pHE1HIZhL8PvBiz5oWdXsRB1ZA6zVKXLqvlNbmGiTFN64JGQHk6qPAW8YahcDIa7hFg +ZVsiRkyEA1UYy6Qg7+V43lIAXoKTk5Lvrg4QwUflbAIJ9lTex8z5InJx2zSqtMZ9pkHvcsXsMOeo +8N4ap1PzvlC9/lFzGsLOrHnpMVdazundq3DdbRkZKbvJ19jeetEvvHXgwCFik4MW5PgAPjsa8OHg +IgcOhKrnJjqkp4VIz7z2nL8SBNY16OPVm9wwdLnUy3AtfXKOYXZT/8IGUT41E8TEa3CMKq1l/0SX +5eqwqksWsvTVo2pNY1TVBREaK49ctLwPU+9fJ4Hk7erxrhOAGqfXa5YmKMvqaF4UJPTO9ksyXrXj +yTo+fF8knENlSYxtZ2o0nvue96YV5sw3OAMa3PPeAlnggIDLcreQH7o7vV0VKxH5fv1tZIjiHa4z +yVoJ1JBtrRISnKR4ePIu6ZODuOeDOoGWBMHEaCve8isiQBVZ9JL+YsBZb0ipS8rAdVvjYc37NdVM +G5t0qO/unABrxFfLtjY1Tm0oSz3c6aDBqasW2q+x1sviWmJ1Gi7ib+glEYksnDntmGU9CA+LwdWy +P2lLcNBSQqXsSoeIFihJhLBCgVjFy58rYQQaEEoRCkWEj7HVEI6g7746gF9/q+GgjhrtEwE1FX0E ++9upm8iDAFTq9Flel0WjXd3CCs8Zdbg9Cr4ZluUYoASzMYwcvE4WXn+GYXZw6vFKBlTXDh/QwJtj +fU1NN9YDohgXAlGmTaVX8E7eF5NKimlDxbQ3xbTLxZqBFWvGX6yZpmLNbGazfdJHg8MvApEJV6jb +G0bENPSfYXuaiFfOzprVGgzDMYz5hPsmpQG1vJS4pPO0VaI6fjkoO6x3TctZ10YPsyO/NeR7MMav +3qxpSmjkoDdCt/KuyuN4KKi1H6ly1uMvilElxbiRdfM96O7JwTC02zeR0QOhk1NfkEMICYKw25hF +QrYdVLQ1XVsSpjFspo3MwgmkKI3Hwa3xsO5gHNbTb9FpyB8NPU2I9kiYuY6p5GYcCPUa1nHVDJ1L +CiSiD4zKrxni7jun/ZMDOPGBDBX0si91D0GLQNPnCeS8WmOS+w8Q4EZVTF8Ngu005LNvjHpMXFGV +9YnRSwg5kAVhJNLJdKZOHlB2Y8jCaPFuwqKp4falTsdwKpzQTYQmNyDmHowa2D+PxCU14zVDU0Ut +MSJPBQvA5iqD/AOiaYVhYfZj+K0hYmVd0TqoQiXYJhqBjs42bvVobquwKjVqx6qh1xqqte/jRdJJ +X67Obq7e33y8frv68PPp+/PV1c3b/Jh/WC2+Bq9V0T3CbAWOcJsi6CbYrZr3EX6DWEwwXMTHCY5/ +9WYNlnMr93hOkXmC6QKd4jpJwwTbo95+hO86DSOMXzOLJ/fr4xcsXaYeN8/DmT4xA9nnifr4qexj +ez//6B7iH+nPu4Z/rCL/OHr/KP/oOv6x3ZiBNGoybSEIgqkzjTWBDKSXvbQmPw/VTD4lb4gPMRK+ +NUgL1TqIonl+ns+UnWfAQVq6uAw5SEsPowEHaSO3tJyDdOTZ4IB1LwfpPwcH6WdxkHlvlnCQo/EX +a6apWDOb8zjItl3IQbqHOEi3gIMctryUg3yIYRzWPI9hdI8yjG4ThnHclQcYxrocM4zYSBsxjIhk +eSqGsW7Nwwyj2uPbppnFOA6rW8Y42gnjmM/YZ2Yc4aqrLFy7lHHEviQL52fxjabnGzdo9Ghmoy/O +Ng6xezHbuBzHl7KNQ9S8h21ci+0Pso/japezj3YN+zjE/OdkH5czcxdnv5yDn/vb+dtNmDnY0xr1 +IIcVGsk7FVLEvwmcnstoE+Q33cvpV+nX2cH43bhwVnH8CT/zAHiNMDSYMoATzmgYvCBBWQZ4awqP +V9YlvwwIdTpBch/jHTOYBK86t0p4hK6J+OO4H/ksptAYkjnbegTSgHcpK1iVSro2gBpM6FwNrEqX +S6eHgtwgkQ3JtTX5yUS1WFeVUBjoMWXYnd+VM/kPZ0XGaTm+EDRMitrFlLgRVlHN3FiVdUgA/X+R +oPpYqt+rzjtTBSD/SwkzqIboMTWCY1qu1tAEYOgbYbhECMTCxJsaBzTTHZQV+VrE46Qm9K8me8za +jv0adbOksWbY12LyTZHq7PM72ojIKY2k/pcDtGqmea8ZOJRe8p2DmaikHE0HY3j+GdjzHPwleEug +3hmKZ8esjIA0mkOHEMOYfKvPRp8b1z1yqpkltmbeKJAizpnxQHQ6HTumoGKAduxxPgr+ZTifXemY +j+PYN1EQOhvPi4cnTU3MD0zbGa3JSyYOmW4XTt1Xb6aTdy/swSlFdx+e1El2yTbjKPd0cxbdRBSl +shE8p5EXjIHFJWVbY9bYY3zQRLEkm+mhIF8lZNEpb1Y3ypuN0t16V9Lk34q03fCHCRUzaQkrqkRS +mDSgRYlAeMSllAiNQrjSnmzuyeaebH5+stkMBHFsCfBEIn+Elm5ECZTdcgUmH5obdJD6MF/x4wQ4 +E0HZaPRwhCA9IIQGeOEgcIRZcxiUHA6ZBRISoCY+K+hsE1ow/cwjgDqqVS948FHjkxypFgH4Px1U +cjAAiazjt7F6jxwMyW1rmNih0uRzDh6wDpmcaPXUrMCag8nFeMk4EagknSODuXooUAGk1clcgyMt +Kot7JhH1BO+2Nayp8yLqUTeGdOIIhqxAEozKx0g2yOBfq9deBltH/xQRwWsksONVUkgBDR+hNUWt +rzR1ncjhyFugF91s2OjRzEZlcWGLh/RuGdK5ICBhDV72wEWYCcF2MW5+9WYpdirlmYufOpalGBrd +9hbi6Gj3mwHTNFiDdNZq0kk9FRt1bmxADeEFCX0r5oSejQZHfFnzJIJsJAd6S4dIaqys/Pa+GYDw +lUeipKZmRqIWSU+k6joCkA3XMaeCi7l0oUm2eiNs0Mzm7WGXupRJn5hmhaHLQVM2MjcLPawAokr7 +BKAYhY2vHLW2rfrQ0e1P2TLmr66pVjbpObJzvFRUNjCipclXtHBP45W+mHRXgnA3jJ3m2VgazdDM +pGQnB3SCDeA9gldLCaLbeEbQPfCEvAhcC8mLNMqLaB5cQHAGAWIZ3Y3+2AA8rEu6543Zk/TrXjWh +r+mXI5W1TPheB1kahlS15ToSBQyreabCc4cJUBwC43iTFmJ0Ve3mNHVZQN4jJoH8gTlBRWjWTRlg +CFxbtKpxSTOSsAm55I45Otu41aO5rTpkB0XCJxN4GdiARplhUtk1zEfaMuq7vHDTgApMtg02+WTj +ALh86whjssnm+erNmu1D4HgDCXD+FlJeZskmYonRNhLYeCOR/xpuJYDGm4mw0XYCbOaG6ld7bNlo +7H0kdczQMQkxnTnreGMCnyv4t+ptAXyG9TSQxWPKGGwITlrJGPm6Qmo6qIC5/E/FyI8gD1KRUnYV +BETDzHhwdUVGzXU6OCJGiRwGsk+RGdbJgcbQ9kCPbF7e0xiIlQZ5UptWM88iiQwifXhpO3BnXKy2 +tAxKsQoBRCVzMG7S2tGc1gJzfDJ/i0VCnmVkY4oWCluEGLybYylqPKmoMtgTbtmeGNaFTCCV6keY +csTDRIQrNxt6yD8Nzt+D4c4SwysL9QA0ILXmIAb9LGmLmShM5MhiylH64cVYhMqAp0MMAo0xZI6Z +do3R8q6VUf7/7L13fipJ0gC4F+AOyCBAuPJVIAnhQRKyIG9xkhBWmO7p+WN/e4E9zl5jr7HX2DTl +fQFvWv2ab755g6qyIjMjI8NlRAaWlIBBJRE75VFiidmnLC9eTEZB/ZfH1EfCOyHQZZSAuSXFaH9j +ryxmsuiSQnjhuygpXfQKhayAL0ml8Lm7muZdE7mearyv9cqIWEOwzCoPgeqNJqAFbek392dAHAtr +G1Dosg4CujU48bILGFZBwotqq6pHLL55Cl4mjYpqiV/Bi69xA/w30NH1j+AZte6rmAFuzNA5vK5Y +O8KqfsiWuymJdxOZJGEwjz9JoCgblChqlBVy2jzN4xAiWHQN3f0gvuGQaUvj8SENDoyYVBL24bfw +fBmmmDh8C7YjAyw+bbq+x35z3vul0B20QP9U9tIc3jyMDkUVAoihW355fAU6itOtqp8x+NLiGAdT +4nlcFYWgYDCmsuTik7zP8Aisnv47BBq1EUErD8T+8z40SFsa+Plkq8e0tZ6TxHdPoKsnCJQLaEev +MKuZcSQbHjlFtNQKoTt+CWQQYvFaYvXSac5zpxTMiaJJwZOmY6Rk+MxIy5qnnqg58GpCz4HXhSga +fKanafBITzPgkZGu1Q9dUzaMozDQNkTFQtSNcagfq5HCtXKPJVUl2lTiCVqs8JZoGIk3gHtd7k7c +24yCT3SJPUfii/bRNVKa6fLGjczL+0/3VcwAN6btm0FXFKhHV/Vp/7L1ycJK7dAFB++QoWAeJlSX +rTYyvjKTINCdvvBePd3mIAkB70OBQt48mlJvZpxfiq4psP+W5XA9AtVuXqDnnPeeySQQelCFVba0 +ao04ccfqnyBxgZdGfAL9Kklc3IwGFpVfWTEo6hkOC4sfRkDqIXI4Xk83jZh+ngbk5FdLbOiiTMFx +xeHlFLACgZbW0P2vHOX4NWT2sGijlto8dp1bqGuYng9EiHMk3iLqNrWcuk3q1W1OMOgtnKDj7kjA +qLg7Jxj0FtUjSW9RfRUzwI0ZOpf0FlKvapHu1O0YdBwKJAqIx1dnkTD70U5/iQEzkWHRdQtIJ6A5 +7YpC9YOGliBNK1U+VF9DryFDOX4tUNg1qr0iy2vfuUX6hjo7wXO8Vu9WVoyTGB+P/w== + + + wjqyWLfSL6kJ6EYgeIk6UiYYFIFKIrdq3qfRL6CBW/VpdBBomGq0FImIeEH+W0NEgorloRtypEcx +A9yYofO8aC6oxyipv+qJIOCsgKepwYcDr6PhhbCsTGLAck/akBh2GBP4MmqaMWEavIrl8NBw13E7 +BtZDox2/hheliSePS/SdW6hvmMkO6xZ5OPXUEqCo28okiNVaL0SI1Fc9GaofuiZEzeAkUoTq5ULE +KOn7WnKUtFW3BKkLB+OtXI4YKmmwpwUTe1owWCCCwQKRcKCyp9WPRHua01sfnAq08kBrT9sy+Z8v +l/SY/hX2tJalYwMVjMuFPW35pbM97dSptT1t9eUS9jRpYk9raVnz1BM1izxHS8+iPe2VokV7mjTa +06TRntbStfqha8rW8Ci9Pe2ZuiV7mjSxp0kne3pBxZaFf76ejYYXk+5w1h1+xGL4MVJ31S98Z2P4 +RsBvLvpz8O9586vTmvnwBZP+3GQ+/fSfNoaNj84EqMbtziRs/86PX+Yb/X4X7NTxZ7cltqyPRv0E +ULHHs7j//I8G+G1sCtQAAELdnrVtb9IUgSj1GzPH9jRqfwXTO7RtEQiTD3irD4xt8URI1vgFWNDz +4UVj9qkBnf9sTFojZZKgFQJh0rTe+c/MX+j+0QUItwdaRyAa484EsM3abDLqdcDA4njNAZFoVnzF +lGOBGEAhaqTAPyGW4P8TBP4v+ksMQbYb7UKdK+SHuqbgfzg/KnKBuyV/Sbe0bso0+I80YdV/Vt4v +RjXcDahb1s9KEjP5qzuVcQw7JVGHgBf6aYxk8hf0y+uQzPt5r0he5Q4w25NgXNJOR8SY8EtaDW4D +mvuphF/6D8RUwo/QRcYpWbNZFHUWI6prOIRuXBRhPpxfNhgVd7NCEbw1wc8p44IRNyTPwRgimB+J +bmOCcZk84n/QbECjJtyO2jMVJPEb6SrmqS9xMhz9OUR/AJmN5HrYnzgD0/BHfYkskOd/dKS3ibyY +Y1jq9sHMYHtAI92hHzfAT7GmmxCbRIGykLjpTrvNPgJohFCbNVq9pSB4HUOuMe22lM/xImOS8p+/ +v087QKCR1t+LHxz1+3N0GcZoEm+MxwBpeHHARx0RfSENUH8VoNJffH8Hawda17szBI5C/fTPJ2Jj +MEC7W7pDR8NpF6Z2ynfZFbrTcb/xF/4TpnwmMCRx1cBErnyA2HiCRJW0BJj4h65y4BmB0+T0CVIq +H8ztE1AlNJKGCYB3WXP3ImhgdDCSWI1PFDrv/j2/zx9SDSeMkYlvKMHPMXKkWUV9e340f/+eD2C0 +MZmZrFiu3xm2PSy4HT4TCJiCK3dOVGVyyucWg7eZR340bM+7MzdzUENZ+Q6A9LcidMrXz1xPO8U/ +OsPzdhuRJOxCQbKn217EAhOqVC/TWhPIxoZ1WZCHCl28B4P0aFi8luIsyk0o6ygP8Denwd9nSr5E +8T+d1hwOAb1A35rJM3h/G7cWar+ZUHPLP9bCaC2MVi6MzCQQPhki4SEIOnzkeFjkENaawLc9ryXQ +3yiBqL9dAvFrCfSbSaCrJW9htjCqTKhybVKtpdj/3qTyfJf5WqD9w6fkSaAJa4H2Gwo0TqAFlF1H +gf9loQ8wKbA0vvuVZeBdCvCGANGDzeK7awiYNwILzln7Cam1o3At1X6EVEsK+Co9huLRHZMsrHSD +olBgDnVy7Sn8l4u15Fqs/WZibe0pXEujn+YpJETxshY2/2ZhA8Mn18JmLWzWwmYtbH6VsHGTe7AW +Ov+7KRmSHv4GsUP/bLHzrxMa0PFG8QQsm4tuyEPnRSTPMIwmPo/nKZbBNaUJGnnieBjNx/6so6QF +Ofbvwm9JAV86TsAyIOiuScx5WdakeJdHxvv78GBP7IpZs6sfx66Wqh63Zlc/hl2JdyYQtEDDYx/E +reCVoxxjdn3Hml+54Vfsml/9OH61Vq9+D34lqVfwfn9SUa9oHhX9W/OrRfjVDw+O/9fxq5/iQ/zn +shqFqVv+wP9BZZc88aU1N3HgJj880Plfx03W1tqPYEmrjmMicXguYGVJAdW2Y/kkQ+CSoISQXEHK +47+Uf63jWtcc0B0HXKe/r492f5g0SDI4DYnieXixILqJN0mxJpdTrs98/+FT8iTU1lGtv5tQ+ylO +gn/YrllLo1+b/04JNM2gMrDwPnkBKFaoDB6zDnX9d+e/c8TPlkD/Ovmxdgv9M1mvkyFAYzuA5GHJ +MVjagyKxU4ihGG4dgrQg91oH6v9u/G+tP6/15x+oP9NUkoe59f4YzwGZC4Ma4jzB0CbVhdf6879J +f6bWEug3k0DrY4kfwU/WguwXH0ugUjEkwzDo6hgSlplB9ggp8MvbI78LFf4+U/Ik1X54Jtpaqq3t +qrU4+ueII5vbNsQ4cUpY38T7L7ekfng64Vrm/BhLan0V71pw/Rw7CryPMwygZmw/cRTFre/y+Jfb +Tz881XQty9b201oM/XPEkJX9FKc4AihYful+AJZjaXZtSP3LDakfnum3Fj5r4bMWPv944QODIoAF +z7F+2YnHJpPrjJZ/ufD54Wma/zrRAX1wAssTAjzm5ViBJ2H8KUcQPPK9cQJPoWLXBLxSBz4hleIh +DE/8uCLD/6KQYtPiTziOmBMIHI2GrwWjGIZY3uf0+zBhTxxrnYP3O/I8jmVJhkMXi/GwVrrZlTM0 +LKiexHwRV1gXUBHAdcGktd7997N/p7MHksSZfUmGIQX4iyFYlsFJJWSS4dahyf9uwcb/8NS+tWBb +7ECdoYkkFFpJVuB49IMUWAZq9QRDYzHGCwxNwh8k1OUpRatfC7a1YPvpgo0TbxKlk1wS3aDFCCRF +oE7iAkOS6wq3/3K5tk76/N3k2vp8Yy2OfpSbDZ9vMDRQotHpOkvFCYoAFlWcIpPU2rL6dx9y8Ouk +z7UEWkugtQT6hRKI4eBBDykQZBKVU+CEOJkU4AFdklgLoL9XAJF/f61Afp2huRZBaxG0FkG/XAQR +JMfTcOkoPs7wAomKJhLr06W1CPrhCZtrAbKuT/R3sE2aQmyTpQQBxcYyHLxnBdWtg2F4zDpOazF2 +s86p+90YFopNpXgaJX8zBAP1jDjMAUdBWVKYFkoMB1YwFHk8jtj6YTGp/7Bdt9aY/xfhWdz6iq0f +rD///eLsh1f3XIuz9XUn/6Ctt5Zp/6NL7GFklsCwgJJh7DFLMFLEMUmv4Br734UKf58peZJpPzzz +/F8pkdbJf/9IVmyT/McLJAs9Szj3DxgVxLp+yIIM65dmK5uymysI058fTYadyXRV7EYHVGYxtmsB ++M9VpwFoF5LXfGq1BVfOdkV25/p7j3zyF7nFf1/utCB+1hxFy1Emk8Zf/spo0v3vaDgD2+opxFP+ +8ewp/I/Sidab89++ObHUqU8aw+n7aDJYlYhSAXQnnmT8zKQvLxozMIYhklSEJLwGoz86N68XM+kp +/mbSee8DbftO+7AxbI8G3f92zJrew4eMP3EE9KzQuDu8GHWHM/gsKT4bzgf50bjbQR3xlLr/iqp/ +UaSOZo1Z5/UKSNYGHjBJyC+nrUYfjrkzaXVwH/Jg0Ktqd9gxBVfofEw6+BWpA1ZqtAD2zTqqqDsi +da+Uz34/Y9wV2y4DhA7VbLssKtsqrl3rDsZ9mWt7UeexHo/7UADD79CNSRZau2gEgJkAErQe+tEQ +aHv+cn/0p58FgmYtZtZi5h8nZhQatpczhcloXPtstEd/xhtdcwGjBuXaAEKcvdkfIpwQcZ6V+ONo +3GjBZ/KDZn8+MTftTS4W0f/A/7lrePUDKJj+aPUnIgNHY/6Y/TX+F7Pti+6w5891/uj0/8UGPPu/ +MuB/ESZF7yhQ6z5XhUcNSG9c4Gs4QzuKl1nA+3QmKoWiqtfvDlzuub/DxahwHY6lCXzkSCV5NReC +ufSip5fjGXY5lvRzznJ+SUKg5TzWusv6qBTp9dBOa0zUin2coOBVY36SZuGmo2G+MM+u/k5UzBBL +8//+9y//aWPaWxX7LHUA44T4dsc6SdnSvLKVQP9sheQXUvpaDv7YrQxtdAbtYsrSUF/IEPp9NoYr +TR1bbWvnxFrA/xTt+Bda6YvJcejc8Ev7ZEkviAaWSzNSluLtxqSndjK0phPkBKHiJCe1+aMzkTzJ +GPHjRhd5JmLqVp+jyX8t1oFiGRj8SAkcDobEKwD/6i2O+KnOPWLn0uGAEaT36qxZtoplP4KnjXl/ +9mzvA/e2o1AoEow8YtGqJzl0hyEvJOGVpfJMvUTAmjvJA9mj5Gtx2M5OZmi0U/iEhU9ez0bDiwlo +3R1+xGL4ca4D9s9Fo9+ZzTqIw1403Ywz9HgFPkRKGMDkcxgt1t1/ffrnvouWNzyFbj+7s474nTO6 +GpAAgazTd5RkOJaGkcVJmidpWuMCEL+7Kuf8V5229GWSTiY1lyQnaYaC6QrqISpf3nf60NGKP+ZY +nie1bgY5d0f9EToHEb9heSLJ8OoOSZphKUb7LSl/m/+rIX0qCDTyavA8QcLbmYxoxcshfpnrzyWE +0uD/SAHhkaCTlOlCqD89bXwAZbAhfk3yFI+RypBJAa0Ly+IfBMcJCH08y2G+pgTS8RzDiyAPYAB4 ++YBO+nMHDGtcNJLGyy0I8IoP9IqheHTBu3SNJwwVRxd7MiSALIKlaB6ApQQAlub0YHkOYDaJwALO +q11jhgXwYG6KPFoNWPCofJAkTMGyJEtS+PZRkklqliHJwWu0YRs8dwAWYUEGC0dLgn8BXEIPl+YZ +lofgBDLJafLA4knpVlMuiW9FiVM0QBktwWXhcOHwcwdsUoLLUzSlGZ3A8ixDaeFCpxiiefh/yrWp +ElwKYpdG6KVFuAAqoRkcxC7HaTvCyBV4UchpoZJozQDFq6CyFK9jEAKXxLhUEM8kCZxMKiKXwvkE +IoUxBERCEg6Wk8ACwtXtFIEFm0gzWoqCRADhSiRGYSxjuCxaMwHYPgc8I21EmkPpC2BeNMKfkCQp +Dm/hJI0uToM0IAl8HqY7iODQIBm4Upy0UgJPC2iQNNgFcGigex65MSmaoAWcCMgQPM6vgHmAAqeG +RkBMstKu4hmORvkXilOUZ3lGM2VSWm55yng/YKCA+UkzJkkZLEQkmiFgJCgjkaEpllNxWDhKDt8i +D34YRsnBvU+yvASPEHhENWDdCN6UmQGtCk4azQBhENIa6IAVwTKY6uE4KUrapoD2KBiYD7Ypg9Fv +wiTjDAP3D0QADVaJVY+TpOE4BUGElwQ/8eVDJFhbxnycElMlk2B1eGXtxXFyAC6Dps9Iw0xyJEEh +eQYrgAs0/prmCIQSOT1G2kA0BixuILR/IHMCQ5LQSXM0kiFJwKoJ80v/GYUpwzQdxKrEvUPAjQ4W +Dg6RlbckICQEkWUJ1hSiwuYkNsriJZO2JC8xfZKRtiQN+sXFkuKAulm0owmAALzQYN+J24cW47Ax +JFYAkOCUkxIckgAMgsNMFwV3A9lE83jBIcuCuxTxSDUaxbugRT5ESXhMGphxkkwyeA== + + + UQBaeS0zlkUS5u2gZ+lEQZZINFodipR4JgfYHYVmTBGI7oDSQbAaapIlM4dzosAPWXYmEaELaANJ +82dowHsERMscYPXwRxLwTCyUmSTqDqKHFbkQgys9SPiE4hhmZcI9Lu1JWEIRrQcL+RvaRDyDmQkF +l42UGQVcRlF00GrBCe8oBoITrrggQQUUwZBwJIC4EWsgADFzmIFwSImgZUYprhOFWT2GKcChol3O +SaRJsQJFoikTHODFcKBJAeGAIAEhCWohwcHhwV4YSrVMUE4ABLAc2kUSJ6ZZUkxiAwqWmCfA82hH +0ngzcOL0GcyI5EoaIlQObnUSiTaBkoAmORbtZtCORdD5JI8GDWiCRtOQJBstyXlRJqklGxJsMvsE +X+L1gJtJ4DB/4ngGAxEQc2ek2h6URFGkdq0gpSKlQVZyGMAOEU/nkjTQ+vxY30mK+okkdsVNCvaV +gtAknDlGp4RNBmjvBFbE4M3tcIyAp6A9C3RzvM7iCOXb2gnMmDFMhE0a8WO8kwyJWrXR+8yPDAH/ +TfdjCI2ZsNjAynVp+o0IHEAsNdod/2zkx+aIEyxtawWKqVfVBo6+vQLJLITKBpCuuSnSoF3gRwF6 +ffeATT+C4EO173lj0pn6s8OPPjCrNGDwfx5VMJ/9Y8MniFzg4mM+Bc3Mi+xZ/fys6Ac8lPXnIdD/ ++PQPpc9wZ8pbAMbwBXomfUBxiLDB/6hAmnUj9wK2KseRGrHKA8rVCloBiRekpYhHzTS+vUGSNzTS +e6GUBUxFkg0ER5CIPQBNUqDMjeWkyCB5kU8IKm0NMAKk9yI1iFTBlfVboLchQcECnqUdMbB8Cdnk +IDBfQ0OX9H8GSUgkwAF7lUAzPEXRGBDPMObKBisJCgGzXSin1aoBDWUaRaJRgyUn5cXB9ohmQQFD +MKwNeiappkke9UAJQLJYqXyyOi4oqqkEjUrKS03CLdf4C8W3XHy49UVg3REKfVkh4xish/IkUJyR ++OM4oMSjAQBdmkVSRbzcQ/9DRD9cWAqyVFm75YFagjPZGJomsDRlCCyqgV2DtBFK/q9owEA1mYWI +ZqUF5MAA0LqxwHZDfBcsF2DOiMuT2JqjpTHpf2CoPBIePKJlCSrQ15GqzFIk3ggMsLbQmIC4JbGO +Iv9XrXnCf6EclkQmGA1aRwaoNIjQgAIBdgdSbUR5Lw1K/0MESyHxjhwD4F+JbjkW30dB8Ei600BC +cphMAEYYUWHi1KoX1pNYWqN60QygMwEpLGD3IqOMJVm1KQTMG+neFt0PES6PVTq0s3hJYFLQFYWs +cJ7jk9iHQuIOFCYj/1ckEgLvUahygH8l5ZgEWgH6TmCT2JcgAO1Lq8dKI9P/kPgKgYx/SNSU4q1g +BdyWYCgCa1zAftM6BJIil9L+r+QCQUo3Q6F9T0lb7rbT9OdH/REUgaP5WN58sJYZif0dHCOYW1+U +dKuAbHxqOA1Hy9Ynpdg2PNDEtHjl8JIq1pKkjPKSpkuJJdJECsPWA9JLeT3PZSkKa+DAtGN5jTPR +0jnEsjbOoaSohAkEIAhKCw+YrIC3wR9qKx7Do+C8acP4PMVJKYOj0D7gZc1WslMByxBwFi3YEVrn +Jo9VTpFo1V4rUkgqlEtimBc52Wkt+aYVb7Xaje07G2OHN3ojubyr3elM7cW3i3KXD2g1MZXG4HLb +BCeD0x2NwNHvbjITksCvan8NmqM+BPN/+EKV0QBolaFKpz8G/5NrTHsdNHCgK7Y+w1D9/AOMCmqe +oataDTaZ9wHW/DH/Vffjc6Z+UBj9OVT/Xe28a95fj9V/5YB2/Gdj0lY/K40m4qPzSRP8fT5pDD9g +17UZUF1Vf+fms9loCIjJ+IxSP6s3mtpG8IGmBe4I+7HB9NsfHfQBXC/5geYD/IgGj0SXOxhct9Xr +wPEhn780WCjjwyLewUqpsW69eiK1FUat+QCQUKExa/gCrwnpb38K/aU654J/351Wz0btjunLPX/o +P4P+ELyONWazSbc5n+EkF9AUU93/AsQK4KtatT67/fYE4B61kWJrpLfwn9lf4w5+G9oZTl//aEym +e6rkfnXTPxpw7XFb+Hxq0Q6mi+Nm4kimmr/+odgZjoYdF4jpjwCFt91gRmoZ/Xvn1ewO22CgpIu5 +AeKodWZnaBLO81O3XtHyL4kJ0hYTrubfbTT7HTeE77iq/6SNnvrD9VaHTf9miobTa82ns9Hg7+Vk +v44OU9MGjIOAMg9sMbfk+Mv3RQ3eXPNjhvI77NLp+58/WBr/zdtg2u+2/um8OCaQSmiY5fK6Wtq/ +m+/CqXBOU/nLzVT++runQnK0QDtN5c9uG4W1O05HbPgPmNJnB1mqLuYktfybJyVFf1pNqDkClu4A +mtfnky6wFt1MzfjNDxD5iNfVRvNJq5ODQdArYXv/aIOMMHmrxtisMfnozIAeAF0G06OCm6U3fvM3 +q7IXZ2WKKY0mg4bVrlRP+b3b79g21kxW3fofb54TTpzgHQVCu7PMlbZ/7/I7Tqo7BOPsN1rupqVu +/cP5NrpsZ9wA4FquNAZt+795026V0P+52LADeJUQOmpxM0l16x9OmMPRqaepadv/AHnrzHj/Zyat +Vij93aMZjWfdQfe/KLPgp4wJWMl/9xAGnVmj3Zg1lh1HcslxbLXF8w83u07VGH38eNppd+cD/1Vn +OurPxZwSGUz2iCT98vEKWPv52F/qw20Lz+guJh2Y6qu4ezmWpVlxNtmjpL8xmTVHjUnb30JHy6S/ +KY9aZieoC2lQ/i4YRWPWAQ07yEVt27g3HLV6o/nM/4HPrNGiKjllcASnnemn/6oxBVJQJGDVTPEX +LMVQgvWgKf8HOsly11bWIGhCM47z+WwMBmo/EkoFWS3dwAi6bf9UvD7OxSgUNDuuiGpyjm3lyZGa +9UBkMPmj4693/jPzF9vdWaPZ7XdnolQmGRmmkZiqjeHHvPHR8V+MxtIS6sUaL+GlPe7GcRMJJBjZ +REciA3QpgeZRo9+d6h5NxyNxB9Cy/2LcaLflfZI98mfns5G8YkayTfrHjTHYBdPuYN5vKKsor3uu +3+m0oU15o2xW0hK/WgsnPxmNs5NOA6csG2RgSIntI9FRP0GIZ/7gB00ZfxHxMPoM/Z+ywcXJyr3B +DjS+A3Gw0qrlG8M/GtOajA41IRD+d5kzgE3Z7w47/ilKFJ7aNx5L9DP6ozMZwwPfqXaVIbJErgMH +fTlvQOryV/ElTHoGYTaOGaBM3JJXKFzTcoLWOfZHB95K6G82+o1hy2GSrX53DNYOeuX/A/bGB6AA +ceAhkomD5VAx0l72qDTv9yU83nQmUyhMZxNDF7XSrT8PIddH/qxIIeb7Qv83oQVSqZ9W/dfTjv9o +ADdYdoqCCiCrHLb1xCi3V5qI4UA1eP2jRBI8D6tgOX+ll1zmTfG48EUR8q4za6joHGZoYIzjkT7w +18bA9JlMAbpn3Vajrycryw+UWBMDfRm/ATjO12ra/WsKGyWFqs1v0g7s0bDVn7eBfjyAFKNnYGZf +lEfwun+YMw/YUbPfcTEkPN3iYDz7K9/p96eWhCF/Ui/cQt9mReUMtOsBLfJpY1yXFRrKRevqqKXi +qPoV1++W0fgvA23rECUi0393emEOU9ceJR9jTPpPcfK2oV91m+th9z+mHasb3XaH7dGfUx21q1p0 +1XJTP8KkBm+1xh9wa8EEfAXCaAgpxa/hz66+8cPl8RPiAhGeviLNltXpI0ocn9tJ4a9oUVHx9BEj +jo/x9BW70FfcQl/x4lfeUCjo6MiGIswJSodG6G12oifC3Sd4gOZLbP/NE0FI9CR4/I4yx73jd/SC +31nQleN3rH7dLBFvynUUiV6bN99H/XZnInkG4dNpWC92dY1V5pqWOxTmYzASaHwpY8l1PgFVqfwz +uClqINKbVjjvmfJ13Tu1DaB6r+Ocxf+MR5MZVIPU0lWlWufQoY1KuTYoSBqnUa3TrzRmoG8oXPpw +elOVvmvR9gj6T48K6pbq13UYdwB7NRsfCgFVDU/7tj4aq97J58Hl/ggon1ed8bw/lQXgHnwrX9ah +m6j+Lg9FwandlJHOYZS94E1x2BqZWNjgDTTjzoeKXqZ+h66NQbiDmoNoQSlAgSnY6irjJpU3JaBN +1Y3OYAgSmFknncnQbCBAt5bVT/XYB02AXqSxm3YEiH2KScuwhZL+4UgxNPzdIdLgR9Ou1I2zR4Ty +A+PQxguithdQW6TO50VD4UptKKitEdQUTypxg82QnMYMUXs2cGspltrfAFoydnXoXAoaNwT+CKa6 +QcsCfYRMdv1HbpxCxYuaWxzgxtZIMLY9F822mtp8VOMKN7NBlnbeuLnzxLUoxl8549hhN8rh8P7b +TjNx0213RonTEdD0OhCpQHEE+7Aj4TahOL4TrVEflgcAkI0sW91uOuvH27gLRNSyQLAHDz8T2yse +QjffjNsD8Lo/dD2ocds1cBzDJ39BytclqRuOx5M4EnbxPgyid9VyNhK9SyzP27ecKIaNQJD2bXHc +gI69a9YQtv1zJFZ4s2/2qWtmwOnXqAlwOu1+DBtGp6G+IVraphg3YAcRNRzBk2EX7RrTZnc2aIzt +m+I2E90+MWvd6k/irdEQXu0FXXI2Q4UtZb7dRFcP4fnzpq0n7Tiw4eEdOg4DAA3fAWuSrg1Doti0 +FRISRi+fodc/4IHrOP7pst0f1mMbfwx68c4Q6hjudhD6AG8hZT3dfAMWbQYvbBPHEqdYU7qHTcGm +hrxZFeBkOfQx2CLd4fvIodlEdXGVQ1PkKW02JlMb5KKGTahigf2k4hAuGstMwkXbicb/4dRazSg4 +y+aDxqQ31Y7aRWN51C7aqkbtorV61GZMXjvH+bQDVGKk3Nrs4/fhLN7ujyfvo6Hddh9P41AxAzxk +ak8W0zjgmdApOwRNVcLf0PI/4/hEz5KQwDdr+eGGeYF2Iu9S/MtmaFLaYX+4NcRJezLV7nhTAYSa +SY7o6dS659YgLnnXW4O/ejZsUGk4wvcwaz24ht4xl7HtGWoJIgu6jtfifpxjCvT5tv8pVLs9v3gK ++/+gHHQgOC6VcDKTdqAN1GK6QxvRCeWr05BhG1FlESVB0pwNQpGusD+BoaxaqSMmQ0ALBHyz7W/+ +5S9Mun+gu67t+DL4XlGxbJQLDSO2Ui1MvLWGRujI0ZXMgDJeMzZTaa2sv7UQnHw4C0rQRhSSqgJT ++laoqpQEy7GdjdDFjcZ9KajIlLhRm9ZwaodS0GbW7astbHP+OZWuzbRpg3isk2ycSHLAbMiY7WqW +xLTNFJjO0smoObvta47dzFo0u9AWsm0y7Hw0lJNNSwEAFNOhfZs+2UKuc4PZpxcSn412Z6I6ijRt +pZUjvJkqCJi5/nTQlOH3uzZKMmgwGrdsFCPUYGozddSgPbc12G12MPjcfgNjETMftlwxBNS6MRyO +lLhSMTQAOlmyUkO/4irzHBVAqtsjJ4HutNjgdjH1IhBWreqyCHew582FIrKQwJBxIg== + + + tCVlKIZUv2/fatrrjoGZM7QR2rDZBOzGybQDhzdx160UduCe1UtfqOZmNRzos5A9dloqOB41j4Ax +oKYBnfNLv6KEpWNIWSzxIuuLQkl0QkFbBgasjYZTvdsOjMB/jl+pXFVqt3Pjj84pEP/dcb+T1aLJ +0cmjqo3gV91ivAL/Dpw9mN8rTJnPKzqxGAZh+52bmAyz7yjY3wVWvNDRKezwYtTvSlLR1HiQBopL +QJQmowFA4p+jSa8uSSbGZnqno+Go9Qk+6qgmedIdujN9pUHjQCvoth/OxAm4w64UxZQFcrTZmFUb +f3UkMxNeGWW/LPByB5yfiU5bss3RHy66RLESVitq3yn61LpXb8tzpSiH5gaR+VQNbmMvKwQLAiB3 +ylEbrFT3vSuxL84DwhTqcEH/1uE6jO2kIV1aY9q76JXgKhFNmHE5kimlQgG0JvV7UuW91n7pKgzS +G8lUFcerzWAtNqN60KY6lvvYLHNT38hSrKnW27xzDh4Ru54VarVQU10HitrvUh1vMHzsggmqhBmM +5wQ0mm+McVRn10F0MBCO5AeyVhaUHtEJxGkDSAklncIdJyl0pmBoDfcSVGId2Yk98ZowuwUFkczm +XGACMJYjxVtq4YOVWtcn3QFE2q3KsneUNWbTsRvSVecD9jF15sw63cSRMaOPcIBsV6XiWs9XOVF3 +HnYJbJ7bTvOm2/nTmUepiEjNl5wHU7czt2W8QAYGFOL653zQHDa6UoRdqP4Jdpq/Men4Z58dv+h2 +8k+lQLg/PztD/xRHWDSG6sJbfshF/Y0pfKzovlJMfBzFh8wQcC2wv0Zz/xhwTj/gJx28p1HXGNwH +rKrT1XQU9YPO5E+HYMbwotUxTCbzd9HJecPfb/wF4+8bYxw6AnnVdN76hMM7GhbQUZUCBvc2BEid +g9GN3pXuu1P/fNiDlUDirnd+a9IdO24s1BhgBHGZusobY7dmshnigtKwjKobUtEc+XNOPsSgWKeN +BQbeMcZgmU0VDGQ8VrFdBxJWSXFbOYrjKWBkxRVcZGv3kJrR6sIZ7eBLzMyFUVKbNYZtOSTaJS8W +S6P8dWbr8nCMHXdGqFo9sF9XRATahQXmMniDlcG8bBu6Mj/NpgP4an86Axb5XE72+f/+7/9n9v/+ +X/Y4Ez8D++t98q2144+GPT+8ok1lwvN8UokJ1JnYyswSua408mwtf3QksIUO7B++ZA7Pdx4j+7cH +wb3GXfSY3jmP5TKT8uAz9THcOC5tREPBfLcRn25z15Uit5XKXJfTp8xhqvoUPM1M5i2+VKROhQDJ +MFsEMS18FT6ixHZm7yW+m9mPjqeZ6QmV8AUye9WNidToeJb7qFxWM/tMp5bvHqRbhXg8+GHoqtq+ +B/3xhVIgxT+UZ4Wv5xzzEItmB6PqNHtUm31G0tzWvFRgtm9zX/3grS9QeCeOm6bAtvnkO39z+fiU +refjN9adqtulnjP7vdJzJjWNDyKFaGBeCpXb774AQlbpDWgYhffnWz7Xz/TvUu+5z1n+k38gNeh4 +2ym0yOp3Zv8weIvhgCFP8y8fLyPwa+e7cNQ+2sjFhK/tbC22NcRjuGu0575A8isUaRVb7GUo/8m8 +7u1nA/ROJHcWfYtk8sHrUr4z303fHG997rVajR781Y0U36ufuGeSSDT4SXf7LdV9OW7n+oHDYGwS +eZpnq7Wdbzj+cGbv+JP2Bbi9m+dMdtgKDiIHp3sJfvB00OX5xPSdzk5aR2SklyJliK3C8fQGoI0P +dvhbmminuvlEA6wveXoQikU7uT5/McAzuK8GMvmj/a3bYjTJTsG6HD1yW2k+P3qJ7N+0H1NUc+sZ +gU0PA2BCaW53Cy7JI3fLXQ4hntK5XpiLiaR5064S5PPWaSHR2N8pbUQeJrAXDr54QVBQE1+AaG4e +Meh3JF3aF3/t3xZPcPN8tPiGgVH31BEg3Tsikk4Xo1Th8ONAhHN7sL/X/jp7QSspDxjAO8+xYi+g +Ue5YHsCzMgAydHAFG3UY9IzdyBVeEaqBsDxkuAfuq5WtF74ihffEyXex0Qhu57jm9eV+pfCaztY/ +W7PsxXbrNFunaLD6Wf75fgt8034o3r0dzmUUYarVkOlLTwEm9OOTirRg96PCe63YRvgEYBvhSHpr +7xavEITsCxRfychNjrk7LmUmk89rJnV6e4hWSGC7Ew4s3m40khslX/So1E5cjXcJT3hhIShfYC9y +MA+VCn0yRxyzKfBPmehiOGmuOcrs1Web2frxbG5EpW4lVXiXFv5usgGf1QEf+453s3o8za+SnVJo +ZxzOf3JXD8Umsb9b6EwmUaJzcbAnDwSjQ0ZGtZx9PSYRte3H3kpwp57EC0dffAPvfbygQu17cJI9 +f8mdlvLvxwJBnjTbpXx7cI+Yp8kalHN97uBWgc3NqgcPuUp960A3Bl8AjKJzXij3Ah3Q1eU+5DA0 +8Z66HRlHq2/XAr+is/J4s5lMRvaYMx1G9o6mo/d8d9rlILeMPV5Q4a2jijKrvU5qZwB28lUYktdp +5OD44Vjq9OMJ8DEavA1Ud8uz1/YgW3s7LiS6B6ESBvAerHDZ+unoI3NTP2qUisLlnS+wHyGKTzI6 +xsXo6Iwq7XCpO7Dm82Sx1fvekTpAG6TfwIx55zFYBezxIJi96o931e0uGxXA/oIMf/W5G8+e3NeG +voCKhUvvXzN1fuc8X/2ukxqRsbtTeM8GXzQy4KpUeg1vfKJpAJ477IAtxTZ1b8XVh+97Gkmj+noX +CNHyqBittw4AFi9vwca+246kDzgavc3Woplhvtu9bMOpbcAm9cLJSSVW2i+yYfQWzuVjd4ib108z +gVz/mIjDtXpU9icvHHZ3mcxNM8FfVE6vyObLdZbe2dguUuHtlzxZzlcz8FcakDh5QHSaqUMyGsof +ys/SvoD2G9wSPYN/5iBTzKMP0Z9crUpdwrcH6Gu5gzx8lsOgsvuxEs/GClfU68O4CJvsA54Mm8MH +BbmrHGx0psDBvcD+tCAy8uDT8hd7qAkczQUaEhoDmAuAk8VDgdPEE4aDgtipw2d7CJjSCwKhRxEc +slmn6E8RYxBiTYtM9M0efIumcaigEjeGg8NYHH7sXcooqCF8yr3sq+aiLF7admldL4RuGXwB3ULg +byCyFNhoGghPWnQcoFkpfyJQcs9lZQy+gHYt02YkZ7skeMjolzwr3KnyJ6YxU8JwQRawcVWelUIq +eprFc7FE1gGeKdo5EjoOlDnDxudmSNXtVF9ARuGBbpoyTlJaEIfa0eSVb9FbXafiuij7TkUxmlVN +K1SLGkNMZE22yp48wguZeWAixXMpITwisG5RrRqDLb0glIPVh3iUYafNGCCamrw1vZEhWhCMsX25 +AzTGK04gw+foF0a/PFOeu4m/Awb+RYtyL5kdZq/eP06AWnky1gmMbP3mZFjKkGTPFygHyq8AJ2yI +U+km88vAful1Vt/N7BEXG5HizV1FEmWxbZU6odIK9FaSuh2gZGgYYPUFiOCIyjQjk8BgOclxQaD6 +hR8trSl+76FaytK97WNkB2gnFEEGgi8gjI4JvhiLvjOFk8NvRt1L7rWTvRrWrrO12dGgGKkmQtq3 +/VImGRhLRsVVWDG+cAdHj/Xv7Hk+dwF1GFG7GmgQAyxQqIVpZ6pSNvi91vVVln86viocT3bfzABk +2crzUfbk9hLoyeLIrgO98vS8MxFVvyqXA2L7KS7bDnF728HecoDahWQ7QGA8f/3cOSm8X05rie7F +I1Cbi995rG/T1OajvTFkaQr5AmpjSKFQODVsYd9lz0uFr9vXfPeLS+y9DwIfQL/dJQFO0m88f9Ue +wcHFFP1IVGNr/WcFFKBkEdjvZFlwu7I/IF34iIUPcQeXdPoNKGrnwfxn5D6f6KYPUuJaafGksUV6 +gOzjJcUQBnxMvQYXFYR+0Cm9BZ0HVUzzInGqBmJlVOykMZ0rG+Ci0geWhaL/a7V/1UCTvc5JHkyo +HSm9vaaThfI9/w7M8SJFUGXmVA/2ciP8pDNSMI0VpW7fLgvv15Ey4NOlAhVuF/EORJYqlAFJzLhe +9nd6VvuKL708726VisP5GxVIDgRx9fej24lHgW9Vj3OXFxkwl/vBmWjgz+8D2cuz2k2pEG5LLxRi +H+0QfG/evCCqJ82xYiPrfQ7UQw+sS/7zaSMVSZdfXyXKeo6DFYyf5HqnEaDaX7wrezYFPS0vuR51 +sKG8kB0BRKo96BNQiJxBbD8o3g5g8Zn0veqesaZ0pt664/hl5PCm8S11UOczeyf3m8B8/NzQwj7P +1srtL7AuBxMqc72RRGuAVuAgNKc6kOTe0QvAxw4/p3O0yMlLwFRBLy8NAKI+Lb6OyWZm7zoYVznJ +KLa/ufc+v/jK1q8b96CDVJ8oPWVoMJpKTObOegeGL5Dsl0bvVhRDyi3r0u5VA3O5e2m1R9F+/xIU +l90pNJlOzXH3qgYCd+8HoORS+KK/VyqwD1Qkff+8a4TowspXga2qdm+u+vqJ8AnWJc0dzwvxq3Ys +kzr76skiqs5tloZ50TUIiC82/h51C4m7vYyEz2An8dl5eYP4nIqDKxcORA56e8BCMU/lBudpIMU0 +iscZkzuf0w8A1VfTYmSXe1dJLIXuIClx21vfQiZ1+93de680PzKpu5IaFObY2HZPNn0BJLH3o/dc +BcFWyW6xJRECdvqsBdbvYa/QGZ9XkTrBbVWZLfiMKpzUTzeV7vmbfrUOBN3hdvGVGD4X3uuFd1+g +GB2dzrNsJvtYbF30wzp1SfRMfgR6gKEmN/lp4uwmW69m4DZMxoyD3w9lJrHkPHtxlXhOdV+Ed7Di +t7tgXVTqDRZHBwlAMdVdoKA8XZde9z4T+k6p9PcALPLHRub7sNVRXsC1mmeF5vgjTlZuouIzsMRA +H6tvf8dKoVEyrHtFNqtHlAJClq9wyGexXH9AvAN66T1w6dT5fWZvnCSNUxPbwXUBLXnhcrRr2Qg1 +SbXbzW9jk4dYgUg+BEv5DtfL1gsNMtcXtgSCin53M6nzyz5aMBWHMVAROp84aN09gk1TOM1e1TPf +RtrYmua7B6fTTKoUaHCH3F05f5a/OZS1Q06UL/x+t/VYOGpdXeSYW2pmWPiXrQ0gPIjLUuj4sJqs +PJVmohIsLmIcENoJt3eynX0vfGw9M3xqHM8Ddai7q4BCWh8E9t4ZQaJ73A9vB14hde8Xm4mHsVbz +xiMT6jvbtdLr1k4NzC/yVHz5mrWQD9KIz/Ks2MzthnyB1GmEfszW6zsbGmI5PJLBVkUvlUgWVcyE +pT+fLAikslXKZ5+Bipg5ugN8rBCts7LPEI822csW61k+efWRZN5yAzDJHGHZBAqCBjSVwrFhtC6r +Z8AKq98c9jL76fEtkJX9IbFjAqKT6wVnxznmfvO6cvDEBF3NVFTzNFBC8SfYS+/oDJgfxZF633GZ +EZSGx9DXCabL0lvARHhIKiBSpLBxVgrfX8yyJ/dkW9XpwclZu9AeJKPqMwswshDg8g== + + + 570Phf9iJjx6+2RVO1U+vcAMN3I2+iq8J4/7heZuN5Csvk32S9n+cBO5Q3X0AlYfHuWlzvKJp8LJ +yX4Cq2rUZS1WKpLvoVIqe7UpLehtCHD+eoI7KGXTOS4wZgtHjX7AwH/6F2GAm+cryEvjhZOjzTzg +ltoNtB+dX9yXMsTsFaz5sFna2I2SwIS9ht8kKbBz6DewDQ8FFVh6NxTGxiVf51+ks6tMQHv6JiJh +rxQ6GmSTn09nW6XCxWmtFBgzgLncdj4ydO6BUfaiqAaBX4qChc7wsnxtK58F/61k9mPxsGkvsNFO +GTqLn0CjIm3cY1u9LBPKXRdD0+YzZCSkHlnENPqAVgBs3Ni9ZS+1ao4Kv9dNQZDB4zY0mU+yo8/z +XbXlZLdTEdlLFp8t4cvO90d0CgDXiio0auWncqD8LAB66c1VjWfV0jNY/cw2UkXQGSXUk7nMaSF+ +/rmvoto0Fx2VdsNRDqhBTACYEpk+Omzc6yRbN+IRHHd8rZ6p2gVxSJX2opuKAW+gMbXYHrffS6GT +clK9yIhWL5+24It+ttYcv2NrkeI2P3KDTeFLpSllKuNvaVcq8gX1ckvvN/i9y/OLbG1+TRkFCjsp +HA26UyC2cgMwwj5XejsNJK01gPPU/hXA2Gm7umW+3JJOISRHiVaxOarEHNrVd26fi423o83cILKj +EtASjam0j8OzO7DSXdW5vQ6Yat8ZZgoFyvsrWMTK7jdQuY/OJImM2OfXJHhX2pmPOzlmngOWDrC0 +VTY5ajIICYCDxov93NfXRaZw1L6cFY5DoRI8Bj3C50bZfmOAVKPibOdoQ+r5eA60caPyWjXTYEU1 +drLVhnQXzV7uvgIJ2RqQanZ8PJ8RR4/lfd1+EOcCFJRWPXX20pyX3l6oAaQxWj5Mf1CT0kEnp2L/ +cJ9jPASI3iMQDnehwvvOeIubncwOSq/9eELTS/cl+gFWY7rLp14iNXgeFNGvCx0e0kAhYBpZJhgc +Jcnbk0RWKE9nMGwAKHRHjbvMNHy3WTg5fv4udPZfNpUFQzr/GwNE9PsYsI+nBJdqnu+4/Rp+mwTG +VaVSep09x0qZYKeuPYzj0EbBHEYyDC6AaM7EPgXQX7RcfhDqT8VmPXtb+GB3ujruJTMuiWfJUhrz +KXFJimgtfAF0BJn/fNz/LmUvMuPU6XQ+0roGOe6bTF4VWvlGr7DbTbT4fbrYKT68HxVl9yRqUgM7 +vlaCsqmRFWLxTegLKSO2hTB28cDX3yqJUmGeRceSl0DjCMYKpWH2FMjPejjX29uPiQqKDuIHYHC1 +eb2tBG5gbigCvdzMseFSAvCxdqrwoeKW4vv6lohlEXfX2atR9Y1Lf4d7apMZ4jgX3K8Wo885YO9z +1EBxziJkAdn71AUYS3/vHhead50rsNvSlfL96/gN8Uh5+1hgXl4c0U94ABh4rLTFTS4rh0D1OQQs ++uQ7h4YkeUepy9AM0tM+d33RToCdeh0tBcgQsJsvr6KF4413Qj0D3HhMcjff71kkEkqBKp/SwZYb +Axor7Tx8DAvvo+cIch2Z+q9FVp8ToHe4Xp7Hxy/Zk4ewoKw+DAEIFlvzzRfhvELXk3T0eK/0Gr1J +6eYiw6kXRzqxrYXzlv/4LAXhqbegGbIMYMyVs6PvaQJGd5wXnrv3W+rTaoUBpI4bN6fK/DVm9CXQ +f09LwXKgVBnIZhEwkG6344XjyBar7rk/2y62mtE2jCK4pQ7Fp4PNHbjwr1Bf29d4up/5zN5LbJ6t +5/lXYHW2gYWdiDWyo2ynpAwOQ6FD2b3M3vN1jh8e1cnC88czBez9Wj+TkIABfnHRBvuvuw8mrFFF +i6WdcnWshCPFN3aSNxx33P3g6rH7B6q4EcslPoftxnby43YCxlqB13TlyHx34zEI9ktkt/VdILZj +QyTe2Y38LglsgsEmUPevm2XoOQ2Q9P+ZlqPltKFwBXRNuDbnLanPehw3hh1dUqB4n5X2Okz1FVl3 ++qtYwLNCvaDLiIQ3c328S8F8hujBPbmKrrayKgz6wxVXYb6d9M6HYhjVT0zj+iJp9o0H5nEzQSQi +pxHAqWc0/EUx+5cpWn5xKf9CL/bow/osByyLcq+ydXXQAPRyn5bfUpGDK+5zI0xXDjZiiSDQYQD3 +6e1vhM8ekhvRzy549fYe34jMU7WN6OldYSNGnFJE4uA+hLoHqxa+ZKbU9BQMrtADK/mWpnMCLQAm +O3hAsTboQEl5S1ReO8CymEzSB81sdHx2nDlJTtNCZf82Xho9MDfFydMDUXgo3ddLB9mDFrmb5Ydi +L/T2ZSQf270C/VU5q+niCcXpanIban36RtXpZLI3rYNOokdEgqnhaSgjmwql2Q31MurtEO0dEvV8 +roCdPBPTfQBbmEfS5Y0dNHG0LoVePDEVyozwvfcF/iz3wdf3BW2nT5Pn06dL807L/AubOnqJm3b6 +sn0G5L6uW6VTrntSDph3ur8RmkzJwMS80wvyidmkUrtKp76A0u00GD2NWXTKfoYawfuieadM+Cmy +T32Yz3Sz9ML4AlvX437VbK5EKXeSseiU29oeTsIHFp3evxCl97Oa0imKg5W7LW/s75DHr3XTTssV +qm6JXuohXX9DnQJabBa1a3oLKPlpnq7CbsPGVQ3d0499Mgw6ZUYGUqoSObHTi2BQ1ynLDl7HSqcK +JeNuXyfPn8O6RaeZBseXtknTTl8O366sOq0ArY8O7T2Zz3V/43m69dm5Mu/0Mh9Of28PqmadRvb6 +qbTSKVgXLSntHj5kzs07Ze7viVKSODPtdLP0wW9fDahzs059AaL0/FyymCu3FegNT/NWnTaIcvTt +xrzTMpENdkL8PerUF9AjeLYVPRQ7vY+FdAg+PGMORPQWn3olTacP+0SVj5Gw011dp77AdLPSGXFX +jRgFuuXHevqtPj40LDrltvheu/Ri1WmBON19TqJOkY2snevRdyrzNTm7Mu20thekLTs96dRowqxT +yPmZxxhRew1vms11unlS6Zw9PoRDpp3eBIcflp3WPi/fmqhTX8A418cycXMy3jfvtEoHrkuZ/QPz +TsfHm2adAp4Mu715LW/OLBD8eE7cHp4UzDs9TRdfXy6fn007fT7vHaFOoXwxzvXrnm2XLDp9Eojn +aT9m3unZ13hwnhRoXaegF9Tt61FsaIngSaAW2bDo9P6aKHYHx6adCmexzY3McwzwMdBt6lu/aeav +/KvYaZMO6zZN+KHa2EWdUsF0qKKdaZV4201lYadRpVPQC+wWgP36lpj+wUTf6XS0cyB2OjuM6Ga6 +8dR4DONOc/fkkZYRRifT6/QG6AV0GzdypaMYmivoND8zsMLKJoc7PSRPYjpGGB0zZ1jS0Nup/Anq +FPYidrs9mTSaQ9gpoet0Msl2RhL9Hm/oOp2yXylR0hymLuM69G6OOm91n6g/dBqvnHZQleudl1HK +8u39JTm4sXr7SVTeAnPlrYHzA9Zb2LH4GqzBTiQvjeurw+vecgL5WhffTnuCYVdyw8/NO7P3mCle +HKWeLN8K1O7Vm/Xbz8ZLUMaY8X2W2nloWb6tRoaHlPXb5vn7nvJWhzFu63yz1axYfC1Udir711P8 +9j34ndR9ex3pSsrpO7mZMmDsunlcG5q9x1yuEOlNLN/eBpqJDeu3T4XUgYQxk/dvgRd+2/Lt1+xi +XLF827uhcpfKWwPGBr1S+sXqazCkyz3W8u0xxaTvrDEWaA2btarV1zsbO0dPu5Zvi9nTZsfy7TF1 +uElaYyy7QW2HUxZv2QpRPNiV5pwK7eneRuqX00PxbT6+r9+VlfpbeTervGemTPRKa4HliXbwMS/y +n7dAH74di+Zo6ZXFrCc3mp7hXxo+Rs22oYWZ34gdJ++BhflVh//E4bPSRrRwlYf/3CL7TbbeMI8Q ++2tc5STON9mkggcXMZGfAztHo4+lt+gg+PB4gPYGtHRUOyJxKgyDwI69mwPWurkD+nvfl/vbSnQP +mmHAnTaLk/lbPKZht5NNX0DpFlk6Fp1yW9DOeTTvlLl/sOwUCJEvUqePqeeKLB3LTqHIa1l12lZ3 +ytSAjazqVjjL1VSdtnd2tpROkfYvd0rr0Au1f3mm5b6m0/A9sl7V3WoQfEBZdoq0f4tOgT0ItP8X +pVMwF81cny07BQieMtadQu3fslNfAOr/n+Zz3d+I23VaDVp2inQKpVO49zXdQp2irlnVTlLqHv0S +FyKcf2gP3LR7mQ+G6r1v0ZLb+n4p3p07tmM/RboTuUUOzPkpK3JLw9Z9Cw0gdq5UDpp0aT4RmctO +LaPb8YnuViqq/JMeh9p10ViHPAnb++lxeH8sQwwhEOlkZfsLjSKdLD8WAONqFGHPtMKaxO7TxYD4 +T/R0JHaAVGCpA1m3BOMBkzsY40Y67xNge7nEZ6cQkP+5UmvMos/sXG5cgL2U1dN9Oz4UfUpgyNcX +4MEOVGjnuxJ2sN4usmPVDC52tAiUPW5gwMQxGwigfyBB3mqtJLNB9ZJHukGph/Q6DwLSPY1SwUNC +5UfTuQMRygG3fJ7nTpyQDv8RB4+NeZP5BTcs5+cLKDNE/1iuoLR+tU3n9duS57cr0pjZDKHyem2D +LPfrN0L0iS0Ll8iyAUbu5r5KlqB8bshdQtZezBNlKXSlkciYsspP394xb4p3oNw8iJS8NOap3EPy +2B7vPmtkaVlP2Mh6Xopa1kNbsh6fE+kWn44magTKQ9YgcAezHnPcvcB8MQnBFuOJFqP4HxF35NAc +d/exDUu2bbUrkT/OdGr3m96nppZiaHL04U391AnV5ZMd8TTBdCCFiG5WaimmmlXnIr4jrr6BjRZB +LzcjTxMy4zCAdoA5d6fCrbwN1XT+Ft4Bg7srWCxTdEw2toMVNAbs518QMYS1lP4cRQ4kylFRMnLq +mAMj3QIzA4Xwrjrl2TXuu0bJ7b6z33VAVjY27+a2a7lFRq/JKPznMaI6pDCQBeCMoeKJ2XICjKkX +FP4DFlRxRBtpA8xP5oJG2ji/lIekGheay6xsOrJ0uTm1mmSG6MyuEwYtzLgkisV3GjEuSbvspIW5 +ZT09YeoLWAomFzqj0hhoM48zS7HkC3hZ3zLEScW79mS299tlLZ82QdbpSBG8NkOaHR5bysrzK3E8 +blQ6MCRrhU5aOl/A3QoCK99WsXDS+TUrOAzYKhYe1q98MVBAYUpeAlht6GJcYFe6AqYVKF7HJZ3w +isDu7Y0YL5NUa3VLY+x1skKMaTmax3GNtX6YN35iMFxn6emC2rHm/AWMp2JmDFoptKYCmsrdfW44 +8DGVgm2+K2eHmyvblbm7721vhjI+jzWsZAUemVQV3EBL3Dt27jd33Bofsm6px056KotlRzeCuWJY +0TEF0/3ivEzpqb2JpxuISMnGoThwAVcD0emWi+HEYdurBoJt5IiFiPqoQNf1owebHB9KaoOM5Nge +6nnajKsc2uDXEaT5oocOLJwaQBPcsNFhTNmHxQY5slc7fAEvg9pakAFouSXccs+zgA== + + + vVh2ywCOFAbg1t63nl/QBcp97pCu0RWc/Rl6TV7x9X0dwUO921UQVWFGFp+nZYUzaGLhTA0fC5sc +0P4n7ZY+xRMrO2S53+KWZg+ykgCyPG5xDbLkLY6+oLeTvYR2gx/DuWi3uKnV7exdAlS76c5DYudL +ONa7ZPWjsXPJ6jwkg2OtBm9hFDu7ZMHUVBtJXH3PbpJjGJdw6ta9IVtJ+qEcz7VieQH3BqCDbwpN +CEWqGFbL/VrpZKqF38cXsPPSDY7h4e79Un4fiBZnX5+OFVj4ayB2OFeUrOKbGk/DWKNKZ+Z6VRrQ +gbUzUeTJLpRpiOUTvSrtBXdYH0PjCdiPx61/gT685oM6ilDZYp4E4YlOE15sv6Quw/ZTc6bzE0X4 +yfJlAW/0+EQv96wm5AvYUDqgHa3QW4QBHF4HWJ/DmrtDzKuDk96nE3VWuizAjk7QOckhtS6L56IS +dfCwKqiO34CzAs/cEIPlrlNRch6MJ+7N522c813NTNppT0VdH0ECYFb+VjNvK7YsrPytEJiHzWdu +L4FN4wssfUiBVs1e5Plcw9Eakt5GI56JYzjL7kAMRbYmFSgST/YCx7vck+19E2CaE0JvQlR7PhhE +2kU0pNU48yhMdSUnDHkUfOoLOG9DF+IGAqPins/4LJQIGMu56wqVKvUz9a2RYnqONu2FDRxt2tMf +4LngaKYekjxATOZ7WY52rXA0yXr1osHrgTlzNJ/LEyQIbHGOJu/K8s1oBRwNrJoZR/O89wEc7xzN +4LvAcJbnaBDK8mevCI7NaVA0F5JPcRK+gJk2oBFCNyM7C1p9dGiuozDRK228JbB5DL5x+GzZA1hJ +vrwHv63ZkEvNLA/2+fnMbDNjD7w3NguA3Wx4YrK+gCWbXTD6QbuZb5AtrbHEF1FQwKrpgpqsOIwz +HHeqvSUU5IcBcJYPgUBQLAxq3cm7MxztobtL97LJaQICtgpfNZaFYH4RqF1opSF4GltGv1cRaWPz +arq0xXd369abpfJdWErDW0/6vb0PFgJbXr9/+jaThV6lGFw17y4toxSDcJbR71VQZFm4uBRDcEz0 +ezMosvVqAcetNLSXhYjDPH0vLQ01svBVf06MegFPVxKOBPmPaRyWKCs1wVNKGIalLvA6sVkSNSqj +Lk7f7u6W8VXr/PwA2LK7WzUuk71tH2ttgzFX6q60krAXK4sIrGXc1T63OT3NA3zeJGw8Vy7C6XRD +sqQIFNvjuL30gikfjxnEUj6ecGVXuhBMVO6ubRmeZx25ZmHvg5FR7lDpYnM1p6uLtgXALM9uZG+P +24B6AIze3juprsJDAjDGe1MxLGIQ4Uq+xl35YDEwi81+bxt8iynCJ/nvXQ3KJUUYNpcokfHWVeRZ +mj0dmloW4hqgbLnpx0ZsePm6Eb15KW7EsvQLzJsrmmXQ4Ztbls+hU0sxYwadLmNo4Rw6+ww6xJNX +kENn2SnKoLPMFvSYQ2efQafOFlwmh84+g06j9S2RQ2efQafJFlwih84+g84mW9BTDp19Bh3KFlxB +Dp19OzG3eukcOsPG1WTQyZbFkjl09hl0SB9zzqHTBCTbZJhdBEtm2rZ1DLx1JpAu2MXFkEw9vQXn +wO1dd/lSJZ2NvHAwbEGv/Zo4B9x6eh8LWmnvbelUZ3wFfcDGwnja29WQqzZXVJbxITfJYJ2vzo2T +E0V7xmcHzD4Oy938kK/PKXPO9fx0nivjfnGP9IT3IVlkPjp4ruyGZJYyB+fiKWnOFa8p6kJBlNge +bwlUM0+hIDh+zDQYxLvb2MppjG4GW9pfdR/bsp+az2WymzYS0qtjEFEyWPNlPcY42c3q2EZrJTkl +u1nbp/YHDipuWbQNBtGYpk5mSFGXzaDJFHYHTBuCRRpPbJrUt1Pmozue1Sh5MnrRrrQye5u0dQil +pxRTlPt26jLr0Nm2B8gyO8uW9TGj68zJcdgTxjo3Cfj22jRodoETq7Kl2mWZBabSlPR5YI5ql+s8 +vrlTDLyHPL6mU/7LlsZpZZ2aZp0EY69KG2PggwefW1aDypilaFqvn2MMvOsognZZ68E0XT+3eXzC +xCknxo4YtNHpENjKMkQnysmHVWaKF2DOFO8eY1oH65IYc0wTdT9JhaMthDGt45fK3d3HtIFOFV1g +vUkmlztd1uDzNZpZ8la/Mvdb2ufL6UBYAOhtaiWyCYg36oWE/7zZ7u6KC2NPtvgcjL2PimtjzwqA +PkZxARBOV6OAdZZv1XCXKrfQCr0SzvJFUmnMtwVMcXN2MvhsXdIwK83CiDOQvV2OnM8hzdnFkSea +kP2VJz6DeWWjR6amhlD+UGHmAuWqkxErSv468ubeMTGVsKbkkCBn4DrWGVEzU2m+gD525HbHK/vd +Uh/7OvLm3rFOs9NHEC2Mp08HT4NPZ0pYk4BHj4xmSJp8ZDAoyov7w2ZI2s3sLMVs8MS4HZJ9dLpz +UpzdkPR3d8R1/l+ckrQKj8wx8sgsGaUGNOFtFx4Z8YzPIT1nOxXfWcYjo7L3j5f3yAAAIZvoDg9p +aIt4ZAzZgst7ZGAams4jY5WR6pSfx3jyyJj6+Y9dpOe4S86BKXpgwzlTsrvwPViqg9AqyyeKsmwd +N+5GWaYPryNbLojBPidxfLKaSAa4LqnL4GqcOmBqqZBDTK+bNLQFA9jV8gUmkFl7lzykjxlCF0yz +BZ3y6jwHzRojVFFenct4Pdu8OlXqqE2msLMT9MT2kirV7lXplrahehfGu0jhM5eCTsp5twpMWk0+ +HOxlFTF19vlw3u8fWyQfziwK+mKw6ny4JfIsPOTD2UWori4fDnqtl9yBLvLhTG4EtUziWjwfThMN +JX0TXHU+nP7eUZwRt+p8OMdbAlaSD6c5sXIRarlYPpzeFrM61oGZbMtn1kMBt7KYSABKGxNppVu6 +iYm8GbmKiXTa+9MevawakEcBEstnoyM4UafVdwnHTR6JJRSsjyE4K8jkMkQy2MTAO3M0mFxn7RAz +xjuratlYRDwHv3cNEc/Bb4eF0G1CS2/P3c0y21BJPlJ5FZbdhgCY7bUyZnzMchvej91uQxttHOLb +m71oSmiruQ0YwfG2fSzykQGclSRCFhLupJgjHOsrgS1u07IKszZeCex4G5rWK627rTEcNfqwYPKZ +/cVOjga1nJFKbi4aIKKas9XFwgtlpDY2X10kkbrMSG1sNt24DBxS/VaSkfr0vZqMVAhnFRmpMF9s ++YxUCGUVGakQjrtroHUmsVlcH9og1pemeg4yCsfE1dduw7ult6EuFc6cj606FQ7F89tG9KwiFc50 +XVaeCre431KLMXvb3YNduUQqnPoOIpQM90tS4Uy8Cr8gFc7cP+bSPru3UwzVrEB9f7Jd4tOnZayq +mxvhtfpYPu5gFrkN9IKgWFceRRcOZAjM+mY7jzqM4ZJhr4cLqmz0e5dHOHa38wJWbibylF6ck5v1 +eXVPltfh6IWD5B01EQ/K/oVV46Jm/YlrgEpcps8/y/2bxmthqz0vlpLbmZdSPX1RzCRmQcD5S/VD +/h6VDS88FCeZbIWrH+dz8VY+n0ucwCIEtbEkjgJ97ZBFj5M2F8ss6wxaSWKO0qN13plwmbpQk5c2 +2W2vdX6qdj6rOmU/dwP7GyOrDDvm/s4u2a2dsOyUKNVzdhl2gfPuacOq0zebTsuxpKpTfS5WKjJV +eeH0yW7M3WdVrkyoSwHbDNklu5FxXafaenx7A6sMO25r65ubP1kluz3aZZ0N7DPsRvW6Zac71c5n +26rTjn09vss7606LZ49lS/RuD+m9V6tOL7UZdmhVwYYVZ41+iXSectluz6wd9ipoWjJPVVcQmfAF +bieKzipnooieSVZSujTv6wWqne/YRcitVoONDPFcNGdEFzuj1aT2OEeo6r0m1nWsvl0MSXUuZjMo +p+BUpzgPbL2uspKcWdkRkztVXHiX7CrJefLCPRZch0g6ZEOiOyE9xPU5FZGzjetzT08OReQs52dW +982p2Ijb+TnXGnCNdKc6I7q71JaoH+d+v5Q71oWILMNd3Rags/f0LpJNt5gfxms2nZkdINXiXF02 +ncv7YZbMpjPzCer3y/LZdGa5dItmPlpn05n54s0j7ZfJptOgRdyzpvePLZVNZwbK4YaQBbLpFpTI +HrPpzM5pZFm5smw6s1w6tb2/mmw6s1w6l7E9HrLpzHztUgX21WXTma0u8vSuNJvOTLlRx46uJpvO +LJfO4rb5JbLpjEP63LLWlBbNpjNTTn2BVWfTma2fSTTUktl0elCONYUXyqaz0i1Xm03nHmPLZNPp +QOnPxFeUTbcQxjxn09nmWK0sm848t3rV2XRmAEAvK86mMzst0cXAryCbzow9aK3XVWTTOZyMrCib +zlm+rCKbzgwZija+qmw6p0yu1WTTmeXSWdbjW94AjCkGoKa+mKerm6yreBmLVOprc7hMfPp22Owa +5DMjq1o2i9erMwxpBk95Vl2vzlq7cIenWSToCU8KljSRkDAn01GxcEkCmgQFi6xnq0HphuSWFbio +Lqc9mFpoSBBjYFCeyi7bDck8kMKSw9jgyabssgXLhFJMaxEdksdTnUVEbyfHDoXN7T1zcrUsu0J3 +S5e5U91z5VIlX6TMnWV1uRNXuUouy9xZZXK5S6RzFSBhH5+sFLpbbq3K92M3VWZsvVSuytw5ehQh +YpYucyfqMPaF7pYuc4dz3xwK3bk7PBqfrOCeK/rwmrRfRPd5FicrC1Eanygq98K5PGBqB2G39Gl5 +ygML1DnGHjrRJ0yjg8azrQfeVSKdm4hmn3OGoXUQh+v8QtCLTdihhyAyiB1L15+Wkt1V2AI9bwX1 ++UTw0lTLOZvdDWV13lO+GCyY2KWJhgJE5RAP7joaCoByjB9zHQ0FgLmL6LYPbEa8byWZj8sfhcCK +gjbXgYur7xKOq9quZlBUkV21VexABMWQyW6aKeycy46AuUqstaoBoU+srQ2NibW14epuBYTAVlLI +GNEYGK0bZqaWXZaorJuh0rHeq10M9a7xSBdm4hkjqG0tcasY6s60t5LMFPnmY++ahBFUdb6qCobg +xYX1EbHrvX/tqVC11ekbLLy2tDqBodhFdXqAs4JbAjCcZatVYyjSJjS74dBbrOq1i0QGTye84YjJ +NrxxkcjgygO/dIU7Kb/SqsbdAtvQJLhi0brV3irc2WU+LrENJUITK9ytpFKeYz6Ru0p5y+YTyZXy +lt+GNhXutHlJbvJDFqlwZ1fvFda4817hzu2t5jD7afnE2qdvRc2xsl5dJ9YCYM5qjs+NooNr0y2W +WKvPfGSX9R/B/MJT03Rob/dcITgL8E3DHREQzkryOU8Jd7aYIxzrXFhdEpPP6ZoJVC7PS367WRKT ++lQUMoioYRumQg4L4cKvJdV9c5nG5CaJKXjwordEVVLMTRqTdpIOvlMFlLwulmlMqZCrDHVbs13e +lamQm13pJokpeDDUK9+L2pV3npKYrCKIYO1EG0nrTTG8E3N4l7iVX6cYmlyWeHePaw== + + + QKwixzUft75VDNovXivSeSr3iFBprY/dr+5qqnt0+raiHNd7y6upvOswzamnco8OlfISC+a4qvan +HIbhIuvZOccVDMl11rNdjqvoAYILUeXN+5NUP5jxVjmoF3pkPpc4vi1sdY5rvkDhMFKrH4zeIhz4 +Vb5A2X2lu6dSmwqmNwtY8CDXrsp3LP7SJOGdHV6pO9Xkw/kC062b+wu1q0pbhy2Vf7y3yIcLWyfh +TeZvKVLLk3VpeMSuVe4ft7XNX4WfrZLwniw7BXPZLI1py7kS5a2Ha8tOg0fN+IdVHbaw0qmcyaUg ++IKlVJ1qU9OmQX5HqSNI67Icw6HDx75Zp74ARLC+5pwmDa+hz/1To/dk/8KiU24rwJwV3hQfrD4j +7tWm0/I2Z91p+XLrwaxTVPdNqGhSK/WdXtnVETy5se60WLwuaSK7QLfb8H1U/iUmYc53DxLa1bdo +R+cJy3bq/EribTeVdQExkhrNioqYBHO+Z/RKp3xYI3p7tMIzb+MnlgWdy7BJgFQ2jE6DNFXMnAMn +XchmAPtAn9jk6CGxTkkyhlZZDglSsvWg8m5Sm5wTm6arqsyCHLoOlVncepIK9qFVlktnqMwCOqh5 +CUGzy7rT3Ty5RFaaQ4QmxpLPHT3pDr28zk/2WsO8O89VFi2GZIjS0u8X10j3FKXlC9gNytpP7G1I +gFtax2mJ4zHExurYVfEpvas9vC4aa6YsZkoA2Ecurr528MG+FFd1eeN9bMPdDYcuspFs3ctuT3le +isvcRKvkJBqujFso2c38yNrTvdYvxQU9y9pbNGEW4LKX0JrdFWeZL+ZktRjvirMxgMz9Y9qgEZMj +1kbJU70Daw5TWpmN3CjpOcyip9444c5qH6MTK+fydZqR6f38zi47VI/P0qvCfBsCCHrCxLs+YlH7 +KXhwZ3046C2RzFDPYomybPaZTJ5yrJKe7jlQDUmX/9Iu2/mOHbVxzZBUofriabVq13pMBextu0jl +VN9zZZMK6FTS2GH9lJP3dtk5Ucc1MejqGptWmfEAzKmKTlCfXWsDTCdVlsOYYy6P+0lqTy6XxJhj +PR1PGKsyTxbADOnCZtqhiLEFswDd5gC6vofEKkHMVQ6gTXS6iyxAtzmARn+ylyxAtzmA6hsOvWcB +us0BRF7rhbMANaRiY2Hq42C9ZQG6zQGEGFs8C1DBpz3f0OZYec0CdJsDKNvIC2UBWgzJkAOoPq/E +4zHOavmifO4rsi1TlE81l19YlM/gVfglRfmcKrKtpigfzhmxV1CWL8rnC5hohSsvymesj/wrivJZ +10deZVE+V/UrlynKp/YqwEFxloMSUeSUGmxd1W/5u6GOV3E3lMu6fq7uhlq6rp9qaiu4G8qqrp+3 +OKVF6/rZV/Vb6G4ok7p+9l4hc0vce10/c+KzvRtqgbp+zpS8irp+9pEhsudqybp+TplcK3Lo2lb1 +8wU8OXQt6/rZT03nu1i4rp9mIIaqfgtUADGt62c/IbMI1UXq+pmmI9rdau4eMa4zZU3vgl6grp/9 +zV/ymfiSdf1sBV0eSbEV1PWzdwt7uoHKpq6fvalrGgW9QF0/szRJZestV49vBTnvnur62UOBfv5V +1PWzP1DxuYazTOK7PiN10bp+JqqmqqqfujoDsURdP902JLRV/TR3dnlOTyHkun6Oea8rqetnX9VP +puQl6/rZB1yrMlKXquun5G+Z0aLunquF6/rZIxBpsCuo62ez16Y9ekX1+Hbtobiux+dQTs51Pb6l +6vrJUEy3j9dsDkNdP5u8B8do247Xun72mjy88WAVdf2sZPiN8SRxsfwtF+q8dJLotA2d6vrZnzdr +owgWr+unxbbeWly0Hp+3IA3renwr2D5yVb/l6/G5SWJyur3BGKvhrRSfPiN1ubp+Gse2oaofzhha +vq6fnCplV1d06bp+9mqOBY15rutnX9Vv6VubxLp+S/r6XNb1c5H3uoK6fvZV/TzX41soC1fHLY11 +/RZPhldV9VP1slRdP6MrWV3Vz+qWM691/ezDu3RSbOG6fvaBTjqf0sJ1/UzWRVXVz/5eOPd1/Rb3 +W2ox5j3nycKuXKKun8K4zKr6LRw9qKvrZ0sRqgogy9X1s1cMsfW6fF0/+4RYUSIvXddPO0l9VT+D +Pub6JittXT9rJQjrMA43Wbms6+dKh1m6rp96JY0HODbZtRb707yun71wsM3iXFlCLJb7CRPx8GCn +o51fm0d86O+V+sQ3KupkJXhq7dq1D7zXpS1qqEmiMeX0Jn0wVufBY9+U2FVIIyHjIwUxROK8w8n4 +PNNYotUpzH2jpp8bQKwcb0Qez7aJxF2Px41gPtXG9mn6KE6EhhuJ1uOYoSefx6V0/zl5eb0big3C +wdx3jqh8nGW3vuc5buOp0abBr7dMgBX2Kjun599X7Hfv/tEX4Nk40xJOS3fxk/hkg62WmbfcVe/6 +sF075W4/650z9vsm1Hnfvs2GmcLXZv3qpJfq79+NOoeh4fcr/x2YZIbc2cbt2WFwmw6VucD749FR +eP659ciMnjopce+j3M70db12sxGPvGQ2qI/vm8g+HcwQpdxJjii9t46JMrdzNZm8JUOTqXB7NN16 +4ZpTtvl4IWda1iMHidhtnK4mN6W0t6/EZPo0gsXmkls4t9rIQzT5pXsP1ddktnU5hga1XAIS1pOc +v5GB3WymemyGLIQMMN3ZDlwXenvDcq4oozHUCHYutm4e6unt4SRR2qGYj/lWv73Rhpmkx1Jy6MY8 +OmbOYLza6RDlJG5kS/V6gNjutJG9fzHSquxj3fYBU7vIq5LmFH+ramqArZnhIc0F8nNfoPBQ6tyh +Apr55/LVHXeWb29mErP940xi2t4rJbd6F8XbDP0C0DZMl/s3d0/ZCrfRBHBuviWwuHxmiIz0eJjK +eP+S2atuTNCssoMRpOTsye3ta6R4c1eBv8CEL/pxmLQbxWZ9mr2fIMuJSMxCMBrhdYY5cYKNB6Vf +ZAj5jgFG+CH4k99FWb+A4RyNwZ8HUcRhtoJAij1OwIN8XPqwlCgVqVMBgK0QkUI0MC+FKkdHZDT4 +OSi2et9JIpHmw2igcHDP5G6e3Mt3GwkSvDiIqF40tvMHvoD0Kh9TXlG5h+tD6cVRQnlBb+99ZKUX +56T84kVEW/lgV3mm9AzlfjkfVb2CfYtwymDXA0zsgpk+ReCcw9Tz9AswwPIViW7CISuHVzSY7uWu +arrNjwjE7CVA+cGoR7a2+ZR8LgZYISSvHNmKHZCwUQLmLQ3I1uERRNslKX5zeY3AwqTW/S3YcwTm +FiOxtE2FYwzU/usxpVMqfJjZw73swQPvq1w//rGbvWi9VwsnRxs1hSTlY4G81nANaA3OHBWulPbN +4AFKXhTiZfVAhphjZxfbnfLzg/CRrc23u8WH9gUBZ0Ui6sWU/EY9z18y4mrcv9ASedUZ1dQLh3xL +2ge3MYRAqnCZhxLwNiGR/S2A3XyGtdluSVHdZW9F7WIEf9PyLwaDKO4NOPDngwjxtVWCS/KQkL5+ +IORfpGo0b9RLVxrNA41e+ALiq0JvW9wHvS8Wz0UrabVnpjsaNiNzAQs2A2QlZDQ6NpN6Ph+Fire5 +0+NcuD+BOf1cJVck4nUjm9FX6Q0iagNcQEA3uoblczHALcUdf9eLYJLM3b1Mwaw244nu5sUOvZ0c +zAgiFJ+K0wXMBcVNI/ck+JMJo6xgsviUgX+mwEba/kpDvhFVrf4T+OYG0kQljtQgGKkSR4Y7WX6J +Q8O8krBwwVQImSB3VO6UNHsSgqGi32SUGL75AtJCnezifRfNB5ryM3H/Ah0ObucTsPD8TSX/1su2 +NUyoShBs8wQuxImKDshy7htqHB/nCGNnoIP7EeLEcOpPWVEtAawHP8PMFTIcLGls5ZDinDWNtJeW +MaQ9g69OoZqTAQJcmGO9ZocdlVTKHXq2mc9ugs+uZrDxjebuA0lTCqtBRLtFHYhIfvuwKAvoChVK +3tOKyoaebW6mD8tEOzAsTCYHo121CgH0A3SvQimggCA6m2xCB+Lu7iIrg+iGNFul3IdIDeH1Kz7t +xeidvUcS4LgQhZQj2ZXoKaSxOH76PH2FW/xpKrGZ15kG81tBscwx9XEpa0rPipKECkxDVXMTvrhH +uFPpyUFFadnN3O42JN3kgJLUEnw/AxB/m0xZX2wZFsKV1mW+ATvdwCvATB93oBQrvW5Id2Qkt8Tx +9K/P1Mr7fXQoYiwXhk4PfClE5Tm++XUN8BQpgU7jMbTBjbdFQC8cGFk5IiKhMK3JSHhSI2H+eC4j +QXdjR0SFgscJ3VTd3SGjwBcI5x/aLxISwHjUSOAnlkiQULC7rULBYf57pELBYagwQSgAlCx2K9X/ +RkvijATAhHoJ3CnNn/dEFFBz0owO8K0a91okJBTCvtsYJYoYCZPc/aOChFBz++rJgg7E62jlquWA +j5mRki2IiHda1EYOS+cAyig8jyFmBgCti2sQ8QW3lBKfHCaWXI2oNU0jzi+Nwoamo1ELEK7wgDh/ +NO5iGnTmMhQSQTQOz7VjIO3HgO1KW/4UpSQQ3JayGtPN8kle0y6xq7SDpdIvLOq8g8UJLUtj4eVp +LLHgGFQ0Ri5LY+HlaWzXEoQLAJjGYi7IVANCPw0HVIo0ZosJYkmKSER8AReYsAXhhvP5ArYgrFDp +ajUggLja27MQUSVcEzaS+6YgiGWnodoZvsBi06A8jQHtff0oaOf9WWEOTvMRPIZJmtVc+vVG6WWA +IpHdYoKKeh+DjltSyxIVFTejCE/cknKj3JjJIYVbUstucYrU/knp+BhFi8ZCqF0HBmlmij0yyCpT +NP10+TaErQjFpiu+pPZFs++8MxRt27tejHqttKNEovEdQ9YwvCNi+hmDX8eRDUIfXm8i2y8oHSdu +BVHQDzKFsXdNNoWxby14cPUN/szE8J/P0w4yFIP09v7+W+k1/Ijqv7xkPmRzNSR7/Z6JdiiUkuzT +1K7KsaaaQToTVbnVgofVtPSiFFdeoPsuZBcMMHZVHrfDm3FO8pSl0DTC6p7LmYjKrabquVxSHHov +qCY08sJVE6JXoXxOQPdABGemAOOZwpZc8yXQkKZ7GcGOs+aYhGR/GZPV620qmA7BpMbLuOhb4/KQ +ci4JXF1uQrYq5+iBCLb18EiKPtH7UiRxWutBflDH5j8V5lJtqdN6HPdChLcFgurXAsVoMvyS2SNu +thXDG9GYZHpj79P/3921rjWVbNsnyDsstFGuSV1Wrary1nIV7Ki0iALaIpE0KAoaYO/df/aznzFm +rSQrC0Ra7POd72x3t6mZZKZqXsa8VdLn7mkNqvcXrStwvIhf45scVYWjbt08uTe9cbdXPNjIn875 +P/Ymylbc9vpYab9br81AG++G5mUmz/YOhx2SVzPVjtvKfULFq2bZbNte1akNtPj+mSsffdow5aOz +129lDGiWJnd3ykdm35GBEwawsZ3th+S43eTvohybnU9tld69c/a85P1ucvNg0Fgz1Q== + + + jtvdvY+DJ/KBF3QGZ9mW0VKlEr+VegTJ2u5vTaRG19KbOfH4qX5fb/1L+RI49nTZOc8nhp3zQbP7 +tvSUeOs4ZRcrk2J5vM7CyLAyPWj+wLEfjv0hAuZ8dEZ+vg8edm+19WHztJlaVR9m7kwLOtlf7i49 +vuhbO41xON/T35LVDv7FpzbKGrnWaJdOfq3HLh2nBwuCMBNAmM7h/KcbR8t65q3vijzlLL+pYd+r +5vE0ziciW4BZSGrSjzYmgvS96LhlC+3Rfk6JPW2W4ztY6n8fNIL2LgtG+az1/OxTt/es92H/w1E2 +07jbaM2tar1xtHe83Ot2X3T/c7p4/P7sc/foNLuTtebWF1ZXg1vsvj/e62ZyB8W985UeQ2qtlddr +qpPIkXs3qQu9+Gd8dLhy8/n93cU/1daDyq0cKfFvf3nxdWzm4COyk7Hp983xsZmdvddjM2Z5fWxi +5WSGy63Uhhic7Pw87B2MpJi6udjtzZ8tTT9pv6o10CVaxncvHt1vjC+9mu8+f9g62b/XWpnb/m1x +e/nl+sPWqTqWTkW9OZhOOhhWXjDb7PXM6a2xyXtP87HZ1u2XnHEu4iy/LIbW2Mzkw4ekPh6b/v3G +U57vKZ/4dWx2zu6NzTzZXBmb+nqzR/sPZQdp+YwX5cx02Roezm+Wd3b6Prh2LI7RSC6kZ/b32dl9 ++bXEWDaJ+e5Bk7glS95EmygffexOlV4E66l6kSzvTNAbV2ZL7OAPe5Qs/ty4c9rvOK9WIpVa2T2N +/RB29QnUcP7UGP/nJlDD+VPqel99AsUlUosxLNceDnnvlF32tWVJGaYAbN15MTRO4YPcpmoH+P8z +qHbtWYuxdgYf8PUXLDeE7VRSTmvttR3Ew+nKLGrvVhMBaas9jOPv+p8ixr4NiS22du/durN/dHtj ++d5S/rHWBuV9hN+rl6v6N6wGdwEidni0MOR4Eb/03YYrc+z/jrFwnHwcfo/h0fLD290Xi6t798dK +b9ra1IMxkxmZ30x+2rnZD5q7+eDou1Xz6jwTPJ0pIbez0SrNvrOpdKe9OolHSDdSXOm8NQ/iqoGu +Oru861A+3suFRanaw+fCcVYuQGG52U+TDl+r/qO3Q2vrVFO5wz1beeLtmN3BWSS6v3vydVzOMnof +Y6F6hwpWW4WZAQp8H2aIlgAaosm98lrFg8NfE9bMfP3y7GKYGeCY+Pnerdatso2fwvGTo/K4z7pT +/Tz79v31qXK8DWiStJvmrMq0+9XSboq1ABdGoJWJFJi7J4est1amSkjRN1pmcfb1tIy3B2F9tvwO +sMy4eUVms8y/Hv02WX4HzS23Lr4mCPzpGyTvmfYvmwIZ8gmOwpq1HD3N1CdqCXoKzakWANYMBk3N +6nT9y4JafHzvWJ1HHcSXcsx0f0ombGkWNS16S1XPo7fS6346W0bqL3daV55JJt7nvtkx+O2PpMah +PfHqR+9+6+OwRLxosMNfi/69P9jpTddmQ73evV/Xq70PtfpmpjnK4uDBxs7U0mCItVEbYpF2szrC +2jaPayMstXTvWWKQJl6/n2dxNsJi5dZK1VXy9dv9eM256cxTw58VpT2tTPNRc0BrCU1+u/ABrHZm +/Svzy16CGQTH7VrS+uNl8cRnueNImZRTq7FyknP38/PB+GjrkvERPef746NyQnzR7CT9tuoVZycX +TE4qPczG+A+1OORHDZMI3lZFIBO9UgTbQxHgLNxPVQhM9L8jhN17T4cisK8/6TAUAfPsZm2MOPzt +9asI4Sqd/sv70fIfRb58hnbpGJH/obi+FN/UDOmKk0j+d6muYYv9bx18axdX28NO73IGSS+Xsuic +XM+lHh2cDbzyB7Wx9ubLFWwaaFlhUbPptZ1vuMVVRbnWPRmi5Q8NZh+sHY99fw9b/duHF++i17+5 +kG99HrJQK0+23o+Mwd8M7Heroni1/MfK85qNyc8YXMfG1o+ubWPd02vu4dPYtW3s5dG1bWzr+G9B +73kGnd7Axi4xke3LjnFwZVF+08YOz66nja2dirsmiV0kiUtZdP4e8jGK1Vl0e9fTxtbBSc2kSold +3ai2Dn/AsEd+j+nB1tHZNY/RG7vIM1C/XP0YZzd+cA+DPHn75s3v+ac5eTNkMXb75cF6dQ+dzrdj +QCUiXyaJTvfrdfZAtOwcXNOoOocn10XLztHpd6Hu0jjU+XpWyZN/yMU7Z2PV5fubN0aWt25KqZA6 +xbyO+Os0uxNFrUOiuqcPgySYw5quUvbt/vL5TSrlb9/fcv1bmDtSMs72b72+OUl15eDSKlvV5aOJ +1M1DKTw1WgpLZTxTLheaUjc3B29rDRrsb4btYEoMhW2l4/bzJlDD+ZN8yj80gRrOnxqjEyi2wR5t +GOmKVRs9awvT0jgrGz1rq7P9IvVsqqwC19rN1Fvjb51j+Vwx+9f41x710lrbTGztry+OmuXV7l+a +k/1Z1KrocrraKdx61pRPsfPBhrvdt5N/LhwUy8/mP4WbodK6Tm1aFN7l98zPjRCG1fvW89bf4ngR +v8Yoxw015Fhs3L+zMLdx6+67hQP/25e5F3NHr1Irbv711Nty0PR+c3Bj+oUdfnehqt1Oe6bSg90t +G5Cd5+m7DfyG+2R6tHvjZWrADVtDZn7brnA2siWDFnlUKraz71JvLXVoDzea6Y6jHtx6nh2MhWar +fdnDXVNprFU6wof7eb9/tO3Ks2yqm1KaDdtq6duGF16wnv5516ulq3DxBeufeL26Mf7NC9Y/8Xp1 +mkVdeMF6+keuV5/890HjLkxqVeudpaO96oypMT4Oynr39OwLX+B25rv7H47au391ew2dpT8Kf/i3 +cS7zkf9XmSOx3WlMzJ3tfTiezNpHjfGd1lzvdPHD+9MPx0e7vb+yOyDprDV/fPwpm5hbXV9+lS39 +58tx7zQT/tmL42xhfX2SU61LX/fyw8mHzqfuyOtbm0/aG6uL2Z2sv4O7fK9WO9gDnkivwqF3Giqb +wz+b/26c4Y/OFrF41lBNhf9ZHO7bD9Kfzd2GEiEY/LP5FxaP8eAjSP/O8uxJ9voPle3xA543fNM7 +Z31mVNOZIs8+N7Rqaq1tZnTTRROydkPjkXcmM6YJecZMm2bu8yIztultEbgugqOwm3mM2ULDNrXR +KpKFxjNgkTdd8Dk/RRdFVjRN1C7TsRkKHbL6HhYaf16smYlZ1bSFUkWczFrrp70PR/vZxPz83HsY +xvPj012+NknRZ63Vo9NsYv3lo531g90v3Rd/felWBDx1huNDrNiAUt5BgCGPBTavmj5El4fShhRl +mTeN8cpxf8qYCBnh4Hlwch6jbJHZpvERRoZ1nvuQmWawLsrzEBxPVKe0QVGx0CIk44LIGWwi5GuK +poWAEkUHbI+StSJIUgyUkzejiibDUinNpY14HTQRdLTUTNTY10KjTmmTYgvql1qLeA+0q5Xou/BQ +GvRvjQqiPJtb8qhR2rCaWNggGlOF52mKpvcFdAidOhNDhg07h/dwXegMIrQ2TxLUYDm6bsta5b4U +MV9uAi2ulHhdAwvndNK+vs2IYdDZaKyWUlU4JjTzueGahbKUESw0wEKLZmF1kP07XxhYsMvhCvKO +AI9YaNQp7UaExmzQlLtyuaEmYHWaVkN/UoaayAOtB3YA8+I6eOuoXeOph5G1+GWE+1D5Icjbo5Ml +BG9lGa3hurDGpvePUJLYde5Es7owQrF5UYiuVWEh+LzIeQwstaViRkWzcE5YP0sRUxv/NAZslCCp ++iCJv/YaRTYxmW2+apzVMdfA9CFt6MzlOrgq+MZotPOCHXhNjgc6PagDsQHiBfgNNFGYIEgCxNBC +0HCpDMsINBBTMFDDy4bFI6hE3uK8ybgOeCXd2BmXbZGFjQXMJQcc5znBAqgLR/bNoAqB7UBj1fDR +XAyJMEUla9i1d+KkUHKCD5+s3MC3YJ+5L4gitFCcHbgdoiKIwEQVgwM+UhALzztYMKi5ViZZPc6P +PfoCGAPbi0QZHLTpERlybs4XruArgvOyVjRmix2U78B2C3w6DCyqIP4SYKWwW2BLroBDWJsYGT+c +0kQyHNgA2WJT59YJD9+0CkfGSRJcmmb02AX2G7nPrQZl5uGD2B9c0SevjAqfEqDfwGfgdVEzaOUu +RKqE8U5jR64Jg4BzAISDdkQpqzVQC2JVNhL0tMPLsA0GRgRIYLdzyXULAIen7fhCQSv8fGjAZLRu +7W0QPPa8fMOAQRXkcEgAueZn4fDUsoL+4csp1uJ5DYFCjjovXFKaNkBXHMAklAXLPHdiO5CxhAAR +OixH1AetOgeRY78CB+DhCNCOFO+5qQhekSdOOULNnv+vRW7oP0Zt6JBeAulnMSuDM6pmQSORoxXW +0TILGpcoDwqBheTRlNoboUB7EHpUOfTpFU1CKI7SZ2JAA9PEUTFnHwPBGLbgEaYsMx4rYFyjSGhX +KVQimSqoJA1fgypCzCUYQK0WZqhDyEOC8xGKmG6OLTKhIlMaJGQU6CiRaALWPIKsrU9RtEog/Kvk +MJGwVCYcplCSQLjYT0qQ5AiFcSYRHL0KBI8gQd/2iJIENYV4Be5WhQJ+aYLXDP91ivh2YW2A12ln +reyoCDm9LiS4g68D3SAOn2tT8hihCA8wjaCYpAQCIA6T0zIgSqJBBBDC2q0R865T2qRILgpBIBTH +RIGTU1E50jUtp8kLT6xL+ADZ5cxl8CnUm+xshNIW9COiGiRDcG7Jg733sg4pS/Ce+aR8lE4QPUIR +57XeCIhIBgggUI7bgB8kCAZq8SjaQ6bJ/0cobVJM7mhi3hsm8FwbI8larsmSYF5QrUo4jBLaDcn3 +tEQGQ5SWk+UuAYCiyrHMQ8pLCyspfjRWEMYa2VWdIkxtiII6jsx5UMI4PBXQJglTQbCBIiDDMhyN +UCQeReCemF6USsQwH6f/55Q34BaeIRZAPb9vGL7QSExUCOb1F2zxBUExoS0Y8Bl2LUxFsJ6bxTrm +KQy7whBu65R2w0rAyXNJmfk0oYhxGwBeUgQboIVgJLJLcMJaeWjYMt3Tgt9B6ZA+YoQiPDzTYCbx +xCisAeDJ9WijzNgRphnTChsTixFKm+mDNylGeubcTCcsP4SZDiKzVWXgUZJeLjRqhDazGtiTbEJ5 +JVEBpY4YBWJHkLW8AWvrCX51ivBIPspIEst9Wbi+HNaKJ55/zYV8cu9lL1aLFkgh+BEudZ+PzhPC +KirdEEEZxwEDVBGsJ+0ffqKl2qhT2hIYCfigREvsgzkXuQA98iLBQkCgPC9p20KjThGj1SlvQy0l +SQkqBismFlkqwpBYLWONlCBPdj9CSR4drZTkokRZFzEdTVI/F/J0dF1iQpXQZlohOR48yRTJlXAy ++pDDLpiKco0ETDCSGQqrB+RXxCHE1JBSkxGKcNU5PwfCYWhiRcNnYFLeRZ5VJzEpdgKQPpdgM0IS +ZCigOyZFknha4omxKJ9JiZKOSYgnZ+a8eZn0jVDaieK0pAFq8CZraoRqorBwPnf4mQ== + + + JSawLrIutrQanFDyEsnNCAYSgYlETAyR3KoYUtjxTFOYY9oyiFYpAsY2T4VILtDPRN/rRMh1gvgy +DTc6JWx1ithUwkJEYGIhlRcZqiQzwKqA0SIbkOgrdl0liPKVE4NxeZR6VOUSlb1YWD/JBK4qX5Se +MUKRWFcUCYNET0IxRSqUpJHEpklqPQXCMk8hQIDNeNM/V5UiLIKk+rDkECX7layc2W60YqRJnnB2 +H3Ta2AhFzmaUkhQ/FpQK3ivJI9eFOEt06fmiUGUGPUIBj4I1h2SaAhmENYZ4+jBCDgHX8G+W66n8 +qlMSOOrkyNExKVCpfOCaYMeyUqKsZtfBJh4jFOHhqBiKlKBg6W0utR1YWTIwaC/vCIgEiccIJQUP +wR9pRUS+J3glZ1FEKqlnjeARKiSTeIxQhAdYSPUpdQrXzgoPg7RM1oWSdxjWIIlHlSI8JA2xklBm +CN6oXzSDN7ICkxCeHZUCUKvEPGoUwb0+xTsvLTbFOC5rltVIaUyQtAR/+WQeIxQxsRTkAZ6phYo0 +S0tQKLykfaFI2RFAuqzERyiCedJaZKmap2I8j6k5lBJCltZAQLhGEVKdV6OIB4ulF+zHqjLUGO9Z +OhdG6eTTQfo5jEXiC7JDhB5jUo+gRhGuYsFMfF2Q7FFiDFJ5ei97SCyKaAk+Ha5GSakes0JgCYMz +8SpKmEjYAkST6DTIgmsEQXJPiZp+meCbqTHHtA8pgeSMtEM4fQpOdYrU3tr4KGVBmZ5TUJ4hT2nv +ytcEz+ILETDlkTpHCKD43CBJhHFF8YsaQbYpsF7A1pW8Hdhl2FJwUo95iiGi/FHSuEgcqpS0A2YB +0KpThSSeTjN9iGxdFKnprlJTnrm8tHpHKO0GGyVsG0tB4oO0aVFlicVK34Z5ANsQ2FhepqKWQiJC +CbjXCNI9htAkO0h9G8g1imFpzROzEGb/Nx+ge50ixbJ0NnLJd1LOpC3LkiKUFblWTlobkuZLCT5C +aZNikRZK+8OlErwWUi+i/D9tTf7NcRANpWAywGJby8zHsM+bk8JmW+ot079QLkh+FChCOIA1bG3S +MYJUMXzeBolRsCRp2UdWMVSzYj1E1wPXYOAXs+yLFkxVgLUIeWzCIEGzWnoJqTIAZKRWFODHJi2W +xSmHTyw9pTuXp3GFlNC59TGNUUzq17A3yUZ7IVZdDk0Us4YSyqUNaCVM5ETdukD+F9pYV+9hsQ0U +g/QIYPCiLWkmSDKHmpTwqEwuEogoAtjZCgyGrCcSMtQp1E2e+iplDdJuUDkWECmdROgkqctK55iS +NDn72rZMAglX0iI4RyLvUJJCqnQA3wWKUZaJTMzZUCLKMmZTxbSdUQqRK3U12e2WSs/LmCcZIMpC +GKRzlkUz1sibMzYiWa7jDUUuZUCdIjZN+5OqmFZIcFNeEg6pqkzqTGDbsk9BvxHKcPwGf+A0r518 +CVsW01ElxahkXDE3JQXeKN5lQ0rUdQo4rE0lBVVp1spEL+YMAw7ylp0VMXg5zSil3Qisx5S4IOJB +RAWnJWDIGghN61dK0jrnI8VcpyBt6hsGu/NaEgXonkERe0XqIP16xcoXa1UwscMGgxWTiD5NGGsU +MQBEdZuyYaQKdHMlHXFWiowWOL7MDZn5h9QRrFHo9zhdlLQclUuihJQwGxm/DZIANrqjTBvSUqeR +50KjRhBNuFBOWH2f4LxghTT9CYQcHRAZbJmDssOUlBmTTYxQ2ufgtLQSV7USNg+ZACIRUGXU5KQA +Hxt0uVbJz3LtEoZVCcLBCQqwjDJJU/C8NCMtrEoT5VGkuIjyjwPb5aFro05oz6c7HEtHe3JzYna2 +MT6+trvffdHb/fCp22vsn+z+q5vtHh1xF90veCbb73VPTo973ezk4PjfpOAt/ZePjy89W278D5Kh +DXU= + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/originals/SVG_files/Audio_blue.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/originals/SVG_files/Audio_blue.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,1662 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + + + + + + + + + + + + eJzsvWuTHMlxIPgL8j/0faAZaXdoZcYzg7d2ZvVqLW/Bh3FIiTLZ2hg4Aw2xiwbmMBjqeL/+/B0e +WdVAAyhJFLc7gUbDO8rTwyPCw1/h8ZP/7TdfPdt9+/aPL5/F2/lm+slPDu9evnj/9t3Pbwh684vX +r3/84f07BP30tz+7WdLtDI12v1i/lob/8PLdD6/evvk5/Yp+eYef/ulXL/748uWbFze7H16/uP/Z +zU9/Br/53av3r1/C73Y/fvvq7dffvYMGtz/8+buf6WsBz/HFe2ixLH83h78L8zLfzO3nacUGL978 ++cUPP7z6//DXJa4RYPu3P7759tWb7/Zv/9+f38w3z5abGOAP/Oa/vvrtyx+2v55v4YPzWqjVctta +y9D0+PabH+9fvnn/m3dvv3n5ww+Ht6/fvvvh5zeHv7x4c/PLF9/Bb17c/NPL16/f/uvN/vWLb/7n +BL3PX9+9ev0SOnr/4v3NQt3e/WIJX+9/fPX621/9eP/Hl8CCWCqC49eE8vc/AC5Aiz8juH79i3uA +fPXy/XsgEV6IrDv88p/+2wH4/fae2iHVQPTNAv/+9De7X/3u1786wevazQFZ9r/Tb+F/823KQ4uw +ZN8kFMSA/7gmQ4sIn79tA45YucFv/37vOUMkYcN//u3L717RzIBR++8/k56+e/v9/Yt3//MHbiaj +gb/53cv771/D2NJYLOU23ywZv+lP0gq4Si2exbXePAslwq9jKzehWZs+Xi///Orlv/785ldv37zk +Qdm9e/8VT5CU5pm/829+++Prl+9+/+bVe6CsIKjxqPzy7bcvX0N7+/zd6xff/aCdXPp3bvC7F+++ +e/keptbb1z++p1m/6htg1J+/+MtLnDoLv+DX379887u3/0A0PqvxtpSSb8oi/wKHy3pTIozuSq+I +DRjR5M38Vhp5Ro/IEJW+A6bWT34D8+fX71599+rNz4XC+vXfv3v1bZ9TNdys/I06cbu6v03/MrXQ +8ffvX74R6mEuH37p5uZ8+8uv4I2nN98e3t4j93/A5Qcz4A1Mjtdvv+Pf2c/0G/j4j98z9fT/r2Gg +fvPu1RvEOf2KfrN+/ZvXP8Kv/v7d2x+//8Wbf3k7/ZTFzu/evfgGmt38+o//4+U370F8CKD/9NWP +r96/vH3x6vuffRDRb16/ePPi3Q3B4cMMfP7qz/CbF0DKDX8MftNhH0d6fPkvsPT7Zxl6evPnl6/f +fv+yww3y4s23N//44t33H0cNw/DOYaD/6r+P6O2L938CKfXyzbc/GFn837GjDPs4vq++wUnx7mb/ +7scf/nTzu7dvXxva8VeGXcAExfZ/He/4DX3gza/fMIPO3yQNtm8CgfBX9xZo/fAb4Jd/zdgPL16/ +fvXduxff/+nVN5decOH39ib+3adMrL/c//Ht61c/3Pf55CC/efHu/atvXr/86i8/vH95/yFsyI1/ +efXmW5iIJHQ6tW/vv0cV4+arP734/iXhfP+nO2r5lSHMX4Ng9KLv2bMPyMQQb/Zv3O///t2Lb1+B +uAWlaf/6x5c3v4X/vnh9o+CfTZfBIO4B0bfTP0//ZZrxa5njnOY8V3jWuc27eT8f59N8tyygLcQl +LXkpS13aslv2y2E5LqcwhyWEkEIJFZ41tLAL+3CYwjGcwl2c4xJDjDHHEivoYy3u4j4e4DnGU7xL +c1pShCfDU1JNLe3SPh3SMZ3SXQZa8pJDjjlNOecCT81rbnmX9/mQT/muzGUpoAEU+DT8ukz/l3am +fy32d7n4P9Qgg32P8hdII3bEOU/EFfyr34v8TfJTAY4V4Jl+X4l/+Le5n3bwdw/fdxP9cyD2HuAv +Mpm/A7OB3UgcfEFnQHWDr7j0H/7LdHd3d7o73h3u9ne7uwbPelfvyl2+S3fxLtwtd/Pp7nQ6HU+H +0/60O7XTeqqncsqndIqncFrgXfDx4+l4PB6O++NuOrbjeqzHcszHdIzHcFyArLvD6XA8HA77w+7Q +DuuhHsohHxIMXTgsQPrd/rQ/7g/7/X63b/t1X/dln/dpH/dh2i/Qv7vdaXfcHXb73W7Xduuu7sou +79Iu7sJuAVbc0Vjd3VF3sENH6hR2Czu2s85h9yp1ETuJ3UzUVewsdhc6jA8iOZ0m6jn2/UD9Rw4g +DxrxATmBvEBuZOII8gS5gnzBZzbuIH/gawImIZuAUfA04tVK/EKOIc+Qa6l35vzr9MjnuH2mc5Dw +6DHP/vyZLgB35w90Jt385Ov9O+hTwa9KzwpPkwcGs+zpgXkBfECm3lUSHRVEBAiDSE+qsGThw/y1 +1jbVBs+u7itMKWQijMjdSitmXeABGbKCoFjTCit9pXeudcWvtsIsWmGqrQcaghNOjTZPsLRAJLXQ +YksNhAOQVxu0BtNtRw/MzwZzGMeOJgLMKliEIMRgJgaYjxFmZYK5iZ0Cymgocf3ROgz0LCQC+Ukg +CiOIwkw/4fcEYjHTU+hBDhTsDAnLBv/uJvphjy+F73v5fqAH1ht8P6E0xdkcSA7Ru2LAL5CgIGHx +AVkIUhYEXlgnEraNBO4uwKIEiXuE7yf4TgsDZC9K3wWkL2JAMQuCFMYE7eJK0niFvjeQxySRH5A2 +yC1ePsQ/5CPyE/naiMs4noX4nmAEIlCEXZ1xcGCIjjBYBxiyHTaFQawTjWiG8Y001gvIyztclTAT +DjArcAQaTJQKkybD9ElAagCGzrD8cZIdYbrtYaQaoKloJU0g9xPsAAE4P4N8OMGKPMD+sAOSVpx8 +sGtk2F8iMG8BkX0Hi/4IW8weBr2lFd5QYPNJwJ8AIzlHlku4pumJ9gR5aLyOMz+y2ETeHEhYHPhr +T8+OnjYh4w7EjAPNfFw2IFAzCdVEghVFayDxis9MQvaOBC2K2iOJWxS4+LWbSO42kr0ofSuvRpDB +KIUTSWKQxfDQTNvPJJJRKKNYPpJoRuGM4hkFdGMJdkEaXHjaY59p+O/6SU+99EwXweWRTz5/uqz7 +Z5v2Nx/4gZ8Af8tNnm9rixWsZkAApu/Xn49g/wO8Pc0gPgM2LanVeBFLCTCR0SRfYWlTm7bOsOoU +Y72NbYk3Md+2nDtd10dNFMPSWpaCfiNQwdZ0EW1IdUafxW0BJTGREwn0JWgsaJdbVLduQBXr5F4Z +L9C6P5qirRrwZRX67sW3L2/ev735xz+hGj9t/g9DFVhpRkoyiCD6IVZQUc/FJ5DUwpLr+ANSOU46 +xHOjeC52lj8+/oB4bCKN/LseShrmL0Q3A7qab65HnyH8lIH9e3Qle6toAyCsYg+ZEE0mROeNCFXx +aQLU6biJtIpAOsZMuq5soAe3dfZtEzZOkr6wReNmPcP2jdv4Hjb2Bvt9Jj1gAd0A9YQdbK+obkTQ +T+5gB0JTAi2RMJ99bS2h8wYk87sEzaJgg2V2F0S9DmiRDEo2Whcn07P3g5UBmvUkKvUymBpH2hrp +OxtpTeylLHYVmlpRDDF9PuHrcX0l6xHtR7YgD6AroCFwJ5Yk25JmTYrmu4rGu9F2Ud+dnLKbSNkt +pOyuqOqinktvddop66aNtNID6aOsiwbSQjNpoCvMkB3MqwPMszuYdQvMvwgzMQMBFTb7hnv/HlSB +I/D+DhSFBZSGCCpEBuoqKBi8l5sCuJACiGY4fiVTBamrrKaTMojmeSMTfUdmuiiGZKzDM+GwRjK8 +Eo1XItWXNVPE6c0G15GdLBNcMEdaPHfUrVm6FuhNvNgyz42VLOUjeR4iqdUracxHmI6B9OAqngZ1 +M2Dv2AijaclfMFV52tIEXmQ6k3JMNiSNOz2oWVxwHfQvno/sIIjU+2yWP1BLHyadlLXSgr4KUktZ +MV2wJSmnrJ6igsoqKiip9OEP2spddHTBkVjX5qHekSaPzyrafZXhxYHmIecvnAg8KaAffsSEjcRI +sRRWmQz7wV+DI57MYwOKPHltRr8NjNlEjpsI7TJp4bzy+qob11xfb2xlsn052JYTmZbBVls3LHm1 +7bZWpdiVbFWyTalWJX5kncioVLPyQGYlOQnQrKSH7cpAnE1mXRZaxVWsTFzNbGnupzNTUx82OWcx +O9nwZNOTjU82QP1DHJjknw9Ozc/8+ltFuNi/izn2Ft5bJvLrRfHvkXx020//qdi2VGmLKrLQq/s/ +ufYm9lvQ+NCaKLIa9m4l4DLIznVpm45zXhbZZnjSw5SH6Q5znreWJFtKs+l9omkdbEqziwRnMtra +R5nBOndl35lowu5shp5kTvLmk23z2cnmcyRpfUfWYxAJzVtQhWm+QxN0TxYpbUOwES1kvUayZgvZ +uCtZvTsyhPHrhMYyGc4LmdK4rWRyo+GaXafjSh62vegKRxDld+iSI10i0IMuO2QfSQVy5/GapY2F +lJG9GuOnI28GR+/aANN+b448deElMe8XMehPYsSz81Pdn0Vs9Sg2OjtBT5MZ5juxx6t4Q/OoPm5U +x50Iexb3XXEME0t91BvJ93IU6T96XcrG6zL6XU7kIjuQu2w3mftlhYnC/pdMUyeaF2bBmUzWNPti +jjTV9uKR2ZG8W8kvU8HmITUnm4MmkpMmkKNmkVXCO+tJnDZHctzwI56KsrOnTSxVWR81Z67z5e4H +X656crsvVz253Zc7qy93Op7Mnau+3O7NbebN7f7c7Dw/g8eHvT2Tc/ZccPVc8POce3oGX8+Ezp7B +3eMdPs7pQ09zfh/1/aj3h2ddHu2XaK6g4BxCi9o0Ztfocxoe4tQk/+D4fGJQwMICD0UFpm1gQNSd +rcJjKg9N8pM4F9m1qDOb/IoTTerFpvPRJnLTCUwzN6prUZyLR3MuqnuxsiI3OU3uXI/biatxJVcj +OhvZ3YgOR3I5ktOR3Y5HmgH7ibyP7H9EDyT6IAupVIk8kZG8kYGULTaNUO3mCc7zkieRDu6ONcDB +cW9CYR6EwkGFguNbNZ9sOpMHxr5JhICKAb/+de3Pg5vW81KctZ6R0wU+ei4mcdoGcq17Hu7FedsG +5qWpe3GNY8yrvSnIq6jG2VRiVojR5r7b7BMH2SnWYZd4fHBsExqbaBHMHwuNibu9z/6u8Pe5f2Cx +roOn7nR1po/znWe7yGYaHxybHYnc1UYllDCJC72PSHOjwWPBDvQTjYJOYZu8IwNJH9+zwmJRnmUT +36mmuoxK+J0o4Kp8AymT6N2qcXdFxqsyYRPPWZ0Z6kxQHIjJ7E/VbVi7WUm+7kjmHkgOn8TSnk3J +YXs7m6KDqs5uMl0H9wbcI1Tb6fpOog3GdB5ReVC6wntYwLLSxM/elKeDoD1atOHO1Cl9ib4oWNQC +Y5PyTn2vvrtKKHOVjZCp2MkGyUqYKmJH2URPvKPeiV6mulnXz4Jsw0meLE9xGlvX2lY2jyb6Zzco +cU6Ns6d/WdCUDXzWwKPo4NW08MNGD0+DJr5XU9Rp4rnr4pMo40eJbao2nk0f39n0vntQI9/LlKZQ +5UYlH1xBl5xBoztINXJ1CcXJeYVWmbI6YdkxtJhGnp1OrhPr4DcMCVm67A7J71gk/g== + + + WCjDY7WQ45G9L4PjIJHjgFwHk2R77GkinsRvpP6D7kHg0VIfwpFGrGd/LOZGcDkgVbx4e/MneI9C +MC9etuFch6g1+xWOk7rxJGi9yEam3jz1MXgvQ5P49c5JN5Fv9W5ygWwNZnfXwxjS1meV4LZ6Inbr +vj/TKrqkrFRdNkOgTJwV3WWxmOOiP+IemujbIKYpgyeCbC9ELuXvOK+apu6oG+hOXH/sBNKl1hda +mMztUx63zmBAjjYSOAbej4o+VGH0uIX0DQS/hnUm3U/irenZAOyeOU5upT20XezdipPtwjyV2exg +WXaTbBayUVzYKnSz8NuFW4d+x0CRPg3bhm4cyW0eheyVrQjf2bMfxfgkjnc37s6DvxMPvvnwxZ66 +5MTfD/ZztRSYOIl6pJbSaTCjuyFdxRxSU7ob0xrqFotnMoN6NKk1tH0e1t6EtMW4VvM6TxaYcaGZ +D6Q3+ASH4qM1anJPbHMPKrZa3l7R3sn6VnW7ihTIZoizKS6mi2rgi4iT2SLdun0e7TnYsx8ellC7 +ib6RWe1j6mM4vGdUaVaVZlZJ2McCPy70M7k8q4Pt2bqHN5dz1a31ampAdhlYYrtPZr4Hl5C1qJ7h +UqBOzqI/ml3fbXux7ydZCs2e1Z7OwWJPdk+6kAACMzy4Z3HP3J9NGtZpeI7jMx3Ov/Znz+6Bp50/ +pDtyGOQ8588y/h5I+PugVTOJh+LjBv7WuhntG7PxJ/Nr6VJTMycNWUTdk6Um69ZcXdjumVwW0d48 +VtWZqnEwU73JvzdzqFr8Jk0XAjicX+RDOBLEsVwjdQB4F4A4ASaxYU8yt8gXINYs27PsEGCrVi1b +tq2yuQdSdxJMY9gNkwmABrBrfRx9LWFZPSDVNdEPsHUGOtUTOIOCA/8h3KIONCYUXBctJRXUZYYG +2GxOuVG6SWmNcgHINMcjRynPDV+SYWQCpgAsjNtSFFq8DTATOqFXxSo5LgFmJiIIDXAhxtDmJQ99 +X5ZaEFKUCQG73vN8bkq4jTBPfIrLNdESpcsKOAcEoRRAMQxbhr4iOxohp3M+jC22W9zWbmLCBCBH +6XXREqVfPp1SuaUUoQWZk8I1Z+oWNafArDWOeVNLWNPAlUb+JPyhhpxoRGdkizKi3sIbMG1paS4T +5rp4PyUh5vmrNy/p2JNlxGwhPdtpc0QAo2F8QOBgBwTweEAdDMg7OR4QKWRf+vEANBynHrffWBgn +sS/iJqR2yZh3QbUpn8S+2FoXhzMTXm2LcxPe+acmSz5uW0t+cE11O8P7pvbtLON4umhxqM3RcyUO +3dZ3mRJnuRLo51eXlZoi7LjaScDAOa/MJulWiVomSaIT5bCi/sDuq5ME6dhhVcjC2ImDSqZCkMmQ +NQtCJgSfGZnl1Eg/N7KSXeq8CzpBJklxzuJicLPEnSFJwymSbVZC8N6fyWzSR7l/Lhqmq8v5IU/B +yTwFwWX71LPcg5PlHvR8dnUK2XSatu5ON6vCJttgm80+5LJrUsHkktnzxpr19uzJeZCCs2a3ns/j +RBHdCPMC7VW0U4/kbAw0IeqxfWwqjJNhdoeI+nTQNPijTIZ5GgTGOBm6t2lxiSpF/U02JYZJMT3g +ExynxXZi7DdR+p4YlqcLeSqjiFk2KSpDQtjWabTO01bu2EzxoufyZLk4XSaXlXJ29mHwk/fJMjo+ +nKcc3R4YucA5grMDhcpJgv1JJkf720lQ6bmH4YFsr2qnuegc1/kM53S180Ny0VyokrhGE1m3P5y+ +h4n8awuJMtz3WIbdwTSNtNdh/tQRpuQCUxETaJu6zmDORZhrK8yvQz3BZIowiSqGiA7rCaiNMDcq +TIcDTIAFhr1QnscRJEEACVBpXE+wPQQa0R2marilvoLkPxxPYIWHCVZOoXSLA3rh7xZKpSswI3fo +uLqzU13+iNrnHFAbjNXpmsfT0EydPn487UNJd2aYWvx5uhiH0yMtPg7nj7OcHWbpJ1mmC0dZPvEg +C4U/OfjZ4jpZ3DNaxPNER4Y4z3ilk0UZJillG9NZpBNlHO8p53ilQ0186AkPRMFyuqNziwdKQe7p +vInyqxbNLn6aCk9T4WkqPE0FNxWcu2ot80y+BdDOSmtkk7ecpBYJ2Z+Xzrd82sfkDMunncz6klNd +n3gy5au3//Ke6wbd/MOr7968fE8Hjy5B+5l95cGkPJiUB9MyzfQImx/f8pEDgudkynoLWme6qfEW +FNvwSSNz6fM0RI/57G3JS0hYGycu+IF4s663NYb2aSQ8jObxlLT8eTNz/OSnTJTfv3nz4v7ltzff +CegGVhzMlItgmo7iu9lUX7hoM190sTxgMk9n9nK1MzL+NPiyyZkYsyZc3sRkId3iUiecy8WFdbvL +pZpZfJYKtHW15LNcoCG8K24WMoofNmZ87YjzehFR/mqxiF40omANiW49VKsGwUbyjjw8BzIlejkI +LgZBf+Gdd3IYHc/D4N8wgcgNdgJdz57zuXM8dV753DnZITsS1/2Q+ckOmAc5ZA7ifaLT5YXO1mie +B2d67Mn+5qPlmN8DewQdH9EzRfmBo+PX2JL9jjxdY0v2O/J0jS3Z78jT52/J/ezStnDFtmzFtmjF +tmSFq1cxDQnOrlzFkNo8W/Sv5zTvh6C9hu3L5CL3LnY/RO/7MfXdWQB/G8KnWiHnh9M/EsfnRHnW +KcciFpfOmp8fEs+byHePfcdpE/52IfCzILjmpx8vRsIlFj65YHgPh58HxHtIfAiKu6R2Ge9pDIu7 +wPjpY4HxUfWCpd/W/CGlBjaxpZV55dgUyBv8AUMn6aKWdC2EHHVrIL8SxfHWebmMLMAap1PiRX+Q +MNRlpfF6KL9szw7rxT0bwH7P5rElPXpvm8VO0rwoKUTOIqlr6tJR2tAPQU3Ot/VJJ2v916W9kX2/ +HBGieBBtVMmViuJIkJaJapI8iI5c8n5NpJrsJfITqBxULwYFCgmpIz3esyMvGLtm7fgUUWaeyWjJ +Vv0Ikk+yOlne7DIk5/b0XNJPJgl77CyRSvNg71zyqya9asKrT3RdT23Muvqk6kCXyv9sCgFNn1L/ +56GiPyxKP9MMv2CF04Y/ffmOL1VJXNL5wZL/V9tJdS/V3VRNXDVyOeu/mJ0bJzZ1zdhVc1cNXjV5 +1ehVs1cNXzJ9N4VDcplb8JKkphw4vq8WIur9KPUwBWEB7aJctjW/FNNo7cKKWjPJ2WXBsh0+rszV +PVwBjZlAD9aUuBbKLxOf8aL0jGM9u6Y++uGRw07uZ/8chsfndB2n8b+inrtnXOR2/DIOSaiXjv2P +B/9Hw+RO476Tnf8vl48n+NeTlLlQ6eZM6fmEZxq1pPOH1umoXX+Ccv253i6fvv60Xz7tl0/75X+a +/TJmkBB+68iwwH3eFm0nXNAJfskpUBf3yy/FxPvll+26cQHQWq+2iyu+v/W9PF3ezFMcTSH8eko9 +e0o9e0o9e0o9e0o9e0o9e0o9e0o9e0o9e0oyeco3epoKT1PhaSp8VuoZ7rmflNS1oE3cviArTBA8 +NsNIDyPm2xmPfX1G8pt+9AuN9HbZSG/OSHceO1KRVT0m3cIM6+hqRnSjWjVhLhch+q+ZRaT1qkHt +dV3WcseUoruhPIQvwuKKIk6Pr8T7n1e75DylIN/ZTILvG+fqh64BOS/n/9Ea/dMDtfgfE4M4DyqA +POjpGNukjLPkDL624WOe1k8U0tMDvtbPFtHTQ7lI5yKaM4I+VJwjWPbPSTr+gfIczIRpOOt/tEyf +8+IccahzeWepPT2xZ1UOFcvp+WCtywfEL3CmLOWiGJXcEJB0FU+8UtrIkkv7cJLuFyIcfa6lzAv7 +cdc4OnTtpHOiI9nmJ/2Ix/ULEX6ZKM+X/a0Axssln/ytT/7WJ3/rk7/1yd/65G998rc++Vuf/K1P +npUnJ9vTVHiaCk9T4cv8rXbrxroZRh1EHMJLtyQ8eMhoGm5FGG/CHE8ajTdh+mvchqNG08WzRsmV +LVxcuVB/J4dWL9Q7OaRE6OSq7/upMpYwjL6E4TBjdM7YjJkenDJ8EI1ni86VD80UmSeTTJQ+TTjx +b7yGrs+P7ewY5wbMjAknBs0KnRN9RlAOLTvpGqxmnARBkh9xDeMKzjDcCwyxls5vZ+fGzMPk/Ev7 +SdbweJlKvljsdSz0urt8o8oky/yh2xPOR3G4N8HdosJ1WXfTQ5fabq611XG9dMhwkAbTg+IAh/nj +4mBnSZ4iD6aPCAQvErxQGMWCCAacAdMFweBEg0wFEd245gMN/YmWNQ48DjldmHDhvkVfVnQY5+ni +MPdFOl6c00f5wVsyJhtqf3GOW7Tu+uJt6VEe7158lMZ82sj+7RUZ4yUZy3DbyP5sK4DRn9zwP2Y/ +cDuCuwvD3YMxbbJ8L+wMw94w7g5uf+CJgIcnDnLq4kNTAVQGVBh2MAiFFIWFlIQDjP4KKySBYjCD +UnAAob06+XGC7WNHUyjAW040eSpIioA7/BHmygr8jXStxgGmQYWBj0AGXqGxgyHKMJIL3Zixg/HK +wJDFziQ0GJAMA7HQlRj7iW7DyLDeFmA2rzMUpcjgBZiLjEW2qgRFZuo1nszBLjuJd5Oxju/zHJjm +eNY2hxfODyzIGYW/Abtc3Qvdz/Qhh2Pa+Je6d2lwLU2PdDR+wM04+qWnz7tQ4qJ/mjyL0weuk3jg +MokPXyo6feBW0fESCXev6IeuFZ3k4ghxGZN/0DuNq7qN5dDHHR32CHTMI9PxjpWu+NjThR6n091E +13LyVZyZruBc0XeO3mu8XUTcC09T4WkqPE2Fp6ngp8JnlY9q8+0yt8/LopGPfl4ZqTLfptjKF6QN +KYZPzBv6rHJZXxpgLpdrG5T1Q/WIzuPAm2tlyC/+gaU1fWRt+dW1vcPJLzCLDE8uRHO5ItHFG8o2 +Eby9rbzTpIFhF44Z48LnUeGxMtEmJjxZMK/fRLNaTFgPBx8+Fq5Zhp+0uNFY5oj/F/r/Jvkx2neN +m0RSTwvXPBKFtdA9uhxP4Z9WKYNU6Fwu3aO729RE2lZFOlldJKmHRJWRtCoSf+/lkNIk1ZAqXaOy +k1pIGoLkakgSl6aLwbUeUpSKSFGKIaHVg7r7bqJYzo7qIO3JOOLw5Cx1kBLdlPRUCekKlZAG+/TR +DgpxT1wuo/QZt8a6OjqHqVdUstyq7Z2x5zfGzmeFlay00rS5K7bfFOvLKw2+z02JpbHI0m46q7M0 +Vlq67P+Uy12HckviSJucF9TVXNp61C7VYPpYHaaHajFlX2xgyAL8UE0mV5Xpcl0mmAnTheJM/aqi +y/WZeoWmCzWapqFMky/UdOkCo8VXirhwjRE804WSTf42I5l7/5kKOIHUmNdK1ZZqSOtFZAsn3823 +JUjK25pTm8MDOXTXQ/llSs5aLio5AH70hRlc8kFtlEsWCiXEPJR4o3kJavxcMoEGI+ghRMUsKUa3 +TehCVIM9dVad4WNxvo9G+R4bMPxoyPAhRB+LPZ6hGpcZ7Gx8ocwygzJA1wXNc6ltWA== + + + FZQoRHmlMun4ipnL8/hqGP/aC9uerZFwMf80xGHhfCy38mJpz4dSK2GMp0GLHvXo8SLHMaFym1Jp +CZXTcP9vsSv41qF6ymgPgzXMNXLO87/qJvF0a2BsTYzByJi2WV+OR55Xj04WnFy2YBm4sxNPAGcP +pTFdkDrnkiV7udcxZfJoKZMPJU1WuRB1h9GXng23zYe7nDg5Gl5nLJmGlNy6214PjWlSC3W+SJdx +EnDnXGbz9oZUTWnm21EDpXRVOuNylPMtfLoFk5dPVIUnlTJBd+VEC5hGkc6yNODTiTiTgBcrnVu5 +g86S2Q6dOkJHAlBfgeY9Zexhut5KdN5NlMRZgF2cwLn0BE6YyMfjHci2CHKuAlP2IAHx7uRwl3jk +Pkm7/7hyP31Qu9/o9o9R7aePZSNcTkagzl23a5hz/HDXLpguH+/e9PFki0vd45H7RMvsYx2cPtUy ++1j3psfkkpx3b+PowzfiBgmqSiuJ6unUFriITg5U7Uc10zlAt2gz3VyWNxbqvhZGvtCuxYWQgFoF +cgIPcWTY3WlvJ13rhpx4XFI0ITZsDPxdYr24M18L4Zdt1xe9edtCpaOeu57puZGKm6H2eO6L36Z+ +n+I8mRf+UtXyB32EruiZ8w96vdfrvj6G4OMIXpH2xxq6DgxTd3KhBdeloVs+q93HGXysgeIN3kO3 +SBpyNCdaFcuhzT7PXkoQSl3wReqCJ4t9lEnU9Wo1wPcu/f7kPF6B/iajODuaGy3n/Ser/J+S2len +ayb2eRPA0+ip9HR6Sj2tnto7f6rQnyt0VA90e8o97UR9p1C5ONK4oXJD5/7CWUC6Ovn8KODeMu5W +c1PZMcDNFd2dZqD6C09Jf7F1Md9GUIXYPmoFFgH+UFoei7wVPC23ktRG6x4jGlSu7LKwvxrGLxKn +MVwSpwD9wns2T07unB2qmlxQs0rlSB/QFHH6pae9dmcHfBbUax464DOEWx9zvGhLgQ/1ls15M6Jg +OhNwSoNSwWcTryfcLlR6fKRw+4/MmX7Muz/57dMlIXn+/o0/E01Hrs8Og0arFcy6ZayiqFc2V70L +94Pr/nooPzP4i5ce5/AlwV/B8GWC56LbJY5VFh+V6Etpvo/K8n1UsugDVtuF9MDHJByeZc49hM6H +5h6TnECpCY9KUvlrRud9migJE7nLc6ObvJGDYTg0L37z8x/8DUbtdl2Ga82vjvkTF978obP3n/Lp +L1pw6WKEIF0IEOhXrzwdLLmT0zyzc9UXSQTlhNBK8fNVzYMeRe/1zSV0uClafmexc95KF7lbaKEo +unr+40SGT5RFVmS5FYut821Dq8TW1cbgCPuBFivvxhprP00avuN+8stCkKLB/BXlhDg/mSQRB+L5 +ZiK+m4j38XUSW0X+S9/12qJGFxfpBUa84bMFdpAzxuN3+t1kTY7u3/6cLjx35P0YApU4bl6riYMu +dxx0OTWNj1b3O0qXV+kDq0ukLE0fMYv1Iq8jeR4fKJ/gctHSZOky20S0SD5JTZPZ1teJD9XXmSwB +LV+ssMPO6AvZZw/knu0mccXfyVHkoMlnknt2kBrl3df+keyz6UyGagKaSlKVpSpNWZ6yRN2RyXYg +uXr0Y6y6a7Lzw6sF1pqlsxwtcWUZ9Ohs+SptksVkqqysFVXyNTlFb+naOa36JFkp/th81nyrlVx3 +OnG6EfDhvEb1rehUgr/ThSSsbYbjmIO1rcmhE0tyryZKveq5jTyv0PV/Iv93oAmF02lHU4knUpCJ +xPcmHCl+EWj61Emc9/2kM1a70JPORc4535FUQp84H3O+Q384jHaDET5qwfm/nRPv/+YIlwcemsCT +7G7q4lJHVzrb38Z97dKGdtBLOcb9bHF7mI9f8wLzm9cqJiObjTs1gu42VwmMNwP43JYxq2XMZpGC +VtOQwTLkrWzyVfwNYmN6ypCWMg35KONtYWP6yZB2MqSbDFkm05heQqlN7DEaE5zYkNM0J010irIp +Lj3daZKMpztJuDm6vCd2M+nFcpz8xC6nMQVKj4FSItQ05EJpPtSis0BG5uTyoo7yln44VA6IPh1M +/ts/mHy1XJLLzoxxlD97nCeXz/nlIw1jPT2uotwHxnoz2tNnxQ4/MN7To6OHHx3xjSW71nnBYFhr +sJkEulYDdoK4kmtHHDqz5NAsGNF7MCvnSzH9p8vGuVzYE+t6mpXqPCW2y+sW3gvlFKfq7szePNHV +RrPtxbwTW2L2tMnJlmxsUhE0CzuRJaRX0la6DWkV225n5pkYYZNlY0fSfEn3pbnGqi/XEttRkP5I +ltOJVPyZ7CdUgFEFTnRDTsGiPBMlcaAuvKP5fZQqY3wiAfsf5ElUtQeVYlSLUTFeabVweSlVj+ne +5Jm0ZK40xXWm8MRCpqO/XGjKl5o6cDUyq0e2yBkGTrPJE2XarEOeDWfa4LI/z7OhTJvRMI3mauex +U+N0oTH78Emq3KscTRfPUK2UGLO7FHDYnp6SMx5ROFkns1cPyDpnWXjb4vDA2Sk9ODXcMZ0oq2a0 +Wo92t7SarcjKj5SF5dypaTg35S1XvZ3tOJyaCpTZXShD5zxJDEzXabBcV7lI67L7j43Xj1+X9biL +sx68Tmv6yJ1aF+/Y+tBzfv/Wh+7desRtXNOF0rWPKWb74DM9WO32Y0+9/EwP/eKBarn0jBaJslZ7 +r/QpCrU61NxYLHasZoYlwn/i1dIPXy6NtsL0mMulH3+99CFPF66XvsIF0595xbQcdvAFRO6mC8Ul +fHmJbYEJKjHxZHv8LdkeD2RIZOBAxEBHwxDZWNq3pEppB1kVSSz1m+oDquj1UP6n00nLxcgJQC/W +mieFhjf0nbkLLx+ClnzgC5u5eqCPlCr+yCPQemdmHTZzn/NNp6An54jurmja0GVLX9xtmFm80rK1 +m2eaD0efUJhP7Ovi1M9efba75TWZWnPLmTvjAda9ZVTf+YOsXPco0ZoutLobrfMdrfjDJrs8UiYy +SodC+cib22tR3k6UTC0uWUmpZr/sQbLqOysr6UU7rkgpnlr21aK3ds+3iE7ssP1f2yXLm8nHKux/ ++K7f8wt8Lxy3+3Dl/QtH8fwzPahXPvR1fOARX6Kc4qPef8rZ1sfsO5+WIv6IXWe6Xv60HGyVmkG0 +7lc6XNErS4UL1cQOrrRUle6cl5aibk1kZGHPeE/l/lmFKeoj97LXGNteK8vdlYtlJ+zzpuKUv1uW +ez/UnRIenCTqurleduJA8IMbL5ZcwvTnluraLu+SWOgf0xESV/7/4F73hQjHTbdBLynTcMVTK5II +wTt2050bb1alpAm+AuAjWsGXYvyiDbpe2p/rl6YwPt0f8HR/wNP9AU/3BzzdH/B0f8BnK8b/vgif +7g94uj/gySn2VDT+aSo8TYWnqfBvf1/r44sYjue8P+lj/+n85e3imcK2OVN4MkbvrcjeTrIr1015 +6WI/XSo1Tf9OQ3bn5+pYFzTBIEef0WVADgMplIRGAKtJmiPPClKjLJAjafqkHk1ywpFdA2jpZanF +wVnxJ3dMvFKSxt4yly1vmSgz1TValRdf3UW9/Zp5PksQXz3/moXO7v+KRwHZLt5R/PQgYf2ThPZn +iwX0aIAG+oukfX482P+RYP7H4vbnsfnHxOg3oXaW358ppy+IaRLS05fXTNyx6bGplD86MbPJP5WA +KgMPg/+ymCCM0+C+PJ6lsalMVKm4vUSBZOMDfk2YwWumM1HL0vJQmK3xEUW7IxR+RaCPuQ6/GCUL +yFzm8e5S+EBoxQs5PMmFJeLgB6xJEcplcfmlmL5MeF6sb9HG+hZWEFQFDrsY7vRIjvM1eT/TeKBi +UyZ662G6VCJ6dEs+UCIafQWT+ZS2vknzJI1y40KpqG1FWg7n7S7Uol0kPNrrZ5XJykPtnB9xjJUm +d2qHI6Y7ygKxqKlIUZKfE6WRZIr9cSpUs2QoiZ+OPfoiCXPpUPQFGfMICfOwGjh9XA/U+573m8T/ +sWTptmjppUSd0zbDfyxcum7y+tOQtLNN29mUL51cDn87XCxgyjGqPc1KvcaoR6u28SpWYx++DEVi +VpMGrYYbUfqdKKzgbuNWlyJXrPBKnSOU+17ys+4r0atNpnGclyEUBEpJGI+Sa/SlaRHKtAYQDxcl +33XQcfEhVNAGWb7WZZMuAh0EcX7jTrkHDFw9tGFcD+WHBDQAvv7V2ze/effqzftXb7579szJbf+L +6Vff428i/+Y3L96/f/nuDQj0r/6fH1+8e/nDze7Nd69ffguyfAO4WZbblOoq/8abUm4xoif/Rujq +j9hdswX+8Bf67/8NP/4PAP7rTbr55c0///f55luC/+G38M8W572DCd6b5wDbvGuA6WefX8CHsDf0 +ul/TUIDlBPoF5aDXSmxO8wo7Dm6HtdC2OPO8wAquUrEqci7QH17gC+ClWNc134KhmZheAfG/9Er6 +bbsAkY89P8eEoH+Bv2HFApawZa6gMtRKb1BYbLdLW8Pw8Usw/ezzC/j0PfQ54FSGjoIUpfcorCy3 +sYGd5z9/CaaffX4Bn75HadLPe47VcJtaXYRBbZ7bJZB/8xabvoU+VoofFgW5QeBPXYC4Mdhg0hdQ +t2rSz947kOescuESzM+GEZu+hKiBWaJjeu9g/JE2fPwSzM+HLb6BW5sxUZgfAP38JZgfgS0+fQ8I +ugDbAi6zPFfYrjGGHkGwsaxOSC9WD5IsACm4BtKbf6AFN9/8lquPBFieXEiuprEEQherqHSzQg77 +Ih0/WXE13/xhxzWPb/7Vz9Q+Vy4N26XFdGHNbrAh6I8s9WvmwrSdvBKWoUpS4jK06EUhMqGXbC5Q +z7fz6/6BkR9W4wbmib80X5lU2OUXqn0XIoY/LvJWtiNn0YB0BPqZ1mGWijS5NHuUW5dgXnJs8XVa +Kyj7kfbHuvDUgna5EKMbxjlRYGvCRmYThypp4K46iHC3lC8JUyx0tZG5AnKr9oLs/+OVJv5WGPt5 +WmEIk7DFhOkFmF+Ql4T7VYefNlGQnX3wB1F7QQwqSD73/AzTNYd9sx/4LcKP8SU5ekFcX9hdmNCU +wIoca6GlvLZRO9USmKtyVfKemFAcSEfBvYPxukjnkngD89Rv8SmtW63Caxoep6guF0Ae4yUdBd/y +++nE6ibop6Jsfpa+uvJv9u9+/OFPisfcDWH+2TTf7ODvH/51+hGeQQu9rIOSBvosgW5+m29AUies +/LkAF56BSrjeYiTfgZ+P4FBu8WJCAiuGS7D+8TcT6qA4keeFxr7isTCcpGCRrST8awEzgQ5E4u6F +ECvAv+g8dqjRsMiBCA4NpuOaE4Lj7RzgMwBc8y3YfkJGhCUPsBpv6zxXR9o3+PmC9MAEJDA2XBp8 +uDXf8C/QEAwtwAlk94ZL3Tb8MzacM2AMyb8clifuzGWg0vNaenSYhra4XwHemwEpMruBmj4QoCPw +zUgpgHOBzg290rZ/Gbvf2zpWaVvsmONqp8Hxv1O7HajD9C/T76d289Of3fzhH+Enmg== + + + 1LAKhin9sZlO0BsA34Rhyj96wq+gPt2uK2gma5gLluelOb/Oa0Qx0Rz4+QYcbkvNK4E9kgfAhuRa +M5+wlwISFLAn2AhyIsoXmFwEiQnUK26W1iUxMMOOejNSBi3XteI0Y3Dk7iFKMNMZiGY4A/FK0ZuL +L8cBRQ5Bm6I0pLQk4We+RWc1guGnGXYoBBaelNw2xkLAeovHpRnYFlgLB0IAMwl9AgzOYdG2McnL +8hxuuOGC+zbBygyE8+cb7IjzygQsNFHXuS23wPvAbVdm2AyzN0MD5U1aGQFO6piE2FBK4RkBYKC2 +DtyBPRgW9CrszTVEAcZlUWIxdZbxIjgqw2LL0jaEWbCmuSiCsBblOSq3hiBXG+AcpC1svFERrAoE +k18pWJN8Pt1iJE6aoskgwM4EmPMCXNAtwATMczAEsPqFi6B0VeEMzpvShOPwX0KRb1OYZYalkJnj +BSjQjtWctWMAxq7zSLaoCFrKCkwpK7ApYb1jsOhs5rcauA/rbViKzCMQtYwUJkfQyQECSz7fYGYX +obUl4WFDxVDeX3Hiy+dlcuG6WO3zmDGlU3bRz5fGn4dXhZAF2JDxDKzrwstxpgUvCOpacc4jMDUe +mQyLPK4CXFOpwus1FEMAM1KHYGksxZZ5gZdEeV0KgmJB9TNqb4nbCExzFmojLFjBu+C+IKt5XueO +t6yzUEFl9xiImV/C8FIZGG4xXq8dLkHwAjgl6dsCi1fwBuhoEnpDbqugSDgmjCLHKsASo67yEA1t +Gd/GaGGV4jbVmcbAaCKQZLYAQdUWAljaMRg2AyF3XtYiJLRZB3jJaxAES+ojmbS/KB10IEA2cFuY +9ik3nYzS2wpSPGoXctGBgN0+FZ1ioVZpW7GMO3MchbsA16prrDgELaqgWSMTsEJvV2mKJTsFCJq7 +vqnN2gMAQ5cFvMqsWW+BcfEMARpLAgTlxRAQibx0VhJ/CAR1Z9F5EHgQGsuczm1G0HAUdcB4EyFg +0qW7wlZ7Yy2Fggr/NQQx2oZTAMzAkmtVxhqQ/K1MgbEAoHOwhSMD3pCbyq5FiVqTbrrrorNomXmq +M9bGswiAXU6SSGRgaasyGzcjRZCBLm3Lk3uBNZ5stwkkp7AlmIJF+BoLzYwFN8Ggwg/DsgdFoK9K +tF0SKAedLNVgXXbrpoTg2Iqu5MgiBoCtrxeWffBqYP/aHE2MIKCnWRfnwmoLAoOuF4zX3PyTtEU7 +WHcawQtLLiSbsKvAQCDrekNJw++KqIXpiiv2+YzM8LsPAvsOWstSDUGbo655PEGDQPhYCKbIkMqD +wFirvAqMAfk8IItKAKja/C74sYUtCzMM5hqdKGQEgKw0XTAo6BlIKjsP11yKANM87F+KoIRVeptT +Ew0WX9eyoCCDV16GNopoWIvhraaxLLo4EO+iU1b2e1C5TIs29QiBC8wfVY+MtQXkjiqamKEsbeuc +TD4IaysMqU65YMsbfRJx1UlXSpK2eEJHWcOaMiIIqolh2F0QgORMtqulVXYPAIPcUnDJikJ1ZRT+ +JQqw2T4T0NeheFtNshgj1o5HIKi5Rac9lkMWIEjDVffVoLxdsbJQdoQxsCZlTZYBAxk7r7p9LXW1 +z8MiVs7Uop/vW/uSglJVo22gfWwaSkFdN8D8GwHC3q4IZgWGtRqwZEPQp7i4YRmc6lK7OsawNSzR +MZGBJeiQJ9ysFW2el7wZGmhbVTWAYU4CTLD9qDK1rIagLConsugWAGxxEWCBBYnAgAXAdafCBAtG +EPDM/JwUAcv0QIZcUbJ4TwkYY1OVh/R4RZBSExaImovANao6V6ULYbkNSfm9or7JCACcmQew2gKv +GwCCwSLdzZHFBAJj0FdFXTcAxkw2IWxt3IXg9gpRqRGYk8o0sF1lFACcqm42eWUJjG3FjMumDSJw +0ZWAN1QZAlJUuLvo+BYg2sCMFXgkQBDLSgEIWEPQYtZ5IPpoiKZUo+8iZwGGlpJyVpUTAMdVFx6x +XoBRV0gRBQ+xNl0hJakCDmD4WRBQZxCYnLAmu4WBXeWBHUKED4JFuQAKWL8LGR3QCw/tEg0Ya1Bg +UA5kt2FKSIbBKarkoG2MgTWpEdJYJCKs6OdrMLTFTEbtEWxaKrVWFnsBl7ROoGrqUkBdW5UAmgsM +zK0J9XOR6Y57nS7janITaTIZa8TDx5aiCEQVB2DIqkmvaMQq9cuqUkOsfkKQtfdJlBtCYJPNVCN0 +dS06KDYHCyzfojNAxUMx/TyzdqsI1qACuaLa/VzBkRcHmr6s9AXc1qrnAgNnWTGla6IIRVnT1xED +M1g0MjHExgAgRZwYaSqLIUim4Cb1eiGYtnkGV5nFlQd1HIbqpPSKQkPxEp9l1QtvcAO1qc0uBgLW +ZL3VrQrBaKtTJ0jgIhBM+dQn51wFqCtOZhIjWM0mwsktogC2n9RURoqlBcBkK65WVdFCczZkm1dF +gJdn6ssqMTzObLJ0GUkIIl3KqRREpjbO5iiyNYewRWfiGtSIxc833VIKyhoGBlt46FATIMW0ZBBU +oCO4qJNjXXiNAbDm6GU3A8nDJhuVLryIHoKmuyIubQEuSUcx8pxFYNSWDav2K4JYbFvlfR1g6nKE +kS2ZexCotr/bJfjzAcSOfl4VWkBQs+4oNEQMbLjvy5sW+zyeVhQtROwEAKagwLUIVbDLiKsNkaZo +CDCHzEmZ5wIGC1R3D95qI+woMeqMjexKjbhLqG+APsJo0QWoO0qTfQqAXbchbZSBWYzdgqE+WR4R +XY+pjASg6hRkcgd2VCFQzXW/USK4WXdbVQTVdJgixiIAMXdOJ5FuUxFFdVS60LcpWItKE8woNQpU +P0Vh7ihYbNKzIwKxzlW1DTHCEbgorXjS1BDUWeesOj0iyncTiCJ3sAtVtdZcVOOKQPiqylVMQm3h +OB4Lz7o0AaonA/dBVccRPEdbdlkRwJRSCsQRAUCylGUaROUBiO8muyrLiucCTqJ3FvZqMDCs6hKr +4qlHoKnTtHUq3mSGRpbNNVYeaNFQWZOLlW6ocXOOEaDv3fTpoOGNWG27citvdZ69LEYFAENUNaiY +jX/e9rmCbTaTP5mBsan4FC83AvOsUYWMtp3i7ZqnbgxIQ1GjooqrC19lDkfakhVBiMqcRvE6psD2 +qyamGVFgCzL1z+PR2VFzjWiFqZ6tqi8Au0tpNQME48aLOhTqyoo6AmOyrU3GHIBrVMUn227TnG3Y +xO4GYMpJ20ooKKLvO9WzyQh7Y1n9OhWsTd3BTRQBBJp2QALUECxz28xQiYeLXG5GVlBh3f1yAM5N +fdo6Xs0Uclgi4pQBYJ1N90OrRj9fbBNpdVUCiu3CtDfKm6Iq5KZ6x+6uI6EnkxOgpuaRnDFw33ON +2NX0fMfC7jagaagvIxIHAZowxSZ4046B6hks7OohBAlzrJJICbXb0+ycAQ1nJAPXNhed3KqTJkrJ +sundGncsdT9in4kADMgnJoyXB8BSaKJnzkEdSwTW7ZWmjKLVIBuAWWtIi9fRxC4CoDop0K5RYlFB +mLVjLGqhZcu6MZBw5IYhmLVh6mDCCLXKHfY/AUjddd20BaCaIKI868ebOSiMr9Fc9IUd6AyktM2N +JoRg0U+AWUoBAIOu7wW9cQhMptMXji8yAvRgG7cbOweTKO0ETOK0TdmiYGgqqEadcKbrYAursS/q +DKnKQGGGCPlVOYCW52xbGGu+CCxqwyYOeCEwLOrJsMWFUPPg2Vj3ptgpVocTrmmzX6oqowBOYZX5 +DszmvlZTpwdgN5e7zgRgsp2FsSVr2xAEGGRcK0e+eFwtBoZNba9sYjACMNfFNo6mSGszV4yJ6FRZ +u7d3PReomxmcwoZg2IJz1w0a8xuBajUnWQWwddWqWIutbgCv2lQFJwDjbNJ04b0agWnxu4wiyKUp +XtlT02qipGjoeEnNMZYCw4wAwyxm3CYxLQGaJJzrFkKjpDDljEyOZj6LDVrVvaEPYlTk2WZnMX88 +5q0V8zKhfkYIMpZlV/VKDf8cLAZX2BnNQNdbXCmMAMBi1SBhIXLPckRfm46Y+JmgbTMZkSvLiIzB +wUXxVg3NIYKixmUU51NGUyGpQKpBgaBTqoao3gCAkpNRVAtWaDNGQJJOcIkrAbCi5dV7oAhUTS3s +oBME4tUpbA4ykLQ6ETxqMyNYNG3HxWTxOqCAbRWA9Q5o/B6h5KwWfjf9OI3y2IFk7lbxiCmCvnJp +w3ouYA1P9kWKnTVfURFNH2ld1PXfPff4uqbBWMkyltcVC8+JTEO8GgOSaDJ+vGisZUXH/+Hhj2NK +h6phiUMt1HA24zZ1qiiewz1gbYO6avJMjMicOB+WgYt6tXK2PbWo1z1jjoVOTZtuCQ+MmCcjdvqb +ORWLzoxs2TjdsZcx9KWU9k2RCKhm3LL4x7Zz1NUlVlXOThYkU2Ey6mmq38bZEOgU1EgRtlsWXZpR +d4SHPo5HwORVEmHP2eJPxY8A2hAqpFXpzrh/rYujlYFhUbLIdcoIigU9iwUuEOtqgkQceIjAsXDp +CJbadFeUaBkAS51NkOjnQVlRAvocKKYEoeHK3l0E9tUt1hAAc1SlO9i+nrE7KuAW8SflaiGhcisf +r5w30icmf5ycnSoxNP8DoEqTLgG0dHWj19gZAKNzEjZDqTkWRTPPENhkVmcJCSIoqWBZis6JtaOj +/5prrbDDn4Eh6WygUdMXt6Z6R5H4rXuxOruy1wO6T2b4eIz6JhCIMhLqUUGags7mHjlAcFJJj+Lg +uUC7lq7Rj4ypGVl6pYY8Au1dPSiD4EVzGqv4tRCYlC0qelYLyqNM18SAjFaw2ilr3y1BaUg6diaT +V96nZeTZLwYtYYYqEG0mxdtK0X2hqd4ErSnRQLgo20XjRINB70G8ttst5qoHMAhbXZIzu5AyBiit +v8UIo/RK6ZkqKACukspX2K5iYFn6hpcFpv6B4qIViNYMgJxcx7ploj55elfcaHkZTctiwCZ0ldmp +aZpzAMC46qBLaIsaRhnI4j8fivariksegCnq1qKWFSI1F29SC6bMbtJpcA6RNlUSKXLCwGxCoU9w +RGBTRv2TZXbqs6SULmXhWDx3NZROgbPZiwb2ofVczLgtSWZo8Sl2qrohZkwc4z1P6V04Q2tlT6Ju +L9i2qqc8iFMIzxFYhl7kdEQEpmgZBzbFEe+qrodWgiLAIZbRFYkNwGqiy2y2Eswn5EYsOBWHvK0M +VL/aMGW6q7ywGsrAklUglDwnAWowDAgIarZjWxsy8knKy7Ku8iabXsEsOrVau5uEEJikktSTAupv +1eHVNQ4tKUKwmmGhCNa46L6zWHdL9/JKIiCSlczxYBFdbFvSxk2AbRf1M6v/HF9lXn0CMoLonKma +0ALAnh5d2e5E2KJusdZnAYBn097iovxusZg7hS1vfFNWyxlFkH4+Lfb5xsHL4jMZNTxWUKs3vcGi +FQDW9J/C0WUBJt3EJO2EYCpmeywP0S660ZJT/rmAc1FJTScJFKypsYU9XIJCYsjM/w== + + + ZLE1SbTnNyVLy8VtSTFi7rJuIGpXIcamdiirKAWtItX8guVswseVJ7qD4+tDc1qLvHvV7Y98lkZS +UG1QU/SRInF8Fc5FFKTNDJ219T4FcyaY2MaXVXPScPy9JA5f8grQfHMEq0OnWH5qkTzNcQUkt1Z6 +akrJ3PFhVy7Z3POy2zOwVGVqMe8Zgpe+83BkqqDSZTxcFeladPyCackl8/mUUcZnFzxJ4tHCvsqy +wOiOZstRW3V5F3H9QFvQ882B2oEWYOgBkSJ2G4PDmo1dGv8RNRtha5OGTgphrqwlgUt+UcmmEvek +tpJtl5ZzE9oDVQR76hci6CkM4v5DYNIUBieFMnOOwXHW8ep5YpqtUorToCgpgRHg5LHo/Soiq3Cq +pmyHs45My2YXWopUwWFqSpgk/mIVA4sO2kQGvT4rY/tuVt02TRYQA53PvspeUt2u0z2gANZIZOHk +MwaGxba4dVEE3SWWzSWGCFadhxqSwraSo9XtVQQ2c+WgSFIEPZqbJWkFqV3bVpRX5wUnoW0UZPVd +LUU/r97GnhKAwEXD/BTq5c+vHMVevdOjVEsb7cmo2NIWQrCsiIIexGzzUDa+bjlYCmJplp8jsUL+ +PDr1dBJEiXDUmdfqoFQBMBXNlOh+6Dq7eLQ2zFFXwdI/XZPmu8y6lVZ0/Vk+sjgc8PNFl6Ha4NjS +lks03bx6DZIEFJ/7WpxOFRcWcAAEqi0fmZc3AEuzWLR67rBprZqmbcc2sLFlAs2rYu2pyxqgRmDR +fpGfQdH2xKlZZDQA16xJr01UMmyZNPt7bar7VMzf1hzfIgGKihEWPXtDSekM1JCzpI8zgmBnnYTa +5wLumWd01BmBkdMWuS3blABLyVRok4YIjnqOjPxJzwXc5yE5TgxsKclyAgiBa7IceslmAiCMrnYt +6aStmACoLIuWVAfgJevJpCyeTQBmOwkmEhXJXfTQxqoHzAit5U5pOm4NzqmmKbYABD1eEcxLR6CS +Grf+Gjds7GcxkFTJSkh8WkURaH4MboYsEZECiQphtrewCzNe9JAdWcU6vppwmdRVgwTIBpTYuSzA +sljD1vrn7TQJBS9kduQqBATMVWOgxt2T8x9VPH6p2e2ksspkXDSFnLwfOkP1nKKdxiNwVrB7WT8z +psdRcDHMOtyOAjwDpS/TvAoA6vmyxMclRKbIENhJJWi4zCW5qcVAGEGhqUhyP8qIRc9i9IxVbGtn +BMmmFWDRdUtZnCKkJK6GLZfYZWKIOtyyA6OcS3YMIHVBmfXcYDCPGcnfFNzQPhdwkGTe1GWiB+rs +hj2hSTpA8jpTs004maQrq+XmD0DaIhnYVR6MjOlSJFP7ue6Bkssau/mJG6ue3VA/KgAXExwUmlNF +xvEhBVNdRf2PLGAZmJvylrIYVRvMTY9LaYIPWh+LIWjd1q5lVVo1AoWWZlb5F7CA03MzVXU1Gt7A +s4WHR5XnnsGdONdb8faVp7E1AHbuyi6EngXZheUkjDos1E2eLAyHbhCJ1UDHVMOaTeeIrLeZi0cy +gSJmWjZzxdDhZAJLEgm6vioLhKgJGOjSk9RA4aF61IK9TBND0Cc46/E0Cs88Y6diVjnZjy2QazQq +XsmzBSCsdplHmlWMDtulaL8s8QldvuL1iea6Qve1nEPDsa/qL6ZcCsFqQctsikdkO/MZx2VSLsrE +ZgE/cX9HTmy14KDorpE1dfYqBss4iRxCfcYRUkkbijyBn1HctUkAIZK1o8HUWTSXyM4NjfKqKRot +xxIDwmuKyoSgaEHoKlrznWFMOSsfKfT6jKLPfdKopodx6lmXSLLACIA1cwkjoLwRI1BckFFDkRiV +L0X41cU6JREEAccm6TXV9Dw5g/1MEhOC9JVyEDRfQc/VRI5bPhcwdV36KzF8BK6CV+2CJBF2BlrM +CXMmRKmL7DV8Rkkbfd0UWbiYySGH1GIPcCQ50MqfF0syJXPjhp7GAEMnh2AlX1VTWWhlMlqJKACw +BiVgEQc5AIscdITtv87RECyzItAQISXetKjTSxKEghkGkZMgGEEw2wQ9gSzBXeLPiGBONrtUzlGO +kc56CgI8iBWzlXUUKeuNEcx2KD2YtAdg31h0dlBWnK67YKlm1UK30fSDKPkbwkPOtUOFUdeBaQ2x +HxKRugHPBZzk5HWwBIAYzV8cuTwCA1MqgqBnMUYzZaMdQIy9tAEdnxYYjQa/34xDTKJOujxmOemB +OdxVZxFFMJ5RujYVNJI5pHIWwU0Xx6IJxIul9UXe3QVYa9VVa3zteeiRU6OeUXa7enD73MSke0lr +iGyIMoIZ5I6uGYr8MRD0EwFqSBiBNoTZ0t8Qb1a8dZHTG83OMEXO82RgibrhWw5EwKNsq0HZNYjA +1KexHABqFroFoOlzYbUDp7GfVal83IHZJQk2eK6mU2V7VUhu2Sc7FqQHkTFnjXcaPKpUdBJlK2IQ +kp2Hx/XPGysCQ9AeiJ7rjkBF56QIaGs2bSubBwD1iCBoITKNQnJj0M+24nkrCUbEfjopWeZv7Md1 +UE1RwUuRbkYQLasrangTT3Zl3YE12ztEK1ISb+2MPUIlkiDqAp+q6UGDyFG3Z3TqTi2gaLo+ADWR +3q16PKlZdXVQGvozPvMrgXFR3p7R+WiNAAZ3EgsPnss5KABLJAALDUgOYbAI3tyPMgc+5EEIcPCl +JkC0I5WkASoPQ0haVUEP90Y+Ya0Iwmwiju0S2h5tGiaryhAkxTc6zZkWcJNyPJKHisUemk4tNQkQ +KBllwR28wDoWlTf7YLHZebbskKAp+1ihQ09RhZ4ojmDVcIMeMCCgOH1NiSIEqwlT3buoRoiY8oGd +Ec8VnNhgDBz/UHCYdRykRgcC56z0Vk56RKBGD0JXqLEkCqW4EVjUGCwLs4ak+zLr01QaR3K3Qj9m +MbfZomKRTVWuraOOqaCuWKzDQzFK4a1sKljzR10EUTM3sDoQTDxhTtXqQL3WksgIRhAtYmoW+oWq +Q/9A5YiwTlFwzoMQpEhSYlWF289FnRIt6Ql0kj/SMmohiJ4og+CyqJlfrFJSWIMYiLqizyngSklo +TrZimdEoRO8VnO3EiGSok//XkpOFNARmTYyZe5C1MjYGq1u6+297IhcCiyYTzpaiUfp59WKOqELp +KJo13tRK3vRAu1bMjEDKqJSxgKuGY4yI4vIjgiSYYxwgaM5BnC1if4b3ubwwOVaQZ/JewNXSeWvW +kEzNmjpEJ5ieSaAoFAXqzlGS6XXFzmBRTEfDV5rndk7AwShTo6xoNVAGqxZjWZDoB7B03lh5pyyJ +q8munFykvlwOTGmYQYOYyWq8FDr1dvH9ShhsKqsm9NII3Ct4UcLqrDkGIWnE1IJ7i2UxUsRULf4e +ybScjIWPeqyc25M0RWHzeqFrSFfJTBTCwMoR2GwWf5sNKEozJtHknpGsOgR6ByxZJWuGUuNDFUys +mvz9lD8mSKnre0OVTDs6O6geZpJx9wLOzY5SoMKhxwR7aQXyEDy/jESwh9kKe2XWoe4FrKK9n+PE +OgSWgybJmwhbLhyFnVmLklUvKqU/tKrhvHMCZIyW6M7VkWJ+r+BmtSNgjKWcg/h5VvZ3a7/PkTyn +moBfVgkQwTfl86sBivTHIAIVrouYdDMXB34+gKGb7FZ5rp8/h7iPviF6qABgRf0FS7eiTMQ6zWGl +ZFwcSbwOBn9o80I3liwwcai8a+T7SrgCIOh1BX8Pr5T86nvR69oSCIxlkEinWeWQ19KCjTmFqVH8 +YyFIsse/ESVjTWy3zrpWUEcAxdXKigRRETT2Bjp4yarSBAv1iQ9TC+XF2oQbsqtQmbqk/iKpw0JK +ioi8heWv0jXPLFtmy/ye8WWou4Al2MtHURSoIVCOyXxDfFnw+BvxBTM2Vy3zwzWJljVaIHyJcuhp +WVGbtFIyGMBoZ4O+ZKmVh601jLigHoI7GOJFTfPm4oB9IwsKT4XhmkSKE6Zn3As4ri048PMNOLIV +IzTjhMJbP7E2o+rNa16bAzIrgS14dZlviwpbjDSlO1YPFApUi4MXrhvCPDhwxTQp49eUMJBH+Yww +AuoQweaZxraOOYb1AsekACW+LqzCePIh0TpuWJMMVf1lpVAtzx50MDAQk3ClhhyWECxEA5bPS0IZ +ejZp6JqcApKRl7IVwc6BYeGo1WJblt2+oEerqmMyWK0b9GcW0cj1+AnW6ZLxqbaNUiQir8qbuDBh +MwZ3cNPHWQ3M4CUEEzzHxL0ljnKVxEpJZsgZkDAyF6IsK5q9qyz3Bd2SkWc6yDld7+yQwpY0OGoS +cE0saovOLV7vC0YLG4Mpr19qVYZVVhBInHJzccRwVfw4LTe772Xo5lhlDpJFeL8BYwSmlRutpEjE +4ID3knyJqmUYkDmXpEbb0BbPZsc8YPVAoYARdPDC/s4B64pKR9pQoEAVaUJtb+v7ZVgv8AB59JOv +/2737v3x1TfvX7198+LdX25+DqCf/ref3fzdV+/fvXrz3c1Pv/rTi+9f7l+/pHLTf/rdX75/+bOb +/wMb7R9s9IsjN/k/4S9uo99PVJIWnalYfwgULaqODvopVatdKKjs6o0HreedeJtC2kG3rixYyJi9 +34AteWWeTVZUcywB80JRGU9AHT7OHRnaUnmQMiLtMHm/jp6Ccd6KROhIZz6rNxIgQEbQibW2vleG +9QIHcPTocG6hAr/ww0x15MGmCVQDfYkZdHfkK274rB6UQNdNJq6TbszlZDpETUrl/QYsVUyYYN7E +kWN0GI87B5tVdUDl7pxYCrq2mMAV1g3WDhQKGEEHL5ZS6rDOfDxhpECAyl6l1tr6fhnWCzwQ9ga8 +tQlLK4MWqzdK8I03YO1G4mrUq4Yi5aBjcVW6ms64C3qvYKaiK/cbMJZdMr8Rl4vFqVdtg2klxw77 +RtxWoPGtY0upiDii7EB5vbJWwYErsI1IZ/Ykj+8XoLJWSbW2vlOG9QIDhLUzFrDG2wVWvCqIrkvI +kW4ZAeujkvYa7UYHvBsBIdlpr+yiqjJvsthOHipJkkwvmLi6qrWmqqyvDlTmhjLHTVtc1mHZYO1A +JqCLFYYGjgmMSGc+pD0SIEBlrhJrbX23DOs5B5i3YHW2pdJtGXOgmzBA6W6RbnkBvZ4MAoycLonu +SkiZ7/hCE6GzFiwrQRzxzOr9BpwskIv1hAupCk3KoXDXSuEdU4DcNXRy6ry3trjmQtxg7UChQAdH +wYEP2YxYFzyPuKVAgMpcpdba+n4Z1gs8EO5i3hBK2NhI3ULjqmFaB11JEelqsuTvICssd42zeDUi +Yw2YI3e/AUtlbKaVq43SpJM8A1Q5xWARoHI21bhs2kap4Tdg7UChwKa9gAN7IUesC9cvGykQoHJW +qbW2vl+G9QIPhLMLHf0j2RIrFbAHnWetwyU/PE3drR/Vbk6RLbXUxqjxBmG2gwawFn5CP31axcqL +UhtvxhJTapgQUNkr5rpvi/kxavAYVg8kChSBgsNttEiDIl16/KQTIEDlrhLr2vZudQ== + + + pGccYObmda10/9qSl0DSYQbtdORtEFlQ0WtAdyzZDToil7K+rWllfg+Oljg/o0qyiNjXAjazrLgO +VAOkrDVv2mKYd143WDtQKLDBMbAmdzisQePMjgCGKWuV1t7S99VQnjEAWbuwhptTYF3h/LafzmC9 +mahfrcV+GWNwSYq/tsX4q1AMnc9K3yqul3grh1iwKnvxMDPvxMbwLflKhwFlB/Lb9eMdqnEKh7PP +u/52hilvlU4/Q3s3DeW2719onuweZ578Xpx7izr34J9vpyK3ivx4NWfb4EJ8RiFdUNRF9pDpeL8B +lx69xaMWrMeulgBrVRkNSPy2JADfFsvmxbLB6oDJ2bQOHDj7csSK943ULQUCZAo6ta5t75fDesYD +klRfbjBSUcLEpEk64v0GHDjXnwo4srWPybTNalvOcXVA7Rjn9Q9t0XGZmkfZIfJu/nQHF04jHVHW +W/RjbF4vQB1ZJbW3dT3qWM97fy1jkdNZZukcRSXvN+CAviutrgk4ZCPTgi/QOXhpc0DlbVnzsmmb +5Kz8gLUDhQJlr4J7wTWHtdqBWUeBABlBp7a3df1yZdzOeHAlY5HScrL5aCwI6cCoRATlbqI0KOQY +6Gg6dZYUPVC5i+60TVsMbba8wdqBQoFyV8G9cKfDWqzak6NAgMpdpda17f1yWM94cC17EYkgF+vK +ThSZuw4qp0gY2F3ONWTlLtdVNaByt0Wdu9Y2y/mEAWsHMgH6eYX2wuQOabGLlBwBAlTmKrGube+W +w7rlwJXsRU4SW1QTxtKE9xtw4BSRZ1L3Vw2zVmWpFrlPyoDcNaogtWza4lHRuGywdqBQoMxVcLKa +iw5rthwnR4EAGUGn1rXt/XJYz3hwBXuR3l9XGbIaNRPCgQNn5TIwLgqk7ZP7JU57BSpnF5GNri0e +RlWgYe1AoUA5q2C8g2HWctWKNdvpF0eBAJWzSq1r2/vlsJ7x4Gr2IsorSmEj9xTm799vwIFzWbgf +Leq8S3JgFAt0B53iyaI9WMx7mc/bzrkuZ1gVKBTYzBcw7DJyQthhxTM7YUuBABWBUuva9n45rGc8 +uJbFiNf/NXXiUI2R+zOw3qiBwFTV/Oh9g42yOqD2LUUdHte2BzUd1g4kCmx4DGzJlx1r6kpIpyB5 +haVTO7Tt/XJYNzy4rtGIO0VrMnp0AOD+DOxKzC/mm8CxFVYUNbSruivo4sZ52basIYQzlB1Ir9fP +d7AerXBIh/mv7xegySfzl1hb3ynDesaAbzgN5N8htvUh05ENmX8T6zFmi2x469GBC6cXPONa0XRc +yke5sOpwiz5MRkzH0rCUpOTbJnHmD1gd0FuPDhws7uywytGtkQIBsvnZqXVte7+CLyS+4YEoil9k +ONIlRJovgRvg/QaMuQhFK3PzQQhklqsy3TlIQGUsF4zybbGy7cr7YsfqgEIBI+jgoFl1DuliJ1Qc +AQJUviqxrm3vliE958D1jEdUoIr4+akeyv0GnMnzw+Q2KhSE/LKTH6BgScqHALlrDatMprEtHqgp +oQ1IHUzer2OjYEt/9kjxqsKweT/DlLNKam/Zu+RQnnX/WnYjVp5PQa22okZ5h+KFJImXUuW0V5pz +Vj97lbNpBlTG8o19vi0u5qSMVawOyASYNEnKWD3U5JCCtbTKhROdAAEyAZ1Y17Z3y2HdcuBqRmMs +mnCCN5rmpTNXwbmfLKp8SJUX9GrM5TOCBlTm8lngoW2TUy0D1g4UChSBgoMv0K5Yg52HdhQIULmr +1Lq2vV8O6xkPrmU34u0GErmPnNl7vwHjPYHs+cHLCaLaC5poRzcLDEDu24p7bty0pYtZ1g3WDhQK +bO7PypzW9F2KNHDYaiQguGiaI9a17d3qSM84cA2rEYXSPGu8C08M3W/AyV/kwJej0qSTLGa8mqGF +xQGVr3wicGiLVRaVr4a1A4UCRdDBWq7ZYcVgS1k3FAhQGavUura+u4b1jAdXsxpx6fSI1TzrTtbB +ya6Zxcsz6FAI55LOyt5a1UlMQOUO3xYytIVtpyh7DWsHCgWKoIM1sdNhpaNNaUOBAJW9Su3QtnfX +sJ7x4FpWI103EmRJZJu7HmoaTNWkTKQsZhXDfPWqAbVrVVIwhrZc72mDtQPz2lnToXpDQ8eJdTkM +qO8XoH5eaR3a9l6tF2DZ5u0VbEUkNze1RYtpCh6sJ2iwF3RAaTPoOc1+JtisCXM6a8tXx22wduC4 +qg2sFZsGrLWFMwJq66zttPaWvVMO5YYBbCt+zJL7tzDi6JC+zoduxDlwL/uORf3XIvaaVgpLdKNY +c0BiRsaKoLWNbTP6+FWXc8XkFeiNOAfuGpbD2jNBHAU+E8RR69r2frkj7mc8uIIRB0jXqn4cLCJ0 +v4G6GytW3C4k6mM3ZuDp6DU6oPJ1DqmNbTM6T5cwYnVAJkDZqtCgV7U5nJbO7N8vQOZqp9W17b0y +pGf9v5oFh1deLDpcEWtq3W/A/a5RrI2Rm8xjrRlEtzWk1QGZNbNcX+zb5sV2qI7VAYUCHZu+m1EB +rxHrwvUNRgoEqMxVal3b3q+O9ZwH1zLj8J6QXNSnODdjrkIxrzMKb0NKepZgYVdnovpG0QGVt6pc +9ba4moOG3gSpg/HrTZoINFoNIIcz2D147v0CVM4qra5t71THetb/qxlxeKtK0zGjQq/3G3DmYhxM +b4wajtN7GqFvVMqlA5W3S8qbtgCkU7cDVgcUChSBgqPdyuKwBrtGwFEgQOWuUuva9n51rOc8uJYR +hxVvYlYDVZXhAUplYJnctGiYXgrd0nUvOXYYd6zJeVjXkqaduvwU5QA0RdhB8RC/lRxSnMHvYfr6 +4PewTqlr2/vksG67fw0DjoS9DiGdibzfgPupcapYpAm4mnAM3QKVsDqgspXOpGzb0v1DI9YOFAoU +QQfrhSAOa7DC4I4CASpjlVrX1nfXsJ7x4GoGHC6bRQey4vVh9xtwMpUVCaaiQQjUE4IAbGENDqjc +CaUsm7bNdFaHtQ2KrPppB7Bf+4I19M2pUxDGjUypHdr27hrWMx5cy4BDGqhmDef8hz55HXiueoUU +F1wkYycay9egThECat9a1Ri/tW14J1fcYB2AZt0OYC1wOWBd+y1YnYLVwloDta5t75fDuuHB1aw4 +LFvWdOBgtPrk7WAqZyrAYuG5PvJVNNE47iVlnc/b8gXUG6wdSBQYAgNLEfoB6VrL2fsRpp/upLqW +1qeOcdP9/zgbLoOIWtfk7Jf7DViuxHvGVQOlf9Xq0mDdQovO9YOBWA8xt7ppG91xa8XqgN6Gc2Ap +lTZiXbj830iBAHkD7dT2tq5fHes5D65gw+GVOOsiPpRktU0cOFvgH29YCT0RrelFIlwfw4DMl0VK +RA1t8eztnEasDigU6Mgo2CoOOaShM7sTEPrheE9s8CzUbhnScw5czYzLPUaY+Gje/QacXVXM2IpY +D0lLb2CF1nl1QOUtH+cf2gY7DG1IHSy5E4MOHPsdAh1psEpjjgABGm/btq3rVcd6zoFrGXFY2rM0 +NWKycVaBmS8RZmpTsfCvXZUDo9o6TBnLle59SywpHDYoHZBermxVYNetHEpMyJZSMf3tAlS2KqG9 +retSx7rt/NUMOLzIyU7lUMm9+w04c5nTZ3KxUdN4st6tgFJ8WRxQOctFqoa2VKOxjVgdUChQBAq2 +CqAOKdZxsQK1SoAAlbdKbG/rumVIzzlwLfMNb7iyTDOSSPdnYImg5+YM5mj7B0w/B2O+4MlFDepr +y0UutXYYB1iXkg4craC7wxn4vsnx9QI0vrYSxrauSx3refevYb9R5WBL9V3nXoeoH8jLcm8H3uVV +4qLzbVa2LnVJDqh8pcK8Y9sFq4bEEasDCgXK2Q7WwmUOay/X6igQoHJWqe1th+4q1nMeXM1+y92L +F/lO1fsNGH1zTclQ27bYHV/zuiwdpqxNljDZW1Ih5QGhA8rL9fMdTBenjkh7pU73fgEqZ9Ww1pZD +PxXneeevZbjh2FL5SsI86+nJEVytzhWd1ePRTYtdFddUs+8H9MrsMky1LUrEpFJOsY7AWdMRB7A6 +iAesJbdwRgEBjbdGrWvb+2Vu5zMeXM1ww3phUU/jU3j3/gysFTMRaHuAG/ke0iagdq5FzYD0bUur +Z1g7sMedB7Dd9Ouxmqzs729d1HZKrV3vkcO36f1j7Lbl3y6LsqCvxZkt9wMwa70/uo9gFWc772R2 +P4qAiA9V72Vz7TaYRiPJIBge5esAHQ6skr9sXsYw/mSnyloa7R3hto/XOmEHeIulOtCFzfcbcLaU +MSR1zaLoptT0SonSogdyt/DWPQ1iWNvIZRJHrB0oFOgoKLgH9B3WYBfQOgoEaIwVantb16+O9ZwH +V7PQCq4VHbho52kcGG87kvtRsAJH1HoVya78KIvVxknqvcXrTWa1iq2tVEcdsXagUKDsVXC0660c +1qCXkToCGKbMVVqtpetUR3nOgGsZaHg7iNV2C3rI2kEzHu/T20XUd9UvQMd7U5IDKV/TrDEfa4nn +72vY4OzA5FZzh8bhhplZzTG649m/XkDG1tUSeaWl61LHedb7q5loFWe3KqEklu/PwE0COXWWC8B5 +QRe9SCqV2BxQWUuVK8a2wbZzh9UDiQJF0Lf+JGfIHNZgRXIdBQJU7iq1rm3vl8N6xoNrGWmVpLOa +f5j1fX8GNhp62NwuIFqwaEVwQGHNplngkqcenQfRi23CN/WqZLGRdQLPendVf6sAjZ9CoWvbe+IQ +nvX6GrYZ3gQXtIrNXNQ2G8Bu7+K7tWmiyZWI2K9FrTirL0kbddNAkbUNeG/IFqsHEgXKVAV3lc1h +7ddIOAoEqJxVal3b3i+H9YwHV7PNcAOtUTNaV1UNHDj1O9qAYCl1lCzHA2+bQhnWgcpeGPTztmvL +eYO1A4UCRdDB/hoswYqlBVPYUCBAY285a+u7a1jPeHAtE42EkbqKKeXgfgNOfWPHworVmBN16lBR +qw5U5sDG3s7a5qa1hpxqocDociEGsJjPDmnknMaRAAEqc5VY19b3VpGeceC6B+qGUcaUzPszaJNr +bugGNvNepai7SPcuEFD5s7S1nrXtxVkMqweusfO3Q6kq7oh0mNLdvUBAY7D51NxE7d0yrFsOfPGB +ukdWY/mQKfj7f7fiLMA8WAHr9nidB1sZlbk2i3lawZW5YpYqq2muOMtc6VbdddM2uhIehjW6Eh5m +LnqwlVHxWK3giqfAFWfx1Pa2rl8d6zkPrmQ6zhUjLhb90eIsHsyVVLBjq+Q2WcEV7JhG4F1xFuxY +DmPLdZEy0obQQVxpFg+2IiodoRVb8a92hVk8ma5t743Dedbzq1XxrHgfjlrDVpjFg62Eylzp4nrJ +L5Wzy9g5+OYrsChfo+yZve06yxWVHqsDusIsHmwlVDxWK7biKXCFWTy1rm3vl8N6xoNrVfGEIc7B +jpdpYRYPthIqSG+ZtaavFFvBvvEtrENhFuRDqGPL1ceJFKcDurIsHmwFVDpOK7Ti3w== + + + 7oqyeEpd294nh/Os/1cr4lmx4rfmyWhRFg+18ikIbOuqCdBcaAVw4ln/5oDKWc2h7G3XWeusO6wO +2IuyeKiVT/FIrdCKJ8AVZfHEura9Ww7rlgPXKuJZ8f6NVfUIdSJ5sJVPwSnC1wi5QivYNS0v6oqy +IBvmsGnZXLE9w+mdZlaSxYOteErHaUVW/NtdQRZPqWvb++RwnvX/GgU88f2zGv5WkMWDrXQKAqsF +J6XICvZLM6pdQRYEq3Xi2oKgzFo+z7B2oCvI4sFWOsVjNTPfU+C8AZ5a17b3y2E948G1rEfaBbqR +pgVZPNjKQdAMSTrrpMgKAvWAsSvIguBaNy2bq4JsOJuvmKzlWDzYCqd0nFZgxb/dFWPxlLq21dmu +hvOs/1eyHIk0q2drxVhGsJRNQSDIcV93RYBr8xVatG/F0tVd27K2doa1A60YywiWsikea+pKSqcg +eSWlUzu07f1yWDc8uKrtSNNk1QIrVoxlBEvlFKRFrj1oWmKFZtSi0QstxkL9C9t2veaqQ9iBVopl +BEvRlI5yWE36bleIxZM5rpK1X/VR8hnwf4lCLDOGKWwJd0vRga1kylxWK+ttxVVgZdiEdIVYZrzd +a0550zbK3cgD1g70lqIDW8kUj9WKq3gKXCEWT61r25wUNqxnPPjy/E9EKpd/NFeIxYOtZAqS2q93 +kOIq2K3OQSvEMtOFbFpc09rirdRq2BvWDnSFWDxYa6Z4pFZcxRPgCrF4Yl3b3q2O9IwDVzMWC+ag +qnfBCrF4sNZMQXIXOctsxVVmunFvCQ7IXcu4mrZtwWDo90gI0g5zhVg8uN9D6ZBqeRX//l6IxZPa +W/YuOZRn3b+WnViav2RFjld7qJVMQWrnHH3NFe4Y3w49FGJBHmiFN9cWFnPUAI5h7cBeiMVD7eit +R2rFVTwBrhCLJ9a17d1yWLccuJqhCDRUS52zQiwebCVTZrxXMpWxEAv2rWU9NGmFWJAPoCylTdss +18UPWDvQFWLxYCuZ4rFacRVPgSvE4ql1bXu/HNYzHlzLVgTMSe75cIVYPNhKpiC9qxz0tOIqCJzr +si3Egl1WS8G1zXjZdthg7UBXiMWDtWaKR2rFVTwBrhCLJ9a17d3qSM84cA1rEYVStUKDWojFg61k +CpJa5X4uK66CwGVdfcUV5WtJ6vqxtgUsZotgKtYOdIVYRrCUTPFYrbiKp8AVYvHUura+u4b1jAdX +sxZxdK3qqxVi8eB+VWDBm9Bm877atIUhDA6o3GlS9d61LewyH7F2oCvEMoJjsLaKNbI5OVIgQGWv +Uju07d01rGc8uJbFiDTMZmXY3PXQloPKhByiFcVWwlLopxH6goyLRsl7yxB1MjqUHZht3npoWLJO +UcWpVRD82xmmH1c6fcveIYdy7Pu1skCJ2GA3WxTTEjxYTolSJ8xG1CsVsQ+xFQe0GZM1idO1rdmO +63asHTiuaANLxZQRK5dWGQnQIiwjrb1l75RDuWHAf9gBvhkPAiU9VtENOAe2cilzhh2mqZ0hhVVg +SeHlux5IzMjRDjO6thheUz3OsHagN+AcuGtXDmu/YsdR4IqweGpd294vh/WMB1cw4PD4mlyO14uw +eKiVSyFKZ43wSGEV7FWW0+OuCMucUe/RwJy1DXYXqMPagb0Ii4fa+nc4+52S7v2uCIun1bXtvepI +t/2/mvWW8dL0qHuTFmHxYCuXMmcsTjmLcisZ7ti1Eu1OOS3Cgmzo4W1rG213clij3zS1CIsHW7kU +j9UKq3gKXBEWT61r2/vlsJ7x4FomHGCuQctJaBEWD9V6KUitpqhaYRXsWY0a9rEiLMgFVaxc2+jq +oivSDutFWDzUyqV4nFZYxb/fFWHxtLq2vVMO67b/VzPgAHNaVUWwIiwebOVSkN6aVOuVwirYN737 +zRVhQT60qGNjbeEVTc9JGdYOdEVYPNjKpXisVljFU+CKsHhqXdveL4f1jAfXMuAAs5bZ6UVYRqhU +TEFySwl678asvG1JbQ8twoJQiksMLZOlkDiUHmhKsINauRSPM/g9TF8f/B7WKXVte58c1m33r2G8 +kbDXNEArwuLBVi4FSc1VPQZ6P2PGsrRaNsiKsNDeEtRnYW3xR7sFUbF2oCvCMoLl8K3HaoVVPAWu +CIun1rX13TWsZzy4mvGGy6ZoxqAVYRnB0MtV+tHL8EvOMAIXKT+Xen4xrdJFA6HWNjud1bDmQZFV +H+0AFsvWIY12qb0jQIDKXSV2aNu7pUjPOHAt0w0HOKj0sRIsHgysWaoKW71wCv2hMQgwZD2AETQL +kXo8W469ts1Y72/dYO1AV4JlBNPBjhFr7NtTpyCOW5lSO7Tt3XVYNzy4mg2HtK2a32slWEawFEtB +oFZOjH13KFZLPI47SWztvG2vZeWwdqCVYBnBXDBlRLramPf3awmWkdTesvepY9x0/z/OgksFD3z6 +VMn7DdiKpYDCDYtYS2NKWRUQbi4uZyVY5hRMGXVtQekHi3WDtQO9BefAVizFY7WyKp4CV4LFU+va +9n45rGc8uIIFl4qVwHclWDzYiqUgqTXPlkrGbgboVsrNA7lbEe9V37bFK7y1Lplh7UBXgsWDtVqK +Rxo6WzoBrgSLJzZ4Fmq3OtIzDlzNiEs9OuhKsHiwVktBcku/1YPLqmDXcmrRAZW3adHb660tntXR +uJ4i7TBXgsWDrViKR2plVTwBrgSLJ9a17b1yWM84cC0TDjCnRe/qVfPYAa1eClErEUctrIIdK1Hr +lpqRkaJd39tb4rXTGto0lB1oJVg8sGtWDqWVVfFvdyVYPKGube+Sw7rp/NXMt4R5uHp9hZVg8WAr +loLk5qxRHymrgl3rlwhaCRZkg14Q79rSvdB1g7UDXQkWD9ZqKR6plVXxBLgSLJ5Y17Z3qyM948C1 +jDfAPPcrHrQEywiW2HnKzlyOtn+sdpNatO0DiMxxHVviyY9cR4we5qRkB1uxFI/Tyqr417sSLJ5S +17Z3yWE96/41rDfcPuXWCleCxYOtWArRumhxaCmrgv1q8+prrShf+1lfaxst3ddh7UBXgmUES7EU +j9XKqngKXAkWT61r67trWM94cDXrLXUfnivBMoKr5D0nPFeut4kVPpdInWsaLyh6hpEkYKr5rC0o +MOsGqwdaHRYPRldAVQTFEjDVanAUJGdhOGpd294vh/WMB9ey33CIk1qWVonFg4GKVYWtKuPoC41K +bi/KR0Dlzdps09W2mJJq5psg7TBXh2UEg6Zj67/ZveNrXTYECFB52y0H17Z31rCeceBq1hsSkbSm +tdVhGcFyUJaAS4+VcSQ4ZRfRtjosBE568M63ndX6clg70OqwjGApIzBibeXs/a3L206ptes9cvg2 +vf+PrcMyx+5u8RacA2sFlTmi1jnUWJljtKPQVotljqjYDzVbYGJYdmpH12HecnNgq6TiUWrBFf/u +XprFE9lbepeSoTzr+LXO2EW89jZo8qKWZ/FgK6SC5KameVFScoV6Jkf3XXkWZIIeyHdt8Zi/anuG +tQNdeRYPtkIqHquVXPEUuPIsnlrXtvfLYT3jwdWst5idt9nKs3iwFVIhgi0XTc5QY+dS0eo3Vp4F +GZGqWszWdkENc9lg7UBXnsWDrZaKx6pFVzwBvTyLp7W3zM7dbijPGHAt4y3mTX2U+w3USqkgterX +sqIr2LEuNaxAC/KgVD0waG2X86IvHpjcml7Oi6l4pFZ2xRPgSrR4Yl3bfF725ZwDVzPhIuYp6xF0 +K9EygqWYCtHb6+9LcDB2m8CVaEE+rFXLm1rb4NQSw+qBVqLFg62YisdqZVc8Ba5Ei6fWte39cljP +eHAtIw4wr3ZSykq0jGCjoQfV9aBVJB+1r9vCPYtu27K2uDpVjTNudZDVafFgK6vicVoBFv9+V6zF +0+ra9j45rGf9v4YVB1hBx9gWaxnBbicLeR2LtWC/tHyaK9aC4FA3xVpoyuG6GbF6oBVr8eCu1zms +VoDFU+CKtXhqXdveL4f1jAdXs+JQV5nVz2HFWjzYyqoQwYsmUGouSETFUm+ksGIttL9YAqVrq7fD +O6wd6Iq1jGAti+CwWgEWT4Er1uKpdW19dw3rGQ+uZcWRWLJUSS3W4sGpb/PoUwq6pXIBFuxbsxRK +K9ZCa3XVC6Zc27RqUSGvaKxaUqjnTAxgrqvikVoBFk+AK9biiXVtfW8V6RkHrnvgbhhlLdYyQqWs +CtHc/VxcgIX6Zy4AK9ZCc8q0V9cWDICyweqBFiYdoFJWxSMdprTzgizOhuiHwt1E7d0yrFsO/FUW +a3Fn8L501M+qteAVSGrE0Vy834Az+w8AiNvlXLXwhFzM/P+z967LkRvXmugT8B3qjyLsHRs08gIg +sfVLpGyPz6Eth2XPKOLERAfFZksc8dLDZtvWfvqzvm9lAgmgSALVTbKKXVJILCwg7ytXrnuWrvMJ +jEAsgTFy3pnSDb81LRJ32EGtOTD24PhAwf3BQfDJCNwlfDFGGHcborUx3SEy6BiBxA0GqaWOxW/L +gCwCyWM1IUwGzDq2ZsZOBGfQCw/JBy+C0QjDqzQTKtAGXAoq3JUOxKbQDAEzoFyBVn2hAjL36y11 +ZYtscawX/IKNKZFKmC0pRYRKc9TroKOTfMDo9JaLEilabEzwQl8rnYmAzdnlRFKnChi5mib5MTrV +FeJ9qDhkXKSVosLhZ2gxBFsaJf0KrCskSrLSlyRwMTQHSWIA5N47jhXo9QS2xNEsnNAJwbjCCytn +S9txxBqpEZXM1BZiZGXn4gQOKWUhLV26WVFmISXUlvmqWwVGlbvOrdWw3eD6+E0gVDQ0yzpERRsW +MlqXAtL/GOagmi76MbEBY7PKt8j6sudXcWzRtiJg+sjqt0YzUAbQeRWlwDGqKCSIKGxgJK5tZ4cJ +rZytnvjL5C6dh6Je61uWXaxkleUeLOsYeYJFq+P1ZjLeivpGLISrNZOWIGNlm7iSclanjQmnBRMX +zcOlNOFzWXsuWh0xUTimoDiT9MDyszVJxvcgSWlPttanDLOt6jXbLt9PwK3nyqgjctZSrAm15qs5 +i7MKO6GubUoG0JaaCUKnulTmG/Nv0g4jFhyvX60THgRtR5K/+uZP4c3vr98e3X788LOQ87vz22sA +KwDf/OXm+q9C8++E7BeFgo/Of7q4zl8c/OU93phSX33/P//4h4tLqebgd91POWd+98OfT/5y8/Yc +PwcH0L0vvl795t9Xl9fyqpBu3V78+PHu/AOOGjnDbk9HX5z9fHH59vb8Gu/t6nd/ur7r3+F/d/Ek ++035lRxk/7i+OBNgOs/yD/95evlRv/z3wx9en17xO3SCvdrWcfw6exy/vsA4ZD/PHsm/Lt7e/Tx7 +NPHrrR7Rz+cXP/18N3tI6fNnH9PNj//n/Ozu6Obj9Vvp39HNI3ujH+A77n/59O7D7FEOyjz7UL/5 +05tvLt//fPrGzB3jxduMN75nTPjmP2f0eFvI5N3H2x8/Cod/dj53FrTozCVO7Tw30Q== + + + FGF97nh+PP1w/ofb8//7USZhPgkdlXr2EV7ffH93cXf2CJXsR/mBX//94vJ8/v4clHn2Edq5Q7v+ +ePXd2d3pPxeMLC/y7APDlps7ttvzDx8v558b6fM5FOierpsHur6e+mWHwPnfc3LycGcfmPdnXpCL +67nLcfP+/Pb07uZ29oL0BZ4dzb6/+Xh7dv7H29P3P1+czT7iHpmK/KS73vK9c3H9CAkZDMa+4K45 +vrl6f/Ph4m7OpnmKDpAPe7Tt3317/m719V7a245x7KW97R3RXtpbM8otkfb8lyztvbs9Fbb38i83 +Fx9embw3W4jfi3vbKe7N3pd7cW8v7u3Fvcmo9uLeXtz7YsS9wr4WgW/JSLZc5POvTuRbMKJdEflE +Djo6/+f55fc/n769+deXbfvSI5Ni4Ws5MH+8/PgIt/IZmM1tlQw+3L399vyfF6fo0AKpJy/0YjzB +H08/fvhwcXp9pAu4K7z07LV5O/8YfvsS5/D8gcw/hd++xDG8hAJsOzW7effuw/nd0XPQtBfa9t9x +hDu04S/Bt8BL8Ozm8ub2v/71s4oxM+nzr5fzVYnx6/0G+oSxfHh/fvbdx0f2w+5xBLN9ez58vH13 +enb+/dnpEsQbFHp+qWP24GRxP16e3h7fXH+4O72ev27Tgi9gTVs6yt//+/3N9fkGo+wL7pJsUlRl +OXuOtlzFYcoFY9luJUdhl4zlv2eP5b9fkAf5683F9d1JVF+8hD7y/Pu4VU8ic7FD/NDrNCYs5Bu2 +nQ3aSNGz2Jqw3Wu0a5LREiPJthCD09uLu5+vzu/mG+B2iSjMPvZ+eUSZkg0Hn27xQB7hxfOBmG0W +FX5x8wfitnog86nyLy9BlF+lFX4xN7DtR+flxd1fTy8ekyW/8LNzd2Tl5WrixTvuhRbyz+e3P51j +JneICVq6uV7jWjxdB/YuQxsr1L56Jeq0BV4p261MM2bvMbT9HkNfVpDI8c3N5dHt+fl/z7ZqvkbP +qLcXl6fz7bq7pMQwh7Pjym9P3158nI+66fPd0G5ut8Q5fyBv5w/k7TYPZNdEzD/f3L7/+eby5qdf +d0g02ZO1HSJrr4aYzY9g2XJi9mrD2HaSmBWvx2X11ez0ZeEU27zVZ49k1/b6znncvt6Y/dksyz5m +/74xvmzM/mw/3F2L2V9AyLf9SJq9ybb+SJov4ezYkbSTWRQe8SjJyNoy5/sX8rr/Inf81jtq/Dgb +y7aees0eya4E4fxttjn1+OfT6+vzy+/PL8/PlujTpgWf3yI029K66SCnBV/sHPr24sP7y9Oz86vz +67s/n77focPo6lSqmm2Y3AnpaJX+XU1+msHPuaPmr/n8d/p8iynl1p/Ey3INbvPpNXsku8Z7HyOM ++c+JfOwKvVuAWdu+R2brELZ+j8weya5wePMjkZ8n8cq27L53i/yD3l1cXi7xf7rc5pV+d3tzNX8w +/Pj5tZKPMDmZYewxj/HcMvbxRWKuZo/lR9zJNV83rl8/v1H/8l+nv84ek1C+u9PbRZRSv99eTfjd +zXzJ4+YFBnJ7ThFw7nBO3769uLv453xxqi/wAvaY6/njOjv7ePXxcW+hfGRZkReIaLo+P50d/nJ2 +enn255u388fWF3j+4LPZvEW2eqn5v3AIcxdwWOqFRJLT64ur0xdLDbureeiKsHeG2TLJ7uzVOMPM +H8muaT/2zjDbou7dX1g40SnsmjfM/Jxmu+YOs4CUb/uh9GrcYeaPZNcOpZ10h5nNf+6GO8wXueO3 +3h3m7NW4w8wfya4YS/buMHt3mG05jL4AdxjzpbjDLKD5234Svxp3mPkj2TXeezfdYRZg1rbvkVfj +DjN/JLvC4W2bO8xW2392x5tnwZZbSjxeaA13MWvgAj/A/So82So8Xc6NHViEp+vACzW++0kbv/nT +m2+Zs+fNMs3XLIZod46o15u3aL4acEeyFj1PAvCXoqZL8uTsKdrDFK3eU7TXSNFmL+ueou0p2iuh +aL+/FcCXzaKdYwpeIz3bc2h7evZl0rMvmkF7tfRsz5/t6dmXRs9yo86bZVb4V0bWZg/+C7Lh7bfN +nG3TfMnbZvbg99vmC982X9ZtQX+9+Pf55V8vT399syzYcRsddqpyVc32ntSZ/9sCB8qsxC5Rvtvz +q5vH0hvsWK6X+TlF9vlR9vlRPhPSrczXtlyZSv5fruS/r+W3/P1aXqxem8v2xfXb83cX1xfzDVy3 +5+/PT+++XbDdshLPPr59jhgd147liPnwHlli5o5ul3LEzORGvrQEMdvCQ73CCwp/XHLZ+JZ76i8Z +y6746u8VFttLDh7b27tpV1pEEbacum1oUtr68Pmbq/c3H4Qt/+7jIyRslwP44hh3iCCc3l7c/Xx1 +fjcf13aJMMzWqf3yiHEqGw4+3eKBPKIMzQdiXkIZMXsgjzg/5QNxWz2Q+aT5l12hzLtxiC6Uenbp +CH21WRE/yxm6OyaOjdZ0ZxyI9gGAe3Py7pmTl6Up3Eat0t6cvG5W9ubkvTn5GcfzWs3JJC4wKNvy +60WEZm9C3puQ9ybk/TUjk5HtTchrurs9KuK9CXlvQt6bkD+/dmJHTcivydj69uLdu4/zbzPZdlKw +cDi7Qg1mp6f78PH2nXC23y9L8z8otL12JJ3+ZWMblHn2of16fnl586+547u8+OnnO3lfnCEP7uwh +jott7wLG3Xl8cy2i+/X8fTcpt1e6vajSbX/H7eOj2SvdnoKUfv3T7fn59dfCgZ1/fXH99uKnm6// +eXFzeX739e35269vbk+vf5q91fbauL02bq+N22vj1oxsPh+2V8m9DFdlwmyry+l/X1x9vHvk6sd8 +SdL3z4549ewxnV/KwyKVT1bixfQ9316Qfz/B/nopj5hvVZY4iXt8h1D+NamdPrw/P5OD6/Y5fOGf +XTp61cqa2SQqLfFiaX9acJvXMHb29/9+L7zeBqPsC74A4/2INvcJVFN7vc1eb7PX23xBepuopVG9 +TVTiUH2z19vs9TZ7vc1eb7PX2+z1Njuut7mMCo1X4UKxV0I9vRLq+yj87aAW6nXmz9hAH7XtKrZX +GQH8nHrDF6JP+xwa20YcXk0OjfkZG7Y8h8b8FdnyHBrzB7LlOTSe5x6Q7fYm3v7j8/Li7q+nF49Z +KfZn5/7s3J+dGw9ky8/Off6pbTs7l1LlbT82NxKmd+Xo3Oed+rS535Zjd/F67nNOLenACzW+zzm1 +Wzmnvv/59O3Nv57i/qLdoURfeHaBXfHrnJ0UbR+R/+xbaPbFmm8fIae5W9u/XwDJ5g/k1/kD+XXL +KcC2U7Obd+8+nN9hS9yev11Ep3dNBviOI/0yBIDNV/U1SgLbsiqv+z7xvWi2y6JZYaqv5qLkfD7j +JdiMJSOZz2i8BJ9hfDl7JP+6eLvAnTB+/fwjcvNH9PP5456H2ZDS58/PQX2JSo0nyKK9O9zVXqmx +E0qNeq/U2FpWOLwWpcb8geyVGjsg/u6VGtt77O6VGttIyfdKjb1SY1uVGl+YaHZ3usDR8jUKZu9u +T8/uTi//cnMx37FZC89c49TSc/tnHs7O2fLj6YfzP9ye/9+P59dn8znOUakXiEn//u7i7uwRBVYu +seHrv19cLsiVMCjz/Jqv2T621x+vvhMs/ueCoeVFnn1kZ0/nZfbcI1mm1driOOf5I3lCgWdbToXX +l+xowXnw7vbmav5w+PGzD+c1pW56ramOysPZt7bc3cznp25eYCj73EWDwe1zF+1zFz2xanm+TPKl +pS56EqXR3z/e/vjxUiZ7l/SIrzP3ygKRYsuFo+dJufJCet4l8WF7Veta/vCr1+E9Nn8cW+47Vr46 +37EFI9r7jq0Z5YsbKHq+5M0j4fev20xxl/Nnr8hIUe6tFDe7baWY7c20a0YKbLktUInvxb3XLe4t +QbO9wLcX+PYC317g2wt8e4Hv9Qt8s0WD1yjwvV6/tNk5HfYS33ZKfLMXcC/x7SW+vcT3SWi2l/j2 +Et8OS3yFeS0y35KRbLnUV706qW/BiPZS35pRvrjU979ubt7+dHs6/7x/jSLfq7wzYlGM+JaHSLzG +jBezhbl9xotnJwj7NJ4PDWSf8eITOYyUB+JV0OZ9/o6tJWPvLoW700uI/+vHy9OzX75eKejm/enZ +xd2v/7VAJ/zh7tfL+Tru+PXzu3AvuXB523fWosHs2mb6AxBxh/bS69SILtsvO3GubpZzaNtv/fnA +VI7Hr4m8fTmMwy7eBviaGO6l12du+cZZOJxdUYjM9jr58PH23enZ+fdnp0s40kGh59eUL1utZWMb +lHn2of3r5wXR+ZfQ6sv7YgbnkY1wXGx71y9uzuOb6w93p49dpZhrVcbldkmBbtzszXv63xdXHxeY +trrvn33JiXOvJstQPTun1fmlPCxSNmclXozH+vaC++YkGhlfwmtA+sA9fBKJ1Z7b25VbX/cs0i6x +SGmBF5+x04Iv4Ce/dJS///f7m+vzDUbZF/xCWMI9v/Ty/NKeXdqzS3P78H0kVDvIL71Oa8AGnNO2 +M4PP4ya9/eu0V5k/QzrR24u7n6/OF+R13yXiMPtA/OURn4JsOPh0e+WMXx75Mh+I2eoVeSSDTz4Q +t9UDmU+Zf3kJwvwqHYmXWs+2/vi8vLj76+nFYxL1/uzcn537s3PjgWz52TmfCdjys3P+QLb87FxK +lbf92NxImN4fna/g6NwdPfT+lsZt5IWenBLuwFo8XQd2CBFeayqiffLZ0Sh3LxXR670ibyOLwXaz +on9fnMN61/i2nUyydHUqVc1OL7ELhN2syvjvul8dZO6Q+Ws+2Uif78D+2naK8Ucp+uFx57HdJRiM +pPpz2oC7QjFe4dn0rPFf25p9YZ/i4/kTpL2aHB/FbGFq25N8PIsi6pnH9N0XE+W6c+kxXqcT32LW +7fXuoO23p8DegJH9/RUnQN5Fd4RN1mXb91E+ptlhjbvCapvD+bFRe2Z7fyZ9hr30w7vz2z9c3G6D +imRb1vnu9Mf5a7wLCk27mm3n4Nj/5zKN5aDMy6Xi+nh99rcdoiavDssOm1W5+jLw7I97PHtBPDNf +Cjk7eikXEwo7iLr+++3p9Yd3M26R2B58f536kE1YtW1nPzeMM9kFbYgObUv46r0+JK4MPee+ubzc +gjXZlinZDFn3vppLOvBCjS+6/umrb/5kyje/v37bXQMFUAXIm7/cXP9VqmCakkLBR+c/XVznLw7+ +8p51eH31/a9XP95cHvzm6PTtT+crsypWf724/uW3Bx/l33L13UHvUPPDr/Lw/8iP/yOgf6386s+r +/+9/l6u3Av3hbwflYVmWbVjZ6rCpVlcHhTksvamrCCisvK9MvbL+sKpcA0Dr6lbeu0PX1s3q7KBw +h8F4u7L20JUo4w9rb6VKc2ibIEWqw9oZeSGA0niPItVhsMHLN+VhWxv5ppZmq6ohwFV4tk0d2vQs +RZpDE6rWdl+EQ+uDZ63Ou3pVtChSGgAaF9gzU+KjBl0zxkozRvpUSRcE4NvWC0AG6A== + + + 26YDoJCMownN4JvaY8gCcJUlIDRNrSN2hoWcTFfp2bhMJ57b4Nh/VxpZH+MPLSbahMNQ6YgE5E1r +VqY5rAwmQQC1q+qVqQ+N9WioQlekEP62LQvhnQxXv0XFKG0J8Cagu2ihaldsUQpLIfbCVivtlRTS +bnoAGgy/4FCsXXFoOnkCatqKoNI2ht/YSoYts1rbVitxTbPixLccEtZc1qQ5bNuqRrWlfCIjqg/r +hrhBHHB+BZywtU9lmiasiDYu9aXxK+CVK1EIuAYEwsqXjoWIj7IEgp9Y7AL46mXQQN/SdM8lP9bf +Rf8yli764rGJIm8j9qPoOxK7WvR9jeMhkgu6x9nmoIt81JiWop+XOHVFPndxeotufuMCFPkKcJWK +fJniUhb9WsbVLrrlTihRZDiR8KboESeiVtHjFvGvjT/aELG2dt7Ez32qAPPEKjEZbAbzxIZ1mdkZ +a1L3QuxwaBI2Vv3G0oE6G7cjd1+Rbz9u0GKyi4t8G3OrV/lXkRoUHTng7Ju4HyLNIF2pPGFKWJTy +BPZ8QJyKnjol+tV9kyhc0ZE4ksE67QGlg8Aj4yNiyboQ1WTq4gxgVYCQvtsFQVFF0NayA0BkroG0 +L6iseF+tElmPj2cHRP22TQBU4DHjqQKSdW6NrhWSdVYZu4LOOlf1vcWIXDMYkQxbdorrh42JafiN +TgzmrgUKd3OH6Q2un15ZACGHNi2AJ30JCU9cQDNYysp0SylECqvdpNUGyZQhVsCyBJBCMo7A2e6/ +qSvTRtTyjVK/NiT8QxnS9brHUaKx7zdZoutxj7Ed0nU/IM21q02/w7CdQtntK+Cd7iaXNp9bjfZn +pSdHZfJNrJ2IG12PXOmkTbTA6AmFTceR1ThBhlSl4je2CibSHT2nuRm4ParAQiBgdaJgJc+1hkuv +NE7Pdqx7T9iJJdiUJJYyNMWjiOTOOOUhEo5XhoWIj5Ewt/VqSLqbVUbWc4rvIoMSMVsosxJ0r2dG +43XgDkSJrUvBxJ+we0KuB0eTPHN6G1fH08tzkELGax5vvtHDXpaPCFp5o20IGgY9IsNK59rrEVo3 +q+kpOz6Ixyf19DAfn/djhiDR7J5kj9mKMd8xZU3G3MuIu1Ey3WT8z5hFGvNQUzZrzIkpca4jq1br +nLYRF9En0uWmjfweeAwT6o5hBFkJWP5EVUh3TPeedMnajuEk6apynjRRt0TcEvlL1C9RyJ5AJiKa +aGiisUMSrE/HI0775ODox4Pk6X70swgiv/nHNYSGt6ufbk/fXpyLVGJ8+1upRtbGBPxtBc+dfO4O +feOAAZnjvFkd/XTgq8OyFhIEQJEeimBqWWBs7CCrLkss9ODo6uCdNH90JOLCf3xE35rSCIUqD0Ow +TuYJEFkOo8PAIsurSl569MRUtSxVidO+kY78cBpH1ygjBkFC5tkKWroIkHa5HDhwHAUKwXdj9cCx +8ktmyB3WZdXq6W9qMITxaKmkMamkDkHPkaaxmFGZyNAY5SgaI2dtDYIW9CSpg6/1sHH987EcNtYB +zTpQOHSmdXoEC28IxHMyOG1ZcL6VQoKbzvIklGHIROG0cSUYdOx30CAcNq5/PuZZ42qff1HVlR41 +pgV5lwkA/gNQhppl3GFl9dwTrqBWmlDr+GxZcxu25AyxU8FxHWNvG/JCspnlCFOyUOJMk91eovtC +B6TvNc8ai4U8PkivCv3Yr7SwHi0GO5sN1MpUyn5B79gJcLXsVkU5i90s2O+Sm78M5DIxNjQkEJ6v +hgxLyy+ErOtRU1vWUZWg95j1yjptpwWjErCBA3e0R204aUTe445uGlRClHBYVSKJUDQ5aoSYlJRF +BYMqHDWCU57HgWAZ5dfGl9pQxMQCuFnX3JkeLQN1TWiqBCjxcfzZvWJhs+rKon6cTxGtOXZTy5dd +D4jIZtV1kXi8ygaBgcoiZONshV5gHgTzdaq8X2Uzxdkk6ayFtVzF2eZk+7ZbDq6Ga3WaEmIJEeDU +Jrziiia06hc9wyrFC2KOVyyTA4E4hSOkxy2+aVcd+hFBraKYqzscZlu+UrQnmrM33qziNug6i+5b +v8r2CfaSI76ZtuZWck6f02b0bVj1exG7tewA2M2m5kFC8pEmtN/voAlUPkSSAKJhW/ZQkEoPGzlt +Vj1ZIeXRA5MQkCZB8FWiTFhlUJmeeIG4JdqWCF+kewmHesqYqGdC2Y64krZ2tJdPxwcDBK4Uv7vS +5GWlASvrq0iLBopBF5q4kXSTs4vcbFEhE0dQYJBej2AOEkKQdW0/L1FQqrOJKjiX3vbfjCdbSUFj +s/UoxktWjJa0mKx5MUKKYow0xRSvihHmFWPMLKbIW4zxuxhvAKW71mR7pBhvo2K8z4rpVizGu7UY +b+disOOtFhrSBH4CSkya4U065ZSs1CRclMPapl4lClyQMrmeMhUT2qXHdNNTtyInf54tZxRSCXCR +E9FKWYdEZMsQpddEgIucOse3sXjRlY9NFHkbsR9F35HY1aLvqw6nyMcTh1zkY+asFP20xKkr8rmL +81v0E5yfgWkJ+mPStXH6srPUVP2Z3x23HUpkZ3KHN0WPOBG1ih63Iv4VOQLK1PGU5edRM2Rkr0ZU +rKL2qC4H3IZ2xpth96qMZ+m2VZHvq7j3inzzORchgw1cZDs47vH+G1CBxkc2DAufSEXGq3X0pGPo +OpJTTOhSxhh2xKv/KtG3jr8kgjRRVZGoILAolBmnqpjWcbFARtdCkO/puWKsNT07rGjtTWSXR+z0 +8cEfREL4NueyayjrpQVhGWo+SrONcUlNEiric90mTa2FFEmiLUKUi7BSNe8iTUQGeDQ7EUKyjePA +Zl9hNapWx9mMl7DpiLDiYPZNY62ShzpEhNcNo/sk0VRIIWzM15h4gZRNo9ruUpWAMi9UuPFHXcfd +IPyQjZ8HEyuotIJgI8demZAajrtPcFg1r5gT1es1xO4GGsqk+a18q3Pa2CZuWkEQqzPvqceolHfF +ugTfAxIBw+/+XSzel45t5E3EjvT9iF3tehqHk48mjrkbcpqWblbS3OVTh3eqE4jzi9IVD8O4BK7j +4bt1iqvJxbS6+bneY5TIMCJiTfoi4dUE+TLcI4Y2rv8m4XBC4YTnGZpjUqvAenUvYNpFgF7ZOuOX +yHb3L8aFUC8k3r5eaTmYqCQoqdxsqr7zqoSwWd9V4W8UIkR1NPzJ/IwmcDDBJq7yYA3GyzRex+lS +j7FhjC5TjBrhHHEydCg5xVpOnww6IfYI8bM9Md4vqWS3o1h5HfJtF5vvtuZw8zar4Qa32p8hEZjQ +Cc5OU+fEJE2k7h5nV2mmO6LE+v2AcnG94qGvC4b1dK4jgKqVbjIaCYyobf8FMKapMuLb6TA6pCLW +8WSJoISViaYnvM3ofkLt7nBIaF/kG6Lgjhg8nhy8O/iPfxz8g8qqH94e1Kvf/Hb1w/+aAr56Y1bf +vJc/pRxUX73pVvmqfxgv82CVMxQ6Q5ERlo1wcISkLDFC5DGij7cCyky2y3g7jTYcy6ALQXsUavaQ +GnB0uJnQDJQY05V7aBE+zenUlIiNCR1LjDpQjPo3IdwsNCXvkwNgzXRNj5LJYbNuZaan1uRYW4MB +aw7I8QmacEw/nxy+0/N5fIprwelpP2EIxlxD6uCIu5hyIBM+JU3/mJ+Z8jxjzkhL6uoW3fKm5S/S ++k+4Ppabcoc58zjY8txMGXmY0I4JfUEJ9KOTpqQf6KiJ/azrKbWM229EUydUd0yZWWw8y5OFGB8C +HNL4oBgfJOOzJhKV0Yk0PrJyHLyGHv+ba8R+CUWEJ45QRLjjUIaBNk/klMbLiX6lIrND5w+roAb8 +Fn4D8HuoHUwbADjgRCVk3kQrushiMJfUh41ItYHfSJEA5UOlO8uUvhJxvi29i94IxpZQc7W+ciq6 +GZjWWqgXSxU1DaQoOYoggUTxkEYT1YyJjCOysIdY0kBipSZAxUYMKwSnBp0SlgOZqarEAsMAVVn6 +A7m6hZa5PfSGz62BYVAOPxlgqIiz2FUGn6h6vqKMzDLOKukzTUX/ijQFBeaggv5PpgATWaRZ4CTU +FMzjLMCQRVFOxlhZVVFhSESGChsQgEo1SxzQsZYJytXasmLn1LxA65aDFqiChEu2t6FJSMTpVhER +Up9VBal+0cLqDSnbRy2R8WWtpjNq2iieB8wBijr1x2i5KVA9PCDYILcbe0CZXvoksjC+Ma1Vu7R3 +mH3hNFyp4qzgt6pBKx/dGESIddQBNVaRhlxnK3xE1WglZVs1tLpFsiEN1cD/RlYXEwiAScpQqgQS +gE4AraoQIkj2rk3fWHjSAKPLuo4obh3dDWp6xHAXYGPJWJPVX3FDto6J9NBGi76gdhVFTmkHCOrQ +spLwpoaHTkba3GHbqLiD70xNapW+Q10+aq6IekXeoCutettIr3yr7BnFdXSbc5b6DUwVYcjmYysm +EwAZpjV1P0XFmnksYKAtY+X6layHpVYB68G92XI3xH1dRs+yEuZNXepISoRCVnHtSxfxvHWRXIMi +qTynZ4uUcsnRRlundlsRvRlgYjFE1zpEZHfKQtg2WpVUOYQfXrsIbA8mfh39ibK9431qRZsFpUIx +6Uobu1a3Omrvg0JMaKOBsIqbrpTjPsnRCpNFhTmVY6QyHBRB9YKRdJJqWOdjc7BOdeR1QHsS/SWN +LnIiHQl50VHyROuLjtinA6FIJ4J6gNFbiriYcNhTOeQS8QYOCwEpo96C77PXsQZUUEenqcG5cwa7 +8zpjc/NbNGNAGCzMx3VzaKGzM/RlcVNjM7wKap6MHiILnOJqQZtWEd+boKZnaV/21UpOZXdoZPP9 +cAUJ1FEr5OXEDVj6dSWbFn4OzQpuVIK7sjOPzjZt9Ghuo152nJeFDrIPqL2TNqOh/B9yvv/um9u7 +gc84pB31IIZ77+oMPvsfr9+uPvx8+v58dUXH6P+Ur76W/w7s0Cd3JD2tYRGUxVzMJIBLXMomKBu8 +lFFQTnYxq0AZajGzIKU2YRek2AYMAwXQxSxDLLWQaZAeLmcbpNAmjAOLLWYduGDLmYev3mzEPnz1 +ZiMGAnL2chZChrYhEyHIvykbQTl/E0ZCCm7GSlBPsBEzgT2+ETuBghswFFpsA5YCBTdiKlBwI7Yi +6g42YCy0yeWshZbbhLnQA2YJe6F6m+UMBsTgTz0qoxi9ktmqo7pxbZX8uE1naBdio8Ex94bLyJSu +vrs9vf7pfHnAjBxIgvCOPg1WqCtjZnAuQk/n1RHqhMZLX1f0rJKVawkKmEx62fDvCQ1WfJu+PtHA +Buz1VOeJGv5hgtaWWZet5QiqkQ+ge8+oBO1aqqZUp/dUT2qtyJpLnSnyXsXXRd75WE3Xv5M0E4rg +7OCJTFHXtZOD1J2ugycHw2pKdGHYGirWrqQuATDt+JrxrZmGfJrS6+xtrKOvInahbyZ2gX+qNuut +dikfUj8xaV76aSk6L8p+diaINMsl1Aa4hJat8Bhw0rQNnenLFXahhbZ2zKa7Fq67Cg== + + + KNIDeOQWhNHBJxQ+y1OPUDm3hRMqYbkHg1YKYTDwGpbWjbBseBV8A86uhA9fCHQaFUZRRg6HUGIC +TMuyQ4RU6WnNg6AElqlzgZ4FPL4wb8IqqCKTJPfkQPoY4HgNdKEXLBfA0AQPhp6OtFDnkYwJrQ9y +TimoIXMC8g8dJ1dSOCg9afjjhMqaplaFYCOHg4JCTXVsrJQ4IUyFsn1smYjD3hSpf8QuPSbiIE4O +OC7Lg11Hyo84+iLNBzGUc1Rmr/u3qY5BFWynayb1pe+KTky16vvLUdmwygYV5yUbOadlxT+hyuYw +zVI/0WmS+sXQOcoWjL1i27Gj/ZrSecWTCY/rnsbbI0e5SvNyclAMXkeITger8JVupq4ZSA8CGXSF +qFNMultMh1RMx92hTI86RXrbT2CR6uhnuUi40y+FYrIgab9exWRNi+m6F1PkKHLcKdbgVrEGBYsp +ohZr0LlYg/XFms1RrNlDxZqtVgx3ZOzeYON2s59t7yZfyKJHqmJKKoqEVxlBKdbQnYwunSSvGgE1 +OMc9HIYq/bxq2zoefFFkFkkUngrayZpjbtRqoVOtc5h+6BxGS45+r1PdejKasVpdETbWNQ9Yf7Tz +Xf4q9iOrITXUt5N6kfdGX+Z9jjWkTp30MwAfqJJzKFtRz/LuRZyZvLTOy6SFQS+UEuGdbfueprb7 +0UyHbLsDfDxPa6ZzOulrlmawgLbNRlP0k7EGGxRT+r8bmsabZBafDFVgkwmhvWs4a1SFjKaWMvpw +/gU0WaSv3kyXEh3jeITln2KACoAjTFFL5Li5NXinRuMhekKymGCxClOT+UhbIXtdDN9PcSBrs8gb +XYMJ/TiK4UCm2z6bnGI4d0WcvLWv12BWt1QZAvZLOujdunGsHfHayenm7jqTqKowtU66QyhlSgoz +bQwOQFBvmw4DBik7kVhNaSONp3NohbjAUumYUcOuvDHWdPKN4WGnFlU9MBprETSuurgTeGyqDtAC +lRucg3BTpS7RUw/TKSwaKGg8wyVbBMrGgERab8vothoo3HbOmIgmxQ+6AbF/BToIJZry++hf0XfQ +IGwKwjqUnDWFOZieNT7fqmaL/JMa3fED0RknB+klLdUI9CJRKWsGYsdKwSDV1Oh1U3NykLqjE9ig +X5hValzTNINJqrxtNdCHiyHUD6r5qMDmkilhwlqq0IYPqJ3qP4DC1bVlnddTpEXMmivW9Kqbpazz +3TRlYyzWTEU3UdmMda+1gEuw8fxrc2A8MjwarGY9RMoizV+Gu0WOvG1ysu5xvNsCJw9bSGxwzgda +SIwwIVLE0OHZTEUvuCkb6AQdNOjQHHs4WTO8FawMiIIIYo10RuYjiKyofuw/XOFgk87WLNGoXn1N +0dYctlDYBtti9wtDdHS2catHc1uVAvSGDrasNGA0N5I8ZuToKU3UgQ1pjZLuEbVRg8aI3qhxZERx +tPiI5gA4oToC3ITukEwvpTx0IxnTHtL2MfUR4BT/CRxTIBoNxjSI2v3x1uMRNKZDX71ZQ4mgr5/s +emjjJ9QIuvYJPYLX0IQi6fnY0SRqvidUif5JE7pEZfeEMnHh1vRyHXXSg3xMn1TDPJ2mdTRKlcpj +KqXQ6Tqto1QZnma0KkPpjFpl2F8M0X9KsfLNNDni28+vNBU8Xf3x9vz8+pOSDIWUZUiYFN9BEO4f +GBzkD+uKgy+dZ4IAxn5qkqE2OI0gL6OhUUgRvcJdCOrTV8PyAq9Yp4VAn0qrof0B2QlE8qvqGIxZ +Z1mG+KhJhmpkWonvZQsbr86cwoVxp1pnDDe5UASXcgwZDWS3arQw+Eidtq0f5hgi4CwGRoy+qVvL +8DRSGlowYvi5F2yOGVRC7Hxoak0VYejZCaNjqzE/Tv5hfJp6sAFU0agnBL8qNclQg8QYyAYQnG4B +X8Myib/BpSRDQX2e9RxgaU0VULkQs1006jDrnE2OZq4q6cNnGG+k/WxW2m+aCgSjmQwAoezR46Fl +h2FyjHk3kDUFFidj1DE0VAxPsw6emJrwxmHRhP7WrVfLTICVqEYYbPRTNAhnJkZ0iYnQbyJNdOj0 +yAcAtGqsGvA8Eg4A86wLMcdQDW9RIKeNsTihoe2jLIPrnlOOodCobSW+jKWLvnhsosjbiP0o+o5o +T4u+q3E0RPCqtHGuOeQiHzNnpeinJU5dkc9dnN+in+C4AkW2BFylIl+muJJFt5RxrYtusRNCFBlG +JKwperSJiFX0mBWxT38EG3G2qUzMSBSio2flmhAR0SZUx2GtDSdcN2VMCBAjA9Fft8oGwG1l4zDj +vuLe07wD3eaT7alO+cM9XOSbmBt98BVpQbSKMb6NBMOm1ah8zDBkvNNeCVnxq0h2oimvzhMMJcKU +CFf6IlG2oiNtwA7XNhFfKqvphRrjUiqd0CqW1TE6zyPBEnHReBOxs25jeiH430QcrjT9SssMTZFg +5/mFQkwwJFMfTAdBHZobKNaBhhgg2zdEmp7y76A36C+JVOwvMb5Ne4A0HQO3MYUZB16T3arTzPT5 +heLUYW41yQ8BmPy67SbfkrL4lNyBtnKuYtOtIhW6LqZqqLFv89xCtW5kDfRoB9/UbfJ3rrxTqpem +XjFPd1ObUUogsFvlpNTp5iSSG03mIvQ8DEhyU/GbRLSxkdrBjtJ9lHZdPAz6jakBzY33+e7VPqRT +xoR47FRpU2nqlo5SONLZITXRDHnETtKbVdoEui1ofMdKN2gGdCtogHkgE0bS1jR6ntfxfG9TmQC0 +II00ekgyx4VS0XaVcExJLTl3xUMf6bF6cmcUO6wyap4ReiNkREl5UJy2TWRLgqJ0GXTcvqSrvLRf +Nx1Twg46jf+Cx7qOwej0hlr2GEfpObvMq8hpqOJUeebBcSXJm86lHo0lp7YFieFMazLC0ek6On/H +5/P0CB+f8mM2YMgpWMXGATMx5jamDMmYZxkzNVO+J5HnRJ0TcU5Ud8pejTmwMYum2OciOlpNLmS8 +5oAiUaAd2CfGsEsuFEkKSU4Z4jMpkvKdJEgkWjGhgdLhRNYiVUtkL1G9RBl7wpiIZ6KdibiOqG98 +PB4z2HMsyW1QdYa3DT1AKkG6mqmD4MfVrssuZJEYK1qS00MRTJC1hnQZrGsObRDaO7ElC1sZWmYO +kr8V81fITKnFGGIkfggO+wbmZVkRuO6U8L+UU3GSXYgSxNp8dpoTgEii2Zr8qkg5xo6Zz861Kblg +qDWfXdXls3Mxn108Kgxj7TSfXQz/R9B9nSVFaN0wxxCfjzWhXUr955hjyKoEaZm7KsSMdl3eQadx +gBoJw/xXLia0S/nrhimG8Hwc09m5/Is8m10ds9n5Ved4dhzT2emQG6bAi5m+Yj47TQbWZYyMEaZ5 +NrsmZrOzq5gAcpzMrtUEQ4YJLzX1WLNKZWMyuzbmNVvFtKgx2qI0KXOqTbnG3Crmsutyp8UkkZr/ +htnVOo8sy0x28bSxTcoeFmKiRxeDU62v6yzymJnsXMxk18ZMdiZmsgsmlmFaQE0VF7QvrYmZ7HwY +ZbLjvCkmMs5KnVWHqexsn8rueJDKrrRdst2uZJ7/VCtnLrt61bUfk5Z1HWQuO7vKxsBcdmHVj7JL +ZRfjrxsw2Ey7plG/eSq7ph3lsvOjXHYxvRBXjEi26hCKGOZ1xetVt+AZOnkTYhq7SrHLh1Eau1YR +UXEpol3CpCyLnely2B0Pc9iVYZVQn71s2pjELo2j0Q1Vew3OJl3QJHbtKtuBMVg7bsBBCruYwa5a +pR2cprLf4ym1aCIDTGFXpZTGVR8/3pGSLNMQISfMa8d0UBFCAlWmTMptR8N6EpbIXKJyiQ4mMphI +ZU8pEzVNxHRdYjtNN9RoHgC8H6aMds0wZXSTMufVlYbnZ31o6mxnxU5qtlSNDY7j0JSqmo6HQ9Wk +q950c5HnG4oTyOStHF36ZrwIMctlyNapGC/lKG90EgczXChGyFKMkSmSrTbDt2KMksUYZ4sxUhdj +rC9Gu6KY7ptivLWK0dYrxluzGO/dYri1i+neLwbkodFTKUuF2aWLVhIDT5HjlC7akArVKTAYzq2R +ShVTOqaHddOTumJMCwfpomHZOE7ponuKWowobpER42JMqIsMk1PxPF10aiPhct+RQbroKvTjKfIB +xTEX2aA5K0U/LXHqinzu4vwW/QQPzsPG9etU5AuVn6tVf/AX3WJHdOjP5mJ0fK86lCp6nBqmim4j +stbOR9HUVrE43b2ZKbqJbWSJonVXRK1A1rPGh4xrKRLxLvLdFHdckW857dN42xbZvo07u/8m7v2O +E+sIRMatjbNEh1VHaIoJNcpYw45k9V8lqtZxmB3py9hQTRRd96xqTBSdcoKzFSaKTvgfFEkYQu56 +vjgmivarYkTMi0TN95mG9pmG9pmG9pmG9pmG7D7T0D7T0BhJ95mG9pmG9pmG9pmGtiXTEEIkk0Pv +wKW3gp0FDH5tGmQ3uOphCPhULRIDPimPwGSiURYiWlGgsZTZ1PovGKTCbghWFdtMeAspJNgQLe56 +91dbOZP8QRTz5BRhWt3egRspZpleHucKb7kJsPh3rho1g/GZZqDWhTTWxrTPKaBbbwNAeK7rLkKy +TJcPE1JZx0iQMq6NoYiMiBRrVNNCuV29FGjEdGrGwPrHyDRZieSsEIPNfZ/2xKdU9lXsEz7n+Ylw +lpQ8v1IfsXBIvzh14olpBVqpKyp9TERxRgdTbK3i7HCV1EfBRCN3FcoYcO3iNQVQJRCiQdwJos5J +bRkT5OpX7WEb7QrJwBAO26aNccqhtdEPqjUu0k/PDShj0vgiLGsdvPLGdYyMJoQOV5zC7BuZm5hC +V3c9EjPEik2lGapgESxjVgrP65Actk20yVf0M5Ep8eohAZuerhsjtNXE0/CmiVJD49VdlSaYkpfA +1KaHwFNBpGuiYwRZqltsX5EDTtWpMUcLXpKjY4c8DL2+7vtcMc7c5gOrY9h2N/g6uUem+YHGx8QL +K+IUNtS2ux4UQDvixHO8jOGMqRjSkEoSzp5MAhe0Jax7SXbQ+9r1ANpVm3SrWfomJiSoyMXINFTl +AA0FZGkrAciQaXEm+hoxjTEAaYNCU6V6eGtDaiZQqUgDAgAttGIm5sHWlNFeu5YljK5iiv8Y2K6J +LbJs0UFNvqorSl+UvNdjpa4VmuW/Sum/9ToZp56alr4tmuTfRHcykqs66u87AA2/0RMkgpAimumb +QeKR5CEl+icARBO4U5XJ+lfiYHGkb3F0Md8/iVLKx3/GhP/quJRl/DfqKrkmP/TZQTFImh6T/vsm +q2GUh1ozDqErLpkd66A50ZvogcPOjnJec0TFZNjMnm2izVOJPaZvMFckK9YmUqNfBRjSqqZfBuT0 +bqo4XcRzJWNMgKGrqfp4V8a7Am0Vxf8Q0rMSTOdc/oFSd2JU0+X/z7Guu8iEqEoHY2oeY1oLpnMZ +ZUWP+Z7oJa+K9fwSAPVgi/nVY/L17oe6WXbJ17N7AGrVlGYXAcTr/chsnR0MOhPTsQ== + + + o8NWO5zfBbDqksyfHWSsZbqGxU6z1cdE6kyt3pjUnKyM0cz3dSRXvtFFlmWMpFt5BEGXJg7PJk/4 +PkV6xLJ0J0qH8V3G/rN4KwAnf3gtAFDcqMt6d1FAWZI8nB30IJfON+QCqeBZgEO81J2gtzccKkek +mrLSM4S9TYxMxzcF6ND9aspJPZRDq4z+EtM4fFlHmK01Dh/Jc7Djgy1L9ls4ctwI8sPVQd1ojpXx +hwJHgp305dHZzCqP7q3S1AZOoC6rsgvjWBO5MWUoM+gyljKKXMuZSpWhNmErtclNGEstuQlrGcXY +xcxlFNs2YC9RciMGU2MiNmAxNcRiEyaTCoWN2EwGhixnNGMA53JWE2PckNlEeqnl7CZCSTdgOL96 +sxHLCYl6A6aTcUXL2U7GKC1lPKXQBqynllrKfLKDC9lP6uqWMaAIttqABcUab8CEAqOWs6HA3oWM +KLOibcCKUnG0CTNKYrARO0oCtBFDGgPEl7GkSmKXMqVK0TdhS/UU2YQx1VC4TVhTPZ83YE41Pdkm +7Kk2uQmDGtNrLmdRNevAciZV+aXlbKqW24RRHSkK2y7y/zvYqjRTZRr6lZrTNBip1li0xuqdiYHn +unVKRDs+TrpKUluAs0JoJPquTBA8mNUjWf1wS96RyuFgLJoDErn81N9ReSibrtGLZCGbc2CHV49+ +V+IaX+w7ujs47D/Vqg4HdLwJny4HrzHxClVhT3TXBFM5ONcipawgMWi/BmmzwfG3Teg/OzqbXePR +/TX6ViZeaFFe7f2s+pqVjerlJWvLPBMbrC5tcMvXV4ptssIPIDhZbZMx1ldM21CajPsWoqZMeOTP +kQfSDJl42+W8RC7heGdpiPHALV0xbbpgDdxOa9V5NhJeq8YTADQ3qfB4td5QSglFKb5Ga/RXwDEs +Pbt1kISU9LYa0Nv+srbBBZ0Z3SZVrwbkXX6RYSQIywEAA9EhbGD1GdxcR2/CuuEVlPKtiV7eZJgp +mLhoCYGYN5nvjeTkBkETUVStD5kPRQbdItYF+I8dgg4hjXTQTg4/5eZLXx2dza3v6L76Kqu+mYNK +7997a5BOI/WXop2mEl6MeNxGS1GP1GE58ml2msXox0lajoAsthwFHyAQnZoAGcagn7jqE24FBpMr +S0l1QxOJUlJKMOCpSvoxD0eKCiqBKjGTBgBfNTGerwUHjGEiJYf6W4GLliExIQWfMXIpY1LDZFjS +pZSpIYoFPVNDxieQ1XQ9f9TGLNpn/Y2UwwspQ70asFmhWg01hSV0AXSz1GqZ1ckeRhlUKDOiYiBN +YYDqC8Zs1Ej5m+RWryIhc3NMJnsj6iCNVG3d6h6FfoKCdBDmmUJXEBQT8VRwBMdzA0HRjb/FPkYm +pf5b5JWfW+/RvfXKrtHkw4OKH1KoTbAvy3G1AP+01GIM1GJLcTA1thALlb1fioex1DJM1JldiosP +kQlS6VpT0jtDd1hQRfgOQvPm6uQ8jaiUOukFgWUMY2khP6vjoyXxr+UQMDGwFi68OA2SLrG/XrhO +Jglqv4AGlCbZmVbTXlBXwFTXGn4YYnQFtB5B4xtVdAHXyOgKCK3BrCZD2nAz1vBu5z6QmaSrvAiE +LQcu+8HB153pjJinvxp/astWv+i/5VacVevRfbUiHpETMqj1gX04XV4FLl1glbcXL3FqbOEia7HF +y7wWz5G1Sbb+vXmbPlsemQ+/nN/9VoNCNfHmdwcIgxbCRjnWCwluKQm3CLfuksuczs/ObWuEEcqc +NEgNyxNdKGUjC+egEY3yta0RL2JgPlF1U1k3vgOQfSf7kSDMNGlxaiQIaxWOLdUqz0yDHts9xinB +LO4V3TI1j/ca0LC7J8TTbxnkD0UJNfeO8a4JYlWHD46p1VTVGttDjVfVPTPmn7cXd180oxqaYRsa +kWc1joszdtJDoD2zbEVvfG/0i9RqelbZAv3qvvCjGvywjePJWDEHjoKfzcbfQWLvpZDxdT9e4QT1 +fTf+GnkfSt9B6lEN9agNeLsqpB9/B4m9T3Wm0aVW+/GnfiWIG9XgRm0cT8aK8Rfjzl1loNj/Ap0B +O58GWEznoEB3qgxNivE8FuPmNThvNA/FeBhdxWmcxXQqug5234ynsxjP+PF05JwO4uFgNhIkDYOY +2WSTQdQczIWiZsg+8aM6/KAVPbIBySYiQdIIUqXdGGO72TSkrvWfNKM6mkErx5PxRs9oBAHRXgJF +iRf56YppGkuvKpqUGRF3eehNFBQKNU8oEx7LMnq1cXUQDAe3nquThcKE22t5OXlXE+7wMVDEh3iD +RdHAmtEGDdipyVLKy9oFTTbsyuEjc2yYHlagnQbRVDY+1PEN8M/i1qkSvOEJn2xM1NfV4+JrtJN+ +E3HVCOiy0oehCtiGwpRDQ+yhkqJnb2tq4vFwSo9BfbLOX8EXyQQdexpPSfbSNCxV80YGxOAxAyMq +bmgMNC2Ts7ooSJcMQc96d3yQ9f7kQMdWd5Bs3NmESKFssk4O8nlMNXQ9zQeCgcVjF3byljnUBL/I +B19hoiyde5G0wsbDCXlkkO4DrBWlauA6NdMRUDIY1VddqWNNyRwNRtZx0yCyzNICWuHuALfqATUS +RjSrvlCjyfRi8AW9AaJdhYmcW0hjghJIUMR87GqO7gCNpnRJZY6zsQqf5oLm9A5yljP7gOw4OkD0 +EEhuVLpM5ug4ns24x0oj/mpoH5yms5M9rzFFBOG+B69CDQ57ZJfJQB75IdpavbYSEAINM212dZku +EC41mCB03PJMHNx/5YX3w3VOfU0dJGuwg3X96mpKfR+P7yzFZdx3qcvRzc0lb3Vxfz29uzu/vf79 +9emPl+d//Hjx9vyDXupi+6tfuo/+/f7m9u7vv76P974IPsnaemjGSmWrvVNN+O/+dn56+efTu9uL +f8t3g0ra7y8vzs6/Pzu9vLj+6Y+3F2//3/NfY3XTFv8mzOiHu9tTdL9vdzEX+/Hy8vxuVayOTs9+ ++dfp7VvNh7jwFhnDePsqJly2iCrlM73YVwkUn3wKHcQZFZPVVquuYDH8vDA+/gJzFX9y92QfDWvo +ymkI1oqtDHoy+DJ1/rgfx/zLS1bwXyiRqUgmS6gmbriaps6VsxIOBRTt0gO0u5WIdaGGVNR+9itL +dLJW1ATHLGkY8EozdTKrVDdJaYpW6V0qo6+s6yanS0ysL4usTKEfc3H7pe3bK/KOxGXtFnWVri9Q +FxRikv6KGY75m//1T7E1v4qNUTSs4hfxg8iVr1QCiC/Sl1oUZD52uKu/ayT24vig686GcV2s6ir+ +6ppQsO0s3Ph5mXKkruKQ885Eey37e9n97oed3hWxzvgTn3bvuyLx27Ouf5cjkbr2XTDGf8R4jE7U +Xf3ErCTqOaILxpgRPMV7MwwjWdQnRG/wAjCavhWQMifw1i0fc2HzIZVPP/oibCY+HqdOxGe9+8X0 +H4yq65tigGPqxMnBuIupmkJZ1zTOdHAikYWnlZnnNK9rxF/kYOErm+6eBotnUwJ5fmhjfHzbdmW7 +56ROZ7CMSZec6FP6ti9kVqmFgu0ZBVLWjfcXsvFB03HsOt0PaMqEixBpntnB25KEqHLVmrtT431Q +ZXQVY+Y9z2wPq/iGmqzKcN2CZTo1T1Va0X/gqpgL86GildOrLY/ONm71aHGruFOqRpriXvO2ngI8 +nC1cNhBowrfqyNXvm+QfmXaOJlOeu3eSgjjunuxx7v7putPtIF4yOnMP0drW76Ls8bF9pDfrlT2t +qeJERYJpOoL54BZL0xc3mXqpztpmydem7fq+ZKtF0mpS8vOHt1saz8n9wxacMmMoLf++J7Driatd +DQGRiIAf8IG+wXoVgaOXw2H06GmYRAXip6Fxpux+wc48fMfCTdsVzuuGgjHR0KwneY9ixx90YYHF +g5e/gdjAvxGZC++lNZZXHzOtK8XTfNfCut1obsSMxDAm85A5ZdeVgAOLbducssxs42huG2D1kCAw +oyOferPkPzpe/+OQWy9MvEbTHGofrg4a3hRNf+aqCTU2egIZOkmna6wG5e49IazjotWhRJ7DeESI +RAvd/UNHBBiPKuYeps9h/yqYulIfXCHXlXqsj1bQQ5vTPlbYxUtnh8fEwpaPNmgZZtMKgbjZUQFe +XogDpO5SJHyRVxv8KMuGPHwdGluRq5d+V4CYPmWk8Pc1mHkG7uraGV/J51cdCApA31Tx9hLeBG24 +tKMSicGWY1BfQEMGtc/Vgd4B3RXU91AkGmoqJiXWgh4Sq3/Dq1tlwPVvV7/7XkTf659Wvzk6+ubs +7OPV327uKMNmWD05OvVEWNNzDezu+t5/0/d+TblEhNf09Hf58+p3f7m5+9v52c3tW8H8/2RH1HJY +8Z4R6B59MPB+sRO5/vibP/0x7pW/v7u5vdJXcZSyud/e/Hj+5ps/tW+kE9/f/Xp5/qZvWr9aOGvZ +4REeMnR9Ph3Hkyslvr351wYXNHyZ6gjHDLgu+Kqlys5WpefVPgbeSHWYEmXPDJx2lVLg8qFQQ3NT +k2cO6jGx103sdRNbp5to6sgixyQRA+nrszPNloxczhdXVPqlX0OeuVJnwcgzs+znZ5nBnTgDR6LE +NPsGZ95DTLNrkEzR3MPRIgzQhDHPha1xX5EqqLPHkG2e1crR7FYggNMI8PkY5zXscq1eJzG3Mo1I +MWFlgp3kMAOjZrwCWIMt1oG6kmwgxpFGUBdLgWu4yzpd4Tvsx2P8dyNTJAR4pey3Yc7EB9hves45 ++jxYJeE9FxsC2uZ8I8S2GjHf8HvHCfFw0cbx/u2zjds8WtwmjilnPz/T7VJaIyS+gW37KgPJUuvy +ZKAygnx3xVgHglilF8p0oHz5S9eky+pFnHL5ZzDyxlvDehgafQBWTWFxCCfTUaXTre81bzeu9A5h +25Vv9OO8P1078E0cgvLRNfHie/nI2MFX2UxNQV2Ta0APSxsRTcpPkTYmXbsaALueMA53MksDaDc2 +DZqzY+CauWLY5ni21nTq00SZAjTCVK0PGgYrvYMIWddPIs0sWpXsnG9eiTTzh5vbvYV1b2HdSzF7 +KWZvYd1bWPcW1r2FdW9h3VtY9xbW3bSwTuypVwdT42mxxsS6xhD7rDZWozdz3GtjBddrHyvrEClW +VotMrJOGj5Y3/FQW1mKNiTW3pxZr7K332liLdUbWqWkyN11Oi6yHPb2ZdV3nmREqM7OuGcy6gp9H +O1EF3F9p9rbWJ9VOnJy/u9vbWve21r2WYq+l2Nta97bWJ7S14nIfZjG6Oij1CkDNOCjyiKHpKMGS +tfWErFiM8B2DkrE1K7gG1Feftf+5jasGgXcIhW2tEujeWNmizaB2TiYXGtpWEcCGG7sfLNrQvDQy +ri5p82hxmziWvBem+TOz2yXvdIRGiSZPZ4kLCZZMZycZLJkyAasmMNxz2Li1oGTwzArmoPJeUDK2 +ZaDUWcUiBuGWg172H6SbB1Nfac8rW5LJuMXKvE/pfQbqO4DctI1bBxnMVbVm/sbtrw== + + + hz0oVnwOqWLaOUoV01H0wH6wWfG1wH4camHtZjdvN/9o3VRtKqoUiRYgrVktWB9gh3oCEWVDCeXV +2E//dvHTz3sRZS+i7EWUvYiyF1H2IspTiih6eWiSI2KIjK1yaaMDZTJJKrgO1Esg9Pd0KoCk17l8 +Mmz8GYWUoAO6T0hBep3KPVK0sZrGZLaUMml07AH6eKNPJaXQvTKuXRRSaOLxNq0dX+dSgUJ6LjVB +evmCvnsjCJa88utAmUCTCg5B5X2gnrOdDKOzU6Qac+EkgvLi5jDlYJnABiOtJmMnpOe8Wcr5NHvD +xteCnlwwmQw4RZWNh5xBcyFkOuwelosc+dCzVoeiy2Tu7xVKvnhp4B/v96LAXhTYiwJ7UWAvCuxF +gacTBRIbTm6/9ikwjCBkLLZ93BZ88XqQRnV4vTjblzasYhSYyT9LgsIaSGzwZNqHpwwK4+09Ax5b +BqbcORKrr4kJC4+UbJD4s3kgJuyxJqchYY80iePJDlLWfx5xoAvU0TQZnUDQ4BARgC5g4t56SOLO +10GqMYSRf3HZVRxYB+rKZaBUeZF40QyUAtAy0HQ0nVwweJWCwVJEUtZ239AU1MUydfMxhXTFWHde +zbQH9wAfFBAE87wRtueTBITxIK8GwCxkazrQDNYNLYZ2DSBrRxajxYZTvqY/n+JlVWg+C9zHysSu +RvpKh+3mKSwYi5bjNcksd3cyECFRq+9uT69/Ot8oBAzWX9zqAR/peBA1wg4hE34CFaE6DNbbFZLo +elyIlQAl0qWmh6J7nSoouhpSKx3k+ICgJgOdHLCc7SGTmvN2x52KhVPZVH3f4GSo9553JtTK7UBj +VnfcTllVDx54hXAatcF1o6ap5MjgocB3uCWpDI1eOiQciTkMpqxGfA/S5uvlgQ+Xhscz0qePYikW +tn20SdtgjOQ/Pz4CbVP6wFOttSUOT9N475NazeEHqI/XiwtEKNO7/HAoMg9RhwoucUOympb3rSSQ +LLeLuOB59W4ClLK06Xd6l0qnwh0yxOccGVzHD7FU1YOKcbVF3mYx6VFXQdfpDO+7lieD7VIoZRsi +8YT5vsm6GXgJYoIVCEVkT4KgLNMBJIh2ND7gLe+ZSjV0FWQ7Y9TLvt1xoXGteZOTDk36PBns8XT8 +94mXvUvxqNs8QieDmww/76kU6B9P8sd+MqcTPlmW47w72QC+erNmVAIc1zhpdNjHYRfHAxqPeLx2 +x1k38l5M5u9eYC4GV269jJ9Onrrm1VHIGl8iX7nsZY+UCmqYiG/Ty5PJ5/cS5dZGCTS41q+6sAUv +Va+JbWNW98ZUvJbG4CKkJufpyzYcOgT6CFOP26kGMqisC/JNaDTUg2VDpVd3Czlc3ODRJg2W8VLI +Ef39RPWYsGm81dzFJPmyZO4wxhadpLfp5cnk80TA6lrh1SGz5F8lQHwWElJltQ4/XgN4+piESYdl +n2Rd7D7oujQp8gWEIlR+/X7/XBceKRdrP5GLFXbCGVy2kxjYygU8gZzzTTjErXauByjvGh+K7nUq +W6BwqhYPckBlT8qspg8n1eSNjHuQ9S7r9vFgEI+ypkIDedN4ZE2dMGD1w1F3uOUDdzWbRviV2oYh +h1fDklprBBZu2xzG+PpGgLxj6+HCAeRpEou3rOWjTVoWYnfYNJ+bLe3Wu6JxB+xdE1x8RttxzfVa +3wSIDJDVNdd3qShLdutcqdll8Bz50O7jYlxVkbdTTHpRDHtZDAdxPBpUx3v2qK12rCEgcp16wUbN +XjWx3fbQGF5cniDarfiAt7y0NBXX0j2mD/oU2xp8O64pb2bSiWEnh2M4PhiP6THuMu9Vx1r2g8h7 +xrti866BkeweT/LHfsZGUzrubtaF1GM5n6aQQS2TVoadGvZpPILB+EZr1DfdtVzMgAw4xyq7MTLb +g/f+0H8ZRtkNG3d7N8xUCxCTFkWQIE44bF2bgYQ/4+1aiKmk7izUelERQ2l9G3cq7tDBjZvke7vt +BWsKQmK7LcZ+ed4ZP9h2lQo48R5wvby+750+Hx8MdiJA2U5PoGJSb7Gu9WLSx2IyjGI61ILTgbs9 +03QUmDFfZvM6nWkkzlh3JeSaJYk4MlwUAW6wLJRyNlgYLbdwaQajSYuj+32T5VEhcoMFQsHNlmi0 +0erIobVj2aw91KuorAa0C4uOEzuYDlI1moG4ho5Jqk7PYGTS74IvZT5S4UJLN6tUfwc4O2iEEniT +gYTFbXEPd1dLApBXir9T86l06t54AMeTIc1PAQVjZovelwj91kHKWoTWruGkoDbDrY6aCio+FMGU +/hC5BISzK/W+8d514bNIZt2EGs2CcoUJpfmqA8mc+TihroHTTwLwiIy/07tUOhXupi8+HwMjcN1d +BxHhxClGaA3pGbWn313TqXAxrr/oG4jCYoYqcWQ1rmxnFrsIEoRL1es9cQnAtpvUL32XSqfCGWLE +hmXsAc5+CRJsmhutIT1z3mw3qfoyFS7G9Rd9AxPQ/TzGwB+ib/gqexq3rJXa0cD0bvrh4O1qPDn9 +xOHrybxOZn4yEhSbTMFkkvqBjG/RrZru7I/uEyJJ6w2KwoeWOB6I2j7gtseOmJ50n+Er2+aQruDn +SXQBqxUlhHi3sCs7JbgqYYQUmaZWBU4DoWGkMpIzgpqshwuD57KmiSqjhS0ebdJiyRwhnz21BW17 +ugy4VZwsWaX3P0etEV+ntyfTApneqIkvWldXVjVHjZZWyAlwo697XGAt6Fn0R32jTRlZoNjRHIn7 +T9m90g9gXfEvQJvUJbZoP68a6Q+n/7y5vbiL2qP/SDLG57w3G5eZ49rmwsGvqoK5QfjCmreJJhDk +nhp0EwAY1JC9rIXyw4EVrFp1ygw1VE221Ss+cSep8erM2QbHK7U1m5XV5+ODBGmRw0YdO5DhCF6W +sqlwG6iUlRe8PJoWOkU/3Laa+qZupxasb/cRa2marhZeM5sa0Wtmu16c6B21hteBx54WHAwhcTC8 +lxfNZiOmaFrz0tE4LQVnzlX9zBWcXhwmWX+bdBdv95W0K7waHCx5u26VjRMZfmqoCHBfdLzeM32F +ipA6pl+o8WIedz6X8YWMLK0yEvZ424MCbCmhYovc047twq/OIPHeMUm70QmRacMHzob0AR1Hw2EQ +1AypDr1lhVeTuvGEJMix+geGss2/qukGRQCvhxWA3mzspNVWkxnKaW6M+iOXoaYXJJKXAoLp43zq +YV8HzX+IR1qU60rdSQ8NrMIy297KqFQmamRSVzjCKpMjHNhjdpef+PgJrgT3muSItYBtxp22itba +kl6NG1G/DlSEsqum6yo9QKH560fDEXuTD5mz4vtZwbw1TTZvk2U+nq78/e6tT+wxUmEOeM+r/HUr +j6uAed2r9VZFkO267vV/nF/SbZ5k99snIL3Y2bbRa5Jq+koZSByhpR9nQD7eQ71kGRSr5P+hJsmA +xbhEMa4UNwZXijZAWNx4nQDdcyrTF0nVplpTm+wHu5FBRh9Pahs1N+7OtMfv4MZdYr+nv1eaVxW5 +/kDkZWMK20WRk6ijnc5AxfjzYlyjfE/nEvk+4HQj2YiAooPwa9K4vliquujqTg0X7EzB3gBmuTDN +alIi1ZZVO2l73LvpALiPEfRQO6WQ3rk63nZVchJkq8Fjyad8+kFoAfU3PDcyCO+HjpkYEwzXuwdk +kEY9coySdrb0faTqqK51Ouxh6Z16foj4ZflDzf6ywnVj9JUw44GXxztYOY55pb0jwYMKSThn9YdU +gRsOA5wfB5VEzaxx8OmGT0/KI4eUFY4u8IVFDmurJmpdCNN9RY4OzL7F4WZ7yNmB4dlkepDIea0m +KUUIXgPrMNZQzzEdroO3omsIIW8h01Yy4qONC94BAo4HmZizgw4kK1PVNWLX4jiFJlKLZ8A8WToM +QIhwekN4U7Ytrq4XwbQOvDUd52TgDeGl1MPpMKWpeCE77u6W7ccrwgNDT6AC8tbw4nHnPduB73yj +7cCd/hAOl5xEkV8qFMLZwnMHhBn3oMunVf8ke73CWI4PMlAIvlG/XJmbZggIlNQPVT0oG4ETK4tP +g7T0q7YI7wsRDX1ccFxljuWSCSKvZJjRlH5xuJ0dKOyiCN9Lm4e+sTW1QE2rF5zLyQ2ATCDcjjEN +bfBoBzjqSo6ybuDsQBStiaKYUNcDQpx0FlIQWqiF8YLLaaWpWF0rJ/1kM2KTgi8I5JTQ09oadYsH +a2A7ELippmqZJNDBBtoDsDBl0CWKIJkFoFNXiexLr8xKailChK4IWsIFPEE8wmlBtLWO7rFrpYPE +jnQVpJ5OhnNGXfqz3BFP+/IWsgo3V+eRVTBPwio4H7X7ggImBKiV5LQUplszKLeyFxgFE0GuVJPX +CVD2XhA42rK2yVmcUr36TDqyx2xUUdOWgQwzTAcrftEqoDqsbODeE5m/bXIYa2JwDgDtGoCWAkDq +RfxLX/NkwCcp03mpZW3Nyq7kAFRDQwScdICm72YAywmfsimoK1aw5hDWQOBFzvxFelWLThQY9oY2 +ldSl7LNRLx9W23y+TSLHay0sfiVHMg4Ojz2u+ZJbU7dbuHG+u/1xVayOLj9y+5ikRTVztwVlJXKe +pMdXHcTZQyWVQS/uocMzCXKRgQp+XvWfd4BUI07TBBKU1KM/VmARYWQQO5R+nR2M33U9jIXHPT6b +Ydhx7rfxAwRCGA93EfyL4FQyKw4HbuVWcn4jqAf6Euh+2ZZVegke1Qs94kUflEZx20cjvXUii/Xm +nU3UdDP79Pn1dVGLaSDGDqfRPjaNUz25DH7o9ElcHOChkKnWusD4HuHukPQtgUQYOySng3TNLbAk +AYRpa8m6ApU6mFA+owGzrAYiGc6K9IOIZEqqcghgybov2T93tSdQ6kGqIXWx7/9xNpZZlkXoNzXs +xnuaf4VtdnrJjHDZzZr4AaHfRv5R3EsPvGRGSBO8fE2QQ0CYpmlUdLCNo+XQl2BZpdkqYMv0nhS0 +KhpQODlTZZfVrZ6lvD8BsmIDq6WLzzIvVeBUSd1QM/WAOHfHBwlENqhqVqkGCGFNmjv+OubFGW3d +hA5UsHTVl+4AWQsZLHajq0e7mbqfVHZ4riOqWd4nkRMs4IFMYZVDsrYiDAoivTgg1uHAK3M86dex +kqyqf5dIVCqcnvPp6kCxF6mOQgNLXK3aQioKN4umnrR6lQFT18Zd74elwdajUU/nZTJ5LDed5HwN +dFyMvM5GPZmSyQDGxsOmv1QB8kzdUxoIc5YGbUeDJdzNe5iw3dDM0luXQS2d1hle1pA6EkAPOyH7 +2TcWPtA2qyUBUlNnBx0IgmfjU2w1qkHotqHgmdrqIJRPtEP9V12n+6omY5tzBBr/EPGGOBZJjf4s +eLtB62yt3uV6S0tHaDDdIZtuA+mSkV0i3ZY+XfMdYV6FLbDNxrron6KR54fJUEmA6s3IBmcfNSKV +hiqrpwPExs4OMlh300dXUZtUGqm1CFBNVOxS91HX666i8dg+fbrlnBHqX+mEpwdNhA== + + + WosQHCw01qVeTxlnXENqYeYXtqdi/EQHahGG1ai1OKUIUtUZtEwuVB1AZwriVPZNjIPva4mA1NLZ +QQcSKb2KPrtaC5Lbli5rKQF0ctmb/pvY376W0Zg+fWahDkHgh+YSiQ/IJQJ1B+LcSqh5qhyXW7gS +lXoxjwZZdxBsWivMRUOCpBhHTZuP8fMdALowF93HIkj2aRuMKkFjPRkoNkYtVQfz1H6suqpE+Kla +F/rmEgDa0dilBOqHEWsZj+vTJ7cSGRNX23Fy0wNYEjARvJRJmHI0lROKjP+THd1oHFxJ76irHtLG +mBEh9VS4FgyZC0AwVTh1AMw0JsP1IAPxGnJ2qqUDxIa4Oh0ECsNVVwnSJfBqpNRQAkDzEzuTQPkA +WMt4RJ+BEsO/zydaHB8KTXQGUZ8XXzmXSxyFIJy3IHU4Y2oNn+9giNGkXyGU2m1JdbFRHjrQ58v1 +EMHGVqguNWHdVwbqKvCCXU0dJLWHzZ5gQsKcDVyMWBNUv6Q0XXsJcnbQ96r7qut5V9NkfJ+DAuMM +rRMF1gdQYKd+cLw1xoP5v/fQcyKg1oYKFlO2FGoSCHp8q3bMumqpo+TJAfMjQnTTM7ax6vATRF04 +fV9FB+iaOTvoYQa3HLlVqkX1LepvwIY6wNlB6ksH6vofK5mM5zMgs8yhicdc/I1UKkEOVIdjzlh4 +mOfEmELjiGggY5lfUR3gaciSEzO0NfXK1KRb2BTaGBSMk0bIkLKfmFZICse4s5N+mJ1B3TbJPx6O +TUJJBdAkEsEI8jO4ZCjHARNwwwxrmhinjYYPC30y1kgK6j6QpajBqxqmHPHqFAdLDO4Z4q23Isy7 +UDfQbDFIkAZJz4wrvGyKrMChUyV+9Nai+bDhB1QcH/Pwd60aC9O2ZugZ4QEWkuG8nd0bOlSpO1zZ +0t0Ls8hcHmULY5zMmnMaYFmnPwDSDRPGCLh+1hYpf5oYXMSsO3VMv9OESIaD1X3AoFc58CoIc7rP +XFtpZJEX1JCZhHVFfoloWK0p29QBV/85OHo3/rCsW03/iIlI3he+bNt5zcJ1DmsVKrVKiIRu15as +gUDOa7B7G5QyzOsx1UT0XxYCI1x/8O1jKYQe8+tatCxPc71y08ga+Jl+cknDtE6t9CACPqxnohmr +pxVC9RzMZgXcGFtsTXrptD6ooV8DmKkzr6ioL7G5anidUNkhRBen+rFUVGt8EkA4BerkluNgecRz +q2ZAPMNj5gxkyajrkkhQsKvy8m3llWkZgkG7JhOImyRIYHHyMLWAHHFkkSs4gmPjh+hRhd6SfAgl +iAxjStZpsePryJ5giCQfQVmYGqUBQFKH4wNSB3CFNjrFJIYIGhcpMp25zegFQhDrlijZtjX/Uk4o +YdcUAtrUuAgCiicjB1aFUiGSDdjTyIDVpNC0H9b08kJeDtvayGq2hqymx1eyy0A3RNauIMjRJBPk +G9lnfk1508Bnpm2g0DAglJDrjpR7adR4I9MMY8m8tkEBKmRLokkTBALpUdYUlV3Pw5eydOu9Eo+5 +3Y6yeK06P3qRfhr52GiVnsZbFBjc2JenIk2uzZDt1NhonG5VW11pkiUczK5RsYvHOT0fDR3lNIEK +3EBIZ+gtdxhaQ6cEJlziV5ro0TE3g14wyTvtCkf+l2oJC20G7YSNipKmVhdGuGAG6Jzg+E3RR8hP +CI2a1gU56VlKX3t0ENwzDOm85BXbS/ieJHOfgSUKTjhu8DuUvZA5UFkX+hLgGb0Haw9cOIbZUU5b +TSlIHYLVkmA3m0odCAYztzERqWB1A1q6hgebMU7dA2XryMBLaM0xVmnskCKBCqj+MOrWYPSku0Lp +QtAsG0YVASJVBOpYDFIr1HTXlyPdwrhMnaB3cGJt15S2Mm+luu0YJ0etSOUN/edh/HJ1klrLdl7D +R3RXK+E3L99XXm8mGZdDWINvEVRReshBLDavv8JqlzCxkmlpGar2yXRj8cI8ydUkIiuVpnxpqjHM +4a6GcarK4MnCXH11aJUhbYKjnFLLHqQIRlUu9pNtVXtGXbJuMVOpg5i6VIFjZcWVSjkAeK+FWojc +lO0s/XWYxSnw5iA1qsFfjl5fNGjX+gmdBlXXGpWeQbMcFmQpgvKwqg2R1ugkBqmQF2CdkazRo0AQ +Dvpnw68MPRA9PXu1nFpyfAxAV3JIEYWeZ6o26cwrjd7hOZ3HTeWW4MgS623g8W+ECp56BmCCV0Me +eJ74ZEIqMAVOlRaCySTUxtOhXqbdqJrWgwzLaslWboWdaDVLjBCDmpl3ZK4CBFG9U2xUGjcBHdKD +L4QSv5zmqgQz6hrGXlkZ0Lqi6xo+0rPJurpRby3j7NqisjNTnhn0TXmXeV3WW3DbCjSI02LMJ4sv +S1fnaZgPV8Ob8GXJCLzE1CPRqgsPHZMqMhY48mUHa+gpYiX0fOeuh5c7xBg1P5K8yGnMW3KDUI6K +z2rdivoWyMVwcxJ6UUNhS32U96qnok5EIzMcffla3alO38Bv05d0EQVzYqIBi7HODt6SpW7ZqHFu +DqPDH2CRCDaKQ4C0ldGvnMaIlAgzofev0qZjOsWqikvO1rKWUUBVBM9/UJG68lTGDCduY2bD0+fx +UGPRD2GXEWKETOC2Fn5bFWkyCdKu86FXcrRIriUEw8LbC14FcFYDla6cagzAR1kfhX4ckD/QGO1x +TkMU822Mwp0Urh04PuhKqxqmi8bXScfRgio5yPq4p2JOq0dqKrKVobhnS2PWFRQCAKFX1XJUsB3N +7a5QCMFSKBFpAijbMnw6p7FsVZ6CQMCbuWzcC/MZoO9MCFCY7IIYeN020UO9qqLWsmpi7Falvroi +PbbqTGHhOkWf8UqdYwHD0e+R4cbqR9RAw42ZX+sndRtVDi3Oa2xGpjQ0TfRlhWmrJTVAbD510vJp +dMBmuE3QnHHKw5R6Yx0IBB3c5bAhVbNwkG+jL7pI2XCbBcFoafhGagTmYFYnZEs1jSMABsZjmC1K +chl0FyyjsRce36BkpDrjSdyYr2CuwFJ9PPGnpZK+BSXyofZI4gYuP8TYtmjVsU0JFr2OmznmWvea +s0mDC4LI3YfUwgTh3aRKq7IJ9MTQEbROoK6s7yntaCKCs2JTNc0hQ66OaCyoYV9U3Qa593ltH+GO +TNc0ZYjKDe/uKwpWtaWngKCMvFcZZWa/UVwKUrsR+dhP5i4WrtETEA+mkRDO6qVllIFmo408POQP +bHEosHG6yj6hR7HzcR8LlghPoAY9nOCWDkoMEdG4QW5EXMtB8UGeoRxFYI3aVIURQNQELhRRNQAZ +fKgdpB2NIvExWgJyIv620Ho5BjPx4Kf1xVXgXxqmV4f7V82YzdaAHMgZSMOGof0D9MbFeCghgDUo +iCs10Xh5SI0mHfYs3cg1Xobxs1TvCjUD0aIxBQowqGOF3o3na2MOo61KhjdWzHcpbTYaYmPArllh +Z4SvR8RAG2xUSqs+A1bBkqEGXqSoFe77tF4d3xzJP3lzhmAy15mrayUaiFiESnMFzz8hvnLkTwsL +RwBbHKQsK7RfF+aI8+hhBoGpzMvxO69Z7HkPjgMxJ6YJ1CpPC9YQEVMCAqiXjuZ2l/JPwDxJWRA4 +33w6l7F8ZZ5EodEiNH9u4vgnIhad+3h+f0lL15wY6kDHrg4EDyvastsYJyYHG/NppJ+qWG+jBwVB +BUv7rnT/nBpQmSHCmqQeiNUgAAKGr7L/yfAlDXWLkL7PsfhkEPfu40aN2TF5okhVzHoR4oSIdCRz +KodaFMGEobYIBLSTrIoUsGBj8nIg0oM8uzeiQuJDbB2ctOxxlzHE0PhoHRxZ/AOlG6FNvgkaUT9M +q7iw6aOlTbM0pTO1ncTt94+hPmzqmjpFpAw4A5XgjboBMuk1QUvQiVdCL0aojTN0zMKvJ/L8z/Jv +uKfJv6HhKX0G1/KJAlSQHWMUoKKgTwhQwcF/X4BK9m4foLKzASr72JSU9e7ZYlM+MfHdPkRlH6Ky +SyEqtX0wRAWuPqMIFYAeCVAxzxigYuYEqNCtaRCfkg/sM4WnlPGG0PTQhaiY+SEqNosaucpheYiK +mYSoVKtxiIotP1OIilY0CFGpVpMQFTMJUbGDisZj+0whKjZOeXroQlQ+NUalGceoNJMYFYZdD2JU +RIAdxqjYZhKjIqBBjApqGcaoNNMYleYFYlRsdItOD12MSvU5g1TUK3oQo/LZIlSG8SlsaffDU1Ss +zMNTCMnDU5gOZlvCU9iZPDwlDaALT8lH9JnCU2IGkSI9dOEp1bOEp3DMw/CUdhKe0q4JT2nH4Sk6 +e9santKaRH31IYWn1OYzhqcg3/q2hKcw9/urCE8hyjwcntLMCE+xM8JTItfQhaeYUXhK3X6mABUk +jfrUAJU66EG/pREqjcZs8NKOByNUqi7ew64pmyJUmocjVMK8Zh+KUBmUfDBC5eEe7yNUXjpCpVFG +bTciVKTM8gCVxj0aoAJeZR+gsg9Q2QeobBagIlMzDFCBljMPUCnbehqgUm4YoALvqkGAilkeoNKO +AlTaSYBKGx4OUCknASp2ywNUmi5AJcSYDV4OCk993UyLY1QG5VOUSlgbpRKSrFqbuY2nOBWT4lT0 +XtZpUYaqhPmhKqPiDFZpUqzKZ/Ag3ceq3B+rgt3xWWJVfLxSsItViTq9PlbFbRKrQr5hFKtiy0ms +SjOJVXFrYlXaSaxKmBWrYh6PVRnM4wvEqtio8DCarnd9yIgNKWQk5LEqLBMDP+4PVYE9T0NVbB6q +UsVQlbKZ2W4fqlLHUBW7PrwGoSq4C2VNqMojPY6RKvU+UuUZI1VKM4xVMY/GqvhRrIofxapUk1gV +O4pVqR+PVeHFKU8TqtI8HqmSOK5tiVQxGqjiU6CKn4SMmDaFjJh2EKjSBX5Mi8YwFWGsYphKpBAM +UxHyr2Eqawqua7MPU3ExTMWvK8gwlTKkMJWmGYSpPNDZcZAKDqp9kMrnDFJp2icMUoH6chikQj/F +R4NUzCRIpZoTpNKGFwpSGUziNgSpmC5cw5nZQSq+WV96YZDKo23fH6QyKTorSOW+fu+DVJ41SAWK +xFGQCpxNhkEq5vEglXIUpFK1y4NUcN3IUwep+MVBKn4QpJLP1wsEqYhc2MQglRgtUqXAjfBojIqs +a4z6KM20cIpRka0XY1Rq08WolG2MUfHzWu1CVEwMUVlXjAEqYW18ysNdTfEpzT4+ZdviU9SP5774 +lOztp8SnNA/Fp2Qv9/Epuxyfch8qpfiUhch0f3zKfegU41MWItQ+PmVtfMrfvv9+EJbyeS8d0jtS +EUgAZ3a6lPUgf5hQw3nPONiWqwrlPTz8E+CM12ziXr/+k2ZYR/ccm1ELDUG8WpBpM7QOND9oJgHi +nYXoSvdN6mtXyXg82F7rseqHP5/840/fCkb95uzi9kwW2L757eprXoBTYtXlZbbQIWYhoPRk1KAF +HxlNFUDQCUBCOAI5HeF4GrVaOZiMaLOk60pb67WPLXyQoocnhokLBMuowalKmIiEmw== + + + omM+GigND6G6DmoWi6ACITzIGnBCvxlDj2n6wlS8VhA3rAq8cgGPwyEcTwYFL3kuS+2ygVKf3eRf +wW8V3Ap8I0KpoqTn1dF4ExrVR0UI7sgLTey0whKanBzYdBtvg9sD2WpjKvpqt5oxctSd40kHT57j +ajIsjlt5g0t8Df/STwjgSl3atuvSpe/PT2/PftY7pTWS6LNTDijZEQYN+QIpn64IClCAU+lKRQeM +rHDCMtHuAX2bt4xX594G+kMtJj8rXFkmx/Ild4TIPXRxbn2p3hj0/RFhqqorBcA1awXXAdyhQMd/ +06BxfiuLcgmpzDtfkYI0taG0JAMvqUlhm7x6DNdewi2+iXTJ6rUMFIPk7LpkLAIlIFywBsEMN/uW +8ZkZFWGfAYVsD7nxzqazc0ksnUSftPfHoXyM/2HpKI3PWDxEjUyWRYGLFwbn/mRpANxgcaTYdHkE +uMkCSbHpEgG4eJHWzBZqwoHxD048V+SrN/2aLF0LqNgsNb0Bdm2uBbwZoQFwKFMiNAlfQt9W0lTg +bWgUCO9JcKQQr5sQPxxVeS/wHclL6vg/8ktpQhRWnuSy+RYytiFC1bCB0XKrnvYJZLxqRAGwwEIo +S1oeA9B4NLh51IZDSw4VZk6HSeDFsYYnPEVY3NIORS2VgpXRk4FZunAGQYeLW25hEIY7EFw+0TUq +XFxyAYVXWVXXHcQjianlMgh/H3gxZs0LO72Ig6ohdZqlLl1Wy2tyDRNjmtYFjYDydFDhLeINQ+Fk +NNwjwMq2RIyYCAeqMJZJQd7L8bylALwEJycl310dIIKPytkEEuypvI+Z80Xk4rZpVGmN+0yD3uWK +2WHOUeG9NU6n5n2hev2j5jSEnVnz0mOutJzTu1fhutsyMlJ2k6+xvfWiX3jrwIFDxCYHLcjxAXx2 +NODDwUUOHAhVz010SE8LkZ557Tl/JQisa9DHqze5YehyqZfhWvrkHMPspv6FDaJ8aiaIidfgGFVa +y/6JLsvVYVWXLGTpq0fVmsaoqgsiNFYeuWh5H6bev04CydvV410nADVOr9csTVCW1dG8KEjone2X +ZLxqx5N1fPi+SDiHypIY287UaDz3Pe9NK8yZb3AGNLjnvQWywAEBl+VuIT90d3q7KlYi8v3628gQ +xTtcZ5K1Eqgh21olJDhJ8fDkXdInB3HPB3UCLQmCidFWvOVXRIAqsugl/cWAs96QUpeUgeu2xsOa +92uqmTY26VDf3TkB1oivlm1tapzaUJZ6uNNBg1NXLbRfY62XxbXE6jRcxN/QSyISWThz2jHLehAe +FoOrZX/SluCgpYRK2ZUOES1QkghhhQKxipc/V8IINCCUIhSKCB9jqyEcQd99dQC//lbDQR012icC +air6CPa3UzeRBwGo1OmzvC6LRru6hRWeM+pwexR8MyzLMUAJZmMYOXidLLz+DMPs4NTjlQyorh0+ +oIE3x/qamm6sB0QxLgSiTJtKr+CdvC8mlRTThoppb4ppl4s1AyvWjL9YM03FmtnMZvukjwaHXwQi +E65QtzeMiGnoP8P2NBGvnJ01qzUYhmMY8wn3TUoDankpcUnnaatEdfxyUHZY75qWs66NHmZHfmvI +92CMX71Z05TQyEFvhG7lXZXH8VBQaz9S5azHXxSjSopxI+vme9Ddk4NhaLdvIqMHQienviCHEBIE +Ybcxi4RsO6hoa7q2JExj2EwbmYUTSFEaj4Nb42HdwTisp9+i05A/GnqaEO2RMHMdU8nNOBDqNazj +qhk6lxRIRB8YlV8zxN13TvsnB3DiAxkq6GVf6h6CFoGmzxPIebXGJPcfIMCNqpi+GgTbachn3xj1 +mLiiKusTo5cQciALwkikk+lMnTyg7MaQhdHi3YRFU8PtS52O4VQ4oZsITW5AzD0YNbB/HolLasZr +hqaKWmJEngoWgM1VBvkHRNMKw8Lsx/BbQ8TKuqJ1UIVKsE00Ah2dbdzq0dxWYVVq1I5VQ681VGvf +x4ukk75cnd1cvb/5eP129eHn0/fnq6ubt/kx/7BafA1eq6J7hNkKHOE2RdBNsFs17yP8BrGYYLiI +jxMc/+rNGiznVu7xnCLzBNMFOsV1koYJtke9/QjfdRpGGL9mFk/u18cvWLpMPW6ehzN9YgayzxP1 +8VPZx/Z+/tE9xD/Sn3cN/1hF/nH0/lH+0XX8Y7sxA2nUZNpCEARTZxprAhlIL3tpTX4eqpl8St4Q +H2IkfGuQFqp1EEXz/DyfKTvPgIO0dHEZcpCWHkYDDtJGbmk5B+nIs8EB614O0n8ODtLP4iDz3izh +IEfjL9ZMU7FmNudxkG27kIN0D3GQbgEHOWx5KQf5EMM4rHkew+geZRjdJgzjuCsPMIx1OWYYsZE2 +YhgRyfJUDGPdmocZRrXHt00zi3EcVreMcbQTxjGfsc/MOMJVV1m4dinjiH1JFs7P4htNzzdu0OjR +zEZfnG0cYvditnE5ji9lG4eoeQ/buBbbH2Qfx9UuZx/tGvZxiPnPyT4uZ+Yuzn45Bz/3t/O3mzBz +sKc16kEOKzSSdyqkiH8TOD2X0SbIb7qX06/Sr7OD8btx4azi+BN+5gHwGmFoMGUAJ5zRMHhBgrIM +8NYUHq+sS34ZEOp0guQ+xjtmMAledW6V8AhdE/HHcT/yWUyhMSRztvUIpAHvUlawKpV0bQA1mNC5 +GliVLpdODwW5QSIbkmtr8pOJarGuKqEw0GPKsDu/K2fyH86KjNNyfCFomBS1iylxI6yimrmxKuuQ +APr/IkH1sVS/V513pgpA/pcSZlAN0WNqBMe0XK2hCcDQN8JwiRCIhYk3NQ5opjsoK/K1iMdJTehf +TfaYtR37NepmSWPNsK/F5Jsi1dnnd7QRkVMaSf0vB2jVTPNeM3AoveQ7BzNRSTmaDsbw/DOw5zn4 +S/CWQL0zFM+OWRkBaTSHDiGGMflWn40+N6575FQzS2zNvFEgRZwz44HodDp2TEHFAO3Y43wU/Mtw +PrvSMR/HsW+iIHQ2nhcPT5qamB+YtjNak5dMHDLdLpy6r95MJ+9e2INTiu4+PKmT7JJtxlHu6eYs +uokoSmUjeE4jLxgDi0vKtsasscf4oIliSTbTQ0G+SsiiU96sbpQ3G6W79a6kyb8VabvhDxMqZtIS +VlSJpDBpQIsSgfCISykRGoVwpT3Z3JPNPdn8/GSzGQji2BLgiUT+CC3diBIou+UKTD40N+gg9WG+ +4scJcCaCstHo4QhBekAIDfDCQeAIs+YwKDkcMgskJEBNfFbQ2Sa0YPqZRwB1VKte8OCjxic5Ui0C +8H86qORgABJZx29j9R45GJLb1jCxQ6XJ5xw8YB0yOdHqqVmBNQeTi/GScSJQSTpHBnP1UKACSKuT +uQZHWlQW90wi6gnebWtYU+dF1KNuDOnEEQxZgSQYlY+RbJDBv1avvQy2jv4pIoLXSGDHq6SQAho+ +QmuKWl9p6jqRw5G3QC+62bDRo5mNyuLCFg/p3TKkc0FAwhq87IGLMBOC7WLc/OrNUuxUyjMXP3Us +SzE0uu0txNHR7jcDpmmwBums1aSTeio26tzYgBrCCxL6VswJPRsNjviy5kkE2UgO9JYOkdRYWfnt +fTMA4SuPRElNzYxELZKeSNV1BCAbrmNOBRdz6UKTbPVG2KCZzdvDLnUpkz4xzQpDl4OmbGRuFnpY +AUSV9glAMQobXzlqbVv1oaPbn7JlzF9dU61s0nNk53ipqGxgREuTr2jhnsYrfTHprgThbhg7zbOx +NJqhmUnJTg7oBBvAewSvlhJEt/GMoHvgCXkRuBaSF2mUF9E8uIDgDALEMrob/bEBeFiXdM8bsyfp +171qQl/TL0cqa5nwvQ6yNAypast1JAoYVvNMhecOE6A4BMbxJi3E6KrazWnqsoC8R0wC+QNzgorQ +rJsywBC4tmhV45JmJGETcskdc3S2catHc1t1yA6KhE8m8DKwAY0yw6Sya5iPtGXUd3nhpgEVmGwb +bPLJxgFw+dYRxmSTzfPVmzXbh8DxBhLg/C2kvMySTcQSo20ksPFGIv813EoAjTcTYaPtBNjMDdWv +9tiy0dj7SOqYoWMSYjpz1vHGBD5X8G/V2wL4DOtpIIvHlDHYEJy0kjHydYXUdFABc/mfipEfQR6k +IqXsKgiIhpnx4OqKjJrrdHBEjBI5DGSfIjOskwONoe2BHtm8vKcxECsN8qQ2rWaeRRIZRPrw0nbg +zrhYbWkZlGIVAohK5mDcpLWjOa0F5vhk/haLhDzLyMYULRS2CDF4N8dS1HhSUWWwJ9yyPTGsC5lA +KtWPMOWIh4kIV2429JB/Gpy/B8OdJYZXFuoBaEBqzUEM+lnSFjNRmMiRxZSj9MOLsQiVAU+HGAQa +Y8gcM+0ao+Xd/8/ee+enkiQNgHsB7oAMAoQrXwWSEB4kIQvyFicJYYXpnp4/9rcX2OPsNfYae41N +U94X8KbVr/nmmzeoKisyMzIyXEZkJMEssaQEDCqJ2CmPEkvMPmV58WIyCuq/PKY+Et4JgS6jBMwt +KUb7G3tlMZNFlxTCC99FSemiVyhkBXxJKoXP3dU075rI9VTjfa1XRsQagmVWeQhUbzQBLWhLv7k/ +A+JYWNuAQpd1ENCtwYmXXcCwChJeVFtVPWLxzVPwMmlUVEv8Cl58jRvgv4GOrn8Ez6h1X8UMcGOG +zuF1xdoRVvVDttxNSbybyCQJg3n8SQJF2aBEUaOskNPmaR6HEMGia+juB/ENh0xbGo8PaXBgxKSS +sA+/hefLMMXE4VuwHRlg8WnT9T32m/PeL4XuoAX6p7KX5vDmYXQoqhBADN3yy+Mr0FGcblX9jMGX +Fsc4mBLP46ooBAWDMZUlF5/kfYZHYPX03yHQqI0IWnkg9p/3oUHa0sDPJ1s9pq31nCS+ewJdPUGg +XEA7eoVZzYwj2fDIKaKlVgjd8UsggxCL1xKrl05znjulYE4UTQqeNB0jJcNnRlrWPPVEzYFXE3oO +vC5E0eAzPU2DR3qaAY+MdK1+6JqyYRyFgbYhKhaiboxD/ViNFK6VeyypKtGmEk/QYoW3RMNIvAHc +63J34t5mFHyiS+w5El+0j66R0kyXN25kXt5/uq9iBrgxbd8MuqJAPbqqT/uXrU8WVmqHLjh4hwwF +8zChumy1kfGVmQSB7vSF9+rpNgdJCHgfChTy5tGUejPj/FJ0TYH9tyyH6xGodvMCPee890wmgdCD +KqyypVVrxIk7Vv8EiQu8NOIT6FdJ4uJmNLCo/MqKQVHPcFhY/DACUg+Rw/F6umnE9PM0ICe/WmJD +F2UKjisOL6eAFQi0tIbuf+Uox68hs4dFG7XU5rHr3EJdw/R8IEKcI/EWUbep5dRtUq9uc4JBb+EE +HXdHAkbF3TnBoLeoHkl6i+qrmAFuzNC5pLeQelWLdKdux6DjUCBRQDy+OouE2Y92+ksMmIkMi65b +QDoBzWlXFKofNLQEaVqp8qH6GnoNGcrxa4HCrlHtFVle+84t0jfU2Qme47V6t7JinA== + + + xPh4/BfWkcW6lX5JTUA3AsFL1JEywaAIVBK5VfM+jX4BDdyqT6ODQMNUo6VIRMQL8t8aIhJULA/d +kCM9ihngxgyd50VzQT1GSf1VTwQBZwU8TQ0+HHgdDS+EZWUSA5Z70obEsMOYwJdR04wJ0+BVLIeH +hruO2zGwHhrt+DW8KE08eVyi79xCfcNMdli3yMOpp5YARd1WJkGs1nohQqS+6slQ/dA1IWoGJ5Ei +VC8XIkZJ39eSo6StuiVIXTgYb+VyxFBJgz0tmNjTgsECEQwWiIQDlT2tfiTa05ze+uBUoJUHWnva +lsn/fLmkx/SvsKe1LB0bqGBcLuxpyy+d7WmnTq3taasvl7CnSRN7WkvLmqeeqFnkOVp6Fu1prxQt +2tOk0Z4mjfa0lq7VD11TtoZH6e1pz9Qt2dOkiT1NOtnTCyq2LPzz9Ww0vJh0h7Pu8CMWw4+Ruqt+ +4TsbwzcCfnPRn4N/z5tfndbMhy+Y9Ocm8+mn/7QxbHx0JkA1bncmYft3fvwy3+j3u2Cnjj+7LbFl +fTTqJ4CKPZ7F/ed/NMBvY1OgBgAQ6vasbXuTpghEqd+YObanUfsrmN6hbYtAmHzAW31gbIsnQrLG +L8CCng8vGrNPDej8Z2PSGimTBK0QCJOm9c5/Zv5C948uQLg90DoC0Rh3JoBt1maTUa8DBhbHaw6I +RLPiK6YcC8QAClEjBf4JsQT/nyDwf9FfYgiy3WgX6lwhP9Q1Bf/D+VGRC9wt+Uu6pXVTpsF/pAmr +/rPyfjGq4W5A3bJ+VpKYyV/dqYxj2CmJOgS80E9jJJO/oF9eh2Tez3tF8ip3gNmeBOOSdjoixoRf +0mpwG9DcTyX80n8gphJ+hC4yTsmazaKosxhRXcMhdOOiCPPh/LLBqLibFYrgrQl+ThkXjLgheQ7G +EMH8SHQbE4zL5BH/g2YDGjXhdtSeqSCJ30hXMU99iZPh6M8h+gPIbCTXw/7EGZiGP+pLZIE8/6Mj +vU3kxRzDUrcPZgbbAxrpDv24AX6KNd2E2CQKlIXETXfabfYRQCOE2qzR6i0FwesYco1pt6V8jhcZ +k5T//P192gECjbT+XvzgqN+fo8swRpN4YzwGSMOLAz7qiOgLaYD6qwCV/uL7O1g70LrenSFwFOqn +fz4RG4MB2t3SHToaTrswtVO+y67QnY77jb/wnzDlM4EhiasGJnLlA8TGEySqpCXAxD90lQPPCJwm +p0+QUvlgbp+AKqGRNEwAvMuauxdBA6ODkcRqfKLQeffv+X3+kGo4YYxMfEMJfo6RI80q6tvzo/n7 +93wAo43JzGTFcv3OsO1hwe3wmUDAFFy5c6Iqk1M+txi8zTzyo2F73p25mYMaysp3AKS/FaFTvn7m +etop/tEZnrfbiCRhFwqSPd32IhaYUKV6mdaaQDY2rMuCPFTo4j0YpEfD4rUUZ1FuQllHeYC/OQ3+ +PlPyJYr/6bTmcAjoBfrWTJ7B+9u4tVD7zYSaW/6xFkZrYbRyYWQmgfDJEAkPQdDhI8fDIoew1gS+ +7Xktgf5GCUT97RKIX0ug30wCXS15C7OFUWVClWuTai3F/vcmlee7zNcC7R8+JU8CTVgLtN9QoHEC +LaDsOgr8Lwt9gEmBpfHdrywD71KANwSIHmwW311DwLwRWHDO2k9IrR2Fa6n2I6RaUsBX6TEUj+6Y +ZGGlGxSFAnOok2tP4b9crCXXYu03E2trT+FaGv00TyEhipe1sPk3CxsYPrkWNmthsxY2a2Hzq4SN +m9yDtdD5303JkPTwN4gd+meLnX+d0ICON4onYNlcdEMeOi8ieYZhNPF5PE+xDK4pTdDIE8fDaD72 +Zx0lLcixfxd+Swr40nEClgFBd01izsuyJsW7PDLe34cHe2JXzJpd/Th2tVT1uDW7+jHsSrwzgaAF +Gh77IG4FrxzlGLPrO9b8yg2/Ytf86sfxq7V69XvwK0m9gvf7k4p6RfOo6N+aXy3Cr354cPy/jl/9 +FB/iP5fVKEzd8gf+Dyq75IkvrbmJAzf54YHO/zpusrbWfgRLWnUcE4nDcwErSwqoth3LJxkClwQl +hOQKUh7/pfxrHde65oDuOOA6/X19tPvDpEGSwWlIFM/DiwXRTbxJijW5nHJ95vsPn5InobaOav3d +hNpPcRL8w3bNWhr92vx3SqBpBpWBhffJC0CxQmXwmHWo6787/50jfrYE+tfJj7Vb6J/Jep0MARrb +ASQPS47B0h4UiZ1CDMVw6xCkBbnXOlD/d+N/a/15rT//QP2ZppI8zK33x3gOyFwY1BDnCYY2qS68 +1p//TfoztZZAv5kEWh9L/Ah+shZkv/hYApWKIRmGQVfHkLDMDLJHSIFf3h75Xajw95mSJ6n2wzPR +1lJtbVetxdE/RxzZ3LYhxolTwvom3n+5JfXD0wnXMufHWFLrq3jXguvn2FHgfZxhADVj+4mjKG59 +l8e/3H764amma1m2tp/WYuifI4as7Kc4xRFAwfJL9wOwHEuza0PqX25I/fBMv7XwWQuftfD5xwsf +GBQBLHiO9ctOPDaZXGe0/MuFzw9P0/zXiQ7ogxNYnhDgMS/HCjwJ4085guCR740TeAoVuybglTrw +CakUD2F44scVGf4XhRSbFn/CccScQOBoNHwtGMUwxPI+p9+HCXviWOscvN+R53EsSzIculiMh7XS +za6coWFB9STmi7jCuoCKAK4LJq317r+f/TudPZAkzuxLMgwpwF8MwbIMTiohkwy3Dk3+dws2/oen +9q0F22IH6gxNJKHQSrICx6MfpMAyUKsnGBqLMV5gaBL+IKEuTyla/VqwrQXbTxdsnHiTKJ3kkugG +LUYgKQJ1EhcYklxXuP2Xy7V10ufvJtfW5xtrcfSj3Gz4fIOhgRKNTtdZKk5QBLCo4hSZpNaW1b/7 +kINfJ32uJdBaAq0l0C+UQAwHD3pIgSCTqJwCJ8TJpAAP6JLEWgD9vQKI/PtrBfLrDM21CFqLoLUI ++uUiiCA5noZLR/FxhhdIVDSRWJ8urUXQD0/YXAuQdX2iv4Nt0hRimywlCCg2luHgPSuobh0Mw2PW +cVqLsZt1Tt3vxrBQbCrF0yj5myEYqGfEYQ44CsqSwrRQYjiwgqHI43HE1g+LSf2H7bq1xvy/CM/i +1lds/WD9+e8XZz+8uudanK2vO/kHbb21TPsfXWIPI7MEhgWUDGOPWYKRIo5JegXX2P8uVPj7TMmT +TPvhmef/Som0Tv77R7Jim+Q/XiBZ6FnCuX/AqCDW9UMWZFi/NFvZlN1cQZj+/Ggy7Eymq2I3OqAy +i7FdC8B/rjoNQLuQvOZTqy24crYrsjvX33vkk7/ILf77cqcF8bPmKFqOMpk0/vJXRpPuf0fDGdhW +TyGe8o9nT+F/lE603pz/9s2JpU590hhO30eTwapElAqgO/Ek42cmfXnRmIExDJGkIiThNRj90bl5 +vZhJT/E3k857H2jbd9qHjWF7NOj+t2PW9B4+ZPyJI6Bnhcbd4cWoO5zBZ0nx2XA+yI/G3Q7qiKfU +/VdU/YsidTRrzDqvV0CyNvCASUJ+OW01+nDMnUmrg/uQB4NeVbvDjim4Qudj0sGvSB2wUqMFsG/W +UUXdEal7pXz2+xnjrth2GSB0qGbbZVHZVnHtWncw7stc24s6j/V43IcCGH6Hbkyy0NpFIwDMBJCg +9dCPhkDb85f7oz/9LBA0azGzFjP/ODGj0LC9nClMRuPaZ6M9+jPe6JoLGDUo1wYQ4uzN/hDhhIjz +rMQfR+NGCz6THzT784m5aW9ysYj+B/7PXcOrH0DB9EerPxEZOBrzx+yv8b+YbV90hz1/rvNHp/8v +NuDZ/5UB/4swKXpHgVr3uSo8akB64wJfwxnaUbzMAt6nM1EpFFW9fnfgcs/9HS5GhetwLE3gI0cq +yau5EMylFz29HM+wy7Gkn3OW80sSAi3nsdZd1kelSK+Hdlpjolbs4wQFrxrzkzQLNx0N84V5dvV3 +omKGWJr/979/+U8b096q2GepAxgnxLc71knKluaVrQT6Zyskv5DS13Lwx25laKMzaBdTlob6QobQ +77MxXGnq2GpbOyfWAv6naMe/0EpfTI5D54Zf2idLekE0sFyakbIUbzcmPbWToTWdICcIFSc5qc0f +nYnkScaIHze6yDMRU7f6HE3+a7EOFMvA4EdK4HAwJF4B+FdvccRPde4RO5cOB4wgvVdnzbJVLPsR +PG3M+7Nnex+4tx2FQpFg5BGLVj3JoTsMeSEJryyVZ+olAtbcSR7IHiVfi8N2djJDo53CJyx88no2 +Gl5MQOvu8CMWw49zHbB/Lhr9zmzWQRz2oulmnKHHK/AhUsIAJp/DaLHu/uvTP/ddtLzhKXT72Z11 +xO+c0dWABAhknb6jJMOxNIwsTtI8SdMaF4D43VU557/qtKUvk3QyqbkkOUkzFExXUA9R+fK+04eO +Vvwxx/I8qXUzyLk76o/QOYj4DcsTSYZXd0jSDEsx2m9J+dv8Xw3pU0GgkVeD5wkS3s5kRCteDvHL +XH8uIZQG/0cKCI8EnaRMF0L96WnjAyiDDfFrkqd4jFSGTApoXVgW/yA4TkDo41kO8zUlkI7nGF4E +eQADwMsHdNKfO2BY46KRNF5uQYBXfKBXDMWjC96lazxhqDi62JMhAWQRLEXzACwlALA0pwfLcwCz +SQQWcF7tGjMsgAdzU+TRasCCR+WDJGEKliVZksK3j5JMUrMMSQ5eow3b4LkDsAgLMlg4WhL8C+AS +erg0z7A8BCeQSU6TBxZPSreackl8K0qcogHKaAkuC4cLh587YJMSXJ6iKc3oBJZnGUoLFzrFEM3D +/1OuTZXgUhC7NEIvLcIFUAnN4CB2OU7bEUauwItCTguVRGsGKF4FlaV4HYMQuCTGpYJ4JkngZFIR +uRTOJxApjCEgEpJwsJwEFhCubqcILNhEmtFSFCQCCFciMQpjGcNl0ZoJwPY54BlpI9IcSl8A86IR +/oQkSXF4CydpdHEapAFJ4PMw3UEEhwbJwJXipJUSeFpAg6TBLoBDA93zyI1J0QQt4ERAhuBxfgXM +AxQ4NTQCYpKVdhXPcDTKv1CcojzLM5opk9Jyy1PG+wEDBcxPmjFJymAhItEMASNBGYkMTbGcisPC +UXL4FnnwwzBKDu59kuUleITAI6oB60bwpswMaFVw0mgGCIOQ1kAHrAiWwVQPx0lR0jYFtEfBwHyw +TRmMfhMmGWcYuH8gAmiwSqx6nCQNxykIIrwk+IkvHyLB2jLm45SYKpkEq8Mray+OkwNwGTR9Rhpm +kiMJCskzWAFcoPHXNEcglMjpMdIGojFgcQOh/QOZExiShE6ao5EMSQJWTZhf+s8oTBmm6SBWJe4d +Am50sHBwiKy8JQEhIYgsS7CmEBU2J7FRFi+ZtCV5iemTjLQladAvLpYUB9TNoh1NAATghQb7Ttw+ +tBiHjSGxAoAEp5yU4JAEYBAcZroouBvIJprHCw5ZFtyliEeq0SjeBS3yIUrCY9LAjA== + + + k2SSwYsC0MprmbEskjBvBz1LJwqyRKLR6lCkxDM5wO4oNGOKQHQHlA6C1VCTLJk5nBMFfsiyM4kI +XUAbSJo/QwPeIyBa5gCrhz+SgGdiocwkUXcQPazIhRhc6UHCJxTHMCsT7nFpT8ISimg9WMjf0Cbi +GcxMKLhspMwo4DKKooNWC054RzEQnHDFBQkqoAiGhCMBxI1YAwGImcMMhENKBC0zSnGdKMzqMUwB +DhXtck4iTYoVKBJNmeAAL4YDTQoIBwQJCElQCwkODg/2wlCqZYJyAiCA5dAukjgxzZJiEhtQsMQ8 +AZ5HO5LGm4ETp89gRiRX0hChcnCrk0i0CZQENMmxaDeDdiyCzid5NGhAEzSahiTZaEnOizJJLdmQ +YJPZJ/gSrwfcTAKH+RPHMxiIgJg7I9X2oCSKIrVrBSkVKQ2yksMAdoh4Opekgdbnx/pOUtRPJLEr +blKwrxSEJuHMMTolbDJAeyewIgZvbodjBDwF7Vmgm+N1Fkco39ZOYMaMYSJs0ogf451kSNSqjd5n +fmQI+G+6H0NozITFBlauS9NvROAAYqnR7vhnIz82R5xgaVsrUEy9qjZw9O0VSGYhVDaAdM1NkQbt +Aj8K0Ou7B2z6EQQfqn3PG5PO1J8dfvSBWaUBg//zqIL57B8bPkHkAhcf8yloZl5kz+rnZ0U/4KGs +Pw+B/senfyh9hjtT3gIwhi/QM+kDikOEDf5HBdKsG7kXsFU5jtSIVR5QrlbQCki8IC1FPGqm8e0N +kryhkd4LpSxgKpJsIDiCROwBaJICZW4sJ0UGyYt8QlBpa4ARIL0XqUGkCq6s3wK9DQkKFvAs7YiB +5UvIJgeB+RoauqT/M0hCIgEO2KsEmuEpisaAeIYxVzZYSVAImO1COa1WDWgo0ygSjRosOSkvDrZH +NAsKGIJhbdAzSTVN8qgHSgCSxUrlk9VxQVFNJWhUUl5qEm65xl8ovuXiw60vAuuOUOjLChnHYD2U +J4HijMQfxwElHg0A6NIskiri5R76HyL64cJSkKXK2i0P1BKcycbQNIGlKUNgUQ3sGqSNUPJ/RQMG +qsksRDQrLSAHBoDWjQW2G+K7YLkAc0ZcnsTWHC2NSf8DQ+WR8OARLUtQgb6OVGWWIvFGYIC1hcYE +xC2JdRT5v2rNE/4L5bAkMsFo0DoyQKVBhAYUCLA7kGojyntpUPofIlgKiXfkGAD/SnTLsfg+CoJH +0p0GEpLDZAIwwogKE6dWvbCexNIa1YtmAJ0JSGEBuxcZZSzJqk0hYN5I97bofohweazSoZ3FSwKT +gq4oZIXzHJ/EPhQSd6AwGfm/IpEQeI9ClQP8KynHJNAK0HcCm8S+BAFoX1o9VhqZ/ofEVwhk/EOi +phRvBSvgtgRDEVjjAvab1iGQFLmU9n8lFwhSuhkK7XtK2nK3naY/P+qPoAgczcfy5oO1zEjs7+AY +wdz6oqRbBWTjU8NpOFq2PinFtuGBJqbFK4eXVLGWJGWUlzRdSiyRJlIYth6QXsrreS5LUVgDB6Yd +y2uciZbOIZa1cQ4lRSVMIABBUFp4wGQFvA3+UFvxGB4F500bxucpTkoZHIX2AS9rtpKdCliGgLNo +wY7QOjd5rHKKRKv2WpFCUqFcEsO8yMlOa8k3rXir1W5s39kYO7zRG8nlXe1OZ2ovvl2Uu3xAq4mp +NAaX2yY4GZzuaASOfneTmZAEflX7a9Ac9SGY/8MXqowGQKsMVTr9MfifXGPa66CBA12x9RmG6ucf +YFRQ8wxd1WqwybwPsOaP+a+6H58z9YPC6M+h+u9q513z/nqs/isHtOM/G5O2+llpNBEfnU+a4O/z +SWP4AbuuzYDqqvo7N5/NRkNATMZnlPpZvdHUNoIPNC1wR9iPDabf/uigD+B6yQ80H+BHNHgkutzB +4LqtXgeOD/n8pcFCGR8W8Q5WSo1169UTqa0was0HgIQKjVnDF3hNSH/7U+gv1TkX/PvutHo2andM +X+75Q/8Z9Ifgdawxm026zfkMJ7mAppjq/hcgVgBf1ar12e23JwD3qI0UWyO9hf/M/hp38NvQznD6 ++kdjMt1TJferm/7RgGuP28LnU4t2MF0cNxNHMtX89Q/FznA07LhATH8EKLztBjNSy+jfO69md9gG +AyVdzA0QR60zO0OTcJ6fuvWKln9JTJC2mHA1/26j2e+4IXzHVf0nbfTUH663Omz6N1M0nF5rPp2N +Bn8vJ/t1dJiaNmAcBJR5YIu5Jcdfvi9q8OaaHzOU32GXTt///MHS+G/eBtN+t/VP58UxgVRCwyyX +19XS/t18F06Fc5rKX26m8tffPRWSowXaaSp/dtsorN1xOmLDf8CUPjvIUnUxJ6nl3zwpKfrTakLN +EbB0B9C8Pp90gbXoZmrGb36AyEe8rjaaT1qdHAyCXgnb+0cbZITJWzXGZo3JR2cG9ADoMpgeFdws +vfGbv1mVvTgrU0xpNBk0rHalesrv3X7HtrFmsurW/3jznHDiBO8oENqdZa60/XuX33FS3SEYZ7/R +cjctdesfzrfRZTvjBgDXcqUxaNv/zZt2q4T+z8WGHcCrhNBRi5tJqlv/cMIcjk49TU3b/gfIW2fG ++z8zabVC6e8ezWg86w66/0WZBT9lTMBK/ruHMOjMGu3GrLHsOJJLjmOrLZ5/uNl1qsbo48fTTrs7 +H/ivOtNRfy7mlMhgskck6ZePV8Daz8f+Uh9uW3hGdzHpwFRfxd3LsSzNirPJHiX9jcmsOWpM2v4W +Olom/U151DI7QV1Ig/J3wSgasw5o2EEuatvGveGo1RvNZ/4PfGaNFlXJKYMjOO1MP/1XjSmQgiIB +q2aKv2AphhKsB035P9BJlru2sgZBE5pxnM9nYzBQ+5FQKshq6QZG0G37p+L1cS5GoaDZcUVUk3Ns +K0+O1KwHIoPJHx1/vfOfmb/Y7s4azW6/OxOlMsnIMI3EVG0MP+aNj47/YjSWllAv1ngJL+1xN46b +SCDByCY6EhmgSwk0jxr97lT3aDoeiTuAlv0X40a7Le+T7JE/O5+N5BUzkm3SP26MwS6YdgfzfkNZ +RXndc/1Opw1tyhtls5KW+NVaOPnJaJyddBo4ZdkgA0NKbB+JjvoJQjzzBz9oyviLiIfRZ+j/lA0u +TlbuDXag8R2Ig5VWLd8Y/tGY1mR0qAmB8L/LnAFsyn532PFPUaLw1L7xWKKf0R+dyRge+E61qwyR +JXIdOOjLeQNSl7+KL2HSMwizccwAZeKWvELhmpYTtM6xPzrwVkJ/s9FvDFsOk2z1u2OwdtAr/x+w +Nz4ABYgDD5FMHCyHipH2skeleb8v4fGmM5lCYTqbGLqolW79eQi5PvJnRQox3xf6vwktkEr9tOq/ +nnb8RwO4wbJTFFQAWeWwrSdGub3SRAwHqsHrHyWS4HlYBcv5K73kMm+Kx4UvipB3nVlDRecwQwNj +HI/0gb82BqbPZArQPeu2Gn09WVl+oMSaGOjL+A3Acb5W0+5fU9goKVRtfpN2YI+Grf68DfTjAaQY +PQMz+6I8gtf9w5x5wI6a/Y6LIeHpFgfj2V/5Tr8/tSQM+ZN64Rb6NisqZ6BdD2iRTxvjuqzQUC5a +V0ctFUfVr7h+t4zGfxloW4coEZn+u9MLc5i69ij5GGPSf4qTtw39qttcD7v/Me1Y3ei2O2yP/pzq +qF3VoquWm/oRJjV4qzX+gFsLJuArEEZDSCl+DX929Y0fLo+fEBeI8PQVabasTh9R4vjcTgp/RYuK +iqePGHF8jKev2IW+4hb6ihe/8oZCQUdHNhRhTlA6NEJvsxM9Ee4+wQM0X2L7b54IQqInweN3lDnu +Hb+jF/zOgq4cv2P162aJeFOuo0j02rz5Puq3OxPJMwifTsN6satrrDLXtNyhMB+DkUDjSxlLrvMJ +qErln8FNUQOR3rTCec+Ur+veqW0A1Xsd5yz+ZzyazKAapJauKtU6hw5tVMq1QUHSOI1qnX6lMQN9 +Q+HSh9ObqvRdi7ZH0H96VFC3VL+uw7gD2KvZ+FAIqGp42rf10Vj1Tj4PLvdHQPm86ozn/aksAPfg +W/myDt1E9Xd5KApO7aaMdA6j7AVvisPWyMTCBm+gGXc+VPQy9Tt0bQzCHdQcRAtKAQpMwVZXGTep +vCkBbapudAZDkMDMOulMhmYDAbq1rH6qxz5oAvQijd20I0DsU0xahi2U9A9HiqHh7w6RBj+adqVu +nD0ilB8YhzZeELW9gNoidT4vGgpXakNBbY2gpnhSiRtshuQ0Zojas4FbS7HU/gbQkrGrQ+dS0Lgh +8Ecw1Q1aFugjZLLrP3LjFCpe1NziADe2RoKx7blottXU5qMaV7iZDbK088bNnSeuRTH+yhnHDrtR +Dof333aaiZtuuzNKnI6ApteBSAWKI9iHHQm3CcXxnWiN+rA8AIBsZNnqdtNZP97GXSCilgWCPXj4 +mdhe8RC6+WbcHoDX/aHrQY3broHjGD75C1K+LkndcDyexJGwi/dhEL2rlrOR6F1ied6+5UQxbASC +tG+L4wZ07F2zhrDtnyOxwpt9s09dMwNOv0ZNgNNp92PYMDoN9Q3R0jbFuAE7iKjhCJ4Mu2jXmDa7 +s0FjbN8Ut5no9olZ61Z/Em+NhvBqL+iSsxkqbCnz7Sa6egjPnzdtPWnHgQ0P79BxGABo+A5Yk3Rt +GBLFpq2QkDB6+Qy9/gEPXMfxT5ft/rAe2/hj0It3hlDHcLeD0Ad4Cynr6eYbsGgzeGGbOJY4xZrS +PWwKNjXkzaoAJ8uhj8EW6Q7fRw7NJqqLqxyaIk9pszGZ2iAXNWxCFQvsJxWHcNFYZhIu2k40/g+n +1mpGwVk2HzQmval21C4ay6N20VY1ahet1aM2Y/LaOc6nHaASI+XWZh+/D2fxdn88eR8N7bb7eBqH +ihngIVN7spjGAc+ETtkhaKoS/oaW/xnHJ3qWhAS+WcsPN8wLtBN5l+JfNkOT0g77w60hTtqTqXbH +mwog1ExyRE+n1j23BnHJu94a/NWzYYNKwxG+h1nrwTX0jrmMbc9QSxBZ0HW8FvfjHFOgz7f9T6Ha +7fnFU9j/B+WgA8FxqYSTmbQDbaAW0x3aiE4oX52GDNuIKosoCZLmbBCKdIX9CQxl1UodMRkCWiDg +m21/8y9/YdL9A911bceXwfeKimWjXGgYsZVqYeKtNTRCR46uZAaU8ZqxmUprZf2theDkw1lQgjai +kFQVmNK3QlWlJFiO7WyELm407ktBRabEjdq0hlM7lII2s25fbWGb88+pdG2mTRvEY51k40SSA2ZD +xmxXsySmbabAdJZORs3ZbV9z7GbWotmFtpBtk2Hno6GcbFoKAKCYDu3b9MkWcp0bzD69kPhstDsT +1VGkaSutHOHNVEHAzPWng6YMv9+1UZJBg9G4ZaMYoQZTm6mjBu25rcFus4PB5/YbGIuY+bDliiGg +1o3hcKTElYqhAdDJkpUa+hVXmeeoAFLdHjkJdKfFBreLqReBsGpVl0W4gz1vLhSRhQ== + + + BIaME6EtKUMxpPp9+1bTXncMzJyhjdCGzSZgN06mHTi8ibtupbAD96xe+kI1N6vhQJ+F7LHTUsHx +qHkEjAE1DeicX/oVJSwdQ8piiRdZXxRKohMK2jIwYG00nOrddmAE/nP8SuWqUrudG390ToH47477 +nawWTY5OHlVtBL/qFuMV+Hfg7MH8XmHKfF7RicUwCNvv3MRkmH1Hwf4usOKFjk5hhxejfleSiqbG +gzRQXAKiNBkNABL/HE16dUkyMTbTOx0NR61P8FFHNcmT7tCd6SsNGgdaQbf9cCZOwB12pSimLJCj +zcas2virI5mZ8Moo+2WBlzvg/Ex02pJtjv5w0SWKlbBaUftO0afWvXpbnitFOTQ3iMynanAbe1kh +WBAAuVOO2mCluu9diX1xHhCmUIcL+rcO12FsJw3p0hrT3kWvBFeJaMKMy5FMKRUKoDWp35Mq77X2 +S1dhkN5Ipqo4Xm0Ga7EZ1YM21bHcx2aZm/pGlmJNtd7mnXPwiNj1rFCrhZrqOlDUfpfqeIPhYxdM +UCXMYDwnoNF8Y4yjOrsOooOBcCQ/kLWyoPSITiBOG0BKKOkU7jhJoTMFQ2u4l6AS68hO7InXhNkt +KIhkNucCE4CxHCneUgsfrNS6PukOINJuVZa9o6wxm47dkK46H7CPqTNn1ukmjowZfYQDZLsqFdd6 +vsqJuvOwS2Dz3HaaN93On848SkVEar7kPJi6nbkt4wUyMKAQ1z/ng+aw0ZUi7EL1T7DT/I1Jxz/7 +7PhFt5N/KgXC/fnZGfqnOMKiMVQX3vJDLupvTOFjRfeVYuLjKD5khoBrgf01mvvHgHP6AT/p4D2N +usbgPmBVna6mo6gfdCZ/OgQzhhetjmEymb+LTs4b/n7jLxh/3xjj0BHIq6bz1icc3tGwgI6qFDC4 +tyFA6hyMbvSudN+d+ufDHqwEEne981uT7thxY6HGACOIy9RV3hi7NZPNEBeUhmVU3ZCK5sifc/Ih +BsU6bSww8I4xBstsqmAg47GK7TqQsEqK28pRHE8BIyuu4CJbu4fUjFYXzmgHX2JmLoyS2qwxbMsh +0S55sVga5a8zW5eHY+y4M0LV6oH9uiIi0C4sMJfBG6wM5mXb0JX5aTYdwFf70xmwyOdyss//93// +P7P/9/+yx5n4Gdhf75NvrR1/NOz54RVtKhOe55NKTKDOxFZmlsh1pZFna/mjI4EtdGD/8CVzeL7z +GNm/PQjuNe6ix/TOeSyXmZQHn6mP4cZxaSMaCua7jfh0m7uuFLmtVOa6nD5lDlPVp+BpZjJv8aUi +dSoESIbZIohp4avwESW2M3sv8d3MfnQ8zUxPqIQvkNmrbkykRsez3EflsprZZzq1fPcg3SrE48EP +Q1fV9j3ojy+UAin+oTwrfD3nmIdYNDsYVafZo9rsM5LmtualArN9m/vqB299gcI7cdw0BbbNJ9/5 +m8vHp2w9H7+x7lTdLvWc2e+VnjOpaXwQKUQD81Ko3H73BRCySm9Awyi8P9/yuX6mf5d6z33O8p/8 +A6lBx9tOoUVWvzP7h8FbDAcMeZp/+XgZgV8734Wj9tFGLiZ8bWdrsa0hHsNdoz33BZJfoUir2GIv +Q/lP5nVvPxugdyK5s+hbJJMPXpfynflu+uZ463Ov1Wr04K9upPhe/cQ9k0SiwU+622+p7stxO9cP +HAZjk8jTPFut7XzD8Ycze8eftC/A7d08Z7LDVnAQOTjdS/CDp4Muzyem73R20joiI70UKUNsFY6n +NwBtfLDD39JEO9XNJxpgfcnTg1As2sn1+YsBnsF9NZDJH+1v3RajSXYK1uXokdtK8/nRS2T/pv2Y +oppbzwhsehgAE0pzu1twSR65W+5yCPGUzvXCXEwkzZt2lSCft04Licb+Tmkj8jCBvXDwxQuCgpr4 +AkRz84hBvyPp0r74a/+2eIKb56PFNwyMuqeOAOneEZF0uhilCocfByKc24P9vfbX2QtaSXnAAN55 +jhV7AY1yx/IAnpUBkKGDK9iow6Bn7Eau8IpQDYTlIcM9cF+tbL3wFSm8J06+i41GcDvHNa8v9yuF +13S2/tmaZS+2W6fZOkWD1c/yz/db4Jv2Q/Hu7XAuowhTrYZMX3oKMKEfn1SkBbsfFd5rxTbCJwDb +CEfSW3u3eIUgZF+g+EpGbnLM3XEpM5l8XjOp09tDtEIC251wYPF2o5HcKPmiR6V24mq8S3jCCwtB ++QJ7kYN5qFTokznimE2Bf8pEF8NJc81RZq8+28zWj2dzIyp1K6nCu7Twd5MN+KwO+Nh3vJvV42l+ +leyUQjvjcP6Tu3ooNon93UJnMokSnYuDPXkgGB0yMqrl7OsxiahtP/ZWgjv1JF44+uIbeO/jBRVq +34OT7PlL7rSUfz8WCPKk2S7l24N7xDxN1qCc63MHtwpsblY9eMhV6lsHujH4AmAUnfNCuRfogK4u +9yGHoYn31O3IOFp9uxb4FZ2Vx5vNZDKyx5zpMLJ3NB2957vTLge5ZezxggpvHVWUWe11UjsDsJOv +wpC8TiMHxw/HUqcfT4CP0eBtoLpbnr22B9na23Eh0T0IlTCA92CFy9ZPRx+Zm/pRo1QULu98gf0I +UXyS0TEuRkdnVGmHS92BNZ8ni63e947UAdog/QZmzDuPwSpgjwfB7FV/vKtud9moAPYXZPirz914 +9uS+NvQFVCxcev+aqfM75/nqd53UiIzdncJ7NviikQFXpdJreOMTTQPw3GEHbCm2qXsrrj5839NI +GtXXu0CIlkfFaL11ALB4eQs29t12JH3A0ehtthbNDPPd7mUbTm0DNqkXTk4qsdJ+kQ2jt3AuH7tD +3Lx+mgnk+sdEHK7Vo7I/eeGwu8tkbpoJ/qJyekU2X66z9M7GdpEKb7/kyXK+moG/0oDEyQOi00wd +ktFQ/lB+lvYFtN/glugZ/DMHmWIefYj+5GpV6hK+PUBfyx3k4bMcBpXdj5V4Nla4ol4fxkXYZB/w +ZNgcPijIXeVgozMFDu4F9qcFkZEHn5a/2ENN4Ggu0JDQGMBcAJwsHgqcJp4wHBTETh0+20PAlF4Q +CD2K4JDNOkV/ihiDEGtaZKJv9uBbNI1DBZW4MRwcxuLwY+9SRkEN4VPuZV81F2Xx0rZL63ohdMvg +C+gWAn8DkaXARtNAeNKi4wDNSvkTgZJ7Litj8AW0a5k2IznbJcFDRr/kWeFOlT8xjZkShguygI2r +8qwUUtHTLJ6LJbIO8EzRzpHQcaDMGTY+N0Oqbqf6AjIKD3TTlHGS0oI41I4mr3yL3uo6FddF2Xcq +itGsalqhWtQYYiJrslX25BFeyMwDEymeSwnhEYF1i2rVGGzpBaEcrD7Eoww7bcYA0dTkremNDNGC +YIztyx2gMV5xAhk+R78w+uWZ8txN/B0w8C9alHvJ7DB79f5xAtTKk7FOYGTrNyfDUoYke75AOVB+ +BThhQ5xKN5lfBvZLr7P6bmaPuNiIFG/uKpIoi22r1AmVVqC3ktTtACVDwwCrL0AER1SmGZkEBstJ +jgsC1S/8aGlN8XsP1VKW7m0fIztAO6EIMhB8AWF0TPDFWPSdKZwcfjPqXnKvnezVsHadrc2OBsVI +NRHSvu2XMsnAWDIqrsKK8YU7OHqsf2fP87kLqMOI2tVAgxhggUItTDtTlbLB77Wur7L80/FV4Xiy ++2YGIMtWno+yJ7eXQE8WR3Yd6JWn552JqPpVuRwQ209x2XaI29sO9pYD1C4k2wEC4/nr585J4f1y +Wkt0Lx6B2lz8zmN9m6Y2H+2NIUtTyBdQG0MKhcKpYQv7LnteKnzdvua7X1xi730Q+AD67S4JcJJ+ +4/mr9ggOLqboR6IaW+s/K6AAJYvAfifLgtuV/QHpwkcsfIg7uKTTb0BROw/mPyP3+UQ3fZAS10qL +J40t0gNkHy8phjDgY+o1uKgg9INO6S3oPKhimheJUzUQK6NiJ43pXNkAF5U+sCwU/V+r/asGmux1 +TvJgQu1I6e01nSyU7/l3YI4XKYIqM6d6sJcb4SedkYJprCh1+3ZZeL+OlAGfLhWocLuIdyCyVKEM +SGLG9bK/07PaV3zp5Xl3q1Qczt+oQHIgiKu/H91OPAp8q3qcu7zIgLncD85EA39+H8hentVuSoVw +W3qhEPtoh+B78+YFUT1pjhUbWe9zoB56YF3yn08bqUi6/PoqUdZzHKxg/CTXO40A1f7iXdmzKehp +ecn1qIMN5YXsCCBS7UGfgELkDGL7QfF2AIvPpO9V94w1pTP11h3HLyOHN41vqYM6n9k7ud8E5uPn +hhb2ebZWbn+BdTmYUJnrjSRaA7QCB6E51YEk945eAD52+Dmdo0VOXgKmCnp5aQAQ9WnxdUw2M3vX +wbjKSUax/c299/nFV7Z+3bgHHaT6ROkpQ4PRVGIyd9Y7MHyBZL80ereiGFJuWZd2rxqYy91Lqz2K +9vuXoLjsTqHJdGqOu1c1ELh7PwAll8IX/b1SgX2gIun7510jRBdWvgpsVbV7c9XXT4RPsC5p7nhe +iF+1Y5nU2VdPFlF1brM0zIuuQUB8sfH3qFtI3O1lJHwGO4nPzssbxOdUHFy5cCBy0NsDFop5Kjc4 +TwMpplE8zpjc+Zx+AKi+mhYju9y7SmIpdAdJidve+hYyqdvv7t57pfmRSd2V1KAwx8a2e7LpCyCJ +vR+95yoItkp2iy2JELDTZy2wfg97hc74vIrUCW6rymzBZ1ThpH66qXTP3/SrdSDoDreLr8TwufBe +L7z7AsXo6HSeZTPZx2Lroh/WqUuiZ/Ij0AMMNbnJTxNnN9l6NQO3YTJmHPx+KDOJJefZi6vEc6r7 +IryDFb/dBeuiUm+wODpIAIqp7gIF5em69Lr3mdB3SqW/B2CRPzYy34etjvICrtU8KzTHH3GychMV +n4ElBvpYffs7VgqNkmHdK7JZPaIUELJ8hUM+i+X6A+Id0EvvgUunzu8ze+MkaZya2A6uC2jJC5ej +XctGqEmq3W5+G5s8xApE8iFYyne4XrZeaJC5vrAlEFT0u5tJnV/20YKpOIyBitD5xEHr7hFsmsJp +9qqe+TbSxtY03z04nWZSpUCDO+Tuyvmz/M2hrB1yonzh97utx8JR6+oix9xSM8PCv2xtAOFBXJZC +x4fVZOWpNBOVYHER44DQTri9k+3se+Fj65nhU+N4HqhD3V0FFNL6ILD3zggS3eN+eDvwCql7v9hM +PIy1mjcemVDf2a6VXrd2amB+kafiy9eshXyQRnyWZ8VmbjfkC6ROI/Rjtl7f2dAQy+GRDLYqeqlE +sqhiJiz9+WRBIJWtUj77DFTEzNEd4GOFaJ2VfYZ4tMletljP8smrjyTzlhuASeYIyyZQEDSgqRSO +DaN1WT0DVlj95rCX2U+Pb4Gs7A+JHRMQnVwvODvOMfeb15WDJyboaqaimqeBEoo/wV56R2fA/CiO +1PuOy4ygNDyGvk4wXZbeAibCQ1IBkSKFjbNS+P5ilj25J9uqTg9OztqF9iAZVZ9ZgA== + + + kYUAlz/vfSj8FzPh0dsnq9qp8ukFZriRs9FX4T153C80d7uBZPVtsl/K9oebyB2qoxew+vAoL3WW +TzwVTk72E1hVoy5rsVKRfA+VUtmrTWlBb0OA89cT3EEpm85xgTFbOGr0Awb+078IA9w8X0FeGi+c +HG3mAbfUbqD96PzivpQhZq9gzYfN0sZulAQm7DX8JkmBnUO/gW14KKjA0ruhMDYu+Tr/Ip1dZQLa +0zcRCXul0NEgm/x8OtsqFS5Oa6XAmAHM5bbzkaFzD4yyF0U1CPxSFCx0hpfla1v5LPhvJbMfi4dN +e4GNdsrQWfwEGhVp4x7b6mWZUO66GJo2nyEjIfXIIqbRB7QCYOPG7i17qVVzVPi9bgqCDB63ocl8 +kh19nu+qLSe7nYrIXrL4bAlfdr4/olMAuFZUoVErP5UD5WcB0Etvrmo8q5aewepntpEqgs4ooZ7M +ZU4L8fPPfRXVprnoqLQbjnJADWICwJTI9NFh414n2boRj+C442v1TNUuiEOqtBfdVAx4A42pxfa4 +/V4KnZST6kVGtHr5tAVf9LO15vgdW4sUt/mRG2wKXypNKVMZf0u7UpEvqJdber/B712eX2Rr82vK +KFDYSeFo0J0CsZUbgBH2udLbaSBprQGcp/avAMZO29Ut8+WWdAohOUq0is1RJebQrr5z+1xsvB1t +5gaRHZWAlmhMpX0cnt2Ble6qzu11wFT7zjBTKFDeX8EiVna/gcp9dCZJZMQ+vybBu9LOfNzJMfMc +sHSApa2yyVGTQUgAHDRe7Oe+vi4yhaP25axwHAqV4DHoET43yvYbA6QaFWc7RxtSz8dzoI0bldeq +mQYrqrGTrTaku2j2cvcVSMjWgFSz4+P5jDh6LO/r9oM4F6CgtOqps5fmvPT2Qg0gjdHyYfqDmpQO +OjkV+4f7HOMhQPQegXC4CxXed8Zb3OxkdlB67ccTml66L9EPsBrTXT71EqnB86CIfl3o8JAGCgHT +yDLB4ChJ3p4kskJ5OoNhA0ChO2rcZabhu83CyfHzd6Gz/7KpLBjS+d8YIKLfx4B9PCW4VPN8x+3X +8NskMK4qldLr7DlWygQ7de1hHIc2CuYwkmFwAURzJvYpgP6i5fKDUH8qNuvZ28IHu9PVcS+ZcUk8 +S5bSmE+JS1JEa+ELoCPI/Ofj/ncpe5EZp06n85HWNchx32TyqtDKN3qF3W6ixe/TxU7x4f2oKLsn +UZMa2PG1EpRNjawQi29CX0gZsS2EsYsHvv5WSZQK8yw6lrwEGkcwVigNs6dAftbDud7efkxUUHQQ +PwCDq83rbSVwA3NDEejlZo4NlxKAj7VThQ8VtxTf17dELIu4u85ejapvXPo73FObzBDHueB+tRh9 +zgF7n6MGinMWIQvI3qcuwFj6e/e40LzrXIHdlq6U71/Hb4hHytvHAvPy4oh+wgPAwGOlLW5yWTkE +qs8hYNEn3zk0JMk7Sl2GZpCe9rnri3YC7NTraClAhoDdfHkVLRxvvBPqGeDGY5K7+X7PIpFQClT5 +lA623BjQWGnn4WNYeB89R5DryNR/LbL6nAC9w/XyPD5+yZ48hAVl9WEIQLDYmm++COcVup6ko8d7 +pdfoTUo3FxlOvTjSiW0tnLf8x2cpCE+9Bc2QZQBjrpwdfU8TMLrjvPDcvd9Sn1YrDCB13Lg5Veav +MaMvgf57WgqWA6XKQDaLgIF0ux0vHEe2WHXP/dl2sdWMtmEUwS11KD4dbO7AhX+F+tq+xtP9zGf2 +XmLzbD3PvwKrsw0s7ESskR1lOyVlcBgKHcruZfaer3P88KhOFp4/nilg79f6mYQEDPCLizbYf919 +MGGNKlos7ZSrYyUcKb6xk7zhuOPuB1eP3T9QxY1YLvE5bDe2kx+3EzDWCrymK0fmuxuPQbBfIrut +7wKxHRsi8c5u5HdJYBMMNoG6f90sQ89pgKT/z7QcLacNhSuga8K1OW9JfdbjuDHs6JICxfustNdh +qq/IutNfxQKeFeoFXUYkvJnr410K5jNED+7JVXS1lVVh0B+uuArz7aR3PhTDqH5iGtcXSbNvPDCP +mwkiETmNAE49o+Evitm/TNHyi0v5F3qxRx/WZzlgWZR7la2rgwagl/u0/JaKHFxxnxthunKwEUsE +gQ4DuE9vfyN89pDciH52wau39/hGZJ6qbURP7wobMeKUIhIH9yHUPVi18CUzpaanYHCFHljJtzSd +E2gBMNnBA4q1QQdKylui8toBlsVkkj5oZqPjs+PMSXKaFir7t/HS6IG5KU6eHojCQ+m+XjrIHrTI +3Sw/FHuhty8j+djuFeivyllNF08oTleT21Dr0zeqTieTvWkddBI9IhJMDU9DGdlUKM1uqJdRb4do +75Co53MF7OSZmO4D2MI8ki5v7KCJo3Up9OKJqVBmhO+9L/BnuQ++vi9oO32aPJ8+XZp3WuZf2NTR +S9y005ftMyD3dd0qnXLdk3LAvNP9jdBkSgYm5p1ekE/MJpXaVTr1BZRup8HoacyiU/Yz1AjeF807 +ZcJPkX3qw3ymm6UXxhfYuh73q2ZzJUq5k4xFp9zW9nASPrDo9P6FKL2f1ZROURys3G15Y3+HPH6t +m3ZarlB1S/RSD+n6G+oU0GKzqF3TW0DJT/N0FXYbNq5q6J5+7JNh0CkzMpBSlciJnV4Eg7pOWXbw +OlY6VSgZd/s6ef4c1i06zTQ4vrRNmnb6cvh2ZdVpBWh9dGjvyXyu+xvP063PzpV5p5f5cPp7e1A1 +6zSy10+llU7BumhJaffwIXNu3ilzf0+UksSZaaebpQ9++2pAnZt16gsQpefnksVcua1Ab3iat+q0 +QZSjbzfmnZaJbLAT4u9Rp76AHsGzreih2Ol9LKRD8OEZcyCit/jUK2k6fdgnqnyMhJ3u6jr1Baab +lc6Iu2rEKNAtP9bTb/XxoWHRKbfF99qlF6tOC8Tp7nMSdYpsZO1cj75Tma/J2ZVpp7W9IG3Z6Umn +RhNmnULOzzzGiNpreNNsrtPNk0rn7PEhHDLt9CY4/LDstPZ5+dZEnfoCxrk+lombk/G+eadVOnBd +yuwfmHc6Pt406xTwZNjtzWt5c2aB4Mdz4vbwpGDe6Wm6+Ppy+fxs2unzee8IdQrli3GuX/dsu2TR +6ZNAPE/7MfNOz77Gg/OkQOs6Bb2gbl+PYkNLBE8CtciGRaf310SxOzg27VQ4i21uZJ5jgI+BblPf ++k0zf+VfxU6bdFi3acIP1cYu6pQKpkMV7UyrxNtuKgs7jSqdgl5gtwDs17fE9A8m+k6no50DsdPZ +YUQ3042nxmMYd5q7J4+0jDA6mV6nN0AvoNu4kSsdxdBcQaf5mYEVVjY53OkheRLTMcLomDnDkobe +TuVPUKewF7Hb7cmk0RzCTgldp5NJtjOS6Pd4Q9fplP1KiZLmMHUZ16F3c9R5q/tE/aHTeOW0g6pc +77yMUpZv7y/JwY3V20+i8haYK28NnB+w3sKOxddgDXYieWlcXx1e95YTyNe6+HbaEwy7kht+bt6Z +vcdM8eIo9WT5VqB2r96s3342XoIyxozvs9TOQ8vybTUyPKSs3zbP3/eUtzqMcVvnm61mxeJrobJT +2b+e4rfvwe+k7tvrSFdSTt/JzZQBY9fN49rQ7D3mcoVIb2L59jbQTGxYv30qpA4kjJm8fwu88NuW +b79mF+OK5dveDZW7VN4aMDboldIvVl+DIV3usZZvjykmfWeNsUBr2KxVrb7e2dg5etq1fFvMnjY7 +lm+PqcNN0hpj2Q1qO5yyeMtWiOLBrjTnVGhP9zZSv5weim/z8X39rqzU38q7WeU9M2WiV1oLLE+0 +g495kf+8Bfrw7Vg0R0uvLGY9udH0DP/S8DFqtg0tzPxG7Dh5DyzMrzr8Jw6flTaihas8/OcW2W+y +9YZ5hNhf4yoncb7JJhU8uIiJ/BzYORp9LL1FB8GHxwO0N6Clo9oRiVNhGAR27N0csNbNHdDf+77c +31aie9AMA+60WZzM3+IxDbudbPoCSrfI0rHolNuCds6jeafM/YNlp0CIfJE6fUw9V2TpWHYKRV7L +qtO2ulOmBmxkVbfCWa6m6rS9s7OldIq0f7lTWodeqP3LMy33NZ2G75H1qu5Wg+ADyrJTpP1bdArs +QaD9vyidgrlo5vps2SlA8JSx7hRq/5ad+gJQ//80n+v+Rtyu02rQslOkUyidwr2v6RbqFHXNqnaS +Uvfol7gQ4fxDe+Cm3ct8MFTvfYuW3Nb3S/Hu3LEd+ynSncgtcmDOT1mRWxq27ltoALFzpXLQpEvz +ichcdmoZ3Y5PdLdSUeWf9DjUrovGOuRJ2N5Pj8P7YxliCIFIJyvbX2gU6WT5sQAYV6MIe6YV1iR2 +ny4GxH+ipyOxA6QCSx3IuiUYD5jcwRg30nmfANvLJT47hYD8z5VaYxZ9Zudy4wLspaye7tvxoehT +AkO+vgAPdqBCO9+VsIP1dpEdq2ZwsaNFoOxxAwMmjtlAAP0DCfJWayWZDaqXPNINSj2k13kQkO5p +lAoeEio/ms4diFAOuOXzPHfihHT4jzh4bMybzC+4YTk/X0CZIfrHcgWl9attOq/fljy/XZHGzGYI +lddrG2S5X78Rok9sWbhElg0wcjf3VbIE5XND7hKy9mKeKEuhK41ExpRVfvr2jnlTvAPl5kGk5KUx +T+Ueksf2ePdZI0vLesJG1vNS1LIe2pL1+JxIt/h0NFEjUB6yBoE7mPWY4+4F5otJCLYYT7QYxf+I +uCOH5ri7j21Ysm2rXYn8caZTu9/0PjW1FEOTow9v6qdOqC6f7IinCaYDKUR0s1JLMdWsOhfxHXH1 +DWy0CHq5GXmakBmHAbQDzLk7FW7lbaim87fwDhjcXcFimaJjsrEdrKAxYD//goghrKX05yhyIFGO +ipKRU8ccGOkWmBkohHfVKc+ucd81Sm73nf2uA7KysXk3t13LLTJ6TUbhP48R1SGFgSwAZwwVT8yW +E2BMvaDwH7CgiiPaSBtgfjIXNNLG+aU8JNW40FxmZdORpcvNqdUkM0Rndp0waGHGJVEsvtOIcUna +ZSctzC3r6QlTX8BSMLnQGZXGQJt5nFmKJV/Ay/qWIU4q3rUns73fLmv5tAmyTkeK4LUZ0uzw2FJW +nl+J43Gj0oEhWSt00tL5Au5WEFj5toqFk86vWcFhwFax8LB+5YuBAgpT8hLAakMX4wK70hUwrUDx +Oi7phFcEdm9vxHiZpFqrWxpjr5MVYkzL0TyOa6z1w7zxE4PhOktPF9SONecvYDwVM2PQSqE1FdBU +7u5zw4GPqRRs8105O9xc2a7M3X1vezOU8XmsYSUr8MikquAGWuLesXO/uePW+JB1Sz120lNZLDu6 +EcwVw4qOKZjuF+dlSk/tTTzdQERKNg7FgQu4GohOt1wMJw7bXjUQbCNHLETURwW6rh892OT4UFIb +ZCTH9lDP02Zc5dAGv44gzRc9dGDh1ACa4IaNDmPKPiw2yJG92uELeBnU1oIMQMst4Q== + + + lnueBezFslsGcKQwALf2vvX8gi5Q7nOHdI2u4OzP0Gvyiq/v6wge6t2ugqgKM7L4PC0rnEETC2dq ++FjY5ID2P2m39CmeWNkhy/0WtzR7kJUEkOVxi2uQJW9x9AW9newltBv8GM5Fu8VNrW5n7xKg2k13 +HhI7X8Kx3iWrH42dS1bnIRkcazV4C6PY2SULpqbaSOLqe3aTHMO4hFO37g3ZStIP5XiuFcsLuDcA +HXxTaEIoUsWwWu7XSidTLfw+voCdl25wDA9375fy+0C0OPv6dKzAwl8DscO5omQV39R4GsYaVToz +16vSgA6snYkiT3ahTEMsn+hVaS+4w/oYGk/Afjxu/Qv04TUf1FGEyhbzJAhPdJrwYvsldRm2n5oz +nZ8owk+WLwt4o8cnerlnNSFfwIbSAe1ohd4iDODwOsD6HNbcHWJeHZz0Pp2os9JlAXZ0gs5JDql1 +WTwXlaiDh1VBdfwGnBV45oYYLHedipLzYDxxbz5v45zvambSTnsq6voIEgCz8reaeVuxZWHlb4XA +PGw+c3sJbBpfYOlDCrRq9iLP5xqO1pD0NhrxTBzDWXYHYiiyNalAkXiyFzje5Z5s75sA05wQehOi +2vPBINIuoiGtxplHYaorOWHIo+BTX8B5G7oQNxAYFfd8xmehRMBYzl1XqFSpn6lvjRTTc7RpL2zg +aNOe/gDPBUcz9ZDkAWIy38tytGuFo0nWqxcNXg/MmaP5XJ4gQWCLczR5V5ZvRivgaGDVzDia570P +4HjnaAbfBYazPEeDUJY/e0VwbE6DormQfIqT8AXMtAGNELoZ2VnQ6qNDcx2FiV5p4y2BzWPwjcNn +yx7ASvLlPfhtzYZcamZ5sM/PZ2abGXvgvbFZAOxmwxOT9QUs2eyC0Q/azXyDbGmNJb6IggJWTRfU +ZMVhnOG4U+0toSA/DICzfAgEgmJhUOtO3p3haA/dXbqXTU4TELBV+KqxLATzi0DtQisNwdPYMvq9 +ikgbm1fTpS2+u1u33iyV78JSGt560u/tfbAQ2PL6/dO3mSz0KsXgqnl3aRmlGISzjH6vgiLLwsWl +GIJjot+bQZGtVws4bqWhvSxEHObpe2lpqJGFr/pzYtQLeLqScCTIf0zjsERZqQmeUsIwLHWB14nN +kqhRGXVx+nZ3t4yvWufnB8CW3d2qcZnsbftYaxuMuVJ3pZWEvVhZRGAt4672uc3paR7g8yZh47ly +EU6nG5IlRaDYHsftpRdM+XjMIJby8YQru9KFYKJyd23L8DzryDULex+MjHKHShebqzldXbQtAGZ5 +diN7e9wG1ANg9PbeSXUVHhKAMd6bimERgwhX8jXuygeLgVls9nvb4FtMET7Jf+9qUC4pwrC5RImM +t64iz9Ls6dDUshDXAGXLTT82YsPL143ozUtxI5alX2DeXNEsgw7f3LJ8Dp1aihkz6HQZQwvn0Nln +0CGevIIcOstOUQadZbagxxw6+ww6dbbgMjl09hl0Gq1viRw6+ww6TbbgEjl09hl0NtmCnnLo7DPo +ULbgCnLo7NuJudVL59AZNq4mg062LJbMobPPoEP6mHMOnSYg2SbD7CJYMtO2rWPgrTOBdMEuLoZk +6uktOAdu77rLlyrpbOSFg2ELeu3XxDng1tP7WNBKe29LpzrjK+gDNhbG096uhly1uaKyjA+5SQbr +fHVunJwo2jM+O2D2cVju5od8fU6Zc67np/NcGfeLe6QnvA/JIvPRwXNlNySzlDk4F09Jc654TVEX +CqLE9nhLoJp5CgXB8WOmwSDe3cZWTmN0M9jS/qr72Jb91Hwuk920kZBeHYOIksGaL+sxxsluVsc2 +WivJKdnN2j61P3BQccuibTCIxjR1MkOKumwGTaawO2DaECzSeGLTpL6dMh/d8axGyZPRi3alldnb +pK1DKD2lmKLct1OXWYfOtj1AltlZtqyPGV1nTo7DnjDWuUnAt9emQbMLnFiVLdUuyywwlaakzwNz +VLtc5/HNnWLgPeTxNZ3yX7Y0Tivr1DTrJBh7VdoYAx88+NyyGlTGLEXTev0cY+BdRxG0y1oPpun6 +uc3jEyZOOTF2xKCNTofAVpYhOlFOPqwyU7wAc6Z49xjTOliXxJhjmqj7SSocbSGMaR2/VO7uPqYN +dKroAutNMrnc6bIGn6/RzJK3+pW539I+X04HwgJAb1MrkU1AvFEvJPznzXZ3V1wYe7LF52DsfVRc +G3tWAPQxiguAcLoaBayzfKuGu1S5hVbolXCWL5JKY74tYIqbs5PBZ+uShllpFkacgeztcuR8DmnO +Lo480YTsrzzxGcwrGz0yNTWE8ocKMxcoV52MWFHy15E3946JqYQ1JYcEOQPXsc6ImplK8wX0sSO3 +O17Z75b62NeRN/eOdZqdPoJoYTx9OngafDpTwpoEPHpkNEPS5CODQVFe3B82Q9JuZmcpZoMnxu2Q +7KPTnZPi7Iakv7sjrvP/4pSkVXhkjpFHZskoNaAJb7vwyIhnfA7pOdup+M4yHhmVvX+8vEcGAAjZ +RHd4SENbxCNjyBZc3iMD09B0HhmrjFSn/DzGk0fG1M9/7CI9x11yDkzRAxvOmZLdhe/BUh2EVlk+ +UZRl67hxN8oyfXgd2XJBDPY5ieOT1UQywHVJXQZX49QBU0uFHGJ63aShLRjArpYvMIHM2rvkIX3M +ELpgmi3olFfnOWjWGKGK8upcxuvZ5tWpUkdtMoWdnaAntpdUqXavSre0DdW7MN5FCp+5FHRSzrtV +YNJq8uFgL6uIqbPPh/N+/9gi+XBmUdAXg1Xnwy2RZ+EhH84uQnV1+XDQa73kDnSRD2dyI6hlEtfi ++XCaaCjpm+Cq8+H0947ijLhV58M53hKwknw4zYmVi1DLxfLh9LaY1bEOzGRbPrMeCriVxUQCUNqY +SCvd0k1M5M3IVUyk096f9uhl1YA8CpBYPhsdwYk6rb5LOG7ySCyhYH0MwVlBJpchksEmBt6Zo8Hk +OmuHmDHeWVXLxiLiOfi9a4h4Dn47LIRuE1p6e+5ultmGSvKRyquw7DYEwGyvlTHjY5bb8H7sdhva +aOMQ397sRVNCW81twAiOt+1jkY8M4KwkEbKQcCfFHOFYXwlscZuWVZi18Upgx9vQtF5p3W2N4ajR +hwWTz+wvdnI0qOWMVHJz0QAR1ZytLhZeKCO1sfnqIonUZUZqY7PpxmXgkOq3kozUp+/VZKRCOKvI +SIX5YstnpEIoq8hIhXDcXQOtM4nN4vrQBrG+NNVzkFE4Jq6+dhveLb0Ndalw5nxs1alwKJ7fNqJn +Falwpuuy8lS4xf2WWozZ2+4e7MolUuHUdxChZLhfkgpn4lX4Balw5v4xl/bZvZ1iqGYF6vuT7RKf +Pi1jVd3cCK/Vx/JxB7PIbaAXBMW68ii6cCBDYNY323nUYQyXDHs9XFBlo9+7PMKxu50XsHIzkaf0 +4pzcrM+re7K8DkcvHCTvqIl4UPYvrBoXNetPXANU4jJ9/lnu3zReC1vtebGU3M68lOrpi2ImMQsC +zl+qH/L3qGx44aE4yWQrXP04n4u38vlc4gQWIaiNJXEU6GuHLHqctLlYZlln0EoSc5QerfPOhMvU +hZq8tMlue63zU7XzWdUp+7kb2N8YWWXYMfd3dslu7YRlp0SpnrPLsAucd08bVp2+2XRajiVVnepz +sVKRqcoLp092Y+4+q3JlQl0K2GbILtmNjOs61dbj2xtYZdhxW1vf3PzJKtnt0S7rbGCfYTeq1y07 +3al2PttWnXbs6/Fd3ll3Wjx7LFuid3tI771adXqpzbBDqwo2rDhr9Euk85TLdntm7bBXQdOSeaq6 +gsiEL3A7UXRWORNF9EyyktKleV8vUO18xy5CbrUabGSI56I5I7rYGa0mtcc5QlXvNbGuY/XtYkiq +czGbQTkFpzrFeWDrdZWV5MzKjpjcqeLCu2RXSc6TF+6x4DpE0iEbEt0J6SGuz6mInG1cn3t6cigi +Zzk/s7pvTsVG3M7PudaAa6Q71RnR3aW2RP049/ul3LEuRGQZ7uq2AJ29p3eRbLrF/DBes+nM7ACp +Fufqsulc3g+zZDadmU9Qv1+Wz6Yzy6VbNPPROpvOzBdvHmm/TDadBi3injW9f2ypbDozUA43hCyQ +TbegRPaYTWd2TiPLypVl05nl0qnt/dVk05nl0rmM7fGQTWfma5cqsK8um85sdZGnd6XZdGbKjTp2 +dDXZdGa5dBa3zS+RTWcc0ueWtaa0aDadmXLqC6w6m85s/UyioZbMptODcqwpvFA2nZVuudpsOvcY +WyabTgdKfya+omy6hTDmOZvONsdqZdl05rnVq86mMwMAellxNp3ZaYkuBn4F2XRm7EFrva4im87h +ZGRF2XTO8mUV2XRmyFC08VVl0zllcq0mm84sl86yHt/yBmBMMQA19cU8Xd1kXcXLWKRSX5vDZeLT +t8Nm1yCfGVnVslm8Xp1hSDN4yrPqenXW2oU7PM0iQU94UrCkiYSEOZmOioVLEtAkKFhkPVsNSjck +t6zARXU57cHUQkOCGAOD8lR22W5I5oEUlhzGBk82ZZctWCaUYlqL6JA8nuosIno7OXYobG7vmZOr +ZdkVulu6zJ3qniuXKvkiZe4sq8uduMpVclnmziqTy10inasACfv4ZKXQ3XJrVb4fu6kyY+ulclXm +ztGjCBGzdJk7UYexL3S3dJk7nPvmUOjO3eHR+GQF91zRh9ek/SK6z7M4WVmI0vhEUbkXzuUBUzsI +u6VPy1MeWKDOMfbQiT5hGh00nm098K4S6dxENPucMwytgzhc5xeCXmzCDj0EkUHsWLr+tJTsrsIW +6HkrqM8ngpemWs7Z7G4oq/Oe8sVgwcQuTTQUICqHeHDX0VAAlGP8mOtoKADMXUS3fWAz4n0ryXxc +/igEVhS0uQ5cXH2XcFzVdjWDoorsqq1iByIohkx200xh51x2BMxVYq1VDQh9Ym1taEysrQ1Xdysg +BLaSQsaIxsBo3TAzteyyRGXdDJWO9V7tYqh3jUe6MBPPGEFta4lbxVB3pr2VZKbINx971ySMoKrz +VVUwBC8urI+IXe/9a0+Fqq1O32DhtaXVCQzFLqrTA5wV3BKA4SxbrRpDkTah2Q2H3mJVr10kMng6 +4Q1HTLbhjYtEBlce+KUr3En5lVY17hbYhibBFYvWrfZW4c4u83GJbSgRmljhbiWV8hzzidxVyls2 +n0iulLf8NrSpcKfNS3KTH7JIhTu7eq+wxp33CndubzWH2U/LJ9Y+fStqjpX16jqxFgBzVnN8bhQd +XJtuscRafeYju6z/COYXnpqmQ3u75wrBWYBvGu6IgHBWks95SrizxRzhWOfC6pKYfE7XTKByeV7y +282SmNSnopBBRA3bMBVyWAgXfi2p7pvLNCY3SUzBgxe9JaqSYm7SmLSTdPCdKqDkdbFMY0qFXGWo +25rt8q5MhdzsSjdJTMGDoV75XtSuvPOUxGQVQQRrJ9pIWm+K4Z2Yw7vErfw6xdDksg== + + + xLt7XANiFTmu+bj1rWLQfvFakc5TuUeESmt97H51V1Pdo9O3FeW43lteTeVdh2lOPZV7dKiUl1gw +x1W1P+UwDBdZz845rmBIrrOe7XJcRQ8QXIgqb96fpPrBjLfKQb3QI/O5xPFtYatzXPMFCoeRWv1g +9BbhwK/yBcruK909ldpUML1ZwIIHuXZVvmPxlyYJ7+zwSt2pJh/OF5hu3dxfqF1V2jpsqfzjvUU+ +XNg6CW8yf0uRWp6sS8Mjdq1y/7itbf4q/GyVhPdk2SmYy2ZpTFvOlShvPVxbdho8asY/rOqwhZVO +5UwuBcEXLKXqVJuaNg3yO0odQVqX5RgOHT72zTr1BSCC9TXnNGl4DX3unxq9J/sXFp1yWwHmrPCm ++GD1GXGvNp2WtznrTsuXWw9mnaK6b0JFk1qp7/TKro7gyY11p8XidUkT2QW63Ybvo/IvMQlzvnuQ +0K6+RTs6T1i2U+dXEm+7qawLiJHUaFZUxCSY8z2jVzrlwxrR26MVnnkbP7Es6FyGTQKksmF0GqSp +YuYcOOlCNgPYB/rEJkcPiXVKkjG0ynJIkJKtB5V3k9rknNg0XVVlFuTQdajM4taTVLAPrbJcOkNl +FtBBzUsIml3Wne7mySWy0hwiNDGWfO7oSXfo5XV+stca5t15rrJoMSRDlJZ+v7hGuqcoLV/AblDW +fmJvQwLc0jpOSxyPITZWx66KT+ld7eF10VgzZTFTAsA+cnH1tYMP9qW4qssb72Mb7m44dJGNZOte +dnvK81Jc5iZaJSfRcGXcQslu5kfWnu61fiku6FnW3qIJswCXvYTW7K44y3wxJ6vFeFecjQFk7h/T +Bo2YHLE2Sp7qHVhzmNLKbORGSc9hFj31xgl3VvsYnVg5l6/TjEzv53d22aF6fJZeFebbEEDQEybe +9RGL2k/Bgzvrw0FviWSGehZLlGWzz2TylGOV9HTPgWpIuvyXdtnOd+yojWuGpArVF0+rVbvWYypg +b9tFKqf6niubVECnksYO66ecvLfLzok6rolBV9fYtMqMB2BOVXSC+uxaG2A6qbIcxhxzedxPUnty +uSTGHOvpeMJYlXmyAGZIFzbTDkWMLZgF6DYH0PU9JFYJYq5yAG2i011kAbrNATT6k71kAbrNAVTf +cOg9C9BtDiDyWi+cBaghFRsLUx8H6y0L0G0OIMTY4lmACj7t+YY2x8prFqDbHEDZRl4oC9BiSIYc +QPV5JR6PcVbLF+VzX5FtmaJ8qrn8wqJ8Bq/CLynK51SRbTVF+XDOiL2CsnxRPl/ARCtceVE+Y33k +X1GUz7o+8iqL8rmqX7lMUT61VwEOirMclIgip9Rg66p+y98NdbyKu6Fc1vVzdTfU0nX9VFNbwd1Q +VnX9vMUpLVrXz76q30J3Q5nU9bP3Cplb4t7r+pkTn+3dUAvU9XOm5FXU9bOPDJE9V0vW9XPK5FqR +Q9e2qp8v4Mmha1nXz35qOt/FwnX9NAMxVPVboAKIaV0/+wmZRaguUtfPNB3R7lZz94hxnSlrehf0 +AnX97G/+ks/El6zrZyvo8kiKraCun71b2NMNVDZ1/exNXdMo6AXq+pmlSSpbb7l6fCvIefdU188e +CvTzr6Kun/2Bis81nGUS3/UZqYvW9TNRNVVV/dTVGYgl6vrptiGhreqnubPLc3oKIdf1c8x7XUld +P/uqfjIlL1nXzz7gWpWRulRdPyV/y4wWdfdcLVzXzx6BSINdQV0/m7027dErqse3aw/FdT0+h3Jy +ruvxLVXXT4Ziun28ZnMY6vrZ5D04Rtt2vNb1s9fk4Y0Hq6jrZyXDb4wniYvlb7lQ56WTRKdt6FTX +z/68WRtFsHhdPy229dbiovX4vAVpWNfjW8H2kav6LV+Pz00Sk9PtDcZYDW+l+PQZqcvV9dM4tg1V +/XDG0PJ1/eRUKbu6okvX9bNXcyxozHNdP/uqfkvf2iTW9VvS1+eyrp+LvNcV1PWzr+rnuR7fQlm4 +Om5prOu3eDK8qqqfqpel6voZXcnqqn5Wt5x5retnH96lk2IL1/WzD3TS+ZQWrutnsi6qqn7298K5 +r+u3uN9SizHvOU8WduUSdf0UxmVW1W/h6EFdXT9bilBVAFmurp+9Yoit1+Xr+tknxIoSeem6ftpJ +6qv6GfQx1zdZaev6WStBWIdxuMnKZV0/VzrM0nX91CtpPMCxya612J/mdf3shYNtFufKEmKx3E+Y +iIcHOx3t/No84kN/r9QnvlFRJyvBU2vXrn3gvS5tUUNNEo0ppzfpg7E6Dx77psSuQhoJGR8piCES +5x1OxueZxhKtTmHuGzX93ABi5Xgj8ni2TSTuejxuBPOpNrZP00dxIjTcSLQexww9+TwupfvPycvr +3VBsEA7mvnNE5eMsu/U9z3EbT402DX69ZQKssFfZOT3/vmK/e/ePvgDPxpmWcFq6i5/EJxtstcy8 +5a5614ft2il3+1nvnLHfN6HO+/ZtNswUvjbrVye9VH//btQ5DA2/X/nvwCQz5M42bs8Og9t0qMwF +3h+PjsLzz61HZvTUSYl7H+V2pq/rtZuNeOQls0F9fN9E9ulghijlTnJE6b11TJS5navJ5C0ZmkyF +26Pp1gvXnLLNxws507IeOUjEbuN0Nbkppb19JSbTpxEsNpfcwrnVRh6iyS/de6i+JrOtyzE0qOUS +kLCe5PyNDOxmM9VjM2QhZIDpznbgutDbG5ZzRRmNoUawc7F181BPbw8nidIOxXzMt/rtjTbMJD2W +kkM35tExcwbj1U6HKCdxI1uq1wPEdqeN7P2LkVZlH+u2D5jaRV6VNKf4W1VTA2zNDA9pLpCf+wKF +h1LnDhXQzD+Xr+64s3x7M5OY7R9nEtP2Xim51bso3mboF4C2Ybrcv7l7yla4jSaAc/MtgcXlM0Nk +pMfDVMb7l8xedWOCZpUdjCAlZ09ub18jxZu7CvwFJnzRj8Ok3Sg269Ps/QRZTkRiFoLRCK8zzIkT +bDwo/SJDyHcMMMIPwZ/8Lsr6BQznaAz+PIgiDrMVBFLscQIe5OPSh6VEqUidCgBshYgUooF5KVQ5 +OiKjwc9BsdX7ThKJNB9GA4WDeyZ38+RevttIkODFQUT1orGdP/AFpFf5mPKKyj1cH0ovjhLKC3p7 +7yMrvTgn5RcvItrKB7vKM6VnKPfL+ajqFexbhFMGux5gYhfM9CkC5xymnqdfgAGWr0h0Ew5ZObyi +wXQvd1XTbX5EIGYvAcoPRj2ytc2n5HMxwAoheeXIVuyAhI0SMG9pQLYOjyDaLknxm8trBBYmte5v +wZ4jMLcYiaVtKhxjoPZfjymdUuHDzB7uZQ8eeF/l+vGP3exF671aODnaqCkkKR8L5LWGa0BrcOao +cKW0bwYPUPKiEC+rBzLEHDu72O6Unx+Ej2xtvt0tPrQvCDgrElEvpuQ36nn+khFX4/6Flsirzqim +XjjkW9I+uI0hBFKFyzyUgLcJiexvAezmM6zNdkuK6i57K2oXI/ibln8xGERxb8CBPx9EiK+tElyS +h4T09QMh/yJVo3mjXrrSaB5o9MIXEF8VetviPuh9sXguWkmrPTPd0bAZmQtYsBkgKyGj0bGZ1PP5 +KFS8zZ0e58L9Cczp5yq5IhGvG9mMvkpvEFEb4AICutE1LJ+LAW4p7vi7XgSTZO7uZQpmtRlPdDcv +dujt5GBGEKH4VJwuYC4obhq5J8GfTBhlBZPFpwz8MwU20vZXGvKNqGr1n8A3N5AmKnGkBsFIlTgy +3MnySxwa5pWEhQumQsgEuaNyp6TZkxAMFf0mo8TwzReQFupkF++7aD7QlJ+J+xfocHA7n4CF528q ++bdetq1hQlWCYJsncCFOVHRAlnPfUOP4OEcYOwMd3I8QJ4ZTf8qKaglgPfgZZq6Q4WBJYyuHFOes +aaS9tIwh7Rl8dQrVnAwQ4MIc6zU77KikUu7Qs818dhN8djWDjW80dx9ImlJYDSLaLepARPLbh0VZ +QFeoUPKeVlQ29GxzM31YJtqBYWEyORjtqlUIoB+gexVKAQUE0dlkEzoQd3cXWRlEN6TZKuU+RGoI +r1/xaS9G7+w9kgDHhSikHMmuRE8hjcXx0+fpK9ziT1OJzbzONJjfCopljqmPS1lTelaUJFRgGqqa +m/DFPcKdSk8OKkrLbuZ2tyHpJgeUpJbg+xmA+Ntkyvpiy7AQrrQu8w3Y6QZeAWb6uAOlWOl1Q7oj +I7kljqd/faZW3u+jQxFjuTB0euBLISrP8c2va4CnSAl0Go+hDW68LQJ64cDIyhERCYVpTUbCkxoJ +88dzGQm6GzsiKhQ8Tuim6u4OGQW+QDj/0H6RkADGo0YCP7FEgoSC3W0VCg7z3yMVCg5DhQlCAaBk +sVup/jdaEmckACbUS+BOaf68J6KAmpNmdIBv1bjXIiGhEPbdxihRxEiY5O4fFSSEmttXTxZ0IF5H +K1ctB3zMjJRsQUS806I2clg6B1BG4XkMMTMAaF1cg4gvuKWU+OQwseRqRK1pGnF+aRQ2NB2NWoBw +hQfE+aNxF9OgM5ehkAiicXiuHQNpPwZsV9rypyglgeC2lNWYbpZP8pp2iV2lHSyVfmFR5x0sTmhZ +GgsvT2OJBcegojFyWRoLL09ju5YgXADANBZzQaYaEPppOKBSpDFbTBBLUkQi4gu4wIQtCDeczxew +BWGFSlerAQHE1d6ehYgq4Zqwkdw3BUEsOw3VzvAFFpsG5WkMaO/rR0E7788Kc3Caj+AxTNKs5tKv +N0ovAxSJ7BYTVNT7GHTcklqWqKi4GUV44paUG+XGTA4p3JJadotTpPZPSsfHKFo0FkLtOjBIM1Ps +kUFWmaLpp8u3IWxFKDZd8SW1L5p9552haNve9WLUa6UdJRKN7xiyhuEdEdPPGPw6jmwQ+vB6E9l+ +Qek4cSuIgn6QKYy9a7IpjH1rwYOrb/BnJob/fJ52kKEYpLf3999Kr+FHVP/lJfMhm6sh2ev3TLRD +oZRkn6Z2VY411QzSmajKrRY8rKalF6W48gLddyG7YICxq/K4Hd6Mc5KnLIWmEVb3XM5EVG41Vc/l +kuLQe0E1oZEXrpoQvQrlcwK6ByI4MwUYzxS25JovgYY03csIdpw1xyQk+8uYrF5vU8F0CCY1XsZF +3xqXh5RzSeDqchOyVTlHD0SwrYdHUvSJ3pciidNaD/KDOjb/qTCXakud1uO4FyK8LRBUvxYoRpPh +l8wecbOtGN6Ixv7/7q69r6mjW3+CfIdNLcp1Z257z4y3ylVoo1IRBbQikRQtChrgvG//OZ/9PM+a +nWRng5RX2vM7v1N/rZmVZGVmXZ51m6SD0jt1ny7c0xpW7y/a1+B4Gb/WNzmqGkfdvnV6f3brXr98 +uOWeLvjfDqaqVtzu5kRlvzuvzVAb70bmZabPD45GHZJXc/WO29oDQsWrvGq27a7r1AZafv+sqB59 +2jLVo/PXb2UMaFam9/eqR+awIINCGMDG9nYfkeNuzt9FOTF7nzoqvXvv/HnF+9309g== + + + h2FjzdQ7bvcO/hg+4YZe0B2eZVdGS7VK/HbqESRre7AzlRpdK28WxONnBn29zS/VS+DYs1Xn3E2N +OufDZvcd6Snx1nHKLtamxfJ4nYWRYW122PyBYz+a+E0EzPnonPx8Hzzs/nr74/ZZnlpVH+fuzgo6 +2R/vrfx82bd2WpNwvqe/JKsd/odPbVU1cqPRLp38Ro9dOk4PlwRhpoAw3aPFTz8cr+q5t74n8pSz +/KJGfa+Gx9M4n4hsAWYhqUk/3poK0vei41YttMeHjhJ7mlfjO1jqfz9sBe2LLBjls/bz80+9/rP+ +x8OPx9lc616rvbCu9dbxwclqv9d70fv32fLJ+/PPveOz7G7WXthcWl8PxXLv/clBL5M7KMU7X+sx +pNZadb2mPokcu3eTutDLv8fHR2u3nj/YX/5d7Tys3cqREv/OlxdfJ+Y+/IHsZGL2fT45Mbd38Hpi +zqxuTkytnc5xuZPaEMOTXZyHvYORlDO3lnv9xfOV2SedV40GukTL+O7F4wetyZVXi73nj9qnh/fb +awu7vyzvrr7cfNQ+UyfSqWg2B9NJh8PKS2ab/b45uz0xff+pm5hv33nJGecyzvLjcmhPzE0/ekTq +zxOzv/7wlOd7yid+mphfsAcTc0+21yZmvt7q0/5D1UFaPedFOTNbtYZH85vVvb2BD26ciGO0kgvp +ucNDdnZffq0wlk1ivnvYJG7LkjfRpqpHf/RmKi+C9dS9SJZ3p+iNa/MVdvCHPSoWv2/dPRt0nNdr +kUqt7Z/FQQi7/gRqNH9qTf5zE6jR/Cl1va8/geISqcUElhuPRrz3qi77xqqkDDMAtt6iGBqn8EFu +U3UC/P8ZVLvxrM1YO4cP+PojllvCdiYpp73x2g7j4WxtFnVwO0dA2umM4vi7waeIse9CYsvt/fu3 +7x4e39lavb/i/mi0QXkf4df65arBDavhXYCIHR4vjThexi99t+HaHAe/Yywcp38Ov8bwePXRnd6L +5fWDBxOVN+1s6+GYyYzNb6Y/7d0aBM19Nzz6ft28us8ET+cqyO1utSuz724r3e2sT+MR0o0UV7pv +zcO4bqCr7j7vOlSPD5ywqFR79Fw4zssFKCy3B2nS0Ws1ePR2ZG3deip3dGBrT7ydsHs4i0T3d0++ +TspZxu9jLNXvUMFq6zAzRIG/hhmiJYCGaHK/ulbx8OinhDVzX788uxxmhjgmfn5wu327auOncPzk +uDrus97MIM++82BzphpvA5ok7aY5qyrtfrWyn2ItwIURaG0qBebe6RHrrbWZClL0D22zPP96Vsbb +w7A+X30HWGbcvCKzXeVfj3+Zrr6DVqy2L78mCPwZGCTvmQ4umwIZ3BRHYXkjR08z9alGgp5Cc6oF +gDXDQVNen65/WVLLP98/URdRB/GlGjM9mJEJW5pFzYreUtXz+K30up/OV5H6y932tWeSifeFb3YM +f/sjqXFkT7z60X/Q/mNUIl422OGvRf86GOz0ZxuzoX7//k+b9d6HWn8zl4+z+PBwa29mZTjE2moM +sUi7VR9h7ZqfGyMstXL/WWKQJl6/XmRxPsZi7fZa3VXc5p1BvObcdO6p4c+K0p7WZvkoH9LaQpPf +LnwIq53b/Mr8sp9gBsFxt5G0fn9ZPPVZ7jhSJtXUaqKa5Nz7/Hw4Ptq5YnxEz/nr8VE1Ib5sdpJ+ +W/Was5NLJie1HmZr8rtaHPKjhkkEb+sikIleJYLdkQhwFu6nLgQm+n8hhP37T0cisK8/6TASAfPs +vDFGHP32+nWEcJ1O/9X9aPmfIl89Q7tyjMj/UdxAim8ahnTNSST/v1Q3sMXBtw6+tYvr7WGvfzWD +pJcrWXRPb+ZSjz+cD73yO7Wx8ebLNWwaaFlj0bDpjb1vuMV1RbnROx2h5XcNZh9unEz89R52BrcP +L99Ff3Bzwe18HrFQa0923o+Nwd8M7Xenpni1+tva84aNyc8Y3MTGNo9vbGO9sxvu4dPEjW3s5fGN +bWzn5D+C3osMuv2hjV1hIrtXHePDtUX5TRs7Or+ZNnb2au6aJHaZJK5k0f3PkI9RrMmi17+ZNnY+ +nDZMqpLY9Y1q5+g7DHvs95ge7hyf3/AY/YnLPAP1y/WPcf7Dd+5hmCfv3rr1V/5pTt+MWEzceflh +s76HbvfbMaAWka+SRLf39SZ7IFp2P9zQqLpHpzdFy+7x2V9C3ZVxqPv1vJYnf5eLd88n6sv3t34Y +W96+JaVC6hTzOuJPs+xOlI0OieqdPQqSYI5qulrZt//j5zeplL/zYKcY3MLck5JxfnDr9c1pqiuH +l1bZqq4eTaVuHkrhmfFSWCrjuWq5lEvdnA/f1h422N+M2sGUGArbWsft75tAjeZP8in/0ARqNH9q +jU+g2AZ7vGWkK1Zv9GwszUrjrGr0bKzPD4rU85mqCtzo5Km3xt86x/K5Yvav8Z8D6qW9sZ3Y2p9e +HOfV1e4f8+nBLGpddDlb7xTuPMvlU+xisOFe7+3070sfytVni5/CrVBrXac2LQrv6nvmF0YIo+p9 +53n7P+J4Gb/WOMctNeJYbj24u7Swdfveu6UP/pcvCy8Wjl+lVtzi65m31aDp/fbwxvQLO/ruQl27 +3c5crQe7XzUgu8/Tdxv4Dffp9Gj/h5epATdqDZnFXbvG2ciODFrkUaXY7mGRemupQ3u0lac7jnp4 +63l+OBaar/dlj/ZNrbFW6wgfHbpB/2i3qM6yrW5JaTZqq6VvG156wXr277teLV2Fyy9Y/43Xq1uT +37xg/Tder06zqEsvWM9+z/Xq0/9+2LoHk1rXem/l+KA+Y2pNToKy2Ts7/8IXFHuLvcOPx539P3v9 +ls7SH4U/+NtlurBZoTNTFKAUJHe6ran984OPJ3vdT+e96axz3Jrcay/0z5Y/vj/7eHK83/8zuwuS +ztqLJyefsqmF9c3VV9nKv7+c9M8y+ZjsxUm2tLk5zeHWla97+fH0Y/dTb+z17e0nna315exuVm3j +38VqtZV7ZKLVHjaDV6SXQwh7LZUt4N/tf7XO8Udny1g8a6lc4R+Lw377Qfqzvd9SIhSDf7f/xOJn +PPgDpH9lLnuSvf5NZQf8gOctn/uisD4zKi9M6bLPLa1yrbXNjM6LaELWaWk88oXJjMkh15hpkzvv +yszY3NsycF0GEXruYsyWWjbXRqtIFhrPgIXLi+AdP0WXZVbmJuoi0zEPpQ5Zcw9Lrd8vV9HUvMpt +qVQZp7P25ln/4/FhNrW4uPAehvL85Gyfr01S9Fl7/fgsm9p8+Xhv88P+l96LP7/0agKeOcfxIVZs +QCkPW8mDiyU2r3IfYuFCZVOKsnS5MV4V3J8yJkJGOLgLhZzHKFtmNjc++si1cz5kJg+2iPI8BMcT +NSkdUFQstQjJFEHkDDYR8jVlbiGgRNEB26NkrQiSFAPluDyqaDIsldJc2ojXQRNBR0vNRI19LbWa +lA4ptqR+qbWI90C7Wom+Sw+lQf/WqCDKs86SR4PSgdXE0gbRmCo9T1Pm3pfQIXRamBgybLgo8B6u +S51BhNa6JEENluPrjqyV85WI+XITaHGVxJsaWLqgk87NbUYMg85GY7WUqsIxoZnPrSIvlaWMYKEB +FlrmpdVB9l/40sCCCwdXkHcEeMRSq0nptCI0ZoOm3FXhDDUBq9O0GvqTMtSEC7Qe2AHMi+vgbUHt +Gk89jK3FLyPch8oPQd4eC1lC8FaW0RquS2tsev8YJYldu0I0q0sjFOvKUnStSgvBu9LxGFhqS8WM +i2bpgrD+LkXMbP3TGLBVgaQagCT+OmiV2dR0tv2qdV5hrvPGQABEWO9ceSn4Fq5QsHmo03hXkBJL +5WEfTSA2QLwAv4EmShMESfAJWggaLpVhGYEGYgoGanjZsngElchbCm8yrgNeSTcuTJHtkIWNJczF +AY6dI1gAdeHIPg+qFNgONFYNH3ViSIQpKlnDrn0hTgolJ/jwycoNfEvz9CVRhBYKSwNuh6gIIjBR +xeCAjxTEwvMFLBhUp5VJVo9ojD36EhgD24tEGRw094gMjpvzZVHyFaHwslY0ZosdVO/Adkt8Ogws +qiD+EmClsFtgi1PAIaxNjIwfhdJEMhzYANlirp0thIfPrcKRcZIElyaPHrvAfiP3udOizDx8EPuD +K/rklVHhUwL0G/gMvC5qBi1XhEiVMN5p7KjIAQKwDYBw0AVRymoN1IJYlY0EPV3gZdgGAyPsAthd +FMl1SwCHp6V4WArQAJ8PDZiM1q29DYLHnpdxGDCoAgeHBJBrfhYOTy0r6B++nGItntcQKOSoXVkk +pWkDdMUBTEJZsHSuENuBjCUEiNBhOaI+aLUoIHLsV+AAPAoCdEGK99xUBK/IE6ccoWHP/9ciN/Qf +o4bzQbkSSD+LWZmSflzSSORopS1omSWNS5QHhcBCXDSV9sYo0B6EHpWDPr2iSQiloPSZGNDANHFU +zNnHQDCGLXiEKcuMxwoYNygS2lUKlUimSipJw9egihCdBAOo1cIMdQguJDgfo4jpOmyRCRWZ0iAh +o0BHiUQTsOYRZG19iqJ1AuFfJYeJhKUq4TClkgSiiIOkBEmOUBhnEqGgV4HgESTo2x5RkqCmEK/A +3apQwi9N8Jrhv0kR3y6tDfA6ZPBWdlQGR68LCe7g60A3iMM7bSoeYxThAaYRFJOUQADEYRwtA6Ik +GkQAIazdGjHvJqVDiuSiEARCcUwUODkV5ZCuaTmNKz2xLuEDZOeYy+BTqDfZ2RilI+hHRDVIhuDc +kgd772UdUpbgPfNJ+SidIHqMIs5rvREQkQwQQKAKbgN+kCAYqMWjaA+ZJv8fo3RIMYxPEIg3TOC5 +NkaSNafJkmBeUq1KOIwTOi3J97REBkOUlpO5IgGAosqxdCHlpaWVFD8aKwhjjeyqSRGmNkRBnYLM +eVDCODwV0CYJU0mwgSIgwyocjVEkHkWlU1iJUokY5uP0f0d5A27hGWIB1PP7luELjcREhVSr+YId +viAoJrSwQOgBYdfCVATruVmso0thuCgN4bZJ6bSsBBznJGXm04Qixm0AeEURbIAWgpHILsEJa+Wh +Yct0Twt+B6VD+ogxivDwTIOZxBOjsAaAJ9ejjTJjR5hmTCttTCzGKB2mD0hxJEZ65txMJyw/BMjK +yGxVFXiUpJdLrQahw6wG9iSbUF5JVECpI0aB2BFkLW/A2nqCX5MiPJKPMpLEal8Wri+HteKJF19z +KR/nvezFatECKQQ/wqUe8NEuIayi0g0RlHEcMEAVwXrS/uEnWqqNJqUjgZGAD0q0xD6Yc+kE6JEX +CRYCAuV5SduWWk2KGK1OeRtqKUlKUDFYMbHIUhGGxGoZa6QELtn9GCV5dLRSkosSZV3GdDRJ/Yrg +0tF1hQl1QodpheR48CRTJlfCyehDBXbBVJRrJGCCkcxQWD0gvyIOIaaGlJqMUYSrdvwcCIehiRUN +n4FJ+SLyrDqJSbETEKOpwGaMJMhQQndMiiTxtMQTY1E+kxIlHZMQT87MeV2V9I1ROg== + + + iSJ5uU4BWwjWNAj1RGHpYu7wd5aYwLrIutjSanBCyUskNyMYSAQmEjExRHLL4kLCjmeawhzTVkG0 +ThEwtkRjeLIT6Gei73UiOJ0gvkrDjU4JW5MiNpWwEBGYWEjlRYYqyQywKmG0yAYk+opd1wmifFWI +wRQuSj2qnERlLxY2SDKBq8qXlWeMUSTWlWXCINGTUEyZCiVpJLFpklpPgbDMUwgQYDPeDM5VpwiL +IKk+LDlEyX4lK2e2G60YaZInnN0HnTY2RpGzGaUkxY8lpYL3SvLIdSnOEov0fFmqKoMeo4BHyZpD +Mk2BDMIaQzx9GCGHgGv4N8v1VH41KQkcdXLkWDApUKl84Jpgx7JSoqxm18EmHmMU4VFQMRQpQcHS +24rUdmBlycCgvbwjIBIkHmOUFDwEf6QVEfme4JWcRRGppJ41gkeokEziMUYRHmAh1afUKVwXVngY +pGWyLpW8w7AGSTzqFOEhaYiVhDJD8Eb9ohm8kRWYhPDsqJSAWiXm0aAI7g0ovvDSYlOM47JmWY2U +xgRJS/CXT+YxRhETS0Ee4JlaqEiztASF0kvaF8qUHQGkq0p8jCKYJ61FlqouFeMupuZQSghZWgMB +4RplSHVegyIeLJZesh+rqlBjvGfpXBqlk08H6ecwFokvyA4ReoxJPYIGRbiKBTPxLYJkjxJjkMrT +e9lDYlFES/DpcA1KSvWYFQJLGJyJV1HCRMIWIJpEp2EW3CAIkntK1AzKBJ+nxhzTPqQEkjPSDuH0 +KTg1KVJ7a+OjlAVVek5BeYY8pX1RvSZ4Fl+IgCmP1A4hgOIrhkkijCuKXzQIsk2B9RK2ruTtwC7D +lkIh9ZinGCLKHyWNi8ShTkk7YBYArRaqlMSz0EwfIlsXZWq6q9SUZy4vrd4xSqfFRgnbxlKQ+CBt +WlRZYrHSt2EewDYENuaqVNRSSEQoAfcGQbrHEJpkB6lvA7lGMSyteWIWwuz/uiG6NylSLEtnw0m+ +k3ImbVmWlKGqyLUqpLUhab6U4GOUDikWaaG0P4pUgjdC6mWU/1+tye8dB9FQSiYDLLa1zHwM+7yO +FDbbUm+Z/oVyQfKjQBHCASwcj2U51C9VDJ+3QWIULEla9pFVDNWsWA/R9cA1GPgFxKMBUEaaVwh5 +bMIgQbNaegmpMgBkpFYU4McmLVbFKYdPLD2lO+fSuEJKaGd9TGMUk/o17E2y0V6KVVdDE8WsoYJy +aQNaCROOqNsUyP9CG+v6PSy2gWKQHgEMXrQlzQRJ5lCTEh6VcSKBiCKAna3AYMh6IiFDk0LduNRX +qWqQTovKsYBI6SRCJ0ldVjrHlKSB3HD4KgkkXEmL4AKJvENFCqnSAXyXKEZZJjIxZ0OJKMuYTRXT +dsYpRK7U1WS3Wyo9L2OeZIAoC2GQRWFZNGONvDljI5LlOt5QOikDmhSxadqfVMW0QoKb8pJwSFVl +UmcC25Z9CvqNUUbjN/gDp3md5EvYspiOqihGJeOKzlQUeKN4lw0pUdcp4LA2lRRUpVkrE73oGAYK +yFt2Vsbg5TTjlE4rsB5T4oKIBxEVnJaAIWsgNK1fKUnrCh8p5iYFadPAMNid15IoQPcMitgrUgfp +1ytWvlirkokdNhismET0acLYoIgBIKrblA0jVaCbK+mIs1JktMDxZW7IzD+kjmCDQr/H6aKk5ahc +EiWkhNnI+G2YBLDRHWXakJY6jTyXWg2CaKII1YTVDwiFF6yQpj+BkKMDIoOtclB2mJIyY7KJMUrn +ApxWVlLUrYTNQyaASARUFTU5KcDHBl2tVfIzp4uEYXWCcCgEBVhGmaQpeF6akZZWpYnyOFJcRvnH +ge3q0LXVJHQW052OleMDuUIxP9+anNzYP+y96O9//NTrtw5P9/+rl+0fH3MXvS94Jjvs907PTvq9 +7PTDyb9IwVsGL5+cXHm22vofFiMWXA== + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/originals/SVG_files/Audio_green.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/originals/SVG_files/Audio_green.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,1662 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + + + + + + + + + + + + eJzsvWuTHMlxIPgL8j/0fZAZaXdoZcYzg7d2ZvVqLW/Bh3FIiTLZ2hg4Aw2xiwbmMBjqeL/+/B0e +WdVAAyhJJLc7gUbDO8rTwyPCw1/h8Xf/26+/erb79u0fXj6Lt/PN9Hd/d3j38sX7t+9+dkPQm5+/ +fv3jD+/fIegnv/npzZJuZ2i0+/n6tTT8x5fvfnj19s3P6Ff0yzv89E++evGHly/fvLjZ/fD6xf1P +b37yU/jNb1+9f/0Sfrf78dtXb7/+/tWb/3n7w5+++6m+FdAcX7yHBsvy93P4+zAv883cfpYqNnjx +5k8vfvjh1f+Hvy5xjQDbv/3xzbev3ny3f/v//uxmvnm23MQAf+A3//XVb17+sP31fAsfnNdCrZbb +1lqGpse33/x4//LN+1+/e/vNyx9+OLx9/fbdDz+7Ofz5xZubX7z4Dn7z4uafX75+/fbfbvavX3zz +PyfofP767tXrl9DP+xfvbxbq9e7nS/h6/+Or19/+8sf7P7wEDsRSERy/JpS/+wFwAVr8GcH165/f +A+Srl+/fA4nwQuTc4Rf//N8OwO6399QOqQaibxb49ye/3v3yt7/65Qle124OyLL/nX4L/5tvUx5a +hCX7JqEgBvzHNRlaRPj8bRtwxMoNfvMPe88ZIgkb/stvXn73iiYGjNp//6n09N3b7+9fvPufP3Az +GQ38zW9f3n//GsaWxmIpt/lmyfhNf5JWwFVq8Syu9eZZKBF+HVu5Cc3a9PF6+adXL//tZze/fPvm +JQ/K7t37r3iCpDTP/J1/85sfX79897s3r94DZQVBjUflF2+/ffka2tvn716/+O4H7eTSv3OD3754 +993L9zC13r7+8T1N+lXfAKP+/MWfX+LUWfgFv/r+5Zvfvv1HovFZjbellHxTFvkXOFzWmxJhdFd6 +RWzAiCZv5rfSyDN6RIao9B24JH4N8+dX71599+rNz4TC+vU/vHv1bZ9TNdys/I06cbu6v03/MrXQ +8ffvX74R6mEuH37h5uZ8+4uv4I2nN98e3t4j93/A5Qcz4A1Mjtdvv+Pf2c/0G/j4j98z9fT/r2Gg +fv3u1RvEOf2SfrN+/evXP8Kv/uHd2x+///mbf307/YSlzm/fvfgGmt386g//4+U370F6CKD/9NWP +r96/vH3x6vuffhDRr1+/ePPi3Q3B4cMMfP7qT/CbF0DKDX8MftNhH0d6fPmvsPT7Zxl6evOnl6/f +fv+yww3y4s23N//04t33H0cNw/DOYaD/6r+P6O2L938EKfXyzbc/GFn837GjDPs4vq++wUnx7mb/ +7scf/njz27dvXxva8VeGXcAExfZ/Ge/4NX3gza/eMIPO3yQNtm8CgfAX9xZo/fAb4Jd/ydgPL16/ +fvXduxff//HVN5decOH39ib+3adMrD/f/+Ht61c/3Pf55CC/fvHu/atvXr/86s8/vH95/yFsyI1/ +ffXmW5iIJHQ6tW/vv0cV4+arP774/iXhfP/HO2r5lSHMX4Ng9KLv2bMPyMQQb/Zv3O//4d2Lb1+B +uAWdaf/6x5c3v4H/vnh9o+CfTpfBIO4B0bfTv0z/ZZrxa5njnOY8V3jWuc27eT8f59N8tyygLcQl +LXkpS13aslv2y2E5LqcwhyWEkEIJFZ41tLAL+3CYwjGcwl2c4xJDjDHHEivoYy3u4j4e4DnGU7xL +c1pShCfDU1JNLe3SPh3SMZ3SXQZa8pJDjjlNOecCT81rbnmX9/mQT/muzGUpoAEU+DT8ukz/l3am +fy32d7n4P9Qgg32P8hdII3bEOU/EFfyr34v8TfJTAY4V4Jl+X4l/+Le5n3bwdw/fdxP9cyD2HuAv +Mpm/A7OB3UgcfEFnQHWDr7j0H/7LdHd3d7o73h3u9ne7uwbPelfvyl2+S3fxLtwtd/Pp7nQ6HU+H +0/60O7XTeqqncsqndIqncFrgXfDx4+l4PB6O++NuOrbjeqzHcszHdIzHcFyArLvD6XA8HA77w+7Q +DuuhHsohHxIMXTgsQPrd/rQ/7g/7/X63b/t1X/dln/dpH/dh2i/Qv7vdaXfcHXb73W7Xduuu7sou +79Iu7sJuAVbc0Vjd3VF3sENH6hR2Czu2s85h9yp1ETuJ3UzUVewsdhc6jA8iOZ0m6jn2/UD9Rw4g +DxrxATmBvEBuZOII8gS5gnzBZzbuIH/gawImIZuAUfA04tVK/EKOIc+Qa6l35vzr9MjnuH2mc5Dw +6DHP/vyZLgB35w90Jt383df7d9Cngl+VnhWeJg8MZtnTA/MC+IBMvaskOiqICBAGkZ5UYcnCh/lr +rW2qDZ5d3VeYUshEGJG7lVbMusADMmQFQbGmFVb6Su9c64pfbYVZtMJUWw80BCecGm2eYGmBSGqh +xZYaCAcgrzZoDabbjh6Ynw3mMI4dTQSYVbAIQYjBTAwwHyPMygRzEzsFlNFQ4vqjdRjoWUgE8pNA +FEYQhZl+wu8JxGKmp9CDHCjYGRKWDf7dTfTDHl8K3/fy/UAPrDf4fkJpirM5kByid8WAXyBBQcLi +A7IQpCwIvLBOJGwbCdxdgEUJEvcI30/wnRYGyF6UvgtIX8SAYhYEKYwJ2sWVpPEKfW8gj0kiPyBt +kFu8fIh/yEfkJ/K1EZdxPAvxPcEIRKAIuzrj4MAQHWGwDjBkO2wKg1gnGtEM4xtprBeQl3e4KmEm +HGBW4Ag0mCgVJk2G6ZOA1AAMnWH54yQ7wnTbw0g1QFPRSppA7ifYAQJwfgb5cIIVeYD9YQckrTj5 +YNfIsL9EYN4CIvsOFv0Rtpg9DHpLK7yhwOaTgD8BRnKOLJdwTdMT7Qny0HgdZ35ksYm8OZCwOPDX +np4dPW1Cxh2IGQea+bhsQKBmEqqJBCuK1kDiFZ+ZhOwdCVoUtUcStyhw8Ws3kdxtJHtR+lZejSCD +UQonksQgi+GhmbafSSSjUEaxfCTRjMIZxTMK6MYS7II0uPC0xz7T8N/1k5566Zkugssjn3z+dFn3 +Lzbtbz7wAz8B/pabPN/WFitYzYAATN+vPx/B/gd4e5pBfAZsWlKr8SKWEmAio0m+wtKmNm2dYdUp +xnob2xJvYr5tOXe6ro+aKIaltSwF/Uaggq3pItqQ6ow+i9sCSmIiJxLoS9BY0C63qG7dgCrWyb0y +XqB1fzRFWzXgyyr03YtvX968f3vzT39ENX7a/B+GKrDSjJRkEEH0Q6ygop6LTyCphSXX8Qekcpx0 +iOdG8VzsLH98/AHx2EQa+Xc9lDTMX4huBnQ131yPPkP4KQP7D+9evnzjraINgLCKPWRCNJkQnTci +VMWnCVCn4ybSKgLpGDPpurKBHtzW2bdN2DhJ+sIWjZv1DNs3buN72Ngb7PeZ9IAFdAPUE3awvaK6 +EUE/uYMdCE0JtETCfPa1tYTOG5DM7xI0i4INltldEPU6oEUyKNloXZxMz94PVgZo1pOo1Mtgahxp +a6TvbKQ1sZey2FVoakUxxPT5hK/H9ZWsR7Qf2YI8gK6AhsCdWJJsS5o1KZrvKhrvRttFfXdyym4i +ZbeQsruiqot6Lr3VaaesmzbSSg+kj7IuGkgLzaSBrjBDdjCvDjDP7mDWLTD/IszEDARU2Owb7v17 +UAWOwPs7UBQWUBoiqBAZqKugYPBebgrgQgogmuH4lUwVpK6ymk7KIJrnjUz0HZnpohiSsQ7PhMMa +yfBKNF6JVF/WTBGnNxtcR3ayTHDBHGnx3FG3ZulaoDfxYss8N1aylI/keYikVq+kMR9hOgbSg6t4 +GtTNgL1jI4ymJX/BVOVpSxN4kelMyjHZkDTu9KBmccF10L94PrKDIFLvs1n+QC19mHRS1koL+ipI +LWXFdMGWpJyyeooKKquooKTShz9oK3fR0QVHYl2bh3pHmjw+q2j3VYYXB5qHnL9wIvCkgH74ERM2 +EiPFUlhlMuwHfw2OeDKPDSjy5LUZ/TYwZhM5biK0y6SF88rrq25cc329sZXJ9uVgW05kWgZbbd2w +5NW221qVYleyVck2pVqV+JF1IqNSzcoDmZXkJECzkh62KwNxNpl1WWgVV7EycTWzpbmfzkxNfdjk +nMXsZMOTTU82PtkA9Q9xYJJ/Pjg1P/PrbxXhYv8u5thbeG+ZyK8Xxb9H8tFtP/2nYttSpS2qyEKv +7v/k2pvYb0HjQ2uiyGrYu5WAyyA716VtOs55WWSb4UkPUx6mO8x53lqSbCnNpveJpnWwKc0uEpzJ +aGsfZQbr3JV9Z6IJu7MZepI5yZtPts1nJ5vPkaT1HVmPQSQ0b0EVpvkOTdA9WaS0DcFGtJD1Gsma +LWTjrmT17sgQxq8TGstkOC9kSuO2ksmNhmt2nY4redj2oiscQZTfoUuOdIlAD7rskH0kFcidx2uW +NhZSRvZqjJ+OvBkcvWsDTPu9OfLUhZfEvF/EoD+JEc/OT3V/FrHVo9jo7AQ9TWaY78Qer+INzaP6 +uFEddyLsWdx3xTFMLPVRbyTfy1Gk/+h1KRuvy+h3OZGL7EDust1k7pcVJgr7XzJNnWhemAVnMlnT +7Is50lTbi0dmR/JuJb9MBZuH1JxsDppITppAjppFVgnvrCdx2hzJccOPeCrKzp42sVRlfdScuc6X +ux98uerJ7b5c9eR2X+6svtzpeDJ3rvpyuze3mTe3+3Oz8/wMHh/29kzO2XPB1XPBz3Pu6Rl8PRM6 +ewZ3j3f4OKcPPc35fdT3o94fnnV5tF+iuYKCcwgtatOYXaPPaXiIU5P8g+PziUEBCws8FBWYtoEB +UXe2Co+pPDTJT+JcZNeizmzyK040qRebzkebyE0nMM3cqK5FcS4ezbmo7sXKitzkNLlzPW4nrsaV +XI3obGR3IzocyeVITkd2Ox5pBuwn8j6y/xE9kOiDLKRSJfJERvJGBlK22DRCtZsnOM9LnkQ6uDvW +AAfHvQmFeRAKBxUKjm/VfLLpTB4Y+yYRAioG/PrXtT8PblrPS3HWekZOF/jouZjEaRvIte55uBfn +bRuYl6buxTWOMa/2piCvohpnU4lZIUab+26zTxxkp1iHXeLxwbFNaGyiRTB/LDQm7vY++7vC3+f+ +gcW6Dp6609WZPs53nu0im2l8cGx2JHJXG5VQwiQu9D4izY0GjwU70E80CjqFbfKODCR9fM8Ki0V5 +lk18p5rqMirhd6KAq/INpEyid6vG3RUZr8qETTxndWaoM0FxICazP1W3Ye1mJfm6I5l7IDl8Ekt7 +NiWH7e1sig6qOrvJdB3cG3CPUG2n6zuJNhjTeUTlQekK72EBy0oTP3tTng6C9mjRhjtTp/Ql+qJg +UQuMTco79b367iqhzFU2QqZiJxskK2GqiB1lEz3xjnonepnqZl0/C7INJ3myPMVpbF1rW9k8muif +3aDEOTXOnv5lQVM28FkDj6KDV9PCDxs9PA2a+F5NUaeJ566LT6KMHyW2qdp4Nn18Z9P77kGNfC9T +mkKVG5V8cAVdcgaN7iDVyNUlFCfnFVplyuqEZcfQYhp5djq5TqyD3zAkZOmyOyS/Yw== + + + kfhjoQyP1UKOR/a+DI6DRI4Dch1Mku2xp4l4Er+R+g+6B4FHS30IRxqxnv2xmBvB5YBU8eLtzZ/g +PQrBvHjZhnMdotbsVzhO6saToPUiG5l689TH4L0MTeLXOyfdRL7Vu8kFsjWY3V0PY0hbn1WC2+qJ +2K37/kyr6JKyUnXZDIEycVZ0l8Vijov+iHtoom+DmKYMngiyvRC5lL/jvGqauqNuoDtx/bETSJda +X2hhMrdPedw6gwE52kjgGHg/KvpQhdHjFtI3EPwa1pl0P4m3pmcDsHvmOLmV9tB2sXcrTrYL81Rm +s4Nl2U2yWchGcWGr0M3CbxduHfodA0X6NGwbunEkt3kUsle2Inxnz34U45M43t24Ow/+Tjz45sMX +e+qSE38/2M/VUmDiJOqRWkqnwYzuhnQVc0hN6W5Ma6hbLJ7JDOrRpNbQ9nlYexPSFuNazes8WWDG +hWY+kN7gExyKj9aoyT2xzT2o2Gp5e0V7J+tb1e0qUiCbIc6muJguqoEvIk5mi3Tr9nm052DPfnhY +Qu0m+kZmtY+pj+HwnlGlWVWaWSVhHwv8uNDP5PKsDrZn6x7eXM5Vt9arqQHZZWCJ7T6Z+R5cQtai +eoZLgTo5i/5odn237cW+n2QpNHtWezoHiz3ZPelCAgjM8OCexT1zfzZpWKfhOY7PdDj/2p89uwee +dv6Q7shhkPOcP8v4eyDh74NWzSQeio8b+FvrZrRvzMafzK+lS03NnDRkEXVPlpqsW3N1YbtncllE +e/NYVWeqxsFM9Sb/3syhavGbNF0I4HB+kQ/hSBDHco3UAeBdAOIEmMSGPcncIl+AWLNsz7JDgK1a +tWzZtsrmHkjdSTCNYTdMJgAawK71cfS1hGX1gFTXRD/A1hnoVE/gDAoO/IdwizrQmFBwXbSUVFCX +GRpgsznlRukmpTXKBSDTHI8cpTw3fEmGkQmYArAwbktRaPE2wEzohF4Vq+S4BJiZiCA0wIUYQ5uX +PPR9WWpBSFEmBOx6z/O5KeE2wjzxKS7XREuULivgHBCEUgDFMGwZ+orsaISczvkwtthucVu7iQkT +gByl10VLlH75dErlllKEFmROCtecqVvUnAKz1jjmTS1hTQNXGvmT8IcacqIRnZEtyoh6C2/AtKWl +uUyY6+L9lISY56/evKRjT5YRs4X0bKfNEQGMhvEBgYMdEMDjAXUwIO/keECkkH3pxwPQcJx63H5j +YZzEvoibkNolY94F1aZ8Evtia10czkx4tS3OTXjnn5os+bhtLfnBNdXtDO+b2rezjOPposWhNkfP +lTh0W99lSpzlSqCfX11Waoqw42onAQPnvDKbpFslapkkiU6Uw4r6A7uvThKkY4dVIQtjJw4qmQpB +JkPWLAiZEHxmZJZTI/3cyEp2qfMu6ASZJMU5i4vBzRJ3hiQNp0i2WQnBe38ms0kf5f65aJiuLueH +PAUn8xQEl+1Tz3IPTpZ70PPZ1Slk02naujvdrAqbbINtNvuQy65JBZNLZs8ba9bbsyfnQQrOmt16 +Po8TRXQjzAu0V9FOPZKzMdCEqMf2sakwTobZHSLq00HT4I8yGeZpEBjjZOjepsUlqhT1N9mUGCbF +9IBPcJwW24mx30Tpe2JYni7kqYwiZtmkqAwJYVun0TpPW7ljM8WLnsuT5eJ0mVxWytnZh8FP3ifL +6PhwnnJ0e2DkAucIzg4UKicJ9ieZHO1vJ0Gl5x6GB7K9qp3monNc5zOc09XOD8lFc6FK4hpNZN3+ +cPoeJvKvLSTKcN9jGXYH0zTSXof5U0eYkgtMRUygbeo6gzkXYa6tML8O9QSTKcIkqhgiOqwnoDbC +3KgwHQ4wARYY9kJ5HkeQBAEkQKVxPcH2EGhEd5iq4Zb6CpL/cDyBFR4mWDmF0i0O6IW/WyiVrsCM +3KHj6s5Odfkjap9zQG0wVqdrHk9DM3X6+PG0DyXdmWFq8efpYhxOj7T4OJw/znJ2mKWfZJkuHGX5 +xIMsFP7k4GeL62Rxz2gRzxMdGeI845VOFmWYpJRtTGeRTpRxvKec45UONfGhJzwQBcvpjs4tHigF +uafzJsqvWjS7+GkqPE2Fp6nwNBXcVHDuqrXMM/kWQDsrrZFN3nKSWiRkf1463/JpH5MzLJ92MutL +TnV94smUr97+63uuG3Tzj6++e/PyPR08ugTtZ/aVB5PyYFIeTMs00yNsfnzLRw4InpMp6y1onemm +xltQbMMnjcylz9MQPeaztyUvIWFtnLjgB+LNut7WGNqnkfAwmsdT0vLnzczxk58yUX735s2L+5ff +3nwnoBtYcTBTLoJpOorvZlN94aLNfNHF8oDJPJ3Zy9XOyPjT4MsmZ2LMmnB5E5OFdItLnXAuFxfW +7S6XambxWSrQ1tWSz3KBhvCuuFnIKH7YmPG1I87rRUT5q8UietGIgjUkuvVQrRoEG8k78vAcyJTo +5SC4GAT9hXfeyWF0PA+Df8MEIjfYCXQ9e87nzvHUeeVz52SH7Ehc90PmJztgHuSQOYj3iU6XFzpb +o3kenOmxJ/ubj5Zjfg/sEXR8RM8U5QeOjl9jS/Y78nSNLdnvyNM1tmS/I0+fvyX3s0vbwhXbshXb +ohXbkhWuXsU0JDi7chVDavNs0b+e07wfgvYati+Ti9y72P0Qve/H1HdnAfxtCJ9qhZwfTv9IHJ8T +5VmnHItYXDprfn5IPG8i3z32HadN+NuFwM+C4JqffrwYCZdY+OSC4T0cfh4Q7yHxISjuktplvKcx +LO4C46ePBcZH1QuWflvzh5Qa2MSWVuaVY1Mgb/AHDJ2ki1rStRBy1K2B/EoUx1vn5TKyAGucTokX +/UHCUJeVxuuh/LI9O6wX92wA+z2bx5b06L1tFjtJ86KkEDmLpK6pS0dpQz8ENTnf1iedrPVfl/ZG +9v1yRIjiQbRRJVcqiiNBWiaqSfIgOnLJ+zWRarKXyE+gclC9GBQoJKSO9HjPjrxg7Jq141NEmXkm +oyVb9SNIPsnqZHmzy5Cc29NzST+ZJOyxs0QqzYO9c8mvmvSqCa8+0XU9tTHr6pOqA10q/7MpBDR9 +Sv2fh4r+sCj9TDP8ghVOG/705Tu+VCVxSecHS/5fbSfVvVR3UzVx1cjlrP9idm6c2NQ1Y1fNXTV4 +1eRVo1fNXjV8yfTdFA7JZW7BS5KacuD4vlqIqPej1MMUhAW0i3LZ1vxSTKO1CytqzSRnlwXLdvi4 +Mlf3cAU0ZgI9WFPiWii/THzGi9IzjvXsmvroh0cOO7mf/XMYHp/TdZzG/4p67p5xkdvxyzgkoV46 +9j8e/B8NkzuN+052/r9cPp7gX09S5kKlmzOl5xOeadSSzh9ap6N2/QnK9ed6u3z6+tN++bRfPu2X +fzX7ZcwgIfzWkWGB+7wt2k64oBP8klOgLu6XX4qJ98sv23XjAqC1Xm0XV3x/63t5uryZpziaQvj1 +lHr2lHr2lHr2lHr2lHr2lHr2lHr2lHr2lHr2lGTylG/0NBWepsLTVPis1DPccz8pqWtBm7h9QVaY +IHhshpEeRsy3Mx77+ozkN/3oFxrp7bKR3pyR7jx2pCKreky6hRnW0dWM6Ea1asJcLkL0XzOLSOtV +g9rruqzljilFd0N5CF+ExRVFnB5fifevV7vkPKUg39lMgu8b5+qHrgE5L+f/0Rr90wO1+B8TgzgP +KoA86OkY26SMs+QMvrbhY57WTxTS0wO+1s8W0dNDuUjnIpozgj5UnCNY9s9JOv6B8hzMhGk463+0 +TJ/z4hxxqHN5Z6k9PbFnVQ4Vy+n5YK3LB8QvcKYs5aIYldwQkHQVT7xS2siSS/twku4XIhx9rqXM +C/tx1zg6dO2kc6Ij2eYn/YjH9QsRfpkoz5f9rQDGyyWf/K1P/tYnf+uTv/XJ3/rkb33ytz75W5/8 +rU+elScn29NUeJoKT1Phy/ytduvGuhlGHUQcwku3JDx4yGgabkUYb8IcTxqNN2H6a9yGo0bTxbNG +yZUtXFy5UH8nh1Yv1Ds5pETo5Krv+6kyljCMvoThMGN0ztiMmR6cMnwQjWeLzpUPzRSZJ5NMlD5N +OPFvvIauz4/t7BjnBsyMCScGzQqdE31GUA4tO+karGacBEGSH3EN4wrOMNwLDLGWzm9n58bMw+T8 +S/tJ1vB4mUq+WOx1LPS6u3yjyiTL/KHbE85Hcbg3wd2iwnVZd9NDl9purrXVcb10yHCQBtOD4gCH ++ePiYGdJniIPpo8IBC8SvFAYxYIIBpwB0wXB4ESDTAUR3bjmAw39iZY1DjwOOV2YcOG+RV9WdBjn +6eIw90U6XpzTR/nBWzImG2p/cY5btO764m3pUR7vXnyUxnzayP7tFRnjJRnLcNvI/mwrgNGf3PA/ +Zj9wO4K7C8PdgzFtsnwv7AzD3jDuDm5/4ImAhycOcuriQ1MBVAZUGHYwCIUUhYWUhAOM/gorJIFi +MINScAChvTr5cYLtY0dTKMBbTjR5KkiKgDv8EebKCvyNdK3GAaZBhYGPQAZeobGDIcowkgvdmLGD +8crAkMXOJDQYkAwDsdCVGPuJbsPIsN4WYDavMxSlyOAFmIuMRbaqBEVm6jWezMEuO4l3k7GO7/Mc +mOZ41jaHF84PLMgZhb8Bu1zdC93P9CGHY9r4l7p3aXAtTY90NH7AzTj6pafPu1Dion+aPIvTB66T +eOAyiQ9fKjp94FbR8RIJd6/oh64VneTiCHEZk3/QO42ruo3l0McdHfYIdMwj0/GOla742NOFHqfT +3UTXcvJVnJmu4FzRd47ea7xdRNwLT1PhaSo8TYWnqeCnwmeVj2rz7TK3z8uikY9+XhmpMt+m2MoX +pA0phk/MG/qscllfGmAul2sblPVD9YjO48Cba2XIL/6BpTV9ZG351bW9w8kvMIsMTy5Ec7ki0cUb +yjYRvL2tvNOkgWEXjhnjwudR4bEy0SYmPFkwr99Es1pMWA8HHz4WrlmGn7S40VjmiP8X+v8m+THa +d42bRFJPC9c8EoW10D26HE/hn1Ypg1ToXC7do7vb1ETaVkU6WV0kqYdElZG0KhJ/7+WQ0iTVkCpd +o7KTWkgaguRqSBKXpovBtR5SlIpIUYohodWDuvtuoljOjuog7ck44vDkLHWQEt2U9FQJ6QqVkAb7 +9NEOCnFPXC6j9Bm3xro6OoepV1Sy3KrtnbHnN8bOZ4WVrLTStLkrtt8U68srDb7PTYmlscjSbjqr +szRWWrrs/5TLXYdyS+JIm5wX1NVc2nrULtVg+lgdpodqMWVfbGDIAvxQTSZXlelyXSaYCdOF4kz9 +qqLL9Zl6haYLNZqmoUyTL9R06QKjxVeKuHCNETzThZJN/jYjmXt/TQWcQGrMa6VqSzWk9SKyhZPv +5tsSJOVtzanN4YEcuuuh/DIlZy0XlRwAP/rCDC75oDbKJQuFEmIeSrzRvAQ1fi6ZQIMR9BCiYpYU +o9smdCGqwZ46q87wsTjfR6N8jw0YfjRk+BCij8Uez1CNywx2Nr5QZplBGaDrgua51A== + + + NqwKShSivFKZdHzFzOV5fDWMf+mFbc/WSLiYfxrisHA+llt5sbTnQ6mVMMbToEWPevR4keOYULlN +qbSEymm4/7fYFXzrUD1ltIfBGuYaOef5X3WTeLo1MLYmxmBkTNusL8cjz6tHJwtOLluwDNzZiSeA +s4fSmC5InXPJkr3c65gyebSUyYeSJqtciLrD6EvPhtvmw11OnBwNrzOWTENKbt1tr4fGNKmFOl+k +yzgJuHMus3l7Q6qmNPPtqIFSuiqdcTnK+RY+3YLJyyeqwpNKmaC7cqIFTKNIZ1ka8OlEnEnAi5XO +rdxBZ8lsh04doSMBqK9A854y9jBdbyU67yZK4izALk7gXHoCJ0zk4/EOZFsEOVeBKXuQgHh3crhL +PHKfpN1/XLmfPqjdb3T7x6j208eyES4nI1Dnrts1zDl+uGsXTJePd2/6eLLFpe7xyH2iZfaxDk6f +apl9rHvTY3JJzru3cfThG3GDBFWllUT1dGoLXEQnB6r2o5rpHKBbtJluLssbC3VfCyNfaNfiQkhA +rQI5gYc4MuzutLeTrnVDTjwuKZoQGzYG/i6xXtyZr4Xwy7bri968baHSUc9dz/TcSMXNUHs898Vv +U79PcZ7MC3+pavmDPkJX9Mz5B73e63VfH0PwcQSvSPtjDV0Hhqk7udCC69LQLZ/V7uMMPtZA8Qbv +oVskDTmaE62K5dBmn2cvJQilLvgidcGTxT7KJOp6tRrge5d+f3Ier0B/k1GcHc2NlvP+k1X+T0nt +q9M1E/u8CeBp9FR6Oj2lnlZP7Z0/VejPFTqqB7o95Z52or5TqFwcadxQuaFzf+EsIF2dfH4UcG8Z +d6u5qewY4OaK7k4zUP2Fp6S/2LqYbyOoQmwftQKLAH8oLY9F3gqelltJaqN1jxENKld2WdhfDeMX +idMYLolTgH7hPZsnJ3fODlVNLqhZpXKkD2iKOP3S0167swM+C+o1Dx3wGcKtjzletKXAh3rL5rwZ +UTCdCTilQangs4nXE24XKj0+Urj9Z+ZMP+bdn/z26ZKQPH//xp+JpiPXZ4dBo9UKZt0yVlHUK5ur +3oX7wXV/PZSfGfzFS49z+JLgr2D4MsFz0e0SxyqLj0r0pTTfR2X5PipZ9AGr7UJ64GMSDs8y5x5C +50Nzj0lOoNSERyWp/CWj8z5NlISJ3OW50U3eyMEwHJoXv/n5D/4Go3a7LsO15lfH/IkLb/7Q2ftP ++fQXLbh0MUKQLgQI9KtXng6W3Mlpntm56oskgnJCaKX4+armQY+i9/rmEjrcFC2/s9g5b6WL3C20 +UBRdPf9xIsMnyiIrstyKxdb5tqFVYutqY3CE/UCLlXdjjbWfJg3fcT/5ZSFI0WD+inJCnJ9MkogD +8XwzEd9NxPv4OomtIv+l73ptUaOLi/QCI97w2QI7yBnj8Tv9brImR/dvf04XnjvyfgyBShw3r9XE +QZc7DrqcmsZHq/sdpcur9IHVJVKWpo+YxXqR15E8jw+UT3C5aGmydJltIlokn6SmyWzr68SH6utM +loCWL1bYYWf0heyzB3LPdpO44u/kKHLQ5DPJPTtIjfLua/9I9tl0JkM1AU0lqcpSlaYsT1mi7shk +O5BcPfoxVt012fnh1QJrzdJZjpa4sgx6dLZ8lTbJYjJVVtaKKvmanKK3dO2cVn2SrBR/bD5rvtVK +rjudON0I+HBeo/pWdCrB3+lCEtY2w3HMwdrW5NCJJblXE6Ve9dxGnlfo+j+R/zvQhMLptKOpxBMp +yETiexOOFL8INH3qJM77ftIZq13oSeci55zvSCqhT5yPOd+hPxxGu8EIH7Xg/N/Oifd/d4TLAw9N +4El2N3VxqaMrne1v4752aUM76KUc4362uD3Mx695gfnNaxWTkc3GnRpBd5urBMabAXxuy5jVMmaz +SEGrachgGfJWNvkq/gaxMT1lSEuZhnyU8bawMf1kSDsZ0k2GLJNpTC+h1Cb2GI0JTmzIaZqTJjpF +2RSXnu40ScbTnSTcHF3eE7uZ9GI5Tn5il9OYAqXHQCkRahpyoTQfatFZICNzcnlRR3lLPxwqB0Sf +Dib/7R9MvlouyWVnxjjKnz3Ok8vn/PKRhrGeHldR7gNjvRnt6bNihx8Y7+nR0cOPjvjGkl3rvGAw +rDXYTAJdqwE7QVzJtSMOnVlyaBaM6D2YlfOlmP7qsnEuF/bEup5mpTpPie3yuoX3QjnFqbo7szdP +dLXRbHsx78SWmD1tcrIlG5tUBM3CTmQJ6ZW0lW5DWsW225l5JkbYZNnYkTRf0n1prrHqy7XEdhSk +P5LldCIVfyb7CRVgVIET3ZBTsCjPREkcqAvvaH4fpcoYn0jA/gd5ElXtQaUY1WJUjFdaLVxeStVj +ujd5Ji2ZK01xnSk8sZDp6C8XmvKlpg5cjczqkS1yhoHTbPJEmTbrkGfDmTa47M/zbCjTZjRMo7na +eezUOF1ozD58kir3KkfTxTNUKyXG7C4FHLanp+SMRxRO1sns1QOyzlkW3rY4PHB2Sg9ODXdMJ8qq +Ga3Wo90trWYrsvIjZWE5d2oazk15y1VvZzsOp6YCZXYXytA5TxID03UaLNdVLtK67P5j4/Xj12U9 +7uKsB6/Tmj5yp9bFO7Y+9Jzfv/Whe7cecRvXdKF07WOK2T74TA9Wu/3YUy8/00O/eKBaLj2jRaKs +1d4rfYpCrQ41NxaLHauZYYnwn3i19MOXS6OtMD3mcunHXy99yNOF66WvcMH0Z14xLYcdfAGRu+lC +cQlfXmJbYIJKTDzZHn9LtscDGRIZOBAx0NEwRDaW9i2pUtpBVkUSS/2m+oAqej2Uf3U6abkYOQHo +xVrzpNDwhr4zd+HlQ9CSD3xhM1cP9JFSxR95BFrvzKzDZu5zvukU9OQc0d0VTRu6bOmLuw0zi1da +tnbzTPPh6BMK84l9XZz62avPdre8JlNrbjlzZzzAureM6jt/kJXrHiVa04VWd6N1vqMVf9hkl0fK +REbpUCgfeXN7LcrbiZKpxSUrKdXslz1IVn1nZSW9aMcVKcVTy75a9Nbu+RbRiR22/2u7ZHkz+ViF +/Q/f9Xt+ge+F43Yfrrx/4Sief6YH9cqHvo4PPOJLlFN81PtPOdv6mH3n01LEH7HrTNfLn5aDrVIz +iNb9SocremWpcKGa2MGVlqrSnfPSUtStiYws7Bnvqdw/qzBFfeRe9hpj22tlubtyseyEfd5UnPJ3 +y3Lvh7pTwoOTRF0318tOHAh+cOPFkkuY/txSXdvlXRIL/WM6QuLK/x/c674Q4bjpNuglZRqueGpF +EiF4x266c+PNqpQ0wVcAfEQr+FKMX7RB10v7c/3SFMan+wOe7g94uj/g6f6Ap/sDnu4P+GzF+D8W +4dP9AU/3Bzw5xZ6Kxj9Nhaep8DQV/v3va318EcPxnPcnfeyvzl/eLp4pbJszhSdj9N6K7O0ku3Ld +lJcu9tOlUtP07zRkd36ujnVBEwxy9BldBuQwkEJJaASwmqQ58qwgNcoCOZKmT+rRJCcc2TWAll6W +WhycFX9yx8QrJWnsLXPZ8paJMlNdo1V58dVd1NuvmeezBPHV869Z6Oz+r3gUkO3iHcVPDxLWP0lo +f7ZYQI8GaKC/SNrnx4P9Hwnmfyxufx6bf0yMfhNqZ/n9mXL6gpgmIT19ec3EHZsem0r5oxMzm/xT +Cagy8DD4L4sJwjgN7svjWRqbykSVittLFEg2PuDXhBm8ZjoTtSwtD4XZGh9RtDtC4VcE+pjr8ItR +soDMZR7vLoUPhFa8kMOTXFgiDn7AmhShXBaXX4rpy4TnxfoWbaxvYQVBVeCwi+FOj+Q4X5P3M40H +KjZlorcepksloke35AMlotFXMJlPaeubNE/SKDculIraVqTlcN7uQi3aRcKjvX5Wmaw81M75EcdY +aXKndjhiuqMsEIuaihQl+TlRGkmm2B+nQjVLhpL46dijL5Iwlw5FX5Axj5AwD6uB08f1QL3veb9J +/B9Llm6Lll5K1DltM/zHwqXrJq8/DUk727SdTfnSyeXwt8PFAqYco9rTrNRrjHq0ahuvYjX24ctQ +JGY1adBquBGl34nCCu42bnUpcsUKr9Q5QrnvJT/rvhK92mQax3kZQkGglITxKLlGX5oWoUxrAPFw +UfJdBx0XH0IFbZDla1026SLQQRDnN+6Ue8DA1UMbxvVQfkhAA+DrX7598+t3r968f/Xmu2fPnNz2 +v5h++T3+JvJvfv3i/fuX796AQP/q//nxxbuXP9zs3nz3+uW3IMs3gJtluU2prvJvvCnlFiN68m+E +rv6I3TVb4Pd/pv/+3/Dj/wDgv92km1/c/Mt/n2++JfjvfwP/bHHeO5jgvXkOsM27Bph+9vkFfAh7 +Q6/7FQ0FWE6gX1AOeq3E5jSvsOPgdlgLbYszzwus4CoVqyLnAv3+Bb4AXop1XfMtGJqJ6RUQ/0uv +pN+2CxD52PNzTAj6V/gbVixgCVvmCipDrfQGhcV2u7Q1DB+/BNPPPr+AT99DnwNOZegoSFF6j8LK +chsb2Hn+85dg+tnnF/Dpe5Qm/bznWA23qdVFGNTmuV0C+Tdvselb6GOl+GFRkBsE/tQFiBuDDSZ9 +AXWrJv3svQN5zioXLsH8bBix6UuIGpglOqb3DsYfacPHL8H8fNjiG7i1GROF+QHQz1+C+RHY4tP3 +gKALsC3gMstzhe0aY+gRBBvL6oT0YvUgyQKQgmsgvfkHWnDzzW+4+kiA5cmF5GoaSyB0sYpKNyvk +sC/S8ZMVV/PN73dc8/jm3/xM7XPl0rBdWkwX1uwGG4L+wFK/Zi5M28krYRmqJCUuQ4teFCITesnm +AvV8O7/uHxj5YTVuYJ74S/OVSYVdfqHadyFi+OMib2U7chYNSEegn2kdZqlIk0uzR7l1CeYlxxZf +p7WCsh9pf6wLTy1olwsxumGcEwW2JmxkNnGokgbuqoMId0v5kjDFQlcbmSsgt2ovyP4/XGnib4Wx +n6cVhjAJW0yYXoD5BXlJuF91+GkTBdnZB38QtRfEoILkc8/PMF1z2Df7gd8i/BhfkqMXxPWF3YUJ +TQmsyLEWWsprG7VTLYG5Klcl74kJxYF0FNw7GK+LdC6JNzBP/Raf0rrVKrym4XGK6nIB5DFe0lHw +Lb+bTqxugn4qyuZn6asr/2b/7scf/qh4zN0Q5p9O880O/v7+36Yf4Rm00Ms6KGmgzxLo5rf5BiR1 +wsqfC3DhGaiE6y1G8h34+QgO5RYvJiSwYrgE6x9/M6EOihN5XmjsKx4Lw0kKFtlKwr8WMBPoQCTu +XgixAvyLzmOHGg2LHIjg0GA6rjkhON7OAT4DwDXfgu0nZERY8gCr8bbOc3WkfYOfL0gPTEACY8Ol +wYdb8w3/DA3B0AKcQHZvuNRtwz9hwzkDxpD8y2F54s5cBio9r6VHh2loi/sV4L0ZkCKzG6jpAwE6 +At+MlAI4F+jc0Ctt++ex+72tY5W2xY45rnYaHP87tduBOkz/Ov1uajc/+enN7/8Jfg== + + + okkNq2CY0h+b6QS9AfBNGKb8oyf8CurT7bqCZrKGuWB5Xprz67xGFBPNgZ9vwOG21LwS2CN5AGxI +rjXzCXspIEEBe4KNICeifIHJRZCYQL3iZmldEgMz7Kg3I2XQcl0rTjMGR+4eogQznYFohjMQrxS9 +ufhyHFDkELQpSkNKSxJ+5lt0ViMYfpphh0Jg4UnJbWMsBKy3eFyagW2BtXAgBDCT0CfA4BwWbRuT +vCzP4YYbLrhvE6zMQDh/vsGOOK9MwEITdZ3bcgu8D9x2ZYbNMHszNFDepJUR4KSOSYgNpRSeEQAG +auvAHdiDYUGvwt5cQxRgXBYlFlNnGS+CozIstixtQ5gFa5qLIghrUZ6jcmsIcrUBzkHawsYbFcGq +QDD5lYI1yefTLUbipCmaDALsTIA5L8AF3QJMwDwHQwCrX7gISlcVzuC8KU04Dv8lFPk2hVlmWAqZ +OV6AAu1YzVk7BmDsOo9ki4qgpazAlLICmxLWOwaLzmZ+q4H7sN6Gpcg8AlHLSGFyBJ0cILDk8w1m +dhFaWxIeNlQM5f0VJ758XiYXrovVPo8ZUzplF/18afx5eFUIWYANGc/Aui68HGda8IKgrhXnPAJT +45HJsMjjKsA1lSq8XkMxBDAjdQiWxlJsmRd4SZTXpSAoFlQ/o/aWuI3ANGehNsKCFbwL7guymud1 +7njLOgsVVHaPgZj5JQwvlYHhFuP12uESBC+AU5K+LbB4BW+AjiahN+S2CoqEY8IocqwCLDHqKg/R +0JbxbYwWViluU51pDIwmAklmCxBUbSGApR2DYTMQcudlLUJCm3WAl7wGQbCkPpJJ+4vSQQcCZAO3 +hWmfctPJKL2tIMWjdiEXHQjY7VPRKRZqlbYVy7gzx1G4C3CtusaKQ9CiCpo1MgEr9HaVpliyU4Cg +ueub2qw9ADB0WcCrzJr1FhgXzxCgsSRAUF4MAZHIS2cl8YdAUHcWnQeBB6GxzOncZgQNR1EHjDcR +AiZduitstTfWUiio8F9DEKNtOAXADCy5VmWsAcnfyhQYCwA6B1s4MuANuansWpSoNemmuy46i5aZ +pzpjbTyLANjlJIlEBpa2KrNxM1IEGejStjy5F1jjyXabQHIKW4IpWISvsdDMWHATDCr8MCx7UAT6 +qkTbJYFy0MlSDdZlt25KCI6t6EqOLGIA2Pp6YdkHrwb2r83RxAgCepp1cS6stiAw6HrBeM3NP0tb +tIN1pxG8sORCsgm7CgwEsq43lDT8rohamK64Yp/PyAy/+yCw76C1LNUQtDnqmscTNAiEj4Vgigyp +PAiMtcqrwBiQzwOyqASAqs3vgh9b2LIww2Cu0YlCRgDIStMFg4KegaSy83DNpQgwzcP+pQhKWKW3 +OTXRYPF1LQsKMnjlZWijiIa1GN5qGsuiiwPxLjplZb8Hlcu0aFOPELjA/FH1yFhbQO6oookZytK2 +zsnkg7C2wpDqlAu2vNEnEVeddKUkaYsndJQ1rCkjgqCaGIbdBQFIzmS7Wlpl9wAwyC0Fl6woVFdG +4V+iAJvtMwF9HYq31SSLMWLteASCmlt02mM5ZAGCNFx1Xw3K2xUrC2VHGANrUtZkGTCQsfOq29dS +V/s8LGLlTC36+b61LykoVTXaBtrHpqEU1HUDzL8RIOztimBWYFirAUs2BH2KixuWwakutatjDFvD +Eh0TGViCDnnCzVrR5nnJm6GBtlVVAxjmJMAE248qU8tqCMqiciKLbgHAFhcBFliQCAxYAFx3Kkyw +YAQBz8zPSRGwTA9kyBUli/eUgDE2VXlIj1cEKTVhgai5CFyjqnNVuhCW25CU3yvqm4wAwJl5AKst +8LoBIBgs0t0cWUwgMAZ9VdR1A2DMZBPC1sZdCG6vEJUagTmpTAPbVUYBwKnqZpNXlsDYVsy4bNog +AhddCXhDlSEgRYW7i45vAaINzFiBRwIEsawUgIA1BC1mnQeij4ZoSjX6LnIWYGgpKWdVOQFwXHXh +EesFGHWFFFHwEGvTFVKSKuAAhp8FAXUGgckJa7JbGNhVHtghRPggWJQLoID1u5DRAb3w0C7RgLEG +BQblQHYbpoRkGJyiSg7axhhYkxohjUUiwop+vgZDW8xk1B7BpqVSa2WxF3BJ6wSqpi4F1LVVCaC5 +wMDcmlA/F5nuuNfpMq4mN5Emk7FGPHxsKYpAVHEAhqya9IpGrFK/rCo1xOonBFl7n0S5IQQ22Uw1 +QlfXooNic7DA8i06A1Q8FNPPM2u3imANKpArqt3PFRx5caDpy0pfwG2tei4wcJYVU7omilCUNX0d +MTCDRSMTQ2wMAFLEiZGmshiCZApuUq8XgmmbZ3CVWVx5UMdhqE5Kryg0FC/xWVa98AY3UJva7GIg +YE3WW92qEIy2OnWCBC4CwZRPfXLOVYC64mQmMYLVbCKc3CIKYPtJTWWkWFoATLbialUVLTRnQ7Z5 +VQR4eaa+rBLD48wmS5eRhCDSpZxKQWRq42yOIltzCFt0Jq5BjVj8fNMtpaCsYWCwhYcONQFSTEsG +QQU6gos6OdaF1xgAa45edjOQPGyyUenCi+ghaLor4tIW4JJ0FCPPWQRGbdmwar8iiMW2Vd7XAaYu +RxjZkrkHgWr7u12CPx9A7OjnVaEFBDXrjkJDxMCG+768abHP42lF0ULETgBgCgpci1AFu4y42hBp +ioYAc8iclHkuYLBAdffgrTbCjhKjztjIrtSIu4T6BugjjBZdgLqjNNmnANh1G9JGGZjF2C0Y6pPl +EdH1mMpIAKpOQSZ3YEcVAtVc9xslgpt1t1VFUE2HKWIsAhBz53QS6TYVUVRHpQt9m4K1qDTBjFKj +QPVTFOaOgsUmPTsiEOtcVdsQIxyBi9KKJ00NQZ11zqrTI6J8N4Eocge7UFVrzUU1rgiEr6pcxSTU +Fo7jsfCsSxOgejJwH1R1HMFztGWXFQFMKaVAHBEAJEtZpkFUHoD4brKrsqx4LuAkemdhrwYDw6ou +sSqeegSaOk1bp+JNZmhk2Vxj5YEWDZU1uVjphho35xgB+t5Nnw4a3ojVtiu38lbn2ctiVAAwRFWD +itn4522fK9hmM/mTGRibik/xciMwzxpVyGjbKd6ueerGgDQUNSqquLrwVeZwpC1ZEYSozGkUr2MK +bL9qYpoRBbYgU/88Hp0dNdeIVpjq2ar6ArC7lFYzQDBuvKhDoa6sqCMwJtvaZMwBuEZVfLLtNs3Z +hk3sbgCmnLSthIIi+r5TPZuMsDeW1a9TwdrUHdxEEUCgaQckQA3BMrfNDJV4uMjlZmQFFdbdLwfg +3NSnrePVTCGHJSJOGQDW2XQ/tGr088U2kVZXJaDYLkx7o7wpqkJuqnfs7joSejI5AWpqHskZA/c9 +14hdTc93LOxuA5qG+jIicRCgCVNsgjftGKiewcKuHkKQMMcqiZRQuz3NzhnQcEYycG1z0cmtOmmi +lCyb3q1xx1L3I/aZCMCAfGLCeHkALIUmeuYc1LFEYN1eacooWg2yAZi1hrR4HU3sIgCqkwLtGiUW +FYRZO8aiFlq2rBsDCUduGIJZG6YOJoxQq9xh/xOA1F3XTVsAqgkiyrN+vJmDwvgazUVf2IHOQErb +3GhCCBb9BJilFAAw6Ppe0BuHwGQ6feH4IiNAD7Zxu7FzMInSTsAkTtuULQqGpoJq1Alnug62sBr7 +os6QqgwUZoiQX5UDaHnOtoWx5ovAojZs4oAXAsOingxbXAg1D56NdW+KnWJ1OOGaNvulqjIK4BRW +me/AbO5rNXV6AHZzuetMACbbWRhbsrYNQYBBxrVy5IvH1WJg2NT2yiYGIwBzXWzjaIq0NnPFmIhO +lbV7e9dzgbqZwSlsCIYtOHfdoDG/EahWc5JVAFtXrYq12OoG8KpNVXACMM4mTRfeqxGYFr/LKIJc +muKVPTWtJkqKho6X1BxjKTDMCDDMYsZtEtMSoEnCuW4hNEoKU87I5Gjms9igVd0b+iBGRZ5tdhbz +x2PeWjEvE+pnhCBjWXZVr9Twz8FicIWd0Qx0vcWVwggALFYNEhYi9yxH9LXpiImfCdo2kxG5sozI +GBxcFG/V0BwiKGpcRnE+ZTQVkgqkGhQIOqVqiOoNACg5GUW1YIU2YwQk6QSXuBIAK1pevQeKQNXU +wg46QSBencLmIANJqxPBozYzgkXTdlxMFq8DCthWAVjvgMbvEUrOauF304/TKI8dSOZuFY+YIugr +lzas5wLW8GRfpNhZ8xUV0fSR1kVd/91zj69rGoyVLGN5XbHwnMg0xKsxIIkm48eLxlpWdPwfHv44 +pnSoGpY41EINZzNuU6eK4jncA9Y2qKsmz8SIzInzYRm4qFcrZ9tTi3rdM+ZY6NS06ZbwwIh5MmKn +v5lTsejMyJaN0x17GUNfSmnfFImAasYti39sO0ddXWJV5exkQTIVJqOepvptnA2BTkGNFGG7ZdGl +GXVHeOjjeARMXiUR9pwt/lT8CKANoUJale6M+9e6OFoZGBYli1ynjKBY0LNY4AKxriZIxIGHCBwL +l45gqU13RYmWAbDU2QSJfh6UFSWgz4FiShAaruzdRWBf3WINATBHVbqD7esZu6MCbhF/Uq4WEiq3 +8vHKeSN9YvLHydmpEkPzPwCqNOkSQEtXN3qNnQEwOidhM5SaY1E08wyBTWZ1lpAggpIKlqXonFg7 +OvqvudYKO/wZGJLOBho1fXFrqncUid+6F6uzK3s9oPtkho/HqG8CgSgjoR4VpCnobO6RAwQnlfQo +Dp4LtGvpGv3ImJqRpVdqyCPQ3tWDMgheNKexil8LgUnZoqJntaA8ynRNDMhoBaudsvbdEpSGpGNn +MnnlfVpGnv1i0BJmqALRZlK8rRTdF5rqTdCaEg2Ei7JdNE40GPQexGu73WKuegCDsNUlObMLKWOA +0vpbjDBKr5SeqYIC4CqpfIXtKgaWpW94WWDqHyguWoFozQDIyXWsWybqk6d3xY2Wl9G0LAZsQleZ +nZqmOQcAjKsOuoS2qGGUgSz+86Fov6q45AGYom4talkhUnPxJrVgyuwmnQbnEGlTJZEiJwzMJhT6 +BEcENmXUP1lmpz5LSulSFo7Fc1dD6RQ4m71oYB9az8WM25JkhhafYqeqG2LGxDHe85TehTO0VvYk +6vaCbat6yoM4hfAcgWXoRU5HRGCKlnFgUxzxrup6aCUoAhxiGV2R2ACsJrrMZivBfEJuxIJTccjb +ykD1qw1TprvKC6uhDCxZBULJcxKgBsOAgKBmO7a1ISOfpLws6ypvsukVzKJTq7W7SQiBSSpJPSmg +/lYdXl3j0JIiBKsZFopgjYvuO4t1t3QvryQCIlnJHA8W0cW2JW3cBNh2UT+z+s/xVebVJyAjiM6Z +qgktAOzp0ZXtToQt6hZrfRYAeDbtLS7K7xaLuVPY8sY3ZbWcUQTp59Nin28cvCw+k1HDYwW1etMb +LFoBYE3/KRxdFmDSTUzSTgimYrbH8hDtohstOeWfCzgXldR0kkDBmhpb2MMlKCSGzA== + + + /E8WW5NEe35TsrRc3JYUI+Yu6waidhVibGqHsopS0CpSzS9YziZ8XHmiOzi+PjSntci7V93+yGdp +JAXVBjVFHykSx1fhXERB2szQWVvvUzBngoltfFk1Jw3H30vi8CWvAM03R7A6dIrlpxbJ0xxXQHJr +paemlMwdH3blks09L7s9A0tVphbzniF46TsPR6YKKl3Gw1WRrkXHL5iWXDKfTxllfHbBkyQeLeyr +LAuM7mi2HLVVl3cR1w+0BT3fHKgdaAGGHhApYrcxOKzZ2KXxH1GzEbY2aeikEObKWhK45BeVbCpx +T2or2XZpOTehPVBFsKd+IYKewiDuPwQmTWFwUigz5xgcZx2vniem2SqlOA2KkhIYAU4ei96vIrIK +p2rKdjjryLRsdqGlSBUcpqaESeIvVjGw6KBNZNDrszK272bVbdNkATHQ+eyr7CXV7TrdAwpgjUQW +Tj5jYFhsi1sXRdBdYtlcYohg1XmoISlsKzla3V5FYDNXDookRdCjuVmSVpDatW1FeXVecBLaRkFW +39VS9PPqbewpAQhcNMxPoV7+/MpR7NU7PUq1tNGejIotbSEEy4oo6EHMNg9l4+uWg6Uglmb5ORIr +5M+jU08nQZQIR515rQ5KFQBT0UyJ7oeus4tHa8McdRUs/dM1ab7LrFtpRdef5SOLwwE/X3QZqg2O +LW25RNPNq9cgSUDxua/F6VRxYQEHQKDa8pF5eQOwNItFq+cOm9aqadp2bAMbWybQvCrWnrqsAWoE +Fu0X+RkUbU+cmkVGA3DNmvTaRCXDlkmzv9emuk/F/G3N8S0SoKgYYdGzN5SUzkANOUv6OCMIdtZJ +qH0u4J55RkedERg5bZHbsk0JsJRMhTZpiOCo58jIn/RcwH0ekuPEwJaSLCeAELgmy6GXbCYAwuhq +15JO2ooJgMqyaEl1AF6ynkzK4tkEYLaTYCJRkdxFD22sesCM0FrulKbj1uCcappiC0DQ4xXBvHQE +Kqlx669xw8Z+FgNJlayExKdVFIHmx+BmyBIRKZCoEGZ7C7sw40UP2ZFVrOOrCZdJXTVIgGxAiZ3L +AiyLNWytf95Ok1DwQmZHrkJAwFw1BmrcPTn/UcXjl5rdTiqrTMZFU8jJ+6EzVM8p2mk8AmcFu5f1 +M2N6HAUXw6zD7SjAM1D6Ms2rAKCeL0t8XEJkigyBnVSChstckptaDIQRFJqKJPejjFj0LEbPWMW2 +dkaQbFoBFl23lMUpQkriathyiV0mhqjDLTswyrlkxwBSF5RZzw0G85iR/E3BDe1zAQdJ5k1dJnqg +zm7YE5qkAySvMzXbhJNJurJabv4ApC2SgV3lwciYLkUytZ/rHii5rLGbn7ix6tkN9aMCcDHBQaE5 +VWQcH1Iw1VXU/8gCloG5KW8pi1G1wdz0uJQm+KD1sRiC1m3tWlalVSNQaGlmlX8BCzg9N1NVV6Ph +DTxbeHhUee4Z3IlzvRVvX3kaWwNg567sQuhZkF1YTsKow0Ld5MnCcOgGkVgNdEw1rNl0jsh6m7l4 +JBMoYqZlM1cMHU4msCSRoOurskCImoCBLj1JDRQeqkct2Ms0MQR9grMeT6PwzDN2KmaVk/3YArlG +o+KVPFsAwmqXeaRZxeiwXYr2yxKf0OUrXp9orit0X8s5NBz7qv5iyqUQrBa0zKZ4RLYzn3FcJuWi +TGwW8BP3d+TEVgsOiu4aWVNnr2KwjJPIIdRnHCGVtKHIE/gZxV2bBBAiWTsaTJ1Fc4ns3NAor5qi +0XIsMSC8pqhMCIoWhK6iNd8ZxpSz8pFCr88o+twnjWp6GKeedYkkC4wAWDOXMALKGzECxQUZNRSJ +UflShF9drFMSQRBwbJJeU03PkzPYzyQxIUhfKQdB8xX0XE3kuOVzAVPXpb8Sw0fgKnjVLkgSYWeg +xZwwZ0KUushew2eUtNHXTZGFi5kcckgt9gBHkgOt/HmxJFMyN27oaQwwdHIIVvJVNZWFViajlYgC +AGtQAhZxkAOwyEFH2P7rHA3BMisCDRFS4k2LOr0kQSiYYRA5CYIRBLNN0BPIEtwl/owI5mSzS+Uc +5RjprKcgwINYMVtZR5Gy3hjBbIfSg0l7APaNRWcHZcXpuguWalYtdBtNP4iSvyE85Fw7VBh1HZjW +EPshEakb8FzASU5eB0sAiNH8xZHLIzAwpSIIehZjNFM22gHE2Esb0PFpgdFo8PvNOMQk6qTLY5aT +HpjDXXUWUQTjGaVrU0EjmUMqZxHcdHEsmkC8WFpf5N1dgLVWXbXG156HHjk16hllt6sHt89NTLqX +tIbIhigjmEHu6JqhyB8DQT8RoIaEEWhDmC39DfFmxVsXOb3R7AxT5DxPBpaoG77lQAQ8yrYalF2D +CEx9GssBoGahWwCaPhdWO3Aa+1mVyscdmF2SYIPnajpVtleF5JZ9smNBehAZc9Z4p8GjSkUnUbYi +BiHZeXhc/7yxIjAE7YHoue4IVHROioC2ZtO2snkAUI8IghYi0ygkNwb9bCuet5JgROynk5Jl/sZ+ +XAfVFBW8FOlmBNGyuqKGN/FkV9YdWLO9Q7QiJfHWztgjVCIJoi7wqZoeNIgcdXtGp+7UAoqm6wNQ +E+ndqseTmlVXB6WhP+MzvxIYF+XtGZ2P1ghgcCex8OC5nIMCsEQCsNCA5BAGi+DN/Shz4EMehAAH +X2oCRDtSSRqg8jCEpFUV9HBv5BPWiiDMJuLYLqHt0aZhsqoMQVJ8o9OcaQE3KccjeahY7KHp1FKT +AIGSURbcwQusY1F5sw8Wm51nyw4JmrKPFTr0FFXoieIIVg036AEDAorT15QoQrCaMNW9i2qEiCkf +2BnxXMGJDcbA8Q8Fh1nHQWp0IHDOSm/lpEcEavQgdIUaS6JQihuBRY3BsjBrSLovsz5NpXEkdyv0 +YxZzmy0qFtlU5do66pgK6orFOjwUoxTeyqaCNX/URRA1cwOrA8HEE+ZUrQ7Uay2JjGAE0SKmZqFf +qDr0j1SOCOsUBec8CEGKJCVWVbj9XNQp0ZKeQCf5Iy2jFoLoiTIILoua+cUqJYU1iIGoK/qcAq6U +hOZkK5YZjUL0XsHZToxIhjr5fy05WUhDYNbEmLkHWStjY7C6pbv/tidyIbBoMuFsKRqln1cv5ogq +lI6iWeNNreRND7RrxcwIpIxKGQu4ajjGiCguPyJIgjnGAYLmHMTZIvZneJ/LC5NjBXkm7wVcLZ23 +Zg3J1KypQ3SC6ZkEikJRoO4cJZleV+wMFsV0NHyleW7nBByMMjXKilYDZbBqMZYFiX4AS+eNlXfK +kria7MrJRerL5cCUhhk0iJmsxkuhU28X36+EwaayakIvjcC9ghclrM6aYxCSRkwtuLdYFiNFTNXi +75FMy8lY+KjHyrk9SVMUNq8XuoZ0lcxEIQysHIHNZvG32YCiNGMSTe4ZyapDoHfAklWyZig1PlTB +xKrJ30/5Y4KUur43VMm0o7OD6mEmGXcv4NzsKAUqHHpMsJdWIA/B88tIBHuYrbBXZh3qXsAq2vs5 +TqxDYDlokryJsOXCUdiZtShZ9aJS+kOrGs47J0DGaInuXB0p5vcKblY7AsZYyjmIn2dlf7f2+xzJ +c6oJ+GWVABF8Uz6/GqBIfwwiUOG6iEk3c3Hg5wMYuslulef6+XOI++gboocKAFbUX7B0K8pErNMc +VkrGxZHE62DwhzYvdGPJAhOHyrtGvq+EKwCCXlfw9/BKya++F72uLYHAWAaJdJpVDnktLdiYU5ga +xT8WgiR7/BtRMtbEduusawV1BFBcraxIEBVBY2+gg5esKk2wUJ/4MLVQXqxNuCG7CpWpS+ovkjos +pKSIyFtY/ipd88yyZbbM7xlfhroLWIK9fBRFgRoC5ZjMN8SXBY+/EV8wY3PVMj9ck2hZowXClyiH +npYVtUkrJYMBjHY26EuWWnnYWsOIC+ohuIMhXtQ0by4O2DeyoPBUGK5JpDhhesa9gOPaggM/34Aj +WzFCM04ovPUTazOq3rzmtTkgsxLYgleX+baosMVIU7pj9UChQLU4eOG6IcyDA1dMkzJ+TQkDeZTP +CCOgDhFsnmls65hjWC9wTApQ4uvCKownHxKt44Y1yVDVX1YK1fLsQQcDAzEJV2rIYQnBQjRg+bwk +lKFnk4auySkgGXkpWxHsHBgWjlottmXZ7Qt6tKo6JoPVukF/ZhGNXI+fYJ0uGZ9q2yhFIvKqvIkL +EzZjcAc3fZzVwAxeQjDBc0zcW+IoV0mslGSGnAEJI3MhyrKi2bvKcl/QLRl5poOc0/XODilsSYOj +JgHXxKK26Nzi9b5gtLAxmPL6pVZlWGUFgcQpNxdHDFfFj9Nys/tehm6OVeYgWYT3GzBGYFq50UqK +RAwOeC/Jl6hahgGZc0lqtA1t8Wx2zANWDxQKGEEHL+zvHLCuqHSkDQUKVJEm1Pa2vl+G9QIPkEd/ +9/Xf7969P7765v2rt29evPvzzc8A9JP/9tObv//q/btXb767+clXf3zx/cv965dUbvqPv/3z9y9/ +evN/YKP9g41+fuQm/yf8xW30+4lK0qIzFesPgaJF1dFBP6VqtQsFlV298aD1vBNvU0g76NaVBQsZ +s/cbsCWvzLPJimqOJWBeKCrjCajDx7kjQ1sqD1JGpB0m79fRUzDOW5EIHenMZ/VGAgTICDqx1tb3 +yrBe4ACOHh3OLVTgF36YqY482DSBaqAvMYPujnzFDZ/VgxLousnEddKNuZxMh6hJqbzfgKWKCRPM +mzhyjA7jcedgs6oOqNydE0tB1xYTuMK6wdqBQgEj6ODFUkod1pmPJ4wUCFDZq9RaW98vw3qBB8Le +gLc2YWll0GL1Rgm+8Qas3UhcjXrVUKQcdCyuSlfTGXdB7xXMVHTlfgPGskvmN+JysTj1qm0wreTY +Yd+I2wo0vnVsKRURR5QdKK9X1io4cAW2EenMnuTx/QJU1iqp1tZ3yrBeYICwdsYC1ni7wIpXBdF1 +CTnSLSNgfVTSXqPd6IB3IyAkO+2VXVRV5k0W28lDJUmS6QUTV1e11lSV9dWBytxQ5rhpi8s6LBus +HcgEdLHC0MAxgRHpzIe0RwIEqMxVYq2t75ZhPecA8xaszrZUui1jDnQTBijdLdItL6DXk0GAkdMl +0V0JKfMdX2gidNaCZSWII55Zvd+AkwVysZ5wIVWhSTkU7lopvGMKkLuGTk6d99YW11yIG6wdKBTo +4Cg48CGbEeuC5xG3FAhQmavUWlvfL8N6gQfCXcwbQgkbG6lbaFw1TOugKykiXU2W/B1kheWucRav +RmSsAXPk7jdgqYzNtHK1UZp0kmeAKqcYLAJUzqYal03bKDX8BqwdKBTYtBdwYC/kiHXh+mUjBQJU +ziq11tb3y7Be4IFwdqGjfyRbYqUC9qDzrHW45Ienqbv1o9rNKbKlltoYNd4gzHbQANbCT+inT6tY +eVFq481YYkoNEwIqe8Vc920xP0YNHsPqgUSBIlBwuI0WaVCkS4+fdAIEqNxVYl3b3g== + + + rY70jAPM3Lyule5fW/ISSDrMoJ2OvA0iCyp6DeiOJbtBR+RS1rc1rczvwdES52dUSRYR+1rAZpYV +14FqgJS15k1bDPPO6wZrBwoFNjgG1uQOhzVonNkRwDBlrdLaW/q+GsozBiBrF9ZwcwqsK5zf9tMZ +rDcT9au12C9jDC5J8de2GH8ViqHzWelbxfUSb+UQC1ZlLx5m5p3YGL4lX+kwoOxAfrt+vEM1TuFw +9nnX384w5a3S6Wdo76ah3Pb9C82T3ePMk9+Jc29R5x788+1U5FaRH6/mbBtciM8opAuKusgeMh3v +N+DSo7d41IL12NUSYK0qowGJ35YE4Nti2bxYNlgdMDmb1oEDZ1+OWPG+kbqlQIBMQafWte39cljP +eECS6ssNRipKmJg0SUe834AD5/pTAUe29jGZtlltyzmuDqgd47z+oS06LlPzKDtE3s2f7uDCaaQj +ynqLfozN6wWoI6uk9rauRx3ree+vZSxyOsssnaOo5P0GHNB3pdU1AYdsZFrwBToHL20OqLwta142 +bZOclR+wdqBQoOxVcC+45rBWOzDrKBAgI+jU9rauX66M2xkPrmQsUlpONh+NBSEdGJWIoNxNlAaF +HAMdTafOkqIHKnfRnbZpi6HNljdYO1AoUO4quBfudFiLVXtyFAhQuavUura9Xw7rGQ+uZS8iEeRi +XdmJInPXQeUUCQO7y7mGrNzluqoGVO62qHPX2mY5nzBg7UAmQD+v0F6Y3CEtdpGSI0CAylwl1rXt +3XJYtxy4kr3ISWKLasJYmvB+Aw6cIvJM6v6qYdaqLNUi90kZkLtGFaSWTVs8KhqXDdYOFAqUuQpO +VnPRYc2W4+QoECAj6NS6tr1fDusZD65gL9L76ypDVqNmQjhw4KxcBsZFgbR9cr/Eaa9A5ewistG1 +xcOoCjSsHSgUKGcVjHcwzFquWrFmO/3iKBCgclapdW17vxzWMx5czV5EeUUpbOSewvz9+w04cC4L +96NFnXdJDoxige6gUzxZtAeLeS/zeds51+UMqwKFApv5AoZdRk4IO6x4ZidsKRCgIlBqXdveL4f1 +jAfXshjx+r+mThyqMXJ/BtYbNRCYqpofvW+wUVYH1L6lqMPj2vagpsPagUSBDY+BLfmyY01dCekU +JK+wdGqHtr1fDuuGB9c1GnGnaE1Gjw4A3J+BXYn5xXwTOLbCiqKGdlV3BV3cOC/bljWEcIayA+n1 ++vkO1qMVDukw//X9AjT5ZP4Sa+s7ZVjPGPANp4H8B8S2PmQ6siHz72I9xmyRDW89OnDh9IJnXCua +jkv5KBdWHW7Rh8mI6VgalpKUfNskzvwBqwN669GBg8WdHVY5ujVSIEA2Pzu1rm3vV/CFxDc8EEXx +iwxHuoRI8yVwA7zfgDEXoWhlbj4IgcxyVaY7BwmojOWCUb4tVrZdeV/sWB1QKGAEHRw0q84hXeyE +iiNAgMpXJda17d0ypOccuJ7xiApUET8/1UO534AzeX6Y3EaFgpBfdvIDFCxJ+RAgd61hlck0tsUD +NSW0AamDyft1bBRs6c8eKV5VGDbvZ5hyVkntLXuXHMqz7l/LbsTK8ymo1VbUKO9QvJAk8VKqnPZK +c87qZ69yNs2Ayli+sc+3xcWclLGK1QGZAJMmSRmrh5ocUrCWVrlwohMgQCagE+va9m45rFsOXM1o +jEUTTvBG07x05io495NFlQ+p8oJejbl8RtCAylw+Czy0bXKqZcDagUKBIlBw8AXaFWuw89COAgEq +d5Va17b3y2E948G17Ea83UAi95Eze+83YLwnkD0/eDlBVHtBE+3oZoEByH1bcc+Nm7Z0Mcu6wdqB +QoHN/VmZ05q+S5EGDluNBAQXTXPEura9Wx3pGQeuYTWiUJpnjXfhiaH7DTj5ixz4clSadJLFjFcz +tLA4oPKVTwQObbHKovLVsHagUKAIOljLNTusGGwp64YCASpjlVrX1nfXsJ7x4GpWIy6dHrGaZ93J +OjjZNbN4eQYdCuFc0lnZW6s6iQmo3OHbQoa2sO0UZa9h7UChQBF0sCZ2Oqx0tCltKBCgslepHdr2 +7hrWMx5cy2qk60aCLIlsc9dDTYOpmpSJlMWsYpivXjWgdq1KCsbQlus9bbB2YF47azpUb2joOLEu +hwH1/QLUzyutQ9veq/UCLNu8vYKtiOTmprZoMU3Bg/UEDfaCDihtBj2n2c8EmzVhTmdt+eq4DdYO +HFe1gbVi04C1tnBGQG2dtZ3W3rJ3yqHcMIBtxY9Zcv8eRhwd0tf50I04B+5l37Go/1rEXtNKYYlu +FGsOSMzIWBG0trFtRh+/6nKumLwCvRHnwF3Dclh7JoijwGeCOGpd294vd8T9jAdXMOIA6VrVj4NF +hO43UHdjxYrbhUR97MYMPB29RgdUvs4htbFtRufpEkasDsgEKFsVGvSqNofT0pn9+wXIXO20ura9 +V4b0rP9Xs+DwyotFhytiTa37DbjfNYq1MXKTeaw1g+i2hrQ6ILNmluuLfdu82A7VsTqgUKBj03cz +KuA1Yl24vsFIgQCVuUqta9v71bGe8+BaZhzeE5KL+hTnZsxVKOZ1RuFtSEnPEizs6kxU3yg6oPJW +laveFldz0NCbIHUwfr1JE4FGqwHkcAa7B8+9X4DKWaXVte2d6ljP+n81Iw5vVWk6ZlTo9X4DzlyM +g+mNUcNxek8j9I1KuXSg8nZJedMWgHTqdsDqgEKBIlBwtFtZHNZg1wg4CgSo3FVqXdver471nAfX +MuKw4k3MaqCqMjxAqQwsk5sWDdNLoVu67iXHDuOONTkP61rStFOXn6IcgKYIOyge4reSQ4oz+D1M +Xx/8HtYpdW17nxzWbfevYcCRsNchpDOR9xtwPzVOFYs0AVcTjqFboBJWB1S20pmUbVu6f2jE2oFC +gSLoYL0QxGENVhjcUSBAZaxS69r67hrWMx5czYDDZbPoQFa8Pux+A06msiLBVDQIgXpCEIAtrMEB +lTuhlGXTtpnO6rC2QZFVP+0A9mtfsIa+OXUKwriRKbVD295dw3rGg2sZcEgD1azhnP/QJ68Dz1Wv +kOKCi2TsRGP5GtQpQkDtW6sa47e2De/kihusA9Cs2wGsBS4HrGu/BatTsFpYa6DWte39clg3PLia +FYdly5oOHIxWn7wdTOVMBVgsPNdHvoomGse9pKzzeVu+gHqDtQOJAkNgYClCPyBdazl7P8L0051U +19L61DFuuv+fZ8NlEFHrmpz9cr8By5V4z7hqoPSvWl0arFto0bl+MBDrIeZWN22jO26tWB3Q23AO +LKXSRqwLl/8bKRAgb6Cd2t7W9atjPefBFWw4vBJnXcSHkqy2iQNnC/zjDSuhJ6I1vUiE62MYkPmy +SImooS2evZ3TiNUBhQIdGQVbxSGHNHRmdwJCPxzviQ2ehdotQ3rOgauZcbnHCBMfzbvfgLOrihlb +EeshaekNrNA6rw6ovOXj/EPbYIehDamDJXdi0IFjv0OgIw1WacwRIEDjbdu2db3qWM85cC0jDkt7 +lqZGTDbOKjDzJcJMbSoW/rWrcmBUW4cpY7nSvW+JJYXDBqUD0suVrQrsupVDiQnZUiqmv12AylYl +tLd1XepYt52/mgGHFznZqRwquXe/AWcuc/pMLjZqGk/WuxVQii+LAypnuUjV0JZqNLYRqwMKBYpA +wVYB1CHFOi5WoFYJEKDyVontbV23DOk5B65lvuENV5ZpRhLp/gwsEfTcnMEcbf+A6edgzBc8uahB +fW25yKXWDuMA61LSgaMVdHc4A983Ob5egMbXVsLY1nWpYz3v/jXsN6ocbKm+69zrEPUDeVnu7cC7 +vEpcdL7NytalLskBla9UmHdsu2DVkDhidUChQDnbwVq4zGHt5VodBQJUziq1ve3QXcV6zoOr2W+5 +e/Ei36l6vwGjb64pGWrbFrvja16XpcOUtckSJntLKqQ8IHRAebl+voPp4tQRaa/U6d4vQOWsGtba +cuin4jzv/LUMNxxbKl9JmGc9PTmCq9W5orN6PLppsavimmr2/YBemV2GqbZFiZhUyinWEThrOuIA +VgfxgLXkFs4oIKDx1qh1bXu/zO18xoOrGW5YLyzqaXwK796fgbViJgJtD3Aj30PaBNTOtagZkL5t +afUMawf2uPMAtpt+PVaTlf39rYvaTqm16z1y+Da9f4zdtvz7ZVEW9LU4s+V+AGat90f3EazibOed +zO5HERDxoeq9bK7dBtNoJBkEw6N8HaDDgVXyl83LGMaf7FRZS6O9I9z28Von7ABvsVQHurD5fgPO +ljKGpK5ZFN2Uml4pUVr0QO4W3rqnQQxrG7lM4oi1A4UCHQUF94C+wxrsAlpHgQCNsUJtb+v61bGe +8+BqFlrBtaIDF+08jQPjbUdyPwpW4IharyLZlR9lsdo4Sb23eL3JrFaxtZXqqCPWDhQKlL0Kjna9 +lcMa9DJSRwDDlLlKq7V0neoozxlwLQMNbwex2m5BD1k7aMbjfXq7iPqu+gXoeG9KciDla5o15mMt +8fx9DRucHZjcau7QONwwM6s5Rnc8+9cLyNi6WiKvtHRd6jjPen81E63i7FYllMTy/Rm4SSCnznIB +OC/oohdJpRKbAyprqXLF2DbYdu6weiBRoAj61p/kDJnDGqxIrqNAgMpdpda17f1yWM94cC0jrZJ0 +VvMPs77vz8BGQw+b2wVECxatCA4orNk0C1zy1KPzIHqxTfimXpUsNrJO4FnvrupvFaDxUyh0bXtP +HMKzXl/DNsOb4IJWsZmL2mYD2O1dfLc2TTS5EhH7tagVZ/UlaaNuGiiytgHvDdli9UCiQJmq4K6y +Oaz9GglHgQCVs0qta9v75bCe8eBqthluoDVqRuuqqoEDp35HGxAspY6S5XjgbVMowzpQ2QuDft52 +bTlvsHagUKAIOthfgyVYsbRgChsKBGjsLWdtfXcN6xkPrmWikTBSVzGlHNxvwKlv7FhYsRpzok4d +KmrVgcoc2NjbWdvctNaQUy0UGF0uxAAW89khjZzTOBIgQGWuEuva+t4q0jMOXPdA3TDKmJJ5fwZt +cs0N3cBm3qsUdRfp3gUCKn+Wttaztr04i2H1wDV2/nYoVcUdkQ5TursXCGgMNp+am6i9W4Z1y4Ev +PlD3yGosHzIFf/cfVpwFmAcrYN0er/NgK6My12YxTyu4MlfMUmU1zRVnmSvdqrtu2kZXwsOwRlfC +w8xFD7YyKh6rFVzxFLjiLJ7a3tb1q2M958GVTMe5YsTFoj9anMWDuZIKdmyV3CYruIId0wi8K86C +HcthbLkuUkbaEDqIK83iwVZEpSO0Yiv+1a4wiyfTte29cTjPen61Kp4V78NRa9gKs3iwlVCZK11c +L/mlcnYZOwfffAUW5WuUPbO3XWe5otJjdUBXmMWDrYSKx2rFVjwFrjCLp9a17f1yWM94cK0qnjDE +OdjxMi3M4sFWQgXpLbPW9JViK9g3voV1KMyCfAh1bLn6OJHidEBXlsWDrYBKx2mFVg== + + + /NtdURZPqWvb++RwnvX/akU8K1b81jwZLcrioVY+BYFtXTUBmgutAE48698cUDmrOZS97TprnXWH +1QF7URYPtfIpHqkVWvEEuKIsnljXtnfLYd1y4FpFPCvev7GqHqFOJA+28ik4RfgaIVdoBbum5UVd +URZkwxw2LZsrtmc4vdPMSrJ4sBVP6TityIp/uyvI4il1bXufHM6z/l+jgCe+f1bD3wqyeLCVTkFg +teCkFFnBfmlGtSvIgmC1TlxbEJRZy+cZ1g50BVk82EqneKxm5nsKnDfAU+va9n45rGc8uJb1SLtA +N9K0IIsHWzkImiFJZ50UWUGgHjB2BVkQXOumZXNVkA1n8xWTtRyLB1vhlI7TCqz4t7tiLJ5S17Y6 +29VwnvX/SpYjkWb1bK0YywiWsikIBDnu664IcG2+Qov2rVi6umtb1tbOsHagFWMZwVI2xWNNXUnp +FCSvpHRqh7a9Xw7rhgdXtR1pmqxaYMWKsYxgqZyCtMi1B01LrNCMWjR6ocVYqH9h267XXHUIO9BK +sYxgKZrSUQ6rSd/tCrF4MsdVsvarPko+A/4vUYhlxjCFLeFuKTqwlUyZy2plva24CqwMm5CuEMuM +t3vNKW/aRrkbecDagd5SdGArmeKxWnEVT4ErxOKpdW2bk8KG9YwHX57/iUjl8o/mCrF4sJVMQVL7 +9Q5SXAW71TlohVhmupBNi2taW7yVWg17w9qBrhCLB2vNFI/Uiqt4AlwhFk+sa9u71ZGeceBqxmLB +HFT1LlghFg/WmilI7iJnma24ykw37i3BAblrGVfTti0YDP0eCUHaYa4Qiwf3eygdUi2v4t/fC7F4 +UnvL3iWH8qz717ITS/OXrMjxag+1kilI7Zyjr7nCHePboYdCLMgDrfDm2sJijhrAMawd2AuxeKgd +vfVIrbiKJ8AVYvHEura9Ww7rlgNXMxSBhmqpc1aIxYOtZMqM90qmMhZiwb61rIcmrRAL8gGUpbRp +m+W6+AFrB7pCLB5sJVM8Viuu4ilwhVg8ta5t75fDesaDa9mKgDnJPR+uEIsHW8kUpHeVg55WXAWB +c122hViwy2opuLYZL9sOG6wd6AqxeLDWTPFIrbiKJ8AVYvHEura9Wx3pGQeuYS2iUKpWaFALsXiw +lUxBUqvcz2XFVRC4rKuvuKJ8LUldP9a2gMVsEUzF2oGuEMsIlpIpHqsVV/EUuEIsnlrX1nfXsJ7x +4GrWIo6uVX21Qiwe3K8KLHgT2mzeV5u2MITBAZU7Tareu7aFXeYj1g50hVhGcAzWVrFGNidHCgSo +7FVqh7a9u4b1jAfXshiRhtmsDJu7HtpyUJmQQ7Si2EpYCv00Ql+QcdEoeW8Zok5Gh7IDs81bDw1L +1imqOLUKgn87w/TjSqdv2TvkUI59v1YWKBEb7GaLYlqCB8spUeqE2Yh6pSL2IbbigDZjsiZxurY1 +23HdjrUDxxVtYKmYMmLl0iojAVqEZaS1t+ydcig3DPhPO8A340GgpMcqugHnwFYuZc6wwzS1M6Sw +CiwpvHzXA4kZOdphRtcWw2uqxxnWDvQGnAN37cph7VfsOApcERZPrWvb++WwnvHgCgYcHl+Ty/F6 +ERYPtXIpROmsER4prIK9ynJ63BVhmTPqPRqYs7bB7gJ1WDuwF2HxUFv/Dme/U9K93xVh8bS6tr1X +Hem2/1ez3jJemh51b9IiLB5s5VLmjMUpZ1FuJcMdu1ai3SmnRViQDT28bW2j7U4Oa/SbphZh8WAr +l+KxWmEVT4ErwuKpdW17vxzWMx5cy4QDzDVoOQktwuKhWi8FqdUUVSusgj2rUcM+VoQFuaCKlWsb +XV10RdphvQiLh1q5FI/TCqv497siLJ5W17Z3ymHd9v9qBhxgTquqCFaExYOtXArSW5NqvVJYBfum +d7+5IizIhxZ1bKwtvKLpOSnD2oGuCIsHW7kUj9UKq3gKXBEWT61r2/vlsJ7x4FoGHGDWMju9CMsI +lYopSG4pQe/dmJW3LantoUVYEEpxiaFlshQSh9IDTQl2UCuX4nEGv4fp64Pfwzqlrm3vk8O67f41 +jDcS9poGaEVYPNjKpSCpuarHQO9nzFiWVssGWREW2luC+iysLf5otyAq1g50RVhGsBy+9VitsIqn +wBVh8dS6tr67hvWMB1cz3nDZFM0YtCIsIxh6uUo/ehl+yRlG4CLl51LPL6ZVumgg1Npmp7Ma1jwo +suqjHcBi2Tqk0S61dwQIULmrxA5te7cU6RkHrmW64QAHlT5WgsWDgTVLVWGrF06hPzQGAYasBzCC +ZiFSj2fLsde2Gev9rRusHehKsIxgOtgxYo19e+oUxHErU2qHtr27DuuGB1ez4ZC2VfN7rQTLCJZi +KQjUyomx7w7FaonHcSeJrZ237bWsHNYOtBIsI5gLpoxIVxvz/n4twTKS2lv2PnWMm+7/51lwqeCB +T58qeb8BW7EUULhhEWtpTCmrAsLNxeWsBMucgimjri0o/WCxbrB2oLfgHNiKpXisVlbFU+BKsHhq +XdveL4f1jAdXsOBSsRL4rgSLB1uxFCS15tlSydjNAN1KuXkgdyviverbtniFt9YlM6wd6EqweLBW +S/FIQ2dLJ8CVYPHEBs9C7VZHesaBqxlxqUcHXQkWD9ZqKUhu6bd6cFkV7FpOLTqg8jYtenu9tcWz +OhrXU6Qd5kqweLAVS/FIrayKJ8CVYPHEura9Vw7rGQeuZcIB5rToXb1qHjug1UshaiXiqIVVsGMl +at1SMzJStOt7e0u8dlpDm4ayA60Eiwd2zcqhtLIq/u2uBIsn1LXtXXJYN52/mvmWMA9Xr6+wEiwe +bMVSkNycNeojZVWwa/0SQSvBgmzQC+JdW7oXum6wdqArweLBWi3FI7WyKp4AV4LFE+va9m51pGcc +uJbxBpjnfsWDlmAZwRI7T9mZy9H2j9VuUou2fQCROa5jSzz5keuI0cOclOxgK5bicVpZFf96V4LF +U+ra9i45rGfdv4b1htun3FrhSrB4sBVLIVoXLQ4tZVWwX21efa0V5Ws/62tto6X7Oqwd6EqwjGAp +luKxWlkVT4ErweKpdW19dw3rGQ+uZr2l7sNzJVhGcJW854TnyvU2scLnEqlzTeMFRc8wkgRMNZ+1 +BQVm3WD1QKvD4sHoCqiKoFgCploNjoLkLAxHrWvb++WwnvHgWvYbDnFSy9IqsXgwULGqsFVlHH2h +UcntRfkIqLxZm2262hZTUs18E6Qd5uqwjGDQdGz9N7t3fK3LhgABKm+75eDa9s4a1jMOXM16QyKS +1rS2OiwjWA7KEnDpsTKOBKfsItpWh4XASQ/e+bazWl8OawdaHZYRLGUERqytnL2/dXnbKbV2vUcO +36b3/7l1WObY3S3egnNgraAyR9Q6hxorc4x2FNpqscwRFfuhZgtMDMtO7eg6zFtuDmyVVDxKLbji +391Ls3gie0vvUjKUZx2/1hm7iNfeBk1e1PIsHmyFVJDc1DQvSkquUM/k6L4rz4JM0AP5ri0e81dt +z7B2oCvP4sFWSMVjtZIrngJXnsVT69r2fjmsZzy4mvUWs/M2W3kWD7ZCKkSw5aLJGWrsXCpa/cbK +syAjUlWL2douqGEuG6wd6MqzeLDVUvFYteiKJ6CXZ/G09pbZudsN5RkDrmW8xbypj3K/gVopFaRW +/VpWdAU71qWGFWhBHpSqBwat7XJe9MUDk1vTy3kxFY/Uyq54AlyJFk+sa5vPy76cc+BqJlzEPGU9 +gm4lWkawFFMhenv9fQkOxm4TuBItyIe1anlTaxucWmJYPdBKtHiwFVPxWK3siqfAlWjx1Lq2vV8O +6xkPrmXEAebVTkpZiZYRbDT0oLoetIrko/Z1W7hn0W1b1hZXp6pxxq0OsjotHmxlVTxOK8Di3++K +tXhaXdveJ4f1rP/XsOIAK+gY22ItI9jtZCGvY7EW7JeWT3PFWhAc6qZYC005XDcjVg+0Yi0e3PU6 +h9UKsHgKXLEWT61r2/vlsJ7x4GpWHOoqs/o5rFiLB1tZFSJ40QRKzQWJqFjqjRRWrIX2F0ugdG31 +dniHtQNdsZYRrGURHFYrwOIpcMVaPLWure+uYT3jwbWsOBJLliqpxVo8OPVtHn1KQbdULsCCfWuW +QmnFWmitrnrBlGubVi0q5BWNVUsK9ZyJAcx1VTxSK8DiCXDFWjyxrq3vrSI948B1D9wNo6zFWkao +lFUhmrufiwuwUP/MBWDFWmhOmfbq2oIBUDZYPdDCpANUyqp4pMOUdl6QxdkQ/VC4m6i9W4Z1y4G/ +yGIt7gzel476WbUWvAJJjTiai/cbcGb/AQBxu5z/f/bedTly41oTfQK+Q/1RhL1jg0ZeACS2fomU +7fE5tOWw7BlFnJjooNhsiSNeeths29pPf9b3rUwgARRJoLpJVrFLComFBeR95cp1zyYlnogXM5eu +8wmMQCyBMXLemdINvzUtEnfYQa05MPbg+EDB/cFB8MkI3CV8MUYYdxuitTHdITLoGIHEDQappY7F +b8uALALJYzUhTAbMOrZmxk4EZ9ALD8kHL4LRCMOrNBMq0AZcCirclQ7EptAMATOgXIFWfaECMvfr +LXVli2xxrBf8go0pkUqYLSlFhEpz1Ougo5N8wOj0losSKVpsTPBCXyudiYDN2eVEUqcKGLmaJvkx +OtUV4n2oOGRcpJWiwuFnaDEEWxol/QqsKyRKstKXJHAxNAdJYgDk3juOFej1BLbE0Syc0AnBuMIL +K2dL23HEGqkRlczUFmJkZefiBA4pZSEtXbpZUWYhJdSW+apbBUaVu86t1bDd4Pr4TSBUNDTLOkRF +GxYyWpcC0v8Y5qCaLvoxsQFjs8q3yPqy51dxbNG2ImD6yOq3RjNQBtB5FaXAMaooJIgobGAkrm1n +hwmtnK2e+MvkLp2Hol7rW5ZdrGSV5R4s6xh5gkWr4/VmMt6K+kYshKs1k5YgY2WbuJJyVqeNCacF +ExfNw6U04XNZey5aHTFROKagOJP0wPKzNUnG9yBJaU+21qcMs63qNdsu30/ArefKqCNy1lKsCbXm +qzmLswo7oa5tSgbQlpoJQqe6VOYb82/SDiMWHK9frRMeBG1Hkr/65k/hze+v3x7dfvzws5Dzu/Pb +awArAN/85eb6r0Lz74TsF4WCj85/urjOXxz85T3emFJfff8///iHi0up5uB33U85Z373w59P/nLz +9hw/BwfQvS++Xv3m31eX1/KqkG7dXvz48e78A44aOcNuT0dfnP18cfn29vwa7+3qd3+6vuvf4X93 +8ST7TfmVHGT/uL44E2A6z/IP/3l6+VG//PfDH16fXvE7dIK92tZx/Dp7HL++wDhkP88eyb8u3t79 +PHs08eutHtHP5xc//Xw3e0jp82cf082P/+f87O7o5uP1W+nf0c0je6Mf4Dvuf/n07sPsUQ7KPPtQ +v/nTm28u3/98+sbMHePF24w3vmdM+OY/Z/R4W8jk3cfbHz8Kh392PncWtOjMJU7tPA== + + + N9EUYX3ueH48/XD+h9vz//tRJmE+CR2VevYRXt98f3dxd/YIlexH+YFf//3i8nz+/hyUefYR2rlD +u/549d3Z3ek/F4wsL/LsA8OWmzu22/MPHy/nnxvp8zkU6J6umwe6vp76ZYfA+d9zcvJwZx+Y92de +kIvructx8/789vTu5nb2gvQFnh3Nvr/5eHt2/sfb0/c/X5zNPuIemYr8pLve8r1zcf0ICRkMxr7g +rjm+uXp/8+Hibs6meYoOkA97tO3ffXv+bvX1XtrbjnHspb3tHdFe2lszyi2R9vyXLO29uz0Vtvfy +LzcXH16ZvDdbiN+Le9sp7s3el3txby/u7cW9yaj24t5e3PtixL3CvhaBb8lItlzk869O5Fswol0R ++UQOOjr/5/nl9z+fvr3515dt+9Ijk2Lhazkwf7z8+Ai38hmYzW2VDD7cvf32/J8Xp+jQAqknL/Ri +PMEfTz9++HBxen2kC7grvPTstXk7/xh++xLn8PyBzD+F377EMbyEAmw7Nbt59+7D+d3Rc9C0F9r2 +33GEO7ThL8G3wEvw7Oby5va//vWzijEz6fOvl/NVifHr/Qb6hLF8eH9+9t3HR/bD7nEEs317Pny8 +fXd6dv792ekSxBsUen6pY/bgZHE/Xp7eHt9cf7g7vZ6/btOCL2BNWzrK3//7/c31+Qaj7AvukmxS +VGU5e462XMVhygVj2W4lR2GXjOW/Z4/lv1+QB/nrzcX13UlUX7yEPvL8+7hVTyJzsUP80Os0Jizk +G7adDdpI0bPYmrDda7RrktESI8m2EIPT24u7n6/O7+Yb4HaJKMw+9n55RJmSDQefbvFAHuHF84GY +bRYVfnHzB+K2eiDzqfIvL0GUX6UVfjE3sO1H5+XF3V9PLx6TJb/ws3N3ZOXlauLFO+6FFvLP57c/ +nWMmd4gJWrq5XuNaPF0H9i5DGyvUvnol6rQFXinbrUwzZu8xtP0eQ19WkMjxzc3l0e35+X/Ptmq+ +Rs+otxeXp/PturukxDCHs+PKb0/fXnycj7rp893Qbm63xDl/IG/nD+TtNg9k10TMP9/cvv/55vLm +p193SDTZk7UdImuvhpjNj2DZcmL2asPYdpKYFa/HZfXV7PRl4RTbvNVnj2TX9vrOedy+3pj92SzL +Pmb/vjG+bMz+bD/cXYvZX0DIt/1Imr3Jtv5Imi/h7NiRtJNZFB7xKMnI2jLn+xfyuv8id/zWO2r8 +OBvLtp56zR7JrgTh/G22OfX459Pr6/PL788vz8+W6NOmBZ/fIjTb0rrpIKcFX+wc+vbiw/vL07Pz +q/Pruz+fvt+hw+jqVKqabZjcCelolf5dTX6awc+5o+av+fx3+nyLKeXWn8TLcg1u8+k1eyS7xnsf +I4z5z4l87Aq9W4BZ275HZusQtn6PzB7JrnB48yORnyfxyrbsvneL/IPeXVxeLvF/utzmlX53e3M1 +fzD8+Pm1ko8wOZlh7DGP8dwy9vFFYq5mj+VH3Mk1XzeuXz+/Uf/yX6e/zh6TUL6709tFlFK/315N ++N3NfMnj5gUGcntOEXDucE7fvr24u/jnfHGqL/AC9pjr+eM6O/t49fFxb6F8ZFmRF4houj4/nR3+ +cnZ6efbnm7fzx9YXeP7gs9m8RbZ6qfm/cAhzF3BY6oVEktPri6vTF0sNu6t56Iqwd4bZMsnu7NU4 +w8wfya5pP/bOMNui7t1fWDjRKeyaN8z8nGa75g6zgJRv+6H0atxh5o9k1w6lnXSHmc1/7oY7zBe5 +47feHebs1bjDzB/JrhhL9u4we3eYbTmMvgB3GPOluMMsoPnbfhK/GneY+SPZNd57N91hFmDWtu+R +V+MOM38ku8LhbZs7zFbbf3bHm2fBlltKPF5oDXcxa+ACP8D9KjzZKjxdzo0dWISn68ALNb77SRu/ ++dObb5mz580yzdcshmh3jqjXm7dovhpwR7IWPU8C8Jeipkvy5Owp2sMUrd5TtNdI0WYv656i7Sna +K6Fov78VwJfNop1jCl4jPdtzaHt69mXSsy+aQXu19GzPn+3p2ZdGz3KjzptlVvhXRtZmD/4LsuHt +t82cbdN8ydtm9uD32+YL3zZf1m1Bf7349/nlXy9Pf32zLNhxGx12qnJVzfae1Jn/2wIHyqzELlG+ +2/Orm8fSG+xYrpf5OUX2+VH2+VE+E9KtzNe2XJlK/l+u5L+v5bf8/VperF6by/bF9dvzdxfXF/MN +XLfn789P775dsN2yEs8+vn2OGB3XjuWI+fAeWWLmjm6XcsTM5Ea+tAQx28JDvcILCn9cctn4lnvq +LxnLrvjq7xUW20sOHtvbu2lXWkQRtpy6bWhS2vrw+Zur9zcfhC3/7uMjJGyXA/jiGHeIIJzeXtz9 +fHV+Nx/XdokwzNap/fKIcSobDj7d4oE8ogzNB2JeQhkxeyCPOD/lA3FbPZD5pPmXXaHMu3GILpR6 +dukIfbVZET/LGbo7Jo6N1nRnHIj2AYB7c/LumZOXpSncRq3S3py8blb25uS9OfkZx/NazckkLjAo +2/LrRYRmb0Lem5D3JuT9NSOTke1NyGu6uz0q4r0JeW9C3puQP792YkdNyK/J2Pr24t27j/NvM9l2 +UrBwOLtCDWanp/vw8fadcLbfL0vzPyi0vXYknf5lYxuUefah/Xp+eXnzr7nju7z46ec7eV+cIQ/u +7CGOi23vAsbdeXxzLaL79fx9Nym3V7q9qNJtf8ft46PZK92egpR+/dPt+fn118KBnX99cf324qeb +r/95cXN5fvf17fnbr29uT69/mr3V9tq4vTZur43ba+PWjGw+H7ZXyb0MV2XCbKvL6X9fXH28e+Tq +x3xJ0vfPjnj17DGdX8rDIpVPVuLF9D3fXpB/P8H+eimPmG9VljiJe3yHUP41qZ0+vD8/k4Pr9jl8 +4Z9dOnrVyprZJCot8WJpf1pwm9cwdvb3/34vvN4Go+wLvgDj/Yg29wlUU3u9zV5vs9fbfEF6m6il +Ub1NVOJQfbPX2+z1Nnu9zV5vs9fb7PU2O663uYwKjVfhQrFXQj29Eur7KPztoBbqdebP2EAfte0q +tlcZAfycesMXok/7HBrbRhxeTQ6N+RkbtjyHxvwV2fIcGvMHsuU5NJ7nHpDt9ibe/uPz8uLur6cX +j1kp9mfn/uzcn50bD2TLz859/qltOzuXUuVtPzY3EqZ35ejc5536tLnflmN38Xruc04t6cALNb7P +ObVbOae+//n07c2/nuL+ot2hRF94doFd8eucnRRtH5H/7Fto9sWabx8hp7lb279fAMnmD+TX+QP5 +dcspwLZTs5t37z6c32FL3J6/XUSnd00G+I4j/TIEgM1X9TVKAtuyKq/7PvG9aLbLollhqq/mouR8 +PuMl2IwlI5nPaLwEn2F8OXsk/7p4u8CdMH79/CNy80f08/njnofZkNLnz89BfYlKjSfIor073NVe +qbETSo16r9TYWlY4vBalxvyB7JUaOyD+7pUa23vs7pUa20jJ90qNvVJjW5UaX5hodne6wNHyNQpm +725Pz+5OL/9yczHfsVkLz1zj1NJz+2cezs7Z8uPph/M/3J7/34/n12fzOc5RqReISf/+7uLu7BEF +Vi6x4eu/X1wuyJUwKPP8mq/ZPrbXH6++Eyz+54Kh5UWefWRnT+dl9twjWabV2uI45/kjeUKBZ1tO +hdeX7GjBefDu9uZq/nD48bMP5zWlbnqtqY7Kw9m3ttzdzOenbl5gKPvcRYPB7XMX7XMXPbFqeb5M +8qWlLnoSpdHfP97++PFSJnuX9IivM/fKApFiy4Wj50m58kJ63iXxYXtV61r+8KvX4T02fxxb7jtW +vjrfsQUj2vuOrRnlixsoer7kzSPh96/bTHGX82evyEhR7q0UN7ttpZjtzbRrRgpsuS1Qie/Fvdct +7i1Bs73Atxf49gLfXuDbC3x7ge/1C3yzRYPXKPC9Xr+02Tkd9hLfdkp8sxdwL/HtJb69xPdJaLaX ++PYS3w5LfIV5LTLfkpFsudRXvTqpb8GI9lLfmlG+uNT3v25u3v50ezr/vH+NIt+rvDNiUYz4lodI +vMaMF7OFuX3Gi2cnCPs0ng8NZJ/x4hM5jJQH4lXQ5n3+jq0lY+8uhbvTS4j/68fL07Nfvl4p6Ob9 +6dnF3a//tUAn/OHu18v5Ou749fO7cC+5cHnbd9aiwezaZvoDEHGH9tLr1Igu2y87ca5ulnNo22/9 ++cBUjsevibx9OYzDLt4G+JoY7qXXZ275xlk4nF1RiMz2Ovnw8fbd6dn592enSzjSQaHn15QvW61l +YxuUefah/evnBdH5l9Dqy/tiBueRjXBcbHvXL27O45vrD3enj12lmGtVxuV2SYFu3OzNe/rfF1cf +F5i2uu+ffcmJc68my1A9O6fV+aU8LFI2ZyVejMf69oL75iQaGV/Ca0D6wD18EonVntvblVtf9yzS +LrFIaYEXn7HTgi/gJ790lL//9/ub6/MNRtkX/EJYwj2/9PL80p5d2rNLc/vwfSRUO8gvvU5rwAac +07Yzg8/jJr3967RXmT9DOtHbi7ufr84X5HXfJeIw+0D85RGfgmw4+HR75YxfHvkyH4jZ6hV5JINP +PhC31QOZT5l/eQnC/CodiZdaz7b++Ly8uPvr6cVjEvX+7Nyfnfuzc+OBbPnZOZ8J2PKzc/5Atvzs +XEqVt/3Y3EiY3h+dr+Do3B099P6Wxm3khZ6cEu7AWjxdB3YIEV5rKqJ98tnRKHcvFdHrvSJvI4vB +drOif1+cw3rX+LadTLJ0dSpVzU4vsQuE3azK+O+6Xx1k7pD5az7ZSJ/vwP7adorxRyn64XHnsd0l +GIyk+nPagLtCMV7h2fSs8V/bmn1hn+Lj+ROkvZocH8VsYWrbk3w8iyLqmcf03RcT5bpz6TFepxPf +Ytbt9e6g7benwN6Akf39FSdA3kV3hE3WZdv3UT6m2WGNu8Jqm8P5sVF7Znt/Jn2GvfTDu/PbP1zc +boOKZFvW+e70x/lrvAsKTbuabefg2P/nMo3loMzLpeL6eH32tx2iJq8Oyw6bVbn6MvDsj3s8e0E8 +M18KOTt6KRcTCjuIuv777en1h3czbpHYHnx/nfqQTVi1bWc/N4wz2QVtiA5tS/jqvT4krgw95765 +vNyCNdmWKdkMWfe+mks68EKNL7r+6atv/mTKN7+/fttdAwVQBcibv9xc/1WqYJqSQsFH5z9dXOcv +Dv7ynnV4ffX9r1c/3lwe/Obo9O1P5yuzKlZ/vbj+5bcHH+XfcvXdQe9Q88Ov8vD/yI//I6B/rfzq +z6v/73+Xq7cC/eFvB+VhWZZtWNnqsKlWVweFOSy9qasIKKy8r0y9sv6wqlwDQOvqVt67Q9fWzers +oHCHwXi7svbQlSjjD2tvpUpzaJsgRarD2hl5IYDSeI8i1WGwwcs35WFbG/mmlmarqiHAVXi2TR3a +9CxFmkMTqtZ2X4RD64Nnrc67elW0KFIaABoX2DNT4qMGXTPGSjNG+lRJFwTg29YLQA== + + + BujbpgOgkIyjCc3gm9pjyAJwlSUgNE2tI3aGhZxMV+nZuEwnntvg2H9XGlkf4w8tJtqEw1DpiATk +TWtWpjmsDCZBALWr6pWpD431aKhCV6QQ/rYtC+GdDFe/RcUobQnwJqC7aKFqV2xRCksh9sJWK+2V +FNJuegAaDL/gUKxdcWg6eQJq2oqg0jaG39hKhi2zWttWK3FNs+LEtxwS1lzWpDls26pGtaV8IiOq +D+uGuEEccH4FnLC1T2WaJqyINi71pfEr4JUrUQi4BgTCypeOhYiPsgSCn1jsAvjqZdBA39J0zyU/ +1t9F/zKWLvrisYkibyP2o+g7Erta9H2N4yGSC7rH2eagi3zUmJain5c4dUU+d3F6i25+4wIU+Qpw +lYp8meJSFv1axtUuuuVOKFFkOJHwpugRJ6JW0eMW8a+NP9oQsbZ23sTPfaoA88QqMRlsBvPEhnWZ +2RlrUvdC7HBoEjZW/cbSgTobtyN3X5FvP27QYrKLi3wbc6tX+VeRGhQdOeDsm7gfIs0gXak8YUpY +lPIE9nxAnIqeOiX61X2TKFzRkTiSwTrtAaWDwCPjI2LJuhDVZOriDGBVgJC+2wVBUUXQ1rIDQGSu +gbQvqKx4X60SWY+PZwdE/bZNAFTgMeOpApJ1bo2uFZJ1Vhm7gs46V/W9xYhcMxiRDFt2iuuHjYlp ++I1ODOauBQp3c4fpDa6fXlkAIYc2LYAnfQkJT1xAM1jKynRLKUQKq92k1QbJlCFWwLIEkEIyjsDZ +7r+pK9NG1PKNUr82JPxDGdL1usdRorHvN1mi63GPsR3SdT8gzbWrTb/DsJ1C2e0r4J3uJpc2n1uN +9melJ0dl8k2snYgbXY9c6aRNtMDoCYVNx5HVOEGGVKXiN7YKJtIdPae5Gbg9qsBCIGB1omAlz7WG +S680Ts92rHtP2Ikl2JQkljI0xaOI5M445SESjleGhYiPkTC39WpIuptVRtZziu8igxIxWyizEnSv +Z0bjdeAORImtS8HEn7B7Qq4HR5M8c3obV8fTy3OQQsZrHm++0cNelo8IWnmjbQgaBj0iw0rn2usR +Wjer6Sk7PojHJ/X0MB+f92OGINHsnmSP2Yox3zFlTcbcy4i7UTLdZPzPmEUa81BTNmvMiSlxriOr +VuucthEX0SfS5aaN/B54DBPqjmEEWQlY/kRVSHdM9550ydqO4STpqnKeNFG3RNwS+UvUL1HInkAm +IppoaKKxQxKsT8cjTvvk4OjHg+TpfvSzCCK/+cc1hIa3q59uT99enItUYnz7W6lG1sYE/G0Fz518 +7g5944ABmeO8WR39dOCrw7IWEgRAkR6KYGpZYGzsIKsuSyz04Ojq4J00f3Qk4sJ/fETfmtIIhSoP +Q7BO5gkQWQ6jw8Aiy6tKXnr0xFS1LFWJ076RjvxwGkfXKCMGQULm2QpaugiQdrkcOHAcBQrBd2P1 +wLHyS2bIHdZl1erpb2owhPFoqaQxqaQOQc+RprGYUZnI0BjlKBojZ20Nghb0JKmDr/Wwcf3zsRw2 +1gHNOlA4dKZ1egQLbwjEczI4bVlwvpVCgpvO8iSUYchE4bRxJRh07HfQIBw2rn8+5lnjap9/UdWV +HjWmBXmXCQD+A1CGmmXcYWX13BOuoFaaUOv4bFlzG7bkDLFTwXEdY28b8kKymeUIU7JQ4kyT3V6i ++0IHpO81zxqLhTw+SK8K/divtLAeLQY7mw3UylTKfkHv2AlwtexWRTmL3SzY75KbvwzkMjE2NCQQ +nq+GDEvLL4Ss61FTW9ZRlaD3mPXKOm2nBaMSsIEDd7RHbThpRN7jjm4aVEKUcFhVIolQNDlqhJiU +lEUFgyocNYJTnseBYBnl18aX2lDExAK4WdfcmR4tA3VNaKoEKPFx/Nm9YmGz6sqifpxPEa05dlPL +l10PiMhm1XWReLzKBoGByiJk42yFXmAeBPN1qrxfZTPF2STprIW1XMXZ5mT7tlsOroZrdZoSYgkR +4NQmvOKKJrTqFz3DKsULYo5XLJMDgTiFI6THLb5pVx36EUGtopirOxxmW75StCeaszferOI26DqL +7lu/yvYJ9pIjvpm25lZyTp/TZvRtWPV7Ebu17ADYzabmQULykSa03++gCVQ+RJIAomFb9lCQSg8b +OW1WPVkh5dEDkxCQJkHwVaJMWGVQmZ54gbgl2pYIX6R7CYd6ypioZ0LZjriStna0l0/HBwMErhS/ +u9LkZaUBK+urSIsGikEXmriRdJOzi9xsUSETR1BgkF6PYA4SQpB1bT8vUVCqs4kqOJfe9t+MJ1tJ +QWOz9SjGS1aMlrSYrHkxQopijDTFFK+KEeYVY8wspshbjPG7GG8ApbvWZHukGG+jYrzPiulWLMa7 +tRhv52Kw460WGtIEfgJKTJrhTTrllKzUJFyUw9qmXiUKXJAyuZ4yFRPapcd001O3Iid/ni1nFFIJ +cJET0UpZh0RkyxCl10SAi5w6x7exeNGVj00UeRuxH0XfkdjVou+rDqfIxxOHXORj5qwU/bTEqSvy +uYvzW/QTnJ+BaQn6Y9K1cfqys9RU/ZnfHbcdSmRncoc3RY84EbWKHrci/hU5AsrU8ZTl51EzZGSv +RlSsovaoLgfchnbGm2H3qoxn6bZVke+ruPeKfPM5FyGDDVxkOzju8f4bUIHGRzYMC59IRcardfSk +Y+g6klNM6FLGGHbEq/8q0beOvySCNFFVkaggsCiUGaeqmNZxsUBG10KQ7+m5Yqw1PTusaO1NZJdH +7PTxwR9EQvg257JrKOulBWEZaj5Ks41xSU0SKuJz3SZNrYUUSaItQpSLsFI17yJNRAZ4NDsRQrKN +48BmX2E1qlbH2YyXsOmIsOJg9k1jrZKHOkSE1w2j+yTRVEghbMzXmHiBlE2j2u5SlYAyL1S48Udd +x90g/JCNnwcTK6i0gmAjx16ZkBqOu09wWDWvmBPV6zXE7gYayqT5rXyrc9rYJm5aQRCrM++px6iU +d8W6BN8DEgHD7/5dLN6Xjm3kTcSO9P2IXe16GoeTjyaOuRtympZuVtLc5VOHd6oTiPOL0hUPw7gE +ruPhu3WKq8nFtLr5ud5jlMgwImJN+iLh1QT5Mtwjhjau/ybhcELhhOcZmmNSq8B6dS9g2kWAXtk6 +45fIdvcvxoVQLyTevl5pOZioJCip3GyqvvOqhLBZ31XhbxQiRHU0/Mn8jCZwMMEmrvJgDcbLNF7H +6VKPsWGMLlOMGuEccTJ0KDnFWk6fDDoh9gjxsz0x3i+pZLejWHkd8m0Xm++25nDzNqvhBrfanyER +mNAJzk5T58QkTaTuHmdXaaY7osT6/YBycb3ioa8LhvV0riOAqpVuMhoJjKht/wUwpqky4tvpMDqk +ItbxZImghJWJpie8zeh+Qu3ucEhoX+QbouCOGDyeHLw7+I9/HPyDyqof3h7Uq9/8dvXD/5oCvnpj +Vt+8lz+lHFRfvelW+ap/GC/zYJUzFDpDkRGWjXBwhKQsMULkMaKPtwLKTLbLeDuNNhzLoAtBexRq +9pAacHS4mdAMlBjTlXtoET7N6dSUiI0JHUuMOlCM+jch3Cw0Je+TA2DNdE2Pkslhs25lpqfW5Fhb +gwFrDsjxCZpwTD+fHL7T83l8imvB6Wk/YQjGXEPq4Ii7mHIgEz4lTf+Yn5nyPGPOSEvq6hbd8qbl +L9L6T7g+lptyhznzONjy3EwZeZjQjgl9QQn0o5OmpB/oqIn9rOsptYzbb0RTJ1R3TJlZbDzLk4UY +HwIc0vigGB8k47MmEpXRiTQ+snIcvIYe/5trxH4JRYQnjlBEuONQhoE2T+SUxsuJfqUis0PnD6ug +BvwWfgPwe6gdTBsAOOBEJWTeRCu6yGIwl9SHjUi1gd9IkQDlQ6U7y5S+EnG+Lb2L3gjGllBztb5y +KroZmNZaqBdLFTUNpCg5iiCBRPGQRhPVjImMI7Kwh1jSQGKlJkDFRgwrBKcGnRKWA5mpqsQCwwBV +WfoDubqFlrk99IbPrYFhUA4/GWCoiLPYVQafqHq+oozMMs4q6TNNRf+KNAUF5qCC/k+mABNZpFng +JNQUzOMswJBFUU7GWFlVUWFIRIYKGxCASjVLHNCxlgnK1dqyYufUvEDrloMWqIKES7a3oUlIxOlW +ERFSn1UFqX7RwuoNKdtHLZHxZa2mM2raKJ4HzAGKOvXHaLkpUD08INggtxt7QJle+iSyML4xrVW7 +tHeYfeE0XKnirOC3qkErH90YRIh11AE1VpGGXGcrfETVaCVlWzW0ukWyIQ3VwP9GVhcTCIBJylCq +BBKATgCtqhAiSPauTd9YeNIAo8u6jihuHd0NanrEcBdgY8lYk9VfcUO2jon00EaLvqB2FUVOaQcI +6tCykvCmhodORtrcYduouIPvTE1qlb5DXT5qroh6Rd6gK61620ivfKvsGcV1dJtzlvoNTBVhyOZj +KyYTABmmNXU/RcWaeSxgoC1j5fqVrIelVgHrwb3ZcjfEfV1Gz7IS5k1d6khKhEJWce1LF/G8dZFc +gyKpPKdni5RyydFGW6d2WxG9GWBiMUTXOkRkd8pC2DZalVQ5hB9euwhsDyZ+Hf2Jsr3jfWpFmwWl +QjHpShu7Vrc6au+DQkxoo4GwipuulOM+ydEKk0WFOZVjpDIcFEH1gpF0kmpY52NzsE515HVAexL9 +JY0uciIdCXnRUfJE64uO2KcDoUgngnqA0VuKuJhw2FM55BLxBg4LASmj3oLvs9exBlRQR6epwblz +BrvzOmNz81s0Y0AYLMzHdXNoobMz9GVxU2MzvApqnoweIguc4mpBm1YR35ugpmdpX/bVSk5ld2hk +8/1wBQnUUSvk5cQNWPp1JZsWfg7NCm5UgruyM4/ONm30aG6jXnacl4UOsg+ovZM2o6H8H3K+/+6b +27uBzzikHfUghnvv6gw++x+v364+/Hz6/nx1Rcfo/5Svvpb/DuzQJ3ckPa1hEZTFXMwkgEtcyiYo +G7yUUVBOdjGrQBlqMbMgpTZhF6TYBgwDBdDFLEMstZBpkB4uZxuk0CaMA4stZh24YMuZh6/ebMQ+ +fPVmIwYCcvZyFkKGtiETIci/KRtBOX8TRkIKbsZKUE+wETOBPb4RO4GCGzAUWmwDlgIFN2IqUHAj +tiLqDjZgLLTJ5ayFltuEudADZgl7oXqb5QwGxOBPPSqjGL2S2aqjunFtlfy4TWdoF2KjwTH3hsvI +lK6+uz29/ul8ecCMHEiC8I4+DVaoK2NmcC5CT+fVEeqExktfV/SskpVrCQqYTHrZ8O8JDVZ8m74+ +0cAG7PVU54ka/mGC1pZZl63lCKqRD6B7z6gE7VqqplSn91RPaq3ImkudKfJexddF3vlYTde/kzQT +iuDs4IlMUde1k4PUna6DJwfDakp0YdgaKtaupC4BMO34mvGtmYZ8mtLr7G2so68idqFvJnaBf6o2 +6612KR9SPzFpXvppKTovyn52Jog0yyXUBriElq3wGHDStA2d6csVdqGFtnbMprsWrg== + + + uwoo0gN45BaE0cEnFD7LU49QObeFEyphuQeDVgphMPAaltaNsGx4FXwDzq6ED18IdBoVRlFGDodQ +YgJMy7JDhFTpac2DoASWqXOBngU8vjBvwiqoIpMk9+RA+hjgeA10oRcsF8DQBA+Gno60UOeRjAmt +D3JOKaghcwLyDx0nV1I4KD1p+OOEypqmVoVgI4eDgkJNdWyslDghTIWyfWyZiMPeFKl/xC49JuIg +Tg44LsuDXUfKjzj6Is0HMZRzVGav+7epjkEVbKdrJvWl74pOTLXq+8tR2bDKBhXnJRs5p2XFP6HK +5jDNUj/RaZL6xdA5yhaMvWLbsaP9mtJ5xZMJj+uextsjR7lK83JyUAxeR4hOB6vwlW6mrhlIDwIZ +dIWoU0y6W0yHVEzH3aFMjzpFettPYJHq6Ge5SLjTL4VisiBpv17FZE2L6boXU+Qoctwp1uBWsQYF +iymiFmvQuViD9cWazVGs2UPFmq1WDHdk7N5g43azn23vJl/IokeqYkoqioRXGUEp1tCdjC6dJK8a +ATU4xz0chir9vGrbOh58UWQWSRSeCtrJmmNu1GqhU61zmH7oHEZLjn6vU916MpqxWl0RNtY1D1h/ +tPNd/ir2I6shNdS3k3qR90Zf5n2ONaROnfQzAB+oknMoW1HP8u5FnJm8tM7LpIVBL5QS4Z1t+56m +tvvRTIdsuwN8PE9rpnM66WuWZrCAts1GU/STsQYbFFP6vxuaxptkFp8MVWCTCaG9azhrVIWMppYy ++nD+BTRZpK/eTJcSHeN4hOWfYoAKgCNMUUvkuLk1eKdG4yF6QrKYYLEKU5P5SFshe10M309xIGuz +yBtdgwn9OIrhQKbbPpucYjh3RZy8ta/XYFa3VBkC9ks66N26cawd8drJ6ebuOpOoqjC1TrpDKGVK +CjNtDA5AUG+bDgMGKTuRWE1pI42nc2iFuMBS6ZhRw668MdZ08o3hYacWVT0wGmsRNK66uBN4bKoO +0AKVG5yDcFOlLtFTD9MpLBooaDzDJVsEysaARFpvy+i2Gijcds6YiCbFD7oBsX8FOgglmvL76F/R +d9AgbArCOpScNYU5mJ41Pt+qZov8kxrd8QPRGScH6SUt1Qj0IlEpawZix0rBINXU6HVTc3KQuqMT +2KBfmFVqXNM0g0mqvG010IeLIdQPqvmowOaSKWHCWqrQhg+oneo/gMLVtWWd11OkRcyaK9b0qpul +rPPdNGVjLNZMRTdR2Yx1r7WAS7Dx/GtzYDwyPBqsZj1EyiLNX4a7RY68bXKy7nG82wInD1tIbHDO +B1pIjDAhUsTQ4dlMRS+4KRvoBB006NAcezhZM7wVrAyIgghijXRG5iOIrKh+7D9c4WCTztYs0ahe +fU3R1hy2UNgG22L3C0N0dLZxq0dzW5UC9IYOtqw0YDQ3kjxm5OgpTdSBDWmNku4RtVGDxojeqHFk +RHG0+IjmADihOgLchO6QTC+lPHQjGdMe0vYx9RHgFP8JHFMgGg3GNIja/fHW4xE0pkNfvVlDiaCv +n+x6aOMn1Ai69gk9gtfQhCLp+djRJGq+J1SJ/kkTukRl94QyceHW9HIdddKDfEyfVMM8naZ1NEqV +ymMqpdDpOq2jVBmeZrQqQ+mMWmXYXwzRf0qx8s00OeLbz680FTxd/fH2/Pz6k5IMhZRlSJgU30EQ +7h8YHOQP64qDL51nggDGfmqSoTY4jSAvo6FRSBG9wl0I6tNXw/ICr1inhUCfSquh/QHZCUTyq+oY +jFlnWYb4qEmGamRaie9lCxuvzpzChXGnWmcMN7lQBJdyDBkNZLdqtDD4SJ22rR/mGCLgLAZGjL6p +W8vwNFIaWjBi+LkXbI4ZVELsfGhqTRVh6NkJo2OrMT9O/mF8mnqwAVTRqCcEvyo1yVCDxBjIBhCc +bgFfwzKJv8GlJENBfZ71HGBpTRVQuRCzXTTqMOucTY5mrirpw2cYb6T9bFbab5oKBKOZDACh7NHj +oWWHYXKMeTeQNQUWJ2PUMTRUDE+zDp6YmvDGYdGE/tatV8tMgJWoRhhs9FM0CGcmRnSJidBvIk10 +6PTIBwC0aqwa8DwSDgDzrAsxx1ANb1Egp42xOKGh7aMsg+ueU46h0KhtJb6MpYu+eGyiyNuI/Sj6 +jmhPi76rcTRE8Kq0ca455CIfM2el6KclTl2Rz12c36Kf4LgCRbYEXKUiX6a4kkW3lHGti26xE0IU +GUYkrCl6tImIVfSYFbFPfwQbcbapTMxIFKKjZ+WaEBHRJlTHYa0NJ1w3ZUwIECMD0V+3ygbAbWXj +MOO+4t7TvAPd5pPtqU75wz1c5JuYG33wFWlBtIoxvo0Ew6bVqHzMMGS8014JWfGrSHaiKa/OEwwl +wpQIV/oiUbaiI23ADtc2EV8qq+mFGuNSKp3QKpbVMTrPI8EScdF4E7GzbmN6IfjfRByuNP1KywxN +kWDn+YVCTDAkUx9MB0Edmhso1oGGGCDbN0SanvLvoDfoL4lU7C8xvk17gDQdA7cxhRkHXpPdqtPM +9PmF4tRhbjXJDwGY/LrtJt+SsviU3IG2cq5i060iFboupmqosW/z3EK1bmQN9GgH39Rt8neuvFOq +l6ZeMU93U5tRSiCwW+Wk1OnmJJIbTeYi9DwMSHJT8ZtEtLGR2sGO0n2Udl08DPqNqQHNjff57tU+ +pFPGhHjsVGlTaeqWjlI40tkhNdEMecRO0ptV2gS6LWh8x0o3aAZ0K2iAeSATRtLWNHqe1/F8b1OZ +ALQgjTR6SDLHhVLRdpVwTEktOXfFQx/psXpyZxQ7rDJqnhF6I2RESXlQnLZNZEuConQZdNy+pKu8 +tF83HVPCDjqN/4LHuo7B6PSGWvYYR+k5u8yryGmo4lR55sFxJcmbzqUejSWntgWJ4UxrMsLR6To6 +f8fn8/QIH5/yYzZgyClYxcYBMzHmNqYMyZhnGTM1U74nkedEnRNxTlR3yl6NObAxi6bY5yI6Wk0u +ZLzmgCJRoB3YJ8awSy4USQpJThniMymS8p0kSCRaMaGB0uFE1iJVS2QvUb1EGXvCmIhnop2JuI6o +b3w8HjPYcyzJbVB1hrcNPUAqQbqaqYPgx9Wuyy5kkRgrWpLTQxFMkLWGdBmsaw5tENo7sSULWxla +Zg6SvxXzV8hMqcUYYiR+CA77BuZlWRG47pTwv5RTcZJdiBLE2nx2mhOASKLZmvyqSDnGjpnPzrUp +uWCoNZ9d1eWzczGfXTwqDGPtNJ9dDP9H0H2dJUVo3TDHEJ+PNaFdSv3nmGPIqgRpmbsqxIx2Xd5B +p3GAGgnD/FcuJrRL+euGKYbwfBzT2bn8izybXR2z2flV53h2HNPZ6ZAbpsCLmb5iPjtNBtZljIwR +pnk2uyZms7OrmABynMyu1QRDhgkvNfVYs0plYzK7NuY1W8W0qDHaojQpc6pNucbcKuay63KnxSSR +mv+G2dU6jyzLTHbxtLFNyh4WYqJHF4NTra/rLPKYmexczGTXxkx2JmayCyaWYVpATRUXtC+tiZns +fBhlsuO8KSYyzkqdVYep7Gyfyu54kMqutF2y3a5knv9UK2cuu3rVtR+TlnUdZC47u8rGwFx2YdWP +sktlF+OvGzDYTLumUb95KrumHeWy86NcdjG9EFeMSLbqEIoY5nXF61W34Bk6eRNiGrtKscuHURq7 +VhFRcSmiXcKkLIud6XLYHQ9z2JVhlVCfvWzamMQujaPRDVV7Dc4mXdAkdu0q24ExWDtuwEEKu5jB +rlqlHZymst/jKbVoIgNMYVellMZVHz/ekZIs0xAhJ8xrx3RQEUICVaZMym1Hw3oSlshconKJDiYy +mEhlTykTNU3EdF1iO0031GgeALwfpox2zTBldJMy59WVhudnfWjqbGfFTmq2VI0NjuPQlKqajodD +1aSr3nRzkecbihPI5K0cXfpmvAgxy2XI1qkYL+Uob3QSBzNcKEbIUoyRKZKtNsO3YoySxRhnizFS +F2OsL0a7opjum2K8tYrR1ivGW7MY791iuLWL6d4vBuSh0VMpS4XZpYtWEgNPkeOULtqQCtUpMBjO +rZFKFVM6pod105O6YkwLB+miYdk4Tumie4pajChukRHjYkyoiwyTU/E8XXRqI+Fy35FBuugq9OMp +8gHFMRfZoDkrRT8tceqKfO7i/Bb9BA/Ow8b161TkC5Wfq1V/8BfdYkd06M/mYnR8rzqUKnqcGqaK +biOy1s5H0dRWsTjdvZkpuoltZImidVdErUDWs8aHjGspEvEu8t0Ud1yRbznt03jbFtm+jTu7/ybu +/Y4T6whExq2Ns0SHVUdoigk1yljDjmT1XyWq1nGYHenL2FBNFF33rGpMFJ1ygrMVJopO+B8USRhC +7nq+OCaK9qtiRMyLRM33mYb2mYb2mYb2mYb2mYbsPtPQPtPQGEn3mYb2mYb2mYb2mYa2JdMQQiST +Q+/ApbeCnQUMfm0aZDe46mEI+FQtEgM+KY/AZKJRFiJaUaCxlNnU+i8YpMJuCFYV20x4Cykk2BAt +7nr3V1s5k/xBFPPkFGFa3d6BGylmmV4e5wpvuQmw+HeuGjWD8ZlmoNaFNNbGtM8poFtvA0B4rusu +QrJMlw8TUlnHSJAyro2hiIyIFGtU00K5Xb0UaMR0asbA+sfINFmJ5KwQg819n/bEp1T2VewTPuf5 +iXCWlDy/Uh+xcEi/OHXiiWkFWqkrKn1MRHFGB1NsreLscJXUR8FEI3cVyhhw7eI1BVAlEKJB3Ami +zkltGRPk6lftYRvtCsnAEA7bpo1xyqG10Q+qNS7ST88NKGPS+CIsax288sZ1jIwmhA5XnMLsG5mb +mEJXdz0SM8SKTaUZqmARLGNWCs/rkBy2TbTJV/QzkSnx6iEBm56uGyO01cTT8KaJUkPj1V2VJpiS +l8DUpofAU0Gka6JjBFmqW2xfkQNO1akxRwtekqNjhzwMvb7u+1wxztzmA6tj2HY3+Dq5R6b5gcbH +xAsr4hQ21La7HhRAO+LEc7yM4YypGNKQShLOnkwCF7QlrHtJdtD72vUA2lWbdKtZ+iYmJKjIxcg0 +VOUADQVkaSsByJBpcSb6GjGNMQBpg0JTpXp4a0NqJlCpSAMCAC20YibmwdaU0V67liWMrmKK/xjY +roktsmzRQU2+qitKX5S812OlrhWa5b9K6b/1OhmnnpqWvi2a5N9EdzKSqzrq7zsADb/REySCkCKa +6ZtB4pHkISX6JwBEE7hTlcn6V+JgcaRvcXQx3z+JUsrHf8aE/+q4lGX8N+oquSY/9NlBMUiaHpP+ ++yarYZSHWjMOoSsumR3roDnRm+iBw86Ocl5zRMVk2MyebaLNU4k9pm8wVyQr1iZSo18FGNKqpl8G +5PRuqjhdxHMlY0yAoaup+nhXxrsCbRXF/xDSsxJM51z+gVJ3YlTT5f/Psa67yISoSgdjah5jWgum +cxllRY/5nuglr4r1/BIA9WCL+dVj8vXuh7pZdsnXs3sAatWUZhcBxOv9yGydHQw6Ew== + + + 07Gjw1Y7nN8FsOqSzJ8dZKxluobFTrPVx0TqTK3emNScrIzRzPd1JFe+0UWWZYykW3kEQZcmDs8m +T/g+RXrEsnQnSofxXcb+s3grACd/eC0AUNyoy3p3UUBZkjycHfQgl8435AKp4FmAQ7zUnaC3Nxwq +R6SastIzhL1NjEzHNwXo0P1qykk9lEOrjP4S0zh8WUeYrTUOH8lzsOODLUv2Wzhy3Ajyw9VB3WiO +lfGHAkeCnfTl0dnMKo/urdLUBk6gLquyC+NYE7kxZSgz6DKWMopcy5lKlaE2YSu1yU0YSy25CWsZ +xdjFzGUU2zZgL1FyIwZTYyI2YDE1xGITJpMKhY3YTAaGLGc0YwDnclYTY9yQ2UR6qeXsJkJJN2A4 +v3qzEcsJiXoDppNxRcvZTsYoLWU8pdAGrKeWWsp8soML2U/q6pYxoAi22oAFxRpvwIQCo5azocDe +hYwos6JtwIpScbQJM0pisBE7SgK0EUMaA8SXsaRKYpcypUrRN2FL9RTZhDHVULhNWFM9nzdgTjU9 +2SbsqTa5CYMa02suZ1E168ByJlX5peVsqpbbhFEdKQrbLvL/O9iqNFNlGvqVmtM0GKnWWLTG6p2J +gee6dUpEOz5OukpSW4CzQmgk+q5MEDyY1SNZ/XBL3pHK4WAsmgMSufzU31F5KJuu0YtkIZtzYIdX +j35X4hpf7Du6OzjsP9WqDgd0vAmfLgevMfEKVWFPdNcEUzk41yKlrCAxaL8GabPB8bdN6D87Optd +49H9NfpWJl5oUV7t/az6mpWN6uUla8s8ExusLm1wy9dXim2ywg8gOFltkzHWV0zbUJqM+xaipkx4 +5M+RB9IMmXjb5bxELuF4Z2mI8cAtXTFtumAN3E5r1Xk2El6rxhMANDep8Hi13lBKCUUpvkZr9FfA +MSw9u3WQhJT0thrQ2/6ytsEFnRndJlWvBuRdfpFhJAjLAQAD0SFsYPUZ3FxHb8K64RWU8q2JXt5k +mCmYuGgJgZg3me+N5OQGQRNRVK0PmQ9FBt0i1gX4jx2CDiGNdNBODj/l5ktfHZ3Nre/ovvoqq76Z +g0rv33trkE4j9ZeinaYSXox43EZLUY/UYTnyaXaaxejHSVqOgCy2HAUfIBCdmgAZxqCfuOoTbgUG +kytLSXVDE4lSUkow4KlK+jEPR4oKKoEqMZMGAF81MZ6vBQeMYSIlh/pbgYuWITEhBZ8xciljUsNk +WNKllKkhigU9U0PGJ5DVdD1/1MYs2mf9jZTDCylDvRqwWaFaDTWFJXQBdLPUapnVyR5GGVQoM6Ji +IE1hgOoLxmzUSPmb5FavIiFzc0wmeyPqII1Ubd3qHoV+goJ0EOaZQlcQFBPxVHAEx3MDQdGNv8U+ +Rial/lvklZ9b79G99cqu0eTDg4ofUqhNsC/LcbUA/7TUYgzUYktxMDW2EAuVvV+Kh7HUMkzUmV2K +iw+RCVLpWlPSO0N3WFBF+A5C8+bq5DyNqJQ66QWBZQxjaSE/q+OjJfGv5RAwMbAWLrw4DZIusb9e +uE4mCWq/gAaUJtmZVtNeUFfAVNcafhhidAW0HkHjG1V0AdfI6AoIrcGsJkPacDPW8G7nPpCZpKu8 +CIQtBy77wcHXnemMmKe/Gn9qy1a/6L/lVpxV69F9tSIekRMyqPWBfThdXgUuXWCVtxcvcWps4SJr +scXLvBbPkbVJtv69eZs+Wx6ZD7+c3/1Wg0I18eZ3BwiDFsJGOdYLCW4pCbcIt+6Sy5zOz85ta4QR +ypw0SA3LE10oZSML56ARjfK1rREvYmA+UXVTWTe+A5B9J/uRIMw0aXFqJAhrFY4t1SrPTIMe2z3G +KcEs7hXdMjWP9xrQsLsnxNNvGeQPRQk1947xrgliVYcPjqnVVNUa20ONV9U9M+aftxd3XzSjGpph +GxqRZzWOizN20kOgPbNsRW98b/SL1Gp6VtkC/eq+8KMa/LCN48lYMQeOgp/Nxt9BYu+lkPF1P17h +BPV9N/4aeR9K30HqUQ31qA14uyqkH38Hib1PdabRpVb78ad+JYgb1eBGbRxPxorxF+POXWWg2P8C +nQE7nwZYTOegQHeqDE2K8TwW4+Y1OG80D8V4GF3FaZzFdCq6DnbfjKezGM/48XTknA7i4WA2EiQN +g5jZZJNB1BzMhaJmyD7xozr8oBU9sgHJJiJB0ghSpd0YY7vZNKSu9Z80ozqaQSvHk/FGz2gEAdFe +AkWJF/npimkaS68qmpQZEXd56E0UFAo1TygTHssyerVxdRAMB7eeq5OFwoTba3k5eVcT7vAxUMSH +eINF0cCa0QYN2KnJUsrL2gVNNuzK4SNzbJgeVqCdBtFUNj7U8Q3wz+LWqRK84QmfbEzU19Xj4mu0 +k34TcdUI6LLSh6EK2IbClEND7KGSomdva2ri8XBKj0F9ss5fwRfJBB17Gk9J9tI0LFXzRgbE4DED +IypuaAw0LZOzuihIlwxBz3p3fJD1/uRAx1Z3kGzc2YRIoWyyTg7yeUw1dD3NB4KBxWMXdvKWOdQE +v8gHX2GiLJ17kbTCxsMJeWSQ7gOsFaVq4Do10xFQMhjVV12pY03JHA1G1nHTILLM0gJa4e4At+oB +NRJGNKu+UKPJ9GLwBb0Bol2FiZxbSGOCEkhQxHzsao7uAI2mdElljrOxCp/mgub0DnKWM/uA7Dg6 +QPQQSG5Uukzm6DiezbjHSiP+amgfnKazkz2vMUUE4b4Hr0INDntkl8lAHvkh2lq9thIQAg0zbXZ1 +mS4QLjWYIHTc8kwc3H/lhffDdU59TR0ka7CDdf3qakp9H4/vLMVl3Hepy9HNzSVvdXF/Pb27O7+9 +/v316Y+X53/8ePH2/INe6mL7q1+6j/79/ub27u+/vo/3vgg+ydp6aMZKZau9U0347/52fnr559O7 +24t/y3eDStrvLy/Ozr8/O728uP7pj7cXb//f819jddMW/ybM6Ie721N0v293MRf78fLy/G5VrI5O +z3751+ntW82HuPAWGcN4+yomXLaIKuUzvdhXCRSffAodxBkVk9VWq65gMfy8MD7+AnMVf3L3ZB8N +a+jKaQjWiq0MejL4MnX+uB/H/MtLVvBfKJGpSCZLqCZuuJqmzpWzEg4FFO3SA7S7lYh1oYZU1H72 +K0t0slbUBMcsaRjwSjN1MqtUN0lpilbpXSqjr6zrJqdLTKwvi6xMoR9zcful7dsr8o7EZe0WdZWu +L1AXFGKS/ooZjvmb//VPsTW/io1RNKziF/GDyJWvVAKIL9KXWhRkPna4q79rJPbi+KDrzoZxXazq +Kv7qmlCw7Szc+HmZcqSu4pDzzkR7Lft72f3uh53eFbHO+BOfdu+7IvHbs65/lyORuvZdMMZ/xHiM +TtRd/cSsJOo5ogvGmBE8xXszDCNZ1CdEb/ACMJq+FZAyJ/DWLR9zYfMhlU8/+iJsJj4ep07EZ737 +xfQfjKrrm2KAY+rEycG4i6maQlnXNM50cCKRhaeVmec0r2vEX+Rg4Sub7p4Gi2dTAnl+aGN8fNt2 +ZbvnpE5nsIxJl5zoU/q2L2RWqYWC7RkFUtaN9xey8UHTcew63Q9oyoSLEGme2cHbkoSoctWau1Pj +fVBldBVj5j3PbA+r+IaarMpw3YJlOjVPVVrRf+CqmAvzoaKV06stj842bvVocau4U6pGmuJe87ae +AjycLVw2EGjCt+rI1e+b5B+Zdo4mU567d5KCOO6e7HHu/um60+0gXjI6cw/R2tbvouzxsX2kN+uV +Pa2p4kRFgmk6gvngFkvTFzeZeqnO2mbJ16bt+r5kq0XSalLy84e3WxrPyf3DFpwyYygt/74nsOuJ +q10NAZGIgB/wgb7BehWBo5fDYfToaZhEBeKnoXGm7H7Bzjx8x8JN2xXO64aCMdHQrCd5j2LHH3Rh +gcWDl7+B2MC/EZkL76U1llcfM60rxdN818K63WhuxIzEMCbzkDll15WAA4tt25yyzGzjaG4bYPWQ +IDCjI596s+Q/Ol7/45BbL0y8RtMcah+uDhreFE1/5qoJNTZ6Ahk6SadrrAbl7j0hrOOi1aFEnsN4 +RIhEC939Q0cEGI8q5h6mz2H/Kpi6Uh9cIdeVeqyPVtBDm9M+VtjFS2eHx8TClo82aBlm0wqBuNlR +AV5eiAOk7lIkfJFXG/woy4Y8fB0aW5Grl35XgJg+ZaTw9zWYeQbu6toZX8nnVx0ICkDfVPH2Et4E +bbi0oxKJwZZjUF9AQwa1z9WB3gHdFdT3UCQaaiomJdaCHhKrf8OrW2XA9W9Xv/teRN/rn1a/OTr6 +5uzs49Xfbu4ow2ZYPTk69URY03MN7O763n/T935NuUSE1/T0d/nz6nd/ubn72/nZze1bwfz/ZEfU +cljxnhHoHn0w8H6xE7n++Js//THulb+/u7m90ldxlLK53978eP7mmz+1b6QT39/9enn+pm9av1o4 +a9nhER4ydH0+HceTKyW+vfnXBhc0fJnqCMcMuC74qqXKzlal59U+Bt5IdZgSZc8MnHaVUuDyoVBD +c1OTZw7qMbHXTex1E1unm2jqyCLHJBED6euzM82WjFzOF1dU+qVfQ565UmfByDOz7OdnmcGdOANH +osQ0+wZn3kNMs2uQTNHcw9EiDNCEMc+FrXFfkSqos8eQbZ7VytHsViCA0wjw+RjnNexyrV4nMbcy +jUgxYWWCneQwA6NmvAJYgy3WgbqSbCDGkUZQF0uBa7jLOl3hO+zHY/x3I1MkBHil7LdhzsQH2G96 +zjn6PFgl4T0XGwLa5nwjxLYaMd/we8cJ8XDRxvH+7bON2zxa3CaOKWc/P9PtUlojJL6BbfsqA8lS +6/JkoDKCfHfFWAeCWKUXynSgfPlL16TL6kWccvlnMPLGW8N6GBp9AFZNYXEIJ9NRpdOt7zVvN670 +DmHblW/047w/XTvwTRyC8tE18eJ7+cjYwVfZTE1BXZNrQA9LGxFNyk+RNiZduxoAu54wDncySwNo +NzYNmrNj4Jq5YtjmeLbWdOrTRJkCNMJUrQ8aBiu9gwhZ108izSxaleycb16JNPOHm9u9hXVvYd1L +MXspZm9h3VtY9xbWvYV1b2HdW1j3FtbdtLBO7KlXB1PjabHGxLrGEPusNlajN3Pca2MF12sfK+sQ +KVZWi0ysk4aPljf8VBbWYo2JNbenFmvsrffaWIt1RtapaTI3XU6LrIc9vZl1XeeZESozs64ZzLqC +n0c7UQXcX2n2ttYn1U6cnL+729ta97bWvZZir6XY21r3ttYntLXich9mMbo6KPUKQM04KPKIoeko +wZK19YSsWIzwHYOSsTUruAbUV5+1/7mNqwaBdwiFba0S6N5Y2aLNoHZOJhca2lYRwIYbux8s2tC8 +NDKuLmnzaHGbOJa8F6b5M7PbJe90hEaJJk9niQsJlkxnJxksmTIBqyYw3HPYuLWgZPDMCuag8l5Q +MrZloNRZxSIG4ZaDXvYfpJsHU19pzytbksm4xcq8T+l9Buo7gNy0jVsHGcxVtWb+xg== + + + 7a+HPShWfA6pYto5ShXTUfTAfrBZ8bXAfhxqYe1mN283/2jdVG0qqhSJFiCtWS1YH2CHegIRZUMJ +5dXYT/928dPPexFlL6LsRZS9iLIXUfYiylOKKHp5aJIjYoiMrXJpowNlMkkquA7USyD093QqgKTX +uXwybPwZhZSgA7pPSEF6nco9UrSxmsZktpQyaXTsAfp4o08lpdC9Mq5dFFJo4vE2rR1f51KBQnou +NUF6+YK+eyMIlrzy60CZQJMKDkHlfaCes50Mo7NTpBpz4SSC8uLmMOVgmcAGI60mYyek57xZyvk0 +e8PG14KeXDCZDDhFlY2HnEFzIWQ67B6Wixz50LNWh6LLZO7vFUq+eGngH+/3osBeFNiLAntRYC8K +7EWBpxMFEhtObr/2KTCMIGQstn3cFnzxepBGdXi9ONuXNqxiFJjJP0uCwhpIbPBk2oenDArj7T0D +HlsGptw5EquviQkLj5RskPizeSAm7LEmpyFhjzSJ48kOUtZ/HnGgC9TRNBmdQNDgEBGALmDi3npI +4s7XQaoxhJF/cdlVHFgH6sploFR5kXjRDJQC0DLQdDSdXDB4lYLBUkRS1nbf0BTUxTJ18zGFdMVY +d17NtAf3AB8UEATzvBG255MEhPEgrwbALGRrOtAM1g0thnYNIGtHFqPFhlO+pj+f4mVVaD4L3MfK +xK5G+kqH7eYpLBiLluM1ySx3dzIQIVGr725Pr3863ygEDNZf3OoBH+l4EDXCDiETfgIVoToM1tsV +kuh6XIiVACXSpaaHonudKii6GlIrHeT4gKAmA50csJztIZOa83bHnYqFU9lUfd/gZKj3nncm1Mrt +QGNWd9xOWVUPHniFcBq1wXWjpqnkyOChwHe4JakMjV46JByJOQymrEZ8D9Lm6+WBD5eGxzPSp49i +KRa2fbRJ22CM5D8/PgJtU/rAU621JQ5P03jvk1rN4Qeoj9eLC0Qo07v8cCgyD1GHCi5xQ7Kalvet +JJAst4u44Hn1bgKUsrTpd3qXSqfCHTLE5xwZXMcPsVTVg4pxtUXeZjHpUVdB1+kM77uWJ4PtUihl +GyLxhPm+yboZeAlighUIRWRPgqAs0wEkiHY0PuAt75lKNXQVZDtj1Mu+3XGhca15k5MOTfo8Gezx +dPz3iZe9S/Go2zxCJ4ObDD/vqRToH0/yx34ypxM+WZbjvDvZAL56s2ZUAhzXOGl02MdhF8cDGo94 +vHbHWTfyXkzm715gLgZXbr2Mn06euubVUcgaXyJfuexlj5QKapiIb9PLk8nn9xLl1kYJNLjWr7qw +BS9Vr4ltY1b3xlS8lsbgIqQm5+nLNhw6BPoIU4/bqQYyqKwL8k1oNNSDZUOlV3cLOVzc4NEmDZbx +UsgR/f1E9ZiwabzV3MUk+bJk7jDGFp2kt+nlyeTzRMDqWuHVIbPkXyVAfBYSUmW1Dj9eA3j6mIRJ +h2WfZF3sPui6NCnyBYQiVH79fv9cFx4pF2s/kYsVdsIZXLaTGNjKBTyBnPNNOMStdq4HKO8aH4ru +dSpboHCqFg9yQGVPyqymDyfV5I2Me5D1Luv28WAQj7KmQgN503hkTZ0wYPXDUXe45QN3NZtG+JXa +hiGHV8OSWmsEFm7bHMb4+kaAvGPr4cIB5GkSi7es5aNNWhZid9g0n5st7da7onEH7F0TXHxG23HN +9VrfBIgMkNU113epKEt261yp2WXwHPnQ7uNiXFWRt1NMelEMe1kMB3E8GlTHe/aorXasISBynXrB +Rs1eNbHd9tAYXlyeINqt+IC3vLQ0FdfSPaYP+hTbGnw7rilvZtKJYSeHYzg+GI/pMe4y71XHWvaD +yHvGu2LzroGR7B5P8sd+xkZTOu5u1oXUYzmfppBBLZNWhp0a9mk8gsH4RmvUN921XMyADDjHKrsx +MtuD9/7QfxlG2Q0bd3s3zFQLEJMWRZAgTjhsXZuBhD/j7VqIqaTuLNR6URFDaX0bdyru0MGNm+R7 +u+0FawpCYrstxn553hk/2HaVCjjxHnC9vL7vnT4fHwx2IkDZTk+gYlJvsa71YtLHYjKMYjrUgtOB +uz3TdBSYMV9m8zqdaSTOWHcl5JoliTgyXBQBbrAslHI2WBgtt3BpBqNJi6P7fZPlUSFygwVCwc2W +aLTR6sihtWPZrD3Uq6isBrQLi44TO5gOUjWagbiGjkmqTs9gZNLvgi9lPlLhQks3q1R/Bzg7aIQS +eJOBhMVtcQ93V0sCkFeKv1PzqXTq3ngAx5MhzU8BBWNmi96XCP3WQcpahNau4aSgNsOtjpoKKj4U +wZT+ELkEhLMr9b7x3nXhs0hm3YQazYJyhQml+aoDyZz5OKGugdNPAvCIjL/Tu1Q6Fe6mLz4fAyNw +3V0HEeHEKUZoDekZtaffXdOpcDGuv+gbiMJihipxZDWubGcWuwgShEvV6z1xCcC2m9QvfZdKp8IZ +YsSGZewBzn4JEmyaG60hPXPebDep+jIVLsb1F30DE9D9PMbAH6Jv+Cp7GresldrRwPRu+uHg7Wo8 +Of3E4evJvE5mfjISFJtMwWSS+oGMb9Gtmu7sj+4TIknrDYrCh5Y4HojaPuC2x46YnnSf4Svb5pCu +4OdJdAGrFSWEeLewKzsluCphhBSZplYFTgOhYaQykjOCmqyHC4PnsqaJKqOFLR5t0mLJHCGfPbUF +bXu6DLhVnCxZpfc/R60RX6e3J9MCmd6oiS9aV1dWNUeNllbICXCjr3tcYC3oWfRHfaNNGVmg2NEc +iftP2b3SD2Bd8S9Am9Qltmg/rxrpD6f/vLm9uIvao/9IMsbnvDcbl5nj2ubCwa+qgrlB+MKat4km +EOSeGnQTABjUkL2shfLDgRWsWnXKDDVUTbbVKz5xJ6nx6szZBscrtTWbldXn44MEaZHDRh07kOEI +XpayqXAbqJSVF7w8mhY6RT/ctpr6pm6nFqxv9xFraZquFl4zmxrRa2a7XpzoHbWG14HHnhYcDCFx +MLyXF81mI6ZoWvPS0TgtBWfOVf3MFZxeHCZZf5t0F2/3lbQrvBocLHm7bpWNExl+aqgIcF90vN4z +fYWKkDqmX6jxYh53PpfxhYwsrTIS9njbgwJsKaFii9zTju3Cr84g8d4xSbvRCZFpwwfOhvQBHUfD +YRDUDKkOvWWFV5O68YQkyLH6B4ayzb+q6QZFAK+HFYDebOyk1VaTGcppboz6I5ehphckkpcCgunj +fOphXwfNf4hHWpTrSt1JDw2swjLb3sqoVCZqZFJXOMIqkyMc2GN2l5/4+AmuBPea5Ii1gG3GnbaK +1tqSXo0bUb8OVISyq6brKj1AofnrR8MRe5MPmbPi+1nBvDVNNm+TZT6ervz97q1P7DFSYQ54z6v8 +dSuPq4B53av1VkWQ7bru9X+cX9JtnmT32ycgvdjZttFrkmr6ShlIHKGlH2dAPt5DvWQZFKvk/6Em +yYDFuEQxrhQ3BleKNkBY3HidAN1zKtMXSdWmWlOb7Ae7kUFGH09qGzU37s60x+/gxl1iv6e/V5pX +Fbn+QORlYwrbRZGTqKOdzkDF+PNiXKN8T+cS+T7gdCPZiICig/Br0ri+WKq66OpODRfsTMHeAGa5 +MM1qUiLVllU7aXvcu+kAuI8R9FA7pZDeuTredlVyEmSrwWPJp3z6QWgB9Tc8NzII74eOmRgTDNe7 +B2SQRj1yjJJ2tvR9pOqornU67GHpnXp+iPhl+UPN/rLCdWP0lTDjgZfHO1g5jnmlvSPBgwpJOGf1 +h1SBGw4DnB8HlUTNrHHw6YZPT8ojh5QVji7whUUOa6smal0I031Fjg7MvsXhZnvI2YHh2WR6kMh5 +rSYpRQheA+sw1lDPMR2ug7eiawghbyHTVjLio40L3gECjgeZmLODDiQrU9U1YtfiOIUmUotnwDxZ +OgxAiHB6Q3hTti2urhfBtA68NR3nZOAN4aXUw+kwpal4ITvu7pbtxyvCA0NPoALy1vDicec924Hv +fKPtwJ3+EA6XnESRXyoUwtnCcweEGfegy6dV/yR7vcJYjg8yUAi+Ub9cmZtmCAiU1A9VPSgbgRMr +i0+DtPSrtgjvCxENfVxwXGWO5ZIJIq9kmNGUfnG4nR0o7KII30ubh76xNbVATasXnMvJDYBMINyO +MQ1t8GgHOOpKjrJu4OxAFK2JophQ1wNCnHQWUhBaqIXxgstppalYXSsn/WQzYpOCLwjklNDT2hp1 +iwdrYDsQuKmmapkk0MEG2gOwMGXQJYogmQWgU1eJ7EuvzEpqKUKErghawgU8QTzCaUG0tY7usWul +g8SOdBWknk6Gc0Zd+rPcEU/78hayCjdX55FVME/CKjgftfuCAiYEqJXktBSmWzMot7IXGAUTQa5U +k9cJUPZeEDjasrbJWZxSvfpMOrLHbFRR05aBDDNMByt+0SqgOqxs4N4Tmb9tchhrYnAOAO0agJYC +QOpF/Etf82TAJynTeallbc3KruQAVENDBJx0gKbvZgDLCZ+yKagrVrDmENZA4EXO/EV6VYtOFBj2 +hjaV1KXss1EvH1bbfL5NIsdrLSx+JUcyDg6PPa75kltTt1u4cb67/XFVrI4uP3L7mKRFNXO3BWUl +cp6kx1cdxNlDJZVBL+6hwzMJcpGBCn5e9Z93gFQjTtMEEpTUoz9WYBFhZBA7lH6dHYzfdT2Mhcc9 +Ppth2HHut/EDBEIYD3cR/IvgVDIrDgdu5VZyfiOoB/oS6H7ZllV6CR7VCz3iRR+URnHbRyO9dSKL +9eadTdR0M/v0+fV1UYtpIMYOp9E+No1TPbkMfuj0SVwc4KGQqda6wPge4e6Q9C2BRBg7JKeDdM0t +sCQBhGlryboClTqYUD6jAbOsBiIZzor0g4hkSqpyCGDJui/ZP3e1J1DqQaohdbHv/3E2llmWReg3 +NezGe5p/hW12esmMcNnNmvgBod9G/lHcSw+8ZEZIE7x8TZBDQJimaVR0sI2j5dCXYFml2Spgy/Se +FLQqGlA4OVNll9WtnqW8PwGyYgOrpYvPMi9V4FRJ3VAz9YA4d8cHCUQ2qGpWqQYIYU2aO/465sUZ +bd2EDlSwdNWX7gBZCxksdqOrR7uZup9UdniuI6pZ3ieREyzggUxhlUOytiIMCiK9OCDW4cArczzp +17GSrKp/l0hUKpye8+nqQLEXqY5CA0tcrdpCKgo3i6aetHqVAVPXxl3vh6XB1qNRT+dlMnksN53k +fA10XIy8zkY9mZLJAMbGw6a/VAHyTN1TGghzlgZtR4Ml3M17mLDd0MzSW5dBLZ3WGV7WkDoSQA87 +IfvZNxY+0DarJQFSU2cHHQiCZ+NTbDWqQei2oeCZ2uoglE+0Q/1XXaf7qiZjm3MEGv8Q8YY4FkmN +/ix4u0HrbK3e5XpLS0doMN0hm24D6ZKRXSLdlj5d8x1hXoUtsM3GuuifopHnh8lQSYDqzcgGZx81 +IpWGKqunA8TGzg4yWHfTR1dRm1QaqbUIUE1U7FL3UdfrrqLx2D59uuWcEepf6YSnBw== + + + TYRaixAcLDTWpV5PGWdcQ2ph5he2p2L8RAdqEYbVqLU4pQhS1Rm0TC5UHUBnCuJU9k2Mg+9riYDU +0tlBBxIpvYo+u1oLktuWLmspAXRy2Zv+m9jfvpbRmD59ZqEOQeCH5hKJD8glAnUH4txKqHmqHJdb +uBKVejGPBll3EGxaK8xFQ4KkGEdNm4/x8x0AujAX3cciSPZpG4wqQWM9GSg2Ri1VB/PUfqy6qkT4 +qVoX+uYSANrR2KUE6ocRaxmP69MntxIZE1fbcXLTA1gSMBG8lEmYcjSVE4qM/5Md3WgcXEnvqKse +0saYESH1VLgWDJkLQDBVOHUAzDQmw/UgA/EacnaqpQPEhrg6HQQKw1VXCdIl8Gqk1FACQPMTO5NA ++QBYy3hEn4ESw7/PJ1ocHwpNdAZRnxdfOZdLHIUgnLcgdThjag2f72CI0aRfIZTabUl1sVEeOtDn +y/UQwcZWqC41Yd1XBuoq8IJdTR0ktYfNnmBCwpwNXIxYE1S/pDRdewlydtD3qvuq63lX02R8n4MC +4wytEwXWB1Bgp35wvDXGg/m/99BzIqDWhgoWU7YUahIIenyrdsy6aqmj5MkB8yNCdNMztrHq8BNE +XTh9X0UH6Jo5O+hhBrccuVWqRfUt6m/AhjrA2UHqSwfq+h8rmYznMyCzzKGJx1z8jVQqQQ5Uh2PO +WHiY58SYQuOIaCBjmV9RHeBpyJITM7Q19crUpFvYFNoYFIyTRsiQsp+YVkgKx7izk36YnUHdNsk/ +Ho5NQkkF0CQSwQjyM7hkKMcBE3DDDGuaGKeNhg8LfTLWSArqPpClqMGrGqYc8eoUB0sM7hnirbci +zLtQN9BsMUiQBknPjCu8bIqswKFTJX701qL5sOEHVBwf8/B3rRoL07Zm6BnhARaS4byd3Rs6VKk7 +XNnS3QuzyFweZQtjnMyacxpgWac/ANINE8YIuH7WFil/mhhcxKw7dUy/04RIhoPVfcCgVznwKghz +us9cW2lkkRfUkJmEdUV+iWhYrSnb1AFX/zk4ejf+sKxbTf+IiUjeF75s23nNwnUOaxUqtUqIhG7X +lqyBQM5rsHsblDLM6zHVRPRfFgIjXH/w7WMphB7z61q0LE9zvXLTyBr4mX5yScO0Tq30IAI+rGei +GaunFUL1HMxmBdwYW2xNeum0PqihXwOYqTOvqKgvsblqeJ1Q2SFEF6f6sVRUa3wSQDgF6uSW42B5 +xHOrZkA8w2PmDGTJqOuSSFCwq/LybeWVaRmCQbsmE4ibJEhgcfIwtYAccWSRKziCY+OH6FGF3pJ8 +CCWIDGNK1mmx4+vInmCIJB9BWZgapQFAUofjA1IHcIU2OsUkhggaFykynbnN6AVCEOuWKNm2Nf9S +Tihh1xQC2tS4CAKKJyMHVoVSIZIN2NPIgNWk0LQf1vTyQl4O29rIaraGrKbHV7LLQDdE1q4gyNEk +E+Qb2Wd+TXnTwGembaDQMCCUkOuOlHtp1Hgj0wxjyby2QQEqZEuiSRMEAulR1hSVXc/Dl7J0670S +j7ndjrJ4rTo/epF+GvnYaJWexlsUGNzYl6ciTa7NkO3U2GicblVbXWmSJRzMrlGxi8c5PR8NHeU0 +gQrcQEhn6C13GFpDpwQmXOJXmujRMTeDXjDJO+0KR/6XagkLbQbthI2KkqZWF0a4YAbonOD4TdFH +yE8IjZrWBTnpWUpfe3QQ3DMM6bzkFdtL+J4kc5+BJQpOOG7wO5S9kDlQWRf6EuAZvQdrD1w4htlR +TltNKUgdgtWSYDebSh0IBjO3MRGpYHUDWrqGB5sxTt0DZevIwEtozTFWaeyQIoEKqP4w6tZg9KS7 +QulC0CwbRhUBIlUE6lgMUivUdNeXI93CuEydoHdwYm3XlLYyb6W67RgnR61I5Q3952H8cnWSWst2 +XsNHdFcr4Tcv31debyYZl0NYg28RVFF6yEEsNq+/wmqXMLGSaWkZqvbJdGPxwjzJ1SQiK5WmfGmq +MczhroZxqsrgycJcfXVolSFtgqOcUssepAhGVS72k21Ve0Zdsm4xU6mDmLpUgWNlxZVKOQB4r4Va +iNyU7Sz9dZjFKfDmIDWqwV+OXl80aNf6CZ0GVdcalZ5BsxwWZCmC8rCqDZHW6CQGqZAXYJ2RrNGj +QBAO+mfDrww9ED09e7WcWnJ8DEBXckgRhZ5nqjbpzCuN3uE5ncdN5ZbgyBLrbeDxb4QKnnoGYIJX +Qx54nvhkQiowBU6VFoLJJNTG06Fept2omtaDDMtqyVZuhZ1oNUuMEIOamXdkrgIEUb1TbFQaNwEd +0oMvhBK/nOaqBDPqGsZeWRnQuqLrGj7Ss8m6ulFvLePs2qKyM1OeGfRNeZd5XdZbcNsKNIjTYswn +iy9LV+dpmA9Xw5vwZckIvMTUI9GqCw8dkyoyFjjyZQdr6CliJfR8566HlzvEGDU/krzIacxbcoNQ +jorPat2K+hbIxXBzEnpRQ2FLfZT3qqeiTkQjMxx9+VrdqU7fwG/Tl3QRBXNiogGLsc4O3pKlbtmo +cW4Oo8MfYJEINopDgLSV0a+cxoiUCDOh96/SpmM6xaqKS87WspZRQFUEz39QkbryVMYMJ25jZsPT +5/FQY9EPYZcRYoRM4LYWflsVaTIJ0q7zoVdytEiuJQTDwtsLXgVwVgOVrpxqDMBHWR+FfhyQP9AY +7XFOQxTzbYzCnRSuHTg+6EqrGqaLxtdJx9GCKjnI+rinYk6rR2oqspWhuGdLY9YVFAIAoVfVclSw +Hc3trlAIwVIoEWkCKNsyfDqnsWxVnoJAwJu5bNwL8xmg70wIUJjsghh43TbRQ72qotayamLsVqW+ +uiI9tupMYeE6RZ/xSp1jAcPR75HhxupH1EDDjZlf6yd1G1UOLc5rbEamNDRN9GWFaaslNUBsPnXS +8ml0wGa4TdCcccrDlHpjHQgEHdzlsCFVs3CQb6MvukjZcJsFwWhp+EZqBOZgVidkSzWNIwAGxmOY +LUpyGXQXLKOxFx7foGSkOuNJ3JivYK7AUn088aelkr4FJfKh9kjiBi4/xNi2aNWxTQkWvY6bOeZa +95qzSYMLgsjdh9TCBOHdpEqrsgn0xNARtE6grqzvKe1oIoKzYlM1zSFDro5oLKhhX1TdBrn3eW0f +4Y5M1zRliMoN7+4rCla1paeAoIy8VxllZr9RXApSuxH52E/mLhau0RMQD6aREM7qpWWUgWajjTw8 +5A9scSiwcbrKPqFHsfNxHwuWCE+gBj2c4JYOSgwR0bhBbkRcy0HxQZ6hHEVgjdpUhRFA1AQuFFE1 +ABl8qB2kHY0i8TFaAnIi/rbQejkGM/Hgp/XFVeBfGqZXh/tXzZjN1oAcyBlIw4ah/QP0xsV4KCGA +NSiIKzXReHlIjSYd9izdyDVehvGzVO8KNQPRojEFCjCoY4XejedrYw6jrUqGN1bMdyltNhpiY8Cu +WWFnhK9HxEAbbFRKqz4DVsGSoQZepKgV7vu0Xh3fHMk/eXOGYDLXmatrJRqIWIRKcwXPPyG+cuRP +CwtHAFscpCwrtF8X5ojz6GEGganMy/E7r1nseQ+OAzEnpgnUKk8L1hARUwICqJeO5naX8k/APElZ +EDjffDqXsXxlnkSh0SI0f27i+CciFp37eH5/SUvXnBjqQMeuDgQPK9qy2xgnJgcb82mkn6pYb6MH +BUEFS/uudP+cGlCZIcKapB6I1SAAAoavsv/J8CUNdYuQvs+x+GQQ9+7jRo3ZMXmiSFXMehHihIh0 +JHMqh1oUwYShtggEtJOsihSwYGPyciDSgzy7N6JC4kNsHZy07HGXMcTQ+GgdHFn8A6UboU2+CRpR +P0yruLDpo6VNszSlM7WdxO33j6E+bOqaOkWkDDgDleCNugEy6TVBS9CJV0IvRqiNM3TMwq8n8vzP +8m+4p8m/oeEpfQbX8okCVJAdYxSgoqBPCFDBwX9fgEr2bh+gsrMBKvvYlJT17tliUz4x8d0+RGUf +orJLISq1fTBEBa4+owgVgB4JUDHPGKBi5gSo0K1pEJ+SD+wzhaeU8YbQ9NCFqJj5ISo2ixq5ymF5 +iIqZhKhUq3GIii0/U4iKVjQIUalWkxAVMwlRsYOKxmP7TCEqNk55euhCVD41RqUZx6g0kxgVhl0P +YlREgB3GqNhmEqMioEGMCmoZxqg00xiV5gViVGx0i04PXYxK9TmDVNQrehCj8tkiVIbxKWxp98NT +VKzMw1MIycNTmA5mW8JT2Jk8PCUNoAtPyUf0mcJTYgaRIj104SnVs4SncMzD8JR2Ep7SrglPacfh +KTp72xqe0ppEffUhhafU5jOGpyDf+raEpzD3+6sITyHKPBye0swIT7EzwlMi19CFp5hReErdfqYA +FSSN+tQAlTroQb+lESqNxmzw0o4HI1SqLt7DrimbIlSahyNUwrxmH4pQGZR8MELl4R7vI1ReOkKl +UUZtNyJUpMzyAJXGPRqgAl5lH6CyD1DZB6hsFqAiUzMMUIGWMw9QKdt6GqBSbhigAu+qQYCKWR6g +0o4CVNpJgEobHg5QKScBKnbLA1SaLkAlxJgNXg4KT33dTItjVAblU5RKWBulEpKsWpu5jac4FZPi +VPRe1mlRhqqE+aEqo+IMVmlSrMpn8CDdx6rcH6uC3fFZYlV8vFKwi1WJOr0+VsVtEqtCvmEUq2LL +SaxKM4lVcWtiVdpJrEqYFatiHo9VGczjC8Sq2KjwMJqud33IiA0pZCTksSosEwM/7g9VgT1PQ1Vs +HqpSxVCVspnZbh+qUsdQFbs+vAahKrgLZU2oyiM9jpEq9T5S5RkjVUozjFUxj8aq+FGsih/FqlST +WBU7ilWpH49V4cUpTxOq0jweqZI4rm2JVDEaqOJToIqfhIyYNoWMmHYQqNIFfkyLxjAVYaximEqk +EAxTEfKvYSprCq5rsw9TcTFMxa8ryDCVMqQwlaYZhKk80NlxkAoOqn2QyucMUmnaJwxSgfpyGKRC +P8VHg1TMJEilmhOk0oYXClIZTOI2BKmYLlzDmdlBKr5ZX3phkMqjbd8fpDIpOitI5b5+74NUnjVI +BYrEUZAKnE2GQSrm8SCVchSkUrXLg1Rw3chTB6n4xUEqfhCkks/XCwSpiFzYxCCVGC1SpcCN8GiM +iqxrjPoozbRwilGRrRdjVGrTxaiUbYxR8fNa7UJUTAxRWVeMASphbXzKw11N8SnNPj5l2+JT1I/n +vviU7O2nxKc0D8WnZC/38Sm7HJ9yHyql+JSFyHR/fMp96BTjUxYi1D4+ZW18yt++/34QlvJ5Lx3S +O1IRSABndrqU9SB/mFDDec842JarCuU9PPwT4IzXbOJev/6TZlhH9xybUQsNQbxakGkztA40P2gm +AeKdhehK903qa1fJeDzYXuux6oc/n/zjT98KRv3m7OL2TBbYvvnt6mtegFNi1eVlttAhZiGg9GTU +oAUfGU0VQNAJQEI4Ajkd4XgatVo5mIxos6TrSlvrtY8tfJCihyeGiQsEy6jBqUqYiA== + + + hJuiYz4aKA0PoboOahaLoAIhPMgacEK/GUOPafrCVLxWEDesCrxyAY/DIRxPBgUveS5L7bKBUp/d +5F/BbxXcCnwjQqmipOfV0XgTGtVHRQjuyAtN7LTCEpqcHNh0G2+D2wPZamMq+mq3mjFy1J3jSQdP +nuNqMiyOW3mDS3wN/9JPCOBKXdq269Kl789Pb89+1julNZLos1MOKNkRBg35AimfrggKUIBT6UpF +B4yscMIy0e4BfZu3jFfn3gb6Qy0mPytcWSbH8iV3hMg9dHFufaneGPT9EWGqqisFwDVrBdcB3KFA +x3/ToHF+K4tyCanMO1+RgjS1obQkAy+pSWGbvHoM117CLb6JdMnqtQwUg+TsumQsAiUgXLAGwQw3 ++5bxmRkVYZ8BhWwPufHOprNzSSydRJ+098ehfIz/Yekojc9YPESNTJZFgYsXBuf+ZGkA3GBxpNh0 +eQS4yQJJsekSAbh4kdbMFmrCgfEPTjxX5Ks3/ZosXQuo2Cw1vQF2ba4FvBmhAXAoUyI0CV9C31bS +VOBtaBQI70lwpBCvmxA/HFV5L/AdyUvq+D/yS2lCFFae5LL5FjK2IULVsIHRcque9glkvGpEAbDA +QihLWh4D0Hg0uHnUhkNLDhVmTodJ4MWxhic8RVjc0g5FLZWCldGTgVm6cAZBh4tbbmEQhjsQXD7R +NSpcXHIBhVdZVdcdxCOJqeUyCH8feDFmzQs7vYiDqiF1mqUuXVbLa3INE2Oa1gWNgPJ0UOEt4g1D +4WQ03CPAyrZEjJgIB6owlklB3svxvKUAvAQnJyXfXR0ggo/K2QQS7Km8j5nzReTitmlUaY37TIPe +5YrZYc5R4b01TqfmfaF6/aPmNISdWfPSY660nNO7V+G62zIyUnaTr7G99aJfeOvAgUPEJgctyPEB +fHY04MPBRQ4cCFXPTXRITwuRnnntOX8lCKxr0MerN7lh6HKpl+Fa+uQcw+ym/oUNonxqJoiJ1+AY +VVrL/okuy9VhVZcsZOmrR9WaxqiqCyI0Vh65aHkfpt6/TgLJ29XjXScANU6v1yxNUJbV0bwoSOid +7ZdkvGrHk3V8+L5IOIfKkhjbztRoPPc9700rzJlvcAY0uOe9BbLAAQGX5W4hP3R3ersqViLy/frb +yBDFO1xnkrUSqCHbWiUkOEnx8ORd0icHcc8HdQItCYKJ0Va85VdEgCqy6CX9xYCz3pBSl5SB67bG +w5r3a6qZNjbpUN/dOQHWiK+WbW1qnNpQlnq400GDU1cttF9jrZfFtcTqNFzE39BLIhJZOHPaMct6 +EB4Wg6tlf9KW4KClhErZlQ4RLVCSCGGFArGKlz9Xwgg0IJQiFIoIH2OrIRxB3311AL/+VsNBHTXa +JwJqKvoI9rdTN5EHAajU6bO8LotGu7qFFZ4z6nB7FHwzLMsxQAlmYxg5eJ0svP4Mw+zg1OOVDKiu +HT6ggTfH+pqabqwHRDEuBKJMm0qv4J28LyaVFNOGimlvimmXizUDK9aMv1gzTcWa2cxm+6SPBodf +BCITrlC3N4yIaeg/w/Y0Ea+cnTWrNRiGYxjzCfdNSgNqeSlxSedpq0R1/HJQdljvmpazro0eZkd+ +a8j3YIxfvVnTlNDIQW+EbuVdlcfxUFBrP1LlrMdfFKNKinEj6+Z70N2Tg2Fot28iowdCJ6e+IIcQ +EgRhtzGLhGw7qGhrurYkTGPYTBuZhRNIURqPg1vjYd3BOKyn36LTkD8aepoQ7ZEwcx1Tyc04EOo1 +rOOqGTqXFEhEHxiVXzPE3XdO+ycHcOIDGSroZV/qHoIWgabPE8h5tcYk9x8gwI2qmL4aBNtpyGff +GPWYuKIq6xOjlxByIAvCSKST6UydPKDsxpCF0eLdhEVTw+1LnY7hVDihmwhNbkDMPRg1sH8eiUtq +xmuGpopaYkSeChaAzVUG+QdE0wrDwuzH8FtDxMq6onVQhUqwTTQCHZ1t3OrR3FZhVWrUjlVDrzVU +a9/Hi6STvlyd3Vy9v/l4/Xb14efT9+erq5u3+TH/sFp8DV6ronuE2Qoc4TZF0E2wWzXvI/wGsZhg +uIiPExz/6s0aLOdW7vGcIvME0wU6xXWShgm2R739CN91GkYYv2YWT+7Xxy9Yukw9bp6HM31iBrLP +E/XxU9nH9n7+0T3EP9Kfdw3/WEX+cfT+Uf7RdfxjuzEDadRk2kIQBFNnGmsCGUgve2lNfh6qmXxK +3hAfYiR8a5AWqnUQRfP8PJ8pO8+Ag7R0cRlykJYeRgMO0kZuaTkH6cizwQHrXg7Sfw4O0s/iIPPe +LOEgR+Mv1kxTsWY253GQbbuQg3QPcZBuAQc5bHkpB/kQwziseR7D6B5lGN0mDOO4Kw8wjHU5Zhix +kTZiGBHJ8lQMY92ahxlGtce3TTOLcRxWt4xxtBPGMZ+xz8w4wlVXWbh2KeOIfUkWzs/iG03PN27Q +6NHMRl+cbRxi92K2cTmOL2Ubh6h5D9u4FtsfZB/H1S5nH+0a9nGI+c/JPi5n5i7OfjkHP/e387eb +MHOwpzXqQQ4rNJJ3KqSIfxM4PZfRJshvupfTr9Kvs4Pxu3HhrOL4E37mAfAaYWgwZQAnnNEweEGC +sgzw1hQer6xLfhkQ6nSC5D7GO2YwCV51bpXwCF0T8cdxP/JZTKExJHO29QikAe9SVrAqlXRtADWY +0LkaWJUul04PBblBIhuSa2vyk4lqsa4qoTDQY8qwO78rZ/IfzoqM03J8IWiYFLWLKXEjrKKaubEq +65AA+v8iQfWxVL9XnXemCkD+lxJmUA3RY2oEx7RcraEJwNA3wnCJEIiFiTc1DmimOygr8rWIx0lN +6F9N9pi1Hfs16mZJY82wr8XkmyLV2ed3tBGRUxpJ/S8HaNVM814zcCi95DsHM1FJOZoOxvD8M7Dn +OfhL8JZAvTMUz45ZGQFpNIcOIYYx+VafjT43rnvkVDNLbM28USBFnDPjgeh0OnZMQcUA7djjfBT8 +y3A+u9IxH8exb6IgdDaeFw9PmpqYH5i2M1qTl0wcMt0unLqv3kwn717Yg1OK7j48qZPskm3GUe7p +5iy6iShKZSN4TiMvGAOLS8q2xqyxx/igiWJJNtNDQb5KyKJT3qxulDcbpbv1rqTJvxVpu+EPEypm +0hJWVImkMGlAixKB8IhLKREahXClPdnck8092fz8ZLMZCOLYEuCJRP4ILd2IEii75QpMPjQ36CD1 +Yb7ixwlwJoKy0ejhCEF6QAgN8MJB4Aiz5jAoORwyCyQkQE18VtDZJrRg+plHAHVUq17w4KPGJzlS +LQLwfzqo5GAAElnHb2P1HjkYktvWMLFDpcnnHDxgHTI50eqpWYE1B5OL8ZJxIlBJOkcGc/VQoAJI +q5O5BkdaVBb3TCLqCd5ta1hT50XUo24M6cQRDFmBJBiVj5FskMG/Vq+9DLaO/ikigtdIYMerpJAC +Gj5Ca4paX2nqOpHDkbdAL7rZsNGjmY3K4sIWD+ndMqRzQUDCGrzsgYswE4LtYtz86s1S7FTKMxc/ +dSxLMTS67S3E0dHuNwOmabAG6azVpJN6Kjbq3NiAGsILEvpWzAk9Gw2O+LLmSQTZSA70lg6R1FhZ ++e19MwDhK49ESU3NjEQtkp5I1XUEIBuuY04FF3PpQpNs9UbYoJnN28MudSmTPjHNCkOXg6ZsZG4W +elgBRJX2CUAxChtfOWptW/Who9ufsmXMX11TrWzSc2TneKmobGBES5OvaOGexit9MemuBOFuGDvN +s7E0mqGZSclODugEG8B7BK+WEkS38Yyge+AJeRG4FpIXaZQX0Ty4gOAMAsQyuhv9sQF4WJd0zxuz +J+nXvWpCX9MvRyprmfC9DrI0DKlqy3UkChhW80yF5w4ToDgExvEmLcToqtrNaeqygLxHTAL5A3OC +itCsmzLAELi2aFXjkmYkYRNyyR1zdLZxq0dzW3XIDoqETybwMrABjTLDpLJrmI+0ZdR3eeGmARWY +bBts8snGAXD51hHGZJPN89WbNduHwPEGEuD8LaS8zJJNxBKjbSSw8UYi/zXcSgCNNxNho+0E2MwN +1a/22LLR2PtI6pihYxJiOnPW8cYEPlfwb9XbAvgM62kgi8eUMdgQnLSSMfJ1hdR0UAFz+Z+KkR9B +HqQipewqCIiGmfHg6oqMmut0cESMEjkMZJ8iM6yTA42h7YEe2by8pzEQKw3ypDatZp5FEhlE+vDS +duDOuFhtaRmUYhUCiErmYNyktaM5rQXm+GT+FouEPMvIxhQtFLYIMXg3x1LUeFJRZbAn3LI9MawL +mUAq1Y8w5YiHiQhXbjb0kH8anL8Hw50lhlcW6gFoQGrNQQz6WdIWM1GYyJHFlKP0w4uxCJUBT4cY +BBpjyBz//+y9d34qSdIAuBfgDsggQLjyVSAJ4UESsiBvcZIQVpju6fljf3uBPc5eY6+x19g05X0B +b1r9mm++eYOqsiIzIyPDZUQGunYNZcvTSTBLLCkBg0oidsqjxBKzT1levJiMgvovj6mPhHdCoMso +AXNLitH+xl5ZzGTRJYXwwndRUrroFQpZAV+SSuFzdzXNuyZyPdV4X+uVEbGGYJlVHgLVG01AC9rS +b+7PgDgW1jag0GUdBHRrcOJlFzCsgoQX1VZVj1h88xS8TBoV1RK/ghdf4wb4b6Cj6x/BM2rdVzED +3Jihc3hdsXaEVf2QLXdTEu8mMknCYB5/kkBRNihR1Cgr5LR5mschRLDoGrr7QXzDIdOWxuNDGhwY +Makk7MNv4fkyTDFx+BZsRwZYfNp0fY/95rz3S6E7aIH+qeylObx5GB2KKgQQQ7f88vgKdBSnW1U/ +Y/ClxTEOpsTzuCoKQcFgTGXJxSd5n+ERWD39dwg0aiOCVh6I/ed9aJC2NPDzyVaPaWs9J4nvnkBX +TxAoF9COXmFWM+NINjxyimipFUJ3/BLIIMTitcTqpdOc504pmBNFk4InTcdIyfCZkZY1Tz1Rc+DV +hJ4DrwtRNPhMT9PgkZ5mwCMjXasfuqZsGEdhoG2IioWoG+NQP1YjhWvlHkuqSrSpxBO0WOEt0TAS +bwD3utyduLcZBZ/oEnuOxBfto2ukNNPljRuZl/ef7quYAW5M2zeDrihQj67q0/5l65OFldqhCw7e +IUPBPEyoLlttZHxlJkGgO33hvXq6zUESAt6HAoW8eTSl3sw4vxRdU2D/LcvhegSq3bxAzznvPZNJ +IPSgCqtsadUaceKO1T9B4gIvjfgE+lWSuLgZDSwqv7JiUNQzHBYWP4yA1EPkcLyebhox/TwNyMmv +ltjQRZmC44rDyylgBQItraH7XznK8WvI7GHRRi21eew6t1DXMD0fiBDnSLxF1G1qOXWb1KvbnGDQ +WzhBx92RgFFxd04w6C2qR5LeovoqZoAbM3Qu6S2kXtUi3anbMeg4FEgUEI+vziJh9qOd/hIDZiLD +ousWkE5Ac9oVheoHDS1BmlaqfKi+hl5DhnL8WqCwa1R7RZbXvnOL9A11doLneK3erQ== + + + rBgnMT4e/4V1ZLFupV9SE9CNQPASdaRMMCgClURu1bxPo19AA7fq0+gg0DDVaCkSEfGC/LeGiAQV +y0M35EiPYga4MUPnedFcUI9RUn/VE0HAWQFPU4MPB15HwwthWZnEgOWetCEx7DAm8GXUNGPCNHgV +y+Gh4a7jdgysh0Y7fg0vShNPHpfoO7dQ3zCTHdYt8nDqqSVAUbeVSRCrtV6IEKmvejJUP3RNiJrB +SaQI1cuFiFHS97XkKGmrbglSFw7GW7kcMVTSYE8LJva0YLBABIMFIuFAZU+rH4n2NKe3PjgVaOWB +1p62ZfI/Xy7pMf0r7GktS8cGKhiXC3va8ktne9qpU2t72urLJexp0sSe1tKy5qknahZ5jpaeRXva +K0WL9jRptKdJoz2tpWv1Q9eUreFRenvaM3VL9jRpYk+TTvb0gootC/98PRsNLybd4aw7/IjF8GOk +7qpf+M7G8I2A31z05+Df8+ZXpzXz4Qsm/bnJfPrpP20MGx+dCVCN251J2P6dH7/MN/r9Ltip489u +S2xZH436CaBij2dx//kfDfDb2BSoAQCEuj1r296kKQJR6jdmju1p1P4Kpndo2yIQJh/wVh8Y2+KJ +kKzxC7Cg58OLxuxTAzr/2Zi0RsokQSsEwqRpvfOfmb/Q/aMLEG4PtI5ANMadCWCbtdlk1OuAgcXx +mgMi0az4iinHAjGAQtRIgX9CLMH/Jwj8X/SXGIJsN9qFOlfID3VNwf9wflTkAndL/pJuad2UafAf +acKq/6y8X4xquBtQt6yflSRm8ld3KuMYdkqiDgEv9NMYyeQv6JfXIZn3816RvModYLYnwbiknY6I +MeGXtBrcBjT3Uwm/9B+IqYQfoYuMU7JmsyjqLEZU13AI3bgownw4v2wwKu5mhSJ4a4KfU8YFI25I +noMxRDA/Et3GBOMyecT/oNmARk24HbVnKkjiN9JVzFNf4mQ4+nOI/gAyG8n1sD9xBqbhj/oSWSDP +/+hIbxN5Mcew1O2DmcH2gEa6Qz9ugJ9iTTchNokCZSFx0512m30E0AihNmu0ektB8DqGXGPabSmf +40XGJOU/f3+fdoBAI62/Fz846vfn6DKM0STeGI8B0vDigI86IvpCGqD+KkClv/j+DtYOtK53Zwgc +hfrpn0/ExmCAdrd0h46G0y5M7ZTvsit0p+N+4y/8J0z5TGBI4qqBiVz5ALHxBIkqaQkw8Q9d5cAz +AqfJ6ROkVD6Y2yegSmgkDRMA77Lm7kXQwOhgJLEanyh03v17fp8/pBpOGCMT31CCn2PkSLOK+vb8 +aP7+PR/AaGMyM1mxXL8zbHtYcDt8JhAwBVfunKjK5JTPLQZvM4/8aNied2du5qCGsvIdAOlvReiU +r5+5nnaKf3SG5+02IknYhYJkT7e9iAUmVKleprUmkI0N67IgDxW6eA8G6dGweC3FWZSbUNZRHuBv +ToO/z5R8ieJ/Oq05HAJ6gb41k2fw/jZuLdR+M6Hmln+shdFaGK1cGJlJIHwyRMJDEHT4yPGwyCGs +NYFve15LoL9RAlF/uwTi1xLoN5NAV0vewmxhVJlQ5dqkWkux/71J5fku87VA+4dPyZNAE9YC7TcU +aJxACyi7jgL/y0IfYFJgaXz3K8vAuxTgDQGiB5vFd9cQMG8EFpyz9hNSa0fhWqr9CKmWFPBVegzF +ozsmWVjpBkWhwBzq5NpT+C8Xa8m1WPvNxNraU7iWRj/NU0iI4mUtbP7NwgaGT66FzVrYrIXNWtj8 +KmHjJvdgLXT+d1MyJD38DWKH/tli518nNKDjjeIJWDYX3ZCHzotInmEYTXwez1Msg2tKEzTyxPEw +mo/9WUdJC3Ls34XfkgK+dJyAZUDQXZOY87KsSfEuj4z39+HBntgVs2ZXP45dLVU9bs2ufgy7Eu9M +IGiBhsc+iFvBK0c5xuz6jjW/csOv2DW/+nH8aq1e/R78SlKv4P3+pKJe0Twq+rfmV4vwqx8eHP+v +41c/xYf4z2U1ClO3/IH/g8oueeJLa27iwE1+eKDzv46brK21H8GSVh3HROLwXMDKkgKqbcfySYbA +JUEJIbmClMd/Kf9ax7WuOaA7DrhOf18f7f4waZBkcBoSxfPwYkF0E2+SYk0up1yf+f7Dp+RJqK2j +Wn83ofZTnAT/sF2zlka/Nv+dEmiaQWVg4X3yAlCsUBk8Zh3q+u/Of+eIny2B/nXyY+0W+meyXidD +gMZ2AMnDkmOwtAdFYqcQQzHcOgRpQe61DtT/3fjfWn9e688/UH+mqSQPc+v9MZ4DMhcGNcR5gqFN +qguv9ed/k/5MrSXQbyaB1scSP4KfrAXZLz6WQKViSIZh0NUxJCwzg+wRUuCXt0d+Fyr8fabkSar9 +8Ey0tVRb21VrcfTPEUc2t22IceKUsL6J919uSf3wdMK1zPkxltT6Kt614Po5dhR4H2cYQM3YfuIo +ilvf5fEvt59+eKrpWpat7ae1GPrniCEr+ylOcQRQsPzS/QAsx9Ls2pD6lxtSPzzTby181sJnLXz+ +8cIHBkUAC55j/bITj00m1xkt/3Lh88PTNP91ogP64ASWJwR4zMuxAk/C+FOOIHjke+MEnkLFrgl4 +pQ58QirFQxie+HFFhv9FIcWmxZ9wHDEnEDgaDV8LRjEMsbzP6fdhwp441joH73fkeRzLkgyHLhbj +Ya10sytnaFhQPYn5Iq6wLqAigOuCSWu9++9n/05nDySJM/uSDEMK8BdDsCyDk0rIJMOtQ5P/3YKN +/+GpfWvBttiBOkMTSSi0kqzA8egHKbAM1OoJhsZijBcYmoQ/SKjLU4pWvxZsa8H20wUbJ94kSie5 +JLpBixFIikCdxAWGJNcVbv/lcm2d9Pm7ybX1+cZaHP0oNxs+32BooESj03WWihMUASyqOEUmqbVl +9e8+5ODXSZ9rCbSWQGsJ9AslEMPBgx5SIMgkKqfACXEyKcADuiSxFkB/rwAi//5agfw6Q3MtgtYi +aC2CfrkIIkiOp+HSUXyc4QUSFU0k1qdLaxH0wxM21wJkXZ/o72CbNIXYJksJAoqNZTh4zwqqWwfD +8Jh1nNZi7GadU/e7MSwUm0rxNEr+ZggG6hlxmAOOgrKkMC2UGA6sYCjyeByx9cNiUv9hu26tMf8v +wrO49RVbP1h//vvF2Q+v7rkWZ+vrTv5BW28t0/5Hl9jDyCyBYQElw9hjlmCkiGOSXsE19r8LFf4+ +U/Ik03545vm/UiKtk//+kazYJvmPF0gWepZw7h8wKoh1/ZAFGdYvzVY2ZTdXEKY/P5oMO5PpqtiN +DqjMYmzXAvCfq04D0C4kr/nUaguunO2K7M719x755C9yi/++3GlB/Kw5ipajTCaNv/yV0aT739Fw +BrbVU4in/OPZU/gfpROtN+e/fXNiqVOfNIbT99FksCoRpQLoTjzJ+JlJX140ZmAMQySpCEl4DUZ/ +dG5eL2bSU/zNpPPeB9r2nfZhY9geDbr/7Zg1vYcPGX/iCOhZoXF3eDHqDmfwWVJ8NpwP8qNxt4M6 +4il1/xVV/6JIHc0as87rFZCsDTxgkpBfTluNPhxzZ9Lq4D7kwaBX1e6wYwqu0PmYdPArUges1GgB +7Jt1VFF3ROpeKZ/9fsa4K7ZdBggdqtl2WVS2VVy71h2M+zLX9qLOYz0e96EAht+hG5MstHbRCAAz +ASRoPfSjIdD2/OX+6E8/CwTNWsysxcw/TswoNGwvZwqT0bj22WiP/ow3uuYCRg3KtQGEOHuzP0Q4 +IeI8K/HH0bjRgs/kB83+fGJu2ptcLKL/gf9z1/DqB1Aw/dHqT0QGjsb8Mftr/C9m2xfdYc+f6/zR +6f+LDXj2f2XA/yJMit5RoNZ9rgqPGpDeuMDXcIZ2FC+zgPfpTFQKRVWv3x243HN/h4tR4TocSxP4 +yJFK8mouBHPpRU8vxzPscizp55zl/JKEQMt5rHWX9VEp0uuhndaYqBX7OEHBq8b8JM3CTUfDfGGe +Xf2dqJghlub//e9f/tPGtLcq9lnqAMYJ8e2OdZKypXllK4H+2QrJL6T0tRz8sVsZ2ugM2sWUpaG+ +kCH0+2wMV5o6ttrWzom1gP8p2vEvtNIXk+PQueGX9smSXhANLJdmpCzF241JT+1kaE0nyAlCxUlO +avNHZyJ5kjHix40u8kzE1K0+R5P/WqwDxTIw+JESOBwMiVcA/tVbHPFTnXvEzqXDASNI79VZs2wV +y34ETxvz/uzZ3gfubUehUCQYecSiVU9y6A5DXkjCK0vlmXqJgDV3kgeyR8nX4rCdnczQaKfwCQuf +vJ6NhhcT0Lo7/IjF8ONcB+yfi0a/M5t1EIe9aLoZZ+jxCnyIlDCAyecwWqy7//r0z30XLW94Ct1+ +dmcd8TtndDUgAQJZp+8oyXAsDSOLkzRP0rTGBSB+d1XO+a86benLJJ1Mai5JTtIMBdMV1ENUvrzv +9KGjFX/MsTxPat0Mcu6O+iN0DiJ+w/JEkuHVHZI0w1KM9ltS/jb/V0P6VBBo5NXgeYKEtzMZ0YqX +Q/wy159LCKXB/5ECwiNBJynThVB/etr4AMpgQ/ya5CkeI5UhkwJaF5bFPwiOExD6eJbDfE0JpOM5 +hhdBHsAA8PIBnfTnDhjWuGgkjZdbEOAVH+gVQ/HognfpGk8YKo4u9mRIAFkES9E8AEsJACzN6cHy +HMBsEoEFnFe7xgwL4MHcFHm0GrDgUfkgSZiCZUmWpPDtoyST1CxDkoPXaMM2eO4ALMKCDBaOlgT/ +AriEHi7NMywPwQlkktPkgcWT0q2mXBLfihKnaIAyWoLLwuHC4ecO2KQEl6doSjM6geVZhtLChU4x +RPPw/5RrUyW4FMQujdBLi3ABVEIzOIhdjtN2hJEr8KKQ00Il0ZoBildBZSlexyAELolxqSCeSRI4 +mVRELoXzCUQKYwiIhCQcLCeBBYSr2ykCCzaRZrQUBYkAwpVIjMJYxnBZtGYCsH0OeEbaiDSH0hfA +vGiEPyFJUhzewkkaXZwGaUAS+DxMdxDBoUEycKU4aaUEnhbQIGmwC+DQQPc8cmNSNEELOBGQIXic +XwHzAAVODY2AmGSlXcUzHI3yLxSnKM/yjGbKpLTc8pTxfsBAAfOTZkySMliISDRDwEhQRiJDUyyn +4rBwlBy+RR78MIySg3ufZHkJHiHwiGrAuhG8KTMDWhWcNJoBwiCkNdABK4JlMNXDcVKUtE0B7VEw +MB9sUwaj34RJxhkG7h+IABqsEqseJ0nDcQqCCC8JfuLLh0iwtoz5OCWmSibB6vDK2ovj5ABcBk2f +kYaZ5EiCQvIMVgAXaPw1zREIJXJ6jLSBaAxY3EBo/0DmBIYkoZPmaCRDkoBVE+aX/jMKU4ZpOohV +iXuHgBsdLBwcIitvSUBICCLLEqwpRIXNSWyUxUsmbUleYvokI21JGvSLiyXFAXWzaEcTAAF4ocG+ +E7cPLcZhY0isACDBKSclOCQBGASHmS4K7gayiebxgkOWBXcp4pFqNIp3QYt8iJLwmA== + + + NDDjJJlk8KIAtPJaZiyLJMzbQc/SiYIskWi0OhQp8UwOsDsKzZgiEN0BpYNgNdQkS2YO50SBH7Ls +TCJCF9AGkubP0ID3CIiWOcDq4Y8k4JlYKDNJ1B1EDytyIQZXepDwCcUxzMqEe1zak7CEIloPFvI3 +tIl4BjMTCi4bKTMKuIyi6KDVghPeUQwEJ1xxQYIKKIIh4UgAcSPWQABi5jAD4ZASQcuMUlwnCrN6 +DFOAQ0W7nJNIk2IFikRTJjjAi+FAkwLCAUECQhLUQoKDw4O9MJRqmaCcAAhgObSLJE5Ms6SYxAYU +LDFPgOfRjqTxZuDE6TOYEcmVNESoHNzqJBJtAiUBTXIs2s2gHYug80keDRrQBI2mIUk2WpLzokxS +SzYk2GT2Cb7E6wE3k8Bh/sTxDAYiIObOSLU9KImiSO1aQUpFSoOs5DCAHSKeziVpoPX5sb6TFPUT +SeyKmxTsKwWhSThzjE4JmwzQ3gmsiMGb2+EYAU9Bexbo5nidxRHKt7UTmDFjmAibNOLHeCcZErVq +o/eZHxkC/pvuxxAaM2GxgZXr0vQbETiAWGq0O/7ZyI/NESdY2tYKFFOvqg0cfXsFklkIlQ0gXXNT +pEG7wI8C9PruAZt+BMGHat/zxqQz9WeHH31gVmnA4P88qmA++8eGTxC5wMXHfAqamRfZs/r5WdEP +eCjrz0Og//HpH0qf4c6UtwCM4Qv0TPqA4hBhg/9RgTTrRu4FbFWOIzVilQeUqxW0AhIvSEsRj5pp +fHuDJG9opPdCKQuYiiQbCI4gEXsAmqRAmRvLSZFB8iKfEFTaGmAESO9FahCpgivrt0BvQ4KCBTxL +O2Jg+RKyyUFgvoaGLun/DJKQSIAD9iqBZniKojEgnmHMlQ1WEhQCZrtQTqtVAxrKNIpEowZLTsqL +g+0RzYIChmBYG/RMUk2TPOqBEoBksVL5ZHVcUFRTCRqVlJeahFuu8ReKb7n4cOuLwLojFPqyQsYx +WA/lSaA4I/HHcUCJRwMAujSLpIp4uYf+h4h+uLAUZKmydssDtQRnsjE0TWBpyhBYVAO7BmkjlPxf +0YCBajILEc1KC8iBAaB1Y4HthvguWC7AnBGXJ7E1R0tj0v/AUHkkPHhEyxJUoK8jVZmlSLwRGGBt +oTEBcUtiHUX+r1rzhP9COSyJTDAatI4MUGkQoQEFAuwOpNqI8l4alP6HCJZC4h05BsC/Et1yLL6P +guCRdKeBhOQwmQCMMKLCxKlVL6wnsbRG9aIZQGcCUljA7kVGGUuyalMImDfSvS26HyJcHqt0aGfx +ksCkoCsKWeE8xyexD4XEHShMRv6vSCQE3qNQ5QD/SsoxCbQC9J3AJrEvQQDal1aPlUam/yHxFQIZ +/5CoKcVbwQq4LcFQBNa4gP2mdQgkRS6l/V/JBYKUboZC+56Sttxtp+nPj/ojKAJH87G8+WAtMxL7 +OzhGMLe+KOlWAdn41HAajpatT0qxbXigiWnxyuElVawlSRnlJU2XEkukiRSGrQekl/J6nstSFNbA +gWnH8hpnoqVziGVtnENJUQkTCEAQlBYeMFkBb4M/1FY8hkfBedOG8XmKk1IGR6F9wMuarWSnApYh +4CxasCO0zk0eq5wi0aq9VqSQVCiXxDAvcrLTWvJNK95qtRvbdzbGDm/0RnJ5V7vTmdqLbxflLh/Q +amIqjcHltglOBqc7GoGj391kJiSBX9X+GjRHfQjm//CFKqMB0CpDlU5/DP4n15j2OmjgQFdsfYah ++vkHGBXUPENXtRpsMu8DrPlj/qvux+dM/aAw+nOo/rvaede8vx6r/8oB7fjPxqStflYaTcRH55Mm ++Pt80hh+wK5rM6C6qv7OzWez0RAQk/EZpX5WbzS1jeADTQvcEfZjg+m3PzroA7he8gPNB/gRDR6J +LncwuG6r14HjQz5/abBQxodFvIOVUmPdevVEaiuMWvMBIKFCY9bwBV4T0t/+FPpLdc4F/747rZ6N +2h3Tl3v+0H8G/SF4HWvMZpNucz7DSS6gKaa6/wWIFcBXtWp9dvvtCcA9aiPF1khv4T+zv8Yd/Da0 +M5y+/tGYTPdUyf3qpn804NrjtvD51KIdTBfHzcSRTDV//UOxMxwNOy4Q0x8BCm+7wYzUMvr3zqvZ +HbbBQEkXcwPEUevMztAknOenbr2i5V8SE6QtJlzNv9to9jtuCN9xVf9JGz31h+utDpv+zRQNp9ea +T2ejwd/LyX4dHaamDRgHAWUe2GJuyfGX74savLnmxwzld9il0/c/f7A0/pu3wbTfbf3TeXFMIJXQ +MMvldbW0fzffhVPhnKbyl5up/PV3T4XkaIF2msqf3TYKa3ecjtjwHzClzw6yVF3MSWr5N09Kiv60 +mlBzBCzdATSvzyddYC26mZrxmx8g8hGvq43mk1YnB4OgV8L2/tEGGWHyVo2xWWPy0ZkBPQC6DKZH +BTdLb/zmb1ZlL87KFFMaTQYNq12pnvJ7t9+xbayZrLr1P948J5w4wTsKhHZnmStt/97ld5xUdwjG +2W+03E1L3fqH82102c64AcC1XGkM2vZ/86bdKqH/c7FhB/AqIXTU4maS6tY/nDCHo1NPU9O2/wHy +1pnx/s9MWq1Q+rtHMxrPuoPuf1FmwU8ZE7CS/+4hDDqzRrsxayw7juSS49hqi+cfbnadqjH6+PG0 +0+7OB/6rznTUn4s5JTKY7BFJ+uXjFbD287G/1IfbFp7RXUw6MNVXcfdyLEuz4myyR0l/YzJrjhqT +tr+FjpZJf1MetcxOUBfSoPxdMIrGrAMadpCL2rZxbzhq9Ubzmf8Dn1mjRVVyyuAITjvTT/9VYwqk +oEjAqpniL1iKoQTrQVP+D3SS5a6trEHQhGYc5/PZGAzUfiSUCrJauoERdNv+qXh9nItRKGh2XBHV +5BzbypMjNeuByGDyR8df7/xn5i+2u7NGs9vvzkSpTDIyTCMxVRvDj3njo+O/GI2lJdSLNV7CS3vc +jeMmEkgwsomORAboUgLNo0a/O9U9mo5H4g6gZf/FuNFuy/ske+TPzmcjecWMZJv0jxtjsAum3cG8 +31BWUV73XL/TaUOb8kbZrKQlfrUWTn4yGmcnnQZOWTbIwJAS20eio36CEM/8wQ+aMv4i4mH0Gfo/ +ZYOLk5V7gx1ofAfiYKVVyzeGfzSmNRkdakIg/O8yZwCbst8ddvxTlCg8tW88luhn9EdnMoYHvlPt +KkNkiVwHDvpy3oDU5a/iS5j0DMJsHDNAmbglr1C4puUErXPsjw68ldDfbPQbw5bDJFv97hisHfTK +/wfsjQ9AAeLAQyQTB8uhYqS97FFp3u9LeLzpTKZQmM4mhi5qpVt/HkKuj/xZkULM94X+b0ILpFI/ +rfqvpx3/0QBusOwUBRVAVjls64lRbq80EcOBavD6R4kkeB5WwXL+Si+5zJviceGLIuRdZ9ZQ0TnM +0MAYxyN94K+NgekzmQJ0z7qtRl9PVpYfKLEmBvoyfgNwnK/VtPvXFDZKClWb36Qd2KNhqz9vA/14 +AClGz8DMviiP4HX/MGcesKNmv+NiSHi6xcF49le+0+9PLQlD/qReuIW+zYrKGWjXA1rk08a4Lis0 +lIvW1VFLxVH1K67fLaPxXwba1iFKRKb/7vTCHKauPUo+xpj0n+LkbUO/6jbXw+5/TDtWN7rtDtuj +P6c6ale16Krlpn6ESQ3eao0/4NaCCfgKhNEQUopfw59dfeOHy+MnxAUiPH1Fmi2r00eUOD63k8Jf +0aKi4ukjRhwf4+krdqGvuIW+4sWvvKFQ0NGRDUWYE5QOjdDb7ERPhLtP8ADNl9j+myeCkOhJ8Pgd +ZY57x+/oBb+zoCvH71j9ulki3pTrKBK9Nm++j/rtzkTyDMKn07Be7Ooaq8w1LXcozMdgJND4UsaS +63wCqlL5Z3BT1ECkN61w3jPl67p3ahtA9V7HOYv/GY8mM6gGqaWrSrXOoUMblXJtUJA0TqNap19p +zEDfULj04fSmKn3Xou0R9J8eFdQt1a/rMO4A9mo2PhQCqhqe9m19NFa9k8+Dy/0RUD6vOuN5fyoL +wD34Vr6sQzdR/V0eioJTuykjncMoe8Gb4rA1MrGwwRtoxp0PFb1M/Q5dG4NwBzUH0YJSgAJTsNVV +xk0qb0pAm6obncEQJDCzTjqTodlAgG4tq5/qsQ+aAL1IYzftCBD7FJOWYQsl/cORYmj4u0OkwY+m +XakbZ48I5QfGoY0XRG0voLZInc+LhsKV2lBQWyOoKZ5U4gabITmNGaL2bODWUiy1vwG0ZOzq0LkU +NG4I/BFMdYOWBfoImez6j9w4hYoXNbc4wI2tkWBsey6abTW1+ajGFW5mgyztvHFz54lrUYy/csax +w26Uw+H9t51m4qbb7owSpyOg6XUgUoHiCPZhR8JtQnF8J1qjPiwPACAbWba63XTWj7dxF4ioZYFg +Dx5+JrZXPIRuvhm3B+B1f+h6UOO2a+A4hk/+gpSvS1I3HI8ncSTs4n0YRO+q5WwkepdYnrdvOVEM +G4Eg7dviuAEde9esIWz750is8Gbf7FPXzIDTr1ET4HTa/Rg2jE5DfUO0tE0xbsAOImo4gifDLto1 +ps3ubNAY2zfFbSa6fWLWutWfxFujIbzaC7rkbIYKW8p8u4muHsLz501bT9pxYMPDO3QcBgAavgPW +JF0bhkSxaSskJIxePkOvf8AD13H802W7P6zHNv4Y9OKdIdQx3O0g9AHeQsp6uvkGLNoMXtgmjiVO +saZ0D5uCTQ15syrAyXLoY7BFusP3kUOzieriKoemyFPabEymNshFDZtQxQL7ScUhXDSWmYSLthON +/8OptZpRcJbNB41Jb6odtYvG8qhdtFWN2kVr9ajNmLx2jvNpB6jESLm12cfvw1m83R9P3kdDu+0+ +nsahYgZ4yNSeLKZxwDOhU3YImqqEv6Hlf8bxiZ4lIYFv1vLDDfMC7UTepfiXzdCktMP+cGuIk/Zk +qt3xpgIINZMc0dOpdc+tQVzyrrcGf/Vs2KDScITvYdZ6cA29Yy5j2zPUEkQWdB2vxf04xxTo823/ +U6h2e37xFPb/QTnoQHBcKuFkJu1AG6jFdIc2ohPKV6chwzaiyiJKgqQ5G4QiXWF/AkNZtVJHTIaA +Fgj4Ztvf/MtfmHT/QHdd2/Fl8L2iYtkoFxpGbKVamHhrDY3QkaMrmQFlvGZsptJaWX9rITj5cBaU +oI0oJFUFpvStUFUpCZZjOxuhixuN+1JQkSlxozat4dQOpaDNrNtXW9jm/HMqXZtp0wbxWCfZOJHk +gNmQMdvVLIlpmykwnaWTUXN229ccu5m1aHahLWTbZNj5aCgnm5YCACimQ/s2fbKFXOcGs08vJD4b +7c5EdRRp2korR3gzVRAwc/3poCnD73dtlGTQYDRu2ShGqMHUZuqoQXtua7Db7GDwuf0GxiJmPmy5 +YgiodWM4HClxpWJoAHSyZKWGfsVV5jkqgFS3R04C3Wmxwe1i6kUgrFrVZRHuYM+bCw== + + + RWQhgSHjRGhLylAMqX7fvtW01x0DM2doI7RhswnYjZNpBw5v4q5bKezAPauXvlDNzWo40Gche+y0 +VHA8ah4BY0BNAzrnl35FCUvHkLJY4kXWF4WS6ISCtgwMWBsNp3q3HRiB/xy/Urmq1G7nxh+dUyD+ +u+N+J6tFk6OTR1Ubwa+6xXgF/h04ezC/V5gyn1d0YjEMwvY7NzEZZt9RsL8LrHiho1PY4cWo35Wk +oqnxIA0Ul4AoTUYDgMQ/R5NeXZJMjM30TkfDUesTfNRRTfKkO3Rn+kqDxoFW0G0/nIkTcIddKYop +C+RoszGrNv7qSGYmvDLKflng5Q44PxOdtmSboz9cdIliJaxW1L5T9Kl1r96W50pRDs0NIvOpGtzG +XlYIFgRA7pSjNlip7ntXYl+cB4Qp1OGC/q3DdRjbSUO6tMa0d9ErwVUimjDjciRTSoUCaE3q96TK +e6390lUYpDeSqSqOV5vBWmxG9aBNdSz3sVnmpr6RpVhTrbd55xw8InY9K9Rqoaa6DhS136U63mD4 +2AUTVAkzGM8JaDTfGOOozq6D6GAgHMkPZK0sKD2iE4jTBpASSjqFO05S6EzB0BruJajEOrITe+I1 +YXYLCiKZzbnABGAsR4q31MIHK7WuT7oDiLRblWXvKGvMpmM3pKvOB+xj6syZdbqJI2NGH+EA2a5K +xbWer3Ki7jzsEtg8t53mTbfzpzOPUhGRmi85D6ZuZ27LeIEMDCjE9c/5oDlsdKUIu1D9E+w0f2PS +8c8+O37R7eSfSoFwf352hv4pjrBoDNWFt/yQi/obU/hY0X2lmPg4ig+ZIeBaYH+N5v4x4Jx+wE86 +eE+jrjG4D1hVp6vpKOoHncmfDsGM4UWrY5hM5u+ik/OGv9/4C8bfN8Y4dATyqum89QmHdzQsoKMq +BQzubQiQOgejG70r3Xen/vmwByuBxF3v/NakO3bcWKgxwAjiMnWVN8ZuzWQzxAWlYRlVN6SiOfLn +nHyIQbFOGwsMvGOMwTKbKhjIeKxiuw4krJLitnIUx1PAyIoruMjW7iE1o9WFM9rBl5iZC6OkNmsM +23JItEteLJZG+evM1uXhGDvujFC1emC/rogItAsLzGXwBiuDedk2dGV+mk0H8NX+dAYs8rmc7PP/ +/d//z+z//b/scSZ+BvbX++Rba8cfDXt+eEWbyoTn+aQSE6gzsZWZJXJdaeTZWv7oSGALHdg/fMkc +nu88RvZvD4J7jbvoMb1zHstlJuXBZ+pjuHFc2oiGgvluIz7d5q4rRW4rlbkup0+Zw1T1KXiamcxb +fKlInQoBkmG2CGJa+Cp8RIntzN5LfDezHx1PM9MTKuELZPaqGxOp0fEs91G5rGb2mU4t3z1Itwrx +ePDD0FW1fQ/64wulQIp/KM8KX8855iEWzQ5G1Wn2qDb7jKS5rXmpwGzf5r76wVtfoPBOHDdNgW3z +yXf+5vLxKVvPx2+sO1W3Sz1n9nul50xqGh9ECtHAvBQqt999AYSs0hvQMArvz7d8rp/p36Xec5+z +/Cf/QGrQ8bZTaJHV78z+YfAWwwFDnuZfPl5G4NfOd+GofbSRiwlf29labGuIx3DXaM99geRXKNIq +ttjLUP6Ted3bzwbonUjuLPoWyeSD16V8Z76bvjne+txrtRo9+KsbKb5XP3HPJJFo8JPu9luq+3Lc +zvUDh8HYJPI0z1ZrO99w/OHM3vEn7QtwezfPmeywFRxEDk73Evzg6aDL84npO52dtI7ISC9FyhBb +hePpDUAbH+zwtzTRTnXziQZYX/L0IBSLdnJ9/mKAZ3BfDWTyR/tbt8Vokp2CdTl65LbSfH70Etm/ +aT+mqObWMwKbHgbAhNLc7hZckkfulrscQjylc70wFxNJ86ZdJcjnrdNCorG/U9qIPExgLxx88YKg +oCa+ANHcPGLQ70i6tC/+2r8tnuDm+WjxDQOj7qkjQLp3RCSdLkapwuHHgQjn9mB/r/119oJWUh4w +gHeeY8VeQKPcsTyAZ2UAZOjgCjbqMOgZu5ErvCJUA2F5yHAP3FcrWy98RQrviZPvYqMR3M5xzevL +/UrhNZ2tf7Zm2Yvt1mm2TtFg9bP88/0W+Kb9ULx7O5zLKMJUqyHTl54CTOjHJxVpwe5HhfdasY3w +CcA2wpH01t4tXiEI2RcovpKRmxxzd1zKTCaf10zq9PYQrZDAdiccWLzdaCQ3Sr7oUamduBrvEp7w +wkJQvsBe5GAeKhX6ZI44ZlPgnzLRxXDSXHOU2avPNrP149nciErdSqrwLi383WQDPqsDPvYd72b1 +eJpfJTul0M44nP/krh6KTWJ/t9CZTKJE5+JgTx4IRoeMjGo5+3pMImrbj72V4E49iReOvvgG3vt4 +QYXa9+Ake/6SOy3l348Fgjxptkv59uAeMU+TNSjn+tzBrQKbm1UPHnKV+taBbgy+ABhF57xQ7gU6 +oKvLfchhaOI9dTsyjlbfrgV+RWfl8WYzmYzsMWc6jOwdTUfv+e60y0FuGXu8oMJbRxVlVnud1M4A +7OSrMCSv08jB8cOx1OnHE+BjNHgbqO6WZ6/tQbb2dlxIdA9CJQzgPVjhsvXT0Ufmpn7UKBWFyztf +YD9CFJ9kdIyL0dEZVdrhUndgzefJYqv3vSN1gDZIv4EZ885jsArY40Ewe9Uf76rbXTYqgP0FGf7q +czeePbmvDX0BFQuX3r9m6vzOeb76XSc1ImN3p/CeDb5oZMBVqfQa3vhE0wA8d9gBW4pt6t6Kqw/f +9zSSRvX1LhCi5VExWm8dACxe3oKNfbcdSR9wNHqbrUUzw3y3e9mGU9uATeqFk5NKrLRfZMPoLZzL +x+4QN6+fZgK5/jERh2v1qOxPXjjs7jKZm2aCv6icXpHNl+ssvbOxXaTC2y95spyvZuCvNCBx8oDo +NFOHZDSUP5SfpX0B7Te4JXoG/8xBpphHH6I/uVqVuoRvD9DXcgd5+CyHQWX3YyWejRWuqNeHcRE2 +2Qc8GTaHDwpyVznY6EyBg3uB/WlBZOTBp+Uv9lATOJoLNCQ0BjAXACeLhwKniScMBwWxU4fP9hAw +pRcEQo8iOGSzTtGfIsYgxJoWmeibPfgWTeNQQSVuDAeHsTj82LuUUVBD+JR72VfNRVm8tO3Sul4I +3TL4ArqFwN9AZCmw0TQQnrToOECzUv5EoOSey8oYfAHtWqbNSM52SfCQ0S95VrhT5U9MY6aE4YIs +YOOqPCuFVPQ0i+diiawDPFO0cyR0HChzho3PzZCq26m+gIzCA900ZZyktCAOtaPJK9+it7pOxXVR +9p2KYjSrmlaoFjWGmMiabJU9eYQXMvPARIrnUkJ4RGDdolo1Blt6QSgHqw/xKMNOmzFANDV5a3oj +Q7QgGGP7cgdojFecQIbP0S+MfnmmPHcTfwcM/IsW5V4yO8xevX+cALXyZKwTGNn6zcmwlCHJni9Q +DpRfAU7YEKfSTeaXgf3S66y+m9kjLjYixZu7iiTKYtsqdUKlFeitJHU7QMnQMMDqCxDBEZVpRiaB +wXKS44JA9Qs/WlpT/N5DtZSle9vHyA7QTiiCDARfQBgdE3wxFn1nCieH34y6l9xrJ3s1rF1na7Oj +QTFSTYS0b/ulTDIwloyKq7BifOEOjh7r39nzfO4C6jCidjXQIAZYoFAL085UpWzwe63rqyz/dHxV +OJ7svpkByLKV56Psye0l0JPFkV0HeuXpeWciqn5VLgfE9lNcth3i9raDveUAtQvJdoDAeP76uXNS +eL+c1hLdi0egNhe/81jfpqnNR3tjyNIU8gXUxpBCoXBq2MK+y56XCl+3r/nuF5fYex8EPoB+u0sC +nKTfeP6qPYKDiyn6kajG1vrPCihAySKw38my4HZlf0C68BELH+IOLun0G1DUzoP5z8h9PtFNH6TE +tdLiSWOL9ADZx0uKIQz4mHoNLioI/aBTegs6D6qY5kXiVA3EyqjYSWM6VzbARaUPLAtF/9dq/6qB +JnudkzyYUDtSentNJwvle/4dmONFiqDKzKke7OVG+ElnpGAaK0rdvl0W3q8jZcCnSwUq3C7iHYgs +VSgDkphxvezv9Kz2FV96ed7dKhWH8zcqkBwI4urvR7cTjwLfqh7nLi8yYC73gzPRwJ/fB7KXZ7Wb +UiHcll4oxD7aIfjevHlBVE+aY8VG1vscqIceWJf859NGKpIuv75KlPUcBysYP8n1TiNAtb94V/Zs +CnpaXnI96mBDeSE7AohUe9AnoBA5g9h+ULwdwOIz6XvVPWNN6Uy9dcfxy8jhTeNb6qDOZ/ZO7jeB ++fi5oYV9nq2V219gXQ4mVOZ6I4nWAK3AQWhOdSDJvaMXgI8dfk7naJGTl4Cpgl5eGgBEfVp8HZPN +zN51MK5yklFsf3PvfX7xla1fN+5BB6k+UXrK0GA0lZjMnfUODF8g2S+N3q0ohpRb1qXdqwbmcvfS +ao+i/f4lKC67U2gynZrj7lUNBO7eD0DJpfBFf69UYB+oSPr+edcI0YWVrwJbVe3eXPX1E+ETrEua +O54X4lftWCZ19tWTRVSd2ywN86JrEBBfbPw96hYSd3sZCZ/BTuKz8/IG8TkVB1cuHIgc9PaAhWKe +yg3O00CKaRSPMyZ3PqcfAKqvpsXILveuklgK3UFS4ra3voVM6va7u/deaX5kUnclNSjMsbHtnmz6 +Akhi70fvuQqCrZLdYksiBOz0WQus38NeoTM+ryJ1gtuqMlvwGVU4qZ9uKt3zN/1qHQi6w+3iKzF8 +LrzXC+++QDE6Op1n2Uz2sdi66Id16pLomfwI9ABDTW7y08TZTbZezcBtmIwZB78fykxiyXn24irx +nOq+CO9gxW93wbqo1Bssjg4SgGKqu0BBebouve59JvSdUunvAVjkj43M92Gro7yAazXPCs3xR5ys +3ETFZ2CJgT5W3/6OlUKjZFj3imxWjygFhCxf4ZDPYrn+gHgH9NJ74NKp8/vM3jhJGqcmtoPrAlry +wuVo17IRapJqt5vfxiYPsQKRfAiW8h2ul60XGmSuL2wJBBX97mZS55d9tGAqDmOgInQ+cdC6ewSb +pnCavapnvo20sTXNdw9Op5lUKdDgDrm7cv4sf3Moa4ecKF/4/W7rsXDUurrIMbfUzLDwL1sbQHgQ +l6XQ8WE1WXkqzUQlWFzEOCC0E27vZDv7XvjYemb41DieB+pQd1cBhbQ+COy9M4JE97gf3g68Qure +LzYTD2Ot5o1HJtR3tmul162dGphf5Kn48jVrIR+kEZ/lWbGZ2w35AqnTCP2Yrdd3NjTEcngkg62K +XiqRLKqYCUt/PlkQSGWrlM8+AxUxc3QH+FghWmdlnyEebbKXLdazfPLqI8m85QZgkjnCsgkUBA1o +KoVjw2hdVs+AFVa/Oexl9tPjWyAr+0NixwREJ9cLzo5zzP3mdeXgiQm6mqmo5mmghOJPsJfe0Rkw +P4oj9b7jMiMoDY+hrxNMl6W3gInwkFRApEhh46wUvr+YZU/uybaq04OTs3ahPUhG1Q== + + + ZxZgZCHA5c97Hwr/xUx49PbJqnaqfHqBGW7kbPRVeE8e9wvN3W4gWX2b7Jey/eEmcofq6AWsPjzK +S53lE0+Fk5P9BFbVqMtarFQk30OlVPZqU1rQ2xDg/PUEd1DKpnNcYMwWjhr9gIH/9C/CADfPV5CX +xgsnR5t5wC21G2g/Or+4L2WI2StY82GztLEbJYEJew2/SVJg59BvYBseCiqw9G4ojI1Lvs6/SGdX +mYD29E1Ewl4pdDTIJj+fzrZKhYvTWikwZgBzue18ZOjcA6PsRVENAr8UBQud4WX52lY+C/5byezH +4mHTXmCjnTJ0Fj+BRkXauMe2elkmlLsuhqbNZ8hISD2yiGn0Aa0A2Lixe8teatUcFX6vm4Igg8dt +aDKfZEef57tqy8lupyKylyw+W8KXne+P6BQArhVVaNTKT+VA+VkA9NKbqxrPqqVnsPqZbaSKoDNK +qCdzmdNC/PxzX0W1aS46Ku2GoxxQg5gAMCUyfXTYuNdJtm7EIzju+Fo9U7UL4pAq7UU3FQPeQGNq +sT1uv5dCJ+WkepERrV4+bcEX/WytOX7H1iLFbX7kBpvCl0pTylTG39KuVOQL6uWW3m/we5fnF9na +/JoyChR2UjgadKdAbOUGYIR9rvR2GkhaawDnqf0rgLHTdnXLfLklnUJIjhKtYnNUiTm0q+/cPhcb +b0ebuUFkRyWgJRpTaR+HZ3dgpbuqc3sdMNW+M8wUCpT3V7CIld1voHIfnUkSGbHPr0nwrrQzH3dy +zDwHLB1gaatsctRkEBIAB40X+7mvr4tM4ah9OSsch0IleAx6hM+Nsv3GAKlGxdnO0YbU8/EcaONG +5bVqpsGKauxkqw3pLpq93H0FErI1INXs+Hg+I44ey/u6/SDOBSgorXrq7KU5L729UANIY7R8mP6g +JqWDTk7F/uE+x3gIEL1HIBzuQoX3nfEWNzuZHZRe+/GEppfuS/QDrMZ0l0+9RGrwPCiiXxc6PKSB +QsA0skwwOEqStyeJrFCezmDYAFDojhp3mWn4brNwcvz8Xejsv2wqC4Z0/jcGiOj3MWAfTwku1Tzf +cfs1/DYJjKtKpfQ6e46VMsFOXXsYx6GNgjmMZBhcANGciX0KoL9oufwg1J+KzXr2tvDB7nR13Etm +XBLPkqU05lPikhTRWvgC6Agy//m4/13KXmTGqdPpfKR1DXLcN5m8KrTyjV5ht5to8ft0sVN8eD8q +yu5J1KQGdnytBGVTIyvE4pvQF1JGbAth7OKBr79VEqXCPIuOJS+BxhGMFUrD7CmQn/Vwrre3HxMV +FB3ED8DgavN6WwncwNxQBHq5mWPDpQTgY+1U4UPFLcX39S0RyyLurrNXo+obl/4O99QmM8RxLrhf +LUafc8De56iB4pxFyAKy96kLMJb+3j0uNO86V2C3pSvl+9fxG+KR8vaxwLy8OKKf8AAw8Fhpi5tc +Vg6B6nMIWPTJdw4NSfKOUpehGaSnfe76op0AO/U6WgqQIWA3X15FC8cb74R6BrjxmORuvt+zSCSU +AlU+pYMtNwY0Vtp5+BgW3kfPEeQ6MvVfi6w+J0DvcL08j49fsicPYUFZfRgCECy25psvwnmFrifp +6PFe6TV6k9LNRYZTL450YlsL5y3/8VkKwlNvQTNkGcCYK2dH39MEjO44Lzx377fUp9UKA0gdN25O +lflrzOhLoP+eloLlQKkykM0iYCDdbscLx5EtVt1zf7ZdbDWjbRhFcEsdik8Hmztw4V+hvrav8XQ/ +85m9l9g8W8/zr8DqbAMLOxFrZEfZTkkZHIZCh7J7mb3n6xw/PKqTheePZwrY+7V+JiEBA/ziog32 +X3cfTFijihZLO+XqWAlHim/sJG847rj7wdVj9w9UcSOWS3wO243t5MftBIy1Aq/pypH57sZjEOyX +yG7ru0Bsx4ZIvLMb+V0S2ASDTaDuXzfL0HMaIOn/My1Hy2lD4QromnBtzltSn/U4bgw7uqRA8T4r +7XWY6iuy7vRXsYBnhXpBlxEJb+b6eJeC+QzRg3tyFV1tZVUY9IcrrsJ8O+mdD8Uwqp+YxvVF0uwb +D8zjZoJIRE4jgFPPaPiLYvYvU7T84lL+hV7s0Yf1WQ5YFuVeZevqoAHo5T4tv6UiB1fc50aYrhxs +xBJBoMMA7tPb3wifPSQ3op9d8OrtPb4RmadqG9HTu8JGjDiliMTBfQh1D1YtfMlMqekpGFyhB1by +LU3nBFoATHbwgGJt0IGS8paovHaAZTGZpA+a2ej47Dhzkpymhcr+bbw0emBuipOnB6LwULqvlw6y +By1yN8sPxV7o7ctIPrZ7BfqrclbTxROK09XkNtT69I2q08lkb1oHnUSPiARTw9NQRjYVSrMb6mXU +2yHaOyTq+VwBO3kmpvsAtjCPpMsbO2jiaF0KvXhiKpQZ4XvvC/xZ7oOv7wvaTp8mz6dPl+adlvkX +NnX0Ejft9GX7DMh9XbdKp1z3pBww73R/IzSZkoGJeacX5BOzSaV2lU59AaXbaTB6GrPolP0MNYL3 +RfNOmfBTZJ/6MJ/pZumF8QW2rsf9qtlciVLuJGPRKbe1PZyEDyw6vX8hSu9nNaVTFAcrd1ve2N8h +j1/rpp2WK1TdEr3UQ7r+hjoFtNgsatf0FlDy0zxdhd2Gjasauqcf+2QYdMqMDKRUJXJipxfBoK5T +lh28jpVOFUrG3b5Onj+HdYtOMw2OL22Tpp2+HL5dWXVaAVofHdp7Mp/r/sbzdOuzc2Xe6WU+nP7e +HlTNOo3s9VNppVOwLlpS2j18yJybd8rc3xOlJHFm2ulm6YPfvhpQ52ad+gJE6fm5ZDFXbivQG57m +rTptEOXo2415p2UiG+yE+HvUqS+gR/BsK3oodnofC+kQfHjGHIjoLT71SppOH/aJKh8jYae7uk59 +gelmpTPirhoxCnTLj/X0W318aFh0ym3xvXbpxarTAnG6+5xEnSIbWTvXo+9U5mtydmXaaW0vSFt2 +etKp0YRZp5DzM48xovYa3jSb63TzpNI5e3wIh0w7vQkOPyw7rX1evjVRp76Aca6PZeLmZLxv3mmV +DlyXMvsH5p2OjzfNOgU8GXZ781renFkg+PGcuD08KZh3epouvr5cPj+bdvp83jtCnUL5Ypzr1z3b +Lll0+iQQz9N+zLzTs6/x4Dwp0LpOQS+o29ej2NASwZNALbJh0en9NVHsDo5NOxXOYpsbmecY4GOg +29S3ftPMX/lXsdMmHdZtmvBDtbGLOqWC6VBFO9Mq8babysJOo0qnoBfYLQD79S0x/YOJvtPpaOdA +7HR2GNHNdOOp8RjGnebuySMtI4xOptfpDdAL6DZu5EpHMTRX0Gl+ZmCFlU0Od3pInsR0jDA6Zs6w +pKG3U/kT1CnsRex2ezJpNIewU0LX6WSS7Ywk+j3e0HU6Zb9SoqQ5TF3GdejdHHXe6j5Rf+g0Xjnt +oCrXOy+jlOXb+0tycGP19pOovAXmylsD5west7Bj8TVYg51IXhrXV4fXveUE8rUuvp32BMOu5Iaf +m3dm7zFTvDhKPVm+Fajdqzfrt5+Nl6CMMeP7LLXz0LJ8W40MDynrt83z9z3lrQ5j3Nb5ZqtZsfha +qOxU9q+n+O178Dup+/Y60pWU03dyM2XA2HXzuDY0e4+5XCHSm1i+vQ00ExvWb58KqQMJYybv3wIv +/Lbl26/Zxbhi+bZ3Q+UulbcGjA16pfSL1ddgSJd7rOXbY4pJ31ljLNAaNmtVq693NnaOnnYt3xaz +p82O5dtj6nCTtMZYdoPaDqcs3rIVoniwK805FdrTvY3UL6eH4tt8fF+/Kyv1t/JuVnnPTJnoldYC +yxPt4GNe5D9vgT58OxbN0dIri1lPbjQ9w780fIyabUMLM78RO07eAwvzqw7/icNnpY1o4SoP/7lF +9ptsvWEeIfbXuMpJnG+ySQUPLmIiPwd2jkYfS2/RQfDh8QDtDWjpqHZE4lQYBoEdezcHrHVzB/T3 +vi/3t5XoHjTDgDttFifzt3hMw24nm76A0i2ydCw65bagnfNo3ilz/2DZKRAiX6ROH1PPFVk6lp1C +kdey6rSt7pSpARtZ1a1wlqupOm3v7GwpnSLtX+6U1qEXav/yTMt9Tafhe2S9qrvVIPiAsuwUaf8W +nQJ7EGj/L0qnYC6auT5bdgoQPGWsO4Xav2WnvgDU/z/N57q/EbfrtBq07BTpFEqncO9ruoU6RV2z +qp2k1D36JS5EOP/QHrhp9zIfDNV736Ilt/X9Urw7d2zHfop0J3KLHJjzU1bkloat+xYaQOxcqRw0 +6dJ8IjKXnVpGt+MT3a1UVPknPQ6166KxDnkStvfT4/D+WIYYQiDSycr2FxpFOll+LADG1SjCnmmF +NYndp4sB8Z/o6UjsAKnAUgeybgnGAyZ3MMaNdN4nwPZyic9OISD/c6XWmEWf2bncuAB7Kaun+3Z8 +KPqUwJCvL8CDHajQzncl7GC9XWTHqhlc7GgRKHvcwICJYzYQQP9AgrzVWklmg+olj3SDUg/pdR4E +pHsapYKHhMqPpnMHIpQDbvk8z504IR3+Iw4eG/Mm8wtuWM7PF1BmiP6xXEFp/Wqbzuu3Jc9vV6Qx +sxlC5fXaBlnu12+E6BNbFi6RZQOM3M19lSxB+dyQu4SsvZgnylLoSiORMWWVn769Y94U70C5eRAp +eWnMU7mH5LE93n3WyNKynrCR9bwUtayHtmQ9PifSLT4dTdQIlIesQeAOZj3muHuB+WISgi3GEy1G +8T8i7sihOe7uYxuWbNtqVyJ/nOnU7je9T00txdDk6MOb+qkTqssnO+JpgulAChHdrNRSTDWrzkV8 +R1x9Axstgl5uRp4mZMZhAO0Ac+5OhVt5G6rp/C28AwZ3V7BYpuiYbGwHK2gM2M+/IGIIayn9OYoc +SJSjomTk1DEHRroFZgYK4V11yrNr3HeNktt9Z7/rgKxsbN7Nbddyi4xek1H4z2NEdUhhIAvAGUPF +E7PlBBhTLyj8Byyo4og20gaYn8wFjbRxfikPSTUuNJdZ2XRk6XJzajXJDNGZXScMWphxSRSL7zRi +XJJ22UkLc8t6esLUF7AUTC50RqUx0GYeZ5ZiyRfwsr5liJOKd+3JbO+3y1o+bYKs05EieG2GNDs8 +tpSV51fieNyodGBI1gqdtHS+gLsVBFa+rWLhpPNrVnAYsFUsPKxf+WKggMKUvASw2tDFuMCudAVM +K1C8jks64RWB3dsbMV4mqdbqlsbY62SFGNNyNI/jGmv9MG/8xGC4ztLTBbVjzfkLGE/FzBi0UmhN +BTSVu/vccOBjKgXbfFfODjdXtitzd9/b3gxlfB5rWMkKPDKpKriBlrh37Nxv7rg1PmTdUo+d9FQW +y45uBHPFsKJjCqb7xXmZ0lN7E083EJGSjUNx4AKuBqLTLRfDicO2Vw0E28gRCxH1UYGu60cPNjk+ +lNQGGcmxPdTztBlXObTBryNI80UPHVg4NYAmuGGjw5iyD4sNcmSvdvgCXga1tSAD0A== + + + cku45Z5nAXux7JYBHCkMwK29bz2/oAuU+9whXaMrOPsz9Jq84uv7OoKHererIKrCjCw+T8sKZ9DE +wpkaPhY2OaD9T9otfYonVnbIcr/FLc0eZCUBZHnc4hpkyVscfUFvJ3sJ7QY/hnPRbnFTq9vZuwSo +dtOdh8TOl3Csd8nqR2PnktV5SAbHWg3ewih2dsmCqak2krj6nt0kxzAu4dSte0O2kvRDOZ5rxfIC +7g1AB98UmhCKVDGslvu10slUC7+PL2DnpRscw8Pd+6X8PhAtzr4+HSuw8NdA7HCuKFnFNzWehrFG +lc7M9ao0oANrZ6LIk10o0xDLJ3pV2gvusD6GxhOwH49b/wJ9eM0HdRShssU8CcITnSa82H5JXYbt +p+ZM5yeK8JPlywLe6PGJXu5ZTcgXsKF0QDtaobcIAzi8DrA+hzV3h5hXBye9TyfqrHRZgB2doHOS +Q2pdFs9FJergYVVQHb8BZwWeuSEGy12nouQ8GE/cm8/bOOe7mpm0056Kuj6CBMCs/K1m3lZsWVj5 +WyEwD5vP3F4Cm8YXWPqQAq2avcjzuYajNSS9jUY8E8dwlt2BGIpsTSpQJJ7sBY53uSfb+ybANCeE +3oSo9nwwiLSLaEirceZRmOpKThjyKPjUF3Dehi7EDQRGxT2f8VkoETCWc9cVKlXqZ+pbI8X0HG3a +Cxs42rSnP8BzwdFMPSR5gJjM97Ic7VrhaJL16kWD1wNz5mg+lydIENjiHE3eleWb0Qo4Glg1M47m +ee8DON45msF3geEsz9EglOXPXhEcm9OgaC4kn+IkfAEzbUAjhG5Gdha0+ujQXEdholfaeEtg8xh8 +4/DZsgewknx5D35bsyGXmlke7PPzmdlmxh54b2wWALvZ8MRkfQFLNrtg9IN2M98gW1pjiS+ioIBV +0wU1WXEYZzjuVHtLKMgPA+AsHwKBoFgY1LqTd2c42kN3l+5lk9MEBGwVvmosC8H8IlC70EpD8DS2 +jH6vItLG5tV0aYvv7tatN0vlu7CUhree9Ht7HywEtrx+//RtJgu9SjG4at5dWkYpBuEso9+roMiy +cHEphuCY6PdmUGTr1QKOW2loLwsRh3n6XloaamThq/6cGPUCnq4kHAnyH9M4LFFWaoKnlDAMS13g +dWKzJGpURl2cvt3dLeOr1vn5AbBld7dqXCZ72z7W2gZjrtRdaSVhL1YWEVjLuKt9bnN6mgf4vEnY +eK5chNPphmRJESi2x3F76QVTPh4ziKV8POHKrnQhmKjcXdsyPM86cs3C3gcjo9yh0sXmak5XF20L +gFme3cjeHrcB9QAYvb13Ul2FhwRgjPemYljEIMKVfI278sFiYBab/d42+BZThE/y37salEuKMGwu +USLjravIszR7OjS1LMQ1QNly04+N2PDydSN681LciGXpF5g3VzTLoMM3tyyfQ6eWYsYMOl3G0MI5 +dPYZdIgnryCHzrJTlEFnmS3oMYfOPoNOnS24TA6dfQadRutbIofOPoNOky24RA6dfQadTbagpxw6 ++ww6lC24ghw6+3ZibvXSOXSGjavJoJMtiyVz6Owz6JA+5pxDpwlItskwuwiWzLRt6xh460wgXbCL +iyGZenoLzoHbu+7ypUo6G3nhYNiCXvs1cQ649fQ+FrTS3tvSqc74CvqAjYXxtLerIVdtrqgs40Nu +ksE6X50bJyeK9ozPDph9HJa7+SFfn1PmnOv56TxXxv3iHukJ70OyyHx08FzZDcksZQ7OxVPSnCte +U9SFgiixPd4SqGaeQkFw/JhpMIh3t7GV0xjdDLa0v+o+tmU/NZ/LZDdtJKRXxyCiZLDmy3qMcbKb +1bGN1kpySnaztk/tDxxU3LJoGwyiMU2dzJCiLptBkynsDpg2BIs0ntg0qW+nzEd3PKtR8mT0ol1p +ZfY2aesQSk8ppij37dRl1qGzbQ+QZXaWLetjRteZk+OwJ4x1bhLw7bVp0OwCJ1ZlS7XLMgtMpSnp +88Ac1S7XeXxzpxh4D3l8Taf8ly2N08o6Nc06CcZelTbGwAcPPresBpUxS9G0Xj/HGHjXUQTtstaD +abp+bvP4hIlTTowdMWij0yGwlWWITpSTD6vMFC/AnCnePca0DtYlMeaYJup+kgpHWwhjWscvlbu7 +j2kDnSq6wHqTTC53uqzB52s0s+StfmXut7TPl9OBsADQ29RKZBMQb9QLCf95s93dFRfGnmzxORh7 +HxXXxp4VAH2M4gIgnK5GAess36rhLlVuoRV6JZzli6TSmG8LmOLm7GTw2bqkYVaahRFnIHu7HDmf +Q5qziyNPNCH7K098BvPKRo9MTQ2h/KHCzAXKVScjVpT8deTNvWNiKmFNySFBzsB1rDOiZqbSfAF9 +7Mjtjlf2u6U+9nXkzb1jnWanjyBaGE+fDp4Gn86UsCYBjx4ZzZA0+chgUJQX94fNkLSb2VmK2eCJ +cTsk++h056Q4uyHp7+6I6/y/OCVpFR6ZY+SRWTJKDWjC2y48MuIZn0N6znYqvrOMR0Zl7x8v75EB +AEI20R0e0tAW8cgYsgWX98jANDSdR8YqI9UpP4/x5JEx9fMfu0jPcZecA1P0wIZzpmR34XuwVAeh +VZZPFGXZOm7cjbJMH15HtlwQg31O4vhkNZEMcF1Sl8HVOHXA1FIhh5heN2loCwawq+ULTCCz9i55 +SB8zhC6YZgs65dV5Dpo1RqiivDqX8Xq2eXWq1FGbTGFnJ+iJ7SVVqt2r0i1tQ/UujHeRwmcuBZ2U +824VmLSafDjYyypi6uzz4bzfP7ZIPpxZFPTFYNX5cEvkWXjIh7OLUF1dPhz0Wi+5A13kw5ncCGqZ +xLV4PpwmGkr6JrjqfDj9vaM4I27V+XCOtwSsJB9Oc2LlItRysXw4vS1mdawDM9mWz6yHAm5lMZEA +lDYm0kq3dBMTeTNyFRPptPenPXpZNSCPAiSWz0ZHcKJOq+8Sjps8EksoWB9DcFaQyWWIZLCJgXfm +aDC5ztohZox3VtWysYh4Dn7vGiKeg98OC6HbhJbenrubZbahknyk8iosuw0BMNtrZcz4mOU2vB+7 +3YY22jjEtzd70ZTQVnMbMILjbftY5CMDOCtJhCwk3EkxRzjWVwJb3KZlFWZtvBLY8TY0rVdad1tj +OGr0YcHkM/uLnRwNajkjldxcNEBENWeri4UXykhtbL66SCJ1mZHa2Gy6cRk4pPqtJCP16Xs1GakQ +zioyUmG+2PIZqRDKKjJSIRx310DrTGKzuD60QawvTfUcZBSOiauv3YZ3S29DXSqcOR9bdSociue3 +jehZRSqc6bqsPBVucb+lFmP2trsHu3KJVDj1HUQoGe6XpMKZeBV+QSqcuX/MpX12b6cYqlmB+v5k +u8SnT8tYVTc3wmv1sXzcwSxyG+gFQbGuPIouHMgQmPXNdh51GMMlw14PF1TZ6Pcuj3DsbucFrNxM +5Cm9OCc36/Pqniyvw9ELB8k7aiIelP0Lq8ZFzfoT1wCVuEyff5b7N43XwlZ7XiwltzMvpXr6ophJ +zIKA85fqh/w9KhteeChOMtkKVz/O5+KtfD6XOIFFCGpjSRwF+tohix4nbS6WWdYZtJLEHKVH67wz +4TJ1oSYvbbLbXuv8VO18VnXKfu4G9jdGVhl2zP2dXbJbO2HZKVGq5+wy7ALn3dOGVadvNp2WY0lV +p/pcrFRkqvLC6ZPdmLvPqlyZUJcCthmyS3Yj47pOtfX49gZWGXbc1tY3N3+ySnZ7tMs6G9hn2I3q +dctOd6qdz7ZVpx37enyXd9adFs8ey5bo3R7Se69WnV5qM+zQqoINK84a/RLpPOWy3Z5ZO+xV0LRk +nqquIDLhC9xOFJ1VzkQRPZOspHRp3tcLVDvfsYuQW60GGxniuWjOiC52RqtJ7XGOUNV7TazrWH27 +GJLqXMxmUE7BqU5xHth6XWUlObOyIyZ3qrjwLtlVkvPkhXssuA6RdMiGRHdCeojrcyoiZxvX556e +HIrIWc7PrO6bU7ERt/NzrjXgGulOdUZ0d6ktUT/O/X4pd6wLEVmGu7otQGfv6V0km24xP4zXbDoz +O0Cqxbm6bDqX98MsmU1n5hPU75fls+nMcukWzXy0zqYz88WbR9ovk02nQYu4Z03vH1sqm84MlMMN +IQtk0y0okT1m05md08iycmXZdGa5dGp7fzXZdGa5dC5jezxk05n52qUK7KvLpjNbXeTpXWk2nZly +o44dXU02nVkuncVt80tk0xmH9LllrSktmk1nppz6AqvOpjNbP5NoqCWz6fSgHGsKL5RNZ6Vbrjab +zj3Glsmm04HSn4mvKJtuIYx5zqazzbFaWTadeW71qrPpzACAXlacTWd2WqKLgV9BNp0Ze9Bar6vI +pnM4GVlRNp2zfFlFNp0ZMhRtfFXZdE6ZXKvJpjPLpbOsx7e8ARhTDEBNfTFPVzdZV/EyFqnU1+Zw +mfj07bDZNchnRla1bBavV2cY0gye8qy6Xp21duEOT7NI0BOeFCxpIiFhTqajYuGSBDQJChZZz1aD +0g3JLStwUV1OezC10JAgxsCgPJVdthuSeSCFJYexwZNN2WULlgmlmNYiOiSPpzqLiN5Ojh0Km9t7 +5uRqWXaF7pYuc6e658qlSr5ImTvL6nInrnKVXJa5s8rkcpdI5ypAwj4+WSl0t9xale/HbqrM2Hqp +XJW5c/QoQsQsXeZO1GHsC90tXeYO5745FLpzd3g0PlnBPVf04TVpv4ju8yxOVhaiND5RVO6Fc3nA +1A7CbunT8pQHFqhzjD10ok+YRgeNZ1sPvKtEOjcRzT7nDEPrIA7X+YWgF5uwQw9BZBA7lq4/LSW7 +q7AFet4K6vOJ4KWplnM2uxvK6rynfDFYMLFLEw0FiMohHtx1NBQA5Rg/5joaCgBzF9FtH9iMeN9K +Mh+XPwqBFQVtrgMXV98lHFe1Xc2gqCK7aqvYgQiKIZPdNFPYOZcdAXOVWGtVA0KfWFsbGhNra8PV +3QoIga2kkDGiMTBaN8xMLbssUVk3Q6VjvVe7GOpd45EuzMQzRlDbWuJWMdSdaW8lmSnyzcfeNQkj +qOp8VRUMwYsL6yNi13v/2lOhaqvTN1h4bWl1AkOxi+r0AGcFtwRgOMtWq8ZQpE1odsOht1jVaxeJ +DJ5OeMMRk2144yKRwZUHfukKd1J+pVWNuwW2oUlwxaJ1q71VuLPLfFxiG0qEJla4W0mlPMd8IneV +8pbNJ5Ir5S2/DW0q3GnzktzkhyxS4c6u3iuscee9wp3bW81h9tPyibVP34qaY2W9uk6sBcCc1Ryf +G0UH16ZbLLFWn/nILus/gvmFp6bp0N7uuUJwFuCbhjsiIJyV5HOeEu5sMUc41rmwuiQmn9M1E6hc +npf8drMkJvWpKGQQUcM2TIUcFsKFX0uq++YyjclNElPw4EVviaqkmJs0Ju0kHXynCih5XSzTmFIh +Vxnqtma7vCtTITe70k0SU/BgqFe+F7Ur7zwlMVlFEMHaiTaS1ptieCfm8C5xK79OMQ== + + + NLks8e4e14BYRY5rPm59qxi0X7xWpPNU7hGh0lofu1/d1VT36PRtRTmu95ZXU3nXYZpTT+UeHSrl +JRbMcVXtTzkMw0XWs3OOKxiS66xnuxxX0QMEF6LKm/cnqX4w461yUC/0yHwucXxb2Ooc13yBwmGk +Vj8YvUU48Kt8gbL7SndPpTYVTG8WsOBBrl2V71j8pUnCOzu8UneqyYfzBaZbN/cXaleVtg5bKv94 +b5EPF7ZOwpvM31Kklifr0vCIXavcP25rm78KP1sl4T1Zdgrmslka05ZzJcpbD9eWnQaPmvEPqzps +YaVTOZNLQfAFS6k61aamTYP8jlJHkNZlOYZDh499s059AYhgfc05TRpeQ5/7p0bvyf6FRafcVoA5 +K7wpPlh9RtyrTaflbc660/Ll1oNZp6jum1DRpFbqO72yqyN4cmPdabF4XdJEdoFut+H7qPxLTMKc +7x4ktKtv0Y7OE5bt1PmVxNtuKusCYiQ1mhUVMQnmfM/olU75sEb09miFZ97GTywLOpdhkwCpbBid +BmmqmDkHTrqQzQD2gT6xydFDYp2SZAytshwSpGTrQeXdpDY5JzZNV1WZBTl0HSqzuPUkFexDqyyX +zlCZBXRQ8xKCZpd1p7t5comsNIcITYwlnzt60h16eZ2f7LWGeXeeqyxaDMkQpaXfL66R7ilKyxew +G5S1n9jbkAC3tI7TEsdjiI3VsaviU3pXe3hdNNZMWcyUALCPXFx97eCDfSmu6vLG+9iGuxsOXWQj +2bqX3Z7yvBSXuYlWyUk0XBm3ULKb+ZG1p3utX4oLepa1t2jCLMBlL6E1uyvOMl/MyWox3hVnYwCZ ++8e0QSMmR6yNkqd6B9YcprQyG7lR0nOYRU+9ccKd1T5GJ1bO5es0I9P7+Z1ddqgen6VXhfk2BBD0 +hIl3fcSi9lPw4M76cNBbIpmhnsUSZdnsM5k85VglPd1zoBqSLv+lXbbzHTtq45ohqUL1xdNq1a71 +mArY23aRyqm+58omFdCppLHD+ikn7+2yc6KOa2LQ1TU2rTLjAZhTFZ2gPrvWBphOqiyHMcdcHveT +1J5cLokxx3o6njBWZZ4sgBnShc20QxFjC2YBus0BdH0PiVWCmKscQJvodBdZgG5zAI3+ZC9ZgG5z +ANU3HHrPAnSbA4i81gtnAWpIxcbC1MfBessCdJsDCDG2eBaggk97vqHNsfKaBeg2B1C2kRfKArQY +kiEHUH1eicdjnNXyRfncV2Rbpiifai6/sCifwavwS4ryOVVkW01RPpwzYq+gLF+Uzxcw0QpXXpTP +WB/5VxTls66PvMqifK7qVy5TlE/tVYCD4iwHJaLIKTXYuqrf8ndDHa/ibiiXdf1c3Q21dF0/1dRW +cDeUVV0/b3FKi9b1s6/qt9DdUCZ1/ey9QuaWuPe6fubEZ3s31AJ1/ZwpeRV1/ewjQ2TP1ZJ1/Zwy +uVbk0LWt6ucLeHLoWtb1s5+aznexcF0/zUAMVf0WqABiWtfPfkJmEaqL1PUzTUe0u9XcPWJcZ8qa +3gW9QF0/+5u/5DPxJev62Qq6PJJiK6jrZ+8W9nQDlU1dP3tT1zQKeoG6fmZpksrWW64e3wpy3j3V +9bOHAv38q6jrZ3+g4nMNZ5nEd31G6qJ1/UxUTVVVP3V1BmKJun66bUhoq/pp7uzynJ5CyHX9HPNe +V1LXz76qn0zJS9b1sw+4VmWkLlXXT8nfMqNF3T1XC9f1s0cg0mBXUNfPZq9Ne/SK6vHt2kNxXY/P +oZyc63p8S9X1k6GYbh+v2RyGun42eQ+O0bYdr3X97DV5eOPBKur6WcnwG+NJ4mL5Wy7Ueekk0Wkb +OtX1sz9v1kYRLF7XT4ttvbW4aD0+b0Ea1vX4VrB95Kp+y9fjc5PE5HR7gzFWw1spPn1G6nJ1/TSO +bUNVP5wxtHxdPzlVyq6u6NJ1/ezVHAsa81zXz76q39K3Nol1/Zb09bms6+ci73UFdf3sq/p5rse3 +UBaujlsa6/otngyvquqn6mWpun5GV7K6qp/VLWde6/rZh3fppNjCdf3sA510PqWF6/qZrIuqqp/9 +vXDu6/ot7rfUYsx7zpOFXblEXT+FcZlV9Vs4elBX18+WIlQVQJar62evGGLrdfm6fvYJsaJEXrqu +n3aS+qp+Bn3M9U1W2rp+1koQ1mEcbrJyWdfPlQ6zdF0/9UoaD3Bssmst9qd5XT974WCbxbmyhFgs +9xMm4uHBTkc7vzaP+NDfK/WJb1TUyUrw1Nq1ax94r0tb1FCTRGPK6U36YKzOg8e+KbGrkEZCxkcK +YojEeYeT8XmmsUSrU5j7Rk0/N4BYOd6IPJ5tE4m7Ho8bwXyqje3T9FGcCA03Eq3HMUNPPo9L6f5z +8vJ6NxQbhIO57xxR+TjLbn3Pc9zGU6NNg19vmQAr7FV2Ts+/r9jv3v2jL8CzcaYlnJbu4ifxyQZb +LTNvuave9WG7dsrdftY7Z+z3Tajzvn2bDTOFr8361Ukv1d+/G3UOQ8PvV/47MMkMubON27PD4DYd +KnOB98ejo/D8c+uRGT11UuLeR7md6et67WYjHnnJbFAf3zeRfTqYIUq5kxxRem8dE2Vu52oyeUuG +JlPh9mi69cI1p2zz8ULOtKxHDhKx2zhdTW5KaW9ficn0aQSLzSW3cG61kYdo8kv3HqqvyWzrcgwN +arkEJKwnOX8jA7vZTPXYDFkIGWC6sx24LvT2huVcUUZjqBHsXGzdPNTT28NJorRDMR/zrX57ow0z +SY+l5NCNeXTMnMF4tdMhykncyJbq9QCx3Wkje/9ipFXZx7rtA6Z2kVclzSn+VtXUAFszw0OaC+Tn +vkDhodS5QwU088/lqzvuLN/ezCRm+8eZxLS9V0pu9S6Ktxn6BaBtmC73b+6eshVuowng3HxLYHH5 +zBAZ6fEwlfH+JbNX3ZigWWUHI0jJ2ZPb29dI8eauAn+BCV/04zBpN4rN+jR7P0GWE5GYhWA0wusM +c+IEGw9Kv8gQ8h0DjPBD8Ce/i7J+AcM5GoM/D6KIw2wFgRR7nIAH+bj0YSlRKlKnAgBbISKFaGBe +ClWOjsho8HNQbPW+k0QizYfRQOHgnsndPLmX7zYSJHhxEFG9aGznD3wB6VU+pryicg/Xh9KLo4Ty +gt7e+8hKL85J+cWLiLbywa7yTOkZyv1yPqp6BfsW4ZTBrgeY2AUzfYrAOYep5+kXYIDlKxLdhENW +Dq9oMN3LXdV0mx8RiNlLgPKDUY9sbfMp+VwMsEJIXjmyFTsgYaMEzFsakK3DI4i2S1L85vIagYVJ +rftbsOcIzC1GYmmbCscYqP3XY0qnVPgws4d72YMH3le5fvxjN3vReq8WTo42agpJyscCea3hGtAa +nDkqXCntm8EDlLwoxMvqgQwxx84utjvl5wfhI1ubb3eLD+0LAs6KRNSLKfmNep6/ZMTVuH+hJfKq +M6qpFw75lrQPbmMIgVThMg8l4G1CIvtbALv5DGuz3ZKiusveitrFCP6m5V8MBlHcG3DgzwcR4mur +BJfkISF9/UDIv0jVaN6ol640mgcavfAFxFeF3ra4D3pfLJ6LVtJqz0x3NGxG5gIWbAbISshodGwm +9Xw+ChVvc6fHuXB/AnP6uUquSMTrRjajr9IbRNQGuICAbnQNy+digFuKO/6uF8Ekmbt7mYJZbcYT +3c2LHXo7OZgRRCg+FacLmAuKm0buSfAnE0ZZwWTxKQP/TIGNtP2Vhnwjqlr9J/DNDaSJShypQTBS +JY4Md7L8EoeGeSVh4YKpEDJB7qjcKWn2JARDRb/JKDF88wWkhTrZxfsumg805Wfi/gU6HNzOJ2Dh ++ZtK/q2XbWuYUJUg2OYJXIgTFR2Q5dw31Dg+zhHGzkAH9yPEieHUn7KiWgJYD36GmStkOFjS2Moh +xTlrGmkvLWNIewZfnUI1JwMEuDDHes0OOyqplDv0bDOf3QSfXc1g4xvN3QeSphRWg4h2izoQkfz2 +YVEW0BUqlLynFZUNPdvcTB+WiXZgWJhMDka7ahUC6AfoXoVSQAFBdDbZhA7E3d1FVgbRDWm2SrkP +kRrC61d82ovRO3uPJMBxIQopR7Ir0VNIY3H89Hn6Crf401RiM68zDea3gmKZY+rjUtaUnhUlCRWY +hqrmJnxxj3Cn0pODitKym7ndbUi6yQElqSX4fgYg/jaZsr7YMiyEK63LfAN2uoFXgJk+7kApVnrd +kO7ISG6J4+lfn6mV9/voUMRYLgydHvhSiMpzfPPrGuApUgKdxmNogxtvi4BeODCyckREQmFak5Hw +pEbC/PFcRoLuxo6ICgWPE7qpurtDRoEvEM4/tF8kJIDxqJHATyyRIKFgd1uFgsP890iFgsNQYYJQ +AChZ7Faq/42WxBkJgAn1ErhTmj/viSig5qQZHeBbNe61SEgohH23MUoUMRImuftHBQmh5vbVkwUd +iNfRylXLAR8zIyVbEBHvtKiNHJbOAZRReB5DzAwAWhfXIOILbiklPjlMLLkaUWuaRpxfGoUNTUej +FiBc4QFx/mjcxTTozGUoJIJoHJ5rx0DajwHblbb8KUpJILgtZTWmm+WTvKZdYldpB0ulX1jUeQeL +E1qWxsLL01hiwTGoaIxclsbCy9PYriUIFwAwjcVckKkGhH4aDqgUacwWE8SSFJGI+AIuMGELwg3n +8wVsQVih0tVqQABxtbdnIaJKuCZsJPdNQRDLTkO1M3yBxaZBeRoD2vv6UdDO+7PCHJzmI3gMkzSr +ufTrjdLLAEUiu8UEFfU+Bh23pJYlKipuRhGeuCXlRrkxk0MKt6SW3eIUqf2T0vExihaNhVC7DgzS +zBR7ZJBVpmj66fJtCFsRik1XfEnti2bfeWco2rZ3vRj1WmlHiUTjO4asYXhHxPQzBr+OIxuEPrze +RLZfUDpO3AqioB9kCmPvmmwKY99a8ODqG/yZieE/n6cdZCgG6e39/bfSa/gR1X95yXzI5mpI9vo9 +E+1QKCXZp6ldlWNNNYN0JqpyqwUPq2npRSmuvED3XcguGGDsqjxuhzfjnOQpS6FphNU9lzMRlVtN +1XO5pDj0XlBNaOSFqyZEr0L5nIDugQjOTAHGM4UtueZLoCFN9zKCHWfNMQnJ/jImq9fbVDAdgkmN +l3HRt8blIeVcEri63IRsVc7RAxFs6+GRFH2i96VI4rTWg/ygjs1/Ksyl2lKn9TjuhQhvCwTVrwWK +0WT4JbNH3Pz/3V17W1PHt/4E+Q4bFeWazGXPnhlvlatgo1IRBbQikRQVBQ3wa/vP77Of912zk+xs +EKnY85zn1Kc1s5KszKzLu26T9Maw8BYb65feqft05p7WoHp/3roEx/P4Nb7JUVU46tb147vTG3d6 +xf2N/Mmc/31vomzFba+Plfa79coMtPF2aF5m8nTvYNgheTlT7bit3CNUvGyWzbbtVZ3aQIvvnrry +0acNUz46ffVGxoBmaXJ3p3xk9h0ZOGEAG9vZfkCO203+LsqR2fnUVundO6fPSt5vJw== + + + N98PGmum2nG7s/dx8EQ+8ILO4CzbMlqqVOI3U48gWdu9rYnU6Fp6PSceP9Xv661/KV8Cx54uO+f5 +xLBzPmh235KeEm8dp+xiZVIsj9dZGBlWpgfNHzj2g7HfRcCcj87Iz/fBw+6utj5snjRTq+rDzO1p +QSd7487So/O+tdMYh/M9+TVZ7eA/fGqjrJFrjXbp5Nd67NJxur8gCDMBhOkczH+6drisZ974rshT +zvKrGva9ah5P43wssgWYhaQm/XBjIkjfi45bttAe7ueU2JNmOb6Dpf73fiNo77JglM9az04/dXtP +ex/2PxxmM407jdbcqtYbh3tHy71u93n3r5PFo3enn7uHJ9ntrDW3vrC6Gtxi993RXjeTOyjura/0 +GFJrrbxeU51Ejty7SV3oxT/iw4OV68/u7S7+obbuV27lSIl/68vzr2Mz7z8iOxmbftccH5vZ2Xs1 +NmOW18cmVo5nuNxKbYjByc7Ow97CSIqp64vd3vzp0vTj9staA12iZXz7/OG9xvjSy/nuswet4/27 +rZW57V8Xt5dfrD9onagj6VTUm4PppINh5TmzzV7PnNwcm7z7JB+bbd16wRnnIs5yYzG0xmYmHzwg +9dHY9G/XnvB8T/jEL2Ozc3ZvbObx5srY1NfrPdp/KDtIy6e8KGemy9bwcH6zvLPT98G1I3GMRnIh +PbO/z87ui68lxrJJzHcPmsQtWfIm2kT56GN3qvQiWE/Vi2R5e4LeuDJbYgd/2KNk8cfG7ZN+x3m1 +EqnUyu5J7Iewy0+ghvOnxvi/N4Eazp9S1/vyEygukVqMYbn2YMh7p+yyry1LyjAFYOvOi6FxCh/k +NlU7wP+fQrVrT1uMtTP4gK83sNwQtlNJOa21V3YQD6crs6i9m00EpK32MI6/7X+KGPs2JLbY2r17 +8/b+4a2N5btL+cdaG5T3EX6rXq7q37Aa3AWI2OHhwpDjefzSdxsuzbH/O8bCcfJR+C2Gh8sPbnWf +L67u3RsrvWlrUw/GTGZkfjP5aed6P2ju5oOj71bNq/NU8HSmhNzORqs0+86m0p326iQeId1IcaXz +xtyPqwa66uzyrkP5eC8XFqVqD54Jx1m5AIXlZj9NOnil+o/eDK2tU03lDvZs5Yk3Y3YHZ5Ho/vbx +13E5y+h9jIXqHSpYbRVmBijwfZghWgJoiCZ3y2sV9w9+SVgz8/XL0/NhZoBj4ud7N1s3yzZ+CseP +D8vjPu1O9fPsW/fWp8rxNqBJ0m6asyrT7pdLuynWAlwYgVYmUmDuHh+w3lqZKiFFX2uZxdlX0zLe +HoT12fI7wDLj5hWZzTL/evjrZPkdNLfcOv+aIPCnb5C8Z9q/bApkyCc4CmvWcvQ0U5+oJegpNKda +AFgzGDQ1q9P1Lwtq8dHdI3UWdRBfyjHTvSmZsKVZ1LToLVU9D99Ir/vJbBmpv9xuXXommXif+WbH +4Lc/khqH9sSrH717rY/DEvG8wQ5/Lfq3/mCnN12bDfV6d39Zr/Y+1OrrmeYoi/f3N3amlgZDrI3a +EIu069UR1rZ5VBthqaW7TxODNPH67SyL0xEWKzdXqq6Sr9/qx2vOTWeeGP6sKO1pZZqPmgNaS2jy +24X3YbUz61+ZX/YSzCA4bteS1h8viyc+yx1HyqScWo2Vk5w7n58NxkdbF4yP6DnfHx+VE+LzZifp +t1UvOTs5Z3JS6WE2xn+oxSE/aphE8KYqApnolSLYHooAZ+F+qkJgov8dIezefTIUgX31SYehCJhn +N2tjxOFvr19GCJfp9F/cj5b/KfLFM7QLx4j8H8X1pfi6ZkiXnETy/0t1BVvsf+vgW7u43B52ehcz +SHq5kEXn+Gou9fD96cArf1Aba6+/XMKmgZYVFjWbXtv5hltcVpRr3eMhWv7QYPb+2tHY9/ew1b99 +eP4uev2bC/nW5yELtfJ4693IGPz1wH63KopXy7+vPKvZmPyMwVVsbP3wyjbWPbniHj6NXdnGXhxe +2ca2jv4R9J5l0OkNbOwCE9m+6BjvLy3Kb9rYwenVtLG1U3HXJLHzJHEhi84/Qz5GsTqLbu9q2th6 +f1wzqVJilzeqrYMfMOyR32O6v3V4esVj9MbO8wzUL5c/xum1H9zDIE/evn79e/5pjl8PWYzdevF+ +vbqHTufbMaASkS+SRKf79Sp7IFp23l/RqDoHx1dFy87hyXeh7sI41Pl6WsmTf8jFO6dj1eW769dG +ljevS6mQOsW8jvjLNLsTRa1DoronD4IkmMOarlL27d74/DqV8rfubbn+LcwdKRln+7deXx+nunJw +aZWt6vLRROrmoRSeGi2FpTKeKZcLTambm4O3tQYN9tfDdjAlhsK20nH7eROo4fxJPuVfmkAN50+N +0QkU22APN4x0xaqNnrWFaWmclY2etdXZfpF6OlVWgWvtZuqt8bfOsXymmP1r/GePemmtbSa29pfn +h83yaveN5mR/FrUqupyudgq3njblU+x8sOFO983kHwvvi+Wn85/C9VBpXac2LQrv8nvmZ0YIw+p9 +61nrH3E8j19jlOOGGnIsNu7dXpjbuHnn7cJ7/+uXuedzhy9TK27+1dSbctD0bnNwY/q5HX53oard +Tnum0oPdLRuQnWfpuw38hvtkerR77UVqwA1bQ2Z+265wNrIlgxZ5VCq2s+9Sby11aA82mumOox7c +ep4djIVmq33Zg11TaaxVOsIH+3m/f7TtyrNsqutSmg3baunbhudesJ7+ederpatw/gXrn3i9ujH+ +zQvWP/F6dZpFnXvBevpHrlcf//d+4w5MalXrnaXDveqMqTE+Dsp69+T0C1/gdua7+x8O27t/d3sN +naU/Cn/wt820s5lLa8f/tDuNid3TvQ9HO/u9bvdwMmsfNsZ3WnO9k8UP704+HB3u9v7OboOks9b8 +0dGnbGJudX35Zbb015ej3kkmn5I9P8oW1tcnOdu68HUvPhx/6Hzqjry+tfm4vbG6mN3Oyn385Zb7 +e7lDLlrtYDd4SXo9hLDTUNkc/t38s3GKPzpbxOJpQzUV/rE43LcfpD+buw0lQjH4d/NvLB7hwUeQ +/szy7HH26neV7fEDnjV80ztnfWZU05kizz43tGpqDUka3XTRhKzd0HjkncmMaRrnYqZNM/d5kRnb +9LYIXBcBQjeumceYLTRsUxutIlloPAMWedMFn/NTdFFkRdNE7TIdm6HQIavvYaHxx/k6mphVTVso +VcTJrLV+0vtwuJ9NzM/PvYOhPDs62eVrkxR91lo9PMkm1l883Fl/v/ul+/zvL92KgKdOcXyIFRtQ +yjsIMOSxwOZV04fo8lDalKIs86YxXjnuTxkTISMcPA9OzmOULTLbND76yHWe+5CZZrAuyvMQHE9U +p7RBUbHQIiTjgsgZbCLka4qmhYASRQdsj5K1IkhSDJSTN6OKBhYPzWsubcTroImgo6Vmosa+Fhp1 +SpsUW1C/1FrEe6BdrUTfhYfSoH9rVBDl2dySR43ShtXEwgbRmCo8T1M0vS+gQ+jUmRgybNg5vIfr +QmcQobV5kqAGy9F1W9Yq96WI+XITaHGlxOsaWDijk/bVbUYMg85GY7WUqsIxoZnPDdcslKWMYKEB +Flo0C6uD7N/5wsCCXQ5XkHcEeMRCo05pNyI0ZoOm3JXLDTUBq9O0GvqTMtREHmg9sAOYF9fBW0ft +Gk89jKzFLyPch8oPQd4enSwheCvLaA3XhTU2vX+EksSucyea1YURis2LQnStCgvB50XOY2CpLRUz +KpqFM8L6WYqY2vi3MWCjBEnVB0n8tdcosonJbPNl47TEXANx6KIKtT6YXI1Q4NoGvo0HwVgEIOxQ +aTj3GSA2QLwAv4EmChMESYAYWgh4g82wjEADMQUDNbxoWDyCSuQtzpuM64BX0o2dcdkWWdhYwFxy +wHGeEyyAunBk3wyqENgONFYNH83FkAhTVLKGXXsnTgolJ/jwycoNfAv2mfuCKEILhaUBt0NUBBGY +qGJwwEcKYuF5BwsGNdfKJKvX2ErT+gIYA9uLRBkctOkRGXJuzheu4CuC87JWNGaLHZTvwHYLfDoM +LKog/hJgpbBbYEuugENYmxgZPxzE7eTABsgWmzq3Tnh4aAJHxkkSXJpm9NgF9hu5z60GZebhg9gf +XNEnr4wKnxKg38Bn4HVRM2jlLkSqhPFOY0euCRCAcwCEg3ZEKas1UAtiVTYS9LTDy7ANBkYESGC3 +c8l1CwCHF2sqFLTCz4cGTEbr1t4GwWPPyzgMGFRBDocEkGt+Fg5PLSvoH76cYi2e1xAo5KjzwiWl +aQN0xQFMQlmwzHMntgMZSwgQocNyRH3QqnMQOfYrcAAejgDtSPGem4rgFXnilCPU7Pn/WuSG/mPU +cD4oVwLpZzErU9B9CxqJHK2wjpZZ0LhEeVAILCSPptTeCAXag9CjyqFPr2gSQnGUPhMDGpgmjoo5 ++xgIxrAFjzBlmfFYAeMaRUK7SqESyVRBJWn4GlQRYi7BAGq1MEMdQh4SnI9QxHRzbJEJFZnSICGj +QEeJRBOw5hFkbX2KolUC4V8lh4mEpTLhMIWSBMLFflKCJEcojDOJ4OhVIHgECfq2R5QkqCnEK3C3 +KhTwSxO8ZvivU8S3C2sDvA4ZvJUdFSGn14UEd/B1oBvE4XNtSh4jFOEBphEUk5RAAMRhcloGREk0 +iABCWLs1Yt51SpsUyUUhCITimChwcioqR7qm5TR54Yl1CR8gu5y5DD6FepOdjVDagn5EVINkCM4t +ebD3XtYhZQneM5+Uj9IJokco4rzWGwERyQABBMpxG/CDBMFALR5Fe8g0+f8IpU2KyR1NzHvDBJ5r +YyRZyzVZEswLqlUJh1FCuyH5npbIYIjScrLcJQBQVDmWeUh5aWElxY/GCsJYI7uqU4SpDVFQx5E5 +D0oYh6cC2iRhKgg2UARkWIajEYrEowjcE9OLUokY5uP0/5zyBtzCM8QCqOd3DcMXGomJCqlW/QVb +fEFQTGhhgdADwq6FqQjWc7NYxzyFYVcYwm2d0m5YCTh5LikznyYUMW4DwEuKYAO0EIxEdglOWCsP +DVume1rwOygd0keMUISHZxrMJJ4YhTUAPLkebZQZO8I0Y1phY2IxQmkzffAmxUjPnJvphOWHAFkZ +ma0qA4+S9HKhUSO0mdXAnmQTyiuJCih1xCgQO4Ks5Q1YW0/wq1OER/JRRpJY7svC9eWwVjzx7GvO +5ZN7L3uxWrRACsGPcKn7fHSeEFZR6YYIyjgOGKCKYD1p//ATLdVGndKWwEjAByVaYh/MucgF6JEX +CRYCAuV5SdsWGnWKGK1OeRtqKUlKUDFYMbHIUhGGxGoZa6QEebL7EUry6GilJBclyrqI6WiS+rmQ +p6PrEhOqhDbTCsnx4EmmSK6Ek9GHHHbBVJRrJGCCkcxQWD0gvyIOIaaGlJqMUISrzvk5EA5DEysa +PgOT8i7yrDqJSbETEKMpwWaEJMhQQHdMiiTxtMQTY1E+kxIlHZMQT87MefMy6RuhtA== + + + E4VdIWxQDd5kTY1QTRQWzuYOP7PEBNZF1sWWVoMTSl4iuRnBQCIwkYiJIZJbFUMKO55pCnNMWwbR +KkXA2BKN4cm5QD8Tfa8TIdcJ4ss03OiUsNUpYlMJCxGBiYVUXmSokswAqwJGi2xAoq/YdZUgyldO +DMblUepRlUtU9mJh/SQTuKp8UXrGCEViHaouwSDRk1BMkQolaSSxaZJaT4GwzFMIEGAz3vTPVaUI +iyCpPiw5RMl+JStnthutGGmSJ5zdB502NkKRsxmlJMWPBaWC90ryyHUhzhJder4oVJlBj1DAo2DN +IZmmQAZhjSGePoyQQ8A1/Jvleiq/6pQEjjo5cnRMClQqH7gm2LGslCir2XWwiccIRXg4KoYiJShY +eptLbQdWlgwM2ss7AiJB4jFCScFD8EdaEZHvCV7JWRSRSupZI3iECskkHiMU4QEWUn1KncK1s8LD +IC2TdaHkHYY1SOJRpQgPSUOsJJQZgjfqF83gjazAJIRnR6UA1CoxjxpFcK9P8c5Li00xjsuaZTVS +GhMkLcFfPpnHCEVMLAV5gGdqoSLN0hIUCi9pXyhSdgSQLivxEYpgnrQWWarmqRjPY2oOpYSQpTUQ +EK5RhFTn1SjiwWLpBfuxqgw1xnuWzoVROvl0kH4OY5H4guwQoceY1COoUYSrWDATXxcke5QYg1Se +3sseEosiWoJPh6tRUqrHrBBYwuBMvIoSJhK2ANEkOg2y4BpBkNxToqZfJvhmaswx7UNKIDkj7RBO +n4JTnSK1tzY+SllQpucUlGfIU9q78jXBs/hCBEx5pM4RAig+N0gSYVxR/KJGkG0KrBewdSVvB3YZ +thSc1GOeYogof5Q0LhKHKiXtgFkAtOpUIYmn00wfIlsXRWq6q9SUZy4vrd4RSrvBRgnbxlKQ+CBt +WlRZYrHSt2EewDYENpaXqailkIhQAu41gnSPITTJDlLfBnKNYlha88QshNn/zQfoXqdIsSydjVzy +nZQzacuypAhlRa6Vk9aGpPlSgo9Q2qRYpIXS/nCpBK+F1PMo/79akz86DqKhFEwGWGxrmfkY9nlz +UthsS71l+hfKBcmPAkUIB7BwPJblUL9UMXzeBolRsCRp2UdWMVSzYj1E1wPXYOAXEI8GQBlpXiHk +sQmDBM1q6SWkygCQkVpRgB+btFgWpxw+sfSU7lyexhVSQufWxzRGMalfw94kG+2FWHU5NFHMGkoo +lzaglTCRE3XrAvlfaGNdvofFNlAM0iOAwYu2pJkgyRxqUsKjMrlIIKIIYGcrMBiynkjIUKdQN3nq +q5Q1SLtB5VhApHQSoZOkLiudY0rS5Gxw2zIJJFxJi+AMibxDSQqp0gF8FyhGWSYyMWdDiSjLmE0V +03ZGKUSu1NVkt1sqPS9jnmSAKAthkM5ZFs1YI2/O2IhkuY43FLmUAXWK2DTtT6piWiHBTXlJOKSq +MqkzgW3LPgX9RijD8Rv8gdO8dvIlbFlMR5UUo5JxxdyUFHijeJcNKVHXKeCwNpUUVKVZKxO9mDMM +OMhbdlbE4OU0o5R2I7AeU+KCiAcRFZyWgCFrIDStXylJ65yPFHOdgrSpbxjszmtJFKB7BkXsFamD +9OsVK1+sVcHEDhsMVkwi+jRhrFHEABDVbcqGkSrQzZV0xFkpMlrg+DI3ZOYfUkewRqHf43RR0nJU +LokSUsJsZPw2SALY6I4ybUhLnUaeC40aQTThQjlh9X2C84IV0vQnEHJ0QGSwZQ7KDlNSZkw2MUJp +n4HT0kpc1UrYPGQCiERAlVGTkwJ8bNDlWiU/y7VLGFYlCAcnKMAyyiRNwfPSjLSwKk2UR5HiPMq/ +DmwXh66NOqE9n+50LB3uyR2K2dnG+Pja7n73eW/3w6dur7F/vPufbrZ7eMhddL/gmWy/1z0+Oep1 +s+P3R3+Sgrf0Xz4+vvR0ufE//kUWXA== + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/originals/SVG_files/Audio_pink.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/originals/SVG_files/Audio_pink.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,1662 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + + + + + + + + + + + + eJzsvWuTHMlxIPgL8j/0fZAZaXdoZcYzg7d2ZvVqLW/Bh3FIiTLZ2hg4Aw2xiwbmMBjqeL/+/B0e +WdVAAyhJJLc7gUbDO8rTwyPCw1/h8Xf/26+/erb79u0fXj6Lt/PN9Hd/d3j38sX7t+9+dkPQm5+/ +fv3jD+/fIegnv/npzZJuZ2i0+/n6tTT8x5fvfnj19s3P6Ff0yzv89E++evGHly/fvLjZ/fD6xf1P +b37yU/jNb1+9f/0Sfrf78dtXb29/+NN3P9UXAobji/fwu2X5+zn8fZiX+WZuP0sVG7x486cXP/zw +6v/DX5e4RoDt3/745ttXb77bv/1/f3Yz3zxbbmKAP/Cb//rqNy9/2P56voUPzmuhVsttay1D0+Pb +b368f/nm/a/fvf3m5Q8/HN6+fvvuh5/dHP784s3NL158B795cfPPL1+/fvtvN/vXL775nxP0O399 +9+r1S+ji/Yv3Nwt1ePfzJXy9//HV629/+eP9H15C52OpCI5fE8rf/QC4AC3+jOD69c/vAfLVy/fv +gUR4ITLt8It//m8H4PTbe2qHVAPRNwv8+5Nf737521/98gSvazcHZNn/Tr+F/823KQ8twpJ9k1AQ +A/7jmgwtInz+tg04YuUGv/mHvecMkYQN/+U3L797RXMCRu2//1R6+u7t9/cv3v3PH7iZjAb+5rcv +779/DWNLY7GU23yzZPymP0kr4Cq1eBbXevMslAi/jq3chGZt+ni9/NOrl//2s5tfvn3zkgdl9+79 +VzxBUppn/s6/+c2Pr1+++92bV++BsoKgxqPyi7ffvnwN7e3zd69ffPeDdnLp37nBb1+8++7le5ha +b1//+J7m+6pvgFF//uLPL3HqLPyCX33/8s1v3/4j0fisxttSSr4pi/wLHC7rTYkwuiu9IjZgRJM3 +81tp5Bk9IkNU+g5cEr+G+fOrd6++e/XmZ0Jh/fof3r36ts+pGm5W/kaduF3d36Z/mVro+Pv3L98I +9TCXD79wc3O+/cVX8MbTm28Pb++R+z/g8oMZ8AYmx+u33/Hv7Gf6DXz8x++Zevr/1zBQv3736g3i +nH5Jv1m//vXrH+FX//Du7Y/f//zNv76dfsIC57fvXnwDzW5+9Yf/8fKb9yA4BNB/+urHV+9f3r54 +9f1PP4jo169fvHnx7obg8GEGPn/1J/jNCyDlhj8Gv+mwjyM9vvxXWPr9sww9vfnTy9dvv3/Z4QZ5 +8ebbm3968e77j6OGYXjnMNB/9d9H9PbF+z+ClHr55tsfjCz+79hRhn0c31ff4KR4d7N/9+MPf7z5 +7du3rw3t+CvDLmCCYvu/jHf8mj7w5ldvmEHnb5IG2zeBQPiLewu0fvgN8Mu/ZOyHF69fv/ru3Yvv +//jqm0svuPB7exP/7lMm1p/v//D29asf7vt8cpBfv3j3/tU3r19+9ecf3r+8/xA25Ma/vnrzLUxE +Ejqd2rf336OKcfPVH198/5Jwvv/jHbX8yhDmr0EwetH37NkHZGKIN/s37vf/8O7Ft69A3IK6tH/9 +48ub38B/X7y+UfBPp8tgEPeA6NvpX6b/Ms34tcxxTnOeKzzr3ObdvJ+P82m+WxbQFuKSlryUpS5t +2S375bAcl1OYwxJCSKGECs8aWtiFfThM4RhO4S7OcYkhxphjiRX0sRZ3cR8P8BzjKd6lOS0pwpPh +KammlnZpnw7pmE7pLgMteckhx5ymnHOBp+Y1t7zL+3zIp3xX5rIU0AAKfBp+Xab/SzvTvxb7u1z8 +H2qQwb5H+QukETvinCfiCv7V70X+JvmpAMcK8Ey/r8Q//NvcTzv4u4fvu4n+ORB7D/AXmczfgdnA +biQOvqAzoLrBV1z6D/9luru7O90d7w53+7vdXYNnvat35S7fpbt4F+6Wu/l0dzqdjqfDaX/andpp +PdVTOeVTOsVTOC3wLvj48XQ8Hg/H/XE3HdtxPdZjOeZjOsZjOC5A1t3hdDgeDof9YXdoh/VQD+WQ +DwmGLhwWIP1uf9of94f9fr/bt/26r/uyz/u0j/sw7Rfo393utDvuDrv9brdru3VXd2WXd2kXd2G3 +ACvuaKzu7qg72KEjdQq7hR3bWeewe5W6iJ3EbibqKnYWuwsdxgeRnE4T9Rz7fqD+IweQB434gJxA +XiA3MnEEeYJcQb7gMxt3kD/wNQGTkE3AKHga8WolfiHHkGfItdQ7c/51euRz3D7TOUh49Jhnf/5M +F4C78wc6k27+7uv9O+hTwa9KzwpPkwcGs+zpgXkBfECm3lUSHRVEBAiDSE+qsGThw/y11jbVBs+u +7itMKWQijMjdSitmXeABGbKCoFjTCit9pXeudcWvtsIsWmGqrQcaghNOjTZPsLRAJLXQYksNhAOQ +Vxu0BtNtRw/MzwZzGMeOJgLMKliEIMRgJgaYjxFmZYK5iZ0Cymgocf3ROgz0LCQC+UkgCiOIwkw/ +4fcEYjHTU+hBDhTsDAnLBv/uJvphjy+F73v5fqAH1ht8P6E0xdkcSA7Ru2LAL5CgIGHxAVkIUhYE +XlgnEraNBO4uwKIEiXuE7yf4TgsDZC9K3wWkL2JAMQuCFMYE7eJK0niFvjeQxySRH5A2yC1ePsQ/ +5CPyE/naiMs4noX4nmAEIlCEXZ1xcGCIjjBYBxiyHTaFQawTjWiG8Y001gvIyztclTATDjArcAQa +TJQKkybD9ElAagCGzrD8cZIdYbrtYaQaoKloJU0g9xPsAAE4P4N8OMGKPMD+sAOSVpx8sGtk2F8i +MG8BkX0Hi/4IW8weBr2lFd5QYPNJwJ8AIzlHlku4pumJ9gR5aLyOMz+y2ETeHEhYHPhrT8+OnjYh +4w7EjAPNfFw2IFAzCdVEghVFayDxis9MQvaOBC2K2iOJWxS4+LWbSO42kr0ofSuvRpDBKIUTSWKQ +xfDQTNvPJJJRKKNYPpJoRuGM4hkFdGMJdkEaXHjaY59p+O/6SU+99EwXweWRTz5/uqz7F5v2Nx/4 +gZ8Af8tNnm9rixWsZkAApu/Xn49g/wO8Pc0gPgM2LanVeBFLCTCR0SRfYWlTm7bOsOoUY72NbYk3 +Md+2nDtd10dNFMPSWpaCfiNQwdZ0EW1IdUafxW0BJTGREwn0JWgsaJdbVLduQBXr5F4ZL9C6P5qi +rRrwZRX67sW3L2/ev735pz+iGj9t/g9DFVhpRkoyiCD6IVZQUc/FJ5DUwpLr+ANSOU46xHOjeC52 +lj8+/oB4bCKN/LseShrmL0Q3A7qab65HnyH8lIH9h3cvX77xVtEGQFjFHjIhmkyIzhsRquLTBKjT +cRNpFYF0jJl0XdlAD27r7NsmbJwkfWGLxs16hu0bt/E9bOwN9vtMesACugHqCTvYXlHdiKCf3MEO +hKYEWiJhPvvaWkLnDUjmdwmaRcEGy+wuiHod0CIZlGy0Lk6mZ+8HKwM060lU6mUwNY60NdJ3NtKa +2EtZ7Co0taIYYvp8wtfj+krWI9qPbEEeQFdAQ+BOLEm2Jc2aFM13FY13o+2ivjs5ZTeRsltI2V1R +1UU9l97qtFPWTRtppQfSR1kXDaSFZtJAV5ghO5hXB5hndzDrFph/EWZiBgIqbPYN9/49qAJH4P0d +KAoLKA0RVIgM1FVQMHgvNwVwIQUQzXD8SqYKUldZTSdlEM3zRib6jsx0UQzJWIdnwmGNZHglGq9E +qi9rpojTmw2uIztZJrhgjrR47qhbs3Qt0Jt4sWWeGytZykfyPERSq1fSmI8wHQPpwVU8DepmwN6x +EUbTkr9gqvK0pQm8yHQm5ZhsSBp3elCzuOA66F88H9lBEKn32Sx/oJY+TDopa6UFfRWklrJiumBL +Uk5ZPUUFlVVUUFLpwx+0lbvo6IIjsa7NQ70jTR6fVbT7KsOLA81Dzl84EXhSQD/8iAkbiZFiKawy +GfaDvwZHPJnHBhR58tqMfhsYs4kcNxHaZdLCeeX1VTeuub7e2Mpk+3KwLScyLYOttm5Y8mrbba1K +sSvZqmSbUq1K/Mg6kVGpZuWBzEpyEqBZSQ/blYE4m8y6LLSKq1iZuJrZ0txPZ6amPmxyzmJ2suHJ +picbn2yA+oc4MMk/H5yan/n1t4pwsX8Xc+wtvLdM5NeL4t8j+ei2n/5TsW2p0hZVZKFX939y7U3s +t6DxoTVRZDXs3UrAZZCd69I2Hee8LLLN8KSHKQ/THeY8by1JtpRm0/tE0zrYlGYXCc5ktLWPMoN1 +7sq+M9GE3dkMPcmc5M0n2+azk83nSNL6jqzHIBKat6AK03yHJuieLFLahmAjWsh6jWTNFrJxV7J6 +d2QI49cJjWUynBcypXFbyeRGwzW7TseVPGx70RWOIMrv0CVHukSgB112yD6SCuTO4zVLGwspI3s1 +xk9H3gyO3rUBpv3eHHnqwkti3i9i0J/EiGfnp7o/i9jqUWx0doKeJjPMd2KPV/GG5lF93KiOOxH2 +LO674hgmlvqoN5Lv5SjSf/S6lI3XZfS7nMhFdiB32W4y98sKE4X9L5mmTjQvzIIzmaxp9sUcaart +xSOzI3m3kl+mgs1Dak42B00kJ00gR80iq4R31pM4bY7kuOFHPBVlZ0+bWKqyPmrOXOfL3Q++XPXk +dl+uenK7L3dWX+50PJk7V3253ZvbzJvb/bnZeX4Gjw97eybn7Lng6rng5zn39Ay+ngmdPYO7xzt8 +nNOHnub8Pur7Ue8Pz7o82i/RXEHBOYQWtWnMrtHnNDzEqUn+wfH5xKCAhQUeigpM28CAqDtbhcdU +HprkJ3EusmtRZzb5FSea1ItN56NN5KYTmGZuVNeiOBeP5lxU92JlRW5ymty5HrcTV+NKrkZ0NrK7 +ER2O5HIkpyO7HY80A/YTeR/Z/4geSPRBFlKpEnkiI3kjAylbbBqh2s0TnOclTyId3B1rgIPj3oTC +PAiFgwoFx7dqPtl0Jg+MfZMIARUDfv3r2p8HN63npThrPSOnC3z0XEzitA3kWvc83Ivztg3MS1P3 +4hrHmFd7U5BXUY2zqcSsEKPNfbfZJw6yU6zDLvH44NgmNDbRIpg/FhoTd3uf/V3h73P/wGJdB0/d +6epMH+c7z3aRzTQ+ODY7ErmrjUooYRIXeh+R5kaDx4Id6CcaBZ3CNnlHBpI+vmeFxaI8yya+U011 +GZXwO1HAVfkGUibRu1Xj7oqMV2XCJp6zOjPUmaA4EJPZn6rbsHazknzdkcw9kBw+iaU9m5LD9nY2 +RQdVnd1kug7uDbhHqLbT9Z1EG4zpPKLyoHSF97CAZaWJn70pTwdBe7Row52pU/oSfVGwqAXGJuWd ++l59d5VQ5iobIVOxkw2SlTBVxI6yiZ54R70TvUx1s66fBdmGkzxZnuI0tq61rWweTfTPblDinBpn +T/+yoCkb+KyBR9HBq2nhh40engZNfK+mqNPEc9fFJ1HGjxLbVG08mz6+s+l996BGvpcpTaHKjUo+ +uIIuOYNGd5Bq5OoSipPzCq0yZXXCsmNoMY08O51cJ9bBbxgSsnTZHZLfsUj8sVCGxw== + + + aiHHI3tfBsdBIscBuQ4myfbY00Q8id9I/Qfdg8CjpT6EI41Yz/5YzI3gckCqePH25k/wHoVgXrxs +w7kOUWv2KxwndeNJ0HqRjUy9eepj8F6GJvHrnZNuIt/q3eQC2RrM7q6HMaStzyrBbfVE7NZ9f6ZV +dElZqbpshkCZOCu6y2Ixx0V/xD000bdBTFMGTwTZXohcyt9xXjVN3VE30J24/tgJpEutL7Qwmdun +PG6dwYAcbSRwDLwfFX2owuhxC+kbCH4N60y6n8Rb07MB2D1znNxKe2i72LsVJ9uFeSqz2cGy7CbZ +LGSjuLBV6Gbhtwu3Dv2OgSJ9GrYN3TiS2zwK2StbEb6zZz+K8Ukc727cnQd/Jx588+GLPXXJib8f +7OdqKTBxEvVILaXTYEZ3Q7qKOaSmdDemNdQtFs9kBvVoUmto+zysvQlpi3Gt5nWeLDDjQjMfSG/w +CQ7FR2vU5J7Y5h5UbLW8vaK9k/Wt6nYVKZDNEGdTXEwX1cAXESezRbp1+zzac7BnPzwsoXYTfSOz +2sfUx3B4z6jSrCrNrJKwjwV+XOhncnlWB9uzdQ9vLueqW+vV1IDsMrDEdp/MfA8uIWtRPcOlQJ2c +RX80u77b9mLfT7IUmj2rPZ2DxZ7snnQhAQRmeHDP4p65P5s0rNPwHMdnOpx/7c+e3QNPO39Id+Qw +yHnOn2X8PZDw90GrZhIPxccN/K11M9o3ZuNP5tfSpaZmThqyiLonS03Wrbm6sN0zuSyivXmsqjNV +42CmepN/b+ZQtfhNmi4EcDi/yIdwJIhjuUbqAPAuAHECTGLDnmRukS9ArFm2Z9khwFatWrZsW2Vz +D6TuJJjGsBsmEwANYNf6OPpawrJ6QKproh9g6wx0qidwBgUH/kO4RR1oTCi4LlpKKqjLDA2w2Zxy +o3ST0hrlApBpjkeOUp4bviTDyARMAVgYt6UotHgbYCZ0Qq+KVXJcAsxMRBAa4EKMoc1LHvq+LLUg +pCgTAna95/nclHAbYZ74FJdroiVKlxVwDghCKYBiGLYMfUV2NEJO53wYW2y3uK3dxIQJQI7S66Il +Sr98OqVySylCCzInhWvO1C1qToFZaxzzppawpoErjfxJ+EMNOdGIzsgWZUS9hTdg2tLSXCbMdfF+ +SkLM81dvXtKxJ8uI2UJ6ttPmiABGw/iAwMEOCODxgDoYkHdyPCBSyL704wFoOE49br+xME5iX8RN +SO2SMe+CalM+iX2xtS4OZya82hbnJrzzT02WfNy2lvzgmup2hvdN7dtZxvF00eJQm6PnShy6re8y +Jc5yJdDPry4rNUXYcbWTgIFzXplN0q0StUySRCfKYUX9gd1XJwnSscOqkIWxEweVTIUgkyFrFoRM +CD4zMsupkX5uZCW71HkXdIJMkuKcxcXgZok7Q5KGUyTbrITgvT+T2aSPcv9cNExXl/NDnoKTeQqC +y/apZ7kHJ8s96Pns6hSy6TRt3Z1uVoVNtsE2m33IZdekgskls+eNNevt2ZPzIAVnzW49n8eJIroR +5gXaq2inHsnZGGhC1GP72FQYJ8PsDhH16aBp8EeZDPM0CIxxMnRv0+ISVYr6m2xKDJNiesAnOE6L +7cTYb6L0PTEsTxfyVEYRs2xSVIaEsK3TaJ2nrdyxmeJFz+XJcnG6TC4r5ezsw+An75NldHw4Tzm6 +PTBygXMEZwcKlZME+5NMjva3k6DScw/DA9le1U5z0Tmu8xnO6Wrnh+SiuVAlcY0msm5/OH0PE/nX +FhJluO+xDLuDaRppr8P8qSNMyQWmIibQNnWdwZyLMNdWmF+HeoLJFGESVQwRHdYTUBthblSYDgeY +AAsMe6E8jyNIggASoNK4nmB7CDSiO0zVcEt9Bcl/OJ7ACg8TrJxC6RYH9MLfLZRKV2BG7tBxdWen +uvwRtc85oDYYq9M1j6ehmTp9/Hjah5LuzDC1+PN0MQ6nR1p8HM4fZzk7zNJPskwXjrJ84kEWCn9y +8LPFdbK4Z7SI54mODHGe8UonizJMUso2prNIJ8o43lPO8UqHmvjQEx6IguV0R+cWD5SC3NN5E+VX +LZpd/DQVnqbC01R4mgpuKjh31VrmmXwLoJ2V1sgmbzlJLRKyPy+db/m0j8kZlk87mfUlp7o+8WTK +V2//9T3XDbr5x1ffvXn5ng4eXYL2M/vKg0l5MCkPpmWa6RE2P77lIwcEz8mU9Ra0znRT4y0otuGT +RubS52mIHvPZ25KXkLA2TlzwA/FmXW9rDO3TSHgYzeMpafnzZub4yU+ZKL978+bF/ctvb74T0A2s +OJgpF8E0HcV3s6m+cNFmvuhiecBkns7s5WpnZPxp8GWTMzFmTbi8iclCusWlTjiXiwvrdpdLNbP4 +LBVo62rJZ7lAQ3hX3CxkFD9szPjaEef1IqL81WIRvWhEwRoS3XqoVg2CjeQdeXgOZEr0chBcDIL+ +wjvv5DA6nofBv2ECkRvsBLqePedz53jqvPK5c7JDdiSu+yHzkx0wD3LIHMT7RKfLC52t0TwPzvTY +k/3NR8sxvwf2CDo+omeK8gNHx6+xJfsdebrGlux35OkaW7LfkafP35L72aVt4Ypt2Ypt0YptyQpX +r2IaEpxduYohtXm26F/Pad4PQXsN25fJRe5d7H6I3vdj6ruzAP42hE+1Qs4Pp38kjs+J8qxTjkUs +Lp01Pz8knjeR7x77jtMm/O1C4GdBcM1PP16MhEssfHLB8B4OPw+I95D4EBR3Se0y3tMYFneB8dPH +AuOj6gVLv635Q0oNbGJLK/PKsSmQN/gDhk7SRS3pWgg56tZAfiWK463zchlZgDVOp8SL/iBhqMtK +4/VQftmeHdaLezaA/Z7NY0t69N42i52keVFSiJxFUtfUpaO0oR+Cmpxv65NO1vqvS3sj+345IkTx +INqokisVxZEgLRPVJHkQHbnk/ZpINdlL5CdQOaheDAoUElJHerxnR14wds3a8SmizDyT0ZKt+hEk +n2R1srzZZUjO7em5pJ9MEvbYWSKV5sHeueRXTXrVhFef6Lqe2ph19UnVgS6V/9kUApo+pf7PQ0V/ +WJR+phl+wQqnDX/68h1fqpK4pPODJf+vtpPqXqq7qZq4auRy1n8xOzdObOqasavmrhq8avKq0atm +rxq+ZPpuCofkMrfgJUlNOXB8Xy1E1PtR6mEKwgLaRblsa34pptHahRW1ZpKzy4JlO3xcmat7uAIa +M4EerClxLZRfJj7jRekZx3p2TX30wyOHndzP/jkMj8/pOk7jf0U9d8+4yO34ZRySUC8d+x8P/o+G +yZ3GfSc7/18uH0/wrycpc6HSzZnS8wnPNGpJ5w+t01G7/gTl+nO9XT59/Wm/fNovn/bLv5r9MmaQ +EH7ryLDAfd4WbSdc0Al+ySlQF/fLL8XE++WX7bpxAdBar7aLK76/9b08Xd7MUxxNIfx6Sj17Sj17 +Sj17Sj17Sj17Sj17Sj17Sj17Sj17SjJ5yjd6mgpPU+FpKnxW6hnuuZ+U1LWgTdy+ICtMEDw2w0gP +I+bbGY99fUbym370C430dtlIb85Idx47UpFVPSbdwgzr6GpGdKNaNWEuFyH6r5lFpPWqQe11XdZy +x5Siu6E8hC/C4ooiTo+vxPvXq11ynlKQ72wmwfeNc/VD14Ccl/P/aI3+6YFa/I+JQZwHFUAe9HSM +bVLGWXIGX9vwMU/rJwrp6QFf62eL6OmhXKRzEc0ZQR8qzhEs++ckHf9AeQ5mwjSc9T9aps95cY44 +1Lm8s9SentizKoeK5fR8sNblA+IXOFOWclGMSm4ISLqKJ14pbWTJpX04SfcLEY4+11Lmhf24axwd +unbSOdGRbPOTfsTj+oUIv0yU58v+VgDj5ZJP/tYnf+uTv/XJ3/rkb33ytz75W5/8rU/+1ifPypOT +7WkqPE2Fp6nwZf5Wu3Vj3QyjDiIO4aVbEh48ZDQNtyKMN2GOJ43GmzD9NW7DUaPp4lmj5MoWLq5c +qL+TQ6sX6p0cUiJ0ctX3/VQZSxhGX8JwmDE6Z2zGTA9OGT6IxrNF58qHZorMk0kmSp8mnPg3XkPX +58d2doxzA2bGhBODZoXOiT4jKIeWnXQNVjNOgiDJj7iGcQVnGO4FhlhL57ezc2PmYXL+pf0ka3i8 +TCVfLPY6FnrdXb5RZZJl/tDtCeejONyb4G5R4bqsu+mhS20319rquF46ZDhIg+lBcYDD/HFxsLMk +T5EH00cEghcJXiiMYkEEA86A6YJgcKJBpoKIblzzgYb+RMsaBx6HnC5MuHDfoi8rOozzdHGY+yId +L87po/zgLRmTDbW/OMctWnd98bb0KI93Lz5KYz5tZP/2iozxkoxluG1kf7YVwOhPbvgfsx+4HcHd +heHuwZg2Wb4XdoZhbxh3B7c/8ETAwxMHOXXxoakAKgMqDDsYhEKKwkJKwgFGf4UVkkAxmEEpOIDQ +Xp38OMH2saMpFOAtJ5o8FSRFwB3+CHNlBf5GulbjANOgwsBHIAOv0NjBEGUYyYVuzNjBeGVgyGJn +EhoMSIaBWOhKjP1Et2FkWG8LMJvXGYpSZPACzEXGIltVgiIz9RpP5mCXncS7yVjH93kOTHM8a5vD +C+cHFuSMwt+AXa7uhe5n+pDDMW38S927NLiWpkc6Gj/gZhz90tPnXShx0T9NnsXpA9dJPHCZxIcv +FZ0+cKvoeImEu1f0Q9eKTnJxhLiMyT/oncZV3cZy6OOODnsEOuaR6XjHSld87OlCj9PpbqJrOfkq +zkxXcK7oO0fvNd4uIu6Fp6nwNBWepsLTVPBT4bPKR7X5dpnb52XRyEc/r4xUmW9TbOUL0oYUwyfm +DX1WuawvDTCXy7UNyvqhekTnceDNtTLkF//A0po+srb86tre4eQXmEWGJxeiuVyR6OINZZsI3t5W +3mnSwLALx4xx4fOo8FiZaBMTniyY12+iWS0mrIeDDx8L1yzDT1rcaCxzxP8L/X+T/Bjtu8ZNIqmn +hWseicJa6B5djqfwT6uUQSp0Lpfu0d1taiJtqyKdrC6S1EOiykhaFYm/93JIaZJqSJWuUdlJLSQN +QXI1JIlL08XgWg8pSkWkKMWQ0OpB3X03USxnR3WQ9mQccXhyljpIiW5KeqqEdIVKSIN9+mgHhbgn +LpdR+oxbY10dncPUKypZbtX2ztjzG2Pns8JKVlpp2twV22+K9eWVBt/npsTSWGRpN53VWRorLV32 +f8rlrkO5JXGkTc4L6moubT1ql2owfawO00O1mLIvNjBkAX6oJpOrynS5LhPMhOlCcaZ+VdHl+ky9 +QtOFGk3TUKbJF2q6dIHR4itFXLjGCJ7pQskmf5uRzL2/pgJOIDXmtVK1pRrSehHZwsl3820JkvK2 +5tTm8EAO3fVQfpmSs5aLSg6AH31hBpd8UBvlkoVCCTEPJd5oXoIaP5dMoMEIeghRMUuK0W0TuhDV +YE+dVWf4WJzvo1G+xwYMPxoyfAjRx2KPZ6jGZQY7G18os8ygDNB1QfNcahtWBSUKUQ== + + + XqlMOr5i5vI8vhrGv/TCtmdrJFzMPw1xWDgfy628WNrzodRKGONp0KJHPXq8yHFMqNymVFpC5TTc +/1vsCr51qJ4y2sNgDXONnPP8r7pJPN0aGFsTYzAypm3Wl+OR59WjkwUnly1YBu7sxBPA2UNpTBek +zrlkyV7udUyZPFrK5ENJk1UuRN1h9KVnw23z4S4nTo6G1xlLpiElt+6210NjmtRCnS/SZZwE3DmX +2by9IVVTmvl21EApXZXOuBzlfAufbsHk5RNV4UmlTNBdOdECplGksywN+HQiziTgxUrnVu6gs2S2 +Q6eO0JEA1FegeU8Ze5iutxKddxMlcRZgFydwLj2BEyby8XgHsi2CnKvAlD1IQLw7OdwlHrlP0u4/ +rtxPH9TuN7r9Y1T76WPZCJeTEahz1+0a5hw/3LULpsvHuzd9PNniUvd45D7RMvtYB6dPtcw+1r3p +Mbkk593bOPrwjbhBgqrSSqJ6OrUFLqKTA1X7Uc10DtAt2kw3l+WNhbqvhZEvtGtxISSgVoGcwEMc +GXZ32ttJ17ohJx6XFE2IDRsDf5dYL+7M10L4Zdv1RW/etlDpqOeuZ3pupOJmqD2e++K3qd+nOE/m +hb9UtfxBH6Ereub8g17v9bqvjyH4OIJXpP2xhq4Dw9SdXGjBdWnols9q93EGH2ugeIP30C2ShhzN +iVbFcmizz7OXEoRSF3yRuuDJYh9lEnW9Wg3wvUu/PzmPV6C/ySjOjuZGy3n/ySr/p6T21emaiX3e +BPA0eio9nZ5ST6un9s6fKvTnCh3VA92eck87Ud8pVC6ONG6o3NC5v3AWkK5OPj8KuLeMu9XcVHYM +cHNFd6cZqP7CU9JfbF3MtxFUIbaPWoFFgD+UlscibwVPy60ktdG6x4gGlSu7LOyvhvGLxGkMl8Qp +QL/wns2Tkztnh6omF9SsUjnSBzRFnH7paa/d2QGfBfWahw74DOHWxxwv2lLgQ71lc96MKJjOBJzS +oFTw2cTrCbcLlR4fKdz+M3OmH/PuT377dElInr9/489E05Hrs8Og0WoFs24Zqyjqlc1V78L94Lq/ +HsrPDP7ipcc5fEnwVzB8meC56HaJY5XFRyX6Uprvo7J8H5Us+oDVdiE98DEJh2eZcw+h86G5xyQn +UGrCo5JU/pLReZ8mSsJE7vLc6CZv5GAYDs2L3/z8B3+DUbtdl+Fa86tj/sSFN3/o7P2nfPqLFly6 +GCFIFwIE+tUrTwdL7uQ0z+xc9UUSQTkhtFL8fFXzoEfRe31zCR1uipbfWeyct9JF7hZaKIqunv84 +keETZZEVWW7FYut829AqsXW1MTjCfqDFyruxxtpPk4bvuJ/8shCkaDB/RTkhzk8mScSBeL6ZiO8m +4n18ncRWkf/Sd722qNHFRXqBEW/4bIEd5Izx+J1+N1mTo/u3P6cLzx15P4ZAJY6b12rioMsdB11O +TeOj1f2O0uVV+sDqEilL00fMYr3I60iexwfKJ7hctDRZusw2ES2ST1LTZLb1deJD9XUmS0DLFyvs +sDP6QvbZA7lnu0lc8XdyFDlo8pnknh2kRnn3tX8k+2w6k6GagKaSVGWpSlOWpyxRd2SyHUiuHv0Y +q+6a7PzwaoG1ZuksR0tcWQY9Olu+SptkMZkqK2tFlXxNTtFbunZOqz5JVoo/Np8132ol151OnG4E +fDivUX0rOpXg73QhCWub4TjmYG1rcujEktyriVKvem4jzyt0/Z/I/x1oQuF02tFU4okUZCLxvQlH +il8Emj51Eud9P+mM1S70pHORc853JJXQJ87HnO/QHw6j3WCEj1pw/m/nxPu/O8LlgYcm8CS7m7q4 +1NGVzva3cV+7tKEd9FKOcT9b3B7m49e8wPzmtYrJyGbjTo2gu81VAuPNAD63ZcxqGbNZpKDVNGSw +DHkrm3wVf4PYmJ4ypKVMQz7KeFvYmH4ypJ0M6SZDlsk0ppdQahN7jMYEJzbkNM1JE52ibIpLT3ea +JOPpThJuji7vid1MerEcJz+xy2lMgdJjoJQINQ25UJoPtegskJE5ubyoo7ylHw6VA6JPB5P/9g8m +Xy2X5LIzYxzlzx7nyeVzfvlIw1hPj6so94Gx3oz29Fmxww+M9/To6OFHR3xjya51XjAY1hpsJoGu +1YCdIK7k2hGHziw5NAtG9B7MyvlSTH912TiXC3tiXU+zUp2nxHZ53cJ7oZziVN2d2Zsnutpotr2Y +d2JLzJ42OdmSjU0qgmZhJ7KE9EraSrchrWLb7cw8EyNssmzsSJov6b4011j15VpiOwrSH8lyOpGK +P5P9hAowqsCJbsgpWJRnoiQO1IV3NL+PUmWMTyRg/4M8iar2oFKMajEqxiutFi4vpeox3Zs8k5bM +laa4zhSeWMh09JcLTflSUweuRmb1yBY5w8BpNnmiTJt1yLPhTBtc9ud5NpRpMxqm0VztPHZqnC40 +Zh8+SZV7laPp4hmqlRJjdpcCDtvTU3LGIwon62T26gFZ5ywLb1scHjg7pQenhjumE2XVjFbr0e6W +VrMVWfmRsrCcOzUN56a85aq3sx2HU1OBMrsLZeicJ4mB6ToNlusqF2lddv+x8frx67Ied3HWg9dp +TR+5U+viHVsfes7v3/rQvVuPuI1rulC69jHFbB98pger3X7sqZef6aFfPFAtl57RIlHWau+VPkWh +VoeaG4vFjtXMsET4T7xa+uHLpdFWmB5zufTjr5c+5OnC9dJXuGD6M6+YlsMOvoDI3XShuIQvL7Et +MEElJp5sj78l2+OBDIkMHIgY6GgYIhtL+5ZUKe0gqyKJpX5TfUAVvR7KvzqdtFyMnAD0Yq15Umh4 +Q9+Zu/DyIWjJB76wmasH+kip4o88Aq13ZtZhM/c533QKenKO6O6Kpg1dtvTF3YaZxSstW7t5pvlw +9AmF+cS+Lk797NVnu1tek6k1t5y5Mx5g3VtG9Z0/yMp1jxKt6UKru9E639GKP2yyyyNlIqN0KJSP +vLm9FuXtRMnU4pKVlGr2yx4kq76zspJetOOKlOKpZV8temv3fIvoxA7b/7VdsryZfKzC/ofv+j2/ +wPfCcbsPV96/cBTPP9ODeuVDX8cHHvElyik+6v2nnG19zL7zaSnij9h1puvlT8vBVqkZROt+pcMV +vbJUuFBN7OBKS1XpznlpKerWREYW9oz3VO6fVZiiPnIve42x7bWy3F25WHbCPm8qTvm7Zbn3Q90p +4cFJoq6b62UnDgQ/uPFiySVMf26pru3yLomF/jEdIXHl/w/udV+IcNx0G/SSMg1XPLUiiRC8Yzfd +ufFmVUqa4CsAPqIVfCnGL9qg66X9uX5pCuPT/QFP9wc83R/wdH/A0/0BT/cHfLZi/B+L8On+gKf7 +A56cYk9F45+mwtNUeJoK//73tT6+iOF4zvuTPvZX5y9vF88Uts2ZwpMxem9F9naSXbluyksX++lS +qWn6dxqyOz9Xx7qgCQY5+owuA3IYSKEkNAJYTdIceVaQGmWBHEnTJ/VokhOO7BpASy9LLQ7Oij+5 +Y+KVkjT2lrlsectEmamu0aq8+Oou6u3XzPNZgvjq+dcsdHb/VzwKyHbxjuKnBwnrnyS0P1ssoEcD +NNBfJO3z48H+jwTzPxa3P4/NPyZGvwm1s/z+TDl9QUyTkJ6+vGbijk2PTaX80YmZTf6pBFQZeBj8 +l8UEYZwG9+XxLI1NZaJKxe0lCiQbH/BrwgxeM52JWpaWh8JsjY8o2h2h8CsCfcx1+MUoWUDmMo93 +l8IHQiteyOFJLiwRBz9gTYpQLovLL8X0ZcLzYn2LNta3sIKgKnDYxXCnR3Kcr8n7mcYDFZsy0VsP +06US0aNb8oES0egrmMyntPVNmidplBsXSkVtK9JyOG93oRbtIuHRXj+rTFYeauf8iGOsNLlTOxwx +3VEWiEVNRYqS/JwojSRT7I9ToZolQ0n8dOzRF0mYS4eiL8iYR0iYh9XA6eN6oN73vN8k/o8lS7dF +Sy8l6py2Gf5j4dJ1k9efhqSdbdrOpnzp5HL42+FiAVOOUe1pVuo1Rj1atY1XsRr78GUoErOaNGg1 +3IjS70RhBXcbt7oUuWKFV+ocodz3kp91X4lebTKN47wMoSBQSsJ4lFyjL02LUKY1gHi4KPmug46L +D6GCNsjytS6bdBHoIIjzG3fKPWDg6qEN43ooPySgAfD1L9+++fW7V2/ev3rz3bNnTm77X0y//B5/ +E/k3v37x/v3Ld29AoH/1//z44t3LH252b757/fJbkOUbwM2y3KZUV/k33pRyixE9+TdCV3/E7pot +8Ps/03//b/jxfwDw327SzS9u/uW/zzffEvz3v4F/tjjvHUzw3jwH2OZdA0w/+/wCPoS9odf9ioYC +LCfQLygHvVZic5pX2HFwO6yFtsWZ5wVWcJWKVZFzgX7/Al8AL8W6rvkWDM3E9AqI/6VX0m/bBYh8 +7Pk5JgT9K/wNKxawhC1zBZWhVnqDwmK7Xdoaho9fgulnn1/Ap++hzwGnMnQUpCi9R2FluY0N7Dz/ ++Usw/ezzC/j0PUqTft5zrIbb1OoiDGrz3C6B/Ju32PQt9LFS/LAoyA0Cf+oCxI3BBpO+gLpVk372 +3oE8Z5ULl2B+NozY9CVEDcwSHdN7B+OPtOHjl2B+PmzxDdzajInC/ADo5y/B/Ahs8el7QNAF2BZw +meW5wnaNMfQIgo1ldUJ6sXqQZAFIwTWQ3vwDLbj55jdcfSTA8uRCcjWNJRC6WEWlmxVy2Bfp+MmK +q/nm9zuueXzzb36m9rlyadguLaYLa3aDDUF/YKlfMxem7eSVsAxVkhKXoUUvCpEJvWRzgXq+nV/3 +D4z8sBo3ME/8pfnKpMIuv1DtuxAx/HGRt7IdOYsGpCPQz7QOs1SkyaXZo9y6BPOSY4uv01pB2Y+0 +P9aFpxa0y4UY3TDOiQJbEzYymzhUSQN31UGEu6V8SZhioauNzBWQW7UXZP8frjTxt8LYz9MKQ5iE +LSZML8D8grwk3K86/LSJguzsgz+I2gtiUEHyuednmK457Jv9wG8RfowvydEL4vrC7sKEpgRW5FgL +LeW1jdqplsBclauS98SE4kA6Cu4djNdFOpfEG5infotPad1qFV7T8DhFdbkA8hgv6Sj4lt9NJ1Y3 +QT8VZfOz9NWVf7N/9+MPf1Q85m4I80+n+WYHf3//b9OP8Axa6GUdlDTQZwl089t8A5I6YeXPBbjw +DFTC9RYj+Q78fASHcosXExJYMVyC9Y+/mVAHxYk8LzT2FY+F4SQFi2wl4V8LmAl0IBJ3L4RYAf5F +57FDjYZFDkRwaDAd15wQHG/nAJ8B4JpvwfYTMiIseYDVeFvnuTrSvsHPF6QHJiCBseHS4MOt+YZ/ +hoZgaAFOILs3XOq24Z+w4ZwBY0j+5bA8cWcuA5We19KjwzS0xf0K8N4MSJHZDdT0gQAdgW9GSgGc +C3Ru6JW2/fPY/d7WsUrbYsccVzsNjv+d2u1AHaZ/nX43tZuf/PTm9/8EP9GkhlUwTA== + + + 6Y/NdILeAPgmDFP+0RN+BfXpdl1BM1nDXLA8L835dV4jionmwM834HBbal4J7JE8ADYk15r5hL0U +kKCAPcFGkBNRvsDkIkhMoF5xs7QuiYEZdtSbkTJoua4VpxmDI3cPUYKZzkA0wxmIV4reXHw5Dihy +CNoUpSGlJQk/8y06qxEMP82wQyGw8KTktjEWAtZbPC7NwLbAWjgQAphJ6BNgcA6Lto1JXpbncMMN +F9y3CVZmIJw/32BHnFcmYKGJus5tuQXeB267MsNmmL0ZGihv0soIcFLHJMSGUgrPCAADtXXgDuzB +sKBXYW+uIQowLosSi6mzjBfBURkWW5a2IcyCNc1FEYS1KM9RuTUEudoA5yBtYeONimBVIJj8SsGa +5PPpFiNx0hRNBgF2JsCcF+CCbgEmYJ6DIYDVL1wEpasKZ3DelCYch/8SinybwiwzLIXMHC9AgXas +5qwdAzB2nUeyRUXQUlZgSlmBTQnrHYNFZzO/1cB9WG/DUmQegahlpDA5gk4OEFjy+QYzuwitLQkP +GyqG8v6KE18+L5ML18Vqn8eMKZ2yi36+NP48vCqELMCGjGdgXRdejjMteEFQ14pzHoGp8chkWORx +FeCaShVer6EYApiROgRLYym2zAu8JMrrUhAUC6qfUXtL3EZgmrNQG2HBCt4F9wVZzfM6d7xlnYUK +KrvHQMz8EoaXysBwi/F67XAJghfAKUnfFli8gjdAR5PQG3JbBUXCMWEUOVYBlhh1lYdoaMv4NkYL +qxS3qc40BkYTgSSzBQiqthDA0o7BsBkIufOyFiGhzTrAS16DIFhSH8mk/UXpoAMBsoHbwrRPuelk +lN5WkOJRu5CLDgTs9qnoFAu1StuKZdyZ4yjcBbhWXWPFIWhRBc0amYAVertKUyzZKUDQ3PVNbdYe +ABi6LOBVZs16C4yLZwjQWBIgKC+GgEjkpbOS+EMgqDuLzoPAg9BY5nRuM4KGo6gDxpsIAZMu3RW2 +2htrKRRU+K8hiNE2nAJgBpZcqzLWgORvZQqMBQCdgy0cGfCG3FR2LUrUmnTTXRedRcvMU52xNp5F +AOxykkQiA0tbldm4GSmCDHRpW57cC6zxZLtNIDmFLcEULMLXWGhmLLgJBhV+GJY9KAJ9VaLtkkA5 +6GSpBuuyWzclBMdWdCVHFjEAbH29sOyDVwP71+ZoYgQBPc26OBdWWxAYdL1gvObmn6Ut2sG60whe +WHIh2YRdBQYCWdcbShp+V0QtTFdcsc9nZIbffRDYd9BalmoI2hx1zeMJGgTCx0IwRYZUHgTGWuVV +YAzI5wFZVAJA1eZ3wY8tbFmYYTDX6EQhIwBkpemCQUHPQFLZebjmUgSY5mH/UgQlrNLbnJposPi6 +lgUFGbzyMrRRRMNaDG81jWXRxYF4F52yst+DymVatKlHCFxg/qh6ZKwtIHdU0cQMZWlb52TyQVhb +YUh1ygVb3uiTiKtOulKStMUTOsoa1pQRQVBNDMPuggAkZ7JdLa2yewAY5JaCS1YUqiuj8C9RgM32 +mYC+DsXbapLFGLF2PAJBzS067bEcsgBBGq66rwbl7YqVhbIjjIE1KWuyDBjI2HnV7Wupq30eFrFy +phb9fN/alxSUqhptA+1j01AK6roB5t8IEPZ2RTArMKzVgCUbgj7FxQ3L4FSX2tUxhq1hiY6JDCxB +hzzhZq1o87zkzdBA26qqAQxzEmCC7UeVqWU1BGVROZFFtwBgi4sACyxIBAYsAK47FSZYMIKAZ+bn +pAhYpgcy5IqSxXtKwBibqjykxyuClJqwQNRcBK5R1bkqXQjLbUjK7xX1TUYA4Mw8gNUWeN0AEAwW +6W6OLCYQGIO+Kuq6ATBmsglha+MuBLdXiEqNwJxUpoHtKqMA4FR1s8krS2BsK2ZcNm0QgYuuBLyh +yhCQosLdRce3ANEGZqzAIwGCWFYKQMAaghazzgPRR0M0pRp9FzkLMLSUlLOqnAA4rrrwiPUCjLpC +iih4iLXpCilJFXAAw8+CgDqDwOSENdktDOwqD+wQInwQLMoFUMD6XcjogF54aJdowFiDAoNyILsN +U0IyDE5RJQdtYwysSY2QxiIRYUU/X4OhLWYyao9g01KptbLYC7ikdQJVU5cC6tqqBNBcYGBuTaif +i0x33Ot0GVeTm0iTyVgjHj62FEUgqjgAQ1ZNekUjVqlfVpUaYvUTgqy9T6LcEAKbbKYaoatr0UGx +OVhg+RadASoeiunnmbVbRbAGFcgV1e7nCo68OND0ZaUv4LZWPRcYOMuKKV0TRSjKmr6OGJjBopGJ +ITYGACnixEhTWQxBMgU3qdcLwbTNM7jKLK48qOMwVCelVxQaipf4LKteeIMbqE1tdjEQsCbrrW5V +CEZbnTpBAheBYMqnPjnnKkBdcTKTGMFqNhFObhEFsP2kpjJSLC0AJltxtaqKFpqzIdu8KgK8PFNf +VonhcWaTpctIQhDpUk6lIDK1cTZHka05hC06E9egRix+vumWUlDWMDDYwkOHmgAppiWDoAIdwUWd +HOvCawyANUcvuxlIHjbZqHThRfQQNN0VcWkLcEk6ipHnLAKjtmxYtV8RxGLbKu/rAFOXI4xsydyD +QLX93S7Bnw8gdvTzqtACgpp1R6EhYmDDfV/etNjn8bSiaCFiJwAwBQWuRaiCXUZcbYg0RUOAOWRO +yjwXMFigunvwVhthR4lRZ2xkV2rEXUJ9A/QRRosuQN1RmuxTAOy6DWmjDMxi7BYM9cnyiOh6TGUk +AFWnIJM7sKMKgWqu+40Swc2626oiqKbDFDEWAYi5czqJdJuKKKqj0oW+TcFaVJpgRqlRoPopCnNH +wWKTnh0RiHWuqm2IEY7ARWnFk6aGoM46Z9XpEVG+m0AUuYNdqKq15qIaVwTCV1WuYhJqC8fxWHjW +pQlQPRm4D6o6juA52rLLigCmlFIgjggAkqUs0yAqD0B8N9lVWVY8F3ASvbOwV4OBYVWXWBVPPQJN +naatU/EmMzSybK6x8kCLhsqaXKx0Q42bc4wAfe+mTwcNb8Rq25Vbeavz7GUxKgAYoqpBxWz887bP +FWyzmfzJDIxNxad4uRGYZ40qZLTtFG/XPHVjQBqKGhVVXF34KnM40pasCEJU5jSK1zEFtl81Mc2I +AluQqX8ej86OmmtEK0z1bFV9AdhdSqsZIBg3XtShUFdW1BEYk21tMuYAXKMqPtl2m+ZswyZ2NwBT +TtpWQkERfd+pnk1G2BvL6tepYG3qDm6iCCDQtAMSoIZgmdtmhko8XORyM7KCCuvulwNwburT1vFq +ppDDEhGnDADrbLofWjX6+WKbSKurElBsF6a9Ud4UVSE31Tt2dx0JPZmcADU1j+SMgfuea8Supuc7 +Fna3AU1DfRmROAjQhCk2wZt2DFTPYGFXDyFImGOVREqo3Z5m5wxoOCMZuLa56ORWnTRRSpZN79a4 +Y6n7EftMBGBAPjFhvDwAlkITPXMO6lgisG6vNGUUrQbZAMxaQ1q8jiZ2EQDVSYF2jRKLCsKsHWNR +Cy1b1o2BhCM3DMGsDVMHE0aoVe6w/wlA6q7rpi0A1QQR5Vk/3sxBYXyN5qIv7EBnIKVtbjQhBIt+ +AsxSCgAYdH0v6I1DYDKdvnB8kRGgB9u43dg5mERpJ2ASp23KFgVDU0E16oQzXQdbWI19UWdIVQYK +M0TIr8oBtDxn28JY80VgURs2ccALgWFRT4YtLoSaB8/GujfFTrE6nHBNm/1SVRkFcAqrzHdgNve1 +mjo9ALu53HUmAJPtLIwtWduGIMAg41o58sXjajEwbGp7ZRODEYC5LrZxNEVam7liTESnytq9veu5 +QN3M4BQ2BMMWnLtu0JjfCFSrOckqgK2rVsVabHUDeNWmKjgBGGeTpgvv1QhMi99lFEEuTfHKnppW +EyVFQ8dLao6xFBhmBBhmMeM2iWkJ0CThXLcQGiWFKWdkcjTzWWzQqu4NfRCjIs82O4v54zFvrZiX +CfUzQpCxLLuqV2r452AxuMLOaAa63uJKYQQAFqsGCQuRe5Yj+tp0xMTPBG2byYhcWUZkDA4uirdq +aA4RFDUuozifMpoKSQVSDQoEnVI1RPUGAJScjKJasEKbMQKSdIJLXAmAFS2v3gNFoGpqYQedIBCv +TmFzkIGk1YngUZsZwaJpOy4mi9cBBWyrAKx3QOP3CCVntfC76cdplMcOJHO3ikdMEfSVSxvWcwFr +eLIvUuys+YqKaPpI66Ku/+65x9c1DcZKlrG8rlh4TmQa4tUYkEST8eNFYy0rOv4PD38cUzpUDUsc +aqGGsxm3qVNF8RzuAWsb1FWTZ2JE5sT5sAxc1KuVs+2pRb3uGXMsdGradEt4YMQ8GbHT38ypWHRm +ZMvG6Y69jKEvpbRvikRANeOWxT+2naOuLrGqcnayIJkKk1FPU/02zoZAp6BGirDdsujSjLojPPRx +PAImr5IIe84Wfyp+BNCGUCGtSnfG/WtdHK0MDIuSRa5TRlAs6FkscIFYVxMk4sBDBI6FS0ew1Ka7 +okTLAFjqbIJEPw/KihLQ50AxJQgNV/buIrCvbrGGAJijKt3B9vWM3VEBt4g/KVcLCZVb+XjlvJE+ +Mfnj5OxUiaH5HwBVmnQJoKWrG73GzgAYnZOwGUrNsSiaeYbAJrM6S0gQQUkFy1J0TqwdHf3XXGuF +Hf4MDElnA42avrg11TuKxG/di9XZlb0e0H0yw8dj1DeBQJSRUI8K0hR0NvfIAYKTSnoUB88F2rV0 +jX5kTM3I0is15BFo7+pBGQQvmtNYxa+FwKRsUdGzWlAeZbomBmS0gtVOWftuCUpD0rEzmbzyPi0j +z34xaAkzVIFoMyneVoruC031JmhNiQbCRdkuGicaDHoP4rXdbjFXPYBB2OqSnNmFlDFAaf0tRhil +V0rPVEEBcJVUvsJ2FQPL0je8LDD1DxQXrUC0ZgDk5DrWLRP1ydO74kbLy2haFgM2oavMTk3TnAMA +xlUHXUJb1DDKQBb/+VC0X1Vc8gBMUbcWtawQqbl4k1owZXaTToNziLSpkkiREwZmEwp9giMCmzLq +nyyzU58lpXQpC8fiuauhdAqczV40sA+t52LGbUkyQ4tPsVPVDTFj4hjveUrvwhlaK3sSdXvBtlU9 +5UGcQniOwDL0IqcjIjBFyziwKY54V3U9tBIUAQ6xjK5IbABWE11ms5VgPiE3YsGpOORtZaD61YYp +013lhdVQBpasAqHkOQlQg2FAQFCzHdvakJFPUl6WdZU32fQKZtGp1drdJITAJJWknhRQf6sOr65x +aEkRgtUMC0WwxkX3ncW6W7qXVxIBkaxkjgeL6GLbkjZuAmy7qJ9Z/ef4KvPqE5ARROdM1YQWAPb0 +6Mp2J8IWdYu1PgsAPJv2Fhfld4vF3ClseeObslrOKIL082mxzzcOXhafyajhsYJavekNFq0AsKb/ +FI4uCzDpJiZpJwRTMdtjeYh20Y2WnPLPBZyLSmo6SaBgTY0t7OESFBJDZv4ni61Jog== + + + Pb8pWVoubkuKEXOXdQNRuwoxNrVDWUUpaBWp5hcsZxM+rjzRHRxfH5rTWuTdq25/5LM0koJqg5qi +jxSJ46twLqIgbWborK33KZgzwcQ2vqyak4bj7yVx+JJXgOabI1gdOsXyU4vkaY4rILm10lNTSuaO +D7tyyeael92egaUqU4t5zxC89J2HI1MFlS7j4apI16LjF0xLLpnPp4wyPrvgSRKPFvZVlgVGdzRb +jtqqy7uI6wfagp5vDtQOtABDD4gUsdsYHNZs7NL4j6jZCFubNHRSCHNlLQlc8otKNpW4J7WVbLu0 +nJvQHqgi2FO/EEFPYRD3HwKTpjA4KZSZcwyOs45XzxPTbJVSnAZFSQmMACePRe9XEVmFUzVlO5x1 +ZFo2u9BSpAoOU1PCJPEXqxhYdNAmMuj1WRnbd7PqtmmygBjofPZV9pLqdp3uAQWwRiILJ58xMCy2 +xa2LIugusWwuMUSw6jzUkBS2lRytbq8isJkrB0WSIujR3CxJK0jt2raivDovOAltoyCr72op+nn1 +NvaUAAQuGuanUC9/fuUo9uqdHqVa2mhPRsWWthCCZUUU9CBmm4ey8XXLwVIQS7P8HIkV8ufRqaeT +IEqEo868VgelCoCpaKZE90PX2cWjtWGOugqW/umaNN9l1q20ouvP8pHF4YCfL7oM1QbHlrZcounm +1WuQJKD43NfidKq4sIADIFBt+ci8vAFYmsWi1XOHTWvVNG07toGNLRNoXhVrT13WADUCi/aL/AyK +tidOzSKjAbhmTXptopJhy6TZ32tT3adi/rbm+BYJUFSMsOjZG0pKZ6CGnCV9nBEEO+sk1D4XcM88 +o6POCIyctsht2aYEWEqmQps0RHDUc2TkT3ou4D4PyXFiYEtJlhNACFyT5dBLNhMAYXS1a0knbcUE +QGVZtKQ6AC9ZTyZl8WwCMNtJMJGoSO6ihzZWPWBGaC13StNxa3BONU2xBSDo8YpgXjoCldS49de4 +YWM/i4GkSlZC4tMqikDzY3AzZImIFEhUCLO9hV2Y8aKH7Mgq1vHVhMukrhokQDagxM5lAZbFGrbW +P2+nSSh4IbMjVyEgYK4aAzXunpz/qOLxS81uJ5VVJuOiKeTk/dAZqucU7TQegbOC3cv6mTE9joKL +YdbhdhTgGSh9meZVAFDPlyU+LiEyRYbATipBw2UuyU0tBsIICk1FkvtRRix6FqNnrGJbOyNINq0A +i65byuIUISVxNWy5xC4TQ9Thlh0Y5VyyYwCpC8qs5waDecxI/qbghva5gIMk86YuEz1QZzfsCU3S +AZLXmZptwskkXVktN38A0hbJwK7yYGRMlyKZ2s91D5Rc1tjNT9xY9eyG+lEBuJjgoNCcKjKODymY +6irqf2QBy8DclLeUxajaYG56XEoTfND6WAxB67Z2LavSqhEotDSzyr+ABZyem6mqq9HwBp4tPDyq +PPcM7sS53oq3rzyNrQGwc1d2IfQsyC4sJ2HUYaFu8mRhOHSDSKwGOqYa1mw6R2S9zVw8kgkUMdOy +mSuGDicTWJJI0PVVWSBETcBAl56kBgoP1aMW7GWaGII+wVmPp1F45hk7FbPKyX5sgVyjUfFKni0A +YbXLPNKsYnTYLkX7ZYlP6PIVr0801xW6r+UcGo59VX8x5VIIVgtaZlM8ItuZzzguk3JRJjYL+In7 +O3JiqwUHRXeNrKmzVzFYxknkEOozjpBK2lDkCfyM4q5NAgiRrB0Nps6iuUR2bmiUV03RaDmWGBBe +U1QmBEULQlfRmu8MY8pZ+Uih12cUfe6TRjU9jFPPukSSBUYArJlLGAHljRiB4oKMGorEqHwpwq8u +1imJIAg4NkmvqabnyRnsZ5KYEKSvlIOg+Qp6riZy3PK5gKnr0l+J4SNwFbxqFySJsDPQYk6YMyFK +XWSv4TNK2ujrpsjCxUwOOaQWe4AjyYFW/rxYkimZGzf0NAYYOjkEK/mqmspCK5PRSkQBgDUoAYs4 +yAFY5KAjbP91joZgmRWBhggp8aZFnV6SIBTMMIicBMEIgtkm6AlkCe4Sf0YEc7LZpXKOcox01lMQ +4EGsmK2so0hZb4xgtkPpwaQ9APvGorODsuJ03QVLNasWuo2mH0TJ3xAecq4dKoy6DkxriP2QiNQN +eC7gJCevgyUAxGj+4sjlERiYUhEEPYsxmikb7QBi7KUN6Pi0wGg0+P1mHGISddLlMctJD8zhrjqL +KILxjNK1qaCRzCGVswhuujgWTSBeLK0v8u4uwFqrrlrja89Dj5wa9Yyy29WD2+cmJt1LWkNkQ5QR +zCB3dM1Q5I+BoJ8IUEPCCLQhzJb+hniz4q2LnN5odoYpcp4nA0vUDd9yIAIeZVsNyq5BBKY+jeUA +ULPQLQBNnwurHTiN/axK5eMOzC5JsMFzNZ0q26tCcss+2bEgPYiMOWu80+BRpaKTKFsRg5DsPDyu +f95YERiC9kD0XHcEKjonRUBbs2lb2TwAqEcEQQuRaRSSG4N+thXPW0kwIvbTSckyf2M/roNqigpe +inQzgmhZXVHDm3iyK+sOrNneIVqRknhrZ+wRKpEEURf4VE0PGkSOuj2jU3dqAUXT9QGoifRu1eNJ +zaqrg9LQn/GZXwmMi/L2jM5HawQwuJNYePBczkEBWCIBWGhAcgiDRfDmfpQ58CEPQoCDLzUBoh2p +JA1QeRhC0qoKerg38glrRRBmE3Fsl9D2aNMwWVWGICm+0WnOtICblOORPFQs9tB0aqlJgEDJKAvu +4AXWsai82QeLzc6zZYcETdnHCh16iir0RHEEq4Yb9IABAcXpa0oUIVhNmOreRTVCxJQP7Ix4ruDE +BmPg+IeCw6zjIDU6EDhnpbdy0iMCNXoQukKNJVEoxY3AosZgWZg1JN2XWZ+m0jiSuxX6MYu5zRYV +i2yqcm0ddUwFdcViHR6KUQpvZVPBmj/qIoiauYHVgWDiCXOqVgfqtZZERjCCaBFTs9AvVB36RypH +hHWKgnMehCBFkhKrKtx+LuqUaElPoJP8kZZRC0H0RBkEl0XN/GKVksIaxEDUFX1OAVdKQnOyFcuM +RiF6r+BsJ0YkQ538v5acLKQhMGtizNyDrJWxMVjd0t1/2xO5EFg0mXC2FI3Sz6sXc0QVSkfRrPGm +VvKmB9q1YmYEUkaljAVcNRxjRBSXHxEkwRzjAEFzDuJsEfszvM/lhcmxgjyT9wKuls5bs4ZkatbU +ITrB9EwCRaEoUHeOkkyvK3YGi2I6Gr7SPLdzAg5GmRplRauBMli1GMuCRD+ApfPGyjtlSVxNduXk +IvXlcmBKwwwaxExW46XQqbeL71fCYFNZNaGXRuBewYsSVmfNMQhJI6YW3Fssi5Eipmrx90im5WQs +fNRj5dyepCkKm9cLXUO6SmaiEAZWjsBms/jbbEBRmjGJJveMZNUh0DtgySpZM5QaH6pgYtXk76f8 +MUFKXd8bqmTa0dlB9TCTjLsXcG52lAIVDj0m2EsrkIfg+WUkgj3MVtgrsw51L2AV7f0cJ9YhsBw0 +Sd5E2HLhKOzMWpSselEp/aFVDeedEyBjtER3ro4U83sFN6sdAWMs5RzEz7Oyv1v7fY7kOdUE/LJK +gAi+KZ9fDVCkPwYRqHBdxKSbuTjw8wEM3WS3ynP9/DnEffQN0UMFACvqL1i6FWUi1mkOKyXj4kji +dTD4Q5sXurFkgYlD5V0j31fCFQBBryv4e3il5Fffi17XlkBgLINEOs0qh7yWFmzMKUyN4h8LQZI9 +/o0oGWtiu3XWtYI6AiiuVlYkiIqgsTfQwUtWlSZYqE98mFooL9Ym3JBdhcrUJfUXSR0WUlJE5C0s +f5WueWbZMlvm94wvQ90FLMFePoqiQA2BckzmG+LLgsffiC+YsblqmR+uSbSs0QLhS5RDT8uK2qSV +ksEARjsb9CVLrTxsrWHEBfUQ3MEQL2qaNxcH7BtZUHgqDNckUpwwPeNewHFtwYGfb8CRrRihGScU +3vqJtRlVb17z2hyQWQlswavLfFtU2GKkKd2xeqBQoFocvHDdEObBgSumSRm/poSBPMpnhBFQhwg2 +zzS2dcwxrBc4JgUo8XVhFcaTD4nWccOaZKjqLyuFann2oIOBgZiEKzXksIRgIRqwfF4SytCzSUPX +5BSQjLyUrQh2DgwLR60W27Ls9gU9WlUdk8Fq3aA/s4hGrsdPsE6XjE+1bZQiEXlV3sSFCZsxuIOb +Ps5qYAYvIZjgOSbuLXGUqyRWSjJDzoCEkbkQZVnR7F1luS/olow800HO6XpnhxS2pMFRk4BrYlFb +dG7xel8wWtgYTHn9UqsyrLKCQOKUm4sjhqvix2m52X0vQzfHKnOQLML7DRgjMK3caCVFIgYHvJfk +S1Qtw4DMuSQ12oa2eDY75gGrBwoFjKCDF/Z3DlhXVDrShgIFqkgTantb3y/DeoEHyKO/+/rvd+/e +H1998/7V2zcv3v355mcA+sl/++nN33/1/t2rN9/d/OSrP774/uX+9UsqN/3H3/75+5c/vfk/sNH+ +wUY/P3KT/xP+4jb6/UQladGZivWHQNGi6uign1K12oWCyq7eeNB63om3KaQddOvKgoWM2fsN2JJX +5tlkRTXHEjAvFJXxBNTh49yRoS2VBykj0g6T9+voKRjnrUiEjnTms3ojAQJkBJ1Ya+t7ZVgvcABH +jw7nFirwCz/MVEcebJpANdCXmEF3R77ihs/qQQl03WTiOunGXE6mQ9SkVN5vwFLFhAnmTRw5Rofx +uHOwWVUHVO7OiaWga4sJXGHdYO1AoYARdPBiKaUO68zHE0YKBKjsVWqtre+XYb3AA2FvwFubsLQy +aLF6owTfeAPWbiSuRr1qKFIOOhZXpavpjLug9wpmKrpyvwFj2SXzG3G5WJx61TaYVnLssG/EbQUa +3zq2lIqII8oOlNcraxUcuALbiHRmT/L4fgEqa5VUa+s7ZVgvMEBYO2MBa7xdYMWrgui6hBzplhGw +Pippr9FudMC7ERCSnfbKLqoq8yaL7eShkiTJ9IKJq6taa6rK+upAZW4oc9y0xWUdlg3WDmQCulhh +aOCYwIh05kPaIwECVOYqsdbWd8uwnnOAeQtWZ1sq3ZYxB7oJA5TuFumWF9DrySDAyOmS6K6ElPmO +LzQROmvBshLEEc+s3m/AyQK5WE+4kKrQpBwKd60U3jEFyF1DJ6fOe2uLay7EDdYOFAp0cBQc+JDN +iHXB84hbCgSozFVqra3vl2G9wAPhLuYNoYSNjdQtNK4apnXQlRSRriZL/g6ywnLXOItXIzLWgDly +9xuwVMZmWrnaKE06yTNAlVMMFgEqZ1ONy6ZtlBp+A9YOFAps2gs4sBdyxLpw/bKRAgEqZ5Vaa+v7 +ZVgv8EA4u9DRP5ItsVIBe9B51jpc8sPT1N36Ue3mFNlSS22MGm8QZjtoAGvhJ/TTp1WsvCi18WYs +MaWGCQGVvWKu+7aYH6MGj2H1QKJAESg43EaLNCjSpcdPOgECVO4qsa5t71ZHesYBZg== + + + bl7XSvevLXkJJB1m0E5H3gaRBRW9BnTHkt2gI3Ip69uaVub34GiJ8zOqJIuIfS1gM8uK60A1QMpa +86YthnnndYO1A4UCGxwDa3KHwxo0zuwIYJiyVmntLX1fDeUZA5C1C2u4OQXWFc5v++kM1puJ+tVa +7JcxBpek+GtbjL8KxdD5rPSt4nqJt3KIBauyFw8z805sDN+Sr3QYUHYgv10/3qEap3A4+7zrb2eY +8lbp9DO0d9NQbvv+hebJ7nHmye/Eubeocw/++XYqcqvIj1dztg0uxGcU0gVFXWQPmY73G3Dp0Vs8 +asF67GoJsFaV0YDEb0sC8G2xbF4sG6wOmJxN68CBsy9HrHjfSN1SIECmoFPr2vZ+OaxnPCBJ9eUG +IxUlTEyapCPeb8CBc/2pgCNb+5hM26y25RxXB9SOcV7/0BYdl6l5lB0i7+ZPd3DhNNIRZb1FP8bm +9QLUkVVSe1vXo471vPfXMhY5nWWWzlFU8n4DDui70uqagEM2Mi34Ap2DlzYHVN6WNS+btknOyg9Y +O1AoUPYquBdcc1irHZh1FAiQEXRqe1vXL1fG7YwHVzIWKS0nm4/GgpAOjEpEUO4mSoNCjoGOplNn +SdEDlbvoTtu0xdBmyxusHSgUKHcV3At3OqzFqj05CgSo3FVqXdveL4f1jAfXsheRCHKxruxEkbnr +oHKKhIHd5VxDVu5yXVUDKndb1LlrbbOcTxiwdiAToJ9XaC9M7pAWu0jJESBAZa4S69r2bjmsWw5c +yV7kJLFFNWEsTXi/AQdOEXkmdX/VMGtVlmqR+6QMyF2jClLLpi0eFY3LBmsHCgXKXAUnq7nosGbL +cXIUCJARdGpd294vh/WMB1ewF+n9dZUhq1EzIRw4cFYuA+OiQNo+uV/itFegcnYR2eja4mFUBRrW +DhQKlLMKxjsYZi1XrViznX5xFAhQOavUura9Xw7rGQ+uZi+ivKIUNnJPYf7+/QYcOJeF+9Gizrsk +B0axQHfQKZ4s2oPFvJf5vO2c63KGVYFCgc18AcMuIyeEHVY8sxO2FAhQESi1rm3vl8N6xoNrWYx4 +/V9TJw7VGLk/A+uNGghMVc2P3jfYKKsDat9S1OFxbXtQ02HtQKLAhsfAlnzZsaauhHQKkldYOrVD +294vh3XDg+sajbhTtCajRwcA7s/ArsT8Yr4JHFthRVFDu6q7gi5unJdtyxpCOEPZgfR6/XwH69EK +h3SY//p+AZp8Mn+JtfWdMqxnDPiG00D+A2JbHzId2ZD5d7EeY7bIhrceHbhwesEzrhVNx6V8lAur +Drfow2TEdCwNS0lKvm0SZ/6A1QG99ejAweLODqsc3RopECCbn51a17b3K/hC4hseiKL4RYYjXUKk ++RK4Ad5vwJiLULQyNx+EQGa5KtOdgwRUxnLBKN8WK9uuvC92rA4oFDCCDg6aVeeQLnZCxREgQOWr +Euva9m4Z0nMOXM94RAWqiJ+f6qHcb8CZPD9MbqNCQcgvO/kBCpakfAiQu9awymQa2+KBmhLagNTB +5P06Ngq29GePFK8qDJv3M0w5q6T2lr1LDuVZ969lN2Ll+RTUaitqlHcoXkiSeClVTnulOWf1s1c5 +m2ZAZSzf2Ofb4mJOyljF6oBMgEmTpIzVQ00OKVhLq1w40QkQIBPQiXVte7cc1i0HrmY0xqIJJ3ij +aV46cxWc+8miyodUeUGvxlw+I2hAZS6fBR7aNjnVMmDtQKFAESg4+ALtijXYeWhHgQCVu0qta9v7 +5bCe8eBadiPebiCR+8iZvfcbMN4TyJ4fvJwgqr2giXZ0s8AA5L6tuOfGTVu6mGXdYO1AocDm/qzM +aU3fpUgDh61GAoKLpjliXdverY70jAPXsBpRKM2zxrvwxND9Bpz8RQ58OSpNOslixqsZWlgcUPnK +JwKHtlhlUflqWDtQKFAEHazlmh1WDLaUdUOBAJWxSq1r67trWM94cDWrEZdOj1jNs+5kHZzsmlm8 +PIMOhXAu6azsrVWdxARU7vBtIUNb2HaKstewdqBQoAg6WBM7HVY62pQ2FAhQ2avUDm17dw3rGQ+u +ZTXSdSNBlkS2ueuhpsFUTcpEymJWMcxXrxpQu1YlBWNoy/WeNlg7MK+dNR2qNzR0nFiXw4D6fgHq +55XWoW3v1XoBlm3eXsFWRHJzU1u0mKbgwXqCBntBB5Q2g57T7GeCzZowp7O2fHXcBmsHjqvawFqx +acBaWzgjoLbO2k5rb9k75VBuGMC24scsuX8PI44O6et86EacA/ey71jUfy1ir2mlsEQ3ijUHJGZk +rAha29g2o49fdTlXTF6B3ohz4K5hOaw9E8RR4DNBHLWube+XO+J+xoMrGHGAdK3qx8EiQvcbqLux +YsXtQqI+dmMGno5eowMqX+eQ2tg2o/N0CSNWB2QClK0KDXpVm8Np6cz+/QJkrnZaXdveK0N61v+r +WXB45cWiwxWxptb9BtzvGsXaGLnJPNaaQXRbQ1odkFkzy/XFvm1ebIfqWB1QKNCx6bsZFfAasS5c +32CkQIDKXKXWte396ljPeXAtMw7vCclFfYpzM+YqFPM6o/A2pKRnCRZ2dSaqbxQdUHmrylVvi6s5 +aOhNkDoYv96kiUCj1QByOIPdg+feL0DlrNLq2vZOdaxn/b+aEYe3qjQdMyr0er8BZy7GwfTGqOE4 +vacR+kalXDpQebukvGkLQDp1O2B1QKFAESg42q0sDmuwawQcBQJU7iq1rm3vV8d6zoNrGXFY8SZm +NVBVGR6gVAaWyU2Lhuml0C1d95Jjh3HHmpyHdS1p2qnLT1EOQFOEHRQP8VvJIcUZ/B6mrw9+D+uU +ura9Tw7rtvvXMOBI2OsQ0pnI+w24nxqnikWagKsJx9AtUAmrAypb6UzKti3dPzRi7UChQBF0sF4I +4rAGKwzuKBCgMlapdW19dw3rGQ+uZsDhsll0ICteH3a/ASdTWZFgKhqEQD0hCMAW1uCAyp1QyrJp +20xndVjboMiqn3YA+7UvWEPfnDoFYdzIlNqhbe+uYT3jwbUMOKSBatZwzn/ok9eB56pXSHHBRTJ2 +orF8DeoUIaD2rVWN8VvbhndyxQ3WAWjW7QDWApcD1rXfgtUpWC2sNVDr2vZ+OawbHlzNisOyZU0H +DkarT94OpnKmAiwWnusjX0UTjeNeUtb5vC1fQL3B2oFEgSEwsBShH5CutZy9H2H66U6qa2l96hg3 +3f/Ps+EyiKh1Tc5+ud+A5Uq8Z1w1UPpXrS4N1i206Fw/GIj1EHOrm7bRHbdWrA7obTgHllJpI9aF +y/+NFAiQN9BObW/r+tWxnvPgCjYcXomzLuJDSVbbxIGzBf7xhpXQE9GaXiTC9TEMyHxZpETU0BbP +3s5pxOqAQoGOjIKt4pBDGjqzOwGhH473xAbPQu2WIT3nwNXMuNxjhImP5t1vwNlVxYytiPWQtPQG +VmidVwdU3vJx/qFtsMPQhtTBkjsx6MCx3yHQkQarNOYIEKDxtm3bul51rOccuJYRh6U9S1MjJhtn +FZj5EmGmNhUL/9pVOTCqrcOUsVzp3rfEksJhg9IB6eXKVgV23cqhxIRsKRXT3y5AZasS2tu6LnWs +285fzYDDi5zsVA6V3LvfgDOXOX0mFxs1jSfr3QooxZfFAZWzXKRqaEs1GtuI1QGFAkWgYKsA6pBi +HRcrUKsECFB5q8T2tq5bhvScA9cy3/CGK8s0I4l0fwaWCHpuzmCOtn/A9HMw5gueXNSgvrZc5FJr +h3GAdSnpwNEKujucge+bHF8vQONrK2Fs67rUsZ53/xr2G1UOtlTfde51iPqBvCz3duBdXiUuOt9m +ZetSl+SAylcqzDu2XbBqSByxOqBQoJztYC1c5rD2cq2OAgEqZ5Xa3nbormI958HV7LfcvXiR71S9 +34DRN9eUDLVti93xNa/L0mHK2mQJk70lFVIeEDqgvFw/38F0ceqItFfqdO8XoHJWDWttOfRTcZ53 +/lqGG44tla8kzLOenhzB1epc0Vk9Ht202FVxTTX7fkCvzC7DVNuiREwq5RTrCJw1HXEAq4N4wFpy +C2cUENB4a9S6tr1f5nY+48HVDDesFxb1ND6Fd+/PwFoxE4G2B7iR7yFtAmrnWtQMSN+2tHqGtQN7 +3HkA202/HqvJyv7+1kVtp9Ta9R45fJveP8ZuW/79sigL+lqc2XI/ALPW+6P7CFZxtvNOZvejCIj4 +UPVeNtdug2k0kgyC4VG+DtDhwCr5y+ZlDONPdqqspdHeEW77eK0TdoC3WKoDXdh8vwFnSxlDUtcs +im5KTa+UKC16IHcLb93TIIa1jVwmccTagUKBjoKCe0DfYQ12Aa2jQIDGWKG2t3X96ljPeXA1C63g +WtGBi3aexoHxtiO5HwUrcEStV5Hsyo+yWG2cpN5bvN5kVqvY2kp11BFrBwoFyl4FR7veymENehmp +I4Bhylyl1Vq6TnWU5wy4loGGt4NYbbegh6wdNOPxPr1dRH1X/QJ0vDclOZDyNc0a87GWeP6+hg3O +DkxuNXdoHG6YmdUcozue/esFZGxdLZFXWroudZxnvb+aiVZxdqsSSmL5/gzcJJBTZ7kAnBd00Yuk +UonNAZW1VLlibBtsO3dYPZAoUAR9609yhsxhDVYk11EgQOWuUuva9n45rGc8uJaRVkk6q/mHWd/3 +Z2CjoYfN7QKiBYtWBAcU1myaBS556tF5EL3YJnxTr0oWG1kn8Kx3V/W3CtD4KRS6tr0nDuFZr69h +m+FNcEGr2MxFbbMB7PYuvlubJppciYj9WtSKs/qStFE3DRRZ24D3hmyxeiBRoExVcFfZHNZ+jYSj +QIDKWaXWte39cljPeHA12ww30Bo1o3VV1cCBU7+jDQiWUkfJcjzwtimUYR2o7IVBP2+7tpw3WDtQ +KFAEHeyvwRKsWFowhQ0FAjT2lrO2vruG9YwH1zLRSBipq5hSDu434NQ3diysWI05UacOFbXqQGUO +bOztrG1uWmvIqRYKjC4XYgCL+eyQRs5pHAkQoDJXiXVtfW8V6RkHrnugbhhlTMm8P4M2ueaGbmAz +71WKuot07wIBlT9LW+tZ216cxbB64Bo7fzuUquKOSIcp3d0LBDQGm0/NTdTeLcO65cAXH6h7ZDWW +D5mCv/sPK84CzIMVsG6P13mwlVGZa7OYpxVcmStmqbKa5oqzzJVu1V03baMr4WFYoyvhYeaiB1sZ +FY/VCq54ClxxFk9tb+v61bGe8+BKpuNcMeJi0R8tzuLBXEkFO7ZKbpMVXMGOaQTeFWfBjuUwtlwX +KSNtCB3ElWbxYCui0hFasRX/aleYxZPp2vbeOJxnPb9aFc+K9+GoNWyFWTzYSqjMlS6ul/xSObuM +nYNvvgKL8jXKntnbrrNcUemxOqArzOLBVkLFY7ViK54CV5jFU+va9n45rGc8uFYVTxjiHOx4mRZm +8WAroYL0lllr+kqxFewb38I6FGZBPoQ6tlx9nEhxOqAry+LBVkCl47RCK/7triiLpw== + + + 1LXtfXI4z/p/tSKeFSt+a56MFmXxUCufgsC2rpoAzYVWACee9W8OqJzVHMredp21zrrD6oC9KIuH +WvkUj9QKrXgCXFEWT6xr27vlsG45cK0inhXv31hVj1Ankgdb+RScInyNkCu0gl3T8qKuKAuyYQ6b +ls0V2zOc3mlmJVk82IqndJxWZMW/3RVk8ZS6tr1PDudZ/69RwBPfP6vhbwVZPNhKpyCwWnBSiqxg +vzSj2hVkQbBaJ64tCMqs5fMMawe6giwebKVTPFYz8z0FzhvgqXVte78c1jMeXMt6pF2gG2lakMWD +rRwEzZCks06KrCBQDxi7giwIrnXTsrkqyIaz+YrJWo7Fg61wSsdpBVb8210xFk+pa1ud7Wo4z/p/ +JcuRSLN6tlaMZQRL2RQEghz3dVcEuDZfoUX7Vixd3bUta2tnWDvQirGMYCmb4rGmrqR0CpJXUjq1 +Q9veL4d1w4Or2o40TVYtsGLFWEawVE5BWuTag6YlVmhGLRq90GIs1L+wbddrrjqEHWilWEawFE3p +KIfVpO92hVg8meMqWftVHyWfAf+XKMQyY5jClnC3FB3YSqbMZbWy3lZcBVaGTUhXiGXG273mlDdt +o9yNPGDtQG8pOrCVTPFYrbiKp8AVYvHUurbNSWHDesaDL8//RKRy+UdzhVg82EqmIKn9egcproLd +6hy0QiwzXcimxTWtLd5KrYa9Ye1AV4jFg7VmikdqxVU8Aa4QiyfWte3d6kjPOHA1Y7FgDqp6F6wQ +iwdrzRQkd5GzzFZcZaYb95bggNy1jKtp2xYMhn6PhCDtMFeIxYP7PZQOqZZX8e/vhVg8qb1l75JD +edb9a9mJpflLVuR4tYdayRSkds7R11zhjvHt0EMhFuSBVnhzbWExRw3gGNYO7IVYPNSO3nqkVlzF +E+AKsXhiXdveLYd1y4GrGYpAQ7XUOSvE4sFWMmXGeyVTGQuxYN9a1kOTVogF+QDKUtq0zXJd/IC1 +A10hFg+2kikeqxVX8RS4QiyeWte298thPePBtWxFwJzkng9XiMWDrWQK0rvKQU8rroLAuS7bQizY +ZbUUXNuMl22HDdYOdIVYPFhrpnikVlzFE+AKsXhiXdverY70jAPXsBZRKFUrNKiFWDzYSqYgqVXu +57LiKghc1tVXXFG+lqSuH2tbwGK2CKZi7UBXiGUES8kUj9WKq3gKXCEWT61r67trWM94cDVrEUfX +qr5aIRYP7lcFFrwJbTbvq01bGMLggMqdJlXvXdvCLvMRawe6QiwjOAZrq1gjm5MjBQJU9iq1Q9ve +XcN6xoNrWYxIw2xWhs1dD205qEzIIVpRbCUshX4aoS/IuGiUvLcMUSejQ9mB2eath4Yl6xRVnFoF +wb+dYfpxpdO37B1yKMe+XysLlIgNdrNFMS3Bg+WUKHXCbES9UhH7EFtxQJsxWZM4Xdua7bhux9qB +44o2sFRMGbFyaZWRAC3CMtLaW/ZOOZQbBvynHeCb8SBQ0mMV3YBzYCuXMmfYYZraGVJYBZYUXr7r +gcSMHO0wo2uL4TXV4wxrB3oDzoG7duWw9it2HAWuCIun1rXt/XJYz3hwBQMOj6/J5Xi9CIuHWrkU +onTWCI8UVsFeZTk97oqwzBn1Hg3MWdtgd4E6rB3Yi7B4qK1/h7PfKene74qweFpd296rjnTb/6tZ +bxkvTY+6N2kRFg+2cilzxuKUsyi3kuGOXSvR7pTTIizIhh7etrbRdieHNfpNU4uweLCVS/FYrbCK +p8AVYfHUura9Xw7rGQ+uZcIB5hq0nIQWYfFQrZeC1GqKqhVWwZ7VqGEfK8KCXFDFyrWNri66Iu2w +XoTFQ61cisdphVX8+10RFk+ra9s75bBu+381Aw4wp1VVBCvC4sFWLgXprUm1Ximsgn3Tu99cERbk +Q4s6NtYWXtH0nJRh7UBXhMWDrVyKx2qFVTwFrgiLp9a17f1yWM94cC0DDjBrmZ1ehGWESsUUJLeU +oPduzMrbltT20CIsCKW4xNAyWQqJQ+mBpgQ7qJVL8TiD38P09cHvYZ1S17b3yWHddv8axhsJe00D +tCIsHmzlUpDUXNVjoPczZixLq2WDrAgL7S1BfRbWFn+0WxAVawe6IiwjWA7feqxWWMVT4IqweGpd +W99dw3rGg6sZb7hsimYMWhGWEQy9XKUfvQy/5AwjcJHyc6nnF9MqXTQQam2z01kNax4UWfXRDmCx +bB3SaJfaOwIEqNxVYoe2vVuK9IwD1zLdcICDSh8rweLBwJqlqrDVC6fQHxqDAEPWAxhBsxCpx7Pl +2GvbjPX+1g3WDnQlWEYwHewYsca+PXUK4riVKbVD295dh3XDg6vZcEjbqvm9VoJlBEuxFARq5cTY +d4ditcTjuJPE1s7b9lpWDmsHWgmWEcwFU0akq415f7+WYBlJ7S17nzrGTff/8yy4VPDAp0+VvN+A +rVgKKNywiLU0ppRVAeHm4nJWgmVOwZRR1xaUfrBYN1g70FtwDmzFUjxWK6viKXAlWDy1rm3vl8N6 +xoMrWHCpWAl8V4LFg61YCpJa82ypZOxmgG6l3DyQuxXxXvVtW7zCW+uSGdYOdCVYPFirpXikobOl +E+BKsHhig2ehdqsjPePA1Yy41KODrgSLB2u1FCS39Fs9uKwKdi2nFh1QeZsWvb3e2uJZHY3rKdIO +cyVYPNiKpXikVlbFE+BKsHhiXdveK4f1jAPXMuEAc1r0rl41jx3Q6qUQtRJx1MIq2LEStW6pGRkp +2vW9vSVeO62hTUPZgVaCxQO7ZuVQWlkV/3ZXgsUT6tr2Ljmsm85fzXxLmIer11dYCRYPtmIpSG7O +GvWRsirYtX6JoJVgQTboBfGuLd0LXTdYO9CVYPFgrZbikVpZFU+AK8HiiXVte7c60jMOXMt4A8xz +v+JBS7CMYImdp+zM5Wj7x2o3qUXbPoDIHNexJZ78yHXE6GFOSnawFUvxOK2sin+9K8HiKXVte5cc +1rPuX8N6w+1Tbq1wJVg82IqlEK2LFoeWsirYrzavvtaK8rWf9bW20dJ9HdYOdCVYRrAUS/FYrayK +p8CVYPHUura+u4b1jAdXs95S9+G5EiwjuErec8Jz5XqbWOFzidS5pvGComcYSQKmms/aggKzbrB6 +oNVh8WB0BVRFUCwBU60GR0FyFoaj1rXt/XJYz3hwLfsNhzipZWmVWDwYqFhV2Koyjr7QqOT2onwE +VN6szTZdbYspqWa+CdIOc3VYRjBoOrb+m907vtZlQ4AAlbfdcnBte2cN6xkHrma9IRFJa1pbHZYR +LAdlCbj0WBlHglN2EW2rw0LgpAfvfNtZrS+HtQOtDssIljICI9ZWzt7furztlFq73iOHb9P7/9w6 +LHPs7hZvwTmwVlCZI2qdQ42VOUY7Cm21WOaIiv1QswUmhmWndnQd5i03B7ZKKh6lFlzx7+6lWTyR +vaV3KRnKs45f64xdxGtvgyYvankWD7ZCKkhuapoXJSVXqGdydN+VZ0Em6IF81xaP+au2Z1g70JVn +8WArpOKxWskVT4Erz+KpdW17vxzWMx5czXqL2XmbrTyLB1shFSLYctHkDDV2LhWtfmPlWZARqarF +bG0X1DCXDdYOdOVZPNhqqXisWnTFE9DLs3hae8vs3O2G8owB1zLeYt7UR7nfQK2UClKrfi0ruoId +61LDCrQgD0rVA4PWdjkv+uKBya3p5byYikdqZVc8Aa5EiyfWtc3nZV/OOXA1Ey5inrIeQbcSLSNY +iqkQvb3+vgQHY7cJXIkW5MNatbyptQ1OLTGsHmglWjzYiql4rFZ2xVPgSrR4al3b3i+H9YwH1zLi +APNqJ6WsRMsINhp6UF0PWkXyUfu6Ldyz6LYta4urU9U441YHWZ0WD7ayKh6nFWDx73fFWjytrm3v +k8N61v9rWHGAFXSMbbGWEex2spDXsVgL9kvLp7liLQgOdVOshaYcrpsRqwdasRYP7nqdw2oFWDwF +rliLp9a17f1yWM94cDUrDnWVWf0cVqzFg62sChG8aAKl5oJEVCz1Rgor1kL7iyVQurZ6O7zD2oGu +WMsI1rIIDqsVYPEUuGItnlrX1nfXsJ7x4FpWHIklS5XUYi0enPo2jz6loFsqF2DBvjVLobRiLbRW +V71gyrVNqxYV8orGqiWFes7EAOa6Kh6pFWDxBLhiLZ5Y19b3VpGeceC6B+6GUdZiLSNUyqoQzd3P +xQVYqH/mArBiLTSnTHt1bcEAKBusHmhh0gEqZVU80mFKOy/I4myIfijcTdTeLcO65cBfZLEWdwbv +S0f9rFoLXoGkRhzNxfsNOLP/AIC4Xc5VC0/Ixcxz/P/Ze9flyI1rTfQJ+A71RxH2jg0aeQGQ2Pol +UrbH59CWw7JnFHFiooNisyWOeOlhs21rP/1Z37cygQRQJIHqJlnFLikkFhaQ95Ur1z07n8AIxBIY +I+edKd3wW9MicYcd1JoDYw+ODxTcHxwEn4zAXcIXY4RxtyFaG9MdIoOOEUjcYJBa6lj8tgzIIpA8 +VhPCZMCsY2tm7ERwBr3wkHzwIhiNMLxKM6ECbcCloMJd6UBsCs0QMAPKFWjVFyogc7/eUle2yBbH +esEv2JgSqYTZklJEqDRHvQ46OskHjE5vuSiRosXGBC/0tdKZCNicXU4kdaqAkatpkh+jU10h3oeK +Q8ZFWikqHH6GFkOwpVHSr8C6QqIkK31JAhdDc5AkBkDuveNYgV5PYEsczcIJnRCMK7ywcra0HUes +kRpRyUxtIUZWdi5O4JBSFtLSpZsVZRZSQm2Zr7pVYFS569xaDdsNro/fBEJFQ7OsQ1S0YSGjdSkg +/Y9hDqrpoh8TGzA2q3yLrC97fhXHFm0rAqaPrH5rNANlAJ1XUQoco4pCgojCBkbi2nZ2mNDK2eqJ +v0zu0nko6rW+ZdnFSlZZ7sGyjpEnWLQ6Xm8m462ob8RCuFozaQkyVraJKylnddqYcFowcdE8XEoT +Ppe156LVEROFYwqKM0kPLD9bk2R8D5KU9mRrfcow26pes+3y/QTceq6MOiJnLcWaUGu+mrM4q7AT +6tqmZABtqZkgdKpLZb4x/ybtMGLB8frVOuFB0HYk+atv/hTe/P767dHtxw8/Czm/O7+9BrAC8M1f +bq7/KjT/Tsh+USj46Pyni+v8xcFf3uONKfXV9//zj3+4uJRqDn7X/ZRz5nc//PnkLzdvz/FzcADd +++Lr1W/+fXV5La8K6dbtxY8f784/4KiRM+z2dPTF2c8Xl29vz6/x3q5+96fru/4d/ncXT7LflF/J +QfaP64szAabzLP/wn6eXH/XLfz/84fXpFb9DJ9irbR3Hr7PH8esLjEP28+yR/Ovi7d3Ps0cTv97q +Ef18fvHTz3ezh5Q+f/Yx3fz4f87P7o5uPl6/lf4d3TyyN/oBvuP+l0/vPswe5aDMsw/1mz+9+eby +/c+nb8zcMV68zXjje8aEb/5zRo+3hUzefbz98aNw+Gfnc2dBi85c4tTOcxNNEdbnjg== + + + 58fTD+d/uD3/vx9lEuaT0FGpZx/h9c33dxd3Z49QyX6UH/j13y8uz+fvz0GZZx+hnTu0649X353d +nf5zwcjyIs8+MGy5uWO7Pf/w8XL+uZE+n0OB7um6eaDr66lfdgic/z0nJw939oF5f+YFubieuxw3 +789vT+9ubmcvSF/g2dHs+5uPt2fnf7w9ff/zxdnsI+6RqchPuust3zsX14+QkMFg7AvumuObq/c3 +Hy7u5myap+gA+bBH2/7dt+fvVl/vpb3tGMde2tveEe2lvTWj3BJpz3/J0t6721Nhey//cnPx4ZXJ +e7OF+L24t53i3ux9uRf39uLeXtybjGov7u3FvS9G3CvsaxH4loxky0U+/+pEvgUj2hWRT+Sgo/N/ +nl9+//Pp25t/fdm2Lz0yKRa+lgPzx8uPj3Arn4HZ3FbJ4MPd22/P/3lxig4tkHryQi/GE/zx9OOH +Dxen10e6gLvCS89em7fzj+G3L3EOzx/I/FP47Uscw0sowLZTs5t37z6c3x09B017oW3/HUe4Qxv+ +EnwLvATPbi5vbv/rXz+rGDOTPv96OV+VGL/eb6BPGMuH9+dn3318ZD/sHkcw27fnw8fbd6dn59+f +nS5BvEGh55c6Zg9OFvfj5ent8c31h7vT6/nrNi34Ata0paP8/b/f31yfbzDKvuAuySZFVZaz52jL +VRymXDCW7VZyFHbJWP579lj++wV5kL/eXFzfnUT1xUvoI8+/j1v1JDIXO8QPvU5jwkK+YdvZoI0U +PYutCdu9RrsmGS0xkmwLMTi9vbj7+er8br4BbpeIwuxj75dHlCnZcPDpFg/kEV48H4jZZlHhFzd/ +IG6rBzKfKv/yEkT5VVrhF3MD2350Xl7c/fX04jFZ8gs/O3dHVl6uJl68415oIf98fvvTOWZyh5ig +pZvrNa7F03Vg7zK0sULtq1eiTlvglbLdyjRj9h5D2+8x9GUFiRzf3Fwe3Z6f//dsq+Zr9Ix6e3F5 +Ot+uu0tKDHM4O6789vTtxcf5qJs+3w3t5nZLnPMH8nb+QN5u80B2TcT8883t+59vLm9++nWHRJM9 +WdshsvZqiNn8CJYtJ2avNoxtJ4lZ8XpcVl/NTl8WTrHNW332SHZtr++cx+3rjdmfzbLsY/bvG+PL +xuzP9sPdtZj9BYR824+k2Zts64+k+RLOjh1JO5lF4RGPkoysLXO+fyGv+y9yx2+9o8aPs7Fs66nX +7JHsShDO32abU49/Pr2+Pr/8/vzy/GyJPm1a8PktQrMtrZsOclrwxc6hby8+vL88PTu/Or+++/Pp ++x06jK5OparZhsmdkI5W6d/V5KcZ/Jw7av6az3+nz7eYUm79Sbws1+A2n16zR7JrvPcxwpj/nMjH +rtC7BZi17Xtktg5h6/fI7JHsCoc3PxL5eRKvbMvue7fIP+jdxeXlEv+ny21e6Xe3N1fzB8OPn18r ++QiTkxnGHvMYzy1jH18k5mr2WH7EnVzzdeP69fMb9S//dfrr7DEJ5bs7vV1EKfX77dWE393Mlzxu +XmAgt+cUAecO5/Tt24u7i3/OF6f6Ai9gj7meP66zs49XHx/3FspHlhV5gYim6/PT2eEvZ6eXZ3++ +eTt/bH2B5w8+m81bZKuXmv8LhzB3AYelXkgkOb2+uDp9sdSwu5qHrgh7Z5gtk+zOXo0zzPyR7Jr2 +Y+8Msy3q3v2FhROdwq55w8zPabZr7jALSPm2H0qvxh1m/kh27VDaSXeY2fznbrjDfJE7fuvdYc5e +jTvM/JHsirFk7w6zd4fZlsPoC3CHMV+KO8wCmr/tJ/GrcYeZP5Jd47130x1mAWZt+x55Ne4w80ey +KxzetrnDbLX9Z3e8eRZsuaXE44XWcBezBi7wA9yvwpOtwtPl3NiBRXi6DrxQ47uftPGbP735ljl7 +3izTfM1iiHbniHq9eYvmqwF3JGvR8yQAfylquiRPzp6iPUzR6j1Fe40Ubfay7inanqK9Eor2+1sB +fNks2jmm4DXSsz2HtqdnXyY9+6IZtFdLz/b82Z6efWn0LDfqvFlmhX9lZG324L8gG95+28zZNs2X +vG1mD36/bb7wbfNl3Rb014t/n1/+9fL01zfLgh230WGnKlfVbO9Jnfm/LXCgzErsEuW7Pb+6eSy9 +wY7lepmfU2SfH2WfH+UzId3KfG3Llank/+VK/vtafsvfr+XF6rW5bF9cvz1/d3F9Md/AdXv+/vz0 +7tsF2y0r8ezj2+eI0XHtWI6YD++RJWbu6HYpR8xMbuRLSxCzLTzUK7yg8Mcll41vuaf+krHsiq/+ +XmGxveTgsb29m3alRRRhy6nbhialrQ+fv7l6f/NB2PLvPj5CwnY5gC+OcYcIwuntxd3PV+d383Ft +lwjDbJ3aL48Yp7Lh4NMtHsgjytB8IOYllBGzB/KI81M+ELfVA5lPmn/ZFcq8G4foQqlnl47QV5sV +8bOcobtj4thoTXfGgWgfALg3J++eOXlZmsJt1CrtzcnrZmVvTt6bk59xPK/VnEziAoOyLb9eRGj2 +JuS9CXlvQt5fMzIZ2d6EvKa726Mi3puQ9ybkvQn582sndtSE/JqMrW8v3r37OP82k20nBQuHsyvU +YHZ6ug8fb98JZ/v9sjT/g0Lba0fS6V82tkGZZx/ar+eXlzf/mju+y4uffr6T98UZ8uDOHuK42PYu +YNydxzfXIrpfz993k3J7pduLKt32d9w+Ppq90u0pSOnXP92en19/LRzY+dcX128vfrr5+p8XN5fn +d1/fnr/9+ub29Pqn2Vttr43ba+P22ri9Nm7NyObzYXuV3MtwVSbMtrqc/vfF1ce7R65+zJckff/s +iFfPHtP5pTwsUvlkJV5M3/PtBfn3E+yvl/KI+VZliZO4x3cI5V+T2unD+/MzObhun8MX/tmlo1et +rJlNotISL5b2pwW3eQ1jZ3//7/fC620wyr7gCzDej2hzn0A1tdfb7PU2e73NF6S3iVoa1dtEJQ7V +N3u9zV5vs9fb7PU2e73NXm+z43qby6jQeBUuFHsl1NMrob6Pwt8OaqFeZ/6MDfRR265ie5URwM+p +N3wh+rTPobFtxOHV5NCYn7Fhy3NozF+RLc+hMX8gW55D43nuAdlub+LtPz4vL+7+enrxmJVif3bu +z8792bnxQLb87Nznn9q2s3MpVd72Y3MjYXpXjs593qlPm/ttOXYXr+c+59SSDrxQ4/ucU7uVc+r7 +n0/f3vzrKe4v2h1K9IVnF9gVv87ZSdH2EfnPvoVmX6z59hFymru1/fsFkGz+QH6dP5Bft5wCbDs1 +u3n37sP5HbbE7fnbRXR612SA7zjSL0MA2HxVX6MksC2r8rrvE9+LZrssmhWm+mouSs7nM16CzVgy +kvmMxkvwGcaXs0fyr4u3C9wJ49fPPyI3f0Q/nz/ueZgNKX3+/BzUl6jUeIIs2rvDXe2VGjuh1Kj3 +So2tZYXDa1FqzB/IXqmxA+LvXqmxvcfuXqmxjZR8r9TYKzW2VanxhYlmd6cLHC1fo2D27vb07O70 +8i83F/Mdm7XwzDVOLT23f+bh7JwtP55+OP/D7fn//Xh+fTaf4xyVeoGY9O/vLu7OHlFg5RIbvv77 +xeWCXAmDMs+v+ZrtY3v98eo7weJ/LhhaXuTZR3b2dF5mzz2SZVqtLY5znj+SJxR4tuVUeH3Jjhac +B+9ub67mD4cfP/twXlPqptea6qg8nH1ry93NfH7q5gWGss9dNBjcPnfRPnfRE6uW58skX1rqoidR +Gv394+2PHy9lsndJj/g6c68sECm2XDh6npQrL6TnXRIftle1ruUPv3od3mPzx7HlvmPlq/MdWzCi +ve/YmlG+uIGi50vePBJ+/7rNFHc5f/aKjBTl3kpxs9tWitneTLtmpMCW2wKV+F7ce93i3hI02wt8 +e4FvL/DtBb69wLcX+F6/wDdbNHiNAt/r9UubndNhL/Ftp8Q3ewH3Et9e4ttLfJ+EZnuJby/x7bDE +V5jXIvMtGcmWS33Vq5P6FoxoL/WtGeWLS33/6+bm7U+3p/PP+9co8r3KOyMWxYhveYjEa8x4MVuY +22e8eHaCsE/j+dBA9hkvPpHDSHkgXgVt3ufv2Foy9u5SuDu9hPi/frw8Pfvl65WCbt6fnl3c/fpf +C3TCH+5+vZyv445fP78L95ILl7d9Zy0azK5tpj8AEXdoL71Ojeiy/bIT5+pmOYe2/dafD0zlePya +yNuXwzjs4m2Ar4nhXnp95pZvnIXD2RWFyGyvkw8fb9+dnp1/f3a6hCMdFHp+Tfmy1Vo2tkGZZx/a +v35eEJ1/Ca2+vC9mcB7ZCMfFtnf94uY8vrn+cHf62FWKuVZlXG6XFOjGzd68p/99cfVxgWmr+/7Z +l5w492qyDNWzc1qdX8rDImVzVuLFeKxvL7hvTqKR8SW8BqQP3MMnkVjtub1dufV1zyLtEouUFnjx +GTst+AJ+8ktH+ft/v7+5Pt9glH3BL4Ql3PNLL88v7dmlPbs0tw/fR0K1g/zS67QGbMA5bTsz+Dxu +0tu/TnuV+TOkE729uPv56nxBXvddIg6zD8RfHvEpyIaDT7dXzvjlkS/zgZitXpFHMvjkA3FbPZD5 +lPmXlyDMr9KReKn1bOuPz8uLu7+eXjwmUe/Pzv3ZuT87Nx7Ilp+d85mALT875w9ky8/OpVR524/N +jYTp/dH5Co7O3dFD729p3EZe6Mkp4Q6sxdN1YIcQ4bWmItonnx2NcvdSEb3eK/I2shhsNyv698U5 +rHeNb9vJJEtXp1LV7PQSu0DYzaqM/6771UHmDpm/5pON9PkO7K9tpxh/lKIfHnce212CwUiqP6cN +uCsU4xWeTc8a/7Wt2Rf2KT6eP0Haq8nxUcwWprY9ycezKKKeeUzffTFRrjuXHuN1OvEtZt1e7w7a +fnsK7A0Y2d9fcQLkXXRH2GRdtn0f5WOaHda4K6y2OZwfG7Vntvdn0mfYSz+8O7/9w8XtNqhItmWd +705/nL/Gu6DQtKvZdg6O/X8u01gOyrxcKq6P12d/2yFq8uqw7LBZlasvA8/+uMezF8Qz86WQs6OX +cjGhsIOo67/fnl5/eDfjFontwffXqQ/ZhFXbdvZzwziTXdCG6NC2hK/e60PiytBz7pvLyy1Yk22Z +ks2Qde+ruaQDL9T4ouufvvrmT6Z88/vrt901UABVgLz5y831X6UKpikpFHx0/tPFdf7i4C/vWYfX +V9//evXjzeXBb45O3/50vjKrYvXXi+tffnvwUf4tV98d9A41P/wqD/+P/Pg/AvrXyq/+vPr//ne5 +eivQH/52UB6WZdmGla0Om2p1dVCYw9KbuoqAwsr7ytQr6w+ryjUAtK5u5b07dG3drM4OCncYjLcr +aw9diTL+sPZWqjSHtglSpDqsnZEXAiiN9yhSHQYbvHxTHra1kW9qabaqGgJchWfb1KFNz1KkOTSh +am33RTi0PnjW6ryrV0WLIqUBoHGBPTMlPmrQNWOsNGOkT5V0QQC+bb0AZIC+bToACg== + + + yTia0Ay+qT2GLABXWQJC09Q6YmdYyMl0lZ6Ny3TiuQ2O/XelkfUx/tBiok04DJWOSEDetGZlmsPK +YBIEULuqXpn60FiPhip0RQrhb9uyEN7JcPVbVIzSlgBvArqLFqp2xRalsBRiL2y10l5JIe2mB6DB +8AsOxdoVh6aTJ6CmrQgqbWP4ja1k2DKrtW21Etc0K058yyFhzWVNmsO2rWpUW8onMqL6sG6IG8QB +51fACVv7VKZpwopo41JfGr8CXrkShYBrQCCsfOlYiPgoSyD4icUugK9eBg30LU33XPJj/V30L2Pp +oi8emyjyNmI/ir4jsatF39c4HiK5oHucbQ66yEeNaSn6eYlTV+RzF6e36OY3LkCRrwBXqciXKS5l +0a9lXO2iW+6EEkWGEwlvih5xImoVPW4R/9r4ow0Ra2vnTfzcpwowT6wSk8FmME9sWJeZnbEmdS/E +DocmYWPVbywdqLNxO3L3Ffn24wYtJru4yLcxt3qVfxWpQdGRA86+ifsh0gzSlcoTpoRFKU9gzwfE +qeipU6Jf3TeJwhUdiSMZrNMeUDoIPDI+IpasC1FNpi7OAFYFCOm7XRAUVQRtLTsAROYaSPuCyor3 +1SqR9fh4dkDUb9sEQAUeM54qIFnn1uhaIVlnlbEr6KxzVd9bjMg1gxHJsGWnuH7YmJiG3+jEYO5a +oHA3d5je4PrplQUQcmjTAnjSl5DwxAU0g6WsTLeUQqSw2k1abZBMGWIFLEsAKSTjCJzt/pu6Mm1E +Ld8o9WtDwj+UIV2vexwlGvt+kyW6HvcY2yFd9wPSXLva9DsM2ymU3b4C3ulucmnzudVof1Z6clQm +38TaibjR9ciVTtpEC4yeUNh0HFmNE2RIVSp+Y6tgIt3Rc5qbgdujCiwEAlYnClbyXGu49Erj9GzH +uveEnViCTUliKUNTPIpI7oxTHiLheGVYiPgYCXNbr4aku1llZD2n+C4yKBGzhTIrQfd6ZjReB+5A +lNi6FEz8Cbsn5HpwNMkzp7dxdTy9PAcpZLzm8eYbPexl+YiglTfahqBh0CMyrHSuvR6hdbOanrLj +g3h8Uk8P8/F5P2YIEs3uSfaYrRjzHVPWZMy9jLgbJdNNxv+MWaQxDzVls8acmBLnOrJqtc5pG3ER +fSJdbtrI74HHMKHuGEaQlYDlT1SFdMd070mXrO0YTpKuKudJE3VLxC2Rv0T9EoXsCWQioomGJho7 +JMH6dDzitE8Ojn48SJ7uRz+LIPKbf1xDaHi7+un29O3FuUglxre/lWpkbUzA31bw3Mnn7tA3DhiQ +Oc6b1dFPB746LGshQQAU6aEIppYFxsYOsuqyxEIPjq4O3knzR0ciLvzHR/StKY1QqPIwBOtkngCR +5TA6DCyyvKrkpUdPTFXLUpU47RvpyA+ncXSNMmIQJGSeraCliwBpl8uBA8dRoBB8N1YPHCu/ZIbc +YV1WrZ7+pgZDGI+WShqTSuoQ9BxpGosZlYkMjVGOojFy1tYgaEFPkjr4Wg8b1z8fy2FjHdCsA4VD +Z1qnR7DwhkA8J4PTlgXnWykkuOksT0IZhkwUThtXgkHHfgcNwmHj+udjnjWu9vkXVV3pUWNakHeZ +AOA/AGWoWcYdVlbPPeEKaqUJtY7PljW3YUvOEDsVHNcx9rYhLySbWY4wJQslzjTZ7SW6L3RA+l7z +rLFYyOOD9KrQj/1KC+vRYrCz2UCtTKXsF/SOnQBXy25VlLPYzYL9Lrn5y0AuE2NDQwLh+WrIsLT8 +Qsi6HjW1ZR1VCXqPWa+s03ZaMCoBGzhwR3vUhpNG5D3u6KZBJUQJh1UlkghFk6NGiElJWVQwqMJR +IzjleRwIllF+bXypDUVMLICbdc2d6dEyUNeEpkqAEh/Hn90rFjarrizqx/kU0ZpjN7V82fWAiGxW +XReJx6tsEBioLEI2zlboBeZBMF+nyvtVNlOcTZLOWljLVZxtTrZvu+XgarhWpykhlhABTm3CK65o +Qqt+0TOsUrwg5njFMjkQiFM4Qnrc4pt21aEfEdQqirm6w2G25StFe6I5e+PNKm6DrrPovvWrbJ9g +Lznim2lrbiXn9DltRt+GVb8XsVvLDoDdbGoeJCQfaUL7/Q6aQOVDJAkgGrZlDwWp9LCR02bVkxVS +Hj0wCQFpEgRfJcqEVQaV6YkXiFuibYnwRbqXcKinjIl6JpTtiCtpa0d7+XR8MEDgSvG7K01eVhqw +sr6KtGigGHShiRtJNzm7yM0WFTJxBAUG6fUI5iAhBFnX9vMSBaU6m6iCc+lt/814spUUNDZbj2K8 +ZMVoSYvJmhcjpCjGSFNM8aoYYV4xxsxiirzFGL+L8QZQumtNtkeK8TYqxvusmG7FYrxbi/F2LgY7 +3mqhIU3gJ6DEpBnepFNOyUpNwkU5rG3qVaLABSmT6ylTMaFdekw3PXUrcvLn2XJGIZUAFzkRrZR1 +SES2DFF6TQS4yKlzfBuLF1352ESRtxH7UfQdiV0t+r7qcIp8PHHIRT5mzkrRT0ucuiKfuzi/RT/B ++RmYlqA/Jl0bpy87S03Vn/ndcduhRHYmd3hT9IgTUavocSviX5EjoEwdT1l+HjVDRvZqRMUqao/q +csBtaGe8GXavyniWblsV+b6Ke6/IN59zETLYwEW2g+Me778BFWh8ZMOw8IlUZLxaR086hq4jOcWE +LmWMYUe8+q8Sfev4SyJIE1UViQoCi0KZcaqKaR0XC2R0LQT5np4rxlrTs8OK1t5EdnnETh8f/EEk +hG9zLruGsl5aEJah5qM02xiX1CShIj7XbdLUWkiRJNoiRLkIK1XzLtJEZIBHsxMhJNs4Dmz2FVaj +anWczXgJm44IKw5m3zTWKnmoQ0R43TC6TxJNhRTCxnyNiRdI2TSq7S5VCSjzQoUbf9R13A3CD9n4 +eTCxgkorCDZy7JUJqeG4+wSHVfOKOVG9XkPsbqChTJrfyrc6p41t4qYVBLE68556jEp5V6xL8D0g +ETD87t/F4n3p2EbeROxI34/Y1a6ncTj5aOKYuyGnaelmJc1dPnV4pzqBOL8oXfEwjEvgOh6+W6e4 +mlxMq5uf6z1GiQwjItakLxJeTZAvwz1iaOP6bxIOJxROeJ6hOSa1CqxX9wKmXQTola0zfolsd/9i +XAj1QuLt65WWg4lKgpLKzabqO69KCJv1XRX+RiFCVEfDn8zPaAIHE2ziKg/WYLxM43WcLvUYG8bo +MsWoEc4RJ0OHklOs5fTJoBNijxA/2xPj/ZJKdjuKldch33ax+W5rDjdvsxpucKv9GRKBCZ3g7DR1 +TkzSROrucXaVZrojSqzfDygX1yse+rpgWE/nOgKoWukmo5HAiNr2XwBjmiojvp0Oo0MqYh1PlghK +WJloesLbjO4n1O4Oh4T2Rb4hCu6IwePJwbuD//jHwT+orPrh7UG9+s1vVz/8ryngqzdm9c17+VPK +QfXVm26Vr/qH8TIPVjlDoTMUGWHZCAdHSMoSI0QeI/p4K6DMZLuMt9Now7EMuhC0R6FmD6kBR4eb +Cc1AiTFduYcW4dOcTk2J2JjQscSoA8WofxPCzUJT8j45ANZM1/QomRw261ZmempNjrU1GLDmgByf +oAnH9PPJ4Ts9n8enuBacnvYThmDMNaQOjriLKQcy4VPS9I/5mSnPM+aMtKSubtEtb1r+Iq3/hOtj +uSl3mDOPgy3PzZSRhwntmNAXlEA/OmlK+oGOmtjPup5Sy7j9RjR1QnXHlJnFxrM8WYjxIcAhjQ+K +8UEyPmsiURmdSOMjK8fBa+jxv7lG7JdQRHjiCEWEOw5lGGjzRE5pvJzoVyoyO3T+sApqwG/hNwC/ +h9rBtAGAA05UQuZNtKKLLAZzSX3YiFQb+I0UCVA+VLqzTOkrEefb0rvojWBsCTVX6yunopuBaa2F +erFUUdNAipKjCBJIFA9pNFHNmMg4Igt7iCUNJFZqAlRsxLBCcGrQKWE5kJmqSiwwDFCVpT+Qq1to +mdtDb/jcGhgG5fCTAYaKOItdZfCJqucrysgs46ySPtNU9K9IU1BgDiro/2QKMJFFmgVOQk3BPM4C +DFkU5WSMlVUVFYZEZKiwAQGoVLPEAR1rmaBcrS0rdk7NC7RuOWiBKki4ZHsbmoREnG4VESH1WVWQ +6hctrN6Qsn3UEhlf1mo6o6aN4nnAHKCoU3+MlpsC1cMDgg1yu7EHlOmlTyIL4xvTWrVLe4fZF07D +lSrOCn6rGrTy0Y1BhFhHHVBjFWnIdbbCR1SNVlK2VUOrWyQb0lAN/G9kdTGBAJikDKVKIAHoBNCq +CiGCZO/a9I2FJw0wuqzriOLW0d2gpkcMdwE2low1Wf0VN2TrmEgPbbToC2pXUeSUdoCgDi0rCW9q +eOhkpM0dto2KO/jO1KRW6TvU5aPmiqhX5A260qq3jfTKt8qeUVxHtzlnqd/AVBGGbD62YjIBkGFa +U/dTVKyZxwIG2jJWrl/JelhqFbAe3Jstd0Pc12X0LCth3tSljqREKGQV1750Ec9bF8k1KJLKc3q2 +SCmXHG20dWq3FdGbASYWQ3StQ0R2pyyEbaNVSZVD+OG1i8D2YOLX0Z8o2zvep1a0WVAqFJOutLFr +dauj9j4oxIQ2GgiruOlKOe6THK0wWVSYUzlGKsNBEVQvGEknqYZ1PjYH61RHXge0J9Ff0ugiJ9KR +kBcdJU+0vuiIfToQinQiqAcYvaWIiwmHPZVDLhFv4LAQkDLqLfg+ex1rQAV1dJoanDtnsDuvMzY3 +v0UzBoTBwnxcN4cWOjtDXxY3NTbDq6DmyeghssAprha0aRXxvQlqepb2ZV+t5FR2h0Y23w9XkEAd +tUJeTtyApV9Xsmnh59Cs4EYluCs78+hs00aP5jbqZcd5Wegg+4DaO2kzGsr/Ief77765vRv4jEPa +UQ9iuPeuzuCz//H67erDz6fvz1dXdIz+T/nqa/nvwA59ckfS0xoWQVnMxUwCuMSlbIKywUsZBeVk +F7MKlKEWMwtSahN2QYptwDBQAF3MMsRSC5kG6eFytkEKbcI4sNhi1oELtpx5+OrNRuzDV282YiAg +Zy9nIWRoGzIRgvybshGU8zdhJKTgZqwE9QQbMRPY4xuxEyi4AUOhxTZgKVBwI6YCBTdiK6LuYAPG +QptczlpouU2YCz1glrAXqrdZzmBADP7UozKK0SuZrTqqG9dWyY/bdIZ2ITYaHHNvuIxM6eq729Pr +n86XB8zIgSQI7+jTYIW6MmYG5yL0dF4doU5ovPR1Rc8qWbmWoIDJpJcN/57QYMW36esTDWzAXk91 +nqjhHyZobZl12VqOoBr5ALr3jErQrqVqSnV6T/Wk1oqsudSZIu9VfF3knY/VdP07STOhCM4OnsgU +dV07OUjd6Tp4cjCspkQXhq2hYu1K6hIA046vGd+aacinKb3O3sY6+ipiF/pmYhf4p2qz3mqX8iH1 +E5PmpZ+WovOi7GdngkizXEJtgEto2QqPASdN29CZvlxhF1poa8dsumvhuquAIj2ARw== + + + bkEYHXxC4bM89QiVc1s4oRKWezBopRAGA69had0Iy4ZXwTfg7Er48IVAp1FhFGXkcAglJsC0LDtE +SJWe1jwISmCZOhfoWcDjC/MmrIIqMklyTw6kjwGO10AXesFyAQxN8GDo6UgLdR7JmND6IOeUghoy +JyD/0HFyJYWD0pOGP06orGlqVQg2cjgoKNRUx8ZKiRPCVCjbx5aJOOxNkfpH7NJjIg7i5IDjsjzY +daT8iKMv0nwQQzlHZfa6f5vqGFTBdrpmUl/6rujEVKu+vxyVDatsUHFespFzWlb8E6psDtMs9ROd +JqlfDJ2jbMHYK7YdO9qvKZ1XPJnwuO5pvD1ylKs0LycHxeB1hOh0sApf6WbqmoH0IJBBV4g6xaS7 +xXRIxXTcHcr0qFOkt/0EFqmOfpaLhDv9UigmC5L261VM1rSYrnsxRY4ix51iDW4Va1CwmCJqsQad +izVYX6zZHMWaPVSs2WrFcEfG7g02bjf72fZu8oUseqQqpqSiSHiVEZRiDd3J6NJJ8qoRUINz3MNh +qNLPq7at48EXRWaRROGpoJ2sOeZGrRY61TqH6YfOYbTk6Pc61a0noxmr1RVhY13zgPVHO9/lr2I/ +shpSQ307qRd5b/Rl3udYQ+rUST8D8IEqOYeyFfUs717EmclL67xMWhj0QikR3tm272lqux/NdMi2 +O8DH87RmOqeTvmZpBgto22w0RT8Za7BBMaX/u6FpvElm8clQBTaZENq7hrNGVchoaimjD+dfQJNF ++urNdCnRMY5HWP4pBqgAOMIUtUSOm1uDd2o0HqInJIsJFqswNZmPtBWy18Xw/RQHsjaLvNE1mNCP +oxgOZLrts8kphnNXxMlb+3oNZnVLlSFgv6SD3q0bx9oRr52cbu6uM4mqClPrpDuEUqakMNPG4AAE +9bbpMGCQshOJ1ZQ20ng6h1aICyyVjhk17MobY00n3xgedmpR1QOjsRZB46qLO4HHpuoALVC5wTkI +N1XqEj31MJ3CooGCxjNcskWgbAxIpPW2jG6rgcJt54yJaFL8oBsQ+1egg1CiKb+P/hV9Bw3CpiCs +Q8lZU5iD6Vnj861qtsg/qdEdPxCdcXKQXtJSjUAvEpWyZiB2rBQMUk2NXjc1JwepOzqBDfqFWaXG +NU0zmKTK21YDfbgYQv2gmo8KbC6ZEiaspQpt+IDaqf4DKFxdW9Z5PUVaxKy5Yk2vulnKOt9NUzbG +Ys1UdBOVzVj3Wgu4BBvPvzYHxiPDo8Fq1kOkLNL8Zbhb5MjbJifrHse7LXDysIXEBud8oIXECBMi +RQwdns1U9IKbsoFO0EGDDs2xh5M1w1vByoAoiCDWSGdkPoLIiurH/sMVDjbpbM0SjerV1xRtzWEL +hW2wLXa/MERHZxu3ejS3VSlAb+hgy0oDRnMjyWNGjp7SRB3YkNYo6R5RGzVojOiNGkdGFEeLj2gO +gBOqI8BN6A7J9FLKQzeSMe0hbR9THwFO8Z/AMQWi0WBMg6jdH289HkFjOvTVmzWUCPr6ya6HNn5C +jaBrn9AjeA1NKJKejx1NouZ7QpXonzShS1R2TygTF25NL9dRJz3Ix/RJNczTaVpHo1SpPKZSCp2u +0zpKleFpRqsylM6oVYb9xRD9pxQr30yTI779/EpTwdPVH2/Pz68/KclQSFmGhEnxHQTh/oHBQf6w +rjj40nkmCGDspyYZaoPTCPIyGhqFFNEr3IWgPn01LC/winVaCPSptBraH5CdQCS/qo7BmHWWZYiP +mmSoRqaV+F62sPHqzClcGHeqdcZwkwtFcCnHkNFAdqtGC4OP1Gnb+mGOIQLOYmDE6Ju6tQxPI6Wh +BSOGn3vB5phBJcTOh6bWVBGGnp0wOrYa8+PkH8anqQcbQBWNekLwq1KTDDVIjIFsAMHpFvA1LJP4 +G1xKMhTU51nPAZbWVAGVCzHbRaMOs87Z5GjmqpI+fIbxRtrPZqX9pqlAMJrJABDKHj0eWnYYJseY +dwNZU2BxMkYdQ0PF8DTr4ImpCW8cFk3ob916tcwEWIlqhMFGP0WDcGZiRJeYCP0m0kSHTo98AECr +xqoBzyPhADDPuhBzDNXwFgVy2hiLExraPsoyuO455RgKjdpW4stYuuiLxyaKvI3Yj6LviPa06Lsa +R0MEr0ob55pDLvIxc1aKflri1BX53MX5LfoJjitQZEvAVSryZYorWXRLGde66BY7IUSRYUTCmqJH +m4hYRY9ZEfv0R7ARZ5vKxIxEITp6Vq4JERFtQnUc1tpwwnVTxoQAMTIQ/XWrbADcVjYOM+4r7j3N +O9BtPtme6pQ/3MNFvom50QdfkRZEqxjj20gwbFqNyscMQ8Y77ZWQFb+KZCea8uo8wVAiTIlwpS8S +ZSs60gbscG0T8aWyml6oMS6l0gmtYlkdo/M8EiwRF403ETvrNqYXgv9NxOFK06+0zNAUCXaeXyjE +BEMy9cF0ENShuYFiHWiIAbJ9Q6TpKf8OeoP+kkjF/hLj27QHSNMxcBtTmHHgNdmtOs1Mn18oTh3m +VpP8EIDJr9tu8i0pi0/JHWgr5yo23SpSoetiqoYa+zbPLVTrRtZAj3bwTd0mf+fKO6V6aeoV83Q3 +tRmlBAK7VU5KnW5OIrnRZC5Cz8OAJDcVv0lEGxupHewo3Udp18XDoN+YGtDceJ/vXu1DOmVMiMdO +lTaVpm7pKIUjnR1SE82QR+wkvVmlTaDbgsZ3rHSDZkC3ggaYBzJhJG1No+d5Hc/3NpUJQAvSSKOH +JHNcKBVtVwnHlNSSc1c89JEeqyd3RrHDKqPmGaE3QkaUlAfFadtEtiQoSpdBx+1LuspL+3XTMSXs +oNP4L3is6xiMTm+oZY9xlJ6zy7yKnIYqTpVnHhxXkrzpXOrRWHJqW5AYzrQmIxydrqPzd3w+T4/w +8Sk/ZgOGnIJVbBwwE2NuY8qQjHmWMVMz5XsSeU7UORHnRHWn7NWYAxuzaIp9LqKj1eRCxmsOKBIF +2oF9Ygy75EKRpJDklCE+kyIp30mCRKIVExooHU5kLVK1RPYS1UuUsSeMiXgm2pmI64j6xsfjMYM9 +x5LcBlVneNvQA6QSpKuZOgh+XO267EIWibGiJTk9FMEEWWtIl8G65tAGob0TW7KwlaFl5iD5WzF/ +hcyUWowhRuKH4LBvYF6WFYHrTgn/SzkVJ9mFKEGszWenOQGIJJqtya+KlGPsmPnsXJuSC4Za89lV +XT47F/PZxaPCMNZO89nF8H8E3ddZUoTWDXMM8flYE9ql1H+OOYasSpCWuatCzGjX5R10GgeokTDM +f+ViQruUv26YYgjPxzGdncu/yLPZ1TGbnV91jmfHMZ2dDrlhCryY6Svms9NkYF3GyBhhmmeza2I2 +O7uKCSDHyexaTTBkmPBSU481q1Q2JrNrY16zVUyLGqMtSpMyp9qUa8ytYi67LndaTBKp+W+YXa3z +yLLMZBdPG9uk7GEhJnp0MTjV+rrOIo+Zyc7FTHZtzGRnYia7YGIZpgXUVHFB+9KamMnOh1EmO86b +YiLjrNRZdZjKzvap7I4HqexK2yXb7Urm+U+1cuayq1dd+zFpWddB5rKzq2wMzGUXVv0ou1R2Mf66 +AYPNtGsa9ZunsmvaUS47P8plF9MLccWIZKsOoYhhXle8XnULnqGTNyGmsasUu3wYpbFrFREVlyLa +JUzKstiZLofd8TCHXRlWCfXZy6aNSezSOBrdULXX4GzSBU1i166yHRiDteMGHKSwixnsqlXawWkq ++z2eUosmMsAUdlVKaVz18eMdKckyDRFywrx2TAcVISRQZcqk3HY0rCdhicwlKpfoYCKDiVT2lDJR +00RM1yW203RDjeYBwPthymjXDFNGNylzXl1peH7Wh6bOdlbspGZL1djgOA5NqarpeDhUTbrqTTcX +eb6hOIFM3srRpW/GixCzXIZsnYrxUo7yRidxMMOFYoQsxRiZItlqM3wrxihZjHG2GCN1Mcb6YrQr +ium+KcZbqxhtvWK8NYvx3i2GW7uY7v1iQB4aPZWyVJhdumglMfAUOU7pog2pUJ0Cg+HcGqlUMaVj +elg3PakrxrRwkC4alo3jlC66p6jFiOIWGTEuxoS6yDA5Fc/TRac2Ei73HRmki65CP54iH1Acc5EN +mrNS9NMSp67I5y7Ob9FP8OA8bFy/TkW+UPm5WvUHf9EtdkSH/mwuRsf3qkOposepYaroNiJr7XwU +TW0Vi9Pdm5mim9hGlihad0XUCmQ9a3zIuJYiEe8i301xxxX5ltM+jbdtke3buLP7b+Le7zixjkBk +3No4S3RYdYSmmFCjjDXsSFb/VaJqHYfZkb6MDdVE0XXPqsZE0SknOFthouiE/0GRhCHkrueLY6Jo +vypGxLxI1HyfaWifaWifaWifaWifacjuMw3tMw2NkXSfaWifaWifaWifaWhbMg0hRDI59A5ceivY +WcDg16ZBdoOrHoaAT9UiMeCT8ghMJhplIaIVBRpLmU2t/4JBKuyGYFWxzYS3kEKCDdHirnd/tZUz +yR9EMU9OEabV7R24kWKW6eVxrvCWmwCLf+eqUTMYn2kGal1IY21M+5wCuvU2AITnuu4iJMt0+TAh +lXWMBCnj2hiKyIhIsUY1LZTb1UuBRkynZgysf4xMk5VIzgox2Nz3aU98SmVfxT7hc56fCGdJyfMr +9RELh/SLUyeemFaglbqi0sdEFGd0MMXWKs4OV0l9FEw0clehjAHXLl5TAFUCIRrEnSDqnNSWMUGu +ftUettGukAwM4bBt2hinHFob/aBa4yL99NyAMiaNL8Ky1sErb1zHyGhC6HDFKcy+kbmJKXR11yMx +Q6zYVJqhChbBMmal8LwOyWHbRJt8RT8TmRKvHhKw6em6MUJbTTwNb5ooNTRe3VVpgil5CUxtegg8 +FUS6JjpGkKW6xfYVOeBUnRpztOAlOTp2yMPQ6+u+zxXjzG0+sDqGbXeDr5N7ZJofaHxMvLAiTmFD +bbvrQQG0I048x8sYzpiKIQ2pJOHsySRwQVvCupdkB72vXQ+gXbVJt5qlb2JCgopcjExDVQ7QUECW +thKADJkWZ6KvEdMYA5A2KDRVqoe3NqRmApWKNCAA0EIrZmIebE0Z7bVrWcLoKqb4j4HtmtgiyxYd +1OSruqL0Rcl7PVbqWqFZ/quU/luvk3HqqWnp26JJ/k10JyO5qqP+vgPQ8Bs9QSIIKaKZvhkkHkke +UqJ/AkA0gTtVmax/JQ4WR/oWRxfz/ZMopXz8Z0z4r45LWcZ/o66Sa/JDnx0Ug6TpMem/b7IaRnmo +NeMQuuKS2bEOmhO9iR447Owo5zVHVEyGzezZJto8ldhj+gZzRbJibSI1+lWAIa1q+mVATu+mitNF +PFcyxgQYupqqj3dlvCvQVlH8DyE9K8F0zuUfKHUnRjVd/v8c67qLTIiqdDCm5jGmtWA6l1FW9Jjv +iV7yqljPLwFQD7aYXz0mX+9+qJtll3w9uwegVk1pdhFAvN6PzNbZwaAzMR07Omy1ww== + + + +V0Aqy7J/NlBxlqma1jsNFt9TKTO1OqNSc3JyhjNfF9HcuUbXWRZxki6lUcQdGni8GzyhO9TpEcs +S3eidBjfZew/i7cCcPKH1wIAxY26rHcXBZQlycPZQQ9y6XxDLpAKngU4xEvdCXp7w6FyRKopKz1D +2NvEyHR8U4AO3a+mnNRDObTK6C8xjcOXdYTZWuPwkTwHOz7YsmS/hSPHjSA/XB3UjeZYGX8ocCTY +SV8enc2s8ujeKk1t4ATqsiq7MI41kRtThjKDLmMpo8i1nKlUGWoTtlKb3ISx1JKbsJZRjF3MXEax +bQP2EiU3YjA1JmIDFlNDLDZhMqlQ2IjNZGDIckYzBnAuZzUxxg2ZTaSXWs5uIpR0A4bzqzcbsZyQ +qDdgOhlXtJztZIzSUsZTCm3AemqppcwnO7iQ/aSubhkDimCrDVhQrPEGTCgwajkbCuxdyIgyK9oG +rCgVR5swoyQGG7GjJEAbMaQxQHwZS6okdilTqhR9E7ZUT5FNGFMNhduENdXzeQPmVNOTbcKeapOb +MKgxveZyFlWzDixnUpVfWs6marlNGNWRorDtIv+/g61KM1WmoV+pOU2DkWqNRWus3pkYeK5bp0S0 +4+OkqyS1BTgrhEai78oEwYNZPZLVD7fkHakcDsaiOSCRy0/9HZWHsukavUgWsjkHdnj16HclrvHF +vqO7g8P+U63qcEDHm/DpcvAaE69QFfZEd00wlYNzLVLKChKD9muQNhscf9uE/rOjs9k1Ht1fo29l +4oUW5dXez6qvWdmoXl6ytswzscHq0ga3fH2l2CYr/ACCk9U2GWN9xbQNpcm4byFqyoRH/hx5IM2Q +ibddzkvkEo53loYYD9zSFdOmC9bA7bRWnWcj4bVqPAFAc5MKj1frDaWUUJTia7RGfwUcw9KzWwdJ +SElvqwG97S9rG1zQmdFtUvVqQN7lFxlGgrAcADAQHcIGVp/BzXX0JqwbXkEp35ro5U2GmYKJi5YQ +iHmT+d5ITm4QNBFF1fqQ+VBk0C1iXYD/2CHoENJIB+3k8FNuvvTV0dnc+o7uq6+y6ps5qPT+vbcG +6TRSfynaaSrhxYjHbbQU9UgdliOfZqdZjH6cpOUIyGLLUfABAtGpCZBhDPqJqz7hVmAwubKUVDc0 +kSglpQQDnqqkH/NwpKigEqgSM2kA8FUT4/lacMAYJlJyqL8VuGgZEhNS8BkjlzImNUyGJV1KmRqi +WNAzNWR8AllN1/NHbcyifdbfSDm8kDLUqwGbFarVUFNYQhdAN0utllmd7GGUQYUyIyoG0hQGqL5g +zEaNlL9JbvUqEjI3x2SyN6IO0kjV1q3uUegnKEgHYZ4pdAVBMRFPBUdwPDcQFN34W+xjZFLqv0Ve ++bn1Ht1br+waTT48qPghhdoE+7IcVwvwT0stxkAtthQHU2MLsVDZ+6V4GEstw0Sd2aW4+BCZIJWu +NSW9M3SHBVWE7yA0b65OztOISqmTXhBYxjCWFvKzOj5aEv9aDgETA2vhwovTIOkS++uF62SSoPYL +aEBpkp1pNe0FdQVMda3hhyFGV0DrETS+UUUXcI2MroDQGsxqMqQNN2MN73buA5lJusqLQNhy4LIf +HHzdmc6Iefqr8ae2bPWL/ltuxVm1Ht1XK+IROSGDWh/Yh9PlVeDSBVZ5e/ESp8YWLrIWW7zMa/Ec +WZtk69+bt+mz5ZH58Mv53W81KFQTb353gDBoIWyUY72Q4JaScItw6y65zOn87Ny2RhihzEmD1LA8 +0YVSNrJwDhrRKF/bGvEiBuYTVTeVdeM7ANl3sh8JwkyTFqdGgrBW4dhSrfLMNOix3WOcEsziXtEt +U/N4rwENu3tCPP2WQf5QlFBz7xjvmiBWdfjgmFpNVa2xPdR4Vd0zY/55e3H3RTOqoRm2oRF5VuO4 +OGMnPQTaM8tW9Mb3Rr9IraZnlS3Qr+4LP6rBD9s4nowVc+Ao+Nls/B0k9l4KGV/34xVOUN9346+R +96H0HaQe1VCP2oC3q0L68XeQ2PtUZxpdarUff+pXgrhRDW7UxvFkrBh/Me7cVQaK/S/QGbDzaYDF +dA4KdKfK0KQYz2Mxbl6D80bzUIyH0VWcxllMp6LrYPfNeDqL8YwfT0fO6SAeDmYjQdIwiJlNNhlE +zcFcKGqG7BM/qsMPWtEjG5BsIhIkjSBV2o0xtptNQ+pa/0kzqqMZtHI8GW/0jEYQEO0lUJR4kZ+u +mKax9KqiSZkRcZeH3kRBoVDzhDLhsSyjVxtXB8FwcOu5OlkoTLi9lpeTdzXhDh8DRXyIN1gUDawZ +bdCAnZospbysXdBkw64cPjLHhulhBdppEE1l40Md3wD/LG6dKsEbnvDJxkR9XT0uvkY76TcRV42A +Lit9GKqAbShMOTTEHiopeva2piYeD6f0GNQn6/wVfJFM0LGn8ZRkL03DUjVvZEAMHjMwouKGxkDT +Mjmri4J0yRD0rHfHB1nvTw50bHUHycadTYgUyibr5CCfx1RD19N8IBhYPHZhJ2+ZQ03wi3zwFSbK +0rkXSStsPJyQRwbpPsBaUaoGrlMzHQElg1F91ZU61pTM0WBkHTcNIsssLaAV7g5wqx5QI2FEs+oL +NZpMLwZf0Bsg2lWYyLmFNCYogQRFzMeu5ugO0GhKl1TmOBur8GkuaE7vIGc5sw/IjqMDRA+B5Eal +y2SOjuPZjHusNOKvhvbBaTo72fMaU0QQ7nvwKtTgsEd2mQzkkR+irdVrKwEh0DDTZleX6QLhUoMJ +Qsctz8TB/VdeeD9c59TX1EGyBjtY16+uptT38fjOUlzGfZe6HN3cXPJWF/fX07u789vr31+f/nh5 +/sePF2/PP+ilLra/+qX76N/vb27v/v7r+3jvi+CTrK2HZqxUtto71YT/7m/np5d/Pr27vfi3fDeo +pP3+8uLs/Puz08uL65/+eHvx9v89/zVWN23xb8KMfri7PUX3+3YXc7EfLy/P71bF6uj07Jd/nd6+ +1XyIC2+RMYy3r2LCZYuoUj7Ti32VQPHJp9BBnFExWW216goWw88L4+MvMFfxJ3dP9tGwhq6chmCt +2MqgJ4MvU+eP+3HMv7xkBf+FEpmKZLKEauKGq2nqXDkr4VBA0S49QLtbiVgXakhF7We/skQna0VN +cMyShgGvNFMns0p1k5SmaJXepTL6yrpucrrExPqyyMoU+jEXt1/avr0i70hc1m5RV+n6AnVBISbp +r5jhmL/5X/8UW/Or2BhFwyp+ET+IXPlKJYD4In2pRUHmY4e7+rtGYi+OD7rubBjXxaqu4q+uCQXb +zsKNn5cpR+oqDjnvTLTXsr+X3e9+2OldEeuMP/Fp974rEr896/p3ORKpa98FY/xHjMfoRN3VT8xK +op4jumCMGcFTvDfDMJJFfUL0Bi8Ao+lbASlzAm/d8jEXNh9S+fSjL8Jm4uNx6kR81rtfTP/BqLq+ +KQY4pk6cHIy7mKoplHVN40wHJxJZeFqZeU7zukb8RQ4WvrLp7mmweDYlkOeHNsbHt21XtntO6nQG +y5h0yYk+pW/7QmaVWijYnlEgZd14fyEbHzQdx67T/YCmTLgIkeaZHbwtSYgqV625OzXeB1VGVzFm +3vPM9rCKb6jJqgzXLVimU/NUpRX9B66KuTAfKlo5vdry6GzjVo8Wt4o7pWqkKe41b+spwMPZwmUD +gSZ8q45c/b5J/pFp52gy5bl7JymI4+7JHufun6473Q7iJaMz9xCtbf0uyh4f20d6s17Z05oqTlQk +mKYjmA9usTR9cZOpl+qsbZZ8bdqu70u2WiStJiU/f3i7pfGc3D9swSkzhtLy73sCu5642tUQEIkI ++AEf6BusVxE4ejkcRo+ehklUIH4aGmfK7hfszMN3LNy0XeG8bigYEw3NepL3KHb8QRcWWDx4+RuI +DfwbkbnwXlpjefUx07pSPM13LazbjeZGzEgMYzIPmVN2XQk4sNi2zSnLzDaO5rYBVg8JAjM68qk3 +S/6j4/U/Drn1wsRrNM2h9uHqoOFN0fRnrppQY6MnkKGTdLrGalDu3hPCOi5aHUrkOYxHhEi00N0/ +dESA8ahi7mH6HPavgqkr9cEVcl2px/poBT20Oe1jhV28dHZ4TCxs+WiDlmE2rRCImx0V4OWFOEDq +LkXCF3m1wY+ybMjD16GxFbl66XcFiOlTRgp/X4OZZ+Curp3xlXx+1YGgAPRNFW8v4U3Qhks7KpEY +bDkG9QU0ZFD7XB3oHdBdQX0PRaKhpmJSYi3oIbH6N7y6VQZc/3b1u+9F9L3+afWbo6Nvzs4+Xv3t +5o4ybIbVk6NTT4Q1PdfA7q7v/Td979eUS0R4TU9/lz+vfveXm7u/nZ/d3L4VzP9PdkQthxXvGYHu +0QcD7xc7keuPv/nTH+Ne+fu7m9srfRVHKZv77c2P52+++VP7Rjrx/d2vl+dv+qb1q4Wzlh0e4SFD +1+fTcTy5UuLbm39tcEHDl6mOcMyA64KvWqrsbFV6Xu1j4I1UhylR9szAaVcpBS4fCjU0NzV55qAe +E3vdxF43sXW6iaaOLHJMEjGQvj4702zJyOV8cUWlX/o15JkrdRaMPDPLfn6WGdyJM3AkSkyzb3Dm +PcQ0uwbJFM09HC3CAE0Y81zYGvcVqYI6ewzZ5lmtHM1uBQI4jQCfj3Fewy7X6nUScyvTiBQTVibY +SQ4zMGrGK4A12GIdqCvJBmIcaQR1sRS4hrus0xW+w348xn83MkVCgFfKfhvmTHyA/abnnKPPg1US +3nOxIaBtzjdCbKsR8w2/d5wQDxdtHO/fPtu4zaPFbeKYcvbzM90upTVC4hvYtq8ykCy1Lk8GKiPI +d1eMdSCIVXqhTAfKl790TbqsXsQpl38GI2+8NayHodEHYNUUFodwMh1VOt36XvN240rvELZd+UY/ +zvvTtQPfxCEoH10TL76Xj4wdfJXN1BTUNbkG9LC0EdGk/BRpY9K1qwGw6wnjcCezNIB2Y9OgOTsG +rpkrhm2OZ2tNpz5NlClAI0zV+qBhsNI7iJB1/STSzKJVyc755pVIM3+4ud1bWPcW1r0Us5di9hbW +vYV1b2HdW1j3Fta9hXVvYd1NC+vEnnp1MDWeFmtMrGsMsc9qYzV6M8e9NlZwvfaxsg6RYmW1yMQ6 +afhoecNPZWEt1phYc3tqscbeeq+NtVhnZJ2aJnPT5bTIetjTm1nXdZ4ZoTIz65rBrCv4ebQTVcD9 +lWZva31S7cTJ+bu7va11b2vdayn2Woq9rXVva31CWysu92EWo6uDUq8A1IyDIo8Ymo4SLFlbT8iK +xQjfMSgZW7OCa0B99Vn7n9u4ahB4h1DY1iqB7o2VLdoMaudkcqGhbRUBbLix+8GiDc1LI+PqkjaP +FreJY8l7YZo/M7td8k5HaJRo8nSWuJBgyXR2ksGSKROwagLDPYeNWwtKBs+sYA4q7wUlY1sGSp1V +LGIQbjnoZf9Bunkw9ZX2vLIlmYxbrMz7lN5noL4DyE3buHWQwVxVa+Zv3P562INixQ== + + + 55Aqpp2jVDEdRQ/sB5sVXwvsx6EW1m5283bzj9ZN1aaiSpFoAdKa1YL1AXaoJxBRNpRQXo399G8X +P/28F1H2IspeRNmLKHsRZS+iPKWIopeHJjkihsjYKpc2OlAmk6SC60C9BEJ/T6cCSHqdyyfDxp9R +SAk6oPuEFKTXqdwjRRuraUxmSymTRsceoI83+lRSCt0r49pFIYUmHm/T2vF1LhUopOdSE6SXL+i7 +N4JgySu/DpQJNKngEFTeB+o528kwOjtFqjEXTiIoL24OUw6WCWww0moydkJ6zpulnE+zN2x8LejJ +BZPJgFNU2XjIGTQXQqbD7mG5yJEPPWt1KLpM5v5eoeSLlwb+8X4vCuxFgb0osBcF9qLAXhR4OlEg +seHk9mufAsMIQsZi28dtwRevB2lUh9eLs31pwypGgZn8syQorIHEBk+mfXjKoDDe3jPgsWVgyp0j +sfqamLDwSMkGiT+bB2LCHmtyGhL2SJM4nuwgZf3nEQe6QB1Nk9EJBA0OEQHoAiburYck7nwdpBpD +GPkXl13FgXWgrlwGSpUXiRfNQCkALQNNR9PJBYNXKRgsRSRlbfcNTUFdLFM3H1NIV4x159VMe3AP +8EEBQTDPG2F7PklAGA/yagDMQramA81g3dBiaNcAsnZkMVpsOOVr+vMpXlaF5rPAfaxM7Gqkr3TY +bp7CgrFoOV6TzHJ3JwMRErX67vb0+qfzjULAYP3FrR7wkY4HUSPsEDLhJ1ARqsNgvV0hia7HhVgJ +UCJdanooutepgqKrIbXSQY4PCGoy0MkBy9keMqk5b3fcqVg4lU3V9w1OhnrveWdCrdwONGZ1x+2U +VfXggVcIp1EbXDdqmkqODB4KfIdbksrQ6KVDwpGYw2DKasT3IG2+Xh74cGl4PCN9+iiWYmHbR5u0 +DcZI/vPjI9A2pQ881Vpb4vA0jfc+qdUcfoD6eL24QIQyvcsPhyLzEHWo4BI3JKtped9KAslyu4gL +nlfvJkApS5t+p3epdCrcIUN8zpHBdfwQS1U9qBhXW+RtFpMedRV0nc7wvmt5MtguhVK2IRJPmO+b +rJuBlyAmWIFQRPYkCMoyHUCCaEfjA97ynqlUQ1dBtjNGvezbHRca15o3OenQpM+TwR5Px3+feNm7 +FI+6zSN0MrjJ8POeSoH+8SR/7CdzOuGTZTnOu5MN4Ks3a0YlwHGNk0aHfRx2cTyg8YjHa3ecdSPv +xWT+7gXmYnDl1sv46eSpa14dhazxJfKVy172SKmghon4Nr08mXx+L1FubZRAg2v9qgtb8FL1mtg2 +ZnVvTMVraQwuQmpynr5sw6FDoI8w9bidaiCDyrog34RGQz1YNlR6dbeQw8UNHm3SYBkvhRzR309U +jwmbxlvNXUySL0vmDmNs0Ul6m16eTD5PBKyuFV4dMkv+VQLEZyEhVVbr8OM1gKePSZh0WPZJ1sXu +g65LkyJfQChC5dfv98914ZFysfYTuVhhJ5zBZTuJga1cwBPIOd+EQ9xq53qA8q7xoehep7IFCqdq +8SAHVPakzGr6cFJN3si4B1nvsm4fDwbxKGsqNJA3jUfW1AkDVj8cdYdbPnBXs2mEX6ltGHJ4NSyp +tUZg4bbNYYyvbwTIO7YeLhxAniaxeMtaPtqkZSF2h03zudnSbr0rGnfA3jXBxWe0Hddcr/VNgMgA +WV1zfZeKsmS3zpWaXQbPkQ/tPi7GVRV5O8WkF8Wwl8VwEMejQXW8Z4/aascaAiLXqRds1OxVE9tt +D43hxeUJot2KD3jLS0tTcS3dY/qgT7GtwbfjmvJmJp0YdnI4huOD8Zge4y7zXnWsZT+IvGe8Kzbv +GhjJ7vEkf+xnbDSl4+5mXUg9lvNpChnUMmll2Klhn8YjGIxvtEZ9013LxQzIgHOsshsjsz147w/9 +l2GU3bBxt3fDTLUAMWlRBAnihMPWtRlI+DPeroWYSurOQq0XFTGU1rdxp+IOHdy4Sb63216wpiAk +ttti7JfnnfGDbVepgBPvAdfL6/ve6fPxwWAnApTt9AQqJvUW61ovJn0sJsMopkMtOB242zNNR4EZ +82U2r9OZRuKMdVdCrlmSiCPDRRHgBstCKWeDhdFyC5dmMJq0OLrfN1keFSI3WCAU3GyJRhutjhxa +O5bN2kO9ispqQLuw6Dixg+kgVaMZiGvomKTq9AxGJv0u+FLmIxUutHSzSvV3gLODRiiBNxlIWNwW +93B3tSQAeaX4OzWfSqfujQdwPBnS/BRQMGa26H2J0G8dpKxFaO0aTgpqM9zqqKmg4kMRTOkPkUtA +OLtS7xvvXRc+i2TWTajRLChXmFCarzqQzJmPE+oaOP0kAI/I+Du9S6VT4W764vMxMALX3XUQEU6c +YoTWkJ5Re/rdNZ0KF+P6i76BKCxmqBJHVuPKdmaxiyBBuFS93hOXAGy7Sf3Sd6l0KpwhRmxYxh7g +7Jcgwaa50RrSM+fNdpOqL1PhYlx/0TcwAd3PYwz8IfqGr7KncctaqR0NTO+mHw7ersaT008cvp7M +62TmJyNBsckUTCapH8j4Ft2q6c7+6D4hkrTeoCh8aInjgajtA2577IjpSfcZvrJtDukKfp5EF7Ba +UUKIdwu7slOCqxJGSJFpalXgNBAaRiojOSOoyXq4MHgua5qoMlrY4tEmLZbMEfLZU1vQtqfLgFvF +yZJVev9z1BrxdXp7Mi2Q6Y2a+KJ1dWVVc9RoaYWcADf6uscF1oKeRX/UN9qUkQWKHc2RuP+U3Sv9 +ANYV/wK0SV1ii/bzqpH+cPrPm9uLu6g9+o8kY3zOe7NxmTmubS4c/KoqmBuEL6x5m2gCQe6pQTcB +gEEN2ctaKD8cWMGqVafMUEPVZFu94hN3khqvzpxtcLxSW7NZWX0+PkiQFjls1LEDGY7gZSmbCreB +Sll5wcujaaFT9MNtq6lv6nZqwfp2H7GWpulq4TWzqRG9ZrbrxYneUWt4HXjsacHBEBIHw3t50Ww2 +YoqmNS8djdNScOZc1c9cwenFYZL1t0l38XZfSbvCq8HBkrfrVtk4keGnhooA90XH6z3TV6gIqWP6 +hRov5nHncxlfyMjSKiNhj7c9KMCWEiq2yD3t2C786gwS7x2TtBudEJk2fOBsSB/QcTQcBkHNkOrQ +W1Z4NakbT0iCHKt/YCjb/KuablAE8HpYAejNxk5abTWZoZzmxqg/chlqekEieSkgmD7Opx72ddD8 +h3ikRbmu1J300MAqLLPtrYxKZaJGJnWFI6wyOcKBPWZ3+YmPn+BKcK9JjlgL2GbcaatorS3p1bgR +9etARSi7arqu0gMUmr9+NByxN/mQOSu+nxXMW9Nk8zZZ5uPpyt/v3vrEHiMV5oD3vMpft/K4CpjX +vVpvVQTZrute/8f5Jd3mSXa/fQLSi51tG70mqaavlIHEEVr6cQbk4z3US5ZBsUr+H2qSDFiMSxTj +SnFjcKVoA4TFjdcJ0D2nMn2RVG2qNbXJfrAbGWT08aS2UXPj7kx7/A5u3CX2e/p7pXlVkesPRF42 +prBdFDmJOtrpDFSMPy/GNcr3dC6R7wNON5KNCCg6CL8mjeuLpaqLru7UcMHOFOwNYJYL06wmJVJt +WbWTtse9mw6A+xhBD7VTCumdq+NtVyUnQbYaPJZ8yqcfhBZQf8NzI4PwfuiYiTHBcL17QAZp1CPH +KGlnS99Hqo7qWqfDHpbeqeeHiF+WP9TsLytcN0ZfCTMeeHm8g5XjmFfaOxI8qJCEc1Z/SBW44TDA ++XFQSdTMGgefbvj0pDxySFnh6AJfWOSwtmqi1oUw3Vfk6MDsWxxutoecHRieTaYHiZzXapJShOA1 +sA5jDfUc0+E6eCu6hhDyFjJtJSM+2rjgHSDgeJCJOTvoQLIyVV0jdi2OU2gitXgGzJOlwwCECKc3 +hDdl2+LqehFM68Bb03FOBt4QXko9nA5TmooXsuPubtl+vCI8MPQEKiBvDS8ed96zHfjON9oO3OkP +4XDJSRT5pUIhnC08d0CYcQ+6fFr1T7LXK4zl+CADheAb9cuVuWmGgEBJ/VDVg7IROLGy+DRIS79q +i/C+ENHQxwXHVeZYLpkg8kqGGU3pF4fb2YHCLorwvbR56BtbUwvUtHrBuZzcAMgEwu0Y09AGj3aA +o67kKOsGzg5E0Zooigl1PSDESWchBaGFWhgvuJxWmorVtXLSTzYjNin4gkBOCT2trVG3eLAGtgOB +m2qqlkkCHWygPQALUwZdogiSWQA6dZXIvvTKrKSWIkToiqAlXMATxCOcFkRb6+geu1Y6SOxIV0Hq +6WQ4Z9SlP8sd8bQvbyGrcHN1HlkF8ySsgvNRuy8oYEKAWklOS2G6NYNyK3uBUTAR5Eo1eZ0AZe8F +gaMta5ucxSnVq8+kI3vMRhU1bRnIMMN0sOIXrQKqw8oG7j2R+dsmh7EmBucA0K4BaCkApF7Ev/Q1 +TwZ8kjKdl1rW1qzsSg5ANTREwEkHaPpuBrCc8CmbgrpiBWsOYQ0EXuTMX6RXtehEgWFvaFNJXco+ +G/XyYbXN59skcrzWwuJXciTj4PDY45ovuTV1u4Ub57vbH1fF6ujyI7ePSVpUM3dbUFYi50l6fNVB +nD1UUhn04h46PJMgFxmo4OdV/3kHSDXiNE0gQUk9+mMFFhFGBrFD6dfZwfhd18NYeNzjsxmGHed+ +Gz9AIITxcBfBvwhOJbPicOBWbiXnN4J6oC+B7pdtWaWX4FG90CNe9EFpFLd9NNJbJ7JYb97ZRE03 +s0+fX18XtZgGYuxwGu1j0zjVk8vgh06fxMUBHgqZaq0LjO8R7g5J3xJIhLFDcjpI19wCSxJAmLaW +rCtQqYMJ5TMaMMtqIJLhrEg/iEimpCqHAJas+5L9c1d7AqUepBpSF/v+H2djmWVZhH5Tw268p/lX +2Ganl8wIl92siR8Q+m3kH8W99MBLZoQ0wcvXBDkEhGmaRkUH2zhaDn0JllWarQK2TO9JQauiAYWT +M1V2Wd3qWcr7EyArNrBauvgs81IFTpXUDTVTD4hzd3yQQGSDqmaVaoAQ1qS5469jXpzR1k3oQAVL +V33pDpC1kMFiN7p6tJup+0llh+c6oprlfRI5wQIeyBRWOSRrK8KgINKLA2IdDrwyx5N+HSvJqvp3 +iUSlwuk5n64OFHuR6ig0sMTVqi2konCzaOpJq1cZMHVt3PV+WBpsPRr1dF4mk8dy00nO10DHxcjr +bNSTKZkMYGw8bPpLFSDP1D2lgTBnadB2NFjC3byHCdsNzSy9dRnU0mmd4WUNqSMB9LATsp99Y+ED +bbNaEiA1dXbQgSB4Nj7FVqMahG4bCp6prQ5C+UQ71H/VdbqvajK2OUeg8Q8Rb4hjkdToz4K3G7TO +1updrre0dIQG0x2y6TaQLhnZJdJt6dM13xHmVdgC22ysi/4pGnl+mAyVBKjejGxw9lEjUmmosno6 +QGzs7CCDdTd9dBW1SaWRWosA1UTFLnUfdb3uKhqP7dOnW84Zof6VTnh60ESotQjBwQ== + + + QmNd6vWUccY1pBZmfmF7KsZPdKAWYViNWotTiiBVnUHL5ELVAXSmIE5l38Q4+L6WCEgtnR10IJHS +q+izq7UguW3pspYSQCeXvem/if3taxmN6dNnFuoQBH5oLpH4gFwiUHcgzq2EmqfKcbmFK1GpF/No +kHUHwaa1wlw0JEiKcdS0+Rg/3wGgC3PRfSyCZJ+2wagSNNaTgWJj1FJ1ME/tx6qrSoSfqnWhby4B +oB2NXUqgfhixlvG4Pn1yK5ExcbUdJzc9gCUBE8FLmYQpR1M5ocj4P9nRjcbBlfSOuuohbYwZEVJP +hWvBkLkABFOFUwfATGMyXA8yEK8hZ6daOkBsiKvTQaAwXHWVIF0Cr0ZKDSUAND+xMwmUD4C1jEf0 +GSgx/Pt8osXxodBEZxD1efGVc7nEUQjCeQtShzOm1vD5DoYYTfoVQqndllQXG+WhA32+XA8RbGyF +6lIT1n1loK4CL9jV1EFSe9jsCSYkzNnAxYg1QfVLStO1lyBnB32vuq+6nnc1Tcb3OSgwztA6UWB9 +AAV26gfHW2M8mP97Dz0nAmptqGAxZUuhJoGgx7dqx6yrljpKnhwwPyJENz1jG6sOP0HUhdP3VXSA +rpmzgx5mcMuRW6VaVN+i/gZsqAOcHaS+dKCu/7GSyXg+AzLLHJp4zMXfSKUS5EB1OOaMhYd5Towp +NI6IBjKW+RXVAZ6GLDkxQ1tTr0xNuoVNoY1BwThphAwp+4lphaRwjDs76YfZGdRtk/zj4dgklFQA +TSIRjCA/g0uGchwwATfMsKaJcdpo+LDQJ2ONpKDuA1mKGryqYcoRr05xsMTgniHeeivCvAt1A80W +gwRpkPTMuMLLpsgKHDpV4kdvLZoPG35AxfExD3/XqrEwbWuGnhEeYCEZztvZvaFDlbrDlS3dvTCL +zOVRtjDGyaw5pwGWdfoDIN0wYYyA62dtkfKnicFFzLpTx/Q7TYhkOFjdBwx6lQOvgjCn+8y1lUYW +eUENmUlYV+SXiIbVmrJNHXD1n4Ojd+MPy7rV9I+YiOR94cu2ndcsXOewVqFSq4RI6HZtyRoI5LwG +u7dBKcO8HlNNRP9lITDC9QffPpZC6DG/rkXL8jTXKzeNrIGf6SeXNEzr1EoPIuDDeiaasXpaIVTP +wWxWwI2xxdakl07rgxr6NYCZOvOKivoSm6uG1wmVHUJ0caofS0W1xicBhFOgTm45DpZHPLdqBsQz +PGbOQJaMui6JBAW7Ki/fVl6ZliEYtGsygbhJggQWJw9TC8gRRxa5giM4Nn6IHlXoLcmHUILIMKZk +nRY7vo7sCYZI8hGUhalRGgAkdTg+IHUAV2ijU0xiiKBxkSLTmduMXiAEsW6Jkm1b8y/lhBJ2TSGg +TY2LIKB4MnJgVSgVItmAPY0MWE0KTfthTS8v5OWwrY2sZmvIanp8JbsMdENk7QqCHE0yQb6RfebX +lDcNfGbaBgoNA0IJue5IuZdGjTcyzTCWzGsbFKBCtiSaNEEgkB5lTVHZ9Tx8KUu33ivxmNvtKIvX +qvOjF+mnkY+NVulpvEWBwY19eSrS5NoM2U6NjcbpVrXVlSZZwsHsGhW7eJzT89HQUU4TqMANhHSG +3nKHoTV0SmDCJX6liR4dczPoBZO8065w5H+plrDQZtBO2KgoaWp1YYQLZoDOCY7fFH2E/ITQqGld +kJOepfS1RwfBPcOQzktesb2E70ky9xlYouCE4wa/Q9kLmQOVdaEvAZ7Re7D2wIVjmB3ltNWUgtQh +WC0JdrOp1IFgMHMbE5EKVjegpWt4sBnj1D1Qto4MvITWHGOVxg4pEqiA6g+jbg1GT7orlC4EzbJh +VBEgUkWgjsUgtUJNd3050i2My9QJegcn1nZNaSvzVqrbjnFy1IpU3tB/HsYvVyeptWznNXxEd7US +fvPyfeX1ZpJxOYQ1+BZBFaWHHMRi8/orrHYJEyuZlpahap9MNxYvzJNcTSKyUmnKl6Yawxzuahin +qgyeLMzVV4dWGdImOMoptexBimBU5WI/2Va1Z9Ql6xYzlTqIqUsVOFZWXKmUA4D3WqiFyE3ZztJf +h1mcAm8OUqMa/OXo9UWDdq2f0GlQda1R6Rk0y2FBliIoD6vaEGmNTmKQCnkB1hnJGj0KBOGgfzb8 +ytAD0dOzV8upJcfHAHQlhxRR6HmmapPOvNLoHZ7TedxUbgmOLLHeBh7/RqjgqWcAJng15IHniU8m +pAJT4FRpIZhMQm08Hepl2o2qaT3IsKyWbOVW2IlWs8QIMaiZeUfmKkAQ1TvFRqVxE9AhPfhCKPHL +aa5KMKOuYeyVlQGtK7qu4SM9m6yrG/XWMs6uLSo7M+WZQd+Ud5nXZb0Ft61Agzgtxnyy+LJ0dZ6G ++XA1vAlflozAS0w9Eq268NAxqSJjgSNfdrCGniJWQs937np4uUOMUfMjyYucxrwlNwjlqPis1q2o +b4FcDDcnoRc1FLbUR3mveirqRDQyw9GXr9Wd6vQN/DZ9SRdRMCcmGrAY6+zgLVnqlo0a5+YwOvwB +FolgozgESFsZ/cppjEiJMBN6/yptOqZTrKq45GwtaxkFVEXw/AcVqStPZcxw4jZmNjx9Hg81Fv0Q +dhkhRsgEbmvht1WRJpMg7TofeiVHi+RaQjAsvL3gVQBnNVDpyqnGAHyU9VHoxwH5A43RHuc0RDHf +xijcSeHageODrrSqYbpofJ10HC2okoOsj3sq5rR6pKYiWxmKe7Y0Zl1BIQAQelUtRwXb0dzuCoUQ +LIUSkSaAsi3Dp3May1blKQgEvJnLxr0wnwH6zoQAhckuiIHXbRM91Ksqai2rJsZuVeqrK9Jjq84U +Fq5T9Bmv1DkWMBz9HhlurH5EDTTcmPm1flK3UeXQ4rzGZmRKQ9NEX1aYtlpSA8TmUyctn0YHbIbb +BM0ZpzxMqTfWgUDQwV0OG1I1Cwf5Nvqii5QNt1kQjJaGb6RGYA5mdUK2VNM4AmBgPIbZoiSXQXfB +Mhp74fENSkaqM57EjfkK5gos1ccTf1oq6VtQIh9qjyRu4PJDjG2LVh3blGDR67iZY651rzmbNLgg +iNx9SC1MEN5NqrQqm0BPDB1B6wTqyvqe0o4mIjgrNlXTHDLk6ojGghr2RdVtkHuf1/YR7sh0TVOG +qNzw7r6iYFVbegoIysh7lVFm9hvFpSC1G5GP/WTuYuEaPQHxYBoJ4axeWkYZaDbayMND/sAWhwIb +p6vsE3oUOx/3sWCJ8ARq0MMJbumgxBARjRvkRsS1HBQf5BnKUQTWqE1VGAFETeBCEVUDkMGH2kHa +0SgSH6MlICfibwutl2MwEw9+Wl9cBf6lYXp1uH/VjNlsDciBnIE0bBjaP0BvXIyHEgJYg4K4UhON +l4fUaNJhz9KNXONlGD9L9a5QMxAtGlOgAIM6VujdeL425jDaqmR4Y8V8l9JmoyE2BuyaFXZG+HpE +DLTBRqW06jNgFSwZauBFilrhvk/r1fHNkfyTN2cIJnOdubpWooGIRag0V/D8E+IrR/60sHAEsMVB +yrJC+3VhjjiPHmYQmMq8HL/zmsWe9+A4EHNimkCt8rRgDRExJSCAeulobncp/wTMk5QFgfPNp3MZ +y1fmSRQaLULz5yaOfyJi0bmP5/eXtHTNiaEOdOzqQPCwoi27jXFicrAxn0b6qYr1NnpQEFSwtO9K +98+pAZUZIqxJ6oFYDQIgYPgq+58MX9JQtwjp+xyLTwZx7z5u1JgdkyeKVMWsFyFOiEhHMqdyqEUR +TBhqi0BAO8mqSAELNiYvByI9yLN7IyokPsTWwUnLHncZQwyNj9bBkcU/ULoR2uSboBH1w7SKC5s+ +Wto0S1M6U9tJ3H7/GOrDpq6pU0TKgDNQCd6oGyCTXhO0BJ14JfRihNo4Q8cs/Hoiz/8s/4Z7mvwb +Gp7SZ3AtnyhABdkxRgEqCvqEABUc/PcFqGTv9gEqOxugso9NSVnvni025RMT3+1DVPYhKrsUolLb +B0NU4OozilAB6JEAFfOMASpmToAK3ZoG8Sn5wD5TeEoZbwhND12IipkfomKzqJGrHJaHqJhJiEq1 +Goeo2PIzhahoRYMQlWo1CVExkxAVO6hoPLbPFKJi45Snhy5E5VNjVJpxjEoziVFh2PUgRkUE2GGM +im0mMSoCGsSooJZhjEozjVFpXiBGxUa36PTQxahUnzNIRb2iBzEqny1CZRifwpZ2PzxFxco8PIWQ +PDyF6WC2JTyFncnDU9IAuvCUfESfKTwlZhAp0kMXnlI9S3gKxzwMT2kn4SntmvCUdhyeorO3reEp +rUnUVx9SeEptPmN4CvKtb0t4CnO/v4rwFKLMw+EpzYzwFDsjPCVyDV14ihmFp9TtZwpQQdKoTw1Q +qYMe9FsaodJozAYv7XgwQqXq4j3smrIpQqV5OEIlzGv2oQiVQckHI1Qe7vE+QuWlI1QaZdR2I0JF +yiwPUGncowEq4FX2ASr7AJV9gMpmASoyNcMAFWg58wCVsq2nASrlhgEq8K4aBKiY5QEq7ShApZ0E +qLTh4QCVchKgYrc8QKXpAlRCjNng5aDw1NfNtDhGZVA+RamEtVEqIcmqtZnbeIpTMSlORe9lnRZl +qEqYH6oyKs5glSbFqnwGD9J9rMr9sSrYHZ8lVsXHKwW7WJWo0+tjVdwmsSrkG0axKracxKo0k1gV +tyZWpZ3EqoRZsSrm8ViVwTy+QKyKjQoPo+l614eM2JBCRkIeq8IyMfDj/lAV2PM0VMXmoSpVDFUp +m5nt9qEqdQxVsevDaxCqgrtQ1oSqPNLjGKlS7yNVnjFSpTTDWBXzaKyKH8Wq+FGsSjWJVbGjWJX6 +8VgVXpzyNKEqzeORKonj2pZIFaOBKj4FqvhJyIhpU8iIaQeBKl3gx7RoDFMRxiqGqUQKwTAVIf8a +prKm4Lo2+zAVF8NU/LqCDFMpQwpTaZpBmMoDnR0HqeCg2gepfM4glaZ9wiAVqC+HQSr0U3w0SMVM +glSqOUEqbXihIJXBJG5DkIrpwjWcmR2k4pv1pRcGqTza9v1BKpOis4JU7uv3PkjlWYNUoEgcBanA +2WQYpGIeD1IpR0EqVbs8SAXXjTx1kIpfHKTiB0Eq+Xy9QJCKyIVNDFKJ0SJVCtwIj8aoyLrGqI/S +TAunGBXZejFGpTZdjErZxhgVP6/VLkTFxBCVdcUYoBLWxqc83NUUn9Ls41O2LT5F/Xjui0/J3n5K +fErzUHxK9nIfn7LL8Sn3oVKKT1mITPfHp9yHTjE+ZSFC7eNT1san/O377wdhKZ/30iG9IxWBBHBm +p0tZD/KHCTWc94yDbbmqUN7Dwz8BznjNJu716z9phnV0z7EZtdAQxKsFmTZD60Dzg2YSIN5ZiK50 +36S+dpWMx4PttR6rfvjzyT/+9K1g1G/OLm7PZIHtm9+uvuYFOCVWXV5mCx1iFgJKT0YNWvCR0VQB +BJ0AJIQjkNMRjqdRq5WDyYg2S7qutLVe+9jCByl6eGKYuECwjBqcqoSJSLgpOuajgQ== + + + 0vAQquugZrEIKhDCg6wBJ/SbMfSYpi9MxWsFccOqwCsX8DgcwvFkUPCS57LULhso9dlN/hX8VsGt +wDcilCpKel4djTehUX1UhOCOvNDETissocnJgU238Ta4PZCtNqair3arGSNH3TmedPDkOa4mw+K4 +lTe4xNfwL/2EAK7UpW27Ll36/vz09uxnvVNaI4k+O+WAkh1h0JAvkPLpiqAABTiVrlR0wMgKJywT +7R7Qt3nLeHXubaA/1GLys8KVZXIsX3JHiNxDF+fWl+qNQd8fEaaqulIAXLNWcB3AHQp0/DcNGue3 +siiXkMq88xUpSFMbSksy8JKaFLbJq8dw7SXc4ptIl6xey0AxSM6uS8YiUALCBWsQzHCzbxmfmVER +9hlQyPaQG+9sOjuXxNJJ9El7fxzKx/gflo7S+IzFQ9TIZFkUuHhhcO5PlgbADRZHik2XR4CbLJAU +my4RgIsXac1soSYcGP/gxHNFvnrTr8nStYCKzVLTG2DX5lrAmxEaAIcyJUKT8CX0bSVNBd6GRoHw +ngRHCvG6CfHDUZX3At+RvKSO/yO/lCZEYeVJLptvIWMbIlQNGxgtt+ppn0DGq0YUAAsshLKk5TEA +jUeDm0dtOLTkUGHmdJgEXhxreMJThMUt7VDUUilYGT0ZmKULZxB0uLjlFgZhuAPB5RNdo8LFJRdQ +eJVVdd1BPJKYWi6D8PeBF2PWvLDTizioGlKnWerSZbW8JtcwMaZpXdAIKE8HFd4i3jAUTkbDPQKs +bEvEiIlwoApjmRTkvRzPWwrAS3ByUvLd1QEi+KicTSDBnsr7mDlfRC5um0aV1rjPNOhdrpgd5hwV +3lvjdGreF6rXP2pOQ9iZNS895krLOb17Fa67LSMjZTf5GttbL/qFtw4cOERsctCCHB/AZ0cDPhxc +5MCBUPXcRIf0tBDpmdee81eCwLoGfbx6kxuGLpd6Ga6lT84xzG7qX9ggyqdmgph4DY5RpbXsn+iy +XB1WdclClr56VK1pjKq6IEJj5ZGLlvdh6v3rJJC8XT3edQJQ4/R6zdIEZVkdzYuChN7ZfknGq3Y8 +WceH74uEc6gsibHtTI3Gc9/z3rTCnPkGZ0CDe95bIAscEHBZ7hbyQ3ent6tiJSLfr7+NDFG8w3Um +WSuBGrKtVUKCkxQPT94lfXIQ93xQJ9CSIJgYbcVbfkUEqCKLXtJfDDjrDSl1SRm4bms8rHm/pppp +Y5MO9d2dE2CN+GrZ1qbGqQ1lqYc7HTQ4ddVC+zXWellcS6xOw0X8Db0kIpGFM6cds6wH4WExuFr2 +J20JDlpKqJRd6RDRAiWJEFYoEKt4+XMljEADQilCoYjwMbYawhH03VcH8OtvNRzUUaN9IqCmoo9g +fzt1E3kQgEqdPsvrsmi0q1tY4TmjDrdHwTfDshwDlGA2hpGD18nC688wzA5OPV7JgOra4QMaeHOs +r6npxnpAFONCIMq0qfQK3sn7YlJJMW2omPammHa5WDOwYs34izXTVKyZzWy2T/pocPhFIDLhCnV7 +w4iYhv4zbE8T8crZWbNag2E4hjGfcN+kNKCWlxKXdJ62SlTHLwdlh/WuaTnr2uhhduS3hnwPxvjV +mzVNCY0c9EboVt5VeRwPBbX2I1XOevxFMaqkGDeybr4H3T05GIZ2+yYyeiB0cuoLcgghQRB2G7NI +yLaDirama0vCNIbNtJFZOIEUpfE4uDUe1h2Mw3r6LToN+aOhpwnRHgkz1zGV3IwDoV7DOq6aoXNJ +gUT0gVH5NUPcfee0f3IAJz6QoYJe9qXuIWgRaPo8gZxXa0xy/wEC3KiK6atBsJ2GfPaNUY+JK6qy +PjF6CSEHsiCMRDqZztTJA8puDFkYLd5NWDQ13L7U6RhOhRO6idDkBsTcg1ED++eRuKRmvGZoqqgl +RuSpYAHYXGWQf0A0rTAszH4MvzVErKwrWgdVqATbRCPQ0dnGrR7NbRVWpUbtWDX0WkO19n28SDrp +y9XZzdX7m4/Xb1cffj59f766unmbH/MPq8XX4LUqukeYrcARblME3QS7VfM+wm8QiwmGi/g4wfGv +3qzBcm7lHs8pMk8wXaBTXCdpmGB71NuP8F2nYYTxa2bx5H59/IKly9Tj5nk40ydmIPs8UR8/lX1s +7+cf3UP8I/151/CPVeQfR+8f5R9dxz+2GzOQRk2mLQRBMHWmsSaQgfSyl9bk56GayafkDfEhRsK3 +BmmhWgdRNM/P85my8ww4SEsXlyEHaelhNOAgbeSWlnOQjjwbHLDu5SD95+Ag/SwOMu/NEg5yNP5i +zTQVa2ZzHgfZtgs5SPcQB+kWcJDDlpdykA8xjMOa5zGM7lGG0W3CMI678gDDWJdjhhEbaSOGEZEs +T8Uw1q15mGFUe3zbNLMYx2F1yxhHO2Ec8xn7zIwjXHWVhWuXMo7Yl2Th/Cy+0fR84waNHs1s9MXZ +xiF2L2Ybl+P4UrZxiJr3sI1rsf1B9nFc7XL20a5hH4eY/5zs43Jm7uLsl3Pwc387f7sJMwd7WqMe +5LBCI3mnQor4N4HTcxltgvymezn9Kv06Oxi/GxfOKo4/4WceAK8RhgZTBnDCGQ2DFyQoywBvTeHx +yrrklwGhTidI7mO8YwaT4FXnVgmP0DURfxz3I5/FFBpDMmdbj0Aa8C5lBatSSdcGUIMJnauBVely +6fRQkBsksiG5tiY/magW66oSCgM9pgy787tyJv/hrMg4LccXgoZJUbuYEjfCKqqZG6uyDgmg/y8S +VB9L9XvVeWeqAOR/KWEG1RA9pkZwTMvVGpoADH0jDJcIgViYeFPjgGa6g7IiX4t4nNSE/tVkj1nb +sV+jbpY01gz7Wky+KVKdfX5HGxE5pZHU/3KAVs007zUDh9JLvnMwE5WUo+lgDM8/A3ueg78EbwnU +O0Px7JiVEZBGc+gQYhiTb/XZ6HPjukdONbPE1swbBVLEOTMeiE6nY8cUVAzQjj3OR8G/DOezKx3z +cRz7JgpCZ+N58fCkqYn5gWk7ozV5ycQh0+3CqfvqzXTy7oU9OKXo7sOTOsku2WYc5Z5uzqKbiKJU +NoLnNPKCMbC4pGxrzBp7jA+aKJZkMz0U5KuELDrlzepGebNRulvvSpr8W5G2G/4woWImLWFFlUgK +kwa0KBEIj7iUEqFRCFfak8092dyTzc9PNpuBII4tAZ5I5I/Q0o0ogbJbrsDkQ3ODDlIf5it+nABn +IigbjR6OEKQHhNAALxwEjjBrDoOSwyGzQEIC1MRnBZ1tQgumn3kEUEe16gUPPmp8kiPVIgD/p4NK +DgYgkXX8NlbvkYMhuW0NEztUmnzOwQPWIZMTrZ6aFVhzMLkYLxknApWkc2QwVw8FKoC0OplrcKRF +ZXHPJKKe4N22hjV1XkQ96saQThzBkBVIglH5GMkGGfxr9drLYOvonyIieI0EdrxKCimg4SO0pqj1 +laauEzkceQv0opsNGz2a2agsLmzxkN4tQzoXBCSswcseuAgzIdguxs2v3izFTqU8c/FTx7IUQ6Pb +3kIcHe1+M2CaBmuQzlpNOqmnYqPOjQ2oIbwgoW/FnNCz0eCIL2ueRJCN5EBv6RBJjZWV3943AxC+ +8kiU1NTMSNQi6YlUXUcAsuE65lRwMZcuNMlWb4QNmtm8PexSlzLpE9OsMHQ5aMpG5mahhxVAVGmf +ABSjsPGVo9a2VR86uv0pW8b81TXVyiY9R3aOl4rKBka0NPmKFu5pvNIXk+5KEO6GsdM8G0ujGZqZ +lOzkgE6wAbxH8GopQXQbzwi6B56QF4FrIXmRRnkRzYMLCM4gQCyju9EfG4CHdUn3vDF7kn7dqyb0 +Nf1ypLKWCd/rIEvDkKq2XEeigGE1z1R47jABikNgHG/SQoyuqt2cpi4LyHvEJJA/MCeoCM26KQMM +gWuLVjUuaUYSNiGX3DFHZxu3ejS3VYfsoEj4ZAIvAxvQKDNMKruG+UhbRn2XF24aUIHJtsEmn2wc +AJdvHWFMNtk8X71Zs30IHG8gAc7fQsrLLNlELDHaRgIbbyTyX8OtBNB4MxE22k6AzdxQ/WqPLRuN +vY+kjhk6JiGmM2cdb0zgcwX/Vr0tgM+wngayeEwZgw3BSSsZI19XSE0HFTCX/6kY+RHkQSpSyq6C +gGiYGQ+ursiouU4HR8QokcNA9ikywzo50BjaHuiRzct7GgOx0iBPatNq5lkkkUGkDy9tB+6Mi9WW +lkEpViGAqGQOxk1aO5rTWmCOT+ZvsUjIs4xsTNFCYYsQg3dzLEWNJxVVBnvCLdsTw7qQCaRS/QhT +jniYiHDlZkMP+afB+Xsw3FlieGWhHoAGpNYcxKCfJW0xE4WJHFlMOUo/vBiLUBnwdIhBoDGGzDHT +rjFa3rUyyv+fvffOTyVJGgD3AtwBGQQIV74KJCE8SEIW5C1OEsIK0z09f+xvL7DH2WvsNfYam6a8 +L+BNq1/zzTdvUFVWZGZkZLiMyMCSEjCoJGKnPEosMfuU5cWLySio//KY+kh4JwS6jBIwt6QY7W/s +lcVMFl1SCC98FyWli16hkBXwJakUPndX07xrItdTjfe1XhkRawiWWeUhUL3RBLSgLf3m/gyIY2Ft +Awpd1kFAtwYnXnYBwypIeFFtVfWIxTdPwcukUVEt8St48TVugP8GOrr+ETyj1n0VM8CNGTqH1xVr +R1jVD9lyNyXxbiKTJAzm8ScJFGWDEkWNskJOm6d5HEIEi66hux/ENxwybWk8PqTBgRGTSsI+/Bae +L8MUE4dvwXZkgMWnTdf32G/Oe78UuoMW6J/KXprDm4fRoahCADF0yy+Pr0BHcbpV9TMGX1oc42BK +PI+rohAUDMZUllx8kvcZHoHV03+HQKM2Imjlgdh/3ocGaUsDP59s9Zi21nOS+O4JdPUEgXIB7egV +ZjUzjmTDI6eIllohdMcvgQxCLF5LrF46zXnulII5UTQpeNJ0jJQMnxlpWfPUEzUHXk3oOfC6EEWD +z/Q0DR7paQY8MtK1+qFryoZxFAbahqhYiLoxDvVjNVK4Vu6xpKpEm0o8QYsV3hINI/EGcK/L3Yl7 +m1HwiS6x50h80T66RkozXd64kXl5/+m+ihngxrR9M+iKAvXoqj7tX7Y+WVipHbrg4B0yFMzDhOqy +1UbGV2YSBLrTF96rp9scJCHgfShQyJtHU+rNjPNL0TUF9t+yHK5HoNrNC/Sc894zmQRCD6qwypZW +rREn7lj9EyQu8NKIT6BfJYmLm9HAovIrKwZFPcNhYfHDCEg9RA7H6+mmEdPP04Cc/GqJDV2UKTiu +OLycAlYg0NIauv+Voxy/hsweFm3UUpvHrnMLdQ3T84EIcY7EW0TdppZTt0m9us0JBr2FE3TcHQkY +FXfnBIPeonok6S2qr2IGuDFD55LeQupVLdKduh2DjkOBRAHx+OosEmY/2ukvMWAmMiy6bgHpBDSn +XVGoftDQEqRppcqH6mvoNWQox68FCrtGtVdkee07t0jfUGcneI7X6t3KinES4+PxXw== + + + WEcW61b6JTUB3QgEL1FHygSDIlBJ5FbN+zT6BTRwqz6NDgINU42WIhERL8h/a4hIULE8dEOO9Chm +gBszdJ4XzQX1GCX1Vz0RBJwV8DQ1+HDgdTS8EJaVSQxY7kkbEsMOYwJfRk0zJkyDV7EcHhruOm7H +wHpotOPX8KI08eRxib5zC/UNM9lh3SIPp55aAhR1W5kEsVrrhQiR+qonQ/VD14SoGZxEilC9XIgY +JX1fS46StuqWIHXhYLyVyxFDJQ32tGBiTwsGC0QwWCASDlT2tPqRaE9zeuuDU4FWHmjtaVsm//Pl +kh7Tv8Ke1rJ0bKCCcbmwpy2/dLannTq1tqetvlzCniZN7GktLWueeqJmkedo6Vm0p71StGhPk0Z7 +mjTa01q6Vj90TdkaHqW3pz1Tt2RPkyb2NOlkTy+o2LLwz9ez0fBi0h3OusOPWAw/Ruqu+oXvbAzf +CPjNRX8O/j1vfnVaMx++YNKfm8ynn/7TxrDx0ZkA1bjdmYTt3/nxy3yj3++CnTr+7LbElvXRqJ8A +KvZ4Fvef/9EAv41NgRoAQKjbs7btTZoiEKV+Y+bYnkbtr2B6h7YtAmHyAW/1gbEtngjJGr8AC3o+ +vGjMPjWg85+NSWukTBK0QiBMmtY7/5n5C90/ugDh9kDrCERj3JkAtlmbTUa9DhhYHK85IBLNiq+Y +ciwQAyhEjRT4J8QS/H+CwP9Ff4khyHajXahzhfxQ1xT8D+dHRS5wt+Qv6ZbWTZkG/5EmrPrPyvvF +qIa7AXXL+llJYiZ/dacyjmGnJOoQ8EI/jZFM/oJ+eR2SeT/vFcmr3AFmexKMS9rpiBgTfkmrwW1A +cz+V8Ev/gZhK+BG6yDglazaLos5iRHUNh9CNiyLMh/PLBqPiblYogrcm+DllXDDihuQ5GEME8yPR +bUwwLpNH/A+aDWjUhNtRe6aCJH4jXcU89SVOhqM/h+gPILORXA/7E2dgGv6oL5EF8vyPjvQ2kRdz +DEvdPpgZbA9opDv04wb4KdZ0E2KTKFAWEjfdabfZRwCNEGqzRqu3FASvY8g1pt2W8jleZExS/vP3 +92kHCDTS+nvxg6N+f44uwxhN4o3xGCANLw74qCOiL6QB6q8CVPqL7+9g7UDreneGwFGon/75RGwM +Bmh3S3foaDjtwtRO+S67Qnc67jf+wn/ClM8EhiSuGpjIlQ8QG0+QqJKWABP/0FUOPCNwmpw+QUrl +g7l9AqqERtIwAfAua+5eBA2MDkYSq/GJQufdv+f3+UOq4YQxMvENJfg5Ro40q6hvz4/m79/zAYw2 +JjOTFcv1O8O2hwW3w2cCAVNw5c6JqkxO+dxi8DbzyI+G7Xl35mYOaigr3wGQ/laETvn6metpp/hH +Z3jebiOShF0oSPZ024tYYEKV6mVaawLZ2LAuC/JQoYv3YJAeDYvXUpxFuQllHeUB/uY0+PtMyZco +/qfTmsMhoBfoWzN5Bu9v49ZC7TcTam75x1oYrYXRyoWRmQTCJ0MkPARBh48cD4scwloT+LbntQT6 +GyUQ9bdLIH4tgX4zCXS15C3MFkaVCVWuTaq1FPvfm1Se7zJfC7R/+JQ8CTRhLdB+Q4HGCbSAsuso +8L8s9AEmBZbGd7+yDLxLAd4QIHqwWXx3DQHzRmDBOWs/IbV2FK6l2o+QakkBX6XHUDy6Y5KFlW5Q +FArMoU6uPYX/crGWXIu130ysrT2Fa2n00zyFhChe1sLm3yxsYPjkWtishc1a2KyFza8SNm5yD9ZC +5383JUPSw98gduifLXb+dUIDOt4onoBlc9ENeei8iOQZhtHE5/E8xTK4pjRBI08cD6P52J91lLQg +x/5d+C0p4EvHCVgGBN01iTkvy5oU7/LIeH8fHuyJXTFrdvXj2NVS1ePW7OrHsCvxzgSCFmh47IO4 +FbxylGPMru9Y8ys3/Ipd86sfx6/W6tXvwa8k9Qre708q6hXNo6J/a361CL/64cHx/zp+9VN8iP9c +VqMwdcsf+D+o7JInvrTmJg7c5IcHOv/ruMnaWvsRLGnVcUwkDs8FrCwpoNp2LJ9kCFwSlBCSK0h5 +/Jfyr3Vc65oDuuOA6/T39dHuD5MGSQanIVE8Dy8WRDfxJinW5HLK9ZnvP3xKnoTaOqr1dxNqP8VJ +8A/bNWtp9Gvz3ymBphlUBhbeJy8AxQqVwWPWoa7/7vx3jvjZEuhfJz/WbqF/Jut1MgRobAeQPCw5 +Bkt7UCR2CjEUw61DkBbkXutA/d+N/63157X+/AP1Z5pK8jC33h/jOSBzYVBDnCcY2qS68Fp//jfp +z9RaAv1mEmh9LPEj+MlakP3iYwlUKoZkGAZdHUPCMjPIHiEFfnl75Hehwt9nSp6k2g/PRFtLtbVd +tRZH/xxxZHPbhhgnTgnrm3j/5ZbUD08nXMucH2NJra/iXQuun2NHgfdxhgHUjO0njqK49V0e/3L7 +6Yenmq5l2dp+Wouhf44YsrKf4hRHAAXLL90PwHIsza4NqX+5IfXDM/3WwmctfNbC5x8vfGBQBLDg +OdYvO/HYZHKd0fIvFz4/PE3zXyc6oA9OYHlCgMe8HCvwJIw/5QiCR743TuApVOyagFfqwCekUjyE +4YkfV2T4XxRSbFr8CccRcwKBo9HwtWAUwxDL+5x+HybsiWOtc/B+R57HsSzJcOhiMR7WSje7coaG +BdWTmC/iCusCKgK4Lpi01rv/fvbvdPZAkjizL8kwpAB/MQTLMjiphEwy3Do0+d8t2Pgfntq3FmyL +HagzNJGEQivJChyPfpACy0CtnmBoLMZ4gaFJ+IOEujylaPVrwbYWbD9dsHHiTaJ0kkuiG7QYgaQI +1ElcYEhyXeH2Xy7X1kmfv5tcW59vrMXRj3Kz4fMNhgZKNDpdZ6k4QRHAoopTZJJaW1b/7kMOfp30 +uZZAawm0lkC/UAIxHDzoIQWCTKJyCpwQJ5MCPKBLEmsB9PcKIPLvrxXIrzM01yJoLYLWIuiXiyCC +5HgaLh3FxxleIFHRRGJ9urQWQT88YXMtQNb1if4OtklTiG2ylCCg2FiGg/esoLp1MAyPWcdpLcZu +1jl1vxvDQrGpFE+j5G+GYKCeEYc54CgoSwrTQonhwAqGIo/HEVs/LCb1H7br1hrz/yI8i1tfsfWD +9ee/X5z98Oqea3G2vu7kH7T11jLtf3SJPYzMEhgWUDKMPWYJRoo4JukVXGP/u1Dh7zMlTzLth2ee +/ysl0jr57x/Jim2S/3iBZKFnCef+AaOCWNcPWZBh/dJsZVN2cwVh+vOjybAzma6K3eiAyizGdi0A +/7nqNADtQvKaT6224MrZrsjuXH/vkU/+Irf478udFsTPmqNoOcpk0vjLXxlNuv8dDWdgWz2FeMo/ +nj2F/1E60Xpz/ts3J5Y69UljOH0fTQarElEqgO7Ek4yfmfTlRWMGxjBEkoqQhNdg9Efn5vViJj3F +30w6732gbd9pHzaG7dGg+9+OWdN7+JDxJ46AnhUad4cXo+5wBp8lxWfD+SA/Gnc7qCOeUvdfUfUv +itTRrDHrvF4BydrAAyYJ+eW01ejDMXcmrQ7uQx4MelXtDjum4Aqdj0kHvyJ1wEqNFsC+WUcVdUek +7pXy2e9njLti22WA0KGabZdFZVvFtWvdwbgvc20v6jzW43EfCmD4HboxyUJrF40AMBNAgtZDPxoC +bc9f7o/+9LNA0KzFzFrM/OPEjELD9nKmMBmNa5+N9ujPeKNrLmDUoFwbQIizN/tDhBMizrMSfxyN +Gy34TH7Q7M8n5qa9ycUi+h/4P3cNr34ABdMfrf5EZOBozB+zv8b/YrZ90R32/LnOH53+v9iAZ/9X +BvwvwqToHQVq3eeq8KgB6Y0LfA1naEfxMgt4n85EpVBU9frdgcs993e4GBWuw7E0gY8cqSSv5kIw +l1709HI8wy7Hkn7OWc4vSQi0nMdad1kflSK9HtppjYlasY8TFLxqzE/SLNx0NMwX5tnV34mKGWJp +/t///uU/bUx7q2KfpQ5gnBDf7lgnKVuaV7YS6J+tkPxCSl/LwR+7laGNzqBdTFka6gsZQr/PxnCl +qWOrbe2cWAv4n6Id/0IrfTE5Dp0bfmmfLOkF0cByaUbKUrzdmPTUTobWdIKcIFSc5KQ2f3QmkicZ +I37c6CLPREzd6nM0+a/FOlAsA4MfKYHDwZB4BeBfvcURP9W5R+xcOhwwgvRenTXLVrHsR/C0Me/P +nu194N52FApFgpFHLFr1JIfuMOSFJLyyVJ6plwhYcyd5IHuUfC0O29nJDI12Cp+w8Mnr2Wh4MQGt +u8OPWAw/znXA/rlo9DuzWQdx2Iumm3GGHq/Ah0gJA5h8DqPFuvuvT//cd9HyhqfQ7Wd31hG/c0ZX +AxIgkHX6jpIMx9IwsjhJ8yRNa1wA4ndX5Zz/qtOWvkzSyaTmkuQkzVAwXUE9ROXL+04fOlrxxxzL +86TWzSDn7qg/Qucg4jcsTyQZXt0hSTMsxWi/JeVv8381pE8FgUZeDZ4nSHg7kxGteDnEL3P9uYRQ +GvwfKSA8EnSSMl0I9aenjQ+gDDbEr0me4jFSGTIpoHVhWfyD4DgBoY9nOczXlEA6nmN4EeQBDAAv +H9BJf+6AYY2LRtJ4uQUBXvGBXjEUjy54l67xhKHi6GJPhgSQRbAUzQOwlADA0pweLM8BzCYRWMB5 +tWvMsAAezE2RR6sBCx6VD5KEKViWZEkK3z5KMknNMiQ5eI02bIPnDsAiLMhg4WhJ8C+AS+jh0jzD +8hCcQCY5TR5YPCndasol8a0ocYoGKKMluCwcLhx+7oBNSnB5iqY0oxNYnmUoLVzoFEM0D/9PuTZV +gktB7NIIvbQIF0AlNIOD2OU4bUcYuQIvCjktVBKtGaB4FVSW4nUMQuCSGJcK4pkkgZNJReRSOJ9A +pDCGgEhIwsFyElhAuLqdIrBgE2lGS1GQCCBcicQojGUMl0VrJgDb54BnpI1Icyh9AcyLRvgTkiTF +4S2cpNHFaZAGJIHPw3QHERwaJANXipNWSuBpAQ2SBrsADg10zyM3JkUTtIATARmCx/kVMA9Q4NTQ +CIhJVtpVPMPRKP9CcYryLM9opkxKyy1PGe8HDBQwP2nGJCmDhYhEMwSMBGUkMjTFcioOC0fJ4Vvk +wQ/DKDm490mWl+ARAo+oBqwbwZsyM6BVwUmjGSAMQloDHbAiWAZTPRwnRUnbFNAeBQPzwTZlMPpN +mGScYeD+gQigwSqx6nGSNBynIIjwkuAnvnyIBGvLmI9TYqpkEqwOr6y9OE4OwGXQ9BlpmEmOJCgk +z2AFcIHGX9McgVAip8dIG4jGgMUNhPYPZE5gSBI6aY5GMiQJWDVhfuk/ozBlmKaDWJW4dwi40cHC +wSGy8pYEhIQgsizBmkJU2JzERlm8ZNKW5CWmTzLSlqRBv7hYUhxQN4t2NAEQgBca7Dtx+9BiHDaG +xAoAEpxyUoJDEoBBcJjpouBuIJtoHi84ZFlwlyIeqUajeBe0yIcoCY9JAzNOkkkGLw== + + + CkArr2XGskjCvB30LJ0oyBKJRqtDkRLP5AC7o9CMKQLRHVA6CFZDTbJk5nBOFPghy84kInQBbSBp +/gwNeI+AaJkDrB7+SAKeiYUyk0TdQfSwIhdicKUHCZ9QHMOsTLjHpT0JSyii9WAhf0ObiGcwM6Hg +spEyo4DLKIoOWi044R3FQHDCFRckqIAiGBKOBBA3Yg0EIGYOMxAOKRG0zCjFdaIwq8cwBThUtMs5 +iTQpVqBINGWCA7wYDjQpIBwQJCAkQS0kODg82AtDqZYJygmAAJZDu0jixDRLiklsQMES8wR4Hu1I +Gm8GTpw+gxmRXElDhMrBrU4i0SZQEtAkx6LdDNqxCDqf5NGgAU3QaBqSZKMlOS/KJLVkQ4JNZp/g +S7wecDMJHOZPHM9gIAJi7oxU24OSKIrUrhWkVKQ0yEoOA9gh4ulckgZanx/rO0lRP5HErrhJwb5S +EJqEM8folLDJAO2dwIoYvLkdjhHwFLRngW6O11kcoXxbO4EZM4aJsEkjfox3kiFRqzZ6n/mRIeC/ +6X4MoTETFhtYuS5NvxGBA4ilRrvjn4382BxxgqVtrUAx9arawNG3VyCZhVDZANI1N0UatAv8KECv +7x6w6UcQfKj2PW9MOlN/dvjRB2aVBgz+z6MK5rN/bPgEkQtcfMynoJl5kT2rn58V/YCHsv48BPof +n/6h9BnuTHkLwBi+QM+kDygOETb4HxVIs27kXsBW5ThSI1Z5QLlaQSsg8YK0FPGomca3N0jyhkZ6 +L5SygKlIsoHgCBKxB6BJCpS5sZwUGSQv8glBpa0BRoD0XqQGkSq4sn4L9DYkKFjAs7QjBpYvIZsc +BOZraOiS/s8gCYkEOGCvEmiGpygaA+IZxlzZYCVBIWC2C+W0WjWgoUyjSDRqsOSkvDjYHtEsKGAI +hrVBzyTVNMmjHigBSBYrlU9WxwVFNZWgUUl5qUm45Rp/ofiWiw+3vgisO0KhLytkHIP1UJ4EijMS +fxwHlHg0AKBLs0iqiJd76H+I6IcLS0GWKmu3PFBLcCYbQ9MElqYMgUU1sGuQNkLJ/xUNGKgmsxDR +rLSAHBgAWjcW2G6I74LlAswZcXkSW3O0NCb9DwyVR8KDR7QsQQX6OlKVWYrEG4EB1hYaExC3JNZR +5P+qNU/4L5TDksgEo0HryACVBhEaUCDA7kCqjSjvpUHpf4hgKSTekWMA/CvRLcfi+ygIHkl3GkhI +DpMJwAgjKkycWvXCehJLa1QvmgF0JiCFBexeZJSxJKs2hYB5I93bovshwuWxSod2Fi8JTAq6opAV +znN8EvtQSNyBwmTk/4pEQuA9ClUO8K+kHJNAK0DfCWwS+xIEoH1p9VhpZPofEl8hkPEPiZpSvBWs +gNsSDEVgjQvYb1qHQFLkUtr/lVwgSOlmKLTvKWnL3Xaa/vyoP4IicDQfy5sP1jIjsb+DYwRz64uS +bhWQjU8Np+Fo2fqkFNuGB5qYFq8cXlLFWpKUUV7SdCmxRJpIYdh6QHopr+e5LEVhDRyYdiyvcSZa +OodY1sY5lBSVMIEABEFp4QGTFfA2+ENtxWN4FJw3bRifpzgpZXAU2ge8rNlKdipgGQLOogU7Quvc +5LHKKRKt2mtFCkmFckkM8yInO60l37TirVa7sX1nY+zwRm8kl3e1O52pvfh2Ue7yAa0mptIYXG6b +4GRwuqMROPrdTWZCEvhV7a9Bc9SHYP4PX6gyGgCtMlTp9Mfgf3KNaa+DBg50xdZnGKqff4BRQc0z +dFWrwSbzPsCaP+a/6n58ztQPCqM/h+q/q513zfvrsfqvHNCO/2xM2upnpdFEfHQ+aYK/zyeN4Qfs +ujYDqqvq79x8NhsNATEZn1HqZ/VGU9sIPtC0wB1hPzaYfvujgz6A6yU/0HyAH9HgkehyB4Prtnod +OD7k85cGC2V8WMQ7WCk11q1XT6S2wqg1HwASKjRmDV/gNSH97U+hv1TnXPDvu9Pq2ajdMX255w/9 +Z9Afgtexxmw26TbnM5zkAppiqvtfgFgBfFWr1me3354A3KM2UmyN9Bb+M/tr3MFvQzvD6esfjcl0 +T5Xcr276RwOuPW4Ln08t2sF0cdxMHMlU89c/FDvD0bDjAjH9EaDwthvMSC2jf++8mt1hGwyUdDE3 +QBy1zuwMTcJ5furWK1r+JTFB2mLC1fy7jWa/44bwHVf1n7TRU3+43uqw6d9M0XB6rfl0Nhr8vZzs +19FhatqAcRBQ5oEt5pYcf/m+qMGba37MUH6HXTp9//MHS+O/eRtM+93WP50XxwRSCQ2zXF5XS/t3 +8104Fc5pKn+5mcpff/dUSI4WaKep/Nlto7B2x+mIDf8BU/rsIEvVxZykln/zpKToT6sJNUfA0h1A +8/p80gXWopupGb/5ASIf8braaD5pdXIwCHolbO8fbZARJm/VGJs1Jh+dGdADoMtgelRws/TGb/5m +VfbirEwxpdFk0LDaleopv3f7HdvGmsmqW//jzXPCiRO8o0Bod5a50vbvXX7HSXWHYJz9RsvdtNSt +fzjfRpftjBsAXMuVxqBt/zdv2q0S+j8XG3YArxJCRy1uJqlu/cMJczg69TQ1bfsfIG+dGe//zKTV +CqW/ezSj8aw76P4XZRb8lDEBK/nvHsKgM2u0G7PGsuNILjmOrbZ4/uFm16kao48fTzvt7nzgv+pM +R/25mFMig8kekaRfPl4Baz8f+0t9uG3hGd3FpANTfRV3L8eyNCvOJnuU9Dcms+aoMWn7W+homfQ3 +5VHL7AR1IQ3K3wWjaMw6oGEHuahtG/eGo1ZvNJ/5P/CZNVpUJacMjuC0M/30XzWmQAqKBKyaKf6C +pRhKsB405f9AJ1nu2soaBE1oxnE+n43BQO1HQqkgq6UbGEG37Z+K18e5GIWCZscVUU3Osa08OVKz +HogMJn90/PXOf2b+Yrs7azS7/e5MlMokI8M0ElO1MfyYNz46/ovRWFpCvVjjJby0x904biKBBCOb +6EhkgC4l0Dxq9LtT3aPpeCTuAFr2X4wb7ba8T7JH/ux8NpJXzEi2Sf+4MQa7YNodzPsNZRXldc/1 +O502tClvlM1KWuJXa+HkJ6NxdtJp4JRlgwwMKbF9JDrqJwjxzB/8oCnjLyIeRp+h/1M2uDhZuTfY +gcZ3IA5WWrV8Y/hHY1qT0aEmBML/LnMGsCn73WHHP0WJwlP7xmOJfkZ/dCZjeOA71a4yRJbIdeCg +L+cNSF3+Kr6ESc8gzMYxA5SJW/IKhWtaTtA6x/7owFsJ/c1GvzFsOUyy1e+OwdpBr/x/wN74ABQg +DjxEMnGwHCpG2sseleb9voTHm85kCoXpbGLoola69ech5PrInxUpxHxf6P8mtEAq9dOq/3ra8R8N +4AbLTlFQAWSVw7aeGOX2ShMxHKgGr3+USILnYRUs56/0ksu8KR4XvihC3nVmDRWdwwwNjHE80gf+ +2hiYPpMpQPes22r09WRl+YESa2KgL+M3AMf5Wk27f01ho6RQtflN2oE9Grb68zbQjweQYvQMzOyL +8ghe9w9z5gE7avY7LoaEp1scjGd/5Tv9/tSSMORP6oVb6NusqJyBdj2gRT5tjOuyQkO5aF0dtVQc +Vb/i+t0yGv9loG0dokRk+u9OL8xh6tqj5GOMSf8pTt429Ktucz3s/se0Y3Wj2+6wPfpzqqN2VYuu +Wm7qR5jU4K3W+ANuLZiAr0AYDSGl+DX82dU3frg8fkJcIMLTV6TZsjp9RInjczsp/BUtKiqePmLE +8TGevmIX+opb6Cte/MobCgUdHdlQhDlB6dAIvc1O9ES4+wQP0HyJ7b95IgiJngSP31HmuHf8jl7w +Owu6cvyO1a+bJeJNuY4i0Wvz5vuo3+5MJM8gfDoN68WurrHKXNNyh8J8DEYCjS9lLLnOJ6AqlX8G +N0UNRHrTCuc9U76ue6e2AVTvdZyz+J/xaDKDapBauqpU6xw6tFEp1wYFSeM0qnX6lcYM9A2FSx9O +b6rSdy3aHkH/6VFB3VL9ug7jDmCvZuNDIaCq4Wnf1kdj1Tv5PLjcHwHl86oznvensgDcg2/lyzp0 +E9Xf5aEoOLWbMtI5jLIXvCkOWyMTCxu8gWbc+VDRy9Tv0LUxCHdQcxAtKAUoMAVbXWXcpPKmBLSp +utEZDEECM+ukMxmaDQTo1rL6qR77oAnQizR2044AsU8xaRm2UNI/HCmGhr87RBr8aNqVunH2iFB+ +YBzaeEHU9gJqi9T5vGgoXKkNBbU1gpriSSVusBmS05ghas8Gbi3FUvsbQEvGrg6dS0HjhsAfwVQ3 +aFmgj5DJrv/IjVOoeFFziwPc2BoJxrbnotlWU5uPalzhZjbI0s4bN3eeuBbF+CtnHDvsRjkc3n/b +aSZuuu3OKHE6AppeByIVKI5gH3Yk3CYUx3eiNerD8gAAspFlq9tNZ/14G3eBiFoWCPbg4Wdie8VD +6OabcXsAXveHrgc1brsGjmP45C9I+bokdcPxeBJHwi7eh0H0rlrORqJ3ieV5+5YTxbARCNK+LY4b +0LF3zRrCtn+OxApv9s0+dc0MOP0aNQFOp92PYcPoNNQ3REvbFOMG7CCihiN4MuyiXWPa7M4GjbF9 +U9xmotsnZq1b/Um8NRrCq72gS85mqLClzLeb6OohPH/etPWkHQc2PLxDx2EAoOE7YE3StWFIFJu2 +QkLC6OUz9PoHPHAdxz9dtvvDemzjj0Ev3hlCHcPdDkIf4C2krKebb8CizeCFbeJY4hRrSvewKdjU +kDerApwshz4GW6Q7fB85NJuoLq5yaIo8pc3GZGqDXNSwCVUssJ9UHMJFY5lJuGg70fg/nFqrGQVn +2XzQmPSm2lG7aCyP2kVb1ahdtFaP2ozJa+c4n3aASoyUW5t9/D6cxdv98eR9NLTb7uNpHCpmgIdM +7cliGgc8Ezplh6CpSvgbWv5nHJ/oWRIS+GYtP9wwL9BO5F2Kf9kMTUo77A+3hjhpT6baHW8qgFAz +yRE9nVr33BrEJe96a/BXz4YNKg1H+B5mrQfX0DvmMrY9Qy1BZEHX8Vrcj3NMgT7f9j+FarfnF09h +/x+Ugw4Ex6USTmbSDrSBWkx3aCM6oXx1GjJsI6osoiRImrNBKNIV9icwlFUrdcRkCGiBgG+2/c2/ +/IVJ9w9017UdXwbfKyqWjXKhYcRWqoWJt9bQCB05upIZUMZrxmYqrZX1txaCkw9nQQnaiEJSVWBK +3wpVlZJgObazEbq40bgvBRWZEjdq0xpO7VAK2sy6fbWFbc4/p9K1mTZtEI91ko0TSQ6YDRmzXc2S +mLaZAtNZOhk1Z7d9zbGbWYtmF9pCtk2GnY+GcrJpKQCAYjq0b9MnW8h1bjD79ELis9HuTFRHkaat +tHKEN1MFATPXnw6aMvx+10ZJBg1G45aNYoQaTG2mjhq057YGu80OBp/bb2AsYubDliuGgFo3hsOR +ElcqhgZAJ0tWauhXXGWeowJIdXvkJNCdFhvcLqZeBMKqVV0W4Q72vLlQRBYSGDJOhA== + + + tqQMxZDq9+1bTXvdMTBzhjZCGzabgN04mXbg8CbuupXCDtyzeukL1dyshgN9FrLHTksFx6PmETAG +1DSgc37pV5SwdAwpiyVeZH1RKIlOKGjLwIC10XCqd9uBEfjP8SuVq0rtdm780TkF4r877neyWjQ5 +OnlUtRH8qluMV+DfgbMH83uFKfN5RScWwyBsv3MTk2H2HQX7u8CKFzo6hR1ejPpdSSqaGg/SQHEJ +iNJkNABI/HM06dUlycTYTO90NBy1PsFHHdUkT7pDd6avNGgcaAXd9sOZOAF32JWimLJAjjYbs2rj +r45kZsIro+yXBV7ugPMz0WlLtjn6w0WXKFbCakXtO0WfWvfqbXmuFOXQ3CAyn6rBbexlhWBBAORO +OWqDleq+dyX2xXlAmEIdLujfOlyHsZ00pEtrTHsXvRJcJaIJMy5HMqVUKIDWpH5PqrzX2i9dhUF6 +I5mq4ni1GazFZlQP2lTHch+bZW7qG1mKNdV6m3fOwSNi17NCrRZqqutAUftdquMNho9dMEGVMIPx +nIBG840xjursOogOBsKR/EDWyoLSIzqBOG0AKaGkU7jjJIXOFAyt4V6CSqwjO7EnXhNmt6Agktmc +C0wAxnKkeEstfLBS6/qkO4BIu1VZ9o6yxmw6dkO66nzAPqbOnFmnmzgyZvQRDpDtqlRc6/kqJ+rO +wy6BzXPbad50O3868ygVEan5kvNg6nbmtowXyMCAQlz/nA+aw0ZXirAL1T/BTvM3Jh3/7LPjF91O +/qkUCPfnZ2fon+IIi8ZQXXjLD7movzGFjxXdV4qJj6P4kBkCrgX212juHwPO6Qf8pIP3NOoag/uA +VXW6mo6iftCZ/OkQzBhetDqGyWT+Ljo5b/j7jb9g/H1jjENHIK+azlufcHhHwwI6qlLA4N6GAKlz +MLrRu9J9d+qfD3uwEkjc9c5vTbpjx42FGgOMIC5TV3lj7NZMNkNcUBqWUXVDKpojf87JhxgU67Sx +wMA7xhgss6mCgYzHKrbrQMIqKW4rR3E8BYysuIKLbO0eUjNaXTijHXyJmbkwSmqzxrAth0S75MVi +aZS/zmxdHo6x484IVasH9uuKiEC7sMBcBm+wMpiXbUNX5qfZdABf7U9nwCKfy8k+/9///f/M/t// +yx5n4mdgf71PvrV2/NGw54dXtKlMeJ5PKjGBOhNbmVki15VGnq3lj44EttCB/cOXzOH5zmNk//Yg +uNe4ix7TO+exXGZSHnymPoYbx6WNaCiY7zbi023uulLktlKZ63L6lDlMVZ+Cp5nJvMWXitSpECAZ +ZosgpoWvwkeU2M7svcR3M/vR8TQzPaESvkBmr7oxkRodz3IflctqZp/p1PLdg3SrEI8HPwxdVdv3 +oD++UAqk+IfyrPD1nGMeYtHsYFSdZo9qs89ImtualwrM9m3uqx+89QUK78Rx0xTYNp98528uH5+y +9Xz8xrpTdbvUc2a/V3rOpKbxQaQQDcxLoXL73RdAyCq9AQ2j8P58y+f6mf5d6j33Oct/8g+kBh1v +O4UWWf3O7B8GbzEcMORp/uXjZQR+7XwXjtpHG7mY8LWdrcW2hngMd4323BdIfoUirWKLvQzlP5nX +vf1sgN6J5M6ib5FMPnhdynfmu+mb463PvVar0YO/upHie/UT90wSiQY/6W6/pbovx+1cP3AYjE0i +T/NstbbzDccfzuwdf9K+ALd385zJDlvBQeTgdC/BD54OujyfmL7T2UnriIz0UqQMsVU4nt4AtPHB +Dn9LE+1UN59ogPUlTw9CsWgn1+cvBngG99VAJn+0v3VbjCbZKViXo0duK83nRy+R/Zv2Y4pqbj0j +sOlhAEwoze1uwSV55G65yyHEUzrXC3MxkTRv2lWCfN46LSQa+zuljcjDBPbCwRcvCApq4gsQzc0j +Bv2OpEv74q/92+IJbp6PFt8wMOqeOgKke0dE0ulilCocfhyIcG4P9vfaX2cvaCXlAQN45zlW7AU0 +yh3LA3hWBkCGDq5gow6DnrEbucIrQjUQlocM98B9tbL1wlek8J44+S42GsHtHNe8vtyvFF7T2fpn +a5a92G6dZusUDVY/yz/fb4Fv2g/Fu7fDuYwiTLUaMn3pKcCEfnxSkRbsflR4rxXbCJ8AbCMcSW/t +3eIVgpB9geIrGbnJMXfHpcxk8nnNpE5vD9EKCWx3woHF241GcqPkix6V2omr8S7hCS8sBOUL7EUO +5qFSoU/miGM2Bf4pE10MJ801R5m9+mwzWz+ezY2o1K2kCu/Swt9NNuCzOuBj3/FuVo+n+VWyUwrt +jMP5T+7qodgk9ncLnckkSnQuDvbkgWB0yMiolrOvxySitv3YWwnu1JN44eiLb+C9jxdUqH0PTrLn +L7nTUv79WCDIk2a7lG8P7hHzNFmDcq7PHdwqsLlZ9eAhV6lvHejG4AuAUXTOC+VeoAO6utyHHIYm +3lO3I+No9e1a4Fd0Vh5vNpPJyB5zpsPI3tF09J7vTrsc5JaxxwsqvHVUUWa110ntDMBOvgpD8jqN +HBw/HEudfjwBPkaDt4Hqbnn22h5ka2/HhUT3IFTCAN6DFS5bPx19ZG7qR41SUbi88wX2I0TxSUbH +uBgdnVGlHS51B9Z8niy2et87Ugdog/QbmDHvPAargD0eBLNX/fGuut1lowLYX5Dhrz5349mT+9rQ +F1CxcOn9a6bO75znq991UiMydncK79ngi0YGXJVKr+GNTzQNwHOHHbCl2Kburbj68H1PI2lUX+8C +IVoeFaP11gHA4uUt2Nh325H0AUejt9laNDPMd7uXbTi1DdikXjg5qcRK+0U2jN7CuXzsDnHz+mkm +kOsfE3G4Vo/K/uSFw+4uk7lpJviLyukV2Xy5ztI7G9tFKrz9kifL+WoG/koDEicPiE4zdUhGQ/lD ++VnaF9B+g1uiZ/DPHGSKefQh+pOrValL+PYAfS13kIfPchhUdj9W4tlY4Yp6fRgXYZN9wJNhc/ig +IHeVg43OFDi4F9ifFkRGHnxa/mIPNYGjuUBDQmMAcwFwsngocJp4wnBQEDt1+GwPAVN6QSD0KIJD +NusU/SliDEKsaZGJvtmDb9E0DhVU4sZwcBiLw4+9SxkFNYRPuZd91VyUxUvbLq3rhdAtgy+gWwj8 +DUSWAhtNA+FJi44DNCvlTwRK7rmsjMEX0K5l2ozkbJcEDxn9kmeFO1X+xDRmShguyAI2rsqzUkhF +T7N4LpbIOsAzRTtHQseBMmfY+NwMqbqd6gvIKDzQTVPGSUoL4lA7mrzyLXqr61RcF2XfqShGs6pp +hWpRY4iJrMlW2ZNHeCEzD0ykeC4lhEcE1i2qVWOwpReEcrD6EI8y7LQZA0RTk7emNzJEC4Ixti93 +gMZ4xQlk+Bz9wuiXZ8pzN/F3wMC/aFHuJbPD7NX7xwlQK0/GOoGRrd+cDEsZkuz5AuVA+RXghA1x +Kt1kfhnYL73O6ruZPeJiI1K8uatIoiy2rVInVFqB3kpStwOUDA0DrL4AERxRmWZkEhgsJzkuCFS/ +8KOlNcXvPVRLWbq3fYzsAO2EIshA8AWE0THBF2PRd6ZwcvjNqHvJvXayV8PadbY2OxoUI9VESPu2 +X8okA2PJqLgKK8YX7uDosf6dPc/nLqAOI2pXAw1igAUKtTDtTFXKBr/Xur7K8k/HV4Xjye6bGYAs +W3k+yp7cXgI9WRzZdaBXnp53JqLqV+VyQGw/xWXbIW5vO9hbDlC7kGwHCIznr587J4X3y2kt0b14 +BGpz8TuP9W2a2ny0N4YsTSFfQG0MKRQKp4Yt7Lvseanwdfua735xib33QeAD6Le7JMBJ+o3nr9oj +OLiYoh+Jamyt/6yAApQsAvudLAtuV/YHpAsfsfAh7uCSTr8BRe08mP+M3OcT3fRBSlwrLZ40tkgP +kH28pBjCgI+p1+CigtAPOqW3oPOgimleJE7VQKyMip00pnNlA1xU+sCyUPR/rfavGmiy1znJgwm1 +I6W313SyUL7n34E5XqQIqsyc6sFeboSfdEYKprGi1O3bZeH9OlIGfLpUoMLtIt6ByFKFMiCJGdfL +/k7Pal/xpZfn3a1ScTh/owLJgSCu/n50O/Eo8K3qce7yIgPmcj84Ew38+X0ge3lWuykVwm3phULs +ox2C782bF0T1pDlWbGS9z4F66IF1yX8+baQi6fLrq0RZz3GwgvGTXO80AlT7i3dlz6agp+Ul16MO +NpQXsiOASLUHfQIKkTOI7QfF2wEsPpO+V90z1pTO1Ft3HL+MHN40vqUO6nxm7+R+E5iPnxta2OfZ +Wrn9BdblYEJlrjeSaA3QChyE5lQHktw7egH42OHndI4WOXkJmCro5aUBQNSnxdcx2czsXQfjKicZ +xfY3997nF1/Z+nXjHnSQ6hOlpwwNRlOJydxZ78DwBZL90ujdimJIuWVd2r1qYC53L632KNrvX4Li +sjuFJtOpOe5e1UDg7v0AlFwKX/T3SgX2gYqk7593jRBdWPkqsFXV7s1VXz8RPsG6pLnjeSF+1Y5l +UmdfPVlE1bnN0jAvugYB8cXG36NuIXG3l5HwGewkPjsvbxCfU3Fw5cKByEFvD1go5qnc4DwNpJhG +8Thjcudz+gGg+mpajOxy7yqJpdAdJCVue+tbyKRuv7t775XmRyZ1V1KDwhwb2+7Jpi+AJPZ+9J6r +INgq2S22JELATp+1wPo97BU64/MqUie4rSqzBZ9RhZP66abSPX/Tr9aBoDvcLr4Sw+fCe73w7gsU +o6PTeZbNZB+LrYt+WKcuiZ7Jj0APMNTkJj9NnN1k69UM3IbJmHHw+6HMJJacZy+uEs+p7ovwDlb8 +dhesi0q9weLoIAEoproLFJSn69Lr3mdC3ymV/h6ARf7YyHwftjrKC7hW86zQHH/EycpNVHwGlhjo +Y/Xt71gpNEqGda/IZvWIUkDI8hUO+SyW6w+Id0AvvQcunTq/z+yNk6RxamI7uC6gJS9cjnYtG6Em +qXa7+W1s8hArEMmHYCnf4XrZeqFB5vrClkBQ0e9uJnV+2UcLpuIwBipC5xMHrbtHsGkKp9mreubb +SBtb03z34HSaSZUCDe6Quyvnz/I3h7J2yInyhd/vth4LR62rixxzS80MC/+ytQGEB3FZCh0fVpOV +p9JMVILFRYwDQjvh9k62s++Fj61nhk+N43mgDnV3FVBI64PA3jsjSHSP++HtwCuk7v1iM/Ew1mre +eGRCfWe7Vnrd2qmB+UWeii9fsxbyQRrxWZ4Vm7ndkC+QOo3Qj9l6fWdDQyyHRzLYquilEsmiipmw +9OeTBYFUtkr57DNQETNHd4CPFaJ1VvYZ4tEme9liPcsnrz6SzFtuACaZIyybQEHQgKZSODaM1mX1 +DFhh9ZvDXmY/Pb4FsrI/JHZMQHRyveDsOMfcb15XDp6YoKuZimqeBkoo/gR76R2dAfOjOFLvOy4z +gtLwGPo6wXRZeguYCA9JBUSKFDbOSuH7i1n25J5sqzo9ODlrF9qDZFR9ZgFGFgJc/g== + + + vPeh8F/MhEdvn6xqp8qnF5jhRs5GX4X35HG/0NztBpLVt8l+KdsfbiJ3qI5ewOrDo7zUWT7xVDg5 +2U9gVY26rMVKRfI9VEplrzalBb0NAc5fT3AHpWw6xwXGbOGo0Q8Y+E//Igxw83wFeWm8cHK0mQfc +UruB9qPzi/tShpi9gjUfNksbu1ESmLDX8JskBXYO/Qa24aGgAkvvhsLYuOTr/It0dpUJaE/fRCTs +lUJHg2zy8+lsq1S4OK2VAmMGMJfbzkeGzj0wyl4U1SDwS1Gw0Blelq9t5bPgv5XMfiweNu0FNtop +Q2fxE2hUpI17bKuXZUK562Jo2nyGjITUI4uYRh/QCoCNG7u37KVWzVHh97opCDJ43IYm80l29Hm+ +q7ac7HYqInvJ4rMlfNn5/ohOAeBaUYVGrfxUDpSfBUAvvbmq8axaegarn9lGqgg6o4R6Mpc5LcTP +P/dVVJvmoqPSbjjKATWICQBTItNHh417nWTrRjyC446v1TNVuyAOqdJedFMx4A00phbb4/Z7KXRS +TqoXGdHq5dMWfNHP1prjd2wtUtzmR26wKXypNKVMZfwt7UpFvqBebun9Br93eX6Rrc2vKaNAYSeF +o0F3CsRWbgBG2OdKb6eBpLUGcJ7avwIYO21Xt8yXW9IphOQo0So2R5WYQ7v6zu1zsfF2tJkbRHZU +AlqiMZX2cXh2B1a6qzq31wFT7TvDTKFAeX8Fi1jZ/QYq99GZJJER+/yaBO9KO/NxJ8fMc8DSAZa2 +yiZHTQYhAXDQeLGf+/q6yBSO2pezwnEoVILHoEf43CjbbwyQalSc7RxtSD0fz4E2blReq2YarKjG +TrbakO6i2cvdVyAhWwNSzY6P5zPi6LG8r9sP4lyAgtKqp85emvPS2ws1gDRGy4fpD2pSOujkVOwf +7nOMhwDRewTC4S5UeN8Zb3Gzk9lB6bUfT2h66b5EP8BqTHf51EukBs+DIvp1ocNDGigETCPLBIOj +JHl7ksgK5ekMhg0Ahe6ocZeZhu82CyfHz9+Fzv7LprJgSOd/Y4CIfh8D9vGU4FLN8x23X8Nvk8C4 +qlRKr7PnWCkT7NS1h3Ec2iiYw0iGwQUQzZnYpwD6i5bLD0L9qdisZ28LH+xOV8e9ZMYl8SxZSmM+ +JS5JEa2FL4COIPOfj/vfpexFZpw6nc5HWtcgx32TyatCK9/oFXa7iRa/Txc7xYf3o6LsnkRNamDH +10pQNjWyQiy+CX0hZcS2EMYuHvj6WyVRKsyz6FjyEmgcwVihNMyeAvlZD+d6e/sxUUHRQfwADK42 +r7eVwA3MDUWgl5s5NlxKAD7WThU+VNxSfF/fErEs4u46ezWqvnHp73BPbTJDHOeC+9Vi9DkH7H2O +GijOWYQsIHufugBj6e/d40LzrnMFdlu6Ur5/Hb8hHilvHwvMy4sj+gkPAAOPlba4yWXlEKg+h4BF +n3zn0JAk7yh1GZpBetrnri/aCbBTr6OlABkCdvPlVbRwvPFOqGeAG49J7ub7PYtEQilQ5VM62HJj +QGOlnYePYeF99BxBriNT/7XI6nMC9A7Xy/P4+CV78hAWlNWHIQDBYmu++SKcV+h6ko4e75Veozcp +3VxkOPXiSCe2tXDe8h+fpSA89RY0Q5YBjLlydvQ9TcDojvPCc/d+S31arTCA1HHj5lSZv8aMvgT6 +72kpWA6UKgPZLAIG0u12vHAc2WLVPfdn28VWM9qGUQS31KH4dLC5Axf+Fepr+xpP9zOf2XuJzbP1 +PP8KrM42sLATsUZ2lO2UlMFhKHQou5fZe77O8cOjOll4/nimgL1f62cSEjDALy7aYP9198GENapo +sbRTro6VcKT4xk7yhuOOux9cPXb/QBU3YrnE57Dd2E5+3E7AWCvwmq4cme9uPAbBfonstr4LxHZs +iMQ7u5HfJYFNMNgE6v51sww9pwGS/j/TcrScNhSugK4J1+a8JfVZj+PGsKNLChTvs9Jeh6m+IutO +fxULeFaoF3QZkfBmro93KZjPED24J1fR1VZWhUF/uOIqzLeT3vlQDKP6iWlcXyTNvvHAPG4miETk +NAI49YyGvyhm/zJFyy8u5V/oxR59WJ/lgGVR7lW2rg4agF7u0/JbKnJwxX1uhOnKwUYsEQQ6DOA+ +vf2N8NlDciP62QWv3t7jG5F5qrYRPb0rbMSIU4pIHNyHUPdg1cKXzJSanoLBFXpgJd/SdE6gBcBk +Bw8o1gYdKClvicprB1gWk0n6oJmNjs+OMyfJaVqo7N/GS6MH5qY4eXogCg+l+3rpIHvQInez/FDs +hd6+jORju1egvypnNV08oThdTW5DrU/fqDqdTPamddBJ9IhIMDU8DWVkU6E0u6FeRr0dor1Dop7P +FbCTZ2K6D2AL80i6vLGDJo7WpdCLJ6ZCmRG+977An+U++Pq+oO30afJ8+nRp3mmZf2FTRy9x005f +ts+A3Nd1q3TKdU/KAfNO9zdCkykZmJh3ekE+MZtUalfp1BdQup0Go6cxi07Zz1AjeF8075QJP0X2 +qQ/zmW6WXhhfYOt63K+azZUo5U4yFp1yW9vDSfjAotP7F6L0flZTOkVxsHK35Y39HfL4tW7aablC +1S3RSz2k62+oU0CLzaJ2TW8BJT/N01XYbdi4qqF7+rFPhkGnzMhASlUiJ3Z6EQzqOmXZwetY6VSh +ZNzt6+T5c1i36DTT4PjSNmna6cvh25VVpxWg9dGhvSfzue5vPE+3PjtX5p1e5sPp7+1B1azTyF4/ +lVY6BeuiJaXdw4fMuXmnzP09UUoSZ6adbpY++O2rAXVu1qkvQJSen0sWc+W2Ar3had6q0wZRjr7d +mHdaJrLBToi/R536AnoEz7aih2Kn97GQDsGHZ8yBiN7iU6+k6fRhn6jyMRJ2uqvr1BeYblY6I+6q +EaNAt/xYT7/Vx4eGRafcFt9rl16sOi0Qp7vPSdQpspG1cz36TmW+JmdXpp3W9oK0ZacnnRpNmHUK +OT/zGCNqr+FNs7lON08qnbPHh3DItNOb4PDDstPa5+VbE3XqCxjn+lgmbk7G++adVunAdSmzf2De +6fh406xTwJNhtzev5c2ZBYIfz4nbw5OCeaen6eLry+Xzs2mnz+e9I9QplC/GuX7ds+2SRadPAvE8 +7cfMOz37Gg/OkwKt6xT0grp9PYoNLRE8CdQiGxad3l8Txe7g2LRT4Sy2uZF5jgE+BrpNfes3zfyV +fxU7bdJh3aYJP1Qbu6hTKpgOVbQzrRJvu6ks7DSqdAp6gd0CsF/fEtM/mOg7nY52DsROZ4cR3Uw3 +nhqPYdxp7p480jLC6GR6nd4AvYBu40audBRDcwWd5mcGVljZ5HCnh+RJTMcIo2PmDEsaejuVP0Gd +wl7Ebrcnk0ZzCDsldJ1OJtnOSKLf4w1dp1P2KyVKmsPUZVyH3s1R563uE/WHTuOV0w6qcr3zMkpZ +vr2/JAc3Vm8/icpbYK68NXB+wHoLOxZfgzXYieSlcX11eN1bTiBf6+LbaU8w7Epu+Ll5Z/YeM8WL +o9ST5VuB2r16s3772XgJyhgzvs9SOw8ty7fVyPCQsn7bPH/fU97qMMZtnW+2mhWLr4XKTmX/eorf +vge/k7pvryNdSTl9JzdTBoxdN49rQ7P3mMsVIr2J5dvbQDOxYf32qZA6kDBm8v4t8MJvW779ml2M +K5ZvezdU7lJ5a8DYoFdKv1h9DYZ0ucdavj2mmPSdNcYCrWGzVrX6emdj5+hp1/JtMXva7Fi+PaYO +N0lrjGU3qO1wyuItWyGKB7vSnFOhPd3bSP1yeii+zcf39buyUn8r72aV98yUiV5pLbA80Q4+5kX+ +8xbow7dj0RwtvbKY9eRG0zP8S8PHqNk2tDDzG7Hj5D2wML/q8J84fFbaiBau8vCfW2S/ydYb5hFi +f42rnMT5JptU8OAiJvJzYOdo9LH0Fh0EHx4P0N6Alo5qRyROhWEQ2LF3c8BaN3dAf+/7cn9bie5B +Mwy402ZxMn+LxzTsdrLpCyjdIkvHolNuC9o5j+adMvcPlp0CIfJF6vQx9VyRpWPZKRR5LatO2+pO +mRqwkVXdCme5mqrT9s7OltIp0v7lTmkdeqH2L8+03Nd0Gr5H1qu6Ww2CDyjLTpH2b9EpsAeB9v+i +dArmopnrs2WnAMFTxrpTqP1bduoLQP3/03yu+xtxu06rQctOkU6hdAr3vqZbqFPUNavaSUrdo1/i +QoTzD+2Bm3Yv88FQvfctWnJb3y/Fu3PHduynSHcit8iBOT9lRW5p2LpvoQHEzpXKQZMuzScic9mp +ZXQ7PtHdSkWVf9LjULsuGuuQJ2F7Pz0O749liCEEIp2sbH+hUaST5ccCYFyNIuyZVliT2H26GBD/ +iZ6OxA6QCix1IOuWYDxgcgdj3EjnfQJsL5f47BQC8j9Xao1Z9Jmdy40LsJeyerpvx4eiTwkM+foC +PNiBCu18V8IO1ttFdqyawcWOFoGyxw0MmDhmAwH0DyTIW62VZDaoXvJINyj1kF7nQUC6p1EqeEio +/Gg6dyBCOeCWz/PciRPS4T/i4LExbzK/4Ibl/HwBZYboH8sVlNavtum8flvy/HZFGjObIVRer22Q +5X79Rog+sWXhElk2wMjd3FfJEpTPDblLyNqLeaIsha40EhlTVvnp2zvmTfEOlJsHkZKXxjyVe0ge +2+PdZ40sLesJG1nPS1HLemhL1uNzIt3i09FEjUB5yBoE7mDWY467F5gvJiHYYjzRYhT/I+KOHJrj +7j62Ycm2rXYl8seZTu1+0/vU1FIMTY4+vKmfOqG6fLIjniaYDqQQ0c1KLcVUs+pcxHfE1Tew0SLo +5WbkaUJmHAbQDjDn7lS4lbehms7fwjtgcHcFi2WKjsnGdrCCxoD9/AsihrCW0p+jyIFEOSpKRk4d +c2CkW2BmoBDeVac8u8Z91yi53Xf2uw7Iysbm3dx2LbfI6DUZhf88RlSHFAayAJwxVDwxW06AMfWC +wn/AgiqOaCNtgPnJXNBIG+eX8pBU40JzmZVNR5YuN6dWk8wQndl1wqCFGZdEsfhOI8YlaZedtDC3 +rKcnTH0BS8HkQmdUGgNt5nFmKZZ8AS/rW4Y4qXjXnsz2frus5dMmyDodKYLXZkizw2NLWXl+JY7H +jUoHhmSt0ElL5wu4W0Fg5dsqFk46v2YFhwFbxcLD+pUvBgooTMlLAKsNXYwL7EpXwLQCxeu4pBNe +Edi9vRHjZZJqrW5pjL1OVogxLUfzOK6x1g/zxk8MhussPV1QO9acv4DxVMyMQSuF1lRAU7m7zw0H +PqZSsM135exwc2W7Mnf3ve3NUMbnsYaVrMAjk6qCG2iJe8fO/eaOW+ND1i312ElPZbHs6EYwVwwr +OqZgul+clyk9tTfxdAMRKdk4FAcu4GogOt1yMZw4bHvVQLCNHLEQUR8V6Lp+9GCT40NJbZCRHNtD +PU+bcZVDG/w6gjRf9NCBhVMDaIIbNjqMKfuw2CBH9mqHL+BlUFsLMgAtt4Rb7nkWsA== + + + F8tuGcCRwgDc2vvW8wu6QLnPHdI1uoKzP0OvySu+vq8jeKh3uwqiKszI4vO0rHAGTSycqeFjYZMD +2v+k3dKneGJlhyz3W9zS7EFWEkCWxy2uQZa8xdEX9Hayl9Bu8GM4F+0WN7W6nb1LgGo33XlI7HwJ +x3qXrH40di5ZnYdkcKzV4C2MYmeXLJiaaiOJq+/ZTXIM4xJO3bo3ZCtJP5TjuVYsL+DeAHTwTaEJ +oUgVw2q5XyudTLXw+/gCdl66wTE83L1fyu8D0eLs69OxAgt/DcQO54qSVXxT42kYa1TpzFyvSgM6 +sHYmijzZhTINsXyiV6W94A7rY2g8AfvxuPUv0IfXfFBHESpbzJMgPNFpwovtl9Rl2H5qznR+ogg/ +Wb4s4I0en+jlntWEfAEbSge0oxV6izCAw+sA63NYc3eIeXVw0vt0os5KlwXY0Qk6Jzmk1mXxXFSi +Dh5WBdXxG3BW4JkbYrDcdSpKzoPxxL35vI1zvquZSTvtqajrI0gAzMrfauZtxZaFlb8VAvOw+czt +JbBpfIGlDynQqtmLPJ9rOFpD0ttoxDNxDGfZHYihyNakAkXiyV7geJd7sr1vAkxzQuhNiGrPB4NI +u4iGtBpnHoWpruSEIY+CT30B523oQtxAYFTc8xmfhRIBYzl3XaFSpX6mvjVSTM/Rpr2wgaNNe/oD +PBcczdRDkgeIyXwvy9GuFY4mWa9eNHg9MGeO5nN5ggSBLc7R5F1ZvhmtgKOBVTPjaJ73PoDjnaMZ +fBcYzvIcDUJZ/uwVwbE5DYrmQvIpTsIXMNMGNELoZmRnQauPDs11FCZ6pY23BDaPwTcOny17ACvJ +l/fgtzUbcqmZ5cE+P5+ZbWbsgffGZgGwmw1PTNYXsGSzC0Y/aDfzDbKlNZb4IgoKWDVdUJMVh3GG +4061t4SC/DAAzvIhEAiKhUGtO3l3hqM9dHfpXjY5TUDAVuGrxrIQzC8CtQutNARPY8vo9yoibWxe +TZe2+O5u3XqzVL4LS2l460m/t/fBQmDL6/dP32ay0KsUg6vm3aVllGIQzjL6vQqKLAsXl2IIjol+ +bwZFtl4t4LiVhvayEHGYp++lpaFGFr7qz4lRL+DpSsKRIP8xjcMSZaUmeEoJw7DUBV4nNkuiRmXU +xenb3d0yvmqdnx8AW3Z3q8ZlsrftY61tMOZK3ZVWEvZiZRGBtYy72uc2p6d5gM+bhI3nykU4nW5I +lhSBYnsct5deMOXjMYNYyscTruxKF4KJyt21LcPzrCPXLOx9MDLKHSpdbK7mdHXRtgCY5dmN7O1x +G1APgNHbeyfVVXhIAMZ4byqGRQwiXMnXuCsfLAZmsdnvbYNvMUX4JP+9q0G5pAjD5hIlMt66ijxL +s6dDU8tCXAOULTf92IgNL183ojcvxY1Yln6BeXNFsww6fHPL8jl0ailmzKDTZQwtnENnn0GHePIK +cugsO0UZdJbZgh5z6Owz6NTZgsvk0Nln0Gm0viVy6Owz6DTZgkvk0Nln0NlkC3rKobPPoEPZgivI +obNvJ+ZWL51DZ9i4mgw62bJYMofOPoMO6WPOOXSagGSbDLOLYMlM27aOgbfOBNIFu7gYkqmnt+Ac +uL3rLl+qpLORFw6GLei1XxPngFtP72NBK+29LZ3qjK+gD9hYGE97uxpy1eaKyjI+5CYZrPPVuXFy +omjP+OyA2cdhuZsf8vU5Zc65np/Oc2XcL+6RnvA+JIvMRwfPld2QzFLm4Fw8Jc254jVFXSiIEtvj +LYFq5ikUBMePmQaDeHcbWzmN0c1gS/ur7mNb9lPzuUx200ZCenUMIkoGa76sxxgnu1kd22itJKdk +N2v71P7AQcUti7bBIBrT1MkMKeqyGTSZwu6AaUOwSOOJTZP6dsp8dMezGiVPRi/alVZmb5O2DqH0 +lGKKct9OXWYdOtv2AFlmZ9myPmZ0nTk5DnvCWOcmAd9emwbNLnBiVbZUuyyzwFSakj4PzFHtcp3H +N3eKgfeQx9d0yn/Z0jitrFPTrJNg7FVpYwx88OBzy2pQGbMUTev1c4yBdx1F0C5rPZim6+c2j0+Y +OOXE2BGDNjodAltZhuhEOfmwykzxAsyZ4t1jTOtgXRJjjmmi7iepcLSFMKZ1/FK5u/uYNtCpogus +N8nkcqfLGny+RjNL3upX5n5L+3w5HQgLAL1NrUQ2AfFGvZDwnzfb3V1xYezJFp+DsfdRcW3sWQHQ +xyguAMLpahSwzvKtGu5S5RZaoVfCWb5IKo35toApbs5OBp+tSxpmpVkYcQayt8uR8zmkObs48kQT +sr/yxGcwr2z0yNTUEMofKsxcoFx1MmJFyV9H3tw7JqYS1pQcEuQMXMc6I2pmKs0X0MeO3O54Zb9b +6mNfR97cO9ZpdvoIooXx9OngafDpTAlrEvDokdEMSZOPDAZFeXF/2AxJu5mdpZgNnhi3Q7KPTndO +irMbkv7ujrjO/4tTklbhkTlGHpklo9SAJrztwiMjnvE5pOdsp+I7y3hkVPb+8fIeGQAgZBPd4SEN +bRGPjCFbcHmPDExD03lkrDJSnfLzGE8eGVM//7GL9Bx3yTkwRQ9sOGdKdhe+B0t1EFpl+URRlq3j +xt0oy/ThdWTLBTHY5ySOT1YTyQDXJXUZXI1TB0wtFXKI6XWThrZgALtavsAEMmvvkof0MUPogmm2 +oFNeneegWWOEKsqrcxmvZ5tXp0odtckUdnaCntheUqXavSrd0jZU78J4Fyl85lLQSTnvVoFJq8mH +g72sIqbOPh/O+/1ji+TDmUVBXwxWnQ+3RJ6Fh3w4uwjV1eXDQa/1kjvQRT6cyY2glklci+fDaaKh +pG+Cq86H0987ijPiVp0P53hLwEry4TQnVi5CLRfLh9PbYlbHOjCTbfnMeijgVhYTCUBpYyKtdEs3 +MZE3I1cxkU57f9qjl1UD8ihAYvlsdAQn6rT6LuG4ySOxhIL1MQRnBZlchkgGmxh4Z44Gk+usHWLG +eGdVLRuLiOfg964h4jn47bAQuk1o6e25u1lmGyrJRyqvwrLbEACzvVbGjI9ZbsP7sdttaKONQ3x7 +sxdNCW01twEjON62j0U+MoCzkkTIQsKdFHOEY30lsMVtWlZh1sYrgR1vQ9N6pXW3NYajRh8WTD6z +v9jJ0aCWM1LJzUUDRFRztrpYeKGM1Mbmq4skUpcZqY3NphuXgUOq30oyUp++V5ORCuGsIiMV5ost +n5EKoawiIxXCcXcNtM4kNovrQxvE+tJUz0FG4Zi4+tpteLf0NtSlwpnzsVWnwqF4ftuInlWkwpmu +y8pT4Rb3W2oxZm+7e7Arl0iFU99BhJLhfkkqnIlX4Rekwpn7x1zaZ/d2iqGaFajvT7ZLfPq0jFV1 +cyO8Vh/Lxx3MIreBXhAU68qj6MKBDIFZ32znUYcxXDLs9XBBlY1+7/IIx+52XsDKzUSe0otzcrM+ +r+7J8jocvXCQvKMm4kHZv7BqXNSsP3ENUInL9PlnuX/TeC1stefFUnI781Kqpy+KmcQsCDh/qX7I +36Oy4YWH4iSTrXD143wu3srnc4kTWISgNpbEUaCvHbLocdLmYpllnUErScxRerTOOxMuUxdq8tIm +u+21zk/VzmdVp+znbmB/Y2SVYcfc39klu7UTlp0SpXrOLsMucN49bVh1+mbTaTmWVHWqz8VKRaYq +L5w+2Y25+6zKlQl1KWCbIbtkNzKu61Rbj29vYJVhx21tfXPzJ6tkt0e7rLOBfYbdqF637HSn2vls +W3Xasa/Hd3ln3Wnx7LFsid7tIb33atXppTbDDq0q2LDirNEvkc5TLtvtmbXDXgVNS+ap6goiE77A +7UTRWeVMFNEzyUpKl+Z9vUC18x27CLnVarCRIZ6L5ozoYme0mtQe5whVvdfEuo7Vt4shqc7FbAbl +FJzqFOeBrddVVpIzKzticqeKC++SXSU5T164x4LrEEmHbEh0J6SHuD6nInK2cX3u6cmhiJzl/Mzq +vjkVG3E7P+daA66R7lRnRHeX2hL149zvl3LHuhCRZbir2wJ09p7eRbLpFvPDeM2mM7MDpFqcq8um +c3k/zJLZdGY+Qf1+WT6bziyXbtHMR+tsOjNfvHmk/TLZdBq0iHvW9P6xpbLpzEA53BCyQDbdghLZ +Yzad2TmNLCtXlk1nlkuntvdXk01nlkvnMrbHQzadma9dqsC+umw6s9VFnt6VZtOZKTfq2NHVZNOZ +5dJZ3Da/RDadcUifW9aa0qLZdGbKqS+w6mw6s/UziYZaMptOD8qxpvBC2XRWuuVqs+ncY2yZbDod +KP2Z+Iqy6RbCmOdsOtscq5Vl05nnVq86m84MAOhlxdl0Zqcluhj4FWTTmbEHrfW6imw6h5ORFWXT +OcuXVWTTmSFD0cZXlU3nlMm1mmw6s1w6y3p8yxuAMcUA1NQX83R1k3UVL2ORSn1tDpeJT98Om12D +fGZkVctm8Xp1hiHN4CnPquvVWWsX7vA0iwQ94UnBkiYSEuZkOioWLklAk6BgkfVsNSjdkNyyAhfV +5bQHUwsNCWIMDMpT2WW7IZkHUlhyGBs82ZRdtmCZUIppLaJD8niqs4jo7eTYobC5vWdOrpZlV+hu +6TJ3qnuuXKrki5S5s6wud+IqV8llmTurTC53iXSuAiTs45OVQnfLrVX5fuymyoytl8pVmTtHjyJE +zNJl7kQdxr7Q3dJl7nDum0OhO3eHR+OTFdxzRR9ek/aL6D7P4mRlIUrjE0XlXjiXB0ztIOyWPi1P +eWCBOsfYQyf6hGl00Hi29cC7SqRzE9Hsc84wtA7icJ1fCHqxCTv0EEQGsWPp+tNSsrsKW6DnraA+ +nwhemmo5Z7O7oazOe8oXgwUTuzTRUICoHOLBXUdDAVCO8WOuo6EAMHcR3faBzYj3rSTzcfmjEFhR +0OY6cHH1XcJxVdvVDIoqsqu2ih2IoBgy2U0zhZ1z2REwV4m1VjUg9Im1taExsbY2XN2tgBDYSgoZ +IxoDo3XDzNSyyxKVdTNUOtZ7tYuh3jUe6cJMPGMEta0lbhVD3Zn2VpKZIt987F2TMIKqzldVwRC8 +uLA+Ina99689Faq2On2DhdeWVicwFLuoTg9wVnBLAIazbLVqDEXahGY3HHqLVb12kcjg6YQ3HDHZ +hjcuEhlceeCXrnAn5Vda1bhbYBuaBFcsWrfaW4U7u8zHJbahRGhihbuVVMpzzCdyVylv2XwiuVLe +8tvQpsKdNi/JTX7IIhXu7Oq9whp33ivcub3VHGY/LZ9Y+/StqDlW1qvrxFoAzFnN8blRdHBtusUS +a/WZj+yy/iOYX3hqmg7t7Z4rBGcBvmm4IwLCWUk+5ynhzhZzhGOdC6tLYvI5XTOByuV5yW83S2JS +n4pCBhE1bMNUyGEhXPi1pLpvLtOY3CQxBQ9e9JaoSoq5SWPSTtLBd6qAktfFMo0pFXKVoW5rtsu7 +MhVysyvdJDEFD4Z65XtRu/LOUxKTVQQRrJ1oI2m9KYZ3Yg7vErfy6xRDk8sS7+5xDQ== + + + iFXkuObj1reKQfvFa0U6T+UeESqt9bH71V1NdY9O31aU43pveTWVdx2mOfVU7tGhUl5iwRxX1f6U +wzBcZD0757iCIbnOerbLcRU9QHAhqrx5f5LqBzPeKgf1Qo/M5xLHt4WtznHNFygcRmr1g9FbhAO/ +yhcou69091RqU8H0ZgELHuTaVfmOxV+aJLyzwyt1p5p8OF9gunVzf6F2VWnrsKXyj/cW+XBh6yS8 +yfwtRWp5si4Nj9i1yv3jtrb5q/CzVRLek2WnYC6bpTFtOVeivPVwbdlp8KgZ/7CqwxZWOpUzuRQE +X7CUqlNtato0yO8odQRpXZZjOHT42Dfr1BeACNbXnNOk4TX0uX9q9J7sX1h0ym0FmLPCm+KD1WfE +vdp0Wt7mrDstX249mHWK6r4JFU1qpb7TK7s6gic31p0Wi9clTWQX6HYbvo/Kv8QkzPnuQUK7+hbt +6Dxh2U6dX0m87aayLiBGUqNZURGTYM73jF7plA9rRG+PVnjmbfzEsqBzGTYJkMqG0WmQpoqZc+Ck +C9kMYB/oE5scPSTWKUnG0CrLIUFKth5U3k1qk3Ni03RVlVmQQ9ehMotbT1LBPrTKcukMlVlABzUv +IWh2WXe6myeXyEpziNDEWPK5oyfdoZfX+clea5h357nKosWQDFFa+v3iGumeorR8AbtBWfuJvQ0J +cEvrOC1xPIbYWB27Kj6ld7WH10VjzZTFTAkA+8jF1dcOPtiX4qoub7yPbbi74dBFNpKte9ntKc9L +cZmbaJWcRMOVcQslu5kfWXu61/qluKBnWXuLJswCXPYSWrO74izzxZysFuNdcTYGkLl/TBs0YnLE +2ih5qndgzWFKK7ORGyU9h1n01Bsn3FntY3Ri5Vy+TjMyvZ/f2WWH6vFZelWYb0MAQU+YeNdHLGo/ +BQ/urA8HvSWSGepZLFGWzT6TyVOOVdLTPQeqIenyX9plO9+xozauGZIqVF88rVbtWo+pgL1tF6mc +6nuubFIBnUoaO6yfcvLeLjsn6rgmBl1dY9MqMx6AOVXRCeqza22A6aTKchhzzOVxP0ntyeWSGHOs +p+MJY1XmyQKYIV3YTDsUMbZgFqDbHEDX95BYJYi5ygG0iU53kQXoNgfQ6E/2kgXoNgdQfcOh9yxA +tzmAyGu9cBaghlRsLEx9HKy3LEC3OYAQY4tnASr4tOcb2hwrr1mAbnMAZRt5oSxAiyEZcgDV55V4 +PMZZLV+Uz31FtmWK8qnm8guL8hm8Cr+kKJ9TRbbVFOXDOSP2CsryRfl8AROtcOVF+Yz1kX9FUT7r ++sirLMrnqn7lMkX51F4FOCjOclAiipxSg62r+i1/N9TxKu6GclnXz9XdUEvX9VNNbQV3Q1nV9fMW +p7RoXT/7qn4L3Q1lUtfP3itkbol7r+tnTny2d0MtUNfPmZJXUdfPPjJE9lwtWdfPKZNrRQ5d26p+ +voAnh65lXT/7qel8FwvX9dMMxFDVb4EKIKZ1/ewnZBahukhdP9N0RLtbzd0jxnWmrOld0AvU9bO/ ++Us+E1+yrp+toMsjKbaCun72bmFPN1DZ1PWzN3VNo6AXqOtnliapbL3l6vGtIOfdU10/eyjQz7+K +un72Byo+13CWSXzXZ6QuWtfPRNVUVfVTV2cglqjrp9uGhLaqn+bOLs/pKYRc188x73Uldf3sq/rJ +lLxkXT/7gGtVRupSdf2U/C0zWtTdc7VwXT97BCINdgV1/Wz22rRHr6ge3649FNf1+BzKybmux7dU +XT8Ziun28ZrNYajrZ5P34Bht2/Fa189ek4c3Hqyirp+VDL8xniQulr/lQp2XThKdtqFTXT/782Zt +FMHidf202NZbi4vW4/MWpGFdj28F20eu6rd8PT43SUxOtzcYYzW8leLTZ6QuV9dP49g2VPXDGUPL +1/WTU6Xs6oouXdfPXs2xoDHPdf3sq/otfWuTWNdvSV+fy7p+LvJeV1DXz76qn+d6fAtl4eq4pbGu +3+LJ8KqqfqpelqrrZ3Qlq6v6Wd1y5rWun314l06KLVzXzz7QSedTWriun8m6qKr62d8L576u3+J+ +Sy3GvOc8WdiVS9T1UxiXWVW/haMHdXX9bClCVQFkubp+9oohtl6Xr+tnnxArSuSl6/ppJ6mv6mfQ +x1zfZKWt62etBGEdxuEmK5d1/VzpMEvX9VOvpPEAxya71mJ/mtf1sxcOtlmcK0uIxXI/YSIeHux0 +tPNr84gP/b1Sn/hGRZ2sBE+tXbv2gfe6tEUNNUk0ppzepA/G6jx47JsSuwppJGR8pCCGSJx3OBmf +ZxpLtDqFuW/U9HMDiJXjjcjj2TaRuOvxuBHMp9rYPk0fxYnQcCPRehwz9OTzuJTuPycvr3dDsUE4 +mPvOEZWPs+zW9zzHbTw12jT49ZYJsMJeZef0/PuK/e7dP/oCPBtnWsJp6S5+Ep9ssNUy85a76l0f +tmun3O1nvXPGft+EOu/bt9kwU/jarF+d9FL9/btR5zA0/H7lvwOTzJA727g9Owxu06EyF3h/PDoK +zz+3HpnRUycl7n2U25m+rtduNuKRl8wG9fF9E9mngxmilDvJEaX31jFR5nauJpO3ZGgyFW6Pplsv +XHPKNh8v5EzLeuQgEbuN09XkppT29pWYTJ9GsNhccgvnVht5iCa/dO+h+prMti7H0KCWS0DCepLz +NzKwm81Uj82QhZABpjvbgetCb29YzhVlNIYawc7F1s1DPb09nCRKOxTzMd/qtzfaMJP0WEoO3ZhH +x8wZjFc7HaKcxI1sqV4PENudNrL3L0ZalX2s2z5gahd5VdKc4m9VTQ2wNTM8pLlAfu4LFB5KnTtU +QDP/XL66487y7c1MYrZ/nElM23ul5FbvoniboV8A2obpcv/m7ilb4TaaAM7NtwQWl88MkZEeD1MZ +718ye9WNCZpVdjCClJw9ub19jRRv7irwF5jwRT8Ok3aj2KxPs/cTZDkRiVkIRiO8zjAnTrDxoPSL +DCHfMcAIPwR/8rso6xcwnKMx+PMgijjMVhBIsccJeJCPSx+WEqUidSoAsBUiUogG5qVQ5eiIjAY/ +B8VW7ztJJNJ8GA0UDu6Z3M2Te/luI0GCFwcR1YvGdv7AF5Be5WPKKyr3cH0ovThKKC/o7b2PrPTi +nJRfvIhoKx/sKs+UnqHcL+ejqlewbxFOGex6gIldMNOnCJxzmHqefgEGWL4i0U04ZOXwigbTvdxV +Tbf5EYGYvQQoPxj1yNY2n5LPxQArhOSVI1uxAxI2SsC8pQHZOjyCaLskxW8urxFYmNS6vwV7jsDc +YiSWtqlwjIHafz2mdEqFDzN7uJc9eOB9levHP3azF633auHkaKOmkKR8LJDXGq4BrcGZo8KV0r4Z +PEDJi0K8rB7IEHPs7GK7U35+ED6ytfl2t/jQviDgrEhEvZiS36jn+UtGXI37F1oirzqjmnrhkG9J +++A2hhBIFS7zUALeJiSyvwWwm8+wNtstKaq77K2oXYzgb1r+xWAQxb0BB/58ECG+tkpwSR4S0tcP +hPyLVI3mjXrpSqN5oNELX0B8Vehti/ug98XiuWglrfbMdEfDZmQuYMFmgKyEjEbHZlLP56NQ8TZ3 +epwL9ycwp5+r5IpEvG5kM/oqvUFEbYALCOhG17B8Lga4pbjj73oRTJK5u5cpmNVmPNHdvNiht5OD +GUGE4lNxuoC5oLhp5J4EfzJhlBVMFp8y8M8U2EjbX2nIN6Kq1X8C39xAmqjEkRoEI1XiyHAnyy9x +aJhXEhYumAohE+SOyp2SZk9CMFT0m4wSwzdfQFqok12876L5QFN+Ju5foMPB7XwCFp6/qeTfetm2 +hglVCYJtnsCFOFHRAVnOfUON4+McYewMdHA/QpwYTv0pK6olgPXgZ5i5QoaDJY2tHFKcs6aR9tIy +hrRn8NUpVHMyQIALc6zX7LCjkkq5Q88289lN8NnVDDa+0dx9IGlKYTWIaLeoAxHJbx8WZQFdoULJ +e1pR2dCzzc30YZloB4aFyeRgtKtWIYB+gO5VKAUUEERnk03oQNzdXWRlEN2QZquU+xCpIbx+xae9 +GL2z90gCHBeikHIkuxI9hTQWx0+fp69wiz9NJTbzOtNgfisoljmmPi5lTelZUZJQgWmoam7CF/cI +dyo9OagoLbuZ292GpJscUJJagu9nAOJvkynriy3DQrjSusw3YKcbeAWY6eMOlGKl1w3pjozkljie +/vWZWnm/jw5FjOXC0OmBL4WoPMc3v64BniIl0Gk8hja48bYI6IUDIytHRCQUpjUZCU9qJMwfz2Uk +6G7siKhQ8Dihm6q7O2QU+ALh/EP7RUICGI8aCfzEEgkSCna3VSg4zH+PVCg4DBUmCAWAksVupfrf +aEmckQCYUC+BO6X5856IAmpOmtEBvlXjXouEhELYdxujRBEjYZK7f1SQEGpuXz1Z0IF4Ha1ctRzw +MTNSsgUR8U6L2shh6RxAGYXnMcTMAKB1cQ0ivuCWUuKTw8SSqxG1pmnE+aVR2NB0NGoBwhUeEOeP +xl1Mg85chkIiiMbhuXYMpP0YsF1py5+ilASC21JWY7pZPslr2iV2lXawVPqFRZ13sDihZWksvDyN +JRYcg4rGyGVpLLw8je1agnABANNYzAWZakDop+GASpHGbDFBLEkRiYgv4AITtiDccD5fwBaEFSpd +rQYEEFd7exYiqoRrwkZy3xQEsew0VDvDF1hsGpSnMaC9rx8F7bw/K8zBaT6CxzBJs5pLv94ovQxQ +JLJbTFBR72PQcUtqWaKi4mYU4YlbUm6UGzM5pHBLatktTpHaPykdH6No0VgItevAIM1MsUcGWWWK +pp8u34awFaHYdMWX1L5o9p13hqJte9eLUa+VdpRINL5jyBqGd0RMP2Pw6ziyQejD601k+wWl48St +IAr6QaYw9q7JpjD2rQUPrr7Bn5kY/vN52kGGYpDe3t9/K72GH1H9l5fMh2yuhmSv3zPRDoVSkn2a +2lU51lQzSGeiKrda8LCall6U4soLdN+F7IIBxq7K43Z4M85JnrIUmkZY3XM5E1G51VQ9l0uKQ+8F +1YRGXrhqQvQqlM8J6B6I4MwUYDxT2JJrvgQa0nQvI9hx1hyTkOwvY7J6vU0F0yGY1HgZF31rXB5S +ziWBq8tNyFblHD0QwbYeHknRJ3pfiiROaz3ID+rY/KfCXKotdVqP416I8LZAUP1aoBhNhl8ye8TN +tmJ4IxqTTG/sffr/u7vWtiaSbf0L8h+acVCunbp0dVV5G7kKM1EZEQV0RJAMMihggLP3fDm//bzv +qk7SaZBhy8x5znO2zx5TK8lK1bq861aJl+5pDar3V+0bcLyKX+ubHFWNo27fOXs4vfGgVz7eKJ7P ++d/2J6pW3Pb6WGW/W2/NQBsfhuZlJi/2j4Ydkjcz9Y7byiNCxZu8arZtr+rUBlr8+MJVjz5vmOrR +xdv3MgY0S5O7O9Ujc+DIwAkD2NjO9hNy3M75uygnZudzR6V371y8rHh/mNz8NGismQ== + + + esftwf4fgyeKgRfsDc6yLaOlWiV+N/UIkrU92ppIja6ld3Pi8VP9vt76afUSOPZ01TkvJoad80Gz ++570lHjrOGUXK5NiebzOwsiwMj1o/sCxn4z9JgLmfHRGfr4PHvZwtX24eZ6nVtXhzP1pQSf744Ol +n6/61k5rHM73/JdktYP/8KmNqkZuNNqlk9/osUvH6fGCIMwEEGbvaP7zD8fLeua974o85Sy/qGHf +q+HxNM5nIluAWUhq0k83JoL0vei4VQvt6UFBiT3Pq/EdLPW/H7eC9i4LRvms/fLic7f3ond4cHic +zbQetNpzq1pvHO+fLPe63Vfdf58vnny8+NI9Ps/uZ+259YXV1eAWux9P9ruZ3EFxH3ytx5Baa9X1 +mvokcuTeTepCL/4enx6t3Hn5aHfxd7X1uHYrR0r8e6evvo7NfPoD2cnY9Md8fGxmZ//t2IxZXh+b +WDmb4XIrtSEGJ7s8D/sAIymn7ix2e/MXS9PPOm8aDXSJlvHDq6ePWuNLb+a7L5+0zw4etlfmtn9Z +3F5+vf6kfa5OpFPRbA6mkw6GlVfMNns9c353bPLh82Jstn3vNWecizjLj4uhPTYz+eQJqT+PTf/6 +w3Oe7zmf+Glsds7uj80821wZm/p6p0f7D1UHafmCF+XMdNUaHs5vlnd2+j64diKO0UoupGcODtjZ +ff21wlg2ifnuQZO4LUveRJuoHv3Rnaq8CNZT9yJZ3p+gN67MVtjBH/aoWPy+cf+833FerUUqtbJ7 +Hvsh7OYTqOH8qTX+z02ghvOn1PW++QSKS6QWY1iuPRny3qm67GvLkjJMAdi682JonMIHuU3VCfD/ +F1Dt2os2Y+0MPuDrj1huCNuppJz22ls7iIfTtVnU/t0cAWmrM4zjH/qfIsa+DYkttncf3r1/cHxv +Y/nhUvFHow3K+wi/1i9X9W9YDe4CROzweGHI8Sp+6bsNN+bY/x1j4Tj5c/g1hqfLT+51Xy2u7j8a +q7xpa1MPxkxmZH4z+XnnTj9o7haDo+/WzWvvheDpTAW5exvtyuz3NpXe66xO4hHSjRRX9t6bx3HV +QFd7u7zrUD3eL4RFpdqjl8JxVi5AYbnZT5OO3qr+o/dDa9urp3JH+7b2xPsxu4OzSHT/8OzruJxl +9D7GQv0OFay2DjMDFPhrmCFaAmiIJg+raxWPj35KWDPz9fTF1TAzwDHx8/277btVGz+F42fH1XFf +dKf6efa9R+tT1Xgb0CRpN81ZVWn3m6XdFGsBLoxAKxMpMHfPjlhvrUxVkKJ/aJvF2bfTMt4ehPXZ +6jvAMuPmFZnNKv96+stk9R00t9y++pog8KdvkLxn2r9sCmQoJjgKyxs5epqpTzQS9BSaUy0ArBkM +mvL6dP10QS3+/PBEXUYdxJdqzPRoSiZsaRY1LXpLVc/T99Lrfj5bRerT++0bzyQT70vf7Bj89kdS +49CeePWj96j9x7BEvGqww1+L/rU/2OlNN2ZDvd7Dn9brvQ+1+m4mH2Xx6fHGztTSYIi10RhikXan +PsLaNj83Rlhq6eGLxCBNvH69zOJihMXK3ZW6qxTr9/rxmnPTmeeGPytKe1qZ5qN8QGsLTX678DGs +dmb9K/PLXoIZBMftRtL6/WXxxBe540iZVFOrsWqS8+DLy8H4aOua8RE956/HR9WE+KrZSfpt1RvO +Tq6YnNR6mK3x72pxyI8aJhG8r4tAJnqVCLaHIsBZuJ+6EJjo/4UQdh8+H4rAvv2sw1AEzLPzxhhx ++NvrNxHCTTr91/ej5R9Fvn6Gdu0Ykf9QXF+K7xqGdMNJJP9dqlvYYv9bB9/axc32sNO7nkHSy7Us +9s5u51JPP10MvPI7tbH27vQGNg20rLFo2PTazjfc4qaiXOueDdHyuwazj9dOxv56D1v924dX76LX +v7lQbH0ZslArz7Y+jozB3w3sd6umeLX828rLho3JzxjcxsbWj29tY93zW+7h89itbez18a1tbOvk +P4Leywz2egMbu8ZEtq87xqcbi/KbNnZ0cTttbO3U3DVJ7CpJXMti7z9DPkaxJotu73ba2Pp01jCp +SmI3N6qto+8w7JHfY3q8dXxxy2P0xq7yDNQvNz/GxQ/fuYdBnrx9585f+ac5ezdkMXbv9af1+h72 +9r4dA2oR+TpJ7HW/3mYPRMu9T7c0qr2js9ui5d7x+V9C3bVxaO/rRS1P/i4X37sYqy8/3vlhZHn3 +jpQKqVPM64g/TbM7UTY6JKp7/iRIgjms6Wpl3+6PX96lUv7eoy3Xv4W5IyXjbP/W67uzVFcOLq2y +VV09mkjdPJTCU6OlsFTGM9VyIZe6OR+8rT1osL8btoMpMRS2tY7b3zeBGs6f5FP+oQnUcP7UGp1A +sQ32dMNIV6ze6FlbmJbGWdXoWVud7RepF1NVFbjWyVNvjb91juVLxexf4z/71Et7bTOxtT+9Os6r +q90/5pP9WdSq6HK63incepHLp9j5YMOD7vvJ3xc+lcsv5j+HO6HWuk5tWhTe1ffML40QhtX71sv2 +f8TxKn6tUY4basix3Hh0f2Fu4+6DDwuf/C+nc6/mjt+kVtz826n31aDp4+bgxvQrO/zuQl27e52Z +Wg92t2pA7r1M323gN9wn06PdH16nBtywNWTmt+0KZyNbMmiRR5Vi9w5c6q2lDu3RRp7uOOrBrefZ +wVhott6XPdo1tcZarSN8dFD0+0fbrjrLprojpdmwrZa+bXjlBevpv+96tXQVrr5g/Tder26Nf/OC +9d94vTrNoq68YD39Pderz/77cesBTGpV652l4/36jKk1Pg7Kevf84pQvcDvz3YPD487un91eS2fp +j8If/G0yo4pMO5tpZUBypHf2WhNzF/uHJzunh8dHk1nnuDW+057rnS8efjw/PDne7f2Z3QdJZ+35 +k5PP2cTc6vrym2zp36cnvfNMPid7dZItrK9Pcrp17eteH54d7n3ujry+vfmss7G6mN3Pqm382y1X +W3lAJlrtYDN4RXo5pLDTUtkc/r/5r9YF/uhsEYsXLZUr/M/itN9+kP5s7raUSIVC2PwTi5/x4A+Q +/pUV2bPs7W8q2+cHvGz53DtnPQSXO1MW2ZeWVrnW2mZG5y6akHVaGo+8g3BNbpyLkHNe+KLMjM29 +LQPXZXA6My4vYswWWjbXRqtIFhrPgEWRu+ALfoouy6zMTdQu0zEPpQ5Zcw8Lrd+vVtHErMptqVQZ +J7P2+nnv8Pggm5ifn/sIS3l5cr7L1yYp+qy9enyeTay/frqz/mn3tPvqz9NuTcBTFzg+xIoNKOUd +BBiKWGLzKvchuiJURqUoyyI3xivH/SljImSEgxfByXmMsmVmc+Ojj1wXhQ+ZyYN1UZ6H4HiiJqUD +ioqlFiEZF0TOYBMhX1PmFgJKFB2wPUrWiiBJMVBOkUcVTYalUppLG/E6aCLoaKmZqLGvhVaT0iHF +ltQvtRbxHmhXK9F36aE06N8aFUR5trDk0aB0YDWxtEE0pkrP05S59yV0CJ06E0OGDTuH93Bd6gwi +tLZIEtRgObruyFoVvhIxX24CLa6SeFMDC5d00rm9zYhh0NlorJZSVTgmNPOl5fJSWcoIFhpgoWVe +Wh1k/86XBhbsCriCvCPAIxZaTUqnFaExGzTlrlxhqAlYnabV0J8AWNBEEWg9sAOYF9fBW0ftGk89 +jKzFLyPch8oPQd4enSwheCvLaA3XpTU2vX+EksSuCyea1aURii3KUnStSgvBF2XBY2CpLRUzKpqF +S8L6uxQxtfFPY8BGBZKqD5L4a79VZhOT2eab1kUfc0ulIVx8qHXBXA2+0bhCoKOIjDt5cAou0ERh +A7gLcBqooTRBYARwoYWg4U+ZFU5B7MBAB69bFo+gD3mL8ybjOuCV9GFnXLZFFjaWsJUCWFwURApA +LrzY50GVgtmBlqrhoIVYETGKGtYwau/EQ6HhhB0+mbiBY8E4C18SQmieMDOAdoiKCAL7VIwM+EiB +KzzvcG5QC8ZdMXmNreTWlwAYGF4kxOCguUdYKLg5X7qSrwjOy1rRki12UL0D2y3x6bCuqII4S4CJ +wmgBLIUCCGFtYmTwcEoTxnBgA1iLuS6sEx4+twpHxkkSVpo8euwC+43c51aLMvNwQOwPfuiTS0KF +NgtQbuAzcLmoGbEKFyJVwmBHg3A5EACeAQQO2hGirNaALIhV2UjE07AXboNREdERwO1c8tsSqOFp +OL5U0Ao/HxowGU1bexsEjD2v4jBaUAUF7BAorvlZODy1rKB/OHIKtHheQ6CQoy5Kl5SmDcwVBzAJ +YsGyKJzYDmQs+C9Ch+WI+qBV5yBy7FewADwc0dmR4j03FcEr8sQpQWjY8/+1sA39x6jpj9pLFP0i +ZmVwRpWXNBI5WmkdLbOkcYnyoBBYSBFNpb0RCrQHoUekmcgBFE1CKI7SZ1ZAA9MEUTFnHwORGLbg +EaMs0x0rSNygSFxXKU4ikyqpJA1fgypCLCQSQK0WZqhDKELC8hGKmG6BLTKbIlMaJGQU6CiRaALW +PIKsrU8htE4g9qvkMJGwVGUbplSSPbjYz0iQ4QiFQSYRHL0KBI8IQd/2CJEENYVgBe5WhRJ+aYLX +jP1Nivh2aW2A1yF3t7KjMhT0upDgDr4OdIM4fKFNxWOEIjzANIJikhIIgDhMQcuAKIkGEUAIa7dG +zLtJ6ZAiiSgEgTgcEwVOTkUVyNW0nKYoPbEu4QNkVzCRwadQb7KzEUpH0I+IapAJwbklCfbeyzqk +FMF7JpPyUTpB9AhFnNd6IyAi6R+AQDluA36QIBioxaNoD5km/x+hdEgxhaOJeW+YvXNtjGRqhSZL +gnlJtSrhMErotCTZ0xIZDFFaTla4BACKKseyCCkpLa3k99FYQRhrZFdNijC1IQrqODLnQQnj8FRA +m2RLJcEGioAMq3A0QpF4FIF7YnpRyhDDZJz+X1DegFt4hlgA9fyxZfhCIzFRIc9qvmCLLwiK2Sws +EHpA2LUwFcF6bhbrWKQw7EpDuG1SOi0rAacoJF/m04Qixm0AeEURbIAWgpHILsEJa+WhYctcTwt+ +ByQg6SNGKMLDMwdmBk+MwhoAnlyPNsp0HWGaMa20MbEYoXSYPniTYqRnws10wvJDmMQgMltVBR4l +ueVCq0HoMKuBPckmlFcSFVDniFEgdgRZyxuwtp7g16QIj+SjjCSx2peF68thrXji5ddcyafwXvZi +tWiBFIIf4VL3+egiIayi0g0RlHEcMEAVwXrS/uEnWkqNJqUjgZGAD0q0xD6Yc1kI0CMvEiwEBMrz +krYttJoUMVqd8jYUUpKUoFywYmKRdSIMiaUy1kgJimT3I5Tk0dFKPS5KlHUZ09Ek9XOhSEfXFSbU +CR2mFZLjwZNMmVwJJ6MPOeyCqSjXSMAEI5mhsHRAfkUcQkwNKTUZoQhXXfBzIByGJpYzfAYm5V3k +WXUSk2IbIEZTgc0ISZChhO6YFEniaYknxqJ2JiVKOiYhnpyZ8xZV0jdC6SSK05IGqA== + + + wZusaRDqicLC5dzh76wvgXWRRbGl1eCEkpdIbkYwkAhMJGJiiOSWpYSEHc80hTmmrYJonSJgbInG +LEME+pnoe50IhU4QX6XhRqeErUkRm0pYiAhMLKTyIkOVZAZYlTBaZAMSfcWu6wRRvnJiMCiJpBhV +hURlLxbWTzKBq8qXlWeMUCTWlWXCINGTUEyZCiXpIrFjkvpOgbDMUwgQYDPe9M9VpwiLIKk+LDlE +yX4lK2e2G60YaZInnN0HnTY2QpGzGaUkxY8lpYL3SvLIdSnOEl16vixVlUGPUMCjZM0hmaZABmGN +IZ4+jJBDwDX8m7V6Kr+alASOOjlydEwKVCofuCbYsayUKKvZcrCJxwhFeDgqhiIlKFh6m0s9B1aW +DAzayzsCIkHiMUJJwUPwR/oQke8JXslZFJFK6lkjeIQKySQeIxThARZSfUqdwrWzwsMgLZN1qeQd +hjVI4lGnCA9JQ6wklBmCN+oXzeCNrMAkhGc7pQTUKjGPBkVwr0/xzkt/TTGOy5plNVIaEyQtwV8+ +mccIRUwsBXmAZ+qfIs3SEhRKL2lfKFN2BJCuKvERimCe9BVZqhapGJeWgtZVQsjSGggI1yhDqvMa +FPFgsfSSzVhVhRrjPUvn0iidfDpIM4exSHxBdojQY0zqETQowlUsmImvC5I9SoxBKk/vZQOJRREt +wafDNSgp1WNWCCxhcCZeRQkTCVuAaBKdBllwgyBI7ilR0y8TfJ66ckz7kBJIzkg7hNOn4NSkSO2t +jY9SFlTpOQXlGfKU9q56TfAsvhABUx6pC4QAis8NkkQYVxS/aBBkmwLrJWxdyduBXYYtBSf1mKcY +IsofJY2LxKFOSTtgFgCtOlVK4uk004fI1kWZOu4qdeSZy0ufd4TSabFRwp6xFCQ+SI8WVZZYrPRt +mAewDYGNFVUqaikkIpSAe4MgrWMITbKD1LeBXKMYltY8MQthNn+LAbo3KVIsS2ejkHwn5Uzasiwp +Q1WRa+WktSFpvpTgI5QOKRZpobQ/XCrBGyH1Ksr/s77kd86CaCglkwEW21oGPoZN3oIUNttSY5n+ +hXJB8qNAEcIBLByPZTnUL1UMn7dBYhQsSfr1kVUM1axYD9H1wDUY+AXEowFQRppXCHlswiBBs1p6 +CakyAGSkVhTgxyYtVsUpJ08sPaU7V6RZhZTQhfUxzVBM6tewN8kueylWXU1MFLOGCsqlDWglTBRE +3aZA/hfaWDfvYbENFIP0CGDwoi1pJkgyh5qU8KhMIRKIKALY2QoMhqwnEjI0KdRNkfoqVQ3SaVE5 +FhApnUToJKnLSueYkjSQGw5fJYGEK2kRXCKRd6hIIVU6gO8SxSjLRCbmbCgRZRmzqWLaziiFyJW6 +mux2S6XnZcaTDBBlIQzSOcuiGWvkzRkbkSzX8YaykDKgSRGbpv1JVUwrJLgpLwmHVFUmdSawbdmn +oN8IZTh7gz9wlNdJvoQti+moimJUMq5YmIoCbxTvsiEl6joFHNamkoKqNGhlohcLhgEHecvOyhi8 +nGaU0mkF1mNKXBDxIKKC0xIwZA2EpvUrJWmd85FiblKQNvUNg915LYkCdM+giL0idZB+vWLlizXH +ICwTYrBiEtGn8WKDIgaAqG5TNoxUgW6upCPOSpHRAseXoSEz/5A6gg0K/R6ni5KWo3JJlJASZiOz +t0ESwEZ3lGlDWuo071xoNQiiCReq8arvE5wXrJCmP4GQowMig61yUHaYkjJjsokRSucSnFZW4upW +wuYhE0AkAqqKmpwU4GODrtYq+VmhXcKwOkE4OEEBllEmaQqelwakpVVpnDyKFFdR/nFguz50bTQJ +nfl0o2PpeF/uT8zOtsbH13YPuq96u4efu73Wwdnuf3Wz3eNj7qJ7imeyg1737Pyk183OPp38ixS8 +pf/y8fGlF8ut/wFCOBND + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/originals/SVG_files/Feed.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/originals/SVG_files/Feed.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,1574 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + + + + + eJzsvWmTHbmRIPgL4j/kfpCZZLvMjsAZ0I6t2buyVzvUYSqpW21tY2VUFVXiDJOsZbG6R/vr1284 +4r0kk+TrQ5rMIJNJTzwPhwNw+AXHT/6333z1bPft2z++fBZv55vpJz85vHv54v3bdz+/IejNL16/ +/vGH9+8Q9NPf/uxmSbczNNr9Yv1aGv7Dy3c/vHr75uf0K/rlHX76p1+9+OPLl29e3Ox+eP3i/mc3 +P/0Z/OZ3r96/fgm/+83bb7958f6bP7989/Wrb96++eHrGL7/n1/f/eJXu+df3b549TMlA/AeX7yH +TyzL383h78K8zDdz+3kq2ODFm3958cMPr/4//HWJawTY/u2Pb7599ea7/dv/+fObZwv+iRH+wK/+ +71e/ffnD+Pv5trbYUsafcqKfYqCf8F/4XYbPHd9+8+P9yzfvf/Pu7Tcvf/jh8Pb123c//Pzm8JcX +b25++eI7+M2Lm396+fr123+92b9+8c3/mIA3+eu7V69fAhvuX7y/WYgpu18s4ev9j69ef/urH+// ++BIYFEtFcPyaUP7+B8AFaPFnBNevf3EPkK9evn8P9MILkbGHX/7Tfz3AaLy9p3YAvJlvl5sF/v3p +b3a/+t2vf3WC17WbAzLwf6ffwv/mW+iYbxGW7JuEghjwH9dkaBHh87dtwBErN/jt3+89Z4gkbPjP +v3353SuaNzCG/+1n0tN3b7+/f/Huf/zAzWKAP/yb3728//41jDQNzFJu882S8Zv+JK2Aqzx0ca03 +z0KJ8OvYyk1o1qaP18t/efXyX39+86u3b17yoOzevf+Kp0tK88zf+Te//fH1y3e/f/PqPVBWENR4 +VH759tuXr6G9ff7u9YvvftBOLv07N/jdi3ffvXwP8+zt6x/f05pY9Q0w6s9f/OUlTp2FX/Dr71++ ++d3bfyAan9V4W0rJN2WRf4HDZb0pEUZ3pVfApFxykzfzW2nkGT0iQ1T6DphaP/kNzJ9fv3v13as3 +PxcK69d//+7Vt31O1XCz8jfqxO3q/jb9y9RCx9+/f/lGqIe5fPilm5vz7S+/gjee3nx7eHuP3P8B +FyPMgDcwOV6//Y5/Zz/Tb+DjP37P1NP/v4aB+s27V28Q5/Qr+s369W9e/wi/+vt3b3/8/hdv/vR2 ++ikLpd+9e/ENNLv59R//+8tv3oNwEUD/6asfX71/CaLk+599ENFvXr948+LdDcHhwwx8/upf4Dcv +gJQb/hj8psM+jvT48k+w9PtnGXp68y8vX7/9/mWHG+TFm29v/vHFu+8/jhqG4Z3DQP/Vfx/R2xfv +/wxS6uWbb38wsvi/Y0cZ9nF8X32Dk+Ldzf7djz/8+eZ3b9++NrTjrwy7gAmK7f9zvOM39IE3v37D +DDp/kzTYvgkEwn+6t0Drh98Av/zPjP3w4vXrV9+9e/H9n199c+kFF35vb+LffcrE+sv9H9++fvXD +fZ9PDvKbF+/ev/rm9cuv/vLD+5f3H8KG3PjTqzffwkQkodOpfXv/PeobN1/9+cX3Lwnn+z/fUcuv +DGH+GgSjF33Pnn1AJoZ4s3/jfv/37158+wrELahU+9c/vrz5Lfz3xesbBf9sugwGcQ+Ivp3+efov +04xfyxznNOe5wrPObd7N+/k4n+a7ZQFtIS5pyUtZ6tKW3bJfDstxOYU5LCGEFEqo8KyhhV3Yh8MU +juEU7uIclxhijDmWWEE7a3EX9/EAzzGe4l2a05IiPBmekmpqaZf26ZCO6ZTuMtCSlxxyzGnKORd4 +al5zy7u8z4d8yndlLksBDaDAp+HXZfq/tDP9a7G/y8X/oT4Z7HuUv0AasSPOeSKu4F/9XuRvkp8K +cKwAz/T7SvzDv839tIO/e/i+m+ifA7H3AH+RyfwdmA3sRuLgCzoDqht8xaX/8F+mu7u7093x7nC3 +v9vdNXjWu3pX7vJduot34W65m093p9PpeDqc9qfdqZ3WUz2VUz6lUzyF0wLvgo8fT8fj8XDcH3fT +sR3XYz2WYz6mYzyG4wJk3R1Oh+PhcNgfdod2WA/1UA75kGDowmEB0u/2p/1xf9jv97t926/7ui/7 +vE/7uA/TfoH+3e1Ou+PusNvvdru2W3d1V3Z5l3ZxF3YLsOKOxurujrqDHTpSp7Bb2LGddQ67V6mL +2EnsZqKuYmexu9BhfBDJ6TRRz7HvB+o/cgB50IgPyAnkBXIjE0eQJ8gV5As+s3EH+QNfEzAJ2QSM +gqcRr1biF3IMeYZcS70z51+nRz7H7TOdg4RHj3n25890Abg7f6Az6eYnX+/fQZ8KflV6VniaPDCY +ZU8PzAvgAzL1rpLoqCAiQBhEelKFJQsf5q+1tqk2eHZ1X2FKIRNhRO5WWjHrAg/IkBUExZpWWOkr +vXOtK361FWbRClNtPdAQnHBqtHmCpQUiqQW04hoIByCvNmjdWtvRA/OzwRzGsaOJALMKFiEIMZiJ +AeZjhFmZYG5ip4AyGkpcf7QOAz0LiUB+EojCCKIw00/4PYFYzPQUepADBTtDwrLBv7uJftjjS+H7 +Xr4f6IH1Bt9PKE1xNgeSQ/SuGPALJChIWHxAFoKUBYEX1omEbSOBuwuwKEHiHuH7Cb7TwgDZi9J3 +AemLGFDMgiCFMUEruZI0XqHvDeQxSeQHpA1yi5cP8Q/5iPxEvjbiMo5nIb4nGIEIFGFXZxwcGKIj +DNYBhmyHTWEQ60QjmmF8I431AvLyDlclzIQDzAocgQYTpcKkyTB9EpAagKEzLH+cZEeYbnsYqQZo +KlpJE8j9BDtAAM7PIB9OsCIPsD/sgKQVJx/sGhn2lwjMW0Bk38GiP8IWs4dBb2mFNxTYfBLwJ8BI +zpHlEq5peqI9QR4ar+PMjyw2kTcHEhYH/trTs6OnTci4AzHjQDMflw0I1ExCNZFgRdEaSLziM5OQ +vSNBi6L2SOIWBS5+7SaSu41kL0rfyqsRZDBK4USSGGQxPDTT9jOJZBTKKJaPJJpROKN4RgHdWIJd +kAYXnvbYZxr+u37SUy8900VweeSTz58u6/7Zpv3NB37gJ8DfcpPJd1TBagYEYPp+/fkI9j/A29MM +4jNg05JajRexlAATGU3yFZY2tWnrDKtOMdbb2JZ4E/Nty7nTdX3URDEsrWUp6DcCFWxNF9GGVGf0 +WdwWUBITOZFAX4LGgna5RXXrBlSxTu6V8QKt+6Mp2qoBX1ah7158+/Lm/dubf/wzqvHT5v8wVIGV +ZqQkgwiiH2IFFfVcfAJJLSy5jj8gleOkQzw3iudiZ/nj4w+IxybSyL/roaRh/kJ0M6Cr+eZ69BnC +TxnYv3/38uUbbxVtAIRV7CETosmE6LwRoSo+TYA6HTeRVhFIx5hJ15UN9OC2zr5twsZJ0he2aNys +Z9i+cRvfw8beYL/PpAcsoBugnrCD7RXVjQj6yR3sQGhKoCUS5rOvrSV03oBkfpegWRRssMzugqjX +AS2SQclG6+JkevZ+sDJAs55EpV4GU+NIWyN9ZyOtib2Uxa5CUyuKIabPJ3w9rq9kPaL9yBbkAXQF +NATuxJJkW9KsSdF8V9F4N9ou6ruTU3YTKbuFlN0VVV3Uc+mtTjtl3bSRVnogfZR10UBaaCYNdIUZ +soN5dYB5dgezboH5F2EmZiCgwmbfcO/fgypwBN7fgaKwgNIQQYXIQF0FBYP3clMAF1IA0QzHr2Sq +IHWV1XRSBtE8b2Si78hMF8WQjHV4JhzWSIZXovFKpPqyZoo4vdngOrKTZYIL5kiL5466NUvXAr2J +F1vmubGSpXwkz0MktXoljfkI0zGQHlzF06BuBuwdG2E0LfkLpipPW5rAi0xnUo7JhqRxpwc1iwuu +g/7F85EdBJF6n83yB2rpw6STslZa0FdBaikrpgu2JOWU1VNUUFlFBSWVPvxBW7mLji44EuvaPNQ7 +0uTxWUW7rzK8ONA85PyFE4EnBfTDj5iwkRgplsIqk2E/+GtwxJN5bECRJ6/N6LeBMZvIcROhXSYt +nFdeX3Xjmuvrja1Mti8H23Ii0zLYauuGJa+23daqFLuSrUq2KdWqxI+sExmValYeyKwkJwGalfSw +XRmIs8msy0KruIqViauZLc39dGZq6sMm5yxmJxuebHqy8ckGqH+IA5P888Gp+Zlff6sIF/t3Mcfe +wnvLRH69KP49ko9u++k/FduWKm1RRRZ6df8n197EfgsaH1oTRVbD3q0EXAbZuS5t03HOyyLbDE96 +mPIw3WHO89aSZEtpNr1PNK2DTWl2keBMRlv7KDNY567sOxNN2J3N0JPMSd58sm0+O9l8jiSt78h6 +DCKheQuqMM13aILuySKlbQg2ooWs10jWbCEbdyWrd0eGMH6d0Fgmw3khUxq3lUxuNFyz63RcycO2 +F13hCKL8Dl1ypEsEetBlh+wjqUDuPF6ztLGQMrJXY/x05M3g6F0bYNrvzZGnLrwk5v0iBv1JjHh2 +fqr7s4itHsVGZyfoaTLDfCf2eBVvaB7Vx43quBNhz+K+K45hYqmPeiP5Xo4i/UevS9l4XUa/y4lc +ZAdyl+0mc7+sMFHY/5Jp6kTzwiw4k8maZl/MkabaXjwyO5J3K/llKtg8pOZkc9BEctIEctQsskp4 +Zz2J0+ZIjht+xFNRdva0iaUq66PmzHW+3P3gy1VPbvflqie3+3Jn9eVOx5O5c9WX2725zby53Z+b +nedn8Piwt2dyzp4Lrp4Lfp5zT8/g65nQ2TO4e7zDxzl96GnO76O+H/X+8KzLo/0SzRUUnENoUZvG +7Bp9TsNDnJrkHxyfTwwKWFjgoajAtA0MiLqzVXhM5aFJfhLnIrsWdWaTX3GiSb3YdD7aRG46gWnm +RnUtinPxaM5FdS9WVuQmp8md63E7cTWu5GpEZyO7G9HhSC5Hcjqy2/FIM2A/kfeR/Y/ogUQfZCGV +KpEnMpI3MpCyxaYRqt08wXle8iTSwd2xBjg47k0ozINQOKhQcHyr5pNNZ/LA2DeJEFAx4Ne/rv15 +cNN6Xoqz1jNyusBHz8UkTttArnXPw704b9vAvDR1L65xjHm1NwV5FdU4m0rMCjHa3HebfeIgO8U6 +7BKPD45tQmMTLYL5Y6Excbf32d8V/j73DyzWdfDUna7O9HG+82wX2Uzjg2OzI5G72qiEEiZxofcR +aW40eCzYgX6iUdApbJN3ZCDp43tWWCzKs2ziO9VUl1EJvxMFXJVvIGUSvVs17q7IeFUmbOI5qzND +nQmKAzGZ/am6DWs3K8nXHcncA8nhk1jasyk5bG9nU3RQ1dlNpuvg3oB7hGo7Xd9JtMGYziMqD0pX +eA8LWFaa+Nmb8nQQtEeLNtyZOqUv0RcFi1pgbFLeqe/Vd1cJZa6yETIVO9kgWQlTRewom+iJd9Q7 +0ctUN+v6WZBtOMmT5SlOY+ta28rm0UT/7AYlzqlx9vQvC5qygc8aeBQdvJoWftjo4WnQxPdqijpN +PHddfBJl/CixTdXGs+njO5vedw9q5HuZ0hSq3KjkgyvokjNodAepRq4uoTg5r9AqUw== + + + VicsO4YW08iz08l1Yh38hiEhS5fdIfkdi8QfC2V4rBZyPLL3ZXAcJHIckOtgkmyPPU3Ek/iN1H/Q +PQg8WupDONKI9eyPxdwILgekihdvb/4E71EI5sXLNpzrELVmv8JxUjeeBK0X2cjUm6c+Bu9laBK/ +3jnpJvKt3k0ukK3B7O56GEPa+qwS3FZPxG7d92daRZeUlarLZgiUibOiuywWc1z0R9xDE30bxDRl +8ESQ7YXIpfwd51XT1B11A92J64+dQLrU+kILk7l9yuPWGQzI0UYCx8D7UdGHKowet5C+geDXsM6k ++0m8NT0bgN0zx8mttIe2i71bcbJdmKcymx0sy26SzUI2igtbhW4Wfrtw69DvGCjSp2Hb0I0juc2j +kL2yFeE7e/ajGJ/E8e7G3Xnwd+LBNx++2FOXnPj7wX6ulgITJ1GP1FI6DWZ0N6SrmENqSndjWkPd +YvFMZlCPJrWGts/D2puQthjXal7nyQIzLjTzgfQGn+BQfLRGTe6Jbe5BxVbL2yvaO1nfqm5XkQLZ +DHE2xcV0UQ18EXEyW6Rbt8+jPQd79sPDEmo30Tcyq31MfQyH94wqzarSzCoJ+1jgx4V+JpdndbA9 +W/fw5nKuurVeTQ3ILgNLbPfJzPfgErIW1TNcCtTJWfRHs+u7bS/2/SRLodmz2tM5WOzJ7kkXEkBg +hgf3LO6Z+7NJwzoNz3F8psP51/7s2T3wtPOHdEcOg5zn/FnG3wMJfx+0aibxUHzcwN9aN6N9Yzb+ +ZH4tXWpq5qQhi6h7stRk3ZqrC9s9k8si2pvHqjpTNQ5mqjf592YOVYvfpOlCAIfzi3wIR4I4lmuk +DgDvAhAnwCQ27EnmFvkCxJple5YdAmzVqmXLtlU290DqToJpDLthMgHQAHatj6OvJSyrB6S6JvoB +ts5Ap3oCZ1Bw4D+EW9SBxoSC66KlpIK6zNAAm80pN0o3Ka1RLgCZ5njkKOW54UsyjEzAFICFcVuK +Qou3AWZCJ/SqWCXHJcDMRAShAS7EGNq85KHvy1ILQooyIWDXe57PTQm3EeaJT3G5JlqidFkB54Ag +lAIohmHL0FdkRyPkdM6HscV2i9vaTUyYAOQovS5aovTLp1Mqt5QitCBzUrjmTN2i5hSYtcYxb2oJ +axq40sifhD/UkBON6IxsUUbUW3gDpi0tzWXCXBfvpyTEPH/15iUde7KMmC2kZzttjghgNIwPCBzs +gAAeD6iDAXknxwMihexLPx6AhuPU4/YbC+Mk9kXchNQuGfMuqDblk9gXW+vicGbCq21xbsI7/9Rk +ycdta8kPrqluZ3jf1L6dZRxPFy0OtTl6rsSh2/ouU+IsVwL9/OqyUlOEHVc7CRg455XZJN0qUcsk +SXSiHFbUH9h9dZIgHTusClkYO3FQyVQIMhmyZkHIhOAzI7OcGunnRlayS513QSfIJCnOWVwMbpa4 +MyRpOEWyzUoI3vszmU36KPfPRcN0dTk/5Ck4macguGyfepZ7cLLcg57Prk4hm07T1t3pZlXYZBts +s9mHXHZNKphcMnveWLPenj05D1Jw1uzW83mcKKIbYV6gvYp26pGcjYEmRD22j02FcTLM7hBRnw6a +Bn+UyTBPg8AYJ0P3Ni0uUaWov8mmxDAppgd8guO02E6M/SZK3xPD8nQhT2UUMcsmRWVICNs6jdZ5 +2sodmyle9FyeLBeny+SyUs7OPgx+8j5ZRseH85Sj2wMjFzhHcHagUDlJsD/J5Gh/OwkqPfcwPJDt +Ve00F53jOp/hnK52fkgumgtVEtdoIuv2h9P3MJF/bSFRhvsey7A7mKaR9jrMnzrClFxgKmICbVPX +Gcy5CHNthfl1qCeYTBEmUcUQ0WE9AbUR5kaF6XCACbDAsBfK8ziCJAggASqN6wm2h0AjusNUDbfU +V5D8h+MJrPAwwcoplG5xQC/83UKpdAVm5A4dV3d2qssfUfucA2qDsTpd83gamqnTx4+nfSjpzgxT +iz9PF+NweqTFx+H8cZazwyz9JMt04SjLJx5kofAnBz9bXCeLe0aLeJ7oyBDnGa90sijDJKVsYzqL +dKKM4z3lHK90qIkPPeGBKFhOd3Ru8UApyD2dN1F+1aLZxU9T4WkqPE2Fp6ngpoJzV61lnsm3ANpZ +aY1s8paT1CIh+/PS+ZZP+5icYfm0k1lfcqrrE0+mfPX2T++5btDNP7z67s3L93Tw6BK0n9lXHkzK +g0l5MC3TTI+w+fEtHzkgeE6mrLegdaabGm9BsQ2fNDKXPk9D9JjP3pa8hIS1ceKCH4g363pbY2if +RsLDaB5PScufNzPHT37KRPn9mzcv7l9+e/OdgG5gxcFMuQim6Si+m031hYs280UXywMm83RmL1c7 +I+NPgy+bnIkxa8LlTUwW0i0udcK5XFxYt7tcqpnFZ6lAW1dLPssFGsK74mYho/hhY8bXjjivFxHl +rxaL6EUjCtaQ6NZDtWoQbCTvyMNzIFOil4PgYhD0F955J4fR8TwM/g0TiNxgJ9D17DmfO8dT55XP +nZMdsiNx3Q+Zn+yAeZBD5iDeJzpdXuhsjeZ5cKbHnuxvPlqO+T2wR9DxET1TlB84On6NLdnvyNM1 +tmS/I0/X2JL9jjx9/pbczy5tC1dsy1Zsi1ZsS1a4ehXTkODsylUMqc2zRf96TvN+CNpr2L5MLnLv +YvdD9L4fU9+dBfC3IXyqFXJ+OP0jcXxOlGedcixicems+fkh8byJfPfYd5w24W8XAj8Lgmt++vFi +JFxi4ZMLhvdw+HlAvIfEh6C4S2qX8Z7GsLgLjJ8+FhgfVS9Y+m3NH1JqYBNbWplXjk2BvMEfMHSS +LmpJ10LIUbcG8itRHG+dl8vIAqxxOiVe9AcJQ11WGq+H8sv27LBe3LMB7PdsHlvSo/e2WewkzYuS +QuQskrqmLh2lDf0Q1OR8W590stZ/Xdob2ffLESGKB9FGlVypKI4EaZmoJsmD6Mgl79dEqsleIj+B +ykH1YlCgkJA60uM9O/KCsWvWjk8RZeaZjJZs1Y8g+SSrk+XNLkNybk/PJf1kkrDHzhKpNA/2ziW/ +atKrJrz6RNf11Masq0+qDnSp/M+mEND0KfV/Hir6w6L0M83wC1Y4bfjTl+/4UpXEJZ0fLPl/tZ1U +91LdTdXEVSOXs/6L2blxYlPXjF01d9XgVZNXjV41e9XwJdN3Uzgkl7kFL0lqyoHj+2ohot6PUg9T +EBbQLsplW/NLMY3WLqyoNZOcXRYs2+HjylzdwxXQmAn0YE2Ja6H8MvEZL0rPONaza+qjHx457OR+ +9s9heHxO13Ea/yvquXvGRW7HL+OQhHrp2P948H80TO407jvZ+f9y+XiCfz1JmQuVbs6Unk94plFL +On9onY7a9Sco15/r7fLp60/75dN++bRf/tXslzGDhPBbR4YF7vO2aDvhgk7wS06Burhffikm3i+/ +bNeNC4DWerVdXPH9re/l6fJmnuJoCuHXU+rZU+rZU+rZU+rZU+rZU+rZU+rZU+rZU+rZU5LJU77R +01R4mgpPU+GzUs9wz/2kpK4FbeL2BVlhguCxGUZ6GDHfznjs6zOS3/SjX2ikt8tGenNGuvPYkYqs +6jHpFmZYR1czohvVqglzuQjRf80sIq1XDWqv67KWO6YU3Q3lIXwRFlcUcXp8Jd6/Xu2S85SCfGcz +Cb5vnKsfugbkvJz/R2v0Tw/U4n9MDOI8qADyoKdjbJMyzpIz+NqGj3laP1FITw/4Wj9bRE8P5SKd +i2jOCPpQcY5g2T8n6fgHynMwE6bhrP/RMn3Oi3PEoc7lnaX29MSeVTlULKfng7UuHxC/wJmylIti +VHJDQNJVPPFKaSNLLu3DSbpfiHD0uZYyL+zHXePo0LWTzomOZJuf9CMe1y9E+GWiPF/2twIYL5d8 +8rc++Vuf/K1P/tYnf+uTv/XJ3/rkb33ytz55Vp6cbE9T4WkqPE2FL/O32q0b62YYdRBxCC/dkvDg +IaNpuBVhvAlzPGk03oTpr3EbjhpNF88aJVe2cHHlQv2dHFq9UO/kkBKhk6u+76fKWMIw+hKGw4zR +OWMzZnpwyvBBNJ4tOlc+NFNknkwyUfo04cS/8Rq6Pj+2s2OcGzAzJpwYNCt0TvQZQTm07KRrsJpx +EgRJfsQ1jCs4w3AvMMRaOr+dnRszD5PzL+0nWcPjZSr5YrHXsdDr7vKNKpMs84duTzgfxeHeBHeL +Ctdl3U0PXWq7udZWx/XSIcNBGkwPigMc5o+Lg50leYo8mD4iELxI8EJhFAsiGHAGTBcEgxMNMhVE +dOOaDzT0J1rWOPA45HRhwoX7Fn1Z0WGcp4vD3BfpeHFOH+UHb8mYbKj9xTlu0brri7elR3m8e/FR +GvNpI/u3V2SMl2Qsw20j+7OtAEZ/csP/mP3A7QjuLgx3D8a0yfK9sDMMe8O4O7j9gScCHp44yKmL +D00FUBlQYdjBIBRSFBZSEg4w+iuskASKwQxKwQGE9urkxwm2jx1NoQBvOdHkqSApAu7wR5grK/A3 +0rUaB5gGFQY+Ahl4hcYOhijDSC50Y8YOxisDQxY7k9BgQDIMxEJXYuwnug0jw3pbgNm8zlCUIoMX +YC4yFtmqEhSZqdd4Mge77CTeTcY6vs9zYJrjWdscXjg/sCBnFP4G7HJ1L3Q/04ccjmnjX+repcG1 +ND3S0fgBN+Pol54+70KJi/5p8ixOH7hO4oHLJD58qej0gVtFx0sk3L2iH7pWdJKLI8RlTP5B7zSu +6jaWQx93dNgj0DGPTMc7VrriY08XepxOdxNdy8lXcWa6gnNF3zl6r/F2EXEvPE2Fp6nwNBWepoKf +Cp9VPqrNt8vcPi+LRj76eWWkynybYitfkDakGD4xb+izymV9aYC5XK5tUNYP1SM6jwNvrpUhv/gH +ltb0kbXlV9f2Die/wCwyPLkQzeWKRBdvKNtE8Pa28k6TBoZdOGaMC59HhcfKRJuY8GTBvH4TzWox +YT0cfPhYuGYZftLiRmOZI/5f6P+b5Mdo3zVuEkk9LVzzSBTWQvfocjyFf1qlDFKhc7l0j+5uUxNp +WxXpZHWRpB4SVUbSqkj8vZdDSpNUQ6p0jcpOaiFpCJKrIUlcmi4G13pIUSoiRSmGhFYP6u67iWI5 +O6qDtCfjiMOTs9RBSnRT0lMlpCtUQhrs00c7KMQ9cbmM0mfcGuvq6BymXlHJcqu2d8ae3xg7nxVW +stJK0+au2H5TrC+vNPg+NyWWxiJLu+msztJYaemy/1Mudx3KLYkjbXJeUFdzaetRu1SD6WN1mB6q +xZR9sYEhC/BDNZlcVabLdZlgJkwXijP1q4ou12fqFZou1GiahjJNvlDTpQuMFl8p4sI1RvBMF0o2 ++duMZO79NRVwAqkxr5WqLdWQ1ovIFk6+m29LkJS3Nac2hwdy6K6H8suUnLVcVHIA/OgLM7jkg9oo +lywUSoh5KPFG8xLU+LlkAg1G0EOIillSjG6b0IWoBnvqrDrDx+J8H43yPTZg+NGQ4Q== + + + Q4g+Fns8QzUuM9jZ+EKZZQZlgK4LmudS27AqKFGI8kpl0vEVM5fn8dUw/mcvbHu2RsLF/NMQh4Xz +sdzKi6U9H0qthDGeBi161KPHixzHhMptSqUlVE7D/b/FruBbh+opoz0M1jDXyDnP/6qbxNOtgbE1 +MQYjY9pmfTkeeV49OllwctmCZeDOTjwBnD2UxnRB6pxLluzlXseUyaOlTD6UNFnlQtQdRl96Ntw2 +H+5y4uRoeJ2xZBpScutuez00pkkt1PkiXcZJwJ1zmc3bG1I1pZlvRw2U0lXpjMtRzrfw6RZMXj5R +FZ5UygTdlRMtYBpFOsvSgE8n4kwCXqx0buUOOktmO3TqCB0JQH0FmveUsYfpeivReTdREmcBdnEC +59ITOGEiH493INsiyLkKTNmDBMS7k8Nd4pH7JO3+48r99EHtfqPbP0a1nz6WjXA5GYE6d92uYc7x +w127YLp8vHvTx5MtLnWPR+4TLbOPdXD6VMvsY92bHpNLct69jaMP34gbJKgqrSSqp1Nb4CI6OVC1 +H9VM5wDdos10c1neWKj7Whj5QrsWF0ICahXICTzEkWF3p72ddK0bcuJxSdGE2LAx8HeJ9eLOfC2E +X7ZdX/TmbQuVjnrueqbnRipuhtrjuS9+m/p9ivNkXvhLVcsf9BG6omfOP+j1Xq/7+hiCjyN4Rdof +a+g6MEzdyYUWXJeGbvmsdh9n8LEGijd4D90iacjRnGhVLIc2+zx7KUEodcEXqQueLPZRJlHXq9UA +37v0+5PzeAX6m4zi7GhutJz3n6zyf0pqX52umdjnTQBPo6fS0+kp9bR6au/8qUJ/rtBRPdDtKfe0 +E/WdQuXiSOOGyg2d+wtnAenq5POjgHvLuFvNTWXHADdXdHeageovPCX9xdbFfBtBFWL7qBVYBPhD +aXks8lbwtNxKUhute4xoULmyy8L+ahi/SJzGcEmcAvQL79k8OblzdqhqckHNKpUjfUBTxOmXnvba +nR3wWVCveeiAzxBufczxoi0FPtRbNufNiILpTMApDUoFn028nnC7UOnxkcLtPzJn+jHv/uS3T5eE +5Pn7N/5MNB25PjsMGq1WMOuWsYqiXtlc9S7cD67766H8zOAvXnqcw5cEfwXDlwmei26XOFZZfFSi +L6X5PirL91HJog9YbRfSAx+TcHiWOfcQOh+ae0xyAqUmPCpJ5T8zOu/TREmYyF2eG93kjRwMw6F5 +8Zuf/+BvMGq36zJca351zJ+48OYPnb3/lE9/0YJLFyME6UKAQL965elgyZ2c5pmdq75IIignhFaK +n69qHvQoeq9vLqHDTdHyO4ud81a6yN1CC0XR1fMfJzJ8oiyyIsutWGydbxtaJbauNgZH2A+0WHk3 +1lj7adLwHfeTXxaCFA3mrygnxPnJJIk4EM83E/HdRLyPr5PYKvJf+q7XFjW6uEgvMOINny2wg5wx +Hr/T7yZrcnT/9ud04bkj78cQqMRx81pNHHS546DLqWl8tLrfUbq8Sh9YXSJlafqIWawXeR3J8/hA ++QSXi5YmS5fZJqJF8klqmsy2vk58qL7OZAlo+WKFHXZGX8g+eyD3bDeJK/5OjiIHTT6T3LOD1Cjv +vvaPZJ9NZzJUE9BUkqosVWnK8pQl6o5MtgPJ1aMfY9Vdk50fXi2w1iyd5WiJK8ugR2fLV2mTLCZT +ZWWtqJKvySl6S9fOadUnyUrxx+az5lut5LrTidONgA/nNapvRacS/J0uJGFtMxzHHKxtTQ6dWJJ7 +NVHqVc9t5HmFrv8T+b8DTSicTjuaSjyRgkwkvjfhSPGLQNOnTuK87yedsdqFnnQucs75jqQS+sT5 +mPMd+sNhtBuM8FELzv/tnHj/N0e4PPDQBJ5kd1MXlzq60tn+Nu5rlza0g17KMe5ni9vDfPyaF5jf +vFYxGdls3KkRdLe5SmC8GcDntoxZLWM2ixS0moYMliFvZZOv4m8QG9NThrSUachHGW8LG9NPhrST +Id1kyDKZxvQSSm1ij9GY4MSGnKY5aaJTlE1x6elOk2Q83UnCzdHlPbGbSS+W4+QndjmNKVB6DJQS +oaYhF0rzoRadBTIyJ5cXdZS39MOhckD06WDy3/7B5Kvlklx2Zoyj/NnjPLl8zi8faRjr6XEV5T4w +1pvRnj4rdviB8Z4eHT386IhvLNm1zgsGw1qDzSTQtRqwE8SVXDvi0Jklh2bBiN6DWTlfiumvLhvn +cmFPrOtpVqrzlNgur1t4L5RTnKq7M3vzRFcbzbYX805sidnTJidbsrFJRdAs7ESWkF5JW+k2pFVs +u52ZZ2KETZaNHUnzJd2X5hqrvlxLbEdB+iNZTidS8Weyn1ABRhU40Q05BYvyTJTEgbrwjub3UaqM +8YkE7H+QJ1HVHlSKUS1GxXil1cLlpVQ9pnuTZ9KSudIU15nCEwuZjv5yoSlfaurA1cisHtkiZxg4 +zSZPlGmzDnk2nGmDy/48z4YybUbDNJqrncdOjdOFxuzDJ6lyr3I0XTxDtVJizO5SwGF7ekrOeETh +ZJ3MXj0g65xl4W2LwwNnp/Tg1HDHdKKsmtFqPdrd0mq2Iis/UhaWc6em4dyUt1z1drbjcGoqUGZ3 +oQyd8yQxMF2nwXJd5SKty+4/Nl4/fl3W4y7OevA6rekjd2pdvGPrQ8/5/VsfunfrEbdxTRdK1z6m +mO2Dz/RgtduPPfXyMz30iweq5dIzWiTKWu290qco1OpQc2Ox2LGaGZYI/4lXSz98uTTaCtNjLpd+ +/PXShzxduF76ChdMf+YV03LYwRcQuZsuFJfw5SW2BSaoxMST7fG3ZHs8kCGRgQMRAx0NQ2Rjad+S +KqUdZFUksdRvqg+ootdD+Venk5aLkROAXqw1TwoNb+g7cxdePgQt+cAXNnP1QB8pVfyRR6D1zsw6 +bOY+55tOQU/OEd1d0bShy5a+uNsws3ilZWs3zzQfjj6hMJ/Y18Wpn736bHfLazK15pYzd8YDrHvL +qL7zB1m57lGiNV1odTda5zta8YdNdnmkTGSUDoXykTe316K8nSiZWlyyklLNftmDZNV3VlbSi3Zc +kVI8teyrRW/tnm8Rndhh+7+2S5Y3k49V2P/wXb/nF/heOG734cr7F47i+Wd6UK986Ov4wCO+RDnF +R73/lLOtj9l3Pi1F/BG7znS9/Gk52Co1g2jdr3S4oleWCheqiR1caakq3TkvLUXdmsjIwp7xnsr9 +swpT1EfuZa8xtr1WlrsrF8tO2OdNxSl/tyz3fqg7JTw4SdR1c73sxIHgBzdeLLmE6c8t1bVd3iWx +0D+mIySu/P/Bve4LEY6bboNeUqbhiqdWJBGCd+ymOzferEpJE3wFwEe0gi/F+EUbdL20P9cvTWF8 +uj/g6f6Ap/sDnu4PeLo/4On+gM9WjP99ET7dH/B0f8CTU+ypaPzTVHiaCk9T4d/+vtbHFzEcz3l/ +0sf+6vzl7eKZwrY5U3gyRu+tyN5OsivXTXnpYj9dKjVN/05Ddufn6lgXNMEgR5/RZUAOAymUhEYA +q0maI88KUqMskCNp+qQeTXLCkV0DaOllqcXBWfEnd0y8UpLG3jKXLW+ZKDPVNVqVF1/dRb39mnk+ +SxBfPf+ahc7u/4pHAdku3lH89CBh/ZOE9meLBfRogAb6i6R9fjzY/5Fg/sfi9uex+cfE6Dehdpbf +nymnL4hpEtLTl9dM3LHpsamUPzoxs8k/lYAqAw+D/7KYIIzT4L48nqWxqUxUqbi9RIFk4wN+TZjB +a6YzUcvS8lCYrfERRbsjFH5FoI+5Dr8YJQvIXObx7lL4QGjFCzk8yYUl4uAHrEkRymVx+aWYvkx4 +Xqxv0cb6FlYQVAUOuxju9EiO8zV5P9N4oGJTJnrrYbpUInp0Sz5QIhp9BZP5lLa+SfMkjXLjQqmo +bUVaDuftLtSiXSQ82utnlcnKQ+2cH3GMlSZ3aocjpjvKArGoqUhRkp8TpZFkiv1xKlSzZCiJn449 ++iIJc+lQ9AUZ8wgJ87AaOH1cD9T7nvebxP+xZOm2aOmlRJ3TNsN/LFy6bvL605C0s03b2ZQvnVwO +fztcLGDKMao9zUq9xqhHq7bxKlZjH74MRWJWkwathhtR+p0orOBu41aXIles8EqdI5T7XvKz7ivR +q02mcZyXIRQESkkYj5Jr9KVpEcq0BhAPFyXfddBx8SFU0AZZvtZlky4CHQRxfuNOuQcMXD20YVwP +5YcENAC+/tXbN7959+rN+1dvvnv2zMlt/4vpV9/jbyL/5jcv3r9/+e4NCPSv/t8fX7x7+cPN7s13 +r19+C7J8A7hZltuU6ir/xptSbjGiJ/9G6OqP2F2zBf7wF/rv/wM//ncA/utNuvnlzT//t/nmW4L/ +4bfwzxbnvYMJ3pvnANu8a4DpZ59fwIewN/S6X9NQgOUE+gXloNdKbE7zCjsOboe10LY487zACq5S +sSpyLtAfXuAL4KVY1zXfgqGZmF4B8b/0SvptuwCRjz0/x4SgP8HfsGIBS9gyV1AZaqU3KCy226Wt +Yfj4JZh+9vkFfPoe+hxwKkNHQYrSexRWltvYwM7zn78E088+v4BP36M06ec9x2q4Ta0uwqA2z+0S +yL95i03fQh8rxQ+Lgtwg8KcuQNwYbDDpC6hbNeln7x3Ic1a5cAnmZ8OITV9C1MAs0TG9dzD+SBs+ +fgnm58MW38CtzZgozA+Afv4SzI/AFp++BwRdgG0Bl1meK2zXGEOPINhYViekF6sHSRaAFFwD6c0/ +0IKbb37L1UcCLE8uJFfTWAKhi1VUulkhh32Rjp+suJpv/rDjmsc3/+pnap8rl4bt0mK6sGY32BD0 +R5b6NXNh2k5eCctQJSlxGVr0ohCZ0Es2F6jn2/l1/8DID6txA/PEX5qvTCrs8gvVvgsRwx8XeSvb +kbNoQDoC/UzrMEtFmlyaPcqtSzAvObb4Oq0VlP1I+2NdeGpBu1yI0Q3jnCiwNWEjs4lDlTRwVx1E +uFvKl4QpFrrayFwBuVV7Qfb/8UoTfyuM/TytMIRJ2GLC9ALML8hLwv2qw0+bKMjOPviDqL0gBhUk +n3t+humaw77ZD/wW4cf4khy9IK4v7C5MaEpgRY610FJe26idagnMVbkqeU9MKA6ko+DewXhdpHNJ +vIF56rf4lNatVuE1DY9TVJcLII/xko6Cb/n9dGJ1E/RTUTY/S19d+Tf7dz/+8GfFY+6GMP9smm92 +8PcP/zr9CM+ghV7WQUkDfZZAN7/NNyCpE1b+XIALz0AlXG8xku/Az0dwKLd4MSGBFcMlWP/4mwl1 +UJzI80JjX/FYGE5SsMhWEv61gJlAByJx90KIFeBfdB471GhY5EAEhwbTcc0JwfF2DvAZAK75Fmw/ +ISPCkgdYjbd1nqsj7Rv8fEF6YAISGBsuDT7cmm/4F2gIhhbgBLJ7w6VuG/4LNpwzYAzJvxyWJ+7M +ZaDS81p6dJiGtrhfAd6bASkyu4GaPhCgI/DNSCmAc4HODb3Stn8Zu9/bOlZpW+yY4w== + + + aqfB8b9Tux2ow/Sn6fdTu/npz27+8I/wE01qWAXDlP7YTCfoDYBvwjDlHz3hV1CfbtcVNJM1zAXL +89KcX+c1ophoDvx8Aw63peaVwB7JA2BDcq2ZT9hLAQkK2BNsBDkR5QtMLoLEBOoVN0vrkhiYYUe9 +GSmDlutacZoxOHL3ECWY6QxEM5yBeKXozcWX44Aih6BNURpSWpLwM9+isxrB8NMMOxQCC09Kbhtj +IWC9xePSDGwLrIUDIYCZhD4BBuewaNuY5GV5DjfccMF9m2BlBsL58w12xHllAhaaqOvcllvgfeC2 +KzNshtmboYHyJq2MACd1TEJsKKXwjAAwUFsH7sAeDAt6FfbmGqIA47IosZg6y3gRHJVhsWVpG8Is +WNNcFEFYi/IclVtDkKsNcA7SFjbeqAhWBYLJrxSsST6fbjESJ03RZBBgZwLMeQEu6BZgAuY5GAJY +/cJFULqqcAbnTWnCcfgvoci3Kcwyw1LIzPECFGjHas7aMQBj13kkW1QELWUFppQV2JSw3jFYdDbz +Ww3ch/U2LEXmEYhaRgqTI+jkAIEln28ws4vQ2pLwsKFiKO+vOPHl8zK5cF2s9nnMmNIpu+jnS+PP +w6tCyAJsyHgG1nXh5TjTghcEda045xGYGo9MhkUeVwGuqVTh9RqKIYAZqUOwNJZiy7zAS6K8LgVB +saD6GbW3xG0EpjkLtREWrOBdcF+Q1Tyvc8db1lmooLJ7DMTML2F4qQwMtxiv1w6XIHgBnJL0bYHF +K3gDdDQJvSG3VVAkHBNGkWMVYIlRV3mIhraMb2O0sEpxm+pMY2A0EUgyW4CgagsBLO0YDJuBkDsv +axES2qwDvOQ1CIIl9ZFM2l+UDjoQIBu4LUz7lJtORultBSketQu56EDAbp+KTrFQq7StWMadOY7C +XYBr1TVWHIIWVdCskQlYoberNMWSnQIEzV3f1GbtAYChywJeZdast8C4eIYAjSUBgvJiCIhEXjor +iT8Egrqz6DwIPAiNZU7nNiNoOIo6YLyJEDDp0l1hq72xlkJBhf8aghhtwykAZmDJtSpjDUj+VqbA +WADQOdjCkQFvyE1l16JErUk33XXRWbTMPNUZa+NZBMAuJ0kkMrC0VZmNm5EiyECXtuXJvcAaT7bb +BJJT2BJMwSJ8jYVmxoKbYFDhh2HZgyLQVyXaLgmUg06WarAuu3VTQnBsRVdyZBEDwNbXC8s+eDWw +f22OJkYQ0NOsi3NhtQWBQdcLxmtu/knaoh2sO43ghSUXkk3YVWAgkHW9oaThd0XUwnTFFft8Rmb4 +3QeBfQetZamGoM1R1zyeoEEgfCwEU2RI5UFgrFVeBcaAfB6QRSUAVG1+F/zYwpaFGQZzjU4UMgJA +VpouGBT0DCSVnYdrLkWAaR72L0VQwiq9zamJBouva1lQkMErL0MbRTSsxfBW01gWXRyId9EpK/s9 +qFymRZt6hMAF5o+qR8baAnJHFU3MUJa2dU4mH4S1FYZUp1yw5Y0+ibjqpCslSVs8oaOsYU0ZEQTV +xDDsLghAcibb1dIquweAQW4puGRFoboyCv8SBdhsnwno61C8rSZZjBFrxyMQ1Nyi0x7LIQsQpOGq ++2pQ3q5YWSg7whhYk7Imy4CBjJ1X3b6WutrnYRErZ2rRz/etfUlBqarRNtA+Ng2loK4bYP6NAGFv +VwSzAsNaDViyIehTXNywDE51qV0dY9galuiYyMASdMgTbtaKNs9L3gwNtK2qGsAwJwEm2H5UmVpW +Q1AWlRNZdAsAtrgIsMCCRGDAAuC6U2GCBSMIeGZ+ToqAZXogQ64oWbynBIyxqcpDerwiSKkJC0TN +ReAaVZ2r0oWw3Iak/F5R32QEAM7MA1htgdcNAMFgke7myGICgTHoq6KuGwBjJpsQtjbuQnB7hajU +CMxJZRrYrjIKAE5VN5u8sgTGtmLGZdMGEbjoSsAbqgwBKSrcXXR8CxBtYMYKPBIgiGWlAASsIWgx +6zwQfTREU6rRd5GzAENLSTmrygmA46oLj1gvwKgrpIiCh1ibrpCSVAEHMPwsCKgzCExOWJPdwsCu +8sAOIcIHwaJcAAWs34WMDuiFh3aJBow1KDAoB7LbMCUkw+AUVXLQNsbAmtQIaSwSEVb08zUY2mIm +o/YINi2VWiuLvYBLWidQNXUpoK6tSgDNBQbm1oT6uch0x71Ol3E1uYk0mYw14uFjS1EEoooDMGTV +pFc0YpX6ZVWpIVY/Icja+yTKDSGwyWaqEbq6Fh0Um4MFlm/RGaDioZh+nlm7VQRrUIFcUe1+ruDI +iwNNX1b6Am5r1XOBgbOsmNI1UYSirOnriIEZLBqZGGJjAJAiTow0lcUQJFNwk3q9EEzbPIOrzOLK +gzoOQ3VSekWhoXiJz7LqhTe4gdrUZhcDAWuy3upWhWC01akTJHARCKZ86pNzrgLUFScziRGsZhPh +5BZRANtPaiojxdICYLIVV6uqaKE5G7LNqyLAyzP1ZZUYHmc2WbqMJASRLuVUCiJTG2dzFNmaQ9ii +M3ENasTi55tuKQVlDQODLTx0qAmQYloyCCrQEVzUybEuvMYAWHP0spuB5GGTjUoXXkQPQdNdEZe2 +AJekoxh5ziIwasuGVfsVQSy2rfK+DjB1OcLIlsw9CFTb3+0S/PkAYkc/rwotIKhZdxQaIgY23Pfl +TYt9Hk8rihYidgIAU1DgWoQq2GXE1YZIUzQEmEPmpMxzAYMFqrsHb7URdpQYdcZGdqVG3CXUN0Af +YbToAtQdpck+BcCu25A2ysAsxm7BUJ8sj4iux1RGAlB1CjK5AzuqEKjmut8oEdysu60qgmo6TBFj +EYCYO6eTSLepiKI6Kl3o2xSsRaUJZpQaBaqfojB3FCw26dkRgVjnqtqGGOEIXJRWPGlqCOqsc1ad +HhHluwlEkTvYhapaay6qcUUgfFXlKiahtnAcj4VnXZoA1ZOB+6Cq4wieoy27rAhgSikF4ogAIFnK +Mg2i8gDEd5NdlWXFcwEn0TsLezUYGFZ1iVXx1CPQ1GnaOhVvMkMjy+YaKw+0aKisycVKN9S4OccI +0Pdu+nTQ8Eastl25lbc6z14WowKAIaoaVMzGP2/7XME2m8mfzMDYVHyKlxuBedaoQkbbTvF2zVM3 +BqShqFFRxdWFrzKHI23JiiBEZU6jeB1TYPtVE9OMKLAFmfrn8ejsqLlGtMJUz1bVF4DdpbSaAYJx +40UdCnVlRR2BMdnWJmMOwDWq4pNtt2nONmxidwMw5aRtJRQU0fed6tlkhL2xrH6dCtam7uAmigAC +TTsgAWoIlrltZqjEw0UuNyMrqLDufjkA56Y+bR2vZgo5LBFxygCwzqb7oVWjny+2ibS6KgHFdmHa +G+VNURVyU71jd9eR0JPJCVBT80jOGLjvuUbsanq+Y2F3G9A01JcRiYMATZhiE7xpx0D1DBZ29RCC +hDlWSaSE2u1pds6AhjOSgWubi05u1UkTpWTZ9G6NO5a6H7HPRAAG5BMTxssDYCk00TPnoI4lAuv2 +SlNG0WqQDcCsNaTF62hiFwFQnRRo1yixqCDM2jEWtdCyZd0YSDhywxDM2jB1MGGEWuUO+58ApO66 +btoCUE0QUZ71480cFMbXaC76wg50BlLa5kYTQrDoJ8AspQCAQdf3gt44BCbT6QvHFxkBerCN242d +g0mUdgImcdqmbFEwNBVUo04403WwhdXYF3WGVGWgMEOE/KocQMtzti2MNV8EFrVhEwe8EBgW9WTY +4kKoefBsrHtT7BSrwwnXtNkvVZVRAKewynwHZnNfq6nTA7Cby11nAjDZzsLYkrVtCAIMMq6VI188 +rhYDw6a2VzYxGAGY62IbR1OktZkrxkR0qqzd27ueC9TNDE5hQzBswbnrBo35jUC1mpOsAti6alWs +xVY3gFdtqoITgHE2abrwXo3AtPhdRhHk0hSv7KlpNVFSNHS8pOYYS4FhRoBhFjNuk5iWAE0SznUL +oVFSmHJGJkczn8UGrere0AcxKvJss7OYPx7z1op5mVA/IwQZy7KreqWGfw4WgyvsjGag6y2uFEYA +YLFqkLAQuWc5oq9NR0z8TNC2mYzIlWVExuDgonirhuYQQVHjMorzKaOpkFQg1aBA0ClVQ1RvAEDJ +ySiqBSu0GSMgSSe4xJUAWNHy6j1QBKqmFnbQCQLx6hQ2BxlIWp0IHrWZESyatuNisngdUMC2CsB6 +BzR+j1ByVgu/m36cRnnsQDJ3q3jEFEFfubRhPRewhif7IsXOmq+oiKaPtC7q+u+ee3xd02CsZBnL +64qF50SmIV6NAUk0GT9eNNayouP/8PDHMaVD1bDEoRZqOJtxmzpVFM/hHrC2QV01eSZGZE6cD8vA +Rb1aOdueWtTrnjHHQqemTbeEB0bMkxE7/c2cikVnRrZsnO7Yyxj6Ukr7pkgEVDNuWfxj2znq6hKr +KmcnC5KpMBn1NNVv42wIdApqpAjbLYsuzag7wkMfxyNg8iqJsOds8afiRwBtCBXSqnRn3L/WxdHK +wLAoWeQ6ZQTFgp7FAheIdTVBIg48ROBYuHQES226K0q0DIClziZI9POgrCgBfQ4UU4LQcGXvLgL7 +6hZrCIA5qtIdbF/P2B0VcIv4k3K1kFC5lY9XzhvpE5M/Ts5OlRia/wFQpUmXAFq6utFr7AyA0TkJ +m6HUHIuimWcIbDKrs4QEEZRUsCxF58Ta0dF/zbVW2OHPwJB0NtCo6YtbU72jSPzWvVidXdnrAd0n +M3w8Rn0TCEQZCfWoIE1BZ3OPHCA4qaRHcfBcoF1L1+hHxtSMLL1SQx6B9q4elEHwojmNVfxaCEzK +FhU9qwXlUaZrYkBGK1jtlLXvlqA0JB07k8kr79My8uwXg5YwQxWINpPibaXovtBUb4LWlGggXJTt +onGiwaD3IF7b7RZz1QMYhK0uyZldSBkDlNbfYoRReqX0TBUUAFdJ5StsVzGwLH3DywJT/0Bx0QpE +awZATq5j3TJRnzy9K260vIymZTFgE7rK7NQ0zTkAYFx10CW0RQ2jDGTxnw9F+1XFJQ/AFHVrUcsK +kZqLN6kFU2Y36TQ4h0ibKokUOWFgNqHQJzgisCmj/skyO/VZUkqXsnAsnrsaSqfA2exFA/vQei5m +3JYkM7T4FDtV3RAzJo7xnqf0LpyhtbInUbcXbFvVUx7EKYTnCCxDL3I6IgJTtIwDm+KId1XXQytB +EeAQy+iKxAZgNdFlNlsJ5hNyIxacikPeVgaqX22YMt1VXlgNZWDJKhBKnpMANRgGBAQ127GtDRn5 +JOVlWVd5k02vYBadWq3dTUIITFJJ6kkB9bfq8Ooah5YUIVjNsFAEa1x031msu6V7eSUREMlK5niw +iC62LWnjJsC2i/qZ1X+OrzKvPgEZQXTOVE1oAWBPj65sdyJsUbdY67MAwLNpb3FRfrdYzJ3Clje+ +KavljCJIP58W+3zj4GXxmYwaHiuo1ZveYNEKAGv6T+HosgCTbmKSdkIwFbM9lodoFw== + + + 3WjJKf9cwLmopKaTBArW1NjCHi5BITFk5n+y2Jok2vObkqXl4rakGDF3WTcQtasQY1M7lFWUglaR +an7Bcjbh48oT3cHx9aE5rUXever2Rz5LIymoNqgp+kiROL4K5yIK0maGztp6n4I5E0xs48uqOWk4 +/l4Shy95BWi+OYLVoVMsP7VInua4ApJbKz01pWTu+LArl2zuedntGViqMrWY9wzBS995ODJVUOky +Hq6KdC06fsG05JL5fMoo47MLniTxaGFfZVlgdEez5aituryLuH6gLej55kDtQAsw9IBIEbuNwWHN +xi6N/4iajbC1SUMnhTBX1pLAJb+oZFOJe1JbybZLy7kJ7YEqgj31CxH0FAZx/yEwaQqDk0KZOcfg +OOt49TwxzVYpxWlQlJTACHDyWPR+FZFVOFVTtsNZR6ZlswstRargMDUlTBJ/sYqBRQdtIoNen5Wx +fTerbpsmC4iBzmdfZS+pbtfpHlAAaySycPIZA8NiW9y6KILuEsvmEkMEq85DDUlhW8nR6vYqApu5 +clAkKYIezc2StILUrm0ryqvzgpPQNgqy+q6Wop9Xb2NPCUDgomF+CvXy51eOYq/e6VGqpY32ZFRs +aQshWFZEQQ9itnkoG1+3HCwFsTTLz5FYIX8enXo6CaJEOOrMa3VQqgCYimZKdD90nV08WhvmqKtg +6Z+uSfNdZt1KK7r+LB9ZHA74+aLLUG1wbGnLJZpuXr0GSQKKz30tTqeKCws4AALVlo/MyxuApVks +Wj132LRWTdO2YxvY2DKB5lWx9tRlDVAjsGi/yM+gaHvi1CwyGoBr1qTXJioZtkya/b021X0q5m9r +jm+RAEXFCIuevaGkdAZqyFnSxxlBsLNOQu1zAffMMzrqjMDIaYvclm1KgKVkKrRJQwRHPUdG/qTn +Au7zkBwnBraUZDkBhMA1WQ69ZDMBEEZXu5Z00lZMAFSWRUuqA/CS9WRSFs8mALOdBBOJiuQuemhj +1QNmhNZypzQdtwbnVNMUWwCCHq8I5qUjUEmNW3+NGzb2sxhIqmQlJD6togg0PwY3Q5aISIFEhTDb +W9iFGS96yI6sYh1fTbhM6qpBAmQDSuxcFmBZrGFr/fN2moSCFzI7chUCAuaqMVDj7sn5jyoev9Ts +dlJZZTIumkJO3g+doXpO0U7jETgr2L2snxnT4yi4GGYdbkcBnoHSl2leBQD1fFni4xIiU2QI7KQS +NFzmktzUYiCMoNBUJLkfZcSiZzF6xiq2tTOCZNMKsOi6pSxOEVISV8OWS+wyMUQdbtmBUc4lOwaQ +uqDMem4wmMeM5G8KbmifCzhIMm/qMtEDdXbDntAkHSB5nanZJpxM0pXVcvMHIG2RDOwqD0bGdCmS +qf1c90DJZY3d/MSNVc9uqB8VgIsJDgrNqSLj+JCCqa6i/kcWsAzMTXlLWYyqDeamx6U0wQetj8UQ +tG5r17IqrRqBQkszq/wLWMDpuZmquhoNb+DZwsOjynPP4E6c6614+8rT2BoAO3dlF0LPguzCchJG +HRbqJk8WhkM3iMRqoGOqYc2mc0TW28zFI5lAETMtm7li6HAygSWJBF1flQVC1AQMdOlJaqDwUD1q +wV6miSHoE5z1eBqFZ56xUzGrnOzHFsg1GhWv5NkCEFa7zCPNKkaH7VK0X5b4hC5f8fpEc12h+1rO +oeHYV/UXUy6FYLWgZTbFI7Kd+YzjMikXZWKzgJ+4vyMntlpwUHTXyJo6exWDZZxEDqE+4wippA1F +nsDPKO7aJIAQydrRYOosmktk54ZGedUUjZZjiQHhNUVlQlC0IHQVrfnOMKaclY8Uen1G0ec+aVTT +wzj1rEskWWAEwJq5hBFQ3ogRKC7IqKFIjMqXIvzqYp2SCIKAY5P0mmp6npzBfiaJCUH6SjkImq+g +52oixy2fC5i6Lv2VGD4CV8GrdkGSCDsDLeaEOROi1EX2Gj6jpI2+boosXMzkkENqsQc4khxo5c+L +JZmSuXFDT2OAoZNDsJKvqqkstDIZrUQUAFiDErCIgxyARQ46wvZf52gIllkRaIiQEm9a1OklCULB +DIPISRCMIJhtgp5AluAu8WdEMCebXSrnKMdIZz0FAR7EitnKOoqU9cYIZjuUHkzaA7BvLDo7KCtO +112wVLNqodto+kGU/A3hIefaocKo68C0htgPiUjdgOcCTnLyOlgCQIzmL45cHoGBKRVB0LMYo5my +0Q4gxl7agI5PC4xGg99vxiEmUSddHrOc9MAc7qqziCIYzyhdmwoayRxSOYvgpotj0QTixdL6Iu/u +Aqy16qo1vvY89MipUc8ou109uH1uYtK9pDVENkQZwQxyR9cMRf4YCPqJADUkjEAbwmzpb4g3K966 +yOmNZmeYIud5MrBE3fAtByLgUbbVoOwaRGDq01gOADUL3QLQ9Lmw2oHT2M+qVD7uwOySBBs8V9Op +sr0qJLfskx0L0oPImLPGOw0eVSo6ibIVMQjJzsPj+ueNFYEhaA9Ez3VHoKJzUgS0NZu2lc0DgHpE +ELQQmUYhuTHoZ1vxvJUEI2I/nZQs8zf24zqopqjgpUg3I4iW1RU1vIknu7LuwJrtHaIVKYm3dsYe +oRJJEHWBT9X0oEHkqNszOnWnFlA0XR+AmkjvVj2e1Ky6OigN/Rmf+ZXAuChvz+h8tEYAgzuJhQfP +5RwUgCUSgIUGJIcwWARv7keZAx/yIAQ4+FITINqRStIAlYchJK2qoId7I5+wVgRhNhHHdgltjzYN +k1VlCJLiG53mTAu4STkeyUPFYg9Np5aaBAiUjLLgDl5gHYvKm32w2Ow8W3ZI0JR9rNChp6hCTxRH +sGq4QQ8YEFCcvqZEEYLVhKnuXVQjREz5wM6I5wpObDAGjn8oOMw6DlKjA4FzVnorJz0iUKMHoSvU +WBKFUtwILGoMloVZQ9J9mfVpKo0juVuhH7OY22xRscimKtfWUcdUUFcs1uGhGKXwVjYVrPmjLoKo +mRtYHQgmnjCnanWgXmtJZAQjiBYxNQv9QtWhf6ByRFinKDjnQQhSJCmxqsLt56JOiZb0BDrJH2kZ +tRBET5RBcFnUzC9WKSmsQQxEXdHnFHClJDQnW7HMaBSi9wrOdmJEMtTJ/2vJyUIaArMmxsw9yFoZ +G4PVLd39tz2RC4FFkwlnS9Eo/bx6MUdUoXQUzRpvaiVveqBdK2ZGIGVUyljAVcMxRkRx+RFBEswx +DhA05yDOFrE/w/tcXpgcK8gzeS/gaum8NWtIpmZNHaITTM8kUBSKAnXnKMn0umJnsCimo+ErzXM7 +J+BglKlRVrQaKINVi7EsSPQDWDpvrLxTlsTVZFdOLlJfLgemNMygQcxkNV4KnXq7+H4lDDaVVRN6 +aQTuFbwoYXXWHIOQNGJqwb3FshgpYqoWf49kWk7Gwkc9Vs7tSZqisHm90DWkq2QmCmFg5QhsNou/ +zQYUpRmTaHLPSFYdAr0DlqySNUOp8aEKJlZN/n7KHxOk1PW9oUqmHZ0dVA8zybh7AedmRylQ4dBj +gr20AnkInl9GItjDbIW9MutQ9wJW0d7PcWIdAstBk+RNhC0XjsLOrEXJqheV0h9a1XDeOQEyRkt0 +5+pIMb9XcLPaETDGUs5B/Dwr+7u13+dInlNNwC+rBIjgm/L51QBF+mMQgQrXRUy6mYsDPx/A0E12 +qzzXz59D3EffED1UALCi/oKlW1EmYp3msFIyLo4kXgeDP7R5oRtLFpg4VN418n0lXAEQ9LqCv4dX +Sn71veh1bQkExjJIpNOscshracHGnMLUKP6xECTZ49+IkrEmtltnXSuoI4DiamVFgqgIGnsDHbxk +VWmChfrEh6mF8mJtwg3ZVahMXVJ/kdRhISVFRN7C8lfpmmeWLbNlfs/4MtRdwBLs5aMoCtQQKMdk +viG+LHj8jfiCGZurlvnhmkTLGi0QvkQ59LSsqE1aKRkMYLSzQV+y1MrD1hpGXFAPwR0M8aKmeXNx +wL6RBYWnwnBNIsUJ0zPuBRzXFhz4+QYc2YoRmnFC4a2fWJtR9eY1r80BmZXAFry6zLdFhS1GmtId +qwcKBarFwQvXDWEeHLhimpTxa0oYyKN8RhgBdYhg80xjW8ccw3qBY1KAEl8XVmE8+ZBoHTesSYaq +/rJSqJZnDzoYGIhJuFJDDksIFqIBy+cloQw9mzR0TU4BychL2Ypg58CwcNRqsS3Lbl/Qo1XVMRms +1g36M4to5Hr8BOt0yfhU20YpEpFX5U1cmLAZgzu46eOsBmbwEoIJnmPi3hJHuUpipSQz5AxIGJkL +UZYVzd5VlvuCbsnIMx3knK53dkhhSxocNQm4Jha1RecWr/cFo4WNwZTXL7UqwyorCCROubk4Yrgq +fpyWm933MnRzrDIHySK834AxAtPKjVZSJGJwwHtJvkTVMgzInEtSo21oi2ezYx6weqBQwAg6eGF/ +54B1RaUjbShQoIo0oba39f0yrBd4gDz6ydd/t3v3/vjqm/ev3r558e4vNz8H0E//689u/u6r9+9e +vfnu5qdf/fnF9y/3r19Suek//+4v37/82c3/gY32Dzb6xZGb/J/wF7fR7ycqSYvOVKw/BIoWVUcH +/ZSq1S4UVHb1xoPW8068TSHtoFtXFixkzN5vwJa8Ms8mK6o5loB5oaiMJ6AOH+eODG2pPEgZkXaY +vF9HT8E4b0UidKQzn9UbCRAgI+jEWlvfK8N6gQM4enQ4t1CBX/hhpjryYNMEqoG+xAy6O/IVN3xW +D0qg6yYT10k35nIyHaImpfJ+A5YqJkwwb+LIMTqMx52Dzao6oHJ3TiwFXVtM4ArrBmsHCgWMoIMX +Syl1WGc+njBSIEBlr1JrbX2/DOsFHgh7A97ahKWVQYvVGyX4xhuwdiNxNepVQ5Fy0LG4Kl1NZ9wF +vVcwU9GV+w0Yyy6Z34jLxeLUq7bBtJJjh30jbivQ+NaxpVREHFF2oLxeWavgwBXYRqQze5LH9wtQ +WaukWlvfKcN6gQHC2hkLWOPtAiteFUTXJeRIt4yA9VFJe412owPejYCQ7LRXdlFVmTdZbCcPlSRJ +phdMXF3VWlNV1lcHKnNDmeOmLS7rsGywdiAT0MUKQwPHBEakMx/SHgkQoDJXibW2vluG9ZwDzFuw +OttS6baMOdBNGKB0t0i3vIBeTwYBRk6XRHclpMx3fKGJ0FkLlpUgjnhm9X4DThbIxXrChVSFJuVQ +uGul8I4pQO4aOjl13ltbXHMhbrB2oFCgg6PgwIdsRqwLnkfcUiBAZa5Sa219vwzrBR4IdzFvCCVs +bKRuoXHVMK2DrqSIdDVZ8neQFZa7xlm8GpGxBsyRu9+ApTI208rVRmnSSZ4BqpxisAhQOZtqXDZt +o9TwG7B2oFBg017Agb2QI9aF65eNFAhQOavUWlvfL8N6gQfC2YWO/pFsiZUK2IPOs9bhkh+epu7W +j2o3p8iWWmpj1HiDMNtBA1gLP6GfPq1i5UWpjTdjiSk1TAio7BVz3bfF/Bg1eAyrBw== + + + EgWKQMHhNlqkQZEuPX7SCRCgcleJdW17tzrSMw4wc/O6Vrp/bclLIOkwg3Y68jaILKjoNaA7luwG +HZFLWd/WtDK/B0dLnJ9RJVlE7GsBm1lWXAeqAVLWmjdtMcw7rxusHSgU2OAYWJM7HNagcWZHAMOU +tUprb+n7aijPGICsXVjDzSmwrnB+209nsN5M1K/WYr+MMbgkxV/bYvxVKIbOZ6VvFddLvJVDLFiV +vXiYmXdiY/iWfKXDgLID+e368Q7VOIXD2eddfzvDlLdKp5+hvZuGctv3LzRPdo8zT34vzr1FnXvw +z7dTkVtFfryas21wIT6jkC4o6iJ7yHS834BLj97iUQvWY1dLgLWqjAYkflsSgG+LZfNi2WB1wORs +WgcOnH05YsX7RuqWAgEyBZ1a17b3y2E94wFJqi83GKkoYWLSJB3xfgMOnOtPBRzZ2sdk2ma1Lee4 +OqB2jPP6h7bouEzNo+wQeTd/uoMLp5GOKOst+jE2rxegjqyS2tu6HnWs572/lrHI6SyzdI6ikvcb +cEDflVbXBByykWnBF+gcvLQ5oPK2rHnZtE1yVn7A2oFCgbJXwb3gmsNa7cCso0CAjKBT29u6frky +bmc8uJKxSGk52Xw0FoR0YFQignI3URoUcgx0NJ06S4oeqNxFd9qmLYY2W95g7UChQLmr4F6402Et +Vu3JUSBA5a5S69r2fjmsZzy4lr2IRJCLdWUnisxdB5VTJAzsLucasnKX66oaULnbos5da5vlfMKA +tQOZAP28Qnthcoe02EVKjgABKnOVWNe2d8th3XLgSvYiJ4ktqgljacL7DThwisgzqfurhlmrslSL +3CdlQO4aVZBaNm3xqGhcNlg7UChQ5io4Wc1FhzVbjpOjQICMoFPr2vZ+OaxnPLiCvUjvr6sMWY2a +CeHAgbNyGRgXBdL2yf0Sp70ClbOLyEbXFg+jKtCwdqBQoJxVMN7BMGu5asWa7fSLo0CAylml1rXt +/XJYz3hwNXsR5RWlsJF7CvP37zfgwLks3I8Wdd4lOTCKBbqDTvFk0R4s5r3M523nXJczrAoUCmzm +Cxh2GTkh7LDimZ2wpUCAikCpdW17vxzWMx5cy2LE6/+aOnGoxsj9GVhv1EBgqmp+9L7BRlkdUPuW +og6Pa9uDmg5rBxIFNjwGtuTLjjV1JaRTkLzC0qkd2vZ+OawbHlzXaMSdojUZPToAcH8GdiXmF/NN +4NgKK4oa2lXdFXRx47xsW9YQwhnKDqTX6+c7WI9WOKTD/Nf3C9Dkk/lLrK3vlGE9Y8A3nAby7xDb ++pDpyIbMv4n1GLNFNrz16MCF0wueca1oOi7lo1xYdbhFHyYjpmNpWEpS8m2TOPMHrA7orUcHDhZ3 +dljl6NZIgQDZ/OzUura9X8EXEt/wQBTFLzIc6RIizZfADfB+A8ZchKKVufkgBDLLVZnuHCSgMpYL +Rvm2WNl25X2xY3VAoYARdHDQrDqHdLETKo4AASpflVjXtnfLkJ5z4HrGIypQRfz8VA/lfgPO5Plh +chsVCkJ+2ckPULAk5UOA3LWGVSbT2BYP1JTQBqQOJu/XsVGwpT97pHhVYdi8n2HKWSW1t+xdcijP +un8tuxErz6egVltRo7xD8UKSxEupctorzTmrn73K2TQDKmP5xj7fFhdzUsYqVgdkAkyaJGWsHmpy +SMFaWuXCiU6AAJmATqxr27vlsG45cDWjMRZNOMEbTfPSmavg3E8WVT6kygt6NebyGUEDKnP5LPDQ +tsmplgFrBwoFikDBwRdoV6zBzkM7CgSo3FVqXdveL4f1jAfXshvxdgOJ3EfO7L3fgPGeQPb84OUE +Ue0FTbSjmwUGIPdtxT03btrSxSzrBmsHCgU292dlTmv6LkUaOGw1EhBcNM0R69r2bnWkZxy4htWI +QmmeNd6FJ4buN+DkL3Lgy1Fp0kkWM17N0MLigMpXPhE4tMUqi8pXw9qBQoEi6GAt1+ywYrClrBsK +BKiMVWpdW99dw3rGg6tZjbh0esRqnnUn6+Bk18zi5Rl0KIRzSWdlb63qJCagcodvCxnawrZTlL2G +tQOFAkXQwZrY6bDS0aa0oUCAyl6ldmjbu2tYz3hwLauRrhsJsiSyzV0PNQ2malImUhazimG+etWA +2rUqKRhDW673tMHagXntrOlQvaGh48S6HAbU9wtQP6+0Dm17r9YLsGzz9gq2IpKbm9qixTQFD9YT +NNgLOqC0GfScZj8TbNaEOZ215avjNlg7cFzVBtaKTQPW2sIZAbV11nZae8veKYdywwC2FT9myf1b +GHF0SF/nQzfiHLiXfcei/msRe00rhSW6Uaw5IDEjY0XQ2sa2GX38qsu5YvIK9EacA3cNy2HtmSCO +Ap8J4qh1bXu/3BH3Mx5cwYgDpGtVPw4WEbrfQN2NFStuFxL1sRsz8HT0Gh1Q+TqH1Ma2GZ2nSxix +OiAToGxVaNCr2hxOS2f27xcgc7XT6tr2XhnSs/5fzYLDKy8WHa6INbXuN+B+1yjWxshN5rHWDKLb +GtLqgMyaWa4v9m3zYjtUx+qAQoGOTd/NqIDXiHXh+gYjBQJU5iq1rm3vV8d6zoNrmXF4T0gu6lOc +mzFXoZjXGYW3ISU9S7CwqzNRfaPogMpbVa56W1zNQUNvgtTB+PUmTQQarQaQwxnsHjz3fgEqZ5VW +17Z3qmM96//VjDi8VaXpmFGh1/sNOHMxDqY3Rg3H6T2N0Dcq5dKBytsl5U1bANKp2wGrAwoFikDB +0W5lcViDXSPgKBCgclepdW17vzrWcx5cy4jDijcxq4GqyvAApTKwTG5aNEwvhW7pupccO4w71uQ8 +rGtJ005dfopyAJoi7KB4iN9KDinO4PcwfX3we1in1LXtfXJYt92/hgFHwl6HkM5E3m/A/dQ4VSzS +BFxNOIZugUpYHVDZSmdStm3p/qERawcKBYqgg/VCEIc1WGFwR4EAlbFKrWvru2tYz3hwNQMOl82i +A1nx+rD7DTiZyooEU9EgBOoJQQC2sAYHVO6EUpZN22Y6q8PaBkVW/bQD2K99wRr65tQpCONGptQO +bXt3DesZD65lwCENVLOGc/5Dn7wOPFe9QooLLpKxE43la1CnCAG1b61qjN/aNryTK26wDkCzbgew +FrgcsK79FqxOwWphrYFa17b3y2Hd8OBqVhyWLWs6cDBaffJ2MJUzFWCx8Fwf+SqaaBz3krLO5235 +AuoN1g4kCgyBgaUI/YB0reXs/QjTT3dSXUvrU8e46f5/nA2XQUSta3L2y/0GLFfiPeOqgdK/anVp +sG6hRef6wUCsh5hb3bSN7ri1YnVAb8M5sJRKG7EuXP5vpECAvIF2antb16+O9ZwHV7Dh8EqcdREf +SrLaJg6cLfCPN6yEnojW9CIRro9hQObLIiWihrZ49nZOI1YHFAp0ZBRsFYcc0tCZ3QkI/XC8JzZ4 +Fmq3DOk5B65mxuUeI0x8NO9+A86uKmZsRayHpKU3sELrvDqg8paP8w9tgx2GNqQOltyJQQeO/Q6B +jjRYpTFHgACNt23b1vWqYz3nwLWMOCztWZoaMdk4q8DMlwgztalY+NeuyoFRbR2mjOVK974llhQO +G5QOSC9Xtiqw61YOJSZkS6mY/nYBKluV0N7Wdalj3Xb+agYcXuRkp3Ko5N79Bpy5zOkzudioaTxZ +71ZAKb4sDqic5SJVQ1uq0dhGrA4oFCgCBVsFUIcU67hYgVolQIDKWyW2t3XdMqTnHLiW+YY3XFmm +GUmk+zOwRNBzcwZztP0Dpp+DMV/w5KIG9bXlIpdaO4wDrEtJB45W0N3hDHzf5Ph6ARpfWwljW9el +jvW8+9ew36hysKX6rnOvQ9QP5GW5twPv8ipx0fk2K1uXuiQHVL5SYd6x7YJVQ+KI1QGFAuVsB2vh +Moe1l2t1FAhQOavU9rZDdxXrOQ+uZr/l7sWLfKfq/QaMvrmmZKhtW+yOr3ldlg5T1iZLmOwtqZDy +gNAB5eX6+Q6mi1NHpL1Sp3u/AJWzalhry6GfivO889cy3HBsqXwlYZ719OQIrlbnis7q8eimxa6K +a6rZ9wN6ZXYZptoWJWJSKadYR+Cs6YgDWB3EA9aSWzijgIDGW6PWte39MrfzGQ+uZrhhvbCop/Ep +vHt/BtaKmQi0PcCNfA9pE1A716JmQPq2pdUzrB3Y484D2G769VhNVvb3ty5qO6XWrvfI4dv0/jF2 +2/Jvl0VZ0NfizJb7AZi13h/dR7CKs513MrsfRUDEh6r3srl2G0yjkWQQDI/ydYAOB1bJXzYvYxh/ +slNlLY32jnDbx2udsAO8xVId6MLm+w04W8oYkrpmUXRTanqlRGnRA7lbeOueBjGsbeQyiSPWDhQK +dBQU3AP6DmuwC2gdBQI0xgq1va3rV8d6zoOrWWgF14oOXLTzNA6Mtx3J/ShYgSNqvYpkV36UxWrj +JPXe4vUms1rF1laqo45YO1AoUPYqONr1Vg5r0MtIHQEMU+YqrdbSdaqjPGfAtQw0vB3EarsFPWTt +oBmP9+ntIuq76heg470pyYGUr2nWmI+1xPP3NWxwdmByq7lD43DDzKzmGN3x7F8vIGPraom80tJ1 +qeM86/3VTLSKs1uVUBLL92fgJoGcOssF4Lygi14klUpsDqispcoVY9tg27nD6oFEgSLoW3+SM2QO +a7AiuY4CASp3lVrXtvfLYT3jwbWMtErSWc0/zPq+PwMbDT1sbhcQLVi0IjigsGbTLHDJU4/Og+jF +NuGbelWy2Mg6gWe9u6q/VYDGT6HQte09cQjPen0N2wxvggtaxWYuapsNYLd38d3aNNHkSkTs16JW +nNWXpI26aaDI2ga8N2SL1QOJAmWqgrvK5rD2ayQcBQJUziq1rm3vl8N6xoOr2Wa4gdaoGa2rqgYO +nPodbUCwlDpKluOBt02hDOtAZS8M+nnbteW8wdqBQoEi6GB/DZZgxdKCKWwoEKCxt5y19d01rGc8 +uJaJRsJIXcWUcnC/Aae+sWNhxWrMiTp1qKhVBypzYGNvZ21z01pDTrVQYHS5EANYzGeHNHJO40iA +AJW5Sqxr63urSM84cN0DdcMoY0rm/Rm0yTU3dAObea9S1F2kexcIqPxZ2lrP2vbiLIbVA9fY+duh +VBV3RDpM6e5eIKAx2HxqbqL2bhnWLQe++EDdI6uxfMgU/P2/W3EWYB6sgHV7vM6DrYzKXJvFPK3g +ylwxS5XVNFecZa50q+66aRtdCQ/DGl0JDzMXPdjKqHisVnDFU+CKs3hqe1vXr471nAdXMh3nihEX +i/5ocRYP5koq2LFVcpus4Ap2TCPwrjgLdiyHseW6SBlpQ+ggrjSLB1sRlY7Qiq34V7vCLJ5M17b3 +xuE86/nVqnhWvA9HrWErzOLBVkJlrnRxveSXytll7Bx88xVYlK9R9szedp3likqP1QFdYRYPthIq +HqsVW/EUuMIsnlrXtvfLYT3jwbWqeMIQ52DHy7QwiwdbCRWkt8xa01eKrWDf+BbWoQ== + + + MAvyIdSx5erjRIrTAV1ZFg+2AiodpxVa8W93RVk8pa5t75PDedb/qxXxrFjxW/NktCiLh1r5FAS2 +ddUEaC60AjjxrH9zQOWs5lD2tuusddYdVgfsRVk81MqneKRWaMUT4IqyeGJd294th3XLgWsV8ax4 +/8aqeoQ6kTzYyqfgFOFrhFyhFeyalhd1RVmQDXPYtGyu2J7h9E4zK8niwVY8peO0Iiv+7a4gi6fU +te19cjjP+n+NAp74/lkNfyvI4sFWOgWB1YKTUmQF+6UZ1a4gC4LVOnFtQVBmLZ9nWDvQFWTxYCud +4rGame8pcN4AT61r2/vlsJ7x4FrWI+0C3UjTgiwebOUgaIYknXVSZAWBesDYFWRBcK2bls1VQTac +zVdM1nIsHmyFUzpOK7Di3+6KsXhKXdvqbFfDedb/K1mORJrVs7ViLCNYyqYgEOS4r7siwLX5Ci3a +t2Lp6q5tWVs7w9qBVoxlBEvZFI81dSWlU5C8ktKpHdr2fjmsGx5c1XakabJqgRUrxjKCpXIK0iLX +HjQtsUIzatHohRZjof6Fbbtec9Uh7EArxTKCpWhKRzmsJn23K8TiyRxXydqv+ij5DPi/RCGWGcMU +toS7pejAVjJlLquV9bbiKrAybEK6Qiwz3u41p7xpG+Vu5AFrB3pL0YGtZIrHasVVPAWuEIun1rVt +Tgob1jMefHn+JyKVyz+aK8TiwVYyBUnt1ztIcRXsVuegFWKZ6UI2La5pbfFWajXsDWsHukIsHqw1 +UzxSK67iCXCFWDyxrm3vVkd6xoGrGYsFc1DVu2CFWDxYa6YguYucZbbiKjPduLcEB+SuZVxN27Zg +MPR7JARph7lCLB7c76F0SLW8in9/L8TiSe0te5ccyrPuX8tOLM1fsiLHqz3USqYgtXOOvuYKd4xv +hx4KsSAPtMKbawuLOWoAx7B2YC/E4qF29NYjteIqngBXiMUT69r2bjmsWw5czVAEGqqlzlkhFg+2 +kikz3iuZyliIBfvWsh6atEIsyAdQltKmbZbr4gesHegKsXiwlUzxWK24iqfAFWLx1Lq2vV8O6xkP +rmUrAuYk93y4QiwebCVTkN5VDnpacRUEznXZFmLBLqul4NpmvGw7bLB2oCvE4sFaM8UjteIqngBX +iMUT69r2bnWkZxy4hrWIQqlaoUEtxOLBVjIFSa1yP5cVV0Hgsq6+4orytSR1/VjbAhazRTAVawe6 +QiwjWEqmeKxWXMVT4AqxeGpdW99dw3rGg6tZizi6VvXVCrF4cL8qsOBNaLN5X23awhAGB1TuNKl6 +79oWdpmPWDvQFWIZwTFYW8Ua2ZwcKRCgslepHdr27hrWMx5cy2JEGmazMmzuemjLQWVCDtGKYith +KfTTCH1BxkWj5L1liDoZHcoOzDZvPTQsWaeo4tQqCP7tDNOPK52+Ze+QQzn2/VpZoERssJstimkJ +HiynRKkTZiPqlYrYh9iKA9qMyZrE6drWbMd1O9YOHFe0gaViyoiVS6uMBGgRlpHW3rJ3yqHcMOA/ +7ADfjAeBkh6r6AacA1u5lDnDDtPUzpDCKrCk8PJdDyRm5GiHGV1bDK+pHmdYO9AbcA7ctSuHtV+x +4yhwRVg8ta5t75fDesaDKxhweHxNLsfrRVg81MqlEKWzRniksAr2KsvpcVeEZc6o92hgztoGuwvU +Ye3AXoTFQ239O5z9Tkn3fleExdPq2vZedaTb/l/Nest4aXrUvUmLsHiwlUuZMxannEW5lQx37FqJ +dqecFmFBNvTwtrWNtjs5rNFvmlqExYOtXIrHaoVVPAWuCIun1rXt/XJYz3hwLRMOMNeg5SS0CIuH +ar0UpFZTVK2wCvasRg37WBEW5IIqVq5tdHXRFWmH9SIsHmrlUjxOK6zi3++KsHhaXdveKYd12/+r +GXCAOa2qIlgRFg+2cilIb02q9UphFeyb3v3mirAgH1rUsbG28Iqm56QMawe6IiwebOVSPFYrrOIp +cEVYPLWube+Xw3rGg2sZcIBZy+z0IiwjVCqmILmlBL13Y1betqS2hxZhQSjFJYaWyVJIHEoPNCXY +Qa1ciscZ/B6mrw9+D+uUura9Tw7rtvvXMN5I2GsaoBVh8WArl4Kk5qoeA72fMWNZWi0bZEVYaG8J +6rOwtvij3YKoWDvQFWEZwXL41mO1wiqeAleExVPr2vruGtYzHlzNeMNlUzRj0IqwjGDo5Sr96GX4 +JWcYgYuUn0s9v5hW6aKBUGubnc5qWPOgyKqPdgCLZeuQRrvU3hEgQOWuEju07d1SpGccuJbphgMc +VPpYCRYPBtYsVYWtXjiF/tAYBBiyHsAImoVIPZ4tx17bZqz3t26wdqArwTKC6WDHiDX27alTEMet +TKkd2vbuOqwbHlzNhkPaVs3vtRIsI1iKpSBQKyfGvjsUqyUex50ktnbetteyclg70EqwjGAumDIi +XW3M+/u1BMtIam/Z+9Qxbrr/H2fBpYIHPn2q5P0GbMVSQOGGRaylMaWsCgg3F5ezEixzCqaMurag +9IPFusHagd6Cc2ArluKxWlkVT4ErweKpdW17vxzWMx5cwYJLxUrguxIsHmzFUpDUmmdLJWM3A3Qr +5eaB3K2I96pv2+IV3lqXzLB2oCvB4sFaLcUjDZ0tnQBXgsUTGzwLtVsd6RkHrmbEpR4ddCVYPFir +pSC5pd/qwWVVsGs5teiAytu06O311hbP6mhcT5F2mCvB4sFWLMUjtbIqngBXgsUT69r2XjmsZxy4 +lgkHmNOid/WqeeyAVi+FqJWIoxZWwY6VqHVLzchI0a7v7S3x2mkNbRrKDrQSLB7YNSuH0sqq+Le7 +EiyeUNe2d8lh3XT+auZbwjxcvb7CSrB4sBVLQXJz1qiPlFXBrvVLBK0EC7JBL4h3bele6LrB2oGu +BIsHa7UUj9TKqngCXAkWT6xr27vVkZ5x4FrGG2Ce+xUPWoJlBEvsPGVnLkfbP1a7SS3a9gFE5riO +LfHkR64jRg9zUrKDrViKx2llVfzrXQkWT6lr27vksJ51/xrWG26fcmuFK8HiwVYshWhdtDi0lFXB +frV59bVWlK/9rK+1jZbu67B2oCvBMoKlWIrHamVVPAWuBIun1rX13TWsZzy4mvWWug/PlWAZwVXy +nhOeK9fbxAqfS6TONY0XFD3DSBIw1XzWFhSYdYPVA60OiwejK6AqgmIJmGo1OAqSszActa5t75fD +esaDa9lvOMRJLUurxOLBQMWqwlaVcfSFRiW3F+UjoPJmbbbpaltMSTXzTZB2mKvDMoJB07H13+ze +8bUuGwIEqLztloNr2ztrWM84cDXrDYlIWtPa6rCMYDkoS8Clx8o4Epyyi2hbHRYCJz1459vOan05 +rB1odVhGsJQRGLG2cvb+1uVtp9Ta9R45fJve/8fWYZljd7d4C86BtYLKHFHrHGqszDHaUWirxTJH +VOyHmi0wMSw7taPrMG+5ObBVUvEoteCKf3cvzeKJ7C29S8lQnnX8WmfsIl57GzR5UcuzeLAVUkFy +U9O8KCm5Qj2To/uuPAsyQQ/ku7Z4zF+1PcPaga48iwdbIRWP1UqueApceRZPrWvb++WwnvHgatZb +zM7bbOVZPNgKqRDBlosmZ6ixc6lo9Rsrz4KMSFUtZmu7oIa5bLB2oCvP4sFWS8Vj1aIrnoBensXT +2ltm5243lGcMuJbxFvOmPsr9BmqlVJBa9WtZ0RXsWJcaVqAFeVCqHhi0tst50RcPTG5NL+fFVDxS +K7viCXAlWjyxrm0+L/tyzoGrmXAR85T1CLqVaBnBUkyF6O319yU4GLtN4Eq0IB/WquVNrW1waolh +9UAr0eLBVkzFY7WyK54CV6LFU+va9n45rGc8uJYRB5hXOyllJVpGsNHQg+p60CqSj9rXbeGeRbdt +WVtcnarGGbc6yOq0eLCVVfE4rQCLf78r1uJpdW17nxzWs/5fw4oDrKBjbIu1jGC3k4W8jsVasF9a +Ps0Va0FwqJtiLTTlcN2MWD3QirV4cNfrHFYrwOIpcMVaPLWube+Xw3rGg6tZcairzOrnsGItHmxl +VYjgRRMoNRckomKpN1JYsRbaXyyB0rXV2+Ed1g50xVpGsJZFcFitAIunwBVr8dS6tr67hvWMB9ey +4kgsWaqkFmvx4NS3efQpBd1SuQAL9q1ZCqUVa6G1uuoFU65tWrWokFc0Vi0p1HMmBjDXVfFIrQCL +J8AVa/HEura+t4r0jAPXPXA3jLIWaxmhUlaFaO5+Li7AQv0zF4AVa6E5ZdqrawsGQNlg9UALkw5Q +KavikQ5T2nlBFmdD9EPhbqL+/+y963LkxrUm+gR8h/qjCHvHBo28AEhs/RIp2+NzaMth2TOKODHR +QbHZEke89LDZtrWf/qzvW5lAAiiSQHWTrGKXFBILC8j7ypXrnv2wulrHM7CVyVqyGLxPXfVJthZc +gZSEOOLi1Qhcqf5AgDguyyYlnogXM5eu8wmMQCyBMXLemdINvzUtEnfYQa05MPbg+EDB/cFB8MkI +3CV8MUYYdxuitTHdITLoGIHEDQappY7Fb8uALALJYzUhTAbMOrZmxk4EZ9ALD8kHL4LRCMOrNBMq +0AZcCirclQ7EptAMATOgXIFWfaECMvfrLXVli2xxrBf8go0pkUqYLSlFhEpz1Ougo5N8wOj0losS +KVpsTPBCXyudiYDN2eVEUqcKGLmaJvkxOtUV4n2oOGRcpJWiwuFnaDEEWxol/QqsKyRKstKXJHAx +NAdJYgDk3juOFej1BLbE0Syc0AnBuMILK2dL23HEGqkRlczUFmJkZefiBA4pZSEtXbpZUWYhJdSW ++apbBUaVu86t1bDd4Pr4TSBUNDTLOkRFGxYyWpcC0v8Y5qCaLvoxsQFjs8q3yPqy51dxbNG2ImD6 +yOq3RjNQBtB5FaXAMaooJIgobGAkrm1nhwmtnK2e+MvkLp2Hol7rW5ZdrGSV5R4s6xh5gkWr4/Vm +Mt6K+kYshKs1k5YgY2WbuJJyVqeNCacFExfNw6U04XNZey5aHTFROKagOJP0wPKzNUnG9yBJaU+2 +1qcMs63qNdsu30/ArefKqCNy1lKsCbXmqzmLswo7oa5tSgbQlpoJQqe6VOYb82/SDiMWHK9frRMe +BG1Hkr/65k/hze+v3x7dfvzws5Dzu/PbawArAN/85eb6r0Lz74TsF4WCj85/urjOXxz85T3emFJf +ff8///iHi0up5uB33U85Z373w59P/nLz9hw/BwfQvS++Xv3m31eX1/KqkG7dXvz48e78A44aOcNu +T0dfnP18cfn29vwa7+3qd3+6vuvf4X938ST7TfmVHGT/uL44E2A6z/IP/3l6+VG//PfDH16fXvE7 +dIK92tZx/Dp7HL++wDhkP88eyb8u3t79PHs08eutHtHP5xc//Xw3e0jp82cf082P/+f87O7o5uP1 +W+nf0c0je6Mf4Dvuf/n07sPsUQ7KPPtQv/nTm28u3/98+sbMHePF24w3vmdM+OY/Zw== + + + 9HhbyOTdx9sfPwqHf3Y+dxa06MwlTu08N9EUYX3ueH48/XD+h9vz//tRJmE+CR2VevYRXt98f3dx +d/YIlexH+YFf//3i8nz+/hyUefYR2rlDu/549d3Z3ek/F4wsL/LsA8OWmzu22/MPHy/nnxvp8zkU +6J6umwe6vp76ZYfA+d9zcvJwZx+Y92dekIvructx8/789vTu5nb2gvQFnh3Nvr/5eHt2/sfb0/c/ +X5zNPuIemYr8pLve8r1zcf0ICRkMxr7grjm+uXp/8+Hibs6meYoOkA97tO3ffXv+bvX1XtrbjnHs +pb3tHdFe2lszyi2R9vyXLO29uz0VtvfyLzcXH16ZvDdbiN+Le9sp7s3el3txby/u7cW9yaj24t5e +3PtixL3CvhaBb8lItlzk869O5Fswol0R+UQOOjr/5/nl9z+fvr3515dt+9Ijk2Lhazkwf7z8+Ai3 +8hmYzW2VDD7cvf32/J8Xp+jQAqknL/RiPMEfTz9++HBxen2kC7grvPTstXk7/xh++xLn8PyBzD+F +377EMbyEAmw7Nbt59+7D+d3Rc9C0F9r233GEO7ThL8G3wEvw7Oby5va//vWzijEz6fOvl/NVifHr +/Qb6hLF8eH9+9t3HR/bD7nEEs317Pny8fXd6dv792ekSxBsUen6pY/bgZHE/Xp7eHt9cf7g7vZ6/ +btOCL2BNWzrK3//7/c31+Qaj7AvukmxSVGU5e462XMVhygVj2W4lR2GXjOW/Z4/lv1+QB/nrzcX1 +3UlUX7yEPvL8+7hVTyJzsUP80Os0JizkG7adDdpI0bPYmrDda7RrktESI8m2EIPT24u7n6/O7+Yb +4HaJKMw+9n55RJmSDQefbvFAHuHF84GYbRYVfnHzB+K2eiDzqfIvL0GUX6UVfjE3sO1H5+XF3V9P +Lx6TJb/ws3N3ZOXlauLFO+6FFvLP57c/nWMmd4gJWrq5XuNaPF0H9i5DGyvUvnol6rQFXinbrUwz +Zu8xtP0eQ19WkMjxzc3l0e35+X/Ptmq+Rs+otxeXp/PturukxDCHs+PKb0/fXnycj7rp893Qbm63 +xDl/IG/nD+TtNg9k10TMP9/cvv/55vLmp193SDTZk7UdImuvhpjNj2DZcmL2asPYdpKYFa/HZfXV +7PRl4RTbvNVnj2TX9vrOedy+3pj92SzLPmb/vjG+bMz+bD/cXYvZX0DIt/1Imr3Jtv5Imi/h7NiR +tJNZFB7xKMnI2jLn+xfyuv8id/zWO2r8OBvLtp56zR7JrgTh/G22OfX459Pr6/PL788vz8+W6NOm +BZ/fIjTb0rrpIKcFX+wc+vbiw/vL07Pzq/Pruz+fvt+hw+jqVKqabZjcCelolf5dTX6awc+5o+av ++fx3+nyLKeXWn8TLcg1u8+k1eyS7xnsfI4z5z4l87Aq9W4BZ275HZusQtn6PzB7JrnB48yORnyfx +yrbsvneL/IPeXVxeLvF/utzmlX53e3M1fzD8+Pm1ko8wOZlh7DGP8dwy9vFFYq5mj+VH3Mk1Xzeu +Xz+/Uf/yX6e/zh6TUL6709tFlFK/315N+N3NfMnj5gUGcntOEXDucE7fvr24u/jnfHGqL/AC9pjr ++eM6O/t49fFxb6F8ZFmRF4houj4/nR3+cnZ6efbnm7fzx9YXeP7gs9m8RbZ6qfm/cAhzF3BY6oVE +ktPri6vTF0sNu6t56Iqwd4bZMsnu7NU4w8wfya5pP/bOMNui7t1fWDjRKeyaN8z8nGa75g6zgJRv ++6H0atxh5o9k1w6lnXSHmc1/7oY7zBe547feHebs1bjDzB/JrhhL9u4we3eYbTmMvgB3GPOluMMs +oPnbfhK/GneY+SPZNd57N91hFmDWtu+RV+MOM38ku8LhbZs7zFbbf3bHm2fBlltKPF5oDXcxa+AC +P8D9KjzZKjxdzo0dWISn68ALNb77SRu/+dObb5mz580yzdcshmh3jqjXm7dovhpwR7IWPU8C8Jei +pkvy5Owp2sMUrd5TtNdI0WYv656i7SnaK6Fov78VwJfNop1jCl4jPdtzaHt69mXSsy+aQXu19GzP +n+3p2ZdGz3KjzptlVvhXRtZmD/4LsuHtt82cbdN8ydtm9uD32+YL3zZf1m1Bf7349/nlXy9Pf32z +LNhxGx12qnJVzfae1Jn/2wIHyqzELlG+2/Orm8fSG+xYrpf5OUX2+VH2+VE+E9KtzNe2XJlK/l+u +5L+v5bf8/VperF6by/bF9dvzdxfXF/MNXLfn789P775dsN2yEs8+vn2OGB3XjuWI+fAeWWLmjm6X +csTM5Ea+tAQx28JDvcILCn9cctn4lnvqLxnLrvjq7xUW20sOHtvbu2lXWkQRtpy6bWhS2vrw+Zur +9zcfhC3/7uMjJGyXA/jiGHeIIJzeXtz9fHV+Nx/XdokwzNap/fKIcSobDj7d4oE8ogzNB2JeQhkx +eyCPOD/lA3FbPZD5pPmXXaHMu3GILpR6dukIfbVZET/LGbo7Jo6N1nRnHIj2AYB7c/LumZOXpSnc +Rq3S3py8blb25uS9OfkZx/NazckkLjAo2/LrRYRmb0Lem5D3JuT9NSOTke1NyGu6uz0q4r0JeW9C +3puQP792YkdNyK/J2Pr24t27j/NvM9l2UrBwOLtCDWanp/vw8fadcLbfL0vzPyi0vXYknf5lYxuU +efah/Xp+eXnzr7nju7z46ec7eV+cIQ/u7CGOi23vAsbdeXxzLaL79fx9Nym3V7q9qNJtf8ft46PZ +K92egpR+/dPt+fn118KBnX99cf324qebr/95cXN5fvf17fnbr29uT69/mr3V9tq4vTZur43ba+PW +jGw+H7ZXyb0MV2XCbKvL6X9fXH28e+Tqx3xJ0vfPjnj17DGdX8rDIpVPVuLF9D3fXpB/P8H+eimP +mG9VljiJe3yHUP41qZ0+vD8/k4Pr9jl84Z9dOnrVyprZJCot8WJpf1pwm9cwdvb3/34vvN4Go+wL +vgDj/Yg29wlUU3u9zV5vs9fbfEF6m6ilUb1NVOJQfbPX2+z1Nnu9zV5vs9fb7PU2O663uYwKjVfh +QrFXQj29Eur7KPztoBbqdebP2EAfte0qtlcZAfycesMXok/7HBrbRhxeTQ6N+RkbtjyHxvwV2fIc +GvMHsuU5NJ7nHpDt9ibe/uPz8uLur6cXj1kp9mfn/uzcn50bD2TLz859/qltOzuXUuVtPzY3EqZ3 +5ejc5536tLnflmN38Xruc04t6cALNb7PObVbOae+//n07c2/nuL+ot2hRF94doFd8eucnRRtH5H/ +7Fto9sWabx8hp7lb279fAMnmD+TX+QP5dcspwLZTs5t37z6c32FL3J6/XUSnd00G+I4j/TIEgM1X +9TVKAtuyKq/7PvG9aLbLollhqq/mouR8PuMl2IwlI5nPaLwEn2F8OXsk/7p4u8CdMH79/CNy80f0 +8/njnofZkNLnz89BfYlKjSfIor073NVeqbETSo16r9TYWlY4vBalxvyB7JUaOyD+7pUa23vs7pUa +20jJ90qNvVJjW5UaX5hodne6wNHyNQpm725Pz+5OL/9yczHfsVkLz1zj1NJz+2cezs7Z8uPph/M/ +3J7/34/n12fzOc5RqReISf/+7uLu7BEFVi6x4eu/X1wuyJUwKPP8mq/ZPrbXH6++Eyz+54Kh5UWe +fWRnT+dl9twjWabV2uI45/kjeUKBZ1tOhdeX7GjBefDu9uZq/nD48bMP5zWlbnqtqY7Kw9m3ttzd +zOenbl5gKPvcRYPB7XMX7XMXPbFqeb5M8qWlLnoSpdHfP97++PFSJnuX9IivM/fKApFiy4Wj50m5 +8kJ63iXxYXtV61r+8KvX4T02fxxb7jtWvjrfsQUj2vuOrRnlixsoer7kzSPh96/bTHGX82evyEhR +7q0UN7ttpZjtzbRrRgpsuS1Qie/Fvdct7i1Bs73Atxf49gLfXuDbC3x7ge/1C3yzRYPXKPC9Xr+0 +2Tkd9hLfdkp8sxdwL/HtJb69xPdJaLaX+PYS3w5LfIV5LTLfkpFsudRXvTqpb8GI9lLfmlG+uNT3 +v25u3v50ezr/vH+NIt+rvDNiUYz4lodIvMaMF7OFuX3Gi2cnCPs0ng8NZJ/x4hM5jJQH4lXQ5n3+ +jq0lY+8uhbvTS4j/68fL07Nfvl4p6Ob96dnF3a//tUAn/OHu18v5Ou749fO7cC+5cHnbd9aiweza +ZvoDEHGH9tLr1Igu2y87ca5ulnNo22/9+cBUjsevibx9OYzDLt4G+JoY7qXXZ275xlk4nF1RiMz2 +Ovnw8fbd6dn592enSzjSQaHn15QvW61lYxuUefah/evnBdH5l9Dqy/tiBueRjXBcbHvXL27O45vr +D3enj12lmGtVxuV2SYFu3OzNe/rfF1cfF5i2uu+ffcmJc68my1A9O6fV+aU8LFI2ZyVejMf69oL7 +5iQaGV/Ca0D6wD18EonVntvblVtf9yzSLrFIaYEXn7HTgi/gJ790lL//9/ub6/MNRtkX/EJYwj2/ +9PL80p5d2rNLc/vwfSRUO8gvvU5rwAac07Yzg8/jJr3967RXmT9DOtHbi7ufr84X5HXfJeIw+0D8 +5RGfgmw4+HR75YxfHvkyH4jZ6hV5JINPPhC31QOZT5l/eQnC/CodiZdaz7b++Ly8uPvr6cVjEvX+ +7Nyfnfuzc+OBbPnZOZ8J2PKzc/5AtvzsXEqVt/3Y3EiY3h+dr+Do3B099P6Wxm3khZ6cEu7AWjxd +B3YIEV5rKqJ98tnRKHcvFdHrvSJvI4vBdrOif1+cw3rX+LadTLJ0dSpVzU4vsQuE3azK+O+6Xx1k +7pD5az7ZSJ/vwP7adorxRyn64XHnsd0lGIyk+nPagLtCMV7h2fSs8V/bmn1hn+Lj+ROkvZocH8Vs +YWrbk3w8iyLqmcf03RcT5bpz6TFepxPfYtbt9e6g7benwN6Akf39FSdA3kV3hE3WZdv3UT6m2WGN +u8Jqm8P5sVF7Znt/Jn2GvfTDu/PbP1zcboOKZFvW+e70x/lrvAsKTbuabefg2P/nMo3loMzLpeL6 +eH32tx2iJq8Oyw6bVbn6MvDsj3s8e0E8M18KOTt6KRcTCjuIuv777en1h3czbpHYHnx/nfqQTVi1 +bWc/N4wz2QVtiA5tS/jqvT4krgw95765vNyCNdmWKdkMWfe+mks68EKNL7r+6atv/mTKN7+/fttd +AwVQBcibv9xc/1WqYJqSQsFH5z9dXOcvDv7ynnV4ffX9r1c/3lwe/Obo9O1P5yuzKlZ/vbj+5bcH +H+XfcvXdQe9Q88Ov8vD/yI//I6B/rfzqz6v/73+Xq7cC/eFvB+VhWZZtWNnqsKlWVweFOSy9qasI +KKy8r0y9sv6wqlwDQOvqVt67Q9fWzersoHCHwXi7svbQlSjjD2tvpUpzaJsgRarD2hl5IYDSeI8i +1WGwwcs35WFbG/mmlmarqiHAVXi2TR3a9CxFmkMTqtZ2X4RD64Nnrc67elW0KFIaAA== + + + GhfYM1PiowZdM8ZKM0b6VEkXBODb1gtABujbpgOgkIyjCc3gm9pjyAJwlSUgNE2tI3aGhZxMV+nZ +uEwnntvg2H9XGlkf4w8tJtqEw1DpiATkTWtWpjmsDCZBALWr6pWpD431aKhCV6QQ/rYtC+GdDFe/ +RcUobQnwJqC7aKFqV2xRCksh9sJWK+2VFNJuegAaDL/gUKxdcWg6eQJq2oqg0jaG39hKhi2zWttW +K3FNs+LEtxwS1lzWpDls26pGtaV8IiOqD+uGuEEccH4FnLC1T2WaJqyINi71pfEr4JUrUQi4BgTC +ypeOhYiPsgSCn1jsAvjqZdBA39J0zyU/1t9F/zKWLvrisYkibyP2o+g7Erta9H2N4yGSC7rH2eag +i3zUmJain5c4dUU+d3F6i25+4wIU+QpwlYp8meJSFv1axtUuuuVOKFFkOJHwpugRJ6JW0eMW8a+N +P9oQsbZ23sTPfaoA88QqMRlsBvPEhnWZ2RlrUvdC7HBoEjZW/cbSgTobtyN3X5FvP27QYrKLi3wb +c6tX+VeRGhQdOeDsm7gfIs0gXak8YUpYlPIE9nxAnIqeOiX61X2TKFzRkTiSwTrtAaWDwCPjI2LJ +uhDVZOriDGBVgJC+2wVBUUXQ1rIDQGSugbQvqKx4X60SWY+PZwdE/bZNAFTgMeOpApJ1bo2uFZJ1 +Vhm7gs46V/W9xYhcMxiRDFt2iuuHjYlp+I1ODOauBQp3c4fpDa6fXlkAIYc2LYAnfQkJT1xAM1jK +ynRLKUQKq92k1QbJlCFWwLIEkEIyjsDZ7r+pK9NG1PKNUr82JPxDGdL1usdRorHvN1mi63GPsR3S +dT8gzbWrTb/DsJ1C2e0r4J3uJpc2n1uN9melJ0dl8k2snYgbXY9c6aRNtMDoCYVNx5HVOEGGVKXi +N7YKJtIdPae5Gbg9qsBCIGB1omAlz7WGS680Ts92rHtP2Ikl2JQkljI0xaOI5M445SESjleGhYiP +kTC39WpIuptVRtZziu8igxIxWyizEnSvZ0bjdeAORImtS8HEn7B7Qq4HR5M8c3obV8fTy3OQQsZr +Hm++0cNelo8IWnmjbQgaBj0iw0rn2usRWjer6Sk7PojHJ/X0MB+f92OGINHsnmSP2Yox3zFlTcbc +y4i7UTLdZPzPmEUa81BTNmvMiSlxriOrVuucthEX0SfS5aaN/B54DBPqjmEEWQlY/kRVSHdM9550 +ydqO4STpqnKeNFG3RNwS+UvUL1HInkAmIppoaKKxQxKsT8cjTvvk4OjHg+TpfvSzCCK/+cc1hIa3 +q59uT99enItUYnz7W6lG1sYE/G0Fz5187g5944ABmeO8WR39dOCrw7IWEgRAkR6KYGpZYGzsIKsu +Syz04Ojq4J00f3Qk4sJ/fETfmtIIhSoPQ7BO5gkQWQ6jw8Aiy6tKXnr0xFS1LFWJ076RjvxwGkfX +KCMGQULm2QpaugiQdrkcOHAcBQrBd2P1wLHyS2bIHdZl1erpb2owhPFoqaQxqaQOQc+RprGYUZnI +0BjlKBojZ20Nghb0JKmDr/Wwcf3zsRw21gHNOlA4dKZ1egQLbwjEczI4bVlwvpVCgpvO8iSUYchE +4bRxJRh07HfQIBw2rn8+5lnjap9/UdWVHjWmBXmXCQD+A1CGmmXcYWX13BOuoFaaUOv4bFlzG7bk +DLFTwXEdY28b8kKymeUIU7JQ4kyT3V6i+0IHpO81zxqLhTw+SK8K/divtLAeLQY7mw3UylTKfkHv +2AlwtexWRTmL3SzY75KbvwzkMjE2NCQQnq+GDEvLL4Ss61FTW9ZRlaD3mPXKOm2nBaMSsIEDd7RH +bThpRN7jjm4aVEKUcFhVIolQNDlqhJiUlEUFgyocNYJTnseBYBnl18aX2lDExAK4WdfcmR4tA3VN +aKoEKPFx/Nm9YmGz6sqifpxPEa05dlPLl10PiMhm1XWReLzKBoGByiJk42yFXmAeBPN1qrxfZTPF +2STprIW1XMXZ5mT7tlsOroZrdZoSYgkR4NQmvOKKJrTqFz3DKsULYo5XLJMDgTiFI6THLb5pVx36 +EUGtopirOxxmW75StCeaszferOI26DqL7lu/yvYJ9pIjvpm25lZyTp/TZvRtWPV7Ebu17ADYzabm +QULykSa03++gCVQ+RJIAomFb9lCQSg8bOW1WPVkh5dEDkxCQJkHwVaJMWGVQmZ54gbgl2pYIX6R7 +CYd6ypioZ0LZjriStna0l0/HBwMErhS/u9LkZaUBK+urSIsGikEXmriRdJOzi9xsUSETR1BgkF6P +YA4SQpB1bT8vUVCqs4kqOJfe9t+MJ1tJQWOz9SjGS1aMlrSYrHkxQopijDTFFK+KEeYVY8wspshb +jPG7GG8ApbvWZHukGG+jYrzPiulWLMa7tRhv52Kw460WGtIEfgJKTJrhTTrllKzUJFyUw9qmXiUK +XJAyuZ4yFRPapcd001O3Iid/ni1nFFIJcJET0UpZh0RkyxCl10SAi5w6x7exeNGVj00UeRuxH0Xf +kdjVou+rDqfIxxOHXORj5qwU/bTEqSvyuYvzW/QTnJ+BaQn6Y9K1cfqys9RU/ZnfHbcdSmRncoc3 +RY84EbWKHrci/hU5AsrU8ZTl51EzZGSvRlSsovaoLgfchnbGm2H3qoxn6bZVke+ruPeKfPM5FyGD +DVxkOzju8f4bUIHGRzYMC59IRcardfSkY+g6klNM6FLGGHbEq/8q0beOvySCNFFVkaggsCiUGaeq +mNZxsUBG10KQ7+m5Yqw1PTusaO1NZJdH7PTxwR9EQvg257JrKOulBWEZaj5Ks41xSU0SKuJz3SZN +rYUUSaItQpSLsFI17yJNRAZ4NDsRQrKN48BmX2E1qlbH2YyXsOmIsOJg9k1jrZKHOkSE1w2j+yTR +VEghbMzXmHiBlE2j2u5SlYAyL1S48Uddx90g/JCNnwcTK6i0gmAjx16ZkBqOu09wWDWvmBPV6zXE +7gYayqT5rXyrc9rYJm5aQRCrM++px6iUd8W6BN8DEgHD7/5dLN6Xjm3kTcSO9P2IXe16GoeTjyaO +uRtympZuVtLc5VOHd6oTiPOL0hUPw7gEruPhu3WKq8nFtLr5ud5jlMgwImJN+iLh1QT5Mtwjhjau +/ybhcELhhOcZmmNSq8B6dS9g2kWAXtk645fIdvcvxoVQLyTevl5pOZioJCip3GyqvvOqhLBZ31Xh +bxQiRHU0/Mn8jCZwMMEmrvJgDcbLNF7H6VKPsWGMLlOMGuEccTJ0KDnFWk6fDDoh9gjxsz0x3i+p +ZLejWHkd8m0Xm++25nDzNqvhBrfanyERmNAJzk5T58QkTaTuHmdXaaY7osT6/YBycb3ioa8LhvV0 +riOAqpVuMhoJjKht/wUwpqky4tvpMDqkItbxZImghJWJpie8zeh+Qu3ucEhoX+QbouCOGDyeHLw7 ++I9/HPyDyqof3h7Uq9/8dvXD/5oCvnpjVt+8lz+lHFRfvelW+ap/GC/zYJUzFDpDkRGWjXBwhKQs +MULkMaKPtwLKTLbLeDuNNhzLoAtBexRq9pAacHS4mdAMlBjTlXtoET7N6dSUiI0JHUuMOlCM+jch +3Cw0Je+TA2DNdE2Pkslhs25lpqfW5FhbgwFrDsjxCZpwTD+fHL7T83l8imvB6Wk/YQjGXEPq4Ii7 +mHIgEz4lTf+Yn5nyPGPOSEvq6hbd8qblL9L6T7g+lptyhznzONjy3EwZeZjQjgl9QQn0o5OmpB/o +qIn9rOsptYzbb0RTJ1R3TJlZbDzLk4UYHwIc0vigGB8k47MmEpXRiTQ+snIcvIYe/5trxH4JRYQn +jlBEuONQhoE2T+SUxsuJfqUis0PnD6ugBvwWfgPwe6gdTBsAOOBEJWTeRCu6yGIwl9SHjUi1gd9I +kQDlQ6U7y5S+EnG+Lb2L3gjGllBztb5yKroZmNZaqBdLFTUNpCg5iiCBRPGQRhPVjImMI7Kwh1jS +QGKlJkDFRgwrBKcGnRKWA5mpqsQCwwBVWfoDubqFlrk99IbPrYFhUA4/GWCoiLPYVQafqHq+oozM +Ms4q6TNNRf+KNAUF5qCC/k+mABNZpFngJNQUzOMswJBFUU7GWFlVUWFIRIYKGxCASjVLHNCxlgnK +1dqyYufUvEDrloMWqIKES7a3oUlIxOlWERFSn1UFqX7RwuoNKdtHLZHxZa2mM2raKJ4HzAGKOvXH +aLkpUD08INggtxt7QJle+iSyML4xrVW7tHeYfeE0XKnirOC3qkErH90YRIh11AE1VpGGXGcrfETV +aCVlWzW0ukWyIQ3VwP9GVhcTCIBJylCqBBKATgCtqhAiSPauTd9YeNIAo8u6jihuHd0NanrEcBdg +Y8lYk9VfcUO2jon00EaLvqB2FUVOaQcI6tCykvCmhodORtrcYduouIPvTE1qlb5DXT5qroh6Rd6g +K61620ivfKvsGcV1dJtzlvoNTBVhyOZjKyYTABmmNXU/RcWaeSxgoC1j5fqVrIelVgHrwb3ZcjfE +fV1Gz7IS5k1d6khKhEJWce1LF/G8dZFcgyKpPKdni5RyydFGW6d2WxG9GWBiMUTXOkRkd8pC2DZa +lVQ5hB9euwhsDyZ+Hf2Jsr3jfWpFmwWlQjHpShu7Vrc6au+DQkxoo4GwipuulOM+ydEKk0WFOZVj +pDIcFEH1gpF0kmpY52NzsE515HVAexL9JY0uciIdCXnRUfJE64uO2KcDoUgngnqA0VuKuJhw2FM5 +5BLxBg4LASmj3oLvs9exBlRQR6epwblzBrvzOmNz81s0Y0AYLMzHdXNoobMz9GVxU2MzvApqnowe +Iguc4mpBm1YR35ugpmdpX/bVSk5ld2hk8/1wBQnUUSvk5cQNWPp1JZsWfg7NCm5UgruyM4/ONm30 +aG6jXnacl4UOsg+ovZM2o6H8H3K+/+6b27uBzzikHfUghnvv6gw++x+v364+/Hz6/nx1Rcfo/5Sv +vpb/DuzQJ3ckPa1hEZTFXMwkgEtcyiYoG7yUUVBOdjGrQBlqMbMgpTZhF6TYBgwDBdDFLEMstZBp +kB4uZxuk0CaMA4stZh24YMuZh6/ebMQ+fPVmIwYCcvZyFkKGtiETIci/KRtBOX8TRkIKbsZKUE+w +ETOBPb4RO4GCGzAUWmwDlgIFN2IqUHAjtiLqDjZgLLTJ5ayFltuEudADZgl7oXqb5QwGxOBPPSqj +GL2S2aqjunFtlfy4TWdoF2KjwTH3hsvIlK6+uz29/ul8ecCMHEiC8I4+DVaoK2NmcC5CT+fVEeqE +xktfV/SskpVrCQqYTHrZ8O8JDVZ8m74+0cAG7PVU54ka/mGC1pZZl63lCKqRD6B7z6gE7VqqplSn +91RPaq3ImkudKfJexddF3vlYTde/kzQTiuDs4IlMUde1k4PUna6DJwfDakp0YdgaKtaupC4BMO34 +mvGtmYZ8mtLr7G2so68idqFvJnaBf6o26612KR9SPzFpXvppKTovyn52Jog0yyXUBg== + + + uISWrfAYcNK0DZ3pyxV2oYW2dsymuxauuwoo0gN45BaE0cEnFD7LU49QObeFEyphuQeDVgphMPAa +ltaNsGx4FXwDzq6ED18IdBoVRlFGDodQYgJMy7JDhFTpac2DoASWqXOBngU8vjBvwiqoIpMk9+RA ++hjgeA10oRcsF8DQBA+Gno60UOeRjAmtD3JOKaghcwLyDx0nV1I4KD1p+OOEypqmVoVgI4eDgkJN +dWyslDghTIWyfWyZiMPeFKl/xC49JuIgTg44LsuDXUfKjzj6Is0HMZRzVGav+7epjkEVbKdrJvWl +74pOTLXq+8tR2bDKBhXnJRs5p2XFP6HK5jDNUj/RaZL6xdA5yhaMvWLbsaP9mtJ5xZMJj+uextsj +R7lK83JyUAxeR4hOB6vwlW6mrhlIDwIZdIWoU0y6W0yHVEzH3aFMjzpFettPYJHq6Ge5SLjTL4Vi +siBpv17FZE2L6boXU+Qoctwp1uBWsQYFiymiFmvQuViD9cWazVGs2UPFmq1WDHdk7N5g43azn23v +Jl/IokeqYkoqioRXGUEp1tCdjC6dJK8aATU4xz0chir9vGrbOh58UWQWSRSeCtrJmmNu1GqhU61z +mH7oHEZLjn6vU916MpqxWl0RNtY1D1h/tPNd/ir2I6shNdS3k3qR90Zf5n2ONaROnfQzAB+oknMo +W1HP8u5FnJm8tM7LpIVBL5QS4Z1t+56mtvvRTIdsuwN8PE9rpnM66WuWZrCAts1GU/STsQYbFFP6 +vxuaxptkFp8MVWCTCaG9azhrVIWMppYy+nD+BTRZpK/eTJcSHeN4hOWfYoAKgCNMUUvkuLk1eKdG +4yF6QrKYYLEKU5P5SFshe10M309xIGuzyBtdgwn9OIrhQKbbPpucYjh3RZy8ta/XYFa3VBkC9ks6 +6N26cawd8drJ6ebuOpOoqjC1TrpDKGVKCjNtDA5AUG+bDgMGKTuRWE1pI42nc2iFuMBS6ZhRw668 +MdZ08o3hYacWVT0wGmsRNK66uBN4bKoO0AKVG5yDcFOlLtFTD9MpLBooaDzDJVsEysaARFpvy+i2 +Gijcds6YiCbFD7oBsX8FOgglmvL76F/Rd9AgbArCOpScNYU5mJ41Pt+qZov8kxrd8QPRGScH6SUt +1Qj0IlEpawZix0rBINXU6HVTc3KQuqMT2KBfmFVqXNM0g0mqvG010IeLIdQPqvmowOaSKWHCWqrQ +hg+oneo/gMLVtWWd11OkRcyaK9b0qpulrPPdNGVjLNZMRTdR2Yx1r7WAS7Dx/GtzYDwyPBqsZj1E +yiLNX4a7RY68bXKy7nG82wInD1tIbHDOB1pIjDAhUsTQ4dlMRS+4KRvoBB006NAcezhZM7wVrAyI +gghijXRG5iOIrKh+7D9c4WCTztYs0ahefU3R1hy2UNgG22L3C0N0dLZxq0dzW5UC9IYOtqw0YDQ3 +kjxm5OgpTdSBDWmNku4RtVGDxojeqHFkRHG0+IjmADihOgLchO6QTC+lPHQjGdMe0vYx9RHgFP8J +HFMgGg3GNIja/fHW4xE0pkNfvVlDiaCvn+x6aOMn1Ai69gk9gtfQhCLp+djRJGq+J1SJ/kkTukRl +94QyceHW9HIdddKDfEyfVMM8naZ1NEqVymMqpdDpOq2jVBmeZrQqQ+mMWmXYXwzRf0qx8s00OeLb +z680FTxd/fH2/Pz6k5IMhZRlSJgU30EQ7h8YHOQP64qDL51nggDGfmqSoTY4jSAvo6FRSBG9wl0I +6tNXw/ICr1inhUCfSquh/QHZCUTyq+oYjFlnWYb4qEmGamRaie9lCxuvzpzChXGnWmcMN7lQBJdy +DBkNZLdqtDD4SJ22rR/mGCLgLAZGjL6pW8vwNFIaWjBi+LkXbI4ZVELsfGhqTRVh6NkJo2OrMT9O +/mF8mnqwAVTRqCcEvyo1yVCDxBjIBhCcbgFfwzKJv8GlJENBfZ71HGBpTRVQuRCzXTTqMOucTY5m +rirpw2cYb6T9bFbab5oKBKOZDACh7NHjoWWHYXKMeTeQNQUWJ2PUMTRUDE+zDp6YmvDGYdGE/tat +V8tMgJWoRhhs9FM0CGcmRnSJidBvIk106PTIBwC0aqwa8DwSDgDzrAsxx1ANb1Egp42xOKGh7aMs +g+ueU46h0KhtJb6MpYu+eGyiyNuI/Sj6jmhPi76rcTRE8Kq0ca455CIfM2el6KclTl2Rz12c36Kf +4LgCRbYEXKUiX6a4kkW3lHGti26xE0IUGUYkrCl6tImIVfSYFbFPfwQbcbapTMxIFKKjZ+WaEBHR +JlTHYa0NJ1w3ZUwIECMD0V+3ygbAbWXjMOO+4t7TvAPd5pPtqU75wz1c5JuYG33wFWlBtIoxvo0E +w6bVqHzMMGS8014JWfGrSHaiKa/OEwwlwpQIV/oiUbaiI23ADtc2EV8qq+mFGuNSKp3QKpbVMTrP +I8EScdF4E7GzbmN6IfjfRByuNP1KywxNkWDn+YVCTDAkUx9MB0Edmhso1oGGGCDbN0SanvLvoDfo +L4lU7C8xvk17gDQdA7cxhRkHXpPdqtPM9PmF4tRhbjXJDwGY/LrtJt+SsviU3IG2cq5i060iFbou +pmqosW/z3EK1bmQN9GgH39Rt8neuvFOql6ZeMU93U5tRSiCwW+Wk1OnmJJIbTeYi9DwMSHJT8ZtE +tLGR2sGO0n2Udl08DPqNqQHNjff57tU+pFPGhHjsVGlTaeqWjlI40tkhNdEMecRO0ptV2gS6LWh8 +x0o3aAZ0K2iAeSATRtLWNHqe1/F8b1OZALQgjTR6SDLHhVLRdpVwTEktOXfFQx/psXpyZxQ7rDJq +nhF6I2RESXlQnLZNZEuConQZdNy+pKu8tF83HVPCDjqN/4LHuo7B6PSGWvYYR+k5u8yryGmo4lR5 +5sFxJcmbzqUejSWntgWJ4UxrMsLR6To6f8fn8/QIH5/yYzZgyClYxcYBMzHmNqYMyZhnGTM1U74n +kedEnRNxTlR3yl6NObAxi6bY5yI6Wk0uZLzmgCJRoB3YJ8awSy4USQpJThniMymS8p0kSCRaMaGB +0uFE1iJVS2QvUb1EGXvCmIhnop2JuI6ob3w8HjPYcyzJbVB1hrcNPUAqQbqaqYPgx9Wuyy5kkRgr +WpLTQxFMkLWGdBmsaw5tENo7sSULWxlaZg6SvxXzV8hMqcUYYiR+CA77BuZlWRG47pTwv5RTcZJd +iBLE2nx2mhOASKLZmvyqSDnGjpnPzrUpuWCoNZ9d1eWzczGfXTwqDGPtNJ9dDP9H0H2dJUVo3TDH +EJ+PNaFdSv3nmGPIqgRpmbsqxIx2Xd5Bp3GAGgnD/FcuJrRL+euGKYbwfBzT2bn8izybXR2z2flV +53h2HNPZ6ZAbpsCLmb5iPjtNBtZljIwRpnk2uyZms7OrmABynMyu1QRDhgkvNfVYs0plYzK7NuY1 +W8W0qDHaojQpc6pNucbcKuay63KnxSSRmv+G2dU6jyzLTHbxtLFNyh4WYqJHF4NTra/rLPKYmexc +zGTXxkx2JmayCyaWYVpATRUXtC+tiZnsfBhlsuO8KSYyzkqdVYep7Gyfyu54kMqutF2y3a5knv9U +K2cuu3rVtR+TlnUdZC47u8rGwFx2YdWPsktlF+OvGzDYTLumUb95KrumHeWy86NcdjG9EFeMSLbq +EIoY5nXF61W34Bk6eRNiGrtKscuHURq7VhFRcSmiXcKkLIud6XLYHQ9z2JVhlVCfvWzamMQujaPR +DVV7Dc4mXdAkdu0q24ExWDtuwEEKu5jBrlqlHZymst/jKbVoIgNMYVellMZVHz/ekZIs0xAhJ8xr +x3RQEUICVaZMym1Hw3oSlshconKJDiYymEhlTykTNU3EdF1iO0031GgeALwfpox2zTBldJMy59WV +hudnfWjqbGfFTmq2VI0NjuPQlKqajodD1aSr3nRzkecbihPI5K0cXfpmvAgxy2XI1qkYL+Uob3QS +BzNcKEbIUoyRKZKtNsO3YoySxRhnizFSF2OsL0a7opjum2K8tYrR1ivGW7MY791iuLWL6d4vBuSh +0VMpS4XZpYtWEgNPkeOULtqQCtUpMBjOrZFKFVM6pod105O6YkwLB+miYdk4Tumie4pajChukRHj +YkyoiwyTU/E8XXRqI+Fy35FBuugq9OMp8gHFMRfZoDkrRT8tceqKfO7i/Bb9BA/Ow8b161TkC5Wf +q1V/8BfdYkd06M/mYnR8rzqUKnqcGqaKbiOy1s5H0dRWsTjdvZkpuoltZImidVdErUDWs8aHjGsp +EvEu8t0Ud1yRbznt03jbFtm+jTu7/ybu/Y4T6whExq2Ns0SHVUdoigk1yljDjmT1XyWq1nGYHenL +2FBNFF33rGpMFJ1ygrMVJopO+B8USRhC7nq+OCaK9qtiRMyLRM33mYb2mYb2mYb2mYb2mYbsPtPQ +PtPQGEn3mYb2mYb2mYb2mYa2JdMQQiSTQ+/ApbeCnQUMfm0aZDe46mEI+FQtEgM+KY/AZKJRFiJa +UaCxlNnU+i8YpMJuCFYV20x4Cykk2BAt7nr3V1s5k/xBFPPkFGFa3d6BGylmmV4e5wpvuQmw+Heu +GjWD8ZlmoNaFNNbGtM8poFtvA0B4rusuQrJMlw8TUlnHSJAyro2hiIyIFGtU00K5Xb0UaMR0asbA ++sfINFmJ5KwQg819n/bEp1T2VewTPuf5iXCWlDy/Uh+xcEi/OHXiiWkFWqkrKn1MRHFGB1NsreLs +cJXUR8FEI3cVyhhw7eI1BVAlEKJB3AmizkltGRPk6lftYRvtCsnAEA7bpo1xyqG10Q+qNS7ST88N +KGPS+CIsax288sZ1jIwmhA5XnMLsG5mbmEJXdz0SM8SKTaUZqmARLGNWCs/rkBy2TbTJV/QzkSnx +6iEBm56uGyO01cTT8KaJUkPj1V2VJpiSl8DUpofAU0Gka6JjBFmqW2xfkQNO1akxRwtekqNjhzwM +vb7u+1wxztzmA6tj2HY3+Dq5R6b5gcbHxAsr4hQ21La7HhRAO+LEc7yM4YypGNKQShLOnkwCF7Ql +rHtJdtD72vUA2lWbdKtZ+iYmJKjIxcg0VOUADQVkaSsByJBpcSb6GjGNMQBpg0JTpXp4a0NqJlCp +SAMCAC20YibmwdaU0V67liWMrmKK/xjYroktsmzRQU2+qitKX5S812OlrhWa5b9K6b/1OhmnnpqW +vi2a5N9EdzKSqzrq7zsADb/REySCkCKa6ZtB4pHkISX6JwBEE7hTlcn6V+JgcaRvcXQx3z+JUsrH +f8aE/+q4lGX8N+oquSY/9NlBMUiaHpP++yarYZSHWjMOoSsumR3roDnRm+iBw86Ocl5zRMVk2Mye +baLNU4k9pm8wVyQr1iZSo18FGNKqpl8G5PRuqjhdxHMlY0yAoaup+nhXxrsCbRXF/xDSsxJM51z+ +gVJ3YlTT5f/Psa67yISoSgdjah5jWgumcxllRY/5nuglr4r1/BIA9WCL+dVj8vXuhw== + + + ull2ydezewBq1ZRmFwHE6/3IbJ0dDDoT07Gjw1Y7nN8FsOqSzJ8dZKxluobFTrPVx0TqTK3emNSc +rIzRzPd1JFe+0UWWZYykW3kEQZcmDs8mT/g+RXrEsnQnSofxXcb+s3grACd/eC0AUNyoy3p3UUBZ +kjycHfQgl8435AKp4FmAQ7zUnaC3NxwqR6SastIzhL1NjEzHNwXo0P1qykk9lEOrjP4S0zh8WUeY +rTUOH8lzsOODLUv2Wzhy3Ajyw9VB3WiOlfGHAkeCnfTl0dnMKo/urdLUBk6gLquyC+NYE7kxZSgz +6DKWMopcy5lKlaE2YSu1yU0YSy25CWsZxdjFzGUU2zZgL1FyIwZTYyI2YDE1xGITJpMKhY3YTAaG +LGc0YwDnclYTY9yQ2UR6qeXsJkJJN2A4v3qzEcsJiXoDppNxRcvZTsYoLWU8pdAGrKeWWsp8soML +2U/q6pYxoAi22oAFxRpvwIQCo5azocDehYwos6JtwIpScbQJM0pisBE7SgK0EUMaA8SXsaRKYpcy +pUrRN2FL9RTZhDHVULhNWFM9nzdgTjU92SbsqTa5CYMa02suZ1E168ByJlX5peVsqpbbhFEdKQrb +LvL/O9iqNFNlGvqVmtM0GKnWWLTG6p2Jgee6dUpEOz5OukpSW4CzQmgk+q5MEDyY1SNZ/XBL3pHK +4WAsmgMSufzU31F5KJuu0YtkIZtzYIdXj35X4hpf7Du6OzjsP9WqDgd0vAmfLgevMfEKVWFPdNcE +Uzk41yKlrCAxaL8GabPB8bdN6D87Optd49H9NfpWJl5oUV7t/az6mpWN6uUla8s8ExusLm1wy9dX +im2ywg8gOFltkzHWV0zbUJqM+xaipkx45M+RB9IMmXjb5bxELuF4Z2mI8cAtXTFtumAN3E5r1Xk2 +El6rxhMANDep8Hi13lBKCUUpvkZr9FfAMSw9u3WQhJT0thrQ2/6ytsEFnRndJlWvBuRdfpFhJAjL +AQAD0SFsYPUZ3FxHb8K64RWU8q2JXt5kmCmYuGgJgZg3me+N5OQGQRNRVK0PmQ9FBt0i1gX4jx2C +DiGNdNBODj/l5ktfHZ3Nre/ovvoqq76Zg0rv33trkE4j9ZeinaYSXox43EZLUY/UYTnyaXaaxejH +SVqOgCy2HAUfIBCdmgAZxqCfuOoTbgUGkytLSXVDE4lSUkow4KlK+jEPR4oKKoEqMZMGAF81MZ6v +BQeMYSIlh/pbgYuWITEhBZ8xciljUsNkWNKllKkhigU9U0PGJ5DVdD1/1MYs2mf9jZTDCylDvRqw +WaFaDTWFJXQBdLPUapnVyR5GGVQoM6JiIE1hgOoLxmzUSPmb5FavIiFzc0wmeyPqII1Ubd3qHoV+ +goJ0EOaZQlcQFBPxVHAEx3MDQdGNv8U+Rial/lvklZ9b79G99cqu0eTDg4ofUqhNsC/LcbUA/7TU +YgzUYktxMDW2EAuVvV+Kh7HUMkzUmV2Kiw+RCVLpWlPSO0N3WFBF+A5C8+bq5DyNqJQ66QWBZQxj +aSE/q+OjJfGv5RAwMbAWLrw4DZIusb9euE4mCWq/gAaUJtmZVtNeUFfAVNcafhhidAW0HkHjG1V0 +AdfI6AoIrcGsJkPacDPW8G7nPpCZpKu8CIQtBy77wcHXnemMmKe/Gn9qy1a/6L/lVpxV69F9tSIe +kRMyqPWBfThdXgUuXWCVtxcvcWps4SJrscXLvBbPkbVJtv69eZs+Wx6ZD7+c3/1Wg0I18eZ3BwiD +FsJGOdYLCW4pCbcIt+6Sy5zOz85ta4QRypw0SA3LE10oZSML56ARjfK1rREvYmA+UXVTWTe+A5B9 +J/uRIMw0aXFqJAhrFY4t1SrPTIMe2z3GKcEs7hXdMjWP9xrQsLsnxNNvGeQPRQk1947xrgliVYcP +jqnVVNUa20ONV9U9M+aftxd3XzSjGpphGxqRZzWOizN20kOgPbNsRW98b/SL1Gp6VtkC/eq+8KMa +/LCN48lYMQeOgp/Nxt9BYu+lkPF1P17hBPV9N/4aeR9K30HqUQ31qA14uyqkH38Hib1PdabRpVb7 +8ad+JYgb1eBGbRxPxorxF+POXWWg2P8CnQE7nwZYTOegQHeqDE2K8TwW4+Y1OG80D8V4GF3FaZzF +dCq6DnbfjKezGM/48XTknA7i4WA2EiQNg5jZZJNB1BzMhaJmyD7xozr8oBU9sgHJJiJB0ghSpd0Y +Y7vZNKSu9Z80ozqaQSvHk/FGz2gEAdFeAkWJF/npimkaS68qmpQZEXd56E0UFAo1TygTHssyerVx +dRAMB7eeq5OFwoTba3k5eVcT7vAxUMSHeINF0cCa0QYN2KnJUsrL2gVNNuzK4SNzbJgeVqCdBtFU +Nj7U8Q3wz+LWqRK84QmfbEzU19Xj4mu0k34TcdUI6LLSh6EK2IbClEND7KGSomdva2ri8XBKj0F9 +ss5fwRfJBB17Gk9J9tI0LFXzRgbE4DEDIypuaAw0LZOzuihIlwxBz3p3fJD1/uRAx1Z3kGzc2YRI +oWyyTg7yeUw1dD3NB4KBxWMXdvKWOdQEv8gHX2GiLJ17kbTCxsMJeWSQ7gOsFaVq4Do10xFQMhjV +V12pY03JHA1G1nHTILLM0gJa4e4At+oBNRJGNKu+UKPJ9GLwBb0Bol2FiZxbSGOCEkhQxHzsao7u +AI2mdElljrOxCp/mgub0DnKWM/uA7Dg6QPQQSG5Uukzm6DiezbjHSiP+amgfnKazkz2vMUUE4b4H +r0INDntkl8lAHvkh2lq9thIQAg0zbXZ1mS4QLjWYIHTc8kwc3H/lhffDdU59TR0ka7CDdf3qakp9 +H4/vLMVl3Hepy9HNzSVvdXF/Pb27O7+9/v316Y+X53/8ePH2/INe6mL7q1+6j/79/ub27u+/vo/3 +vgg+ydp6aMZKZau9U0347/52fnr559O724t/y3eDStrvLy/Ozr8/O728uP7pj7cXb//f819jddMW +/ybM6Ie721N0v293MRf78fLy/G5VrI5Oz3751+ntW82HuPAWGcN4+yomXLaIKuUzvdhXCRSffAod +xBkVk9VWq65gMfy8MD7+AnMVf3L3ZB8Na+jKaQjWiq0MejL4MnX+uB/H/MtLVvBfKJGpSCZLqCZu +uJqmzpWzEg4FFO3SA7S7lYh1oYZU1H72K0t0slbUBMcsaRjwSjN1MqtUN0lpilbpXSqjr6zrJqdL +TKwvi6xMoR9zcful7dsr8o7EZe0WdZWuL1AXFGKS/ooZjvmb//VPsTW/io1RNKziF/GDyJWvVAKI +L9KXWhRkPna4q79rJPbi+KDrzoZxXazqKv7qmlCw7Szc+HmZcqSu4pDzzkR7Lft72f3uh53eFbHO ++BOfdu+7IvHbs65/lyORuvZdMMZ/xHiMTtRd/cSsJOo5ogvGmBE8xXszDCNZ1CdEb/ACMJq+FZAy +J/DWLR9zYfMhlU8/+iJsJj4ep07EZ737xfQfjKrrm2KAY+rEycG4i6maQlnXNM50cCKRhaeVmec0 +r2vEX+Rg4Sub7p4Gi2dTAnl+aGN8fNt2ZbvnpE5nsIxJl5zoU/q2L2RWqYWC7RkFUtaN9xey8UHT +cew63Q9oyoSLEGme2cHbkoSoctWau1PjfVBldBVj5j3PbA+r+IaarMpw3YJlOjVPVVrRf+CqmAvz +oaKV06stj842bvVocau4U6pGmuJe87aeAjycLVw2EGjCt+rI1e+b5B+Zdo4mU567d5KCOO6e7HHu +/um60+0gXjI6cw/R2tbvouzxsX2kN+uVPa2p4kRFgmk6gvngFkvTFzeZeqnO2mbJ16bt+r5kq0XS +alLy84e3WxrPyf3DFpwyYygt/74nsOuJq10NAZGIgB/wgb7BehWBo5fDYfToaZhEBeKnoXGm7H7B +zjx8x8JN2xXO64aCMdHQrCd5j2LHH3RhgcWDl7+B2MC/EZkL76U1llcfM60rxdN818K63WhuxIzE +MCbzkDll15WAA4tt25yyzGzjaG4bYPWQIDCjI596s+Q/Ol7/45BbL0y8RtMcah+uDhreFE1/5qoJ +NTZ6Ahk6SadrrAbl7j0hrOOi1aFEnsN4RIhEC939Q0cEGI8q5h6mz2H/Kpi6Uh9cIdeVeqyPVtBD +m9M+VtjFS2eHx8TClo82aBlm0wqBuNlRAV5eiAOk7lIkfJFXG/woy4Y8fB0aW5Grl35XgJg+ZaTw +9zWYeQbu6toZX8nnVx0ICkDfVPH2Et4Ebbi0oxKJwZZjUF9AQwa1z9WB3gHdFdT3UCQaaiomJdaC +HhKrf8OrW2XA9W9Xv/teRN/rn1a/OTr65uzs49Xfbu4ow2ZYPTk69URY03MN7O763n/T935NuUSE +1/T0d/nz6nd/ubn72/nZze1bwfz/ZEfUcljxnhHoHn0w8H6xE7n++Js//THulb+/u7m90ldxlLK5 +3978eP7mmz+1b6QT39/9enn+pm9av1o4a9nhER4ydH0+HceTKyW+vfnXBhc0fJnqCMcMuC74qqXK +zlal59U+Bt5IdZgSZc8MnHaVUuDyoVBDc1OTZw7qMbHXTex1E1unm2jqyCLHJBED6euzM82WjFzO +F1dU+qVfQ565UmfByDOz7OdnmcGdOANHosQ0+wZn3kNMs2uQTNHcw9EiDNCEMc+FrXFfkSqos8eQ +bZ7VytHsViCA0wjw+RjnNexyrV4nMbcyjUgxYWWCneQwA6NmvAJYgy3WgbqSbCDGkUZQF0uBa7jL +Ol3hO+zHY/x3I1MkBHil7LdhzsQH2G96zjn6PFgl4T0XGwLa5nwjxLYaMd/we8cJ8XDRxvH+7bON +2zxa3CaOKWc/P9PtUlojJL6BbfsqA8lS6/JkoDKCfHfFWAeCWKUXynSgfPlL16TL6kWccvlnMPLG +W8N6GBp9AFZNYXEIJ9NRpdOt7zVvN670DmHblW/047w/XTvwTRyC8tE18eJ7+cjYwVfZTE1BXZNr +QA9LGxFNyk+RNiZduxoAu54wDncySwNoNzYNmrNj4Jq5YtjmeLbWdOrTRJkCNMJUrQ8aBiu9gwhZ +108izSxaleycb16JNPOHm9u9hXVvYd1LMXspZm9h3VtY9xbWvYV1b2HdW1j3FtbdtLBO7KlXB1Pj +abHGxLrGEPusNlajN3Pca2MF12sfK+sQKVZWi0ysk4aPljf8VBbWYo2JNbenFmvsrffaWIt1Rtap +aTI3XU6LrIc9vZl1XeeZESozs64ZzLqCn0c7UQXcX2n2ttYn1U6cnL+729ta97bWvZZir6XY21r3 +ttYntLXich9mMbo6KPUKQM04KPKIoekowZK19YSsWIzwHYOSsTUruAbUV5+1/7mNqwaBdwiFba0S +6N5Y2aLNoHZOJhca2lYRwIYbux8s2tC8NDKuLmnzaHGbOJa8F6b5M7PbJe90hEaJJk9niQsJlkxn +JxksmTIBqyYw3HPYuLWgZPDMCuag8l5QMrZloNRZxSIG4ZaDXvYfpJsHU19pzytbkg== + + + ybjFyrxP6X0G6juA3LSNWwcZzFW1Zv7G7a+HPShWfA6pYto5ShXTUfTAfrBZ8bXAfhxqYe1mN283 +/2jdVG0qqhSJFiCtWS1YH2CHegIRZUMJ5dXYT/928dPPexFlL6LsRZS9iLIXUfYiylOKKHp5aJIj +YoiMrXJpowNlMkkquA7USyD093QqgKTXuXwybPwZhZSgA7pPSEF6nco9UrSxmsZktpQyaXTsAfp4 +o08lpdC9Mq5dFFJo4vE2rR1f51KBQnouNUF6+YK+eyMIlrzy60CZQJMKDkHlfaCes50Mo7NTpBpz +4SSC8uLmMOVgmcAGI60mYyek57xZyvk0e8PG14KeXDCZDDhFlY2HnEFzIWQ67B6Wixz50LNWh6LL +ZO7vFUq+eGngH+/3osBeFNiLAntRYC8K7EWBpxMFEhtObr/2KTCMIGQstn3cFnzxepBGdXi9ONuX +NqxiFJjJP0uCwhpIbPBk2oenDArj7T0DHlsGptw5EquviQkLj5RskPizeSAm7LEmpyFhjzSJ48kO +UtZ/HnGgC9TRNBmdQNDgEBGALmDi3npI4s7XQaoxhJF/cdlVHFgH6sploFR5kXjRDJQC0DLQdDSd +XDB4lYLBUkRS1nbf0BTUxTJ18zGFdMVYd17NtAf3AB8UEATzvBG255MEhPEgrwbALGRrOtAM1g0t +hnYNIGtHFqPFhlO+pj+f4mVVaD4L3MfKxK5G+kqH7eYpLBiLluM1ySx3dzIQIVGr725Pr3863ygE +DNZf3OoBH+l4EDXCDiETfgIVoToM1tsVkuh6XIiVACXSpaaHonudKii6GlIrHeT4gKAmA50csJzt +IZOa83bHnYqFU9lUfd/gZKj3nncm1MrtQGNWd9xOWVUPHniFcBq1wXWjpqnkyOChwHe4JakMjV46 +JByJOQymrEZ8D9Lm6+WBD5eGxzPSp49iKRa2fbRJ22CM5D8/PgJtU/rAU621JQ5P03jvk1rN4Qeo +j9eLC0Qo07v8cCgyD1GHCi5xQ7KalvetJJAst4u44Hn1bgKUsrTpd3qXSqfCHTLE5xwZXMcPsVTV +g4pxtUXeZjHpUVdB1+kM77uWJ4PtUihlGyLxhPm+yboZeAlighUIRWRPgqAs0wEkiHY0PuAt75lK +NXQVZDtj1Mu+3XGhca15k5MOTfo8GezxdPz3iZe9S/Go2zxCJ4ObDD/vqRToH0/yx34ypxM+WZbj +vDvZAL56s2ZUAhzXOGl02MdhF8cDGo94vHbHWTfyXkzm715gLgZXbr2Mn06euubVUcgaXyJfuexl +j5QKapiIb9PLk8nn9xLl1kYJNLjWr7qwBS9Vr4ltY1b3xlS8lsbgIqQm5+nLNhw6BPoIU4/bqQYy +qKwL8k1oNNSDZUOlV3cLOVzc4NEmDZbxUsgR/f1E9ZiwabzV3MUk+bJk7jDGFp2kt+nlyeTzRMDq +WuHVIbPkXyVAfBYSUmW1Dj9eA3j6mIRJh2WfZF3sPui6NCnyBYQiVH79fv9cFx4pF2s/kYsVdsIZ +XLaTGNjKBTyBnPNNOMStdq4HKO8aH4rudSpboHCqFg9yQGVPyqymDyfV5I2Me5D1Luv28WAQj7Km +QgN503hkTZ0wYPXDUXe45QN3NZtG+JXahiGHV8OSWmsEFm7bHMb4+kaAvGPr4cIB5GkSi7es5aNN +WhZid9g0n5st7da7onEH7F0TXHxG23HN9VrfBIgMkNU113epKEt261yp2WXwHPnQ7uNiXFWRt1NM +elEMe1kMB3E8GlTHe/aorXasISBynXrBRs1eNbHd9tAYXlyeINqt+IC3vLQ0FdfSPaYP+hTbGnw7 +rilvZtKJYSeHYzg+GI/pMe4y71XHWvaDyHvGu2LzroGR7B5P8sd+xkZTOu5u1oXUYzmfppBBLZNW +hp0a9mk8gsH4RmvUN921XMyADDjHKrsxMtuD9/7QfxlG2Q0bd3s3zFQLEJMWRZAgTjhsXZuBhD/j +7VqIqaTuLNR6URFDaX0bdyru0MGNm+R7u+0FawpCYrstxn553hk/2HaVCjjxHnC9vL7vnT4fHwx2 +IkDZTk+gYlJvsa71YtLHYjKMYjrUgtOBuz3TdBSYMV9m8zqdaSTOWHcl5JoliTgyXBQBbrAslHI2 +WBgtt3BpBqNJi6P7fZPlUSFygwVCwc2WaLTR6sihtWPZrD3Uq6isBrQLi44TO5gOUjWagbiGjkmq +Ts9gZNLvgi9lPlLhQks3q1R/Bzg7aIQSeJOBhMVtcQ93V0sCkFeKv1PzqXTq3ngAx5MhzU8BBWNm +i96XCP3WQcpahNau4aSgNsOtjpoKKj4UwZT+ELkEhLMr9b7x3nXhs0hm3YQazYJyhQml+aoDyZz5 +OKGugdNPAvCIjL/Tu1Q6Fe6mLz4fAyNw3V0HEeHEKUZoDekZtaffXdOpcDGuv+gbiMJihipxZDWu +bGcWuwgShEvV6z1xCcC2m9QvfZdKp8IZYsSGZewBzn4JEmyaG60hPXPebDep+jIVLsb1F30DE9D9 +PMbAH6Jv+Cp7GresldrRwPRu+uHg7Wo8Of3E4evJvE5mfjISFJtMwWSS+oGMb9Gtmu7sj+4TIknr +DYrCh5Y4HojaPuC2x46YnnSf4Svb5pCu4OdJdAGrFSWEeLewKzsluCphhBSZplYFTgOhYaQykjOC +mqyHC4PnsqaJKqOFLR5t0mLJHCGfPbUFbXu6DLhVnCxZpfc/R60RX6e3J9MCmd6oiS9aV1dWNUeN +llbICXCjr3tcYC3oWfRHfaNNGVmg2NEciftP2b3SD2Bd8S9Am9Qltmg/rxrpD6f/vLm9uIvao/9I +MsbnvDcbl5nj2ubCwa+qgrlB+MKat4kmEOSeGnQTABjUkL2shfLDgRWsWnXKDDVUTbbVKz5xJ6nx +6szZBscrtTWbldXn44MEaZHDRh07kOEIXpayqXAbqJSVF7w8mhY6RT/ctpr6pm6nFqxv9xFraZqu +Fl4zmxrRa2a7XpzoHbWG14HHnhYcDCFxMLyXF81mI6ZoWvPS0TgtBWfOVf3MFZxeHCZZf5t0F2/3 +lbQrvBocLHm7bpWNExl+aqgIcF90vN4zfYWKkDqmX6jxYh53PpfxhYwsrTIS9njbgwJsKaFii9zT +ju3Cr84g8d4xSbvRCZFpwwfOhvQBHUfDYRDUDKkOvWWFV5O68YQkyLH6B4ayzb+q6QZFAK+HFYDe +bOyk1VaTGcppboz6I5ehphckkpcCgunjfOphXwfNf4hHWpTrSt1JDw2swjLb3sqoVCZqZFJXOMIq +kyMc2GN2l5/4+AmuBPea5Ii1gG3GnbaK1tqSXo0bUb8OVISyq6brKj1AofnrR8MRe5MPmbPi+1nB +vDVNNm+TZT6ervz97q1P7DFSYQ54z6v8dSuPq4B53av1VkWQ7bru9X+cX9JtnmT32ycgvdjZttFr +kmr6ShlIHKGlH2dAPt5DvWQZFKvk/6EmyYDFuEQxrhQ3BleKNkBY3HidAN1zKtMXSdWmWlOb7Ae7 +kUFGH09qGzU37s60x+/gxl1iv6e/V5pXFbn+QORlYwrbRZGTqKOdzkDF+PNiXKN8T+cS+T7gdCPZ +iICig/Br0ri+WKq66OpODRfsTMHeAGa5MM1qUiLVllU7aXvcu+kAuI8R9FA7pZDeuTredlVyEmSr +wWPJp3z6QWgB9Tc8NzII74eOmRgTDNe7B2SQRj1yjJJ2tvR9pOqornU67GHpnXp+iPhl+UPN/rLC +dWP0lTDjgZfHO1g5jnmlvSPBgwpJOGf1h1SBGw4DnB8HlUTNrHHw6YZPT8ojh5QVji7whUUOa6sm +al0I031Fjg7MvsXhZnvI2YHh2WR6kMh5rSYpRQheA+sw1lDPMR2ug7eiawghbyHTVjLio40L3gEC +jgeZmLODDiQrU9U1YtfiOIUmUotnwDxZOgxAiHB6Q3hTti2urhfBtA68NR3nZOAN4aXUw+kwpal4 +ITvu7pbtxyvCA0NPoALy1vDicec924HvfKPtwJ3+EA6XnESRXyoUwtnCcweEGfegy6dV/yR7vcJY +jg8yUAi+Ub9cmZtmCAiU1A9VPSgbgRMri0+DtPSrtgjvCxENfVxwXGWO5ZIJIq9kmNGUfnG4nR0o +7KII30ubh76xNbVATasXnMvJDYBMINyOMQ1t8GgHOOpKjrJu4OxAFK2JophQ1wNCnHQWUhBaqIXx +gstppalYXSsn/WQzYpOCLwjklNDT2hp1iwdrYDsQuKmmapkk0MEG2gOwMGXQJYogmQWgU1eJ7Euv +zEpqKUKErghawgU8QTzCaUG0tY7usWulg8SOdBWknk6Gc0Zd+rPcEU/78hayCjdX55FVME/CKjgf +tfuCAiYEqJXktBSmWzMot7IXGAUTQa5Uk9cJUPZeEDjasrbJWZxSvfpMOrLHbFRR05aBDDNMByt+ +0SqgOqxs4N4Tmb9tchhrYnAOAO0agJYCQOpF/Etf82TAJynTeallbc3KruQAVENDBJx0gKbvZgDL +CZ+yKagrVrDmENZA4EXO/EV6VYtOFBj2hjaV1KXss1EvH1bbfL5NIsdrLSx+JUcyDg6PPa75kltT +t1u4cb67/XFVrI4uP3L7mKRFNXO3BWUlcp6kx1cdxNlDJZVBL+6hwzMJcpGBCn5e9Z93gFQjTtME +EpTUoz9WYBFhZBA7lH6dHYzfdT2Mhcc9Ppth2HHut/EDBEIYD3cR/IvgVDIrDgdu5VZyfiOoB/oS +6H7ZllV6CR7VCz3iRR+URnHbRyO9dSKL9eadTdR0M/v0+fV1UYtpIMYOp9E+No1TPbkMfuj0SVwc +4KGQqda6wPge4e6Q9C2BRBg7JKeDdM0tsCQBhGlryboClTqYUD6jAbOsBiIZzor0g4hkSqpyCGDJ +ui/ZP3e1J1DqQaohdbHv/3E2llmWReg3NezGe5p/hW12esmMcNnNmvgBod9G/lHcSw+8ZEZIE7x8 +TZBDQJimaVR0sI2j5dCXYFml2Spgy/SeFLQqGlA4OVNll9WtnqW8PwGyYgOrpYvPMi9V4FRJ3VAz +9YA4d8cHCUQ2qGpWqQYIYU2aO/465sUZbd2EDlSwdNWX7gBZCxksdqOrR7uZup9UdniuI6pZ3ieR +EyzggUxhlUOytiIMCiK9OCDW4cArczzp17GSrKp/l0hUKpye8+nqQLEXqY5CA0tcrdpCKgo3i6ae +tHqVAVPXxl3vh6XB1qNRT+dlMnksN53kfA10XIy8zkY9mZLJAMbGw6a/VAHyTN1TGghzlgZtR4Ml +3M17mLDd0MzSW5dBLZ3WGV7WkDoSQA87IfvZNxY+0DarJQFSU2cHHQiCZ+NTbDWqQei2oeCZ2uog +lE+0Q/1XXaf7qiZjm3MEGv8Q8YY4FkmN/ix4u0HrbK3e5XpLS0doMN0hm24D6ZKRXSLdlj5d8x1h +XoUtsM3GuuifopHnh8lQSYDqzcgGZx81IpWGKqunA8TGzg4yWHfTR1dRm1QaqbUIUA== + + + TVTsUvdR1+uuovHYPn265ZwR6l/phKcHTYRaixAcLDTWpV5PGWdcQ2ph5he2p2L8RAdqEYbVqLU4 +pQhS1Rm0TC5UHUBnCuJU9k2Mg+9riYDU0tlBBxIpvYo+u1oLktuWLmspAXRy2Zv+m9jfvpbRmD59 +ZqEOQeCH5hKJD8glAnUH4txKqHmqHJdbuBKVejGPBll3EGxaK8xFQ4KkGEdNm4/x8x0AujAX3cci +SPZpG4wqQWM9GSg2Ri1VB/PUfqy6qkT4qVoX+uYSANrR2KUE6ocRaxmP69MntxIZE1fbcXLTA1gS +MBG8lEmYcjSVE4qM/5Md3WgcXEnvqKse0saYESH1VLgWDJkLQDBVOHUAzDQmw/UgA/EacnaqpQPE +hrg6HQQKw1VXCdIl8Gqk1FACQPMTO5NA+QBYy3hEn4ESw7/PJ1ocHwpNdAZRnxdfOZdLHIUgnLcg +dThjag2f72CI0aRfIZTabUl1sVEeOtDny/UQwcZWqC41Yd1XBuoq8IJdTR0ktYfNnmBCwpwNXIxY +E1S/pDRdewlydtD3qvuq63lX02R8n4MC4wytEwXWB1Bgp35wvDXGg/m/99BzIqDWhgoWU7YUahII +enyrdsy6aqmj5MkB8yNCdNMztrHq8BNEXTh9X0UH6Jo5O+hhBrccuVWqRfUt6m/AhjrA2UHqSwfq ++h8rmYznMyCzzKGJx1z8jVQqQQ5Uh2POWHiY58SYQuOIaCBjmV9RHeBpyJITM7Q19crUpFvYFNoY +FIyTRsiQsp+YVkgKx7izk36YnUHdNsk/Ho5NQkkF0CQSwQjyM7hkKMcBE3DDDGuaGKeNhg8LfTLW +SArqPpClqMGrGqYc8eoUB0sM7hnirbcizLtQN9BsMUiQBknPjCu8bIqswKFTJX701qL5sOEHVBwf +8/B3rRoL07Zm6BnhARaS4byd3Rs6VKk7XNnS3QuzyFweZQtjnMyacxpgWac/ANINE8YIuH7WFil/ +mhhcxKw7dUy/04RIhoPVfcCgVznwKghzus9cW2lkkRfUkJmEdUV+iWhYrSnb1AFX/zk4ejf+sKxb +Tf+IiUjeF75s23nNwnUOaxUqtUqIhG7XlqyBQM5rsHsblDLM6zHVRPRfFgIjXH/w7WMphB7z61q0 +LE9zvXLTyBr4mX5yScO0Tq30IAI+rGeiGaunFUL1HMxmBdwYW2xNeum0PqihXwOYqTOvqKgvsblq +eJ1Q2SFEF6f6sVRUa3wSQDgF6uSW42B5xHOrZkA8w2PmDGTJqOuSSFCwq/LybeWVaRmCQbsmE4ib +JEhgcfIwtYAccWSRKziCY+OH6FGF3pJ8CCWIDGNK1mmx4+vInmCIJB9BWZgapQFAUofjA1IHcIU2 +OsUkhggaFykynbnN6AVCEOuWKNm2Nf9STihh1xQC2tS4CAKKJyMHVoVSIZIN2NPIgNWk0LQf1vTy +Ql4O29rIaraGrKbHV7LLQDdE1q4gyNEkE+Qb2Wd+TXnTwGembaDQMCCUkOuOlHtp1Hgj0wxjyby2 +QQEqZEuiSRMEAulR1hSVXc/Dl7J0670Sj7ndjrJ4rTo/epF+GvnYaJWexlsUGNzYl6ciTa7NkO3U +2GicblVbXWmSJRzMrlGxi8c5PR8NHeU0gQrcQEhn6C13GFpDpwQmXOJXmujRMTeDXjDJO+0KR/6X +agkLbQbthI2KkqZWF0a4YAbonOD4TdFHyE8IjZrWBTnpWUpfe3QQ3DMM6bzkFdtL+J4kc5+BJQpO +OG7wO5S9kDlQWRf6EuAZvQdrD1w4htlRTltNKUgdgtWSYDebSh0IBjO3MRGpYHUDWrqGB5sxTt0D +ZevIwEtozTFWaeyQIoEKqP4w6tZg9KS7QulC0CwbRhUBIlUE6lgMUivUdNeXI93CuEydoHdwYm3X +lLYyb6W67RgnR61I5Q3952H8cnWSWst2XsNHdFcr4Tcv31debyYZl0NYg28RVFF6yEEsNq+/wmqX +MLGSaWkZqvbJdGPxwjzJ1SQiK5WmfGmqMczhroZxqsrgycJcfXVolSFtgqOcUssepAhGVS72k21V +e0Zdsm4xU6mDmLpUgWNlxZVKOQB4r4VaiNyU7Sz9dZjFKfDmIDWqwV+OXl80aNf6CZ0GVdcalZ5B +sxwWZCmC8rCqDZHW6CQGqZAXYJ2RrNGjQBAO+mfDrww9ED09e7WcWnJ8DEBXckgRhZ5nqjbpzCuN +3uE5ncdN5ZbgyBLrbeDxb4QKnnoGYIJXQx54nvhkQiowBU6VFoLJJNTG06Fept2omtaDDMtqyVZu +hZ1oNUuMEIOamXdkrgIEUb1TbFQaNwEd0oMvhBK/nOaqBDPqGsZeWRnQuqLrGj7Ss8m6ulFvLePs +2qKyM1OeGfRNeZd5XdZbcNsKNIjTYswniy9LV+dpmA9Xw5vwZckIvMTUI9GqCw8dkyoyFjjyZQdr +6CliJfR8566HlzvEGDU/krzIacxbcoNQjorPat2K+hbIxXBzEnpRQ2FLfZT3qqeiTkQjMxx9+Vrd +qU7fwG/Tl3QRBXNiogGLsc4O3pKlbtmocW4Oo8MfYJEINopDgLSV0a+cxoiUCDOh96/SpmM6xaqK +S87WspZRQFUEz39QkbryVMYMJ25jZsPT5/FQY9EPYZcRYoRM4LYWflsVaTIJ0q7zoVdytEiuJQTD +wtsLXgVwVgOVrpxqDMBHWR+FfhyQP9AY7XFOQxTzbYzCnRSuHTg+6EqrGqaLxtdJx9GCKjnI+rin +Yk6rR2oqspWhuGdLY9YVFAIAoVfVclSwHc3trlAIwVIoEWkCKNsyfDqnsWxVnoJAwJu5bNwL8xmg +70wIUJjsghh43TbRQ72qotayamLsVqW+uiI9tupMYeE6RZ/xSp1jAcPR75HhxupH1EDDjZlf6yd1 +G1UOLc5rbEamNDRN9GWFaaslNUBsPnXS8ml0wGa4TdCcccrDlHpjHQgEHdzlsCFVs3CQb6MvukjZ +cJsFwWhp+EZqBOZgVidkSzWNIwAGxmOYLUpyGXQXLKOxFx7foGSkOuNJ3JivYK7AUn088aelkr4F +JfKh9kjiBi4/xNi2aNWxTQkWvY6bOeZa95qzSYMLgsjdh9TCBOHdpEqrsgn0xNARtE6grqzvKe1o +IoKzYlM1zSFDro5oLKhhX1TdBrn3eW0f4Y5M1zRliMoN7+4rCla1paeAoIy8VxllZr9RXApSuxH5 +2E/mLhau0RMQD6aREM7qpWWUgWajjTw85A9scSiwcbrKPqFHsfNxHwuWCE+gBj2c4JYOSgwR0bhB +bkRcy0HxQZ6hHEVgjdpUhRFA1AQuFFE1ABl8qB2kHY0i8TFaAnIi/rbQejkGM/Hgp/XFVeBfGqZX +h/tXzZjN1oAcyBlIw4ah/QP0xsV4KCGANSiIKzXReHlIjSYd9izdyDVehvGzVO8KNQPRojEFCjCo +Y4XejedrYw6jrUqGN1bMdyltNhpiY8CuWWFnhK9HxEAbbFRKqz4DVsGSoQZepKgV7vu0Xh3fHMk/ +eXOGYDLXmatrJRqIWIRKcwXPPyG+cuRPCwtHAFscpCwrtF8X5ojz6GEGganMy/E7r1nseQ+OAzEn +pgnUKk8L1hARUwICqJeO5naX8k/APElZEDjffDqXsXxlnkSh0SI0f27i+CciFp37eH5/SUvXnBjq +QMeuDgQPK9qy2xgnJgcb82mkn6pYb6MHBUEFS/uudP+cGlCZIcKapB6I1SAAAoavsv/J8CUNdYuQ +vs+x+GQQ9+7jRo3ZMXmiSFXMehHihIh0JHMqh1oUwYShtggEtJOsihSwYGPyciDSgzy7N6JC4kNs +HZy07HGXMcTQ+GgdHFn8A6UboU2+CRpRP0yruLDpo6VNszSlM7WdxO33j6E+bOqaOkWkDDgDleCN +ugEy6TVBS9CJV0IvRqiNM3TMwq8n8vzP8m+4p8m/oeEpfQbX8okCVJAdYxSgoqBPCFDBwX9fgEr2 +bh+gsrMBKvvYlJT17tliUz4x8d0+RGUforJLISq1fTBEBa4+owgVgB4JUDHPGKBi5gSo0K1pEJ+S +D+wzhaeU8YbQ9NCFqJj5ISo2ixq5ymF5iIqZhKhUq3GIii0/U4iKVjQIUalWkxAVMwlRsYOKxmP7 +TCEqNk55euhCVD41RqUZx6g0kxgVhl0PYlREgB3GqNhmEqMioEGMCmoZxqg00xiV5gViVGx0i04P +XYxK9TmDVNQrehCj8tkiVIbxKWxp98NTVKzMw1MIycNTmA5mW8JT2Jk8PCUNoAtPyUf0mcJTYgaR +Ij104SnVs4SncMzD8JR2Ep7SrglPacfhKTp72xqe0ppEffUhhafU5jOGpyDf+raEpzD3+6sITyHK +PBye0swIT7EzwlMi19CFp5hReErdfqYAFSSN+tQAlTroQb+lESqNxmzw0o4HI1SqLt7DrimbIlSa +hyNUwrxmH4pQGZR8MELl4R7vI1ReOkKlUUZtNyJUpMzyAJXGPRqgAl5lH6CyD1DZB6hsFqAiUzMM +UIGWMw9QKdt6GqBSbhigAu+qQYCKWR6g0o4CVNpJgEobHg5QKScBKnbLA1SaLkAlxJgNXg4KT33d +TItjVAblU5RKWBulEpKsWpu5jac4FZPiVPRe1mlRhqqE+aEqo+IMVmlSrMpn8CDdx6rcH6uC3fFZ +YlV8vFKwi1WJOr0+VsVtEqtCvmEUq2LLSaxKM4lVcWtiVdpJrEqYFatiHo9VGczjC8Sq2KjwMJqu +d33IiA0pZCTksSosEwM/7g9VgT1PQ1VsHqpSxVCVspnZbh+qUsdQFbs+vAahKrgLZU2oyiM9jpEq +9T5S5RkjVUozjFUxj8aq+FGsih/FqlSTWBU7ilWpH49V4cUpTxOq0jweqZI4rm2JVDEaqOJToIqf +hIyYNoWMmHYQqNIFfkyLxjAVYaximEqkEAxTEfKvYSprCq5rsw9TcTFMxa8ryDCVMqQwlaYZhKk8 +0NlxkAoOqn2QyucMUmnaJwxSgfpyGKRCP8VHg1TMJEilmhOk0oYXClIZTOI2BKmYLlzDmdlBKr5Z +X3phkMqjbd8fpDIpOitI5b5+74NUnjVIBYrEUZAKnE2GQSrm8SCVchSkUrXLg1Rw3chTB6n4xUEq +fhCkks/XCwSpiFzYxCCVGC1SpcCN8GiMiqxrjPoozbRwilGRrRdjVGrTxaiUbYxR8fNa7UJUTAxR +WVeMASphbXzKw11N8SnNPj5l2+JT1I/nvviU7O2nxKc0D8WnZC/38Sm7HJ9yHyql+JSFyHR/fMp9 +6BTjUxYi1D4+ZW18yt++/34QlvJ5Lx3SO1IRSABndrqU9SB/mFDDec842JarCuU9PPwT4IzXbOJe +v/6TZlhH9xybUQsNQbxakGkztA40P2gmAeKdhehK903qa1fJeDzYXuux6oc/n/zjT98KRv3m7OL2 +TBbYvvnt6mtegFNi1eVlttAhZiGg9GTUoAUfGU0VQNAJQEI4Ajkd4XgatVo5mIxosw== + + + pOtKW+u1jy18kKKHJ4aJCwTLqMGpSpiIhJuiYz4aKA0PoboOahaLoAIhPMgacEK/GUOPafrCVLxW +EDesCrxyAY/DIRxPBgUveS5L7bKBUp/d5F/BbxXcCnwjQqmipOfV0XgTGtVHRQjuyAtN7LTCEpqc +HNh0G2+D2wPZamMq+mq3mjFy1J3jSQdPnuNqMiyOW3mDS3wN/9JPCOBKXdq269Kl789Pb89+1jul +NZLos1MOKNkRBg35AimfrggKUIBT6UpFB4yscMIy0e4BfZu3jFfn3gb6Qy0mPytcWSbH8iV3hMg9 +dHFufaneGPT9EWGqqisFwDVrBdcB3KFAx3/ToHF+K4tyCanMO1+RgjS1obQkAy+pSWGbvHoM117C +Lb6JdMnqtQwUg+TsumQsAiUgXLAGwQw3+5bxmRkVYZ8BhWwPufHOprNzSSydRJ+098ehfIz/Yeko +jc9YPESNTJZFgYsXBuf+ZGkA3GBxpNh0eQS4yQJJsekSAbh4kdbMFmrCgfEPTjxX5Ks3/ZosXQuo +2Cw1vQF2ba4FvBmhAXAoUyI0CV9C31bSVOBtaBQI70lwpBCvmxA/HFV5L/AdyUvq+D/yS2lCFFae +5LL5FjK2IULVsIHRcque9glkvGpEAbDAQihLWh4D0Hg0uHnUhkNLDhVmTodJ4MWxhic8RVjc0g5F +LZWCldGTgVm6cAZBh4tbbmEQhjsQXD7RNSpcXHIBhVdZVdcdxCOJqeUyCH8feDFmzQs7vYiDqiF1 +mqUuXVbLa3INE2Oa1gWNgPJ0UOEt4g1D4WQ03CPAyrZEjJgIB6owlklB3svxvKUAvAQnJyXfXR0g +go/K2QQS7Km8j5nzReTitmlUaY37TIPe5YrZYc5R4b01TqfmfaF6/aPmNISdWfPSY660nNO7V+G6 +2zIyUnaTr7G99aJfeOvAgUPEJgctyPEBfHY04MPBRQ4cCFXPTXRITwuRnnntOX8lCKxr0MerN7lh +6HKpl+Fa+uQcw+ym/oUNonxqJoiJ1+AYVVrL/okuy9VhVZcsZOmrR9WaxqiqCyI0Vh65aHkfpt6/ +TgLJ29XjXScANU6v1yxNUJbV0bwoSOid7ZdkvGrHk3V8+L5IOIfKkhjbztRoPPc9700rzJlvcAY0 +uOe9BbLAAQGX5W4hP3R3ersqViLy/frbyBDFO1xnkrUSqCHbWiUkOEnx8ORd0icHcc8HdQItCYKJ +0Va85VdEgCqy6CX9xYCz3pBSl5SB67bGw5r3a6qZNjbpUN/dOQHWiK+WbW1qnNpQlnq400GDU1ct +tF9jrZfFtcTqNFzE39BLIhJZOHPaMct6EB4Wg6tlf9KW4KClhErZlQ4RLVCSCGGFArGKlz9Xwgg0 +IJQiFIoIH2OrIRxB3311AL/+VsNBHTXaJwJqKvoI9rdTN5EHAajU6bO8LotGu7qFFZ4z6nB7FHwz +LMsxQAlmYxg5eJ0svP4Mw+zg1OOVDKiuHT6ggTfH+pqabqwHRDEuBKJMm0qv4J28LyaVFNOGimlv +immXizUDK9aMv1gzTcWa2cxm+6SPBodfBCITrlC3N4yIaeg/w/Y0Ea+cnTWrNRiGYxjzCfdNSgNq +eSlxSedpq0R1/HJQdljvmpazro0eZkd+a8j3YIxfvVnTlNDIQW+EbuVdlcfxUFBrP1LlrMdfFKNK +inEj6+Z70N2Tg2Fot28iowdCJ6e+IIcQEgRhtzGLhGw7qGhrurYkTGPYTBuZhRNIURqPg1vjYd3B +OKyn36LTkD8aepoQ7ZEwcx1Tyc04EOo1rOOqGTqXFEhEHxiVXzPE3XdO+ycHcOIDGSroZV/qHoIW +gabPE8h5tcYk9x8gwI2qmL4aBNtpyGffGPWYuKIq6xOjlxByIAvCSKST6UydPKDsxpCF0eLdhEVT +w+1LnY7hVDihmwhNbkDMPRg1sH8eiUtqxmuGpopaYkSeChaAzVUG+QdE0wrDwuzH8FtDxMq6onVQ +hUqwTTQCHZ1t3OrR3FZhVWrUjlVDrzVUa9/Hi6STvlyd3Vy9v/l4/Xb14efT9+erq5u3+TH/sFp8 +DV6ronuE2Qoc4TZF0E2wWzXvI/wGsZhguIiPExz/6s0aLOdW7vGcIvME0wU6xXWShgm2R739CN91 +GkYYv2YWT+7Xxy9Yukw9bp6HM31iBrLPE/XxU9nH9n7+0T3EP9Kfdw3/WEX+cfT+Uf7RdfxjuzED +adRk2kIQBFNnGmsCGUgve2lNfh6qmXxK3hAfYiR8a5AWqnUQRfP8PJ8pO8+Ag7R0cRlykJYeRgMO +0kZuaTkH6cizwQHrXg7Sfw4O0s/iIPPeLOEgR+Mv1kxTsWY253GQbbuQg3QPcZBuAQc5bHkpB/kQ +wziseR7D6B5lGN0mDOO4Kw8wjHU5ZhixkTZiGBHJ8lQMY92ahxlGtce3TTOLcRxWt4xxtBPGMZ+x +z8w4wlVXWbh2KeOIfUkWzs/iG03PN27Q6NHMRl+cbRxi92K2cTmOL2Ubh6h5D9u4FtsfZB/H1S5n +H+0a9nGI+c/JPi5n5i7OfjkHP/e387ebMHOwpzXqQQ4rNJJ3KqSIfxM4PZfRJshvupfTr9Kvs4Px +u3HhrOL4E37mAfAaYWgwZQAnnNEweEGCsgzw1hQer6xLfhkQ6nSC5D7GO2YwCV51bpXwCF0T8cdx +P/JZTKExJHO29QikAe9SVrAqlXRtADWY0LkaWJUul04PBblBIhuSa2vyk4lqsa4qoTDQY8qwO78r +Z/IfzoqM03J8IWiYFLWLKXEjrKKaubEq65AA+v8iQfWxVL9XnXemCkD+lxJmUA3RY2oEx7RcraEJ +wNA3wnCJEIiFiTc1DmimOygr8rWIx0lN6F9N9pi1Hfs16mZJY82wr8XkmyLV2ed3tBGRUxpJ/S8H +aNVM814zcCi95DsHM1FJOZoOxvD8M7DnOfhL8JZAvTMUz45ZGQFpNIcOIYYx+VafjT43rnvkVDNL +bM28USBFnDPjgeh0OnZMQcUA7djjfBT8y3A+u9IxH8exb6IgdDaeFw9PmpqYH5i2M1qTl0wcMt0u +nLqv3kwn717Yg1OK7j48qZPskm3GUe7p5iy6iShKZSN4TiMvGAOLS8q2xqyxx/igiWJJNtNDQb5K +yKJT3qxulDcbpbv1rqTJvxVpu+EPEypm0hJWVImkMGlAixKB8IhLKREahXClPdnck8092fz8ZLMZ +COLYEuCJRP4ILd2IEii75QpMPjQ36CD1Yb7ixwlwJoKy0ejhCEF6QAgN8MJB4Aiz5jAoORwyCyQk +QE18VtDZJrRg+plHAHVUq17w4KPGJzlSLQLwfzqo5GAAElnHb2P1HjkYktvWMLFDpcnnHDxgHTI5 +0eqpWYE1B5OL8ZJxIlBJOkcGc/VQoAJIq5O5BkdaVBb3TCLqCd5ta1hT50XUo24M6cQRDFmBJBiV +j5FskMG/Vq+9DLaO/ikigtdIYMerpJACGj5Ca4paX2nqOpHDkbdAL7rZsNGjmY3K4sIWD+ndMqRz +QUDCGrzsgYswE4LtYtz86s1S7FTKMxc/dSxLMTS67S3E0dHuNwOmabAG6azVpJN6Kjbq3NiAGsIL +EvpWzAk9Gw2O+LLmSQTZSA70lg6R1FhZ+e19MwDhK49ESU3NjEQtkp5I1XUEIBuuY04FF3PpQpNs +9UbYoJnN28MudSmTPjHNCkOXg6ZsZG4WelgBRJX2CUAxChtfOWptW/Who9ufsmXMX11TrWzSc2Tn +eKmobGBES5OvaOGexit9MemuBOFuGDvNs7E0mqGZSclODugEG8B7BK+WEkS38Yyge+AJeRG4FpIX +aZQX0Ty4gOAMAsQyuhv9sQF4WJd0zxuzJ+nXvWpCX9MvRyprmfC9DrI0DKlqy3UkChhW80yF5w4T +oDgExvEmLcToqtrNaeqygLxHTAL5A3OCitCsmzLAELi2aFXjkmYkYRNyyR1zdLZxq0dzW3XIDoqE +TybwMrABjTLDpLJrmI+0ZdR3eeGmARWYbBts8snGAXD51hHGZJPN89WbNduHwPEGEuD8LaS8zJJN +xBKjbSSw8UYi/zXcSgCNNxNho+0E2MwN1a/22LLR2PtI6pihYxJiOnPW8cYEPlfwb9XbAvgM62kg +i8eUMdgQnLSSMfJ1hdR0UAFz+Z+KkR9BHqQipewqCIiGmfHg6oqMmut0cESMEjkMZJ8iM6yTA42h +7YEe2by8pzEQKw3ypDatZp5FEhlE+vDSduDOuFhtaRmUYhUCiErmYNyktaM5rQXm+GT+FouEPMvI +xhQtFLYIMXg3x1LUeFJRZbAn3LI9MawLmUAq1Y8w5YiHiQhXbjb0kH8anL8Hw50lhlcW6oH/n733 +zk8lSRoA9wLcARkECFe+AAmEB0lIQgJ5i5OEsMJ0T88f+9sL7HH2GnuNvcamKe8LeNPq13zzzRtU +lRWZGRkZLiMyoAeEw3cQQ/5JoLMYncMEiCx05SiKwxNyEVgS6nQwBwEdxiDlGF27hrLl6QSYJZaU +gEElEDvlUWKJ0acsL1xMRkH9l8fUR8I7IdBllIC5JYRof32vLGay6JJCeOG7ICkd9AqFbBxfkkrh +c3clzTsmci3VuF/rtRGximCZdR4CNZotQAvq0m/Oz4A4FtY2oNBlHQR0a3DCZRcwrIKEF9VWFY9Y +fPMUvEwaFdUSvoIXX+MG+G+go2sfwTNqzVcRHdyIrnN4XbF6hFXtkE13UwLvJjJBwmAeb4JAUTYo +UVQvK6S0eZrHIUSw6Bq6+0F4wyHTlsbjQxocGDEpJ+zDb+H5MkwxsfkWbEcGWHzqdH2X/ebc90uh +O2iB/invpQW8eRgdisoEEEG3/PL4CnQUp1tVPmPwpcURDqbE87gqCkHBYEx5yYUneY/uEVg97XcI +NGojgJYfCP3nPWiQljTw88lWi2lzPSeB755AV08QKBfQil5hVjNjSzY8coqoqRVCt/0SyCDE4tXE +6qbTnOtOKZgTRZNxV5qOnpLhMz0tq566ombfqwE9+16XomjwmZamwSMtzYBHerpWPnRM2TCOQkfb +EBVLUTfGoXasegpXyz2WVJRoU4gnaLHCW6JhJN4Q7nWpO2FvMzI+0SX2HIkv2kfXSKmmy+s3Mi/t +P81XER3ciLpvBl1RoBxd1aP+y9InCyu1QxccvEOGgnmYUF0228j4ykyCQHf6wnv1NJuDJOJ4H8Yp +5M2jKeVmxvml6JoC629ZDtcjUOzmJXrOue+ZTAChB1VYeUsr1ogTdqz2CRIXeGmEJ9CvksDFzWhg +UXnlFYOinuGwsPhhBKQcIofj9TTTiGjnqUNOfr3Ehi7KjNuuOLycAlYgUNMauv+Vo2y/hsweFm1U +U5vLrnNLdQ3T84EIsY/EW0bdplZTt0mtus3FdXoLF9dwdyRgFNydi+v0FsUjUW9RfBXRwY3oOhf1 +FlKrapHO1O0IdBzGSRQQj6/OImH2o5X+EgFmIsOi6xaQTkBz6hWF6gcNLUGalqt8KA== + + + voZeQ4ay/TpOYdeo+oost33nlukb6uwEz/FqvVteMU5kfDz+C+vIQt1Kr6gmoBuB4CXqSJlgUAQq +idyqeY9Kv4AGbtWj0kGgYarSUkQi4uPS3yoiiitYHrohR3wU0cGN6DrPC+aCcoyi+qucCALOxvE0 +Vfiw4XU0vBCWlUgMWO4JCxLDDmMCX0ZNMwZMg1ewHB4a7hpux8B6aLTt1/CiNOHkcYW+c0v1DTPZ +Yd0iF6eeagIUdFuJBLFa64YIkfqqJUPlQ8eEqBqcSIpQvVyKGEV9X02OorbqlCA14WC8mcsRQyV1 +9nTcwJ6O6yyQuM4CEXGgsKeVjwR7mtNaH5wCtPxAbU9bMvmfL5e0mP4V9rSapWMDFYzLgT1t+qW9 +PW3Xqbk9bfblCvY0aWBPq2lZ9dQVNQs8R03Pgj3tlqIFe5rU29Ok3p5W07XyoWPKVvEorT3tmrpF +e5o0sKdJO3t6ScWWhX++no9HtWlvNO+NPiIR/Bipu8oXnvMJfBPHb2qDBfj3ovXVbc89+IJJb266 +mH16z5qj5kd3ClTjTncatH7nxS/zzcGgB3bq5LPXFlo2xuNBDKjYk3nUe/FHE/zWNwVqAAChbM9a +tjdoikCUBs25bXsatb+C6R3qtgiEwQe82Qf6tngiJKv/AizoxajWnH+qQOc/m9P2WJ4kaIVAGDRt +dP8z9xZ6f/QAwq2BNhCI5qQ7BWyzPp+O+10wsChec0AkqhVfM+WYIAZQiBIp8E+IJfj/BIH/i/4S +QpCtRrtU5zL5oa4p+B/Oi4pc4G7JX9ItrZkyDf4jTljxn7X3i1ENdwPqlvWyosRM/OpOJRzDTknU +IeCFXhojmfwF/fIaJPNe3i2S17kDjPYkGJe40xExxryiVoPbgOZeKuYV/wMxFfMidJFRStJslkWd +yYgaKg6hGRdFGA/nlw1Gwd3MUARvTfBy8rhgxA3JczCGCOZHotuYYFwmj/gfNBvQqAmno3ZNBQn8 +RryKeeaJnY7Gf47QH0BmI7ke9MbOwTS8YU8sC+T5H13xbSwv5BiWegMwM9ge0Ehv5MUN8FOs6caE +JmGgLMRuerNea4AA6iHU5812fyUIbseQa856bflzvMiYpLwX7++zLhBopPn3wgfHg8ECXYYxnkab +kwlAGl4c8FFXQF9ABdRbBaj0Ft/fwdqB1o3eHIGjUD+Di6nQGAzQ6pbuwPFo1oOpndJddoXebDJo +/oX/hCmfMQxJWDUwkSsPIDaeIFElrThM/ENXOfBMnFPl9MXFVD6Y2xdHldBIGiYA3mWN3Yuggd7B +SGI1PlbovnsPvB5vQDGcIEYmvqEEP8fIEWcV9hx40fy9Bx6A0eZ0brBiuUF31HGx4Fb4jCFgMq6c +OVHlycmfmwzeYh758aiz6M2dzEEJZe07ANLfmtApXT9zPesW/+iOLjodRJKwCxnJrm57EQpMKFK9 +DGtNIBsb1mVBHip08R4M0qNh8VqKMyk3Ia+jNMDfnAZ/nyl5YsX/dNsLOAT0An1rJM/g/W3cRqj9 +ZkLNKf/YCKONMFq7MDKSQPhkiISHIOjwkeNhkUNYawLf9ryRQH+jBKL+dgnEbyTQbyaBrla8hdnE +qDKgyo1JtZFi/3uTyvVd5huB9g+fkiuBFt8ItN9QoHFxOo6y6yjwvyz0ASbiLI3vfmUZeJcCvCFA +8GCz+O4aAuaNwIJz5n5CauMo3Ei1HyHVEnF8lR5D8eiOSRZWukFRKDCHOrHxFP7LxVpiI9Z+M7G2 +8RRupNFP8xQSgnjZCJt/s7CB4ZMbYbMRNhthsxE2v0rYOMk92Aid/92UdEkPf4PYoX+22PnXCQ3o +eKN4ApbNRTfkofMikmcYRhWfx/MUy+Ca0gSNPHE8jOZjf9ZR0pIc+3fht2QcXzpOwDIg6K5JzHlZ +1qB4l0vG+/vwYFfsitmwqx/HrlaqHrdhVz+GXQl3JhB0nIbHPohbwStHOcbo+o4Nv3LCr9gNv/px +/GqjXv0e/EpUr+D9/qSsXtE8Kvq34VfL8KsfHhz/r+NXP8WH+M9lNTJTN/2B/4PKLrniSxtuYsNN +fnig87+Om2ystR/BktYdx0Ti8FzAyhJxVNuO5RMMgUuCEvHEGlIe/6X8axPXuuGAzjjgJv19c7T7 +w6RBgsFpSBTPw4sF0U28CYo1uJxyc+b7D5+SK6G2iWr93YTaT3ES/MN2zUYa/dr8dypO0wwqAwvv +k48DxQqVwWM2oa7/7vx3jvjZEuhfJz82bqF/Juu1MwRobAeQPCw5Bkt7UCR2CjEUw21CkJbkXptA +/d+N/230543+/AP1Z5pK8DC33hvhOSBzYVBDlCcY2qC68EZ//jfpz9RGAv1mEmhzLPEj+MlGkP3i +YwlUKoZkGAZdHUPCMjPIHiHj/Or2yO9Chb/PlFxJtR+eibaRahu7aiOO/jniyOK2DSFOnIpvbuL9 +l1tSPzydcCNzfowltbmKdyO4fo4dBd5HGQZQM7afOIriNnd5/Mvtpx+earqRZRv7aSOG/jliyMx+ +ilIcARQsr3g/AMuxNLsxpP7lhtQPz/TbCJ+N8NkIn3+88IFBEcCC51iv5MRjE4lNRsu/XPj88DTN +f53ogD64OMsTcXjMy7FxnoTxpxxB8Mj3xsV5ChW7JuCVOvAJKRcPYXjixxUZ/heFFBsWf8JxxFyc +wNFo+FowimGI1X1Ovw8TdsWxNjl4vyPP41iWZDh0sRgPa6UbXTlDw4LqCcwXcYX1OCoCuCmYtNG7 +/372b3f2QJI4sy/BMGQc/mIIlmVwUgmZYLhNaPK/W7DxPzy1byPYljtQZ2giAYVWgo1zPPpBxlkG +avUEQ2MxxscZmoQ/SKjLU7JWvxFsG8H20wUbJ9wkSie4BLpBi4mTFIE6icYZktxUuP2Xy7VN0ufv +Jtc25xsbcfSj3Gz4fIOhgRKNTtdZKkpQBLCoohSZoDaW1b/7kIPfJH1uJNBGAm0k0C+UQAwHD3rI +OEEmUDkFLh4lE3F4QJcgNgLo7xVA5N9fK5DfZGhuRNBGBG1E0C8XQQTJ8TRcOoqPMnycREUTic3p +0kYE/fCEzY0A2dQn+jvYJk0htslS8TiKjWU4eM8KqlsHw/CYTZzWcuxmk1P3uzEsFJtK8TRK/mYI +BuoZUZgDjoKyxDAtlBgOrGAo8ngcsfXDYlL/YbtuozH/L8KzuM0VWz9Yf/77xdkPr+65EWeb607+ +QVtvI9P+R5fYw8isOMMCSoaxxyzBiBHHJL2Ga+x/Fyr8fabkSqb98Mzzf6VE2iT//SNZsUXyHx8n +WehZwrl/wKggNvVDlmRYvzRb2ZDdXEGY3vx4OupOZ+tiNxqgEouxXAvAf666TUC7kLwWM7MtuHa2 +K7A7x9+75JO/yC3++3KnJfGz4ShqjjKdNv/yVsbT3n/HoznYVk8BnvJO5k/Bf5ROtNmc//bNiaVO +Y9oczd7H0+G6RJQCoDPxJOFnLn5Za87BGEZIUhGi8BqO/+jevNbm4lP8zbT7PgDa9p36YXPUGQ97 +/+0aNb2HDxlv7BjoWYFJb1Qb90Zz+CwhPBsthvnxpNdFHfGUsv+Kon9BpI7nzXn39QpI1iYeMElI +L2ft5gCOuTttd3Ef0mDQq2pv1DUEV+h+TLv4FakBVmq2AfaNOqooOyI1r+TPfj9j3BHbLgOEjpRs +uywo2wquXe8NJwOJa7tR57Eej/uQAcPv0I1JJlq7YASAmQASNB/68Qhoe97yYPynlwWCZiNmNmLm +HydmZBq2ljOF6XhS/2x2xn9Gmz1jAaME5dgAQpy9NRghnBBRnhX543jSbMNn0oPWYDE1Nu0NLhbR +/sD/uWu69QPImP5oD6YCA0dj/pj/NfkXs+1ab9T35rp/dAf/YgOe/V8Z8L8Ik4J3FKh1n+vCowqk +Oy7wNZqjHcVLLOB9NheUQkHVG/SGDvfc3+FilLkOx9IEPnKkErySC8FcesHTy/EMuxpL+jlnOb8k +IdB0HhvdZXNUivR6aKc1p0rFPkpQ8KoxL0mzcNPRMF+YZ9d/JypmiKXFf//7l/esOeuvi32WuoBx +Qnw7Y52kZGleWUqgf7ZC8gspfSMHf+xWhjY6g3YxZWqoL2UI/T4bw5Gmjq22jXNiI+B/inb8C630 +5eQ4dG54xX2yohdEBcuhGSlJ8U5z2lc6GdqzKXKCUFGSE9v80Z2KnmSM+EmzhzwTEWWrz/H0vybr +QLEMDH6k4hwOhsQrAP/qL4/4mcY9YuXS4YARpPXqbFi2gmU/gqfNxWD+bO0Dd7ejUCgSjDxi0aon +OHSHIR9PwCtLpZm6iYA1dpL7sseJ1+Kok53O0Whn8AkLn7yej0e1KWjdG31EIvhxrgv2T6056M7n +XcRhay0n4ww8XoEPkRIGMPkcRIt191+P9rmn1naHp8DtZ2/eFb6zR1cTEiCQddqOEgzH0jCyOEHz +JE2rXADCd1flnPeq2xG/TNCJhOqS5ATNUDBdQTlE+cv77gA6WvHHHMvzpNrNIOXuKD9C5yDCNyxP +JBhe2SFJMyzFqL8lpW/zfzXFT+NxGnk1eJ4g4e1MerTi5RC+zA0WIkJp8H9kHOGRoBOU4UIoPz1r +fgBlsCl8TfIUj5HKkIk4WheWxT8Ijosj9PEsh/maHEjHcwwvgEzBAPByik54cymG1S8aSePljsfh +FR/oFUPx6IJ38RpPGCqOLvZkSABZAEvRPABLxQFYmtOC5TmA2QQCCziveo0ZFsCDuSnSaFVgwaNy +KkEYgmVJlqTw7aMkk1AtQ4KD12jDNnjuACzCggQWjpYE/wK4hBYuzTMsD8HFyQSnygOLJsRbTbkE +vhUlStEAZbQIl4XDhcPPpdiECJenaEo1ujjLswylhgudYojm4f/J16aKcCmIXRqhlxbgAqiEanAQ +uxyn7ggjN84LQk4NlURrBiheAZWleA2DiHMJjEsZ8UyCwMmkAnIpnE8gUBhDQCQk4GA5ESwgXM1O +ibNgE6lGS1GQCCBckcQojGUMl0VrFge2T4pnxI1Icyh9AcyLRviLJ0iKw1s4QaOL0yANiAKfh+kO +Ajg0SAauFCeuVJyn42iQNNgFcGigex65MSmaoOM4EZAheJxfAfMA45wSGgExyYq7imc4GuVfyE5R +nuUZ1ZRJcbmlKeP9gIEC5ifOmCQlsBCRaIaAkaCMRIamWE7BYeEoOXyLPPihGyUH9z7J8iI8Is4j +qgHrRvCGzAxoVXDSaAYIg5DWQAesAJbBVA/HSVHiNgW0R8HAfLBNGYx+AyYZZRi4fyACaLBKrHKc +JA3HGY8L8BLgJ758iARryxiPU2SqZAKsDi+vvTBODsBl0PQZcZgJjiQoJM9gBfA4jb+mOQKhREqP +ETcQjQELGwjtH8icwJBEdNIcjWRIArBqwvjSf0ZmyjBNB7EqYe8QcKODhYNDZKUtCQgJQWRZgjWE +KLM5kY2yeMnELcmLTJ9kxC1Jg35xsaQooG4W7WgCIAAvNNh3wvahhThsDImNA0hwyg== + + + CREOSQAGwWGmi4K7gWyiebzgkGXBXYp4pBKNwl3QAh+iRDwmdMw4QSYYvCgArbyaGUsiCfN20LN4 +oiBJJBqtDkWKPJMD7I5CM6YIRHdA6SBYFTVJkpnDOVHghyQ7E4jQ42gDifNnaMB74oiWOcDq4Y8E +4JlYKDMJ1B1EDytwIQZXehDxCcUxzMqEe1zck7CEIloPFvI3tIl4BjMTCi4bKTEKuIyC6KCVghPe +UQwEJ1zxuAgVUARDwpEA4kasgQDEzGEGwiElgpYYpbBOFGb1GGYcDhXtck4kTYqNUySaMsEBXgwH +mogjHBAkIKS4UkhwcHiwF4ZSLBOUEwABLId2kciJaZYUktiAgiXkCfA82pE03gycMH0GMyKpkoYA +lYNbnUSiLU6JQBMci3YzaMci6HyCR4MGNEGjaYiSjRblvCCTlJINCTaJfYIv8XrAzRTnMH/ieAYD +iSPmzoi1PSiRokj1WkFKRUqDpOQwgB0ins4laKD1ebG+kxD0E1HsCpsU7CsZoQk4c4xOEZsM0N4J +rIjBm9vhGAFPQXsW6OZ4nYURSre1E5gxY5gImzTix3gn6RK16uP3uRcZAt6b3scIGjNBoYGZ69Lw +GwE4gFhqdrre+diLzRE7WOrWMhRDr6oFHG17GZJRCJUFIE1zQ6RBu8CLAvQGzgEbfgTBB+rfi+a0 +O/NmRx8DYFapwOD/PCpgPnsnuk8QucDFx3wKmpm17Hnj4rzoBTyU9eYh0P94tA/Fz3Bn8lsARvcF +eiZ+QHGIsMH/KEAadSP1ArYqx5EqscoDylUL2jgSL0hLEY6aaXx7gyhvaKT3QikLmIooGwiOIBF7 +AJpknDI2lhMCg+QFPhFXaGuAESC9F6lBpAKupN8CvQ0JChbwLPWIgeVLSCYHgfkaGrqo/zNIQiIB +DtirCJrhKYrGgHiGMVY2WFFQxDHbhXJaqRrQUKZRJBo1WHJSWhxsj6gWFDAE3dqgZ6JqmuBRD1Qc +SBYzlU9Sx+OyaipCoxLSUpNwyzX/QvEttQ+nvgisO0KhLylkHIP1UJ4EijMSfxwHlHg0AKBLs0iq +CJd7aH8I6IcLS0GWKmm3PFBLcCYbQ9MElqYMgUU1sGuQNkJJ/xUMGKgmsxDRrLiAHBgAWjcW2G6I +74LlAswZcXkSW3O0OCbtDwyVR8KDR7QsQgX6OlKVWYrEG4EB1hYaExC3JNZRpP8qNU/4L5TDosgE +o0HryACVBhEaUCDA7kCqjSDvxUFpfwhgKSTekWMA/CvSLcfi+ygIHkl3GkhIDpMJwAgjKEycUvXC +ehJLq1QvmgF0FkcKC9i9yChjSVZpCgHzRry3RfNDgMtjlQ7tLF4UmBR0RSErnOf4BPahkLgDmclI +/xWIhMB7FKoc4F9ROSaBVoC+i7MJ7EuIA+1LrceKI9P+EPkKgYx/SNSU7K1g47gtwVAE1riA/aZ2 +CCQELqX+X9EFgpRuhkL7nhK33G235c2PB2MoAseLibT5YC0zEvs7OCZubH1R4q0CkvGp4jQcLVmf +lGzb8EATU+OVw0sqW0uiMsqLmi4llEgTKAxbD0gv5bU8l6UorIED047lVc5EU+cQy1o4hxKCEhYn +AEFQanjAZAW8Df5QWvEYHgXnTevG5ypOSh4chfYBL2m2op0KWEYcZ9GCHaF2bvJY5RSIVum1IuMJ +mXJJDLOWk5zWom9a9lYr3die8wl2eKM3osu72pvNlV58qyh36YBWFVOpDy63THDSOd3RCGz97gYz +IQn8qv7XsDUeQDD/hydQGQ+BVhmodAcT8D+55qzfRQMHumL7MwjVzz/AqKDmGbiq12GTxQBgzRvx +XvU+PufKB4XxnyPl39Xuu+r99UT5Vw5ox382px3ls9J4Kjy6mLbA3xfT5ugDdl2fA9VV8XduMZ+P +R4CY9M8o5bNGs6VuBB+oWuCOsB8bTL/z0UUfwPWSHqg+wI9o8EhwuYPB9dr9Lhwf8vmLg4UyPijg +HayUEuvmqydQW2HcXgwBCRWa86bH9xoT//Ym0V+Kcy74991Z9Xzc6Rq+PPAG/jMcjMDrSHM+n/Za +izlOcgFNMdX9L0CsAb6iVfuzN+hMAe5RGzG2RnwL/5n/Nenit4G90ez1j+Z0dqBI7lc2/aMJ1x63 +hc9nJu1gujhuJoxkpvrrH4qd0XjUdYCYwRhQeMcJZsSW4b93Xq3eqAMGSjqYGyCOend+jiZhPz9l +6zUt/4qYIC0x4Wj+vWZr0HVC+Lar+k/a6Mk/HG912PRvpmg4vfZiNh8P/15O9uvoMDlrwjgIKPPA +FnNKjr98X9ThzTU/Zii/wy6dvf/5g6Xx37wNZoNe+5/OiyNxUg4NM11eR0v7d/NdOBXObip/OZnK +X3/3VEiOjtN2U/mz10Fh7bbTERr+A6b02UWWqoM5iS3/5kmJ0Z9mE2qNgaU7hOb1xbQHrEUnU9N/ +8wNEPuJ19fFi2u7mYBD0WtjeP9ogIwzeKjE2b04/unOgB0CXwey44GTp9d/8zaps7bxMMaXxdNg0 +25XKKb/3Bl3LxqrJKlv/481zwo4TvKNAaGeWudz2711+20n1RmCcg2bb2bSUrX8430aX7UyaAFzb +kcagbv83b9qdEvo/Bxt2CK8SQkctTiapbP3DCXM0PnM1NXX7HyBv7Rnv/8ykVQulv3s048m8N+z9 +F2UW/JQxASv57x7CsDtvdprz5qrjSKw4jp2OcP7hZNcpGqOPH8+6nd5i6L3qzsaDhZBTIoHJHpOk +VzpeAWu/mHhLA7ht4RldbdqFqb6yu5djWZoVZpM9Tnib03lr3Jx2vG10tEx6W9KoJXaCuhAH5e2B +UTTnXdCwi1zUlo37o3G7P17MvR/4zBotqpxTBkdw1p19eq+aMyAFBQJWzBR/wVIMFTcfNOX9QCdZ +ztpKGgRNqMZxsZhPwECtR0IpICulGxhBr+OdCdfHORiFjGbbFVFMzratNDlStR6IDKZ/dL2N7n/m +3mKnN2+2eoPeXJDKJCPB1BNTtTn6WDQ/ut7aeCIuoVas8SJeOpNeFDcRQYKRTTUkMkSXEqgeNQe9 +mebRbDIWdgAt+S8mzU5H2ifZY292MR9LK6Yn24R30pyAXTDrDReDpryK0rrnBt1uB9qUN/JmJU3x +q7Zw8tPxJDvtNnHKsk4GBuTYPhId9ROEcOYPftCU/hcRDaLP0P/JG1yYrNQb7EDlOxAGK65avjn6 +ozmrS+hQEgLhfZc4A9iUg96o652hROGZdeOJSD/jP7rTCTzwnalXGSJL4Dpw0JeLJqQubxVfwqRl +EEbjmAPKxC15mcJVLadonSN/dOGthN5Wc9ActW0m2R70JmDtoFf+P2BvfAAKEAYeIJkoWA4FI+1n +j0uLwUDE4013OoPCdD7VdVEv3XrzEHJj7M0KFGK8L7R/E2oglcZZ1Xs963qPh3CDZWcoqACyylFH +S4xSe7mJEA5Uh9c/iiTB87AKlv1XWsll3BSPC18UIe06o4ayzmGEBkY/HvEDb30CTJ/pDKB73ms3 +B1qyMv1AjjXR0Zf+G4DjfL2u3r+GsFFSqNL8Jq3AHo/ag0UH6MdDSDFaBmb0RXkMr/uHOfOAHbUG +XQdDwtMtDifzv/LdwWBmShjSJ43CLfRtVhTOQKse0CKfNScNSaGhHLSujtsKjqpdce1uGU/+0tG2 +BlECMr13ZzVjmJr2KPkYY9J7hpO3df0q21yPev8x7FjZ6LY36oz/nGmoXdGip5Sb2hEmVHirN/+A +Wwsm4MsQxiNIKV4Vf3b0jRcuj5cQFohw9RVptKx2H1HC+JxOCn9FC4qKq48YYXyMq6/Ypb7ilvqK +F75yh8K4ho4sKMKYoDRohN5mO3oinH2CB2i8xNbfPBGESE9xl99Rxri3/Y5e8jsTurL9jtWumyni +DbmOLNHri9b7eNDpTkXPIHw6C2rFrqaxwlxTc4fCYgJGAo0veSy57iegKoV/BjdFDQR6UwvnA0O+ +rnmntAEU7zWcs/ifyXg6h2qQUroqVOscOrRRKNc6BUnlNKp3B5XmHPQNhcsATm+m0HdN2h5D/+lx +QdlS+boB4w5gr0bjQyGgiuGp3zbGE8U76Ty4PBgD5fOqO1kMZpIAPIBvpcs6NBPV3uUhKzj1mzLS +OfSyF7wpjtpjAwsbvIFm3MVI1suU79C1MQh3UHMQLCgZKDAF2z153KT8pgS0qYbeGQxBAjPrtDsd +GQ0E6NaS+qkc+7AF0Is0dsOOALHPMGnptlDCOxrLhoa3N0Ia/HjWE7ux94hQXmAcWnhBlPYCaovU ++bxgKFwpDQWlNYKa4knFbrAZklOZIUrPBm4txlJ7m0BLxq4OjUtB5YbAH8FUN2hZoI+Qya79yIlT +qFirO8UBbmyOBH3bC8FsqyvNRyWucDMLZKnnjZvbT1yNYvyVPY5tdqMUDu+97bZiN71Odxw7GwNN +rwuRChRHsA+7Im5jsuM71h4PYHkAAFnPspXtZvNBtIO7QEQtCQRr8PAzob3sIXTyzaQzBK8HI8eD +mnQcA8cxfNIXpHRdkrLhZDKNImEXHcAgekct52PBu8TyvHXLqWzYxAnSui2OG9Cwd9UawrZ/joUK +b9bNPjXNdDj9GrcATme9j1FT7zTUNkRL2xLiBqwgooZjeDLsoF1z1urNh82JdVPcZqrZJ0at24Np +tD0ewau9oEvOYqiwpcS3W+jqITx/3rD1tBMFNjy8Q8dmAKDhO2BN4rVhSBQbtkJCQu/l0/X6Bzxw +nUQ/Hbb7w3xsk49hP9odQR3D2Q5CH+AtJK+nk2/Aos3hhW3CWKIUa0j3sCnY1JA3KwKcTIc+AVuk +N3of2zSbKi6usmmKPKWt5nRmgVzUsAVVLLCfFBzCQWOJSThoO1X5P+xaKxkFZ9p82Jz2Z+pRO2gs +jdpBW8WoHbRWjtqIyavnuJh1gUqMlFuLffw+mkc7g8n0fTyy2u6TWRQqZoCHzKzJYhYFPBM6ZUeg +qUL461r+ZxKdalkSEvhGLT+cMC/QTuBdsn/ZCE1yO+wPN4c47Uxn6h1vKIBQM9ERPZuZ99weRkXv +env4V9+CDcoNx/geZrUHV9c75jKWPUMtQWBB19F61ItzTIE+3/E+Beq3F7WnoPcPykYHguNSCCcj +aQfaQC2mN7IQnVC+2g0ZthFUFkESJIzZIBTpMvuLM5RZK2XEZABogYBvdrytv7yFae8PdNe1FV8G +38sqloVyoWLEZqqFgbdW1wgdOTqSGVDGq8ZmKK3l9TcXgtMPe0EJ2ghCUlFgStsKVZUSYdm2sxC6 +uNFkIAYVGRI3atMezaxQCtrMewOlhW3MP2fitZkWbRCPtZONU1EOGA0Zs13Vkhi2mQHTWTwZNWa3 +A9Wxm1GLVg/aQpZNRt2PpnyyaSoAgGI6sm4zINvIda4z+7RC4rPZ6U4VR5GGrdRyhDdSBQEz154O +GjL8Qc9CSQYNxpO2hWKEGswspo4adBaWBrvFDgafW29gLGIWo7YjhoBaN0ejsRxXKg== + + + hAZAJ0tWbOiVXWWuowJIZXvkJNCcFuvcLoZeBMKsVUMS4Tb2vLFQRBYSGDJOhDalDNmQGgysW836 +vQkwc0YWQhs2m4LdOJ114fCmzroVww6cs3rxC8XczIYDfRaSx05NBSfj1jEwBpQ0oHF+aVeUMHUM +yYslXGRdK5QEJxS0ZWDA2ng007rtwAi8F/iVwlWldDs3/+ieAfHfmwy6WTWabJ08itoIXsUtxmvw +78DZg/m9wpT5vKwTC2EQlt85ickw+o6C/dWw4oWOTmGHtfGgJ0pFQ+NBHCguAVGajocAiX+Op/2G +KJkYi+mdjUfj9if4qKuY5Glv5Mz0FQeNA62g2340FybgDLtiFFMWyNFWc15t/tUVzUx4ZZT1ssDL +HXB+JjptybbGfzjoEsVKmK2odafoU/Ne3S3PlawcGhtExlPVuY3drBAsCIDcKccdsFK9957IvjgX +CJOpwwH9m4frMJaThnRpjmn3oleEK0c0YcZlS6aUAgXQmtTuSYX3Wv2lozBIdyRTlR2vFoM12YzK +QRvqWM5js4xNfT1LMadad/PO2XhErHqWqdVETXUcKGq9SzW8QfexAyaoEGYwnhPQaL45wVGdPRvR +wUA4oh/IXFmQe0QnEGdNICXkdApnnKTQnYGhNZ1LUJF1ZKfWxGvA7JYURBKbc4AJwFiOZW+piQ9W +bN2Y9oYQabcKy95W1hhNx2pIV90P2MfMnjNrdBNbxow+wgGyPYWKaz5f+UTdftglsHluu62bXvdP +ex6lICIlX7IfTMPK3JbwAhkYUIgbn4tha9TsiRF2gcYn2Gne5rTrnX92vYLbyTsTA+H+/OyOvDMc +YdEcKQtveSEX9TZn8LGs+4ox8VEUHzJHwNXA/hovvBPAOb2An3TxnkZdY3AfsKpOT9VR2As6kz4d +gRnDi1YnMJnM20Mn503voPkXjL9vTnDoCORVs0X7Ew7veFRAR1UyGNzbCCB1AUY3fpe77828i1Ef +VgKJOt757WlvYruxUGOAEcRlGgpvjNWaSWaIA0rDMqqhS0Wz5c856RCDYu02Fhh4Vx+DZTRVMJDJ +RMF2bUhYIcUt5SiOp4CRFVdwkc3dQ0pGqwlntIIvMjMHRkl93hx1pJBoh7xYKI3y17mly8M2dtwe +oUr1wHpdERGoFxaYy+ANVgbzkm3oyPw0mg7gq4PZHFjkCynZ5//7v/+f+f/7f1njTPgM7K/36bfa +jj8e9b3wijaFCc/zCTkmUGNiyzOL5XriyLP1/PFxnC10Yf/wJXN0sfcYOrxN+Q+ad+ETeu8ikstM +y8PP5Mdo66S0FQ74871mdLbLXVeK3E4yc11OnzFHyeqT/ywzXbT5UpE6i/tIhtkhiFnhq/ARJnYz +By/R/cxheDLLzE6pmMeXOahuTcVGJ/PcR+WymjlkuvV8L5VuF6JR/4euq2rnHvTHF0q+JP9Qnhe+ +nnPMQyScHY6rs+xxff4ZSnM7i1KB2b3NfQ38tx5f4Z04aRkC2+UT7/zN5eNTtpGP3ph3qmyXfM4c +9kvPmeQsOgwVwr5FKVDuvHt8CFmlN6BhFN6fb/ncIDO4S77nPuf5T/6BVKHjba/QJqvfmcMj/y2G +A4Y8y798vIzBr73vwnHneCsXiX/tZuuRnREew12zs/D4El+BULvYZi8D+U/m9eAw66P3Qrnz8Fso +k/dfl/LdxX765mTn86Ddbvbhr16o+F79xD2TRKzJT3u7b8ney0knN/Ad+SPT0NMiW63vfcPxBzMH +J5+0x8cd3DxnsqO2fxhKnR3E+OFTqsfzsdk7nZ22j8lQP0lKENuFk9kNQBvv7/K3NNFJ9vKxJlhf +8iwViIS7uQFfG+IZ3Fd9mfzx4c5tMZxgZ2Bdjh+5nTSfH7+EDm86j0mqtfOMwKZHPjChNLe/A5fk +kbvlLkcQT+lcP8hFBNK86VQJ8nnnrBBrHu6VtkIPU9gLB1+8ICioicdHtLaPGfQ7lC4dCr8Ob4un +uHk+XHzDwKh76hiQ7h0RSqeLYapw9JES4NymDg86X+cvaCWlAQN4FzlW6AU0yp1IA3iWB0AGUlew +UZdBz9itXOEVoRoIyyOGe+C+2tlG4StUeI+dfhebTf9ujmtdXx5WCq/pbOOzPc/Wdttn2QZFg9XP +8s/3O+CbzkPx7u1oIaEIU62KTF/6MrD4IDqtiAt2Py6814sdhE8AthkMpXcObvEKQcgeX/GVDN3k +mLuTUmY6/bxmkme3R2iF4mxvyoHF2w+HcuPEixaV6okr8S7iCS8sBOXxHYRSi0CpMCBzxAmbBP+U +iR6Gk+Za48xBY76dbZzMF3pUalZSgXdx4e+mW/BZA/Cx72gvq8XT4irRLQX2JsH8J3f1UGwRh/uF +7nQaJrq11IE0EIwOCRnVcvb1hETUdhh5K8GdehotHH/xTbz38YLG69/D0+zFS+6slH8/iRPkaatT +yneG94h5GqxBOTfgUrcybG5eTT3kKo2dlGYMHh8YRfeiUO77uqCry0PIYWjiPXk71o9W264NfoXn +5cl2K5EIHTDnGowcHM/G7/nerMdBbhl5rFHBneOKPKuDbnJvCHbyVRCS11kodfJwInb68QT4GA3e ++qr75flrZ5itv50UYr1UoIQBvPsrXLZxNv7I3DSOm6Vi/PLO4zsMEcUnCR2TYnh8TpX2uOQdWPNF +otjuf++JHaANMmhixrz36K8C9pjyZ68Gk31lu8tmBbA/P8Nffe5Hs6f39ZHHp2Dh4vvXTIPfu8hX +vxukSmTs7xXes/4XlQy4KpVeg1ufaBqA5466YEuxLc1bYfXh+75K0ii+3gdCtDwuhhvtFMDi5S3Y +2He7oXSKo9HbbD2cGeV7vcsOnNoWbNIonJ5WIqXDIhtEb+FcPvZHuHnjLOPLDU6IKFyrR3l/8vGj +3j6TuWnF+Frl7IpsvVxn6b2t3SIV3H3Jk+V8NQN/pQGJkymi20oekeFA/kh6lvb41N/glugZ/DMH +mWIefYj+5OpV6hK+TaGvpQ7y8FkOg8oeRko8GylcUa8PkyJscgh4MmwOHxSkrnKw0bkMB/cC+1OD +yEiDT0tfHKAmcDQ1NCQ0BjAXACeLhwKniScMBwWx04DPDhAwuRcEQosiOGSjTtGfAsYgxLoameib +A/gWTeNIRiVuDAeHsTj6OLiUUFBH+JR6OVTMRV68tOXSOl4IzTJ4fJqFwN9AZMmw0TQQntToSKFZ +yX8iUFLPZXkMHp96LdNGJGe5JHjI6Jc0K9yp/CemMUPCcEAWsHFVmpVMKlqaxXMxRVYKzxTtHBEd +KXnOsPGFEVI1O9Xjk1CY0kxTwklSDeJIPZq8/C16q+lUWBd53ykoRrWqaZlqUWOIiazBVjmQRliT +mAcmUjyXEsIjAusU1YoxWNILQjlYfYhHCXbaiAGiqUlb0x0ZogXBGDuUOkBjvOLiZPAC/cLol2bK +czfRd8DAv2hB7iWyo+zV+8cpUCtPJxqBkW3cnI5KGZLse3xlX/kV4IQNcArdZHHpOyy9zhv7mQOi +thUq3txVRFEW2VWoEwqtQGslKdsBSoaGAVZfgAgOKUwzMgEMltMc5weqX/DR1JriDx6qpSzd3z1B +doB6QiFkIHh88fEJwRcj4XemcHr0zSh7yb12s1ej+nW2Pj8eFkPVWED9dlDKJHwT0ai4CsrGF+7g ++LHxnb3I52pQhxG0q6EKMcAChVqYeqYKZYM/aF9fZfmnk6vCyXT/zQhAlq08H2dPby+BniyM7NrX +L88uulNB9atyOSC2n6KS7RC1th2sLQeoXYi2AwTG89fP3dPC++WsHuvVHoHaXPzOY32bprYfrY0h +U1PI41MaQzKFwqlhC/sue1EqfN2+5ntfXOzgfej7APrtPglwkn7j+avOGA4uIutHghpbHzzLoAAl +C8B+J8uC25f8AenCRyR4hDu4pNNvQFG78Oc/Q/f5WC+dSgprpcaTyhbpA7KPlmRDGPAx5RrUKgj9 +oFN6BzoPqpjmBeJUDMTMqNhLYzqXN0CtMgCWhaz/q7V/xUAT/e5pHkyoEyq9vaYThfI9/w7M8SJF +UGXmTAv2civ4pDFSMI0VxW7fLgvv16Ey4NOlAhXsFPEORJYqlAEJzLheDvf6ZvuKL7087++UiqPF +G+VLDOPC6h+Gd2OPcb5dPcld1jJgLvfDc8HAX9z7spfn9ZtSIdgRX8jEPt4j+P6iVSOqp62JbCNr +fQ7UQx+sS/7zaSsZSpdfX0XKeo6CFYye5vpnIaDa197lPZuEnpaXXJ9KbckvJEcAkewMBwQUIucQ +2w+ytwNYfAZ9r7tnrCmdK7fuJHoZOrppfosdNPjMwen9NjAfP7fUsC+y9XLnC6xLakplrrcSaA3Q +CqQCC6oLSe4dvQB87OhztkCLnLgETBX08tIEIBqz4uuEbGUOrv1RhZOMYgfbB++L2le2cd28Bx0k +B0TpKUOD0VQiEnfWOjA8vsSgNH43oxhSatkQd68SmMPdSys9itb7l6C47F6hxXTrtrtXMRC4ez8A +JZeCtcFBqcA+UKH0/fO+HqIDK18BtqrYvbnq6yfCJ1iXNHeyKESvOpFM8vyrL4moBrddGuUF1yAg +vsjke9wrxO4OMiI+/d3YZ/flDeJzJgyuXEgJHPQ2xUIxT+WGF2kgxVSKxzmTu1jQDwDVV7NiaJ97 +V0gsme4gKXG7O9/xTPL2u3fwXml9ZJJ3JSUozLGx7Z5oeXxIYh+G77kKgq2Q3UJLIgDs9HkbrN/D +QaE7uagidYLbqTI78BlVOG2cbcvd8zeDagMIuqPd4isxei68NwrvHl8xPD5bZNlM9rHYrg2CGnVJ +8Ex++PqAoSa2+Vns/CbbqGbgNkxE9IM/DGSmkcQiW7uKPSd7L/F3sOK3+2BdFOoNFkepGKCY6j5Q +UJ6uS68HnzFtp1T6ewgW+WMr833U7sov4FotsvHW5CNKVm7CwjOwxEAfa+x+R0qBcSKoeUW2qseU +DEKSr3DI55HcYEi8A3rpP3Dp5MV95mCSIPVTE9rBdQEt+fjleN+0EWqS7HRa3/omD5ECkXjwl/Jd +rp9tFJpkbhDfiRNU+LuXSV5cDtCCKTiMjorQ+USqffcINk3hLHvVyHzraWNnlu+lzmaZZMnX5I64 +u3L+PH9zJGmHnCBf+MNe+7Fw3L6q5Zhbaq5b+JedLSA8iMtS4OSomqg8leaCEiwsYhQQ2il3cLqb +fS987DwzfHISzQN1qLcvg0JaHwT23h1Dons8DO76XiF1HxZbsYeJWvPGI4s39nbrpdedvTqYX+ip ++PI1byMfpB6f5XmxldsPeHzJsxD9mG009rZUxHJ0LIGtCl4qgSyqmAmLfz6ZEEhlp5TPPgMVMXN8 +B/hYIdxgJZ8hHm2iny02snzi6iPBvOWGYJI5wrQJFARNaCoFI6NwQ1LPgBXWuDnqZw7Tk1sgKwcj +Ys8ARDfX989Pcsz99nUl9cT4Hc1UUPNUUALRJ9hL//gcmB/FsXLfcZkxlIYn0NcJpg== + + + y9I7wER4SMggkmR867wUvK/Ns6f3ZEfRaer0vFPoDBNh5ZkFGFkAcPmL/ofMfzETHr99soqdKp1e +YIYbOh9/Fd4TJ4NCa7/nS1Tfpoel7GC0jdyhGnoBqw+P8pLn+dhT4fT0MIZVNeqyHikVyfdAKZm9 +2hYX9DYAOH8jxqVK2XSO803YwnFz4NPxn0EtCHDzfAV5abRwerydB9xSvYEOw4vafSlDzF/Bmo9a +pa39MAlM2Gv4TYICO4d+A9vwKK4AS+8Hgti45Bv8i3h2lfGpT98EJByUAsfDbOLz6XynVKid1Uu+ +CQOYy233I0PnHhh5LwpqEPglK1joDC/L13fyWfDfSuYwEg0a9gIb7ZWhs/gJNCrS+j22088ygdx1 +MTBrPUNGQmqRRczCD2gFwMaN3Jv2Uq/mqOB7wxAE6T/pQJP5NDv+vNhXWk5WOxWRvWjxWRK+5Hx/ +RKcAcK2oQrNefir7ys9xQC/9haLxvFp6Bquf2UWqCDqjhHoylzkrRC8+DxVUm+bC49J+MMwBNYjx +AVMiM0CHjQfdRPtGOILjTq6VM1W6II6o0kF4WzbgdTSmFNuTznspcFpOKBcZ0erl0w58McjWW5N3 +bC1S3PZHbrgd/1JoSpnK5FvclbJ8Qb3c0odN/uDyopatL64pvUBhp4XjYW8GxFZuCEY44EpvZ76E +uQZwkTy8Ahg761R3jJdb1CniiXGsXWyNKxGbdo292+di8+14OzcM7SkEtEhjCu3j6PwOrHRPcW6v +AabYd7qZQoHy/goWsbL/DVTu43NRIiP2+TX135X2FpNujlnkgKUDLG2FTY6aDANxwEGjxUHu66uW +KRx3LueFk0CgBI9Bj/G5UXbQHCLVqDjfO94Sez5ZAG1cr7xWjTRYQY2d7nQg3YWzl/uvQEK2h6SS +HZ8s5sTxY/lQsx+EuQAFpd1Inr+0FqW3F2oIaYyWDtMflKSU6uYU7B/uc4wHH9F/BMLhLlB435vs +cPPTear0OojGVL30XsIfYDVm+3zyJVSH50Eh7brQwRENFAKmmWX8/nGCvD2NZePl2RyGDQCF7rh5 +l5kF77YLpyfP34Xu4cu2vGBI539jgIh+nwD28RTjkq2LPadfw28TwLiqVEqv8+dIKePvNtSHcRza +KJjDiIZBDYjmTOQzDvoLl8sP8cZTsdXI3hY+2L2ehntJjEvkWZKUxnxKWJIiWguPDx1B5j8fD79L +2VpmkjybLcZq1yDHfZOJq0I73+wX9nuxNn9IF7vFh/fjouSeRE3qYMfXS1A2NbPxSHQb+kLKiG0h +jNUe+MZbJVYqLLLoWPISaBz+SKE0yp4B+dkI5voHhxFBQdFA/AAMrr5odOTADcwNBaCX2zk2WIoB +PtZJFj4U3FJ439gRsCzg7jp7Na6+cenvYF9pMkMc5/yH1WL4OQfsfY4ays5ZhCwge596AGPp7/2T +QuuuewV2W7pSvn+dvCEeKW0fE8xLiyP4CVOAgUdKO9z0snIEVJ8jwKJPv3NoSKJ3lLoMzCE9HXLX +tU4M7NTrcMlHBoDdfHkVLpxsvRPKGeDGE5K7+X7PIpFQ8lX5pAa21BjQWGnv4WNUeB8/h5DryNB/ +LbD6XBx6hxvlRXTykj19CMbl1YchAP5ie7H9Er+o0I0EHT45KL2Gb5KauUhwGsWxRmyr4bzlPz5L +fnjqHVcNWQIw4crZ8fcsBqM7LgrPvfsd5Wm1zACSJ82bM3n+KjP6Eui/ZyV/2VeqDCWzCBhIt7vR +wkloh1X2PJjvFtutcAdGEdxSR8LT4fYeXPhXqK8dqjzdz3zm4CWyyDby/CuwOjvAwo5FmtlxtluS +B4eh0IHsQebg+TrHj44bZOH545kC9n59kImJwAC/qHXA/usdggmrVNFiaa9cncjhSNGtvcQNx530 +PrhG5P6BKm5FcrHPUae5m/i4nYKxVuA1XTky39t69IP9EtpvfxeI3cgIiXd2K79PAptguA3U/etW +GXpOfST9f6alaDl1KFwBXROuznlLaLMeJ81RV5MUKNxnpb4OU3lF1p32KhbwrNAoaDIi4c1cH+9i +MJ8uevBAqqKrrqwKg/5wxVWYbye+86AYRuUTw7i+UJp944F53IoRsdBZCHDqOQ1/UczhZZKWXlxK +v9CLA/qoMc8By6Lcr+xcpZqAXu7T0lsqlLriPreCdCW1FYn5gQ4DuE//cCt4/pDYCn/2wKu39+hW +aJGsb4XP7gpbEeKMImKp+wDqHqxa8JKZUbMzMLhCH6zkW5rOxek4YLLDBxRrgw6U5LdE5bULLIvp +NJ1qZcOT85PMaWKWjlcOb6Ol8QNzU5w+PRCFh9J9o5TKptrkfpYfCb3Qu5ehfGT/CvRX5cymiycU +pauJXaj1aRtVZ9PpwawBOgkfEzGmjqchj2wWL81vqJdxf4/o7JGo5wsZ7PSZmB0C2PFFKF3e2kMT +R+tS6Edjs3iZiX8ffIE/ywPw9X1B3enT9Pns6dK40zL/wiaPX6KGnb7sngO5r+lW7pTrnZZ9xp0e +bgWmM9I3Ne60Rj4x21RyX+7U45O7nfnDZxGTTtnPQNN/XzTulAk+hQ6pD+OZbpdeGI9v53oyqBrN +lSjlTjMmnXI7u6NpMGXS6f0LUXo/r8udojhYqdvy1uEeefLaMOy0XKEapuilHtKNN9QpoMVWUb2m +t4CSnxbpKuw2qF/VwD39OCCDoFNmrCOlKpETOq35/ZpOWXb4OpE7lSkZd/s6ff4cNUw6zTQ5vrRL +Gnb6cvR2ZdZpBWh9dODgyXiuh1vPs53P7pVxp5f5YPp7d1g16jR0MEim5U7BuqhJaf/oIXNh3Clz +f0+UEsS5YafbpQ9+92pIXRh16vERpefnkslcuR1ff3SWN+u0SZTDbzfGnZaJrL8b4O9Rpx6fFsHz +nfCR0Ol9JKBB8NE5kxLQW3zql1SdPhwSVT5Cwk73NZ16fLPtSnfMXTUjFOiWn2jpt/r40DTplNvh ++53Si1mnBeJs/zmBOkU2snqux9/JzNf0/Mqw0/qBnzbt9LRbpwmjTiHnZx4jRP01uG0019n2aaV7 +/vgQDBh2euMffZh2Wv+8fGuhTj0+/Vwfy8TN6eTQuNMq7bsuZQ5Txp1OTraNOgU8GXZ781renpsg ++PGCuD06LRh3epYuvr5cPj8bdvp80T9GnUL5op/r1z3bKZl0+hQnnmeDiHGn51+T4UUiTms6Bb2g +bl+PIyNTBE999dCWSaf310SxNzwx7DR+HtneyjxHAB8D3Sa/tZtm8cq/Cp226KBm0wQfqs191Cnl +Twcq6plWibf9ZBZ2GpY7Bb3AbgHYr2+R6aem2k5n472U0On8KKSZ6dZT8zGIO83dk8dqRhiezq7T +W6AX0G1Uz5WOI2iuoNP8XMcKK9sc7vSIPI1oGGF4wpxjSUPvJvOnqFPYi9Dt7nTabI1gp4Sm0+k0 +2x2L9Huypel0xn4lBUlzlLyMatC7Pe6+NTyC/tBtvnLqQVWu917GSdO395fk8Mbs7SdRefMt5Lc6 +zg9Yb2HP5GuwBnuhvDiury6vecvFydeG8HbWj+t2JTf63L4zeo+ZYu04+WT6Nk7tX72Zv/1svvgl +jOnfZ6m9h7bp22podESZv21dvB/IbzUY43YuttutisnX8cpe5fB6ht+++78Tmm+vQz1ROX0nt5M6 +jF23Tuojo/eYyxVC/anp21tfK7Zl/vapkEyJGDN4/+Z74XdN337Na5OK6dv+DZW7lN/qMDbsl9Iv +Zl+DIV0esKZvTygmfWeOMV971KpXzb7e29o7fto3fVvMnrW6pm9PqKNt0hxj2S1qN5g0ectWiGJq +X5xzMnCgeRtqXM6OhLf56KF2V1Yab+X9rPyemTHhK7UFlic6/se8wH/efAP4diKYo6VXFrOe3Hh2 +jn+p+Bg134UWZn4rcpK4BxbmVwP+E4XPSlvhwlUe/nOL7DfJesM8QuiveZUTOd90m/KnahGBnwM7 +R6WPpXdoP/jwZIj2BrR0FDsidhYf+YEde7cArHV7D/T3fij1txPrpVpBwJ22i9PFWzSiYrfTbY9P +7hZZOiadcjvQznk07pS5fzDtFAiRL1Kjjynniiwd006hyGubddpRdsrUgY2s6DZ+nqsrOu3s7e3I +nSLtX+qU1qAXav/STMsDVafBe2S9KrtVIThFmXaKtH+TToE9CLT/F7lTMBfVXJ9NOwUInjHmnULt +37RTjw/q/5/Gcz3cilp1WvWbdop0CrlTuPdV3UKdoqFa1W5C7B79EhYimH/oDJ20e1kMR8q9b9KS +2/l+Kd5d2LZjPwW6E7hFDsz5KStwS93WfQsMIXauFA6adGkxFZjLXj2j2fGx3k4yLP+TngQ6DcFY +hzwJ2/vpSfBwIkEMIBDpRGX3C40inSg/FgDjahZhz7TMmoTu00Wf8E/4bCx0gFRgsQNJtwTjAZNL +TXAjjfcJsL1c7LNb8En/XCk1ZsFndiE1LsBeysrpvp0cCT4lMOTrGniwBxXaxb6IHay3C+xYMYPa +nhqBkscNDJg4YX0+9A8kyFu1lWQ0qH7iWDMo5ZBeF35Aumdhyn9EKPxoGncgQjngls+L3Kkd0uE/ +wuCxMW8wP/+W6fw8PnmG6B/TFRTXr75tv3470vz2BRozmiFUXq8tkOV8/caIPrFl4RBZFsDI/dxX +yRSUxwm5i8g6iLiiLJmuVBIZU1b56ds95g3xDpSbB4GSV8Y8lXtInFjj3WOOLDXrCepZz0tRzXpo +U9bjsSPd4tPxVIlAacgqBO5h1mOMuxeYLyYi2GQ84WIY/yPgjhwZ4+4+smXKts12JfLHGU7tftv9 +1JRSDE2OPrppnNmhuny6J5wmGA6kENLMSinFFLPq1qJ7wurr2GgR9HIzdjUhIw4DaAeYc3cK3Erb +UEnnb8E9MLi7gskyhSdkc9dfQWPAfv4lEUOYS+nPcSglUo6CkpFTxxgY6RSYESiEd8Upz75+3zVL +Tved9a4DsrK5fbewXMsdMnxNhuE/jyHFIYWOLABnDBRPjZYTYEy5oPAfsKCyI1pPG2B+EhfU08bF +pTQkxbjQXOZlw5Gly62Z2SQzRHd+HdNpYfolkS2+s5B+STplOy3MKevpx2cen6lgcqAzyo2BNvM4 +NxVLHp+b9S1DnFTca09Ge79TVvNpA2SdjWXBazGk+dGJqay8uBLG40SlA0MyV+jEpfP4nK0gsPIt +FQs7nV+1giOfpWLhYv3KtaEMClPyCsDqIwfjArvSETC1QHE7LvGEVwB2b23EuJmkUqtbGWOv0zVi +TM3RXI5rovbDvPFTneE6T8+W1I5V5y9gPBUjY9BMoTUU0FTu7nPLho8pFGzjXTk/2l7brszdfe+6 +M5TxeaxuJSvwyKQq4wZa4u6xc7+959T4kHRLLXbSM0ks27oRjBXDioYpGO4X+2VKz6xNPM1ABErW +D8WGCzgaiEa3XA4nNtteMRBsI4dMRNRHBbquH13Y5PhQUh1kJMX2UM+zVlTh0Aa/jg== + + + Ic0XXXRg4tQAmuCWhQ5jyD5MNsixtdrh8bkZ1M6SDEDNLeGWe577rMWyUwZwLDMAp/a++fz8DlDu +cYZ0la5g78/QavKyr+/rGB7q3a6DqApzsvg8K8ucQRULZ2j4mNjkgPY/aaf0KZxYWSHL+RY3NXuQ +lQSQ5XKLq5AlbXH0Bb2b6MfUG/wEzkW9xQ2tbnvvEqDabWceEitfwonWJasdjZVLVuMhGZ6oNXgT +o9jeJQumpthIwuq7dpOcwLiEM6fuDclK0g7lZKEWy0u4NwAdfFNoQihSRbdaztdKI1NN/D4en5WX +bngCD3fvV/L7QLTY+/o0rMDEXwOxwzmiZAXfVHkaJipVOrPQqtKADsydiQJPdqBMQyyfalVpN7jD ++hgaj896PE79C/TRNe/XUITCFnMlCE81mvBy+yV5GbSemj2dn8rCT5IvS3ijJ6dauWc2IY/PgtIB +7aiF3jIM4Ojax3ps1twZYl5tnPQejagz02UBdjSCzk4OKXVZPBeFqIOHVX5l/AacFXjmhBhMd52C +kvNgPFF3Pm/9nO/qRtJOfSrq+AgSADPztxp5W7FlYeZvhcBcbD5jewlsGo9v5UMKtGrWIs/jGI7a +kHQ3GuFMHMNZdQdiKJI1KUMRebIbOO7lnmTvGwBTnRC6E6Lq80E/0i7CAbXGmUdhqms5Ycij4FOP +z34bOhA3EBgVdX3GZ6JEwFjOfUeoVKifyW+VFNNytFk/qONos772AM8BRzP0kOQBYjLfq3K0a5mj +idarGw1eC8yeo3kcniBBYMtzNGlXlm/Ga+BoYNWMOJrrvQ/guOdoOt8FhrM6R4NQVj97RXAsToPC +uYB0ihPz+Iy0AZUQuhlbWdDKo0NjHYUJX6njLYHNo/ONw2erHsCK8uXd/23OhhxqZnmwzy/mRpsZ +e+DdsVkA7GbLFZP1+EzZ7JLRD+rNfINsaZUlvoyCAlZNE9RkxmHs4ThT7U2hID8MgLN6CASCYmJQ +a07e7eGoD90dupcNThMQsHX4qrEsBPMLQe1CLQ3B08gq+r2CSJvbV7OVLb67W6feLIXvwlQa3rrS +7619sBDY6vr907eRLHQrxeCquXdp6aUYhLOKfq+AIsnC5aUYgmOg3xtBkaxXEzhOpaG1LEQc5ul7 +ZWmokoWv2nNi1At4upZwJMh/DOOwBFmpCp6SwzBMdYHXqcWSKFEZdnD6dne3iq9a4+cHwFbd3Ypx +Gext61hrC4w5UnfFlYS9mFlEYC2jjva5xelpHuDzJmbhuXIQTqcZkilFoNge2+2lFUz5aEQnlvLR +mCO70oFgonJ3HdPwPPPINRN7H4yMcoZKB5urNVtftC0AZnp2I3l7nAbUA2D07sFpdR0eEoAx3p2K +YRKDCFfyNerIB4uBmWz2e8vgW0wRHtF/72hQDilCt7kEiYy3rizP0uzZyNCyENYAZcvNPrYio8vX +rfDNS3ErkqVfYN5c0SiDDt/csnoOnVKK6TPoNBlDS+fQWWfQIZ68hhw6005RBp1ptqDLHDrrDDpl +tuAqOXTWGXQqrW+FHDrrDDpVtuAKOXTWGXQW2YKucuisM+hQtuAacuis2wm51Svn0Ok2riqDTrIs +Vsyhs86gQ/qYfQ6dKiDZIsOs5i8ZadvmMfDmmUCaYBcHQzL09BbsA7f3neVLlTQ28tLBsAWt9mvg +HHDq6X0sqKW9u6VTnPEVtAEbS+PpYF9FrupcUUnGB5wkg3W/ujd2ThT1GZ8VMOs4LGfzQ74+u8w5 +x/PTeK70+8U50mPuh2SS+WjjubIaklHKHJyLq6Q5R7ymqAkFkWN73CVQzV2FguD4McNgEPduYzOn +MboZbGV/1X1kx3pqHofJbupISLeOQUTJYM1X9RjjZDezYxu1lWSX7GZun1ofOCi4ZdEyGERlmtqZ +IUVNNoMqU9gZMHUIFqk/sWlR33aZj854VrPkyuhFu9LM7G3R5iGUrlJMUe7bmcOsQ3vbHiDL6Cxb +0sf0rjM7x2E/PtG4ScC314ZBs0ucWJVN1S7TLDCFpqTNA7NVuxzn8S3sYuBd5PG17PJfdlROK/PU +NPMkGGtVWh8D70997pgNKmOUomm+frYx8I6jCDpltQfTcP2c5vHFp3Y5MVbEoI5Oh8DWliE6lU8+ +zDJT3ACzp3jnGFM7WFfEmG2aqPNJyhxtKYypHb9U7u4+og50qmgC6w0yuZzpsjqfr97Mkrb6lbHf +0jpfTgPCBEB/Wy2RDUC8US8k/OfNcndXHBh7ksVnY+x9VBwbe2YAtDGKS4CwuxoFrLN0q4azVLml +VuiVsJcvokpjvC1gipu9k8Fj6ZKGWWkmRpyO7K1y5Dw2ac4OjjzRhKyvPPHozCsLPTI504XyBwpz +ByhXnIyYUfLXsTv3joGphDUlmwQ5Hdcxz4iaG0rzJfSxY6c7Xt7vpvrY17E79455mp02gmhpPH3a +eBo8GlPCnARcemRUQ1LlI4NBUW7cHxZDUm9meylmgSfG6ZCso9Ptk+KshqS9uyOq8f/ilKR1eGRO +kEdmxSg1oAnvOvDICGd8Nuk5u8no3ioeGYW9f7K6RwYACFhEd7hIQ1vGI6PLFlzdIwPT0DQeGbOM +VLv8PMaVR8bQz3/iID3HWXIOTNEDG86ekp2F78FSHYRaWT6VlWXzuHEnyjJ9dB3acUAM1jmJk9P1 +RDLAdUle+tfj1AFTSwZsYnqdpKEtGcCulC8wgczcu+QifUwXumCYLWiXV+c6aFYfoYry6hzG61nm +1SlSRy0yhe2doKeWl1Qpdq9Ct7QM1avp7yKFzxwKOjHn3SwwaT35cLCXdcTUWefDub9/bJl8OKMo +6Npw3flwK+RZuMiHs4pQXV8+HPRar7gDHeTDGdwIaprEtXw+nCoaSvzGv+58OO29ozgjbt35cLa3 +BKwlH051YuUg1HK5fDitLWZ2rAMz2VbPrIcCbm0xkQCUOibSTLd0EhN5M3YUE2m392d9elU1II8C +JFbPRkdwwnar7xCOkzwSUyhYH0Nw1pDJpYtksIiBt+doMLnO3CGmj3dW1LIxiXj2f+/rIp793zYL +odmEpt6eu5tVtqGcfKTwKqy6DQEwy2tljPiY6Ta8nzjdhhbaOMS3O3vRkNDWcxswguNu+5jkIwM4 +a0mELMScSTFbOOZXApvcpmUWZq2/Etj2NjS1V1pzW2MwrPdhweQz64udbA1qKSOV3F42QEQxZ7OL +hZfKSG1uvzpIInWYkdrcbjlxGdik+q0lI/Xpez0ZqRDOOjJSYb7Y6hmpEMo6MlIhHGfXQGtMYqO4 +PrRBzC9NdR1kFIwIq6/ehncrb0NNKpwxH1t3KhyK57eM6FlHKpzhuqw9FW55v6UaY9a2uwu7coVU +OOUdRCgZ7pekwhl4FX5BKpyxf8yhfXZvpRgqWYHy/mSrxKdP01hVJzfCq/WxfNTGLHIa6AVBsY48 +ig4cyBCY+c12LnUY3SXDbg8XFNno9w6PcKxu5wWs3Ejkyb3YJzdr8+qeTK/D0QoH0TtqIB7k/Qur +xoWN+hPWAJW4TF98lgc3zdfCTmdRLCV2My+lRrpWzMTmfsD5S40j/h6VDS88FKeZbIVrnORz0XY+ +n4udwiIE9YkojnwD9ZAFj5M6F8so6wxaSUKO0qN53ln8MllTkpc62e2gfXGmdD4rOmU/932HW2Oz +DDvm/s4q2a0TM+2UKDVyVhl2voveWdOs0zeLTsuRhKJTbS5WMjRTeOG0yW7M3WdVqkyoSQHbDlgl +u5FRTafqenwHQ7MMO25n55tbPJkluz1aZZ0NrTPsxo2Gaad71e5nx6zTrnU9vss7806L549lU/Tu +juiDV7NOL9UZdmhVwYYVZo1+CXSedNjuwKgd9iqoWjJPVUcQmWANtxNEZ5UzUETPRSspXVoMtALV +ynfsIORWrcGGRnguqjOi2t54Pak99hGqWq+JeR2rbwdDUpyLWQzKLjjVLs4DW6/rrCRnVHbE4E4V +B94lq0pyrrxwjwXHIZI22ZDoTkgXcX12ReQs4/qc05NNETnT+RnVfbMrNuJ0fva1Bhwj3a7OiOYu +tRXqxznfL+WueSEi03BXpwXorD29y2TTLeeHcZtNZ2QHiLU415dN5/B+mBWz6Yx8gtr9sno2nVEu +3bKZj+bZdEa+eONI+1Wy6VRoEfas4f1jK2XTGYGyuSFkiWy6JSWyy2w6o3MaSVauLZvOKJdOae+v +J5vOKJfOYWyPi2w6I1+7WIF9fdl0RquLPL1rzaYzUm6UsaPryaYzyqUzuW1+hWw6/ZA+d8w1pWWz +6YyUU49v3dl0RutnEA21YjadFpRtTeGlsunMdMv1ZtM5x9gq2XQaUNoz8TVl0y2FMdfZdJY5VmvL +pjPOrV53Np0RANDLmrPpjE5LNDHwa8imM2IPaut1Hdl0Nicja8qms5cv68imM0KGrI2vK5vOLpNr +Pdl0Rrl0pvX4VjcAI7IBqKov5urqJvMqXvoildraHA4Tn75tNrsK+czYrJbN8vXqdEOaw1Oedder +M9cunOFpHvK7wpOMJVUkJMzJtFUsHJKAKkHBJOvZbFCaITllBQ6qy6kPppYaEsQYGJSrsstWQzIO +pDDlMBZ4sii7bMIyoRRTW0RH5MlMYxHRu4mJTWFza8+cVC3LqtDdymXuFPdcOVTJlylzZ1pd7tRR +rpLDMndmmVzOEukcBUhYxyfLhe5WW6vy/cRJlRlLL5WjMne2HkWImJXL3Ak6jHWhu5XL3OHcN5tC +d84Ojyana7jnij66Jq0X0XmexenaQpQmp7LKvXQuD5haKuiUPk1PeWCBOtvYQzv6hGl00Hi29MA7 +SqRzEtHssc8wNA/icJxfCHqxCDt0EUQGsWPq+lNTsrMKW6DnHb82nwhemmo6Z6O7oczOe8q14ZKJ +XapoKEBUNvHgjqOhACjb+DHH0VAAmLOIbuvAZsT71pL5uPpRCKwoaHEduLD6DuE4qu1qBEUR2VVf +xw5EUHSZ7IaZwva57AiYo8RasxoQ2sTa+kifWFsfre9WQAhsLYWMEY2B0TphZkrZZYrKhhEqbeu9 +WsVQ7+uPdGEmnj6C2tISN4uh7s76a8lMkW4+dq9J6EFVF+uqYAhe1MyPiB3v/WtXharNTt9g4bWV +1QkMxSqq0wWcNdwSgOGsWq0aQxE3odENh+5iVa8dJDK4OuENhgy24Y2DRAZHHviVK9yJ+ZVmNe6W +2IYGwRXL1q12V+HOKvNxhW0oEppQ4W4tlfJs84mcVcpbNZ9IqpS3+ja0qHCnzktykh+yTIU7q3qv +sMad+wp3Tm81h9lPqyfWPn3Lao6Z9eo4sRYAs1dzPE4UHVybbrnEWm3mI7uq/wjmF54ZpkO7u+cK +wVmCb+ruiIBw1pLPeUY4s8Vs4ZjnwmqSmDx210ygcnlu8tuNkpiUp6KQQYR12zAZsFkIB34tse6b +wzQmJ0lM/tSL1hJVSDEnaUzqSdr4TmVQ0rqYpjElA44y1C3NdmlXJgNOdqWTJCZ/ag== + + + pFW+l7Ur71wlMZlFEMHaiRaS1p1ieCfk8K5wK79GMTS4LPHuHteAWEeOaz5qfqsYtF/cVqRzVe4R +odJcH7tf39VU9+j0bU05rvemV1O512FaM1flHm0q5cWWzHFV7E8pDMNB1rN9jisYkuOsZ6scV8ED +BBeiyhv3J6p+MOOtkmoU+mQ+Fzu5Lex0T+oeX+EoVG+kxm8hDvwq11B2X+nuqdSh/OntAhY8yLWr +8B0Lv1RJeOdHV8pOVflwHt9s5+a+pnRVqeuwJfOP9yb5cEHzJLzp4i1JqnmyJg2P2DfL/eN2dvmr +4LNZEt6TaadgLtulCW06V6K883Bt2qn/uBX9MKvDFpQ7lTK5ZATXWErRqTo1bebn9+Q6grQmyzEY +OHocGHXq8UEEa2vOqdLwmtrcPyV6Tw9rJp1yOz7mvPAm+2C1GXGvFp2WdznzTsuXOw9GnaK6b/GK +KrVS2+mVVR3B0xvzTovF65Iqsgt0uwvfh6VfQhLmYj8VU6++STs6T5i2U+ZXEm/7yawDiKHkeF6U +xSSY8z2jVTqlwxrB26MWnnkLP7Ek6ByGTQKkskF0GqSqYmYfOOlANgPYKW1ik62HxDwlSR9aZTok +SMnmg8o7SW2yT2yarasyC3Lo2lRmcepJKliHVpkuna4yC+ig7iYEzSrrTnPz5ApZaTYRmhhLHmf0 +pDn0cjs/yWsN8+5cV1k0GZIuSku7Xxwj3VWUlsdnNShzP7G7IQFuaR6nJYxHFxurYVfFp/S++vC6 +qK+ZspwpAWAfO7j62sYH+1Jc1+WN95EtZzccOshGsnQvOz3leSmuchOtnJOouzJuqWQ34yNrV/da +vxSX9Cyrb9GEWYCrXkJrdFecab6YndWivyvOwgAy9o+pg0YMjlibJVf1Dsw5TGltNnKzpOUwy556 +44Q7s32MTqzsy9epRqb189u77FA9PlOvCvOtCyDox6fu9RGT2k/+1J354aC7RDJdPYsVyrJZZzK5 +yrFKuLrnQDEkTf5Lp2zlO7bVxlVDUoTqC6fVil3rMhWwv+sglVN5z5VFKqBdSWOb9ZNP3jtl+0Qd +x8SgqWtsWGXGBTC7Kjp+bXatBTCNVFkNY7a5PM4nqT65XBFjtvV0XGGsyjyZANOlCxtphwLGlswC +dJoD6PgeErMEMUc5gBbR6Q6yAJ3mAOr9yW6yAJ3mACpvOHSfBeg0BxB5rZfOAlSRioWFqY2DdZcF +6DQHEGJs+SxAGZ/WfEOdY+U2C9BpDqBkIy+VBWgyJF0OoPK8Eo9HP6vVi/I5r8i2SlE+xVx+YVE+ +nVfhlxTls6vItp6ifDhnxFpBWb0on8dnoBWuvSifvj7yryjKZ14feZ1F+RzVr1ylKJ/SqwAHxZkO +SkCRXWqweVW/1e+GOlnH3VAO6/o5uhtq5bp+iqmt4W4os7p+7uKUlq3rZ13Vb6m7oQzq+ll7hYwt +cfd1/YyJz/JuqCXq+tlT8jrq+llHhkieqxXr+tllcq3JoWtZ1c/jc+XQNa3rZz01je9i6bp+qoHo +qvotUQHEsK6f9YSMIlSXqetnmI5odau5c8Q4zpQ1vAt6ibp+1jd/SWfiK9b1sxR0eSTF1lDXz9ot +7OoGKou6ftamrmEU9BJ1/YzSJOWtt1o9vjXkvLuq62cNBfr511HXz/pAxeMYziqJ79qM1GXr+hmo +moqqfsrqDMQKdf0025BQV/VT3dnlOj2FkOr62ea9rqWun3VVP4mSV6zrZx1wrchIXamun5y/ZUSL +mnuulq7rZ41ApMGuoa6fxV6b9ek11ePbt4biuB6fTTk5x/X4VqrrJ0Ex3D5uszl0df0s8h5so227 +buv6WWvy8MaDddT1M5PhN/qTxOXytxyo8+JJot02tKvrZ33erI4iWL6unxrbWmtx2Xp87oI0zOvx +rWH7SFX9Vq/H5ySJye72Bn2shrtSfNqM1NXq+qkc27qqfjhjaPW6flKqlFVd0ZXr+lmrOSY05rqu +n3VVv5VvbRLq+q3o63NY189B3usa6vpZV/VzXY9vqSxcDbfU1/VbPhleUdVP0ctKdf30rmRlVT+z +W87c1vWzDu/SSLGl6/pZBzppfEpL1/UzWBdFVT/re+Gc1/Vb3m+pxpj7nCcTu3KFun4y4zKq6rd0 +9KCmrp8lRSgqgKxW189aMcTW6+p1/awTYgWJvHJdP/UktVX9dPqY45us1HX9zJUgrMPY3GTlsK6f +Ix1m5bp+ypXUH+BYZNea7E/jun7WwsEyi3NtCbFY7scMxMODlY52cW0c8aG9V+oT36iokZXgqblr +1zrwXpO2qKImkcbk05t0aqLMg8e+KaGrgEpCRscyYojYRZeT8HmuskSrM5j7Rs0+t4BYOdkKPZ7v +ErG7Po8bwXyqrd2z9HGUCIy2Yu3HCUNPP09K6cFz4vJ6PxAZBv257xxR+TjP7nwvctzWU7NDg19v +GR8bP6jsnV18X7Hf/ftHj49no0w7fla6i55Gp1tstcy85a7610ed+hl3+9nonrPfN4Hu++5tNsgU +vrYbV6f95ODwbtw9Coy+X/lv3zQz4s63bs+P/Lt0oMz53h+Pj4OLz51HZvzUTQp7H+V2pq8b9Zut +aOgls0V9fN+EDml/hijlTnNE6b19QpS5vavp9C0RmM7it8eznReuNWNbjzUp07IRSsUit1G6mtgW +096+YtPZ0xgWm0vs4NxqPQ9R5ZcePFRfE9n25QQa1FIJSFhPcvFG+vazmeqJEbIQMsB053twXejd +LdO5oozGQNPfre3cPDTSu6NprLRHMR+LnUFnqwMzSU/E5NCtRXjCnMN4tbMRykncypYaDR+x2+0g +e782VqvsE832AVOr5RVJc7K/VTE1wNaM8JDmfPmFx1d4KHXvUAHN/HP56o47z3e2M7H54UkmNusc +lBI7/VrxNkO/ALSN0uXBzd1TtsJttQCcm28RLC6fGSBDfR6mMt6/ZA6qW1M0q+xwDCk5e3p7+xoq +3txV4C8w4dogCpN2w9isT7P3U2Q5EbF5AEYjvM4xJ46xUb/4iwwg3zHACD8Cf/L7KOsXMJzjCfgz +FUYcZscPpNjjFDzIR8UPS7FSkTqLA7AVIlQI+xalQOX4mAz7P4fFdv87QcTSfBANFA7umdzPkwf5 +XjNGghepkOJFczef8vjEV/mI/IrKPVwfiS+OY/ILevfgIyu+uCClFy8C2sqpffmZ3DOU++V8WPEK +9i3AKYNdDzCxD2b6FIJzDlLPsy/AAMtXJLoJh6wcXdFgupf7ium2PkIQs5cA5alxn2zv8knpXAyw +QkheObIdSZGwUQzmLQ3J9tExRNslKXxzeY3AwqTWwx3YcwjmFiOxtEsFIwzU/hsRuVMqeJQ5wL0c +wAPvq9wg+rGfrbXfq4XT4626TJLSsUBebbj61AZnjgpWSodG8AAlLwvxspqSIObYeW23W35+iH9k +64vdXvGhUyPgrEhEvZiS36jnxUtGWI37F1okrwajmHrhiG+L++A2ghBIFS7zUALexkSyvwWwW8+w +NtstKai77K2gXYzhb1r6xWAQxYMhB/58ECC+tktwSR5i4tcPhPSLVIzmjXrpiaN5oNELj094Vejv +Cvug/8XiuaglrfrMdE/FZiQuYMJmgKyEjEbDZpLPF+NA8TZ3dpILDqYwp5+r5IpEtKFnM9oqvX5E +bYALxNGNrkHpXAxwS2HH3/VDmCRzdy8zMKvtaKy3XdujdxPDOUEEojNhuoC5oLhp5J4EfzJBlBVM +Fp8y8M8k2Ei7X2nIN8KK1X8C39xAmqhEkRoEI1WiyHAnyy9RaJhXYiYumAohEeSewp2SZk8DMFT0 +mwwTozePT1yo032878J5X0t6JuxfoMPB7XwKFp6/qeTf+tmOiglVCYJtncKFOFXQAVnOfUON4+MC +YewcdHA/RpwYTv0pK6glgPXgZ5i5QoaDJY2lHJKds4aR9uIyBtRn8NUZVHMyQIDHF1iv2WPHJYVy +h55t57Pb4LOrOWx8o7r7QNSUgkoQ4V5RAyKU3z0qSgK6QgUS97SssqFn29vpozLR8Y0K02lqvK9U +IYB+gO5VKPlkEER3m41pQNzd1bISiF5AtVXKA4jUAF6/4tNBhN47eCQBjgthSDmiXYmeQhqL4qfP +s1e4xZ9mIpt5naswv+MXyhxTH5eSpvQsK0mowDRUNbfhi3uEO4We7JeVlv3M7X5T1E1SlKiW4PsZ +gPjbZsraYsuwEK64Lost2OkWXgFm9rgHpVjpdUu8IyOxI4xncH2uVN7vwyMBY7kgdHrgSyEqz9Ht +r2uAp1AJdBqNoA2uvy0CeuHAyMohAQmFWV1CwpMSCYvHCwkJmhs7QgoUPE7pluLuDgkFHl8w/9B5 +EZEAxqNEAj81RYKIgv1dBQqO8t9jBQqOAoUpQgGgZKFbsf43WhJ7JAAm1I/hTmn+oi+ggFqQRnSA +b9W4VyMhJhP23dY4VsRImObuH2UkBFq7V08mdCBcRytVLQd8zIiULEGE3NOiOnJYPAeQR+F6DBEj +AGhdHIOILrml5PjkILHiaoTNaRpxfnEUFjQdDpuAcIQHxPnDUQfToDOXgYAAonl0oR4DaT0GbFda +8qcwJYLgduTVmG2XT/OqdrF9uR0slV4zqfMOFiewKo0FV6ex2JJjUNAYuSqNBVensX1TEA4AYBqL +OCBTFQjtNGxQKdCYJSaIFSkiFvL4HGDCEoQTzufxWYIwQ6Wj1YAAokpvz1JEFXNM2EjuG4IgVp2G +Ymd4fMtNg3I1BrT3taOg7fdnhUmd5UN4DNM0q7r0643SygBZIjvFBBV2PwYNt6RWJSoqakQRrrgl +5US5MZJDMrekVt3iFKn+k9LwMYoWjIVApwEM0swMe2SQVSZr+unybQBbEbJNV3xJHgpm30V3JNi2 +d/0I9VrphIlY8zuCrGF4R8TsMwK/jiIbhD663ka2n188Ttzxo6AfZApj75pkCmPfmj919Q3+zETw +n8+zLjIU/fTu4eFb6TX4iOq/vGQ+JHM1IHn9nolOIJAU7dPkvsKxpphBOhNWuNX8R9W0+KIUlV+g ++y4kFwwwdhUet6ObSU70lCXRNILKnsuZkMKtpui5XJIdei+oJjTywlVjglehfEFA90AIZ6YA45nC +llzrxdcUp3sZwo6z1oSEZH8ZkdTrXcqfDsCkxsuo4Fvj8pByLglcXW5KtisX6IEAtv3wSAo+0ftS +KHZW70N+0MDmPxXkkh2x00YU90L8/7VdeV/iOhf+BP0OYdzYbJN0dxsVRHBcGBEVdESQDjogKMs7 +d/65n/09JyltRVRGvXd+V5vSHpKzJXme05qYdyjvlBZ20m7ianOVns6HG2/hY+Ott0SfntVpBbv3 +E20GidPkKS9KpBGJTJsbrKXKq31ro2wcbtk/mnEfiquWYr7/Vi54YI3r0L14YtRshwjJWTqKuOXX +MVWcqT7YVi0wCQNlb45M/6hT5v7R6OJK0IB8J1Gv+Ue8ZaIAUwgAH6tVN1FiVcX3og== + + + 9Hits0/l3bXRsS/7OnF+GwBrPIq4rTZ/BR8YQRQ0grFUBbUU2YkvSoxAett6JS6Brp3LLRHxyTGu +V3rwL4HATvnIuREPkfMA7F4SmBJWHcvVRT4hPA/LWXBmyKcC8AcCezP2QygY+dG0eH0fRNhaQbs7 +H6oSqrpLr6REdtLnV3f2pj21oyxA8B1+k14b/MCPyv4eeQJoF0j+BMYuEKeNjMgwccgwjfZ250s3 +x9JXtif0KcbyjYa410TEo3MeCN1CMnOkmdhuOe4I3AsD14fQdlsGauxQ9ek78NR/NxSH2SZxOLWJ +djzqeP2j/l3rrkvSyqqibRUYK3ebvVzf8068f4bZ3s3o3usOyQrRtkqZQsExs95Nr+kRUYNiXtsR +jEFCa355TZSJfFJ3I1Ho7E93t52fO16vZ3/SykakKkds8ZceTh5j6dtfsDqJpW7UhVi61ryIpXmu +FIvnB2lsViQMEYzsOR92DU5iJeeyXn97tJM62D+bANDFbOlen+yuKws7Z9ve8aY2aK1p+a3qt2w1 +d1ra1Ia0J5CKSXBQjjQgK6dwm/0+Hy7GEmuHRmxZWzpFjjMLY5nPOlosndjcxLN7sdT3L4c4vkP8 +4GtseUtvxtIH5/lY8nGuj/7v+AhSboSFcjzlQ8Mhf5Or1cYxWOyJwFBkCLF0q4XI7umjn2MRJMa7 +A5BYE02sRIv7R7+8pB9F4D3RKBLNlThGY37Zzx34Yg9fxM/yynCMOBciMxXN14fueAqbnYEK+Sdl +4b9joEL+SaLeszNQ2ISlRQyaxc1Qds1H2Ys5sWRIQmLztoWjIQvviGqqfQfi/whMWzzScK5Nwxc8 +zkOzLMQmpXG04oUezIepCBfVXFRhQqrsh/P49fhbhLNXQWNZrb62uNLqLpVzazvGrwkYFOsRvkeL +q8YVVkEtgAs97GZCidPkyWcbZpY4fo+xkJjYc767zm5uc8k7yRaa6zE/mirnLKCZ+BP+JtGpzY0n +zboRDL0eda/GkcinaT/lNsqa7/aNc8oa+4UEHMFyQ84rjSu+4RY42KpRx1oH/7hpCBG+advHQuKy +KICC5vl4mdS+oOOjq9DbGtGlXLupRz64iuk1GIuY3a8PHhfEWJ7WY2SiNVTgtdE0E2SBt9MMZktI +NJhN1vyyio32V5lr0o8PR9PTTJDHRJw3F7VFH8aX0/FB1x/ukZccr7OX1ktJn96G1CSW3ejO1F92 +n+3U5VwLyQVnoHxcTszeoI37rXzSTynsi8azyxcpQW8H0/qy/wyw4LixRObcX3/tfkv4z6CZOW16 +mSDkn7FDYp3puNgUMoMRRypMnVijS049PrFAl1Oz3AtArgmIJjXKrj9kaHZvrUefZx2YX3yaaT0p +GDbJRaWE3eSuZ/dKYN2Hy/5M/bCizcxJStnPnuwI3v0hzRj6E5Z+9Ne1X+EWcRqxg2+L/j4mdvqp +CW6o31/7WopiH7RwmVafirjdKNeSOwGJVZ4gsfDcXJTCqvK9CQqL7qwdSQGS8fr+XMToiYj8Yj4a +KkZpaTxfI2+aPuT4WlH0p3wKj9TgnCbOiXcXboDXpkuPuL7syzQDk2N1YtH6/m1x/F7UOKJOfNYq +5jM5q/fHAX1UeYU+wsh5mz7yGeJp3Il8t+qM3MkU5iSCYSoL74I4xEsNpQquoioQjJ6vgmqoAhgL +9ieqBFzov6GE+tphqAL9osOcUAW4zlYnaMTw3euzKGEWpP91PFr8UeTXObRXaUT8Q3FjLV5OONKM +TCT+XaoP+OL4qYOXejFbH2r91wVIu7wqojH4WEjt3o6CqHynNYqXDzP4NGTLiIgJny7WXgiLWVVZ +9AZhtnwXMbtR7MXe7kNlXH04vRf9ceWCUbkPRdD8QeXmCQ1+GfhvJWJ4mvuRP57wMfEag4/4WKn7 +YR/zhh/sQyf2YR877X7Yxyq9v0q9zwU0+oGPveIi1deGcTuzKl/0sfboY9ao1CLhKjU2TROvimj8 +XebDWWxShNf/mDUqt4MJl/I1NrtTVdrvcOwn72PaqHRHHxxGPzYtMmD/MvswRl/e2YdgnVydm3sr +PvngMhQRWzq9LUX70Gi8PAdEZuTXNNHwHj/SB8yWjdsPOlWjPfhotmx0h2+mulfnocbjKLJOfleI +N0axaPNm7suT5uKc2CpIpBjLEb+mEJ2wJhAS6g03HbHADPd0kW1fff7+Um7ll9Yr5rgKsya2jMvj +qtfLgdxXBkWrCFX7R3GJ5sFWOPl0Kyx2xmm/mVHFvlkNbtMCgP0yhINRY7CxjSBun8dAhfyT+Jb/ +iIEK+SflKQOFMNhumQtULAr0FDMpAZz5QE+xsDzepI6S/i6wuK9KbA3fdQ7NY4qrfwY/mmgXrXgu +xepfT7qqX9o9rybGXFRB2DIVRQorR6r4Fn3b0Z1V7yrxM3Nr5Y62O86cE4GuJUwLG2//OfNnFEK4 +e68ca38lcZo85anEMg0lWuX1lcxWeXH1OnNrf3vYOtnqnkkobvsieeUTTTfnQcX0iR4+uxC1bmM/ +HcFg6z4A2TiWzzbgE+4JeVT/cioBuBAa4ttVPY/cSEUQLeLIN2yjZUpsTSK07bIqaxxZUPW8HNBC +y1Fctl3nEWAtggi3W8YYP6qa/ljO6ZzYmoWwmnzacGqBderzyqsFqjC9wPoTy6uVhRcLrD+xvFpy +UVMLrFPvKa8e/LuhrIJLFRir7XSbUY5JWViAMyVvOHrAC8zatte66+7X/3h9hRH5j8I//Gm7hHGH +cNOEholn9xtKPOd5zQTZ7yoLNW2rP8ze3Qzvet16/w9ZgVOMaNu9XofEtwql3BnZ+eeh1x8SIZ+c +9EimVEogq/Xqdad3g7tGx3tyvXZ+sF8uZMkK8TuwircyWoMuwHl5EYy5plCyBf+f/4YfRwpVKbct +h8BvmxquDQeOzW0DT8B/OgxTdV2L2niJ43Dd1OGAGS7l5LwOIo5BhGNRapt4geFargsHtuOahuOr +Cr4MvzFo/AFF7kHzF2Gq6diGS34TgxyQix+UNLFrx4quGqZJHaJTlTtUJ/fKMnTINaBrhFuqblg2 +gTPMtbjjEs5Vk5vYZ8aYDhZhlupwg5Mb6JzBXJdzwpjKdFvcpdtgMZfYqq4zakInHJtRkAIfWK5J +MoqpWrrLLJCnm9R0LMJQTRwHBjcYFpjdUG1mok50alvMhm/iTBViqWpalkEtwm3VMcE1uMps3dFx +LAbIJaYKqoF2RtG5apscnUh1dd0iOuiDgjFQFLPE6A1qc8Id1WHwrRmFu6ppM53Ab5s5Dn5i266Q +bRtgEvhOSzdtlMRtimNhrmoZKBvsyMF4MBRQmkF0XbUcMO+kpjPK9nTHdS2TaIXuENyq2Wt4pNip +w2ckc3vXaZKTekt6GH3lmj8PXsQNRwoDPVOIIW7CYGC49woa0gV9g4kdCp2C4VAHo8xWOVrIUi3T +0tGW8AtHV5reV5MZn9pXDkZltvADgzocewpnbIuLMxYEB7Qt8E1omjpoEZtgfNF2XActB3pnBmQP +E24A/YOLGpQJ37VR73Cl5YJoHtzxwtgg9D51bI5q2aYtYoZhl+/hjM0NxvEM5+BU6GPcsETbBKcD +b6QuFXdw1zDQyRg4MGQAPGNYDMPDcbFtqAy1YsDYqVAWOuvLQ7M/12wywb2dnTCP7cEBJCTyW7Ex +D+BwOUSEzaRCDNu00O8ghhwCQWgZriFiCQSikU1pfI5OIPRBwZqQYjA5oAZdS9cdAiqGCQ1TD7g1 +JC4L3IrCoG8g5bi26+IV0FUT+wz+DQlEfJ8J0kxDBzGmzrkuMhRo3hUa1bnJ4TbLsoS7udjRySFk +lJ/TNc7Zpyq8rLgkniDnZ8r+tpw9YS4Vc9byMkysxXrLO+nX7zowl7YG9f95pN7t9ob1ofcAn5BW +3xsMe32PDG57v/EM3DK+HGblo5zyfw/e9iQ= + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/originals/SVG_files/Podcatcher_48px.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/originals/SVG_files/Podcatcher_48px.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,2719 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + eJzsvWuPHElyIPgL4j/UfRAwAxxL4c8In1sckFmZpdUtNRpMz0haCIsGp5vq4S6L7GOzpZ379Wdv +N4/I4jO1kmarAlUsWnlamJu7m9vLzf/i//jNN88O37/9w8tn6Xa+mf7iL+7evXzx/u27X90Q9Oav +X7/++af37xD0i9/+8ibk2xkaHf56/VYa/t3Ldz+9evvmV/Qn+uM9fvoX37z4w8uXb17cHH56/eLh +lze/+CX85Xev3r9+CX/7zdvvv3vx/rs/vnz3bV5//J+3L179Ut8MqE4v3kOjMP/lHP8yzmG+CeVX +OWODF2/++cVPP736//DPNa0JYMe3P7/5/tWbH45v/+evbuabZ+Emrze5wV/+86vfvvxp++f5NsS2 +rolarbfzTE1Pb7/7+eHlm/e/eff2u5c//XT39vXbdz/96ubuTy/e3PzNix/gLy9u/uvL16/f/svN +8fWL7/7HBAwo396/ev0S+vrw4j0Qiz0//HWI3x5/fvX6+1///PCHl8CFVBcEp28J5e9/AlyAFn9H +8PLtXz8A5JuX798DifDC2dFyB2x/+6Ck/OI3h1//7m9/fb4JMd3cEbf+5r/+F9cGezffxgw/Gvy4 +8IHf/tXR948+gA3/8bcvf3hFQwy8/2+/FHrfvf3x4cW7//ETNyNu8V9+9/Lhx9cwQsTRmG/LTUz4 +Q3+TVsAbavEsLe3mWSwF/pznfJNma9O5/vKfX738l1/d/Prtm5fM2sO799/wMOc8z/yT//Lbn1+/ +fPf7N6/eA2UVQY15+zdvv3/5Gtrb5+9fv/jhJ+1k6D+5we9evPvh5XuYIG9f//yepu+qb4Cxe/7i +Ty+R64Ff8Lc/vnzzu7d/RzQ+C8DeEMtNugmprjc1hZuwEvq0wKxs9sagPxktIkEUihsmxl/8Bkb/ +b9+9+uHVm18JZcu3f/Xu1fd9RizxZuUfRPzt6r6bfjOV0OH371++EaphJt79jZtZ8+3ffANvPL/5 +/u7tA3L9J1w8MPJvYFK8fvsD/81+p7/Ax3/+kamn/38LA/Sbd6/eIM7p1/SX9dvfvP4Z/vRX797+ +/ONfv/mnt9MvWG787t2L76DZzd/+4b+//O49rH8B9N+++fnV+5ew9H/85QcRQbfevbzhP8KH6b/6 +78c/fXr5T7BC+8cZen7zzy9fv/3RoTXIizff3/z9i3c/fhz1b16/ePPi3Q3BDfPzV/8Mf3kBPOq4 +O+wTkL54/0eQMS/ffP+T4eT/jvgY9nF833yHk+LdzfHdzz/98eZ3b9++NrTjnwy7gAmK7f99vOM3 +9IE3f/uGGbR/kzTYvgkEwb+7t0Drx98Af/z3jP3uxevXr3549+LHP7767tILLvzd3sR/+5yJ9aeH +P7x9/eqnhz6fHOQ3L969f/Xd65ff/Omn9y8fPoQNufFPr958DxORhE6n9u3Dj6gg3Hzzxxc/viSc +7/94Ty2/MYTlWxCMXvQ9e/YBmQi77fGN+/tfvXvx/SsQt7CFH1///PLmt/DfF69vFPzL6TIYxD0g ++n76x+k/TTN+hTnNeS7zAs86t/kwH+fTfJ7vQwgxpJBDCTUsoYVDOIa7cArnOMcQY8yxxgWeNbZ4 +iMd4N8VTPMd72IlDiimlkmpaQJtq6ZCO6Q6eUzqne9itQ07wFHhqXnLLh3zMd/mUz/m+AC0llFhS +yVMppcKzlLW0cijHclfO5b7ONdRYU4VPw5/r9H9rZ/pXsO9w8X+o/0X7meQbSCN2pLlMxBX81p9V +vrP8VoFjFXimP1fiH34399sBvo/w8zDRP3fE3jv4RibzT2A2sBuJgy/oDOh88JVC/+U/Tff39+f7 +0/3d/fH+cN/gWe+X+3pf7vN9uo/34X4+35/P59P57nw8H87tvJ6Xcz2Xcz6nczwHeBd8/HQ+nU53 +p+PpMJ3aaT0tp3oqp3xKp3gKQNb93fnudHd3d7w73LW79W65q3flLsPQxbsApN8fz8fT8e54PB6O +7bgel2M9lmM+pmOcjgH6d384H06Hu8PxcDi0w3pYDvVQDvmQDvEQgBX3NFb399Qd7NCJOoXdwo4d +rHPYvYW6iJ3EbmbqKnYWuwsdxgeRnM8T9Rz7fkf9Rw4gDxrxATmBvEBuFOII8gS5gnzBZzbuIH/g +awImIZuAUfA04tVK/EKOIc+Qa7l3Zv91/sTntH2mPUh49CnPcf9MF4CH/QOdyTd/8e3xHfSp4tdC +zwpPkwcGsx7pgXkBfECm3i8kOhYQESAMEj15gSULH+avdWnT0uA5LMcFphQyEUbkfqUVswZ4QIas +ICjWvMJKX+md67LiV1thFq0w1dY7GoIzTo02T7C0QCS12FLLDYQDkLc0aN1aO9AD87PBHMaxo4kA +swoWIQgxmIkR5mOCWZlhbmKngDIaSlx/tA4jPYFEID8ZRGECUVjoN/yZQSwWeio9yIGKnSFh2eDf +w0S/HPGl8PMoP+/ogfUGP88oTXE2R5JD9K4U8QskKEhYfEAWgpQFgRfXiYRtI4F7iLAoQeKe4OcZ +ftLCANmL0jeA9EUMKGZBkMKYoFW7kDReoe8N5DFJ5EekDXKLlw/xD/mI/ES+NuIyjmclvmcYgQQU +YVdnHBwYohMM1h0M2QGbwiAuE41ogfFNNNYB5OU9rkqYCXcwK3AEGkyUBSZNgemTgdQIDJ1h+eMk +O8F0O8JINUCzwNQsE8j9DDtABM7PIB/OsCLvYH84AEkrTj7YNQrsLwmYF0Bk38OiP8EWc4RBb3mF +N1TYfDLwJ8JIzonlEq5pepI9UR4ar9PMjyw2kTd3JCzu+OtIz4GeNiHj7ogZdzTzcdmAQC0kVDMJ +VhStkcQrPjMJ2XsStChqTyRuUeDi12EiudtI9qL0XXg1ggxGKZxJEoMshodm2nEmkYxCGcXyiUQz +CmcUzyigG0uwC9LgwtM+9ZmG/66f9SyXnukiuH7iU/ZPl3X/aNP+5gO/8BPhu96U+XZpYJLPiABM +32+/HMHxJ3h7nkF8Rmxac1vSRSw1wkRGk3yFpU1t2jrDqlOMy21qId2kcttK6XRdHzVRDEsrhIpe +IVDB1nwRbczLXBBtBSUxF0QL+hI0FrThFtWtG1DFOrlXxgu0Hk+maKsGfFmFvn/x/cub929v/v6P +qMZPm//DUEVWmpGSAiKIfkkLqKh78QkktRjKMv6CVI6TDvHcKJ6LneWPj78gHptII/+uh5KG+SvR +zYBuKTfXo88Qfs7A/tW7ly/feKtoAyCsYg+ZEM0mROeNCFXxaQLU6biZtIpIOsZMuq5soHdu6+zb +JmycJH1hi8bNeobtG7fxI2zsDfb7QnpAAN0A9YQDbK+obiTQT+5hB0JTAi2ROO++tpbQvgHJ/C5B +iyjYYJndR1GvI1okg5KN1sXZ9OzjYGWAZj2JSh0GU+NEWyP9ZCOtib1UxK5CUyuJIabPZ3x9Wl/J +ekT7kS3IO9AV0BC4F0uSbUmzJkXzXUXj3Wi7qO9OTtnNpOxWUnZXVHVRz6W3Ou2UddNGWukd6aOs +i0bSQgtpoCvMkAPMqzuYZ/cw6wLMvwQzsQABC2z2Dff+I6gCJ+D9PSgKAZSGBCpEAeoWUDB4LzcF +MJACiGY4fmVTBamrrKaTMojmeSMT/UBmuiiGZKzDM+GwJjK8Mo1XJtWXNVPE6c0G15GDLBNcMCda +PPfUrVm6FulNvNgKz42VLOUTeR4SqdUracwnmI6R9OBFPA3qZsDesRFG05K/YKrytKUJHGQ6k3JM +NiSNOz2oWVxwHfQvno/sIEjU+2KWP1BLHyadlLXSir4KUktZMQ3YkpRTVk9RQWUVFZRU+vAHbeUu +OrrgyKxr81AfSJPHZxXtfpHhxYHmIecvnAg8KaAffsSEjcRIsRRWmQzHwV+DI57NYwOKPHltRr8N +jNlEjpsE7Qpp4bzy+qob11xfb2xlsn052JYTmZbRVls3LHm1HbZWpdiVbFWyTalWJX5kncioVLPy +jsxKchKgWUkP25WROJvNuqy0ihexMnE1s6V5nHampj5scs5idrLhyaYnG59sgPqHODDJPx+cml/4 +9eeKMNi/wRx7gfeWifx6Sfx7JB/d9tN/q7YtLbRFVVnoi/s/ufYm9lvQ+NCaqLIajm4l4DIoznVp +m45zXlbZZnjSw5SH6Q5znreWLFtKs+l9pmkdbUqziwRnMtraJ5nBOndl35lowh5shp5lTvLmU2zz +OcjmcyJpfU/WYxQJzVvQAtP8gCbokSxS2oZgIwpkvSayZivZuCtZvQcyhPHrjMYyGc6BTGncVgq5 +0XDNrtNpJQ/bUXSFE4jye3TJkS4R6UGXHbKPpAK583jN0sZCyshRjfHziTeDk3dtgGl/NEeeuvCy +mPdBDPqzGPHs/FT3ZxVbPYmNzk7Q82SG+UHs8UW8oWVUHzeq40GEPYv7rjjGiaU+6o3kezmJ9B+9 +LnXjdRn9Lmdykd2Ru+wwmftlhYnC/pdCUyeZFybgTCZrmn0xJ5pqR/HIHEjereSXWcDmITWnmIMm +kZMmkqMmyCrhnfUsTpsTOW74EU9FPdjTJpaqrI+aM9f5co+DL1c9ud2Xq57c7sud1Zc7nc7mzlVf +bvfmNvPmdn9ucZ6fwePD3p7JOXsuuHou+Hn2np7B1zOhs2dw93iHj3P60NOc30d9P+r94VlXRvsl +mSsoOodQUJvG7Bp9zsNDnJrkHxyfzwwKWFjgsajAtA0MiLqzVXhM5aFJfhbnIrsWdWaTX3GiSR1s +Op9sIjedwDRzk7oWxbl4MueiuhcXVuQmp8nt9biDuBpXcjWis5HdjehwJJcjOR3Z7XiiGXCcyPvI +/kf0QKIPspJKlckTmcgbGUnZYtMI1W6e4DwveRLp4B5YAxwc9yYU5kEo3KlQcHxbzCebd/LA2DeJ +EFAx4Ne/rv15cNN6Xoqz1jNyusBHz8UsTttIrnXPw6M4b9vAvDx1L65xjHl1NAV5FdW4mErMCjHa +3PebfeJOdop12CU+PTi2CY1NtAjmj4XGxN3eZ39X+Pvcv2OxroOn7nR1po/znWe7yGYaHxybA4nc +1UYl1jiJC72PSHOjwWPBDvQzjYJOYZu8IwNJHz+ywmJRnrCJ7yymuoxK+L0o4Kp8AymT6N2qcXdF +xqsycRPPWZ0Z6kxQHIjJ7E/VbVi7WUm+Hkjm3pEcPoulPZuSw/Z2MUUHVZ3DZLoO7g24R6i20/Wd +TBuM6Tyi8qB0hfewgGWliZ+jKU93gvZk0YZ7U6f0JfqiaFELjE3KO/W9+u5FQpmrbIRMxUE2SFbC +VBE7ySZ65h31XvQy1c26fhZlG87yFHmq09i61rayeTTRP4dBiXNqnD39y4KmbOCzBp5EB19MC7/b +6OF50MSPaoo6Tbx0XXwSZfwksU3Vxovp4web3vePauRHmdIUqtyo5IMr6JIzaHQHqUauLqE0Oa/Q +KlNWJyw7hoJp5MXp5Dqx7vyGISFLl90h+R1B4o+VMjxWCzme2PsyOA4yOQ7IdTBJtg== + + + x5Em4ln8Ruo/6B4EHi31IZxoxHr2RzA3gssBWcSLdzR/gvcoRPPiFRvOdYhas1/hNKkbT4LWQTYy +9eapj8F7GZrErw9Ouol8W+4nF8jWYHZ3PYwhbX1WCW6rJ+KwHvszraJLykrVZTMEysRZ0V0WwRwX +/RH30EQ/BjFNGTwJZHslcil/x3nVNHVH3UD34vpjJ5Autb7Q4mRun/pp6wwG5GQjgWPg/ajoQxVG +j1tI30Dwa1hn0v0s3pqeDcDumdPkVtpj28XRrTjZLsxTWcwOlmU3yWYhG8WFrUI3C79duHXodwwU +6dOwbejGkd3mUcle2Yrwgz3HUYxP4nh34+48+Afx4JsPX+ypS07842A/L5YCkyZRj9RSOg9mdDek +FzGH1JTuxrSGusXimcygHk1qDW3vw9qbkLYY12pel8kCMy4084H0Bp/gUH20Rk3uiW3uQcVWy9sr +2gdZ36puLyIFihnibIqL6aIaeBBxMlukW7fPkz139hyHhyXUYaIfZFb7mPoYDu8ZVZpVpZlVEvax +wI8L/Uwuz+rO9mzdw5vLuerW+mJqQHEZWGK7T2a+R5eQFVTPcClQZ2fRn8yu77a92PeTLIVmz2pP +52C1p7gnX0gAgRke3RPcM/dnk4Z1Hp7T+Ex3+6/j7jk88rT9Q7ojh0H2OX+W8fdIwt8HrZpJPBQf +N/C31s1o35iNP5lfS5eamjl5yCLqniw1WbfmamC7Z3JZREfzWC3OVE2DmepN/qOZQ4vFb/J0IYDD ++UU+hCNBHMs1UgeAdwGIE2ASG/Ysc4t8AWLNsj3LDgG2atWyZduqmHsgdyfBNIbdMJkAaAC71sfR +1xrx9EgH5GXN9AtsnTFh4kTkDAoO/Md4izrQmFBwXbSUVLCEGRpgszmXRukmtTXKBSDTHH5JucwN +X1JgZCKmAATGbSkKLd1GmAmd0KtilRyXCDMTEcTWKp2GiW0OZeh7CEtFSFUmROx6z/O5qfE2wTzx +KS7XREuUhhVwDghirYBiGLYCfeUjXIiczvkwttRucVu7SRkTgByl10VLlH79dMr1llKEAjInx2vO +1C1qToFZlzTmTYW45oErjfxJ+MsSS6YRnZEtyogFj69h2lJoLhPmung/JyHm+as3L+l0kWXEbCE9 +22lzRACjYXxA4M4OCODxgGUwIO/leECikH3txwPQcJx63H5jYZzFvkibkNolY94F1aZyFvtia13c +7Ux4tS32JrzzT02WfNy2lvzgmup2hvdNHdsu43i6aHGozdFzJe66re8yJXa5EujnV5eVmiLsuDpI +wMA5r8wm6VaJWiZZohP1bkX9gd1XZwnSscOqkoVxEAeVTIUok6FoFoRMCD4zMsupkX5uZCW71HkX +dIJMkuJcxMXgZok7Q5KHUyTbrITovT+T2aSf5P65aJiuLueHPAVn8xREl+2z7HIPzpZ70PPZ1Slk +02naujvdrIqbbINtNvuQy65JBZNLZi8ba9bbs2fnQYrOmt16Pk8TRXQTzAu0V9FOPZGzMdKEWE7t +Y1NhnAyzO0TUp4OmwZ9kMszTIDDGydC9TcElqlT1N9mUGCbF9IhPcJwW24lx3ETpe2JYmS7kqYwi +JmxSVIaEsK3TaJ2nrdyxmeJFz+XJcnG6TC4rZXf2YfCT98kyOj6cpxzdHhi5wDmCswOFylmC/Vkm +R/vzSVDpuYfxkWyvxU5z0Tmu/QzndLX9IblkLlRJXKOJrNsfTt+7ifxrgUQZ7nssw+5hmiba6zB/ +6gRTMsBUxATapq4zmHMJ5toK8+tuOcNkSjCJFgwR3a1noDbB3FhgOtzBBAgw7JXyPE4gCSJIgIXG +9QzbQ6QRPWCqhlvqK0j+u9MZrPA4wcqplG5xh174+0CpdBVm5AEdV/d2qssfUfuSA2qDsTpd83ga +mqnTx4+nfSjpzgxTiz9PF+NweqTFx+H8cZbdYZZ+kmW6cJTlMw+yUPiTg58trZPFPZNFPM90ZIjz +jFc6WVRgklK2MZ1FOlPG8ZFyjlc61MSHnvBAFCynezq3eEcpyD2dN1N+VdDs4qep8DQVnqbC01Rw +U8G5q9Y6z+RbAO2stkY2eStZapGQ/XnpfMvnfUzOsHzeyayvOdX1mSdTvnn7T++56s/N37364c3L +93Tw6BK0n9lXHkzKg0l5MIVppkfY/OktP3FA8JxMXW9B68w3S7oFxTZ+1shc+jwN0ad89raWEHNB +v0fAD6Sbdb1dUmyfR8LjaD6dkla+bGaOn/ycifL7N29ePLz8/uYHAd3AioOZchFM01F8N5vqCxdt +5osulkdM5mlnLy92RsafBg+bnIkxa8LlTUwW0q0udcK5XFxYt7tcFjOLd6lAW1dL2eUCDeFdcbOQ +Ufy4MeNrR+zrRST51mIRvWhExRoS3XpYrBoEG8kH8vDckSnRy0FwMQj6hnfey2F0PA+D33ECkRvt +BLqePedz53jqfOFz52SHHEhc90PmZztgHuWQOYj3iU6XVzpbo3kenOlxJPubj5Zjfg/sEXR8RM8U +lUeOjl9jS/Y78nSNLdnvyNM1tmS/I09fviX3s0vbwhXbshXbohXbkhWuXsU0JDi7chVDavNs0b+e +03wcgvYatq+Ti9y72P0Qve/H1A+7AP42hE+1QvaH0z8Sx+dEedYpxyIWl86a7w+Jl03ku8e+07QJ +f7sQ+C4Irvnpp4uRcImFTy4Y3sPh+4B4D4kPQXGX1C7jPY1hcRcYP38sMD6qXhHLFJYPKTWwiYVW +55VjUyBv8BcMneSLWtK1EHLUrYH8yhTHW+dwGVmENU6nxKv+ImGoy0rj9VB+3Z4d14t7NoD9ns1j +S3r00TaLg6R5UVKInEVS19Slo7SxH4KanG/rs07W+q9LeyP7fjkiRPEg2qiyKxXFkSAtE9UkeRAd +ueT9mkg1OUrkJ1I5qF4MChQSUkd6vOdAXjB2zdrxKaLMPJPJkq36ESSfZHW2vNkwJOf29FzSTyYJ +exwskUrzYO9d8qsmvWrCq090Xc9tzLr6rOpAl8r/bAoBTZ9T/+exoj8sSr/QDL9ghdOGP339ji9V +SVzS+Z0l/6+2k+peqrupmrhq5HLWfzU7N01s6pqxq+auGrxq8qrRq2avGr5k+m4Kh5Q6t+glyZJL +5Pi+Woio96PUwxSEANpFvWxrfi2m0dqFFbUWkrMhYNkOH1fm6h6ugMZMoEdrSlwL5deJz3RReqax +nl1TH/3wyGEn97t/7obH53SdpvG/op67Z1zkdvwyDUmol479jwf/R8PkXuO+k53/r5ePJ/jXk5S5 +UOlmp/R8xjONWtL+oXU6atefoVx/qbfLp68/7ZdP++XTfvkfZr9MBSSE3zoKLHCft0XbCRd0gj9y +CtTF/fJrMfF++XW7bgoAWper7eKK7899L8+XN/OcRlMIv55Sz55Sz55Sz55Sz55Sz55Sz55Sz55S +z55Sz56STJ7yjZ6mwtNUeJoKX5R6hnvuZyV1BbSJ21dkhQmCT80w0sOI5XbGY19fkPymH/1KI71d +NtKbM9Kdx45UZFWPSbcwwzq5mhHdqFZNmMtFiP5rZhFpvWpQe12Xtdwxpeh+KA/hi7C4oojTp1fi +/Y+rXXKeUpSfbCbBz41z9UPXgOzL+X+0Rv/0SC3+T4lB7IMKIA96OsY2KWOXnMHXNnzM0/qZQnp6 +xNf6xSJ6eiwXaS+iOSPoQ8U5omX/nKXjHyjPwUyYhrP+J8v02RfnSEOdy3tL7emJPatyqFpOzwdr +XT4ifoEzNdSLYlRyQ0DSLXjildJGQqntw0m6X4lw9LnWOgf2465pdOjaSedMR7LNT/oRj+tXIvw6 +UV4u+1sBjJdLPvlbn/ytT/7WJ3/rk7/1yd/65G998rc++VufPCtPTranqfA0FZ6mwtf5W+3WjXUz +jDqIOISXbkl49JDRNNyKMN6EOZ40Gm/C9Ne4DUeNpotnjbIrWxhcuVB/J4dWL9Q7OaRE6OSq7/up +MpYwTL6E4TBjdM7YjJkenTJ8EI1ni86VD80UmSeTTJQ+TTjxb7yGrs+P7ewY5wbMjAknBs0KnRN9 +RlAOLTvpGqxmnARRkh9xDeMKLjDcAYZYS+e33bkx8zA5/9JxkjU8XqZSLhZ7HQu9Hi7fqDLJMn/s +9oT9KA73JrhbVLgu62F67FLbzbW2Oq6XDhkO0mB6VBzgMH9cHBwsyVPkwfQRgeBFghcKo1gQwYAz +YLogGJxokKkgohvXfKShP9OyxoHHIacLEy7ct+jLig7jPF0c5r5Ix4tz+ig/ekvGZEPtL85xi9Zd +X7wtPcrj3YuP0phPG9m/vSJjvCQjDLeNHHdbAYz+5Ib/U/YDtyO4uzDcPRjTJsv3ws4w7A3j7uD2 +B54IeHjiTk5dfGgqgMqACsMBBqGSohBISbiD0V9hhWRQDGZQCu5AaK9Ofpxh+zjQFIrwljNNngUk +RcQd/gRzZQX+JrpW4w6mwQIDn4AMvELjAENUYCQD3ZhxgPEqwJBgZxIaDEiBgQh0JcZxotswCqy3 +AMzmdYaiFBkcgLnIWGSrSlBkpl7jyRzsspN4Nxnr+D7PgWmOZ21zeGF/YEHOKPwZ2OXqXuh+pg85 +HPPGv9S9S4NrafpER+MH3IyjX3r6sgslLvqnybM4feA6iUcuk/jwpaLTB24VHS+RcPeKfuha0Uku +jhCXMfkHvdN4UbexHPq4p8MekY55FDresdIVH0e60ON8vp/oWk6+irPQFZwr+s7Re423i4h74Wkq +PE2Fp6nwNBX8VPii8lFtvg1z+7IsGvnol5WRqvNtTq1+RdqQYvjMvKEvKpf1tQHmerm2QV0/VI9o +HwfeXCtDfvEPLK3pI2vLr67tHU5+gVlkeHIhmssViS7eULaJ4B1t5Z0nDQy7cMwYF95HhcfKRJuY +8GTBvH4TzWoxYT0cfPexcE0YftPiRmOZI/5f7P+b5NdkPzVukkg9rVzzSBTWSvfocjyFf1ulDFKl +c7l0j+5hUxNpWxXpbHWRpB4SVUbSqkj8s5dDypNUQ1roGpWD1ELSECRXQ5K4NF0MrvWQklRESlIM +Ca0e1N0PE8VyDlQH6UjGEYcnZ6mDlOmmpKdKSFeohDTYp5/soBD3xOUySl9wa6yro3M39YpKllu1 +vTN2f2PsvCusZKWVps1dsf2mWF9eafB9bkosjUWWDtOuztJYaemy/1Mudx3KLYkjbXJeUFdzaetR +u1SD6WN1mB6rxVR8sYEhC/BDNZlcVabLdZlgJkwXijP1q4ou12fqFZou1GiahjJNvlDTpQuMgq8U +ceEaI3imCyWb/G1GMvf+IxVwAqkxrwtVW1piXi8iC5x8N9/WKClva8ltjo/k0F0P5dcpOWu9qOQA ++JMvzOCSD2qjXLJQKCHmscQbzUtQ4+eSCTQYQY8hqmZJMbptQheiGuypXXWGj8X5Phrl+9SA4UdD +ho8h+ljscYdqXGaws/GFMmEGZYCuC5rnurRhVVCiEOWVyqTjK2Yuz+OrYfz3Xth2tw== + + + RuLF/NOYhoXzsdzKi6U9H0uthDGeBi161KPHixzHhMptSqUlVE7D/b/VruBbh+opoz0M1jDXyNnn +fy2bxNOtgbE1MQYjY9pmfTkeeV59crLg5LIF68Cdg3gCOHsoj+mC1DmXLNnLvY4pkydLmXwsaXKR +C1EPGH3p2XDbfLjLiZOj4bVjyTSk5C6H7fXQmCYVqPNVuoyTgDvnMpu3N6RqSjPfjhoppWuhMy4n +Od/Cp1sweflMVXhyrRN0V060gGmU6CxLAz6diTMZeLHSuZV76CyZ7dCpE3QkAvUL0HykjD1M11uJ +zvuJkjgrsIsTOENP4ISJfDrdg2xLIOcWYMoRJCDenRzvM4/cZ2n3H1fupw9q9xvd/lNU++lj2QiX +kxGoc9ftGuYcP961C6bLx7s3fTzZ4lL3eOQ+0zL7WAenz7XMPta96VNySfbd2zj68I24QYKq0mqm +ejpLi1xEp0Sq9qOa6RyhW7SZbi7LGwt1XwsjX2jXUiAkoFaBnMBDHAV2d9rbSde6IScelxTNiA0b +A39DWi7uzNdC+HXb9UVv3rZQ6ajnrjs9N1FxM9Qe9774ber3Oc2TeeEvVS1/1Efoip45/6DXe73u +62MIPo7gFWl/rKHrwDB1JxdacF0auuWz2n2cwccaKN7gPXRB0pCTOdEWsRza7PPspQSh1AUPUhc8 +W+yjTqKuL1YD/OjS78/O4xXpOxvFxdHcaDkfP1vl/5zUvmW6ZmKfNwE8jZ5KT6en1NPqqb33pwr9 +uUJH9UC3p9zTTtR3CpWLI40bKjd0Hi+cBaSrk/dHAY+Wcbeam8qOAW6u6O40A9VfeUr6q62L+TaB +KsT2UauwCPCX2spY5K3iabmVpDZa9xjRoHJll4X91TB+lThN8ZI4BehX3rN5dnJnd6hqckHNRSpH ++oCmiNOvPe112B3wCajXPHbAZwi3fsrxoi0FPtRbN+fNiIJpJ+CUBqWCzyZeT7hdqPT4icLt3zJn ++lPe/dlvny4Jyf37N/5MNB25PjsMGq1WMOvCWEVRr2xe9C7cD67766H8wuAvXnpc4tcEfwXD1wme +i26XNFZZ/KREX0rz/aQs309KFn3EaruQHvgpCYe7zLnH0PnQ3KckJ1Bqwiclqfx7Rud9migJM7nL +S6ObvJGDcTg0L37z/S/+BqN2u4bhWvOrY/7MhTd/6Oz953z6qxZcvhghyBcCBPrVK09HS+7kNM/i +XPVVEkE5IXSh+Pmq5kGPovf65hI63BQtv7fYOW+lQe4WChRFV89/msjwSbLIqiy3arF1vm1oldi6 +2hgcYb+jxcq7scbaz5OG77if/LIYpWgwfyU5Ic5PIUnEgXi+mYjvJuJ9fJ3EVpH/0k+9tqjRxUV6 +gRFv+GyB3ckZ4/En/W2yJif3b3/OF5578n4MgUocN6/VpEGXOw26nJrGJ6v7naTLq/SB1SVSlqaP +mMV6kdeJPI+PlE9wuWh5snSZbSJaIp+kpsls6+ukx+rrTJaAVi5W2GFn9IXss0dyzw6TuOLv5Shy +1OQzyT27kxrl3df+keyzaSdDNQFNJanKUpWmLE9Zoh7IZLsjuXryY6y6a7bzw6sF1pqls5wscSUM +enSxfJU2yWIyVVbWiir5mpyit3QdnFZ9lqwUf2y+aL7VSq47nTjdCPhwXqP6VnQqwfd0IQlrm+E4 +5mBta3LoxJLcq4lSr3puI88rdP2fyf8daULhdDrQVOKJFGUi8b0JJ4pfRJo+yyTO+37SGatd6Enn +Kuec70kqoU+cjznfoz8cRrvBCJ+04Pyfz4n3f3WE4ZGHJvAku5u6uNTRlXf727ivXdrQ7vRSjnE/ +C24P8/FrXmB+81rFZGSz8aBG0P3mKoHxZgCf2zJmtYzZLFLQahoyWIa8lU2+ir9BbExPGdJSpiEf +ZbwtbEw/GdJOhnSTIctkGtNLKLWJPUZjghMbcprmpIlOSTbF0NOdJsl4upeEm5PLe2I3k14sx8lP +7HIaU6D0GCglQk1DLpTmQwWdBTIyZ5cXdZK39MOhckD06WDyn//B5Kvlklx2Zoyj/MXjPLl8zq8f +aRjr6dMqyn1grDejPX1R7PAD4z19cvTwoyO+sWTXZQ4YDGsNNpNI12rATpBWcu2IQ2eWHJqAEb1H +s3K+FtN/uGycy4U9sa6nWanOU2K7vG7hvVBOdaruwezNM11tNNtezDuxJWZPm5xsycYmFUGzsDNZ +Qnol7UK3Ia1i2x3MPBMjbLJs7ESaL+m+NNdY9eVaYgcK0p/IcjqTij+T/YQKMKrAmW7IqViUZ6Ik +DtSFDzS/T1JljE8kYP+jPJmq9qBSjGoxKsYrrRYuL6XqMd2bPJOWzJWmuM4UnlgodPSXC035UlN3 +XI3M6pEFOcPAaTZlokybdciz4UwbXPb7PBvKtBkN02Sudh47NU4DjdmHT1KVXuVouniGaqXEmMOl +gMP29JSc8UjCyWUye/UOWecsC29b3D1ydkoPTg13TGfKqhmt1pPdLa1mK7LyI2VhOXdqGs5NectV +b2c7DaemImV2V8rQ2SeJgek6DZbrKhdpXXb/sfH68euyPu3irEev05o+cqfWxTu2PvTs79/60L1b +n3Ab13ShdO2nFLN99JkerXb7sWe5/EyP/eGRarn0jBaJslZ7r/QpCrU61NwIFjtWM8MS4T/zaunH +L5dGW2H6lMulP/166bsyXbhe+goXTH/hFdNy2MEXELmfLhSX8OUltgUmqMTEk+3x52R7PJIhUYAD +CQMdDUNkY2nfmhdKOyiqSGKp37w8oopeD+V/OJ20XoycAPRirXlSaHhDP5i78PIhaMkHvrCZqwf6 +RKnin3gEWu/MXIbN3Od80ynoyTmiuyuaNnTZ0oO7DbOIV1q2dvNM8+HoMwrziX1dnPrZq892t7wm +U2tuOXNnPMB6tIzqe3+QleseZVrTlVZ3o3V+oBV/t8kuT5SJjNKhUj7y5vZalLcTJVOLS1ZSqtkv +eydZ9Z2VC+lFB65IKZ5a9tWit/bIt4hO7LD939sly5vJxyrsf/iu3/0FvheO23248v6Fo3j+mR7V +Kx/7Oj3yiC9RTvFR7z/nbOun7DuflyL+CbvOdL38aTnYKjWDaN2vdLiiV5aKF6qJ3bnSUot0Z19a +iro1kZGFPeM9lftnFaaoj9zLXmNse60sd1culp2wz5uKU/5uWe79UHdKeHCWqOvmetmJA8GPbrxY +cgnTn1te1nZ5l8RC/5iOkLny/wf3uq9EOG66DXpJmYYrnlqRRAjesZvu3HizKiVN8BUAH9EKvhbj +V23Qy6X9efnaFMan+wOe7g94uj/g6f6Ap/sDnu4P+GLF+H8twqf7A57uD3hyij0VjX+aCk9T4Wkq +/Ovf1/rpRQzHc96f9bH/cP7ydvFMYducKTwbo49WZO8g2ZXrprx0td8ulZqmf6chu/NLdawLmmCU +o8/oMiCHgRRKQiOA1STNkWcFqVEWyIk0fVKPJjnhyK4BtPSK1OLgrPizOya+UJLG0TKXLW+ZKDPV +NVmVF1/dRb39mnk+SxBfPf+ahc7u/wWPArJdfKD46Z2E9c8S2p8tFtCjARror5L2+fFg/0eC+R+L +2+9j858So9+E2ll+f6GcviCmSUhPX18z8cCmx6ZS/ujELCb/VAKqDLwb/JfVBGGaBvflaZfGpjJR +peL2EgWSjY/4NWEGr4XORIXQylCYrfERRbsjFP5EoI+5Dr8aJQvIUufx7lL4QGzVCzk8yYUl4uAX +rEkR62Vx+bWYvk54Xqxv0cb6FlYQVAUOuxju9UiO8zV5P9N4oGJTJnrrYbpUInp0Sz5SIhp9BZP5 +lLa+SfMkjXLjQqmobUVaDucdLtSiDRIe7fWz6mTloQ7OjzjGSrM7tcMR0wNlgVjUVKQoyc+J0kgK +xf44FapZMpTET8cefZWEuXQo+oKM+QQJ87gaOH1cD9T7no+bxP+xZOm2aOmlRJ3zNsN/LFy6bvL6 +85C0s03b2ZQvnVwOf7u7WMCUY1RHmpV6jVGPVm3jVazGPn4ZisSsJg1aDTei9DtRWMHdxq0uRa5Y +4ZU6Ryj3veRn3VeiV5tM4zSHIRQESkkcj5Jr9KVpEcq8RhAPFyXfddBx8SFU0AZZvi5hky4CHQRx +fuNOuUcMXD22YVwP5YcENAC+/fXbN7959+rN+1dvfnj2zMlt/4fp1z/iXxL/5Tcv3r9/+e4NCPRv +/t+fX7x7+dPN4c0Pr19+D7J8A7gJ4TbnZZV/002ttxjRk38TdPVn7K7ZAv/wJ/rv/wO//ncA/stN +vvmbm3/8b/PN9wT/h9/CP1ucDw4meG+eA2zzrgGmn31+AR/C3tDr/paGAiwn0C8oB31ZiM15XmHH +we1wqbQtzjwvsIKrVKxKnAv0Dy/wBfBSrOtabsHQzEyvgPhfeiX9tV2AyMee7zEh6J/gO65YwBK2 +zBVUhmWhNygstdvQ1jh8/BJMP/v8Aj59D30OOFWgoyBF6T0Kq+E2NbDz/OcvwfSzzy/g0/coTfp5 +z7El3ua2BGFQm+d2CeTfvMWmb6GP1eqHRUFuEPhTFyBuDDaY9AXUrSXrZx8cyHNWuXAJ5mfDiE1f +QtTALNExfXAw/kgbPn4J5ufDFt/Arc2YKMwPgH7+EsyPwBafvgcEXYRtAZdZmRfYrjGGnkCwsazO +SC9WD5IsACm4BtKbf6EFN9/8lquPRFieXEhuyWMJhC5WUelmhRz2RTp+suJqvvmHA9c8vvkXP1P7 +XLk0bJcW04U1u8GGoD+w1F8KF6bt5NUYhipJmcvQoheFyIResrlAPd/Or4dHRn5YjRuYJ/7SfGVS +YZcPVPsuJgx/XOStbEfOogHpCPQzrcMsFWlyafYoty7BvOTY4uu0LqDsJ9ofl8BTC9qVSoxuGOdE +ga0JG4VNHKqkgbvqIMLdUr4kTLHQ1UbmCsit2guy/w9XmvhbYezn6QJDmIUtJkwvwPyCvCTcrzr8 +tImC7OyDP4jaC2JQQfK55ztM1xz2zX7gtwg/xpfk6AVxfWF3YUJzBityrIWWy9pG7VRLYK7KVcl7 +YkJxIB0FDw7G6yLvJfEG5qnf4lNat1qF1zQ8TlFdLoA8xks6Cr7l99OZ1U3QT0XZ/CJ9deW/HN/9 +/NMfFY+5G+L8y2m+OcD3P/zL9DM8gxZ6WQclDfRZji3flhu0VbDyZwAuPAOVENPBYMw6+PkITvkW +LyYksGK4BOsffzOhDooTeQ409gseC8NJChbZSsJ/qWAm0IFI3L0QYgX4g85j97r1Fs0yIhiEDdgz +JeMbw+0c4TMAXJZbsP2EjARLHmC13C7zvDjSvsPPlwj0wAQkMDYMK3y4Nd/wT9AQrBbACWT3hnPb +Nvxn5FVbAGPM/uVzo525DlR6pkqP7qahbaowfxMjMKTI7AZq+kCAjsB3I6UALhU6N/RK2/5p7H5v +61ilbbFjjqudBsf/Tu12oO6mf5p+P7WbX/zy5h/+Hn6jSQ2rYJjSH5vpBL0B8E0cpg== + + + /CdPeGBJvV1X0EzWGDKW56U5v85LQTHRHPj5BgxTdSkrgT2SR8CG5Fozn7DXChIUsEfYCEomykNd +GAKzCgaOmuU1ZAYW2FFvRsqg5bouOM0YnLh7iBLMdAaiGc5AvFL05uLLcUCRQxV28kVa5xyy8HO5 +RWc1gtNtnGGHQuDKk5LbwmQhYLvF49IMbAHWApKGC2NGnwCDSwzaNmV5WZnjDTcMuG8TrM5AOH8e +BPY8r0xAoIkKQPg11MhtV2bYDLO3QAPlTV4FAUzqlIXYWGvlGQFgoHYZuDOvME3iKuwtS0wCTCEo +sZg6y3gRnJRhqRVpG+MsWPNcFUFcq/IclVtDUBYb4BKlLWy8SRGsCgSTXylYs3we1ii6AbgpmgwC +7EyAOS/AgG4BJmCeoyFIUbkIStcinMF5U5twfG6ZUCy3Oc4yw0DUMMdhT07asaUU7RiAses8ki0p +gpaLAnMuCmxKWO/YCmqRzvy2ROpDQ1dGlXkEopaQNpgcUScHCCz+PECjdAA+n5mHCExK1IITXz4v +kwuIqqt9HjOmdMoG/Xxt/Hl4VYxFgA0Zz8BlDYIg4oIXBMu60JxvOEg8MgkWeVoFuGZe+cDrNVZD +ADNShyA0kWINX5LkdTkKClwWS9LeMrcBmOci1CYYUsGbcF+Q1QwrruOt6yxUUNk9BmLmlzC8LgzM +txiv1w5XmUkIzln6FmDxCt4MHc1CbyxtFRQZx4RRlLQIsMIWIwhiMrR1fBujhVWK21RnGgOTiUCS +2QIEVVsIYGnHYNgMhNw5rFVIaLMOcCgyawp0rI9k1v5WkA46ECAbuC1qqKXpZJTeNpDiSbtQqg4E +7Pa56hSD3VjaLljGnTmOwl2A66JrrDoELamgWRMSAIor9HaVpliyU4Cgueubmqx9AodZ1n5badYg +EBiXdgjQWBJgmIshIBJ56awk/hAI6k7QeUDCPsyBZU7nNiMIOIo6YLyJEDDr0l1hq72xlkLBAhLJ +EKRkG04FMANrWRZlrAHJ38oUGAsAOkdbOGuUpsBNZVdQotasm+4aZBYB93iqM9a2ctvo5CSJRAbW +tiqzcTNSBAXo0rase8w4d2y3iSULAjAFq/A11eWGW4YQVfhhWPZOEeirMm2XBCpRJ8tisC67dVNC +cGpVV3IiEYPA1tcLy74ww+JOa3M0MYKMnmZdnIHVFgRGXS8Yr7n5r9IW7WDdaQQvLLmYbcKuAgOB +rOsNJQ2/q6AWpiuu2ucLMsPvPgjsO+hSw2II2px0zeMJGgSCihSjKTI5CDAti7wKdGb5PGyVSQmI +i7wLVKYWtyxcYDDX5EQhI1huU226YFDQM5BUdh6uuVYB5nnYvxRBjav0tuQmGiy+rhXVKNHglZeh +jSIaVjC8i2kswRYH4A06ZWW/D/NqWrSpRwgMMH9UPTLWriB3VNHEDGVpu8zZ5IOwFmztrFMu9uUN +WkBaddLVmqUtntBR1rCmjAiiamIYdhcEIDmz7Wp5jcIa0D3XRcG1KArVlVH41yTAZvtMRF+H4m1L +lsWYsHY8AMF+mKtOeyyHLECQhqvuq1F4G6iyUHGEMXDJyprCAxbQGbzq9hWW1T4Pi1g5s1T9fN/a +Q45K1ZJsA7WxCQGloK4bYP6NAGFvVwSzAuO6GLAWQ9CnuLhhGZyXsHR1jGH4X8dEBtaoQ55xs1a0 +ZQ5lHBpsu6hqAMOcBZhh+1FlKqyGoAaVE4V1CwS2FARYYUESEBVh3akwwUIQgEwHsaQIWKYjMIaq +ZPGeAkCwIVSdQz1eEeTchAWi5gbay1SdW7QL0Jus/F5R32QEyCXmQQZZy+uGuKyiviQWEwhMUV+V +dN0Q4UXAIKC5C9ntFaJSI7BklWlgu+oogIK26GZTVpbA2FbMuKTaIAGDrgS8ocoQkKLC3UXHtwDR +BmaswCMBglhWCkDAGoKWis4D1kdByzKlGtXVUgQYW87KWVVOAJxWXXjEegEmXSG1rIa16QqpWRRw +BMPvgoA6g8DqhDXZLQzsKg/sECJ8ECzKBVCwML8XdEAHHtqQDJiWqMCoHFjchikhGQbnpJKDtjEG +LlmNkMYiEWFVP79EQ7uayZiFeNi0VGqtLPbgs3PTCbSYugTgsKoSQHOBgaU1oX6uMt1xr9NlvJjc +RJpMxhrxQFGoiiDIglthDagmvaIRq9SHVaWGWP2EoGjvsyg3hMAmm6lGAK5BB8Xm4ArLt+oMUPGw +mn6eWLtVBGtUgbyg2v1cwYkXB3RiZqUv4La2eC4wcJYVk7smilCUNX0dMbCARSMTg20MBFLEiZHm +GgxBNgU3q9cLwbTNM3iRWdx4UMdhaE5Kryg0FC/xWVa98AY3UJva7GIg4JKtt7ZVNbbVqRMkcAEY +MRDTJ+e8CFBXnMwkQgBgtYlwcrMoiLD95KYyki0tBGZbccuiKloMzoZs7FBBIF6eqS9biOExssnS +ZSQjiHgpp1KQhNpojiJbcwgLOhPXKEYsfb7pllJb0HdFW3jochEgxbRkEFSgI7iqk2MNvMYiWgzJ +y24GkodNNipdeBE9BE13RVzaAgxZRzHxnEVg0pYNq/YrglRtW+V9PSZzOcLI1sI9yFTb3+0S/Hlg +ctLPq0IbcZ7ojkJDxMCG+768Kdjn8bSiaCFiJwAwRwWuVaiCXUZcbYg0J0OAOWROyjwXMFigunvw +VhthR0lJZ2xiV2rEXUJ9A/QRRosuQN1RmuxTAOy6DWmjDCxi7GYM9cnyiBUkWq4jASB+c5TJHdlR +hUA11/1GieBm3W2LIlhMh6liLAIQc+d0Euk2FVFUJ6ULfZuCtao0wYxSo0D1U+yQoyDYpGdHBGKd +F9U2xAhHYFBa8aSpIVhmnbPi9EAgVvEZ5Q52YVGttVTVuDARYFXlKmWhVuJ4LDyX0ASongyckKqO +I3hOtuyKIoAppRSIIwKAZCnLNEjKAxDfTXZVlhXPBZxF78zs1WBgXNUltoinHoGmTtPWqXizGRpF +NtfYeKBFQ2VNLja6ocbNOUKQ0Pdu+nTU8EZstl31lQdtu2eviFGRKJq+uqmkeDdtnyvYZjP5kxmY +mopP8XIjsMwaVSho2ynernnqxoA0VDUqFnF14avM4UhbsiKISZnTKF7HFNh+1cQ0IwpsQeb+eTw6 +O2quCa0w1bNV9U2zcymtZoCkAFJVHQrLyoo6AlO2rY3HHIFrUsWn6G5DYN0DmtjdAMwla1sJBSX0 +fedlOxkBDNuoX6eCtak7uIkigEDTDkiAGoIwt3GGEoLVdoBmZEUV1t0vB+DS1Ket4xVMIUdZzo4S +AC6z6X5o1ejnq20ibVmVgGq7MO2N8qakCrmp3qm769KtxnsIamoeyRkD9z3XiF1Nz3cs7G4Dmob6 +MiJxEKAJdmzbh8m0Y6B6BjO7ehgBelKySAm12wHYnQENZyQD1zZXndyqkyK49undmnSs+xHdTEQv +VTOrpAgsxyZ65hzVsURg3V5pyihaDbIBmLWGlLyOJnZRSuakQKVAicXfZ+0Yi9qEv+nGQMKRG8Zo +1oapgwkj1Cp32P+E8es4qG0MVBNElGf9eDMHhfG1mIs+swOdgZS2udGEECz6CTBLKQBg1PUd0BuH +wGo6feb4IiMAiysYtxs7B9PCSjsBszhtAahRMDQVVKMGsO5A6pvEllWdIYsycGFmiJBflQMrppnb +FsaaLwKr2rCZA14IjEE9GX1xrRwFHse6N8VOsTqc0NY0+2VRZRTAOa4y34HZ3Ndm6vQA7OZy15kw +NSctihftQWkbowCjjGvjyBePq8bAqKntlU0MRgCWJdjG0RTp0swV00V0Y+3e3vVcoG5mcAobgDMe +aOq6AYUtGahWc+ZVkDEpbFGsVVc3gldtqoIzY5aYSdPAezUCc/C7jCIotSle2VPzbKIka+gYJpNj +LAWGGQGGWcy4zWJa5sATdVgIOVBSmHKGJwe2FJ/FBq3q3hhTZPU9R5ud2fzxOZrPV/QzRoDRAVWv +1PDP2WJwmZ3RDHS9xZXCCAAsVg0SFpP0rKCvTUdM/EzQtpmMKAvLiIzBwaB4FwnNEYKqxmUS51NG +UyGrQFqiAkEgqIao3gCAkpNRVAtWaDNGQLJOcIkrAXBBy6v3QBGomioOOkEgXp3M5iADSasTwaM2 +M4JF03ZcrBavAwrYVgFY74DG7xFKzmrhd9OP0yiPHajmbhWPmCLoK5c2rOcC1vBkX6TYWfMVVdH0 +kdagrv/uucfXNQ3GSpaxvK5aeE5kGuLVGBBHk+njVWMtKzr+7x7/ONCaVA3LHGqhhrMZt7lTRfEc +7gFrG9RVk2diRGbJh2VgUK9WXmxPzep1h6bVpqZNt4oHRsyTkTr9zZyKVWfGYtk43bEHwJSU0r4p +EgGLGbcs/rHtnHR1iVWVFycLsqkwGY1T1W/TbAh0CmqkCNuFoEsz6Y7w2MfxCJi8Ki76fo0/ZT8C +YG5GFdKqdGfcv9bgaGVgDEoWuU4ZwWpBz2yBC8S6miARBx4icCwMHUFYmu6KEi0DYF1mEyT6eVBW +lIA+B1ZTgkAdkuANAvvqFmsoYx6fKt3R9nUAL+b2COJPys1CQui9V9Cqky2apZnJ2akSQ/I/EKo0 +6RJAS1c3eo2dATA5J2EzlJpjkTXzDIFNZnWRkCCCsgqWIDk8ocwdHf3XXGuZHf4MjFlnA42avrg1 +1TuqxG/di9XZlb0e0H0yw8dT0jeBQJSRUI8K0hR1NvfIAYKzSnoUB88F2rV0jX4UTM0o0is15BFo +7+pBGQQHzWlcxK+FwKxsEdFTZgvKo0zXxICCVrDaKavtlgWUhqxjpzIZ266612Rx2kJLmKEKRJtJ +8bZadV9oqjeVwIkGwkXeLvBlNqFV70G8ttsFc9UDGIStLsmZXUgFA5TW32qEUXql9EwVFAAvksqX +2a5iYA19wysCU/9AdtEKRGsGQMmuY90yUZ88vStttLyCpmU1YFO6olPTNOegSDao0BVvtGGSgaz+ +87FqvxZxyRdMYdStRS0rRGou3qwWDED7pNPgHCJtqiRS5ISBxYSCm+CY/6dTRv2TJTr1WVJKQ5FY +vOiutVPgbPaqgf2CaQJm3NasM9Sn2KnqViRxjPc8pVcytFb2JOr2gm0X9ZRHcQoBMFmGXuJ0RATm +ZBkHfYpjrp26HlqNigBvs5XRFYld0I9S1j6M/PlsPiE3YtmpOORtZaD61YYp013lmdVQBtaiAqGW +OQtQg2FoQavZjm1tyMgnKS8rusqbbHoFs+jUau1uEkJgkkpSTwqov4sOr63xzBGC1QwLRbCmoPtO +sO7W7uXlREAiK5vjwSK62LbmjZsA2wb1M6v/vIjY7EBGUJwzVRNaANjToxe2OxEW1C3W+iwA8Gza +WwrK75aquVPY8sY3FbWcUQTp53OwzzcOXhafyajhsYJavekNFq0AsKb/SDqWALNuYpJ2QjAVsz2W +h2iDbrTklH8u4FJVUtNJAgVramxmD5egkBgyz8FqsTVJtOc3VUvLxW1JMYJZMesGog== + + + dhVibGqHsopS0CpSzS9qziZ+XHmiOzi+Pjantci7V93+yGdpJEXVBjVFHykSx1fmXERB2szQWVvv +UzRngoltfNliThqOv5fK4UteAZpvjmB16GTNT0XgGnU/shVQ3VrpqSll4Y6Pu/Ji7nnZ7RlYF2Vq +Ne8ZgkPfeTgyVdB3ZDxcFeladfyiacll4fMpo4xfXPAki0cL+yrLAliwarYctVWXdxXXD7QFPd8c +qB1oAYYeEEHOlNkCDGsxdmn8R9RshK1NGjopBHStlgQu+UVI1ao+TTVVAKi7tJyb0B6oIthTvxBB +T2EQ9x8Cs6YwOCm0MOcYnGYdr54nptkqMDBdg6KkBEYA41User+KyFo5VVO2w1lHphWzCy1FCtrm +0JQwSfwFYLPooE1k0OuLMrbvZs1t02QBMdD57BfZS5rbdboHFMAaicycfMbAGGyLW4Mi6C6xYi4x +RLDqPNSQFLaVHK1uryKwmSsHRZIi6NHcIkkrSO3atqK8OS84CW2joKjvKlT9vHobe0oAAoOG+SnU +S5+vM0exV+/0KM3SRnsyKra0hRAtK6KiB7HYPOSNr3bLwVIQa7D8HIkV8ufRqaeTIEmEo0Zeq4NS +VfFoiWZKdD90jS4erQ1L0lUQ+qeXrPkus26lFf0slo8sDgf8fNVlqDZ4ldRyptN08+o1SBJQfO4r +OZ0qBRZwleau5SPz8q64Ji0WrZ47bLosmqatxzaosWUCzati7anLGqBGYNV+kZ9B0fbEqVlkdJWg +H5MlKhm2zJr9vTbVfSrqIZrjWyVAUVGl1rM3lJTOQA05S/o4I8h21kmofS7gnnlGR50RWDhtkduy +TQmwnE2FNmmI4KTnyMif9FzAfR6S48TAlpIsJ4AQuGbLoZdsJgDC6GrXsk1aTABUliVLqgMw6Ax6 +6Es8mwAsdhJMJCqSG/TQxqoHzAhtVOGp6bg1O6eaptgCEPR4RTCHjkAlNaZ2L2nDxn4WA0mVrITI +p1UUgebH4JEClohIgUSFMNtb2IUZL3rIjqxiHV9NuIzqqkECZAOK7FwWYA3WsLX+eTtNQsELmR1l +EQIi5qoxUOPu0fmPKrpFNLudVFaZjEFTyMn7oTNUzynaaTwCFwW7l/UzY3ocBRfDrMPtKMDNTF+m +eRUA1PNlkY9LiEyRIdCTStgwzDW7qcVAGEGhqUpyP8qIoGcxesYqtrUzgmTTCrDquqUsThFSElfD +liF1mRiTDrfswCjnsh0DyF1QFj03GM1jRvI3Rze0zwUcJZk3dpnogTa7A/tOGWg6E564l004dkk3 +W27+AKQtkoGm8iB40aVIpvZz3QMllzV08xM3Vj27oX5UAAYTHBSaU0XG8SFHU11F/Q8sYBlYmvKW +shhVGyxNj0tpgg9aH8EQtG5rL3VVWjUChZZmUfkXsYDTczNVdTUaXvHa8fCo8twzuCPneivevvI0 +tlay467sQoW0jyJ0mThAN8SsW4OG4dANIrEaTIUQDSuazhFYbzMXj2QCUaZlM1cMHU4msCSRoOtr +YYEQNAEDXXqSGig8VI9atJdpYgj6BGc9nkbhGQRigUiVk/3YArlGk+KVPFsAwmqXeaRZxeiwlRPZ +wSU+octXvD7BXFfovpZzaNAXcU2gnzwW5Va2oOViikdgO/MZx2VyqcrEZgE/cX9LYqsFB0V3Dayp +s6c9W8ZJ4BDqM46QStpQ4An8jOKuTQIIgawdDabOorkEdm5olFdN0WA5lpkoT8qEqGhB6Cpa851h +TLkoHyn0+oyiz33SqKaHcepZl0jugZHZMpfQn8obcZ7tKEDQUCRG5WsVfnWxTkkEUcCpSXpNMz0v +sIH8TBITovSVchA0X0HP1QSOWz4XMHVd+iuZLAhcBa/aBYi3KQU95oQ5E6LUBfYaPqOkjb5uqixc +zOSQQ2qhBzgAGhedYGpJpmpu3LmnMYCKJIdgA+eraioLrUxGKxEFAC5RCQjiIAdglYOOYA0sczIE +YVYEGiKkxJuWdHpJglA2wyBwEgQjyGabAFiMPpf4MyKYs80ulXOUY6SznoIAj2LF5C4dRcp6YwTR +DqXPJu1TdBuLzQ7MitN1Fy19tlnoNph+EFdWgYSHnFKL/gRdB6Y1xH5IJHBuxnMBZzl5PVsCQCzm +Lw5cHoGBOVdBYGo1piUnlVJ6ADH20gZ0nFZgNBr8/p4yn21zDly8gYEgIVSYiP8uUjq4zSGVswhu +ujiCJhAnS+sLvLsLcFkWXbXG156HHjg16hllt6sHt89NTLqXtAY5tc8IcN/TNUORPwaCfiJADQnH +6NZRsfQ3xFsU7xLYZx+DnWGSPE8G1qQbvuVARDzKthpU8odFAMg0FgKChW4xZKVyJ8524DT0syqN +jzswuyTBBs/VdKpsrwrVLftsx4L0IDIqa7zT4FGlqpOoaBEDPsGk4CobKwJj1B6InuuOQAXnpAh4 +jrZpW9k8AKhHBPEIBU8jAPYx6Gdb8byVBCNCP51ULfM39OM6mIeigpci3YygWFZX0PAmnuwqugNr +tncoVqQk3OoZe4JKJEHUBT5V04MGgaNuz+jUnVpAwXR9ckSoamGrPtAFvasKDdY78cyvBMZnVt6e +0flojQDO7iQWHjyXc1AA5kgAFRqQHMLZSpe0fpR55kMeiACrGjSpCRD0SCUBZ+VhjFmrKujh3sAn +rBVBnE3ESYGOYmeugiaycsOqElo1Z0IrTuNZ8lCp2EPTqSUmAQElo2zuBy+ojsXCm/2ssVksmqHZ +IbOm7GOFDj1FNfdEcQSrhjvrAQMCitPXlChCsJownY2CgOWglDA1Sgic2WCcOf6h4DjrOFiNDuBo +UXoXTnpEoEYP5q5QY0kUSnEjsKgxWBZmjVn3ZSk4gaVxJHdr7scs5jVaVCywqcq1ddQxNasrFuvw +UIxSeCubCtb8URdB0MwNrA4EM1eYs2h1oF5rSWQEIygWMTUL/ULVob+jckRYpyg650GMUiSpsqrC +7eeqTomW9QQ6yR9pmbQQRE+UQXANauZXq5QU1ygGoq7oPQVcKQnNyVYtMxqF6IOCi50YkQx18v9a +crKQhsCiiTFzD7I2xsZgcUs7/21P5EJg1WTCuado9PPq2RxRhdJRNGu8qZW86YF2bTUzAimjUsYC +XjQco0QAsOdHREkwxzhA1JyDNFvEfof3ubywOlaQZ/JBwIul8y5FQzJL0dQhOsH0TAJFsSpQdw4E +W3aqnsGimI6GrzTPbU/AnVGmRlnWaqAMVi3GsiDRD2DpvGkRE7RyNdmVk4vUl8uBKQ0zaBCzWo2X +TKfeLr5fCcNjrprQSyPwoOCghC2z5hjErBFTC+4ly2KkiKla/D2SaTkZctRj5dyerCkKm9crXT5d +pQhRqGUsGgSezeJvswFFacYkmtIzklWHQO+AJasUzVAKfKiCiVWTv5/yxwQpC/uPVMm0o7OD6mEm +Gfcg4NLsKAUqHHpMsJdWIA/B88tIBDu5MLUWBOlQDwJW0d7PcZJssWBWttoEYX8UFtFWDSzPolIG +f2hVw3l7AmSM5uLO1ZFi/qDgZrUj8KzCcwWv6rmj355fRvKcagJ+XSVABN/UL68GKNIfgwhUuC5S +gSsPfj6Aw9rYrfJcP7+HuI++IXqoAOCCBXGwdCvKRKzTHFdKxsVsQrwOBn9pc6AbS2AZr1TeNfF9 +JVwBcMaoOioaoUl+9YPodS1EAmPwlzTAWQ95zbOOOdaPTFw9D4v4oD3+nSgZaya7dV51raCOAIqr +lRWJoiJo7A108KpVsdZsob7APkwtlJeWJg422VWoTF1Wf5HUYSElhUUelkhB+at0zTPJlnnVzG9U +7OZAustcNIqM6ipYJyiasOARnij5jviCh1Iy8aXq4Q6s3EOJLwELs4nDay5y5ik0UJ6aVZLB3I22 +G2FQublUHrbWKCK0zei9IrxY+unm4nh9JysdTQhaklj3CbMzHgScVjJfFfx8Aw5sxAjNOJ8Ad2P7 +lvXjtaCMNiBxEivz4c1lQ1vQ11Kiid6xeqBQoEocaMjrhjAPnrlgmlTxa0oYiqMtXQjT8YGdM/uW +njOG8gK7pPgkviuuwnXyH9EabliPDNV82O27nYLOBQaK/isF2SjFLrSVZet3sqJAPSU2yBEgGXep +WTHbITCsGrVaYMtS22d0Zy3qlYxa6GbGIxpV1HE9e4JzlkaHpjTvoUgYEL4qb3QksT8Vd3yc0lrV +EksclpS5uxKmxRKJC2WYIWvIpcdTociiosnb13XC7QvnOQg5BbI3ChvC4BSzB7ggFrVFzxYv9oSh +wsZgSuqXQpVxlfUD4qbeXBwyXBM/T+Hm8KOM3ZwWmYFkDj5swJg+2OqNllFkwVHVb0p1ArlUhgKZ +c1ULtPm2eDCbrBuPtQOFAkagYByRRe1cxYqid6l5pMCAKs+Y2qGt9mvAuuMB8ugvvv3Lw7v3p1ff +vX/19s2Ld3+6+RWAfnH85c1ffvP+3as3P9z84ps/vvjx5fH1S6o1/ce/Pv3y5v/EJv/l0Sa/+9OP +L7nR/wXfuIf+OFE9WvSkojEMWhaVRgfllErVBooou2LjUYt5Z96jkHZQrBcWK2TJPmzAmrmChrek +cKFUZq8SMi9WFfAE1OGTxBHfFg8Vpjoi7TB5v44eg5HPaxCRoEhx9buSkkyAARlBNLHm2mqvBqw7 +DuDoUZmuStV94ZeZisiDQROpAHpIBdY48hV3e9YNaqS7JjMXSTfmSibdLDGnhw1YSphIMVHewefC +J/Gk4GZgvUCAyt05k8fMt8W0PfI3eawdKBQwAgUjIySftGNFltHZBE+BAZW9TO3QVvs1YN3xQNgb +8comrKsMKqxeJ8HX3YAwTMTVpPcMJUpAn1HvwCo/xl1QegUzVVx52IATqjTqNJJasViMUFxpVIQk +ddh34rMCdW8dWy6aueFRdqC8Xlmr4JnLr3mkyC5yI/v3G1BZy6QObXunHNYdA4S1M1avxqsFVrwn +iO5KKImuGAHTYyHVNdl1DngxAkKKU13ZP7XIvCliOHloZMOJ6QX7Vle1FlQl06c5oDI31jlt2uKy +JtvGY+1AJqCLFYbOHBDwSJFhLRpzmQADKnOZ2KFt75bDuuUA8xZMzhYWuioDNEz8BdZgS3TFCyj1 +ZA1g2DRkuighF77gC+2DzlowqwRxwgOrDxtw1CguFROuFJidpRYKd63yQVkFctcwW1vnvbVFIy6m +DdYOFAp0cBQ88wkbjxXXNNk/ngIDKnOZ2qFt75fDuuOBcBeThlDCpkbqFlpWDXM66D6KRPeSZX8B +WWW5a5zFexEZa8QEuYcNWMpiM61SahQnHScZkM4p1ooAlbN5SWHTtmgBP4+1A4UCm/YCntkF6bEi +t8psMokpMKBylqkd2vZ+Oaw7HghnA537w02spoWq14POsy7DDT88Td2VH4tdmyJbaiWHL1bqbbPu +Zh4sVZ/ISZ9XMfHSKoWPsb6UmiUEVPaKCe/b0sGtusHqgUSBIlDwzLc3OKSkqDXjLg== + + + E2BA5S4TO7Tt3epIdxxg5pZ1XejytVBCJOkwg3Y68jaKLFjQZUAXLNn1OSKXir6tWVl+Bw6aNY/A +hd19AJTqNWRpBJYUAlQDpPKZIt8W3cbzusHagUKBDY6BJbPDY50lyOwJYJiyVmntLX1fDeWOAcja +wBpuyZF1hf1VP53Bei1Rv1eLnTLG4JoV/9KC8VeheBBxVvrk1gIqaa1TV1zxAjPzTkwP31Luc/Ao +O5Dfrh/vUAlSeJx93vW3M0x5q3T6Gdq7aSi3fX/cPDlc0Tz5vXj2gnr24J/vpypXivx8NU/b4D/k +eC4o6iJ7yHR82IBzD93iOQvWuqtlv/aSjAokL0PPAHBtsWZeqhusDhi7TevBM6deeqyokWhamVFg +QEJg1A5te7861j0PSFJ9vcFIFQkzM0dyER824JkT/al6I9vPK0couWN5TqsDasc4qX9oW3HWN4fS +QeTd/OkOzpxD6lGijYSa4/B6A+rIMqm+retRx7rv/bWMRc5lmaVzFJJ82IBxowlaWhNwyEZGx625 +c/DS5oDK27qWsGlb9aC8w+qAQoGyV8G92pphRZbpaVmjwIDMXqXWt3X96lj3PLiSsUg5OcV8NBaB +dGC6LU65m5dFOAY6mk6dkJMHKndR6dq0xbhmKyNWBxQKlLsK7lU7DSsZoVLqySgwoHKXqfVtXb9c +LdAdD65lLyIRjSvqkRNF526HznyEhIHd4bzEotzloqoGVO62pHPX2i56OMFhdUAmQD+vUFeVXJHy +wubcACPAgMpc9Xn1tq5bHeuOA1eyFzlDLKgmjHUJHzbgWf3jXPRXDbO2yFJd5TIpAzJvViwfFTZt +8ZxoChusHSgUKHMVHK3gomElL5QkOBkFBmQESq1v6/rVse55cAV7kd6/rDJkS9I0CAeeOSWXgSko +kLZP7hc77Q2onA0iG13bBSdw2GDtQKFAOatgLBs4a61qxZrs6IujQIDKWaXWte39clh3PLiWvUjy +ivPX0D2FyfsPG/DMiSzcj5Z03mU5LYrVuaNOcQIqe1OY923nsoQdVgUKBTbzBQy7jBwPdljxwE7c +UiBARaDUura9Xw7rjgdXshiRBkliQCMOC4w87MB6nQYC86LmR+8bbJSLA2rfctLhcW17SNNh7UCi +wIbHwJZ52bFGK0/nKBCgIlBqh7a9Xw7rhgdXNRppp+ADqLNk/z/swK6+fDDfBI6tsKKqob3Ma++f +iEjfcokx7lB2IL1eP9/Beq7CIR3mv75fgCafzF9ibX2nDOuOAd9xDsj/gtjWh0xHNmT+VazHuFgc +xluPDpw5ueAZF4rms1I9ykUlh1vyYTJiOtaF5Qwl3zbrDS0OqwN669GBZ8vdMqwUd5ZrmIwCA7Iu +o9T6tq5fs68ivuGBKIpfZTjSDUSaLYEb4MMGjMf8q5blllMQFII3xnYO5uoYK9WifNvE0f0BqwMK +BYygg2dNqTOkyCvN3zMCDKh8ZWJ9W9ctQ7rnwPWMR0wfqOLnp2IoDxtwIs8Pk9u4StBc7NgHFs8u +qwcya9BpuORN26iZwx2pg8n7dWwUbLnPHSk5syXZzwgwoPKWifVtXa861j0HrmY6rlqpn66CU9um +Q3H+ZK7f3zjtlaad1c+e9WyaApW3cmOfb4vp0cpbxeqAsafjOKg71KRIyWDSctBKgAGZt0qsb+u6 +1bHuOHA9u3GVnBPEPJfQmavg1E8WNT6kymt6NebKGUEFKnPlLLBvG/RUi8PqgEKBIlDw7Au0K9bZ +zkM7CgSo3FVqe1vXr451z4OrmY54EU7W1AbM7H3YgPGeQHEpNTxOKSaDZtrRzQIDkJlD227atKXz +q+uI1QGFApv7szKnNX2XIp05cjUSMPeAmie2t3XdMqR7DlzDcESpxFXDZzkx9LABR3+Rg1yOOic7 +uIxXM7QYHFD5KicCXVu8l2BVvipWBxQKFEEHW93yjhXjLZy45ygQoDJWqXVtfXcV654HVzMccen0 +oNU862bWwVGvmaXLM/hQyCyXhj6T85rqJyagckduC3FtceOpyl7F6oBCgSLoYM3sdFgxGzXmDQUC +VPYqtUPb3l3FuufBtQxHum4kypIoNnc9VM/jApATM4myVFQMy9WrCtSuLZLaMbSVek8j1g4sa2dN +h0qBAIcTD+saUN8vQP280jq07b1aL8CKzdsrmItIbmlqjlbTFDxYT9BgL/iA0jjoJc9+JtisiXPe +tZWr40asHTiuagNrxaYB69LijgCE6cc7rb1l75RDuWEAm4sfM+b+New4OqSv86HbcQ7cy75jUX+u +94b5wXIkK9ONYs0BiRkZS0YtbdOWDqiUEasDejvOgbuGZVg5wSO1gQIDshRSan1b1y+nDe54cAU7 +DpCui7pysIjQwwbab6zACxAWDfzojRkZHRxrckDl6xxz27TFKgEhbrB2IBOgbFXorFe1GU7ScLW2 +tL7fgPx5pdW3db0ypLv+X82Iwysvgg5XwppaDxtwv2s0k8Yi81hrBtFtDXl1QO5a1OuLfdtkO5TD +mtzGSRTo2PTdjAp4eawUPxCHtlFgQGUuU+vbun51rHseXMuMw3tC+Jg5JWw1Y65CMbUzCW9jznqc +IEj9capvlBxQeavKlWuL9aQ0+qZIO4xfb9JEoMFqADmcs92D594vQOWs0trbuk51rLv+X82Iw1tV +mo4ZFXp92IATF+NgelPSiJze05illEsHKm8DVxP2bSOfuh2xdqBQoAgUHPqtLB3r3K8R6BQIULmr +1Pa2rl8d654H1zLisOJNKmqgqjI8QKkMLJObg0bqpdAtXfdSUodxx4Keh3Uto+XCOJQeaIqwg+Ih +fis5pDhnv4fp62e3hzlKe1vXp4511/1rGHAk7HUI6UzkwwbcT41TxSLNwZXsYOwWqISLAypb6VjK +tm3jQ/0eawcKBYqgg+1CkI51tsLgjgIBKmOVWtfWd9ew7nhwNQMOl03QgVzw+rCHDTiayooEc9Gg +OVqd2YzekTU6oHIn1ho2bYPprA5rGBTZ0vr4GNivfcE6c6GekQIBGnuF2qFt765h3fHgWgYc0sA1 +ayjtP/bJ68DzoldIScHFOdiN4plC+4sDat/aomF+a4uJrmqWGdYBaNbtANYClwPWtd+C1SlYLbI1 +UOva9n45rBseXM2Kw7JlTQcORqtP3g6mcqYCrBah6yO/iCYaxr2krvO+rVxAPWLtQKLAEBhYitAP +SNel7t6PMP10J9W1tD51jJvu/9vZcAWVuzVvbTgHTlxm8RlXDZT+FbtgsUQXoLOzgVQPsbRl07a4 +49aGtQO9DefAUirNY6XTZVKMyigwICNQaoe2vV8O644HV7Dh8EqcNYgPJffaJh2cLPaPN6zEnovW +9CIRqY+hQO5W0hJRvi1WqJ3zBmsHCgU6MgrWikMe6dzZ0gmY++F4T+zsWajd6kh3HLiaGVd6nDLy +6byHDTi5qpipVbEespbewAqt8+qAyls5zu/bZjkQ7ZF2WOyHBj049DsEOtLZKo05AgRovG27tr1X +DuuOA9cy4rC0Z21qxBTjrAITXyLM1OZqEWC7KgdGtXWYMlYq3buWWFI4blF2IL1c2arArls5lKgs +SemS/nYBKluVUNe2d8lh3XT+agZcoeJYooNRyb2HDThxmVMmVyo/zu5uBTy9EYIDKmelSJVvSzUa +2wZrBwoFikDBVgHUIcU8BytQqwQIUHmrxLq2vVsd6Y4D1zLf8IYrSzYjifSwA0sQvQRnMCfbP2D6 +ORj3C6tAa1xfWya91Nph9DAnJTs4WEF3h3Pm+ybH1wvQ+Npq3LQNLtvOsO66fw37jSoHW7bvOvc6 +RP1MXtF7O7DUXwo632Zla1hCdkDla+U6eL4tXT6QNlg7UChQznawFi5zWHu5VkfB3As+eGpdW99d +w7rjwdXst9L9iIHvVH3YgNE315QMtW2r3fE1ryF0mLI2W85kb7mEZYuwA+Xl+vkOpotTR6S9Uqd7 +vwCVs2pYW0vfT8O56/y1DDccWy5fiZjneTW2OvBida7ouB6Pbg52VVxTzd7O6NFUsiRTaxu5PvOI +dQDOmpE4gNVBPGCtpcUdBQQ03hq1rm3vl2Hd8eBqhlsJVjIkcHj3YQe2O++C2wPcyPeQNgG1cy1p +EqRvW9uyw9qBPe48gLXQ74DVZGV/f+uitlNq7XqPHL5N7z/Fbgv/eomUFX0tW9PNgEnr/dF9BKs4 +23kn6/ejMIj4UO1ett6ujpjq1kyr4liPK18H6HBgX8LmZQzjT3aqekul3SHc9PFah+wAb7VUB7qw ++WEDTpYyhqRyOUi0C3LTKyUqX4GsQO4W3rqnQQxrW7hM4oi1A4UCHQUF94C+wzrbBbSOAgEaY4Va +1za4U8qGdceDq1loFdeKDlyyIzUOjLcdyf0oES+H1ZIV2a78qMHK42T13la69DBs2ha9XMpj7UCh +QNmr4GDXWzmss15G6ghgmDJXae0te6ccyh0DrmWg4e0gVtstyjlrD8W7Pme9XUR9V/0CdLw3JTuQ +8jXPGvOxlniB+xI3ODswutXcoWG4YWZWc4zuePavF5CxdbVcXm3Zu+Rwbnt/NROtYkKyKqEklh92 +4CaBHLxNK3YxUfUiqVxTc0BlLRWvGNtm284dVg+0oh8eLLfujlhnK5LrKBCgclepdW17vxzWHQ+u +ZaThRTd2NIoSvx92YKOhh83tAqKEdSuiAwprNs2k5KlH50H0YpvwTb0qRWxkC+jq3VX9rQI0fgqF +rm3viUO46/U1bDO8CS5qIZu5qm02gN3eJXdrz3JFg/QrqBVn9SVpo24aKLK2eP9t2WL1QKJAmarg +rrI5rP0aCUeBAJWzSq1r2/vlsO54cDXbDDfQJWlG62qqQQfHfkcb3hzVRC3SHI8qV+F1oLIXBn3f +duVrQz3WDhQKFEEH+2uwBCt6ZnPcUCBAY2/dtfXdNaw7HlzLRCNhpK5iSjl42IBj39jxfOpizEk6 +daiuVQcqc2Bjb7u2pWm5IadaKDC4XIgBLOazQxo4p3EkQIDKXCXWtfW9VaQ7Dlz3TN0wypiS+bCD +Nrnmhm5gM+9VTrqLdO8CAZU/oa3Lrm2vz2JYPXBNnb8dSlVxR6TDlO7uBQIag82n5iZq75Zh3XLg +Q2fqrlmQ5UOm4O//l9VnAV0IVsC6PWHnwVZJZV6CxTyt5spcMUuV1TRXn2WuC96qu27aFlfFQ7E6 +oDMXPdgqqXSsruZKp2Coz9Kp9W1dvzrWPQ+uZDrOteIZNFXttT6LB3MxFezYmsJYnwU7xhH4oT4L +dqzEseWStIy0InQQV53Fg62OiiJ09Vb6q4faLJ3MoW3vTce57/nVCnlWvA9HrWGrzeLBVkVlrite +XJ+GeivYOez0pjYLsoGv5fZtl6hXVDqsDuhqs3iwVVHpWF29lU7BUJulUzu07f3qWPc8uFYhTxji +Eu14mdZm8WCrooL01lnL+kq9Fewb38I61GZBPsRlbLn4OJHidEBXmcWDrYaK4nS1Vg== + + + +tuHuiyd0qFt71PHue//1ep4Viz5rXkyWpfFQ62CCgLbumoCNNdamRe8gqQ2B1TOcg7l0DZKoXWP +1QF7XRYPtQoqHamrtdIJGOqydGJ9W9etjnXHgWvV8QTEy7yqHqFOJA+2Cio4RfgaIVdrBbvGFUaH +uizIhjluWgZXb09xLt5pZlVZPNjqpyhOV2elv32oydIp9W1dnzrOff+vUcMT3z+r4W81WTzYqqcg +cLHgpNRZwX5pRrWryYJgtU5cW7ziSCvoKVYHdDVZPNiqp3isZuZ7Cpw3wFPb27p+dax7Hlythifu +At1I05osHmwVIWiGZJ11UmcFgXpq2dVkQfCybFoGVwjZcAZfNFkrsniw1U7pOK3Gin+7q8fiKe1t +XZ86zn3/r1XBE0mzkrZWj2UES+UUBIIc96VXBLg2X6RF+1YtXd21rWtrO6wdaPVYRrBUTvFYrcaK +p8DVY/HUDm17vxzWDQ+uW8QTp8mqNVasHssIluIpSAvffECLaFaZtwSNXmg9Fupf3LbrZVcdwg60 +aiwjWOqmdJTDatJ3u1osnsxxlaz9ro9adsD/LWqxzBimsCXcLUUHtqopc52tDHm/caCsNiH97QR4 +u9ecy6Zt0buRHVYH9JaiA1vVlI7V1VfpFAy1WDq1vq3rV8e658HX538iUr7/g2JrWovFg61qCpLa +b3iQ+irYrc5Bq8Uy04VsWl/T2hbQdNWwV6wO6GqxeLCWTelIXX2VTsBQi6UT69u6bhnSPQeuZyyi +91K9C1aLxYO1bAqSG+Qss9VXmenGvRAdkFmz4Gratq0we5YRqYO5Wiwe3O+hNKSuvkonYKjF0on1 +bV2vOtY9B65mKgZ/1UpdjbUKtaopSO5cki+7wl2TC6J9LRZkg9Z5c21hPSeN6ihWB+y1WDzUTt92 +pK6+SidgqMXSifVtXbc61h0Hrmcr4o20GnexWiwebFVTZrxaMtexFgv2rRU9N2m1WJAPoC/lTdtF +b4z3WDvQ1WLxYKua4rFafRVPgavF4qntbV2/OtY9D65mLmI9jaIJg1qLxYOtagrSu8pZT6uvgkDQ +Aba1WLDLaiy4tgvetx03WDvQ1WLxYC2b4pFafRVPgKvF4ontbV23DOmeA1cxGGe8uljPtWgtFg+2 +qilI6pKKsFDqqyAwrKsvuqJ8rVm9P9Z2BaPZgpiKtQNdLZYRLFVTPFarr+IpcLVYPLW97dBdxbrn +wdUMRhxdq/1qtVg8uN8WCECYgOaAtWkLQxgdULnTpPa9a0te87TB2oGuFssITtHaKlaxKEcKBKjs +VWqHtr27hnXHg2sZjUjDbIaGzt0B2kpUmVBistLYSliO/UBCX5ApaKC8t4xJJ6ND2YHF5q2HxlB0 +iipOLYTg384w/bjS6Vv2DjmUY9+vlQhKxEa730LrsIzgqPtxwzMXY/Ed6kNq1QFtxhTN43Rtl2In +djvWDhxXtIGlaMqIlaurjARoHZaR1t6yd8qh3DDg3+wM31xmuWlztOEc2CqmzBl2mKamhtRWmfOC +9+96IDEjFzvP6NriVX6qxxnWDvQ2nAN37cqwutoqnYKhDkun1rd1/XKa4I4HV7Dh8ASb3JzX67B4 +qFVMIUpnDfJIbRXsVZED5K4Oy5wrSrG4aZvlQtABawf2OiweauvfcLraKv39Qx2WTqtv63rVhcq2 +/1cz4DLem550b9I6LB5sFVPmjAUqZ1FuJckdu1aT3SyndViQDT3CbW2L7U4Oa/GbptZh8WCrmNKx +utoqnYKhDkundmjb++Ww7nhwLRMu08WZGsmULH0P1ZIpSK1mqVptFezZkjTyY3VYkAuqWLm2xVVH +V6Qd1uuweKhVTPE4rbaKf7+rw+JpdW17pxzWbf+vZsAB5ryqimB1WDzYKqYgvUtWrVdqq2Df9AY4 +V4cF+dCSjo21xQtt9aiUYe1AV4fFg61iisdqtVU8Ba4Oi6fWte39clh3PLiWAQeYtdJOr8MyQqVo +CpJba9TbN2blbctqe2gdFoRSaGJoWS3nxaH0QFOCHdQqpnics9/D9PWz38M6pa5t75PDuu3+NYw3 +EvaaCWh1WDzYKqYgqWVRj4He0pixMq1WDrI6LLS3RPVZWFu8ENruQlSsHejqsIxgOX/rsVptFU+B +q8PiqXVtfXcN644HVzPecNlUTRq0OiwjGHq5Sj96MX5JG0ZgkBp4sacY0yoNGgu1tovTWQ3rMiiy +pfXxMbBYtg5pMPeiIyA4V6Qjdmjbu6VIdxy4lumGAxxV+lgVFg/GHIdFha1eO4X+0BQFGIuewYia +iEg9ni3NXtsuWPJv3WDtQFeFZQTT2Y4Ra+jbU6cgjFuZUju07d11WDc8uJoNh7StmuJrVVhGsNRL +QaCWZAx9d1itonkYd5LU2r5tL2flsHagVWEZwVwzZUS62pj392sVlpHU3rL3qWPcdP/fzoJLK575 +9NmSDxuw1UuZEy5irY4plVVASXehuX5De8qmOru2CVigB/sMawd6C86BrV5Kx+oqq3QKhiosndqh +be+Xw7rjwRUsuLRadX1XhcWDrV4KkrqU2bLJ2M0A3cqleSB3q+Dt6tu2eJG3liYzrB3oqrB4sBZM +8UjnzpZOgKvC4omdPQu1Wx3pjgNXM+JSj1C6KiwerAVTkNza7/bgyirYtZJbckDlbQ56h721xeM6 +GtpTpB3mqrB4sNVL8UitsoonwFVh8cS6tr1XDuuOA9cy4QBzDnpjr5rHDmglU4haCTpqbRXsWE1a +utSMDOCBXuLbW+Ll0xrdNJQdaFVYPLBrVg6lVVbxb3dVWDyhrm3vksO66fzVzLeEqbh6g4VVYfFg +q5eC5JaiUR+prIJd61cJWhUWZINeE+/aFozVLBusHeiqsHiwFkzxSK2yiifAVWHxxLq2vVsd6Y4D +1zLeAPPcb3nQKiwjWMLnQG03l5PtH6vdp2YX8AI0lLSOLQu+eBkxepiTkh1s9VI8Tqus4l/vqrB4 +Sl3b3iWHddf9a1hvuH3KxRWuCosHW70UojVofWi9Fhn61ebVl1tRvvbjvta2WMavw9qBrgrLCJZ6 +KR6rVVbxFLgqLJ5a19Z317DueHA16y11L6KrwjKCF0l9BmAqeqdY5aOJ1Lmm8YKqxxhJAual7NqC +ArNusHqglWLxYHQFLIqgWg6mWg2OgugsDEeta9v75bDueHAt+w2HOKtlacVYPBjLyKiwVWUcfaFJ +ye11+QiovFmbbbraFuRiMvNNkHaYK8Uygkuotv6b3T6+LmFDgACVt91ycG17Zw3rjgNXs96QiKxl +ra0UywiWs7IEDD1WxpFgAPaItpViIXDWs3e+7azWl8PagVaKZQRLJYERa6u797cubzul1q73yOHb +9P7fthTLHLu7xVtwDqxFVOaIWudQZgWWp52GtnIscwQlbRnKtsDObAmqHV2HecvNga2YikepNVf8 +u3t1Fk9kb+ldSoZy1/FrHbOLePlt1PxFrdDiwVZLBcnNTfOipOoK9UxO77sKLcgEPZPv2uJJf9X2 +DGsHugotHmy1VDxWq7riKXAVWjy1rm3vl8O648HVrLe4OG+zVWjxYKulQgRbLpoco8bO5aoFcKxC +CzIiL2oxW9uEGmbYYO1AV6HFg62ciseqdVc8Ab1Ci6e1t1ycu91Q7hhwLeMtLpsSKQ8bqFVTQWrV +r2V1V7BjXWpYjRbkQV30zKC1Tfu6Lx4Y3ZpO+3oqHqlVXvEEuCotnljXdtlXftlz4GomXMRUZT2F +blVaRrDUUyF6ewl+CQ7GbhO4Ki3Ih3XRCqfWNju1xLB6oFVp8WCrp+KxWuUVT4Gr0uKpdW17vxzW +HQ+uZcQB5tUOS1mVlhFsNPSgup61wp41nYz9XBaA+7ZlbbFYrqpxxq0OslItHmyVVTxOq8Hi3+/q +tXhaXdveJ4d11/9rWHGAFXSMbb2WEex2sljWsV4L9ksrqLl6LQiOy6ZeC005XDcjVg+0ei0e3PU6 +h9VqsHgKXL0WT61r2/vlsO54cDUrDnWVWf0cVq/Fg62yChEcNIFSc0Ggc2vWSymsXgvtL5ZA6drq +HfEOawe6ei0jWCsjOKxWg8VT4Oq1eGpdW99dw7rjwbWsOBJLliqp9Vo8OPZtvt4GiXVbDRbsW7MU +SqvXQmt11TumXNu8al0hr2isWlWo50wMYC6t4pFaDRZPgKvX4ol1bX1vFemOA9c9czeMstZrGaFS +WYVo7n4ursFC/TMXgNVroTll2qtrCwZA3WD1QAuTDlCprOKRDlPaeUGCsyH6uXA3UXu3DOuWA/8u +67W4Y3hfO+pb83HFW5DUiKO5+LABJ/YfILCiHqW1J+Q8UCuWEyhAHIKA55jCnIa2IaAObHokY/VA +oeBuYnDfOAj8fAO2mi8Bs+viKtFGuUZkJIyA/z9777ocuXGtiT4B36H+KMLesUEjLwASW79Eyvb4 +HNpyWPaMIk5MdFBstsQRLz1stm3tpz/r+1YmkACKJFDdJKvYJYXEwgLyvnLluidxIwRhEFPH0rcN +Egkkj9UuP00PzDq2ZsZOBGfQC2SmoSEytBpkeJVmwmsuFtwLKtwVB4KGGJoBMGPKFWjpC4Uq6top +0CBhHA2c4Bds3GXI10JZzrQOaerbOGh1kjctRqcMR4ssLTbmeIERWsuT9e2yIqlPRcA15k1yY3Sq +KgzYjxVHLJKLS3HhQbh6q6x2q5RfgXXFVElY1yhvBZ/SxJi49Y5jBfGCAoOTWRihE4JJgLFwpuwY +YumYqZMzFZWFGIKNHk4YmOscfGTo6W7FqlPmyhd1q0B7GGI+aqgTjN5dh8zRZUx3BvO02pllGaKe +DeuoxiUTEJ5gmIVquubHRAaMzZJtwfKy51dxbGpaAZgusvqtCWXsRVuqJCWTXjo1a3sMJ016MsOY +FpFTnmNDL9vOQVFXsrVdaKfLWFpgQAw8gY++XnAGwUPVjQYCqebSQrScbeJKylEd9yU8soOJi+bh +UZrQuayZmVAzBMjMC8MUFGeSGhjDM0nE96BIaUu21qccs62qNUPK+IOB6nVBwKPatl7npA/5lUkN +pTpr99kAgtVUEDrTpe4ETL9J+4tml+P1i3XCY6DtCPJX3/wpvPn99duj248ffhZyfnd+ew1gBeCb +v9xc/1Vo/p2Q/aJQ8NH5TxfX+YuDv7zHG1Pqq+//5x//cHEp1Rz8rvspp8zvfvjzyV9u3p7j5+D4 +uffF16vf/Pvq8lpeFdKt24sfP96df8BBIyfY7enoi7OfLy7f3p5f471d/e5P13f9O/zvLh5SvzFl ++ZUcZf+4vjgTcDrR8k//eXr5Ub/9+fzip5/vHv76+vSKH0tf0uf/uc1j+tfF27ufZw8pfv3sI5o/ +nn/PHsu/t3ocv84ex68vMI6bH//P+dnd0c3H67fStaObR2a9H9Y77n/59O7D7AEOyjz7UL/505tv +Lt//fPrGzB3jxduMN75nTPjmP2f0eFvI5N3H2x8/Cod/dj53FrTozCVO7TzzqOzcwQ== + + + XH+8+u7s7vSf5/OxNi/y7AO7vvn+7uLu7BHC3o/vA7/++8XlggEOyjw/JT0sq7mj+/H0w/kfbs// +70fB3/l0dVTq2UeILTd3hLfnHz5ezudM0udzKNA9XTcPdH099csOgfO/5+Tk4c4+MO/PvCAX13OX +4+b9+e3p3c3t7AXpC2w1ml1cP0Ix8xMO3z77aL6/+Xh7dv7H29P3P1+czR/WglG94K45vrl6f/Ph +4m7OpnmKDpAPe7Tt3317/m719V7a28Yx7aW97RzHXtrbNmnPf8nS3rvbUxFdLv9yc/HhVcl7sxd1 +L+9tn7w3W/+yF/dGQ9uLe3txby/u7cW9L0/c869Q3Fswpt0Q9wr7WgS+JSPZbpFP5KCj83+eX37/ +8+nbm3992bYvPWQoFj7ZEfPMQ/rx8uMj3MpnYDa3Vbj7cPf22/N/XpyiQwukn7zQi/EEfzz9+OHD +xen1kS7grvDSs9fm7Xyy+PYl6OL8gcw/qd6+xFG1hAJsOzW7effuw/nd0XPQtBfa9t9xhDu04S/B +HcNL8Ozm8ub2v/71s4oxM+nzr5fzVYnx6/0G+oSxfHh/fvbdx0f2w+5xBKacjXIyAR8vT29//+/3 +N9fn1/PHNi34/KNcOsjjm+sPd6cbDLIv+OyDnO3r8+Hj7bvTs/Pvz06X0JBBoV2STYqqLGdj+ZYL +z6ZcMJbtFp8Lu2Qs/z17LP/9gjzIX28uru9OopLsJfSR599HOnQSmYsd4odepzFhI83IttsUFjJD +e97uRSWjJUaSbSEGp7cXdz9fnd/NN1ntElGYzY/+Mp8S/PIShGD+QNz8gbgXGMhsRuSXR4acD8Rs +9UAe0dPlA/HbT5S3/9B8HkP8syux7v56evGYoPyFn527IysvVxPviqfIn89vfzrHTO4QE7R0c73G +tXi6DuxdhjZl+l6jy5B5dS5D1ewBbbnScwG6bbfK88sKEjm+ubk8uj0//+/ZVs3X6Bn19uLydL5d +d6eUGIezcwPcnr69+DgfddPnu6Gs3W4Bbf5A3s4fyNttHsiuiZh/vrl9//PN5c1Pv+6QaLInaztE +1l4NMZsflrPlxOzVhrHtJDErXo3v7YK4tS3f6cvCKbZ5q88eya7t9Z3zuH2tMfuzPf/2MfvTAb50 +zP5sbnM3Y/YXEPJtP5Jmr9TWH0nzJZwdO5J2MovCI64xGXlb5rGdXLW3Fru232fjFVGv2Vi29dRr +9kh2JQjnm9nmreOfT6+vzy+/P788P1uiT5sWfPZB/m22NXLTQU4Lvtg59O3Fh/eXp2fnV+fXd38+ +fb9Dh9HVqVQ12zC5C9JRuUr/riY/zeDn3FHz13wJI32+xZRy60+vZbkGt/n0mj2SXeO9jxHG/OdE +PnaF3i3ArG3fI7PVQFu/R2aPZFc4vPkByM+TeGVbdt+7Rf5B7y4uL5f4P12+wErPRt27m/mM080L +DOT08l+nvz7C5Aw24t3p7aKdqN8/Pzs4e0w/4m6u+YpW/fr5EW72eN4+5tWfWy8/bnVc3Lvbm6v5 +lIAfP38A02xS3o+ra/4v7P7MAY5KvUAQ0PX56eyIkbPTy7M/37ydP7y+wAsYoK5nn06nZ2cfrz4+ +7haVL1xW5NnHdntOFcXs4b19e3F38c8Fg+sKvJBIcnp9cXX6YqlhdzUPXRH2zjBbJtmdvRpnmPkj +2TXtx94ZZkvUvfMzmu29YdapEvY3Fm4HAdz6Q+nVuMPMH8muHUo76Q4zm//cDXeYBftk691hXhH1 +ejXuMPNHsivGkr07zN4dZlsOoy/AHcZ8Ke4wC2j+tp9er8YdZv5Ido333k13mAWYte175NW4w8wf +ya5weNvmDrPV9p/d8eZZsOWWEo8XWsNdzBq4wA9wvwpPtgpPl3NjBxbh6TrwQo3vftLGb/705lvm +7HmzTPM1iyHanSPq9eYtmq8G3JGsRa/64upFeXL2FO1hilbvKdprpGizl3VP0fYU7ZVQtN/fCuDL +ZtHOMQWvkZ7tObQ9Pfsy6dkXzaC9Wnq258/29OxLo2e5UefNMiv8KyNrswf/Bdnw9ttmzrZpvuRt +M3vw+23zhW+bL+u2oL9e/Pv88q+Xp7++WRbsuI0OO1W5qmZ7T+rM/22BA2VWYpco3+351c1j4eO7 +letlnyJlN1KkmPkD2oEcKSvztS1XppL/lyv572v5LX+/lher1+ayPZM47noClQ/vkUJl7hj3CVS+ +vAQqzzy0i+u35+8uri/mG5ZlMs5P775dQD6zElufIGZbeKhXeEHhj0suG99yT/0lY9kVX/29wmJ7 +ycFje3s37UobmmG2PXh+EaHbcqJ9dnP1/uaDsAfffXyEhO1yAF8c4w4RhNPbi7ufr87v5u+bXSIM +szWDv8ynBb+8BCmYP5BHfIbygbgXGMhsLecvjww5H4jZ6oE8YvfMB+Jf7PBcKCFs+9G5yXGzS0fo +q82K+FnO0N0xcWy0pjvjQLQPANybk3fPnLwsTeE2apX25uR1s7I3J+/NyXtz8uchLjAo2/LrRYRm +b0LeKhPy/g6O1d6EvDchP7dYtDch37y8KmVvQt6bkPcm5L1V8u3Fu3cf599msu2kYOFwdoUazE5P +9+Hj7Tthjr5fluZ/UGh7LXtxcY9vrkUsv56/bJNyzz7EX88vL2/+NXeclxc//Xwn74sz5MOdPcxx +se1dSN1Hy5B0UGavdNsr3fZKt0f342u651ZJ6Nc/3Z6fX38tHNj51yItX/x08/U/L24uz+++vj1/ ++/XN7en1T7O32q5o45YcB3uV3F4l9/xj26vk9iq55z7bwmyry+l/X1x9vHvkCsgc29L3z45s9ewx +nV/KwyKVT1bixfQ9315QADvBgfZSHjHfqjB4Eg/VHUL516R2+vD+/ExOq9vn8IV/dq57trImTsLv +//1emIMFCo1pwRcw6C8d5WK1zbTgNq/lDireRGR6dpXUXm+z19t87nHt9TZbrLeJWhrV20QlDtU3 +e73NXm+z19vs9TZ7vc1eb7PjepvLqNB4FS4UeyXU0yuhvo+i7Q5qoV5z/oxXFgK8gZJtrzd8HfG/ ++xwaL5LoYMtzaMwfyJbn0JifDGSfQ2MrHW+3//B8notNnl1Qufvr6cVjNpj92bk/O/f5pzYeyJaf +nfv8U9t2dm4kp237+bn0qNmVo3Ofd+rT5n5bjt3F67nPObWkAy/U+D7n1G7lnPr+59O3N/96ivuL +docSfeHZBXbFr3N2UrR9RP6zb6HZF2u+/XW+u9SvL4Bk8wfyyLmQD+TfW04Btp2a3bx79+H8Dlvi +9vztIjq9azLAdxzplyEAbL6qr1ES2JZVed33ie9Fs10WzYwrv5qLkj+fP+4TlqFl+vz51dp+/pj+ +dfF2gTte/PrZR1SYavaI5jNRL8FDLRnJfL72JdjaL1Kp8QRZtHeHu9orNXZCqVHvlRpbywqH16LU +mD+QvVJjB8TfvVJje4/dvVJjGyn5XqmxV2psq1LjCxPN7k4XOFq+RsHs3e3p2d3p5V9uLuZ7a2vh +mWucWtrahDTXH6++kyn454IcAnmRF4hA//7u4u7sEc1bLqrh679fXC4Y4KDM83tyHs7Os/Pj6Yfz +P9ye/9+P59dn88WeUalnH+DZ03mZPfdIlmm1tjjOef5InlDg2ZZT4fUlOyoPZ1+hcXcz/3C7eYGh +vNa8Ta8pzdGCI+zd7c3V/N3Dj59f0zX/mN2nLnpwePvURU90YO1TF30hqYueRGn094+3P368FOq2 +S3rEfe6VnQl/WyAn7Yied0l82F7Vul5F9Qr9xxaMaTf8x+aPZ7u9x+aPY+87tj0Gip4vefNIHoHX +baa4y/mzV2OkmO0Js7dRTAf40jaK8pUbKbDltkAlvhf39uLezol7S/bOXuDbC3zT4e4Fvr3Atxf4 +vmiBbzZ/+RoFvtfqlzY7o8Ne5Ns+kW/24u0lvtHQ9hLfXuLbS3x7iW9RB16BxFe9QolvwZh2Q+Ir +zGuR+ZaMZC/1bY/U979ubt7+dHs6/7x/jSLfq7xiYVGM+JaHSLzGjBezRbp9xotnJwj7NJ4PDWSf +8eITOYyUB+JV0OZ9/o6tJWPvLoW701u//+vHy9OzX75eKejm/enZxd2v/7VAsfjh7tfL+Tru+PXz +ezsvueF823fWosHs2mb6AxBxh/bS69SIfkqanm1XjC6jBVvOM3xgKsfj10TevhzGYRdvA3xNDPfS +O0G3fOMsHM6uKERme518+Hj77vTs/Puz0yUc6aDQ89suZgviurjHN9cf7k4fu7Uul8rH5Z59iP/6 +eUGk8CVsSPK+mHFKZ6McF9veddRttAxHB2V2SYFu3OzNe/rfF1cfF5jmuu+ffamJa68my1A9Oy3Z ++aU8LFI2ZyVejMf69oJ07ySasl/Ca0D6QBp8EonUntt7GVFp+S22u8Iizc8tmCbh9/9+f3N9voCP +mBbc3jM29XUxszQtuOd2d58V3PNLL88v7dmlPbs0tw/fRyq8g/zS67QGvEr/6A3YwT2Hu1eZb7As +p7cXdz9fnS/I675LxGH2gfjLfIrwy0sQhPkDeSTxTT4Qt81y0i+PfJkPxGz1ijzirpIPxL/AQJYa +mrb+8HyVntGXF3d/Pb14TF2wPzv3Z+fzU+otPzvnD2TLz875R87+7NxaoWb7z8+lR83+6HwFR+fu +6KH3tzRuIy/05ERjB9bi6TqwQ4jwWlMR7a/I291cRK8+++xGRpDt5tr+vjiH9a7xbTuZZOnqVKqa +nV5iJwj7qoz/rvvVQeYOmb/mE8b0+Q7sr22nGH+Uoh8e9zjaXYLBSKo/pw24KxTjFZ5Nzxr/ta3Z +F/YpPp59KxWz2dhtz/FRvJokH8+iiHrmMX33xUS57lx6jNfpxLc5wm2/OWUxW7rt1AH2BizV319x +AuRddEfYZF12CddmhzXuCqtt5l97vme2n307vUq6/cO789s/XNxug4pkW9b57vTH+Wu8CwpNu5pt +quLY/+cyjeWgzMul4vp4ffa3HaImrw7LDptVufoy8OyPezx7QTwzXwo5O3opFxMKO4ib//vt6fWH +dzNukdgefH+d+pANQxi2XRWyCQe6C1y1LteW8NV7fUhcGXrOfXN5uQVrsi1Tshmy7n01l3TghRpf +dP3TV9/8yZRvfn/9trsGCqAKkDd/ubn+q1TBNCWFgo/Of7q4zl8c/OU96/D66vtfr368uTz4zdHp +25/OV2ZVrP56cf3Lbw8+yr/l6ruD3qHmh1/l4f+RH/9HQP9a+dWfV//f/y5XbwX6w98OysOyLNuw +stVhU62uDgpzWHpTVxFQWHlfmXpl/WFVuQaA1tWtvHeHrq2b1dlB4Q6D8XZl7aErUcYf1t5KlebQ +NkGKVIe1M/JCAKXxHkWqw2CDl2/Kw7Y28k0tzVZVQ4Cr8GybOrTpWYo0hyZUre2+CIfWB89anXf1 +qmhRpDQANC6wZ6bERw26ZoyVZoz0qZIuCMC3rReADNC3TQdAIRlHE5rBN7XHkAXgKg== + + + S0BomlpH7AwLOZmu0rNxmU48t8Gx/640sj7GH1pMtAmHodIRCcib1qxMc1gZTIIAalfVK1MfGuvR +UIWuSCH8bVsWwjsZrn6LilHaEuBNQHfRQtWu2KIUlkLsha1W2isppN30ADQYfsGhWLvi0HTyBNS0 +FUGlbQy/sZUMW2a1tq1W4ppmxYlvOSSsuaxJc9i2VY1qS/lERlQf1g1xgzjg/Ao4YWufyjRNWBFt +XOpL41fAK1eiEHANCISVLx0LER9lCQQ/sdgF8NXLoIG+pemeS36sv4v+ZSxd9MVjE0XeRuxH0Xck +drXo+xrHQyQXdI+zzUEX+agxLUU/L3Hqinzu4vQW3fzGBSjyFeAqFfkyxaUs+rWMq110y51Qoshw +IuFN0SNORK2ixy3iXxt/tCFibe28iZ/7VAHmiVViMtgM5okN6zKzM9ak7oXY4dAkbKz6jaUDdTZu +R+6+It9+3KDFZBcX+TbmVq/yryI1KDpywNk3cT9EmkG6UnnClLAo5Qns+YA4FT11SvSr+yZRuKIj +cSSDddoDSgeBR8ZHxJJ1IarJ1MUZwKoAIX23C4KiiqCtZQeAyFwDaV9QWfG+WiWyHh/PDoj6bZsA +qMBjxlMFJOvcGl0rJOusMnYFnXWu6nuLEblmMCIZtuwU1w8bE9PwG50YzF0LFO7mDtMbXD+9sgBC +Dm1aAE/6EhKeuIBmsJSV6ZZSiBRWu0mrDZIpQ6yAZQkghWQcgbPdf1NXpo2o5Rulfm1I+IcypOt1 +j6NEY99vskTX4x5jO6TrfkCaa1ebfodhO4Wy21fAO91NLm0+txrtz0pPjsrkm1g7ETe6HrnSSZto +gdETCpuOI6txggypSsVvbBVMpDt6TnMzcHtUgYVAwOpEwUqeaw2XXmmcnu1Y956wE0uwKUksZWiK +RxHJnXHKQyQcrwwLER8jYW7r1ZB0N6uMrOcU30UGJWK2UGYl6F7PjMbrwB2IEluXgok/YfeEXA+O +Jnnm9DaujqeX5yCFjNc83nyjh70sHxG08kbbEDQMekSGlc611yO0blbTU3Z8EI9P6ulhPj7vxwxB +otk9yR6zFWO+Y8qajLmXEXejZLrJ+J8xizTmoaZs1pgTU+JcR1at1jltIy6iT6TLTRv5PfAYJtQd +wwiyErD8iaqQ7pjuPemStR3DSdJV5Txpom6JuCXyl6hfopA9gUxENNHQRGOHJFifjkec9snB0Y8H +ydP96GcRRH7zj2sIDW9XP92evr04F6nE+Pa3Uo2sjQn42wqeO/ncHfrGAQMyx3mzOvrpwFeHZS0k +CIAiPRTBVDI72NhBeidLLOh1dHXwTpo/OhJx4T8+om9NaYRClYchWCfzBIgsh9FhYJHlVSUvPXoi +NcpSlTjtG+nID6dxdI0yYhAkZJ6toKWLAHMYuBw4cBwFCsF3Y/XAsfJLZsgd1mXV6ulvajCE8Wip +pDGppA5Bz5GmsZhRmcjQGOUoGiNnbQ2CFvQkqYOv9bBx/fOxHDbWAc06UDh0pnV6BAtvCMRzMjht +WXC+lUKCm87yJJRhyEThtHElGHTsd9AgHDaufz7mWeNqn39R1ZUeNaYFeZcJAP4DUIaaZdxhZfXc +E66gVppQ6/hsWXMbtuQMsVPBcR1jbxvyQrKZ5QhTslDiTJPdXqL7Qgek7zXPGouFPD5Irwr92K+0 +sB4tBjubDdTKVMp+Qe/YCXC17FZFOYvdLNjvkpu/DOQyMTY0JBCer4YMS8svhKzrUVNb1lGVoPeY +9co6bacFoxKwgQN3tEdtOGlE3uOObhpUQpRwWFUiiVA0OWqEmJSURQWDKhw1glOex4FgGeXXxpfa +UMTEArhZ19yZHi0DdU1oqgQo8XH82b1iYbPqyqJ+nE8RrTl2U8uXXQ+IyGbVdZF4vMoGgYHKImTj +bIVeYB4E83WqvF9lM8XZJOmshbVcxdnmZPu2Ww6uhmt1mhJiVbKHVxlecUUTWvWLnmGV4gUxxyuW +yYFAnMIR0uMW37SrDv2IoFZRzNUdDrMtXynaE83ZG29WcRt0nUX3rV9l+wR7yRHfTFtzKzmnz2kz ++jas+r2I3Vp2AOxmU/MgIflIE9rvd9AEKh8iSQDRsC17KEilh42cNquerJDy6IFJCEiTIPgqUSas +MqhMT7xA3BJtS4Qv0r2EQz1lTNQzoWxHXElbO9rLp+ODAQJXit9dafKy0oCV9VWkRQPFoAtN3Ei6 +ydlFbraokIkjKDBIr0cwBwkhyLq2n5coKNXZRBWcS2/7b8aTraSgsdl6FOMlK0ZLWkzWvBghRTFG +mmKKV8UI84oxZhZT5C3G+F2MN4DSXWuyPVKMt1Ex3mfFdCsW491ajLdzMdjxVgsNaQI/ASUmzfAm +nXJKVmoSLsphbVOvEgUuSJlcT5mKCe3SY7rpqVuRkz/PljMKqQS4yIlopaxDIrJliNJrIsBFTp3j +21i86MrHJoq8jdiPou9I7GrR91WHU+TjiUMu8jFzVop+WuLUFfncxfkt+gnOz8C0BP0x6do4fdlZ +aqr+zO+O2w4lsjO5w5uiR5yIWkWPWxH/ihwBZep4yvLzqBkyslcjKlZRe1SXA25DO+PNsHtVxrN0 +26rI91Xce0W++ZyLkMEGLrIdHPd4/w2oQOMjG4aFT6Qi49U6etIxdB3JKSZ0KWMMO+LVf5XoW8df +EkGaqKpIVBBYFMqMU1VM67hYIKNrIcj39Fwx1pqeHVa09iayyyN2+vjgDyIhfJtz2TWU9dKCsAw1 +H6XZxrikJgkV8bluk6bWQook0RYhykVYqZp3kSYiAzyanQgh2cZxYLOvsBpVq+NsxkvYdERYcTD7 +prFWyUMdIsLrhtF9kmgqpBA25mtMvEDKplFtd6lKQJkXKtz4o67jbhB+yMbPg4kVVFpBsJFjr0xI +DcfdJzismlfMier1GmJ3Aw1l0vxWvtU5bWwTN60giNWZ99RjVMq7Yl2C7wGJgOF3/y4W70vHNvIm +Ykf6fsSudj2Nw8lHE8fcDTlNSzcrae7yqcM71QnE+UXpiodhXALX8fDdOsXV5GJa3fxc7zFKZBgR +sSZ9kfBqgnwZ7hFDG9d/k3A4oXDC8wzNMalVYL26FzDtIkCvbJ3xS2S7+xfjQqgXEm9fr7QcTFQS +lFRuNlXfeVVC2KzvqvA3ChGiOhr+ZH5GEziYYBNXebAG42Uar+N0qcfYMEaXKUaNcI44GTqUnGIt +p08GnRB7hPjZnhjvl1Sy21GsvA75tovNd1tzuHmb1XCDW+3PkAhM6ARnp6lzYpImUnePs6s00x1R +Yv1+QLm4XvHQ1wXDejrXEUDVSjcZjQRG1Lb/AhjTVBnx7XQYHVIR63iyRFDCykTTE95mdD+hdnc4 +JLQv8g1RcEcMHk8O3h38xz8O/kFl1Q9vD+rVb367+uF/TQFfvTGrb97Ln1IOqq/edKt81T+Ml3mw +yhkKnaHICMtGODhCUpYYIfIY0cdbAWUm22W8nUYbjmXQhaA9CjV7SA04OtxMaAZKjOnKPbQIn+Z0 +akrExoSOJUYdKEb9mxBuFpqS98kBsGa6pkfJ5LBZtzLTU2tyrK3BgDUH5PgETTimn08O3+n5PD7F +teD0tJ8wBGOuIXVwxF1MOZAJn5Kmf8zPTHmeMWekJXV1i2550/IXaf0nXB/LTbnDnHkcbHlupow8 +TGjHhL6gBPrRSVPSD3TUxH7W9ZRaxu03oqkTqjumzCw2nuXJQowPAQ5pfFCMD5LxWROJyuhEGh9Z +OQ5eQ4//zTViv4QiwhNHKCLccSjDQJsnckrj5US/UpHZofOHVVADfgu/Afg91A6mDQAccKISMm+i +FV1kMZhL6sNGpNrAb6RIgPKh0p1lSl+JON+W3kVvBGNLqLlaXzkV3QxMay3Ui6WKmgZSlBxFkECi +eEijiWrGRMYRWdhDLGkgsVIToGIjhhWCU4NOCcuBzFRVYoFhgIKtQUq7uoWWuT30hs+tgWFQDj8Z +YKiIs9hVBp+oer6ijMwyzirpM01F/4o0BQXmoIL+T6YAE1mkWeAk1BTM4yzAkEVRTsZYWVVRYUhE +hgobEIBKNUsc0LGWCcrV2rJi59S8QOuWgxaogoRLtrehSUjE6VYREVKfVQWpftHC6g0p20ctkfFl +raYzatoongfMAYo69cdouSlQPTwg2CC3G3tAmV76JLIwvjGtVbu0d5h94TRcqeKs4LeqQSsf3RhE +iHXUATVWkYZcZyt8RNVoJWVbNbS6RbIhDdXA/0ZWFxMIgEnKUKoEEoBOAK2qECJI9q5N31h40gCj +y7qOKG4d3Q1qesRwF2BjyViT1V9xQ7aOifTQRou+oHYVRU5pBwjq0LKS8KaGh05G2txh26i4g+9M +TWqVvkNdPmquiHpF3qArrXrbSK98q+wZxXV0m3OW+g1MFWHI5mMrJhMAGaY1dT9FxZp5LGCgLWPl ++pWsh6VWAevBvdlyN8R9XUbPshLmTV3qSEqEQlZx7UsX8bx1kVyDIqk8p2eLlHLJ0UZbp3ZbEb0Z +YGIxRNc6RGR3ykLYNlqVVDmEH167CGwPJn4d/YmyveN9akWbBaVCMelKG7tWtzpq74NCTGijgbCK +m66U4z7J0QqTRYU5lWOkMhwUQfWCkXSSaljnY3OwTnXkdUB7Ev0ljS5yIh0JedFR8kTri47YpwOh +SCeCeoDRW4q4mHDYUznkEvEGDgsBKaPegu+z17EGVFBHp6nBuXMGu/M6Y3PzWzRjQBgszMd1c2ih +szP0ZXFTYzO8CmqejB4iC5ziakGbVhHfm6CmZy9cgNAlOealT7L5friCBOqoFfJy4gYs/bqSjYGf +QyMlW1l+ITqro7NNGz2a26jDestCBwtnCUFmaTMayv8h5/vvvrm9G/iMQ9pRD2K4967O4LP/8frt +6sPPp+/PV1d0jP5P+epr+e/ADn1yR9LTGhZBWczFTAK4xKVsgrLBSxkF5WQXswqUoRYzC1JqE3ZB +im3AMFAAXcwyxFILmQbp4XK2QQptwjiw2GLWgQu2nHn46s1G7MNXbzZiICBnL2chZGgbMhGC/Juy +EZTzN2EkpOBmrAT1BBsxE9jjG7ETKLgBQ6HFNmApUHAjpgIFN2Irou5gA8ZCm1zOWmi5TZgLPWCW +sBeqt1nOYEAM/tSjMorRK5mtOqob11bJj9t0hnYhNhocc2+4jEzp6rvb0+ufzpcHzMiBJAjv6NNg +hboyZgbnIvR0Xh2hTmi89HVFzypZuZaggMmklw3/ntBgxbfp6xMNbMBeT3WeqOEfJmhtmXXZWo6g +GvkAuveMStCupWpKdXpP9aTWiqy51Jki71V8XeSdj9V0/TtJM6EIzg6eyBR1XTs5SN3pOnhyMKym +RBeGraFi7UrqEgDTjq8Z35ppyKcpvc7exjr6KmIX+mZiF/inarPeapfyIfUTk+aln5ai86LsZ2eC +SLNcQm2AS2jZCo8BJ03b0Jm+XGEXWmhrx2y6cLSNsFjqE5oehNOtDQijE063hC/91A== + + + I1TObeGESljuwaCVQhgMvIaldSMsG14F34CzK+HDFwKdRoVRlJHDIZSYANOy7BAhVXpa8yAogWXq +XKBnAY8vzJuwCqrIJMk9ORCCGeB4DXShFywXwNAED4aejrRQ55GMCa0Pck4pqCFzAvIPHSdXUjgo +PWn444TKmqZWhWAjh4OCQk11bKyUOCFMhbJ9bJmIw94UqX/ELj0m4iBODjguy4NdR8qPOPoizQcx +lHNUZq/7t6mOQRVsp2sm9aXvik5Mter7y1HZsMoGFeclGzmnZcU/ocrmMM1SP9FpkvrF0DnKFoy9 +Ytuxo/2a0nnFkwmP657G2yNHuUrzcnJQDF5HiE4Hq/CVbqauGUgPAhl0hahTTLpbTIdUTMfdoUyP +OkV6209gkeroZ7lIuNMvhWKyIGm/XsVkTYvpuhdT5Chy3CnW4FaxBgWLKaIWa9C5WIP1xZrNUazZ +Q8WarVYMd2Ts3mDjdrOfbe8mX8iiR6piSiqKhFcZQSnW0J2MLp0krxoBNTjHPRyGKv28ats6HnxR +ZBZJFJ4K2smaY27UaqFTrXOYfugcRkuOfq9T3XoymrFaXRE21jUPWH+0813+KvYjqyE11LeTepH3 +Rl/mfY41pE6d9DMAH6iScyhbUc/y7kWcmby0zsukhUEvlBLhnW37nqa2+9FMh2y7A3w8T2umczrp +a5ZmsIC2zUZT9JOxBhsUU/q/G5rGm2QWnwxVYJMJob1rOGtUhYymljL6cP4FNFmkr95MlxId43iE +5Z9igAqAI0xRS+S4uTV4p0bjIXpCsphgsQpTk/lIWyF7XQzfT3Ega7PIG12DCf04iuFApts+m5xi +OHdFnLy1r9dgVrdUGQL2Szro3bpxrB3x2snp5u46k6iqMLVOukMoZUoKM20MDkBQb5sOAwYpO5FY +TWkjjadzaIW4wFLpmFHDrrwx1nTyjeFhpxZVPTAaaxE0rrq4E3hsqg7QApUbnINwU6Uu0VMP0yks +GihoPMMlWwTKxoBEWm/L6LYaKNx2zpiIJsUPugGxfwU6CCWa8vvoX9F30CBsCsI6lJw1hTmYnjU+ +36pmi/yTGt3xA9EZJwfpJS3VCPQiUSlrBmLHSsEg1dTodVNzcpC6oxPYoF+YVWpc0zSDSaq8bTXQ +h4sh1A+q+ajA5pIpYcJaqtCGD6id6j+AwtW1ZZ3XU6RFzJor1vSqm6Ws8900ZWMs1kxFN1HZjHWv +tYBLsPH8a3NgPDI8GqxmPUTKIs1fhrtFjrxtcrLucbzbAicPW0hscM4HWkiMMCFSxNDh2UxFL7gp +G+gEHTTo0Bx7OFkzvBWsDIhCMBU6I/MRbOXUj/2HKxxs0tmaJRrVq68pGoTngcI22Fb2ENSTR2cb +t3o0t1XXqDd0sMZpwGhuJHnMyNFTmqgDG9IaJd0jaqMGjRG9UePIiOJo8RHNAXBCdQS4Cd0hmV5K +eehGMqY9pO1j6iPAKf4TOKZANBqMaRC1++OtxyNoTIe+erOGEkFfP9n10MZPqBF07RN6BK+hCUXS +87GjSdR8T6gS/ZMmdInK7gll4sKt6eU66qQH+Zg+qYZ5Ok3raJQqlcdUSqHTdVpHqTI8zWhVhtIZ +tcqwvxii/5Ri5ZtpcsS3n19pKni6+uPt+fn1JyUZCinLkDApvoMg3D8wOMgf1hUHXzrPBAGM/dQk +Q21wGkFeRkOj8RW9wl0I6tNXw/ICr1inhaT2qrQa2h+QnUAkv6qOwZh1lmWIj5pkqEamlfhetrDx +6swpXBh3qnXGcJMLRXApx5DRQHarRguDj9Rp2/phjiECzmJgxOiburUMTyOloQUjhp97weaYQSXE +zoem1lQRhp6dMDq2GvPj5B/Gp6kHG0AVjXqNVFxqkqEGiTFg4A5Ot4CvYZnE3+BSkqGgPs96DrC0 +pgqoXIjZLhp1mHXOJkczV5X04TOMN9J+NivtN00FgtFMBoBQ9ujx0LLDMDnGvBvImgKLkzHqGBoq +hqdZB09MTXjjsGhCf+vWq2UmwEpUIww2+ikahDMTI7rEROg3kSY6dHrkAwBaNVYNeB4JB4B51oWY +Y6iGtyiQ08ZYnNDQ9lGWwXXPKcdQaNS2El/G0kVfPDZR5G3EfhR9R7SnRd/VOBoieFXaONcccpGP +mbNS9NMSp67I5y7Ob9FPcFyBIlsCrlKRL1NcyaJbyrjWRbfYCSGKDCMS1hQ92kTEKnrMitinP4KN +ONtUJmYkCtHRs3JNiIhoE6rjsNaGE66bMiYEiJGB6K9bZQPgtrJxmHFfce9p3oFu88n2VKf84R4u +8k3MjT74irQgWsUY30aCYdNqVD5mGDLeaa+ErPhVJDvRlFfnCYYSYUqEK32RKFvRkTZgh2ubiC+V +1fRCjXEplU5oFcvqGJ3nkWCJuGi8idhZtzG9UJBTJuJwpelXWmZoigQ7zy8UYoIhmfpgOgjq0NxA +sQ40xADZviHS9JR/B71Bf0mkYn+J8W3aA6TpGLiNKcw48JrsVp1mps8vFKcOc6tJfgjA5NdtN/mW +lMWn5A60lXMVm24VqdB1MVVDjX2b5xaqdSNroEc7+KZuk79z5Z1SvTT1inm6m9qMUgKB3SonpU43 +J5HcaDIXoedhQJKbit8koo2N1A52lO6jtOviYdBvTA1obrzPd6/2IZ0yJsRjp0qbSlO3dJTCkc4O +qYlmyCN2kt6s0ibQbUHjO1a6QTOgW0EDzAOZMJK2ptHzvI7ne5vKBKAFaaTRQ5I5LpSKtquEY0pq +ybkrHvpIj9WTO6PYYZVR84zQGyEjSsqD4rRtIlsSFKXLoOP2JV3lpf266ZgSdtBp/Bc81nUMRqc3 +1LLHOErP2WVeRU5DFafKMw+OK0nedC71aCw5tS1IDGdakxGOTtfR+Ts+n6dH+PiUH7MBQ07BKjYO +mIkxtzFlSMY8y5ipmfI9iTwn6pyIc6K6U/ZqzIGNWTTFPhfR0WpyIeM1BxSJAu3APjGGXXKhSFJI +csoQn0mRlO8kQSLRigkNlA4nshapWiJ7ieolytgTxkQ8E+1MxHVEfePj8ZjBnmNJboOqM7xt6AFS +CdLVTB0EP652XXYhi8RY0ZKcHuCoKbIJpMtgPdxvhPZObMnCVoaWmYPkb8X8FTJTajGGGIkfgsO+ +gXlZVgSuOyX8L+VUnGQXogSxNp+d5gQgkmi2Jr8qUo6xY+azc21KLhhqzWdXdfnsXMxnF48Kw1g7 +zWcXw/8RdF9nSRFaN8wxxOdjTWiXUv855hiyKkFa5q4KMaNdl3fQaRygRsIw/5WLCe1S/rphiiE8 +H8d0di7/Is9mV8dsdn7VOZ4dx3R2OuSGKfBipq+Yz06TgXUZI2OEaZ7NronZ7OwqJoAcJ7NrNcGQ +YcJLTT3WrFLZmMyujXnNVjEtaoy2KE3KnGpTrjG3irnsutxpMUmk5r9hdrXOI8syk108bWyTsoeF +mOjRxeBU6+s6izxmJjsXM9m1MZOdiZnsgollmBZQU8UF7UtrYiY7H0aZ7DhviomMs1Jn1WEqO9un +sjsepLIrbZdstyuZ5z/VypnLrl517cekZV0HmcvOrrIxMJddWPWj7FLZxfjrBgw2065p1G+eyq5p +R7ns/CiXXUwvxBUjkq06hCKGeV3xetUteIZO3oSYxq5S7PJhlMauVURUXIpolzApy2Jnuhx2x8Mc +dmVYJdRnL5s2JrFL42h0Q9Veg7NJFzSJXbvKdmAM1o4bcJDCLmawq1ZpB6ep7Pd4Si2ayABT2FUp +pXHVx493pCTLNETICfPaMR1UhJBAlSmTctvRsJ6EJTKXqFyig4kMJlLZU8pETRMxXZfYTtMNNZoH +AO+HKaNdM0wZ3aTMeXWl4flZH5o621mxk5otVWOD4zg0paqm4+FQNemqN91c5PmG4gQyeStHl74Z +L0LMchmydSrGSznKG53EwQwXihGyFGNkimSrzfCtGKNkMcbZYozUxRjri9GuKKb7phhvrWK09Yrx +1izGe7cYbu1iuveLAXlo9FTKUmF26aKVxMBT5DilizakQnUKDIZza6RSxZSO6WHd9KSuGNPCQbpo +WDaOU7ronqIWI4pbZMS4GBPqIsPkVDxPF53aSLjcd2SQLroK/XiKfEBxzEU2aM5K0U9LnLoin7s4 +v0U/wYPzsHH9OhX5QuXnatUf/EW32BEd+rO5GB3fqw6lih6nhqmi24istfNRNLVVLE53b2aKbmIb +WaJo3RVRK5D1rPEh41qKRLyLfDfFHVfkW077NN62RbZv487uv4l7v+PEOgKRcWvjLNFh1RGaYkKN +MtawI1n9V4mqdRxmR/oyNlQTRdc9qxoTRaec4GyFiaIT/gdFEoaQu54vjomi/aoYEfMiUfN9pqF9 +pqF9pqF9pqF9piG7zzS0zzQ0RtJ9pqF9pqF9pqF9pqFtyTSEEMnk0Dtw6a1gZwGDX5sG2Q2uehgC +PlWLxIBPyiMwmWiUhYhWFGgsZTa1/gsGqbAbglXFNhPeQgoJNkSLu9791VbOJH8QxTw5RZhWt3fg +RopZppfHucJbbgIs/p2rRs1gfKYZqHUhjbUx7XMK6NbbABCe67qLkCzT5cOEVNYxEqSMa2MoIiMi +xRrVtFBuVy8FGjGdmjGw/jEyTVYiOSvEYHPfpz3xKZV9FfuEz3l+IpwlJc+v1EcsHNIvTp14YlqB +VuqKSh8TUZzRwRRbqzg7XCX1UTDRyF2FMgZcu3hNAVQJhGgQd4Koc1JbxgS5+lV72Ea7QjIwhMO2 +aWOccmht9INqjYv003MDypg0vgjLWgevvHEdI6MJocMVpzD7RuYmptDVXY/EDLFiU2mGKlgEy5iV +wvM6JIdtE23yFf1MZEq8ekjApqfrxghtNfE0vGmi1NB4dVelCabkJTC16SHwVBDpmugYQZbqFttX +5IBTdWrM0YKX5OjYIQ9Dr6/7PleMM7f5wOoYtt0Nvk7ukWl+oPEx8cKKOIUNte2uBwXQjjjxHC9j +OGMqhjSkkoSzJ5PABW0J616SHfS+dj2AdtUm3WqWvokJCSpyMTINVTlAQwFZ2koAMmRanIm+Rkxj +DEDaoNBUqR7e2pCaCVQq0oAAQAutmIl5sDVltNeuZQmjq5jiPwa2a2KLLFt0UJOv6orSFyXv9Vip +a4Vm+a9S+m+9Tsapp6alb4sm+TfRnYzkqo76+w5Aw2/0BIkgpIhm+maQeCR5SIn+CQDRBO5UZbL+ +lThYHOlbHF3M90+ilPLxnzHhvzouZRn/jbpKrskPfXZQDJKmx6T/vslqGOWh1oxD6IpLZsc6aE70 +JnrgsLOjnNccUTEZNrNnm2jzVGKP6RvMFcmKtYnU6FcBhrSq6ZcBOb2bKk4X8VzJGBNg6GqqPt6V +8a5AW0XxP4T0rATTOZd/oNSdGNV0+f9zrOsuMiGq0sGYmseY1oLpXEZZ0WO+J3rJq2I9vwRAPdhi +fvWYfL37oW6WXfL17B6AWjWl2UUA8Xo/MltnB4POxHTs6LDVDud3Aay6JPNnBxlrmQ== + + + rmGx02z1MZE6U6s3JjUnK2M0830dyZVvdJFlGSPpVh5B0KWJw7PJE75PkR6xLN2J0mF8l7H/LN4K +wMkfXgsAFDfqst5dFFCWJA9nBz3IpfMNzggVPAtwiJe6E/T2hkPliFRTVnqGsLeJken4pgAdul9N +OamHcmiV0V9iGocv6wiztcbhI3mOYTRFq2pn8JKybX+4OqgbzbEy+tBWmmAnfXl0NrPKo3urNJWD +E6jLquzCONZEbkwZygy6jKWMItdyplJlqE3YSm1yE8ZSS27CWkYxdjFzGcW2DdhLlNyIwdSYiA1Y +TA2x2ITJpEJhIzaTgSHLGc0YwLmc1cQYN2Q2kV5qObuJUNINGM6v3mzEckKi3oDpZFzRcraTMUpL +GU8ptAHrqaWWMp/s4EL2k7q6ZQwogq02YEGxxhswocCo5WwosHchI8qsaBuwolQcbcKMkhhsxI6S +AG3EkMYA8WUsqZLYpUypUvRN2FI9RTZhTDUUbhPWVM/nDZhTTU+2CXuqTW7CoMb0mstZVM06sJxJ +VX5pOZuq5TZhVEeKwraL/P8OtirNVJmGfqXmNA1GqjUWrbF6Z2LguW6dEtGOj5OuktQW4KwQGom+ +KxMED2b1SFY/3JJ3pHI4GIvmgEQuP/V3VB7Kpmv0IlnI5hzY4dWj35W4xhf7ju4ODvtPtarDAR1v +wqfLwWtMvEJV2BPdNbjsDc61SCmL80cGpkHabHD8bVP2nx2dza7x6P4aPU4voUV5tfez6mtWNqqX +l6wt80xssLq0wS1fXym2yQo/gOBktU3GWF8xbUNpMu5biJoy4ZE/Rx5IM2TibZfz0iFKS+8sDTEe +uKUrpk0XrIHbaa06z0bCa9V4AoDmJhUer9YbSimhKMXXaI3+CjiGpWe3DpKQkt5WA3rbX9Y2uKAz +o9uk6tWAvMsvMowEYTkAYCA6hA2sPoOb6+hNWDe8glK+NdHLmwwzBRMXLSEQ8ybzvZGc3CBoIoqq +9SHzocigIYk44L+z2iGkkQ7ayeGn3Hzpq6OzufUd3VcfUiHAN3NQ6f17bw3SaaT+UrTTVMKLEY/b +aCnqkTosRz7NTrMY/ThJyxGQxZaj4AMEolMTIMMY9BNXfcKtwGByZSmpbmgiUUpKCQY8VUk/5uFI +UUElUCVm0gDgqybG87XggDFMpORQfytw0TIkJqTgM0YuZUxqmAxLupQyNUSxoGdqyPgEspqu54/a +mEX7rL+RcnghZahXAzYrVKuhprCELoBullotszrZwyiDCmVGVAykKQxQfcGYjRopf5Pc6lUkZG6O +yWRvRB2kkaqtW92j0E9QkBYutEUOTWxoAQZEo+B8biApuvHHSO2OVEr9t0gsP7vio3srFrFI0w8P +an5IpTbBvyzL1QIM1FKLcVCLLcXC1NhCPFQGfykmxlLLcFFndik2PkQoSKdrTUrvDB1iQRfhPQjd +m6uT+zTiUuqkGcRdBQxkaSFBq+ujJfmv5RgwMbQWTrw4D5I2sb9guE5GCeq/gAaUJ9mZVhNfUFvA +ZNcagBhifAX0HkEjHFV4EYDGV0BsDWY1GdKG27GGfzv3gcwkneVlGxgOPMjI4O3OhEbM1F+NP+2+ +6H9xL86q9ei+WhGRyAkZ1PrAPpwurwKXLrBK3IuXODW2cJG12OJlXovnyNskW//ezE2fLZPMh1/O +736rYaGaevO7AwRCC2GjJOuFBreUhVsEXHfpZU7n5+e2NQIJZU4aJIflmS6UspGFc9CJRgnb1ogY +AZVuVOFU1o3vAGTgyYAkCHNNWhwbCcJahWdLtcozE6HHdo9xSjCPe0XHTM3kvQY07O4J8fRbhvlD +VULdvWPEa4JY1eKDZ2o1WbVG91DnVXXPjPrn/cXdF82ohmbYhsbkWY3k4oyd9BDozyxb0TvfG/0i +tZqeVbpAv7ov/KgGP2zjeDJWzIGj6Gez8XeQ2HspZHzdj1d4QX3fjR83uECPnCD1qIZ61Ab8XRXS +j7+DxN6nOtPoUqv9+FO/EsSNanCjNo4nY8X4i3HnrjJQ7H+BzoChTwMspnNQoDtVhibFeB6LcfMa +njeah2I8jK7iNM5iOhVdB7tvxtNZjGf8eDpyTgfxcDAbCZKGQcxssskgag7mQlEzZJ/4UR1+0Ioe +2YBkE5EgaQSp0m6Msd1sGlLX+k+aUR3NoJXjyXijbzTCgGgxgarEiwR1xUSNpVclTcqNiNs89C4K +ioWaKZQpj2UZvVq5OgiGg3vP1c1CYcLttbyevKsJt/gYqOJDvMOiaGDPaIOG7NRkKeVl7YKmG3bl +8JFZNkwPK9BOg3gqGx/q+Ab4Z3HvVAne8IRPNqbq6+px8TXaSb+JuGoGdFnpw1AFbEMRP6Ej9lBK +0be3NTXxeDilx6A+Weev4I1kgo49jacke2kalqp5JwOi8JiDERU3NAealulZXRSlSwahZ707Psh6 +f3KgY6s7SDbubEKkUDZZJwf5PKYaup7mA8HA4rELS3nLLGqCX+SDrzBRlu69SFth4+GETDJI+AHW +inI1cJ266QgoGY7qq67UsSZljiYj67hpEFtmaQOtcHuAW/WAGikjmlVfqNF0ejH8gv4A0bLCVM4t +jGuCEkhRxIzsapDuAI0mdUlljrOxCp/mgmb1DnKWM/+A7Di6QPQQeB9Q7TKZo+N4NuMmK435q6F/ +cJrQTva8RhURhBsfvAo1OOyRXyYDeWSIaGv120pACDTMtdnVZbpQuNRggtB1yzN1cP+VF94PFzr1 +NXWQrMEO1vWrqyn1fTy+sxSZsZYJtP21Lu6vp3d357fXv//3+5vbu7//+j7e6VKufnd0c3M5/Ob6 +9MfL8z9+vHh7/kG/MtOK/ibc44e721O011cniCdI4KFEK5X/9k6V5r/72/np5Z9P724v/i3fDapq +v7+8ODv//uz08uL6pz/eXrz9f89/zW6cWcLFfry8PL9bFauj07Nf/nV6+1YzIi68R8Yw4r6KKZct +4kr5TD/2VQLFJ5+CB3FGxXS11aorWAw/L4yPv8BcxZ/cPdlHwxq6chqEtWIrg54MvkydP+7HMf/6 +khU8GErkKpLJEqqJO66myXPlrIRLAUW79IB7S0RYNK0XqUgQ/HNfWqKTtaIuOOZJw4BXmquTeaW6 +SUpTtErvUhl9ZV03OV1qYn1ZZGUK/ZiL2y9t316RdyQua7eoq3SBgTqhEJP0V8xxzN/8r3+KrflV +bIyiYRW/iB9ErnylEkB8kb7UoiDzscNd/V0jsRfHB113NozsYlVX8VfXhIJtZ+PGz8uUJXUVh5x3 +Jlps2d/L7nc/7PSuiHXGn/i0e98Vid+edf27HInUte/CMf4jRmR0ou7qJ+YlUd8RXTBGjeAp3pxh +GMuiXiF6hxeA0fitgJQ7gfdu+ZgNmw+pfPrRF2Ez8fE4dSI+6+0vpv9gVF3fFEMcUydODsZdTNUU +yrqmcaaDE6ksPO3MPKd5YSP+IgsLX9l0+zRYPJtSyPNDGyPk27Yr2z0nhTrDZUy65kSf0rd9IbNK +LRRszyiQsm68wZCND5qOY9fpfkBTJlyESPPMD96WJESVq9bcnhpvhCqjsxhz73nme1jFN9RkeQ0q +ChaeNHBH+OGqKwpuvorZMB8qWhu93PLobONWj5a3WsLNtM01b+spwMP5wmUDgSZ8q65c/b5JHpJp +52g65bl7JymI4+7JHufun6473Q7iNaMz9xDtbf0uyh4f20d6t17Z05oqTlQkmKYjmA9usTR9cZOp +n+qsbZa8bdqu70u2WiStJqU/f3i7pfGc3D9swSkzhtL273sCu5642tUQEIkI+AEf6B2slxE4+jkc +Rp+ehmlUIH4aGmfK7hcszcN3LNy0XeG8bigYEw3NepL3KHb8QScWWDx4/RuIDXxEkLvwXlpjefkx +E7tSPM13LezblWZHzEgMozIPmVV2XYka3Fvb5pRlZhtHc9sAq8dsUj0d+dS7Jf/R8fofh9x6YeJF +muZQ+3B10PCuaHo0V02osdETyNBNOl1kNSh37wlhHRetDiUyHcYjQiRa6O4fOiLAeFQx+zC9DvtX +IvQ26oUr5Nqpz/poBT20Oe1jhX2jF6QOj4mFLR9t0nIp4gNCcbOjAry8EAdI3XKOVCKvNvhRlg15 ++Do0tiJXD5QCxPRJI4W/r8HMM3RX1874Sj6/6kBQAPqmiveX8C5ow6UdlUgMdiPfaN4jCBKGl4Xx +FuiuoL6HItFQUzEpsRb0kFj9G17eKgOuf7v63fci0V7/tPrN0dE3Z2cfr/52c0eROMPqydGpJ8Ka +nmtod9f3/pu+92vKJSK8pqe/y59Xv/vLzd3fzs9ubt8K5qvwr5bDylfRn8sHA/8XOxHXj7/50x/j +Xvn7u5vbK30VRymb++3Nj+dvvvlT+0Y68f3dr5fnb/qm9auFs5YdHuEhQ9fz6zg2Vkp8e/OvDa5o ++DLVEY45cF3wVUuVna1Kz8t9DPyR6jAlyp45OO0qJcHlA6zTcElidJYcZvSY2Osm9rqJrdNNNHVk +kWOaiIH09dmZZktGLueLKyr90q8hz1ypu2DkmVn287PM4E6cgSNRYpp9gzPvIabZNUinaO7haOHX +YcKY58LWuK9IXauzx5BtntXK0fxWSnhuVf4zMs5r2OVavU5idmUakWLKygQ7yWEGRs14CbCGW6wD +dSXZQIwkjaAumgIXcZd1usR32I/H+O9GuE8hwCtlvw2zJj7AftNzztHnwSoJ77nYUKJtuPyVcEat +Rsw3PN9xQjxYFK5Nthoy3svaPFrcJo4pZz8/0+1SYiOkvoFt+yoDyVLr8mSgMoJ8d8lYB4JYpVfK +dKB8+UvXpOvqRZxy+Wcw8sZ7w3oYGn0AVk1hcQgn01Gl063vNe83rvQWYduVb/TjvD9dO/BNHILy +0TW4d563SlpjB19lMzUFdU2uAT0sbUQ0KT9F2ph07WoA7HrCSNzJLA2g3dg0bM6OgWvmioGb49la +06lPE2UK0AhTtT5oIKz0DiJkXT+JNLNoVbJzvnkl0swfbm73Fta9hXUvxeylmL2FdW9h3VtY9xbW +vYV1b2HdW1h308I6sadeHUyNp8UaE+saQ+yz2lid3s1xr40VXK99rKxHBFlZLTKxTho+2qDhJ7Kw +FmtMrLk9tVhjb73XxlqsM7JOTZO56XJaZD3s6c2s6zrPnFCZmXXNYNYV/DzaiSrgBkuzt7U+qXbi +5Pzd3d7Wure17rUUey3F3ta6t7U+oa0V1/swj9HVQamXAGrOQZFHDE1HCZasrSdkxWKE7xiUjK1Z +wTWgvvqs/c9tXDUIvEMobGuVQPfGSph41UOw0vRCQ9sqAthwZ/dDRZELotGkTRu2ebS4TRxL3gvT +/JnZ7ZK3OkKjRJOns8SFBEums5MMlkyZgFUTGG46bNxaUDJ4ZgVzUHkvKBnbMlDqrGIRg3DLQS/7 +D9Ldg6mvtOeVLcmk1S1W5n1K7zNQ3wFkp23cOshgrqo18zdufz3sQbHic0gV085Rqg== + + + mI6iB/aDzYqvBfbjUAtrN7t5u/lH66ZqU1GlSLQAic1qwfoAO9QTiCgbSiivxn76t4ufft6LKHsR +ZS+i7EWUvYiyF1GeUkTR60OTHBFDZGyVSxsdKJNJUsF1oF4Cob+nUwEkvc7lk2HjzyiklDqg+4QU +pNep3MNF6ZaJNCazpZRJo2MP0McbfSophe6Vce2ikEITj7dp7fg6lwoU0nOpCdLLF/TdG0Gw5JVf +B8oEmlRwCCrvA/Wc7WQYnZ0i1ZgLJxGUFzeHKQfLBDYYaTUZOyE9581SzqfZGza+FvTkgslkwCmq +bDzkDJoLIdNh97Bc5MiHnrU6FF0mc3+vUPLFSwP/eL8XBfaiwF4U2IsCe1FgLwo8nSiQ2HBy+7VP +gWEEIWOx7eO24IvXgzSqw+vV2b60YRWjwEz+WRIU1kBigyfTPjxlUBjv7xnw2DIw5c6RWH1NTFh4 +uCSMCcY2D8SEPdbkNCTskSZxPNlByvrPIw50gTqaJqMTCBocIgLQBUzcWw9J3Pk6SDWGMPIvLruK +A+tAXbkMlCovEi+agVIAWgaajqaTCwavUjBYikjK2u4bmoK6WKZuPqaQrhjrzquZ9uAe4IMCglBc +b4Tt+SQBYTzIqwEwC9maDjSDdUOLoV0DyNqRxWix4ZSv6c+neFkVms/C1o0mdjXSVzpsN09hwVi0 +HK9JZrm7k4EIiVp9d3t6/dP5RiFgjSAGrvWAj3Q8iBphh5AJP4EKYdBxAe6K+W9wJVYClEiXmh6K +7nWqoOhqSK10kOMDgpoMdHLAcraHTGrO2x13KhZOZVP1fYOTod573plQK7cDjVndcTtlVT144BW2 +PawNLhw1TSVHBg8FvsM9SXIk6LVDco60h8GU1YjvQdp8vT7w4dLweEb69FEsxcK2jzZqu0TKZuvH +R6BtSh94qrW2xOFpGu99Uqs5/AD18XpxgQhlepsfDkXmIepQwSVuSJq0vG8lgWS5XcQFz8t3E6CU +pU2/07tUOhXukCE+58jgOn6IpaoeVIyrLfI2i0mPugq6Tmd437U8GWyXQinbEIknzPdN1s3AaxAT +rAh17EkQlGU6gATRjsYHvOVNU6mGroJsZ4x62bc7LjSuNW9y0qFJnyeDPZ6O/z7xsncpHnWbR+hk +cJPh5z2VAv3jSf7YT+Z0wifLcpx3JxvAV2/WjEqA4xonjQ77OOzieEDjEY/X7jjrRt6LyfzdC8zF +4Mqtl/HTyVPr3VHIGl8iX7nsZY+UCmqYiG/Ty5PJ5/cS5dZGCTS41q+6sAUvVa+JbWNW98ZUvJbG +4CKkJufpy7Y8dAj0CVaE/7YayKCyLo3Tq0oeKds6vbxbyOHiBo82aRA8O66FHNHfT1SPCZvGe81d +TJIvS+YOY2zRSXqbXp5MPk8ErK4VXh0yS/5VAsRnISFVVuvw4zWAp49JmHRY9knWxe6DrkuTIl9A +KELl1+/3z3XhkXKx9hO5WGEnnMFlO4mBrVzAE8g53wShkRbenwmgvGt8KLrXqWyBwqlaPMgBlT0p +s5o+nFSTNzLuQda7rNvHg0E8ypoKDeRd45E1dcKA1Q9H3eGWD9zWbBrhV2obhhweL3eoNQIL920O +Y3x9I0DesfVw4RbkaRKLt6zlo01aNm3b6QU/J2ParXhF8w4YvCa4+CwLa+Oq69W+CRBZIKurru9S +UZbsVrpSw8vgOXKi3cfFuKoib6eY9KIY9rIYDuJ4NKiO++yRWy1ZQ0DkO/WKjZq9amK7IhwYXl6e +INqt+IC3vLg0FdfSPa4P+hTbGnw7rilvZtKJYSeHYzg+GI/pMf4y71XHXPaDyHvG+2LzroGV7B5P +8sd+xkZTOu5u1oXUYzmhppBBLZNWhp0a9mk8gsH4RmvUN921XMyADHjHKrszMtuD9/7QfxlI2Q3b +HXphb7AbAWLaoggSxAmHrWszkAhpvF8LUZXUnoVarypiMK1v407FLTq4c5Ocb7e9YE9BUGy3xdgv +z3vjB9uuUhEn3gWuF9j3vdPn44PBTgQo2+kJVEzqLda1Xkz6WEyGUUyHWnA6cLtnmo4CM+bLbF6n +M43UGesuhVyzJBFHhosiwA2WhXLOBguj5RYuzWA0aXF0v2+yPCpGbrBAKLjZEo02Wh15tHYsnbWH +ehmVPSwrD0tDjVutgukgVaM5iGtomaTq9AxWJv0u+FLmIxUutHSzSvV3gLODRiiBNxlImNwWd3F3 +tSQAuaX4OzWfSqfujQdwPBnS/CRQMGe26H2J4G8dpKxFaO0aXgrXiuJeR00GFR8gnIk07mgdCnrn +eO+88Flks25CjeZBucKE0oDVgRBXEyfUNXD7SQAekfF3epdKp8Ld9MXnY2AELrzrICKeOMUIrSE9 +o/b0u2s6FS7G9Rd9A1FczFAljqzGte3MYxdBgnCper0pLgHYdpP6pe9S6VQ4Q4zYsIwdTGoHCTbN +jdaQnjlvtptUfZkKF+P6i76BCeh+HmPgEdE3fJU9jVvWSu1oYHo//XDwdjWenH7i8PVkXiczPxkJ +ik2mYDJJ/UDG9+hWTXf2RwcKkaX1DkXhQ0scD0RtH3DfY0dMT7rP8JVtc0hX8POkuoDdihJCvF3Y +lZ0anGqYIDTf6E3nIm1AaBgpjeSMoC7r4cJtdWitaaLSaGGLR5u0WLaHVFB/ZsM1rXu6DLhXnCxZ +pTdAR70RX6e3J9MCmeaoiS9aV1dWdUeNllbICXCjr3tcYC3oWTRIfaNNGVmg2NEciftP2b3SD2Bd +8S9An9Sltmg/ryLpD6f/vLm9uIv6o/9IMsbnvDkb15nj4ubCwbOqgsFB+MKa94kmEOSeGnQTAJjU +cE9tC/WHAytYteqWGWoom2yrl3ziVlLj1Z2zDY6Xams+K6vPxwcJ0iKLjbp2IMcR/CxlU+E+UCkr +L3h9NG10in64bzX1TR1PLVjf7iPW0jRdLbxoNjWiF812vTjRW2oNLwSPPS04GELiYHgzL5rNRkzR +tOa1o3FaCs6cq/qZKzi9OEyy/jbpNt7uK2lXeDW4WPJ+3SobJ3L81FAR4MboeMFn+goVIXlMv1Dj +xTzuvC7jCxlZWmWk7PG2BwVYU0LFFrmnHduFZ51B6r1jknajEyLThg+cDekDuo6GwyCoGVIdes8K +Lyd14wlJkGP1EAxlm39V0xGKAF4QKwC929hJq62mM4TV16hHchlq+kEeigQBCKaP86mHfR00AyIe +aVOuK3UoPTSwC8tseyujUpmokUld4QirTI5wYI/ZXX7i4ye4FNxrmiPWArYZt9oqWmtLejluRP06 +UBXKrpquq/QBleOt7kfDEXuTD5mz4vtZwbw1TTZvk2U+nq78/Q6uW+IzgptdYTZiFkSEC+DWYF74 +ar1VWeVZLnz9H+eXdJwn2f32CUgvdrZt9KKkmt5SBhJHaOnJGaQZ2VjKsDomo3O8AjgHFuMSxbhS +3BlcKdoAYXHndQJ0z6lMXyRVm2pNbbIf7EYGGX08qW3U3Lg70x6/gyN3if2e/l5pZlVk+wORl40p +bBdFTmKEdjoDFePPi3GN8j3dS+T7gNONZCMCig7Cr0nj+mKp6qKrOzVcsDMFewOY5cI0q0mJVFtW +7aTtce+mA+A+RthD7ZRCeufqeN9VyUmQHQSfJZ8y6gehBdTf8NzIILwhOuZiTDBc8B6QQxr1yDFK +2tnS+5Gqo7rW6bCHpXfq+yHil+UPNfwb5Co1+kqY8cDr4x3sHMe81N6R4EGFJJyzekSqwA2XAc6P +g0qiZt44eHXDqydlkkPSCkcn+MIii7VVI7UuhOm+IkcHZt/icLM95OzA8GwyPUjkvFbTlCIIr4F9 +GGuo55gO18Ff0TWEkLeQaSsZ89HGBe8AAceDTMzZQQeSlanqGtFrcZxC6qjFM2CeLF0GIEQ4vSO8 +KdsWl9eLYFoH3puOczLwjvBS6uF0mNJUvJIdt3fL9uMl4SIb1tC5VI23hlePO+/ZDrznG20HDvWH +cLnkJIr8UqEQzhaeO6C3uAldPq36J9nrFcZyfJCBQvCNeubK3DRDQKCkfqjqQdkInFhZfJqkpV+1 +RYBfiGjo44LjMnMsl0wQeSXDnKb0jMP97EBhF0X4Xto89I2tqQVqWr3iXE5uAGQC4XiMaWiDRzvA +UVdylHUDdweiaE0UxYS6HhDipLOQgtBCLYwXnE4rTcbqWjnpJ5sRmxR8QSCnhJ7W1qhjPFgD24HA +TTVVyzSBDlbQHoCFKYMuUQTJLACdukpkX3plVlJLESJ0RdASTuAJ4hFQC6KtdXSPXSsdJHakqyD1 +dDKcM+rSt4V70FviaYp+Plbh5uo8sgrmSVgF56N2X1DAhAC1kpyWwnRrDuVW9gLjYCLIlWryOgHK +3gsCR1vWNrmLU6pXr0lH9piNKmraMpBhhulgxS9aBVSHlQ3ceyLzt00OY00MzwGgXQPQUgBIvbB0 +9zVPBnyScp2XWtbWrOxKDkA1NETASQdo+m4GcJLwKpuCumIFaw5hDQR+5MxgpJe16ESBYW9oU0ld +yj4b9fJhtc0LbBI5h2uRBSo5u3HC4BbQSlMrt6Zun2/jfHf746pYHV1+5PYxSYtq5m4LykrkPEmP +rzqIs4dKKoNe3UOXZxLkIgMV/LzqP+8AqUacpgkkKKlHf6zAIsbIIHoo/To7GL/rehgLj3t8NsOw +49xv4wcIhTAeDiP4F+GpZFYcDtzKreT8Ft4Nsih1v2zLKhkEj+qFHvGqj5q4j3gjGPRExOrNO5uo +6Wb26fPr66IW00CMHU6jfWwap3pyGfzQ7ZO4OMBDIVOtdYERPsLdIe1bAokwdkhOR7aQaYElCSBM +W0vWFajUwYTyGQ2ZZTUQyXBWpB9EJFNSlUMAS9Z9yf65qz2BUg9SDamLff+Ps7HMsixCv6mBN97T +/Ctss9NrZoTLbtZEEAj9NvKP4l564DUzQnHg5ytdFPYb2anHcdHBNo6WQ1+CZZVmq4At03tS0Kpo +QLjkTJVdVrd6lvIGBciKDayWLj7LvFSBUyV1Q83UA+LcHR8kENmgqlmlGiCENWnu+OuYV2e0dRM6 +UMHSVV+6A2QtZLDYja4e7WbqflLZ4bmOqGZ5o0ROsIAHJkAm6yFZWxEGBZFeHRDrcOCVOZ7061hJ +VtW/SyQqFU7P+XR1oNiLVEehoSWuVm0hFYWbxVNPWr3KgKlr4673w9Jw69Gop/MymTyWm05yvgY6 +LsZeZ6OeTMlkAGPjYdNfqwB5pu4pDYQ5S4O2o8ESDuc9TNhuaGbpr8uwlk7rDD9rSB0JoIedkP3s +GwsvaJvVkgCpqbODDgTBs/EpuhrVIHjbUPBMbXUQyifaof6rrtN9VZOxzTkCjX+IeEMci6RGfwqh +oXuOrdW/XO9p6QgNpjtk020gXTK2S6Tb0qeLviPMq7AFttlYF/1TNPb8MBkqCVC9Gdng7KNGpNJQ +ZfV0gNjY2UEG6+766Cpqk0ojtRYBqomKXeo+6nrdVTQe26dPt5wzQv0rnfD0oKlQaw== + + + EYKDFUbflXpBZZxxDaqFmV/YnooRFB2IgViNWotTkiBVnUHL5ELVAXSmIE5l37QaCd/XEgGppbOD +DiRSehW9drUWpLctXdZSAujksjf9N7G/fS2jMX36zEIdgtAPzSYSHzCzFt2D1Vsojhtc0NbClajU +q3k0zLqDYNNaYS4aEiTFOGrafIyg7wDQhbnoPhZBsk/bYFQJGuvJQLExaqk6mKf2Y9VVJcJP1brQ +N5cA0I7GLiVQP4xYy3hcnz65CJE3Pt58lx7Akgjvb3m3kqvZVE4oMv5PdnSjkXAlvaOuekgbo0aE +1FPhWjBoLgDBVOHUATDTmAzXgwzEa8jZqZYOEBvi6nQQKAxXXSVImMDLkVJDCQDNT+xMAuUDYC3j +EX0GSgz/Pp9ocXzAHCMUyhq9+sq5XOIoBOG8BanDGVNrAH0Ha3DnDU5RKLXbkupiozx0oM+X6yGC +ja1QXWrCuq8M1FXgBbuaOkhqD5s9wYSlczZwMWJNUP2S0nTtJcjZQd+r7quu511Nk/F9DgqMM7RO +FFgfcOjFNBC8N8aD+b/30BMaXdWGChZTthRqEghFrdox66qljpInB8yPCNJNz9jGqsNPEHXh9H0V +HaBr5uyghxlER7hVqkX1LepvwIY6wNlB6ksH6vofK5mM5zMgsxwKJh5z8Tfu14GTkcMxJ10xuG2z +n2MKjSOigZxlfkV1gKchS07M0NbUK1OTbmFTaGNYME4aGyL7iWmFpHCMWzvph9kZ1G2T/OPh2CSU +VABNIhGMIT+DS4ZyHDABN8yxpqlx2mj4sNAnY42koO4DWYoavKph0hGvTnGwxOCmId57K8K8C3UD +zRbDBGmQ9My5wuumyAocOlXi1+qtRfNhww+oOD7m4e9aNRambc3gM8IDLCTDeTu7N3ioUne4sqW7 +F2aR2TzKFsY4mTXnNMSyTn8ApBsmjBFw/ZQDwKOwhhcx704dE/A0IZLhYHUfMOxVOJ4GwpzuM9dW +GlvkqwDvW1hX5JeIhtWask2tsVJw9JZjvaxbTQCJiUjeF75s23nNwnUOaxUqtUqIhG7XlqxaTIXX +cPc2KGWY12MhK6X6LwsjItUE3z6WROgxv65Fy/I0Fyw3jayBn+knlzRM69RKDyLgw3ommrF6WiFU +z8FsVoDCtNia9NJpfVBDv4YwU2deUVFfYnPV8DqhskOILk71Y6mo1vgkF0+BOrnlOFge8dyqGRDP +8Jg5A1ky6rokEhTsqrx+W3llWoZg0K7JBOIuCRJYnDxMLiBHHFnkCo7g2PghelShtyQfQgkiw5jS +dSIRaVNH9gRDJPkIysLUKA0A0jocH5A6gCu00SkmMUTQuEiR6cxtRi8QhFi3RMm2rfmXckIJu6YQ +0KbGVRBQPBk5sCqUCpFswJ5GBqwmhab9sKaXFzJz2NZGVrM1ZDV9QGYPS7ohsnYFQY4mmSCbTfaZ +X1PeNLL/m7aBQkPEPTXPHSn30qjxRqYZxpJ5bYMCVMiXRJMmThgkSFlTFJHTOHwpS7feK/GY2+0o +i9eq86MX6aeRj41W6Wm8RYHBjX15KtLk2gzZTo2NxulWtdWVplnCwewaFbt4nNPz0dBRTlOowA2E +dIbecoehNXRKYMolfqWpHh2zM+gVk7zVrnDkf6mWsNBm0E7YqChpanVhhAtmgM5J3qjoI+QnhEZN +64Kc9Cylrz06CO4ZhnRe84rtJXxPkrnPwBIFJxw3+B3KXsgdqKwLfQnwjN6DtQcuHMPsKKetJhWk +DsFqSbCbTaUOBIOZ25iIVDCmAS1dw4PNGKfugbJ1ZOAltOYYqzR2SJFABVR/GHVrMHrSXaF0IWie +DUNFQCukMVDHgjzRWCchIKYFK9pwZivvsMfaNaWtyGJW3XaMqyvZ+ZjQIxoOhLgmqbVs5zV8RHe1 +En7z8n3l9W6ScbkKcV4tgiroJ0SiM7O/wXgLEyuZloahap9MNxYvzJNcTiKyUmnKl6Yawyzuahin +qgyeLMzWV4dWGdImOMoptexBimBU5WI/2Va1Z9Ql6xYzlTqIqUuV/A2suFIpBwDvtVALkZuynaW/ +DhwSeIaYaFSDvxy9vminrvUTOg2qrjUqPYPmOSzIUgTlYVUbYit1EoNUyCuwzkjW6FEgCAf9s+FX +hh6Inp69Wk4tOT4GoCs5pIhCzzNVm3TmlUZv8ZzO46ZyS3BkifU+8Pg3QgVPPQMwwau1jQ5GmZDK +QKZUpYVgMgm18XSol2k3qqb1YJ4MUoKCqMLTFkyIEIOauXdkrgIEUb1VbFS6snKe0oMvBIhqpd4g +TGbUNYy9sjKgdUXXNXykZ5N1daPeWsbZtUUbm7LFwLBeKu8yr8uCUfDdZy5mJoc15pPFl6Wr8zTM +h6vhTfiyZAReYuqRaNWFh45JFRkLHPmygzX0FLESer5z18PLHWKMmh9JXoTY855c4U6htoA3MK1b +QfUtkIvh5iT0oobClvoo71VPRZ2IRmY4+vK1ulOdvoHfpi/pIgrmxEQDFmOdHbwlS92yUePcHEaH +P8AiEYw4VDDTkdGvnMaIlAgzofev0qZjOsWqistBxJdRyLOB5z+oSF15KmOGE7cxs+Hp83ioseiH +sMsIMUIucFuHKirSZBKkXedDr+RokV5LCIaFtxe8CuCsBipdOdUYyPwjmkaFfhyQP9AY7XFOQxTz +bYzCnRSGOu+QutKqbmXLNb5OOo4WVMlB1sdNFXNaPVJTka0MxT1bGrOuIJIcGSUupSrYjuZ2l34w +AUpEmgDKtgyfzmksW5WnIBDwZi4b98J8Bug7EwIUJrsiBl63TfRQr6qotayaGLtVqa+uSI+tOlNY +uE7RZ7xS51jAcPR7ZLix+hE10HBj5tf6Sd1GlUOL8xqbkUkNTRN9WXEgtKQGiM2nTlo+jQ7YDLcJ +mjVOeZhS76wDgaCDuxw2pGoWDvJt9EUXKRtusyAYLQ3fSI3ALMzqhGyppnEEwMB4DLNFSS6D7oJl +NPbC4xuUjFRnPIkb8xXMFliqjyf+tFTSt6BEPtQeadzA5YcY2xatOrYpwaLXpW7mmG3da9YmDS4Q +6gbxssE566GssiqbQE8MHUHrnLwv63tKO5qI4IMoolh1yJCrIxoLatgXVbdB7n1e20e4JdM1TRmi +csO7+4piYVp6Cggll/cqo8zst9EAYGo3rPKxn8xdLFyjJyAeTCMhnNVLyygDzUYbeXjIH9jiUGDj +dJV9Qo9i5+M+FiwRnkANejjBLR2UGCKicYPciAYBj4ZfVFCOIrBGbarCCCBqAleKqBqADD7UDtKO +RpH4GC0BORF/W2i9HIOZePDT+uIq8C8NE6zD/atmzGZrQA7kDKRhw9D+AXrjYjyUEMAaFMSVmmq8 +PKRGkw57lm7kGi/D+Fmqd4WagWjRmAIFGNSxQu/G87Uxh9FWJcMbK2a8lDYbDbExYNdEIhCG1yJi +oA02KqVVnwGrYMlQAy9S1Ao3flqvjm+O5J+8ucxCq9nOXF0r0UDEIlSaK3j+CfGVI39aWDgC2OIg +ZVmHq0yxMEecRw8zCExlXo7fec1iz3twHIg5MU2gVnlasBLq4lMCAqiXjuZ2l/JPwDzJLIHA+ebT +uYzlK/MkCo0WoflzU8c/EbHo3MfzG0xauubEUAc6dnUgeFjRlt3GODE52JhPI/1UxXobPSgIKlja +d6X759SAygwR1iT1QKwGARAwfJX9T4YvaahbhPR9jsUng7h3HzdqzI7pE0WqYtaLECdEpCOZUznU +oggmDLVFIKCd5FWkgAUbk5cTjR7k2c0RvhJOLXg9adnjLmOIofHROjiy+AdKN0KbPHZKPOQ3b/po +adMsDcO9V9tJ3H7/GOrDpq6pU0TKgDNQCd6oGyCTXhS0BJ14KfRihNo4Q8cs/Hoiz/8s/4Z7mvwb +Gp7S53AtnyhABdkxRgEqCvqEABUc/PcFqGTv9gEqOxugso9NSVnvni025RMT3+1DVPYhKrsUolLb +B0NU4OozilAB6JEAFfOMASpmToAK3ZoG8Sn5wD5TeEoZ7whND12IipkfomKzqJGrHJaHqJhJiEq1 +Goeo2PIzhahoRYMQlWo1CVExkxAVO6hoPLbPFKJi45Snhy5E5VNjVJpxjEoziVFhNPUgRkUE2GGM +im0mMSoCGsSooJZhjEozjVFpXiBGxUa36PTQxahUnzNIRb2iBzEqny1CZRifwpZ2PzxFxco8PIWQ +PDyF6WC2JTyFncnDU9IAuvCUfESfKTwlJgYp0kMXnlI9S3gKxzwMT2kn4SntmvCUdhyeorO3reEp +rUnUVx9SeEptPmN4CvKtb0t4CnO/v4rwFKLMw+EpzYzwFDsjPCVyDV14ihmFp9TtZwpQQdKoTw1Q +qYMe9FsaodJozAYv7XgwQqXq4j3smrIpQqV5OEIlzGv2oQiVQckHI1Qe7vE+QuWlI1QaZdR2I0JF +yiwPUGncowEq4FX2ASr7AJV9gMpmASoyNcMAFWg58wCVsq2nASrlhgEq8K4aBKiY5QEq7ShApZ0E +qLTh4QCVchKgYrc8QKXpAlRCjNng9aDw1NfNxFCRZn6IyqB4ClIJa4NUQhJVazOz7RSlYlKUit7L +Oi3JQJUwP1BlVJyhKk2KVPkM/qP7SJX7I1WwNz5LpIqPFwp2kSpRo9dHqrhNIlXINYwiVWw5iVRp +JpEqbk2kSjuJVAmzIlXM45Eqg3l8gUgVG9UdRpP1rg8YsSEFjIQ8UoVlYtjH/YEqsOZpoIrNA1Wq +GKhSNjPb7QNV6hioYtcH1yBQBTehrAlUeaTHMU6lsfs4leeLUynNMFLFPBqp4keRKn4UqVJNIlXs +KFKlfjxShdemPE2gSvN4nErit7YlTsVomIpPYSp+EjBi2hQwYtpBmEoX9jEtGoNUhK2KQSqRQjBI +Rci/BqmsKbiuzT5IxcUgFb+uIINUypCCVJpmEKTyQGfHISo4qPYhKp8zRKVpnzBEBcrLYYgKvRQf +DVExkxCVak6IShteKERlMInbEKJiumANZ2aHqPhmfemFISqPtn1/iMqk6KwQlfv6vQ9RedYQFagR +RyEqcDUZhqiYx0NUylGIStUuD1HBZSNPHaLiF4eo+EGISj5fLxCiInJhE0NUYqxIlcI2wqMRKrKu +MeajNNPCKUJFtl6MUKlNF6FStjFCxc9rtQtQMTFAZV0xhqeEtdEpD3c1Rac0++iUbYtOUS+e+6JT +srefEp3SPBSdkr3cR6fscnTKfaiUolMWItP90Sn3oVOMTlmIUPvolLXRKX/7/vtBUMrnvXJIb0hF +GAFc2elQ1oP8YUIN5z2jYFuuqoUtwzUd4IyXbOJWv/6TZlhH9xybUfsMQbxYkEkztA40P2gmAeKN +hehK903qa1fJeDzYXuux6oc/n/zjT98KRv3m7OL2TBbYvvnt6mtegVNi1eVlttAh5iCg9GTUnAUP +GU0UQNAJQEI4Ajkd4XgatVkhxgDyk1fHlbbWSx9beCBF/04ME9cHllGDU5UwEAk3RQ== + + + t3w0UBoeQnUd1CgWQQUCeJAz4IReM4b+0vSEqXipIO5XFXjlAh6HQzieDAo+8lyW2mUDpT67yb+C +1yq4FXhGhFJFSc+Lo/EmNKqPihDckBea2GmFJTQ5ObDpLt4Gdwey1cZU9NRuNV/kqDvHkw6ebNXF +ZFhFtxI2qwVPj790JwK4Us+3Z7ly6fvz09uzn/VGaY0j+uyUA0p2BEFDvkDCpyuCAhTgVLpS0QET +K1ywTLR7QN/mLaPVubeB/lCLyc8KF5bJsXzJHSFyDx2cW1+qLwY9f0SYqupKAXDMWsFxADco0O3f +NGic38pcX0Iq885XpCBNbSgtycBLalLYJi8ew6WXcIpvIl2yeikDxSA5uy4ZiUAJCNerQTDDvb5l +fGY+RdhnQCHbQ268s+nsXBJLJ7En7f1RKB/jf1g6SuMzFg8xI5NlUeDihcG5P1kaADdYHCk2XR4B +brJAUmy6RAAuXqQ1s4WacGD8gxPPFfnqTb8mS9cCKjZLTW+AWZtrAV9GaAAcypQITMKX0LeVNBV4 +GxoFwncSHCnE6ybED0dV3gt8R7KVOv6P/EqaEIWVJ7lqvoWMbYhQNWxgtNyqn30CGa8aUQAssBDK +kpbHADQeDe4dteHQkkOFmdNhEnhtrOEJTxEWd7RDUUulYGX0ZGCOLpxB0OHijlsYhOEMBIdPdI0K +F5ccQOFTVtV1B/FIYWq5DNZhv6izmaEvZKMaUqc56tJVtbwk1zAtpmld0PgnT/cU3iHeMBBORsM9 +AqxsS0SIiXCgCmOZFGS9HM9bCr9LcHJS8t3VAeL3qJxNIMGeyvuYN19ELm6bRpXWuM006E2umB1m +HBXeW6N0at4Wqpc/akZD2Jk1Kz3mSss5vXkVjrst4yJlN/ka21uv+YWvDvw3RGxy0IIcH8BjR8M9 +HBzkwIFQ9dxEd/S0EOmZl57zV4LAugZ9vKMvuWHgcqlX4Vp65BzD7KbehQ1ifGqmh4mX4BhVWsv+ +iQ7L1WFVlyxk6alH1ZpGqKoDIjRWHploeRum3r5OAsm71eNNJwA1Ti/XLE1QltXRvChI6J3tl2S8 +aseTdXz4tki4hsqSGNvO1Ghs7S3vTStcnG9wWDS45b0FVsFTAXfqPh8/dHd6uypWIvL9+tvIEMUb +XGeStRKoIdtaJSS4SPHw5E3SJwdxzwd1AS0JgonRVrzjV0SAKrLoJb3FgLPekFKXlIHrtsbDmvdr +qpk2NulQ39054dWIrkYcQY1TG8pSD2c6aHDqqoX2a6z1sriUWF2Gi/gbFgj5vqlhvSxhaB4Eh8XQ +atmftCU4aCmhUnalQzwLlCRCWKFArOLVz5UwAg0IpQiFIsLHyGoIR9B3Xx3Aq7/VYFBHjfaJgJqK +HoL93dRN5EEAKnX6LC/LotGubmGF54w63B0ldIJBSSdUiYGE4WrqwMtk4fNnGGQHpx6vZEB17fAA +Dbw31tfUdGM9IIpxIRBj2lR6Ae/kfTGppJg2VEx7U0y7XKwZWLFm/MWaaSrWzGY22yd9LDj8IhCX +cIW6vWE8jPrPsD1NwytnZ81qDYbhGMR8wn2TkoBaXklc0nXaKlEdvxyUHda7puWsa6OH2XHfGvA9 +GONXb9Y0JZR00Buhc3lX5XE8FNTaj1Q56/EXxaiSYtzIuvkedPfkYBjY7ZvI6IHQyakvyCGEBCHY +bcwhIdsOKtqari0J0xg000Zm4QRSlEbj4M54WHcwDuvpt+g04I+GniZEeyTMXMdUcjMKhHoN67hq +hs4lBdLQB8bk1wxw953L/skBnPhAhgr62Je6h6BFoOnzBHJerRHJ/QcIb6Mqpq8GoXYa8Nk3Rj0m +LqjK+sTYJQQcyIIwDulkOlMnDyi7MWRhtHgzYdHUcPtSl2M4FU7oZgtGCMTcg1ED++eRtqRmtGZo +KtUSV/AFEiwIVs5LMsg/IJZWGBbmPob/MuJV1hWtS1WoBBu8GoGOzjZu9Whuq7AqNVRrlx56raFa +ey0vUvYsRLk6u7l6f/Px+u3qw8+n789XVzdvz7Nj/mG1+Bq8VkX3CLMVOMJtiqCbYLdq3kf4DWIx +wXARHyc4/tWbNVjOrdzjOUXmCaYLdIrrJA0TbI96+xG+6zSMMH7NLJ7cr49fsHSZetxsF2e6IQPZ +Z4n6+KnsY3s//+ge4h/pz7uGf6wi/zh6/yj/6Dr+sd2YgTRqMm0hCIKpM401gQykl720JjsP1Uw+ +pW6IDzEOvjXML2AgitYZC/mZcvMMOEhLF5chB2npYTTgIG3klpZzkI48Gxyw7uUg/efgIP0sDjLv +zRIOcjT+Ys00FWtmcx4H2bYLOUj3EAfpFnCQw5aXcpAPMYzDmucxjO5RhtFtwjCOu/IAw1iXY4YR +G2kjhhGRLE/FMNateZhhVHt82zSzGMdhdcsYRzthHPMZ+8yMI1x1lYVrlzKO2Jdk4fwsvtH0fOMG +jR7NbPTF2cYhdi9mG5fj+FK2cYia97CNa7H9QfZxXO1y9tGuYR+HmP+c7ONyZu7i7Jdz8HN/O3+7 +CTMHe1qjHuSwQiN1p0KK+DeB03MZbYL8pns5/Sr9OjsYvxsXziqOP+n1C3iNMDSYMoATzmgQvCBB +WQZ4awqPV9YlvwwIdTpBah/jHfOXBK86t0p4hK6J+OO4H/ksptAYkjnbegTSgHcpK1iVSro2gBpM +6FwNrEpXS6cHeEpWh4JsoDEx88lEs1hXlRAYqDFl1J3blTP5D2dFxGk5vBA0SorKxZS1EUZRTdtY +lXVIAP1/kaD6WKrbq0478wQ4DQVLEXrMi+CYk6s1tAAYukYYrhDisDDvpsb5zFwHZUW2FuE4qQn9 +q5kes7Zjv0bdLGmrGfa1mHxTpDr75I424nHKIan/5QCtmjnea8YNpZd852AlKilG078Yjn8G5jwH +LwheEagXhuLZMSUjII0m0CHEMCDf6rPR58Z1j5xqpoitmTQKlIhzZjzwnD7HjvmnGJ0de5yPgn8Z +zWdXOubjOPZN9IPOxuPi4UlTC/MD03ZGY/KSiUOa24VT99Wb6eTdC3twStHdhyd1klqyzRjKPdmc +RTYRRKlcBI9pJAVjXHFJ0daYNeYYHzRLLKlmegDVZOybU9asbpQ1G+W69a6kxb8VYbvhDyG2TKMl +nKgSSeHRgBYl4uARllIiMgrRSnuyuSebe7L5+clmM5DDsSXAEon4EVp6ESVQdsUVeHwobtBBqsN8 +xY8T4EzkZKPBwxGC3ICQGeCEg7gRpsxhTHI4ZApICICa9aygr01owfMzjQDqqFa93MFHDU9ypFoE +4P/0T8nBACSyjt/G6iVysCO3rWFeh0ozzzk4wDqkcaLRU1MCawImF8Ml40SgknSODObqoTgFkFYn +cw2GtKgsLplE0BOc29Zwps6LpEfVGHKJIxayAkkwKh4j0yBjf73eeRmErVT3FJHAa2Sv4z1SyP8M +F6E1RWXVNW9dcBVDThlDtGGjRzMbFbEQpngw1nSLCwviEdbgZQ9chJmQaxfj5ldvlmKnUp65+Klj +WYqh0WtvIY6Odr8ZME2DNUhnrWac1FOxUd/GBtQQTpBQt2JO6NhocMSXNU8iyEZyoLf0h6TCShY9 +eN8MQPjKI0tSUzMdUYucJ1J1HQFIheuYUsHFRLomXvkKL0ZNax4D5pkSjCHGyLLCyOWg+RqZmoUO +VgBRo30CUAzCxleOSttWXejo9adsGZNX19Qqm/Qc2TneKCobGMHS5CtaeKfxPl9MuitBuBuGTvNs +LI2mZ2ZGspMD+sAG8B7Bq6EEwW08I+gdeEJeBJ6F5EUa5UU0CS4gOIMAsQzuRn9sAB7WJb3zxuxJ ++nWvltDXdMuRylpme6+DLA0jqtpyHYkChtU8U+G4w/wnDnFxvEYLIboUpV2lectkywfNAPkDE4KK +0KybEgGG64sKa1m2NXKX1KXumKOzjVs9mtsqEv6UuJUcsdDc4DmRMsOUsmu4j7Rn1Hd54a4BGZjs +G+zyyc4BcPneEc5kk93z1Zs1+4fA8Q4S4Pw9pMzMkl3EEqN9JLDxTiIDNtxLAI13E2Gj/QTYzB3V +r/bYstHY+2jqmKNjCmI6c9bxvgQ+V/Bv1bsC+AzraSCPx5QxwcZJKxkjX1dITAcVMJf/qTj5EeRB +MlLKtoKEaJgXD66uyKe5TgdHxCiRw0A2KvLCOjnRGNoe6JHNq3saA7kSqfbbptW8s0gig0gfXtkO +3BkXQyhwVePa37qCzzkzMG7S2tGc1hqHDJ8MrkY0Vl0vIhtTtFDYIsTgzRxLUeNJZZXBnnDL9sSw +LmQCqVRBwpQjHiYiXLjZ0EP+aXD+Hgx3lhheWegHoAKpNQMx6GdJW8xEYyJnFhOO0g8vxiJUBkwd +YhBojCF3zLRrjJZ3rYxSj0ohUC3JacPAkrVF25iYzMLjv1HsM8gJwVSUQtz+f/beOz+RJWkA3Atw +B2QQIFz5AuTwIAlJSCBvcZIQVph+8+aP/e0F9jh7jb3GXmPTlMnyhenp7veY+aY/VJUVmRkZPjMy +EtJpf8On8MJnKGTRJYXwundJVbroFWrZOL4iVdp3J2neNZHrqWb+tV4ZEWsIllvlJlCt3gC0oC38 +5n4PCEiwBKyrAi/roGBcQ5Auu4DHKmh4TW2ZeMTjm6fgVdKopJb0Fbz2GjfAfwMjXf8I7lHrvooY +4EYMncPLirUjLOuHbMlNCcxNdIKGh3m8CQqdskGJokZdoaTNsyI+QgRLrqG7H6Q3AvJteTw+ZMKB +EfNqwj78Fu4vwxQTh295AfiODK1N15+z38z8/TLwTjat2TmD9w6jTVGVACLojl8RX4COzumWyWcc +vrI4IsCUeBHXRKEYeBhTXXLpSdZjeARWT/+dwMttJNDqA6n/rAcN0pYGfn+y1WPa2s5J4Lsn0NUT +FMoFtKNXmNXMOZINj6IiWmqF0B2/5OGoOT2xztNpZu5OGVjnjqXjc1k6RkqGz4y0rHk6FzX7Xk3o +2fe6EEWDz/Q0DR7paQY8MtI1+dA1ZcNzFAbahqhYiLoxDvVjNVK4Vu/xNFGgjVBP0GOFd0TDk3h9 +yOtKdxJvcyo+0RX2Ao2v2UfXSGmmKxoZWVT4T/dVxAA3ou2bQ1cUkKMre7R/2QZlYZ12GIODd8gw +MA8TmstWjIyvzKQodKcvvFdPxxw0rDMB+TAOL2bhEixDMjPOL0XXFNh/K3C4GgHBzQv0nFmgZwoo +PWjCqixNrJEgcaz+CVIXeGmkJzCwksClzVga+NzqikFVzwlYWfxmBEQOUcDn9XTTiOjnaUBOdrXE +hi7KjDuvOA8vCYzraA3d/yowjl8D5wGVbNRS25xdZxbqGgafgApxPom3iLnNLGdu03pzW4gb7BYh +rpPuSMEQ0l2IG+wW4pFstxBfRQxwI4bOZbuF1ptatDtzOwIDh/B+ea98dRYNsx/t7JcIx8MUaSRA +UPUDgVxRKhGHF5GgOhu0WuOD+BpGDTnG8esEhUOj2iuy5u07s0jf0GaHxdu0dre6Yg== + + + giz4RPwXtpGlqpVe2UxANwLBS9SRMcGhE6g0CqtmPRr7Ajq4ZY/GBoGOqcZKkYlIjCt/a4goTog8 +dEOO/ChigBsxdJ6V3AVyjLL5S04EAefjeJoafDjIOhZeCMsrJAY894QNieGAMYUvowaGpV5oUIkE +IXJE6LjrpB0Hq6Gxjl/j6xnjemk3Z9+ZhfqGm3WwatEc255aApRsW4UEsVk7DxEi81VPhuRD14So +GZxMitC8XIgYZXtfS46yteqWIHXnwUSrkCOGShv86biJPx03eCBxgwci44Dwp8lHkj8t6L0PgQCt +PtD607ZC/vfXS3pM/wx/WivSsYMKxuXCn7b80tmfdurU2p+2+nIJf5o28ae1tKx5Ohc1SzJHS8+S +Pz0vRUv+NG30p2mjP62la/Kha8rWyCi9Pz03dcv+NG3iT9NO/vSChi0P/3w9Hw4q485g2hl8RCL4 +MTJ3yRee8xF8E8dvKr0Z+Pei8dVuTj34gklvZjybfHrP6oP6R3sMTONWexy0f+fFL7P1Xq8DOHX0 +2WlKLWvDYS8GTOzRNOq9+FEHv41NgRkAQJDtedv2Jk0RiEKvPnVsz6L2VzC9Q9sWgTD5QLT6wNgW +T4TmjV+ABb0YVOrTTw3o7Gd93ByqkwStEAiTprX2f6beXOdHByDcHmgNgaiP2mMgNqvT8bDbBgOL +4jUHRKJZ8RVTjgViAIWQSIF/QizB/6Mo/D/0l3QG2W60C3Wukh/qmoH/FbyoyAXulv4p3bK6KbPg +v/KEif+uvF+MasgNqFvey8saM/GzO1VwDDulUYdAFnpZjGT6J/Qr6pAsesV5kbxKDjDjSTAumdMR +Mca8slWD24DmXibmlf8LMRXzInTRUUaxbBZFncWIahoJoRsXQ5kP56cNhpBuViiCtyZ4BXVc8MQN +LQrwDBHMj0S3McGDmSKSf9BtQKOm3I56bipI4DfyVcwTT+x0MPxrgP4AOhvp9aA3dg6m4Q17Ymmg +z3+05bexrJRjWOj0wMxge0AjnYEXN8BPsaUbk5qEgbEQu+lMOo0eAmiEUJ3Wm92lIMw7hkx90mmq +n+NFxiTlvXh/n7SBQqOtv5c+OO71ZugyjOE4Wh+NANLw4oCP2hL6Ahqg3jJApTf//g7WDrSudaYI +HIP66V2MpcZggHa3dMdwM2lJwCivPICSRIpGZbLiwNBm0D0NIhcXNBl7cTlRD2buxVGZM5qF6X13 +afPYIWhgjB7S2EaP5drv3j2vxxsghgPTTQPHg0kHZp4qV+3lOpNRr/43/jOIkYmvH8GfYuTIn4U9 +e140f++eB2C0Pp6arFim1x605lhwW3wiYCo63QVR1fmrn1sM3mYe2eGgNetM3cyBhLJyDoD0tyJ0 +KnfLXE/a+R/twUWrBfGCSFxF8ly3vUgFJohcL9NaE8jHhnVZUIQKXbwHD+mxsHQtI1iUm1DXURng +P5wG/zlT8sTy/2k3Z3AI6AX61kyfwfvbhLVS+5OUmlvhsFZGa2X0K5SRmQbCO0M03ARBm4+wipyA +Ch7h257XGugXaiDml2sgca2B/iQNdLXkFcsWTpUJya1dqrUW+y1dqrnvMl8rtD98SnMptPhaof1p +Ck2Is3GUOseA/8/DGGAizrP4YleegzclwPx/KTzN45tpKJgUAqvJWccJmXWgcK3V/hStlojjq/Q4 +RkR3TPKw0g06hQJzqBPrSOG/XK0l1mrtT1Jr60jhWhv9ztrIIlJISeplrWz+zcoGHp9cK5u1slkr +m7Wy+VnKxk3uwVrp/O+mZEh6+AVqh/291c4/S2nAwBsjUrAmLrr+Du0X0SLHcZrzeaLI8BwuGE2x +KBInwtN8/B+3lbSgxP6nyFs6jm8dp2AZEHTZJJa8PG9SvGtOwfvPkcFziStuLa7+t+JqqdJwa3H1 +J4kr6c4Eio2zcGcISSt45ajAmV3fsZZXbuQVv5ZXa/NqLa9+qnkFL/inVfOKFVHRv7W8WkRe/eaH +4/9Z8uoPiiH+uaJGlfuWP/B/Ud2lueTSWpo4SJPf/KDzP0uarL21P0UkrfocE42P5wJRloij4na8 +mOAoXBKUiidWkPL4L5Vf63Otawm4Tn9fb+3+kdogweFMJUYU4cWC6CbeBMObXE653vP9w6c0l1Jb +n2r9o5TaHxQk+MO4Zq2Nfm7+OxNnWQ7VgYX3yceB7YXK4HHro67/7vx3gfq9NdA/S3+sw0L/2rAQ +i/0AWoQlx2BpD4bGQSGO4YT1EaQFpdf6oP4fJf/W9vPafv6dhbi1/cwyCVioBdjPogDUMjzUEBUp +jjWpLry2n/9N9jOz1kB/kgZab0v8KfJkrch+8rYEKhVDcxyHbpehYZkZ5I/QcXF5f+SfQoX/nCnN +pdV+80y0tVZb+1VrdfTnqCOb2zakc+JMfH0T77/ck/rN0wnXOuffvZfxp0qTteL6yX4UeB/lOEDw +2H8SGEZY3+XxL/effvNU07UuW/tPazX056ghK/8pyggUsMG88v0AvMCz/NqR+pc7Ur95pt9a+ayV +z1r5/PHKBx6KAE6+wHuVIB6fSKwzWv7lyuc3T9P8Z6kOGIOL8yIVh3u4Ah8XaXi4VKAoEcXehLjI +oErWFLxSBz6h1eIhnEj9iUWG/0VHik2LP+FzxEKcwqfR8LVgDMdRy8ec/jlCeC6Jtc7B++NknsDz +NCegi8VEWCvd7D4ZFhZUT2C5iCusx1ERwHXBpLXd/UeIf6e9B5rGmX0JjqPj8BdH8TyHk0roBCes +jyb/uxWb+Jun9q0Vm8mGOsdSCai0EnxcENEPOs5z0KqnOBarMTHOsTT8QUNbnlGt+rViWyu2f4Bi +E6SbRNmEkEA3aHFxmqFQJ9E4R9PrCrf/cr22Tvr8o/Taen9jrY5+Z3Vkvb/BscCIRrvrPBOlGAp4 +VFGGTjBrz+rfvckhrpM+1xporYHWGugnaiBOgBs9dJyiE6icghCP0ok43MNLUGsF9GsVEP3rawWK +6wzNtQpaq6C1CvrpKoiiBZGFS8eIUU6M06hoIrXeXVqroN88YXOtQNZHtH6F2GQZJDZ5Jh5HZ2M5 +Ad6zgkrbwZN63Pqc1mLiZp1T90cJLHQ2lRFZlPzNURw0IqIwBxwdypKPaaHEcODiQn0m4hNbf96Z +1D+M69YW8//ieJawvmLrN7aff706+82re67V2fq6kz+I9dY67X90iT08mRXneEDs8OwxT3HyiWOa +XcE19v8UKvznTGkunfabZ57/8zTSOvnv3xRZkpL/xDjNw8gSzv0DTgW1rh+yoMD6qdnKpuLmCsL0 +ZofjQXs8WZW40QFVRIztWgD5c9WuA9qF5DWbWLHgysWuJO5cf/97RM7/udJpQfysJYpWoozH9b+9 +peG489/hYArY6ikgMt7R9Cn4R9lEa+b8tzMn1jq1cX0weR+O+6tSUQRAd+pJwc9U/rJSn4IxDCaS +LYmV16RZ77VLr4V6E/SO3lCU7l2lPW4C88n42Q3xmfLReDitT9uvufbHuN2eBMmRoI/KnQF+rO/o +huxID+4K6Ng6HrqoKN7+8Acc3hQ9Tnhjx8DGCwxm/exw1MF9cNLDUWdQGXYU0Hg44/Z7D7gU99qH +9UFr2O/8t23W9E4zNNj9jdz9P88ZdyW2i2CRB6TYLkrGNiG1q53+qKdI7XnMeWzH4z5UwPA7dGOS +hdUuOQFgJmDFrYd+PADWnrfYG/7l5YGiWauZtZr549SMSsP2eiY3Ho6qn/XW8K9ovWOuYEhQ7jQM +LQnXj+nfI3Ov3eRaEf0P/N+7+rwuvorEj2YPaSBelsuN3gyrpKioPBuO6s0gZgQ05kZv0PoXi+1K +Z9D1Zto/2r1/sQPP/68c+J+ESSk6Csy6z1XhUQPSHRY5xRzqdfrIPlN47n0yJXnuazAdueS5XxFi +VEWTwLMU3pVkEiIpqmAuvRQMFkSOX05u/T57OT8lIdByHmvbZb1Viux66AnWx6RhH6UYeBuZl2Z5 +yHQszBcW+dXfiYoFYmH23//+7T2rT7qrEp+FNhCcEN8uDSjFlbyy1UB/tkHyEyl9rQd/W1aGPjqH +uJixdNQXcoT+OYzhylLHXts6OLFW8L+LdfwTXfnF9DgMbnhlPlkyCqKB5U7wm+CK4Tl4hpGJC/hM +I8YS/Ku7OHImUpwjwkRpQdYtn8PxfzVnQ0b1DmpFNvrRHsvRe6SAmpMxCobwiv3Rqo+78IkAHBw3 +YRTaOYzy7xXZj+BpfdabPtvHwOfjKHRaCR5O4hFFJQR0zaEYT8ArS5WZznNI1jxI7ksfJ17zg1Z6 +PEWjncAnPHzyej4cVMagdWfwEYngx5k24J9KvdeeTttIwlYabsYZeLwCHyIjDGDyOYgW6+6/Hv1z +T6U5H54Ct5+daVv6zhlddUiAQNfpO0pwAs/Cw8cJVqRZVhMCkL67Kma8V+2W/GWCTSQ09ygnWI6B +6QrkENUv79s9GGjFHwu8KNLaMIOS3kN+hPZBpG94kUpwItkhzXI8w2m/pZVvs3/X5U/jcRZFNUSR +ouHtTEa04uWQvsz0ZjJCWfAfOo7wSLEJxnQhyE/P6h/AGKxLX9MiI2KkcnQijtaF5/EPShDiCH0i +L2CZqZ61EwVOlEAewDPixQM24c0ccLxx0WgWL3c8Dq/4QK84RkQXvMs3fcLT5OjuT44GkCWwDCsC +sEwcgGUFPVhRAJhNILBAqmvXmOMBPJibooxWAxY8Kh4kKFOwPM3TDL6glOYSmmVICPCmbdgGzx2A +RVhQwMLR0uBfAJfSw2VFjhchuDidEDSpYtGEfPGpkMC3okQZFqCMleHycLhw+JkDPiHDFRmW0Ywu +zos8x2jhwqAYonn4H/VmVRkuA7HLIvSyElwAldIMDmJXELQdYeTGRUmBaqHSaM0AxRNQeUbUCYi4 +kMC4VBHPJSicTCohl8EpBxKFcRREQgIOVpDBAsLVcUqcB0ykGS3DQCKAcGUSYzCWMVwerVkc+D4H +IiczIiugDAcwLxbhL56gGQGzcIJFF6dBGpCNCRFmREjg0CA5uFKCvFJxkY2jQbKAC+DQQPciCmMy +LMXGca4gR4k4BQOmCsYFEhoFMcnLXCVyAotSNNSgqMiLnGbKtLzcypQxP2CgQPjJM6ZpBSxEJJoh +ECQoaZFjGV4gJCwcpYAvmgc/DKMUIO/TvCjDo+IiohqwbpRoKsyAHQQnjWaAMAhpDXTAS2A5TPVw +nAwjsymgPQYezAdsymH0mwjJKMdB/oEIYMEq8eQ4aRaOMx6X4CXAT3z5EA3WljMfpyxU6QRYHVFd +e2mcAoDLoelz8jATAk0xSJ/BCuBxFn/NChRCiZJBIzMQiwFLDIT4BwonMCQZnazAIh2SAKKaMq8L +wKlCGWbyIFEl8Q4FGR0sHBwir7AkICQEkecp3hSiKuZkMcrjJZNZUpSFPs3JLMmCfnGxpCigbh5x +NAUQgBca8J3EPqx0VBtD4uMAEpxyQoZDU0BACFjoovPfQDexIl5wKLIglyIZSaJRug== + + + LlqSQ4yMx4RBGCfoBIcXBaBV1ApjRSVh2Q56lncUFI3EotVhaFlmCkDcMWjGDIXoDhgdFK+hJkUz +CzhtCvxQdGcCEXocMZA8f44FsieOaFkAoh7+SACZiZUyl0DdQfTwkhTicDEIGZ9QHcOsTMjjMk/C +EopoPXgo3xATiRwWJgxcNloRFHAZJdXBkooT3lEMFCdc8bgMFVAER8ORAOJGooECxCxgASIgI4JV +BKW0TgwW9RhmHA4VcbkgkybDxxkaTZkSgCyGA03EEQ4oGhBSnFQSAhwe7IVjiGWCegIggBcQF8mS +mOVpKc8NGFhSKoEoIo5kMTMI0vQ5LIiUYhsSVAGyOo1UW5yRgSYEHnEzaMcj6GJCRIMGNMGiacia +jZX1vKSTSM2GFJsiPsGXeD0gM8UFLJ8EkcNA4ki4c3L5D0amKFq7VpBSkdGgGDkcEIdIpgsJFlh9 +XmzvJCT7RFa7EpMCvlIRmoAzx+iUsckB653Chhi83B2OEcgUxLPANsfrLI1QudCdwoIZw0TYZJE8 +xpxkSNSqDt+nXuQIeG86HwPozASlBlahS9NvJOAAYqHeanunQy92R5xgaVurUEyjqjZw9O1VSGZH +qGwA6ZqbIg36BV50LK/nHrDpRxB8oPo9q4/bE2968NEDbpUGDP7vIwHz2TsyfILIBfEDpBGYKR6o +pM9rF+d5Lw24Ogth/sejewY/oiF+6n+jwwiVD7eOI1b0UEIr2lPgsNEg0sDKQbJKEIDFBQEBAwNp +P1q+rEH/Q5L7kFYZSP+KKSICHYIzkziWpbDo4ygsV4ERilQHo/xPsjahTcNDYcfLykMAA0DmGw8M +bcQkPMcDTkIsSWPTm5XHpP+BoYqI06HbISpSGRhXyK7hGch8SKTxcTQmIBtprFCU/5FmAvwXCk1Z +voHR0EjBAP2DxBqQ9iyP5IMsnOVB6X9IYBkki5EXB+vKS9JD4PHlAZSIRDFwkrHdSQE5h50h5X8a +pcazGj0JXEAGub7ADBcQJOAu8aTdCmxR+R4O3Q8Jroj1L7JjRFm6MTBugFwmURAT2OGlcQeqs6H8 +TyISikMmB9QP4F/ZkqGBCEffxfkEdvziQFVqjQ55ZPofstVBIU8NEjWjupZ8HLcFzjSF1SMwtrXe +W0JSPdr/L/uryELi4HqDf2WWu203vNlhbwjl1XA2UpgP1qaisXMqcHFzU5mRs8QVTyFBWowCq7gK +jGqIAreV1eJVwEuqmray5SDKZgkjlbySKAybesiIEPW2Hs8w2FwCdjgvaiI/lp48z9t48glJY8Yp +QBCMFh7wL4BvgHQx4XJheAycN2sY31yHWtTBMYgPRMUMkZ0KIDLiOCsScIQ2EiVi+0AiWjLEQMcT +KuXSGGYlo0QY5UCiGlokY46e8xGOTqI3cnyy3JlMyZCr3ZFkZTdNcwDOeBLYNhvFECFFI3AMkprM +hKbwq+rf/cawB8H8H55AadgHJkCg1O6NwP/L1CfdNho4UOzNzyC0FX6AUUEzIXBVrcImsx7Amjfi +vep8fE7JB7nhXwPy73L7XfP+ekT+lQGmzF/1cYt8VhiOpUcX4wb4+2JcH3zArqtTYGcQf2dm0+lw +AIjJ+Iwhn9XqDW0j+EDTAneEg45g+q2PNvoArpfyQPMBfsSCR1J8FAyu0+y24fhQgFYeLNTxQQnv +YKVIrFuvnkRtuWFz1gcklKtP6x7fa0z+25tEfxGbEvDvu7Py+bDVNn255w38p98bgNeR+nQ67jRm +U5yqAJpiqvtfgFgBfKJV87PTa40B7lEb+ZiD/Bb+M/171MZvAzuDyeuP+niyR6Q6k01/1OHa47bw ++cSiHcztxc2kkUw0f/2h2BkMB20XiOkNAYW33GBGbhn+tfNqdAYtMFDaxdwAcVTb03M0Cef5ka1X +tPxLYoK2xYSr+XfqjV7bDeE7ruqfxOjJH65ZHTb9xRQNp9ecTabD/q+VZD+PDpOTOty0hjoPsJhb +cvzpfFGF14z8NkP5J3Dp5P2v31gb/2I2mPQ6zT9dFnNxGJxSzgNZTfWzjVwIFysst/y1Mlg9q2Q1 +o786LXSC13FCUsNfOx/kQ9NOc/qPKxb81XOJwMMcCccF+tvNZP7+1ZNRTtdZTaMxBL5uHzrYF+MO +8BfdzMr4zW+g9JG0qw5n42Y7A8+srkTw/dkuWeW8yHCF4bhftxKNJALfO722bWMNDZCtf7HsMXlL +zmtaH3+0p8DggbGRyXHOzeyM3/zxDrqjJEC3bYzqAFzTlWzTtv/lNGA/uc5g2h736k13oQey9S92 +1rYK6D8u+LcPL0lB+xJupki2/s3XbjA8m2tq2va/+eTe0Wlxd2Sptv0N9K2zcvmfObVaaf2rRzMc +TTv9zn/RQfDfZUzAT/7VQ+i3p/VWfVpfdhyJJcex1ZJ2QNxwHNFYo0PTx9XCrTfb64y8taE3PZ42 +hnC3CTOfXuU7/K0HOhz9jba0PsbQjNWJEdzmeNDszYA4uzuraBcHv87NRsAYrk9RYkrbizI5Mu3P ++o+OLBADnX79QxMbkADDx97qrPE+7LXaY68andaN8nrS1jc2nz3DaYZWhVY6MSyUYTaA+1E1sIbe +J4riJbE673fcgt+x0nfxOb9jJLwk5vyO1lqtrj7DnwjuPpl4q9IlYIiEnVpbLBuj7QzQDqASywHG +zZHv8JW40FfCQl/xpjh0+IgzX2OHr2SKmusjiZwYaq6vaDP2d/qI0gpSp4/M6cm6uTlB6SSY8k19 +6j3DmXkGGUO2uR50/mMqCslGt51Ba/jXRDdUokWn0el1pn/rGqBJSBNSFbZxCUu1s7LSAEu/s/qo +PGwiVW/G1uZf1EifzLJ1LXcLI3slIl5pB7w6Au7KeJLvj6Z/Z9u93sQUW9pvikN4P7mMmp65pNfN +AWse8E1fXWvbcaFUPDJSYDskoFey1SpuyDlPVz3n4vqTm/Z4CpRjT0cEmrbmJKxXlugTVVNL+hDf +vIAQKYgirGxlHBPxEeGlmFCDviFAZ32qdy2I9qpaTk8MRsSeFWjttJVmylER7Xtdv/n/jIbjKTSD +lIULPJ61W51Z33vVngx7MylTksAeTWuAz0beQg+6bPAwU2XchhdYqJaHfhlYZTdgVG/p7aM+uhNF +82gyGuopr97rSJMRZRZvjTpRLQ01h70xgRFvejYdeq/qE+CCKfKQwEXCO6qPwPgnnf6sR0gEdVUT +3rpkKHqb6qormcyZXrvdgkHVG9ValTkrOx6O0uN2HV+hYHDyAupZYxqdZqMo6Vgb+MHFjb+oaBB9 +hv6jLo00WaU32IFMy2ycVWYiL162PvhRn6jqQeB5lrecr5f2NsiZyZgD1CCb2d7uYNjsDmdT7wc+ +WmnTtANoC9q4DZj8LBUaAANVU8PhCM7ak09l0dCqEESJv+AZjjD+DINmvB/odJa7top3zlKacVzM +piMwK/uRMARkMroGRtBpAcKS0ew4ChXNjitCTM6xrTI5WrMiiGPHP9reWvs/U2++1ZnWST1Lq0LZ +yPfl+uBjhsTmcCSvt5KzX+wNG/XeVXs0601IDUvwS2040rIL8Q4dKyTeGhwxTZSk2u6V6lMwvGMY +/DvOTQjqt2gJVX8PCiqyLdmgBrfaYa9mw8ugXRRifAGaiwKuJSRlN31cmPV6Ms6A6oJ4AG+Ny0B5 +3xUR2oR+aXMIj0D8ByzaB/hGFnfq+mq+GCO6jPxow0uRvQDp9UHThFHJTwCT9jqDtncKFl2vfBOy +PIezuJzVITF4y/jSRruBj2RKGv5oj0fwOOPE/gN5EBN0I4qiwGLE3Qq6dddfvUBMsHpTvKuPdB2C +h5WPd600Bs9ytZxevAPizleq3guboTNeoEcupDFXyTFTVq1qCnqdp4EGElODgbGvYSMKmLen2Awq +aembjQAT4oOpmmkZmsGZ1Xs9+1aTbmfUADTUDdoObQwoYjxpwzmM3XUriyQJawHAK8AzaA5bbat5 +yV8Qc9tT5Ba8QOJk2DgevA+9KpsSS4qXQreiWn2E1tywWDRpGAyGKkF7OwPEmsNJR14UZ3MJDcPG +RDLQGIpMZSUJcGUlAVBTrJJiN5j1MyTra3Qpbi2fSPfWgd2IlatOiWkUH/4IZnfBIBn6CCkJ/Udu +LEaIaJc4wI2tkWBsa8qUJK5wMxtkaeeNmztPXIti/JUzjh1EgZJU4L1tN2I3nVZ7GDsbAp3cfrZn +GCgr2giyBq8GlpxMe9EW7gIRtcy+DvwIP5Paq1FWN9+MWn3wujdwPahRyzVwfBJS+YJWDn6QDUej +cRSFTKM9mIrgquV0KNszomjfcqy6+HH1FI15W3z2QmdPaNYQtv1rKBU1s2/2qWtmKntb7UnnY1A3 +mqmmQrohnb2wg4gaDuEJAhft6pNGZ9qvj6ybwpngVbQmDthGIg5pURK8FaKJE1VxjrFqRR4kCwB+ +A6ze8jb+9ubGwEMb29Md/F4lZptlVEdis4gmESJDI+ROuFaamrEZAfbGUciPdgMbt6LD8UfUdvBS +G+lANFFUQ98KFdmQYTm2+2EzctRo1JMPLJhRCm7THEzsUAraTIGLIzudplT50e9GJ/KdXDZtGtAZ +cGjTHA9H1kN+H0yjrZ5mSUzbTGYNeVasWU8TIN0UG910LJNoowO1jm2TQfujroYpLBo1h0AEDOzb +9Ogmik0aFKyu3eSzDizItqrcTVtBr2HQnuh1O9nqP6OoxvcxQzZoA/0r64GDBsNRc+jQYGIzddSg +NbM1jWw4GHxuz8DAGgbomA2argQCal0fDOQomrkPgVo5SeFmnxAcgetoNerFybTAQWl5nwLV24vK +U9D7g3EwU/pANRD6w0whgTbQ0OgMHLQbVi5jnYFlJfYA1cIrCWFI0UbHwZaKwd9A17ThcYpWwmQ4 +hgafyT6CvuE7ID355kQUKTFthbwLY8TE0OsPeMpp5CylpXY2khVJqfYAxjvcmV5YrCF6URfSzTdg +0abwcktpLFHGXI/DpkDhQ6Neq0XNhw7d3w5wAx2ajYlL/pxENgyaNerjiQ1yVfkPDDHCtHTRWLEu +XbQdawwEp9akhSlYNu/Xx92JdtQuGiujdtGWGLWL1uSoTQ1AzRxnk3Zu2ERhOBs+xnp1NH4fGra6 +DNqsD2XIxJ4sgKZqT7VqCCk1MwUw1osk5CmatfxwI7yg1sKya0rGKGza4ZCagxLRcLyp4sW6RnLb +JxPrnpFQx+G/Zv9vm8gR0XCI76w3BnXScnMyrDNvHJrc6Kr/aJ8B36Ez6rXT2hhULNOR/fB0NXt8 +HOdzbSjA4Evu6GLnMbR/e+Dfq9+FT9idi0gmNS72P5Mfg42TwkY44M926tHJtnBdygtbydR18fCM +O0qWn/xnqfGsKRbyzFncR3PcFkVNcl+5jzC1ndp7ie6m9sOjSWpyysQ8vtReeWMsNzqZZj5Kl+XU +PteuZjsHh81cNOr/MHRVbt2D/sRcwZcUH4rT3NdzhnuIhNP9YXkCpjv9DB0KW7NCjg== + + + 277NfPX8tx5f7p06aZgC2xYT7+LN5eNTupaN3lh3SrZLPqf2u4XnVHIS7YdyYd+sECi23j0+hKzC +2+vFLPf+fCtmeqneXfI98znNfooPtAYdbzu5Jl3+Tu0f+W8xHDDkSfbl42UIfu18545bxxuZSPxr +O12NbA3wGO7qrZnHl/gKhJr5Jn8ZyH5yr3v7aR+7E8qch99Cqaz/upBtz3YPb062PveazXoX/uqE +8u/lT9wzTcXq4riz/ZbsvJy0Mj3fkT8yDj3N0uXqzjccfzC1d/LJenzC3s1zKj1o+vuhg7O9mNh/ +OuiIYmzyzqbHzWM61E3SCsRm7mRyA9Am+tviLUu1kp1srA7Wlz47CETC7UxPrPTxDO7LvlT2eH/r +Nh9O8BOwLsePwtahmB2+hPZvWo9JprH1jMAeDnxgQofC7hZckkfhVrgcQDwdZrpBISKR5k2rTNHP +W2e5WH1/p7ARehjDXgT44gVBQU08Pqqxecyh36HDwr70a/82f4qbZ8P5NwyMuWeOAeneUaHDw3yY +yR19HEhwbg/291pf5y9oJZUBA3gXGV7qBTTKnCgDeFYHQAcOrmCjNoee8RuZ3CtCda49OeKEB+Gr +ma7lvkK599jpd75e929nhMb15X4p93qYrn02p+nKdvMsXWNYsPpp8fl+C3zTesjfvR3NFBRhqtWQ +6UtXBRbvRcclecHuh7n3ar6F8AnA1oOhw629W7xCELLHl3+lQzcZ7u6kkBqPP6+55NntEVqhON8Z +C2DxdsOhzDDxokelduIk3mU84YWFoDy+vdDBLFDI9egMdcInwT9FqoPhHAqNYWqvNt1M106mMyMq +dStJ4F1e+LvxBnxWA3LsO9pJ6/E0u0q0C4GdUTD7KVw95BvU/m6uPR6HqXblYE8ZCEaHgoxyMf16 +QiNq24+8FSCnnkZzx19iHfM+XtB49bt/mr54yZwVsu8ncYo+bbQK2Vb/HglPkzUoZnrCwa0KW5iW +Dx4ypdrWgW4MHh8YRfsiV+z62qCry30oYVjqPXk7NI5W364JfoWnxdFmI5EI7XHnOozsHQNLJNuZ +dAQoLSOPFSa4dVxSZ7XXTu70ASdfBSF5nYUOTh5O5E4/noAcY8FbX3m3OH1t9dPVt5NcrHMQKGAA +7/6SkK6dDT9SN7XjeiEfv7zz+PZDVP5JQccoHx6eM4UdIXkH1nyWyDe73ztyB4hBenUsmHce/WUg +Hg/86aveaJdsd1kvAfHn58Srz91o+vS+OvD4CBEuv39N1cSdi2z5u0ZrVMbuTu497X/R6ICrQuE1 +uPGJpgFk7qANWIpv6N5Kqw/fdzWahvh6FyjR4jAfrjUPABYvbwFj322HDg8EFr1NV8OpQbbTuWzB +qW3AJrXc6WkpUtjP80H0Fs7lY3eAm9fOUr5M74SKwrV6VPlTjB91drnUTSMmVkpnV3Tj5TrN7mxs +55ng9kuWLmbLKfjrEJA4fUC1G8kjOhzIHinPDj0+7Te4JXoG/8xAoZhFH6I/hWqZuYRvD9DXSgdZ ++CyDQaX3IwWRj+SumNeHUR422QcyGTaHD3JKVxnY6FyFg3uB/WlBpJTBHypf7KEmcDQVNCQ0BjAX +ACeNhwKniScMBwWxU4PP9hAwtRcEQo8iOGSzTtGfEsYgxKoWmeibPfgWTeNIRSVuDAeHsTj42LtU +UFBF+FR62Sfmoi7eoe3Sul4I3TJ4fLqFwN9AZKmw0TQQnrToOECzUv9EoJSei+oYPD7tWh6akZzt +kuAho1/KrHCn6p+YxkwJwwVZwMZlZVYqqehpFs/FElkHeKaIc2R0HKhzho0vzJCq41SPT0HhgW6a +Ck6SWhBH2tFk1W/RW12n0rqofEdQjGZVD1WqRY0hJtImrLKnjLCiCA9MpHguBYRHBNYtqokx2NIL +QjlYfYhHBfahmQBEU1NYcz4yRAuCMbavdIDGeCXE6eAF+oXRr8xUFG6i70CAf7GS3kukB+mr949T +YFaejnQKI127OR0UUjTd9fiKvuIrwAkfEAjbZHbp2y+8Tmu7qT2qshHK39yVZFUW2SbMCcIq0HtJ +ZDtAydAxwOYLUMEhwjWjE8BhOc0IfmD6BR8tvSlx76FcSLPd7RPkB2gnFEIOgscXH55QYj4Sfudy +p0ffHNlL5rWdvhpUr9PV6XE/HyrHAtq3vUIq4RvJTsVVUHW+cAfHj7Xv9EU2U4E2jGRd9TWIAR4o +tMK0MyWMDXGveX2VFp9OrnIn4903MwBpvvR8nD69vQR2sjSya1+3OLlojyXTryxkgNp+iiq+Q9Te +d7D3HKB1IfsOEJgoXj+3T3Pvl5NqrFN5BGZz/juL7W2W2Xy0d4YsXSGPj3SGVAqFU8Me9l36opD7 +un3Ndr6E2N573/cB7NtdGuDk8E0Ur1pDOLiIah9JZmy196yCApQsAfsneRbCrhIPOMx9RIJHuINL +9vANGGoX/uxn6D4b6xweJKW10uJJ44t0AdlHC6ojDOQYuQaVEkI/6JTdgsGDMqZ5iTiJgVg5FTuH +mM5VBqiUesCzUO1/rfVPDDTRbZ9mwYRaocLb62EiV7wX34E7nmcopsid6cFebgSfdE4KprG83O3b +Ze79OlQEcrqQY4KtPOZA5KlCHZDAgutlf6drxVdi4eV5d6uQH8zeGF+iH5dWfz+8HXuMi83ySeay +kgJzue+fSw7+7N6Xvjyv3hRywZb8QiX24Q4ldmeNClU+bYxUH1kfc2AeumBdsp9PG8nQYfH1Vaas +5yhYwehppnsWAqZ95V3l2SSMtLxkuszBhvpCCQRQyVa/R0Elcg6x/aBGO4DHZ9L3qnvGltI5ybqj +6GXo6Kb+LXdQE1N7p/ebwH383NDCvkhXi60vsC4HYyZ1vZFAa4BW4CAwY9qQ5N7RCyDHjj4nM7TI +iUsgVEEvL3UAojbJv47oRmrv2h8lgmQM39vce59VvtK16/o96CDZowpPKRaMphRRpLM+gOHxJXqF +4bsVxdBKy5rMvSQwl9zLkhFFe/6lGCG9k2tw7aoj9xIDgdz7ASi5EKz09go5/oEJHd4/7xohuvDy +CbBlgnsz5ddPhE+wLofCySwXvWpFUsnzr66iomrCZmGQlUKDgPgio+9hJxe720vJ+PS3Y5/tlzeI +z4k0uGLuQJKgtwc8VPNMpn9xCLSYxvA45zIXM/YBoPpqkg/tCu+ExlLpDpKSsL31HU8lb787e++l +xkcqeVcgQWGJjX33RMPjQxp7P3wvlBBsQndLLakA8NOnTbB+D3u59uiijMwJYavMbcFnTO60drap +di/e9Mo1oOiOtvOv1OA5917LvXt8+fDwbJbmU+nHfLPSC+rMJSky+eHrAoGa2BQnsfObdK2cgmyY +iBgHvx9IjSOJWbpyFXtOdl7i72DFb3fBuhDmDVZHBzFAMeVdYKA8XRde9z5j+k6Zw+8+WOSPjdT3 +UbOtvoBrNUvHG6OPKF26CUvPwBIDe6y2/R0pBIaJoO4V3SgfMyoIRb/CIZ9HMr0+9Q7opfsgHCYv +7lN7owRtnJrUDq4LaCnGL4e7lo1Qk2Sr1fg2NnmI5KjEg7+QbQvddC1XpzO9+FacYsLfnVTy4rKH +FoyQMAYqQvsTB827R8A0ubP0VS31baSNrUm2c3A2SSULvrpwJNwVs+fZmyPFOhQk/SLud5qPuePm +VSXD3TJTw8K/bG0A5UFdFgInR+VE6akwlYxgaRGjgNBOhb3T7fR77mPrmROTo2gWmEOdXRUUsvog +sPf2EBLd435w2/cKqXs/34g9jLSWNx5ZvLazXS28bu1UwfxCT/mXr2kTxSCN+CxO843MbsDjS56F +2Md0rbazoSGWo2MFbFmKUklkUcZCWP7zyYJASluFbPoZmIip4zsgx3LhGq/EDPFoE910vpYWE1cf +Ce4t0weTzFCWTaAiqENXKRgZhGuKeQa8sNrNUTe1fzi6BbqyN6B2TEC0M13/9CTD3W9elw6eOL+r +mUpmngZKIPoEe+kenwP3Iz8k+U5IDaE2PIGxTjBdnt0CLsJDQgWRpOMb54XgfWWaPr2nW0SnB6fn +rVyrnwiTexZgZAEg5S+6H6r8xUJ4+PbJE5yq7F5ggRs6H37l3hMnvVxjt+NLlN/G+4V0b7CJwqE6 +egGrD7fykufZ2FPu9HQ/hk015rIaKeTp90Ahmb7alBf0NgAkfy0mHBTShxnBN+Jzx/WezyB/epUg +wM3zFZSl0dzp8WYWSEstA+2HZ5X7QoqavoI1HzQKG7thGriw1/CbBAM4h30DbHgUJ8Cyu4Egdi7F +mvgi712lfNrdNwkJe4XAcT+d+Hw63yrkKmfVgm/EAeFy2/5IsZkHTuVFyQwCv1QDC+3hpcXqVjYN +/ldK7UeiQdNeYKOdIgwWP4FGedbIY1vdNBfIXOcDk8YzFCS0HlnUJPyAVgAwbuTespdqOcME32um +IGj/SQu6zKfp4efFLuk52XEqInvZ47MlfCX4/oh2AeBaMbl6tfhU9BWf44BeujOi8bRceAarn9pG +pgjao4R2spA6y0UvPvcJqj0UwsPCbjAsADOI8wFXItVDm4177UTzRtqCE06uyZmSIYgjprAX3lQd +eAONkWp71HovBE6LCXKREa1ePm3BF710tTF6x94iI2x+ZPqb8S/CUkqVRt8yV6r6BfVyy+7Xxb3L +i0q6OrtmjAqFH+eO+50JUFuZPhhhTyi8nfkS1hbARXL/CmDsrFXeMl9u2aaIJ4axZr4xLEUc2tV2 +bp/z9bfjzUw/tEMoaJnGCOvj6PwOrHSH2LfXASP4zjBTqFDeX8Eilna/gcl9fC5rZCQ+v8b+u8LO +bNTOcLMM8HSAp0345KhJPxAHEjSa72W+viqp3HHrcpo7CQQKcBv0GO8bpXv1PjKN8tOd4w2555MZ +sMaNxmvZzIKVzNjxVgvSXTh9ufsKNGSzT5Pi+GQ2pY4fi/s6fpDmAgyUZi15/tKYFd5emD6kMVbZ +TH8gSemgnSHEP+RzjAcf1X0EyuEukHvfGW0J09PpQeG1F41peum8hD/Aakx2xeRLqAr3g0L6dWGD +AxYYBFw9zfn9wwR9expLx4uTKTw2AAy64/pdahK828ydnjx/59r7L5vqgiGb/40DKvp9BMTHU0xI +Ni523H4Nv00A56pUKrxOnyOFlL9d027GCYhRsISRHYMKUM2pyGcc9BcuFh/itad8o5a+zX3wOx2d +9FIElyyzFC2N5ZS0JHm0Fh4f2oLMfj7ufxfSldQoeTaZDbWhQUH4phNXuWa23s3tdmJNcZ/Nt/MP +78d5JTyJmlQBx1cLUDfV0/FIdBPGQopIbCGMVR7E2lspVsjN0mhb8hJYHP5IrjBInwH9WQtmunv7 +EclA0UH8AAKuOqu11IMbWBpKQC83M3ywEANyrJXMfRDSUnpf25KwLOHuOn01LL8Jh9/BLukyQxxn +/PvlfPg5A/x9gemrwVmELKB7nzoAY4ffuye5xl37CnDbYal4/zp6QzJSYR8LzCuLIw== + + + xQkPgACPFLaE8WXpCJg+R0BEn35n0JDk6ChzGZhCetoXriutGODU63DBRweA33x5Fc6dbLxT5Axw +4xEt3Hy/p5FKKPjKYlIHW2kMaKyw8/AxyL0Pn0ModGQav5ZEfSYOo8O14iw6ekmfPgTj6urDIwD+ +fHO2+RK/KLG1BBs+2Su8hm+SurkocGr5oU5ta+G8ZT8+C3646x3XDFkBMBKK6eH3JAZPd1zknjv3 +W+RutSoAkif1mzN1/ho3+hLYv2cFf9FXKPUVtwg4SLfb0dxJaIsne+5Nt/PNRrgFTxHcMkfS0/7m +Dlz4V2iv7Wsi3c9iau8lMkvXsuIr8DpbwMOORerpYbpdUAeHobCB9F5q7/k6Iw6Oa3Tu+eOZAf5+ +tZeKycCAvKi0AP919sGENaZovrBTLI/U40jRjZ3EjSCcdD6EWuT+gclvRDKxz0Grvp34uB2DsZZg +BnKGznY2Hv2AX0K7ze8ctR0ZIPXOb2R3aeAT9DeBuX/dKMLIqY9m/89D5ZQdA5MmvRcjeORw4s2h +S70WzFDtDLq9yTTaHM7kg9qB/+///n+m/+//ZX8SWPps0hy/j7+1BwCPB10vrI1CnPwLpFvDRttb +yRWktEF4iHiIh69PtCRnpibBiWJCveRE10q9/sAxLe+415uh48PDsZcotT5vRp7pSVA4eTDDV3RP +CCygg+/At0nP1H7t8o4Cs6Obctdnw8Gw+Tke9ttq/6cd+foR00O88qcXKBGtAL5Nj6d/DcfdDHGe +1/yQrF2v+lGbZnu4z4G3mDSDRo6wBi8NGEwrOCsBLlVl2OvIaUbzzbysZhjylmvl4l4Lu0EjIsmi +g77wzDI52PnzTeSZqDn/mMtUiuVsKRYuoLp06PqadGP4wx737u47EJwYJase3FYp1SENQbvyAIst +lGxx3AIU0HnvKLnstpOGNZ2s6XU+irlST8ozjAWlm8kGl6g2xZZ0q4ObXrVTnadT+WaRdHM8bNSn +5frf7bG7LEYH7pTI0pVUMSWR+RaoZpe9Jw9VGh66YUvPlC6YwPQqDDvkwmWxWlA3i0IoM3jnC1iC +bH2Eb37pyP0zvCMH1sCcq+SFStZ4Ja5NsU4PcLymxCXlXOFUn7/tM+Hl1tVpHdhXY5s8TnkStXGn +fwazVqwTMVX8GC6to21VYXXWgIQ3HEyvoE5wi9IymXhkOcXauD4aybke9gsLScuwrvZkkCEzpSyb +SiqmZrh63I5glfs7nOd4PWmjBJIakdwbqH0CgveC3rzTz7ZXyiL3TuR75f76bA+8E3x9YH3gJW08 +yM/e+gQ+Vk1Q+QKrKLqtbYqAa4H9PZx5R8D88AKt3sashbrG4D7qnQG8RYToKOwFnSmfDsCSwqLM +I3iDubeDrhype3v1v+G9WmAN0d2w0GKYzJqfcHjHgxzK8VfB4N4GgGpmYHTDd7X7zsQ7G3QHQJxH +3fERAN0cd0buLMgi5Nn6tF37nPUbg3qnZ5c9p6FhVyIWjAUgE02elK62FAdsrNt246bT/svtUAh1 +bDdXzHod+ZIcJ34yVUN2IwcCjJAzjrrdzGS3yq7Uy7JbhysIFNUBVP+xkmW5mJnlTrGZzcYeBRi7 +QGHPNTiCos5tc65V7YnuP4FYM94DqvuAQz1IeYqKlwseYvs6q/iGWijQP9Clt43qg7buzqbqTREq +CnUQjPoiPwDzJm83UO7CgpfYXAyIOy610LSXobLqSzDiZkeTHkmABMuk3FBFXrwFb1w8bY8HWmsN +vECXipqPvN8ADIj8ImNPSAaj+9rgVaCmE8AadKrMfc/oxu8pdXS1tVXhCuOaqxBJ8jsPWnnyiWmm +YOiQfxNDRzeNGBULnYVCR59TFv5iuP3LJKu8uFR+oRd77FFtmsm9J4rd0tbVQT33Tt0fKm+Z0MGV +8LkRZEsHG5GY/8rj2wgddvc3gucPiY3wZwe8enuPboRmyepG+OwutxGhzhgqdnAfQN3zG9ngJTdh +JmdgcLkud3Txdshm4mxceBD6Dyh7Bx1RVd9Spdd21uMbjw8PGunw6PwkdZqYHMZL+7fRwvCBu8mP +nx6o3EPhvlY4SB806d20OJB6YbcvQ9nI7hXoryxYTRdPKMqWE9twH0nfqDwZj/cmNdBJ+JiKcVU8 +DXVkk3hhesO8DLs7VGuHRj1fqGDHz9RkH8COz0KHxY0dNHG0LrluNDaJF7n4994X+LPYA1/f57Sd +Po2fz54uzTstii988vglatrpy/Z52ePTdat2KnROiz7zTvc3AuMJ7Rubd1qhn7hNJrmrdurxqd1O +/OGziEWn/Geg7r/Pm3fKBZ9C+8yH+Uw3Cy+cx7d1PeqVzeZKFTKnKYtOha3twTh4YNHp/QtVeD+v +qp2izFql2+LG/g598loz7bRYYmqW6GUeDmtvqFNAi428dk1vASU/zQ7LsNugcVUD9+xjjw6CTrmh +gZTKVEbqtOL36zrl+f7rSO1UpWTc7ev4+XNQs+g0VRfEwjZt2unL0duVVaclj2+bDew9mc91f+N5 +svXZvjLv9DIbPPze7pfNOg3t9ZKHaqdgXbSktHv0kLow75S7v6cKCerctNPNwoe4fdVnLsw69fio +wvNzwWKuwpavOzjLWnVap4rhtxvzTotU2t8OiPeoU49Pj+DpVvhI6vQ+EtAh+OicO5DQm3/qFjSd +PuxTZTFCw053dZ16fJPNUnsoXNUjDOhWHOnpt/z4ULfoVNgSu63Ci1WnOeps9zmBOkW77tq5Hn8n +U1/j8yvTTqt7ftay09N2laXMOoWSn3uMUNXX4KbZXCebp6X2+eNDMGDa6Y1/8GHZafXz8q2BOvX4 +jHN9LFI3p6N9807LrO+6kNo/MO90dLJp1imQybDbm9fi5tQCwY8X1O3Rac6807PD/OvL5fOzaafP +F91j1CnUL8a5ft3zrYJFp09x6nnSi5h3ev416l8k4qyuU9AL6vb1ODKwRPDYVw1tWHR6f03lO/0T +007j55HNjdRzBMgx0G3yW880s1fxVeq0wQZ1TBN8KNd3UaeM/zBQ0s60TL3tJtOw07DaKegFdgvA +fn3LQv9grO90Mtw5kDqdHoV0M914qj8GcaeZe/pYKwjD48n14QboBXQbNUql4wiaK+g0OzWIwtKm +gDs9ok8jOkEYHnHnWNOw28nsKeoU9iJ1uz0e1xsD2Cml63Q8TreHMv2ebOg6nfBfSUnTHCUvozr0 +bg7bbzWPZD+066+CdlCl652XYdLy7f0l3b+xevtJld58M/WtQfID0ZvbsfgarMFOKCuP66st6t4K +cfq1Jr2ddOMGrhQGn5t3Zu+xUKwcJ58s38aZ3as367ef9Re/gjHj+zSz89C0fFsODY4Y67eNi/c9 +9a0OY8LWxWazUbL4Ol7aKe1fT/Dbd/93QvftdagjG6fv9GbSgLHrxkl1YPYeS7lcqDu2fHvra8Q2 +rN8+5ZIHMsZM3r/5XsRty7df08qoZPm2e8NkLtW3Boz1u4XDF6uvwZAu93jLtycMd3hnjTFfc9Co +lq2+3tnYOX7atXybT5812pZvT5ijTdoaY+kNZjuYtHjLl6j8wa4852RgT/c2VLucHElvs9F9PVeW +am/F3bT6nptw4SutB5alWv7HrCR/3nw9+HYkuaOFVx6Lnsxwco5/aeQYM92GHmZ2I3KSuAce5lcN +/hOFzwob4dxVFv5zi/w3xXvDMkLqr36VkSXfeJPxH1QikjwHfo7GHjvcYv3gw5M+4g3o6RAcETuL +D/zAj72bAdG6uQP6e99X+tuKdQ4aQSCdNvPj2Vs0ohG3402PT+0WeToWnQpb0M95NO+Uu3+w7BQo +kS9aZ4+Rc0WejmWnUOU1rTptkZ1yVeAjE93GzzNVotPWzs6W2imy/pVOWR16ofWvzLTY03QavEfe +K9mtBsEHjGWnyPq36BT4g8D6f1E7BXPRzPXZslOA4Aln3Sm0/i079fig/f9pPtf9jahdp2W/ZafI +plA7hbyv6RbaFDXNqrYTcvfol7QQwexDq++m3cusPyB536KlsPX9kr+7cGzHf0p0J0mLDJjzU1qS +lgbWfQv0IXauiADNYWE2loTLTjWl4/hYZysZVv85HAVaNclZhzIJ+/uHo+D+SIEYQCAOE6XtLzSK +w0TxMQcEVz0Pe2ZV0SR1f5j3Sf+Ez4ZSB8gEljtQbEswHjC5gxFupIs+AbGXiX22cz7lnyvSYpZi +ZhdK4xzspUhO9+3kSIopgSFfV8CDHWjQznZl7GC7XRLHxAwqO1oEKhE3MGDqhPf50D+QIG+1XpLZ +oLqJY92gyCG9zvyAdM/CjP+IIuJounAgQjmQls+zzKkT0uE/0uCxM28yP/+G5fw8PnWG6B/LFZTX +r7rpvH5byvx2JRozmyE0Xq9tkOV+/YaIPrFn4RJZNsDo3cxXwRKUxw25y8jai8xFWSpdaTQypqzi +0/f8mDfFOzBuHiRKXhrzTOYhcWKPd481srSiJ2gUPS95rehhLUWPx4l080/HYxKBypA1CNzBoscc +dy/wBhoZwRbjCefD+B8Jd/TAHHf3kQ1LsW3FlSgeZzq1+835p0ZqMTQ59uimduaE6uLpjrSbYDqQ +XEg3K1KLEbNqV6I70uobxGge9HIznGtCZhIG0A5w5+4I3CpsSNL5W3AHDO4uZ7FM4RFd3/aX0Bhw +nH9BxFDWWvpzGDqQKYegZBTUMQdGuwVmBgrhndjl2TXyXb3glu/suQ7oyvrm3cx2Lbfo8DUdhv88 +hohNCgNZAMkYyJ+aLSfAGLmg8B+woGog2kgbYH6KFDTSxsWlMiRiXGgu06LpyA6LjYnVJFNUe3od +M1hhxiVRPb6zkHFJWkUnK8yt6OnGJx6fpWJyYTOqjYE18zi1VEse3zzrW4Q4Kc1vPZnxfquoldMm +yDobqorXZkjToxNLXXlxJY3HjUkHhmRt0MlL5/G5W0Hg5dsaFk42v2YFBz5bw2KO9StW+iooTMlL +AKsOXIwLcKUrYFqFMu+45B1eCdi9vRMzzyRJq25pjL2OV4gxrUSbc1wjbRzmTRwbHNfp4WRB61iz +/wLGUzJzBq0MWlMFzWTuPjcc5BhhYJtz5fRoc2Vcmbn73p7PUcb7sYaVLMEtk7KKG+iJz4+d+80d +t86HYlvqsXM4UdSyYxjB3DAs6YSCKb84L9PhxN7F0w1EomTjUBykgKuB6GzLxXDiwPbEQLCPHLJQ +UR8lGLp+nMMnx5uS2kNGytke5nnSiBIBbfDrGNJ8fo4OLIIawBLcsLFhTMWHBYMc25sdHt88g9pa +UABopSVkueepz14tuxUAx6oAcOvvW8/P7wLlHndI19gKzvEMvSWvxvq+juGm3u0qiCo3pfPPk6Iq +GTRn4UwdHwufHND+J+uWPqUdKztkuWdxS7cHeUkAWXOyuAZZCoujL9jtRDemZfATOBcti5t63c7R +JUC1m+4iJHaxhBN9SFY/GruQrC5C0j/RWvAWTrFzSBZMjWAkafXnDpOcwHMJZ27DGw== + + + ipekH8rJTKuWFwhvADr4ZtCE0EkVw2q5XyudTrWI+3h8dlG6/gnc3L1fKu4D0eIc69OJAot4DcSO +4IqSCbmpiTSMNKZ0aqY3pQEdWAcTJZnswpiGWD7Vm9Lz4A7bY2g8PvvxuI0vsEfXol9HEYQvNpci +PNVZwovxS/IyaD81Zzo/VZWfol8WiEaPTvV6z2pCHp8NpQPa0Sq9RQTA0bWP9zisuTvEvDoE6T06 +VWdlywLs6BSdkx4ibVk8F0LVwc0qP3l+A84KPHNDDJZcR1ByFownOl/M2zjnu6qZttPuirreggTA +rOKtZtFW7FlYxVshsDmYz9xfAkzj8S29SYFWzV7leVzD0TqS841G2hPHcJblQAxF8SZVKLJMngfO +/HpP8fdNgGl2COdTotr9QT+yLsIBrcWZRcdUV7LDkEWHTz0+ZzZ0oW4gMCY69x6fhREBz3LuukIl +YX4mvzVaTC/RJt2gQaJNuvoNPBcSzTRCkgWISX0vK9GuVYkme6/zWPB6YM4SzeNyBwkCW1yiKVxZ +vBmuQKKBVTOTaHPzPoAzv0QzxC4wnOUlGoSy/N4rgmOzGxTOBJRdnJjHZ2YNaJTQzdDOgya3Ds1t +FC58pT1vCXweQ2wcPlt2A1bWL+/+b2sx5NIyywI+v5iaMTOOwM8nZgGwm425hKzHZylmFzz9oGXm +G+RLazzxRQwUsGq6Q01WEsYZjjvT3hIKisMAOMsfgUBQLBxq3c67MxztprvL8LLJbgICtopYNdaF +YH4haF1otSF4GlnGvieItL55NVna47u7dRvNImIXltrwdi773j4GC4Etb98/fZvpwnm1GFy1+UNa +Ri0G4Sxj3xNQFF24uBZDcEzsezMoivdqAcetNrTXhUjCPH0vrQ01uvBVv0+MegFPV3IcCcof03NY +kq7UHJ5Sj2FY2gKvY5slIVEZdrH7dne3TKxaF+cHwJblbmJcJrxtf9baBmOuzF15JWEvVh4RWMuo +Kz632T3NAnzexGwiVy6O0+mGZEkR6GyPI3vpFVM2GjGopWw05sqvdKGYmMxdy/J4nvXJNQt/H4yM +cYdKF8zVmKzutC0AZrl3o0R73B6oB8DY7b3T8ioiJABj4nwmhsUZRLiSr1FXMVgMzILZ720P32KK +8Mjxe1eDckkRBuaSNDJmXVWfHfJnA1PPQloDlC03+diIDC5fN8I3L/mNSJp9gXlzebMMOnxzy/I5 +dKQWM2bQ6TKGFs6hs8+gQzJ5BTl0lp2iDDrLbME5c+jsM+jIbMFlcujsM+g0Vt8SOXT2GXSabMEl +cujsM+hssgXnyqGzz6BD2YIryKGzbyflVi+dQ2dgXE0GneJZLJlDZ59Bh+wx5xw6zYFkmwyzir9g +Zm1bn4G3zgTSHXZxMSTTSG/O+eD2rrt8qYLOR174MGxOb/2aBAfcRnofc1ptP9/SEXt8Of2BjYXx +tLerIVdtrqii4wNuksHaX+0bpyCKdo/PDpj9OSx380OxPqfMOdfz00WujPziHumx+YdkkfnoELmy +G5JZyhycy1xJc65kTV53FEQ92zNfAtV0rqMg+PyY6WGQ+cPGVkFjdDPY0vGq+8iW/dQ8LpPdtCch +5w0MIkoGa75sxBgnu1lt22i9JKdkN2v/1H7DgZCWedvDIBrX1MkNyeuyGTSZwu6AaY9g0cYdmwbz +7ZT56E5m1QtzOb2IK63c3gZrfYRyrhRTlPt25jLr0Nm3B8gy28tW7DFj6MwpcNiNj3RhEvDttemh +2QV2rIqWZpdlFhhhKenzwBzNLtd5fDOnM/Bz5PE1nPJftjRBK+vUNOskGHtT2ngG3n/wuWU1qJRZ +iqb1+jmegXd9iqBV1EYwTdfPbR5ffOyUE2NHDNrT6RDYyjJEx+rOh1VmyjzAnCnePca0AdYlMeaY +Jup+kqpEWwhj2sAvk7m7j2gPOpV0B+tNMrnc2bKGmK/RzVJY/co8bmmfL6cDYQGgu6nVyCYg3pgX +Gv7zZsvdJRfOnuLxOTh7HyXXzp4VAP0ZxQVAOF2NAtZZuVXDXarcQiv0SjnrF9mkMWcLmOLmHGTw +2IakYVaahRNnIHu7HDmPQ5qziy1PNCH7K088BvfKxo5MTgxH+QO5qQuUEzsjVpT8dTxfeMfEVcKW +kkOCnEHqWGdETU21+QL22LFbjlf53dIe+zqeL7xjnWanP0G0MJ4+HSINHp0rYU0Cc0ZkNEPS5COD +QTHzhD9shqRlZmctZoMnzu2Q7E+nOyfF2Q1Jf3dHVBf/xSlJq4jInKCIzJKn1IAlvO0iIiPt8Tmk +52wnozvLRGQIf/9k+YgMABCwOd0xRxraIhEZQ7bg8hEZmIami8hYZaQ65edxc0VkTOP8Jy7Sc9wl +58AUPcBwzpTs7vgeLNVBaY3lU9VYtj437sZYZo+uQ1suiME+J3F0upqTDHBdkpf+1QR1wNSSAYcz +vW7S0BY8wE7qF5hAZh1dmiN9zHB0wTRb0Cmvbu5Ds8YTqiivzuV5Pdu8OiJ11CZT2DkIemp7SRXB +vYRtaXtUr2K8ixQ+c6no5Jx3q4NJq8mHg72s4kydfT7c/PePLZIPZ3YKutJfdT7cEnkWc+TD2Z1Q +XV0+HIxaL8mBLvLhTG4EtUziWjwfTnMaSv7Gv+p8OP29ozgjbtX5cI63BKwkH06zY+XiqOVi+XB6 +X8xqWwdmsi2fWQ8V3MrORAJQ2jORVralmzORN0NXZyKdeH/SZZc1A7LogMTy2egITthp9V3CcZNH +YgkF22MIzgoyuQwnGWzOwDtLNJhcZx0QM553JmrZWJx49n/vGk48+78dFkLHhJbRnrubZdhQTT4i +ogrLsiEAZnutjJkcs2TD+5FbNrSxxiG+5/MXTQltNbcBIzjzsY9FPjKAs5JEyFzMnRZzhGN9JbDF +bVpWx6yNVwI73oamjUrrbmsMho0xLJh8Zn+xk6NDrWSk0puLHhAh5mx1sfBCGan1zVcXSaQuM1Lr +mw03IQOHVL+VZKQ+fa8mIxXCWUVGKswXWz4jFUJZRUYqhOPuGmidS2x2rg8xiPWlqXMfMgpGpNXX +suHd0myoS4Uzl2OrToVD5/ltT/SsIhXOdF1Wngq3eNxSizF7330Ov3KJVDjyDiKUDPdTUuFMogo/ +IRXOPD7m0j+7tzMMSVFA3p9sl/j0aXlW1c2N8Fp7LBt1cIvcHvSCoHhXEUUXAWQIzPpmuzltGMMl +w/NuLhDZ6Pcut3DsbucFotxM5am9OCc36/Pqniyvw9ErBzk6aqIeVP6FVePCZv1Ja4BKXB5efBZ7 +N/XX3FZrli8ktlMvhdphJZ+KTf1A8hdqR+I9Khuee8iPU+mSUDvJZqLNbDYTO4VFCKojWR35etoh +SxEnbS6WWdYZ9JKkHKVH67yz+GWyQpKXNtltr3lxRgafiU75z13f/sbQKsOOu7+zS3ZrxSw7pQq1 +jF2Gne+ic1a36vTNptNiJEF0qs/FSoYmRBROn+zG3X2WlcqEuhSwzYBdshsd1XWqrce317fKsBO2 +tr6F2ZNVstujXdZZ3z7DblirWXa6U25/tqw6bdvX47u8s+40f/5YtETv9oDde7Xq9FKbYYdWFTCs +NGv0S6LzpMt2e2btcFRB05J7KruCyAUruJ2kOsuCiSF6LntJh4VZT69Q7WLHLo7cai3Y0ADPRbNH +VNkZria1x/mEqj5qYl3H6tvFkIh9MZtBOR1OdTrngb3XVVaSMys7YnKniovokl0lubmicI8510ck +HbIh0Z2Qc5zrcyoiZ3uuzz09ORSRs5yfWd03p2IjbufnXGvANdKd6ozo7lJbon6ce34ptq0LEVke +d3VbgM4+0rtINt1icZh5s+nM/AC5Fufqsulc3g+zZDadWUxQzy/LZ9OZ5dItmvlonU1nFos3P2m/ +TDadBi0Sz5reP7ZUNp0ZKIcbQhbIpltQI8+ZTWe2T6PoypVl05nl0pH+/mqy6cxy6Vye7Zkjm84s +1i5XYF9dNp3Z6qJI70qz6cyMG/Ls6Gqy6cxy6Sxum18im844pM8ta0tp0Ww6M+PU41t1Np3Z+pmc +hloym04PyrGm8ELZdFa25Wqz6dxjbJlsOh0o/Z74irLpFsLY3Nl0tjlWK8umM8+tXnU2nRkA0MuK +s+nMdkt0Z+BXkE1nJh603usqsukcdkZWlE3nrF9WkU1nhgzVGl9VNp1TJtdqsunMcuks6/Et7wBG +VAdQU19srqubrKt4GYtU6mtzuEx8+nZgdg3yuaFVLZvF69UZhjSFuzyrrldnbV24w9M05J8LTyqW +NCchYU6mo2HhkgQ0CQoWWc9Wg9INya0ocFFdTrsxtdCQIMbAoOYqu2w3JPODFJYSxgZPNmWXLUQm +1GJaj+iIPpnoPCJ2OzFyKGxuH5lTqmXZFbpbuswdcc+VS5N8kTJ3ltXlTl3lKrksc2eVyeUukc7V +AQn788lqobvl1qp4P3JTZcY2SuWqzJ1jRBEiZukyd5INY1/obukydzj3zaHQnbvNo9HpCu65Yo+u +aftFdJ9ncbqyI0qjU9XkXjiXB0ztIOiWPi13eWCBOsezh070CdPooPNsG4F3lUjn5kSzxznD0PoQ +h+v8QtCLzbHDOQ6RQexYhv60lOyuwhboecuvzyeCl6Zaztnsbiir/Z5ipb9gYpfmNBQgKofz4K5P +QwFQjufHXJ+GAsDcnei2P9iMZN9KMh+X3wqBFQVtrgOXVt8lHFe1Xc2gECe7qqvgQATFkMlumins +nMuOgLlKrLWqAaFPrK0OjIm11cHqbgWEwFZSyBjRGBitG2FG6i5LVNbMUOlY79XuDPWucUsXZuIZ +T1DbeuJWZ6jbk+5KMlOUm4/ntySMoMqzVVUwBC8q1lvErnn/eq5C1Va7b7Dw2tLmBIZid6pzDjgr +uCUAw1m2WjWGIjOh2Q2H851VvXaRyDDXDm8wZMKGNy4SGVxF4JeucCfnV1rVuFuADU0OVyxat3q+ +Cnd2mY9LsKFMaFKFu5VUynPMJ3JXKW/ZfCKlUt7ybGhT4U6bl+QmP2SRCnd29V5hjbv5K9y5vdUc +Zj8tn1j79K2aOVbeq+vEWgDM2czxuDF0cG26xRJr9ZmP/LLxI5hfeGaaDj3fPVcIzgJy03BHBISz +knzOM8qdL+YIxzoXVpfE5HG6ZgKVy5snv90siYncFYUCImxgw2TAYSFcxLXkum8u05jcJDH5D170 +niihxdykMWkn6RA7VUEp62KZxpQMuMpQt3XbFa5MBtxwpZskJv/BQG98L+pX3s2VxGR1ggjWTrTR +tPMZhndSDu8St/LrDEOTyxLv7nENiFXkuGaj1reKQf9l3op0c5V7RKi0tsfuV3c11T3afVtRjuu9 +5dVU89swjclc5R4dKuXFFsxxJfhTOYbhIuvZOccVDMl11rNdjqsUAYILURbN+5NNP5jxVjqo5bp0 +NhM7uc1ttU+qHl/uKFStHQzfQgL4Vayg7L7C3VOhxfgPN3NY8aDQLhE7ln5pkvDOjw== + + + rshONflwHt9k6+a+QoaqtHXYktnHe4t8uKB1Et549paktTJZl4ZH7Vrl/glb2+JV8NkqCe/JslMw +l83CiLWcK1Xceri27NR/3Ih+WNVhC6qdKplcKoIrPEN0qk1Nm/jFHbWOIKvLcgwGjh57Zp16fBDB ++ppzmjS8uj73j0Tv6X7FolNhy8ed597UGKw+I+7VptPitmDdafFy68GsU1T3LV7SpFbqO72yqyN4 +emPdaT5/XdCc7ALdbsP3YeWXlIQ52z2IaVffoh2bpSzbkfmV1NtuMu0CYig5nOZVNQnmfM/pjU5l +s0aK9miVZ9YmTqwoOpfHJgFS+SDaDdJUMXM+OOlCNwPYB/rEJscIiXVKkvFoleWQICVbDyrrJrXJ +ObFpsqrKLCig61CZxW0kKWd/tMpy6QyVWUAH1XmOoNll3elunlwiK83hhCbGkscdPek2veadnxK1 +hnl3c1dZtBiS4ZSWnl9cI32uU1oen92grOPE8w0JSEvrc1rSeAxnY3XiKv90uKvdvM4ba6Ys5koA +2Mcurr52iMG+5Fd1eeN9ZMPdDYcuspFsw8tud3le8svcRKvmJBqujFso2c18y3que61f8gtGlrW3 +aMIswGUvoTW7K84yX8zJazHeFWfjAJnHx7SHRky2WOuFueodWEuYwsp85HpBL2EW3fXGCXdWfIx2 +rJzL12lGpo/zO4fsUD0+y6gK9204QNCNj+e3RyxqP/kP7qw3B+dLJDPUs1iiLJt9JtNcOVaJue45 +IIaky39pFe1ix47WuGZIxFF9abea4No5UwG72y5SOcl7rmxSAZ1KGjusn7rz3io6J+q4JgZdXWPT +KjNzAHOqouPXZ9faANNpleUw5pjL436S2p3LJTHmWE9nLoyVuScLYIZ0YTPrUMLYglmAbnMAXd9D +YpUg5ioH0OZ0uossQLc5gMZ48jxZgG5zAMkbDufPAnSbA4ii1gtnAWpIxcbD1J+DnS8L0G0OIMTY +4lmAKj7t5YY2x2reLEC3OYCKj7xQFqDFkAw5gOR+JR6PcVbLF+VzX5FtmaJ8xFx+YlE+Q1ThpxTl +c6rItpqifDhnxN5AWb4on8dnYhWuvCifsT7yzyjKZ10feZVF+VzVr1ymKB8ZVYCDEiwHJaHIKTXY +uqrf8ndDnazibiiXdf1c3Q21dF0/YmoruBvKqq7ffOeUFq3rZ1/Vb6G7oUzq+tlHhcw98fnr+pkT +n+3dUAvU9XOm5FXU9bM/GaJErpas6+eUybWigK5tVT+Pb66ArmVdP/up6WIXC9f10wzEUNVvgQog +pnX97CdkdkJ1kbp+pumIdreau0eM60xZ07ugF6jrZ3/zl7InvmRdP1tFl0VabAV1/ezDwnPdQGVT +18/e1TU9Bb1AXT+zNEmV9Zarx7eCnPe56vrZQ4Fx/lXU9bPfUPG4hrNM4rs+I3XRun4mpiZR1Y+s +zkAtUddPx4aUtqqf5s6uudNTKKWun2Pe60rq+tlX9VMoecm6fvYHromM1KXq+qn5W2a0qLvnauG6 +fvYIRBbsCur62fDapMuuqB7frj0U1/X4HMrJua7Ht1RdPwWKKfvMm81hqOtnk/fgeNq2PW9dP3tL +Ht54sIq6flY6/Ma4k7hY/pYLc17eSXRiQ6e6fvb7zdpTBIvX9dNiW+8tLlqPb75DGtb1+FbAPkpV +v+Xr8blJYnK6vcF4VmO+Unz6jNTl6vppAtuGqn44Y2j5un5KqpRdXdGl6/rZmzkWNDZ3XT/7qn5L +39ok1fVbMtbnsq6fi7zXFdT1s6/qN3c9voWycHXS0ljXb/FkeKKqH9HLUnX9jKFksqqf1S1n89b1 +sz/epdNiC9f1sz/opIspLVzXz2RdiKp+9vfCua/rt3jcUoux+XOeLPzKJer6qYLLrKrfwqcHdXX9 +bCmCqACyXF0/e8MQe6/L1/WzT4iVNPLSdf20k9RX9TPYY65vstLW9bM2grAN43CTlcu6fq5smKXr ++pEradzAscmuteBP87p+9srBNotzZQmxWO/HTNTDg52NdnFtfuJDf6/UJ75RUacrwVPr0K79wXtd +2qKGmmQaU3dvDg9GZB48jk1JXQU0GjI6VBFDxS7agoLPc40nWp7A3Ddm8rkB1MrJRujxfJuK3XVF +3AjmU21snx0eR6nAYCPWfBxx7PjzpHDYe05cXu8GIv2gP/OdoUof5+mt71lG2Hiqt1jw6y3l4+N7 +pZ2zi+8r/rt7/+jxiXyUa8bPCnfR0+h4gy8XubfMVff6qFU9E24/a+1z/vsm0H7fvk0HudzXZu3q +tJvs7d8N20eBwfer+O0bpwbC+cbt+ZF/mw0UBd/74/FxcPa59cgNn9pJifdRbufhda16sxENvaQ2 +mI/vm9A+609Rhcxphiq8N0+oorBzNR6/JQLjSfz2eLL1IjQmfOOxomRa1kIHschtlC0nNuW0t6/Y +ePI0hMXmEls4t9ooQzT5pXsP5ddEunk5gg61UgIS1pOcvdG+3XSqfGKGLIQMMN3pDlwXdnvDcq4o +ozFQ97crWzcPtcPtwThW2GG4j9lWr7XRgpmkJ3Jy6MYsPOLO4Xm1swHKSdxIF2o1H7XdbiF/vzLU +muwjHfuAqVWyRNKcGm8lpgbEmhkeDgVfdubx5R4K7TtUQDP7XLy6E86zrc1UbLp/kopNWnuFxFa3 +kr9NsS8AbYPDYu/m7ildEjYaAM7NtwwWl88M0KGuCFMZ719Se+WNMZpVuj+ElJw+vb19DeVv7krw +F5hwpReFSbth7NYf8vdj5DlRsWkAnkZ4nWJJHOOjfvkXHUCxY4ARcQD+FHdR1i8QOMcj8OdBGEmY +LT/QYo9j8CAblT8sxAp55iwOwJaoUC7smxUCpeNjOuz/7Oeb3e8EFTsUg2igcHDP9G6W3st26jEa +vDgIES/q29kDj09+lY2or5jMw/WR/OI4pr5gt/c+0vKLC1p58SKhrXiwqz5Te4Z6v5gNE69g3xKc +IuB6gIldMNOnEJxzkHmefAEBWLyi0U04dOnoigXTvdwlptv4CEHMXgKUHwy7dHNbTCr7YkAUQvLK +0M3IAQ0bxWDeUp9uHh1DtF3S0jeX1wgsTGrd34I9h2BuMVJL20wwwkHrvxZRO2WCR6k93Mse3PC+ +yvSiH7vpSvO9nDs93qiqJKlsC2S1jqtP63BmmGCpsG8GD1DyohAvywcKxAw/rWy3i88P8Y90dbbd +yT+0KhScFY2oF1PyG/M8e0lJq3H/wsrkVeOIqeeOxKbMB7cRhEAmd5mFGvA2JpP9LYDdeIa12W5p +ydzlbyXrYgh/s8ovDoPI7/UF8OeDBPG1WYBL8hCTv36glF80MZo35qUjj+aBRS88PulVrrst8UH3 +i8dz0Wpa7Z7pjkbMKFLAQswAXQkFjU7MJJ8vhoH8bebsJBPsjWFOv1DK5KlozShm9FV6/YjagBSI +oxtdg8q+GJCWEsffdUOYJDN3LxMwq81orLNZ2WG3E/0pRQWiE2m6QLigc9MoPAn+5IIoK5jOP6Xg +n0nASNtfh1BuhInVfwLf3ECaKEWRGQRPqkSR404XX6LQMS/FLEIwJUohyB0inHLInwbgUdFvOkwN +3jw+eaFOdzHfhbO+hvJM4l9gw0F2PgULL96Usm/ddEsjhMoUxTdO4UKcEnRAFzPf0OL4uEAYOwcd +3A+RJIZTf0pLZgkQPfgZFq5Q4GBNY6uHJN+njPPXVR+5zOtDC6rG0sJBFBM6qOZbVMs3yI3HB80d +UpGjqs/7p7eKni0x2VqDIz1x9BQW9T2TQbz59CBmjco3MBjiM2xH7TwwJ4QxiZ5tHNzDowJXU2iD +XaOsfNW2LE9grn6FBMEPC3oQ7PGjCqKqrV3L40XEqqzw6meC/YwIzcGAxweo6IOCRByUnta/d6Vn +3c0QEPUNXtGkLY0NOuziOaNbJ9QS0qnb3Tqg6VABvIhGEKNge0x774IsMpWayYrZ9axaXKG93vU5 +HOgmfHGvvYQioK7L3cYwlgdzQYbOOHP/KNs4wDRqbF89AcriivrKzdA6ljE224CdbmBUcpPHHYin +Dfm6jcSWOhrNWbjDBjOUkZBiQ5o62m8yErgYQoIymi5RTQldXIBRkJtUFRQ8ofrIChJmjxcKEnTX +f4R1SDBDAZu6DAQkFNSPLnReEjqkDZEAulWRIC2JBRIIFOB6Doj2M8FTBQWl5+jm1zVCAbBgFUow +owN8Ng0TsXjRlZDAzGgSBc2LMys68CMxCvgFj5v5uDQnJVsQKOHZmRahpWQFor5ZDC0zBpUYwFwW +BIHyclyyFL7tRA8C6JdubInVCOCrLhSaVmrWS+TlgqYD5GqQbGGNB3098YCKTOtpHCW7AxnErh6A +igd1DOr9MK7kk0rYVClXbSjXrgy07YL4PiF8hUwtc6li7P5ZtzhqywUJRJW5i9MYUAlRt2OwoLEl +OT5A4mFBGiO1j0b0WgIw0BjJ8ZZkSoLQT4NkVxmVJjRmh4m5VkMFQESugq4wYTOGIMnxmjFotZgt +CAuOd7Oc+GxPUF2NxYgqSCpjIypl/WIPgljQeaeBAMDMenlBF5yGmeDSjQHMxXYULvhzw597upQA +MJMXLQAcK1E08iKY2FWp0n4MikY2jkKnieYfg0qVi0rLXTdUqeghxPt6TbRrT5cuxsBk7ulj9U9I +Y9PkifqA3U5mT/EmRfurHZO8MuW+LGzp7zAhyRVW41WF11fZUawM5bBEdUSHPz4Okcd38y3F2aBT +DL9WnOIY+hPuvAekX19teP1FKYj7e/d/w5vOSyHpz2QAGpCliPRnmcMA4Gmo6+RU9rCPKTUWRpUa +x3eF1+DjKfJzCS+XCMppXV3ixTXdUl5EwVyIVx8H78orMsIX2T7+lF+c42nQxfJmXXkWIj3jl6gS +rzmPkBESujhKQn//XAmynFM4PlYSyiykpwh7dL0xo2KVlBrNe5WiCpUC8qUh6bYzyLyGuw5x6AXG +wbcXY8gvlYsY5I0wEFff2+DPaxp9gxcnVnlkY2fVLnRnaiEi9tbaiQIP876sBiLf5F7ewMILD5Fc +rL6/k/wY+K/BXPbz3JfB9S7eXZKbyfKOsrL3kQBjHGTNIJrBw6duHCDK9zYiiMGT+GUiXiyk/O1a +7rh1sCER+/0drYTVGDKi2Hvd8vgk8rqvc8rU66CXaULig8ZFBIWXJQ+7cR2TyL5xR9GN8nEQ/Hqk +pXBR44U5TBwDvzHWqLPyrxaH48lhaWm7VwhiBG34gj/vYtLX3cf/n7Yz79etqK71J9jfYaMx0u6z +qq8ydnAQMTk2ETGiXgkgUSMHFCE3/nM/+63xjLnevfcBESWJv7BPrXe11cyazZhjHue/fnXr3307 +f/Vbj74Zb/P7X5c7P/zqqfImqyD/+/f/+JX4FrtfL1PE6lTMtn9+HA/YV3nFv/Wlf0ZHfe48ZS/r +LZ1v5FaUEf7LP+nXBxc3wS/5lvEhXnT7uERRd8+L/lr1st8L+4/n6v32CxAQanX//A== + + + uW8+/9Nw0r/7o/F1S6e91H/xF/jG/+NX3/5luDkv/9EP8rvL/v6XZ+4u4fWRhMu/3F2Qzz96ThLm +X14Ih9dvvvHg5X/++geH1ss3X7m562Nfv3/vpfe+9P4rT6740w/1kpb9TX75hV88dzz47refk639 +fSJ74ev77isv2JH+1W/8OML5H/y/b17N1Mf1zKldP/jxx++9++EPP/zdb373/vXzV/909eDF76X0 ++vu//uCVD9999yfv/vdHL3/wzseP333/o+uvXT948bWH3/vebC+/+84Hv373GjxK+/dxWSvPxRwP +f9jdqOQ9R5k90i//x/ru71/98o+/8dbL/3G88c07bjRvuX/4yR+fev63//nq1Veeeu6dm6889fyb +v/7FU8/nV1576ulX//S8mm/Yi+Ag5afGxliKz3755Xc/fOnj7zz3/Uf/9oQzHQfC+veffPcbe77+ +20vv/vjbD/70m68/ePXFn//Lyz9/5aevffvBR8cHnqpPOAr9pZfA5afEOffm+9E/PvXM139Qn3rh +wVd/qnjny/tb/uHl+eCp55/59rd19J+feu5fv/QDfd8P9MO3nnrhxfLrp57//s9eferZP375Q/nI +ZuyNr3z83ufdG6++crs7/u/tjdoRz93xM/bGW+H1N0SjbmNRV1/534tG3cai7AH//NEoNf/2vdFe +Y++O/3t749VXPnsv+5/ZG20Lfe47/p174xnL0e74v7c3anc/d8f/vb1xf8tld7zsjbfYjId38VR7 +1t4VMxcp8NfFjKTlFjSSJl8PiMU3f/8ty5rn//iHH366mLnIsVDBH/yjPvzpcxv+/vvxuT9899nQ +hveO8tqzEereokn5+i9oOh/conzr377zFp8r4aKAzqtPo1oKxiNP8qvPhkhJX3oQ+1f7xvOXePYL +kQ9MvFtwmZ9ddttnIh+tvfLg0yGDW/6cE1KY0xN4uiVDxQ+yl/XTT3/tlBZfe9b60NPpO7/62tfP +o99m/T7NtomsuQSdbu7u5H94eLB1f1Lq7P0lQk7feJZom+NSz93dun+Fq/oHoQdsZfzB545P+t6f +yPK48IB4GG/nEwGmbzz4z1sf/vHul9qDJ8JLYo7+1zO89OFzn4xQfeu1u6iX43u/fP7m/i1++83X +33z2O08EmO7N1T99+bMjVMd3vv5D38A4oX/95C0+vneLV//x1btLpb721XO/Vgz1+R9k2daaT68+ +p3/dXI494Bg8ht/cs/b51/4olMaHFjN7c/z5nZ6/4F8cbwmYyzfy54v+PP0YvKNDH//nL4U+3vjL +oQ9WzmeGPgh8RLT400Iftw6Gv8/Z8+xtF1x95dlffFjevkMEf+mEZx7+/Ne/Ojthz+67nQDBobvg +V3e7AEdDdMHPb7tAnqP9Pnc74aNv/vGvdcJbX//BbReUX7yX5p0Q2Kc4MP82H+jN5wiBfdo8uOVn +oUDy3xgHvIcH/OkHfzGGdvWVz3eLN/7wRebimYHwRSJ5FDj5zBt4XD7zFm//6Ystqe/+9uPLqvw7 +R+NHv/zD55jT9k1/+XZ63bvFm39hWXzervzRu3+6lZZ/8TOe/Yc7t/jWwz9+cO8WHzz119/hjROJ ++Olv8eGXzlu88fj2Fser33/jnbvnvfHLy/x9487AH6/8n1d//MQc+9HjLzjHKMn6xebYux99wXd4 +76kvPMd++v4XnmNvfPA3id5P3uDtDy9z7DOmyM8/6zN++7m78i/Osd9//MVG44037yxX99in9cRn +3uLtv03yaRd78hbvfvjFRuON3/7piSkVPfb5J9Ubv/87JvZ9PMob73/8BT/jw6c+bWVs++Xzf8bH +X/o73+GiJ//8y1/+a+sz/+mXt7d46qs//e1r93A5b//lPeDOjvxZPfH2u3/8Iu8gafn2b7/gpHr7 +938FnPPXpeXb73/0V0XdZ+5Db//x4zt68t+1xN/++Km7zXe+/KV7zX/8MqYCerIM0o++9Zy8E/0J +D8nx7kffniiYtzbdHbPvrX94/Eub8l/9xhvtRGS+icn4womA/eWfbFdeYiuvXvzeerK8edsUfva+ +Kfy8MZluPry5MRjzvOyO37t866d/eOmCqN6G7R2P233r9o5j7b6Be8etdsdtcc8BfQsH5imP7vj1 +bl9gm7hfw2n/zN0nf/fbz93xuN158ndfufVc/Wp34Ot74n730YMzT/vBd394yI3wXLjBvvt6xit2 +19Hzo4fP4TgLR8+PvvfCaaR+/GxYgT96dGPfmnjPd/PHh7T/tP/z6z8Rl/qZb1u+9ZP3bwLm/Q83 +z4TD6I3vMZbP3fUUvvHDG55SXppl/tO7v3rmPx7+tr/yw5fem1+ed1zXdtNuwztyzj9BAnZrvb/x +4wd/0x0/7X5X9+/4+nF7x/76N7728MXX//Gf/v3hb8e//OHFn7z4/r/ZFffSL579lefvM+/87IKe +/km5zWO4O7pvP3r+jg/2rXBAvv1j5zko2/0Z/+utL/3UDrhb11B+6eflVeUUvbGn0te/x79iYN/+ +TbNvzR7a379+Az/+d9MFAf3CvveLT/tfd/yyv38r33Gs3fEI//439fQf/fxEkv7s+DKm2a1bzZmH +nwq2/h+EWuNV+HSw9f8g1PrqK38RbP0/CLVGWn462Prvglr/6f998+qf9pT6Xkpvfuf9X9+NMV19 +5Sv7yGvvfvTxH3RCe/Old3/zu/cfvfXndz+8Stf+37H/p/+OdZ3yvM6t7UbT0UdvXz3NudfpmetH +71995c0HL3740cu/e+ej333w/lsf/vn6a/tQun7w0gcfvHf99Ivfe+2Vf7v+zn//4YMPP7r2ZT/5 +4Prha689o8DWZ57309/96Xdvv/fuvfMf/Oz7j17/3svXX7v2O7y53+GfdHU63txvsX/yefvL37w6 +rl/c//+z/3v17Mf7u17e//7h1XFz7P8r+9P+8j/8v5+9dXVER+yb/Hk3/nn/4z/3of97Xa+/f/2L +/3Nc/3rf92c/vqr5JuV2XfLNHO368VVNN62W61Jueq7tWs3Rstrr6OW6Hjf7tN0ax7x+52o30xqc +7tPWzbHa0O1a7vW6zH0b7p56b/uCMm5SO/YP6eYoPV2XdlN7Wddl36ilynP7uM7rpjY9YJ+3yrEP +zJsxZ9Lfeoysv/nI/Tp3n7+f4wfkfcN1cMLaY79ftPWp+63S9uX5ZtT9dz9u5v0FDzm/7fP1QrO0 +6zxu+uy8cmn71XVl2h9U6SZeKK1c9eKprM55ue/r+01N+4XUE3P/PG44u970Qx0wb8pYi6vq7sDd +b0edRVfluftN3Vp7PztoD8Du+DwPOlwP3n/W7pD9R6+9B+2oqXkA8tj/2kdmr5xeyv7T9vP2Y9f5 +r4dXvEK/rvVmv/7UC+bFibktXqS5oXfY1/SZae9/6K2PXKuv3Z2/v+ronXYZ+2P3FfuF+u69WvYV +ieFcqyZ9xd5olnpxHMufzXvvbl5lNfqpzz1A9WYs7rzS7v09Trnq58r8eecqLX0/B0rP5TqNPdEm +8yfnPaCpq2O4H1+b2k1Paarj6fBHV2nfurjre98Dtc/IqVS9cpl7yqZyU8cegv3Rmg/7kfsd5tjf +0Pej9xRM6aYP9e3cM2V/09oTRffTNN2zsuayB2Z/Vt3D0G9mXXt6V73mHrC2R2ft6b3vxefsDmzJ +o8FxrafeqoaxlJTUTtw8xYjcjHLs2abZ0Pezdy+UWoc+tx7q2P2HhTa4Of9se8Wk/bq7g7N7su0F +nG8Wr71HrHpi7CE62v7wPbN7m/s7NSVT1wra12/ZuUdm7VNYGiNruPdb1JT2zffyS1nnaACrRm7/ +tCWRl97hsZOMKHP3U04MslbasXs87x80K9JNzavvv3vJdrpzv9L+2D3GpWlJamp7xNaUDNqTaJV9 +n+o5pC9uR5tdR5qkyn4XunGP6cz7zMboJq2v5nm0B3fsz7wejHFSO5W9WWi6dIa6NuZdkqRrGuxc +D57JQl2atqXrnZFsc8u7PaQxU0fO+86rjzHUD1sg6Emp5T3ftsAp6tZ94ZFat8ha+y32kVrWPnN3 +KiJpy9LK2mDS7Dc4tkTS+f3m4C332m9eO+tQv+5FV/dkypod+wn73fci0gWSzuowjfCenXt19bH/ +7vZMex3vcZmtcsEqlqIas1bolqm5P33lbpe5P2ovt736tL9aWr6jBXekSZcfZfA3RmB3Boun5aTu +65OO3R2YNCL7utH3x2w5sAVi1aDntdcPH7h2HzGFtthcc+8z+732KKW9nvLS2fvN99LU+tLd93ft +mcrpezlpxlYJMC3H0uruCvXkuh76i5h5eDW8OvbUzuOQmNiTnnWhTpRA3e9ZJIBzYVW9sV/cCyjH +AlKnTj083RTNas2sxtzuWozqhyyBtW/UBlMUgavJvnc+JjETct5EN44y+Hnv50sd3dpK6paZ9+hr +Teihe90nbr9vw1rY++DReO7SNrTb6RzqpUXd2N/3yO6NrGoktoCsi+nIfpm0n1Umm07UPGc6sx8W +L62sEdizdG+papda2FmzFtL+zr2G9Ups5Zore9ZtQcnOOmpmZmgWaq9Qc/dTOpY3DzaJfaSmrcNo +C9VM1/Sse01u0bUFBD27p/n0trokqyWiq7WI1gpndNQRrZCCTD/SwUvtKXBIQuwNKmmDUn/tz5dc +qIvte2a/5Ch7Y2YjrkMzt2onKdpJuJd6cqtCXHEMerpJ5fEz2l5O+8hsCxVhtc7e1EdjG200vNHv +b6haYt1LS1+ZEmevapVqstT2FjK17PeBtKU8K2Ts3VgSPEt87hddGQ2mz8rvZ8furU46iiZTti6j +Z0tmrc5QtqknTq0KhnrPAH7fYhU5lFpjLnpBrN6ZyGz1iJVVtWQXOodW35bCatYjsTbZcHc7pp5e +p7KIW1LPLguTfWI+Ou+RpCskD+6e3PrS/Wr7zk27I12tXado7hU2BK0dLfNYPGXtCbTnNPdr2ouS +vuNoFdk9Cyqezt3DOvbC2B/d2sE6bFJNpElmyyVUlbz8F5ViaOWq27hiC5MxaWdtCf9l0V9RSvee +UdkC1177WnN0+O5gBLy295WtTWq17wN5DGaIpIa/p7AYkeTvoL1J75G+q28qoX0wZgXFcM09KfRy +tWs0pblvpUMfkPaskZ7PBbvTNTmlMO6xK4dO1ftIJ9xa8X4b/SRJJt1766z3LYR3rv7j6tnXt0Uh +m2RvQPVau85WAJ7+0Ys/+MkPf/CdvQjL9cNn9pH/lgXz4yurZOo9GSiP9Sk9NUTW3iEan1IrK2Nq +y5AujCmzt8FjT7+HUnLn3lxYeqWjRqL96J5r8vHe/rcsS8gHTXRvN3NabTrUF5JqfdBueTLoW8tM +1qPXOFjtWfvV7j3Uf2kQQwrXlkV5sZ/1wWqhQy34trZEB8/QIwtXZHQ+yaS5H/lQFzBk2kNR6ZNs +gKn2Oqy6py17uEDLj+8ueXCLPrYA1GtvdVvNFEZDP4blJiqrvqL4EVlduB+RvPmukQ== + + + +KitgVS1t3o5PUnQzPYRptdujziDfRZrUIpFq2v6jcaRUDVknxUZR3uKSNPQJr7bqRy00/4mWR37 +SEZV0XayW7VLRGgAF+c3bQ2+TY6Rk1qw/7S93zA5xjZBltQ3GVAaWXSj3YW8ku4py3Qya4pU4i0F +h+6pAS1aIJlHVilHCPbjaMvvJOtGAvjgm/dKx5DT/ZLU0rQs11EOtNOXwgVsYFKcpYO3S6eHQqcj +R0ZbYtrt9pT2rmFp7FYzhhUziwu2iuiRnLbGSmoeac02vVPu07pFjXeyyqZN9eCrj+52LQ07KEv7 +1/xdOQzLJp1Ic17avNpHZ1HtObKu7y/Td65euarNMmUbLcW+gf2jNs+qHtvDVUssL73eFuS7jTYV +FyBYbMzG7ruXwMBa7bINsHaQRbu5LQSvkS3hJxc0rfS93IruLH1z8QRer4bY4xFTUkSWV9pLXo9I +u8uqdsWJYeyZPM532lNaCuo+kCToWfmVj5gWDec7nU+QzV2xA21iLk8wuqcwJQe281gIXk1qHrB3 +o+lJvo4Da3mmtrzOZctXq++sKoyPWj0UFfuq62tXPqJdsa63sh0LfduBdE8aCAb0XNmyo2DjonSq +/7dS4QtKYcSSfGJI0MINpFzw0Y0HHNraLHokvdSdsyOUi+wkDVB2My22itxzvu+IOAQbRyZbkGJK +nW+8V5WEnS8oMnklOxq33OedMouP7oc6IUljqyF8ykJIJdmh2hZm4Z6J6Sif0ow7rMse2JDeh0wh +yWxpfbpyCx61WV9qFxwZdJBlK5ajhkTan+5w2AXi6ZEu+6zMbfdM4m+xq2NLB3mmaome3v0i8cTG +sZpnavhyRim8i4w+vUC2P8cOJ43x3g9wrUj9qPKUeGhleVc50DIrpcqIfIdVmiuzp2l/0cTuiStQ +bdVmRZwurX1gG6rFzojJN6Nn1zDp9QZyHejJyRO2hC9FRp9dJHUs2n7UfckhnUHrUcYsvqV9ymMd +SUmeMx0pvBeWoFw6y1Kklkx7z/HsF2VOyR8lc24/pm8DVqrz3FsrK05fVtDtsvsi65vxI02u2IYl +3hC2F31AS5gYexNP+rR9pGQ8Ub36E9nmpa63hntoT9fud/AE2CPATrN/mYt139iIpC+q/5u7DaOE +/UHdIzsbMd/tFYqtZ3Tt013SOAZnXy3Hg8Q1khEPGacya2SdVPvvao35aHdOt9KpYZ9+HexVTZxe +7TnbBqtHk1WhgShjeaYVtq1WmdB5VZq4YZiSaA3attr03NNw65GHpXZd/p699xZfUZf3seZ94nCP +bD3Ya+T8qOWP2M/s00bWKJZLGvh9wnGwcSy8xnsjKpjZVTtn4xXyKqz0Y61uL5jF0Nb9+ehuJ1my +/atxPQoLvMr5JDOsVxZ46Qe/H8PrdguipY2yhBa6r9DGIWe45VYb09brRQNHXu0jOWtYt4SoE8Nt +7fnJ1mRPXLdmLRGgLVqWnTfL4taxvHniuJNV7I1p32dqcutTik/YwkntU3YvSXe5rLV+Gem9LXQU +/bK1p0cM5aGePdRP2UPTcOCO0fCOSi+kaYdztaKhI5okVb63Ehfst9X8rPKPH/YteQ1ipO8j1Xv5 +3joIAaR03O60JVlCsM7xSehT2cYkVhw0sJO7efVioByxzmv05RF7Lx5qBR4OS8mt69DO8R06osHZ +fc0s1yqO0QhJsQ0t/PuhEOm95bsqmowrWbjZ4S8jT2IVv0C9CAa5/ArCJw8t8+lFV89/hn7pRtcs +HXskj26RqK55QmhKkG6LbRucydGabc21pUytLXLUU7JWpdRNeSn3LiRzULJoKnqDPNlHSvaRITmG +U7dKwd4WqUxO+S2n2o1JwxVIp63mjK1Cc09NEanok0ALu0M6fC6uD2nbWqBZvvJtrspVOfd2uu8+ +MWGkLZQaTgd9Gs7MjIsOwZakLxSM96KNGKWrE7FRvw+ej1L5iCN72Pc3dfQjuVilGMzTgbr3B1my ++1GHXTU6sjVsuX/1aYo+tD1pd5MtM1cvSXnv7STXGfYXHzgn5GLQrbYAWnK+7DYWlzTj6OhmIbgF +c9G8kJc3cUbyS/bTlXkZmm7t31Yt7gJUKUI0A1dFViuxWz+k6/YE1IYVXZuqfndoYbexdZvtfk7H +vpaU1xjpBMU32vmCw8ZFQwuIsdHGpt0KN/Gejfsf+qKOq3B40XVtMJlHTGsOclLgb52IrO5IgIJ6 +Gg6JaC90uQplL8rJKT1NzkWFT0Z425msu4/GzTkM8s5kHdjS/ECmsIjUE/IElINpq98xf3hE2xNc +c4G9Fe/knrZ6U82nO8tJq+tjrVqFh7aGg7cNPcXhh30EhbRZVO4J21crbJCIDnlDsPseXmEA7xm4 +D3m05GJT2I14ad4T6KdXUw7XfOfQkD2xRY8O1FL4inIc8/bAQ3m2GQMpy0dShEwb2pYAL+xH2YhO +OLaS4jhH2l+sCE/DU5UUNZIdKr+b3CPycMohKCVegZ/dt4cuUDQS2zb7/fW4iiCx7to4ID1ee19F +Jzw0GRgDOWOaPmOrbzLFCmGJtD9Zo4XDQFr13vqvLwcULZD/WgfQXrUPKUCpG2/TRDNaa0sRFJkm +TG05QOnTMqzAbGGoxalrymy5EVjj/vvAIjiyX2Yo4nrIgS6DrSqAs8/wF+gtFF2rCjSpk7McY/Z9 +68lVHpctmCPAwNvJi6OolKekfCVsKNIXGbytIkk7arjBs7s3IzO1a3VeZk8ODeseXvtf9iLXHNsr +R2F1DWHBhbvXTta+nBQr2p/c2erVbiFdPC10xSBSrl6TfEiyQstitWrHJ2JbtRrlbZLqm4ndavXt +SbcFbJapNrS4klfz/hJ94ZCbtrIc9zdWHajMvL0ODu1GIyRK0WYwNY/r0irV9JUvXY/wdMIo34qI +NgHNhxXzYhBseXi1tsQbCIBOCGyricktadpLXjz/iph4eIXHRVLa3iPsYYn1PvZtrt/Qro/Xdx/x +0pX3t2tqHTjr1JY7pQoMYI/XfXHwaMuIT0WNjOsH33v/o+unX/vpd9987bdv/eHdn/z5D+8a0PG0 +Nj8N2zPXD1776MPfvf+b66dfeunFd975+PGPP/joLd3lDvLj2Y/3/NjqzoFEURiZ6Tv2KMlRd4I6 +ToRHNsIDFXzPgy0GDvvBHlsIbRH3woEStKfXKYV0JLPHSAw9eewRokn2McfQaiSb5P+8e8TCiSPq +TaJpTx57pGMYVPePSSjG/RV1w/+VtXiStHAt05xr4qruc1N4AOWuSSgCTx55dJUwXCTYkrzQCRsA +Sai4xz7P29IZcNZKfOLQo32oV5whcu8ptijRQVRJwlB/JedH03Z1Yzmk+zxxSPfZ61GRsy0PCQ3v +kbFglvWk6XrnwOC1dZ8nDj3i0H6BhlxtfIZEjxyPd+TqE4e4bJ+MHEpJEuJyoKAs8fhWLXsbRjGP +v3+IzxhEyDt+HGaA5MiB+GX3BnxUkfzbFs3ujycO8UKJ7UUOO3mz9gGZHiy2Q98qcEhVQEnhEm93 +nzjk/kCxqlhP8uwrMFpDhdBcH1rJW/vxpHzyCN/k3YvAeWKDnfi1W2iM8k2VOQfalkQHQ3z/0CN2 +ma2bSrS3YRjWXreKRNjAl2Df5qs20o6D3H38xCFN24M4dz+BEHtL2h8pYT5jv057L5foPmf+vQO6 +Q8X6krks75AC/bKwpUF6P5mYhAMLtBr1ce/I1qJBFaAT008ZCEBCRssOVehf+opsEllIEv/3j+ge +DU1NzgqZnpmoqsAQu1crukGfCGhjku42H+1mKYXdYNpFsSePXBjy6MtJsz9Ocb0RE0jX3z8iQdL1 +9roj5qk2Ft+iY96sUE4GwdfEFnP/yCMdoduHcD+ZAwkQkU5RSFhHMu6GOEWBTJm2I7QjbUxyM4zQ +AfSU+0ceeasq3PS0tJkyQ0E3OwLLnpPX4W+Lfz/C1FXEeuJNKtqysmbCRNjUYSeaAolam2xg9448 +0hGFXauMaxudwGjk+MA5qs+U8Xl3D7x35BEmK/72ROMGQSlbW4ahwgOJ9Sw7QU+q2BFaqpz48OrJ +I490pMh8kXhJjiIUR1Fut7RPbnIPP2Xj+4tb9N+2Dwt1qb1RrntZFVN7gjfVyabTvFj1AoppHWBs +arY5UPrtAb/kvUM4XggC6dC2S+xpHkhTdV7FP1sXZ4wDLZRuu3/oET7RhYxI7ACaDtaNi12wI5x5 +MVyM5r0jTAgZGBpfXIV3jxSUQ7VxMSn8l3gKqmEFkVV813tHeLMmNbIzr/HahO5nXY9JrRVRMNli +lt8eiCUyWcTo5Q6sIJEwFn569eQRrcxKzE22fgOolfHW3bYTcI4Ru6CW5v0jUk/8hvuT2Oi2eGeP +GbJWJ3ot4ne3Zf1bEN07IlnWi2WjleUiW6JLYiS88AUQB1dI6+Ie94/oHgnkjBAgCilnQYYGUj1Z +QstdKhUfDU4C+d4ByeMxqoZgJa99BRC1QXXHnC2xZQd3x7dzABn3zoJhvXUeVPzusCxGwt0DukFC +L5ADWmslazevmc2sYHROPNNGS9iWuX9E29dIw7Av9HZZM3LKduFWBGmJ7a0RYvf2df8Iuh/AJJkY +CqYlq1Jyd+CPE0yBF6ohcNH+7h/Slr4OvHw1QIfSxXHzAoha1snDRugx+p84pPtIuAoWgBdIImQe +jqDtqTpwDey3k+1TARJbNXjikO6jzzwQt1hMBwMoD608sli/o9prfMf6feIQ96kH8MO7JudEZejd +WtxY8vPcs7yfOMR3HfxTWuToaDg+cKtnzoP4ZgEK635+4pDvM9NhrVaeWrmLcdVK85XY0IFsf4Kn +LPe5f4j7nJdZUdR4EY8zWqpY65cvZusiuARC6797CBVsDnpnKJAqV78gFZlYpNqNt0wEmz2J7x/R +LTouwmSLBfsheTILPLHt7zo5DGpLd7h3QMt9Ly1rsMnegf0h7CzoHhN4srai0Eg/cUiSa62W8u2G +NY3UvT3nE1vaw0/ucv9DO+izr/89prJ2sZY/1wNefzLLYf/59VW/fvqZ65/929XHmNKX3InPY1Jv +tV1YZ22EmGyP5W+TvasZp/WD8n+oWYEL1hjjEh4QQZGHQW039knVcBDv0Z4CM8uPHD63EZEodX/D +OwdY4pHQ4aeBhUoqzUAzSzs2oeBoN22PjvlejljaVFCOOJdJt6jhNpLPORm+tHf23CToi4NFwgL6 +jBBB/o6zLVDtsT9kXY404546QCnZQBPzKGKZ71ztfxRBT1oITtk72yK+vON/XfWb0wrDjNGVUnxv +jC1/cjDknpVStvu8KQLVw031+Op0vTUC3rrhXrOovPbxnu1KtDBGKY6cgnuC06+E2sr1n68UrEUt +u3zFkmmlCUAc9r+YLArraQuq1qfvvdefjZSLSbj1Ek0ZJMv+qMdXAurJ152Ib0gxGKCMlCqjIZPa +3vEe9EWkREZOseLdFFOZChYK2be/Ph8F75hSZSpwOvm+BbNSQBA4fAOWhQuw2qsovA== + + + OHGGQKpzgZH+inlmIFL7uoUDRZviEx9xjsjWoIzB2SOlDV0f1x1OVKisKTJTwqJreGSm8I6KAYbJ +oAyKTJBUcdxK7GZv5gKx33gLOr8uhxdECPLFGsw33gEUc5IbXm4J8FyHQ8I5DCo+j8SBrZsR610a +9YbXBJDUk9/xzr0RFOK5rIohJQHyWEf2IpY0mDgyHl2OCGNkzaY4fykZIwC8GHvcgy6w4CQFomC3 +k3WyJ9q0g7c2I+yX+qGhtQsi1oTHBmkRV+yOw/xaQoKoXdjpt5pgPGFJS/OG8ISvQLkr506V5WKn +H2TN6hWGB4/FAIg9r4oYcTiPmOe8OMqFMiNhSIYyEAF9N6ErYaZrdMQqiAckE31V7Fgq+XLgbge/ +F9NLmMuOI805F48B1UvWKLVCBun5fufAChWnATl/55OHYxEtKVyiT3YXydQ4W3ZbczbtNA+jzMEt +S28Fl15A1CYigjkw/iRcCF59cEJtjFlfQMhLID/DKfHwE5/03v2ZNn19sXvnsYDQHfxE6HxJ5tg4 +f/+vKwGjE4ZJfH+3RS7Uhdazsnn2mDZWGg2/j/Rt4Y0j1itEbifIU5RrwrkEcTADxuQKaYJqE69Q +eyaEFv4dMNt6tSSs9CBxpCZucCRDz7dRpDWrhLLkBAbyHfZ9df4jvvVAA8Ppo/slQSNv7H3jY3fX +ZaJYUv3BEeMftr0hUDjhuhGAT6U6CJZyio6EB0Wf7Z1L7aIosHICCfUbSKwBKGADdQdJSPX/op/2 +KKy70707u+PcuwTiTyj7ijIB4pc5fpHE9BP7ScWbk8mwObhnRlK88eQsuJ0iAtoPAaSjSx7ryJYq +dAmW1SOO5HnbCxxJ83Zg9oHd50lY3i15hbrJ2h0w2DIxrv8SYN8pCQ4tguTPq1+2g90e21C+bFkk +P4HoMRKF1ADcbvJtCZBNXpHz3ZjIJAXUxq6VkHNZlhM9WbC/Ml9Z8fYugsbKVqrp1jeh7ICEy3zi +Z/izPpX5e/Y+H7/tqXIZn0dKXgDQVwBMRAfd69ZT/CgfQUhSwbLlUXnMkY54EQ67uC+3MpcxcPS9 +j/RdW7akixBV0oNcg+c19O6WHx1PgIxcpwy1y5549tX+GEAh9FWY1JYjSqjw2ug+UwjmS4ue2lrf +uvt7fIkXwhuf+Lb7cihHCmHC+6h9XTAHx5YLaAy1F+ETW0NqC1+TjDwCBZGFgcphY6gtm0auY2HN +btsOfN5ecao5j4S9iA1sAen2EUCVt8Op1FQG2NPkEfgLK3+eJneP1MO7MxgNEA+CBNAm9+begcHs +rDIZjTUh0/lcyRwxHD/0VF9ls3nd3ocNUhttJcykc0hkJpWhXNPXOGAIVpwPTjeOPYEOQYIaKS6s +iENbkVrZI+Ph0vHdmXYJzIZGVoCT2cft2HVnfJ26x5Ojfav9KI8I6Nm5H+XlrIhzGSup5Pb3/xJM +YwD5iv1IECKZ1ed+pHZm2p2b0u0Rp7VMIwzPnYlUpTXv7ExkfGOhe2fSIx2l8M4k6Il8dbc7U7zk +KQD1URUji51JTefHnjtTCQDy7dakz5adce5NuqOm4e3epKfKu3LuTaTjlMvetJveDi57E6CcelmR +oLHG7dakNnLzsjXpCAjW2JqE1zroWg/ixId6uzORON9urSqlA5U5LrJROWF53NmYBJA5cIB5YwIr +2O5uTE9Mh1uZIexkQe9x/zzWESyzbPiFnBzVKNlTOxWxgDwWp3Zaiif2buPXJu/tEPyjhOkdKMdT +LBb3zSU663zCAx3kNKgF+0N5DkcyR0K4Xl4sn1uTIym+SrNbSMHb+0j8nSYwRzBkuqBNI+48Gi7j +QUhMbTsCHX71EQDBu4cd01Rq31y3m0MRaHyMiwwU5DQiYGxxZA8KGQG+pTpxvrmTzmRCIMn2KHH6 +iA5gmjz6xFjdGcVphFSxtHx8BdbYq7cTbTwPyFQpYG4x8shS6qByCQFknEWRS4nrP4U7Qkk5Nnu8 +DpSzk1H67Ox0vhuavSVx0erG8LQKLp4JKe53HrEMTjunwSMdwddxWpBKRSJ/MoKFxeA0QqVl+ZnO +kNnjIrW92GpVp63IqVnuMredI0rybCx3fecq9WK8kVWa730XudxKNtfuJ0i4nKhMGf90TgpOJZZ/ +ahC6mSJklciTc/9ljJtCIPl1YrcaK85A+6oSAeoBZfSjS3Xyyei10/uDo1i5LAY8JbYZtYsdyaQX +P3xydpxKkrJj8d14s31MupGQO6fcKSAnkUx24YpVAY06ENyaAw4R29P2SPdcsa0wx9/TEac2RMyh +TBL+zk3/iZe4b76De5eAIf5OOlMmDqoMKW1Swls3VDgmd/Xeo3YkrOTALd9MC8jsJOMSONSaHK8k +8d1ZOnuqjTv68yNQ53Innhp0RUOrlwl0px1T7PZIBapAOswBOMvR2jvteSY4nUfwpKid7Uly8tWl +zQj6gpBQrMJHJoFR6oJyv9vdFz9dkBzBWVxR4MDkM5dPxb3iqGACVE9PdTDZlyDGjU+fwO32szLJ +SDjbzzs8/MSYhZB6/UlXLx7ev5qNCt8N5Ap2L2mWHoamznBsvGe8aAZAgGb73hV7uIJwRhJygATN +EYbTe2ifissOo5zfu/cUvfTfRN2TBUk9fUzKdU68j5E5PAyuG2Pi/HBjLtaI11F8RA8f0kffw24Q +LG4qdcT3uH0EfXqSDP1GUdu9z7PlACR8fFUDXa0jcxqvn5zWALwMHLw3qWxPce3OUSnAGiFMAZwk +yVWcqrecDj+PHhAFKf/OmAHS0I/ajIpPzt1z8kYruP4Ujibxpwkx7XB0cmKQaVe6c3HVbk5ZkdPg +WJFsxEsjZSDkWWAWAB4qrUejTYLAbMbzbyFK+LorxKtko+GUAvYwba21dqcOgVnTPbM66kwhcFqy +mj2ReMM65ALiytoGpnMOtzlHe68Q5wXVaaaBHl9REMsDcBmJk1KLtRWIMEM3PGlheorkJCsEA0sH +8EjxBiwEcI2UH7WzE2lqMCQN570oS7GYqaj1StTeSSeNmKkXKYj9AsCdvDMzKDVbpwAkstOJJC8d +6Gd4xB7jtEOibWT7OJ+I9FclsWagqRIVilbordpCuGAHeE9E1gigooSj5ZfKMSkjm5dUU7M2nOnv +TuYhfMEjZFnN7jSn3py46PEnQUJZhWxkSoA5kvMRAQFrnmvLlsJBQnFxvof0CXJzs+/00BpGcpKJ +dj21xVtBW3NpOouLJJQRpE3JeSv4SrXDOatFVoFSdpHkmX3vIfqISDiUKKMZU8AGKT8oeVot9ZYS +bSohBeVPCdahVJx5qiDZ9E2xOkjwVXKPw0Yl0g0FvJ9OrGMalMOuQ6mVimpgRaxq9X1Ak7DIW0SK +mJbAvng5quTFX2dGCDk8hy2VSHgiLREig0IbcKpyXTKJEGIY0fQn+2SQe2TqgxndcHhdwWgEalus +Xi1YxWwUEYxTG0addXPmIwwbg3pd8j5mqL7L84szsl+/x++RqLD3D9NJBNdGls6P2SqDbtg85w1I +PFR2R6TXkF4sIpZ6cAUwPJnvwgTos72MZLAfWHC2qCS6Gu0xMqwYjdxGxVR9QTXhxjk4ubqnS7D9 +0PZwkxTGFeQT6Uiw4Gw9kbwLYk4nBQhtEKxZ6pQzM8hKUbKch6RgMisbcfoRRnLoSPYTSIuBAC4m +lL6qyHnrJuEOkRlFwhkw3VwuM07BKdpa0ZoEucQTrDAfBiT5DJv8kvm6Yz145OlrqbZXZPviEK8e +RSaaglSRRljIsQg/FxJXRyTcc7N7QpMVf01z4pPWXiI3ObfYo5LfjvygymrFMMMXFau1pdOlg+kv +s2kwhxh4iQNZVXIFYLcEi4BZ1jCqs3Fjys85LF/oQ7Wz5VFzqog8FErXRgJlrmBZluDLUoYOb3nJ +T5Z6NAZHDJnQipg0tRVr+orVpaB+dq89UE3oD4OlRCysmDEqg+CyI+AwqmlFeErBm9VMJldROJCi +csuIq0OSpp4uDMthJ+hHIBCbeZnmJLndyEo4GYoKIVwG0cktQqwtxONoVh368PlnprJVgGTni9pS +DNVe5n2AmMNXXI4Am1LuIsOrXMZuViRh3aQdHB6yHLsqlhhyEX+UhHQy/w+cWOzMhc9nBUnMO9uC +DjMHRvQotA3aFUowDAmCeCoDXGBnjLghjubk10JbGRawIC7b6wF8V5/KxSBTkx2jmp9RG1VuaEcn +EeSJ2d1iSvxwGKMrtLppbpDQCYCtHzeRyKLvrSYIgIdG6mgyFSI+xk4A6WQk8KamvHLYUg5rMmAW +DzNC6PO1IcFlAu4KS7pCCwAcWZ8rJiUIB7gBK1XNWWJbJgAO48DBtwhbTjtYS/Bhw8rTwz2BB+rk +6VFbEgT2CTgk4HQyGUUyrQn5yRAPHOZTOMxxIE+Cvt6UB7jPUUbwGOoE9RtUMOZdYP4on1mqoT7C +cRTZs8XkOCLzlPXlG/cS3B7d1BCr4Y8AoGp78lgLfOqQsiBFiazvYBqUHdwM6JQyYEIhuOGE8VXu +qdpSoXRH0cSQrF2HryDb3kcMir20S3F73LbJFEe+mBIT5RPqDDVHsDsmjPtUzlT0/Q7mgpCaihWa +axCFoL7C8wXTxQqKEdMNyNe3ppHapi+ZwZqxtQvzJq0gkcALD9NDJycam+pi8NagpVDwiTlLGn9x +ojtztQbvic4IagYoLrLjNUZQQ8yhl4u8a9Afxf0gHK5R5UcbKRKejU5mSYPGPTghCQUFz4HJHpLo +7MxSAJaoODNeVp1iIICZjQGGZkNf54RUGVWNA7MfpipY5tCwR6WGC0iIlVX9EXIgwqkwnFmZzbnQ +hDTC8jx4clJ0jSdc2FmWbVHPj+5cfHLLnVO+rbxsG8sYIDkpK4wPyGqxTSjlF7YGm4zD0XxoMBpn +rCO+t/kMJVk7zZ6f2QmxNQwG69654O6o7WJjwqc1ul86mKAIIfEReFdyMHCciKhg4PIdx6c8soQM +I1uadxR8sZIxTEcr+0PZbLLYTdgxzgTztS5MMmo3j7HRaWGJc0XD/ot4gyZ94YK9kXleTZvmQzS1 +iBMLLCVzmAiGnQHiHbu23CuD7FNbXIfHDv9sdY6m+znZ94iI7CZvMdWToPYY1otNxetsjyFksNPE +mbJql3lpZ3RoMynXSaNm4507kF3OFTUkO+ESXWAnsSxQNdEMZgiP3a4Q5WhjYwaKe6Rg0nn/aqY8 +UruYmySb4WraZodsN5yWPt8Ofalobg5/dGS/cKSz95pKtpmdBcu+xyuuuALdWt2SKrs38U6W1bA/ +oXoptFJP/qkg/G29s2vPGc+EHdhUMVqulXSWgtOUI1WyXrqHHN7VSVnEM6YN+56rL2Ck5BJa9iUV +S6MVqslxBKFUjgcIVsyRVf27JeaSUkh7TnsO7JcWm042W0m2SXuSYPSZCGNhyomUIwgYj6A7SebU +lRqp+CgEwdNMedOKRtIdUERx+Gkvlm9bbRQXR+LESeY2DiJrujUYorpJrBUQNuOdow== + + + nFA8whgFqpgjmTMc/5sRaIWOwcbhQHtoB4weHCiXAzRTivZ0+4g2oGGp57IO8fzbJu7a1aWBZJsI +VufJgjoV/G6ePpF2OaTJK505/thZapccNgTkcNMheWK5c0T0YTqp/4BQcyRQIxgZwRZeHbuFEBL2 +cEdNsUmm9X1bKUGr3YbteNMfTzFL8o7mgoNPYNq6VkYaC1jT4+RNRLPtsDGctNhEPaGZABSoI6X7 +hM4JyijDPA+ib7yjpuWFAKbb7ZODIQiWHNvj4GtkJchWxpQtNixsVWbSeuxRhC2ZTIuI5T00yGTa +TGGokpN0CqpAN3Rmpfg9ACNt9BGGDey5vDO56UbjZHskj8NAP7wyw27RAwZeNLdCFoXhXKYxbwvJ +kebFbIEvS+Sj7UBLh4ITUYSbbQtHUheHsXI6ks1WCrM1Vg3cpmBium3Dh8aTFf8+fUcifzj2Eugv +yI8hQEKvFT5M/iLEnHk6m7QsKJUmlLoW7eMMgKTT5z3snEggI5g+SZgsQ8qYj5GpAZ3uYD+owhWp +Le1KExCIoGh8mbDHSR1auB7fKiR7nt9LaDjBy/piCcGIZfpyvCDL2hlthzA14jTD41guGDdcxyt4 +bpvn9cmOmEiM5IZ7t+jxiByypLQeZ5iS0V/QQ5ptzXSeFyBqcMrTdFgV36UviPY8PyIHV6nUt0dm +ZXf4dn+d3wqf6jKxIG2LP7xq/q64K9Q/fHnjO7Z+645pJs8km9JXEH+S2DZreNMMlcXU3flNHv7q +7N1A+42wfPwIE9EdQFhFKguQS/7fWvxd0GhwxMNHCQDaiyeSyqi2tn6uMMdd8jJQO5venU1KHIwR +DpQvgFdS2vX1SWAHWf1RbWuZnTaHOUjn+wrzlBIwV5NeIPScguURJexANOhAcp0B0wyLLNefKVVK +9Lfo6jLVTvpbGPeJ82W6yWnVwl/7BpJu0ODV8wKsnBzrTk84+WSH2+kI0+ycYbjdIMqqvqN99clT +GivRcdjz/N5D1Zx0q7UKkRbuO8OtbeKt5UwkHakzjlSzb2ez8y05D9Um5p5NRc8Vc5nW70hBIqwd +FTtLcdkaVIIoxEzAal4ddPQgnV0j7KiDK2zlyH3Vhp8xgtMPHCVQaFsnMPPGNSa0MGKboL/VIyuu +OiIB4KxZvn0vPnNIAgnG5oQwbv8cX8bC15FpXtBVaSbKAFRB1rON1xyvibCDuNIvVduwedtNCe6I +bxiEdAW+TKmFcKMTDF52BMy4ws8ojZgKZwxsRxT0FPEEuAgPX1FNnlkvQ1psVNYJ42+0RCdvlvJm +ezqRp8oR8+jhJVJbWomJ9HjFvaCSLfAS/ZRn1GqgfMFte4iEHcy/qfjGBLGkI70nM35WujaXZcM3 +umFPuunf46vz4aEAA5Hk5igu1jH8iNQOzI7DRLw6EvSE7LNyWNvK2CvAFxB7a7b2fcHlSJwhx7rs +fviuq1cpDInY/6leDJWk3UlnHHGGAsf6fZjvEM2RZ3Dvs26I2sl2PbZNCg0IUyYHDt5uihCZZAlM +m2cJHL+Ji8WVhpsLmvnGLaoKuqhd53kGmQjSX2pUdXl4JiLUiBTTPKLKx+QJe8fPd2whHak2Efc7 +wxiPn1JGp3YxpXAsm4B9WPSW4BhsAbksJtKC+FE7YzkJYjOkFiSB9GJXRK1OD2hmzzwiXaC7WSx6 +TwJO+YI7rwBFoXQuv2HPy+2Gyp5KhF4VYzj8hOyv3lLDbVx2gXflEVD1YGw7wSNGbmmJw+V/mLg3 +1ehXL9RuKa4ciBYh6+XqD3aBOCykDI0ZPg+QXsWcU2oXv1EuzWCC3qJwQlbCHl4S9+reI9PFCaI2 +uJOulOXqK0z2J2zsoF+8YXSTe6oty0Xt8xvIidWBdkTaiBlT4aylfIA9EED3fMVhvwu1YJQqg0+s +ezKordQC2guhmcOL1h0VTxEmkecm12T27znsyfGakBvRB/o0f/g0YmHUks0nfnQ7sMp5QbWbbKyD +R8xqdxEVNXBHLRMcp2BJkkHLgeJaKNOEhtAs0u49iGPP7JnwT0G0SttONAE9aLpQTraQ1QG3pys9 +1HD0UNYjhyl+qcKhI8UOP+5A2928+vIdFE1V26AD8nm6zyB9IrvGgjxgii6ordQWPGJErhPEjvaR +1eDWFjioDqf+kgS1YNAIai8dSQdnpJWiPoV9Xib3LocdZLmd5+dlL5xyKknE0hCrLdd6Cgr+GnUW +uMJqXnhsOKNxRg0CcfLi1U5n6laKr6jOBsO9ezrZ1JYDRz/b3EqMkNrNhW0mquowR7WY4Isf0EO5 +FdDLnkB8h6JBHz4BtvtkUl55+bKXBODmYtdhJsmwzGVPofY0tUe3a/HAda0jLTyFqsAE2XyhF6it +o/bhl9wznJUdDHU6QnpBMpl0uBppZnoBxxaPENsQRw6zSzL11KZEh6IgmZdiMT1UbiA8uzqyzFC5 +V3T1GZ3sQufnKBhUIruSyB1HpjnxTTROpgOE8+ZngeyXR7iglF5zQorpLRl6FbItHbpRmzm7IsW0 +mpwGnnyp+9wzQYoJVJ828HBl6BAOGy54JizA4c9C8u92jq4jmVf0F04C5Mgc0GqOeCTE+81s1cMw +BF1QTVAjptBaycwkPkDtK11REnmp5r0pDjIpNu3f3O0Ui1mhSQ3T+cL31lVviKdRdimzLautsJnK +7xzj/EASS82e6WEBcbdSNMmBFb5CSX3nEfAWPTqkJtrFK2YlZ8PjHzy7Q/iNMtud6xH0NKF6nFH+ +YdhTJ1fW8oLZegUFpRxXGRbOuuAgi4DJ3GGmjC9AKk7XG7n1xE9j21hxpM4exPCZ/OYtgsi1BqfS +yWPE/Qp8QtDQs9rIKzYPoFb0IjGCggnJR7a1cY8cT/aXlj4R12E3u57RT0nYM0hI53kA3INwz+h3 +A/m4wARJHOCCNOOl2KolxZd5ZhB8yh5fOaYlfkow5ZlHlDRMYxjjGI7yHgUgEM+5QkI6zOkH75jC +CtPLLQ0I5XXk8PxLiudD1WrxmyrPaCkGG7idrqiATNg05gL2n/wM0ZCp7Qz9YSp6fcdWGg9vhitl +Z+Bbb1omT80Y6NAHIybkCCvWCIjJKNkwWzVC++uQJrl9oFz14IepgRDH92ZlC1+v2keoDMPnw1Km +9kGygnGh0lEWxBPzjK7hphFv45R9BrPTyDDUEtmD6YkUf+++3b4WeEqBLdfgJRepbLWqVeW3kfIc ++t8WkpUrTFkG7TtUbN2hmW5EgWI+zcUmCsnq0s+LlZJIG25US0HnhCi3haoWydyC6AzrJblDfFtH +tR6Ec+Vk4ySI2Ex54LJ6hBkhFFD2ar6gRSMEA26zu5/MrKojGTLecgJSsa7kRl0eu2Ph8T/paYBy +xhmHVaGjlEGlM3Nqwf+pd8orSmhoh2sUSkxuwzxnvgK1D8ji4Hlf1uUXHBE5h5GF6UQFxWZjwBtV +ixwKHcm9XCiHOSMnErSn4abLXCY6Ety4K8FjmuClhrm7coeTbx9QLVeYxa85vCXnkNgTauBd7G2y +UVOaJ8gBng3+3a63OOCIV1sx0BaZnGoTpKqAn2y5TUhnl8uXqB0MrcOxPtR70UIsUHq12ekpczxg +siRvyteTjyi6YOw8lDQG1h6RahGU5S47gtB1aU3FTfVWg1ouOqIKphCEmLIcv8uZzoFh7jJAp7St +ZxJrM4m44uxQVNQWoAEcS3orU1jWwK1VakPYqTFNsXFEMQHCwVxhU+cEHpwzvUYVjt0W/gvowqhx +BUMqN9IiYbdKwJkQnoRdQLxyzHQ0DXtaHDRUEFBnDJfUYIfePSb4rNo2O2qwleAeIpc2j3IW4ejQ +Edhw1rO7eT1yi9IVLoAiUWDPi+PlweuDC4tAuiB0LSAajUdY4aimeauRlnaCX7gCeS5vSLkkysiJ +BvG8ktSMQ1nTMBvppuGHg9gpleC2Y+hSwDzmMCJCC2V0O/r4xCgUKp8A42DKF8LzMcuP4hOgRKoR +6y0OGMoDM41RqSb1lg8muZ5IrXAoOKtWbRgJnJKppkOMFPazL7Isn0FZO7U1yWDPsD+Tqmxc4VoA +IomqpNQ4sl+iTNS5txfju1XfdOEhApyzeCkjhYqjumpXg5SSWT0LlISug+J8pJWj45MKRp2Evfxu +CJbSvYxgp5BmsSJ/un7lSQVzkb2qIHXzVp2jnt+pJ+VArmFtBFqjxxUV4EqG9PaSS0jb+XsGB2Q2 +UF9xJhPhPNRbQGeawTLeeSn2Or+Uf+/E/k7iGrUPEuvRqLPhpzrfdM+GZ5irpBue0Y9oZxecaev8 +7Nsj5O7DIUcz32tOF+ASGNKQK23Il6RggfKHqWxt7mfCwvdeCf7uEhm5NccMFKyMbgUqywWuR6xk +aUZuUBvg9PuX4NmoVHfggn669bEbL+V085lnOSjiXKO8KY8ATRihh3LyHGbH33hC3KAE418/IwXE +yakL56EW/x1tRG661MWUA8gxnOBECKU52WdU8E/k+N0z1lR2ZJbBOhV8msKbZrfZnoRpMBrF5MUc +MYu6GVRdioRnqMAgP8f06N52k81dtRVeJd8L3mvTA7oOuHuqsURV/qSZqB2OFWJbcLyRDKrg10H9 +Dz1zGt/j8iTndx92sNLX3fifqLF9Mh0tpw6UYN5XuJPclGA5A0FgkTbO2L7psZSJ7/QIRDi4eOE+ +a5QLFpUvoFUb4LGPCDlLDTEDfcm7cTWss9xytw1VmWdUn2GvzCcSFYcAUnxK4BW4bfr1uS2R7wl1 +RcYzqah5id0UlbO0M0XOtQHUVqXIGsWCS4Rx+WZAiJT1cUqkwc0ulUvWaFRPoneRsXydUzScOixH +BTDgTkYnyg/Jx4YFkUho9A11NDy0gHdM1cRWUfLpHs1RhoSMFxW6DDuQ/JZJhjCbCr9n00kWeoSU +lmr6g+5i1K2QETyhd6WguD1gCvgOUN3B9V3F1kQSg4Bq4gCn/vRyMSVdsRXlBkAHT/HB5pJdGrNA +/yzqMpeRnxOfvkorQiQMPiaZLo4MiHkTtIJbBpFAP71F6ZpuI0fwE+3FhznVqORBsV88RrLMsgtU +cJGIMAQ/gm1U+YClmE43wIAH1kmFKwPYgOtvk9upSifNXNoVq16gE00UuZKM76k3weYghtwCQxk1 +gH2VqcJycXiMILpC22JHGfF+W1PkO4VyhIDysGkn3pXgI/d2Ls4ZYQ94P5PEw9WydE452ENF5zJc +5gEhT73i4c6LuihRoEOJnK5NuYzTSvQzlZKhiNfAZidkx5iczBYqJOuKHTbo0nCZSl3RwNFCMpTh +eMfSTVH/mdLEJlDC6/XOVY5SAsKAkErhckEKNSM3gzIM7qoUGmV32WA7vqKaeoqyQJd2uQkW0jNd +WUdMNcJ8VsgFpLcSrYbr03czOmti5+L4BqaSzTXCF5BudfLRcPMX24yTRAA875hOJiM8K4n2yKeG +98peC2zn5ApVHawF3mUCvfKpC7oo5/LqdghZoHFEBLUxMMkkHMPDjbs5AyYXr8X0GQ== + + + gKXk36NEZnJ1StOBZPuGkx15e5m47CbAoT3mYBbl/D0o8NJRLhO1/mq4/ujqw9DoSQFj/K7o/MvK +d4LCdOI8Na26fMGHilGoogl+WeokCwkj1VJt+3+1PNMRiJvDHM/JjPl2OUMq577G21+hIHea9RkF +hkv8aBfEjZLWKtUJhBMSLmnCn2qIziSPdzqw2FxRcgaTN1dgIs6Ti7QblzlvTDItLFTF52gS2YfC +PsEaN6PEyV4J1PmewbQiniot3Bm0tUC+auKICUFUgnykfMk/VqXzCrG5PXbmLdK+PRj9Ak9Rct0O +8B5ZIJV8WycE5iI8D4NcLoqtb0WaSiNmsc2urTkuqf7ifGrwLZt+UzGwoZdyiRvonkrlEepswHfw +dw/gjOSRQY8zwnYm8YyiUWdRH+Wydc4oZ4n4QzrRILuQLDFmwPC8InuujnbL6EybQj/J5Y0qUZoR +RU+4gEilTihHpPAVE08rDVRt2e1qzx6PQFnEk2fQIbEVlyIni4zIWQv64CifhXeM0K9wjNIjBL2R +lsbOJKLTa8MshYFQafjAihJ+aFGngH2uQ7lM/owTzhR31zQsrq6NZtXDDs+uptKDDf+hi4uZPbrE +9grPQHchECeBFl1hxoyg8dEHm5mXCmgU4kpoMeKzWfxegqmXdDF7XvmrduaWFfQjv+sGpnTlCZg2 +48bMxoLxFmSUnXl6x8l0HaVdgL7y0Y+z7BrAYDFgaFlK75gwfDZYkHkCYeMRvEDKUNPGNUjDy+Ym +4glm+AWsrJccQZVKciNiMlmnPqwrzOBu4wKwyhN1givAFk4ijfQCTv55412WlyItbgY9g3pSYnBG +2Z+8nMqlem/JiFc+85RXKE+EZOYyiJdXWUGHaiCxbiDgcLbmBKgU2s1enWsIzTshrHdcTuxAYuKy +gAXKld9wSp3puaJlqivYjjDe11ndLtqS1SsUvKg/RxJZgJVd0RpHNSmTlvlRVQ23SqI4FBrrMKXT +4ZLMaqKoHqZxVhueLnHnxfnMCR0QUFVtSPXUdtYmma16JVdqzsgHk69KEHWHttSWqnGmgVIxz4x4 +3QmOOpKNVSan+tyKoA7zxheARIkFcGSHrQelr0oRTEckRFdnVWkTi+JQwr1lIsaH8mVyNapZ26+k +ndrZGgB5iyHMChs0nGfZFH8oBSR6mumFmHUhrASN4eG62dK5BHAGOZid4aidBSRgdn73Q+GVUw9N +J6MIEu1MgaROM0DDwTxivPJwpW02/UTI2KiKUASFikqBD4SnEaMyBQuVqtRXg26wSZPBJGqOFEBM +qRlAYKJoPbg6OEoNezwCeRRJKoLqTYNu8JSmsD9B7STAXbhspCDmHuyqTPxEdjVwm2qdErHCy/Ri +jFcOxEetRmSZdDjdRLV784lKpzqyYaaEYW1B83HF9QOCxpJsnxaV6vLh0qRyzoNV106fCIws6MSy +M3GlOwsEo5979fkT2jJB0g8iSJNSvtBBVmmo9q0Jwe5qmjjptRyScyvJ+bEyQRosebNakJE7pSso +L0C6t/ck+KRzNdXcWX+HmUzengwuDU1u7rcezhGSu+HKNjW9Vo+5uwfFgtlFScUW38KIKpayMIl/ +Lmw5WOoUzU3kV2hNHulWjc2EMyRdF0Iy1xO5t86Sk+UEAVg1znasEVOXU0Jp7LNZjXUOelSiBRLu +BYeWvwhNYPXV5CC9LX+pRI0ofc/ylOZiH44sacgKspMkACZQ3seJbGjC6pewCJE7NhlRoE0svaAY +tVZPWVYGuxq0Ry9pfecciLcK8GeZNgGYnmb2NNsdGMwFnyxpHWi+NWcW8FIZCJhps4lXM2kGpL2i +7uKOSxM/p46AUk+Q+3Ehu7qyKdIAhUy1SsQTcxK1vKC+YebDJ2sKRxeKrBbYIcmNQm3e4HxCibwf +9Zu/LpmAu5wPlYMY9gALvuwguMgykkE5IZaV2a+9FJxPIQu/2Uhy3k82Kji5/DFsHOiFCGV8QfAK +CvUzIxVFC1ryYaIuyp+k2PF5hHaK9hHt0i5troB/KoXtX05sZ7IVTuFbG4NY1FwBDRyfZdYe+dlT +ipSbZv1JN1zswco/kWbGGWs4H2W4F0pQz1T3E/6ndy5J5JJ0h1PglL/BNt+c8C4f4Yr6aaTpaejW +yYIo3o+E7iJnh9OnUKcG3iYnJ0rMmKkuO6+CQrsDwmsSKRaAE5O1kOFeDGEBhXiYxUTLszv/MUpW +4V4nh1x4BnQZvwI1dvUNw4kZxNG01hy5IWPe9ix2lTIcqqvzOjcOh8mwpmE3ZLKGpSOR4mAj+zC7 +Xg2LP7lK0TW5rDiesJnDH64sWbXB0WSrxrKyg3v/vKdpaZ1/x46cIm2fUAeIPqwinaAk1ZMKXa+t +gBP2tNunIlH6SdUGyPukQj8TrzmjZ4eVrAQYMKsDkt/pNi/xaIaQOu6UzeecYi8xmZmwFXLTSHYp ++lFNRU4PVhO72quT4gr2BgDErh/O/E9ntricJcueouMkZrOqaA+zuQDKukW1H9T2BNuvmfMOLACK +kesIUZ7DmXXa6JWBqLYMy1RvghgdXoEZKSlmSaAsKFkwPdlrjxTE5cAFYD8kF30+yB1Rji9nS4LU +khidWMEljB1lbk0n+S0nbplWbNhHhJwFs3guRsnqahoO41JHFOCOxJJTcsNCAYEH6WamSxrhzDAb +RXLyd4oayRByuAzHsOYowcviCZgbBpYkDIRLttj46mk9D9KdxO/wOuTAhYnO3NM8n5yW8+akci2x +ZQ2lEOcegzf9TjDCCE1Czp0dEoM0CxxGbKZy5UilcmIC2+uo9pg2+1+bm/LUqFm8kcFbSAIh1o+U +LkhpkilWpGSJISgf9uTkw+HKh/LcgE4mtbD6F83qO3/JU8mHh4grgH3CJo5CiE+EWw9eRj5Zq/bN +54emX6hYJQZx5Q6InRyE6nJ+gt5dS5cdf9Ad2f5TVHox/Z7b84hSVjlsPYrM4gEKo2EYmyF1By1a +8+pAofJGFfnS2YU6w62mKIR4gIqXlwm4O0WPnHiUbNEW57FEdh0uk2xGfmnUZ1XuBGEBHD7BPpoC +fJX9upr8Sr/JIwDzQq256DYgCiwTyAHOwEFi2WTbiyMmO81b28cMUz10AFnyA/PQPKdKNlz5Opim +H96ORTMjgvjGBUmRkwmPQLLTW7qrmFaCm73YfsS4zU6Nw5HlMTJZr9ogdaVTkosaxDG45QrWoq8s +N6c+zI5kTqqhGEW9sFgNJanjnqt2gS0P+Iga80GmLZeeVgL2cnfYQw4ZaefQI5FIsWy0EzXLxSG+ +s4/VhpVeIPFiJ2FZYbSfSje1zgfBbnTyxaiR2YVKXuIJ4E51RNbvScXE96Z2CSvlAG7gZCrNHFw4 +DiSiiBMFLVKJ1D/ormok0cNYIctBohX2IUx1bqnwp9iE1WETt4BSYvFRNMceCm56B55MhCMRL+Yq +YEbSkZKTp4mWw1Z34KFwzu4p+rrpv2FLIAP25CJXBmy3vQQLhxJcNbthLz9i9xBbu/Otna5K3hYj +4iucDC3Tq4ci5p4dwaAkeih7Nh2mXb6T2h3jVUe00BnDhSZFRaZMHMOKmJ2X+KtCdTt8ZETyqUcZ +PbYewSigxX3usiQXaNThZNV2YwYAM58olGWXmUFiKUZu2uaDPOOAk4B6qmgXw9xvciCahKSaDOvk +loFa8nA3CQ8kxUaexRx1M/HqQYpm0hbolw7TgVfrIifVN2wwZuM7bk7MHLv5EYy8zbp5OZxLAlcl +KaraWUmQ7PaawoiWnWQDB6JdEVxgvEm2VxlE4wGdGX5aEq46v2cXEuSIucYMHW3W0tSehqsa6RPk +ZTwDECkk3UbhontDKs47mrAhX5TVDmsuZFuo0EE4ozYY6SfoUsU5DNtwgroTBO1QiQ7pcsVJMCZQ +SeZZIAkHHTYA0qG+HkZHXwBI2eQrFZ2rWHqCjZ5RYNRI5W7cvLTRYkqaTtKUabEv2Fjr7UHmelCP +FkXesFCyMkAgmfpkCaGrR1TnYwmBb6W59SDhgXTnpJ05Gbqq7ThIe+p1UBAZzFpzUJgEa8+WQyvS +05Y7NZ8jnD27ROQohCOAwAZzG6A8N3kBuHsOQ0BTpIEaWiLsaHZyLIVsg3GBbxiBa5zLxDhgmapz +pYDddVNbYe0EmBGeEwNDu2lQbAR0252RUgtfERIA3hMDpPHZ6rHOuEIrgELVRFBCNdsAYWMhXTM7 +NTinSEI1YpDiMLwSsdVqtAZnAvk5M+yKmU9rpKqZfvUIo6aZpYUttwZln9ryb9BuQTdkth8KjHpu +FP8F5waYbNCGAozphXxg4nk2IR9qUJde3jZfjB3RStmaAwtZS/AFpcgWq2bjrxEsNFlY5LgbFlWc +sit7cRkjCTlaTc6ZYmHB6VGD8A+jLVjZwK6enEXJzl4bxODrkuHZOrMaUMVWV29N6dZXGN2jxpo1 +39olgRmPy7L3WwM9zQJ8OIANJnyEAWzoPNwZT4gSSRh5vwD/TBv4j0EcgTCcVoZqVD/FKQA8jbhc +PUxYB8aqByqr9mpw4xF8b5QuubDGtYBk1cCB1WkS9BKoL5AjJQpUnKNloOLlCKCtz2ijboJD6uYs +kIi8QBWT4/UlwjzVlTN9hdGSCbCIzkCzZVal22YyZzEXuDKQ9hgDND3g2mOoIjrRNgAGpngpgr2w +DlBwYRp0HcUh1IY1KDtOwBWg4iulSOCX94KUxULd5cChZvsw6dzZTRR2FrqxLZ1tqFzqPubTuKSq +nM8ICKWI5kyE7OoZ+3d7X2JanhMAEklOcFZzRh+Q5D7sxeiNvKmzms0JLK1RildLP0PrfpwkeJc6 +lgfIAeCx5VJET1KEytGuoQ7cdgVIDvVTwoWcxd3OAegFHZ6KGfFyC+ByMraxBPkiA1AvzGRnyoHi +KgwdgrGaeMF1JvNZRryRQSWWaVMd0vYVIa57YNpN3FcAhFTKKVo0HYE3d+WXynqhWqSqB5i2KhkU +L7cseO9mKGEg0ouLZ4jXQD2u9nIV9nIBlAf4sPr1qwn8YBDN3mMOlxxb8fPKccGJ/k+gPeGdcLv0 +KGZkDgXSnLjCstZdRokJuRbrSYYQGCRYFwKD1E5mhyqXQYVCt9zuhK50TntFyU3XdNYORoJpFMim +TdM6XDWOQxdgztRqKpwaRC/1hGB22DNqMGOQJmFOuwp0ulKJzBfAvCm2BpPjASrVA4gPaa8n/RQO +z+I2SPqQiBC+O9fDLJ/SFVgCc2SzNgjfrnySc2ScPlSDerCeQz1PVjVwW/UEuTcTKZLi4swO+IUB +ZXjKN+q2kHhTnNdPlgCpOme+CWq82sncb3jZZAsr3gH7QHbCUSVRCJ1qkgXlQhLNZhNpU2OZOwAH +ntkYeQtgyDqjnuoa6UDGbpAOFOliTfCuOylGDUcrdALkUXXCDBW/Chdckr1gxGyBuqtOZbsE96Rq +HsPhQNdn0BFN6oYjysrooGjPQOZjhiR/hmu0k+5F14Rk7ybfaOdu0R1zAjZHhA199A== + + + oNKrAb9K2tPouGgaSjUKruKc/WQxyBPUSnxWGaTyZRdF6Xankx7oLBnlwQFbceVuOAsyqJQV6V3N +UageFSzJtaNgbzu5IslZ6hEXhbSgOD1QK8pHmlMpSxhkJAvOHpYAiYg6f+9GY/kIgVJXyaxBNkle +4hHkk20+cUWlOPzCfU4b6I0B3DVIN3XFomAyKYm1Xpuavl1SGMmftEEz4ZJVSmYzb8ISkeKIOqJq +TyKt5bSJSO9XbLacmcxE2fBtBCVAA7Zl/A8J/8mps7V053wDwxkBANQZA7RZc8bZMLEEMEZTTgxF +Son34mlRW8lcIyrMknNKFso49YVhe3rAEBwkA6BtXGUZWgHc4TNCThxZhTOCf1VaIBnG1Sn56DKO +MS8n7JJYr6Kb5CYMJ19eKgfLSdUdlW42rIa9/vM26xt9SI6JYiqE6n0Mar5WLxm7atfI4G2ALTu0 +gLRZfzNQO+eRSUaTrVqZ1tOuBpgNCJCdsEYdkQUqfFGQGYDNWfITOFUa5xGh8qBBJaq3AiOmtnIl +15msJb9Mc755OnlRSVqDTy2u0JJZLHzzJTgyvfCh+hmZ34mSYJm7PaNXFv6rFXirGjSd66wcPsxQ +tM4EC3lvlz+iHzGT2zYRiP8159tTL2Wdy3mYqY0rWo/vHomIYQvSBjBNasfMp+2k/5gRDQCVmLB9 +g+6Af7q8U+f8szALDr115vsOS6UVdcl4AdhgxUyQ4oxBcepQes8HLqcbDkMU9IRIvRyGPK4zOTMG +l/iL8+ibeScUPHezmTthmlMCrC5Qp/hkk9EdJPbwPssQhRod0ByePFO96XQgC5oLviIHzjdeOa4w +lexwph2PqDE9+1mPOsYtOSLqNE11IqOQTs7uYWJWY9BiGKqD0zE5ew3IMQPMEd9xxEwRVTUcFaYS +aClgF04EHy69onY7e43ryRI714tZMI5I/T8S32D33ojoJviwEaPS/Yix4hu0KBXndRL+1s0ZF5vB +aqf4aJdv1RGHhYu/SARDak+PA8QAPj+EMD+v6FOqh9Ausf5Qb6hx7j40ggS8mqVON2b9GOYRqIZQ +ACA3MTHUYik5qHPKJbVDvu4NJNhFYMTiiJEOUKdrRxnNELgewrIECwuMaRLIBmug3tUIV6odcoo8 +VwhPXFNsRO7D6TQdUZA9uR6M2jXHI3DdI/PzNG+LeworFMDHCnYEn9+CKSYFEB/CSM43UKKHDEmr +xhNM4zMcAhW4IgWhjqQL4AtfkE4SFsKJbI4Ht1zeG6nbkrIz1s2VEHQ4R7zjSdHjHTtAOymHTRjc +CSbQ6WY2CCKiLOgkZAqtOf5vt+dJ8xIpDJApGImUxwrupLpcLH1G+0Ttl/BfK+0ieH/CH5Pr3Sv6 +BWwHvw8K1vI9u5kLSKRVe4YHvAZHVJnVCprMTtqh0uWA/8BBGJUNjOdL5hkwP2Q2Jr/CZEXfmqei +e1n5in4EAQO/W1+r00PhUoL9xgahEJZHeGpJ5MiuFV37hZiomcGpXD7Byfnd3kYgm+HECo6pRnW4 +jkUcV4QD3FM8m4DP7Ayuup7d76EIpaiahDoeddln+OA9lD2433FfmiTqCIKHbE6oZWoFqljws+dC +OHtSBAp0pAeOdHhsIQgBNWq3elSzuEOuBWUsZ/ir8Bfyu+9wzPhs+ISIRJi4inLlWD6egGuabk5u +o2uwcGbFlMFijEqqpgiHwAWiNDvq0epMtpbsX2/LiUI5ePV7sLvlalo9hsBXBJcCWlsCCWiavdWM +gznM7BeGCwxvjrlUVf2C/82UcsxMtccwk18PsrUCj1kzHxRtcxoWcHclJnkzeDlAgMGUMA3GaaZv +MO1qcTIE5vUtiZ1dDMagKK3NbotLGzOlmrnIRHndlJUzePFauACGmziSq3mBTd2XwqlQg9lvnj6G +Gkldy06KFASHM/mRvZiJz9zrNXZk+f7s1oDx0FcIkH9hwMT7Z5KD6c92JKraPWyKQ8Ip0CQEvNCu +kRJQZcc2qqEEfDZEHvh7uOO0rwYiRwGQsjk48cSZ2LGYFBNySNr+Ctd1rTenh2rNkzuyhZNqGDBh +h3u1hE+kp04HaE5yUSi98YMF5WXu0W4p+Cmr28fJaOlQipmBTw7N4izJVG0uEaWiCK6JO5O5EIIc +FOoncLDO4RMxNA7FHldYMEdBujttDKpUo8JDcZSDlwJSA8JsmVU1ynLkvTVdv3F1YTQtprHlDDMb +tGg280XAkutb9qjUkdyXdfrDQedyy9PtDemXAOWHa6I4C6wGOZ6E8gjIObVv8Bf7Cgoak4Jvbk9T +WmZHGLnCNITZIyumXCVEmGCYrlgRvlH+oq/Yi2c6hnCYv5c9RLpNzm53kyKTwqUD0C+mC/2v9Ggq +2RRTGB8E1wcYZNiCDRj0ttou9WzM7Nrs3qzHHVLl1px4DoyuRWmGyL7hgskTsEB9hUo2KsozmlmX +h4M+Sqy8g5kDBMYFBhwescXoDKPo9gVAh7d4dQWBCzW4A8grZFQzazCgA+PwmLSKG9UWL+WSSzLK +2r0rCMVAP32Y6nuuyAosLgrgNJHmRBLayU0zhQe3YoswhDBuR9ywmeF/uimnVol8H94I5qUy7VFN +IdKLTXzaCpJR7nAG+ThORvGnD6YbDnXKcRgCKbopqm2kdcqTwR3RFUFdukKkWL8TCequS3WQXyqN +BsoEDHfQyd2lMJid0riT6f6DgYT0m0QSP2FSgOcuiQgsXD6T7IKS1P5yQqo8IDpS8ZkkKgWLFmCa +yI2EdLUba0g/CGgl7vqOj7JSpUHEAXahn+U+S2QGN2IuJXI0axQ0p8DHAVmNwYth25hGIKA9AwZi +JJlLWCUXcb8XOFQwMUdlnBXpao99pPkIxQ3vtEkcuG2f9RS7K1qQIpsMbhTsbaETg/fBySzHQmQg +dc/WFcWdaU8oDacxad346xUlb3JUcF2RyXj7yEXMXW34Chej4XJ50yc4V75HVq9pENQECnv45tMm ++8GdQAmoRapcOBDlIzjQ+nLgpHRkOYdr2hqlboVQPQCSD2ui5KWxQsjZcg0NeVTxQhzdiW2RpXbJ +StMrmADDBS20T65Im87DiCVFd3OLVAOyWBaAZV56FdDkCSpV7rBIeqaSiqtuFNxq63wJZvhUaNf5 +fiRSaxGbY14INJlVyhCsLpM5nGPoDGbqSHb5As1W8ZAsxERi42JVUSeSzN8F9pssxevA4Pr0Sh3l +KGB+uNzOMJZc95fsh9kwRS3BVUmtNORzecMbUfpYmZfqhAF6NQaCpTRAChX3PByMeOHoE/KOF5DI +24KI40w3mvaJyVkgdD41RkfHH+1VziP45r22S7/UKZVTHFjpMulMj3C268oUnODmjMnLErwDgXVb +O+iZwRpVXDgj9fgMCkF0YE0uLypGP0FBK6AB0hCHwgPLubth55+8ivnCkuiwmRGNHOhOtB3eiGyD +JldQOYg3HC68kQOOJJJEOVVzuDd6lGfPztYmNdelI8PD0o1UyVGGr/MtzamUi48M+FYO/6TLHrPu +aEeNr+yEcgVmZiQLDwc1WnBDahWYjjAbjzrMwd8iBdVLW3pNi+hyDrAwVotXHti+FonlTvKRk61R +cqcamZjzJZCWg7S4KURqMHn3PqkoF2DR4Jdu8JAg/KqvWI48Ci7Z6Llg0ehO7JQZmsj3pMJrvyTO +mgJPQ8NXtrMjJx6bHNVdBsAT5lNzcWO5dpgdzXcc51DcL3DuC0zkeckzZ9poWQDoDCUBtx75MWSm +89A+oyKqXAh3mxpKsQYs2DkFMz14h2VELEyAl5RnPnp2mCI6wgbcMtKJ1E71YiaigvAA9Ux2sWDg +saNoeq6boCK57FGV0BQbTG3scgZ1Z68F9sGV7uxReKqf3Ecf7r2Vspih98lgeHxFjRnrSKaxGcY/ +UyLGNWNA6iVnSBplSwBbVWmoayMCXhDlZvLVplNJwEAtBGxqHHsPGOHh0ji6QTM8FZxUioJFQJBq +vETUgGGLTGdR22UNB42cGhcUbHEmCvz90k4PF3QgAMgdii0R7fe8lFNIT+QcVba4QyYzJZm37awZ +APSKstkm3Dczl5PnTIeaI8ernMDfGhlDaIMGw5ibpTixCqhKMgvKWnHFMDG3+eqyvQGmI+cGtiSy +OQVcVjzb/wWOvUamMlck12eZp6Oox1eQwy6/TvZw4ZKXF2cFVljZGviBLnlhzQ4wuz/gyeKtgO8L +OzzD32pWG8Bp9hITw0jhvcIFHCCuFEzcfEUUIcazHWVnIkfLJK3JexzRgPOdZugvgGv01s15xK4l +piw5HpgB810KFSXYM8B5Q9qfnI5ZgmhJbzBrzHIwUPLPNwPZ2KjPfPMSJAyEA6ofQXIuAQhA2lyn +mMaKcmTSURUjWVS21ztl57SDFJB5c8yg7Xaz+QNrTHHIgaWyDZdYYzWdVAJkAKLAmmqAK0hsXMbO +KQFQ47gY8HKxz6K+cZR47RIwBWdrWS7yCSt2irpJKHk5Ul3uHgkoO8laKxiA7vye2uUZ55E+L8Wa +PqU5sf1OeP06jZnl7lOePRXql10NwZ3jjxYQWt3fXKKK3f3UM+llX79c/3DZptbx5DRHgu3B+qBx +G46sBv+1juhOi1x+JCSM3CuYc0vUuFth63guNd6hkBGkdnEiNBgBtQW80QiahozadAQ2C7uP2hps +cY1Uz18oCxc4nBJSWXREywuCCsB8pwlqyBddDDbIBx6Bc395VZcoo6csUd2Z2pX0o3POeQJRAOn8 +1dY0ZAYrKGZlwy1bTMVW2JmPsYJfE2vZkccj21rGJjDxPIMxnNWLXeIyzoTUtQyKDcvgOAKoTR4t +AXMtQzLtur+T8FOijTiH6YlNUKXcpAZLXAk5W5pVdgV3pBarfbjGg0uFlMilT8HxI+u4mKLB/dAj +lTuf9Sx0ZJwEWC4+5zI6aq/ibF/7pNHdnOjincEsmgO4WrjWyvWT27a2cnDJzoiQpvT4CsRnxkhB +Y8SX5oQHI2uzrSNSJIxQy5iJJdLegQgPjCDjWsNdp5wNuem83UhnEjXLaoFrbWQfnpmwpExQIR0M +rUS7aJV15DCS2ekzK1JThFtW8ss694LDeQknEU+JdUiySw+Pi7WbGqWsh2MEOZBXJUpwSD8LWkQe +hUaXo4I39hoq38TDIZp02iWukLaQg2aZKwC8oblOxpw4J+00XAR8+Y5OIad8YI7SbaW7uLHah0sB +nsQOyGwyyBEBueF8VMJ4cWoTK4NK7n7jwzxZymqfTvpfQbMIX2G1N75E6THIJDAkVJWxRM6gYu6l +xi2rrZwSjME5siRcVFVmC6lwnfrsGMlKfYNFsZjb6UyNI5uffUBHECLFLlBRXGjHgKnRL8155L2y +TpWmJomvmZSdGYcdGRlexXnzmEP2lkRUQm3mE7hnbDZmZi5G1nMF9ZFylIjNUa9WSWhKzqESZ+EZ +QTdOItYwwQX8St1qiBL9ZBJY7TZrISTJZ36ZPkv+wUy1RPeLObBy8DMwEd+Bimaagg== + + + hgQ/vZtiuDnc3ko6hBqq+smwg0HrqiNkfma7t3Pw/pFc6gkCAAwCsq0sDRtXnTOaTS3tdidhWQ5y +BM6HTCs385BBeeaPwZmiap/dMxy0qpJ1VZBCHwu5RooZ2CKpMVjuZPtx/0MJ6qxKWIQOGyvKhezO ++YX+WWZUgUVVZC6VhY5TW8mfdZhMSBqRaBhH+NmyQQpnBdju5GDlk0qZy8PbDbnQySmr5r1SBurh +vDmz9cB0iGchaBqZW+OEucPa4VQ9cLBpmM0MVibnc1PnCloxE40MV3XULIxyoQDzNE8HtUDxrcoP +oGgrabeIfPl5hpkft2mNx40Cc1T6XObuKD283Z48AViT0aQpkE87rZn3GK6psyQldMN5mdOF6o5u +OwldiOOMGD/OKnheI9PUSClQ1OrZZf/4OuwlZaweOthSmG8YzS6W6EzOZPpK0EznfHQYoSVLPJdz +RAOAhyaCBN0SEXvMYQGVdWeRLL6iHmZ+wllHoUxSe0N2UGlzskxHCQ6B7FWGVFYbIpt67rIpSray +ugYziBARlW8X5WipMQRrqBN15aMd3TxB1b9oE4ZHiEVFOTGdlu3fyd7n0nI6Ihw3k+RnJ6oLqV/g +ogElSr6xKWSWU7H0gYBLotYyC7iQ+s/2bVeHukALYnkbgphCZ3T7Y9wB03qL842x8aZ1n3xaQ9NJ +68rSlGDWAjAFbEkeyBSAtxJomhQEiCUIwsVf1XALkLLImiHvpgSVurLdUZpKGHERbDBXDKyhSipM +FOmWKFJT2KsSudBkqpP6WKqJCFLoX6VaCREXD7t2daV3OSbsUSnevznQKRNsS1VBFhf5ZZz1uwne +lLPcfQRVTgEc4QqTCaPQWLNjeVAaoOoZntQMtkNjdaDNhDb9MhvZAtElWixTLMCzfrqruEZFaIe1 +btVJIapT1EeHaTplx2GtRkPZQMA5nkBRGIg8zCtdHdkl/1fqC7wt8Ef2UKItKMyWLBnsiozVMSq4 +HE/+L84HVYzvZE3rzGYnIRVENzDDWCWCVwJZBAjDdyxxPez5xXX8gJ6QSacDR1ThK1bS0X90g2ya +IAr8qN3hby3sSzzAtNQoyfxeON/EM1F2gPNN6lus0ZYgHQDEUV2h2jX6ApGMhpb8zvLSQQrkVyB2 +wisF9VsQ/IfWRzG5yI8XZ3YK+pgSAWK1i9dQSMPziGb0sL+HxaNC28lMuS2da4Lt+QRAFeelnAiq +EhqJ0U/FF3ivyxH0CLLmFDKxFAOEUmgk6I2EJu5cYV6LbJdqqVFBMZtiAd00BdAM9wuapxF5kyeQ +GKHmsElWQoBl69VqB00VsQDpodNgJpi24aUiVIFV18moxhjgOzU/grXtZOZDM8UJp+9EgCUTI+g7 +YWBKlxKhyUny4nCpJk7GsaM2rtViukO1kwl3zrcS2tRTBLvwMGQPoNGAI5M6FUw54iwcsZPRaY9H +VB1XsqpNNRvI5QyeK0YVRUDNU7Ci7mOxR/AkA1V7BK2DoawU7jWhKd99atjrJBhcZnXQBUoyOYFA +OSw2Vr+jcthl1G8FWy1NxdLDwdnpGp01qHIHDoVQMkao8MVwFzu65aQ33KUNWwkhfqj25MhPuH9N +FDcc0k944T3/6+X9Iy6bahgE3egUlJpSLn53fj8vCB5EWKXP8LPazfaCEdpajCUiAcAfQZTUakJM +Q0KOYcKKfKcqNhcQsUSkD2tRruRt0hUSmOwOgL4Qy9VV0k2ld6dtpcoQ8GZsI0rEMJrDvA41qkk3 +Fp6UkOIa2tNMHLI/usnnsrl8vOhbsKWIj6qYNGm24PZJKoyuMADQpBVlUns4xYdh12KN6SfuJMPe +DBWvycN1mQn2onzDSeAOJBnnf45sXLWr6RfrDJz1guHFLmP5ZZMtJ+KG8J2auAfdFoS+2xHChvuj +omCSXjPDPYeFkythZdN2pDMxhmqQJ7HHNIvgaU7OSKaDxSOq1p3Bc9QRTdpl6wE9p0c+Hlo2zk3K +PTjeNh1/azXACoR6ergLmV9Rtq6Yzb+7KHSP+gZo6pSYy6TLEsHrzp3K5hvstiQV5emm/8d51yPn +D8MtReob+kmOguiabNV+gaBnLmxwkPiz9zYIfpg2CDx0+4Kencm2K7joMEEPPyLDVylmblcMG2GS +Zi6PV04o2ZwOia7UbQGjWmS1wfJ0OHh6mFgKU4HKaugPMkudp+isxHyc4ddqMpvjhAC1kwT4OAul +RRz6MMdDOxnll6lVblMEE9krpARCsyhCLffbIHSvpWKy/xaoAJiQKiTT9k1O16GWczNZLR/OlHPy +ybRDT7NERohIwhwMPbzxau2B0h9BBphC35dgtgqN23VdVFEyWcm7KcKuoKxO582wjZ4EiIcpfLC9 +WqSIVKHuTnQcNPQhbaHAU66Ba3GftFDiDTrYD4hIylE7HakjzxqAe2A814nDpkL8WVo+u6ibtrwI +2MH8crYNL4ZmsgTyroB5VHM4FlYNIQat8fACHdTeD/C/OwcYBHiwrMnlr1cLrPA0YBEdJ5nLKtD5 +ZuNfEHWkC2tYPmnsTq7h4kQAKCOLfW6D1Ixk8neR8hbnjxxmka2q2kMGymzXJ9c7xQVm8B9fUmCK +nU81OJWx7WhXX5FWPMN75WHbE0JRh7i8PjF6CCgZr346wpYDfdCRETs5m8dy7IdV55B6I78rGGKb +aZbYK45wNtU7EWzZttIt5F+W3ov7CoZYF7Y6jf2F1+HkiRYAfuF/4StJt14n97+Qpa1fkGI456B7 +kGI0c3gceCnjJeRf6OTmFTaOgBKkTuQeVi7JAtBSwcbbrBjMyLXkigXZbgAumutLz8hS1w0UGXfE +JcAHQDpnaEDVMO7JUFWPdhbZp6ulebQP6r0ugq9MIKOpzp7KJG86c8702Jr8hoLZraCXxQPgschg +q9Jx+WrVk5iUeqmXbhKUaoQbRo4LIcOOGURpmJPjRLxVK7PydCmjQvssOMVbwu6AhayTtK3kZTRW +DAQloUdUDPZHZ2rKulhEDkuEYtHVfuRmTMdhovxi45vqxGeRhXRLdC/usg7gazJBcZPKxsbv4S0I +X8RAm/YOo68fQTiNG5MsLNUmQEtcZrmT63GZf3Ea8lWWY1ppeunPyGOXV1F5O6J0VD/Jhyho4gRz +h39umO9vRtKi2gryq/pwM9PlAZO+SVLsCnO0D4wGpKDNqZ0QIEfdbwJ1QKMkliy9DyrTO3UKBKJJ +18maI2uR2XTm0QE5tFBJ3STx0JSuILtGi0PYCJV2GCXAYlKK77KAwwieEYBNEWMS4DUxn0gNM2gO +o0ixvkaC9bIVmCDTIjsaAp4z00uKWY00re6qv9hdMlQzoy2/SA6IhjYMOWdFNI526qoPgH8w8VYo +Q66eUoBo12AaJ4EF1oeJDuTEDddLnGYPrS50coJooURN5qUpOVDSxdw3hVzWFIVHZaDiYw2Gs0wO +FoymJxwW69+OMMjpoupICmpGsbYEC+RZWyTqPqZIZIQkx/5rzVmgS2ZsjKQAeWkLug3vcluvKln/ +//9dndvqJcd1h59g3mFuBHaIx13Hrkqu5LENAWMbxwHnygwToQgyUpDlJH777PV9q/YeCyGJ6n/3 +3r37ULUOv8MFDedSlHuCWpWPqsYgVcZQYw/ACK8xHlddbFTNvCVsmboWFad3R7uQvs7Qiz0+tSgS +SFs+jhlXAqq40nRMlzg1nocL0J29hmzZX/icidLl4zHlqeIOI/8NIwIeibqONVVcgwBxRz67w5gK +hrCle4R136Vv1joSvOUYr6zUGI4bKOzTNz06uup4rqvrHdaYM6M0H/NN4FfosmwbkiUtoiPNL5em +VEHWABo7w7TqThE83rXIiW0ZJ8gyIu5Q76KJHLcvwBAafGz6uKnvEdUPM4ya5nTFskGAhMCpF5bu +oOEN/dOO+GVk9W7RXysKTerw2W1L8ngUkOfyiH1E8QaOV0qItMQ4HfNEXOHSAVLlleMT15RqiWFw +v6NgF9XOM8azlHACgUq0ggo8opaZH357m0pWal513u4onqktpF5NO6SU0D8u7E86rHjMsOiH3myn +PkPZMCYp1GCW1WAaBMwLI8EDSAAMpAAdLxwKwGa3eSwM+jvN3aKwGR9NZ3BTbtsXAkaAUlv2Zp15 +uPvd9aRjS6wBH2boMHQtrN8pedQBzTWYcFwnDRCDroe7q/IF9HnzylYYSbGF/n/kBZsr/YgUUfLx +cQnvsPQq1H4xviOo1ONYDzYhxFH03vavoR+Ru/kgJEkoultU6FK7bjhFeKmUtVkILbFhYeYzJUZU +9URgjrfUXSGtmiAdU3o/0iyqbUPpsGlQFt9XehIrrtzCxBZ5+0rzwwCFxTgK8PG8tJYLDdFAy97U +pBLMb5ogrSfLZBRj17YU0CeapkE3U9rlPPPgdubxY4xyRtWP3qCopcJtgHpjconiaeUkcQfkJRjp +Fa/raHxHQdrlkTbe+cAg7bJB1TXIgqqJpBx9N/CiE3snngGAsJbXyt+ro9JYQrgXenKR0lLhF157 +ehAAeOOItU8B/sbWaJ+XD7pWOFjEZHnefoQ71OGMx3SDyKUJSccINzKXjKaYmlwaFC7tIC2Cs5hm +4/pHJTb+zkPZ5fFwxMwqP+e50vuvocqja9Et1eYCTowPEb8Tns8+L8ZUxHIr9AsVp7t/hcjahrkn +RYPaPSVBVaXphnlf1OEj9prOc64ml2Kb8TNHYgvn4u+P+dMYbE8/kv5vrOXDvgMIwoj+EG3NchNf +gULNsRotxcgq+j3FdPUAXvhEef7Dz3ABw1KCNyWYqgSWFxce7CGRpzX+SHANzqK31Q6Ts8qJjSbD +uk45YDk52wlBx4vLtJO7fjmVV4rF2DjcImhWGkf4+pfQq45xEyREOVhZAN7u+VTxJ8alLycP3MeL +OD3Z6ORAZ8KhQuG9lIbXpFRGg7IrIt5EUsaLVKxdoOnUkkxHwDlzCkLujpDU86x67iT5i7/HN4YQ +dpzT3slmVkn2OJI0G+wtNerBojXHayQT2F4JxmPl6f8T7UUwd8hVA+t7zGVJ43aKmVJEo0KzJZBd +0nZr9rmmPOCuQNCz1xZFjtt7Q7yp9TzzaO/Jb0XzqaXCaoy3j5MhdBSCWprQsXu7dKlFugeW79o2 +YW3NkNsj+S/9uZvQYd4rr/SxKGoT0IU+QLgPiN59JfQBjguXpUjrnDL5eLMjkA9l5FhNFBaKVm93 +7rANO9ItJcqeVa32anNv9TRJNCqLLcT95xoMq1PYVjWonFlcx72dr/TCU8+Kp6Gvrc/SBXS13D7j +Q9k7QJ5Fj5mYnhvMJgv9t/ceMRmAK/C/af6K5r9bTvWCabwK4509vOj7h4gZ4cpFlksPjye6plOO +D3i5jkw+0FbqqAILdnX/5VCzFk6UElzjzgxduvHu8TKCnKlAq50m7rSFxPOYPlQV8NSZKQADRHE6 +25n8XYhV8Tb0qm0t4Tpzy6U6e3E1BK1LbYlKEMrne1uot4EOQ5XWQa1PGIFgtO3zZQ== + + + LemWmxXjNu0m4HuD2IvNtZjjF9zYSBP0uFiZNdyH3CvmG3tCZVaFGclXhFLcNDFODjMvsD5+8X39 +UgukpVcLiPwFHlWQ/+WbxBE0EDsNmvHCoxbZ+YFHPYyLbcv5ejqSMLEg4u0nSPy9dIh+qcFeTx1d +bkQr1qLwBDcZiauBijn8x0CrIPdWdKCJ1uwt0wB5jEhvVnqhV3HlRTwO/jFDQ2iU1Kp4NWTDlexN +cV8SnF1eOqtVzA++8wyBS6N4CgIqvJOumYKlXZfqywMwUQ0VcPgzTdkZEDEUi1EI6KzsoBt6S1XV +9u5okPLW2mlH1iCFDuJhnikHnNkBtQNULkt6G5XiHgdZmrqXdABBMVREMco4WI+eEo9kWdEfe/75 +0I2Q3i5CVVZP1YykH11qd++o5MU4tUGXeVE82REpP89Ha17GsT4f0f/4hmlffgkVPtrVgXwfCpj4 +Ki0t9Hria+RyNM+SqjskgqlA+JR1oMwaRPOU7C81hb2XzHPEoYfa8aDpFY1myRThH3M8cqMdzkq9 +le5YcM13amdFBek4D2AiyA+VCqGOb3zmzScocdZtP+tVUBTaQNwD5kJXeGNqUE81AClrIuXDZUAv +VksnRJx6Sgfvp+55Fa6NB5TKrDSCmFmKshihSXmIV6GCUd4m/yNVwbucEjCyoYrB+XUFMIZ9cM5Y +bYlHkCLrpiuIqwHZstuBBu+d7AyV5Zu6Wnxhim/vPEEmOIBB6c+gRmIzfItxU7MeJcfgP9VkY61z +I6rSwdHohDGSchYS8LfV154ySp6UAsuH5RKtBkwTJlMl5MZejwlov8TYPJWmt/AppLeblDuqCEXo +xfs3hw2ErH+ZGlfkDJgPC6F8TJn3OjQW5g7cq9yhe0CwFlviDfnAnrfOu5NsLV4S9TJAPMW4lrTD +on35vHtFEGzcrWBtchKDRYrySIwTAbWE4bAl/The45AriTepu6WegGR7KR73vapFcPOZAAZeFJFY +b6qgvhFtqFihWCxmPjGX0y5THsTheBIoJORby++p24Tp5uzCB9mJGEZeo9shZGnoV9KtqNA1bk8t +ydjSFEYwpW5PwstzfPf8+zFPodBDvJ4fuQUYQnRp3vD2FHlrB3cGJ9Zql5ITPCnHISLmZ72PgWjW +bgR3UW/T2GVqX3EgnVSkqPrGoleMPNfS1+oRIy/Rc+lilQE4+BaXdmo1iQcmGBhWzuI2RrDAQB+J +iC5Mwx/heNMk2OxQjDrOkJbp5rFKvoqlAO1JaOtExtvFMjHRRUY8ax7gb2qqN9QlYC7GhHDL3gIV +r2MCLAqzpTvRraZslFWKBkkGZPXQbIJevbl8nvSU/kkAIERaNGomnq9+YkQQl31Xo8RiLHwg/eGw +s5/etqE0FXHL1EozMBkEPrfWUqCqo4xryBRgjGL0ZTOuGqPGDbp1ODex0oAFoDJCYbCD5EtI/73s +eR83z5YEUr4C6UysnkUVgSnEu4wPeCTwDhsAiZrGshWfJzvSXVw64m10Pbu3Na2xRzqHraRFJOwW +rLtUjQhWcEMbaU2s9dISEYVqgEbMWjDdeeDSWENZCsAmCcCnVi9kX9f1wGa05t9LerNRVqo5VRFE +V6r6tJWgbHnE8Yu7ALCxoXAJIUQzdv/8vFkzFvWSLzETLf0E4ipwC+rzQqNY5KsNEG4bg2JIp5U4 +s2SMly/YpQ9WTA89xSG2keX20ksyy0ZpgP9KzjboBeF/XsyiZks/9CxsLtUmoLgALAXMUpOrHVNC +OoEjzh2TxtSuPF1e2zTGbkn/i2ByVFsPvUjR7WnIs3PJsvtw3D7SbjDe5ohvYCbvLbPpPsTi5ewo +q/sSMh6/v5sIgemkXn0lYc05r4r2i1SJuDTqMUorQWiLv/eRR6wzg1wuqJjNtVT1wornomaetUJo +3HO4SuhyQWM3PqG4SMMPbIlP8QimiJpB4fml2cjs5WlmRJ+aI2R11XR4KRZ9o+tSk+8OFbXK95EN +GF25lja7iHX5S3lWIj7Kvg39Fo5QPKoKWyaZ6k50uWjTAKRbdKjhwFZjqmsmZJN6YTHI7ZmGxTOQ +dPXyxOcaKFTLxPEJRESVekHLSygLcpgDamVzeJIZ1/SkVgHv9Ssqva1Gbser3Y5MbMnPumzYcTrk +R/ESb+MWnC5bAs1+ROOE2Xk6NdUo7xNbmncTyzX8gnyugdTiLzRur6vmFwJHaap1EhVEK9lB6Xxq +/k10JPvL8SupvTcyHywZXg0VgmK89N1M2hEXEoFJWeUlHcWm0yZ5skHtVHEhZq9L2wEdv4oLRnxl +TLAxLlo0dBvcsYoRgWejqqUfJBY9thLpU7zXtKf6HTul8+KCxb3FAOAsWkW1uI9aCWU6rsQCb/F5 +L3qSeuNeiM7o6ed9EORoNuSke0mz1UesWubgCNCIMQuRKp8nEptlSwbDEK49LWl34XXHLSVe92xY +sn8RKQBjcz5Nb2WBBgRCG5ZBLRi7qSborD1FZOO62I0wV84mURupN3lCx2fF8RhNEbeZfZO3URU3 +/Ue6mYoiKv88H1bBsThDQNQKNLVbvBaMcC+SpJ4myVEcxoxBAww7Koo9vhqYJY/Y2YallBiSuFlP +Vtozwu/GyoJJ2uOIY8AaNcChsm/Gk1GiCXlaYmT0KKcPLWk5XNd08jr9yn73tz9+V0PA7B/+7c0V +WIYeEIDHf97+5Pdf/vaPv/vtr94C3fvpY8v/Pfb40x/erJfLQGQ7nwJCbIaebZ+J1KDlk5S3ATAe +b4LZzZ0dtkPWDvD9JXm7R0UCAYmRPjeXjaQ0v6jazPwGGe/JR6T688inhqyHDk1WhE7DZFbnBFbV +gq2zGsZo8//dj+KK/PVNefvLx2/++vH/x+/GhtwXmq7GJ+wUMClKFnKoP1VPAo8PqqCqVD4yg8IP +b7hGNIlVd3bkEM/kQqnN34zGMVNAW/hsQdxJocv6WOIxU0grtMdqZaNxhBpLvAyBmLslrCpzGSNJ +802hd+DcK+ecK4SBbqTKi97NKHTd2vxEYFD5BUrNHd+zuJURSXCrgOsucMAx46jFGsA1pL+zn3RT +M+tZFwxcXbWuAP7pI49TTX+0eiQAUwoAqN9l1bMKPwHCzupErUNwn24AgcrYATA7x9Od1NqhpeNa +pMKxw9RuTFBbOZPkuMedoC0k31P7Exhcvx0PtNtAczAufENaIGSUsVJrhMf3XsAFqd4FqEm3iTQ1 +qSJgox7Y9ksPIcZBcWKSxPxjUWqzMtvo7m7LXlU1xmi9Tgs8aawS1ZaWvpcXmirtFHMh0EXe2dTj +oT8aR4yS4UdXLWTWrBenSMudzuBD4OqWIRcbRJ8K8mIMnnX7ltZUHAjluVuJ1IT2bXDnjGti+c51 +XMexYGiZxaVHbdAdoj7Cn0uOT7f32iNL1okDntbEgauWK3We67v5hAHWNOaL2lkMq8Zh2HvwZ53+ +iFKBiyv0nOAe1G68NYRP9LBdlw+G6lK/mc8QAI2dRyfFUU8nLShJcTgpLObOFtVEyuffST6BPtOV +RyD7gEKGGj3Du72a6iSz5ms5S/4Mw+5QwC26z28nF5TnQzTIGuW80xiBcjeTy91VPrImiaAjbBbL +pHQj3z/pL0xn6unr7IKstYSZbuEVzibTNo4u/aDcjwlAk3uZShwx7c8rv0IBZCIgJP91gtzi0h/P +6VRBOW0LyB964vLBcerhdcSgWq4j5UrFf/0EWcv4+7IR4CU4LZhu/98DyOK6Bqyl2B2OcepLtVDV +x4aznCNu/TBZtQOOUFx2wrIRfSgXnZzyAZtqqSUgsqQzaIQ7y3HxFIgwPCJtxHpNzamuyZbK9CVN +R1N42SPoj/T0B4/PLMQ3PRkR4ahm1X6m+8KxCgsgUorbKOLdvXQ95bMn4mZ+RVqP1duf4fgRkm6/ +4tY5bPnAvr5Uhsmxh+1J7PpsXFUSjy10eR4rkbcrEwVKnc+7OyhXfvR2X8SBvWo60ZoRVfpBmPwO +mas+fhEFx5bhzVMee9iBZzwcrzvvBXWRfsi7ryN4P3GxuGj8pM6STheGr8O7VdPB9Y6A8OmMMRR+ ++OhL4R4YiWCu4Xkvn8lqOLzKPlYbRZV4ABjsUKp2ZvLU0GjFvKzlOQE8wZxMAEqJlY3xmFJAvHB0 +hqTCxT3oKUGIZtmxBVhqluFuM/1uJjQt4gIssvQxaToTCC+JhqreZG3kDLjSAoICI64peh+okAyp +RH+FRmBaTpN2Wi9kj0pYiAI/fy+YTPDg+B2XvhRK+F9KG2PP25rYcb3IUEiT0xcucriV1a5AnOYF +x71l3jXDafefQz+0Q1eauro9Yr+tX41XZbSz4sFBZcsu7uHPxEedv2sSgSDG+5eHDta72+VH64zE +v/uepROZEKrLBJpyKIvorZtZSCYTXXvALsmosu+SGKvN0pFjJL7gE2BB0jKSgJ8XO0wUv4TBs8d6 +CUpiY0LGCuXXsyYS3Qmpw/hkBDCsjzwFAGPxHSLIY8sgZOoafk51QPZxhZwnozxSZmzhM5vuWnQf +oCYMT6l7SumMNUXNBKl4afCxBzrC1073vD2O+VbzV7OURnFweSGZ4QISMfWxTYIU/l5+BB4IoYZR +zh4wOG4VLqcOQBHMToEKcWXhyvR1nFYi4Vw2b+LeVSrcC6CkrtvSeToUSfYAmdggRGJ1t0eGvzWd +swdfUVp+AjobQXqoWsqMcSUNVcPEqWdS4CPz5uGEFgKf29eM5ZS0Ai8wXs2hS9zS34WWU9Cv82cV +nSRDQ2lrKwKRM7Ih/14l5FzHTnpn4jLEQkxrvGkVFsOJu944biw4OXKASAawT8i29rQtiTVR96Zm +EWHrfNfBvWLxqPArUR8iCwwpPsX4Lgk8pQTek4MWGWNLn8koLglyc+pf9Mci40zXyLtAGmqUFVhO +psn5FCWADVYcUUc6UzJj3Se5CaQBl0ExbJAI2yy1YCHfh1I8AdcrOlcWaEdFaPbQv48D0PgAYAHV +qehzN3SNujEdsGS4pydVjld45qWxSAiPqFyIoqZmF6yXR6RtCfSpksCEeCED5JgwhPD85VaUU67j +zbrTSLcfZepCzRTcQjeVf24Z8+KcjxsHsMgflwuOqT2q52lget2NMkKa0Q4rhpZ7Wv56HBShlFFP +yay9UxjnekFX67AgGVfHIXPFOK9f1zctSqwV5W2nviEMNHq8eUeqCUds2T44dev8SH+GPXgM+hja +qIJJ8Gnu3sXgTsfz39JWlXiU8a1r93XnG4aYbGyJZC722P7SuSCoPWYPq6z3SPa5lWSQgTHiFR7Q +jWI88tKuu2tGOZFl6KmP+LSWHAK97jM7Dg1TIBdbuAu1u1smYE5daV+5rzRV5VLHEfKdmUiEdh+f +Th73+xhPBza3Ti7U7jkRgWBctDU0XQpb6HVMoOcB1C2BKsxt4LSlVcR4QfK/qIXEeJ8DoFGxZarN +3mvarN4yItObKuuS1DhGy+iJZcB6wtScOLHgMUEndnxqKRdRRImFJ+0LpwjEWMm2BQ== + + + tmlrdQOdM8q4kWgtlKc5AgJuRfGHcS7p0srYwvrZqCuwVPEd/bosgfKJH1nSnz7vkHh9rKUmHFIv +w6bF4uNOaF+VIrD2jdL3NVpx6cgFW5tC5M5lZ46uOUMGV4+MiTgFoBOXZZ2ayKWlFujUfVzfp03G +7BRyBjUB7YDjY4eZRZDmWjjTUaFnufVqGVGi3dIPYvlSJ4Fb1zRM2HrX9j4zMm5Nq7NeNU3Ag4zl +9TYAvPJhuNOhkEY5gfEqr3JDhM6pB5xmaMjQGVPm8kjG/lnUWa2inCf6CfyfGVUoihQWNd6rK6NW +7KFYbk+wDkWgz6dCK2qyrLeqHNMt4+VueU5AKjBZrskizzJ/szYE5yImmGmWcllUZ/n00orEGvj+ +HiI7JmFXpk6PDHq7nmqScpyi5SYWbfmY8k6ydT4DgBGpUq6WXSfF0RNreDInjNRYqtx/mf4TK5J6 +WdOA7+gBMMRiqTLFRDUkCgK3fNbzgcgamM61g6HL7+hafJl6FUFEVDFOphy0Kt2tkiO7j7tVFoNW +VlosPZdjItlFilsMslbT7tRGWc1azvOIKFLHlqJeruCtlsLaRcpwb0ebvFyGA7FlWVO44p2JMb/r +gtbNuF35GArvSq7rM+mMxkIOx/DPPV++HRVZivzqAqv/HeAcX75dxfJRiveZSnjhsVHVWuzUuE7a +2j7L6Natb9e4fJd8jtPuDfUDPvCRd5wH/RJT2xAhildFH6+T1/oyNSHcZqVe/FY9B9PYRtHYca0i +Enc7BxQ36PpyW6fLHPVOH7H0Oihgpty/WfG0/HgcvC7fjxj3kpXe0UaaeMnrdlpsAkSoiA7Lk6U/ +s1LL8tBgY16MWZveRCHp1P62Crj5CHfosq20KjLRu+QOV1cVulo7RnAGS96aMEou6Kbnb1l2oK99 +o92fDXtm/2nFG2JBpLVZ0KaYvI9/c/V5im+YABTcolAFzoXZDglY0WopdFwsoo/7lJerixYAvp7W +jhuT5BwXnYjHwYGzZYtD4CtxIrbCWN9lUb+dqzC3Sa4ekdk0DiRpz3aKomKxsjf7BsgGbPjyPWvw +MTS4zj+/p6eYd24GRySaGVWjNIry68RYcQrDhHEbRle5AIFM3qcqfxOO+ADnbyJTJp/hMqlCsbLE +XnDwuS0OVd16I8K571P4ryTGNwjLU8ZfKY3D2KBLavjrAE1/qNn3OCCEVuuzE0YQhTB0r4LE1mc3 +N+YrvL6Kj9O2sTRwqeIj0M5IN/Wq6Od6dxosy5kgMNzTbvlSSqOXbGWtqLsusWg9nRXigAZMmpeG +W1ERg4yxvue6mdARvG3Y4bXerPCsU/NoBKVYjSwJANeqVgdKBGs90UjiUbs7TEJTICv8/fTrkGjs +KTMae1T9ANm+kvncE91ovFxsTdSLNui2xhGzT3kKXcTwBjAXQXqCCLDJfAbxzV7ZjZFIe86P1B90 ++2uS2NN/iVYGufuNZEu0MmomvTfCT7GluwcIC5rBpHnya1kGsgAhv5YttIuliOPGSDIDUJVh91dM +HK9Ye8hJp3bbzZL6TajOKRDvxBED0QyoFWRc2g6xTFPk6LQtsMEcmUmajSbDCKsf7Tpj1b6p6rfP +mg0KfdKOoMeFfbPxymPCdzwE9M+7SchtoM5ItrldHQXfGCt80tE8jvGdIhnPLYs6SjbSu8/wj3Pu +9wl4CEmV8CK8qCXtUFm4H6FURF1vL/7504eoh9CHOSiuT1xmHoZUm74hIdYnfCEKjMtFAtpNkJIX +krNgZCYmQjZgiijlmZJUYOPpgk8CF0HkhfS7jES+0waKSk/zrDg7OvP0vGKLOjyPR+EW+r4p061z +xDC3gtkXwwtLn5I/CkWV/H0oTsWE7sOdl2C/awe/DoUpJFummPlsV8YrilV9MU16QiMSRxUlIib4 ++HuxeFZNvIupFsy6xQ++C2m0ykWMuUS/PhCNUAgmMgi3Uu7QShL4iV9DmoIf2+H1BQS15l+LM8xN +WRpSCRM7/tZdT+M4Gq5DOreylrSwRyK6ra42o2d0Sy++5hdQrWK5QlaDLWTLWzxZD/DMeHXv06mV +I/S6CXYn11zJohgvXDZO65SEhEVXMkTTzh2nlux9VgKJLD6n0y1HjOoctUva3KW3KzEv/jPrFZHD +56Zq34yCj6lKb/aFUkSzpx8vD5nJbbPJvCV29CaVOOKO2w4x0zNFfMQbmaHQs9pUiAn57TFTlokz +ELgcW4ph4Y7ppaTuF+NKbEy5lnHmBBbPouebuXGa6Oom2JuZzqXiC90Pd0gvHOfY7vJFZixLCmPD +zJX3eKU+lzpXPD791bnv6o4Z6V5OodoYRSzsw4IuSknzIrKvO89prJnPqwiDYTmzJmmeFYGE7sTS +GNXHhuwhXelmfPmjZvLlWhnZ3EdTN7bkZRTLehyUL/WdaCHPhA+guNH7swox7SkjCcKfc/zED0R1 +zoXAmgLEaxLXkuPbDnFpJ+domipH1YU9iieFMQ5HTBcK/SvZYmpL64qqQu4RBfJ/Zw+vzFI1DnQ6 +ubXZ200zrsu78RyI+I9i+/Ukk0EuZtxfIDvPIVKknjYIJmO5Gp3vvJKduM53ZGFTKcXM7wY6emZe +w+p5XaelaL284BUb5yiX8fIM79x/y0o+V2Eoq0JyZtugBwHOm2+RIqn98YCsdDvv1WqOldlxa/Dk +A/nyT7+0i6A0cucj5hFY1NuVtM/d9kkRL3/mnPZ3aUnQ5x4+1XdJ2GY7j3XAgmLL9k0bFtJpXfHn +K8vH52dEDdr+iKk38Coqyvv4WGU75Qm7sdmBV1mMq82QkBH5+/F5Nc2ehnk/n5B71LQB6tbRs+dX +EmzfU5w00th4xRg7YRyTd2QmTHQTp6AA9GUMSiXMn0VaH2MtbWJL2LidXtYzVU55w5gGl63PA1y5 +0s1+vktIZqzPDBFGvt6dfiwtnJxX27SA56tDJk/R2ksHe4oS4cyi4pUdvMtz0ts6Udg7dQE5oN1Z +GV2nio0g29YpOqqSlHvXzooyCDa1P1dNZDfrSXC8bPDrbtUhJ/bktLNkAcl6fcd1Z4uXqTbW4WLd +u+S6e9nWmCpnrGc9t+gEu+UTzmN8u04ukZjhdYLDdBEJGtDpRNas5uPMesATixnHB2ZndFOzsai6 +7TJNPm2PlZ7JNBZBu2bVATfIPMDyy1DzJFLVmo1FD3jioU82PWhZ8qqYeNKT6bqEkrmGZpyvt7mu +ykxMADSFhxTG4dQRqWtP1P4sXqgh71v29vqsf1TQfdX1C2zNygNqErUf4YSqOs1GJHIJGGV3x6MZ +ZXX5E0OK6Ur9zBj34icASIyu1zKS69L208ggPmHleIAFfX6iHMjDog7MkQk4PCkWnErKn/CueY/m +dTJJ6zooBJmvmaKFV/bbH0e777OxWE4NvyOK/okN1Q0kWOUU9WPcEmXtfPuY7M68kr9NnZtLNhPn +vhLYaKNS6gKzgPeQxIod7K890sb5iq6GfDORj83F6CxOeIx7+fornBq2uhLHaA+PAgJz9PXiznOE +0Xqa3THZGf5g3/Ebz9NlfOSSKy24i/fbqUF5In4yHjQPibDAguTU07kEEZfehmjUD3ZqRIG5wxVv +2x3NcGkfmHNXHV9caugS9ZeC7Ulyn6d4e/eAEDtdmuMC8Y75tZqzHLu50mr+vWXzwqJG0PUNnoXv +dhlLjA1UacNmBbW8MuvYY2RX3DX880csnrwNl923Ouq5PHZW4UfqDCPblzODq7JOosOS6PvXeQ6o +ItyusjJU2MCGBefHdxj2PWL18nyt1YDazkbUGCD023V5jm+nDgRmub/V0AC3YOicl5HEJT7p735W +VgziXd4pLRIz76fIoWTQXIZSO1UqcYPN3ttrJBRPfr5/fpHIaA4jFCUdfaoYXzNyB+SJJFJp0tnX +1tfBukJNNaJmjgo/T3loutLw9y7Hl/a1xS9odhdREPAM7mOLeakzKhdyK9jDKSkwsYwaSxrqBbM8 +pU2Hmjsrf7HiIy9bxNBsY5x4t1CIaKJnXIHr2WJBUEnZ+PwlFkg/luVSAxZjSv9H7uRODOblKfz4 +pgUSA70t8fQobX2KLZQKo6Bc0jnxso4Z5W3daLNS2kqKfIk/pLSqR8ptWVvjgpaTzJNmg4uKeHjW +jviEywJxQVsqC8dROKpgRkp65fZkqEFjaTwgVAVAakp73OsAGK+mh67PFxiSXtKY1VU+EKM9X73a ++1RTxg4oQqdxBjHZlLTB5QxLQqZx/+p4QKVLr6V7ZJjwgVEQBv2O91zrW07iuLRYsTNcDcZj3JIc +AUvm12+++PPPv/z+h19+8/GHb7779sP3f3v7T49NP6Fp/Xg4f/r25//6w/fffPv125/84hdffvz4 +109/+O6HD7HrT9/+42PHf378++Y3v3jzxZf/Mv78q2//4zcf/vbV9z/72Zsvvvj9h6+/+uP3H775 +r6++f/P1Xz78z1dvP3z7bRz71X8//vL26++/+ssP333/1du//Od3/xtbHoec3b/44le/+/Wb/wdJ +0f6z + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/originals/SVG_files/Podcatcher_64px.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/originals/SVG_files/Podcatcher_64px.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,2732 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + eJzsvWmTHTlyIPgL4j/kfpBZt9kWFTgCAfSOrdm7UqMdqtXW1S1pTDZWxq6iqjnDJGtZLGl6f/36 +DUfESx7Fp5HUkxmVWUlPPA+HA3D4Bcdf/B+/+fqrw3dv//Dyq/Rsvpv+4i9O716+eP/23a/uCHr3 +169f//Tj+3cI+sVvf3kX8rMZGh3+un4jDf/u5bsfX7198yv6E/3xHj/9i69f/OHlyzcv7g4/vn7x +8Mu7X/wS/vK7V+9fv4S//ebtd9++eP/tH1+++6bkH/7nsxevfqlvBlTnF++hUZj/co5/Gecw34Xl +V3nBBi/e/POLH3989f/hn0uqCWDHtz+9+e7Vm++Pb//nr+6+CnfzXcnwH/zlP7/67csfxz8DffOc +a72bn4W6LHm1xue33/708PLN+9+8e/vtyx9/PL19/fbdj7+6O/3pxZu7v3nxPfzlxd1/ffn69dt/ +uTu+fvHt/5iABcs3969ev4TePrx4D+Ri3w9/HeI3x59evf7u1z89/OEl8CGVFcHpG0L5+x8BF6DF +3xG8fvPXDwD5+uX790AkvHB2tJyA8W8flJRf/Obw69/97a8vdyGmuxPx62/+639xbeDD0K+Y4UeD +H1c+8Nu/Ovr+0Qew4T/+9uX3r2iQgfv/7ZdC77u3Pzy8ePc/fuRmwij8y+9ePvzwGsaIeJris+Uu +Bfyhv0kr4A1zPa3h7quYV/hzDhGaWJvO9Zf//Orlv/zq7tdv37xk1h7evf+aBzrneeaf/Jff/vT6 +5bvfv3n1HigrCGrM2795+93L19DePn//+sX3P2onQ//JDX734t33L9/DFHn7+qf3NIGrvgHG7vmL +P71Ergd+wd/+8PLN797+HdH4VYjrs1LKAmNe+JcE9MV6V5ZwFyq9pMAEDfbqoD8ZP2JDXPoSmCF/ +8RuYBn/77tX3r978qt5Vnht/9e7Vd31qrPGu8g9C/Ky676bfTC70/P37l2+EfJiSp79xU2x+9jdf +wxsvb747vX1A9v+I6wimwBuYHa/ffs9/s9/pL/Dxn35g6unf38BI/ebdqzeIc/o1/aV+85vXP8Gf +/urd259++Os3//R2+gWLkN+9e/EtNLv72z/895ffvgdRIID+29c/vXr/EqTAD7/8ICLo1ruXd/xH ++DD9U///8U+fX/4TLNX+cYZe3vzzy9dvf3BoDfLizXd3f//i3Q8fR/2b1y/evHh3R3DD/PzVP8Nf +XgCPOu4O+wSkL97/EYTNyzff/Wg4+Z8jPoZ9HN/X3+KkeHd3fPfTj3+8+93bt68N7fgnwy5ggmL7 +fx/v+A194M3fvmEG7d8kDbZvAonw7+4t0PrxN8Af/z1jP714/frV9+9e/PDHV99ee8GVv9ub+G+f +M7H+9PCHt69f/fjQ55OD/ObFu/evvn398us//fj+5cOHsCE3/unVm+9gIpLQ6dS+ffgBdYW7r//4 +4oeXhPP9H++p5deGcPkGBKMXfV999QGZCNvu8Y37+1+9e/HdKxC3sJcfX//08u638M8Xr+8U/Mvp +OhjEPSD6bvrH6T9NM36FOc15XuYVnjq3+TAf5/N8me9DCDGkkMMCm88aWjiEYziFc7jEOYYYY44l +rvDU2OIhHuNpiud4ifdpTiHFlNKSSlpBsWrpkI7pBM85XdJ9nnPICZ4FnpLX3PIhH/Mpn/Ml3y9A +yxKWuKQlT8uyFHjWpS5tOSzH5bRclvsyl1BiSQU+DX8u0/+tnelfwb7D1X+hKhjtZ5JvII3YkeZl +Iq7gt/4s8p3ltwIcK8Az/VmJf/jd3G8H+D7Cz8NE/zsRe0/wjUzmn8BsYDcSB1/QGVIsgYn9l/80 +3d/fX+7P96f74/3hvsFT79f7cr/c5/t0H+/D/Xy5v1wu58vpcrwcLu1SL+ulXJZLvqRLvAR4F3z8 +fDmfz6fz8XyYzu1cz+u5nJdzPqdzPAcg6/50OZ1Pp9PxdDi1Uz2tp3JaThmGLp4CkH5/vBzPx9Px +eDwc27Ee12M5Lsd8TMc4HQP07/5wOZwPp8PxcDi0Qz2sh3JYDvmQDvEQgBX3NFb399Qd7NCZOoXd +wo4drHPYvZW6iJ3EbmbqKnYWuwsdxgeRXC4T9Rz7fqL+IweQB434gJxAXiA3FuII8gS5gnzBZzbu +IH/gawImIZuAUfA04lUlfiHHkGfItdw7s/+6fOJz3j7THiQ8+pTnuH+mK8DD/oHO5Lu/+Ob4DvpU +8Gulp8LT5IHBLEd6YF4AH5Cp9yuJjhVEBAiDRE9eYcnCh/mrrm1aGzyH9bjClEImwojcV1oxNcAD +MqSCoKi5wkqv9M66VvxqFWZRhalWTzQEF5wabZ5gaYFIarGllhsIByBvbdC6tXagB+ZngzmMY0cT +AWYVLEIQYjATI8zHBLMyw9zETgFlNJS4/mgdRnoCiUB+MojCBKJwod/wZwaxuNBT6EEOFOwMCcsG +/z9M9MsRXwo/j/LzRA+sN/h5QWmKszmSHKJ3pYhfIEFBwuIDshCkLAi8WCcSto0E7iHCogSJe4af +F/hJCwNkL0rfANIXMaCYBUEKY4IG7krSuELfG8hjksiPSBvkFi8f4h/yEfmJfG3EZRzPQnzPMAIJ +KMKuzjg4MERnGKwTDNkBm8IgrhON6ALjm2isA8jLe1yVMBNOMCtwBBpMlBUmzQLTJwOpERg6w/LH +SXaG6XaEkWqAZkUjaQK5n2EHiMD5GeTDBVbkCfaHA5BUcfLBrgEmOfQ9wgjNIDsusF5PsM0cYLup +8IYCm08G/kQYyTmxXMI1TU+yJ8pD43We+ZHFJvLmRMLixF9Heg70tAkZdyJmnGjm47IBgbqQUM0k +WFG0RhKv+MwkZO9J0KKoPZO4RYGLX4eJ5G4j2YvSd+XVCDIYpXAmSQyyGB6aaceZRDIKZRTLZxLN +KJxRPKOAbizBrkiDK0/71Gca/lk/61mvPdNVcPnEZ9k/Xdb9o037uw/8wk+E73K3zM/WllawmgEB +mL7f/HwExx/h7XkG8RmxacltTVexlAgTGU3yCkub2rQ6w6pTjOuz1EK6S8uztiydrtujJophaYVQ +0D0EKljNV9HGvM4Loi2gJOYF0YK+BI0FbXiG6tYdqGKd3BvjBVqPZ1O0VQO+rkLfv/ju5d37t3d/ +/0dU46fNv2GoIivNSMkCIoh+SSuoqHvxCSS1GJZ1/AWpHCcd4rlTPFc7yx8ff0E8NpFG/t0OJQ3z +F6JDt9W63N2OPkP4OQP7V+9evnzjraINgLCKPWRCNJsQnTciVMWnCVCn42bSKiLpGDPpurKBntzW +2bdN2DhJ+sIWjZv1DNs3buNH2Ngb7PcL6QEBdAPUEw6wvaK6kUA/uYcdCE0JtETivPvaWkL7BiTz +uwRdRMEGy+w+inod0SIZlGy0Li6mZx8HKwM060lU6jCYGmfaGuknG2lN7KVF7Co0tZIYYvp8xten +9ZWsR7Qf2YI8ga6AhsC9WJJsS5o1KZpvFY13o+2ivjs5ZTeTsltI2a2o6qKeS2912inrpo200hPp +o6yLRtJCF9JAK8yQA8yrE8yze5h1AeZfgpm4AAErbPYN9/4jqAJn4P09KAoBlIYEKsQC1K2gYPBe +bgpgIAUQzXD8yqYKUldZTSdlEM3zRib6gcx0UQzJWIdnwmFNZHhlGq9Mqi9rpojTmw2uIwdZJrhg +zrR47qlbs3Qt0pt4sS08NypZymfyPCRSqytpzGeYjpH04FU8DepmwN6xEUbTkr9gqvK0pQkcZDqT +ckw2JI07PahZXHEd9C+ej+wgSNT7xSx/oJY+TDopa6UFfRWklrJiGrAlKaesnqKCyioqKKn04Q/a +yl10dMGRWdfmoT6QJo9PFe1+leHFgeYh5y+cCDwpoB9+xISNxEixFKpMhuPgr8ERz+axAUWevDaj +3wbGbCLHTYJ2C2nhvPL6qhvXXF9vbGWyfTnYlhOZltFWWzcsebUdtlal2JVsVbJNqVYlfqROZFSq +WXkis5KcBGhW0sN2ZSTOZrMuC63iVaxMXM1saR6nnampD5ucs5idbHiy6cnGJxug/iEOTPK/D07N +n/n154ow2P+DOfYC7y0T+fWS+PdIPrrtp/9WbFtaaYsqstBX929y7U3st6DxoTVRZDUc3UrAZbA4 +16VtOs55WWSb4UkPUx6mO8x53lqybCnNpveFpnW0Kc0uEpzJaGufZQbr3JV9Z6IJe7AZepE5yZvP +YpvPQTafM0nre7Ieo0ho3oJWmOYHNEGPZJHSNgQbUSDrNZE1W8jGrWT1HsgQxq8LGstkOAcypXFb +WciNhmu2TudKHraj6ApnEOX36JIjXSLSgy47ZB9JBXLn8ZqljYWUkaMa45czbwZn79oA0/5ojjx1 +4WUx74MY9Bcx4tn5qe7PIrZ6EhudnaCXyQzzg9jjq3hDl1F93KiOBxH2LO674hgnlvqoN5Lv5SzS +f/S6lI3XZfS7XMhFdiJ32WEy90uFicL+l4WmTjIvTMCZTNY0+2LONNWO4pE5kLyr5JdZweYhNWcx +B00iJ00kR02QVcI760WcNmdy3PAjnopysKdNLFVZHzVnrvPlHgdfrnpyuy9XPbndlzurL3c6X8yd +q77c7s1t5s3t/tzFeX4Gjw97eybn7Lni6rni59l7egZfz4TOnsHd4x0+zulDT3N+H/X9qPeHZ90y +2i/JXEHROYSC2jRm1+hzGR7i1CT/w/H5zKCAhQUeiwpM28CAqDtbhcdUHprkF3EusmtRZzb5FSea +1MGm89kmctMJTDM3qWtRnItncy6qe3FlRW5ymtxejzuIq7GSqxGdjexuRIcjuRzJ6chuxzPNgONE +3kf2P6IHEn2QhVSqTJ7IRN7ISMoWm0aodvME53nJk0gH98Aa4OC4N6EwD0LhpELB8W01n2zeyQNj +3yRCQMWAX/+69ufBTet5Kc5az8jpCh89F7M4bSO51j0Pj+K8bQPz8tS9uMYx5tXRFOQqqvFiKjEr +xGhz32/2iZPsFHXYJT49OLYJjU20COaPhcbE3d5nf1f4+9w/sVjXwVN3ujrTx/nOs11kM40Pjs2B +RG61UYklTuJC7yPS3GjwWLAD/UKjoFPYJu/IQNLHj6ywWJQnbOI7q6kuoxJ+Lwq4Kt9AyiR6t2rc +XZHxqkzcxHOqM0OdCYoDMZn9qboNazeV5OuBZO6J5PBFLO3ZlBy2txdTdFDVOUym6+DegHuEajtd +38m0wZjOIyoPSld4DwtYVpr4OZrydBK0Z4s23Js6pS/RF0WLWmBsUt6p79V3rxLKrLIRMhUH2SBZ +CVNF7Cyb6IV31HvRy1Q36/pZlG04y7PIU5zG1rW2yubRRP87DEqcU+Ps6V8WNGUDnzXwJDr4alr4 +aaOH50ETP6op6jTxpevikyjjZ4ltqja+mD5+sOl9/6hGfpQpTaHKjUo+uIKuOYNGd5Bq5OoSSpPz +ClWZsjph2TEUTCNfnE6uE+vkNwwJWbrsDsnvCBJ/LJThUS3keGbvy+A4yOQ4INfBJA== + + + 2R5HmogX8Rup/6B7EHi01IdwphHr2R/B3AguB2QVL97R/AneoxDNi7fYcNYhas1+hfOkbjwJWgfZ +yNSbpz4G72VoEr8+OOkm8m29n1wgW4PZ3fUwhrT1qRLcVk/EoR77M1XRJWWl6rIZAmXirOgui2CO +i/6Ie2iiH4OYpgyeBLK9ELmUv+O8apq6o26ge3H9sRNIl1pfaHEyt0/5tHUGA3K2kcAx8H5U9KEK +o8ctpG8g+DWsM+l+Fm9NzwZg98x5civtse3i6FacbBfmqVzMDpZlN8lmIRvFla1CNwu/Xbh16HcM +FOnTsG3oxpHd5lHIXtmK8IM9x1GMT+J4d+PuPPgH8eCbD1/sqWtO/ONgP6+WApMmUY/UUroMZnQ3 +pFcxh9SU7sa0hrrF4pnMoB5Nag1t78Pam5C2GNdqXi+TBWZcaOYD6Q0+waH4aI2a3BPb3IOKrZa3 +V7QPsr5V3V5FCixmiLMpLqaLauBBxMlskW7dPs/2nOw5Dg9LqMNEP8is9jH1MRzeM6o0q0ozqyTs +Y4EfF/qZXJ7VyfZs3cOby7nq1vpqasDiMrDEdp/MfI8uISuonuFSoC7Ooj+bXd9te7HvJ1kKzZ5q +T+dgsWdxT76SAAIzPLonuGfuzyYN6zI85/GZTvuv4+45PPK0/UO6I4dB9jl/lvH3SMLfB62aSTwU +Hzfwt9bNaN+YjT+ZX0uXmpo5ecgi6p4sNVm35mpgu2dyWURH81itzlRNg5nqTf6jmUOrxW/ydCWA +w/lFPoQjQRzLNVIHgHcBiBNgEhv2InOLfAFizbI9yw4BtmrVsmXbajH3QO5OgmkMu2EyAdAAdq2P +o9cSQ/WAvNZMv8DWGRMmTkTOoODAf4zPUAcaEwpui5aSCtYwQwNsNuelUbpJaY1yAcg0h19SXuaG +L1lgZOJKx6sIt6UotPQswkzohN4Uq+S4RJiZiCA2wIUYY5vDMvQ9hLUgpCgTIna95/nclfgswTzx +KS63REuUhgo4BwSxFEAxDNsCfeWzXIiczvkwttSe4bZ2lzImADlKb4uWKP3y6ZTLM0oRCsicHG85 +U7eoOQWmrmnMmwqx5oErjfxJ+Msal0wjOiNblBF4UC1i2lJoLhPmtng/JyHm+as3L+l0kWXEbCE9 +22lzRACjYXxA4GQHBPB4wDoYkPdyPCBRyL704wFoOE49br+xMC5iX6RNSO2aMe+CatNyEftia12c +dia82hZ7E975pyZLPm5bS35wTXU7w/umjm2XcTxdtTjU5ui5Eqdu67tMiV2uBPr51WWlpgg7rg4S +MHDOK7NJulWilkmW6EQ5VdQf2H11kSAdO6wKWRgHcVDJVIgyGRbNgpAJwWdGZjk10s+NVLJLnXdB +J8gkKc6LuBjcLHFnSPJwimSblRC992cym/ST3D9XDdPqcn7IU3AxT0F02T7rLvfgYrkHPZ9dnUI2 +naatu9PNqrjJNthmsw+57JpUMLlk9mVjzXp79uI8SNFZs1vP53miiG6CeYH2KtqpZ3I2RpoQ67l9 +bCqMk2F2h4j6dNA0+LNMhnkaBMY4Gbq3KbhElaL+JpsSw6SYHvEJjtNiOzGOmyh9Twxbpit5KqOI +CZsUlSEhbOs0qvO0lTs2U7zouT5Zrk6XyWWl7M4+DH7yPllGx4fzlKPbAyMXOEdwdqBQuUiwP8vk +aH8+CSo99zA+ku212mkuOse1n+GcrrY/JJfMhSqJazSRdfvD6XuayL8WSJThvscy7B6maaK9DvOn +zjAlA0xFTKBt6jqDOZdgrlWYX6f1ApMpwSRaMUR0qhegNsHcWGE6nGACBBj2QnkeZ5AEESTASuN6 +ge0h0ogeMFXDLfUKkv90voAVHidYOYXSLU7ohb8PlEpXYEYe0HF1b6e6/BG1n3NAbTBWp1seT0Mz +dfr48bQPJd2ZYWrx5+lqHE6PtPg4nD/OsjvM0k+yTFeOsnzmQRYKf3Lws6U6WdwzWcTzQkeGOM+4 +0smiBSYpZRvTWaQLZRwfKee40qEmPvSEB6JgOd3TucUTpSD3dN5M+VVBs4ufpsLTVHiaCk9TwU0F +566qZZ7JtwDaWWmNbPK2ZKlFQvbntfMtn/cxOcPyeSezvuRU12eeTPn67T+95/I/d3/36vs3L9/T +waNr0H5mX3kwKQ8m5cEUppkeYfOnt/zEAcFzMqU+A60z363pGSi28bNG5trnaYg+5bPPyhJiXtDv +EfAD6a7WZ2uK7fNIeBzNp1PSlp83M8dPfs5E+f2bNy8eXn53972A7mDFwUy5CqbpKL6bTfWFqzbz +VRfLIybztLOXVzsj40+Dh03OxJg14fImJgvpFpc64VwuLqzbXS6rmcW7VKCtq2XZ5QIN4V1xs5BR +/Lgx42tH7OtFJPnWYhG9aETBGhLdelitGgQbyQfy8JzIlOjlILgYBH3DO+/lMDqeh8HvOIHIjXYC +Xc+e87lzPHW+8rlzskMOJK77IfOLHTCPcsgcxPtEp8sLna3RPA/O9DiS/c1HyzG/B/YIOj6iZ4qW +R46O32JL9jvydIst2e/I0y22ZL8jTz9/S+5nl7aFK7ZlK7ZFK7YlK1y9imlIcHblKobU5tmifz2n ++TgE7TVsXyYXuXex+yF634+pH3YB/G0In2qF7A+nfySOz4nyrFOORSyunTXfHxJfNpHvHvtO0yb8 +7ULguyC45qefr0bCJRY+uWB4D4fvA+I9JD4ExV1Su4z3NIbFXWD88rHA+Kh6wdJvdfmQUgObWGhl +rhybwhp7eCQ8p5Cvakm3QshRtwbyK1Mcr87hOrIIa5xOiRf9RcJQ15XG26H8sj071qt7NoD9ns1j +S3r00TaLg6R5UVKInEVS19S1o7SxH4KanG/rs07W+q9reyP7fjkiRPEg2qiyKxXFkSAtE9UkeRAd +ueT9mkg1OUrkJ1I5qF4MChQSUkd6vOdAXjB2zdrxKaLMPJPJkq36ESSfZHWxvNkwJOf29FzSTyYJ +exwskUrzYO9d8qsmvWrCq090rZc2Zl19VnWga+V/NoWAps+p//NY0R8WpT/TDL9ihdOGP335ji9V +SVzS+cmS/6vtpLqX6m6qJq4auZz1X8zOTRObumbsqrmrBq+avGr0qtmrhi+ZvpvCIUuZW/SSZM1L +5Pi+Woio96PUwxSEANpFuW5rfimm0dqFFVUXkrMhYNkOH1fm6h6ugMZMoEdrStwK5ZeJz3RVeqax +nl1TH/3wyGEn97t/TsPjc7rO0/hPUc/dMy5yO36ZhiTUa8f+x4P/o2Fyr3Hfyc7/l+vHE/zrScpc +qXSzU3o+45lGLWn/0DodtevPUK5/rrfLp68/7ZdP++XTfvkfZr9MC0gIv3UssMB93hZtJ1zQCf7I +KVBX98svxcT75ZftuikAqK4328UV35/7Xp6vb+Y5jaYQfj2lnj2lnj2lnj2lnj2lnj2lnj2lnj2l +nj2lnj0lmTzlGz1Nhaep8DQVflbqGe65n5XUFdAmbl+QFSYIPjXDSA8jLs9mPPb1M5Lf9KNfaKS3 +60Z6c0a689iRiqzqMekWZlgnVzOiG9WqCXO5CNF/zSwirVcNaq/rspY7phTdD+UhfBEWVxRx+vRK +vP9xtUvOU4ryk80k+Llxrn7oGpB9Of+P1uifHqnF/ykxiH1QAeRBT8fYJmXskjP42oaPeVo/U0hP +j/haf7aInh7LRdqLaM4I+lBxjmjZPxfp+AfKczATpuGs/9kyffbFOdJQ5/LeUnt6Yk9VDhXL6flg +rctHxC9wpoRyVYxKbghIuhVPvFLaSFhK+3CS7hciHH2upcyB/bg1jQ5dO+mc6Ui2+Uk/4nH9QoRf +JsqX6/5WAEPHr98G9uRvffK3Pvlbn/ytT/7WJ3/rk7/1yd/65G998qw8OdmepsLTVHiaCp/sb7Vb +N+pmGHUQcQiv3ZLw6CGjabgVYbwJczxpNN6E6a9xG44aTVfPGmVXtjC4cqH+Tg6tXqh3ckiJ0MlV +3/dTZSxhmHwJw2HG6JyxGTM9OmX4IBrPFp0rH5opMk8mmSh9mnDi33gNXZ8f29kxzg2YGRNODJoV +Oif6jKAcWnbSNVjNOAmiJD/iGsYVvMBwBxhiLZ3fdufGzMPk/EvHSdbweJnKcrXY61jo9XD9RpVJ +lvljtyfsR3G4N8HdosJ1WQ/TY5fabq611XG9dshwkAbTo+IAh/nj4uBgSZ4iD6aPCAQvErxQGMWC +CAacAdMVweBEg0wFEd245iMN/YWWNQ48DjldmHDlvkVfVnQY5+nqMPdFOl6c00f50VsyJhtqf3GO +W7Tu+uJt6VEe7158lMZ82sj+7RUZ4yUZYbht5LjbCmD0Jzf8n7IfuB3B3YXh7sGYNlm+V3aGYW8Y +dwe3P/BEwMMTJzl18aGpACoDKgwHGIRCikIgJeEEo19hhWRQDGZQCk4gtKuTHxfYPg40hSK85UKT +ZwVJEXGHP8NcqcDfRNdqnGAarDDwCcjAKzQOMEQLjGSgGzMOMF4LMCTYmYQGA7LAQAS6EuM40W0Y +C6y3AMzmdYaiFBkcgLnIWGSrSlBkpl7jyRzsspN4Nxnr+D7PgWmOZ21zeGF/YEHOKPwZ2OXqXuh+ +pg85HPPGv9S9S4NrafpER+MH3IyjX3r6eRdKXPVPk2dx+sB1Eo9cJvHhS0WnD9wqOl4i4e4V/dC1 +opNcHCEuY/IPeqfxqm5jOfRxT4c9Ih3zWOh4R6UrPo50ocflcj/RtZx8FedCV3BW9J2j9xpvFxH3 +wtNUeJoKT1PhaSr4qfCzyke1+VmY28/LopGP/rwyUmV+llMrX5A2pBg+M2/oZ5XL+tIAc7le26DU +D9Uj2seBN9fKkF/8A0tr+sja8qtre4eTX2AWGZ5ciOZ6RaKrN5RtInhHW3mXSQPDLhwzxoX3UeGx +MtEmJjxZMK/fRFMtJqyHg08fC9eE4TctbjSWOeJ/xf6vSX5N9lPjJonU08I1j0RhLXSPLsdT+Lcq +ZZAKncule3QPm5pI26pIF6uLJPWQqDKSVkXin70cUp6kGtJK16gcpBaShiC5GpLEpelicK2HlKQi +UpJiSGj1oO5+mCiWc6A6SEcyjjg8OUsdpEw3JT1VQrpBJaTBPv1kB4W4J66XUfoZt8a6OjqnqVdU +styq7Z2x+xtj511hJSutNG3uiu03xfrySoPvc1NiaSyydJh2dZbGSkvX/Z9yuetQbkkcaZPzgrqa +S1uP2rUaTB+rw/RYLabFFxsYsgA/VJPJVWW6XpcJZsJ0pThTv6roen2mXqHpSo2maSjT5As1XbvA +KPhKEVeuMYJnulKyyd9mJHPvP1IBJ5Aac12p2tIac72KLHDy3fysREl5q0tuc3wkh+52KL9Myanl +qpID4E++MINLPqiNcs1CoYSYxxJvNC9BjZ9rJtBgBD2GqJglxei2CV2IarCndtUZPhbn+2iU71MD +hh8NGT6G6GOxxx2qcZnBzsYXyoQZlAG6Lmiey9qGVUGJQpRXKpOOr5i5Po9vhvHfew== + + + YdvdGolX809jGhbOx3Irr5b2fCy1EsZ4GrToUY8eL3IcEyq3KZWWUDkN9/8Wu4KvDtVTRnsYrGGu +kbPP/1o3iadbA2NrYgxGxrTN+nI88rz65GTByWULloE7B/EEcPZQHtMFqXMuWbKXex1TJs+WMvlY +0uQqF6IeMPrSs+G2+XDXEydHw2vHkmlIyV0P2+uhMU0qUOeLdBknAXfOZTZvb0jVlGa+HTVSStdK +Z1zOcr6FT7dg8vKFqvDkUiborpxoAdMo0VmWBny6EGcy8KLSuZV76CyZ7dCpM3QkAvUr0HykjD1M +16tE5/1ESZwF2MUJnKEncMJEPp/vQbYlkHMrMOUIEhDvTo73mUfus7T7jyv30we1+41u/ymq/fSx +bITryQjUudt2DXOOH+/aFdPl492bPp5sca17PHKfaZl9rIPT51pmH+ve9Cm5JPvubRx9+EbcIEFV +aSVTPZ21RS6is0Sq9qOa6RyhW7SZbi7LGwt13wojX2jXUiAkoFaBnMBDHAvs7rS3k651R048Lima +ERs2Bv6GtF7dmW+F8Mu266vevG2h0lHPrTs9N1FxM9Qe9774ber3Jc2TeeGvVS1/1Efoip45/6DX +e73u62MIPo7gFWl/rKHrwDB1JxdacF0auuWz2n2cwccaKN7gPXRB0pCTOdFWsRza7PPspQSh1AUP +Uhc8W+yjTKKur1YD/OjS7y/O4xXpOxvFi6O50XI+frbK/zmpfet0y8Q+bwJ4Gj2Vnk5PqafVU3vv +TxX6c4WO6oFuT7mnnajvFCoXRxo3VG7oPF45C0hXJ++PAh4t466am8qOAW6u6O40A9VfeEr6i62L ++VkCVYjto1ZgEeAvpS1jkbeCp+UqSW207jGiQeXKrgv7m2H8InGa4jVxCtAvvGfz4uTO7lDV5IKa +q1SO9AFNEadfetrrsDvgE1CveeyAzxBu/ZTjRVsKfKi3bM6bEQXTTsApDUoFn028nXC7UunxE4Xb +v2XO9Ke8+7PfPl0Tkvv3b/yZaDpyfXYYNFqtYNaFsYqiXtm86l24H1z3t0P5M4O/eOnxEr8k+CsY +vkzwXHW7pLHK4icl+lKa7ydl+X5SsugjVtuV9MBPSTjcZc49hs6H5j4lOYFSEz4pSeXfMzrv00RJ +mMldvjS6yRs5GIdD8+I33//ibzBqz2oYrjW/OebPXHjzh87ef86nv2jB5asRgnwlQKBfvfJ0tORO +TvNcnKu+SCIoJ4SuFD+vah70KHqvby6hw03R8nuLnfNWGuRuoUBRdPX8p4kMnySLrMhyKxZb59uG +qsTW1cbgCPuJFivvxhprv0wavuN+8stilKLB/JXkhDg/C0kiDsTzzUR8NxHv43USW0X+ST/12qJG +FxfpBUa84bMFdpIzxuNP+ttkTc7u//25XHnuyfsxBCpx3LxWkwZd7jzocmoan63ud5IuV+kDq0uk +LE0fMYv1Iq8zeR4fKZ/gctHyZOky20S0RD5JTZPZ1tdJj9XXmSwBbblaYYed0Veyzx7JPTtM4oq/ +l6PIUZPPJPfsJDXKu6/9I9ln006GagKaSlKVpSpNWZ6yRD2QyXYiuXr2Y6y6a7bzw9UCa83SWc6W +uBIGPXqxfJU2yWIyVVbWiir5mpyit3QdnFZ9kawUf2x+0XyrSq47nTjdCPhwXqP6VnQqwfd0JQlr +m+E45mBta3LoxJLcq4lSr3puI88rdP1fyP8daULhdDrQVOKJFGUi8b0JZ4pfRJo+6yTO+37SGatd +6EnnIuec70kqoU+cjznfoz8cRrvBCJ+14Pyfz4n3f3WE4ZGHJvAku5u6uNTRlXf727ivXdvQTnop +x7ifBbeH+fg1LzC/eVUxGdlsPKgRdL+5SmC8GcDntoxZLWM2ixS0moYMliFvZZOv4m8QG9NThrSU +achHGW8LG9NPhrSTId1kyDKZxvQSSm1ij9GY4MSGnKY5aaJTkk0x9HSnSTKe7iXh5uzyntjNpBfL +cfITu5zGFCg9BkqJUNOQC6X5UEFngYzMxeVFneUt/XCoHBB9Opj8538w+Wa5JNedGeMo/+xxnlw+ +55ePNIz19GkV5T4w1pvRnn5W7PAD4z19cvTwoyO+sWTrOgcMhrUGm0mkazVgJ0iVXDvi0JklhyZg +RO/RrJwvxfQfLhvnemFPrOtpVqrzlNgur1t4L5RTnKp7MHvzQlcbzbYX805sidnTJidbsrFJRdAs +7EyWkF5Ju9JtSFVsu4OZZ2KETZaNnUjzJd2X5hqrvlxL7EBB+jNZThdS8Weyn1ABRhU40w05BYvy +TJTEgbrwgeb3WaqM8YkE7H+UJ1PVHlSKUS1GxbjSauHyUqoe073JM2nJXGmK60zhiYWFjv5yoSlf +aurE1cisHlmQMwycZrNMlGlThzwbzrTBZb/Ps6FMm9EwTeZq57FT4zTQmH34JNXSqxxNV89QVUqM +OVwLOGxPT8kZjyScXCezV0/IOmdZeNvi9MjZKT04NdwxnSmrZrRaz3a3tJqtyMqPlIXl3KlpODfl +LVe9ne08nJqKlNldKENnnyQGpus0WK5VLtK67v5j4/Xj12V92sVZj16nNX3kTq2rd2x96Nnfv/Wh +e7c+4Tau6Urp2k8pZvvoMz1a7fZjz3r9mR77wyPVcukZLRJlrfZe6VMUanWouREsdqxmhiXCf+bV +0o9fLo22wvQpl0t/+vXSp2W6cr30DS6Y/plXTMthB19A5H66UlzCl5fYFpigEhNPtsefk+3xSIbE +AhxIGOhoGCIbS/uWvFLawaKKJJb6zesjqujtUP6H00nL1cgJQK/WmieFhjf0g7kLrx+ClnzgK5u5 +eqDPlCr+iUeg9c7MddjMfc43nYKenCO6u6JpQ5ctPbjbMBfxSsvWbp5pPhx9QWE+sa+LUz979dnu +ltdkas0tZ+6MB1iPllF97w+yct2jTGu60OputM4PtOJPm+zyRJnIKB0K5SNvbq9FeTtRMrW4ZCWl +mv2yJ8mq76xcSS86cEVK8dSyrxa9tUe+RXRih+3/3i5Z3kw+VmH/w3f97i/wvXLc7sOV968cxfPP +9Khe+djX+ZFHfIlyio96/zlnWz9l3/m8FPFP2HWm2+VPy8FWqRlE677S4YpeWSpeqSZ2cqWlVunO +vrQUdWsiIwt7xnsq988qTFEfuZe9xtj2WlnurlwsO2GfNxWn/N2y3Puh7pTw4CJR1831shMHgh/d +eLHkEqY/t7zWdn2XxEL/mI6QufL/B/e6L0Q4broNekmZhhVPrUgiBO/YTXduvFmVkib4CoCPaAVf +ivGLNuj12v68fmkK49P9AU/3BzzdH/B0f8DT/QFP9wf8bMX4fy3Cp/sDnu4PeHKKPRWNf5oKT1Ph +aSr869/X+ulFDMdz3p/1sf9w/vJ29Uxh25wpvBijj1Zk7yDZlXVTXrrYb9dKTdP/pyG78+fqWFc0 +wShHn9FlQA4DKZSERgCrSZojzwpSoyyQM2n6pB5NcsKRXQNo6S1Si4Oz4i/umPhKSRpHy1y2vGWi +zFTXZFVefHUX9fZr5vksQXz1/GsWOrv/VzwKyHbxgeKnJwnrXyS0P1ssoEcDNNBfJO3z48H+jwTz +Pxa338fmPyVGvwm1s/z+mXL6ipgmIT19ec3EA5sem0r5oxNzMfmnElBl4GnwXxYThGka3JfnXRqb +ykSVittLFEg2PuLXhBlcFzoTFUJbhsJsjY8o2h2h8CcCfcx1+MUoWUAuZR7vLoUPxFa8kMOTXFgi +Dn7BmhSxXBeXX4rpy4Tn1foWbaxvYQVBVeCwi+Fej+Q4X5P3M40HKjZlorcepmsloke35CMlotFX +MJlPaeubNE/SKDeulIraVqTlcN7hSi3aIOHRXj+rTFYe6uD8iGOsNLtTOxwxPVAWiEVNRYqS/Jwo +jWSh2B+nQjVLhpL46dijL5Iw1w5FX5ExnyBhHlcDp4/rgXrf83GT+D+WLN0WLb2WqHPZZviPhUvr +Jq8/D0k727SdTfnSyeXwt9PVAqYcozrSrNRrjHq0ahuvYjX28ctQJGY1adBquBGl34nCCu42bnUt +csUKr9Q5QrnvJT/rvhK92mQapzkMoSBQSuJ4lFyjL02LUOYaQTxclXy3QcfFh1BBG2R5XcMmXQQ6 +COL8zp1yjxi4emzDuB3KDwloAHzz67dvfvPu1Zv3r958/9VXTm77P0y//gH/kvgvv3nx/v3Ld29A +oH/9//704t3LH+8Ob75//fI7kOUbwF0Iz3Jeq/w/3ZXyDCN68v8EXf0Ju2u2wD/8if75/8Cv/x2A +/3KX7/7m7h//23z3HcH/4bfwvy3OBwcTvHfPAbZ51wDTzz6/gg9hb+h1f0tDAZYT6BeUg76uxOY8 +V9hxcDtcC22LM88LrOAqFasS5wL9wwt8AbwU67ouz8DQzEyvgPj/9Er6a7sCkY8932NC0D/Bd6xY +wBK2zAoqw7rSGxSW2rPQahw+fg2mn31+BZ++hz4HnFqgoyBF6T0KK+FZamDn+c9fg+lnn1/Bp+9R +mvTznmNrfJbbGoRBbZ7bNZB/8xabvoU+VoofFgW5QeBPXYG4Mdhg0hdQt9asn31wIM9Z5cI1mJ8N +IzZ9CVEDs0TH9MHB+CNt+Pg1mJ8PW3wDtzZjojA/APr5azA/Alt8+h4QdBG2BVxmy7zCdo0x9ASC +jWV1RnqxepBkAUjBNZDe/AstuPnut1x9JMLy5EJyax5LIHSxiko3K+SwL9Lxk4qr+e4fDlzz+O5f +/Eztc+XasF1bTFfW7AYbgv7AUn9duDBtJ6/EMFRJylyGFr0oRCb0ks0F6vl2fj08MvLDatzAPPHX +5iuTCrt8oNp3MWH44ypvZTtyFg1IR6CfaR1mqUiTa7NHuXUN5iXHFl+ndQVlP9H+uAaeWtBuKcTo +hnFOFNiasLGwiUOVNHBXHUS4W8rXhCkWutrIXAG5VXtF9v/hRhN/K4z9PF1hCLOwxYTpFZhfkNeE ++02HnzZRkJ198AdRe0UMKkg+93yH6ZbDvtkP/Bbhx/iaHL0irq/sLkxozmBFjrXQ8lLbqJ1qCcyq +XJW8JyYUB9JR8OBgvC7yXhJvYJ76LT6ldatVeE3D4xTV5QrIY7ymo+Bbfj9dWN0E/VSUzZ+lr1b+ +y/HdTz/+UfGYuyHOv5zmuwN8/8O/TD/BM2ih13VQ0kC/yrGWZ8tdhoWNlT8DcOGrPMPoYiTfgZ+P +4Byf4cWEBFYM12D9428m1EFxIs+Bxn7FY2E4ScEiqyT81wJmAh2IxN0LIVaAP+g8dq+D/2ExKyQ4 +rgXsmSUjuD2bI3wGgKU9A9tPyEiw5AG2rM/WeV4dad/i53MGemACEhgbhhU+3Jpv+CdoGEIGnEB2 +bziHbcN/Rl7VBhhj9i8HzRp35jJQ6ZkqPTpNY9sM8zcxAkOKzG6gpg8E6Ah8O1IK4KVA54Zeads/ +jd3vbR2rtC12zHG10+D5b9RuB+o0/dP0+6nd/eKXd//w9/AbTWpYBcOU/thMJ+gdgA== + + + 7+Iw5T95wtew1Ge1gmZSY4xYnpfmfJ3LimKiOfDzERzqs7IulcAOySPgjuRWM5+wlwISFLDjRrBk +ojwsjSEpg3rFzXINmYEL7Kh3I2XQstYVpxmD09oUJZjpDEQznIF4pejd1ZfjgCKHQPIBB/gPOYcs +/GzP0FmN4PAszrBDfYWxIZ6U3DalQsDwDI9LM7AFWAtIGi6MGX0CDF5i0LYpy8uWOd5xw4D7NsHK +DITz5xPsiHNlAgJNVAAuz4D3kdtWZtgMs3eBBsqbXAUBTGqYvdLjUgrPCAADtevAnXmFaRKrsHdZ +YxJgCkGJxdRZxovgpAxLbZG28E/BmueiCGAVKc9RuTUEy2oDvERpCxtvUgRVgWDyKwU1y+dhR0Q3 +ADdFk0GAnQkw5wUY0C3ABMxzNAQpKhdB6VqFMzhvShOOzy0TivYsx1lmGEgV4ngFbSBpx9ZlkY4h +GLvOI9mSImh5UWDOiwKbEmYdq6gW6cxva6Q+gCSNocg8AlFLSCtMjqiTAwSWfD7BzC5Ca8vMQwQm +JWrFiS+fl8mFOmG1z2PGlE7ZoJ8vjT8Pr4pxEWBDxjNwrUEQZFzwgmCtK815AObGIwM6SE5VgDWX +VXhdYzEEMCN1CEITKVYXeEmS1+UoKBZUP5P2lrkNwDwvQm2aq+JdcF+Q1Qx87nhLnYUKKrvHQMz8 +EoaXlYHlGcbrtcNFZhKCc5a+BVi8grdAR7PQG5dWBUXGMWEUS1oFWFLSVR6ToS3j2xgtrFLcpjrT +GJhMBJLMFiCo2kIASzsGw2Yg5M6hFiGhzTrAICejIAi5j2TW/laQDjoQIBuobYNpn5emk5F724Ch +IOq0t0UGAsCYDirUxnWVtiuWcWeOo3AXYF11jRWHoCUVNDUxARF6W6UpluwUIGju+qamax/BYZa1 +3yrPGgAC49IOARpLAgzzYgiIRF46lcVfI3Un6DxgYd8Sy5zObUaQcBR1wGQTQWDWpVthq72zlkLB +ChLJEKRkG04BMAPLsq7KWAOSv5UpMBYAdI62cHjAAQjcVHYFJapm3XRhC5VZ1DJPdcbaeBYBsMtJ +EokMLK0qs3EzUgQL0KVteXI3WOPZdpvIcgpagilYhK+p8MzATTCq8MOw7EkR6Ksyb5cIWqJOltVg +XXbbpgTg1Iqu5MQiBoCtrxeRfQ0Wd6rN0cQICnqadXGGkLRt1PWC8Zq7/ypt0Q7WnUbwwpKL2SZs +FRgIZF1vKGn4XStqYbriin1+QWYMu0/zO+hawmoI2px0zeMJGgSCigT/1inAKg8A07rKq1LSKQBb +ZVIC4irvApWpxS0LGwxmTU4UMoL2LJWmCwYFPQNJZefhmksRYJ6H/UsRlFilt0tuVWYRvK4tgoIM +XnkZ2iiiYQXDu5rGEmxxAN6gU1b2e7CMTbk29QiBYJCsqh4JaxEMs0/nV2radp2zyQdiLVo+IeuU +i7q8sW1LVSddKVna4gkdZQ1ryjNtGTq4qSZBAJIz266WK+8eCAa5peCyKArVlVH4lyTAZvtMRF+H +4m1rlsWYsHY8AkHNLTrtsRyyAEEaVt1XYxQEESsLLY4wBq5ZWbPULDAM3Stn1mqfh0WsnFmLfr5v +7SFHpWpNtoH2sUkoBXXdAPPvBAh7uyKYFRjrasCyGII+xcUNy+C8hrWrYwyrMSTHRAaWqEOecbNW +tMscls3QQNtVVQMY5izADNuPKlOhGoISVE4srFsgsKUgwAILkoAZNiXdqTDBQhCATIcfiqAWaRti +KErW3AQIapqqc6jHK4Kcm7BA1FwE1qTq3KpdWJ7FrPyuqG8yAgAvzAOYUlHWDQjrpqJ+SS0oMEV9 +VbJ1s6CsFDAIaO5CcXuFqNQIXLLKNLBddRRAQVt1s1lqq9pWzLig2iABg64EvKHKEJCiwt1Fx7cA +0QZmrMAjAYJYVgpAwBqClhadB6yPhnk1pRraAsMEGFvOytlZmQh6X9WFR6wXYNIVUpZqWJuukJJF +AUcw/C4IqDMIrE5Yk93CwK7ywA6hwqeacoF2MfO7oQM68NCGZMC0RgVG5UBzG6aEZBick0oO2sYY +uGY1QpqIRIAV/fwaFW2YzWSMQjxsWiq1qoi9BpNNJ9Cq6hKCQ1UlgOYCA5fWhPq5yHTHvU6X8drl +ZnMyVolHikJRBKyKIzAuqklXNGKV+lBVaojVTwgW7X1m5YYR2GRT1QjBJeig6BwMGA8pOgNEPGBL +25NIu1UENapAXlHtfq7gxIsDvR0L40WBuXouMHCWFRNNEyUoypq+jhi4gEUjE4NtDARSxImR5hIM +QTYFN6vXC8G0zTN45VkcZFDHYQhOSlcUGoqX+CyrXniDLWxqs4uBgGu23upWhWC01akTJHARCL/m +PjnnVYC64mQmMYJoNhFObhYFAbaf3FRGsqWFwGwrbl1FRUNwtyEbO1QQiJdn6stWZnhmk6XLSEaQ +8VJOpSAJtdkcRbbmEBZ0JsKP1D/fdEspKGsYGG3hoe0pQIppySCoQEdwUSdHDbzGALguyctuBpKH +TTYqXXgBPQRNd0Vc2gIMWUcxyZwFYNKWDav2K4JUbFvlfR1g6nKE4SwL96BQbX+3S/DnC4gd/bwo +tIhgXXRHoSFiYMN9X94U7PN4WlG0ELYTEJijAmsRqmCXEVcbIs3JEGAOmZMyzwUMFqjuHrzVBthR +UtIZm9iVGnCXUN8AfYTRogtQd5Qm+xQAu25D2igDFzF2I4b6dHlUkGi5jASA+M1RJndkRxUC1Vz3 +GyWCm3W3rYpgNR2msLGIQMyd00mk21RAUZ2ULvRtCtai0gQzSo0C1U9riIujINikT1HaYsBY+MJG +OAGD0oonTQ3BOuucFacHArGKz0buQBdW1VqXohpXxGQnVa5SZmrjzHE8Fp5raAJUT0ZE1SkagjIn +W3aLIoAppRSwIyKopSzTIAkPSAeWXZVlxXMBZ9E7I3s1GBirusRW8dQj0NRp2joVbzZDY5HNVQda +NFTW5Gg3mpObc4wA9xjTp6OGN6hH25WHpJucXMSooCWgalBRG/9K2+cKttlM/mQGpqbiU7zcCFxm +jSosaNsp3q556sZA4kWNipVdXfQqczjSlqwIYlLmNIrXMQW2XzUxzYgCW5C5fx6Pzo6aa0QrTPVs +VX0xMGQ7bjUDJCaQqupQWCsr6ghM2bY2GXMA1qSKz6K7DYF1D2hidwMwL1nbSigoou87r7vJCHtj +qX6dCtam7uAmigACTTsgAWoIwtw2MzRxPFzkcjOyogpr88sheGnq09bxSqaQw8ixUwaB62y6H1o1 ++vlim0hbqxJQbBemvVHelFQhN9U7dnddeKbxHoKamkdyxsB9zzViq+n5joXdbUDTUF9GJA4CNMKO +bfswmXYMVM9gZFcPI8iwgrJICbXbAdidAQ1nJANrm4tObtVJEVz69G5NOtb9iG4mgnGJfGLCZHks +QFcTPXOOi67FxW2vNGUUrQbZAMxaQ1y8jiZ2EQDVSYF2jRKLCsKsHRNRC3v+ohsDCUduGKNZG6YO +RoxQq9xh/xOA1F3XTVsAqgkiyrN+vJmDwvi6moteHOgMpLTNjSaEYNFPgFlKAQCjru+A3jgEVtPp +I8cXGQFYXMG43RJT0FhpJ2Bmpy0CNQqGYlw1agDrDiS+SWpZ1BmyKgMbM0OEfBUOJEozty2MNV8E +FrVhMwe8EBiDejJscSHUPHg61q4pdorV4YS2ptkvqyqjCd2JVeY7MJv6moKp0wOwm8tdZ0qBbWdh +bFm0bYwCjDyuSSJfPK4aA6Omtlc2MRgTzqdgG0dTpGszV4yJ6CTavb3ruUDdzOAUNgTjJ7tu0Jjf +CFSrOfMqSKjsrYq16OpGcNWmKjgT9sekaeC9GoE5+F1GESylKV7ZU1M0URI1dAzblmMsBYYZAYZZ +zLjNYloCNEs4ty+ElCgpTDkjkyOZz2KDVnVv1CZYfU/ZZmdUfzwC1ecr+hkjAGOnqXqlhn8qFoOL +7IxmoOstrhRGAGCxapCwmKRnK/radMTEzwRtm8mIZWUZkTA4GBTvWnSCAYKixmUS51NCUyGrQFqj +AgGzaojqDQAoORlFtWCFNmEEJOsE57gSAle0vHoPFIGqqZEddIJAvDqRzUEGklYngkdtZgSLpu24 +WC1eBxSwrQKw3gGN3yOUnNXC76Yfp1EeO1DN3SoeMUXQVy5tWM8FrOFJt0hXDrOxnBNNH2kN6vrv +nnt8XdNgrGQZy+uKhedUpmFsSUAcTaaPF421VHT8nx7/ONCaVA3LnHtDDWczbnOniuI53APWNqir +Js/EiAQg5cMyMKhXC3MVo9o64nWHpsWmpk23igdGzJOROv3NnIpFZ0azbJzu2ANgSkpp3xSJgNWM +WxH/0HZOurrEqkrNyYJsKkxC41T12zQbAp2CGinCdiHo0ky2IzzycTwCJq+Kq75f40/RjwCYm1GF +tCrdGfevGhytDIxBySLXKSHIswU9owUuEGs1QSIOPETgWBg6grA23RUlWgbAss4mSPTzoKwoATYH +sGlUL3KR4E2e/eoWayhjrpEq3dH29YyRMxVwQfxJOVhICN1wCqo62aJZmpmcnSoxJP8DoUqTLAGE +NN3oNXaWMSe3OwmbodQci6iZZwhsMqsXCQkiKKtgCZLDE3Ls6Oif5lqL7PBnYMw6G2jU9MWtqd5R +OH7rX6zOruz1gO6TGT6ekr4JBKKMhHpUkKaos7lHDhCcVdKjOHgu0K6la/QjUwPplRryCLR39aAM +goPmNK7i10JgVraI6MnRgvIo09dmn6+zcrXabplBacg6diqTsW3VvSaL0xZawgxVINpMireVovtC +U70JWlOigXCRtwt8mU1o1XsQr+12wVz1AAZhq0tyZhdSxgCl9bcYYZReKT1TBQXAq6TyRbarGFhC +3/AWgal/ILpoBaI1A2DJrmPdMlGfPL0rbbS8jKZlMWBTurJT0yTnAIGp6qBLaIsaJhnI4j8fi/Zr +FZc8AHPSrUUtK0RqLt6sFgxA+6TT4BwibaokUuSEgYsJBTfBAYFNGfVPArCrz5JSCvoSx+K5q7F0 +CpzNXjSwD63nYsZtyTpDfYqdqm6IGRPHeM9TehfO0KrsSdTtBduu6imP4hQCYLIMvcTpiAjMyTIO ++hRf0EOpMr9ERaA5v9HC7QBcw1L7MPLni/mE3IgVp+KQt5WB6lcbpkx3lUdWQxlYFhUIZZmzADUY +BgRENduxrQ0Z+STlZYuu8iabXsYsOrVau5uEEJikmmUzAPV31eG1NV44QlDNsFAENQXdd4J1t3Qv +LycCElnZHA8W0cW2JW/cBNg2qJ9Z/ef4KvPqE5ARrM6ZqgktAOzp0SvbnQgL6hZrfRYAeDbtLQXl +d0vF3ClseeObFrWcUQTp53OwzzcOXmafyajhsYxavekNFq0AsKb/RI4uCzDrJiZpJwRTMdtjeYg2 +6EZLTvnnAl6KSmo6SaBgTY2N7OESFBJDZvZVi61Joj2/qVpaLm5LihHMilk3ELWrEA== + + + Y1M7VFQUtIpU84uas4kfV57YDg6vj81pLfLuqtsf+SyNpKjaoKboI0Xi+IqciyhImxk6tfU+RXMm +mNjGl63mpCnKFApf8grQfHMEq0Mnan4qAmvU/chWQHVrpaem5MYdH3flZu552e0ZWFZlajHvGYJD +33k4MrWg78h4WBVpLTp+sWvJjc+njDK+ueBJFo8W9lWWBbCgtmoI5qYu7yKuH2gLer45UDvQAgw9 +IIKcWWYLMNTF2KXxH1WzK0fBCeakENBVLQlc8ouQqqo+TTVVAKi7tJyb0B6oIthTvxBBT2EQ9x8C +s6YwOCnUmHMMTrOOV88T02wVGJiuQVFSAiHA8Vosel9ZZCEwqGVt5gNaUGYXWooUno8KTQnjxF8E +NosO6kReMDFKGWu72RLcNk0WEAOdz37lvWQJbtfpHtAlWCQycvIZA2OwLa4GRdBdYou5xBBB1Xmo +ISlsKzla3V5d5LQgA1EkKYIezV0kaWUJJtu6KMd+mRechLZRsKjvKhT9vHobe0oAAoOG+SnUy5+X +KHb1To8lWNqoJaNSS1sI0bIiFuzOYvOQN76lWw6Wgrgky8+RWCF/Hp16OgmSRDiWzGt1UKoAmItm +SnQ/NIB7PFobLklXQeifXrPmu8y6lS7o+rN8ZHE44OeLLkO1wbGlLZdkuvniNUgSUHzua3E6VQoi +4Bacu5aPzMsbgKVZLFo9d9h0XTVNW49tUGPLBJqrYu2pyxqgRmDRfpGfQdH2xKlZZDQA66JJr01U +MmyZNfu7NtV9Fszf1hzfIgGKBSMsevaGktIZqCFnSR9nBMXOOgm1zwXcM8/oqDMCV05b5LZsUwIs +Z1OhTRoiOOk5MvInPRdwn4fkODGwpSTLCSAE1mw59JLNBEAYXe1atkmLCYDKsmRJdQAGDumhL/Fs +AnCxk2AqUVED00MbVQ+YEVrLndJ03KU4p5qm2AIQ9HhFMIeOQCU1pnavacNGO4tBpEpWwsynVRSB +5sfgLRQiEYtFhTDBQdiFGS96yI6sYh1fTbic1VWDBMgGNLNzWYAlWMPW+uftNAkFL2R2LKsQEDFX +jYEad5+d/wjAZdXsdlJZZTIGTSEn74fOUD2naKfxCLwo2L2snxmT4yi0GGYdbkcBnoHSl2leBQD1 +fJkcdROZIkOgJ5WwYZhLdlOLgTCCQlPh5H6SEUHPYvSMVWxrZwTJphVg0XVLWZwipCSuhi1D6jIx +Jh1u3YHR9rVjALkLykXPDUbzmJH8zdEN7XMBR0nmnbtM9ECb3Yl9pww0nQnAugnPXdJFy80fgLRF +MtBUHgSvuhTJ1H6ueyDnsoZm5idtrHp2Q/2oC0oRFRwUmlNFxvEhR1NdWf3HHCQUsAxcmvKWshhV +G1yaHpfSBB+0PoIhaN3WXktVWjUChZbmovIvYgGn52aq6mo0vIVnCw+PKs89g3vmXG/F21eextYA +2LkruxB6FngXRrpMHKAbYtatQcNw6AbhWA12TDQsPHLOOgdlZ5kLFU+t0zaCbfG+HHXF0OFkAksS +Cbq+VhII2DSZS49TA5WH6lGL9jJNDEGf4KzH0yg8g0C0JlVO9mML5BpNilfybPGsfFxlHmlWcSb/ +ovbLEp/Q5cteHwUzUM6hUebdqv5iyqUQrBa0bKp4ADiJ9o1xmbwUZWKzgB+7v5FXs4vtie6KbVFT +5xBW0YyT0DiE+hVHSDltKMgE/oriro0DCEiB+meg6cyaC/YhWcQtqSmKvZAcSwwI15yUCVHRgtBV +tOY7w5jyonyk0OtXFH3uk0Y1PYxTz7pE6OC7hq8lcwn7sPBGnKIeBQjNQpHo8yvCry7WKYkgCjg1 +NpAx3SAoAaknQUBD6SvlIGi+gpyrQTBGGp8LmLou/ZXwFgKr4FW7IMnhbAb2mBMev4+6FiStODa3 +boos3Nj0kBqyq/Q8kLjqBFNLMlZ144Zq3vgIKhIfgkVSLSCA4LXKiGmcG4BrVAKCOMgBWPigI+am +rnMyBGFWBBoipMSblnR6SYJQUcMAsc7qkELwrBwPYvT1xJ8Ngjnb7FI5RzlGOuspCPAoVsxW1lGk +rDdGkPVQeqgm7QHYNxadHZQVp+suWqpZ0NAtskD0A1WBhIecUov+BF0HpjUEOySCSNHT91zAmU9e +48ckASCs6i/GqaE50KhXF0FgajWmJSeVUnIAEYGSYoNNq6U1z03ndk+ZL7o5Y1M56YE53KvOIopg +fEXp2lTQSOaQylkEN10cQROIF03rC413dwGu66qr1tKSLQ89SGrUV5TdLh5cNzcx6Z7TGmiw9BQV +Jt0vumYo8sdA0E8EqCFhBNoQLpb+hngXxbsGOb2R9AwTUqBHRRKWVZHOWg5EwKNs1aCSn59YAMg0 +FgKShm4RaPpciHrgVMXGV3xQJOtC0gQbPFfTqbK9aq5u2Wc7FiQHkXEHFY0ajyoVnUSLFjHgE0wK +LrKxIjBG7YHouf0IlOajK4LC3lXqmBwHrHZEEP1TPI0A2MfAzrbSeSsORtCWUBSBZP4iWXqaD/NQ +VPBSpJsRrJrVhW2jnhgTQ4HUGBbc86pFSjhP3j4+cyRB1QU+hGVBA9rDOWN9XtQCIrLshJ4k0vtV +P1OErarQ4LodeOaXA+Ow5kl54/PREgFEYD+4nvUcFII5EkCFBjiHMFQrXVLtKDNKkmQFOsA+5poA +tOqkFgZmPCoPY8xaVUEO95KM16IsFWMZJuKkQMeqZ65oV7eqDJFTfBGpas6Elp3GSNfKtTSKulRI +aJBJQEDOKCMB3bSAw8Jp57zPcWwWi2ZIdgh1lmsH1KSnqBAYrUJHUg0XwXzAgIDs9O1KFCGoJkxn +oyBhOSglTI0SAmcyGJEw3PYVHGcdB6vRkUDEKL0rJz0iUKIHWpGIXzdzihuBRY3BsjA1Zt2XpeAE +lsbh3C18lR6zAA1Zo2LUjcI1WZI6prAtu2KxDg/FKIW3sqlgzR9xEZCgJRcxVgeCVSLMWaU6kKu1 +JDKCEJTVIqZmoV+pOvR3VI4I6xRF5zyIUYokVVZVxH9R1CnRsp5AJ/kjLZMWguiJMgguQc38YpWS +Yo1iIOqK3lNwEtIwiGuZ0ShEHxS82IkRyVAn/68lJytpmHmriTGzBVkXwcZgdUt3/21P5FokJYtb +WorG0s+rx+6IonQUzRpvaiVveqBdmy1xHSmjUsYCXjUcY0TMLj8iSoI5xgGi5hykWSXpHu9zfiEF +ZCxvCT2TDwJeLZ13XTQksy6aOkQnmL6SQFEsCtSdA8GWnapnsCimo+ErzXPbE3AyysQo07wUpUwP +J1gWJPoBLJ03rWKCVq4mWzm5SH25HJjSMIMGMavVeIl06u3q+5Uw2FSqJvTSCDwoOChh66w5BjFr +xNSCe4tlMVLEVC3+Hsk0w3bhox6Vc3uypihsXq90+XSVRYhCl9CqQeDZLP42G1CUZkyiWXpGsuoQ +6B2wZJVFM5QSH6pgYtXk76f8MUHKwv4jVTLt6OygephJxj0IeGl2lAIVDj0m2EsrkIfg+XUkgn3O +VtgrsA71IGANDPdznFiHwHLQtGRCNrelPwqLaIsGlmdRKWd/aFXDeXsCpMhbW925OlLMHxTcrHYE +nlV4ruCqnjv67fl1JM+pJuCXVQJE8F35+dUARfpjEIH6FDDpZi4O/HwAgwXCbpXn+vk9xH30DdFD +BQBXLCmBpVtRJmKdZtg7Ald1xTscqOh6mwPdWBJg4lB518T3lVAFQNTrSiBFY5b86gfR61ogYYal +HbQikxzymquOOdaPTFw9D+0BtMe/FSWjZrZbi64V1BFAcbWyIlFUBI29gQ5etJTMWjTURyaPHGxA +cFqbONhkV6EydVn9RVKHhZQUFnlhZfmrdM0ze/2KZn6jYjdzkibaP1I+qqIWwqrHzMdkCEFb8Pgb +8SXL4Q6q3EOJLwEr1Yiu1lY58xSwhk8LvUpPwgtkxhFGlZtL5WFriSJi24zeK8JL1a6ujte3stLx +UBhra1j9NoosntFDxuargJ+PYKylICXwkOZAozavbN+yflwXktEKJEZgZb6ZtCXXdqXUkzJi7UCl +QJU40JDrhjAHRpMrSr26WRMzsEZGqTu6EKbjAztn9i0dZzrKK+wSuYTvilW4Tv4jWhAV65GRmj+H +bqegc4GBifVfnjkLp9jNhWXrt7KiQD0lNsgRIBl3rllBGrLNp6VaYEtT23Hkl7iqVzJKoRtsncVk +rnr2hIp08eiQS4CLdAFhQHhV3uhIVozs0I5PuwKX6cIShwt5W7EYLIdpsUTiShlmyBpy6fFUWGVR +0eTt6zrh9oXzXOtGrYt4o7Cheg/RHOB6WNRUTVvCMKNdFqgKl1CA8c0qy0fSD6+MGC6Jn6Zwd/hB +hm5Oq0xAsgYfNmAc21bE5pFzDSGr25TKBHKlDAUy46rWZ3NtG57LZuOmY3VAoYCnhIFn8XUOWGcM +wecNBQpUcSbU+rbWL491xwPk0V9885eHd+/Pr759/+rtmxfv/nT3KwD94vjLu7/8+v27V2++v/vF +13988cPL4+uXVGr6j399/uXd/4lN/sujTX73px9ecqP/C75xC/1honK06EjF2iSgZFFldNBNqVJt +oICyqzUetZZ3li2q0lmtlaUKGbIPIzho4gra3SIoQlKnEjIvFpXvBNThk7wR17ZRUK0MSDtM36+j +p+CV9f0BKSx+V1FSCFAgE2DE+ra9sw7rjgM4engbWS5U3Bd+mamGPNgzkeqfh7TAEke+4mbPqkGJ +dNVk5hrpxlxJpJsl5PQwgoNUMGGCZQMPchCPOxcCqQUKVO7OmR1mri36o9jd5LAaUClgBB28ajqp +wzoXPpowUKBAZa9Q69v27jqsOx4IeyPe2IRllUGD1dsk+LYb2H4ScTXpNUOJ8s9J7cAiP8Zd0HkF +M2kBDyMY+AAajfqMpFQsFpphT1qlGiSpw74VlxVoe3Vs2TRxw6M0oL5eWavgytXXBqRzYS/y8H4F +KmuFVN+299Vh3TFAWDtj8Wq8WaDiNUF0VcKS6IYRsDxW0lyT3eaA9yIgZPGaK7mnVpk3i9hNDhpm +tpuYXjBvdVVrPVXMes/NAZW5scxp0xaXNTvNHFYDCgFdrDC0cjxgQIr1xKIxVwhQoDJXiPVte2cd +1i0HmLdgcbaw0k0ZoGDiL7A9tEQ3vIBOT8YARk1DpnsS8sL3e6F50FkLVpUgTnhe9WEEh1mDuFRL +uHBcVkqhcNcKn5NVIHcNj7nqvLe2aMPFtMFqQKVAB0fBlQ/YDFixBBuaPwMFClTmCrW+be+uw7rj +gXAXc4ZQwqZG2hYaVg1TOug6ikTXkmV//1hhuWucxWsRGWvE/LiHERykKjbTKpVGcdJxjgGpnGKs +CFA5m9cUNm1Xrd/nsRpQKbBpL2DxQA5YMXwxm0wSChSonBVqfdveXYd1xwPhbKBjf7iJlbRS8XrQ +eeo6XPDD09Td+LHarSmypRby91LluFl3Mw9WbRR99LmKhZe4Lh52LhW1Sgio7BUL3g== + + + t8XcGLV2DKsHEgWKQMGVL2/wSFFRa8ZdIUCByl0h1rft3epIdxxg5i61rnT3WlhCJOkwg3Y68jaK +LFjRY0D3K9ntOSKXFn1bs6r8Dtw0aR6BK3v7MCLI55TI0Ai89gSo9kfhI0W+LYZ457rB2oFCgQ2O +gSWxw2OtEmP2BDBMWau09pa+r4ZyxwBkbWANd8mRdYX9TT+dwXorUb9Wi30yxuCSFf/agvFXobht +z0qfXFqAS2jWqSueeIGZdSc2hm8p1zl4lB3Ib9ePd6jEKDzOPu/62xmmvFU6/Qzt3TSU274/bp4c +bmie/F4ce0Ede/C/76YiN4r8dDNH2+A+5HAuKOoie8h0fNiAY4/cYhiZte5sya+9IqMCv53GBADX +drEcjI7VAedu0zowTnw5adqxYuVUySrrFCiQEHRqXdveL4d1zwOSVF9uMFJBwszMkVTEhxGME086 +BvrVIqqWVIfAApZzqg6oHZOcftcWJUbJzaHsEH03f7qDJYV0QIlFIOdWxtcrUEdWSPVte0c71n3v +b2UscirLLJ2jiOTDCEYuwL/vOGkEcMhGRqetuXPw0uaAyttSlzC2RYnRVIIr1g5UCpS9Cu7F1jpW +ZJ4clu0UKJDZa9T6tr27HeueBzcyFiklZzEfjQUgOxizWCRzHEuUcgoUJpGsSadOyMkDlbuYkzG2 +RTHLuW0OawcqBcpdBfeinR0rGqFS6alToEDlrlDr2/buulKgOx7cyl5EIhoX1CMnis7dDq18goSB +3d+8xkW5KzVVFajcbUnnrrbFfbWoNq1YHZAJ0M8LNLii5IaUFrZU/jQCFKjMVZ+Xa2vdclh3HLiR +vcgJYkE1YSxL+LABV3WPc81fNczaKotq1rukFMhdw5jQHMa2ZI6lMGJ1QKFAmStgNIuk3mLHGoLm +NzkKFMgUGLW+rfXLY93x4Ab2Ir1/rTJka9IsCAeunJHLwBQUSNsn94t99gZUzgaRuL0tviIqULE6 +oFCgnBUw7t4Y+Buw4qyTky+dAgUqZ4Va39b65bHueHAre5HkFaev4WaBufsPG3DlPBbuR0s677Ic +FsXi3FGnOAGVvSnM+7bzsoYdVgUKBTbzGYy7jJwO7liRpyluKFCgIhBqfVvrl8e648GNLMZA/hx1 +4lB9kYcdWG/TQGBe1fzofYONcnVA7VtOOjyubY9oOqwdSBTY8BhYEy87VmLOvI4UKFARCLVj294v +h3XDg5sajbRT8PnTWZL/H3ZgV14+mG8Cx1ZYUdTQXufa+yeC17dcY4w7lB1Ir9fPd7Aeq3BIh/mv +7xegySfzl2jboVOKdc+AbzkF5H9BbOtDpiMbMv8q1iMluGeVvWY9OnDk3IKvuE60HJWyKBdVHG7J +h8mI6VgWVnJ8XduiF7R4rB3orccORqVSUrc6Vgw7B6kYbBQokBEYta5t75fDuueBKIpfZDjSBUSa +LIEb4MMGjLpW0arceggi+QrTnYO5OMZKsSjfduHg/oi1A4UCRmBglHhScdiQzqul73UCFKh8FWJd +296tjnTPgdsZj5g9UMTPT7VQHjZgqjogvG1cJCgkO/VBBUSqB3LXElaYzJu22RKHO9IOk/fr2Ah4 +ttRnh3ReLdevE6BA5a0Q69r2Xjmsew7cynSkw5lRDbcito2DYpmJzKeHAme9coJCNt7q0TQBKm/l +wj7fFq8VUt4a1g6cLRvHQWd3psmQosGk1aCNAAUyAiPWt7VueaxbDtzMbqQj51UUrHkJnbkKDnaw +KMrVbbymqzFXjwgKUJkrR4F922SHWhzWDhQKFIGA6SiM1WcXrOhykuPQnQIFKneFWt/W+uWx7nhw +K9ORjqNnTW3AxN6HEYyG2crOHyqQoSaDFpyheiwDkPuGZd5q2rSle1nqBqsBlQKb+7MypzV9lyBF +qynPcSRAgcpcIda37b3tSHccuIXhSEUZZg15YVbVwwgmbczucZC7UXHSSRIz5vC2GBxQ+aoHAl1b +LLKofDWsBlQKFEEHW9lyw0rxFs7b6xQoUBkr1Pq2vruGdceDmxmOlJxsQatZ4rgOTM7Bpv2Qe9iC +3Bn6lRzXVD8xAZU7clmIbwsbT1H2GlYDKgWKoIMlBdNhRQ2qxTxSoEBlr1A7tu3dNaw7HtzKcKSS +hVGWxGJz10PtOG6wvEw8KLWoGJabVxWoXVslC2NoK+WeRqwduNTOmg7VCxoMJ11oZkB5vwL180Lr +2Lb3ql6BLTZvb2AuIrlLU3O0mKbgwXqABnvB55PGQV/y7GeCzZo4511buTluxNqB46o2sBZsGrCu +Le4IQJh+vNPaW/ZOOZQbBrC5+DFj7l/DjqMz+jofuh3nwK7qe9Byb+gilxNZiS4Uaw5IzEhYEHRt +m7aYgaC6nKslr0Bvx3Ww07A61lmutR0oUCAjMGp9W+uXx7rjwQ3suIS7u7pysIbQwwbaL6xIVNlT +Aj96YUbCw9E1OaDydY65bdpikYAQN1g7kAlQtgqUjinXuwEnariz3VMg71cgf95o9W2tVw7ptv83 +M+Lwxougw5WwpNbDBtyvGsXSGEuTeawlg+iyhlwdkLuW9fZi33axPdJhXdzGSRTo2PTdjOp3DVjn +1RzanQIFKnOFWt/W+uWx7nhwKzMOrwmRU+YzlQt/2EAxtTMJb2POepogsLczUXmj5IDKW1XZXFss +J6XRN0XaYfx6kyYMRdVKSgB1nJgyJyUg+vsVqJwVWn1b65THuu3/zYw4vFSl6ZhRndeHDThwLQ6m +NyWNyOk1jdA3quTSgcrbwMWEfdvMh25HrB0oFCgCAc+tX8piWDGwrbcIGAUKVO4Ktb6t9ctj3fHg +VkZckmsbWbFRZXiAUhVYJjcHjdRLnVu67WVJHcYdS3oc1rXMlgvjUHqgKcIdiixYreKQ4MScgr6H +yesVqIwVSn1b65PHuu3+LQy4JOemWS9sqgR3cOiHxqlgkebgSnYwdgtUwtUBla10LGXbtsmZfofV +gEqBIuhguw/EsJIvMYWRAgUqY4Va39Z317DueHAzAw6XTdCBXPH2sIcRTC66prQtUjNotjKzCa/n +qNEBlTuxlLBpm1Rn9VjToMgurY+Pgf3aZ6x6mfNAgQKNvUzt2LZ317DueHArAw5p4JI1qHq32Cev +A8+r3iAl9RbR2EnG8hrVKUJA7VtbNcxvbRNeyZU2WAegWbcDWOtbDlhrvwSrU1AtsjVQ69r2fjms +Gx7czIrDqmVNBw5Gq0/eDqZqpgIsFqHrI7+KJtrGvaTUed9W7p8esXYgUWAIDCw16AekdS279yNM +P91JdS2tTx3jpvv/djZcRt9tzc5+ediAA1dZ/IqLBnL/0H6Q+xWxbKEF6OxsIJVDXNq6abu609aG +tQO9DdfBs1RKG7Di6TKpRdUpUCAjMGp9W+uXx7rjwQ1suEy374kPJVtpEwcOFvvHC1Ziz0Vreo+I +FvmKLqSQF6sQ5dpiSuecN1g7UCjQkRHwrAWHHFL0pCtbjAAFKl+FWN/WuuWQ7jhwMzMu9zjlzKfz +Hjbg4IpiplbEeshaeQMLtM7VAZW3cprfty16Htoh7bC5Hxp0YOSCXiFgSMmRnsNIgAKNt23XtsdE +HdYdB25lxGFlz9LUiFmMswoMfIcwU5uLRYDtphwY1dZhylgpdO9aYkXhuEXZgfRyZasAnW7VUVJO +tlQusbcrUNkqhPq21iWPddP5mxlwme75EB2MKu49bMBS5ZTJ1cKP7moFPL0RggMqZ7VGlWtLJRrb +BmsHCgWKQMCzFQDtSGeqy1tHAhSovBVifVvrlkO648CtzDe84MqSzUgiPezAEkTPyRnMyfYPmH4O +xv3CItAa19eWi95p7TB6mJOSBp6b1XPvONFy0JtT7PUKNL62Ejdtk8u2M6y77t/CfqPCwZbtW+de +hqifyVv02o4EqyYFnW+zsjWsITug8rVIGTzXdsGqIWmD1YBKgXK2g7VuWcc692qtnQIFKmeFWt/W +d9ew7nhwM/stdy9e4ytVH0Yw+eaakqG2bbErvuYaQocpa7PlTPaWa1i3CA2oL9fPdzDdmzognXuh +zv5+BSpn1bC2lr6fhnPX+VsZbji2XL0SMc9zNbY68Gplrui4Ho9uDnZTXFPN3s7o0VSyJFNrm7k8 +84h1AM6akTiA1UE8YC1LizsKCGi8NWpd294vw7rjwc0MNywXlvRAPoV3H3Zgu/IuuT3AjXwPaRNQ +O9eSJkH6tqWtO6wd2OPOA1jr/A5YTVb297cuajul1q73yOHb9P5T7Lbwr5dIuaCvxZktDwMwaLk/ +uo6girOdd7J+PQqDiA+LXcvW29URU3Vv48/oJl/5NsCOY6ZbusaXCYw/aVS5lkK7R7jp460O2S1J +D9iGme9rftiAg6WMIalcDRLtgtz0RonCNyArkLuFl+5pEMParlwlccTagUKBjoKAXUC/Y0UNNtkg +CgUKNMYytb5tcqeUDeuOBzez0BZcKzpwyY7UODDGSuR6lIx3w2rJimw3fpRg5XGyem/xdpNZrWJr +u+rdUh5rBwoFyl4BIyP0divDSmf1lpEAgSlzhVbX0jrlUe4YcCsDDS8HsdJuUc5Ze2jAE356uYj4 +rkK//xyvTckOpHzNs8Z8rCXe377GDc4OnN1qNihKcHfBzKzmGF3x7F6vIGNrtVxebWld8ji3vb+Z +ibZgQrIqoSSWH3bgJoEcvEwrdjFR9B6pXFJzQGUtFa8Y2xbdzj1WD7SiHw6MfJBjZB0rZiNojVyj +QIHKXaHWt7V+eaw7HtzKSMN7buxoFCV+P+zARkMPm9v9QwvWrYgOKKzZNCtc8dSj8yB6sU34pl6V +RWzkRcPEenWVvVWBxk8J1ru21hOPcNfrW9hmeBFc1EI2c1HbbAC7vatGLU/T5EZE7FdQK87KS9JG +3TRQZG0LVtXbYvVAokCZKmCnsnWsc79FolOgQOWsUOvbWr881h0Pbmab4Qa6Js1oraYaGDjM/Yo2 +IFhKM82W44GXTaEM60BlLwz6vm3lW0M9VgMqBYqgg/0tWIwVdx85T9opUKCxt+za+u4a1h0PbmWi +kTBSVzGlHDyMYFwpurFjbcXVmJN06lBdqw5U5sDG3nZtl6blhpxqIUCloA+PgsV87khJSNq1YUKA +ApW5Qqxv63urSHccuO2ZumGUMSXzYQdtcssNXcBm3qucdBfp3gUCKn9Cq+uuba/PYlg9sKbO3w6l +orgD0nFKd/cCAY3B5lNzE7V3y7BuOfChM3W3LMjyIVPw9//L6rPMBaZtrtsTdh5slVTmkjTm2Wuu +zAU1FdYSXX0W2LPwUt2xPsu8rK6Kh2J1QGcuOnCvpOKw9porjgJfn8VR69tavxzWPQ9uZDrOS8Uz +aKraa30WB5ZiKtixKrlNVnMFO6YReFefBTu2xE3LRatIK8IO0Td/O41gq6NiCHu9FfdqX5vFkena +uk52nPue36yQ54KnddQattosDtyrqMBuj/fWS36p1FvBztVZS4pYbRZkg9zK7dtmvQ== + + + odJjNaBSwAg62KqoOKy93oqjwNdmcdS6tq67HeueB7cq5LmgSmrHy7Q2iwP3KipIb5m1rK/UW8G+ +ySWsvjYL8iGum5Y+TmQ4e/TKVWbxYKuhYjh7rRX3dl+XxVHq2rqudpz7/t+sjmdBDVPzZLQui4da +BRUENr5xsNdamQteTFCaAypnNYfStc1SZ33A2oG9LouD9goqDmmvteII8HVZHLG+rXXLY91y4FZ1 +PAsOUFU9Qp1IHmwVVHCKyC1CvdYKdk0rjLq6LMiGOW5aJldvz3B6p5lVZXHgYPVTDGevs+Le7muy +OEp9W+uTx7nr/y1qeOL7ZzX8rSaLB1v1FASuFpyUOivYL82odjVZEKzWiWsLgnLRCnqGtQNdTRYH +DlY9xWHtZr6jwHsDHLW+rfXLY93x4GY1PHEX6Eaa1mTxYKsIQTMk66yTOisI1APGriYLgtd10zK5 +QsiGM/miyVqRxYGD1U4xnMFqrLi3K1DfLpT6tsHZroZz1/9bVfBE0qykrdVjGcFSOQWBIMd96RUB +1uaLtGjfiqWru7altrbD2oFWj2UES+UUhzVYjRVHgQIVgVA7tu39clg3PLhtEU+cJlVrrFg9lhEs +xVOQFr75gBbRrDJvDRq90Hos1L+4bdfLrjqEHWjVWEaw1E3pKIfVpO92tVg8meMqqf2qj7LsgP9b +1GKZMUxhS7hbig5sVVPmJVoZ8n7jwDJbUW1/OwFe7jXnZWybV7sauWN1QG8pdnCvmuKw9voqjgJf +i8VR69smJ4UV654HX57/iUj5/g+KrWktFg+2qilIar/hQeqrYLc6B60Wy0z3sWl9TW0LzFqaGvaK +1QFdLRYHtrIpDmmvr+II8LVYHLG+rXWrI91z4HbGIuagqnfBarF4sJZNQXKDnGW2+iozXbgXogMy +azDsHDdtgTehXyXBSB3M1WJx4F41xSHt9VUcAb4WiyPWt7VeOax7DtzMVEz+qpVSjbUKtaopSC78 +wZdd4a7p/dCuFguyQeu89ba4npNGdRSrA/ZaLA7aT986pL2+iiPA12JxxPq21i2HdceBm9mKC+ZV +aNzFarF4sFVNmfFmyVzGWizYt7bouUmrxYJ8AH0pj20BqBfGd6wO6GqxOHCvmuKw9voqjgJfi8VR +69tavxzWPQ9uZS4ueDvkogmDWovFgYNVTUF6q5w1tfoqCJzXsK3Fgl1WC6K3xam36ixVrB04u1os +HqxlUxzSXl/FEeBrsThifdve2450x4FbGIwolVYrN6i1WBw4WNUUJHVNmjUk9VUQGGr1RVeUryWr +98faAm3NgpiK1YBKgSLoYKma4rD2+iqOAl+LxVHr2/ruGtYdD25mMOLoWu1Xq8XiwKFfFrjQBDQH +rE1bGMLogModuoh4bItlWTSb1LAacHa1WEZwitZWsM5yDc9AgQKVvULt2LZ317DueHAroxFpmM3Q +sLnroW2JKhOWmKw0thKWYz+Q0BdkChoo7y1j0snoUHbgYvPWQ2NYdIoKTiuE4N4uMP240Dm07B1y +KMe+3yoRlIiNdr9FMS3Bg6PusQHPXIzFd6gPqRUHtBmzaB6na7sudmK3Y+3AcUUbWIqmjFi5uspI +gNZhGWntLXunHMoNA/7NzvDNeBYo68mKbsM5sFVMmTMemlZTQ2qrwAjj9bseSMxIq55n9G3xKj/V +4xSrA3obroOddtWx9toqjgJfh8VR69r2fnlNcMeDG9hweIJNbtPrdVg81CqmEKWzBnn0useEh3zD +6oDMlopSLG7aFr0P1GF1wF6HxUH7+u84e20V935fh8XR6tr2XnWku/7fzIDLeP4z6d6kdVg82Cqm +zBkLVM6i3EqSO3atJLtZTuuwIBt6hNvarrY/dqwO6OqwOHCvmOKw9toqjgJfh8VR69r2fjmsex7c +yoTLeBRMK0pEydL3UC2ZgtRqlqrVVsGerUkjP1aHBbmg6ppru7rq6ILUwXodFgedrWKKw9lrq7j3 ++zosjlbXtnfKYd31/2YGXEYzVVUEq8PiwVYxBelds2q9UlsF+6a3xbk6LMiHlnRsrC10s+lRKcXq +gK4OiwPPVjHFYe21VRwFvg6Lo9a17f1yWPc8uJUBl4NVBep1WEaoFE1BckuJevvGrLxtWW0PrcOC +UApNDC2r5bx0lAPQlOAOna1iisPZa6u41/s6LI5S17b3yWHddf8WxhsJe80EtDosDhysYgqSuqzq +MdBbGjOuDq0cZHVYaG+J6rPQtgnvbLO7EAVrByoFiqCD5fytw9prqzgKfB0WR61v67urWPc8uJnx +hsumaNKg1WEZwdDLKv3oxfglbRiBQWrgzT3FmFZp0FiotqX93FL4os1Fr8gurY+PgcWy7UjRHhD3 +YidAgcpdvbtgaNu7JUj3HLiV6YYDHFX6WBUWB0bWhFWFrV47hToH1aFEYFz0DEbURETq8Wxp9tIW +V69dDqpYO3B2VVhGMJ3tGLCSrDSGCQUKNObOeuLMte3ddVg3PLiZDZep81als/ap28FSLwWBWjyx +9d1htoLibdxJUmv7tr2clcPagVaFZQRzzZQRabUx7+/XKiwjqb1l71PHuOn+v50Fl2Y88+mzJR82 +YKuXArIAFrFWx5TKKnOsLjTXb2iPxVRn13YBFpSywdqB3oLr4NnqpTisvbKKo8BXYXHUura9Xw7r +ngc3sODSbNX1XRUWD7Z6KUjqusyWTcZuBuhWXpoHcrdWvF192xYv8tbSZIa1A10VFgeetWCKQ9or +qzgCfBUWR6xr27vVke45cDMjLvUIpavC4sFaMAXJLf1uD66sgl1bcksOqLzNQe+wt7Z4XEdDe4q0 +w1wVFgeerV6KQ9orqzgCfBUWR6xr23vlsO45cCsTLqHmoTf2qnnsgFYyhaiVWKTWVsGOlaSlS83I +AB7IJb6uJV4+rdFNQ9mBVoXFAZ1m1VH2yiru7b4KiyPUte1d8lrgpvM3M98SpuLqDRZWhcWDrV4K +krssGvWRyirYtX6VoFVhQTbINfG+7YqxmnWDtQNdFRYHnrVgikPaK6s4AnwVFkesa9u71ZHuOXAr +4y2hnmq3PGgVlhEs4XOgtpvLyfaPavep2QW8AA1LqmPLFV+8jhg9zElJA89WL8Xh7JVV3Ot9FRZH +qWvbu+Sw7rt/C+sNt0+5zcJVYXHgYPVSiNag9aH1WuSIWZfVl1tRvvbjvtZ2tYxfh9WASoHNeANL +vRSHtVdWcRT4KiyOWt/Wd9ew7nhwM+stdh+eq8IygldJfQZgWvROscJHE6lzTeMFRY8xkgTM67Jr +CwpM3WD1QCvF4sDkClgVQbEcTLUaOgUKVPYKtb5td5o6rDse3Mp+wyHOallaMRYHRiqqCltRxskX +mpTcXpePgMqb2mzT1baYuWnmmyA1mL5fP9/BoOnY+m92+3hdw0iAApW33XJwbXtnDeuOAzez3pCI +rGWtrRTLCJazsgQMPVbGkeDYXETbSrEQOOvZO992VuvLYe1AK8UygqWSwIi1ld37W5e3nVJr13vk +8G16/29bigUaqrtlsOAcWIuogEEM4z+UWZnDauexrRzLHArsI0PZljksmqDq0HWYt9w6eLZiKg6l +1Vxx73bVWRyRrqV3KRnKXcdvdcwu4OW3UfMXtUKLB1stFSQ3N82Lkqor1DOpGeAqtCAT9Ey+a4sn +/VXbM6wd6Cq0OPBstVQc1l51xVHgK7Q4an1b65fHuuPBzay30Jy32Sq0eLDVUiGCLRdNjlFj53LR +AjhWoQUZkVe1mK3tghpm2GDtQFehxYFnK6fisFrdFUeAq9DiaHUtm3O3G8odA25lvIW2KZHysIFa +NRWkVvxave4KdqxLDavRgjwoq54ZtLbLvu6LB85uTS/7eioOaa+84gjwVVocsb5t21d+2XPgZiZc +wFRlPYVuVVpGsNRTIXp7CX4JDoZuKrgqLciHumqFU2tbnFpiWD3QqrQ48Gz1VBzWXnnFUeCrtDhq +fVvrl8e648GtjDjAXO2wlFVpGcFGQw+q61kr7FnTydjPZQG4b1vWFovlqhpn3OogK9XiwLNVVnE4 +Z6vB4t4/u3otjlbf1vrkse76fwsrDrCCjrGt1zKC3U4WlzrWa8F+abk2V68FwXHd1GuhKYfrZsTq +gVavxYGdXtexzlaDxVEwu3otjlrf1vrlse54cDMrDnWVWf0cVq/FgYNVViGCgyZQai4IdK5mvZTC +6rXQ/mIJlK6t3hHvsBpwdvVaRrBWRuhYZ6vB4iiYXb0WR61v67trWHc8uJUVR2LJUiW1XosDh7lv +8/VZkKi81WDBvjVLobR6LbRWq94x5drmqnWFvKJRtapQz5kYwFxa5f9n712XIzeOddEn4Dv0H0XY +KxZo1AV1WfolUra3z6Eth2XvrYgTOyYoDkfiFi+zORzbWk9/8susKhSAJgn0DMluTkshsZFA3bOy +8l5VpW3JwVJ1oK3ytVSdrb+tR5srnczA5425G6xyztcyhKbMKtznXs8lOVh4fEUFUPK1ME4V7rX6 +lgQAN6q1BhYz6QCaMqtUlQ5RutKCqEqG6OPCK0Tth1VqHc/AVuZrqcLwPnXVx+Kjxy1IWYhjXLwa +gZXoDwCEt4PPuSdSPFDwxVMwAXkJIp2SqjWDb+kZuTv0oNYamHpwfCDg/uBg8MkI3Od8icS465Cs +jekakWHHGMgdCzRRMXcsf+tB/LPHaq61AlYdWzNjJ4Qz6EWA5EMvFA2egwyv8kywQKsi7gUlAnzC +YJdCMxSXE5mWgJp9oVCFc2IAigYJ47he8AuZxkeYLUW0UEhTH9Ogs5M8RicMR0CWFp1yvMAILROh +sTdLViTxqfDM62U3RiOqQo/9KAnvkN0rx4V74uq1sNpeKL8AXSd5nWKRt7wraWLS1jtOFaQLCnAJ +NRWTmfG4xEsWLhSGmDqmXHamYmUhhmCLh5OT5JoyMl/uVjRFmUvTRZPPQNzpLjNDU6s5cBdT20dw +xi7ZmbEMWc+GFTHyLRIAyXxP1/xYkIHGppltwfKWYDYamlhWAO2M7CD6VHEKSnQitiJI0Zy3SRDS +GE2e894Kg1xgVtaX1j8W/0RZyGBLZKeqONrYligZjyBJm7ZPJ9pGXFfthDTTIDvt00LSSZ2wn4bZ +BZXWzMKhNGNz6zgxoaQGoSUgfikIymQtcDDwLy6hfK7fkVHbnGI2ymz7PqdRdyi3BQGNnBaZRlcR +vzSp8BiWlc3JAAjIGiCZ6RRRielXeXtxLM3x2rU64UMgFnL81Td/Cm9+f/326Pbjh5+JmN+d314D +2AH45i83138lin9HRL9pBHx0/tPFdf3i4C/v8Ua18ur7//nHP1xcUjUHvys/6Yz53Q9/PvnLzdtz +/BwcPve++Hr1m39fXV7Tq4a6dXvx48e78w84Zuj8uj0dfXH288Xl29vza7zXq9/96fquf4f/3aUj +6jeqbb+ig+wf1xdnBM7nWf3pP08vP8q3P59f/PTz3cNfX59e8cfUl/z5f27zmP518Q== + + + 9u7n2UNKXz/7iOaP59+zx/LvrR7Hr7PH8esLjOPmx/9zfnZ3dPPx+i117ejmkVnvh/WO9z99evdh +9gAHZZ59qN/86c03l+9/Pn2j5o7x4m3FGd8zJnzznzN6vC1k8u7j7Y8fib8/O587C1J05hLndp55 +VHruYK4/Xn13dnf6z/P5WFsXefaBXd98f3dxd/YIYe/H94G//vvF5YIBDso8PyU9bLu5o/vx9MP5 +H27P/+9Hwt/5dHVU6tlHiC03d4S35x8+Xs7nTPLncyjQPV1XD3R9PfWrDoHzv9fk5OHOPjDvz7wg +F9dzl+Pm/fnt6d3N7ewF6QtsNZpdXD9CMesTDt8++2i+v/l4e3b+x9vT9z9fnM0f1oJRveCuOb65 +en/z4eJuzqZ5ig4wH/Zo27/79vzd6uu9tLeNY9pLe9s5jr20t23Snv2Spb13t6ckulz+5ebiw6uS +92Yv6l7e2z55b7b+ZS/ujYa2F/f24t5e3NuLe1+euGdfobi3YEy7Ie41+rUIfEtGst0iH8lBR+f/ +PL/8/ufTtzf/+rJtX3LIsFj4ZEfMMw/px8uPj3Arn4HZ3Fbh7sPd22/P/3lxig4tkH7qQi/GE/zx +9OOHDxen10eygLvCS89em7fzyeLbl6CL8wcy/6R6+xJH1RIKsO3U7Obduw/nd0fPQdNeaNt/xyPc +oQ1/Ce4YXoJnN5c3t//1r59FjJlJn3+9nK9KTF/vN9AnjOXD+/Oz7z4+sh92jyNQ7WyUown4eHl6 ++/t/v7+5Pr+eP7Zpwecf5dJBHt9cf7g73WCQfcFnH+RsX58PH2/fnZ6df392uoSGDArtkmzSdG07 +G8u3XHhW7YKxbLf43OglY/nv2WP57xfkQf56c3F9d5KUZC+hjzz/PtGhk8Rc7BA/9DqNCRtpRrbd +prCQGdrzdi8qGS0xkmwLMTi9vbj7+er8br7JapeIwmx+9Jf5lOCXlyAE8wdi5g/EvMBAZjMivzwy +5HogaqsH8oierh6I3X6ivP2H5vMY4p9diXX319OLxwTlL/zs3B1ZebmaeFc8Rf58fvvTOWZyh5ig +pZvrNa7F03Vg7zK0KdP3Gl2G1KtzGepmD2jLlZ4L0G27VZ5fVpDI8c3N5dHt+fl/z7ZqvkbPqLcX +l6fz7bo7pcQ4nJ0b4Pb07cXH+aibP98NZe12C2jzB/J2/kDebvNAdk3E/PPN7fufby5vfvp1h0ST +PVnbIbL2aojZ/LCcLSdmrzaMbSeJWfNqfG8XxK1t+U5fFk6xzVt99kh2ba/vnMfta43Zn+35t4/Z +nw7wpWP2Z3Obuxmzv4CQb/uRNHultv5Imi/h7NiRtJNZFB5xjanI2zKP7eyqvbXYtf0+G6+Ies3G +sq2nXrNHsitBON/MNm8d/3x6fX1++f355fnZEn3atOCzD/Jvs62Rmw5yWvDFzqFvLz68vzw9O786 +v7778+n7HTqMrk6pqtmGyV2QjtpV/nc1+akGP+eOmn/NlzDy51tMKbf+9FqWa3CbT6/ZI9k13vsY +Ycx/zuRjV+jdAsza9j0yWw209Xtk9kh2hcObH4D8PIlXtmX3vVvkH/Tu4vJyif/T5Qus9GzUvbuZ +zzjdvMBATi//dfrrI0zOYCPend4u2ony/fOzg7PH9CPu5pqvaJWvnx/hZo/n7WNe/bX18uNWx8W9 +u725mk8J+OPnD2CaTcr7cZXm/8LdnznAUakXCAK6Pj+dHTFydnp59uebt/OH1xd4AQPU9ezT6fTs +7OPVx8fdouqFq4o8+9huz1lFMXt4b99e3F38c8HgSoEXEklOry+uTl8sNeyu5qFrwt4ZZssku7NX +4wwzfyS7pv3YO8Nsibp3fkazvTfMOlXC/sbC7SCAW38ovRp3mPkj2bVDaSfdYWbzn7vhDrNgn2y9 +O8wrol6vxh1m/kh2xViyd4fZu8Nsy2H0BbjDqC/FHWYBzd/20+vVuMPMH8mu8d676Q6zALO2fY+8 +GneY+SPZFQ5v29xhttr+szvePAu23FLi8UJruItZAxf4Ae5X4clW4elybuzAIjxdB16o8d1P2vjN +n958yzl73izTfM1iiHbniHq9eYvmqwF3JGvRq764elGenD1Fe5iiuT1Fe40Ubfay7inanqK9Eor2 ++1sCfNks2jmm4DXSsz2HtqdnXyY9+6IZtFdLz/b82Z6efWn0rDbqvFlmhX9lZG324L8gG95+28zZ +Nv5L3jazB7/fNl/4tvmybgv668W/zy//enn665tlwY7b6LDTtatutvekzPzfFjhQViV2ifLdnl/d +PBY+vlu5XvYpUnYjRYqaP6AdyJGyUl/rdqU6+n+7ov++pt/092t6sXptLtszieOuJ1D58B4pVOaO +cZ9A5ctLoPLMQ7u4fnv+7uL6Yr5hmSbj/PTu2wXksyqx9QlitoWHeoUXFP645LLxLffUXzKWXfHV +3ysstpccPLa3d9OutKEZZtuD5xcRui0n2mc3V+9vPhB78N3HR0jYLgfwpTHuEEE4vb24+/nq/G7+ +vtklwjBbM/jLfFrwy0uQgvkDecRnqB6IeYGBzNZy/vLIkOuBqK0eyCN2z3og9sUOz4USwrYfnZsc +N7t0hL7arIif5QzdHRPHRmu6Mw5E+wDAvTl598zJy9IUbqNWaW9OXjcre3Py3py8Nyd/HuICg7Ju +v15EaPYm5K0yIe/v4FjtTch7E/Jzi0V7E/LNy6tS9ibkvQl5b0LeWyXfXrx793H+bSbbTgoWDmdX +qMHs9HQfPt6+I+bo+2Vp/geFtteylxb3+OaaxPLr+cs2KffsQ/z1/PLy5l9zx3l58dPPd/S+OUM+ +3NnDHBfb3oWUfbQMSQdl9kq3vdJtr3R7dD++pntuhYR+/dPt+fn118SBnX9N0vLFTzdf//Pi5vL8 +7uvb87df39yeXv80e6vtijZuyXGwV8ntVXLPP7a9Sm6vknvusy3Mtrqc/vfF1ce7R66ArLEtf//s +yOZmj+n8kh4WqXyqEi+m7/n2ggWwExxoL+UR860IgyfpUN0hlH9NaqcP78/P6LS6fQ5f+Gfnumcr +a9Ik/P7f74k5WKDQmBZ8AYP+0lEuVttMC27zWu6g4o1EpmdXSe31Nnu9zece115vs8V6m6SlEb1N +UuKw+mavt9nrbfZ6m73eZq+32ettdlxvc5kUGq/ChWKvhHp6JdT3SbTdQS3Ua86f8cpCgDdQsu31 +hq8j/nefQ+NFEh1seQ6N+QPZ8hwa85OB7HNobKXj7fYfns9zscmzCyp3fz29eMwGsz8792fnPv/U +xgPZ8rNzn39q287OjeS0bT8/lx41u3J07vNOfdrcb8uxu3g99zmnlnTghRrf55zarZxT3/98+vbm +X09xf9HuUKIvPLvArvh1zk6Kto/If/YtNPtizbe/zneX+vUFkGz+QB45F+qB/HvLKcC2U7Obd+8+ +nN9hS9yev11Ep3dNBviOR/plCACbr+prlAS2ZVVe933ie9Fsl0UzZdqv5qLkz+eP+4RVaJk/f361 +tp0/pn9dvF3gjpe+fvYRNaqbPaL5TNRL8FBLRjKfr30JtvaLVGo8QRbt3eGu9kqNnVBquL1SY2tZ +4fBalBrzB7JXauyA+LtXamzvsbtXamwjJd8rNfZKjW1Vanxhotnd6QJHy9comL27PT27O738y83F +fG9tKTxzjXNLW5uQ5vrj1Xc0Bf9ckEOgLvICEejf313cnT2ieatFNXz994vLBQMclHl+T87D2Xl2 +fjz9cP6H2/P/+/H8+my+2DMq9ewDPHs6L7PnHskyrdYWxznPH8kTCjzbciq8vmRH7eHsKzTubuYf +bjcvMJTXmrfpNaU5WnCEvbu9uZq/e/jj59d0zT9m96mLHhzePnXREx1Y+9RFX0jqoidRGv394+2P +Hy+Juu2SHnGfe2Vnwt8WyEk7ouddEh+2V7WuV1G9Qv+xBWPaDf+x+ePZbu+x+ePY+45tj4Gi50ve +PJJH4HWbKe5q/uzVGClme8LsbRTTAb60jaJ95UYKbLktUInvxb29uLdz4t6SvbMX+PYC33S4e4Fv +L/DtBb4vWuCbzV++RoHvtfqlzc7osBf5tk/km714e4lvNLS9xLeX+PYS317iW9SBVyDxda9Q4lsw +pt2Q+Br1WmS+JSPZS33bI/X9r5ubtz/dns4/71+jyPcqr1hYFCO+5SESrzHjxWyRbp/x4tkJwj6N +50MD2We8+EQOI+eBeBW0eZ+/Y2vJ2LtL4u7k1u//+vHy9OyXr1cCunl/enZx9+t/LVAsfrj79XK+ +jjt9/fzezktuON/2nbVoMLu2mf4ARNyhvfQ6NaKfkqZn2xWjy2jBlvMMHziV4/FrIm9fDuOwi7cB +viaGe+mdoFu+cRYOZ1cUIrO9Tj58vH13enb+/dnpEo50UOj5bRezBXFZ3OOb6w93p4/dWldL5eNy +zz7Ef/28IFL4EjYket/MOKWrUY6Lbe86yjZahqODMrukQFdm9uY9/e+Lq48LTHPl+2dfasa1V5Nl +yM1OS3Z+SQ+LlM1ViRfjsb69YLp3kkzZL+E1QH1gGnySiNSe23sZUWn5Lba7wiLNzy2YJ+H3/35/ +c32+gI+YFtzeMzb3dTGzNC2453Z3nxXc80svzy/t2aU9uzS3D98nKryD/NLrtAa8Sv/oDdjBPYe7 +V5lvsCyntxd3P1+dL8jrvkvEYfaB+Mt8ivDLSxCE+QN5JPFNPRCzzXLSL498WQ9EbfWKPOKuUg/E +vsBAlhqatv7wfJWe0ZcXd389vXhMXbA/O/dn5/NT6i0/O+cPZMvPzvlHzv7s3FqhZvvPz6VHzf7o +fAVH5+7oofe3NG4jL/TkRGMH1uLpOrBDiPBaUxHtr8jb3VxErz777EZGkO3m2v6+OIf1rvFtO5lk +6eqUqpqdXmInCPuqTf+u+1Ugc4fMv+YTxvz5DuyvbacYf6SiHx73ONpdgsGRVH/OG3BXKMYrPJue +Nf5rW7Mv7FN8PPtWamazsdue46N5NUk+nkUR9cxj+u6LiXLdufQYr9OJb3OE235zymK2dNupA+wN +WKq/v+IEyLvojrDJuuwSrs0Oa9wVVlvNv/Z8z2w/+3Z6lXT7h3fnt3+4uN0GFcm2rPPd6Y/z13gX +FJp6NdtUxWP/n8s0loMyL5eK6+P12d92iJq8Oiw79Kt29WXg2R/3ePaCeKa+FHJ29FIuJizsIG7+ +77en1x/ezbhFYnvw/XXqQzYMYdh2VcgmHOgucNWyXFvCV+/1IWll2HPum8vLLViTbZmSzZB176u5 +pAMv1Pii65+++uZPqn3z++u35RoogDpA3vzl5vqvVAWnKWkEfHT+08V1/eLgL++5Diuvvv/16seb +y4PfHJ2+/el8pVbN6q8X17/89uAj/duuvjvoHWp++JUe/h/68X8I9K+VXf159f/973b1lqA//O2g +PWzbNoaV7g59t7o6aNRha5XrEqDR9L5TbqXtYdcZD0A0LtJ7c2ii86uzg8YcBmX1Sg== + + + 60PToow9dFZTlepQ+0BFukNnFL0gQKusRZHuMOhg6Zv2MDpF3zhqtus8A0yHZ+1diPmZivhDFbqo +yxfhUNtguVZjjVs1EUVaBYA3gXumWnzk0TWlNDWjqE8ddYEANkZLABqgjb4AUIjG4YMffOMshkwA +02kGBO+djNgoLmRoulrLjdN04jkGw/03raL1UfZQY6JVOAydjIhAVkW1Uv6wU5gEAjjTuZVyh0pb +NNShK1QIf2PkQnhHw5VvUTFKawZYFdBdtNDFFbdIhakQ90J3K+kVFZJuWgA8ht/wULRe8dBk8gjk +Y8egVnvF3+iOhk2z6nSUSoz3K574yEPCmtOa+MMYO4dqW/qERuQOnWfcYBwwdgWc0M7mMt6HFaON +yX3xdgW8Mi0KAdeAQFj51nAhxkdaAsJPLHYDfLU0aKBvq8pzyx/L76Z/mUo3ffHURFO3kfrR9B1J +XW36vqbxMJITuqfZ5kE39agxLU0/L2nqmnru0vQ2ZX7TAjT1CvAqNfUypaVs+rVMq92U5c4o0VQ4 +kfGm6REnoVbT4xbjX0w/YkhY64xV6XObK8A8cZWYDG4G88QNyzJzZ7TK3Qupw8FnbOz6jSUDNTpt +R959Tb39eIM2k13c1NuYt3pXf5WoQVPIAc++Svsh0QymK51lmBAWoTyBez4gTk1PnTL9Kt9kCtcU +Esdk0OU9IHQQeKRsQixaF0Y1mro0A1gVIKQtuyAIqhDaau4AEJnXgNonVBa871aZrKfHswNG/Rgz +ABVYzHiugMk6b43SCpN1rjJ1BZ01put7ixEZPxgRDZt2iumHjYnx/I1MDOYuAoXL3GF6g+mnlxaA +yKHOC2CZvoSMJyagGSxlp8pSEpHCavu82iCZNMQOWJYBVIjGEXi2+29cp2JCLeuF+sWQ8Q9lmK67 +HkcZjW2/yTJdT3uM22G6bgek2Rmn+h2G7RTasq+Ad7KbTN58ZjXan52cHJ2qN7F0Im10OXKpkzrT +AiUnFDYdj8zhBBlSlY6/0V1Qie7IOc2bgbdHF7gQCJjLFKzlc83z0guNk7Md694TdsYSbEomljQ0 +waOE5EYZ4SEyjneKCzE+JsIc3WpIuv2qIus1xTeJQUmYTZRZCLqVM8NbGbgBUeLWqWDmT7h7RK4H +RxM98/R649LpZXmQRMYdH2/Wy2FPy8cI2lklbRAaBjkiw0rm2soR6vxqesqOD+LxST09zMfn/Zgh +yDS7J9ljtmLMd0xZkzH3MuJuhEz7iv8Zs0hjHmrKZo05MSHOLrFqTuY0JlxEn5gu+5j4PfAYKrjC +MIKsBCx/pipMd1R5z3RJ68JwMunqap40U7dM3DL5y9QvU8ieQGYimmloprFDEixPxyNO++Tg6MeD +7Ol+9DMJIr/5xzWEhrern25P316ck1SibPwtVUNrowL+RsJzQ5+bQ+sNMKBynFero58ObHfYOiJB +ADT5oaFh0NxhYwc6WWiJCb2Org7eUfNHRyQu/MdH9M23iihUexiCNjRPgNByKBkGFpledfTSoieq +c7RULU57Tx354TSNzgsjBkGC5lkTWpoEUIeBlwMHjmGBgvBdaTlwNP2iGTKHru2inP7KgSFMR0tH +jVElLgQ5R7zXmFGayOCVcBSeBomzhiiZnCQuWCeHjemfj+mw0QZoVkDh0Kho5Agm3hCIZ2hw0jLh +fKRChJtG80lIw6CJwmljWjDo2O+gQThsTP98zGeNcbb+onOdHDUqgrzTBAD/AWiD4zLmsNNy7hFX +4IQmOBmfbh1vw8icIXYqOK5j7G3FvBBtZjrChCy0ONNot7foPtEB6rvjs0ZjIY8P8qtGPrYrKSxH +i8LO5gacMJW0X9A77gS4Wu5Wx3IWd7Phfre8+dvAXCbGhoYIwuerYoYl8hdE1uWocZrr6FrQe8x6 +p420E8GoBGzgwDvaojacNCTv8Y72HpUwShisKiMJUTQ6aoiYtCyLEgZ1OGoIpywfB4RlLL9620pD +CRMb4KZzvDMtWgbqquC7DGjxcfpZXnFhtSplUT/Op4TWPHbl6MvSA0ZktSpdZDxeVYPAQGkRqnFG +oheYB8J8mSprV9VM8Wwy6XTEWq7SbPNk21iWg1fDRJmmjFgd7eFVhVe8ohmt+kWvsErwgjHHCpbR +gcA4hSOkxy1+E1cF/RhBtaCYcQWHuS3bCdozmnNvrFqlbVA6i+5ru6r2CfaSYXxT0fFWMkae82a0 +Maz6vYjd2hYAdrNyfJAw+cgT2u930ARWPiSSAKKhI/eQkEoOGzptVj1ZYcojByZDQJoIwVeZMmGV +QWV64gXilmlbJnyJ7mUc6iljpp4ZZQtxZdpaaC8/HR8MELgT/C6lmZelBjStryAtGmgGXfBpI8km +5y7yZksKmTSCBoO0cgTzICEEaRP7eUmCkqsmquG5tLr/ZjzZQgq8rtajGS9ZM1rSZrLmzQgpmjHS +NFO8akaY14wxs5kibzPG72a8AYTualXtkWa8jZrxPmumW7EZ79ZmvJ2bwY7XUmhIE/gTUGKmGVbl +U07IimPCxXJY9G6VKXDDlMn0lKmZ0C45pn1P3Zqa/FluuaKQQoCbmoh2wjpkItuGJL1mAtzU1Dm9 +TcWbUj410dRtpH40fUdSV5u+rzKcph5PGnJTj5lnpemnJU1dU89dmt+mn+D6DMxL0B+TJqbpq85S +1fVnfjluC0pUZ3LBm6ZHnIRaTY9bCf+aGgFp6viU5c+TZkjRXk2o2CXtkWsH3IZ0xqph97qKZynb +qqn3Vdp7Tb35jEmQwQZuqh2c9nj/DaiAt4kNw8JnUlHxaoWeFIaukJxmQpcqxrAQr/6rTN8Kf8kI +4pOqIlNBYFFoK05VMK1wsUBGEyHI9/RcMFarnh0WtLYqscsjdvr44A8kIXxbc9kOynpqgVgGx4/U +rFcmq0lCx/jsYtbUakiRTLRJiDIJ1ormnaSJxACPZidBmGzjONDVV1iNLso4/XgJfSHCgoPVN15r +IQ8uJISXDSP7JNNUSCHcmHWYeIK03ou2uxUlIM0LK9z4h3NpNxA/pNPnQaUKOqkg6MSxdyrkhtPu +IxwWzSvmRPR6nrHbQ0OZNb+djTKnXvu0aQlBtMy8ZT1GJ7wr1iXYHpAJGH7371LxvnRqo24idaTv +R+pq6WkaTj2aNOYy5DwtZVby3NVTh3eiE0jzi9IdH4ZpCUzh4cs6pdXkxdSy+Xm9xyhRYUTCmvxF +xqsJ8lW4xxjqTf9NxuGMwhnPKzTHpHaB65W9gGknAXqlXcUvMdvdvxgXQr2QePt6qeWgkpKgZeWm +7/rOixJCV30Xhb8SCBHV0fAn8zOawMEEq7TKgzUYL9N4HadLPcaGMbpMMWqEc4yToaDkFGt5+mjQ +GbFHiF/tifF+ySXLjuLKXai3XWq+bM3h5vWr4QbX0p8hEZjQCZ4d72pikidSdo/RqzzThShx/XZA +uXi90qEvC4b1NKYQQNFK+4pGAiOc7r8AxviuIr5Fh1GQirGOT5YEyliZaXrG24ruZ9Quh0NG+6be +EA3viMHjycG7g//4x8E/WFn1w9sDt/rNb1c//K8p4Ks3avXNe/rT0kH11Zuyylf9w3iZB6tcodAZ +ioywbISDIyTlEiNEHiP6eCugzGS7jLfTaMNxGXQhSI+C4x6yBhwd9hOagRJjunIPLcKnNZ2aErEx +oeMSow40o/5NCDcXmpL3yQGwZrqmR8nksFm3MtNTa3KsrcGANQfk+ATNOCafTw7f6fk8PsWl4PS0 +nzAEY64hd3DEXUw5kAmfkqd/zM9MeZ4xZyQlZXWbsrx5+Zu8/hOuj8tNucOaeRxsed5MFXmY0I4J +fUEJ9KNIU9QPdFSlfjo3pZZp+41o6oTqjikzFxvP8mQhxocAD2l8UIwPkvFZk4jK6EQaH1k1Dl5D +j//NNWK/iCLCE4coItxxWIaBNo/kFG/pRL8Skdmg84ddEAN+hN8A/B6cgWkDAAOc6IjMq2RFJ1kM +5hJ36EmqDfwNFQlQPnSys1RrOxLnY2tN8kZQuoWaK9rOiOimYFqLUC+2ImoqSFF0FEECSeIhG01E +M0YyDsnCFmKJh8TKmgARGzGsEIwYdFpYDmimuhYLDAMUbA1U2rgILXM8tIqfo4JhkA4/GmDoGGex +qxQ+EfV8xzIylzFaSJ/yHftX5CloMAcd9H80BZjIJs8CT4JjwTzNAgxZLMrRGDstKioMiZGhwwYE +oBPNEg/oWMoE4Wp123HnxLzA1i0DLVAHCZfZXs8mIRKnoyAipD4tClL5IsLqDSnbJi2Rsq0T0xlr +2lg8D5gDFDXijxF5U6B6eEBwg7zduAcs01OfSBbGNypqsUtbg9knTsO0Is4SfosatLPJjYGEWMM6 +IK8FaZjrjMRHdF4qaWPn2eqWyAY15ID/nlYXEwiAyspQVglkADsBRFEhJBDtXZ2/0fCkAUa3ziUU +14bdDRx7xPAuwMaisWarv+AGbR2V6KFOFn1C7S6JnNQOENSgZSHh3sFDpyJt5jB6EXfwnXJMrfJ3 +qMsmzRWjXlM3aFot3jbUKxuFPWNxHd3mOcv9BqaSMKTrsTWTCYAME5Xrp6hZM48NDLRtqly+ovXQ +rFXAevDejLwb0r5uk2dZC/OmLHUiJUQhu7T2rUl4Hk0i16BIIs/J2UKlTHa0kdZZuy2I7geY2AzR +1YWE7EZYCB2TVUmUQ/hhpYvA9qDS18mfqNo71uZWpFlQKhSjrsTUNRdl1NYGgagQk4GwS5uupeM+ +y9ECo0WFOZXHyMpwUATRCybSyVRDG5uag3WqkNcB7cn0l2l0UxPpRMibQskzrW8Ksc8HQpNPBPEA +Y28pxsWMw5aVQyYTb+AwEZA26S34ffU61YAKXHKaGpw7Z7A7rzM2+9+iGQXCoGE+dv5QQ2en2JfF +TI3N8CpwfDJaiCxwinOENlEQ36ogpmdCa9pXKzrmCYVp8/1wBQnUsFbI0okbsPTrSjoDPwe/CvQt +4S7tzKOzTRs9mtuoAY2khQ5aW9beUZvJUP4POt9/983t3cBnHNKOeBDDvXd1Bp/9j9dvVx9+Pn1/ +vrpix+j/pK++pv8O9NAndyQ9rWERhMVczCSAS1zKJggbvJRREE52MavAMtRiZoFKbcIuULENGAYW +QBezDKnUQqaBericbaBCmzAOXGwx68ALtpx5+OrNRuzDV282YiAgZy9nIWhoGzIRhPybshEs52/C +SFDBzVgJ1hNsxExgj2/ETqDgBgyFFNuApUDBjZgKFNyIrUi6gw0YC2lyOWsh5TZhLuSAWcJeiN5m +OYMBMfhTj8okRq9otlxSN66tkj+O+QwtITYSHHNvuAxN6eq729Prn86XB8zQgUQIb9inQRN15ZgZ +nIvQ01lxhDph46V1HXtW0cpFBgVMJnvZ8N8TNljx2/z1iQQ2YK/nOk/E8A8TtLTMdWlHR5BDPoDy +nqMSpGu5mlac3nM9ubWmai53pql7lV43dedTNaV/J3kmBMG5gyc0RaVrJwe5O6WDJw== + + + B8NqWnRh2Boqlq7kLgEw7fia8a2Zhnqa8uvqbaqjryJ1oW8mdYH/dLHqrXSpHlI/MXle+mlpihdl +PzsTRJrlEqoDXELbSDwGnDS1Z2f6doVdqKGtHbPpJsJ1VwBNfiBOt4N1vzPwCYXD/dQjlM5t4oRa +WO7BoLVEGBS8hql1RSwbXgXrwdm18OELgZ1GiVGkkcMhlDEBpmXaIUSq5LTmg6AFlolzgZwFfHxh +3ohVEEUmk9yTAyKYAY7XQBf2guUFUGyCB0PPjrRQ5zEZI1of6JwSkGfmBOQfOk5eSeKg5KThHyes +rPFOFIKeDgcBBcfq2FQp4wQxFcL2ccuMONybJvePsUuOiTSIkwMel+aDXUbKH/HomzwfjKE8R231 +un+b6xhUwe2UZnJf+q7IxHSrvr88Kh1W1aDSvFQj52lZ8Z/QVXOYZ6mf6DxJ/WLIHFULxr3itlNH ++zVl5xXLTHha9zzeHjnaVZ6Xk4Nm8DpBZDq4CtvJZirNQHogyKArjDrNpLvNdEjNdNwFZXrUafLb +fgKbXEc/y03GnX4pBJMJSfv1aiZr2kzXvZkiR1PjTrMGt5o1KNhMEbVZg87NGqxv1myOZs0eatZs +tWa4I1P3Bhu3zH61vX29kE2PVM2UVDQZryqC0qyhOxVdOsleNQTyOMctHIY6+byL0aWDL4nMJInC +U0E66XjMXqwWMtUyh/mHzGGy5Mj3MtXRMqOZqpUV4cZK84D1Rzu/q1+lflQ15Ib6dnIv6t7Iy7rP +qYbcqZN+BuAD1fIc0laUs7y8SDNTl5Z5mbQw6IVQIrzTse9pbrsfzXTIuhzg43laM53TSV+zNIMF +1LEaTdNPxhpsEEzp/25oGvfZLD4ZKsEmE8L2ruGssSpkNLUsow/nn0CTRfrqzXQp0TEeD7H8UwwQ +AXCEKWKJHDe3Bu/EaDxET0gWEywWYWoyH3krVK+b4fspDlRtNnWjazChH0czHMh021eT0wznrkmT +t/b1GswqS1UhYL+kg96tG8faEa+dnDJ315VE1YWpddIcQinTsjATU3AAgnpjPgw4SNmQxKpanWg8 +O4d2iAtshY4pMezSG6VVkW8UH3ZiUZUDw2uNoHHRxZ3AY1N0gBqo7HEOwk2VdYmW9TBFYYHoJcRS +nDFnxEKsT8pJVl6JUgPw4owJ5hY/2A2I+9egg1CiCb+P/jV9BxXCpiCsQ8npWJiD6Vni87Votph/ +EqM7fiA64+Qgv2RLNQK9mKi0jgOxU6VgkBxr9MrUnBzk7sgEevQLs8oa1zzNYJI6q6ME+vBiEPWD +aj4psHnJhDBhLUVowwesneo/gMLVxNbV9TR5EavmmjW9KrNUdb5MUzXGZs1UlImqZqy8lgImw8bz +L82B8ajwaLCaboiUTZ6/CnebGnljdrLucbxsgZOHLSQ6GGMDW0gUMSFURLHDs5qKXnBTVtAJGmjQ +oTm2cLLm8FawMiAKJIjRQDTNR9Au+bH/cIWDjTrruIQXvfqaor47jFDYBtOSWAn15NHZxq0ezW1V +R/GGDhpNIWC0NpI8ZuToKU3SgQ1pjZDuEbURg8aI3ohxZERxpPiI5gA4oToE3ITuMJleSnnYjWRM +e5i2j6kPAaf4z8AxBWKjwZgGsXZ/vPX4CBrToa/erKFE0NdPdj208RNqBF37hB7Ba2hCkeR8LDSJ +Nd8TqsT+SRO6xMruCWXihVvTy3XUSQ7yMX0SDfN0mtbRKFEqj6mUQKfrtI5SVXha0aoKpStqVWF/ +M0T/KcWqN9PkiI+fX2lKeLr64+35+fUnJRkKOcsQMSm2QBDuHzg4yB66jgffGssJAjj2U5IMxWAk +grxNhkZlO/YKNyGIT5+D5QVesUYKUe1dqyW0PyA7AUl+nUvBmK7KMsSPkmTIIdNKek9bWFlx5iQu +jHeqNkrxJieKYHKOISWB7FqMFgofidO2tsMcQww4S4ERo29c1ByexpSGLRgp/NwSNqcMKiF1Pngn +qSIUe3bC6Bgl5sfQPxyfJh5sAHVs1PNUcStJhjwSYyAbQDCyBayDZRJ/g8lJhoL4PMs5wKUlVUBn +Qsp24cVh1hidHc1M17IPn+J4I+mnX0m/2VRAGM3JABDKnjweIncYJseUdwNZU2BxUkocQ0PH4Wna +wBNTEt4YLBrRXxetWGYCrEQOYbDJT1EhnJkxoiQmQr8ZaZJDp0U+AKCV12LAs0g4AMzTJqQcQw7e +okBOnWJxgmfbR9sGU55zjqHgxbaSXqbSTV88NdHUbaR+NH1HpKdN39U0GkbwrtVprnnITT1mnpWm +n5Y0dU09d2l+m36C0wo01RLwKjX1MqWVbMpSprVuymJnhGgqjMhY0/RokxCr6TErYZ/8CDrhrO9U +ykgUkqNnZ3xIiKgzquOwloYzrqs2JQRIkYHor1lVA+BtpdMw077ivSd5B8rmo+0pTvnDPdzUm5g3 ++uArpgXJKsbxbUwwdF6NzqYMQ8oa6RWRFbtKZCeZ8lydYCgTpky48heZsjWFtAE7TPQJXzot6YW8 +MjmVToiCZS5F51kkWGJcVFYl7HQxpRci5jImHO4k/UrkDE2JYNf5hUJKMERTH1SBoA7JDZTqQEMc +INs3xDQ9599Bb9BfJlKpv4zxMe8BpukYuE4pzHjgjtktl2emzy+Upg5zK0l+GIDJd7FMvmbKYnNy +B7aV8yr6soqs0DUpVYPDvq1zCznZyBLoEQffuJj9nTtrhOrlqRfMk90UK0oJBDarmpQa2ZyM5EqS +uRA9DwOS7Dv+JhNtbKQ42FGyj/KuS4dBvzEloNlbW+9e6UM+ZVRIx06XN5WkbimUwjCdHVITyZDH +2Mn0ZpU3gWwLNr5jpT2aAd0KEmAemAlj0ua9nOcune8xlwlAC6aRSg5JznEhVDSuMo4JqWXOXfDQ +JnosntwVxQ6rippXhF4RGRFSHgSntU9sSRCUboOM27bsKk/tO1+YEu6gkfgveKzLGJRMb3C0x3iU +lmeX8yryNHRpqiznwTEtkzeZSzkaW57aCBLDMy3JCEen6+j8HZ/P0yN8fMqP2YAhp6AFGwfMxJjb +mDIkY55lzNRM+Z5MnjN1zsQ5U90pezXmwMYsmmCfSeioJbmQspIDiokC24FtZgxLcqFEUpjktCE9 +M0USvpMJEhOtlNBA6HAma4mqZbKXqV6mjD1hzMQz085MXEfUNz0ejxnsOZbkGESdYbVnD5COkM5x +6iD4ccV12YU0EmMlS3J+gBaCpBtIl0F3JI8Eor0TWzKxlSFy5iD623H+CpopsRhDjMQPwmHrYV6m +FYHrTgv/SzoVJ9mFWIJYm89OcgIwkki2Jrtqco6xY85nZ2JOLhic5LPrSj47k/LZpaNCcayd5LNL +4f8IundVUoRohjmG+PlYEtrl1H+GcwxpkSA1564KKaNdyTtoJA5QImE4/5VJCe1y/rphiiE8H6d0 +dqb+os5m51I2O7sqjmfHKZ2dDNlzCryU6Svls5NkYCVjZIowrbPZ+ZTNTq9SAshxMrsoCYYUJ7yU +1GN+lcumZHYx5TVbpbSoKdqiVTlzqs65xswq5bIrudNSkkjJf8PZ1YpHluZMdum00T5nDwsp0aNJ +wanaOldFHnMmO5My2cWUyU6lTHZBpTKcFlBSxQXpS1Qpk50No0x2PG+CiRxnJc6qw1R2uk9ldzxI +Zdfqkmy3lKzzn0rlnMvOrUr7KWlZ6SDnstOragycyy6s+lGWVHYp/tqDwea0axL1W6ey83GUy86O +ctml9EK8Yoxkq4JQjGFWVtytyoJX6GRVSGnsOsEuG0Zp7KIgouBSQruMSVUWO1Vy2B0Pc9i1YZVR +n3vpY0pil8fhZUM5K8HZTBckiV1cVTswBWunDThIYZcy2HWrvIPzVPZ7PKcWzWSAU9h1OaVx18eP +F1JSZRpiyAnnteN0UAnCBKrNmZRjoWE9CctkLlO5TAczGcyksqeUmZpmYrousZ2kG/KSBwDvhymj +jR+mjPY5c57rJDy/6oN31c5KnZRsqRIbnMYhKVUlHQ8PVZKuWlXmos43lCaQk7fy6PI340VIWS5D +tU7NeClHeaOzOFjhQjNClmaMTIlsxQrfmjFKNmOcbcZI3Yyxvhntima6b5rx1mpGW68Zb81mvHeb +4dZupnu/GZAHL6dSlQqzpIsWEgNPkeOcLloxFXI5MBjOrYlKNVM6Joe170ldM6aFg3TRsGwc53TR +PUVtRhS3qYhxMybUTYXJuXidLjq3kXG578ggXXQX+vE09YDSmJtq0DwrTT8taeqaeu7S/Db9BA/O +Q2/6dWrqharP1a4/+Juy2Akd+rO5GR3fq4JSTY9Tw1TRMSGrMzaJprpLxdndmzNF+9RGlShadkXS +ClQ98zZUXEuTiXdT76a045p6y0mfxtu2qfZt2tn9N2nvF06sEIiKWxtniQ6rQmiaCTWqWMNCsvqv +MlUrHGYhfRUbKomiXc+qpkTROSc4t8KJojP+B0ESDiE3PV+cEkXbVTMi5k2m5vtMQ/tMQ/tMQ/tM +Q/tMQ3qfaWifaWiMpPtMQ/tMQ/tMQ/tMQ9uSaQghktmhd+DS28HOAgbfKY/sBlc9DAGfokXigE+W +R2AykSgLEq1YoNEss4n1nzBIhN0QtCi2OeEtpJCgQ7K4y91fsTMq+4MI5tEpwml1ewdupJjl9PI4 +V/iWmwCLf3HVcByMz2kGnCyk0jqlfc4B3XIbAMJzTbkISXO6fJiQWpciQdq0NopFZESkaCWaFpbb +xUuBjZhGzBhY/xSZRiuRnRVSsLnt057YnMq+S33C53x+IpwlJ8/vxEcsHLJfnDjxpLQCkepKSh+V +UJyjg1ls7dLs8CqJj4JKRu4utCng2qRrCqBKYIgEcWeIOCfFNiXIla/iYUx2hWxgCIfRxxSnHKJO +flBRmUQ/LW9AGpPEF2FZXbDCG7sUGc0QdrjiKay+oblJKXRl1yMxQ6pYdZKhChbBNmWlsHwdksG2 +STb5jv1MaEqseEjApifrxhHaYuLxfNNEK6Hx4q7KJpiWL4FxqofAU4Gka0bHBNKsbtF9RQY45XJj +hi14WY5OHbIw9FrX97njOHNdD8ylsO0yeJfdI/P8QOOj0oUVaQo9a9tNDwqgHWniebwcw5lSMeQh +tUw4ezIJXJCWsO4ts4PWOtMD2K7q861m+ZuUkKBjLoamoWsHaEggzbYSgBQzLUYlXyNOYwxA3qDQ +VIkeXuuQmwmsVGQDAgARWjGV8mBLymgrXasSRncpxX8KbJfEFlW26CAmX9EV5S9avtdjJa4VkuW/ +y+m/5ToZI56amn1bJMm/Su5kTK5c0t8XABt+kydIAiFFNKdvBolHkoec6J8BIJrAna7N1r8WB4th ++pZGl/L9M1HK+fjPOOG/OC5VGf+VuEquyQ99dtAMkqanpP/WVzWM8lBLxiF0xWSzowuSE90nDxzu +7CjnNY+omQybs2erZPMUYo/pG8wVkxWtM6mRrwIMaZ3vlwE5vX2XpovxXMgYJ8CQ1Q== + + + FH28adNdgbpL4n8I+VkIpjGm/kCoO2OUL/n/a6wrF5kwqrKDMWseU1oLTucyyoqe8j2xl7wo1utL +AMSDLeVXT8nXyw9xsyzJ16t7AJxoSquLANL1fsxsnR0MOpPSsaPDWjpc3wWwKknmzw4q1jJfw6Kn +2epTInVOre5Vbo5WRknme5fIlfWyyLSMiXQLj0Do4tPwdPaE71OkJyzLd6IUjC8Z+8/SrQA8+cNr +AYDiSlzWy0UBbcvk4eygB5l8viEXSAfPAhzirewEub3hUDgi0ZS1lkPYY2ZkCt8UoEO3qykn9VAO +rTb5S0zj8GkdYbaWOHwkz1EcTRH4FgI4T9DphdAP5yXHyuhD3SlOsJO/PDqbWeXRvVUStYMTqKmq +LGEcayI3pgxlBV3GUiaRazlTKTLUJmylNLkJYyklN2Etkxi7mLlMYtsG7CVKbsRgSkzEBiymhFhs +wmSyQmEjNpMDQ5YzmimAczmriTFuyGwivdRydhOhpBswnF+92YjlhES9AdPJcUXL2U6OUVrKeFKh +DVhPKbWU+eQOLmQ/WVe3jAFFsNUGLCjWeAMmFBi1nA0F9i5kRDkr2gasKCuONmFGmRhsxI4yAdqI +IU0B4stYUiGxS5lSoeibsKVyimzCmEoo3CasqZzPGzCnkp5sE/ZUmtyEQU3pNZezqJJ1YDmTKvzS +cjZVym3CqI4UhbFE/n8HW5VkqsxDvxJzmgQjOYlF81ruTAx8rmsjRLTwcdRVJrUNOCuERqLvwgTB +g1k8ksUPt+U7Unk4GIvkgEQuP/F3FB5K52v0Elmo5hzYYcWj37S4xhf7jt0dDPafaFWHAzrehE+n +g1epdIUqsSeyaxBQDedapJTVEdWnIG1ucPyt0/1nR2ezazy6v0aDiSdaVFd7P6u+ZmWTennJ2nKe +iQ1Wl21wy9eXim2ywg8gOLPaqmKsrzhtQ6sq7puImjDhiT9HHkg1ZOJ1yXlpEKUld5aGFA8c2RVT +5wvWwO1ELc6zifBqMZ4AILlJicdzckMpSyhC8SVao78CjsPSq1sHmZAyve0G9La/rG1wQWdFt5mq +dwPyTr+YYWQQlgMADkSHsIHV5+Bml7wJnecrKOlblby8mWFmwcQkSwjEvMl8byQnewRNJFHVHXI+ +FBJUDWJdgP+2lQ4hjXSQTg4/5c2Xvzo6m1vf0X31GSe+mYNK7997a5BOIvWXop2kEl6MeLyNlqIe +U4flyCfZaRajH0/ScgTkYstR8AECUdQEyDAG/cRVn3ArcDC5sJSsbvCJKGWlBAc8dVk/ZuFI0UEl +0GVmUgFgO5/i+SI4YAwTKTnE3wpcNA2JE1LwM0ZOZVRumBmWfCllbojFgp6pYcYnMKtpev4opiza +Z/2NlMMLKYNbDdis0K2GmsIWugB2s5RqOauTPkwyKFFmRMVAmsIAxReMs1Ej5W+WW62IhJybYzLZ +G1EHaqSLLsoehX6CBWniQqGgwZWlGooZRKPgfPaQFM34YyS8RCql/lsklp9d8dG9FSsfJf3woOaH +VGoT/KuyXC3AQCm1GAel2FIszI0txENh8JdiYiq1DBdlZpdi40OEgum0k6T0RrFDLOgivAehezMu +u08jLsVlzSDuKuBAlggJWlwfNZN/OlM4cgtkE068OA+yNrG/YNhlowTrv4AGLE9yZ6IkvmBtASe7 +lgDEkOIroPcIEuEowgsBJL4CYmtQq8mQNtyODv7tvA9oJtlZnraB4YHTRovwdueERpypv5t8Go18 +0X/Le3FWrUf31uqVTMig1gf24XR5Bbh0gUXiXrzEubGFiyzFFi/zWjxH3iba+vdmbvpsmWQ+/HJ+ +91sJC5XUm98dIBCaCBtLspZocGRZOCLguqSXOZ2fn1s7BBLSnHgkh+UznSilp4Uz0IkmCVs7RIzA +pOJF4dQ6bwuAGXhmQDKEc01qHBsZwrUSz5ZrpWdOhJ7aPcYpwXncO3bMlEzea0DD7p4wnn7LYf5Q +lbDu3nDEa4Zo0eKDZ4qSrFqie1jn1ZVnjvrn+4vLF35Ugx+2ITF5WiK5eMZOegj0Z5pbkTvfvXyR +W83PIl2gX+ULO6rBDts4nowVc2BY9NPV+Ask9Z4KKev68RIvKO/L+B0yP7S2QNyoBjdqA/6uAunH +XyCp97nOPLrcaj/+3K8MMaMazKiN48lYMf5m3LmrCpT636AzYOjzAJvpHDToTlehSTOex2bcvITn +jeahGQ+jVJzH2UynonSwfDOezmY848fTkfN0MB4OZiND8jAYM301GYyag7kQ1AzVJ3ZUhx20Ikc2 +INVEZEgeQa60jDG1W01D7lr/iR/V4QetHE/Gm3yjEQbEFhOoSixJUFecqLG1oqTJuRFxm4fcRcFi +oWQK5ZTHtIxWrFwFguHg3nNxsxAYcXuRrycvNeEWHwVVfEh3WDQe9owYJGTHMUtJL50Jkm7YtMNH +zrKheliDdjziqXR6cOkN8E/j3qkWvOEJP+mUqq/UY9JrtJN/M+KKGdBUpQ9DF7ANSfyEjthCKcW+ +vVE5xuPhlB6D+lSdv4I3kgoy9jyeltlL5bmU4zsZEIXHORhRsWdzoIqcntUkUbrlIPSqd8cHVe9P +DmRsrkCqcVcTQoWqyTo5qOcx11B6Wg8EA0vHLizlkbOoEX4xH3yFidLs3ou0FTodTsgkg4QfYK1Y +rgaus246AVoOR7VdKXUsSZmTyUgb3jSILdNsA+1we4BZ9QCHlBF+1Rfykk4vhV+wP0CyrHAq5wjj +GqEEUhRxRnYxSBeAl6QuucxxNVZkywyS1TvQWc75B2jHsQtED4H3AatdJnN0nM5m3GQlMX8O+gcj +Ce1oz0tUEYNw44MVoQaHPfLLVCCLDBHRid9WBkKg4VybpS5VQuFygxnCrluWUwf3X1ni/XChU19T +gVQNFljpV6kp9308vrMcmbGWCdT9tS7mr6d3d+e317//9/ub27u///o+3enSrn53dHNzOfzm+vTH +y/M/frx4e/5BvlLTiv5G3OOHu9tTtNdXR4hHSGChRGuF/7ZGlOa/+9v56eWfT+9uL/5N3w2qit9f +Xpydf392enlx/dMfby/e/r/nv1Y3zizhYj9eXp7frZrV0enZL/86vX0rGREX3iOjOOK+SymXNeJK ++Zn92FcZlJ5sDh7EGZXS1XarUrAZft4om36BuUo/efdUHw1rKOUkCGvFrQx6Mvgyd/64H8f860tW +8GBokauIJouoJu64mibPpbMSLgUs2uUHJK6FKrbVJBURgn/uS0tkslasC0550jDgleTq5LxSZZLy +FK3yu1xGXmlTJqekJpaXTVWmkY95cful7dtr6o6kZS2LusoXGIgTCmOS/Eo5jvk3/9c/pdbsKjXG +omGXvkgfJK58JRJAepG/lKIg86nDpf7SSOrF8UHpzoaRXVzVVfpVmhCwLjZu/LzMWVJXach1Z5LF +lvt7WX73w87vmlRn+olPy/tSJH17Vvp3ORKpnS3hGP+RIjKKqLv6ifOSiO+ILBhHjeAp3ZyhOJZF +vELkDi8Ak/FbADl3At+7ZVM2bH7I5fOPvgg3kx6PcyfSs9z+ovoPRtX1TXGIY+7EycG4i7maRljX +PM58cCKVhWU7M5/TfGEj/iILC7/S+fZpsHg6p5DnD3WKkI+xlC3PWaHO4TIqX3MiT/nbvpBa5RYa +bk8JkGXddIMhNz5oOo1dpvsBTRlxESTNc37w2DIh6ky35vbUdCNUm5zFOPee5XwPq/SGNVmm43UL +2hiJ3//hqhQFN9+lbJgPFXVRLrc8Otu41aPlrULJjkTFveZtPQV4OF84bSDQhG/FlavfN9lDMu8c +Sac8d+9kBXHaPdXj3P1TulN2EF8zOnMPsb2t30XV42P7SO7Wa3ta06WJSgRTFYL54BbL05c2mfip +ztpm2dsmlr4v2WqJtKqc/vzh7ZbHc3L/sAmn1BjKtn/bE9j1xFWvhoBERMAP2MDewXIZgWE/h8Pk +0+M5jQrET8XGmbb8gqV5+I4L+1gK13VDwZhpaNWTukep4w86scDiwde/gdjAwxG5C++lNZovP+bE +riye1rsW9m0j2RErEsNRmYecVXZdCaIsxKTEmrLMbONodhst572r6cin3i35j8Lrfxxy641KF2mq +Q+nDFa0p7opmj+bOB4eNnkGK3aTzRVaDcveeENrwornQItNhOiJIooXu/qEjAoxHl7IPs9dh/yoo +G8ULl8i1Ep/10QpaaHPiY4W7Ti5IHR4TC1s+2qRlzCRCcaujArw8EQdI3S1J+CSvevxoW888vAte +d8zVU9MdIKpPGkn8vQMzz6G7snbKdvT5VQFBAWh9l+4v4bugFS/tqERmsD19I3mPIEgoviyMb4Eu +BeU9FImKNRWTEmtBD4nVv+HLW2nA7rer331PEu31T6vfHB19c3b28epvN3csEldYPTk65URY03MJ +7S5977/pe7+mXCbCa3r6u/p59bu/3Nz97fzs5vYtYb4I/2I57GyX/LlsUPB/0RNx/fibP/0x7ZW/ +v7u5vZJXaZS0ud/e/Hj+5ps/xTfUie/vfr08f9M3LV8tnLXq8AgPGbqeX8exsVLi25t/bXBFw5ep +jjCcA9cE20VW2emutXy5j4I/kgtTomw5B6de5SS4/ACTs0eqFBiyjRWPib1uYq+b2DrdhHeJRU5p +IgbS12dnmjUzcjVf3LHSL/8a8syduAsmnpnLfn6WGdyJUXAkykyz9TjzHmKajUc6RXUPRwuPKxXG +PBe2xn1FvBVnjyHbPKuVo/mtkADORoDPxzivYZedeJ2k7MpsREopKzPspIbh0jGdLgGWcIt1oFKS +G0iRpAlUoilwEXfr8iW+w348xn/7oDoiwCthvxVnTXyA/WbPOcM+D1pIeM/FeiSdbNnlD7bHbsR8 +w/MdJ8SDRVWIfAP32cZtHi1uE8eU0Z+f6TY5sRFS38C2fVWBaKlleSpQm0C2XDJWQBCr5EqZAqqX +vzU+X1dP4pSpP4ORN90b1sPQ6AOwbgpLQziZjiqfbn2v+X7jTm4R1qW8l4/r/pR24Js4BNWj87h3 +nm+V1EoPvqpmagoqTa4BPSxtJDRpP0XamHTtagAsPeFI3MksDaBlbBI2p8fANXPFgZvj2VrTqU8T +ZRrQCNVFGyQQlnoHEdK5J5FmFq1Kdc77VyLN/OHmdm9h3VtY91LMXorZW1j3Fta9hXVvYd1bWPcW +1r2FdTctrBN76tXB1HjarDGxrjHEPquNtZO7Oe61sYLr1Y+V7YgIQRJdYmKdNHy0QcNPZGFt1phY +a3tqs8beeq+NtVlnZJ2aJmvT5bTIetjTm1nXdZ5zQlVm1jWDWVfw82gnuoAbLNXe1vqk2omT83d3 +e1vr3ta611LstRR7W+ve1vqEtlZc78N5jK4OWrkEUHIOkjyi2HSUYdnaesKsWIrwHYOysbUquAbU +V1+1/7mNqwqBdwiFjVoIdG+sRCCkeAgaSS80tK0igA13dj9UlNAP5qWRcXVJm0eL2w== + + + xLFkLTHNn5ndbvlWR2iU2ORpNONChmXT2UkFy6ZMwLoJDDcderMWlA2eVcEa1N4Lysa2CpQ7K1jE +QbjtoJf9B/nuwdxXtue1kcmkli3W1n3K7ytQ3wFkp/VmHWQwV92a+Ru3vx72oFjxOaSKaedYqpiO +ogf2g62KrwX24xALa5ndut36o3VTtamo0mRagMRmjrA+wA71BCLKhhLKq7Gf/u3ip5/3IspeRNmL +KHsRZS+i7EWUpxRR5PrQLEekEBnd1dJGAVUySS64DtRLIOzvaUQAya9r+WTY+DMKKVoGdJ+QgvQ6 +nXm4qAopjclsKWXS6NgD9PFGn0pKYffKtHZJSGETj9V57fh1LRUIpOdSM6SXL9h3bwTBknd2HagS +aHLBIai9D9RztpNhFDtFrrEWThKoLq4Ocw6WCWww0m4ydob0nDeXMjbP3rDxtaAnF0wmA85RZeMh +V9BaCJkOu4fVIkc99KrVoegymft7hZIvXhr4x/u9KLAXBfaiwF4U2IsCe1Hg6USBzIYzt+9sDgxj +EDIW6z5uC754PUiiOqxcnW1bHVYpCkzVn2VBYQ0kNXgy7cNTBoXx/T0DHpsGJtw5EquviQkLD5dE +SJjS/oGYsMeanIaEPdIkjic9SFn/ecSBEqgjaTKKQOBxiBBAFjBzbz0kc+frIN0YwpF/adlFHFgH +KuUqUK68ybxoBcoBaBVoOpoiFwxe5WCwHJFUtd03NAWVWKYyH1NIKcZ119VMe3AP8EEBgSiuVcT2 +fJKAMB7k1QBYhWxNB1rBytBSaNcAsnZkKVpsOOVr+vMpXlaN5LPQzktiV0V9ZYdt/xQWjEXL8Zpk +lrs7GgiRqNV3t6fXP51vFALmCTFwrQd8pNNB5IkdQib8DGoCnaDa6hWS6FpciZUBLdKl5oemvM4V +NKWG3EqBHB8wyFegkwMup3vIpOa63XGnUuFcNlffNzgZ6r3nnQpOuB1ozFzhdtque/DAa3Q8dAoX +jirf0ZHBhwK/wz1JrVdy7RAdBcS6qbYb8T1Imy/XBz5cGh7PSJ8+iqVY2PbRRm23uEdX2/ERqH1r +A59qUbc4PJW31ma1msEPUB8rFxeQUCa3+eFQ5DxEBRVM5oZwUQzft5JBtNwm4YLly3czoKWlzb/z +u1w6Fy7IkJ5rZDCFH+JSXQ9qxtU2dZvNpEelgtLpCu9Ly5PBlhRK1YbIPGG9b6puBr4GMcOa4FJP +AqEspwPIEOloesBbvmkq11AqqHbGqJd9u+NC41rrJicdmvR5Mtjj6fjvEy97l+JRt/kInQxuMvy6 +p1SgfzypH/vJnE74ZFmO6+5UA/jqzZpREXBc46TRYR+HXRwPaDzi8dodV92oezGZv3uBtRjcmfUy +fj55nOO7o5A1vkW+ctrLFikVxDCR3uaXJ5PP7yXKUScJNJhoVyVswVLVa2LbOKu7Vx1fS6NwEZKv +eXrixw8NAn2CJo4/dgMZlNbFG7mq5OGypk2XdxM5XNzg0QYN4tYsvhZyRH8/UT1GbBrfa25Sknxa +MnOYYotO8tv88mTyeSZgzgm8O+Qs+VcZkJ6JhHRVrcOP1wCePiZh0mHaJ1UXywelS5MiX0AoQmfX +7/fPdeGRcLH6E7lYYieMwmU7mYHtTMATyDm/CUQjNbw/M0B41/TQlNe5bIPCuVo80AFVPQmzmj+c +VFM3Mu5B1buq28eDQTzKmhIN5LvGE2tqiAFzD0fd4ZYP3NYMdbt1Ogw5PAQNBycRWLhvcxjjaz0B ++Y6thwtHkKdJLN6ylo82arn1RS/4ORnTsuIdm3fA4Plg0jMtrE6rLlf7ZkBigbSsurzLRblkWelO +DC+D58SJlo+bcVVN3U4z6UUz7GUzHMTxaFCF++yRWyxZQ0DiO+WKDce98qndeKgUX16eIdKt9IC3 +fHFpLi6le1wf9Cm1Nfh2XFPdzKQTw04Ox3B8MB7TY/xl3avCXPaDqHvG98XWXQMrWR5P6sd+xkZT +Ou5u1YXcYzqhppBBLZNWhp0a9mk8gsH4RmvUN11abmZABrxjV90ZWe3Be3/IvxxIWYZtDi2xN9iN +AHHaogQixAmH0cQKREIa36+FqErWngUnVxVxMK2NaafiFh3cucmcb9lesKcgKLZsMe6X5XvjB9uu +ExEn3QUuF9j3vZPn44PBTgSo2ukZ1Ezqbda13kz62EyG0UyH2vB04HbPPB0NZsy21bxOZxqpM9Zd +CrlmSRKODBeFgBssC8s5GyyMlFu4NIPR5MWR/b7J8ogYucECoeBmSzTaaC7xaHEsncVDuYwKIe0W +lgaHW62CKpDOSw5iBy0TVZ2fwcrk3w2/pPnIhRsp7Ve5/gI4O/BECayqQMTkRtzFXWrJAOaW0u/c +fC6duzcewPFkSPOTQMGcGdH7FsHfMkhaixD1Gl4K14riXkdJBpUeIJyFQ2QTIJbByZ3jvfPCZ5HN +yoQqyYNyhQllA1YB0ZzZNKHGw+0nA/iITL/zu1w6Fy7Tl56PgRG48K5ASDwxghFSQ35G7fl3aToX +bsb1N30DSVysUCWNzOHads5jl0CEcLl6uSkuA7htn/sl73LpXLhCjNQwjT3A3S9Dgs5zIzXkZ543 +XSZVXubCzbj+pm9gArqfxxh4RPQNX1VP45alUj0amNxPPxy8Xo0np584fD2Z18nMT0aCYpMpmExS +P5DxPbqdL2d/cqAgWVruUCQ+tMXxwKhtA+57LMT0pHyGr3SsIaXg50l1AbsVSwjpdmHTFjW4qGFo +gyq+6VyTtAGhYaQ0ojOCdVkPFjYt0UytfFIaLWzxaIMWNa7KhIL6Mxuu2bony4B7xZkl6+QG6KQ3 +4tf57cm0QKU58ulFNK7TojvyUlogJ8CNvu5xgbWgZ9Eg9Y36NrFAqaM1EvefcvdaO4CV4l+APqmk +toifV5H0h9N/3txe3CX90X9kGeNz3pyN68xxcXNj4FnVweBAfKHj+0QzCHKPA90EACY1bL4I9YcB +K9hFccsMDsomHeWST2SuUVbcOWMwfKm25LPS8nx8kCERWWzEtQNWOfhZ0qbCfaAadMXz9dFsoxP0 +w32ruW/ieKrB+paPuBbvSy180WxuRC6aLb04kVtqFV8Innra8GAYkgbDN/Oi2WrELJo6vnY0TUvD +M2e6fuYanl4cJlV/fb6Nt3xF7RKvBhdLvl+3q8aJHD8OKgLcGJ0u+MxfoSIkj+kXaryYx8XrMr2g +keVVRsoeq3tQgDUldNwi72nD7cKzTiH13jGTdiUTQtOGD4wO+QN2HQ2HgVAz5DrknhW+nNSMJyRD +jsVDMLSx/sqxIxQD+IJYAsjdxoZajZLOkE5zpcQjuQ2O/SAPSYIABNPH8ymHvQuSARGPbFN2nTiU +HirYhWm2raZRiUzkaVJXOMI6VSMc2GPuLn9i0ye4FNxKmiOuBWwzbrUVtJaW5HLchPousCqUu6pK +V9kHlI4314+GR2xVPWSeFdvPCubN+2reJst8PF35+x1ct8RnBDe7wmzEWRARLoBbg/nCV221yCrP +cuHr/zi/ZMd5JrvfPgHpxc7WXi5KcuwtpSBxhMienIGaoY0lDKvhZHSGrwCugc24RDOuFHcGd4I2 +QFjceZ0B5TmX6YvkanOtuU3uB3ejgow+ntQ2am7cnWmP38GRu8V+z3+vJLMqsv2ByNPGJLaLRU7G +COl0BWrGnzfjGul7di+h7wNONyYbCdAUCH/NNK4vlqtuSt254YY703BvANO8MH41KZFrq6qdtD3u +3XQAvI8R9uCMUEhrjEv3XbU8CbSD4LNkc0b9QLSA9Td8blQQviE65WLMMFzwHpBDGvXQMcq0M7L3 +I6uOnJPp0IetNeL7QeKX5h9i+KcVdl7JK2LGA18fb2DnOOZL7Q0TPKiQiHMWj0gRuOEywPNjoJJw +nDcOXt3w6smZ5JC0wrATfKORxVqLkVoWQpWvmKMDs69xuOkecnag+GxSPYjkvChpShGE52EfxhrK +OSbDNfBXNJ4hzFvQtLUc8xHTghdAwPFAE3N2UEC0Mp1ziF5L4yRSx1o8BeZJs8sAhAgjd4T7NkZc +Xk+CqQt8bzrOycB3hLdUD0+HalXHV7Lj9m7afnxJOMmGDjqXzlut+OpxYy23A+95L+3Aof4QLpc8 +iSS/dCiEs4XPHdBb3IROn3b9E+31DmM5PqhAIVgvnrk0N34ICCypH4p6kDYCTywtPpukqV9OI8Av +JDS0acFxmTmWiyaIeSXFOU3ZMw73swOFTRLhe2nz0HrtWAvko1xxTic3ADSBcDzGNMRg0Q5w1LQ8 +Sufh7sAo6hhFMaGmB4Q06VxIQGjBEeMFp9NOkrGaSCf9ZDNik4IvCMwpoadOK3GMB2ugCwjclO8i +pwk0sIL2ACxMG2SJEgiCs171ldC+tMKs5JYShOgKoSWcwDPEIqAWRFvqKI+llQJJHSkV5J5OhnPG +uvRt4R7klng2RT8fq3BzdZ5YBfUkrAKCyFi7TyigQoBaiU5LYrolh3KkvcBxMAlkWjF5nQBl7wWB +o22dzu7iLNWL16Rh9pgbFdTUbWCGGaaDFX8RBdAddjrw3iOZP/oaxjVxeA4AcQ1ASgFA9cLS3dc8 +GfBJznXeSlntuLIrOgDF0JAAJwXg+24GcJLwKpuCSrGGaw5hDQR+5JzBSC5rkYkCw+7ZppK7VH02 +6uXDapsX2CR0DjuSBTo6u3HCWBADSa0clYvPt3G+u/1x1ayOLj/y9lFZi6rmbguWlZjzZHp8VSBG +HwqpDHJ1D7s8M0FuKlDDn3f95wWQa8RpmkEI0+KjP1WgEWOkED2Uf50djN+VHqbC4x6fzTDsGPPb +9AFCIZSFwwj+RXgqMysGB25nVnR+E+8GWZR1v9yWFjIIHtUSPeKrPgT3V0FFwlhDIlZv3tlETTez +T59fX5e0mApi7HAa9WPTONWT0+CHbp+MiwM8JDIVtQkc4UPcHdK+ZRAJY4fM6dAWUhFYkgHEtEVm +XYFKBUaUT0nILFcDkQxnRf7BiKRaVuUwgEu6vmT/XGrPoNyDXEPuYt//42ossyyL0G9K4I21bP4l +ttnINTPEZfs1EQREvxX9I7iXH/iaGaI4li8yAPuN7NTjuOigvWHLoW3BslKzXcCW6T0p2KqoQLjo +TKVd5qKcpXyDAmRFD6ulSc80L13gqaK6oWbqAWnujg8yiNmgzq9yDRDCfJ47/nXMV2dE50MBNVy6 +60sXQNVCBUvdKPVIN3P3s8oOzy6hmuYbJWqCBTxQATJZD6naSjAoiOTqgFSHAa/M48m/joVkdf27 +TKJy4fxcT1cBpV7kOhoJLTFOtIWsKNwsnnrS6lUFzF0bd70floRbj0Y9nZfJ5HG56STXayDj4tjr +atSTKZkMYGw89P21CpBnXE9pIMxpNmgbNljC4byHEdsNzSz763JYS9E6w88aUkcGyGFHZL/6RsML +Wle1ZEBu6uyggCB4epujq1ENgrcVC565rQJh+UQ61H9VOt1XNRnbnCNQ2YeIN8SxRA== + + + auQnAlxb6p924l8u97QUQoPpDtV0K0iXHNtF0m1r80XfCWZF2ALbrLRJ/ikSe36YDZUMEL0Zs8HV +R56k0tBV9RRAauzsoIKVuz5KRTGrNHJrCSCaqNSl8lHpdaloPLZPn246Z4j6dzLh+UFSoTqHUHMT +qSm5oDLNuATVwsxPbE/HERQFFBGI5cVanJMEieoMWiYTugKQmYI4VX0TJRK+ryUBcktnBwVEUnqX +vHalFqS3bU3VUgbI5HJv+m9Sf/taRmP69JmFOgShH5JNJD1gZi26B1yGB9bggrYIV6JWruaRMOsC +wabVxFx4JkiCcaxpsymCvgCgCzPJfSyBaJ/GoEQJmuqpQKkx1lIVmGXtx6pURcJPF03om8sAaEdT +lzKoH0aqZTyuT5/cjmRMZdPNd/kBLAltTM13K1nLTdWEouL/aEd7iYRr2TvqqofEFDVCpJ4Vrg0H +zQUgmCicCgAzjckwPUhBvIacnWspgNQQr06BQGG4KpUgYQJfjpQbygBoflJnMqgeANcyHtFnoMTw +77OZFqcHzLGj40crufrKmFriaAjhrAapwxnjJIC+wDzuvMEpCqV2bFldrISHDuzzZXoIYWMkqsua +sPKVgroKvGCpqUBye9jsGUYsndGBFyPVBNUvU5rSXoacHfS9Kl+VnpeaJuP7HBQYZ6jLFFgeaJrh +jIKjle+NsWD+7z306IPOKVawqDayUJNB0ONrsWO6LrKOkk8OmB8RpJufsY1Fh58h4sJp+yoKoDRz +dtDDiMRC+5trEX2L+BtwQwVwdpD7UkCl/6mSyXg+AzLToaDSMZd+434dOvE6zqiiYfdua2LMQuOI +aCBnmV2xOsCyIYvKh+hYr8yadA2bQkxhwThpqF5hPzGtkBSOcWsn+2EWg7r22T8ejk1ESeFMlUkE +x5CfwSVDOA6YgD3nWJPUODEZPjT0yVgjKij7gJbCgVdVnHTEilMcLDG4aYjvvSVh3gTnodniMEE2 +SFrOucLXTTErcGhEie/EW4vNh54/YMXxMR/+JoqxMG9rDj5jeICFZDhvZ/cGD3XiDtdGdvfCLHI2 +jzbCGEezZoyEWLr8B0B2w4QxAq6fTiPpj0/hRZx3x6UEPD4kMhy07AMOew2KRD8S5mSfmdhJbJHt +ArxvYV3pcEsfs+Tjst55+IwaOHpH2JCiJIDERGTvC9vGOK9ZuM5hrUInVgmS0PXakriEyrFLbxvo +c6EM83pMZEWL/3IgjvSQj5lHkgg95te1aFme5oJl72kN7Ew/uaxhWqdWehABH9YzsRmrpxVE9QzM +Zg3cGCO2JnvpRBvE0C8hzKwz71hR32JzOXidsLKDiC5O9WOqyEl8EkA4BVx2y8Hp6/EcxQyIZ3jM +nIEsKXFdIgkKdlW+flt4ZbYMwaDtmAnEXRJMYHHycHIBOuKYRe7gCI6NH5JHFXrL5IMoQWIYc7pO +jR3vEnuCITL5CMLCOJQGAGkdjg+YOoAr1MkpJjNE0LhQkenMbUYvEIToIqNkjI7/spzQwq5JBNQ7 +XAUBxZOiAwtXckLFzGQD9jRmwBxTaLYfOvbyQmYOHXViNaNiVrPDhNAuA90gWbuDIMcmmUCCa1CQ +6iflaU4ifLSg0FDsA0bc3ZFwL16MN1QrjCXz2gYF6JAviU2aOGGQIGVNURopH74sS0drhXjM7XaS +xZ3o/NiL9NPIx0ar9DTeosBgr1+eivham0HbyetknI6ire4kzRIOZuNF7OLjnD0fFTvKSQoVuIEw +nWFvucMQFTslcMol/kpSPRrOziBXTPKtdo1h/pfVEhraDLYTehEllRMXRrhgBuic6I2IPkR+QvBi +WifkZM9S9rVHB8E9w5DO17xiexHfk2XuM7BEwRDHDX6HZS/kDhTWhX0J8Izeg7UHLhzD7EinrSQV +ZB2ClpJgN30nDgSDmduYiHQwpgEtjeeDTSkj7oG0dWjgLbTmGCs1dsgigQio9jDp1mD0ZHeF1oQg +eTYUKwICHCpYxwKTKdaJCIiKWsO4zDpBa+DEGteU1t62Vtx2lHGIcsKEHrHhgIhrllrbOK/hI3ZX +a+E3T993Vu4mGZfrcH5FBFXA0dEy0ZnZX+iVYGLlHBESqvbJdGPxwjzJ5SQkK7WqfWmqMcziLoZx +VpXBk4Wz9bkQhSH1wbCc4mgPsgjGqlzsJx1Fe8a6ZNliqhMHMXGpor+BK+5EygHAWikUIXKzbKfZ +XwcOCXyGqGRUg78ce32xndrJJ+w0KLrWpPQMkuewYZYiCA8r2hBqjZ3EIBXyFVhnTNbYo4AQDvpn +xV8p9kC07Nkr5cSSY1MAupBDFlHY80zUJsW84uUWz+k8biq3BMMssdwHnv4mKOGp5QBM8GrRy2CE +CSEun2RKUVoQJjOhVpYd6mnalahpwfNpWi1EwRA7ESVPDBEDx7l3aK4CBFG5VWxUmkRv4jvgwRdI +GKBfcoMwM6PGc+yVpgGtK7qu4SM5m7RxXry1lNFrizpbMs1EhExxyXldJvaDikTOxQwEgSHyU8WX +pavzNMyHcfAmfFkyAi8x8UjU4sLDjkkdMxY48mkHS+gpYiXkfOddDy93iDFifmTyQqcx35MbiHJ0 +/CzWrSD6FsjFcHMieuGgsGV9lLWip2KdiERmGPbli7JTjbyB36Zt2UUUzIlKBiyOdTbwlmxlyyaN +sz9MDn+AJSLoBYcAiZ2Sr4zEiLQIM2HvX6FNx+wUKyouOltbR6OgZwXPf1AR11lWxgwnbmNmw7LP +46HEoh/CLkPECLnAtQtdUqTRJFC7xoZeyRGRXosIhoa3F7wK4KwGKt0ZFvottEbaJqEf5PgHNkZb +nNMQxWxMUbiTwo4oxCHrSukMAE22Lus4IqiSgayPmyrmtHokpiLdKRb3SIZQ6wo6z0KvqOVYwXY0 +t7tEIagIlIhsAmhjGz6d01i2Kk9BIODN3HrzwnwG6DsnBGhUdUUMvG598lDvuqS17HyK3erEV5ek +xyjOFBquU+wz3olzLGA4+i0y3Gj5iDXQcGPmr+UTF5PKIeK8xmbkpIbKJ19WmLYiUwPE5rNOmj5N +DtgcbhMka5zwMK3cWQcCwQ7udNgwVdNwkI/JF52kbLjNgmBENnwjNQJnYRYnZM1qGsMAGBiPYbZo +mctgd8E2GXvh8Q1KxlRnPIkb8xWcLbAVH0/8iaykj6BENtAxG0XBGFJsW7LqaN+CRXetbOaUbd1K +1iYJLqAtSA/QwgQNk1rUIptATwwdQTSGxM/W3VPasIkIPoieaPghh1wdsbHAgSqIboO593ltH+GW +TON9G5Jyw5p7inYRmRLYU4COInovMsrMfqO4btnRoG2Fj/1k7mLhGj0B8eA0EsRZvbSMMtBsxMTD +Q/7AFocCG6cr7RP2KDY27WPCEuIJxKCHE1yzgxKHiEjcIG9EhYBHxV90UI4isEZsqsQIIGoCiQlF +DcAMPtQO1I5EkdgULQE5EX8jtF6Gg5n44Gfri+nAv3hOsA73L8cxm1GBHNAZyIYNxfYP0BuT4qGI +ADpQENNKqnEoz3wnDnua3cglXobjZ1m9S9QMRIuNKVCAQR1L9G48XxtzGLFrObyx44yX1KaXEBsF +dk0TO0N8PSIGYtBJKS36DFgFWw41sCRFrXDjp7bi+GaY/DNvTrMQJduZcU6IBiIWodJcwfOPiC8d ++dPCxBHAFgcpi1pvZWGOeB4tzCAwlVk6fuc1iz1vkUYBMSfEELBWeVrQEtLYnIAA6qWjud1l+Sdg +nohFAYGz/tO5jOUr8yQKjYjQ/Lmp45+IWBT38foGk8iuOSnUgR27CgiuNGzLjilOjA42zqeRf4pi +PSYPCgY1XNqW0v1zbkBkhgTzWT2QqkEABAxfbf+Tw5ck1C1B+j6n4pNB3LuPvRizU/pEkqo460VI +E0LSEc0pHWpJBCOGWiMQUE/yKrKABRsT7S/NHuTVzRFItg26xict97hkDFFsfIT7l9xUfF9pT7SJ +2C6JqB8mVlzY9NHSprk0zFNWbCdp+/1jqA+buqZOEakCzkAleKNugExyUdASdOJLoRcj1MYZOmbh +1xN5/lf5N8zT5N+Q8JQ+h2v7RAEqyI4xClAR0CcEqODgvy9ApXq3D1DZ2QCVfWxKznr3bLEpn5j4 +bh+isg9R2aUQFacfDFGBq88oQgWgRwJU1DMGqKg5ASrs1jSIT6kH9pnCU9p0R2h+KCEqan6Iiq6i +Rq5qWB2ioiYhKt1qHKKi288UoiIVDUJUutUkREVNQlT0oKLx2D5TiIpOU54fSojKp8ao+HGMip/E +qHA09SBGhQTYYYyK9pMYFQINYlRQyzBGxU9jVPwLxKjo5BadH0qMSvc5g1TEK3oQo/LZIlSG8Snc +0u6Hp4hYWYenMKQOT+F0MNsSnsKdqcNT8gBKeEo9os8UnpISgzT5oYSndM8SnsJjHoanxEl4SlwT +nhLH4Skye9sanhJVpr7ykMNTnPqM4SnIt74t4Smc+/1VhKcwyjwcnuJnhKfoGeEpiWso4SlqFJ7i +4mcKUEHSqE8NUHFBDvotjVDxErPBl3Y8GKHSlXgPvaZsjlDxD0eohHnNPhShMij5YITKwz3eR6i8 +dISKF0ZtNyJUqMzyABVvHg1QAa+yD1DZB6jsA1Q2C1ChqRkGqEDLWQeotNFNA1TaDQNU4F01CFBR +ywNU4ihAJU4CVGJ4OEClnQSo6C0PUPElQCWkmA2+HhSe+rKZOFTEzw9RGRTPQSphbZBKyKKqUzPb +zlEqKkepyL2s05IcqBLmB6qMinOois+RKp/Bf3QfqXJ/pAr2xmeJVLHpQsESqZI0en2kitkkUoW5 +hlGkim4nkSp+Eqli1kSqxEmkSpgVqaIej1QZzOMLRKropO5Qkqx3fcCIDjlgJNSRKlwmhX3cH6gC +a54Equg6UKVLgSqtn9luH6jiUqCKXh9cg0AV3ISyJlDlkR6nOBWv93Eqzxen0qphpIp6NFLFjiJV +7ChSpZtEquhRpIp7PFKFr015mkAV/3icSua3tiVORUmYis1hKnYSMKJiDhhRcRCmUsI+pkVTkAqx +VSlIJVEIDlIh8i9BKmsKrmuzD1IxKUjFrivIQSoInpMgFe8HQSoPdHYcooKDah+i8jlDVHx8whAV +KC+HISrspfhoiIqahKh0c0JUYnihEJXBJG5DiIoqwRpGzQ5RsX596YUhKo+2fX+IyrjovBCV+/q9 +D1F51hAVqBFHISpwNRmGqKjHQ1TaUYhKF5eHqOCykacOUbGLQ1TsIESlnq8XCFEhudCnEJUUK9Ll +sI3waIQKrWuK+WjVtHCOUKGtlyJUnCoRKm1MESp2XqslQEWlAJV1xTg8JayNTnm4qzk6xe+jU7Yt +OkW8eO6LTqnefkp0in8oOqV6uY9O2eXolPtQKUenLESm+6NT7kOnFJ2yEKH20Slro1P+9v33g6CU +z3vlkNyQijACuLKzQ1kPsocZNYy1HAUbeVU1bBnGF8AZX7KJW/36T/ywjvKcmhH7DA== + + + g/hiQU6aIXWg+UEzGZBuLERXyje5r6WS8XiwvdZj1Q9/PvnHn74ljPrN2cXtGS2wfvPb1dd8BU6L +VaeX1UKHlIOApScl5ix4yEiiAAadAESEIzCnQxyPF5sVYgwgP1lxXIlOLn2M8EBK/p0YJq4PbJMG +p2thICJuit3y0UCr+BByLohRLIEaBPAgZ8AJe80o9pdmT5iOLxXE/aoE70zA43AIx5NBwUeel8WZ +aqCsz/b1V/BaBbcCz4jQiihp+eJovAle9FEJghvygk+dFlhGk5MDne/i9bg7kFv1qmNP7Sj5Ikfd +OZ508GSrLibDKpqVVbjrV/FfdicCuBPPt2e5cun789Pbs5/lRmmJI/rslANKdgRB65Tw6YpBAQpw +VrqyogMmVrhgqWT3gL7Nao5W570N9IdajH52uLCMjuVL3hEk97CDc7St+GKw5w8JU53rBADHrBUc +B3CDArv9K4/G+Vua60tIZdbYjimId4qlJRp4y5oUbpMvHsOll3CK94kuabmUgcUgOrsuORKBJSBc +rwbBDPf6tumZ8ynCPgMKGQ95451NZ+eSsXQSexLvj0L5mP7D0rE0PmPxEDMyWRYBLl4YnPuTpQFw +g8WhYtPlIeAmC0TFpksE4OJFWjNbqAkHxj944nlFvnrTr8nStYCKTbOmN8CszWsBX0ZoAAzKtAhM +wpfQt7VsKrA6eAHCdxIcKcRrH9KHoyrvBb5jspU7/o/6SpqQhJUnuWo+QsZWjFAONjC23IqffQYp +KxpRADSwEMqSyMcANB4e945qqMCcGEOtwSTwtbGKT3gWYXFHOxS1rBTslJwMnKMLZxB0uLjjFgZh +OAPB4RNdY4WLyQ6g8CnrnCsQixSmmpdBG+wXcTZT7AvpRUNqJEddvqqWL8lVnBZTRRMk/smyewrf +Ie45EI5Gw3sEWBlbRIiRcCAKY5oUZL0cz1sOv8tw5qTou6sDxO+xcjaDCHs6a1PefBK5eNt4UVrj +NtMgN7lidjjjKPHeEqXj+LZQufxRMhrCzixZ6TFXUs7Izatw3I0cF0m7yTpsb7nmF7468N8gsclA +C3J8AI8dCfcwcJADB8KqZ5/c0fNC5Ge+9Jx/ZQisa9DHG/YlVxy43MpVuJo9co5hdhPvQpiAsYhw +FOpS7L3kizHZYbk77FzLhTR76rFqTSJUxQERGiuLTLR8G6bcvs4Eku9WTzedAOSNXK7ZqiAsq2Hz +IiGhNbpfkvGqHU/W8eHbIuEaSkuidJyp0djaW959JC7OehwWHre8R2AVPBVwp+7z8UN3p7erZkUi +36+/TQxRusF1JllrgRq0rUVCgosUH558k/TJQdrzQVxAWwbBxKg7vuOXRIAusegte4sBZ61iSt2y +DOyiw8Oa92uqmTY26VDf3Tnh1Yiupm2tHE5tKEstnOmgwXFdhPZrrPXSuJRYXIab9BsWCHjkOFgv ++d7sQXBYCq2m/cm2BAMtJVTKpjWIZ4GShAgrFIhduvq5I0bAg1CSUEgifIqshnAEfffVAbz6owSD +GtZonxDId+wh2N9N7RMPAlAr06f5siw22rkIKzzPqMHdUUQnOCjphFViIGG4mjrwZbLw+VMcZAen +HitkQHTt8AANfG+sdazpxnpAFOOFQIyp7+QC3sn7ZlJJM22omfammXa5WTOwZs34mzXT1KyZzWq2 +T/pYcPhFIC7hCnVbxfEwnv1nuD1Jw0tnp+NqFYZhOIj5hPdNTgKq+Urill2ntRDV8ctB2WG9a1qu +ujZ6mB33LQHfgzF+9WZNU0RJB70hOld3lR7HQ0Gt/UiFsx5/0YwqacaNrJvvQXdPDoaB3dYnRg+E +jk59Qg4iJAjBjimHBG07qGgdu7ZkTOOgmZiYhRNIURKNgzvjYd3BOLRlv0UjAX9s6PEh2SNh5jpm +JTdHgbBeQxteNcXOJQ3S0AeOyXcc4G6Ly/7JAZz4QIYa9rFvZQ9Bi8CmzxPIeU4ikvsPEN7Gqpi+ +GoTaScBn3xjrMXFBVdUnjl1CwAFcO9G5k+lMnTyg7MaQidHimwkb7+D2JS7HcCqc0M0IRgjE3IJR +A/tnkbbEcbRm8J1oiS34uQ5mIaKozCD/gFhaYlg49zH8lxGvsq5olxQqQUctRqCjs41bPZrbKqxK +ntXaUL/B6bpWa6/lRdqehWhXZzdX728+Xr9dffj59P356urm7Xl1zD+sFl+D16LoHmG2AEe4zSLo +JtgtmvcRfoNYTDCcxMcJjn/1Zg2W81bu8ZxF5gmmE3SK60waJtie9PYjfJdpGGH8mlk8uV8fv2Dp +KvW42i7OdEMGss8S9fFT2cd4P/9oHuIf2Z93Df/YJf5x9P5R/tEU/jFuzEAqMZlGCIJg6pTXKjAD +aWkvrcnOw2omm1M3pIcUBx8VnEraCFHUVSzkZ8rNM+AgNbu4DDlIzR5GAw5SJ25pOQdpmGeDA9a9 +HKT9HBykncVB1r1ZwkGOxt+smaZmzWzO4yBjXMhBmoc4SLOAgxy2vJSDfIhhHNY8j2E0jzKMZhOG +cdyVBxhG144ZRmykjRhGRLI8FcPoonqYYRR7fPR+FuM4rG4Z46gnjGM9Y5+ZcYSrrrBwcSnjiH3J +LJydxTeqnm/coNGjmY2+ONs4xO7FbONyHF/KNg5R8x62cS22P8g+jqtdzj7qNezjEPOfk31czsxd +nP1yDn7ub+dvN2HmYE/z4kEOKzRSdwqkSX8zOD+3ySbI35SX06/yr7OD8btx4ari9BN+5gFwhzA0 +mDKAE0ZJEDwhQdsGeGsSj9e6lr8MCHU6QWof2sacvyRY0bl1xCOUJtKP437ks5hCpZjM6WgRSAPe +pe1gVWrZtQHUYELnHLAqXy2dH+ApSSeYA42x6aKYiWbRdR0RGKgxadTF7cqo+ofRJOJEHl4IEiXF +ysWctRFGUUnb2LUuZID8v8lQeWzF7VWmnfMEIPlLCyuoROhxXgTDObmiYguAYtcIxSuEOCzMu3I4 +nznXQdsxW4twnNyE/JVMj1XbqV+jbrZsqxn2tZl80+Q6++SOOuFxziEp/9UAqZpzvDuOG8ov+Z2B +lahlMZr9i+H4p2DOM/CC4CsC5cJQPBtOyQiIlwQ6DJGAfC3PSp69KY881Zwi1nHSKFAinjNlgefs +c2w4/xRHZ6ce16PgvxzNp1cy5uM09k30g0an4+LhSRML8wPTdsbG5CUThzS3C6fuqzfTybsX9uCU +orsPT+oktWSsGMo92ZxFNhFEKVwEH9NICsZxxS2LtkqtMcfYIFlimWrmBwTKM1k0wpo5L6zZKNet +NS1b/CMJ255/qNBxGi3iRIVIEo8GtGgRB4+wlBaRUYhW2pPNPdnck83PTzb9QA7HlgBLROJHiOxF +lEHVFVfg8aG4QQdZHWY7/jgDzkhOVhI8nCDIDQiZAU44iBvhlDkckxwOOQUkBEDJetawr02I4Pk5 +jQDq6Fa93MGPEp5kmGoxAP9n/5QaDEAm6/hNop9kNIS3RlSc16GTzHMGDrAGaZzY6CkpgSUBk0nh +kmkiUEk+RwZz9VCcAkirobkGQ9qQANxqDnqCc9saztRYkvRYNYZc4oiF7EASlIjHyDTI4X9O7ryk ++dPinkISuEP2Or5HCvmf4SK0pihSCXDeOjpccCTJLTcbNno0s1GFcNWOI5AQhD1IafJYPMIavOyB +izATcu1i3PzqzVLsFMozFz9lLEsxNHntLcTR0e5XA6ZpsAb5rJWMk3IqevFt9KCGcIKEuhVzwo6N +Ckd86/gkgmxEB3pkf0hWWBHOBWv9AISvLLIkecfpiCJynlDVLgGQCtdwSgWTEulCkazlOtggac3j +YclbyhmfOMsKRy4HydfIqVnYwQog1mifAJSCsPGVYaVtFBc69voTtoyTVzvWKqv8nNg5vlGUNjCC +pZmviPBO4/t8MemmBeH2HDrNZyPylwmn0aJ99oEN4D2CFUMJgtv4jGDvwBPmReBZyLyIF15EkuAC +gjMIEM3B3eiPDsBD17J33pg9yb/u1RJax245VFnkbO8u0NJwRFVs15EoYJjjMxWOO5z/xCAujq/R +Qogui9KcKYLDjDmS2XgOddTUWSebEply1xe1MKU45C6hrvCOOTrbuNWjua3CAa/lW8lbK1lsaiKl +hill13Afec+I7/LCXQMyMNk32OWTnQPg8r1DnMkmu+erN2v2DwPHO4iA8/eQMDNLdhGXGO0jgo13 +EjNgw70E0Hg3MWy0nwCbuaP61R5bNry+j6aOOTpOQczOnC7dl8DPHfxb5a4Afob1NDCPxyljSMKS +SWs5Rt51SEwHFTAv/1Nx8iPIg2SkpW0FCVFxXjy4uiKf5jodHCNGixwGtFGRF9bQicah7YE9svnq +Hq8gV6oQEegieWcV8xKSopkvAB4Xs44tgyvO0B+QQAmBlxu0djSnNYfwg47zt4T/n733zk9kSRoA +9wLcARkECFe+ADk8SEISEshbnCSEFabfvPljf3uBPc5eY6+x19g0ZbJ8YXq6+z1mvukPVWVFZkaG +z4wMfCHPPGLDSBb42VyEgSpzzEsaP9VX0fAEOx9PaGHBm0B4HCBBV45wcIsIFtwU0Qn5n0PzFhTO +MojCeQbGB2AIRMA3EEP5SaG9GEPEBOgsdOEoOocn5SLwNDTqYA4C2oxB1jG6dg1ly7MJMEusKoGA +SiBxKqLEErNPOVq6mIxh4d6WgPa2aHgnBLqKEgi3hHTa3/Ap+ImELLqkEF73LqlKF71CLRvHV6TG +8b47SfOuiVxPNfOv9cqIWEOw3Co3gWr1BqAFbeE393tAQLokYF0VeFkHBeMagnTZBTxWQcNrasvE +Ix7fPAWvkkYltaSv4LXXuAH+Gxjp+kdwj1r3VcQAN2LoHF5WrB1hWT9kS25KYG6iEzQ8zONNUOiU +DUoUNeoKJW2eFfERIlhyDd39IL0RkG8r4vEhEw6MmFcT9uG3cH8ZppjYfwuv3eOAy6dN15+z38z8 +/TKAl3Vm5wzeO4w2RVUCiKA7fkV8ATo6p1smn3H4yuKIAFPiRVwThWLgYUx1yaUnWY/hEVg9/XcI +NGojgVYfSP1nPWiQtjTw+5OtHtPWdk4C3z2Brp6gUC6gHb3CrGbOkWxYFBXRUiuE7vQluqweingt +sc7TaWbuToF8BfDp+FyWjpGS4TMjLWuezkXNvlcTeva9LkTR4DM9TYNHepoBj4x0TT50TdnwHIWB +tiEqFqJujEP9WI0UrtV7PE0UaCPUE/RY4R3R8CReH/K60p3E25yKT3SFvUDja/bRNVKa6YpGRhYV +/tN9FTHAjWj75tAVBeToyh7tX7ZBWVinHcbg4B0yDMzDhOayFSPjKzMpCt3pC+01HXNQCYkPAXOI +MLWZIZkZ55eiawrsvxUZXI2A4OYFes4s0DM8hqstdUGskSBxrP4JUhd4aaQnApYpMALC0sDnVlcM +qnpOwMriNyMgcogCPq+nm0ZEP08DcrKrJTZ0UWbcecVZeElgXEdr6P5XgXH8mhdxyQ== + + + Ri21zdl1ZqGu4e0aQIU4n8RbxNxmljO3ab25LcQNdosQ10l3pGAI6S7EDXYL8Ui2W4ivIga4EUPn +st1C600t2p25HYGBQ1jWyStfnUXD7Ec7+yXC8TBFGgkQVP1A0K4oPAzOooJyCbXGB/E1jIlwjOPX +iTgOjWqvyJq378xCfQObHRZv09rd6ooJsuAT8V/YRpaqVnplMwHdCAQvUUfGBIdOoNIorJr1aOwL +6OCWPRobBDqmGitFJiIxrvytIaI4IfLQDTnyo4gBbsTQeVZyF8gxyuYvOREEnI/jaWrw4SDrWHgh +LK+QGPDcEzYkhgPGFL6MmuVMhAZNiBwROu46acfBamis49c8vBwBbz0u0Xdmob7R3n2cnWfbU0uA +km2rkCA2a+chQmS+6smQfOiaEDWDk0kRmpcLEaNs72vJUbZW3RKk7jyYaBVyxFBpgz8dN/Gn4wYP +JG7wQGQcEP40+UjypwW99yEQoNUHWn/aVsj//npJj+mf4U9rRTp2UIW4G3/a6ksX/rRTp9b+tOWX +i/vTtIk/raVlzdO5qFmSOVp6lvzpeSla8qdpoz9NG/1pLV2TD11TtkZG6f3pualb9qdpE3+advKn +FzRsefjn6/lwUBl3BtPO4CMSwY+RuUu+8JyP4Js4flPpzcC/F42vdnPqwRdMejPj2eTTe1Yf1D/a +Y2Aat9rjoP07L36Zrfd6HcCpo89OU2pZGw57MWBij6ZR78WPOvhtbArMAACCbM/btjdpikAUevWp +Y3sWtb+C6R3atgiEyQei1QfGtngiNG/8AizoxaBSn35qQGc/6+PmUJ0kaIVAmDSttf8z9eY6PzoA +4fZAawhEfdQeA7FZnY6H3TYYWBSvOSASzYqvmHIsEAMohEQK/BNiCf4fReH/ob+kM8h2o12oc5X8 +UNcM/K/gRUUucLf0T+mW1U2ZBf+VJ0z8d+X9YlRDbkDd8l5e1piJn92pgmPYKY06BLLQy2Ik0z+h +X1GHZNErzovkVXKAGU+Cccmcjogx5pWtGtwGNPcyMa/8X4ipmBehi44yimWzKOosRlTTSAjduBjK +fDg/bTCEdLNCEbw1wSuo44InbmhRgGeIYH4kuo0JHswUkfyDbgMaNeV21HNTQQK/ka9innhip4Ph +XwP0B9DZSK8HvbFzMA1v2BNLA33+oy2/jWWlHMNCpwdmBtsDGukMvLgBfoot3ZjUJAyMhdhNZ9Jp +9BBAI4TqtN7sLgVh3jFk6pNOU/0cLzImKe/F+/ukDRQabf299MFxrzdDl2EMx9H6aASQhhcHfNSW +0BfQAPWWASq9+fd3sHagda0zReAY1E/vYiw1BgO0u6U7hptJSwJGeeUBlCRSNCqTFYeHJNA9DSIX +FzQZe3E5UQ9m7sVRmTOahel9d2nz2CFoYIwe0thGj+Xa7949r8cbIIYD000Dx4NJB2aeKlft5TqT +Ua/+N/4ziJGJrx/Bn2LkyJ+FPXteNH/vngdgtD6emqxYptcetOZYcFt8ImAqOt0FUdX5q59bDN5m +HtnhoDXrTN3MgYSycg6A9LcidCp3y1xP2vkf7cFFqwXxgkhcRfJct71IBSaIXC/TWhPIx4Z1WVCE +Cl28Bw/psbB0LSNYlJtQ11EZ4D+cBv85U/LE8v9pN2dwCOgF+tZMn8H724S1UvuTlJpb4bBWRmtl +9CuUkZkGwjtDNNwEQZuPggiLHMJaE/i257UG+oUaiPnlGkhca6A/SQNdLXnFsoVTZUJya5dqrcV+ +S5dq7rvM1wrtD5/SXAotvlZof5pCE+JsHKXOMeD/8zAGmIjzLL7YlefgTQkw/18KT/P4ZhoKJoXA +anLWcUJmHShca7U/Rasl4vgqPY4R0R2TPKx0g06hwBzqxDpS+C9Xa4m1WvuT1No6UrjWRr+zNrKI +FFKSelkrm3+zsoHHJ9fKZq1s1spmrWx+lrJxk3uwVjr/uykZkh5+gdphf2+1889SGjDwxogUrImL +rr9D+0W0yHGc5nyeKDI8hwtGUyyKxInwNB//x20lLSix/ynylo7jW8cpWAYEXTaJJS/PmxTvmlPw +/nNk8FziiluLq/+tuFqqNNxaXP1J4kq6M4Fi4yzcGULSCl45KnBm13es5ZUbecWv5dXavFrLq59q +XsEL/mnVvGJFVPRvLa8WkVe/+eH4f5a8+oNiiH+uqFHlvuUP/F9Ud2kuubSWJg7S5Dc/6PzPkiZr +b+1PEUmrPsdE4+O5QJQl4qi4HS8mOAqXBKXiiRWkPP5L5df6XOtaAq7T39dbu3+kNkhwOFOJEUV4 +sSC6iTfB8CaXU673fP/wKc2l1NanWv8opfYHBQn+MK5Za6Ofm//OxFmWQ3Vg4X3ycWB7oTJ43Pqo +6787/12gfm8N9M/SH+uw0L82LMRiP4AWYckxWNqDoXFQiGM4YX0EaUHptT6o/0fJv7X9vLaff2ch +bm0/s0wCFmoB9rMoALUMDzVERYpjTaoLr+3nf5P9zKw10J+kgdbbEn+KPFkrsp+8LYFKxdAcx6Hb +ZWhYZgb5I3RcXN4f+adQ4T9nSnNptd88E22t1dZ+1Vod/TnqyOa2DemcOBNf38T7L/ekfvN0wrXO ++XfvZfyp0mStuH6yHwXeRzkOEDz2nwSGEdZ3efzL/affPNV0rcvW/tNaDf05asjKf4oyAgVsMK98 +PwAv8Cy/dqT+5Y7Ub57pt1Y+a+WzVj5/vPKBhyKAky/wXiWIxycS64yWf7ny+c3TNP9ZqgPG4OK8 +SMXhHq7Ax0UaHi4VKEpEsTchLjKokjUFr9SBT2i1eAgnUn9ikeF/0ZFi0+JP+ByxEKfwaTR8LRjD +cdTyMad/jhCeS2Ktc/D+OJkn8DzNCehiMRHWSje7T4aFBdUTWC7iCutxVARwXTBpbXf/EeLfae+B +pnFmX4Lj6Dj8xVE8z+GkEjrBCeujyf9uxSb+5ql9a8VmsqHOsVQCKq0EHxdE9IOO8xy06imOxWpM +jHMsDX/Q0JZnVKt+rdjWiu0foNgE6SZRNiEk0A1aXJxmKNRJNM7R9LrC7b9cr62TPv8ovbbe31ir +o99ZHVnvb3AsMKLR7jrPRCmGAh5VlKETzNqz+ndvcojrpM+1BlproLUG+okaiBPgRg8dp+gEKqcg +xKN0Ig738BLUWgH9WgVE//pageI6Q3OtgtYqaK2CfroKomhBZOHSMWKUE+M0KppIrXeX1iroN0/Y +XCuQ9RGtXyE2WQaJTZ6Jx9HZWE6A96yg0nbwpB63Pqe1mLhZ59T9UQILnU1lRBYlf3MUB42IKMwB +R4ey5GNaKDEcuLhQn4n4xNafdyb1D+O6tcX8vzieJayv2PqN7edfr85+8+qea3W2vu7kD2K9tU77 +H11iD09mxTkeEDs8e8xTnHzimGZXcI39P4UK/zlTmkun/eaZ5/88jbRO/vs3RZak5D8xTvMwsoRz +/4BTQa3rhywosH5qtrKpuLmCML3Z4XjQHk9WJW50QBURY7sWQP5cteuAdiF5zSZWLLhysSuJO9ff +/x6R83+udFoQP2uJopUo43H9b29pOO78dziYArZ6CoiMdzR9Cv5RNtGaOf/tzIm1Tm1cH0zeh+P+ +qlQUAdCdelLwM5W/rNSnYAyDiWRLYuU1adZ77dJrod4EvaM3FKV7V2mPm8B8Mn52Q3ymfDQeTuvT +9muu/TFutydBciToo3JngB/rO7ohO9KDuwI6to6HLiqKtz/8AYc3RY8T3tgxsPECg1k/Oxx1cB+c +9HDUGVSGHQU0Hs64/d4DLsW99mF90Br2O/9tmzW90wwNdn8jd//Pc8Zdie0iWOQBKbaLkrFNSO1q +pz/qKVJ7HnMe2/G4DxUw/A7dmGRhtUtOAJgJWHHroR8PgLXnLfaGf3l5oGjWamatZv44NaPSsL2e +yY2Ho+pnvTX8K1rvmCsYEpQ7DUNLwvVj+vfI3Gs3uVZE/wP/964+r4uvIvGj2UMaiJflcqM3wyop +KirPhqN6M4gZAY250Ru0/sViu9IZdL2Z9o9271/swPP/Kwf+J2FSio4Cs+5zVXjUgHSHRU4xh3qd +PrLPFJ57n0xJnvsaTEcuee5XhBhV0STwLIV3JZmESIoqmEsvBYMFkeOXk1u/z17OT0kItJzH2nZZ +b5Uiux56gvUxadhHKQbeRualWR4yHQvzhUV+9XeiYoFYmP33v397z+qT7qrEZ6ENBCfEt0sDSnEl +r2w10J9tkPxESl/rwd+WlaGPziEuZiwd9YUcoX8OY7iy1LHXtg5OrBX872Id/0RXfjE9DoMbXplP +loyCaGC5E/wmuGJ4Dp5hZOICPtOIsQT/6i6OnIkU54gwUVqQdcvncPxfzdmQUb2DWpGNfrTHcvQe +KaDmZIyCIbxif7Tq4y58IgAHx00YhXYOo/x7RfYjeFqf9abP9jHw+TgKnVaCh5N4RFEJAV1zKMYT +8MpSZabzHJI1D5L70seJ1/yglR5P0Wgn8AkPn7yeDweVMWjdGXxEIvhxpg34p1LvtafTNpKwlYab +cQYer8CHyAgDmHwOosW6+69H/9xTac6Hp8DtZ2falr5zRlcdEiDQdfqOEpzAs/DwcYIVaZbVhACk +766KGe9VuyV/mWATCc09ygmWY2C6AjlE9cv7dg8GWvHHAi+KtDbMoKT3kB+hfRDpG16kEpxIdkiz +HM9w2m9p5dvs33X503icRVENUaRoeDuTEa14OaQvM72ZjFAW/IeOIzxSbIIxXQjy07P6BzAG69LX +tMiIGKkcnYijdeF5/IMShDhCn8gLWGaqZ+1EgRMlkAfwjHjxgE14Mwccb1w0msXLHY/DKz7QK44R +0QXv8k2f8DQ5uvuTowFkCSzDigAsEwdgWUEPVhQAZhMILJDq2jXmeAAP5qYoo9WABY+KBwnKFCxP +8zSDLyiluYRmGRICvGkbtsFzB2ARFhSwcLQ0+BfApfRwWZHjRQguTicETapYNCFffCok8K0oUYYF +KGNluDwcLhx+5oBPyHBFhmU0o4vzIs8xWrgwKIZoHv5HvVlVhstA7LIIvawEF0ClNIOD2BUEbUcY +uXFRUqBaqDRaM0DxBFSeEXUCIi4kMC5VxHMJCieTSshlcMqBRGEcBZGQgIMVZLCAcHWcEucBE2lG +yzCQCCBcmcQYjGUMl0drFge+z4HIyYzICijDAcyLRfiLJ2hGwCycYNHFaZAGZGNChBkREjg0SA6u +lCCvVFxk42iQLOACODTQvYjCmAxLsXGcK8hRIk7BgKmCcYGERkFM8jJXiZzAohQNNSgq8iKnmTIt +L7cyZcwPGCgQfvKMaVoBCxGJZggECUpa5FiGFwgJC0cp4IvmwQ/DKAXI+zQvyvCouIioBqwbJZoK +M2AHwUmjGSAMQloDHfASWA5TPRwnw8hsCmiPgQfzAZtyGP0mQjLKcZB/IAJYsEo8OU6aheOMxyV4 +CfATXz5Eg7XlzMcpC1U6AVZHVNdeGqcA4HJo+pw8zIRAUwzSZ7ACeJzFX7MChVCiZA== + + + 0MgMxGLAEgMh/oHCCQxJRicrsEiHJICopszrAnCqUIaZPEhUSbxDQUYHCweHyCssCQgJQeR5ijeF +qIo5WYzyeMlklhRloU9zMkuyoF9cLCkKqJtHHE0BBOCFBnwnsQ8rHdXGkPg4gASnnJDh0BQQEAIW +uuj8N9BNrIgXHIosyKVIRpJolK6LluQQI+MxYRDGCTrB4UUBaBW1wlhRSVi2g57lHQVFI7FodRha +lpkCEHcMmjFDIboDRgfFa6hJ0cwCTpsCPxTdmUCEHkcMJM+fY4HsiSNaFoCohz8SQGZipcwlUHcQ +PbwkhThcDELGJ1THMCsT8rjMk7CEIloPHso3xEQih4UJA5eNVgQFXEZJdbCk4oR3FAPFCVc8LkMF +FMHRcCSAuJFooAAxC1iACMiIYBVBKa0Tg0U9hhmHQ0VcLsikyfBxhkZTpgQgi+FAE3GEA4oGhBQn +lYQAhwd74RhimaCeAAjgBcRFsiRmeVrKcwMGlpRKIIqII1nMDII0fQ4LIqXYhgRVgKxOI9UWZ2Sg +CYFH3Aza8Qi6mBDRoAFNsGgasmZjZT0v6SRSsyHFpohP8CVeD8hMcQHLJ0HkMJA4Eu6cXP6DkSmK +1q4VpFRkNChGDgfEIZLpQoIFVp8X2zsJyT6R1a7EpICvVIQm4MwxOmVscsB6p7AhBi93h2MEMgXx +LLDN8TpLI1QudKewYMYwETZZJI8xJxkStarD96kXOQLem87HADozQamBVejS9BsJOIBYqLfa3unQ +i90RJ1ja1ioU06iqDRx9exWS2REqG0C65qZIg36BFx3L67kHbPoRBB+ofs/q4/bEmx589IBbpQGD +//tIwHz2jgyfIHJB/ABpBGaKByrp89rFed5LA67OQpj/8eiewY9oiJ/63+gwQuXDreOIFT2U0Ir2 +FDhsNIg0sHKQrBIEYHFBQMDAQNqPli9r0P+Q5D6kVQbSv2KKiECH4MwkjmUpLPo4CstVYIQi1cEo +/5OsTWjT8FDY8bLyEMAAkPnGA0MbMQnP8YCTEEvS2PRm5THpf2CoIuJ06HaIilQGxhWya3gGMh8S +aXwcjQnIRhorFOV/pJkA/4VCU5ZvYDQ0UjBA/yCxBqQ9yyP5IAtneVD6HxJYBsli5MXBuvKS9BB4 +fHkAJSJRDJxkbHdSQM5hZ0j5n0ap8axGTwIXkEGuLzDDBQQJuEs8abcCW1S+h0P3Q4IrYv2L7BhR +lm4MjBsgl0kUxAR2eGncgepsKP+TiITikMkB9QP4V7ZkaCDC0XdxPoEdvzhQlVqjQx6Z/odsdVDI +U4NEzaiuJR/HbYEzTWH1CIxtrfeWkFSP9v/L/iqykDi43uBfmeVu2w1vdtgbQnk1nI0U5oO1qWjs +nApc3NxUZuQsccVTSJAWo8AqrgKjGqLAbWW1eBXwkqqmrWw5iLJZwkglryQKw6YeMiJEva3HMww2 +l4AdzouayI+lJ8/zNp58QtKYcQoQBKOFB/wL4BsgXUy4XBgeA+fNGsY316EWdXAM4gNRMUNkpwKI +jDjOigQcoY1Eidg+kIiWDDHQ8YRKuTSGWckoEUY5kKiGFsmYo+d8hKOT6I0cnyx3JlMy5Gp3JFnZ +TdMcgDOeBLbNRjFESNEIHIOkJjOhKfyq+ne/MexBMP+HJ1Aa9oEJECi1eyPw/zL1SbeNBg4Ue/Mz +CG2FH2BU0EwIXFWrsMmsB7DmjXivOh+fU/JBbvjXgPy73H7XvL8ekX9lgCnzV33cIp8VhmPp0cW4 +Af6+GNcHH7Dr6hTYGcTfmdl0OhwAYjI+Y8hntXpD2wg+0LTAHeGgI5h+66ONPoDrpTzQfIAfseCR +FB8Fg+s0u204PhSglQcLdXxQwjtYKRLr1qsnUVtu2Jz1AQnl6tO6x/cak//2JtFfxKYE/PvurHw+ +bLVNX+55A//p9wbgdaQ+nY47jdkUpyqAppjq/hcgVgCfaNX87PRaY4B71EY+5iC/hf9M/x618dvA +zmDy+qM+nuwRqc5k0x91uPa4LXw+sWgHc3txM2kkE81ffyh2BsNB2wViekNA4S03mJFbhn/tvBqd +QQsMlHYxN0Ac1fb0HE3CeX5k6xUt/5KYoG0x4Wr+nXqj13ZD+I6r+icxevKHa1aHTX8xRcPpNWeT +6bD/ayXZz6PD5KQON62hzgMs5pYcfzpfVOE1I7/NUP4JXDp5/+s31sa/mA0mvU7zT5fFAhdl6bhy +QtVqqp9t5EK4WGG55a+VwWBaFDxf6jCtvzotdIzXcVZSw187qQg+t+A0qf+4YsTfYDJuCO9vN5P5 ++1dPRjljZzWNxhB4vH3oZl+MO8BrdDMr4ze/gepHMq86nI2b7Qw8uboS8fdnO2aV8yLDFYbjft1K +QJIIfO/02raNNTRAtv61JE6ZvCXnNa2PP9pTYPbACMnkOOdmdsZv/ng33VESoDs3RnUArulKtmnb +/3IasJ9cZzBtj3v1prsABNn6F7tsWwX0Hxf824dXpaDdCTdTJFv/5ms3GJ7NNTVt+998cu/ozLg7 +slTb/gb61lm5/M9cW620/tWjGY6mnX7nv+g4+O8yJuAt/+oh9NvTeqs+rS87jsSS49hqSfsgbjiO +aKzRoenjauHWm+11Rt7a0JseTxtDuOeEmU+v8h3+1gMdjv5GG1sfY2jG6sQIbnM8aPZmQJzdnVW0 +i4Nf52YjYAzXpyg9pe1F+RyZ9mf9R0cWiIFOv/6hiRBIgOFjb3XWeB/2Wu2xV41R60Z5PWnrG5vP +nuE0Q6tCK50YFsozG8BdqRpYQ+8TRfGSWJ33O27B71jpu/ic3zESXhJzfkdrrVZXn0mhA3efTLxV +6SowRMJOrS2WjdF2BmgHUInlAOPmyHf4SlzoK2Ghr3hTHDp8xJmvscNXMkXN9ZFETgw111e0Gfs7 +fURpBanTR+b0ZN3cnKB0Ekz5pj71nuH8PIOMIdtcDzr/MRWFZKPbzqA1/GuiGyrRotPo9DrTv3UN +0CSkCakK27iEpdpZWWmApd9ZfVQeNpGqN2Nr8y9qpE9m2bqWu4WhvRIRtbQDXh0Bd2U8yfdH07+z +7V5vYoot7TfFIbylXEZNz1zS6+aANQ/4pq+ute24UEIeGSmwHRLQK9lqFTfknKernnZx/clNezwF +yrGnIwJNW3MS1itL9ImqqSV9iO9fQIgURBHWtzKOifiI8FJMqEHfEKCzPtW7FkR7VS2nJwYjYs8K +tHbaSjPlwIj2va7f/H9Gw/EUmkHKwgUez9qtzqzvvWpPhr2ZlC9JYI+mNcBnI2+hB102eKSpMm7D +ayxUy0O/DKySIzyqt/T2UR/djKJ5NBkN9ZRX73WkyYgyi7dGnaiWhprD3pjAiDc9mw69V/UJcMEU +eUjgIuEd1Udg/JNOf9YjJIK6qglvXTIUvU111ZV85kyv3W7BoOqNaq3KnJUdD0fpcbuOL1IwOHkB +9cQxjc60UZR0uA38wDsO2l9UNIg+Q/9Rl0aarNIb7ECmZTbOKjORFy9bH/yoT1T1IPA8y1vO10t7 +G+TMZMwBapDNbG93MGx2h7Op9wMfsLRp2gG0BW3cBkyBlsoNgIGqCeJwBGftyaeyaGhVCKLEX/AM +Rxh/hkEz3g90RstdW8U7ZynNOC5m0xGYlf1IGAIyGV0DI+i0AGHJaHYchYpmxxUhJufYVpkcrVkR +xLHjH21vrf2fqTff6kzrpJ6lVaFs5PtyffAxQ2JzOJLXW8ncL/aGjXrvqj2a9SakhiX4pTYcadmF +eIcOFxJvDY6YJkpSbfdK9SkY3jEM/h3nJgT1W7SEqr8HBRXZlmxQgxvusFez4WXQLgoxvgAN+DNK +sGOgmz4uzHo9GWdAdUE8gLfGZaC874oIbUK/tDmEByH+AxbtA3wjizt1fTVfjBFdRn604dXIXoD0 ++qBpwqjkJ4BJe51B2zsFi65XvglZnsNZXM7qkBi8ZXx1o93ARzIlDX+0xyN4qHFi/4E8iAm6F0VR +YDHihgXduusvYCAmWL0p3tVHug7Bw8rHu1Yag2e5Wk4v3gFx5ytV74XN0Bkv0CMX0pir5Jgpq1Y1 +Bb3O00ADianBwNjXsBEFzNtTbAaVtPTNRoAJ8fFUzbQMzeDM6r2efatJtzNqABrqBm2HNgYUMZ60 +4RzG7rqVRZKEtQDgFeAZNIetttW85C+Iue0pcgteI3EybBwP3odelU2JJcVLoVtRrT5Ca25YLJo0 +DAZDlaC9nQFizeGkIy+Ks7mEhmFjIhloDEWmspIEuLKSAKgpVkmxG8z6GZL1NboUt5bPpXvrwG7E +ylWnxDSKD38Ec7xgkAx9hJSE/iM3FiNEtEsc4MbWSDC2NWVKEle4mQ2ytPPGzZ0nrkUx/soZxw6i +QEkt8N62G7GbTqs9jJ0NgU5uP9szDJQVbQRZg1cDS06mvWgLd4GIWmZfB36En0nt1Sirm29GrT54 +3Ru4HtSo5Ro4Pg+pfEErdwmRDUejcRSFTKM9mJDgquV0KNszomjfcqy6+HGKtm+Lz17o7AnNGsK2 +fw2l0mb2zT51zUxlb6s96XwM6kYz1VRIN6SzF3YQUcMhPEHgol190uhM+/WRdVM4E7yK1sQB20jE +IS1KgrdCNHGkKs4xVq3I42QBwG+A1Vvext/e3Bh4aGN7uoPfq8Rss4zqSGwW0SRCZGiE3AnXSlMz +NiPA3jgK+dFuYONWdDj+iNoOXmojHYsmSmvoW6FSGzIsx3Y/bEaOGo168oEFM0rBbZqDiR1KQZsp +cHFkp9OUKj/63ehEvpnLpk0DOgMObZrj4ch6yO+DabTV0yyJaZvJrCHPijXraQKkm2Kjm45lEm10 +oNaxbTJof9TVMIVFo+YQiICBfZse3USxSYOC1bWbfNaBBdlWlbtpK+g1DNoTvW4nW/1nFNX4PmbI +Bm2gf2U9cNBgOGoOHRpMbKaOGrRmtqaRDQeDz+0ZGFjDAB2zQdOVQECt64OBHEUz9yFQKycp3OwT +giNwHa1GvTilFjgoLe9ToHp7UXkKen8wDmZKH6gGQn+YKSTQBhoanYGDdsPKZawzsKzEHqBaeDEh +DCna6DjYUjH4G+iyNjxO0UqYDMfQ4DPZR9A3fAekJ9+fiCIlpq2Qd2GMmBh6/QFPOY2cpbTUzkay +IinVHsB4hzvTC4s1RC/qQrr5BizaFF5xKY0lypjrcdgUKHxo1Gu1qPnQofvbAW6gQ7MxcdWfk8iG +QbNGfTyxQa4q/4EhRpiWLhor1qWLtmONgeDUmrQwBcvm/fq4O9GO2kVjZdQu2hKjdtGaHLWpAaiZ +42zSzg2bKAxnw8dYr47G70PDVpdBm/WhDJnYkwXQVO2pVg0hpWamAMZ6kYQ8RbOWH26EF9RaWHZN +yRiFTTscUnNQIhqON1W8WNdIbvtkYt0zEuo4/Nfs/20TOSIaDvHN9cagTlpuToZ15o1Dkxtd9R/t +M+A7dEa9dlobg4plOrIfnq5mj4/jfK4NBRh8yR1d7DyG9m8P/Hv1u/AJu3MRyaTGxQ== + + + /mfyY7BxUtgIB/zZTj062RauS3lhK5m6Lh6ecUfJ8pP/LDWeNcVCnjmL+2iO26KoSe4r9xGmtlN7 +L9Hd1H54NElNTpmYx5faK2+M5UYn08xH6bKc2ufa1Wzn4LCZi0b9H4auyq170J+YK/iS4kNxmvt6 +znAPkXC6PyxPwHSnn6FDYWtWyHHbt5mvnv/W48u9UycNU2DbYuJdvLl8fErXstEb607Jdsnn1H63 +8JxKTqL9UC7smxUCxda7x4eQVXh7vZjl3p9vxUwv1btLvmc+p9lP8YHWoONtJ9eky9+p/SP/LYYD +hjzJvny8DMGvne/ccet4IxOJf22nq5GtAR7DXb018/gSX4FQM9/kLwPZT+51bz/tY3dCmfPwWyiV +9V8Xsu3Z7uHNydbnXrNZ78JfnVD+vfyJe6apWF0cd7bfkp2Xk1am5zvyR8ahp1m6XN35huMPpvZO +PlmPT9i7eU6lB01/P3RwthcT+08HHVGMTd7Z9Lh5TIe6SVqB2MydTG4A2kR/W7xlqVayk43VwfrS +ZweBSLid6YmVPp7BfdmXyh7vb93mwwl+Atbl+FHYOhSzw5fQ/k3rMck0tp4R2MOBD0zoUNjdgkvy +KNwKlwOIp8NMNyhEJNK8aZUp+nnrLBer7+8UNkIPY9iLAF+8ICioicdHNTaPOfQ7dFjYl37t3+ZP +cfNsOP+GgTH3zDEg3TsqdHiYDzO5o48DCc7twf5e6+v8Ba2kMmAA7yLDS72ARpkTZQDP6gDowMEV +bNTm0DN+I5N7RajOtSdHnPAgfDXTtdxXKPceO/3O1+v+7YzQuL7cL+VeD9O1z+Y0XdlunqVrDAtW +Py0+32+Bb1oP+bu3o5mCIky1GjJ96arA4r3ouCQv2P0w917NtxA+Adh6MHS4tXeLVwhC9vjyr3To +JsPdnRRS4/HnNZc8uz1CKxTnO2MBLN5uOJQZJl70qNROnMS7jCe8sBCUx7cXOpgFCrkenaFO+CT4 +p0h1MJxDoTFM7dWmm+nayXRmRKVuJQm8ywt/N96Az2pAjn1HO2k9nmZXiXYhsDMKZj+Fq4d8g9rf +zbXH4zDVrhzsKQPB6FCQUS6mX09oRG37kbcC5NTTaO74S6xj3scLGq9+90/TFy+Zs0L2/SRO0aeN +ViHb6t8j4WmyBsVMTzi4VWEL0/LBQ6ZU2zrQjcHjA6NoX+SKXV8bdHW5DyUMS70nb4fG0erbNcGv +8LQ42mwkEqE97lyHkb1jYIlkO5OOAKVl5LHCBLeOS+qs9trJnT7g5KsgJK+z0MHJw4nc6ccTkGMs +eOsr7xanr61+uvp2kot1DgIFDODdXxLStbPhR+qmdlwv5OOXdx7ffojKPynoGOXDw3OmsCMk78Ca +zxL5Zvd7R+4AMUivjgXzzqO/DMTjgT991Rvtku0u6yUg/vycePW5G02f3lcHHh8hwuX3r6mauHOR +LX/XaI3K2N3Jvaf9LxodcFUovAY3PtE0gMwdtAFL8Q3dW2n14fuuRtMQX+8CJVoc5sO15gHA4uUt +YOy77dDhgcCit+lqODXIdjqXLTi1Ddikljs9LUUK+3k+iN7CuXzsDnDz2lnKl+mdUFG4Vo8qf4rx +o84ul7ppxMRK6eyKbrxcp9mdje08E9x+ydLFbDkFfx0CEqcPqHYjeUSHA9kj5dmhx6f9BrdEz+Cf +GSgUs+hD9KdQLTOX8O0B+lrpIAufZTCo9H6kIPKR3BXz+jDKwyb7QCbD5vBBTukqAxudq3BwL7A/ +LYiUMvhD5Ys91ASOpoKGhMYA5gLgpPFQ4DTxhOGgIHZq8NkeAqb2gkDoUQSHbNYp+lPCGIRY1SIT +fbMH36JpHKmoxI3h4DAWBx97lwoKqgifSi/7xFzUxTu0XVrXC6FbBo9PtxD4G4gsFTaaBsKTFh0H +aFbqnwiU0nNRHYPHp13LQzOSs10SPGT0S5kV7lT9E9OYKWG4IAvYuKzMSiUVPc3iuVgi6wDPFHGO +jI4Ddc6w8YUZUnWc6vEpKDzQTVPBSVIL4kg7mqz6LXqr61RaF5XvCIrRrOqhSrWoMcRE2oRV9pQR +VhThgYkUz6WA8IjAukU1MQZbekEoB6sP8ajAPjQTgGhqCmvOR4ZoQTDG9pUO0BivhDgdvEC/MPqV +mYrCTfQdCPAvVtJ7ifQgffX+cQrMytORTmGkazeng0KKprseX9FXfAU44QMCYZvMLn37hddpbTe1 +R1U2Qvmbu5KsyiLbhDlBWAV6L4lsBygZOgbYfAEqOES4ZnQCOCynGcEPTL/go6U3Je49lAtptrt9 +gvwA7YRCyEHw+OLDE0rMR8LvXO706Jsje8m8ttNXg+p1ujo97udD5VhA+7ZXSCV8I9mpuAqqzhfu +4Pix9p2+yGYq0IaRrKu+BjHAA4VWmHamhLEh7jWvr9Li08lV7mS8+2YGIM2Xno/Tp7eXwE6WRnbt +6xYnF+2xZPqVhQxQ209RxXeI2vsO9p4DtC5k3wECE8Xr5/Zp7v1yUo11Ko/AbM5/Z7G9zTKbj/bO +kKUr5PGRzpBKoXBq2MO+S18Ucl+3r9nOlxDbe+/7PoB9u0sDnBy+ieJVawgHF1HtI8mMrfaeVVCA +kiVg/yTPQthV4gGHuY9I8Ah3cMkevgFD7cKf/QzdZ2Odw4OktFZaPGl8kS4g+2hBdYSBHCPXoFJC +6AedslsweFDGNC8RJzEQK6di5xDTucoAlVIPeBaq/a+1/omBJrrt0yyYUCtUeHs9TOSK9+I7cMfz +DMUUuTM92MuN4JPOScE0lpe7fbvMvV+HikBOF3JMsJXHHIg8VagDElhwvezvdK34Siy8PO9uFfKD +2RvjS/Tj0urvh7djj3GxWT7JXFZSYC73/XPJwZ/d+9KX59WbQi7Ykl+oxD7cocTurFGhyqeNkeoj +62MOzEMXrEv282kjGTosvr7KlPUcBSsYPc10z0LAtK+8qzybhJGWl0yXOdhQXyiBACrZ6vcoqETO +IbYf1GgH8PhM+l51z9hSOidZdxS9DB3d1L/lDmpiau/0fhO4j58bWtgX6Wqx9QXW5WDMpK43EmgN +0AocBGZMG5LcO3oB5NjR52SGFjlxCYQq6OWlDkDUJvnXEd1I7V37o0SQjOF7m3vvs8pXunZdvwcd +JHtU4SnFgtGUIop01gcwPL5ErzB8t6IYWmlZk7mXBOaSe1kyomjPvxQjpHdyDa5ddeReYiCQez8A +JReCld5eIcc/MKHD++ddI0QXXj4Btkxwb6b8+onwCdblUDiZ5aJXrUgqef7VVVRUTdgsDLJSaBAQ +X2T0PezkYnd7KRmf/nbss/3yBvE5kQZXzB1IEvT2gIdqnsn0Lw6BFtMYHudc5mLGPgBUX03yoV3h +ndBYKt1BUhK2t77jqeTtd2fvvdT4SCXvCiQoLLGx755oeHxIY++H74USgk3obqklFQB++rQJ1u9h +L9ceXZSROSFslbkt+IzJndbONtXuxZteuQYU3dF2/pUaPOfea7l3jy8fHp7N0nwq/ZhvVnpBnbkk +RSY/fF0gUBOb4iR2fpOulVOQDRMR4+D3A6lxJDFLV65iz8nOS/wdrPjtLlgXwrzB6uggBiimvAsM +lKfrwuveZ0zfKXP43QeL/LGR+j5qttUXcK1m6Xhj9BGlSzdh6RlYYmCP1ba/I4XAMBHUvaIb5WNG +BaHoVzjk80im16feAb10H4TD5MV9am+UoI1Tk9rBdQEtxfjlcNeyEWqSbLUa38YmD5EclXjwF7Jt +oZuu5ep0phffilNM+LuTSl5c9tCCERLGQEVof+KgefcImCZ3lr6qpb6NtLE1yXYOziapZMFXF46E +u2L2PHtzpFiHgqRfxP1O8zF33LyqZLhbZmpY+JetDaA8qMtC4OSonCg9FaaSESwtYhQQ2qmwd7qd +fs99bD1zYnIUzQJzqLOrgkJWHwT23h5ConvcD277XiF17+cbsYeR1vLGI4vXdrarhdetnSqYX+gp +//I1baIYpBGfxWm+kdkNeHzJsxD7mK7VdjY0xHJ0rIAtS1EqiSzKWAjLfz5ZEEhpq5BNPwMTMXV8 +B+RYLlzjlZghHm2im87X0mLi6iPBvWX6YJIZyrIJVAR16CoFI4NwTTHPgBdWuznqpvYPR7dAV/YG +1I4JiHam65+eZLj7zevSwRPndzVTyczTQAlEn2Av3eNz4H7khyTfCakh1IYnMNYJpsuzW8BFeEio +IJJ0fOO8ELyvTNOn93SL6PTg9LyVa/UTYXLPAowsAKT8RfdDlb9YCA/fPnmCU5XdCyxwQ+fDr9x7 +4qSXa+x2fIny23i/kO4NNlE4VEcvYPXhVl7yPBt7yp2e7sewqcZcViOFPP0eKCTTV5vygt4GgOSv +xYSDQvowI/hGfO643vMZ5E+vEgS4eb6CsjSaOz3ezAJpqWWg/fCscl9IUdNXsOaDRmFjN0wDF/Ya +fpNgAOewb4ANj+IEWHY3EMTOpVgTX+S9q5RPu/smIWGvEDjupxOfT+dbhVzlrFrwjTggXG7bHyk2 +88CpvCiZQeCXamChPby0WN3KpsH/Sqn9SDRo2gtstFOEweIn0CjPGnlsq5vmApnrfGDSeIaChNYj +i5qEH9AKAMaN3Fv2Ui1nmOB7zRQE7T9pQZf5ND38vNglPSc7TkVkL3t8toSvBN8f0S4AXCsmV68W +n4q+4nMc0Et3RjSelgvPYPVT28gUQXuU0E4WUme56MXnPkG1h0J4WNgNhgVgBnE+4Eqkemizca+d +aN5IW3DCyTU5UzIEccQU9sKbqgNvoDFSbY9a74XAaTFBLjKi1cunLfiil642Ru/YW2SEzY9MfzP+ +RVhKqdLoW+ZKVb+gXm7Z/bq4d3lRSVdn14xRofDj3HG/MwFqK9MHI+wJhbczX8LaArhI7l8BjJ21 +ylvmyy3bFPHEMNbMN4aliEO72s7tc77+dryZ6Yd2CAUt0xhhfRyd34GV7hD79jpgBN8ZZgoVyvsr +WMTS7jcwuY/PZY2MxOfX2H9X2JmN2hlulgGeDvC0CZ8cNekH4kCCRvO9zNdXJZU7bl1OcyeBQAFu +gx7jfaN0r95HplF+unO8Ifd8MgPWuNF4LZtZsJIZO95qQboLpy93X4GGbPZpUhyfzKbU8WNxX8cP +0lyAgdKsJc9fGrPC2wvThzTGKpvpDyQpHbQzhPiHfI7x4KO6j0A53AVy7zujLWF6Oj0ovPaiMU0v +nZfwB1iNya6YfAlV4X5QSL8ubHDAAoOAq6c5v3+YoG9PY+l4cTKFxwaAQXdcv0tNgnebudOT5+9c +e/9lU10wZPO/cUBFv4+A+HiKCcnGxY7br+G3CeBclUqF1+lzpJDyt2vazTgBMQqWMLJjUAGqORX5 +jIP+wsXiQ7z2lG/U0re5D36no5NeiuCSZZaipbGckpYkj9bC40NbkNnPx/3vQrqSGiXPJrOhNjQo +CN904irXzNa7ud1OrCnus/l2/uH9OK+EJ1GTKuD4agHqpno6HoluwlhIEYkthLHKgw== + + + WHsrxQq5WRptS14Ci8MfyRUG6TOgP2vBTHdvPyIZKDqIH0DAVWe1lnpwA0tDCejlZoYPFmJAjrWS +uQ9CWkrva1sSliXcXaevhuU34fA72CVdZojjjH+/nA8/Z4C/LzB9NTiLkAV071MHYOzwe/ck17hr +XwFuOywV719Hb0hGKuxjgXllcaQ44QEQ4JHCljC+LB0B0+cIiOjT7wwakhwdZS4DU0hP+8J1pRUD +nHodLvjoAPCbL6/CuZONd4qcAW48ooWb7/c0UgkFX1lM6mArjQGNFXYePga59+FzCIWOTOPXkqjP +xGF0uFacRUcv6dOHYFxdfXgEwJ9vzjZf4hcltpZgwyd7hdfwTVI3FwVOLT/UqW0tnLfsx2fBD3e9 +45ohKwBGQjE9/J7E4OmOi9xz536L3K1WBUDypH5zps5f40ZfAvv3rOAv+gqlvuIWAQfpdjuaOwlt +8WTPvel2vtkIt+ApglvmSHra39yBC/8K7bV9TaT7WUztvURm6VpWfAVeZwt42LFIPT1Mtwvq4DAU +NpDeS+09X2fEwXGNzj1/PDPA36/2UjEZGJAXlRbgv84+mLDGFM0XdorlkXocKbqxk7gRhJPOh1CL +3D8w+Y1IJvY5aNW3Ex+3YzDWEsxAztDZzsajH/BLaLf5naO2IwOk3vmN7C4NfIL+JjD3rxtFGDn1 +0ez/eaicsmNg0qT3YgSPHE68OXSp14IZqp1BtzeZRpvDmXxQO/D//d//z/T//b/sTwJLn02a4/fx +t/YA4PGg64UVUoiTf4F0a9hoeyu5gpQ2CA8RD/Hw9YmW5MzUJDhRTKiXnOhaqdcfOKblHfd6M3R8 +eDj2EgXX583IMz0JCicPZviK7gmBZXTwTfg26Znar13eUWB2dFPu+mw4GDY/x8N+W+3/tCNfP2J6 +iFf+9AIlohXAt+nx9K/huJshzvOaH5K161U/atNsD/c58BaTZtDIEdbgpQGDaQVnJcClqgx7HTnN +aL6Zl9UMQ95yrVzca2E3aEQkWXTQF55ZJgc7f76JPBM15x9zmUqxnC3FwgVUlw5dX5NuDH/Y497d +fQeCE6Nk1YPbKqU6pCFoVx5gsYWSLY5bgAI67x0ll9120rCykzW9zkcxV+pJeYaxoHQz2eAS1abY +km51cNOrdqrzdCrfLJJujoeN+rRc/7s9dpfF6MCdElm6kiqmJDLfAtXssvfkoUrDQzds6ZnSBROY +XoVhh1y4LFYL6mZRCGUG73wBS5Ctj/DNLx25f4Z35MAamHOVvFDJGq/EtSnW6QGO15S4pJwrnOrz +t30mvNy6Oq0D+2psk8cpT6I27vTPYNaKdSKmih/DpXW0rSqszhqQ8IaD6RXUCW5RWiYTjyynWBvX +RyM518N+YSFpGdbVngwyZKaUZVNJxdQMV4/bEaxyf4fzHK8nbZRAUiOSewO1T0DwXtCbd/rZ9kpZ +5N6JfK/cX5/tgXeCrw+sD7ykjQf52VufwMeqCSpfYBVFt7VNEXAtsL+HM+8ImB9eoNXbmLVQ1xjc +R70zgLeIEB2FvaAz5dMBWFJYmnkEbzD3dtCVI3Vvr/43vFcLrCG6GxZaDJNZ8xMO73iQQzn+Khjc +2wBQzQyMbviudt+ZeGeD7gCI86g7PgKgm+POyJ0FWYQ8W5+2a5+zfmNQ7/Tssuc0NOxKxIKxAGSi +yZPS1ZbigI11227cdNp/uR0KoY7t5opZryNfkuPET6ZqyG7kQIARcsZRt5uZ7FbZlXpZdutwBYGi +OoDqP1ayLBczs9wpNrPZ2KMAYxco7LkGR1DUuW3Otao90f0nEGvGe0B1H3CoBylPUfFywUNsX2cV +31ALBfoHuvS2UX3Q1t3ZVL0pQkWhDoJRX+QHYN7k7QbKXVjwEpuLAXHHpRaa9jJUVn0JRtzsaNIj +CZBgmZQbqsiLt+CNi6ft8UBrrYEX6FJR85H3G4ABkV9k7AnJYHRfG7wK1HQCWINOlbnvGd34PaWa +rrbCKlxhXHkVIkl+50ErTz4xzRQMHfJvYujophGjYqGzUOjoc8rCXwy3f5lklReXyi/0Yo89qk0z +ufdEsVvaujqo596p+0PlLRM6uBI+N4Js6WAjEvNfeXwbocPu/kbw/CGxEf7sgFdv79GN0CxZ3Qif +3eU2ItQZQ8UO7gOoe34jG7zkJszkDAwu1+WOLt4O2UycjQsPQv8BZe+gI6rqW6r02s56fOPx4UEj +HR6dn6ROE5PDeGn/NloYPnA3+fHTA5V7KNzXCgfpgya9mxYHUi/s9mUoG9m9Av2VBavp4glF2XJi +G+4j6RuVJ+Px3qQGOgkfUzGuiqehjmwSL0xvmJdhd4dq7dCo5wsV7PiZmuwD2PFZ6LC4sYMmjtYl +143GJvEiF//e+wJ/Fnvg6/ucttOn8fPZ06V5p0XxhU8ev0RNO33ZPi97fLpu1U6FzmnRZ97p/kZg +PKF9Y/NOK/QTt8kkd9VOPT6124k/fBax6JT/DNT993nzTrngU2if+TCf6WbhhfP4tq5HvbLZXKlC +5jRl0amwtT0YBw8sOr1/oQrv51W1U5RZq3Rb3NjfoU9ea6adFktMzRK9zMNh7Q11Cmixkdeu6S2g +5KfZYRl2GzSuauCefezRQdApNzSQUpnKSJ1W/H5dpzzffx2pnaqUjLt9HT9/DmoWnabqgljYpk07 +fTl6u7LqtOTxbbOBvSfzue5vPE+2PttX5p1eZoOH39v9slmnob1e8lDtFKyLlpR2jx5SF+adcvf3 +VCFBnZt2uln4ELev+syFWaceH1V4fi5YzFXY8nUHZ1mrTutUMfx2Y95pkUr72wHxHnXq8ekRPN0K +H0md3kcCOgQfnXMHEnrzT92CptOHfaosRmjY6a6uU49vsllqD4WreoQB3YojPf2WHx/qFp0KW2K3 +VXix6jRHne0+J1CnaNddO9fj72Tqa3x+Zdppdc/PWnZ62q6ylFmnUPJzjxGq+hrcNJvrZPO01D5/ +fAgGTDu98Q8+LDutfl6+NVCnHp9xro9F6uZ0tG/eaZn1XRdS+wfmnY5ONs06BTIZdnvzWtycWiD4 +8YK6PTrNmXd6dph/fbl8fjbt9Pmie4w6hfrFONeve75VsOj0KU49T3oR807Pv0b9i0Sc1XUKekHd +vh5HBpYIHvuqoQ2LTu+vqXynf2Laafw8srmReo4AOQa6TX7rmWb2Kr5KnTbYoI5pgg/l+i7qlPEf +BkramZapt91kGnYaVjsFvcBuAdivb1noH4z1nU6GOwdSp9OjkG6mG0/1xyDuNHNPH2sFYXg8uT7c +AL2AbqNGqXQcQXMFnWanBlFY2hRwp0f0aUQnCMMj7hxrGnY7mT1FncJepG63x+N6YwA7pXSdjsfp +9lCm35MNXacT/ispaZqj5GVUh97NYfut5pHsh3b9VdAOqnS98zJMWr69v6T7N1ZvP6nSm2+mvjVI +fiB6czsWX4M12All5XF9tUXdWyFOv9akt5Nu3MCVwuBz887sPRaKlePkk+XbOLN79Wb99rP+4lcw +ZnyfZnYempZvy6HBEWP9tnHxvqe+1WFM2LrYbDZKFl/HSzul/esJfvvu/07ovr0OdWTj9J3eTBow +dt04qQ7M3mMplwt1x5Zvb32N2Ib126dc8kDGmMn7N9+LuG359mtaGZUs33ZvmMyl+taAsX63cPhi +9TUY0uUeb/n2hOEO76wx5msOGtWy1dc7GzvHT7uWb/Pps0bb8u0Jc7RJW2MsvcFsB5MWb/kSlT/Y +leecDOzp3oZql5Mj6W02uq/nylLtrbibVt9zEy58pfXAslTL/5iV5M+brwffjiR3tPDKY9GTGU7O +8S+NHGOm29DDzG5EThL3wMP8qsF/ovBZYSOcu8rCf26R/6Z4b1hGSP3VrzKy5BtvMv6DSkSS58DP +0dhjh1usH3x40ke8AT0dgiNiZ/GBH/ixdzMgWjd3QH/v+0p/W7HOQSMIpNNmfjx7i0Y04na86fGp +3SJPx6JTYQv6OY/mnXL3D5adAiXyRevsMXKuyNOx7BSqvKZVpy2yU64KfGSi2/h5pkp02trZ2VI7 +Rda/0imrQy+0/pWZFnuaToP3yHslu9Ug+ICx7BRZ/xadAn8QWP8vaqdgLpq5Plt2ChA84aw7hda/ +ZaceH7T/P83nur8Rteu07LfsFNkUaqeQ9zXdQpuiplnVdkLuHv2SFiKYfWj13bR7mfUHJO9btBS2 +vl/ydxeO7fhPie4kaZEBc35KS9LSwLpvgT7EzhURoDkszMaScNmppnQcH+tsJcPqP4ejQKsmOetQ +JmF//3AU3B8pEAMIxGGitP2FRnGYKD7mgOCq52HPrCqapO4P8z7pn/DZUOoAmcByB4ptCcYDJncw +wo100Scg9jKxz3bOp/xzRVrMUszsQmmcg70Uyem+nRxJMSUw5OsKeLADDdrZrowdbLdL4piYQWVH +i0Al4gYGTJ3wPh/6BxLkrdZLMhtUN3GsGxQ5pNeZH5DuWZjxH1FEHE0XDkQoB9LyeZY5dUI6/Eca +PHbmTebn37Ccn8enzhD9Y7mC8vpVN53Xb0uZ365EY2YzhMbrtQ2y3K/fENEn9ixcIssGGL2b+SpY +gvK4IXcZWXuRuShLpSuNRsaUVXz6nh/zpngHxs2DRMlLY57JPCRO7PHusUaWVvQEjaLnJa8VPayl +6PE4kW7+6XhMIlAZsgaBO1j0mOPuBd5AIyPYYjzhfBj/I+GOHpjj7j6yYSm2rbgSxeNMp3a/Of/U +SC2GJsce3dTOnFBdPN2RdhNMB5IL6WZFajFiVu1KdEdafYMYzYNeboZzTchMwgDaAe7cHYFbhQ1J +On8L7oDB3eUslik8ouvb/hIaA47zL4gYylpLfw5DBzLlEJSMgjrmwGi3wMxAIbwTuzy7Rr6rF9zy +nT3XAV1Z37yb2a7lFh2+psPwn8cQsUlhIAsgGQP5U7PlBBgjFxT+AxZUDUQbaQPMT5GCRtq4uFSG +RIwLzWVaNB3ZYbExsZpkimpPr2MGK8y4JKrHdxYyLkmr6GSFuRU93fjE47NUTC5sRrUxsGYep5Zq +yeObZ32LECel+a0nM95vFbVy2gRZZ0NV8doMaXp0YqkrL66k8bgx6cCQrA06eek8PncrCLx8W8PC +yebXrODAZ2tYzLF+xUpfBYUpeQlg1YGLcQGudAVMq1DmHZe8wysBu7d3YuaZJGnVLY2x1/EKMaaV +aHOOa6SNw7yJY4PjOj2cLGgda/ZfwHhKZs6glUFrqqCZzN3nhoMcIwxsc66cHm2ujCszd9/b8znK +eD/WsJIluGVSVnEDPfH5sXO/uePW+VBsSz12DieKWnYMI5gbhiWdUDDlF+dlOpzYu3i6gUiUbByK +gxRwNRCdbbkYThzYnhgI9pFDFirqowRD149z+OR4U1J7yEg528M8TxpRIqANfh1Dms/P0YFFUANY +ghs2Noyp+LBgkGN7s8Pjm2dQWwsKAK20hCz3PPXZq2W3AuBYFQBu/X3r+fldoNzjDg== + + + 6RpbwTmeobfk1Vjf1zHc1LtdBVHlpnT+eVJUJYPmLJyp42PhkwPa/2Td0qe0Y2WHLPcsbun2IC8J +IGtOFtcgS2Fx9AW7nejGtAx+AueiZXFTr9s5ugSodtNdhMQulnCiD8nqR2MXktVFSPonWgvewil2 +DsmCqRGMJK3+3GGSE3gu4cxteEPxkvRDOZlp1fIC4Q1AB98MmhA6qWJYLfdrpdOpFnEfj88uStc/ +gZu790vFfSBanGN9OlFgEa+B2BFcUTIhNzWRhpHGlE7N9KY0oAPrYKIkk10Y0xDLp3pTeh7cYXsM +jcdnPx638QX26Fr06yiC8MXmUoSnOkt4MX5JXgbtp+ZM56eq8lP0ywLR6NGpXu9ZTcjjs6F0QDta +pbeIADi69vEehzV3h5hXhyC9R6fqrGxZgB2donPSQ6Qti+dCqDq4WeUnz2/AWYFnbojBkusISs6C +8UTni3kb53xXNdN22l1R11uQAJhVvNUs2oo9C6t4KwQ2B/OZ+0uAaTy+pTcp0KrZqzyPazhaR3K+ +0Uh74hjOshyIoSjepApFlsnzwJlf7yn+vgkwzQ7hfEpUuz/oR9ZFOKC1OLPomOpKdhiy6PCpx+fM +hi7UDQTGROfe47MwIuBZzl1XqCTMz+S3RovpJdqkGzRItElXv4HnQqKZRkiyADGp72Ul2rUq0WTv +dR4LXg/MWaJ5XO4gQWCLSzSFK4s3wxVINLBqZhJtbt4HcOaXaIbYBYazvESDUJbfe0VwbHaDwpmA +sosT8/jMrAGNEroZ2nnQ5NahuY3Cha+05y2Bz2OIjcNny27Ayvrl3f9tLYZcWmZZwOcXUzNmxhH4 ++cQsAHazMZeQ9fgsxeyCpx+0zHyDfGmNJ76IgQJWTXeoyUrCOMNxZ9pbQkFxGABn+SMQCIqFQ63b +eXeGo910dxleNtlNQMBWEavGuhDMLwStC602BE8jy9j3BJHWN68mS3t8d7duo1lE7MJSG97OZd/b +x2AhsOXt+6dvM104rxaDqzZ/SMuoxSCcZex7AoqiCxfXYgiOiX1vBkXxXi3guNWG9roQSZin76W1 +oUYXvur3iVEv4OlKjiNB+WN6DkvSlZrDU+oxDEtb4HVssyQkKsMudt/u7paJVevi/ADYstxNjMuE +t+3PWttgzJW5K68k7MXKIwJrGXXF5za7p1mAz5uYTeTKxXE63ZAsKQKd7XFkL71iykYjBrWUjcZc ++ZUuFBOTuWtZHs+zPrlm4e+DkTHuUOmCuRqT1Z22BcAs926UaI/bA/UAGLu9d1peRYQEYEycz8Sw +OIMIV/I16ioGi4FZMPu97eFbTBEeOX7valAuKcLAXJJGxqyr6rND/mxg6llIa4Cy5SYfG5HB5etG ++OYlvxFJsy8wby5vlkGHb25ZPoeO1GLGDDpdxtDCOXT2GXRIJq8gh86yU5RBZ5ktOGcOnX0GHZkt +uEwOnX0GncbqWyKHzj6DTpMtuEQOnX0GnU224Fw5dPYZdChbcAU5dPbtpNzqpXPoDIyryaBTPIsl +c+jsM+iQPeacQ6c5kGyTYVbxF8ysbesz8NaZQLrDLi6GZBrpzTkf3N51ly9V0PnICx+GzemtX5Pg +gNtI72NOq+3nWzpijy+nP7CxMJ72djXkqs0VVXR8wE0yWPurfeMURNHu8dkBsz+H5W5+KNbnlDnn +en66yJWRX9wjPTb/kCwyHx0iV3ZDMkuZg3OZK2nOlazJ646CqGd75kugms51FASfHzM9DDJ/2Ngq +aIxuBls6XnUf2bKfmsdlspv2JOS8gUFEyWDNl40Y42Q3q20brZfklOxm7Z/abzgQ0jJvexhE45o6 +uSF5XTaDJlPYHTDtESzauGPTYL6dMh/dyax6YS6nF3GlldvbYK2PUM6VYopy385cZh06+/YAWWZ7 +2Yo9ZgydOQUOu/GRLkwCvr02PTS7wI5V0dLssswCIywlfR6Yo9nlOo9v5nQGfo48voZT/suWJmhl +nZpmnQRjb0obz8D7Dz63rAaVMkvRtF4/xzPwrk8RtIraCKbp+rnN44uPnXJi7IhBezodAltZhuhY +3fmwykyZB5gzxbvHmDbAuiTGHNNE3U9SlWgLYUwb+GUyd/cR7UGnku5gvUkmlztb1hDzNbpZCqtf +mcct7fPldCAsAHQ3tRrZBMQb80LDf95subvkwtlTPD4HZ++j5NrZswKgP6O4AAinq1HAOiu3arhL +lVtohV4pZ/0imzTmbAFT3JyDDB7bkDTMSrNw4gxkb5cj53FIc3ax5YkmZH/licfgXtnYkcmJ4Sh/ +IDd1gXJiZ8SKkr+O5wvvmLhK2FJySJAzSB3rjKipqTZfwB47dsvxKr9b2mNfx/OFd6zT7PQniBbG +06dDpMGjcyWsSWDOiIxmSJp8ZDAoZp7wh82QtMzsrMVs8MS5HZL96XTnpDi7Ienv7ojq4r84JWkV +EZkTFJFZ8pQasIS3XURkpD0+h/Sc7WR0Z5mIDOHvnywfkQEAAjanO+ZIQ1skImPIFlw+IgPT0HQR +GauMVKf8PG6uiIxpnP/ERXqOu+QcmKIHGM6Zkt0d34OlOiitsXyqGsvW58bdGMvs0XVoywUx2Ock +jk5Xc5IBrkvy0r+aoA6YWjLgcKbXTRraggfYSf0CE8iso0tzpI8Zji6YZgs65dXNfWjWeEIV5dW5 +PK9nm1dHpI7aZAo7B0FPbS+pIriXsC1tj+pVjHeRwmcuFZ2c8251MGk1+XCwl1WcqbPPh5v//rFF +8uHMTkFX+qvOh1siz2KOfDi7E6qry4eDUeslOdBFPpzJjaCWSVyL58NpTkPJ3/hXnQ+nv3cUZ8St +Oh/O8ZaAleTDaXasXBy1XCwfTu+LWW3rwEy25TProYJb2ZlIAEp7JtLKtnRzJvJm6OpMpBPvT7rs +smZAFh2QWD4bHcEJO62+Szhu8kgsoWB7DMFZQSaX4SSDzRl4Z4kGk+usA2LG885ELRuLE8/+713D +iWf/t8NC6JjQMtpzd7MMG6rJR0RUYVk2BMBsr5Uxk2OWbHg/csuGNtY4xPd8/qIpoa3mNmAEZz72 +schHBnBWkgiZi7nTYo5wrK8EtrhNy+qYtfFKYMfb0LRRad1tjcGwMYYFk8/sL3ZydKiVjFR6c9ED +IsScrS4WXigjtb756iKJ1GVGan2z4SZk4JDqt5KM1Kfv1WSkQjiryEiF+WLLZ6RCKKvISIVw3F0D +rXOJzc71IQaxvjR17kNGwYi0+lo2vFuaDXWpcOZybNWpcOg8v+2JnlWkwpmuy8pT4RaPW2oxZu+7 +z+FXLpEKR95BhJLhfkoqnElU4SekwpnHx1z6Z/d2hiEpCsj7k+0Snz4tz6q6uRFea49low5ukduD +XhAU7yqi6CKADIFZ32w3pw1juGR43s0FIhv93uUWjt3tvECUm6k8tRfn5GZ9Xt2T5XU4euUgR0dN +1IPKv7BqXNisP2kNUInLw4vPYu+m/prbas3yhcR26qVQO6zkU7GpH0j+Qu1IvEdlw3MP+XEqXRJq +J9lMtJnNZmKnsAhBdSSrI19PO2Qp4qTNxTLLOoNekpSj9Giddxa/TFZI8tImu+01L87I4DPRKf+5 +69vfGFpl2HH3d3bJbq2YZadUoZaxy7DzXXTO6ladvtl0WowkiE71uVjJ0ISIwumT3bi7z7JSmVCX +ArYZsEt2o6O6TrX1+Pb6Vhl2wtbWtzB7skp2e7TLOuvbZ9gNazXLTnfK7c+WVadt+3p8l3fWnebP +H4uW6N0esHuvVp1eajPs0KoChpVmjX5JdJ502W7PrB2OKmhack9lVxC5YAW3k1RnWTAxRM9lL+mw +MOvpFapd7NjFkVutBRsa4Llo9ogqO8PVpPY4n1DVR02s61h9uxgSsS9mMyinw6lO5zyw97rKSnJm +ZUdM7lRxEV2yqyQ3VxTuMef6iKRDNiS6E3KOc31OReRsz/W5pyeHInKW8zOr++ZUbMTt/JxrDbhG +ulOdEd1dakvUj3PPL8W2dSEiy+OubgvQ2Ud6F8mmWywOM282nZkfINfiXF02ncv7YZbMpjOLCer5 +ZflsOrNcukUzH62z6cxi8eYn7ZfJptOgReJZ0/vHlsqmMwPlcEPIAtl0C2rkObPpzPZpFF25smw6 +s1w60t9fTTadWS6dy7M9c2TTmcXa5Qrsq8umM1tdFOldaTadmXFDnh1dTTadWS6dxW3zS2TTGYf0 +uWVtKS2aTWdmnHp8q86mM1s/k9NQS2bT6UE51hReKJvOyrZcbTade4wtk02nA6XfE19RNt1CGJs7 +m842x2pl2XTmudWrzqYzAwB6WXE2ndluie4M/Aqy6czEg9Z7XUU2ncPOyIqy6Zz1yyqy6cyQoVrj +q8qmc8rkWk02nVkunWU9vuUdwIjqAGrqi811dZN1FS9jkUp9bQ6XiU/fDsyuQT43tKpls3i9OsOQ +pnCXZ9X16qytC3d4mob8c+FJxZLmJCTMyXQ0LFySgCZBwSLr2WpQuiG5FQUuqstpN6YWGhLEGBjU +XGWX7YZkfpDCUsLY4Mmm7LKFyIRaTOsRHdEnE51HxG4nRg6Fze0jc0q1LLtCd0uXuSPuuXJpki9S +5s6yutypq1wll2XurDK53CXSuTogYX8+WS10t9xaFe9HbqrM2EapXJW5c4woQsQsXeZOsmHsC90t +XeYO5745FLpzt3k0Ol3BPVfs0TVtv4ju8yxOV3ZEaXSqmtwL5/KAqR0E3dKn5S4PLFDnePbQiT5h +Gh10nm0j8K4S6dycaPY4ZxhaH+JwnV8IerE5djjHITKIHcvQn5aS3VXYAj1v+fX5RPDSVMs5m90N +ZbXfU6z0F0zs0pyGAkTlcB7c9WkoAMrx/Jjr01AAmLsT3fYHm5HsW0nm4/JbIbCioM114NLqu4Tj +qrarGRTiZFd1FRyIoBgy2U0zhZ1z2REwV4m1VjUg9Im11YExsbY6WN2tgBDYSgoZIxoDo3UjzEjd +ZYnKmhkqHeu92p2h3jVu6cJMPOMJaltP3OoMdXvSXUlminLz8fyWhBFUebaqCobgRcV6i9g171/P +VajaavcNFl5b2pzAUOxOdc4BZwW3BGA4y1arxlBkJjS74XC+s6rXLhIZ5trhDYZM2PDGRSKDqwj8 +0hXu5PxKqxp3C7ChyeGKRetWz1fhzi7zcQk2lAlNqnC3kkp5jvlE7irlLZtPpFTKW54NbSrcafOS +3OSHLFLhzq7eK6xxN3+FO7e3msPsp+UTa5++VTPHynt1nVgLgDmbOR43hg6uTbdYYq0+85FfNn4E +8wvPTNOh57vnCsFZQG4a7oiAcFaSz3lGufPFHOFY58Lqkpg8TtdMoHJ58+S3myUxkbuiUECEDWyY +DDgshIu4llz3zWUak5skJv/Bi94TJbSYmzQm7SQdYqcqKGVdLNOYkgFXGeq2brvClcmAG650k8Tk +Pxjoje9F/cq7uZKYrE4QwdqJNpp2PsPwTsrhXeJWfp1haHJZ4t09rgGxihzXbNT6Vg== + + + Mei/zFuRbq5yjwiV1vbY/equprpHu28rynG9t7yaan4bpjGZq9yjQ6W82II5rgR/KscwXGQ9O+e4 +giG5znq2y3GVIkBwIcqieX+y6Qcz3koHtVyXzmZiJ7e5rfZJ1ePLHYWqtYPhW0gAv4oVlN1XuHsq +tBj/4WYOKx4U2iVix9IvTRLe+dEV2akmH87jm2zd3FfIUJW2Dlsy+3hvkQ8XtE7CG8/ekrRWJuvS +8Khdq9w/YWtbvAo+WyXhPVl2CuayWRixlnOlilsP15ad+o8b0Q+rOmxBtVMlk0tFcIVniE61qWkT +v7ij1hFkdVmOwcDRY8+sU48PIlhfc06ThlfX5/6R6D3dr1h0Kmz5uPPcmxqD1WfEvdp0WtwWrDst +Xm49mHWK6r7FS5rUSn2nV3Z1BE9vrDvN568LmpNdoNtt+D6s/JKSMGe7BzHt6lu0Y7OUZTsyv5J6 +202mXUAMJYfTvKomwZzvOb3RqWzWSNEerfLM2sSJFUXn8tgkQCofRLtBmipmzgcnXehmAPtAn9jk +GCGxTkkyHq2yHBKkZOtBZd2kNjknNk1WVZkFBXQdKrO4jSTl7I9WWS6doTIL6KA6zxE0u6w73c2T +S2SlOZzQxFjyuKMn3abXvPNTotYw727uKosWQzKc0tLzi2ukz3VKy+OzG5R1nHi+IQFpaX1OSxqP +4WysTlzlnw53tZvXeWPNlMVcCQD72MXV1w4x2Jf8qi5vvI9suLvh0EU2km142e0uz0t+mZto1ZxE +w5VxCyW7mW9Zz3Wv9Ut+wciy9hZNmAW47CW0ZnfFWeaLOXktxrvibBwg8/iY9tCIyRZrvTBXvQNr +CVNYmY9cL+glzKK73jjhzoqP0Y6Vc/k6zcj0cX7nkB2qx2cZVeG+DQcIuvHx/PaIRe0n/8Gd9ebg +fIlkhnoWS5Rls89kmivHKjHXPQfEkHT5L62iXezY0RrXDIk4qi/tVhNcO2cqYHfbRSonec+VTSqg +U0ljh/VTd95bRedEHdfEoKtrbFplZg5gTlV0/PrsWhtgOq2yHMYcc3ncT1K7c7kkxhzr6cyFsTL3 +ZAHMkC5sZh1KGFswC9BtDqDre0isEsRc5QDanE53kQXoNgfQGE+eJwvQbQ4gecPh/FmAbnMAUdR6 +4SxADanYeJj6c7DzZQG6zQGEGFs8C1DFp73c0OZYzZsF6DYHUPGRF8oCtBiSIQeQ3K/E4zHOavmi +fO4rsi1TlI+Yy08symeIKvyUonxOFdlWU5QP54zYGyjLF+Xz+EyswpUX5TPWR/4ZRfms6yOvsiif +q/qVyxTlI6MKcFCC5aAkFDmlBltX9Vv+bqiTVdwN5bKun6u7oZau60dMbQV3Q1nV9ZvvnNKidf3s +q/otdDeUSV0/+6iQuSc+f10/c+KzvRtqgbp+zpS8irp+9idDlMjVknX9nDK5VhTQta3q5/HNFdC1 +rOtnPzVd7GLhun6agRiq+i1QAcS0rp/9hMxOqC5S1880HdHuVnP3iHGdKWt6F/QCdf3sb/5S9sSX +rOtnq+iySIutoK6ffVh4rhuobOr62bu6pqegF6jrZ5YmqbLecvX4VpDzPlddP3soMM6/irp+9hsq +Htdwlkl812ekLlrXz8TUJKr6kdUZqCXq+unYkNJW9dPc2TV3egql1PVzzHtdSV0/+6p+CiUvWdfP +/sA1kZG6VF0/NX/LjBZ191wtXNfPHoHIgl1BXT8bXpt02RXV49u1h+K6Hp9DOTnX9fiWquunQDFl +n3mzOQx1/WzyHhxP27bnretnb8nDGw9WUdfPSoffGHcSF8vfcmHOyzuJTmzoVNfPfr9Ze4pg8bp+ +WmzrvcVF6/HNd0jDuh7fCthHqeq3fD0+N0lMTrc3GM9qzFeKT5+RulxdP01g21DVD2cMLV/XT0mV +sqsrunRdP3szx4LG5q7rZ1/Vb+lbm6S6fkvG+lzW9XOR97qCun72Vf3mrse3UBauTloa6/otngxP +VPUjelmqrp8xlExW9bO65Wzeun72x7t0Wmzhun72B510MaWF6/qZrAtR1c/+Xjj3df0Wj1tqMTZ/ +zpOFX7lEXT9VcJlV9Vv49KCurp8tRRAVQJar62dvGGLvdfm6fvYJsZJGXrqun3aS+qp+BnvM9U1W +2rp+1kYQtmEcbrJyWdfPlQ2zdF0/ciWNGzg22bUW/Gle189eOdhmca4sIRbr/ZiJeniws9Eurs1P +fOjvlfrENyrqdCV4ah3atT94r0tb1FCTTGPq7s3hwYjMg8exKamrgEZDRocqYqjYRVtQ8Hmu8UTL +E5j7xkw+N4BaOdkIPZ5vU7G7rogbwXyqje2zw+MoFRhsxJqPI44df54UDnvPicvr3UCkH/RnvjNU +6eM8vfU9ywgbT/UWC369pXx8fK+0c3bxfcV/d+8fPT6Rj3LN+FnhLnoaHW/w5SL3lrnqXh+1qmfC +7Wetfc5/3wTa79u36SCX+9qsXZ12k739u2H7KDD4fhW/fePUQDjfuD0/8m+zgaLge388Pg7OPrce +ueFTOynxPsrtPLyuVW82oqGX1Abz8X0T2mf9KaqQOc1QhffmCVUUdq7G47dEYDyJ3x5Ptl6ExoRv +PFaUTMta6CAWuY2y5cSmnPb2FRtPnoaw2FxiC+dWG2WIJr9076H8mkg3L0fQoVZKQMJ6krM32reb +TpVPzJCFkAGmO92B68Jub1jOFWU0Bur+dmXr5qF2uD0Yxwo7DPcx2+q1Nlowk/RETg7dmIVH3Dk8 +r3Y2QDmJG+lCreajttst5O9XhlqTfaRjHzC1SpZImlPjrcTUgFgzw8Oh4MvOPL7cQ6F9hwpoZp+L +V3fCeba1mYpN909SsUlrr5DY6lbytyn2BaBtcFjs3dw9pUvCRgPAufmWweLymQE61BVhKuP9S2qv +vDFGs0r3h5CS06e3t6+h/M1dCf4CE670ojBpN4zd+kP+fow8Jyo2DcDTCK9TLIljfNQv/6IDKHYM +MCIOwJ/iLsr6BQLneAT+PAgjCbPlB1rscQweZKPyh4VYIc+cxQHYEhXKhX2zQqB0fEyH/Z/9fLP7 +naBih2IQDRQO7pnezdJ72U49RoMXByHiRX07e+Dxya+yEfUVk3m4PpJfHMfUF+z23kdafnFBKy9e +JLQVD3bVZ2rPUO8Xs2HiFexbglMEXA8wsQtm+hSCcw4yz5MvIACLVzS6CYcuHV2xYLqXu8R0Gx8h +iNlLgPKDYZdubotJZV8MiEJIXhm6GTmgYaMYzFvq082jY4i2S1r65vIagYVJrftbsOcQzC1Gammb +CUY4aP3XImqnTPAotYd72YMb3leZXvRjN11pvpdzp8cbVZUklW2BrNZx9WkdzgwTLBX2zeABSl4U +4mX5QIGY4aeV7Xbx+SH+ka7Otjv5h1aFgrOiEfViSn5jnmcvKWk17l9YmbxqHDH13JHYlPngNoIQ +yOQus1AD3sZksr8FsBvPsDbbLS2Zu/ytZF0M4W9W+cVhEPm9vgD+fJAgvjYLcEkeYvLXD5TyiyZG +88a8dOTRPLDohccnvcp1tyU+6H7xeC5aTavdM93RiBlFCliIGaAroaDRiZnk88UwkL/NnJ1kgr0x +zOkXSpk8Fa0ZxYy+Sq8fURuQAnF0o2tQ2RcD0lLi+LtuCJNk5u5lAma1GY11Nis77HaiP6WoQHQi +TRcIF3RuGoUnwZ9cEGUF0/mnFPwzCRhp++sQyo0wsfpP4JsbSBOlKDKD4EmVKHLc6eJLFDrmpZhF +CKZEKQS5Q4RTDvnTADwq+k2HqcGbxycv1Oku5rtw1tdQnkn8C2w4yM6nYOHFm1L2rZtuaYRQmaL4 +xilciFOCDuhi5htaHB8XCGPnoIP7IZLEcOpPacksAaIHP8PCFQocrGls9ZDk+5Rx/rrqI5d5fWhB +1VhaOIhiQgfVfItq+Qa58figuUMqclT1ef/0VtGzJSZba3CkJ46ewqK+ZzKIN58exKxR+QYGQ3yG +7aidB+aEMCbRs42De3hU4GoKbbBrlJWv2pblCczVr5Ag+GFBD4I9flRBVLW1a3m8iFiVFV79TLCf +EaE5GPD4ABV9UJCIg9LT+veu9Ky7GQKivsErmrSlsUGHXTxndOuEWkI6dbtbBzQdKoAX0QhiFGyP +ae9dkEWmUjNZMbueVYsrtNe7PocD3YQv7rWXUATUdbnbGMbyYC7I0Bln7h9lGweYRo3tqydAWVxR +X7kZWscyxmYbsNMNjEpu8rgD8bQhX7eR2FJHozkLd9hghjISUmxIU0f7TUYCF0NIUEbTJaopoYsL +MApyk6qCgidUH1lBwuzxQkGC7vqPsA4JZihgU5eBgISC+tGFzktCh7QhEkC3KhKkJbFAAoECXM8B +0X4meKqgoPQc3fy6RigAFqxCCWZ0gM+mYSIWL7oSEpgZTaKgeXFmRQd+JEYBv+BxMx+X5qRkCwIl +PDvTIrSUrEDUN4uhZcagEgOYy4IgUF6OS5bCt53oQQD90o0tsRoBfNWFQtNKzXqJvFzQdIBcDZIt +rPGgryceUJFpPY2jZHcgg9jVA1DxoI5BvR/GlXxSCZsq5aoN5dqVgbZdEN8nhK+QqWUuVYzdP+sW +R225IIGoMndxGgMqIep2DBY0tiTHB0g8LEhjpPbRiF5LAAYaIznekkxJEPppkOwqo9KExuwwMddq +qACIyFXQFSZsxhAkOV4zBq0WswVhwfFulhOf7Qmqq7EYUQVJZWxEpaxf7EEQCzrvNBAAmFkvL+iC +0zATXLoxgLnYjsIFf274c0+XEgBm8qIFgGMlikZeBBO7KlXaj0HRyMZR6DTR/GNQqXJRabnrhioV +PYR4X6+Jdu3p0sUYmMw9faz+CWlsmjxRH7Dbyewp3qRof7Vjklem3JeFLf0dJiS5wmq8qvD6KjuK +laEclqiO6PDHxyHy+G6+pTgbdIrh14pTHEN/wp33gPTrqw2vvygFcX/v/m9403kpJP2ZDEADshSR +/ixzGAA8DXWdnMoe9jGlxsKoUuP4rvAafDxFfi7h5RJBOa2rS7y4plvKiyiYC/Hq4+BdeUVG+CLb +x5/yi3M8DbpY3qwrz0KkZ/wSVeI15xEyQkIXR0no758rQZZzCsfHSkKZhfQUYY+uN2ZUrJJSo3mv +UlShUkC+NCTddgaZ13DXIQ69wDj49mIM+aVyEYO8EQbi6nsb/HlNo2/w4sQqj2zsrNqF7kwtRMTe +WjtR4GHel9VA5JvcyxtYeOEhkovV93eSHwP/NZjLfp77MrjexbtLcjNZ3lFW9j4SYIyDrBlEM3j4 +1I0DRPneRgQxeBK/TMSLhZS/Xcsdtw42JGK/v6OVsBpDRhT/f9rOvN/Xorryr+C8h4OGhPHcp+Yq +4wQXEZLrEBEiaksAidoyKEJ3/Kdfe9f6rv38zrkHRJSk82m5Vef3TDXs2sPaa7//1tevnozl9ebb +9fLpb++nfLJiH7zzo+dxL4eF/c7rD2LZv/OzI73z6NWn979+kcJd9M6v8rfXq9tufA== + + + 8M7b5fzXr6v9yc/F1P7+J9zxeQK+u/mzB3H1739xnP/61a1/9538T9959O14m9//utz5w6+eKG+x +C/J//OCPT8a32P16WSJWp2K1/csH8YB9lXf821/7F3TUZ8+f7G29pfON3Ioywn/5J/31wcVN8Eu+ +ZXyMF90+LlHUPeZFf6162++N/cdz9373eQgItbt//uy3n3sjnPTv/Xh809Jpb/Vf/AW+8f/81Xd/ +GW7Oy//oD/K7y/7+16fvbuH1iYTLv97dkM89elYS5l+fD4fXb7714KV/+eZHh/bLt1++uetjX79/ +/8X3v/bhy/d3/OmHelHb/ia/9Pwvnj0efP+7z8rW/gGRvfD1ff/l5+1I/6dv/STC+R/9v29fzdTW +9cy5XD/4yafvv/fxjz7+3W9+9+H1c1f/fPXghVdTev3DX3/08sfvvffT9/7rk5c+evfTD9778JPr +b1w/eOG1h6++OttL77370a/fuwaP0v5jXPbKs7HGwx92Nyr5mKPMHumX/nN9//evfP0n33r7pf88 +3vz2HTeaj9w//PSPTzz32//9ytWTTzz77s2TTzz31q9/8cRz+eXXnnjqlT89p+ab9iI4SPm5sTG2 +4jNff+m9j1/89HvP/uDRv99zpuNAWP/x0+9/a6/Xf3/xvZ9898GffvPNB6+88PN/fennL7/x2ncf +fHJ85KV6z1HoL70ELj8nzrkP30/+8Ymnv/nD+sTzD/7pDcU7X9rf8g8vzQdPPPf0d7+r3n954tl/ ++9oP9X0/1B++88TzL5RfP/HcD372yhPP/PHrH8tHNuNsfPnT97/s2Xj15O3p+D93NupEPE/HLzgb +b4XX3xCNuo1FXT35PxeNuo1F2QP+5aNRav7tZ6O9xj4d/+fOxqsnv/gs++85G20Lfek7/p1n4xnL +0en4P3c26nQ/T8f/ubNxf8vldLycjbfYjId38VR71d4VMxcp8NfFjKTlFjSSJt8MiMW3f/8dy5rn +/viHH32+mLnIsVDBH/yjPvyp8xj+wYfxuT9675nQhveJ8tozEereokn5+s9rOR/conzn37/3Np8r +4aKAzitPoVoKxiNP8ivPhEhJX3sQ51f71nOXePbzkQ9MvFtwmZ9dTtunIx+tvfzg8yGDW/6cC1KY +0xN4uiVDxQ+yt/VTT33jlBbfeMb60FPpe7/6xjfP3u+yf5/i2ETWXIJON3dP8j88PDi6Pyt19vkS +IadvPUO0zXGpZ+8e3b/CVf3D0AO2Mv7gS8cnfe/PZHlceEA8jbfriQDTtx7871sf/vHe19qDe+El +MUf/2xle+vjZz0aovvPaXdTL8eovn7t5/Ba//fbrbz3zvXsBpsfW6p++/sURquN73/yRb2Cc0L99 +9hafPnaLV/7xlbtbpb72T+d5rRjqcz/Msq21nl55Vv+6ufQ9oA8ew2/vVfvca38USuNji5l9OP78 +zshf8C+OtwTM5Vv5y0V/nvoAvKNDH//rL4U+3vzLoQ92zheGPgh8RLT480Iftw6Gv8/Z88ztEFw9 ++cwvPi7v3CGCvwzC0w9//utfnYOwV/fdQYDg0EPwq7tDgKMhhuDnt0Mgz9F+n7uD8Mm3//jXBuHt +b/7wdgjKL95P804I7HMcmH+bD/TmS4TAPm8d3PKzUCD5b4wDPoYHfOOjvxhDu3ryy93izT98lbV4 +ZiB8lUgeBU6+8Aaely+8xTt/+mpb6vu//fSyK//O2fjxL//wJda0fdNfv11ej93irb+wLb7sUP74 +vT/dSsu/+BnP/MOdW3zn4R8/euwWHz3x19/hzROJ+Plv8fHXzlu8+cHtLY5XfvDmu3d/9+YvL+v3 +zTsTf7z8v175yb019uMPvuIaoyTrV1tj733yFd/h/Se+8hp748OvvMbe/OhvEr2fvcE7H1/W2Bcs +kZ9/0Wf89ksP5V9cY7//9KvNxptv3dmuHrHPG4kvvMU7f5vk0yl2/xbvffzVZuPN3/7p3pKKEfvy +i+rN3/8dC/txPMqbH376FT/j4yc+b2ds++XLf8anX/s73+GiJ//861//a/sz/+mXt7d44p/e+O1r +j+Fy3vnLZ8CdE/mLRuKd9/74Vd5B0vKd337FRfXO7/8KOOevS8t3Pvzkr4q6LzyH3vnjp3f05L9r +i7/z6RN3m+9+/WuPNf/x65gK6MkySD/5zrPyTvR7HpLjvU++O1Ewb226O2bf2//wwS9tyv/Tt95s +JyLzLUzG508E7C//ZLvyElt55eL31pPlzdum8DOPm8LPGZPp5sObG4Mxz8vu+L3Ld974w4sXRPU2 +bO943B63bu841h43cO+41e64LR5zQN/CgXnKozt+vdsX2CbuN3DaP333yd//7rN3PG53nvz9l289 +V7/aA/j6Xrjff/TgzNN+8P0fHXIjPBtusO+/nvGK3XX0/PjhszjOwtHz41efP43UT58JK/DHj27s +WxPv+W7+5JD2n/b//PpPxKV+5tuW7/z0w5uAef/DzdPhMHrzVeby2buewjd/dMNTyouzzH9+71dP +/+fD3/aXf/Ti+/Pr847r2m7abXhHzvlnSMBurfc3f/Lgb7rj593v6vE7vn7c3rG//q1vPHzh9X/8 +5/94+Nvxr3944acvfPjvdsW9+ItnfuX1+/S7P7ugp39abvMY7s7uO4+eu+ODfTsckO/8xHkOynZ/ +2v96+2tv2AF36xrKL/68vKKcojf3Uvrmq/wrJvad3zT71uyh/f3rN/Djfz9dENDP73u/8JT/dccv ++/u38x3H2h2P8O9/U0//0c9PJOnPjq9jmt261Zx5+Llg6/9GqDVehc8HW/83Qq2vnvyLYOv/Rqg1 +0vLzwdZ/F9T6T//v21f/vJfUqym99b0Pf303xnT15JO757X3Pvn0D/pBe+vF937zuw8fvf3n9z6+ +Stf+v2P/n/53rOuU53VubTeaeh+9c/UUv71OT18/+vDqybcevPDxJy/97t1PfvfRh29//Ofrb+yu +dP3gxY8+ev/6qRdefe3lf7/+3n/94aOPP7n2ZT/96Prha689rcDWF/7ujd/96XfvvP/eY79/8LMf +PHr91Zeuv3Htd3hrv8M/6+p0vLXfYv/Jv9tf/tbVcf3C/v8/+79Xz3y6v+ul/e8fXR03x/5/ZX/a +X/6H/+9nb18dMRD7Jn/ejX/Z//jfu+v/XtfrH1z/4n8d17/e9/3ZT65av0m9Xddys+qxrj+4au2m +zNWva71ZpaXr3a6l7PbuP2a/bvWmlKzmUdu6fveqlZu22tAFs+8LW75JueuOdax23dJNXUvN48h1 +/76um8Yd0k07yv7LuMmz7vaxb3zw4DnnuC7rpqbUdUW+aSOX6zJvWi71uoybOZr+M+pI16XdtLZf +YP+59P2zd6/K/po5uGCMMa9LuumjTj3iqPuRZT8qd14hpzmvH3JF0Vvvl+p9P6LfrMRH5Lr0KrzS +/ui2Jq+0fzfXvuP+XS1TP0yHLpg3vaSij9hPLnvZ3Rxjf+y+Yg902e+wxyOXNXTl1Nvu4astJ11Z +xl6yGt8xznGaTMAxG79b/LnvwVCzp6Ne7/k71n4B5qHvd7lu4yZNTVzxK/TjpqX9CvvBa9/gbD68 +2h2pj+u2/KnrZuQ89PfSNGH7S3qnWf0++76tc7+StUD6fp4+Udfrgr1Q8l5Cu512h+dtT9N+nz72 +zO8hK3nP8/6emVvWoPYUA1BZGXtC9Yc9ZqnXPa97yWhe9aA663XeF/S9mXc77yv3Bbl7EPajV9qr +P+8HrlG1pI62V0ZOMUjHTd0Tv785HzczNXpW2fd4dJX4/KaBzb316/2LvRyHXnuOfp3Gzep7ieyv +7nNP07tXqe8Nst+755t+7J60F0Uv7brXm5SOuWWOb9j3klpFI5f2lLe9V9STVr3eA1TynoJ9hzH3 +DA8PSNcqLVq/eySPpL22v/jYa2JvxZr2iOzJ3nPR1G5aEtqDlZG+2Z+dYlWkvcj21K+iOdWFuzlH +3UuiaksdGjntem37vYXW3hB7Ec3CyJZjr4Gi+x9Jq7r0xLjtN9IW3FO6J39/9M1IZbLnmkY63Ryd +ORt6JU3mnsQ51h65sl9uHWMLoLK/dwvk/ZdSxmQbsun049ymuvYc571Jtszgg/O+3dprbS/do+e2 +ZflN07xvOTC2IMh6vz2vZU/q3AOy57s1Pr+sub8/x0rS9x7swz3bPe/naMEce5+nvcpn3ctci32P +zG6nWvRKe95r3c/YCyCXpEkbacut6z39LNe0V1LXdO+xXl2TsP/FaktbFqThZ3UtkCKpc533Atv/ +73qvht5qieWbF7da2jlFn93mftTc71+1AfZk798fix24R3KPdVFPq/uRW/CxZPeK25K6e6QXz5tz ++YI+9zQnJlT3y2k/J0lS70/Z81ElvPaL53FoYPUGZc/V7pkS9nuG9scvffQhyZu1dFdWO01mbn/D +yn2qpx17Le6vnGO/y26PeRRtyT0D7KM0uuTUnhTutXt6PfiLZHPSSvJ4sub26M082HD7FrMxu7lt +ab6HS1O3Jz9rke8ZW5qovTa636lrWe1b7NWzP6bv/XX0sldRnno37Tc9oejrpmXb0D7bskkjMrln +HZp0jXDa37/20bT3xz4VjrqX4cMrvcMs6mjJYmTviJWa7tDbzJqTIbHN0bPbb17tScj8Yi/KY99M +cmNs8bbfqtMeXu4VkbEHpe/Fsoc3z540GkdSe4uGscWypFb1opqzxLCumZeX2f7FHvhj7CnMEkN7 +Ze//JknPLHE7kZ57pPMWUPuXZWQ2275X0TiPsfewJr/vvbHbSM+9PPbRHvtsL/R2fZ6z+9k1Jxbk +9CZDHO8LdIwmXr/vBSPxsLpWyx5Qn89r7O9OmpiBINvPPLak2j1Zx089F+SeoSVJLxGSaGvH7Av2 +HuGZ+zhN+5V08KZYsW2gtqyjsW1RaziIuw5irdi1xdGWgXyeViiPmHuoLfm71tm+YlpsJh0JRT+Y +aa8CyQqNxpaqbFCtYG1Pju7V9RI6U6UD7cNjH0yMZJa2sK/Y08vI9+N8xKjM2jjQibY6VtWsezmp +LZVJzcYhVOPl1VMkyPfIbxmoNmfJbqdZmP1DSta+okogM/9b1qKx7OOedqs6Y/KWvDoztzAt51zM +JqG7V9Sekn1et6blUvce0d7Yn783jdp9n9Oe7bpPavVw3JTKeGVtomrxM/WEvVELk7c3x8qFX+yT +gg3Z6hZEWefRPn84DRbtcWhb7CW69xsbpe0jQBfO6p1dRx7xqk0X1oXapQHYeiuLWYs6SzvdK3I/ +uhx7oCRUhmTpPlOOUz5tLXPpdfdGbhwiRdJif42ksiZVetX+2tSyrtg9e+KneqY0A63uqdU+fZxK +4u0xVnturVHH6Zbp+o7dk/fLaccde7ak2O5Ve/1/OBpK5qH7fOaoHFq+ElClIYn21FR9xpaywxrp +LAcftnXagn6JGh0fpjW4tT3OjKXZkvontWr3bEmD3r70SvvJx+6Wolm1x/WKnIiyBA== + + + qj9r1b2ltjYSynGWpJfemaT6arxY1G1fOpvVbE38/gWHsDbxPl6u79ke717959Uzr29jRebOnq66 +/2efjsf1Uz9+4Yc//dEPv3ctdfHh07vnv2QcbePl8LbYX6Ij5AN9U91Hm3q2MKz6ptkGs95HWlby +JtuM438rwXs17+NIVxQtdmnNi1sWjauU00PtQ5ol5k6OnXZ417eQpxJ6xXrkvhCRt8W7lqBGcq+C +3ZHTFtB7GDEEtrgYOs6alLUDcVJnYdz2wNLOmBA6OSfihcNBbVkAWxrV/QN9g42VLdD63NtkP28U +3XBYeMhA68XttsXyQ5kKQ4tAIq9zATO3m8f+ElkgdXcjUlPzF7QpMb5X3T469Qupi7uZEW9SPxcn +2j48Y6n4nZsPht1mMelw36IVG3Ov86Qn1eFpQN4nlCRGNWepNnu57uGXTTmsqaRVmLfMq+/fW8PP +WsRJ7a0wJ7WHzq596LZjzZi3VtGFGD4td038Pqi39TlZKgOXwR6lnvyItpXHfbLP1RDitR+oV20M +lOm9JXlkPjBHdk+pUmH0UguTbmtfWe21Gm1uaCVWBl+T9tesKenckZRI6KrI/JjVLCMBA2z2mX2U +JX6A/ctBthe12szqlpbNMh/1Xh1SPDjGtvjRrEtF0ev0aQ23j+4PQKvX0SeNC3uBlZq6LLyFGNbC +HRyMWLfLa12Wmtpb9UQfkAJwb3++e/Xy1TZyStqLs0tcTTkcunb5wJ7KSct1v5aMny6lX3M/UbXO +C/ZTt/DXDts92mCSKnnwg62XFxtJkyew/Nkf2Fm6Bcbf9OEoC06auOSUBm7bZwn/QdNI0d4mYNMd +V91vstslyyzrPnT1ey2yd+002SPVdfwuNsgW37TbsddrK95KemUZqLbWpULJ6Nvnsn6RZH1reBar +EWN9nxMjx/IdOkRlvhdvkG10Z5mIw+6A1vVpW7Motu618ifDOWXPq71VK4Z3tup2rR7uNMKRwyxq +eCoOBOxuWcJxh9EPBBBWFldsc5RftFSzhSdyfisz3IDjTG0Z27zUlOWrOZNAob0VIc0QkqSETNQS +H/muV2Pvij6qBbK8BrK6F94Dv3SzquArard13Cv33EcoUorTWdIOR0y1fY7w2YPOX7a5zCnRkgXp +kromgZr69B3aOI/CwRVba8Mwx2zUlQxqD5lRcdqwZjmY1CEnz7S2yp09i0nyEWcbIxsKjI6C42AT +5K3n4jzpsnCHRzoUJR7AyaaRS/tU1pqVq0Aje+w1qhfQHOqQ9idMO1uG7RStIynWmso88fL05L+v +gi6vfSrtTvtx2f9RpxfUFuJ4M9gVLDjMMGm3ekkp/15XA/dQrplWPrr/Wn0qaWVmPXlrrOzWJXGz +/4u4ui85pC50bCpciGVIAWADSpjunqqLwzSW86reyhS57ZYdA8nrSepSGrjHlg5BKdgSIkfo112S +rHkYyt719kJJCh3Yn2pjX+n1JVXVThzP6qncEfuvy9mh1tDE4m6z62VKFeQBPccbJxxwGgWEe6WJ +s1XKd/P7y2EiWS49X+JExiQ2SbU8KTiCsDU9iyxEXntq+FnTuqB1XE5V4kFn19G7F8rYQ4SDUoe1 +5ts+tlIsHZAG8rlpuz1krUsAaw4sLjqnh7o70mHoaN/tnvhiCRjdWQfc4oLF9dOWrNor+bwqMxb7 +Wnw0RqFWpA55fUOx/JnNg7CPs+wL+t6Q6snVq7weHpdDYle7R1bkvuO2qoZ1sP01PjSHXW/7RPOh +u7eBtbbOMCSpy8iELZmZZ8wbSaTpeT/qRM9L1abaNl2mr8CrVWUgDTZ3lsdMxttRLAw6Ju302pMa +tQWteupxsMmTXLC7bVHXT197Xzk0SVQEOfJWSpYK+3urdP3MSCVZ2XKw1xiooiNSfj68/ZIXWt1J +Oj9yBxfSbvfuXTv8uVLy6x6oR+oZsu5r+Jc1O1t61tjHOl50KW2fbZODXB15ISHKFhz+QaKNewxv +fV6xB+UbUk/b4raf3vhklyzHrL5hW9nDmwQ/hb5TQQuJFCZXLtzYY6Xz99Hx7+uYnVgqsyQ2+R6N +5XGzWDh4YNEmDel4bMHBSMsho12sU0ZzIeGnRyxfMRLKGS8tJ6sM826xxlTOldFN0ILkVZfuiDid +Q7+Xw3GfVviXl/fdY82SMFRuOxib3dyD6V1ZOu27olPStKBL4HHMUiA/UE/WVMpnua/Zlh+68W4u ++SFKeK5TxpDDg88A7w6cDDImte+SBl624vB5JR+51iFXFNTc4oWnoI4cjMWLRA4jea9S8XG0L5Cy +dqD5Z1k5ChpISsjHKSlRup3Kag8E2O7BW4wXVL9oeJfV1p6/2PVbs9CeeCi3KSePXmLf6dEVjoxs +U2Dg9tpqPaNyYISXLUX0+8M7HUfZXrJyGi/c5rs9dSovvVPDjN+juuTj0wmh5tyqiDpGOGplEmr0 +tRhKsT695dlMaN5yDUtULHTfqo8osm7kRNX5oE+Q22va6bMvaHZKT0IGDAKamKS4ThJ5M7JcpZnR +fMioKTSwZ6zI2yXnxr6TIis6J9RUt5aPZC0XzNXVUzkg1dY5LQUj2bGAo3wgesI7OMqWU5LzBz8o +fSuDOom2wkl7aAwLLs+HxIckYpZkkoZF/oWkj9z6nT1UHL1bnBzd/my5SXvhlrIRtLrwgB/2VGm9 +SnuUM38ey8/AubF7tkSMqGRWk9N4N70DJDFatZcMT4wWg2SwHinXA257OYXubSpttE+1OZNc0k2e +/InmohUvL+wexcNhtm2TlOtDcYeJIoa7XHGogQt6L8p9iKmjoqcrjCCl5sD63P94Q25qvKOXrnSg +1li5K1xT9OGXjofyhadCmGYPKoaogqV7Ap6X4153y7LNtcv3L45MdOiQJ0iuNexNTfw+RTMK2/50 +xbW2TiljaA6N8sFelRtuL7LBC7WF4bJ3NXaO3tMq9h5/mcm6aMtLrb3KRtWHbkMe+2P/Rb6vN/Sb +PZzSa24moZ9LhzR1beqDAO+hod/61yrcWNI/azclXHt7kicuFJn6BUfU3jOKFLf4RN4mETOwL0O/ +aXll6S8KAU86trmvA02Gx0y+iKNRm006lT57yanQ5Qso+myFj2Xn7b941ctvN5dMxRvJDlbEluBF +d1kY7ppkvCaSrnKHMsD7F0O7rdnzEnM2EVV74nd/lrzwUO7ltO8quTpj+tGU9/qVHqhVII+Z3nBi +V1RmvWDELXw9Wrk6YAobVqeFZJxEw9Y9+fXiHJK6r1VaiA9KJG49qijmKOtdu38iRvZWlP/j8N7T +fWVbHW7bVSeJltjMOsm0cis+fnVovenWsvt1A+3I7EOczY9jQMfU8C6gB9+Pn1CJS2R7YWkzGQTC +thKvfYRXdY/vXkW0S1WYR5qDAg/qaTrXFf0bGviKO09tIQykP2qhP/yMLHi0JcTnIlPG9YNXP/zk ++qnX3vj+W6/99u0/vPfTP//hPYNGnlLUWv78p68fvPbJx7/78DfXT7344gvvvvvpBz/56JO3dZc7 +6JJnPr0ienkM7TwtmbVYRavJMXkCR04USTaKBAkkMA1hIfytyCCWrST4Ue7IoK0myZuFDHq865HF +UneXT1Lt7dIe6wi5lCbymJDb413cp9SW73fpPNOaYRE8upKbbHmztaTjtRIKSBJobNAsiTWkq29J +RRhG2+Hxnn1nRXM7wq0sQtRNX7wXleOVLKUq4dgsVu73PNKgN0cE5DbgW1ruRW75vZe0y6TYcq6W +iHhrK9/r0n3kTzsEBADxYm10P0rTkeZtW8LzFAj3uh7RhYiVNTEzV/ESd8XpvS6uGiiSkrDyol06 +5HaeHBxb58FwUyCNjfaZLt1Haug+UpeshC02dbxIfVI4vwHCAdVULXWRGQ+vPtPFC6Uu93WT0+7g +sqrjXoKYoP5hhaIS9dejuM/jXR4OZHC3nXIg8Ibkbj1S0cmxLSHZxFJqU/eRdK+LubHgFL5H4kmR +jLlFgKQzn+cVSkfGfGOOH+/SfSRgilSygQ9dBgQSdBK4kwhPwKIE1CkoL/d7tGgLUIIp/WZq9W4d +5NCgH+AtttRHw9yaplXRex26g7EgC+iJVnOSgJYcR7UnIMUdZyy1+z2PrhR9OdB+UcBlRMnsklzW +USPNBzDGQaBRkv+xjq2A30p2B5pvhlV47WBZVVL8JmJZZ+++xf2eR1fSGtjrOj/lUUGDtqYnxUxh +mVS4Yst+/Mb3eiRKalt+D8FnFpEba1WokdmOCKmTMmo4YR7reUSPEDL0zBo9048hfEIPCKfzNzqX +4nPXcdC+AEeMa7rf84iTSrtSPcLv4QD0PVfPy+2R3C4r/DZ3ex5d4aoqnG7IDhmlQpbsE35JKOIQ +rzIiMqciZ9ljPY/UQ2hWQQmMUC3zjn2T3JZr8O5h+FgPN+iFnobl4h4dRDK+t5mJ6awNBiqh2sUo +f75O9bI3ob7tftcjex20GeWkrPZHAqWM0+0zx93Dz56Af/Go/tvOYyE8OSalexhX6bNVq0IwjkQY +sGc2vWxAmhqVsx2OmDs9fCEwDflVZPU0rEMJAStsu703hB6Zw/q53/NIXoq07RIde1masGImHcW4 +CEqjpkbknJyHV/d7HqmHONOeUs66256OStBYV9J4Wexy2aIirzB07nXwTqiM8idLYZIPE+FmPQ+d +rLPn+HyG5rEe745sXfBQME/7R15oTPi9X9+4ut/DrtynZXcPgUPpv3ea8ujTSt6Rd9qPrrDtEYLW +5uWBPLDgJ0bSPhmJai1hs7LFz+M9EmGTMOipI1cikY1faA1X4o/o0Ie8ABKDj/foHkmmoGRX00GK +VoGZved1y5YtWkFdgj61SXyvR+K4s4B2T84oR3hEULmxiiyyq1ypoHiTDnU8SXsfLtn2GrPqw9/2 +x/0enRoTpN26mJ0dzXriiJCq7tPwPIzv9+gOGX8eEUVhn+yrlSNbkfPzaJNDMiWrbI/3oPUpRDjC +CkrSMZrahRmQ01O7tssrf4TW91iPbpGEvus41NnByI4eQLHYnHv5ox1wij/Wozsc3hr4yApoy6aA +pKJoBzKiFqtkWF66x+M93AMUjiHM3OOwGlcaxuo+DAVnuGPgPt7ziB5WkZAx1h4yNiOI32oU6PGY +aX2/h/cwZncf4UVKQLRPdTLZJy6Fs68Ut7jTwR2G/MBSW6Voqd2ww1nqao5uRfdyh8d6fAt5nLcB +Ddo0gfqTgZlob8Wdtuyydqryd3p0ByNUdTixlAZ+8nKxhQ/cv0JAL6JA93tYnYAodahmLImi8c7y +9R2L7qI1m1F5dIfHOrSV9+fgEKj2pkg9ySyx0lKzunQURiik8/0eDKY9Q+k8d6Tr4MLx3++dSg/v +H1P/TQfgM6//PRavNOaWv9QDXr+fELH/8+urfv3U09c/+/erT7GIL2kWX8YylnhXZK0Rhs86r3VE +KoqFeEra9YogbBGt41vjKlG920cjxKCBXwJogdFlqLsAxpnHcq4A55GBeeAr1/E10Q== + + + n1m9OlPsK1TMIQ5AK0DC8dgapy28gsLs3CJ6FrjARNjC8qwP+1okIhVBazUemhVuAPt42PORRsKN +K8Pp/IyzDdydM+Dyi3TDih/xtooe9KX2wNYB4asXvB6MmfXdfnnH/2PtVhD78BambHhAC1/S/cmQ +jzV0Ku2YQQiFOdodQgRLlwDochhm22M3n+0WFgqfHz1bmMc8gnbby1uG1J9ZCR1LsgKk4OBXEEp5 +Fn349aWX7DHec8+Y332rPxv2FiswRZpIBr7KOzdHlrASFugi4oiFgG2lrXyL/Z/jICNHoZGKsZ1Q +eoWa2geI1K0iT6WUn4HBvLCIgBvL4tKAjh5ZD5qQZitQTYXPBfc1PkE9ii9sU64yY0o64R0tQe99 +xWVCWuA9BHvcQoevy8KKNlz7fM3Mwu3uxSGg/m7LuYnk7SBC1JNQXKrh4PYQa9/oIDs/br9ZcQAb +PFSW5brXsaHo2CiFeDawN9DdFYOp+Ou2hiBx73iMEFZ2KCTs6vuf8e5jUwh+euLCRTv6gJ4DfW1h +Cz269GQCmc09vK+8RRIQgoiCgY1pz8IQJ+xvHFIAVQkb5/AZCDE/OE+KT9JlyS5IcTsCqFo0uEUI +jgEksVTO80n8d7dJQKjg5nNAWztjMwFZCfwqdGkLI0PgWGBIsR0Mnx13vDHCpZNfE7qqALfFfqh4 +Rsba0Ka0WuaxGEs7ZmyjdrkH6JYgcJWY3P1Rfj+WmJ6HR8Ar+QN1bDmqFaR4Sro+X/CcXA2jFvn5 +dz56riUVpRNn0kCuxTAB4rltVzn2fUX0HESNUlgkW25hbOdAeWTWUfEwdUXHAdFUMMIG/G+p0T37 +GW9LD1TFve96//El1+1+rvGGHwjc35biuwDwgVgfe8Yuv/g/V8JKCwpzDoPU/KRhIICYwRBIUfem +AUkdPZ2guYDiQ/ZCBeyYSX9S297Kd/UABFMRVF8g7YoWhdkeMPHI3vEKJyOBl8TNoADSlssSItMg +XqEbaOLrJfcEkyGH8/QRX12JRB24ufYj1kxEphhOvnqbJRrnRABktzFuskCcyd9d+Lu09+TvzgXZ +ZoEiRLlSnhSj1cIDYb4SSUj+7iIpeA3SS+8il4ggSSFtNW7d+uq5AZRSKWxbHGfGzyONZSHkM/My +pp5xcu4g2Lh64uNbeKfe/Mx6uF0tJUnvzpcR+UA9B0tunxYHuSyFpdYuY0CPVU/PCx1b+5Ia6IC2 +APejIK2Ep9njPB15zOH03G2vwzghdjtGzacY2H6cTIrKy6jJhIX1DZUE1Kzsz1UuK/pdPWOCx9zS +Qm+udAFhpFos4WXEb4uI1rt6a9DzZ4QOrLzAUCH5/6zBIHgdQ/+I8Sp4B3v4m9VDct1NWDT3h/SU +REVbfGQsbIU2P1APOGp5yhN+iIL85GQhuraX8DLiOQTq/kZlql0uYWRZoTUc+RqX4/aAPIepgEBN +HqYwHCxL8rJncIsewoe7DUb6bL+rd+DQPXvOLzm3wJuf+bbHxZHQBwpPSC2Ts+0D9RhHzyogr0GB +CqHzwIXsj+FrwzgidQ1AQ4l9qbY+R4ESwAGX9hZeY9254tR6HgkkoZEQFj0RVyuxFe9MZrHD61wj +YD1IVTrXyGM9Vfqre+wVOMKHW3jIutfjk9GhGnr427mP6WH/nnqrrwKSHLNJD1HWggvrvDNJmhE6 +qpHgFb6L88GCLuljwX7gJ82GDug9rGkMXDGNg+XO0Pfz7LHcfl83cP7SOXuRI37qIvfn+1YfqoeB +/7cHk/AQx7rs4t2Ue+HOuSSQ0YEzK8Aww9jpOJjIkXGOahxMtz0+mMpFkPhkEkwkcTifJxOJOcJm +xBeqLdDWeTKVyMa6PZnO1zwloFAfc92eTfpO2U23h5N+oVzz28NJCc+a2/NwElxlpXnncCqBcDwP +J6VYWSX0HnCm5O3RJPBURc3wvizO5zhPJjXJ8DlPJnWA1YujqSiFRLnocTRp5AYC9DyaNBJGYUTU +XuBeS1DJR3L0Sac9jybBX4ZjbyxtJZFZoJ5n0/0lcSs6RDlAFlcM0AfqARlaLmqy8vu0XE+VtYZg +OVXWWgBbKMbbMZoFyAPoJmV5r29B9vKRLvLxzNwvcfxxhacyrOyaneGTbxwPpKegRl/eyh0VhHSN +aw4gGg5FukerclwCjvWCDDiy3NnuEUZ/KI1iLF+1wIE7r8AdjvRCosA1eF7PAwKA4UUI7uGRG+Zy +wpEHiPNciWXgYgRCRcM3DkNg1Il6HGQKFfvqstcffWaa7kygDmDu3UgJ/EAZKHhzz55Hd3rsfxQs +GBOkn2wQRsiFS5E8GVA/YDONyC3Sn85tIKSytEPBsJz1siIZUCCODiyYFOVTGW8R1bp9RAs0V7mo +QEr2sUTDqFQiiywCuaAVCm6B/5SfIs946CCdcist5LxhSmmzJ9zqQhr7kHXbKZ8r32qignRX38Gg +3uE45Z0PG85p9SpJYMYb+zumPv4ea4MLMu4g6xK6o3JjWxhzNTLO9gEA/JWvwK3XcTkYD72yHc0c +nIKAsZtX7UBxSSsUkvjGwI2GPxe38tRR0MKMrco+JPR+f5Gc6pKefefc/UAD1BbZ/JY9WggQYuxt +pxE2C0gljSsGFLCfHXDMoYHGsdLfJy/X9ABVG7mGcXse/vfe4HGrXmDtgtruaMQHShsZymIMRKRy +P3w3YYvJASIVSLDAGokpS8JS7A2CJzZ2ag10ihJZ2MYFYKfTcSp+jSPCAEqKIyH7dOVrdfZ6WUF3 +2rHG7vRM+UhatlYuODhgkEsb17nTjKID54puoJMS4660O+0WSb9njyINwkjxmkSp2kUani9++iXp +QWpJM6mkKA6LKc74hrBm5jltbjMQG/lBzkC0B8ZwhRb6V9zg4WemK4TU6/ddv3h8/2q2KVQ50sR0 +xIB+HlZleD1BO4Xme59DP9kRC4DhfZQToWDx5k6tdpSPqUDXwq55X0ooADA5Y1MNhevuo/TyfxP7 +j+w/3Umu2Ikglk2H81WeiMGbyS+U0wX8xnuAmwUy0HnXyKfVe0xMG5mayx5Xbef3P/MoBvokLfqN +YrW9J6PcSwHoKotqgnTHcUMan2CmOnGc5+MU9iqHajbyncxzTqIM0wouPqXYtDINfR9g2cmseGiE +gCUihxogBGfRaJMJcUcMSikpRzzCAm94JyiKPZ2FUyFzkV8mc4PSEPg9UlKRscmv3Z04tKeMNKUm +QSghXY5INbKY6abw6YfXMLn8h1P7wNt2EelUZw5BZKF7KpZ6SSIQyL+QhjDPTNBJAFMJg1KzlDtz +ZAZXKmd1hgWTkUldZeB4J8HtJQk1v8qGav7B4mLi6RL6Z+4TOHjyPpPfmKSHhRlItpQ0pd2e1Uw2 +0nnjAYdTL/Hw69AuZF5Ktjv3tWUjELD+lf2qIIFgGdVZDMPJz6vGPCkv/qGTh5wRJayQMA6yKGtQ +BygZxcfxOOLnuRTO40qyUbfxoCHpzvMBfK7cIseESapx+hE+F5EcdGdcOfNP4HOazb8PQhjym5yZ +SOKlUsjkfJXo4rRuXlJkRZJ5oPWtT9kitcg61g4Q4EBZ7VJglEtSWBjqMT2VIIktCDrINRmcuQhF +2rn492e+Ci44KTwyiVAvuxN1D02kxH+NU1pBa2XMZA8ntxJLhGgUlOosIaYcm2rlZPqoqcFlIDUt +snjMtTXMJlGJvQahlJOuFBozYwEAFmypZVYnma0V6oZlVRQNAMELU1hKZpLCay239sSuShih+hql +GBbg/2TzoHlAYJB41XnY/JvK234oEgWgxWU63aQaWg3NESQZB7QjsB6RZVuCYUk9yoCVjScpKLsJ +G3TZflK7o3+X5aEml8ZJC0k7hF9krsAGKEFp8dAHhvnNtmGM1RbGYWknVZlNs+b0lR7xDRHLJBwC +xKTFhibnNA6Cxjvtb5tOeAFRqHdRRLLA9sQwy79Gtkqr/nryeAtu6nSZmoItQHpECdIJj7hg0ewK +9SiN+zSLRf3RB5NLoPGkAqnG5+uKJLQsHVKz5GWbKSzvQjP5+n7Ez3GHqINIfAJF6rYmOTmRjzbZ +y/L1FU8qWWPyBja/ogD2tDt/nhpOHpFBARzOIlV7sKCZsEQMlXYjmU50Oej++h3kQkRdxGkjdLnS +iBSn0Y7JToYqToWvEe3QvIB0SBF/q8H/FW5WU0LJIFFP9hXOxszhXq3AJmjHS7WwF7NjPVot8n1g +WJJwBUBH9H2Fo1FOBvzXQvQcZGgVaTRqy/GotgSj2jEVOoclCoq1IC1Y4RRkmtZhmpNp0rzpwxQu +mWwqEBDAEh6RG3d4rRMUk86QvCXIhkVnsIuHbIkqCAeMJFyLDsAmZT3jO+gsc5RXGbItwTToM0Be +WI5qrevsHqGXWCIkDDZzv2iOOSWUyHF0Sw6IinSYKx1PU6ijUkd38pSR3hIpTA9xGSAPlbhdEU6w +MF2k4m4LDaqz/kDWPNZTw6fg2VUsWdtR4tumUZ+W7pGIO6dtTs3RmLah5/B4pziOEyNSSZRcDkY+ +lLGP3aYDPNmhAE0G9m5LHrPcLirAQwlpnMYoCTWbF3BhM3OSCMgzOIIIxHABpnMLpVlcRr4eXhTl +zyqWIco+853ooBg+5yhRpwHRehIJiE9mWw9kzfER02cQZAFO8zWJQCRjYopPszQcwc0xpXiJK6B1 +vh4WRJG71Ph6wfrEHJDLeV5qrNVz2FLO1VQpW0rzufYcVPtifSb34AAAf5wim7naBGvEcU3Es2pw +QCCw6ElYcwCt1daho7YCamqLfQUKkxk9I1XYE+TL4RGHza4cRAdrNVMh4M+HQ8aUCG2Y0MJsEs0q +oYIysCUpBXma9sZDPIKQpUaYd5pRDd5KWCHFD7CG+RjIJ1/OD5eepOCfMtATFt2aJ3L3GCaAgG2S +QImeK+euFEo8kOYSMoQ1Dbdlct5p5vh5vzR5GySLeTSLyS/Mm5AOZ0ijG4iIIUFsyBcOUzNIC1HK +tLQIeEfMtGAtTrnX6UyqxkgV/1EGymtviph98jKjgnkysIj8VqbyZBsCy3XqfCkLlg97ZUdwhZK1 +X4C+AtFsy2FkfsDvOXTV7GxS0T0k99Rk+gfMQ9p+ApQ+LfRsJzg3a+Byq8N7AM2GMswWtkAO1LRZ +08RM0Aw0R8bIpFLwgPaCmgHLuJHv2W28QGonPG+BFIPABgvExBJ4rYH7muNkXShOjUY+LmSdW9s3 +3YqUfVlBGYw7FDAmYoGsliTscpdrAu2/k+Xg38O+ow55zmVfFbeZCT1J46j2PC0evFayGIvnDPqR +Lk15MEVJ2q3eYB0B3IZJSj3TA3SYv2YvxOZV08PAHHy2f7t1W2fbKwHJPWNdSLZ8t/n5z0N46Z0h +IbH00/xILZRNNpwgvhfZ9JbCyylsPgG1aa+A2uJWU5vRK05R5QrTTxSbD3qkFMwugVNSLCvyAfBB +IEeIiuseYYdx2JEWa5Is5wuAgENQYTRomAXgbhFVZ5g7ZDWw+IkAQ6OILIQiqoc+1w== + + + GDCabN9kBirZtGYwVQ9JCuHUOQnT1IZJJ3nbQsnDAm6BiuSK7CPLlLu2NQ8noKvdyftRTxq2mxuH +BrmqauuQULuZn4Bogj3VOuHN0ottjgSn7VNVR2CPXDmeUEU6RU/2uaRd2Q9D8HVuLf+9rvMk4xQk +AXlg3Cu2wUrvqAYKJqmZ60lLpVNYPX2i8eDGuBAJNzPPaNe2OO+xPyTZV61W2ioyB9ErJa/ZNXCE +CgKeUEJxWY3D5mzwV2EmB0VOK34AHf4B2UHVjFpcwPNI11dzrNDFVvFWs7MqBU2RiJ8yho8lUTNN +EQoi+FidnMUaZOgHhrgoJ9bUa30bSNZBD+VeQON8hA3aUUGIPMwgjioGPVjF1WGghSwcuaw5xU2g +6Vu2QRHxGQIoLiCMrw64F4ISRu1q+5B5kDGXly+o8Xt10LTegdAsEZ+gXWsYorhAsq1hBVYFCUXv +yPP61OJPtjb0evM8ZfMjqc1pe7IwyqV/cEctuUi/r4QRFtawvAZHt6qXCAbzcVKWxgjzBPBHk+ge +NjZYLWQ4X5+2SAu2DR5R8SxBTA6BBPqGof2YM768ZDzJJdjDtLnFvCWWS3Od5VagTwQsJnXXCZvq +aWZPszHTzDSHinz4Clxc6xKXrWZuq+GIEE5h1VDcF5bjkcxqlKwKlmS2IdEIYYAftlXlOlTUad0Q +mZTPaZBeIayMBlK7UzJc6BpoQLtZefJgGfnP03AcsDIYNAqHKphczfq9gGYZp6msdGh6ReK5bAHt +KZzAlpqNkyQvlXhCTTndKhRoIMZmeIYOmEc55xUIC6ZaFo2094WvLxdTbKtHQV4hrYaJ9liYufiM +haqow0wAAaQ1/G76T+we+XdMwGpv4byAt3KYY8ppmJDjQryLhzRBKQ4ZD07RVQxfdARMkrYB3QMH +LOGtBPdsNwLnSyITQPlXh5cYoMBkb6pWoESCkH7CUmnJSvIa+wcJUfLxqbYYM9klHQjjXiZss5za +yXM+TcYPSxXtYddiMjO2aRKyDUEAiVhd2c6JHNzIOjUBkRoBJmFg+URHryF/mn9QHSHS8ap2NhPj +9AHMLw73yLPDLywMwMX4ChORHs6ZwEM+3EPmGPztwY/Xup+aTPJ2yL+cT7iBVgL8HJe7CuwxWowE +tiBfznenEMyzxRWtW3YvbsmRK2OpmNzQplER1iOgnMU0mor9gtSVCiyTR/63fNjolsHTa3wX3kD1 +DA9uLTYncRrAn2hjcq64oDQYoRTNAk4qh4UIo+Tlz0cAvoWyOL8BWh/16Baw2h/TRtbhttaF2nUF +7W12uQc04ExOfTB3enK2HgZDHVQ1XGB6JglAf0QqwdSXvABM53TxkeRghm0nOlzJBs221vKCSFHT +IDuJjh7f08MiLxh/9jinOvw3kp54o7g+7jZH2GnxPr56OV/sMCE7dI6N+7FmrEGPYHQ1NxiJzXQ4 +9zKb9XIua9y4zNSeNoGKrYd0IhCHrQM4zW0kE/YEJnwSJjrFwzTzKMwiIDeDtCnRmnm0Szcd4GEW +GHkiHPfIosSioIHtaUVSgvE+mgssMym86Owj+Q6tWuEiYCUQuDRCFLDqtmx9mV/oDdAbm3YNtxmo +cr/UEiuZiG6XLXVJTi7Y+xxuuUPxObVHs+WnJ9M+2sUSZBiyIPtY+83cuc30lsmAbHR1NVuNkca1 +T/GJVnyBU0Oz9Cv+fljnHM6yU5TA5ieknnfacJ4C+MJyPqDFoSN19xgJD3qLtmcfvnW1yxHvROYo +FuHBLc82dR7Uxnxa5kvjs/E5yKwVzeqWR/6zPoW2zV8QMvsB0yzhbZnPX215K1v4okSr3m3iHHja +6Mio5oc0abWVsgRnYTQTmjwwP19w6WlB1G6LBjCV2sUmEabSu7piSHriDjBZ7LTJQ5QU7libLwm9 +WB29p0tVEQoyrHYxaNQe/gbKo3BF9ztXEVMmyA5st2XTJiO2e2BtfYEiAEQrPUxNrm5+cXCHdjJe +Eg5JEd7phwuOpGmVBYvo4J0I9tzaQAliNFtFsNFP62EyLiEH0eaz7bn2EvcVZfgK5yBOe9Xhd/Tc +FUdU98aPyYbYs5PaaXpoyfweAJsUKEcSts/ZzuFIgAZRNL7K/OUXlalJKszSnf/olwJ9qh4xwEL8 +e/AM76IZqU0OaPCI0y0iCDYc1TnTdtkCkvOLwwIkFR14JurUgh62CKl74hyiCFLjDuaCkey+GZBD +y61dgt4vu4CEI+1oCeTt9MO0uVNMYmnYwjt9H2pr7OTuMc2jOLFHstvgSMGRHd4aMimDnk7tjvmg +HtZfNjWv2pEJn2Quq93c5nTxFUGQiktUfMuK1tNOwb/ceQbMqFyRW8WrBJ292ooDyWNz5Oz24XYq +MVROMo6KApTbMI4BpkQneLldIchQj45lPFfLBTpy5ctx+0AG3nHb1YUWSo89Lvy12ct15n8ddQYp +LN6TdPqlso8T2tPEhs2TadpmcQE4tXR4zHHpZLKuSEPgiprdTsNtH12Q3KbLPdSe9sZhdvP3bDRH +8Z4QOqMG9fPwPQ+PJMmWySx3+MIARKlDPnfV6tGqhBTdHkL0ICWXKVdDbZ9E3elGQpTkzDtYeATl +YeqGN4sH6sDmFZ/3CjrpZALwbYKZKUqu7gQdPOTUWEFql0CxaDeqLZLPXhye5e+0Eg53JeMJ/NCL +IRFkyPV8utbUnPbuAYp+SJYerrGgIRRDuSI6+oWkf4LNHQfhJDNZNO/r1mOojLzDvrwtYE3irgSJ +fvGGqKfwxp1yMs0UmIoXFlpSNWmeP4evUz3JNPAHElyo0QHN/DHsbsSCpBbPkTwmXWqs0gqlpJ7u +xVQNE5YDcnp1VyN+1FP0dzL+RAGuOgBiqtcuUTt7kKqZunuJvMNqBYxfrO40TXOIF8wEqOn9klOk +VRBU2sPpM6I4viU00+Fk7WJlsFOTAOr6OofxTokmPkCanCnFqq06sgsREQjjjrmYVPPIbte44hxI +EVVSOij7DhhJ4ukUzlPtC6HNvpc/e81l+nwPzJLkV92bVVz9qpxX9CiHJes2ZYO0XAzLfPvJayHo +uOnxD7TMaPoBrbjYkXRp7neyuAFp45GRHVyird3/Jgw752eWYRrPy9xMteG+ZmbILFJP8hajh3b1 +V0N84Hx/j5MPt3RD5OEclhRRgNsbCC3EE/vy70uLVzCTaInllUwvZ8WMFcBHKhramQmqrsFPaQ86 +SQWwGuV8xwcP4vDcZEc1Z1HskWVAYvHiwn3BBehH3LKUkyuSbWhqod1rn/4EHgty0KNwUt7ldsoB +Z1eDi+zFlRMeOoPdPEAn1RDqOvg8k62k5JfcJoc00GV01wngk/USyw0wFYWZjlvZ9+6VFP7ur0CX +kYkAM3ZUxVocVJa/hfN53pjmK1vVmkHIoraO0imgyXC8aoEnEL+oVK7u7A9+EafG1sNNQIIbn9IS +hSua93YE6IEXDVeAU4FCgpBWGkC1vHsl52vz8blV0Al94IyjbkL0WiD6Jsx0+BnZwYLssZwY8D7A +Rec0KXniAz75MxJBUHWIUAJfbTMBT+ezDhKEerh3dYWrqEkvmbAGzBnaUe5NnAADvQvNBpN8GLAo +5UiSZ0D4mt2G2yyoLeUPzp0LOolPKFzKlmgrFEqMIQUbKd2Q7P/RBQ2Gd/UkbtkOVUYi/pX1jhWK +frUrYvIkqA01UvpbDxyqnPvW1vznhFkm+17J7lJUhWMZ0HS7LRVqnJQvQT/NFaF5t8lXwH0DJHRN +k+wmRxvr9DAl80yrJiZPiAqBycUaB7Zlck2LuOJAHwGxyVsf4mND3d42Hu1kbbqM5IJ2B9Ag9TTI +ZNaKt4Z2V7pTs3IMquCh6qiNgLZCedjxS1ar/4U72DajMFvxFS1o54G5dA6L4l/oERMDFXsiLnCR +QPUABlbbPPZem5LUfslEDKKj2ScbNWbZI8JAe0Az5lNV2FVU4w59Pe+Ad6ETcrTlNUkg7+CPsbyg +n+tBZtSjSKTK9E3be2DUVCFJQENZd8sF51pXTlEPD2d3aCao+wUYFR17D4mr31cKqsAVykdsAeQY +OpBneayOEXE/gByC9BXfg+qU/RKshFZRGqIQ0rLLZ/bcmV4VXwAvYRrn5uKCAucbpSCAbnPRyW0c +Hi46mQzfN4ui3BckG5sRU+0GyYZyPsB+yOVBvvICHQMaAfj+dDrZYgR8BUhC9cgOFlQW3MLyES54 +FViY5fJLIsFyfqccN433HkQb1Sb5wqxa8vt0V9rYPcAzJPh5RHchjOVsELWppblgkOQKs1mpB/gs +Vn22Owpe1oEmjfvKxYdC4OPigrzCLzEdLmy4DYiTQ1yvCzqwWbnMMulZRtVMuZKhtjNohtC7J6O1 +CGH2AtOJqZNx0jFQLcUjw9vUKJ1W7Ocj384lRGdUPAh2EuFbMse9MnSKbxkEZIW8ZsXuASrggEnm +7y8e2lLCnalzQXk4/Hecn+1MR7UNBVM9g+SqI04G4tB2RRmpQQ0VGn/oTMtXFKxC+T8BkRFkc5kS +/KIcLIYZdZeaklHtSgWwI8vWyGbmhTXN/CK+wgKBe9rrakx58GmqvcjYyZ7d4bJuekayS3UYqN2C +J/r0/LaboIIerggIdxsM+S3scMGmZvwiR5Iyy3k4tg3ZJD4WejSYzsCiySMPEk8BixhsADfrDLiI +X2J5IPZWH3dfivx+v9QyZn01qL98qrQwipXJxKLrhptyBZUPW5jJtrO4wtEhag+43k054opLT4a1 +8cABQbveaxsvL84HRwGoa9BwEuPzd8029DS3778U+b4tanj0wGWxXI3kP0nwlhEf3Vpnhdl8Xhz/ +ogFb2ZCTWX0BkRyXIRqXersdRcDNZUzYmGYbXeTDOvIgTMCJGauVtFAsa7UzRTP0AOjElcFCrvN0 +bZ1u5149ZW8DQEKBX4c2JLeVfjWdkt6inoecFHP5z/D9QxU4fQewr9ajFb4h+SZIpkA0HB6k6e3e +7J0mwSpxBQWY1M5+JVPMiRKGddes9ZwUMdRBmTAWLCFPWjvJs+uZgNmihA4QnuywVqN9qdTU4iOy +EOuUURLg//zsar8/Jcpbc6Gp2KmHQYXhO9FeLoaGlosESs34AQMYg5cb7I7EpIta426WJDeGdV2w +fACB093cQY6TStADwj0jh5ddFhwWUYs5Uie7M1imvaENinHa4VmA6c5JOy2TSunzSXHxscxVQMr8 +gPbRpwXTrjwgE901hDwJnzm+KteoBeIzr4BwoYoP5DyuoCMXXOawIGumGyfK73ElCIybc7BVZsC9 +2ZNvDUhYnl49d862F3pHMt7ocLd17sJ4nV2spgcDpLUg0lxIYwdfTpILWa5kJumPhaQFebFcvCbY +SiI/WKh7qg/UXg2v3/q8NpHy6LvzGFgkxtCB7sYqSZGjKjRPIuFEEBFZrkraUP2cFIcLePNlqtXu +dJFqv5PcTs4QAZiuRZX4Ae6oS00FUvm7S19PF38e9ovKzkfjES5FO1eGProN5dGBJw== + + + HyAMEiUyiJQeoDQruR5Yv4c1SKqbVMK1srSHdEUlGbgQAlNYKHSaYclOKMJKR3Rupyi5KwZrkQ04 +uGiasSMKABGynRQLDvYkhVkp53EY70msSY5GMCoJHu3smpvL1MRcQ00DdZHcqwC4y2HMswxGiyIS +MlMh/JCPBEx6pu7BNekb4mhohrRRCusw9ZFZupIx6+LXaVC4W0KJE4gqxRKyrZjKyBW6deqWaTYk +Ee2ogmZPLqILuUO8NmQbwuWEFkYl8gapFKhZRezBPqByEMhF4UU1xPRTfJEMW8U8SoT7jsfasFk8 +RO0+HAHC9G+ACIjvIElaGHLEf7INmkLJ3mTKvevTTEuRiz9cfePakQoXxJ5nEWTKRgize/gKaSWK +JGnm7HCv+Cs6KpH84Z1SNsU5rd3kKUvrx97mYBpfIcbogfiVyYG3mhsEQ2EzaspMhLIRU7u4wLqK +L1FI20S8S7EcKoibvSzZ8427eeFm4+CRd3jaKUfQp9oTG36/YhY6KZXk31acuRwwKbtypJzFA+Q1 +3snW7DA2BXh4g8k5l3tUcyLv8HCMt5jqRu5g6sacbs5irCc3OnDWMkf4+5vrEzk7N+LA8qtqZE+g +TcrG0gVVmOvCcyJDwTZwjBIahFpuuCBGywFJcrwuGbAglFOzG3NFWWqy+jU+gczI5i9LIQfEciVA +dTIxKixXiQTmEvXJq4H2SpZeFIGG2u3MNc5Rr/usWOPK8nhrD9NHauNHyRqgl2JG0pVR/gPWov13 +1wORd0G8Rqr/JaeihCV8UJkLsAThg6K2sXpEXiB+KEi2o/K5RNg4osLIDNwdkfKA3wqGN51DTe1S +ksz8+0nBlxK4RXg2BZHMTjEKt6aqxRfqRE0CfOTJRSmaoNrNriO2YkPS7pSKotiMrzCPNNYXyXoQ +LU8nR8rlSLq5FZOH0CLJ0SWLWsKeY5qwfSLFjGRDwQONZZTtMMIup2oUjr/kMtQjINAUFSTPbxhg +NKKqQwnqbQotmaKGUy2ydsFvki40GfJ2SWecro9IFSkKOIWdVCLBYNmqKVGbdgavaoEvSxLq5OYr +kdk7iVQ6WxRKaL/PspUgcEsjDEl22IEfmELOaivGPYNsY5npZwrLTd1U0k9zorKNUNtlOu0ULlUn +r6HFpuNMx5W+ML3uJAtPLLBWlQKBpIiaD4DD8LaOVYoMTOWjRZUUFOkjiAgOnB/GJ2OTa3uROnxY +i9fuO5xEKRtJ2/PAhSUdSDkq2r+wLx12n6st1bJEeeuUnErCO0lHlAAornMFq4VEhI7EgsTn77g8 +AAOfESAEFQjmEoSprjRuusXsDFnDh2X9q0fmprQm5HgOjrPhY1mi8KjBcIR6rjAV2bXTZc8IfTln +Fk2veKRNcKT8JInbadBzNC+gaaA09TSihVAuFvgkY5EOmYgoWpvqZoNT/G+uKIxGPik9rnPm9VEN +k6ZInp+RztJrpLCqA5YlhZD7ipAiW4QQhtqlBWWXPk9vqXxAbVMU3Gq84JnzSQW86SRQvIHqSE4R +hjbgPIRU8E5iO0WZOVKEjfCoBpFIi9TC0kkIbXyJw7makgAxgwan0xUYdPHbJqeQlcjW1tnsoh+S +Yy6PLbW+5LghJjH6ZjMooATd+3IRIfXA/zrjsB9WIHSiKPcEaEIFPtzMI4GaUyCgpLYt4ImB3gew +DYBGC2ZGxDWUsYtTLpAn1RyZpBQLVpLAreXskKMUq8AXE3uR4iXdW+coWkI4vIL8NBh3hb4XeLQt +U+5Og4Hh/hLSxlXzKCxvtBaYqxSOTmGOEgCqUQ0gOhmcWfSu2334cwnvgwYLlEwfINiSKw9QUbwC +u3PdhGaZJ7wiV1Q7kHJgrlztQJMr+PSSKMzWixVw5TRYmBHS1A8SsbSLQEcPy5lx8pTGiTKM9ciD +O3GBCCpyZMeO8Axkh3euRxyHedwEi90IqlWxH4oLfYQ5mNd5IHXoksXJuCIuNMiUKsmAxxHhjpIt +AyYJu6xc8qak9LZSO5nc5MbMCEYUF1ngjIIlMbK0FZ20jVvkmNCJ4RqWLWoEHiaCoRgjocZkVLYI +9hRpPRVYmWwlCnEWlIQc2MxslEgxqZxlaSVVnVLmqKuV3PaesfHg3qYDZyg/OJwu3yyMLf+TieN5 +BIkViUJHaLjF9h/lZYp3XVFVncAkQAsbSVNI3nGxBSV2hfURn6iJcZPTBDRtw8Xtkxzgmmj5jgBk +LShPiS0bVibvnEhRJQe08AXQzPLsZAMzZd/KDDwsB46bk/sVEZ2z+bG1n01sy7yTO8A861LpWDkb +DSbiWQEvtZ3h6xNyrQH1R84inECYaXvLk6gMjjG6UfId+ko/OojEQoQXW4awA07/AoCkckMOpwtr +9/o8JQl9ekgEplSOvwmwR7NjhVsn4NJyvxXjhjSk0BIUkzVIwmq3i0muFgtc021Un/BB9leba0sL +HtSihLWITmShDQB79Kx56RH3jU5y2r27ncelzRUwHuihpKM591GvSCLWcIYRECjkhnr0dQlEOMny +Ofv3Uf32sNWZkEvqGMZInWw9XkbdgTIog5bHxGmrZ664zqVgj+PWnO8tO63dYBqqs5CTdxpgxn+r +Zlzy1knOyiCpHmMSB1++cRUp7d7qFK4jdrN04zOFQqrTIpqnZAXBHuCaT8lZY97eUEcouaF4dyFA +YA/DtkORabwE3nF9xnAKF0RV9Saqp5D/kPmBYzPVh6IOfPwSzdDr6kVHMWqXiKhOwmnNeYCoOb3Z +d21FCFsBJh2b9NX5Y3i7+YELZnfrWCJ4706DPm+poJ7z1Ges2CqfmZLOhVjQAd5GpIW6jsG4cZkk +5Rp25hfcCBW0s90UzWmnpEfqxBtG5mP+eBM5m3nygGonBIGoDjySwh9UEl+cxi69IGim8bxsX65A +CeMYdhzD0P5p4CivwAV4e3kn7DOAztM+f0i4pvebfPYVcK1VMMYpKwtZKHeZoco8Yc0ue7GrS1vp +OF9eHdXbjVyBzHqyC2kZg9YA5iGuqHrwrldgIWcDilItjxHpM4TfxAhQcXyleVK2AbHMIBRMALBo +ut5W0HNkSy0WIKASJXFRWjOZKCKnYBSVT/DIFrJn9ixbUYI6eCCwZUkcSz3c1+Uitkk9haVD3gqN +PZXSrac4EpRZ5FJbjLpWRfFiB+BSWpRqkmtx51DNxRVz2KVIgNemGnS81dujkORwfbo/iqv34YM8 +wv7FMyBlNGEMsDEzIEg0d0kZOMDNWlOMTMzNNdt1kuPd6JHZtWynZpcb9FlEplYGRZL4BZTzwzs7 +Rxa92krz5gqhLXKYNjqLWQ1heoupW15x/bcAwsnDyef8RZk9w4jFfGq1wwtSPpxEXN/3ooeirlLs +5FKXFt+5ARWFpxkt+D3hE/UMqFH5YOv9WPw671dFwUMpyw5A8bkTEAXaPKoIWpnOecWCSlBY5uK8 +Q6kyrvemHo2QdB3FxHI2SwLMQHIDC651oDGS6vjQVRxEo6P08+LsG1VtgCHZ+WmoY+PGC/LMopMl +27x9wG+LqVc5glr8MBJHuDQSFF3nvCufV464jMqIvqS9oJChbESnjOdisPgZK9BaVzJdCWmsYai3 +NqPp6GUvaO2JqStX66DNMOOTY182YyUj45wJxRqkcUkJx0AszA7+wBJgXtx0KLelOESSlzNIRY+U +0AwdYskmPn8I1/hhFipBAAo4Hn6/70gkgkQ+PGMr2KkIYChoIW8Vk5HMMSW/qHxe8lYVl3Mn/xY/ +jPIM+DBQ9fC692SC7AY/VJ8tGLZOyieCE2q3uAFMUh2Zxp9HKHeeVm1WW/Q9Fo6dJ8F+gBaOsqYF +kKJHccaTZUltIkraP9l6+QQ6IT+XTDB4qA5TUg/7JPH1iP2Mj6gpR1o9vFo5WAlHVGHP5p6qy+n0 +Bc8HQesFYYJIqUoyja50DyJMhfxXPOAazJ4uitEB2Tt0gCcXbGnmZmiBPJOTsRIClOqEx4NiXk4D +r2771CEhAnspryB1QD5qjrqT3dknLPaDg8w7uF/4AksMbDePidrFOwydpNgJpf10ID6hMzVRVtPq +JpG0J3tlUrPuNXkkHsXQ1trwFh38Agch9e7nNA3R7N7UDuBWi2Y5QwlP14uDC0aQFutLGM8c9KZY +ZQIQpVAJ7KsE5BXfRvPk/IAzPrKYgc/gBjQ6ZeJjkdOwMdXKDiw2Oki8JW3OkVMkv3LQtDUq8c1r +2GEgd0o85uTU0J9htkxWhvTn0YJ3UmXooEbrhrViz8N05uwJfGUn55X5NjNGDjSDwiRKyiv6Ww2M +W/gty6kK9iieCk+ZsZMoSTJzFGABGTnWhZWMlzLbV4kctuTTpwYaXu1l2kW8Gr6imEnsOIJoxtSm +ZJLeJz8VozBcwtWEpXz1ISpZaXDAYAvUSM23Fbg3aCdWpLX0i9qaDN0FBttOP3yxEqAJHTlA0L14 +AeCehYUngzQZkUKUA9mSLxBYVHXcMeqpZsTuFqJw7GQAPhj8GlaAD8O2L0NixXdeZr+tmm+JZZJ5 +CLWoZLyZk8eLiAiXoLzStnvU7hUWWJsckKjnhZiT57gY2jkNK8TtBvDSKaxT5JxanX0GsdLJGER6 +v94J6PYRd5hBAHQYHc4VzrVeFz4dQN8tQjgt8u4EaSyExvgu8xeRRQdLq6+AW8mZYuWSP0uF0wsj +yTJU1QRn0wxmZw6d3qXimIRspcTTvfyx4aGvMv+TWOjIGz5fypwog9wdXYdFFSl2bdycYLJiy5kM +5KCUgh9nBB/JCOaZE283nKjp+sFlxWK0oWNKtEC0dddE0sozxyg9Zs4qCpKd8LkW1j5MW5FRXgn5 +8z0GJRndOkkVAaNkslij7kDpWI65XEGjYjrDM2wRrWFyJpOqRDoQTzD4rxK/1Mvy1TVYRoKWCH40 +IzWbLUhdUEzGhu8Ue9nQpGyMEyQAmKiGAgwfvKIFhzkr0qaLEYGkkp7HSR1e9uRAYPUaqG2ug3vS +RFKmka8CKwk74ANhhIS9h0OiUqChcmzpBGXlR0p1AQ9l0CPFxNvJpnNWEa7Ge1GFpGKeEhPnim0/ +MPwQW7QoFwIDbjemsVi8MV1GJEbP4Lj+onYx+CGheqmn3wEkBkpAjxSoAGDcMeICYJGmI4eePYe3 +oR7tsbY5wtTTTQ2clE2qO7QVvAPZZfUOwyb3o6JQuIXonldqt5g8MHhY1Q5CuFIDF+sa6urpcKdv +9bnzC/MSnnjTboWaofVcd0eom7c9nHMFmCzkDVJRmvFdhtjcYiSzgdWib+lGxR4msSNdC1Qs8694 +azOYF3Rfv1SrAhoCEjTWhzNQbtGjW0G1V2cB1DbCrEWmKEg7HCFa+MlYPNxecpkMrqio5aBqAxtT +Z6B9awO7Xc0pMsJbE9WGtY3X8ktd+MZ6lPVZFlLziBribFYJ8eqp0Ehng5ZBuIagNedkFEk+2/79 +WLeCt5G+zlEDKafw6YLuo0HFrtjirluYT2PeQT60yCrX36cPkq3YeAEGAF2p7RNMoQ== + + + abenkxmF1M8p4OOHJ2/lOPCictj04J8uIzkSG98xQ7yfaP8ZLIxRmlBtnoWp5CN0dn/5QucDBk8J +UWeY6JhziV/Djk5dUbCjw9rmitT1AA1eDkIhw0zjQCKpEiNiay0XGe1npXLYR5XmgA5CCgIIn050 +wSkIJI8rJmZOBasOUWNX7Ypvo0eyjnrIJJLmY/HL4HIWZau4OfsZW080Pxlk0F0HoJkehsQdLkTT +WcxKxS3ZDkGB4URDwQhN5aBwzVnYWc2OV1EZJil+ABubPr9NkywW2vsEcNsA8x5pDeJF6E6tcar7 +EbknWuDmTRitOuJ2wMPaXeFXzeQcFIKgioF2E8PBPvSQJKZsVZuo8ghEJ6k13XlSzmpKi7QIMuNN +Ok/MB6LgOUJvS2RaNecGofaIBSVbvSGfaCh9OPv3GugRZYo6US9/wyW5q1AN0mg7nYz7MLvE9GAY +IIQhL+1ydljLPMLbXe1RnJBGmm5ykiMZa5dkLmFo5ckyYWRXcvYI1HMPyx2oHFbCqeyPKGTdcQb0 +S8lKyCizX8p7C+KCrNy+5PxqcUsN1yePkYoCNThRnN1FHHDi+kimKSCdsEd2f9R9l6QQBL0H5Etq +r5ATajudcKCbwVJw+AqjCNUjM2ndZgeira44FTtF1RcAviQHFMmAiR8A0jhpJReBu6CZRJzfXgDj +yorqqbSrIE3Gap/cmrrA9cXJQCSeWo5IkyRjcUUKCymPMAKoIj0FH8QhAIrwkmjZeadJ5Ygzm18B +2ZitYMFbZwKa8vmTbiDF0JmZ1V9tJH7Pnjy1u79qDMPTjhKEADpZXbbZhBEzUD2EPtUeBotdbDlZ +sFzQ4K7MeAnBOforQQoDkXMO7D6xiqPEwxmuKWWX8G5ui5NBMeTk3GT0mIgqT+fALmN0iDhgPhrm +Z7uDSmLEoZPZmt3DD/xnKogkl9GgjYNMPU4ENiMBVHs0lSYqDFFxNjQ6B7/fKkS99NB2/jX5bSm5 +hGEPXwtXjO4EfUcAk4OScBRUImNntj2ZEQ6NJ9MeYPdTwuTgmXvdAjKiErHahYhEol6ArygRSzdN +ATlICfciXwnRpTPRI20bf3AK9g3GdU5npqezHY+Afo98ZsNHLSwUJnd8b5k3tQYnQGYJu8dvPYME +oBpLBS8szSOy6eFfU082+ko5eH7C4ajl8A1o+4pIsRZNm6BU1VneyCBDq3q8E48oNl8ZmFqMAcjx +yL1NFZVsTsmuuQQINnUn9dND2yQBfiYLx3d0BFQ92dnoFZKpYg6pc36FKyCzOO7AFaR8cA8BtOQH +8j2RrgrgphpD5ekrVp/pAQyFMulHAsCNHH5Gnq/o0OEUu6wVay2mNjgvQGlnORzxFfYkFcMwAGTF +xquOzpJQyEiWoJk4IuseAL7azYuwGrpMwlA3dMEsE6vFEyJeq6S2fuJzXSfU72QASL3MDol0giof +R4ykwT4mnykXBiYFu2KjEO8FHNsDU0eEucVOPJkvTi5f703h7cNZdbhZYs2bdF49LYYh2Dc4z3mi +v9oUs8ECwBUkTvMLo6t73FKmmEPMNfxjMa6QDkl+uMp48DtgwaZ6qRuUzTQjALiFB7xilCn3TreA +quGWDLiLr1heHNRWFGaqmndgqxVuT28rMMiwnABQ4YpK1NsUxsVKYGrBoFNuop4tvCfxi3QLreMC +l33vljYwl5l2JX5gWrWGy0EHi5g7BZwXecVJVWNiF5HYcBItgPNmvsquC6e2oJwcTS24Y3o3wc50 +6fnRzPLDmSTkR7LeMWMiZJen5ePR7C9rWJfBh5cCxgc1gkW/LI/2GCUPcUuz/hjbMXzmQ5VgxhyI +pE7uoW4/es8X9AduU7iKejAL4cKAPMF4kaLa6nhouwEIrbhZ/XuS3NQBir+7VgtMCKXevQBvoa/o +VjQcnJeR4HeCqU6IhCOoE9Z5BYhjfOPm8QFVBpmCQTMgCNDxTrYjzFdrgcN17M3BBOMoOD+rbOjN +Zi9KNQjRfU+Yk+BfMHaoBwPYGicHkxJzzKlVuWef1rg5d4SkyKZWp6wXV5AErp7Ds4Fv4lR/SSGx +OjxWjdGF+0QdZmBaM9gYeCAhVLVniVcCk4BGPk0LlUxjRnq12uLH4e+klKpHzlv1VPNGZfuVt8Jk +lqhqmrN2LsELX3yLtBho4RWtM17UBbKS63AHeVYPKnr/3ZzusDekcJn2qL9leq5uCgnnJg1zMRH3 +mN2gr2nytj6DPsvEJilooYYRdxh4zvVR8F7eaLsAAKmaS9worWFyyR6cqmo3k9hFdTH1LHP/m1PM +/vwj+AyHs9nh1TOfHGzNxWTj1YRv5k0Af6c2C+E467app5ppoekcpH24sFgz0hZIHoTpPa4A6C07 +eJkv8MgtGApN9kcqJJY1oQ167DIgrAvpnWNcl/YwqyLFBADQuqDIiiUN+6bt/WXmvW6aA9a1mffw +74WPQVCfWsPnwDtyluOkqMGziB7Ulj2l8Aku3hH2DhgHU9Bb9pOjMNmXYsLLaQ4eeBH8FfKQwHoQ +Xw27J7QIBhO5Hona2fCj4jAH4VG+mvA//p5sNFKOWhRu45KF9TPHR1BnGxeSP3Mkcxhgi6ZpukRI +EI4Y2BGOLgJuYB1NZgqeEsSTm8F2Ol36gVCSUVewEs/LOJ+UBsRPuGCZ9aCJQPvCmDmdYpCCo1Rx +gVSDgPU4PX76S4rxkH+QE3AZJNKiKjVXOIgq9hvToZ5t/AECZR2u/tGNl6Anog816EyrgzHQmb15 +daEvJT7hXyj1kyjeDAZVWsWUWSvofYf5YgT8SqamRS3ijqYUHs5ZV9tcDegcgobBK+HyjnwVyDcc +xqaqZcTVzn7nEQ5nEA6Chod/GJ+/kGSSueYP5gEg41ugSLjC3B/N45Wj+qXayUizw7Gco/bgWT4C +erYUrgY7ayCZ9jPswtPhkYH4gQ+4TtfkacOcxq5VYyTM4d0kLFuh1rEogQ9Hfw5tH65w+Oc4jMZ3 +6O5MpNAF1FEpdiirPcw/zUJVWwYclXZw5SgTNBk2wEkKl3Pills1gXi5uBnxonw49wDC6u5U0h6l +AqYhxa7sUAxp9SOWObD9zv49hqC5pYtBp6IwMxt1OmGorfsXEHnjKnMz2jXeCFNSwNZSgq7apQWc +aKd0ZFPyr2MFV3R1IUM8qWoGfzkpwmovXxB+HMibOz0A9VIk4KsGxzCou8A2nowZDVni0szEzXQQ +UGU3nCkJzmVn9rs2pbSfUrkCio3kcrPw9IvAniwHYYRdOxJ7j9NHFTHIyHSygxDCs4XXhJ9DNuf0 +U6qULVfCIhnrqK6qnIZrwsJvv8jikSSlnJfkXZKvMZN+WO29w3+u2nhw0yc7s48S1StLJ/Q0jPUJ +x7PCZtNk9QHjlMLXu6tvwZaionrECSuC8l7cULHE0gxQjXLlH9CB7Yqr/U6rjbstXE2kHjmhilCN +2lJrsfj9c9UZkjlfACqoZzofdmtOvr38sTLfuxGRTn4K/LUfAQNzcXrPnUdSuUBttH6leJ0l8GZk +2BbuSKlPmfNAqprBr2onNNYSHA7q0QEutBHchVE/THgvsPnFmiwIMUByWjLyFQnOdTiJFzAieD87 +PoKwQ7lt3SOxqutBHpEwQeoxxTV8h2HuLECEp+sjAxYySFyApT6NIezOQXZZszKcaZeyd5PgRtXZ +ciTSl3FZ2DhuuKLHFQTQ9RZC8cq91p0vB1Gq3G/1km4ZmYYkshbyuiPvF8AsLl0xHi5Xc4tkWe2O +RrlFu2cOolwuKdnYLJjoXFCyL4Aqmht4ezGmagOwdpKki3SSCXJcUhPJoYUR8XC9wOqETZDZZAUy +9XKUkuAj/SCbp3G5DAnQbBypZ9orihuiz4VOIiedLDZqdy6lwWMk+Qm5kPSuEAc5o2QENYZFuZJy +MnFqO4twuiLXgtbVRU0nmcQHVGvA/yAfdNqqy7XINTjDJ15C3VjkEAFHI71A0bdaAqao4PJi7QKR +IxVC+a2UoOm4C4J8nZ8T6QMtbBgkVYdW4AColAIT4ZpOmCJzcSlRyvw2gO5Gg3MxXglstzRFcZxz +BbbCRJkqxtTBf9hxLastahMFU5PrVXZHvCZeJX4R7dwDx8fbTFvJXADtjLZTpCzjdFTOnxz1ukCL +YARPlHe3zinQeoEd1JodEcHWwGRyzjpgQmf3aG2OwDc6qVEaoqLzoBeXnjBCTkviCGwhe6cFFldR +9EnSJBmdCP5JFn0INVI/ZlRuF+JYAGCq/hzgOOHPmDhJilGvcBJM62ElCAkIxhqfi/2oKOdxJo5D +I4EZ5CqxpGYvZll4XtJgQo/z75WcB6tnMtHI8lYm3KC0ue4M/2AeFjIXvVxFuIwoPlpwAJztOc4Q +CIu8uvaxxAXFdaqLqESis75au0PNjqpMamsbzlN2/R4cy1AdLKQ/fLSSgUc9T6QaWca53x5ZOWRD +c/kq+BlSOw+kvHwK9n73yAIKce9AfSi8jj6Q5Ir9sh9cBf2QiBu6C4dRsJRsshSFxCaZFZmNK0Wq +u9ZMlI40KYOCIgNNkPxo0OQuwliop6YOSEaUD+JSNNTcJLtjkL7WnVjYijcJxWoK1VDIc8mReq6C +LJG/GjnrlGhJVoEV5aWQlalPUN+5Q8OyONN9lAyYsB2cOBUV4ineYC2cCFkKnj3AV84qlHFaXNcx +kuYI+4FeqbgmwIsZc7bCuQGOY7hCFc6Q5OJ7KXKE7fqlCJjvwTmlO5AbPRyLgsnsKM4idnXubgwV +VPBGyIgUzVcEQ5asrDScuQz+F5xDikKuLXzy+D/6sHFQmn06l3QtMbGkHklnUSkXspBFm+jGmUkX +zyj4bMnQptjMxCXbxIoku6uYXLs6q6M1izE5kgWRFq6rOoZAklWL6rjkcxVD22rkxpt1K3Q0+ZmH +TQr8jXrkMaKkqf3pLV47+XP0EqCzU1A0N5tuLPUZ3m0oq06I+Jlm3qLysVz4zshRj0L2ZJZSTMiz +Ue2ba/lMbIuwjjrOjL/k8mbISQU6mjHmZ8Y/BidXOAmshEkbmX8ni0A7WfJNMsAFns/iEaRGWzZN +weHdROSI5Foj43OwhGefZlhzjhd2m16w20I/syLJ8Lanxy9OgpqownT+fRjgc7dn+BeM/ee11/lS +2S9FudJsnLKaUsipRIeuGNVtKCYVkVSQXqb2PtVNBrpVq6OWCDmy6bJzCxrwhXIhfNBcLudF9oYx +q57DSi+qupZH8jhBSxheaA1j4DdT5KRmQ9ploxJQzpFzmIIsKupckaQQnzWCOM7peMHtrLZ2ObHb +5CcM8YcSunUdSUTPyQ1E0kOqZyY1D3ByphAB00bw8jghYyklZlMBkjseQTYeVpW/mqMF06BH7eQ1 +nH1NKOjMzSAKujARlQ1CSNP2n0WUjmgjp4+biJrib5VJOb0JsPSwOM32gEnx7hWMeN52zkeeToHS +1h5R1k2yLUUBPco0UycgRT2oOkJv71Z26vCa787hdF3n6QoJiDYZyskUEHgPZHiH2A== + + + rCZiVU+xA958dSsGbjgHtQZLLAQNCNoaVZ3scOXsPYTVxGPWPFKXk5ujvDGNMLDs4+AD8jml45+5 +gnKhYackh3ZBSEa2xHQqZLCCUon+OElAsXRaFD8m/CBLx9EkcKEda2tFvWOzAa3wyULpR/6HYYzN +4XJx1wyX/cIlBtHdYa+bfPgyjdaZBqOVQwHG5DpytTnpZbEcWOMoR8bNH8HyIjk9XUYUK7X6DBC7 +4XQmPHVsmE0wWerxenGWTI28jajmqdR5afy+QHoWyfSTwoFketA+XOZbYljtPmKBSfctJAK60iCc +Q9WFqOr0mVJCjpM/jhSQYlpMoHiYIo90vRpo8XJxFSiBvaLqCvFS43SmoKMT4lmgUEiQU9WNKVGK +mmr9qfa5XExkYQ1qoVPp8GRxcvXUk9eJYTFJJulvWskq4Y4eG+lxpPGjypRsPqwaCdpq1xTlVGnB +p1CjzjDZcIfXzOE8U9LwhnVQalK2YMRBSJfs4j9qs5ayy32VYY+A2nZXK+e1mcyKiHbpRjapTX+H +ZkXNReBJlmVzRp/pFQV4LTySao1o3DyxDNDM0vLh88le9/Xy0lQzZP6GB7HD68kA74VbAkSlrxeZ +mFhrFFpQUqgihCVgNJCH4RTCytHwKltlslS8sKPsn55VbGhG0T31kDZ4mJkC+hDp0kFQprbylsmV +hMtCy2+RqWs2idA8VNTzTMmzrgNtRmKFm2JRoavptlyPSsgl+bM6Mkydzy5jQml7iv6JaEO6iiyn +aUIWc6FVM4hAzAYythgIT+axKp7IJhXMBSIOu/p6w3Gq7OVl0wm/GbnOTog7s6n9zG5fDzmoHiqo +jrjiKN1pebKQRS8nnJPMfxMeKI01L+fYHeSAkw0q411DlItJGLTUpCZyQVI0mOXZnEXOVlRk9SCT +lhijKKWmS0kmlxeSDMR2IldTrh55ZSnrmas5psxgly5OMorHyFYi+zdIpXIQwssXdKyIWFDnDvdP +qradnMd3NFtKBecQaHbiPrIky8lisZwdIP/DNH9PZO5GGiBRmMECwpNMTcTmBTVtq53py6xIxxKK +03eFeqRpCUl2qDz3gm6XwEo5OCCTUtuiOMjSQiAeNmnBCkoC1hRshUMsydpp0lkwek27A9OCRlEB +oBKVSeEeFA2nE7cTyffyneXl0t+kI5O1jq+O/GRcq5ADOfGdYhIs9UROOWtDjIMulJcXKcc5HFjl +IEMt93CCCtqQyIRGiSDjGCIk9Uij1bfAFxppmsVZRErqn1BhcJ6YqxQ4FjR8kwugtVF7kORvzIR2 +Crn61Rp0MZsdlFUFxYAaxdoWLL2aTBnmmrrKkuyyTXPgCJUDqdQ85YYXBIdyGqt/gSeOItymvEEH +q3Fsa5c4TbxWq7E5bBTlEyv0pfb0MQMkSm3TFNeGqhS2jqiEpakrob3CLAyfgfggDgJfwU2c46Ch +hO/g982FyzFO4eCp2Qpnkx4lJ4bMkLrsvCCn/qy/nKO+rvlqlgvT5NDVavhY5WeBs3neRFI+sQ0U +CFCnsHT5lsUhOBxbPMGhzCjTIe3RXpF99KGQulrPcp0XvbKQkwpnuUieXqGbuKNaBfI+hualnt73 +dRYOkUaTfQNI0MUifbLJKrKmUerpluuLNwK/LJdJfIJjFzNqTs/gWJnmbYYRx1aegBMHPNRnzTfI +4dDCTWqGU+5d61kHercYvtGrRBqYphFtVHx2rUbSVCkij56awtEuRQsjazp0Jt6e6oA/BQe5Iru+ +JPFkaWJHICdSaF5yfvPSa52aGZo9UwgTUDPqRcj/Gq6W5HLg/B5dj2J70wny1VxDkOjyhMPwpeRX +Oon8okftYs66yQLs9tdRhK4nX4GzFvzQwS8UJDlpdWt3QDWFk4ottJLtE3JMtaVyC4IazXczkg1O +N9svwWZw5wpXvpOja1rjpGJgPw8V3TOd+DJxnpBCV42BGxYF9jxFbXGpnFh23a5TtcH9di8UKaCD +gcJigonKBEjdAZhq9GoKghJJqzpvefj2BdmhDH2mXLGiumqGLMHCEhZ5pKyatqWZqI8TUz9IF/yR +/ppMfEdZSH6flKkP696BPCUfFORPWebLdF1Pgi0EoVBE1FNs7nEgqi1A6IVhc1pMOc5Vg6bPQSeS +o5IjG7eknxMDi6iVuSqnt1VZYexO+2hpz6iwejJAUCOKHhNqLjbqNHHDDFLjZWFEhOiUHraDBtxr +UiMEyC3D/EzLy5lTiOERGESwCLhaLW36CJaSkD6QtzrggydsmbWsuKAB2I/s0Czn0OHA5MMzNhvF +mtUSLOWEA5y+dteanuGcX4Hl6CZAr/2C9FArm6XI9r+8/VoQJ05DqpEiMNJrdKwpalJWoCRyBBj6 +iZvo1pP5C4pM6+b6M4bBpjXGpCtos8rutFswsh8uqA0PEsrD3gzdp1CYPWmiYAL1k/YhnBnufsL+ +kOsdnFPk5EgRkgeJ0vOmXm8tmYU8OIAiSz1HZVTp6DJMIaiEAkbW5f5vu1DklWxWIrvkhwEGUqUM +jRDT4YWuHYw3tJPqmf4FpKd5BSFrtYDP6/RgJyoEDFjgD2P+QdeVI2DhxcSNfCyPyAZBycqDjDsF +a3N1OqGCsYdpN6CccV5MXye1B+FdmwgW7Id5xLEpVlTAc7S2c2ovkikdKC2EWjMTUAI+DGKD+GUJ +EDNxy2MYUtBhIYbTRmpcrZHItbwPKK+OMEihoruqW6zbo7s2XTE7STVLuIKY2S4NKsfPyG+UtTai +WFkHPVui2OZgcLC+cd6PyCSWQVurrzDJvQzWI5vcedjaxEoTNlVnS14+WrkCUuq8oqKwwlQZqiUo +unuwxcs+PborZC3TfE/ji4FDTBM8Nd4yEQnN86w9QLT1QGlH/J3ZiFLa5e8fgX4K/lBd4OpEOYgp +RjBA54j4jKixpyVczqE66Ryh1JJPUMp3hlGWaOzkfsnFHZQ0fJibSyJaFNnSanJAWmaw7EPdheyY +ANTR0gELKkTPA8Pe1V5pJqJEe/MKlBtCavdyGckWDGbJMAw/Mp1+XPmETZLmxIXiynPIkhYshR1p +FQbdGaMAJGametAxINlcvBVLOwXhM1kGPtpWYEGazSdAhuex309i+sBrO7Utkonlj40aBuxMdC6X +iz536iDvOgUtRYIfy0opxNbDFYkoSD0DQ8lnSANQTDVnsxGlcTGU6nJ9XjY57L8unN2ttmraekTM +5EUUo6hEJJB3DgvsRPcQpyspQkvd1MW4zAoebZ6JKDd4qboaRskuKZVOh0ewuzudpPsKaM+Rl9X3 +hAdfXnPTufN9KQgofFxkczOjbZ7+UNBpq5q7OWBATmk9nWFaK/+/q7PbteU4jvQTnHfYNwSkgU13 +dVV1d9lXEi0BAwi2YXsA+8ogzhAcAUNqQNH2+O294/uy1j4SCOKgeq9e3at/qjIjIyMaOxAwfAzt +hivKbKZTqvaaWwjQHnaaIXidBc/upipfZ6qJpQt9X000VIXMSn4NYtNxNCr5hf2eLf0s7NNnV6yU +NH4zxpC8033g9JEEO7ioZijh24sAFDRvXptHYCnrUqIK4ezdf5c1/dAAoRnsBxCZZQ3bWVI0imh1 +V8ZHI+O9j4DsHjQC4Q7VVk/5w7mvsaFn0SKdzZ3s1omoredZWbbscR37NuJuxkbswe8JlWrUlUxr +RSvto5yDkuxbG78Dg7YiRb6u01HwaheY3QslR0CtoB0fz+upIy66CQCyXhY6tNVW09oV3DsMUFfS +R3j2LiYWP9UfTUPE8ZIzo+sJQscSSjkkWpEp4phwDbXsmUN60wp2a9tHe++pPYQuAqtOTXPJGYOS +XmUlcbAIQS0sKWUQT6eKBvCd9/5YXEYlpSfih/SsHiUCTu8PVhcgiagY0HG6xDfOkrHXmSgIh8rI +optnFfdPM64o9tGakC6cbdjBY5bH9ZHuT99tXgFm3HL4pjpn014U5vwErtW7a6rJ60hNrVn/I+S3 +pe6RkKhJcsiSs8RXH84+UGSb2xUX8xDVfcchoUYl/GlYhmWx2r53MOnPdhVrD75JPLdta9u7wFDy +8v22MfqyWeqEG3ftTBRRnqVTDNmylrjrOtU7BpnAdMlK3gO9S+LPbeWE5R0r5GAID/alcK+ylnRt +OQm92uOa+g22nOSFS2eVYs9CREcpRrkKJdpBRmJL1k5X30R1dKt0aTjzDTv0mwfgquympCOyJS9o +mhVVTVdp8P1JRbvzNZGd5X+ahw5wtBwUT0taZ3kAntP39P22FUn8klm9/ahO/IRj1/T+2kFQPHZr +d1iSQHt5sxIfx9tklvcINZBDPiAzdbHNDmgGY+xi3aEvM1MrGdrBXTmMTMelMdRFR19i2bC/D4QG +qRA2jaKewc/u5Q+XXZZ+zyHM8dSVzW1C8ltDrjswZb+L29tQ1IHaqhAwSTSYO02CeYrPqwiZkDdo +VRdzJ9qPEgRJFDBX9rgogcauYlAHaGVznIQaz4zS3uh0bfQ36mADbxGcVOMjZeAXZ7Er90sKZfT3 +Eg6EPhLSESYctPGe2l0B7KaHRqrA0MwMNzXFPFKse2Czp8c6gUMkbFNMSF9rcIbIPrJAgb8DrihS +Ej515qsBKSN/J0gYpzBuHjiAtDyCnFMvhYjBcx1HwIlk63DO2a6IGL6t8l2ErbEt4JKz4D4yFGcc +yh/uIXo/YlLEy8j9JOoNIEWROQW3G1yt97KTBf2+hFu3Qk1wtzS+lbFkiq596btbBnDJFZDFWdsX +b4WWetFeLO56Lf2JyzmvROUvTarGo0dMeAd5yAOJqnGNMvXQeg+/7jDCxykWGC2UUnoZsARqD28+ +WEjHy5c9pp5MdrueuSirHG4fVGgDuJ+I/cjwDOyGD+gkF8Vo71br5wK9GsMup1k2BbnwqgMtKEEZ +91EiOdQLcogssmHA4r43VFCNGG9eu5zz0ypdo2E090K/4QXzZFQXYmTbE8HnSo1DLRe1ldxCakuN +dmhgC5VDPJqmcbKpzRygWp/samlayG0PLgYwe3uIrBhauQccTpxHo4W+hqBR28MntYf+tEroL30O +388JNjVUvgCzcTR/Sv5l1PqL8Rk58NDH5Cl5oVJXfYgGVYQ8wD4zqyQ3pux+L/i4yzr+THrylNVS +3oEBH+0pq+aBbBjs6iwJXPuB1UZ65cZ0YY+kiXTtPPdh+S8UALgVsEhXcYbHswUcIoKSWZXHWN+h +zBEZ3o5Z2MdjdxlpqvaPqPGXExtY8rjL9SvpzX7xkeuwdWbEhuP5sBkaAid0B0yvohUsvNsuHjG7 +McpvYqit24rxlBs1qMcDBx2jOBl8IBN+3u3wFzAm81cDzRjhZKLnZbbpIVqJo5oI4feuy+6bVc4X +qAnkQnKdTmgKnFHhVb7HlRcRnDXuVGtNfYhkVPmRMMS6IgKB6LstuV1kKQ9kxOiS4dzadD6PORea +CjnHu0QunqD72z004Vxag+AxGa2hRwDPSVmMqfU2bqKn8V1S7VHOxPTjM8WK3ISMNQ== + + + bo0/L5P9uG2ObSmUF91bz2NtbzRfKMed/vDHqxRhCrvUeaEu+wDnqzoiWj0V1caIYdtPNAt+z1kN +5L7WG2u8lF1JOW8uO9B7WbTe1RptYaGmGvCIyY9aMnkxoUi5Zc7qrt1Plw9fxC+rylQeQ0TPTD0w +FQOQoij/CJTiUyLB7LitVHB5KUqOaqbGnnRpMk/cqu6yz+tjMBEelcByTioTOlQ7/R17OnPTn2at +Av7B2ByvfMNyNQP3pOK3rCLSzPIoHjtExt5sfk3rWl5rnD2WrdGZL5fNrygMZKykE5iQFxJgZ9UT +LmYI7B9RB3w8RuE26PLktcwkTa1Cpt7U1EgT58Mmdjt4j8hkHuXkUWWRSY5pI+rs8PCuao2ON55t +chRZd4/mfrHPcvnLKSweqBAzLt1B4FSFykFd6hY3oILcHyMJ8fRmbxlbGnuQoo/LPOw0RtTPZCvD +wzzkqEMaPDW+JU8rZxm+Taia16w2SzDekDupGLx/g787aCNK86d+JHr6nuro5q3AD+uUywEL7lnW +5Z0fURAiT12ZRohVynnhsRSKRGi4AOtkCr0N0LIFpt1t6MGYX3lru4Bmc6q+NA2chczn9kPlmJpG +5uW/bwgYrp0qA5qbr5j1jkoaYTi59rEEhZhh3LHGZmHBys+WFFF6yRNTWdWndjxWawHeQZPAMhIE +5oXD+2xISAyHg64nC+O3JaarZJ9XAWCXGrkZh+CQ8S294OrbotAey908tonC+HX0D9MNXAQo3Kn/ +2em/CokTucCsD8s0ofqWkRbTre+m9fkMVjGqFhX+fbqDhr6CUyslPs6bkBaAu6nqvbDRRpc9xFO0 +AIa0Uq2FUAuYVZdu1lvpEWiMyZ0/tF8xxnjYA3m40dRAh2jqN1C5pWdAS/Mmo2SWkcVoenGgdp17 +3F6W5QjnsMfLJR3C7Pl1Gb/Dm02mE9wHnVaOcArhbFnVpDYl4uvLesqKpkuE5sVYJNmIT4/dqAYm +VJFXVyrcxn2k3yHBHCW0TEGMUnhDYABoY+hpjvjnNaoeb7JSogZ5ssP8mdR/mwH0o6KlqxezrWqS +dkTeAoXRfHaSovUyItftKlo04kfHbk/GdnL/vXqLsrdWA7PENfL9jysO6cLcLfxHiSTn+ZeffHiL +9hllzrpLESMl6S30HxGOYxRnXs3iw7UnFHckvVNnvGTZJ7WLsIcSYSHyj156lrZQlFwlj/b5UjMZ +0lbp2vBnRSGS1vLndNw4IOWkaG5MULrdCoC2qN4C+vEsF7c0NxyK2ZdnXTqakuXxMxcN87rlLIVS +6HjyQhJqak9wHR86HrOEdpDlkKcPESIiGnVOW64icM6sck8kOHhBu2wYxLxntQHBmEXXvA/NCVTU +kCleTVYIXgD57i4OBGzzMqX5wk/A1qU95px6AoxXS8Uq5fNRn5hqhs/G+uTdzypA1py2DTV1R5h8 +OWSYMnzg9CSXX4i2pt4/6vqqTdARpU8/c3s0u1oqzo9VvwFpFqTEby4r6Mhu3qKlR2slZATZg1Bx +VktrTmnZMEY4O6uZcV5qmHNKAFkvZemubz1Tog+k4rbTmgLHsG0tOcz0rNAsCKdvzVfjEW5Nryub +TG3iT21rEpLbYSn4DTbbTat77sHdmV/7FgCl4h5gpxIuenxf371P3Lu0ch1KMtBgNjWFmdX1iE+W +17YQerb4Ln8xPt/+9RPtJ4qwwxzLfIGu8/RFybrYbCLUCWp3gsziCIySdRnWgsMWczUqxYuEXUjL +ozhnLnJ8PHc7fcqsk/mJWdgXMRDzzawLpysWJbe4xmOgvJ4iLEExGEWHzTgKNV+OMX5YWws3W6Zr +fnANoRO/cYi1mJPTDPu4gym1AqKk+4AXSzLdqG7bRBlzlT0fsknEb7pQIByXsDVdhJvDCRSFWFcW +vMes5H1ewo2DDucE9HuV7oa1QPXaAmdBsy9Bx48ozI5LnZkEDvr0lXJaIothOCW9Jr/fFPbJvJ3I +hVzwUmAAWQ5wAMBOJKZzvygkqnNBNiwf/vl6o0zv8Q48aPhx3M5l131qtwBddpzfxR0dql9tNnfY +q48eLIRiXSUqlRuAHLv5L2ye5DxdLRncbQahBMW4j9LhOE3Bw93NDcKJ5C6m80Mw0e+q+d7rwNwE +N79eKmOJb4JaQh6eRkQJ54lZ/d1NodtNvBhNLSYYMLJ6cVuB8INTfVhlYNWHSWPGl0ZEoPmJC6+j +jMrx60Qc4dCZ/NHBBYF8DEAZVjEmpb5AeZ1+bwvPgXNzh1HV6KAcfW3GcC7M6ka3tuUMza95qYPh +l40l8B0N6vwaSGeyajSpefQDLowudPqlkkS5O2+CfX/Kl+kpA6jHGgB/L+s1DVpDGm1dexuJb7pD +Hq7sHfWn7uMNYa3vVPqQ3cxYgJ4Gag59lOmmNYoUVIpZnWWhP/osju517s92HeO9Pjzd3O08nIfW +1MwVjGXn3bTdZmqg579y4lEllb5sdgwymPmwI0Oz3orj6b1zCpliCeQVxpSZSFN9oNlllDpJ19Ep +SezlC0t9PfNF89cfJ+akYSXz2h8u8Ykhk2MmAm+HTbjT0kBTUW+WxEjezMu5HCQFT1E1l6id8K7P +ah6eBf5TWVdzidmAPou0rDuXn3ct0M52oxbNLs8H3PsgiFhG4Fu6fxT5fdR6PEwwuL42QCPjOqok +SpfcLKB8TFdyFCfzDZfr9uP8dFwaFhQqxgTUPn5k6cTMosyPUg1lBwClUWLQOcK0xEIj8aXb6agy +r41+KQAN+jaJcDxeTxl9FttlVKDI52kgywEO9bmOkHszvS1DDWYQykLAJ7kMjxMcNgz5xCj7MOMh +50sydj5O7WQU8YGI6uLz1DKxg3A8GwSWWSo0fGLML/sfbW+9JXeOUoviR5BBJ4mM9HDa/MGGgxob +ecCvGm3L42VLkiIS1+Gde0wyd8T0ZZMmfZvLztZRcs4/sIXVsWNudR3SW3IplTlELiRZ5eItSYZF +BaOkwJPcjH3tbxIyZELGqQMOe9S13TqJsPtGFYwzftzhOtESjxb/5dWGqYnA5KTKRxKNKKYE6bJH +RuneYKA8rcROG9pTOYEQcKFEa3C6qq+wWf5Era+fXlsNhBYVkrbbcdhyssdSc468Kbc3vz7J8tKp +66pu5bsKiKcz4Cy4cb8WeQDmKlq42gV34eBdfZhZki0ZE0qmQHXfviezHLKo0GX+wRJoP5ajzuoy +UaKvpZeRD+lNpterTIVOopcW6eDE+ZcuyOMpXYijikcIwedVRJ1rO4GkheEgiKTFhwtlp8xTKg/l +bpx6wrnV+s4vUMbtJAX+ampKSxNQeON5QcIBDJFGpDwfdVBgL8RAF2FmCplaKRj5vgfbVDgPJTIS +hcdeMcnsqjLK0hfD1yJvDEUKDBxYZHDcyDQBwnc9aA3js5Al5CDzQt/4EfKbQw8zADwwWhwLbksg +g7Qc24TZqstA765hNXOrcn75lkag7H/8r0/HWz72ltf57Xj7xT/86u/++e//7jdvgRq++eX7lv// +/ol/+cdPiLyoTkwM8sMnNKDushjDkwDxi7zcKQUEA8w4b4FlqUNu/Es4MSiroBPGYQh+HaSiJIFU +jQioMom9//M7JLoTaeWhbfppQ3JMjh41ayoyj5YmEJaQy9CDgkJ5VCNwCakOxT//VVyTf//U3v72 +/Vd///7v+y9fHxYkHPwHrBKwtnoMliOKdfQCH7BnkMuMVdiirnhTNZ2KEL2p+KjJWGJou1f56bda +bpQ2ro8ta08QLFI4JYySvbyK/Yqgwct2+dAxghdjwuCG6jhv5yb5srO2BAHNeInHjWKmbRMzbQSz +YfX2sjXjfvbLOWjoxuAIbCzDxykKCaNWTb6MT8fTv5dpOg/UKhuk9aLG5QO9NMZKDZQYS5J6wHDg +DU8Z15OMW1VfeTyu7VlEPfbQqykhY8aXhlM+UEep/5XdutSsR4OpW4km4HPwkxpPjdfuZ/OQcUBm +5b34GaRo2AY2x+AG1y4NQDo8dJy6FgXaw69E8rZ9XWqiBKR8fJtssfDkGS4brl7VV0xCAGTApLcg +06yKL6oh/ggiceq3or2zJCHPsppOdntcCm54FWaphiwvvB03KDhpsnUHKUVIT1BIel7XRpAfPbYr +wSUEfV+qaei/eLmgt/7y+C56Y6s+2Nel7+ZJqAgN3+3Dc35K2r6XFnBQalmvMIJx4pJmqw/TJQpg +3XlcL7ysVSt0xqWsCIuQ8V2ccJScmdQeqcXLm0NJg8K1RyxF5K7uLrT+W1JhPeS3p0RvAWNrkXsZ +ri0ZA+V/HFHditv4DMLiUVZe8ZnTh17fQcxiM758kSHFfrah5C4/MW3mddO85cThEWAEQ0sKewjP +3rJ7WjW5YjyoHcP7ezadj46iUQJhZUaLZG/b+P5NJoANgIZkaElzCDQ/UxDgZ5TI/4QowjAlt8z9 +91lHQKg60/Cpov+cL59KNf2dtMcoTf92W3G4EXZGB+7UXVLtJfJq4jgV27OluwU3hSk2wtgvuLXG +fLq3Ylqmw02x+ZVTRzMaQzgpvcTe7+GsPXAue4ptOssk8/m6XABI4uazqc5t1jy+dE7lE6xWTXYr +KgaIXa8yJjgPNbfPJKQZXwpkgzVl/JTH6NX2HrEkN6bS+6Dp6qWa5HzFPwpyuuERzZcai9tN1mW6 +AKZ84QRMRysmw7nU2L7u2qNbJtEaCCDMCsPUGePjoMitNklECXIQOvsY2ozGMRU3T4sCN2ZY+lk+ +XNzZRPX9qdBBT6WjwpOAb1Z/5vL5oj6dTKO18mMAfbhUz2SH6fCuQ7b683Vu24plKoFXzRd7KCcV +mNhDPNdTt+LoFrCehLGMNYo9vvS9QGru9ldse124jWh9KYZPPNxGeUY0dXJ8i4bxbiuTEkQFNCtz +j+G4MvFsOTT5pTaNyJkS/cTgGXcF97HvtOXtaeU+djBD6bGF4bYeJE+ZCtismPmlTAAuOErjlbXB ++cr4PMrZ8yjfEQ03mprpoXEHt8setz4kIzreGT9PzYKjrAzu5bw5UlG/YGAxPDV0eC4l0odOMdmC +IVBB3bjweunAFK/SCrRzb+mBhvMjfjB6C1PdyrgbUrc6Aqra11kdOIWNXx9Sbc3wlSIzO9C0zRYt +aJjD9ID2CzTjKMb9yyXnLEeqXq7QZynYdTXvttUYCxJ4HemLTKvLk8bNttlJgb+H73bccHQOw8gD +P6K7rMju+0XVx2LkrCXvKAMPqNdEH5pv2BJR+mFXyasRr1Cmv7ZMXmCA49LY5Lxeqmd4ON9l7gQN +JVsOO3ywPdPuzH6xMvy45IImSloasKjLftohi1mK/Sp5X66qbn3+MME6qyP/LFfjU3JzxlpXl4Ee +/Swam8yUWxLZTe8+fpehAl5eyWkbMl5eZdqWhz2NFmvWJ5pSwmXwgic7XL+ZiIRrq5pw9yshfYRN +2PV76ce9pbjvMmwZ9o6ezYtP1R3yYPmzFMns0CIYxxbFg5nO8FJphumn1+HIqbAHTA== + + + t2tL0B11+5pgRcZNV5GnzJ3oKXbL7DrBlU8JHV1KweNNeDbDeBgjV5UWyIeGNiOYFdBGzYR09UqP +nIublFgSrKWVME9tSADXrbP5qj1gL15beP34elsqItmXFG7W+GTCiaRx2bWcKBYviB5Xs8N1FVs5 +47vpoIc8UDZMTPweSkxM95j83at8TI5J9/8qT1Wsx3sorxstgwe3dOq7Xi1EWX4xvDtU21jpcAB9 +Cw9qYbMqOtfp2sNNVDIB6Soo+nNrG35djIfr1Vmfvwt+YT1fMNFOEUGON3sxB6zzrvLkPKRA5u/N +M2LCw9xUv3OCYXfIaosnCWcwiCehaKDJO6ASgYZs0i/PDNwE3BgHsmCJPZLFb5FnuAoAfV9sQcUf +Qwj5EFRH/hwx2Ob1C8ypCYfOBZKg22y2DG7IQ8lM91KAAb35DrVIeQQebDmz5Z7IYtcdw11j4b8z +vKLHKCgBQ8sS9yZCMupAkCghUlm/d+suC3X0uu/IXC+abnGKqXHKAXjJ9FFP8tQCdZ4PL/CmoJR8 +v15r6I7X25XIDzP2i0wdPa88p9WQTnCfJ7ntSYUHoVWUe7xMfujgy/vdfBU2Wzc/1/Vd17BtHhnk +21R/L8XFQmDSaDqknry/M0AcM4CgSzxTGa+2udzDT8yU7xnrtoT/S8azvI2ebU+JpVyTFwTE0cSe +u5MKaM9VOpdCHKm4MLGVg2UC28QobdnLh2kYFqm7c/8W36YFCVBECOzuzq3UwDIerY6htV6TfZAZ +fjoZUoDa/O/MztdRa8J07Wx292krdfpSZxmbzvdnt+3nFAnGZ12FUJok2aNpILl02zrbKsWC7spn +a/Upw4EvUEGaTo/9hZ9dz686hD23mWo4x5IMBSnGAqxtjCNpMFuKk35UXIO0R+pwR9m6+kidkrfY +Iu8dXig2Yn6D7lj5udtJkWIP0ZUaoIBhfEJEgsYxzuE4Ny7iWRzPvXnrfgLHmy4Kx1K56hi7oLHK +7uHqOmKlR0fbA33H+iiQg+nqKpMRmPDagiE3hZxEN5Yex+58j9EjvmOFWizfpdsotNapW0dcEAdf +Jc2GKurcDapjv8vxGK/P32UE3Gzy1h+0qTKVcXdpjRG6sTqod17WEs3AuoaXVyfFVRlHr0g9hO28 +/EFsMw6BOdPFqYTxrLUb6ESA43ZWBLmh2/OspbOZotzOgfdadQwMHVhNSzR5W34RWg2Z8Py9VTaw +v8PobdjZBHBvJ3ugkVncGk5Kw3Orz/TGF+Fx2ZH6hFOedWmZ/qVQe3Yz8U4OgyBK4ADUvj++8Jhr +2zVOk/1DUVphmbSQXuZ2FIEeOtTqEF3W27PlS1Z/YSCkerNAlX0EYtbALmXniN1vgJqj9khtJzBO +30mNNOD0GQodEeVCDfXxoC0443OnixD2swWkb5iDByyaSjdc+Bs9O5LJlsEOtq9XvskHTO3mI1DT +nfuHGghzNxwPe9AgBxYgluLhfNRK9ImCCfzYuoiKtr7xG6bjKUiR4O71Gs1CvMjR9lMMndD8Eruh +2zZqH/NYvFJI9MV8f55OLbfW83qPdqGRPaL9IaHQh5YUNuNLd84+5BfeV3vtYe15Z95k/Y6HY3G9 +2zpqG5qEBAt8fNk2/qhF1zCUniVIYVI6BANNY7pyEtQmFGuWLho+b69JkFJMEMzLGWqGgzlL7KSV +ye0ukH62Yejo1swVhTijzYli8CwNiGWJvdUkiOUzQOtUs6H7s5AG6PZ/zxIkc/I/vT9M1aS1fX2g +ySfRn2P6tGmcGoU3b/+Z8VERObUEZTjLcBhpbbaotJ0wTOF9x705PMtmOcI8ry3tLBbtVb5KJ0a9 +HL9S3iGZgtIhre7PKiF/CgmyRy/p8OxBr9nc+lZnkYovMSE6xwphb63KGeuWT5o6E9WM+gldx+vn +qS+8FDxplm7ZotwA7CB+g+1qeCPu32SWvHycIP9mPCVcrMekV7u9SwCZAIdC26tW2cz5N46PRc8j +zB/KOce4jj/ZwZe9+qcSQz33RzWMQ9Dxxxa77nTZKoPLVvaV2CzYi5VU01qBhgWt7Mnusjxw7Zu3 +mDI7nHcVAsiKm+EV42PZ6Od1oaPMUlSQB2p6RrRcUwjFRrSraP2YtH422fex1/wDvfRiMJuJr3LP +oyFAeOCw8Kfiy1FrVMaMui/Ne6q5LdebnGcwjIyL8rwFMnxJbqPuCpqthfZRaELVIm5jaELDzFCS +IwnU1RO/y86IQH7Sj8PQCgxzpIH/0ZxWPSPqBHeZXB7SFSdyCZUo7FlU2G9z9x+bQdAucpFs505e +HlcTihjNUj6ftzTqjPpo+McvwNiM5UfMpdWSqPHEoZNxFsS7VTkeGi3dFLOROO7ix3m+Sb41UhhP +gQ87MmhJVsgbm6WFx0wUefePUkNpelI3WCSz+mCm2bCq3oG/E76gK8yGyrSDMyTKqTrCdZkN37g/ +hmjDhPnFlifcklchvdjEf55xf1OchzANEo+jD5eaM644iQja28F///JtwBAE+afCejAe8qaGt9W5 +Yg9rySYwrNIN2E02Ob2mNUpEt5+bBuRDDjnav0vJKYjwQyyib4I4bZaLlLPTX6R/ELncLEyeuwhJ +LVua0+c+AlbiTH22I/W7sp4+ZK91gVJuXgjmTaceKNMc0Hwy7NW+L8L2OwvlZ2kFdPoLKO75ttqs +RHv7ixpRShW51XQPTKFbICc6S9njEqIKMBsS0dW9yqe6+npn/XYzNFozm06omhX3Byfhdr2C12J1 +T52+GD9WkWhfdmUwLPyY1g0L7Sxtr8CSJccd7uJ2davzhOx5i5byP9Sf6Cqp1a1ZhbSsnb9ffCMF +9lfxvnxY3eMxdL0UtsHvC2NWrS6cs9OSeu0ldxiaEtO2UnqnkeXoL9g542dWFIBxerbcyusAleQb +wklFeclGFyJy97g1jz0Ugyov2Rk5gYybwTKtST5lj905lodPK3+ZflbJ9RwWb0sq6OUBsjvnu3F1 +xpjUdBM+zlETyl6TKj1bOsIcdZKnmbO+rc+riNRLDaMML82MvVmYX/Rq23rM4Njjqd+xVYF2Tfqp +KHF5Uo+QLuWT64v0p8vwIzuqSPbyCSOsMdY9TG54EoiGvbhEZBgu+ITOXeFpZir6jCuKyUvg53HL +phy8djBNoXxp61k1Ixhx0wNMU8T3e1+pr2vH0gqK8To/DJJLpoQK8qw9iNnSw/CYEuBblS5zy3sA +QTsLdYeuLzQZjXUxP/GYZtqiu9SJM+1o17K5zwQNjY+sDc1cWDPYJXTmMarVDjFrQAVXtAz/la+c +XjoYdYwvk2tLZbSyUEO+KkfslV/rrjJsbwVbtkLYVzlma9vjJ8pD27vTh6hCZdc9ShXA15Ub9xfe +O9rO8CTMnuZv4gPtqXtLcxrY7lHnLB5OMYZxE/u91v4NuQpgu7dXPmxzytzmsfTCB6Xo+xht3lUl +sLxLKVFzcx+gqmtve/ShZBn26I8J3xQJebb9U1rUqWtvfKZ1AWNa1vPMLtfth/rOEP+/MFeth/oW +TEFEgYfc/Z8CpO6Cj+9rZ5RiWsdVCeVVdXM9VUlCqKQ816bd3AUwKxG4NoA0/2x87qkiJHo4nmac +cIgYN3PW04oVLAoPodM93AdUCAXN5NP1cnCvdnUPUQA18g5pI7EAVQ6qWN0mb3jVaYXIrWBVigyo +NtTUaJbAYK2zB4sSeHaZtooDw0yl0GuRrbRxN6EK3M7ZDZWDq9krBAHLU8D3gvkRx2TQ5ymJawiR +30XQ7BudbvezAdGq9J/b77YJRZbv1xJ8JEtgrSK95isfLVvvq8BLuWvvU44A+fXs1SpdzK9DJGmV +wHCd5t0U06EnbGbqfpxSXiIMWAKkJSMIRYBLWynrtLqIrluTTceta46blQWCth1mvBgTW0wx41Fl +3RR39qMjIr/6F9WOZs2ZWuLNCe5SRcP/jw1HPd/XMkGV7IDjBempZAhSFM4JNh3vyG1K23ntdZFr +qnNvVvRn89WnXvte+art1pqdtddkBwXQDLfmQ+ogGd9yiqF+Mh4yaq66sD18zqv8LKhmsz+OLKjp +FAVHHyPUcgRcb7+vVe80UHnGlt84cw9Q5TU47Ox/cEbKq+7vA2erlNt65ukJYyfCEiMs8D6puq7p +jMJVHZUUiV5gBzI/rLH/JMj9pmqJG7Qn81nwsWM45oqoDErB+Jv33cqD+zp2Ww9brN7SbI7qTrf5 +vGuxjMENe+wZ6Eo+uvOpHPOoPe77I6Jihdow2w17fa9IvV6NQ6DeAIrLOwssPNK1filj7sTcXv3x +zKqWd0kJneZQMVkGr7/jJJuJKArJlEwuO8e9LlgB7SDfFCeQCyFVxZ5XNYtPrd3O297zowS1+yte +aa3qOLcnYYhUxtIZazPWSn8oW7pza3+MLvZJyo5fsoycKkevqEnNI2Ihqs4eg1naJ+d2D89peqEh +10GG357cEgNLDpeb5aNGOp1PeNmeEhX/8gHLg8fsPM4XQY2HjiJytkxVNXv3kRLp6K93HPfdb+ok +rxIE5m5RSzzkNnAI4xMTrI665n6jXQ+WG5qsX3hLX44Zof7sva0nbHaXYSqI+f5TZak/+UmFEPDi +HiTe7wECuWWKfuoESD8+fQJnNdBy9a75GhP8CY3tT0xR+eTWvJCXiwcOcr2pGAVFJFuW3hSHqTB6 +orddDukWn09JJyG8QrfccWmCOjnCgL986ykXtRN0PdBaWqUjcCP4JDsiaf+zXgrPKDoMz8iHrsmE +bldlK2jMQlnMTIG0zl2FuVAVo0I0rQahwBOtnWIvQ4mbhzoDLL6nfZHNfDp131kkepoGlsaPl4DP +lMJ96mCOvUu71W8R2v2T+xbqBbJa9hXQn/VDttCOcb0MPCgr0m+lHQsVmE2H5rqdo+RNltrZ4xT6 +uZOFoFklMZxsxCs95a+7xt8lL3FZ6mxlRBiw6LakedV3zhe5eKg/sJZUwZWWFUReVl3qcWomuzmR +tj9MOypedZWZBbvmSlxDaF20DHY8QuWGwUOtIE7yLAIzAkfzsk+2FU89TWAh9CMxK56P3+I3XG1U +Hy7FyPJIlbaMEV+2D/9+Arb/9tNX//ZXv/rp57/9/eeff/+HH7/96b/e/vp90y/gp9zj+uXbX/3T +zz/9/sfv337x61//6vPnf//hH//w87f56C/f/uL9g3/z/v+n3/3601e/+p/z337z4//+3bf/9d1P +f/mXn7766h++/f67f/7p29//3+9++vT9H7/9j+/evv3xx+z73f97/8vb9z9998ef//DTd29//D9/ ++M9sed9lf/yrr37z97/99N/VdhfA + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/originals/SVG_files/Video.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/originals/SVG_files/Video.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,1802 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + eJzsvWuTHMlxIPgL8j/0faAZaXdoZcYzg7d2ZvVqLW/Bh3FIiTLZ2hg4Aw2xiwbmMBjqeL/+/B0e +WdVAAyhJFLc7gUbDO8rTwyPCw1/h8ZP/7TdfPdt9+/aPL5/F2/lm+slPDu9evnj/9t3Pbwh684vX +r3/84f07BP30tz+7WdLtDI12v1i/lob/8PLdD6/evvk5/Yp+eYef/ulXL/748uWbFze7H16/uP/Z +zU9/Br/53av3r1/C73Y/fvvq7dd/fP3jy9sf/vzdz/StgOb44j00WJa/m8PfhXmZb+b287Rigxdv +/vzihx9e/X/46xLXCLD92x/ffPvqzXf7t//vz2+g6U0M8Ad+8V9f/fblDw/+9vj2mx/vX755/5t3 +b795+cMPh7ev37774ec3h7+8eHPzyxffwW9e3PzTy9ev3/7rzf71i2/+5wTdzV/fvXr9Enp2/+L9 +zUL93P1iCV/vf3z1+ttf/Xj/x5fQ51gqguPXhPL3PwAuQIs/I7h+/Yt7gHz18v17oApeiLw6/PKf +/tsBGPz2ntoRobfLzQL//vQ3u1/97te/OsHr2s0BmfS/02/hf/NtykOLsGTfJBTEgP+4JkOLCJ+/ +bQOOWLnBb/9+7znDvIOG//zbl9+9oqkA4/TffyY9fff2+/sX7/7nDwOL8Te/e3n//WsYTWL/Um7z +zZLxm/4krYCr1OJZXOvNs1Ai/Dq2chOatenj9fLPr17+689vfvX2zUselN2791/xlEhpnvk7/+a3 +P75++e73b169B8oKghqPyi/ffvvyNbS3z9+9fvHdD9rJpX/nBr978e67l+9hNr19/eN7muarvgFG +/fmLv7zEqbPwC379/cs3v3v7D0TjsxpvSyn5pizyL3C4rDclwuiu9IrYgBFN3sxvpZFn9IgMUek7 +YGr95Dcwf3797tV3r978XCisX//9u1ff9jlVw83K36gTt6v72/QvUwsdf//+5RuhHuby4Zdubs63 +v/wK3nh68+3h7T1y/wdccDAD3sDkeP32O/6d/Uy/gY//+D1TT///GgbqN+9evUGc06/oN+vXv3n9 +I/zq79+9/fH7X7z5l7fTT1nO/O7di2+g2c2v//g/Xn7zHuSFAPpPX/346v3L2xevvv/ZBxH95vWL +Ny/e3RAcPszA56/+DL95AaTc8MfgNx32caTHl/8CS79/lqGnN39++frt9y873CAv3nx7848v3n3/ +cdQwDO8cBvqv/vuI3r54/yeQUi/ffPuDkcX/HTvKsI/j++obnBTvbvbvfvzhTze/e/v2taEdf2XY +BUxQbP/X8Y7f0Afe/PoNM+j8TdJg+yYQCH91b4HWD78BfvnXjP3w4vXrV9+9e/H9n159c+kFF35v +b+LffcrE+sv9H9++fvXDfZ9PDvKbF+/ev/rm9cuv/vLD+5f3H8KG3PiXV2++hYlIQqdT+/b+e9Qq +br7604vvXxLO93+6o5ZfGcL8NQhGL/qePfuATAzxZv/G/f7v37349hWIW9CS9qAf3fwW/vvi9Y2C +fzZdBoO4B0TfTv88/Zdpxq9ljnOa81zhWec27+b9fJxP892ygLYQl7TkpSx1actu2S+H5bicwhyW +EEIKJVR41tDCLuzDYQrHcAp3cY5LDDHGHEusoIG1uIv7eIDnGE/xLs1pSRGeDE9JNbW0S/t0SMd0 +SncZaMlLDjnmNOWcCzw1r7nlXd7nQz7luzKXpYAGUODT8Osy/V/amf612N/l4v9QZwz2PcpfII3Y +Eec8EVfwr34v8jfJTwU4VoBn+n0l/uHf5n7awd89fN9N9M+B2HuAv8hk/g7MBnYjcfAFnQHVDb7i +0n/4L9Pd3d3p7nh3uNvf7e4aPOtdvSt3+S7dxbtwt9zNp7vT6XQ8HU770+7UTuupnsopn9IpnsJp +gXfBx4+n4/F4OO6Pu+nYjuuxHssxH9MxHsNxAbLuDqfD8XA47A+7Qzush3ooh3xIMHThsADpd/vT +/rg/7Pf73b7t133dl33ep33ch2m/QP/udqfdcXfY7Xe7Xdutu7oru7xLu7gLuwVYcUdjdXdH3cEO +HalT2C3s2M46h92r1EXsJHYzUVexs9hd6DA+iOR0mqjn2PcD9R85gDxoxAfkBPICuZGJI8gT5Ary +BZ/ZuIP8ga8JmIRsAkbB04hXK/ELOYY8Q66l3pnzr9Mjn+P2mc5BwqPHPPvzZ7oA3J0/0Jl085Ov +9++gTwW/Kj0rPE0eGMyypwfmBfABmXpXSXRUEBEgDCI9qcKShQ/z11rbVBs8u7qvMKWQiTAidyut +mHWBB2TICoJiTSus9JXeudYVv9oKs2iFqbYeaAhOODXaPMHSApHUQostNRAOQF5t0Lq1tqMH5meD +OYxjRxMBZhUsQhBiMBMDzMcIszLB3MROAWU0lLj+aB0GehYSgfwkEIURRGGmn/B7ArGY6Sn0IAcK +doaEZYN/dxP9sMeXwve9fD/QA+sNvp9QmuJsDiSH6F0x4BdIUJCw+IAsBCkLAi+sEwnbRgJ3F2BR +gsQ9wvcTfKeFAbIXpe8C0hcxoJgFQQpjgpZwJWm8Qt8byGOSyA9IG+QWLx/iH/IR+Yl8bcRlHM9C +fE8wAhEowq7OODgwREcYrAMM2Q6bwiDWiUY0w/hGGusF5OUdrkqYCQeYFTgCDSZKhUmTYfokIDUA +Q2dY/jjJjjDd9jBSDdBUtJImkPsJdoAAnJ9BPpxgRR5gf9gBSStOPtg1MuwvEZi3gMi+g0V/hC1m +D4Pe0gpvKLD5JOBPgJGcI8slXNP0RHuCPDRex5kfWWwibw4kLA78tadnR0+bkHEHYsaBZj4uGxCo +mYRqIsGKojWQeMVnJiF7R4IWRe2RxC0KXPzaTSR3G8lelL6VVyPIYJTCiSQxyGJ4aKbtZxLJKJRR +LB9JNKNwRvGMArqxBLsgDS487bHPNPx3/aSnXnqmi+DyyCefP13W/bNN+5sP/MBPgL/lJs+3tcUK +VjMgANP3689HsP8B3p5mEJ8Bm5bUaryIpQSYyGiSr7C0qU1bZ1h1irHexrbEm5hvW86druujJoph +aS1LQb8RqGBruog2pDqjz+K2gJKYyIkE+hI0FrTLLapbN6CKdXKvjBdo3R9N0VYN+LIKfffi25c3 +79/e/OOfUI2fNv+HoQqsNCMlGUQQ/RArqKjn4hNIamHJdfwBqRwnHeK5UTwXO8sfH39APDaRRv5d +DyUN8xeimwFdzTfXo88QfsrA/v27ly/feKtoAyCsYg+ZEE0mROeNCFXxaQLU6biJtIpAOsZMuq5s +oAe3dfZtEzZOkr6wReNmPcP2jdv4Hjb2Bvt9Jj1gAd0A9YQdbK+obkTQT+5gB0JTAi2RMJ99bS2h +8wYk87sEzaJgg2V2F0S9DmiRDEo2Whcn07P3g5UBmvUkKvUymBpH2hrpOxtpTeylLHYVmlpRDDF9 +PuHrcX0l6xHtR7YgD6AroCFwJ5Yk25JmTYrmu4rGu9F2Ud+dnLKbSNktpOyuqOqinktvddop66aN +tNID6aOsiwbSQjNpoCvMkB3MqwPMszuYdQvMvwgzMQMBFTb7hnv/HlSBI/D+DhSFBZSGCCpEBuoq +KBi8l5sCuJACiGY4fiVTBamrrKaTMojmeSMTfUdmuiiGZKzDM+GwRjK8Eo1XItWXNVPE6c0G15Gd +LBNcMEdaPHfUrVm6FuhNvNgyz42VLOUjeR4iqdUracxHmI6B9OAqngZ1M2Dv2AijaclfMFV52tIE +XmQ6k3JMNiSNOz2oWVxwHfQvno/sIIjU+2yWP1BLHyadlLXSgr4KUktZMV2wJSmnrJ6igsoqKiip +9OEP2spddHTBkVjX5qHekSaPzyrafZXhxYHmIecvnAg8KaAffsSEjcRIsRRWmQz7wV+DI57MYwOK +PHltRr8NjNlEjpsI7TJp4bzy+qob11xfb2xlsn052JYTmZbBVls3LHm17bZWpdiVbFWyTalWJX5k +ncioVLPyQGYlOQnQrKSH7cpAnE1mXRZaxVWsTFzNbGnupzNTUx82OWcxO9nwZNOTjU82QP1DHJjk +nw9Ozc/8+ltFuNi/izn2Ft5bJvLrRfHvkXx020//qdi2VGmLKrLQq/s/ufYm9lvQ+NCaKLIa9m4l +4DLIznVpm45zXhbZZnjSw5SH6Q5znreWJFtKs+l9omkdbEqziwRnMtraR5nBOndl35lowu5shp5k +TvLmk23z2cnmcyRpfUfWYxAJzVtQhWm+QxN0TxYpbUOwES1kvUayZgvZuCtZvTsyhPHrhMYyGc4L +mdK4rWRyo+GaXafjSh62vegKRxDld+iSI10i0IMuO2QfSQVy5/GapY2FlJG9GuOnI28GR+/aANN+ +b448deElMe8XMehPYsSz81Pdn0Vs9Sg2OjtBT5MZ5juxx6t4Q/OoPm5Ux50Iexb3XXEME0t91BvJ +93IU6T96XcrG6zL6XU7kIjuQu2w3mftlhYnC/pdMUyeaF2bBmUzWNPtijjTV9uKR2ZG8W8kvU8Hm +ITUnm4MmkpMmkKNmkVXCO+tJnDZHctzwI56KsrOnTSxVWR81Z67z5e4HX656crsvVz253Zc7qy93 +Op7Mnau+3O7NbebN7f7c7Dw/g8eHvT2Tc/ZccPVc8POce3oGX8+Ezp7B3eMdPs7pQ09zfh/1/aj3 +h2ddHu2XaK6g4BxCi9o0Ztfocxoe4tQk/+D4fGJQwMICD0UFpm1gQNSdrcJjKg9N8pM4F9m1qDOb +/IoTTerFpvPRJnLTCUwzN6prUZyLR3MuqnuxsiI3OU3uXI/biatxJVcjOhvZ3YgOR3I5ktOR3Y5H +mgH7ibyP7H9EDyT6IAupVIk8kZG8kYGULTaNUO3mCc7zkieRDu6ONcDBcW9CYR6EwkGFguNbNZ9s +OpMHxr5JhICKAb/+de3Pg5vW81KctZ6R0wU+ei4mcdoGcq17Hu7FedsG5qWpe3GNY8yrvSnIq6jG +2VRiVojR5r7b7BMH2SnWYZd4fHBsExqbaBHMHwuNibu9z/6u8Pe5f2CxroOn7nR1po/znWe7yGYa +HxybHYnc1UYllDCJC72PSHOjwWPBDvQTjYJOYZu8IwNJH9+zwmJRnmUT36mmuoxK+J0o4Kp8AymT +6N2qcXdFxqsyYRPPWZ0Z6kxQHIjJ7E/VbVi7WUm+7kjmHkgOn8TSnk3JYXs7m6KDqs5uMl0H9wbc +I1Tb6fpOog3GdB5ReVC6wntYwLLSxM/elKeDoD1atOHO1Cl9ib4oWNQCY5PyTn2vvrtKKHOVjZCp +2MkGyUqYKmJH2URPvKPeiV6mulnXz4Jsw0meLE9xGlvX2lY2jyb6ZzcocU6Ns6d/WdCUDXzWwKPo +4NW08MNGD0+DJr5XU9Rp4rnr4pMo40eJbao2nk0f39n0vntQI9/LlKZQ5UYlH1xBl5xBoztINXJ1 +CcXJeYVWmbI6YdkxtJhGnp1OrhPr4DcMCVm67A7J71gk/lgow2O1kOORvS+D4yCR4w== + + + gFwHk2R77GkinsRvpP6D7kHg0VIfwpFGrGd/LOZGcDkgVbx4e/MneI9CMC9etuFch6g1+xWOk7rx +JGi9yEam3jz1MXgvQ5P49c5JN5Fv9W5ygWwNZnfXwxjS1meV4LZ6Inbrvj/TKrqkrFRdNkOgTJwV +3WWxmOOiP+IemujbIKYpgyeCbC9ELuXvOK+apu6oG+hOXH/sBNKl1hdamMztUx63zmBAjjYSOAbe +j4o+VGH0uIX0DQS/hnUm3U/irenZAOyeOU5upT20XezdipPtwjyV2exgWXaTbBayUVzYKnSz8NuF +W4d+x0CRPg3bhm4cyW0eheyVrQjf2bMfxfgkjnc37s6DvxMPvvnwxZ665MTfD/ZztRSYOIl6pJbS +aTCjuyFdxRxSU7ob0xrqFotnMoN6NKk1tH0e1t6EtMW4VvM6TxaYcaGZD6Q3+ASH4qM1anJPbHMP +KrZa3l7R3sn6VnW7ihTIZoizKS6mi2rgi4iT2SLdun0e7TnYsx8ellC7ib6RWe1j6mM4vGdUaVaV +ZlZJ2McCPy70M7k8q4Pt2bqHN5dz1a31ampAdhlYYrtPZr4Hl5C1qJ7hUqBOzqI/ml3fbXux7ydZ +Cs2e1Z7OwWJPdk+6kAACMzy4Z3HP3J9NGtZpeI7jMx3Ov/Znz+6Bp50/pDtyGOQ8588y/h5I+Pug +VTOJh+LjBv7WuhntG7PxJ/Nr6VJTMycNWUTdk6Um69ZcXdjumVwW0d48VtWZqnEwU73JvzdzqFr8 +Jk0XAjicX+RDOBLEsVwjdQB4F4A4ASaxYU8yt8gXINYs27PsEGCrVi1btq2yuQdSdxJMY9gNkwmA +BrBrfRx9LWFZPSDVNdEPsHUGOtUTOIOCA/8h3KIONCYUXBctJRXUZYYG2GxOuVG6SWmNcgHINMcj +RynPDV+SYWQCpgAsjNtSFFq8DTATOqFXxSo5LgFmJiIIDXAhxtDmJQ99X5ZaEFKUCQG73vN8bkq4 +jTBPfIrLNdESpcsKOAcEoRRAMQxbhr4iOxohp3M+jC22W9zWbmLCBCBH6XXREqVfPp1SuaUUoQWZ +k8I1Z+oWNafArDWOeVNLWNPAlUb+JPyhhpxoRGdkizKi3sIbMG1paS4T5rp4PyUh5vmrNy/p2JNl +xGwhPdtpc0QAo2F8QOBgBwTweEAdDMg7OR4QKWRf+vEANBynHrffWBgnsS/iJqR2yZh3QbUpn8S+ +2FoXhzMTXm2LcxPe+acmSz5uW0t+cE11O8P7pvbtLON4umhxqM3RcyUO3dZ3mRJnuRLo51eXlZoi +7LjaScDAOa/MJulWiVomSaIT5bCi/sDuq5ME6dhhVcjC2ImDSqZCkMmQNQtCJgSfGZnl1Eg/N7KS +Xeq8CzpBJklxzuJicLPEnSFJwymSbVZC8N6fyWzSR7l/Lhqmq8v5IU/ByTwFwWX71LPcg5PlHvR8 +dnUK2XSatu5ON6vCJttgm80+5LJrUsHkktnzxpr19uzJeZCCs2a3ns/jRBHdCPMC7VW0U4/kbAw0 +IeqxfWwqjJNhdoeI+nTQNPijTIZ5GgTGOBm6t2lxiSpF/U02JYZJMT3gExynxXZi7DdR+p4YlqcL +eSqjiFk2KSpDQtjWabTO01bu2EzxoufyZLk4XSaXlXJ29mHwk/fJMjo+nKcc3R4YucA5grMDhcpJ +gv1JJkf720lQ6bmH4YFsr2qnuegc1/kM53S180Ny0VyokrhGE1m3P5y+h4n8awuJMtz3WIbdwTSN +tNdh/tQRpuQCUxETaJu6zmDORZhrK8yvQz3BZIowiSqGiA7rCaiNMDcqTIcDTIAFhr1QnscRJEEA +CVBpXE+wPQQa0R2marilvoLkPxxPYIWHCVZOoXSLA3rh7xZKpSswI3fouLqzU13+iNrnHFAbjNXp +msfT0EydPn487UNJd2aYWvx5uhiH0yMtPg7nj7OcHWbpJ1mmC0dZPvEgC4U/OfjZ4jpZ3DNaxPNE +R4Y4z3ilk0UZJillG9NZpBNlHO8p53ilQ0186AkPRMFyuqNziwdKQe7pvInyqxbNLn6aCk9T4Wkq +PE0FNxWcu2ot80y+BdDOSmtkk7ecpBYJ2Z+Xzrd82sfkDMunncz6klNdn3gy5au3//Ke6wbd/MOr +7968fE8Hjy5B+5l95cGkPJiUB9MyzfQImx/f8pEDgudkynoLWme6qfEWFNvwSSNz6fM0RI/57G3J +S0hYGycu+IF4s663NYb2aSQ8jObxlLT8eTNz/OSnTJTfv3nz4v7ltzffCegGVhzMlItgmo7iu9lU +X7hoM190sTxgMk9n9nK1MzL+NPiyyZkYsyZc3sRkId3iUiecy8WFdbvLpZpZfJYKtHW15LNcoCG8 +K24WMoofNmZ87YjzehFR/mqxiF40omANiW49VKsGwUbyjjw8BzIlejkILgZBf+Gdd3IYHc/D4N8w +gcgNdgJdz57zuXM8dV753DnZITsS1/2Q+ckOmAc5ZA7ifaLT5YXO1mieB2d67Mn+5qPlmN8DewQd +H9EzRfmBo+PX2JL9jjxdY0v2O/J0jS3Z78jT52/J/ezStnDFtmzFtmjFtmSFq1cxDQnOrlzFkNo8 +W/Sv5zTvh6C9hu3L5CL3LnY/RO/7MfXdWQB/G8KnWiHnh9M/EsfnRHnWKcciFpfOmp8fEs+byHeP +fcdpE/52IfCzILjmpx8vRsIlFj65YHgPh58HxHtIfAiKu6R2Ge9pDIu7wPjpY4HxUfWCpd/W/CGl +BjaxpZV55dgUyBv8AUMn6aKWdC2EHHVrIL8SxfHWebmMLMAap1PiRX+QMNRlpfF6KL9szw7rxT0b +wH7P5rElPXpvm8VO0rwoKUTOIqlr6tJR2tAPQU3Ot/VJJ2v916W9kX2/HBGieBBtVMmViuJIkJaJ +apI8iI5c8n5NpJrsJfITqBxULwYFCgmpIz3esyMvGLtm7fgUUWaeyWjJVv0Ikk+yOlne7DIk5/b0 +XNJPJgl77CyRSvNg71zyqya9asKrT3RdT23Muvqk6kCXyv9sCgFNn1L/56GiPyxKP9MMv2CF04Y/ +ffmOL1VJXNL5wZL/V9tJdS/V3VRNXDVyOeu/mJ0bJzZ1zdhVc1cNXjV51ehVs1cNXzJ9N4VDcplb +8JKkphw4vq8WIur9KPUwBWEB7aJctjW/FNNo7cKKWjPJ2WXBsh0+rszVPVwBjZlAD9aUuBbKLxOf +8aL0jGM9u6Y++uGRw07uZ/8chsfndB2n8b+inrtnXOR2/DIOSaiXjv2PB/9Hw+RO476Tnf8vl48n ++NeTlLlQ6eZM6fmEZxq1pPOH1umoXX+Ccv253i6fvv60Xz7tl0/75X+a/TJmkBB+68iwwH3eFm0n +XNAJfskpUBf3yy/FxPvll+26cQHQWq+2iyu+v/W9PF3ezFMcTSH8eko9e0o9e0o9e0o9e0o9e0o9 +e0o9e0o9e0o9e0oyeco3epoKT1PhaSp8VuoZ7rmflNS1oE3cviArTBA8NsNIDyPm2xmPfX1G8pt+ +9AuN9HbZSG/OSHceO1KRVT0m3cIM6+hqRnSjWjVhLhch+q+ZRaT1qkHtdV3WcseUoruhPIQvwuKK +Ik6Pr8T7n1e75DylIN/ZTILvG+fqh64BOS/n/9Ea/dMDtfgfE4M4DyqAPOjpGNukjLPkDL624WOe +1k8U0tMDvtbPFtHTQ7lI5yKaM4I+VJwjWPbPSTr+gfIczIRpOOt/tEyf8+IccahzeWepPT2xZ1UO +Fcvp+WCtywfEL3CmLOWiGJXcEJB0FU+8UtrIkkv7cJLuFyIcfa6lzAv7cdc4OnTtpHOiI9nmJ/2I +x/ULEX6ZKM+X/a0Axssln/ytT/7WJ3/rk7/1yd/65G998rc++Vuf/K1PnpUnJ9vTVHiaCk9T4cv8 +rXbrxroZRh1EHMJLtyQ8eMhoGm5FGG/CHE8ajTdh+mvchqNG08WzRsmVLVxcuVB/J4dWL9Q7OaRE +6OSq7/upMpYwjL6E4TBjdM7YjJkenDJ8EI1ni86VD80UmSeTTJQ+TTjxb7yGrs+P7ewY5wbMjAkn +Bs0KnRN9RlAOLTvpGqxmnARBkh9xDeMKzjDcCwyxls5vZ+fGzMPk/Ev7SdbweJlKvljsdSz0urt8 +o8oky/yh2xPOR3G4N8HdosJ1WXfTQ5fabq611XG9dMhwkAbTg+IAh/nj4mBnSZ4iD6aPCAQvErxQ +GMWCCAacAdMFweBEg0wFEd245gMN/YmWNQ48DjldmHDhvkVfVnQY5+niMPdFOl6c00f5wVsyJhtq +f3GOW7Tu+uJt6VEe7158lMZ82sj+7RUZ4yUZy3DbyP5sK4DRn9zwP2Y/cDuCuwvD3YMxbbJ8L+wM +w94w7g5uf+CJgIcnDnLq4kNTAVQGVBh2MAiFFIWFlIQDjP4KKySBYjCDUnAAob06+XGC7WNHUyjA +W040eSpIioA7/BHmygr8jXStxgGmQYWBj0AGXqGxgyHKMJIL3Zixg/HKwJDFziQ0GJAMA7HQlRj7 +iW7DyLDeFmA2rzMUpcjgBZiLjEW2qgRFZuo1nszBLjuJd5Oxju/zHJjmeNY2hxfODyzIGYW/Abtc +3Qvdz/Qhh2Pa+Je6d2lwLU2PdDR+wM04+qWnz7tQ4qJ/mjyL0weuk3jgMokPXyo6feBW0fESCXev +6IeuFZ3k4ghxGZN/0DuNq7qN5dDHHR32CHTMI9PxjpWu+NjThR6n091E13LyVZyZruBc0XeO3mu8 +XUTcC09T4WkqPE2Fp6ngp8JnlY9q8+0yt8/LopGPfl4ZqTLfptjKF6QNKYZPzBv6rHJZXxpgLpdr +G5T1Q/WIzuPAm2tlyC/+gaU1fWRt+dW1vcPJLzCLDE8uRHO5ItHFG8o2Eby9rbzTpIFhF44Z48Ln +UeGxMtEmJjxZMK/fRLNaTFgPBx8+Fq5Zhp+0uNFY5oj/F/r/Jvkx2neNm0RSTwvXPBKFtdA9uhxP +4Z9WKYNU6Fwu3aO729RE2lZFOlldJKmHRJWRtCoSf+/lkNIk1ZAqXaOyk1pIGoLkakgSl6aLwbUe +UpSKSFGKIaHVg7r7bqJYzo7qIO3JOOLw5Cx1kBLdlPRUCekKlZAG+/TRDgpxT1wuo/QZt8a6OjqH +qVdUstyq7Z2x5zfGzmeFlay00rS5K7bfFOvLKw2+z02JpbHI0m46q7M0Vlq67P+Uy12HckviSJuc +F9TVXNp61C7VYPpYHaaHajFlX2xgyAL8UE0mV5Xpcl0mmAnTheJM/aqiy/WZeoWmCzWapqFMky/U +dOkCo8VXirhwjRE804WSTf42I5l7/5kKOIHUmNdK1ZZqSOtFZAsn3823JUjK25pTm8MDOXTXQ/ll +Ss5aLio5AH70hRlc8kFtlEsWCiXEPJR4o3kJavxcMoEGI+ghRMUsKUa3TehCVIM9dVad4WNxvo9G ++R4bMPxoyPAhRB+LPZ6hGpcZ7Gx8ocwygzJA1wXNc6ltWBWUKER5pTLp+IqZy/P4ag== + + + GP/aC9uerZFwMf80xGHhfCy38mJpz4dSK2GMp0GLHvXo8SLHMaFym1JpCZXTcP9vsSv41qF6ymgP +gzXMNXLO87/qJvF0a2BsTYzByJi2WV+OR55Xj04WnFy2YBm4sxNPAGcPpTFdkDrnkiV7udcxZfJo +KZMPJU1WuRB1h9GXng23zYe7nDg5Gl5nLJmGlNy6214PjWlSC3W+SJdxEnDnXGbz9oZUTWnm21ED +pXRVOuNylPMtfLoFk5dPVIUnlTJBd+VEC5hGkc6yNODTiTiTgBcrnVu5g86S2Q6dOkJHAlBfgeY9 +Zexhut5KdN5NlMRZgF2cwLn0BE6YyMfjHci2CHKuAlP2IAHx7uRwl3jkPkm7/7hyP31Qu9/o9o9R +7aePZSNcTkagzl23a5hz/HDXLpguH+/e9PFki0vd45H7RMvsYx2cPtUy+1j3psfkkpx3b+Powzfi +BgmqSiuJ6unUFriITg5U7Uc10zlAt2gz3VyWNxbqvhZGvtCuxYWQgFoFcgIPcWTY3WlvJ13rhpx4 +XFI0ITZsDPxdYr24M18L4Zdt1xe9edtCpaOeu57puZGKm6H2eO6L36Z+n+I8mRf+UtXyB32EruiZ +8w96vdfrvj6G4OMIXpH2xxq6DgxTd3KhBdeloVs+q93HGXysgeIN3kO3SBpyNCdaFcuhzT7PXkoQ +Sl3wReqCJ4t9lEnU9Wo1wPcu/f7kPF6B/iajODuaGy3n/Ser/J+S2lenayb2eRPA0+ip9HR6Sj2t +nto7f6rQnyt0VA90e8o97UR9p1C5ONK4oXJD5/7CWUC6Ovn8KODeMu5Wc1PZMcDNFd2dZqD6C09J +f7F1Md9GUIXYPmoFFgH+UFoei7wVPC23ktRG6x4jGlSu7LKwvxrGLxKnMVwSpwD9wns2T07unB2q +mlxQs0rlSB/QFHH6pae9dmcHfBbUax464DOEWx9zvGhLgQ/1ls15M6JgOhNwSoNSwWcTryfcLlR6 +fKRw+4/MmX7Muz/57dMlIXn+/o0/E01Hrs8Og0arFcy6ZayiqFc2V70L94Pr/nooPzP4i5ce5/Al +wV/B8GWC56LbJY5VFh+V6Etpvo/K8n1UsugDVtuF9MDHJByeZc49hM6H5h6TnECpCY9KUvlrRud9 +migJE7nLc6ObvJGDYTg0L37z8x/8DUbtdl2Ga82vjvkTF978obP3n/LpL1pw6WKEIF0IEOhXrzwd +LLmT0zyzc9UXSQTlhNBK8fNVzYMeRe/1zSV0uClafmexc95KF7lbaKEounr+40SGT5RFVmS5FYut +821Dq8TW1cbgCPuBFivvxhprP00avuN+8stCkKLB/BXlhDg/mSQRB+L5ZiK+m4j38XUSW0X+S9/1 +2qJGFxfpBUa84bMFdpAzxuN3+t1kTY7u3/6cLjx35P0YApU4bl6riYMudxx0OTWNj1b3O0qXV+kD +q0ukLE0fMYv1Iq8jeR4fKJ/gctHSZOky20S0SD5JTZPZ1teJD9XXmSwBLV+ssMPO6AvZZw/knu0m +ccXfyVHkoMlnknt2kBrl3df+keyz6UyGagKaSlKVpSpNWZ6yRN2RyXYguXr0Y6y6a7Lzw6sF1pql +sxwtcWUZ9Ohs+SptksVkqqysFVXyNTlFb+naOa36JFkp/th81nyrlVx3OnG6EfDhvEb1rehUgr/T +hSSsbYbjmIO1rcmhE0tyryZKveq5jTyv0PV/Iv93oAmF02lHU4knUpCJxPcmHCl+EWj61Emc9/2k +M1a70JPORc4535FUQp84H3O+Q384jHaDET5qwfm/nRPv/+YIlwcemsCT7G7q4lJHVzrb38Z97dKG +dtBLOcb9bHF7mI9f8wLzm9cqJiObjTs1gu42VwmMNwP43JYxq2XMZpGCVtOQwTLkrWzyVfwNYmN6 +ypCWMg35KONtYWP6yZB2MqSbDFkm05heQqlN7DEaE5zYkNM0J010irIpLj3daZKMpztJuDm6vCd2 +M+nFcpz8xC6nMQVKj4FSItQ05EJpPtSis0BG5uTyoo7yln44VA6IPh1M/ts/mHy1XJLLzoxxlD97 +nCeXz/nlIw1jPT2uotwHxnoz2tNnxQ4/MN7To6OHHx3xjSW71nnBYFhrsJkEulYDdoK4kmtHHDqz +5NAsGNF7MCvnSzH9p8vGuVzYE+t6mpXqPCW2y+sW3gvlFKfq7szePNHVRrPtxbwTW2L2tMnJlmxs +UhE0CzuRJaRX0la6DWkV225n5pkYYZNlY0fSfEn3pbnGqi/XEttRkP5IltOJVPyZ7CdUgFEFTnRD +TsGiPBMlcaAuvKP5fZQqY3wiAfsf5ElUtQeVYlSLUTFeabVweSlVj+ne5Jm0ZK40xXWm8MRCpqO/ +XGjKl5o6cDUyq0e2yBkGTrPJE2XarEOeDWfa4LI/z7OhTJvRMI3mauexU+N0oTH78Emq3KscTRfP +UK2UGLO7FHDYnp6SMx5ROFkns1cPyDpnWXjb4vDA2Sk9ODXcMZ0oq2a0Wo92t7SarcjKj5SF5dyp +aTg35S1XvZ3tOJyaCpTZXShD5zxJDEzXabBcV7lI67L7j43Xj1+X9biLsx68Tmv6yJ1aF+/Y+tBz +fv/Wh+7desRtXNOF0rWPKWb74DM9WO32Y0+9/EwP/eKBarn0jBaJslZ7r/QpCrU61NxYLHasZoYl +wn/i1dIPXy6NtsL0mMulH3+99CFPF66XvsIF0595xbQcdvAFRO6mC8UlfHmJbYEJKjHxZHv8Ldke +D2RIZOBAxEBHwxDZWNq3pEppB1kVSSz1m+oDquj1UP6n00nLxcgJQC/WmieFhjf0nbkLLx+Clnzg +C5u5eqCPlCr+yCPQemdmHTZzn/NNp6An54jurmja0GVLX9xtmFm80rK1m2eaD0efUJhP7Ovi1M9e +fba75TWZWnPLmTvjAda9ZVTf+YOsXPco0ZoutLobrfMdrfjDJrs8UiYySodC+cib22tR3k6UTC0u +WUmpZr/sQbLqOysr6UU7rkgpnlr21aK3ds+3iE7ssP1f2yXLm8nHKux/+K7f8wt8Lxy3+3Dl/QtH +8fwzPahXPvR1fOARX6Kc4qPef8rZ1sfsO5+WIv6IXWe6Xv60HGyVmkG07lc6XNErS4UL1cQOrrRU +le6cl5aibk1kZGHPeE/l/lmFKeoj97LXGNteK8vdlYtlJ+zzpuKUv1uWez/UnRIenCTqurleduJA +8IMbL5ZcwvTnluraLu+SWOgf0xESV/7/4F73hQjHTbdBLynTcMVTK5IIwTt2050bb1alpAm+AuAj +WsGXYvyiDbpe2p/rl6YwPt0f8HR/wNP9AU/3BzzdH/B0f8BnK8b/vgif7g94uj/gySn2VDT+aSo8 +TYWnqfBvf1/r44sYjue8P+lj/+n85e3imcK2OVN4MkbvrcjeTrIr10156WI/XSo1Tf9OQ3bn5+pY +FzTBIEef0WVADgMplIRGAKtJmiPPClKjLJAjafqkHk1ywpFdA2jpZanFwVnxJ3dMvFKSxt4yly1v +mSgz1TValRdf3UW9/Zp5PksQXz3/moXO7v+KRwHZLt5R/PQgYf2ThPZniwX0aIAG+oukfX482P+R +YP7H4vbnsfnHxOg3oXaW358ppy+IaRLS05fXTNyx6bGplD86MbPJP5WAKgMPg/+ymCCM0+C+PJ6l +salMVKm4vUSBZOMDfk2YwWumM1HL0vJQmK3xEUW7IxR+RaCPuQ6/GCULyFzm8e5S+EBoxQs5PMmF +JeLgB6xJEcplcfmlmL5MeF6sb9HG+hZWEFQFDrsY7vRIjvM1eT/TeKBiUyZ662G6VCJ6dEs+UCIa +fQWT+ZS2vknzJI1y40KpqG1FWg7n7S7Uol0kPNrrZ5XJykPtnB9xjJUmd2qHI6Y7ygKxqKlIUZKf +E6WRZIr9cSpUs2QoiZ+OPfoiCXPpUPQFGfMICfOwGjh9XA/U+573m8T/sWTptmjppUSd0zbDfyxc +um7y+tOQtLNN29mUL51cDn87XCxgyjGqPc1KvcaoR6u28SpWYx++DEViVpMGrYYbUfqdKKzgbuNW +lyJXrPBKnSOU+17ys+4r0atNpnGclyEUBEpJGI+Sa/SlaRHKtAYQDxcl33XQcfEhVNAGWb7WZZMu +Ah0EcX7jTrkHDFw9tGFcD+WHBDQAvv7V2ze/effqzftXb7579szJbf+L6Vff428i/+Y3L96/f/nu +DQj0r/6fH1+8e/nDze7Nd69ffguyfAO4WZbblOoq/8abUm4xoif/Rujqj9hdswX+8Bf67/8NP/4P +AP7rTbr55c0///f55luC/+G38M8W572DCd6b5wDbvGuA6WefX8CHsDf0ul/TUIDlBPoF5aDXSmxO +8wo7Dm6HtdC2OPO8wAquUrEqci7QH17gC+ClWNc134KhmZheAfG/9Er6bbsAkY89P8eEoH+Bv2HF +ApawZa6gMtRKb1BYbLdLW8Pw8Usw/ezzC/j0PfQ54FSGjoIUpfcorCy3sYGd5z9/CaaffX4Bn75H +adLPe47VcJtaXYRBbZ7bJZB/8xabvoU+VoofFgW5QeBPXYC4Mdhg0hdQt2rSz947kOescuESzM+G +EZu+hKiBWaJjeu9g/JE2fPwSzM+HLb6BW5sxUZgfAP38JZgfgS0+fQ8IugDbAi6zPFfYrjGGHkGw +saxOSC9WD5IsACm4BtKbf6AFN9/8lquPBFieXEiuprEEQherqHSzQg77Ih0/WXE13/xhxzWPb/7V +z9Q+Vy4N26XFdGHNbrAh6I8s9WvmwrSdvBKWoUpS4jK06EUhMqGXbC5Qz7fz6/6BkR9W4wbmib80 +X5lU2OUXqn0XIoY/LvJWtiNn0YB0BPqZ1mGWijS5NHuUW5dgXnJs8XVaKyj7kfbHuvDUgna5EKMb +xjlRYGvCRmYThypp4K46iHC3lC8JUyx0tZG5AnKr9oLs/+OVJv5WGPt5WmEIk7DFhOkFmF+Ql4T7 +VYefNlGQnX3wB1F7QQwqSD73/AzTNYd9sx/4LcKP8SU5ekFcX9hdmNCUwIoca6GlvLZRO9USmKty +VfKemFAcSEfBvYPxukjnkngD89Rv8SmtW63Caxoep6guF0Ae4yUdBd/y++nE6ibop6Jsfpa+uvJv +9u9+/OFPisfcDWH+2TTf7ODvH/51+hGeQQu9rIOSBvosgW5+m29AUies/LkAF56BSrjeYiTfgZ+P +4FBu8WJCAiuGS7D+8TcT6qA4keeFxr7isTCcpGCRrST8awEzgQ5E4u6FECvAv+g8dqjRsMiBCA4N +puOaE4Lj7RzgMwBc8y3YfkJGhCUPsBpv6zxXR9o3+PmC9MAEJDA2XBp8uDXf8C/QEAwtwAlk94ZL +3Tb8MzacM2AMyb8clifuzGWg0vNaenSYhra4XwHemwEpMruBmj4QoCPwzUgpgHOBzg290rZ/Gbvf +2zpWaVvsmONqp8Hxv1O7HajD9C/T76d289Of3fzhH+EnmtSwCoYp/bGZTtAbAN+EYQ== + + + yj96wq+gPt2uK2gma5gLluelOb/Oa0Qx0Rz4+QYcbkvNK4E9kgfAhuRaM5+wlwISFLAn2AhyIsoX +mFwEiQnUK26W1iUxMMOOejNSBi3XteI0Y3Dk7iFKMNMZiGY4A/FK0ZuLL8cBRQ5Bm6I0pLQk4We+ +RWc1guGnGXYoBBaelNw2xkLAeovHpRnYFlgLB0IAMwl9AgzOYdG2McnL8hxuuOGC+zbBygyE8+cb +7IjzygQsNFHXuS23wPvAbVdm2AyzN0MD5U1aGQFO6piE2FBK4RkBYKC2DtyBPRgW9CrszTVEAcZl +UWIxdZbxIjgqw2LL0jaEWbCmuSiCsBblOSq3hiBXG+AcpC1svFERrAoEk18pWJN8Pt1iJE6aoskg +wM4EmPMCXNAtwATMczAEsPqFi6B0VeEMzpvShOPwX0KRb1OYZYalkJnjBSjQjtWctWMAxq7zSLao +CFrKCkwpK7ApYb1jsOhs5rcauA/rbViKzCMQtYwUJkfQyQECSz7fYGYXobUl4WFDxVDeX3Hiy+dl +cuG6WO3zmDGlU3bRz5fGn4dXhZAF2JDxDKzrwstxpgUvCOpacc4jMDUemQyLPK4CXFOpwus1FEMA +M1KHYGksxZZ5gZdEeV0KgmJB9TNqb4nbCExzFmojLFjBu+C+IKt5XueOt6yzUEFl9xiImV/C8FIZ +GG4xXq8dLkHwAjgl6dsCi1fwBuhoEnpDbqugSDgmjCLHKsASo67yEA1tGd/GaGGV4jbVmcbAaCKQ +ZLYAQdUWAljaMRg2AyF3XtYiJLRZB3jJaxAES+ojmbS/KB10IEA2cFuY9ik3nYzS2wpSPGoXctGB +gN0+FZ1ioVZpW7GMO3MchbsA16prrDgELaqgWSMTsEJvV2mKJTsFCJq7vqnN2gMAQ5cFvMqsWW+B +cfEMARpLAgTlxRAQibx0VhJ/CAR1Z9F5EHgQGsuczm1G0HAUdcB4EyFg0qW7wlZ7Yy2Fggr/NQQx +2oZTAMzAkmtVxhqQ/K1MgbEAoHOwhSMD3pCbyq5FiVqTbrrrorNomXmqM9bGswiAXU6SSGRgaasy +GzcjRZCBLm3Lk3uBNZ5stwkkp7AlmIJF+BoLzYwFN8Ggwg/DsgdFoK9KtF0SKAedLNVgXXbrpoTg +2Iqu5MgiBoCtrxeWffBqYP/aHE2MIKCnWRfnwmoLAoOuF4zX3PyTtEU7WHcawQtLLiSbsKvAQCDr +ekNJw++KqIXpiiv2+YzM8LsPAvsOWstSDUGbo655PEGDQPhYCKbIkMqDwFirvAqMAfk8IItKAKja +/C74sYUtCzMM5hqdKGQEgKw0XTAo6BlIKjsP11yKANM87F+KoIRVeptTEw0WX9eyoCCDV16GNopo +WIvhraaxLLo4EO+iU1b2e1C5TIs29QiBC8wfVY+MtQXkjiqamKEsbeucTD4IaysMqU65YMsbfRJx +1UlXSpK2eEJHWcOaMiIIqolh2F0QgORMtqulVXYPAIPcUnDJikJ1ZRT+JQqw2T4T0NeheFtNshgj +1o5HIKi5Rac9lkMWIEjDVffVoLxdsbJQdoQxsCZlTZYBAxk7r7p9LXW1z8MiVs7Uop/vW/uSglJV +o22gfWwaSkFdN8D8GwHC3q4IZgWGtRqwZEPQp7i4YRmc6lK7OsawNSzRMZGBJeiQJ9ysFW2el7wZ +GmhbVTWAYU4CTLD9qDK1rIagLConsugWAGxxEWCBBYnAgAXAdafCBAtGEPDM/JwUAcv0QIZcUbJ4 +TwkYY1OVh/R4RZBSExaImovANao6V6ULYbkNSfm9or7JCACcmQew2gKvGwCCwSLdzZHFBAJj0FdF +XTcAxkw2IWxt3IXg9gpRqRGYk8o0sF1lFACcqm42eWUJjG3FjMumDSJw0ZWAN1QZAlJUuLvo+BYg +2sCMFXgkQBDLSgEIWEPQYtZ5IPpoiKZUo+8iZwGGlpJyVpUTAMdVFx6xXoBRV0gRBQ+xNl0hJakC +DmD4WRBQZxCYnLAmu4WBXeWBHUKED4JFuQAKWL8LGR3QCw/tEg0Ya1BgUA5kt2FKSIbBKarkoG2M +gTWpEdJYJCKs6OdrMLTFTEbtEWxaKrVWFnsBl7ROoGrqUkBdW5UAmgsMzK0J9XOR6Y57nS7janIT +aTIZa8TDx5aiCEQVB2DIqkmvaMQq9cuqUkOsfkKQtfdJlBtCYJPNVCN0dS06KDYHCyzfojNAxUMx +/TyzdqsI1qACuaLa/VzBkRcHmr6s9AXc1qrnAgNnWTGla6IIRVnT1xEDM1g0MjHExgAgRZwYaSqL +IUim4Cb1eiGYtnkGV5nFlQd1HIbqpPSKQkPxEp9l1QtvcAO1qc0uBgLWZL3VrQrBaKtTJ0jgIhBM ++dQn51wFqCtOZhIjWM0mwsktogC2n9RURoqlBcBkK65WVdFCczZkm1dFgJdn6ssqMTzObLJ0GUkI +Il3KqRREpjbO5iiyNYewRWfiGtSIxc833VIKyhoGBlt46FATIMW0ZBBUoCO4qJNjXXiNAbDm6GU3 +A8nDJhuVLryIHoKmuyIubQEuSUcx8pxFYNSWDav2K4JYbFvlfR1g6nKEkS2ZexCotr/bJfjzAcSO +fl4VWkBQs+4oNEQMbLjvy5sW+zyeVhQtROwEAKagwLUIVbDLiKsNkaZoCDCHzEmZ5wIGC1R3D95q +I+woMeqMjexKjbhLqG+APsJo0QWoO0qTfQqAXbchbZSBWYzdgqE+WR4RXY+pjASg6hRkcgd2VCFQ +zXW/USK4WXdbVQTVdJgixiIAMXdOJ5FuUxFFdVS60LcpWItKE8woNQpUP0Vh7ihYbNKzIwKxzlW1 +DTHCEbgorXjS1BDUWeesOj0iyncTiCJ3sAtVtdZcVOOKQPiqylVMQm3hOB4Lz7o0AaonA/dBVccR +PEdbdlkRwJRSCsQRAUCylGUaROUBiO8muyrLiucCTqJ3FvZqMDCs6hKr4qlHoKnTtHUq3mSGRpbN +NVYeaNFQWZOLlW6ocXOOEaDv3fTpoOGNWG27citvdZ69LEYFAENUNaiYjX/e9rmCbTaTP5mBsan4 +FC83AvOsUYWMtp3i7ZqnbgxIQ1GjooqrC19lDkfakhVBiMqcRvE6psD2qyamGVFgCzL1z+PR2VFz +jWiFqZ6tqi8Au0tpNQME48aLOhTqyoo6AmOyrU3GHIBrVMUn227TnG3YxO4GYMpJ20ooKKLvO9Wz +yQh7Y1n9OhWsTd3BTRQBBJp2QALUECxz28xQiYeLXG5GVlBh3f1yAM5Nfdo6Xs0Uclgi4pQBYJ1N +90OrRj9fbBNpdVUCiu3CtDfKm6Iq5KZ6x+6uI6EnkxOgpuaRnDFw33ON2NX0fMfC7jagaagvIxIH +AZowxSZ4046B6hks7OohBAlzrJJICbXb0+ycAQ1nJAPXNhed3KqTJkrJsundGncsdT9in4kADMgn +JoyXB8BSaKJnzkEdSwTW7ZWmjKLVIBuAWWtIi9fRxC4CoDop0K5RYlFBmLVjLGqhZcu6MZBw5IYh +mLVh6mDCCLXKHfY/AUjddd20BaCaIKI868ebOSiMr9Fc9IUd6AyktM2NJoRg0U+AWUoBAIOu7wW9 +cQhMptMXji8yAvRgG7cbOweTKO0ETOK0TdmiYGgqqEadcKbrYAursS/qDKnKQGGGCPlVOYCW52xb +GGu+CCxqwyYOeCEwLOrJsMWFUPPg2Vj3ptgpVocTrmmzX6oqowBOYZX5DszmvlZTpwdgN5e7zgRg +sp2FsSVr2xAEGGRcK0e+eFwtBoZNba9sYjACMNfFNo6mSGszV4yJ6FRZu7d3PReomxmcwoZg2IJz +1w0a8xuBajUnWQWwddWqWIutbgCv2lQFJwDjbNJ04b0agWnxu4wiyKUpXtlT02qipGjoeEnNMZYC +w4wAwyxm3CYxLQGaJJzrFkKjpDDljEyOZj6LDVrVvaEPYlTk2WZnMX885q0V8zKhfkYIMpZlV/VK +Df8cLAZX2BnNQNdbXCmMAMBi1SBhIXLPckRfm46Y+JmgbTMZkSvLiIzBwUXxVg3NIYKixmUU51NG +UyGpQKpBgaBTqoao3gCAkpNRVAtWaDNGQJJOcIkrAbCi5dV7oAhUTS3soBME4tUpbA4ykLQ6ETxq +MyNYNG3HxWTxOqCAbRWA9Q5o/B6h5KwWfjf9OI3y2IFk7lbxiCmCvnJpw3ouYA1P9kWKnTVfURFN +H2ld1PXfPff4uqbBWMkyltcVC8+JTEO8GgOSaDJ+vGisZUXH/+Hhj2NKh6phiUMt1HA24zZ1qiie +wz1gbYO6avJMjMicOB+WgYt6tXK2PbWo1z1jjoVOTZtuCQ+MmCcjdvqbORWLzoxs2TjdsZcx9KWU +9k2RCKhm3LL4x7Zz1NUlVlXOThYkU2Ey6mmq38bZEOgU1EgRtlsWXZpRd4SHPo5HwORVEmHP2eJP +xY8A2hAqpFXpzrh/rYujlYFhUbLIdcoIigU9iwUuEOtqgkQceIjAsXDpCJbadFeUaBkAS51NkOjn +QVlRAvocKKYEoeHK3l0E9tUt1hAAc1SlO9i+nrE7KuAW8SflaiGhcisfr5w30icmf5ycnSoxNP8D +oEqTLgG0dHWj19gZAKNzEjZDqTkWRTPPENhkVmcJCSIoqWBZis6JtaOj/5prrbDDn4Eh6WygUdMX +t6Z6R5H4rXuxOruy1wO6T2b4eIz6JhCIMhLqUUGags7mHjlAcFJJj+LguUC7lq7Rj4ypGVl6pYY8 +Au1dPSiD4EVzGqv4tRCYlC0qelYLyqNM18SAjFaw2ilr3y1BaUg6diaTV96nZeTZLwYtYYYqEG0m +xdtK0X2hqd4ErSnRQLgo20XjRINB70G8ttst5qoHMAhbXZIzu5AyBiitv8UIo/RK6ZkqKACukspX +2K5iYFn6hpcFpv6B4qIViNYMgJxcx7ploj55elfcaHkZTctiwCZ0ldmpaZpzAMC46qBLaIsaRhnI +4j8fivariksegCnq1qKWFSI1F29SC6bMbtJpcA6RNlUSKXLCwGxCoU9wRGBTRv2TZXbqs6SULmXh +WDx3NZROgbPZiwb2ofVczLgtSWZo8Sl2qrohZkwc4z1P6V04Q2tlT6JuL9i2qqc8iFMIzxFYhl7k +dEQEpmgZBzbFEe+qrodWgiLAIZbRFYkNwGqiy2y2Eswn5EYsOBWHvK0MVL/aMGW6q7ywGsrAklUg +lDwnAWowDAgIarZjWxsy8knKy7Ku8iabXsEsOrVau5uEEJikktSTAupv1eHVNQ4tKUKwmmGhCNa4 +6L6zWHdL9/JKIiCSlczxYBFdbFvSxk2AbRf1M6v/HF9lXn0CMoLonKma0ALAnh5d2e5E2KJusdZn +AYBn097iovxusZg7hS1vfFNWyxlFkH4+Lfb5xsHL4jMZNTxWUKs3vcGiFQDW9J/C0WUBJt3EJO2E +YCpmeywP0S660ZJT/rmAc1FJTScJFKypsYU9XIJCYsjM/2SxNUm05zclS8vFbUkxYg== + + + 7rJuIGpXIcamdiirKAWtItX8guVswseVJ7qD4+tDc1qLvHvV7Y98lkZSUG1QU/SRInF8Fc5FFKTN +DJ219T4FcyaY2MaXVXPScPy9JA5f8grQfHMEq0OnWH5qkTzNcQUkt1Z6akrJ3PFhVy7Z3POy2zOw +VGVqMe8Zgpe+83BkqqDSZTxcFeladPyCackl8/mUUcZnFzxJ4tHCvsqywOiOZstRW3V5F3H9QFvQ +882B2oEWYOgBkSJ2G4PDmo1dGv8RNRtha5OGTgphrqwlgUt+UcmmEvektpJtl5ZzE9oDVQR76hci +6CkM4v5DYNIUBieFMnOOwXHW8ep5YpqtUorToCgpgRHg5LHo/Soiq3CqpmyHs45My2YXWopUwWFq +Spgk/mIVA4sO2kQGvT4rY/tuVt02TRYQA53PvspeUt2u0z2gANZIZOHkMwaGxba4dVEE3SWWzSWG +CFadhxqSwraSo9XtVQQ2c+WgSFIEPZqbJWkFqV3bVpRX5wUnoW0UZPVdLUU/r97GnhKAwEXD/BTq +5c+vHMVevdOjVEsb7cmo2NIWQrCsiIIexGzzUDa+bjlYCmJplp8jsUL+PDr1dBJEiXDUmdfqoFQB +MBXNlOh+6Dq7eLQ2zFFXwdI/XZPmu8y6lVZ0/Vk+sjgc8PNFl6Ha4NjSlks03bx6DZIEFJ/7WpxO +FRcWcAAEqi0fmZc3AEuzWLR67rBprZqmbcc2sLFlAs2rYu2pyxqgRmDRfpGfQdH2xKlZZDQA16xJ +r01UMmyZNPt7bar7VMzf1hzfIgGKihEWPXtDSekM1JCzpI8zgmBnnYTa5wLumWd01BmBkdMWuS3b +lABLyVRok4YIjnqOjPxJzwXc5yE5TgxsKclyAgiBa7IceslmAiCMrnYt6aStmACoLIuWVAfgJevJ +pCyeTQBmOwkmEhXJXfTQxqoHzAit5U5pOm4NzqmmKbYABD1eEcxLR6CSGrf+Gjds7GcxkFTJSkh8 +WkURaH4MboYsEZECiQphtrewCzNe9JAdWcU6vppwmdRVgwTIBpTYuSzAsljD1vrn7TQJBS9kduQq +BATMVWOgxt2T8x9VPH6p2e2ksspkXDSFnLwfOkP1nKKdxiNwVrB7WT8zpsdRcDHMOtyOAjwDpS/T +vAoA6vmyxMclRKbIENhJJWi4zCW5qcVAGEGhqUhyP8qIRc9i9IxVbGtnBMmmFWDRdUtZnCKkJK6G +LZfYZWKIOtyyA6OcS3YMIHVBmfXcYDCPGcnfFNzQPhdwkGTe1GWiB+rshj2hSTpA8jpTs004maQr +q+XmD0DaIhnYVR6MjOlSJFP7ue6Bkssau/mJG6ue3VA/KgAXExwUmlNFxvEhBVNdRf2PLGAZmJvy +lrIYVRvMTY9LaYIPWh+LIWjd1q5lVVo1AoWWZlb5F7CA03MzVXU1Gt7As4WHR5XnnsGdONdb8faV +p7E1AHbuyi6EngXZheUkjDos1E2eLAyHbhCJ1UDHVMOaTeeIrLeZi0cygSJmWjZzxdDhZAJLEgm6 +vioLhKgJGOjSk9RA4aF61IK9TBND0Cc46/E0Cs88Y6diVjnZjy2QazQqXsmzBSCsdplHmlWMDtul +aL8s8QldvuL1iea6Qve1nEPDsa/qL6ZcCsFqQctsikdkO/MZx2VSLsrEZgE/cX9HTmy14KDorpE1 +dfYqBss4iRxCfcYRUkkbijyBn1HctUkAIZK1o8HUWTSXyM4NjfKqKRotxxIDwmuKyoSgaEHoKlrz +nWFMOSsfKfT6jKLPfdKopodx6lmXSLLACIA1cwkjoLwRI1BckFFDkRiVL0X41cU6JREEAccm6TXV +9Dw5g/1MEhOC9JVyEDRfQc/VRI5bPhcwdV36KzF8BK6CV+2CJBF2BlrMCXMmRKmL7DV8Rkkbfd0U +WbiYySGH1GIPcCQ50MqfF0syJXPjhp7GAEMnh2AlX1VTWWhlMlqJKACwBiVgEQc5AIscdITtv87R +ECyzItAQISXetKjTSxKEghkGkZMgGEEw2wQ9gSzBXeLPiGBONrtUzlGOkc56CgI8iBWzlXUUKeuN +Ecx2KD2YtAdg31h0dlBWnK67YKlm1UK30fSDKPkbwkPOtUOFUdeBaQ2xHxKRugHPBZzk5HWwBIAY +zV8cuTwCA1MqgqBnMUYzZaMdQIy9tAEdnxYYjQa/34xDTKJOujxmOemBOdxVZxFFMJ5RujYVNJI5 +pHIWwU0Xx6IJxIul9UXe3QVYa9VVa3zteeiRU6OeUXa7enD73MSke0lriGyIMoIZ5I6uGYr8MRD0 +EwFqSBiBNoTZ0t8Qb1a8dZHTG83OMEXO82RgibrhWw5EwKNsq0HZNYjA1KexHABqFroFoOlzYbUD +p7GfVal83IHZJQk2eK6mU2V7VUhu2Sc7FqQHkTFnjXcaPKpUdBJlK2IQkp2Hx/XPGysCQ9AeiJ7r +jkBF56QIaGs2bSubBwD1iCBoITKNQnJj0M+24nkrCUbEfjopWeZv7Md1UE1RwUuRbkYQLasrangT +T3Zl3YE12ztEK1ISb+2MPUIlkiDqAp+q6UGDyFG3Z3TqTi2gaLo+ADWR3q16PKlZdXVQGvozPvMr +gXFR3p7R+WiNAAZ3EgsPnss5KABLJAALDUgOYbAI3tyPMgc+5EEIcPClJkC0I5WkASoPQ0haVUEP +90Y+Ya0Iwmwiju0S2h5tGiaryhAkxTc6zZkWcJNyPJKHisUemk4tNQkQKBllwR28wDoWlTf7YLHZ +ebbskKAp+1ihQ09RhZ4ojmDVcIMeMCCgOH1NiSIEqwlT3buoRoiY8oGdEc8VnNhgDBz/UHCYdRyk +RgcC56z0Vk56RKBGD0JXqLEkCqW4EVjUGCwLs4ak+zLr01QaR3K3Qj9mMbfZomKRTVWuraOOqaCu +WKzDQzFK4a1sKljzR10EUTM3sDoQTDxhTtXqQL3WksgIRhAtYmoW+oWqQ/9A5YiwTlFwzoMQpEhS +YlWF289FnRIt6Ql0kj/SMmohiJ4og+CyqJlfrFJSWIMYiLqizyngSkloTrZimdEoRO8VnO3EiGSo +k//XkpOFNARmTYyZe5C1MjYGq1u6+297IhcCiyYTzpaiUfp59WKOqELpKJo13tRK3vRAu1bMjEDK +qJSxgKuGY4yI4vIjgiSYYxwgaM5BnC1if4b3ubwwOVaQZ/JewNXSeWvWkEzNmjpEJ5ieSaAoFAXq +zlGS6XXFzmBRTEfDV5rndk7AwShTo6xoNVAGqxZjWZDoB7B03lh5pyyJq8munFykvlwOTGmYQYOY +yWq8FDr1dvH9ShhsKqsm9NII3Ct4UcLqrDkGIWnE1IJ7i2UxUsRULf4eybScjIWPeqyc25M0RWHz +eqFrSFfJTBTCwMoR2GwWf5sNKEozJtHknpGsOgR6ByxZJWuGUuNDFUysmvz9lD8mSKnre0OVTDs6 +O6geZpJx9wLOzY5SoMKhxwR7aQXyEDy/jESwh9kKe2XWoe4FrKK9n+PEOgSWgybJmwhbLhyFnVmL +klUvKqU/tKrhvHMCZIyW6M7VkWJ+r+BmtSNgjKWcg/h5VvZ3a7/PkTynmoBfVgkQwTfl86sBivTH +IAIVrouYdDMXB34+gKGb7FZ5rp8/h7iPviF6qABgRf0FS7eiTMQ6zWGlZFwcSbwOBn9o80I3liww +cai8a+T7SrgCIOh1BX8Pr5T86nvR69oSCIxlkEinWeWQ19KCjTmFqVH8YyFIsse/ESVjTWy3zrpW +UEcAxdXKigRRETT2Bjp4yarSBAv1iQ9TC+XF2oQbsqtQmbqk/iKpw0JKioi8heWv0jXPLFtmy/ye +8WWou4Al2MtHURSoIVCOyXxDfFnw+BvxBTM2Vy3zwzWJljVaIHyJcuhpWVGbtFIyGMBoZ4O+ZKmV +h601jLigHoI7GOJFTfPm4oB9IwsKT4XhmkSKE6Zn3As4ri048PMNOLIVIzTjhMJbP7E2o+rNa16b +AzIrgS14dZlviwpbjDSlO1YPFApUi4MXrhvCPDhwxTQp49eUMJBH+YwwAuoQweaZxraOOYb1Asek +ACW+LqzCePIh0TpuWJMMVf1lpVAtzx50MDAQk3ClhhyWECxEA5bPS0IZejZp6JqcApKRl7IVwc6B +YeGo1WJblt2+oEerqmMyWK0b9GcW0cj1+AnW6ZLxqbaNUiQir8qbuDBhMwZ3cNPHWQ3M4CUEEzzH +xL0ljnKVxEpJZsgZkDAyF6IsK5q9qyz3Bd2SkWc6yDld7+yQwpY0OGoScE0saovOLV7vC0YLG4Mp +r19qVYZVVhBInHJzccRwVfw4LTe772Xo5lhlDpJFeL8BYwSmlRutpEjE4ID3knyJqmUYkDmXpEbb +0BbPZsc8YPVAoYARdPDC/s4B64pKR9pQoEAVaUJtb+v7ZVgv8AB59JOv/2737v3x1TfvX7198+Ld +X25+DqCf/ref3fzdV+/fvXrz3c1Pv/rTi+9f7l+/pHLTf/rdX75/+bOb/wMb7R9s9IsjN/k/4S9u +o99PVJIWnalYfwgULaqODvopVatdKKjs6o0HreedeJtC2kG3rixYyJi934AteWWeTVZUcywB80JR +GU9AHT7OHRnaUnmQMiLtMHm/jp6Ccd6KROhIZz6rNxIgQEbQibW2vleG9QIHcPTocG6hAr/ww0x1 +5MGmCVQDfYkZdHfkK274rB6UQNdNJq6TbszlZDpETUrl/QYsVUyYYN7EkWN0GI87B5tVdUDl7pxY +Crq2mMAV1g3WDhQKGEEHL5ZS6rDOfDxhpECAyl6l1tr6fhnWCzwQ9ga8tQlLK4MWqzdK8I03YO1G +4mrUq4Yi5aBjcVW6ms64C3qvYKaiK/cbMJZdMr8Rl4vFqVdtg2klxw77RtxWoPGtY0upiDii7EB5 +vbJWwYErsI1IZ/Ykj+8XoLJWSbW2vlOG9QIDhLUzFrDG2wVWvCqIrkvIkW4ZAeujkvYa7UYHvBsB +Idlpr+yiqjJvsthOHipJkkwvmLi6qrWmqqyvDlTmhjLHTVtc1mHZYO1AJqCLFYYGjgmMSGc+pD0S +IEBlrhJrbX23DOs5B5i3YHW2pdJtGXOgmzBA6W6RbnkBvZ4MAoycLonuSkiZ7/hCE6GzFiwrQRzx +zOr9BpwskIv1hAupCk3KoXDXSuEdU4DcNXRy6ry3trjmQtxg7UChQAdHwYEP2YxYFzyPuKVAgMpc +pdba+n4Z1gs8EO5i3hBK2NhI3ULjqmFaB11JEelqsuTvICssd42zeDUiYw2YI3e/AUtlbKaVq43S +pJM8A1Q5xWARoHI21bhs2kap4Tdg7UChwKa9gAN7IUesC9cvGykQoHJWqbW2vl+G9QIPhLMLHf0j +2RIrFbAHnWetwyU/PE3drR/Vbk6RLbXUxqjxBmG2gwawFn5CP31axcqLUhtvxhJTapgQUNkr5rpv +i/kxavAYVg8kChSBgsNttEiDIl16/KQTIEDlrhLr2vZudaRnHGDm5nWtdP/akpdA0g== + + + YQbtdORtEFlQ0WtAdyzZDToil7K+rWllfg+Oljg/o0qyiNjXAjazrLgOVAOkrDVv2mKYd143WDtQ +KLDBMbAmdzisQePMjgCGKWuV1t7S99VQnjEAWbuwhptTYF3h/LafzmC9mahfrcV+GWNwSYq/tsX4 +q1AMnc9K3yqul3grh1iwKnvxMDPvxMbwLflKhwFlB/Lb9eMdqnEKh7PPu/52hilvlU4/Q3s3DeW2 +719onuweZ578Xpx7izr34J9vpyK3ivx4NWfb4EJ8RiFdUNRF9pDpeL8Blx69xaMWrMeulgBrVRkN +SPy2JADfFsvmxbLB6oDJ2bQOHDj7csSK943ULQUCZAo6ta5t75fDesYDklRfbjBSUcLEpEk64v0G +HDjXnwo4srWPybTNalvOcXVA7Rjn9Q9t0XGZmkfZIfJu/nQHF04jHVHWW/RjbF4vQB1ZJbW3dT3q +WM97fy1jkdNZZukcRSXvN+CAviutrgk4ZCPTgi/QOXhpc0DlbVnzsmmb5Kz8gLUDhQJlr4J7wTWH +tdqBWUeBABlBp7a3df1yZdzOeHAlY5HScrL5aCwI6cCoRATlbqI0KOQY6Gg6dZYUPVC5i+60TVsM +bba8wdqBQoFyV8G9cKfDWqzak6NAgMpdpda17f1yWM94cC17EYkgF+vKThSZuw4qp0gY2F3ONWTl +LtdVNaByt0Wdu9Y2y/mEAWsHMgH6eYX2wuQOabGLlBwBAlTmKrGube+Ww7rlwJXsRU4SW1QTxtKE +9xtw4BSRZ1L3Vw2zVmWpFrlPyoDcNaogtWza4lHRuGywdqBQoMxVcLKaiw5rthwnR4EAGUGn1rXt +/XJYz3hwBXuR3l9XGbIaNRPCgQNn5TIwLgqk7ZP7JU57BSpnF5GNri0eRlWgYe1AoUA5q2C8g2HW +ctWKNdvpF0eBAJWzSq1r2/vlsJ7x4Gr2IsorSmEj9xTm799vwIFzWbgfLeq8S3JgFAt0B53iyaI9 +WMx7mc/bzrkuZ1gVKBTYzBcw7DJyQthhxTM7YUuBABWBUuva9n45rGc8uJbFiNf/NXXiUI2R+zOw +3qiBwFTV/Oh9g42yOqD2LUUdHte2BzUd1g4kCmx4DGzJlx1r6kpIpyB5haVTO7Tt/XJYNzy4rtGI +O0VrMnp0AOD+DOxKzC/mm8CxFVYUNbSruivo4sZ52basIYQzlB1Ir9fPd7AerXBIh/mv7xegySfz +l1hb3ynDesaAbzgN5N8htvUh05ENmX8T6zFmi2x469GBC6cXPONa0XRcyke5sOpwiz5MRkzH0rCU +pOTbJnHmD1gd0FuPDhws7uywytGtkQIBsvnZqXVte7+CLyS+4YEoil9kONIlRJovgRvg/QaMuQhF +K3PzQQhklqsy3TlIQGUsF4zybbGy7cr7YsfqgEIBI+jgoFl1DuliJ1QcAQJUviqxrm3vliE958D1 +jEdUoIr4+akeyv0GnMnzw+Q2KhSE/LKTH6BgScqHALlrDatMprEtHqgpoQ1IHUzer2OjYEt/9kjx +qsKweT/DlLNKam/Zu+RQnnX/WnYjVp5PQa22okZ5h+KFJImXUuW0V5pzVj97lbNpBlTG8o19vi0u +5qSMVawOyASYNEnKWD3U5JCCtbTKhROdAAEyAZ1Y17Z3y2HdcuBqRmMsmnCCN5rmpTNXwbmfLKp8 +SJUX9GrM5TOCBlTm8lngoW2TUy0D1g4UChSBgoMv0K5Yg52HdhQIULmr1Lq2vV8O6xkPrmU34u0G +ErmPnNl7vwHjPYHs+cHLCaLaC5poRzcLDEDu24p7bty0pYtZ1g3WDhQKbO7PypzW9F2KNHDYaiQg +uGiaI9a17d3qSM84cA2rEYXSPGu8C08M3W/AyV/kwJej0qSTLGa8mqGFxQGVr3wicGiLVRaVr4a1 +A4UCRdDBWq7ZYcVgS1k3FAhQGavUura+u4b1jAdXsxpx6fSI1TzrTtbBya6Zxcsz6FAI55LOyt5a +1UlMQOUO3xYytIVtpyh7DWsHCgWKoIM1sdNhpaNNaUOBAJW9Su3QtnfXsJ7x4FpWI103EmRJZJu7 +HmoaTNWkTKQsZhXDfPWqAbVrVVIwhrZc72mDtQPz2lnToXpDQ8eJdTkMqO8XoH5eaR3a9l6tF2DZ +5u0VbEUkNze1RYtpCh6sJ2iwF3RAaTPoOc1+JtisCXM6a8tXx22wduC4qg2sFZsGrLWFMwJq66zt +tPaWvVMO5YYBbCt+zJL7tzDi6JC+zoduxDlwL/uORf3XIvaaVgpLdKNYc0BiRsaKoLWNbTP6+FWX +c8XkFeiNOAfuGpbD2jNBHAU+E8RR69r2frkj7mc8uIIRB0jXqn4cLCJ0v4G6GytW3C4k6mM3ZuDp +6DU6oPJ1DqmNbTM6T5cwYnVAJkDZqtCgV7U5nJbO7N8vQOZqp9W17b0ypGf9v5oFh1deLDpcEWtq +3W/A/a5RrI2Rm8xjrRlEtzWk1QGZNbNcX+zb5sV2qI7VAYUCHZu+m1EBrxHrwvUNRgoEqMxVal3b +3q+O9ZwH1zLj8J6QXNSnODdjrkIxrzMKb0NKepZgYVdnovpG0QGVt6pc9ba4moOG3gSpg/HrTZoI +NFoNIIcz2D147v0CVM4qra5t71THetb/qxlxeKtK0zGjQq/3G3DmYhxMb4wajtN7GqFvVMqlA5W3 +S8qbtgCkU7cDVgcUChSBgqPdyuKwBrtGwFEgQOWuUuva9n51rOc8uJYRhxVvYlYDVZXhAUplYJnc +tGiYXgrd0nUvOXYYd6zJeVjXkqaduvwU5QA0RdhB8RC/lRxSnMHvYfr64PewTqlr2/vksG67fw0D +joS9DiGdibzfgPupcapYpAm4mnAM3QKVsDqgspXOpGzb0v1DI9YOFAoUQQfrhSAOa7DC4I4CASpj +lVrX1nfXsJ7x4GoGHC6bRQey4vVh9xtwMpUVCaaiQQjUE4IAbGENDqjcCaUsm7bNdFaHtQ2KrPpp +B7Bf+4I19M2pUxDGjUypHdr27hrWMx5cy4BDGqhmDef8hz55HXiueoUUF1wkYycay9egThECat9a +1Ri/tW14J1fcYB2AZt0OYC1wOWBd+y1YnYLVwloDta5t75fDuuHB1aw4LFvWdOBgtPrk7WAqZyrA +YuG5PvJVNNE47iVlnc/b8gXUG6wdSBQYAgNLEfoB6VrL2fsRpp/upLqW1qeOcdP9/zgbLoOIWtfk +7Jf7DViuxHvGVQOlf9Xq0mDdQovO9YOBWA8xt7ppG91xa8XqgN6Gc2AplTZiXbj830iBAHkD7dT2 +tq5fHes5D65gw+GVOOsiPpRktU0cOFvgH29YCT0RrelFIlwfw4DMl0VKRA1t8eztnEasDigU6Mgo +2CoOOaShM7sTEPrheE9s8CzUbhnScw5czYzLPUaY+Gje/QacXVXM2IpYD0lLb2CF1nl1QOUtH+cf +2gY7DG1IHSy5E4MOHPsdAh1psEpjjgABGm/btq3rVcd6zoFrGXFY2rM0NWKycVaBmS8RZmpTsfCv +XZUDo9o6TBnLle59SywpHDYoHZBermxVYNetHEpMyJZSMf3tAlS2KqG9retSx7rt/NUMOLzIyU7l +UMm9+w04c5nTZ3KxUdN4st6tgFJ8WRxQOctFqoa2VKOxjVgdUChQBAq2CqAOKdZxsQK1SoAAlbdK +bG/rumVIzzlwLfMNb7iyTDOSSPdnYImg5+YM5mj7B0w/B2O+4MlFDepry0UutXYYB1iXkg4craC7 +wxn4vsnx9QI0vrYSxrauSx3refevYb9R5WBL9V3nXoeoH8jLcm8H3uVV4qLzbVa2LnVJDqh8pcK8 +Y9sFq4bEEasDCgXK2Q7WwmUOay/X6igQoHJWqe1th+4q1nMeXM1+y92LF/lO1fsNGH1zTclQ27bY +HV/zuiwdpqxNljDZW1Ih5QGhA8rL9fMdTBenjkh7pU73fgEqZ9Ww1pZDPxXneeevZbjh2FL5SsI8 +6+nJEVytzhWd1ePRTYtdFddUs+8H9MrsMky1LUrEpFJOsY7AWdMRB7A6iAesJbdwRgEBjbdGrWvb ++2Vu5zMeXM1ww3phUU/jU3j3/gysFTMRaHuAG/ke0iagdq5FzYD0bUurZ1g7sMedB7Dd9Ouxmqzs +729d1HZKrV3vkcO36f1j7Lbl3y6LsqCvxZkt9wMwa70/uo9gFWc772R2P4qAiA9V72Vz7TaYRiPJ +IBge5esAHQ6skr9sXsYw/mSnyloa7R3hto/XOmEHeIulOtCFzfcbcLaUMSR1zaLoptT0SonSogdy +t/DWPQ1iWNvIZRJHrB0oFOgoKLgH9B3WYBfQOgoEaIwVantb16+O9ZwHV7PQCq4VHbho52kcGG87 +kvtRsAJH1HoVya78KIvVxknqvcXrTWa1iq2tVEcdsXagUKDsVXC0660c1qCXkToCGKbMVVqtpetU +R3nOgGsZaHg7iNV2C3rI2kEzHu/T20XUd9UvQMd7U5IDKV/TrDEfa4nn72vY4OzA5FZzh8bhhplZ +zTG649m/XkDG1tUSeaWl61LHedb7q5loFWe3KqEklu/PwE0COXWWC8B5QRe9SCqV2BxQWUuVK8a2 +wbZzh9UDiQJF0Lf+JGfIHNZgRXIdBQJU7iq1rm3vl8N6xoNrGWmVpLOaf5j1fX8GNhp62NwuIFqw +aEVwQGHNplngkqcenQfRi23CN/WqZLGRdQLPendVf6sAjZ9CoWvbe+IQnvX6GrYZ3gQXtIrNXNQ2 +G8Bu7+K7tWmiyZWI2K9FrTirL0kbddNAkbUNeG/IFqsHEgXKVAV3lc1h7ddIOAoEqJxVal3b3i+H +9YwHV7PNcAOtUTNaV1UNHDj1O9qAYCl1lCzHA2+bQhnWgcpeGPTztmvLeYO1A4UCRdDB/hoswYql +BVPYUCBAY285a+u7a1jPeHAtE42EkbqKKeXgfgNOfWPHworVmBN16lBRqw5U5sDG3s7a5qa1hpxq +ocDociEGsJjPDmnknMaRAAEqc5VY19b3VpGeceC6B+qGUcaUzPszaJNrbugGNvNepai7SPcuEFD5 +s7S1nrXtxVkMqweusfO3Q6kq7oh0mNLdvUBAY7D51NxE7d0yrFsOfPGBukdWY/mQKfj7f7fiLMA8 +WAHr9nidB1sZlbk2i3lawZW5YpYqq2muOMtc6VbdddM2uhIehjW6Eh5mLnqwlVHxWK3giqfAFWfx +1Pa2rl8d6zkPrmQ6zhUjLhb90eIsHsyVVLBjq+Q2WcEV7JhG4F1xFuxYDmPLdZEy0obQQVxpFg+2 +IiodoRVb8a92hVk8ma5t743Dedbzq1XxrHgfjlrDVpjFg62Eylzp4nrJL5Wzy9g5+OYrsChfo+yZ +ve06yxWVHqsDusIsHmwlVDxWK7biKXCFWTy1rm3vl8N6xoNrVfGEIc7BjpdpYRYPthIqSG+Ztaav +FFvBvvEtrENhFuRDqGPL1ceJFKcDurIsHmwFVDpOK7Ti3+6KsnhKXdveJ4fzrP9XKw== + + + 4lmx4rfmyWhRFg+18ikIbOuqCdBcaAVw4ln/5oDKWc2h7G3XWeusO6wO2IuyeKiVT/FIrdCKJ8AV +ZfHEura9Ww7rlgPXKuJZ8f6NVfUIdSJ5sJVPwSnC1wi5QivYNS0v6oqyIBvmsGnZXLE9w+mdZlaS +xYOteErHaUVW/NtdQRZPqWvb++RwnvX/GgU88f2zGv5WkMWDrXQKAqsFJ6XICvZLM6pdQRYEq3Xi +2oKgzFo+z7B2oCvI4sFWOsVjNTPfU+C8AZ5a17b3y2E948G1rEfaBbqRpgVZPNjKQdAMSTrrpMgK +AvWAsSvIguBaNy2bq4JsOJuvmKzlWDzYCqd0nFZgxb/dFWPxlLq21dmuhvOs/1eyHIk0q2drxVhG +sJRNQSDIcV93RYBr8xVatG/F0tVd27K2doa1A60YywiWsikea+pKSqcgeSWlUzu07f1yWDc8uKrt +SNNk1QIrVoxlBEvlFKRFrj1oWmKFZtSi0QstxkL9C9t2veaqQ9iBVoplBEvRlI5yWE36bleIxZM5 +rpK1X/VR8hnwf4lCLDOGKWwJd0vRga1kylxWK+ttxVVgZdiEdIVYZrzda0550zbK3cgD1g70lqID +W8kUj9WKq3gKXCEWT61r25wUNqxnPPjy/E9EKpd/NFeIxYOtZAqS2q93kOIq2K3OQSvEMtOFbFpc +09rirdRq2BvWDnSFWDxYa6Z4pFZcxRPgCrF4Yl3b3q2O9IwDVzMWC+agqnfBCrF4sNZMQXIXOcts +xVVmunFvCQ7IXcu4mrZtwWDo90gI0g5zhVg8uN9D6ZBqeRX//l6IxZPaW/YuOZRn3b+WnViav2RF +jld7qJVMQWrnHH3NFe4Y3w49FGJBHmiFN9cWFnPUAI5h7cBeiMVD7eitR2rFVTwBrhCLJ9a17d1y +WLccuJqhCDRUS52zQiwebCVTZrxXMpWxEAv2rWU9NGmFWJAPoCylTdss18UPWDvQFWLxYCuZ4rFa +cRVPgSvE4ql1bXu/HNYzHlzLVgTMSe75cIVYPNhKpiC9qxz0tOIqCJzrsi3Egl1WS8G1zXjZdthg +7UBXiMWDtWaKR2rFVTwBrhCLJ9a17d3qSM84cA1rEYVStUKDWojFg61kCpJa5X4uK66CwGVdfcUV +5WtJ6vqxtgUsZotgKtYOdIVYRrCUTPFYrbiKp8AVYvHUura+u4b1jAdXsxZxdK3qqxVi8eB+VWDB +m9Bm877atIUhDA6o3GlS9d61LewyH7F2oCvEMoJjsLaKNbI5OVIgQGWvUju07d01rGc8uJbFiDTM +ZmXY3PXQloPKhByiFcVWwlLopxH6goyLRsl7yxB1MjqUHZht3npoWLJOUcWpVRD82xmmH1c6fcve +IYdy7Pu1skCJ2GA3WxTTEjxYTolSJ8xG1CsVsQ+xFQe0GZM1idO1rdmO63asHTiuaANLxZQRK5dW +GQnQIiwjrb1l75RDuWHAf9gBvhkPAiU9VtENOAe2cilzhh2mqZ0hhVVgSeHlux5IzMjRDjO6thhe +Uz3OsHagN+AcuGtXDmu/YsdR4IqweGpd294vh/WMB1cw4PD4mlyO14uweKiVSyFKZ43wSGEV7FWW +0+OuCMucUe/RwJy1DXYXqMPagb0Ii4fa+nc4+52S7v2uCIun1bXtvepIt/2/mvWW8dL0qHuTFmHx +YCuXMmcsTjmLcisZ7ti1Eu1OOS3Cgmzo4W1rG213clij3zS1CIsHW7kUj9UKq3gKXBEWT61r2/vl +sJ7x4FomHGCuQctJaBEWD9V6KUitpqhaYRXsWY0a9rEiLMgFVaxc2+jqoivSDutFWDzUyqV4nFZY +xb/fFWHxtLq2vVMO67b/VzPgAHNaVUWwIiwebOVSkN6aVOuVwirYN737zRVhQT60qGNjbeEVTc9J +GdYOdEVYPNjKpXisVljFU+CKsHhqXdveL4f1jAfXMuAAs5bZ6UVYRqhUTEFySwl678asvG1JbQ8t +woJQiksMLZOlkDiUHmhKsINauRSPM/g9TF8f/B7WKXVte58c1m33r2G8kbDXNEArwuLBVi4FSc1V +PQZ6P2PGsrRaNsiKsNDeEtRnYW3xR7sFUbF2oCvCMoLl8K3HaoVVPAWuCIun1rX13TWsZzy4mvGG +y6ZoxqAVYRnB0MtV+tHL8EvOMAIXKT+Xen4xrdJFA6HWNjud1bDmQZFVH+0AFsvWIY12qb0jQIDK +XSV2aNu7pUjPOHAt0w0HOKj0sRIsHgysWaoKW71wCv2hMQgwZD2AETQLkXo8W469ts1Y72/dYO1A +V4JlBNPBjhFr7NtTpyCOW5lSO7Tt3XVYNzy4mg2HtK2a32slWEawFEtBoFZOjH13KFZLPI47SWzt +vG2vZeWwdqCVYBnBXDBlRLramPf3awmWkdTesvepY9x0/z/OgksFD3z6VMn7DdiKpYDCDYtYS2NK +WRUQbi4uZyVY5hRMGXVtQekHi3WDtQO9BefAVizFY7WyKp4CV4LFU+va9n45rGc8uIIFl4qVwHcl +WDzYiqUgqTXPlkrGbgboVsrNA7lbEe9V37bFK7y1Lplh7UBXgsWDtVqKRxo6WzoBrgSLJzZ4Fmq3 +OtIzDlzNiEs9OuhKsHiwVktBcku/1YPLqmDXcmrRAZW3adHb660tntXRuJ4i7TBXgsWDrViKR2pl +VTwBrgSLJ9a17b1yWM84cC0TDjCnRe/qVfPYAa1eClErEUctrIIdK1HrlpqRkaJd39tb4rXTGto0 +lB1oJVg8sGtWDqWVVfFvdyVYPKGube+Sw7rp/NXMt4R5uHp9hZVg8WArloLk5qxRHymrgl3rlwha +CRZkg14Q79rSvdB1g7UDXQkWD9ZqKR6plVXxBLgSLJ5Y17Z3qyM948C1jDfAPPcrHrQEywiW2HnK +zlyOtn+sdpNatO0DiMxxHVviyY9cR4we5qRkB1uxFI/Tyqr417sSLJ5S17Z3yWE96/41rDfcPuXW +CleCxYOtWArRumhxaCmrgv1q8+prrShf+1lfaxst3ddh7UBXgmUES7EUj9XKqngKXAkWT61r67tr +WM94cDXrLXUfnivBMoKr5D0nPFeut4kVPpdInWsaLyh6hpEkYKr5rC0oMOsGqwdaHRYPRldAVQTF +EjDVanAUJGdhOGpd294vh/WMB9ey33CIk1qWVonFg4GKVYWtKuPoC41Kbi/KR0Dlzdps09W2mJJq +5psg7TBXh2UEg6Zj67/ZveNrXTYECFB52y0H17Z31rCeceBq1hsSkbSmtdVhGcFyUJaAS4+VcSQ4 +ZRfRtjosBE568M63ndX6clg70OqwjGApIzBibeXs/a3L206ptes9cvg2vf+PrcMyx+5u8RacA2sF +lTmi1jnUWJljtKPQVotljqjYDzVbYGJYdmpH12HecnNgq6TiUWrBFf/uXprFE9lbepeSoTzr+LXO +2EW89jZo8qKWZ/FgK6SC5KameVFScoV6Jkf3XXkWZIIeyHdt8Zi/anuGtQNdeRYPtkIqHquVXPEU +uPIsnlrXtvfLYT3jwdWst5idt9nKs3iwFVIhgi0XTc5QY+dS0eo3Vp4FGZGqWszWdkENc9lg7UBX +nsWDrZaKx6pFVzwBvTyLp7W3zM7dbijPGHAt4y3mTX2U+w3USqkgterXsqIr2LEuNaxAC/KgVD0w +aG2X86IvHpjcml7Oi6l4pFZ2xRPgSrR4Yl3bfF725ZwDVzPhIuYp6xF0K9EygqWYCtHb6+9LcDB2 +m8CVaEE+rFXLm1rb4NQSw+qBVqLFg62YisdqZVc8Ba5Ei6fWte39cljPeHAtIw4wr3ZSykq0jGCj +oQfV9aBVJB+1r9vCPYtu27K2uDpVjTNudZDVafFgK6vicVoBFv9+V6zF0+ra9j45rGf9v4YVB1hB +x9gWaxnBbicLeR2LtWC/tHyaK9aC4FA3xVpoyuG6GbF6oBVr8eCu1zmsVoDFU+CKtXhqXdveL4f1 +jAdXs+JQV5nVz2HFWjzYyqoQwYsmUGouSETFUm+ksGIttL9YAqVrq7fDO6wd6Iq1jGAti+CwWgEW +T4Er1uKpdW19dw3rGQ+uZcWRWLJUSS3W4sGpb/PoUwq6pXIBFuxbsxRKK9ZCa3XVC6Zc27RqUSGv +aKxaUqjnTAxgrqvikVoBFk+AK9biiXVtfW8V6RkHrnvgbhhlLdYyQqWsCtHc/VxcgIX6Zy4AK9ZC +c8q0V9cWDICyweqBFiYdoFJWxSMdprTzgizOhuiHwt1E7d0yrFsO/FUWa3Fn8L501M+qteAVSGrE +0Vy834Az+w8AiNvlXLXwhFzMPEfLCRQgDsGywH63zHFsu/z/7L3rcuTGtSb6BHyH+qMIe8cGjbwA +SGz9Einb43Noy2HZM4o4MdFBsdkSR7z0sNm2tZ/+rO9bmUACKJJAdZOsYpcUEgsLyPvKleueLRJ3 +2EGtOTD24PhAwf3BQfDJCNwlfDFGGHcborUx3SEy6BiBxA0GqaWOxW/LgCwCyWM1IUwGzDq2ZsZO +BGfQCw/JBy+C0QjDqzQTKtAGXAoq3JUOxKbQDAEzoFyBVn2hAjL36y11ZYtscawX/IKNKZFKmC0p +RYRKc9TroKOTfMDo9JaLEilabEzwQl8rnYmAzdnlRFKnChi5mib5MTrVFeJ9qDhkXKSVosLhZ2gx +BFsaJf0KrCskSrLSlyRwMTQHSWIA5N47jhXo9QS2xNEsnNAJwbjCCytnS9txxBqpEZXM1BZiZGXn +4gQOKWUhLV26WVFmISXUlvmqWwVGlbvOrdWw3eD6+E0gVDQ0yzpERRsWMlqXAtL/GOagmi76MbEB +Y7PKt8j6sudXcWzRtiJg+sjqt0YzUAbQeRWlwDGqKCSIKGxgJK5tZ4cJrZytnvjL5C6dh6Je61uW +XaxkleUeLOsYeYJFq+P1ZjLeivpGLISrNZOWIGNlm7iSclanjQmnBRMXzcOlNOFzWXsuWh0xUTim +oDiT9MDyszVJxvcgSWlPttanDLOt6jXbLt9PwK3nyqgjctZSrAm15qs5i7MKO6GubUoG0JaaCUKn +ulTmG/Nv0g4jFhyvX60THgRtR5K/+uZP4c3vr98e3X788LOQ87vz22sAKwDf/OXm+q9C8++E7BeF +go/Of7q4zl8c/OU93phSX33/P//4h4tLqebgd91POWd+98OfT/5y8/YcPwcH0L0vvl795t9Xl9fy +qpBu3V78+PHu/AOOGjnDbk9HX5z9fHH59vb8Gu/t6nd/ur7r3+F/d/Ek+035lRxk/7i+OBNgOs/y +D/95evlRv/z3wx9en17xO3SCvdrWcfw6exy/vsA4ZD/PHsm/Lt7e/Tx7NPHrrR7Rz+cXP/18N3tI +6fNnH9PNj//n/Ozu6Obj9Vvp39HNI3ujH+A77n/59O7D7FEOyjz7UL/505tvLt//fPrGzB3jxduM +N75nTPjmP2f0eFvI5N3H2x8/Cod/dj53FrTozCVO7Tw30RRhfe54fjz9cP6H2/P/+w== + + + USZhPgkdlXr2EV7ffH93cXf2CJXsR/mBX//94vJ8/v4clHn2Edq5Q7v+ePXd2d3pPxeMLC/y7APD +lps7ttvzDx8v558b6fM5FOierpsHur6e+mWHwPnfc3LycGcfmPdnXpCL67nLcfP+/Pb07uZ29oL0 +BZ4dzb6/+Xh7dv7H29P3P1+czT7iHpmK/KS73vK9c3H9CAkZDMa+4K45vrl6f/Ph4m7OpnmKDpAP +e7Tt3317/m719V7a245x7KW97R3RXtpbM8otkfb8lyztvbs9Fbb38i83Fx9embw3W4jfi3vbKe7N +3pd7cW8v7u3Fvcmo9uLeXtz7YsS9wr4WgW/JSLZc5POvTuRbMKJdEflEDjo6/+f55fc/n769+deX +bfvSI5Ni4Ws5MH+8/PgIt/IZmM1tlQw+3L399vyfF6fo0AKpJy/0YjzBH08/fvhwcXp9pAu4K7z0 +7LV5O/8YfvsS5/D8gcw/hd++xDG8hAJsOzW7effuw/nd0XPQtBfa9t9xhDu04S/Bt8BL8Ozm8ub2 +v/71s4oxM+nzr5fzVYnx6/0G+oSxfHh/fvbdx0f2w+5xBLN9ez58vH13enb+/dnpEsQbFHp+qWP2 +4GRxP16e3h7fXH+4O72ev27Tgi9gTVs6yt//+/3N9fkGo+wL7pJsUlRlOXuOtlzFYcoFY9luJUdh +l4zlv2eP5b9fkAf5683F9d1JVF+8hD7y/Pu4VU8ic7FD/NDrNCYs5Bu2nQ3aSNGz2Jqw3Wu0a5LR +EiPJthCD09uLu5+vzu/mG+B2iSjMPvZ+eUSZkg0Hn27xQB7hxfOBmG0WFX5x8wfitnog86nyLy9B +lF+lFX4xN7DtR+flxd1fTy8ekyW/8LNzd2Tl5WrixTvuhRbyz+e3P51jJneICVq6uV7jWjxdB/Yu +Qxsr1L56Jeq0BV4p261MM2bvMbT9HkNfVpDI8c3N5dHt+fl/z7ZqvkbPqLcXl6fz7bq7pMQwh7Pj +ym9P3158nI+66fPd0G5ut8Q5fyBv5w/k7TYPZNdEzD/f3L7/+eby5qdfd0g02ZO1HSJrr4aYzY9g +2XJi9mrD2HaSmBWvx2X11ez0ZeEU27zVZ49k1/b6znncvt6Y/dksyz5m/74xvmzM/mw/3F2L2V9A +yLf9SJq9ybb+SJov4ezYkbSTWRQe8SjJyNoy5/sX8rr/Inf81jtq/Dgby7aees0eya4E4fxttjn1 ++OfT6+vzy+/PL8/PlujTpgWf3yI029K66SCnBV/sHPr24sP7y9Oz86vz67s/n77focPo6lSqmm2Y +3AnpaJX+XU1+msHPuaPmr/n8d/p8iynl1p/Ey3INbvPpNXsku8Z7HyOM+c+JfOwKvVuAWdu+R2br +ELZ+j8weya5wePMjkZ8n8cq27L53i/yD3l1cXi7xf7rc5pV+d3tzNX8w/Pj5tZKPMDmZYewxj/Hc +MvbxRWKuZo/lR9zJNV83rl8/v1H/8l+nv84ek1C+u9PbRZRSv99eTfjdzXzJ4+YFBnJ7ThFw7nBO +3769uLv453xxqi/wAvaY6/njOjv7ePXxcW+hfGRZkReIaLo+P50d/nJ2enn255u388fWF3j+4LPZ +vEW2eqn5v3AIcxdwWOqFRJLT64ur0xdLDbureeiKsHeG2TLJ7uzVOMPMH8muaT/2zjDbou7dX1g4 +0SnsmjfM/Jxmu+YOs4CUb/uh9GrcYeaPZNcOpZ10h5nNf+6GO8wXueO33h3m7NW4w8wfya4YS/bu +MHt3mG05jL4AdxjzpbjDLKD5234Svxp3mPkj2TXeezfdYRZg1rbvkVfjDjN/JLvC4W2bO8xW2392 +x5tnwZZbSjxeaA13MWvgAj/A/So82So8Xc6NHViEp+vACzW++0kbv/nTm2+Zs+fNMs3XLIZod46o +15u3aL4acEeyFj1PAvCXoqZL8uTsKdrDFK3eU7TXSNFmL+ueou0p2iuhaL+/FcCXzaKdYwpeIz3b +c2h7evZl0rMvmkF7tfRsz5/t6dmXRs9yo86bZVb4V0bWZg/+C7Lh7bfNnG3TfMnbZvbg99vmC982 +X9ZtQX+9+Pf55V8vT399syzYcRsddqpyVc32ntSZ/9sCB8qsxC5Rvtvzq5vH0hvsWK6X+TlF9vlR +9vlRPhPSrczXtlyZSv5fruS/r+W3/P1aXqxem8v2xfXb83cX1xfzDVy35+/PT+++XbDdshLPPr59 +jhgd147liPnwHlli5o5ul3LEzORGvrQEMdvCQ73CCwp/XHLZ+JZ76i8Zy6746u8VFttLDh7b27tp +V1pEEbacum1oUtr68Pmbq/c3H4Qt/+7jIyRslwP44hh3iCCc3l7c/Xx1fjcf13aJMMzWqf3yiHEq +Gw4+3eKBPKIMzQdiXkIZMXsgjzg/5QNxWz2Q+aT5l12hzLtxiC6UenbpCH21WRE/yxm6OyaOjdZ0 +ZxyI9gGAe3Py7pmTl6Up3Eat0t6cvG5W9ubkvTn5GcfzWs3JJC4wKNvy60WEZm9C3puQ9ybk/TUj +k5HtTchrurs9KuK9CXlvQt6bkD+/dmJHTcivydj69uLdu4/zbzPZdlKwcDi7Qg1mp6f78PH2nXC2 +3y9L8z8otL12JJ3+ZWMblHn2of16fnl586+547u8+OnnO3lfnCEP7uwhjott7wLG3Xl8cy2i+/X8 +fTcpt1e6vajSbX/H7eOj2SvdnoKUfv3T7fn59dfCgZ1/fXH99uKnm6//eXFzeX739e35269vbk+v +f5q91fbauL02bq+N22vj1oxsPh+2V8m9DFdlwmyry+l/X1x9vHvk6sd8SdL3z4549ewxnV/KwyKV +T1bixfQ9316Qfz/B/nopj5hvVZY4iXt8h1D+NamdPrw/P5OD6/Y5fOGfXTp61cqa2SQqLfFiaX9a +cJvXMHb29/9+L7zeBqPsC74A4/2INvcJVFN7vc1eb7PX23xBepuopVG9TVTiUH2z19vs9TZ7vc1e +b7PX2+z1Njuut7mMCo1X4UKxV0I9vRLq+yj87aAW6nXmz9hAH7XtKrZXGQH8nHrDF6JP+xwa20Yc +Xk0OjfkZG7Y8h8b8FdnyHBrzB7LlOTSe5x6Q7fYm3v7j8/Li7q+nF49ZKfZn5/7s3J+dGw9ky8/O +ff6pbTs7l1LlbT82NxKmd+Xo3Oed+rS535Zjd/F67nNOLenACzW+zzm1Wzmnvv/59O3Nv57i/qLd +oURfeHaBXfHrnJ0UbR+R/+xbaPbFmm8fIae5W9u/XwDJ5g/k1/kD+XXLKcC2U7Obd+8+nN9hS9ye +v11Ep3dNBviOI/0yBIDNV/U1SgLbsiqv+z7xvWi2y6JZYaqv5qLkfD7jJdiMJSOZz2i8BJ9hfDl7 +JP+6eLvAnTB+/fwjcvNH9PP5456H2ZDS58/PQX2JSo0nyKK9O9zVXqmxE0qNeq/U2FpWOLwWpcb8 +geyVGjsg/u6VGtt77O6VGttIyfdKjb1SY1uVGl+YaHZ3usDR8jUKZu9uT8/uTi//cnMx37FZC89c +49TSc/tnHs7O2fLj6YfzP9ye/9+P59dn8znOUakXiEn//u7i7uwRBVYuseHrv19cLsiVMCjz/Jqv +2T621x+vvhMs/ueCoeVFnn1kZ0/nZfbcI1mm1driOOf5I3lCgWdbToXXl+xowXnw7vbmav5w+PGz +D+c1pW56ramOysPZt7bc3cznp25eYCj73EWDwe1zF+1zFz2xanm+TPKlpS56EqXR3z/e/vjxUiZ7 +l/SIrzP3ygKRYsuFo+dJufJCet4l8WF7Veta/vCr1+E9Nn8cW+47Vr4637EFI9r7jq0Z5YsbKHq+ +5M0j4fev20xxl/Nnr8hIUe6tFDe7baWY7c20a0YKbLktUInvxb3XLe4tQbO9wLcX+PYC317g2wt8 +e4Hv9Qt8s0WD1yjwvV6/tNk5HfYS33ZKfLMXcC/x7SW+vcT3SWi2l/j2Et8OS3yFeS0y35KRbLnU +V706qW/BiPZS35pRvrjU979ubt7+dHs6/7x/jSLfq7wzYlGM+JaHSLzGjBezhbl9xotnJwj7NJ4P +DWSf8eITOYyUB+JV0OZ9/o6tJWPvLoW700uI/+vHy9OzX75eKejm/enZxd2v/7VAJ/zh7tfL+Tru ++PXzu3AvuXB523fWosHs2mb6AxBxh/bS69SILtsvO3GubpZzaNtv/fnAVI7Hr4m8fTmMwy7eBvia +GO6l12du+cZZOJxdUYjM9jr58PH23enZ+fdnp0s40kGh59eUL1utZWMblHn2of3r5wXR+ZfQ6sv7 +YgbnkY1wXGx71y9uzuOb6w93p49dpZhrVcbldkmBbtzszXv63xdXHxeYtrrvn33JiXOvJstQPTun +1fmlPCxSNmclXozH+vaC++YkGhlfwmtA+sA9fBKJ1Z7b25VbX/cs0i6xSGmBF5+x04Iv4Ce/dJS/ +//f7m+vzDUbZF/xCWMI9v/Ty/NKeXdqzS3P78H0kVDvIL71Oa8AGnNO2M4PP4ya9/eu0V5k/QzrR +24u7n6/OF+R13yXiMPtA/OURn4JsOPh0e+WMXx75Mh+I2eoVeSSDTz4Qt9UDmU+Zf3kJwvwqHYmX +Ws+2/vi8vLj76+nFYxL1/uzcn537s3PjgWz52TmfCdjys3P+QLb87FxKlbf92NxImN4fna/g6Nwd +PfT+lsZt5IWenBLuwFo8XQd2CBFeayqiffLZ0Sh3LxXR670ibyOLwXazon9fnMN61/i2nUyydHUq +Vc1OL7ELhN2syvjvul8dZO6Q+Ws+2Uif78D+2naK8Ucp+uFx57HdJRiMpPpz2oC7QjFe4dn0rPFf +25p9YZ/i4/kTpL2aHB/FbGFq25N8PIsi6pnH9N0XE+W6c+kxXqcT32LW7fXuoO23p8DegJH9/RUn +QN5Fd4RN1mXb91E+ptlhjbvCapvD+bFRe2Z7fyZ9hr30w7vz2z9c3G6DimRb1vnu9Mf5a7wLCk27 +mm3n4Nj/5zKN5aDMy6Xi+nh99rcdoiavDssOm1W5+jLw7I97PHtBPDNfCjk7eikXEwo7iLr+++3p +9Yd3M26R2B58f536kE1YtW1nPzeMM9kFbYgObUv46r0+JK4MPee+ubzcgjXZlinZDFn3vppLOvBC +jS+6/umrb/5kyje/v37bXQMFUAXIm7/cXP9VqmCakkLBR+c/XVznLw7+8p51eH31/a9XP95cHvzm +6PTtT+crsypWf724/uW3Bx/l33L13UHvUPPDr/Lw/8iP/yOgf6386s+r/+9/l6u3Av3hbwflYVmW +bVjZ6rCpVlcHhTksvamrCCisvK9MvbL+sKpcA0Dr6lbeu0PX1s3q7KBwh8F4u7L20JUo4w9rb6VK +c2ibIEWqw9oZeSGA0niPItVhsMHLN+VhWxv5ppZmq6ohwFV4tk0d2vQsRZpDE6rWdl+EQ+uDZ63O +u3pVtChSGgAaF9gzU+KjBl0zxkozRvpUSRcE4NvWC0AG6NumA6CQjKMJzeCb2mPIAg== + + + cJUlIDRNrSN2hoWcTFfp2bhMJ57b4Nh/VxpZH+MPLSbahMNQ6YgE5E1rVqY5rAwmQQC1q+qVqQ+N +9WioQlekEP62LQvhnQxXv0XFKG0J8Cagu2ihaldsUQpLIfbCVivtlRTSbnoAGgy/4FCsXXFoOnkC +atqKoNI2ht/YSoYts1rbVitxTbPixLccEtZc1qQ5bNuqRrWlfCIjqg/rhrhBHHB+BZywtU9lmias +iDYu9aXxK+CVK1EIuAYEwsqXjoWIj7IEgp9Y7AL46mXQQN/SdM8lP9bfRf8yli764rGJIm8j9qPo +OxK7WvR9jeMhkgu6x9nmoIt81JiWop+XOHVFPndxeotufuMCFPkKcJWKfJniUhb9WsbVLrrlTihR +ZDiR8KboESeiVtHjFvGvjT/aELG2dt7Ez32qAPPEKjEZbAbzxIZ1mdkZa1L3QuxwaBI2Vv3G0oE6 +G7cjd1+Rbz9u0GKyi4t8G3OrV/lXkRoUHTng7Ju4HyLNIF2pPGFKWJTyBPZ8QJyKnjol+tV9kyhc +0ZE4ksE67QGlg8Aj4yNiyboQ1WTq4gxgVYCQvtsFQVFF0NayA0BkroG0L6iseF+tElmPj2cHRP22 +TQBU4DHjqQKSdW6NrhWSdVYZu4LOOlf1vcWIXDMYkQxbdorrh42JafiNTgzmrgUKd3OH6Q2un15Z +ACGHNi2AJ30JCU9cQDNYysp0SylECqvdpNUGyZQhVsCyBJBCMo7A2e6/qSvTRtTyjVK/NiT8QxnS +9brHUaKx7zdZoutxj7Ed0nU/IM21q02/w7CdQtntK+Cd7iaXNp9bjfZnpSdHZfJNrJ2IG12PXOmk +TbTA6AmFTceR1ThBhlSl4je2CibSHT2nuRm4ParAQiBgdaJgJc+1hkuvNE7Pdqx7T9iJJdiUJJYy +NMWjiOTOOOUhEo5XhoWIj5Ewt/VqSLqbVUbWc4rvIoMSMVsosxJ0r2dG43XgDkSJrUvBxJ+we0Ku +B0eTPHN6G1fH08tzkELGax5vvtHDXpaPCFp5o20IGgY9IsNK59rrEVo3q+kpOz6Ixyf19DAfn/dj +hiDR7J5kj9mKMd8xZU3G3MuIu1Ey3WT8z5hFGvNQUzZrzIkpca4jq1brnLYRF9En0uWmjfweeAwT +6o5hBFkJWP5EVUh3TPeedMnajuEk6apynjRRt0TcEvlL1C9RyJ5AJiKaaGiisUMSrE/HI0775ODo +x4Pk6X70swgiv/nHNYSGt6ufbk/fXpyLVGJ8+1upRtbGBPxtBc+dfO4OfeOAAZnjvFkd/XTgq8Oy +FhIEQJEeimBqWWBs7CCrLkss9ODo6uCdNH90JOLCf3xE35rSCIUqD0OwTuYJEFkOo8PAIsurSl56 +9MRUtSxVidO+kY78cBpH1ygjBkFC5tkKWroIkHa5HDhwHAUKwXdj9cCx8ktmyB3WZdXq6W9qMITx +aKmkMamkDkHPkaaxmFGZyNAY5SgaI2dtDYIW9CSpg6/1sHH987EcNtYBzTpQOHSmdXoEC28IxHMy +OG1ZcL6VQoKbzvIklGHIROG0cSUYdOx30CAcNq5/PuZZ42qff1HVlR41pgV5lwkA/gNQhppl3GFl +9dwTrqBWmlDr+GxZcxu25AyxU8FxHWNvG/JCspnlCFOyUOJMk91eovtCB6TvNc8ai4U8PkivCv3Y +r7SwHi0GO5sN1MpUyn5B79gJcLXsVkU5i90s2O+Sm78M5DIxNjQkEJ6vhgxLyy+ErOtRU1vWUZWg +95j1yjptpwWjErCBA3e0R204aUTe445uGlRClHBYVSKJUDQ5aoSYlJRFBYMqHDWCU57HgWAZ5dfG +l9pQxMQCuFnX3JkeLQN1TWiqBCjxcfzZvWJhs+rKon6cTxGtOXZTy5ddD4jIZtV1kXi8ygaBgcoi +ZONshV5gHgTzdaq8X2Uzxdkk6ayFtVzF2eZk+7ZbDq6Ga3WaEmIJEeDUJrziiia06hc9wyrFC2KO +VyyTA4E4hSOkxy2+aVcd+hFBraKYqzscZlu+UrQnmrM33qziNug6i+5bv8r2CfaSI76ZtuZWck6f +02b0bVj1exG7tewA2M2m5kFC8pEmtN/voAlUPkSSAKJhW/ZQkEoPGzltVj1ZIeXRA5MQkCZB8FWi +TFhlUJmeeIG4JdqWCF+kewmHesqYqGdC2Y64krZ2tJdPxwcDBK4Uv7vS5GWlASvrq0iLBopBF5q4 +kXSTs4vcbFEhE0dQYJBej2AOEkKQdW0/L1FQqrOJKjiX3vbfjCdbSUFjs/UoxktWjJa0mKx5MUKK +Yow0xRSvihHmFWPMLKbIW4zxuxhvAKW71mR7pBhvo2K8z4rpVizGu7UYb+disOOtFhrSBH4CSkya +4U065ZSs1CRclMPapl4lClyQMrmeMhUT2qXHdNNTtyInf54tZxRSCXCRE9FKWYdEZMsQpddEgIuc +Ose3sXjRlY9NFHkbsR9F35HY1aLvqw6nyMcTh1zkY+asFP20xKkr8rmL81v0E5yfgWkJ+mPStXH6 +srPUVP2Z3x23HUpkZ3KHN0WPOBG1ih63Iv4VOQLK1PGU5edRM2Rkr0ZUrKL2qC4H3IZ2xpth96qM +Z+m2VZHvq7j3inzzORchgw1cZDs47vH+G1CBxkc2DAufSEXGq3X0pGPoOpJTTOhSxhh2xKv/KtG3 +jr8kgjRRVZGoILAolBmnqpjWcbFARtdCkO/puWKsNT07rGjtTWSXR+z08cEfREL4NueyayjrpQVh +GWo+SrONcUlNEiric90mTa2FFEmiLUKUi7BSNe8iTUQGeDQ7EUKyjePAZl9hNapWx9mMl7DpiLDi +YPZNY62ShzpEhNcNo/sk0VRIIWzM15h4gZRNo9ruUpWAMi9UuPFHXcfdIPyQjZ8HEyuotIJgI8de +mZAajrtPcFg1r5gT1es1xO4GGsqk+a18q3Pa2CZuWkEQqzPvqceolHfFugTfAxIBw+/+XSzel45t +5E3EjvT9iF3tehqHk48mjrkbcpqWblbS3OVTh3eqE4jzi9IVD8O4BK7j4bt1iqvJxbS6+bneY5TI +MCJiTfoi4dUE+TLcI4Y2rv8m4XBC4YTnGZpjUqvAenUvYNpFgF7ZOuOXyHb3L8aFUC8k3r5eaTmY +qCQoqdxsqr7zqoSwWd9V4W8UIkR1NPzJ/IwmcDDBJq7yYA3GyzRex+lSj7FhjC5TjBrhHHEydCg5 +xVpOnww6IfYI8bM9Md4vqWS3o1h5HfJtF5vvtuZw8zar4Qa32p8hEZjQCc5OU+fEJE2k7h5nV2mm +O6LE+v2AcnG94qGvC4b1dK4jgKqVbjIaCYyobf8FMKapMuLb6TA6pCLW8WSJoISViaYnvM3ofkLt +7nBIaF/kG6Lgjhg8nhy8O/iPfxz8g8qqH94e1Kvf/Hb1w/+aAr56Y1bfvJc/pRxUX73pVvmqfxgv +82CVMxQ6Q5ERlo1wcISkLDFC5DGij7cCyky2y3g7jTYcy6ALQXsUavaQGnB0uJnQDJQY05V7aBE+ +zenUlIiNCR1LjDpQjPo3IdwsNCXvkwNgzXRNj5LJYbNuZaan1uRYW4MBaw7I8QmacEw/nxy+0/N5 +fIprwelpP2EIxlxD6uCIu5hyIBM+JU3/mJ+Z8jxjzkhL6uoW3fKm5S/S+k+4Ppabcoc58zjY8txM +GXmY0I4JfUEJ9KOTpqQf6KiJ/azrKbWM229EUydUd0yZWWw8y5OFGB8CHNL4oBgfJOOzJhKV0Yk0 +PrJyHLyGHv+ba8R+CUWEJ45QRLjjUIaBNk/klMbLiX6lIrND5w+roAb8Fn4D8HuoHUwbADjgRCVk +3kQrushiMJfUh41ItYHfSJEA5UOlO8uUvhJxvi29i94IxpZQc7W+ciq6GZjWWqgXSxU1DaQoOYog +gUTxkEYT1YyJjCOysIdY0kBipSZAxUYMKwSnBp0SlgOZqarEAsMAVVn6A7m6hZa5PfSGz62BYVAO +PxlgqIiz2FUGn6h6vqKMzDLOKukzTUX/ijQFBeaggv5PpgATWaRZ4CTUFMzjLMCQRVFOxlhZVVFh +SESGChsQgEo1SxzQsZYJytXasmLn1LxA65aDFqiChEu2t6FJSMTpVhERUp9VBal+0cLqDSnbRy2R +8WWtpjNq2iieB8wBijr1x2i5KVA9PCDYILcbe0CZXvoksjC+Ma1Vu7R3mH3hNFyp4qzgt6pBKx/d +GESIddQBNVaRhlxnK3xE1WglZVs1tLpFsiEN1cD/RlYXEwiAScpQqgQSgE4AraoQIkj2rk3fWHjS +AKPLuo4obh3dDWp6xHAXYGPJWJPVX3FDto6J9NBGi76gdhVFTmkHCOrQspLwpoaHTkba3GHbqLiD +70xNapW+Q10+aq6IekXeoCutettIr3yr7BnFdXSbc5b6DUwVYcjmYysmEwAZpjV1P0XFmnksYKAt +Y+X6layHpVYB68G92XI3xH1dRs+yEuZNXepISoRCVnHtSxfxvHWRXIMiqTynZ4uUcsnRRlundlsR +vRlgYjFE1zpEZHfKQtg2WpVUOYQfXrsIbA8mfh39ibK9431qRZsFpUIx6Uobu1a3Omrvg0JMaKOB +sIqbrpTjPsnRCpNFhTmVY6QyHBRB9YKRdJJqWOdjc7BOdeR1QHsS/SWNLnIiHQl50VHyROuLjtin +A6FIJ4J6gNFbiriYcNhTOeQS8QYOCwEpo96C77PXsQZUUEenqcG5cwa78zpjc/NbNGNAGCzMx3Vz +aKGzM/RlcVNjM7wKap6MHiILnOJqQZtWEd+boKZnaV/21UpOZXdoZPP9cAUJ1FEr5OXEDVj6dSWb +Fn4OzQpuVIK7sjOPzjZt9Ghuo152nJeFDrIPqL2TNqOh/B9yvv/um9u7gc84pB31IIZ77+oMPvsf +r9+uPvx8+v58dUXH6P+Ur76W/w7s0Cd3JD2tYRGUxVzMJIBLXMomKBu8lFFQTnYxq0AZajGzIKU2 +YRek2AYMAwXQxSxDLLWQaZAeLmcbpNAmjAOLLWYduGDLmYev3mzEPnz1ZiMGAnL2chZChrYhEyHI +vykbQTl/E0ZCCm7GSlBPsBEzgT2+ETuBghswFFpsA5YCBTdiKlBwI7Yi6g42YCy0yeWshZbbhLnQ +A2YJe6F6m+UMBsTgTz0qoxi9ktmqo7pxbZX8uE1naBdio8Ex94bLyJSuvrs9vf7pfHnAjBxIgvCO +Pg1WqCtjZnAuQk/n1RHqhMZLX1f0rJKVawkKmEx62fDvCQ1WfJu+PtHABuz1VOeJGv5hgtaWWZet +5QiqkQ+ge8+oBO1aqqZUp/dUT2qtyJpLnSnyXsXXRd75WE3Xv5M0E4rg7OCJTFHXtZOD1J2ugycH +w2pKdGHYGirWrqQuATDt+JrxrZmGfJrS6+xtrKOvInahbyZ2gX+qNuutdikfUj8xaV76aSk6L8p+ +diaINMsl1Aa4hJat8Bhw0rQNnenLFXahhbZ2zKa7Fq67CijSA3jkFoTRwScUPstTjw== + + + UDm3hRMqYbkHg1YKYTDwGpbWjbBseBV8A86uhA9fCHQaFUZRRg6HUGICTMuyQ4RU6WnNg6AElqlz +gZ4FPL4wb8IqqCKTJPfkQPoY4HgNdKEXLBfA0AQPhp6OtFDnkYwJrQ9yTimoIXMC8g8dJ1dSOCg9 +afjjhMqaplaFYCOHg4JCTXVsrJQ4IUyFsn1smYjD3hSpf8QuPSbiIE4OOC7Lg11Hyo84+iLNBzGU +c1Rmr/u3qY5BFWynayb1pe+KTky16vvLUdmwygYV5yUbOadlxT+hyuYwzVI/0WmS+sXQOcoWjL1i +27Gj/ZrSecWTCY/rnsbbI0e5SvNyclAMXkeITger8JVupq4ZSA8CGXSFqFNMultMh1RMx92hTI86 +RXrbT2CR6uhnuUi40y+FYrIgab9exWRNi+m6F1PkKHLcKdbgVrEGBYspohZr0LlYg/XFms1RrNlD +xZqtVgx3ZOzeYON2s59t7yZfyKJHqmJKKoqEVxlBKdbQnYwunSSvGgE1OMc9HIYq/bxq2zoefFFk +FkkUngrayZpjbtRqoVOtc5h+6BxGS45+r1PdejKasVpdETbWNQ9Yf7TzXf4q9iOrITXUt5N6kfdG +X+Z9jjWkTp30MwAfqJJzKFtRz/LuRZyZvLTOy6SFQS+UEuGdbfueprb70UyHbLsDfDxPa6ZzOulr +lmawgLbNRlP0k7EGGxRT+r8bmsabZBafDFVgkwmhvWs4a1SFjKaWMvpw/gU0WaSv3kyXEh3jeITl +n2KACoAjTFFL5Li5NXinRuMhekKymGCxClOT+UhbIXtdDN9PcSBrs8gbXYMJ/TiK4UCm2z6bnGI4 +d0WcvLWv12BWt1QZAvZLOujdunGsHfHayenm7jqTqKowtU66QyhlSgozbQwOQFBvmw4DBik7kVhN +aSONp3NohbjAUumYUcOuvDHWdPKN4WGnFlU9MBprETSuurgTeGyqDtAClRucg3BTpS7RUw/TKSwa +KGg8wyVbBMrGgERab8vothoo3HbOmIgmxQ+6AbF/BToIJZry++hf0XfQIGwKwjqUnDWFOZieNT7f +qmaL/JMa3fED0RknB+klLdUI9CJRKWsGYsdKwSDV1Oh1U3NykLqjE9igX5hValzTNINJqrxtNdCH +iyHUD6r5qMDmkilhwlqq0IYPqJ3qP4DC1bVlnddTpEXMmivW9Kqbpazz3TRlYyzWTEU3UdmMda+1 +gEuw8fxrc2A8MjwarGY9RMoizV+Gu0WOvG1ysu5xvNsCJw9bSGxwzgdaSIwwIVLE0OHZTEUvuCkb +6AQdNOjQHHs4WTO8FawMiIIIYo10RuYjiKyofuw/XOFgk87WLNGoXn1N0dYctlDYBtti9wtDdHS2 +catHc1uVAvSGDrasNGA0N5I8ZuToKU3UgQ1pjZLuEbVRg8aI3qhxZERxtPiI5gA4oToC3ITukEwv +pTx0IxnTHtL2MfUR4BT/CRxTIBoNxjSI2v3x1uMRNKZDX71ZQ4mgr5/semjjJ9QIuvYJPYLX0IQi +6fnY0SRqvidUif5JE7pEZfeEMnHh1vRyHXXSg3xMn1TDPJ2mdTRKlcpjKqXQ6Tqto1QZnma0KkPp +jFpl2F8M0X9KsfLNNDni28+vNBU8Xf3x9vz8+pOSDIWUZUiYFN9BEO4fGBzkD+uKgy+dZ4IAxn5q +kqE2OI0gL6OhUUgRvcJdCOrTV8PyAq9Yp4VAn0qrof0B2QlE8qvqGIxZZ1mG+KhJhmpkWonvZQsb +r86cwoVxp1pnDDe5UASXcgwZDWS3arQw+Eidtq0f5hgi4CwGRoy+qVvL8DRSGlowYvi5F2yOGVRC +7Hxoak0VYejZCaNjqzE/Tv5hfJp6sAFU0agnBL8qNclQg8QYyAYQnG4BX8Myib/BpSRDQX2e9Rxg +aU0VULkQs1006jDrnE2OZq4q6cNnGG+k/WxW2m+aCgSjmQwAoezR46Flh2FyjHk3kDUFFidj1DE0 +VAxPsw6emJrwxmHRhP7WrVfLTICVqEYYbPRTNAhnJkZ0iYnQbyJNdOj0yAcAtGqsGvA8Eg4A86wL +McdQDW9RIKeNsTihoe2jLIPrnlOOodCobSW+jKWLvnhsosjbiP0o+o5oT4u+q3E0RPCqtHGuOeQi +HzNnpeinJU5dkc9dnN+in+C4AkW2BFylIl+muJJFt5RxrYtusRNCFBlGJKwperSJiFX0mBWxT38E +G3G2qUzMSBSio2flmhAR0SZUx2GtDSdcN2VMCBAjA9Fft8oGwG1l4zDjvuLe07wD3eaT7alO+cM9 +XOSbmBt98BVpQbSKMb6NBMOm1ah8zDBkvNNeCVnxq0h2oimvzhMMJcKUCFf6IlG2oiNtwA7XNhFf +KqvphRrjUiqd0CqW1TE6zyPBEnHReBOxs25jeiH430QcrjT9SssMTZFg5/mFQkwwJFMfTAdBHZob +KNaBhhgg2zdEmp7y76A36C+JVOwvMb5Ne4A0HQO3MYUZB16T3arTzPT5heLUYW41yQ8BmPy67Sbf +krL4lNyBtnKuYtOtIhW6LqZqqLFv89xCtW5kDfRoB9/UbfJ3rrxTqpemXjFPd1ObUUogsFvlpNTp +5iSSG03mIvQ8DEhyU/GbRLSxkdrBjtJ9lHZdPAz6jakBzY33+e7VPqRTxoR47FRpU2nqlo5SONLZ +ITXRDHnETtKbVdoEui1ofMdKN2gGdCtogHkgE0bS1jR6ntfxfG9TmQC0II00ekgyx4VS0XaVcExJ +LTl3xUMf6bF6cmcUO6wyap4ReiNkREl5UJy2TWRLgqJ0GXTcvqSrvLRfNx1Twg46jf+Cx7qOwej0 +hlr2GEfpObvMq8hpqOJUeebBcSXJm86lHo0lp7YFieFMazLC0ek6On/H5/P0CB+f8mM2YMgpWMXG +ATMx5jamDMmYZxkzNVO+J5HnRJ0TcU5Ud8pejTmwMYum2OciOlpNLmS85oAiUaAd2CfGsEsuFEkK +SU4Z4jMpkvKdJEgkWjGhgdLhRNYiVUtkL1G9RBl7wpiIZ6KdibiOqG98PB4z2HMsyW1QdYa3DT1A +KkG6mqmD4MfVrssuZJEYK1qS00MRTJC1hnQZrGsObRDaO7ElC1sZWmYOkr8V81fITKnFGGIkfggO ++wbmZVkRuO6U8L+UU3GSXYgSxNp8dpoTgEii2Zr8qkg5xo6Zz861KblgqDWfXdXls3Mxn108Kgxj +7TSfXQz/R9B9nSVFaN0wxxCfjzWhXUr955hjyKoEaZm7KsSMdl3eQadxgBoJw/xXLia0S/nrhimG +8Hwc09m5/Is8m10ds9n5Ved4dhzT2emQG6bAi5m+Yj47TQbWZYyMEaZ5NrsmZrOzq5gAcpzMrtUE +Q4YJLzX1WLNKZWMyuzbmNVvFtKgx2qI0KXOqTbnG3Crmsutyp8UkkZr/htnVOo8sy0x28bSxTcoe +FmKiRxeDU62v6yzymJnsXMxk18ZMdiZmsgsmlmFaQE0VF7QvrYmZ7HwYZbLjvCkmMs5KnVWHqexs +n8rueJDKrrRdst2uZJ7/VCtnLrt61bUfk5Z1HWQuO7vKxsBcdmHVj7JLZRfjrxsw2Ey7plG/eSq7 +ph3lsvOjXHYxvRBXjEi26hCKGOZ1xetVt+AZOnkTYhq7SrHLh1Eau1YRUXEpol3CpCyLnely2B0P +c9iVYZVQn71s2pjELo2j0Q1Vew3OJl3QJHbtKtuBMVg7bsBBCruYwa5apR2cprLf4ym1aCIDTGFX +pZTGVR8/3pGSLNMQISfMa8d0UBFCAlWmTMptR8N6EpbIXKJyiQ4mMphIZU8pEzVNxHRdYjtNN9Ro +HgC8H6aMds0wZXSTMufVlYbnZ31o6mxnxU5qtlSNDY7j0JSqmo6HQ9Wkq950c5HnG4oTyOStHF36 +ZrwIMctlyNapGC/lKG90EgczXChGyFKMkSmSrTbDt2KMksUYZ4sxUhdjrC9Gu6KY7ptivLWK0dYr +xluzGO/dYri1i+neLwbkodFTKUuF2aWLVhIDT5HjlC7akArVKTAYzq2RShVTOqaHddOTumJMCwfp +omHZOE7ponuKWowobpER42JMqIsMk1PxPF10aiPhct+RQbroKvTjKfIBxTEX2aA5K0U/LXHqinzu +4vwW/QQPzsPG9etU5AuVn6tVf/AX3WJHdOjP5mJ0fK86lCp6nBqmim4jstbOR9HUVrE43b2ZKbqJ +bWSJonVXRK1A1rPGh4xrKRLxLvLdFHdckW857dN42xbZvo07u/8m7v2OE+sIRMatjbNEh1VHaIoJ +NcpYw45k9V8lqtZxmB3py9hQTRRd96xqTBSdcoKzFSaKTvgfFEkYQu56vjgmivarYkTMi0TN95mG +9pmG9pmG9pmG9pmG7D7T0D7T0BhJ95mG9pmG9pmG9pmGtiXTEEIkk0PvwKW3gp0FDH5tGmQ3uOph +CPhULRIDPimPwGSiURYiWlGgsZTZ1PovGKTCbghWFdtMeAspJNgQLe5691dbOZP8QRTz5BRhWt3e +gRspZpleHucKb7kJsPh3rho1g/GZZqDWhTTWxrTPKaBbbwNAeK7rLkKyTJcPE1JZx0iQMq6NoYiM +iBRrVNNCuV29FGjEdGrGwPrHyDRZieSsEIPNfZ/2xKdU9lXsEz7n+YlwlpQ8v1IfsXBIvzh14olp +BVqpKyp9TERxRgdTbK3i7HCV1EfBRCN3FcoYcO3iNQVQJRCiQdwJos5JbRkT5OpX7WEb7QrJwBAO +26aNccqhtdEPqjUu0k/PDShj0vgiLGsdvPLGdYyMJoQOV5zC7BuZm5hCV3c9EjPEik2lGapgESxj +VgrP65Actk20yVf0M5Ep8eohAZuerhsjtNXE0/CmiVJD49VdlSaYkpfA1KaHwFNBpGuiYwRZqlts +X5EDTtWpMUcLXpKjY4c8DL2+7vtcMc7c5gOrY9h2N/g6uUem+YHGx8QLK+IUNtS2ux4UQDvixHO8 +jOGMqRjSkEoSzp5MAhe0Jax7SXbQ+9r1ANpVm3SrWfomJiSoyMXINFTlAA0FZGkrAciQaXEm+hox +jTEAaYNCU6V6eGtDaiZQqUgDAgAttGIm5sHWlNFeu5YljK5iiv8Y2K6JLbJs0UFNvqorSl+UvNdj +pa4VmuW/Sum/9ToZp56alr4tmuTfRHcykqs66u87AA2/0RMkgpAimumbQeKR5CEl+icARBO4U5XJ ++lfiYHGkb3F0Md8/iVLKx3/GhP/quJRl/DfqKrkmP/TZQTFImh6T/vsmq2GUh1ozDqErLpkd66A5 +0ZvogcPOjnJec0TFZNjMnm2izVOJPaZvMFckK9YmUqNfBRjSqqZfBuT0bqo4XcRzJWNMgKGrqfp4 +V8a7Am0Vxf8Q0rMSTOdc/oFSd2JU0+X/z7Guu8iEqEoHY2oeY1oLpnMZZUWP+Z7oJa+K9fwSAPVg +i/nVY/L17oe6WXbJ17N7AGrVlGYXAcTr/chsnR0MOhPTsaPDVjuc3wWw6pLMnx1krA== + + + ZbqGxU6z1cdE6kyt3pjUnKyM0cz3dSRXvtFFlmWMpFt5BEGXJg7PJk/4PkV6xLJ0J0qH8V3G/rN4 +KwAnf3gtAFDcqMt6d1FAWZI8nB30IJfON+QCqeBZgEO81J2gtzccKkekmrLSM4S9TYxMxzcF6ND9 +aspJPZRDq4z+EtM4fFlHmK01Dh/Jc7Djgy1L9ls4ctwI8sPVQd1ojpXxhwJHgp305dHZzCqP7q3S +1AZOoC6rsgvjWBO5MWUoM+gyljKKXMuZSpWhNmErtclNGEstuQlrGcXYxcxlFNs2YC9RciMGU2Mi +NmAxNcRiEyaTCoWN2EwGhixnNGMA53JWE2PckNlEeqnl7CZCSTdgOL96sxHLCYl6A6aTcUXL2U7G +KC1lPKXQBqynllrKfLKDC9lP6uqWMaAIttqABcUab8CEAqOWs6HA3oWMKLOibcCKUnG0CTNKYrAR +O0oCtBFDGgPEl7GkSmKXMqVK0TdhS/UU2YQx1VC4TVhTPZ83YE41Pdkm7Kk2uQmDGtNrLmdRNevA +ciZV+aXlbKqW24RRHSkK2y7y/zvYqjRTZRr6lZrTNBip1li0xuqdiYHnunVKRDs+TrpKUluAs0Jo +JPquTBA8mNUjWf1wS96RyuFgLJoDErn81N9ReSibrtGLZCGbc2CHV49+V+IaX+w7ujs47D/Vqg4H +dLwJny4HrzHxClVhT3TXBFM5ONcipawgMWi/BmmzwfG3Teg/OzqbXePR/TX6ViZeaFFe7f2s+pqV +jerlJWvLPBMbrC5tcMvXV4ptssIPIDhZbZMx1ldM21CajPsWoqZMeOTPkQfSDJl42+W8RC7heGdp +iPHALV0xbbpgDdxOa9V5NhJeq8YTADQ3qfB4td5QSglFKb5Ga/RXwDEsPbt1kISU9LYa0Nv+srbB +BZ0Z3SZVrwbkXX6RYSQIywEAA9EhbGD1GdxcR2/CuuEVlPKtiV7eZJgpmLhoCYGYN5nvjeTkBkET +UVStD5kPRQbdItYF+I8dgg4hjXTQTg4/5eZLXx2dza3v6L76Kqu+mYNK7997a5BOI/WXop2mEl6M +eNxGS1GP1GE58ml2msXox0lajoAsthwFHyAQnZoAGcagn7jqE24FBpMrS0l1QxOJUlJKMOCpSvox +D0eKCiqBKjGTBgBfNTGerwUHjGEiJYf6W4GLliExIQWfMXIpY1LDZFjSpZSpIYoFPVNDxieQ1XQ9 +f9TGLNpn/Y2UwwspQ70asFmhWg01hSV0AXSz1GqZ1ckeRhlUKDOiYiBNYYDqC8Zs1Ej5m+RWryIh +c3NMJnsj6iCNVG3d6h6FfoKCdBDmmUJXEBQT8VRwBMdzA0HRjb/FPkYmpf5b5JWfW+/RvfXKrtHk +w4OKH1KoTbAvy3G1AP+01GIM1GJLcTA1thALlb1fioex1DJM1JldiosPkQlS6VpT0jtDd1hQRfgO +QvPm6uQ8jaiUOukFgWUMY2khP6vjoyXxr+UQMDGwFi68OA2SLrG/XrhOJglqv4AGlCbZmVbTXlBX +wFTXGn4YYnQFtB5B4xtVdAHXyOgKCK3BrCZD2nAz1vBu5z6QmaSrvAiELQcu+8HB153pjJinvxp/ +astWv+i/5VacVevRfbUiHpETMqj1gX04XV4FLl1glbcXL3FqbOEia7HFy7wWz5G1Sbb+vXmbPlse +mQ+/nN/9VoNCNfHmdwcIgxbCRjnWCwluKQm3CLfuksuczs/ObWuEEcqcNEgNyxNdKGUjC+egEY3y +ta0RL2JgPlF1U1k3vgOQfSf7kSDMNGlxaiQIaxWOLdUqz0yDHts9xinBLO4V3TI1j/ca0LC7J8TT +bxnkD0UJNfeO8a4JYlWHD46p1VTVGttDjVfVPTPmn7cXd180oxqaYRsakWc1joszdtJDoD2zbEVv +fG/0i9RqelbZAv3qvvCjGvywjePJWDEHjoKfzcbfQWLvpZDxdT9e4QT1fTf+GnkfSt9B6lEN9agN +eLsqpB9/B4m9T3Wm0aVW+/GnfiWIG9XgRm0cT8aK8Rfjzl1loNj/Ap0BO58GWEznoEB3qgxNivE8 +FuPmNThvNA/FeBhdxWmcxXQqug5234ynsxjP+PF05JwO4uFgNhIkDYOY2WSTQdQczIWiZsg+8aM6 +/KAVPbIBySYiQdIIUqXdGGO72TSkrvWfNKM6mkErx5PxRs9oBAHRXgJFiRf56YppGkuvKpqUGRF3 +eehNFBQKNU8oEx7LMnq1cXUQDAe3nquThcKE22t5OXlXE+7wMVDEh3iDRdHAmtEGDdipyVLKy9oF +TTbsyuEjc2yYHlagnQbRVDY+1PEN8M/i1qkSvOEJn2xM1NfV4+JrtJN+E3HVCOiy0oehCtiGwpRD +Q+yhkqJnb2tq4vFwSo9BfbLOX8EXyQQdexpPSfbSNCxV80YGxOAxAyMqbmgMNC2Ts7ooSJcMQc96 +d3yQ9f7kQMdWd5Bs3NmESKFssk4O8nlMNXQ9zQeCgcVjF3byljnUBL/IB19hoiyde5G0wsbDCXlk +kO4DrBWlauA6NdMRUDIY1VddqWNNyRwNRtZx0yCyzNICWuHuALfqATUSRjSrvlCjyfRi8AW9AaJd +hYmcW0hjghJIUMR87GqO7gCNpnRJZY6zsQqf5oLm9A5yljP7gOw4OkD0EEhuVLpM5ug4ns24x0oj +/mpoH5yms5M9rzFFBOG+B69CDQ57ZJfJQB75IdpavbYSEAINM212dZkuEC41mCB03PJMHNx/5YX3 +w3VOfU0dJGuwg3X96mpKfR+P7yzFZdx3qcvRzc0lb3Vxfz29uzu/vf799emPl+d//Hjx9vyDXupi ++6tfuo/+/f7m9u7vv76P974IPsnaemjGSmWrvVNN+O/+dn56+efTu9uLf8t3g0ra7y8vzs6/Pzu9 +vLj+6Y+3F2//3/NfY3XTFv8mzOiHu9tTdL9vdzEX+/Hy8vxuVayOTs9++dfp7VvNh7jwFhnDePsq +Jly2iCrlM73YVwkUn3wKHcQZFZPVVquuYDH8vDA+/gJzFX9y92QfDWvoymkI1oqtDHoy+DJ1/rgf +x/zLS1bwXyiRqUgmS6gmbriaps6VsxIOBRTt0gO0u5WIdaGGVNR+9itLdLJW1ATHLGkY8EozdTKr +VDdJaYpW6V0qo6+s6yanS0ysL4usTKEfc3H7pe3bK/KOxGXtFnWVri9QFxRikv6KGY75m//1T7E1 +v4qNUTSs4hfxg8iVr1QCiC/Sl1oUZD52uKu/ayT24vig686GcV2s6ir+6ppQsO0s3Ph5mXKkruKQ +885Eey37e9n97oed3hWxzvgTn3bvuyLx27Ouf5cjkbr2XTDGf8R4jE7UXf3ErCTqOaILxpgRPMV7 +MwwjWdQnRG/wAjCavhWQMifw1i0fc2HzIZVPP/oibCY+HqdOxGe9+8X0H4yq65tigGPqxMnBuIup +mkJZ1zTOdHAikYWnlZnnNK9rxF/kYOErm+6eBotnUwJ5fmhjfHzbdmW756ROZ7CMSZec6FP6ti9k +VqmFgu0ZBVLWjfcXsvFB03HsOt0PaMqEixBpntnB25KEqHLVmrtT431QZXQVY+Y9z2wPq/iGmqzK +cN2CZTo1T1Va0X/gqpgL86GildOrLY/ONm71aHGruFOqRpriXvO2ngI8nC1cNhBowrfqyNXvm+Qf +mXaOJlOeu3eSgjjunuxx7v7putPtIF4yOnMP0drW76Ls8bF9pDfrlT2tqeJERYJpOoL54BZL0xc3 +mXqpztpmydem7fq+ZKtF0mpS8vOHt1saz8n9wxacMmMoLf++J7DriatdDQGRiIAf8IG+wXoVgaOX +w2H06GmYRAXip6Fxpux+wc48fMfCTdsVzuuGgjHR0KwneY9ixx90YYHFg5e/gdjAvxGZC++lNZZX +HzOtK8XTfNfCut1obsSMxDAm85A5ZdeVgAOLbducssxs42huG2D1kCAwoyOferPkPzpe/+OQWy9M +vEbTHGofrg4a3hRNf+aqCTU2egIZOkmna6wG5e49IazjotWhRJ7DeESIRAvd/UNHBBiPKuYeps9h +/yqYulIfXCHXlXqsj1bQQ5vTPlbYxUtnh8fEwpaPNmgZZtMKgbjZUQFeXogDpO5SJHyRVxv8KMuG +PHwdGluRq5d+V4CYPmWk8Pc1mHkG7uraGV/J51cdCApA31Tx9hLeBG24tKMSicGWY1BfQEMGtc/V +gd4B3RXU91AkGmoqJiXWgh4Sq3/Dq1tlwPVvV7/7XkTf659Wvzk6+ubs7OPV327uKMNmWD05OvVE +WNNzDezu+t5/0/d+TblEhNf09Hf58+p3f7m5+9v52c3tW8H8/2RH1HJY8Z4R6B59MPB+sRO5/vib +P/0x7pW/v7u5vdJXcZSyud/e/Hj+5ps/tW+kE9/f/Xp5/qZvWr9aOGvZ4REeMnR9Ph3Hkyslvr35 +1wYXNHyZ6gjHDLgu+Kqlys5WpefVPgbeSHWYEmXPDJx2lVLg8qFQQ3NTk2cO6jGx103sdRNbp5to +6sgixyQRA+nrszPNloxczhdXVPqlX0OeuVJnwcgzs+znZ5nBnTgDR6LENPsGZ95DTLNrkEzR3MPR +IgzQhDHPha1xX5EqqLPHkG2e1crR7FYggNMI8PkY5zXscq1eJzG3Mo1IMWFlgp3kMAOjZrwCWIMt +1oG6kmwgxpFGUBdLgWu4yzpd4Tvsx2P8dyNTJAR4pey3Yc7EB9hves45+jxYJeE9FxsC2uZ8I8S2 +GjHf8HvHCfFw0cbx/u2zjds8WtwmjilnPz/T7VJaIyS+gW37KgPJUuvyZKAygnx3xVgHglilF8p0 +oHz5S9eky+pFnHL5ZzDyxlvDehgafQBWTWFxCCfTUaXTre81bzeu9A5h25Vv9OO8P1078E0cgvLR +NfHie/nI2MFX2UxNQV2Ta0APSxsRTcpPkTYmXbsaALueMA53MksDaDc2DZqzY+CauWLY5ni21nTq +00SZAjTCVK0PGgYrvYMIWddPIs0sWpXsnG9eiTTzh5vbvYV1b2HdSzF7KWZvYd1bWPcW1r2FdW9h +3VtY9xbW3bSwTuypVwdT42mxxsS6xhD7rDZWozdz3GtjBddrHyvrEClWVotMrJOGj5Y3/FQW1mKN +iTW3pxZr7K332liLdUbWqWkyN11Oi6yHPb2ZdV3nmREqM7OuGcy6gp9HO1EF3F9p9rbWJ9VOnJy/ +u9vbWve21r2WYq+l2Nta97bWJ7S14nIfZjG6Oij1CkDNOCjyiKHpKMGStfWErFiM8B2DkrE1K7gG +1Feftf+5jasGgXcIhW2tEujeWNmizaB2TiYXGtpWEcCGG7sfLNrQvDQyri5p82hxmziWvBem+TOz +2yXvdIRGiSZPZ4kLCZZMZycZLJkyAasmMNxz2Li1oGTwzArmoPJeUDK2ZaDUWcUiBuGWg172H6Sb +B1Nfac8rW5LJuMXKvE/pfQbqO4DctI1bBxnMVbVm/sbtr4c9KFZ8Dqli2jlKFdNR9A== + + + wH6wWfG1wH4camHtZjdvN/9o3VRtKqoUiRYgrVktWB9gh3oCEWVDCeXV2E//dvHTz3sRZS+i7EWU +vYiyF1H2IspTiih6eWiSI2KIjK1yaaMDZTJJKrgO1Esg9Pd0KoCk17l8Mmz8GYWUoAO6T0hBep3K +PVK0sZrGZLaUMml07AH6eKNPJaXQvTKuXRRSaOLxNq0dX+dSgUJ6LjVBevmCvnsjCJa88utAmUCT +Cg5B5X2gnrOdDKOzU6Qac+EkgvLi5jDlYJnABiOtJmMnpOe8Wcr5NHvDxteCnlwwmQw4RZWNh5xB +cyFkOuwelosc+dCzVoeiy2Tu7xVKvnhp4B/v96LAXhTYiwJ7UWAvCuxFgacTBRIbTm6/9ikwjCBk +LLZ93BZ88XqQRnV4vTjblzasYhSYyT9LgsIaSGzwZNqHpwwK4+09Ax5bBqbcORKrr4kJC4+UbJD4 +s3kgJuyxJqchYY80iePJDlLWfx5xoAvU0TQZnUDQ4BARgC5g4t56SOLO10GqMYSRf3HZVRxYB+rK +ZaBUeZF40QyUAtAy0HQ0nVwweJWCwVJEUtZ239AU1MUydfMxhXTFWHdezbQH9wAfFBAE87wRtueT +BITxIK8GwCxkazrQDNYNLYZ2DSBrRxajxYZTvqY/n+JlVWg+C9zHysSuRvpKh+3mKSwYi5bjNcks +d3cyECFRq+9uT69/Ot8oBAzWX9zqAR/peBA1wg4hE34CFaE6DNbbFZLoelyIlQAl0qWmh6J7nSoo +uhpSKx3k+ICgJgOdHLCc7SGTmvN2x52KhVPZVH3f4GSo9553JtTK7UBjVnfcTllVDx54hXAatcF1 +o6ap5MjgocB3uCWpDI1eOiQciTkMpqxGfA/S5uvlgQ+Xhscz0qePYikWtn20SdtgjOQ/Pz4CbVP6 +wFOttSUOT9N475NazeEHqI/XiwtEKNO7/HAoMg9RhwoucUOympb3rSSQLLeLuOB59W4ClLK06Xd6 +l0qnwh0yxOccGVzHD7FU1YOKcbVF3mYx6VFXQdfpDO+7lieD7VIoZRsi8YT5vsm6GXgJYoIVCEVk +T4KgLNMBJIh2ND7gLe+ZSjV0FWQ7Y9TLvt1xoXGteZOTDk36PBns8XT894mXvUvxqNs8QieDmww/ +76kU6B9P8sd+MqcTPlmW47w72QC+erNmVAIc1zhpdNjHYRfHAxqPeLx2x1k38l5M5u9eYC4GV269 +jJ9Onrrm1VHIGl8iX7nsZY+UCmqYiG/Ty5PJ5/cS5dZGCTS41q+6sAUvVa+JbWNW98ZUvJbG4CKk +JufpyzYcOgT6CFOP26kGMqisC/JNaDTUg2VDpVd3Czlc3ODRJg2W8VLIEf39RPWYsGm81dzFJPmy +ZO4wxhadpLfp5cnk80TA6lrh1SGz5F8lQHwWElJltQ4/XgN4+piESYdln2Rd7D7oujQp8gWEIlR+ +/X7/XBceKRdrP5GLFXbCGVy2kxjYygU8gZzzTTjErXauByjvGh+K7nUqW6BwqhYPckBlT8qspg8n +1eSNjHuQ9S7r9vFgEI+ypkIDedN4ZE2dMGD1w1F3uOUDdzWbRviV2oYhh1fDklprBBZu2xzG+PpG +gLxj6+HCAeRpEou3rOWjTVoWYnfYNJ+bLe3Wu6JxB+xdE1x8RttxzfVa3wSIDJDVNdd3qShLdutc +qdll8Bz50O7jYlxVkbdTTHpRDHtZDAdxPBpUx3v2qK12rCEgcp16wUbNXjWx3fbQGF5cniDarfiA +t7y0NBXX0j2mD/oU2xp8O64pb2bSiWEnh2M4PhiP6THuMu9Vx1r2g8h7xrti866BkeweT/LHfsZG +UzrubtaF1GM5n6aQQS2TVoadGvZpPILB+EZr1DfdtVzMgAw4xyq7MTLbg/f+0H8ZRtkNG3d7N8xU +CxCTFkWQIE44bF2bgYQ/4+1aiKmk7izUelERQ2l9G3cq7tDBjZvke7vtBWsKQmK7LcZ+ed4ZP9h2 +lQo48R5wvby+750+Hx8MdiJA2U5PoGJSb7Gu9WLSx2IyjGI61ILTgbs903QUmDFfZvM6nWkkzlh3 +JeSaJYk4MlwUAW6wLJRyNlgYLbdwaQajSYuj+32T5VEhcoMFQsHNlmi00erIobVj2aw91KuorAa0 +C4uOEzuYDlI1moG4ho5Jqk7PYGTS74IvZT5S4UJLN6tUfwc4O2iEEniTgYTFbXEPd1dLApBXir9T +86l06t54AMeTIc1PAQVjZovelwj91kHKWoTWruGkoDbDrY6aCio+FMGU/hC5BISzK/W+8d514bNI +Zt2EGs2CcoUJpfmqA8mc+TihroHTTwLwiIy/07tUOhXupi8+HwMjcN1dBxHhxClGaA3pGbWn313T +qXAxrr/oG4jCYoYqcWQ1rmxnFrsIEoRL1es9cQnAtpvUL32XSqfCGWLEhmXsAc5+CRJsmhutIT1z +3mw3qfoyFS7G9Rd9AxPQ/TzGwB+ib/gqexq3rJXa0cD0bvrh4O1qPDn9xOHrybxOZn4yEhSbTMFk +kvqBjG/RrZru7I/uEyJJ6w2KwoeWOB6I2j7gtseOmJ50n+Er2+aQruDnSXQBqxUlhHi3sCs7Jbgq +YYQUmaZWBU4DoWGkMpIzgpqshwuD57KmiSqjhS0ebdJiyRwhnz21BW17ugy4VZwsWaX3P0etEV+n +tyfTApneqIkvWldXVjVHjZZWyAlwo697XGAt6Fn0R32jTRlZoNjRHIn7T9m90g9gXfEvQJvUJbZo +P68a6Q+n/7y5vbiL2qP/SDLG57w3G5eZ49rmwsGvqoK5QfjCmreJJhDknhp0EwAY1JC9rIXyw4EV +rFp1ygw1VE221Ss+cSep8erM2QbHK7U1m5XV5+ODBGmRw0YdO5DhCF6WsqlwG6iUlRe8PJoWOkU/ +3Laa+qZupxasb/cRa2marhZeM5sa0Wtmu16c6B21hteBx54WHAwhcTC8lxfNZiOmaFrz0tE4LQVn +zlX9zBWcXhwmWX+bdBdv95W0K7waHCx5u26VjRMZfmqoCHBfdLzeM32FipA6pl+o8WIedz6X8YWM +LK0yEvZ424MCbCmhYovc047twq/OIPHeMUm70QmRacMHzob0AR1Hw2EQ1AypDr1lhVeTuvGEJMix ++geGss2/qukGRQCvhxWA3mzspNVWkxnKaW6M+iOXoaYXJJKXAoLp43zqYV8HzX+IR1qU60rdSQ8N +rMIy297KqFQmamRSVzjCKpMjHNhjdpef+PgJrgT3muSItYBtxp22itbakl6NG1G/DlSEsqum6yo9 +QKH560fDEXuTD5mz4vtZwbw1TTZvk2U+nq78/e6tT+wxUmEOeM+r/HUrj6uAed2r9VZFkO267vV/ +nF/SbZ5k99snIL3Y2bbRa5Jq+koZSByhpR9nQD7eQ71kGRSr5P+hJsmAxbhEMa4UNwZXijZAWNx4 +nQDdcyrTF0nVplpTm+wHu5FBRh9Pahs1N+7OtMfv4MZdYr+nv1eaVxW5/kDkZWMK20WRk6ijnc5A +xfjzYlyjfE/nEvk+4HQj2YiAooPwa9K4vliquujqTg0X7EzB3gBmuTDNalIi1ZZVO2l73LvpALiP +EfRQO6WQ3rk63nZVchJkq8Fjyad8+kFoAfU3PDcyCO+HjpkYEwzXuwdkkEY9coySdrb0faTqqK51 +Ouxh6Z16foj4ZflDzf6ywnVj9JUw44GXxztYOY55pb0jwYMKSThn9YdUgRsOA5wfB5VEzaxx8OmG +T0/KI4eUFY4u8IVFDmurJmpdCNN9RY4OzL7F4WZ7yNmB4dlkepDIea0mKUUIXgPrMNZQzzEdroO3 +omsIIW8h01Yy4qONC94BAo4HmZizgw4kK1PVNWLX4jiFJlKLZ8A8WToMQIhwekN4U7Ytrq4XwbQO +vDUd52TgDeGl1MPpMKWpeCE77u6W7ccrwgNDT6AC8tbw4nHnPduB73yj7cCd/hAOl5xEkV8qFMLZ +wnMHhBn3oMunVf8ke73CWI4PMlAIvlG/XJmbZggIlNQPVT0oG4ETK4tPg7T0q7YI7wsRDX1ccFxl +juWSCSKvZJjRlH5xuJ0dKOyiCN9Lm4e+sTW1QE2rF5zLyQ2ATCDcjjENbfBoBzjqSo6ybuDsQBSt +iaKYUNcDQpx0FlIQWqiF8YLLaaWpWF0rJ/1kM2KTgi8I5JTQ09oadYsHa2A7ELippmqZJNDBBtoD +sDBl0CWKIJkFoFNXiexLr8xKailChK4IWsIFPEE8wmlBtLWO7rFrpYPEjnQVpJ5OhnNGXfqz3BFP ++/IWsgo3V+eRVTBPwio4H7X7ggImBKiV5LQUplszKLeyFxgFE0GuVJPXCVD2XhA42rK2yVmcUr36 +TDqyx2xUUdOWgQwzTAcrftEqoDqsbODeE5m/bXIYa2JwDgDtGoCWAkDqRfxLX/NkwCcp03mpZW3N +yq7kAFRDQwScdICm72YAywmfsimoK1aw5hDWQOBFzvxFelWLThQY9oY2ldSl7LNRLx9W23y+TSLH +ay0sfiVHMg4Ojz2u+ZJbU7dbuHG+u/1xVayOLj9y+5ikRTVztwVlJXKepMdXHcTZQyWVQS/uocMz +CXKRgQp+XvWfd4BUI07TBBKU1KM/VmARYWQQO5R+nR2M33U9jIXHPT6bYdhx7rfxAwRCGA93EfyL +4FQyKw4HbuVWcn4jqAf6Euh+2ZZVegke1Qs94kUflEZx20cjvXUii/XmnU3UdDP79Pn1dVGLaSDG +DqfRPjaNUz25DH7o9ElcHOChkKnWusD4HuHukPQtgUQYOySng3TNLbAkAYRpa8m6ApU6mFA+owGz +rAYiGc6K9IOIZEqqcghgybov2T93tSdQ6kGqIXWx7/9xNpZZlkXoNzXsxnuaf4VtdnrJjHDZzZr4 +AaHfRv5R3EsPvGRGSBO8fE2QQ0CYpmlUdLCNo+XQl2BZpdkqYMv0nhS0KhpQODlTZZfVrZ6lvD8B +smIDq6WLzzIvVeBUSd1QM/WAOHfHBwlENqhqVqkGCGFNmjv+OubFGW3dhA5UsHTVl+4AWQsZLHaj +q0e7mbqfVHZ4riOqWd4nkRMs4IFMYZVDsrYiDAoivTgg1uHAK3M86dexkqyqf5dIVCqcnvPp6kCx +F6mOQgNLXK3aQioKN4umnrR6lQFT18Zd74elwdajUU/nZTJ5LDed5HwNdFyMvM5GPZmSyQDGxsOm +v1QB8kzdUxoIc5YGbUeDJdzNe5iw3dDM0luXQS2d1hle1pA6EkAPOyH72TcWPtA2qyUBUlNnBx0I +gmfjU2w1qkHotqHgmdrqIJRPtEP9V12n+6omY5tzBBr/EPGGOBZJjf4seLtB62yt3uV6S0tHaDDd +IZtuA+mSkV0i3ZY+XfMdYV6FLbDNxrron6KR54fJUEmA6s3IBmcfNSKVhiqrpwPExs4OMlh300dX +UZtUGqm1CFBNVOxS91HX666i8dg+fbrlnBHqX+mEpwdNhFqLEBwsNNalXk8ZZ1xDag== + + + YeYXtqdi/EQHahGG1ai1OKUIUtUZtEwuVB1AZwriVPZNjIPva4mA1NLZQQcSKb2KPrtaC5Lbli5r +KQF0ctmb/pvY376W0Zg+fWahDkHgh+YSiQ/IJQJ1B+LcSqh5qhyXW7gSlXoxjwZZdxBsWivMRUOC +pBhHTZuP8fMdALowF93HIkj2aRuMKkFjPRkoNkYtVQfz1H6suqpE+KlaF/rmEgDa0dilBOqHEWsZ +j+vTJ7cSGRNX23Fy0wNYEjARvJRJmHI0lROKjP+THd1oHFxJ76irHtLGmBEh9VS4FgyZC0AwVTh1 +AMw0JsP1IAPxGnJ2qqUDxIa4Oh0ECsNVVwnSJfBqpNRQAkDzEzuTQPkAWMt4RJ+BEsO/zydaHB8K +TXQGUZ8XXzmXSxyFIJy3IHU4Y2oNn+9giNGkXyGU2m1JdbFRHjrQ58v1EMHGVqguNWHdVwbqKvCC +XU0dJLWHzZ5gQsKcDVyMWBNUv6Q0XXsJcnbQ96r7qut5V9NkfJ+DAuMMrRMF1gdQYKd+cLw1xoP5 +v/fQcyKg1oYKFlO2FGoSCHp8q3bMumqpo+TJAfMjQnTTM7ax6vATRF04fV9FB+iaOTvoYQa3HLlV +qkX1LepvwIY6wNlB6ksH6vofK5mM5zMgs8yhicdc/I1UKkEOVIdjzlh4mOfEmELjiGggY5lfUR3g +aciSEzO0NfXK1KRb2BTaGBSMk0bIkLKfmFZICse4s5N+mJ1B3TbJPx6OTUJJBdAkEsEI8jO4ZCjH +ARNwwwxrmhinjYYPC30y1kgK6j6QpajBqxqmHPHqFAdLDO4Z4q23Isy7UDfQbDFIkAZJz4wrvGyK +rMChUyV+9Nai+bDhB1QcH/Pwd60aC9O2ZugZ4QEWkuG8nd0bOlSpO1zZ0t0Ls8hcHmULY5zMmnMa +YFmnPwDSDRPGCLh+1hYpf5oYXMSsO3VMv9OESIaD1X3AoFc58CoIc7rPXFtpZJEX1JCZhHVFfolo +WK0p29QBV/85OHo3/rCsW03/iIlI3he+bNt5zcJ1DmsVKrVKiIRu15asgUDOa7B7G5QyzOsx1UT0 +XxYCI1x/8O1jKYQe8+tatCxPc71y08ga+Jl+cknDtE6t9CACPqxnohmrpxVC9RzMZgXcGFtsTXrp +tD6ooV8DmKkzr6ioL7G5anidUNkhRBen+rFUVGt8EkA4BerkluNgecRzq2ZAPMNj5gxkyajrkkhQ +sKvy8m3llWkZgkG7JhOImyRIYHHyMLWAHHFkkSs4gmPjh+hRhd6SfAgliAxjStZpsePryJ5giCQf +QVmYGqUBQFKH4wNSB3CFNjrFJIYIGhcpMp25zegFQhDrlijZtjX/Uk4oYdcUAtrUuAgCiicjB1aF +UiGSDdjTyIDVpNC0H9b08kJeDtvayGq2hqymx1eyy0A3RNauIMjRJBPkG9lnfk1508Bnpm2g0DAg +lJDrjpR7adR4I9MMY8m8tkEBKmRLokkTBALpUdYUlV3Pw5eydOu9Eo+53Y6yeK06P3qRfhr52GiV +nsZbFBjc2JenIk2uzZDt1NhonG5VW11pkiUczK5RsYvHOT0fDR3lNIEK3EBIZ+gtdxhaQ6cEJlzi +V5ro0TE3g14wyTvtCkf+l2oJC20G7YSNipKmVhdGuGAG6Jzg+E3RR8hPCI2a1gU56VlKX3t0ENwz +DOm85BXbS/ieJHOfgSUKTjhu8DuUvZA5UFkX+hLgGb0Haw9cOIbZUU5bTSlIHYLVkmA3m0odCAYz +tzERqWB1A1q6hgebMU7dA2XryMBLaM0xVmnskCKBCqj+MOrWYPSku0LpQtAsG0YVASJVBOpYDFIr +1HTXlyPdwrhMnaB3cGJt15S2Mm+luu0YJ0etSOUN/edh/HJ1klrLdl7DR3RXK+E3L99XXm8mGZdD +WINvEVRReshBLDavv8JqlzCxkmlpGar2yXRj8cI8ydUkIiuVpnxpqjHM4a6GcarK4MnCXH11aJUh +bYKjnFLLHqQIRlUu9pNtVXtGXbJuMVOpg5i6VIFjZcWVSjkAeK+FWojclO0s/XWYxSnw5iA1qsFf +jl5fNGjX+gmdBlXXGpWeQbMcFmQpgvKwqg2R1ugkBqmQF2CdkazRo0AQDvpnw68MPRA9PXu1nFpy +fAxAV3JIEYWeZ6o26cwrjd7hOZ3HTeWW4MgS623g8W+ECp56BmCCV0MeeJ74ZEIqMAVOlRaCySTU +xtOhXqbdqJrWgwzLaslWboWdaDVLjBCDmpl3ZK4CBFG9U2xUGjcBHdKDL4QSv5zmqgQz6hrGXlkZ +0Lqi6xo+0rPJurpRby3j7NqisjNTnhn0TXmXeV3WW3DbCjSI02LMJ4svS1fnaZgPV8Ob8GXJCLzE +1CPRqgsPHZMqMhY48mUHa+gpYiX0fOeuh5c7xBg1P5K8yGnMW3KDUI6Kz2rdivoWyMVwcxJ6UUNh +S32U96qnok5EIzMcffla3alO38Bv05d0EQVzYqIBi7HODt6SpW7ZqHFuDqPDH2CRCDaKQ4C0ldGv +nMaIlAgzofev0qZjOsWqikvO1rKWUUBVBM9/UJG68lTGDCduY2bD0+fxUGPRD2GXEWKETOC2Fn5b +FWkyCdKu86FXcrRIriUEw8LbC14FcFYDla6cagzAR1kfhX4ckD/QGO1xTkMU822Mwp0Urh04PuhK +qxqmi8bXScfRgio5yPq4p2JOq0dqKrKVobhnS2PWFRQCAKFX1XJUsB3N7a5QCMFSKBFpAijbMnw6 +p7FsVZ6CQMCbuWzcC/MZoO9MCFCY7IIYeN020UO9qqLWsmpi7FalvroiPbbqTGHhOkWf8UqdYwHD +0e+R4cbqR9RAw42ZX+sndRtVDi3Oa2xGpjQ0TfRlhWmrJTVAbD510vJpdMBmuE3QnHHKw5R6Yx0I +BB3c5bAhVbNwkG+jL7pI2XCbBcFoafhGagTmYFYnZEs1jSMABsZjmC1Kchl0FyyjsRce36BkpDrj +SdyYr2CuwFJ9PPGnpZK+BSXyofZI4gYuP8TYtmjVsU0JFr2OmznmWveas0mDC4LI3YfUwgTh3aRK +q7IJ9MTQEbROoK6s7yntaCKCs2JTNc0hQ66OaCyoYV9U3Qa593ltH+GOTNc0ZYjKDe/uKwpWtaWn +gKCMvFcZZWa/UVwKUrsR+dhP5i4WrtETEA+mkRDO6qVllIFmo408POQPbHEosHG6yj6hR7HzcR8L +lghPoAY9nOCWDkoMEdG4QW5EXMtB8UGeoRxFYI3aVIURQNQELhRRNQAZfKgdpB2NIvExWgJyIv62 +0Ho5BjPx4Kf1xVXgXxqmV4f7V82YzdaAHMgZSMOGof0D9MbFeCghgDUoiCs10Xh5SI0mHfYs3cg1 +Xobxs1TvCjUD0aIxBQowqGOF3o3na2MOo61KhjdWzHcpbTYaYmPArllhZ4SvR8RAG2xUSqs+A1bB +kqEGXqSoFe77tF4d3xzJP3lzhmAy15mrayUaiFiESnMFzz8hvnLkTwsLRwBbHKQsK7RfF+aI8+hh +BoGpzMvxO69Z7HkPjgMxJ6YJ1CpPC9YQEVMCAqiXjuZ2l/JPwDxJWRA433w6l7F8ZZ5EodEiNH9u +4vgnIhad+3h+f0lL15wY6kDHrg4EDyvastsYJyYHG/NppJ+qWG+jBwVBBUv7rnT/nBpQmSHCmqQe +iNUgAAKGr7L/yfAlDXWLkL7PsfhkEPfu40aN2TF5okhVzHoR4oSIdCRzKodaFMGEobYIBLSTrIoU +sGBj8nIg0oM8uzeiQuJDbB2ctOxxlzHE0PhoHRxZ/AOlG6FNvgkaUT9Mq7iw6aOlTbM0pTO1ncTt +94+hPmzqmjpFpAw4A5XgjboBMuk1QUvQiVdCL0aojTN0zMKvJ/L8z/JvuKfJv6HhKX0G1/KJAlSQ +HWMUoKKgTwhQwcF/X4BK9m4foLKzASr72JSU9e7ZYlM+MfHdPkRlH6KySyEqtX0wRAWuPqMIFYAe +CVAxzxigYuYEqNCtaRCfkg/sM4WnlPGG0PTQhaiY+SEqNosaucpheYiKmYSoVKtxiIotP1OIilY0 +CFGpVpMQFTMJUbGDisZj+0whKjZOeXroQlQ+NUalGceoNJMYFYZdD2JURIAdxqjYZhKjIqBBjApq +GcaoNNMYleYFYlRsdItOD12MSvU5g1TUK3oQo/LZIlSG8SlsaffDU1SszMNTCMnDU5gOZlvCU9iZ +PDwlDaALT8lH9JnCU2IGkSI9dOEp1bOEp3DMw/CUdhKe0q4JT2nH4Sk6e9santKaRH31IYWn1OYz +hqcg3/q2hKcw9/urCE8hyjwcntLMCE+xM8JTItfQhaeYUXhK3X6mABUkjfrUAJU66EG/pREqjcZs +8NKOByNUqi7ew64pmyJUmocjVMK8Zh+KUBmUfDBC5eEe7yNUXjpCpVFGbTciVKTM8gCVxj0aoAJe +ZR+gsg9Q2QeobBagIlMzDFCBljMPUCnbehqgUm4YoALvqkGAilkeoNKOAlTaSYBKGx4OUCknASp2 +ywNUmi5AJcSYDV4OCk993UyLY1QG5VOUSlgbpRKSrFqbuY2nOBWT4lT0XtZpUYaqhPmhKqPiDFZp +UqzKZ/Ag3ceq3B+rgt3xWWJVfLxSsItViTq9PlbFbRKrQr5hFKtiy0msSjOJVXFrYlXaSaxKmBWr +Yh6PVRnM4wvEqtio8DCarnd9yIgNKWQk5LEqLBMDP+4PVYE9T0NVbB6qUsVQlbKZ2W4fqlLHUBW7 +PrwGoSq4C2VNqMojPY6RKvU+UuUZI1VKM4xVMY/GqvhRrIofxapUk1gVO4pVqR+PVeHFKU8TqtI8 +HqmSOK5tiVQxGqjiU6CKn4SMmDaFjJh2EKjSBX5Mi8YwFWGsYphKpBAMUxHyr2Eqawqua7MPU3Ex +TMWvK8gwlTKkMJWmGYSpPNDZcZAKDqp9kMrnDFJp2icMUoH6chikQj/FR4NUzCRIpZoTpNKGFwpS +GUziNgSpmC5cw5nZQSq+WV96YZDKo23fH6QyKTorSOW+fu+DVJ41SAWKxFGQCpxNhkEq5vEglXIU +pFK1y4NUcN3IUwep+MVBKn4QpJLP1wsEqYhc2MQglRgtUqXAjfBojIqsa4z6KM20cIpRka0XY1Rq +08WolG2MUfHzWu1CVEwMUVlXjAEqYW18ysNdTfEpzT4+ZdviU9SP5774lOztp8SnNA/Fp2Qv9/Ep +uxyfch8qpfiUhch0f3zKfegU41MWItQ+PmVtfMrfvv9+EJbyeS8d0jtSEUgAZ3a6lPUgf5hQw3nP +ONiWqwrlPTz8E+CM12ziXr/+k2ZYR/ccm1ELDUG8WpBpM7QOND9oJgHinYXoSvdN6mtXyXg82F7r +seqHP5/840/fCkb95uzi9kwW2L757eprXoBTYtXlZbbQIWYhoPRk1KAFHxlNFUDQCUBCOAI5HeF4 +GrVaOZiMaLOk60pb67WPLXyQoocnhokLBMuowalKmIiEm6JjPhooDQ+hug5qFougAg== + + + ITzIGnBCvxlDj2n6wlS8VhA3rAq8cgGPwyEcTwYFL3kuS+2ygVKf3eRfwW8V3Ap8I0KpoqTn1dF4 +ExrVR0UI7sgLTey0whKanBzYdBtvg9sD2WpjKvpqt5oxctSd40kHT57jajIsjlt5g0t8Df/STwjg +Sl3atuvSpe/PT2/PftY7pTWS6LNTDijZEQYN+QIpn64IClCAU+lKRQeMrHDCMtHuAX2bt4xX594G ++kMtJj8rXFkmx/Ild4TIPXRxbn2p3hj0/RFhqqorBcA1awXXAdyhQMd/06BxfiuLcgmpzDtfkYI0 +taG0JAMvqUlhm7x6DNdewi2+iXTJ6rUMFIPk7LpkLAIlIFywBsEMN/uW8ZkZFWGfAYVsD7nxzqaz +c0ksnUSftPfHoXyM/2HpKI3PWDxEjUyWRYGLFwbn/mRpANxgcaTYdHkEuMkCSbHpEgG4eJHWzBZq +woHxD048V+SrN/2aLF0LqNgsNb0Bdm2uBbwZoQFwKFMiNAlfQt9W0lTgbWgUCO9JcKQQr5sQPxxV +eS/wHclL6vg/8ktpQhRWnuSy+RYytiFC1bCB0XKrnvYJZLxqRAGwwEIoS1oeA9B4NLh51IZDSw4V +Zk6HSeDFsYYnPEVY3NIORS2VgpXRk4FZunAGQYeLW25hEIY7EFw+0TUqXFxyAYVXWVXXHcQjianl +Mgh/H3gxZs0LO72Ig6ohdZqlLl1Wy2tyDRNjmtYFjYDydFDhLeINQ+FkNNwjwMq2RIyYCAeqMJZJ +Qd7L8bylALwEJycl310dIIKPytkEEuypvI+Z80Xk4rZpVGmN+0yD3uWK2WHOUeG9NU6n5n2hev2j +5jSEnVnz0mOutJzTu1fhutsyMlJ2k6+xvfWiX3jrwIFDxCYHLcjxAXx2NODDwUUOHAhVz010SE8L +kZ557Tl/JQisa9DHqze5YehyqZfhWvrkHMPspv6FDaJ8aiaIidfgGFVay/6JLsvVYVWXLGTpq0fV +msaoqgsiNFYeuWh5H6bev04CydvV410nADVOr9csTVCW1dG8KEjone2XZLxqx5N1fPi+SDiHypIY +287UaDz3Pe9NK8yZb3AGNLjnvQWywAEBl+VuIT90d3q7KlYi8v3628gQxTtcZ5K1Eqgh21olJDhJ +8fDkXdInB3HPB3UCLQmCidFWvOVXRIAqsugl/cWAs96QUpeUgeu2xsOa92uqmTY26VDf3TkB1oiv +lm1tapzaUJZ6uNNBg1NXLbRfY62XxbXE6jRcxN/QSyISWThz2jHLehAeFoOrZX/SluCgpYRK2ZUO +ES1QkghhhQKxipc/V8IINCCUIhSKCB9jqyEcQd99dQC//lbDQR012icCair6CPa3UzeRBwGo1Omz +vC6LRru6hRWeM+pwexR8MyzLMUAJZmMYOXidLLz+DMPs4NTjlQyorh0+oIE3x/qamm6sB0QxLgSi +TJtKr+CdvC8mlRTThoppb4ppl4s1AyvWjL9YM03FmtnMZvukjwaHXwQiE65QtzeMiGnoP8P2NBGv +nJ01qzUYhmMY8wn3TUoDankpcUnnaatEdfxyUHZY75qWs66NHmZHfmvI92CMX71Z05TQyEFvhG7l +XZXH8VBQaz9S5azHXxSjSopxI+vme9Ddk4NhaLdvIqMHQienviCHEBIEYbcxi4RsO6hoa7q2JExj +2EwbmYUTSFEaj4Nb42HdwTisp9+i05A/GnqaEO2RMHMdU8nNOBDqNazjqhk6lxRIRB8YlV8zxN13 +TvsnB3DiAxkq6GVf6h6CFoGmzxPIebXGJPcfIMCNqpi+GgTbachn3xj1mLiiKusTo5cQciALwkik +k+lMnTyg7MaQhdHi3YRFU8PtS52O4VQ4oZsITW5AzD0YNbB/HolLasZrhqaKWmJEngoWgM1VBvkH +RNMKw8Lsx/BbQ8TKuqJ1UIVKsE00Ah2dbdzq0dxWYVVq1I5VQ681VGvfx4ukk75cnd1cvb/5eP12 +9eHn0/fnq6ubt/kx/7BafA1eq6J7hNkKHOE2RdBNsFs17yP8BrGYYLiIjxMc/+rNGiznVu7xnCLz +BNMFOsV1koYJtke9/QjfdRpGGL9mFk/u18cvWLpMPW6ehzN9YgayzxP18VPZx/Z+/tE9xD/Sn3cN +/1hF/nH0/lH+0XX8Y7sxA2nUZNpCEARTZxprAhlIL3tpTX4eqpl8St4QH2IkfGuQFqp1EEXz/Dyf +KTvPgIO0dHEZcpCWHkYDDtJGbmk5B+nIs8EB614O0n8ODtLP4iDz3izhIEfjL9ZMU7FmNudxkG27 +kIN0D3GQbgEHOWx5KQf5EMM4rHkew+geZRjdJgzjuCsPMIx1OWYYsZE2YhgRyfJUDGPdmocZRrXH +t00zi3EcVreMcbQTxjGfsc/MOMJVV1m4dinjiH1JFs7P4htNzzdu0OjRzEZfnG0cYvditnE5ji9l +G4eoeQ/buBbbH2Qfx9UuZx/tGvZxiPnPyT4uZ+Yuzn45Bz/3t/O3mzBzsKc16kEOKzSSdyqkiH8T +OD2X0SbIb7qX06/Sr7OD8btx4azi+BN+5gHwGmFoMGUAJ5zRMHhBgrIM8NYUHq+sS34ZEOp0guQ+ +xjtmMAledW6V8AhdE/HHcT/yWUyhMSRztvUIpAHvUlawKpV0bQA1mNC5GliVLpdODwW5QSIbkmtr +8pOJarGuKqEw0GPKsDu/K2fyH86KjNNyfCFomBS1iylxI6yimrmxKuuQAPr/IkH1sVS/V513pgpA +/pcSZlAN0WNqBMe0XK2hCcDQN8JwiRCIhYk3NQ5opjsoK/K1iMdJTehfTfaYtR37NepmSWPNsK/F +5Jsi1dnnd7QRkVMaSf0vB2jVTPNeM3AoveQ7BzNRSTmaDsbw/DOw5zn4S/CWQL0zFM+OWRkBaTSH +DiGGMflWn40+N6575FQzS2zNvFEgRZwz44HodDp2TEHFAO3Y43wU/MtwPrvSMR/HsW+iIHQ2nhcP +T5qamB+YtjNak5dMHDLdLpy6r95MJ+9e2INTiu4+PKmT7JJtxlHu6eYsuokoSmUjeE4jLxgDi0vK +tsasscf4oIliSTbTQ0G+SsiiU96sbpQ3G6W79a6kyb8VabvhDxMqZtISVlSJpDBpQIsSgfCISykR +GoVwpT3Z3JPNPdn8/GSzGQji2BLgiUT+CC3diBIou+UKTD40N+gg9WG+4scJcCaCstHo4QhBekAI +DfDCQeAIs+YwKDkcMgskJEBNfFbQ2Sa0YPqZRwB1VKte8OCjxic5Ui0C8H86qORgABJZx29j9R45 +GJLb1jCxQ6XJ5xw8YB0yOdHqqVmBNQeTi/GScSJQSTpHBnP1UKACSKuTuQZHWlQW90wi6gnebWtY +U+dF1KNuDOnEEQxZgSQYlY+RbJDBv1avvQy2jv4pIoLXSGDHq6SQAho+QmuKWl9p6jqRw5G3QC+6 +2bDRo5mNyuLCFg/p3TKkc0FAwhq87IGLMBOC7WLc/OrNUuxUyjMXP3UsSzE0uu0txNHR7jcDpmmw +Bums1aSTeio26tzYgBrCCxL6VswJPRsNjviy5kkE2UgO9JYOkdRYWfntfTMA4SuPRElNzYxELZKe +SNV1BCAbrmNOBRdz6UKTbPVG2KCZzdvDLnUpkz4xzQpDl4OmbGRuFnpYAUSV9glAMQobXzlqbVv1 +oaPbn7JlzF9dU61s0nNk53ipqGxgREuTr2jhnsYrfTHprgThbhg7zbOxNJqhmUnJTg7oBBvAewSv +lhJEt/GMoHvgCXkRuBaSF2mUF9E8uIDgDALEMrob/bEBeFiXdM8bsyfp171qQl/TL0cqa5nwvQ6y +NAypast1JAoYVvNMhecOE6A4BMbxJi3E6KrazWnqsoC8R0wC+QNzgorQrJsywBC4tmhV45JmJGET +cskdc3S2catHc1t1yA6KhE8m8DKwAY0yw6Sya5iPtGXUd3nhpgEVmGwbbPLJxgFw+dYRxmSTzfPV +mzXbh8DxBhLg/C2kvMySTcQSo20ksPFGIv813EoAjTcTYaPtBNjMDdWv9tiy0dj7SOqYoWMSYjpz +1vHGBD5X8G/V2wL4DOtpIIvHlDHYEJy0kjHydYXUdFABc/mfipEfQR6kIqXsKgiIhpnx4OqKjJrr +dHBEjBI5DGSfIjOskwONoe2BHtm8vKcxECsN8qQ2rWaeRRIZRPrw0nbgzrhYbWkZlGIVAohK5mDc +pLWjOa0F5vhk/haLhDzLyMYULRS2CDF4N8dS1HhSUWWwJ9yyPTGsC5lAKtWPMOWIh4kIV2429JB/ +Gpy/B8OdJYZXFuoBaEBqzUEM+lnSFjNRmMiRxZSj9MOLsQiVAU+HGAQaY8gcM+0ao+VdK6PUk1II +VEty2jCwZF3RqomJyez/z95756eSJA2AewHugAwChCtfBZIQHiQhC/IWJwlhhemenj/2txfY4+w1 +9hp7jU1T3hfwptWv+eabN6gqKzIzMjJcRmRA/ZfH1EfCOyHQZZSAuSXFaH9jryxmsuiSQnjhuygp +XfQKhayAL0ml8Lm7muZdE7mearyv9cqIWEOwzCoPgeqNJqAFbek392dAHAtrG1Dosg4CujU48bIL +GFZBwotqq6pHLL55Cl4mjYpqiV/Bi69xA/w30NH1j+AZte6rmAFuzNA5vK5YO8KqfsiWuymJdxOZ +JGEwjz9JoCgblChqlBVy2jzN4xAiWHQN3f0gvuGQaUvj8SENDoyYVBL24bfwfBmmmDh8C7YjAyw+ +bbq+x35z3vul0B20QP9U9tIc3jyMDkUVAoihW355fAU6itOtqp8x+NLiGAdT4nlcFYWgYDCmsuTi +k7zP8Aisnv47BBq1EUErD8T+8z40SFsa+Plkq8e0tZ6TxHdPoKsnCJQLaEevMKuZcSQbHjlFtNQK +oTt+CWQQYvFaYvXSac5zpxTMiaJJwZOmY6Rk+MxIy5qnnqg58GpCz4HXhSgafKanafBITzPgkZGu +1Q9dUzaMozDQNkTFQtSNcagfq5HCtXKPJVUl2lTiCVqs8JZoGIk3gHtd7k7c24yCT3SJPUfii/bR +NVKa6fLGjczL+0/3VcwAN6btm0FXFKhHV/Vp/7L1ycJK7dAFB++QoWAeJlSXrTYyvjKTINCdvvBe +Pd3mIAkB70OBQt48mlJvZpxfiq4psP+W5XA9AtVuXqDnnPeeySQQelCFVba0ao04ccfqnyBxgZdG +fAL9Kklc3IwGFpVfWTEo6hkOC4sfRkDqIXI4Xk83jZh+ngbk5FdLbOiiTMFxxeHlFLACgZbW0P2v +HOX4NWT2sGijlto8dp1bqGuYng9EiHMk3iLqNrWcuk3q1W1OMOgtnKDj7kjAqLg7Jxj0FtUjSW9R +fRUzwI0ZOpf0FlKvapHu1O0YdBwKJAqIx1dnkTD70U5/iQEzkWHRdQtIJ6A57YpC9YOGliBNK1U+ +VF9DryFDOX4tUNg1qr0iy2vfuUX6hjo7wXO8Vu9WVoyTGB+P/8I6sli30i+pCehGIA== + + + eIk6UiYYFIFKIrdq3qfRL6CBW/VpdBBomGq0FImIeEH+W0NEgorloRtypEcxA9yYofO8aC6oxyip +v+qJIOCsgKepwYcDr6PhhbCsTGLAck/akBh2GBP4MmqaMWEavIrl8NBw13E7BtZDox2/hheliSeP +S/SdW6hvmMkO6xZ5OPXUEqCo28okiNVaL0SI1Fc9GaofuiZEzeAkUoTq5ULEKOn7WnKUtFW3BKkL +B+OtXI4YKmmwpwUTe1owWCCCwQKRcKCyp9WPRHua01sfnAq08kBrT9sy+Z8vl/SY/hX2tJalYwMV +jMuFPW35pbM97dSptT1t9eUS9jRpYk9raVnz1BM1izxHS8+iPe2VokV7mjTa06TRntbStfqha8rW +8Ci9Pe2ZuiV7mjSxp0kne3pBxZaFf76ejYYXk+5w1h1+xGL4MVJ31S98Z2P4RsBvLvpz8O9586vT +mvnwBZP+3GQ+/fSfNoaNj84EqMbtziRs/86PX+Yb/X4X7NTxZ7cltqyPRv0EULHHs7j//I8G+G1s +CtQAAELdnrVtb9IUgSj1GzPH9jRqfwXTO7RtEQiTD3irD4xt8URI1vgFWNDz4UVj9qkBnf9sTFoj +ZZKgFQJh0rTe+c/MX+j+0QUItwdaRyAa484EsM3abDLqdcDA4njNAZFoVnzFlGOBGEAhaqTAPyGW +4P8TBP4v+ksMQbYb7UKdK+SHuqbgfzg/KnKBuyV/Sbe0bso0+I80YdV/Vt4vRjXcDahb1s9KEjP5 +qzuVcQw7JVGHgBf6aYxk8hf0y+uQzPt5r0he5Q4w25NgXNJOR8SY8EtaDW4DmvuphF/6D8RUwo/Q +RcYpWbNZFHUWI6prOIRuXBRhPpxfNhgVd7NCEbw1wc8p44IRNyTPwRgimB+JbmOCcZk84n/QbECj +JtyO2jMVJPEb6SrmqS9xMhz9OUR/AJmN5HrYnzgD0/BHfYkskOd/dKS3ibyYY1jq9sHMYHtAI92h +HzfAT7GmmxCbRIGykLjpTrvNPgJohFCbNVq9pSB4HUOuMe22lM/xImOS8p+/v087QKCR1t+LHxz1 ++3N0GcZoEm+MxwBpeHHARx0RfSENUH8VoNJffH8Hawda17szBI5C/fTPJ2JjMEC7W7pDR8NpF6Z2 +ynfZFbrTcb/xF/4TpnwmMCRx1cBErnyA2HiCRJW0BJj4h65y4BmB0+T0CVIqH8ztE1AlNJKGCYB3 +WXP3ImhgdDCSWI1PFDrv/j2/zx9SDSeMkYlvKMHPMXKkWUV9e340f/+eD2C0MZmZrFiu3xm2PSy4 +HT4TCJiCK3dOVGVyyucWg7eZR340bM+7MzdzUENZ+Q6A9LcidMrXz1xPO8U/OsPzdhuRJOxCQbKn +217EAhOqVC/TWhPIxoZ1WZCHCl28B4P0aFi8luIsyk0o6ygP8Denwd9nSr5E8T+d1hwOAb1A35rJ +M3h/G7cWar+ZUHPLP9bCaC2MVi6MzCQQPhki4SEIOnzkeFjkENaawLc9ryXQ3yiBqL9dAvFrCfSb +SaCrJW9htjCqTKhybVKtpdj/3qTyfJf5WqD9w6fkSaAJa4H2Gwo0TqAFlF1Hgf9loQ8wKbA0vvuV +ZeBdCvCGANGDzeK7awiYNwILzln7Cam1o3At1X6EVEsK+Co9huLRHZMsrHSDolBgDnVy7Sn8l4u1 +5Fqs/WZibe0pXEujn+YpJETxshY2/2ZhA8Mn18JmLWzWwmYtbH6VsHGTe7AWOv+7KRmSHv4GsUP/ +bLHzrxMa0PFG8QQsm4tuyEPnRSTPMIwmPo/nKZbBNaUJGnnieBjNx/6so6QFOfbvwm9JAV86TsAy +IOiuScx5WdakeJdHxvv78GBP7IpZs6sfx66Wqh63Zlc/hl2JdyYQtEDDYx/EreCVoxxjdn3Hml+5 +4Vfsml/9OH61Vq9+D34lqVfwfn9SUa9oHhX9W/OrRfjVDw+O/9fxq5/iQ/znshqFqVv+wP9BZZc8 +8aU1N3HgJj880Plfx03W1tqPYEmrjmMicXguYGVJAdW2Y/kkQ+CSoISQXEHK47+Uf63jWtcc0B0H +XKe/r492f5g0SDI4DYnieXixILqJN0mxJpdTrs98/+FT8iTU1lGtv5tQ+ylOgn/YrllLo1+b/04J +NM2gMrDwPnkBKFaoDB6zDnX9d+e/c8TPlkD/Ovmxdgv9M1mvkyFAYzuA5GHJMVjagyKxU4ihGG4d +grQg91oH6v9u/G+tP6/15x+oP9NUkoe59f4YzwGZC4Ma4jzB0CbVhdf6879Jf6bWEug3k0DrY4kf +wU/WguwXH0ugUjEkwzDo6hgSlplB9ggp8MvbI78LFf4+U/Ik1X54Jtpaqq3tqrU4+ueII5vbNsQ4 +cUpY38T7L7ekfng64Vrm/BhLan0V71pw/Rw7CryPMwygZmw/cRTFre/y+JfbTz881XQty9b201oM +/XPEkJX9FKc4AihYful+AJZjaXZtSP3LDakfnum3Fj5r4bMWPv944QODIoAFz7F+2YnHJpPrjJZ/ +ufD54Wma/zrRAX1wAssTAjzm5ViBJ2H8KUcQPPK9cQJPoWLXBLxSBz4hleIhDE/8uCLD/6KQYtPi +TziOmBMIHI2GrwWjGIZY3uf0+zBhTxxrnYP3O/I8jmVJhkMXi/GwVrrZlTM0LKiexHwRV1gXUBHA +dcGktd7997N/p7MHksSZfUmGIQX4iyFYlsFJJWSS4dahyf9uwcb/8NS+tWBb7ECdoYkkFFpJVuB4 +9IMUWAZq9QRDYzHGCwxNwh8k1OUpRatfC7a1YPvpgo0TbxKlk1wS3aDFCCRFoE7iAkOS6wq3/3K5 +tk76/N3k2vp8Yy2OfpSbDZ9vMDRQotHpOkvFCYoAFlWcIpPU2rL6dx9y8Oukz7UEWkugtQT6hRKI +4eBBDykQZBKVU+CEOJkU4AFdklgLoL9XAJF/f61Afp2huRZBaxG0FkG/XAQRJMfTcOkoPs7wAomK +JhLr06W1CPrhCZtrAbKuT/R3sE2aQmyTpQQBxcYyHLxnBdWtg2F4zDpOazF2s86p+90YFopNpXga +JX8zBAP1jDjMAUdBWVKYFkoMB1YwFHk8jtj6YTGp/7Bdt9aY/xfhWdz6iq0frD///eLsh1f3XIuz +9XUn/6Ctt5Zp/6NL7GFklsCwgJJh7DFLMFLEMUmv4Br734UKf58peZJpPzzz/F8pkdbJf/9IVmyT +/McLJAs9Szj3DxgVxLp+yIIM65dmK5uymysI058fTYadyXRV7EYHVGYxtmsB+M9VpwFoF5LXfGq1 +BVfOdkV25/p7j3zyF7nFf1/utCB+1hxFy1Emk8Zf/spo0v3vaDgD2+opxFP+8ewp/I/Sidab89++ +ObHUqU8aw+n7aDJYlYhSAXQnnmT8zKQvLxozMIYhklSEJLwGoz86N68XM+kp/mbSee8DbftO+7Ax +bI8G3f92zJrew4eMP3EE9KzQuDu8GHWHM/gsKT4bzgf50bjbQR3xlLr/iqp/UaSOZo1Z5/UKSNYG +HjBJyC+nrUYfjrkzaXVwH/Jg0Ktqd9gxBVfofEw6+BWpA1ZqtAD2zTqqqDsida+Uz34/Y9wV2y4D +hA7VbLssKtsqrl3rDsZ9mWt7UeexHo/7UADD79CNSRZau2gEgJkAErQe+tEQaHv+cn/0p58FgmYt +ZtZi5h8nZhQatpczhcloXPtstEd/xhtdcwGjBuXaAEKcvdkfIpwQcZ6V+ONo3GjBZ/KDZn8+MTft +TS4W0f/A/7lrePUDKJj+aPUnIgNHY/6Y/TX+F7Pti+6w5891/uj0/8UGPPu/MuB/ESZF7yhQ6z5X +hUcNSG9c4Gs4QzuKl1nA+3QmKoWiqtfvDlzuub/DxahwHY6lCXzkSCV5NReCufSip5fjGXY5lvRz +znJ+SUKg5TzWusv6qBTp9dBOa0zUin2coOBVY36SZuGmo2G+MM+u/k5UzBBL8//+9y//aWPaWxX7 +LHUA44T4dsc6SdnSvLKVQP9sheQXUvpaDv7YrQxtdAbtYsrSUF/IEPp9NoYrTR1bbWvnxFrA/xTt ++Bda6YvJcejc8Ev7ZEkviAaWSzNSluLtxqSndjK0phPkBKHiJCe1+aMzkTzJGPHjRhd5JmLqVp+j +yX8t1oFiGRj8SAkcDobEKwD/6i2O+KnOPWLn0uGAEaT36qxZtoplP4KnjXl/9mzvA/e2o1AoEow8 +YtGqJzl0hyEvJOGVpfJMvUTAmjvJA9mj5Gtx2M5OZmi0U/iEhU9ez0bDiwlo3R1+xGL4ca4D9s9F +o9+ZzTqIw1403Ywz9HgFPkRKGMDkcxgt1t1/ffrnvouWNzyFbj+7s474nTO6GpAAgazTd5RkOJaG +kcVJmidpWuMCEL+7Kuf8V5229GWSTiY1lyQnaYaC6QrqISpf3nf60NGKP+ZYnie1bgY5d0f9EToH +Eb9heSLJ8OoOSZphKUb7LSl/m/+rIX0qCDTyavA8QcLbmYxoxcshfpnrzyWE0uD/SAHhkaCTlOlC +qD89bXwAZbAhfk3yFI+RypBJAa0Ly+IfBMcJCH08y2G+pgTS8RzDiyAPYAB4+YBO+nMHDGtcNJLG +yy0I8IoP9IqheHTBu3SNJwwVRxd7MiSALIKlaB6ApQQAlub0YHkOYDaJwALOq11jhgXwYG6KPFoN +WPCofJAkTMGyJEtS+PZRkklqliHJwWu0YRs8dwAWYUEGC0dLgn8BXEIPl+YZlofgBDLJafLA4knp +VlMuiW9FiVM0QBktwWXhcOHwcwdsUoLLUzSlGZ3A8ixDaeFCpxiiefh/yrWpElwKYpdG6KVFuAAq +oRkcxC7HaTvCyBV4UchpoZJozQDFq6CyFK9jEAKXxLhUEM8kCZxMKiKXwvkEIoUxBERCEg6Wk8AC +wtXtFIEFm0gzWoqCRADhSiRGYSxjuCxaMwHYPgc8I21EmkPpC2BeNMKfkCQpDm/hJI0uToM0IAl8 +HqY7iODQIBm4Upy0UgJPC2iQNNgFcGigex65MSmaoAWcCMgQPM6vgHmAAqeGRkBMstKu4hmORvkX +ilOUZ3lGM2VSWm55yng/YKCA+UkzJkkZLEQkmiFgJCgjkaEpllNxWDhKDt8iD34YRsnBvU+yvASP +EHhENWDdCN6UmQGtCk4azQBhENIa6IAVwTKY6uE4KUrapoD2KBiYD7Ypg9FvwiTjDAP3D0QADVaJ +VY+TpOE4BUGElwQ/8eVDJFhbxnycElMlk2B1eGXtxXFyAC6Dps9Iw0xyJEEheQYrgAs0/prmCIQS +OT1G2kA0BixuILR/IHMCQ5LQSXM0kiFJwKoJ80v/GYUpwzQdxKrEvUPAjQ4WDg6RlbckICQEkWUJ +1hSiwuYkNsriJZO2JC8xfZKRtiQN+sXFkuKAulm0owmAALzQYN+J24cW47AxJFYAkOCUkxIckgAM +gsNMFwV3A9lE83jBIcuCuxTxSDUaxbugRT5ESXhMGphxkkwyeFEAWnktM5ZFEubtoA== + + + Z+lEQZZINFodipR4JgfYHYVmTBGI7oDSQbAaapIlM4dzosAPWXYmEaELaANJ82dowHsERMscYPXw +RxLwTCyUmSTqDqKHFbkQgys9SPiE4hhmZcI9Lu1JWEIRrQcL+RvaRDyDmQkFl42UGQVcRlF00GrB +Ce8oBoITrrggQQUUwZBwJIC4EWsgADFzmIFwSImgZUYprhOFWT2GKcChol3OSaRJsQJFoikTHODF +cKBJAeGAIAEhCWohwcHhwV4YSrVMUE4ABLAc2kUSJ6ZZUkxiAwqWmCfA82hH0ngzcOL0GcyI5Eoa +IlQObnUSiTaBkoAmORbtZtCORdD5JI8GDWiCRtOQJBstyXlRJqklGxJsMvsEX+L1gJtJ4DB/4ngG +AxEQc2ek2h6URFGkdq0gpSKlQVZyGMAOEU/nkjTQ+vxY30mK+okkdsVNCvaVgtAknDlGp4RNBmjv +BFbE4M3tcIyAp6A9C3RzvM7iCOXb2gnMmDFMhE0a8WO8kwyJWrXR+8yPDAH/TfdjCI2ZsNjAynVp ++o0IHEAsNdod/2zkx+aIEyxtawWKqVfVBo6+vQLJLITKBpCuuSnSoF3gRwF6ffeATT+C4EO173lj +0pn6s8OPPjCrNGDwfx5VMJ/9Y8MniFzg4mM+Bc3Mi+xZ/fys6Ac8lPXnIdD/+PQPpc9wZ8pbAMbw +BXomfUBxiLDB/6hAmnUj9wK2KseRGrHKA8rVCloBiRekpYhHzTS+vUGSNzTSe6GUBUxFkg0ER5CI +PQBNUqDMjeWkyCB5kU8IKm0NMAKk9yI1iFTBlfVboLchQcECnqUdMbB8CdnkIDBfQ0OX9H8GSUgk +wAF7lUAzPEXRGBDPMObKBisJCgGzXSin1aoBDWUaRaJRgyUn5cXB9ohmQQFDMKwNeiappkke9UAJ +QLJYqXyyOi4oqqkEjUrKS03CLdf4C8W3XHy49UVg3REKfVkh4xish/IkUJyR+OM4oMSjAQBdmkVS +RbzcQ/9DRD9cWAqyVFm75YFagjPZGJomsDRlCCyqgV2DtBFK/q9owEA1mYWIZqUF5MAA0LqxwHZD +fBcsF2DOiMuT2JqjpTHpf2CoPBIePKJlCSrQ15GqzFIk3ggMsLbQmIC4JbGOIv9XrXnCf6EclkQm +GA1aRwaoNIjQgAIBdgdSbUR5Lw1K/0MESyHxjhwD4F+JbjkW30dB8Ei600BCcphMAEYYUWHi1KoX +1pNYWqN60QygMwEpLGD3IqOMJVm1KQTMG+neFt0PES6PVTq0s3hJYFLQFYWscJ7jk9iHQuIOFCYj +/1ckEgLvUahygH8l5ZgEWgH6TmCT2JcgAO1Lq8dKI9P/kPgKgYx/SNSU4q1gBdyWYCgCa1zAftM6 +BJIil9L+r+QCQUo3Q6F9T0lb7rbT9OdH/REUgaP5WN58sJYZif0dHCOYW1+UdKuAbHxqOA1Hy9Yn +pdg2PNDEtHjl8JIq1pKkjPKSpkuJJdJECsPWA9JLeT3PZSkKa+DAtGN5jTPR0jnEsjbOoaSohAkE +IAhKCw+YrIC3wR9qKx7Do+C8acP4PMVJKYOj0D7gZc1WslMByxBwFi3YEVrnJo9VTpFo1V4rUkgq +lEtimBc52Wkt+aYVb7Xaje07G2OHN3ojubyr3elM7cW3i3KXD2g1MZXG4HLbBCeD0x2NwNHvbjIT +ksCvan8NmqM+BPN/+EKV0QBolaFKpz8G/5NrTHsdNHCgK7Y+w1D9/AOMCmqeoataDTaZ9wHW/DH/ +Vffjc6Z+UBj9OVT/Xe28a95fj9V/5YB2/Gdj0lY/K40m4qPzSRP8fT5pDD9g17UZUF1Vf+fms9lo +CIjJ+IxSP6s3mtpG8IGmBe4I+7HB9NsfHfQBXC/5geYD/IgGj0SXOxhct9XrwPEhn780WCjjwyLe +wUqpsW69eiK1FUat+QCQUKExa/gCrwnpb38K/aU654J/351Wz0btjunLPX/oP4P+ELyONWazSbc5 +n+EkF9AUU93/AsQK4KtatT67/fYE4B61kWJrpLfwn9lf4w5+G9oZTl//aEyme6rkfnXTPxpw7XFb ++Hxq0Q6mi+Nm4kimmr/+odgZjoYdF4jpjwCFt91gRmoZ/Xvn1ewO22CgpIu5AeKodWZnaBLO81O3 +XtHyL4kJ0hYTrubfbTT7HTeE77iq/6SNnvrD9VaHTf9miobTa82ns9Hg7+Vkv44OU9MGjIOAMg9s +Mbfk+Mv3RQ3eXPNjhvI77NLp+58/WBr/zdtg2u+2/um8OCaQSmiY5fK6Wtq/m+/CqXBOU/nLzVT+ ++runQnK0QDtN5c9uG4W1O05HbPgPmNJnB1mqLuYktfybJyVFf1pNqDkClu4Amtfnky6wFt1MzfjN +DxD5iNfVRvNJq5ODQdArYXv/aIOMMHmrxtisMfnozIAeAF0G06OCm6U3fvM3q7IXZ2WKKY0mg4bV +rlRP+b3b79g21kxW3fofb54TTpzgHQVCu7PMlbZ/7/I7Tqo7BOPsN1rupqVu/cP5NrpsZ9wA4Fqu +NAZt+795026V0P+52LADeJUQOmpxM0l16x9OmMPRqaepadv/AHnrzHj/ZyatVij93aMZjWfdQfe/ +KLPgp4wJWMl/9xAGnVmj3Zg1lh1HcslxbLXF8w83u07VGH38eNppd+cD/1VnOurPxZwSGUz2iCT9 +8vEKWPv52F/qw20Lz+guJh2Y6qu4ezmWpVlxNtmjpL8xmTVHjUnb30JHy6S/KY9aZieoC2lQ/i4Y +RWPWAQ07yEVt27g3HLV6o/nM/4HPrNGiKjllcASnnemn/6oxBVJQJGDVTPEXLMVQgvWgKf8HOsly +11bWIGhCM47z+WwMBmo/EkoFWS3dwAi6bf9UvD7OxSgUNDuuiGpyjm3lyZGa9UBkMPmj4693/jPz +F9vdWaPZ7XdnolQmGRmmkZiqjeHHvPHR8V+MxtIS6sUaL+GlPe7GcRMJJBjZREciA3QpgeZRo9+d +6h5NxyNxB9Cy/2LcaLflfZI98mfns5G8YkayTfrHjTHYBdPuYN5vKKsor3uu3+m0oU15o2xW0hK/ +WgsnPxmNs5NOA6csG2RgSIntI9FRP0GIZ/7gB00ZfxHxMPoM/Z+ywcXJyr3BDjS+A3Gw0qrlG8M/ +GtOajA41IRD+d5kzgE3Z7w47/ilKFJ7aNx5L9DP6ozMZwwPfqXaVIbJErgMHfTlvQOryV/ElTHoG +YTaOGaBM3JJXKFzTcoLWOfZHB95K6G82+o1hy2GSrX53DNYOeuX/A/bGB6AAceAhkomD5VAx0l72 +qDTv9yU83nQmUyhMZxNDF7XSrT8PIddH/qxIIeb7Qv83oQVSqZ9W/dfTjv9oADdYdoqCCiCrHLb1 +xCi3V5qI4UA1eP2jRBI8D6tgOX+ll1zmTfG48EUR8q4za6joHGZoYIzjkT7w18bA9JlMAbpn3Vaj +rycryw+UWBMDfRm/ATjO12ra/WsKGyWFqs1v0g7s0bDVn7eBfjyAFKNnYGZflEfwun+YMw/YUbPf +cTEkPN3iYDz7K9/p96eWhCF/Ui/cQt9mReUMtOsBLfJpY1yXFRrKRevqqKXiqPoV1++W0fgvA23r +ECUi0393emEOU9ceJR9jTPpPcfK2oV91m+th9z+mHasb3XaH7dGfUx21q1p01XJTP8KkBm+1xh9w +a8EEfAXCaAgpxa/hz66+8cPl8RPiAhGeviLNltXpI0ocn9tJ4a9oUVHx9BEjjo/x9BW70FfcQl/x +4lfeUCjo6MiGIswJSodG6G12oifC3Sd4gOZLbP/NE0FI9CR4/I4yx73jd/SC31nQleN3rH7dLBFv +ynUUiV6bN99H/XZnInkG4dNpWC92dY1V5pqWOxTmYzASaHwpY8l1PgFVqfwzuClqINKbVjjvmfJ1 +3Tu1DaB6r+Ocxf+MR5MZVIPU0lWlWufQoY1KuTYoSBqnUa3TrzRmoG8oXPpwelOVvmvR9gj6T48K +6pbq13UYdwB7NRsfCgFVDU/7tj4aq97J58Hl/ggon1ed8bw/lQXgHnwrX9ahm6j+Lg9FwandlJHO +YZS94E1x2BqZWNjgDTTjzoeKXqZ+h66NQbiDmoNoQSlAgSnY6irjJpU3JaBN1Y3OYAgSmFknncnQ +bCBAt5bVT/XYB02AXqSxm3YEiH2KScuwhZL+4UgxNPzdIdLgR9Ou1I2zR4TyA+PQxguithdQW6TO +50VD4UptKKitEdQUTypxg82QnMYMUXs2cGspltrfAFoydnXoXAoaNwT+CKa6QcsCfYRMdv1HbpxC +xYuaWxzgxtZIMLY9F822mtp8VOMKN7NBlnbeuLnzxLUoxl8549hhN8rh8P7bTjNx0213RonTEdD0 +OhCpQHEE+7Aj4TahOL4TrVEflgcAkI0sW91uOuvH27gLRNSyQLAHDz8T2yseQjffjNsD8Lo/dD2o +cds1cBzDJ39BytclqRuOx5M4EnbxPgyid9VyNhK9SyzP27ecKIaNQJD2bXHcgI69a9YQtv1zJFZ4 +s2/2qWtmwOnXqAlwOu1+DBtGp6G+IVraphg3YAcRNRzBk2EX7RrTZnc2aIztm+I2E90+MWvd6k/i +rdEQXu0FXXI2Q4UtZb7dRFcP4fnzpq0n7Tiw4eEdOg4DAA3fAWuSrg1Doti0FRISRi+fodc/4IHr +OP7pst0f1mMbfwx68c4Q6hjudhD6AG8hZT3dfAMWbQYvbBPHEqdYU7qHTcGmhrxZFeBkOfQx2CLd +4fvIodlEdXGVQ1PkKW02JlMb5KKGTahigf2k4hAuGstMwkXbicb/4dRazSg4y+aDxqQ31Y7aRWN5 +1C7aqkbtorV61GZMXjvH+bQDVGKk3Nrs4/fhLN7ujyfvo6Hddh9P41AxAzxkak8W0zjgmdApOwRN +VcLf0PI/4/hEz5KQwDdr+eGGeYF2Iu9S/MtmaFLaYX+4NcRJezLV7nhTAYSaSY7o6dS659YgLnnX +W4O/ejZsUGk4wvcwaz24ht4xl7HtGWoJIgu6jtfifpxjCvT5tv8pVLs9v3gK+/+gHHQgOC6VcDKT +dqAN1GK6QxvRCeWr05BhG1FlESVB0pwNQpGusD+BoaxaqSMmQ0ALBHyz7W/+5S9Mun+gu67t+DL4 +XlGxbJQLDSO2Ui1MvLWGRujI0ZXMgDJeMzZTaa2sv7UQnHw4C0rQRhSSqgJT+laoqpQEy7GdjdDF +jcZ9KajIlLhRm9ZwaodS0GbW7astbHP+OZWuzbRpg3isk2ycSHLAbMiY7WqWxLTNFJjO0smoObvt +a47dzFo0u9AWsm0y7Hw0lJNNSwEAFNOhfZs+2UKuc4PZpxcSn412Z6I6ijRtpZUjvJkqCJi5/nTQ +lOH3uzZKMmgwGrdsFCPUYGozddSgPbc12G12MPjcfgNjETMftlwxBNS6MRyOlLhSMTQAOlmyUkO/ +4irzHBVAqtsjJ4HutNjgdjH1IhBWreqyCHew582FIrKQwJBxIrQlZSiGVL9v32ra6w== + + + joGZM7QR2rDZBOzGybQDhzdx160UduCe1UtfqOZmNRzos5A9dloqOB41j4AxoKYBnfNLv6KEpWNI +WSzxIuuLQkl0QkFbBgasjYZTvdsOjMB/jl+pXFVqt3Pjj84pEP/dcb+T1aLJ0cmjqo3gV91ivAL/ +Dpw9mN8rTJnPKzqxGAZh+52bmAyz7yjY3wVWvNDRKezwYtTvSlLR1HiQBopLQJQmowFA4p+jSa8u +SSbGZnqno+Go9Qk+6qgmedIdujN9pUHjQCvoth/OxAm4w64UxZQFcrTZmFUbf3UkMxNeGWW/LPBy +B5yfiU5bss3RHy66RLESVitq3yn61LpXb8tzpSiH5gaR+VQNbmMvKwQLAiB3ylEbrFT3vSuxL84D +whTqcEH/1uE6jO2kIV1aY9q76JXgKhFNmHE5kimlQgG0JvV7UuW91n7pKgzSG8lUFcerzWAtNqN6 +0KY6lvvYLHNT38hSrKnW27xzDh4Ru54VarVQU10HitrvUh1vMHzsggmqhBmM5wQ0mm+McVRn10F0 +MBCO5AeyVhaUHtEJxGkDSAklncIdJyl0pmBoDfcSVGId2Yk98ZowuwUFkczmXGACMJYjxVtq4YOV +Wtcn3QFE2q3KsneUNWbTsRvSVecD9jF15sw63cSRMaOPcIBsV6XiWs9XOVF3HnYJbJ7bTvOm2/nT +mUepiEjNl5wHU7czt2W8QAYGFOL653zQHDa6UoRdqP4Jdpq/Men4Z58dv+h28k+lQLg/PztD/xRH +WDSG6sJbfshF/Y0pfKzovlJMfBzFh8wQcC2wv0Zz/xhwTj/gJx28p1HXGNwHrKrT1XQU9YPO5E+H +YMbwotUxTCbzd9HJecPfb/wF4+8bYxw6AnnVdN76hMM7GhbQUZUCBvc2BEidg9GN3pXuu1P/fNiD +lUDirnd+a9IdO24s1BhgBHGZusobY7dmshnigtKwjKobUtEc+XNOPsSgWKeNBQbeMcZgmU0VDGQ8 +VrFdBxJWSXFbOYrjKWBkxRVcZGv3kJrR6sIZ7eBLzMyFUVKbNYZtOSTaJS8WS6P8dWbr8nCMHXdG +qFo9sF9XRATahQXmMniDlcG8bBu6Mj/NpgP4an86Axb5XE72+f/+7/9n9v/+X/Y4Ez8D++t98q21 +44+GPT+8ok1lwvN8UokJ1JnYyswSua408mwtf3QksIUO7B++ZA7Pdx4j+7cHwb3GXfSY3jmP5TKT +8uAz9THcOC5tREPBfLcRn25z15Uit5XKXJfTp8xhqvoUPM1M5i2+VKROhQDJMFsEMS18FT6ixHZm +7yW+m9mPjqeZ6QmV8AUye9WNidToeJb7qFxWM/tMp5bvHqRbhXg8+GHoqtq+B/3xhVIgxT+UZ4Wv +5xzzEItmB6PqNHtUm31G0tzWvFRgtm9zX/3grS9QeCeOm6bAtvnkO39z+fiUrefjN9adqtulnjP7 +vdJzJjWNDyKFaGBeCpXb774AQlbpDWgYhffnWz7Xz/TvUu+5z1n+k38gNeh42ym0yOp3Zv8weIvh +gCFP8y8fLyPwa+e7cNQ+2sjFhK/tbC22NcRjuGu0575A8isUaRVb7GUo/8m87u1nA/ROJHcWfYtk +8sHrUr4z303fHG997rVajR781Y0U36ufuGeSSDT4SXf7LdV9OW7n+oHDYGwSeZpnq7Wdbzj+cGbv ++JP2Bbi9m+dMdtgKDiIHp3sJfvB00OX5xPSdzk5aR2SklyJliK3C8fQGoI0PdvhbmminuvlEA6wv +eXoQikU7uT5/McAzuK8GMvmj/a3bYjTJTsG6HD1yW2k+P3qJ7N+0H1NUc+sZgU0PA2BCaW53Cy7J +I3fLXQ4hntK5XpiLiaR5064S5PPWaSHR2N8pbUQeJrAXDr54QVBQE1+AaG4eMeh3JF3aF3/t3xZP +cPN8tPiGgVH31BEg3Tsikk4Xo1Th8ONAhHN7sL/X/jp7QSspDxjAO8+xYi+gUe5YHsCzMgAydHAF +G3UY9IzdyBVeEaqBsDxkuAfuq5WtF74ihffEyXex0Qhu57jm9eV+pfCaztY/W7PsxXbrNFunaLD6 +Wf75fgt8034o3r0dzmUUYarVkOlLTwEm9OOTirRg96PCe63YRvgEYBvhSHpr7xavEITsCxRfychN +jrk7LmUmk89rJnV6e4hWSGC7Ew4s3m40khslX/So1E5cjXcJT3hhIShfYC9yMA+VCn0yRxyzKfBP +mehiOGmuOcrs1Web2frxbG5EpW4lVXiXFv5usgGf1QEf+453s3o8za+SnVJoZxzOf3JXD8Umsb9b +6EwmUaJzcbAnDwSjQ0ZGtZx9PSYRte3H3kpwp57EC0dffAPvfbygQu17cJI9f8mdlvLvxwJBnjTb +pXx7cI+Yp8kalHN97uBWgc3NqgcPuUp960A3Bl8AjKJzXij3Ah3Q1eU+5DA08Z66HRlHq2/XAr+i +s/J4s5lMRvaYMx1G9o6mo/d8d9rlILeMPV5Q4a2jijKrvU5qZwB28lUYktdp5OD44Vjq9OMJ8DEa +vA1Ud8uz1/YgW3s7LiS6B6ESBvAerHDZ+unoI3NTP2qUisLlnS+wHyGKTzI6xsXo6Iwq7XCpO7Dm +82Sx1fvekTpAG6TfwIx55zFYBezxIJi96o931e0uGxXA/oIMf/W5G8+e3NeGvoCKhUvvXzN1fuc8 +X/2ukxqRsbtTeM8GXzQy4KpUeg1vfKJpAJ477IAtxTZ1b8XVh+97Gkmj+noXCNHyqBittw4AFi9v +wca+246kDzgavc3Woplhvtu9bMOpbcAm9cLJSSVW2i+yYfQWzuVjd4ib108zgVz/mIjDtXpU9icv +HHZ3mcxNM8FfVE6vyObLdZbe2dguUuHtlzxZzlcz8FcakDh5QHSaqUMyGsofys/SvoD2G9wSPYN/ +5iBTzKMP0Z9crUpdwrcH6Gu5gzx8lsOgsvuxEs/GClfU68O4CJvsA54Mm8MHBbmrHGx0psDBvcD+ +tCAy8uDT8hd7qAkczQUaEhoDmAuAk8VDgdPEE4aDgtipw2d7CJjSCwKhRxEcslmn6E8RYxBiTYtM +9M0efIumcaigEjeGg8NYHH7sXcooqCF8yr3sq+aiLF7admldL4RuGXwB3ULgbyCyFNhoGghPWnQc +oFkpfyJQcs9lZQy+gHYt02YkZ7skeMjolzwr3KnyJ6YxU8JwQRawcVWelUIqeprFc7FE1gGeKdo5 +EjoOlDnDxudmSNXtVF9ARuGBbpoyTlJaEIfa0eSVb9FbXafiuij7TkUxmlVNK1SLGkNMZE22yp48 +wguZeWAixXMpITwisG5RrRqDLb0glIPVh3iUYafNGCCamrw1vZEhWhCMsX25AzTGK04gw+foF0a/ +PFOeu4m/Awb+RYtyL5kdZq/eP06AWnky1gmMbP3mZFjKkGTPFygHyq8AJ2yIU+km88vAful1Vt/N +7BEXG5HizV1FEmWxbZU6odIK9FaSuh2gZGgYYPUFiOCIyjQjk8BgOclxQaD6hR8trSl+76FaytK9 +7WNkB2gnFEEGgi8gjI4JvhiLvjOFk8NvRt1L7rWTvRrWrrO12dGgGKkmQtq3/VImGRhLRsVVWDG+ +cAdHj/Xv7Hk+dwF1GFG7GmgQAyxQqIVpZ6pSNvi91vVVln86viocT3bfzABk2crzUfbk9hLoyeLI +rgO98vS8MxFVvyqXA2L7KS7bDnF728HecoDahWQ7QGA8f/3cOSm8X05rie7FI1Cbi995rG/T1Oaj +vTFkaQr5AmpjSKFQODVsYd9lz0uFr9vXfPeLS+y9DwIfQL/dJQFO0m88f9UewcHFFP1IVGNr/WcF +FKBkEdjvZFlwu7I/IF34iIUPcQeXdPoNKGrnwfxn5D6f6KYPUuJaafGksUV6gOzjJcUQBnxMvQYX +FYR+0Cm9BZ0HVUzzInGqBmJlVOykMZ0rG+Ci0geWhaL/a7V/1UCTvc5JHkyoHSm9vaaThfI9/w7M +8SJFUGXmVA/2ciP8pDNSMI0VpW7fLgvv15Ey4NOlAhVuF/EORJYqlAFJzLhe9nd6VvuKL708726V +isP5GxVIDgRx9fej24lHgW9Vj3OXFxkwl/vBmWjgz+8D2cuz2k2pEG5LLxRiH+0QfG/evCCqJ82x +YiPrfQ7UQw+sS/7zaSMVSZdfXyXKeo6DFYyf5HqnEaDaX7wrezYFPS0vuR51sKG8kB0BRKo96BNQ +iJxBbD8o3g5g8Zn0veqesaZ0pt664/hl5PCm8S11UOczeyf3m8B8/NzQwj7P1srtL7AuBxMqc72R +RGuAVuAgNKc6kOTe0QvAxw4/p3O0yMlLwFRBLy8NAKI+Lb6OyWZm7zoYVznJKLa/ufc+v/jK1q8b +96CDVJ8oPWVoMJpKTObOegeGL5Dsl0bvVhRDyi3r0u5VA3O5e2m1R9F+/xIUl90pNJlOzXH3qgYC +d+8HoORS+KK/VyqwD1Qkff+8a4TowspXga2qdm+u+vqJ8AnWJc0dzwvxq3Yskzr76skiqs5tloZ5 +0TUIiC82/h51C4m7vYyEz2An8dl5eYP4nIqDKxcORA56e8BCMU/lBudpIMU0iscZkzuf0w8A1VfT +YmSXe1dJLIXuIClx21vfQiZ1+93de680PzKpu5IaFObY2HZPNn0BJLH3o/dcBcFWyW6xJRECdvqs +BdbvYa/QGZ9XkTrBbVWZLfiMKpzUTzeV7vmbfrUOBN3hdvGVGD4X3uuFd1+gGB2dzrNsJvtYbF30 +wzp1SfRMfgR6gKEmN/lp4uwmW69m4DZMxoyD3w9lJrHkPHtxlXhOdV+Ed7Dit7tgXVTqDRZHBwlA +MdVdoKA8XZde9z4T+k6p9PcALPLHRub7sNVRXsC1mmeF5vgjTlZuouIzsMRAH6tvf8dKoVEyrHtF +NqtHlAJClq9wyGexXH9AvAN66T1w6dT5fWZvnCSNUxPbwXUBLXnhcrRr2Qg1SbXbzW9jk4dYgUg+ +BEv5DtfL1gsNMtcXtgSCin53M6nzyz5aMBWHMVAROp84aN09gk1TOM1e1TPfRtrYmua7B6fTTKoU +aHCH3F05f5a/OZS1Q06UL/x+t/VYOGpdXeSYW2pmWPiXrQ0gPIjLUuj4sJqsPJVmohIsLmIcENoJ +t3eynX0vfGw9M3xqHM8Ddai7q4BCWh8E9t4ZQaJ73A9vB14hde8Xm4mHsVbzxiMT6jvbtdLr1k4N +zC/yVHz5mrWQD9KIz/Ks2MzthnyB1GmEfszW6zsbGmI5PJLBVkUvlUgWVcyEpT+fLAikslXKZ5+B +ipg5ugN8rBCts7LPEI822csW61k+efWRZN5yAzDJHGHZBAqCBjSVwrFhtC6rZ8AKq98c9jL76fEt +kJX9IbFjAqKT6wVnxznmfvO6cvDEBF3NVFTzNFBC8SfYS+/oDJgfxZF633GZEZSGx9DXCabL0lvA +RHhIKiBSpLBxVgrfX8yyJ/dkW9XpwclZu9AeJKPqMwswshDg8ue9D4X/YiY8evtkVQ== + + + O1U+vcAMN3I2+iq8J4/7heZuN5Csvk32S9n+cBO5Q3X0AlYfHuWlzvKJp8LJyX4Cq2rUZS1WKpLv +oVIqe7UpLehtCHD+eoI7KGXTOS4wZgtHjX7AwH/6F2GAm+cryEvjhZOjzTzgltoNtB+dX9yXMsTs +Faz5sFna2I2SwIS9ht8kKbBz6DewDQ8FFVh6NxTGxiVf51+ks6tMQHv6JiJhrxQ6GmSTn09nW6XC +xWmtFBgzgLncdj4ydO6BUfaiqAaBX4qChc7wsnxtK58F/61k9mPxsGkvsNFOGTqLn0CjIm3cY1u9 +LBPKXRdD0+YzZCSkHlnENPqAVgBs3Ni9ZS+1ao4Kv9dNQZDB4zY0mU+yo8/zXbXlZLdTEdlLFp8t +4cvO90d0CgDXiio0auWncqD8LAB66c1VjWfV0jNY/cw2UkXQGSXUk7nMaSF+/rmvoto0Fx2VdsNR +DqhBTACYEpk+Omzc6yRbN+IRHHd8rZ6p2gVxSJX2opuKAW+gMbXYHrffS6GTclK9yIhWL5+24It+ +ttYcv2NrkeI2P3KDTeFLpSllKuNvaVcq8gX1ckvvN/i9y/OLbG1+TRkFCjspHA26UyC2cgMwwj5X +ejsNJK01gPPU/hXA2Gm7umW+3JJOISRHiVaxOarEHNrVd26fi423o83cILKjEtASjam0j8OzO7DS +XdW5vQ6Yat8ZZgoFyvsrWMTK7jdQuY/OJImM2OfXJHhX2pmPOzlmngOWDrC0VTY5ajIICYCDxov9 +3NfXRaZw1L6cFY5DoRI8Bj3C50bZfmOAVKPibOdoQ+r5eA60caPyWjXTYEU1drLVhnQXzV7uvgIJ +2RqQanZ8PJ8RR4/lfd1+EOcCFJRWPXX20pyX3l6oAaQxWj5Mf1CT0kEnp2L/cJ9jPASI3iMQDneh +wvvOeIubncwOSq/9eELTS/cl+gFWY7rLp14iNXgeFNGvCx0e0kAhYBpZJhgcJcnbk0RWKE9nMGwA +KHRHjbvMNHy3WTg5fv4udPZfNpUFQzr/GwNE9PsYsI+nBJdqnu+4/Rp+mwTGVaVSep09x0qZYKeu +PYzj0EbBHEYyDC6AaM7EPgXQX7RcfhDqT8VmPXtb+GB3ujruJTMuiWfJUhrzKXFJimgtfAF0BJn/ +fNz/LmUvMuPU6XQ+0roGOe6bTF4VWvlGr7DbTbT4fbrYKT68HxVl9yRqUgM7vlaCsqmRFWLxTegL +KSO2hTB28cDX3yqJUmGeRceSl0DjCMYKpWH2FMjPejjX29uPiQqKDuIHYHC1eb2tBG5gbigCvdzM +seFSAvCxdqrwoeKW4vv6lohlEXfX2atR9Y1Lf4d7apMZ4jgX3K8Wo885YO9z1EBxziJkAdn71AUY +S3/vHhead50rsNvSlfL96/gN8Uh5+1hgXl4c0U94ABh4rLTFTS4rh0D1OQQs+uQ7h4YkeUepy9AM +0tM+d33RToCdeh0tBcgQsJsvr6KF4413Qj0D3HhMcjff71kkEkqBKp/SwZYbAxor7Tx8DAvvo+cI +ch2Z+q9FVp8ToHe4Xp7Hxy/Zk4ewoKw+DAEIFlvzzRfhvELXk3T0eK/0Gr1J6eYiw6kXRzqxrYXz +lv/4LAXhqbegGbIMYMyVs6PvaQJGd5wXnrv3W+rTaoUBpI4bN6fK/DVm9CXQf09LwXKgVBnIZhEw +kG6344XjyBar7rk/2y62mtE2jCK4pQ7Fp4PNHbjwr1Bf29d4up/5zN5LbJ6t5/lXYHW2gYWdiDWy +o2ynpAwOQ6FD2b3M3vN1jh8e1cnC88czBez9Wj+TkIABfnHRBvuvuw8mrFFFi6WdcnWshCPFN3aS +Nxx33P3g6rH7B6q4EcslPoftxnby43YCxlqB13TlyHx34zEI9ktkt/VdILZjQyTe2Y38LglsgsEm +UPevm2XoOQ2Q9P+ZlqPltKFwBXRNuDbnLanPehw3hh1dUqB4n5X2Okz1FVl3+qtYwLNCvaDLiIQ3 +c328S8F8hujBPbmKrrayKgz6wxVXYb6d9M6HYhjVT0zj+iJp9o0H5nEzQSQipxHAqWc0/EUx+5cp +Wn5xKf9CL/bow/osByyLcq+ydXXQAPRyn5bfUpGDK+5zI0xXDjZiiSDQYQD36e1vhM8ekhvRzy54 +9fYe34jMU7WN6OldYSNGnFJE4uA+hLoHqxa+ZKbU9BQMrtADK/mWpnMCLQAmO3hAsTboQEl5S1Re +O8CymEzSB81sdHx2nDlJTtNCZf82Xho9MDfFydMDUXgo3ddLB9mDFrmb5YdiL/T2ZSQf270C/VU5 +q+niCcXpanIban36RtXpZLI3rYNOokdEgqnhaSgjmwql2Q31MurtEO0dEvV8roCdPBPTfQBbmEfS +5Y0dNHG0LoVePDEVyozwvfcF/iz3wdf3BW2nT5Pn06dL807L/AubOnqJm3b6sn0G5L6uW6VTrntS +Dph3ur8RmkzJwMS80wvyidmkUrtKp76A0u00GD2NWXTKfoYawfuieadM+CmyT32Yz3Sz9ML4AlvX +437VbK5EKXeSseiU29oeTsIHFp3evxCl97Oa0imKg5W7LW/s75DHr3XTTssVqm6JXuohXX9DnQJa +bBa1a3oLKPlpnq7CbsPGVQ3d0499Mgw6ZUYGUqoSObHTi2BQ1ynLDl7HSqcKJeNuXyfPn8O6RaeZ +BseXtknTTl8O366sOq0ArY8O7T2Zz3V/43m69dm5Mu/0Mh9Of28PqmadRvb6qbTSKVgXLSntHj5k +zs07Ze7viVKSODPtdLP0wW9fDahzs059AaL0/FyymCu3FegNT/NWnTaIcvTtxrzTMpENdkL8PerU +F9AjeLYVPRQ7vY+FdAg+PGMORPQWn3olTacP+0SVj5Gw011dp77AdLPSGXFXjRgFuuXHevqtPj40 +LDrltvheu/Ri1WmBON19TqJOkY2snevRdyrzNTm7Mu20thekLTs96dRowqxTyPmZxxhRew1vms11 +unlS6Zw9PoRDpp3eBIcflp3WPi/fmqhTX8A418cycXMy3jfvtEoHrkuZ/QPzTsfHm2adAp4Mu715 +LW/OLBD8eE7cHp4UzDs9TRdfXy6fn007fT7vHaFOoXwxzvXrnm2XLDp9EojnaT9m3unZ13hwnhRo +XaegF9Tt61FsaIngSaAW2bDo9P6aKHYHx6adCmexzY3McwzwMdBt6lu/aeav/KvYaZMO6zZN+KHa +2EWdUsF0qKKdaZV4201lYadRpVPQC+wWgP36lpj+wUTf6XS0cyB2OjuM6Ga68dR4DONOc/fkkZYR +RifT6/QG6AV0GzdypaMYmivoND8zsMLKJoc7PSRPYjpGGB0zZ1jS0Nup/AnqFPYidrs9mTSaQ9gp +oet0Msl2RhL9Hm/oOp2yXylR0hymLuM69G6OOm91n6g/dBqvnHZQleudl1HK8u39JTm4sXr7SVTe +AnPlrYHzA9Zb2LH4GqzBTiQvjeurw+vecgL5WhffTnuCYVdyw8/NO7P3mCleHKWeLN8K1O7Vm/Xb +z8ZLUMaY8X2W2nloWb6tRoaHlPXb5vn7nvJWhzFu63yz1axYfC1Udir711P89j34ndR9ex3pSsrp +O7mZMmDsunlcG5q9x1yuEOlNLN/eBpqJDeu3T4XUgYQxk/dvgRd+2/Lt1+xiXLF827uhcpfKWwPG +Br1S+sXqazCkyz3W8u0xxaTvrDEWaA2btarV1zsbO0dPu5Zvi9nTZsfy7TF1uElaYyy7QW2HUxZv +2QpRPNiV5pwK7eneRuqX00PxbT6+r9+VlfpbeTervGemTPRKa4HliXbwMS/yn7dAH74di+Zo6ZXF +rCc3mp7hXxo+Rs22oYWZ34gdJ++BhflVh//E4bPSRrRwlYf/3CL7TbbeMI8Q+2tc5STON9mkggcX +MZGfAztHo4+lt+gg+PB4gPYGtHRUOyJxKgyDwI69mwPWurkD+nvfl/vbSnQPmmHAnTaLk/lbPKZh +t5NNX0DpFlk6Fp1yW9DOeTTvlLl/sOwUCJEvUqePqeeKLB3LTqHIa1l12lZ3ytSAjazqVjjL1VSd +tnd2tpROkfYvd0rr0Au1f3mm5b6m0/A9sl7V3WoQfEBZdoq0f4tOgT0ItP8XpVMwF81cny07BQie +MtadQu3fslNfAOr/n+Zz3d+I23VaDVp2inQKpVO49zXdQp2irlnVTlLqHv0SFyKcf2gP3LR7mQ+G +6r1v0ZLb+n4p3p07tmM/RboTuUUOzPkpK3JLw9Z9Cw0gdq5UDpp0aT4RmctOLaPb8YnuViqq/JMe +h9p10ViHPAnb++lxeH8sQwwhEOlkZfsLjSKdLD8WAONqFGHPtMKaxO7TxYD4T/R0JHaAVGCpA1m3 +BOMBkzsY40Y67xNge7nEZ6cQkP+5UmvMos/sXG5cgL2U1dN9Oz4UfUpgyNcX4MEOVGjnuxJ2sN4u +smPVDC52tAiUPW5gwMQxGwigfyBB3mqtJLNB9ZJHukGph/Q6DwLSPY1SwUNC5UfTuQMRygG3fJ7n +TpyQDv8RB4+NeZP5BTcs5+cLKDNE/1iuoLR+tU3n9duS57cr0pjZDKHyem2DLPfrN0L0iS0Ll8iy +AUbu5r5KlqB8bshdQtZezBNlKXSlkciYsspP394xb4p3oNw8iJS8NOap3EPy2B7vPmtkaVlP2Mh6 +Xopa1kNbsh6fE+kWn44magTKQ9YgcAezHnPcvcB8MQnBFuOJFqP4HxF35NAcd/exDUu2bbUrkT/O +dGr3m96nppZiaHL04U391AnV5ZMd8TTBdCCFiG5WaimmmlXnIr4jrr6BjRZBLzcjTxMy4zCAdoA5 +d6fCrbwN1XT+Ft4Bg7srWCxTdEw2toMVNAbs518QMYS1lP4cRQ4kylFRMnLqmAMj3QIzA4Xwrjrl +2TXuu0bJ7b6z33VAVjY27+a2a7lFRq/JKPznMaI6pDCQBeCMoeKJ2XICjKkXFP4DFlRxRBtpA8xP +5oJG2ji/lIekGheay6xsOrJ0uTm1mmSG6MyuEwYtzLgkisV3GjEuSbvspIW5ZT09YeoLWAomFzqj +0hhoM48zS7HkC3hZ3zLEScW79mS299tlLZ82QdbpSBG8NkOaHR5bysrzK3E8blQ6MCRrhU5aOl/A +3QoCK99WsXDS+TUrOAzYKhYe1q98MVBAYUpeAlht6GJcYFe6AqYVKF7HJZ3wisDu7Y0YL5NUa3VL +Y+x1skKMaTmax3GNtX6YN35iMFxn6emC2rHm/AWMp2JmDFoptKYCmsrdfW448DGVgm2+K2eHmyvb +lbm7721vhjI+jzWsZAUemVQV3EBL3Dt27jd33Bofsm6px056KotlRzeCuWJY0TEF0/3ivEzpqb2J +pxuISMnGoThwAVcD0emWi+HEYdurBoJt5IiFiPqoQNf1owebHB9KaoOM5Nge6nnajKsc2uDXEaT5 +oocOLJwaQBPcsNFhTNmHxQY5slc7fAEvg9pakAFouSXccs+zgL1YdssAjhQG4Nbetw== + + + nl/QBcp97pCu0RWc/Rl6TV7x9X0dwUO921UQVWFGFp+nZYUzaGLhTA0fC5sc0P4n7ZY+xRMrO2S5 +3+KWZg+ykgCyPG5xDbLkLY6+oLeTvYR2gx/DuWi3uKnV7exdAlS76c5DYudLONa7ZPWjsXPJ6jwk +g2OtBm9hFDu7ZMHUVBtJXH3PbpJjGJdw6ta9IVtJ+qEcz7VieQH3BqCDbwpNCEWqGFbL/VrpZKqF +38cXsPPSDY7h4e79Un4fiBZnX5+OFVj4ayB2OFeUrOKbGk/DWKNKZ+Z6VRrQgbUzUeTJLpRpiOUT +vSrtBXdYH0PjCdiPx61/gT685oM6ilDZYp4E4YlOE15sv6Quw/ZTc6bzE0X4yfJlAW/0+EQv96wm +5AvYUDqgHa3QW4QBHF4HWJ/DmrtDzKuDk96nE3VWuizAjk7QOckhtS6L56ISdfCwKqiO34CzAs/c +EIPlrlNRch6MJ+7N522c813NTNppT0VdH0ECYFb+VjNvK7YsrPytEJiHzWduL4FN4wssfUiBVs1e +5Plcw9Eakt5GI56JYzjL7kAMRbYmFSgST/YCx7vck+19E2CaE0JvQlR7PhhE2kU0pNU48yhMdSUn +DHkUfOoLOG9DF+IGAqPins/4LJQIGMu56wqVKvUz9a2RYnqONu2FDRxt2tMf4LngaKYekjxATOZ7 +WY52rXA0yXr1osHrgTlzNJ/LEyQIbHGOJu/K8s1oBRwNrJoZR/O89wEc7xzN4LvAcJbnaBDK8mev +CI7NaVA0F5JPcRK+gJk2oBFCNyM7C1p9dGiuozDRK228JbB5DL5x+GzZA1hJvrwHv63ZkEvNLA/2 ++fnMbDNjD7w3NguA3Wx4YrK+gCWbXTD6QbuZb5AtrbHEF1FQwKrpgpqsOIwzHHeqvSUU5IcBcJYP +gUBQLAxq3cm7MxztobtL97LJaQICtgpfNZaFYH4RqF1opSF4GltGv1cRaWPzarq0xXd369abpfJd +WErDW0/6vb0PFgJbXr9/+jaThV6lGFw17y4toxSDcJbR71VQZFm4uBRDcEz0ezMosvVqAcetNLSX +hYjDPH0vLQ01svBVf06MegFPVxKOBPmPaRyWKCs1wVNKGIalLvA6sVkSNSqjLk7f7u6W8VXr/PwA +2LK7WzUuk71tH2ttgzFX6q60krAXK4sIrGXc1T63OT3NA3zeJGw8Vy7C6XRDsqQIFNvjuL30gikf +jxnEUj6ecGVXuhBMVO6ubRmeZx25ZmHvg5FR7lDpYnM1p6uLtgXALM9uZG+P24B6AIze3juprsJD +AjDGe1MxLGIQ4Uq+xl35YDEwi81+bxt8iynCJ/nvXQ3KJUUYNpcokfHWVeRZmj0dmloW4hqgbLnp +x0ZsePm6Eb15KW7EsvQLzJsrmmXQ4Ztbls+hU0sxYwadLmNo4Rw6+ww6xJNXkENn2SnKoLPMFvSY +Q2efQafOFlwmh84+g06j9S2RQ2efQafJFlwih84+g84mW9BTDp19Bh3KFlxBDp19OzG3eukcOsPG +1WTQyZbFkjl09hl0SB9zzqHTBCTbZJhdBEtm2rZ1DLx1JpAu2MXFkEw9vQXnwO1dd/lSJZ2NvHAw +bEGv/Zo4B9x6eh8LWmnvbelUZ3wFfcDGwnja29WQqzZXVJbxITfJYJ2vzo2TE0V7xmcHzD4Oy938 +kK/PKXPO9fx0nivjfnGP9IT3IVlkPjp4ruyGZJYyB+fiKWnOFa8p6kJBlNgebwlUM0+hIDh+zDQY +xLvb2MppjG4GW9pfdR/bsp+az2WymzYS0qtjEFEyWPNlPcY42c3q2EZrJTklu1nbp/YHDipuWbQN +BtGYpk5mSFGXzaDJFHYHTBuCRRpPbJrUt1Pmozue1Sh5MnrRrrQye5u0dQilpxRTlPt26jLr0Nm2 +B8gyO8uW9TGj68zJcdgTxjo3Cfj22jRodoETq7Kl2mWZBabSlPR5YI5ql+s8vrlTDLyHPL6mU/7L +lsZpZZ2aZp0EY69KG2PggwefW1aDypilaFqvn2MMvOsognZZ68E0XT+3eXzCxCknxo4YtNHpENjK +MkQnysmHVWaKF2DOFO8eY1oH65IYc0wTdT9JhaMthDGt45fK3d3HtIFOFV1gvUkmlztd1uDzNZpZ +8la/Mvdb2ufL6UBYAOhtaiWyCYg36oWE/7zZ7u6KC2NPtvgcjL2PimtjzwqAPkZxARBOV6OAdZZv +1XCXKrfQCr0SzvJFUmnMtwVMcXN2MvhsXdIwK83CiDOQvV2OnM8hzdnFkSeakP2VJz6DeWWjR6am +hlD+UGHmAuWqkxErSv468ubeMTGVsKbkkCBn4DrWGVEzU2m+gD525HbHK/vdUh/7OvLm3rFOs9NH +EC2Mp08HT4NPZ0pYk4BHj4xmSJp8ZDAoyov7w2ZI2s3sLMVs8MS4HZJ9dLpzUpzdkPR3d8R1/l+c +krQKj8wx8sgsGaUGNOFtFx4Z8YzPIT1nOxXfWcYjo7L3j5f3yAAAIZvoDg9paIt4ZAzZgst7ZGAa +ms4jY5WR6pSfx3jyyJj6+Y9dpOe4S86BKXpgwzlTsrvwPViqg9AqyyeKsmwdN+5GWaYPryNbLojB +PidxfLKaSAa4LqnL4GqcOmBqqZBDTK+bNLQFA9jV8gUmkFl7lzykjxlCF0yzBZ3y6jwHzRojVFFe +nct4Pdu8OlXqqE2msLMT9MT2kirV7lXplrahehfGu0jhM5eCTsp5twpMWk0+HOxlFTF19vlw3u8f +WyQfziwK+mKw6ny4JfIsPOTD2UWori4fDnqtl9yBLvLhTG4EtUziWjwfThMNJX0TXHU+nP7eUZwR +t+p8OMdbAlaSD6c5sXIRarlYPpzeFrM61oGZbMtn1kMBt7KYSABKGxNppVu6iYm8GbmKiXTa+9Me +vawakEcBEstnoyM4UafVdwnHTR6JJRSsjyE4K8jkMkQy2MTAO3M0mFxn7RAzxjuratlYRDwHv3cN +Ec/Bb4eF0G1CS2/P3c0y21BJPlJ5FZbdhgCY7bUyZnzMchvej91uQxttHOLbm71oSmiruQ0YwfG2 +fSzykQGclSRCFhLupJgjHOsrgS1u07IKszZeCex4G5rWK627rTEcNfqwYPKZ/cVOjga1nJFKbi4a +IKKas9XFwgtlpDY2X10kkbrMSG1sNt24DBxS/VaSkfr0vZqMVAhnFRmpMF9s+YxUCGUVGakQjrtr +oHUmsVlcH9og1pemeg4yCsfE1dduw7ult6EuFc6cj606FQ7F89tG9KwiFc50XVaeCre431KLMXvb +3YNduUQqnPoOIpQM90tS4Uy8Cr8gFc7cP+bSPru3UwzVrEB9f7Jd4tOnZayqmxvhtfpYPu5gFrkN +9IKgWFceRRcOZAjM+mY7jzqM4ZJhr4cLqmz0e5dHOHa38wJWbibylF6ck5v1eXVPltfh6IWD5B01 +EQ/K/oVV46Jm/YlrgEpcps8/y/2bxmthqz0vlpLbmZdSPX1RzCRmQcD5S/VD/h6VDS88FCeZbIWr +H+dz8VY+n0ucwCIEtbEkjgJ97ZBFj5M2F8ss6wxaSWKO0qN13plwmbpQk5c22W2vdX6qdj6rOmU/ +dwP7GyOrDDvm/s4u2a2dsOyUKNVzdhl2gfPuacOq0zebTsuxpKpTfS5WKjJVeeH0yW7M3WdVrkyo +SwHbDNklu5FxXafaenx7A6sMO25r65ubP1kluz3aZZ0N7DPsRvW6Zac71c5n26rTjn09vss7606L +Z49lS/RuD+m9V6tOL7UZdmhVwYYVZ41+iXSectluz6wd9ipoWjJPVVcQmfAFbieKzipnooieSVZS +ujTv6wWqne/YRcitVoONDPFcNGdEFzuj1aT2OEeo6r0m1nWsvl0MSXUuZjMop+BUpzgPbL2uspKc +WdkRkztVXHiX7CrJefLCPRZch0g6ZEOiOyE9xPU5FZGzjetzT08OReQs52dW982p2Ijb+TnXGnCN +dKc6I7q71JaoH+d+v5Q71oWILMNd3Rags/f0LpJNt5gfxms2nZkdINXiXF02ncv7YZbMpjPzCer3 +y/LZdGa5dItmPlpn05n54s0j7ZfJptOgRdyzpvePLZVNZwbK4YaQBbLpFpTIHrPpzM5pZFm5smw6 +s1w6tb2/mmw6s1w6l7E9HrLpzHztUgX21WXTma0u8vSuNJvOTLlRx46uJpvOLJfO4rb5JbLpjEP6 +3LLWlBbNpjNTTn2BVWfTma2fSTTUktl0elCONYUXyqaz0i1Xm03nHmPLZNPpQOnPxFeUTbcQxjxn +09nmWK0sm848t3rV2XRmAEAvK86mMzst0cXAryCbzow9aK3XVWTTOZyMrCibzlm+rCKbzgwZija+ +qmw6p0yu1WTTmeXSWdbjW94AjCkGoKa+mKerm6yreBmLVOprc7hMfPp22Owa5DMjq1o2i9erMwxp +Bk95Vl2vzlq7cIenWSToCU8KljSRkDAn01GxcEkCmgQFi6xnq0HphuSWFbioLqc9mFpoSBBjYFCe +yi7bDck8kMKSw9jgyabssgXLhFJMaxEdksdTnUVEbyfHDoXN7T1zcrUsu0J3S5e5U91z5VIlX6TM +nWV1uRNXuUouy9xZZXK5S6RzFSBhH5+sFLpbbq3K92M3VWZsvVSuytw5ehQhYpYucyfqMPaF7pYu +c4dz3xwK3bk7PBqfrOCeK/rwmrRfRPd5FicrC1Eanygq98K5PGBqB2G39Gl5ygML1DnGHjrRJ0yj +g8azrQfeVSKdm4hmn3OGoXUQh+v8QtCLTdihhyAyiB1L15+Wkt1V2AI9bwX1+UTw0lTLOZvdDWV1 +3lO+GCyY2KWJhgJE5RAP7joaCoByjB9zHQ0FgLmL6LYPbEa8byWZj8sfhcCKgjbXgYur7xKOq9qu +ZlBUkV21VexABMWQyW6aKeycy46AuUqstaoBoU+srQ2NibW14epuBYTAVlLIGNEYGK0bZqaWXZao +rJuh0rHeq10M9a7xSBdm4hkjqG0tcasY6s60t5LMFPnmY++ahBFUdb6qCobgxYX1EbHrvX/tqVC1 +1ekbLLy2tDqBodhFdXqAs4JbAjCcZatVYyjSJjS74dBbrOq1i0QGTye84YjJNrxxkcjgygO/dIU7 +Kb/SqsbdAtvQJLhi0brV3irc2WU+LrENJUITK9ytpFKeYz6Ru0p5y+YTyZXylt+GNhXutHlJbvJD +FqlwZ1fvFda4817hzu2t5jD7afnE2qdvRc2xsl5dJ9YCYM5qjs+NooNr0y2WWKvPfGSX9R/B/MJT +03Rob/dcITgL8E3DHREQzkryOU8Jd7aYIxzrXFhdEpPP6ZoJVC7PS367WRKT+lQUMoioYRumQg4L +4cKvJdV9c5nG5CaJKXjwordEVVLMTRqTdpIOvlMFlLwulmlMqZCrDHVbs13elamQm13pJokpeDDU +K9+L2pV3npKYrCKIYO1EG0nrTTG8E3N4l7iVX6cYmlyWeHePa0CsIsc1H7e+VQzaLw== + + + XivSeSr3iFBprY/dr+5qqnt0+raiHNd7y6upvOswzamnco8OlfISC+a4qvanHIbhIuvZOccVDMl1 +1rNdjqvoAYILUeXN+5NUP5jxVjmoF3pkPpc4vi1sdY5rvkDhMFKrH4zeIhz4Vb5A2X2lu6dSmwqm +NwtY8CDXrsp3LP7SJOGdHV6pO9Xkw/kC062b+wu1q0pbhy2Vf7y3yIcLWyfhTeZvKVLLk3VpeMSu +Ve4ft7XNX4WfrZLwniw7BXPZLI1py7kS5a2Ha8tOg0fN+IdVHbaw0qmcyaUg+IKlVJ1qU9OmQX5H +qSNI67Icw6HDx75Zp74ARLC+5pwmDa+hz/1To/dk/8KiU24rwJwV3hQfrD4j7tWm0/I2Z91p+XLr +waxTVPdNqGhSK/WdXtnVETy5se60WLwuaSK7QLfb8H1U/iUmYc53DxLa1bdoR+cJy3bq/EribTeV +dQExkhrNioqYBHO+Z/RKp3xYI3p7tMIzb+MnlgWdy7BJgFQ2jE6DNFXMnAMnXchmAPtAn9jk6CGx +TkkyhlZZDglSsvWg8m5Sm5wTm6arqsyCHLoOlVncepIK9qFVlktnqMwCOqh5CUGzy7rT3Ty5RFaa +Q4QmxpLPHT3pDr28zk/2WsO8O89VFi2GZIjS0u8X10j3FKXlC9gNytpP7G1IgFtax2mJ4zHExurY +VfEpvas9vC4aa6YsZkoA2Ecurr528MG+FFd1eeN9bMPdDYcuspFs3ctuT3leisvcRKvkJBqujFso +2c38yNrTvdYvxQU9y9pbNGEW4LKX0JrdFWeZL+ZktRjvirMxgMz9Y9qgEZMj1kbJU70Daw5TWpmN +3CjpOcyip9444c5qH6MTK+fydZqR6f38zi47VI/P0qvCfBsCCHrCxLs+YlH7KXhwZ3046C2RzFDP +YomybPaZTJ5yrJKe7jlQDUmX/9Iu2/mOHbVxzZBUofriabVq13pMBextu0jlVN9zZZMK6FTS2GH9 +lJP3dtk5Ucc1MejqGptWmfEAzKmKTlCfXWsDTCdVlsOYYy6P+0lqTy6XxJhjPR1PGKsyTxbADOnC +ZtqhiLEFswDd5gC6vofEKkHMVQ6gTXS6iyxAtzmARn+ylyxAtzmA6hsOvWcBus0BRF7rhbMANaRi +Y2Hq42C9ZQG6zQGEGFs8C1DBpz3f0OZYec0CdJsDKNvIC2UBWgzJkAOoPq/E4zHOavmifO4rsi1T +lE81l19YlM/gVfglRfmcKrKtpigfzhmxV1CWL8rnC5hohSsvymesj/wrivJZ10deZVE+V/UrlynK +p/YqwEFxloMSUeSUGmxd1W/5u6GOV3E3lMu6fq7uhlq6rp9qaiu4G8qqrp+3OKVF6/rZV/Vb6G4o +k7p+9l4hc0vce10/c+KzvRtqgbp+zpS8irp+9pEhsudqybp+TplcK3Lo2lb18wU8OXQt6/rZT03n +u1i4rp9mIIaqfgtUADGt62c/IbMI1UXq+pmmI9rdau4eMa4zZU3vgl6grp/9zV/ymfiSdf1sBV0e +SbEV1PWzdwt7uoHKpq6fvalrGgW9QF0/szRJZestV49vBTnvnur62UOBfv5V1PWzP1DxuYazTOK7 +PiN10bp+JqqmqqqfujoDsURdP902JLRV/TR3dnlOTyHkun6Oea8rqetnX9VPpuQl6/rZB1yrMlKX +quun5G+Z0aLunquF6/rZIxBpsCuo62ez16Y9ekX1+Hbtobiux+dQTs51Pb6l6vrJUEy3j9dsDkNd +P5u8B8do247Xun72mjy88WAVdf2sZPiN8SRxsfwtF+q8dJLotA2d6vrZnzdrowgWr+unxbbeWly0 +Hp+3IA3renwr2D5yVb/l6/G5SWJyur3BGKvhrRSfPiN1ubp+Gse2oaofzhhavq6fnCplV1d06bp+ +9mqOBY15rutnX9Vv6VubxLp+S/r6XNb1c5H3uoK6fvZV/TzX41soC1fHLY11/RZPhldV9VP1slRd +P6MrWV3Vz+qWM691/ezDu3RSbOG6fvaBTjqf0sJ1/UzWRVXVz/5eOPd1/Rb3W2ox5j3nycKuXKKu +n8K4zKr6LRw9qKvrZ0sRqgogy9X1s1cMsfW6fF0/+4RYUSIvXddPO0l9VT+DPub6JittXT9rJQjr +MA43Wbms6+dKh1m6rp96JY0HODbZtRb707yun71wsM3iXFlCLJb7CRPx8GCno51fm0d86O+V+sQ3 +KupkJXhq7dq1D7zXpS1qqEmiMeX0Jn0wVufBY9+U2FVIIyHjIwUxROK8w8n4PNNYotUpzH2jpp8b +QKwcb0Qez7aJxF2Px41gPtXG9mn6KE6EhhuJ1uOYoSefx6V0/zl5eb0big3Cwdx3jqh8nGW3vuc5 +buOp0abBr7dMgBX2Kjun599X7Hfv/tEX4Nk40xJOS3fxk/hkg62WmbfcVe/6sF075W4/650z9vsm +1Hnfvs2GmcLXZv3qpJfq79+NOoeh4fcr/x2YZIbc2cbt2WFwmw6VucD749FReP659ciMnjopce+j +3M70db12sxGPvGQ2qI/vm8g+HcwQpdxJjii9t46JMrdzNZm8JUOTqXB7NN164ZpTtvl4IWda1iMH +idhtnK4mN6W0t6/EZPo0gsXmkls4t9rIQzT5pXsP1ddktnU5hga1XAIS1pOcv5GB3WymemyGLIQM +MN3ZDlwXenvDcq4oozHUCHYutm4e6unt4SRR2qGYj/lWv73Rhpmkx1Jy6MY8OmbOYLza6RDlJG5k +S/V6gNjutJG9fzHSquxj3fYBU7vIq5LmFH+ramqArZnhIc0F8nNfoPBQ6tyhApr55/LVHXeWb29m +ErP940xi2t4rJbd6F8XbDP0C0DZMl/s3d0/ZCrfRBHBuviWwuHxmiIz0eJjKeP+S2atuTNCssoMR +pOTsye3ta6R4c1eBv8CEL/pxmLQbxWZ9mr2fIMuJSMxCMBrhdYY5cYKNB6VfZAj5jgFG+CH4k99F +Wb+A4RyNwZ8HUcRhtoJAij1OwIN8XPqwlCgVqVMBgK0QkUI0MC+FKkdHZDT4OSi2et9JIpHmw2ig +cHDP5G6e3Mt3GwkSvDiIqF40tvMHvoD0Kh9TXlG5h+tD6cVRQnlBb+99ZKUX56T84kVEW/lgV3mm +9AzlfjkfVb2CfYtwymDXA0zsgpk+ReCcw9Tz9AswwPIViW7CISuHVzSY7uWuarrNjwjE7CVA+cGo +R7a2+ZR8LgZYISSvHNmKHZCwUQLmLQ3I1uERRNslKX5zeY3AwqTW/S3YcwTmFiOxtE2FYwzU/usx +pVMqfJjZw73swQPvq1w//rGbvWi9VwsnRxs1hSTlY4G81nANaA3OHBWulPbN4AFKXhTiZfVAhphj +ZxfbnfLzg/CRrc23u8WH9gUBZ0Ui6sWU/EY9z18y4mrcv9ASedUZ1dQLh3xL2ge3MYRAqnCZhxLw +NiGR/S2A3XyGtdluSVHdZW9F7WIEf9PyLwaDKO4NOPDngwjxtVWCS/KQkL5+IORfpGo0b9RLVxrN +A41e+ALiq0JvW9wHvS8Wz0UrabVnpjsaNiNzAQs2A2QlZDQ6NpN6Ph+Fire50+NcuD+BOf1cJVck +4nUjm9FX6Q0iagNcQEA3uoblczHALcUdf9eLYJLM3b1Mwaw244nu5sUOvZ0czAgiFJ+K0wXMBcVN +I/ck+JMJo6xgsviUgX+mwEba/kpDvhFVrf4T+OYG0kQljtQgGKkSR4Y7WX6JQ8O8krBwwVQImSB3 +VO6UNHsSgqGi32SUGL75AtJCnezifRfNB5ryM3H/Ah0ObucTsPD8TSX/1su2NUyoShBs8wQuxImK +Dshy7htqHB/nCGNnoIP7EeLEcOpPWVEtAawHP8PMFTIcLGls5ZDinDWNtJeWMaQ9g69OoZqTAQJc +mGO9ZocdlVTKHXq2mc9ugs+uZrDxjebuA0lTCqtBRLtFHYhIfvuwKAvoChVK3tOKyoaebW6mD8tE +OzAsTCYHo121CgH0A3SvQimggCA6m2xCB+Lu7iIrg+iGNFul3IdIDeH1Kz7txeidvUcS4LgQhZQj +2ZXoKaSxOH76PH2FW/xpKrGZ15kG81tBscwx9XEpa0rPipKECkxDVXMTvrhHuFPpyUFFadnN3O42 +JN3kgJLUEnw/AxB/m0xZX2wZFsKV1mW+ATvdwCvATB93oBQrvW5Id2Qkt8Tx9K/P1Mr7fXQoYiwX +hk4PfClE5Tm++XUN8BQpgU7jMbTBjbdFQC8cGFk5IiKhMK3JSHhSI2H+eC4jQXdjR0SFgscJ3VTd +3SGjwBcI5x/aLxISwHjUSOAnlkiQULC7rULBYf57pELBYagwQSgAlCx2K9X/RkvijATAhHoJ3CnN +n/dEFFBz0owO8K0a91okJBTCvtsYJYoYCZPc/aOChFBz++rJgg7E62jlquWAj5mRki2IiHda1EYO +S+cAyig8jyFmBgCti2sQ8QW3lBKfHCaWXI2oNU0jzi+Nwoamo1ELEK7wgDh/NO5iGnTmMhQSQTQO +z7VjIO3HgO1KW/4UpSQQ3JayGtPN8kle0y6xq7SDpdIvLOq8g8UJLUtj4eVpLLHgGFQ0Ri5LY+Hl +aWzXEoQLAJjGYi7IVANCPw0HVIo0ZosJYkmKSER8AReYsAXhhvP5ArYgrFDpajUggLja27MQUSVc +EzaS+6YgiGWnodoZvsBi06A8jQHtff0oaOf9WWEOTvMRPIZJmtVc+vVG6WWAIpHdYoKKeh+DjltS +yxIVFTejCE/cknKj3JjJIYVbUstucYrU/knp+BhFi8ZCqF0HBmlmij0yyCpTNP10+TaErQjFpiu+ +pPZFs++8MxRt27tejHqttKNEovEdQ9YwvCNi+hmDX8eRDUIfXm8i2y8oHSduBVHQDzKFsXdNNoWx +by14cPUN/szE8J/P0w4yFIP09v7+W+k1/Ijqv7xkPmRzNSR7/Z6JdiiUkuzT1K7KsaaaQToTVbnV +gofVtPSiFFdeoPsuZBcMMHZVHrfDm3FO8pSl0DTC6p7LmYjKrabquVxSHHovqCY08sJVE6JXoXxO +QPdABGemAOOZwpZc8yXQkKZ7GcGOs+aYhGR/GZPV620qmA7BpMbLuOhb4/KQci4JXF1uQrYq5+iB +CLb18EiKPtH7UiRxWutBflDH5j8V5lJtqdN6HPdChLcFgurXAsVoMvyS2SNuthXDG9GYZHpj75Mh +Tku23usJFxDN4PksIRIqiOT/39uVrkdxJNsn6HdoGYNZRCv3hc0GsdptgwFhhD3IEsiAAYEFujPz +5z77jXMiq7uqkDEjxnfm84wyuiurKjOWEyci22vH3l04s3F+P13aCD9czv94erJRcY/urTT93fzZ +LXbj16V6uVMHT18uGZKfVvuM282LcBU/zRrZ9uiWVRro6pPbsf31asO1vw5+fswyoLt2anur/eWe +RUwQOYHo2NajbzDjoxl+F+WN23o1N3r11sHdNvevpx4+XxBrrs+4nX/6++KDsLCCnQ== + + + xbs8Ymmpl4mfUI5Ate3i5kkluq79cpkWf7rj9e69bV8Rwz7TmPNwcsmcL8jur8gpoetY0cXNU9Q8 +tLMgMtw8syB/xLC/WfkHFxj10VX+fJ9Y2IVbay8evp8pVfVi9dwZeif/5flr3x52amdyXIzvh+9U +axf/g482Wo48ItrJ5I84djJOl9bpYU6Kh9l5eeXVF3vX7erjvMv15Lt8Z5a818jioZzfc23FmRXd +Jntj42Qh7wXDbRTajWcBK/bDrJXvRFP/99Kk2BynxZk8Xbt78Gp3//b+i2cv9qark/OTtcu3rN3Y +e/rm+v7u7v3df72/+ubJwevdvffTc9O1y/fWb90q8erukzdPd6fsQYm/5h7HoNRaa6/pVyIHfTfK +Ql/9rd54efPY3YvbV38zm5d6XTlM8b96e/+PldXnvws6WTnzZHZ8ZXXr6c8rq+76vZWTN9+tYrip +NMTizT6sh/0qSpJOH7u6u3/l4NqZ7+c/jQh0Rsv66/0bFyfHr/10ZffuN2vvnl1Yu3n50XdXH11/ +cO+btffmDZmKMTmob7ooVh5S29zfd+9PrJy68ENYObv21QPUOK/Ku3x5taytrJ765htIv1058+MX +P+D9fsAHX6+cveyfrqx+//Dmyuk/ju1D/0tjkK4foFHOnWnU8LJ+c31rq7PBO29oGBM1Ibv67BmY +3Qd/NB8LkhhXL0jiNQ7RiXay/fX77ulmRaI9fSvi8NxJWOPNs8134Ic92hS/bZx73zHOt3qRytzc +fl+7EPbpFahl/Wly/O+rQC3rT8p6f3oFCkOBFisyvPPNcu6txrLfuU7IcFoc2+4VKhqq8IXdVPMi +9n9btvbO7TXE2lW5wR9fynCD057WzVm787NfxMMzvVrU0xMzCUib82Uc/7W7C5X9kazY1bXtCyfO +Pdv7auP6hWvh9xENin6EH/vNVV2H1aIXoMoT7q0vZzxsPj3b8Mkzdr9jzBlPfVt+rOXG9W++2r1/ +9dbTiyvNmjYf2kWZyQ3qN6debR3rguZ2WLz6dl+9dm7Tn642l7uzsdbUfuehsTvzW6fkL4EbGld2 +HrtL9ZaTvdrZRq9D+/tp4BRta1/e5Yxn2QAlw4cdTHr5s+n+erzUtp0+lHv51Pc+eLzit+RdGN1/ +/f6P43yXYT/Ger+HSrS272YWXuCv3Qy8pTgaeJMLra3i0suv1des/vH29uFuZuHHaOdPT6ydaDS+ +huPv99rr3t493eHsry7eO93K2+KaCLuhzqbB7p+ubWusFeeCCHTzpAbm3XcvkW/dPN1civ1izV09 ++/MZlrcXYf1sOwPMGjdaZB42/HXju1PtDFq8vnZ4m6D4n04h0WfaNZuKZwgnUQqbjTC61tRPjgC6 +hmbNBcTXLApNs351/e26ufrthTfmQ68j8aWVmS6eZoVNa1FnuG+a9dx4TK77h7MtUr89t/bJNUmd ++4OTHYvf/tBtXOoTWj/2L679vkwRDyvs4Neif+wKO/tnRrWh/f0LX9/rcx/m1i+rs+EUzy9tbJ2+ +tihibYyKWJAd65ewHrlvRyUsc+3CbZ1AK14/fjjFwWCKmydu9k0l3Puqi9eom67+4PCzotCnm2fw +12whW6OMv114SbR29d4fwJf76mYkOD4agdajp8UnX7PHEWvSqlYrrZJz/vXdRflo8yPlI1jOX5eP +WoX4sNqJ/rbqJ9ZODqmc9DjMyfEjURz8UUNdgsf9JWBFry3Bo+USyLvgefqLAKD/F4uwfeGH5RL4 +n1/ZslwC4OzZqIy4/O31T1mET2H6P85H81+K/PEa2kfLiPgXxXWr+MtIkT6xEol/L9Vn6GJ36uDP +nuLTnmFr/+MT6L58dIqdd59nUjeeHyys8oi7ceeXt5+g0+Ite1OMdPrO1p+Yxacu5Z3dd0tveaTC +7KU7b1b++hk2u+7Dw59iv+tcCJuvl1OYm99vPhmUwX9Z6O9mb+PN9X/cvDvSMf6Mwefo2L29z9ax +3fef+QyvVj5bxx7sfbaObb75j1zvhxPs7C907CMq8uhjr/H8k5fyT3Xs5cHn7cbmVs9cdcUOW4mP +TrHzn3k+RLHxFLv7n7cbm8/fjVSqrdinK9XmyyMo9uD3mC5t7h185mvsrxxmGZK/fPprHHxxxGdY +4ORHx479lX26d78sp1j56sHze/1n2Nn58xjQi8gfW4md3T8+5xngLXeef6ZS7bx897necmfv/V+6 +uo/GoZ0/Dno4+UgmvnOw0h8+OfbFYHjiGFMFZYrRjvj1GbATacSQmN333xQCzGVO10v7tr98/Yum +8l9d3IxdF+YWU8azXdfrL+80r1w0rYKqbn+dVDZPUuHTw1SYmfFqG67PmDfPFpetLQj2X5Z0MFZM +Etse4/bfq0At60+8y99UgVrWnybDChRosBsbjqxYn+i5s36GxFkjeu7cOtslqQenWxZ4Zz5Tbg2/ +dS7Duwbo38r/PMW+rN15qNP6r+/vzVpr95ezU10t6hb38kyfKdy8PeNd/JXiy/ndx6d+W3+ert++ +8qocKz3qWmlaSbzbOfMPSgjL7H3z7tp/NONh802GM26Y5Yxp4+K59csbJ87/uv48f/f28v3Lez8p +FXfl59OPW6HpycNFx/R9vzy70N/dnflqj4PdbgTkzl0924AT7qf0r+0vHigBt6SG3JVH/iZqI5ss +tPCvtrE7z6Jya8rQvtyYaY+jXXQ9n12Uhc72edmX265HrPUY4ZfPQscfPYrtXR6aY0zNlrSanjY8 +tMH6zH+vvZqswuEN1v/F9urJ8T9tsP4vtldrLerQBuszR2mvfve/lybnRaVuWbt1be9pv8Y0OX5c +JPd23x+8xRfi1pXdZy/25tv/3t2f2Kn+18h/7TRMXYz8J1cRREjnO5OT//Pi6e6brXfP3/xzy7hT +0/ne5PjW2uX991dfPHn/4s3e9v6/p+dEZKdrV968eTU9efnWves/Ta/96+2b/fdT3mh6/810/d69 +UyhvffR7D168e7Hzanfw/bWH3883bl2dnpu2J/lXvK5Pgz/wROcxlzVb8kzyRb1KVmNrYqaX5Z+H +/5wcyKtelT9vT8zMyH+8vPOf/6H/fbg9MVwbJ/88/LcMvpU/fhfRP2Wpvp/+/A8zfYrp707sLEdf +5SIzKyXl6euJn0VvXYQkmOSncWacr35aZ94V66dplkuwZVpm2RdXpuuTPDO2miCSFJNcmWcumYxx +zM5lGUcTfZZxKMl7ucJ6uRvn8iYl2T03q9W4qZ/ZkuN0c+LkCxEfzErFQ7gwy/KUfuZy9tjtmcGd +wsyEUjCjt7MQrcNMNtownUOSXUic27kwlbHzmMrLVDK1NzOfjcXUpvI9nLxIEQWS2Z3Vb5oiN0uz +WFKdPpjIVCVTkGLJmDklazHO3vEtQsB1aVZMyHjPOuOby8w5VFnTOMtZLpCV8s5PrZvJM8vHdVZC +4gXy+DUVSKqPsi1WFsrwYY2TTZBxTJFj6y2X0swSFF8kwRfZpWywkLKdLmDJi0k24uW9LOz6RPbA +4BFEELMpsjfVVLn1chyjyx7jgAfA7lpZr8r1K9HJnhVRAN6i1mShD8E6i3GyBuuY5Fm58lAAeQhs +VsZ6xZmsY5KFDHKpT7BYWUGTZB+rM8FiHEJ1Mi4hOo6d91XmlE1yojJTZ2fyuPJ8M+O9PJWVN/Ty +gvL4scrdZYWrC1yYWbBRlk4k0WLt5fGNLLaMbZBds6IoVfTYQrVwgbxPCDLpVLQzeXnes2YGO3Az +k43H9z0sRLbAJlli3MHbgu/bGR5eHsGJLcFwasi4YGha65PfDnc/ebp2a+/99OS9Bze27j3ffrt7 +/99vdwe+QByALJ0xsoXyR5DtEDcndlhjKM0JGli9aGwsYgSiEtZUMWYReB8XAmo0NBbLbmkbRQzS +yRYGMZr1yUgwp8DSEOXesjBZbGiKfRRnIMriuU1F3h/bBmUZSuZQH+NMFIn1piSoT7LyjEVsLIh1 +iS25WuBOXNU5xpK5bH4ucElF9tbKJ+IG5M2tKHsVgay4XJGquiwfI7dmKJnT0bkQFrsBSckZEos1 +qnAZs5w8VALWY+D6XAqipmJUHsaVZGNNgCtUk8CzDiV83xxgh6ZGuL5AZZGh9QnjFGFueBOdYSyR +5xJd91kNq8jKyabZEMSG2ztxLLvQjdcnY8kcEkd/GTP8rAyDr5giRvpb1ZNuuD4ZCWQCeYgcVFJk +cWTMh/HwK85hnKy4sDBzxloo91hCDwxfJCrkjXdN4INKKn2OibLc8JvVD8ax+qJefSDRKaL4FGiy +NRleJzevHnKiF3LWU9NTpEqPJXNKZFqVyF6Jv65e5kKQgUIwYsBfJVnWqFbRF9Aqsk280tmsz2dw +DxlXbJm8oI2MFD52Uwwkss2lTSo2Y+BfIvS+wmuqV5ErimUo8LVUDQ4DyRwSk3C/KruTGR6yz/xG +LGL3Fk4QnrjOUqmcYySZI4AEuZghRmLMtLYojYAiwQtRXByr+ntRBcaQoWSOqBIRdWRzXKblMvRi +jGhVmg/oxphiKIHdcK5OkGmBjFNG3K6Ms5dAxbHoEA1nKMEUgbuC4If1ERySk1wLHTGwPQEX8sp4 +sai4ZSCYizUHfFF2IMCtIHAEeMmou/1gMpbMJwhYTjRTJNGIa4ozMXOrGAIoQ8YmJI6tc0nuOpbA +vemKS2yDbxcbCyVi9wQmyJQWcVacN8BD8Bp4hhL6slgKJeLK4BGzh6paRFpMkaxEAAxTKuof+wJM +EACt4OILLpSt9eL3LdSwwoNir00Shw0t9LlqwByK5hAljZKimYZ3Ni5U4hiCStEpLBNwjCA3DdMD +CR4l+mJ4TYh07rVmQiGdWdx21CnpttcnY8nhzv7DgOBDFcQokgh/JU8qcIbhG9BSrhT9Ek8jY2JO +vO9IhPd1kQiUqEAWVDCDoYrAFIvsDaE5Xqy/biMR5iGE5vp7b4Doo6DWwh104sRFkKoVQA6BADCd +ZySaU5RlMbjxtlAisA5aBYmGU3kP8TiZYElAJfc2SSwmVkrZYc0FLYjlWIFywN1Y46EE6yerJroj +EvkoqESiZ6DE01uLWyzwdvB1NTIepVoYAGQ2ydvEkQXxMWILArgycd5QQuuQd6IkCZwLoiZRoSIV +FVEnqytGnsIphhIYqeBQBC3JWQQ5TOGlLSFzlrDCoQv0GzmlxLA+lKhrkOxGUXAijBEQXDAWOOoB +hXJSl1eQVRAKDSTwTwmoCJKKVxEfJ4mRjB09pATJKc27N6BrZarDL0k6ZRknK6I5kgsJ1xhn7Nr6 +ZCyZi0R03NKPikdOVN2a6fPEaBghsnVMKGLOSSPEQKJRRgF+yE1pLYde3BTGSWybkbdw9cYSmUFQ +uQUUqIo/LfESPa2ABeqDoKSIWCjL3uLlQNKQKLIvICx4XI+UwHNMLCuQJ+AeksVh9QhqBpL5hLPJ +SkKXYmXMiw54SLTKp6TjsBwTPQwkRCCSQhEBOd92E3kQEEiEjjuFKxHq3BvM28DXGg== + + + VAUqU0hbNd2q4hNkrKinG8gjI+YA6EhMg2FQItEJEiNhjo8WoKw9kB+ZxsrYm9ihu55krpI4vGQ0 +XKYR6+O8Yn7UTGaj8RKm4yXk/55O0vTkqenDnyYHn0lzeCwbErCEmBLIZSTZ+Az/Q/wr2y7pNSOt ++F0kH8YQDYFuKIGWb8UlVt1di284BeGy/4npikewxrhEq75CIwByV5vgXOAQyFGIDU43J8DxLhEi +VMUhgo8daQKxfkuYwnRZPk8aE2VO66kdcm/G96QRpwOeMq4uU5+CuEGMSwSocGJyPivFIhcEBJSA +1H8OSWJEb2aBUFOZ7TIRw//7yAgkgMbTDyVDUIH8SyJwbGQMYIeVSEI8pLSEfCTJr3zDClxPzMLF +VyGPjwn+P2k2AefsUo58AZfh+0Z7tnlU1Tp98Ik5MiMscAXIHC9Kwhc2sRNgHVwmqMHrYizejx9X +x6xkLKGTVkAmppgDEuTM4C/rIOmhIsehBEHJVwtfGIF3sLqGK4AYDGOTRZfck0E6J/qzsQSxUXIK +Lj9vD2YLkB3LDaJKxoVIqo3XJ2MJcl5JA9r628o5nY8axYM6nA++ctgsyqWI+URCaUR6aldSQEpJ +CIEPB6UBFvBBr0nRDMbF8H3HEs7B/BR4AlYZgZ8CzFmSGZp3ipHJIMMNwPZQMqekaBYtGWVUCXN3 +SFID9cXkRBcv6Sp4gCpam5j05goKTNIcT88r3iQ0yqsvAWBwDkAM/hs5EdYBQQi4BUkc/MJQQpCR +cmaeybAIqtUq4egDQYbkRnJ/jAUmKfU6kJB/SFmTWh+Mp3fhk8nYKWdTgDlxD9B5BCoDCb1NQmoC +XkGUQSUVSSKCLtG6TAtHDH8UwFPKmJHDKSgQIxlJ5gOJRXojj1orfRjCF4Z8eQmJObUpBhKlRmJw +C5RMp1aVsiPpAB/nmimTr1IF0iEtty+YqzOooWf7BOT94dJVrI99B+Ig2HlsOu8na1wFKb2egDkC +3wM3V2pi4An6DXHflYGHCYr84aOGkaEETiU74C4Qliaq24581QgGhGOXF2M+3UDC15MUmL49Anni ++Y36/AiKafE+bdx7wybRJcqhf4kED683AeEqY+utjhX+jSRzlYTUfzBxAggc0AXFmCLwGvJYVWhf +yfoVcJL0G1XZoih4i4tdlXUvJHDHEhpDTDko3qNfEomDwpJ5zqhVGBo9xtlUmhg2iGPXmVhfgjka +F90kuUMRmNOBuJOnsMu7kiYcSOaUOOUJ6O0pyc1hSP5Cnj3Gylkl0hNXJJoLwgAZt7EEc8RMPgpJ +U4DTkaVS9EL6EV7CiYmjBpKTOq6hBM6vEt8DI8nrSRyydJRgI3zCWGKf7keuVePSUDIfSCRv4jXJ +c8+YywUiWH6eQm5T9ASYQdQA8TKBbMIVSYJPWESPscmtf2CEMM7TG38XTv3ckhzyW63XhCQeAlR9 +2+cqriMmhgUiI6RKUfcUpPzi83VkVWQdxRuBvNE8ywUlbaK4TLgOVrSsYy2CrgTaBuSCatk6WEhX +kBrbWSOwReKj4B7X8hrsu3N09aZoLs/gz88DVh6MJXLMrhYzh4RMpUgyPBIqQV7nIksGhg1Wh3tZ +Zsvj9ThyivHJOBChGtW6ArIwIFsApg+mLCRYcUBoARsk8RH+PSufNS45776EO+Cr4Q5Y671KTFI8 +2RE6xSrcDKh5sv5UNSZpRjGWzPuSVrIqkkdzyC2SMYthXulgTjGQMPrWqLtm6IFk7VkJRPh1mXsj +gJQ1IbF75kxE6hxrRW0k4Rz0GpTErLqhEdsHnYM6wpDPfR5LqCsKv0XRafpQlojJKmp8ZG10weRm +rH8Urc4gqbMmqQIOJPO+xHvkyCiE6gMqTpO5iiqkIK2scwwkzLPpzitwWmy5OOFDVe39k68AoODR +oxLFDqXh0tIcKB0MrxtThQaSuSpmdX01ZD1xMO4p7voHqtzhEqQSNtLc6TpUxSOdTOT68G4FAbe2 +Yr0jcQi3E5ktdnN34+XdOok+Me67uEZUHnVtzCmxjGPX7uprUXMfSOYq8aH/ZEWDFhWTLCkk5Fax +z9YOv0MJXZHhLobiuM+KV0WnbGq6MpCoEie8ObIIBg5IfNS8oloWmVkXsBq9FnbQxj3LaBJOQQDY +v4ZJP26SNZoa9bJy09Tm6EvoOTS5d1oXaBLl4AjZWdsOrBUp6zva8PUPVOD/Jyp+iv8dhkOkLeoW +JEks0FRQdZESXdoscLAxIFWJQSbUGCPMys6KFaLAj3ShqF5CIUNUuhkFFnRH0AcWHXXbbuh3RaAP +Qd6yTWCKoUSrjnAjjq6JmAiuCvVMw/SvtZDwKY18wHCK5hDagBGFyMzUCO8cilSadSmIs2Ceqs4x +WIsjh0IWgWNVbNeaATSLFWQStfypVJbErqw5sn7syP+A0WKXhsB2s/B35OIB6AmaSYIjTwSsdSQm +shZQQ7NzVrWxyGgOaexlKErBKXtZfaDau6T+R/NX+VxiaqtuM4cHkU7DAC9Wsa9WeQ9moUp+OU1K +CxEsMoWQGhO8XIkjL6hsO1td2H5UABlEkrWNpTrueghaqrAGbRcGcZpRwFTHJZVdLiUqT2DpYTRB +Qbx27HySt3TFKtzz1AtZ8aQFeL2iVMexizojwR/WHOs4h0RQS15YhrMKQEBElxT0qXJaWBbblBwI +Pqx01XKgKL7TRgHBLGkJ+pBIRnrEmnxb0NLmYGEI2mSQcooxcU3ATpc8fYBvqH3Km0XWAAaLeWTm +D04RpBv4i5QQ5ZB1o/CLRixCGViUZ6OWRWFCxqqnoq+1gWBCbIA3UF/d5wFqXjEW9KqWwpwQWUjr +o8jekveLObrlBZGsi2aI7EIALsyaRZL4Hz/00d/eKn3msjalvZ6w1mohUF8FnI7tztp9BRxqtCrC +Hjwm7KS1IAnZLd9GUtKkjLB+LtGmksVFQl+0xl2VMWaXyXLMjiksp9Pvi6qhQxAeJbbeBkA6zCjr +/QDPXF3VHUGzBqrBsXFjSAs28Q1JupUl99p0ZUPb0xpZPxZAwXFwqtVWuR14YBInVglN+Ojost5V +HAtfnPs7Xssjbwq6F5w29pkkjuA1eib4F4IOHGFVQO/QBAJK3WgdiGC4Zu3r8zUxzlV0J1T2NPDp +PZh+GRNZYpMM4XlVFgABRTuQJJPS7kUxe6SNBh2D+DiU1nkkcEcLaKlq71JgioLYG1NZNFAg9lpw +I55dOAi9sXEjQQ2laF0vt84QRyCOCkEGcopaevWccrgyR17iTysl/cdABEx+ido5wOoA3gSlSrQF +oNZeujZAo3gks/TOLj8CLS4Km1lRakXVWZaXRac25QMUhJQdMRrGEm4RqMIG6Z1otC2JtVm6ZdDY +2g0DhQUeWXyj9SbS30WOfVZqCPk3oSNjgNyiZiUPqQVgn2Um5e8c8EnqOkg8p1g8NGybHQAAtFXv +mVNWgrIwl9N6L1RMm/6Q2WpSzDZKpMKlaz7tL+7R47BTaqoCZBWgRTg1xCkJMV3XigFkqaSYHcvc +IZE8YVGH9sW0tyJEx1YqT9iW2rIoWJhhM2Br4auaOMAwXZvCS/rHydFP1nqpEh1JRdENKuCy7hNc +DlpDW58WOi7UM0a2YsA5sXDA9S3a7xJ1T1HCV+3wDftrf3bXTT1ajqMDRqO4JbVc9PWEyLaRj7SC +qjoNp8LHRreYZxcnm8VJ2hMZwKkYJS/gAxzrnCT9JbdHPxcIE4bipPqW2XPFYGyN0+4G3RhISkiL +zUNyl7RTja0Rlo0RmZuPzrl1PDZ5MPmg9bwAkOOVmMkhsMCcKxJzxAQifAIxtKU6usfxYnwODGfd +N7ZsmEC8lAKJZ20WSBwtNJEMEclYH1g1UG0myiOkjcj7SI8BOUqoZG2K2MVqF0BSY8PHMIDU3Ben +qNlypcm0EUazuxI7hncGJ4OqCpw5UnB2LujnVfeGqYJFUUlwApNnlMgyPb8vYHxQJ0daDZ6dxR5B +RIClqdWO1z9YjqN7gdaAATMs7HYWiSxYXfhiAJna+rVIMYH98HHhy7VkkNkVQwZTS18+8hI6Sssa +HJwCuCcdG3qD6Gs3hQRiaBaa3tsc4t+X64bqePaRoSLpKQBBG7rugV0HqGsBWXUnJFgyQQNnaZ1L +gGAF99DtR3GfBi9b7BtlOFiLoyurrIxlsxhdClooPKEaaExLIj6wFopvANyhdR/tDvrAlcEqsOGW +xTZ5zcU3SBLiiiiQR+MCmxHRU4zsDMBV++YFAtHxafECZwK08pQZYEUeLHdTk/LhI/9tiOLQkziy +6iCAxRfLM5XY5/+x+aJJgBwBrSQGXgx/HFILCHCZcK5WyQ8g8ESSoGrztXNas45Rcyx2ALEppVFy +4raYXcQUeIENOBEFMOyZr3umfNDermXcVC01a4e4awle0qyBZ1tK1c9ls55MurobCQ09V+Oizqgp +v4l6B7JY9J+x9bmSlF2MPXom9W1hL6g8KIEjEr2nRTtFwjfof5xtSWjVTk0mtLUFG/ZWwcKKZi6o +mQKkkX3fpB1Z+vXMBANYJbLOAGilURaOtTIdsxrVjfhDkWhPZFF8XbVgmduhgYpMMikGjjyJ0hkj +KuO1Jjb0IwdE/OB5h0xCEPaBonqg+cNVdxYVtUVWfJTEWhxtSkzwWddy6ArOpGtiezekYDCviLwo +oh3MqTklPYFgm7dB2gd0BgzMUFDZd84W05BaXbzBRIN6qaOxoyiInkE6MDQzsAfNNA4YEvS+oTId +tMyNPkltJQpa9o4cE+GqowUV4mkx7OnwfAntTmCbCHoM2yEzvSChLb1R6xgXj7MfXp0oynw88xA0 +/YEeEYhnPUumTW7wGPC33jAV4uEUoGiv+W3DDa51+CIV8gy8qi2knth0Wrsew4ioQMasi4jayN4k +yKF9QX0Sh81IMkqKBK0ILYaiX51AW9t3cUWgZoqiRK1MD7zB/8OxoYpvFXgoU0iAvGZyKJs9NWRE +qGaqRmKbrBeE7mQeKbhARR1KUMRFzOSxPZxDgef3wNy+RbWAEwYZewiUpu1hQwkLwezFCShUM/44 +ltwCT/fZxTgutmQsmS8kqYFMME7ABwB/gs/ZslcdK622qAkNBCz5s2MbhR4xEabCUHzxCsbSyLRX +o87UaIdjNogVy0OUhTAJhylRqIezYSuZUVKmG2t+0pcwuSD90ruG6VdtzQVwZdg8Hh3UU1AjCZOL +GOncctcdiBBbG3pD/xrgfJnxiCdxRV/ACoQtLbkFAhRrIx+YtNEeLGBSZta5jhbsCcgs8jSTawkP +uEenTp2dWhiTGRH/1cqOI8lcmcSaFlyoSpyWV6r1SQG/gc4tqF8ZazcWaRicEChlQXGp++hLiLBz +Y+jZvD5XFE6LZXlLEXTj2nimkHXPyDM9zrnW11yDdjGzu3os4RyMGyRdlMUmYYJhYbG1oFuqG+sZ +vb6Ejk65ne4aP2ut03wIcZFJXZMNtZ32Gkj0uJfT40kSbch0egQVsEdsbQmtGSfJKg== + + + plZzHEg4h3avxQZeAo6vkORj8yfGjRHmHmj5vC/ROUrLiACNF9fiGJDRigOaE1CAafWF3ng+hFJ6 +gLHNgExVqyk82laZ8pWijeQ5az0kpHZAuB1xk1S1VSAGkvlSgq7NrDy4VQa5DbVnYtG7OZZodLJK +UksA09s7bdyzOBPbxR4yxHFRCOlJ2sZnYjIeTGHhRVGdd62BmKrSxj3laRI9y5aL71/T9Q9a7dDK +hJYYE9+PJZyC/l0fQ7uSybTyQbWlAGc12NeorzKS0LYUQMZ2pA7HurLqstXaijge+gmemdYEvS+Z +a8qeWCPx7Js0rYMAZ1UidQBoEaja5HY+uy/QpojAljsedIW3S/Du2t6xORkJ2JkhzpfcaKia/QHP +VUdGA41yzOUiEGURRFO1nhsNj8UhY6LjdskynaPLouMeSOj8qzF1wYogGKCjDwVKztHCRTdeBpBO +AoJL6d1OguNl2u+i+X9pfW2lPTkIu6EEgRB2hVYDnAC2POCKfLmQXsHY8pcAvM+NZO6P2VqbY0Xu +myu65rHbtpKgjKWWxXgZzseS+UISGrsTW48+mq9Bn0QetdSTqIVuYizhuT1WOT0UgEd9o0M5GXas +VEwqOKPj9UggO4n7Aj0RxLA0c2QGSjt7g2TFky7UlnA2pjry80MJN5WHQXmOkoUnnlTU03eZBLBB +tG5D6kVfoA2eoNUhUF2Cu0MHfjv3g8wINK/Xp2Ihqi9gRGeG5GGRejI1KsPoG+RqEv0OCSuMA3MO +1E20/x99ewswPhLoDIVwXiEXWtbRTO7bnnGsnzecPJboKSIUS3zjXlQS9VwZX4puJAXtr+BpPjon +6g1bf9Rn1qSH30rSQ72lsbjaBo225Mjfu+Dba1bQl+g5IstUypL2xNjzkLtq03Kc2XfHOQYSncOz +gOBIpCA7wVxw/1lLYcykY+uIY7AbSLTxBtXE0JGAQMs+0xLoeAOR7rQ7daH5Sl/COcR7MmPpTrrw +Sfl/gSQDi2PdmHMMJBp2cQAY9tXen2cbtOhpWe2JPA6fqgL9sYS9Fqw0SO6ekp4Vo+6wcNQyKU3E +UX9pcwwknIMxtOt/BBvBpCW3pgNYR2pgwHeNSH1JgxCxKIQwDUKwaQrRIuvxetZ4SF5D2XAUzrV+ +PHwB48iCiMJqHiMbSOYLSedIcVjOkT5ozYaoN0T275MW4OsOJNopRwqu/TAArEGTaPLg3T4BAbva +37lOQmvg0dFOAqYIfgRgBKeAgDkMx63KOBIoBok8tVxr+7kCnglCjsz8toFTcFgptm6MgUTnKBAo +yUooZNjkK4kNMTwT9dhqmIrI+hJFdQiIsTkYEs88E6IOHR0WjqUyQgKuRV+grXuFvfmJTCawCZob +80xxSjFURuZN65OxZN6TVD3ciOstw20KDetEli1IpugUPQFnoHHCzSOYAjTiuCxOaWunEo9i26xU +rHL6fQm5Z2ZqvlE3KnF0+LawnpTa798038WjZfxFFWv0VxfGEj1+Fj2uMQT9GPMIjyGJiCHyZFH/ +riQ1kugUBnTfsk07oUvLqR7xyAkYSwlGjdIeSejtE7vIlRpDE0JtlCv9M6OjxD7TRUr+zTCbUv97 +BnwAj2Y77t0H/Mf6h5TI33TmcWMsmF/R37q6tveUPyx19uzk+PE728927+9vv3i1uz959m77f3an +23t7b95vv999K59Mn+3vvnv/Zn93it+WgkQu6b5+/Pi129cn/wdMDf+r + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/toolbars/podcast_tab_feeds.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/toolbars/podcast_tab_feeds.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,8 @@ + + + + + + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/toolbars/podcast_tab_queue.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/toolbars/podcast_tab_queue.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,6 @@ + + + + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/toolbars/podcast_tab_search.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/toolbars/podcast_tab_search.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,4 @@ + + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/toolbars/podcast_tb_addfeed.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/toolbars/podcast_tb_addfeed.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,18 @@ + + + + + + + + + + + + + + + + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/toolbars/podcast_tb_cancel.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/toolbars/podcast_tb_cancel.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,4 @@ + + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/toolbars/podcast_tb_clear.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/toolbars/podcast_tb_clear.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,6 @@ + + + + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/toolbars/podcast_tb_delete.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/toolbars/podcast_tb_delete.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,9 @@ + + + + + + + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/toolbars/podcast_tb_download.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/toolbars/podcast_tb_download.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,17 @@ + + + + + + + + + + + + + + + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/toolbars/podcast_tb_marknew.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/toolbars/podcast_tb_marknew.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,4 @@ + + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/toolbars/podcast_tb_markold.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/toolbars/podcast_tb_markold.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,4 @@ + + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/toolbars/podcast_tb_remove.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/toolbars/podcast_tb_remove.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,7 @@ + + + + + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/toolbars/podcast_tb_resume.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/toolbars/podcast_tb_resume.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,9 @@ + + + + + + + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/toolbars/podcast_tb_search.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/toolbars/podcast_tb_search.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,4 @@ + + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/toolbars/podcast_tb_settings.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/toolbars/podcast_tb_settings.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,10 @@ + + + + + + + + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/toolbars/podcast_tb_suspend.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/toolbars/podcast_tb_suspend.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,8 @@ + + + + + + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/toolbars/podcast_tb_update.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/toolbars/podcast_tb_update.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,5 @@ + + + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/images/toolbars/podcast_tb_updateall.svg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/images/toolbars/podcast_tb_updateall.svg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,5 @@ + + + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/data/languages.rss --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/data/languages.rss Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,23 @@ +/* + * Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB + * + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of the License "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * EmbedDev AB - initial contribution. + * + * Contributors: + * + * Description: + * + */ + +#include "PodcastClient_common.rls" // strings common between languages + +//#ifdef LANGUAGE_01 + #include "PodcastClient_english.rls" +//#endif diff -r 5f8e5adbbed9 -r 29cda98b007e application/group/Podcast.mmp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/group/Podcast.mmp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,115 @@ +/* + * Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB + * + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of the License "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * EmbedDev AB - initial contribution. + * + * Contributors: + * + * Description: + * + */ + +TARGET Podcast.exe +TARGETTYPE exe +UID 0x100039CE 0xA0009D00 + +CAPABILITY NetworkServices UserEnvironment + +EPOCSTACKSIZE 81920 +EPOCHEAPSIZE 1024000 32768000 + +SYSTEMINCLUDE \epoc32\include +SYSTEMINCLUDE \epoc32\include\mmf\common +SYSTEMINCLUDE \epoc32\include\domain\middleware +SYSTEMINCLUDE \epoc32\include\mw // for Symbian^3 +SYSTEMINCLUDE \epoc32\include\platform\mw // for Symbian^3 + +USERINCLUDE ..\..\engine\inc +USERINCLUDE . +USERINCLUDE ..\inc + +SOURCEPATH ..\src +SOURCE Podcast.cpp +SOURCE PodcastApp.cpp +SOURCE PodcastAppui.cpp +SOURCE PodcastDocument.cpp +SOURCE PodcastListView.cpp +SOURCE PodcastFeedView.cpp +SOURCE PodcastSettingsView.cpp +SOURCE PodcastShowsView.cpp +SOURCE PodcastSearchView.cpp +SOURCE PodcastFeedViewUpdater.cpp +SOURCE PodcastQueueView.cpp + + +SOURCEPATH ..\data + +START RESOURCE Podcast.rss + HEADER + TARGETPATH resource\apps + LANG SC +END + +START RESOURCE Podcast_reg.rss +LANG SC +#ifdef WINSCW +TARGETPATH \private\10003a3f\apps +#else +TARGETPATH \private\10003a3f\import\apps +#endif +END + +#ifdef SQLITE_INCLUDED +STATICLIBRARY PodCastEngine.lib +STATICLIBRARY sqlite_podcatcher.lib +LIBRARY mediaclientaudio.lib +LIBRARY inetprotutil.lib +LIBRARY xmlframework.lib +LIBRARY http.lib +LIBRARY ezlib.lib +LIBRARY commdb.lib +LIBRARY esock.lib +LIBRARY mmfcontrollerframework.lib +LIBRARY cmmanager.lib +LIBRARY libc.lib +LIBRARY imageconversion.lib +LIBRARY bitmaptransforms.lib +#else +LIBRARY PodCastEngine.lib +#endif +LIBRARY euser.lib +LIBRARY apparc.lib +LIBRARY cone.lib +LIBRARY eikcore.lib +LIBRARY eikcoctl.lib +LIBRARY avkon.lib +LIBRARY egul.lib // for CGulIcon +LIBRARY bafl.lib +LIBRARY eikdlg.lib +LIBRARY eikcdlg.lib +LIBRARY efsrv.lib +LIBRARY aknicon.lib +LIBRARY gdi.lib +LIBRARY eikctl.lib +LIBRARY charconv.lib +LIBRARY flogger.lib +LIBRARY apmime.lib +LIBRARY estor.lib +LIBRARY apgrfx.lib +LIBRARY CommonDialogs.lib +LIBRARY aknskins.lib +LIBRARY fbscli.lib +LIBRARY etext.lib +LIBRARY PlatformEnv.lib // for PathInfo +LIBRARY form.lib +LIBRARY ws32.lib +LIBRARY hlplch.lib +LIBRARY bitgdi.lib + diff -r 5f8e5adbbed9 -r 29cda98b007e application/group/icons.mk --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/group/icons.mk Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,46 @@ +ifeq (WINS,$(findstring WINS, $(PLATFORM))) +ZDIR=$(EPOCROOT)epoc32\release\$(PLATFORM)\$(CFG)\Z +else +ZDIR=$(EPOCROOT)epoc32\data\z +endif + +TARGETDIR=$(ZDIR)\resource\apps +ICONTARGETFILENAME=$(TARGETDIR)\Podcast.mif +HEADERFILE=$(EPOCROOT)epoc32\include\Podcast.mbg +DPATH=..\data\images + +do_nothing : + @rem do_nothing + +MAKMAKE : do_nothing + +BLD : do_nothing + +CLEAN : do_nothing + +LIB : do_nothing + +CLEANLIB : do_nothing + +RESOURCE : + mifconv $(ICONTARGETFILENAME) /h$(HEADERFILE) /c16,1\ + $(DPATH)\podcatcher_64px.svg\ + $(DPATH)\new\Audio.svg\ + $(DPATH)\new\Audio_new.svg\ + $(DPATH)\new\Audio_queued.svg\ + $(DPATH)\new\Audio_downloading.svg\ + $(DPATH)\new\Audio_downloaded.svg\ + $(DPATH)\new\Audio_downloaded_new.svg\ + $(DPATH)\new\Audio_failed.svg\ + $(DPATH)\new\Audio_suspended.svg\ + $(DPATH)\new\Feed.svg + +FREEZE : do_nothing + +SAVESPACE : do_nothing + +RELEASABLES : + @echo $(ICONTARGETFILENAME) + +FINAL : do_nothing + diff -r 5f8e5adbbed9 -r 29cda98b007e application/help/custom.xml --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/help/custom.xml Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,17 @@ + + + + + + +Note: + + + + + + + + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/help/pictures/important2.jpg Binary file application/help/pictures/important2.jpg has changed diff -r 5f8e5adbbed9 -r 29cda98b007e application/help/pictures/important2.mbm Binary file application/help/pictures/important2.mbm has changed diff -r 5f8e5adbbed9 -r 29cda98b007e application/help/pictures/tip2.jpg Binary file application/help/pictures/tip2.jpg has changed diff -r 5f8e5adbbed9 -r 29cda98b007e application/help/pictures/tip2.mbm Binary file application/help/pictures/tip2.mbm has changed diff -r 5f8e5adbbed9 -r 29cda98b007e application/help/podcatcher.cshlp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/help/podcatcher.cshlp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,21 @@ + + + + + + 0xA0009D00 + + + + pictures + + + + + podcatcher.rtf + + podcatcher.hlp + custom.xml + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/help/podcatcher.hlp Binary file application/help/podcatcher.hlp has changed diff -r 5f8e5adbbed9 -r 29cda98b007e application/help/podcatcher.hlp.hrh --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/help/podcatcher.hlp.hrh Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,19 @@ +// +// podcatcher.hlp.hrh +// + +// +// File generated by cshlpcmp Version 011 +// + +#ifndef __PODCATCHER_HLP_HRH__ +#define __PODCATCHER_HLP_HRH__ + + +_LIT(KContextApplication,"ContextApplication"); //Podcatcher +_LIT(KContextFeedsView,"ContextFeedsView"); //Feeds View +_LIT(KContextShowsView,"ContextShowsView"); //Shows View +_LIT(KContextDownloadQueue,"ContextDownloadQueue"); //Download Queue +_LIT(KContextSettings,"ContextSettings"); //Settings + +#endif diff -r 5f8e5adbbed9 -r 29cda98b007e application/help/podcatcher.rtf --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/help/podcatcher.rtf Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,253 @@ +{\rtf1\ansi\deff1\adeflang1025 +{\fonttbl{\f0\froman\fprq2\fcharset128 Times New Roman;}{\f1\fswiss\fprq2\fcharset0 Arial;}{\f2\fnil\fprq0\fcharset128 OpenSymbol{\*\falt Arial Unicode MS};}{\f3\fswiss\fprq2\fcharset0 Arial;}{\f4\fswiss\fprq2\fcharset128 Arial;}{\f5\froman\fprq2\fcharset2 Webdings;}{\f6\froman\fprq2\fcharset2 Symbol;}{\f7\fmodern\fprq1\fcharset0 Courier New;}{\f8\fswiss\fprq2\fcharset0 Arial Narrow;}{\f9\fnil\fprq2\fcharset128 MS Mincho;}{\f10\fnil\fprq0\fcharset128 Tahoma;}} +{\colortbl;\red0\green0\blue0;\red0\green0\blue128;\red128\green0\blue0;\red0\green128\blue0;\red128\green128\blue128;} +{\stylesheet{\s1\sa120\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057\snext1 Normal;} +{\s2\sb240\sa120\keepn\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\af4\afs28\lang255\ltrch\dbch\af9\langfe1033\hich\f4\fs28\lang2057\loch\f4\fs28\lang2057\sbasedon1\snext3 Heading;} +{\s3\sa120\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057\sbasedon1\snext3 Body Text;} +{\s4\sa120\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057\sbasedon3\snext4 List;} +{\s5\sb120\sa120\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\af10\afs24\lang255\ai\ltrch\dbch\langfe1033\hich\fs24\lang2057\i\loch\fs24\lang2057\i\sbasedon1\snext5 caption;} +{\s6\li283\ri0\lin283\rin0\fi-283\sa120\brdrb\brdrs\brdrw1\brdrcf1\brsp20{\*\brdrb\brdlncol1\brdlnin0\brdlnout1\brdlndist0}\brsp20\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057\sbasedon1\snext6 Index;} +{\s7\sb120\sa120\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs24\lang255\ai\ltrch\dbch\langfe1033\hich\fs24\lang2057\i\loch\fs24\lang2057\i\sbasedon1\snext7 caption;} +{\s8\sb120\sa120\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs24\lang255\ai\ltrch\dbch\langfe1033\hich\fs24\lang2057\i\loch\fs24\lang2057\i\sbasedon1\snext8 WW-caption;} +{\s9\sb360\sa240\keepn\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs32\lang255\ab\ltrch\dbch\langfe1033\hich\fs32\lang2057\b\loch\fs32\lang2057\b\sbasedon1\snext1 heading 1;} +{\s10\sb120\sa120\brdrt\brdrs\brdrw20\brdrcf1\brsp20\brdrb\brdrs\brdrw20\brdrcf1\brsp20{\*\brdrt\brdlncol1\brdlnin0\brdlnout20\brdlndist0}\brsp20{\*\brdrb\brdlncol1\brdlnin0\brdlnout20\brdlndist0}\brsp20\keepn\cf0\tqr\tx9072{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs24\lang255\ab\ltrch\dbch\langfe1033\hich\fs24\lang2057\b\loch\fs24\lang2057\b\sbasedon1\snext1 heading 2;} +{\s11\sb120\sa120\brdrt\brdrs\brdrw20\brdrcf1\brsp20{\*\brdrt\brdlncol1\brdlnin0\brdlnout20\brdlndist0}\brsp20\keepn\cf0\tqr\tx9072{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs28\lang255\ab\ltrch\dbch\langfe1033\hich\fs28\lang2057\b\loch\fs28\lang2057\b\sbasedon1\snext1 heading 3;} +{\s12\sb120\sa120\brdrt\brdrs\brdrw1\brdrcf1\brsp20{\*\brdrt\brdlncol1\brdlnin0\brdlnout1\brdlndist0}\brsp20\keepn\cf0\tqr\tx9072{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs24\lang255\ab\ltrch\dbch\langfe1033\hich\fs24\lang2057\b\loch\fs24\lang2057\b\sbasedon1\snext1 heading 4;} +{\s13\sa120\keepn\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs20\lang255\ab\ltrch\dbch\langfe1033\hich\fs20\lang2057\b\loch\fs20\lang2057\b\sbasedon1\snext1 heading 5;} +{\s14\sb240\sa60\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs22\lang255\ai\ltrch\dbch\langfe1033\hich\fs22\lang2057\i\loch\fs22\lang2057\i\sbasedon1\snext1 heading 6;} +{\s15\sb240\sa60\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057\sbasedon1\snext1 heading 7;} +{\s16\sb240\sa60\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs20\lang255\ai\ltrch\dbch\langfe1033\hich\fs20\lang2057\i\loch\fs20\lang2057\i\sbasedon1\snext1 heading 8;} +{\s17\sb240\sa60\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs18\lang255\ai\ltrch\dbch\langfe1033\hich\fs18\lang2057\i\loch\fs18\lang2057\i\sbasedon1\snext1 heading 9;} +{\s18\li284\ri0\lin284\rin0\fi-284\sa120\cf0\tx284{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057\sbasedon1\snext18 List Bullet;} +{\s19\li284\ri0\lin284\rin0\fi0\sa120\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057\sbasedon1\snext19 List Continue;} +{\s20\li284\ri0\lin284\rin0\fi-284\sa120\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057\sbasedon1\snext20 List Number;} +{\s21\li568\ri0\lin568\rin0\fi-284\sa120\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057\sbasedon1\snext21 List Bullet 2;} +{\s22\sb360\sa240\keepn\cf2{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs32\lang255\ab\ltrch\dbch\langfe1033\hich\fs32\lang2057\b\loch\fs32\lang2057\b\sbasedon1\snext22 Category UID;} +{\s23\sa120\cf3{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057\sbasedon1\snext23 Synonyms;} +{\s24\li284\ri0\lin284\rin0\fi-284\sa120\cf0\tx284{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057\sbasedon20\snext24 List Manual;} +{\s25\li568\ri0\lin568\rin0\fi-284\sa120\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057\sbasedon1\snext25 List Number 2;} +{\s26\li566\ri0\lin566\rin0\fi0\sa120\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057\sbasedon1\snext26 List Continue 2;} +{\s27\sa120\cf4{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057\sbasedon1\snext27 Definition Term;} +{\s28\sa120\cf4{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057\sbasedon27\snext28 Definition Definition;} +{\s29\li283\ri0\lin283\rin0\fi-283\sa120\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057\sbasedon1\snext29 Tip;} +{\s30\li283\ri0\lin283\rin0\fi-283\sa120\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057\sbasedon29\snext30 Note;} +{\s31\li283\ri0\lin283\rin0\fi-283\sa120\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057\sbasedon30\snext31 Important;} +{\s32\li568\ri0\lin568\rin0\fi-284\sa120\cf0\tx284\tx568{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057\sbasedon25\snext32 List Manual 2;} +{\s33\sa120\cf0\tqc\tx4153\tqr\tx8306{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057\sbasedon1\snext33 footer;} +{\s34\sa120\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs20\lang255\ai\ltrch\dbch\langfe1033\hich\fs20\lang2057\i\loch\fs20\lang2057\i\sbasedon1\snext34 Comment;} +{\s35\li283\ri0\lin283\rin0\fi-283\sa120\brdrb\brdrs\brdrw1\brdrcf1\brsp20{\*\brdrb\brdlncol1\brdlnin0\brdlnout1\brdlndist0}\brsp20\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057\sbasedon1\snext35 Context;} +{\s36\sa120\cf0\tqc\tx1984\tqr\tx3969{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057\sbasedon1\snext36 WW-footer;} +{\s37\sa120\cf0\tqc\tx4320\tqr\tx8640{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057\sbasedon1\snext37 WW-footer1;} +{\s38\sa120\cf0\tqc\tx4320\tqr\tx8640{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057\sbasedon1\snext38 footer;} +{\*\cs40\cf0\rtlch\af1\afs24\lang255\ltrch\dbch\af1\langfe1033\hich\f1\fs24\lang1033\loch\f1\fs24\lang1033 RTF_Num 2 1;} +{\*\cs41\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 2;} +{\*\cs42\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 3;} +{\*\cs43\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 4;} +{\*\cs44\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 5;} +{\*\cs45\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 6;} +{\*\cs46\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 7;} +{\*\cs47\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 8;} +{\*\cs48\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 9;} +{\*\cs49\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 10;} +{\*\cs50\cf0\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 1;} +{\*\cs51\cf0\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 2;} +{\*\cs52\cf0\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 3;} +{\*\cs53\cf0\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 4;} +{\*\cs54\cf0\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 5;} +{\*\cs55\cf0\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 6;} +{\*\cs56\cf0\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 7;} +{\*\cs57\cf0\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 8;} +{\*\cs58\cf0\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 9;} +{\*\cs59\cf0\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 10;} +{\*\cs60\cf0\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 1;} +{\*\cs61\cf0\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 2;} +{\*\cs62\cf0\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 3;} +{\*\cs63\cf0\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 4;} +{\*\cs64\cf0\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 5;} +{\*\cs65\cf0\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 6;} +{\*\cs66\cf0\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 7;} +{\*\cs67\cf0\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 8;} +{\*\cs68\cf0\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 9;} +{\*\cs69\cf0\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 10;} +{\*\cs70\cf0\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe1033\hich\f5\fs24\lang1033\loch\f5\fs24\lang1033 RTF_Num 2 1;} +{\*\cs71\cf0\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 2;} +{\*\cs72\cf0\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 3;} +{\*\cs73\cf0\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 4;} +{\*\cs74\cf0\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 5;} +{\*\cs75\cf0\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 6;} +{\*\cs76\cf0\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 7;} +{\*\cs77\cf0\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 8;} +{\*\cs78\cf0\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 9;} +{\*\cs79\cf0\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 RTF_Num 2 10;} +{\*\cs80\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 WW-RTF_Num 2 1;} +{\*\cs81\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 WW-RTF_Num 2 2;} +{\*\cs82\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 WW-RTF_Num 2 3;} +{\*\cs83\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 WW-RTF_Num 2 4;} +{\*\cs84\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 WW-RTF_Num 2 5;} +{\*\cs85\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 WW-RTF_Num 2 6;} +{\*\cs86\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 WW-RTF_Num 2 7;} +{\*\cs87\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 WW-RTF_Num 2 8;} +{\*\cs88\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 WW-RTF_Num 2 9;} +{\*\cs89\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 WW-RTF_Num 2 10;} +{\*\cs90\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 WW-RTF_Num 2 11;} +{\*\cs91\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 WW-RTF_Num 2 21;} +{\*\cs92\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 WW-RTF_Num 2 31;} +{\*\cs93\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 WW-RTF_Num 2 41;} +{\*\cs94\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 WW-RTF_Num 2 51;} +{\*\cs95\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 WW-RTF_Num 2 61;} +{\*\cs96\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 WW-RTF_Num 2 71;} +{\*\cs97\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 WW-RTF_Num 2 81;} +{\*\cs98\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 WW-RTF_Num 2 91;} +{\*\cs99\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 WW-RTF_Num 2 101;} +{\*\cs100\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 WW-RTF_Num 2 112;} +{\*\cs101\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 WW-RTF_Num 2 212;} +{\*\cs102\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 WW-RTF_Num 2 312;} +{\*\cs103\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 WW-RTF_Num 2 412;} +{\*\cs104\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 WW-RTF_Num 2 512;} +{\*\cs105\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 WW-RTF_Num 2 612;} +{\*\cs106\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 WW-RTF_Num 2 712;} +{\*\cs107\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 WW-RTF_Num 2 812;} +{\*\cs108\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 WW-RTF_Num 2 912;} +{\*\cs109\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe255\hich\f5\fs24\lang2057\loch\f5\fs24\lang2057 WW-RTF_Num 2 1012;} +{\*\cs110\cf0\rtlch\af6\afs24\lang255\ltrch\dbch\af6\langfe1033\hich\f6\fs24\lang1033\loch\f6\fs24\lang1033 RTF_Num 3 1;} +{\*\cs111\cf0\rtlch\af1\afs24\lang255\ltrch\dbch\af1\langfe1033\hich\f1\fs24\lang1033\loch\f1\fs24\lang1033 RTF_Num 4 1;} +{\*\cs112\cf0\rtlch\af6\afs24\lang255\ltrch\dbch\af6\langfe1033\hich\f6\fs24\lang1033\loch\f6\fs24\lang1033 RTF_Num 5 1;} +{\*\cs113\cf0\rtlch\af5\afs24\lang255\ltrch\dbch\af5\langfe1033\hich\f5\fs24\lang1033\loch\f5\fs24\lang1033 RTF_Num 6 1;} +{\*\cs114\cf0\rtlch\af1\afs24\lang255\ltrch\dbch\af1\langfe1033\hich\f1\fs24\lang1033\loch\f1\fs24\lang1033 Default Paragraph Font;} +{\*\cs115\cf0{\*\updnprop10000}\up6\rtlch\af1\afs24\lang255\ltrch\dbch\af1\langfe1033\hich\f1\fs24\lang1033\loch\f1\fs24\lang1033\sbasedon114 endnote reference;} +{\*\cs116\cf0\rtlch\af7\afs20\lang255\ab\ltrch\dbch\af7\langfe1033\hich\f7\fs20\lang1033\b\loch\f7\fs20\lang1033\b\sbasedon114 Key Name;} +{\*\cs117\cf0\rtlch\af1\afs20\lang255\ab\ltrch\dbch\af1\langfe1033\hich\f1\fs20\lang1033\b\loch\f1\fs20\lang1033\b\sbasedon114 App Text;} +{\*\cs118\scaps\cf3\rtlch\af8\afs20\lang255\ltrch\dbch\af8\langfe1033\hich\f8\fs20\lang1033\loch\f8\fs20\lang1033\sbasedon114 Graphic Link;} +{\*\cs119\cf0\rtlch\af1\afs20\lang255\ai\ltrch\dbch\af1\langfe1033\hich\f1\fs20\lang1033\i\loch\f1\fs20\lang1033\i\sbasedon114 Context Comment;} +{\*\cs120\cf0\rtlch\af2\afs24\lang255\ltrch\dbch\af2\langfe255\hich\f2\fs24\lang2057\loch\f2\fs24\lang2057 Bullet Symbols;} +{\*\cs121\cf0\rtlch\af1\afs24\lang255\ltrch\dbch\af1\langfe255\hich\f1\fs24\lang2057\loch\f1\fs24\lang2057 Numbering Symbols;} +}{\*\listtable{\list\listtemplateid1 +{\listlevel\levelnfc23\leveljc0\levelstartat1\levelfollow0{\leveltext \'01\u8226 ?;}{\levelnumbers;}\f2\f2\f2\f2\fi-360\li360} +{\listlevel\levelnfc23\leveljc0\levelstartat1\levelfollow0{\leveltext \'01\u9702 ?;}{\levelnumbers;}\f2\f2\f2\f2\fi-360\li720} +{\listlevel\levelnfc23\leveljc0\levelstartat1\levelfollow0{\leveltext \'01\u9642 ?;}{\levelnumbers;}\f2\f2\f2\f2\fi-360\li1080} +{\listlevel\levelnfc23\leveljc0\levelstartat1\levelfollow0{\leveltext \'01\u8226 ?;}{\levelnumbers;}\f2\f2\f2\f2\fi-360\li1440} +{\listlevel\levelnfc23\leveljc0\levelstartat1\levelfollow0{\leveltext \'01\u9702 ?;}{\levelnumbers;}\f2\f2\f2\f2\fi-360\li1800} +{\listlevel\levelnfc23\leveljc0\levelstartat1\levelfollow0{\leveltext \'01\u9642 ?;}{\levelnumbers;}\f2\f2\f2\f2\fi-360\li2160} +{\listlevel\levelnfc23\leveljc0\levelstartat1\levelfollow0{\leveltext \'01\u8226 ?;}{\levelnumbers;}\f2\f2\f2\f2\fi-360\li2520} +{\listlevel\levelnfc23\leveljc0\levelstartat1\levelfollow0{\leveltext \'01\u9702 ?;}{\levelnumbers;}\f2\f2\f2\f2\fi-360\li2880} +{\listlevel\levelnfc23\leveljc0\levelstartat1\levelfollow0{\leveltext \'01\u9642 ?;}{\levelnumbers;}\f2\f2\f2\f2\fi-360\li3240} +{\*\soutlvl{\listlevel\levelnfc23\leveljc0\levelstartat1\levelfollow0{\leveltext \'01\u8226 ?;}{\levelnumbers;}\f2\f2\f2\f2\fi-360\li3600}}\listid1} +{\list\listtemplateid2 +{\listlevel\levelnfc0\leveljc0\levelstartat1\levelfollow0{\leveltext \'02\'00.;}{\levelnumbers\'01;}\fi-360\li360} +{\listlevel\levelnfc0\leveljc0\levelstartat1\levelfollow0{\leveltext \'02\'01.;}{\levelnumbers\'01;}\fi-360\li720} +{\listlevel\levelnfc0\leveljc0\levelstartat1\levelfollow0{\leveltext \'02\'02.;}{\levelnumbers\'01;}\fi-360\li1080} +{\listlevel\levelnfc0\leveljc0\levelstartat1\levelfollow0{\leveltext \'02\'03.;}{\levelnumbers\'01;}\fi-360\li1440} +{\listlevel\levelnfc0\leveljc0\levelstartat1\levelfollow0{\leveltext \'02\'04.;}{\levelnumbers\'01;}\fi-360\li1800} +{\listlevel\levelnfc0\leveljc0\levelstartat1\levelfollow0{\leveltext \'02\'05.;}{\levelnumbers\'01;}\fi-360\li2160} +{\listlevel\levelnfc0\leveljc0\levelstartat1\levelfollow0{\leveltext \'02\'06.;}{\levelnumbers\'01;}\fi-360\li2520} +{\listlevel\levelnfc0\leveljc0\levelstartat1\levelfollow0{\leveltext \'02\'07.;}{\levelnumbers\'01;}\fi-360\li2880} +{\listlevel\levelnfc0\leveljc0\levelstartat1\levelfollow0{\leveltext \'02\'08.;}{\levelnumbers\'01;}\fi-360\li3240} +{\*\soutlvl{\listlevel\levelnfc0\leveljc0\levelstartat1\levelfollow0{\leveltext \'02\'09.;}{\levelnumbers\'01;}\fi-360\li3600}}\listid2} +{\list\listtemplateid3 +{\listlevel\levelnfc23\leveljc0\levelstartat1\levelfollow0{\leveltext \'01\u8226 ?;}{\levelnumbers;}\f2\f2\f2\f2\fi-360\li360} +{\listlevel\levelnfc23\leveljc0\levelstartat1\levelfollow0{\leveltext \'01\u9702 ?;}{\levelnumbers;}\f2\f2\f2\f2\fi-360\li720} +{\listlevel\levelnfc23\leveljc0\levelstartat1\levelfollow0{\leveltext \'01\u9642 ?;}{\levelnumbers;}\f2\f2\f2\f2\fi-360\li1080} +{\listlevel\levelnfc23\leveljc0\levelstartat1\levelfollow0{\leveltext \'01\u8226 ?;}{\levelnumbers;}\f2\f2\f2\f2\fi-360\li1440} +{\listlevel\levelnfc23\leveljc0\levelstartat1\levelfollow0{\leveltext \'01\u9702 ?;}{\levelnumbers;}\f2\f2\f2\f2\fi-360\li1800} +{\listlevel\levelnfc23\leveljc0\levelstartat1\levelfollow0{\leveltext \'01\u9642 ?;}{\levelnumbers;}\f2\f2\f2\f2\fi-360\li2160} +{\listlevel\levelnfc23\leveljc0\levelstartat1\levelfollow0{\leveltext \'01\u8226 ?;}{\levelnumbers;}\f2\f2\f2\f2\fi-360\li2520} +{\listlevel\levelnfc23\leveljc0\levelstartat1\levelfollow0{\leveltext \'01\u9702 ?;}{\levelnumbers;}\f2\f2\f2\f2\fi-360\li2880} +{\listlevel\levelnfc23\leveljc0\levelstartat1\levelfollow0{\leveltext \'01\u9642 ?;}{\levelnumbers;}\f2\f2\f2\f2\fi-360\li3240} +{\*\soutlvl{\listlevel\levelnfc23\leveljc0\levelstartat1\levelfollow0{\leveltext \'01\u8226 ?;}{\levelnumbers;}\f2\f2\f2\f2\fi-360\li3600}}\listid3} +{\list\listtemplateid4\listsimple +{\listlevel\levelnfc23\leveljc0\levelstartat1\levelfollow0{\leveltext \'01\u61545 ?;}{\levelnumbers;}\f5\lang1033\f5\langfe1033\f5\f5\fi-283\li283} +{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0} +{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0} +{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0} +{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0} +{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0} +{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0} +{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0} +{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0} +{\*\soutlvl{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0}}{\listname RTF_Num 13;}\listid4} +{\list\listtemplateid5\listsimple +{\listlevel\levelnfc23\leveljc0\levelstartat1\levelfollow0{\leveltext \'01\u61602 ?;}{\levelnumbers;}\f5\f5\f5\f5\fi-283\li283} +{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0} +{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0} +{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0} +{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0} +{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0} +{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0} +{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0} +{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0} +{\*\soutlvl{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0}}{\listname RTF_Num 12;}\listid5} +{\list\listtemplateid6\listsimple +{\listlevel\levelnfc23\leveljc0\levelstartat1\levelfollow0{\leveltext \'01\u61545 ?;}{\levelnumbers;}\f5\f5\f5\f5\fi-283\li283} +{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0} +{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0} +{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0} +{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0} +{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0} +{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0} +{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0} +{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0} +{\*\soutlvl{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0}}{\listname RTF_Num 8;}\listid6} +{\list\listtemplateid7\listsimple +{\listlevel\levelnfc23\leveljc0\levelstartat1\levelfollow0{\leveltext \'01\u61602 ?;}{\levelnumbers;}\lang1033\langfe1033\f5\fi-283\li283} +{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0} +{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0} +{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0} +{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0} +{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0} +{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0} +{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0} +{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0} +{\*\soutlvl{\listlevel\levelnfc0\leveljc0\levelstartat0\levelfollow0{\leveltext \'01*;}{\levelnumbers;}\f5\f5\f5\fi0\li0}}{\listname RTF_Num 7;}\listid7} +}{\listoverridetable{\listoverride\listid1\listoverridecount0\ls0}{\listoverride\listid2\listoverridecount0\ls1}{\listoverride\listid3\listoverridecount0\ls2}{\listoverride\listid4\listoverridecount0\ls3}{\listoverride\listid5\listoverridecount0\ls4}{\listoverride\listid6\listoverridecount0\ls5}{\listoverride\listid7\listoverridecount0\ls6}} + +{\info{\title Author: }{\author FitzgibbonS}{\creatim\yr2002\mo7\dy10\hr10\min42}{\revtim\yr2003\mo5\dy15\hr18\min21}{\printim\yr0\mo0\dy0\hr0\min0}{\comment StarWriter}{\vern3100}}\deftab720 +{\*\pgdsctbl +{\pgdsc0\pgdscuse195\pgwsxn11907\pghsxn16840\marglsxn567\margrsxn7371\margtsxn567\margbsxn720\footery0{\*\footeryt174\footerxl0\footerxr0\footeryh230}{\footer \pard\plain \s1\cf0\qc{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\margtsxn0\margbsxn120\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057{\field{\*\fldinst \\page\\* ARABIC}{\fldrslt 2}}{\rtlch \ltrch\loch } +\par } +\pgdscnxt0 Standard;}} +{\*\pgdscno0}\paperh16840\paperw11907\margl567\margr7371\margt567\margb720\sectd\sbknone\pgwsxn11907\pghsxn16840\marglsxn567\margrsxn7371\margtsxn567\margbsxn950\footery720{\footer \pard\plain \s1\cf0\qc{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\margtsxn0\margbsxn350{\field{\*\fldinst \\page\\* ARABIC}{\fldrslt 2}}{\rtlch \ltrch\loch } +\par } +\ftnbj\ftnstart1\ftnrstcont\ftnnar\aenddoc\aftnrstcont\aftnstart1\aftnnrlc +\pard\plain \ltrpar\s34\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\sa120\ql {\rtlch \ltrch\loch\f1\fs20\lang2057\i\b0 Author: Symbian} +\par \pard\plain \ltrpar\s34\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\sa120\ql\rtlch\afs20\lang255\ai\ltrch\dbch\langfe1033\hich\fs20\lang2057\i\loch\fs20\lang2057\i {\rtlch \ltrch\loch\f1\fs20\lang2057\i\b0 Date: 30 January 2010} +\par \pard\plain \ltrpar\s34\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\sa120\rtlch\afs20\lang255\ai\ltrch\dbch\langfe1033\hich\fs20\lang2057\i\loch\fs20\lang2057\i {\rtlch \ltrch\loch\f1\fs20\lang2057\i\b0 Version: 1} +\par \pard\plain \ltrpar\s9\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\sb360\sa240\keepn\ql\rtlch\afs32\lang255\ab\ltrch\dbch\langfe1033\hich\fs32\lang2057\b\loch\fs32\lang2057\b {\rtlch \ltrch\loch\f1\fs32\lang2057\i0\b Podcatcher} +\par \pard\plain \ltrpar\s22\cf2{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\sb360\sa240\keepn\ql\rtlch\afs32\lang255\ab\ltrch\dbch\langfe1033\hich\fs32\lang2057\b\loch\fs32\lang2057\b {\rtlch \ltrch\loch\f1\fs32\lang2057\i0\b 0xA0009D00} +\par \pard\plain \ltrpar\s10\cf0\tqr\tx9072{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\sb120\sa120\brdrt\brdrs\brdrw20\brdrcf1\brsp20\brdrb\brdrs\brdrw20\brdrcf1\brsp20{\*\brdrt\brdlncol1\brdlnin0\brdlnout20\brdlndist0}\brsp20{\*\brdrb\brdlncol1\brdlnin0\brdlnout20\brdlndist0}\brsp20\keepn\ql\rtlch\afs24\lang255\ab\ltrch\dbch\langfe1033\hich\fs24\lang2057\b\loch\fs24\lang2057\b {\rtlch \ltrch\loch\f1\fs24\lang2057\i0\b Podcatcher} +\par \pard\plain {\listtext\pard\plain \li283\ri0\lin283\rin0\fi-283\sa120\brdrb\brdrs\brdrw1\brdrcf1\brsp20{\*\brdrb\brdlncol1\brdlnin0\brdlnout1\brdlndist0}\brsp20\fs20\langfe1033\fs20\nooverflow\faroman\f5\f5\f5 \u61602\'3f\tab}\ilvl0 \ltrpar\s35\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\ls4\nooverflow\faroman\li283\ri0\lin283\rin0\fi-283\sa120\brdrb\brdrs\brdrw1\brdrcf1\brsp20{\*\brdrb\brdlncol1\brdlnin0\brdlnout1\brdlndist0}\brsp20\ql\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057 {\rtlch \ltrch\loch\f1\fs20\lang2057\i0\b0 ContextApplication {\*\cs119\cf0\rtlch\ltrch\dbch\hich\f1\fs20\lang1033\i\loch\f1\fs20\lang1033\i Podcatcher}} +\par \pard\plain {\listtext\pard\plain \li283\ri0\lin283\rin0\fi-283\sa120\brdrb\brdrs\brdrw1\brdrcf1\brsp20{\*\brdrb\brdlncol1\brdlnin0\brdlnout1\brdlndist0}\brsp20\fs20\langfe1033\fs20\nooverflow\faroman\f5\lang1033\f5\langfe1033\f5 \u61545\'3f\tab}\ilvl0 \ltrpar\s6\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\ls3\nooverflow\faroman\li283\ri0\lin283\rin0\fi-283\sa120\brdrb\brdrs\brdrw1\brdrcf1\brsp20{\*\brdrb\brdlncol1\brdlnin0\brdlnout1\brdlndist0}\brsp20\ql\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057 {\rtlch \ltrch\loch\f1\fs20\lang2057\i0\b0 Podcatcher} +\par \pard\plain \ltrpar\s1\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\sa120\ql\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057 {\rtlch \ltrch\loch\f1\fs20\lang2057\i0\b0 Podcatcher is an application that downloads internet radio and video shows, so called Podcasts to your phone.} +\par \pard\plain \ltrpar\s1\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\sa120\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057 {\rtlch \ltrch\loch\f1\fs20\lang2057\i0\b0 Podcasts consists of {\rtlch\ltrch\hich\i\loch\i feeds}, through which {\rtlch\ltrch\hich\i\loch\i shows} are distributed.} +\par \pard\plain \ltrpar\s1\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\sa120\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057 {\rtlch \ltrch\loch\f1\fs20\lang2057\i0\b0 By adding a feed to Podcatcher, you can manually or automatically download any new shows that re published for the feed.} +\par \pard\plain \ltrpar\s1\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\sa120\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057 {\rtlch \ltrch\loch\f1\fs20\lang2057\i0\b0 Feeds are in the RSS format, and you add a feed by entering its HTTP address.} +\par \pard\plain \ltrpar\s10\cf0\tqr\tx9072{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\sb120\sa120\brdrt\brdrs\brdrw20\brdrcf1\brsp20\brdrb\brdrs\brdrw20\brdrcf1\brsp20{\*\brdrt\brdlncol1\brdlnin0\brdlnout20\brdlndist0}\brsp20{\*\brdrb\brdlncol1\brdlnin0\brdlnout20\brdlndist0}\brsp20\keepn\ql\rtlch\afs24\lang255\ab\ltrch\dbch\langfe1033\hich\fs24\lang2057\b\loch\fs24\lang2057\b {\rtlch \ltrch\loch\f1\fs24\lang2057\i0\b Feeds View} +\par \pard\plain {\listtext\pard\plain \li283\ri0\lin283\rin0\fi-283\sa120\brdrb\brdrs\brdrw1\brdrcf1\brsp20{\*\brdrb\brdlncol1\brdlnin0\brdlnout1\brdlndist0}\brsp20\fs20\langfe1033\fs20\nooverflow\faroman\lang1033\langfe1033 \u61602\'3f\tab}\ilvl0 \ltrpar\s35\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\ls6\nooverflow\faroman\li283\ri0\lin283\rin0\fi-283\sa120\brdrb\brdrs\brdrw1\brdrcf1\brsp20{\*\brdrb\brdlncol1\brdlnin0\brdlnout1\brdlndist0}\brsp20\ql\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057 {\rtlch \ltrch\loch\f1\fs20\lang2057\i0\b0 ContextFeedsView {\*\cs119\cf0\rtlch\ltrch\dbch\hich\f1\fs20\lang1033\i\loch\f1\fs20\lang1033\i Feeds View}} +\par \pard\plain {\listtext\pard\plain \li283\ri0\lin283\rin0\fi-283\sa120\brdrb\brdrs\brdrw1\brdrcf1\brsp20{\*\brdrb\brdlncol1\brdlnin0\brdlnout1\brdlndist0}\brsp20\fs20\langfe1033\fs20\nooverflow\faroman\f5\f5\f5 \u61545\'3f\tab}\ilvl0 \ltrpar\s6\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\ls5\nooverflow\faroman\li283\ri0\lin283\rin0\fi-283\sa120\brdrb\brdrs\brdrw1\brdrcf1\brsp20{\*\brdrb\brdlncol1\brdlnin0\brdlnout1\brdlndist0}\brsp20\ql\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057 {\rtlch \ltrch\loch\f1\fs20\lang2057\i0\b0 Podcatcher Feeds View} +\par \pard\plain \ltrpar\s1\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\sa120\ql\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057 {\rtlch \ltrch\loch\f1\fs20\lang2057\i0\b0 The Feeds View lists all the feeds you are subscribing too. It is the default view of Podcatcher, which you will see when you launch the application.} +\par \pard\plain \ltrpar\s1\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\sa120\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057 {\rtlch \ltrch\loch\f1\fs20\lang2057\i0\b0 From the Feeds View you can update all feeds, add, edit and remove feeds.} +\par \pard\plain \ltrpar\s10\cf0\tqr\tx9072{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\sb120\sa120\brdrt\brdrs\brdrw20\brdrcf1\brsp20\brdrb\brdrs\brdrw20\brdrcf1\brsp20{\*\brdrt\brdlncol1\brdlnin0\brdlnout20\brdlndist0}\brsp20{\*\brdrb\brdlncol1\brdlnin0\brdlnout20\brdlndist0}\brsp20\keepn\ql\rtlch\afs24\lang255\ab\ltrch\dbch\langfe1033\hich\fs24\lang2057\b\loch\fs24\lang2057\b {\rtlch \ltrch\loch\f1\fs24\lang2057\i0\b Shows View} +\par \pard\plain {\listtext\pard\plain \li283\ri0\lin283\rin0\fi-283\sa120\brdrb\brdrs\brdrw1\brdrcf1\brsp20{\*\brdrb\brdlncol1\brdlnin0\brdlnout1\brdlndist0}\brsp20\fs20\langfe1033\fs20\nooverflow\faroman\lang1033\langfe1033 \u61602\'3f\tab}\ilvl0 \ltrpar\s35\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\ls6\nooverflow\faroman\li283\ri0\lin283\rin0\fi-283\sa120\brdrb\brdrs\brdrw1\brdrcf1\brsp20{\*\brdrb\brdlncol1\brdlnin0\brdlnout1\brdlndist0}\brsp20\ql\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057 {\rtlch \ltrch\loch\f1\fs20\lang2057\i0\b0 ContextShowsView {\*\cs119\cf0\rtlch\ltrch\dbch\hich\f1\fs20\lang1033\i\loch\f1\fs20\lang1033\i Shows View}} +\par \pard\plain {\listtext\pard\plain \li283\ri0\lin283\rin0\fi-283\sa120\brdrb\brdrs\brdrw1\brdrcf1\brsp20{\*\brdrb\brdlncol1\brdlnin0\brdlnout1\brdlndist0}\brsp20\fs20\langfe1033\fs20\nooverflow\faroman\f5\f5\f5 \u61545\'3f\tab}\ilvl0 \ltrpar\s6\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\ls5\nooverflow\faroman\li283\ri0\lin283\rin0\fi-283\sa120\brdrb\brdrs\brdrw1\brdrcf1\brsp20{\*\brdrb\brdlncol1\brdlnin0\brdlnout1\brdlndist0}\brsp20\ql\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057 {\rtlch \ltrch\loch\f1\fs20\lang2057\i0\b0 Podcatcher Shows View} +\par \pard\plain \ltrpar\s1\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\sa120\ql\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057 {\rtlch \ltrch\loch\f1\fs20\lang2057\i0\b0 The Shows View lists all the available shows for a feed.} +\par \pard\plain \ltrpar\s1\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\sa120\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057 {\rtlch \ltrch\loch\f1\fs20\lang2057\i0\b0 From the Shows View you can add a show to the Download Queue by pressing Download.} +\par \pard\plain \ltrpar\s1\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\sa120\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057 {\rtlch \ltrch\loch\f1\fs20\lang2057\i0\b0 You can also mark a show as New or Old.} +\par \pard\plain \ltrpar\s10\cf0\tqr\tx9072{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\sb120\sa120\brdrt\brdrs\brdrw20\brdrcf1\brsp20\brdrb\brdrs\brdrw20\brdrcf1\brsp20{\*\brdrt\brdlncol1\brdlnin0\brdlnout20\brdlndist0}\brsp20{\*\brdrb\brdlncol1\brdlnin0\brdlnout20\brdlndist0}\brsp20\keepn\ql\rtlch\afs24\lang255\ab\ltrch\dbch\langfe1033\hich\fs24\lang2057\b\loch\fs24\lang2057\b {\rtlch \ltrch\loch\f1\fs24\lang2057\i0\b Download Queue} +\par \pard\plain {\listtext\pard\plain \li283\ri0\lin283\rin0\fi-283\sa120\brdrb\brdrs\brdrw1\brdrcf1\brsp20{\*\brdrb\brdlncol1\brdlnin0\brdlnout1\brdlndist0}\brsp20\fs20\langfe1033\fs20\nooverflow\faroman\lang1033\langfe1033 \u61602\'3f\tab}\ilvl0 \ltrpar\s35\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\ls6\nooverflow\faroman\li283\ri0\lin283\rin0\fi-283\sa120\brdrb\brdrs\brdrw1\brdrcf1\brsp20{\*\brdrb\brdlncol1\brdlnin0\brdlnout1\brdlndist0}\brsp20\ql\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057 {\rtlch \ltrch\loch\f1\fs20\lang2057\i0\b0 ContextDownloadQueue {\*\cs119\cf0\rtlch\ltrch\dbch\hich\f1\fs20\lang1033\i\loch\f1\fs20\lang1033\i Download Queue}} +\par \pard\plain {\listtext\pard\plain \li283\ri0\lin283\rin0\fi-283\sa120\brdrb\brdrs\brdrw1\brdrcf1\brsp20{\*\brdrb\brdlncol1\brdlnin0\brdlnout1\brdlndist0}\brsp20\fs20\langfe1033\fs20\nooverflow\faroman\f5\f5\f5 \u61545\'3f\tab}\ilvl0 \ltrpar\s6\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\ls5\nooverflow\faroman\li283\ri0\lin283\rin0\fi-283\sa120\brdrb\brdrs\brdrw1\brdrcf1\brsp20{\*\brdrb\brdlncol1\brdlnin0\brdlnout1\brdlndist0}\brsp20\ql\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057 {\rtlch \ltrch\loch\f1\fs20\lang2057\i0\b0 Podcatcher Download Queue} +\par \pard\plain \ltrpar\s1\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\sa120\ql\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057 {\rtlch \ltrch\loch\f1\fs20\lang2057\i0\b0 The Download Queue lists all the shows that are queued to be downloaded. } +\par \pard\plain \ltrpar\s1\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\sa120\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057 {\rtlch \ltrch\loch\f1\fs20\lang2057\i0\b0 Podcatcher will only download one show at a time.} +\par \pard\plain \ltrpar\s10\cf0\tqr\tx9072{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\sb120\sa120\brdrt\brdrs\brdrw20\brdrcf1\brsp20\brdrb\brdrs\brdrw20\brdrcf1\brsp20{\*\brdrt\brdlncol1\brdlnin0\brdlnout20\brdlndist0}\brsp20{\*\brdrb\brdlncol1\brdlnin0\brdlnout20\brdlndist0}\brsp20\keepn\ql\rtlch\afs24\lang255\ab\ltrch\dbch\langfe1033\hich\fs24\lang2057\b\loch\fs24\lang2057\b {\rtlch \ltrch\loch\f1\fs24\lang2057\i0\b Settings} +\par \pard\plain {\listtext\pard\plain \li283\ri0\lin283\rin0\fi-283\sa120\brdrb\brdrs\brdrw1\brdrcf1\brsp20{\*\brdrb\brdlncol1\brdlnin0\brdlnout1\brdlndist0}\brsp20\fs20\langfe1033\fs20\nooverflow\faroman\lang1033\langfe1033 \u61602\'3f\tab}\ilvl0 \ltrpar\s35\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\ls6\nooverflow\faroman\li283\ri0\lin283\rin0\fi-283\sa120\brdrb\brdrs\brdrw1\brdrcf1\brsp20{\*\brdrb\brdlncol1\brdlnin0\brdlnout1\brdlndist0}\brsp20\ql\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057 {\rtlch \ltrch\loch\f1\fs20\lang2057\i0\b0 ContextSettings {\*\cs119\cf0\rtlch\ltrch\dbch\hich\f1\fs20\lang1033\i\loch\f1\fs20\lang1033\i Settings}} +\par \pard\plain {\listtext\pard\plain \li283\ri0\lin283\rin0\fi-283\sa120\brdrb\brdrs\brdrw1\brdrcf1\brsp20{\*\brdrb\brdlncol1\brdlnin0\brdlnout1\brdlndist0}\brsp20\fs20\langfe1033\fs20\nooverflow\faroman\f5\f5\f5 \u61545\'3f\tab}\ilvl0 \ltrpar\s6\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\ls5\nooverflow\faroman\li283\ri0\lin283\rin0\fi-283\sa120\brdrb\brdrs\brdrw1\brdrcf1\brsp20{\*\brdrb\brdlncol1\brdlnin0\brdlnout1\brdlndist0}\brsp20\ql\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057 {\rtlch \ltrch\loch\f1\fs20\lang2057\i0\b0 Podcatcher Settings} +\par \pard\plain \ltrpar\s1\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\sa120\ql\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057 {\rtlch \ltrch\loch\f1\fs20\lang2057\i0\b0 Podcatcher has a number of settings that affects its behavior.} +\par \pard\plain {\listtext\pard\plain \li360\ri0\lin360\rin0\fi-360\sa120\fs20\langfe1033\fs20\nooverflow\faroman\f2\f2\f2 \'95\tab}\ilvl0 \ltrpar\s1\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\ls2\nooverflow\faroman\li360\ri0\lin360\rin0\fi-360\sa120\ql\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057 {\rtlch \ltrch\loch\f1\fs20\lang2057\i0\b0 Podcast Directory \'96 where Podcatcher will store downloaded shows} +\par \pard\plain {\listtext\pard\plain \li360\ri0\lin360\rin0\fi-360\sa120\fs20\langfe1033\fs20\nooverflow\faroman\f2\f2\f2 \'95\tab}\ilvl0 \ltrpar\s1\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\sa120\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057 {\rtlch \ltrch\loch\f1\fs20\lang2057\i0\b0 Automatic Update \'96 whether Podcatcher will automatically update all feeds. Automatic Update can be done either at a fixed time every day (\'93At\'94) or periodically (\'93Periodical\'94). This setting is only available when Connection is set to \'93Use specified\'94 or \'93Use + default.\'94} +\par \pard\plain {\listtext\pard\plain \li360\ri0\lin360\rin0\fi-360\sa120\fs20\langfe1033\fs20\nooverflow\faroman\f2\f2\f2 \'95\tab}\ilvl0 \ltrpar\s1\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\sa120\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057 {\rtlch \ltrch\loch\f1\fs20\lang2057\i0\b0 Update at/Update Interval \'96 specifies when automatic updates are triggered. This option is only available when Automatic Update is enabled.} +\par \pard\plain {\listtext\pard\plain \li360\ri0\lin360\rin0\fi-360\sa120\fs20\langfe1033\fs20\nooverflow\faroman\f2\f2\f2 \'95\tab}\ilvl0 \ltrpar\s1\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\sa120\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057 {\rtlch \ltrch\loch\f1\fs20\lang2057\i0\b0 Automatic Download \'96 whether Podcatcher will automatically add new shows to the Download Queue.} +\par \pard\plain {\listtext\pard\plain \li360\ri0\lin360\rin0\fi-360\sa120\fs20\langfe1033\fs20\nooverflow\faroman\f2\f2\f2 \'95\tab}\ilvl0 \ltrpar\s1\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\sa120\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057 {\rtlch \ltrch\loch\f1\fs20\lang2057\i0\b0 Connection \'96 three options are available} +\par \pard\plain {\listtext\pard\plain \li720\ri0\lin720\rin0\fi-360\sa120\fs20\langfe1033\fs20\nooverflow\faroman 1.\tab}\ilvl1 \ltrpar\s1\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\ls1\nooverflow\faroman\li720\ri0\lin720\rin0\fi-360\sa120\ql\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057 {\rtlch \ltrch\loch\f1\fs20\lang2057\i0\b0 Use Default \'96 don't ask for connection, use the best available} +\par \pard\plain {\listtext\pard\plain \li720\ri0\lin720\rin0\fi-360\sa120\fs20\langfe1033\fs20\nooverflow\faroman 2.\tab}\ilvl1 \ltrpar\s1\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\sa120\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057 {\rtlch \ltrch\loch\f1\fs20\lang2057\i0\b0 Always Ask \'96 always ask the user which connection to use} +\par \pard\plain {\listtext\pard\plain \li720\ri0\lin720\rin0\fi-360\sa120\fs20\langfe1033\fs20\nooverflow\faroman 3.\tab}\ilvl1 \ltrpar\s1\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\nooverflow\faroman\sa120\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057 {\rtlch \ltrch\loch\f1\fs20\lang2057\i0\b0 Use Specified \'96 lets the user select a connection to use. No other connection will be used.} +\par \pard\plain {\listtext\pard\plain \li360\ri0\lin360\rin0\fi-360\sa120\fs20\langfe1033\fs20\nooverflow\faroman\f2\f2\f2 \'95\tab}\ilvl0 \ltrpar\s1\cf0{\*\hyphen2\hyphlead2\hyphtrail2\hyphmax0}\ls0\nooverflow\faroman\li360\ri0\lin360\rin0\fi-360\sa120\ql\rtlch\afs20\lang255\ltrch\dbch\langfe1033\hich\fs20\lang2057\loch\fs20\lang2057 {\rtlch \ltrch\loch\f1\fs20\lang2057\i0\b0 Connections \'96 a list of available connections. This option is only available when Connection is set to \'93Use Specified.\'94} +\par } \ No newline at end of file diff -r 5f8e5adbbed9 -r 29cda98b007e application/inc/PodCastFeedViewUpdater.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/inc/PodCastFeedViewUpdater.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,47 @@ +/* +* Copyright (c) 2010 Anders Fridlund, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#ifndef PODCASTFEEDVIEWUPDATER_H_ +#define PODCASTFEEDVIEWUPDATER_H_ + +#include +class CPodcastFeedView; + +class CPodcastFeedViewUpdater : public CAsyncOneShot + { +public: + static CPodcastFeedViewUpdater* NewL(CPodcastFeedView& aPodcastFeedView); + void StartUpdate(TInt aNbrItems); + void StopUpdate(); + ~CPodcastFeedViewUpdater(); + +private: + void ConstructL(); + CPodcastFeedViewUpdater(CPodcastFeedView& aPodcastFeedView); + + // From CAsyncOneShot + void RunL(); + TInt RunError(TInt aError); + +private: + CPodcastFeedView& iPodcastFeedView; + TInt iNbrItems; + TInt iNextItem; +}; + +#endif /* PODCASTFEEDVIEWUPDATER_H_ */ diff -r 5f8e5adbbed9 -r 29cda98b007e application/inc/Podcast.hrh --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/inc/Podcast.hrh Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,100 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#ifndef PODCAST_HRH +#define PODCAST_HRH + +enum TPodcastCommandIds + { + EPodcastView = 0x1000, + EPodcastViewMain, + EPodcastViewNewShows, + EPodcastViewDownloadedShows, + EPodcastViewPendingShows, + EPodcastViewFeeds, + EPodcastPlay, + // Feeds commands + EPodcastAddFeed, + EPodcastEditFeed, + EPodcastDeleteFeed, + EPodcastDeleteFeedHardware, + EPodcastDeleteAllPlayed, + EPodcastUpdateFeed, + EPodcastUpdateAllFeeds, + EPodcastCancelUpdateAllFeeds, + EPodcastImportExportFeeds, + EPodcastImportFeeds, + EPodcastExportFeeds, + // Show commands + EPodcastDownloadShow, + EPodcastDeleteShow, + EPodcastRemoveDownload, + EPodcastRemoveAllDownloads, + EPodcastSuspendDownloads, + EPodcastResumeDownloads, + EPodcastMarkAllPlayed, + EPodcastMarkAsPlayed, + EPodcastMarkAsUnplayed, + EPodcastShowInfo, + // Common commands + EPodcastBack, + EPodcastSettings, + EPodcastSelectShowDir, + EPodcastAbout, + EPodcastHide, + EPodcastHelp, + EPodcastSearch, + EPodcastAddSearchResult +}; + +enum TPodcastControl + { + EPodcastListViewListCtrl= 0x1000, + EPodcastSettingShowDir, + EPodcastSettingAutoDownload, + EPodcastSettingAutoUpdate, + EPodcastSettingMaxsimdls, + EPodcastSettingConnection, + EPodcastSettingIAPList, + EPodcastAboutDlg, + EPodcastFeedsToolbarExtension, + EQueryControl, + EPodcastShowInfoImage, + EWaitDlg + }; + +enum TShowsIconIndex + { + EShowIcon, + ENewShowIcon, + EQuedShowIcon, + EDownloadingShowIcon, + EDownloadedShowIcon, + EDownloadedNewShowIcon, + EFailedShowIcon, + ESuspendedShowIcon + }; + +enum TConnectionSetting { + EConnectionDefault = 0, + EConnectionAlwaysAsk = 1, + EConnectionUseNetwork = 2, + EConnectionUseIap = 0x7FFF +}; + +#endif diff -r 5f8e5adbbed9 -r 29cda98b007e application/inc/PodcastApp.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/inc/PodcastApp.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,34 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#ifndef PODCASTAPP_H +#define PODCASTAPP_H + +#include + +const TUid KUidPodcast = { 0xA0009D00 }; + +class CPodcastApp : public CAknApplication + { + private: + + CApaDocument* CreateDocumentL(); + TUid AppDllUid() const; + }; + +#endif diff -r 5f8e5adbbed9 -r 29cda98b007e application/inc/PodcastAppui.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/inc/PodcastAppui.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,139 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#ifndef PODCASTAPPUI_H +#define PODCASTAPPUI_H + +#include +#include +#include +#include + +class CPodcastMainView; +class CPodcastFeedView; +class CPodcastShowsView; +class CPodcastQueueView; +class CPodcastSettingsView; +class CPodcastSearchView; +class CPodcastModel; + +const TUid KUidPodcastClientID = {0xA00046AE}; +const TUid KUidPodcastFeedViewID = {0x00000001}; +const TUid KUidPodcastShowsViewID = {0x00000002}; +const TUid KUidPodcastQueueViewID = {0x00000003}; +const TUid KUidPodcastSearchViewID = {0x00000004}; +const TUid KUidPodcastSettingsViewID = {0x00000005}; + +const TInt KTabIdFeeds = 0; +const TInt KTabIdQueue = 1; + +const TInt KTimeoutPrio = CActive::EPriorityStandard; + +class CTimeout; + +class MTimeoutObserver +{ +public: + virtual void HandleTimeout(const CTimeout& aId, TInt aError)=0; +protected: + virtual ~MTimeoutObserver() {} +}; + +class CTimeout : public CTimer +{ +public: + + static CTimeout* NewLC(MTimeoutObserver& aObserver, TInt aPrio=KTimeoutPrio) + { + CTimeout* self=new(ELeave) CTimeout(aObserver, aPrio); + CleanupStack::PushL(self); + self->ConstructL(); + return self; + } + + static CTimeout* NewL(MTimeoutObserver& aObserver, TInt aPrio=KTimeoutPrio) + { + CTimeout* self=NewLC(aObserver, aPrio); + CleanupStack::Pop(self); + return self; + } + + ~CTimeout() + { + Cancel(); + } +protected: + CTimeout(MTimeoutObserver& aObserver, TInt aPrio) : CTimer(aPrio), iObserver(aObserver) + { + CActiveScheduler::Add(this); + } + void ConstructL() + { + CTimer::ConstructL(); + } + + void RunL() + { + TInt r=iStatus.Int(); + iObserver.HandleTimeout(*this, r); + } + +protected: + MTimeoutObserver& iObserver; +}; + +class CPodcastAppUi : public CAknViewAppUi, public MAknTabObserver, MTimeoutObserver + { + public: + CPodcastAppUi(CPodcastModel* aPodcastModel); + void ConstructL(); + ~CPodcastAppUi(); + + void SetActiveTab(TInt aIndex); + void UpdateQueueTab(TInt aQueueLength); + void TabLeft(); + void TabRight(); + private: + // From MEikMenuObserver + void DynInitMenuPaneL(TInt aResourceId,CEikMenuPane* aMenuPane); + void TabChangedL (TInt aIndex); + CArrayFix* HelpContextL() const; + private: + void HandleCommandL(TInt aCommand); + void NaviShowTabGroupL(); + protected: + void HandleTimeout(const CTimeout& aId, TInt aError); + + private: + CPodcastMainView *iMainView; + CPodcastFeedView* iFeedView; + CPodcastShowsView* iShowsView; + CPodcastQueueView* iQueueView; + CPodcastSearchView* iSearchView; + CPodcastSettingsView* iSettingsView; + + CPodcastModel* iPodcastModel; + + CAknNavigationDecorator* iNaviDecorator; + CAknTabGroup* iTabGroup; + CAknNavigationControlContainer* iNaviPane; + + CTimeout* iStartTimer; + }; + +#endif diff -r 5f8e5adbbed9 -r 29cda98b007e application/inc/PodcastDocument.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/inc/PodcastDocument.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,42 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#ifndef PODCASTDOCUMENT_H +#define PODCASTDOCUMENT_H + +#include + +class CEikAppUi; +class CPodcastModel; +class CPodcastDocument : public CAknDocument + { + public: + static CPodcastDocument* NewL( CEikApplication& aApp ); + virtual ~CPodcastDocument(); + + private: + CPodcastDocument( CEikApplication& aApp ); + void ConstructL(); + + private: + CEikAppUi* CreateAppUiL(); + CPodcastModel* iPodcastModel; + }; + +#endif + diff -r 5f8e5adbbed9 -r 29cda98b007e application/inc/PodcastFeedView.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/inc/PodcastFeedView.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,118 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#ifndef PODCASTFEEDVIEWH +#define PODCASTFEEDVIEWH + +#include "FeedEngine.h" +#include "PodcastListView.h" +#include "ImageHandler.h" + +class CPodcastFeedViewUpdater; + +enum TOpmlState { + EOpmlIdle, + EOpmlImporting, + EOpmlSearching +}; + +class CPodcastFeedView : public CPodcastListView, public MEikListBoxObserver, + public MFeedEngineObserver, public MImageHandlerCallback + { + public: + static CPodcastFeedView* NewL(CPodcastModel& aPodcastModel); + static CPodcastFeedView* NewLC(CPodcastModel& aPodcastModel); + ~CPodcastFeedView(); + void UpdateItemL(TInt aIndex); + void CheckResumeDownload(); + + protected: + void ConstructL(); + CPodcastFeedView(CPodcastModel& aPodcastModel); + + /** + * Returns views id, intended for overriding by sub classes. + * @return id for this view. + */ + TUid Id() const; + + /** + * Handles a view activation and passes the message of type + * @c aCustomMessageId. This function is intended for overriding by + * sub classes. This function is called by @c AknViewActivatedL(). + * @param aPrevViewId Specifies the view previously active. + * @param aCustomMessageId Specifies the message type. + * @param aCustomMessage The activation message. + */ + void DoActivateL(const TVwsViewId& aPrevViewId, + TUid aCustomMessageId, + const TDesC8& aCustomMessage); + + /** + * View deactivation function intended for overriding by sub classes. + * This function is called by @c AknViewDeactivated(). + */ + void DoDeactivate(); + + + // From // MEikListBoxObserverClass + void HandleListBoxEventL(CEikListBox* aListBox, TListBoxEvent aEventType); + void UpdateListboxItemsL(); + + // from MFeedEngineObserver + void FeedDownloadStartedL(TFeedState aState,TUint aFeedUid); + void FeedDownloadFinishedL(TFeedState aState,TUint aFeeidUid, TInt aError); + void FeedUpdateAllCompleteL(TFeedState aState); + void OpmlParsingComplete(TUint aNumFeedsImported); + + /** + * Command handling function intended for overriding by sub classes. + * Default implementation is empty. + * @param aCommand ID of the command to respond to. + */ + void HandleCommandL(TInt aCommand); + void FeedInfoUpdatedL(TUint aFeedUid); + void UpdateFeedInfoDataL(CFeedInfo* aFeedInfo, TInt aIndex, TBool aIsUpdating = EFalse); + void UpdateFeedInfoStatusL(TUint aFeedUid, TBool aIsUpdating = EFalse); + + void UpdateToolbar(); + // from MProgressDialogCallback + void DialogDismissedL(TInt aButtonId); + + // from MImageHandlerCallback + void ImageOperationCompleteL(TInt aError); + private: + void FormatFeedInfoListBoxItemL(CFeedInfo& aFeedInfo, TBool aIsUpdating = EFalse); + void HandleAddFeedL(); + void HandleEditFeedL(); + void HandleRemoveFeedL(); + void HandleImportFeedsL(); + void HandleExportFeedsL(); + void HandleUpdateFeedL(); + + private: + CPodcastModel& iPodcastModel; + TBool iUpdatingAllRunning; + HBufC* iFeedsFormat; + HBufC* iNeverUpdated; + CPodcastFeedViewUpdater* iUpdater; + TBool iFirstActivateAfterLaunch; + TOpmlState iOpmlState; +}; + +#endif // PODCASTFEEDVIEWH diff -r 5f8e5adbbed9 -r 29cda98b007e application/inc/PodcastListView.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/inc/PodcastListView.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,169 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#ifndef PODCASTLISTVIEWH +#define PODCASTLISTVIEWH + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "PodcastModel.h" + +class CAknDoubleLargeStyleListBox; +class CEikFormattedCellListBox; + + +class MKeyEventListener { +public: +virtual TKeyResponse OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType) = 0; +}; + +class MPointerListener { +public: +virtual void PointerEventL(const TPointerEvent& aPointerEvent) = 0; +}; + +class CPodcastListContainer : public CCoeControl + { + public: + CPodcastListContainer(); + ~CPodcastListContainer(); + void ConstructL( const TRect& aRect, TInt aListboxFlags ); + void SizeChanged(); + TInt CountComponentControls() const; + CCoeControl* ComponentControl( TInt aIndex ) const; + void HandleResourceChange(TInt aType); + virtual TKeyResponse OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType); + void SetKeyEventListener(MKeyEventListener *aKeyEventListener); + void SetPointerListener(MPointerListener *aPointerListener); + + CEikFormattedCellListBox* Listbox(); + void ScrollToVisible(); + void Draw(const TRect& aRect) const; + CEikFormattedCellListBox * iListbox; + + protected: + TTypeUid::Ptr MopSupplyObject( TTypeUid aId ); + virtual void HandlePointerEventL(const TPointerEvent& aPointerEvent); + + private: + MKeyEventListener* iKeyEventListener; + MPointerListener* iPointerListener; + CAknsBasicBackgroundControlContext* iBgContext; + }; + + +class CPodcastListView : public CAknView, public MAknToolbarObserver, +public MPointerListener, public MAknLongTapDetectorCallBack, +public MProgressDialogCallback, public MKeyEventListener + { + public: + ~CPodcastListView(); + protected: + void ConstructL(); + CPodcastListView(); + + /** + * Handles a view activation and passes the message of type + * @c aCustomMessageId. This function is intended for overriding by + * sub classes. This function is called by @c AknViewActivatedL(). + * @param aPrevViewId Specifies the view previously active. + * @param aCustomMessageId Specifies the message type. + * @param aCustomMessage The activation message. + */ + void DoActivateL(const TVwsViewId& aPrevViewId, + TUid aCustomMessageId, + const TDesC8& aCustomMessage); + + /** + * View deactivation function intended for overriding by sub classes. + * This function is called by @c AknViewDeactivated(). + */ + void DoDeactivate(); + + void HandleViewRectChange(); + + /** + * Event handler for status pane size changes. + * @c CAknView provides an empty implementation for sub classes that do + * not want to handle this event. + */ + void HandleStatusPaneSizeChange(); + + /** + * Command handling function intended for overriding by sub classes. + * Default implementation is empty. + * @param aCommand ID of the command to respond to. + */ + void HandleCommandL(TInt aCommand); + + void OfferToolbarEventL(TInt aCommand); + void DynInitToolbarL (TInt aResourceId, CAknToolbar *aToolbar); + + virtual void UpdateListboxItemsL() = 0; + + void RunAboutDialogL(); + void SetEmptyTextL(TInt aResourceId); + void ShowOkMessage(TDesC &aText); + void ShowErrorMessage(TDesC &aText); + TInt ShowQueryMessage(TDesC &aText); + void CloseToolbarExtension(); + void ShowWaitDialogL(TDesC &aWaitText); + void CloseWaitDialog(); + + // From MAknLongTapDetectorCallBack + virtual void HandleLongTapEventL( const TPoint& aPenEventLocation, const TPoint& aPenEventScreenLocation ); + + // from MProgressDialogCallback + void DialogDismissedL(TInt /*aButtonId*/) {} + + // from MKeyEventListener + virtual TKeyResponse OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType); + + // from MPointerListener + void PointerEventL(const TPointerEvent& aPointerEvent); + + virtual void UpdateToolbar() = 0; + protected: + CPodcastListContainer* iListContainer; + /** Previous activated view */ + TVwsViewId iPreviousView; + + /** Listbox flags which the listbox is created with*/ + TInt iListboxFlags; + + CDesCArray* iItemArray; + RArray iItemIdArray; + + TBuf<1024> iListboxFormatbuffer; + + CAknToolbar *iToolbar; + CAknStylusPopUpMenu* iStylusPopupMenu; + CAknLongTapDetector* iLongTapDetector; + CAknWaitDialog *iWaitDialog; + + }; +#endif // PODCASTBASEVIEWH + diff -r 5f8e5adbbed9 -r 29cda98b007e application/inc/PodcastQueueView.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/inc/PodcastQueueView.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,114 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#ifndef PODCASTQUEUEVIEWH +#define PODCASTQUEUEVIEWH + +#include +#include +#include +#include +#include +#include "ShowEngine.h" +#include "FeedEngine.h" +#include "PodcastModel.h" +#include "Podcast.hrh" +#include "PodcastListView.h" + +class CPodcastQueueView : public CPodcastListView, public MEikListBoxObserver, + public MFeedEngineObserver, public MShowEngineObserver + { +public: + static CPodcastQueueView* NewL(CPodcastModel& aPodcastModel); + static CPodcastQueueView* NewLC(CPodcastModel& aPodcastModel); + ~CPodcastQueueView(); +protected: + void ConstructL(); + CPodcastQueueView(CPodcastModel& aPodcastModel); + + /** + * Returns views id, intended for overriding by sub classes. + * @return id for this view. + */ + TUid Id() const; + + /** + * Handles a view activation and passes the message of type + * @c aCustomMessageId. This function is intended for overriding by + * sub classes. This function is called by @c AknViewActivatedL(). + * @param aPrevViewId Specifies the view previously active. + * @param aCustomMessageId Specifies the message type. + * @param aCustomMessage The activation message. + */ + void DoActivateL(const TVwsViewId& aPrevViewId, + TUid aCustomMessageId, + const TDesC8& aCustomMessage); + + /** + * View deactivation function intended for overriding by sub classes. + * This function is called by @c AknViewDeactivated(). + */ + void DoDeactivate(); + + void UpdateListboxItemsL(); + + // From // MEikListBoxObserverClass + void HandleListBoxEventL(CEikListBox* aListBox, TListBoxEvent aEventType); + // From showengine observer + void ShowListUpdatedL(); + void ShowDownloadUpdatedL(TInt aBytesOfCurrentDownload, TInt aBytesTotal); + void DownloadQueueUpdatedL(TInt aDownloadingShows, TInt aQueuedShows); + void ShowDownloadFinishedL(TUint aShowUid, TInt aError) ; + // from MFeedEngineObserver + void FeedDownloadStartedL(TFeedState aState,TUint aFeedUid); + void FeedDownloadFinishedL(TFeedState aState,TUint aFeedUid, TInt aError); + void FeedUpdateAllCompleteL(TFeedState aState); + void OpmlParsingComplete(TUint /*aNumFeedsImported*/) {} + + /** + * Command handling function intended for overriding by sub classes. + * Default implementation is empty. + * @param aCommand ID of the command to respond to. + */ + void HandleCommandL(TInt aCommand); + TKeyResponse OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType); + + void UpdateFeedUpdateStateL(); + void UpdateShowItemL(TUint aUid, TInt aSizeDownloaded); + void UpdateShowItemDataL(CShowInfo* aShowInfo,TInt aIndex, TInt aSizeDownloaded = KErrNotFound); + void DynInitMenuPaneL(TInt aResourceId,CEikMenuPane* aMenuPane); + void FormatShowInfoListBoxItemL(CShowInfo& aShowInfo, TInt aSizeDownloaded = 0); + + void HandleLongTapEventL( const TPoint& aPenEventLocation, const TPoint& aPenEventScreenLocation); + +private: + void GetShowIcons(CShowInfo* aShowInfo, TInt& aIconIndex); + void UpdateToolbar(); + + +private: + + CPodcastModel& iPodcastModel; + TBool iProgressAdded; + TInt iLastImageHandlerError; + TBool iSetTitlebarImage; + }; + +#endif // PODCASTSHOWSVIEWH + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/inc/PodcastSearchView.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/inc/PodcastSearchView.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,88 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#ifndef PODCASTSEARCHVIEW_H +#define PODCASTSEARCHVIEW_H + +#include +#include "FeedEngine.h" +#include "PodcastModel.h" +#include "PodcastListView.h" +#include "Podcast.hrh" + +class CPodcastSearchView : public CPodcastListView, public MEikListBoxObserver, + public MFeedEngineObserver + { + public: + static CPodcastSearchView* NewL(CPodcastModel& aPodcastModel); + static CPodcastSearchView* NewLC(CPodcastModel& aPodcastModel); + ~CPodcastSearchView(); + + protected: + void ConstructL(); + CPodcastSearchView(CPodcastModel& aPodcastModel); + + /** + * Returns views id, intended for overriding by sub classes. + * @return id for this view. + */ + TUid Id() const; + + /** + * Handles a view activation and passes the message of type + * @c aCustomMessageId. This function is intended for overriding by + * sub classes. This function is called by @c AknViewActivatedL(). + * @param aPrevViewId Specifies the view previously active. + * @param aCustomMessageId Specifies the message type. + * @param aCustomMessage The activation message. + */ + void DoActivateL(const TVwsViewId& aPrevViewId, + TUid aCustomMessageId, + const TDesC8& aCustomMessage); + + /** + * View deactivation function intended for overriding by sub classes. + * This function is called by @c AknViewDeactivated(). + */ + void DoDeactivate(); + + // from MEikListBoxObserverClass + void HandleListBoxEventL(CEikListBox* aListBox, TListBoxEvent aEventType); + void UpdateListboxItemsL(); + + // from MFeedEngineObserver + void FeedDownloadStartedL(TFeedState /*aState*/,TUint /*aFeedUid*/) {} + void FeedDownloadFinishedL(TFeedState /*aState*/,TUint /*aFeedUid*/, TInt /*aError*/) {} + void FeedUpdateAllCompleteL(TFeedState /*aState*/) {} + void OpmlParsingComplete(TUint aNumFeedsImported); + + /** + * Command handling function intended for overriding by sub classes. + * Default implementation is empty. + * @param aCommand ID of the command to respond to. + */ + void HandleCommandL(TInt aCommand); + + void UpdateToolbar(); + + private: + CPodcastModel& iPodcastModel; + TBool iSearchRunning; +}; + +#endif // PODCASTSEARCHVIEW_H diff -r 5f8e5adbbed9 -r 29cda98b007e application/inc/PodcastSettingsView.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/inc/PodcastSettingsView.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,85 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#ifndef PODCASTSETTINGSVIEWH +#define PODCASTSETTINGSVIEWH + +#include +#include +#include "ShowEngineObserver.h" +#include "PodcastModel.h" + +class CPodcastSettingsContainer; +class CPodcastSettingItemList; + +class CPodcastSettingsView : public CAknView + { + public: + static CPodcastSettingsView* NewL(CPodcastModel& aPodcastModel); + static CPodcastSettingsView* NewLC(CPodcastModel& aPodcastModel); + ~CPodcastSettingsView(); + protected: + void ConstructL(); + CPodcastSettingsView(CPodcastModel& aPodcastModel); + + /** + * Returns views id, intended for overriding by sub classes. + * @return id for this view. + */ + TUid Id() const; + + /** + * Handles a view activation and passes the message of type + * @c aCustomMessageId. This function is intended for overriding by + * sub classes. This function is called by @c AknViewActivatedL(). + * @param aPrevViewId Specifies the view previously active. + * @param aCustomMessageId Specifies the message type. + * @param aCustomMessage The activation message. + */ + void DoActivateL(const TVwsViewId& aPrevViewId, + TUid aCustomMessageId, + const TDesC8& aCustomMessage); + + /** + * View deactivation function intended for overriding by sub classes. + * This function is called by @c AknViewDeactivated(). + */ + void DoDeactivate(); + + /** + * Command handling function intended for overriding by sub classes. + * Default implementation is empty. + * @param aCommand ID of the command to respond to. + */ + void HandleCommandL(TInt aCommand); + void HandleStatusPaneSizeChange(); + + private: + //CPodcastSettingsContainer* iSettingsContainer; + CPodcastModel& iPodcastModel; + /** Previous activated view */ + TVwsViewId iPreviousView; + TInt iAutoDownloadValue; + CAknNavigationDecorator* iNaviDecorator; + CAknNavigationControlContainer* iNaviPane; + CPodcastSettingItemList * iListbox; +}; + +#endif // PODCASTSETTINGSVIEWH + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/inc/PodcastShowsView.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/inc/PodcastShowsView.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,128 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#ifndef PODCASTSHOWSVIEWH +#define PODCASTSHOWSVIEWH + +#include +#include +#include +#include +#include +#include "ShowEngine.h" +#include "FeedEngine.h" +#include "PodcastModel.h" +#include "Podcast.hrh" +#include "PodcastListView.h" +#include "Imagehandler.h" + +class CImageHandler; + +class CPodcastShowsView : public CPodcastListView, public MEikListBoxObserver, + public MFeedEngineObserver, public MShowEngineObserver, public MImageHandlerCallback + { +public: + static CPodcastShowsView* NewL(CPodcastModel& aPodcastModel); + static CPodcastShowsView* NewLC(CPodcastModel& aPodcastModel); + ~CPodcastShowsView(); +protected: + void ConstructL(); + CPodcastShowsView(CPodcastModel& aPodcastModel); + + /** + * Returns views id, intended for overriding by sub classes. + * @return id for this view. + */ + TUid Id() const; + + /** + * Handles a view activation and passes the message of type + * @c aCustomMessageId. This function is intended for overriding by + * sub classes. This function is called by @c AknViewActivatedL(). + * @param aPrevViewId Specifies the view previously active. + * @param aCustomMessageId Specifies the message type. + * @param aCustomMessage The activation message. + */ + void DoActivateL(const TVwsViewId& aPrevViewId, + TUid aCustomMessageId, + const TDesC8& aCustomMessage); + + /** + * View deactivation function intended for overriding by sub classes. + * This function is called by @c AknViewDeactivated(). + */ + void DoDeactivate(); + + void UpdateListboxItemsL(); + + // From // MEikListBoxObserverClass + void HandleListBoxEventL(CEikListBox* aListBox, TListBoxEvent aEventType); + // From showengine observer + void ShowListUpdatedL(); + void ShowDownloadUpdatedL(TInt aBytesOfCurrentDownload, TInt aBytesTotal); + void DownloadQueueUpdatedL(TInt aDownloadingShows, TInt aQueuedShows); + void ShowDownloadFinishedL(TUint aShowUid, TInt aError) ; + // from MFeedEngineObserver + void FeedDownloadStartedL(TFeedState aState,TUint aFeedUid); + void FeedDownloadFinishedL(TFeedState aState,TUint aFeedUid, TInt aError); + void FeedUpdateAllCompleteL(TFeedState aState); + void OpmlParsingComplete(TUint /*aNumFeedsImported*/) {} + + /** + * Command handling function intended for overriding by sub classes. + * Default implementation is empty. + * @param aCommand ID of the command to respond to. + */ + void HandleCommandL(TInt aCommand); + TKeyResponse OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType); + + void UpdateFeedUpdateStateL(); + void UpdateShowItemL(TUint aUid, TInt aSizeDownloaded); + void UpdateShowItemDataL(CShowInfo* aShowInfo,TInt aIndex, TInt aSizeDownloaded = KErrNotFound); + void DynInitMenuPaneL(TInt aResourceId,CEikMenuPane* aMenuPane); + void FormatShowInfoListBoxItemL(CShowInfo& aShowInfo, TInt aSizeDownloaded = 0); + + void HandleLongTapEventL( const TPoint& aPenEventLocation, const TPoint& aPenEventScreenLocation); + +private: + void GetShowIcons(CShowInfo* aShowInfo, TInt& aIconIndex); + void UpdateToolbar(); + void DisplayShowInfoDialogL(); + /* + * Called by CImageHandler when an image has been loaded. + * @param aError Error code given by the CImageHandler or 0 (zero) if the + * image was loaded successfully. + */ + virtual void ImageOperationCompleteL(TInt aError); + void SetShowPlayed(TBool aPlayed); + void DeleteShow(); + void UpdateViewTitleL(); + void CreateIconsL(); + void GetShowErrorText(TDes &aErrorMessage, TInt aErrorCode); + +private: + + CPodcastModel& iPodcastModel; + TBool iProgressAdded; + TInt iLastImageHandlerError; + TBool iSetTitlebarImage; + }; + +#endif // PODCASTSHOWSVIEWH + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/sis/backup_registration.xml --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/sis/backup_registration.xml Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,12 @@ + + + + + + + + + + + + diff -r 5f8e5adbbed9 -r 29cda98b007e application/sis/make_s60_5th_sis.cmd --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/sis/make_s60_5th_sis.cmd Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,6 @@ +del *.sis +makesis -dc:\symbian\S60_5th_Edition_SDK_v1.0 podcatcher_udeb.pkg +signsis podcatcher_udeb.sis podcatcher_udeb_signed.sis podcast.cer podcast.key + +makesis -dc:\symbian\S60_5th_Edition_SDK_v1.0 podcatcher_urel.pkg +signsis podcatcher_urel.sis podcatcher_urel_signed.sis podcast.cer podcast.key \ No newline at end of file diff -r 5f8e5adbbed9 -r 29cda98b007e application/sis/podcast.cer --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/sis/podcast.cer Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,19 @@ +-----BEGIN CERTIFICATE----- +MIIDHzCCAt2gAwIBAgIBADALBgcqhkjOOAQDBQAwdTELMAkGA1UEBhMCU0UxETAP +BgNVBAoTCEJlcmdhbW90MRQwEgYDVQQLEwtEZXZlbG9wbWVudDETMBEGA1UEAxMK +V29ybGQgVXNlcjEoMCYGCSqGSIb3DQEJARYZYmVyZ2Ftb3RAZ29vZ2xlZ3JvdXBz +LmNvbTAeFw0wOTEyMTUyMDQ2MTFaFw0xODAzMDMyMDQ2MTFaMHUxCzAJBgNVBAYT +AlNFMREwDwYDVQQKEwhCZXJnYW1vdDEUMBIGA1UECxMLRGV2ZWxvcG1lbnQxEzAR +BgNVBAMTCldvcmxkIFVzZXIxKDAmBgkqhkiG9w0BCQEWGWJlcmdhbW90QGdvb2ds +ZWdyb3Vwcy5jb20wggG2MIIBKwYHKoZIzjgEATCCAR4CgYEAgbCoT/vP8W/B65X4 +JRvTIap4oIoaKg/1RH5YVUnaRG/kuuZJUC3c79X15C2WtexdbAFUYOfQMVzIhekr +dFyXvQfArbvvQFI1E5nKHcrnIefe96XZMt5wiP80fCsnmj0utpPEwMMzE2UtX0BY +Llb9Xy7HVauZf4w+/hk66H3XhLECFQCjCA801nDjpTrIjQT9A8PO5YRTxQKBgEnf +6waZ4wriaqu9u8AANncLUr+OV0HOqRB8ocio7oxOLLd5TOTvpFtPZL/Gwr+/cGj3 +ZEah0pyAYlivS/FrKn874UksbIjFmBq07YxCv5oZA7SIJIGBqpi+/HZKB5pKThNN +PAvqm6CV6QKDv41Z5D/Zwf38RVO3d3spPemLVLV2A4GEAAKBgCNq+QlVxi+wTzk0 +qFDGi/fT9hv0E/I5Ticd90+xLsB0bDIIW+aesacItd4XbOZPRJAKnjJyHI8459K8 ++qidHZAUMg+o2P5Gws5HtWNXQrhBSjuA12w5ShojUkYcDUBMGv3GhITQ9NbT8N7m +6CmSayODBXTzwkVazXqy4F+NeW3NMAsGByqGSM44BAMFAAMvADAsAhRiNUWMQZV7 +5dN/l0QjDc+qENqHWwIUDYYuvVK/F1UsKOMhrNhZ8+wfANY= +-----END CERTIFICATE----- diff -r 5f8e5adbbed9 -r 29cda98b007e application/sis/podcast.key --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/sis/podcast.key Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,12 @@ +-----BEGIN DSA PRIVATE KEY----- +MIIBugIBAAKBgQCBsKhP+8/xb8HrlfglG9MhqnigihoqD/VEflhVSdpEb+S65klQ +Ldzv1fXkLZa17F1sAVRg59AxXMiF6St0XJe9B8Ctu+9AUjUTmcodyuch5973pdky +3nCI/zR8KyeaPS62k8TAwzMTZS1fQFguVv1fLsdVq5l/jD7+GTrofdeEsQIVAKMI +DzTWcOOlOsiNBP0Dw87lhFPFAoGASd/rBpnjCuJqq727wAA2dwtSv45XQc6pEHyh +yKjujE4st3lM5O+kW09kv8bCv79waPdkRqHSnIBiWK9L8WsqfzvhSSxsiMWYGrTt +jEK/mhkDtIgkgYGqmL78dkoHmkpOE008C+qboJXpAoO/jVnkP9nB/fxFU7d3eyk9 +6YtUtXYCgYAjavkJVcYvsE85NKhQxov30/Yb9BPyOU4nHfdPsS7AdGwyCFvmnrGn +CLXeF2zmT0SQCp4ychyPOOfSvPqonR2QFDIPqNj+RsLOR7VjV0K4QUo7gNdsOUoa +I1JGHA1ATBr9xoSE0PTW0/De5ugpkmsjgwV088JFWs16suBfjXltzQIUUmkXpM64 +yxIBqo9sB3AG94V8598= +-----END DSA PRIVATE KEY----- diff -r 5f8e5adbbed9 -r 29cda98b007e application/sis/podcatcher_udeb.pkg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/sis/podcatcher_udeb.pkg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,30 @@ +&EN +:"Symbian Foundation" +%{"Podcatcher"} +#{"Podcatcher"},(0xA0009D00), 1, 00, 0, TYPE=SA + +;Supports S60 3rd edition +[0x101F7961], 0, 0, 0, {"Series60ProductID"} + +;Supports Symbian^1 +[0x1028315F], 0, 0, 0, {"Series60ProductID"} + +; resources +"\epoc32\data\z\resource\apps\Podcast.RSC"-"!:\resource\apps\Podcast.rsc" +"\epoc32\data\z\resource\apps\Podcast.mif"-"!:\resource\apps\Podcast.mif" +"\epoc32\data\z\private\10003a3f\import\apps\Podcast_reg.rsc"-"!:\private\10003a3f\import\apps\Podcast_reg.rsc" +"..\help\podcatcher.hlp"-"!:\resource\help\podcatcher.hlp" + +; configuration and DB +"../../engine/config/config.cfg"-"!:\private\A0009D00\config.cfg" +"../../engine/config/defaultfeeds.xml"-"!:\private\A0009D00\defaultfeeds.xml" +"../../engine/config/podcatcher.sqlite"-"!:\private\A0009D00\podcatcher.sqlite.template" + +; backup +"./backup_registration.xml" - "!:\private\A0009D00\backup_registration.xml" + +; app DLL +;"\epoc32\release\gcce\udeb\podcastengine.dll"-"!:\sys\bin\podcastengine.dll" + +; application UI - note that FR,RI does not work when SIS is self signed +"\epoc32\release\gcce\udeb\Podcast.exe"-"!:\sys\bin\Podcast.exe",FR,RI diff -r 5f8e5adbbed9 -r 29cda98b007e application/sis/podcatcher_udeb.sis Binary file application/sis/podcatcher_udeb.sis has changed diff -r 5f8e5adbbed9 -r 29cda98b007e application/sis/podcatcher_udeb_signed.sis Binary file application/sis/podcatcher_udeb_signed.sis has changed diff -r 5f8e5adbbed9 -r 29cda98b007e application/sis/podcatcher_urel.pkg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/sis/podcatcher_urel.pkg Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,30 @@ +&EN +:"Symbian Foundation" +%{"Podcatcher"} +#{"Podcatcher"},(0xA0009D00), 1, 00, 0, TYPE=SA + +;Supports S60 3rd edition +[0x101F7961], 0, 0, 0, {"Series60ProductID"} + +;Supports Symbian^1 +[0x1028315F], 0, 0, 0, {"Series60ProductID"} + +; resources +"\epoc32\data\z\resource\apps\Podcast.RSC"-"!:\resource\apps\Podcast.rsc" +"\epoc32\data\z\resource\apps\Podcast.mif"-"!:\resource\apps\Podcast.mif" +"\epoc32\data\z\private\10003a3f\import\apps\Podcast_reg.rsc"-"!:\private\10003a3f\import\apps\Podcast_reg.rsc" +"..\help\podcatcher.hlp"-"!:\resource\help\podcatcher.hlp" + +; configuration and DB +"../../engine/config/config.cfg"-"!:\private\A0009D00\config.cfg" +"../../engine/config/defaultfeeds.xml"-"!:\private\A0009D00\defaultfeeds.xml" +"../../engine/config/podcatcher.sqlite"-"!:\private\A0009D00\podcatcher.sqlite.template" + +; backup +"./backup_registration.xml" - "!:\private\A0009D00\backup_registration.xml" + +; app DLL +;"\epoc32\release\gcce\urel\podcastengine.dll"-"!:\sys\bin\podcastengine.dll" + +; application UI - note that FR,RI does not work when SIS is self signed +"\epoc32\release\gcce\urel\Podcast.exe"-"!:\sys\bin\Podcast.exe",FR,RI diff -r 5f8e5adbbed9 -r 29cda98b007e application/sis/podcatcher_urel.sis Binary file application/sis/podcatcher_urel.sis has changed diff -r 5f8e5adbbed9 -r 29cda98b007e application/sis/podcatcher_urel_signed.sis Binary file application/sis/podcatcher_urel_signed.sis has changed diff -r 5f8e5adbbed9 -r 29cda98b007e application/src/Podcast.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/src/Podcast.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,31 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +// INCLUDE FILES +#include +#include "PodcastApp.h" + +LOCAL_C CApaApplication* NewApplication() + { + return new CPodcastApp; + } + +GLDEF_C TInt E32Main() + { + return EikStart::RunApplication( NewApplication ); + } diff -r 5f8e5adbbed9 -r 29cda98b007e application/src/PodcastApp.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/src/PodcastApp.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,31 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#include "PodcastApp.h" +#include "PodcastDocument.h" + +TUid CPodcastApp::AppDllUid() const + { + return KUidPodcast; + } + +CApaDocument* CPodcastApp::CreateDocumentL() + { + return CPodcastDocument::NewL( *this ); + } + diff -r 5f8e5adbbed9 -r 29cda98b007e application/src/PodcastAppui.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/src/PodcastAppui.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,244 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#include "PodcastAppui.h" +#include +#include "Podcast.hrh" +#include "PodcastFeedView.h" +#include "PodcastShowsView.h" +#include "PodcastQueueView.h" +#include "PodcastSettingsView.h" +#include "PodcastSearchView.h" +#include "ShowEngine.h" +#include "PodcastModel.h" +#include "debug.h" +#include "..\help\podcatcher.hlp.hrh" +#include "PodcastApp.h" + +#include +#include + +const TUint KDelayLaunch = 1000; + +CPodcastAppUi::CPodcastAppUi(CPodcastModel* aPodcastModel):iPodcastModel(aPodcastModel) + { + + } + +void CPodcastAppUi::ConstructL() + { + DP("CPodcastAppUi::ConstructL() BEGIN"); + BaseConstructL(CAknAppUi::EAknEnableSkin); + + DP("Constructing FeedView"); + iFeedView = CPodcastFeedView::NewL(*iPodcastModel); + this->AddViewL(iFeedView); + + DP("Constructing ShowsView"); + iShowsView = CPodcastShowsView::NewL(*iPodcastModel); + this->AddViewL(iShowsView); + + DP("Constructing QueueView"); + iQueueView = CPodcastQueueView::NewL(*iPodcastModel); + this->AddViewL(iQueueView); + + DP("Constructing SearchView"); + iSearchView = CPodcastSearchView::NewL(*iPodcastModel); + this->AddViewL(iSearchView); + + DP("Constructing SettingsView"); + iSettingsView = CPodcastSettingsView::NewL(*iPodcastModel); + this->AddViewL(iSettingsView); + + iNaviPane =( CAknNavigationControlContainer * ) StatusPane()->ControlL( TUid::Uid( EEikStatusPaneUidNavi ) ); + NaviShowTabGroupL(); + + // start a timer to let ConstructL finish before we display any dialogs or start downloading + // this provides another entry point in HandleTimeout below + iStartTimer = CTimeout::NewL(*this); + iStartTimer->After(KDelayLaunch); + DP("CPodcastAppUi::ConstructL() END"); + } + +CPodcastAppUi::~CPodcastAppUi() + { + if(iNaviDecorator) + { + iNaviPane->Pop(iNaviDecorator); + delete iNaviDecorator; + } + delete iStartTimer; + } + +// ----------------------------------------------------------------------------- +// CPodcastAppUi::DynInitMenuPaneL(TInt aResourceId,CEikMenuPane* aMenuPane) +// This function is called by the EIKON framework just before it displays +// a menu pane. Its default implementation is empty, and by overriding it, +// the application can set the state of menu items dynamically according +// to the state of application data. +// ------------------------------------------------------------------------------ +// +void CPodcastAppUi::DynInitMenuPaneL( + TInt /*aResourceId*/,CEikMenuPane* /*aMenuPane*/) + { + // no implementation required + } + +// ----------------------------------------------------------------------------- +// CPodcastAppUi::HandleCommandL(TInt aCommand) +// takes care of command handling +// ----------------------------------------------------------------------------- +// +void CPodcastAppUi::HandleCommandL( TInt aCommand ) + { + switch ( aCommand ) + { + case EAknSoftkeyExit: + { + Exit(); + break; + } + case EEikCmdExit: + { + TApaTask task(CEikonEnv::Static()->WsSession()); + task.SetWgId(CEikonEnv::Static()->RootWin().Identifier()); + task.SendToBackground(); + break; + } + case EPodcastHelp: + { + CArrayFix* buf = CPodcastAppUi::AppHelpContextL(); + HlpLauncher::LaunchHelpApplicationL(iEikonEnv->WsSession(), buf); + } + break; + default: + break; + } + } + +CArrayFix* CPodcastAppUi::HelpContextL() const + { + CArrayFixFlat* array = + new(ELeave)CArrayFixFlat(1); + CleanupStack::PushL(array); + // todo: view detection doesn't seem to work + if (ViewShown(KUidPodcastSearchViewID)) { + array->AppendL(TCoeHelpContext(KUidPodcast,KContextSettings)); + } else { + array->AppendL(TCoeHelpContext(KUidPodcast,KContextApplication)); + } + + CleanupStack::Pop(array); + return array; + } + +void CPodcastAppUi::NaviShowTabGroupL() + { + iNaviDecorator = iNaviPane->CreateTabGroupL(); + + iTabGroup = STATIC_CAST(CAknTabGroup*, iNaviDecorator->DecoratedControl()); + iTabGroup->SetTabFixedWidthL(EAknTabWidthWithTwoTabs); + + HBufC *label1 = iEikonEnv->AllocReadResourceLC(R_TABGROUP_FEEDS); + iTabGroup->AddTabL(KTabIdFeeds,*label1); + + HBufC *label3 = iEikonEnv->AllocReadResourceLC(R_TABGROUP_QUEUE); + iTabGroup->AddTabL(KTabIdQueue,*label3); + +// HBufC *label4 = iEikonEnv->AllocReadResourceLC(R_TABGROUP_SEARCH); +// iTabGroup->AddTabL(KTabIdSearch,*label4); +// +// CleanupStack::PopAndDestroy(label4); + CleanupStack::PopAndDestroy(label3); + CleanupStack::PopAndDestroy(label1); + + iTabGroup->SetActiveTabByIndex(0); + iTabGroup->SetObserver(this); + + iNaviPane->Pop(); + iNaviPane->PushL(*iNaviDecorator); + } + +void CPodcastAppUi::TabChangedL (TInt aIndex) + { + DP("CPodcastListView::TabChangedL "); + + TUid newview = TUid::Uid(0); + TUid messageUid = TUid::Uid(0); + + if (aIndex == KTabIdFeeds) { + newview = KUidPodcastFeedViewID; + } else if (aIndex == KTabIdQueue) { + newview = KUidPodcastQueueViewID; + } else { + User::Leave(KErrTooBig); + } + + if(newview.iUid != 0) + { + ActivateLocalViewL(newview, messageUid, KNullDesC8()); + } + } + +void CPodcastAppUi::SetActiveTab(TInt aIndex) { + iTabGroup->SetActiveTabByIndex(aIndex); +} + +void CPodcastAppUi::HandleTimeout(const CTimeout& /*aId*/, TInt /*aError*/) + { + iFeedView->CheckResumeDownload(); + } + +void CPodcastAppUi::UpdateQueueTab(TInt aQueueLength) + { + if (aQueueLength == 0) + { + HBufC *queue = iEikonEnv->AllocReadResourceLC(R_TABGROUP_QUEUE); + iTabGroup->ReplaceTabL(KTabIdQueue, *queue); + CleanupStack::PopAndDestroy(queue); + } + else + { + HBufC *queueTemplate = iEikonEnv->AllocReadResourceLC(R_TABGROUP_QUEUE_COUNTER); + HBufC *queueCounter = HBufC::NewLC(queueTemplate->Length()+2); + queueCounter->Des().Format(*queueTemplate, aQueueLength); + + iTabGroup->ReplaceTabL(KTabIdQueue, *queueCounter); + CleanupStack::PopAndDestroy(queueCounter); + CleanupStack::PopAndDestroy(queueTemplate); + } + } + +void CPodcastAppUi::TabLeft() + { + TInt ati = iTabGroup->ActiveTabIndex(); + if(ati > 0) { + SetActiveTab(ati-1); + TabChangedL(ati-1); + } + } + +void CPodcastAppUi::TabRight() + { + TInt ati = iTabGroup->ActiveTabIndex(); + + if(ati < iTabGroup->TabCount()-1) { + SetActiveTab(ati+1); + TabChangedL(ati+1); + } + } diff -r 5f8e5adbbed9 -r 29cda98b007e application/src/PodcastDocument.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/src/PodcastDocument.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,52 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#include "PodcastDocument.h" +#include "PodcastAppui.h" +#include "PodcastModel.h" + +CPodcastDocument::CPodcastDocument( CEikApplication& aApp ) + : CAknDocument( aApp ) + { + } + +CPodcastDocument::~CPodcastDocument() + { + delete iPodcastModel; + } + +void CPodcastDocument::ConstructL() + { + DP("CPodcastDocument::ConstructL BEGIN"); + iPodcastModel = CPodcastModel::NewL(); + DP("CPodcastDocument::ConstructL END"); + } + +CPodcastDocument* CPodcastDocument::NewL(CEikApplication& aApp ) + { + CPodcastDocument* self = new (ELeave) CPodcastDocument( aApp ); + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop( self ); + return self; + } + +CEikAppUi* CPodcastDocument::CreateAppUiL() + { + return new (ELeave) CPodcastAppUi(iPodcastModel); + } diff -r 5f8e5adbbed9 -r 29cda98b007e application/src/PodcastFeedView.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/src/PodcastFeedView.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,918 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#include "PodcastFeedView.h" +#include "PodcastAppUi.h" +#include "ShowEngine.h" +#include "SettingsEngine.h" +#include "PodcastApp.h" +#include "PodcastUtils.h" +#include "PodcastFeedViewUpdater.h" +#include "Podcast.hrh" +#include +#include +#include +#include +#include +#include +#include +#include +#include + +const TInt KMaxFeedNameLength = 100; +const TInt KMaxUnplayedFeedsLength =64; +const TInt KADayInHours = 24; +const TInt KDefaultGran = 5; +const TInt KNumberOfFilesMaxLength = 4; +#define KMaxMessageLength 200 +#define KMaxTitleLength 100 +const TInt KMimeBufLength = 100; + +_LIT(KFeedFormat, "%d\t%S\t%S%S"); +enum +{ + EFeedIcon +}; + +CPodcastFeedView* CPodcastFeedView::NewL(CPodcastModel& aPodcastModel) + { + CPodcastFeedView* self = CPodcastFeedView::NewLC(aPodcastModel); + CleanupStack::Pop( self ); + return self; + } + +CPodcastFeedView* CPodcastFeedView::NewLC(CPodcastModel& aPodcastModel) + { + CPodcastFeedView* self = new ( ELeave ) CPodcastFeedView(aPodcastModel); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + +CPodcastFeedView::CPodcastFeedView(CPodcastModel& aPodcastModel):iPodcastModel(aPodcastModel) + { + iFirstActivateAfterLaunch = ETrue; + } +#define KAsterisk iEikonEnv->EikAppUi()->Application()->BitmapStoreName() +void CPodcastFeedView::ConstructL() + { + DP("CPodcastFeedView::ConstructL BEGIN"); + //_LIT(KAsterisk, "*"); + BaseConstructL(R_PODCAST_FEEDVIEW); + iNeverUpdated = iEikonEnv->AllocReadResourceL(R_PODCAST_FEEDS_NEVER_UPDATED); + iFeedsFormat = iEikonEnv->AllocReadResourceL(R_PODCAST_FEEDS_STATUS_FORMAT); + CPodcastListView::ConstructL(); + iPodcastModel.FeedEngine().AddObserver(this); + CArrayPtr< CGulIcon >* icons = new(ELeave) CArrayPtrFlat< CGulIcon >(1); + CleanupStack::PushL( icons ); + + CFbsBitmap* bitmap = NULL; + CFbsBitmap* mask = NULL; + // Load the bitmap for empty icon + TFileName fname = KAsterisk; + TParsePtr parser(fname); + + SetEmptyTextL(R_PODCAST_NO_FEEDS); + + // Load svg.-image and mask with a single call + AknIconUtils::CreateIconL(bitmap, + mask, + iEikonEnv->EikAppUi()->Application()->BitmapStoreName(), + EMbmPodcastFeed, + EMbmPodcastFeed_mask); + + /*bitmap = iEikonEnv->CreateBitmapL(KAsterisk,EMbmPodcastFeed_40x40); + * */ + CleanupStack::PushL( bitmap ); + // Load the mask for feed icon + //mask = iEikonEnv->CreateBitmapL(KAsterisk,EMbmPodcastFeed_40x40m ); + CleanupStack::PushL( mask ); + // Append the feed icon to icon array + icons->AppendL( CGulIcon::NewL( bitmap, mask ) ); + CleanupStack::Pop(2); // bitmap, mask + + iListContainer->Listbox()->ItemDrawer()->FormattedCellData()->SetIconArrayL( icons ); + CleanupStack::Pop(icons); // icons + + iListContainer->Listbox()->SetListBoxObserver(this); + + iStylusPopupMenu = CAknStylusPopUpMenu::NewL( this , TPoint(0,0)); + TResourceReader reader; + iCoeEnv->CreateResourceReaderLC(reader,R_FEEDVIEW_POPUP_MENU); + iStylusPopupMenu->ConstructFromResourceL(reader); + CleanupStack::PopAndDestroy(); + + iUpdater = CPodcastFeedViewUpdater::NewL(*this); + DP("CPodcastFeedView::ConstructL END"); + } + +CPodcastFeedView::~CPodcastFeedView() + { + iPodcastModel.FeedEngine().RemoveObserver(this); + delete iFeedsFormat; + delete iNeverUpdated; + delete iStylusPopupMenu; + delete iUpdater; + } + +void CPodcastFeedView::UpdateItemL(TInt aIndex) + { + _LIT(KPanicCategory, "CPodcastFeedView::UpdateItemL"); + __ASSERT_DEBUG(iListContainer->IsVisible(), User::Panic(KPanicCategory, 0)); + __ASSERT_ALWAYS(iItemIdArray.Count() > aIndex, User::Panic(KPanicCategory, 1)); + + const RFeedInfoArray& sortedItems = iPodcastModel.FeedEngine().GetSortedFeeds(); + __ASSERT_ALWAYS(sortedItems.Count() > aIndex, User::Panic(KPanicCategory, 2)); + + // Update UID of for the feed at aIndex + iItemIdArray[aIndex] = sortedItems[aIndex]->Uid(); + + // Prepare data to update the listbox item with + FormatFeedInfoListBoxItemL(*sortedItems[aIndex], EFalse); + + // If nothing has changed, we are done here + if (iListboxFormatbuffer == iItemArray->MdcaPoint(aIndex)) + { + return; + } + + // Something has changed, update the listbox item + TListItemProperties itemProps; + itemProps.SetDimmed(EFalse); + iItemArray->Delete(aIndex); + iItemArray->InsertL(aIndex, iListboxFormatbuffer); + iListContainer->Listbox()->ItemDrawer()->SetPropertiesL(aIndex, itemProps); + // If item is visible, redraw it + if (iListContainer->Listbox()->TopItemIndex() <= aIndex + && iListContainer->Listbox()->BottomItemIndex() >= aIndex) + { + iListContainer->Listbox()->DrawItem(aIndex); + } + } + +TUid CPodcastFeedView::Id() const + { + return KUidPodcastFeedViewID; + } + +void CPodcastFeedView::DoActivateL(const TVwsViewId& aPrevViewId, + TUid aCustomMessageId, + const TDesC8& aCustomMessage) + { + UpdateToolbar(); + + CPodcastListView::DoActivateL(aPrevViewId, aCustomMessageId, aCustomMessage); + + if (iFirstActivateAfterLaunch) + { + iFirstActivateAfterLaunch = EFalse; + } + } + +void CPodcastFeedView::DoDeactivate() + { + iUpdater->StopUpdate(); + CPodcastListView::DoDeactivate(); + } + + +void CPodcastFeedView::HandleListBoxEventL(CEikListBox* /* aListBox */, TListBoxEvent aEventType) + { + DP("CPodcastFeedView::HandleListBoxEventL BEGIN"); + + switch(aEventType) + { + case EEventEnterKeyPressed: + case EEventItemDoubleClicked: + case EEventItemActioned: + { + const RFeedInfoArray* sortedItems = NULL; + TInt index = iListContainer->Listbox()->CurrentItemIndex(); + sortedItems = &iPodcastModel.FeedEngine().GetSortedFeeds(); + + if(index >= 0 && index < sortedItems->Count()) + { + iPodcastModel.ActiveShowList().Reset(); + iPodcastModel.SetActiveFeedInfo((*sortedItems)[index]); + + AppUi()->ActivateLocalViewL(KUidPodcastShowsViewID, TUid::Uid(0), KNullDesC8()); + } + } + break; + default: + break; + } + DP("CPodcastFeedView::HandleListBoxEventL END"); + } + +void CPodcastFeedView::FeedUpdateAllCompleteL(TFeedState /*aState*/) + { + iUpdatingAllRunning = EFalse; + UpdateToolbar(); + } + +void CPodcastFeedView::FeedDownloadStartedL(TFeedState /*aState*/, TUint aFeedUid) + { + // Update status text + UpdateFeedInfoStatusL(aFeedUid, ETrue); + + UpdateToolbar(); + } + +void CPodcastFeedView::FeedDownloadFinishedL(TFeedState aState,TUint aFeedUid, TInt aError) + { + switch(aError) + { + case KErrCouldNotConnect: + { + if(aState == MFeedEngineObserver::EFeedManualUpdate) + { + TBuf message; + iEikonEnv->ReadResourceL(message, R_PODCAST_CONNECTION_ERROR); + ShowErrorMessage(message); + } + } + break; + default: // Do nothing + break; + } + UpdateFeedInfoStatusL(aFeedUid, EFalse); + } + +void CPodcastFeedView::UpdateFeedInfoStatusL(TUint aFeedUid, TBool aIsUpdating) + { + const RFeedInfoArray& feeds = iPodcastModel.FeedEngine().GetSortedFeeds(); + + // Find the index for the feed i both the feed-array and the listbox + TInt feedsIdx = KErrNotFound; + TInt listboxIdx = KErrNotFound; + for (TInt i = 0; i < feeds.Count(); i++) + { + if (feeds[i]->Uid() == aFeedUid) + { + feedsIdx = i; + break; + } + } + for (TInt j = 0; j < iItemIdArray.Count(); j++) + { + if (iItemIdArray[j] == aFeedUid) + { + listboxIdx = j; + break; + } + } + + if (feedsIdx != KErrNotFound && listboxIdx != KErrNotFound) + { + // TODO In the long run we want to move the sorting resposibility from + // CFeedEngine to CPodcastFeedView. + // Hackish fix to make sure the listbox is sorted. + if (listboxIdx != feedsIdx) + { + iItemIdArray.Remove(listboxIdx); + iItemIdArray.InsertL(aFeedUid, feedsIdx); + iItemArray->Delete(listboxIdx); + iItemArray->InsertL(feedsIdx, KNullDesC); + iListContainer->Listbox()->HandleItemAdditionL(); + } + // Update the listbox info + UpdateFeedInfoDataL(feeds[feedsIdx], feedsIdx, aIsUpdating); + //TODO sort the listbox after update + } + // Update all visible listbox items that are affected by sorting and update. + TInt minIdx = Max(Min(feedsIdx, listboxIdx), iListContainer->Listbox()->TopItemIndex()); + TInt maxIdx = Min(Max(feedsIdx, listboxIdx), iListContainer->Listbox()->BottomItemIndex()); + for (TInt k = minIdx; k <= maxIdx; k++) + { + iListContainer->Listbox()->DrawItem(k); + } + } + +void CPodcastFeedView::FormatFeedInfoListBoxItemL(CFeedInfo& aFeedInfo, TBool aIsUpdating) + { + TBuf updatedDate; + TBuf unplayedShows; + TUint unplayedCount = 0; + TUint showCount = 0; + TInt iconIndex = EFeedIcon; + + if(aIsUpdating) + { + iEikonEnv->ReadResourceL(updatedDate, R_PODCAST_FEEDS_IS_UPDATING); + unplayedShows = KNullDesC(); + } + else + { + iPodcastModel.FeedEngine().GetStatsByFeed(aFeedInfo.Uid(), showCount, unplayedCount); + + if (unplayedCount) { + unplayedShows.Format(*iFeedsFormat, unplayedCount); + } else { + unplayedShows.Zero(); + } + + if (aFeedInfo.LastUpdated().Int64() == 0) + { + updatedDate.Copy(*iNeverUpdated); + unplayedShows.Zero(); + } + else + { + TTime now; + TTimeIntervalHours interval; + now.HomeTime(); + now.HoursFrom(aFeedInfo.LastUpdated(), interval); + if (interval.Int() < KADayInHours) + { + aFeedInfo.LastUpdated().FormatL(updatedDate, KTimeFormat()); + } + else + { + aFeedInfo.LastUpdated().FormatL(updatedDate, KDateFormatShort()); + } + } + } + CArrayPtr* icons = iListContainer->Listbox()->ItemDrawer()->FormattedCellData()->IconArray(); + + if (aFeedInfo.FeedIconIndex() != -1) { + iconIndex = aFeedInfo.FeedIconIndex(); + } else { + if(aFeedInfo.FeedIcon() != NULL && + aFeedInfo.FeedIcon()->SizeInPixels().iHeight > 0 && + aFeedInfo.FeedIcon()->SizeInPixels().iWidth > 0) + { + // Hopefully temporary haxx to prevent double delete. I would prefer if + // this could be solved with a little better design. + CFbsBitmap* bmpCopy = new (ELeave) CFbsBitmap; + CleanupStack::PushL(bmpCopy); + bmpCopy->Duplicate(aFeedInfo.FeedIcon()->Handle()); + icons->AppendL( CGulIcon::NewL(bmpCopy, NULL)); + CleanupStack::Pop(bmpCopy); + iconIndex = icons->Count()-1; + aFeedInfo.SetFeedIconIndex(iconIndex); + } + else { + if(BaflUtils::FileExists(iPodcastModel.FsSession(), aFeedInfo.ImageFileName())) + { + // If this fails, no reason to worry + TRAP_IGNORE(iPodcastModel.ImageHandler().LoadFileAndScaleL(aFeedInfo.FeedIcon(), aFeedInfo.ImageFileName(), TSize(64,56), *this)); + } + } + } + + if (unplayedShows.Length() > 0) { + unplayedShows.Insert(0,_L(", ")); + } + + iListboxFormatbuffer.Format(KFeedFormat(), iconIndex, &(aFeedInfo.Title()), &updatedDate, &unplayedShows); + } + +void CPodcastFeedView::ImageOperationCompleteL(TInt aError) + { + if (aError == KErrNone) { + UpdateListboxItemsL(); + } + } + +void CPodcastFeedView::UpdateFeedInfoDataL(CFeedInfo* aFeedInfo, TInt aIndex, TBool aIsUpdating ) + { + TListItemProperties itemProps; + itemProps.SetDimmed(aIsUpdating); + FormatFeedInfoListBoxItemL(*aFeedInfo, aIsUpdating); + + TPtrC compareTo((*iItemArray)[aIndex]); + + if (iListboxFormatbuffer.Compare(compareTo) != 0) { + iItemArray->Delete(aIndex); + if(aIndex>= iItemArray->MdcaCount()) + { + iItemArray->AppendL(iListboxFormatbuffer); + } + else + { + iItemArray->InsertL(aIndex, iListboxFormatbuffer); + } + } + iListContainer->Listbox()->ItemDrawer()->SetPropertiesL(aIndex, itemProps); + } + + +void CPodcastFeedView::UpdateListboxItemsL() + { + // No reason to do any work if it isn't going to show.. + if(!iListContainer->IsVisible()) + { + return; + } + + TInt nbrItems = iPodcastModel.FeedEngine().GetSortedFeeds().Count(); + if (nbrItems > 0) + { + // Ensure that there are as many elements in iItemIdArray as in FeedEngine + while (iItemIdArray.Count() < nbrItems) + { + iItemIdArray.AppendL(0); + } + while (iItemIdArray.Count() > nbrItems) + { + iItemIdArray.Remove(iItemIdArray.Count() - 1); + } + + // Ensure that there are as many elements in iItemArray as in FeedEngine + while (iItemArray->Count() < nbrItems) + { + iItemArray->AppendL(KNullDesC); + TListItemProperties itemProps; + iListContainer->Listbox()->ItemDrawer()->SetPropertiesL(iItemArray->Count() - 1, itemProps); + } + while (iItemArray->Count() > nbrItems) + { + iItemArray->Delete(iItemArray->Count() - 1); + } + iUpdater->StartUpdate(nbrItems); + } + else + { + // No feeds at all in the list , add dummy list item + TBuf itemName; + iEikonEnv->ReadResourceL(itemName, R_PODCAST_FEEDS_NO_FEEDS); + iItemArray->Reset(); + iItemIdArray.Reset(); + + TListItemProperties itemProps; + itemProps.SetDimmed(ETrue); + itemProps.SetHiddenSelection(ETrue); + iListContainer->Listbox()->ItemDrawer()->SetPropertiesL(0, itemProps); + } + iListContainer->Listbox()->HandleItemAdditionL(); + } + +/** + * Command handling function intended for overriding by sub classes. + * Default implementation is empty. + * @param aCommand ID of the command to respond to. + */ +void CPodcastFeedView::HandleCommandL(TInt aCommand) + { + //CloseToolbarExtension(); + switch(aCommand) + { + case EPodcastHide: + AppUi()->HandleCommandL(EEikCmdExit); + break; + case EPodcastAddFeed: + HandleAddFeedL(); + break; + case EPodcastImportFeeds: + HandleImportFeedsL(); + break; + case EPodcastExportFeeds: + HandleExportFeedsL(); + break; + case EPodcastEditFeed: + HandleEditFeedL(); + break; + case EPodcastDeleteFeedHardware: + case EPodcastDeleteFeed: + HandleRemoveFeedL(); + break; + case EPodcastUpdateAllFeeds: + { + iUpdatingAllRunning = ETrue; + iPodcastModel.FeedEngine().UpdateAllFeedsL(); + UpdateToolbar(); + }break; + case EPodcastUpdateFeed: + { + HandleUpdateFeedL(); + }break; + case EPodcastCancelUpdateAllFeeds: + { + if(iUpdatingAllRunning) + { + iUpdatingAllRunning = EFalse; + iPodcastModel.FeedEngine().CancelUpdateAllFeeds(); + } + }break; + case EAknSoftkeyExit: + { + RShowInfoArray dlQueue; + iPodcastModel.ShowEngine().GetShowsDownloadingL(dlQueue); + TUint queueCount = dlQueue.Count(); + dlQueue.ResetAndDestroy(); + dlQueue.Close(); + + if (queueCount > 0 && !iPodcastModel.SettingsEngine().DownloadSuspended()) + { + TBuf message; + iEikonEnv->ReadResourceL(message, R_EXIT_SHOWS_DOWNLOADING); + if(ShowQueryMessage(message)) + { + // pass it on to AppUi, which will exit for us + CPodcastListView::HandleCommandL(aCommand); + } + } + else + { + // nothing in queue, or downloading suspended + CPodcastListView::HandleCommandL(aCommand); + } + } + break; + default: + CPodcastListView::HandleCommandL(aCommand); + break; + } + UpdateToolbar(); + } + +void CPodcastFeedView::UpdateToolbar() +{ + CAknToolbar* toolbar = Toolbar(); + + if (toolbar) + { + toolbar->HideItem(EPodcastUpdateAllFeeds, iUpdatingAllRunning, ETrue); + toolbar->HideItem(EPodcastCancelUpdateAllFeeds, !iUpdatingAllRunning, ETrue ); + toolbar->SetItemDimmed(EPodcastAddFeed, iUpdatingAllRunning, ETrue ); + toolbar->SetItemDimmed(EPodcastSettings, iUpdatingAllRunning, ETrue ); + } +} + +void CPodcastFeedView::HandleAddFeedL() + { + TBuf url; + url.Copy(_L("http://")); + CAknTextQueryDialog * dlg =CAknTextQueryDialog::NewL(url); + dlg->PrepareLC(R_PODCAST_ADD_FEED_DLG); + HBufC* prompt = iEikonEnv->AllocReadResourceLC(R_PODCAST_ADDFEED_PROMPT); + dlg->SetPromptL(*prompt); + CleanupStack::PopAndDestroy(prompt); + + if(dlg->RunLD()) + { + + // if no :// we do a search + if (url.Find(_L("://")) == KErrNotFound) + { + HBufC *waitText = iEikonEnv->AllocReadResourceLC(R_SEARCHING); + ShowWaitDialogL(*waitText); + CleanupStack::PopAndDestroy(waitText); + + iOpmlState = EOpmlSearching; + iPodcastModel.FeedEngine().SearchForFeedL(url); + } + else + { + PodcastUtils::FixProtocolsL(url); + + CFeedInfo* newFeedInfo = CFeedInfo::NewL(); + CleanupStack::PushL(newFeedInfo); + newFeedInfo->SetUrlL(url); + newFeedInfo->SetTitleL(newFeedInfo->Url()); + + TBool added = iPodcastModel.FeedEngine().AddFeedL(*newFeedInfo); + + if (added) + { + UpdateListboxItemsL(); + + // ask if users wants to update it now + TBuf message; + iEikonEnv->ReadResourceL(message, R_ADD_FEED_SUCCESS); + if(ShowQueryMessage(message)) + { + CFeedInfo *info = iPodcastModel.FeedEngine().GetFeedInfoByUid(newFeedInfo->Uid()); + + iPodcastModel.ActiveShowList().Reset(); + iPodcastModel.SetActiveFeedInfo(info); + AppUi()->ActivateLocalViewL(KUidPodcastShowsViewID, TUid::Uid(0), KNullDesC8()); + iPodcastModel.FeedEngine().UpdateFeedL(newFeedInfo->Uid()); + } + } + else + { + TBuf message; + iEikonEnv->ReadResourceL(message, R_ADD_FEED_EXISTS); + ShowErrorMessage(message); + } + + CleanupStack::PopAndDestroy(newFeedInfo); + } + } + } + +void CPodcastFeedView::HandleEditFeedL() + { + TInt index = iListContainer->Listbox()->CurrentItemIndex(); + + if(index < iItemArray->MdcaCount() && index >= 0) + { + CFeedInfo *info = iPodcastModel.FeedEngine().GetSortedFeeds()[index]; + + TBuf title; + title.Copy(info->Title()); + TBuf url; + url.Copy(info->Url()); + CAknMultiLineDataQueryDialog *dlg = CAknMultiLineDataQueryDialog ::NewL(title, url); + + if (dlg->ExecuteLD(R_PODCAST_EDIT_FEED_DLG)) + { + + if(info->Url().Compare(url) != 0) + { + TBuf dlgMessage; + iEikonEnv->ReadResourceL(dlgMessage, R_ADD_FEED_REPLACE); + + // Ask the user if it is OK to remove all shows + if ( ShowQueryMessage(dlgMessage)) + { + PodcastUtils::FixProtocolsL(url); + + //----- HACK ---- // + CFeedInfo* temp = CFeedInfo::NewLC(); + temp->SetUrlL(url); + TBool added = iPodcastModel.FeedEngine().AddFeedL(*temp); + if (added) { + // The Feed URL did not exist + // Remove the temp entry so that the correct entry could be changed + iPodcastModel.FeedEngine().RemoveFeedL(temp->Uid()); + + // user has accepted that shows will be deleted + iPodcastModel.ShowEngine().DeleteAllShowsByFeedL(info->Uid()); + + // update URL + info->SetUrlL(url); + + if (info->Title().Compare(title) != 0) + { + info->SetTitleL(title); + info->SetCustomTitle(); + } + iPodcastModel.FeedEngine().UpdateFeed(info); + UpdateListboxItemsL(); + } else { + // the feed existed. Object deleted in AddFeed. + TBuf dlgMessage; + iEikonEnv->ReadResourceL(dlgMessage, R_ADD_FEED_EXISTS); + ShowErrorMessage(dlgMessage); + } + CleanupStack::PopAndDestroy(temp); + } + } else { // no url change, maybe title? + // Update the title + if (info->Title().Compare(title) != 0) + { + info->SetTitleL(title); + info->SetCustomTitle(); + iPodcastModel.FeedEngine().UpdateFeed(info); + UpdateListboxItemsL(); + } + } + } + } + } + +void CPodcastFeedView::HandleRemoveFeedL() + { + if(iListContainer->Listbox() != NULL) + { + TInt index = iListContainer->Listbox()->CurrentItemIndex(); + + if(index < iItemArray->MdcaCount() && index >= 0) + { + CFeedInfo *info = iPodcastModel.FeedEngine().GetFeedInfoByUid(iItemIdArray[index]); + TBuf templ; + TBuf message; + iEikonEnv->ReadResourceL(templ, R_PODCAST_REMOVE_FEED_PROMPT); + message.Format(templ, &info->Title()); + if(ShowQueryMessage(message)) + { + iPodcastModel.FeedEngine().RemoveFeedL(iItemIdArray[index]); + iItemArray->Delete(index); + iItemIdArray.Remove(index); + iListContainer->Listbox()->HandleItemRemovalL(); + iListContainer->Listbox()->DrawNow(); + } + } + UpdateListboxItemsL(); + } + } + +void CPodcastFeedView::HandleUpdateFeedL() + { + TInt index = iListContainer->Listbox()->CurrentItemIndex(); + + if(index < iItemArray->MdcaCount() && index >= 0) + { + CFeedInfo *info = iPodcastModel.FeedEngine().GetSortedFeeds()[index]; + iPodcastModel.FeedEngine().UpdateFeedL(info->Uid()); + } + } + +void CPodcastFeedView::HandleImportFeedsL() + { + CAknMemorySelectionDialog* memDlg = + CAknMemorySelectionDialog::NewL(ECFDDialogTypeNormal, ETrue); + CleanupStack::PushL(memDlg); + CAknMemorySelectionDialog::TMemory memory = + CAknMemorySelectionDialog::EPhoneMemory; + + if (memDlg->ExecuteL(memory)) + { + TFileName importName; + + if (memory==CAknMemorySelectionDialog::EMemoryCard) + { + importName = PathInfo:: MemoryCardRootPath(); + } + else + { + importName = PathInfo:: PhoneMemoryRootPath(); + } + + CAknFileSelectionDialog* dlg = CAknFileSelectionDialog::NewL(ECFDDialogTypeNormal, R_PODCAST_IMPORT_PODCAST); + CleanupStack::PushL(dlg); + + dlg->SetDefaultFolderL(importName); + + if(dlg->ExecuteL(importName)) + { + if(importName.Length()>0) + { + HBufC *waitText = iEikonEnv->AllocReadResourceLC(R_IMPORTING); + iOpmlState = EOpmlImporting; + ShowWaitDialogL(*waitText); + CleanupStack::PopAndDestroy(waitText); + + TRAPD(err, iPodcastModel.FeedEngine().ImportFeedsL(importName)); + + if (err != KErrNone) { + TBuf message; + iEikonEnv->ReadResourceL(message, R_IMPORT_FEED_FAILURE); + ShowErrorMessage(message); + } + } + + } + CleanupStack::PopAndDestroy(dlg); + } + CleanupStack::PopAndDestroy(memDlg); + } + +void CPodcastFeedView::HandleExportFeedsL() + { + CAknMemorySelectionDialog* memDlg = + CAknMemorySelectionDialog::NewL(ECFDDialogTypeSave, ETrue); + CleanupStack::PushL(memDlg); + CAknMemorySelectionDialog::TMemory memory = + CAknMemorySelectionDialog::EPhoneMemory; + + if (memDlg->ExecuteL(memory)) + { + TFileName pathName; + + if (memory==CAknMemorySelectionDialog::EMemoryCard) + { + pathName = PathInfo::MemoryCardRootPath(); + } + else + { + pathName = PathInfo::PhoneMemoryRootPath(); + } + + CAknFileSelectionDialog* dlg = CAknFileSelectionDialog::NewL(ECFDDialogTypeSave, R_PODCAST_EXPORT_FEEDS); + CleanupStack::PushL(dlg); + + if(dlg->ExecuteL(pathName)) + { + CAknFileNamePromptDialog *fileDlg = CAknFileNamePromptDialog::NewL(R_PODCAST_FILENAME_PROMPT_DIALOG); + CleanupStack::PushL(fileDlg); + fileDlg->SetPathL(pathName); + TFileName fileName; + if (fileDlg->ExecuteL(fileName) && fileName.Length() > 0) + { + pathName.Append(fileName); + TFileName temp; + TRAPD(err, iPodcastModel.FeedEngine().ExportFeedsL(temp)); + BaflUtils::CopyFile(iEikonEnv->FsSession(), temp, pathName); + BaflUtils::DeleteFile(iEikonEnv->FsSession(),temp); + if (err == KErrNone) + { + UpdateListboxItemsL(); + TInt numFeeds = iPodcastModel.FeedEngine().GetSortedFeeds().Count(); + + TBuf message; + TBuf templ; + iEikonEnv->ReadResourceL(templ, R_EXPORT_FEED_SUCCESS); + message.Format(templ, numFeeds); + ShowOkMessage(message); + } + else + { + TBuf message; + iEikonEnv->ReadResourceL(message, R_EXPORT_FEED_FAILURE); + ShowErrorMessage(message); + } + } + CleanupStack::PopAndDestroy(fileDlg); + } + CleanupStack::PopAndDestroy(dlg); + } + CleanupStack::PopAndDestroy(memDlg); + } + +void CPodcastFeedView::CheckResumeDownload() + { + // if there are shows queued for downloading, ask if we should resume now + RShowInfoArray showsDownloading; + iPodcastModel.ShowEngine().GetShowsDownloadingL(showsDownloading); + + if (showsDownloading.Count() > 0) + { + TBuf msg; + iEikonEnv->ReadResourceL(msg, R_PODCAST_ENABLE_DOWNLOADS_PROMPT); + + if (ShowQueryMessage(msg)) + { + // need to suspend downloads before ResumeDownloadL will work :) + iPodcastModel.SettingsEngine().SetDownloadSuspended(ETrue); + // resume downloading if user says yes + iPodcastModel.ShowEngine().ResumeDownloadsL(); + } + else + { + // we disable downloading if user says no + iPodcastModel.SettingsEngine().SetDownloadSuspended(ETrue); + } + } + + // if no shows in queue, we keep whichever state suspend is in + showsDownloading.ResetAndDestroy(); + } + +void CPodcastFeedView::OpmlParsingComplete(TUint aNumFeedsImported) + { + DP("CPodcastFeedView::OpmlParsingComplete BEGIN"); + + switch (iOpmlState) + { + case EOpmlIdle: + break; + case EOpmlImporting: + { + UpdateListboxItemsL(); + delete iWaitDialog; + iOpmlState = EOpmlIdle; + + TBuf message; + TBuf templ; + iEikonEnv->ReadResourceL(templ, R_IMPORT_FEED_SUCCESS); + message.Format(templ, aNumFeedsImported); + + if(ShowQueryMessage(message)) + { + HandleCommandL(EPodcastUpdateAllFeeds); + } + } + break; + case EOpmlSearching: + delete iWaitDialog; + if (iPodcastModel.FeedEngine().GetSearchResults().Count() == 0) + { + TBuf message; + iEikonEnv->ReadResourceL(message, R_SEARCH_NORESULTS); + ShowErrorMessage(message); + } + else + { + AppUi()->ActivateLocalViewL(KUidPodcastSearchViewID, TUid::Uid(0), KNullDesC8()); + } + iOpmlState = EOpmlIdle; + default: + break; + } + + DP("CPodcastFeedView::OpmlParsingComplete END"); + } + +void CPodcastFeedView::DialogDismissedL(TInt /*aButtonId*/) + { + iPodcastModel.FeedEngine().CancelUpdateAllFeeds(); + } diff -r 5f8e5adbbed9 -r 29cda98b007e application/src/PodcastFeedViewUpdater.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/src/PodcastFeedViewUpdater.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,85 @@ +/* +* Copyright (c) 2010 Anders Fridlund, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#include "PodcastFeedViewUpdater.h" +#include "PodcastFeedView.h" + +CPodcastFeedViewUpdater* CPodcastFeedViewUpdater::NewL(CPodcastFeedView& aPodcastFeedView) + { + CPodcastFeedViewUpdater* self = new (ELeave) CPodcastFeedViewUpdater(aPodcastFeedView); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +void CPodcastFeedViewUpdater::StartUpdate(TInt aNbrItems) + { + // If there is an update in progress, stop it. + StopUpdate(); + // Reset values to start an update from the beginning + iNbrItems = aNbrItems; + iNextItem = 0; + // Queue this active object to be run once + Call(); + } + +void CPodcastFeedViewUpdater::StopUpdate() + { + // Cancel any outstanding request + Cancel(); + // Reset values to zero. Not really necessary, but made for robustness + iNbrItems = 0; + iNextItem = 0; + } + +CPodcastFeedViewUpdater::~CPodcastFeedViewUpdater() + { + StopUpdate(); + Deque(); + } + +CPodcastFeedViewUpdater::CPodcastFeedViewUpdater(CPodcastFeedView& aPodcastFeedView) + : CAsyncOneShot(EPriorityNormal), iPodcastFeedView(aPodcastFeedView) + { + } + +void CPodcastFeedViewUpdater::ConstructL() + { + } + +void CPodcastFeedViewUpdater::RunL() + { + _LIT(KPanicCategory, "CPodcastFeedViewUpdater::RunL"); + __ASSERT_DEBUG(iNextItem < iNbrItems, User::Panic(KPanicCategory, 0)); + iPodcastFeedView.UpdateItemL(iNextItem++); + if (iNextItem < iNbrItems) + { + Call(); + } + else + { + StopUpdate(); + } + } + +TInt CPodcastFeedViewUpdater::RunError(TInt aError) + { + return aError; + } + diff -r 5f8e5adbbed9 -r 29cda98b007e application/src/PodcastListView.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/src/PodcastListView.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,410 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#include "PodcastListView.h" +#include "Podcast.hrh" +#include "PodcastAppUi.h" +#include "constants.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include + +const TInt KDefaultGran = 5; + +CPodcastListContainer::CPodcastListContainer() +{ +} + +void CPodcastListContainer::SetKeyEventListener(MKeyEventListener *aKeyEventListener) + { + iKeyEventListener = aKeyEventListener; + } + +TKeyResponse CPodcastListContainer::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType) +{ + TKeyResponse response = iListbox->OfferKeyEventL(aKeyEvent, aType); + if (iKeyEventListener) + iKeyEventListener->OfferKeyEventL(aKeyEvent, aType); + + return response; +} + +void CPodcastListContainer::ConstructL( const TRect& aRect, TInt aListboxFlags ) +{ + CreateWindowL(); + + iBgContext = + CAknsBasicBackgroundControlContext::NewL( KAknsIIDQsnBgAreaMain, + aRect, + ETrue ); + + // Set the windows size + SetRect( aRect ); + iListbox =static_cast( new (ELeave) CAknDoubleLargeStyleListBox); + iListbox->ConstructL(this, aListboxFlags); + iListbox->SetMopParent( this ); + iListbox->SetContainerWindowL(*this); + iListbox->CreateScrollBarFrameL(ETrue); + iListbox->ScrollBarFrame()->SetScrollBarVisibilityL(CEikScrollBarFrame::EAuto, CEikScrollBarFrame::EAuto ); + + iListbox->ItemDrawer()->FormattedCellData()->EnableMarqueeL( ETrue ); + + iListbox->SetSize(aRect.Size()); + iListbox->MakeVisible(ETrue); + MakeVisible(EFalse); + + // Activate the window, which makes it ready to be drawn + ActivateL(); +} + +TInt CPodcastListContainer::CountComponentControls() const + { + return 1; // return number of controls inside this container + } + +CCoeControl* CPodcastListContainer::ComponentControl(TInt aIndex) const + { + switch ( aIndex ) + { + case 0: + return iListbox; + default: + return NULL; + } + } + +void CPodcastListContainer::HandleResourceChange(TInt aType) +{ + switch( aType ) + { + case KEikDynamicLayoutVariantSwitch: + SetRect(iEikonEnv->EikAppUi()->ClientRect()); + break; + } +} + +void CPodcastListContainer::ScrollToVisible() { + if (iListbox != NULL) { + iListbox->ScrollToMakeItemVisible(iListbox->CurrentItemIndex()); + } +} +void CPodcastListContainer::SizeChanged() +{ + DP2("CPodcastListContainer::SizeChanged(), width=%d, height=%d",Size().iWidth, Size().iHeight); + if(iListbox != NULL) + { + iListbox->SetSize(Size()); + } +} + +CEikFormattedCellListBox* CPodcastListContainer::Listbox() +{ + return iListbox; +} + + +CPodcastListContainer::~CPodcastListContainer() +{ + delete iListbox; + delete iBgContext; +} + + +void CPodcastListContainer::Draw(const TRect& aRect) const + { + CWindowGc& gc = SystemGc(); + gc.SetBrushStyle(CGraphicsContext::ESolidBrush); + MAknsControlContext* cc = AknsDrawUtils::ControlContext(this); + MAknsSkinInstance* skin = AknsUtils::SkinInstance(); + AknsDrawUtils::Background(skin, cc, (CCoeControl*) this, gc, aRect); + } + + +TTypeUid::Ptr CPodcastListContainer::MopSupplyObject( TTypeUid aId ) + { + if (iBgContext ) + { + return MAknsControlContext::SupplyMopObject( aId, iBgContext ); + } + return CCoeControl::MopSupplyObject(aId); + } + +void CPodcastListContainer::HandlePointerEventL(const TPointerEvent& aPointerEvent) + { + if (iPointerListener) + iPointerListener->PointerEventL(aPointerEvent); + + // Call base class HandlePointerEventL() + CCoeControl::HandlePointerEventL(aPointerEvent); + } + + +void CPodcastListContainer::SetPointerListener(MPointerListener *aPointerListener) + { + iPointerListener = aPointerListener; + } + + +CPodcastListView::CPodcastListView() +{ +} + +void CPodcastListView::ConstructL() +{ + DP("CPodcastListView::ConstructL BEGIN"); + iListContainer = new (ELeave) CPodcastListContainer; + iListContainer->ConstructL(ClientRect(), iListboxFlags); + iListContainer->SetMopParent(this); + iListContainer->ActivateL(); + iItemArray = new (ELeave)CDesCArrayFlat(KDefaultGran); + iListContainer->Listbox()->Model()->SetItemTextArray(iItemArray); + iListContainer->Listbox()->Model()->SetOwnershipType(ELbmDoesNotOwnItemArray); + + if (Toolbar()) { + iToolbar = Toolbar(); + iToolbar->SetToolbarObserver(this); + } + + iLongTapDetector = CAknLongTapDetector::NewL(this); + iListContainer->SetPointerListener(this); + iListContainer->SetKeyEventListener(this); + DP("CPodcastListView::ConstructL END"); +} + +void CPodcastListView::HandleViewRectChange() +{ + if ( iListContainer ) + { + iListContainer->SetRect( ClientRect() ); + } +} + +void CPodcastListView::HandleStatusPaneSizeChange() +{ + DP2("CPodcastListView::HandleStatusPaneSizeChange(), width=%d, height=%d", ClientRect().Width(), ClientRect().Height()); + + if ( iListContainer ) + { + iListContainer->SetRect( ClientRect() ); + } + +} + + +CPodcastListView::~CPodcastListView() + { + if(iListContainer) + { + AppUi()->RemoveFromStack(iListContainer); + delete iListContainer; + } + + delete iItemArray; + delete iLongTapDetector; + iItemIdArray.Close(); + } + + +void CPodcastListView::DoActivateL(const TVwsViewId& /*aPrevViewId */, + TUid /*aCustomMessageId */, + const TDesC8& /* aCustomMessage */) +{ + DP("CPodcastListView::DoActivateL() BEGIN"); + + if(iListContainer) + { + iListContainer->SetSize(ClientRect().Size()); + iListContainer->SetMopParent(this); + + AppUi()->AddToStackL(*this, iListContainer); + iListContainer->MakeVisible(ETrue); + UpdateListboxItemsL(); + iListContainer->DrawNow(); + } + DP("CPodcastListView::DoActivateL() END"); + +} + +void CPodcastListView::DoDeactivate() +{ + DP("CPodcastListView::DoDeactivate() BEGIN"); + if ( iListContainer ) + { + AppUi()->RemoveFromViewStack( *this, iListContainer); + iListContainer->MakeVisible(EFalse); + } + DP("CPodcastListView::DoDeactivate() END"); +} + +/** +* Command handling function intended for overriding by sub classes. +* Default implementation is empty. +* @param aCommand ID of the command to respond to. +*/ +void CPodcastListView::HandleCommandL(TInt aCommand) +{ + DP1("CPodcastListView::HandleCommandL=%d", aCommand); + switch(aCommand) + { + case EAknSoftkeyExit: + case EEikCmdExit: + { + AppUi()->Exit(); + break; + } + case EAknSoftkeyBack: + { + AppUi()->ActivateViewL(iPreviousView); + if (iPreviousView.iViewUid == KUidPodcastFeedViewID) { + ((CPodcastAppUi*)AppUi())->SetActiveTab(KTabIdFeeds); + } + }break; + case EPodcastSettings: + AppUi()->ActivateLocalViewL(KUidPodcastSettingsViewID); + break; + case EPodcastAbout: + RunAboutDialogL(); + break; + default: + AppUi()->HandleCommandL(aCommand); + } +} + + +void CPodcastListView::RunAboutDialogL() +{ + CAknNoteDialog* dlg = new(ELeave) CAknNoteDialog(); + dlg->ExecuteLD(R_DLG_ABOUT); +} + +void CPodcastListView::SetEmptyTextL(TInt aResourceId) + { + HBufC* emptyText = iEikonEnv->AllocReadResourceLC(aResourceId); + iListContainer->Listbox()->View()->SetListEmptyTextL(*emptyText); + CleanupStack::PopAndDestroy(emptyText); + } + +void CPodcastListView::ShowOkMessage(TDesC &aText) + { + CAknNoteDialog* dlg= new(ELeave) CAknNoteDialog(); + CleanupStack::PushL(dlg); + dlg->SetTextL(aText); + CleanupStack::Pop(dlg); + dlg->ExecuteLD(R_MESSAGEDLG_OK); + } + +void CPodcastListView::ShowErrorMessage(TDesC &aText) + { + CAknNoteDialog* dlg= new(ELeave) CAknNoteDialog(); + CleanupStack::PushL(dlg); + dlg->SetTextL(aText); + CleanupStack::Pop(dlg); + dlg->ExecuteLD(R_ERRORDLG_OK); + } + +TInt CPodcastListView::ShowQueryMessage(TDesC &aText) + { + CAknQueryDialog* dlg= new(ELeave) CAknQueryDialog(); + + CleanupStack::PushL(dlg); + dlg->SetPromptL(aText); + CleanupStack::Pop(dlg); + return dlg->ExecuteLD(R_QUERYDLG); + } + +void CPodcastListView::CloseToolbarExtension() +{ + CAknToolbar* toolbar = Toolbar(); + if (toolbar) { + CAknToolbarExtension* toolbarExtension = toolbar->ToolbarExtension(); + if (toolbarExtension) { + toolbarExtension->SetShown( EFalse ); + } + } +} + +void CPodcastListView::PointerEventL(const TPointerEvent& aPointerEvent) + { + //DP1("CPodcastListView::PointerEventL, iType=%d", aPointerEvent.iType); + // Pass the pointer event to Long tap detector component + iLongTapDetector->PointerEventL(aPointerEvent); + } + + +void CPodcastListView::HandleLongTapEventL( const TPoint& aPenEventLocation, const TPoint& /* aPenEventScreenLocation */) +{ + DP("CPodcastListView::HandleLongTapEventL BEGIN"); + if(iStylusPopupMenu) + { + iStylusPopupMenu->ShowMenu(); + iStylusPopupMenu->SetPosition(aPenEventLocation); + } + DP("CPodcastListView::HandleLongTapEventL END"); +} + + +void CPodcastListView::DynInitToolbarL (TInt /*aResourceId*/, CAknToolbar * /*aToolbar*/) + { + DP("CPodcastListView::DynInitToolbarL"); + UpdateToolbar(); + } + + +void CPodcastListView::OfferToolbarEventL(TInt aCommand) + { + HandleCommandL(aCommand); + } + +void CPodcastListView::ShowWaitDialogL(TDesC &aWaitText) + { + DP("CPodcastListView::ShowWaitDialogL BEGIN"); + + if (iWaitDialog) { + User::Leave(KErrInUse); + } + + iWaitDialog=new(ELeave) CAknWaitDialog(reinterpret_cast(&iWaitDialog), EFalse); + iWaitDialog->SetCallback(this); + iWaitDialog->ExecuteLD(R_WAITDLG); + iWaitDialog->SetTextL(aWaitText); + DP("CPodcastListView::ShowWaitDialogL END"); + } + +TKeyResponse CPodcastListView::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType) + { + if (aType==EEventKey) + { + switch (aKeyEvent.iCode) + { + case EKeyRightArrow: + ((CPodcastAppUi*)AppUi())->TabRight(); + return EKeyWasConsumed; + case EKeyLeftArrow: + ((CPodcastAppUi*)AppUi())->TabLeft(); + return EKeyWasConsumed; + } + } + return EKeyWasNotConsumed; + } + diff -r 5f8e5adbbed9 -r 29cda98b007e application/src/PodcastQueueView.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/src/PodcastQueueView.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,598 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#include "PodcastQueueView.h" +#include "PodcastAppUi.h" +#include "ShowEngine.h" +#include "SettingsEngine.h" +#include "PodcastApp.h" +#include "Constants.h" +#include "imagehandler.h" +#include "PodcastShowsView.h" + +#include +#include +#include +#include +#include +#include +#include +#include "Podcast.hrh" + +#define KMaxMessageLength 200 + +#define KPodcastImageWidth 160 +#define KPodcastImageHeight 120 +#define KPodcastDialogOffset 2 + +#define KOneHundredPercent 100 + +const TInt KSizeBufLen = 64; +const TInt KDefaultGran = 5; +_LIT(KSizeDownloadingOf, "%.1f/%.1f MB"); +_LIT(KShowsSizeFormatS60, "%.1f MB"); + +_LIT(KShowFormat, "%d\t%S\t%S %S\t"); +_LIT(KShowErrorFormat, "%d\t%S\t%S\t"); +_LIT(KShowQueueFormat, "%d\t%S\t%S%S\t"); + + +// these must correspond with TShowsIconIndex + +const TUint KShowIconArrayIds[] = + { + EMbmPodcastAudio, + EMbmPodcastAudio_mask, + EMbmPodcastAudio_new, + EMbmPodcastAudio_new_mask, + EMbmPodcastAudio_queued, + EMbmPodcastAudio_queued_mask, + EMbmPodcastAudio_downloading, + EMbmPodcastAudio_downloading_mask, + EMbmPodcastAudio_downloaded, + EMbmPodcastAudio_downloaded_mask, + EMbmPodcastAudio_downloaded_new, + EMbmPodcastAudio_downloaded_new_mask, + EMbmPodcastAudio_failed, + EMbmPodcastAudio_failed_mask, + EMbmPodcastAudio_suspended, + EMbmPodcastAudio_suspended_mask, + 0, + 0 + }; + +CPodcastQueueView* CPodcastQueueView::NewL(CPodcastModel& aPodcastModel) + { + CPodcastQueueView* self = CPodcastQueueView::NewLC(aPodcastModel); + CleanupStack::Pop(self); + return self; + } + +CPodcastQueueView* CPodcastQueueView::NewLC(CPodcastModel& aPodcastModel) + { + CPodcastQueueView* self = new ( ELeave ) CPodcastQueueView(aPodcastModel); + CleanupStack::PushL(self); + self->ConstructL(); + return self; + } + +CPodcastQueueView::CPodcastQueueView(CPodcastModel& aPodcastModel) : + iPodcastModel(aPodcastModel) + { + } + +void CPodcastQueueView::ConstructL() + { + BaseConstructL(R_PODCAST_QUEUEVIEW); + CPodcastListView::ConstructL(); + CArrayPtr< CGulIcon>* icons = new(ELeave) CArrayPtrFlat< CGulIcon>(1); + CleanupStack::PushL(icons); + TInt pos = 0; + while (KShowIconArrayIds[pos] > 0) + { + // Load the bitmap for play icon + CFbsBitmap* bitmap= NULL;//iEikonEnv->CreateBitmapL( _L("*"), KIconArrayIds[pos]); + CFbsBitmap* mask= NULL;////iEikonEnv->CreateBitmapL( _L("*"), KIconArrayIds[pos+1] ); + AknIconUtils::CreateIconL(bitmap, + mask, + iEikonEnv->EikAppUi()->Application()->BitmapStoreName(), + KShowIconArrayIds[pos], + KShowIconArrayIds[pos+1]); + CleanupStack::PushL(bitmap); + // Load the mask for play icon + CleanupStack::PushL(mask); + // Append the play icon to icon array + icons->AppendL(CGulIcon::NewL(bitmap, mask) ); + CleanupStack::Pop(2); // bitmap, mask + pos+=2; + } + iListContainer->Listbox()->ItemDrawer()->FormattedCellData()->SetIconArrayL(icons); + CleanupStack::Pop(icons); // icons + iListContainer->Listbox()->SetListBoxObserver(this); + + iPodcastModel.FeedEngine().AddObserver(this); + iPodcastModel.ShowEngine().AddObserver(this); + + iStylusPopupMenu = CAknStylusPopUpMenu::NewL( this , TPoint(0,0)); + TResourceReader reader; + iCoeEnv->CreateResourceReaderLC(reader,R_QUEUEVIEW_POPUP_MENU); + iStylusPopupMenu->ConstructFromResourceL(reader); + CleanupStack::PopAndDestroy(); + SetEmptyTextL(R_PODCAST_EMPTY_QUEUE); + } + +TKeyResponse CPodcastQueueView::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType) + { + if (aType == EEventKey) + { + CShowInfo *activeShow = NULL; + + TInt index = iListContainer->Listbox()->CurrentItemIndex(); + if(index >= 0 && index < iPodcastModel.ActiveShowList().Count()) + { + activeShow = iPodcastModel.ActiveShowList()[index]; + } + + if (activeShow != NULL) { + DP1("aKeyEvent.iCode=%d", aKeyEvent.iCode); + switch (aKeyEvent.iCode) { + case 117: + case '*': + case EKeySpace: + if (activeShow->PlayState() == EPlayed) { + HandleCommandL(EPodcastMarkAsUnplayed); + } else { + HandleCommandL(EPodcastMarkAsPlayed); + } + break; + case 106: + case '#': + if (activeShow->DownloadState() == ENotDownloaded) { + HandleCommandL(EPodcastDownloadShow); + } + break; + case EKeyBackspace: + case EKeyDelete: + HandleCommandL(EPodcastRemoveDownload); + break; + default: + break; + } + UpdateToolbar(); + } + } + return CPodcastListView::OfferKeyEventL(aKeyEvent, aType); + } + +CPodcastQueueView::~CPodcastQueueView() + { + iPodcastModel.ShowEngine().RemoveObserver(this); + iPodcastModel.FeedEngine().RemoveObserver(this); + + if(iStylusPopupMenu) + delete iStylusPopupMenu, iStylusPopupMenu = NULL; + } + + +TUid CPodcastQueueView::Id() const + { + return KUidPodcastQueueViewID; + } + +void CPodcastQueueView::DoActivateL(const TVwsViewId& aPrevViewId, + TUid aCustomMessageId, const TDesC8& aCustomMessage) + { + DP("CPodcastQueueView::DoActivateL BEGIN"); + + CPodcastListView::DoActivateL(aPrevViewId, aCustomMessageId, aCustomMessage); + iPreviousView = TVwsViewId(KUidPodcast, KUidPodcastFeedViewID); + + UpdateFeedUpdateStateL(); + UpdateToolbar(); + DP("CPodcastQueueView::DoActivateL END"); + } + +void CPodcastQueueView::DoDeactivate() + { + CPodcastListView::DoDeactivate(); + } + +// Engine callback when new shows are available +void CPodcastQueueView::ShowListUpdatedL() + { + UpdateListboxItemsL(); + } + +void CPodcastQueueView::ShowDownloadUpdatedL(TInt aBytesOfCurrentDownload, TInt /*aBytesTotal*/) + { + if (!iListContainer->IsVisible()) + { + return; + } + + CShowInfo *info = iPodcastModel.ShowEngine().ShowDownloading(); + if (info) + { + UpdateShowItemL(info->Uid(), aBytesOfCurrentDownload); + } + } + +void CPodcastQueueView::ShowDownloadFinishedL(TUint /*aShowUid*/, TInt aError) + { + iProgressAdded = EFalse; + + iPodcastModel.GetShowsDownloading(); + UpdateListboxItemsL(); + UpdateToolbar(); + + switch(aError) + { + case KErrCouldNotConnect: + { + TBuf message; + iEikonEnv->ReadResourceL(message, R_PODCAST_CONNECTION_ERROR); + ShowErrorMessage(message); + } + break; + default: // Do nothing + break; + } + } + + +void CPodcastQueueView::FeedDownloadStartedL(TFeedState /*aState*/, TUint aFeedUid) + { + // TODO make use of the fact that we know that the feed download is + // started instead of checking feed engine states in UpdateFeedUpdateStateL. + if (iPodcastModel.ActiveFeedInfo() != NULL + && iPodcastModel.ActiveFeedInfo()->Uid() == aFeedUid) + { + TRAP_IGNORE(UpdateFeedUpdateStateL()); + UpdateToolbar(); + } + } + +void CPodcastQueueView::FeedDownloadFinishedL(TFeedState /*aState*/, TUint aFeedUid, TInt /*aError*/) + { + DP("CPodcastQueueView::FeedDownloadFinishedL BEGIN"); + // TODO make use of the fact that we know that the feed download is + // finished instead of checking feed engine states in UpdateFeedUpdateStateL. + if (iPodcastModel.ActiveFeedInfo() != NULL + && iPodcastModel.ActiveFeedInfo()->Uid() == aFeedUid) + { + TRAP_IGNORE(UpdateFeedUpdateStateL()); + } + DP("CPodcastQueueView::FeedDownloadFinishedL END"); + } + +void CPodcastQueueView::HandleListBoxEventL(CEikListBox* /*aListBox*/, + TListBoxEvent aEventType) + { + switch (aEventType) + { + case EEventEnterKeyPressed: + case EEventItemActioned: + case EEventItemDoubleClicked: + break; + default: + break; + } + UpdateToolbar(); + } + +void CPodcastQueueView::GetShowIcons(CShowInfo* aShowInfo, TInt& aIconIndex) + { + TBool dlStop = iPodcastModel.SettingsEngine().DownloadSuspended(); + TUint showDownloadingUid = iPodcastModel.ShowEngine().ShowDownloading() ? iPodcastModel.ShowEngine().ShowDownloading()->Uid() : 0; + + if (showDownloadingUid == aShowInfo->Uid()) + { + aIconIndex = dlStop ? ESuspendedShowIcon : EDownloadingShowIcon; + } + else + { + switch (aShowInfo->DownloadState()) + { + case EQueued: + aIconIndex = dlStop ? ESuspendedShowIcon : EQuedShowIcon; + break; + case EDownloading: + aIconIndex = dlStop ? ESuspendedShowIcon : EDownloadingShowIcon; + break; + case EFailedDownload: + aIconIndex = EFailedShowIcon; + break; + default: + DP("Wrong download state for queue view!"); + break; + } + } + } + +void CPodcastQueueView::UpdateFeedUpdateStateL() + { + TBool listboxDimmed = EFalse; + + if (iPodcastModel.FeedEngine().ClientState() != EIdle && iPodcastModel.ActiveFeedInfo() + != NULL && iPodcastModel.FeedEngine().ActiveClientUid() == iPodcastModel.ActiveFeedInfo()->Uid()) + { + listboxDimmed = ETrue; + } + + if ((iListContainer->Listbox()->IsDimmed() && !listboxDimmed) || (!iListContainer->Listbox()->IsDimmed() && listboxDimmed)) + { + iListContainer->Listbox()->SetDimmed(listboxDimmed); + } + UpdateListboxItemsL(); + UpdateToolbar(); + } + +void CPodcastQueueView::FormatShowInfoListBoxItemL(CShowInfo& aShowInfo, TInt aSizeDownloaded) + { + TBuf<32> infoSize; + TInt iconIndex = 0; + TBuf showDate; + GetShowIcons(&aShowInfo, iconIndex); + + if(aSizeDownloaded > 0) + { + if (aShowInfo.ShowSize() > 0) + { + infoSize.Format(KSizeDownloadingOf(), ((float) aSizeDownloaded / (float) KSizeMb), + ((float)aShowInfo.ShowSize() / (float)KSizeMb)); + } + else + { + infoSize.Format(KShowsSizeFormatS60(), (float)aSizeDownloaded / (float)KSizeMb); + } + } + else if (aShowInfo.ShowSize() > 0) + { + infoSize.Format(KShowsSizeFormatS60(), (float)aShowInfo.ShowSize() / (float)KSizeMb); + } + else { + infoSize = KNullDesC(); + } + + if (aShowInfo.PubDate().Int64() == 0) + { + showDate = KNullDesC(); + } + else + { + aShowInfo.PubDate().FormatL(showDate, KDateFormatShort()); + } + + if(aShowInfo.LastError() != KErrNone) + { + TBuf errorBuffer; + iEikonEnv->GetErrorText(errorBuffer, aShowInfo.LastError()); + iListboxFormatbuffer.Format(KShowErrorFormat(), iconIndex, &aShowInfo.Title(), &errorBuffer); + } + else + { + if (infoSize.Length() > 0) { + infoSize.Insert(0,_L(", ")); + } + + iListboxFormatbuffer.Format(KShowQueueFormat(), iconIndex, &aShowInfo.Title(), &showDate, &infoSize); + } + } + +void CPodcastQueueView::UpdateShowItemDataL(CShowInfo* aShowInfo,TInt aIndex, TInt aSizeDownloaded) +{ + FormatShowInfoListBoxItemL(*aShowInfo, aSizeDownloaded); + iItemArray->Delete(aIndex); + if(aIndex>= iItemArray->MdcaCount()) + { + iItemArray->AppendL(iListboxFormatbuffer); + } + else + { + iItemArray->InsertL(aIndex, iListboxFormatbuffer); + } +} + +void CPodcastQueueView::UpdateShowItemL(TUint aUid, TInt aSizeDownloaded) +{ + RShowInfoArray& array = iPodcastModel.ActiveShowList(); + + for (int i=0;iUid() == aUid) { + UpdateShowItemDataL(array[i], i, aSizeDownloaded); + if (iListContainer->Listbox()->TopItemIndex() <= i && + iListContainer->Listbox()->BottomItemIndex() >= i) { + iListContainer->Listbox()->DrawItem(i); + } + } + } +} + +void CPodcastQueueView::UpdateListboxItemsL() + { + if (iListContainer->IsVisible()) + { + TListItemProperties itemProps; + TInt len = 0; + + iPodcastModel.GetShowsDownloading(); + + RShowInfoArray &fItems = iPodcastModel.ActiveShowList(); + len = fItems.Count(); + + if (iListContainer->Listbox() != NULL) + { + TBool allUidsMatch = EFalse; + + if (len == iListContainer->Listbox()->Model()->NumberOfItems()) + { + allUidsMatch = ETrue; + TUint itemId = 0; + for (TInt loop = 0; loop< len; loop++) + { + itemId = iItemIdArray[loop]; + if (fItems[loop]->Uid() != itemId) + { + allUidsMatch = EFalse; + break; + } + } + } + + if (allUidsMatch && len > 0) + { + for (TInt loop = 0; loop< len; loop++) + { + UpdateShowItemDataL(fItems[loop], loop); + iListContainer->Listbox()->DrawItem(loop); + } + } + else + { + iListContainer->Listbox()->ItemDrawer()->ClearAllPropertiesL(); + iListContainer->Listbox()->Reset(); + iItemIdArray.Reset(); + iItemArray->Reset(); + + if (len > 0) + { + for (TInt i=0; iUid()); + iItemArray->AppendL(iListboxFormatbuffer); + } + } + else + { + iItemArray->Reset(); + iItemIdArray.Reset(); + + itemProps.SetDimmed(ETrue); + itemProps.SetHiddenSelection(ETrue); + } + iListContainer->Listbox()->HandleItemAdditionL(); + } + } + } + } + +/** + * Command handling function intended for overriding by sub classes. + * Default implementation is empty. + * @param aCommand ID of the command to respond to. + */ +void CPodcastQueueView::HandleCommandL(TInt aCommand) + { + switch (aCommand) + { + case EPodcastRemoveAllDownloads: + { + TBuf msg; + iEikonEnv->ReadResourceL(msg, R_CLEAR_QUERY); + + if(ShowQueryMessage(msg)) + { + iPodcastModel.ShowEngine().RemoveAllDownloads(); + UpdateListboxItemsL(); + } + } + break; + case EPodcastRemoveDownload: + { + TInt index = iListContainer->Listbox()->CurrentItemIndex(); + if (index >= 0 && index < iPodcastModel.ActiveShowList().Count()) + { + if (iPodcastModel.ShowEngine().RemoveDownloadL(iPodcastModel.ActiveShowList()[index]->Uid())) + { + iItemArray->Delete(index); + iItemIdArray.Remove(index); + iListContainer->Listbox()->HandleItemRemovalL(); + iListContainer->Listbox()->SetCurrentItemIndex(index - 1 > 0 ? index - 1 : 0); + iListContainer->Listbox()->DrawNow(); + + delete iPodcastModel.ActiveShowList()[index]; + iPodcastModel.ActiveShowList().Remove(index); + } + } + } + break; + case EPodcastSuspendDownloads: + { + iPodcastModel.ShowEngine().SuspendDownloads(); + UpdateListboxItemsL(); + } + break; + case EPodcastResumeDownloads: + { + iPodcastModel.ShowEngine().ResumeDownloadsL(); + UpdateListboxItemsL(); + } + break; + default: + CPodcastListView::HandleCommandL(aCommand); + break; + } + UpdateToolbar(); + } + +void CPodcastQueueView::DynInitMenuPaneL(TInt aResourceId,CEikMenuPane* aMenuPane) +{ + if(aResourceId == R_PODCAST_SHOWSVIEW_MENU) + { + aMenuPane->SetItemDimmed(EPodcastMarkAllPlayed, ETrue); + } +} + +void CPodcastQueueView::UpdateToolbar() +{ + CAknToolbar* toolbar = Toolbar(); + + RShowInfoArray &fItems = iPodcastModel.ActiveShowList(); + TInt itemCnt = fItems.Count(); + + toolbar->HideItem(EPodcastRemoveDownload, EFalse, ETrue); + toolbar->HideItem(EPodcastRemoveAllDownloads, EFalse, ETrue); + toolbar->SetItemDimmed(EPodcastRemoveDownload, itemCnt == 0, ETrue); + toolbar->SetItemDimmed(EPodcastRemoveAllDownloads, itemCnt == 0, ETrue); + toolbar->HideItem(EPodcastSuspendDownloads,iPodcastModel.SettingsEngine().DownloadSuspended(), ETrue); + toolbar->HideItem(EPodcastResumeDownloads,!iPodcastModel.SettingsEngine().DownloadSuspended(), ETrue); +} + +void CPodcastQueueView::HandleLongTapEventL( const TPoint& aPenEventLocation, const TPoint& /* aPenEventScreenLocation */) +{ + DP("CPodcastQueueView::HandleLongTapEventL BEGIN"); + + if(iStylusPopupMenu) + { + iStylusPopupMenu->ShowMenu(); + iStylusPopupMenu->SetPosition(aPenEventLocation); + } + DP("CPodcastQueueView::HandleLongTapEventL END"); +} + +void CPodcastQueueView::DownloadQueueUpdatedL(TInt /*aDownloadingShows*/, TInt /*aQueuedShows*/) + { + } + +void CPodcastQueueView::FeedUpdateAllCompleteL(TFeedState /*aState*/) + { + UpdateListboxItemsL(); + UpdateToolbar(); + } diff -r 5f8e5adbbed9 -r 29cda98b007e application/src/PodcastSearchView.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/src/PodcastSearchView.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,298 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#include "PodcastSearchView.h" +#include "PodcastAppUi.h" +#include "FeedEngine.h" +#include "ShowEngine.h" +#include "SettingsEngine.h" +#include "PodcastApp.h" +#include "PodcastUtils.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +const TInt KMaxFeedNameLength = 100; +const TInt KDefaultGran = 5; +const TInt KNumberOfFilesMaxLength = 4; +#define KMaxMessageLength 200 +#define KMaxTitleLength 100 +const TInt KMimeBufLength = 100; + +_LIT(KUnknownUpdateDateString, "?/?"); +_LIT(KSearchResultFormat, "%d\t%S\t%S"); + +CPodcastSearchView* CPodcastSearchView::NewL(CPodcastModel& aPodcastModel) + { + CPodcastSearchView* self = CPodcastSearchView::NewLC(aPodcastModel); + CleanupStack::Pop( self ); + return self; + } + +CPodcastSearchView* CPodcastSearchView::NewLC(CPodcastModel& aPodcastModel) + { + CPodcastSearchView* self = new ( ELeave ) CPodcastSearchView(aPodcastModel); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + +CPodcastSearchView::CPodcastSearchView(CPodcastModel& aPodcastModel):iPodcastModel(aPodcastModel) +{ +} + +void CPodcastSearchView::ConstructL() +{ + BaseConstructL(R_PODCAST_SEARCHVIEW); + CPodcastListView::ConstructL(); + iPodcastModel.FeedEngine().AddObserver(this); + CArrayPtr< CGulIcon >* icons = new(ELeave) CArrayPtrFlat< CGulIcon >(1); + CleanupStack::PushL( icons ); + + // Load the bitmap for empty icon + CFbsBitmap* bitmap = NULL; + CFbsBitmap* mask = NULL;// + + // Load the bitmap for feed icon + + // Load svg.-image and mask with a single call + AknIconUtils::CreateIconL(bitmap, + mask, + iEikonEnv->EikAppUi()->Application()->BitmapStoreName(), + EMbmPodcastFeed, + EMbmPodcastFeed_mask); + /* + bitmap = iEikonEnv->CreateBitmapL( _L("*"),EMbmPodcastFeed_40x40);*/ + CleanupStack::PushL( bitmap ); + // Load the mask for feed icon + /*mask = iEikonEnv->CreateBitmapL( _L("*"),EMbmPodcastFeed_40x40m ); + */ + CleanupStack::PushL( mask ); + // Append the feed icon to icon array + icons->AppendL( CGulIcon::NewL( bitmap, mask ) ); + CleanupStack::Pop(2); // bitmap, mask + + iListContainer->Listbox()->ItemDrawer()->FormattedCellData()->SetIconArrayL( icons ); + CleanupStack::Pop(icons); // icons + + iListContainer->Listbox()->SetListBoxObserver(this); + + SetEmptyTextL(R_PODCAST_EMPTY_SEARCH); +} + +CPodcastSearchView::~CPodcastSearchView() + { + iPodcastModel.FeedEngine().RemoveObserver(this); + + if(iLongTapDetector) + delete iLongTapDetector, iLongTapDetector = NULL; + + if(iStylusPopupMenu) + delete iStylusPopupMenu, iStylusPopupMenu = NULL; + + } + +TUid CPodcastSearchView::Id() const +{ + return KUidPodcastSearchViewID; +} + +void CPodcastSearchView::DoActivateL(const TVwsViewId& aPrevViewId, + TUid aCustomMessageId, + const TDesC8& aCustomMessage) +{ + UpdateToolbar(); + + CAknTitlePane* titlePane = static_cast + ( StatusPane()->ControlL( TUid::Uid( EEikStatusPaneUidTitle ) ) ); + + HBufC* title = iEikonEnv->AllocReadResourceLC(R_SEARCH_RESULTS); + titlePane->SetTextL( *title, ETrue ); + CleanupStack::PopAndDestroy(title); + + CPodcastListView::DoActivateL(aPrevViewId, aCustomMessageId, aCustomMessage); + iPreviousView = TVwsViewId(KUidPodcast, KUidPodcastFeedViewID); +} + +void CPodcastSearchView::DoDeactivate() +{ + CPodcastListView::DoDeactivate(); + CAknTitlePane* titlePane = static_cast + ( StatusPane()->ControlL( TUid::Uid( EEikStatusPaneUidTitle ) ) ); + titlePane->SetTextToDefaultL(); +} + + +void CPodcastSearchView::HandleListBoxEventL(CEikListBox* /* aListBox */, TListBoxEvent aEventType) +{ + DP("CPodcastSearchView::HandleListBoxEventL BEGIN"); + switch(aEventType) + { + case EEventEnterKeyPressed: + case EEventItemDoubleClicked: + case EEventItemActioned: + { + HandleCommandL(EPodcastAddSearchResult); + } + break; + default: + break; + } + DP("CPodcastSearchView::HandleListBoxEventL END"); +} + +void CPodcastSearchView::UpdateListboxItemsL() + { + DP("CPodcastSearchView::UpdateListboxItemsL BEGIN"); + if(!iListContainer->IsVisible()) { + DP("CPodcastSearchView::UpdateListboxItemsL END (not visible)"); + return; + } + const RFeedInfoArray* searchItems = NULL; + searchItems = &iPodcastModel.FeedEngine().GetSearchResults(); + TInt len = searchItems->Count(); + TListItemProperties itemProps; + iListContainer->Listbox()->Reset(); + iListContainer->Listbox()->ItemDrawer()->ClearAllPropertiesL(); + iItemIdArray.Reset(); + iItemArray->Reset(); + + if (len > 0) + { + for (int i=0;iUid()); + TInt iconIndex = 0; + + TBuf<512> descr; + descr.Copy(fi->Description().Left(512)); + + iListboxFormatbuffer.Format(KSearchResultFormat(), iconIndex, &fi->Title(), &descr); + iItemArray->AppendL(iListboxFormatbuffer); + iListContainer->Listbox()->ItemDrawer()->SetPropertiesL(i, itemProps); + } + } + else + { + TBuf itemName; + iEikonEnv->ReadResourceL(itemName, R_PODCAST_NO_SEARCH_RESULTS); + iItemArray->Reset(); + iItemIdArray.Reset(); + + TListItemProperties itemProps; + itemProps.SetDimmed(ETrue); + itemProps.SetHiddenSelection(ETrue); + iListContainer->Listbox()->ItemDrawer()->SetPropertiesL(0, itemProps); + } + iListContainer->Listbox()->HandleItemAdditionL(); + DP("CPodcastSearchView::UpdateListboxItemsL END"); + } + +/** + * Command handling function intended for overriding by sub classes. + * Default implementation is empty. + * @param aCommand ID of the command to respond to. + */ +void CPodcastSearchView::HandleCommandL(TInt aCommand) + { + //CloseToolbarExtension(); + switch(aCommand) + { + case EPodcastAddSearchResult: + { + TInt index = iListContainer->Listbox()->CurrentItemIndex(); + + if(index < iItemArray->MdcaCount() && index >= 0) + { + CFeedInfo *newInfo = iPodcastModel.FeedEngine().GetSearchResults()[index]; + + // ask if user wants to add the feed + TBuf templ; + TBuf message; + + iEikonEnv->ReadResourceL(templ, R_ADD_FEED_QUERY); + message.Format(templ, &newInfo->Title()); + if(ShowQueryMessage(message)) { + TBool added = iPodcastModel.FeedEngine().AddFeedL(*newInfo); + + if (added) + { + // ask if user wants to update it now + TBuf message; + iEikonEnv->ReadResourceL(message, R_ADD_FEED_SUCCESS); + if(ShowQueryMessage(message)) + { + CFeedInfo *info = iPodcastModel.FeedEngine().GetFeedInfoByUid(newInfo->Uid()); + + iPodcastModel.ActiveShowList().Reset(); + iPodcastModel.SetActiveFeedInfo(info); + AppUi()->ActivateLocalViewL(KUidPodcastShowsViewID, TUid::Uid(0), KNullDesC8()); + iPodcastModel.FeedEngine().UpdateFeedL(info->Uid()); + } + } + else + { + TBuf message; + iEikonEnv->ReadResourceL(message, R_ADD_FEED_EXISTS); + ShowErrorMessage(message); + } + } + } + } + break; + default: + CPodcastListView::HandleCommandL(aCommand); + break; + } + UpdateToolbar(); + } + +void CPodcastSearchView::OpmlParsingComplete(TUint /*aNumFeedsImported*/) + { + DP("CPodcastSearchView::OpmlParsingComplete BEGIN"); + UpdateListboxItemsL(); + UpdateToolbar(); + DP("CPodcastSearchView::OpmlParsingComplete END"); + } + +void CPodcastSearchView::UpdateToolbar() +{ + TBool disableAdd = iItemArray->MdcaCount() == 0 || iSearchRunning; + + CAknToolbar* toolbar = Toolbar(); + + if (toolbar) + { + toolbar->SetItemDimmed(EPodcastAddSearchResult, disableAdd, ETrue ); + toolbar->HideItem(EPodcastSearch, iSearchRunning, ETrue ); + toolbar->HideItem(EPodcastCancelUpdateAllFeeds, !iSearchRunning, ETrue); + } +} diff -r 5f8e5adbbed9 -r 29cda98b007e application/src/PodcastSettingsView.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/src/PodcastSettingsView.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,567 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#include "PodcastSettingsView.h" +#include "PodcastAppUi.h" +#include "Podcast.hrh" +#include +#include +#include +#include +#include "SettingsEngine.h" + +#include +#include +#include + + +class CIapSetting: public CAknEnumeratedTextPopupSettingItem +{ +public: + CIapSetting(TInt aResourceId, TInt& aValue, CPodcastModel &aPodcastModel) : + CAknEnumeratedTextPopupSettingItem(aResourceId, aValue), iPodcastModel(aPodcastModel), iIap(aValue) + { + } + + ~CIapSetting() + { + } + + void RefreshConnectionListL() + { + CArrayPtr< CAknEnumeratedText > * enumeratedArr = EnumeratedTextArray(); + CArrayPtr< HBufC > * poppedUpTextArray = PoppedUpTextArray(); + enumeratedArr->ResetAndDestroy(); + poppedUpTextArray->ResetAndDestroy(); + + CDesCArrayFlat *iapArray = iPodcastModel.IAPNames(); + + TBool valueExists = EFalse; + DP2("InternalValue=%d, ExternalValue=%d", InternalValue(), ExternalValue()); + for (int i=0;iCount();i++) { + HBufC *buf = (*iapArray)[i].AllocL(); + poppedUpTextArray->AppendL(buf); + + TInt iapId = iPodcastModel.IAPIds()[i].iIapId; + DP2("IAP name='%S', id=%d", buf, iapId); + + if (iapId == ExternalValue()) { + valueExists = ETrue; + } + // both arrays destroy themselves, so we need two copies to prevent USER 44 + HBufC *buf2 = (*iapArray)[i].AllocL(); + + CAknEnumeratedText *enumerated = new CAknEnumeratedText(iapId, buf2); + enumeratedArr->AppendL(enumerated); + } + + DP1("valueExists=%d", valueExists); + if (!valueExists && iPodcastModel.IAPIds().Count() > 0 ) { + DP1("Setting iIap=%d", iPodcastModel.IAPIds()[0].iIapId); + iIap = iPodcastModel.IAPIds()[0].iIapId; + LoadL(); + DP2("InternalValue=%d, ExternalValue=%d", InternalValue(), ExternalValue()); + } + + TRAPD(err, HandleTextArrayUpdateL()); + + if (err != KErrNone) { + DP1("Leave in HandleTextArrayUpdateL, err=%d", err); + } + } + + void CompleteConstructionL() + { + DP("CIapSetting::CompleteConstructionL BEGIN"); + CAknEnumeratedTextPopupSettingItem::CompleteConstructionL(); + RefreshConnectionListL(); + DP("CIapSetting::CompleteConstructionL END"); + } + + void EditItemL(TBool aCalledFromMenu) + { + DP("CIapSetting::EditItemL BEGIN"); + LoadL(); + CAknEnumeratedTextPopupSettingItem::EditItemL(aCalledFromMenu); + StoreL(); + DP2("InternalValue=%d, ExternalValue=%d", InternalValue(), ExternalValue()); + DP("CIapSetting::EditItemL END"); + } + + void HandleSettingPageEventL(CAknSettingPage* aSettingPage, TAknSettingPageEvent aEventType) + { + DP("CIapSetting::HandleSettingPageEventL BEGIN"); + CAknSettingItem::HandleSettingPageEventL(aSettingPage, aEventType); + /*if (aEventType == EEventSettingOked) + { + DP2("InternalValue=%d, ExternalValue=%d", InternalValue(), ExternalValue()); + StoreL(); + }*/ + DP("CIapSetting::HandleSettingPageEventL END"); + } + +protected: + CPodcastModel& iPodcastModel; + TInt& iIap; +}; + + +class CConnectionSetting: public CAknEnumeratedTextPopupSettingItem +{ +public: + CConnectionSetting(TInt aResourceId, TInt& aValue, CPodcastModel &aPodcastModel) : + CAknEnumeratedTextPopupSettingItem(aResourceId, aValue), iPodcastModel(aPodcastModel) + { + } + + ~CConnectionSetting() + { + } + + void RefreshConnectionListL() + { + CArrayPtr< CAknEnumeratedText > * enumeratedArr = EnumeratedTextArray(); + CArrayPtr< HBufC > * poppedUpTextArray = PoppedUpTextArray(); + + CDesCArrayFlat *snapArray = iPodcastModel.SNAPNames(); + + TBool valueExists = EFalse; + DP2("InternalValue=%d, ExternalValue=%d", InternalValue(), ExternalValue()); + for (int i=0;iCount();i++) { + HBufC *buf = (*snapArray)[i].AllocL(); + poppedUpTextArray->InsertL(EConnectionUseNetwork+i,buf); + + TInt snapId = iPodcastModel.SNAPIds()[i].iIapId; + DP2("SNAP name='%S', id=%d", buf, snapId); + + if (snapId == ExternalValue()) { + valueExists = ETrue; + } + // both arrays destroy themselves, so we need two copies to prevent USER 44 + HBufC *buf2 = (*snapArray)[i].AllocL(); + + CAknEnumeratedText *enumerated = new CAknEnumeratedText(EConnectionUseNetwork+i, buf2); + enumeratedArr->InsertL(EConnectionUseNetwork+i, enumerated); + } + + DP1("valueExists=%d", valueExists); + if (!valueExists && iPodcastModel.SNAPIds().Count() > 0 ) { + DP1("Setting i=%d", iPodcastModel.SNAPIds()[0].iIapId); + LoadL(); + DP2("InternalValue=%d, ExternalValue=%d", InternalValue(), ExternalValue()); + } + + TRAPD(err, HandleTextArrayUpdateL()); + + if (err != KErrNone) { + DP1("Leave in HandleTextArrayUpdateL, err=%d", err); + } + } + + void CompleteConstructionL() + { + DP("CIapSetting::CompleteConstructionL BEGIN"); + CAknEnumeratedTextPopupSettingItem::CompleteConstructionL(); + RefreshConnectionListL(); + DP("CIapSetting::CompleteConstructionL END"); + } + + void EditItemL(TBool aCalledFromMenu) + { + DP("CIapSetting::EditItemL BEGIN"); + LoadL(); + CAknEnumeratedTextPopupSettingItem::EditItemL(aCalledFromMenu); + StoreL(); + DP2("InternalValue=%d, ExternalValue=%d", InternalValue(), ExternalValue()); + DP("CIapSetting::EditItemL END"); + } + + void HandleSettingPageEventL(CAknSettingPage* aSettingPage, TAknSettingPageEvent aEventType) + { + DP("CIapSetting::HandleSettingPageEventL BEGIN"); + CAknSettingItem::HandleSettingPageEventL(aSettingPage, aEventType); + /*if (aEventType == EEventSettingOked) + { + DP2("InternalValue=%d, ExternalValue=%d", InternalValue(), ExternalValue()); + StoreL(); + }*/ + DP("CIapSetting::HandleSettingPageEventL END"); + } + +protected: + CPodcastModel& iPodcastModel; +}; + +class CPodcastSettingItemList:public CAknSettingItemList + { +public: + CPodcastSettingItemList(CPodcastModel& aPodcastModel) : iPodcastModel(aPodcastModel) + { + } + + ~CPodcastSettingItemList() + { + DP("CPodcastSettingItemList~"); + } + + void StoreSettings() { + DP("StoreSettings BEGIN"); + StoreSettingsL(); + CSettingsEngine &se = iPodcastModel.SettingsEngine(); + se.SetBaseDir(iShowDir); + DP1("Base Dir: %S", &iShowDir); + se.SetUpdateAutomatically((TAutoUpdateSetting)iAutoUpdate); + DP1("Update automatically: %d", iAutoUpdate); + switch(iConnection) + { + case EConnectionDefault: + { + DP("Specific IAP: 0 Ask user"); + se.SetSpecificIAP(0); + }break; + case EConnectionAlwaysAsk: + { + DP("Specific IAP: -1 Ask user"); + se.SetSpecificIAP(-1); + }break; + + case EConnectionUseIap: + { + DP1("Specific NETWORK: %d", iIap); + se.SetSpecificIAP((iIap|KUseIAPFlag)); + }break; + default: + case EConnectionUseNetwork: + { + DP1("Specific IAP: %d", iIap); + TInt snapIndex = iConnection-EConnectionUseNetwork; + se.SetSpecificIAP(iPodcastModel.SNAPIds()[snapIndex].iIapId); + }break; + } + + DP1("Download automatically: %d", iAutoDownload); + se.SetDownloadAutomatically(iAutoDownload); + se.SaveSettingsL(); + DP("StoreSettings END"); + } + + void HandleListBoxEventL(CEikListBox* aListBox, TListBoxEvent aEventType) + { + DP1("CPodcastSettingItemList::HandleListBoxEventL event %d", aEventType) + CAknSettingItemList::HandleListBoxEventL(aListBox, aEventType); + } + + void UpdateSettingVisibility() + { + DP("UpdateSettingVisibility BEGIN"); + LoadSettingsL(); + TBool dimAutoUpdate = iConnection == EConnectionAlwaysAsk; + TBool dimIAP = iConnection < EConnectionUseIap; + + iSettingAutoUpdate->SetHidden(dimAutoUpdate); + iSettingIAP->SetHidden(dimIAP); + if(!dimIAP) + { + iSettingIAP->RefreshConnectionListL(); + } + ListBox()->ScrollToMakeItemVisible(0); + + TRAP_IGNORE(HandleChangeInItemArrayOrVisibilityL()); + DP("UpdateSettingVisibility END"); + } + + void EditItemL (TInt aIndex, TBool aCalledFromMenu) + { + DP("EditItemL BEGIN"); + if (aIndex == 0) { + CAknMemorySelectionDialog* memDlg = + CAknMemorySelectionDialog::NewL(ECFDDialogTypeNormal, ETrue); + CleanupStack::PushL(memDlg); + CAknMemorySelectionDialog::TMemory memory = + CAknMemorySelectionDialog::EPhoneMemory; + + if (memDlg->ExecuteL(memory)) + { + TFileName importName; + + if (memory==CAknMemorySelectionDialog::EMemoryCard) + { + importName = PathInfo:: MemoryCardRootPath(); + } + else + { + importName = PathInfo:: PhoneMemoryRootPath(); + } + + CAknFileSelectionDialog* dlg = CAknFileSelectionDialog::NewL(ECFDDialogTypeSave, R_PODCAST_SHOWDIR_SELECTOR); + HBufC* select = iEikonEnv->AllocReadResourceLC(R_PODCAST_SOFTKEY_SELECT); + dlg->SetLeftSoftkeyFileL(*select); + CleanupStack::PopAndDestroy(select); + CleanupStack::PushL(dlg); + + dlg->SetDefaultFolderL(importName); + + if(dlg->ExecuteL(importName)) + { + importName.Append(_L("Podcasts")); + iShowDir.Copy(importName); + LoadSettingsL(); + } + CleanupStack::PopAndDestroy(dlg); + } + CleanupStack::PopAndDestroy(memDlg); + } + else { + CAknSettingItemList::EditItemL(aIndex,aCalledFromMenu); + } + StoreSettingsL(); + UpdateSettingVisibility(); + DP("EditItemL END"); + } + + /** + * Framework method to create a setting item based upon the user id aSettingId. The + * client code decides what type to contruct. new (ELeave) must then be used and the resulting + * pointer returned. Ownership is thereafter base class's responsiblity. + * + * @param aSettingId ID to use to determine the type of the setting item + * @return a constructed (not 2nd-stage constructed) setting item. + */ + CAknSettingItem* CreateSettingItemL( TInt aSettingId ) + { + DP1("CreateSettingItemL BEGIN, aSettingId=%d", aSettingId); + + CSettingsEngine &se = iPodcastModel.SettingsEngine(); + iShowDir.Copy(se.BaseDir()); + iAutoUpdate = se.UpdateAutomatically(); + iIap = se.SpecificIAP(); + + if( iIap == 0) + { + iConnection = EConnectionDefault; + } + else if ( iIap == -1) + { + iConnection = EConnectionAlwaysAsk; + } + else if ( (iIap & KUseIAPFlag)) + { + iConnection = EConnectionUseIap; + iIap = iIap& KUseIAPMask; + } + else + { + TInt snapIndex = 0; + TInt cnt = iPodcastModel.SNAPIds().Count(); + while(snapIndex < cnt && ((TInt)iPodcastModel.SNAPIds()[snapIndex].iIapId) != iIap) + { + snapIndex++; + } + + if(snapIndex != cnt) + { + iConnection = EConnectionUseNetwork+snapIndex; + } + else + { + iConnection = EConnectionAlwaysAsk; + } + } + + iAutoDownload = se.DownloadAutomatically(); + + switch(aSettingId) + { + case EPodcastSettingShowDir: + DP("EPodcastSettingShowDir"); + return new (ELeave) CAknTextSettingItem(aSettingId, iShowDir); + break; + case EPodcastSettingAutoUpdate: + DP("EPodcastSettingAutoUpdate"); + iSettingAutoUpdate = new (ELeave) CAknEnumeratedTextPopupSettingItem(aSettingId, iAutoUpdate); + return iSettingAutoUpdate; + break; + case EPodcastSettingConnection: + DP("EPodcastSettingConnection"); + return new (ELeave) CConnectionSetting (aSettingId, iConnection, iPodcastModel); + break; + case EPodcastSettingIAPList: + DP("EPodcastSettingIAPList"); + iSettingIAP = new (ELeave) CIapSetting (aSettingId, iIap, iPodcastModel); + return iSettingIAP; + break; + case EPodcastSettingAutoDownload: + DP("EPodcastSettingAutoDownload"); + iSettingAutoDownload = new (ELeave) CAknBinaryPopupSettingItem (aSettingId, iAutoDownload); + return iSettingAutoDownload; + break; + default: + return CAknSettingItemList::CreateSettingItemL(aSettingId); + break; + } + DP("CreateSettingItemL END"); + return NULL; + } + + TFileName iShowDir; + + TInt iAutoUpdate; + CAknSettingItem *iSettingAutoUpdate; + + TInt iAutoDownload; + CAknSettingItem *iSettingAutoDownload; + + TInt iConnection; + + TInt iIap; + CIapSetting *iSettingIAP; + + + CPodcastModel &iPodcastModel; + }; + + +CPodcastSettingsView* CPodcastSettingsView::NewL(CPodcastModel& aPodcastModel) + { + CPodcastSettingsView* self = CPodcastSettingsView::NewLC(aPodcastModel); + CleanupStack::Pop( self ); + return self; + } + +CPodcastSettingsView* CPodcastSettingsView::NewLC(CPodcastModel& aPodcastModel) + { + CPodcastSettingsView* self = new ( ELeave ) CPodcastSettingsView(aPodcastModel); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + +CPodcastSettingsView::CPodcastSettingsView(CPodcastModel& aPodcastModel):iPodcastModel(aPodcastModel) +{ +} + +void CPodcastSettingsView::ConstructL() +{ + BaseConstructL(R_PODCAST_SETTINGSVIEW); +} + +CPodcastSettingsView::~CPodcastSettingsView() + { + DP("CPodcastSettingsView::~CPodcastSettingsView()"); + delete iListbox; + } + +TUid CPodcastSettingsView::Id() const +{ + return KUidPodcastSettingsViewID; +} + +void CPodcastSettingsView::DoActivateL(const TVwsViewId& aPrevViewId, + TUid /*aCustomMessageId*/, + const TDesC8& /*aCustomMessage*/) +{ + DP("CPodcastSettingsView::DoActivateL BEGIN"); + iPreviousView = aPrevViewId; + + if (iListbox) { + delete iListbox; + iListbox = NULL; + } + + DP("Creating listbox"); + iPodcastModel.UpdateSNAPListL(); + iPodcastModel.UpdateIAPListL(); + + iListbox =new (ELeave) CPodcastSettingItemList(iPodcastModel); + iListbox->SetMopParent( this ); + iListbox->ConstructFromResourceL(R_PODCAST_SETTINGS); + iListbox->SetRect(ClientRect()); + iListbox->ActivateL(); + + DP("Creating navipane"); + iNaviPane =( CAknNavigationControlContainer * ) StatusPane()->ControlL( TUid::Uid( EEikStatusPaneUidNavi ) ); + + HBufC *titleBuffer = iEikonEnv->AllocReadResourceL(R_SETTINGS_TITLE); + iNaviDecorator = iNaviPane->CreateNavigationLabelL(*titleBuffer); + delete titleBuffer; + + DP("Updating listbox"); + AppUi()->AddToStackL(*this, iListbox); + iListbox->UpdateSettingVisibility(); + iListbox->MakeVisible(ETrue); + iListbox->DrawNow(); + iListbox->SetFocus(ETrue); + + if(iNaviDecorator && iNaviPane) + { + iNaviPane->PushL(*iNaviDecorator); + } + DP("CPodcastSettingsView::DoActivateL END"); +} + +void CPodcastSettingsView::DoDeactivate() + { + DP("CPodcastSettingsView::DoDeactivate BEGIN"); + if (iListbox) { + iListbox->MakeVisible(EFalse); + + AppUi()->RemoveFromViewStack( *this, iListbox ); + + } + + if(iNaviDecorator && iNaviPane) + { + iNaviPane->Pop(iNaviDecorator); + delete iNaviDecorator; + iNaviDecorator = NULL; + } + DP("CPodcastSettingsView::DoDeactivate END"); + } + +/** +* Command handling function intended for overriding by sub classes. +* Default implementation is empty. +* @param aCommand ID of the command to respond to. +*/ +void CPodcastSettingsView::HandleCommandL(TInt aCommand) +{ + CAknView::HandleCommandL(aCommand); + DP1("CPodcastListView::HandleCommandL=%d", aCommand); + switch(aCommand) + { + case EAknSoftkeyBack: + { + iListbox->StoreSettings(); + AppUi()->ActivateViewL(iPreviousView); + } + break; + default: + AppUi()->HandleCommandL(aCommand); + break; + } +} + +void CPodcastSettingsView::HandleStatusPaneSizeChange() +{ + CAknView::HandleStatusPaneSizeChange(); + + DP2("CPodcastSettingsView::HandleStatusPaneSizeChange() width=%d, height=%d", ClientRect().Width(), ClientRect().Height()); + if (iListbox) { + iListbox->SetRect( ClientRect()); + } +} diff -r 5f8e5adbbed9 -r 29cda98b007e application/src/PodcastShowsView.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/application/src/PodcastShowsView.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,904 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#include "PodcastShowsView.h" +#include "PodcastAppUi.h" +#include "ShowEngine.h" +#include "SettingsEngine.h" +#include "PodcastApp.h" +#include "imagehandler.h" +#include "constants.h" + +#include +#include +#include +#include +#include +#include +#include + +#define KMaxMessageLength 200 + +#define KPodcastImageWidth 160 +#define KPodcastImageHeight 120 +#define KPodcastDialogOffset 2 + +#define KOneHundredPercent 100 + +const TInt KSizeBufLen = 64; +const TInt KDefaultGran = 5; +_LIT(KSizeDownloadingOf, "%.1f/%.1f MB"); +_LIT(KShowsSizeFormatS60, "%.1f MB"); + +_LIT(KShowFormat, "%d\t%S\t%S %S\t"); +_LIT(KShowErrorFormat, "%d\t%S\t%S\t"); +_LIT(KShowQueueFormat, "%d\t%S\t%S%S\t"); + +// these must correspond with TShowsIconIndex + +const TUint KShowIconArrayIds[] = + { + EMbmPodcastAudio, + EMbmPodcastAudio_mask, + EMbmPodcastAudio_new, + EMbmPodcastAudio_new_mask, + EMbmPodcastAudio_queued, + EMbmPodcastAudio_queued_mask, + EMbmPodcastAudio_downloading, + EMbmPodcastAudio_downloading_mask, + EMbmPodcastAudio_downloaded, + EMbmPodcastAudio_downloaded_mask, + EMbmPodcastAudio_downloaded_new, + EMbmPodcastAudio_downloaded_new_mask, + EMbmPodcastAudio_failed, + EMbmPodcastAudio_failed_mask, + EMbmPodcastAudio_suspended, + EMbmPodcastAudio_suspended_mask, + 0, + 0 + }; + +/** + * This is an interal class to display a message query dialog with an image at the bottm + */ +class CPodcastImageMessageQueryDialog:public CAknMessageQueryDialog + { + public: + /** + * C++ default constructor. + * + * @param aMessage Dialog box text. + * @param aHeader Header for the dialog. + * @deprecated + */ + CPodcastImageMessageQueryDialog(TDesC* aMessage, TDesC* aHeader):CAknMessageQueryDialog(aMessage, aHeader) + { + + } + + ~CPodcastImageMessageQueryDialog() + { + + } + + void SetSizeAndPosition(const TSize& aSize) + { + CAknMessageQueryDialog::SetSizeAndPosition(aSize); + + TPoint pos = Position(); + TSize size = Size(); + + CAknDialog::SetSizeAndPosition(aSize); + + pos.iY-=((aSize.iHeight-size.iHeight)-KPodcastDialogOffset); + SetPosition(pos); + SetSize(aSize); + } + + }; + +CPodcastShowsView* CPodcastShowsView::NewL(CPodcastModel& aPodcastModel) + { + CPodcastShowsView* self = CPodcastShowsView::NewLC(aPodcastModel); + CleanupStack::Pop(self); + return self; + } + +CPodcastShowsView* CPodcastShowsView::NewLC(CPodcastModel& aPodcastModel) + { + CPodcastShowsView* self = new ( ELeave ) CPodcastShowsView(aPodcastModel); + CleanupStack::PushL(self); + self->ConstructL(); + return self; + } + +CPodcastShowsView::CPodcastShowsView(CPodcastModel& aPodcastModel) : + iPodcastModel(aPodcastModel) + { + } + +void CPodcastShowsView::ConstructL() + { + BaseConstructL(R_PODCAST_SHOWSVIEW); + CPodcastListView::ConstructL(); + + CreateIconsL(); + + iListContainer->Listbox()->SetListBoxObserver(this); + + iPodcastModel.FeedEngine().AddObserver(this); + iPodcastModel.ShowEngine().AddObserver(this); + + iStylusPopupMenu = CAknStylusPopUpMenu::NewL( this , TPoint(0,0)); + TResourceReader reader; + iCoeEnv->CreateResourceReaderLC(reader,R_SHOWVIEW_POPUP_MENU); + iStylusPopupMenu->ConstructFromResourceL(reader); + + CleanupStack::PopAndDestroy(); + } + +void CPodcastShowsView::CreateIconsL() + { + CArrayPtr< CGulIcon>* icons = new(ELeave) CArrayPtrFlat< CGulIcon>(1); + CleanupStack::PushL(icons); + TInt pos = 0; + while (KShowIconArrayIds[pos] > 0) + { + // Load the bitmap for play icon + CFbsBitmap* bitmap= NULL;//iEikonEnv->CreateBitmapL( _L("*"), KIconArrayIds[pos]); + CFbsBitmap* mask= NULL;////iEikonEnv->CreateBitmapL( _L("*"), KIconArrayIds[pos+1] ); + AknIconUtils::CreateIconL(bitmap, + mask, + iEikonEnv->EikAppUi()->Application()->BitmapStoreName(), + KShowIconArrayIds[pos], + KShowIconArrayIds[pos+1]); + CleanupStack::PushL(bitmap); + CleanupStack::PushL(mask); + + // Append the play icon to icon array + icons->AppendL(CGulIcon::NewL(bitmap, mask) ); + CleanupStack::Pop(2); // bitmap, mask + pos+=2; + } + + iListContainer->Listbox()->ItemDrawer()->FormattedCellData()->SetIconArrayL(icons); + CleanupStack::Pop(icons); // icons + } + +TKeyResponse CPodcastShowsView::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType) + { + if (aType == EEventKey) + { + CShowInfo *activeShow = NULL; + + TInt index = iListContainer->Listbox()->CurrentItemIndex(); + if(index >= 0 && index < iPodcastModel.ActiveShowList().Count()) + { + activeShow = iPodcastModel.ActiveShowList()[index]; + } + + if (activeShow != NULL) { + DP1("aKeyEvent.iCode=%d", aKeyEvent.iCode); + switch (aKeyEvent.iCode) { + case 117: + case '*': + case EKeySpace: + if (activeShow->PlayState() == EPlayed) { + HandleCommandL(EPodcastMarkAsUnplayed); + } else { + HandleCommandL(EPodcastMarkAsPlayed); + } + break; + case 106: + case '#': + if (activeShow->DownloadState() == ENotDownloaded) { + HandleCommandL(EPodcastDownloadShow); + } + break; + case EKeyBackspace: + case EKeyDelete: + HandleCommandL(EPodcastDeleteShow); + break; + default: + break; + } + UpdateToolbar(); + } + } + return CPodcastListView::OfferKeyEventL(aKeyEvent, aType); + } + +CPodcastShowsView::~CPodcastShowsView() + { + iPodcastModel.ShowEngine().RemoveObserver(this); + iPodcastModel.FeedEngine().RemoveObserver(this); + + if(iStylusPopupMenu) + delete iStylusPopupMenu, iStylusPopupMenu = NULL; + } + + +TUid CPodcastShowsView::Id() const + { + return KUidPodcastShowsViewID; + } + +void CPodcastShowsView::DoActivateL(const TVwsViewId& aPrevViewId, + TUid aCustomMessageId, const TDesC8& aCustomMessage) + { + DP("CPodcastShowsView::DoActivateL BEGIN"); + + UpdateViewTitleL(); + + CPodcastListView::DoActivateL(aPrevViewId, aCustomMessageId, aCustomMessage); + iPreviousView = TVwsViewId(KUidPodcast, KUidPodcastFeedViewID); + + UpdateFeedUpdateStateL(); + UpdateToolbar(); + DP("CPodcastShowsView::DoActivateL END"); + } + +void CPodcastShowsView::DoDeactivate() + { + CAknTitlePane* titlePane = static_cast + ( StatusPane()->ControlL( TUid::Uid( EEikStatusPaneUidTitle ) ) ); + +// titlePane->SetSmallPicture(NULL, NULL, ETrue); + titlePane->SetPicture(NULL, NULL); + titlePane->SetTextToDefaultL(); + CPodcastListView::DoDeactivate(); + } + +// Engine callback when new shows are available +void CPodcastShowsView::ShowListUpdatedL() + { + UpdateListboxItemsL(); + } + +void CPodcastShowsView::ShowDownloadUpdatedL(TInt aBytesOfCurrentDownload, TInt /*aBytesTotal*/) + { + if (!iListContainer->IsVisible()) + { + return; + } + + CShowInfo *info = iPodcastModel.ShowEngine().ShowDownloading(); + if (info) + { + UpdateShowItemL(info->Uid(), aBytesOfCurrentDownload); + } + } + +void CPodcastShowsView::ShowDownloadFinishedL(TUint /*aShowUid*/, TInt aError) + { + iProgressAdded = EFalse; + + switch(aError) + { + case KErrCouldNotConnect: + { + TBuf message; + iEikonEnv->ReadResourceL(message, R_PODCAST_CONNECTION_ERROR); + ShowErrorMessage(message); + } + break; + default: // Do nothing + break; + } + } + + +void CPodcastShowsView::FeedDownloadStartedL(TFeedState /*aState*/, TUint aFeedUid) + { + // TODO make use of the fact that we know that the feed download is + // started instead of checking feed engine states in UpdateFeedUpdateStateL. + if (iPodcastModel.ActiveFeedInfo() != NULL + && iPodcastModel.ActiveFeedInfo()->Uid() == aFeedUid) + { + TRAP_IGNORE(UpdateFeedUpdateStateL()); + UpdateToolbar(); + } + } + +void CPodcastShowsView::FeedDownloadFinishedL(TFeedState /*aState*/, TUint aFeedUid, TInt /*aError*/) + { + DP("CPodcastShowsView::FeedDownloadFinishedL BEGIN"); + // TODO make use of the fact that we know that the feed download is + // finished instead of checking feed engine states in UpdateFeedUpdateStateL. + if (iPodcastModel.ActiveFeedInfo() != NULL + && iPodcastModel.ActiveFeedInfo()->Uid() == aFeedUid) + { + TRAP_IGNORE(UpdateFeedUpdateStateL()); + TRAP_IGNORE(UpdateViewTitleL()); + } + DP("CPodcastShowsView::FeedDownloadFinishedL END"); + } + +void CPodcastShowsView::HandleListBoxEventL(CEikListBox* /*aListBox*/, + TListBoxEvent aEventType) + { + switch (aEventType) + { + case EEventEnterKeyPressed: + case EEventItemActioned: + case EEventItemDoubleClicked: + { + RShowInfoArray &fItems = iPodcastModel.ActiveShowList(); + TInt index = iListContainer->Listbox()->CurrentItemIndex(); + if (index>=0 && index< fItems.Count()) + { + DP2("Handle event for podcast %S, downloadState is %d", &(fItems[index]->Title()), fItems[index]->DownloadState()); + CShowInfo *showInfo = fItems[index]; + + switch (showInfo->DownloadState()) { + case ENotDownloaded: + HandleCommandL(EPodcastDownloadShow); + break; + case EQueued: + AppUi()->ActivateLocalViewL(KUidPodcastQueueViewID, TUid::Uid(0), KNullDesC8()); + ((CPodcastAppUi*)AppUi())->SetActiveTab(KTabIdQueue); + break; + case EDownloaded: + #pragma message("LAPER Replace activate playview with activate playback in mpx") + break; + default: + break; + } + } + } + break; + default: + break; + } + UpdateToolbar(); + } + +void CPodcastShowsView::GetShowIcons(CShowInfo* aShowInfo, TInt& aIconIndex) + { + TBool dlStop = iPodcastModel.SettingsEngine().DownloadSuspended(); + TUint showDownloadingUid = iPodcastModel.ShowEngine().ShowDownloading() ? iPodcastModel.ShowEngine().ShowDownloading()->Uid() : 0; + + if (showDownloadingUid == aShowInfo->Uid()) + { + aIconIndex = dlStop ? ESuspendedShowIcon : EDownloadingShowIcon; + } + else + { + switch (aShowInfo->DownloadState()) + { + case EDownloaded: + if (aShowInfo->PlayState() == ENeverPlayed) { + aIconIndex = EDownloadedNewShowIcon; + } else { + aIconIndex = EDownloadedShowIcon; + } + break; + case ENotDownloaded: + if (aShowInfo->PlayState() == ENeverPlayed) { + aIconIndex = ENewShowIcon; + } else { + aIconIndex = EShowIcon; + } + break; + case EQueued: + aIconIndex = dlStop ? ESuspendedShowIcon : EQuedShowIcon; + break; + case EDownloading: + aIconIndex = dlStop ? ESuspendedShowIcon : EDownloadingShowIcon; + break; + case EFailedDownload: + aIconIndex = EFailedShowIcon; + break; + } + } + } + + +void CPodcastShowsView::UpdateFeedUpdateStateL() + { + TBool listboxDimmed = EFalse; + + if (iPodcastModel.FeedEngine().ClientState() != EIdle && iPodcastModel.ActiveFeedInfo() + != NULL && iPodcastModel.FeedEngine().ActiveClientUid() == iPodcastModel.ActiveFeedInfo()->Uid()) + { + listboxDimmed = ETrue; + } + + if ((iListContainer->Listbox()->IsDimmed() && !listboxDimmed) || (!iListContainer->Listbox()->IsDimmed() && listboxDimmed)) + { + iListContainer->Listbox()->SetDimmed(listboxDimmed); + } + UpdateListboxItemsL(); + UpdateToolbar(); + } + +void CPodcastShowsView::FormatShowInfoListBoxItemL(CShowInfo& aShowInfo, TInt aSizeDownloaded) + { + TBuf<32> infoSize; + TInt iconIndex = 0; + TBuf showDate; + GetShowIcons(&aShowInfo, iconIndex); + + if(aSizeDownloaded > 0) + { + if (aShowInfo.ShowSize() > 0) + { + infoSize.Format(KSizeDownloadingOf(), ((float) aSizeDownloaded / (float) KSizeMb), + ((float)aShowInfo.ShowSize() / (float)KSizeMb)); + } + else + { + infoSize.Format(KShowsSizeFormatS60(), (float)aSizeDownloaded / (float)KSizeMb); + } + } + else if (aShowInfo.ShowSize() > 0) + { + infoSize.Format(KShowsSizeFormatS60(), (float)aShowInfo.ShowSize() / (float)KSizeMb); + } + else { + infoSize = KNullDesC(); + } + + if (aShowInfo.PubDate().Int64() == 0) + { + showDate = KNullDesC(); + } + else + { + aShowInfo.PubDate().FormatL(showDate, KDateFormatShort()); + } + + if(aShowInfo.LastError() != KErrNone) + { + TBuf errorBuffer; + GetShowErrorText(errorBuffer, aShowInfo.LastError()); + iListboxFormatbuffer.Format(KShowErrorFormat(), iconIndex, &aShowInfo.Title(), &errorBuffer); + } + else + { + if (infoSize.Length() > 0) { + infoSize.Insert(0,_L(", ")); + } + + iListboxFormatbuffer.Format(KShowFormat(), iconIndex, &aShowInfo.Title(), &showDate, &infoSize); + } + } + +void CPodcastShowsView::GetShowErrorText(TDes &aErrorMessage, TInt aErrorCode) + { + iEikonEnv->GetErrorText(aErrorMessage, aErrorCode); + } + +void CPodcastShowsView::UpdateShowItemDataL(CShowInfo* aShowInfo,TInt aIndex, TInt aSizeDownloaded) +{ + FormatShowInfoListBoxItemL(*aShowInfo, aSizeDownloaded); + iItemArray->Delete(aIndex); + if(aIndex>= iItemArray->MdcaCount()) + { + iItemArray->AppendL(iListboxFormatbuffer); + } + else + { + iItemArray->InsertL(aIndex, iListboxFormatbuffer); + } +} + +void CPodcastShowsView::UpdateShowItemL(TUint aUid, TInt aSizeDownloaded) +{ + RShowInfoArray& array = iPodcastModel.ActiveShowList(); + + for (int i=0;iUid() == aUid) { + UpdateShowItemDataL(array[i], i, aSizeDownloaded); + if (iListContainer->Listbox()->TopItemIndex() <= i && + iListContainer->Listbox()->BottomItemIndex() >= i) { + iListContainer->Listbox()->DrawItem(i); + } + } + } +} + +void CPodcastShowsView::UpdateListboxItemsL() + { + if (iListContainer->IsVisible()) + { + TListItemProperties itemProps; + TInt len = 0; + + iPodcastModel.GetShowsByFeed(iPodcastModel.ActiveFeedInfo()->Uid()); + + RShowInfoArray &fItems = iPodcastModel.ActiveShowList(); + len = fItems.Count(); + + if (iListContainer->Listbox() != NULL) + { + TBool allUidsMatch = EFalse; + + if (len == iListContainer->Listbox()->Model()->NumberOfItems()) + { + allUidsMatch = ETrue; + TUint itemId = 0; + for (TInt loop = 0; loop< len; loop++) + { + itemId = iItemIdArray[loop]; + if (fItems[loop]->Uid() != itemId) + { + allUidsMatch = EFalse; + break; + } + } + } + + if (allUidsMatch && len > 0) + { + for (TInt loop = 0; loop< len; loop++) + { + UpdateShowItemDataL(fItems[loop], loop); + } + } + else + { + iListContainer->Listbox()->ItemDrawer()->ClearAllPropertiesL(); + iListContainer->Listbox()->Reset(); + iItemIdArray.Reset(); + iItemArray->Reset(); + + if (len > 0) + { + for (TInt i=0; iUid()); + iItemArray->AppendL(iListboxFormatbuffer); + } + } + else + { + iItemArray->Reset(); + iItemIdArray.Reset(); + + itemProps.SetDimmed(ETrue); + itemProps.SetHiddenSelection(ETrue); + } + iListContainer->Listbox()->HandleItemAdditionL(); + } + } + } + } + +/** + * Command handling function intended for overriding by sub classes. + * Default implementation is empty. + * @param aCommand ID of the command to respond to. + */ +void CPodcastShowsView::HandleCommandL(TInt aCommand) + { + switch (aCommand) + { + case EPodcastMarkAsPlayed: + SetShowPlayed(ETrue); + break; + case EPodcastMarkAsUnplayed: + SetShowPlayed(EFalse); + break; + case EPodcastMarkAllPlayed: + iPodcastModel.MarkSelectionPlayed(); + UpdateListboxItemsL(); + break; + case EPodcastDeleteShow: + DeleteShow(); + break; + case EPodcastDownloadShow: + { + TInt index = iListContainer->Listbox()->CurrentItemIndex(); + if (index >= 0 && index < iPodcastModel.ActiveShowList().Count()) + { + iPodcastModel.ShowEngine().AddDownloadL(*iPodcastModel.ActiveShowList()[index]); + UpdateShowItemL(iPodcastModel.ActiveShowList()[index]->Uid(),-1); + } + } + break; + case EPodcastUpdateFeed: + { + + if (iPodcastModel.ActiveFeedInfo()->Url().Length()>0) + { + TRAPD(error, iPodcastModel.FeedEngine().UpdateFeedL(iPodcastModel.ActiveFeedInfo()->Uid())); + + if (error != KErrNone) + { + HBufC + * str = + iEikonEnv->AllocReadResourceLC(R_PODCAST_FEEDS_UPDATE_ERROR); + User::InfoPrint(*str); + CleanupStack::PopAndDestroy(str); + } + } + } + break; + case EPodcastCancelUpdateAllFeeds: + iPodcastModel.FeedEngine().CancelUpdateAllFeeds(); + break; + case EPodcastShowInfo: + { + DisplayShowInfoDialogL(); + }break; + default: + CPodcastListView::HandleCommandL(aCommand); + break; + } + UpdateToolbar(); + } + +void CPodcastShowsView::DynInitMenuPaneL(TInt aResourceId,CEikMenuPane* aMenuPane) +{ + if(aResourceId == R_PODCAST_SHOWSVIEW_MENU) + { + TBool updatingState = iPodcastModel.FeedEngine().ClientState() != EIdle && iPodcastModel.FeedEngine().ActiveClientUid() == iPodcastModel.ActiveFeedInfo()->Uid(); + aMenuPane->SetItemDimmed(EPodcastMarkAllPlayed, updatingState); + } +} + +void CPodcastShowsView::ImageOperationCompleteL(TInt aError) + { + iLastImageHandlerError = aError; + if(iSetTitlebarImage) + { + iSetTitlebarImage = EFalse; + if(aError == KErrNone) + { + CAknTitlePane* titlePane = static_cast + ( StatusPane()->ControlL( TUid::Uid( EEikStatusPaneUidTitle ) ) ); + titlePane->SetSmallPicture(iPodcastModel.ImageHandler().ScaledBitmap(), NULL, ETrue); + } + else + { + iPodcastModel.ImageHandler().ScaledBitmap(); + } + + } + else + { + CActiveScheduler::Stop(); + } + } + +void CPodcastShowsView::DisplayShowInfoDialogL() + { + TInt index = iListContainer->Listbox()->CurrentItemIndex(); + if (index >= 0 && index < iPodcastModel.ActiveShowList().Count()) + { + CShowInfo* info = iPodcastModel.ActiveShowList()[index]; + TUint32 feedUid = info->FeedUid(); + CFeedInfo* feedInfo = iPodcastModel.FeedEngine().GetFeedInfoByUid(feedUid); + + CPodcastImageMessageQueryDialog* note = new ( ELeave ) CPodcastImageMessageQueryDialog( (TDesC*)&info->Description(), (TDesC*)&info->Title() ); + + note->PrepareLC( R_SHOW_INFO_NOTE ); // Adds to CleanupStack + + if(feedInfo && feedInfo->ImageFileName().Length()>0) + { + CFbsBitmap * bitmap = new (ELeave) CFbsBitmap; + CleanupStack::PushL(bitmap); + + TRAPD(loaderror, iPodcastModel.ImageHandler().LoadFileAndScaleL(bitmap, feedInfo->ImageFileName(), TSize(KPodcastImageWidth, KPodcastImageHeight), *this)); + + if(loaderror == KErrNone) + { + CActiveScheduler::Start(); + if(iLastImageHandlerError == KErrNone) + { + CEikImage* image = static_cast(note->ControlOrNull(EPodcastShowInfoImage)); + image->SetBitmap(bitmap); + CleanupStack::Pop(bitmap); + bitmap = NULL; + } + else + { + CleanupStack::PopAndDestroy(bitmap); + bitmap = NULL; + } + } + else + { + CleanupStack::PopAndDestroy(bitmap); + bitmap = NULL; + } + } + + note->RunLD(); + } + } + +void CPodcastShowsView::UpdateToolbar() +{ + CAknToolbar* toolbar = Toolbar(); + + RShowInfoArray &fItems = iPodcastModel.ActiveShowList(); + TInt itemCnt = fItems.Count(); + + TBool hideDownloadShowCmd = EFalse; + TBool dimDownloadShowCmd = EFalse; + TBool hideSetPlayed = EFalse; + TBool updatingState = iPodcastModel.FeedEngine().ClientState() != EIdle && + iPodcastModel.FeedEngine().ActiveClientUid() == iPodcastModel.ActiveFeedInfo()->Uid(); + + if(iListContainer->Listbox() != NULL) + { + TInt index = iListContainer->Listbox()->CurrentItemIndex(); + + if(index>= 0 && index < itemCnt) + { + switch(fItems[index]->DownloadState()) + { + case ENotDownloaded: + case EFailedDownload: + hideDownloadShowCmd = EFalse; + dimDownloadShowCmd = EFalse; + break; + case EQueued: + case EDownloading: + hideDownloadShowCmd = EFalse; + dimDownloadShowCmd = ETrue; + break; + case EDownloaded: + hideDownloadShowCmd = ETrue; + break; + } + + if(fItems[index]->PlayState() == EPlayed) { + hideSetPlayed = ETrue; + } + } + } + + toolbar->HideItem(EPodcastUpdateFeed, updatingState, ETrue ); + toolbar->HideItem(EPodcastCancelUpdateAllFeeds, !updatingState, ETrue ); + + if (hideDownloadShowCmd) { + toolbar->HideItem(EPodcastDownloadShow, ETrue, ETrue ); + toolbar->HideItem(EPodcastDeleteShow, EFalse, ETrue); + toolbar->SetItemDimmed(EPodcastDeleteShow, updatingState, ETrue); + } else { + toolbar->HideItem(EPodcastDownloadShow, EFalse, ETrue ); + toolbar->HideItem(EPodcastDeleteShow, ETrue, ETrue); + toolbar->SetItemDimmed(EPodcastDownloadShow, updatingState || dimDownloadShowCmd, ETrue); + } + + if (hideSetPlayed) { + toolbar->HideItem(EPodcastMarkAsPlayed, ETrue, ETrue ); + toolbar->HideItem(EPodcastMarkAsUnplayed, EFalse, ETrue ); + toolbar->SetItemDimmed(EPodcastMarkAsUnplayed, updatingState, ETrue); + } else { + toolbar->HideItem(EPodcastMarkAsPlayed, EFalse, ETrue ); + toolbar->HideItem(EPodcastMarkAsUnplayed, ETrue, ETrue ); + toolbar->SetItemDimmed(EPodcastMarkAsPlayed, updatingState, ETrue); + } +} + +void CPodcastShowsView::HandleLongTapEventL( const TPoint& aPenEventLocation, const TPoint& /* aPenEventScreenLocation */) +{ + DP("CPodcastShowsView::HandleLongTapEventL BEGIN"); + + if(iStylusPopupMenu) + { + TInt index = iListContainer->Listbox()->CurrentItemIndex(); + if (index >= 0 && index < iPodcastModel.ActiveShowList().Count()) + { + CShowInfo *info = iPodcastModel.ActiveShowList()[index]; + TBool hideDownloadShowCmd = info->DownloadState() != ENotDownloaded; + TBool hideDeleteShowCmd = info->DownloadState() != EDownloaded; + TBool hideMarkOld = info->PlayState() == EPlayed; + + iStylusPopupMenu->SetItemDimmed(EPodcastMarkAsPlayed, hideMarkOld); + iStylusPopupMenu->SetItemDimmed(EPodcastMarkAsUnplayed, !hideMarkOld); + + iStylusPopupMenu->SetItemDimmed(EPodcastDownloadShow, hideDownloadShowCmd); + iStylusPopupMenu->SetItemDimmed(EPodcastDeleteShow, hideDeleteShowCmd); + } + + iStylusPopupMenu->ShowMenu(); + iStylusPopupMenu->SetPosition(aPenEventLocation); + } + DP("CPodcastShowsView::HandleLongTapEventL END"); +} + +void CPodcastShowsView::SetShowPlayed(TBool aPlayed) + { + + TInt index = iListContainer->Listbox()->CurrentItemIndex(); + + if (index >= 0 && index < iPodcastModel.ActiveShowList().Count()) + { + CShowInfo *info = iPodcastModel.ActiveShowList()[index]; + info->SetPlayState(aPlayed ? EPlayed : ENeverPlayed); + iPodcastModel.ShowEngine().UpdateShow(*info); + UpdateShowItemDataL(iPodcastModel.ActiveShowList()[index], index, 0); + iListContainer->Listbox()->DrawItem(index); + } + } + +void CPodcastShowsView::DeleteShow() + { + TInt index = iListContainer->Listbox()->CurrentItemIndex(); + + if (index >= 0 && index < iPodcastModel.ActiveShowList().Count()) + { + CShowInfo *info = iPodcastModel.ActiveShowList()[index]; + TBuf msg; + TBuf templ; + iEikonEnv->ReadResourceL(templ, R_PODCAST_DELETE_SHOW_PROMPT); + msg.Format(templ, &(info->Title())); + if (ShowQueryMessage(msg)) + { + iPodcastModel.ShowEngine().DeleteShowL(iPodcastModel.ActiveShowList()[index]->Uid()); + + // and mark as played, and not downloaded + + info->SetDownloadState(ENotDownloaded); + info->SetPlayState(EPlayed); + iPodcastModel.ShowEngine().UpdateShow(*info); + + UpdateShowItemDataL(iPodcastModel.ActiveShowList()[index], index, 0); + iListContainer->Listbox()->DrawItem(index); + } + } + } + +void CPodcastShowsView::DownloadQueueUpdatedL(TInt /*aDownloadingShows*/, TInt /*aQueuedShows*/) + { + //((CPodcastAppUi*)AppUi())->UpdateQueueTab(aDownloadingShows+aQueuedShows); + } + +void CPodcastShowsView::FeedUpdateAllCompleteL(TFeedState /*aState*/) + { + UpdateListboxItemsL(); + UpdateToolbar(); + } + +void CPodcastShowsView::UpdateViewTitleL() + { + DP("CPodcastShowsView::UpdateViewTitleL BEGIN"); + CAknTitlePane* titlePane = static_cast + ( StatusPane()->ControlL( TUid::Uid( EEikStatusPaneUidTitle ) ) ); + + TBool updatingState = iPodcastModel.FeedEngine().ClientState() != EIdle && + iPodcastModel.FeedEngine().ActiveClientUid() == iPodcastModel.ActiveFeedInfo()->Uid(); + + if (updatingState) { + SetEmptyTextL(R_PODCAST_EMPTY_LIST_UPDATING); + } else { + SetEmptyTextL(R_PODCAST_EMPTY_LIST); + } + + if(iPodcastModel.ActiveFeedInfo()) + { + if (iPodcastModel.ActiveFeedInfo()->Title() != KNullDesC) + { + titlePane->SetTextL( iPodcastModel.ActiveFeedInfo()->Title(), ETrue ); + } + } + else + { + titlePane->SetPicture(NULL, NULL); + titlePane->SetTextToDefaultL(); + } + + DP("CPodcastShowsView::UpdateViewTitleL END"); + } diff -r 5f8e5adbbed9 -r 29cda98b007e engine/BWINS/podcastengineu.def --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/BWINS/podcastengineu.def Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,173 @@ +EXPORTS + ??0CShowInfo@@QAE@PAV0@@Z @ 1 NONAME ; CShowInfo::CShowInfo(class CShowInfo *) + ??1CFeedInfo@@UAE@XZ @ 2 NONAME ; CFeedInfo::~CFeedInfo(void) + ??1CPodcastModel@@UAE@XZ @ 3 NONAME ; CPodcastModel::~CPodcastModel(void) + ??1CShowInfo@@UAE@XZ @ 4 NONAME ; CShowInfo::~CShowInfo(void) + ?ActiveClientUid@CFeedEngine@@QAEIXZ @ 5 NONAME ; unsigned int CFeedEngine::ActiveClientUid(void) + ?ActiveFeedInfo@CPodcastModel@@QAEPAVCFeedInfo@@XZ @ 6 NONAME ; class CFeedInfo * CPodcastModel::ActiveFeedInfo(void) + ?ActiveShowList@CPodcastModel@@QAEAAV?$RPointerArray@VCShowInfo@@@@XZ @ 7 NONAME ; class RPointerArray & CPodcastModel::ActiveShowList(void) + ?AddObserver@CFeedEngine@@QAEXPAVMFeedEngineObserver@@@Z @ 8 NONAME ; void CFeedEngine::AddObserver(class MFeedEngineObserver *) + ?AddObserver@CShowEngine@@QAEXPAVMShowEngineObserver@@@Z @ 9 NONAME ; void CShowEngine::AddObserver(class MShowEngineObserver *) + ?AddObserver@CSoundEngine@@QAEXPAVMSoundEngineObserver@@@Z @ 10 NONAME ; void CSoundEngine::AddObserver(class MSoundEngineObserver *) + ?BaseDir@CSettingsEngine@@QAEAAV?$TBuf@$0BAA@@@XZ @ 11 NONAME ; class TBuf<256> & CSettingsEngine::BaseDir(void) + ?ClientState@CFeedEngine@@QAE?AW4TClientState@@XZ @ 12 NONAME ; enum TClientState CFeedEngine::ClientState(void) + ?DeleteAllShowsByFeedL@CShowEngine@@QAEXIH@Z @ 13 NONAME ; void CShowEngine::DeleteAllShowsByFeedL(unsigned int, int) + ?DeletePlayedShows@CShowEngine@@QAEXAAV?$RPointerArray@VCShowInfo@@@@@Z @ 14 NONAME ; void CShowEngine::DeletePlayedShows(class RPointerArray &) + ?DeleteShowL@CShowEngine@@QAEXIH@Z @ 15 NONAME ; void CShowEngine::DeleteShowL(unsigned int, int) + ?Description@CFeedInfo@@QBEABVTDesC16@@XZ @ 16 NONAME ; class TDesC16 const & CFeedInfo::Description(void) const + ?Description@CShowInfo@@QBEABVTDesC16@@XZ @ 17 NONAME ; class TDesC16 const & CShowInfo::Description(void) const + ?DownloadAutomatically@CSettingsEngine@@QAEHXZ @ 18 NONAME ; int CSettingsEngine::DownloadAutomatically(void) + ?ExportFeedsL@CFeedEngine@@QAEHAAV?$TBuf@$0BAA@@@@Z @ 19 NONAME ; int CFeedEngine::ExportFeedsL(class TBuf<256> &) + ?FeedEngine@CPodcastModel@@QAEAAVCFeedEngine@@XZ @ 20 NONAME ; class CFeedEngine & CPodcastModel::FeedEngine(void) + ?FileName@CShowInfo@@QBEABVTDesC16@@XZ @ 21 NONAME ; class TDesC16 const & CShowInfo::FileName(void) const + ?FixProtocolsL@PodcastUtils@@SAXAAVTDes16@@@Z @ 22 NONAME ; void PodcastUtils::FixProtocolsL(class TDes16 &) + ?GetAllShows@CPodcastModel@@QAEXXZ @ 23 NONAME ; void CPodcastModel::GetAllShows(void) + ?GetDownloadedStats@CFeedEngine@@QAEXAAI0@Z @ 24 NONAME ; void CFeedEngine::GetDownloadedStats(unsigned int &, unsigned int &) + ?GetFeedInfoByUid@CFeedEngine@@QAEPAVCFeedInfo@@I@Z @ 25 NONAME ; class CFeedInfo * CFeedEngine::GetFeedInfoByUid(unsigned int) + ?GetMimeType@CShowEngine@@QAEXABVTDesC16@@AAVTDes16@@@Z @ 26 NONAME ; void CShowEngine::GetMimeType(class TDesC16 const &, class TDes16 &) + ?GetNewShows@CPodcastModel@@QAEXXZ @ 27 NONAME ; void CPodcastModel::GetNewShows(void) + ?GetShowByUidL@CShowEngine@@QAEPAVCShowInfo@@I@Z @ 28 NONAME ; class CShowInfo * CShowEngine::GetShowByUidL(unsigned int) + ?GetShowsByFeed@CPodcastModel@@QAEXI@Z @ 29 NONAME ; void CPodcastModel::GetShowsByFeed(unsigned int) + ?GetShowsDownloaded@CPodcastModel@@QAEXXZ @ 30 NONAME ; void CPodcastModel::GetShowsDownloaded(void) + ?GetShowsDownloading@CPodcastModel@@QAEXXZ @ 31 NONAME ; void CPodcastModel::GetShowsDownloading(void) + ?GetSortedFeeds@CFeedEngine@@QAEABV?$RPointerArray@VCFeedInfo@@@@XZ @ 32 NONAME ; class RPointerArray const & CFeedEngine::GetSortedFeeds(void) + ?IAPIds@CPodcastModel@@QAEAAV?$RArray@VTPodcastIAPItem@@@@XZ @ 33 NONAME ; class RArray & CPodcastModel::IAPIds(void) + ?IAPNames@CPodcastModel@@QAEPAVCDesC16ArrayFlat@@XZ @ 34 NONAME ; class CDesC16ArrayFlat * CPodcastModel::IAPNames(void) + ?ImageFileName@CFeedInfo@@QBEABVTDesC16@@XZ @ 35 NONAME ; class TDesC16 const & CFeedInfo::ImageFileName(void) const + ?ImageUrl@CFeedInfo@@QBEABVTDesC16@@XZ @ 36 NONAME ; class TDesC16 const & CFeedInfo::ImageUrl(void) const + ?ImportFeedsL@CFeedEngine@@QAEXABVTDesC16@@@Z @ 37 NONAME ; void CFeedEngine::ImportFeedsL(class TDesC16 const &) + ?Link@CFeedInfo@@QBEABVTDesC16@@XZ @ 38 NONAME ; class TDesC16 const & CFeedInfo::Link(void) const + ?MarkSelectionPlayed@CPodcastModel@@QAEXXZ @ 39 NONAME ; void CPodcastModel::MarkSelectionPlayed(void) + ?NewL@CFeedInfo@@SAPAV1@XZ @ 40 NONAME ; class CFeedInfo * CFeedInfo::NewL(void) + ?NewL@CPodcastModel@@SAPAV1@XZ @ 41 NONAME ; class CPodcastModel * CPodcastModel::NewL(void) + ?NewL@CShowInfo@@SAPAV1@I@Z @ 42 NONAME ; class CShowInfo * CShowInfo::NewL(unsigned int) + ?NewLC@CFeedInfo@@SAPAV1@XZ @ 43 NONAME ; class CFeedInfo * CFeedInfo::NewLC(void) + ?Pause@CSoundEngine@@QAEXH@Z @ 44 NONAME ; void CSoundEngine::Pause(int) + ?Play@CSoundEngine@@QAEXXZ @ 45 NONAME ; void CSoundEngine::Play(void) + ?PlayPausePodcastL@CPodcastModel@@QAEXPAVCShowInfo@@H@Z @ 46 NONAME ; void CPodcastModel::PlayPausePodcastL(class CShowInfo *, int) + ?PlayTime@CShowInfo@@QBEIXZ @ 47 NONAME ; unsigned int CShowInfo::PlayTime(void) const + ?PlayingPodcast@CPodcastModel@@QAEPAVCShowInfo@@XZ @ 48 NONAME ; class CShowInfo * CPodcastModel::PlayingPodcast(void) + ?Position@CShowInfo@@QBE?AVTTimeIntervalMicroSeconds@@XZ @ 49 NONAME ; class TTimeIntervalMicroSeconds CShowInfo::Position(void) const + ?Position@CSoundEngine@@QAE?AVTTimeIntervalMicroSeconds@@XZ @ 50 NONAME ; class TTimeIntervalMicroSeconds CSoundEngine::Position(void) + ?PubDate@CShowInfo@@QBE?BVTTime@@XZ @ 51 NONAME ; class TTime const CShowInfo::PubDate(void) const + ?RemoveAllDownloads@CShowEngine@@QAEXXZ @ 52 NONAME ; void CShowEngine::RemoveAllDownloads(void) + ?RemoveDownloadL@CShowEngine@@QAEHI@Z @ 53 NONAME ; int CShowEngine::RemoveDownloadL(unsigned int) + ?RemoveObserver@CFeedEngine@@QAEXPAVMFeedEngineObserver@@@Z @ 54 NONAME ; void CFeedEngine::RemoveObserver(class MFeedEngineObserver *) + ?RemoveObserver@CShowEngine@@QAEXPAVMShowEngineObserver@@@Z @ 55 NONAME ; void CShowEngine::RemoveObserver(class MShowEngineObserver *) + ?ResumeDownloadsL@CShowEngine@@QAEXXZ @ 56 NONAME ; void CShowEngine::ResumeDownloadsL(void) + ?SaveSettingsL@CSettingsEngine@@QAEXXZ @ 57 NONAME ; void CSettingsEngine::SaveSettingsL(void) + ?SetActiveFeedInfo@CPodcastModel@@QAEXPAVCFeedInfo@@@Z @ 58 NONAME ; void CPodcastModel::SetActiveFeedInfo(class CFeedInfo *) + ?SetBaseDir@CSettingsEngine@@QAEXAAV?$TBuf@$0BAA@@@@Z @ 59 NONAME ; void CSettingsEngine::SetBaseDir(class TBuf<256> &) + ?SetBuildDate@CFeedInfo@@QAEXVTTime@@@Z @ 60 NONAME ; void CFeedInfo::SetBuildDate(class TTime) + ?SetCustomTitle@CFeedInfo@@QAEXXZ @ 61 NONAME ; void CFeedInfo::SetCustomTitle(void) + ?SetDescriptionL@CFeedInfo@@QAEXABVTDesC16@@@Z @ 62 NONAME ; void CFeedInfo::SetDescriptionL(class TDesC16 const &) + ?SetDescriptionL@CShowInfo@@QAEXABVTDesC16@@@Z @ 63 NONAME ; void CShowInfo::SetDescriptionL(class TDesC16 const &) + ?SetDownloadAutomatically@CSettingsEngine@@QAEXH@Z @ 64 NONAME ; void CSettingsEngine::SetDownloadAutomatically(int) + ?SetDownloadState@CShowInfo@@QAEXW4TDownloadState@@@Z @ 65 NONAME ; void CShowInfo::SetDownloadState(enum TDownloadState) + ?SetFeedUid@CShowInfo@@QAEXI@Z @ 66 NONAME ; void CShowInfo::SetFeedUid(unsigned int) + ?SetFileNameL@CShowInfo@@QAEXABVTDesC16@@@Z @ 67 NONAME ; void CShowInfo::SetFileNameL(class TDesC16 const &) + ?SetImageFileNameL@CFeedInfo@@QAEXABVTDesC16@@@Z @ 68 NONAME ; void CFeedInfo::SetImageFileNameL(class TDesC16 const &) + ?SetImageUrlL@CFeedInfo@@QAEXABVTDesC16@@@Z @ 69 NONAME ; void CFeedInfo::SetImageUrlL(class TDesC16 const &) + ?SetLastUpdated@CFeedInfo@@QAEXVTTime@@@Z @ 70 NONAME ; void CFeedInfo::SetLastUpdated(class TTime) + ?SetLinkL@CFeedInfo@@QAEXABVTDesC16@@@Z @ 71 NONAME ; void CFeedInfo::SetLinkL(class TDesC16 const &) + ?SetPlayState@CShowInfo@@QAEXW4TPlayState@@@Z @ 72 NONAME ; void CShowInfo::SetPlayState(enum TPlayState) + ?SetPlayTime@CShowInfo@@QAEXI@Z @ 73 NONAME ; void CShowInfo::SetPlayTime(unsigned int) + ?SetPlayingPodcast@CPodcastModel@@QAEXPAVCShowInfo@@@Z @ 74 NONAME ; void CPodcastModel::SetPlayingPodcast(class CShowInfo *) + ?SetPosition@CShowInfo@@QAEXVTTimeIntervalMicroSeconds@@@Z @ 75 NONAME ; void CShowInfo::SetPosition(class TTimeIntervalMicroSeconds) + ?SetPosition@CSoundEngine@@QAEXI@Z @ 76 NONAME ; void CSoundEngine::SetPosition(unsigned int) + ?SetPubDate@CShowInfo@@QAEXVTTime@@@Z @ 77 NONAME ; void CShowInfo::SetPubDate(class TTime) + ?SetShowSize@CShowInfo@@QAEXI@Z @ 78 NONAME ; void CShowInfo::SetShowSize(unsigned int) + ?SetShowType@CShowInfo@@QAEXW4TShowType@@@Z @ 79 NONAME ; void CShowInfo::SetShowType(enum TShowType) + ?SetSpecificIAP@CSettingsEngine@@QAEXH@Z @ 80 NONAME ; void CSettingsEngine::SetSpecificIAP(int) + ?SetTitleL@CFeedInfo@@QAEXABVTDesC16@@@Z @ 81 NONAME ; void CFeedInfo::SetTitleL(class TDesC16 const &) + ?SetTitleL@CShowInfo@@QAEXABVTDesC16@@@Z @ 82 NONAME ; void CShowInfo::SetTitleL(class TDesC16 const &) + ?SetTrackNo@CShowInfo@@QAEXI@Z @ 83 NONAME ; void CShowInfo::SetTrackNo(unsigned int) + ?SetUid@CShowInfo@@QAEXI@Z @ 84 NONAME ; void CShowInfo::SetUid(unsigned int) + ?SetUpdateAutomatically@CSettingsEngine@@QAEXW4TAutoUpdateSetting@@@Z @ 85 NONAME ; void CSettingsEngine::SetUpdateAutomatically(enum TAutoUpdateSetting) + ?SetUpdateFeedInterval@CSettingsEngine@@QAEXH@Z @ 86 NONAME ; void CSettingsEngine::SetUpdateFeedInterval(int) + ?SetUpdateFeedTime@CSettingsEngine@@QAEXVTTime@@@Z @ 87 NONAME ; void CSettingsEngine::SetUpdateFeedTime(class TTime) + ?SetUrlL@CFeedInfo@@QAEXABVTDesC16@@@Z @ 88 NONAME ; void CFeedInfo::SetUrlL(class TDesC16 const &) + ?SetUrlL@CShowInfo@@QAEXABVTDesC16@@@Z @ 89 NONAME ; void CShowInfo::SetUrlL(class TDesC16 const &) + ?SettingsEngine@CPodcastModel@@QAEAAVCSettingsEngine@@XZ @ 90 NONAME ; class CSettingsEngine & CPodcastModel::SettingsEngine(void) + ?ShowDownloading@CShowEngine@@QAEPAVCShowInfo@@XZ @ 91 NONAME ; class CShowInfo * CShowEngine::ShowDownloading(void) + ?ShowEngine@CPodcastModel@@QAEAAVCShowEngine@@XZ @ 92 NONAME ; class CShowEngine & CPodcastModel::ShowEngine(void) + ?SoundEngine@CPodcastModel@@QAEAAVCSoundEngine@@XZ @ 93 NONAME ; class CSoundEngine & CPodcastModel::SoundEngine(void) + ?SpecificIAP@CSettingsEngine@@QAEHXZ @ 94 NONAME ; int CSettingsEngine::SpecificIAP(void) + ?State@CSoundEngine@@QAE?AW4TSoundEngineState@@XZ @ 95 NONAME ; enum TSoundEngineState CSoundEngine::State(void) + ?Stop@CSoundEngine@@QAEXH@Z @ 96 NONAME ; void CSoundEngine::Stop(int) + ?Title@CFeedInfo@@QBEABVTDesC16@@XZ @ 97 NONAME ; class TDesC16 const & CFeedInfo::Title(void) const + ?Title@CShowInfo@@QBEABVTDesC16@@XZ @ 98 NONAME ; class TDesC16 const & CShowInfo::Title(void) const + ?TrackNo@CShowInfo@@QBEIXZ @ 99 NONAME ; unsigned int CShowInfo::TrackNo(void) const + ?Uid@CShowInfo@@QBEIXZ @ 100 NONAME ; unsigned int CShowInfo::Uid(void) const + ?SNAPNames@CPodcastModel@@QAEPAVCDesC16ArrayFlat@@XZ @ 101 NONAME ; class CDesC16ArrayFlat * CPodcastModel::SNAPNames(void) + ?UpdateAutomatically@CSettingsEngine@@QAE?AW4TAutoUpdateSetting@@XZ @ 102 NONAME ; enum TAutoUpdateSetting CSettingsEngine::UpdateAutomatically(void) + ?UpdateFeed@CFeedEngine@@QAEXPAVCFeedInfo@@@Z @ 103 NONAME ; void CFeedEngine::UpdateFeed(class CFeedInfo *) + ?UpdateFeedInterval@CSettingsEngine@@QAEHXZ @ 104 NONAME ; int CSettingsEngine::UpdateFeedInterval(void) + ?UpdateFeedL@CFeedEngine@@QAEHI@Z @ 105 NONAME ; int CFeedEngine::UpdateFeedL(unsigned int) + ?UpdateFeedTime@CSettingsEngine@@QAE?AVTTime@@XZ @ 106 NONAME ; class TTime CSettingsEngine::UpdateFeedTime(void) + ?AddDownloadL@CShowEngine@@QAEXAAVCShowInfo@@@Z @ 107 NONAME ; void CShowEngine::AddDownloadL(class CShowInfo &) + ?Url@CFeedInfo@@QBEABVTDesC16@@XZ @ 108 NONAME ; class TDesC16 const & CFeedInfo::Url(void) const + ?Url@CShowInfo@@QBEABVTDesC16@@XZ @ 109 NONAME ; class TDesC16 const & CShowInfo::Url(void) const + ?RemoveFeedL@CFeedEngine@@QAEXI@Z @ 110 NONAME ; void CFeedEngine::RemoveFeedL(unsigned int) + ??1CShowEngine@@UAE@XZ @ 111 NONAME ; CShowEngine::~CShowEngine(void) + ?DBGetShowByFileNameL@CShowEngine@@QAEPAVCShowInfo@@V?$TBuf@$0BAA@@@@Z @ 112 NONAME ; class CShowInfo * CShowEngine::DBGetShowByFileNameL(class TBuf<256>) + ?DeleteOldShowsByFeed@CShowEngine@@QAEXI@Z @ 113 NONAME ; void CShowEngine::DeleteOldShowsByFeed(unsigned int) + ?GetAllShowsL@CShowEngine@@QAEXAAV?$RPointerArray@VCShowInfo@@@@@Z @ 114 NONAME ; void CShowEngine::GetAllShowsL(class RPointerArray &) + ?GetNewShowsL@CShowEngine@@QAEXAAV?$RPointerArray@VCShowInfo@@@@@Z @ 115 NONAME ; void CShowEngine::GetNewShowsL(class RPointerArray &) + ?GetNextShowByTrackL@CShowEngine@@QAEPAVCShowInfo@@PAV2@@Z @ 116 NONAME ; class CShowInfo * CShowEngine::GetNextShowByTrackL(class CShowInfo *) + ?GetNumDownloadingShows@CShowEngine@@QAEHXZ @ 117 NONAME ; int CShowEngine::GetNumDownloadingShows(void) + ?GetShowsByFeedL@CShowEngine@@QAEXAAV?$RPointerArray@VCShowInfo@@@@I@Z @ 118 NONAME ; void CShowEngine::GetShowsByFeedL(class RPointerArray &, unsigned int) + ?GetShowsDownloadedL@CShowEngine@@QAEXAAV?$RPointerArray@VCShowInfo@@@@@Z @ 119 NONAME ; void CShowEngine::GetShowsDownloadedL(class RPointerArray &) + ?GetShowsDownloadingL@CShowEngine@@QAEXAAV?$RPointerArray@VCShowInfo@@@@@Z @ 120 NONAME ; void CShowEngine::GetShowsDownloadingL(class RPointerArray &) + ?MetaDataReader@CShowEngine@@QAEAAVCMetaDataReader@@XZ @ 121 NONAME ; class CMetaDataReader & CShowEngine::MetaDataReader(void) + ?NewL@CShowEngine@@SAPAV1@AAVCPodcastModel@@@Z @ 122 NONAME ; class CShowEngine * CShowEngine::NewL(class CPodcastModel &) + ?NewLC@CShowInfo@@SAPAV1@I@Z @ 123 NONAME ; class CShowInfo * CShowInfo::NewLC(unsigned int) + ?NotifyShowListUpdatedL@CShowEngine@@QAEXXZ @ 124 NONAME ; void CShowEngine::NotifyShowListUpdatedL(void) + ?CancelUpdateAllFeeds@CFeedEngine@@QAEXXZ @ 125 NONAME ; void CFeedEngine::CancelUpdateAllFeeds(void) + ?ConnectionEngine@CPodcastModel@@QAEAAVCConnectionEngine@@XZ @ 126 NONAME ; class CConnectionEngine & CPodcastModel::ConnectionEngine(void) + ?SetLastError@CFeedInfo@@QAEXH@Z @ 127 NONAME ; void CFeedInfo::SetLastError(int) + ?SetLastError@CShowInfo@@QAEXH@Z @ 128 NONAME ; void CShowInfo::SetLastError(int) + ?LastError@CFeedInfo@@QBEHXZ @ 129 NONAME ; int CFeedInfo::LastError(void) const + ?LastError@CShowInfo@@QBEHXZ @ 130 NONAME ; int CShowInfo::LastError(void) const + ?AddSearchResultL@CFeedEngine@@QAEXPAVCFeedInfo@@@Z @ 131 NONAME ; void CFeedEngine::AddSearchResultL(class CFeedInfo *) + ?GetSearchResults@CFeedEngine@@QAEABV?$RPointerArray@VCFeedInfo@@@@XZ @ 132 NONAME ; class RPointerArray const & CFeedEngine::GetSearchResults(void) + ?GetStatsByFeed@CFeedEngine@@QAEXIAAI0@Z @ 133 NONAME ; void CFeedEngine::GetStatsByFeed(unsigned int, unsigned int &, unsigned int &) + ?SearchForFeedL@CFeedEngine@@QAEXAAVTDesC16@@@Z @ 134 NONAME ; void CFeedEngine::SearchForFeedL(class TDesC16 &) + ?AddFeedL@CFeedEngine@@QAEHABVCFeedInfo@@@Z @ 135 NONAME ; int CFeedEngine::AddFeedL(class CFeedInfo const &) + ?BuildDate@CFeedInfo@@QBE?AVTTime@@XZ @ 136 NONAME ; class TTime CFeedInfo::BuildDate(void) const + ?CopyL@CFeedInfo@@QBEPAV1@XZ @ 137 NONAME ; class CFeedInfo * CFeedInfo::CopyL(void) const + ?CustomTitle@CFeedInfo@@QBEHXZ @ 138 NONAME ; int CFeedInfo::CustomTitle(void) const + ?LastUpdated@CFeedInfo@@QBE?AVTTime@@XZ @ 139 NONAME ; class TTime CFeedInfo::LastUpdated(void) const + ?Uid@CFeedInfo@@QBEIXZ @ 140 NONAME ; unsigned int CFeedInfo::Uid(void) const + ?AddShowL@CShowEngine@@QAEHABVCShowInfo@@@Z @ 141 NONAME ; int CShowEngine::AddShowL(class CShowInfo const &) + ?DownloadState@CShowInfo@@QBE?AW4TDownloadState@@XZ @ 142 NONAME ; enum TDownloadState CShowInfo::DownloadState(void) const + ?FeedUid@CShowInfo@@QBEIXZ @ 143 NONAME ; unsigned int CShowInfo::FeedUid(void) const + ?PlayState@CShowInfo@@QBE?AW4TPlayState@@XZ @ 144 NONAME ; enum TPlayState CShowInfo::PlayState(void) const + ?ShowSize@CShowInfo@@QBEIXZ @ 145 NONAME ; unsigned int CShowInfo::ShowSize(void) const + ?ShowType@CShowInfo@@QBE?AW4TShowType@@XZ @ 146 NONAME ; enum TShowType CShowInfo::ShowType(void) const + ?UpdateShow@CShowEngine@@QAEXAAVCShowInfo@@@Z @ 147 NONAME ; void CShowEngine::UpdateShow(class CShowInfo &) + ?UpdateIAPListL@CPodcastModel@@QAEXXZ @ 148 NONAME ; void CPodcastModel::UpdateIAPListL(void) + ?UpdateSNAPListL@CPodcastModel@@QAEXXZ @ 149 NONAME ; void CPodcastModel::UpdateSNAPListL(void) + ?SNAPIds@CPodcastModel@@QAEAAV?$RArray@VTPodcastIAPItem@@@@XZ @ 150 NONAME ; class RArray & CPodcastModel::SNAPIds(void) + ?UpdateAllFeedsL@CFeedEngine@@QAEXH@Z @ 151 NONAME ; void CFeedEngine::UpdateAllFeedsL(int) + ?CleanHtmlL@PodcastUtils@@SAXAAVTDes16@@@Z @ 152 NONAME ; void PodcastUtils::CleanHtmlL(class TDes16 &) + ?DownloadSuspended@CSettingsEngine@@QAEHXZ @ 153 NONAME ; int CSettingsEngine::DownloadSuspended(void) + ?EnsureProperPathName@PodcastUtils@@SAXAAV?$TBuf@$0BAA@@@@Z @ 154 NONAME ; void PodcastUtils::EnsureProperPathName(class TBuf<256> &) + ?FileNameFromUrl@PodcastUtils@@SAXABVTDesC16@@AAV?$TBuf@$0BAA@@@@Z @ 155 NONAME ; void PodcastUtils::FileNameFromUrl(class TDesC16 const &, class TBuf<256> &) + ?IsFirstStartup@CPodcastModel@@QAEHXZ @ 156 NONAME ; int CPodcastModel::IsFirstStartup(void) + ?OpmlParsingComplete@CFeedEngine@@QAEXI@Z @ 157 NONAME ; void CFeedEngine::OpmlParsingComplete(unsigned int) + ?ReplaceChar@PodcastUtils@@SAXAAVTDes16@@II@Z @ 158 NONAME ; void PodcastUtils::ReplaceChar(class TDes16 &, unsigned int, unsigned int) + ?ReplaceString@PodcastUtils@@SAXAAVTDes16@@ABVTDesC16@@1@Z @ 159 NONAME ; void PodcastUtils::ReplaceString(class TDes16 &, class TDesC16 const &, class TDesC16 const &) + ?SQLEncode@PodcastUtils@@SAXAAVTDes16@@@Z @ 160 NONAME ; void PodcastUtils::SQLEncode(class TDes16 &) + ?SetDownloadSuspended@CSettingsEngine@@QAEXH@Z @ 161 NONAME ; void CSettingsEngine::SetDownloadSuspended(int) + ?SuspendDownloads@CShowEngine@@QAEXXZ @ 162 NONAME ; void CShowEngine::SuspendDownloads(void) + ?XMLEncode@PodcastUtils@@SAXAAVTDes16@@@Z @ 163 NONAME ; void PodcastUtils::XMLEncode(class TDes16 &) + ?FeedIcon@CFeedInfo@@QBEPAVCFbsBitmap@@XZ @ 164 NONAME ; class CFbsBitmap * CFeedInfo::FeedIcon(void) const + ?SetFeedIcon@CFeedInfo@@QAEXPAVCFbsBitmap@@@Z @ 165 NONAME ; void CFeedInfo::SetFeedIcon(class CFbsBitmap *) + ??1CImageHandler@@UAE@XZ @ 166 NONAME ; CImageHandler::~CImageHandler(void) + ?LoadFileAndScaleL@CImageHandler@@QAEXPAVCFbsBitmap@@ABV?$TBuf@$0BAA@@@ABVTSize@@AAVMImageHandlerCallback@@H@Z @ 167 NONAME ; void CImageHandler::LoadFileAndScaleL(class CFbsBitmap *, class TBuf<256> const &, class TSize const &, class MImageHandlerCallback &, int) + ?NewL@CImageHandler@@SAPAV1@AAVRFs@@@Z @ 168 NONAME ; class CImageHandler * CImageHandler::NewL(class RFs &) + ?NewLC@CImageHandler@@SAPAV1@AAVRFs@@@Z @ 169 NONAME ; class CImageHandler * CImageHandler::NewLC(class RFs &) + ?ScaledBitmap@CImageHandler@@QAEPAVCFbsBitmap@@XZ @ 170 NONAME ; class CFbsBitmap * CImageHandler::ScaledBitmap(void) + ?ImageHandler@CPodcastModel@@QAEAAVCImageHandler@@XZ @ 171 NONAME ; class CImageHandler & CPodcastModel::ImageHandler(void) + diff -r 5f8e5adbbed9 -r 29cda98b007e engine/config/defaultfeeds.xml --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/config/defaultfeeds.xml Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,14 @@ + + + + Default feed list + + + + + + + + + + \ No newline at end of file diff -r 5f8e5adbbed9 -r 29cda98b007e engine/config/podcatcher.sqlite Binary file engine/config/podcatcher.sqlite has changed diff -r 5f8e5adbbed9 -r 29cda98b007e engine/config/testfeeds.xml --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/config/testfeeds.xml Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,48 @@ + + + + Default feed list (Emulator) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + --> + + + \ No newline at end of file diff -r 5f8e5adbbed9 -r 29cda98b007e engine/group/engine.mmp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/group/engine.mmp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB + * + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of the License "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * EmbedDev AB - initial contribution. + * + * Contributors: + * + * Description: + * + */ + +#ifdef SQLITE_INCLUDED +// must build a .lib since sqlite uses "initialized writable data" +TARGET podcastengine.lib +TARGETTYPE LIB +#else +TARGET podcastengine.dll +TARGETTYPE DLL +UID 0x1000008d 0xA11F867F +#endif + +SOURCEPATH ..\src +USERINCLUDE ..\inc +SYSTEMINCLUDE \epoc32\include +SYSTEMINCLUDE \epoc32\include\mw // needed for S^3 + +// Engine +SOURCE HttpClient.cpp +SOURCE HttpEventHandler.cpp +SOURCE FeedParser.cpp +SOURCE FeedEngine.cpp +SOURCE ShowInfo.cpp +SOURCE SoundEngine.cpp +SOURCE FeedInfo.cpp +SOURCE FeedTimer.cpp +SOURCE ShowEngine.cpp +SOURCE SettingsEngine.cpp +SOURCE MetaDataReader.cpp +SOURCE OpmlParser.cpp +SOURCE PodcastUtils.cpp +SOURCE PodCastModel.cpp +SOURCE ImageHandler.cpp +SOURCE ConnectionEngine.cpp +CAPABILITY NetworkServices UserEnvironment + +#ifndef SQLITE_INCLUDED +LIBRARY sqlite3.lib +#endif + +LIBRARY euser.lib +LIBRARY bafl.lib +LIBRARY efsrv.lib +LIBRARY mediaclientaudio.lib +LIBRARY inetprotutil.lib +LIBRARY charconv.lib +LIBRARY xmlframework.lib +LIBRARY http.lib +LIBRARY flogger.lib +LIBRARY ezlib.lib +LIBRARY estor.lib +LIBRARY commdb.lib +LIBRARY esock.lib +LIBRARY mmfcontrollerframework.lib +LIBRARY apgrfx.lib +LIBRARY cone.lib +LIBRARY apmime.lib +LIBRARY cmmanager.lib +LIBRARY fbscli.lib +LIBRARY imageconversion.lib +LIBRARY bitmaptransforms.lib diff -r 5f8e5adbbed9 -r 29cda98b007e engine/inc/ConnectionEngine.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/inc/ConnectionEngine.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,113 @@ +/* + * Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB + * + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of the License "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * EmbedDev AB - initial contribution. + * + * Contributors: + * + * Description: + * + */ + +#ifndef PODCAST_CONNECTIONENGINE_H +#define PODCAST_CONNECTIONENGINE_H + + +// Connect using mobility extension +#include +#include +#include +#include + +// Using connection manager settings UI +#include +class CPodcastModel; + +class MConnectionObserver + { +public: + virtual void ConnectCompleteL(TInt aErrorCode) = 0; + virtual void Disconnected() = 0; + }; + +/** + * This class helps to connect using three available methods + * SNAP, Mobility extension and Connection manager UI + */ +class CConnectionEngine:public CActive, public MMobilityProtocolResp + { +public: + enum TConnectionType + { + EUserSelectConnection, + ESNAPConnection, + EMobilityConnection, + EDefaultConnection, + EIAPConnection + }; + + enum TConnectionState + { + ENotConnected, + EConnecting, + EConnected + }; + + static CConnectionEngine* NewL(CPodcastModel& aPodcastModel); + ~CConnectionEngine(); + void StartL(TConnectionType aConnectionType); + RConnection& Connection(); + TConnectionState ConnectionState(); + void AddObserver(MConnectionObserver* aObserver); + RSocketServ& SockServ(); +private: // Methods + CConnectionEngine(CPodcastModel& aPodcastModel); + void ConstructL(); +protected: + // From CActive + void RunL(); + void DoCancel(); + TInt RunError( TInt aError ); +protected: + // From MMobilityProtocolResp + void PreferredCarrierAvailable( TAccessPointInfo aOldAPInfo, + TAccessPointInfo aNewAPInfo, + TBool aIsUpgrade, + TBool aIsSeamless ); + + void NewCarrierActive( TAccessPointInfo aNewAPInfo, TBool aIsSeamless ); + void Error( TInt aError ); +protected: + // UI Setting + TBool ConnectionSettingL(); + + void ReportConnection(TInt aError); +private: + RConnection iConnection; + RSocketServ iSocketServer; + // Connect using mobility extension + CActiveCommsMobilityApiExt* iMobility; + + // Using connection manager settings UI + TCmSettingSelection iUserSelection; + + // Connect using Commdb + TCommDbConnPref iCommdbPreference; + + // Connect using SNAP setting + TConnSnapPref iSnapPreference; + + TConnectionType iConnectionType; + TConnectionState iConnectionState; + RPointerArray iObserverArray; + CPodcastModel &iPodcastModel; // reference to the model + }; + +#endif // PODCAST_CONNECTIONENGINE_H diff -r 5f8e5adbbed9 -r 29cda98b007e engine/inc/Constants.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/inc/Constants.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,34 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#ifndef __CONSTANTS_H__ +#define __CONSTANTS_H__ + +const TUint KSizeKb = 1024; +const TUint KSizeMb = 1024000; + +_LIT(KShowsSizeFormat,"%.1f"); +_LIT(KShowsSizeUnit,"MB"); +_LIT(KDateFormat,"%D%M%Y%/0%1%/1%2%/2%3%/3"); +_LIT(KDateFormatShort,"%D%M%/0%4%/1%5"); +// Date/time format string +_LIT(KTimeFormat, "%-B%:0%J%:1%T%+B"); + +#define KDefaultSQLDataBufferLength 2048 +#define KDefaultURLBufferLength 2048 +#endif diff -r 5f8e5adbbed9 -r 29cda98b007e engine/inc/FeedEngine.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/inc/FeedEngine.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,167 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#ifndef FEEDENGINE_H_ +#define FEEDENGINE_H_ + +#include "HttpClientObserver.h" +#include "HttpClient.h" +#include "FeedParser.h" +#include "FeedInfo.h" +#include "ShowInfo.h" +#include +#include "Constants.h" +#include "FeedEngineObserver.h" +#include "FeedTimer.h" +#include "sqlite3.h" + +class CPodcastModel; +class COpmlParser; + +_LIT(KOpmlFeed, " "); +_LIT(KOpmlHeader, "\n\n\n Podcast Feed List\n\n\n "); +_LIT(KOpmlFooter, " \n\n"); + +_LIT(KSearchUrl, "http://www.digitalpodcast.com/podcastsearchservice/v2b/search/?appid=SymbianPodcatcher&keywords=%S&format=rssopml&sort=rel&searchsource=all&contentfilter=noadult&start=0&results=20"); +_LIT(KSearchResultsFileName, "searchresults.opml"); + +const TInt KMaxUidBufLen = 20; +const TInt KMaxTitleLength = 512; +const TInt KMaxDescriptionLength = 1024; +const TInt KMaxURLLength = 512; +const TInt KMaxLineLength = 4096; +const TInt KMaxSearchString = 30; + +enum TClientState { + EIdle, + EUpdatingFeed, + EUpdatingImage, + ESearching +}; + +class CFeedEngine : public CBase, public MHttpClientObserver, public MFeedParserObserver +{ +public: + static CFeedEngine* NewL(CPodcastModel& aPodcastModel); + virtual ~CFeedEngine(); + +public: + IMPORT_C TBool AddFeedL(const CFeedInfo& item); + IMPORT_C void ImportFeedsL(const TDesC& aFile); + IMPORT_C TBool ExportFeedsL(TFileName& aFile); + IMPORT_C void RemoveFeedL(TUint aUid); + IMPORT_C TBool UpdateFeedL(TUint aFeedUid); + IMPORT_C void UpdateAllFeedsL(TBool aAutoUpdate = EFalse); + IMPORT_C void CancelUpdateAllFeeds(); + IMPORT_C const RFeedInfoArray& GetSortedFeeds(); + IMPORT_C CFeedInfo* GetFeedInfoByUid(TUint aFeedUid); + IMPORT_C void GetStatsByFeed(TUint aFeedUid, TUint &aNumShows, TUint &aNumUnplayed); + IMPORT_C void GetDownloadedStats(TUint &aNumShows, TUint &aNumUnplayed); + + IMPORT_C void AddObserver(MFeedEngineObserver *observer); + IMPORT_C void RemoveObserver(MFeedEngineObserver *observer); + + void RunFeedTimer(); + + IMPORT_C void UpdateFeed(CFeedInfo *aItem); + /** + * Returns the current internal state of the feed engine4 + */ + IMPORT_C TClientState ClientState(); + + /** + * Returns the current updating client UID if clientstate is != ENotUpdateing + * @return TUint + */ + IMPORT_C TUint ActiveClientUid(); + + IMPORT_C void SearchForFeedL(TDesC& aSearchString); + IMPORT_C void AddSearchResultL(CFeedInfo *item); + IMPORT_C const RFeedInfoArray& GetSearchResults(); + + IMPORT_C void OpmlParsingComplete(TUint aNumFeedsAdded); +protected: + + static TInt CompareFeedsByTitle(const CFeedInfo &a, const CFeedInfo &b); + +private: + void ConstructL(); + CFeedEngine(CPodcastModel& aPodcastModel); + + // from HttpClientObserver + void Connected(CHttpClient* aClient); + void Disconnected(CHttpClient* aClient); + void Progress(CHttpClient* aHttpClient, TInt aBytes, TInt aTotalBytes); + void DownloadInfo(CHttpClient* aClient, TInt aSize); + void CompleteL(CHttpClient* aClient, TInt aError); + void FileError(TUint /*aError*/) { } + // from FeedParser + void NewShowL(CShowInfo& aItem); + void ParsingCompleteL(CFeedInfo *aItem); + + void GetFeedImageL(CFeedInfo *aFeedInfo); + + void UpdateNextFeedL(); + void NotifyFeedUpdateComplete(TInt aError); + void NotifyOpmlParsingComplete(TUint aNumFeedsAdded); + + +private: + void DBLoadFeedsL(); + TBool DBRemoveFeed(TUint aUid); + TBool DBAddFeedL(const CFeedInfo& aTtem); + CFeedInfo* DBGetFeedInfoByUidL(TUint aFeedUid); + TUint DBGetFeedCount(); + TBool DBUpdateFeed(const CFeedInfo& aItem); + void DBGetStatsByFeed(TUint aFeedUid, TUint &aNumShows, TUint &aNumUnplayed); + + +private: + CHttpClient* iFeedClient; + TClientState iClientState; + CFeedTimer iFeedTimer; + + CPodcastModel& iPodcastModel; + + // RSS parser + CFeedParser* iParser; + + // the list of feeds + RFeedInfoArray iSortedFeeds; + + CFeedInfo *iActiveFeed; + TFileName iUpdatingFeedFileName; + TFileName iSearchResultsFileName; + RFeedInfoArray iFeedsUpdating; + + // observers that will receive callbacks, not owning + RArray iObservers; + + TBool iCatchupMode; + TUint iCatchupCounter; + + sqlite3& iDB; + + TBuf iSqlBuffer; + + COpmlParser* iOpmlParser; + RFeedInfoArray iSearchResults; + TBool iAutoUpdatedInitiator; +}; +#endif /*FEEDENGINE_H_*/ + diff -r 5f8e5adbbed9 -r 29cda98b007e engine/inc/FeedEngineObserver.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/inc/FeedEngineObserver.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,35 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#ifndef FEEDENGINEOBSERVER_H_ +#define FEEDENGINEOBSERVER_H_ +class MFeedEngineObserver { +public: + enum TFeedState + { + EFeedAutoUpdate, + EFeedManualUpdate, + EFeedSearch + }; + + virtual void FeedDownloadStartedL(TFeedState aState, TUint aFeedUid) = 0; + virtual void FeedDownloadFinishedL(TFeedState aState, TUint aFeedUid, TInt aError) = 0; + virtual void FeedUpdateAllCompleteL(TFeedState aState) = 0; + virtual void OpmlParsingComplete(TUint aNumFeedsImported) = 0; +}; +#endif /*FEEDENGINEOBSERVER_H_*/ diff -r 5f8e5adbbed9 -r 29cda98b007e engine/inc/FeedInfo.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/inc/FeedInfo.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,99 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#ifndef _FEEDINFO_H_ +#define _FEEDINFO_H_ + +#include +#include + +#include "ImageHandler.h" + +const TInt KFeedTitleLength=256; +const TInt KFeedUrlLength=1024; +const TInt KFeedDescriptionLength=2048; +class CFbsBitmap; + +class CFeedInfo : public CBase, public MImageHandlerCallback + { + public: + IMPORT_C static CFeedInfo* NewL(); + IMPORT_C static CFeedInfo* NewLC(); + ~CFeedInfo(); + IMPORT_C CFeedInfo* CopyL() const; + IMPORT_C const TDesC& Url() const; + IMPORT_C void SetUrlL(const TDesC &aUrl); + + IMPORT_C const TDesC& Title() const; + IMPORT_C void SetTitleL(const TDesC &aTitle); + + IMPORT_C const TDesC& Description() const; + IMPORT_C void SetDescriptionL(const TDesC &aDescription); + + IMPORT_C const TDesC& ImageUrl() const; + IMPORT_C void SetImageUrlL(const TDesC &aImageUrl); + + IMPORT_C const TDesC& Link() const; + IMPORT_C void SetLinkL(const TDesC &aLink); + + IMPORT_C TTime BuildDate() const; + IMPORT_C void SetBuildDate(TTime aBuildDate); + + IMPORT_C TTime LastUpdated() const; + IMPORT_C void SetLastUpdated(TTime aUpdated); + + IMPORT_C TUint Uid() const; + + IMPORT_C const TDesC& ImageFileName() const; + IMPORT_C void SetImageFileNameL(const TDesC &aFileName); + + IMPORT_C void SetCustomTitle(); + IMPORT_C TBool CustomTitle() const; + + IMPORT_C void SetLastError(TInt aLastError); + IMPORT_C TInt LastError() const; + + IMPORT_C CFbsBitmap* FeedIcon() const; + IMPORT_C void SetFeedIcon(CFbsBitmap* aBitmapToClone); + + IMPORT_C TInt FeedIconIndex() const; + IMPORT_C void SetFeedIconIndex(TInt aIndex); + private: + CFeedInfo(); + void ConstructL(); + void ImageOperationCompleteL(TInt aError); + private: + HBufC* iUrl; + HBufC* iTitle; + HBufC* iDescription; + HBufC* iImageUrl; + HBufC* iImageFileName; + HBufC* iLink; + TTime iBuildDate; + TTime iLastUpdated; + TUint iUid; + TBool iCustomTitle; + TInt iLastError; + CFbsBitmap* iFeedIcon; + TInt iFeedIconIndex; + }; + +typedef RPointerArray RFeedInfoArray; + +#endif + diff -r 5f8e5adbbed9 -r 29cda98b007e engine/inc/FeedParser.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/inc/FeedParser.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,104 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#ifndef FEEDPARSER_H_ +#define FEEDPARSER_H_ + +#include "FeedParserObserver.h" +#include "FeedInfo.h" +#include // for CParser +#include // for Xml::MContentHandler +#include + +_LIT(KTagItem, "item"); +_LIT(KTagTitle, "title"); +_LIT(KTagImage, "image"); +_LIT(KTagLink, "link"); +_LIT(KTagDescription, "description"); +_LIT(KTagUrl, "url"); +_LIT(KTagLength, "length"); +_LIT(KTagChannel, "channel"); +_LIT(KTagEnclosure, "enclosure"); +_LIT(KTagPubDate, "pubDate"); +_LIT(KTagLastBuildDate, "lastBuildDate"); +_LIT(KTagHref, "href"); + +enum TFeedState { + EStateRoot, + EStateChannel, + EStateChannelTitle, + EStateChannelLink, + EStateChannelLastBuildDate, + EStateChannelDescription, + EStateChannelImage, + EStateChannelImageUrl, + EStateItem, + EStateItemTitle, + EStateItemLink, + EStateItemEnclosure, + EStateItemDescription, + EStateItemPubDate +}; + +enum TEncoding { + EUtf8, + ELatin1 +}; + +const int KBufferLength = 1024; + +class CFeedParser : public CBase, public Xml::MContentHandler +{ +public: + CFeedParser(MFeedParserObserver& aCallbacks, RFs& aFs); + virtual ~CFeedParser(); + +public: + void ParseFeedL(const TFileName &feedFileName, CFeedInfo *item, TUint aMaxItems); + +public: // from MContentHandler + void OnStartDocumentL(const Xml::RDocumentParameters& aDocParam, TInt aErrorCode); + void OnEndDocumentL(TInt aErrorCode); + void OnStartElementL(const Xml::RTagInfo& aElement, const Xml::RAttributeArray& aAttributes, TInt aErrorCode); + void OnEndElementL(const Xml::RTagInfo& aElement, TInt aErrorCode); + void OnContentL(const TDesC8& aBytes, TInt aErrorCode); + void OnStartPrefixMappingL(const RString& aPrefix, const RString& aUri, TInt aErrorCode); + void OnEndPrefixMappingL(const RString& aPrefix, TInt aErrorCode); + void OnIgnorableWhiteSpaceL(const TDesC8& aBytes, TInt aErrorCode); + void OnSkippedEntityL(const RString& aName, TInt aErrorCode); + void OnProcessingInstructionL(const TDesC8& aTarget, const TDesC8& aData, TInt aErrorCode); + void OnError(TInt aErrorCode); + TAny* GetExtendedInterface(const TInt32 aUid); + CFeedInfo& ActiveFeed(); +private: + MFeedParserObserver& iCallbacks; + TFeedState iFeedState; + + CShowInfo* iActiveShow; + CFeedInfo *iActiveFeed; + + TBuf iBuffer; + + TUint iMaxItems; + TUint iItemsParsed; + TBool iStoppedParsing; + TEncoding iEncoding; + RFs& iRfs; +}; + +#endif diff -r 5f8e5adbbed9 -r 29cda98b007e engine/inc/FeedParserObserver.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/inc/FeedParserObserver.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,32 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#ifndef FEEDPARSEROBSERVER_H_ +#define FEEDPARSEROBSERVER_H_ + +#include "ShowInfo.h" +#include "FeedInfo.h" + +class MFeedParserObserver +{ +public: + virtual void NewShowL(CShowInfo& item) = 0; + virtual void ParsingCompleteL(CFeedInfo *item) = 0; +}; + +#endif diff -r 5f8e5adbbed9 -r 29cda98b007e engine/inc/FeedTimer.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/inc/FeedTimer.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,42 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#ifndef FEEDTIMER_H +#define FEEDTIMER_H + +#include + +class CFeedEngine; + +class CFeedTimer : public CTimer + { + public: + CFeedTimer(CFeedEngine *aFeedEngine); + ~CFeedTimer(); + void ConstructL(); + void RunL(); + void RunPeriodically(); + void SetPeriod(TInt aPeriodMinutes); + void SetSyncTime(TTime aTime); + + private: + TInt iPeriodMinutes; + CFeedEngine *iFeedEngine; + }; +#endif + diff -r 5f8e5adbbed9 -r 29cda98b007e engine/inc/HttpClient.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/inc/HttpClient.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,69 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#ifndef __HTTPCLIENT_H__ +#define __HTTPCLIENT_H__ + +#include +#include "HttpClientObserver.h" +#include "HttpEventHandler.h" +#include "PodcastModel.h" +#include "connectionengine.h" +#include "es_sock.h" +#include "constants.h" + +_LIT8(KUserAgent, "Symbian/Podcatcher"); +_LIT8(KAccept, "*/*"); + +class CHttpClient : public CBase, public MConnectionObserver +{ +public: + virtual ~CHttpClient(); + static CHttpClient* NewL(CPodcastModel& aPodcastModel, MHttpClientObserver& aResObs); + TBool GetL(const TDesC& aUrl, const TDesC& aFileName, TBool aSilent = EFalse); + void Stop(); + TBool IsActive(); + void ClientRequestCompleteL(TInt aErrorCode); + void SetResumeEnabled(TBool aEnabled); + +private: + CHttpClient(CPodcastModel& aPodcastModel, MHttpClientObserver& aResObs); + static CHttpClient* NewLC(CPodcastModel& aPodcastModel, MHttpClientObserver& aResObs); + void ConstructL(); + void SetHeaderL(RHTTPHeaders aHeaders, TInt aHdrField, const TDesC8& aHdrValue); + void ConnectHttpSessionL(); + void ConnectCompleteL(TInt aErrorCode); + void Disconnected(); + void DoGetAfterConnectL(); +private: + RHTTPSession iSession; + TBool iWaitingForGet; + TBool iIsActive; + RHTTPTransaction iTrans; + CHttpEventHandler* iHandler; + TBool iResumeEnabled; + CPodcastModel& iPodcastModel; + MHttpClientObserver& iObserver; + TInt iTransactionCount; + TBuf8 iCurrentURL; + TUriParser8 iUriParser; + TBool iSilentGet; + TFileName iCurrentFileName; +}; +#endif + diff -r 5f8e5adbbed9 -r 29cda98b007e engine/inc/HttpClientObserver.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/inc/HttpClientObserver.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,37 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#ifndef _MHTTPCLIENTOBSERVER_H_ +#define _MHTTPCLIENTOBSERVER_H_ + +#include + +class CHttpClient; + +class MHttpClientObserver +{ +public: + virtual void Connected(CHttpClient* aHttpClient) = 0; + virtual void Disconnected(CHttpClient* aHttpClient) = 0; + virtual void CompleteL(CHttpClient* aHttpClient, TInt aError) = 0; + virtual void Progress(CHttpClient* aHttpClient, TInt aBytes, TInt aTotalBytes) = 0; + virtual void DownloadInfo(CHttpClient* aHttpClient, TInt aTotalBytes) = 0; + virtual void FileError(TUint aError) = 0; +}; + +#endif diff -r 5f8e5adbbed9 -r 29cda98b007e engine/inc/HttpEventHandler.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/inc/HttpEventHandler.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,76 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#ifndef HTTPEVENTHANDLER_H +#define HTTPEVENTHANDLER_H + +#include +#include +#include +#include +#include +#include +#include "HttpClientObserver.h" + +const TInt KMaxSubmitSize = 1024; +const TInt KMaxHeaderNameLen = 32; +const TInt KMaxHeaderValueLen = 128; +const TInt KByteOverlap = 4096; + +class CHttpEventHandler : public CBase, + public MHTTPTransactionCallback + { + public: + virtual ~CHttpEventHandler(); + static CHttpEventHandler* NewLC(CHttpClient* aClient, MHttpClientObserver &aCallbacks, RFs& aFs); + static CHttpEventHandler* NewL(CHttpClient* aClient, MHttpClientObserver &aCallbacks, RFs& aFs); + void SetSaveFileName(const TDesC &fName,TBool aContinue=EFalse); + void CloseSaveFile(); + // from MHTTPTransactionCallback + virtual void MHFRunL(RHTTPTransaction aTransaction, const THTTPEvent& aEvent); + virtual TInt MHFRunError(TInt aError, RHTTPTransaction aTransaction, const THTTPEvent& aEvent); + void SetSilent(TBool aSilent); + + +protected: + CHttpEventHandler(CHttpClient* aClient, MHttpClientObserver &aCallbacks, RFs& aFs); + void ConstructL(); + +private: + void DumpRespHeadersL(RHTTPTransaction& aTrans); + void DumpRespBody(RHTTPTransaction& aTrans); + void DumpIt(const TDesC8& aData); + +private: + TBool iVerbose; + TBool iSavingResponseBody; + RFs& iFileServ; + RFile iRespBodyFile; + TFileName iFileName; + TParse iParsedFileName; + MHTTPDataSupplier* iRespBody; + TInt iBytesDownloaded; + TInt iBytesTotal; + CHttpClient* iHttpClient; + MHttpClientObserver& iCallbacks; + TBool iSilent; + TBool iContinue; + TInt iLastStatusCode; +}; + +#endif diff -r 5f8e5adbbed9 -r 29cda98b007e engine/inc/ImageHandler.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/inc/ImageHandler.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,183 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* Example code from OcrExample Copyright (c) 2006 Nokia Corporation. +* Description: +* +*/ + +#ifndef IMAGEHANDLER_H +#define IMAGEHANDLER_H + +#include +#include +#include + +/** + * Listener interface that can be used to listen for image loading operation + * completion events from CImageHandler. + * + * The class is intended to be implemented by a client class that observes the + * loading operation of image handler. The methods in this class + * are called by the image handler (class CImageHandler) when it loads + * an image. + * + * Reference to implementations of this listener interface can be passed as + * a parameter to the constructor of the image handler (class CImageHandler). + */ +class MImageHandlerCallback + { +public: + /** + * Called by CImageHandler when an image has been loaded. + * @param aError Error code given by the CImageHandler or 0 (zero) if the + * image was loaded successfully. + */ + virtual void ImageOperationCompleteL(TInt aError) = 0; + }; + +// ============================================================================ +class TImageStruct + { +public: + CFbsBitmap* iScaledImage; + TSize iScaledSize; + MImageHandlerCallback* iCallBack; + TFileName iFileName; + }; +/** +* CImageHandler +* Image loader and scaler class. +*/ +class CImageHandler : public CActive + { + public: // Constructors and destructor + /** + * Factory method that constructs a CImageHandler by using the NewLC method + * and then cleans the cleanup stack. + * @param aBitmap Bitmap where the image data is loaded to. + * @param aScaledBitmap Bitmap where the scaled image data is loaded to. + * @param aFs File server reference that is used to load the image data. + * @param aCallback Listener interface implementation that is notified + * when an image has been loaded. + * @return pointer to created CImageHandler-object + */ + IMPORT_C static CImageHandler* NewL(RFs& aFs); + + /** + * Factory method that constructs a CImageHandler and leaves it to the + * cleanup stack. + * @param aBitmap Bitmap where the image data is loaded to. + * @param aScaledBitmap Bitmap where the scaled image data is loaded to. + * @param aFs File server reference that is used to load the image data. + * @param aCallback Listener interface implementation that is notified + * when an image has been loaded. + * @return pointer to created CImageHandler-object + */ + IMPORT_C static CImageHandler* NewLC(RFs& aFs); + /** + * Desctructor. Destroys the CImageDecoder used by the image handler. + */ + IMPORT_C virtual ~CImageHandler(); + IMPORT_C CFbsBitmap* ScaledBitmap(); + public: // New functions + + /** + * Loads a the given frame from the given file and scale it to the + * specified size + * @param aFileName Filename wherefrom the bitmap data is loaded. + * @param aSize the target size for the scaling + * @param aSelectedFrame A single frame index in a multi-frame file. + * If not given the first frame is loaded. + */ + IMPORT_C void LoadFileAndScaleL(CFbsBitmap* aScaledBitmap, + const TFileName& aFileName, + const TSize &aSize, + MImageHandlerCallback& aCallback, + TInt aSelectedFrame = 0); + + /** + * Returns the current frame information. + * @return Current frame information. + */ + const TFrameInfo& FrameInfo() const; + private: + /** + * Loads a the given frame from the given file. + * @param aFileName Filename wherefrom the bitmap data is loaded. + * @param aSelectedFrame A single frame index in a multi-frame file. If not given the first frame is loaded. + */ + void LoadFileL(const TFileName& aFileName, TInt aSelectedFrame = 0); + + /** + * Scales a loaded image + * Scales a loaded image to the target size (given in LoadFileAndScaleL or + * FitToScreenL). The scaled image is stored into iScaledBitmap. + */ + void ScaleL(); + + private: // Functions from base classes + + /** + * CActive::RunL() implementation. Called on image load success/failure. + */ + void RunL(); + /** + * CActive::Cancel() implementation. Stops decoding. + */ + void DoCancel(); + + protected: + /** + * C++ default constructor. Just stores the given parameters to + * corresponding attributes. + * @param aScaledBitmap Bitmap where the scaled image data is loaded to. + * @param aFs File server reference that is used to load the image data. + * @param aCallback Listener interface implementation that is notified + * when an image has been loaded. + */ + CImageHandler(RFs& aFs); + /** + * 2nd phase constructor. Adds this object to the active scheduler. + */ + void ConstructL(); + + private: // Data + /** Image decoder that is used to load the image data from file. */ + CImageDecoder *iDecoder; + + /** Image scaler that is used to scale the image */ + CBitmapScaler *iScaler; + + /** Listener that is notified when an image has been loaded. */ + MImageHandlerCallback * iCallback; + + /** Bitmap (owned by the user of this class) where the loaded image is put */ + CFbsBitmap *iBitmap; + + /** Bitmap (owned by the user of this class) where the SCALED image is put */ + CFbsBitmap *iScaledBitmap; + + /** File server session (owned by the user of this class) */ + RFs &iFs; + + /** Current image frame information. */ + TFrameInfo iFrameInfo; + + /** target size for scaled image */ + TSize iSize; + RArray iCallbackQue; + }; + +#endif + diff -r 5f8e5adbbed9 -r 29cda98b007e engine/inc/MetaDataReader.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/inc/MetaDataReader.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,61 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#ifndef METADATAREADER_H_ +#define METADATAREADER_H_ + +#include +#include +#include "ShowInfo.h" +#include "MetaDataReaderObserver.h" + +class CCnvCharacterSetConverter; +#define KMetaDataBufferLength 1024 +class CMetaDataReader : public CBase, public MMdaAudioPlayerCallback +{ +public: + CMetaDataReader(MMetaDataReaderObserver &aObserver, RFs& aFs); + void SubmitShowL(CShowInfo *aShowInfo); + virtual ~CMetaDataReader(); + void ConstructL(); + void SetIgnoreTrackNo(TBool aIgnoreTrackNo); + +protected: + void MapcPlayComplete(TInt aError); + void MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds &aDuration); + static TInt ParseNextShowCallbackL(TAny* aMetaDataReader); +private: + void ParseNextShowL(); + +private: + CMdaAudioPlayerUtility *iPlayer; + RShowInfoArray iShowsToParse; + CShowInfo *iShow; + MMetaDataReaderObserver &iObserver; + TBuf8 iTempFileName; + TBuf8 iTempDataBuffer; + TBuf iStringBuffer; + TBuf iStringBuffer2; + CAsyncCallBack* iParseNextShowCallBack; + CCnvCharacterSetConverter* iCharConverter; + TUint iLastConverterCharset; + TBool iIgnoreTrackNo; + RFs &iFs; +}; + +#endif /*METADATAREADER_H_*/ diff -r 5f8e5adbbed9 -r 29cda98b007e engine/inc/MetaDataReaderObserver.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/inc/MetaDataReaderObserver.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,28 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#ifndef METADATAREADEROBSERVER_H_ +#define METADATAREADEROBSERVER_H_ + +class MMetaDataReaderObserver { +public: + virtual void ReadMetaData(CShowInfo& aShowInfo) = 0; + virtual void ReadMetaDataCompleteL() = 0; +}; + +#endif /*METADATAREADEROBSERVER_H_*/ diff -r 5f8e5adbbed9 -r 29cda98b007e engine/inc/OpmlParser.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/inc/OpmlParser.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,74 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#ifndef OPMLPARSER_H_ +#define OPMLPARSER_H_ + +#include // for CParser +#include // for Xml::MContentHandler +#include +#include "FeedEngine.h" + +_LIT(KTagOpml, "opml"); +_LIT(KTagBody, "body"); +_LIT(KTagOutline, "outline"); +_LIT(KTagXmlUrl, "xmlUrl"); +_LIT(KTagText, "text"); +_LIT(KTagHtmlUrl, "htmlUrl"); + +enum TOpmlState { + EStateOpmlRoot, + EStateOpmlBody, + EStateOpmlOutline, + EStateOpmlOutlineOutline + }; + +class COpmlParser : public CBase, public Xml::MContentHandler +{ +public: + COpmlParser(CFeedEngine& aFeedEngine, RFs& aFs); + virtual ~COpmlParser(); + +public: + void ParseOpmlL(const TFileName &feedFileName, TBool aSearching); + +public: // from MContentHandler + void OnStartDocumentL(const Xml::RDocumentParameters& aDocParam, TInt aErrorCode); + void OnEndDocumentL(TInt aErrorCode); + void OnStartElementL(const Xml::RTagInfo& aElement, const Xml::RAttributeArray& aAttributes, TInt aErrorCode); + void OnEndElementL(const Xml::RTagInfo& aElement, TInt aErrorCode); + void OnContentL(const TDesC8& aBytes, TInt aErrorCode); + void OnStartPrefixMappingL(const RString& aPrefix, const RString& aUri, TInt aErrorCode); + void OnEndPrefixMappingL(const RString& aPrefix, TInt aErrorCode); + void OnIgnorableWhiteSpaceL(const TDesC8& aBytes, TInt aErrorCode); + void OnSkippedEntityL(const RString& aName, TInt aErrorCode); + void OnProcessingInstructionL(const TDesC8& aTarget, const TDesC8& aData, TInt aErrorCode); + void OnError(TInt aErrorCode); + TAny* GetExtendedInterface(const TInt32 aUid); +private: + CFeedEngine& iFeedEngine; + TOpmlState iOpmlState; + + TBuf iBuffer; + TEncoding iEncoding; + RFs& iFs; + TBool iSearching; + TUint iNumFeedsAdded; +}; + +#endif diff -r 5f8e5adbbed9 -r 29cda98b007e engine/inc/PodcastModel.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/inc/PodcastModel.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,131 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#ifndef PODCASTMODEL_H +#define PODCASTMODEL_H +#include +#include +#include +#include +#include +#include +#include + +#include "FeedInfo.h" +#include "ShowInfo.h" +#include "debug.h" +#include "sqlite3.h" +#include "ImageHandler.h" + +// SQLite leaks memory when sorting, so to test our own memory leaks we need to disable this +//#define DONT_SORT_SQL +class RCmManager; +class CFeedEngine; +class CSoundEngine; +class CShowEngine; +class CSettingsEngine; +class CCommsDatabase; +class CConnectionEngine; + +class TPodcastIAPItem +{ +public: + TUint32 iIapId; + TBuf iServiceType; + TBuf iBearerType; +}; + +/** + * This class handles application storage needs and ownership of audioplayer, resource lists etc. + */ +class CPodcastModel : public CBase, public MImageHandlerCallback +{ +public: + IMPORT_C static CPodcastModel* NewL(); + IMPORT_C ~CPodcastModel(); + IMPORT_C CFeedEngine& FeedEngine(); + IMPORT_C CShowEngine& ShowEngine(); + IMPORT_C CSoundEngine& SoundEngine(); + IMPORT_C CSettingsEngine& SettingsEngine(); + IMPORT_C CConnectionEngine& ConnectionEngine(); + IMPORT_C CShowInfo* PlayingPodcast(); + IMPORT_C void SetPlayingPodcast(CShowInfo* aPodcast); + IMPORT_C void PlayPausePodcastL(CShowInfo * aPodcast, TBool aPlayOnInit = EFalse); + IMPORT_C CFeedInfo* ActiveFeedInfo(); + IMPORT_C void SetActiveFeedInfo(CFeedInfo* aFeedInfo); + + RFs& FsSession(); + + IMPORT_C RShowInfoArray& ActiveShowList(); + + void SetActiveShowList(RShowInfoArray& aShowArray); + + IMPORT_C void UpdateIAPListL(); + IMPORT_C void UpdateSNAPListL(); + IMPORT_C CDesCArrayFlat* IAPNames(); + IMPORT_C RArray& IAPIds(); + IMPORT_C CDesCArrayFlat* SNAPNames(); + IMPORT_C RArray& SNAPIds(); + + void SetProxyUsageIfNeededL(RHTTPSession& aSession); + void GetProxyInformationForConnectionL(TBool& aIsUsed, HBufC*& aServerName, TUint32& aPort); + TInt GetIapId(); + + sqlite3* DB(); + + IMPORT_C void GetAllShows(); + IMPORT_C void GetNewShows(); + IMPORT_C void GetShowsDownloaded(); + IMPORT_C void GetShowsDownloading(); + IMPORT_C void GetShowsByFeed(TUint aFeedUid); + IMPORT_C void MarkSelectionPlayed(); + + TInt FindActiveShowByUid(TUint aUid); + IMPORT_C TBool IsFirstStartup(); + IMPORT_C CImageHandler& ImageHandler(); +protected: + CPodcastModel(); + void ConstructL(); + // From ImageHandler + void ImageOperationCompleteL(TInt aError); +private: + CShowInfo* iPlayingPodcast; + + CFeedEngine* iFeedEngine; + CShowEngine* iShowEngine; + CSoundEngine* iSoundEngine; + CSettingsEngine *iSettingsEngine; + CConnectionEngine* iConnectionEngine; + RShowInfoArray iActiveShowList; + CFeedInfo *iActiveFeed; + + RFs iFsSession; + RArray iIapIdArray; + CDesCArrayFlat* iIapNameArray; + + RArray iSNAPIdArray; + CDesCArrayFlat* iSNAPNameArray; + CCommsDatabase* iCommDB; + + sqlite3* iDB; + RCmManager iCmManager; + TBool iIsFirstStartup; + CImageHandler* iImageHandler; +}; + +#endif // PODCASTMODEL_H diff -r 5f8e5adbbed9 -r 29cda98b007e engine/inc/PodcastUtils.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/inc/PodcastUtils.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,41 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#ifndef PODCASTUTILS_H_ +#define PODCASTUTILS_H_ + +#include + +_LIT(KURLPrefix, "http://"); +_LIT(KItpcPrefix, "itpc://"); +_LIT(KPcastPrefix, "pcast://"); + +class PodcastUtils + { +public: + IMPORT_C static void FixProtocolsL(TDes &aUrl); + IMPORT_C static void CleanHtmlL(TDes &str); + IMPORT_C static void ReplaceString(TDes & aString, const TDesC& aStringToReplace, const TDesC& aReplacement); + IMPORT_C static void ReplaceChar(TDes & aString, TUint aCharToReplace, TUint aReplacement); + IMPORT_C static void EnsureProperPathName(TFileName &aPath); + IMPORT_C static void FileNameFromUrl(const TDesC &aUrl, TFileName &aFileName); + IMPORT_C static void SQLEncode(TDes &aString); + IMPORT_C static void XMLEncode(TDes &aString); +}; + +#endif /* PODCASTUTILS_H_ */ diff -r 5f8e5adbbed9 -r 29cda98b007e engine/inc/SettingsEngine.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/inc/SettingsEngine.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,112 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#ifndef SETTINGSENGINE_H_ +#define SETTINGSENGINE_H_ + +#include +#include "PodcastModel.h" + +_LIT(KPodcastDir1, "F:\\Podcasts\\"); // memory card on phone with flash disk +_LIT(KPodcastDir2, "E:\\Podcasts\\"); // memory card on phone without flash disk +_LIT(KPodcastDir3, "C:\\Podcasts\\"); + +_LIT(KConfigImportFile, "config.cfg"); +_LIT(KDefaultFeedsFile, "defaultfeeds.xml"); +_LIT(KImportFeedsFile, "feeds.xml"); + +_LIT(KConfigFile, "config.db"); + +// constants +const TInt KSettingsUid = 1000; +const TInt KDefaultUpdateFeedInterval = 60; +const TInt KDefaultMaxListItems = 100; +const TInt32 KUseIAPFlag =0x01000000; +const TInt32 KUseIAPMask =0x00FFFFFF; + +enum TAutoUpdateSetting + { + EAutoUpdateOff, + EAutoUpdatePeriod1=60, + EAutoUpdatePeriod2=360, + EAutoUpdatePeriod3=720, + EAutoUpdatePeriod4=1440 + }; + +class CSettingsEngine : public CBase + { + public: + static CSettingsEngine* NewL(CPodcastModel& aPodcastModel); + virtual ~CSettingsEngine(); + + + TFileName DefaultFeedsFileName(); + TFileName ImportFeedsFileName(); + TFileName PrivatePath(); + + TInt MaxListItems(); + + IMPORT_C TFileName& BaseDir(); + IMPORT_C void SetBaseDir(TFileName& aFileName); + + IMPORT_C TInt UpdateFeedInterval(); + IMPORT_C void SetUpdateFeedInterval(TInt aInterval); + + IMPORT_C TInt MaxSimultaneousDownloads(); + IMPORT_C void SetMaxSimultaneousDownloads(TInt aMaxDownloads); + + IMPORT_C TAutoUpdateSetting UpdateAutomatically(); + IMPORT_C void SetUpdateAutomatically(TAutoUpdateSetting aAutoOn); + + IMPORT_C TBool DownloadAutomatically(); + IMPORT_C void SetDownloadAutomatically(TBool aAutoDownloadOn); + + IMPORT_C TBool DownloadSuspended(); + IMPORT_C void SetDownloadSuspended(TBool aSuspended); + + IMPORT_C TTime UpdateFeedTime(); + IMPORT_C void SetUpdateFeedTime(TTime aTime); + + IMPORT_C TInt SpecificIAP(); + IMPORT_C void SetSpecificIAP(TInt aIap); + + IMPORT_C void SaveSettingsL(); + + private: + CSettingsEngine(CPodcastModel& aPodcastModel); + void ConstructL(); + void LoadSettingsL(); + void GetDefaultBaseDirL(TDes &aBaseDir); + + + private: + // the settings we serialize + TFileName iBaseDir; + TInt iUpdateFeedInterval; + TAutoUpdateSetting iUpdateAutomatically; + TBool iDownloadAutomatically; + TInt iIap; + TInt iMaxListItems; + TTime iUpdateFeedTime; + TBool iDownloadSuspended; + + // Other member variables + CPodcastModel &iPodcastModel; // reference to the model + }; + +#endif /*SETTINGSENGINE_H_*/ diff -r 5f8e5adbbed9 -r 29cda98b007e engine/inc/ShowEngine.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/inc/ShowEngine.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,147 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#ifndef SHOWENGINE_H_ +#define SHOWENGINE_H_ + +#include +#include +#include "constants.h" +#include "ShowInfo.h" +#include "PodcastModel.h" +#include "HttpClient.h" +#include "ShowEngineObserver.h" +#include "MetaDataReader.h" +#include "sqlite3.h" + +class CShowEngine : public CBase, public MHttpClientObserver, public MMetaDataReaderObserver +{ +public: + IMPORT_C static CShowEngine* NewL(CPodcastModel& aPodcastModel); + IMPORT_C virtual ~CShowEngine(); + +public: + IMPORT_C void AddDownloadL(CShowInfo& info); + IMPORT_C TBool RemoveDownloadL(TUint aUid); + IMPORT_C void RemoveAllDownloads(); + + IMPORT_C void SuspendDownloads(); + IMPORT_C void ResumeDownloadsL(); + + IMPORT_C TInt GetNumDownloadingShows(); + IMPORT_C CShowInfo* ShowDownloading(); + IMPORT_C CShowInfo* GetShowByUidL(TUint aShowUid); + IMPORT_C CShowInfo* GetNextShowByTrackL(CShowInfo* aShowInfo); + + // show access methods + IMPORT_C void GetAllShowsL(RShowInfoArray &aArray); + IMPORT_C void GetShowsByFeedL(RShowInfoArray &aArray, TUint aFeedUid); + IMPORT_C void GetShowsDownloadedL(RShowInfoArray &aArray); + IMPORT_C void GetNewShowsL(RShowInfoArray &aArray); + IMPORT_C void GetShowsDownloadingL(RShowInfoArray &aArray); + IMPORT_C CShowInfo* DBGetShowByFileNameL(TFileName aFileName); + + IMPORT_C TBool AddShowL(const CShowInfo& item); + IMPORT_C void DeletePlayedShows(RShowInfoArray &aShowInfoArray); + IMPORT_C void DeleteAllShowsByFeedL(TUint aFeedUid,TBool aDeleteFiles=ETrue); + IMPORT_C void DeleteShowL(TUint aShowUid, TBool aRemoveFile=ETrue); + IMPORT_C void DeleteOldShowsByFeed(TUint aFeedUid); + + IMPORT_C void AddObserver(MShowEngineObserver *observer); + IMPORT_C void RemoveObserver(MShowEngineObserver *observer); + + IMPORT_C void NotifyShowListUpdatedL(); + IMPORT_C void UpdateShow(CShowInfo& aInfo); + + IMPORT_C void GetMimeType(const TDesC& aFileName, TDes& aMimeType); + + IMPORT_C CMetaDataReader& MetaDataReader(); + +private: + // from HttpClientObserver, dont have to be public + void Connected(CHttpClient* aClient); + void Disconnected(CHttpClient* aClient); + void CompleteL(CHttpClient* aClient, TInt aError); + void Progress(CHttpClient* aHttpClient, int aBytes, int aTotalBytes); + void DownloadInfo(CHttpClient* aClient, int aSize); + void FileError(TUint aError); + // from MetaDataReaderObserver + void ReadMetaData(CShowInfo& aShowInfo); + void ReadMetaDataCompleteL(); + +private: + CShowEngine(CPodcastModel& aPodcastModel); + void ConstructL(); + + TBool GetShowL(CShowInfo *info); + + void NotifyDownloadQueueUpdatedL(); + void NotifyShowDownloadUpdatedL(TInt aBytesOfCurrentDownload, TInt aBytesTotal); + void NotifyShowFinishedL(TInt aError); + void DownloadNextShowL(); + + static TInt CompareShowsByDate(const CShowInfo &a, const CShowInfo &b); + static TBool CompareShowsByUid(const CShowInfo &a, const CShowInfo &b); + static TInt CompareShowsByTitle(const CShowInfo &a, const CShowInfo &b); + static TInt CompareShowsByTrackNo(const CShowInfo &a, const CShowInfo &b); + + void AddShowToMpxCollection(CShowInfo &aShowInfo); + +private: + // DB methods + CShowInfo* DBGetShowByUidL(TUint aUid); + void DBFillShowInfoFromStmtL(sqlite3_stmt *st, CShowInfo* showInfo); + TBool DBAddShow(const CShowInfo& aItem); + TBool DBUpdateShow(CShowInfo& aItem); + void DBGetShowsByFeedL(RShowInfoArray& aShowArray, TUint aFeedUid); + void DBGetAllShowsL(RShowInfoArray& aShowArray); + void DBGetNewShowsL(RShowInfoArray& aShowArray); + void DBGetDownloadedShowsL(RShowInfoArray& aShowArray); + TBool DBDeleteAllShowsByFeed(TUint aFeedUid); + void DBDeleteOldShowsByFeed(TUint aFeedUid); + TBool DBDeleteShow(TUint aUid); + void DBRemoveAllDownloads(); + void DBRemoveDownload(TUint aUid); + void DBGetAllDownloadsL(RShowInfoArray& aShowArray); + TUint DBGetDownloadsCount(); + void DBAddDownload(TUint aUid); + CShowInfo* DBGetNextDownloadL(); + +private: + CHttpClient* iShowClient; + + CPodcastModel& iPodcastModel; + + // observers that will receive callbacks + RArray iObservers; + + // The show we are currently downloading + CShowInfo* iShowDownloading; + TUint iDownloadErrors; + + CMetaDataReader* iMetaDataReader; + + RApaLsSession iApaSession; + TBuf8<512> iRecogBuffer; + + sqlite3& iDB; + TBuf iSqlBuffer; +}; + +#endif /*SHOWENGINE_H_*/ + diff -r 5f8e5adbbed9 -r 29cda98b007e engine/inc/ShowEngineObserver.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/inc/ShowEngineObserver.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,28 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#ifndef SHOWENGINEOBSERVER_H_ +#define SHOWENGINEOBSERVER_H_ +class MShowEngineObserver { +public: + virtual void ShowListUpdatedL() = 0; + virtual void DownloadQueueUpdatedL(TInt aDownloadingShows, TInt aQueuedShows) = 0; + virtual void ShowDownloadUpdatedL(TInt aBytesOfCurrentDownload, TInt aBytesTotal) = 0; + virtual void ShowDownloadFinishedL(TUint aShowUid, TInt aError) = 0; +}; +#endif /*SHOWENGINEOBSERVER_H_*/ diff -r 5f8e5adbbed9 -r 29cda98b007e engine/inc/ShowInfo.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/inc/ShowInfo.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,124 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#ifndef SHOWINFO_H_ +#define SHOWINFO_H_ +#include +#include +#include +#include +#include + +const int KShowInfoVersion = 8; + +enum TPlayState { + ENeverPlayed, + EPlayed, + EPlaying +}; + +enum TDownloadState { + ENotDownloaded, + EQueued, + EDownloading, + EFailedDownload, + EDownloaded +}; + +enum TShowType { + EAudioPodcast = 0, + EVideoPodcast +}; + +class CShowInfo: public CBase { +public: + IMPORT_C static CShowInfo* NewL(TUint aVersion=KShowInfoVersion); + IMPORT_C static CShowInfo* NewLC(TUint aVersion=KShowInfoVersion); + ~CShowInfo(); + IMPORT_C CShowInfo(CShowInfo *aInfo); // copy constructor + +public: + IMPORT_C const TDesC& Title() const; + IMPORT_C void SetTitleL(const TDesC& aTitle); + + IMPORT_C const TDesC& Url() const; + IMPORT_C void SetUrlL(const TDesC &aUrl); + + IMPORT_C const TDesC& Description() const; + IMPORT_C void SetDescriptionL(const TDesC &aDescription); + + IMPORT_C TTimeIntervalMicroSeconds Position() const; + IMPORT_C void SetPosition(TTimeIntervalMicroSeconds aPosition); + + IMPORT_C TUint PlayTime() const; + IMPORT_C void SetPlayTime(TUint aPlayTime); + + IMPORT_C TPlayState PlayState() const; + IMPORT_C void SetPlayState(TPlayState aPlayState); + + IMPORT_C TDownloadState DownloadState() const; + IMPORT_C void SetDownloadState(TDownloadState aDownloadState); + + IMPORT_C TUint FeedUid() const; + IMPORT_C void SetFeedUid(TUint aFeedUid); + + IMPORT_C void SetUid(TUint aUid); + IMPORT_C TUint Uid() const; + + IMPORT_C TUint ShowSize() const; + IMPORT_C void SetShowSize(TUint aShowSize); + + IMPORT_C const TTime PubDate() const; + IMPORT_C void SetPubDate(TTime aPubDate); + + IMPORT_C const TDesC &FileName() const; + IMPORT_C void SetFileNameL(const TDesC &aFileName); + + IMPORT_C void SetShowType(TShowType aShowType); + IMPORT_C TShowType ShowType() const; + + IMPORT_C void SetTrackNo(TUint aTrackNo); + IMPORT_C TUint TrackNo() const; + + IMPORT_C void SetLastError(TInt aLastError); + IMPORT_C TInt LastError() const; +private: + CShowInfo(); + void ConstructL(); + +private: + HBufC* iTitle; + HBufC* iUrl; + HBufC* iDescription; + HBufC* iFileName; + TTimeIntervalMicroSeconds iPosition; + TUint iPlayTime; + TPlayState iPlayState; + TDownloadState iDownloadState; + TUint iFeedUid; + TUint iUid; + TUint iShowSize; + TUint iTrackNo; + TTime iPubDate; + TBool iDelete; + TShowType iShowType; + TInt iLastError; +}; + +typedef RPointerArray RShowInfoArray; +#endif diff -r 5f8e5adbbed9 -r 29cda98b007e engine/inc/SoundEngine.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/inc/SoundEngine.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,88 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#ifndef SOUND_ENGINE_H +#define SOUND_ENGINE_H +#include + +class CPodcastModel; + +const TInt KVolumeSteps = 10; + +enum TSoundEngineState +{ + ESoundEngineNotInitialized, + ESoundEngineOpening, + ESoundEnginePlaying, + ESoundEnginePaused, + ESoundEngineStopped +}; + +class MSoundEngineObserver +{ +public: + virtual void PlaybackInitializedL() = 0; + virtual void PlaybackStartedL() = 0; + virtual void PlaybackStoppedL() = 0; + virtual void VolumeChanged(TUint aVolume, TUint aMaxVolume) = 0; +}; + + +/** + * This class handles all playback and audio associated resources that the application/client needs + */ +class CSoundEngine : public CBase +{ +public: + static CSoundEngine* NewL(CPodcastModel& aPodcastModel); + ~CSoundEngine(); + void OpenFileL(const TDesC& aFileName, TBool aPlayOnInit); + IMPORT_C void Play(); + IMPORT_C void Stop(TBool aMarkPlayed=ETrue); + IMPORT_C TTimeIntervalMicroSeconds Position(); + IMPORT_C void SetPosition(TUint aPos); + + IMPORT_C void Pause(TBool aOverrideState = EFalse); + + IMPORT_C TSoundEngineState State(); + IMPORT_C void AddObserver(MSoundEngineObserver* aObserver); + void RemoveObserver(MSoundEngineObserver* aObserver); + + const TFileName& LastFileName(); + +private: + void NotifyPlaybackStarted(); + void NotifyPlaybackStopped(); + void NotifyPlaybackInitialized(); + void NotifyVolumeChanged(); + +protected: + CSoundEngine(CPodcastModel& aPodcastModel); + void ConstructL(); + +private: + CPodcastModel& iPodcastModel; + TSoundEngineState iState; + RArray iObservers; + TFileName iLastOpenedFileName; + TBool iPlayOnInit; + TTimeIntervalMicroSeconds iMaxPos; +}; + +#endif // SOUND_ENGINE_H + diff -r 5f8e5adbbed9 -r 29cda98b007e engine/inc/debug.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/inc/debug.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,419 @@ +/* +* Copyright (c) 2007-2010 Sebastian Brannstrom, Lars Persson, EmbedDev AB +* +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* EmbedDev AB - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +// dbg_dp.h +// debug printouts + +/************************************************* + + USAGE + DP("Hi there"); + DP1("My name is %S", &name); + DPV1("My detailed info is %S", &detailedInfo); + DP_MSG(aMsg); + DP_MSG_COMPL(aMsg, r); + DP_EXC(aType); + + CUSTOMISATION + With SUPPORT_DP_CLIENT_SERVER_V2 defined, a + proper opcode type (default TOpcode) needs to + be specified. + + NOTE + This file may be included by many components + within one application and defining something + here will affect all such components. In such + cases it might be better to state a MACRO in + the intended component's MMP file. + +**************************************************/ + +#ifndef ___DBG_DP_H +#define ___DBG_DP_H + +// This file may be included butThese defines may be individual + +//#if defined (_DEBUG) && (__WINS__) +//#if defined _DEBUG +# define SUPPORT_DP_STANDARD +# define SUPPORT_DP_FILE +//#endif + +// #define SUPPORT_RDEBUG_PRINT +// #define SUPPORT_DP_VERBOSE +// #define SUPPORT_DP_THREAD_NAME +// #define SUPPORT_DP_CLIENT_SERVER_V2 +// #define SUPPORT_DP_EXCEPTION +// #define SUPPORT_DP_COMMDB + +// ------------------------------------------------- no need to modify + +#if defined (SUPPORT_RDEBUG_PRINT)\ + || defined (SUPPORT_DP_VERBOSE)\ + || defined(SUPPORT_DP_CLIENT_SERVER_V2)\ + || defined(SUPPORT_DP_EXCEPTION) +# define SUPPORT_DP_STANDARD +#endif + +#if defined(SUPPORT_RDEBUG_PRINT) +# include // RDebug +#endif + +#if defined(SUPPORT_DP_FILE) +# include +#endif + +#if defined(SUPPORT_DP_CLIENT_SERVER_V2) +# include "dbg_cmn.h" // TOpcode +#endif + +#if defined(SUPPORT_DP_COMMDB) +# include // TCommDbConnPref +#endif + +namespace Dbg +{ + +// ------------------------------------------------- file output +#ifdef SUPPORT_DP_FILE +_LIT(KLogDir, "podcatcher"); +_LIT(KLogFile, "debug.log"); +# define DPF(a); RFileLogger::WriteFormat(Dbg::KLogDir, Dbg::KLogFile, EFileLoggingModeAppend, _L("%S %s"), &s, L##a); +# define DPF1(a,b); RFileLogger::WriteFormat(Dbg::KLogDir, Dbg::KLogFile, EFileLoggingModeAppend, _L("%S " L##a), &s, b); +# define DPF2(a,b,c); RFileLogger::WriteFormat(Dbg::KLogDir, Dbg::KLogFile, EFileLoggingModeAppend, _L("%S " L##a), &s, b,c); +# define DPF3(a,b,c,d); RFileLogger::WriteFormat(Dbg::KLogDir, Dbg::KLogFile, EFileLoggingModeAppend, _L("%S " L##a), &s, b,c,d); +# define DPF4(a,b,c,d,e); RFileLogger::WriteFormat(Dbg::KLogDir, Dbg::KLogFile, EFileLoggingModeAppend, _L("%S " L##a), &s, b,c,d,e); +# define DPF5(a,b,c,d,e,f); RFileLogger::WriteFormat(Dbg::KLogDir, Dbg::KLogFile, EFileLoggingModeAppend, _L("%S " L##a), &s, b,c,d,e,f); +# define DPF6(a,b,c,d,e,f,g); RFileLogger::WriteFormat(Dbg::KLogDir, Dbg::KLogFile, EFileLoggingModeAppend, _L("%S " L##a), &s, b, c, d,e,f,g); +# define HEXDUMP(aHeader, aMargin, aPtr, aLen); RFileLogger::HexDump(Dbg::KLogDir, Dbg::KLogFile, EFileLoggingModeAppend, aHeader, aMargin, aPtr, aLen); +# define DPDT(dt); RFileLogger::WriteFormat(Dbg::KLogDir, Dbg::KLogFile, EFileLoggingModeAppend, _L("DateTime: %d-%d-%d %d:%d:%d "), dt.Year(), dt.Month()+1, dt.Day()+1, dt.Hour(), dt.Minute(), dt.Second() ); + +#else +# define DPF(a); +# define DPF1(a,b); +# define DPF2(a,b,c); +# define DPF3(a,b,c,d); +# define DPF4(a,b,c,d,e); +# define DPF5(a,b,c,d,e,f); +# define DPF6(a,b,c,d,e,f,g); +# define HEXDUMP(aHeader, aMargin, aPtr, aLen); +# define DPDT(dt); +#endif +// ------------------------------------------------- standard debugprint +#ifdef SUPPORT_DP_STANDARD + +inline void FormatThreadName(TFullName& aName) +{ + const TChar KLeftBracket('['); + const TChar KScope(':'); + TInt a = aName.LocateReverse(KLeftBracket); + if (a==KErrNotFound) + { return; } + TInt b = aName.Locate(KScope); + if (b==KErrNotFound || b=3001001). +** +** See also: [sqlite3_libversion()] and [sqlite3_libversion_number()]. +*/ +#define SQLITE_VERSION "3.5.4" +#define SQLITE_VERSION_NUMBER 3005004 + +/* +** CAPI3REF: Run-Time Library Version Numbers {F10020} +** +** {F10021} The sqlite3_libversion_number() interface returns an integer +** equal to [SQLITE_VERSION_NUMBER]. {END} The value returned +** by this routine should only be different from the header values +** if the application is compiled using an sqlite3.h header from a +** different version of SQLite than library. Cautious programmers might +** include a check in their application to verify that +** sqlite3_libversion_number() always returns the value +** [SQLITE_VERSION_NUMBER]. +** +** {F10022} The sqlite3_version[] string constant contains the text of the +** [SQLITE_VERSION] string. {F10023} The sqlite3_libversion() function returns +** a pointer to the sqlite3_version[] string constant. {END} The +** sqlite3_libversion() function +** is provided for DLL users who can only access functions and not +** constants within the DLL. +*/ +const char sqlite3_version[] = SQLITE_VERSION; +/*IMPORT_C*/ const char *sqlite3_libversion(void); +/*IMPORT_C*/ int sqlite3_libversion_number(void); + + +void LogMessage(char *message); + +/* +** CAPI3REF: Test To See If The Library Is Threadsafe {F10100} +** +** {F10101} The sqlite3_threadsafe() routine returns nonzero +** if SQLite was compiled with its mutexes enabled or zero if +** SQLite was compiled with mutexes disabled. {END} If this +** routine returns false, then it is not safe for simultaneously +** running threads to both invoke SQLite interfaces. +** +** Really all this routine does is return true if SQLite was +** compiled with the -DSQLITE_THREADSAFE=1 option and false if +** compiled with -DSQLITE_THREADSAFE=0. If SQLite uses an +** application-defined mutex subsystem, malloc subsystem, collating +** sequence, VFS, SQL function, progress callback, commit hook, +** extension, or other accessories and these add-ons are not +** threadsafe, then clearly the combination will not be threadsafe +** either. Hence, this routine never reports that the library +** is guaranteed to be threadsafe, only when it is guaranteed not +** to be. +*/ +/*IMPORT_C*/ int sqlite3_threadsafe(void); + +/* +** CAPI3REF: Database Connection Handle {F12000} +** +** Each open SQLite database is represented by pointer to an instance of the +** opaque structure named "sqlite3". It is useful to think of an sqlite3 +** pointer as an object. The [sqlite3_open()], [sqlite3_open16()], and +** [sqlite3_open_v2()] interfaces are its constructors +** and [sqlite3_close()] is its destructor. There are many other interfaces +** (such as [sqlite3_prepare_v2()], [sqlite3_create_function()], and +** [sqlite3_busy_timeout()] to name but three) that are methods on this +** object. +*/ +typedef struct sqlite3 sqlite3; + + +/* +** CAPI3REF: 64-Bit Integer Types {F10200} +** +** Because there is no cross-platform way to specify such types +** SQLite includes typedefs for 64-bit signed and unsigned integers. +** {F10201} The sqlite_int64 and sqlite3_int64 types specify a +** 64-bit signed integer. {F10202} The sqlite_uint64 and +** sqlite3_uint64 types specify a 64-bit unsigned integer. {END} +** +** The sqlite3_int64 and sqlite3_uint64 are the preferred type +** definitions. The sqlite_int64 and sqlite_uint64 types are +** supported for backwards compatibility only. +*/ +#ifdef SQLITE_INT64_TYPE + typedef SQLITE_INT64_TYPE sqlite_int64; + typedef unsigned SQLITE_INT64_TYPE sqlite_uint64; +#elif defined(_MSC_VER) || defined(__BORLANDC__) + typedef __int64 sqlite_int64; + typedef unsigned __int64 sqlite_uint64; +#else + typedef long long int sqlite_int64; + typedef unsigned long long int sqlite_uint64; +#endif +typedef sqlite_int64 sqlite3_int64; +typedef sqlite_uint64 sqlite3_uint64; + +/* +** If compiling for a processor that lacks floating point support, +** substitute integer for floating-point +*/ +#ifdef SQLITE_OMIT_FLOATING_POINT +# define double sqlite3_int64 +#endif + +/* +** CAPI3REF: Closing A Database Connection {F12010} +** +** {F12011} The sqlite3_close() interfaces destroys an [sqlite3] object +** allocated by a prior call to [sqlite3_open()], [sqlite3_open16()], or +** [sqlite3_open_v2()]. {F12012} Sqlite3_close() releases all +** memory used by the connection and closes all open files. {END}. +** +** {F12013} If the database connection contains +** [sqlite3_stmt | prepared statements] that have not been finalized +** by [sqlite3_finalize()], then sqlite3_close() returns SQLITE_BUSY +** and leaves the connection open. {F12014} Giving sqlite3_close() +** a NULL pointer is a harmless no-op. {END} +** +** {U12015} Passing this routine a database connection that has already been +** closed results in undefined behavior. {U12016} If other interfaces that +** reference the same database connection are pending (either in the +** same thread or in different threads) when this routine is called, +** then the behavior is undefined and is almost certainly undesirable. +*/ +/*IMPORT_C*/ int sqlite3_close(sqlite3 *); + +/* +** The type for a callback function. +** This is legacy and deprecated. It is included for historical +** compatibility and is not documented. +*/ +typedef int (*sqlite3_callback)(void*,int,char**, char**); + +/* +** CAPI3REF: One-Step Query Execution Interface {F12100} +** +** {F12101} The sqlite3_exec() interface evaluates zero or more +** UTF-8 encoded, semicolon-separated SQL statements in the zero-terminated +** string of its second argument. {F12102} The SQL +** statements are evaluated in the context of the database connection +** specified by in the first argument. +** {F12103} SQL statements are prepared one by one using +** [sqlite3_prepare()] or the equivalent, evaluated +** using one or more calls to [sqlite3_step()], then destroyed +** using [sqlite3_finalize()]. {F12104} The return value of +** sqlite3_exec() is SQLITE_OK if all SQL statement run +** successfully. +** +** {F12105} If one or more of the SQL statements handed to +** sqlite3_exec() are queries, then +** the callback function specified by the 3rd parameter is +** invoked once for each row of the query result. {F12106} +** If the callback returns a non-zero value then the query +** is aborted, all subsequent SQL statements +** are skipped and the sqlite3_exec() function returns the [SQLITE_ABORT]. +** +** {F12107} The 4th parameter to sqlite3_exec() is an arbitrary pointer +** that is passed through to the callback function as its first parameter. +** +** {F12108} The 2nd parameter to the callback function is the number of +** columns in the query result. {F12109} The 3rd parameter to the callback +** is an array of pointers to strings holding the values for each column +** as extracted using [sqlite3_column_text()]. NULL values in the result +** set result in a NULL pointer. All other value are in their UTF-8 +** string representation. {F12117} +** The 4th parameter to the callback is an array of strings +** obtained using [sqlite3_column_name()] and holding +** the names of each column, also in UTF-8. +** +** {F12110} The callback function may be NULL, even for queries. A NULL +** callback is not an error. It just means that no callback +** will be invoked. +** +** {F12112} If an error occurs while parsing or evaluating the SQL +** then an appropriate error message is written into memory obtained +** from [sqlite3_malloc()] and *errmsg is made to point to that message +** assuming errmsg is not NULL. +** {U12113} The calling function is responsible for freeing the memory +** using [sqlite3_free()]. +** {F12116} If [sqlite3_malloc()] fails while attempting to generate +** the error message, *errmsg is set to NULL. +** {F12114} If errmsg is NULL then no attempt is made to generate an +** error message. Is the return code SQLITE_NOMEM or the original +** error code? What happens if there are multiple errors? +** Do we get code for the first error, or is the choice of reported +** error arbitrary? +** +** {F12115} The return value is is SQLITE_OK if there are no errors and +** some other [SQLITE_OK | return code] if there is an error. +** The particular return value depends on the type of error. {END} +*/ +/*IMPORT_C*/ int sqlite3_exec( + sqlite3*, /* An open database */ + const char *sql, /* SQL to be evaluted */ + int (*callback)(void*,int,char**,char**), /* Callback function */ + void *, /* 1st argument to callback */ + char **errmsg /* Error msg written here */ +); + +/* +** CAPI3REF: Result Codes {F10210} +** KEYWORDS: SQLITE_OK +** +** Many SQLite functions return an integer result code from the set shown +** above in order to indicates success or failure. +** +** {F10211} The result codes shown here are the only ones returned +** by SQLite in its default configuration. {F10212} However, the +** [sqlite3_extended_result_codes()] API can be used to set a database +** connectoin to return more detailed result codes. {END} +** +** See also: [SQLITE_IOERR_READ | extended result codes] +** +*/ +#define SQLITE_OK 0 /* Successful result */ +/* beginning-of-error-codes */ +#define SQLITE_ERROR 1 /* SQL error or missing database */ +#define SQLITE_INTERNAL 2 /* Internal logic error in SQLite */ +#define SQLITE_PERM 3 /* Access permission denied */ +#define SQLITE_ABORT 4 /* Callback routine requested an abort */ +#define SQLITE_BUSY 5 /* The database file is locked */ +#define SQLITE_LOCKED 6 /* A table in the database is locked */ +#define SQLITE_NOMEM 7 /* A malloc() failed */ +#define SQLITE_READONLY 8 /* Attempt to write a readonly database */ +#define SQLITE_INTERRUPT 9 /* Operation terminated by sqlite3_interrupt()*/ +#define SQLITE_IOERR 10 /* Some kind of disk I/O error occurred */ +#define SQLITE_CORRUPT 11 /* The database disk image is malformed */ +#define SQLITE_NOTFOUND 12 /* NOT USED. Table or record not found */ +#define SQLITE_FULL 13 /* Insertion failed because database is full */ +#define SQLITE_CANTOPEN 14 /* Unable to open the database file */ +#define SQLITE_PROTOCOL 15 /* NOT USED. Database lock protocol error */ +#define SQLITE_EMPTY 16 /* Database is empty */ +#define SQLITE_SCHEMA 17 /* The database schema changed */ +#define SQLITE_TOOBIG 18 /* String or BLOB exceeds size limit */ +#define SQLITE_CONSTRAINT 19 /* Abort due to constraint violation */ +#define SQLITE_MISMATCH 20 /* Data type mismatch */ +#define SQLITE_MISUSE 21 /* Library used incorrectly */ +#define SQLITE_NOLFS 22 /* Uses OS features not supported on host */ +#define SQLITE_AUTH 23 /* Authorization denied */ +#define SQLITE_FORMAT 24 /* Auxiliary database format error */ +#define SQLITE_RANGE 25 /* 2nd parameter to sqlite3_bind out of range */ +#define SQLITE_NOTADB 26 /* File opened that is not a database file */ +#define SQLITE_ROW 100 /* sqlite3_step() has another row ready */ +#define SQLITE_DONE 101 /* sqlite3_step() has finished executing */ +/* end-of-error-codes */ + +/* +** CAPI3REF: Extended Result Codes {F10220} +** +** In its default configuration, SQLite API routines return one of 26 integer +** [SQLITE_OK | result codes]. However, experience has shown that +** many of these result codes are too course-grained. They do not provide as +** much information about problems as programmers might like. In an effort to +** address this, newer versions of SQLite (version 3.3.8 and later) include +** support for additional result codes that provide more detailed information +** about errors. {F10221} The extended result codes are enabled or disabled +** for each database connection using the [sqlite3_extended_result_codes()] +** API. {END} +** +** Some of the available extended result codes are listed above. +** We expect the number of extended result codes will be expand +** over time. {U10422} Software that uses extended result codes should expect +** to see new result codes in future releases of SQLite. {END} +** +** {F10223} The symbolic name for an extended result code always contains +** a related primary result code as a prefix. {F10224} Primary result +** codes contain a single "_" character. {F10225} Extended result codes +** contain two or more "_" characters. {F10226} The numeric value of an +** extended result code can be converted to its +** corresponding primary result code by masking off the lower 8 bytes. {END} +** +** The SQLITE_OK result code will never be extended. It will always +** be exactly zero. +*/ +#define SQLITE_IOERR_READ (SQLITE_IOERR | (1<<8)) +#define SQLITE_IOERR_SHORT_READ (SQLITE_IOERR | (2<<8)) +#define SQLITE_IOERR_WRITE (SQLITE_IOERR | (3<<8)) +#define SQLITE_IOERR_FSYNC (SQLITE_IOERR | (4<<8)) +#define SQLITE_IOERR_DIR_FSYNC (SQLITE_IOERR | (5<<8)) +#define SQLITE_IOERR_TRUNCATE (SQLITE_IOERR | (6<<8)) +#define SQLITE_IOERR_FSTAT (SQLITE_IOERR | (7<<8)) +#define SQLITE_IOERR_UNLOCK (SQLITE_IOERR | (8<<8)) +#define SQLITE_IOERR_RDLOCK (SQLITE_IOERR | (9<<8)) +#define SQLITE_IOERR_DELETE (SQLITE_IOERR | (10<<8)) +#define SQLITE_IOERR_BLOCKED (SQLITE_IOERR | (11<<8)) +#define SQLITE_IOERR_NOMEM (SQLITE_IOERR | (12<<8)) + +/* +** CAPI3REF: Flags For File Open Operations {F10230} +** +** {F10231} Some combination of the these bit values are used as the +** third argument to the [sqlite3_open_v2()] interface and +** as fourth argument to the xOpen method of the +** [sqlite3_vfs] object. +*/ +#define SQLITE_OPEN_READONLY 0x00000001 +#define SQLITE_OPEN_READWRITE 0x00000002 +#define SQLITE_OPEN_CREATE 0x00000004 +#define SQLITE_OPEN_DELETEONCLOSE 0x00000008 +#define SQLITE_OPEN_EXCLUSIVE 0x00000010 +#define SQLITE_OPEN_MAIN_DB 0x00000100 +#define SQLITE_OPEN_TEMP_DB 0x00000200 +#define SQLITE_OPEN_TRANSIENT_DB 0x00000400 +#define SQLITE_OPEN_MAIN_JOURNAL 0x00000800 +#define SQLITE_OPEN_TEMP_JOURNAL 0x00001000 +#define SQLITE_OPEN_SUBJOURNAL 0x00002000 +#define SQLITE_OPEN_MASTER_JOURNAL 0x00004000 + +/* +** CAPI3REF: Device Characteristics {F10240} +** +** {F10241} The xDeviceCapabilities method of the [sqlite3_io_methods] +** object returns an integer which is a vector of the these +** bit values expressing I/O characteristics of the mass storage +** device that holds the file that the [sqlite3_io_methods] +** refers to. {END} +** +** {F10242} The SQLITE_IOCAP_ATOMIC property means that all writes of +** any size are atomic. {F10243} The SQLITE_IOCAP_ATOMICnnn values +** mean that writes of blocks that are nnn bytes in size and +** are aligned to an address which is an integer multiple of +** nnn are atomic. {F10244} The SQLITE_IOCAP_SAFE_APPEND value means +** that when data is appended to a file, the data is appended +** first then the size of the file is extended, never the other +** way around. {F10245} The SQLITE_IOCAP_SEQUENTIAL property means that +** information is written to disk in the same order as calls +** to xWrite(). +*/ +#define SQLITE_IOCAP_ATOMIC 0x00000001 +#define SQLITE_IOCAP_ATOMIC512 0x00000002 +#define SQLITE_IOCAP_ATOMIC1K 0x00000004 +#define SQLITE_IOCAP_ATOMIC2K 0x00000008 +#define SQLITE_IOCAP_ATOMIC4K 0x00000010 +#define SQLITE_IOCAP_ATOMIC8K 0x00000020 +#define SQLITE_IOCAP_ATOMIC16K 0x00000040 +#define SQLITE_IOCAP_ATOMIC32K 0x00000080 +#define SQLITE_IOCAP_ATOMIC64K 0x00000100 +#define SQLITE_IOCAP_SAFE_APPEND 0x00000200 +#define SQLITE_IOCAP_SEQUENTIAL 0x00000400 + +/* +** CAPI3REF: File Locking Levels {F10250} +** +** {F10251} SQLite uses one of the following integer values as the second +** argument to calls it makes to the xLock() and xUnlock() methods +** of an [sqlite3_io_methods] object. {END} +*/ +#define SQLITE_LOCK_NONE 0 +#define SQLITE_LOCK_SHARED 1 +#define SQLITE_LOCK_RESERVED 2 +#define SQLITE_LOCK_PENDING 3 +#define SQLITE_LOCK_EXCLUSIVE 4 + +/* +** CAPI3REF: Synchronization Type Flags {F10260} +** +** {F10261} When SQLite invokes the xSync() method of an +** [sqlite3_io_methods] object it uses a combination of the +** these integer values as the second argument. +** +** {F10262} When the SQLITE_SYNC_DATAONLY flag is used, it means that the +** sync operation only needs to flush data to mass storage. Inode +** information need not be flushed. {F10263} The SQLITE_SYNC_NORMAL means +** to use normal fsync() semantics. {F10264} The SQLITE_SYNC_FULL flag means +** to use Mac OS-X style fullsync instead of fsync(). +*/ +#define SQLITE_SYNC_NORMAL 0x00002 +#define SQLITE_SYNC_FULL 0x00003 +#define SQLITE_SYNC_DATAONLY 0x00010 + + +/* +** CAPI3REF: OS Interface Open File Handle {F11110} +** +** An [sqlite3_file] object represents an open file in the OS +** interface layer. Individual OS interface implementations will +** want to subclass this object by appending additional fields +** for their own use. The pMethods entry is a pointer to an +** [sqlite3_io_methods] object that defines methods for performing +** I/O operations on the open file. +*/ +typedef struct sqlite3_file sqlite3_file; +struct sqlite3_file { + int isOpen; + //const struct sqlite3_io_methods *pMethods; /* Methods for an open file */ +}; + +/* +** CAPI3REF: OS Interface File Virtual Methods Object {F11120} +** +** Every file opened by the [sqlite3_vfs] xOpen method contains a pointer to +** an instance of the this object. This object defines the +** methods used to perform various operations against the open file. +** +** The flags argument to xSync may be one of [SQLITE_SYNC_NORMAL] or +** [SQLITE_SYNC_FULL]. The first choice is the normal fsync(). +* The second choice is an +** OS-X style fullsync. The SQLITE_SYNC_DATA flag may be ORed in to +** indicate that only the data of the file and not its inode needs to be +** synced. +** +** The integer values to xLock() and xUnlock() are one of +**
    +**
  • [SQLITE_LOCK_NONE], +**
  • [SQLITE_LOCK_SHARED], +**
  • [SQLITE_LOCK_RESERVED], +**
  • [SQLITE_LOCK_PENDING], or +**
  • [SQLITE_LOCK_EXCLUSIVE]. +**
+** xLock() increases the lock. xUnlock() decreases the lock. +** The xCheckReservedLock() method looks +** to see if any database connection, either in this +** process or in some other process, is holding an RESERVED, +** PENDING, or EXCLUSIVE lock on the file. It returns true +** if such a lock exists and false if not. +** +** The xFileControl() method is a generic interface that allows custom +** VFS implementations to directly control an open file using the +** [sqlite3_file_control()] interface. The second "op" argument +** is an integer opcode. The third +** argument is a generic pointer which is intended to be a pointer +** to a structure that may contain arguments or space in which to +** write return values. Potential uses for xFileControl() might be +** functions to enable blocking locks with timeouts, to change the +** locking strategy (for example to use dot-file locks), to inquire +** about the status of a lock, or to break stale locks. The SQLite +** core reserves opcodes less than 100 for its own use. +** A [SQLITE_FCNTL_LOCKSTATE | list of opcodes] less than 100 is available. +** Applications that define a custom xFileControl method should use opcodes +** greater than 100 to avoid conflicts. +** +** The xSectorSize() method returns the sector size of the +** device that underlies the file. The sector size is the +** minimum write that can be performed without disturbing +** other bytes in the file. The xDeviceCharacteristics() +** method returns a bit vector describing behaviors of the +** underlying device: +** +**
    +**
  • [SQLITE_IOCAP_ATOMIC] +**
  • [SQLITE_IOCAP_ATOMIC512] +**
  • [SQLITE_IOCAP_ATOMIC1K] +**
  • [SQLITE_IOCAP_ATOMIC2K] +**
  • [SQLITE_IOCAP_ATOMIC4K] +**
  • [SQLITE_IOCAP_ATOMIC8K] +**
  • [SQLITE_IOCAP_ATOMIC16K] +**
  • [SQLITE_IOCAP_ATOMIC32K] +**
  • [SQLITE_IOCAP_ATOMIC64K] +**
  • [SQLITE_IOCAP_SAFE_APPEND] +**
  • [SQLITE_IOCAP_SEQUENTIAL] +**
+** +** The SQLITE_IOCAP_ATOMIC property means that all writes of +** any size are atomic. The SQLITE_IOCAP_ATOMICnnn values +** mean that writes of blocks that are nnn bytes in size and +** are aligned to an address which is an integer multiple of +** nnn are atomic. The SQLITE_IOCAP_SAFE_APPEND value means +** that when data is appended to a file, the data is appended +** first then the size of the file is extended, never the other +** way around. The SQLITE_IOCAP_SEQUENTIAL property means that +** information is written to disk in the same order as calls +** to xWrite(). +*/ +/*typedef struct sqlite3_io_methods sqlite3_io_methods; +struct sqlite3_io_methods { + int iVersion; + int (*xClose)(sqlite3_file*); + int (*xRead)(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst); + int (*xWrite)(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst); + int (*xTruncate)(sqlite3_file*, sqlite3_int64 size); + int (*xSync)(sqlite3_file*, int flags); + int (*xFileSize)(sqlite3_file*, sqlite3_int64 *pSize); + int (*xLock)(sqlite3_file*, int); + int (*xUnlock)(sqlite3_file*, int); + int (*xCheckReservedLock)(sqlite3_file*); + int (*xFileControl)(sqlite3_file*, int op, void *pArg); + int (*xSectorSize)(sqlite3_file*); + int (*xDeviceCharacteristics)(sqlite3_file*); +};*/ + +/* +** CAPI3REF: Standard File Control Opcodes {F11310} +** +** These integer constants are opcodes for the xFileControl method +** of the [sqlite3_io_methods] object and to the [sqlite3_file_control()] +** interface. +** +** {F11311} The [SQLITE_FCNTL_LOCKSTATE] opcode is used for debugging. This +** opcode cases the xFileControl method to write the current state of +** the lock (one of [SQLITE_LOCK_NONE], [SQLITE_LOCK_SHARED], +** [SQLITE_LOCK_RESERVED], [SQLITE_LOCK_PENDING], or [SQLITE_LOCK_EXCLUSIVE]) +** into an integer that the pArg argument points to. {F11312} This capability +** is used during testing and only needs to be supported when SQLITE_TEST +** is defined. +*/ +#define SQLITE_FCNTL_LOCKSTATE 1 + +/* +** CAPI3REF: Mutex Handle {F17110} +** +** The mutex module within SQLite defines [sqlite3_mutex] to be an +** abstract type for a mutex object. {F17111} The SQLite core never looks +** at the internal representation of an [sqlite3_mutex]. {END} It only +** deals with pointers to the [sqlite3_mutex] object. +** +** Mutexes are created using [sqlite3_mutex_alloc()]. +*/ +typedef struct sqlite3_mutex sqlite3_mutex; + +/* +** CAPI3REF: OS Interface Object {F11140} +** +** An instance of this object defines the interface between the +** SQLite core and the underlying operating system. The "vfs" +** in the name of the object stands for "virtual file system". +** +** The iVersion field is initially 1 but may be larger for future +** versions of SQLite. Additional fields may be appended to this +** object when the iVersion value is increased. +** +** The szOsFile field is the size of the subclassed [sqlite3_file] +** structure used by this VFS. mxPathname is the maximum length of +** a pathname in this VFS. +** +** Registered vfs modules are kept on a linked list formed by +** the pNext pointer. The [sqlite3_vfs_register()] +** and [sqlite3_vfs_unregister()] interfaces manage this list +** in a thread-safe way. The [sqlite3_vfs_find()] interface +** searches the list. +** +** The pNext field is the only fields in the sqlite3_vfs +** structure that SQLite will ever modify. SQLite will only access +** or modify this field while holding a particular static mutex. +** The application should never modify anything within the sqlite3_vfs +** object once the object has been registered. +** +** The zName field holds the name of the VFS module. The name must +** be unique across all VFS modules. +** +** {F11141} SQLite will guarantee that the zFilename string passed to +** xOpen() is a full pathname as generated by xFullPathname() and +** that the string will be valid and unchanged until xClose() is +** called. {END} So the [sqlite3_file] can store a pointer to the +** filename if it needs to remember the filename for some reason. +** +** {F11142} The flags argument to xOpen() includes all bits set in +** the flags argument to [sqlite3_open_v2()]. Or if [sqlite3_open()] +** or [sqlite3_open16()] is used, then flags includes at least +** [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]. {END} +** If xOpen() opens a file read-only then it sets *pOutFlags to +** include [SQLITE_OPEN_READONLY]. Other bits in *pOutFlags may be +** set. +** +** {F11143} SQLite will also add one of the following flags to the xOpen() +** call, depending on the object being opened: +** +**
    +**
  • [SQLITE_OPEN_MAIN_DB] +**
  • [SQLITE_OPEN_MAIN_JOURNAL] +**
  • [SQLITE_OPEN_TEMP_DB] +**
  • [SQLITE_OPEN_TEMP_JOURNAL] +**
  • [SQLITE_OPEN_TRANSIENT_DB] +**
  • [SQLITE_OPEN_SUBJOURNAL] +**
  • [SQLITE_OPEN_MASTER_JOURNAL] +**
{END} +** +** The file I/O implementation can use the object type flags to +** changes the way it deals with files. For example, an application +** that does not care about crash recovery or rollback, might make +** the open of a journal file a no-op. Writes to this journal are +** also a no-op. Any attempt to read the journal return SQLITE_IOERR. +** Or the implementation might recognize the a database file will +** be doing page-aligned sector reads and writes in a random order +** and set up its I/O subsystem accordingly. +** +** {F11144} SQLite might also add one of the following flags to the xOpen +** method: +** +**
    +**
  • [SQLITE_OPEN_DELETEONCLOSE] +**
  • [SQLITE_OPEN_EXCLUSIVE] +**
+** +** {F11145} The [SQLITE_OPEN_DELETEONCLOSE] flag means the file should be +** deleted when it is closed. {F11146} The [SQLITE_OPEN_DELETEONCLOSE] +** will be set for TEMP databases, journals and for subjournals. +** {F11147} The [SQLITE_OPEN_EXCLUSIVE] flag means the file should be opened +** for exclusive access. This flag is set for all files except +** for the main database file. {END} +** +** {F11148} At least szOsFile bytes of memory is allocated by SQLite +** to hold the [sqlite3_file] structure passed as the third +** argument to xOpen. {END} The xOpen method does not have to +** allocate the structure; it should just fill it in. +** +** {F11149} The flags argument to xAccess() may be [SQLITE_ACCESS_EXISTS] +** to test for the existance of a file, +** or [SQLITE_ACCESS_READWRITE] to test to see +** if a file is readable and writable, or [SQLITE_ACCESS_READ] +** to test to see if a file is at least readable. {END} The file can be a +** directory. +** +** {F11150} SQLite will always allocate at least mxPathname+1 byte for +** the output buffers for xGetTempname and xFullPathname. {F11151} The exact +** size of the output buffer is also passed as a parameter to both +** methods. {END} If the output buffer is not large enough, SQLITE_CANTOPEN +** should be returned. As this is handled as a fatal error by SQLite, +** vfs implementations should endeavor to prevent this by setting +** mxPathname to a sufficiently large value. +** +** The xRandomness(), xSleep(), and xCurrentTime() interfaces +** are not strictly a part of the filesystem, but they are +** included in the VFS structure for completeness. +** The xRandomness() function attempts to return nBytes bytes +** of good-quality randomness into zOut. The return value is +** the actual number of bytes of randomness obtained. The +** xSleep() method cause the calling thread to sleep for at +** least the number of microseconds given. The xCurrentTime() +** method returns a Julian Day Number for the current date and +** time. +*/ +typedef struct sqlite3_vfs sqlite3_vfs; +struct sqlite3_vfs { + int iVersion; /* Structure version number */ + int szOsFile; /* Size of subclassed sqlite3_file */ + int mxPathname; /* Maximum file pathname length */ + sqlite3_vfs *pNext; /* Next registered VFS */ + const char *zName; /* Name of this virtual file system */ + void *pAppData; /* Pointer to application-specific data */ +/* int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*, + int flags, int *pOutFlags); + int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir); + int (*xAccess)(sqlite3_vfs*, const char *zName, int flags); + int (*xGetTempname)(sqlite3_vfs*, int nOut, char *zOut); + int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut); + void *(*xDlOpen)(sqlite3_vfs*, const char *zFilename); + void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg); + void *(*xDlSym)(sqlite3_vfs*,void*, const char *zSymbol); + void (*xDlClose)(sqlite3_vfs*, void*); + int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut); + int (*xSleep)(sqlite3_vfs*, int microseconds); + int (*xCurrentTime)(sqlite3_vfs*, double*);*/ + /* New fields may be appended in figure versions. The iVersion + ** value will increment whenever this happens. */ +}; + +/* +** CAPI3REF: Flags for the xAccess VFS method {F11190} +** +** {F11191} These integer constants can be used as the third parameter to +** the xAccess method of an [sqlite3_vfs] object. {END} They determine +** the kind of what kind of permissions the xAccess method is +** looking for. {F11192} With SQLITE_ACCESS_EXISTS, the xAccess method +** simply checks to see if the file exists. {F11193} With +** SQLITE_ACCESS_READWRITE, the xAccess method checks to see +** if the file is both readable and writable. {F11194} With +** SQLITE_ACCESS_READ the xAccess method +** checks to see if the file is readable. +*/ +#define SQLITE_ACCESS_EXISTS 0 +#define SQLITE_ACCESS_READWRITE 1 +#define SQLITE_ACCESS_READ 2 + +/* +** CAPI3REF: Enable Or Disable Extended Result Codes {F12200} +** +** {F12201} The sqlite3_extended_result_codes() routine enables or disables the +** [SQLITE_IOERR_READ | extended result codes] feature on a database +** connection if its 2nd parameter is +** non-zero or zero, respectively. {F12202} +** By default, SQLite API routines return one of only 26 integer +** [SQLITE_OK | result codes]. {F12203} When extended result codes +** are enabled by this routine, the repetoire of result codes can be +** much larger and can (hopefully) provide more detailed information +** about the cause of an error. +** +** {F12204} The second argument is a boolean value that turns extended result +** codes on and off. {F12205} Extended result codes are off by default for +** backwards compatibility with older versions of SQLite. +*/ +/*IMPORT_C*/ int sqlite3_extended_result_codes(sqlite3*, int onoff); + +/* +** CAPI3REF: Last Insert Rowid {F12220} +** +** {F12221} Each entry in an SQLite table has a unique 64-bit signed +** integer key called the "rowid". {F12222} The rowid is always available +** as an undeclared column named ROWID, OID, or _ROWID_ as long as those +** names are not also used by explicitly declared columns. {F12223} If +** the table has a column of type INTEGER PRIMARY KEY then that column +** is another an alias for the rowid. +** +** {F12224} This routine returns the rowid of the most recent +** successful INSERT into the database from the database connection +** shown in the first argument. {F12225} If no successful inserts +** have ever occurred on this database connection, zero is returned. +** +** {F12226} If an INSERT occurs within a trigger, then the rowid of the +** inserted row is returned by this routine as long as the trigger +** is running. {F12227} But once the trigger terminates, the value returned +** by this routine reverts to the last value inserted before the +** trigger fired. +** +** {F12228} An INSERT that fails due to a constraint violation is not a +** successful insert and does not change the value returned by this +** routine. {F12229} Thus INSERT OR FAIL, INSERT OR IGNORE, INSERT OR ROLLBACK, +** and INSERT OR ABORT make no changes to the return value of this +** routine when their insertion fails. {F12231} When INSERT OR REPLACE +** encounters a constraint violation, it does not fail. The +** INSERT continues to completion after deleting rows that caused +** the constraint problem so INSERT OR REPLACE will always change +** the return value of this interface. +** +** {UF12232} If another thread does a new insert on the same database connection +** while this routine is running and thus changes the last insert rowid, +** then the return value of this routine is undefined. +*/ +/*IMPORT_C*/ sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*); + +/* +** CAPI3REF: Count The Number Of Rows Modified {F12240} +** +** {F12241} This function returns the number of database rows that were changed +** or inserted or deleted by the most recently completed SQL statement +** on the connection specified by the first parameter. {F12242} Only +** changes that are directly specified by the INSERT, UPDATE, or +** DELETE statement are counted. Auxiliary changes caused by +** triggers are not counted. {F12243} Use the [sqlite3_total_changes()] function +** to find the total number of changes including changes caused by triggers. +** +** {F12244} Within the body of a trigger, the sqlite3_changes() interface +** can be called to find the number of +** changes in the most recently completed INSERT, UPDATE, or DELETE +** statement within the body of the same trigger. +** +** {F12245} All changes are counted, even if they are later undone by a +** ROLLBACK or ABORT. {F12246} Except, changes associated with creating and +** dropping tables are not counted. +** +** {F12247} If a callback invokes [sqlite3_exec()] or [sqlite3_step()] +** recursively, then the changes in the inner, recursive call are +** counted together with the changes in the outer call. +** +** {F12248} SQLite implements the command "DELETE FROM table" without +** a WHERE clause by dropping and recreating the table. (This is much +** faster than going through and deleting individual elements from the +** table.) Because of this optimization, the change count for +** "DELETE FROM table" will be zero regardless of the number of elements +** that were originally in the table. {F12251} To get an accurate count +** of the number of rows deleted, use +** "DELETE FROM table WHERE 1" instead. +** +** {UF12252} If another thread makes changes on the same database connection +** while this routine is running then the return value of this routine +** is undefined. +*/ +/*IMPORT_C*/ int sqlite3_changes(sqlite3*); + +/* +** CAPI3REF: Total Number Of Rows Modified {F12260} +*** +** {F12261} This function returns the number of database rows that have been +** modified by INSERT, UPDATE or DELETE statements since the database handle +** was opened. {F12262} The count includes UPDATE, INSERT and DELETE +** statements executed as part of trigger programs. {F12263} All changes +** are counted as soon as the statement that makes them is completed +** (when the statement handle is passed to [sqlite3_reset()] or +** [sqlite3_finalize()]). {END} +** +** See also the [sqlite3_change()] interface. +** +** {F12265} SQLite implements the command "DELETE FROM table" without +** a WHERE clause by dropping and recreating the table. (This is much +** faster than going +** through and deleting individual elements form the table.) Because of +** this optimization, the change count for "DELETE FROM table" will be +** zero regardless of the number of elements that were originally in the +** table. To get an accurate count of the number of rows deleted, use +** "DELETE FROM table WHERE 1" instead. +** +** {U12264} If another thread makes changes on the same database connection +** while this routine is running then the return value of this routine +** is undefined. {END} +*/ +/*IMPORT_C*/ int sqlite3_total_changes(sqlite3*); + +/* +** CAPI3REF: Interrupt A Long-Running Query {F12270} +** +** {F12271} This function causes any pending database operation to abort and +** return at its earliest opportunity. {END} This routine is typically +** called in response to a user action such as pressing "Cancel" +** or Ctrl-C where the user wants a long query operation to halt +** immediately. +** +** {F12272} It is safe to call this routine from a thread different from the +** thread that is currently running the database operation. {U12273} But it +** is not safe to call this routine with a database connection that +** is closed or might close before sqlite3_interrupt() returns. +** +** If an SQL is very nearly finished at the time when sqlite3_interrupt() +** is called, then it might not have an opportunity to be interrupted. +** It might continue to completion. +** {F12274} The SQL operation that is interrupted will return +** [SQLITE_INTERRUPT]. {F12275} If the interrupted SQL operation is an +** INSERT, UPDATE, or DELETE that is inside an explicit transaction, +** then the entire transaction will be rolled back automatically. +** {F12276} A call to sqlite3_interrupt() has no effect on SQL statements +** that are started after sqlite3_interrupt() returns. +*/ +/*IMPORT_C*/ void sqlite3_interrupt(sqlite3*); + +/* +** CAPI3REF: Determine If An SQL Statement Is Complete {F10510} +** +** These routines are useful for command-line input to determine if the +** currently entered text seems to form complete a SQL statement or +** if additional input is needed before sending the text into +** SQLite for parsing. These routines return true if the input string +** appears to be a complete SQL statement. A statement is judged to be +** complete if it ends with a semicolon and is not a fragment of a +** CREATE TRIGGER statement. These routines do not parse the SQL and +** so will not detect syntactically incorrect SQL. +** +** {F10511} These functions return true if the given input string +** ends with a semicolon optionally followed by whitespace or +** comments. {F10512} For sqlite3_complete(), +** the parameter must be a zero-terminated UTF-8 string. {F10513} For +** sqlite3_complete16(), a zero-terminated machine byte order UTF-16 string +** is required. {F10514} These routines return false if the terminal +** semicolon is within a comment, a string literal or a quoted identifier +** (in other words if the final semicolon is not really a separate token +** but part of a larger token) or if the final semicolon is +** in between the BEGIN and END keywords of a CREATE TRIGGER statement. +** {END} +*/ +/*IMPORT_C*/ int sqlite3_complete(const char *sql); +/*IMPORT_C*/ int sqlite3_complete16(const void *sql); + +/* +** CAPI3REF: Register A Callback To Handle SQLITE_BUSY Errors {F12310} +** +** {F12311} This routine identifies a callback function that might be +** invoked whenever an attempt is made to open a database table +** that another thread or process has locked. +** {F12312} If the busy callback is NULL, then [SQLITE_BUSY] +** or [SQLITE_IOERR_BLOCKED] +** is returned immediately upon encountering the lock. +** {F12313} If the busy callback is not NULL, then the +** callback will be invoked with two arguments. {F12314} The +** first argument to the handler is a copy of the void* pointer which +** is the third argument to this routine. {F12315} The second argument to +** the handler is the number of times that the busy handler has +** been invoked for this locking event. {F12316} If the +** busy callback returns 0, then no additional attempts are made to +** access the database and [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED] is returned. +** {F12317} If the callback returns non-zero, then another attempt +** is made to open the database for reading and the cycle repeats. +** +** The presence of a busy handler does not guarantee that +** it will be invoked when there is lock contention. {F12319} +** If SQLite determines that invoking the busy handler could result in +** a deadlock, it will go ahead and return [SQLITE_BUSY] or +** [SQLITE_IOERR_BLOCKED] instead of invoking the +** busy handler. {END} +** Consider a scenario where one process is holding a read lock that +** it is trying to promote to a reserved lock and +** a second process is holding a reserved lock that it is trying +** to promote to an exclusive lock. The first process cannot proceed +** because it is blocked by the second and the second process cannot +** proceed because it is blocked by the first. If both processes +** invoke the busy handlers, neither will make any progress. Therefore, +** SQLite returns [SQLITE_BUSY] for the first process, hoping that this +** will induce the first process to release its read lock and allow +** the second process to proceed. +** +** {F12321} The default busy callback is NULL. {END} +** +** {F12322} The [SQLITE_BUSY] error is converted to [SQLITE_IOERR_BLOCKED] +** when SQLite is in the middle of a large transaction where all the +** changes will not fit into the in-memory cache. {F12323} SQLite will +** already hold a RESERVED lock on the database file, but it needs +** to promote this lock to EXCLUSIVE so that it can spill cache +** pages into the database file without harm to concurrent +** readers. {F12324} If it is unable to promote the lock, then the in-memory +** cache will be left in an inconsistent state and so the error +** code is promoted from the relatively benign [SQLITE_BUSY] to +** the more severe [SQLITE_IOERR_BLOCKED]. {F12325} This error code promotion +** forces an automatic rollback of the changes. {END} See the +** +** CorruptionFollowingBusyError wiki page for a discussion of why +** this is important. +** +** {F12326} Sqlite is re-entrant, so the busy handler may start a new +** query. {END} (It is not clear why anyone would every want to do this, +** but it is allowed, in theory.) {U12327} But the busy handler may not +** close the database. Closing the database from a busy handler will delete +** data structures out from under the executing query and will +** probably result in a segmentation fault or other runtime error. {END} +** +** {F12328} There can only be a single busy handler defined for each database +** connection. Setting a new busy handler clears any previous one. +** {F12329} Note that calling [sqlite3_busy_timeout()] will also set or clear +** the busy handler. +** +** {F12331} When operating in [sqlite3_enable_shared_cache | shared cache mode], +** only a single busy handler can be defined for each database file. +** So if two database connections share a single cache, then changing +** the busy handler on one connection will also change the busy +** handler in the other connection. {F12332} The busy handler is invoked +** in the thread that was running when the lock contention occurs. +*/ +/*IMPORT_C*/ int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*); + +/* +** CAPI3REF: Set A Busy Timeout {F12340} +** +** {F12341} This routine sets a [sqlite3_busy_handler | busy handler] +** that sleeps for a while when a +** table is locked. {F12342} The handler will sleep multiple times until +** at least "ms" milliseconds of sleeping have been done. {F12343} After +** "ms" milliseconds of sleeping, the handler returns 0 which +** causes [sqlite3_step()] to return [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED]. +** +** {F12344} Calling this routine with an argument less than or equal to zero +** turns off all busy handlers. +** +** {F12345} There can only be a single busy handler for a particular database +** connection. If another busy handler was defined +** (using [sqlite3_busy_handler()]) prior to calling +** this routine, that other busy handler is cleared. +*/ +/*IMPORT_C*/ int sqlite3_busy_timeout(sqlite3*, int ms); + +/* +** CAPI3REF: Convenience Routines For Running Queries {F12370} +** +** This next routine is a convenience wrapper around [sqlite3_exec()]. +** {F12371} Instead of invoking a user-supplied callback for each row of the +** result, this routine remembers each row of the result in memory +** obtained from [sqlite3_malloc()], then returns all of the result after the +** query has finished. {F12372} +** +** As an example, suppose the query result where this table: +** +** 
+**        Name        | Age
+**        -----------------------
+**        Alice       | 43
+**        Bob         | 28
+**        Cindy       | 21
+**
+** +** If the 3rd argument were &azResult then after the function returns +** azResult will contain the following data: +** +** 
+**        azResult[0] = "Name";
+**        azResult[1] = "Age";
+**        azResult[2] = "Alice";
+**        azResult[3] = "43";
+**        azResult[4] = "Bob";
+**        azResult[5] = "28";
+**        azResult[6] = "Cindy";
+**        azResult[7] = "21";
+**
+** +** Notice that there is an extra row of data containing the column +** headers. But the *nrow return value is still 3. *ncolumn is +** set to 2. In general, the number of values inserted into azResult +** will be ((*nrow) + 1)*(*ncolumn). +** +** {U12374} After the calling function has finished using the result, it should +** pass the result data pointer to sqlite3_free_table() in order to +** release the memory that was malloc-ed. Because of the way the +** [sqlite3_malloc()] happens, the calling function must not try to call +** [sqlite3_free()] directly. Only [sqlite3_free_table()] is able to release +** the memory properly and safely. {END} +** +** {F12373} The return value of this routine is the same as +** from [sqlite3_exec()]. +*/ +/*IMPORT_C*/ int sqlite3_get_table( + sqlite3*, /* An open database */ + const char *sql, /* SQL to be executed */ + char ***resultp, /* Result written to a char *[] that this points to */ + int *nrow, /* Number of result rows written here */ + int *ncolumn, /* Number of result columns written here */ + char **errmsg /* Error msg written here */ +); +/*IMPORT_C*/ void sqlite3_free_table(char **result); + +/* +** CAPI3REF: Formatted String Printing Functions {F17400} +** +** These routines are workalikes of the "printf()" family of functions +** from the standard C library. +** +** {F17401} The sqlite3_mprintf() and sqlite3_vmprintf() routines write their +** results into memory obtained from [sqlite3_malloc()]. +** {U17402} The strings returned by these two routines should be +** released by [sqlite3_free()]. {F17403} Both routines return a +** NULL pointer if [sqlite3_malloc()] is unable to allocate enough +** memory to hold the resulting string. +** +** {F17404} In sqlite3_snprintf() routine is similar to "snprintf()" from +** the standard C library. The result is written into the +** buffer supplied as the second parameter whose size is given by +** the first parameter. {END} Note that the order of the +** first two parameters is reversed from snprintf(). This is an +** historical accident that cannot be fixed without breaking +** backwards compatibility. {F17405} Note also that sqlite3_snprintf() +** returns a pointer to its buffer instead of the number of +** characters actually written into the buffer. {END} We admit that +** the number of characters written would be a more useful return +** value but we cannot change the implementation of sqlite3_snprintf() +** now without breaking compatibility. +** +** {F17406} As long as the buffer size is greater than zero, sqlite3_snprintf() +** guarantees that the buffer is always zero-terminated. {F17407} The first +** parameter "n" is the total size of the buffer, including space for +** the zero terminator. {END} So the longest string that can be completely +** written will be n-1 characters. +** +** These routines all implement some additional formatting +** options that are useful for constructing SQL statements. +** All of the usual printf formatting options apply. In addition, there +** is are "%q", "%Q", and "%z" options. +** +** {F17410} The %q option works like %s in that it substitutes a null-terminated +** string from the argument list. But %q also doubles every '\'' character. +** %q is designed for use inside a string literal. {END} By doubling each '\'' +** character it escapes that character and allows it to be inserted into +** the string. +** +** For example, so some string variable contains text as follows: +** +** 
+**  char *zText = "It's a happy day!";
+**
+** +** One can use this text in an SQL statement as follows: +** +** 
+**  char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES('%q')", zText);
+**  sqlite3_exec(db, zSQL, 0, 0, 0);
+**  sqlite3_free(zSQL);
+**
+** +** Because the %q format string is used, the '\'' character in zText +** is escaped and the SQL generated is as follows: +** +** 
+**  INSERT INTO table1 VALUES('It''s a happy day!')
+**
+** +** This is correct. Had we used %s instead of %q, the generated SQL +** would have looked like this: +** +** 
+**  INSERT INTO table1 VALUES('It's a happy day!');
+**
+** +** This second example is an SQL syntax error. As a general rule you +** should always use %q instead of %s when inserting text into a string +** literal. +** +** {F17411} The %Q option works like %q except it also adds single quotes around +** the outside of the total string. Or if the parameter in the argument +** list is a NULL pointer, %Q substitutes the text "NULL" (without single +** quotes) in place of the %Q option. {END} So, for example, one could say: +** +** 
+**  char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES(%Q)", zText);
+**  sqlite3_exec(db, zSQL, 0, 0, 0);
+**  sqlite3_free(zSQL);
+**
+** +** The code above will render a correct SQL statement in the zSQL +** variable even if the zText variable is a NULL pointer. +** +** {F17412} The "%z" formatting option works exactly like "%s" with the +** addition that after the string has been read and copied into +** the result, [sqlite3_free()] is called on the input string. {END} +*/ +/*IMPORT_C*/ char *sqlite3_mprintf(const char*,...); +/*IMPORT_C*/ char *sqlite3_snprintf(int,char*,const char*, ...); + +/* +** CAPI3REF: Memory Allocation Subsystem {F17300} +** +** {F17301} The SQLite core uses these three routines for all of its own +** internal memory allocation needs. {END} "Core" in the previous sentence +** does not include operating-system specific VFS implementation. The +** windows VFS uses native malloc and free for some operations. +** +** {F17302} The sqlite3_malloc() routine returns a pointer to a block +** of memory at least N bytes in length, where N is the parameter. +** {F17303} If sqlite3_malloc() is unable to obtain sufficient free +** memory, it returns a NULL pointer. {F17304} If the parameter N to +** sqlite3_malloc() is zero or negative then sqlite3_malloc() returns +** a NULL pointer. +** +** {F17305} Calling sqlite3_free() with a pointer previously returned +** by sqlite3_malloc() or sqlite3_realloc() releases that memory so +** that it might be reused. {F17306} The sqlite3_free() routine is +** a no-op if is called with a NULL pointer. Passing a NULL pointer +** to sqlite3_free() is harmless. {U17307} After being freed, memory +** should neither be read nor written. Even reading previously freed +** memory might result in a segmentation fault or other severe error. +** {U17309} Memory corruption, a segmentation fault, or other severe error +** might result if sqlite3_free() is called with a non-NULL pointer that +** was not obtained from sqlite3_malloc() or sqlite3_free(). +** +** {F17310} The sqlite3_realloc() interface attempts to resize a +** prior memory allocation to be at least N bytes, where N is the +** second parameter. The memory allocation to be resized is the first +** parameter. {F17311} If the first parameter to sqlite3_realloc() +** is a NULL pointer then its behavior is identical to calling +** sqlite3_malloc(N) where N is the second parameter to sqlite3_realloc(). +** {F17312} If the second parameter to sqlite3_realloc() is zero or +** negative then the behavior is exactly the same as calling +** sqlite3_free(P) where P is the first parameter to sqlite3_realloc(). +** {F17313} Sqlite3_realloc() returns a pointer to a memory allocation +** of at least N bytes in size or NULL if sufficient memory is unavailable. +** {F17314} If M is the size of the prior allocation, then min(N,M) bytes +** of the prior allocation are copied into the beginning of buffer returned +** by sqlite3_realloc() and the prior allocation is freed. +** {F17315} If sqlite3_realloc() returns NULL, then the prior allocation +** is not freed. +** +** {F17316} The memory returned by sqlite3_malloc() and sqlite3_realloc() +** is always aligned to at least an 8 byte boundary. {END} +** +** {F17381} The default implementation +** of the memory allocation subsystem uses the malloc(), realloc() +** and free() provided by the standard C library. {F17382} However, if +** SQLite is compiled with the following C preprocessor macro +** +**
SQLITE_MEMORY_SIZE=NNN
+** +** where NNN is an integer, then SQLite create a static +** array of at least NNN bytes in size and use that array +** for all of its dynamic memory allocation needs. {END} Additional +** memory allocator options may be added in future releases. +** +** In SQLite version 3.5.0 and 3.5.1, it was possible to define +** the SQLITE_OMIT_MEMORY_ALLOCATION which would cause the built-in +** implementation of these routines to be omitted. That capability +** is no longer provided. Only built-in memory allocators can be +** used. +** +** The windows OS interface layer calls +** the system malloc() and free() directly when converting +** filenames between the UTF-8 encoding used by SQLite +** and whatever filename encoding is used by the particular windows +** installation. Memory allocation errors are detected, but +** they are reported back as [SQLITE_CANTOPEN] or +** [SQLITE_IOERR] rather than [SQLITE_NOMEM]. +*/ +/*IMPORT_C*/ void *sqlite3_malloc(int); +/*IMPORT_C*/ void *sqlite3_realloc(void*, int); +/*IMPORT_C*/ void sqlite3_free(void*); + +/* +** CAPI3REF: Memory Allocator Statistics {F17370} +** +** In addition to the basic three allocation routines +** [sqlite3_malloc()], [sqlite3_free()], and [sqlite3_realloc()], +** the memory allocation subsystem included with the SQLite +** sources provides the interfaces shown here. +** +** {F17371} The sqlite3_memory_used() routine returns the +** number of bytes of memory currently outstanding (malloced but not freed). +** {F17372} The value returned by sqlite3_memory_used() includes +** any overhead added by SQLite, but not overhead added by the +** library malloc() that backs the sqlite3_malloc() implementation. +** {F17373} The sqlite3_memory_highwater() routines returns the +** maximum number of bytes that have been outstanding at any time +** since the highwater mark was last reset. +** {F17374} The byte count returned by sqlite3_memory_highwater() +** uses the same byte counting rules as sqlite3_memory_used(). {END} +** In other words, overhead added internally by SQLite is counted, +** but overhead from the underlying system malloc is not. +** {F17375} If the parameter to sqlite3_memory_highwater() is true, +** then the highwater mark is reset to the current value of +** sqlite3_memory_used() and the prior highwater mark (before the +** reset) is returned. {F17376} If the parameter to +** sqlite3_memory_highwater() is zero, then the highwater mark is +** unchanged. +*/ +/*IMPORT_C*/ sqlite3_int64 sqlite3_memory_used(void); +/*IMPORT_C*/ sqlite3_int64 sqlite3_memory_highwater(int resetFlag); + +/* +** CAPI3REF: Compile-Time Authorization Callbacks {F12500} +** +** {F12501} This routine registers a authorizer callback with a particular +** database connection, supplied in the first argument. {F12502} +** The authorizer callback is invoked as SQL statements are being compiled +** by [sqlite3_prepare()] or its variants [sqlite3_prepare_v2()], +** [sqlite3_prepare16()] and [sqlite3_prepare16_v2()]. {F12503} At various +** points during the compilation process, as logic is being created +** to perform various actions, the authorizer callback is invoked to +** see if those actions are allowed. The authorizer callback should +** return SQLITE_OK to allow the action, [SQLITE_IGNORE] to disallow the +** specific action but allow the SQL statement to continue to be +** compiled, or [SQLITE_DENY] to cause the entire SQL statement to be +** rejected with an error. {F12504} If the authorizer callback returns +** any value other than [SQLITE_IGNORE], [SQLITE_OK], or [SQLITE_DENY] +** then [sqlite3_prepare_v2()] or equivalent call that triggered +** the authorizer shall +** fail with an SQLITE_ERROR error code and an appropriate error message. {END} +** +** When the callback returns [SQLITE_OK], that means the operation +** requested is ok. {F12505} When the callback returns [SQLITE_DENY], the +** [sqlite3_prepare_v2()] or equivalent call that triggered the +** authorizer shall fail +** with an SQLITE_ERROR error code and an error message explaining that +** access is denied. {F12506} If the authorizer code (the 2nd parameter +** to the authorizer callback is anything other than [SQLITE_READ], then +** a return of [SQLITE_IGNORE] has the same effect as [SQLITE_DENY]. +** If the authorizer code is [SQLITE_READ] and the callback returns +** [SQLITE_IGNORE] then the prepared statement is constructed to +** insert a NULL value in place of the table column that would have +** been read if [SQLITE_OK] had been returned. {END} +** +** {F12510} The first parameter to the authorizer callback is a copy of +** the third parameter to the sqlite3_set_authorizer() interface. +** {F12511} The second parameter to the callback is an integer +** [SQLITE_COPY | action code] that specifies the particular action +** to be authorized. {END} The available action codes are +** [SQLITE_COPY | documented separately]. {F12512} The third through sixth +** parameters to the callback are zero-terminated strings that contain +** additional details about the action to be authorized. {END} +** +** An authorizer is used when preparing SQL statements from an untrusted +** source, to ensure that the SQL statements do not try to access data +** that they are not allowed to see, or that they do not try to +** execute malicious statements that damage the database. For +** example, an application may allow a user to enter arbitrary +** SQL queries for evaluation by a database. But the application does +** not want the user to be able to make arbitrary changes to the +** database. An authorizer could then be put in place while the +** user-entered SQL is being prepared that disallows everything +** except SELECT statements. +** +** {F12520} Only a single authorizer can be in place on a database connection +** at a time. Each call to sqlite3_set_authorizer overrides the +** previous call. {F12521} A NULL authorizer means that no authorization +** callback is invoked. {F12522} The default authorizer is NULL. {END} +** +** Note that the authorizer callback is invoked only during +** [sqlite3_prepare()] or its variants. {F12523} Authorization is not +** performed during statement evaluation in [sqlite3_step()]. {END} +*/ +/*IMPORT_C*/ int sqlite3_set_authorizer( + sqlite3*, + int (*xAuth)(void*,int,const char*,const char*,const char*,const char*), + void *pUserData +); + +/* +** CAPI3REF: Authorizer Return Codes {F12590} +** +** The [sqlite3_set_authorizer | authorizer callback function] must +** return either [SQLITE_OK] or one of these two constants in order +** to signal SQLite whether or not the action is permitted. See the +** [sqlite3_set_authorizer | authorizer documentation] for additional +** information. +*/ +#define SQLITE_DENY 1 /* Abort the SQL statement with an error */ +#define SQLITE_IGNORE 2 /* Don't allow access, but don't generate an error */ + +/* +** CAPI3REF: Authorizer Action Codes {F12550} +** +** The [sqlite3_set_authorizer()] interface registers a callback function +** that is invoked to authorizer certain SQL statement actions. {F12551} The +** second parameter to the callback is an integer code that specifies +** what action is being authorized. These are the integer action codes that +** the authorizer callback may be passed. {END} +** +** These action code values signify what kind of operation is to be +** authorized. {F12552} The 3rd and 4th parameters to the authorization +** callback function will be parameters or NULL depending on which of these +** codes is used as the second parameter. {F12553} The 5th parameter to the +** authorizer callback is the name of the database ("main", "temp", +** etc.) if applicable. {F12554} The 6th parameter to the authorizer callback +** is the name of the inner-most trigger or view that is responsible for +** the access attempt or NULL if this access attempt is directly from +** top-level SQL code. +*/ +/******************************************* 3rd ************ 4th ***********/ +#define SQLITE_CREATE_INDEX 1 /* Index Name Table Name */ +#define SQLITE_CREATE_TABLE 2 /* Table Name NULL */ +#define SQLITE_CREATE_TEMP_INDEX 3 /* Index Name Table Name */ +#define SQLITE_CREATE_TEMP_TABLE 4 /* Table Name NULL */ +#define SQLITE_CREATE_TEMP_TRIGGER 5 /* Trigger Name Table Name */ +#define SQLITE_CREATE_TEMP_VIEW 6 /* View Name NULL */ +#define SQLITE_CREATE_TRIGGER 7 /* Trigger Name Table Name */ +#define SQLITE_CREATE_VIEW 8 /* View Name NULL */ +#define SQLITE_DELETE 9 /* Table Name NULL */ +#define SQLITE_DROP_INDEX 10 /* Index Name Table Name */ +#define SQLITE_DROP_TABLE 11 /* Table Name NULL */ +#define SQLITE_DROP_TEMP_INDEX 12 /* Index Name Table Name */ +#define SQLITE_DROP_TEMP_TABLE 13 /* Table Name NULL */ +#define SQLITE_DROP_TEMP_TRIGGER 14 /* Trigger Name Table Name */ +#define SQLITE_DROP_TEMP_VIEW 15 /* View Name NULL */ +#define SQLITE_DROP_TRIGGER 16 /* Trigger Name Table Name */ +#define SQLITE_DROP_VIEW 17 /* View Name NULL */ +#define SQLITE_INSERT 18 /* Table Name NULL */ +#define SQLITE_PRAGMA 19 /* Pragma Name 1st arg or NULL */ +#define SQLITE_READ 20 /* Table Name Column Name */ +#define SQLITE_SELECT 21 /* NULL NULL */ +#define SQLITE_TRANSACTION 22 /* NULL NULL */ +#define SQLITE_UPDATE 23 /* Table Name Column Name */ +#define SQLITE_ATTACH 24 /* Filename NULL */ +#define SQLITE_DETACH 25 /* Database Name NULL */ +#define SQLITE_ALTER_TABLE 26 /* Database Name Table Name */ +#define SQLITE_REINDEX 27 /* Index Name NULL */ +#define SQLITE_ANALYZE 28 /* Table Name NULL */ +#define SQLITE_CREATE_VTABLE 29 /* Table Name Module Name */ +#define SQLITE_DROP_VTABLE 30 /* Table Name Module Name */ +#define SQLITE_FUNCTION 31 /* Function Name NULL */ +#define SQLITE_COPY 0 /* No longer used */ + +/* +** CAPI3REF: Tracing And Profiling Functions {F12280} +** +** These routines register callback functions that can be used for +** tracing and profiling the execution of SQL statements. +** +** {F12281} The callback function registered by sqlite3_trace() is invoked +** at the first [sqlite3_step()] for the evaluation of an SQL statement. +** {F12282} Only a single trace callback can be registered at a time. +** Each call to sqlite3_trace() overrides the previous. {F12283} A +** NULL callback for sqlite3_trace() disables tracing. {F12284} The +** first argument to the trace callback is a copy of the pointer which +** was the 3rd argument to sqlite3_trace. {F12285} The second argument +** to the trace callback is a zero-terminated UTF8 string containing +** the original text of the SQL statement as it was passed into +** [sqlite3_prepare_v2()] or the equivalent. {END} Note that the +** host parameter are not expanded in the SQL statement text. +** +** {F12287} The callback function registered by sqlite3_profile() is invoked +** as each SQL statement finishes. {F12288} The first parameter to the +** profile callback is a copy of the 3rd parameter to sqlite3_profile(). +** {F12289} The second parameter to the profile callback is a +** zero-terminated UTF-8 string that contains the complete text of +** the SQL statement as it was processed by [sqlite3_prepare_v2()] or +** the equivalent. {F12290} The third parameter to the profile +** callback is an estimate of the number of nanoseconds of +** wall-clock time required to run the SQL statement from start +** to finish. {END} +** +** The sqlite3_profile() API is currently considered experimental and +** is subject to change. +*/ +/*IMPORT_C*/ void *sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*); +/*IMPORT_C*/ void *sqlite3_profile(sqlite3*, + void(*xProfile)(void*,const char*,sqlite3_uint64), void*); + +/* +** CAPI3REF: Query Progress Callbacks {F12910} +** +** {F12911} This routine configures a callback function - the +** progress callback - that is invoked periodically during long +** running calls to [sqlite3_exec()], [sqlite3_step()] and +** [sqlite3_get_table()]. {END} An example use for this +** interface is to keep a GUI updated during a large query. +** +** {F12912} The progress callback is invoked once for every N virtual +** machine opcodes, where N is the second argument to this function. +** {F12913} The progress callback itself is identified by the third +** argument to this function. {F12914} The fourth argument to this +** function is a void pointer passed to the progress callback +** function each time it is invoked. {END} +** +** {F12915} If a call to [sqlite3_exec()], [sqlite3_step()], or +** [sqlite3_get_table()] results in fewer than N opcodes being executed, +** then the progress callback is never invoked. {END} +** +** {F12916} Only a single progress callback function may be registered for each +** open database connection. Every call to sqlite3_progress_handler() +** overwrites the results of the previous call. {F12917} +** To remove the progress callback altogether, pass NULL as the third +** argument to this function. {END} +** +** {F12918} If the progress callback returns a result other than 0, then +** the current query is immediately terminated and any database changes +** rolled back. {F12919} +** The containing [sqlite3_exec()], [sqlite3_step()], or +** [sqlite3_get_table()] call returns SQLITE_INTERRUPT. {END} This feature +** can be used, for example, to implement the "Cancel" button on a +** progress dialog box in a GUI. +*/ +/*IMPORT_C*/ void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*); + +/* +** CAPI3REF: Opening A New Database Connection {F12700} +** +** {F12701} These routines open an SQLite database file whose name +** is given by the filename argument. +** {F12702} The filename argument is interpreted as UTF-8 +** for [sqlite3_open()] and [sqlite3_open_v2()] and as UTF-16 +** in the native byte order for [sqlite3_open16()]. +** {F12703} An [sqlite3*] handle is returned in *ppDb, even +** if an error occurs. {F12723} (Exception: if SQLite is unable +** to allocate memory to hold the [sqlite3] object, a NULL will +** be written into *ppDb instead of a pointer to the [sqlite3] object.) +** {F12704} If the database is opened (and/or created) +** successfully, then [SQLITE_OK] is returned. {F12705} Otherwise an +** error code is returned. {F12706} The +** [sqlite3_errmsg()] or [sqlite3_errmsg16()] routines can be used to obtain +** an English language description of the error. +** +** {F12707} The default encoding for the database will be UTF-8 if +** [sqlite3_open()] or [sqlite3_open_v2()] is called and +** UTF-16 in the native byte order if [sqlite3_open16()] is used. +** +** {F12708} Whether or not an error occurs when it is opened, resources +** associated with the [sqlite3*] handle should be released by passing it +** to [sqlite3_close()] when it is no longer required. +** +** {F12709} The [sqlite3_open_v2()] interface works like [sqlite3_open()] +** except that it acccepts two additional parameters for additional control +** over the new database connection. {F12710} The flags parameter can be +** one of: +** +**
    +**
  1. [SQLITE_OPEN_READONLY] +**
  2. [SQLITE_OPEN_READWRITE] +**
  3. [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE] +**
+** +** {F12711} The first value opens the database read-only. +** {F12712} If the database does not previously exist, an error is returned. +** {F12713} The second option opens +** the database for reading and writing if possible, or reading only if +** if the file is write protected. {F12714} In either case the database +** must already exist or an error is returned. {F12715} The third option +** opens the database for reading and writing and creates it if it does +** not already exist. {F12716} +** The third options is behavior that is always used for [sqlite3_open()] +** and [sqlite3_open16()]. +** +** {F12717} If the filename is ":memory:", then an private +** in-memory database is created for the connection. {F12718} This in-memory +** database will vanish when the database connection is closed. {END} Future +** version of SQLite might make use of additional special filenames +** that begin with the ":" character. It is recommended that +** when a database filename really does begin with +** ":" that you prefix the filename with a pathname like "./" to +** avoid ambiguity. +** +** {F12719} If the filename is an empty string, then a private temporary +** on-disk database will be created. {F12720} This private database will be +** automatically deleted as soon as the database connection is closed. +** +** {F12721} The fourth parameter to sqlite3_open_v2() is the name of the +** [sqlite3_vfs] object that defines the operating system +** interface that the new database connection should use. {F12722} If the +** fourth parameter is a NULL pointer then the default [sqlite3_vfs] +** object is used. {END} +** +** Note to windows users: The encoding used for the filename argument +** of [sqlite3_open()] and [sqlite3_open_v2()] must be UTF-8, not whatever +** codepage is currently defined. Filenames containing international +** characters must be converted to UTF-8 prior to passing them into +** [sqlite3_open()] or [sqlite3_open_v2()]. +*/ +/*IMPORT_C*/ int sqlite3_open( + const char *filename, /* Database filename (UTF-8) */ + sqlite3 **ppDb /* OUT: SQLite db handle */ +); +/*IMPORT_C*/ int sqlite3_open16( + const void *filename, /* Database filename (UTF-16) */ + sqlite3 **ppDb /* OUT: SQLite db handle */ +); +/*IMPORT_C*/ int sqlite3_open_v2( + const char *filename, /* Database filename (UTF-8) */ + sqlite3 **ppDb, /* OUT: SQLite db handle */ + int flags, /* Flags */ + const char *zVfs /* Name of VFS module to use */ +); + +/* +** CAPI3REF: Error Codes And Messages {F12800} +** +** {F12801} The sqlite3_errcode() interface returns the numeric +** [SQLITE_OK | result code] or [SQLITE_IOERR_READ | extended result code] +** for the most recent failed sqlite3_* API call associated +** with [sqlite3] handle 'db'. {U12802} If a prior API call failed but the +** most recent API call succeeded, the return value from sqlite3_errcode() +** is undefined. {END} +** +** {F12803} The sqlite3_errmsg() and sqlite3_errmsg16() return English-language +** text that describes the error, as either UTF8 or UTF16 respectively. +** {F12804} Memory to hold the error message string is managed internally. +** {U12805} The +** string may be overwritten or deallocated by subsequent calls to SQLite +** interface functions. {END} +** +** {F12806} Calls to many sqlite3_* functions set the error code and +** string returned by [sqlite3_errcode()], [sqlite3_errmsg()], and +** [sqlite3_errmsg16()] overwriting the previous values. {F12807} +** Except, calls to [sqlite3_errcode()], +** [sqlite3_errmsg()], and [sqlite3_errmsg16()] themselves do not affect the +** results of future invocations. {F12808} Calls to API routines that +** do not return an error code (example: [sqlite3_data_count()]) do not +** change the error code returned by this routine. {F12809} Interfaces that +** are not associated with a specific database connection (examples: +** [sqlite3_mprintf()] or [sqlite3_enable_shared_cache()] do not change +** the return code. {END} +** +** {F12810} Assuming no other intervening sqlite3_* API calls are made, +** the error code returned by this function is associated with the same +** error as the strings returned by [sqlite3_errmsg()] and [sqlite3_errmsg16()]. +*/ +/*IMPORT_C*/ int sqlite3_errcode(sqlite3 *db); +/*IMPORT_C*/ const char *sqlite3_errmsg(sqlite3*); +/*IMPORT_C*/ const void *sqlite3_errmsg16(sqlite3*); + +/* +** CAPI3REF: SQL Statement Object {F13000} +** +** An instance of this object represent single SQL statements. This +** object is variously known as a "prepared statement" or a +** "compiled SQL statement" or simply as a "statement". +** +** The life of a statement object goes something like this: +** +**
    +**
  1. Create the object using [sqlite3_prepare_v2()] or a related +** function. +**
  2. Bind values to host parameters using +** [sqlite3_bind_blob | sqlite3_bind_* interfaces]. +**
  3. Run the SQL by calling [sqlite3_step()] one or more times. +**
  4. Reset the statement using [sqlite3_reset()] then go back +** to step 2. Do this zero or more times. +**
  5. Destroy the object using [sqlite3_finalize()]. +**
+** +** Refer to documentation on individual methods above for additional +** information. +*/ +typedef struct sqlite3_stmt sqlite3_stmt; + +/* +** CAPI3REF: Compiling An SQL Statement {F13010} +** +** To execute an SQL query, it must first be compiled into a byte-code +** program using one of these routines. +** +** {F13011} The first argument "db" is an [sqlite3 | SQLite database handle] +** obtained from a prior call to [sqlite3_open()], [sqlite3_open_v2()] +** or [sqlite3_open16()]. {F13012} +** The second argument "zSql" is the statement to be compiled, encoded +** as either UTF-8 or UTF-16. The sqlite3_prepare() and sqlite3_prepare_v2() +** interfaces uses UTF-8 and sqlite3_prepare16() and sqlite3_prepare16_v2() +** use UTF-16. {END} +** +** {F13013} If the nByte argument is less +** than zero, then zSql is read up to the first zero terminator. +** {F13014} If nByte is non-negative, then it is the maximum number of +** bytes read from zSql. When nByte is non-negative, the +** zSql string ends at either the first '\000' or '\u0000' character or +** until the nByte-th byte, whichever comes first. {END} +** +** {F13015} *pzTail is made to point to the first byte past the end of the +** first SQL statement in zSql. These routines only compiles the first +** statement in zSql, so *pzTail is left pointing to what remains +** uncompiled. {END} +** +** {F13016} *ppStmt is left pointing to a compiled +** [sqlite3_stmt | SQL statement structure] that can be +** executed using [sqlite3_step()]. Or if there is an error, *ppStmt may be +** set to NULL. {F13017} If the input text contains no SQL (if the input +** is and empty string or a comment) then *ppStmt is set to NULL. +** {U13018} The calling procedure is responsible for deleting the +** compiled SQL statement +** using [sqlite3_finalize()] after it has finished with it. +** +** {F13019} On success, [SQLITE_OK] is returned. Otherwise an +** [SQLITE_ERROR | error code] is returned. {END} +** +** The sqlite3_prepare_v2() and sqlite3_prepare16_v2() interfaces are +** recommended for all new programs. The two older interfaces are retained +** for backwards compatibility, but their use is discouraged. +** {F13020} In the "v2" interfaces, the prepared statement +** that is returned (the [sqlite3_stmt] object) contains a copy of the +** original SQL text. {END} This causes the [sqlite3_step()] interface to +** behave a differently in two ways: +** +**
    +**
  1. {F13022} +** If the database schema changes, instead of returning [SQLITE_SCHEMA] as it +** always used to do, [sqlite3_step()] will automatically recompile the SQL +** statement and try to run it again. {F12023} If the schema has changed in +** a way that makes the statement no longer valid, [sqlite3_step()] will still +** return [SQLITE_SCHEMA]. {END} But unlike the legacy behavior, +** [SQLITE_SCHEMA] is now a fatal error. {F12024} Calling +** [sqlite3_prepare_v2()] again will not make the +** error go away. {F12025} Note: use [sqlite3_errmsg()] to find the text +** of the parsing error that results in an [SQLITE_SCHEMA] return. {END} +**
    2. +** +**
  2. +** {F13030} When an error occurs, +** [sqlite3_step()] will return one of the detailed +** [SQLITE_ERROR | result codes] or +** [SQLITE_IOERR_READ | extended result codes]. {F13031} +** The legacy behavior was that [sqlite3_step()] would only return a generic +** [SQLITE_ERROR] result code and you would have to make a second call to +** [sqlite3_reset()] in order to find the underlying cause of the problem. +** {F13032} +** With the "v2" prepare interfaces, the underlying reason for the error is +** returned immediately. {END} +**
    3. +**
+*/ +/*IMPORT_C*/ int sqlite3_prepare( + sqlite3 *db, /* Database handle */ + const char *zSql, /* SQL statement, UTF-8 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const char **pzTail /* OUT: Pointer to unused portion of zSql */ +); +/*IMPORT_C*/ int sqlite3_prepare_v2( + sqlite3 *db, /* Database handle */ + const char *zSql, /* SQL statement, UTF-8 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const char **pzTail /* OUT: Pointer to unused portion of zSql */ +); +/*IMPORT_C*/ int sqlite3_prepare16( + sqlite3 *db, /* Database handle */ + const void *zSql, /* SQL statement, UTF-16 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const void **pzTail /* OUT: Pointer to unused portion of zSql */ +); +/*IMPORT_C*/ int sqlite3_prepare16_v2( + sqlite3 *db, /* Database handle */ + const void *zSql, /* SQL statement, UTF-16 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const void **pzTail /* OUT: Pointer to unused portion of zSql */ +); + +/* +** CAPIREF: Retrieving Statement SQL {F13100} +** +** {F13101} If the compiled SQL statement passed as an argument was +** compiled using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()], +** then this function returns a pointer to a zero-terminated string +** containing a copy of the original SQL statement. {F13102} The +** pointer is valid until the statement +** is deleted using sqlite3_finalize(). +** {F13103} The string returned by sqlite3_sql() is always UTF8 even +** if a UTF16 string was originally entered using [sqlite3_prepare16_v2()] +** or the equivalent. +** +** {F13104} If the statement was compiled using either of the legacy +** interfaces [sqlite3_prepare()] or [sqlite3_prepare16()], this +** function returns NULL. +*/ +/*IMPORT_C*/ const char *sqlite3_sql(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Dynamically Typed Value Object {F15000} +** +** {F15001} SQLite uses the sqlite3_value object to represent all values +** that are or can be stored in a database table. {END} +** SQLite uses dynamic typing for the values it stores. +** {F15002} Values stored in sqlite3_value objects can be +** be integers, floating point values, strings, BLOBs, or NULL. +*/ +typedef struct Mem sqlite3_value; + +/* +** CAPI3REF: SQL Function Context Object {F16001} +** +** The context in which an SQL function executes is stored in an +** sqlite3_context object. {F16002} A pointer to an sqlite3_context +** object is always first parameter to application-defined SQL functions. +*/ +typedef struct sqlite3_context sqlite3_context; + +/* +** CAPI3REF: Binding Values To Prepared Statements {F13500} +** +** {F13501} In the SQL strings input to [sqlite3_prepare_v2()] and its +** variants, literals may be replace by a parameter in one +** of these forms: +** +**
    +**
  • ? +**
  • ?NNN +**
  • :AAA +**
  • @AAA +**
  • $VVV +**
+** +** In the parameter forms shown above NNN is an integer literal, +** AAA is an alphanumeric identifier and VVV is a variable name according +** to the syntax rules of the TCL programming language. {END} +** The values of these parameters (also called "host parameter names") +** can be set using the sqlite3_bind_*() routines defined here. +** +** {F13502} The first argument to the sqlite3_bind_*() routines always +** is a pointer to the [sqlite3_stmt] object returned from +** [sqlite3_prepare_v2()] or its variants. {F13503} The second +** argument is the index of the parameter to be set. {F13504} The +** first parameter has an index of 1. {F13505} When the same named +** parameter is used more than once, second and subsequent +** occurrences have the same index as the first occurrence. +** {F13506} The index for named parameters can be looked up using the +** [sqlite3_bind_parameter_name()] API if desired. {F13507} The index +** for "?NNN" parameters is the value of NNN. +** {F13508} The NNN value must be between 1 and the compile-time +** parameter SQLITE_MAX_VARIABLE_NUMBER (default value: 999). {END} +** See limits.html for additional information. +** +** {F13509} The third argument is the value to bind to the parameter. {END} +** +** {F13510} In those +** routines that have a fourth argument, its value is the number of bytes +** in the parameter. To be clear: the value is the number of bytes in the +** string, not the number of characters. {F13511} The number +** of bytes does not include the zero-terminator at the end of strings. +** {F13512} +** If the fourth parameter is negative, the length of the string is +** number of bytes up to the first zero terminator. {END} +** +** {F13513} +** The fifth argument to sqlite3_bind_blob(), sqlite3_bind_text(), and +** sqlite3_bind_text16() is a destructor used to dispose of the BLOB or +** text after SQLite has finished with it. {F13514} If the fifth argument is +** the special value [SQLITE_STATIC], then the library assumes that the +** information is in static, unmanaged space and does not need to be freed. +** {F13515} If the fifth argument has the value [SQLITE_TRANSIENT], then +** SQLite makes its own private copy of the data immediately, before +** the sqlite3_bind_*() routine returns. {END} +** +** {F13520} The sqlite3_bind_zeroblob() routine binds a BLOB of length N that +** is filled with zeros. {F13521} A zeroblob uses a fixed amount of memory +** (just an integer to hold it size) while it is being processed. {END} +** Zeroblobs are intended to serve as place-holders for BLOBs whose +** content is later written using +** [sqlite3_blob_open | increment BLOB I/O] routines. {F13522} A negative +** value for the zeroblob results in a zero-length BLOB. {END} +** +** {F13530} The sqlite3_bind_*() routines must be called after +** [sqlite3_prepare_v2()] (and its variants) or [sqlite3_reset()] and +** before [sqlite3_step()]. {F13531} +** Bindings are not cleared by the [sqlite3_reset()] routine. +** {F13532} Unbound parameters are interpreted as NULL. {END} +** +** {F13540} These routines return [SQLITE_OK] on success or an error code if +** anything goes wrong. {F13541} [SQLITE_RANGE] is returned if the parameter +** index is out of range. {F13542} [SQLITE_NOMEM] is returned if malloc fails. +** {F13543} [SQLITE_MISUSE] is returned if these routines are called on a +** virtual machine that is the wrong state or which has already been finalized. +*/ +/*IMPORT_C*/ int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*)); +/*IMPORT_C*/ int sqlite3_bind_double(sqlite3_stmt*, int, double); +/*IMPORT_C*/ int sqlite3_bind_int(sqlite3_stmt*, int, int); +/*IMPORT_C*/ int sqlite3_bind_int64(sqlite3_stmt*, int, sqlite3_int64); +/*IMPORT_C*/ int sqlite3_bind_null(sqlite3_stmt*, int); +/*IMPORT_C*/ int sqlite3_bind_text(sqlite3_stmt*, int, const char*, int n, void(*)(void*)); +/*IMPORT_C*/ int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*)); +/*IMPORT_C*/ int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*); +/*IMPORT_C*/ int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n); + +/* +** CAPI3REF: Number Of Host Parameters {F13600} +** +** {F13601} Return the largest host parameter index in the precompiled +** statement given as the argument. {F13602} When the host parameters +** are of the forms like ":AAA", "$VVV", "@AAA", or "?", +** then they are assigned sequential increasing numbers beginning +** with one, so the value returned is the number of parameters. +** {F13603} However +** if the same host parameter name is used multiple times, each occurrance +** is given the same number, so the value returned in that case is the number +** of unique host parameter names. {F13604} If host parameters of the +** form "?NNN" are used (where NNN is an integer) then there might be +** gaps in the numbering and the value returned by this interface is +** the index of the host parameter with the largest index value. {END} +** +** {U13605} The prepared statement must not be [sqlite3_finalize | finalized] +** prior to this routine returning. Otherwise the results are undefined +** and probably undesirable. +*/ +/*IMPORT_C*/ int sqlite3_bind_parameter_count(sqlite3_stmt*); + +/* +** CAPI3REF: Name Of A Host Parameter {F13620} +** +** {F13621} This routine returns a pointer to the name of the n-th +** parameter in a [sqlite3_stmt | prepared statement]. {F13622} +** Host parameters of the form ":AAA" or "@AAA" or "$VVV" have a name +** which is the string ":AAA" or "@AAA" or "$VVV". +** In other words, the initial ":" or "$" or "@" +** is included as part of the name. {F13626} +** Parameters of the form "?" or "?NNN" have no name. +** +** {F13623} The first host parameter has an index of 1, not 0. +** +** {F13624} If the value n is out of range or if the n-th parameter is +** nameless, then NULL is returned. {F13625} The returned string is +** always in the UTF-8 encoding even if the named parameter was +** originally specified as UTF-16 in [sqlite3_prepare16()] or +** [sqlite3_prepare16_v2()]. +*/ +/*IMPORT_C*/ const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int); + +/* +** CAPI3REF: Index Of A Parameter With A Given Name {F13640} +** +** {F13641} This routine returns the index of a host parameter with the +** given name. {F13642} The name must match exactly. {F13643} +** If no parameter with the given name is found, return 0. +** {F13644} Parameter names must be UTF8. +*/ +/*IMPORT_C*/ int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName); + +/* +** CAPI3REF: Reset All Bindings On A Prepared Statement {F13660} +** +** {F13661} Contrary to the intuition of many, [sqlite3_reset()] does not +** reset the [sqlite3_bind_blob | bindings] on a +** [sqlite3_stmt | prepared statement]. {F13662} Use this routine to +** reset all host parameters to NULL. +*/ +/*IMPORT_C*/ int sqlite3_clear_bindings(sqlite3_stmt*); + +/* +** CAPI3REF: Number Of Columns In A Result Set {F13710} +** +** {F13711} Return the number of columns in the result set returned by the +** [sqlite3_stmt | compiled SQL statement]. {F13712} This routine returns 0 +** if pStmt is an SQL statement that does not return data (for +** example an UPDATE). +*/ +/*IMPORT_C*/ int sqlite3_column_count(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Column Names In A Result Set {F13720} +** +** {F13721} These routines return the name assigned to a particular column +** in the result set of a SELECT statement. {F13722} The sqlite3_column_name() +** interface returns a pointer to a zero-terminated UTF8 string +** and sqlite3_column_name16() returns a pointer to a zero-terminated +** UTF16 string. {F13723} The first parameter is the +** [sqlite3_stmt | prepared statement] that implements the SELECT statement. +** The second parameter is the column number. The left-most column is +** number 0. +** +** {F13724} The returned string pointer is valid until either the +** [sqlite3_stmt | prepared statement] is destroyed by [sqlite3_finalize()] +** or until the next call sqlite3_column_name() or sqlite3_column_name16() +** on the same column. +** +** {F13725} If sqlite3_malloc() fails during the processing of either routine +** (for example during a conversion from UTF-8 to UTF-16) then a +** NULL pointer is returned. +*/ +/*IMPORT_C*/ const char *sqlite3_column_name(sqlite3_stmt*, int N); +/*IMPORT_C*/ const void *sqlite3_column_name16(sqlite3_stmt*, int N); + +/* +** CAPI3REF: Source Of Data In A Query Result {F13740} +** +** {F13741} These routines provide a means to determine what column of what +** table in which database a result of a SELECT statement comes from. +** {F13742} The name of the database or table or column can be returned as +** either a UTF8 or UTF16 string. {F13743} The _database_ routines return +** the database name, the _table_ routines return the table name, and +** the origin_ routines return the column name. {F13744} +** The returned string is valid until +** the [sqlite3_stmt | prepared statement] is destroyed using +** [sqlite3_finalize()] or until the same information is requested +** again in a different encoding. +** +** {F13745} The names returned are the original un-aliased names of the +** database, table, and column. +** +** {F13746} The first argument to the following calls is a +** [sqlite3_stmt | compiled SQL statement]. +** {F13747} These functions return information about the Nth column returned by +** the statement, where N is the second function argument. +** +** {F13748} If the Nth column returned by the statement is an expression +** or subquery and is not a column value, then all of these functions +** return NULL. {F13749} Otherwise, they return the +** name of the attached database, table and column that query result +** column was extracted from. +** +** {F13750} As with all other SQLite APIs, those postfixed with "16" return +** UTF-16 encoded strings, the other functions return UTF-8. {END} +** +** These APIs are only available if the library was compiled with the +** SQLITE_ENABLE_COLUMN_METADATA preprocessor symbol defined. +** +** {U13751} +** If two or more threads call one or more of these routines against the same +** prepared statement and column at the same time then the results are +** undefined. +*/ +/*IMPORT_C*/ const char *sqlite3_column_database_name(sqlite3_stmt*,int); +/*IMPORT_C*/ const void *sqlite3_column_database_name16(sqlite3_stmt*,int); +/*IMPORT_C*/ const char *sqlite3_column_table_name(sqlite3_stmt*,int); +/*IMPORT_C*/ const void *sqlite3_column_table_name16(sqlite3_stmt*,int); +/*IMPORT_C*/ const char *sqlite3_column_origin_name(sqlite3_stmt*,int); +/*IMPORT_C*/ const void *sqlite3_column_origin_name16(sqlite3_stmt*,int); + +/* +** CAPI3REF: Declared Datatype Of A Query Result {F13760} +** +** The first parameter is a [sqlite3_stmt | compiled SQL statement]. +** {F13761} If this statement is a SELECT statement and the Nth column of the +** returned result set of that SELECT is a table column (not an +** expression or subquery) then the declared type of the table +** column is returned. {F13762} If the Nth column of the result set is an +** expression or subquery, then a NULL pointer is returned. +** {F13763} The returned string is always UTF-8 encoded. {END} +** For example, in the database schema: +** +** CREATE TABLE t1(c1 VARIANT); +** +** And the following statement compiled: +** +** SELECT c1 + 1, c1 FROM t1; +** +** Then this routine would return the string "VARIANT" for the second +** result column (i==1), and a NULL pointer for the first result column +** (i==0). +** +** SQLite uses dynamic run-time typing. So just because a column +** is declared to contain a particular type does not mean that the +** data stored in that column is of the declared type. SQLite is +** strongly typed, but the typing is dynamic not static. Type +** is associated with individual values, not with the containers +** used to hold those values. +*/ +/*IMPORT_C*/ const char *sqlite3_column_decltype(sqlite3_stmt *, int i); +/*IMPORT_C*/ const void *sqlite3_column_decltype16(sqlite3_stmt*,int); + +/* +** CAPI3REF: Evaluate An SQL Statement {F13200} +** +** After an [sqlite3_stmt | SQL statement] has been prepared with a call +** to either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] or to one of +** the legacy interfaces [sqlite3_prepare()] or [sqlite3_prepare16()], +** then this function must be called one or more times to evaluate the +** statement. +** +** The details of the behavior of this sqlite3_step() interface depend +** on whether the statement was prepared using the newer "v2" interface +** [sqlite3_prepare_v2()] and [sqlite3_prepare16_v2()] or the older legacy +** interface [sqlite3_prepare()] and [sqlite3_prepare16()]. The use of the +** new "v2" interface is recommended for new applications but the legacy +** interface will continue to be supported. +** +** In the lagacy interface, the return value will be either [SQLITE_BUSY], +** [SQLITE_DONE], [SQLITE_ROW], [SQLITE_ERROR], or [SQLITE_MISUSE]. +** With the "v2" interface, any of the other [SQLITE_OK | result code] +** or [SQLITE_IOERR_READ | extended result code] might be returned as +** well. +** +** [SQLITE_BUSY] means that the database engine was unable to acquire the +** database locks it needs to do its job. If the statement is a COMMIT +** or occurs outside of an explicit transaction, then you can retry the +** statement. If the statement is not a COMMIT and occurs within a +** explicit transaction then you should rollback the transaction before +** continuing. +** +** [SQLITE_DONE] means that the statement has finished executing +** successfully. sqlite3_step() should not be called again on this virtual +** machine without first calling [sqlite3_reset()] to reset the virtual +** machine back to its initial state. +** +** If the SQL statement being executed returns any data, then +** [SQLITE_ROW] is returned each time a new row of data is ready +** for processing by the caller. The values may be accessed using +** the [sqlite3_column_int | column access functions]. +** sqlite3_step() is called again to retrieve the next row of data. +** +** [SQLITE_ERROR] means that a run-time error (such as a constraint +** violation) has occurred. sqlite3_step() should not be called again on +** the VM. More information may be found by calling [sqlite3_errmsg()]. +** With the legacy interface, a more specific error code (example: +** [SQLITE_INTERRUPT], [SQLITE_SCHEMA], [SQLITE_CORRUPT], and so forth) +** can be obtained by calling [sqlite3_reset()] on the +** [sqlite3_stmt | prepared statement]. In the "v2" interface, +** the more specific error code is returned directly by sqlite3_step(). +** +** [SQLITE_MISUSE] means that the this routine was called inappropriately. +** Perhaps it was called on a [sqlite3_stmt | prepared statement] that has +** already been [sqlite3_finalize | finalized] or on one that had +** previously returned [SQLITE_ERROR] or [SQLITE_DONE]. Or it could +** be the case that the same database connection is being used by two or +** more threads at the same moment in time. +** +** Goofy Interface Alert: +** In the legacy interface, +** the sqlite3_step() API always returns a generic error code, +** [SQLITE_ERROR], following any error other than [SQLITE_BUSY] +** and [SQLITE_MISUSE]. You must call [sqlite3_reset()] or +** [sqlite3_finalize()] in order to find one of the specific +** [SQLITE_ERROR | result codes] that better describes the error. +** We admit that this is a goofy design. The problem has been fixed +** with the "v2" interface. If you prepare all of your SQL statements +** using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] instead +** of the legacy [sqlite3_prepare()] and [sqlite3_prepare16()], then the +** more specific [SQLITE_ERROR | result codes] are returned directly +** by sqlite3_step(). The use of the "v2" interface is recommended. +*/ +/*IMPORT_C*/ int sqlite3_step(sqlite3_stmt*); + +/* +** CAPI3REF: Number of columns in a result set {F13770} +** +** Return the number of values in the current row of the result set. +** +** {F13771} After a call to [sqlite3_step()] that returns [SQLITE_ROW], +** this routine +** will return the same value as the [sqlite3_column_count()] function. +** {F13772} +** After [sqlite3_step()] has returned an [SQLITE_DONE], [SQLITE_BUSY], or +** a [SQLITE_ERROR | error code], or before [sqlite3_step()] has been +** called on the [sqlite3_stmt | prepared statement] for the first time, +** this routine returns zero. +*/ +/*IMPORT_C*/ int sqlite3_data_count(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Fundamental Datatypes {F10265} +** +** {F10266}Every value in SQLite has one of five fundamental datatypes: +** +**
    +**
  • 64-bit signed integer +**
  • 64-bit IEEE floating point number +**
  • string +**
  • BLOB +**
  • NULL +**
{END} +** +** These constants are codes for each of those types. +** +** Note that the SQLITE_TEXT constant was also used in SQLite version 2 +** for a completely different meaning. Software that links against both +** SQLite version 2 and SQLite version 3 should use SQLITE3_TEXT not +** SQLITE_TEXT. +*/ +#define SQLITE_INTEGER 1 +#define SQLITE_FLOAT 2 +#define SQLITE_BLOB 4 +#define SQLITE_NULL 5 +#ifdef SQLITE_TEXT +# undef SQLITE_TEXT +#else +# define SQLITE_TEXT 3 +#endif +#define SQLITE3_TEXT 3 + +/* +** CAPI3REF: Results Values From A Query {F13800} +** +** These routines return information about +** a single column of the current result row of a query. In every +** case the first argument is a pointer to the +** [sqlite3_stmt | SQL statement] that is being +** evaluated (the [sqlite3_stmt*] that was returned from +** [sqlite3_prepare_v2()] or one of its variants) and +** the second argument is the index of the column for which information +** should be returned. The left-most column of the result set +** has an index of 0. +** +** If the SQL statement is not currently point to a valid row, or if the +** the column index is out of range, the result is undefined. +** These routines may only be called when the most recent call to +** [sqlite3_step()] has returned [SQLITE_ROW] and neither +** [sqlite3_reset()] nor [sqlite3_finalize()] has been call subsequently. +** If any of these routines are called after [sqlite3_reset()] or +** [sqlite3_finalize()] or after [sqlite3_step()] has returned +** something other than [SQLITE_ROW], the results are undefined. +** If [sqlite3_step()] or [sqlite3_reset()] or [sqlite3_finalize()] +** are called from a different thread while any of these routines +** are pending, then the results are undefined. +** +** The sqlite3_column_type() routine returns +** [SQLITE_INTEGER | datatype code] for the initial data type +** of the result column. The returned value is one of [SQLITE_INTEGER], +** [SQLITE_FLOAT], [SQLITE_TEXT], [SQLITE_BLOB], or [SQLITE_NULL]. The value +** returned by sqlite3_column_type() is only meaningful if no type +** conversions have occurred as described below. After a type conversion, +** the value returned by sqlite3_column_type() is undefined. Future +** versions of SQLite may change the behavior of sqlite3_column_type() +** following a type conversion. +** +** If the result is a BLOB or UTF-8 string then the sqlite3_column_bytes() +** routine returns the number of bytes in that BLOB or string. +** If the result is a UTF-16 string, then sqlite3_column_bytes() converts +** the string to UTF-8 and then returns the number of bytes. +** If the result is a numeric value then sqlite3_column_bytes() uses +** [sqlite3_snprintf()] to convert that value to a UTF-8 string and returns +** the number of bytes in that string. +** The value returned does not include the zero terminator at the end +** of the string. For clarity: the value returned is the number of +** bytes in the string, not the number of characters. +** +** Strings returned by sqlite3_column_text() and sqlite3_column_text16(), +** even zero-length strings, are always zero terminated. The return +** value from sqlite3_column_blob() for a zero-length blob is an arbitrary +** pointer, possibly even a NULL pointer. +** +** The sqlite3_column_bytes16() routine is similar to sqlite3_column_bytes() +** but leaves the result in UTF-16 instead of UTF-8. +** The zero terminator is not included in this count. +** +** These routines attempt to convert the value where appropriate. For +** example, if the internal representation is FLOAT and a text result +** is requested, [sqlite3_snprintf()] is used internally to do the conversion +** automatically. The following table details the conversions that +** are applied: +** +**
+** +**
Internal
Type 		Requested
Type 		Conversion +** +**
NULL INTEGER Result is 0 +**
NULL FLOAT Result is 0.0 +**
NULL TEXT Result is NULL pointer +**
NULL BLOB Result is NULL pointer +**
INTEGER FLOAT Convert from integer to float +**
INTEGER TEXT ASCII rendering of the integer +**
INTEGER BLOB Same as for INTEGER->TEXT +**
FLOAT INTEGER Convert from float to integer +**
FLOAT TEXT ASCII rendering of the float +**
FLOAT BLOB Same as FLOAT->TEXT +**
TEXT INTEGER Use atoi() +**
TEXT FLOAT Use atof() +**
TEXT BLOB No change +**
BLOB INTEGER Convert to TEXT then use atoi() +**
BLOB FLOAT Convert to TEXT then use atof() +**
BLOB TEXT Add a zero terminator if needed +**
+**
+** +** The table above makes reference to standard C library functions atoi() +** and atof(). SQLite does not really use these functions. It has its +** on equavalent internal routines. The atoi() and atof() names are +** used in the table for brevity and because they are familiar to most +** C programmers. +** +** Note that when type conversions occur, pointers returned by prior +** calls to sqlite3_column_blob(), sqlite3_column_text(), and/or +** sqlite3_column_text16() may be invalidated. +** Type conversions and pointer invalidations might occur +** in the following cases: +** +**
    +**

  • The initial content is a BLOB and sqlite3_column_text() +** or sqlite3_column_text16() is called. A zero-terminator might +** need to be added to the string.

    • +** +**

  • The initial content is UTF-8 text and sqlite3_column_bytes16() or +** sqlite3_column_text16() is called. The content must be converted +** to UTF-16.

    • +** +**

  • The initial content is UTF-16 text and sqlite3_column_bytes() or +** sqlite3_column_text() is called. The content must be converted +** to UTF-8.

    • +**
+** +** Conversions between UTF-16be and UTF-16le are always done in place and do +** not invalidate a prior pointer, though of course the content of the buffer +** that the prior pointer points to will have been modified. Other kinds +** of conversion are done in place when it is possible, but sometime it is +** not possible and in those cases prior pointers are invalidated. +** +** The safest and easiest to remember policy is to invoke these routines +** in one of the following ways: +** +**
    +**
  • sqlite3_column_text() followed by sqlite3_column_bytes()
    • +**
  • sqlite3_column_blob() followed by sqlite3_column_bytes()
    • +**
  • sqlite3_column_text16() followed by sqlite3_column_bytes16()
    • +**
+** +** In other words, you should call sqlite3_column_text(), sqlite3_column_blob(), +** or sqlite3_column_text16() first to force the result into the desired +** format, then invoke sqlite3_column_bytes() or sqlite3_column_bytes16() to +** find the size of the result. Do not mix call to sqlite3_column_text() or +** sqlite3_column_blob() with calls to sqlite3_column_bytes16(). And do not +** mix calls to sqlite3_column_text16() with calls to sqlite3_column_bytes(). +** +** The pointers returned are valid until a type conversion occurs as +** described above, or until [sqlite3_step()] or [sqlite3_reset()] or +** [sqlite3_finalize()] is called. The memory space used to hold strings +** and blobs is freed automatically. Do not pass the pointers returned +** [sqlite3_column_blob()], [sqlite3_column_text()], etc. into +** [sqlite3_free()]. +** +** If a memory allocation error occurs during the evaluation of any +** of these routines, a default value is returned. The default value +** is either the integer 0, the floating point number 0.0, or a NULL +** pointer. Subsequent calls to [sqlite3_errcode()] will return +** [SQLITE_NOMEM]. +*/ +/*IMPORT_C*/ const void *sqlite3_column_blob(sqlite3_stmt*, int iCol); +/*IMPORT_C*/ int sqlite3_column_bytes(sqlite3_stmt*, int iCol); +/*IMPORT_C*/ int sqlite3_column_bytes16(sqlite3_stmt*, int iCol); +/*IMPORT_C*/ double sqlite3_column_double(sqlite3_stmt*, int iCol); +/*IMPORT_C*/ int sqlite3_column_int(sqlite3_stmt*, int iCol); +/*IMPORT_C*/ sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol); +/*IMPORT_C*/ const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol); +/*IMPORT_C*/ const void *sqlite3_column_text16(sqlite3_stmt*, int iCol); +/*IMPORT_C*/ int sqlite3_column_type(sqlite3_stmt*, int iCol); +/*IMPORT_C*/ sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol); + +/* +** CAPI3REF: Destroy A Prepared Statement Object {F13300} +** +** The sqlite3_finalize() function is called to delete a +** [sqlite3_stmt | compiled SQL statement]. If the statement was +** executed successfully, or not executed at all, then SQLITE_OK is returned. +** If execution of the statement failed then an +** [SQLITE_ERROR | error code] or [SQLITE_IOERR_READ | extended error code] +** is returned. +** +** This routine can be called at any point during the execution of the +** [sqlite3_stmt | virtual machine]. If the virtual machine has not +** completed execution when this routine is called, that is like +** encountering an error or an interrupt. (See [sqlite3_interrupt()].) +** Incomplete updates may be rolled back and transactions cancelled, +** depending on the circumstances, and the +** [SQLITE_ERROR | result code] returned will be [SQLITE_ABORT]. +*/ +/*IMPORT_C*/ int sqlite3_finalize(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Reset A Prepared Statement Object {F13330} +** +** The sqlite3_reset() function is called to reset a +** [sqlite3_stmt | compiled SQL statement] object. +** back to its initial state, ready to be re-executed. +** Any SQL statement variables that had values bound to them using +** the [sqlite3_bind_blob | sqlite3_bind_*() API] retain their values. +** Use [sqlite3_clear_bindings()] to reset the bindings. +*/ +/*IMPORT_C*/ int sqlite3_reset(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Create Or Redefine SQL Functions {F16100} +** +** The following two functions are used to add SQL functions or aggregates +** or to redefine the behavior of existing SQL functions or aggregates. The +** difference only between the two is that the second parameter, the +** name of the (scalar) function or aggregate, is encoded in UTF-8 for +** sqlite3_create_function() and UTF-16 for sqlite3_create_function16(). +** +** The first argument is the [sqlite3 | database handle] that holds the +** SQL function or aggregate is to be added or redefined. If a single +** program uses more than one database handle internally, then SQL +** functions or aggregates must be added individually to each database +** handle with which they will be used. +** +** The second parameter is the name of the SQL function to be created +** or redefined. +** The length of the name is limited to 255 bytes, exclusive of the +** zero-terminator. Note that the name length limit is in bytes, not +** characters. Any attempt to create a function with a longer name +** will result in an SQLITE_ERROR error. +** +** The third parameter is the number of arguments that the SQL function or +** aggregate takes. If this parameter is negative, then the SQL function or +** aggregate may take any number of arguments. +** +** The fourth parameter, eTextRep, specifies what +** [SQLITE_UTF8 | text encoding] this SQL function prefers for +** its parameters. Any SQL function implementation should be able to work +** work with UTF-8, UTF-16le, or UTF-16be. But some implementations may be +** more efficient with one encoding than another. It is allowed to +** invoke sqlite3_create_function() or sqlite3_create_function16() multiple +** times with the same function but with different values of eTextRep. +** When multiple implementations of the same function are available, SQLite +** will pick the one that involves the least amount of data conversion. +** If there is only a single implementation which does not care what +** text encoding is used, then the fourth argument should be +** [SQLITE_ANY]. +** +** The fifth parameter is an arbitrary pointer. The implementation +** of the function can gain access to this pointer using +** [sqlite3_user_data()]. +** +** The seventh, eighth and ninth parameters, xFunc, xStep and xFinal, are +** pointers to C-language functions that implement the SQL +** function or aggregate. A scalar SQL function requires an implementation of +** the xFunc callback only, NULL pointers should be passed as the xStep +** and xFinal parameters. An aggregate SQL function requires an implementation +** of xStep and xFinal and NULL should be passed for xFunc. To delete an +** existing SQL function or aggregate, pass NULL for all three function +** callback. +** +** It is permitted to register multiple implementations of the same +** functions with the same name but with either differing numbers of +** arguments or differing perferred text encodings. SQLite will use +** the implementation most closely matches the way in which the +** SQL function is used. +*/ +/*IMPORT_C*/ int sqlite3_create_function( + sqlite3 *, + const char *zFunctionName, + int nArg, + int eTextRep, + void*, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*) +); +/*IMPORT_C*/ int sqlite3_create_function16( + sqlite3*, + const void *zFunctionName, + int nArg, + int eTextRep, + void*, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*) +); + +/* +** CAPI3REF: Text Encodings {F10267} +** +** These constant define integer codes that represent the various +** text encodings supported by SQLite. +*/ +#define SQLITE_UTF8 1 +#define SQLITE_UTF16LE 2 +#define SQLITE_UTF16BE 3 +#define SQLITE_UTF16 4 /* Use native byte order */ +#define SQLITE_ANY 5 /* sqlite3_create_function only */ +#define SQLITE_UTF16_ALIGNED 8 /* sqlite3_create_collation only */ + +/* +** CAPI3REF: Obsolete Functions +** +** These functions are all now obsolete. In order to maintain +** backwards compatibility with older code, we continue to support +** these functions. However, new development projects should avoid +** the use of these functions. To help encourage people to avoid +** using these functions, we are not going to tell you want they do. +*/ +/*IMPORT_C*/ int sqlite3_aggregate_count(sqlite3_context*); +/*IMPORT_C*/ int sqlite3_expired(sqlite3_stmt*); +/*IMPORT_C*/ int sqlite3_transfer_bindings(sqlite3_stmt*, sqlite3_stmt*); +/*IMPORT_C*/ int sqlite3_global_recover(void); +/*IMPORT_C*/ void sqlite3_thread_cleanup(void); +/*IMPORT_C*/ int sqlite3_memory_alarm(void(*)(void*,sqlite3_int64,int),void*,sqlite3_int64); + +/* +** CAPI3REF: Obtaining SQL Function Parameter Values {F15100} +** +** The C-language implementation of SQL functions and aggregates uses +** this set of interface routines to access the parameter values on +** the function or aggregate. +** +** The xFunc (for scalar functions) or xStep (for aggregates) parameters +** to [sqlite3_create_function()] and [sqlite3_create_function16()] +** define callbacks that implement the SQL functions and aggregates. +** The 4th parameter to these callbacks is an array of pointers to +** [sqlite3_value] objects. There is one [sqlite3_value] object for +** each parameter to the SQL function. These routines are used to +** extract values from the [sqlite3_value] objects. +** +** These routines work just like the corresponding +** [sqlite3_column_blob | sqlite3_column_* routines] except that +** these routines take a single [sqlite3_value*] pointer instead +** of an [sqlite3_stmt*] pointer and an integer column number. +** +** The sqlite3_value_text16() interface extracts a UTF16 string +** in the native byte-order of the host machine. The +** sqlite3_value_text16be() and sqlite3_value_text16le() interfaces +** extract UTF16 strings as big-endian and little-endian respectively. +** +** The sqlite3_value_numeric_type() interface attempts to apply +** numeric affinity to the value. This means that an attempt is +** made to convert the value to an integer or floating point. If +** such a conversion is possible without loss of information (in other +** words if the value is a string that looks like a number) +** then the conversion is done. Otherwise no conversion occurs. The +** [SQLITE_INTEGER | datatype] after conversion is returned. +** +** Please pay particular attention to the fact that the pointer that +** is returned from [sqlite3_value_blob()], [sqlite3_value_text()], or +** [sqlite3_value_text16()] can be invalidated by a subsequent call to +** [sqlite3_value_bytes()], [sqlite3_value_bytes16()], [sqlite3_value_text()], +** or [sqlite3_value_text16()]. +** +** These routines must be called from the same thread as +** the SQL function that supplied the sqlite3_value* parameters. +** Or, if the sqlite3_value* argument comes from the [sqlite3_column_value()] +** interface, then these routines should be called from the same thread +** that ran [sqlite3_column_value()]. +** +*/ +/*IMPORT_C*/ const void *sqlite3_value_blob(sqlite3_value*); +/*IMPORT_C*/ int sqlite3_value_bytes(sqlite3_value*); +/*IMPORT_C*/ int sqlite3_value_bytes16(sqlite3_value*); +/*IMPORT_C*/ double sqlite3_value_double(sqlite3_value*); +/*IMPORT_C*/ int sqlite3_value_int(sqlite3_value*); +/*IMPORT_C*/ sqlite3_int64 sqlite3_value_int64(sqlite3_value*); +/*IMPORT_C*/ const unsigned char *sqlite3_value_text(sqlite3_value*); +/*IMPORT_C*/ const void *sqlite3_value_text16(sqlite3_value*); +/*IMPORT_C*/ const void *sqlite3_value_text16le(sqlite3_value*); +/*IMPORT_C*/ const void *sqlite3_value_text16be(sqlite3_value*); +/*IMPORT_C*/ int sqlite3_value_type(sqlite3_value*); +/*IMPORT_C*/ int sqlite3_value_numeric_type(sqlite3_value*); + +/* +** CAPI3REF: Obtain Aggregate Function Context {F16210} +** +** The implementation of aggregate SQL functions use this routine to allocate +** a structure for storing their state. +** {F16211} The first time the sqlite3_aggregate_context() routine is +** is called for a particular aggregate, SQLite allocates nBytes of memory +** zeros that memory, and returns a pointer to it. +** {F16212} On second and subsequent calls to sqlite3_aggregate_context() +** for the same aggregate function index, the same buffer is returned. {END} +** The implementation +** of the aggregate can use the returned buffer to accumulate data. +** +** {F16213} SQLite automatically frees the allocated buffer when the aggregate +** query concludes. {END} +** +** The first parameter should be a copy of the +** [sqlite3_context | SQL function context] that is the first +** parameter to the callback routine that implements the aggregate +** function. +** +** This routine must be called from the same thread in which +** the aggregate SQL function is running. +*/ +/*IMPORT_C*/ void *sqlite3_aggregate_context(sqlite3_context*, int nBytes); + +/* +** CAPI3REF: User Data For Functions {F16240} +** +** {F16241} The sqlite3_user_data() interface returns a copy of +** the pointer that was the pUserData parameter (the 5th parameter) +** of the the [sqlite3_create_function()] +** and [sqlite3_create_function16()] routines that originally +** registered the application defined function. {END} +** +** {U16243} This routine must be called from the same thread in which +** the application-defined function is running. +*/ +/*IMPORT_C*/ void *sqlite3_user_data(sqlite3_context*); + +/* +** CAPI3REF: Function Auxiliary Data {F16270} +** +** The following two functions may be used by scalar SQL functions to +** associate meta-data with argument values. If the same value is passed to +** multiple invocations of the same SQL function during query execution, under +** some circumstances the associated meta-data may be preserved. This may +** be used, for example, to add a regular-expression matching scalar +** function. The compiled version of the regular expression is stored as +** meta-data associated with the SQL value passed as the regular expression +** pattern. The compiled regular expression can be reused on multiple +** invocations of the same function so that the original pattern string +** does not need to be recompiled on each invocation. +** +** {F16271} +** The sqlite3_get_auxdata() interface returns a pointer to the meta-data +** associated by the sqlite3_set_auxdata() function with the Nth argument +** value to the application-defined function. +** {F16272} If no meta-data has been ever been set for the Nth +** argument of the function, or if the cooresponding function parameter +** has changed since the meta-data was set, then sqlite3_get_auxdata() +** returns a NULL pointer. +** +** {F16275} The sqlite3_set_auxdata() interface saves the meta-data +** pointed to by its 3rd parameter as the meta-data for the N-th +** argument of the application-defined function. {END} Subsequent +** calls to sqlite3_get_auxdata() might return this data, if it has +** not been destroyed. +** {F16277} If it is not NULL, SQLite will invoke the destructor +** function given by the 4th parameter to sqlite3_set_auxdata() on +** the meta-data when the corresponding function parameter changes +** or when the SQL statement completes, whichever comes first. {END} +** +** In practice, meta-data is preserved between function calls for +** expressions that are constant at compile time. This includes literal +** values and SQL variables. +** +** These routines must be called from the same thread in which +** the SQL function is running. +*/ +/*IMPORT_C*/ void *sqlite3_get_auxdata(sqlite3_context*, int N); +/*IMPORT_C*/ void sqlite3_set_auxdata(sqlite3_context*, int N, void*, void (*)(void*)); + + +/* +** CAPI3REF: Constants Defining Special Destructor Behavior {F10280} +** +** These are special value for the destructor that is passed in as the +** final argument to routines like [sqlite3_result_blob()]. If the destructor +** argument is SQLITE_STATIC, it means that the content pointer is constant +** and will never change. It does not need to be destroyed. The +** SQLITE_TRANSIENT value means that the content will likely change in +** the near future and that SQLite should make its own private copy of +** the content before returning. +** +** The typedef is necessary to work around problems in certain +** C++ compilers. See ticket #2191. +*/ +typedef void (*sqlite3_destructor_type)(void*); +#define SQLITE_STATIC ((sqlite3_destructor_type)0) +#define SQLITE_TRANSIENT ((sqlite3_destructor_type)-1) + +/* +** CAPI3REF: Setting The Result Of An SQL Function {F16400} +** +** These routines are used by the xFunc or xFinal callbacks that +** implement SQL functions and aggregates. See +** [sqlite3_create_function()] and [sqlite3_create_function16()] +** for additional information. +** +** These functions work very much like the +** [sqlite3_bind_blob | sqlite3_bind_*] family of functions used +** to bind values to host parameters in prepared statements. +** Refer to the +** [sqlite3_bind_blob | sqlite3_bind_* documentation] for +** additional information. +** +** {F16402} The sqlite3_result_blob() interface sets the result from +** an application defined function to be the BLOB whose content is pointed +** to by the second parameter and which is N bytes long where N is the +** third parameter. +** {F16403} The sqlite3_result_zeroblob() inerfaces set the result of +** the application defined function to be a BLOB containing all zero +** bytes and N bytes in size, where N is the value of the 2nd parameter. +** +** {F16407} The sqlite3_result_double() interface sets the result from +** an application defined function to be a floating point value specified +** by its 2nd argument. +** +** {F16409} The sqlite3_result_error() and sqlite3_result_error16() functions +** cause the implemented SQL function to throw an exception. +** {F16411} SQLite uses the string pointed to by the +** 2nd parameter of sqlite3_result_error() or sqlite3_result_error16() +** as the text of an error message. {F16412} SQLite interprets the error +** message string from sqlite3_result_error() as UTF8. {F16413} SQLite +** interprets the string from sqlite3_result_error16() as UTF16 in native +** byte order. {F16414} If the third parameter to sqlite3_result_error() +** or sqlite3_result_error16() is negative then SQLite takes as the error +** message all text up through the first zero character. +** {F16415} If the third parameter to sqlite3_result_error() or +** sqlite3_result_error16() is non-negative then SQLite takes that many +** bytes (not characters) from the 2nd parameter as the error message. +** {F16417} The sqlite3_result_error() and sqlite3_result_error16() +** routines make a copy private copy of the error message text before +** they return. {END} Hence, the calling function can deallocate or +** modify the text after they return without harm. +** +** {F16421} The sqlite3_result_toobig() interface causes SQLite +** to throw an error indicating that a string or BLOB is to long +** to represent. {F16422} The sqlite3_result_nomem() interface +** causes SQLite to throw an exception indicating that the a +** memory allocation failed. +** +** {F16431} The sqlite3_result_int() interface sets the return value +** of the application-defined function to be the 32-bit signed integer +** value given in the 2nd argument. +** {F16432} The sqlite3_result_int64() interface sets the return value +** of the application-defined function to be the 64-bit signed integer +** value given in the 2nd argument. +** +** {F16437} The sqlite3_result_null() interface sets the return value +** of the application-defined function to be NULL. +** +** {F16441} The sqlite3_result_text(), sqlite3_result_text16(), +** sqlite3_result_text16le(), and sqlite3_result_text16be() interfaces +** set the return value of the application-defined function to be +** a text string which is represented as UTF-8, UTF-16 native byte order, +** UTF-16 little endian, or UTF-16 big endian, respectively. +** {F16442} SQLite takes the text result from the application from +** the 2nd parameter of the sqlite3_result_text* interfaces. +** {F16444} If the 3rd parameter to the sqlite3_result_text* interfaces +** is negative, then SQLite takes result text from the 2nd parameter +** through the first zero character. +** {F16447} If the 3rd parameter to the sqlite3_result_text* interfaces +** is non-negative, then as many bytes (not characters) of the text +** pointed to by the 2nd parameter are taken as the application-defined +** function result. +** {F16451} If the 4th parameter to the sqlite3_result_text* interfaces +** or sqlite3_result_blob is a non-NULL pointer, then SQLite calls that +** function as the destructor on the text or blob result when it has +** finished using that result. +** {F16453} If the 4th parameter to the sqlite3_result_text* interfaces +** or sqlite3_result_blob is the special constant SQLITE_STATIC, then +** SQLite assumes that the text or blob result is constant space and +** does not copy the space or call a destructor when it has +** finished using that result. +** {F16454} If the 4th parameter to the sqlite3_result_text* interfaces +** or sqlite3_result_blob is the special constant SQLITE_TRANSIENT +** then SQLite makes a copy of the result into space obtained from +** from [sqlite3_malloc()] before it returns. +** +** {F16461} The sqlite3_result_value() interface sets the result of +** the application-defined function to be a copy the [sqlite3_value] +** object specified by the 2nd parameter. {F16463} The +** sqlite3_result_value() interface makes a copy of the [sqlite3_value] +** so that [sqlite3_value] specified in the parameter may change or +** be deallocated after sqlite3_result_value() returns without harm. +** +** {U16491} These routines are called from within the different thread +** than the one containing the application-defined function that recieved +** the [sqlite3_context] pointer, the results are undefined. +*/ +/*IMPORT_C*/ void sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*)); +/*IMPORT_C*/ void sqlite3_result_double(sqlite3_context*, double); +/*IMPORT_C*/ void sqlite3_result_error(sqlite3_context*, const char*, int); +/*IMPORT_C*/ void sqlite3_result_error16(sqlite3_context*, const void*, int); +/*IMPORT_C*/ void sqlite3_result_error_toobig(sqlite3_context*); +/*IMPORT_C*/ void sqlite3_result_error_nomem(sqlite3_context*); +/*IMPORT_C*/ void sqlite3_result_int(sqlite3_context*, int); +/*IMPORT_C*/ void sqlite3_result_int64(sqlite3_context*, sqlite3_int64); +/*IMPORT_C*/ void sqlite3_result_null(sqlite3_context*); +/*IMPORT_C*/ void sqlite3_result_text(sqlite3_context*, const char*, int, void(*)(void*)); +/*IMPORT_C*/ void sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*)); +/*IMPORT_C*/ void sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*)); +/*IMPORT_C*/ void sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*)); +/*IMPORT_C*/ void sqlite3_result_value(sqlite3_context*, sqlite3_value*); +/*IMPORT_C*/ void sqlite3_result_zeroblob(sqlite3_context*, int n); + +/* +** CAPI3REF: Define New Collating Sequences {F16600} +** +** {F16601} +** These functions are used to add new collation sequences to the +** [sqlite3*] handle specified as the first argument. +** +** {F16602} +** The name of the new collation sequence is specified as a UTF-8 string +** for sqlite3_create_collation() and sqlite3_create_collation_v2() +** and a UTF-16 string for sqlite3_create_collation16(). {F16603} In all cases +** the name is passed as the second function argument. +** +** {F16604} +** The third argument may be one of the constants [SQLITE_UTF8], +** [SQLITE_UTF16LE] or [SQLITE_UTF16BE], indicating that the user-supplied +** routine expects to be passed pointers to strings encoded using UTF-8, +** UTF-16 little-endian or UTF-16 big-endian respectively. {F16605} The +** third argument might also be [SQLITE_UTF16_ALIGNED] to indicate that +** the routine expects pointers to 16-bit word aligned strings +** of UTF16 in the native byte order of the host computer. +** +** {F16607} +** A pointer to the user supplied routine must be passed as the fifth +** argument. {F16609} If it is NULL, this is the same as deleting the collation +** sequence (so that SQLite cannot call it anymore). +** {F16611} Each time the application +** supplied function is invoked, it is passed a copy of the void* passed as +** the fourth argument to sqlite3_create_collation() or +** sqlite3_create_collation16() as its first parameter. +** +** {F16612} +** The remaining arguments to the application-supplied routine are two strings, +** each represented by a [length, data] pair and encoded in the encoding +** that was passed as the third argument when the collation sequence was +** registered. {END} The application defined collation routine should +** return negative, zero or positive if +** the first string is less than, equal to, or greater than the second +** string. i.e. (STRING1 - STRING2). +** +** {F16615} +** The sqlite3_create_collation_v2() works like sqlite3_create_collation() +** excapt that it takes an extra argument which is a destructor for +** the collation. {F16617} The destructor is called when the collation is +** destroyed and is passed a copy of the fourth parameter void* pointer +** of the sqlite3_create_collation_v2(). +** {F16618} Collations are destroyed when +** they are overridden by later calls to the collation creation functions +** or when the [sqlite3*] database handle is closed using [sqlite3_close()]. +*/ +/*IMPORT_C*/ int sqlite3_create_collation( + sqlite3*, + const char *zName, + int eTextRep, + void*, + int(*xCompare)(void*,int,const void*,int,const void*) +); +/*IMPORT_C*/ int sqlite3_create_collation_v2( + sqlite3*, + const char *zName, + int eTextRep, + void*, + int(*xCompare)(void*,int,const void*,int,const void*), + void(*xDestroy)(void*) +); +/*IMPORT_C*/ int sqlite3_create_collation16( + sqlite3*, + const char *zName, + int eTextRep, + void*, + int(*xCompare)(void*,int,const void*,int,const void*) +); + +/* +** CAPI3REF: Collation Needed Callbacks {F16700} +** +** {F16701} +** To avoid having to register all collation sequences before a database +** can be used, a single callback function may be registered with the +** database handle to be called whenever an undefined collation sequence is +** required. +** +** {F16702} +** If the function is registered using the sqlite3_collation_needed() API, +** then it is passed the names of undefined collation sequences as strings +** encoded in UTF-8. {F16703} If sqlite3_collation_needed16() is used, the names +** are passed as UTF-16 in machine native byte order. {F16704} A call to either +** function replaces any existing callback. +** +** {F16705} When the callback is invoked, the first argument passed is a copy +** of the second argument to sqlite3_collation_needed() or +** sqlite3_collation_needed16(). {F16706} The second argument is the database +** handle. {F16707} The third argument is one of [SQLITE_UTF8], +** [SQLITE_UTF16BE], or [SQLITE_UTF16LE], indicating the most +** desirable form of the collation sequence function required. +** {F16708} The fourth parameter is the name of the +** required collation sequence. {END} +** +** The callback function should register the desired collation using +** [sqlite3_create_collation()], [sqlite3_create_collation16()], or +** [sqlite3_create_collation_v2()]. +*/ +/*IMPORT_C*/ int sqlite3_collation_needed( + sqlite3*, + void*, + void(*)(void*,sqlite3*,int eTextRep,const char*) +); +/*IMPORT_C*/ int sqlite3_collation_needed16( + sqlite3*, + void*, + void(*)(void*,sqlite3*,int eTextRep,const void*) +); + +/* +** Specify the key for an encrypted database. This routine should be +** called right after sqlite3_open(). +** +** The code to implement this API is not available in the public release +** of SQLite. +*/ +/*IMPORT_C*/ int sqlite3_key( + sqlite3 *db, /* Database to be rekeyed */ + const void *pKey, int nKey /* The key */ +); + +/* +** Change the key on an open database. If the current database is not +** encrypted, this routine will encrypt it. If pNew==0 or nNew==0, the +** database is decrypted. +** +** The code to implement this API is not available in the public release +** of SQLite. +*/ +/*IMPORT_C*/ int sqlite3_rekey( + sqlite3 *db, /* Database to be rekeyed */ + const void *pKey, int nKey /* The new key */ +); + +/* +** CAPI3REF: Suspend Execution For A Short Time {F10530} +** +** {F10531} The sqlite3_sleep() function +** causes the current thread to suspend execution +** for at least a number of milliseconds specified in its parameter. +** +** {F10532} If the operating system does not support sleep requests with +** millisecond time resolution, then the time will be rounded up to +** the nearest second. {F10533} The number of milliseconds of sleep actually +** requested from the operating system is returned. +** +** {F10534} SQLite implements this interface by calling the xSleep() +** method of the default [sqlite3_vfs] object. {END} +*/ +/*IMPORT_C*/ int sqlite3_sleep(int); + +/* +** CAPI3REF: Name Of The Folder Holding Temporary Files {F10310} +** +** If this global variable is made to point to a string which is +** the name of a folder (a.ka. directory), then all temporary files +** created by SQLite will be placed in that directory. If this variable +** is NULL pointer, then SQLite does a search for an appropriate temporary +** file directory. +** +** It is not safe to modify this variable once a database connection +** has been opened. It is intended that this variable be set once +** as part of process initialization and before any SQLite interface +** routines have been call and remain unchanged thereafter. +*/ +SQLITE_EXTERN char *sqlite3_temp_directory; + +/* +** CAPI3REF: Test To See If The Database Is In Auto-Commit Mode {F12930} +** +** {F12931} The sqlite3_get_autocommit() interfaces returns non-zero or +** zero if the given database connection is or is not in autocommit mode, +** respectively. {F12932} Autocommit mode is on +** by default. {F12933} Autocommit mode is disabled by a BEGIN statement. +** {F12934} Autocommit mode is reenabled by a COMMIT or ROLLBACK. {END} +** +** If certain kinds of errors occur on a statement within a multi-statement +** transactions (errors including [SQLITE_FULL], [SQLITE_IOERR], +** [SQLITE_NOMEM], [SQLITE_BUSY], and [SQLITE_INTERRUPT]) then the +** transaction might be rolled back automatically. {F12935} The only way to +** find out if SQLite automatically rolled back the transaction after +** an error is to use this function. {END} +** +** {U12936} If another thread changes the autocommit status of the database +** connection while this routine is running, then the return value +** is undefined. {END} +*/ +/*IMPORT_C*/ int sqlite3_get_autocommit(sqlite3*); + +/* +** CAPI3REF: Find The Database Handle Of A Prepared Statement {F13120} +** +** {F13121} The sqlite3_db_handle interface +** returns the [sqlite3*] database handle to which a +** [sqlite3_stmt | prepared statement] belongs. +** {F13122} the database handle returned by sqlite3_db_handle +** is the same database handle that was +** the first argument to the [sqlite3_prepare_v2()] or its variants +** that was used to create the statement in the first place. +*/ +/*IMPORT_C*/ sqlite3 *sqlite3_db_handle(sqlite3_stmt*); + + +/* +** CAPI3REF: Commit And Rollback Notification Callbacks {F12950} +** +** {F12951} The sqlite3_commit_hook() interface registers a callback +** function to be invoked whenever a transaction is committed. +** {F12952} Any callback set by a previous call to sqlite3_commit_hook() +** for the same database connection is overridden. +** {F12953} The sqlite3_rollback_hook() interface registers a callback +** function to be invoked whenever a transaction is committed. +** {F12954} Any callback set by a previous call to sqlite3_commit_hook() +** for the same database connection is overridden. +** {F12956} The pArg argument is passed through +** to the callback. {F12957} If the callback on a commit hook function +** returns non-zero, then the commit is converted into a rollback. +** +** {F12958} If another function was previously registered, its +** pArg value is returned. Otherwise NULL is returned. +** +** {F12959} Registering a NULL function disables the callback. +** +** {F12961} For the purposes of this API, a transaction is said to have been +** rolled back if an explicit "ROLLBACK" statement is executed, or +** an error or constraint causes an implicit rollback to occur. +** {F12962} The rollback callback is not invoked if a transaction is +** automatically rolled back because the database connection is closed. +** {F12964} The rollback callback is not invoked if a transaction is +** rolled back because a commit callback returned non-zero. +** Check on this {END} +** +** These are experimental interfaces and are subject to change. +*/ +/*IMPORT_C*/ void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*); +/*IMPORT_C*/ void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*); + +/* +** CAPI3REF: Data Change Notification Callbacks {F12970} +** +** {F12971} The sqlite3_update_hook() interface +** registers a callback function with the database connection identified by the +** first argument to be invoked whenever a row is updated, inserted or deleted. +** {F12972} Any callback set by a previous call to this function for the same +** database connection is overridden. +** +** {F12974} The second argument is a pointer to the function to invoke when a +** row is updated, inserted or deleted. +** {F12976} The first argument to the callback is +** a copy of the third argument to sqlite3_update_hook(). +** {F12977} The second callback +** argument is one of [SQLITE_INSERT], [SQLITE_DELETE] or [SQLITE_UPDATE], +** depending on the operation that caused the callback to be invoked. +** {F12978} The third and +** fourth arguments to the callback contain pointers to the database and +** table name containing the affected row. +** {F12979} The final callback parameter is +** the rowid of the row. +** {F12981} In the case of an update, this is the rowid after +** the update takes place. +** +** {F12983} The update hook is not invoked when internal system tables are +** modified (i.e. sqlite_master and sqlite_sequence). +** +** {F12984} If another function was previously registered, its pArg value +** is returned. {F12985} Otherwise NULL is returned. +*/ +/*IMPORT_C*/ void *sqlite3_update_hook( + sqlite3*, + void(*)(void *,int ,char const *,char const *,sqlite3_int64), + void* +); + +/* +** CAPI3REF: Enable Or Disable Shared Pager Cache {F10330} +** +** {F10331} +** This routine enables or disables the sharing of the database cache +** and schema data structures between connections to the same database. +** {F10332} +** Sharing is enabled if the argument is true and disabled if the argument +** is false. +** +** {F10333} Cache sharing is enabled and disabled +** for an entire process. {END} This is a change as of SQLite version 3.5.0. +** In prior versions of SQLite, sharing was +** enabled or disabled for each thread separately. +** +** {F10334} +** The cache sharing mode set by this interface effects all subsequent +** calls to [sqlite3_open()], [sqlite3_open_v2()], and [sqlite3_open16()]. +** {F10335} Existing database connections continue use the sharing mode +** that was in effect at the time they were opened. {END} +** +** Virtual tables cannot be used with a shared cache. {F10336} When shared +** cache is enabled, the [sqlite3_create_module()] API used to register +** virtual tables will always return an error. {END} +** +** {F10337} This routine returns [SQLITE_OK] if shared cache was +** enabled or disabled successfully. {F10338} An [SQLITE_ERROR | error code] +** is returned otherwise. {END} +** +** {F10339} Shared cache is disabled by default. {END} But this might change in +** future releases of SQLite. Applications that care about shared +** cache setting should set it explicitly. +*/ +/*IMPORT_C*/ int sqlite3_enable_shared_cache(int); + +/* +** CAPI3REF: Attempt To Free Heap Memory {F17340} +** +** {F17341} The sqlite3_release_memory() interface attempts to +** free N bytes of heap memory by deallocating non-essential memory +** allocations held by the database labrary. {END} Memory used +** to cache database pages to improve performance is an example of +** non-essential memory. {F16342} sqlite3_release_memory() returns +** the number of bytes actually freed, which might be more or less +** than the amount requested. +*/ +/*IMPORT_C*/ int sqlite3_release_memory(int); + +/* +** CAPI3REF: Impose A Limit On Heap Size {F17350} +** +** {F16351} The sqlite3_soft_heap_limit() interface +** places a "soft" limit on the amount of heap memory that may be allocated +** by SQLite. {F16352} If an internal allocation is requested +** that would exceed the soft heap limit, [sqlite3_release_memory()] is +** invoked one or more times to free up some space before the allocation +** is made. {END} +** +** {F16353} The limit is called "soft", because if +** [sqlite3_release_memory()] cannot +** free sufficient memory to prevent the limit from being exceeded, +** the memory is allocated anyway and the current operation proceeds. +** +** {F16354} +** A negative or zero value for N means that there is no soft heap limit and +** [sqlite3_release_memory()] will only be called when memory is exhausted. +** {F16355} The default value for the soft heap limit is zero. +** +** SQLite makes a best effort to honor the soft heap limit. +** {F16356} But if the soft heap limit cannot honored, execution will +** continue without error or notification. {END} This is why the limit is +** called a "soft" limit. It is advisory only. +** +** Prior to SQLite version 3.5.0, this routine only constrained the memory +** allocated by a single thread - the same thread in which this routine +** runs. Beginning with SQLite version 3.5.0, the soft heap limit is +** applied to all threads. {F16357} The value specified for the soft heap limit +** is an upper bound on the total memory allocation for all threads. {END} In +** version 3.5.0 there is no mechanism for limiting the heap usage for +** individual threads. +*/ +/*IMPORT_C*/ void sqlite3_soft_heap_limit(int); + +/* +** CAPI3REF: Extract Metadata About A Column Of A Table {F12850} +** +** This routine +** returns meta-data about a specific column of a specific database +** table accessible using the connection handle passed as the first function +** argument. +** +** The column is identified by the second, third and fourth parameters to +** this function. The second parameter is either the name of the database +** (i.e. "main", "temp" or an attached database) containing the specified +** table or NULL. If it is NULL, then all attached databases are searched +** for the table using the same algorithm as the database engine uses to +** resolve unqualified table references. +** +** The third and fourth parameters to this function are the table and column +** name of the desired column, respectively. Neither of these parameters +** may be NULL. +** +** Meta information is returned by writing to the memory locations passed as +** the 5th and subsequent parameters to this function. Any of these +** arguments may be NULL, in which case the corresponding element of meta +** information is ommitted. +** +** 
+** Parameter     Output Type      Description
+** -----------------------------------
+**
+**   5th         const char*      Data type
+**   6th         const char*      Name of the default collation sequence 
+**   7th         int              True if the column has a NOT NULL constraint
+**   8th         int              True if the column is part of the PRIMARY KEY
+**   9th         int              True if the column is AUTOINCREMENT
+**
+** +** +** The memory pointed to by the character pointers returned for the +** declaration type and collation sequence is valid only until the next +** call to any sqlite API function. +** +** If the specified table is actually a view, then an error is returned. +** +** If the specified column is "rowid", "oid" or "_rowid_" and an +** INTEGER PRIMARY KEY column has been explicitly declared, then the output +** parameters are set for the explicitly declared column. If there is no +** explicitly declared IPK column, then the output parameters are set as +** follows: +** +** 
+**     data type: "INTEGER"
+**     collation sequence: "BINARY"
+**     not null: 0
+**     primary key: 1
+**     auto increment: 0
+**
+** +** This function may load one or more schemas from database files. If an +** error occurs during this process, or if the requested table or column +** cannot be found, an SQLITE error code is returned and an error message +** left in the database handle (to be retrieved using sqlite3_errmsg()). +** +** This API is only available if the library was compiled with the +** SQLITE_ENABLE_COLUMN_METADATA preprocessor symbol defined. +*/ +/*IMPORT_C*/ int sqlite3_table_column_metadata( + sqlite3 *db, /* Connection handle */ + const char *zDbName, /* Database name or NULL */ + const char *zTableName, /* Table name */ + const char *zColumnName, /* Column name */ + char const **pzDataType, /* OUTPUT: Declared data type */ + char const **pzCollSeq, /* OUTPUT: Collation sequence name */ + int *pNotNull, /* OUTPUT: True if NOT NULL constraint exists */ + int *pPrimaryKey, /* OUTPUT: True if column part of PK */ + int *pAutoinc /* OUTPUT: True if column is auto-increment */ +); + +/* +** CAPI3REF: Load An Extension {F12600} +** +** {F12601} The sqlite3_load_extension() interface +** attempts to load an SQLite extension library contained in the file +** zFile. {F12602} The entry point is zProc. {F12603} zProc may be 0 +** in which case the name of the entry point defaults +** to "sqlite3_extension_init". +** +** {F12604} The sqlite3_load_extension() interface shall +** return [SQLITE_OK] on success and [SQLITE_ERROR] if something goes wrong. +** +** {F12605} +** If an error occurs and pzErrMsg is not 0, then the +** sqlite3_load_extension() interface shall attempt to fill *pzErrMsg with +** error message text stored in memory obtained from [sqlite3_malloc()]. +** {END} The calling function should free this memory +** by calling [sqlite3_free()]. +** +** {F12606} +** Extension loading must be enabled using [sqlite3_enable_load_extension()] +** prior to calling this API or an error will be returned. +*/ +/*IMPORT_C*/ int sqlite3_load_extension( + sqlite3 *db, /* Load the extension into this database connection */ + const char *zFile, /* Name of the shared library containing extension */ + const char *zProc, /* Entry point. Derived from zFile if 0 */ + char **pzErrMsg /* Put error message here if not 0 */ +); + +/* +** CAPI3REF: Enable Or Disable Extension Loading {F12620} +** +** So as not to open security holes in older applications that are +** unprepared to deal with extension loading, and as a means of disabling +** extension loading while evaluating user-entered SQL, the following +** API is provided to turn the [sqlite3_load_extension()] mechanism on and +** off. {F12622} It is off by default. {END} See ticket #1863. +** +** {F12621} Call the sqlite3_enable_load_extension() routine +** with onoff==1 to turn extension loading on +** and call it with onoff==0 to turn it back off again. {END} +*/ +/*IMPORT_C*/ int sqlite3_enable_load_extension(sqlite3 *db, int onoff); + +/* +** CAPI3REF: Make Arrangements To Automatically Load An Extension {F12640} +** +** {F12641} This function +** registers an extension entry point that is automatically invoked +** whenever a new database connection is opened using +** [sqlite3_open()], [sqlite3_open16()], or [sqlite3_open_v2()]. {END} +** +** This API can be invoked at program startup in order to register +** one or more statically linked extensions that will be available +** to all new database connections. +** +** {F12642} Duplicate extensions are detected so calling this routine multiple +** times with the same extension is harmless. +** +** {F12643} This routine stores a pointer to the extension in an array +** that is obtained from sqlite_malloc(). {END} If you run a memory leak +** checker on your program and it reports a leak because of this +** array, then invoke [sqlite3_reset_auto_extension()] prior +** to shutdown to free the memory. +** +** {F12644} Automatic extensions apply across all threads. {END} +** +** This interface is experimental and is subject to change or +** removal in future releases of SQLite. +*/ +/*IMPORT_C*/ int sqlite3_auto_extension(void *xEntryPoint); + + +/* +** CAPI3REF: Reset Automatic Extension Loading {F12660} +** +** {F12661} This function disables all previously registered +** automatic extensions. {END} This +** routine undoes the effect of all prior [sqlite3_automatic_extension()] +** calls. +** +** {F12662} This call disabled automatic extensions in all threads. {END} +** +** This interface is experimental and is subject to change or +** removal in future releases of SQLite. +*/ +/*IMPORT_C*/ void sqlite3_reset_auto_extension(void); + + +/* +****** EXPERIMENTAL - subject to change without notice ************** +** +** The interface to the virtual-table mechanism is currently considered +** to be experimental. The interface might change in incompatible ways. +** If this is a problem for you, do not use the interface at this time. +** +** When the virtual-table mechanism stablizes, we will declare the +** interface fixed, support it indefinitely, and remove this comment. +*/ + +/* +** Structures used by the virtual table interface +*/ +typedef struct sqlite3_vtab sqlite3_vtab; +typedef struct sqlite3_index_info sqlite3_index_info; +typedef struct sqlite3_vtab_cursor sqlite3_vtab_cursor; +typedef struct sqlite3_module sqlite3_module; + +/* +** A module is a class of virtual tables. Each module is defined +** by an instance of the following structure. This structure consists +** mostly of methods for the module. +*/ +struct sqlite3_module { + int iVersion; + int (*xCreate)(sqlite3*, void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVTab, char**); + int (*xConnect)(sqlite3*, void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVTab, char**); + int (*xBestIndex)(sqlite3_vtab *pVTab, sqlite3_index_info*); + int (*xDisconnect)(sqlite3_vtab *pVTab); + int (*xDestroy)(sqlite3_vtab *pVTab); + int (*xOpen)(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor); + int (*xClose)(sqlite3_vtab_cursor*); + int (*xFilter)(sqlite3_vtab_cursor*, int idxNum, const char *idxStr, + int argc, sqlite3_value **argv); + int (*xNext)(sqlite3_vtab_cursor*); + int (*xEof)(sqlite3_vtab_cursor*); + int (*xColumn)(sqlite3_vtab_cursor*, sqlite3_context*, int); + int (*xRowid)(sqlite3_vtab_cursor*, sqlite3_int64 *pRowid); + int (*xUpdate)(sqlite3_vtab *, int, sqlite3_value **, sqlite3_int64 *); + int (*xBegin)(sqlite3_vtab *pVTab); + int (*xSync)(sqlite3_vtab *pVTab); + int (*xCommit)(sqlite3_vtab *pVTab); + int (*xRollback)(sqlite3_vtab *pVTab); + int (*xFindFunction)(sqlite3_vtab *pVtab, int nArg, const char *zName, + void (**pxFunc)(sqlite3_context*,int,sqlite3_value**), + void **ppArg); + + int (*xRename)(sqlite3_vtab *pVtab, const char *zNew); +}; + +/* +** The sqlite3_index_info structure and its substructures is used to +** pass information into and receive the reply from the xBestIndex +** method of an sqlite3_module. The fields under **Inputs** are the +** inputs to xBestIndex and are read-only. xBestIndex inserts its +** results into the **Outputs** fields. +** +** The aConstraint[] array records WHERE clause constraints of the +** form: +** +** column OP expr +** +** Where OP is =, <, <=, >, or >=. +** The particular operator is stored +** in aConstraint[].op. The index of the column is stored in +** aConstraint[].iColumn. aConstraint[].usable is TRUE if the +** expr on the right-hand side can be evaluated (and thus the constraint +** is usable) and false if it cannot. +** +** The optimizer automatically inverts terms of the form "expr OP column" +** and makes other simplifications to the WHERE clause in an attempt to +** get as many WHERE clause terms into the form shown above as possible. +** The aConstraint[] array only reports WHERE clause terms in the correct +** form that refer to the particular virtual table being queried. +** +** Information about the ORDER BY clause is stored in aOrderBy[]. +** Each term of aOrderBy records a column of the ORDER BY clause. +** +** The xBestIndex method must fill aConstraintUsage[] with information +** about what parameters to pass to xFilter. If argvIndex>0 then +** the right-hand side of the corresponding aConstraint[] is evaluated +** and becomes the argvIndex-th entry in argv. If aConstraintUsage[].omit +** is true, then the constraint is assumed to be fully handled by the +** virtual table and is not checked again by SQLite. +** +** The idxNum and idxPtr values are recorded and passed into xFilter. +** sqlite3_free() is used to free idxPtr if needToFreeIdxPtr is true. +** +** The orderByConsumed means that output from xFilter will occur in +** the correct order to satisfy the ORDER BY clause so that no separate +** sorting step is required. +** +** The estimatedCost value is an estimate of the cost of doing the +** particular lookup. A full scan of a table with N entries should have +** a cost of N. A binary search of a table of N entries should have a +** cost of approximately log(N). +*/ +struct sqlite3_index_info { + /* Inputs */ + int nConstraint; /* Number of entries in aConstraint */ + struct sqlite3_index_constraint { + int iColumn; /* Column on left-hand side of constraint */ + unsigned char op; /* Constraint operator */ + unsigned char usable; /* True if this constraint is usable */ + int iTermOffset; /* Used internally - xBestIndex should ignore */ + } *aConstraint; /* Table of WHERE clause constraints */ + int nOrderBy; /* Number of terms in the ORDER BY clause */ + struct sqlite3_index_orderby { + int iColumn; /* Column number */ + unsigned char desc; /* True for DESC. False for ASC. */ + } *aOrderBy; /* The ORDER BY clause */ + + /* Outputs */ + struct sqlite3_index_constraint_usage { + int argvIndex; /* if >0, constraint is part of argv to xFilter */ + unsigned char omit; /* Do not code a test for this constraint */ + } *aConstraintUsage; + int idxNum; /* Number used to identify the index */ + char *idxStr; /* String, possibly obtained from sqlite3_malloc */ + int needToFreeIdxStr; /* Free idxStr using sqlite3_free() if true */ + int orderByConsumed; /* True if output is already ordered */ + double estimatedCost; /* Estimated cost of using this index */ +}; +#define SQLITE_INDEX_CONSTRAINT_EQ 2 +#define SQLITE_INDEX_CONSTRAINT_GT 4 +#define SQLITE_INDEX_CONSTRAINT_LE 8 +#define SQLITE_INDEX_CONSTRAINT_LT 16 +#define SQLITE_INDEX_CONSTRAINT_GE 32 +#define SQLITE_INDEX_CONSTRAINT_MATCH 64 + +/* +** This routine is used to register a new module name with an SQLite +** connection. Module names must be registered before creating new +** virtual tables on the module, or before using preexisting virtual +** tables of the module. +*/ +/*IMPORT_C*/ int sqlite3_create_module( + sqlite3 *db, /* SQLite connection to register module with */ + const char *zName, /* Name of the module */ + const sqlite3_module *, /* Methods for the module */ + void * /* Client data for xCreate/xConnect */ +); + +/* +** This routine is identical to the sqlite3_create_module() method above, +** except that it allows a destructor function to be specified. It is +** even more experimental than the rest of the virtual tables API. +*/ +/*IMPORT_C*/ int sqlite3_create_module_v2( + sqlite3 *db, /* SQLite connection to register module with */ + const char *zName, /* Name of the module */ + const sqlite3_module *, /* Methods for the module */ + void *, /* Client data for xCreate/xConnect */ + void(*xDestroy)(void*) /* Module destructor function */ +); + +/* +** Every module implementation uses a subclass of the following structure +** to describe a particular instance of the module. Each subclass will +** be tailored to the specific needs of the module implementation. The +** purpose of this superclass is to define certain fields that are common +** to all module implementations. +** +** Virtual tables methods can set an error message by assigning a +** string obtained from sqlite3_mprintf() to zErrMsg. The method should +** take care that any prior string is freed by a call to sqlite3_free() +** prior to assigning a new string to zErrMsg. After the error message +** is delivered up to the client application, the string will be automatically +** freed by sqlite3_free() and the zErrMsg field will be zeroed. Note +** that sqlite3_mprintf() and sqlite3_free() are used on the zErrMsg field +** since virtual tables are commonly implemented in loadable extensions which +** do not have access to sqlite3MPrintf() or sqlite3Free(). +*/ +struct sqlite3_vtab { + const sqlite3_module *pModule; /* The module for this virtual table */ + int nRef; /* Used internally */ + char *zErrMsg; /* Error message from sqlite3_mprintf() */ + /* Virtual table implementations will typically add additional fields */ +}; + +/* Every module implementation uses a subclass of the following structure +** to describe cursors that point into the virtual table and are used +** to loop through the virtual table. Cursors are created using the +** xOpen method of the module. Each module implementation will define +** the content of a cursor structure to suit its own needs. +** +** This superclass exists in order to define fields of the cursor that +** are common to all implementations. +*/ +struct sqlite3_vtab_cursor { + sqlite3_vtab *pVtab; /* Virtual table of this cursor */ + /* Virtual table implementations will typically add additional fields */ +}; + +/* +** The xCreate and xConnect methods of a module use the following API +** to declare the format (the names and datatypes of the columns) of +** the virtual tables they implement. +*/ +/*IMPORT_C*/ int sqlite3_declare_vtab(sqlite3*, const char *zCreateTable); + +/* +** Virtual tables can provide alternative implementations of functions +** using the xFindFunction method. But global versions of those functions +** must exist in order to be overloaded. +** +** This API makes sure a global version of a function with a particular +** name and number of parameters exists. If no such function exists +** before this API is called, a new function is created. The implementation +** of the new function always causes an exception to be thrown. So +** the new function is not good for anything by itself. Its only +** purpose is to be a place-holder function that can be overloaded +** by virtual tables. +** +** This API should be considered part of the virtual table interface, +** which is experimental and subject to change. +*/ +/*IMPORT_C*/ int sqlite3_overload_function(sqlite3*, const char *zFuncName, int nArg); + +/* +** The interface to the virtual-table mechanism defined above (back up +** to a comment remarkably similar to this one) is currently considered +** to be experimental. The interface might change in incompatible ways. +** If this is a problem for you, do not use the interface at this time. +** +** When the virtual-table mechanism stabilizes, we will declare the +** interface fixed, support it indefinitely, and remove this comment. +** +****** EXPERIMENTAL - subject to change without notice ************** +*/ + +/* +** CAPI3REF: A Handle To An Open BLOB {F17800} +** +** An instance of the following opaque structure is used to +** represent an blob-handle. A blob-handle is created by +** [sqlite3_blob_open()] and destroyed by [sqlite3_blob_close()]. +** The [sqlite3_blob_read()] and [sqlite3_blob_write()] interfaces +** can be used to read or write small subsections of the blob. +** The [sqlite3_blob_bytes()] interface returns the size of the +** blob in bytes. +*/ +typedef struct sqlite3_blob sqlite3_blob; + +/* +** CAPI3REF: Open A BLOB For Incremental I/O {F17810} +** +** {F17811} This interfaces opens a handle to the blob located +** in row iRow,, column zColumn, table zTable in database zDb; +** in other words, the same blob that would be selected by: +** +** 
+**     SELECT zColumn FROM zDb.zTable WHERE rowid = iRow;
+**
{END} +** +** {F17812} If the flags parameter is non-zero, the blob is opened for +** read and write access. If it is zero, the blob is opened for read +** access. {END} +** +** {F17813} On success, [SQLITE_OK] is returned and the new +** [sqlite3_blob | blob handle] is written to *ppBlob. +** {F17814} Otherwise an error code is returned and +** any value written to *ppBlob should not be used by the caller. +** {F17815} This function sets the database-handle error code and message +** accessible via [sqlite3_errcode()] and [sqlite3_errmsg()]. +** We should go through and mark all interfaces that behave this +** way with a similar statement +*/ +/*IMPORT_C*/ int sqlite3_blob_open( + sqlite3*, + const char *zDb, + const char *zTable, + const char *zColumn, + sqlite3_int64 iRow, + int flags, + sqlite3_blob **ppBlob +); + +/* +** CAPI3REF: Close A BLOB Handle {F17830} +** +** Close an open [sqlite3_blob | blob handle]. +** +** {F17831} Closing a BLOB shall cause the current transaction to commit +** if there are no other BLOBs, no pending prepared statements, and the +** database connection is in autocommit mode. +** {F17832} If any writes were made to the BLOB, they might be held in cache +** until the close operation if they will fit. {END} +** Closing the BLOB often forces the changes +** out to disk and so if any I/O errors occur, they will likely occur +** at the time when the BLOB is closed. {F17833} Any errors that occur during +** closing are reported as a non-zero return value. +** +** {F17839} The BLOB is closed unconditionally. Even if this routine returns +** an error code, the BLOB is still closed. +*/ +/*IMPORT_C*/ int sqlite3_blob_close(sqlite3_blob *); + +/* +** CAPI3REF: Return The Size Of An Open BLOB {F17805} +** +** {F16806} Return the size in bytes of the blob accessible via the open +** [sqlite3_blob | blob-handle] passed as an argument. +*/ +/*IMPORT_C*/ int sqlite3_blob_bytes(sqlite3_blob *); + +/* +** CAPI3REF: Read Data From A BLOB Incrementally {F17850} +** +** This function is used to read data from an open +** [sqlite3_blob | blob-handle] into a caller supplied buffer. +** {F17851} n bytes of data are copied into buffer +** z from the open blob, starting at offset iOffset. +** +** {F17852} If offset iOffset is less than n bytes from the end of the blob, +** [SQLITE_ERROR] is returned and no data is read. {F17853} If n is +** less than zero [SQLITE_ERROR] is returned and no data is read. +** +** {F17854} On success, SQLITE_OK is returned. Otherwise, an +** [SQLITE_ERROR | SQLite error code] or an +** [SQLITE_IOERR_READ | extended error code] is returned. +*/ +/*IMPORT_C*/ int sqlite3_blob_read(sqlite3_blob *, void *z, int n, int iOffset); + +/* +** CAPI3REF: Write Data Into A BLOB Incrementally {F17870} +** +** This function is used to write data into an open +** [sqlite3_blob | blob-handle] from a user supplied buffer. +** {F17871} n bytes of data are copied from the buffer +** pointed to by z into the open blob, starting at offset iOffset. +** +** {F17872} If the [sqlite3_blob | blob-handle] passed as the first argument +** was not opened for writing (the flags parameter to [sqlite3_blob_open()] +*** was zero), this function returns [SQLITE_READONLY]. +** +** {F17873} This function may only modify the contents of the blob; it is +** not possible to increase the size of a blob using this API. +** {F17874} If offset iOffset is less than n bytes from the end of the blob, +** [SQLITE_ERROR] is returned and no data is written. {F17875} If n is +** less than zero [SQLITE_ERROR] is returned and no data is written. +** +** {F17876} On success, SQLITE_OK is returned. Otherwise, an +** [SQLITE_ERROR | SQLite error code] or an +** [SQLITE_IOERR_READ | extended error code] is returned. +*/ +/*IMPORT_C*/ int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset); + +/* +** CAPI3REF: Virtual File System Objects {F11200} +** +** A virtual filesystem (VFS) is an [sqlite3_vfs] object +** that SQLite uses to interact +** with the underlying operating system. Most builds come with a +** single default VFS that is appropriate for the host computer. +** New VFSes can be registered and existing VFSes can be unregistered. +** The following interfaces are provided. +** +** {F11201} The sqlite3_vfs_find() interface returns a pointer to +** a VFS given its name. {F11202} Names are case sensitive. +** {F11203} Names are zero-terminated UTF-8 strings. +** {F11204} If there is no match, a NULL +** pointer is returned. {F11205} If zVfsName is NULL then the default +** VFS is returned. {END} +** +** {F11210} New VFSes are registered with sqlite3_vfs_register(). +** {F11211} Each new VFS becomes the default VFS if the makeDflt flag is set. +** {F11212} The same VFS can be registered multiple times without injury. +** {F11213} To make an existing VFS into the default VFS, register it again +** with the makeDflt flag set. {U11214} If two different VFSes with the +** same name are registered, the behavior is undefined. {U11215} If a +** VFS is registered with a name that is NULL or an empty string, +** then the behavior is undefined. +** +** {F11220} Unregister a VFS with the sqlite3_vfs_unregister() interface. +** {F11221} If the default VFS is unregistered, another VFS is chosen as +** the default. The choice for the new VFS is arbitrary. +*/ +/*IMPORT_C*/ sqlite3_vfs *sqlite3_vfs_find(const char *zVfsName); +/*IMPORT_C*/ int sqlite3_vfs_register(sqlite3_vfs*, int makeDflt); +/*IMPORT_C*/ int sqlite3_vfs_unregister(sqlite3_vfs*); + +/* +** CAPI3REF: Mutexes {F17000} +** +** The SQLite core uses these routines for thread +** synchronization. Though they are intended for internal +** use by SQLite, code that links against SQLite is +** permitted to use any of these routines. +** +** The SQLite source code contains multiple implementations +** of these mutex routines. An appropriate implementation +** is selected automatically at compile-time. The following +** implementations are available in the SQLite core: +** +**
    +**
  • SQLITE_MUTEX_OS2 +**
  • SQLITE_MUTEX_PTHREAD +**
  • SQLITE_MUTEX_W32 +**
  • SQLITE_MUTEX_NOOP +**
+** +** The SQLITE_MUTEX_NOOP implementation is a set of routines +** that does no real locking and is appropriate for use in +** a single-threaded application. The SQLITE_MUTEX_OS2, +** SQLITE_MUTEX_PTHREAD, and SQLITE_MUTEX_W32 implementations +** are appropriate for use on os/2, unix, and windows. +** +** If SQLite is compiled with the SQLITE_MUTEX_APPDEF preprocessor +** macro defined (with "-DSQLITE_MUTEX_APPDEF=1"), then no mutex +** implementation is included with the library. The +** mutex interface routines defined here become external +** references in the SQLite library for which implementations +** must be provided by the application. This facility allows an +** application that links against SQLite to provide its own mutex +** implementation without having to modify the SQLite core. +** +** {F17011} The sqlite3_mutex_alloc() routine allocates a new +** mutex and returns a pointer to it. {F17012} If it returns NULL +** that means that a mutex could not be allocated. {F17013} SQLite +** will unwind its stack and return an error. {F17014} The argument +** to sqlite3_mutex_alloc() is one of these integer constants: +** +**
    +**
  • SQLITE_MUTEX_FAST +**
  • SQLITE_MUTEX_RECURSIVE +**
  • SQLITE_MUTEX_STATIC_MASTER +**
  • SQLITE_MUTEX_STATIC_MEM +**
  • SQLITE_MUTEX_STATIC_MEM2 +**
  • SQLITE_MUTEX_STATIC_PRNG +**
  • SQLITE_MUTEX_STATIC_LRU +**
{END} +** +** {F17015} The first two constants cause sqlite3_mutex_alloc() to create +** a new mutex. The new mutex is recursive when SQLITE_MUTEX_RECURSIVE +** is used but not necessarily so when SQLITE_MUTEX_FAST is used. {END} +** The mutex implementation does not need to make a distinction +** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does +** not want to. {F17016} But SQLite will only request a recursive mutex in +** cases where it really needs one. {END} If a faster non-recursive mutex +** implementation is available on the host platform, the mutex subsystem +** might return such a mutex in response to SQLITE_MUTEX_FAST. +** +** {F17017} The other allowed parameters to sqlite3_mutex_alloc() each return +** a pointer to a static preexisting mutex. {END} Four static mutexes are +** used by the current version of SQLite. Future versions of SQLite +** may add additional static mutexes. Static mutexes are for internal +** use by SQLite only. Applications that use SQLite mutexes should +** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or +** SQLITE_MUTEX_RECURSIVE. +** +** {F17018} Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST +** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc() +** returns a different mutex on every call. {F17034} But for the static +** mutex types, the same mutex is returned on every call that has +** the same type number. {END} +** +** {F17019} The sqlite3_mutex_free() routine deallocates a previously +** allocated dynamic mutex. {F17020} SQLite is careful to deallocate every +** dynamic mutex that it allocates. {U17021} The dynamic mutexes must not be in +** use when they are deallocated. {U17022} Attempting to deallocate a static +** mutex results in undefined behavior. {F17023} SQLite never deallocates +** a static mutex. {END} +** +** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt +** to enter a mutex. {F17024} If another thread is already within the mutex, +** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return +** SQLITE_BUSY. {F17025} The sqlite3_mutex_try() interface returns SQLITE_OK +** upon successful entry. {F17026} Mutexes created using +** SQLITE_MUTEX_RECURSIVE can be entered multiple times by the same thread. +** {F17027} In such cases the, +** mutex must be exited an equal number of times before another thread +** can enter. {U17028} If the same thread tries to enter any other +** kind of mutex more than once, the behavior is undefined. +** {F17029} SQLite will never exhibit +** such behavior in its own use of mutexes. {END} +** +** Some systems (ex: windows95) do not the operation implemented by +** sqlite3_mutex_try(). On those systems, sqlite3_mutex_try() will +** always return SQLITE_BUSY. {F17030} The SQLite core only ever uses +** sqlite3_mutex_try() as an optimization so this is acceptable behavior. {END} +** +** {F17031} The sqlite3_mutex_leave() routine exits a mutex that was +** previously entered by the same thread. {U17032} The behavior +** is undefined if the mutex is not currently entered by the +** calling thread or is not currently allocated. {F17033} SQLite will +** never do either. {END} +** +** See also: [sqlite3_mutex_held()] and [sqlite3_mutex_notheld()]. +*/ +/*IMPORT_C*/ sqlite3_mutex *sqlite3_mutex_alloc(int); +/*IMPORT_C*/ void sqlite3_mutex_free(sqlite3_mutex*); +/*IMPORT_C*/ void sqlite3_mutex_enter(sqlite3_mutex*); +/*IMPORT_C*/ int sqlite3_mutex_try(sqlite3_mutex*); +/*IMPORT_C*/ void sqlite3_mutex_leave(sqlite3_mutex*); + +/* +** CAPI3REF: Mutex Verifcation Routines {F17080} +** +** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routines +** are intended for use inside assert() statements. {F17081} The SQLite core +** never uses these routines except inside an assert() and applications +** are advised to follow the lead of the core. {F17082} The core only +** provides implementations for these routines when it is compiled +** with the SQLITE_DEBUG flag. {U17087} External mutex implementations +** are only required to provide these routines if SQLITE_DEBUG is +** defined and if NDEBUG is not defined. +** +** {F17083} These routines should return true if the mutex in their argument +** is held or not held, respectively, by the calling thread. {END} +** +** {X17084} The implementation is not required to provided versions of these +** routines that actually work. +** If the implementation does not provide working +** versions of these routines, it should at least provide stubs +** that always return true so that one does not get spurious +** assertion failures. {END} +** +** {F17085} If the argument to sqlite3_mutex_held() is a NULL pointer then +** the routine should return 1. {END} This seems counter-intuitive since +** clearly the mutex cannot be held if it does not exist. But the +** the reason the mutex does not exist is because the build is not +** using mutexes. And we do not want the assert() containing the +** call to sqlite3_mutex_held() to fail, so a non-zero return is +** the appropriate thing to do. {F17086} The sqlite3_mutex_notheld() +** interface should also return 1 when given a NULL pointer. +*/ +/*IMPORT_C*/ int sqlite3_mutex_held(sqlite3_mutex*); +/*IMPORT_C*/ int sqlite3_mutex_notheld(sqlite3_mutex*); + +/* +** CAPI3REF: Mutex Types {F17001} +** +** {F17002} The [sqlite3_mutex_alloc()] interface takes a single argument +** which is one of these integer constants. {END} +*/ +#define SQLITE_MUTEX_FAST 0 +#define SQLITE_MUTEX_RECURSIVE 1 +#define SQLITE_MUTEX_STATIC_MASTER 2 +#define SQLITE_MUTEX_STATIC_MEM 3 /* sqlite3_malloc() */ +#define SQLITE_MUTEX_STATIC_MEM2 4 /* sqlite3_release_memory() */ +#define SQLITE_MUTEX_STATIC_PRNG 5 /* sqlite3_random() */ +#define SQLITE_MUTEX_STATIC_LRU 6 /* lru page list */ + +/* +** CAPI3REF: Low-Level Control Of Database Files {F11300} +** +** {F11301} The [sqlite3_file_control()] interface makes a direct call to the +** xFileControl method for the [sqlite3_io_methods] object associated +** with a particular database identified by the second argument. {F11302} The +** name of the database is the name assigned to the database by the +** ATTACH SQL command that opened the +** database. {F11303} To control the main database file, use the name "main" +** or a NULL pointer. {F11304} The third and fourth parameters to this routine +** are passed directly through to the second and third parameters of +** the xFileControl method. {F11305} The return value of the xFileControl +** method becomes the return value of this routine. +** +** {F11306} If the second parameter (zDbName) does not match the name of any +** open database file, then SQLITE_ERROR is returned. {F11307} This error +** code is not remembered and will not be recalled by [sqlite3_errcode()] +** or [sqlite3_errmsg()]. {U11308} The underlying xFileControl method might +** also return SQLITE_ERROR. {U11309} There is no way to distinguish between +** an incorrect zDbName and an SQLITE_ERROR return from the underlying +** xFileControl method. {END} +** +** See also: [SQLITE_FCNTL_LOCKSTATE] +*/ +/*IMPORT_C*/ int sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*); + +/*IMPORT_C*/ int sqlite3_openTest( + const char *zFilename +); + +/*IMPORT_C*/ int sqlite3_bind_double_ref(sqlite3_stmt *stmt, int iCol, double *val); + +/*IMPORT_C*/ int sqlite3_bind_int64_ref(sqlite3_stmt *stmt, int iCol, sqlite_int64 *val); + +/*IMPORT_C*/ void sqlite3_column_double_ref(sqlite3_stmt *stmt, int iCol, double *val); + +/*IMPORT_C*/ void sqlite3_column_int64_ref(sqlite3_stmt *stmt, int iCol, sqlite_int64 *val); + +/*IMPORT_C*/ unsigned int sqlite3_strlen(char *ptr); + +/* +** Undo the hack that converts floating point types to integer for +** builds on processors without floating point support. +*/ +#ifdef SQLITE_OMIT_FLOATING_POINT +# undef double +#endif + +#ifdef __cplusplus +} /* End of the 'extern "C"' block */ +#endif +#endif diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/group/bld.inf --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/group/bld.inf Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,10 @@ +// Project configuration file for SQLite +// Project platforms +PRJ_PLATFORMS +WINSCW GCCE +// Project exports +PRJ_EXPORTS + +// MMP files for project components +PRJ_MMPFILES +sqlite.mmp diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/group/sqlite.mmp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/group/sqlite.mmp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,60 @@ +TARGET sqlite_podcatcher.lib +TARGETTYPE lib +SOURCEPATH ..\src +SOURCE where.cpp +SOURCE vtab.cpp +SOURCE vdbemem.cpp +SOURCE vdbefifo.cpp +SOURCE vdbeblob.cpp +SOURCE vdbeaux.cpp +SOURCE vdbeapi.cpp +SOURCE vdbe.cpp +SOURCE vacuum.cpp +SOURCE util.cpp +SOURCE utf.cpp +SOURCE update.cpp +SOURCE trigger.cpp +SOURCE tokenize.cpp +SOURCE table.cpp +SOURCE select.cpp +SOURCE random.cpp +SOURCE printf.cpp +SOURCE prepare.cpp +SOURCE pragma.cpp +SOURCE parse.cpp +SOURCE pager.cpp +SOURCE os.cpp +SOURCE opcodes.cpp +SOURCE mutex.cpp +SOURCE mem4.cpp +SOURCE mem3.cpp +SOURCE mem2.cpp +SOURCE mem1.cpp +SOURCE malloc.cpp +SOURCE main.cpp +SOURCE loadext.cpp +SOURCE legacy.cpp +SOURCE journal.cpp +SOURCE insert.cpp +SOURCE helper.cpp +SOURCE hash.cpp +SOURCE func.cpp +SOURCE expr.cpp +SOURCE delete.cpp +SOURCE date.cpp +SOURCE complete.cpp +SOURCE callback.cpp +SOURCE build.cpp +SOURCE btree.cpp +SOURCE btmutex.cpp +SOURCE auth.cpp +SOURCE attach.cpp +SOURCE analyze.cpp +SOURCE alter.cpp +SOURCE os_symbian.cpp + +USERINCLUDE ..\src +USERINCLUDE .. +SYSTEMINCLUDE \Epoc32\include +SYSTEMINCLUDE \Epoc32\include\libc +macro OS_SYMBIAN diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/sqlite3.exe Binary file engine/sqlite/sqlite3.exe has changed diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/sqlite_port.doc Binary file engine/sqlite/sqlite_port.doc has changed diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/sqlite_port.htm --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/sqlite_port.htm Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,1535 @@ + + + + + + + + + + + + + + + + + + + +
+ +

SQLite implementation for Symbian OS with an ADO.NET +Provider for Red Five Labs’ .NET Compact Framework 1.0

+ +

Converting SQLite to S60

+ +

Red Five Labs’ +Net60, a .NET Compact Framework Version 1.0, introduces .NET programming to the +great family of Symbian S60 smartphones. Now it is possible to run a managed .NET +application, written for Windows Mobile, on S60 smartphones. Unfortunately, +however, the .NET Compact Framework 1.0 does not provide any form of database +support. This is first supported in the .NET Compact Framework 2.0 together +with the SQL Server Compact Edition. This SQL Server only runs on Windows +Mobile devices which means another database system is +needed to provide database functionality to Symbian devices. Enter SQLite for +S60.

+ +

SQLite is a +popular open source, stand-alone database system that was written in C and is +available for Windows, Windows Mobile, OS2 and Unix operating +systems. It is ACID compliant and supports the SQL-92 standard. The Symbian OS at +present does not provide a database system, however in the future Symbian OS +Version 9.4 will support a SQLite implementation.

+ +

 

+ +

PIPS for S60 made porting SQLite to Symbian OS +possible

+ +

At the +beginning of 2007 Symbian published the P.I.P.S. SDK (http://developer.symbian.com/wiki/display/oe/P.I.P.S.+Home +) for the S60 and UIQ platforms. P.I.P.S. is the implementation of the POSIX +Interface for Symbian OS that provides C Libraries like STDIO or STDLIB. With +the Open C SDK it is possible to port the SQLite library written in ANSI C to +Symbian OS. To do such a conversion of an existing ANSI C project knowledge of +programming for Symbian OS is needed. A good description of the conversion of +SQLite to S60 is the article on Dr.Dobbs (http://www.ddj.com/mobile/198702204?pgno=2) +and describes how such a port of SQLite could be done. By following these +instructions, it was easy to create a project that could compile the C files of +the SQLite project.

+ +

Note, the +PIPS SDK for S60 must be installed to the PC to compile the SqliteS60 project +whilst the PIPS_s60_1_2_SS .SIS must be installed on the device.

+ +

 

+ +

Converting SQLite .C files to .CPP files

+ +

Before the +SQLite source could be completely compiled, the file IO operations had to be +rewritten. This part of SQLite is not platform independent and uses the native +OS operations to open, read and write files.  +The first step was to rewrite the file operations with the STDIO +implementation.  For example the OpenDatabase method was modified to use +the fopen method of POSIX. Unfortunately +this did not result in the outcome that was expected.  On the test device this implementation does +not run. After analyzing this, it seems to be that the ANSI C file IO methods +cause the error.  The Symbian API is an +object oriented programming interface, therefore to use the native file IO classes, the SQLite source must be converted from .C files +to .CPP files. Renaming the files was easy, but after renaming the source files +over 500 compiler errors were output. Most of these were language differences +between C and C++ and could be solved quickly. After resolving these problems, +programming the OS routines with the Symbian file IO classes could begin.

+ +

For this +part a new file was created and added to the SQLiteS60 project +(os_symbian.cpp). This file includes all methods that SQLite expects for file +IO. The conversion of the existing C files of the SQLite project to CPP files +makes the SQLiteS60 project very different from the main source. As a result of +this, the implementations for the other OS operations, i.e. for OS2, Windows and +Mac, were deleted from this project. SQLite uses a structure to reference the +correct OS operations and is implemented in every OS implementation. Due to this +practice, only a compiler switch is needed to generate a run-able SQLite library +for the specific operating system. As this structure is not used in the S60 +conversion project, it has also been removed from the code and the Symbian IO +methods are directly connected to the OS methods in the file os.cpp.

+ +

 

+ +

A simple +example to open or create a file with native Symbian methods is shown in the +following code snippet.

+ +
RFs fileSession;
RFile file;   
 
fileSession.Connect();
 
TInt err=file.Open(fsSession,fileName,shareMode);
if (err==KErrNotFound) // file does not exist - create it
{
    err=file.Create(fsSession,fileName,shareMode);
}
 
// do read and write operations
 
file.Close();
fileSession.Close();
+ +

 

+ +

The RFs +class defines the file server session. Any file operation in controlled by an +instance of this class. After this instance is created, the file can be opened +over the RFile class. The RFile class contains all file IO operations. By using +these two classes to extend the sqlite3_file +structure, the SQLite file IO operations can use the class instances of RFs and +RFile as shown in the struct below.

+ +

 

+ +
struct symbianFile {
  int isOpen;
  unsigned char locktype; /* Type of lock currently held on this file */
  short sharedLockByte;   /* Randomly chosen byte used as a shared lock */
  char fileName[512];
  RFs session;
  RFile file;
};
+ +

 

+ +

Finally all +the methods that SQLite needs to handle file operations must be rewritten by +using this structure and the RFile methods. The following example shows how to +close an open file and the file server session.

+ +
int Close(sqlite3_file *id){
  int rc, cnt = 0;
  symbianFile *pFile = (symbianFile*)id;
  pFile->file.Close();
  pFile->session.Close();
  return SQLITE_OK;
}
+ +

 

+ +

The other file +IO operations are similar to the close +method. The open method of RFile expects +a Unicode string that contains the name of the database file. A conversion of +the ASCII format to Unicode must be done before calling the open method. For such a conversion the CCnvCharacterSetConverter class can be +used. This class needs the file server session handle and the string to convert +to Unicode. The following example shows the converter method used in SQLite.

+ +

 

+ +
void ConvertToUnicode(RFs session, TDes16& aUnicode, const char *str)
{
  CCnvCharacterSetConverter *converter = CCnvCharacterSetConverter::NewL();
  converter->PrepareToConvertToOrFromL(KCharacterSetIdentifierUtf8, session);
  
  TPtrC8 ptr((const unsigned char*)str);
 
  int state = CCnvCharacterSetConverter::KStateDefault;
  converter->ConvertToUnicode(aUnicode, ptr, state);
}
+ +

 

+ +

After +rewriting all operations used by SQLite to use the RFile class, in the os_symbian.cpp +file , the project can be compiled by the Symbian C +compiler (which has been included in the build chain by installing the Carbide +plug in for Visual Studio) and a Symbian Library is created that can be used on +a S60 device as a database. This library takes the form of a native Symbian DLL +called sqlite.dll.

+ +

The +database file that the sqlite.dll generates can be used by any other +implementation of SQLite. So it will be possible to transfer all stored data +from a smart device to a database server in a company network.

+ +

Compiling sqlite.dll from the SQLiteS60 project

+ +

It is +possible to compile the sqlite.dll using Visual Studio with the Carbide plugin. +

+ +

Another  easier possibility is to type the +following command lines in the ‘group’ directory of the SqliteS60 folder. 

+ +

To compile +for the S60 device (GCCE compiler) and as a release version:

+ +
> Bldmake bldfiles [enter]
 
> abld build gcce urel
+ +

 

+ +

For the +emulator with debug information: 

+ +
> Bldmake bldfiles [enter]
 
> abld build winscw udeb [enter]
+ +

 

+ +

Note:  No +spaces must be present in the directory path where the SQliteS60 project is +located. Also, the command line console must be run with “Admin” privileges.

+ +


+Writing an ADO.NET Provider using Net60 Compact Framework 1.0

+ +

After the +successful conversion of the SQLite code to the S60 platform, the development +of an ADO.NET provider for Net60 that uses the SQLite library for Symbian OS can +be started. As there are some existing implementations of an ADO.NET provider +for the .NET Framework, this development did not have to start at the grass +roots level. Mono, for example, contains such an implementation ( www.mono-project.com +). This could be used as a base for the ADO.NET provider for Net60.

+ +

The .NET Compact +Framework 1.0 only provides the basic interfaces like IDbConnection, +IDbCommand, IDbParameter and so on. Other +functionality such as the base classes in the System.Data.Common namespace are not provided. Also the DbDataAdapter base class is not implemented. +So this implementation cannot support DataAdapters, however with these basic +interfaces it is possible to develop an ADO.NET Provider that supports all +basic features of the .NET Framework 1.1 for the desktop.

+ +

The +SQLiteS60 project results in a native Symbian DLL, sqlite.dll, which must be +used from within managed .NET code. Net60, and the .NET Compact Framework, +supports interoperability between managed and unmanaged code through a +mechanism called P/Invoke.

+ +

The diagram +below shows the interaction between the various components of the solution:

+ +

 

+ +

+ + + + + + + + + +
+ + 

+ +

 

+ +

 

+ +

 

+ +

 

+ +

 

+ +

 

+ +

 

+ +
+ +

The native SQLite +methods, such as libversion, open etc., are called using the +P/Invoke mechanism in the .NET code. To do this, the entry point of the corresponding +method in the SQLite library must be known. Symbian has a specific entry point +model. All methods are exported from a library by ordinal numbers instead of +method names. The relation of method name and export number can be found in the +generated .DEF file of the SQLite.dll or by using a dump tool.

+ +

The +following example shows how a native SQLite method is defined in .NET. The DLLImort attribute defines the library +name and the entry points were the method is located in the library. The CallingConvention +defines the type of data exchange between the unmanaged SQLite and the managed +.NET code.

+ +
[DllImport("sqlite.dll", EntryPoint = "#86", CallingConvention = _Convention)]
public static extern SQLiteCode sqlite3_open(IntPtr filename, out IntPtr db);
+ +

 

+ +

Based on +the existing implementations of SQLite for .NET it was easy to develop an +ADO.NET Provider that runs on the Compact Framework. To test the behavior of a +.NET application, this implementation provides a P/Invoke call for each sqlite3_ method call to the Symbian +version contained in the sqlite.dll. These P/Invokes +are performed in the SymbianMethods.cs file in the managed System.Data.SQLiteClient.dll +extension class.

+ +

Interestingly, +all applications are also executable on the smartphone device emulator. To +change between the emulator and device, only the emulator flag in the +connection string must be set to true or false. For the emulator the Windows +version of SQLite is required ( www.sqlite.org ), the emulator flag links the +P/Invoke call to that library.

+ +

Deploying SQLiteS60 to the device

+ +

In order to +deploy the SQLite database to device, the sqlite.dll must be deployed to the \sys\bin +directory and the System.Data.SQLiteClient.dll to the Red Five Labs GAC +repository on the device which is \Resource\RedFiveLabs\Gac. The sqlite.pkg is +used together with the Symbian makesis.exe to create an installable SQLite.SIS +file which deploys these two libraries to their respective destinations. If the +sqlite.dll and System.Data.SQLiteClient.dll are placed in the same directory as +the sqlite.pcg file, an example command line to generate the Sqlite.sis is

+ +
C:\temp\sis>makesis sqlite.pkg
+ +

 

+ +

Using SQLite

+ +

The +implementation for Compact Framework 1.0 contains the SQLiteConnection class +that handles the connection to the sqlite database and creates new +SQLiteCommand instances. With these instances database queries can be sent to +and the results received from the database. As a result a SQLiteDataReader set instance +can be returned. This class provides the functionality to step through the rows +of the result sets. Transactional processing can be performed by using the +SQLiteTransaction class. An instance for that class can be created over the +SQLiteConnection instance. Any SQLiteCommand can contain one or more SQL statements. +These statements are handled in the SQLiteStatement class. Each statement is +represented by an instance of that class. This class calls the native SQLite +methods to perform the database operations.

+ +

 

+ +

The +following example shows how to open a database by using the SQLiteConnection +class.

+ +
SQLiteConnection _Connection = new SQLiteConnection("Data Source=test1.db;NewDatabase=True;
                                                  Synchronous=Off;Encoding=UTF8;Emulator=true");
_Connection.Open();
 
SQLiteCommand cmd = _Connection.CreateCommand();
cmd.CommandText = "select id, orderid, article from orderdetails where OrderId = @OrderId";
cmd.Parameters.Add("@OrderId", DbType.Int32).Value = orderId;
 
DataTable table = new DataTable();
 
table.Columns.Add("Id");
table.Columns.Add("OrderId");
table.Columns.Add("Article");
 
SQLiteDataReader reader = cmd.ExecuteReader();
 
while (reader.Read())
{
    DataRow row = table.NewRow();
    row["Id"] = reader.GetInt32(0);
    row["OrderId"] = reader.GetInt32(1);
    row["Article"] = reader.GetString(2);
    table.Rows.Add(row);
}
 
dataGridView.DataSource = table;
+ +

 

+ +

The +SQLiteCommand instance contains a select statement that loads the orders with +the specified OrderId. The result set of this query is then filled in a data +table that is databinded to an dataGridView that +displays the result. An example application is provided in the form of +SqlMobileTest project.

+ +

 

+ +

Conclusion

+ +

With this +conversion of SQLite, it is now possible to create .NET applications with database +support for the great family of Symbian S60 smartphones. With the upcoming release +of version 9.4 the Symbian OS provides an implementation of SQLite but this +version is not released yet and only new devices will get this database +support. With this conversion all S60 3rd Edition devices will be able +to use SQLite. Together with the Red Five Labs Net60 implementation of the .NET +Compact Framework it is possible to run .NET applications on Symbian OS. Together +with the ADO.NET provider for this SQLite implementation these applications can +use database functionality like any other application on a personal computer.

+ +

 

+ +

Tools Used for this project

+ +

Microsoft +Visual Studio 2005 together with the Carbide.vs Plugin (http://www.forum.nokia.com/main/resources/tools_and_sdks/carbide/index.html ) were used in this project.

+ +

 Additionally the S60 SDK and the Symbian PIPS +SDK are required to compile the project. With the Carbide plug in it is +possible to develop native Symbian applications in the Visual Studio IDE and to +debug on the S60 emulator. To convert a S60 project (f.e. a BLD or MMP file) to +a Visual Studio project, the Import Wizard of the carbide plugin could be used. +It is located under the File menu. The user only has to select the s60 project +and to assign an S60 SDK (f.e. maintenance release or FP1/FP2). The rest of the +transformation does the wizard. So it is easy to convert existing projects to +use the carbide plugin.

+ +

 

+ +

 

+ +
+ + + + diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/alter.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/alter.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,629 @@ +/* +** 2005 February 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains C code routines that used to generate VDBE code +** that implements the ALTER TABLE command. +** +** $Id: alter.cpp 1282 2008-11-13 09:31:33Z LarsPson $ +*/ +#include "sqliteInt.h" +#include + +/* +** The code in this file only exists if we are not omitting the +** ALTER TABLE logic from the build. +*/ +#ifndef SQLITE_OMIT_ALTERTABLE + + +/* +** This function is used by SQL generated to implement the +** ALTER TABLE command. The first argument is the text of a CREATE TABLE or +** CREATE INDEX command. The second is a table name. The table name in +** the CREATE TABLE or CREATE INDEX statement is replaced with the third +** argument and the result returned. Examples: +** +** sqlite_rename_table('CREATE TABLE abc(a, b, c)', 'def') +** -> 'CREATE TABLE def(a, b, c)' +** +** sqlite_rename_table('CREATE INDEX i ON abc(a)', 'def') +** -> 'CREATE INDEX i ON def(a, b, c)' +*/ +static void renameTableFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + unsigned char const *zSql = sqlite3_value_text(argv[0]); + unsigned char const *zTableName = sqlite3_value_text(argv[1]); + + int token; + Token tname; + unsigned char const *zCsr = zSql; + int len = 0; + char *zRet; + + sqlite3 *db = (sqlite3 *)sqlite3_user_data(context); + + /* The principle used to locate the table name in the CREATE TABLE + ** statement is that the table name is the first token that is immediatedly + ** followed by a left parenthesis - TK_LP - or "USING" TK_USING. + */ + if( zSql ){ + do { + if( !*zCsr ){ + /* Ran out of input before finding an opening bracket. Return NULL. */ + return; + } + + /* Store the token that zCsr points to in tname. */ + tname.z = zCsr; + tname.n = len; + + /* Advance zCsr to the next token. Store that token type in 'token', + ** and its length in 'len' (to be used next iteration of this loop). + */ + do { + zCsr += len; + len = sqlite3GetToken(zCsr, &token); + } while( token==TK_SPACE ); + assert( len>0 ); + } while( token!=TK_LP && token!=TK_USING ); + + zRet = sqlite3MPrintf(db, "%.*s%Q%s", tname.z - zSql, zSql, + zTableName, tname.z+tname.n); + sqlite3_result_text(context, zRet, -1, sqlite3_free); + } +} + +#ifndef SQLITE_OMIT_TRIGGER +/* This function is used by SQL generated to implement the +** ALTER TABLE command. The first argument is the text of a CREATE TRIGGER +** statement. The second is a table name. The table name in the CREATE +** TRIGGER statement is replaced with the third argument and the result +** returned. This is analagous to renameTableFunc() above, except for CREATE +** TRIGGER, not CREATE INDEX and CREATE TABLE. +*/ +static void renameTriggerFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + unsigned char const *zSql = sqlite3_value_text(argv[0]); + unsigned char const *zTableName = sqlite3_value_text(argv[1]); + + int token; + Token tname; + int dist = 3; + unsigned char const *zCsr = zSql; + int len = 0; + char *zRet; + + sqlite3 *db = (sqlite3 *)sqlite3_user_data(context); + + /* The principle used to locate the table name in the CREATE TRIGGER + ** statement is that the table name is the first token that is immediatedly + ** preceded by either TK_ON or TK_DOT and immediatedly followed by one + ** of TK_WHEN, TK_BEGIN or TK_FOR. + */ + if( zSql ){ + do { + + if( !*zCsr ){ + /* Ran out of input before finding the table name. Return NULL. */ + return; + } + + /* Store the token that zCsr points to in tname. */ + tname.z = zCsr; + tname.n = len; + + /* Advance zCsr to the next token. Store that token type in 'token', + ** and its length in 'len' (to be used next iteration of this loop). + */ + do { + zCsr += len; + len = sqlite3GetToken(zCsr, &token); + }while( token==TK_SPACE ); + assert( len>0 ); + + /* Variable 'dist' stores the number of tokens read since the most + ** recent TK_DOT or TK_ON. This means that when a WHEN, FOR or BEGIN + ** token is read and 'dist' equals 2, the condition stated above + ** to be met. + ** + ** Note that ON cannot be a database, table or column name, so + ** there is no need to worry about syntax like + ** "CREATE TRIGGER ... ON ON.ON BEGIN ..." etc. + */ + dist++; + if( token==TK_DOT || token==TK_ON ){ + dist = 0; + } + } while( dist!=2 || (token!=TK_WHEN && token!=TK_FOR && token!=TK_BEGIN) ); + + /* Variable tname now contains the token that is the old table-name + ** in the CREATE TRIGGER statement. + */ + zRet = sqlite3MPrintf(db, "%.*s%Q%s", tname.z - zSql, zSql, + zTableName, tname.z+tname.n); + sqlite3_result_text(context, zRet, -1, sqlite3_free); + } +} +#endif /* !SQLITE_OMIT_TRIGGER */ + +/* +** Register built-in functions used to help implement ALTER TABLE +*/ +void sqlite3AlterFunctions(sqlite3 *db){ + static const struct { + char *zName; + signed char nArg; + void (*xFunc)(sqlite3_context*,int,sqlite3_value **); + } aFuncs[] = { + { "sqlite_rename_table", 2, renameTableFunc}, +#ifndef SQLITE_OMIT_TRIGGER + { "sqlite_rename_trigger", 2, renameTriggerFunc}, +#endif + }; + int i; + + for(i=0; idb->aDb[1].pSchema; /* Temp db schema */ + + /* If the table is not located in the temp-db (in which case NULL is + ** returned, loop through the tables list of triggers. For each trigger + ** that is not part of the temp-db schema, add a clause to the WHERE + ** expression being built up in zWhere. + */ + if( pTab->pSchema!=pTempSchema ){ + sqlite3 *db = pParse->db; + for( pTrig=pTab->pTrigger; pTrig; pTrig=pTrig->pNext ){ + if( pTrig->pSchema==pTempSchema ){ + if( !zWhere ){ + zWhere = sqlite3MPrintf(db, "name=%Q", pTrig->name); + }else{ + tmp = zWhere; + zWhere = sqlite3MPrintf(db, "%s OR name=%Q", zWhere, pTrig->name); + sqlite3_free(tmp); + } + } + } + } + return zWhere; +} + +/* +** Generate code to drop and reload the internal representation of table +** pTab from the database, including triggers and temporary triggers. +** Argument zName is the name of the table in the database schema at +** the time the generated code is executed. This can be different from +** pTab->zName if this function is being called to code part of an +** "ALTER TABLE RENAME TO" statement. +*/ +static void reloadTableSchema(Parse *pParse, Table *pTab, const char *zName){ + Vdbe *v; + char *zWhere; + int iDb; /* Index of database containing pTab */ +#ifndef SQLITE_OMIT_TRIGGER + Trigger *pTrig; +#endif + + v = sqlite3GetVdbe(pParse); + if( !v ) return; + assert( sqlite3BtreeHoldsAllMutexes(pParse->db) ); + iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + assert( iDb>=0 ); + +#ifndef SQLITE_OMIT_TRIGGER + /* Drop any table triggers from the internal schema. */ + for(pTrig=pTab->pTrigger; pTrig; pTrig=pTrig->pNext){ + int iTrigDb = sqlite3SchemaToIndex(pParse->db, pTrig->pSchema); + assert( iTrigDb==iDb || iTrigDb==1 ); + sqlite3VdbeOp3(v, OP_DropTrigger, iTrigDb, 0, pTrig->name, 0); + } +#endif + + /* Drop the table and index from the internal schema */ + sqlite3VdbeOp3(v, OP_DropTable, iDb, 0, pTab->zName, 0); + + /* Reload the table, index and permanent trigger schemas. */ + zWhere = sqlite3MPrintf(pParse->db, "tbl_name=%Q", zName); + if( !zWhere ) return; + sqlite3VdbeOp3(v, OP_ParseSchema, iDb, 0, zWhere, P3_DYNAMIC); + +#ifndef SQLITE_OMIT_TRIGGER + /* Now, if the table is not stored in the temp database, reload any temp + ** triggers. Don't use IN(...) in case SQLITE_OMIT_SUBQUERY is defined. + */ + if( (zWhere=whereTempTriggers(pParse, pTab))!=0 ){ + sqlite3VdbeOp3(v, OP_ParseSchema, 1, 0, zWhere, P3_DYNAMIC); + } +#endif +} + +/* +** Generate code to implement the "ALTER TABLE xxx RENAME TO yyy" +** command. +*/ +void sqlite3AlterRenameTable( + Parse *pParse, /* Parser context. */ + SrcList *pSrc, /* The table to rename. */ + Token *pName /* The new table name. */ +){ + int iDb; /* Database that contains the table */ + char *zDb; /* Name of database iDb */ + Table *pTab; /* Table being renamed */ + char *zName = 0; /* NULL-terminated version of pName */ + sqlite3 *db = pParse->db; /* Database connection */ + int nTabName; /* Number of UTF-8 characters in zTabName */ + const char *zTabName; /* Original name of the table */ + Vdbe *v; +#ifndef SQLITE_OMIT_TRIGGER + char *zWhere = 0; /* Where clause to locate temp triggers */ +#endif + int isVirtualRename = 0; /* True if this is a v-table with an xRename() */ + + if( db->mallocFailed ) goto exit_rename_table; + assert( pSrc->nSrc==1 ); + assert( sqlite3BtreeHoldsAllMutexes(pParse->db) ); + + pTab = sqlite3LocateTable(pParse, pSrc->a[0].zName, pSrc->a[0].zDatabase); + if( !pTab ) goto exit_rename_table; + iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + zDb = db->aDb[iDb].zName; + + /* Get a NULL terminated version of the new table name. */ + zName = sqlite3NameFromToken(db, pName); + if( !zName ) goto exit_rename_table; + + /* Check that a table or index named 'zName' does not already exist + ** in database iDb. If so, this is an error. + */ + if( sqlite3FindTable(db, zName, zDb) || sqlite3FindIndex(db, zName, zDb) ){ + sqlite3ErrorMsg(pParse, + "there is already another table or index with this name: %s", zName); + goto exit_rename_table; + } + + /* Make sure it is not a system table being altered, or a reserved name + ** that the table is being renamed to. + */ + if( strlen(pTab->zName)>6 && 0==sqlite3StrNICmp(pTab->zName, "sqlite_", 7) ){ + sqlite3ErrorMsg(pParse, "table %s may not be altered", pTab->zName); + goto exit_rename_table; + } + if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){ + goto exit_rename_table; + } + +#ifndef SQLITE_OMIT_VIEW + if( pTab->pSelect ){ + sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName); + goto exit_rename_table; + } +#endif + +#ifndef SQLITE_OMIT_AUTHORIZATION + /* Invoke the authorization callback. */ + if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){ + goto exit_rename_table; + } +#endif + +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( sqlite3ViewGetColumnNames(pParse, pTab) ){ + goto exit_rename_table; + } + if( IsVirtual(pTab) && pTab->pMod->pModule->xRename ){ + isVirtualRename = 1; + } +#endif + + /* Begin a transaction and code the VerifyCookie for database iDb. + ** Then modify the schema cookie (since the ALTER TABLE modifies the + ** schema). Open a statement transaction if the table is a virtual + ** table. + */ + v = sqlite3GetVdbe(pParse); + if( v==0 ){ + goto exit_rename_table; + } + sqlite3BeginWriteOperation(pParse, isVirtualRename, iDb); + sqlite3ChangeCookie(db, v, iDb); + + /* If this is a virtual table, invoke the xRename() function if + ** one is defined. The xRename() callback will modify the names + ** of any resources used by the v-table implementation (including other + ** SQLite tables) that are identified by the name of the virtual table. + */ +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( isVirtualRename ){ + sqlite3VdbeOp3(v, OP_String8, 0, 0, zName, 0); + sqlite3VdbeOp3(v, OP_VRename, 0, 0, (const char*)pTab->pVtab, P3_VTAB); + } +#endif + + /* figure out how many UTF-8 characters are in zName */ + zTabName = pTab->zName; + nTabName = sqlite3Utf8CharLen(zTabName, -1); + + /* Modify the sqlite_master table to use the new table name. */ + sqlite3NestedParse(pParse, + "UPDATE %Q.%s SET " +#ifdef SQLITE_OMIT_TRIGGER + "sql = sqlite_rename_table(sql, %Q), " +#else + "sql = CASE " + "WHEN type = 'trigger' THEN sqlite_rename_trigger(sql, %Q)" + "ELSE sqlite_rename_table(sql, %Q) END, " +#endif + "tbl_name = %Q, " + "name = CASE " + "WHEN type='table' THEN %Q " + "WHEN name LIKE 'sqlite_autoindex%%' AND type='index' THEN " + "'sqlite_autoindex_' || %Q || substr(name,%d+18) " + "ELSE name END " + "WHERE tbl_name=%Q AND " + "(type='table' OR type='index' OR type='trigger');", + zDb, SCHEMA_TABLE(iDb), zName, zName, zName, +#ifndef SQLITE_OMIT_TRIGGER + zName, +#endif + zName, nTabName, zTabName + ); + +#ifndef SQLITE_OMIT_AUTOINCREMENT + /* If the sqlite_sequence table exists in this database, then update + ** it with the new table name. + */ + if( sqlite3FindTable(db, "sqlite_sequence", zDb) ){ + sqlite3NestedParse(pParse, + "UPDATE %Q.sqlite_sequence set name = %Q WHERE name = %Q", + zDb, zName, pTab->zName); + } +#endif + +#ifndef SQLITE_OMIT_TRIGGER + /* If there are TEMP triggers on this table, modify the sqlite_temp_master + ** table. Don't do this if the table being ALTERed is itself located in + ** the temp database. + */ + if( (zWhere=whereTempTriggers(pParse, pTab))!=0 ){ + sqlite3NestedParse(pParse, + "UPDATE sqlite_temp_master SET " + "sql = sqlite_rename_trigger(sql, %Q), " + "tbl_name = %Q " + "WHERE %s;", zName, zName, zWhere); + sqlite3_free(zWhere); + } +#endif + + /* Drop and reload the internal table schema. */ + reloadTableSchema(pParse, pTab, zName); + +exit_rename_table: + sqlite3SrcListDelete(pSrc); + sqlite3_free(zName); +} + + +/* +** This function is called after an "ALTER TABLE ... ADD" statement +** has been parsed. Argument pColDef contains the text of the new +** column definition. +** +** The Table structure pParse->pNewTable was extended to include +** the new column during parsing. +*/ +void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){ + Table *pNew; /* Copy of pParse->pNewTable */ + Table *pTab; /* Table being altered */ + int iDb; /* Database number */ + const char *zDb; /* Database name */ + const char *zTab; /* Table name */ + char *zCol; /* Null-terminated column definition */ + Column *pCol; /* The new column */ + Expr *pDflt; /* Default value for the new column */ + sqlite3 *db; /* The database connection; */ + + if( pParse->nErr ) return; + pNew = pParse->pNewTable; + assert( pNew ); + + db = pParse->db; + assert( sqlite3BtreeHoldsAllMutexes(db) ); + iDb = sqlite3SchemaToIndex(db, pNew->pSchema); + zDb = db->aDb[iDb].zName; + zTab = pNew->zName; + pCol = &pNew->aCol[pNew->nCol-1]; + pDflt = pCol->pDflt; + pTab = sqlite3FindTable(db, zTab, zDb); + assert( pTab ); + +#ifndef SQLITE_OMIT_AUTHORIZATION + /* Invoke the authorization callback. */ + if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){ + return; + } +#endif + + /* If the default value for the new column was specified with a + ** literal NULL, then set pDflt to 0. This simplifies checking + ** for an SQL NULL default below. + */ + if( pDflt && pDflt->op==TK_NULL ){ + pDflt = 0; + } + + /* Check that the new column is not specified as PRIMARY KEY or UNIQUE. + ** If there is a NOT NULL constraint, then the default value for the + ** column must not be NULL. + */ + if( pCol->isPrimKey ){ + sqlite3ErrorMsg(pParse, "Cannot add a PRIMARY KEY column"); + return; + } + if( pNew->pIndex ){ + sqlite3ErrorMsg(pParse, "Cannot add a UNIQUE column"); + return; + } + if( pCol->notNull && !pDflt ){ + sqlite3ErrorMsg(pParse, + "Cannot add a NOT NULL column with default value NULL"); + return; + } + + /* Ensure the default expression is something that sqlite3ValueFromExpr() + ** can handle (i.e. not CURRENT_TIME etc.) + */ + if( pDflt ){ + sqlite3_value *pVal; + if( sqlite3ValueFromExpr(db, pDflt, SQLITE_UTF8, SQLITE_AFF_NONE, &pVal) ){ + db->mallocFailed = 1; + return; + } + if( !pVal ){ + sqlite3ErrorMsg(pParse, "Cannot add a column with non-constant default"); + return; + } + sqlite3ValueFree(pVal); + } + + /* Modify the CREATE TABLE statement. */ + zCol = sqlite3DbStrNDup(db, (char*)pColDef->z, pColDef->n); + if( zCol ){ + char *zEnd = &zCol[pColDef->n-1]; + while( (zEnd>zCol && *zEnd==';') || isspace(*(unsigned char *)zEnd) ){ + *zEnd-- = '\0'; + } + sqlite3NestedParse(pParse, + "UPDATE %Q.%s SET " + "sql = substr(sql,1,%d) || ', ' || %Q || substr(sql,%d) " + "WHERE type = 'table' AND name = %Q", + zDb, SCHEMA_TABLE(iDb), pNew->addColOffset, zCol, pNew->addColOffset+1, + zTab + ); + sqlite3_free(zCol); + } + + /* If the default value of the new column is NULL, then set the file + ** format to 2. If the default value of the new column is not NULL, + ** the file format becomes 3. + */ + sqlite3MinimumFileFormat(pParse, iDb, pDflt ? 3 : 2); + + /* Reload the schema of the modified table. */ + reloadTableSchema(pParse, pTab, pTab->zName); +} + +/* +** This function is called by the parser after the table-name in +** an "ALTER TABLE ADD" statement is parsed. Argument +** pSrc is the full-name of the table being altered. +** +** This routine makes a (partial) copy of the Table structure +** for the table being altered and sets Parse.pNewTable to point +** to it. Routines called by the parser as the column definition +** is parsed (i.e. sqlite3AddColumn()) add the new Column data to +** the copy. The copy of the Table structure is deleted by tokenize.c +** after parsing is finished. +** +** Routine sqlite3AlterFinishAddColumn() will be called to complete +** coding the "ALTER TABLE ... ADD" statement. +*/ +void sqlite3AlterBeginAddColumn(Parse *pParse, SrcList *pSrc){ + Table *pNew; + Table *pTab; + Vdbe *v; + int iDb; + int i; + int nAlloc; + sqlite3 *db = pParse->db; + + /* Look up the table being altered. */ + assert( pParse->pNewTable==0 ); + assert( sqlite3BtreeHoldsAllMutexes(db) ); + if( db->mallocFailed ) goto exit_begin_add_column; + pTab = sqlite3LocateTable(pParse, pSrc->a[0].zName, pSrc->a[0].zDatabase); + if( !pTab ) goto exit_begin_add_column; + +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( IsVirtual(pTab) ){ + sqlite3ErrorMsg(pParse, "virtual tables may not be altered"); + goto exit_begin_add_column; + } +#endif + + /* Make sure this is not an attempt to ALTER a view. */ + if( pTab->pSelect ){ + sqlite3ErrorMsg(pParse, "Cannot add a column to a view"); + goto exit_begin_add_column; + } + + assert( pTab->addColOffset>0 ); + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + + /* Put a copy of the Table struct in Parse.pNewTable for the + ** sqlite3AddColumn() function and friends to modify. + */ + pNew = (Table*)sqlite3DbMallocZero(db, sizeof(Table)); + if( !pNew ) goto exit_begin_add_column; + pParse->pNewTable = pNew; + pNew->nRef = 1; + pNew->nCol = pTab->nCol; + assert( pNew->nCol>0 ); + nAlloc = (((pNew->nCol-1)/8)*8)+8; + assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 ); + pNew->aCol = (Column*)sqlite3DbMallocZero(db, sizeof(Column)*nAlloc); + pNew->zName = sqlite3DbStrDup(db, pTab->zName); + if( !pNew->aCol || !pNew->zName ){ + db->mallocFailed = 1; + goto exit_begin_add_column; + } + memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol); + for(i=0; inCol; i++){ + Column *pCol = &pNew->aCol[i]; + pCol->zName = sqlite3DbStrDup(db, pCol->zName); + pCol->zColl = 0; + pCol->zType = 0; + pCol->pDflt = 0; + } + pNew->pSchema = db->aDb[iDb].pSchema; + pNew->addColOffset = pTab->addColOffset; + pNew->nRef = 1; + + /* Begin a transaction and increment the schema cookie. */ + sqlite3BeginWriteOperation(pParse, 0, iDb); + v = sqlite3GetVdbe(pParse); + if( !v ) goto exit_begin_add_column; + sqlite3ChangeCookie(db, v, iDb); + +exit_begin_add_column: + sqlite3SrcListDelete(pSrc); + return; +} +#endif /* SQLITE_ALTER_TABLE */ diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/analyze.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/analyze.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,420 @@ +/* +** 2005 July 8 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code associated with the ANALYZE command. +** +** @(#) $Id: analyze.cpp 1282 2008-11-13 09:31:33Z LarsPson $ +*/ +#ifndef SQLITE_OMIT_ANALYZE +#include "sqliteInt.h" + +/* +** This routine generates code that opens the sqlite_stat1 table on cursor +** iStatCur. +** +** If the sqlite_stat1 tables does not previously exist, it is created. +** If it does previously exist, all entires associated with table zWhere +** are removed. If zWhere==0 then all entries are removed. +*/ +static void openStatTable( + Parse *pParse, /* Parsing context */ + int iDb, /* The database we are looking in */ + int iStatCur, /* Open the sqlite_stat1 table on this cursor */ + const char *zWhere /* Delete entries associated with this table */ +){ + sqlite3 *db = pParse->db; + Db *pDb; + int iRootPage; + Table *pStat; + Vdbe *v = sqlite3GetVdbe(pParse); + + if( v==0 ) return; + assert( sqlite3BtreeHoldsAllMutexes(db) ); + assert( sqlite3VdbeDb(v)==db ); + pDb = &db->aDb[iDb]; + if( (pStat = sqlite3FindTable(db, "sqlite_stat1", pDb->zName))==0 ){ + /* The sqlite_stat1 tables does not exist. Create it. + ** Note that a side-effect of the CREATE TABLE statement is to leave + ** the rootpage of the new table on the top of the stack. This is + ** important because the OpenWrite opcode below will be needing it. */ + sqlite3NestedParse(pParse, + "CREATE TABLE %Q.sqlite_stat1(tbl,idx,stat)", + pDb->zName + ); + iRootPage = 0; /* Cause rootpage to be taken from top of stack */ + }else if( zWhere ){ + /* The sqlite_stat1 table exists. Delete all entries associated with + ** the table zWhere. */ + sqlite3NestedParse(pParse, + "DELETE FROM %Q.sqlite_stat1 WHERE tbl=%Q", + pDb->zName, zWhere + ); + iRootPage = pStat->tnum; + }else{ + /* The sqlite_stat1 table already exists. Delete all rows. */ + iRootPage = pStat->tnum; + sqlite3VdbeAddOp(v, OP_Clear, pStat->tnum, iDb); + } + + /* Open the sqlite_stat1 table for writing. Unless it was created + ** by this vdbe program, lock it for writing at the shared-cache level. + ** If this vdbe did create the sqlite_stat1 table, then it must have + ** already obtained a schema-lock, making the write-lock redundant. + */ + if( iRootPage>0 ){ + sqlite3TableLock(pParse, iDb, iRootPage, 1, "sqlite_stat1"); + } + sqlite3VdbeAddOp(v, OP_Integer, iDb, 0); + sqlite3VdbeAddOp(v, OP_OpenWrite, iStatCur, iRootPage); + sqlite3VdbeAddOp(v, OP_SetNumColumns, iStatCur, 3); +} + +/* +** Generate code to do an analysis of all indices associated with +** a single table. +*/ +static void analyzeOneTable( + Parse *pParse, /* Parser context */ + Table *pTab, /* Table whose indices are to be analyzed */ + int iStatCur, /* Cursor that writes to the sqlite_stat1 table */ + int iMem /* Available memory locations begin here */ +){ + Index *pIdx; /* An index to being analyzed */ + int iIdxCur; /* Cursor number for index being analyzed */ + int nCol; /* Number of columns in the index */ + Vdbe *v; /* The virtual machine being built up */ + int i; /* Loop counter */ + int topOfLoop; /* The top of the loop */ + int endOfLoop; /* The end of the loop */ + int addr; /* The address of an instruction */ + int iDb; /* Index of database containing pTab */ + + v = sqlite3GetVdbe(pParse); + if( v==0 || pTab==0 || pTab->pIndex==0 ){ + /* Do no analysis for tables that have no indices */ + return; + } + assert( sqlite3BtreeHoldsAllMutexes(pParse->db) ); + iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + assert( iDb>=0 ); +#ifndef SQLITE_OMIT_AUTHORIZATION + if( sqlite3AuthCheck(pParse, SQLITE_ANALYZE, pTab->zName, 0, + pParse->db->aDb[iDb].zName ) ){ + return; + } +#endif + + /* Establish a read-lock on the table at the shared-cache level. */ + sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName); + + iIdxCur = pParse->nTab; + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx); + + /* Open a cursor to the index to be analyzed + */ + assert( iDb==sqlite3SchemaToIndex(pParse->db, pIdx->pSchema) ); + sqlite3VdbeAddOp(v, OP_Integer, iDb, 0); + VdbeComment((v, "# %s", pIdx->zName)); + sqlite3VdbeOp3(v, OP_OpenRead, iIdxCur, pIdx->tnum, + (char *)pKey, P3_KEYINFO_HANDOFF); + nCol = pIdx->nColumn; + if( iMem+nCol*2>=pParse->nMem ){ + pParse->nMem = iMem+nCol*2+1; + } + sqlite3VdbeAddOp(v, OP_SetNumColumns, iIdxCur, nCol+1); + + /* Memory cells are used as follows: + ** + ** mem[iMem]: The total number of rows in the table. + ** mem[iMem+1]: Number of distinct values in column 1 + ** ... + ** mem[iMem+nCol]: Number of distinct values in column N + ** mem[iMem+nCol+1] Last observed value of column 1 + ** ... + ** mem[iMem+nCol+nCol]: Last observed value of column N + ** + ** Cells iMem through iMem+nCol are initialized to 0. The others + ** are initialized to NULL. + */ + for(i=0; i<=nCol; i++){ + sqlite3VdbeAddOp(v, OP_MemInt, 0, iMem+i); + } + for(i=0; i0 then it is always the case the D>0 so division by zero + ** is never possible. + */ + sqlite3VdbeAddOp(v, OP_MemLoad, iMem, 0); + addr = sqlite3VdbeAddOp(v, OP_IfNot, 0, 0); + sqlite3VdbeAddOp(v, OP_NewRowid, iStatCur, 0); + sqlite3VdbeOp3(v, OP_String8, 0, 0, pTab->zName, 0); + sqlite3VdbeOp3(v, OP_String8, 0, 0, pIdx->zName, 0); + sqlite3VdbeAddOp(v, OP_MemLoad, iMem, 0); + sqlite3VdbeOp3(v, OP_String8, 0, 0, " ", 0); + for(i=0; idb; + Schema *pSchema = db->aDb[iDb].pSchema; /* Schema of database iDb */ + HashElem *k; + int iStatCur; + int iMem; + + sqlite3BeginWriteOperation(pParse, 0, iDb); + iStatCur = pParse->nTab++; + openStatTable(pParse, iDb, iStatCur, 0); + iMem = pParse->nMem; + for(k=sqliteHashFirst(&pSchema->tblHash); k; k=sqliteHashNext(k)){ + Table *pTab = (Table*)sqliteHashData(k); + analyzeOneTable(pParse, pTab, iStatCur, iMem); + } + loadAnalysis(pParse, iDb); +} + +/* +** Generate code that will do an analysis of a single table in +** a database. +*/ +static void analyzeTable(Parse *pParse, Table *pTab){ + int iDb; + int iStatCur; + + assert( pTab!=0 ); + assert( sqlite3BtreeHoldsAllMutexes(pParse->db) ); + iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + sqlite3BeginWriteOperation(pParse, 0, iDb); + iStatCur = pParse->nTab++; + openStatTable(pParse, iDb, iStatCur, pTab->zName); + analyzeOneTable(pParse, pTab, iStatCur, pParse->nMem); + loadAnalysis(pParse, iDb); +} + +/* +** Generate code for the ANALYZE command. The parser calls this routine +** when it recognizes an ANALYZE command. +** +** ANALYZE -- 1 +** ANALYZE -- 2 +** ANALYZE ?.? -- 3 +** +** Form 1 causes all indices in all attached databases to be analyzed. +** Form 2 analyzes all indices the single database named. +** Form 3 analyzes all indices associated with the named table. +*/ +void sqlite3Analyze(Parse *pParse, Token *pName1, Token *pName2){ + sqlite3 *db = pParse->db; + int iDb; + int i; + char *z, *zDb; + Table *pTab; + Token *pTableName; + + /* Read the database schema. If an error occurs, leave an error message + ** and code in pParse and return NULL. */ + assert( sqlite3BtreeHoldsAllMutexes(pParse->db) ); + if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){ + return; + } + + if( pName1==0 ){ + /* Form 1: Analyze everything */ + for(i=0; inDb; i++){ + if( i==1 ) continue; /* Do not analyze the TEMP database */ + analyzeDatabase(pParse, i); + } + }else if( pName2==0 || pName2->n==0 ){ + /* Form 2: Analyze the database or table named */ + iDb = sqlite3FindDb(db, pName1); + if( iDb>=0 ){ + analyzeDatabase(pParse, iDb); + }else{ + z = sqlite3NameFromToken(db, pName1); + if( z ){ + pTab = sqlite3LocateTable(pParse, z, 0); + sqlite3_free(z); + if( pTab ){ + analyzeTable(pParse, pTab); + } + } + } + }else{ + /* Form 3: Analyze the fully qualified table name */ + iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pTableName); + if( iDb>=0 ){ + zDb = db->aDb[iDb].zName; + z = sqlite3NameFromToken(db, pTableName); + if( z ){ + pTab = sqlite3LocateTable(pParse, z, zDb); + sqlite3_free(z); + if( pTab ){ + analyzeTable(pParse, pTab); + } + } + } + } +} + +/* +** Used to pass information from the analyzer reader through to the +** callback routine. +*/ +typedef struct analysisInfo analysisInfo; +struct analysisInfo { + sqlite3 *db; + const char *zDatabase; +}; + +/* +** This callback is invoked once for each index when reading the +** sqlite_stat1 table. +** +** argv[0] = name of the index +** argv[1] = results of analysis - on integer for each column +*/ +static int analysisLoader(void *pData, int argc, char **argv, char **azNotUsed){ + analysisInfo *pInfo = (analysisInfo*)pData; + Index *pIndex; + int i, c; + unsigned int v; + const char *z; + + assert( argc==2 ); + if( argv==0 || argv[0]==0 || argv[1]==0 ){ + return 0; + } + pIndex = sqlite3FindIndex(pInfo->db, argv[0], pInfo->zDatabase); + if( pIndex==0 ){ + return 0; + } + z = argv[1]; + for(i=0; *z && i<=pIndex->nColumn; i++){ + v = 0; + while( (c=z[0])>='0' && c<='9' ){ + v = v*10 + c - '0'; + z++; + } + pIndex->aiRowEst[i] = v; + if( *z==' ' ) z++; + } + return 0; +} + +/* +** Load the content of the sqlite_stat1 table into the index hash tables. +*/ +int sqlite3AnalysisLoad(sqlite3 *db, int iDb){ + analysisInfo sInfo; + HashElem *i; + char *zSql; + int rc; + + assert( iDb>=0 && iDbnDb ); + assert( db->aDb[iDb].pBt!=0 ); + assert( sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) ); + + /* Clear any prior statistics */ + for(i=sqliteHashFirst(&db->aDb[iDb].pSchema->idxHash);i;i=sqliteHashNext(i)){ + Index *pIdx = (Index *)sqliteHashData(i); + sqlite3DefaultRowEst(pIdx); + } + + /* Check to make sure the sqlite_stat1 table existss */ + sInfo.db = db; + sInfo.zDatabase = db->aDb[iDb].zName; + if( sqlite3FindTable(db, "sqlite_stat1", sInfo.zDatabase)==0 ){ + return SQLITE_ERROR; + } + + + /* Load new statistics out of the sqlite_stat1 table */ + zSql = sqlite3MPrintf(db, "SELECT idx, stat FROM %Q.sqlite_stat1", + sInfo.zDatabase); + sqlite3SafetyOff(db); + rc = sqlite3_exec(db, zSql, analysisLoader, &sInfo, 0); + sqlite3SafetyOn(db); + sqlite3_free(zSql); + return rc; +} + + +#endif /* SQLITE_OMIT_ANALYZE */ diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/attach.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/attach.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,521 @@ +/* +** 2003 April 6 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code used to implement the ATTACH and DETACH commands. +** +** $Id: attach.cpp 1282 2008-11-13 09:31:33Z LarsPson $ +*/ +#include "sqliteInt.h" + +#ifndef SQLITE_OMIT_ATTACH +/* +** Resolve an expression that was part of an ATTACH or DETACH statement. This +** is slightly different from resolving a normal SQL expression, because simple +** identifiers are treated as strings, not possible column names or aliases. +** +** i.e. if the parser sees: +** +** ATTACH DATABASE abc AS def +** +** it treats the two expressions as literal strings 'abc' and 'def' instead of +** looking for columns of the same name. +** +** This only applies to the root node of pExpr, so the statement: +** +** ATTACH DATABASE abc||def AS 'db2' +** +** will fail because neither abc or def can be resolved. +*/ +static int resolveAttachExpr(NameContext *pName, Expr *pExpr) +{ + int rc = SQLITE_OK; + if( pExpr ){ + if( pExpr->op!=TK_ID ){ + rc = sqlite3ExprResolveNames(pName, pExpr); + if( rc==SQLITE_OK && !sqlite3ExprIsConstant(pExpr) ){ + sqlite3ErrorMsg(pName->pParse, "invalid name: \"%T\"", &pExpr->span); + return SQLITE_ERROR; + } + }else{ + pExpr->op = TK_STRING; + } + } + return rc; +} + +/* +** An SQL user-function registered to do the work of an ATTACH statement. The +** three arguments to the function come directly from an attach statement: +** +** ATTACH DATABASE x AS y KEY z +** +** SELECT sqlite_attach(x, y, z) +** +** If the optional "KEY z" syntax is omitted, an SQL NULL is passed as the +** third argument. +*/ +static void attachFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + int i; + int rc = 0; + sqlite3 *db = (sqlite3 *)sqlite3_user_data(context); + const char *zName; + const char *zFile; + Db *aNew; + char *zErrDyn = 0; + char zErr[128]; + + zFile = (const char *)sqlite3_value_text(argv[0]); + zName = (const char *)sqlite3_value_text(argv[1]); + if( zFile==0 ) zFile = ""; + if( zName==0 ) zName = ""; + + /* Check for the following errors: + ** + ** * Too many attached databases, + ** * Transaction currently open + ** * Specified database name already being used. + */ + if( db->nDb>=SQLITE_MAX_ATTACHED+2 ){ + sqlite3_snprintf( + sizeof(zErr), zErr, "too many attached databases - max %d", + SQLITE_MAX_ATTACHED + ); + goto attach_error; + } + if( !db->autoCommit ){ + sqlite3_snprintf(sizeof(zErr), zErr, + "cannot ATTACH database within transaction"); + goto attach_error; + } + for(i=0; inDb; i++){ + char *z = db->aDb[i].zName; + if( z && zName && sqlite3StrICmp(z, zName)==0 ){ + sqlite3_snprintf(sizeof(zErr), zErr, + "database %s is already in use", zName); + goto attach_error; + } + } + + /* Allocate the new entry in the db->aDb[] array and initialise the schema + ** hash tables. + */ + if( db->aDb==db->aDbStatic ){ + aNew = (Db*)sqlite3_malloc( sizeof(db->aDb[0])*3 ); + if( aNew==0 ){ + db->mallocFailed = 1; + return; + } + memcpy(aNew, db->aDb, sizeof(db->aDb[0])*2); + }else{ + aNew = (Db*)sqlite3_realloc(db->aDb, sizeof(db->aDb[0])*(db->nDb+1) ); + if( aNew==0 ){ + db->mallocFailed = 1; + return; + } + } + db->aDb = aNew; + aNew = &db->aDb[db->nDb++]; + memset(aNew, 0, sizeof(*aNew)); + + /* Open the database file. If the btree is successfully opened, use + ** it to obtain the database schema. At this point the schema may + ** or may not be initialised. + */ + rc = sqlite3BtreeFactory(db, zFile, 0, SQLITE_DEFAULT_CACHE_SIZE, + db->openFlags | SQLITE_OPEN_MAIN_DB, + &aNew->pBt); + if( rc==SQLITE_OK ){ + aNew->pSchema = sqlite3SchemaGet(db, aNew->pBt); + if( !aNew->pSchema ){ + rc = SQLITE_NOMEM; + }else if( aNew->pSchema->file_format && aNew->pSchema->enc!=ENC(db) ){ + sqlite3_snprintf(sizeof(zErr), zErr, + "attached databases must use the same text encoding as main database"); + goto attach_error; + } + sqlite3PagerLockingMode(sqlite3BtreePager(aNew->pBt), db->dfltLockMode); + } + aNew->zName = sqlite3DbStrDup(db, zName); + aNew->safety_level = 3; + +#if SQLITE_HAS_CODEC + { + extern int sqlite3CodecAttach(sqlite3*, int, const void*, int); + extern void sqlite3CodecGetKey(sqlite3*, int, void**, int*); + int nKey; + char *zKey; + int t = sqlite3_value_type(argv[2]); + switch( t ){ + case SQLITE_INTEGER: + case SQLITE_FLOAT: + zErrDyn = sqlite3DbStrDup(db, "Invalid key value"); + rc = SQLITE_ERROR; + break; + + case SQLITE_TEXT: + case SQLITE_BLOB: + nKey = sqlite3_value_bytes(argv[2]); + zKey = (char *)sqlite3_value_blob(argv[2]); + sqlite3CodecAttach(db, db->nDb-1, zKey, nKey); + break; + + case SQLITE_NULL: + /* No key specified. Use the key from the main database */ + sqlite3CodecGetKey(db, 0, (void**)&zKey, &nKey); + sqlite3CodecAttach(db, db->nDb-1, zKey, nKey); + break; + } + } +#endif + + /* If the file was opened successfully, read the schema for the new database. + ** If this fails, or if opening the file failed, then close the file and + ** remove the entry from the db->aDb[] array. i.e. put everything back the way + ** we found it. + */ + if( rc==SQLITE_OK ){ + sqlite3SafetyOn(db); + rc = sqlite3Init(db, &zErrDyn); + sqlite3SafetyOff(db); + } + if( rc ){ + int iDb = db->nDb - 1; + assert( iDb>=2 ); + if( db->aDb[iDb].pBt ){ + sqlite3BtreeClose(db->aDb[iDb].pBt); + db->aDb[iDb].pBt = 0; + db->aDb[iDb].pSchema = 0; + } + sqlite3ResetInternalSchema(db, 0); + db->nDb = iDb; + if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){ + db->mallocFailed = 1; + sqlite3_snprintf(sizeof(zErr),zErr, "out of memory"); + }else{ + sqlite3_snprintf(sizeof(zErr),zErr, "unable to open database: %s", zFile); + } + goto attach_error; + } + + return; + +attach_error: + /* Return an error if we get here */ + if( zErrDyn ){ + sqlite3_result_error(context, zErrDyn, -1); + sqlite3_free(zErrDyn); + }else{ + zErr[sizeof(zErr)-1] = 0; + sqlite3_result_error(context, zErr, -1); + } +} + +/* +** An SQL user-function registered to do the work of an DETACH statement. The +** three arguments to the function come directly from a detach statement: +** +** DETACH DATABASE x +** +** SELECT sqlite_detach(x) +*/ +static void detachFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const char *zName = (const char *)sqlite3_value_text(argv[0]); + sqlite3 *db = (sqlite3 *)sqlite3_user_data(context); + int i; + Db *pDb = 0; + char zErr[128]; + + if( zName==0 ) zName = ""; + for(i=0; inDb; i++){ + pDb = &db->aDb[i]; + if( pDb->pBt==0 ) continue; + if( sqlite3StrICmp(pDb->zName, zName)==0 ) break; + } + + if( i>=db->nDb ){ + sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName); + goto detach_error; + } + if( i<2 ){ + sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName); + goto detach_error; + } + if( !db->autoCommit ){ + sqlite3_snprintf(sizeof(zErr), zErr, + "cannot DETACH database within transaction"); + goto detach_error; + } + if( sqlite3BtreeIsInReadTrans(pDb->pBt) ){ + sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName); + goto detach_error; + } + + sqlite3BtreeClose(pDb->pBt); + pDb->pBt = 0; + pDb->pSchema = 0; + sqlite3ResetInternalSchema(db, 0); + return; + +detach_error: + sqlite3_result_error(context, zErr, -1); +} + +/* +** This procedure generates VDBE code for a single invocation of either the +** sqlite_detach() or sqlite_attach() SQL user functions. +*/ +static void codeAttach( + Parse *pParse, /* The parser context */ + int type, /* Either SQLITE_ATTACH or SQLITE_DETACH */ + const char *zFunc, /* Either "sqlite_attach" or "sqlite_detach */ + int nFunc, /* Number of args to pass to zFunc */ + Expr *pAuthArg, /* Expression to pass to authorization callback */ + Expr *pFilename, /* Name of database file */ + Expr *pDbname, /* Name of the database to use internally */ + Expr *pKey /* Database key for encryption extension */ +){ + int rc; + NameContext sName; + Vdbe *v; + FuncDef *pFunc; + sqlite3* db = pParse->db; + +#ifndef SQLITE_OMIT_AUTHORIZATION + assert( db->mallocFailed || pAuthArg ); + if( pAuthArg ){ + char *zAuthArg = sqlite3NameFromToken(db, &pAuthArg->span); + if( !zAuthArg ){ + goto attach_end; + } + rc = sqlite3AuthCheck(pParse, type, zAuthArg, 0, 0); + sqlite3_free(zAuthArg); + if(rc!=SQLITE_OK ){ + goto attach_end; + } + } +#endif /* SQLITE_OMIT_AUTHORIZATION */ + + memset(&sName, 0, sizeof(NameContext)); + sName.pParse = pParse; + + if( + SQLITE_OK!=(rc = resolveAttachExpr(&sName, pFilename)) || + SQLITE_OK!=(rc = resolveAttachExpr(&sName, pDbname)) || + SQLITE_OK!=(rc = resolveAttachExpr(&sName, pKey)) + ){ + pParse->nErr++; + goto attach_end; + } + + v = sqlite3GetVdbe(pParse); + sqlite3ExprCode(pParse, pFilename); + sqlite3ExprCode(pParse, pDbname); + sqlite3ExprCode(pParse, pKey); + + assert( v || db->mallocFailed ); + if( v ){ + sqlite3VdbeAddOp(v, OP_Function, 0, nFunc); + pFunc = sqlite3FindFunction(db, zFunc, strlen(zFunc), nFunc, SQLITE_UTF8,0); + sqlite3VdbeChangeP3(v, -1, (char *)pFunc, P3_FUNCDEF); + + /* Code an OP_Expire. For an ATTACH statement, set P1 to true (expire this + ** statement only). For DETACH, set it to false (expire all existing + ** statements). + */ + sqlite3VdbeAddOp(v, OP_Expire, (type==SQLITE_ATTACH), 0); + } + +attach_end: + sqlite3ExprDelete(pFilename); + sqlite3ExprDelete(pDbname); + sqlite3ExprDelete(pKey); +} + +/* +** Called by the parser to compile a DETACH statement. +** +** DETACH pDbname +*/ +void sqlite3Detach(Parse *pParse, Expr *pDbname){ + codeAttach(pParse, SQLITE_DETACH, "sqlite_detach", 1, pDbname, 0, 0, pDbname); +} + +/* +** Called by the parser to compile an ATTACH statement. +** +** ATTACH p AS pDbname KEY pKey +*/ +void sqlite3Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *pKey){ + codeAttach(pParse, SQLITE_ATTACH, "sqlite_attach", 3, p, p, pDbname, pKey); +} +#endif /* SQLITE_OMIT_ATTACH */ + +/* +** Register the functions sqlite_attach and sqlite_detach. +*/ +void sqlite3AttachFunctions(sqlite3 *db){ +#ifndef SQLITE_OMIT_ATTACH + static const int enc = SQLITE_UTF8; + sqlite3CreateFunc(db, "sqlite_attach", 3, enc, db, attachFunc, 0, 0); + sqlite3CreateFunc(db, "sqlite_detach", 1, enc, db, detachFunc, 0, 0); +#endif +} + +/* +** Initialize a DbFixer structure. This routine must be called prior +** to passing the structure to one of the sqliteFixAAAA() routines below. +** +** The return value indicates whether or not fixation is required. TRUE +** means we do need to fix the database references, FALSE means we do not. +*/ +int sqlite3FixInit( + DbFixer *pFix, /* The fixer to be initialized */ + Parse *pParse, /* Error messages will be written here */ + int iDb, /* This is the database that must be used */ + const char *zType, /* "view", "trigger", or "index" */ + const Token *pName /* Name of the view, trigger, or index */ +){ + sqlite3 *db; + + if( iDb<0 || iDb==1 ) return 0; + db = pParse->db; + assert( db->nDb>iDb ); + pFix->pParse = pParse; + pFix->zDb = db->aDb[iDb].zName; + pFix->zType = zType; + pFix->pName = pName; + return 1; +} + +/* +** The following set of routines walk through the parse tree and assign +** a specific database to all table references where the database name +** was left unspecified in the original SQL statement. The pFix structure +** must have been initialized by a prior call to sqlite3FixInit(). +** +** These routines are used to make sure that an index, trigger, or +** view in one database does not refer to objects in a different database. +** (Exception: indices, triggers, and views in the TEMP database are +** allowed to refer to anything.) If a reference is explicitly made +** to an object in a different database, an error message is added to +** pParse->zErrMsg and these routines return non-zero. If everything +** checks out, these routines return 0. +*/ +int sqlite3FixSrcList( + DbFixer *pFix, /* Context of the fixation */ + SrcList *pList /* The Source list to check and modify */ +){ + int i; + const char *zDb; + SrcList::SrcList_item *pItem; + + if( pList==0 ) return 0; + zDb = pFix->zDb; + for(i=0, pItem=pList->a; inSrc; i++, pItem++){ + if( pItem->zDatabase==0 ){ + pItem->zDatabase = sqlite3DbStrDup(pFix->pParse->db, zDb); + }else if( sqlite3StrICmp(pItem->zDatabase,zDb)!=0 ){ + sqlite3ErrorMsg(pFix->pParse, + "%s %T cannot reference objects in database %s", + pFix->zType, pFix->pName, pItem->zDatabase); + return 1; + } +#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) + if( sqlite3FixSelect(pFix, pItem->pSelect) ) return 1; + if( sqlite3FixExpr(pFix, pItem->pOn) ) return 1; +#endif + } + return 0; +} +#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) +int sqlite3FixSelect( + DbFixer *pFix, /* Context of the fixation */ + Select *pSelect /* The SELECT statement to be fixed to one database */ +){ + while( pSelect ){ + if( sqlite3FixExprList(pFix, pSelect->pEList) ){ + return 1; + } + if( sqlite3FixSrcList(pFix, pSelect->pSrc) ){ + return 1; + } + if( sqlite3FixExpr(pFix, pSelect->pWhere) ){ + return 1; + } + if( sqlite3FixExpr(pFix, pSelect->pHaving) ){ + return 1; + } + pSelect = pSelect->pPrior; + } + return 0; +} +int sqlite3FixExpr( + DbFixer *pFix, /* Context of the fixation */ + Expr *pExpr /* The expression to be fixed to one database */ +){ + while( pExpr ){ + if( sqlite3FixSelect(pFix, pExpr->pSelect) ){ + return 1; + } + if( sqlite3FixExprList(pFix, pExpr->pList) ){ + return 1; + } + if( sqlite3FixExpr(pFix, pExpr->pRight) ){ + return 1; + } + pExpr = pExpr->pLeft; + } + return 0; +} +int sqlite3FixExprList( + DbFixer *pFix, /* Context of the fixation */ + ExprList *pList /* The expression to be fixed to one database */ +){ + int i; + ExprList::ExprList_item *pItem; + if( pList==0 ) return 0; + for(i=0, pItem=pList->a; inExpr; i++, pItem++){ + if( sqlite3FixExpr(pFix, pItem->pExpr) ){ + return 1; + } + } + return 0; +} +#endif + +#ifndef SQLITE_OMIT_TRIGGER +int sqlite3FixTriggerStep( + DbFixer *pFix, /* Context of the fixation */ + TriggerStep *pStep /* The trigger step be fixed to one database */ +){ + while( pStep ){ + if( sqlite3FixSelect(pFix, pStep->pSelect) ){ + return 1; + } + if( sqlite3FixExpr(pFix, pStep->pWhere) ){ + return 1; + } + if( sqlite3FixExprList(pFix, pStep->pExprList) ){ + return 1; + } + pStep = pStep->pNext; + } + return 0; +} +#endif diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/auth.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/auth.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,234 @@ +/* +** 2003 January 11 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code used to implement the sqlite3_set_authorizer() +** API. This facility is an optional feature of the library. Embedded +** systems that do not need this facility may omit it by recompiling +** the library with -DSQLITE_OMIT_AUTHORIZATION=1 +** +** $Id: auth.cpp 1282 2008-11-13 09:31:33Z LarsPson $ +*/ +#include "sqliteInt.h" + +/* +** All of the code in this file may be omitted by defining a single +** macro. +*/ +#ifndef SQLITE_OMIT_AUTHORIZATION + +/* +** Set or clear the access authorization function. +** +** The access authorization function is be called during the compilation +** phase to verify that the user has read and/or write access permission on +** various fields of the database. The first argument to the auth function +** is a copy of the 3rd argument to this routine. The second argument +** to the auth function is one of these constants: +** +** SQLITE_CREATE_INDEX +** SQLITE_CREATE_TABLE +** SQLITE_CREATE_TEMP_INDEX +** SQLITE_CREATE_TEMP_TABLE +** SQLITE_CREATE_TEMP_TRIGGER +** SQLITE_CREATE_TEMP_VIEW +** SQLITE_CREATE_TRIGGER +** SQLITE_CREATE_VIEW +** SQLITE_DELETE +** SQLITE_DROP_INDEX +** SQLITE_DROP_TABLE +** SQLITE_DROP_TEMP_INDEX +** SQLITE_DROP_TEMP_TABLE +** SQLITE_DROP_TEMP_TRIGGER +** SQLITE_DROP_TEMP_VIEW +** SQLITE_DROP_TRIGGER +** SQLITE_DROP_VIEW +** SQLITE_INSERT +** SQLITE_PRAGMA +** SQLITE_READ +** SQLITE_SELECT +** SQLITE_TRANSACTION +** SQLITE_UPDATE +** +** The third and fourth arguments to the auth function are the name of +** the table and the column that are being accessed. The auth function +** should return either SQLITE_OK, SQLITE_DENY, or SQLITE_IGNORE. If +** SQLITE_OK is returned, it means that access is allowed. SQLITE_DENY +** means that the SQL statement will never-run - the sqlite3_exec() call +** will return with an error. SQLITE_IGNORE means that the SQL statement +** should run but attempts to read the specified column will return NULL +** and attempts to write the column will be ignored. +** +** Setting the auth function to NULL disables this hook. The default +** setting of the auth function is NULL. +*/ +EXPORT_C int sqlite3_set_authorizer( + sqlite3 *db, + int (*xAuth)(void*,int,const char*,const char*,const char*,const char*), + void *pArg +){ + sqlite3_mutex_enter(db->mutex); + db->xAuth = xAuth; + db->pAuthArg = pArg; + sqlite3ExpirePreparedStatements(db); + sqlite3_mutex_leave(db->mutex); + return SQLITE_OK; +} + +/* +** Write an error message into pParse->zErrMsg that explains that the +** user-supplied authorization function returned an illegal value. +*/ +static void sqliteAuthBadReturnCode(Parse *pParse, int rc){ + sqlite3ErrorMsg(pParse, "illegal return value (%d) from the " + "authorization function - should be SQLITE_OK, SQLITE_IGNORE, " + "or SQLITE_DENY", rc); + pParse->rc = SQLITE_ERROR; +} + +/* +** The pExpr should be a TK_COLUMN expression. The table referred to +** is in pTabList or else it is the NEW or OLD table of a trigger. +** Check to see if it is OK to read this particular column. +** +** If the auth function returns SQLITE_IGNORE, change the TK_COLUMN +** instruction into a TK_NULL. If the auth function returns SQLITE_DENY, +** then generate an error. +*/ +void sqlite3AuthRead( + Parse *pParse, /* The parser context */ + Expr *pExpr, /* The expression to check authorization on */ + Schema *pSchema, /* The schema of the expression */ + SrcList *pTabList /* All table that pExpr might refer to */ +){ + sqlite3 *db = pParse->db; + int rc; + Table *pTab = 0; /* The table being read */ + const char *zCol; /* Name of the column of the table */ + int iSrc; /* Index in pTabList->a[] of table being read */ + const char *zDBase; /* Name of database being accessed */ + TriggerStack *pStack; /* The stack of current triggers */ + int iDb; /* The index of the database the expression refers to */ + + if( db->xAuth==0 ) return; + if( pExpr->op!=TK_COLUMN ) return; + iDb = sqlite3SchemaToIndex(pParse->db, pSchema); + if( iDb<0 ){ + /* An attempt to read a column out of a subquery or other + ** temporary table. */ + return; + } + for(iSrc=0; pTabList && iSrcnSrc; iSrc++){ + if( pExpr->iTable==pTabList->a[iSrc].iCursor ) break; + } + if( iSrc>=0 && pTabList && iSrcnSrc ){ + pTab = pTabList->a[iSrc].pTab; + }else if( (pStack = pParse->trigStack)!=0 ){ + /* This must be an attempt to read the NEW or OLD pseudo-tables + ** of a trigger. + */ + assert( pExpr->iTable==pStack->newIdx || pExpr->iTable==pStack->oldIdx ); + pTab = pStack->pTab; + } + if( pTab==0 ) return; + if( pExpr->iColumn>=0 ){ + assert( pExpr->iColumnnCol ); + zCol = pTab->aCol[pExpr->iColumn].zName; + }else if( pTab->iPKey>=0 ){ + assert( pTab->iPKeynCol ); + zCol = pTab->aCol[pTab->iPKey].zName; + }else{ + zCol = "ROWID"; + } + assert( iDb>=0 && iDbnDb ); + zDBase = db->aDb[iDb].zName; + rc = db->xAuth(db->pAuthArg, SQLITE_READ, pTab->zName, zCol, zDBase, + pParse->zAuthContext); + if( rc==SQLITE_IGNORE ){ + pExpr->op = TK_NULL; + }else if( rc==SQLITE_DENY ){ + if( db->nDb>2 || iDb!=0 ){ + sqlite3ErrorMsg(pParse, "access to %s.%s.%s is prohibited", + zDBase, pTab->zName, zCol); + }else{ + sqlite3ErrorMsg(pParse, "access to %s.%s is prohibited",pTab->zName,zCol); + } + pParse->rc = SQLITE_AUTH; + }else if( rc!=SQLITE_OK ){ + sqliteAuthBadReturnCode(pParse, rc); + } +} + +/* +** Do an authorization check using the code and arguments given. Return +** either SQLITE_OK (zero) or SQLITE_IGNORE or SQLITE_DENY. If SQLITE_DENY +** is returned, then the error count and error message in pParse are +** modified appropriately. +*/ +int sqlite3AuthCheck( + Parse *pParse, + int code, + const char *zArg1, + const char *zArg2, + const char *zArg3 +){ + sqlite3 *db = pParse->db; + int rc; + + /* Don't do any authorization checks if the database is initialising + ** or if the parser is being invoked from within sqlite3_declare_vtab. + */ + if( db->init.busy || IN_DECLARE_VTAB ){ + return SQLITE_OK; + } + + if( db->xAuth==0 ){ + return SQLITE_OK; + } + rc = db->xAuth(db->pAuthArg, code, zArg1, zArg2, zArg3, pParse->zAuthContext); + if( rc==SQLITE_DENY ){ + sqlite3ErrorMsg(pParse, "not authorized"); + pParse->rc = SQLITE_AUTH; + }else if( rc!=SQLITE_OK && rc!=SQLITE_IGNORE ){ + rc = SQLITE_DENY; + sqliteAuthBadReturnCode(pParse, rc); + } + return rc; +} + +/* +** Push an authorization context. After this routine is called, the +** zArg3 argument to authorization callbacks will be zContext until +** popped. Or if pParse==0, this routine is a no-op. +*/ +void sqlite3AuthContextPush( + Parse *pParse, + AuthContext *pContext, + const char *zContext +){ + pContext->pParse = pParse; + if( pParse ){ + pContext->zAuthContext = pParse->zAuthContext; + pParse->zAuthContext = zContext; + } +} + +/* +** Pop an authorization context that was previously pushed +** by sqlite3AuthContextPush +*/ +void sqlite3AuthContextPop(AuthContext *pContext){ + if( pContext->pParse ){ + pContext->pParse->zAuthContext = pContext->zAuthContext; + pContext->pParse = 0; + } +} + +#endif /* SQLITE_OMIT_AUTHORIZATION */ diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/btmutex.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/btmutex.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,315 @@ +/* +** 2007 August 27 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** $Id: btmutex.cpp 1282 2008-11-13 09:31:33Z LarsPson $ +** +** This file contains code used to implement mutexes on Btree objects. +** This code really belongs in btree.c. But btree.c is getting too +** big and we want to break it down some. This packaged seemed like +** a good breakout. +*/ +#include "btreeInt.h" +#if SQLITE_THREADSAFE && !defined(SQLITE_OMIT_SHARED_CACHE) + + +/* +** Enter a mutex on the given BTree object. +** +** If the object is not sharable, then no mutex is ever required +** and this routine is a no-op. The underlying mutex is non-recursive. +** But we keep a reference count in Btree.wantToLock so the behavior +** of this interface is recursive. +** +** To avoid deadlocks, multiple Btrees are locked in the same order +** by all database connections. The p->pNext is a list of other +** Btrees belonging to the same database connection as the p Btree +** which need to be locked after p. If we cannot get a lock on +** p, then first unlock all of the others on p->pNext, then wait +** for the lock to become available on p, then relock all of the +** subsequent Btrees that desire a lock. +*/ +void sqlite3BtreeEnter(Btree *p){ + Btree *pLater; + + /* Some basic sanity checking on the Btree. The list of Btrees + ** connected by pNext and pPrev should be in sorted order by + ** Btree.pBt value. All elements of the list should belong to + ** the same connection. Only shared Btrees are on the list. */ + assert( p->pNext==0 || p->pNext->pBt>p->pBt ); + assert( p->pPrev==0 || p->pPrev->pBtpBt ); + assert( p->pNext==0 || p->pNext->db==p->db ); + assert( p->pPrev==0 || p->pPrev->db==p->db ); + assert( p->sharable || (p->pNext==0 && p->pPrev==0) ); + + /* Check for locking consistency */ + assert( !p->locked || p->wantToLock>0 ); + assert( p->sharable || p->wantToLock==0 ); + + /* We should already hold a lock on the database connection */ + assert( sqlite3_mutex_held(p->db->mutex) ); + + if( !p->sharable ) return; + p->wantToLock++; + if( p->locked ) return; + + /* In most cases, we should be able to acquire the lock we + ** want without having to go throught the ascending lock + ** procedure that follows. Just be sure not to block. + */ + if( sqlite3_mutex_try(p->pBt->mutex)==SQLITE_OK ){ + p->locked = 1; + return; + } + + /* To avoid deadlock, first release all locks with a larger + ** BtShared address. Then acquire our lock. Then reacquire + ** the other BtShared locks that we used to hold in ascending + ** order. + */ + for(pLater=p->pNext; pLater; pLater=pLater->pNext){ + assert( pLater->sharable ); + assert( pLater->pNext==0 || pLater->pNext->pBt>pLater->pBt ); + assert( !pLater->locked || pLater->wantToLock>0 ); + if( pLater->locked ){ + sqlite3_mutex_leave(pLater->pBt->mutex); + pLater->locked = 0; + } + } + sqlite3_mutex_enter(p->pBt->mutex); + p->locked = 1; + for(pLater=p->pNext; pLater; pLater=pLater->pNext){ + if( pLater->wantToLock ){ + sqlite3_mutex_enter(pLater->pBt->mutex); + pLater->locked = 1; + } + } +} + +/* +** Exit the recursive mutex on a Btree. +*/ +void sqlite3BtreeLeave(Btree *p){ + if( p->sharable ){ + assert( p->wantToLock>0 ); + p->wantToLock--; + if( p->wantToLock==0 ){ + assert( p->locked ); + sqlite3_mutex_leave(p->pBt->mutex); + p->locked = 0; + } + } +} + +#ifndef NDEBUG +/* +** Return true if the BtShared mutex is held on the btree. +** +** This routine makes no determination one why or another if the +** database connection mutex is held. +** +** This routine is used only from within assert() statements. +*/ +int sqlite3BtreeHoldsMutex(Btree *p){ + return (p->sharable==0 || + (p->locked && p->wantToLock && sqlite3_mutex_held(p->pBt->mutex))); +} +#endif + + +#ifndef SQLITE_OMIT_INCRBLOB +/* +** Enter and leave a mutex on a Btree given a cursor owned by that +** Btree. These entry points are used by incremental I/O and can be +** omitted if that module is not used. +*/ +void sqlite3BtreeEnterCursor(BtCursor *pCur){ + sqlite3BtreeEnter(pCur->pBtree); +} +void sqlite3BtreeLeaveCursor(BtCursor *pCur){ + sqlite3BtreeLeave(pCur->pBtree); +} +#endif /* SQLITE_OMIT_INCRBLOB */ + + +/* +** Enter the mutex on every Btree associated with a database +** connection. This is needed (for example) prior to parsing +** a statement since we will be comparing table and column names +** against all schemas and we do not want those schemas being +** reset out from under us. +** +** There is a corresponding leave-all procedures. +** +** Enter the mutexes in accending order by BtShared pointer address +** to avoid the possibility of deadlock when two threads with +** two or more btrees in common both try to lock all their btrees +** at the same instant. +*/ +void sqlite3BtreeEnterAll(sqlite3 *db){ + int i; + Btree *p, *pLater; + assert( sqlite3_mutex_held(db->mutex) ); + for(i=0; inDb; i++){ + p = db->aDb[i].pBt; + if( p && p->sharable ){ + p->wantToLock++; + if( !p->locked ){ + assert( p->wantToLock==1 ); + while( p->pPrev ) p = p->pPrev; + while( p->locked && p->pNext ) p = p->pNext; + for(pLater = p->pNext; pLater; pLater=pLater->pNext){ + if( pLater->locked ){ + sqlite3_mutex_leave(pLater->pBt->mutex); + pLater->locked = 0; + } + } + while( p ){ + sqlite3_mutex_enter(p->pBt->mutex); + p->locked++; + p = p->pNext; + } + } + } + } +} +void sqlite3BtreeLeaveAll(sqlite3 *db){ + int i; + Btree *p; + assert( sqlite3_mutex_held(db->mutex) ); + for(i=0; inDb; i++){ + p = db->aDb[i].pBt; + if( p && p->sharable ){ + assert( p->wantToLock>0 ); + p->wantToLock--; + if( p->wantToLock==0 ){ + assert( p->locked ); + sqlite3_mutex_leave(p->pBt->mutex); + p->locked = 0; + } + } + } +} + +#ifndef NDEBUG +/* +** Return true if the current thread holds the database connection +** mutex and all required BtShared mutexes. +** +** This routine is used inside assert() statements only. +*/ +int sqlite3BtreeHoldsAllMutexes(sqlite3 *db){ + int i; + if( !sqlite3_mutex_held(db->mutex) ){ + return 0; + } + for(i=0; inDb; i++){ + Btree *p; + p = db->aDb[i].pBt; + if( p && p->sharable && + (p->wantToLock==0 || !sqlite3_mutex_held(p->pBt->mutex)) ){ + return 0; + } + } + return 1; +} +#endif /* NDEBUG */ + +/* +** Potentially dd a new Btree pointer to a BtreeMutexArray. +** Really only add the Btree if it can possibly be shared with +** another database connection. +** +** The Btrees are kept in sorted order by pBtree->pBt. That +** way when we go to enter all the mutexes, we can enter them +** in order without every having to backup and retry and without +** worrying about deadlock. +** +** The number of shared btrees will always be small (usually 0 or 1) +** so an insertion sort is an adequate algorithm here. +*/ +void sqlite3BtreeMutexArrayInsert(BtreeMutexArray *pArray, Btree *pBtree){ + int i, j; + BtShared *pBt; + if( pBtree==0 || pBtree->sharable==0 ) return; +#ifndef NDEBUG + { + for(i=0; inMutex; i++){ + assert( pArray->aBtree[i]!=pBtree ); + } + } +#endif + assert( pArray->nMutex>=0 ); + assert( pArray->nMutexaBtree)/sizeof(pArray->aBtree[0])-1 ); + pBt = pBtree->pBt; + for(i=0; inMutex; i++){ + assert( pArray->aBtree[i]!=pBtree ); + if( pArray->aBtree[i]->pBt>pBt ){ + for(j=pArray->nMutex; j>i; j--){ + pArray->aBtree[j] = pArray->aBtree[j-1]; + } + pArray->aBtree[i] = pBtree; + pArray->nMutex++; + return; + } + } + pArray->aBtree[pArray->nMutex++] = pBtree; +} + +/* +** Enter the mutex of every btree in the array. This routine is +** called at the beginning of sqlite3VdbeExec(). The mutexes are +** exited at the end of the same function. +*/ +void sqlite3BtreeMutexArrayEnter(BtreeMutexArray *pArray){ + int i; + for(i=0; inMutex; i++){ + Btree *p = pArray->aBtree[i]; + /* Some basic sanity checking */ + assert( i==0 || pArray->aBtree[i-1]->pBtpBt ); + assert( !p->locked || p->wantToLock>0 ); + + /* We should already hold a lock on the database connection */ + assert( sqlite3_mutex_held(p->db->mutex) ); + + p->wantToLock++; + if( !p->locked && p->sharable ){ + sqlite3_mutex_enter(p->pBt->mutex); + p->locked = 1; + } + } +} + +/* +** Leave the mutex of every btree in the group. +*/ +void sqlite3BtreeMutexArrayLeave(BtreeMutexArray *pArray){ + int i; + for(i=0; inMutex; i++){ + Btree *p = pArray->aBtree[i]; + /* Some basic sanity checking */ + assert( i==0 || pArray->aBtree[i-1]->pBtpBt ); + assert( p->locked || !p->sharable ); + assert( p->wantToLock>0 ); + + /* We should already hold a lock on the database connection */ + assert( sqlite3_mutex_held(p->db->mutex) ); + + p->wantToLock--; + if( p->wantToLock==0 && p->locked ){ + sqlite3_mutex_leave(p->pBt->mutex); + p->locked = 0; + } + } +} + + +#endif /* SQLITE_THREADSAFE && !SQLITE_OMIT_SHARED_CACHE */ diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/btree.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/btree.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,6916 @@ +/* +** 2004 April 6 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** $Id: btree.cpp 1282 2008-11-13 09:31:33Z LarsPson $ +** +** This file implements a external (disk-based) database using BTrees. +** See the header comment on "btreeInt.h" for additional information. +** Including a description of file format and an overview of operation. +*/ +#include "btreeInt.h" + +/* +** The header string that appears at the beginning of every +** SQLite database. +*/ +static const char zMagicHeader[] = SQLITE_FILE_HEADER; + +/* +** Set this global variable to 1 to enable tracing using the TRACE +** macro. +*/ +#if SQLITE_TEST +int sqlite3_btree_trace=0; /* True to enable tracing */ +#endif + + + +#ifndef SQLITE_OMIT_SHARED_CACHE +/* +** A flag to indicate whether or not shared cache is enabled. Also, +** a list of BtShared objects that are eligible for participation +** in shared cache. The variables have file scope during normal builds, +** but the test harness needs to access these variables so we make them +** global for test builds. +*/ +#ifdef SQLITE_TEST +BtShared *sqlite3SharedCacheList = 0; +int sqlite3SharedCacheEnabled = 0; +#else +static BtShared *sqlite3SharedCacheList = 0; +static int sqlite3SharedCacheEnabled = 0; +#endif +#endif /* SQLITE_OMIT_SHARED_CACHE */ + +#ifndef SQLITE_OMIT_SHARED_CACHE +/* +** Enable or disable the shared pager and schema features. +** +** This routine has no effect on existing database connections. +** The shared cache setting effects only future calls to +** sqlite3_open(), sqlite3_open16(), or sqlite3_open_v2(). +*/ +EXPORT_C int sqlite3_enable_shared_cache(int enable){ + sqlite3SharedCacheEnabled = enable; + return SQLITE_OK; +} +#endif + + +/* +** Forward declaration +*/ +static int checkReadLocks(Btree*,Pgno,BtCursor*); + + +#ifdef SQLITE_OMIT_SHARED_CACHE + /* + ** The functions queryTableLock(), lockTable() and unlockAllTables() + ** manipulate entries in the BtShared.pLock linked list used to store + ** shared-cache table level locks. If the library is compiled with the + ** shared-cache feature disabled, then there is only ever one user + ** of each BtShared structure and so this locking is not necessary. + ** So define the lock related functions as no-ops. + */ + #define queryTableLock(a,b,c) SQLITE_OK + #define lockTable(a,b,c) SQLITE_OK + #define unlockAllTables(a) +#endif + +#ifndef SQLITE_OMIT_SHARED_CACHE +/* +** Query to see if btree handle p may obtain a lock of type eLock +** (READ_LOCK or WRITE_LOCK) on the table with root-page iTab. Return +** SQLITE_OK if the lock may be obtained (by calling lockTable()), or +** SQLITE_LOCKED if not. +*/ +static int queryTableLock(Btree *p, Pgno iTab, u8 eLock){ + BtShared *pBt = p->pBt; + BtLock *pIter; + + assert( sqlite3BtreeHoldsMutex(p) ); + + /* This is a no-op if the shared-cache is not enabled */ + if( !p->sharable ){ + return SQLITE_OK; + } + + /* This (along with lockTable()) is where the ReadUncommitted flag is + ** dealt with. If the caller is querying for a read-lock and the flag is + ** set, it is unconditionally granted - even if there are write-locks + ** on the table. If a write-lock is requested, the ReadUncommitted flag + ** is not considered. + ** + ** In function lockTable(), if a read-lock is demanded and the + ** ReadUncommitted flag is set, no entry is added to the locks list + ** (BtShared.pLock). + ** + ** To summarize: If the ReadUncommitted flag is set, then read cursors do + ** not create or respect table locks. The locking procedure for a + ** write-cursor does not change. + */ + if( + !p->db || + 0==(p->db->flags&SQLITE_ReadUncommitted) || + eLock==WRITE_LOCK || + iTab==MASTER_ROOT + ){ + for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){ + if( pIter->pBtree!=p && pIter->iTable==iTab && + (pIter->eLock!=eLock || eLock!=READ_LOCK) ){ + return SQLITE_LOCKED; + } + } + } + return SQLITE_OK; +} +#endif /* !SQLITE_OMIT_SHARED_CACHE */ + +#ifndef SQLITE_OMIT_SHARED_CACHE +/* +** Add a lock on the table with root-page iTable to the shared-btree used +** by Btree handle p. Parameter eLock must be either READ_LOCK or +** WRITE_LOCK. +** +** SQLITE_OK is returned if the lock is added successfully. SQLITE_BUSY and +** SQLITE_NOMEM may also be returned. +*/ +static int lockTable(Btree *p, Pgno iTable, u8 eLock){ + BtShared *pBt = p->pBt; + BtLock *pLock = 0; + BtLock *pIter; + + assert( sqlite3BtreeHoldsMutex(p) ); + + /* This is a no-op if the shared-cache is not enabled */ + if( !p->sharable ){ + return SQLITE_OK; + } + + assert( SQLITE_OK==queryTableLock(p, iTable, eLock) ); + + /* If the read-uncommitted flag is set and a read-lock is requested, + ** return early without adding an entry to the BtShared.pLock list. See + ** comment in function queryTableLock() for more info on handling + ** the ReadUncommitted flag. + */ + if( + (p->db) && + (p->db->flags&SQLITE_ReadUncommitted) && + (eLock==READ_LOCK) && + iTable!=MASTER_ROOT + ){ + return SQLITE_OK; + } + + /* First search the list for an existing lock on this table. */ + for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){ + if( pIter->iTable==iTable && pIter->pBtree==p ){ + pLock = pIter; + break; + } + } + + /* If the above search did not find a BtLock struct associating Btree p + ** with table iTable, allocate one and link it into the list. + */ + if( !pLock ){ + pLock = (BtLock *)sqlite3MallocZero(sizeof(BtLock)); + if( !pLock ){ + return SQLITE_NOMEM; + } + pLock->iTable = iTable; + pLock->pBtree = p; + pLock->pNext = pBt->pLock; + pBt->pLock = pLock; + } + + /* Set the BtLock.eLock variable to the maximum of the current lock + ** and the requested lock. This means if a write-lock was already held + ** and a read-lock requested, we don't incorrectly downgrade the lock. + */ + assert( WRITE_LOCK>READ_LOCK ); + if( eLock>pLock->eLock ){ + pLock->eLock = eLock; + } + + return SQLITE_OK; +} +#endif /* !SQLITE_OMIT_SHARED_CACHE */ + +#ifndef SQLITE_OMIT_SHARED_CACHE +/* +** Release all the table locks (locks obtained via calls to the lockTable() +** procedure) held by Btree handle p. +*/ +static void unlockAllTables(Btree *p){ + BtLock **ppIter = &p->pBt->pLock; + + assert( sqlite3BtreeHoldsMutex(p) ); + assert( p->sharable || 0==*ppIter ); + + while( *ppIter ){ + BtLock *pLock = *ppIter; + if( pLock->pBtree==p ){ + *ppIter = pLock->pNext; + sqlite3_free(pLock); + }else{ + ppIter = &pLock->pNext; + } + } +} +#endif /* SQLITE_OMIT_SHARED_CACHE */ + +static void releasePage(MemPage *pPage); /* Forward reference */ + +/* +** Verify that the cursor holds a mutex on the BtShared +*/ +#ifndef NDEBUG +static int cursorHoldsMutex(BtCursor *p){ + return sqlite3_mutex_held(p->pBt->mutex); +} +#endif + + +#ifndef SQLITE_OMIT_INCRBLOB +/* +** Invalidate the overflow page-list cache for cursor pCur, if any. +*/ +static void invalidateOverflowCache(BtCursor *pCur){ + assert( cursorHoldsMutex(pCur) ); + sqlite3_free(pCur->aOverflow); + pCur->aOverflow = 0; +} + +/* +** Invalidate the overflow page-list cache for all cursors opened +** on the shared btree structure pBt. +*/ +static void invalidateAllOverflowCache(BtShared *pBt){ + BtCursor *p; + assert( sqlite3_mutex_held(pBt->mutex) ); + for(p=pBt->pCursor; p; p=p->pNext){ + invalidateOverflowCache(p); + } +} +#else + #define invalidateOverflowCache(x) + #define invalidateAllOverflowCache(x) +#endif + +/* +** Save the current cursor position in the variables BtCursor.nKey +** and BtCursor.pKey. The cursor's state is set to CURSOR_REQUIRESEEK. +*/ +static int saveCursorPosition(BtCursor *pCur){ + int rc; + + assert( CURSOR_VALID==pCur->eState ); + assert( 0==pCur->pKey ); + assert( cursorHoldsMutex(pCur) ); + + rc = sqlite3BtreeKeySize(pCur, &pCur->nKey); + + /* If this is an intKey table, then the above call to BtreeKeySize() + ** stores the integer key in pCur->nKey. In this case this value is + ** all that is required. Otherwise, if pCur is not open on an intKey + ** table, then malloc space for and store the pCur->nKey bytes of key + ** data. + */ + if( rc==SQLITE_OK && 0==pCur->pPage->intKey){ + void *pKey = sqlite3_malloc(pCur->nKey); + if( pKey ){ + rc = sqlite3BtreeKey(pCur, 0, pCur->nKey, pKey); + if( rc==SQLITE_OK ){ + pCur->pKey = pKey; + }else{ + sqlite3_free(pKey); + } + }else{ + rc = SQLITE_NOMEM; + } + } + assert( !pCur->pPage->intKey || !pCur->pKey ); + + if( rc==SQLITE_OK ){ + releasePage(pCur->pPage); + pCur->pPage = 0; + pCur->eState = CURSOR_REQUIRESEEK; + } + + invalidateOverflowCache(pCur); + return rc; +} + +/* +** Save the positions of all cursors except pExcept open on the table +** with root-page iRoot. Usually, this is called just before cursor +** pExcept is used to modify the table (BtreeDelete() or BtreeInsert()). +*/ +static int saveAllCursors(BtShared *pBt, Pgno iRoot, BtCursor *pExcept){ + BtCursor *p; + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( pExcept==0 || pExcept->pBt==pBt ); + for(p=pBt->pCursor; p; p=p->pNext){ + if( p!=pExcept && (0==iRoot || p->pgnoRoot==iRoot) && + p->eState==CURSOR_VALID ){ + int rc = saveCursorPosition(p); + if( SQLITE_OK!=rc ){ + return rc; + } + } + } + return SQLITE_OK; +} + +/* +** Clear the current cursor position. +*/ +static void clearCursorPosition(BtCursor *pCur){ + assert( cursorHoldsMutex(pCur) ); + sqlite3_free(pCur->pKey); + pCur->pKey = 0; + pCur->eState = CURSOR_INVALID; +} + +/* +** Restore the cursor to the position it was in (or as close to as possible) +** when saveCursorPosition() was called. Note that this call deletes the +** saved position info stored by saveCursorPosition(), so there can be +** at most one effective restoreOrClearCursorPosition() call after each +** saveCursorPosition(). +** +** If the second argument argument - doSeek - is false, then instead of +** returning the cursor to its saved position, any saved position is deleted +** and the cursor state set to CURSOR_INVALID. +*/ +int sqlite3BtreeRestoreOrClearCursorPosition(BtCursor *pCur){ + int rc; + assert( cursorHoldsMutex(pCur) ); + assert( pCur->eState>=CURSOR_REQUIRESEEK ); + if( pCur->eState==CURSOR_FAULT ){ + return pCur->skip; + } +#ifndef SQLITE_OMIT_INCRBLOB + if( pCur->isIncrblobHandle ){ + return SQLITE_ABORT; + } +#endif + pCur->eState = CURSOR_INVALID; + rc = sqlite3BtreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &pCur->skip); + if( rc==SQLITE_OK ){ + sqlite3_free(pCur->pKey); + pCur->pKey = 0; + assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_INVALID ); + } + return rc; +} + +#define restoreOrClearCursorPosition(p) \ + (p->eState>=CURSOR_REQUIRESEEK ? \ + sqlite3BtreeRestoreOrClearCursorPosition(p) : \ + SQLITE_OK) + +#ifndef SQLITE_OMIT_AUTOVACUUM +/* +** Given a page number of a regular database page, return the page +** number for the pointer-map page that contains the entry for the +** input page number. +*/ +static Pgno ptrmapPageno(BtShared *pBt, Pgno pgno){ + int nPagesPerMapPage, iPtrMap, ret; + assert( sqlite3_mutex_held(pBt->mutex) ); + nPagesPerMapPage = (pBt->usableSize/5)+1; + iPtrMap = (pgno-2)/nPagesPerMapPage; + ret = (iPtrMap*nPagesPerMapPage) + 2; + if( ret==PENDING_BYTE_PAGE(pBt) ){ + ret++; + } + return ret; +} + +/* +** Write an entry into the pointer map. +** +** This routine updates the pointer map entry for page number 'key' +** so that it maps to type 'eType' and parent page number 'pgno'. +** An error code is returned if something goes wrong, otherwise SQLITE_OK. +*/ +static int ptrmapPut(BtShared *pBt, Pgno key, u8 eType, Pgno parent){ + DbPage *pDbPage; /* The pointer map page */ + u8 *pPtrmap; /* The pointer map data */ + Pgno iPtrmap; /* The pointer map page number */ + int offset; /* Offset in pointer map page */ + int rc; + + assert( sqlite3_mutex_held(pBt->mutex) ); + /* The master-journal page number must never be used as a pointer map page */ + assert( 0==PTRMAP_ISPAGE(pBt, PENDING_BYTE_PAGE(pBt)) ); + + assert( pBt->autoVacuum ); + if( key==0 ){ + return SQLITE_CORRUPT_BKPT; + } + iPtrmap = PTRMAP_PAGENO(pBt, key); + rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage); + if( rc!=SQLITE_OK ){ + return rc; + } + offset = PTRMAP_PTROFFSET(pBt, key); + pPtrmap = (u8 *)sqlite3PagerGetData(pDbPage); + + if( eType!=pPtrmap[offset] || get4byte(&pPtrmap[offset+1])!=parent ){ + TRACE(("PTRMAP_UPDATE: %d->(%d,%d)\n", key, eType, parent)); + rc = sqlite3PagerWrite(pDbPage); + if( rc==SQLITE_OK ){ + pPtrmap[offset] = eType; + put4byte(&pPtrmap[offset+1], parent); + } + } + + sqlite3PagerUnref(pDbPage); + return rc; +} + +/* +** Read an entry from the pointer map. +** +** This routine retrieves the pointer map entry for page 'key', writing +** the type and parent page number to *pEType and *pPgno respectively. +** An error code is returned if something goes wrong, otherwise SQLITE_OK. +*/ +static int ptrmapGet(BtShared *pBt, Pgno key, u8 *pEType, Pgno *pPgno){ + DbPage *pDbPage; /* The pointer map page */ + int iPtrmap; /* Pointer map page index */ + u8 *pPtrmap; /* Pointer map page data */ + int offset; /* Offset of entry in pointer map */ + int rc; + + assert( sqlite3_mutex_held(pBt->mutex) ); + + iPtrmap = PTRMAP_PAGENO(pBt, key); + rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage); + if( rc!=0 ){ + return rc; + } + pPtrmap = (u8 *)sqlite3PagerGetData(pDbPage); + + offset = PTRMAP_PTROFFSET(pBt, key); + assert( pEType!=0 ); + *pEType = pPtrmap[offset]; + if( pPgno ) *pPgno = get4byte(&pPtrmap[offset+1]); + + sqlite3PagerUnref(pDbPage); + if( *pEType<1 || *pEType>5 ) return SQLITE_CORRUPT_BKPT; + return SQLITE_OK; +} + +#endif /* SQLITE_OMIT_AUTOVACUUM */ + +/* +** Given a btree page and a cell index (0 means the first cell on +** the page, 1 means the second cell, and so forth) return a pointer +** to the cell content. +** +** This routine works only for pages that do not contain overflow cells. +*/ +#define findCell(pPage, iCell) \ + ((pPage)->aData + get2byte(&(pPage)->aData[(pPage)->cellOffset+2*(iCell)])) +#ifdef SQLITE_TEST +u8 *sqlite3BtreeFindCell(MemPage *pPage, int iCell){ + assert( iCell>=0 ); + assert( iCellaData[pPage->hdrOffset+3]) ); + return findCell(pPage, iCell); +} +#endif + +/* +** This a more complex version of sqlite3BtreeFindCell() that works for +** pages that do contain overflow cells. See insert +*/ +static u8 *findOverflowCell(MemPage *pPage, int iCell){ + int i; + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + for(i=pPage->nOverflow-1; i>=0; i--){ + int k; + MemPage::_OvflCell *pOvfl; + pOvfl = &pPage->aOvfl[i]; + k = pOvfl->idx; + if( k<=iCell ){ + if( k==iCell ){ + return pOvfl->pCell; + } + iCell--; + } + } + return findCell(pPage, iCell); +} + +/* +** Parse a cell content block and fill in the CellInfo structure. There +** are two versions of this function. sqlite3BtreeParseCell() takes a +** cell index as the second argument and sqlite3BtreeParseCellPtr() +** takes a pointer to the body of the cell as its second argument. +** +** Within this file, the parseCell() macro can be called instead of +** sqlite3BtreeParseCellPtr(). Using some compilers, this will be faster. +*/ +void sqlite3BtreeParseCellPtr( + MemPage *pPage, /* Page containing the cell */ + u8 *pCell, /* Pointer to the cell text. */ + CellInfo *pInfo /* Fill in this structure */ +){ + int n; /* Number bytes in cell content header */ + u32 nPayload; /* Number of bytes of cell payload */ + + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + + pInfo->pCell = pCell; + assert( pPage->leaf==0 || pPage->leaf==1 ); + n = pPage->childPtrSize; + assert( n==4-4*pPage->leaf ); + if( pPage->hasData ){ + n += getVarint32(&pCell[n], &nPayload); + }else{ + nPayload = 0; + } + pInfo->nData = nPayload; + if( pPage->intKey ){ + n += getVarint(&pCell[n], (u64 *)&pInfo->nKey); + }else{ + u32 x; + n += getVarint32(&pCell[n], &x); + pInfo->nKey = x; + nPayload += x; + } + pInfo->nPayload = nPayload; + pInfo->nHeader = n; + if( nPayload<=pPage->maxLocal ){ + /* This is the (easy) common case where the entire payload fits + ** on the local page. No overflow is required. + */ + int nSize; /* Total size of cell content in bytes */ + pInfo->nLocal = nPayload; + pInfo->iOverflow = 0; + nSize = nPayload + n; + if( nSize<4 ){ + nSize = 4; /* Minimum cell size is 4 */ + } + pInfo->nSize = nSize; + }else{ + /* If the payload will not fit completely on the local page, we have + ** to decide how much to store locally and how much to spill onto + ** overflow pages. The strategy is to minimize the amount of unused + ** space on overflow pages while keeping the amount of local storage + ** in between minLocal and maxLocal. + ** + ** Warning: changing the way overflow payload is distributed in any + ** way will result in an incompatible file format. + */ + int minLocal; /* Minimum amount of payload held locally */ + int maxLocal; /* Maximum amount of payload held locally */ + int surplus; /* Overflow payload available for local storage */ + + minLocal = pPage->minLocal; + maxLocal = pPage->maxLocal; + surplus = minLocal + (nPayload - minLocal)%(pPage->pBt->usableSize - 4); + if( surplus <= maxLocal ){ + pInfo->nLocal = surplus; + }else{ + pInfo->nLocal = minLocal; + } + pInfo->iOverflow = pInfo->nLocal + n; + pInfo->nSize = pInfo->iOverflow + 4; + } +} +#define parseCell(pPage, iCell, pInfo) \ + sqlite3BtreeParseCellPtr((pPage), findCell((pPage), (iCell)), (pInfo)) +void sqlite3BtreeParseCell( + MemPage *pPage, /* Page containing the cell */ + int iCell, /* The cell index. First cell is 0 */ + CellInfo *pInfo /* Fill in this structure */ +){ + parseCell(pPage, iCell, pInfo); +} + +/* +** Compute the total number of bytes that a Cell needs in the cell +** data area of the btree-page. The return number includes the cell +** data header and the local payload, but not any overflow page or +** the space used by the cell pointer. +*/ +#ifndef NDEBUG +static int cellSize(MemPage *pPage, int iCell){ + CellInfo info; + sqlite3BtreeParseCell(pPage, iCell, &info); + return info.nSize; +} +#endif +static int cellSizePtr(MemPage *pPage, u8 *pCell){ + CellInfo info; + sqlite3BtreeParseCellPtr(pPage, pCell, &info); + return info.nSize; +} + +#ifndef SQLITE_OMIT_AUTOVACUUM +/* +** If the cell pCell, part of page pPage contains a pointer +** to an overflow page, insert an entry into the pointer-map +** for the overflow page. +*/ +static int ptrmapPutOvflPtr(MemPage *pPage, u8 *pCell){ + if( pCell ){ + CellInfo info; + sqlite3BtreeParseCellPtr(pPage, pCell, &info); + assert( (info.nData+(pPage->intKey?0:info.nKey))==info.nPayload ); + if( (info.nData+(pPage->intKey?0:info.nKey))>info.nLocal ){ + Pgno ovfl = get4byte(&pCell[info.iOverflow]); + return ptrmapPut(pPage->pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno); + } + } + return SQLITE_OK; +} +/* +** If the cell with index iCell on page pPage contains a pointer +** to an overflow page, insert an entry into the pointer-map +** for the overflow page. +*/ +static int ptrmapPutOvfl(MemPage *pPage, int iCell){ + u8 *pCell; + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + pCell = findOverflowCell(pPage, iCell); + return ptrmapPutOvflPtr(pPage, pCell); +} +#endif + + +/* +** Defragment the page given. All Cells are moved to the +** end of the page and all free space is collected into one +** big FreeBlk that occurs in between the header and cell +** pointer array and the cell content area. +*/ +static int defragmentPage(MemPage *pPage){ + int i; /* Loop counter */ + int pc; /* Address of a i-th cell */ + int addr; /* Offset of first byte after cell pointer array */ + int hdr; /* Offset to the page header */ + int size; /* Size of a cell */ + int usableSize; /* Number of usable bytes on a page */ + int cellOffset; /* Offset to the cell pointer array */ + int brk; /* Offset to the cell content area */ + int nCell; /* Number of cells on the page */ + unsigned char *data; /* The page data */ + unsigned char *temp; /* Temp area for cell content */ + + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); + assert( pPage->pBt!=0 ); + assert( pPage->pBt->usableSize <= SQLITE_MAX_PAGE_SIZE ); + assert( pPage->nOverflow==0 ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + temp = (unsigned char*)sqlite3PagerTempSpace(pPage->pBt->pPager); + data = pPage->aData; + hdr = pPage->hdrOffset; + cellOffset = pPage->cellOffset; + nCell = pPage->nCell; + assert( nCell==get2byte(&data[hdr+3]) ); + usableSize = pPage->pBt->usableSize; + brk = get2byte(&data[hdr+5]); + memcpy(&temp[brk], &data[brk], usableSize - brk); + brk = usableSize; + for(i=0; ipBt->usableSize ); + size = cellSizePtr(pPage, &temp[pc]); + brk -= size; + memcpy(&data[brk], &temp[pc], size); + put2byte(pAddr, brk); + } + assert( brk>=cellOffset+2*nCell ); + put2byte(&data[hdr+5], brk); + data[hdr+1] = 0; + data[hdr+2] = 0; + data[hdr+7] = 0; + addr = cellOffset+2*nCell; + memset(&data[addr], 0, brk-addr); + return SQLITE_OK; +} + +/* +** Allocate nByte bytes of space on a page. +** +** Return the index into pPage->aData[] of the first byte of +** the new allocation. Or return 0 if there is not enough free +** space on the page to satisfy the allocation request. +** +** If the page contains nBytes of free space but does not contain +** nBytes of contiguous free space, then this routine automatically +** calls defragementPage() to consolidate all free space before +** allocating the new chunk. +*/ +static int allocateSpace(MemPage *pPage, int nByte){ + int addr, pc, hdr; + int size; + int nFrag; + int top; + int nCell; + int cellOffset; + unsigned char *data; + + data = pPage->aData; + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); + assert( pPage->pBt ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + if( nByte<4 ) nByte = 4; + if( pPage->nFreenOverflow>0 ) return 0; + pPage->nFree -= nByte; + hdr = pPage->hdrOffset; + + nFrag = data[hdr+7]; + if( nFrag<60 ){ + /* Search the freelist looking for a slot big enough to satisfy the + ** space request. */ + addr = hdr+1; + while( (pc = get2byte(&data[addr]))>0 ){ + size = get2byte(&data[pc+2]); + if( size>=nByte ){ + if( sizecellOffset; + if( nFrag>=60 || cellOffset + 2*nCell > top - nByte ){ + if( defragmentPage(pPage) ) return 0; + top = get2byte(&data[hdr+5]); + } + top -= nByte; + assert( cellOffset + 2*nCell <= top ); + put2byte(&data[hdr+5], top); + return top; +} + +/* +** Return a section of the pPage->aData to the freelist. +** The first byte of the new free block is pPage->aDisk[start] +** and the size of the block is "size" bytes. +** +** Most of the effort here is involved in coalesing adjacent +** free blocks into a single big free block. +*/ +static void freeSpace(MemPage *pPage, int start, int size){ + int addr, pbegin, hdr; + unsigned char *data = pPage->aData; + + assert( pPage->pBt!=0 ); + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); + assert( start>=pPage->hdrOffset+6+(pPage->leaf?0:4) ); + assert( (start + size)<=pPage->pBt->usableSize ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + if( size<4 ) size = 4; + +#ifdef SQLITE_SECURE_DELETE + /* Overwrite deleted information with zeros when the SECURE_DELETE + ** option is enabled at compile-time */ + memset(&data[start], 0, size); +#endif + + /* Add the space back into the linked list of freeblocks */ + hdr = pPage->hdrOffset; + addr = hdr + 1; + while( (pbegin = get2byte(&data[addr]))0 ){ + assert( pbegin<=pPage->pBt->usableSize-4 ); + assert( pbegin>addr ); + addr = pbegin; + } + assert( pbegin<=pPage->pBt->usableSize-4 ); + assert( pbegin>addr || pbegin==0 ); + put2byte(&data[addr], start); + put2byte(&data[start], pbegin); + put2byte(&data[start+2], size); + pPage->nFree += size; + + /* Coalesce adjacent free blocks */ + addr = pPage->hdrOffset + 1; + while( (pbegin = get2byte(&data[addr]))>0 ){ + int pnext, psize; + assert( pbegin>addr ); + assert( pbegin<=pPage->pBt->usableSize-4 ); + pnext = get2byte(&data[pbegin]); + psize = get2byte(&data[pbegin+2]); + if( pbegin + psize + 3 >= pnext && pnext>0 ){ + int frag = pnext - (pbegin+psize); + assert( frag<=data[pPage->hdrOffset+7] ); + data[pPage->hdrOffset+7] -= frag; + put2byte(&data[pbegin], get2byte(&data[pnext])); + put2byte(&data[pbegin+2], pnext+get2byte(&data[pnext+2])-pbegin); + }else{ + addr = pbegin; + } + } + + /* If the cell content area begins with a freeblock, remove it. */ + if( data[hdr+1]==data[hdr+5] && data[hdr+2]==data[hdr+6] ){ + int top; + pbegin = get2byte(&data[hdr+1]); + memcpy(&data[hdr+1], &data[pbegin], 2); + top = get2byte(&data[hdr+5]); + put2byte(&data[hdr+5], top + get2byte(&data[pbegin+2])); + } +} + +/* +** Decode the flags byte (the first byte of the header) for a page +** and initialize fields of the MemPage structure accordingly. +*/ +static void decodeFlags(MemPage *pPage, int flagByte){ + BtShared *pBt; /* A copy of pPage->pBt */ + + assert( pPage->hdrOffset==(pPage->pgno==1 ? 100 : 0) ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + pPage->intKey = (flagByte & (PTF_INTKEY|PTF_LEAFDATA))!=0; + pPage->zeroData = (flagByte & PTF_ZERODATA)!=0; + pPage->leaf = (flagByte & PTF_LEAF)!=0; + pPage->childPtrSize = 4*(pPage->leaf==0); + pBt = pPage->pBt; + if( flagByte & PTF_LEAFDATA ){ + pPage->leafData = 1; + pPage->maxLocal = pBt->maxLeaf; + pPage->minLocal = pBt->minLeaf; + }else{ + pPage->leafData = 0; + pPage->maxLocal = pBt->maxLocal; + pPage->minLocal = pBt->minLocal; + } + pPage->hasData = !(pPage->zeroData || (!pPage->leaf && pPage->leafData)); +} + +/* +** Initialize the auxiliary information for a disk block. +** +** The pParent parameter must be a pointer to the MemPage which +** is the parent of the page being initialized. The root of a +** BTree has no parent and so for that page, pParent==NULL. +** +** Return SQLITE_OK on success. If we see that the page does +** not contain a well-formed database page, then return +** SQLITE_CORRUPT. Note that a return of SQLITE_OK does not +** guarantee that the page is well-formed. It only shows that +** we failed to detect any corruption. +*/ +int sqlite3BtreeInitPage( + MemPage *pPage, /* The page to be initialized */ + MemPage *pParent /* The parent. Might be NULL */ +){ + int pc; /* Address of a freeblock within pPage->aData[] */ + int hdr; /* Offset to beginning of page header */ + u8 *data; /* Equal to pPage->aData */ + BtShared *pBt; /* The main btree structure */ + int usableSize; /* Amount of usable space on each page */ + int cellOffset; /* Offset from start of page to first cell pointer */ + int nFree; /* Number of unused bytes on the page */ + int top; /* First byte of the cell content area */ + + pBt = pPage->pBt; + assert( pBt!=0 ); + assert( pParent==0 || pParent->pBt==pBt ); + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( pPage->pgno==sqlite3PagerPagenumber(pPage->pDbPage) ); + assert( pPage == sqlite3PagerGetExtra(pPage->pDbPage) ); + assert( pPage->aData == sqlite3PagerGetData(pPage->pDbPage) ); + if( pPage->pParent!=pParent && (pPage->pParent!=0 || pPage->isInit) ){ + /* The parent page should never change unless the file is corrupt */ + return SQLITE_CORRUPT_BKPT; + } + if( pPage->isInit ) return SQLITE_OK; + if( pPage->pParent==0 && pParent!=0 ){ + pPage->pParent = pParent; + sqlite3PagerRef(pParent->pDbPage); + } + hdr = pPage->hdrOffset; + data = pPage->aData; + decodeFlags(pPage, data[hdr]); + pPage->nOverflow = 0; + pPage->idxShift = 0; + usableSize = pBt->usableSize; + pPage->cellOffset = cellOffset = hdr + 12 - 4*pPage->leaf; + top = get2byte(&data[hdr+5]); + pPage->nCell = get2byte(&data[hdr+3]); + if( pPage->nCell>MX_CELL(pBt) ){ + /* To many cells for a single page. The page must be corrupt */ + return SQLITE_CORRUPT_BKPT; + } + if( pPage->nCell==0 && pParent!=0 && pParent->pgno!=1 ){ + /* All pages must have at least one cell, except for root pages */ + return SQLITE_CORRUPT_BKPT; + } + + /* Compute the total free space on the page */ + pc = get2byte(&data[hdr+1]); + nFree = data[hdr+7] + top - (cellOffset + 2*pPage->nCell); + while( pc>0 ){ + int next, size; + if( pc>usableSize-4 ){ + /* Free block is off the page */ + return SQLITE_CORRUPT_BKPT; + } + next = get2byte(&data[pc]); + size = get2byte(&data[pc+2]); + if( next>0 && next<=pc+size+3 ){ + /* Free blocks must be in accending order */ + return SQLITE_CORRUPT_BKPT; + } + nFree += size; + pc = next; + } + pPage->nFree = nFree; + if( nFree>=usableSize ){ + /* Free space cannot exceed total page size */ + return SQLITE_CORRUPT_BKPT; + } + + pPage->isInit = 1; + return SQLITE_OK; +} + +/* +** Set up a raw page so that it looks like a database page holding +** no entries. +*/ +static void zeroPage(MemPage *pPage, int flags){ + unsigned char *data = pPage->aData; + BtShared *pBt = pPage->pBt; + int hdr = pPage->hdrOffset; + int first; + + assert( sqlite3PagerPagenumber(pPage->pDbPage)==pPage->pgno ); + assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage ); + assert( sqlite3PagerGetData(pPage->pDbPage) == data ); + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); + assert( sqlite3_mutex_held(pBt->mutex) ); + memset(&data[hdr], 0, pBt->usableSize - hdr); + data[hdr] = flags; + first = hdr + 8 + 4*((flags&PTF_LEAF)==0); + memset(&data[hdr+1], 0, 4); + data[hdr+7] = 0; + put2byte(&data[hdr+5], pBt->usableSize); + pPage->nFree = pBt->usableSize - first; + decodeFlags(pPage, flags); + pPage->hdrOffset = hdr; + pPage->cellOffset = first; + pPage->nOverflow = 0; + pPage->idxShift = 0; + pPage->nCell = 0; + pPage->isInit = 1; +} + +/* +** Get a page from the pager. Initialize the MemPage.pBt and +** MemPage.aData elements if needed. +** +** If the noContent flag is set, it means that we do not care about +** the content of the page at this time. So do not go to the disk +** to fetch the content. Just fill in the content with zeros for now. +** If in the future we call sqlite3PagerWrite() on this page, that +** means we have started to be concerned about content and the disk +** read should occur at that point. +*/ +int sqlite3BtreeGetPage( + BtShared *pBt, /* The btree */ + Pgno pgno, /* Number of the page to fetch */ + MemPage **ppPage, /* Return the page in this parameter */ + int noContent /* Do not load page content if true */ +){ + int rc; + MemPage *pPage; + DbPage *pDbPage; + + assert( sqlite3_mutex_held(pBt->mutex) ); + rc = sqlite3PagerAcquire(pBt->pPager, pgno, (DbPage**)&pDbPage, noContent); + if( rc ) return rc; + pPage = (MemPage *)sqlite3PagerGetExtra(pDbPage); + pPage->aData = (u8*)sqlite3PagerGetData(pDbPage); + pPage->pDbPage = pDbPage; + pPage->pBt = pBt; + pPage->pgno = pgno; + pPage->hdrOffset = pPage->pgno==1 ? 100 : 0; + *ppPage = pPage; + return SQLITE_OK; +} + +/* +** Get a page from the pager and initialize it. This routine +** is just a convenience wrapper around separate calls to +** sqlite3BtreeGetPage() and sqlite3BtreeInitPage(). +*/ +static int getAndInitPage( + BtShared *pBt, /* The database file */ + Pgno pgno, /* Number of the page to get */ + MemPage **ppPage, /* Write the page pointer here */ + MemPage *pParent /* Parent of the page */ +){ + int rc; + assert( sqlite3_mutex_held(pBt->mutex) ); + if( pgno==0 ){ + return SQLITE_CORRUPT_BKPT; + } + rc = sqlite3BtreeGetPage(pBt, pgno, ppPage, 0); + if( rc==SQLITE_OK && (*ppPage)->isInit==0 ){ + rc = sqlite3BtreeInitPage(*ppPage, pParent); + } + return rc; +} + +/* +** Release a MemPage. This should be called once for each prior +** call to sqlite3BtreeGetPage. +*/ +static void releasePage(MemPage *pPage){ + if( pPage ){ + assert( pPage->aData ); + assert( pPage->pBt ); + assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage ); + assert( sqlite3PagerGetData(pPage->pDbPage)==pPage->aData ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + sqlite3PagerUnref(pPage->pDbPage); + } +} + +/* +** This routine is called when the reference count for a page +** reaches zero. We need to unref the pParent pointer when that +** happens. +*/ +static void pageDestructor(DbPage *pData, int pageSize){ + MemPage *pPage; + assert( (pageSize & 7)==0 ); + pPage = (MemPage *)sqlite3PagerGetExtra(pData); + assert( pPage->isInit==0 || sqlite3_mutex_held(pPage->pBt->mutex) ); + if( pPage->pParent ){ + MemPage *pParent = pPage->pParent; + assert( pParent->pBt==pPage->pBt ); + pPage->pParent = 0; + releasePage(pParent); + } + pPage->isInit = 0; +} + +/* +** During a rollback, when the pager reloads information into the cache +** so that the cache is restored to its original state at the start of +** the transaction, for each page restored this routine is called. +** +** This routine needs to reset the extra data section at the end of the +** page to agree with the restored data. +*/ +static void pageReinit(DbPage *pData, int pageSize){ + MemPage *pPage; + assert( (pageSize & 7)==0 ); + pPage = (MemPage *)sqlite3PagerGetExtra(pData); + if( pPage->isInit ){ + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + pPage->isInit = 0; + sqlite3BtreeInitPage(pPage, pPage->pParent); + } +} + +/* +** Invoke the busy handler for a btree. +*/ +static int sqlite3BtreeInvokeBusyHandler(void *pArg, int n){ + BtShared *pBt = (BtShared*)pArg; + assert( pBt->db ); + assert( sqlite3_mutex_held(pBt->db->mutex) ); + return sqlite3InvokeBusyHandler(&pBt->db->busyHandler); +} + +/* +** Open a database file. +** +** zFilename is the name of the database file. If zFilename is NULL +** a new database with a random name is created. This randomly named +** database file will be deleted when sqlite3BtreeClose() is called. +** If zFilename is ":memory:" then an in-memory database is created +** that is automatically destroyed when it is closed. +*/ +int sqlite3BtreeOpen( + const char *zFilename, /* Name of the file containing the BTree database */ + sqlite3 *db, /* Associated database handle */ + Btree **ppBtree, /* Pointer to new Btree object written here */ + int flags, /* Options */ + int vfsFlags /* Flags passed through to sqlite3_vfs.xOpen() */ +){ + sqlite3_vfs *pVfs; /* The VFS to use for this btree */ + BtShared *pBt = 0; /* Shared part of btree structure */ + Btree *p; /* Handle to return */ + int rc = SQLITE_OK; + int nReserve; + unsigned char zDbHeader[100]; + + /* Set the variable isMemdb to true for an in-memory database, or + ** false for a file-based database. This symbol is only required if + ** either of the shared-data or autovacuum features are compiled + ** into the library. + */ +#if !defined(SQLITE_OMIT_SHARED_CACHE) || !defined(SQLITE_OMIT_AUTOVACUUM) + #ifdef SQLITE_OMIT_MEMORYDB + const int isMemdb = 0; + #else + const int isMemdb = zFilename && !strcmp(zFilename, ":memory:"); + #endif +#endif + + assert( db!=0 ); + assert( sqlite3_mutex_held(db->mutex) ); + + pVfs = db->pVfs; + p = (Btree*)sqlite3MallocZero(sizeof(Btree)); + if( !p ){ + return SQLITE_NOMEM; + } + p->inTrans = TRANS_NONE; + p->db = db; +#if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO) + /* + ** If this Btree is a candidate for shared cache, try to find an + ** existing BtShared object that we can share with + */ + + if( (flags & BTREE_PRIVATE)==0 + && isMemdb==0 + && (db->flags & SQLITE_Vtab)==0 + && zFilename && zFilename[0] + ){ + if( sqlite3SharedCacheEnabled ){ + int nFullPathname = pVfs->mxPathname+1; + + char *zFullPathname = (char *)sqlite3_malloc(nFullPathname); + + sqlite3_mutex *mutexShared; + p->sharable = 1; + if( db ){ + db->flags |= SQLITE_SharedCache; + } + if( !zFullPathname ){ + sqlite3_free(p); + return SQLITE_NOMEM; + } + + sqlite3OsFullPathname(pVfs, zFilename, nFullPathname, zFullPathname); + mutexShared = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER); + sqlite3_mutex_enter(mutexShared); + for(pBt=sqlite3SharedCacheList; pBt; pBt=pBt->pNext){ + assert( pBt->nRef>0 ); + if( 0==strcmp(zFullPathname, sqlite3PagerFilename(pBt->pPager)) + && sqlite3PagerVfs(pBt->pPager)==pVfs ){ + p->pBt = pBt; + pBt->nRef++; + break; + } + } + sqlite3_mutex_leave(mutexShared); + sqlite3_free(zFullPathname); + } +#ifdef SQLITE_DEBUG + else{ + /* In debug mode, we mark all persistent databases as sharable + ** even when they are not. This exercises the locking code and + ** gives more opportunity for asserts(sqlite3_mutex_held()) + ** statements to find locking problems. + */ + p->sharable = 1; + } +#endif + } +#endif + + if( pBt==0 ){ + + /* + ** The following asserts make sure that structures used by the btree are + ** the right size. This is to guard against size changes that result + ** when compiling on a different architecture. + */ + assert( sizeof(i64)==8 || sizeof(i64)==4 ); + assert( sizeof(u64)==8 || sizeof(u64)==4 ); + assert( sizeof(u32)==4 ); + assert( sizeof(u16)==2 ); + assert( sizeof(Pgno)==4 ); + + pBt = (BtShared*)sqlite3MallocZero( sizeof(*pBt) ); + if( pBt==0 ){ + rc = SQLITE_NOMEM; + goto btree_open_out; + } + pBt->busyHdr.xFunc = sqlite3BtreeInvokeBusyHandler; + pBt->busyHdr.pArg = pBt; + + + rc = sqlite3PagerOpen(pVfs, &pBt->pPager, zFilename, + EXTRA_SIZE, flags, vfsFlags); + if( rc==SQLITE_OK ){ + rc = sqlite3PagerReadFileheader(pBt->pPager,sizeof(zDbHeader),zDbHeader); + } + if( rc!=SQLITE_OK ){ + goto btree_open_out; + } + + sqlite3PagerSetBusyhandler(pBt->pPager, &pBt->busyHdr); + p->pBt = pBt; + + sqlite3PagerSetDestructor(pBt->pPager, pageDestructor); + sqlite3PagerSetReiniter(pBt->pPager, pageReinit); + pBt->pCursor = 0; + pBt->pPage1 = 0; + pBt->readOnly = sqlite3PagerIsreadonly(pBt->pPager); + pBt->pageSize = get2byte(&zDbHeader[16]); + if( pBt->pageSize<512 || pBt->pageSize>SQLITE_MAX_PAGE_SIZE + || ((pBt->pageSize-1)&pBt->pageSize)!=0 ){ + pBt->pageSize = 0; + sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize); + pBt->maxEmbedFrac = 64; /* 25% */ + pBt->minEmbedFrac = 32; /* 12.5% */ + pBt->minLeafFrac = 32; /* 12.5% */ +#ifndef SQLITE_OMIT_AUTOVACUUM + /* If the magic name ":memory:" will create an in-memory database, then + ** leave the autoVacuum mode at 0 (do not auto-vacuum), even if + ** SQLITE_DEFAULT_AUTOVACUUM is true. On the other hand, if + ** SQLITE_OMIT_MEMORYDB has been defined, then ":memory:" is just a + ** regular file-name. In this case the auto-vacuum applies as per normal. + */ + if( zFilename && !isMemdb ){ + pBt->autoVacuum = (SQLITE_DEFAULT_AUTOVACUUM ? 1 : 0); + pBt->incrVacuum = (SQLITE_DEFAULT_AUTOVACUUM==2 ? 1 : 0); + } +#endif + nReserve = 0; + }else{ + nReserve = zDbHeader[20]; + pBt->maxEmbedFrac = zDbHeader[21]; + pBt->minEmbedFrac = zDbHeader[22]; + pBt->minLeafFrac = zDbHeader[23]; + pBt->pageSizeFixed = 1; +#ifndef SQLITE_OMIT_AUTOVACUUM + pBt->autoVacuum = (get4byte(&zDbHeader[36 + 4*4])?1:0); + pBt->incrVacuum = (get4byte(&zDbHeader[36 + 7*4])?1:0); +#endif + } + pBt->usableSize = pBt->pageSize - nReserve; + assert( (pBt->pageSize & 7)==0 ); /* 8-byte alignment of pageSize */ + sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize); + +#if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO) + /* Add the new BtShared object to the linked list sharable BtShareds. + */ + if( p->sharable ){ + sqlite3_mutex *mutexShared; + pBt->nRef = 1; + mutexShared = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER); + if( SQLITE_THREADSAFE ){ + pBt->mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST); + if( pBt->mutex==0 ){ + rc = SQLITE_NOMEM; + db->mallocFailed = 0; + goto btree_open_out; + } + } + sqlite3_mutex_enter(mutexShared); + pBt->pNext = sqlite3SharedCacheList; + sqlite3SharedCacheList = pBt; + sqlite3_mutex_leave(mutexShared); + } +#endif + } + +#if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO) + /* If the new Btree uses a sharable pBtShared, then link the new + ** Btree into the list of all sharable Btrees for the same connection. + ** The list is kept in ascending order by pBt address. + */ + if( p->sharable ){ + int i; + Btree *pSib; + for(i=0; inDb; i++){ + if( (pSib = db->aDb[i].pBt)!=0 && pSib->sharable ){ + while( pSib->pPrev ){ pSib = pSib->pPrev; } + if( p->pBtpBt ){ + p->pNext = pSib; + p->pPrev = 0; + pSib->pPrev = p; + }else{ + while( pSib->pNext && pSib->pNext->pBtpBt ){ + pSib = pSib->pNext; + } + p->pNext = pSib->pNext; + p->pPrev = pSib; + if( p->pNext ){ + p->pNext->pPrev = p; + } + pSib->pNext = p; + } + break; + } + } + } +#endif + *ppBtree = p; + +btree_open_out: + if( rc!=SQLITE_OK ){ + if( pBt && pBt->pPager ){ + sqlite3PagerClose(pBt->pPager); + } + sqlite3_free(pBt); + sqlite3_free(p); + *ppBtree = 0; + } + return rc; +} + +/* +** Decrement the BtShared.nRef counter. When it reaches zero, +** remove the BtShared structure from the sharing list. Return +** true if the BtShared.nRef counter reaches zero and return +** false if it is still positive. +*/ +static int removeFromSharingList(BtShared *pBt){ +#ifndef SQLITE_OMIT_SHARED_CACHE + sqlite3_mutex *pMaster; + BtShared *pList; + int removed = 0; + + assert( sqlite3_mutex_notheld(pBt->mutex) ); + pMaster = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER); + sqlite3_mutex_enter(pMaster); + pBt->nRef--; + if( pBt->nRef<=0 ){ + if( sqlite3SharedCacheList==pBt ){ + sqlite3SharedCacheList = pBt->pNext; + }else{ + pList = sqlite3SharedCacheList; + while( pList && pList->pNext!=pBt ){ + pList=pList->pNext; + } + if( pList ){ + pList->pNext = pBt->pNext; + } + } + if( SQLITE_THREADSAFE ){ + sqlite3_mutex_free(pBt->mutex); + } + removed = 1; + } + sqlite3_mutex_leave(pMaster); + return removed; +#else + return 1; +#endif +} + +/* +** Close an open database and invalidate all cursors. +*/ +int sqlite3BtreeClose(Btree *p){ + BtShared *pBt = p->pBt; + BtCursor *pCur; + + /* Close all cursors opened via this handle. */ + assert( sqlite3_mutex_held(p->db->mutex) ); + sqlite3BtreeEnter(p); + pBt->db = p->db; + pCur = pBt->pCursor; + while( pCur ){ + BtCursor *pTmp = pCur; + pCur = pCur->pNext; + if( pTmp->pBtree==p ){ + sqlite3BtreeCloseCursor(pTmp); + } + } + + /* Rollback any active transaction and free the handle structure. + ** The call to sqlite3BtreeRollback() drops any table-locks held by + ** this handle. + */ + sqlite3BtreeRollback(p); + sqlite3BtreeLeave(p); + + /* If there are still other outstanding references to the shared-btree + ** structure, return now. The remainder of this procedure cleans + ** up the shared-btree. + */ + assert( p->wantToLock==0 && p->locked==0 ); + if( !p->sharable || removeFromSharingList(pBt) ){ + /* The pBt is no longer on the sharing list, so we can access + ** it without having to hold the mutex. + ** + ** Clean out and delete the BtShared object. + */ + assert( !pBt->pCursor ); + sqlite3PagerClose(pBt->pPager); + if( pBt->xFreeSchema && pBt->pSchema ){ + pBt->xFreeSchema(pBt->pSchema); + } + sqlite3_free(pBt->pSchema); + sqlite3_free(pBt); + } + +#ifndef SQLITE_OMIT_SHARED_CACHE + assert( p->wantToLock==0 ); + assert( p->locked==0 ); + if( p->pPrev ) p->pPrev->pNext = p->pNext; + if( p->pNext ) p->pNext->pPrev = p->pPrev; +#endif + + sqlite3_free(p); + return SQLITE_OK; +} + +/* +** Change the limit on the number of pages allowed in the cache. +** +** The maximum number of cache pages is set to the absolute +** value of mxPage. If mxPage is negative, the pager will +** operate asynchronously - it will not stop to do fsync()s +** to insure data is written to the disk surface before +** continuing. Transactions still work if synchronous is off, +** and the database cannot be corrupted if this program +** crashes. But if the operating system crashes or there is +** an abrupt power failure when synchronous is off, the database +** could be left in an inconsistent and unrecoverable state. +** Synchronous is on by default so database corruption is not +** normally a worry. +*/ +int sqlite3BtreeSetCacheSize(Btree *p, int mxPage){ + BtShared *pBt = p->pBt; + assert( sqlite3_mutex_held(p->db->mutex) ); + sqlite3BtreeEnter(p); + sqlite3PagerSetCachesize(pBt->pPager, mxPage); + sqlite3BtreeLeave(p); + return SQLITE_OK; +} + +/* +** Change the way data is synced to disk in order to increase or decrease +** how well the database resists damage due to OS crashes and power +** failures. Level 1 is the same as asynchronous (no syncs() occur and +** there is a high probability of damage) Level 2 is the default. There +** is a very low but non-zero probability of damage. Level 3 reduces the +** probability of damage to near zero but with a write performance reduction. +*/ +#ifndef SQLITE_OMIT_PAGER_PRAGMAS +int sqlite3BtreeSetSafetyLevel(Btree *p, int level, int fullSync){ + BtShared *pBt = p->pBt; + assert( sqlite3_mutex_held(p->db->mutex) ); + sqlite3BtreeEnter(p); + sqlite3PagerSetSafetyLevel(pBt->pPager, level, fullSync); + sqlite3BtreeLeave(p); + return SQLITE_OK; +} +#endif + +/* +** Return TRUE if the given btree is set to safety level 1. In other +** words, return TRUE if no sync() occurs on the disk files. +*/ +int sqlite3BtreeSyncDisabled(Btree *p){ + BtShared *pBt = p->pBt; + int rc; + assert( sqlite3_mutex_held(p->db->mutex) ); + sqlite3BtreeEnter(p); + assert( pBt && pBt->pPager ); + rc = sqlite3PagerNosync(pBt->pPager); + sqlite3BtreeLeave(p); + return rc; +} + +#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) || !defined(SQLITE_OMIT_VACUUM) +/* +** Change the default pages size and the number of reserved bytes per page. +** +** The page size must be a power of 2 between 512 and 65536. If the page +** size supplied does not meet this constraint then the page size is not +** changed. +** +** Page sizes are constrained to be a power of two so that the region +** of the database file used for locking (beginning at PENDING_BYTE, +** the first byte past the 1GB boundary, 0x40000000) needs to occur +** at the beginning of a page. +** +** If parameter nReserve is less than zero, then the number of reserved +** bytes per page is left unchanged. +*/ +int sqlite3BtreeSetPageSize(Btree *p, int pageSize, int nReserve){ + int rc = SQLITE_OK; + BtShared *pBt = p->pBt; + sqlite3BtreeEnter(p); + if( pBt->pageSizeFixed ){ + sqlite3BtreeLeave(p); + return SQLITE_READONLY; + } + if( nReserve<0 ){ + nReserve = pBt->pageSize - pBt->usableSize; + } + if( pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE && + ((pageSize-1)&pageSize)==0 ){ + assert( (pageSize & 7)==0 ); + assert( !pBt->pPage1 && !pBt->pCursor ); + pBt->pageSize = pageSize; + rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize); + } + pBt->usableSize = pBt->pageSize - nReserve; + sqlite3BtreeLeave(p); + return rc; +} + +/* +** Return the currently defined page size +*/ +int sqlite3BtreeGetPageSize(Btree *p){ + return p->pBt->pageSize; +} +int sqlite3BtreeGetReserve(Btree *p){ + int n; + sqlite3BtreeEnter(p); + n = p->pBt->pageSize - p->pBt->usableSize; + sqlite3BtreeLeave(p); + return n; +} + +/* +** Set the maximum page count for a database if mxPage is positive. +** No changes are made if mxPage is 0 or negative. +** Regardless of the value of mxPage, return the maximum page count. +*/ +int sqlite3BtreeMaxPageCount(Btree *p, int mxPage){ + int n; + sqlite3BtreeEnter(p); + n = sqlite3PagerMaxPageCount(p->pBt->pPager, mxPage); + sqlite3BtreeLeave(p); + return n; +} +#endif /* !defined(SQLITE_OMIT_PAGER_PRAGMAS) || !defined(SQLITE_OMIT_VACUUM) */ + +/* +** Change the 'auto-vacuum' property of the database. If the 'autoVacuum' +** parameter is non-zero, then auto-vacuum mode is enabled. If zero, it +** is disabled. The default value for the auto-vacuum property is +** determined by the SQLITE_DEFAULT_AUTOVACUUM macro. +*/ +int sqlite3BtreeSetAutoVacuum(Btree *p, int autoVacuum){ +#ifdef SQLITE_OMIT_AUTOVACUUM + return SQLITE_READONLY; +#else + BtShared *pBt = p->pBt; + int rc = SQLITE_OK; + int av = (autoVacuum?1:0); + + sqlite3BtreeEnter(p); + if( pBt->pageSizeFixed && av!=pBt->autoVacuum ){ + rc = SQLITE_READONLY; + }else{ + pBt->autoVacuum = av; + } + sqlite3BtreeLeave(p); + return rc; +#endif +} + +/* +** Return the value of the 'auto-vacuum' property. If auto-vacuum is +** enabled 1 is returned. Otherwise 0. +*/ +int sqlite3BtreeGetAutoVacuum(Btree *p){ +#ifdef SQLITE_OMIT_AUTOVACUUM + return BTREE_AUTOVACUUM_NONE; +#else + int rc; + sqlite3BtreeEnter(p); + rc = ( + (!p->pBt->autoVacuum)?BTREE_AUTOVACUUM_NONE: + (!p->pBt->incrVacuum)?BTREE_AUTOVACUUM_FULL: + BTREE_AUTOVACUUM_INCR + ); + sqlite3BtreeLeave(p); + return rc; +#endif +} + + +/* +** Get a reference to pPage1 of the database file. This will +** also acquire a readlock on that file. +** +** SQLITE_OK is returned on success. If the file is not a +** well-formed database file, then SQLITE_CORRUPT is returned. +** SQLITE_BUSY is returned if the database is locked. SQLITE_NOMEM +** is returned if we run out of memory. +*/ +static int lockBtree(BtShared *pBt){ + int rc, pageSize; + MemPage *pPage1; + + assert( sqlite3_mutex_held(pBt->mutex) ); + if( pBt->pPage1 ) return SQLITE_OK; + rc = sqlite3BtreeGetPage(pBt, 1, &pPage1, 0); + if( rc!=SQLITE_OK ) return rc; + + + /* Do some checking to help insure the file we opened really is + ** a valid database file. + */ + rc = SQLITE_NOTADB; + if( sqlite3PagerPagecount(pBt->pPager)>0 ){ + u8 *page1 = pPage1->aData; + if( memcmp(page1, zMagicHeader, 16)!=0 ){ + goto page1_init_failed; + } + if( page1[18]>1 ){ + pBt->readOnly = 1; + } + if( page1[19]>1 ){ + goto page1_init_failed; + } + pageSize = get2byte(&page1[16]); + if( ((pageSize-1)&pageSize)!=0 || pageSize<512 || + (SQLITE_MAX_PAGE_SIZE<32768 && pageSize>SQLITE_MAX_PAGE_SIZE) + ){ + goto page1_init_failed; + } + assert( (pageSize & 7)==0 ); + pBt->pageSize = pageSize; + pBt->usableSize = pageSize - page1[20]; + if( pBt->usableSize<500 ){ + goto page1_init_failed; + } + pBt->maxEmbedFrac = page1[21]; + pBt->minEmbedFrac = page1[22]; + pBt->minLeafFrac = page1[23]; +#ifndef SQLITE_OMIT_AUTOVACUUM + pBt->autoVacuum = (get4byte(&page1[36 + 4*4])?1:0); + pBt->incrVacuum = (get4byte(&page1[36 + 7*4])?1:0); +#endif + } + + /* maxLocal is the maximum amount of payload to store locally for + ** a cell. Make sure it is small enough so that at least minFanout + ** cells can will fit on one page. We assume a 10-byte page header. + ** Besides the payload, the cell must store: + ** 2-byte pointer to the cell + ** 4-byte child pointer + ** 9-byte nKey value + ** 4-byte nData value + ** 4-byte overflow page pointer + ** So a cell consists of a 2-byte poiner, a header which is as much as + ** 17 bytes long, 0 to N bytes of payload, and an optional 4 byte overflow + ** page pointer. + */ + pBt->maxLocal = (pBt->usableSize-12)*pBt->maxEmbedFrac/255 - 23; + pBt->minLocal = (pBt->usableSize-12)*pBt->minEmbedFrac/255 - 23; + pBt->maxLeaf = pBt->usableSize - 35; + pBt->minLeaf = (pBt->usableSize-12)*pBt->minLeafFrac/255 - 23; + if( pBt->minLocal>pBt->maxLocal || pBt->maxLocal<0 ){ + goto page1_init_failed; + } + assert( pBt->maxLeaf + 23 <= MX_CELL_SIZE(pBt) ); + pBt->pPage1 = pPage1; + return SQLITE_OK; + +page1_init_failed: + releasePage(pPage1); + pBt->pPage1 = 0; + return rc; +} + +/* +** This routine works like lockBtree() except that it also invokes the +** busy callback if there is lock contention. +*/ +static int lockBtreeWithRetry(Btree *pRef){ + int rc = SQLITE_OK; + + assert( sqlite3BtreeHoldsMutex(pRef) ); + if( pRef->inTrans==TRANS_NONE ){ + u8 inTransaction = pRef->pBt->inTransaction; + btreeIntegrity(pRef); + rc = sqlite3BtreeBeginTrans(pRef, 0); + pRef->pBt->inTransaction = inTransaction; + pRef->inTrans = TRANS_NONE; + if( rc==SQLITE_OK ){ + pRef->pBt->nTransaction--; + } + btreeIntegrity(pRef); + } + return rc; +} + + +/* +** If there are no outstanding cursors and we are not in the middle +** of a transaction but there is a read lock on the database, then +** this routine unrefs the first page of the database file which +** has the effect of releasing the read lock. +** +** If there are any outstanding cursors, this routine is a no-op. +** +** If there is a transaction in progress, this routine is a no-op. +*/ +static void unlockBtreeIfUnused(BtShared *pBt){ + assert( sqlite3_mutex_held(pBt->mutex) ); + if( pBt->inTransaction==TRANS_NONE && pBt->pCursor==0 && pBt->pPage1!=0 ){ + if( sqlite3PagerRefcount(pBt->pPager)>=1 ){ + if( pBt->pPage1->aData==0 ){ + MemPage *pPage = pBt->pPage1; + pPage->aData = (u8*)sqlite3PagerGetData(pPage->pDbPage); + pPage->pBt = pBt; + pPage->pgno = 1; + } + releasePage(pBt->pPage1); + } + pBt->pPage1 = 0; + pBt->inStmt = 0; + } +} + +/* +** Create a new database by initializing the first page of the +** file. +*/ +static int newDatabase(BtShared *pBt){ + MemPage *pP1; + unsigned char *data; + int rc; + + assert( sqlite3_mutex_held(pBt->mutex) ); + if( sqlite3PagerPagecount(pBt->pPager)>0 ) return SQLITE_OK; + pP1 = pBt->pPage1; + assert( pP1!=0 ); + data = pP1->aData; + rc = sqlite3PagerWrite(pP1->pDbPage); + if( rc ) return rc; + memcpy(data, zMagicHeader, sizeof(zMagicHeader)); + assert( sizeof(zMagicHeader)==16 ); + put2byte(&data[16], pBt->pageSize); + data[18] = 1; + data[19] = 1; + data[20] = pBt->pageSize - pBt->usableSize; + data[21] = pBt->maxEmbedFrac; + data[22] = pBt->minEmbedFrac; + data[23] = pBt->minLeafFrac; + memset(&data[24], 0, 100-24); + zeroPage(pP1, PTF_INTKEY|PTF_LEAF|PTF_LEAFDATA ); + pBt->pageSizeFixed = 1; +#ifndef SQLITE_OMIT_AUTOVACUUM + assert( pBt->autoVacuum==1 || pBt->autoVacuum==0 ); + assert( pBt->incrVacuum==1 || pBt->incrVacuum==0 ); + put4byte(&data[36 + 4*4], pBt->autoVacuum); + put4byte(&data[36 + 7*4], pBt->incrVacuum); +#endif + return SQLITE_OK; +} + +/* +** Attempt to start a new transaction. A write-transaction +** is started if the second argument is nonzero, otherwise a read- +** transaction. If the second argument is 2 or more and exclusive +** transaction is started, meaning that no other process is allowed +** to access the database. A preexisting transaction may not be +** upgraded to exclusive by calling this routine a second time - the +** exclusivity flag only works for a new transaction. +** +** A write-transaction must be started before attempting any +** changes to the database. None of the following routines +** will work unless a transaction is started first: +** +** sqlite3BtreeCreateTable() +** sqlite3BtreeCreateIndex() +** sqlite3BtreeClearTable() +** sqlite3BtreeDropTable() +** sqlite3BtreeInsert() +** sqlite3BtreeDelete() +** sqlite3BtreeUpdateMeta() +** +** If an initial attempt to acquire the lock fails because of lock contention +** and the database was previously unlocked, then invoke the busy handler +** if there is one. But if there was previously a read-lock, do not +** invoke the busy handler - just return SQLITE_BUSY. SQLITE_BUSY is +** returned when there is already a read-lock in order to avoid a deadlock. +** +** Suppose there are two processes A and B. A has a read lock and B has +** a reserved lock. B tries to promote to exclusive but is blocked because +** of A's read lock. A tries to promote to reserved but is blocked by B. +** One or the other of the two processes must give way or there can be +** no progress. By returning SQLITE_BUSY and not invoking the busy callback +** when A already has a read lock, we encourage A to give up and let B +** proceed. +*/ +int sqlite3BtreeBeginTrans(Btree *p, int wrflag){ + BtShared *pBt = p->pBt; + int rc = SQLITE_OK; + + sqlite3BtreeEnter(p); + pBt->db = p->db; + btreeIntegrity(p); + + /* If the btree is already in a write-transaction, or it + ** is already in a read-transaction and a read-transaction + ** is requested, this is a no-op. + */ + if( p->inTrans==TRANS_WRITE || (p->inTrans==TRANS_READ && !wrflag) ){ + goto trans_begun; + } + + /* Write transactions are not possible on a read-only database */ + if( pBt->readOnly && wrflag ){ + rc = SQLITE_READONLY; + goto trans_begun; + } + + /* If another database handle has already opened a write transaction + ** on this shared-btree structure and a second write transaction is + ** requested, return SQLITE_BUSY. + */ + if( pBt->inTransaction==TRANS_WRITE && wrflag ){ + rc = SQLITE_BUSY; + goto trans_begun; + } + + do { + if( pBt->pPage1==0 ){ + rc = lockBtree(pBt); + } + + if( rc==SQLITE_OK && wrflag ){ + if( pBt->readOnly ){ + rc = SQLITE_READONLY; + }else{ + rc = sqlite3PagerBegin(pBt->pPage1->pDbPage, wrflag>1); + if( rc==SQLITE_OK ){ + rc = newDatabase(pBt); + } + } + } + + if( rc==SQLITE_OK ){ + if( wrflag ) pBt->inStmt = 0; + }else{ + unlockBtreeIfUnused(pBt); + } + }while( rc==SQLITE_BUSY && pBt->inTransaction==TRANS_NONE && + sqlite3BtreeInvokeBusyHandler(pBt, 0) ); + + if( rc==SQLITE_OK ){ + if( p->inTrans==TRANS_NONE ){ + pBt->nTransaction++; + } + p->inTrans = (wrflag?TRANS_WRITE:TRANS_READ); + if( p->inTrans>pBt->inTransaction ){ + pBt->inTransaction = p->inTrans; + } + } + + +trans_begun: + btreeIntegrity(p); + sqlite3BtreeLeave(p); + return rc; +} + +#ifndef SQLITE_OMIT_AUTOVACUUM + +/* +** Set the pointer-map entries for all children of page pPage. Also, if +** pPage contains cells that point to overflow pages, set the pointer +** map entries for the overflow pages as well. +*/ +static int setChildPtrmaps(MemPage *pPage){ + int i; /* Counter variable */ + int nCell; /* Number of cells in page pPage */ + int rc; /* Return code */ + BtShared *pBt = pPage->pBt; + int isInitOrig = pPage->isInit; + Pgno pgno = pPage->pgno; + + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + rc = sqlite3BtreeInitPage(pPage, pPage->pParent); + if( rc!=SQLITE_OK ){ + goto set_child_ptrmaps_out; + } + nCell = pPage->nCell; + + for(i=0; ileaf ){ + Pgno childPgno = get4byte(pCell); + rc = ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno); + if( rc!=SQLITE_OK ) goto set_child_ptrmaps_out; + } + } + + if( !pPage->leaf ){ + Pgno childPgno = get4byte(&pPage->aData[pPage->hdrOffset+8]); + rc = ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno); + } + +set_child_ptrmaps_out: + pPage->isInit = isInitOrig; + return rc; +} + +/* +** Somewhere on pPage, which is guarenteed to be a btree page, not an overflow +** page, is a pointer to page iFrom. Modify this pointer so that it points to +** iTo. Parameter eType describes the type of pointer to be modified, as +** follows: +** +** PTRMAP_BTREE: pPage is a btree-page. The pointer points at a child +** page of pPage. +** +** PTRMAP_OVERFLOW1: pPage is a btree-page. The pointer points at an overflow +** page pointed to by one of the cells on pPage. +** +** PTRMAP_OVERFLOW2: pPage is an overflow-page. The pointer points at the next +** overflow page in the list. +*/ +static int modifyPagePointer(MemPage *pPage, Pgno iFrom, Pgno iTo, u8 eType){ + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + if( eType==PTRMAP_OVERFLOW2 ){ + /* The pointer is always the first 4 bytes of the page in this case. */ + if( get4byte(pPage->aData)!=iFrom ){ + return SQLITE_CORRUPT_BKPT; + } + put4byte(pPage->aData, iTo); + }else{ + int isInitOrig = pPage->isInit; + int i; + int nCell; + + sqlite3BtreeInitPage(pPage, 0); + nCell = pPage->nCell; + + for(i=0; iaData[pPage->hdrOffset+8])!=iFrom ){ + return SQLITE_CORRUPT_BKPT; + } + put4byte(&pPage->aData[pPage->hdrOffset+8], iTo); + } + + pPage->isInit = isInitOrig; + } + return SQLITE_OK; +} + + +/* +** Move the open database page pDbPage to location iFreePage in the +** database. The pDbPage reference remains valid. +*/ +static int relocatePage( + BtShared *pBt, /* Btree */ + MemPage *pDbPage, /* Open page to move */ + u8 eType, /* Pointer map 'type' entry for pDbPage */ + Pgno iPtrPage, /* Pointer map 'page-no' entry for pDbPage */ + Pgno iFreePage /* The location to move pDbPage to */ +){ + MemPage *pPtrPage; /* The page that contains a pointer to pDbPage */ + Pgno iDbPage = pDbPage->pgno; + Pager *pPager = pBt->pPager; + int rc; + + assert( eType==PTRMAP_OVERFLOW2 || eType==PTRMAP_OVERFLOW1 || + eType==PTRMAP_BTREE || eType==PTRMAP_ROOTPAGE ); + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( pDbPage->pBt==pBt ); + + /* Move page iDbPage from its current location to page number iFreePage */ + TRACE(("AUTOVACUUM: Moving %d to free page %d (ptr page %d type %d)\n", + iDbPage, iFreePage, iPtrPage, eType)); + rc = sqlite3PagerMovepage(pPager, pDbPage->pDbPage, iFreePage); + if( rc!=SQLITE_OK ){ + return rc; + } + pDbPage->pgno = iFreePage; + + /* If pDbPage was a btree-page, then it may have child pages and/or cells + ** that point to overflow pages. The pointer map entries for all these + ** pages need to be changed. + ** + ** If pDbPage is an overflow page, then the first 4 bytes may store a + ** pointer to a subsequent overflow page. If this is the case, then + ** the pointer map needs to be updated for the subsequent overflow page. + */ + if( eType==PTRMAP_BTREE || eType==PTRMAP_ROOTPAGE ){ + rc = setChildPtrmaps(pDbPage); + if( rc!=SQLITE_OK ){ + return rc; + } + }else{ + Pgno nextOvfl = get4byte(pDbPage->aData); + if( nextOvfl!=0 ){ + rc = ptrmapPut(pBt, nextOvfl, PTRMAP_OVERFLOW2, iFreePage); + if( rc!=SQLITE_OK ){ + return rc; + } + } + } + + /* Fix the database pointer on page iPtrPage that pointed at iDbPage so + ** that it points at iFreePage. Also fix the pointer map entry for + ** iPtrPage. + */ + if( eType!=PTRMAP_ROOTPAGE ){ + rc = sqlite3BtreeGetPage(pBt, iPtrPage, &pPtrPage, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + rc = sqlite3PagerWrite(pPtrPage->pDbPage); + if( rc!=SQLITE_OK ){ + releasePage(pPtrPage); + return rc; + } + rc = modifyPagePointer(pPtrPage, iDbPage, iFreePage, eType); + releasePage(pPtrPage); + if( rc==SQLITE_OK ){ + rc = ptrmapPut(pBt, iFreePage, eType, iPtrPage); + } + } + return rc; +} + +/* Forward declaration required by incrVacuumStep(). */ +static int allocateBtreePage(BtShared *, MemPage **, Pgno *, Pgno, u8); + +/* +** Perform a single step of an incremental-vacuum. If successful, +** return SQLITE_OK. If there is no work to do (and therefore no +** point in calling this function again), return SQLITE_DONE. +** +** More specificly, this function attempts to re-organize the +** database so that the last page of the file currently in use +** is no longer in use. +** +** If the nFin parameter is non-zero, the implementation assumes +** that the caller will keep calling incrVacuumStep() until +** it returns SQLITE_DONE or an error, and that nFin is the +** number of pages the database file will contain after this +** process is complete. +*/ +static int incrVacuumStep(BtShared *pBt, Pgno nFin){ + Pgno iLastPg; /* Last page in the database */ + Pgno nFreeList; /* Number of pages still on the free-list */ + + assert( sqlite3_mutex_held(pBt->mutex) ); + iLastPg = pBt->nTrunc; + if( iLastPg==0 ){ + iLastPg = sqlite3PagerPagecount(pBt->pPager); + } + + if( !PTRMAP_ISPAGE(pBt, iLastPg) && iLastPg!=PENDING_BYTE_PAGE(pBt) ){ + int rc; + u8 eType; + Pgno iPtrPage; + + nFreeList = get4byte(&pBt->pPage1->aData[36]); + if( nFreeList==0 || nFin==iLastPg ){ + return SQLITE_DONE; + } + + rc = ptrmapGet(pBt, iLastPg, &eType, &iPtrPage); + if( rc!=SQLITE_OK ){ + return rc; + } + if( eType==PTRMAP_ROOTPAGE ){ + return SQLITE_CORRUPT_BKPT; + } + + if( eType==PTRMAP_FREEPAGE ){ + if( nFin==0 ){ + /* Remove the page from the files free-list. This is not required + ** if nFin is non-zero. In that case, the free-list will be + ** truncated to zero after this function returns, so it doesn't + ** matter if it still contains some garbage entries. + */ + Pgno iFreePg; + MemPage *pFreePg; + rc = allocateBtreePage(pBt, &pFreePg, &iFreePg, iLastPg, 1); + if( rc!=SQLITE_OK ){ + return rc; + } + assert( iFreePg==iLastPg ); + releasePage(pFreePg); + } + } else { + Pgno iFreePg; /* Index of free page to move pLastPg to */ + MemPage *pLastPg; + + rc = sqlite3BtreeGetPage(pBt, iLastPg, &pLastPg, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + + /* If nFin is zero, this loop runs exactly once and page pLastPg + ** is swapped with the first free page pulled off the free list. + ** + ** On the other hand, if nFin is greater than zero, then keep + ** looping until a free-page located within the first nFin pages + ** of the file is found. + */ + do { + MemPage *pFreePg; + rc = allocateBtreePage(pBt, &pFreePg, &iFreePg, 0, 0); + if( rc!=SQLITE_OK ){ + releasePage(pLastPg); + return rc; + } + releasePage(pFreePg); + }while( nFin!=0 && iFreePg>nFin ); + assert( iFreePgpDbPage); + if( rc==SQLITE_OK ){ + rc = relocatePage(pBt, pLastPg, eType, iPtrPage, iFreePg); + } + releasePage(pLastPg); + if( rc!=SQLITE_OK ){ + return rc; + } + } + } + + pBt->nTrunc = iLastPg - 1; + while( pBt->nTrunc==PENDING_BYTE_PAGE(pBt)||PTRMAP_ISPAGE(pBt, pBt->nTrunc) ){ + pBt->nTrunc--; + } + return SQLITE_OK; +} + +/* +** A write-transaction must be opened before calling this function. +** It performs a single unit of work towards an incremental vacuum. +** +** If the incremental vacuum is finished after this function has run, +** SQLITE_DONE is returned. If it is not finished, but no error occured, +** SQLITE_OK is returned. Otherwise an SQLite error code. +*/ +int sqlite3BtreeIncrVacuum(Btree *p){ + int rc; + BtShared *pBt = p->pBt; + + sqlite3BtreeEnter(p); + pBt->db = p->db; + assert( pBt->inTransaction==TRANS_WRITE && p->inTrans==TRANS_WRITE ); + if( !pBt->autoVacuum ){ + rc = SQLITE_DONE; + }else{ + invalidateAllOverflowCache(pBt); + rc = incrVacuumStep(pBt, 0); + } + sqlite3BtreeLeave(p); + return rc; +} + +/* +** This routine is called prior to sqlite3PagerCommit when a transaction +** is commited for an auto-vacuum database. +** +** If SQLITE_OK is returned, then *pnTrunc is set to the number of pages +** the database file should be truncated to during the commit process. +** i.e. the database has been reorganized so that only the first *pnTrunc +** pages are in use. +*/ +static int autoVacuumCommit(BtShared *pBt, Pgno *pnTrunc){ + int rc = SQLITE_OK; + Pager *pPager = pBt->pPager; +#ifndef NDEBUG + int nRef = sqlite3PagerRefcount(pPager); +#endif + + assert( sqlite3_mutex_held(pBt->mutex) ); + invalidateAllOverflowCache(pBt); + assert(pBt->autoVacuum); + if( !pBt->incrVacuum ){ + Pgno nFin = 0; + + if( pBt->nTrunc==0 ){ + Pgno nFree; + Pgno nPtrmap; + const int pgsz = pBt->pageSize; + Pgno nOrig = sqlite3PagerPagecount(pBt->pPager); + + if( PTRMAP_ISPAGE(pBt, nOrig) ){ + return SQLITE_CORRUPT_BKPT; + } + if( nOrig==PENDING_BYTE_PAGE(pBt) ){ + nOrig--; + } + nFree = get4byte(&pBt->pPage1->aData[36]); + nPtrmap = (nFree-nOrig+PTRMAP_PAGENO(pBt, nOrig)+pgsz/5)/(pgsz/5); + nFin = nOrig - nFree - nPtrmap; + if( nOrig>PENDING_BYTE_PAGE(pBt) && nFin<=PENDING_BYTE_PAGE(pBt) ){ + nFin--; + } + while( PTRMAP_ISPAGE(pBt, nFin) || nFin==PENDING_BYTE_PAGE(pBt) ){ + nFin--; + } + } + + while( rc==SQLITE_OK ){ + rc = incrVacuumStep(pBt, nFin); + } + if( rc==SQLITE_DONE ){ + assert(nFin==0 || pBt->nTrunc==0 || nFin<=pBt->nTrunc); + rc = SQLITE_OK; + if( pBt->nTrunc ){ + rc = sqlite3PagerWrite(pBt->pPage1->pDbPage); + put4byte(&pBt->pPage1->aData[32], 0); + put4byte(&pBt->pPage1->aData[36], 0); + pBt->nTrunc = nFin; + } + } + if( rc!=SQLITE_OK ){ + sqlite3PagerRollback(pPager); + } + } + + if( rc==SQLITE_OK ){ + *pnTrunc = pBt->nTrunc; + pBt->nTrunc = 0; + } + assert( nRef==sqlite3PagerRefcount(pPager) ); + return rc; +} + +#endif + +/* +** This routine does the first phase of a two-phase commit. This routine +** causes a rollback journal to be created (if it does not already exist) +** and populated with enough information so that if a power loss occurs +** the database can be restored to its original state by playing back +** the journal. Then the contents of the journal are flushed out to +** the disk. After the journal is safely on oxide, the changes to the +** database are written into the database file and flushed to oxide. +** At the end of this call, the rollback journal still exists on the +** disk and we are still holding all locks, so the transaction has not +** committed. See sqlite3BtreeCommit() for the second phase of the +** commit process. +** +** This call is a no-op if no write-transaction is currently active on pBt. +** +** Otherwise, sync the database file for the btree pBt. zMaster points to +** the name of a master journal file that should be written into the +** individual journal file, or is NULL, indicating no master journal file +** (single database transaction). +** +** When this is called, the master journal should already have been +** created, populated with this journal pointer and synced to disk. +** +** Once this is routine has returned, the only thing required to commit +** the write-transaction for this database file is to delete the journal. +*/ +int sqlite3BtreeCommitPhaseOne(Btree *p, const char *zMaster){ + int rc = SQLITE_OK; + if( p->inTrans==TRANS_WRITE ){ + BtShared *pBt = p->pBt; + Pgno nTrunc = 0; + sqlite3BtreeEnter(p); + pBt->db = p->db; +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum ){ + rc = autoVacuumCommit(pBt, &nTrunc); + if( rc!=SQLITE_OK ){ + sqlite3BtreeLeave(p); + return rc; + } + } +#endif + rc = sqlite3PagerCommitPhaseOne(pBt->pPager, zMaster, nTrunc); + sqlite3BtreeLeave(p); + } + return rc; +} + +/* +** Commit the transaction currently in progress. +** +** This routine implements the second phase of a 2-phase commit. The +** sqlite3BtreeSync() routine does the first phase and should be invoked +** prior to calling this routine. The sqlite3BtreeSync() routine did +** all the work of writing information out to disk and flushing the +** contents so that they are written onto the disk platter. All this +** routine has to do is delete or truncate the rollback journal +** (which causes the transaction to commit) and drop locks. +** +** This will release the write lock on the database file. If there +** are no active cursors, it also releases the read lock. +*/ +int sqlite3BtreeCommitPhaseTwo(Btree *p){ + BtShared *pBt = p->pBt; + + sqlite3BtreeEnter(p); + pBt->db = p->db; + btreeIntegrity(p); + + /* If the handle has a write-transaction open, commit the shared-btrees + ** transaction and set the shared state to TRANS_READ. + */ + if( p->inTrans==TRANS_WRITE ){ + int rc; + assert( pBt->inTransaction==TRANS_WRITE ); + assert( pBt->nTransaction>0 ); + rc = sqlite3PagerCommitPhaseTwo(pBt->pPager); + if( rc!=SQLITE_OK ){ + sqlite3BtreeLeave(p); + return rc; + } + pBt->inTransaction = TRANS_READ; + pBt->inStmt = 0; + } + unlockAllTables(p); + + /* If the handle has any kind of transaction open, decrement the transaction + ** count of the shared btree. If the transaction count reaches 0, set + ** the shared state to TRANS_NONE. The unlockBtreeIfUnused() call below + ** will unlock the pager. + */ + if( p->inTrans!=TRANS_NONE ){ + pBt->nTransaction--; + if( 0==pBt->nTransaction ){ + pBt->inTransaction = TRANS_NONE; + } + } + + /* Set the handles current transaction state to TRANS_NONE and unlock + ** the pager if this call closed the only read or write transaction. + */ + p->inTrans = TRANS_NONE; + unlockBtreeIfUnused(pBt); + + btreeIntegrity(p); + sqlite3BtreeLeave(p); + return SQLITE_OK; +} + +/* +** Do both phases of a commit. +*/ +int sqlite3BtreeCommit(Btree *p){ + int rc; + sqlite3BtreeEnter(p); + rc = sqlite3BtreeCommitPhaseOne(p, 0); + if( rc==SQLITE_OK ){ + rc = sqlite3BtreeCommitPhaseTwo(p); + } + sqlite3BtreeLeave(p); + return rc; +} + +#ifndef NDEBUG +/* +** Return the number of write-cursors open on this handle. This is for use +** in assert() expressions, so it is only compiled if NDEBUG is not +** defined. +** +** For the purposes of this routine, a write-cursor is any cursor that +** is capable of writing to the databse. That means the cursor was +** originally opened for writing and the cursor has not be disabled +** by having its state changed to CURSOR_FAULT. +*/ +static int countWriteCursors(BtShared *pBt){ + BtCursor *pCur; + int r = 0; + for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){ + if( pCur->wrFlag && pCur->eState!=CURSOR_FAULT ) r++; + } + return r; +} +#endif + +/* +** This routine sets the state to CURSOR_FAULT and the error +** code to errCode for every cursor on BtShared that pBtree +** references. +** +** Every cursor is tripped, including cursors that belong +** to other database connections that happen to be sharing +** the cache with pBtree. +** +** This routine gets called when a rollback occurs. +** All cursors using the same cache must be tripped +** to prevent them from trying to use the btree after +** the rollback. The rollback may have deleted tables +** or moved root pages, so it is not sufficient to +** save the state of the cursor. The cursor must be +** invalidated. +*/ +void sqlite3BtreeTripAllCursors(Btree *pBtree, int errCode){ + BtCursor *p; + sqlite3BtreeEnter(pBtree); + for(p=pBtree->pBt->pCursor; p; p=p->pNext){ + clearCursorPosition(p); + p->eState = CURSOR_FAULT; + p->skip = errCode; + } + sqlite3BtreeLeave(pBtree); +} + +/* +** Rollback the transaction in progress. All cursors will be +** invalided by this operation. Any attempt to use a cursor +** that was open at the beginning of this operation will result +** in an error. +** +** This will release the write lock on the database file. If there +** are no active cursors, it also releases the read lock. +*/ +int sqlite3BtreeRollback(Btree *p){ + int rc; + BtShared *pBt = p->pBt; + MemPage *pPage1; + + sqlite3BtreeEnter(p); + pBt->db = p->db; + rc = saveAllCursors(pBt, 0, 0); +#ifndef SQLITE_OMIT_SHARED_CACHE + if( rc!=SQLITE_OK ){ + /* This is a horrible situation. An IO or malloc() error occured whilst + ** trying to save cursor positions. If this is an automatic rollback (as + ** the result of a constraint, malloc() failure or IO error) then + ** the cache may be internally inconsistent (not contain valid trees) so + ** we cannot simply return the error to the caller. Instead, abort + ** all queries that may be using any of the cursors that failed to save. + */ + sqlite3BtreeTripAllCursors(p, rc); + } +#endif + btreeIntegrity(p); + unlockAllTables(p); + + if( p->inTrans==TRANS_WRITE ){ + int rc2; + +#ifndef SQLITE_OMIT_AUTOVACUUM + pBt->nTrunc = 0; +#endif + + assert( TRANS_WRITE==pBt->inTransaction ); + rc2 = sqlite3PagerRollback(pBt->pPager); + if( rc2!=SQLITE_OK ){ + rc = rc2; + } + + /* The rollback may have destroyed the pPage1->aData value. So + ** call sqlite3BtreeGetPage() on page 1 again to make + ** sure pPage1->aData is set correctly. */ + if( sqlite3BtreeGetPage(pBt, 1, &pPage1, 0)==SQLITE_OK ){ + releasePage(pPage1); + } + assert( countWriteCursors(pBt)==0 ); + pBt->inTransaction = TRANS_READ; + } + + if( p->inTrans!=TRANS_NONE ){ + assert( pBt->nTransaction>0 ); + pBt->nTransaction--; + if( 0==pBt->nTransaction ){ + pBt->inTransaction = TRANS_NONE; + } + } + + p->inTrans = TRANS_NONE; + pBt->inStmt = 0; + unlockBtreeIfUnused(pBt); + + btreeIntegrity(p); + sqlite3BtreeLeave(p); + return rc; +} + +/* +** Start a statement subtransaction. The subtransaction can +** can be rolled back independently of the main transaction. +** You must start a transaction before starting a subtransaction. +** The subtransaction is ended automatically if the main transaction +** commits or rolls back. +** +** Only one subtransaction may be active at a time. It is an error to try +** to start a new subtransaction if another subtransaction is already active. +** +** Statement subtransactions are used around individual SQL statements +** that are contained within a BEGIN...COMMIT block. If a constraint +** error occurs within the statement, the effect of that one statement +** can be rolled back without having to rollback the entire transaction. +*/ +int sqlite3BtreeBeginStmt(Btree *p){ + int rc; + BtShared *pBt = p->pBt; + sqlite3BtreeEnter(p); + pBt->db = p->db; + if( (p->inTrans!=TRANS_WRITE) || pBt->inStmt ){ + rc = pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR; + }else{ + assert( pBt->inTransaction==TRANS_WRITE ); + rc = pBt->readOnly ? SQLITE_OK : sqlite3PagerStmtBegin(pBt->pPager); + pBt->inStmt = 1; + } + sqlite3BtreeLeave(p); + return rc; +} + + +/* +** Commit the statment subtransaction currently in progress. If no +** subtransaction is active, this is a no-op. +*/ +int sqlite3BtreeCommitStmt(Btree *p){ + int rc; + BtShared *pBt = p->pBt; + sqlite3BtreeEnter(p); + pBt->db = p->db; + if( pBt->inStmt && !pBt->readOnly ){ + rc = sqlite3PagerStmtCommit(pBt->pPager); + }else{ + rc = SQLITE_OK; + } + pBt->inStmt = 0; + sqlite3BtreeLeave(p); + return rc; +} + +/* +** Rollback the active statement subtransaction. If no subtransaction +** is active this routine is a no-op. +** +** All cursors will be invalidated by this operation. Any attempt +** to use a cursor that was open at the beginning of this operation +** will result in an error. +*/ +int sqlite3BtreeRollbackStmt(Btree *p){ + int rc = SQLITE_OK; + BtShared *pBt = p->pBt; + sqlite3BtreeEnter(p); + pBt->db = p->db; + if( pBt->inStmt && !pBt->readOnly ){ + rc = sqlite3PagerStmtRollback(pBt->pPager); + assert( countWriteCursors(pBt)==0 ); + pBt->inStmt = 0; + } + sqlite3BtreeLeave(p); + return rc; +} + +/* +** Default key comparison function to be used if no comparison function +** is specified on the sqlite3BtreeCursor() call. +*/ +static int dfltCompare( + void *NotUsed, /* User data is not used */ + int n1, const void *p1, /* First key to compare */ + int n2, const void *p2 /* Second key to compare */ +){ + int c; + c = memcmp(p1, p2, n1pBt; + + assert( sqlite3BtreeHoldsMutex(p) ); + *ppCur = 0; + if( wrFlag ){ + if( pBt->readOnly ){ + return SQLITE_READONLY; + } + if( checkReadLocks(p, iTable, 0) ){ + return SQLITE_LOCKED; + } + } + + if( pBt->pPage1==0 ){ + rc = lockBtreeWithRetry(p); + if( rc!=SQLITE_OK ){ + return rc; + } + if( pBt->readOnly && wrFlag ){ + return SQLITE_READONLY; + } + } + pCur = (BtCursor*)sqlite3MallocZero( sizeof(*pCur) ); + if( pCur==0 ){ + rc = SQLITE_NOMEM; + goto create_cursor_exception; + } + pCur->pgnoRoot = (Pgno)iTable; + if( iTable==1 && sqlite3PagerPagecount(pBt->pPager)==0 ){ + rc = SQLITE_EMPTY; + goto create_cursor_exception; + } + rc = getAndInitPage(pBt, pCur->pgnoRoot, &pCur->pPage, 0); + if( rc!=SQLITE_OK ){ + goto create_cursor_exception; + } + + /* Now that no other errors can occur, finish filling in the BtCursor + ** variables, link the cursor into the BtShared list and set *ppCur (the + ** output argument to this function). + */ + pCur->xCompare = xCmp ? xCmp : dfltCompare; + pCur->pArg = pArg; + pCur->pBtree = p; + pCur->pBt = pBt; + pCur->wrFlag = wrFlag; + pCur->pNext = pBt->pCursor; + if( pCur->pNext ){ + pCur->pNext->pPrev = pCur; + } + pBt->pCursor = pCur; + pCur->eState = CURSOR_INVALID; + *ppCur = pCur; + + return SQLITE_OK; + +create_cursor_exception: + if( pCur ){ + releasePage(pCur->pPage); + sqlite3_free(pCur); + } + unlockBtreeIfUnused(pBt); + return rc; +} +int sqlite3BtreeCursor( + Btree *p, /* The btree */ + int iTable, /* Root page of table to open */ + int wrFlag, /* 1 to write. 0 read-only */ + int (*xCmp)(void*,int,const void*,int,const void*), /* Key Comparison func */ + void *pArg, /* First arg to xCompare() */ + BtCursor **ppCur /* Write new cursor here */ +){ + int rc; + sqlite3BtreeEnter(p); + p->pBt->db = p->db; + rc = btreeCursor(p, iTable, wrFlag, xCmp, pArg, ppCur); + sqlite3BtreeLeave(p); + return rc; +} + + +/* +** Close a cursor. The read lock on the database file is released +** when the last cursor is closed. +*/ +int sqlite3BtreeCloseCursor(BtCursor *pCur){ + BtShared *pBt = pCur->pBt; + Btree *pBtree = pCur->pBtree; + + sqlite3BtreeEnter(pBtree); + pBt->db = pBtree->db; + clearCursorPosition(pCur); + if( pCur->pPrev ){ + pCur->pPrev->pNext = pCur->pNext; + }else{ + pBt->pCursor = pCur->pNext; + } + if( pCur->pNext ){ + pCur->pNext->pPrev = pCur->pPrev; + } + releasePage(pCur->pPage); + unlockBtreeIfUnused(pBt); + invalidateOverflowCache(pCur); + sqlite3_free(pCur); + sqlite3BtreeLeave(pBtree); + return SQLITE_OK; +} + +/* +** Make a temporary cursor by filling in the fields of pTempCur. +** The temporary cursor is not on the cursor list for the Btree. +*/ +void sqlite3BtreeGetTempCursor(BtCursor *pCur, BtCursor *pTempCur){ + assert( cursorHoldsMutex(pCur) ); + memcpy(pTempCur, pCur, sizeof(*pCur)); + pTempCur->pNext = 0; + pTempCur->pPrev = 0; + if( pTempCur->pPage ){ + sqlite3PagerRef(pTempCur->pPage->pDbPage); + } +} + +/* +** Delete a temporary cursor such as was made by the CreateTemporaryCursor() +** function above. +*/ +void sqlite3BtreeReleaseTempCursor(BtCursor *pCur){ + assert( cursorHoldsMutex(pCur) ); + if( pCur->pPage ){ + sqlite3PagerUnref(pCur->pPage->pDbPage); + } +} + +/* +** Make sure the BtCursor* given in the argument has a valid +** BtCursor.info structure. If it is not already valid, call +** sqlite3BtreeParseCell() to fill it in. +** +** BtCursor.info is a cache of the information in the current cell. +** Using this cache reduces the number of calls to sqlite3BtreeParseCell(). +** +** 2007-06-25: There is a bug in some versions of MSVC that cause the +** compiler to crash when getCellInfo() is implemented as a macro. +** But there is a measureable speed advantage to using the macro on gcc +** (when less compiler optimizations like -Os or -O0 are used and the +** compiler is not doing agressive inlining.) So we use a real function +** for MSVC and a macro for everything else. Ticket #2457. +*/ +#ifndef NDEBUG + static void assertCellInfo(BtCursor *pCur){ + CellInfo info; + memset(&info, 0, sizeof(info)); + sqlite3BtreeParseCell(pCur->pPage, pCur->idx, &info); + assert( memcmp(&info, &pCur->info, sizeof(info))==0 ); + } +#else + #define assertCellInfo(x) +#endif +#ifdef _MSC_VER + /* Use a real function in MSVC to work around bugs in that compiler. */ + static void getCellInfo(BtCursor *pCur){ + if( pCur->info.nSize==0 ){ + sqlite3BtreeParseCell(pCur->pPage, pCur->idx, &pCur->info); + }else{ + assertCellInfo(pCur); + } + } +#else /* if not _MSC_VER */ + /* Use a macro in all other compilers so that the function is inlined */ +#define getCellInfo(pCur) \ + if( pCur->info.nSize==0 ){ \ + sqlite3BtreeParseCell(pCur->pPage, pCur->idx, &pCur->info); \ + }else{ \ + assertCellInfo(pCur); \ + } +#endif /* _MSC_VER */ + +/* +** Set *pSize to the size of the buffer needed to hold the value of +** the key for the current entry. If the cursor is not pointing +** to a valid entry, *pSize is set to 0. +** +** For a table with the INTKEY flag set, this routine returns the key +** itself, not the number of bytes in the key. +*/ +int sqlite3BtreeKeySize(BtCursor *pCur, i64 *pSize){ + int rc; + + assert( cursorHoldsMutex(pCur) ); + rc = restoreOrClearCursorPosition(pCur); + if( rc==SQLITE_OK ){ + assert( pCur->eState==CURSOR_INVALID || pCur->eState==CURSOR_VALID ); + if( pCur->eState==CURSOR_INVALID ){ + *pSize = 0; + }else{ + getCellInfo(pCur); + *pSize = pCur->info.nKey; + } + } + return rc; +} + +/* +** Set *pSize to the number of bytes of data in the entry the +** cursor currently points to. Always return SQLITE_OK. +** Failure is not possible. If the cursor is not currently +** pointing to an entry (which can happen, for example, if +** the database is empty) then *pSize is set to 0. +*/ +int sqlite3BtreeDataSize(BtCursor *pCur, u32 *pSize){ + int rc; + + assert( cursorHoldsMutex(pCur) ); + rc = restoreOrClearCursorPosition(pCur); + if( rc==SQLITE_OK ){ + assert( pCur->eState==CURSOR_INVALID || pCur->eState==CURSOR_VALID ); + if( pCur->eState==CURSOR_INVALID ){ + /* Not pointing at a valid entry - set *pSize to 0. */ + *pSize = 0; + }else{ + getCellInfo(pCur); + *pSize = pCur->info.nData; + } + } + return rc; +} + +/* +** Given the page number of an overflow page in the database (parameter +** ovfl), this function finds the page number of the next page in the +** linked list of overflow pages. If possible, it uses the auto-vacuum +** pointer-map data instead of reading the content of page ovfl to do so. +** +** If an error occurs an SQLite error code is returned. Otherwise: +** +** Unless pPgnoNext is NULL, the page number of the next overflow +** page in the linked list is written to *pPgnoNext. If page ovfl +** is the last page in its linked list, *pPgnoNext is set to zero. +** +** If ppPage is not NULL, *ppPage is set to the MemPage* handle +** for page ovfl. The underlying pager page may have been requested +** with the noContent flag set, so the page data accessable via +** this handle may not be trusted. +*/ +static int getOverflowPage( + BtShared *pBt, + Pgno ovfl, /* Overflow page */ + MemPage **ppPage, /* OUT: MemPage handle */ + Pgno *pPgnoNext /* OUT: Next overflow page number */ +){ + Pgno next = 0; + int rc; + + assert( sqlite3_mutex_held(pBt->mutex) ); + /* One of these must not be NULL. Otherwise, why call this function? */ + assert(ppPage || pPgnoNext); + + /* If pPgnoNext is NULL, then this function is being called to obtain + ** a MemPage* reference only. No page-data is required in this case. + */ + if( !pPgnoNext ){ + return sqlite3BtreeGetPage(pBt, ovfl, ppPage, 1); + } + +#ifndef SQLITE_OMIT_AUTOVACUUM + /* Try to find the next page in the overflow list using the + ** autovacuum pointer-map pages. Guess that the next page in + ** the overflow list is page number (ovfl+1). If that guess turns + ** out to be wrong, fall back to loading the data of page + ** number ovfl to determine the next page number. + */ + if( pBt->autoVacuum ){ + Pgno pgno; + Pgno iGuess = ovfl+1; + u8 eType; + + while( PTRMAP_ISPAGE(pBt, iGuess) || iGuess==PENDING_BYTE_PAGE(pBt) ){ + iGuess++; + } + + if( iGuess<=sqlite3PagerPagecount(pBt->pPager) ){ + rc = ptrmapGet(pBt, iGuess, &eType, &pgno); + if( rc!=SQLITE_OK ){ + return rc; + } + if( eType==PTRMAP_OVERFLOW2 && pgno==ovfl ){ + next = iGuess; + } + } + } +#endif + + if( next==0 || ppPage ){ + MemPage *pPage = 0; + + rc = sqlite3BtreeGetPage(pBt, ovfl, &pPage, next!=0); + assert(rc==SQLITE_OK || pPage==0); + if( next==0 && rc==SQLITE_OK ){ + next = get4byte(pPage->aData); + } + + if( ppPage ){ + *ppPage = pPage; + }else{ + releasePage(pPage); + } + } + *pPgnoNext = next; + + return rc; +} + +/* +** Copy data from a buffer to a page, or from a page to a buffer. +** +** pPayload is a pointer to data stored on database page pDbPage. +** If argument eOp is false, then nByte bytes of data are copied +** from pPayload to the buffer pointed at by pBuf. If eOp is true, +** then sqlite3PagerWrite() is called on pDbPage and nByte bytes +** of data are copied from the buffer pBuf to pPayload. +** +** SQLITE_OK is returned on success, otherwise an error code. +*/ +static int copyPayload( + void *pPayload, /* Pointer to page data */ + void *pBuf, /* Pointer to buffer */ + int nByte, /* Number of bytes to copy */ + int eOp, /* 0 -> copy from page, 1 -> copy to page */ + DbPage *pDbPage /* Page containing pPayload */ +){ + if( eOp ){ + /* Copy data from buffer to page (a write operation) */ + int rc = sqlite3PagerWrite(pDbPage); + if( rc!=SQLITE_OK ){ + return rc; + } + memcpy(pPayload, pBuf, nByte); + }else{ + /* Copy data from page to buffer (a read operation) */ + memcpy(pBuf, pPayload, nByte); + } + return SQLITE_OK; +} + +/* +** This function is used to read or overwrite payload information +** for the entry that the pCur cursor is pointing to. If the eOp +** parameter is 0, this is a read operation (data copied into +** buffer pBuf). If it is non-zero, a write (data copied from +** buffer pBuf). +** +** A total of "amt" bytes are read or written beginning at "offset". +** Data is read to or from the buffer pBuf. +** +** This routine does not make a distinction between key and data. +** It just reads or writes bytes from the payload area. Data might +** appear on the main page or be scattered out on multiple overflow +** pages. +** +** If the BtCursor.isIncrblobHandle flag is set, and the current +** cursor entry uses one or more overflow pages, this function +** allocates space for and lazily popluates the overflow page-list +** cache array (BtCursor.aOverflow). Subsequent calls use this +** cache to make seeking to the supplied offset more efficient. +** +** Once an overflow page-list cache has been allocated, it may be +** invalidated if some other cursor writes to the same table, or if +** the cursor is moved to a different row. Additionally, in auto-vacuum +** mode, the following events may invalidate an overflow page-list cache. +** +** * An incremental vacuum, +** * A commit in auto_vacuum="full" mode, +** * Creating a table (may require moving an overflow page). +*/ +static int accessPayload( + BtCursor *pCur, /* Cursor pointing to entry to read from */ + int offset, /* Begin reading this far into payload */ + int amt, /* Read this many bytes */ + unsigned char *pBuf, /* Write the bytes into this buffer */ + int skipKey, /* offset begins at data if this is true */ + int eOp /* zero to read. non-zero to write. */ +){ + unsigned char *aPayload; + int rc = SQLITE_OK; + u32 nKey; + int iIdx = 0; + MemPage *pPage = pCur->pPage; /* Btree page of current cursor entry */ + BtShared *pBt; /* Btree this cursor belongs to */ + + assert( pPage ); + assert( pCur->eState==CURSOR_VALID ); + assert( pCur->idx>=0 && pCur->idxnCell ); + assert( offset>=0 ); + assert( cursorHoldsMutex(pCur) ); + + getCellInfo(pCur); + aPayload = pCur->info.pCell + pCur->info.nHeader; + nKey = (pPage->intKey ? 0 : pCur->info.nKey); + + if( skipKey ){ + offset += nKey; + } + if( offset+amt > nKey+pCur->info.nData ){ + /* Trying to read or write past the end of the data is an error */ + return SQLITE_ERROR; + } + + /* Check if data must be read/written to/from the btree page itself. */ + if( offsetinfo.nLocal ){ + int a = amt; + if( a+offset>pCur->info.nLocal ){ + a = pCur->info.nLocal - offset; + } + rc = copyPayload(&aPayload[offset], pBuf, a, eOp, pPage->pDbPage); + offset = 0; + pBuf += a; + amt -= a; + }else{ + offset -= pCur->info.nLocal; + } + + pBt = pCur->pBt; + if( rc==SQLITE_OK && amt>0 ){ + const int ovflSize = pBt->usableSize - 4; /* Bytes content per ovfl page */ + Pgno nextPage; + + nextPage = get4byte(&aPayload[pCur->info.nLocal]); + +#ifndef SQLITE_OMIT_INCRBLOB + /* If the isIncrblobHandle flag is set and the BtCursor.aOverflow[] + ** has not been allocated, allocate it now. The array is sized at + ** one entry for each overflow page in the overflow chain. The + ** page number of the first overflow page is stored in aOverflow[0], + ** etc. A value of 0 in the aOverflow[] array means "not yet known" + ** (the cache is lazily populated). + */ + if( pCur->isIncrblobHandle && !pCur->aOverflow ){ + int nOvfl = (pCur->info.nPayload-pCur->info.nLocal+ovflSize-1)/ovflSize; + pCur->aOverflow = (Pgno *)sqlite3MallocZero(sizeof(Pgno)*nOvfl); + if( nOvfl && !pCur->aOverflow ){ + rc = SQLITE_NOMEM; + } + } + + /* If the overflow page-list cache has been allocated and the + ** entry for the first required overflow page is valid, skip + ** directly to it. + */ + if( pCur->aOverflow && pCur->aOverflow[offset/ovflSize] ){ + iIdx = (offset/ovflSize); + nextPage = pCur->aOverflow[iIdx]; + offset = (offset%ovflSize); + } +#endif + + for( ; rc==SQLITE_OK && amt>0 && nextPage; iIdx++){ + +#ifndef SQLITE_OMIT_INCRBLOB + /* If required, populate the overflow page-list cache. */ + if( pCur->aOverflow ){ + assert(!pCur->aOverflow[iIdx] || pCur->aOverflow[iIdx]==nextPage); + pCur->aOverflow[iIdx] = nextPage; + } +#endif + + if( offset>=ovflSize ){ + /* The only reason to read this page is to obtain the page + ** number for the next page in the overflow chain. The page + ** data is not required. So first try to lookup the overflow + ** page-list cache, if any, then fall back to the getOverflowPage() + ** function. + */ +#ifndef SQLITE_OMIT_INCRBLOB + if( pCur->aOverflow && pCur->aOverflow[iIdx+1] ){ + nextPage = pCur->aOverflow[iIdx+1]; + } else +#endif + rc = getOverflowPage(pBt, nextPage, 0, &nextPage); + offset -= ovflSize; + }else{ + /* Need to read this page properly. It contains some of the + ** range of data that is being read (eOp==0) or written (eOp!=0). + */ + DbPage *pDbPage; + int a = amt; + rc = sqlite3PagerGet(pBt->pPager, nextPage, &pDbPage); + if( rc==SQLITE_OK ){ + aPayload = (unsigned char*)sqlite3PagerGetData(pDbPage); + nextPage = get4byte(aPayload); + if( a + offset > ovflSize ){ + a = ovflSize - offset; + } + rc = copyPayload(&aPayload[offset+4], pBuf, a, eOp, pDbPage); + sqlite3PagerUnref(pDbPage); + offset = 0; + amt -= a; + pBuf += a; + } + } + } + } + + if( rc==SQLITE_OK && amt>0 ){ + return SQLITE_CORRUPT_BKPT; + } + return rc; +} + +/* +** Read part of the key associated with cursor pCur. Exactly +** "amt" bytes will be transfered into pBuf[]. The transfer +** begins at "offset". +** +** Return SQLITE_OK on success or an error code if anything goes +** wrong. An error is returned if "offset+amt" is larger than +** the available payload. +*/ +int sqlite3BtreeKey(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){ + int rc; + + assert( cursorHoldsMutex(pCur) ); + rc = restoreOrClearCursorPosition(pCur); + if( rc==SQLITE_OK ){ + assert( pCur->eState==CURSOR_VALID ); + assert( pCur->pPage!=0 ); + if( pCur->pPage->intKey ){ + return SQLITE_CORRUPT_BKPT; + } + assert( pCur->pPage->intKey==0 ); + assert( pCur->idx>=0 && pCur->idxpPage->nCell ); + rc = accessPayload(pCur, offset, amt, (unsigned char*)pBuf, 0, 0); + } + return rc; +} + +/* +** Read part of the data associated with cursor pCur. Exactly +** "amt" bytes will be transfered into pBuf[]. The transfer +** begins at "offset". +** +** Return SQLITE_OK on success or an error code if anything goes +** wrong. An error is returned if "offset+amt" is larger than +** the available payload. +*/ +int sqlite3BtreeData(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){ + int rc; + + assert( cursorHoldsMutex(pCur) ); + rc = restoreOrClearCursorPosition(pCur); + if( rc==SQLITE_OK ){ + assert( pCur->eState==CURSOR_VALID ); + assert( pCur->pPage!=0 ); + assert( pCur->idx>=0 && pCur->idxpPage->nCell ); + rc = accessPayload(pCur, offset, amt, (unsigned char*)pBuf, 1, 0); + } + return rc; +} + +/* +** Return a pointer to payload information from the entry that the +** pCur cursor is pointing to. The pointer is to the beginning of +** the key if skipKey==0 and it points to the beginning of data if +** skipKey==1. The number of bytes of available key/data is written +** into *pAmt. If *pAmt==0, then the value returned will not be +** a valid pointer. +** +** This routine is an optimization. It is common for the entire key +** and data to fit on the local page and for there to be no overflow +** pages. When that is so, this routine can be used to access the +** key and data without making a copy. If the key and/or data spills +** onto overflow pages, then accessPayload() must be used to reassembly +** the key/data and copy it into a preallocated buffer. +** +** The pointer returned by this routine looks directly into the cached +** page of the database. The data might change or move the next time +** any btree routine is called. +*/ +static const unsigned char *fetchPayload( + BtCursor *pCur, /* Cursor pointing to entry to read from */ + int *pAmt, /* Write the number of available bytes here */ + int skipKey /* read beginning at data if this is true */ +){ + unsigned char *aPayload; + MemPage *pPage; + u32 nKey; + int nLocal; + + assert( pCur!=0 && pCur->pPage!=0 ); + assert( pCur->eState==CURSOR_VALID ); + assert( cursorHoldsMutex(pCur) ); + pPage = pCur->pPage; + assert( pCur->idx>=0 && pCur->idxnCell ); + getCellInfo(pCur); + aPayload = pCur->info.pCell; + aPayload += pCur->info.nHeader; + if( pPage->intKey ){ + nKey = 0; + }else{ + nKey = pCur->info.nKey; + } + if( skipKey ){ + aPayload += nKey; + nLocal = pCur->info.nLocal - nKey; + }else{ + nLocal = pCur->info.nLocal; + if( nLocal>nKey ){ + nLocal = nKey; + } + } + *pAmt = nLocal; + return aPayload; +} + + +/* +** For the entry that cursor pCur is point to, return as +** many bytes of the key or data as are available on the local +** b-tree page. Write the number of available bytes into *pAmt. +** +** The pointer returned is ephemeral. The key/data may move +** or be destroyed on the next call to any Btree routine, +** including calls from other threads against the same cache. +** Hence, a mutex on the BtShared should be held prior to calling +** this routine. +** +** These routines is used to get quick access to key and data +** in the common case where no overflow pages are used. +*/ +const void *sqlite3BtreeKeyFetch(BtCursor *pCur, int *pAmt){ + assert( cursorHoldsMutex(pCur) ); + if( pCur->eState==CURSOR_VALID ){ + return (const void*)fetchPayload(pCur, pAmt, 0); + } + return 0; +} +const void *sqlite3BtreeDataFetch(BtCursor *pCur, int *pAmt){ + assert( cursorHoldsMutex(pCur) ); + if( pCur->eState==CURSOR_VALID ){ + return (const void*)fetchPayload(pCur, pAmt, 1); + } + return 0; +} + + +/* +** Move the cursor down to a new child page. The newPgno argument is the +** page number of the child page to move to. +*/ +static int moveToChild(BtCursor *pCur, u32 newPgno){ + int rc; + MemPage *pNewPage; + MemPage *pOldPage; + BtShared *pBt = pCur->pBt; + + assert( cursorHoldsMutex(pCur) ); + assert( pCur->eState==CURSOR_VALID ); + rc = getAndInitPage(pBt, newPgno, &pNewPage, pCur->pPage); + if( rc ) return rc; + pNewPage->idxParent = pCur->idx; + pOldPage = pCur->pPage; + pOldPage->idxShift = 0; + releasePage(pOldPage); + pCur->pPage = pNewPage; + pCur->idx = 0; + pCur->info.nSize = 0; + if( pNewPage->nCell<1 ){ + return SQLITE_CORRUPT_BKPT; + } + return SQLITE_OK; +} + +/* +** Return true if the page is the virtual root of its table. +** +** The virtual root page is the root page for most tables. But +** for the table rooted on page 1, sometime the real root page +** is empty except for the right-pointer. In such cases the +** virtual root page is the page that the right-pointer of page +** 1 is pointing to. +*/ +int sqlite3BtreeIsRootPage(MemPage *pPage){ + MemPage *pParent; + + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + pParent = pPage->pParent; + if( pParent==0 ) return 1; + if( pParent->pgno>1 ) return 0; + if( get2byte(&pParent->aData[pParent->hdrOffset+3])==0 ) return 1; + return 0; +} + +/* +** Move the cursor up to the parent page. +** +** pCur->idx is set to the cell index that contains the pointer +** to the page we are coming from. If we are coming from the +** right-most child page then pCur->idx is set to one more than +** the largest cell index. +*/ +void sqlite3BtreeMoveToParent(BtCursor *pCur){ + MemPage *pParent; + MemPage *pPage; + int idxParent; + + assert( cursorHoldsMutex(pCur) ); + assert( pCur->eState==CURSOR_VALID ); + pPage = pCur->pPage; + assert( pPage!=0 ); + assert( !sqlite3BtreeIsRootPage(pPage) ); + pParent = pPage->pParent; + assert( pParent!=0 ); + idxParent = pPage->idxParent; + sqlite3PagerRef(pParent->pDbPage); + releasePage(pPage); + pCur->pPage = pParent; + pCur->info.nSize = 0; + assert( pParent->idxShift==0 ); + pCur->idx = idxParent; +} + +/* +** Move the cursor to the root page +*/ +static int moveToRoot(BtCursor *pCur){ + MemPage *pRoot; + int rc = SQLITE_OK; + Btree *p = pCur->pBtree; + BtShared *pBt = p->pBt; + + assert( cursorHoldsMutex(pCur) ); + assert( CURSOR_INVALID < CURSOR_REQUIRESEEK ); + assert( CURSOR_VALID < CURSOR_REQUIRESEEK ); + assert( CURSOR_FAULT > CURSOR_REQUIRESEEK ); + if( pCur->eState>=CURSOR_REQUIRESEEK ){ + if( pCur->eState==CURSOR_FAULT ){ + return pCur->skip; + } + clearCursorPosition(pCur); + } + pRoot = pCur->pPage; + if( pRoot && pRoot->pgno==pCur->pgnoRoot ){ + assert( pRoot->isInit ); + }else{ + if( + SQLITE_OK!=(rc = getAndInitPage(pBt, pCur->pgnoRoot, &pRoot, 0)) + ){ + pCur->eState = CURSOR_INVALID; + return rc; + } + releasePage(pCur->pPage); + pCur->pPage = pRoot; + } + pCur->idx = 0; + pCur->info.nSize = 0; + if( pRoot->nCell==0 && !pRoot->leaf ){ + Pgno subpage; + assert( pRoot->pgno==1 ); + subpage = get4byte(&pRoot->aData[pRoot->hdrOffset+8]); + assert( subpage>0 ); + pCur->eState = CURSOR_VALID; + rc = moveToChild(pCur, subpage); + } + pCur->eState = ((pCur->pPage->nCell>0)?CURSOR_VALID:CURSOR_INVALID); + return rc; +} + +/* +** Move the cursor down to the left-most leaf entry beneath the +** entry to which it is currently pointing. +** +** The left-most leaf is the one with the smallest key - the first +** in ascending order. +*/ +static int moveToLeftmost(BtCursor *pCur){ + Pgno pgno; + int rc = SQLITE_OK; + MemPage *pPage; + + assert( cursorHoldsMutex(pCur) ); + assert( pCur->eState==CURSOR_VALID ); + while( rc==SQLITE_OK && !(pPage = pCur->pPage)->leaf ){ + assert( pCur->idx>=0 && pCur->idxnCell ); + pgno = get4byte(findCell(pPage, pCur->idx)); + rc = moveToChild(pCur, pgno); + } + return rc; +} + +/* +** Move the cursor down to the right-most leaf entry beneath the +** page to which it is currently pointing. Notice the difference +** between moveToLeftmost() and moveToRightmost(). moveToLeftmost() +** finds the left-most entry beneath the *entry* whereas moveToRightmost() +** finds the right-most entry beneath the *page*. +** +** The right-most entry is the one with the largest key - the last +** key in ascending order. +*/ +static int moveToRightmost(BtCursor *pCur){ + Pgno pgno; + int rc = SQLITE_OK; + MemPage *pPage; + + assert( cursorHoldsMutex(pCur) ); + assert( pCur->eState==CURSOR_VALID ); + while( rc==SQLITE_OK && !(pPage = pCur->pPage)->leaf ){ + pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]); + pCur->idx = pPage->nCell; + rc = moveToChild(pCur, pgno); + } + if( rc==SQLITE_OK ){ + pCur->idx = pPage->nCell - 1; + pCur->info.nSize = 0; + } + return SQLITE_OK; +} + +/* Move the cursor to the first entry in the table. Return SQLITE_OK +** on success. Set *pRes to 0 if the cursor actually points to something +** or set *pRes to 1 if the table is empty. +*/ +int sqlite3BtreeFirst(BtCursor *pCur, int *pRes){ + int rc; + + assert( cursorHoldsMutex(pCur) ); + assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) ); + rc = moveToRoot(pCur); + if( rc==SQLITE_OK ){ + if( pCur->eState==CURSOR_INVALID ){ + assert( pCur->pPage->nCell==0 ); + *pRes = 1; + rc = SQLITE_OK; + }else{ + assert( pCur->pPage->nCell>0 ); + *pRes = 0; + rc = moveToLeftmost(pCur); + } + } + return rc; +} + +/* Move the cursor to the last entry in the table. Return SQLITE_OK +** on success. Set *pRes to 0 if the cursor actually points to something +** or set *pRes to 1 if the table is empty. +*/ +int sqlite3BtreeLast(BtCursor *pCur, int *pRes){ + int rc; + + assert( cursorHoldsMutex(pCur) ); + assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) ); + rc = moveToRoot(pCur); + if( rc==SQLITE_OK ){ + if( CURSOR_INVALID==pCur->eState ){ + assert( pCur->pPage->nCell==0 ); + *pRes = 1; + }else{ + assert( pCur->eState==CURSOR_VALID ); + *pRes = 0; + rc = moveToRightmost(pCur); + } + } + return rc; +} + +/* Move the cursor so that it points to an entry near pKey/nKey. +** Return a success code. +** +** For INTKEY tables, only the nKey parameter is used. pKey is +** ignored. For other tables, nKey is the number of bytes of data +** in pKey. The comparison function specified when the cursor was +** created is used to compare keys. +** +** If an exact match is not found, then the cursor is always +** left pointing at a leaf page which would hold the entry if it +** were present. The cursor might point to an entry that comes +** before or after the key. +** +** The result of comparing the key with the entry to which the +** cursor is written to *pRes if pRes!=NULL. The meaning of +** this value is as follows: +** +** *pRes<0 The cursor is left pointing at an entry that +** is smaller than pKey or if the table is empty +** and the cursor is therefore left point to nothing. +** +** *pRes==0 The cursor is left pointing at an entry that +** exactly matches pKey. +** +** *pRes>0 The cursor is left pointing at an entry that +** is larger than pKey. +** +*/ +int sqlite3BtreeMoveto( + BtCursor *pCur, /* The cursor to be moved */ + const void *pKey, /* The key content for indices. Not used by tables */ + i64 nKey, /* Size of pKey. Or the key for tables */ + int biasRight, /* If true, bias the search to the high end */ + int *pRes /* Search result flag */ +){ + int rc; + + assert( cursorHoldsMutex(pCur) ); + assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) ); + rc = moveToRoot(pCur); + if( rc ){ + return rc; + } + assert( pCur->pPage ); + assert( pCur->pPage->isInit ); + if( pCur->eState==CURSOR_INVALID ){ + *pRes = -1; + assert( pCur->pPage->nCell==0 ); + return SQLITE_OK; + } + for(;;){ + int lwr, upr; + Pgno chldPg; + MemPage *pPage = pCur->pPage; + int c = -1; /* pRes return if table is empty must be -1 */ + lwr = 0; + upr = pPage->nCell-1; + if( !pPage->intKey && pKey==0 ){ + return SQLITE_CORRUPT_BKPT; + } + if( biasRight ){ + pCur->idx = upr; + }else{ + pCur->idx = (upr+lwr)/2; + } + if( lwr<=upr ) for(;;){ + void *pCellKey; + i64 nCellKey; + pCur->info.nSize = 0; + if( pPage->intKey ){ + u8 *pCell; + pCell = findCell(pPage, pCur->idx) + pPage->childPtrSize; + if( pPage->hasData ){ + u32 dummy; + pCell += getVarint32(pCell, &dummy); + } + getVarint(pCell, (u64 *)&nCellKey); + if( nCellKeynKey ){ + c = +1; + }else{ + c = 0; + } + }else{ + int available; + pCellKey = (void *)fetchPayload(pCur, &available, 0); + nCellKey = pCur->info.nKey; + if( available>=nCellKey ){ + c = pCur->xCompare(pCur->pArg, nCellKey, pCellKey, nKey, pKey); + }else{ + pCellKey = sqlite3_malloc( nCellKey ); + if( pCellKey==0 ) return SQLITE_NOMEM; + rc = sqlite3BtreeKey(pCur, 0, nCellKey, (void *)pCellKey); + c = pCur->xCompare(pCur->pArg, nCellKey, pCellKey, nKey, pKey); + sqlite3_free(pCellKey); + if( rc ){ + return rc; + } + } + } + if( c==0 ){ + if( pPage->leafData && !pPage->leaf ){ + lwr = pCur->idx; + upr = lwr - 1; + break; + }else{ + if( pRes ) *pRes = 0; + return SQLITE_OK; + } + } + if( c<0 ){ + lwr = pCur->idx+1; + }else{ + upr = pCur->idx-1; + } + if( lwr>upr ){ + break; + } + pCur->idx = (lwr+upr)/2; + } + assert( lwr==upr+1 ); + assert( pPage->isInit ); + if( pPage->leaf ){ + chldPg = 0; + }else if( lwr>=pPage->nCell ){ + chldPg = get4byte(&pPage->aData[pPage->hdrOffset+8]); + }else{ + chldPg = get4byte(findCell(pPage, lwr)); + } + if( chldPg==0 ){ + assert( pCur->idx>=0 && pCur->idxpPage->nCell ); + if( pRes ) *pRes = c; + return SQLITE_OK; + } + pCur->idx = lwr; + pCur->info.nSize = 0; + rc = moveToChild(pCur, chldPg); + if( rc ){ + return rc; + } + } + /* NOT REACHED */ +} + + +/* +** Return TRUE if the cursor is not pointing at an entry of the table. +** +** TRUE will be returned after a call to sqlite3BtreeNext() moves +** past the last entry in the table or sqlite3BtreePrev() moves past +** the first entry. TRUE is also returned if the table is empty. +*/ +int sqlite3BtreeEof(BtCursor *pCur){ + /* TODO: What if the cursor is in CURSOR_REQUIRESEEK but all table entries + ** have been deleted? This API will need to change to return an error code + ** as well as the boolean result value. + */ + return (CURSOR_VALID!=pCur->eState); +} + +/* +** Return the database connection handle for a cursor. +*/ +sqlite3 *sqlite3BtreeCursorDb(const BtCursor *pCur){ + assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) ); + return pCur->pBtree->db; +} + +/* +** Advance the cursor to the next entry in the database. If +** successful then set *pRes=0. If the cursor +** was already pointing to the last entry in the database before +** this routine was called, then set *pRes=1. +*/ +static int btreeNext(BtCursor *pCur, int *pRes){ + int rc; + MemPage *pPage; + + assert( cursorHoldsMutex(pCur) ); + rc = restoreOrClearCursorPosition(pCur); + if( rc!=SQLITE_OK ){ + return rc; + } + assert( pRes!=0 ); + pPage = pCur->pPage; + if( CURSOR_INVALID==pCur->eState ){ + *pRes = 1; + return SQLITE_OK; + } + if( pCur->skip>0 ){ + pCur->skip = 0; + *pRes = 0; + return SQLITE_OK; + } + pCur->skip = 0; + + assert( pPage->isInit ); + assert( pCur->idxnCell ); + + pCur->idx++; + pCur->info.nSize = 0; + if( pCur->idx>=pPage->nCell ){ + if( !pPage->leaf ){ + rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8])); + if( rc ) return rc; + rc = moveToLeftmost(pCur); + *pRes = 0; + return rc; + } + do{ + if( sqlite3BtreeIsRootPage(pPage) ){ + *pRes = 1; + pCur->eState = CURSOR_INVALID; + return SQLITE_OK; + } + sqlite3BtreeMoveToParent(pCur); + pPage = pCur->pPage; + }while( pCur->idx>=pPage->nCell ); + *pRes = 0; + if( pPage->leafData ){ + rc = sqlite3BtreeNext(pCur, pRes); + }else{ + rc = SQLITE_OK; + } + return rc; + } + *pRes = 0; + if( pPage->leaf ){ + return SQLITE_OK; + } + rc = moveToLeftmost(pCur); + return rc; +} +int sqlite3BtreeNext(BtCursor *pCur, int *pRes){ + int rc; + assert( cursorHoldsMutex(pCur) ); + rc = btreeNext(pCur, pRes); + return rc; +} + + +/* +** Step the cursor to the back to the previous entry in the database. If +** successful then set *pRes=0. If the cursor +** was already pointing to the first entry in the database before +** this routine was called, then set *pRes=1. +*/ +static int btreePrevious(BtCursor *pCur, int *pRes){ + int rc; + Pgno pgno; + MemPage *pPage; + + assert( cursorHoldsMutex(pCur) ); + rc = restoreOrClearCursorPosition(pCur); + if( rc!=SQLITE_OK ){ + return rc; + } + if( CURSOR_INVALID==pCur->eState ){ + *pRes = 1; + return SQLITE_OK; + } + if( pCur->skip<0 ){ + pCur->skip = 0; + *pRes = 0; + return SQLITE_OK; + } + pCur->skip = 0; + + pPage = pCur->pPage; + assert( pPage->isInit ); + assert( pCur->idx>=0 ); + if( !pPage->leaf ){ + pgno = get4byte( findCell(pPage, pCur->idx) ); + rc = moveToChild(pCur, pgno); + if( rc ){ + return rc; + } + rc = moveToRightmost(pCur); + }else{ + while( pCur->idx==0 ){ + if( sqlite3BtreeIsRootPage(pPage) ){ + pCur->eState = CURSOR_INVALID; + *pRes = 1; + return SQLITE_OK; + } + sqlite3BtreeMoveToParent(pCur); + pPage = pCur->pPage; + } + pCur->idx--; + pCur->info.nSize = 0; + if( pPage->leafData && !pPage->leaf ){ + rc = sqlite3BtreePrevious(pCur, pRes); + }else{ + rc = SQLITE_OK; + } + } + *pRes = 0; + return rc; +} +int sqlite3BtreePrevious(BtCursor *pCur, int *pRes){ + int rc; + assert( cursorHoldsMutex(pCur) ); + rc = btreePrevious(pCur, pRes); + return rc; +} + +/* +** Allocate a new page from the database file. +** +** The new page is marked as dirty. (In other words, sqlite3PagerWrite() +** has already been called on the new page.) The new page has also +** been referenced and the calling routine is responsible for calling +** sqlite3PagerUnref() on the new page when it is done. +** +** SQLITE_OK is returned on success. Any other return value indicates +** an error. *ppPage and *pPgno are undefined in the event of an error. +** Do not invoke sqlite3PagerUnref() on *ppPage if an error is returned. +** +** If the "nearby" parameter is not 0, then a (feeble) effort is made to +** locate a page close to the page number "nearby". This can be used in an +** attempt to keep related pages close to each other in the database file, +** which in turn can make database access faster. +** +** If the "exact" parameter is not 0, and the page-number nearby exists +** anywhere on the free-list, then it is guarenteed to be returned. This +** is only used by auto-vacuum databases when allocating a new table. +*/ +static int allocateBtreePage( + BtShared *pBt, + MemPage **ppPage, + Pgno *pPgno, + Pgno nearby, + u8 exact +){ + MemPage *pPage1; + int rc; + int n; /* Number of pages on the freelist */ + int k; /* Number of leaves on the trunk of the freelist */ + MemPage *pTrunk = 0; + MemPage *pPrevTrunk = 0; + + assert( sqlite3_mutex_held(pBt->mutex) ); + pPage1 = pBt->pPage1; + n = get4byte(&pPage1->aData[36]); + if( n>0 ){ + /* There are pages on the freelist. Reuse one of those pages. */ + Pgno iTrunk; + u8 searchList = 0; /* If the free-list must be searched for 'nearby' */ + + /* If the 'exact' parameter was true and a query of the pointer-map + ** shows that the page 'nearby' is somewhere on the free-list, then + ** the entire-list will be searched for that page. + */ +#ifndef SQLITE_OMIT_AUTOVACUUM + if( exact && nearby<=sqlite3PagerPagecount(pBt->pPager) ){ + u8 eType; + assert( nearby>0 ); + assert( pBt->autoVacuum ); + rc = ptrmapGet(pBt, nearby, &eType, 0); + if( rc ) return rc; + if( eType==PTRMAP_FREEPAGE ){ + searchList = 1; + } + *pPgno = nearby; + } +#endif + + /* Decrement the free-list count by 1. Set iTrunk to the index of the + ** first free-list trunk page. iPrevTrunk is initially 1. + */ + rc = sqlite3PagerWrite(pPage1->pDbPage); + if( rc ) return rc; + put4byte(&pPage1->aData[36], n-1); + + /* The code within this loop is run only once if the 'searchList' variable + ** is not true. Otherwise, it runs once for each trunk-page on the + ** free-list until the page 'nearby' is located. + */ + do { + pPrevTrunk = pTrunk; + if( pPrevTrunk ){ + iTrunk = get4byte(&pPrevTrunk->aData[0]); + }else{ + iTrunk = get4byte(&pPage1->aData[32]); + } + rc = sqlite3BtreeGetPage(pBt, iTrunk, &pTrunk, 0); + if( rc ){ + pTrunk = 0; + goto end_allocate_page; + } + + k = get4byte(&pTrunk->aData[4]); + if( k==0 && !searchList ){ + /* The trunk has no leaves and the list is not being searched. + ** So extract the trunk page itself and use it as the newly + ** allocated page */ + assert( pPrevTrunk==0 ); + rc = sqlite3PagerWrite(pTrunk->pDbPage); + if( rc ){ + goto end_allocate_page; + } + *pPgno = iTrunk; + memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4); + *ppPage = pTrunk; + pTrunk = 0; + TRACE(("ALLOCATE: %d trunk - %d free pages left\n", *pPgno, n-1)); + }else if( k>pBt->usableSize/4 - 8 ){ + /* Value of k is out of range. Database corruption */ + rc = SQLITE_CORRUPT_BKPT; + goto end_allocate_page; +#ifndef SQLITE_OMIT_AUTOVACUUM + }else if( searchList && nearby==iTrunk ){ + /* The list is being searched and this trunk page is the page + ** to allocate, regardless of whether it has leaves. + */ + assert( *pPgno==iTrunk ); + *ppPage = pTrunk; + searchList = 0; + rc = sqlite3PagerWrite(pTrunk->pDbPage); + if( rc ){ + goto end_allocate_page; + } + if( k==0 ){ + if( !pPrevTrunk ){ + memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4); + }else{ + memcpy(&pPrevTrunk->aData[0], &pTrunk->aData[0], 4); + } + }else{ + /* The trunk page is required by the caller but it contains + ** pointers to free-list leaves. The first leaf becomes a trunk + ** page in this case. + */ + MemPage *pNewTrunk; + Pgno iNewTrunk = get4byte(&pTrunk->aData[8]); + rc = sqlite3BtreeGetPage(pBt, iNewTrunk, &pNewTrunk, 0); + if( rc!=SQLITE_OK ){ + goto end_allocate_page; + } + rc = sqlite3PagerWrite(pNewTrunk->pDbPage); + if( rc!=SQLITE_OK ){ + releasePage(pNewTrunk); + goto end_allocate_page; + } + memcpy(&pNewTrunk->aData[0], &pTrunk->aData[0], 4); + put4byte(&pNewTrunk->aData[4], k-1); + memcpy(&pNewTrunk->aData[8], &pTrunk->aData[12], (k-1)*4); + releasePage(pNewTrunk); + if( !pPrevTrunk ){ + put4byte(&pPage1->aData[32], iNewTrunk); + }else{ + rc = sqlite3PagerWrite(pPrevTrunk->pDbPage); + if( rc ){ + goto end_allocate_page; + } + put4byte(&pPrevTrunk->aData[0], iNewTrunk); + } + } + pTrunk = 0; + TRACE(("ALLOCATE: %d trunk - %d free pages left\n", *pPgno, n-1)); +#endif + }else{ + /* Extract a leaf from the trunk */ + int closest; + Pgno iPage; + unsigned char *aData = pTrunk->aData; + rc = sqlite3PagerWrite(pTrunk->pDbPage); + if( rc ){ + goto end_allocate_page; + } + if( nearby>0 ){ + int i, dist; + closest = 0; + dist = get4byte(&aData[8]) - nearby; + if( dist<0 ) dist = -dist; + for(i=1; isqlite3PagerPagecount(pBt->pPager) ){ + /* Free page off the end of the file */ + return SQLITE_CORRUPT_BKPT; + } + TRACE(("ALLOCATE: %d was leaf %d of %d on trunk %d" + ": %d more free pages\n", + *pPgno, closest+1, k, pTrunk->pgno, n-1)); + if( closestpDbPage); + rc = sqlite3PagerWrite((*ppPage)->pDbPage); + if( rc!=SQLITE_OK ){ + releasePage(*ppPage); + } + } + searchList = 0; + } + } + releasePage(pPrevTrunk); + pPrevTrunk = 0; + }while( searchList ); + }else{ + /* There are no pages on the freelist, so create a new page at the + ** end of the file */ + *pPgno = sqlite3PagerPagecount(pBt->pPager) + 1; + +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->nTrunc ){ + /* An incr-vacuum has already run within this transaction. So the + ** page to allocate is not from the physical end of the file, but + ** at pBt->nTrunc. + */ + *pPgno = pBt->nTrunc+1; + if( *pPgno==PENDING_BYTE_PAGE(pBt) ){ + (*pPgno)++; + } + } + if( pBt->autoVacuum && PTRMAP_ISPAGE(pBt, *pPgno) ){ + /* If *pPgno refers to a pointer-map page, allocate two new pages + ** at the end of the file instead of one. The first allocated page + ** becomes a new pointer-map page, the second is used by the caller. + */ + TRACE(("ALLOCATE: %d from end of file (pointer-map page)\n", *pPgno)); + assert( *pPgno!=PENDING_BYTE_PAGE(pBt) ); + (*pPgno)++; + } + if( pBt->nTrunc ){ + pBt->nTrunc = *pPgno; + } +#endif + + assert( *pPgno!=PENDING_BYTE_PAGE(pBt) ); + rc = sqlite3BtreeGetPage(pBt, *pPgno, ppPage, 0); + if( rc ) return rc; + rc = sqlite3PagerWrite((*ppPage)->pDbPage); + if( rc!=SQLITE_OK ){ + releasePage(*ppPage); + } + TRACE(("ALLOCATE: %d from end of file\n", *pPgno)); + } + + assert( *pPgno!=PENDING_BYTE_PAGE(pBt) ); + +end_allocate_page: + releasePage(pTrunk); + releasePage(pPrevTrunk); + return rc; +} + +/* +** Add a page of the database file to the freelist. +** +** sqlite3PagerUnref() is NOT called for pPage. +*/ +static int freePage(MemPage *pPage){ + BtShared *pBt = pPage->pBt; + MemPage *pPage1 = pBt->pPage1; + int rc, n, k; + + /* Prepare the page for freeing */ + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + assert( pPage->pgno>1 ); + pPage->isInit = 0; + releasePage(pPage->pParent); + pPage->pParent = 0; + + /* Increment the free page count on pPage1 */ + rc = sqlite3PagerWrite(pPage1->pDbPage); + if( rc ) return rc; + n = get4byte(&pPage1->aData[36]); + put4byte(&pPage1->aData[36], n+1); + +#ifdef SQLITE_SECURE_DELETE + /* If the SQLITE_SECURE_DELETE compile-time option is enabled, then + ** always fully overwrite deleted information with zeros. + */ + rc = sqlite3PagerWrite(pPage->pDbPage); + if( rc ) return rc; + memset(pPage->aData, 0, pPage->pBt->pageSize); +#endif + +#ifndef SQLITE_OMIT_AUTOVACUUM + /* If the database supports auto-vacuum, write an entry in the pointer-map + ** to indicate that the page is free. + */ + if( pBt->autoVacuum ){ + rc = ptrmapPut(pBt, pPage->pgno, PTRMAP_FREEPAGE, 0); + if( rc ) return rc; + } +#endif + + if( n==0 ){ + /* This is the first free page */ + rc = sqlite3PagerWrite(pPage->pDbPage); + if( rc ) return rc; + memset(pPage->aData, 0, 8); + put4byte(&pPage1->aData[32], pPage->pgno); + TRACE(("FREE-PAGE: %d first\n", pPage->pgno)); + }else{ + /* Other free pages already exist. Retrive the first trunk page + ** of the freelist and find out how many leaves it has. */ + MemPage *pTrunk; + rc = sqlite3BtreeGetPage(pBt, get4byte(&pPage1->aData[32]), &pTrunk, 0); + if( rc ) return rc; + k = get4byte(&pTrunk->aData[4]); + if( k>=pBt->usableSize/4 - 8 ){ + /* The trunk is full. Turn the page being freed into a new + ** trunk page with no leaves. */ + rc = sqlite3PagerWrite(pPage->pDbPage); + if( rc==SQLITE_OK ){ + put4byte(pPage->aData, pTrunk->pgno); + put4byte(&pPage->aData[4], 0); + put4byte(&pPage1->aData[32], pPage->pgno); + TRACE(("FREE-PAGE: %d new trunk page replacing %d\n", + pPage->pgno, pTrunk->pgno)); + } + }else if( k<0 ){ + rc = SQLITE_CORRUPT; + }else{ + /* Add the newly freed page as a leaf on the current trunk */ + rc = sqlite3PagerWrite(pTrunk->pDbPage); + if( rc==SQLITE_OK ){ + put4byte(&pTrunk->aData[4], k+1); + put4byte(&pTrunk->aData[8+k*4], pPage->pgno); +#ifndef SQLITE_SECURE_DELETE + sqlite3PagerDontWrite(pPage->pDbPage); +#endif + } + TRACE(("FREE-PAGE: %d leaf on trunk page %d\n",pPage->pgno,pTrunk->pgno)); + } + releasePage(pTrunk); + } + return rc; +} + +/* +** Free any overflow pages associated with the given Cell. +*/ +static int clearCell(MemPage *pPage, unsigned char *pCell){ + BtShared *pBt = pPage->pBt; + CellInfo info; + Pgno ovflPgno; + int rc; + int nOvfl; + int ovflPageSize; + + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + sqlite3BtreeParseCellPtr(pPage, pCell, &info); + if( info.iOverflow==0 ){ + return SQLITE_OK; /* No overflow pages. Return without doing anything */ + } + ovflPgno = get4byte(&pCell[info.iOverflow]); + ovflPageSize = pBt->usableSize - 4; + nOvfl = (info.nPayload - info.nLocal + ovflPageSize - 1)/ovflPageSize; + assert( ovflPgno==0 || nOvfl>0 ); + while( nOvfl-- ){ + MemPage *pOvfl; + if( ovflPgno==0 || ovflPgno>sqlite3PagerPagecount(pBt->pPager) ){ + return SQLITE_CORRUPT_BKPT; + } + + rc = getOverflowPage(pBt, ovflPgno, &pOvfl, (nOvfl==0)?0:&ovflPgno); + if( rc ) return rc; + rc = freePage(pOvfl); + sqlite3PagerUnref(pOvfl->pDbPage); + if( rc ) return rc; + } + return SQLITE_OK; +} + +/* +** Create the byte sequence used to represent a cell on page pPage +** and write that byte sequence into pCell[]. Overflow pages are +** allocated and filled in as necessary. The calling procedure +** is responsible for making sure sufficient space has been allocated +** for pCell[]. +** +** Note that pCell does not necessary need to point to the pPage->aData +** area. pCell might point to some temporary storage. The cell will +** be constructed in this temporary area then copied into pPage->aData +** later. +*/ +static int fillInCell( + MemPage *pPage, /* The page that contains the cell */ + unsigned char *pCell, /* Complete text of the cell */ + const void *pKey, i64 nKey, /* The key */ + const void *pData,int nData, /* The data */ + int nZero, /* Extra zero bytes to append to pData */ + int *pnSize /* Write cell size here */ +){ + int nPayload; + const u8 *pSrc; + int nSrc, n, rc; + int spaceLeft; + MemPage *pOvfl = 0; + MemPage *pToRelease = 0; + unsigned char *pPrior; + unsigned char *pPayload; + BtShared *pBt = pPage->pBt; + Pgno pgnoOvfl = 0; + int nHeader; + CellInfo info; + + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + + /* Fill in the header. */ + nHeader = 0; + if( !pPage->leaf ){ + nHeader += 4; + } + if( pPage->hasData ){ + nHeader += putVarint(&pCell[nHeader], nData+nZero); + }else{ + nData = nZero = 0; + } + nHeader += putVarint(&pCell[nHeader], *(u64*)&nKey); + sqlite3BtreeParseCellPtr(pPage, pCell, &info); + assert( info.nHeader==nHeader ); + assert( info.nKey==nKey ); + assert( info.nData==nData+nZero ); + + /* Fill in the payload */ + nPayload = nData + nZero; + if( pPage->intKey ){ + pSrc = (const u8*)pData; + nSrc = nData; + nData = 0; + }else{ + nPayload += nKey; + pSrc = (const u8*)pKey; + nSrc = nKey; + } + *pnSize = info.nSize; + spaceLeft = info.nLocal; + pPayload = &pCell[nHeader]; + pPrior = &pCell[info.iOverflow]; + + while( nPayload>0 ){ + if( spaceLeft==0 ){ + int isExact = 0; +#ifndef SQLITE_OMIT_AUTOVACUUM + Pgno pgnoPtrmap = pgnoOvfl; /* Overflow page pointer-map entry page */ + if( pBt->autoVacuum ){ + do{ + pgnoOvfl++; + } while( + PTRMAP_ISPAGE(pBt, pgnoOvfl) || pgnoOvfl==PENDING_BYTE_PAGE(pBt) + ); + if( pgnoOvfl>1 ){ + /* isExact = 1; */ + } + } +#endif + rc = allocateBtreePage(pBt, &pOvfl, &pgnoOvfl, pgnoOvfl, isExact); +#ifndef SQLITE_OMIT_AUTOVACUUM + /* If the database supports auto-vacuum, and the second or subsequent + ** overflow page is being allocated, add an entry to the pointer-map + ** for that page now. + ** + ** If this is the first overflow page, then write a partial entry + ** to the pointer-map. If we write nothing to this pointer-map slot, + ** then the optimistic overflow chain processing in clearCell() + ** may misinterpret the uninitialised values and delete the + ** wrong pages from the database. + */ + if( pBt->autoVacuum && rc==SQLITE_OK ){ + u8 eType = (pgnoPtrmap?PTRMAP_OVERFLOW2:PTRMAP_OVERFLOW1); + rc = ptrmapPut(pBt, pgnoOvfl, eType, pgnoPtrmap); + if( rc ){ + releasePage(pOvfl); + } + } +#endif + if( rc ){ + releasePage(pToRelease); + return rc; + } + put4byte(pPrior, pgnoOvfl); + releasePage(pToRelease); + pToRelease = pOvfl; + pPrior = pOvfl->aData; + put4byte(pPrior, 0); + pPayload = &pOvfl->aData[4]; + spaceLeft = pBt->usableSize - 4; + } + n = nPayload; + if( n>spaceLeft ) n = spaceLeft; + if( nSrc>0 ){ + if( n>nSrc ) n = nSrc; + assert( pSrc ); + memcpy(pPayload, pSrc, n); + }else{ + memset(pPayload, 0, n); + } + nPayload -= n; + pPayload += n; + pSrc += n; + nSrc -= n; + spaceLeft -= n; + if( nSrc==0 ){ + nSrc = nData; + pSrc = (u8*)pData; + } + } + releasePage(pToRelease); + return SQLITE_OK; +} + +/* +** Change the MemPage.pParent pointer on the page whose number is +** given in the second argument so that MemPage.pParent holds the +** pointer in the third argument. +*/ +static int reparentPage(BtShared *pBt, Pgno pgno, MemPage *pNewParent, int idx){ + MemPage *pThis; + DbPage *pDbPage; + + assert( sqlite3_mutex_held(pBt->mutex) ); + assert( pNewParent!=0 ); + if( pgno==0 ) return SQLITE_OK; + assert( pBt->pPager!=0 ); + pDbPage = sqlite3PagerLookup(pBt->pPager, pgno); + if( pDbPage ){ + pThis = (MemPage *)sqlite3PagerGetExtra(pDbPage); + if( pThis->isInit ){ + assert( pThis->aData==sqlite3PagerGetData(pDbPage) ); + if( pThis->pParent!=pNewParent ){ + if( pThis->pParent ) sqlite3PagerUnref(pThis->pParent->pDbPage); + pThis->pParent = pNewParent; + sqlite3PagerRef(pNewParent->pDbPage); + } + pThis->idxParent = idx; + } + sqlite3PagerUnref(pDbPage); + } + +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum ){ + return ptrmapPut(pBt, pgno, PTRMAP_BTREE, pNewParent->pgno); + } +#endif + return SQLITE_OK; +} + + + +/* +** Change the pParent pointer of all children of pPage to point back +** to pPage. +** +** In other words, for every child of pPage, invoke reparentPage() +** to make sure that each child knows that pPage is its parent. +** +** This routine gets called after you memcpy() one page into +** another. +*/ +static int reparentChildPages(MemPage *pPage){ + int i; + BtShared *pBt = pPage->pBt; + int rc = SQLITE_OK; + + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + if( pPage->leaf ) return SQLITE_OK; + + for(i=0; inCell; i++){ + u8 *pCell = findCell(pPage, i); + if( !pPage->leaf ){ + rc = reparentPage(pBt, get4byte(pCell), pPage, i); + if( rc!=SQLITE_OK ) return rc; + } + } + if( !pPage->leaf ){ + rc = reparentPage(pBt, get4byte(&pPage->aData[pPage->hdrOffset+8]), + pPage, i); + pPage->idxShift = 0; + } + return rc; +} + +/* +** Remove the i-th cell from pPage. This routine effects pPage only. +** The cell content is not freed or deallocated. It is assumed that +** the cell content has been copied someplace else. This routine just +** removes the reference to the cell from pPage. +** +** "sz" must be the number of bytes in the cell. +*/ +static void dropCell(MemPage *pPage, int idx, int sz){ + int i; /* Loop counter */ + int pc; /* Offset to cell content of cell being deleted */ + u8 *data; /* pPage->aData */ + u8 *ptr; /* Used to move bytes around within data[] */ + + assert( idx>=0 && idxnCell ); + assert( sz==cellSize(pPage, idx) ); + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + data = pPage->aData; + ptr = &data[pPage->cellOffset + 2*idx]; + pc = get2byte(ptr); + assert( pc>10 && pc+sz<=pPage->pBt->usableSize ); + freeSpace(pPage, pc, sz); + for(i=idx+1; inCell; i++, ptr+=2){ + ptr[0] = ptr[2]; + ptr[1] = ptr[3]; + } + pPage->nCell--; + put2byte(&data[pPage->hdrOffset+3], pPage->nCell); + pPage->nFree += 2; + pPage->idxShift = 1; +} + +/* +** Insert a new cell on pPage at cell index "i". pCell points to the +** content of the cell. +** +** If the cell content will fit on the page, then put it there. If it +** will not fit, then make a copy of the cell content into pTemp if +** pTemp is not null. Regardless of pTemp, allocate a new entry +** in pPage->aOvfl[] and make it point to the cell content (either +** in pTemp or the original pCell) and also record its index. +** Allocating a new entry in pPage->aCell[] implies that +** pPage->nOverflow is incremented. +** +** If nSkip is non-zero, then do not copy the first nSkip bytes of the +** cell. The caller will overwrite them after this function returns. If +** nSkip is non-zero, then pCell may not point to an invalid memory location +** (but pCell+nSkip is always valid). +*/ +static int insertCell( + MemPage *pPage, /* Page into which we are copying */ + int i, /* New cell becomes the i-th cell of the page */ + u8 *pCell, /* Content of the new cell */ + int sz, /* Bytes of content in pCell */ + u8 *pTemp, /* Temp storage space for pCell, if needed */ + u8 nSkip /* Do not write the first nSkip bytes of the cell */ +){ + int idx; /* Where to write new cell content in data[] */ + int j; /* Loop counter */ + int top; /* First byte of content for any cell in data[] */ + int end; /* First byte past the last cell pointer in data[] */ + int ins; /* Index in data[] where new cell pointer is inserted */ + int hdr; /* Offset into data[] of the page header */ + int cellOffset; /* Address of first cell pointer in data[] */ + u8 *data; /* The content of the whole page */ + u8 *ptr; /* Used for moving information around in data[] */ + + assert( i>=0 && i<=pPage->nCell+pPage->nOverflow ); + assert( sz==cellSizePtr(pPage, pCell) ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + if( pPage->nOverflow || sz+2>pPage->nFree ){ + if( pTemp ){ + memcpy(pTemp+nSkip, pCell+nSkip, sz-nSkip); + pCell = pTemp; + } + j = pPage->nOverflow++; + assert( jaOvfl)/sizeof(pPage->aOvfl[0]) ); + pPage->aOvfl[j].pCell = pCell; + pPage->aOvfl[j].idx = i; + pPage->nFree = 0; + }else{ + int rc = sqlite3PagerWrite(pPage->pDbPage); + if( rc!=SQLITE_OK ){ + return rc; + } + assert( sqlite3PagerIswriteable(pPage->pDbPage) ); + data = pPage->aData; + hdr = pPage->hdrOffset; + top = get2byte(&data[hdr+5]); + cellOffset = pPage->cellOffset; + end = cellOffset + 2*pPage->nCell + 2; + ins = cellOffset + 2*i; + if( end > top - sz ){ + rc = defragmentPage(pPage); + if( rc!=SQLITE_OK ) return rc; + top = get2byte(&data[hdr+5]); + assert( end + sz <= top ); + } + idx = allocateSpace(pPage, sz); + assert( idx>0 ); + assert( end <= get2byte(&data[hdr+5]) ); + pPage->nCell++; + pPage->nFree -= 2; + memcpy(&data[idx+nSkip], pCell+nSkip, sz-nSkip); + for(j=end-2, ptr=&data[j]; j>ins; j-=2, ptr-=2){ + ptr[0] = ptr[-2]; + ptr[1] = ptr[-1]; + } + put2byte(&data[ins], idx); + put2byte(&data[hdr+3], pPage->nCell); + pPage->idxShift = 1; +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pPage->pBt->autoVacuum ){ + /* The cell may contain a pointer to an overflow page. If so, write + ** the entry for the overflow page into the pointer map. + */ + CellInfo info; + sqlite3BtreeParseCellPtr(pPage, pCell, &info); + assert( (info.nData+(pPage->intKey?0:info.nKey))==info.nPayload ); + if( (info.nData+(pPage->intKey?0:info.nKey))>info.nLocal ){ + Pgno pgnoOvfl = get4byte(&pCell[info.iOverflow]); + rc = ptrmapPut(pPage->pBt, pgnoOvfl, PTRMAP_OVERFLOW1, pPage->pgno); + if( rc!=SQLITE_OK ) return rc; + } + } +#endif + } + + return SQLITE_OK; +} + +/* +** Add a list of cells to a page. The page should be initially empty. +** The cells are guaranteed to fit on the page. +*/ +static void assemblePage( + MemPage *pPage, /* The page to be assemblied */ + int nCell, /* The number of cells to add to this page */ + u8 **apCell, /* Pointers to cell bodies */ + int *aSize /* Sizes of the cells */ +){ + int i; /* Loop counter */ + int totalSize; /* Total size of all cells */ + int hdr; /* Index of page header */ + int cellptr; /* Address of next cell pointer */ + int cellbody; /* Address of next cell body */ + u8 *data; /* Data for the page */ + + assert( pPage->nOverflow==0 ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + totalSize = 0; + for(i=0; inFree ); + assert( pPage->nCell==0 ); + cellptr = pPage->cellOffset; + data = pPage->aData; + hdr = pPage->hdrOffset; + put2byte(&data[hdr+3], nCell); + if( nCell ){ + cellbody = allocateSpace(pPage, totalSize); + assert( cellbody>0 ); + assert( pPage->nFree >= 2*nCell ); + pPage->nFree -= 2*nCell; + for(i=0; ipBt->usableSize ); + } + pPage->nCell = nCell; +} + +/* +** The following parameters determine how many adjacent pages get involved +** in a balancing operation. NN is the number of neighbors on either side +** of the page that participate in the balancing operation. NB is the +** total number of pages that participate, including the target page and +** NN neighbors on either side. +** +** The minimum value of NN is 1 (of course). Increasing NN above 1 +** (to 2 or 3) gives a modest improvement in SELECT and DELETE performance +** in exchange for a larger degradation in INSERT and UPDATE performance. +** The value of NN appears to give the best results overall. +*/ +#define NN 1 /* Number of neighbors on either side of pPage */ +#define NB (NN*2+1) /* Total pages involved in the balance */ + +/* Forward reference */ +static int balance(MemPage*, int); + +#ifndef SQLITE_OMIT_QUICKBALANCE +/* +** This version of balance() handles the common special case where +** a new entry is being inserted on the extreme right-end of the +** tree, in other words, when the new entry will become the largest +** entry in the tree. +** +** Instead of trying balance the 3 right-most leaf pages, just add +** a new page to the right-hand side and put the one new entry in +** that page. This leaves the right side of the tree somewhat +** unbalanced. But odds are that we will be inserting new entries +** at the end soon afterwards so the nearly empty page will quickly +** fill up. On average. +** +** pPage is the leaf page which is the right-most page in the tree. +** pParent is its parent. pPage must have a single overflow entry +** which is also the right-most entry on the page. +*/ +static int balance_quick(MemPage *pPage, MemPage *pParent){ + int rc; + MemPage *pNew; + Pgno pgnoNew; + u8 *pCell; + int szCell; + CellInfo info; + BtShared *pBt = pPage->pBt; + int parentIdx = pParent->nCell; /* pParent new divider cell index */ + int parentSize; /* Size of new divider cell */ + u8 parentCell[64]; /* Space for the new divider cell */ + + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + + /* Allocate a new page. Insert the overflow cell from pPage + ** into it. Then remove the overflow cell from pPage. + */ + rc = allocateBtreePage(pBt, &pNew, &pgnoNew, 0, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + pCell = pPage->aOvfl[0].pCell; + szCell = cellSizePtr(pPage, pCell); + zeroPage(pNew, pPage->aData[0]); + assemblePage(pNew, 1, &pCell, &szCell); + pPage->nOverflow = 0; + + /* Set the parent of the newly allocated page to pParent. */ + pNew->pParent = pParent; + sqlite3PagerRef(pParent->pDbPage); + + /* pPage is currently the right-child of pParent. Change this + ** so that the right-child is the new page allocated above and + ** pPage is the next-to-right child. + */ + assert( pPage->nCell>0 ); + pCell = findCell(pPage, pPage->nCell-1); + sqlite3BtreeParseCellPtr(pPage, pCell, &info); + rc = fillInCell(pParent, parentCell, 0, info.nKey, 0, 0, 0, &parentSize); + if( rc!=SQLITE_OK ){ + return rc; + } + assert( parentSize<64 ); + rc = insertCell(pParent, parentIdx, parentCell, parentSize, 0, 4); + if( rc!=SQLITE_OK ){ + return rc; + } + put4byte(findOverflowCell(pParent,parentIdx), pPage->pgno); + put4byte(&pParent->aData[pParent->hdrOffset+8], pgnoNew); + +#ifndef SQLITE_OMIT_AUTOVACUUM + /* If this is an auto-vacuum database, update the pointer map + ** with entries for the new page, and any pointer from the + ** cell on the page to an overflow page. + */ + if( pBt->autoVacuum ){ + rc = ptrmapPut(pBt, pgnoNew, PTRMAP_BTREE, pParent->pgno); + if( rc==SQLITE_OK ){ + rc = ptrmapPutOvfl(pNew, 0); + } + if( rc!=SQLITE_OK ){ + releasePage(pNew); + return rc; + } + } +#endif + + /* Release the reference to the new page and balance the parent page, + ** in case the divider cell inserted caused it to become overfull. + */ + releasePage(pNew); + return balance(pParent, 0); +} +#endif /* SQLITE_OMIT_QUICKBALANCE */ + +/* +** This routine redistributes Cells on pPage and up to NN*2 siblings +** of pPage so that all pages have about the same amount of free space. +** Usually NN siblings on either side of pPage is used in the balancing, +** though more siblings might come from one side if pPage is the first +** or last child of its parent. If pPage has fewer than 2*NN siblings +** (something which can only happen if pPage is the root page or a +** child of root) then all available siblings participate in the balancing. +** +** The number of siblings of pPage might be increased or decreased by one or +** two in an effort to keep pages nearly full but not over full. The root page +** is special and is allowed to be nearly empty. If pPage is +** the root page, then the depth of the tree might be increased +** or decreased by one, as necessary, to keep the root page from being +** overfull or completely empty. +** +** Note that when this routine is called, some of the Cells on pPage +** might not actually be stored in pPage->aData[]. This can happen +** if the page is overfull. Part of the job of this routine is to +** make sure all Cells for pPage once again fit in pPage->aData[]. +** +** In the course of balancing the siblings of pPage, the parent of pPage +** might become overfull or underfull. If that happens, then this routine +** is called recursively on the parent. +** +** If this routine fails for any reason, it might leave the database +** in a corrupted state. So if this routine fails, the database should +** be rolled back. +*/ +static int balance_nonroot(MemPage *pPage){ + MemPage *pParent; /* The parent of pPage */ + BtShared *pBt; /* The whole database */ + int nCell = 0; /* Number of cells in apCell[] */ + int nMaxCells = 0; /* Allocated size of apCell, szCell, aFrom. */ + int nOld; /* Number of pages in apOld[] */ + int nNew; /* Number of pages in apNew[] */ + int nDiv; /* Number of cells in apDiv[] */ + int i, j, k; /* Loop counters */ + int idx; /* Index of pPage in pParent->aCell[] */ + int nxDiv; /* Next divider slot in pParent->aCell[] */ + int rc; /* The return code */ + int leafCorrection; /* 4 if pPage is a leaf. 0 if not */ + int leafData; /* True if pPage is a leaf of a LEAFDATA tree */ + int usableSpace; /* Bytes in pPage beyond the header */ + int pageFlags; /* Value of pPage->aData[0] */ + int subtotal; /* Subtotal of bytes in cells on one page */ + int iSpace = 0; /* First unused byte of aSpace[] */ + MemPage *apOld[NB]; /* pPage and up to two siblings */ + Pgno pgnoOld[NB]; /* Page numbers for each page in apOld[] */ + MemPage *apCopy[NB]; /* Private copies of apOld[] pages */ + MemPage *apNew[NB+2]; /* pPage and up to NB siblings after balancing */ + Pgno pgnoNew[NB+2]; /* Page numbers for each page in apNew[] */ + u8 *apDiv[NB]; /* Divider cells in pParent */ + int cntNew[NB+2]; /* Index in aCell[] of cell after i-th page */ + int szNew[NB+2]; /* Combined size of cells place on i-th page */ + u8 **apCell = 0; /* All cells begin balanced */ + int *szCell; /* Local size of all cells in apCell[] */ + u8 *aCopy[NB]; /* Space for holding data of apCopy[] */ + u8 *aSpace; /* Space to hold copies of dividers cells */ +#ifndef SQLITE_OMIT_AUTOVACUUM + u8 *aFrom = 0; +#endif + + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + + /* + ** Find the parent page. + */ + assert( pPage->isInit ); + assert( sqlite3PagerIswriteable(pPage->pDbPage) || pPage->nOverflow==1 ); + pBt = pPage->pBt; + pParent = pPage->pParent; + assert( pParent ); + if( SQLITE_OK!=(rc = sqlite3PagerWrite(pParent->pDbPage)) ){ + return rc; + } + TRACE(("BALANCE: begin page %d child of %d\n", pPage->pgno, pParent->pgno)); + +#ifndef SQLITE_OMIT_QUICKBALANCE + /* + ** A special case: If a new entry has just been inserted into a + ** table (that is, a btree with integer keys and all data at the leaves) + ** and the new entry is the right-most entry in the tree (it has the + ** largest key) then use the special balance_quick() routine for + ** balancing. balance_quick() is much faster and results in a tighter + ** packing of data in the common case. + */ + if( pPage->leaf && + pPage->intKey && + pPage->leafData && + pPage->nOverflow==1 && + pPage->aOvfl[0].idx==pPage->nCell && + pPage->pParent->pgno!=1 && + get4byte(&pParent->aData[pParent->hdrOffset+8])==pPage->pgno + ){ + /* + ** TODO: Check the siblings to the left of pPage. It may be that + ** they are not full and no new page is required. + */ + return balance_quick(pPage, pParent); + } +#endif + + if( SQLITE_OK!=(rc = sqlite3PagerWrite(pPage->pDbPage)) ){ + return rc; + } + + /* + ** Find the cell in the parent page whose left child points back + ** to pPage. The "idx" variable is the index of that cell. If pPage + ** is the rightmost child of pParent then set idx to pParent->nCell + */ + if( pParent->idxShift ){ + Pgno pgno; + pgno = pPage->pgno; + assert( pgno==sqlite3PagerPagenumber(pPage->pDbPage) ); + for(idx=0; idxnCell; idx++){ + if( get4byte(findCell(pParent, idx))==pgno ){ + break; + } + } + assert( idxnCell + || get4byte(&pParent->aData[pParent->hdrOffset+8])==pgno ); + }else{ + idx = pPage->idxParent; + } + + /* + ** Initialize variables so that it will be safe to jump + ** directly to balance_cleanup at any moment. + */ + nOld = nNew = 0; + sqlite3PagerRef(pParent->pDbPage); + + /* + ** Find sibling pages to pPage and the cells in pParent that divide + ** the siblings. An attempt is made to find NN siblings on either + ** side of pPage. More siblings are taken from one side, however, if + ** pPage there are fewer than NN siblings on the other side. If pParent + ** has NB or fewer children then all children of pParent are taken. + */ + nxDiv = idx - NN; + if( nxDiv + NB > pParent->nCell ){ + nxDiv = pParent->nCell - NB + 1; + } + if( nxDiv<0 ){ + nxDiv = 0; + } + nDiv = 0; + for(i=0, k=nxDiv; inCell ){ + apDiv[i] = findCell(pParent, k); + nDiv++; + assert( !pParent->leaf ); + pgnoOld[i] = get4byte(apDiv[i]); + }else if( k==pParent->nCell ){ + pgnoOld[i] = get4byte(&pParent->aData[pParent->hdrOffset+8]); + }else{ + break; + } + rc = getAndInitPage(pBt, pgnoOld[i], &apOld[i], pParent); + if( rc ) goto balance_cleanup; + apOld[i]->idxParent = k; + apCopy[i] = 0; + assert( i==nOld ); + nOld++; + nMaxCells += 1+apOld[i]->nCell+apOld[i]->nOverflow; + } + + /* Make nMaxCells a multiple of 2 in order to preserve 8-byte + ** alignment */ + nMaxCells = (nMaxCells + 1)&~1; + + /* + ** Allocate space for memory structures + */ + apCell = (u8**)sqlite3_malloc( + nMaxCells*sizeof(u8*) /* apCell */ + + nMaxCells*sizeof(int) /* szCell */ + + ROUND8(sizeof(MemPage))*NB /* aCopy */ + + pBt->pageSize*(5+NB) /* aSpace */ + + (ISAUTOVACUUM ? nMaxCells : 0) /* aFrom */ + ); + if( apCell==0 ){ + rc = SQLITE_NOMEM; + goto balance_cleanup; + } + szCell = (int*)&apCell[nMaxCells]; + aCopy[0] = (u8*)&szCell[nMaxCells]; + assert( ((aCopy[0] - (u8*)apCell) & 7)==0 ); /* 8-byte alignment required */ + for(i=1; ipageSize+ROUND8(sizeof(MemPage))]; + assert( ((aCopy[i] - (u8*)apCell) & 7)==0 ); /* 8-byte alignment required */ + } + aSpace = &aCopy[NB-1][pBt->pageSize+ROUND8(sizeof(MemPage))]; + assert( ((aSpace - (u8*)apCell) & 7)==0 ); /* 8-byte alignment required */ +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum ){ + aFrom = &aSpace[5*pBt->pageSize]; + } +#endif + + /* + ** Make copies of the content of pPage and its siblings into aOld[]. + ** The rest of this function will use data from the copies rather + ** that the original pages since the original pages will be in the + ** process of being overwritten. + */ + for(i=0; iaData = (u8*)(void*)&p[1]; + memcpy(p->aData, apOld[i]->aData, pBt->pageSize); + } + + /* + ** Load pointers to all cells on sibling pages and the divider cells + ** into the local apCell[] array. Make copies of the divider cells + ** into space obtained form aSpace[] and remove the the divider Cells + ** from pParent. + ** + ** If the siblings are on leaf pages, then the child pointers of the + ** divider cells are stripped from the cells before they are copied + ** into aSpace[]. In this way, all cells in apCell[] are without + ** child pointers. If siblings are not leaves, then all cell in + ** apCell[] include child pointers. Either way, all cells in apCell[] + ** are alike. + ** + ** leafCorrection: 4 if pPage is a leaf. 0 if pPage is not a leaf. + ** leafData: 1 if pPage holds key+data and pParent holds only keys. + */ + nCell = 0; + leafCorrection = pPage->leaf*4; + leafData = pPage->leafData && pPage->leaf; + for(i=0; inCell+pOld->nOverflow; + for(j=0; jautoVacuum ){ + int a; + aFrom[nCell] = i; + for(a=0; anOverflow; a++){ + if( pOld->aOvfl[a].pCell==apCell[nCell] ){ + aFrom[nCell] = 0xFF; + break; + } + } + } +#endif + nCell++; + } + if( ipageSize*5 ); + memcpy(pTemp, apDiv[i], sz); + apCell[nCell] = pTemp+leafCorrection; +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum ){ + aFrom[nCell] = 0xFF; + } +#endif + dropCell(pParent, nxDiv, sz); + szCell[nCell] -= leafCorrection; + assert( get4byte(pTemp)==pgnoOld[i] ); + if( !pOld->leaf ){ + assert( leafCorrection==0 ); + /* The right pointer of the child page pOld becomes the left + ** pointer of the divider cell */ + memcpy(apCell[nCell], &pOld->aData[pOld->hdrOffset+8], 4); + }else{ + assert( leafCorrection==4 ); + if( szCell[nCell]<4 ){ + /* Do not allow any cells smaller than 4 bytes. */ + szCell[nCell] = 4; + } + } + nCell++; + } + } + } + + /* + ** Figure out the number of pages needed to hold all nCell cells. + ** Store this number in "k". Also compute szNew[] which is the total + ** size of all cells on the i-th page and cntNew[] which is the index + ** in apCell[] of the cell that divides page i from page i+1. + ** cntNew[k] should equal nCell. + ** + ** Values computed by this block: + ** + ** k: The total number of sibling pages + ** szNew[i]: Spaced used on the i-th sibling page. + ** cntNew[i]: Index in apCell[] and szCell[] for the first cell to + ** the right of the i-th sibling page. + ** usableSpace: Number of bytes of space available on each sibling. + ** + */ + usableSpace = pBt->usableSize - 12 + leafCorrection; + for(subtotal=k=i=0; i usableSpace ){ + szNew[k] = subtotal - szCell[i]; + cntNew[k] = i; + if( leafData ){ i--; } + subtotal = 0; + k++; + } + } + szNew[k] = subtotal; + cntNew[k] = nCell; + k++; + + /* + ** The packing computed by the previous block is biased toward the siblings + ** on the left side. The left siblings are always nearly full, while the + ** right-most sibling might be nearly empty. This block of code attempts + ** to adjust the packing of siblings to get a better balance. + ** + ** This adjustment is more than an optimization. The packing above might + ** be so out of balance as to be illegal. For example, the right-most + ** sibling might be completely empty. This adjustment is not optional. + */ + for(i=k-1; i>0; i--){ + int szRight = szNew[i]; /* Size of sibling on the right */ + int szLeft = szNew[i-1]; /* Size of sibling on the left */ + int r; /* Index of right-most cell in left sibling */ + int d; /* Index of first cell to the left of right sibling */ + + r = cntNew[i-1] - 1; + d = r + 1 - leafData; + assert( d0) or we are the + ** a virtual root page. A virtual root page is when the real root + ** page is page 1 and we are the only child of that page. + */ + assert( cntNew[0]>0 || (pParent->pgno==1 && pParent->nCell==0) ); + + /* + ** Allocate k new pages. Reuse old pages where possible. + */ + assert( pPage->pgno>1 ); + pageFlags = pPage->aData[0]; + for(i=0; ipDbPage); + nNew++; + if( rc ) goto balance_cleanup; + }else{ + assert( i>0 ); + rc = allocateBtreePage(pBt, &pNew, &pgnoNew[i], pgnoNew[i-1], 0); + if( rc ) goto balance_cleanup; + apNew[i] = pNew; + nNew++; + } + zeroPage(pNew, pageFlags); + } + + /* Free any old pages that were not reused as new pages. + */ + while( ii ){ + int t; + MemPage *pT; + t = pgnoNew[i]; + pT = apNew[i]; + pgnoNew[i] = pgnoNew[minI]; + apNew[i] = apNew[minI]; + pgnoNew[minI] = t; + apNew[minI] = pT; + } + } + TRACE(("BALANCE: old: %d %d %d new: %d(%d) %d(%d) %d(%d) %d(%d) %d(%d)\n", + pgnoOld[0], + nOld>=2 ? pgnoOld[1] : 0, + nOld>=3 ? pgnoOld[2] : 0, + pgnoNew[0], szNew[0], + nNew>=2 ? pgnoNew[1] : 0, nNew>=2 ? szNew[1] : 0, + nNew>=3 ? pgnoNew[2] : 0, nNew>=3 ? szNew[2] : 0, + nNew>=4 ? pgnoNew[3] : 0, nNew>=4 ? szNew[3] : 0, + nNew>=5 ? pgnoNew[4] : 0, nNew>=5 ? szNew[4] : 0)); + + /* + ** Evenly distribute the data in apCell[] across the new pages. + ** Insert divider cells into pParent as necessary. + */ + j = 0; + for(i=0; ipgno==pgnoNew[i] ); + assemblePage(pNew, cntNew[i]-j, &apCell[j], &szCell[j]); + assert( pNew->nCell>0 || (nNew==1 && cntNew[0]==0) ); + assert( pNew->nOverflow==0 ); + +#ifndef SQLITE_OMIT_AUTOVACUUM + /* If this is an auto-vacuum database, update the pointer map entries + ** that point to the siblings that were rearranged. These can be: left + ** children of cells, the right-child of the page, or overflow pages + ** pointed to by cells. + */ + if( pBt->autoVacuum ){ + for(k=j; kpgno!=pNew->pgno ){ + rc = ptrmapPutOvfl(pNew, k-j); + if( rc!=SQLITE_OK ){ + goto balance_cleanup; + } + } + } + } +#endif + + j = cntNew[i]; + + /* If the sibling page assembled above was not the right-most sibling, + ** insert a divider cell into the parent page. + */ + if( ileaf ){ + memcpy(&pNew->aData[8], pCell, 4); + pTemp = 0; + }else if( leafData ){ + /* If the tree is a leaf-data tree, and the siblings are leaves, + ** then there is no divider cell in apCell[]. Instead, the divider + ** cell consists of the integer key for the right-most cell of + ** the sibling-page assembled above only. + */ + CellInfo info; + j--; + sqlite3BtreeParseCellPtr(pNew, apCell[j], &info); + pCell = &aSpace[iSpace]; + fillInCell(pParent, pCell, 0, info.nKey, 0, 0, 0, &sz); + iSpace += sz; + assert( iSpace<=pBt->pageSize*5 ); + pTemp = 0; + }else{ + pCell -= 4; + pTemp = &aSpace[iSpace]; + iSpace += sz; + assert( iSpace<=pBt->pageSize*5 ); + /* Obscure case for non-leaf-data trees: If the cell at pCell was + ** previously stored on a leaf node, and its reported size was 4 + ** bytes, then it may actually be smaller than this + ** (see sqlite3BtreeParseCellPtr(), 4 bytes is the minimum size of + ** any cell). But it is important to pass the correct size to + ** insertCell(), so reparse the cell now. + ** + ** Note that this can never happen in an SQLite data file, as all + ** cells are at least 4 bytes. It only happens in b-trees used + ** to evaluate "IN (SELECT ...)" and similar clauses. + */ + if( szCell[j]==4 ){ + assert(leafCorrection==4); + sz = cellSizePtr(pParent, pCell); + } + } + rc = insertCell(pParent, nxDiv, pCell, sz, pTemp, 4); + if( rc!=SQLITE_OK ) goto balance_cleanup; + put4byte(findOverflowCell(pParent,nxDiv), pNew->pgno); +#ifndef SQLITE_OMIT_AUTOVACUUM + /* If this is an auto-vacuum database, and not a leaf-data tree, + ** then update the pointer map with an entry for the overflow page + ** that the cell just inserted points to (if any). + */ + if( pBt->autoVacuum && !leafData ){ + rc = ptrmapPutOvfl(pParent, nxDiv); + if( rc!=SQLITE_OK ){ + goto balance_cleanup; + } + } +#endif + j++; + nxDiv++; + } + } + assert( j==nCell ); + assert( nOld>0 ); + assert( nNew>0 ); + if( (pageFlags & PTF_LEAF)==0 ){ + memcpy(&apNew[nNew-1]->aData[8], &apCopy[nOld-1]->aData[8], 4); + } + if( nxDiv==pParent->nCell+pParent->nOverflow ){ + /* Right-most sibling is the right-most child of pParent */ + put4byte(&pParent->aData[pParent->hdrOffset+8], pgnoNew[nNew-1]); + }else{ + /* Right-most sibling is the left child of the first entry in pParent + ** past the right-most divider entry */ + put4byte(findOverflowCell(pParent, nxDiv), pgnoNew[nNew-1]); + } + + /* + ** Reparent children of all cells. + */ + for(i=0; iisInit ); + rc = balance(pParent, 0); + + /* + ** Cleanup before returning. + */ +balance_cleanup: + sqlite3_free(apCell); + for(i=0; ipgno, nOld, nNew, nCell)); + return rc; +} + +/* +** This routine is called for the root page of a btree when the root +** page contains no cells. This is an opportunity to make the tree +** shallower by one level. +*/ +static int balance_shallower(MemPage *pPage){ + MemPage *pChild; /* The only child page of pPage */ + Pgno pgnoChild; /* Page number for pChild */ + int rc = SQLITE_OK; /* Return code from subprocedures */ + BtShared *pBt; /* The main BTree structure */ + int mxCellPerPage; /* Maximum number of cells per page */ + u8 **apCell; /* All cells from pages being balanced */ + int *szCell; /* Local size of all cells */ + + assert( pPage->pParent==0 ); + assert( pPage->nCell==0 ); + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + pBt = pPage->pBt; + mxCellPerPage = MX_CELL(pBt); + apCell = (u8**)sqlite3_malloc( mxCellPerPage*(sizeof(u8*)+sizeof(int)) ); + if( apCell==0 ) return SQLITE_NOMEM; + szCell = (int*)&apCell[mxCellPerPage]; + if( pPage->leaf ){ + /* The table is completely empty */ + TRACE(("BALANCE: empty table %d\n", pPage->pgno)); + }else{ + /* The root page is empty but has one child. Transfer the + ** information from that one child into the root page if it + ** will fit. This reduces the depth of the tree by one. + ** + ** If the root page is page 1, it has less space available than + ** its child (due to the 100 byte header that occurs at the beginning + ** of the database fle), so it might not be able to hold all of the + ** information currently contained in the child. If this is the + ** case, then do not do the transfer. Leave page 1 empty except + ** for the right-pointer to the child page. The child page becomes + ** the virtual root of the tree. + */ + pgnoChild = get4byte(&pPage->aData[pPage->hdrOffset+8]); + assert( pgnoChild>0 ); + assert( pgnoChild<=sqlite3PagerPagecount(pPage->pBt->pPager) ); + rc = sqlite3BtreeGetPage(pPage->pBt, pgnoChild, &pChild, 0); + if( rc ) goto end_shallow_balance; + if( pPage->pgno==1 ){ + rc = sqlite3BtreeInitPage(pChild, pPage); + if( rc ) goto end_shallow_balance; + assert( pChild->nOverflow==0 ); + if( pChild->nFree>=100 ){ + /* The child information will fit on the root page, so do the + ** copy */ + int i; + zeroPage(pPage, pChild->aData[0]); + for(i=0; inCell; i++){ + apCell[i] = findCell(pChild,i); + szCell[i] = cellSizePtr(pChild, apCell[i]); + } + assemblePage(pPage, pChild->nCell, apCell, szCell); + /* Copy the right-pointer of the child to the parent. */ + put4byte(&pPage->aData[pPage->hdrOffset+8], + get4byte(&pChild->aData[pChild->hdrOffset+8])); + freePage(pChild); + TRACE(("BALANCE: child %d transfer to page 1\n", pChild->pgno)); + }else{ + /* The child has more information that will fit on the root. + ** The tree is already balanced. Do nothing. */ + TRACE(("BALANCE: child %d will not fit on page 1\n", pChild->pgno)); + } + }else{ + memcpy(pPage->aData, pChild->aData, pPage->pBt->usableSize); + pPage->isInit = 0; + pPage->pParent = 0; + rc = sqlite3BtreeInitPage(pPage, 0); + assert( rc==SQLITE_OK ); + freePage(pChild); + TRACE(("BALANCE: transfer child %d into root %d\n", + pChild->pgno, pPage->pgno)); + } + rc = reparentChildPages(pPage); + assert( pPage->nOverflow==0 ); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum ){ + int i; + for(i=0; inCell; i++){ + rc = ptrmapPutOvfl(pPage, i); + if( rc!=SQLITE_OK ){ + goto end_shallow_balance; + } + } + } +#endif + releasePage(pChild); + } +end_shallow_balance: + sqlite3_free(apCell); + return rc; +} + + +/* +** The root page is overfull +** +** When this happens, Create a new child page and copy the +** contents of the root into the child. Then make the root +** page an empty page with rightChild pointing to the new +** child. Finally, call balance_internal() on the new child +** to cause it to split. +*/ +static int balance_deeper(MemPage *pPage){ + int rc; /* Return value from subprocedures */ + MemPage *pChild; /* Pointer to a new child page */ + Pgno pgnoChild; /* Page number of the new child page */ + BtShared *pBt; /* The BTree */ + int usableSize; /* Total usable size of a page */ + u8 *data; /* Content of the parent page */ + u8 *cdata; /* Content of the child page */ + int hdr; /* Offset to page header in parent */ + int brk; /* Offset to content of first cell in parent */ + + assert( pPage->pParent==0 ); + assert( pPage->nOverflow>0 ); + pBt = pPage->pBt; + assert( sqlite3_mutex_held(pBt->mutex) ); + rc = allocateBtreePage(pBt, &pChild, &pgnoChild, pPage->pgno, 0); + if( rc ) return rc; + assert( sqlite3PagerIswriteable(pChild->pDbPage) ); + usableSize = pBt->usableSize; + data = pPage->aData; + hdr = pPage->hdrOffset; + brk = get2byte(&data[hdr+5]); + cdata = pChild->aData; + memcpy(cdata, &data[hdr], pPage->cellOffset+2*pPage->nCell-hdr); + memcpy(&cdata[brk], &data[brk], usableSize-brk); + assert( pChild->isInit==0 ); + rc = sqlite3BtreeInitPage(pChild, pPage); + if( rc ) goto balancedeeper_out; + memcpy(pChild->aOvfl, pPage->aOvfl, pPage->nOverflow*sizeof(pPage->aOvfl[0])); + pChild->nOverflow = pPage->nOverflow; + if( pChild->nOverflow ){ + pChild->nFree = 0; + } + assert( pChild->nCell==pPage->nCell ); + zeroPage(pPage, pChild->aData[0] & ~PTF_LEAF); + put4byte(&pPage->aData[pPage->hdrOffset+8], pgnoChild); + TRACE(("BALANCE: copy root %d into %d\n", pPage->pgno, pChild->pgno)); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum ){ + int i; + rc = ptrmapPut(pBt, pChild->pgno, PTRMAP_BTREE, pPage->pgno); + if( rc ) goto balancedeeper_out; + for(i=0; inCell; i++){ + rc = ptrmapPutOvfl(pChild, i); + if( rc!=SQLITE_OK ){ + return rc; + } + } + } +#endif + rc = balance_nonroot(pChild); + +balancedeeper_out: + releasePage(pChild); + return rc; +} + +/* +** Decide if the page pPage needs to be balanced. If balancing is +** required, call the appropriate balancing routine. +*/ +static int balance(MemPage *pPage, int insert){ + int rc = SQLITE_OK; + assert( sqlite3_mutex_held(pPage->pBt->mutex) ); + if( pPage->pParent==0 ){ + rc = sqlite3PagerWrite(pPage->pDbPage); + if( rc==SQLITE_OK && pPage->nOverflow>0 ){ + rc = balance_deeper(pPage); + } + if( rc==SQLITE_OK && pPage->nCell==0 ){ + rc = balance_shallower(pPage); + } + }else{ + if( pPage->nOverflow>0 || + (!insert && pPage->nFree>pPage->pBt->usableSize*2/3) ){ + rc = balance_nonroot(pPage); + } + } + return rc; +} + +/* +** This routine checks all cursors that point to table pgnoRoot. +** If any of those cursors were opened with wrFlag==0 in a different +** database connection (a database connection that shares the pager +** cache with the current connection) and that other connection +** is not in the ReadUncommmitted state, then this routine returns +** SQLITE_LOCKED. +** +** In addition to checking for read-locks (where a read-lock +** means a cursor opened with wrFlag==0) this routine also moves +** all write cursors so that they are pointing to the +** first Cell on the root page. This is necessary because an insert +** or delete might change the number of cells on a page or delete +** a page entirely and we do not want to leave any cursors +** pointing to non-existant pages or cells. +*/ +static int checkReadLocks(Btree *pBtree, Pgno pgnoRoot, BtCursor *pExclude){ + BtCursor *p; + BtShared *pBt = pBtree->pBt; + sqlite3 *db = pBtree->db; + assert( sqlite3BtreeHoldsMutex(pBtree) ); + for(p=pBt->pCursor; p; p=p->pNext){ + if( p==pExclude ) continue; + if( p->eState!=CURSOR_VALID ) continue; + if( p->pgnoRoot!=pgnoRoot ) continue; + if( p->wrFlag==0 ){ + sqlite3 *dbOther = p->pBtree->db; + if( dbOther==0 || + (dbOther!=db && (dbOther->flags & SQLITE_ReadUncommitted)==0) ){ + return SQLITE_LOCKED; + } + }else if( p->pPage->pgno!=p->pgnoRoot ){ + moveToRoot(p); + } + } + return SQLITE_OK; +} + +/* +** Insert a new record into the BTree. The key is given by (pKey,nKey) +** and the data is given by (pData,nData). The cursor is used only to +** define what table the record should be inserted into. The cursor +** is left pointing at a random location. +** +** For an INTKEY table, only the nKey value of the key is used. pKey is +** ignored. For a ZERODATA table, the pData and nData are both ignored. +*/ +int sqlite3BtreeInsert( + BtCursor *pCur, /* Insert data into the table of this cursor */ + const void *pKey, i64 nKey, /* The key of the new record */ + const void *pData, int nData, /* The data of the new record */ + int nZero, /* Number of extra 0 bytes to append to data */ + int appendBias /* True if this is likely an append */ +){ + int rc; + int loc; + int szNew; + MemPage *pPage; + Btree *p = pCur->pBtree; + BtShared *pBt = p->pBt; + unsigned char *oldCell; + unsigned char *newCell = 0; + + assert( cursorHoldsMutex(pCur) ); + if( pBt->inTransaction!=TRANS_WRITE ){ + /* Must start a transaction before doing an insert */ + rc = pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR; + return rc; + } + assert( !pBt->readOnly ); + if( !pCur->wrFlag ){ + return SQLITE_PERM; /* Cursor not open for writing */ + } + if( checkReadLocks(pCur->pBtree, pCur->pgnoRoot, pCur) ){ + return SQLITE_LOCKED; /* The table pCur points to has a read lock */ + } + if( pCur->eState==CURSOR_FAULT ){ + return pCur->skip; + } + + /* Save the positions of any other cursors open on this table */ + clearCursorPosition(pCur); + if( + SQLITE_OK!=(rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur)) || + SQLITE_OK!=(rc = sqlite3BtreeMoveto(pCur, pKey, nKey, appendBias, &loc)) + ){ + return rc; + } + + pPage = pCur->pPage; + assert( pPage->intKey || nKey>=0 ); + assert( pPage->leaf || !pPage->leafData ); + TRACE(("INSERT: table=%d nkey=%lld ndata=%d page=%d %s\n", + pCur->pgnoRoot, nKey, nData, pPage->pgno, + loc==0 ? "overwrite" : "new entry")); + assert( pPage->isInit ); + newCell = (unsigned char*)sqlite3_malloc( MX_CELL_SIZE(pBt) ); + if( newCell==0 ) return SQLITE_NOMEM; + rc = fillInCell(pPage, newCell, pKey, nKey, pData, nData, nZero, &szNew); + if( rc ) goto end_insert; + assert( szNew==cellSizePtr(pPage, newCell) ); + assert( szNew<=MX_CELL_SIZE(pBt) ); + if( loc==0 && CURSOR_VALID==pCur->eState ){ + int szOld; + assert( pCur->idx>=0 && pCur->idxnCell ); + rc = sqlite3PagerWrite(pPage->pDbPage); + if( rc ){ + goto end_insert; + } + oldCell = findCell(pPage, pCur->idx); + if( !pPage->leaf ){ + memcpy(newCell, oldCell, 4); + } + szOld = cellSizePtr(pPage, oldCell); + rc = clearCell(pPage, oldCell); + if( rc ) goto end_insert; + dropCell(pPage, pCur->idx, szOld); + }else if( loc<0 && pPage->nCell>0 ){ + assert( pPage->leaf ); + pCur->idx++; + pCur->info.nSize = 0; + }else{ + assert( pPage->leaf ); + } + rc = insertCell(pPage, pCur->idx, newCell, szNew, 0, 0); + if( rc!=SQLITE_OK ) goto end_insert; + rc = balance(pPage, 1); + /* sqlite3BtreePageDump(pCur->pBt, pCur->pgnoRoot, 1); */ + /* fflush(stdout); */ + if( rc==SQLITE_OK ){ + moveToRoot(pCur); + } +end_insert: + sqlite3_free(newCell); + return rc; +} + +/* +** Delete the entry that the cursor is pointing to. The cursor +** is left pointing at a random location. +*/ +int sqlite3BtreeDelete(BtCursor *pCur){ + MemPage *pPage = pCur->pPage; + unsigned char *pCell; + int rc; + Pgno pgnoChild = 0; + Btree *p = pCur->pBtree; + BtShared *pBt = p->pBt; + + assert( cursorHoldsMutex(pCur) ); + assert( pPage->isInit ); + if( pBt->inTransaction!=TRANS_WRITE ){ + /* Must start a transaction before doing a delete */ + rc = pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR; + return rc; + } + assert( !pBt->readOnly ); + if( pCur->eState==CURSOR_FAULT ){ + return pCur->skip; + } + if( pCur->idx >= pPage->nCell ){ + return SQLITE_ERROR; /* The cursor is not pointing to anything */ + } + if( !pCur->wrFlag ){ + return SQLITE_PERM; /* Did not open this cursor for writing */ + } + if( checkReadLocks(pCur->pBtree, pCur->pgnoRoot, pCur) ){ + return SQLITE_LOCKED; /* The table pCur points to has a read lock */ + } + + /* Restore the current cursor position (a no-op if the cursor is not in + ** CURSOR_REQUIRESEEK state) and save the positions of any other cursors + ** open on the same table. Then call sqlite3PagerWrite() on the page + ** that the entry will be deleted from. + */ + if( + (rc = restoreOrClearCursorPosition(pCur))!=0 || + (rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur))!=0 || + (rc = sqlite3PagerWrite(pPage->pDbPage))!=0 + ){ + return rc; + } + + /* Locate the cell within its page and leave pCell pointing to the + ** data. The clearCell() call frees any overflow pages associated with the + ** cell. The cell itself is still intact. + */ + pCell = findCell(pPage, pCur->idx); + if( !pPage->leaf ){ + pgnoChild = get4byte(pCell); + } + rc = clearCell(pPage, pCell); + if( rc ){ + return rc; + } + + if( !pPage->leaf ){ + /* + ** The entry we are about to delete is not a leaf so if we do not + ** do something we will leave a hole on an internal page. + ** We have to fill the hole by moving in a cell from a leaf. The + ** next Cell after the one to be deleted is guaranteed to exist and + ** to be a leaf so we can use it. + */ + BtCursor leafCur; + unsigned char *pNext; + int szNext; /* The compiler warning is wrong: szNext is always + ** initialized before use. Adding an extra initialization + ** to silence the compiler slows down the code. */ + int notUsed; + unsigned char *tempCell = 0; + assert( !pPage->leafData ); + sqlite3BtreeGetTempCursor(pCur, &leafCur); + rc = sqlite3BtreeNext(&leafCur, ¬Used); + if( rc==SQLITE_OK ){ + rc = sqlite3PagerWrite(leafCur.pPage->pDbPage); + } + if( rc==SQLITE_OK ){ + TRACE(("DELETE: table=%d delete internal from %d replace from leaf %d\n", + pCur->pgnoRoot, pPage->pgno, leafCur.pPage->pgno)); + dropCell(pPage, pCur->idx, cellSizePtr(pPage, pCell)); + pNext = findCell(leafCur.pPage, leafCur.idx); + szNext = cellSizePtr(leafCur.pPage, pNext); + assert( MX_CELL_SIZE(pBt)>=szNext+4 ); + tempCell = (unsigned char*)sqlite3_malloc( MX_CELL_SIZE(pBt) ); + if( tempCell==0 ){ + rc = SQLITE_NOMEM; + } + } + if( rc==SQLITE_OK ){ + rc = insertCell(pPage, pCur->idx, pNext-4, szNext+4, tempCell, 0); + } + if( rc==SQLITE_OK ){ + put4byte(findOverflowCell(pPage, pCur->idx), pgnoChild); + rc = balance(pPage, 0); + } + if( rc==SQLITE_OK ){ + dropCell(leafCur.pPage, leafCur.idx, szNext); + rc = balance(leafCur.pPage, 0); + } + sqlite3_free(tempCell); + sqlite3BtreeReleaseTempCursor(&leafCur); + }else{ + TRACE(("DELETE: table=%d delete from leaf %d\n", + pCur->pgnoRoot, pPage->pgno)); + dropCell(pPage, pCur->idx, cellSizePtr(pPage, pCell)); + rc = balance(pPage, 0); + } + if( rc==SQLITE_OK ){ + moveToRoot(pCur); + } + return rc; +} + +/* +** Create a new BTree table. Write into *piTable the page +** number for the root page of the new table. +** +** The type of type is determined by the flags parameter. Only the +** following values of flags are currently in use. Other values for +** flags might not work: +** +** BTREE_INTKEY|BTREE_LEAFDATA Used for SQL tables with rowid keys +** BTREE_ZERODATA Used for SQL indices +*/ +static int btreeCreateTable(Btree *p, int *piTable, int flags){ + BtShared *pBt = p->pBt; + MemPage *pRoot; + Pgno pgnoRoot; + int rc; + + assert( sqlite3BtreeHoldsMutex(p) ); + if( pBt->inTransaction!=TRANS_WRITE ){ + /* Must start a transaction first */ + rc = pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR; + return rc; + } + assert( !pBt->readOnly ); + +#ifdef SQLITE_OMIT_AUTOVACUUM + rc = allocateBtreePage(pBt, &pRoot, &pgnoRoot, 1, 0); + if( rc ){ + return rc; + } +#else + if( pBt->autoVacuum ){ + Pgno pgnoMove; /* Move a page here to make room for the root-page */ + MemPage *pPageMove; /* The page to move to. */ + + /* Creating a new table may probably require moving an existing database + ** to make room for the new tables root page. In case this page turns + ** out to be an overflow page, delete all overflow page-map caches + ** held by open cursors. + */ + invalidateAllOverflowCache(pBt); + + /* Read the value of meta[3] from the database to determine where the + ** root page of the new table should go. meta[3] is the largest root-page + ** created so far, so the new root-page is (meta[3]+1). + */ + rc = sqlite3BtreeGetMeta(p, 4, &pgnoRoot); + if( rc!=SQLITE_OK ){ + return rc; + } + pgnoRoot++; + + /* The new root-page may not be allocated on a pointer-map page, or the + ** PENDING_BYTE page. + */ + if( pgnoRoot==PTRMAP_PAGENO(pBt, pgnoRoot) || + pgnoRoot==PENDING_BYTE_PAGE(pBt) ){ + pgnoRoot++; + } + assert( pgnoRoot>=3 ); + + /* Allocate a page. The page that currently resides at pgnoRoot will + ** be moved to the allocated page (unless the allocated page happens + ** to reside at pgnoRoot). + */ + rc = allocateBtreePage(pBt, &pPageMove, &pgnoMove, pgnoRoot, 1); + if( rc!=SQLITE_OK ){ + return rc; + } + + if( pgnoMove!=pgnoRoot ){ + /* pgnoRoot is the page that will be used for the root-page of + ** the new table (assuming an error did not occur). But we were + ** allocated pgnoMove. If required (i.e. if it was not allocated + ** by extending the file), the current page at position pgnoMove + ** is already journaled. + */ + u8 eType; + Pgno iPtrPage; + + releasePage(pPageMove); + + /* Move the page currently at pgnoRoot to pgnoMove. */ + rc = sqlite3BtreeGetPage(pBt, pgnoRoot, &pRoot, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + rc = ptrmapGet(pBt, pgnoRoot, &eType, &iPtrPage); + if( rc!=SQLITE_OK || eType==PTRMAP_ROOTPAGE || eType==PTRMAP_FREEPAGE ){ + releasePage(pRoot); + return rc; + } + assert( eType!=PTRMAP_ROOTPAGE ); + assert( eType!=PTRMAP_FREEPAGE ); + rc = sqlite3PagerWrite(pRoot->pDbPage); + if( rc!=SQLITE_OK ){ + releasePage(pRoot); + return rc; + } + rc = relocatePage(pBt, pRoot, eType, iPtrPage, pgnoMove); + releasePage(pRoot); + + /* Obtain the page at pgnoRoot */ + if( rc!=SQLITE_OK ){ + return rc; + } + rc = sqlite3BtreeGetPage(pBt, pgnoRoot, &pRoot, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + rc = sqlite3PagerWrite(pRoot->pDbPage); + if( rc!=SQLITE_OK ){ + releasePage(pRoot); + return rc; + } + }else{ + pRoot = pPageMove; + } + + /* Update the pointer-map and meta-data with the new root-page number. */ + rc = ptrmapPut(pBt, pgnoRoot, PTRMAP_ROOTPAGE, 0); + if( rc ){ + releasePage(pRoot); + return rc; + } + rc = sqlite3BtreeUpdateMeta(p, 4, pgnoRoot); + if( rc ){ + releasePage(pRoot); + return rc; + } + + }else{ + rc = allocateBtreePage(pBt, &pRoot, &pgnoRoot, 1, 0); + if( rc ) return rc; + } +#endif + assert( sqlite3PagerIswriteable(pRoot->pDbPage) ); + zeroPage(pRoot, flags | PTF_LEAF); + sqlite3PagerUnref(pRoot->pDbPage); + *piTable = (int)pgnoRoot; + return SQLITE_OK; +} +int sqlite3BtreeCreateTable(Btree *p, int *piTable, int flags){ + int rc; + sqlite3BtreeEnter(p); + p->pBt->db = p->db; + rc = btreeCreateTable(p, piTable, flags); + sqlite3BtreeLeave(p); + return rc; +} + +/* +** Erase the given database page and all its children. Return +** the page to the freelist. +*/ +static int clearDatabasePage( + BtShared *pBt, /* The BTree that contains the table */ + Pgno pgno, /* Page number to clear */ + MemPage *pParent, /* Parent page. NULL for the root */ + int freePageFlag /* Deallocate page if true */ +){ + MemPage *pPage = 0; + int rc; + unsigned char *pCell; + int i; + + assert( sqlite3_mutex_held(pBt->mutex) ); + if( pgno>sqlite3PagerPagecount(pBt->pPager) ){ + return SQLITE_CORRUPT_BKPT; + } + + rc = getAndInitPage(pBt, pgno, &pPage, pParent); + if( rc ) goto cleardatabasepage_out; + for(i=0; inCell; i++){ + pCell = findCell(pPage, i); + if( !pPage->leaf ){ + rc = clearDatabasePage(pBt, get4byte(pCell), pPage->pParent, 1); + if( rc ) goto cleardatabasepage_out; + } + rc = clearCell(pPage, pCell); + if( rc ) goto cleardatabasepage_out; + } + if( !pPage->leaf ){ + rc = clearDatabasePage(pBt, get4byte(&pPage->aData[8]), pPage->pParent, 1); + if( rc ) goto cleardatabasepage_out; + } + if( freePageFlag ){ + rc = freePage(pPage); + }else if( (rc = sqlite3PagerWrite(pPage->pDbPage))==0 ){ + zeroPage(pPage, pPage->aData[0] | PTF_LEAF); + } + +cleardatabasepage_out: + releasePage(pPage); + return rc; +} + +/* +** Delete all information from a single table in the database. iTable is +** the page number of the root of the table. After this routine returns, +** the root page is empty, but still exists. +** +** This routine will fail with SQLITE_LOCKED if there are any open +** read cursors on the table. Open write cursors are moved to the +** root of the table. +*/ +int sqlite3BtreeClearTable(Btree *p, int iTable){ + int rc; + BtShared *pBt = p->pBt; + sqlite3BtreeEnter(p); + pBt->db = p->db; + if( p->inTrans!=TRANS_WRITE ){ + rc = pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR; + }else if( (rc = checkReadLocks(p, iTable, 0))!=SQLITE_OK ){ + /* nothing to do */ + }else if( SQLITE_OK!=(rc = saveAllCursors(pBt, iTable, 0)) ){ + /* nothing to do */ + }else{ + rc = clearDatabasePage(pBt, (Pgno)iTable, 0, 0); + } + sqlite3BtreeLeave(p); + return rc; +} + +/* +** Erase all information in a table and add the root of the table to +** the freelist. Except, the root of the principle table (the one on +** page 1) is never added to the freelist. +** +** This routine will fail with SQLITE_LOCKED if there are any open +** cursors on the table. +** +** If AUTOVACUUM is enabled and the page at iTable is not the last +** root page in the database file, then the last root page +** in the database file is moved into the slot formerly occupied by +** iTable and that last slot formerly occupied by the last root page +** is added to the freelist instead of iTable. In this say, all +** root pages are kept at the beginning of the database file, which +** is necessary for AUTOVACUUM to work right. *piMoved is set to the +** page number that used to be the last root page in the file before +** the move. If no page gets moved, *piMoved is set to 0. +** The last root page is recorded in meta[3] and the value of +** meta[3] is updated by this procedure. +*/ +static int btreeDropTable(Btree *p, int iTable, int *piMoved){ + int rc; + MemPage *pPage = 0; + BtShared *pBt = p->pBt; + + assert( sqlite3BtreeHoldsMutex(p) ); + if( p->inTrans!=TRANS_WRITE ){ + return pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR; + } + + /* It is illegal to drop a table if any cursors are open on the + ** database. This is because in auto-vacuum mode the backend may + ** need to move another root-page to fill a gap left by the deleted + ** root page. If an open cursor was using this page a problem would + ** occur. + */ + if( pBt->pCursor ){ + return SQLITE_LOCKED; + } + + rc = sqlite3BtreeGetPage(pBt, (Pgno)iTable, &pPage, 0); + if( rc ) return rc; + rc = sqlite3BtreeClearTable(p, iTable); + if( rc ){ + releasePage(pPage); + return rc; + } + + *piMoved = 0; + + if( iTable>1 ){ +#ifdef SQLITE_OMIT_AUTOVACUUM + rc = freePage(pPage); + releasePage(pPage); +#else + if( pBt->autoVacuum ){ + Pgno maxRootPgno; + rc = sqlite3BtreeGetMeta(p, 4, &maxRootPgno); + if( rc!=SQLITE_OK ){ + releasePage(pPage); + return rc; + } + + if( iTable==maxRootPgno ){ + /* If the table being dropped is the table with the largest root-page + ** number in the database, put the root page on the free list. + */ + rc = freePage(pPage); + releasePage(pPage); + if( rc!=SQLITE_OK ){ + return rc; + } + }else{ + /* The table being dropped does not have the largest root-page + ** number in the database. So move the page that does into the + ** gap left by the deleted root-page. + */ + MemPage *pMove; + releasePage(pPage); + rc = sqlite3BtreeGetPage(pBt, maxRootPgno, &pMove, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + rc = relocatePage(pBt, pMove, PTRMAP_ROOTPAGE, 0, iTable); + releasePage(pMove); + if( rc!=SQLITE_OK ){ + return rc; + } + rc = sqlite3BtreeGetPage(pBt, maxRootPgno, &pMove, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + rc = freePage(pMove); + releasePage(pMove); + if( rc!=SQLITE_OK ){ + return rc; + } + *piMoved = maxRootPgno; + } + + /* Set the new 'max-root-page' value in the database header. This + ** is the old value less one, less one more if that happens to + ** be a root-page number, less one again if that is the + ** PENDING_BYTE_PAGE. + */ + maxRootPgno--; + if( maxRootPgno==PENDING_BYTE_PAGE(pBt) ){ + maxRootPgno--; + } + if( maxRootPgno==PTRMAP_PAGENO(pBt, maxRootPgno) ){ + maxRootPgno--; + } + assert( maxRootPgno!=PENDING_BYTE_PAGE(pBt) ); + + rc = sqlite3BtreeUpdateMeta(p, 4, maxRootPgno); + }else{ + rc = freePage(pPage); + releasePage(pPage); + } +#endif + }else{ + /* If sqlite3BtreeDropTable was called on page 1. */ + zeroPage(pPage, PTF_INTKEY|PTF_LEAF ); + releasePage(pPage); + } + return rc; +} +int sqlite3BtreeDropTable(Btree *p, int iTable, int *piMoved){ + int rc; + sqlite3BtreeEnter(p); + p->pBt->db = p->db; + rc = btreeDropTable(p, iTable, piMoved); + sqlite3BtreeLeave(p); + return rc; +} + + +/* +** Read the meta-information out of a database file. Meta[0] +** is the number of free pages currently in the database. Meta[1] +** through meta[15] are available for use by higher layers. Meta[0] +** is read-only, the others are read/write. +** +** The schema layer numbers meta values differently. At the schema +** layer (and the SetCookie and ReadCookie opcodes) the number of +** free pages is not visible. So Cookie[0] is the same as Meta[1]. +*/ +int sqlite3BtreeGetMeta(Btree *p, int idx, u32 *pMeta){ + DbPage *pDbPage; + int rc; + unsigned char *pP1; + BtShared *pBt = p->pBt; + + sqlite3BtreeEnter(p); + pBt->db = p->db; + + /* Reading a meta-data value requires a read-lock on page 1 (and hence + ** the sqlite_master table. We grab this lock regardless of whether or + ** not the SQLITE_ReadUncommitted flag is set (the table rooted at page + ** 1 is treated as a special case by queryTableLock() and lockTable()). + */ + rc = queryTableLock(p, 1, READ_LOCK); + if( rc!=SQLITE_OK ){ + sqlite3BtreeLeave(p); + return rc; + } + + assert( idx>=0 && idx<=15 ); + rc = sqlite3PagerGet(pBt->pPager, 1, &pDbPage); + if( rc ){ + sqlite3BtreeLeave(p); + return rc; + } + pP1 = (unsigned char *)sqlite3PagerGetData(pDbPage); + *pMeta = get4byte(&pP1[36 + idx*4]); + sqlite3PagerUnref(pDbPage); + + /* If autovacuumed is disabled in this build but we are trying to + ** access an autovacuumed database, then make the database readonly. + */ +#ifdef SQLITE_OMIT_AUTOVACUUM + if( idx==4 && *pMeta>0 ) pBt->readOnly = 1; +#endif + + /* Grab the read-lock on page 1. */ + rc = lockTable(p, 1, READ_LOCK); + sqlite3BtreeLeave(p); + return rc; +} + +/* +** Write meta-information back into the database. Meta[0] is +** read-only and may not be written. +*/ +int sqlite3BtreeUpdateMeta(Btree *p, int idx, u32 iMeta){ + BtShared *pBt = p->pBt; + unsigned char *pP1; + int rc; + assert( idx>=1 && idx<=15 ); + sqlite3BtreeEnter(p); + pBt->db = p->db; + if( p->inTrans!=TRANS_WRITE ){ + rc = pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR; + }else{ + assert( pBt->pPage1!=0 ); + pP1 = pBt->pPage1->aData; + rc = sqlite3PagerWrite(pBt->pPage1->pDbPage); + if( rc==SQLITE_OK ){ + put4byte(&pP1[36 + idx*4], iMeta); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( idx==7 ){ + assert( pBt->autoVacuum || iMeta==0 ); + assert( iMeta==0 || iMeta==1 ); + pBt->incrVacuum = iMeta; + } +#endif + } + } + sqlite3BtreeLeave(p); + return rc; +} + +/* +** Return the flag byte at the beginning of the page that the cursor +** is currently pointing to. +*/ +int sqlite3BtreeFlags(BtCursor *pCur){ + /* TODO: What about CURSOR_REQUIRESEEK state? Probably need to call + ** restoreOrClearCursorPosition() here. + */ + MemPage *pPage = pCur->pPage; + assert( cursorHoldsMutex(pCur) ); + assert( pPage->pBt==pCur->pBt ); + return pPage ? pPage->aData[pPage->hdrOffset] : 0; +} + + +/* +** Return the pager associated with a BTree. This routine is used for +** testing and debugging only. +*/ +Pager *sqlite3BtreePager(Btree *p){ + return p->pBt->pPager; +} + +#ifndef SQLITE_OMIT_INTEGRITY_CHECK +/* +** Append a message to the error message string. +*/ +static void checkAppendMsg( + IntegrityCk *pCheck, + char *zMsg1, + const char *zFormat, + ... +){ + va_list ap; + char *zMsg2; + if( !pCheck->mxErr ) return; + pCheck->mxErr--; + pCheck->nErr++; + va_start(ap, zFormat); + zMsg2 = sqlite3VMPrintf(0, zFormat, ap); + va_end(ap); + if( zMsg1==0 ) zMsg1 = ""; + if( pCheck->zErrMsg ){ + char *zOld = pCheck->zErrMsg; + pCheck->zErrMsg = 0; + sqlite3SetString(&pCheck->zErrMsg, zOld, "\n", zMsg1, zMsg2, (char*)0); + sqlite3_free(zOld); + }else{ + sqlite3SetString(&pCheck->zErrMsg, zMsg1, zMsg2, (char*)0); + } + sqlite3_free(zMsg2); +} +#endif /* SQLITE_OMIT_INTEGRITY_CHECK */ + +#ifndef SQLITE_OMIT_INTEGRITY_CHECK +/* +** Add 1 to the reference count for page iPage. If this is the second +** reference to the page, add an error message to pCheck->zErrMsg. +** Return 1 if there are 2 ore more references to the page and 0 if +** if this is the first reference to the page. +** +** Also check that the page number is in bounds. +*/ +static int checkRef(IntegrityCk *pCheck, int iPage, char *zContext){ + if( iPage==0 ) return 1; + if( iPage>pCheck->nPage || iPage<0 ){ + checkAppendMsg(pCheck, zContext, "invalid page number %d", iPage); + return 1; + } + if( pCheck->anRef[iPage]==1 ){ + checkAppendMsg(pCheck, zContext, "2nd reference to page %d", iPage); + return 1; + } + return (pCheck->anRef[iPage]++)>1; +} + +#ifndef SQLITE_OMIT_AUTOVACUUM +/* +** Check that the entry in the pointer-map for page iChild maps to +** page iParent, pointer type ptrType. If not, append an error message +** to pCheck. +*/ +static void checkPtrmap( + IntegrityCk *pCheck, /* Integrity check context */ + Pgno iChild, /* Child page number */ + u8 eType, /* Expected pointer map type */ + Pgno iParent, /* Expected pointer map parent page number */ + char *zContext /* Context description (used for error msg) */ +){ + int rc; + u8 ePtrmapType; + Pgno iPtrmapParent; + + rc = ptrmapGet(pCheck->pBt, iChild, &ePtrmapType, &iPtrmapParent); + if( rc!=SQLITE_OK ){ + checkAppendMsg(pCheck, zContext, "Failed to read ptrmap key=%d", iChild); + return; + } + + if( ePtrmapType!=eType || iPtrmapParent!=iParent ){ + checkAppendMsg(pCheck, zContext, + "Bad ptr map entry key=%d expected=(%d,%d) got=(%d,%d)", + iChild, eType, iParent, ePtrmapType, iPtrmapParent); + } +} +#endif + +/* +** Check the integrity of the freelist or of an overflow page list. +** Verify that the number of pages on the list is N. +*/ +static void checkList( + IntegrityCk *pCheck, /* Integrity checking context */ + int isFreeList, /* True for a freelist. False for overflow page list */ + int iPage, /* Page number for first page in the list */ + int N, /* Expected number of pages in the list */ + char *zContext /* Context for error messages */ +){ + int i; + int expected = N; + int iFirst = iPage; + while( N-- > 0 && pCheck->mxErr ){ + DbPage *pOvflPage; + unsigned char *pOvflData; + if( iPage<1 ){ + checkAppendMsg(pCheck, zContext, + "%d of %d pages missing from overflow list starting at %d", + N+1, expected, iFirst); + break; + } + if( checkRef(pCheck, iPage, zContext) ) break; + if( sqlite3PagerGet(pCheck->pPager, (Pgno)iPage, &pOvflPage) ){ + checkAppendMsg(pCheck, zContext, "failed to get page %d", iPage); + break; + } + pOvflData = (unsigned char *)sqlite3PagerGetData(pOvflPage); + if( isFreeList ){ + int n = get4byte(&pOvflData[4]); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pCheck->pBt->autoVacuum ){ + checkPtrmap(pCheck, iPage, PTRMAP_FREEPAGE, 0, zContext); + } +#endif + if( n>pCheck->pBt->usableSize/4-8 ){ + checkAppendMsg(pCheck, zContext, + "freelist leaf count too big on page %d", iPage); + N--; + }else{ + for(i=0; ipBt->autoVacuum ){ + checkPtrmap(pCheck, iFreePage, PTRMAP_FREEPAGE, 0, zContext); + } +#endif + checkRef(pCheck, iFreePage, zContext); + } + N -= n; + } + } +#ifndef SQLITE_OMIT_AUTOVACUUM + else{ + /* If this database supports auto-vacuum and iPage is not the last + ** page in this overflow list, check that the pointer-map entry for + ** the following page matches iPage. + */ + if( pCheck->pBt->autoVacuum && N>0 ){ + i = get4byte(pOvflData); + checkPtrmap(pCheck, i, PTRMAP_OVERFLOW2, iPage, zContext); + } + } +#endif + iPage = get4byte(pOvflData); + sqlite3PagerUnref(pOvflPage); + } +} +#endif /* SQLITE_OMIT_INTEGRITY_CHECK */ + +#ifndef SQLITE_OMIT_INTEGRITY_CHECK +/* +** Do various sanity checks on a single page of a tree. Return +** the tree depth. Root pages return 0. Parents of root pages +** return 1, and so forth. +** +** These checks are done: +** +** 1. Make sure that cells and freeblocks do not overlap +** but combine to completely cover the page. +** NO 2. Make sure cell keys are in order. +** NO 3. Make sure no key is less than or equal to zLowerBound. +** NO 4. Make sure no key is greater than or equal to zUpperBound. +** 5. Check the integrity of overflow pages. +** 6. Recursively call checkTreePage on all children. +** 7. Verify that the depth of all children is the same. +** 8. Make sure this page is at least 33% full or else it is +** the root of the tree. +*/ +static int checkTreePage( + IntegrityCk *pCheck, /* Context for the sanity check */ + int iPage, /* Page number of the page to check */ + MemPage *pParent, /* Parent page */ + char *zParentContext /* Parent context */ +){ + MemPage *pPage; + int i, rc, depth, d2, pgno, cnt; + int hdr, cellStart; + int nCell; + u8 *data; + BtShared *pBt; + int usableSize; + char zContext[100]; + char *hit; + + sqlite3_snprintf(sizeof(zContext), zContext, "Page %d: ", iPage); + + /* Check that the page exists + */ + pBt = pCheck->pBt; + usableSize = pBt->usableSize; + if( iPage==0 ) return 0; + if( checkRef(pCheck, iPage, zParentContext) ) return 0; + if( (rc = sqlite3BtreeGetPage(pBt, (Pgno)iPage, &pPage, 0))!=0 ){ + checkAppendMsg(pCheck, zContext, + "unable to get the page. error code=%d", rc); + return 0; + } + if( (rc = sqlite3BtreeInitPage(pPage, pParent))!=0 ){ + checkAppendMsg(pCheck, zContext, + "sqlite3BtreeInitPage() returns error code %d", rc); + releasePage(pPage); + return 0; + } + + /* Check out all the cells. + */ + depth = 0; + for(i=0; inCell && pCheck->mxErr; i++){ + u8 *pCell; + int sz; + CellInfo info; + + /* Check payload overflow pages + */ + sqlite3_snprintf(sizeof(zContext), zContext, + "On tree page %d cell %d: ", iPage, i); + pCell = findCell(pPage,i); + sqlite3BtreeParseCellPtr(pPage, pCell, &info); + sz = info.nData; + if( !pPage->intKey ) sz += info.nKey; + assert( sz==info.nPayload ); + if( sz>info.nLocal ){ + int nPage = (sz - info.nLocal + usableSize - 5)/(usableSize - 4); + Pgno pgnoOvfl = get4byte(&pCell[info.iOverflow]); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum ){ + checkPtrmap(pCheck, pgnoOvfl, PTRMAP_OVERFLOW1, iPage, zContext); + } +#endif + checkList(pCheck, 0, pgnoOvfl, nPage, zContext); + } + + /* Check sanity of left child page. + */ + if( !pPage->leaf ){ + pgno = get4byte(pCell); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum ){ + checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage, zContext); + } +#endif + d2 = checkTreePage(pCheck,pgno,pPage,zContext); + if( i>0 && d2!=depth ){ + checkAppendMsg(pCheck, zContext, "Child page depth differs"); + } + depth = d2; + } + } + if( !pPage->leaf ){ + pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]); + sqlite3_snprintf(sizeof(zContext), zContext, + "On page %d at right child: ", iPage); +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->autoVacuum ){ + checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage, 0); + } +#endif + checkTreePage(pCheck, pgno, pPage, zContext); + } + + /* Check for complete coverage of the page + */ + data = pPage->aData; + hdr = pPage->hdrOffset; + hit = (char*)sqlite3MallocZero( usableSize ); + if( hit ){ + memset(hit, 1, get2byte(&data[hdr+5])); + nCell = get2byte(&data[hdr+3]); + cellStart = hdr + 12 - 4*pPage->leaf; + for(i=0; i=usableSize || pc<0 ){ + checkAppendMsg(pCheck, 0, + "Corruption detected in cell %d on page %d",i,iPage,0); + }else{ + for(j=pc+size-1; j>=pc; j--) hit[j]++; + } + } + for(cnt=0, i=get2byte(&data[hdr+1]); i>0 && i=usableSize || i<0 ){ + checkAppendMsg(pCheck, 0, + "Corruption detected in cell %d on page %d",i,iPage,0); + }else{ + for(j=i+size-1; j>=i; j--) hit[j]++; + } + i = get2byte(&data[i]); + } + for(i=cnt=0; i1 ){ + checkAppendMsg(pCheck, 0, + "Multiple uses for byte %d of page %d", i, iPage); + break; + } + } + if( cnt!=data[hdr+7] ){ + checkAppendMsg(pCheck, 0, + "Fragmented space is %d byte reported as %d on page %d", + cnt, data[hdr+7], iPage); + } + } + sqlite3_free(hit); + + releasePage(pPage); + return depth+1; +} +#endif /* SQLITE_OMIT_INTEGRITY_CHECK */ + +#ifndef SQLITE_OMIT_INTEGRITY_CHECK +/* +** This routine does a complete check of the given BTree file. aRoot[] is +** an array of pages numbers were each page number is the root page of +** a table. nRoot is the number of entries in aRoot. +** +** If everything checks out, this routine returns NULL. If something is +** amiss, an error message is written into memory obtained from malloc() +** and a pointer to that error message is returned. The calling function +** is responsible for freeing the error message when it is done. +*/ +char *sqlite3BtreeIntegrityCheck( + Btree *p, /* The btree to be checked */ + int *aRoot, /* An array of root pages numbers for individual trees */ + int nRoot, /* Number of entries in aRoot[] */ + int mxErr, /* Stop reporting errors after this many */ + int *pnErr /* Write number of errors seen to this variable */ +){ + int i; + int nRef; + IntegrityCk sCheck; + BtShared *pBt = p->pBt; + + sqlite3BtreeEnter(p); + pBt->db = p->db; + nRef = sqlite3PagerRefcount(pBt->pPager); + if( lockBtreeWithRetry(p)!=SQLITE_OK ){ + sqlite3BtreeLeave(p); + return sqlite3StrDup("Unable to acquire a read lock on the database"); + } + sCheck.pBt = pBt; + sCheck.pPager = pBt->pPager; + sCheck.nPage = sqlite3PagerPagecount(sCheck.pPager); + sCheck.mxErr = mxErr; + sCheck.nErr = 0; + *pnErr = 0; +#ifndef SQLITE_OMIT_AUTOVACUUM + if( pBt->nTrunc!=0 ){ + sCheck.nPage = pBt->nTrunc; + } +#endif + if( sCheck.nPage==0 ){ + unlockBtreeIfUnused(pBt); + sqlite3BtreeLeave(p); + return 0; + } + sCheck.anRef = (int*)sqlite3_malloc( (sCheck.nPage+1)*sizeof(sCheck.anRef[0]) ); + if( !sCheck.anRef ){ + unlockBtreeIfUnused(pBt); + *pnErr = 1; + sqlite3BtreeLeave(p); + return sqlite3MPrintf(p->db, "Unable to malloc %d bytes", + (sCheck.nPage+1)*sizeof(sCheck.anRef[0])); + } + for(i=0; i<=sCheck.nPage; i++){ sCheck.anRef[i] = 0; } + i = PENDING_BYTE_PAGE(pBt); + if( i<=sCheck.nPage ){ + sCheck.anRef[i] = 1; + } + sCheck.zErrMsg = 0; + + /* Check the integrity of the freelist + */ + checkList(&sCheck, 1, get4byte(&pBt->pPage1->aData[32]), + get4byte(&pBt->pPage1->aData[36]), "Main freelist: "); + + /* Check all the tables. + */ + for(i=0; iautoVacuum && aRoot[i]>1 ){ + checkPtrmap(&sCheck, aRoot[i], PTRMAP_ROOTPAGE, 0, 0); + } +#endif + checkTreePage(&sCheck, aRoot[i], 0, "List of tree roots: "); + } + + /* Make sure every page in the file is referenced + */ + for(i=1; i<=sCheck.nPage && sCheck.mxErr; i++){ +#ifdef SQLITE_OMIT_AUTOVACUUM + if( sCheck.anRef[i]==0 ){ + checkAppendMsg(&sCheck, 0, "Page %d is never used", i); + } +#else + /* If the database supports auto-vacuum, make sure no tables contain + ** references to pointer-map pages. + */ + if( sCheck.anRef[i]==0 && + (PTRMAP_PAGENO(pBt, i)!=i || !pBt->autoVacuum) ){ + checkAppendMsg(&sCheck, 0, "Page %d is never used", i); + } + if( sCheck.anRef[i]!=0 && + (PTRMAP_PAGENO(pBt, i)==i && pBt->autoVacuum) ){ + checkAppendMsg(&sCheck, 0, "Pointer map page %d is referenced", i); + } +#endif + } + + /* Make sure this analysis did not leave any unref() pages + */ + unlockBtreeIfUnused(pBt); + if( nRef != sqlite3PagerRefcount(pBt->pPager) ){ + checkAppendMsg(&sCheck, 0, + "Outstanding page count goes from %d to %d during this analysis", + nRef, sqlite3PagerRefcount(pBt->pPager) + ); + } + + /* Clean up and report errors. + */ + sqlite3BtreeLeave(p); + sqlite3_free(sCheck.anRef); + *pnErr = sCheck.nErr; + return sCheck.zErrMsg; +} +#endif /* SQLITE_OMIT_INTEGRITY_CHECK */ + +/* +** Return the full pathname of the underlying database file. +** +** The pager filename is invariant as long as the pager is +** open so it is safe to access without the BtShared mutex. +*/ +const char *sqlite3BtreeGetFilename(Btree *p){ + assert( p->pBt->pPager!=0 ); + return sqlite3PagerFilename(p->pBt->pPager); +} + +/* +** Return the pathname of the directory that contains the database file. +** +** The pager directory name is invariant as long as the pager is +** open so it is safe to access without the BtShared mutex. +*/ +const char *sqlite3BtreeGetDirname(Btree *p){ + assert( p->pBt->pPager!=0 ); + return sqlite3PagerDirname(p->pBt->pPager); +} + +/* +** Return the pathname of the journal file for this database. The return +** value of this routine is the same regardless of whether the journal file +** has been created or not. +** +** The pager journal filename is invariant as long as the pager is +** open so it is safe to access without the BtShared mutex. +*/ +const char *sqlite3BtreeGetJournalname(Btree *p){ + assert( p->pBt->pPager!=0 ); + return sqlite3PagerJournalname(p->pBt->pPager); +} + +#ifndef SQLITE_OMIT_VACUUM +/* +** Copy the complete content of pBtFrom into pBtTo. A transaction +** must be active for both files. +** +** The size of file pBtFrom may be reduced by this operation. +** If anything goes wrong, the transaction on pBtFrom is rolled back. +*/ +static int btreeCopyFile(Btree *pTo, Btree *pFrom){ + int rc = SQLITE_OK; + Pgno i, nPage, nToPage, iSkip; + + BtShared *pBtTo = pTo->pBt; + BtShared *pBtFrom = pFrom->pBt; + pBtTo->db = pTo->db; + pBtFrom->db = pFrom->db; + + + if( pTo->inTrans!=TRANS_WRITE || pFrom->inTrans!=TRANS_WRITE ){ + return SQLITE_ERROR; + } + if( pBtTo->pCursor ) return SQLITE_BUSY; + nToPage = sqlite3PagerPagecount(pBtTo->pPager); + nPage = sqlite3PagerPagecount(pBtFrom->pPager); + iSkip = PENDING_BYTE_PAGE(pBtTo); + for(i=1; rc==SQLITE_OK && i<=nPage; i++){ + DbPage *pDbPage; + if( i==iSkip ) continue; + rc = sqlite3PagerGet(pBtFrom->pPager, i, &pDbPage); + if( rc ) break; + rc = sqlite3PagerOverwrite(pBtTo->pPager, i, sqlite3PagerGetData(pDbPage)); + sqlite3PagerUnref(pDbPage); + } + + /* If the file is shrinking, journal the pages that are being truncated + ** so that they can be rolled back if the commit fails. + */ + for(i=nPage+1; rc==SQLITE_OK && i<=nToPage; i++){ + DbPage *pDbPage; + if( i==iSkip ) continue; + rc = sqlite3PagerGet(pBtTo->pPager, i, &pDbPage); + if( rc ) break; + rc = sqlite3PagerWrite(pDbPage); + sqlite3PagerDontWrite(pDbPage); + /* Yeah. It seems wierd to call DontWrite() right after Write(). But + ** that is because the names of those procedures do not exactly + ** represent what they do. Write() really means "put this page in the + ** rollback journal and mark it as dirty so that it will be written + ** to the database file later." DontWrite() undoes the second part of + ** that and prevents the page from being written to the database. The + ** page is still on the rollback journal, though. And that is the whole + ** point of this loop: to put pages on the rollback journal. */ + sqlite3PagerUnref(pDbPage); + } + if( !rc && nPagepPager, nPage); + } + + if( rc ){ + sqlite3BtreeRollback(pTo); + } + return rc; +} +int sqlite3BtreeCopyFile(Btree *pTo, Btree *pFrom){ + int rc; + sqlite3BtreeEnter(pTo); + sqlite3BtreeEnter(pFrom); + rc = btreeCopyFile(pTo, pFrom); + sqlite3BtreeLeave(pFrom); + sqlite3BtreeLeave(pTo); + return rc; +} + +#endif /* SQLITE_OMIT_VACUUM */ + +/* +** Return non-zero if a transaction is active. +*/ +int sqlite3BtreeIsInTrans(Btree *p){ + assert( p==0 || sqlite3_mutex_held(p->db->mutex) ); + return (p && (p->inTrans==TRANS_WRITE)); +} + +/* +** Return non-zero if a statement transaction is active. +*/ +int sqlite3BtreeIsInStmt(Btree *p){ + assert( sqlite3BtreeHoldsMutex(p) ); + return (p->pBt && p->pBt->inStmt); +} + +/* +** Return non-zero if a read (or write) transaction is active. +*/ +int sqlite3BtreeIsInReadTrans(Btree *p){ + assert( sqlite3_mutex_held(p->db->mutex) ); + return (p && (p->inTrans!=TRANS_NONE)); +} + +/* +** This function returns a pointer to a blob of memory associated with +** a single shared-btree. The memory is used by client code for its own +** purposes (for example, to store a high-level schema associated with +** the shared-btree). The btree layer manages reference counting issues. +** +** The first time this is called on a shared-btree, nBytes bytes of memory +** are allocated, zeroed, and returned to the caller. For each subsequent +** call the nBytes parameter is ignored and a pointer to the same blob +** of memory returned. +** +** Just before the shared-btree is closed, the function passed as the +** xFree argument when the memory allocation was made is invoked on the +** blob of allocated memory. This function should not call sqlite3_free() +** on the memory, the btree layer does that. +*/ +void *sqlite3BtreeSchema(Btree *p, int nBytes, void(*xFree)(void *)){ + BtShared *pBt = p->pBt; + sqlite3BtreeEnter(p); + if( !pBt->pSchema ){ + pBt->pSchema = sqlite3MallocZero(nBytes); + pBt->xFreeSchema = xFree; + } + sqlite3BtreeLeave(p); + return pBt->pSchema; +} + +/* +** Return true if another user of the same shared btree as the argument +** handle holds an exclusive lock on the sqlite_master table. +*/ +int sqlite3BtreeSchemaLocked(Btree *p){ + int rc; + assert( sqlite3_mutex_held(p->db->mutex) ); + sqlite3BtreeEnter(p); + rc = (queryTableLock(p, MASTER_ROOT, READ_LOCK)!=SQLITE_OK); + sqlite3BtreeLeave(p); + return rc; +} + + +#ifndef SQLITE_OMIT_SHARED_CACHE +/* +** Obtain a lock on the table whose root page is iTab. The +** lock is a write lock if isWritelock is true or a read lock +** if it is false. +*/ +int sqlite3BtreeLockTable(Btree *p, int iTab, u8 isWriteLock){ + int rc = SQLITE_OK; + u8 lockType = (isWriteLock?WRITE_LOCK:READ_LOCK); + sqlite3BtreeEnter(p); + rc = queryTableLock(p, iTab, lockType); + if( rc==SQLITE_OK ){ + rc = lockTable(p, iTab, lockType); + } + sqlite3BtreeLeave(p); + return rc; +} +#endif + +#ifndef SQLITE_OMIT_INCRBLOB +/* +** Argument pCsr must be a cursor opened for writing on an +** INTKEY table currently pointing at a valid table entry. +** This function modifies the data stored as part of that entry. +** Only the data content may only be modified, it is not possible +** to change the length of the data stored. +*/ +int sqlite3BtreePutData(BtCursor *pCsr, u32 offset, u32 amt, void *z){ + assert( cursorHoldsMutex(pCsr) ); + assert( sqlite3_mutex_held(pCsr->pBtree->db->mutex) ); + assert(pCsr->isIncrblobHandle); + if( pCsr->eState>=CURSOR_REQUIRESEEK ){ + if( pCsr->eState==CURSOR_FAULT ){ + return pCsr->skip; + }else{ + return SQLITE_ABORT; + } + } + + /* Check some preconditions: + ** (a) the cursor is open for writing, + ** (b) there is no read-lock on the table being modified and + ** (c) the cursor points at a valid row of an intKey table. + */ + if( !pCsr->wrFlag ){ + return SQLITE_READONLY; + } + assert( !pCsr->pBt->readOnly + && pCsr->pBt->inTransaction==TRANS_WRITE ); + if( checkReadLocks(pCsr->pBtree, pCsr->pgnoRoot, pCsr) ){ + return SQLITE_LOCKED; /* The table pCur points to has a read lock */ + } + if( pCsr->eState==CURSOR_INVALID || !pCsr->pPage->intKey ){ + return SQLITE_ERROR; + } + + return accessPayload(pCsr, offset, amt, (unsigned char *)z, 0, 1); +} + +/* +** Set a flag on this cursor to cache the locations of pages from the +** overflow list for the current row. This is used by cursors opened +** for incremental blob IO only. +** +** This function sets a flag only. The actual page location cache +** (stored in BtCursor.aOverflow[]) is allocated and used by function +** accessPayload() (the worker function for sqlite3BtreeData() and +** sqlite3BtreePutData()). +*/ +void sqlite3BtreeCacheOverflow(BtCursor *pCur){ + assert( cursorHoldsMutex(pCur) ); + assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) ); + assert(!pCur->isIncrblobHandle); + assert(!pCur->aOverflow); + pCur->isIncrblobHandle = 1; +} +#endif diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/btree.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/btree.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,203 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This header file defines the interface that the sqlite B-Tree file +** subsystem. See comments in the source code for a detailed description +** of what each interface routine does. +** +** @(#) $Id: btree.h 1282 2008-11-13 09:31:33Z LarsPson $ +*/ +#ifndef _BTREE_H_ +#define _BTREE_H_ + +/* TODO: This definition is just included so other modules compile. It +** needs to be revisited. +*/ +#define SQLITE_N_BTREE_META 10 + +/* +** If defined as non-zero, auto-vacuum is enabled by default. Otherwise +** it must be turned on for each database using "PRAGMA auto_vacuum = 1". +*/ +#ifndef SQLITE_DEFAULT_AUTOVACUUM + #define SQLITE_DEFAULT_AUTOVACUUM 0 +#endif + +#define BTREE_AUTOVACUUM_NONE 0 /* Do not do auto-vacuum */ +#define BTREE_AUTOVACUUM_FULL 1 /* Do full auto-vacuum */ +#define BTREE_AUTOVACUUM_INCR 2 /* Incremental vacuum */ + +/* +** Forward declarations of structure +*/ +typedef struct Btree Btree; +typedef struct BtCursor BtCursor; +typedef struct BtShared BtShared; +typedef struct BtreeMutexArray BtreeMutexArray; + +/* +** This structure records all of the Btrees that need to hold +** a mutex before we enter sqlite3VdbeExec(). The Btrees are +** are placed in aBtree[] in order of aBtree[]->pBt. That way, +** we can always lock and unlock them all quickly. +*/ +struct BtreeMutexArray { + int nMutex; + Btree *aBtree[SQLITE_MAX_ATTACHED+1]; +}; + + +int sqlite3BtreeOpen( + const char *zFilename, /* Name of database file to open */ + sqlite3 *db, /* Associated database connection */ + Btree **, /* Return open Btree* here */ + int flags, /* Flags */ + int vfsFlags /* Flags passed through to VFS open */ +); + +/* The flags parameter to sqlite3BtreeOpen can be the bitwise or of the +** following values. +** +** NOTE: These values must match the corresponding PAGER_ values in +** pager.h. +*/ +#define BTREE_OMIT_JOURNAL 1 /* Do not use journal. No argument */ +#define BTREE_NO_READLOCK 2 /* Omit readlocks on readonly files */ +#define BTREE_MEMORY 4 /* In-memory DB. No argument */ +#define BTREE_READONLY 8 /* Open the database in read-only mode */ +#define BTREE_READWRITE 16 /* Open for both reading and writing */ +#define BTREE_CREATE 32 /* Create the database if it does not exist */ + +/* Additional values for the 4th argument of sqlite3BtreeOpen that +** are not associated with PAGER_ values. +*/ +#define BTREE_PRIVATE 64 /* Never share with other connections */ + +int sqlite3BtreeClose(Btree*); +int sqlite3BtreeSetCacheSize(Btree*,int); +int sqlite3BtreeSetSafetyLevel(Btree*,int,int); +int sqlite3BtreeSyncDisabled(Btree*); +int sqlite3BtreeSetPageSize(Btree*,int,int); +int sqlite3BtreeGetPageSize(Btree*); +int sqlite3BtreeMaxPageCount(Btree*,int); +int sqlite3BtreeGetReserve(Btree*); +int sqlite3BtreeSetAutoVacuum(Btree *, int); +int sqlite3BtreeGetAutoVacuum(Btree *); +int sqlite3BtreeBeginTrans(Btree*,int); +int sqlite3BtreeCommitPhaseOne(Btree*, const char *zMaster); +int sqlite3BtreeCommitPhaseTwo(Btree*); +int sqlite3BtreeCommit(Btree*); +int sqlite3BtreeRollback(Btree*); +int sqlite3BtreeBeginStmt(Btree*); +int sqlite3BtreeCommitStmt(Btree*); +int sqlite3BtreeRollbackStmt(Btree*); +int sqlite3BtreeCreateTable(Btree*, int*, int flags); +int sqlite3BtreeIsInTrans(Btree*); +int sqlite3BtreeIsInStmt(Btree*); +int sqlite3BtreeIsInReadTrans(Btree*); +void *sqlite3BtreeSchema(Btree *, int, void(*)(void *)); +int sqlite3BtreeSchemaLocked(Btree *); +int sqlite3BtreeLockTable(Btree *, int, u8); + +const char *sqlite3BtreeGetFilename(Btree *); +const char *sqlite3BtreeGetDirname(Btree *); +const char *sqlite3BtreeGetJournalname(Btree *); +int sqlite3BtreeCopyFile(Btree *, Btree *); + +int sqlite3BtreeIncrVacuum(Btree *); + +/* The flags parameter to sqlite3BtreeCreateTable can be the bitwise OR +** of the following flags: +*/ +#define BTREE_INTKEY 1 /* Table has only 64-bit signed integer keys */ +#define BTREE_ZERODATA 2 /* Table has keys only - no data */ +#define BTREE_LEAFDATA 4 /* Data stored in leaves only. Implies INTKEY */ + +int sqlite3BtreeDropTable(Btree*, int, int*); +int sqlite3BtreeClearTable(Btree*, int); +int sqlite3BtreeGetMeta(Btree*, int idx, u32 *pValue); +int sqlite3BtreeUpdateMeta(Btree*, int idx, u32 value); +void sqlite3BtreeTripAllCursors(Btree*, int); + +int sqlite3BtreeCursor( + Btree*, /* BTree containing table to open */ + int iTable, /* Index of root page */ + int wrFlag, /* 1 for writing. 0 for read-only */ + int(*)(void*,int,const void*,int,const void*), /* Key comparison function */ + void*, /* First argument to compare function */ + BtCursor **ppCursor /* Returned cursor */ +); + +int sqlite3BtreeCloseCursor(BtCursor*); +int sqlite3BtreeMoveto(BtCursor*,const void *pKey,i64 nKey,int bias,int *pRes); +int sqlite3BtreeDelete(BtCursor*); +int sqlite3BtreeInsert(BtCursor*, const void *pKey, i64 nKey, + const void *pData, int nData, + int nZero, int bias); +int sqlite3BtreeFirst(BtCursor*, int *pRes); +int sqlite3BtreeLast(BtCursor*, int *pRes); +int sqlite3BtreeNext(BtCursor*, int *pRes); +int sqlite3BtreeEof(BtCursor*); +int sqlite3BtreeFlags(BtCursor*); +int sqlite3BtreePrevious(BtCursor*, int *pRes); +int sqlite3BtreeKeySize(BtCursor*, i64 *pSize); +int sqlite3BtreeKey(BtCursor*, u32 offset, u32 amt, void*); +sqlite3 *sqlite3BtreeCursorDb(const BtCursor*); +const void *sqlite3BtreeKeyFetch(BtCursor*, int *pAmt); +const void *sqlite3BtreeDataFetch(BtCursor*, int *pAmt); +int sqlite3BtreeDataSize(BtCursor*, u32 *pSize); +int sqlite3BtreeData(BtCursor*, u32 offset, u32 amt, void*); + +char *sqlite3BtreeIntegrityCheck(Btree*, int *aRoot, int nRoot, int, int*); +struct Pager *sqlite3BtreePager(Btree*); + +int sqlite3BtreePutData(BtCursor*, u32 offset, u32 amt, void*); +void sqlite3BtreeCacheOverflow(BtCursor *); + +#ifdef SQLITE_TEST +int sqlite3BtreeCursorInfo(BtCursor*, int*, int); +void sqlite3BtreeCursorList(Btree*); +int sqlite3BtreePageDump(Btree*, int, int recursive); +#endif + +/* +** If we are not using shared cache, then there is no need to +** use mutexes to access the BtShared structures. So make the +** Enter and Leave procedures no-ops. +*/ +#if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE + void sqlite3BtreeEnter(Btree*); + void sqlite3BtreeLeave(Btree*); + int sqlite3BtreeHoldsMutex(Btree*); + void sqlite3BtreeEnterCursor(BtCursor*); + void sqlite3BtreeLeaveCursor(BtCursor*); + void sqlite3BtreeEnterAll(sqlite3*); + void sqlite3BtreeLeaveAll(sqlite3*); + int sqlite3BtreeHoldsAllMutexes(sqlite3*); + void sqlite3BtreeMutexArrayEnter(BtreeMutexArray*); + void sqlite3BtreeMutexArrayLeave(BtreeMutexArray*); + void sqlite3BtreeMutexArrayInsert(BtreeMutexArray*, Btree*); +#else +# define sqlite3BtreeEnter(X) +# define sqlite3BtreeLeave(X) +# define sqlite3BtreeHoldsMutex(X) 1 +# define sqlite3BtreeEnterCursor(X) +# define sqlite3BtreeLeaveCursor(X) +# define sqlite3BtreeEnterAll(X) +# define sqlite3BtreeLeaveAll(X) +# define sqlite3BtreeHoldsAllMutexes(X) 1 +# define sqlite3BtreeMutexArrayEnter(X) +# define sqlite3BtreeMutexArrayLeave(X) +# define sqlite3BtreeMutexArrayInsert(X,Y) +#endif + + +#endif /* _BTREE_H_ */ diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/btreeInt.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/btreeInt.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,649 @@ +/* +** 2004 April 6 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** $Id: btreeInt.h 1282 2008-11-13 09:31:33Z LarsPson $ +** +** This file implements a external (disk-based) database using BTrees. +** For a detailed discussion of BTrees, refer to +** +** Donald E. Knuth, THE ART OF COMPUTER PROGRAMMING, Volume 3: +** "Sorting And Searching", pages 473-480. Addison-Wesley +** Publishing Company, Reading, Massachusetts. +** +** The basic idea is that each page of the file contains N database +** entries and N+1 pointers to subpages. +** +** ---------------------------------------------------------------- +** | Ptr(0) | Key(0) | Ptr(1) | Key(1) | ... | Key(N-1) | Ptr(N) | +** ---------------------------------------------------------------- +** +** All of the keys on the page that Ptr(0) points to have values less +** than Key(0). All of the keys on page Ptr(1) and its subpages have +** values greater than Key(0) and less than Key(1). All of the keys +** on Ptr(N) and its subpages have values greater than Key(N-1). And +** so forth. +** +** Finding a particular key requires reading O(log(M)) pages from the +** disk where M is the number of entries in the tree. +** +** In this implementation, a single file can hold one or more separate +** BTrees. Each BTree is identified by the index of its root page. The +** key and data for any entry are combined to form the "payload". A +** fixed amount of payload can be carried directly on the database +** page. If the payload is larger than the preset amount then surplus +** bytes are stored on overflow pages. The payload for an entry +** and the preceding pointer are combined to form a "Cell". Each +** page has a small header which contains the Ptr(N) pointer and other +** information such as the size of key and data. +** +** FORMAT DETAILS +** +** The file is divided into pages. The first page is called page 1, +** the second is page 2, and so forth. A page number of zero indicates +** "no such page". The page size can be anything between 512 and 65536. +** Each page can be either a btree page, a freelist page or an overflow +** page. +** +** The first page is always a btree page. The first 100 bytes of the first +** page contain a special header (the "file header") that describes the file. +** The format of the file header is as follows: +** +** OFFSET SIZE DESCRIPTION +** 0 16 Header string: "SQLite format 3\000" +** 16 2 Page size in bytes. +** 18 1 File format write version +** 19 1 File format read version +** 20 1 Bytes of unused space at the end of each page +** 21 1 Max embedded payload fraction +** 22 1 Min embedded payload fraction +** 23 1 Min leaf payload fraction +** 24 4 File change counter +** 28 4 Reserved for future use +** 32 4 First freelist page +** 36 4 Number of freelist pages in the file +** 40 60 15 4-byte meta values passed to higher layers +** +** All of the integer values are big-endian (most significant byte first). +** +** The file change counter is incremented when the database is changed +** This counter allows other processes to know when the file has changed +** and thus when they need to flush their cache. +** +** The max embedded payload fraction is the amount of the total usable +** space in a page that can be consumed by a single cell for standard +** B-tree (non-LEAFDATA) tables. A value of 255 means 100%. The default +** is to limit the maximum cell size so that at least 4 cells will fit +** on one page. Thus the default max embedded payload fraction is 64. +** +** If the payload for a cell is larger than the max payload, then extra +** payload is spilled to overflow pages. Once an overflow page is allocated, +** as many bytes as possible are moved into the overflow pages without letting +** the cell size drop below the min embedded payload fraction. +** +** The min leaf payload fraction is like the min embedded payload fraction +** except that it applies to leaf nodes in a LEAFDATA tree. The maximum +** payload fraction for a LEAFDATA tree is always 100% (or 255) and it +** not specified in the header. +** +** Each btree pages is divided into three sections: The header, the +** cell pointer array, and the cell content area. Page 1 also has a 100-byte +** file header that occurs before the page header. +** +** |----------------| +** | file header | 100 bytes. Page 1 only. +** |----------------| +** | page header | 8 bytes for leaves. 12 bytes for interior nodes +** |----------------| +** | cell pointer | | 2 bytes per cell. Sorted order. +** | array | | Grows downward +** | | v +** |----------------| +** | unallocated | +** | space | +** |----------------| ^ Grows upwards +** | cell content | | Arbitrary order interspersed with freeblocks. +** | area | | and free space fragments. +** |----------------| +** +** The page headers looks like this: +** +** OFFSET SIZE DESCRIPTION +** 0 1 Flags. 1: intkey, 2: zerodata, 4: leafdata, 8: leaf +** 1 2 byte offset to the first freeblock +** 3 2 number of cells on this page +** 5 2 first byte of the cell content area +** 7 1 number of fragmented free bytes +** 8 4 Right child (the Ptr(N) value). Omitted on leaves. +** +** The flags define the format of this btree page. The leaf flag means that +** this page has no children. The zerodata flag means that this page carries +** only keys and no data. The intkey flag means that the key is a integer +** which is stored in the key size entry of the cell header rather than in +** the payload area. +** +** The cell pointer array begins on the first byte after the page header. +** The cell pointer array contains zero or more 2-byte numbers which are +** offsets from the beginning of the page to the cell content in the cell +** content area. The cell pointers occur in sorted order. The system strives +** to keep free space after the last cell pointer so that new cells can +** be easily added without having to defragment the page. +** +** Cell content is stored at the very end of the page and grows toward the +** beginning of the page. +** +** Unused space within the cell content area is collected into a linked list of +** freeblocks. Each freeblock is at least 4 bytes in size. The byte offset +** to the first freeblock is given in the header. Freeblocks occur in +** increasing order. Because a freeblock must be at least 4 bytes in size, +** any group of 3 or fewer unused bytes in the cell content area cannot +** exist on the freeblock chain. A group of 3 or fewer free bytes is called +** a fragment. The total number of bytes in all fragments is recorded. +** in the page header at offset 7. +** +** SIZE DESCRIPTION +** 2 Byte offset of the next freeblock +** 2 Bytes in this freeblock +** +** Cells are of variable length. Cells are stored in the cell content area at +** the end of the page. Pointers to the cells are in the cell pointer array +** that immediately follows the page header. Cells is not necessarily +** contiguous or in order, but cell pointers are contiguous and in order. +** +** Cell content makes use of variable length integers. A variable +** length integer is 1 to 9 bytes where the lower 7 bits of each +** byte are used. The integer consists of all bytes that have bit 8 set and +** the first byte with bit 8 clear. The most significant byte of the integer +** appears first. A variable-length integer may not be more than 9 bytes long. +** As a special case, all 8 bytes of the 9th byte are used as data. This +** allows a 64-bit integer to be encoded in 9 bytes. +** +** 0x00 becomes 0x00000000 +** 0x7f becomes 0x0000007f +** 0x81 0x00 becomes 0x00000080 +** 0x82 0x00 becomes 0x00000100 +** 0x80 0x7f becomes 0x0000007f +** 0x8a 0x91 0xd1 0xac 0x78 becomes 0x12345678 +** 0x81 0x81 0x81 0x81 0x01 becomes 0x10204081 +** +** Variable length integers are used for rowids and to hold the number of +** bytes of key and data in a btree cell. +** +** The content of a cell looks like this: +** +** SIZE DESCRIPTION +** 4 Page number of the left child. Omitted if leaf flag is set. +** var Number of bytes of data. Omitted if the zerodata flag is set. +** var Number of bytes of key. Or the key itself if intkey flag is set. +** * Payload +** 4 First page of the overflow chain. Omitted if no overflow +** +** Overflow pages form a linked list. Each page except the last is completely +** filled with data (pagesize - 4 bytes). The last page can have as little +** as 1 byte of data. +** +** SIZE DESCRIPTION +** 4 Page number of next overflow page +** * Data +** +** Freelist pages come in two subtypes: trunk pages and leaf pages. The +** file header points to the first in a linked list of trunk page. Each trunk +** page points to multiple leaf pages. The content of a leaf page is +** unspecified. A trunk page looks like this: +** +** SIZE DESCRIPTION +** 4 Page number of next trunk page +** 4 Number of leaf pointers on this page +** * zero or more pages numbers of leaves +*/ +#include "sqliteInt.h" +#include "pager.h" +#include "btree.h" +#include "os.h" +#include + +/* Round up a number to the next larger multiple of 8. This is used +** to force 8-byte alignment on 64-bit architectures. +*/ +#define ROUND8(x) ((x+7)&~7) + + +/* The following value is the maximum cell size assuming a maximum page +** size give above. +*/ +#define MX_CELL_SIZE(pBt) (pBt->pageSize-8) + +/* The maximum number of cells on a single page of the database. This +** assumes a minimum cell size of 3 bytes. Such small cells will be +** exceedingly rare, but they are possible. +*/ +#define MX_CELL(pBt) ((pBt->pageSize-8)/3) + +/* Forward declarations */ +typedef struct MemPage MemPage; +typedef struct BtLock BtLock; + +/* +** This is a magic string that appears at the beginning of every +** SQLite database in order to identify the file as a real database. +** +** You can change this value at compile-time by specifying a +** -DSQLITE_FILE_HEADER="..." on the compiler command-line. The +** header must be exactly 16 bytes including the zero-terminator so +** the string itself should be 15 characters long. If you change +** the header, then your custom library will not be able to read +** databases generated by the standard tools and the standard tools +** will not be able to read databases created by your custom library. +*/ +#ifndef SQLITE_FILE_HEADER /* 123456789 123456 */ +# define SQLITE_FILE_HEADER "SQLite format 3" +#endif + +/* +** Page type flags. An ORed combination of these flags appear as the +** first byte of on-disk image of every BTree page. +*/ +#define PTF_INTKEY 0x01 +#define PTF_ZERODATA 0x02 +#define PTF_LEAFDATA 0x04 +#define PTF_LEAF 0x08 + +/* +** As each page of the file is loaded into memory, an instance of the following +** structure is appended and initialized to zero. This structure stores +** information about the page that is decoded from the raw file page. +** +** The pParent field points back to the parent page. This allows us to +** walk up the BTree from any leaf to the root. Care must be taken to +** unref() the parent page pointer when this page is no longer referenced. +** The pageDestructor() routine handles that chore. +** +** Access to all fields of this structure is controlled by the mutex +** stored in MemPage.pBt->mutex. +*/ +struct MemPage { + u8 isInit; /* True if previously initialized. MUST BE FIRST! */ + u8 idxShift; /* True if Cell indices have changed */ + u8 nOverflow; /* Number of overflow cell bodies in aCell[] */ + u8 intKey; /* True if intkey flag is set */ + u8 leaf; /* True if leaf flag is set */ + u8 zeroData; /* True if table stores keys only */ + u8 leafData; /* True if tables stores data on leaves only */ + u8 hasData; /* True if this page stores data */ + u8 hdrOffset; /* 100 for page 1. 0 otherwise */ + u8 childPtrSize; /* 0 if leaf==1. 4 if leaf==0 */ + u16 maxLocal; /* Copy of BtShared.maxLocal or BtShared.maxLeaf */ + u16 minLocal; /* Copy of BtShared.minLocal or BtShared.minLeaf */ + u16 cellOffset; /* Index in aData of first cell pointer */ + u16 idxParent; /* Index in parent of this node */ + u16 nFree; /* Number of free bytes on the page */ + u16 nCell; /* Number of cells on this page, local and ovfl */ + struct _OvflCell { /* Cells that will not fit on aData[] */ + u8 *pCell; /* Pointers to the body of the overflow cell */ + u16 idx; /* Insert this cell before idx-th non-overflow cell */ + } aOvfl[5]; + BtShared *pBt; /* Pointer to BtShared that this page is part of */ + u8 *aData; /* Pointer to disk image of the page data */ + DbPage *pDbPage; /* Pager page handle */ + Pgno pgno; /* Page number for this page */ + MemPage *pParent; /* The parent of this page. NULL for root */ +}; + +/* +** The in-memory image of a disk page has the auxiliary information appended +** to the end. EXTRA_SIZE is the number of bytes of space needed to hold +** that extra information. +*/ +#define EXTRA_SIZE sizeof(MemPage) + +/* A Btree handle +** +** A database connection contains a pointer to an instance of +** this object for every database file that it has open. This structure +** is opaque to the database connection. The database connection cannot +** see the internals of this structure and only deals with pointers to +** this structure. +** +** For some database files, the same underlying database cache might be +** shared between multiple connections. In that case, each contection +** has it own pointer to this object. But each instance of this object +** points to the same BtShared object. The database cache and the +** schema associated with the database file are all contained within +** the BtShared object. +** +** All fields in this structure are accessed under sqlite3.mutex. +** The pBt pointer itself may not be changed while there exists cursors +** in the referenced BtShared that point back to this Btree since those +** cursors have to do go through this Btree to find their BtShared and +** they often do so without holding sqlite3.mutex. +*/ +struct Btree { + sqlite3 *db; /* The database connection holding this btree */ + BtShared *pBt; /* Sharable content of this btree */ + u8 inTrans; /* TRANS_NONE, TRANS_READ or TRANS_WRITE */ + u8 sharable; /* True if we can share pBt with another db */ + u8 locked; /* True if db currently has pBt locked */ + int wantToLock; /* Number of nested calls to sqlite3BtreeEnter() */ + Btree *pNext; /* List of other sharable Btrees from the same db */ + Btree *pPrev; /* Back pointer of the same list */ +}; + +/* +** Btree.inTrans may take one of the following values. +** +** If the shared-data extension is enabled, there may be multiple users +** of the Btree structure. At most one of these may open a write transaction, +** but any number may have active read transactions. +*/ +#define TRANS_NONE 0 +#define TRANS_READ 1 +#define TRANS_WRITE 2 + +/* +** An instance of this object represents a single database file. +** +** A single database file can be in use as the same time by two +** or more database connections. When two or more connections are +** sharing the same database file, each connection has it own +** private Btree object for the file and each of those Btrees points +** to this one BtShared object. BtShared.nRef is the number of +** connections currently sharing this database file. +** +** Fields in this structure are accessed under the BtShared.mutex +** mutex, except for nRef and pNext which are accessed under the +** global SQLITE_MUTEX_STATIC_MASTER mutex. The pPager field +** may not be modified once it is initially set as long as nRef>0. +** The pSchema field may be set once under BtShared.mutex and +** thereafter is unchanged as long as nRef>0. +*/ +struct BtShared { + Pager *pPager; /* The page cache */ + sqlite3 *db; /* Database connection currently using this Btree */ + BtCursor *pCursor; /* A list of all open cursors */ + MemPage *pPage1; /* First page of the database */ + u8 inStmt; /* True if we are in a statement subtransaction */ + u8 readOnly; /* True if the underlying file is readonly */ + u8 maxEmbedFrac; /* Maximum payload as % of total page size */ + u8 minEmbedFrac; /* Minimum payload as % of total page size */ + u8 minLeafFrac; /* Minimum leaf payload as % of total page size */ + u8 pageSizeFixed; /* True if the page size can no longer be changed */ +#ifndef SQLITE_OMIT_AUTOVACUUM + u8 autoVacuum; /* True if auto-vacuum is enabled */ + u8 incrVacuum; /* True if incr-vacuum is enabled */ + Pgno nTrunc; /* Non-zero if the db will be truncated (incr vacuum) */ +#endif + u16 pageSize; /* Total number of bytes on a page */ + u16 usableSize; /* Number of usable bytes on each page */ + int maxLocal; /* Maximum local payload in non-LEAFDATA tables */ + int minLocal; /* Minimum local payload in non-LEAFDATA tables */ + int maxLeaf; /* Maximum local payload in a LEAFDATA table */ + int minLeaf; /* Minimum local payload in a LEAFDATA table */ + u8 inTransaction; /* Transaction state */ + int nTransaction; /* Number of open transactions (read + write) */ + void *pSchema; /* Pointer to space allocated by sqlite3BtreeSchema() */ + void (*xFreeSchema)(void*); /* Destructor for BtShared.pSchema */ + sqlite3_mutex *mutex; /* Non-recursive mutex required to access this struct */ + BusyHandler busyHdr; /* The busy handler for this btree */ +#ifndef SQLITE_OMIT_SHARED_CACHE + int nRef; /* Number of references to this structure */ + BtShared *pNext; /* Next on a list of sharable BtShared structs */ + BtLock *pLock; /* List of locks held on this shared-btree struct */ +#endif +}; + +/* +** An instance of the following structure is used to hold information +** about a cell. The parseCellPtr() function fills in this structure +** based on information extract from the raw disk page. +*/ +typedef struct CellInfo CellInfo; +struct CellInfo { + u8 *pCell; /* Pointer to the start of cell content */ + i64 nKey; /* The key for INTKEY tables, or number of bytes in key */ + u32 nData; /* Number of bytes of data */ + u32 nPayload; /* Total amount of payload */ + u16 nHeader; /* Size of the cell content header in bytes */ + u16 nLocal; /* Amount of payload held locally */ + u16 iOverflow; /* Offset to overflow page number. Zero if no overflow */ + u16 nSize; /* Size of the cell content on the main b-tree page */ +}; + +/* +** A cursor is a pointer to a particular entry within a particular +** b-tree within a database file. +** +** The entry is identified by its MemPage and the index in +** MemPage.aCell[] of the entry. +** +** When a single database file can shared by two more database connections, +** but cursors cannot be shared. Each cursor is associated with a +** particular database connection identified BtCursor.pBtree.db. +** +** Fields in this structure are accessed under the BtShared.mutex +** found at self->pBt->mutex. +*/ +struct BtCursor { + Btree *pBtree; /* The Btree to which this cursor belongs */ + BtShared *pBt; /* The BtShared this cursor points to */ + BtCursor *pNext, *pPrev; /* Forms a linked list of all cursors */ + int (*xCompare)(void*,int,const void*,int,const void*); /* Key comp func */ + void *pArg; /* First arg to xCompare() */ + Pgno pgnoRoot; /* The root page of this tree */ + MemPage *pPage; /* Page that contains the entry */ + int idx; /* Index of the entry in pPage->aCell[] */ + CellInfo info; /* A parse of the cell we are pointing at */ + u8 wrFlag; /* True if writable */ + u8 eState; /* One of the CURSOR_XXX constants (see below) */ + void *pKey; /* Saved key that was cursor's last known position */ + i64 nKey; /* Size of pKey, or last integer key */ + int skip; /* (skip<0) -> Prev() is a no-op. (skip>0) -> Next() is */ +#ifndef SQLITE_OMIT_INCRBLOB + u8 isIncrblobHandle; /* True if this cursor is an incr. io handle */ + Pgno *aOverflow; /* Cache of overflow page locations */ +#endif +}; + +/* +** Potential values for BtCursor.eState. +** +** CURSOR_VALID: +** Cursor points to a valid entry. getPayload() etc. may be called. +** +** CURSOR_INVALID: +** Cursor does not point to a valid entry. This can happen (for example) +** because the table is empty or because BtreeCursorFirst() has not been +** called. +** +** CURSOR_REQUIRESEEK: +** The table that this cursor was opened on still exists, but has been +** modified since the cursor was last used. The cursor position is saved +** in variables BtCursor.pKey and BtCursor.nKey. When a cursor is in +** this state, restoreOrClearCursorPosition() can be called to attempt to +** seek the cursor to the saved position. +** +** CURSOR_FAULT: +** A unrecoverable error (an I/O error or a malloc failure) has occurred +** on a different connection that shares the BtShared cache with this +** cursor. The error has left the cache in an inconsistent state. +** Do nothing else with this cursor. Any attempt to use the cursor +** should return the error code stored in BtCursor.skip +*/ +#define CURSOR_INVALID 0 +#define CURSOR_VALID 1 +#define CURSOR_REQUIRESEEK 2 +#define CURSOR_FAULT 3 + +/* +** The TRACE macro will print high-level status information about the +** btree operation when the global variable sqlite3_btree_trace is +** enabled. +*/ +#if SQLITE_TEST +# define TRACE(X) if( sqlite3_btree_trace ){ printf X; fflush(stdout); } +#else +# define TRACE(X) +#endif + +/* +** Routines to read and write variable-length integers. These used to +** be defined locally, but now we use the varint routines in the util.c +** file. +*/ +#define getVarint sqlite3GetVarint +#define getVarint32(A,B) ((*B=*(A))<=0x7f?1:sqlite3GetVarint32(A,B)) +#define putVarint sqlite3PutVarint + +/* The database page the PENDING_BYTE occupies. This page is never used. +** TODO: This macro is very similary to PAGER_MJ_PGNO() in pager.c. They +** should possibly be consolidated (presumably in pager.h). +** +** If disk I/O is omitted (meaning that the database is stored purely +** in memory) then there is no pending byte. +*/ +#ifdef SQLITE_OMIT_DISKIO +# define PENDING_BYTE_PAGE(pBt) 0x7fffffff +#else +# define PENDING_BYTE_PAGE(pBt) ((PENDING_BYTE/(pBt)->pageSize)+1) +#endif + +/* +** A linked list of the following structures is stored at BtShared.pLock. +** Locks are added (or upgraded from READ_LOCK to WRITE_LOCK) when a cursor +** is opened on the table with root page BtShared.iTable. Locks are removed +** from this list when a transaction is committed or rolled back, or when +** a btree handle is closed. +*/ +struct BtLock { + Btree *pBtree; /* Btree handle holding this lock */ + Pgno iTable; /* Root page of table */ + u8 eLock; /* READ_LOCK or WRITE_LOCK */ + BtLock *pNext; /* Next in BtShared.pLock list */ +}; + +/* Candidate values for BtLock.eLock */ +#define READ_LOCK 1 +#define WRITE_LOCK 2 + +/* +** These macros define the location of the pointer-map entry for a +** database page. The first argument to each is the number of usable +** bytes on each page of the database (often 1024). The second is the +** page number to look up in the pointer map. +** +** PTRMAP_PAGENO returns the database page number of the pointer-map +** page that stores the required pointer. PTRMAP_PTROFFSET returns +** the offset of the requested map entry. +** +** If the pgno argument passed to PTRMAP_PAGENO is a pointer-map page, +** then pgno is returned. So (pgno==PTRMAP_PAGENO(pgsz, pgno)) can be +** used to test if pgno is a pointer-map page. PTRMAP_ISPAGE implements +** this test. +*/ +#define PTRMAP_PAGENO(pBt, pgno) ptrmapPageno(pBt, pgno) +#define PTRMAP_PTROFFSET(pBt, pgno) (5*(pgno-ptrmapPageno(pBt, pgno)-1)) +#define PTRMAP_ISPAGE(pBt, pgno) (PTRMAP_PAGENO((pBt),(pgno))==(pgno)) + +/* +** The pointer map is a lookup table that identifies the parent page for +** each child page in the database file. The parent page is the page that +** contains a pointer to the child. Every page in the database contains +** 0 or 1 parent pages. (In this context 'database page' refers +** to any page that is not part of the pointer map itself.) Each pointer map +** entry consists of a single byte 'type' and a 4 byte parent page number. +** The PTRMAP_XXX identifiers below are the valid types. +** +** The purpose of the pointer map is to facility moving pages from one +** position in the file to another as part of autovacuum. When a page +** is moved, the pointer in its parent must be updated to point to the +** new location. The pointer map is used to locate the parent page quickly. +** +** PTRMAP_ROOTPAGE: The database page is a root-page. The page-number is not +** used in this case. +** +** PTRMAP_FREEPAGE: The database page is an unused (free) page. The page-number +** is not used in this case. +** +** PTRMAP_OVERFLOW1: The database page is the first page in a list of +** overflow pages. The page number identifies the page that +** contains the cell with a pointer to this overflow page. +** +** PTRMAP_OVERFLOW2: The database page is the second or later page in a list of +** overflow pages. The page-number identifies the previous +** page in the overflow page list. +** +** PTRMAP_BTREE: The database page is a non-root btree page. The page number +** identifies the parent page in the btree. +*/ +#define PTRMAP_ROOTPAGE 1 +#define PTRMAP_FREEPAGE 2 +#define PTRMAP_OVERFLOW1 3 +#define PTRMAP_OVERFLOW2 4 +#define PTRMAP_BTREE 5 + +/* A bunch of assert() statements to check the transaction state variables +** of handle p (type Btree*) are internally consistent. +*/ +#define btreeIntegrity(p) \ + assert( p->pBt->inTransaction!=TRANS_NONE || p->pBt->nTransaction==0 ); \ + assert( p->pBt->inTransaction>=p->inTrans ); + + +/* +** The ISAUTOVACUUM macro is used within balance_nonroot() to determine +** if the database supports auto-vacuum or not. Because it is used +** within an expression that is an argument to another macro +** (sqliteMallocRaw), it is not possible to use conditional compilation. +** So, this macro is defined instead. +*/ +#ifndef SQLITE_OMIT_AUTOVACUUM +#define ISAUTOVACUUM (pBt->autoVacuum) +#else +#define ISAUTOVACUUM 0 +#endif + + +/* +** This structure is passed around through all the sanity checking routines +** in order to keep track of some global state information. +*/ +typedef struct IntegrityCk IntegrityCk; +struct IntegrityCk { + BtShared *pBt; /* The tree being checked out */ + Pager *pPager; /* The associated pager. Also accessible by pBt->pPager */ + int nPage; /* Number of pages in the database */ + int *anRef; /* Number of times each page is referenced */ + int mxErr; /* Stop accumulating errors when this reaches zero */ + char *zErrMsg; /* An error message. NULL if no errors seen. */ + int nErr; /* Number of messages written to zErrMsg so far */ +}; + +/* +** Read or write a two- and four-byte big-endian integer values. +*/ +#define get2byte(x) ((x)[0]<<8 | (x)[1]) +#define put2byte(p,v) ((p)[0] = (v)>>8, (p)[1] = (v)) +#define get4byte sqlite3Get4byte +#define put4byte sqlite3Put4byte + +/* +** Internal routines that should be accessed by the btree layer only. +*/ +int sqlite3BtreeGetPage(BtShared*, Pgno, MemPage**, int); +int sqlite3BtreeInitPage(MemPage *pPage, MemPage *pParent); +void sqlite3BtreeParseCellPtr(MemPage*, u8*, CellInfo*); +void sqlite3BtreeParseCell(MemPage*, int, CellInfo*); +#ifdef SQLITE_TEST +u8 *sqlite3BtreeFindCell(MemPage *pPage, int iCell); +#endif +int sqlite3BtreeRestoreOrClearCursorPosition(BtCursor *pCur); +void sqlite3BtreeGetTempCursor(BtCursor *pCur, BtCursor *pTempCur); +void sqlite3BtreeReleaseTempCursor(BtCursor *pCur); +int sqlite3BtreeIsRootPage(MemPage *pPage); +void sqlite3BtreeMoveToParent(BtCursor *pCur); diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/build.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/build.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,3436 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains C code routines that are called by the SQLite parser +** when syntax rules are reduced. The routines in this file handle the +** following kinds of SQL syntax: +** +** CREATE TABLE +** DROP TABLE +** CREATE INDEX +** DROP INDEX +** creating ID lists +** BEGIN TRANSACTION +** COMMIT +** ROLLBACK +** +** $Id: build.cpp 1282 2008-11-13 09:31:33Z LarsPson $ +*/ +#include "sqliteInt.h" +#include + +/* +** This routine is called when a new SQL statement is beginning to +** be parsed. Initialize the pParse structure as needed. +*/ +void sqlite3BeginParse(Parse *pParse, int explainFlag){ + pParse->explain = explainFlag; + pParse->nVar = 0; +} + +#ifndef SQLITE_OMIT_SHARED_CACHE +/* +** The TableLock structure is only used by the sqlite3TableLock() and +** codeTableLocks() functions. +*/ +struct TableLock { + int iDb; /* The database containing the table to be locked */ + int iTab; /* The root page of the table to be locked */ + u8 isWriteLock; /* True for write lock. False for a read lock */ + const char *zName; /* Name of the table */ +}; + +/* +** Record the fact that we want to lock a table at run-time. +** +** The table to be locked has root page iTab and is found in database iDb. +** A read or a write lock can be taken depending on isWritelock. +** +** This routine just records the fact that the lock is desired. The +** code to make the lock occur is generated by a later call to +** codeTableLocks() which occurs during sqlite3FinishCoding(). +*/ +void sqlite3TableLock( + Parse *pParse, /* Parsing context */ + int iDb, /* Index of the database containing the table to lock */ + int iTab, /* Root page number of the table to be locked */ + u8 isWriteLock, /* True for a write lock */ + const char *zName /* Name of the table to be locked */ +){ + int i; + int nBytes; + TableLock *p; + + if( iDb<0 ){ + return; + } + + for(i=0; inTableLock; i++){ + p = &pParse->aTableLock[i]; + if( p->iDb==iDb && p->iTab==iTab ){ + p->isWriteLock = (p->isWriteLock || isWriteLock); + return; + } + } + + nBytes = sizeof(TableLock) * (pParse->nTableLock+1); + pParse->aTableLock = + (TableLock*)sqlite3DbReallocOrFree(pParse->db, pParse->aTableLock, nBytes); + if( pParse->aTableLock ){ + p = &pParse->aTableLock[pParse->nTableLock++]; + p->iDb = iDb; + p->iTab = iTab; + p->isWriteLock = isWriteLock; + p->zName = zName; + }else{ + pParse->nTableLock = 0; + pParse->db->mallocFailed = 1; + } +} + +/* +** Code an OP_TableLock instruction for each table locked by the +** statement (configured by calls to sqlite3TableLock()). +*/ +static void codeTableLocks(Parse *pParse){ + int i; + Vdbe *pVdbe; + + if( 0==(pVdbe = sqlite3GetVdbe(pParse)) ){ + return; + } + + for(i=0; inTableLock; i++){ + TableLock *p = &pParse->aTableLock[i]; + int p1 = p->iDb; + if( p->isWriteLock ){ + p1 = -1*(p1+1); + } + sqlite3VdbeOp3(pVdbe, OP_TableLock, p1, p->iTab, p->zName, P3_STATIC); + } +} +#else + #define codeTableLocks(x) +#endif + +/* +** This routine is called after a single SQL statement has been +** parsed and a VDBE program to execute that statement has been +** prepared. This routine puts the finishing touches on the +** VDBE program and resets the pParse structure for the next +** parse. +** +** Note that if an error occurred, it might be the case that +** no VDBE code was generated. +*/ +void sqlite3FinishCoding(Parse *pParse){ + sqlite3 *db; + Vdbe *v; + + db = pParse->db; + if( db->mallocFailed ) return; + if( pParse->nested ) return; + if( !pParse->pVdbe ){ + if( pParse->rc==SQLITE_OK && pParse->nErr ){ + pParse->rc = SQLITE_ERROR; + return; + } + } + + /* Begin by generating some termination code at the end of the + ** vdbe program + */ + v = sqlite3GetVdbe(pParse); + if( v ){ + sqlite3VdbeAddOp(v, OP_Halt, 0, 0); + + /* The cookie mask contains one bit for each database file open. + ** (Bit 0 is for main, bit 1 is for temp, and so forth.) Bits are + ** set for each database that is used. Generate code to start a + ** transaction on each used database and to verify the schema cookie + ** on each used database. + */ + if( pParse->cookieGoto>0 ){ + u32 mask; + int iDb; + sqlite3VdbeJumpHere(v, pParse->cookieGoto-1); + for(iDb=0, mask=1; iDbnDb; mask<<=1, iDb++){ + if( (mask & pParse->cookieMask)==0 ) continue; + sqlite3VdbeUsesBtree(v, iDb); + sqlite3VdbeAddOp(v, OP_Transaction, iDb, (mask & pParse->writeMask)!=0); + sqlite3VdbeAddOp(v, OP_VerifyCookie, iDb, pParse->cookieValue[iDb]); + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( pParse->pVirtualLock ){ + char *vtab = (char *)pParse->pVirtualLock->pVtab; + sqlite3VdbeOp3(v, OP_VBegin, 0, 0, vtab, P3_VTAB); + } +#endif + + /* Once all the cookies have been verified and transactions opened, + ** obtain the required table-locks. This is a no-op unless the + ** shared-cache feature is enabled. + */ + codeTableLocks(pParse); + sqlite3VdbeAddOp(v, OP_Goto, 0, pParse->cookieGoto); + } + +#ifndef SQLITE_OMIT_TRACE + /* Add a No-op that contains the complete text of the compiled SQL + ** statement as its P3 argument. This does not change the functionality + ** of the program. + ** + ** This is used to implement sqlite3_trace(). + */ + sqlite3VdbeOp3(v, OP_Noop, 0, 0, pParse->zSql, pParse->zTail-pParse->zSql); +#endif /* SQLITE_OMIT_TRACE */ + } + + + /* Get the VDBE program ready for execution + */ + if( v && pParse->nErr==0 && !db->mallocFailed ){ +#ifdef SQLITE_DEBUG + FILE *trace = (db->flags & SQLITE_VdbeTrace)!=0 ? stdout : 0; + sqlite3VdbeTrace(v, trace); +#endif + sqlite3VdbeMakeReady(v, pParse->nVar, pParse->nMem+3, + pParse->nTab+3, pParse->explain); + pParse->rc = SQLITE_DONE; + pParse->colNamesSet = 0; + }else if( pParse->rc==SQLITE_OK ){ + pParse->rc = SQLITE_ERROR; + } + pParse->nTab = 0; + pParse->nMem = 0; + pParse->nSet = 0; + pParse->nVar = 0; + pParse->cookieMask = 0; + pParse->cookieGoto = 0; +} + +/* +** Run the parser and code generator recursively in order to generate +** code for the SQL statement given onto the end of the pParse context +** currently under construction. When the parser is run recursively +** this way, the final OP_Halt is not appended and other initialization +** and finalization steps are omitted because those are handling by the +** outermost parser. +** +** Not everything is nestable. This facility is designed to permit +** INSERT, UPDATE, and DELETE operations against SQLITE_MASTER. Use +** care if you decide to try to use this routine for some other purposes. +*/ + +void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){ + va_list ap; + char *zSql; +#define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD)) +# define SAVE_SZ (sizeof(Parse) - offsetof(Parse,nVar)) + char saveBuf[SAVE_SZ]; + + if( pParse->nErr ) return; + assert( pParse->nested<10 ); /* Nesting should only be of limited depth */ + va_start(ap, zFormat); + zSql = sqlite3VMPrintf(pParse->db, zFormat, ap); + va_end(ap); + if( zSql==0 ){ + pParse->db->mallocFailed = 1; + return; /* A malloc must have failed */ + } + pParse->nested++; + memcpy(saveBuf, &pParse->nVar, SAVE_SZ); + memset(&pParse->nVar, 0, SAVE_SZ); + sqlite3RunParser(pParse, zSql, 0); + sqlite3_free(zSql); + memcpy(&pParse->nVar, saveBuf, SAVE_SZ); + pParse->nested--; +} + +/* +** Locate the in-memory structure that describes a particular database +** table given the name of that table and (optionally) the name of the +** database containing the table. Return NULL if not found. +** +** If zDatabase is 0, all databases are searched for the table and the +** first matching table is returned. (No checking for duplicate table +** names is done.) The search order is TEMP first, then MAIN, then any +** auxiliary databases added using the ATTACH command. +** +** See also sqlite3LocateTable(). +*/ +Table *sqlite3FindTable(sqlite3 *db, const char *zName, const char *zDatabase){ + Table *p = 0; + int i; + assert( zName!=0 ); + for(i=OMIT_TEMPDB; inDb; i++){ + int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */ + if( zDatabase!=0 && sqlite3StrICmp(zDatabase, db->aDb[j].zName) ) continue; + p = (Table*)sqlite3HashFind(&db->aDb[j].pSchema->tblHash, zName, strlen(zName)+1); + if( p ) break; + } + return p; +} + +/* +** Locate the in-memory structure that describes a particular database +** table given the name of that table and (optionally) the name of the +** database containing the table. Return NULL if not found. Also leave an +** error message in pParse->zErrMsg. +** +** The difference between this routine and sqlite3FindTable() is that this +** routine leaves an error message in pParse->zErrMsg where +** sqlite3FindTable() does not. +*/ +Table *sqlite3LocateTable(Parse *pParse, const char *zName, const char *zDbase){ + Table *p; + + /* Read the database schema. If an error occurs, leave an error message + ** and code in pParse and return NULL. */ + if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){ + return 0; + } + + p = sqlite3FindTable(pParse->db, zName, zDbase); + if( p==0 ){ + if( zDbase ){ + sqlite3ErrorMsg(pParse, "no such table: %s.%s", zDbase, zName); + }else{ + sqlite3ErrorMsg(pParse, "no such table: %s", zName); + } + pParse->checkSchema = 1; + } + return p; +} + +/* +** Locate the in-memory structure that describes +** a particular index given the name of that index +** and the name of the database that contains the index. +** Return NULL if not found. +** +** If zDatabase is 0, all databases are searched for the +** table and the first matching index is returned. (No checking +** for duplicate index names is done.) The search order is +** TEMP first, then MAIN, then any auxiliary databases added +** using the ATTACH command. +*/ +Index *sqlite3FindIndex(sqlite3 *db, const char *zName, const char *zDb){ + Index *p = 0; + int i; + for(i=OMIT_TEMPDB; inDb; i++){ + int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */ + Schema *pSchema = db->aDb[j].pSchema; + if( zDb && sqlite3StrICmp(zDb, db->aDb[j].zName) ) continue; + assert( pSchema || (j==1 && !db->aDb[1].pBt) ); + if( pSchema ){ + p = (Index*)sqlite3HashFind(&pSchema->idxHash, zName, strlen(zName)+1); + } + if( p ) break; + } + return p; +} + +/* +** Reclaim the memory used by an index +*/ +static void freeIndex(Index *p){ + sqlite3_free(p->zColAff); + sqlite3_free(p); +} + +/* +** Remove the given index from the index hash table, and free +** its memory structures. +** +** The index is removed from the database hash tables but +** it is not unlinked from the Table that it indexes. +** Unlinking from the Table must be done by the calling function. +*/ +static void sqliteDeleteIndex(Index *p){ + Index *pOld; + const char *zName = p->zName; + + pOld = (Index*)sqlite3HashInsert(&p->pSchema->idxHash, zName, strlen( zName)+1, 0); + assert( pOld==0 || pOld==p ); + freeIndex(p); +} + +/* +** For the index called zIdxName which is found in the database iDb, +** unlike that index from its Table then remove the index from +** the index hash table and free all memory structures associated +** with the index. +*/ +void sqlite3UnlinkAndDeleteIndex(sqlite3 *db, int iDb, const char *zIdxName){ + Index *pIndex; + int len; + Hash *pHash = &db->aDb[iDb].pSchema->idxHash; + + len = strlen(zIdxName); + pIndex = (Index*)sqlite3HashInsert(pHash, zIdxName, len+1, 0); + if( pIndex ){ + if( pIndex->pTable->pIndex==pIndex ){ + pIndex->pTable->pIndex = pIndex->pNext; + }else{ + Index *p; + for(p=pIndex->pTable->pIndex; p && p->pNext!=pIndex; p=p->pNext){} + if( p && p->pNext==pIndex ){ + p->pNext = pIndex->pNext; + } + } + freeIndex(pIndex); + } + db->flags |= SQLITE_InternChanges; +} + +/* +** Erase all schema information from the in-memory hash tables of +** a single database. This routine is called to reclaim memory +** before the database closes. It is also called during a rollback +** if there were schema changes during the transaction or if a +** schema-cookie mismatch occurs. +** +** If iDb<=0 then reset the internal schema tables for all database +** files. If iDb>=2 then reset the internal schema for only the +** single file indicated. +*/ +void sqlite3ResetInternalSchema(sqlite3 *db, int iDb){ + int i, j; + + assert( iDb>=0 && iDbnDb ); + for(i=iDb; inDb; i++){ + Db *pDb = &db->aDb[i]; + if( pDb->pSchema ){ + sqlite3SchemaFree(pDb->pSchema); + } + if( iDb>0 ) return; + } + assert( iDb==0 ); + db->flags &= ~SQLITE_InternChanges; + + /* If one or more of the auxiliary database files has been closed, + ** then remove them from the auxiliary database list. We take the + ** opportunity to do this here since we have just deleted all of the + ** schema hash tables and therefore do not have to make any changes + ** to any of those tables. + */ + for(i=0; inDb; i++){ + struct Db *pDb = &db->aDb[i]; + if( pDb->pBt==0 ){ + if( pDb->pAux && pDb->xFreeAux ) pDb->xFreeAux(pDb->pAux); + pDb->pAux = 0; + } + } + for(i=j=2; inDb; i++){ + struct Db *pDb = &db->aDb[i]; + if( pDb->pBt==0 ){ + sqlite3_free(pDb->zName); + pDb->zName = 0; + continue; + } + if( jaDb[j] = db->aDb[i]; + } + j++; + } + memset(&db->aDb[j], 0, (db->nDb-j)*sizeof(db->aDb[j])); + db->nDb = j; + if( db->nDb<=2 && db->aDb!=db->aDbStatic ){ + memcpy(db->aDbStatic, db->aDb, 2*sizeof(db->aDb[0])); + sqlite3_free(db->aDb); + db->aDb = db->aDbStatic; + } +} + +/* +** This routine is called when a commit occurs. +*/ +void sqlite3CommitInternalChanges(sqlite3 *db){ + db->flags &= ~SQLITE_InternChanges; +} + +/* +** Clear the column names from a table or view. +*/ +static void sqliteResetColumnNames(Table *pTable){ + int i; + Column *pCol; + assert( pTable!=0 ); + if( (pCol = pTable->aCol)!=0 ){ + for(i=0; inCol; i++, pCol++){ + sqlite3_free(pCol->zName); + sqlite3ExprDelete(pCol->pDflt); + sqlite3_free(pCol->zType); + sqlite3_free(pCol->zColl); + } + sqlite3_free(pTable->aCol); + } + pTable->aCol = 0; + pTable->nCol = 0; +} + +/* +** Remove the memory data structures associated with the given +** Table. No changes are made to disk by this routine. +** +** This routine just deletes the data structure. It does not unlink +** the table data structure from the hash table. Nor does it remove +** foreign keys from the sqlite.aFKey hash table. But it does destroy +** memory structures of the indices and foreign keys associated with +** the table. +*/ +void sqlite3DeleteTable(Table *pTable){ + Index *pIndex, *pNext; + FKey *pFKey, *pNextFKey; + + if( pTable==0 ) return; + + /* Do not delete the table until the reference count reaches zero. */ + pTable->nRef--; + if( pTable->nRef>0 ){ + return; + } + assert( pTable->nRef==0 ); + + /* Delete all indices associated with this table + */ + for(pIndex = pTable->pIndex; pIndex; pIndex=pNext){ + pNext = pIndex->pNext; + assert( pIndex->pSchema==pTable->pSchema ); + sqliteDeleteIndex(pIndex); + } + +#ifndef SQLITE_OMIT_FOREIGN_KEY + /* Delete all foreign keys associated with this table. The keys + ** should have already been unlinked from the pSchema->aFKey hash table + */ + for(pFKey=pTable->pFKey; pFKey; pFKey=pNextFKey){ + pNextFKey = pFKey->pNextFrom; + assert( sqlite3HashFind(&pTable->pSchema->aFKey, + pFKey->zTo, strlen(pFKey->zTo)+1)!=pFKey ); + sqlite3_free(pFKey); + } +#endif + + /* Delete the Table structure itself. + */ + sqliteResetColumnNames(pTable); + sqlite3_free(pTable->zName); + sqlite3_free(pTable->zColAff); + sqlite3SelectDelete(pTable->pSelect); +#ifndef SQLITE_OMIT_CHECK + sqlite3ExprDelete(pTable->pCheck); +#endif + sqlite3VtabClear(pTable); + sqlite3_free(pTable); +} + +/* +** Unlink the given table from the hash tables and the delete the +** table structure with all its indices and foreign keys. +*/ +void sqlite3UnlinkAndDeleteTable(sqlite3 *db, int iDb, const char *zTabName){ + Table *p; + FKey *pF1, *pF2; + Db *pDb; + + assert( db!=0 ); + assert( iDb>=0 && iDbnDb ); + assert( zTabName && zTabName[0] ); + pDb = &db->aDb[iDb]; + p = (Table*)sqlite3HashInsert(&pDb->pSchema->tblHash, zTabName, strlen(zTabName)+1,0); + if( p ){ +#ifndef SQLITE_OMIT_FOREIGN_KEY + for(pF1=p->pFKey; pF1; pF1=pF1->pNextFrom){ + int nTo = strlen(pF1->zTo) + 1; + pF2 = (FKey*)sqlite3HashFind(&pDb->pSchema->aFKey, pF1->zTo, nTo); + if( pF2==pF1 ){ + sqlite3HashInsert(&pDb->pSchema->aFKey, pF1->zTo, nTo, pF1->pNextTo); + }else{ + while( pF2 && pF2->pNextTo!=pF1 ){ pF2=pF2->pNextTo; } + if( pF2 ){ + pF2->pNextTo = pF1->pNextTo; + } + } + } +#endif + sqlite3DeleteTable(p); + } + db->flags |= SQLITE_InternChanges; +} + +/* +** Given a token, return a string that consists of the text of that +** token with any quotations removed. Space to hold the returned string +** is obtained from sqliteMalloc() and must be freed by the calling +** function. +** +** Tokens are often just pointers into the original SQL text and so +** are not \000 terminated and are not persistent. The returned string +** is \000 terminated and is persistent. +*/ +char *sqlite3NameFromToken(sqlite3 *db, Token *pName){ + char *zName; + if( pName ){ + zName = sqlite3DbStrNDup(db, (char*)pName->z, pName->n); + sqlite3Dequote(zName); + }else{ + zName = 0; + } + return zName; +} + +/* +** Open the sqlite_master table stored in database number iDb for +** writing. The table is opened using cursor 0. +*/ +void sqlite3OpenMasterTable(Parse *p, int iDb){ + Vdbe *v = sqlite3GetVdbe(p); + sqlite3TableLock(p, iDb, MASTER_ROOT, 1, SCHEMA_TABLE(iDb)); + sqlite3VdbeAddOp(v, OP_Integer, iDb, 0); + sqlite3VdbeAddOp(v, OP_OpenWrite, 0, MASTER_ROOT); + sqlite3VdbeAddOp(v, OP_SetNumColumns, 0, 5); /* sqlite_master has 5 columns */ +} + +/* +** The token *pName contains the name of a database (either "main" or +** "temp" or the name of an attached db). This routine returns the +** index of the named database in db->aDb[], or -1 if the named db +** does not exist. +*/ +int sqlite3FindDb(sqlite3 *db, Token *pName){ + int i = -1; /* Database number */ + int n; /* Number of characters in the name */ + Db *pDb; /* A database whose name space is being searched */ + char *zName; /* Name we are searching for */ + + zName = sqlite3NameFromToken(db, pName); + if( zName ){ + n = strlen(zName); + for(i=(db->nDb-1), pDb=&db->aDb[i]; i>=0; i--, pDb--){ + if( (!OMIT_TEMPDB || i!=1 ) && n==strlen(pDb->zName) && + 0==sqlite3StrICmp(pDb->zName, zName) ){ + break; + } + } + sqlite3_free(zName); + } + return i; +} + +/* The table or view or trigger name is passed to this routine via tokens +** pName1 and pName2. If the table name was fully qualified, for example: +** +** CREATE TABLE xxx.yyy (...); +** +** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if +** the table name is not fully qualified, i.e.: +** +** CREATE TABLE yyy(...); +** +** Then pName1 is set to "yyy" and pName2 is "". +** +** This routine sets the *ppUnqual pointer to point at the token (pName1 or +** pName2) that stores the unqualified table name. The index of the +** database "xxx" is returned. +*/ +int sqlite3TwoPartName( + Parse *pParse, /* Parsing and code generating context */ + Token *pName1, /* The "xxx" in the name "xxx.yyy" or "xxx" */ + Token *pName2, /* The "yyy" in the name "xxx.yyy" */ + Token **pUnqual /* Write the unqualified object name here */ +){ + int iDb; /* Database holding the object */ + sqlite3 *db = pParse->db; + + if( pName2 && pName2->n>0 ){ + assert( !db->init.busy ); + *pUnqual = pName2; + iDb = sqlite3FindDb(db, pName1); + if( iDb<0 ){ + sqlite3ErrorMsg(pParse, "unknown database %T", pName1); + pParse->nErr++; + return -1; + } + }else{ + assert( db->init.iDb==0 || db->init.busy ); + iDb = db->init.iDb; + *pUnqual = pName1; + } + return iDb; +} + +/* +** This routine is used to check if the UTF-8 string zName is a legal +** unqualified name for a new schema object (table, index, view or +** trigger). All names are legal except those that begin with the string +** "sqlite_" (in upper, lower or mixed case). This portion of the namespace +** is reserved for internal use. +*/ +int sqlite3CheckObjectName(Parse *pParse, const char *zName){ + if( !pParse->db->init.busy && pParse->nested==0 + && (pParse->db->flags & SQLITE_WriteSchema)==0 + && 0==sqlite3StrNICmp(zName, "sqlite_", 7) ){ + sqlite3ErrorMsg(pParse, "object name reserved for internal use: %s", zName); + return SQLITE_ERROR; + } + return SQLITE_OK; +} + +/* +** Begin constructing a new table representation in memory. This is +** the first of several action routines that get called in response +** to a CREATE TABLE statement. In particular, this routine is called +** after seeing tokens "CREATE" and "TABLE" and the table name. The isTemp +** flag is true if the table should be stored in the auxiliary database +** file instead of in the main database file. This is normally the case +** when the "TEMP" or "TEMPORARY" keyword occurs in between +** CREATE and TABLE. +** +** The new table record is initialized and put in pParse->pNewTable. +** As more of the CREATE TABLE statement is parsed, additional action +** routines will be called to add more information to this record. +** At the end of the CREATE TABLE statement, the sqlite3EndTable() routine +** is called to complete the construction of the new table record. +*/ +void sqlite3StartTable( + Parse *pParse, /* Parser context */ + Token *pName1, /* First part of the name of the table or view */ + Token *pName2, /* Second part of the name of the table or view */ + int isTemp, /* True if this is a TEMP table */ + int isView, /* True if this is a VIEW */ + int isVirtual, /* True if this is a VIRTUAL table */ + int noErr /* Do nothing if table already exists */ +){ + Table *pTable; + char *zName = 0; /* The name of the new table */ + sqlite3 *db = pParse->db; + Vdbe *v; + int iDb; /* Database number to create the table in */ + Token *pName; /* Unqualified name of the table to create */ + + /* The table or view name to create is passed to this routine via tokens + ** pName1 and pName2. If the table name was fully qualified, for example: + ** + ** CREATE TABLE xxx.yyy (...); + ** + ** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if + ** the table name is not fully qualified, i.e.: + ** + ** CREATE TABLE yyy(...); + ** + ** Then pName1 is set to "yyy" and pName2 is "". + ** + ** The call below sets the pName pointer to point at the token (pName1 or + ** pName2) that stores the unqualified table name. The variable iDb is + ** set to the index of the database that the table or view is to be + ** created in. + */ + iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName); + if( iDb<0 ) return; + if( !OMIT_TEMPDB && isTemp && iDb>1 ){ + /* If creating a temp table, the name may not be qualified */ + sqlite3ErrorMsg(pParse, "temporary table name must be unqualified"); + return; + } + if( !OMIT_TEMPDB && isTemp ) iDb = 1; + + pParse->sNameToken = *pName; + zName = sqlite3NameFromToken(db, pName); + if( zName==0 ) return; + if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){ + goto begin_table_error; + } + if( db->init.iDb==1 ) isTemp = 1; +#ifndef SQLITE_OMIT_AUTHORIZATION + assert( (isTemp & 1)==isTemp ); + { + int code; + char *zDb = db->aDb[iDb].zName; + if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(isTemp), 0, zDb) ){ + goto begin_table_error; + } + if( isView ){ + if( !OMIT_TEMPDB && isTemp ){ + code = SQLITE_CREATE_TEMP_VIEW; + }else{ + code = SQLITE_CREATE_VIEW; + } + }else{ + if( !OMIT_TEMPDB && isTemp ){ + code = SQLITE_CREATE_TEMP_TABLE; + }else{ + code = SQLITE_CREATE_TABLE; + } + } + if( !isVirtual && sqlite3AuthCheck(pParse, code, zName, 0, zDb) ){ + goto begin_table_error; + } + } +#endif + + /* Make sure the new table name does not collide with an existing + ** index or table name in the same database. Issue an error message if + ** it does. The exception is if the statement being parsed was passed + ** to an sqlite3_declare_vtab() call. In that case only the column names + ** and types will be used, so there is no need to test for namespace + ** collisions. + */ + if( !IN_DECLARE_VTAB ){ + if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){ + goto begin_table_error; + } + pTable = sqlite3FindTable(db, zName, db->aDb[iDb].zName); + if( pTable ){ + if( !noErr ){ + sqlite3ErrorMsg(pParse, "table %T already exists", pName); + } + goto begin_table_error; + } + if( sqlite3FindIndex(db, zName, 0)!=0 && (iDb==0 || !db->init.busy) ){ + sqlite3ErrorMsg(pParse, "there is already an index named %s", zName); + goto begin_table_error; + } + } + + pTable = (Table*)sqlite3DbMallocZero(db, sizeof(Table)); + if( pTable==0 ){ + db->mallocFailed = 1; + pParse->rc = SQLITE_NOMEM; + pParse->nErr++; + goto begin_table_error; + } + pTable->zName = zName; + pTable->iPKey = -1; + pTable->pSchema = db->aDb[iDb].pSchema; + pTable->nRef = 1; + if( pParse->pNewTable ) sqlite3DeleteTable(pParse->pNewTable); + pParse->pNewTable = pTable; + + /* If this is the magic sqlite_sequence table used by autoincrement, + ** then record a pointer to this table in the main database structure + ** so that INSERT can find the table easily. + */ +#ifndef SQLITE_OMIT_AUTOINCREMENT + if( !pParse->nested && strcmp(zName, "sqlite_sequence")==0 ){ + pTable->pSchema->pSeqTab = pTable; + } +#endif + + /* Begin generating the code that will insert the table record into + ** the SQLITE_MASTER table. Note in particular that we must go ahead + ** and allocate the record number for the table entry now. Before any + ** PRIMARY KEY or UNIQUE keywords are parsed. Those keywords will cause + ** indices to be created and the table record must come before the + ** indices. Hence, the record number for the table must be allocated + ** now. + */ + if( !db->init.busy && (v = sqlite3GetVdbe(pParse))!=0 ){ + int lbl; + int fileFormat; + sqlite3BeginWriteOperation(pParse, 0, iDb); + +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( isVirtual ){ + sqlite3VdbeAddOp(v, OP_VBegin, 0, 0); + } +#endif + + /* If the file format and encoding in the database have not been set, + ** set them now. + */ + sqlite3VdbeAddOp(v, OP_ReadCookie, iDb, 1); /* file_format */ + sqlite3VdbeUsesBtree(v, iDb); + lbl = sqlite3VdbeMakeLabel(v); + sqlite3VdbeAddOp(v, OP_If, 0, lbl); + fileFormat = (db->flags & SQLITE_LegacyFileFmt)!=0 ? + 1 : SQLITE_MAX_FILE_FORMAT; + sqlite3VdbeAddOp(v, OP_Integer, fileFormat, 0); + sqlite3VdbeAddOp(v, OP_SetCookie, iDb, 1); + sqlite3VdbeAddOp(v, OP_Integer, ENC(db), 0); + sqlite3VdbeAddOp(v, OP_SetCookie, iDb, 4); + sqlite3VdbeResolveLabel(v, lbl); + + /* This just creates a place-holder record in the sqlite_master table. + ** The record created does not contain anything yet. It will be replaced + ** by the real entry in code generated at sqlite3EndTable(). + ** + ** The rowid for the new entry is left on the top of the stack. + ** The rowid value is needed by the code that sqlite3EndTable will + ** generate. + */ +#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) + if( isView || isVirtual ){ + sqlite3VdbeAddOp(v, OP_Integer, 0, 0); + }else +#endif + { + sqlite3VdbeAddOp(v, OP_CreateTable, iDb, 0); + } + sqlite3OpenMasterTable(pParse, iDb); + sqlite3VdbeAddOp(v, OP_NewRowid, 0, 0); + sqlite3VdbeAddOp(v, OP_Dup, 0, 0); + sqlite3VdbeAddOp(v, OP_Null, 0, 0); + sqlite3VdbeAddOp(v, OP_Insert, 0, OPFLAG_APPEND); + sqlite3VdbeAddOp(v, OP_Close, 0, 0); + sqlite3VdbeAddOp(v, OP_Pull, 1, 0); + } + + /* Normal (non-error) return. */ + return; + + /* If an error occurs, we jump here */ +begin_table_error: + sqlite3_free(zName); + return; +} + +/* +** This macro is used to compare two strings in a case-insensitive manner. +** It is slightly faster than calling sqlite3StrICmp() directly, but +** produces larger code. +** +** WARNING: This macro is not compatible with the strcmp() family. It +** returns true if the two strings are equal, otherwise false. +*/ +#define STRICMP(x, y) (\ +sqlite3UpperToLower[*(unsigned char *)(x)]== \ +sqlite3UpperToLower[*(unsigned char *)(y)] \ +&& sqlite3StrICmp((x)+1,(y)+1)==0 ) + +/* +** Add a new column to the table currently being constructed. +** +** The parser calls this routine once for each column declaration +** in a CREATE TABLE statement. sqlite3StartTable() gets called +** first to get things going. Then this routine is called for each +** column. +*/ +void sqlite3AddColumn(Parse *pParse, Token *pName){ + Table *p; + int i; + char *z; + Column *pCol; + if( (p = pParse->pNewTable)==0 ) return; + if( p->nCol+1>SQLITE_MAX_COLUMN ){ + sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName); + return; + } + z = sqlite3NameFromToken(pParse->db, pName); + if( z==0 ) return; + for(i=0; inCol; i++){ + if( STRICMP(z, p->aCol[i].zName) ){ + sqlite3ErrorMsg(pParse, "duplicate column name: %s", z); + sqlite3_free(z); + return; + } + } + if( (p->nCol & 0x7)==0 ){ + Column *aNew; + aNew = (Column*)sqlite3DbRealloc(pParse->db,p->aCol,(p->nCol+8)*sizeof(p->aCol[0])); + if( aNew==0 ){ + sqlite3_free(z); + return; + } + p->aCol = aNew; + } + pCol = &p->aCol[p->nCol]; + memset(pCol, 0, sizeof(p->aCol[0])); + pCol->zName = z; + + /* If there is no type specified, columns have the default affinity + ** 'NONE'. If there is a type specified, then sqlite3AddColumnType() will + ** be called next to set pCol->affinity correctly. + */ + pCol->affinity = SQLITE_AFF_NONE; + p->nCol++; +} + +/* +** This routine is called by the parser while in the middle of +** parsing a CREATE TABLE statement. A "NOT NULL" constraint has +** been seen on a column. This routine sets the notNull flag on +** the column currently under construction. +*/ +void sqlite3AddNotNull(Parse *pParse, int onError){ + Table *p; + int i; + if( (p = pParse->pNewTable)==0 ) return; + i = p->nCol-1; + if( i>=0 ) p->aCol[i].notNull = onError; +} + +/* +** Scan the column type name zType (length nType) and return the +** associated affinity type. +** +** This routine does a case-independent search of zType for the +** substrings in the following table. If one of the substrings is +** found, the corresponding affinity is returned. If zType contains +** more than one of the substrings, entries toward the top of +** the table take priority. For example, if zType is 'BLOBINT', +** SQLITE_AFF_INTEGER is returned. +** +** Substring | Affinity +** -------------------------------- +** 'INT' | SQLITE_AFF_INTEGER +** 'CHAR' | SQLITE_AFF_TEXT +** 'CLOB' | SQLITE_AFF_TEXT +** 'TEXT' | SQLITE_AFF_TEXT +** 'BLOB' | SQLITE_AFF_NONE +** 'REAL' | SQLITE_AFF_REAL +** 'FLOA' | SQLITE_AFF_REAL +** 'DOUB' | SQLITE_AFF_REAL +** +** If none of the substrings in the above table are found, +** SQLITE_AFF_NUMERIC is returned. +*/ +char sqlite3AffinityType(const Token *pType){ + u32 h = 0; + char aff = SQLITE_AFF_NUMERIC; + const unsigned char *zIn = pType->z; + const unsigned char *zEnd = &pType->z[pType->n]; + + while( zIn!=zEnd ){ + h = (h<<8) + sqlite3UpperToLower[*zIn]; + zIn++; + if( h==(('c'<<24)+('h'<<16)+('a'<<8)+'r') ){ /* CHAR */ + aff = SQLITE_AFF_TEXT; + }else if( h==(('c'<<24)+('l'<<16)+('o'<<8)+'b') ){ /* CLOB */ + aff = SQLITE_AFF_TEXT; + }else if( h==(('t'<<24)+('e'<<16)+('x'<<8)+'t') ){ /* TEXT */ + aff = SQLITE_AFF_TEXT; + }else if( h==(('b'<<24)+('l'<<16)+('o'<<8)+'b') /* BLOB */ + && (aff==SQLITE_AFF_NUMERIC || aff==SQLITE_AFF_REAL) ){ + aff = SQLITE_AFF_NONE; +#ifndef SQLITE_OMIT_FLOATING_POINT + }else if( h==(('r'<<24)+('e'<<16)+('a'<<8)+'l') /* REAL */ + && aff==SQLITE_AFF_NUMERIC ){ + aff = SQLITE_AFF_REAL; + }else if( h==(('f'<<24)+('l'<<16)+('o'<<8)+'a') /* FLOA */ + && aff==SQLITE_AFF_NUMERIC ){ + aff = SQLITE_AFF_REAL; + }else if( h==(('d'<<24)+('o'<<16)+('u'<<8)+'b') /* DOUB */ + && aff==SQLITE_AFF_NUMERIC ){ + aff = SQLITE_AFF_REAL; +#endif + }else if( (h&0x00FFFFFF)==(('i'<<16)+('n'<<8)+'t') ){ /* INT */ + aff = SQLITE_AFF_INTEGER; + break; + } + } + + return aff; +} + +/* +** This routine is called by the parser while in the middle of +** parsing a CREATE TABLE statement. The pFirst token is the first +** token in the sequence of tokens that describe the type of the +** column currently under construction. pLast is the last token +** in the sequence. Use this information to construct a string +** that contains the typename of the column and store that string +** in zType. +*/ +void sqlite3AddColumnType(Parse *pParse, Token *pType){ + Table *p; + int i; + Column *pCol; + + if( (p = pParse->pNewTable)==0 ) return; + i = p->nCol-1; + if( i<0 ) return; + pCol = &p->aCol[i]; + sqlite3_free(pCol->zType); + pCol->zType = sqlite3NameFromToken(pParse->db, pType); + pCol->affinity = sqlite3AffinityType(pType); +} + +/* +** The expression is the default value for the most recently added column +** of the table currently under construction. +** +** Default value expressions must be constant. Raise an exception if this +** is not the case. +** +** This routine is called by the parser while in the middle of +** parsing a CREATE TABLE statement. +*/ +void sqlite3AddDefaultValue(Parse *pParse, Expr *pExpr){ + Table *p; + Column *pCol; + if( (p = pParse->pNewTable)!=0 ){ + pCol = &(p->aCol[p->nCol-1]); + if( !sqlite3ExprIsConstantOrFunction(pExpr) ){ + sqlite3ErrorMsg(pParse, "default value of column [%s] is not constant", + pCol->zName); + }else{ + Expr *pCopy; + sqlite3 *db = pParse->db; + sqlite3ExprDelete(pCol->pDflt); + pCol->pDflt = pCopy = sqlite3ExprDup(db, pExpr); + if( pCopy ){ + sqlite3TokenCopy(db, &pCopy->span, &pExpr->span); + } + } + } + sqlite3ExprDelete(pExpr); +} + +/* +** Designate the PRIMARY KEY for the table. pList is a list of names +** of columns that form the primary key. If pList is NULL, then the +** most recently added column of the table is the primary key. +** +** A table can have at most one primary key. If the table already has +** a primary key (and this is the second primary key) then create an +** error. +** +** If the PRIMARY KEY is on a single column whose datatype is INTEGER, +** then we will try to use that column as the rowid. Set the Table.iPKey +** field of the table under construction to be the index of the +** INTEGER PRIMARY KEY column. Table.iPKey is set to -1 if there is +** no INTEGER PRIMARY KEY. +** +** If the key is not an INTEGER PRIMARY KEY, then create a unique +** index for the key. No index is created for INTEGER PRIMARY KEYs. +*/ +void sqlite3AddPrimaryKey( + Parse *pParse, /* Parsing context */ + ExprList *pList, /* List of field names to be indexed */ + int onError, /* What to do with a uniqueness conflict */ + int autoInc, /* True if the AUTOINCREMENT keyword is present */ + int sortOrder /* SQLITE_SO_ASC or SQLITE_SO_DESC */ +){ + Table *pTab = pParse->pNewTable; + char *zType = 0; + int iCol = -1, i; + if( pTab==0 || IN_DECLARE_VTAB ) goto primary_key_exit; + if( pTab->hasPrimKey ){ + sqlite3ErrorMsg(pParse, + "table \"%s\" has more than one primary key", pTab->zName); + goto primary_key_exit; + } + pTab->hasPrimKey = 1; + if( pList==0 ){ + iCol = pTab->nCol - 1; + pTab->aCol[iCol].isPrimKey = 1; + }else{ + for(i=0; inExpr; i++){ + for(iCol=0; iColnCol; iCol++){ + if( sqlite3StrICmp(pList->a[i].zName, pTab->aCol[iCol].zName)==0 ){ + break; + } + } + if( iColnCol ){ + pTab->aCol[iCol].isPrimKey = 1; + } + } + if( pList->nExpr>1 ) iCol = -1; + } + if( iCol>=0 && iColnCol ){ + zType = pTab->aCol[iCol].zType; + } + if( zType && sqlite3StrICmp(zType, "INTEGER")==0 + && sortOrder==SQLITE_SO_ASC ){ + pTab->iPKey = iCol; + pTab->keyConf = onError; + pTab->autoInc = autoInc; + }else if( autoInc ){ +#ifndef SQLITE_OMIT_AUTOINCREMENT + sqlite3ErrorMsg(pParse, "AUTOINCREMENT is only allowed on an " + "INTEGER PRIMARY KEY"); +#endif + }else{ + sqlite3CreateIndex(pParse, 0, 0, 0, pList, onError, 0, 0, sortOrder, 0); + pList = 0; + } + +primary_key_exit: + sqlite3ExprListDelete(pList); + return; +} + +/* +** Add a new CHECK constraint to the table currently under construction. +*/ +void sqlite3AddCheckConstraint( + Parse *pParse, /* Parsing context */ + Expr *pCheckExpr /* The check expression */ +){ +#ifndef SQLITE_OMIT_CHECK + Table *pTab = pParse->pNewTable; + sqlite3 *db = pParse->db; + if( pTab && !IN_DECLARE_VTAB ){ + /* The CHECK expression must be duplicated so that tokens refer + ** to malloced space and not the (ephemeral) text of the CREATE TABLE + ** statement */ + pTab->pCheck = sqlite3ExprAnd(db, pTab->pCheck, + sqlite3ExprDup(db, pCheckExpr)); + } +#endif + sqlite3ExprDelete(pCheckExpr); +} + +/* +** Set the collation function of the most recently parsed table column +** to the CollSeq given. +*/ +void sqlite3AddCollateType(Parse *pParse, Token *pToken){ + Table *p; + int i; + char *zColl; /* Dequoted name of collation sequence */ + + if( (p = pParse->pNewTable)==0 ) return; + i = p->nCol-1; + + zColl = sqlite3NameFromToken(pParse->db, pToken); + if( !zColl ) return; + + if( sqlite3LocateCollSeq(pParse, zColl, -1) ){ + Index *pIdx; + p->aCol[i].zColl = zColl; + + /* If the column is declared as " PRIMARY KEY COLLATE ", + ** then an index may have been created on this column before the + ** collation type was added. Correct this if it is the case. + */ + for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){ + assert( pIdx->nColumn==1 ); + if( pIdx->aiColumn[0]==i ){ + pIdx->azColl[0] = p->aCol[i].zColl; + } + } + }else{ + sqlite3_free(zColl); + } +} + +/* +** This function returns the collation sequence for database native text +** encoding identified by the string zName, length nName. +** +** If the requested collation sequence is not available, or not available +** in the database native encoding, the collation factory is invoked to +** request it. If the collation factory does not supply such a sequence, +** and the sequence is available in another text encoding, then that is +** returned instead. +** +** If no versions of the requested collations sequence are available, or +** another error occurs, NULL is returned and an error message written into +** pParse. +** +** This routine is a wrapper around sqlite3FindCollSeq(). This routine +** invokes the collation factory if the named collation cannot be found +** and generates an error message. +*/ +CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char *zName, int nName){ + sqlite3 *db = pParse->db; + u8 enc = ENC(db); + u8 initbusy = db->init.busy; + CollSeq *pColl; + + pColl = sqlite3FindCollSeq(db, enc, zName, nName, initbusy); + if( !initbusy && (!pColl || !pColl->xCmp) ){ + pColl = sqlite3GetCollSeq(db, pColl, zName, nName); + if( !pColl ){ + if( nName<0 ){ + nName = strlen(zName); + } + sqlite3ErrorMsg(pParse, "no such collation sequence: %.*s", nName, zName); + pColl = 0; + } + } + + return pColl; +} + + +/* +** Generate code that will increment the schema cookie. +** +** The schema cookie is used to determine when the schema for the +** database changes. After each schema change, the cookie value +** changes. When a process first reads the schema it records the +** cookie. Thereafter, whenever it goes to access the database, +** it checks the cookie to make sure the schema has not changed +** since it was last read. +** +** This plan is not completely bullet-proof. It is possible for +** the schema to change multiple times and for the cookie to be +** set back to prior value. But schema changes are infrequent +** and the probability of hitting the same cookie value is only +** 1 chance in 2^32. So we're safe enough. +*/ +void sqlite3ChangeCookie(sqlite3 *db, Vdbe *v, int iDb){ + sqlite3VdbeAddOp(v, OP_Integer, db->aDb[iDb].pSchema->schema_cookie+1, 0); + sqlite3VdbeAddOp(v, OP_SetCookie, iDb, 0); +} + +/* +** Measure the number of characters needed to output the given +** identifier. The number returned includes any quotes used +** but does not include the null terminator. +** +** The estimate is conservative. It might be larger that what is +** really needed. +*/ +static int identLength(const char *z){ + int n; + for(n=0; *z; n++, z++){ + if( *z=='"' ){ n++; } + } + return n + 2; +} + +/* +** Write an identifier onto the end of the given string. Add +** quote characters as needed. +*/ +static void identPut(char *z, int *pIdx, char *zSignedIdent){ + unsigned char *zIdent = (unsigned char*)zSignedIdent; + int i, j, needQuote; + i = *pIdx; + for(j=0; zIdent[j]; j++){ + if( !isalnum(zIdent[j]) && zIdent[j]!='_' ) break; + } + needQuote = zIdent[j]!=0 || isdigit(zIdent[0]) + || sqlite3KeywordCode(zIdent, j)!=TK_ID; + if( needQuote ) z[i++] = '"'; + for(j=0; zIdent[j]; j++){ + z[i++] = zIdent[j]; + if( zIdent[j]=='"' ) z[i++] = '"'; + } + if( needQuote ) z[i++] = '"'; + z[i] = 0; + *pIdx = i; +} + +/* +** Generate a CREATE TABLE statement appropriate for the given +** table. Memory to hold the text of the statement is obtained +** from sqliteMalloc() and must be freed by the calling function. +*/ +static char *createTableStmt(Table *p, int isTemp){ + int i, k, n; + char *zStmt; + char *zSep, *zSep2, *zEnd, *z; + Column *pCol; + n = 0; + for(pCol = p->aCol, i=0; inCol; i++, pCol++){ + n += identLength(pCol->zName); + z = pCol->zType; + if( z ){ + n += (strlen(z) + 1); + } + } + n += identLength(p->zName); + if( n<50 ){ + zSep = ""; + zSep2 = ","; + zEnd = ")"; + }else{ + zSep = "\n "; + zSep2 = ",\n "; + zEnd = "\n)"; + } + n += 35 + 6*p->nCol; + zStmt = (char*)sqlite3_malloc( n ); + if( zStmt==0 ) return 0; + sqlite3_snprintf(n, zStmt, + !OMIT_TEMPDB&&isTemp ? "CREATE TEMP TABLE ":"CREATE TABLE "); + k = strlen(zStmt); + identPut(zStmt, &k, p->zName); + zStmt[k++] = '('; + for(pCol=p->aCol, i=0; inCol; i++, pCol++){ + sqlite3_snprintf(n-k, &zStmt[k], zSep); + k += strlen(&zStmt[k]); + zSep = zSep2; + identPut(zStmt, &k, pCol->zName); + if( (z = pCol->zType)!=0 ){ + zStmt[k++] = ' '; + assert( strlen(z)+k+1<=n ); + sqlite3_snprintf(n-k, &zStmt[k], "%s", z); + k += strlen(z); + } + } + sqlite3_snprintf(n-k, &zStmt[k], "%s", zEnd); + return zStmt; +} + +/* +** This routine is called to report the final ")" that terminates +** a CREATE TABLE statement. +** +** The table structure that other action routines have been building +** is added to the internal hash tables, assuming no errors have +** occurred. +** +** An entry for the table is made in the master table on disk, unless +** this is a temporary table or db->init.busy==1. When db->init.busy==1 +** it means we are reading the sqlite_master table because we just +** connected to the database or because the sqlite_master table has +** recently changed, so the entry for this table already exists in +** the sqlite_master table. We do not want to create it again. +** +** If the pSelect argument is not NULL, it means that this routine +** was called to create a table generated from a +** "CREATE TABLE ... AS SELECT ..." statement. The column names of +** the new table will match the result set of the SELECT. +*/ +void sqlite3EndTable( + Parse *pParse, /* Parse context */ + Token *pCons, /* The ',' token after the last column defn. */ + Token *pEnd, /* The final ')' token in the CREATE TABLE */ + Select *pSelect /* Select from a "CREATE ... AS SELECT" */ +){ + Table *p; + sqlite3 *db = pParse->db; + int iDb; + + if( (pEnd==0 && pSelect==0) || pParse->nErr || db->mallocFailed ) { + return; + } + p = pParse->pNewTable; + if( p==0 ) return; + + assert( !db->init.busy || !pSelect ); + + iDb = sqlite3SchemaToIndex(db, p->pSchema); + +#ifndef SQLITE_OMIT_CHECK + /* Resolve names in all CHECK constraint expressions. + */ + if( p->pCheck ){ + SrcList sSrc; /* Fake SrcList for pParse->pNewTable */ + NameContext sNC; /* Name context for pParse->pNewTable */ + + memset(&sNC, 0, sizeof(sNC)); + memset(&sSrc, 0, sizeof(sSrc)); + sSrc.nSrc = 1; + sSrc.a[0].zName = p->zName; + sSrc.a[0].pTab = p; + sSrc.a[0].iCursor = -1; + sNC.pParse = pParse; + sNC.pSrcList = &sSrc; + sNC.isCheck = 1; + if( sqlite3ExprResolveNames(&sNC, p->pCheck) ){ + return; + } + } +#endif /* !defined(SQLITE_OMIT_CHECK) */ + + /* If the db->init.busy is 1 it means we are reading the SQL off the + ** "sqlite_master" or "sqlite_temp_master" table on the disk. + ** So do not write to the disk again. Extract the root page number + ** for the table from the db->init.newTnum field. (The page number + ** should have been put there by the sqliteOpenCb routine.) + */ + if( db->init.busy ){ + p->tnum = db->init.newTnum; + } + + /* If not initializing, then create a record for the new table + ** in the SQLITE_MASTER table of the database. The record number + ** for the new table entry should already be on the stack. + ** + ** If this is a TEMPORARY table, write the entry into the auxiliary + ** file instead of into the main database file. + */ + if( !db->init.busy ){ + int n; + Vdbe *v; + char *zType; /* "view" or "table" */ + char *zType2; /* "VIEW" or "TABLE" */ + char *zStmt; /* Text of the CREATE TABLE or CREATE VIEW statement */ + + v = sqlite3GetVdbe(pParse); + if( v==0 ) return; + + sqlite3VdbeAddOp(v, OP_Close, 0, 0); + + /* Create the rootpage for the new table and push it onto the stack. + ** A view has no rootpage, so just push a zero onto the stack for + ** views. Initialize zType at the same time. + */ + if( p->pSelect==0 ){ + /* A regular table */ + zType = "table"; + zType2 = "TABLE"; +#ifndef SQLITE_OMIT_VIEW + }else{ + /* A view */ + zType = "view"; + zType2 = "VIEW"; +#endif + } + + /* If this is a CREATE TABLE xx AS SELECT ..., execute the SELECT + ** statement to populate the new table. The root-page number for the + ** new table is on the top of the vdbe stack. + ** + ** Once the SELECT has been coded by sqlite3Select(), it is in a + ** suitable state to query for the column names and types to be used + ** by the new table. + ** + ** A shared-cache write-lock is not required to write to the new table, + ** as a schema-lock must have already been obtained to create it. Since + ** a schema-lock excludes all other database users, the write-lock would + ** be redundant. + */ + if( pSelect ){ + Table *pSelTab; + sqlite3VdbeAddOp(v, OP_Dup, 0, 0); + sqlite3VdbeAddOp(v, OP_Integer, iDb, 0); + sqlite3VdbeAddOp(v, OP_OpenWrite, 1, 0); + pParse->nTab = 2; + sqlite3Select(pParse, pSelect, SRT_Table, 1, 0, 0, 0, 0); + sqlite3VdbeAddOp(v, OP_Close, 1, 0); + if( pParse->nErr==0 ){ + pSelTab = sqlite3ResultSetOfSelect(pParse, 0, pSelect); + if( pSelTab==0 ) return; + assert( p->aCol==0 ); + p->nCol = pSelTab->nCol; + p->aCol = pSelTab->aCol; + pSelTab->nCol = 0; + pSelTab->aCol = 0; + sqlite3DeleteTable(pSelTab); + } + } + + /* Compute the complete text of the CREATE statement */ + if( pSelect ){ + zStmt = createTableStmt(p, p->pSchema==db->aDb[1].pSchema); + }else{ + n = pEnd->z - pParse->sNameToken.z + 1; + zStmt = sqlite3MPrintf(db, + "CREATE %s %.*s", zType2, n, pParse->sNameToken.z + ); + } + + /* A slot for the record has already been allocated in the + ** SQLITE_MASTER table. We just need to update that slot with all + ** the information we've collected. The rowid for the preallocated + ** slot is the 2nd item on the stack. The top of the stack is the + ** root page for the new table (or a 0 if this is a view). + */ + sqlite3NestedParse(pParse, + "UPDATE %Q.%s " + "SET type='%s', name=%Q, tbl_name=%Q, rootpage=#0, sql=%Q " + "WHERE rowid=#1", + db->aDb[iDb].zName, SCHEMA_TABLE(iDb), + zType, + p->zName, + p->zName, + zStmt + ); + sqlite3_free(zStmt); + sqlite3ChangeCookie(db, v, iDb); + +#ifndef SQLITE_OMIT_AUTOINCREMENT + /* Check to see if we need to create an sqlite_sequence table for + ** keeping track of autoincrement keys. + */ + if( p->autoInc ){ + Db *pDb = &db->aDb[iDb]; + if( pDb->pSchema->pSeqTab==0 ){ + sqlite3NestedParse(pParse, + "CREATE TABLE %Q.sqlite_sequence(name,seq)", + pDb->zName + ); + } + } +#endif + + /* Reparse everything to update our internal data structures */ + sqlite3VdbeOp3(v, OP_ParseSchema, iDb, 0, + sqlite3MPrintf(db, "tbl_name='%q'",p->zName), P3_DYNAMIC); + } + + + /* Add the table to the in-memory representation of the database. + */ + if( db->init.busy && pParse->nErr==0 ){ + Table *pOld; + FKey *pFKey; + Schema *pSchema = p->pSchema; + pOld = (Table*)sqlite3HashInsert(&pSchema->tblHash, p->zName, strlen(p->zName)+1,p); + if( pOld ){ + assert( p==pOld ); /* Malloc must have failed inside HashInsert() */ + db->mallocFailed = 1; + return; + } +#ifndef SQLITE_OMIT_FOREIGN_KEY + for(pFKey=p->pFKey; pFKey; pFKey=pFKey->pNextFrom){ + void *data; + int nTo = strlen(pFKey->zTo) + 1; + pFKey->pNextTo = (FKey*)sqlite3HashFind(&pSchema->aFKey, pFKey->zTo, nTo); + data = sqlite3HashInsert(&pSchema->aFKey, pFKey->zTo, nTo, pFKey); + if( data==(void *)pFKey ){ + db->mallocFailed = 1; + } + } +#endif + pParse->pNewTable = 0; + db->nTable++; + db->flags |= SQLITE_InternChanges; + +#ifndef SQLITE_OMIT_ALTERTABLE + if( !p->pSelect ){ + const char *zName = (const char *)pParse->sNameToken.z; + int nName; + assert( !pSelect && pCons && pEnd ); + if( pCons->z==0 ){ + pCons = pEnd; + } + nName = (const char *)pCons->z - zName; + p->addColOffset = 13 + sqlite3Utf8CharLen(zName, nName); + } +#endif + } +} + +#ifndef SQLITE_OMIT_VIEW +/* +** The parser calls this routine in order to create a new VIEW +*/ +void sqlite3CreateView( + Parse *pParse, /* The parsing context */ + Token *pBegin, /* The CREATE token that begins the statement */ + Token *pName1, /* The token that holds the name of the view */ + Token *pName2, /* The token that holds the name of the view */ + Select *pSelect, /* A SELECT statement that will become the new view */ + int isTemp, /* TRUE for a TEMPORARY view */ + int noErr /* Suppress error messages if VIEW already exists */ +){ + Table *p; + int n; + const unsigned char *z; + Token sEnd; + DbFixer sFix; + Token *pName; + int iDb; + sqlite3 *db = pParse->db; + + if( pParse->nVar>0 ){ + sqlite3ErrorMsg(pParse, "parameters are not allowed in views"); + sqlite3SelectDelete(pSelect); + return; + } + sqlite3StartTable(pParse, pName1, pName2, isTemp, 1, 0, noErr); + p = pParse->pNewTable; + if( p==0 || pParse->nErr ){ + sqlite3SelectDelete(pSelect); + return; + } + sqlite3TwoPartName(pParse, pName1, pName2, &pName); + iDb = sqlite3SchemaToIndex(db, p->pSchema); + if( sqlite3FixInit(&sFix, pParse, iDb, "view", pName) + && sqlite3FixSelect(&sFix, pSelect) + ){ + sqlite3SelectDelete(pSelect); + return; + } + + /* Make a copy of the entire SELECT statement that defines the view. + ** This will force all the Expr.token.z values to be dynamically + ** allocated rather than point to the input string - which means that + ** they will persist after the current sqlite3_exec() call returns. + */ + p->pSelect = sqlite3SelectDup(db, pSelect); + sqlite3SelectDelete(pSelect); + if( db->mallocFailed ){ + return; + } + if( !db->init.busy ){ + sqlite3ViewGetColumnNames(pParse, p); + } + + /* Locate the end of the CREATE VIEW statement. Make sEnd point to + ** the end. + */ + sEnd = pParse->sLastToken; + if( sEnd.z[0]!=0 && sEnd.z[0]!=';' ){ + sEnd.z += sEnd.n; + } + sEnd.n = 0; + n = sEnd.z - pBegin->z; + z = (const unsigned char*)pBegin->z; + while( n>0 && (z[n-1]==';' || isspace(z[n-1])) ){ n--; } + sEnd.z = &z[n-1]; + sEnd.n = 1; + + /* Use sqlite3EndTable() to add the view to the SQLITE_MASTER table */ + sqlite3EndTable(pParse, 0, &sEnd, 0); + return; +} +#endif /* SQLITE_OMIT_VIEW */ + +#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) +/* +** The Table structure pTable is really a VIEW. Fill in the names of +** the columns of the view in the pTable structure. Return the number +** of errors. If an error is seen leave an error message in pParse->zErrMsg. +*/ +int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){ + Table *pSelTab; /* A fake table from which we get the result set */ + Select *pSel; /* Copy of the SELECT that implements the view */ + int nErr = 0; /* Number of errors encountered */ + int n; /* Temporarily holds the number of cursors assigned */ + sqlite3 *db = pParse->db; /* Database connection for malloc errors */ + int (*xAuth)(void*,int,const char*,const char*,const char*,const char*); + + assert( pTable ); + +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( sqlite3VtabCallConnect(pParse, pTable) ){ + return SQLITE_ERROR; + } + if( IsVirtual(pTable) ) return 0; +#endif + +#ifndef SQLITE_OMIT_VIEW + /* A positive nCol means the columns names for this view are + ** already known. + */ + if( pTable->nCol>0 ) return 0; + + /* A negative nCol is a special marker meaning that we are currently + ** trying to compute the column names. If we enter this routine with + ** a negative nCol, it means two or more views form a loop, like this: + ** + ** CREATE VIEW one AS SELECT * FROM two; + ** CREATE VIEW two AS SELECT * FROM one; + ** + ** Actually, this error is caught previously and so the following test + ** should always fail. But we will leave it in place just to be safe. + */ + if( pTable->nCol<0 ){ + sqlite3ErrorMsg(pParse, "view %s is circularly defined", pTable->zName); + return 1; + } + assert( pTable->nCol>=0 ); + + /* If we get this far, it means we need to compute the table names. + ** Note that the call to sqlite3ResultSetOfSelect() will expand any + ** "*" elements in the results set of the view and will assign cursors + ** to the elements of the FROM clause. But we do not want these changes + ** to be permanent. So the computation is done on a copy of the SELECT + ** statement that defines the view. + */ + assert( pTable->pSelect ); + pSel = sqlite3SelectDup(db, pTable->pSelect); + if( pSel ){ + n = pParse->nTab; + sqlite3SrcListAssignCursors(pParse, pSel->pSrc); + pTable->nCol = -1; +#ifndef SQLITE_OMIT_AUTHORIZATION + xAuth = db->xAuth; + db->xAuth = 0; + pSelTab = sqlite3ResultSetOfSelect(pParse, 0, pSel); + db->xAuth = xAuth; +#else + pSelTab = sqlite3ResultSetOfSelect(pParse, 0, pSel); +#endif + pParse->nTab = n; + if( pSelTab ){ + assert( pTable->aCol==0 ); + pTable->nCol = pSelTab->nCol; + pTable->aCol = pSelTab->aCol; + pSelTab->nCol = 0; + pSelTab->aCol = 0; + sqlite3DeleteTable(pSelTab); + pTable->pSchema->flags |= DB_UnresetViews; + }else{ + pTable->nCol = 0; + nErr++; + } + sqlite3SelectDelete(pSel); + } else { + nErr++; + } +#endif /* SQLITE_OMIT_VIEW */ + return nErr; +} +#endif /* !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) */ + +#ifndef SQLITE_OMIT_VIEW +/* +** Clear the column names from every VIEW in database idx. +*/ +static void sqliteViewResetAll(sqlite3 *db, int idx){ + HashElem *i; + if( !DbHasProperty(db, idx, DB_UnresetViews) ) return; + for(i=sqliteHashFirst(&db->aDb[idx].pSchema->tblHash); i;i=sqliteHashNext(i)){ + Table *pTab = (Table*)sqliteHashData(i); + if( pTab->pSelect ){ + sqliteResetColumnNames(pTab); + } + } + DbClearProperty(db, idx, DB_UnresetViews); +} +#else +# define sqliteViewResetAll(A,B) +#endif /* SQLITE_OMIT_VIEW */ + +/* +** This function is called by the VDBE to adjust the internal schema +** used by SQLite when the btree layer moves a table root page. The +** root-page of a table or index in database iDb has changed from iFrom +** to iTo. +** +** Ticket #1728: The symbol table might still contain information +** on tables and/or indices that are the process of being deleted. +** If you are unlucky, one of those deleted indices or tables might +** have the same rootpage number as the real table or index that is +** being moved. So we cannot stop searching after the first match +** because the first match might be for one of the deleted indices +** or tables and not the table/index that is actually being moved. +** We must continue looping until all tables and indices with +** rootpage==iFrom have been converted to have a rootpage of iTo +** in order to be certain that we got the right one. +*/ +#ifndef SQLITE_OMIT_AUTOVACUUM +void sqlite3RootPageMoved(Db *pDb, int iFrom, int iTo){ + HashElem *pElem; + Hash *pHash; + + pHash = &pDb->pSchema->tblHash; + for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){ + Table *pTab = (Table*)sqliteHashData(pElem); + if( pTab->tnum==iFrom ){ + pTab->tnum = iTo; + } + } + pHash = &pDb->pSchema->idxHash; + for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){ + Index *pIdx = (Index*)sqliteHashData(pElem); + if( pIdx->tnum==iFrom ){ + pIdx->tnum = iTo; + } + } +} +#endif + +/* +** Write code to erase the table with root-page iTable from database iDb. +** Also write code to modify the sqlite_master table and internal schema +** if a root-page of another table is moved by the btree-layer whilst +** erasing iTable (this can happen with an auto-vacuum database). +*/ +static void destroyRootPage(Parse *pParse, int iTable, int iDb){ + Vdbe *v = sqlite3GetVdbe(pParse); + sqlite3VdbeAddOp(v, OP_Destroy, iTable, iDb); +#ifndef SQLITE_OMIT_AUTOVACUUM + /* OP_Destroy pushes an integer onto the stack. If this integer + ** is non-zero, then it is the root page number of a table moved to + ** location iTable. The following code modifies the sqlite_master table to + ** reflect this. + ** + ** The "#0" in the SQL is a special constant that means whatever value + ** is on the top of the stack. See sqlite3RegisterExpr(). + */ + sqlite3NestedParse(pParse, + "UPDATE %Q.%s SET rootpage=%d WHERE #0 AND rootpage=#0", + pParse->db->aDb[iDb].zName, SCHEMA_TABLE(iDb), iTable); +#endif +} + +/* +** Write VDBE code to erase table pTab and all associated indices on disk. +** Code to update the sqlite_master tables and internal schema definitions +** in case a root-page belonging to another table is moved by the btree layer +** is also added (this can happen with an auto-vacuum database). +*/ +static void destroyTable(Parse *pParse, Table *pTab){ +#ifdef SQLITE_OMIT_AUTOVACUUM + Index *pIdx; + int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + destroyRootPage(pParse, pTab->tnum, iDb); + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + destroyRootPage(pParse, pIdx->tnum, iDb); + } +#else + /* If the database may be auto-vacuum capable (if SQLITE_OMIT_AUTOVACUUM + ** is not defined), then it is important to call OP_Destroy on the + ** table and index root-pages in order, starting with the numerically + ** largest root-page number. This guarantees that none of the root-pages + ** to be destroyed is relocated by an earlier OP_Destroy. i.e. if the + ** following were coded: + ** + ** OP_Destroy 4 0 + ** ... + ** OP_Destroy 5 0 + ** + ** and root page 5 happened to be the largest root-page number in the + ** database, then root page 5 would be moved to page 4 by the + ** "OP_Destroy 4 0" opcode. The subsequent "OP_Destroy 5 0" would hit + ** a free-list page. + */ + int iTab = pTab->tnum; + int iDestroyed = 0; + + while( 1 ){ + Index *pIdx; + int iLargest = 0; + + if( iDestroyed==0 || iTabpIndex; pIdx; pIdx=pIdx->pNext){ + int iIdx = pIdx->tnum; + assert( pIdx->pSchema==pTab->pSchema ); + if( (iDestroyed==0 || (iIdxiLargest ){ + iLargest = iIdx; + } + } + if( iLargest==0 ){ + return; + }else{ + int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + destroyRootPage(pParse, iLargest, iDb); + iDestroyed = iLargest; + } + } +#endif +} + +/* +** This routine is called to do the work of a DROP TABLE statement. +** pName is the name of the table to be dropped. +*/ +void sqlite3DropTable(Parse *pParse, SrcList *pName, int isView, int noErr){ + Table *pTab; + Vdbe *v; + sqlite3 *db = pParse->db; + int iDb; + + if( pParse->nErr || db->mallocFailed ){ + goto exit_drop_table; + } + assert( pName->nSrc==1 ); + pTab = sqlite3LocateTable(pParse, pName->a[0].zName, pName->a[0].zDatabase); + + if( pTab==0 ){ + if( noErr ){ + sqlite3ErrorClear(pParse); + } + goto exit_drop_table; + } + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + assert( iDb>=0 && iDbnDb ); + + /* If pTab is a virtual table, call ViewGetColumnNames() to ensure + ** it is initialized. + */ + if( IsVirtual(pTab) && sqlite3ViewGetColumnNames(pParse, pTab) ){ + goto exit_drop_table; + } +#ifndef SQLITE_OMIT_AUTHORIZATION + { + int code; + const char *zTab = SCHEMA_TABLE(iDb); + const char *zDb = db->aDb[iDb].zName; + const char *zArg2 = 0; + if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb)){ + goto exit_drop_table; + } + if( isView ){ + if( !OMIT_TEMPDB && iDb==1 ){ + code = SQLITE_DROP_TEMP_VIEW; + }else{ + code = SQLITE_DROP_VIEW; + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + }else if( IsVirtual(pTab) ){ + code = SQLITE_DROP_VTABLE; + zArg2 = pTab->pMod->zName; +#endif + }else{ + if( !OMIT_TEMPDB && iDb==1 ){ + code = SQLITE_DROP_TEMP_TABLE; + }else{ + code = SQLITE_DROP_TABLE; + } + } + if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){ + goto exit_drop_table; + } + if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){ + goto exit_drop_table; + } + } +#endif + if( pTab->readOnly || pTab==db->aDb[iDb].pSchema->pSeqTab ){ + sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName); + goto exit_drop_table; + } + +#ifndef SQLITE_OMIT_VIEW + /* Ensure DROP TABLE is not used on a view, and DROP VIEW is not used + ** on a table. + */ + if( isView && pTab->pSelect==0 ){ + sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName); + goto exit_drop_table; + } + if( !isView && pTab->pSelect ){ + sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName); + goto exit_drop_table; + } +#endif + + /* Generate code to remove the table from the master table + ** on disk. + */ + v = sqlite3GetVdbe(pParse); + if( v ){ + Trigger *pTrigger; + Db *pDb = &db->aDb[iDb]; + sqlite3BeginWriteOperation(pParse, 1, iDb); + +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( IsVirtual(pTab) ){ + Vdbe *v = sqlite3GetVdbe(pParse); + if( v ){ + sqlite3VdbeAddOp(v, OP_VBegin, 0, 0); + } + } +#endif + + /* Drop all triggers associated with the table being dropped. Code + ** is generated to remove entries from sqlite_master and/or + ** sqlite_temp_master if required. + */ + pTrigger = pTab->pTrigger; + while( pTrigger ){ + assert( pTrigger->pSchema==pTab->pSchema || + pTrigger->pSchema==db->aDb[1].pSchema ); + sqlite3DropTriggerPtr(pParse, pTrigger); + pTrigger = pTrigger->pNext; + } + +#ifndef SQLITE_OMIT_AUTOINCREMENT + /* Remove any entries of the sqlite_sequence table associated with + ** the table being dropped. This is done before the table is dropped + ** at the btree level, in case the sqlite_sequence table needs to + ** move as a result of the drop (can happen in auto-vacuum mode). + */ + if( pTab->autoInc ){ + sqlite3NestedParse(pParse, + "DELETE FROM %s.sqlite_sequence WHERE name=%Q", + pDb->zName, pTab->zName + ); + } +#endif + + /* Drop all SQLITE_MASTER table and index entries that refer to the + ** table. The program name loops through the master table and deletes + ** every row that refers to a table of the same name as the one being + ** dropped. Triggers are handled seperately because a trigger can be + ** created in the temp database that refers to a table in another + ** database. + */ + sqlite3NestedParse(pParse, + "DELETE FROM %Q.%s WHERE tbl_name=%Q and type!='trigger'", + pDb->zName, SCHEMA_TABLE(iDb), pTab->zName); + if( !isView && !IsVirtual(pTab) ){ + destroyTable(pParse, pTab); + } + + /* Remove the table entry from SQLite's internal schema and modify + ** the schema cookie. + */ + if( IsVirtual(pTab) ){ + sqlite3VdbeOp3(v, OP_VDestroy, iDb, 0, pTab->zName, 0); + } + sqlite3VdbeOp3(v, OP_DropTable, iDb, 0, pTab->zName, 0); + sqlite3ChangeCookie(db, v, iDb); + } + sqliteViewResetAll(db, iDb); + +exit_drop_table: + sqlite3SrcListDelete(pName); +} + +/* +** This routine is called to create a new foreign key on the table +** currently under construction. pFromCol determines which columns +** in the current table point to the foreign key. If pFromCol==0 then +** connect the key to the last column inserted. pTo is the name of +** the table referred to. pToCol is a list of tables in the other +** pTo table that the foreign key points to. flags contains all +** information about the conflict resolution algorithms specified +** in the ON DELETE, ON UPDATE and ON INSERT clauses. +** +** An FKey structure is created and added to the table currently +** under construction in the pParse->pNewTable field. The new FKey +** is not linked into db->aFKey at this point - that does not happen +** until sqlite3EndTable(). +** +** The foreign key is set for IMMEDIATE processing. A subsequent call +** to sqlite3DeferForeignKey() might change this to DEFERRED. +*/ +void sqlite3CreateForeignKey( + Parse *pParse, /* Parsing context */ + ExprList *pFromCol, /* Columns in this table that point to other table */ + Token *pTo, /* Name of the other table */ + ExprList *pToCol, /* Columns in the other table */ + int flags /* Conflict resolution algorithms. */ +){ +#ifndef SQLITE_OMIT_FOREIGN_KEY + FKey *pFKey = 0; + Table *p = pParse->pNewTable; + int nByte; + int i; + int nCol; + char *z; + + assert( pTo!=0 ); + if( p==0 || pParse->nErr || IN_DECLARE_VTAB ) goto fk_end; + if( pFromCol==0 ){ + int iCol = p->nCol-1; + if( iCol<0 ) goto fk_end; + if( pToCol && pToCol->nExpr!=1 ){ + sqlite3ErrorMsg(pParse, "foreign key on %s" + " should reference only one column of table %T", + p->aCol[iCol].zName, pTo); + goto fk_end; + } + nCol = 1; + }else if( pToCol && pToCol->nExpr!=pFromCol->nExpr ){ + sqlite3ErrorMsg(pParse, + "number of columns in foreign key does not match the number of " + "columns in the referenced table"); + goto fk_end; + }else{ + nCol = pFromCol->nExpr; + } + nByte = sizeof(*pFKey) + nCol*sizeof(pFKey->aCol[0]) + pTo->n + 1; + if( pToCol ){ + for(i=0; inExpr; i++){ + nByte += strlen(pToCol->a[i].zName) + 1; + } + } + pFKey = (FKey*)sqlite3DbMallocZero(pParse->db, nByte ); + if( pFKey==0 ){ + goto fk_end; + } + pFKey->pFrom = p; + pFKey->pNextFrom = p->pFKey; + z = (char*)&pFKey[1]; + pFKey->aCol = (FKey::sColMap*)z; + z += sizeof(FKey::sColMap)*nCol; + pFKey->zTo = z; + memcpy(z, pTo->z, pTo->n); + z[pTo->n] = 0; + z += pTo->n+1; + pFKey->pNextTo = 0; + pFKey->nCol = nCol; + if( pFromCol==0 ){ + pFKey->aCol[0].iFrom = p->nCol-1; + }else{ + for(i=0; inCol; j++){ + if( sqlite3StrICmp(p->aCol[j].zName, pFromCol->a[i].zName)==0 ){ + pFKey->aCol[i].iFrom = j; + break; + } + } + if( j>=p->nCol ){ + sqlite3ErrorMsg(pParse, + "unknown column \"%s\" in foreign key definition", + pFromCol->a[i].zName); + goto fk_end; + } + } + } + if( pToCol ){ + for(i=0; ia[i].zName); + pFKey->aCol[i].zCol = z; + memcpy(z, pToCol->a[i].zName, n); + z[n] = 0; + z += n+1; + } + } + pFKey->isDeferred = 0; + pFKey->deleteConf = flags & 0xff; + pFKey->updateConf = (flags >> 8 ) & 0xff; + pFKey->insertConf = (flags >> 16 ) & 0xff; + + /* Link the foreign key to the table as the last step. + */ + p->pFKey = pFKey; + pFKey = 0; + +fk_end: + sqlite3_free(pFKey); +#endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */ + sqlite3ExprListDelete(pFromCol); + sqlite3ExprListDelete(pToCol); +} + +/* +** This routine is called when an INITIALLY IMMEDIATE or INITIALLY DEFERRED +** clause is seen as part of a foreign key definition. The isDeferred +** parameter is 1 for INITIALLY DEFERRED and 0 for INITIALLY IMMEDIATE. +** The behavior of the most recently created foreign key is adjusted +** accordingly. +*/ +void sqlite3DeferForeignKey(Parse *pParse, int isDeferred){ +#ifndef SQLITE_OMIT_FOREIGN_KEY + Table *pTab; + FKey *pFKey; + if( (pTab = pParse->pNewTable)==0 || (pFKey = pTab->pFKey)==0 ) return; + pFKey->isDeferred = isDeferred; +#endif +} + +/* +** Generate code that will erase and refill index *pIdx. This is +** used to initialize a newly created index or to recompute the +** content of an index in response to a REINDEX command. +** +** if memRootPage is not negative, it means that the index is newly +** created. The memory cell specified by memRootPage contains the +** root page number of the index. If memRootPage is negative, then +** the index already exists and must be cleared before being refilled and +** the root page number of the index is taken from pIndex->tnum. +*/ +static void sqlite3RefillIndex(Parse *pParse, Index *pIndex, int memRootPage){ + Table *pTab = pIndex->pTable; /* The table that is indexed */ + int iTab = pParse->nTab; /* Btree cursor used for pTab */ + int iIdx = pParse->nTab+1; /* Btree cursor used for pIndex */ + int addr1; /* Address of top of loop */ + int tnum; /* Root page of index */ + Vdbe *v; /* Generate code into this virtual machine */ + KeyInfo *pKey; /* KeyInfo for index */ + sqlite3 *db = pParse->db; /* The database connection */ + int iDb = sqlite3SchemaToIndex(db, pIndex->pSchema); + +#ifndef SQLITE_OMIT_AUTHORIZATION + if( sqlite3AuthCheck(pParse, SQLITE_REINDEX, pIndex->zName, 0, + db->aDb[iDb].zName ) ){ + return; + } +#endif + + /* Require a write-lock on the table to perform this operation */ + sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName); + + v = sqlite3GetVdbe(pParse); + if( v==0 ) return; + if( memRootPage>=0 ){ + sqlite3VdbeAddOp(v, OP_MemLoad, memRootPage, 0); + tnum = 0; + }else{ + tnum = pIndex->tnum; + sqlite3VdbeAddOp(v, OP_Clear, tnum, iDb); + } + sqlite3VdbeAddOp(v, OP_Integer, iDb, 0); + pKey = sqlite3IndexKeyinfo(pParse, pIndex); + sqlite3VdbeOp3(v, OP_OpenWrite, iIdx, tnum, (char *)pKey, P3_KEYINFO_HANDOFF); + sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead); + addr1 = sqlite3VdbeAddOp(v, OP_Rewind, iTab, 0); + sqlite3GenerateIndexKey(v, pIndex, iTab); + if( pIndex->onError!=OE_None ){ + int curaddr = sqlite3VdbeCurrentAddr(v); + int addr2 = curaddr+4; + sqlite3VdbeChangeP2(v, curaddr-1, addr2); + sqlite3VdbeAddOp(v, OP_Rowid, iTab, 0); + sqlite3VdbeAddOp(v, OP_AddImm, 1, 0); + sqlite3VdbeAddOp(v, OP_IsUnique, iIdx, addr2); + sqlite3VdbeOp3(v, OP_Halt, SQLITE_CONSTRAINT, OE_Abort, + "indexed columns are not unique", P3_STATIC); + assert( db->mallocFailed || addr2==sqlite3VdbeCurrentAddr(v) ); + } + sqlite3VdbeAddOp(v, OP_IdxInsert, iIdx, 0); + sqlite3VdbeAddOp(v, OP_Next, iTab, addr1+1); + sqlite3VdbeJumpHere(v, addr1); + sqlite3VdbeAddOp(v, OP_Close, iTab, 0); + sqlite3VdbeAddOp(v, OP_Close, iIdx, 0); +} + +/* +** Create a new index for an SQL table. pName1.pName2 is the name of the index +** and pTblList is the name of the table that is to be indexed. Both will +** be NULL for a primary key or an index that is created to satisfy a +** UNIQUE constraint. If pTable and pIndex are NULL, use pParse->pNewTable +** as the table to be indexed. pParse->pNewTable is a table that is +** currently being constructed by a CREATE TABLE statement. +** +** pList is a list of columns to be indexed. pList will be NULL if this +** is a primary key or unique-constraint on the most recent column added +** to the table currently under construction. +*/ +void sqlite3CreateIndex( + Parse *pParse, /* All information about this parse */ + Token *pName1, /* First part of index name. May be NULL */ + Token *pName2, /* Second part of index name. May be NULL */ + SrcList *pTblName, /* Table to index. Use pParse->pNewTable if 0 */ + ExprList *pList, /* A list of columns to be indexed */ + int onError, /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */ + Token *pStart, /* The CREATE token that begins this statement */ + Token *pEnd, /* The ")" that closes the CREATE INDEX statement */ + int sortOrder, /* Sort order of primary key when pList==NULL */ + int ifNotExist /* Omit error if index already exists */ +){ + Table *pTab = 0; /* Table to be indexed */ + Index *pIndex = 0; /* The index to be created */ + char *zName = 0; /* Name of the index */ + int nName; /* Number of characters in zName */ + int i, j; + Token nullId; /* Fake token for an empty ID list */ + DbFixer sFix; /* For assigning database names to pTable */ + int sortOrderMask; /* 1 to honor DESC in index. 0 to ignore. */ + sqlite3 *db = pParse->db; + Db *pDb; /* The specific table containing the indexed database */ + int iDb; /* Index of the database that is being written */ + Token *pName = 0; /* Unqualified name of the index to create */ + ExprList::ExprList_item *pListItem; /* For looping over pList */ + int nCol; + int nExtra = 0; + char *zExtra; + + if( pParse->nErr || db->mallocFailed || IN_DECLARE_VTAB ){ + goto exit_create_index; + } + + /* + ** Find the table that is to be indexed. Return early if not found. + */ + if( pTblName!=0 ){ + + /* Use the two-part index name to determine the database + ** to search for the table. 'Fix' the table name to this db + ** before looking up the table. + */ + assert( pName1 && pName2 ); + iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName); + if( iDb<0 ) goto exit_create_index; + +#ifndef SQLITE_OMIT_TEMPDB + /* If the index name was unqualified, check if the the table + ** is a temp table. If so, set the database to 1. Do not do this + ** if initialising a database schema. + */ + if( !db->init.busy ){ + pTab = sqlite3SrcListLookup(pParse, pTblName); + if( pName2 && pName2->n==0 && pTab && pTab->pSchema==db->aDb[1].pSchema ){ + iDb = 1; + } + } +#endif + + if( sqlite3FixInit(&sFix, pParse, iDb, "index", pName) && + sqlite3FixSrcList(&sFix, pTblName) + ){ + /* Because the parser constructs pTblName from a single identifier, + ** sqlite3FixSrcList can never fail. */ + assert(0); + } + pTab = sqlite3LocateTable(pParse, pTblName->a[0].zName, + pTblName->a[0].zDatabase); + if( !pTab ) goto exit_create_index; + assert( db->aDb[iDb].pSchema==pTab->pSchema ); + }else{ + assert( pName==0 ); + pTab = pParse->pNewTable; + if( !pTab ) goto exit_create_index; + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + } + pDb = &db->aDb[iDb]; + + if( pTab==0 || pParse->nErr ) goto exit_create_index; + if( pTab->readOnly ){ + sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName); + goto exit_create_index; + } +#ifndef SQLITE_OMIT_VIEW + if( pTab->pSelect ){ + sqlite3ErrorMsg(pParse, "views may not be indexed"); + goto exit_create_index; + } +#endif +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( IsVirtual(pTab) ){ + sqlite3ErrorMsg(pParse, "virtual tables may not be indexed"); + goto exit_create_index; + } +#endif + + /* + ** Find the name of the index. Make sure there is not already another + ** index or table with the same name. + ** + ** Exception: If we are reading the names of permanent indices from the + ** sqlite_master table (because some other process changed the schema) and + ** one of the index names collides with the name of a temporary table or + ** index, then we will continue to process this index. + ** + ** If pName==0 it means that we are + ** dealing with a primary key or UNIQUE constraint. We have to invent our + ** own name. + */ + if( pName ){ + zName = sqlite3NameFromToken(db, pName); + if( SQLITE_OK!=sqlite3ReadSchema(pParse) ) goto exit_create_index; + if( zName==0 ) goto exit_create_index; + if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){ + goto exit_create_index; + } + if( !db->init.busy ){ + if( SQLITE_OK!=sqlite3ReadSchema(pParse) ) goto exit_create_index; + if( sqlite3FindTable(db, zName, 0)!=0 ){ + sqlite3ErrorMsg(pParse, "there is already a table named %s", zName); + goto exit_create_index; + } + } + if( sqlite3FindIndex(db, zName, pDb->zName)!=0 ){ + if( !ifNotExist ){ + sqlite3ErrorMsg(pParse, "index %s already exists", zName); + } + goto exit_create_index; + } + }else{ + char zBuf[30]; + int n; + Index *pLoop; + for(pLoop=pTab->pIndex, n=1; pLoop; pLoop=pLoop->pNext, n++){} + sqlite3_snprintf(sizeof(zBuf),zBuf,"_%d",n); + zName = 0; + sqlite3SetString(&zName, "sqlite_autoindex_", pTab->zName, zBuf, (char*)0); + if( zName==0 ){ + db->mallocFailed = 1; + goto exit_create_index; + } + } + + /* Check for authorization to create an index. + */ +#ifndef SQLITE_OMIT_AUTHORIZATION + { + const char *zDb = pDb->zName; + if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iDb), 0, zDb) ){ + goto exit_create_index; + } + i = SQLITE_CREATE_INDEX; + if( !OMIT_TEMPDB && iDb==1 ) i = SQLITE_CREATE_TEMP_INDEX; + if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){ + goto exit_create_index; + } + } +#endif + + /* If pList==0, it means this routine was called to make a primary + ** key out of the last column added to the table under construction. + ** So create a fake list to simulate this. + */ + if( pList==0 ){ + nullId.z = (u8*)pTab->aCol[pTab->nCol-1].zName; + nullId.n = strlen((char*)nullId.z); + pList = sqlite3ExprListAppend(pParse, 0, 0, &nullId); + if( pList==0 ) goto exit_create_index; + pList->a[0].sortOrder = sortOrder; + } + + /* Figure out how many bytes of space are required to store explicitly + ** specified collation sequence names. + */ + for(i=0; inExpr; i++){ + Expr *pExpr = pList->a[i].pExpr; + if( pExpr ){ + nExtra += (1 + strlen(pExpr->pColl->zName)); + } + } + + /* + ** Allocate the index structure. + */ + nName = strlen(zName); + nCol = pList->nExpr; + pIndex = (Index*)sqlite3DbMallocZero(db, + sizeof(Index) + /* Index structure */ + sizeof(int)*nCol + /* Index.aiColumn */ + sizeof(int)*(nCol+1) + /* Index.aiRowEst */ + sizeof(char *)*nCol + /* Index.azColl */ + sizeof(u8)*nCol + /* Index.aSortOrder */ + nName + 1 + /* Index.zName */ + nExtra /* Collation sequence names */ + ); + if( db->mallocFailed ){ + goto exit_create_index; + } + pIndex->azColl = (char**)(&pIndex[1]); + pIndex->aiColumn = (int *)(&pIndex->azColl[nCol]); + pIndex->aiRowEst = (unsigned *)(&pIndex->aiColumn[nCol]); + pIndex->aSortOrder = (u8 *)(&pIndex->aiRowEst[nCol+1]); + pIndex->zName = (char *)(&pIndex->aSortOrder[nCol]); + zExtra = (char *)(&pIndex->zName[nName+1]); + memcpy(pIndex->zName, zName, nName+1); + pIndex->pTable = pTab; + pIndex->nColumn = pList->nExpr; + pIndex->onError = onError; + pIndex->autoIndex = pName==0; + pIndex->pSchema = db->aDb[iDb].pSchema; + + /* Check to see if we should honor DESC requests on index columns + */ + if( pDb->pSchema->file_format>=4 ){ + sortOrderMask = -1; /* Honor DESC */ + }else{ + sortOrderMask = 0; /* Ignore DESC */ + } + + /* Scan the names of the columns of the table to be indexed and + ** load the column indices into the Index structure. Report an error + ** if any column is not found. + */ + for(i=0, pListItem=pList->a; inExpr; i++, pListItem++){ + const char *zColName = pListItem->zName; + Column *pTabCol; + int requestedSortOrder; + char *zColl; /* Collation sequence name */ + + for(j=0, pTabCol=pTab->aCol; jnCol; j++, pTabCol++){ + if( sqlite3StrICmp(zColName, pTabCol->zName)==0 ) break; + } + if( j>=pTab->nCol ){ + sqlite3ErrorMsg(pParse, "table %s has no column named %s", + pTab->zName, zColName); + goto exit_create_index; + } + /* TODO: Add a test to make sure that the same column is not named + ** more than once within the same index. Only the first instance of + ** the column will ever be used by the optimizer. Note that using the + ** same column more than once cannot be an error because that would + ** break backwards compatibility - it needs to be a warning. + */ + pIndex->aiColumn[i] = j; + if( pListItem->pExpr ){ + assert( pListItem->pExpr->pColl ); + zColl = zExtra; + sqlite3_snprintf(nExtra, zExtra, "%s", pListItem->pExpr->pColl->zName); + zExtra += (strlen(zColl) + 1); + }else{ + zColl = pTab->aCol[j].zColl; + if( !zColl ){ + zColl = db->pDfltColl->zName; + } + } + if( !db->init.busy && !sqlite3LocateCollSeq(pParse, zColl, -1) ){ + goto exit_create_index; + } + pIndex->azColl[i] = zColl; + requestedSortOrder = pListItem->sortOrder & sortOrderMask; + pIndex->aSortOrder[i] = requestedSortOrder; + } + sqlite3DefaultRowEst(pIndex); + + if( pTab==pParse->pNewTable ){ + /* This routine has been called to create an automatic index as a + ** result of a PRIMARY KEY or UNIQUE clause on a column definition, or + ** a PRIMARY KEY or UNIQUE clause following the column definitions. + ** i.e. one of: + ** + ** CREATE TABLE t(x PRIMARY KEY, y); + ** CREATE TABLE t(x, y, UNIQUE(x, y)); + ** + ** Either way, check to see if the table already has such an index. If + ** so, don't bother creating this one. This only applies to + ** automatically created indices. Users can do as they wish with + ** explicit indices. + */ + Index *pIdx; + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + int k; + assert( pIdx->onError!=OE_None ); + assert( pIdx->autoIndex ); + assert( pIndex->onError!=OE_None ); + + if( pIdx->nColumn!=pIndex->nColumn ) continue; + for(k=0; knColumn; k++){ + const char *z1 = pIdx->azColl[k]; + const char *z2 = pIndex->azColl[k]; + if( pIdx->aiColumn[k]!=pIndex->aiColumn[k] ) break; + if( pIdx->aSortOrder[k]!=pIndex->aSortOrder[k] ) break; + if( z1!=z2 && sqlite3StrICmp(z1, z2) ) break; + } + if( k==pIdx->nColumn ){ + if( pIdx->onError!=pIndex->onError ){ + /* This constraint creates the same index as a previous + ** constraint specified somewhere in the CREATE TABLE statement. + ** However the ON CONFLICT clauses are different. If both this + ** constraint and the previous equivalent constraint have explicit + ** ON CONFLICT clauses this is an error. Otherwise, use the + ** explicitly specified behaviour for the index. + */ + if( !(pIdx->onError==OE_Default || pIndex->onError==OE_Default) ){ + sqlite3ErrorMsg(pParse, + "conflicting ON CONFLICT clauses specified", 0); + } + if( pIdx->onError==OE_Default ){ + pIdx->onError = pIndex->onError; + } + } + goto exit_create_index; + } + } + } + + /* Link the new Index structure to its table and to the other + ** in-memory database structures. + */ + if( db->init.busy ){ + Index *p; + p = (Index*)sqlite3HashInsert(&pIndex->pSchema->idxHash, + pIndex->zName, strlen(pIndex->zName)+1, pIndex); + if( p ){ + assert( p==pIndex ); /* Malloc must have failed */ + db->mallocFailed = 1; + goto exit_create_index; + } + db->flags |= SQLITE_InternChanges; + if( pTblName!=0 ){ + pIndex->tnum = db->init.newTnum; + } + } + + /* If the db->init.busy is 0 then create the index on disk. This + ** involves writing the index into the master table and filling in the + ** index with the current table contents. + ** + ** The db->init.busy is 0 when the user first enters a CREATE INDEX + ** command. db->init.busy is 1 when a database is opened and + ** CREATE INDEX statements are read out of the master table. In + ** the latter case the index already exists on disk, which is why + ** we don't want to recreate it. + ** + ** If pTblName==0 it means this index is generated as a primary key + ** or UNIQUE constraint of a CREATE TABLE statement. Since the table + ** has just been created, it contains no data and the index initialization + ** step can be skipped. + */ + else if( db->init.busy==0 ){ + Vdbe *v; + char *zStmt; + int iMem = pParse->nMem++; + + v = sqlite3GetVdbe(pParse); + if( v==0 ) goto exit_create_index; + + + /* Create the rootpage for the index + */ + sqlite3BeginWriteOperation(pParse, 1, iDb); + sqlite3VdbeAddOp(v, OP_CreateIndex, iDb, 0); + sqlite3VdbeAddOp(v, OP_MemStore, iMem, 0); + + /* Gather the complete text of the CREATE INDEX statement into + ** the zStmt variable + */ + if( pStart && pEnd ){ + /* A named index with an explicit CREATE INDEX statement */ + zStmt = sqlite3MPrintf(db, "CREATE%s INDEX %.*s", + onError==OE_None ? "" : " UNIQUE", + pEnd->z - pName->z + 1, + pName->z); + }else{ + /* An automatic index created by a PRIMARY KEY or UNIQUE constraint */ + /* zStmt = sqlite3MPrintf(""); */ + zStmt = 0; + } + + /* Add an entry in sqlite_master for this index + */ + sqlite3NestedParse(pParse, + "INSERT INTO %Q.%s VALUES('index',%Q,%Q,#0,%Q);", + db->aDb[iDb].zName, SCHEMA_TABLE(iDb), + pIndex->zName, + pTab->zName, + zStmt + ); + sqlite3VdbeAddOp(v, OP_Pop, 1, 0); + sqlite3_free(zStmt); + + /* Fill the index with data and reparse the schema. Code an OP_Expire + ** to invalidate all pre-compiled statements. + */ + if( pTblName ){ + sqlite3RefillIndex(pParse, pIndex, iMem); + sqlite3ChangeCookie(db, v, iDb); + sqlite3VdbeOp3(v, OP_ParseSchema, iDb, 0, + sqlite3MPrintf(db, "name='%q'", pIndex->zName), P3_DYNAMIC); + sqlite3VdbeAddOp(v, OP_Expire, 0, 0); + } + } + + /* When adding an index to the list of indices for a table, make + ** sure all indices labeled OE_Replace come after all those labeled + ** OE_Ignore. This is necessary for the correct operation of UPDATE + ** and INSERT. + */ + if( db->init.busy || pTblName==0 ){ + if( onError!=OE_Replace || pTab->pIndex==0 + || pTab->pIndex->onError==OE_Replace){ + pIndex->pNext = pTab->pIndex; + pTab->pIndex = pIndex; + }else{ + Index *pOther = pTab->pIndex; + while( pOther->pNext && pOther->pNext->onError!=OE_Replace ){ + pOther = pOther->pNext; + } + pIndex->pNext = pOther->pNext; + pOther->pNext = pIndex; + } + pIndex = 0; + } + + /* Clean up before exiting */ +exit_create_index: + if( pIndex ){ + freeIndex(pIndex); + } + sqlite3ExprListDelete(pList); + sqlite3SrcListDelete(pTblName); + sqlite3_free(zName); + return; +} + +/* +** Generate code to make sure the file format number is at least minFormat. +** The generated code will increase the file format number if necessary. +*/ +void sqlite3MinimumFileFormat(Parse *pParse, int iDb, int minFormat){ + Vdbe *v; + v = sqlite3GetVdbe(pParse); + if( v ){ + sqlite3VdbeAddOp(v, OP_ReadCookie, iDb, 1); + sqlite3VdbeUsesBtree(v, iDb); + sqlite3VdbeAddOp(v, OP_Integer, minFormat, 0); + sqlite3VdbeAddOp(v, OP_Ge, 0, sqlite3VdbeCurrentAddr(v)+3); + sqlite3VdbeAddOp(v, OP_Integer, minFormat, 0); + sqlite3VdbeAddOp(v, OP_SetCookie, iDb, 1); + } +} + +/* +** Fill the Index.aiRowEst[] array with default information - information +** to be used when we have not run the ANALYZE command. +** +** aiRowEst[0] is suppose to contain the number of elements in the index. +** Since we do not know, guess 1 million. aiRowEst[1] is an estimate of the +** number of rows in the table that match any particular value of the +** first column of the index. aiRowEst[2] is an estimate of the number +** of rows that match any particular combiniation of the first 2 columns +** of the index. And so forth. It must always be the case that +* +** aiRowEst[N]<=aiRowEst[N-1] +** aiRowEst[N]>=1 +** +** Apart from that, we have little to go on besides intuition as to +** how aiRowEst[] should be initialized. The numbers generated here +** are based on typical values found in actual indices. +*/ +void sqlite3DefaultRowEst(Index *pIdx){ + unsigned *a = pIdx->aiRowEst; + int i; + assert( a!=0 ); + a[0] = 1000000; + for(i=pIdx->nColumn; i>=5; i--){ + a[i] = 5; + } + while( i>=1 ){ + a[i] = 11 - i; + i--; + } + if( pIdx->onError!=OE_None ){ + a[pIdx->nColumn] = 1; + } +} + +/* +** This routine will drop an existing named index. This routine +** implements the DROP INDEX statement. +*/ +void sqlite3DropIndex(Parse *pParse, SrcList *pName, int ifExists){ + Index *pIndex; + Vdbe *v; + sqlite3 *db = pParse->db; + int iDb; + + if( pParse->nErr || db->mallocFailed ){ + goto exit_drop_index; + } + assert( pName->nSrc==1 ); + if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){ + goto exit_drop_index; + } + pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].zDatabase); + if( pIndex==0 ){ + if( !ifExists ){ + sqlite3ErrorMsg(pParse, "no such index: %S", pName, 0); + } + pParse->checkSchema = 1; + goto exit_drop_index; + } + if( pIndex->autoIndex ){ + sqlite3ErrorMsg(pParse, "index associated with UNIQUE " + "or PRIMARY KEY constraint cannot be dropped", 0); + goto exit_drop_index; + } + iDb = sqlite3SchemaToIndex(db, pIndex->pSchema); +#ifndef SQLITE_OMIT_AUTHORIZATION + { + int code = SQLITE_DROP_INDEX; + Table *pTab = pIndex->pTable; + const char *zDb = db->aDb[iDb].zName; + const char *zTab = SCHEMA_TABLE(iDb); + if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){ + goto exit_drop_index; + } + if( !OMIT_TEMPDB && iDb ) code = SQLITE_DROP_TEMP_INDEX; + if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){ + goto exit_drop_index; + } + } +#endif + + /* Generate code to remove the index and from the master table */ + v = sqlite3GetVdbe(pParse); + if( v ){ + sqlite3BeginWriteOperation(pParse, 1, iDb); + sqlite3NestedParse(pParse, + "DELETE FROM %Q.%s WHERE name=%Q", + db->aDb[iDb].zName, SCHEMA_TABLE(iDb), + pIndex->zName + ); + sqlite3ChangeCookie(db, v, iDb); + destroyRootPage(pParse, pIndex->tnum, iDb); + sqlite3VdbeOp3(v, OP_DropIndex, iDb, 0, pIndex->zName, 0); + } + +exit_drop_index: + sqlite3SrcListDelete(pName); +} + +/* +** pArray is a pointer to an array of objects. Each object in the +** array is szEntry bytes in size. This routine allocates a new +** object on the end of the array. +** +** *pnEntry is the number of entries already in use. *pnAlloc is +** the previously allocated size of the array. initSize is the +** suggested initial array size allocation. +** +** The index of the new entry is returned in *pIdx. +** +** This routine returns a pointer to the array of objects. This +** might be the same as the pArray parameter or it might be a different +** pointer if the array was resized. +*/ +void *sqlite3ArrayAllocate( + sqlite3 *db, /* Connection to notify of malloc failures */ + void *pArray, /* Array of objects. Might be reallocated */ + int szEntry, /* Size of each object in the array */ + int initSize, /* Suggested initial allocation, in elements */ + int *pnEntry, /* Number of objects currently in use */ + int *pnAlloc, /* Current size of the allocation, in elements */ + int *pIdx /* Write the index of a new slot here */ +){ + char *z; + if( *pnEntry >= *pnAlloc ){ + void *pNew; + int newSize; + newSize = (*pnAlloc)*2 + initSize; + pNew = sqlite3DbRealloc(db, pArray, newSize*szEntry); + if( pNew==0 ){ + *pIdx = -1; + return pArray; + } + *pnAlloc = newSize; + pArray = pNew; + } + z = (char*)pArray; + memset(&z[*pnEntry * szEntry], 0, szEntry); + *pIdx = *pnEntry; + ++*pnEntry; + return pArray; +} + +/* +** Append a new element to the given IdList. Create a new IdList if +** need be. +** +** A new IdList is returned, or NULL if malloc() fails. +*/ +IdList *sqlite3IdListAppend(sqlite3 *db, IdList *pList, Token *pToken){ + int i; + if( pList==0 ){ + pList = (IdList*)sqlite3DbMallocZero(db, sizeof(IdList) ); + if( pList==0 ) return 0; + pList->nAlloc = 0; + } + pList->a = (IdList::IdList_item*)sqlite3ArrayAllocate( + db, + pList->a, + sizeof(pList->a[0]), + 5, + &pList->nId, + &pList->nAlloc, + &i + ); + if( i<0 ){ + sqlite3IdListDelete(pList); + return 0; + } + pList->a[i].zName = sqlite3NameFromToken(db, pToken); + return pList; +} + +/* +** Delete an IdList. +*/ +void sqlite3IdListDelete(IdList *pList){ + int i; + if( pList==0 ) return; + for(i=0; inId; i++){ + sqlite3_free(pList->a[i].zName); + } + sqlite3_free(pList->a); + sqlite3_free(pList); +} + +/* +** Return the index in pList of the identifier named zId. Return -1 +** if not found. +*/ +int sqlite3IdListIndex(IdList *pList, const char *zName){ + int i; + if( pList==0 ) return -1; + for(i=0; inId; i++){ + if( sqlite3StrICmp(pList->a[i].zName, zName)==0 ) return i; + } + return -1; +} + +/* +** Append a new table name to the given SrcList. Create a new SrcList if +** need be. A new entry is created in the SrcList even if pToken is NULL. +** +** A new SrcList is returned, or NULL if malloc() fails. +** +** If pDatabase is not null, it means that the table has an optional +** database name prefix. Like this: "database.table". The pDatabase +** points to the table name and the pTable points to the database name. +** The SrcList.a[].zName field is filled with the table name which might +** come from pTable (if pDatabase is NULL) or from pDatabase. +** SrcList.a[].zDatabase is filled with the database name from pTable, +** or with NULL if no database is specified. +** +** In other words, if call like this: +** +** sqlite3SrcListAppend(D,A,B,0); +** +** Then B is a table name and the database name is unspecified. If called +** like this: +** +** sqlite3SrcListAppend(D,A,B,C); +** +** Then C is the table name and B is the database name. +*/ +SrcList *sqlite3SrcListAppend( + sqlite3 *db, /* Connection to notify of malloc failures */ + SrcList *pList, /* Append to this SrcList. NULL creates a new SrcList */ + Token *pTable, /* Table to append */ + Token *pDatabase /* Database of the table */ +){ + SrcList::SrcList_item *pItem; + if( pList==0 ){ + pList = (SrcList*)sqlite3DbMallocZero(db, sizeof(SrcList) ); + if( pList==0 ) return 0; + pList->nAlloc = 1; + } + if( pList->nSrc>=pList->nAlloc ){ + SrcList *pNew; + pList->nAlloc *= 2; + pNew = (SrcList*)sqlite3DbRealloc(db, pList, + sizeof(*pList) + (pList->nAlloc-1)*sizeof(pList->a[0]) ); + if( pNew==0 ){ + sqlite3SrcListDelete(pList); + return 0; + } + pList = pNew; + } + pItem = &pList->a[pList->nSrc]; + memset(pItem, 0, sizeof(pList->a[0])); + if( pDatabase && pDatabase->z==0 ){ + pDatabase = 0; + } + if( pDatabase && pTable ){ + Token *pTemp = pDatabase; + pDatabase = pTable; + pTable = pTemp; + } + pItem->zName = sqlite3NameFromToken(db, pTable); + pItem->zDatabase = sqlite3NameFromToken(db, pDatabase); + pItem->iCursor = -1; + pItem->isPopulated = 0; + pList->nSrc++; + return pList; +} + +/* +** Assign cursors to all tables in a SrcList +*/ +void sqlite3SrcListAssignCursors(Parse *pParse, SrcList *pList){ + int i; + SrcList::SrcList_item *pItem; + assert(pList || pParse->db->mallocFailed ); + if( pList ){ + for(i=0, pItem=pList->a; inSrc; i++, pItem++){ + if( pItem->iCursor>=0 ) break; + pItem->iCursor = pParse->nTab++; + if( pItem->pSelect ){ + sqlite3SrcListAssignCursors(pParse, pItem->pSelect->pSrc); + } + } + } +} + +/* +** Delete an entire SrcList including all its substructure. +*/ +void sqlite3SrcListDelete(SrcList *pList){ + int i; + SrcList::SrcList_item *pItem; + if( pList==0 ) return; + for(pItem=pList->a, i=0; inSrc; i++, pItem++){ + sqlite3_free(pItem->zDatabase); + sqlite3_free(pItem->zName); + sqlite3_free(pItem->zAlias); + sqlite3DeleteTable(pItem->pTab); + sqlite3SelectDelete(pItem->pSelect); + sqlite3ExprDelete(pItem->pOn); + sqlite3IdListDelete(pItem->pUsing); + } + sqlite3_free(pList); +} + +/* +** This routine is called by the parser to add a new term to the +** end of a growing FROM clause. The "p" parameter is the part of +** the FROM clause that has already been constructed. "p" is NULL +** if this is the first term of the FROM clause. pTable and pDatabase +** are the name of the table and database named in the FROM clause term. +** pDatabase is NULL if the database name qualifier is missing - the +** usual case. If the term has a alias, then pAlias points to the +** alias token. If the term is a subquery, then pSubquery is the +** SELECT statement that the subquery encodes. The pTable and +** pDatabase parameters are NULL for subqueries. The pOn and pUsing +** parameters are the content of the ON and USING clauses. +** +** Return a new SrcList which encodes is the FROM with the new +** term added. +*/ +SrcList *sqlite3SrcListAppendFromTerm( + Parse *pParse, /* Parsing context */ + SrcList *p, /* The left part of the FROM clause already seen */ + Token *pTable, /* Name of the table to add to the FROM clause */ + Token *pDatabase, /* Name of the database containing pTable */ + Token *pAlias, /* The right-hand side of the AS subexpression */ + Select *pSubquery, /* A subquery used in place of a table name */ + Expr *pOn, /* The ON clause of a join */ + IdList *pUsing /* The USING clause of a join */ +){ + SrcList::SrcList_item *pItem; + sqlite3 *db = pParse->db; + p = sqlite3SrcListAppend(db, p, pTable, pDatabase); + if( p==0 || p->nSrc==0 ){ + sqlite3ExprDelete(pOn); + sqlite3IdListDelete(pUsing); + sqlite3SelectDelete(pSubquery); + return p; + } + pItem = &p->a[p->nSrc-1]; + if( pAlias && pAlias->n ){ + pItem->zAlias = sqlite3NameFromToken(db, pAlias); + } + pItem->pSelect = pSubquery; + pItem->pOn = pOn; + pItem->pUsing = pUsing; + return p; +} + +/* +** When building up a FROM clause in the parser, the join operator +** is initially attached to the left operand. But the code generator +** expects the join operator to be on the right operand. This routine +** Shifts all join operators from left to right for an entire FROM +** clause. +** +** Example: Suppose the join is like this: +** +** A natural cross join B +** +** The operator is "natural cross join". The A and B operands are stored +** in p->a[0] and p->a[1], respectively. The parser initially stores the +** operator with A. This routine shifts that operator over to B. +*/ +void sqlite3SrcListShiftJoinType(SrcList *p){ + if( p && p->a ){ + int i; + for(i=p->nSrc-1; i>0; i--){ + p->a[i].jointype = p->a[i-1].jointype; + } + p->a[0].jointype = 0; + } +} + +/* +** Begin a transaction +*/ +void sqlite3BeginTransaction(Parse *pParse, int type){ + sqlite3 *db; + Vdbe *v; + int i; + + if( pParse==0 || (db=pParse->db)==0 || db->aDb[0].pBt==0 ) return; + if( pParse->nErr || db->mallocFailed ) return; + if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "BEGIN", 0, 0) ) return; + + v = sqlite3GetVdbe(pParse); + if( !v ) return; + if( type!=TK_DEFERRED ){ + for(i=0; inDb; i++){ + sqlite3VdbeAddOp(v, OP_Transaction, i, (type==TK_EXCLUSIVE)+1); + sqlite3VdbeUsesBtree(v, i); + } + } + sqlite3VdbeAddOp(v, OP_AutoCommit, 0, 0); +} + +/* +** Commit a transaction +*/ +void sqlite3CommitTransaction(Parse *pParse){ + sqlite3 *db; + Vdbe *v; + + if( pParse==0 || (db=pParse->db)==0 || db->aDb[0].pBt==0 ) return; + if( pParse->nErr || db->mallocFailed ) return; + if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "COMMIT", 0, 0) ) return; + + v = sqlite3GetVdbe(pParse); + if( v ){ + sqlite3VdbeAddOp(v, OP_AutoCommit, 1, 0); + } +} + +/* +** Rollback a transaction +*/ +void sqlite3RollbackTransaction(Parse *pParse){ + sqlite3 *db; + Vdbe *v; + + if( pParse==0 || (db=pParse->db)==0 || db->aDb[0].pBt==0 ) return; + if( pParse->nErr || db->mallocFailed ) return; + if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "ROLLBACK", 0, 0) ) return; + + v = sqlite3GetVdbe(pParse); + if( v ){ + sqlite3VdbeAddOp(v, OP_AutoCommit, 1, 1); + } +} + +/* +** Make sure the TEMP database is open and available for use. Return +** the number of errors. Leave any error messages in the pParse structure. +*/ +int sqlite3OpenTempDatabase(Parse *pParse){ + sqlite3 *db = pParse->db; + if( db->aDb[1].pBt==0 && !pParse->explain ){ + int rc; + static const int flags = + SQLITE_OPEN_READWRITE | + SQLITE_OPEN_CREATE | + SQLITE_OPEN_EXCLUSIVE | + SQLITE_OPEN_DELETEONCLOSE | + SQLITE_OPEN_TEMP_DB; + + rc = sqlite3BtreeFactory(db, 0, 0, SQLITE_DEFAULT_CACHE_SIZE, flags, + &db->aDb[1].pBt); + if( rc!=SQLITE_OK ){ + sqlite3ErrorMsg(pParse, "unable to open a temporary database " + "file for storing temporary tables"); + pParse->rc = rc; + return 1; + } + if( db->flags & !db->autoCommit ){ + rc = sqlite3BtreeBeginTrans(db->aDb[1].pBt, 1); + if( rc!=SQLITE_OK ){ + sqlite3ErrorMsg(pParse, "unable to get a write lock on " + "the temporary database file"); + pParse->rc = rc; + return 1; + } + } + assert( db->aDb[1].pSchema ); + } + return 0; +} + +/* +** Generate VDBE code that will verify the schema cookie and start +** a read-transaction for all named database files. +** +** It is important that all schema cookies be verified and all +** read transactions be started before anything else happens in +** the VDBE program. But this routine can be called after much other +** code has been generated. So here is what we do: +** +** The first time this routine is called, we code an OP_Goto that +** will jump to a subroutine at the end of the program. Then we +** record every database that needs its schema verified in the +** pParse->cookieMask field. Later, after all other code has been +** generated, the subroutine that does the cookie verifications and +** starts the transactions will be coded and the OP_Goto P2 value +** will be made to point to that subroutine. The generation of the +** cookie verification subroutine code happens in sqlite3FinishCoding(). +** +** If iDb<0 then code the OP_Goto only - don't set flag to verify the +** schema on any databases. This can be used to position the OP_Goto +** early in the code, before we know if any database tables will be used. +*/ +void sqlite3CodeVerifySchema(Parse *pParse, int iDb){ + sqlite3 *db; + Vdbe *v; + int mask; + + v = sqlite3GetVdbe(pParse); + if( v==0 ) return; /* This only happens if there was a prior error */ + db = pParse->db; + if( pParse->cookieGoto==0 ){ + pParse->cookieGoto = sqlite3VdbeAddOp(v, OP_Goto, 0, 0)+1; + } + if( iDb>=0 ){ + assert( iDbnDb ); + assert( db->aDb[iDb].pBt!=0 || iDb==1 ); + assert( iDbcookieMask & mask)==0 ){ + pParse->cookieMask |= mask; + pParse->cookieValue[iDb] = db->aDb[iDb].pSchema->schema_cookie; + if( !OMIT_TEMPDB && iDb==1 ){ + sqlite3OpenTempDatabase(pParse); + } + } + } +} + +/* +** Generate VDBE code that prepares for doing an operation that +** might change the database. +** +** This routine starts a new transaction if we are not already within +** a transaction. If we are already within a transaction, then a checkpoint +** is set if the setStatement parameter is true. A checkpoint should +** be set for operations that might fail (due to a constraint) part of +** the way through and which will need to undo some writes without having to +** rollback the whole transaction. For operations where all constraints +** can be checked before any changes are made to the database, it is never +** necessary to undo a write and the checkpoint should not be set. +** +** Only database iDb and the temp database are made writable by this call. +** If iDb==0, then the main and temp databases are made writable. If +** iDb==1 then only the temp database is made writable. If iDb>1 then the +** specified auxiliary database and the temp database are made writable. +*/ +void sqlite3BeginWriteOperation(Parse *pParse, int setStatement, int iDb){ + Vdbe *v = sqlite3GetVdbe(pParse); + if( v==0 ) return; + sqlite3CodeVerifySchema(pParse, iDb); + pParse->writeMask |= 1<nested==0 ){ + sqlite3VdbeAddOp(v, OP_Statement, iDb, 0); + } + if( (OMIT_TEMPDB || iDb!=1) && pParse->db->aDb[1].pBt!=0 ){ + sqlite3BeginWriteOperation(pParse, setStatement, 1); + } +} + +/* +** Check to see if pIndex uses the collating sequence pColl. Return +** true if it does and false if it does not. +*/ +#ifndef SQLITE_OMIT_REINDEX +static int collationMatch(const char *zColl, Index *pIndex){ + int i; + for(i=0; inColumn; i++){ + const char *z = pIndex->azColl[i]; + if( z==zColl || (z && zColl && 0==sqlite3StrICmp(z, zColl)) ){ + return 1; + } + } + return 0; +} +#endif + +/* +** Recompute all indices of pTab that use the collating sequence pColl. +** If pColl==0 then recompute all indices of pTab. +*/ +#ifndef SQLITE_OMIT_REINDEX +static void reindexTable(Parse *pParse, Table *pTab, char const *zColl){ + Index *pIndex; /* An index associated with pTab */ + + for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){ + if( zColl==0 || collationMatch(zColl, pIndex) ){ + int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + sqlite3BeginWriteOperation(pParse, 0, iDb); + sqlite3RefillIndex(pParse, pIndex, -1); + } + } +} +#endif + +/* +** Recompute all indices of all tables in all databases where the +** indices use the collating sequence pColl. If pColl==0 then recompute +** all indices everywhere. +*/ +#ifndef SQLITE_OMIT_REINDEX +static void reindexDatabases(Parse *pParse, char const *zColl){ + Db *pDb; /* A single database */ + int iDb; /* The database index number */ + sqlite3 *db = pParse->db; /* The database connection */ + HashElem *k; /* For looping over tables in pDb */ + Table *pTab; /* A table in the database */ + + for(iDb=0, pDb=db->aDb; iDbnDb; iDb++, pDb++){ + assert( pDb!=0 ); + for(k=sqliteHashFirst(&pDb->pSchema->tblHash); k; k=sqliteHashNext(k)){ + pTab = (Table*)sqliteHashData(k); + reindexTable(pParse, pTab, zColl); + } + } +} +#endif + +/* +** Generate code for the REINDEX command. +** +** REINDEX -- 1 +** REINDEX -- 2 +** REINDEX ?.? -- 3 +** REINDEX ?.? -- 4 +** +** Form 1 causes all indices in all attached databases to be rebuilt. +** Form 2 rebuilds all indices in all databases that use the named +** collating function. Forms 3 and 4 rebuild the named index or all +** indices associated with the named table. +*/ +#ifndef SQLITE_OMIT_REINDEX +void sqlite3Reindex(Parse *pParse, Token *pName1, Token *pName2){ + CollSeq *pColl; /* Collating sequence to be reindexed, or NULL */ + char *z; /* Name of a table or index */ + const char *zDb; /* Name of the database */ + Table *pTab; /* A table in the database */ + Index *pIndex; /* An index associated with pTab */ + int iDb; /* The database index number */ + sqlite3 *db = pParse->db; /* The database connection */ + Token *pObjName; /* Name of the table or index to be reindexed */ + + /* Read the database schema. If an error occurs, leave an error message + ** and code in pParse and return NULL. */ + if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){ + return; + } + + if( pName1==0 || pName1->z==0 ){ + reindexDatabases(pParse, 0); + return; + }else if( pName2==0 || pName2->z==0 ){ + char *zColl; + assert( pName1->z ); + zColl = sqlite3NameFromToken(pParse->db, pName1); + if( !zColl ) return; + pColl = sqlite3FindCollSeq(db, ENC(db), zColl, -1, 0); + if( pColl ){ + if( zColl ){ + reindexDatabases(pParse, zColl); + sqlite3_free(zColl); + } + return; + } + sqlite3_free(zColl); + } + iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pObjName); + if( iDb<0 ) return; + z = sqlite3NameFromToken(db, pObjName); + if( z==0 ) return; + zDb = db->aDb[iDb].zName; + pTab = sqlite3FindTable(db, z, zDb); + if( pTab ){ + reindexTable(pParse, pTab, 0); + sqlite3_free(z); + return; + } + pIndex = sqlite3FindIndex(db, z, zDb); + sqlite3_free(z); + if( pIndex ){ + sqlite3BeginWriteOperation(pParse, 0, iDb); + sqlite3RefillIndex(pParse, pIndex, -1); + return; + } + sqlite3ErrorMsg(pParse, "unable to identify the object to be reindexed"); +} +#endif + +/* +** Return a dynamicly allocated KeyInfo structure that can be used +** with OP_OpenRead or OP_OpenWrite to access database index pIdx. +** +** If successful, a pointer to the new structure is returned. In this case +** the caller is responsible for calling sqlite3_free() on the returned +** pointer. If an error occurs (out of memory or missing collation +** sequence), NULL is returned and the state of pParse updated to reflect +** the error. +*/ +KeyInfo *sqlite3IndexKeyinfo(Parse *pParse, Index *pIdx){ + int i; + int nCol = pIdx->nColumn; + int nBytes = sizeof(KeyInfo) + (nCol-1)*sizeof(CollSeq*) + nCol; + KeyInfo *pKey = (KeyInfo *)sqlite3DbMallocZero(pParse->db, nBytes); + + if( pKey ){ + pKey->db = pParse->db; + pKey->aSortOrder = (u8 *)&(pKey->aColl[nCol]); + assert( &pKey->aSortOrder[nCol]==&(((u8 *)pKey)[nBytes]) ); + for(i=0; iazColl[i]; + assert( zColl ); + pKey->aColl[i] = sqlite3LocateCollSeq(pParse, zColl, -1); + pKey->aSortOrder[i] = pIdx->aSortOrder[i]; + } + pKey->nField = nCol; + } + + if( pParse->nErr ){ + sqlite3_free(pKey); + pKey = 0; + } + return pKey; +} diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/callback.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/callback.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,378 @@ +/* +** 2005 May 23 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains functions used to access the internal hash tables +** of user defined functions and collation sequences. +** +** $Id: callback.cpp 1282 2008-11-13 09:31:33Z LarsPson $ +*/ + +#include "sqliteInt.h" + +/* +** Invoke the 'collation needed' callback to request a collation sequence +** in the database text encoding of name zName, length nName. +** If the collation sequence +*/ +static void callCollNeeded(sqlite3 *db, const char *zName, int nName){ + assert( !db->xCollNeeded || !db->xCollNeeded16 ); + if( nName<0 ) nName = strlen(zName); + if( db->xCollNeeded ){ + char *zExternal = sqlite3DbStrNDup(db, zName, nName); + if( !zExternal ) return; + db->xCollNeeded(db->pCollNeededArg, db, (int)ENC(db), zExternal); + sqlite3_free(zExternal); + } +#ifndef SQLITE_OMIT_UTF16 + if( db->xCollNeeded16 ){ + char const *zExternal; + sqlite3_value *pTmp = sqlite3ValueNew(db); + sqlite3ValueSetStr(pTmp, nName, zName, SQLITE_UTF8, SQLITE_STATIC); + zExternal = (const char*)sqlite3ValueText(pTmp, SQLITE_UTF16NATIVE); + if( zExternal ){ + db->xCollNeeded16(db->pCollNeededArg, db, (int)ENC(db), zExternal); + } + sqlite3ValueFree(pTmp); + } +#endif +} + +/* +** This routine is called if the collation factory fails to deliver a +** collation function in the best encoding but there may be other versions +** of this collation function (for other text encodings) available. Use one +** of these instead if they exist. Avoid a UTF-8 <-> UTF-16 conversion if +** possible. +*/ +static int synthCollSeq(sqlite3 *db, CollSeq *pColl){ + CollSeq *pColl2; + char *z = pColl->zName; + int n = strlen(z); + int i; + static const u8 aEnc[] = { SQLITE_UTF16BE, SQLITE_UTF16LE, SQLITE_UTF8 }; + for(i=0; i<3; i++){ + pColl2 = sqlite3FindCollSeq(db, aEnc[i], z, n, 0); + if( pColl2->xCmp!=0 ){ + memcpy(pColl, pColl2, sizeof(CollSeq)); + pColl->xDel = 0; /* Do not copy the destructor */ + return SQLITE_OK; + } + } + return SQLITE_ERROR; +} + +/* +** This function is responsible for invoking the collation factory callback +** or substituting a collation sequence of a different encoding when the +** requested collation sequence is not available in the database native +** encoding. +** +** If it is not NULL, then pColl must point to the database native encoding +** collation sequence with name zName, length nName. +** +** The return value is either the collation sequence to be used in database +** db for collation type name zName, length nName, or NULL, if no collation +** sequence can be found. +*/ +CollSeq *sqlite3GetCollSeq( + sqlite3* db, + CollSeq *pColl, + const char *zName, + int nName +){ + CollSeq *p; + + p = pColl; + if( !p ){ + p = sqlite3FindCollSeq(db, ENC(db), zName, nName, 0); + } + if( !p || !p->xCmp ){ + /* No collation sequence of this type for this encoding is registered. + ** Call the collation factory to see if it can supply us with one. + */ + callCollNeeded(db, zName, nName); + p = sqlite3FindCollSeq(db, ENC(db), zName, nName, 0); + } + if( p && !p->xCmp && synthCollSeq(db, p) ){ + p = 0; + } + assert( !p || p->xCmp ); + return p; +} + +/* +** This routine is called on a collation sequence before it is used to +** check that it is defined. An undefined collation sequence exists when +** a database is loaded that contains references to collation sequences +** that have not been defined by sqlite3_create_collation() etc. +** +** If required, this routine calls the 'collation needed' callback to +** request a definition of the collating sequence. If this doesn't work, +** an equivalent collating sequence that uses a text encoding different +** from the main database is substituted, if one is available. +*/ +int sqlite3CheckCollSeq(Parse *pParse, CollSeq *pColl){ + if( pColl ){ + const char *zName = pColl->zName; + CollSeq *p = sqlite3GetCollSeq(pParse->db, pColl, zName, -1); + if( !p ){ + if( pParse->nErr==0 ){ + sqlite3ErrorMsg(pParse, "no such collation sequence: %s", zName); + } + pParse->nErr++; + return SQLITE_ERROR; + } + assert( p==pColl ); + } + return SQLITE_OK; +} + + + +/* +** Locate and return an entry from the db.aCollSeq hash table. If the entry +** specified by zName and nName is not found and parameter 'create' is +** true, then create a new entry. Otherwise return NULL. +** +** Each pointer stored in the sqlite3.aCollSeq hash table contains an +** array of three CollSeq structures. The first is the collation sequence +** prefferred for UTF-8, the second UTF-16le, and the third UTF-16be. +** +** Stored immediately after the three collation sequences is a copy of +** the collation sequence name. A pointer to this string is stored in +** each collation sequence structure. +*/ +static CollSeq *findCollSeqEntry( + sqlite3 *db, + const char *zName, + int nName, + int create +){ + CollSeq *pColl; + if( nName<0 ) nName = strlen(zName); + pColl = (CollSeq*)sqlite3HashFind(&db->aCollSeq, zName, nName); + + if( 0==pColl && create ){ + pColl = (CollSeq*)sqlite3DbMallocZero(db, 3*sizeof(*pColl) + nName + 1 ); + if( pColl ){ + CollSeq *pDel = 0; + pColl[0].zName = (char*)&pColl[3]; + pColl[0].enc = SQLITE_UTF8; + pColl[1].zName = (char*)&pColl[3]; + pColl[1].enc = SQLITE_UTF16LE; + pColl[2].zName = (char*)&pColl[3]; + pColl[2].enc = SQLITE_UTF16BE; + memcpy(pColl[0].zName, zName, nName); + pColl[0].zName[nName] = 0; + pDel = (CollSeq*)sqlite3HashInsert(&db->aCollSeq, pColl[0].zName, nName, pColl); + + /* If a malloc() failure occured in sqlite3HashInsert(), it will + ** return the pColl pointer to be deleted (because it wasn't added + ** to the hash table). + */ + assert( pDel==0 || pDel==pColl ); + if( pDel!=0 ){ + db->mallocFailed = 1; + sqlite3_free(pDel); + pColl = 0; + } + } + } + return pColl; +} + +/* +** Parameter zName points to a UTF-8 encoded string nName bytes long. +** Return the CollSeq* pointer for the collation sequence named zName +** for the encoding 'enc' from the database 'db'. +** +** If the entry specified is not found and 'create' is true, then create a +** new entry. Otherwise return NULL. +** +** A separate function sqlite3LocateCollSeq() is a wrapper around +** this routine. sqlite3LocateCollSeq() invokes the collation factory +** if necessary and generates an error message if the collating sequence +** cannot be found. +*/ +CollSeq *sqlite3FindCollSeq( + sqlite3 *db, + u8 enc, + const char *zName, + int nName, + int create +){ + CollSeq *pColl; + if( zName ){ + pColl = findCollSeqEntry(db, zName, nName, create); + }else{ + pColl = db->pDfltColl; + } + assert( SQLITE_UTF8==1 && SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 ); + assert( enc>=SQLITE_UTF8 && enc<=SQLITE_UTF16BE ); + if( pColl ) pColl += enc-1; + return pColl; +} + +/* +** Locate a user function given a name, a number of arguments and a flag +** indicating whether the function prefers UTF-16 over UTF-8. Return a +** pointer to the FuncDef structure that defines that function, or return +** NULL if the function does not exist. +** +** If the createFlag argument is true, then a new (blank) FuncDef +** structure is created and liked into the "db" structure if a +** no matching function previously existed. When createFlag is true +** and the nArg parameter is -1, then only a function that accepts +** any number of arguments will be returned. +** +** If createFlag is false and nArg is -1, then the first valid +** function found is returned. A function is valid if either xFunc +** or xStep is non-zero. +** +** If createFlag is false, then a function with the required name and +** number of arguments may be returned even if the eTextRep flag does not +** match that requested. +*/ +FuncDef *sqlite3FindFunction( + sqlite3 *db, /* An open database */ + const char *zName, /* Name of the function. Not null-terminated */ + int nName, /* Number of characters in the name */ + int nArg, /* Number of arguments. -1 means any number */ + u8 enc, /* Preferred text encoding */ + int createFlag /* Create new entry if true and does not otherwise exist */ +){ + FuncDef *p; /* Iterator variable */ + FuncDef *pFirst; /* First function with this name */ + FuncDef *pBest = 0; /* Best match found so far */ + int bestmatch = 0; + + + assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE ); + if( nArg<-1 ) nArg = -1; + + pFirst = (FuncDef*)sqlite3HashFind(&db->aFunc, zName, nName); + for(p=pFirst; p; p=p->pNext){ + /* During the search for the best function definition, bestmatch is set + ** as follows to indicate the quality of the match with the definition + ** pointed to by pBest: + ** + ** 0: pBest is NULL. No match has been found. + ** 1: A variable arguments function that prefers UTF-8 when a UTF-16 + ** encoding is requested, or vice versa. + ** 2: A variable arguments function that uses UTF-16BE when UTF-16LE is + ** requested, or vice versa. + ** 3: A variable arguments function using the same text encoding. + ** 4: A function with the exact number of arguments requested that + ** prefers UTF-8 when a UTF-16 encoding is requested, or vice versa. + ** 5: A function with the exact number of arguments requested that + ** prefers UTF-16LE when UTF-16BE is requested, or vice versa. + ** 6: An exact match. + ** + ** A larger value of 'matchqual' indicates a more desirable match. + */ + if( p->nArg==-1 || p->nArg==nArg || nArg==-1 ){ + int match = 1; /* Quality of this match */ + if( p->nArg==nArg || nArg==-1 ){ + match = 4; + } + if( enc==p->iPrefEnc ){ + match += 2; + } + else if( (enc==SQLITE_UTF16LE && p->iPrefEnc==SQLITE_UTF16BE) || + (enc==SQLITE_UTF16BE && p->iPrefEnc==SQLITE_UTF16LE) ){ + match += 1; + } + + if( match>bestmatch ){ + pBest = p; + bestmatch = match; + } + } + } + + /* If the createFlag parameter is true, and the seach did not reveal an + ** exact match for the name, number of arguments and encoding, then add a + ** new entry to the hash table and return it. + */ + if( createFlag && bestmatch<6 && + (pBest = (FuncDef*)sqlite3DbMallocZero(db, sizeof(*pBest)+nName))!=0 ){ + pBest->nArg = nArg; + pBest->pNext = pFirst; + pBest->iPrefEnc = enc; + memcpy(pBest->zName, zName, nName); + pBest->zName[nName] = 0; + if( pBest==sqlite3HashInsert(&db->aFunc,pBest->zName,nName,(void*)pBest) ){ + db->mallocFailed = 1; + sqlite3_free(pBest); + return 0; + } + } + + if( pBest && (pBest->xStep || pBest->xFunc || createFlag) ){ + return pBest; + } + return 0; +} + +/* +** Free all resources held by the schema structure. The void* argument points +** at a Schema struct. This function does not call sqlite3_free() on the +** pointer itself, it just cleans up subsiduary resources (i.e. the contents +** of the schema hash tables). +*/ +void sqlite3SchemaFree(void *p){ + Hash temp1; + Hash temp2; + HashElem *pElem; + Schema *pSchema = (Schema *)p; + + temp1 = pSchema->tblHash; + temp2 = pSchema->trigHash; + sqlite3HashInit(&pSchema->trigHash, SQLITE_HASH_STRING, 0); + sqlite3HashClear(&pSchema->aFKey); + sqlite3HashClear(&pSchema->idxHash); + for(pElem=sqliteHashFirst(&temp2); pElem; pElem=sqliteHashNext(pElem)){ + sqlite3DeleteTrigger((Trigger*)sqliteHashData(pElem)); + } + sqlite3HashClear(&temp2); + sqlite3HashInit(&pSchema->tblHash, SQLITE_HASH_STRING, 0); + for(pElem=sqliteHashFirst(&temp1); pElem; pElem=sqliteHashNext(pElem)){ + Table *pTab = (Table*)sqliteHashData(pElem); + sqlite3DeleteTable(pTab); + } + sqlite3HashClear(&temp1); + pSchema->pSeqTab = 0; + pSchema->flags &= ~DB_SchemaLoaded; +} + +/* +** Find and return the schema associated with a BTree. Create +** a new one if necessary. +*/ +Schema *sqlite3SchemaGet(sqlite3 *db, Btree *pBt){ + Schema * p; + if( pBt ){ + p = (Schema *)sqlite3BtreeSchema(pBt, sizeof(Schema), sqlite3SchemaFree); + }else{ + p = (Schema *)sqlite3MallocZero(sizeof(Schema)); + } + if( !p ){ + db->mallocFailed = 1; + }else if ( 0==p->file_format ){ + sqlite3HashInit(&p->tblHash, SQLITE_HASH_STRING, 0); + sqlite3HashInit(&p->idxHash, SQLITE_HASH_STRING, 0); + sqlite3HashInit(&p->trigHash, SQLITE_HASH_STRING, 0); + sqlite3HashInit(&p->aFKey, SQLITE_HASH_STRING, 1); + p->enc = SQLITE_UTF8; + } + return p; +} diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/complete.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/complete.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,271 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** An tokenizer for SQL +** +** This file contains C code that implements the sqlite3_complete() API. +** This code used to be part of the tokenizer.c source file. But by +** separating it out, the code will be automatically omitted from +** static links that do not use it. +** +** $Id: complete.cpp 1282 2008-11-13 09:31:33Z LarsPson $ +*/ +#include "sqliteInt.h" +#ifndef SQLITE_OMIT_COMPLETE + +/* +** This is defined in tokenize.c. We just have to import the definition. +*/ +//#ifndef SQLITE_AMALGAMATION +//#ifdef SQLITE_ASCII +//extern const char sqlite3IsAsciiIdChar[]; +//#define IdChar(C) (((c=C)&0x80)!=0 || (c>0x1f && sqlite3IsAsciiIdChar[c-0x20])) +//#endif +//#ifdef SQLITE_EBCDIC +//extern const char sqlite3IsEbcdicIdChar[]; +//#define IdChar(C) (((c=C)>=0x42 && sqlite3IsEbcdicIdChar[c-0x40])) +//#endif +//#endif /* SQLITE_AMALGAMATION */ + + +/* +** Token types used by the sqlite3_complete() routine. See the header +** comments on that procedure for additional information. +*/ +#define tkSEMI 0 +#define tkWS 1 +#define tkOTHER 2 +#define tkEXPLAIN 3 +#define tkCREATE 4 +#define tkTEMP 5 +#define tkTRIGGER 6 +#define tkEND 7 + +/* +** Return TRUE if the given SQL string ends in a semicolon. +** +** Special handling is require for CREATE TRIGGER statements. +** Whenever the CREATE TRIGGER keywords are seen, the statement +** must end with ";END;". +** +** This implementation uses a state machine with 7 states: +** +** (0) START At the beginning or end of an SQL statement. This routine +** returns 1 if it ends in the START state and 0 if it ends +** in any other state. +** +** (1) NORMAL We are in the middle of statement which ends with a single +** semicolon. +** +** (2) EXPLAIN The keyword EXPLAIN has been seen at the beginning of +** a statement. +** +** (3) CREATE The keyword CREATE has been seen at the beginning of a +** statement, possibly preceeded by EXPLAIN and/or followed by +** TEMP or TEMPORARY +** +** (4) TRIGGER We are in the middle of a trigger definition that must be +** ended by a semicolon, the keyword END, and another semicolon. +** +** (5) SEMI We've seen the first semicolon in the ";END;" that occurs at +** the end of a trigger definition. +** +** (6) END We've seen the ";END" of the ";END;" that occurs at the end +** of a trigger difinition. +** +** Transitions between states above are determined by tokens extracted +** from the input. The following tokens are significant: +** +** (0) tkSEMI A semicolon. +** (1) tkWS Whitespace +** (2) tkOTHER Any other SQL token. +** (3) tkEXPLAIN The "explain" keyword. +** (4) tkCREATE The "create" keyword. +** (5) tkTEMP The "temp" or "temporary" keyword. +** (6) tkTRIGGER The "trigger" keyword. +** (7) tkEND The "end" keyword. +** +** Whitespace never causes a state transition and is always ignored. +** +** If we compile with SQLITE_OMIT_TRIGGER, all of the computation needed +** to recognize the end of a trigger can be omitted. All we have to do +** is look for a semicolon that is not part of an string or comment. +*/ +EXPORT_C int sqlite3_complete(const char *zSql){ + u8 state = 0; /* Current state, using numbers defined in header comment */ + u8 token; /* Value of the next token */ + +#ifndef SQLITE_OMIT_TRIGGER + /* A complex statement machine used to detect the end of a CREATE TRIGGER + ** statement. This is the normal case. + */ + static const u8 trans[7][8] = { + /* Token: */ + /* State: ** SEMI WS OTHER EXPLAIN CREATE TEMP TRIGGER END */ + /* 0 START: */ { 0, 0, 1, 2, 3, 1, 1, 1, }, + /* 1 NORMAL: */ { 0, 1, 1, 1, 1, 1, 1, 1, }, + /* 2 EXPLAIN: */ { 0, 2, 1, 1, 3, 1, 1, 1, }, + /* 3 CREATE: */ { 0, 3, 1, 1, 1, 3, 4, 1, }, + /* 4 TRIGGER: */ { 5, 4, 4, 4, 4, 4, 4, 4, }, + /* 5 SEMI: */ { 5, 5, 4, 4, 4, 4, 4, 6, }, + /* 6 END: */ { 0, 6, 4, 4, 4, 4, 4, 4, }, + }; +#else + /* If triggers are not suppored by this compile then the statement machine + ** used to detect the end of a statement is much simplier + */ + static const u8 trans[2][3] = { + /* Token: */ + /* State: ** SEMI WS OTHER */ + /* 0 START: */ { 0, 0, 1, }, + /* 1 NORMAL: */ { 0, 1, 1, }, + }; +#endif /* SQLITE_OMIT_TRIGGER */ + + while( *zSql ){ + switch( *zSql ){ + case ';': { /* A semicolon */ + token = tkSEMI; + break; + } + case ' ': + case '\r': + case '\t': + case '\n': + case '\f': { /* White space is ignored */ + token = tkWS; + break; + } + case '/': { /* C-style comments */ + if( zSql[1]!='*' ){ + token = tkOTHER; + break; + } + zSql += 2; + while( zSql[0] && (zSql[0]!='*' || zSql[1]!='/') ){ zSql++; } + if( zSql[0]==0 ) return 0; + zSql++; + token = tkWS; + break; + } + case '-': { /* SQL-style comments from "--" to end of line */ + if( zSql[1]!='-' ){ + token = tkOTHER; + break; + } + while( *zSql && *zSql!='\n' ){ zSql++; } + if( *zSql==0 ) return state==0; + token = tkWS; + break; + } + case '[': { /* Microsoft-style identifiers in [...] */ + zSql++; + while( *zSql && *zSql!=']' ){ zSql++; } + if( *zSql==0 ) return 0; + token = tkOTHER; + break; + } + case '`': /* Grave-accent quoted symbols used by MySQL */ + case '"': /* single- and double-quoted strings */ + case '\'': { + int c = *zSql; + zSql++; + while( *zSql && *zSql!=c ){ zSql++; } + if( *zSql==0 ) return 0; + token = tkOTHER; + break; + } + default: { + int c; + if( IdChar((u8)*zSql) ){ + /* Keywords and unquoted identifiers */ + int nId; + for(nId=1; IdChar(zSql[nId]); nId++){} +#ifdef SQLITE_OMIT_TRIGGER + token = tkOTHER; +#else + switch( *zSql ){ + case 'c': case 'C': { + if( nId==6 && sqlite3StrNICmp(zSql, "create", 6)==0 ){ + token = tkCREATE; + }else{ + token = tkOTHER; + } + break; + } + case 't': case 'T': { + if( nId==7 && sqlite3StrNICmp(zSql, "trigger", 7)==0 ){ + token = tkTRIGGER; + }else if( nId==4 && sqlite3StrNICmp(zSql, "temp", 4)==0 ){ + token = tkTEMP; + }else if( nId==9 && sqlite3StrNICmp(zSql, "temporary", 9)==0 ){ + token = tkTEMP; + }else{ + token = tkOTHER; + } + break; + } + case 'e': case 'E': { + if( nId==3 && sqlite3StrNICmp(zSql, "end", 3)==0 ){ + token = tkEND; + }else +#ifndef SQLITE_OMIT_EXPLAIN + if( nId==7 && sqlite3StrNICmp(zSql, "explain", 7)==0 ){ + token = tkEXPLAIN; + }else +#endif + { + token = tkOTHER; + } + break; + } + default: { + token = tkOTHER; + break; + } + } +#endif /* SQLITE_OMIT_TRIGGER */ + zSql += nId-1; + }else{ + /* Operators and special symbols */ + token = tkOTHER; + } + break; + } + } + state = trans[state][token]; + zSql++; + } + return state==0; +} + +#ifndef SQLITE_OMIT_UTF16 +/* +** This routine is the same as the sqlite3_complete() routine described +** above, except that the parameter is required to be UTF-16 encoded, not +** UTF-8. +*/ +EXPORT_C int sqlite3_complete16(const void *zSql){ + sqlite3_value *pVal; + char const *zSql8; + int rc = SQLITE_NOMEM; + + pVal = sqlite3ValueNew(0); + sqlite3ValueSetStr(pVal, -1, zSql, SQLITE_UTF16NATIVE, SQLITE_STATIC); + zSql8 = (const char*)sqlite3ValueText(pVal, SQLITE_UTF8); + if( zSql8 ){ + rc = sqlite3_complete(zSql8); + } + sqlite3ValueFree(pVal); + return sqlite3ApiExit(0, rc); +} +#endif /* SQLITE_OMIT_UTF16 */ +#endif /* SQLITE_OMIT_COMPLETE */ diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/date.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/date.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,1045 @@ +/* +** 2003 October 31 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the C functions that implement date and time +** functions for SQLite. +** +** There is only one exported symbol in this file - the function +** sqlite3RegisterDateTimeFunctions() found at the bottom of the file. +** All other code has file scope. +** +** $Id: date.cpp 1282 2008-11-13 09:31:33Z LarsPson $ +** +** SQLite processes all times and dates as Julian Day numbers. The +** dates and times are stored as the number of days since noon +** in Greenwich on November 24, 4714 B.C. according to the Gregorian +** calendar system. +** +** 1970-01-01 00:00:00 is JD 2440587.5 +** 2000-01-01 00:00:00 is JD 2451544.5 +** +** This implemention requires years to be expressed as a 4-digit number +** which means that only dates between 0000-01-01 and 9999-12-31 can +** be represented, even though julian day numbers allow a much wider +** range of dates. +** +** The Gregorian calendar system is used for all dates and times, +** even those that predate the Gregorian calendar. Historians usually +** use the Julian calendar for dates prior to 1582-10-15 and for some +** dates afterwards, depending on locale. Beware of this difference. +** +** The conversion algorithms are implemented based on descriptions +** in the following text: +** +** Jean Meeus +** Astronomical Algorithms, 2nd Edition, 1998 +** ISBM 0-943396-61-1 +** Willmann-Bell, Inc +** Richmond, Virginia (USA) +*/ +#include "sqliteInt.h" +#include +#include +#include +#include + +#ifndef SQLITE_OMIT_DATETIME_FUNCS + +/* +** A structure for holding a single date and time. +*/ +typedef struct DateTime DateTime; +struct DateTime { + double rJD; /* The julian day number */ + int Y, M, D; /* Year, month, and day */ + int h, m; /* Hour and minutes */ + int tz; /* Timezone offset in minutes */ + double s; /* Seconds */ + char validYMD; /* True if Y,M,D are valid */ + char validHMS; /* True if h,m,s are valid */ + char validJD; /* True if rJD is valid */ + char validTZ; /* True if tz is valid */ +}; + + +/* +** Convert zDate into one or more integers. Additional arguments +** come in groups of 5 as follows: +** +** N number of digits in the integer +** min minimum allowed value of the integer +** max maximum allowed value of the integer +** nextC first character after the integer +** pVal where to write the integers value. +** +** Conversions continue until one with nextC==0 is encountered. +** The function returns the number of successful conversions. +*/ +static int getDigits(const char *zDate, ...){ + va_list ap; + int val; + int N; + int min; + int max; + int nextC; + int *pVal; + int cnt = 0; + va_start(ap, zDate); + do{ + N = va_arg(ap, int); + min = va_arg(ap, int); + max = va_arg(ap, int); + nextC = va_arg(ap, int); + pVal = va_arg(ap, int*); + val = 0; + while( N-- ){ + if( !isdigit(*(u8*)zDate) ){ + goto end_getDigits; + } + val = val*10 + *zDate - '0'; + zDate++; + } + if( valmax || (nextC!=0 && nextC!=*zDate) ){ + goto end_getDigits; + } + *pVal = val; + zDate++; + cnt++; + }while( nextC ); +end_getDigits: + va_end(ap); + return cnt; +} + +/* +** Read text from z[] and convert into a floating point number. Return +** the number of digits converted. +*/ +#define getValue sqlite3AtoF + +/* +** Parse a timezone extension on the end of a date-time. +** The extension is of the form: +** +** (+/-)HH:MM +** +** If the parse is successful, write the number of minutes +** of change in *pnMin and return 0. If a parser error occurs, +** return 0. +** +** A missing specifier is not considered an error. +*/ +static int parseTimezone(const char *zDate, DateTime *p){ + int sgn = 0; + int nHr, nMn; + while( isspace(*(u8*)zDate) ){ zDate++; } + p->tz = 0; + if( *zDate=='-' ){ + sgn = -1; + }else if( *zDate=='+' ){ + sgn = +1; + }else{ + return *zDate!=0; + } + zDate++; + if( getDigits(zDate, 2, 0, 14, ':', &nHr, 2, 0, 59, 0, &nMn)!=2 ){ + return 1; + } + zDate += 5; + p->tz = sgn*(nMn + nHr*60); + while( isspace(*(u8*)zDate) ){ zDate++; } + return *zDate!=0; +} + +/* +** Parse times of the form HH:MM or HH:MM:SS or HH:MM:SS.FFFF. +** The HH, MM, and SS must each be exactly 2 digits. The +** fractional seconds FFFF can be one or more digits. +** +** Return 1 if there is a parsing error and 0 on success. +*/ +static int parseHhMmSs(const char *zDate, DateTime *p){ + int h, m, s; + double ms = 0.0; + if( getDigits(zDate, 2, 0, 24, ':', &h, 2, 0, 59, 0, &m)!=2 ){ + return 1; + } + zDate += 5; + if( *zDate==':' ){ + zDate++; + if( getDigits(zDate, 2, 0, 59, 0, &s)!=1 ){ + return 1; + } + zDate += 2; + if( *zDate=='.' && isdigit((u8)zDate[1]) ){ + double rScale = 1.0; + zDate++; + while( isdigit(*(u8*)zDate) ){ + ms = ms*10.0 + *zDate - '0'; + rScale *= 10.0; + zDate++; + } + ms /= rScale; + } + }else{ + s = 0; + } + p->validJD = 0; + p->validHMS = 1; + p->h = h; + p->m = m; + p->s = s + ms; + if( parseTimezone(zDate, p) ) return 1; + p->validTZ = p->tz!=0; + return 0; +} + +/* +** Convert from YYYY-MM-DD HH:MM:SS to julian day. We always assume +** that the YYYY-MM-DD is according to the Gregorian calendar. +** +** Reference: Meeus page 61 +*/ +static void computeJD(DateTime *p){ + int Y, M, D, A, B, X1, X2; + + if( p->validJD ) return; + if( p->validYMD ){ + Y = p->Y; + M = p->M; + D = p->D; + }else{ + Y = 2000; /* If no YMD specified, assume 2000-Jan-01 */ + M = 1; + D = 1; + } + if( M<=2 ){ + Y--; + M += 12; + } + A = Y/100; + B = 2 - A + (A/4); + X1 = 365.25*(Y+4716); + X2 = 30.6001*(M+1); + p->rJD = X1 + X2 + D + B - 1524.5; + p->validJD = 1; + if( p->validHMS ){ + p->rJD += (p->h*3600.0 + p->m*60.0 + p->s)/86400.0; + if( p->validTZ ){ + p->rJD -= p->tz*60/86400.0; + p->validYMD = 0; + p->validHMS = 0; + p->validTZ = 0; + } + } +} + +/* +** Parse dates of the form +** +** YYYY-MM-DD HH:MM:SS.FFF +** YYYY-MM-DD HH:MM:SS +** YYYY-MM-DD HH:MM +** YYYY-MM-DD +** +** Write the result into the DateTime structure and return 0 +** on success and 1 if the input string is not a well-formed +** date. +*/ +static int parseYyyyMmDd(const char *zDate, DateTime *p){ + int Y, M, D, neg; + + if( zDate[0]=='-' ){ + zDate++; + neg = 1; + }else{ + neg = 0; + } + if( getDigits(zDate,4,0,9999,'-',&Y,2,1,12,'-',&M,2,1,31,0,&D)!=3 ){ + return 1; + } + zDate += 10; + while( isspace(*(u8*)zDate) || 'T'==*(u8*)zDate ){ zDate++; } + if( parseHhMmSs(zDate, p)==0 ){ + /* We got the time */ + }else if( *zDate==0 ){ + p->validHMS = 0; + }else{ + return 1; + } + p->validJD = 0; + p->validYMD = 1; + p->Y = neg ? -Y : Y; + p->M = M; + p->D = D; + if( p->validTZ ){ + computeJD(p); + } + return 0; +} + +/* +** Attempt to parse the given string into a Julian Day Number. Return +** the number of errors. +** +** The following are acceptable forms for the input string: +** +** YYYY-MM-DD HH:MM:SS.FFF +/-HH:MM +** DDDD.DD +** now +** +** In the first form, the +/-HH:MM is always optional. The fractional +** seconds extension (the ".FFF") is optional. The seconds portion +** (":SS.FFF") is option. The year and date can be omitted as long +** as there is a time string. The time string can be omitted as long +** as there is a year and date. +*/ +static int parseDateOrTime( + sqlite3_context *context, + const char *zDate, + DateTime *p +){ + memset(p, 0, sizeof(*p)); + if( parseYyyyMmDd(zDate,p)==0 ){ + return 0; + }else if( parseHhMmSs(zDate, p)==0 ){ + return 0; + }else if( sqlite3StrICmp(zDate,"now")==0){ + double r; + sqlite3OsCurrentTime((sqlite3_vfs *)sqlite3_user_data(context), &r); + p->rJD = r; + p->validJD = 1; + return 0; + }else if( sqlite3IsNumber(zDate, 0, SQLITE_UTF8) ){ + getValue(zDate, &p->rJD); + p->validJD = 1; + return 0; + } + return 1; +} + +/* +** Compute the Year, Month, and Day from the julian day number. +*/ +static void computeYMD(DateTime *p){ + int Z, A, B, C, D, E, X1; + if( p->validYMD ) return; + if( !p->validJD ){ + p->Y = 2000; + p->M = 1; + p->D = 1; + }else{ + Z = p->rJD + 0.5; + A = (Z - 1867216.25)/36524.25; + A = Z + 1 + A - (A/4); + B = A + 1524; + C = (B - 122.1)/365.25; + D = 365.25*C; + E = (B-D)/30.6001; + X1 = 30.6001*E; + p->D = B - D - X1; + p->M = E<14 ? E-1 : E-13; + p->Y = p->M>2 ? C - 4716 : C - 4715; + } + p->validYMD = 1; +} + +/* +** Compute the Hour, Minute, and Seconds from the julian day number. +*/ +static void computeHMS(DateTime *p){ + int Z, s; + if( p->validHMS ) return; + computeJD(p); + Z = p->rJD + 0.5; + s = (p->rJD + 0.5 - Z)*86400000.0 + 0.5; + p->s = 0.001*s; + s = p->s; + p->s -= s; + p->h = s/3600; + s -= p->h*3600; + p->m = s/60; + p->s += s - p->m*60; + p->validHMS = 1; +} + +/* +** Compute both YMD and HMS +*/ +static void computeYMD_HMS(DateTime *p){ + computeYMD(p); + computeHMS(p); +} + +/* +** Clear the YMD and HMS and the TZ +*/ +static void clearYMD_HMS_TZ(DateTime *p){ + p->validYMD = 0; + p->validHMS = 0; + p->validTZ = 0; +} + +/* +** Compute the difference (in days) between localtime and UTC (a.k.a. GMT) +** for the time value p where p is in UTC. +*/ +static double localtimeOffset(DateTime *p){ + DateTime x, y; + time_t t; + x = *p; + computeYMD_HMS(&x); + if( x.Y<1971 || x.Y>=2038 ){ + x.Y = 2000; + x.M = 1; + x.D = 1; + x.h = 0; + x.m = 0; + x.s = 0.0; + } else { + int s = x.s + 0.5; + x.s = s; + } + x.tz = 0; + x.validJD = 0; + computeJD(&x); + t = (x.rJD-2440587.5)*86400.0 + 0.5; +#ifdef HAVE_LOCALTIME_R + { + struct tm sLocal; + localtime_r(&t, &sLocal); + y.Y = sLocal.tm_year + 1900; + y.M = sLocal.tm_mon + 1; + y.D = sLocal.tm_mday; + y.h = sLocal.tm_hour; + y.m = sLocal.tm_min; + y.s = sLocal.tm_sec; + } +#else + { + struct tm *pTm; + sqlite3_mutex_enter(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER)); + pTm = localtime(&t); + y.Y = pTm->tm_year + 1900; + y.M = pTm->tm_mon + 1; + y.D = pTm->tm_mday; + y.h = pTm->tm_hour; + y.m = pTm->tm_min; + y.s = pTm->tm_sec; + sqlite3_mutex_leave(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER)); + } +#endif + y.validYMD = 1; + y.validHMS = 1; + y.validJD = 0; + y.validTZ = 0; + computeJD(&y); + return y.rJD - x.rJD; +} + +/* +** Process a modifier to a date-time stamp. The modifiers are +** as follows: +** +** NNN days +** NNN hours +** NNN minutes +** NNN.NNNN seconds +** NNN months +** NNN years +** start of month +** start of year +** start of week +** start of day +** weekday N +** unixepoch +** localtime +** utc +** +** Return 0 on success and 1 if there is any kind of error. +*/ +static int parseModifier(const char *zMod, DateTime *p){ + int rc = 1; + int n; + double r; + char *z, zBuf[30]; + z = zBuf; + for(n=0; nrJD += localtimeOffset(p); + clearYMD_HMS_TZ(p); + rc = 0; + } + break; + } + case 'u': { + /* + ** unixepoch + ** + ** Treat the current value of p->rJD as the number of + ** seconds since 1970. Convert to a real julian day number. + */ + if( strcmp(z, "unixepoch")==0 && p->validJD ){ + p->rJD = p->rJD/86400.0 + 2440587.5; + clearYMD_HMS_TZ(p); + rc = 0; + }else if( strcmp(z, "utc")==0 ){ + double c1; + computeJD(p); + c1 = localtimeOffset(p); + p->rJD -= c1; + clearYMD_HMS_TZ(p); + p->rJD += c1 - localtimeOffset(p); + rc = 0; + } + break; + } + case 'w': { + /* + ** weekday N + ** + ** Move the date to the same time on the next occurrence of + ** weekday N where 0==Sunday, 1==Monday, and so forth. If the + ** date is already on the appropriate weekday, this is a no-op. + */ + if( strncmp(z, "weekday ", 8)==0 && getValue(&z[8],&r)>0 + && (n=r)==r && n>=0 && r<7 ){ + int Z; + computeYMD_HMS(p); + p->validTZ = 0; + p->validJD = 0; + computeJD(p); + Z = p->rJD + 1.5; + Z %= 7; + if( Z>n ) Z -= 7; + p->rJD += n - Z; + clearYMD_HMS_TZ(p); + rc = 0; + } + break; + } + case 's': { + /* + ** start of TTTTT + ** + ** Move the date backwards to the beginning of the current day, + ** or month or year. + */ + if( strncmp(z, "start of ", 9)!=0 ) break; + z += 9; + computeYMD(p); + p->validHMS = 1; + p->h = p->m = 0; + p->s = 0.0; + p->validTZ = 0; + p->validJD = 0; + if( strcmp(z,"month")==0 ){ + p->D = 1; + rc = 0; + }else if( strcmp(z,"year")==0 ){ + computeYMD(p); + p->M = 1; + p->D = 1; + rc = 0; + }else if( strcmp(z,"day")==0 ){ + rc = 0; + } + break; + } + case '+': + case '-': + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': { + n = getValue(z, &r); + assert( n>=1 ); + if( z[n]==':' ){ + /* A modifier of the form (+|-)HH:MM:SS.FFF adds (or subtracts) the + ** specified number of hours, minutes, seconds, and fractional seconds + ** to the time. The ".FFF" may be omitted. The ":SS.FFF" may be + ** omitted. + */ + const char *z2 = z; + DateTime tx; + int day; + if( !isdigit(*(u8*)z2) ) z2++; + memset(&tx, 0, sizeof(tx)); + if( parseHhMmSs(z2, &tx) ) break; + computeJD(&tx); + tx.rJD -= 0.5; + day = (int)tx.rJD; + tx.rJD -= day; + if( z[0]=='-' ) tx.rJD = -tx.rJD; + computeJD(p); + clearYMD_HMS_TZ(p); + p->rJD += tx.rJD; + rc = 0; + break; + } + z += n; + while( isspace(*(u8*)z) ) z++; + n = strlen(z); + if( n>10 || n<3 ) break; + if( z[n-1]=='s' ){ z[n-1] = 0; n--; } + computeJD(p); + rc = 0; + if( n==3 && strcmp(z,"day")==0 ){ + p->rJD += r; + }else if( n==4 && strcmp(z,"hour")==0 ){ + p->rJD += r/24.0; + }else if( n==6 && strcmp(z,"minute")==0 ){ + p->rJD += r/(24.0*60.0); + }else if( n==6 && strcmp(z,"second")==0 ){ + p->rJD += r/(24.0*60.0*60.0); + }else if( n==5 && strcmp(z,"month")==0 ){ + int x, y; + computeYMD_HMS(p); + p->M += r; + x = p->M>0 ? (p->M-1)/12 : (p->M-12)/12; + p->Y += x; + p->M -= x*12; + p->validJD = 0; + computeJD(p); + y = r; + if( y!=r ){ + p->rJD += (r - y)*30.0; + } + }else if( n==4 && strcmp(z,"year")==0 ){ + computeYMD_HMS(p); + p->Y += r; + p->validJD = 0; + computeJD(p); + }else{ + rc = 1; + } + clearYMD_HMS_TZ(p); + break; + } + default: { + break; + } + } + return rc; +} + +/* +** Process time function arguments. argv[0] is a date-time stamp. +** argv[1] and following are modifiers. Parse them all and write +** the resulting time into the DateTime structure p. Return 0 +** on success and 1 if there are any errors. +*/ +static int isDate( + sqlite3_context *context, + int argc, + sqlite3_value **argv, + DateTime *p +){ + int i; + const unsigned char *z; + if( argc==0 ) return 1; + z = sqlite3_value_text(argv[0]); + if( !z || parseDateOrTime(context, (char*)z, p) ){ + return 1; + } + for(i=1; iSQLITE_MAX_LENGTH ){ + sqlite3_result_error_toobig(context); + return; + }else{ + z = (char*)sqlite3_malloc( n ); + if( z==0 ) return; + } + computeJD(&x); + computeYMD_HMS(&x); + for(i=j=0; zFmt[i]; i++){ + if( zFmt[i]!='%' ){ + z[j++] = zFmt[i]; + }else{ + i++; + switch( zFmt[i] ){ + case 'd': sqlite3_snprintf(3, &z[j],"%02d",x.D); j+=2; break; + case 'f': { + double s = x.s; + if( s>59.999 ) s = 59.999; + sqlite3_snprintf(7, &z[j],"%06.3f", s); + j += strlen(&z[j]); + break; + } + case 'H': sqlite3_snprintf(3, &z[j],"%02d",x.h); j+=2; break; + case 'W': /* Fall thru */ + case 'j': { + int nDay; /* Number of days since 1st day of year */ + DateTime y = x; + y.validJD = 0; + y.M = 1; + y.D = 1; + computeJD(&y); + nDay = x.rJD - y.rJD + 0.5; + if( zFmt[i]=='W' ){ + int wd; /* 0=Monday, 1=Tuesday, ... 6=Sunday */ + wd = ((int)(x.rJD+0.5)) % 7; + sqlite3_snprintf(3, &z[j],"%02d",(nDay+7-wd)/7); + j += 2; + }else{ + sqlite3_snprintf(4, &z[j],"%03d",nDay+1); + j += 3; + } + break; + } + case 'J': { + sqlite3_snprintf(20, &z[j],"%.16g",x.rJD); + j+=strlen(&z[j]); + break; + } + case 'm': sqlite3_snprintf(3, &z[j],"%02d",x.M); j+=2; break; + case 'M': sqlite3_snprintf(3, &z[j],"%02d",x.m); j+=2; break; + case 's': { + sqlite3_snprintf(30,&z[j],"%d", + (int)((x.rJD-2440587.5)*86400.0 + 0.5)); + j += strlen(&z[j]); + break; + } + case 'S': sqlite3_snprintf(3,&z[j],"%02d",(int)x.s); j+=2; break; + case 'w': z[j++] = (((int)(x.rJD+1.5)) % 7) + '0'; break; + case 'Y': sqlite3_snprintf(5,&z[j],"%04d",x.Y); j+=strlen(&z[j]);break; + case '%': z[j++] = '%'; break; + } + } + } + z[j] = 0; + sqlite3_result_text(context, z, -1, SQLITE_TRANSIENT); + if( z!=zBuf ){ + sqlite3_free(z); + } +} + +/* +** current_time() +** +** This function returns the same value as time('now'). +*/ +static void ctimeFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + sqlite3_value *pVal = sqlite3ValueNew(0); + if( pVal ){ + sqlite3ValueSetStr(pVal, -1, "now", SQLITE_UTF8, SQLITE_STATIC); + timeFunc(context, 1, &pVal); + sqlite3ValueFree(pVal); + } +} + +/* +** current_date() +** +** This function returns the same value as date('now'). +*/ +static void cdateFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + sqlite3_value *pVal = sqlite3ValueNew(0); + if( pVal ){ + sqlite3ValueSetStr(pVal, -1, "now", SQLITE_UTF8, SQLITE_STATIC); + dateFunc(context, 1, &pVal); + sqlite3ValueFree(pVal); + } +} + +/* +** current_timestamp() +** +** This function returns the same value as datetime('now'). +*/ +static void ctimestampFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + sqlite3_value *pVal = sqlite3ValueNew(0); + if( pVal ){ + sqlite3ValueSetStr(pVal, -1, "now", SQLITE_UTF8, SQLITE_STATIC); + datetimeFunc(context, 1, &pVal); + sqlite3ValueFree(pVal); + } +} +#endif /* !defined(SQLITE_OMIT_DATETIME_FUNCS) */ + +#ifdef SQLITE_OMIT_DATETIME_FUNCS +/* +** If the library is compiled to omit the full-scale date and time +** handling (to get a smaller binary), the following minimal version +** of the functions current_time(), current_date() and current_timestamp() +** are included instead. This is to support column declarations that +** include "DEFAULT CURRENT_TIME" etc. +** +** This function uses the C-library functions time(), gmtime() +** and strftime(). The format string to pass to strftime() is supplied +** as the user-data for the function. +*/ +static void currentTimeFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + time_t t; + char *zFormat = (char *)sqlite3_user_data(context); + char zBuf[20]; + + time(&t); +#ifdef SQLITE_TEST + { + extern int sqlite3_current_time; /* See os_XXX.c */ + if( sqlite3_current_time ){ + t = sqlite3_current_time; + } + } +#endif + +#ifdef HAVE_GMTIME_R + { + struct tm sNow; + gmtime_r(&t, &sNow); + strftime(zBuf, 20, zFormat, &sNow); + } +#else + { + struct tm *pTm; + sqlite3_mutex_enter(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER)); + pTm = gmtime(&t); + strftime(zBuf, 20, zFormat, pTm); + sqlite3_mutex_leave(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER)); + } +#endif + + sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT); +} +#endif + +/* +** This function registered all of the above C functions as SQL +** functions. This should be the only routine in this file with +** external linkage. +*/ +void sqlite3RegisterDateTimeFunctions(sqlite3 *db){ +#ifndef SQLITE_OMIT_DATETIME_FUNCS + static const struct { + char *zName; + int nArg; + void (*xFunc)(sqlite3_context*,int,sqlite3_value**); + } aFuncs[] = { + { "julianday", -1, juliandayFunc }, + { "date", -1, dateFunc }, + { "time", -1, timeFunc }, + { "datetime", -1, datetimeFunc }, + { "strftime", -1, strftimeFunc }, + { "current_time", 0, ctimeFunc }, + { "current_timestamp", 0, ctimestampFunc }, + { "current_date", 0, cdateFunc }, + }; + int i; + + for(i=0; ipVfs), aFuncs[i].xFunc, 0, 0); + } +#else + static const struct { + char *zName; + char *zFormat; + } aFuncs[] = { + { "current_time", "%H:%M:%S" }, + { "current_date", "%Y-%m-%d" }, + { "current_timestamp", "%Y-%m-%d %H:%M:%S" } + }; + int i; + + for(i=0; izErrMsg and return NULL. If all tables +** are found, return a pointer to the last table. +*/ +Table *sqlite3SrcListLookup(Parse *pParse, SrcList *pSrc){ + Table *pTab = 0; + int i; + SrcList::SrcList_item *pItem; + for(i=0, pItem=pSrc->a; inSrc; i++, pItem++){ + pTab = sqlite3LocateTable(pParse, pItem->zName, pItem->zDatabase); + sqlite3DeleteTable(pItem->pTab); + pItem->pTab = pTab; + if( pTab ){ + pTab->nRef++; + } + } + return pTab; +} + +/* +** Check to make sure the given table is writable. If it is not +** writable, generate an error message and return 1. If it is +** writable return 0; +*/ +int sqlite3IsReadOnly(Parse *pParse, Table *pTab, int viewOk){ + if( (pTab->readOnly && (pParse->db->flags & SQLITE_WriteSchema)==0 + && pParse->nested==0) +#ifndef SQLITE_OMIT_VIRTUALTABLE + || (pTab->pMod && pTab->pMod->pModule->xUpdate==0) +#endif + ){ + sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName); + return 1; + } +#ifndef SQLITE_OMIT_VIEW + if( !viewOk && pTab->pSelect ){ + sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName); + return 1; + } +#endif + return 0; +} + +/* +** Generate code that will open a table for reading. +*/ +void sqlite3OpenTable( + Parse *p, /* Generate code into this VDBE */ + int iCur, /* The cursor number of the table */ + int iDb, /* The database index in sqlite3.aDb[] */ + Table *pTab, /* The table to be opened */ + int opcode /* OP_OpenRead or OP_OpenWrite */ +){ + Vdbe *v; + if( IsVirtual(pTab) ) return; + v = sqlite3GetVdbe(p); + assert( opcode==OP_OpenWrite || opcode==OP_OpenRead ); + sqlite3TableLock(p, iDb, pTab->tnum, (opcode==OP_OpenWrite), pTab->zName); + sqlite3VdbeAddOp(v, OP_Integer, iDb, 0); + VdbeComment((v, "# %s", pTab->zName)); + sqlite3VdbeAddOp(v, opcode, iCur, pTab->tnum); + sqlite3VdbeAddOp(v, OP_SetNumColumns, iCur, pTab->nCol); +} + + +/* +** Generate code for a DELETE FROM statement. +** +** DELETE FROM table_wxyz WHERE a<5 AND b NOT NULL; +** \________/ \________________/ +** pTabList pWhere +*/ +void sqlite3DeleteFrom( + Parse *pParse, /* The parser context */ + SrcList *pTabList, /* The table from which we should delete things */ + Expr *pWhere /* The WHERE clause. May be null */ +){ + Vdbe *v; /* The virtual database engine */ + Table *pTab; /* The table from which records will be deleted */ + const char *zDb; /* Name of database holding pTab */ + int end, addr = 0; /* A couple addresses of generated code */ + int i; /* Loop counter */ + WhereInfo *pWInfo; /* Information about the WHERE clause */ + Index *pIdx; /* For looping over indices of the table */ + int iCur; /* VDBE Cursor number for pTab */ + sqlite3 *db; /* Main database structure */ + AuthContext sContext; /* Authorization context */ + int oldIdx = -1; /* Cursor for the OLD table of AFTER triggers */ + NameContext sNC; /* Name context to resolve expressions in */ + int iDb; /* Database number */ + int memCnt = 0; /* Memory cell used for change counting */ + +#ifndef SQLITE_OMIT_TRIGGER + int isView; /* True if attempting to delete from a view */ + int triggers_exist = 0; /* True if any triggers exist */ +#endif + + sContext.pParse = 0; + db = pParse->db; + if( pParse->nErr || db->mallocFailed ){ + goto delete_from_cleanup; + } + assert( pTabList->nSrc==1 ); + + /* Locate the table which we want to delete. This table has to be + ** put in an SrcList structure because some of the subroutines we + ** will be calling are designed to work with multiple tables and expect + ** an SrcList* parameter instead of just a Table* parameter. + */ + pTab = sqlite3SrcListLookup(pParse, pTabList); + if( pTab==0 ) goto delete_from_cleanup; + + /* Figure out if we have any triggers and if the table being + ** deleted from is a view + */ +#ifndef SQLITE_OMIT_TRIGGER + triggers_exist = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0); + isView = pTab->pSelect!=0; +#else +# define triggers_exist 0 +# define isView 0 +#endif +#ifdef SQLITE_OMIT_VIEW +# undef isView +# define isView 0 +#endif + + if( sqlite3IsReadOnly(pParse, pTab, triggers_exist) ){ + goto delete_from_cleanup; + } + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + assert( iDbnDb ); + zDb = db->aDb[iDb].zName; + if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){ + goto delete_from_cleanup; + } + + /* If pTab is really a view, make sure it has been initialized. + */ + if( sqlite3ViewGetColumnNames(pParse, pTab) ){ + goto delete_from_cleanup; + } + + /* Allocate a cursor used to store the old.* data for a trigger. + */ + if( triggers_exist ){ + oldIdx = pParse->nTab++; + } + + /* Resolve the column names in the WHERE clause. + */ + assert( pTabList->nSrc==1 ); + iCur = pTabList->a[0].iCursor = pParse->nTab++; + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = pParse; + sNC.pSrcList = pTabList; + if( sqlite3ExprResolveNames(&sNC, pWhere) ){ + goto delete_from_cleanup; + } + + /* Start the view context + */ + if( isView ){ + sqlite3AuthContextPush(pParse, &sContext, pTab->zName); + } + + /* Begin generating code. + */ + v = sqlite3GetVdbe(pParse); + if( v==0 ){ + goto delete_from_cleanup; + } + if( pParse->nested==0 ) sqlite3VdbeCountChanges(v); + sqlite3BeginWriteOperation(pParse, triggers_exist, iDb); + + /* If we are trying to delete from a view, realize that view into + ** a ephemeral table. + */ + if( isView ){ + Select *pView = sqlite3SelectDup(db, pTab->pSelect); + sqlite3Select(pParse, pView, SRT_EphemTab, iCur, 0, 0, 0, 0); + sqlite3SelectDelete(pView); + } + + /* Initialize the counter of the number of rows deleted, if + ** we are counting rows. + */ + if( db->flags & SQLITE_CountRows ){ + memCnt = pParse->nMem++; + sqlite3VdbeAddOp(v, OP_MemInt, 0, memCnt); + } + + /* Special case: A DELETE without a WHERE clause deletes everything. + ** It is easier just to erase the whole table. Note, however, that + ** this means that the row change count will be incorrect. + */ + if( pWhere==0 && !triggers_exist && !IsVirtual(pTab) ){ + if( db->flags & SQLITE_CountRows ){ + /* If counting rows deleted, just count the total number of + ** entries in the table. */ + int addr2; + if( !isView ){ + sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenRead); + } + sqlite3VdbeAddOp(v, OP_Rewind, iCur, sqlite3VdbeCurrentAddr(v)+2); + addr2 = sqlite3VdbeAddOp(v, OP_MemIncr, 1, memCnt); + sqlite3VdbeAddOp(v, OP_Next, iCur, addr2); + sqlite3VdbeAddOp(v, OP_Close, iCur, 0); + } + if( !isView ){ + sqlite3VdbeAddOp(v, OP_Clear, pTab->tnum, iDb); + if( !pParse->nested ){ + sqlite3VdbeChangeP3(v, -1, pTab->zName, P3_STATIC); + } + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + assert( pIdx->pSchema==pTab->pSchema ); + sqlite3VdbeAddOp(v, OP_Clear, pIdx->tnum, iDb); + } + } + } + /* The usual case: There is a WHERE clause so we have to scan through + ** the table and pick which records to delete. + */ + else{ + /* Begin the database scan + */ + pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0); + if( pWInfo==0 ) goto delete_from_cleanup; + + /* Remember the rowid of every item to be deleted. + */ + sqlite3VdbeAddOp(v, IsVirtual(pTab) ? OP_VRowid : OP_Rowid, iCur, 0); + sqlite3VdbeAddOp(v, OP_FifoWrite, 0, 0); + if( db->flags & SQLITE_CountRows ){ + sqlite3VdbeAddOp(v, OP_MemIncr, 1, memCnt); + } + + /* End the database scan loop. + */ + sqlite3WhereEnd(pWInfo); + + /* Open the pseudo-table used to store OLD if there are triggers. + */ + if( triggers_exist ){ + sqlite3VdbeAddOp(v, OP_OpenPseudo, oldIdx, 0); + sqlite3VdbeAddOp(v, OP_SetNumColumns, oldIdx, pTab->nCol); + } + + /* Delete every item whose key was written to the list during the + ** database scan. We have to delete items after the scan is complete + ** because deleting an item can change the scan order. + */ + end = sqlite3VdbeMakeLabel(v); + + /* This is the beginning of the delete loop when there are + ** row triggers. + */ + if( triggers_exist ){ + int mem1 = pParse->nMem++; + addr = sqlite3VdbeAddOp(v, OP_FifoRead, 0, end); + sqlite3VdbeAddOp(v, OP_StackDepth, -1, 0); + sqlite3VdbeAddOp(v, OP_MemStore, mem1, 0); + if( !isView ){ + sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenRead); + } + sqlite3VdbeAddOp(v, OP_NotExists, iCur, addr); + sqlite3VdbeAddOp(v, OP_Rowid, iCur, 0); + sqlite3VdbeAddOp(v, OP_RowData, iCur, 0); + sqlite3VdbeAddOp(v, OP_Insert, oldIdx, 0); + if( !isView ){ + sqlite3VdbeAddOp(v, OP_Close, iCur, 0); + } + + (void)sqlite3CodeRowTrigger(pParse, TK_DELETE, 0, TRIGGER_BEFORE, pTab, + -1, oldIdx, (pParse->trigStack)?pParse->trigStack->orconf:OE_Default, + addr); + if( !isView ){ + sqlite3VdbeAddOp(v, OP_MemLoad, mem1, 0); + } + } + + if( !isView ){ + /* Open cursors for the table we are deleting from and all its + ** indices. If there are row triggers, this happens inside the + ** OP_FifoRead loop because the cursor have to all be closed + ** before the trigger fires. If there are no row triggers, the + ** cursors are opened only once on the outside the loop. + */ + sqlite3OpenTableAndIndices(pParse, pTab, iCur, OP_OpenWrite); + + /* This is the beginning of the delete loop when there are no + ** row triggers */ + if( !triggers_exist ){ + addr = sqlite3VdbeAddOp(v, OP_FifoRead, 0, end); + sqlite3VdbeAddOp(v, OP_StackDepth, -1, 0); + } + + /* Delete the row */ +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( IsVirtual(pTab) ){ + pParse->pVirtualLock = pTab; + sqlite3VdbeOp3(v, OP_VUpdate, 0, 1, (const char*)pTab->pVtab, P3_VTAB); + }else +#endif + { + sqlite3GenerateRowDelete(db, v, pTab, iCur, pParse->nested==0); + } + } + + /* If there are row triggers, close all cursors then invoke + ** the AFTER triggers + */ + if( triggers_exist ){ + if( !isView ){ + for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){ + sqlite3VdbeAddOp(v, OP_Close, iCur + i, pIdx->tnum); + } + sqlite3VdbeAddOp(v, OP_Close, iCur, 0); + } + (void)sqlite3CodeRowTrigger(pParse, TK_DELETE, 0, TRIGGER_AFTER, pTab, -1, + oldIdx, (pParse->trigStack)?pParse->trigStack->orconf:OE_Default, + addr); + } + + /* End of the delete loop */ + sqlite3VdbeAddOp(v, OP_Goto, 0, addr); + sqlite3VdbeResolveLabel(v, end); + + /* Close the cursors after the loop if there are no row triggers */ + if( !triggers_exist && !IsVirtual(pTab) ){ + for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){ + sqlite3VdbeAddOp(v, OP_Close, iCur + i, pIdx->tnum); + } + sqlite3VdbeAddOp(v, OP_Close, iCur, 0); + } + } + + /* + ** Return the number of rows that were deleted. If this routine is + ** generating code because of a call to sqlite3NestedParse(), do not + ** invoke the callback function. + */ + if( db->flags & SQLITE_CountRows && pParse->nested==0 && !pParse->trigStack ){ + sqlite3VdbeAddOp(v, OP_MemLoad, memCnt, 0); + sqlite3VdbeAddOp(v, OP_Callback, 1, 0); + sqlite3VdbeSetNumCols(v, 1); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows deleted", P3_STATIC); + } + +delete_from_cleanup: + sqlite3AuthContextPop(&sContext); + sqlite3SrcListDelete(pTabList); + sqlite3ExprDelete(pWhere); + return; +} + +/* +** This routine generates VDBE code that causes a single row of a +** single table to be deleted. +** +** The VDBE must be in a particular state when this routine is called. +** These are the requirements: +** +** 1. A read/write cursor pointing to pTab, the table containing the row +** to be deleted, must be opened as cursor number "base". +** +** 2. Read/write cursors for all indices of pTab must be open as +** cursor number base+i for the i-th index. +** +** 3. The record number of the row to be deleted must be on the top +** of the stack. +** +** This routine pops the top of the stack to remove the record number +** and then generates code to remove both the table record and all index +** entries that point to that record. +*/ +void sqlite3GenerateRowDelete( + sqlite3 *db, /* The database containing the index */ + Vdbe *v, /* Generate code into this VDBE */ + Table *pTab, /* Table containing the row to be deleted */ + int iCur, /* Cursor number for the table */ + int count /* Increment the row change counter */ +){ + int addr; + addr = sqlite3VdbeAddOp(v, OP_NotExists, iCur, 0); + sqlite3GenerateRowIndexDelete(v, pTab, iCur, 0); + sqlite3VdbeAddOp(v, OP_Delete, iCur, (count?OPFLAG_NCHANGE:0)); + if( count ){ + sqlite3VdbeChangeP3(v, -1, pTab->zName, P3_STATIC); + } + sqlite3VdbeJumpHere(v, addr); +} + +/* +** This routine generates VDBE code that causes the deletion of all +** index entries associated with a single row of a single table. +** +** The VDBE must be in a particular state when this routine is called. +** These are the requirements: +** +** 1. A read/write cursor pointing to pTab, the table containing the row +** to be deleted, must be opened as cursor number "iCur". +** +** 2. Read/write cursors for all indices of pTab must be open as +** cursor number iCur+i for the i-th index. +** +** 3. The "iCur" cursor must be pointing to the row that is to be +** deleted. +*/ +void sqlite3GenerateRowIndexDelete( + Vdbe *v, /* Generate code into this VDBE */ + Table *pTab, /* Table containing the row to be deleted */ + int iCur, /* Cursor number for the table */ + char *aIdxUsed /* Only delete if aIdxUsed!=0 && aIdxUsed[i]!=0 */ +){ + int i; + Index *pIdx; + + for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){ + if( aIdxUsed!=0 && aIdxUsed[i-1]==0 ) continue; + sqlite3GenerateIndexKey(v, pIdx, iCur); + sqlite3VdbeAddOp(v, OP_IdxDelete, iCur+i, 0); + } +} + +/* +** Generate code that will assemble an index key and put it on the top +** of the tack. The key with be for index pIdx which is an index on pTab. +** iCur is the index of a cursor open on the pTab table and pointing to +** the entry that needs indexing. +*/ +void sqlite3GenerateIndexKey( + Vdbe *v, /* Generate code into this VDBE */ + Index *pIdx, /* The index for which to generate a key */ + int iCur /* Cursor number for the pIdx->pTable table */ +){ + int j; + Table *pTab = pIdx->pTable; + + sqlite3VdbeAddOp(v, OP_Rowid, iCur, 0); + for(j=0; jnColumn; j++){ + int idx = pIdx->aiColumn[j]; + if( idx==pTab->iPKey ){ + sqlite3VdbeAddOp(v, OP_Dup, j, 0); + }else{ + sqlite3VdbeAddOp(v, OP_Column, iCur, idx); + sqlite3ColumnDefault(v, pTab, idx); + } + } + sqlite3VdbeAddOp(v, OP_MakeIdxRec, pIdx->nColumn, 0); + sqlite3IndexAffinityStr(v, pIdx); +} diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/expr.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/expr.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,2816 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains routines used for analyzing expressions and +** for generating VDBE code that evaluates expressions in SQLite. +** +** $Id: expr.cpp 1282 2008-11-13 09:31:33Z LarsPson $ +*/ +#include "sqliteInt.h" +#include + +/* +** Return the 'affinity' of the expression pExpr if any. +** +** If pExpr is a column, a reference to a column via an 'AS' alias, +** or a sub-select with a column as the return value, then the +** affinity of that column is returned. Otherwise, 0x00 is returned, +** indicating no affinity for the expression. +** +** i.e. the WHERE clause expresssions in the following statements all +** have an affinity: +** +** CREATE TABLE t1(a); +** SELECT * FROM t1 WHERE a; +** SELECT a AS b FROM t1 WHERE b; +** SELECT * FROM t1 WHERE (select a from t1); +*/ +char sqlite3ExprAffinity(Expr *pExpr){ + int op = pExpr->op; + if( op==TK_SELECT ){ + return sqlite3ExprAffinity(pExpr->pSelect->pEList->a[0].pExpr); + } +#ifndef SQLITE_OMIT_CAST + if( op==TK_CAST ){ + return sqlite3AffinityType(&pExpr->token); + } +#endif + return pExpr->affinity; +} + +/* +** Set the collating sequence for expression pExpr to be the collating +** sequence named by pToken. Return a pointer to the revised expression. +** The collating sequence is marked as "explicit" using the EP_ExpCollate +** flag. An explicit collating sequence will override implicit +** collating sequences. +*/ +Expr *sqlite3ExprSetColl(Parse *pParse, Expr *pExpr, Token *pName){ + char *zColl = 0; /* Dequoted name of collation sequence */ + CollSeq *pColl; + zColl = sqlite3NameFromToken(pParse->db, pName); + if( pExpr && zColl ){ + pColl = sqlite3LocateCollSeq(pParse, zColl, -1); + if( pColl ){ + pExpr->pColl = pColl; + pExpr->flags |= EP_ExpCollate; + } + } + sqlite3_free(zColl); + return pExpr; +} + +/* +** Return the default collation sequence for the expression pExpr. If +** there is no default collation type, return 0. +*/ +CollSeq *sqlite3ExprCollSeq(Parse *pParse, Expr *pExpr){ + CollSeq *pColl = 0; + if( pExpr ){ + int op; + pColl = pExpr->pColl; + op = pExpr->op; + if( (op==TK_CAST || op==TK_UPLUS) && !pColl ){ + return sqlite3ExprCollSeq(pParse, pExpr->pLeft); + } + } + if( sqlite3CheckCollSeq(pParse, pColl) ){ + pColl = 0; + } + return pColl; +} + +/* +** pExpr is an operand of a comparison operator. aff2 is the +** type affinity of the other operand. This routine returns the +** type affinity that should be used for the comparison operator. +*/ +char sqlite3CompareAffinity(Expr *pExpr, char aff2){ + char aff1 = sqlite3ExprAffinity(pExpr); + if( aff1 && aff2 ){ + /* Both sides of the comparison are columns. If one has numeric + ** affinity, use that. Otherwise use no affinity. + */ + if( sqlite3IsNumericAffinity(aff1) || sqlite3IsNumericAffinity(aff2) ){ + return SQLITE_AFF_NUMERIC; + }else{ + return SQLITE_AFF_NONE; + } + }else if( !aff1 && !aff2 ){ + /* Neither side of the comparison is a column. Compare the + ** results directly. + */ + return SQLITE_AFF_NONE; + }else{ + /* One side is a column, the other is not. Use the columns affinity. */ + assert( aff1==0 || aff2==0 ); + return (aff1 + aff2); + } +} + +/* +** pExpr is a comparison operator. Return the type affinity that should +** be applied to both operands prior to doing the comparison. +*/ +static char comparisonAffinity(Expr *pExpr){ + char aff; + assert( pExpr->op==TK_EQ || pExpr->op==TK_IN || pExpr->op==TK_LT || + pExpr->op==TK_GT || pExpr->op==TK_GE || pExpr->op==TK_LE || + pExpr->op==TK_NE ); + assert( pExpr->pLeft ); + aff = sqlite3ExprAffinity(pExpr->pLeft); + if( pExpr->pRight ){ + aff = sqlite3CompareAffinity(pExpr->pRight, aff); + } + else if( pExpr->pSelect ){ + aff = sqlite3CompareAffinity(pExpr->pSelect->pEList->a[0].pExpr, aff); + } + else if( !aff ){ + aff = SQLITE_AFF_NONE; + } + return aff; +} + +/* +** pExpr is a comparison expression, eg. '=', '<', IN(...) etc. +** idx_affinity is the affinity of an indexed column. Return true +** if the index with affinity idx_affinity may be used to implement +** the comparison in pExpr. +*/ +int sqlite3IndexAffinityOk(Expr *pExpr, char idx_affinity){ + char aff = comparisonAffinity(pExpr); + switch( aff ){ + case SQLITE_AFF_NONE: + return 1; + case SQLITE_AFF_TEXT: + return idx_affinity==SQLITE_AFF_TEXT; + default: + return sqlite3IsNumericAffinity(idx_affinity); + } +} + +/* +** Return the P1 value that should be used for a binary comparison +** opcode (OP_Eq, OP_Ge etc.) used to compare pExpr1 and pExpr2. +** If jumpIfNull is true, then set the low byte of the returned +** P1 value to tell the opcode to jump if either expression +** evaluates to NULL. +*/ +static int binaryCompareP1(Expr *pExpr1, Expr *pExpr2, int jumpIfNull){ + char aff = sqlite3ExprAffinity(pExpr2); + return ((int)sqlite3CompareAffinity(pExpr1, aff))+(jumpIfNull?0x100:0); +} + +/* +** Return a pointer to the collation sequence that should be used by +** a binary comparison operator comparing pLeft and pRight. +** +** If the left hand expression has a collating sequence type, then it is +** used. Otherwise the collation sequence for the right hand expression +** is used, or the default (BINARY) if neither expression has a collating +** type. +** +** Argument pRight (but not pLeft) may be a null pointer. In this case, +** it is not considered. +*/ +CollSeq *sqlite3BinaryCompareCollSeq( + Parse *pParse, + Expr *pLeft, + Expr *pRight +){ + CollSeq *pColl; + assert( pLeft ); + if( pLeft->flags & EP_ExpCollate ){ + assert( pLeft->pColl ); + pColl = pLeft->pColl; + }else if( pRight && pRight->flags & EP_ExpCollate ){ + assert( pRight->pColl ); + pColl = pRight->pColl; + }else{ + pColl = sqlite3ExprCollSeq(pParse, pLeft); + if( !pColl ){ + pColl = sqlite3ExprCollSeq(pParse, pRight); + } + } + return pColl; +} + +/* +** Generate code for a comparison operator. +*/ +static int codeCompare( + Parse *pParse, /* The parsing (and code generating) context */ + Expr *pLeft, /* The left operand */ + Expr *pRight, /* The right operand */ + int opcode, /* The comparison opcode */ + int dest, /* Jump here if true. */ + int jumpIfNull /* If true, jump if either operand is NULL */ +){ + int p1 = binaryCompareP1(pLeft, pRight, jumpIfNull); + CollSeq *p3 = sqlite3BinaryCompareCollSeq(pParse, pLeft, pRight); + return sqlite3VdbeOp3(pParse->pVdbe, opcode, p1, dest, (const char*)p3, P3_COLLSEQ); +} + +/* +** Construct a new expression node and return a pointer to it. Memory +** for this node is obtained from sqlite3_malloc(). The calling function +** is responsible for making sure the node eventually gets freed. +*/ +Expr *sqlite3Expr( + sqlite3 *db, /* Handle for sqlite3DbMallocZero() (may be null) */ + int op, /* Expression opcode */ + Expr *pLeft, /* Left operand */ + Expr *pRight, /* Right operand */ + const Token *pToken /* Argument token */ +){ + Expr *pNew; + pNew = (Expr*)sqlite3DbMallocZero(db, sizeof(Expr)); + if( pNew==0 ){ + /* When malloc fails, delete pLeft and pRight. Expressions passed to + ** this function must always be allocated with sqlite3Expr() for this + ** reason. + */ + sqlite3ExprDelete(pLeft); + sqlite3ExprDelete(pRight); + return 0; + } + pNew->op = op; + pNew->pLeft = pLeft; + pNew->pRight = pRight; + pNew->iAgg = -1; + if( pToken ){ + assert( pToken->dyn==0 ); + pNew->span = pNew->token = *pToken; + }else if( pLeft ){ + if( pRight ){ + sqlite3ExprSpan(pNew, &pLeft->span, &pRight->span); + if( pRight->flags & EP_ExpCollate ){ + pNew->flags |= EP_ExpCollate; + pNew->pColl = pRight->pColl; + } + } + if( pLeft->flags & EP_ExpCollate ){ + pNew->flags |= EP_ExpCollate; + pNew->pColl = pLeft->pColl; + } + } + + sqlite3ExprSetHeight(pNew); + return pNew; +} + +/* +** Works like sqlite3Expr() except that it takes an extra Parse* +** argument and notifies the associated connection object if malloc fails. +*/ +Expr *sqlite3PExpr( + Parse *pParse, /* Parsing context */ + int op, /* Expression opcode */ + Expr *pLeft, /* Left operand */ + Expr *pRight, /* Right operand */ + const Token *pToken /* Argument token */ +){ + return sqlite3Expr(pParse->db, op, pLeft, pRight, pToken); +} + +/* +** When doing a nested parse, you can include terms in an expression +** that look like this: #0 #1 #2 ... These terms refer to elements +** on the stack. "#0" means the top of the stack. +** "#1" means the next down on the stack. And so forth. +** +** This routine is called by the parser to deal with on of those terms. +** It immediately generates code to store the value in a memory location. +** The returns an expression that will code to extract the value from +** that memory location as needed. +*/ +Expr *sqlite3RegisterExpr(Parse *pParse, Token *pToken){ + Vdbe *v = pParse->pVdbe; + Expr *p; + int depth; + if( pParse->nested==0 ){ + sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", pToken); + return sqlite3PExpr(pParse, TK_NULL, 0, 0, 0); + } + if( v==0 ) return 0; + p = sqlite3PExpr(pParse, TK_REGISTER, 0, 0, pToken); + if( p==0 ){ + return 0; /* Malloc failed */ + } + depth = atoi((char*)&pToken->z[1]); + p->iTable = pParse->nMem++; + sqlite3VdbeAddOp(v, OP_Dup, depth, 0); + sqlite3VdbeAddOp(v, OP_MemStore, p->iTable, 1); + return p; +} + +/* +** Join two expressions using an AND operator. If either expression is +** NULL, then just return the other expression. +*/ +Expr *sqlite3ExprAnd(sqlite3 *db, Expr *pLeft, Expr *pRight){ + if( pLeft==0 ){ + return pRight; + }else if( pRight==0 ){ + return pLeft; + }else{ + return sqlite3Expr(db, TK_AND, pLeft, pRight, 0); + } +} + +/* +** Set the Expr.span field of the given expression to span all +** text between the two given tokens. +*/ +void sqlite3ExprSpan(Expr *pExpr, Token *pLeft, Token *pRight){ + assert( pRight!=0 ); + assert( pLeft!=0 ); + if( pExpr && pRight->z && pLeft->z ){ + assert( pLeft->dyn==0 || pLeft->z[pLeft->n]==0 ); + if( pLeft->dyn==0 && pRight->dyn==0 ){ + pExpr->span.z = pLeft->z; + pExpr->span.n = pRight->n + (pRight->z - pLeft->z); + }else{ + pExpr->span.z = 0; + } + } +} + +/* +** Construct a new expression node for a function with multiple +** arguments. +*/ +Expr *sqlite3ExprFunction(Parse *pParse, ExprList *pList, Token *pToken){ + Expr *pNew; + assert( pToken ); + pNew = (Expr*)sqlite3DbMallocZero(pParse->db, sizeof(Expr) ); + if( pNew==0 ){ + sqlite3ExprListDelete(pList); /* Avoid leaking memory when malloc fails */ + return 0; + } + pNew->op = TK_FUNCTION; + pNew->pList = pList; + assert( pToken->dyn==0 ); + pNew->token = *pToken; + pNew->span = pNew->token; + + sqlite3ExprSetHeight(pNew); + return pNew; +} + +/* +** Assign a variable number to an expression that encodes a wildcard +** in the original SQL statement. +** +** Wildcards consisting of a single "?" are assigned the next sequential +** variable number. +** +** Wildcards of the form "?nnn" are assigned the number "nnn". We make +** sure "nnn" is not too be to avoid a denial of service attack when +** the SQL statement comes from an external source. +** +** Wildcards of the form ":aaa" or "$aaa" are assigned the same number +** as the previous instance of the same wildcard. Or if this is the first +** instance of the wildcard, the next sequenial variable number is +** assigned. +*/ +void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr){ + Token *pToken; + sqlite3 *db = pParse->db; + + if( pExpr==0 ) return; + pToken = &pExpr->token; + assert( pToken->n>=1 ); + assert( pToken->z!=0 ); + assert( pToken->z[0]!=0 ); + if( pToken->n==1 ){ + /* Wildcard of the form "?". Assign the next variable number */ + pExpr->iTable = ++pParse->nVar; + }else if( pToken->z[0]=='?' ){ + /* Wildcard of the form "?nnn". Convert "nnn" to an integer and + ** use it as the variable number */ + int i; + pExpr->iTable = i = atoi((char*)&pToken->z[1]); + if( i<1 || i>SQLITE_MAX_VARIABLE_NUMBER ){ + sqlite3ErrorMsg(pParse, "variable number must be between ?1 and ?%d", + SQLITE_MAX_VARIABLE_NUMBER); + } + if( i>pParse->nVar ){ + pParse->nVar = i; + } + }else{ + /* Wildcards of the form ":aaa" or "$aaa". Reuse the same variable + ** number as the prior appearance of the same name, or if the name + ** has never appeared before, reuse the same variable number + */ + int i, n; + n = pToken->n; + for(i=0; inVarExpr; i++){ + Expr *pE; + if( (pE = pParse->apVarExpr[i])!=0 + && pE->token.n==n + && memcmp(pE->token.z, pToken->z, n)==0 ){ + pExpr->iTable = pE->iTable; + break; + } + } + if( i>=pParse->nVarExpr ){ + pExpr->iTable = ++pParse->nVar; + if( pParse->nVarExpr>=pParse->nVarExprAlloc-1 ){ + pParse->nVarExprAlloc += pParse->nVarExprAlloc + 10; + pParse->apVarExpr = + (Expr**)sqlite3DbReallocOrFree( + db, + pParse->apVarExpr, + pParse->nVarExprAlloc*sizeof(pParse->apVarExpr[0]) + ); + } + if( !db->mallocFailed ){ + assert( pParse->apVarExpr!=0 ); + pParse->apVarExpr[pParse->nVarExpr++] = pExpr; + } + } + } + if( !pParse->nErr && pParse->nVar>SQLITE_MAX_VARIABLE_NUMBER ){ + sqlite3ErrorMsg(pParse, "too many SQL variables"); + } +} + +/* +** Recursively delete an expression tree. +*/ +void sqlite3ExprDelete(Expr *p){ + if( p==0 ) return; + if( p->span.dyn ) sqlite3_free((char*)p->span.z); + if( p->token.dyn ) sqlite3_free((char*)p->token.z); + sqlite3ExprDelete(p->pLeft); + sqlite3ExprDelete(p->pRight); + sqlite3ExprListDelete(p->pList); + sqlite3SelectDelete(p->pSelect); + sqlite3_free(p); +} + +/* +** The Expr.token field might be a string literal that is quoted. +** If so, remove the quotation marks. +*/ +void sqlite3DequoteExpr(sqlite3 *db, Expr *p){ + if( ExprHasAnyProperty(p, EP_Dequoted) ){ + return; + } + ExprSetProperty(p, EP_Dequoted); + if( p->token.dyn==0 ){ + sqlite3TokenCopy(db, &p->token, &p->token); + } + sqlite3Dequote((char*)p->token.z); +} + + +/* +** The following group of routines make deep copies of expressions, +** expression lists, ID lists, and select statements. The copies can +** be deleted (by being passed to their respective ...Delete() routines) +** without effecting the originals. +** +** The expression list, ID, and source lists return by sqlite3ExprListDup(), +** sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded +** by subsequent calls to sqlite*ListAppend() routines. +** +** Any tables that the SrcList might point to are not duplicated. +*/ +Expr *sqlite3ExprDup(sqlite3 *db, Expr *p){ + Expr *pNew; + if( p==0 ) return 0; + pNew = (Expr*)sqlite3DbMallocRaw(db, sizeof(*p) ); + if( pNew==0 ) return 0; + memcpy(pNew, p, sizeof(*pNew)); + if( p->token.z!=0 ){ + pNew->token.z = (u8*)sqlite3DbStrNDup(db, (char*)p->token.z, p->token.n); + pNew->token.dyn = 1; + }else{ + assert( pNew->token.z==0 ); + } + pNew->span.z = 0; + pNew->pLeft = sqlite3ExprDup(db, p->pLeft); + pNew->pRight = sqlite3ExprDup(db, p->pRight); + pNew->pList = sqlite3ExprListDup(db, p->pList); + pNew->pSelect = sqlite3SelectDup(db, p->pSelect); + return pNew; +} +void sqlite3TokenCopy(sqlite3 *db, Token *pTo, Token *pFrom){ + if( pTo->dyn ) sqlite3_free((char*)pTo->z); + if( pFrom->z ){ + pTo->n = pFrom->n; + pTo->z = (u8*)sqlite3DbStrNDup(db, (char*)pFrom->z, pFrom->n); + pTo->dyn = 1; + }else{ + pTo->z = 0; + } +} +ExprList *sqlite3ExprListDup(sqlite3 *db, ExprList *p){ + ExprList *pNew; + ExprList::ExprList_item *pItem, *pOldItem; + int i; + if( p==0 ) return 0; + pNew = (ExprList*)sqlite3DbMallocRaw(db, sizeof(*pNew) ); + if( pNew==0 ) return 0; + pNew->iECursor = 0; + pNew->nExpr = pNew->nAlloc = p->nExpr; + pNew->a = pItem = (ExprList::ExprList_item*)sqlite3DbMallocRaw(db, p->nExpr*sizeof(p->a[0]) ); + if( pItem==0 ){ + sqlite3_free(pNew); + return 0; + } + pOldItem = p->a; + for(i=0; inExpr; i++, pItem++, pOldItem++){ + Expr *pNewExpr, *pOldExpr; + pItem->pExpr = pNewExpr = sqlite3ExprDup(db, pOldExpr = pOldItem->pExpr); + if( pOldExpr->span.z!=0 && pNewExpr ){ + /* Always make a copy of the span for top-level expressions in the + ** expression list. The logic in SELECT processing that determines + ** the names of columns in the result set needs this information */ + sqlite3TokenCopy(db, &pNewExpr->span, &pOldExpr->span); + } + assert( pNewExpr==0 || pNewExpr->span.z!=0 + || pOldExpr->span.z==0 + || db->mallocFailed ); + pItem->zName = sqlite3DbStrDup(db, pOldItem->zName); + pItem->sortOrder = pOldItem->sortOrder; + pItem->isAgg = pOldItem->isAgg; + pItem->done = 0; + } + return pNew; +} + +/* +** If cursors, triggers, views and subqueries are all omitted from +** the build, then none of the following routines, except for +** sqlite3SelectDup(), can be called. sqlite3SelectDup() is sometimes +** called with a NULL argument. +*/ +#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) \ + || !defined(SQLITE_OMIT_SUBQUERY) +SrcList *sqlite3SrcListDup(sqlite3 *db, SrcList *p){ + SrcList *pNew; + int i; + int nByte; + if( p==0 ) return 0; + nByte = sizeof(*p) + (p->nSrc>0 ? sizeof(p->a[0]) * (p->nSrc-1) : 0); + pNew = (SrcList*)sqlite3DbMallocRaw(db, nByte ); + if( pNew==0 ) return 0; + pNew->nSrc = pNew->nAlloc = p->nSrc; + for(i=0; inSrc; i++){ + SrcList::SrcList_item *pNewItem = &pNew->a[i]; + SrcList::SrcList_item *pOldItem = &p->a[i]; + Table *pTab; + pNewItem->zDatabase = sqlite3DbStrDup(db, pOldItem->zDatabase); + pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName); + pNewItem->zAlias = sqlite3DbStrDup(db, pOldItem->zAlias); + pNewItem->jointype = pOldItem->jointype; + pNewItem->iCursor = pOldItem->iCursor; + pNewItem->isPopulated = pOldItem->isPopulated; + pTab = pNewItem->pTab = pOldItem->pTab; + if( pTab ){ + pTab->nRef++; + } + pNewItem->pSelect = sqlite3SelectDup(db, pOldItem->pSelect); + pNewItem->pOn = sqlite3ExprDup(db, pOldItem->pOn); + pNewItem->pUsing = sqlite3IdListDup(db, pOldItem->pUsing); + pNewItem->colUsed = pOldItem->colUsed; + } + return pNew; +} +IdList *sqlite3IdListDup(sqlite3 *db, IdList *p){ + IdList *pNew; + int i; + if( p==0 ) return 0; + pNew = (IdList*)sqlite3DbMallocRaw(db, sizeof(*pNew) ); + if( pNew==0 ) return 0; + pNew->nId = pNew->nAlloc = p->nId; + pNew->a = (IdList::IdList_item*)sqlite3DbMallocRaw(db, p->nId*sizeof(p->a[0]) ); + if( pNew->a==0 ){ + sqlite3_free(pNew); + return 0; + } + for(i=0; inId; i++){ + IdList::IdList_item *pNewItem = &pNew->a[i]; + IdList::IdList_item *pOldItem = &p->a[i]; + pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName); + pNewItem->idx = pOldItem->idx; + } + return pNew; +} +Select *sqlite3SelectDup(sqlite3 *db, Select *p){ + Select *pNew; + if( p==0 ) return 0; + pNew = (Select*)sqlite3DbMallocRaw(db, sizeof(*p) ); + if( pNew==0 ) return 0; + pNew->isDistinct = p->isDistinct; + pNew->pEList = sqlite3ExprListDup(db, p->pEList); + pNew->pSrc = sqlite3SrcListDup(db, p->pSrc); + pNew->pWhere = sqlite3ExprDup(db, p->pWhere); + pNew->pGroupBy = sqlite3ExprListDup(db, p->pGroupBy); + pNew->pHaving = sqlite3ExprDup(db, p->pHaving); + pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy); + pNew->op = p->op; + pNew->pPrior = sqlite3SelectDup(db, p->pPrior); + pNew->pLimit = sqlite3ExprDup(db, p->pLimit); + pNew->pOffset = sqlite3ExprDup(db, p->pOffset); + pNew->iLimit = -1; + pNew->iOffset = -1; + pNew->isResolved = p->isResolved; + pNew->isAgg = p->isAgg; + pNew->usesEphm = 0; + pNew->disallowOrderBy = 0; + pNew->pRightmost = 0; + pNew->addrOpenEphm[0] = -1; + pNew->addrOpenEphm[1] = -1; + pNew->addrOpenEphm[2] = -1; + return pNew; +} +#else +Select *sqlite3SelectDup(sqlite3 *db, Select *p){ + assert( p==0 ); + return 0; +} +#endif + + +/* +** Add a new element to the end of an expression list. If pList is +** initially NULL, then create a new expression list. +*/ +ExprList *sqlite3ExprListAppend( + Parse *pParse, /* Parsing context */ + ExprList *pList, /* List to which to append. Might be NULL */ + Expr *pExpr, /* Expression to be appended */ + Token *pName /* AS keyword for the expression */ +){ + sqlite3 *db = pParse->db; + if( pList==0 ){ + pList = (ExprList*)sqlite3DbMallocZero(db, sizeof(ExprList) ); + if( pList==0 ){ + goto no_mem; + } + assert( pList->nAlloc==0 ); + } + if( pList->nAlloc<=pList->nExpr ){ + ExprList::ExprList_item *a; + int n = pList->nAlloc*2 + 4; + a = (ExprList::ExprList_item*)sqlite3DbRealloc(db, pList->a, n*sizeof(pList->a[0])); + if( a==0 ){ + goto no_mem; + } + pList->a = a; + pList->nAlloc = n; + } + assert( pList->a!=0 ); + if( pExpr || pName ){ + ExprList::ExprList_item *pItem = &pList->a[pList->nExpr++]; + memset(pItem, 0, sizeof(*pItem)); + pItem->zName = sqlite3NameFromToken(db, pName); + pItem->pExpr = pExpr; + } + return pList; + +no_mem: + /* Avoid leaking memory if malloc has failed. */ + sqlite3ExprDelete(pExpr); + sqlite3ExprListDelete(pList); + return 0; +} + +/* +** If the expression list pEList contains more than iLimit elements, +** leave an error message in pParse. +*/ +void sqlite3ExprListCheckLength( + Parse *pParse, + ExprList *pEList, + int iLimit, + const char *zObject +){ + if( pEList && pEList->nExpr>iLimit ){ + sqlite3ErrorMsg(pParse, "too many columns in %s", zObject); + } +} + + +#if defined(SQLITE_TEST) || SQLITE_MAX_EXPR_DEPTH>0 +/* The following three functions, heightOfExpr(), heightOfExprList() +** and heightOfSelect(), are used to determine the maximum height +** of any expression tree referenced by the structure passed as the +** first argument. +** +** If this maximum height is greater than the current value pointed +** to by pnHeight, the second parameter, then set *pnHeight to that +** value. +*/ +static void heightOfExpr(Expr *p, int *pnHeight){ + if( p ){ + if( p->nHeight>*pnHeight ){ + *pnHeight = p->nHeight; + } + } +} +static void heightOfExprList(ExprList *p, int *pnHeight){ + if( p ){ + int i; + for(i=0; inExpr; i++){ + heightOfExpr(p->a[i].pExpr, pnHeight); + } + } +} +static void heightOfSelect(Select *p, int *pnHeight){ + if( p ){ + heightOfExpr(p->pWhere, pnHeight); + heightOfExpr(p->pHaving, pnHeight); + heightOfExpr(p->pLimit, pnHeight); + heightOfExpr(p->pOffset, pnHeight); + heightOfExprList(p->pEList, pnHeight); + heightOfExprList(p->pGroupBy, pnHeight); + heightOfExprList(p->pOrderBy, pnHeight); + heightOfSelect(p->pPrior, pnHeight); + } +} + +/* +** Set the Expr.nHeight variable in the structure passed as an +** argument. An expression with no children, Expr.pList or +** Expr.pSelect member has a height of 1. Any other expression +** has a height equal to the maximum height of any other +** referenced Expr plus one. +*/ +void sqlite3ExprSetHeight(Expr *p){ + int nHeight = 0; + heightOfExpr(p->pLeft, &nHeight); + heightOfExpr(p->pRight, &nHeight); + heightOfExprList(p->pList, &nHeight); + heightOfSelect(p->pSelect, &nHeight); + p->nHeight = nHeight + 1; +} + +/* +** Return the maximum height of any expression tree referenced +** by the select statement passed as an argument. +*/ +int sqlite3SelectExprHeight(Select *p){ + int nHeight = 0; + heightOfSelect(p, &nHeight); + return nHeight; +} +#endif + +/* +** Delete an entire expression list. +*/ +void sqlite3ExprListDelete(ExprList *pList){ + int i; + ExprList::ExprList_item *pItem; + if( pList==0 ) return; + assert( pList->a!=0 || (pList->nExpr==0 && pList->nAlloc==0) ); + assert( pList->nExpr<=pList->nAlloc ); + for(pItem=pList->a, i=0; inExpr; i++, pItem++){ + sqlite3ExprDelete(pItem->pExpr); + sqlite3_free(pItem->zName); + } + sqlite3_free(pList->a); + sqlite3_free(pList); +} + +/* +** Walk an expression tree. Call xFunc for each node visited. +** +** The return value from xFunc determines whether the tree walk continues. +** 0 means continue walking the tree. 1 means do not walk children +** of the current node but continue with siblings. 2 means abandon +** the tree walk completely. +** +** The return value from this routine is 1 to abandon the tree walk +** and 0 to continue. +** +** NOTICE: This routine does *not* descend into subqueries. +*/ +static int walkExprList(ExprList *, int (*)(void *, Expr*), void *); +static int walkExprTree(Expr *pExpr, int (*xFunc)(void*,Expr*), void *pArg){ + int rc; + if( pExpr==0 ) return 0; + rc = (*xFunc)(pArg, pExpr); + if( rc==0 ){ + if( walkExprTree(pExpr->pLeft, xFunc, pArg) ) return 1; + if( walkExprTree(pExpr->pRight, xFunc, pArg) ) return 1; + if( walkExprList(pExpr->pList, xFunc, pArg) ) return 1; + } + return rc>1; +} + +/* +** Call walkExprTree() for every expression in list p. +*/ +static int walkExprList(ExprList *p, int (*xFunc)(void *, Expr*), void *pArg){ + int i; + ExprList::ExprList_item *pItem; + if( !p ) return 0; + for(i=p->nExpr, pItem=p->a; i>0; i--, pItem++){ + if( walkExprTree(pItem->pExpr, xFunc, pArg) ) return 1; + } + return 0; +} + +/* +** Call walkExprTree() for every expression in Select p, not including +** expressions that are part of sub-selects in any FROM clause or the LIMIT +** or OFFSET expressions.. +*/ +static int walkSelectExpr(Select *p, int (*xFunc)(void *, Expr*), void *pArg){ + walkExprList(p->pEList, xFunc, pArg); + walkExprTree(p->pWhere, xFunc, pArg); + walkExprList(p->pGroupBy, xFunc, pArg); + walkExprTree(p->pHaving, xFunc, pArg); + walkExprList(p->pOrderBy, xFunc, pArg); + if( p->pPrior ){ + walkSelectExpr(p->pPrior, xFunc, pArg); + } + return 0; +} + + +/* +** This routine is designed as an xFunc for walkExprTree(). +** +** pArg is really a pointer to an integer. If we can tell by looking +** at pExpr that the expression that contains pExpr is not a constant +** expression, then set *pArg to 0 and return 2 to abandon the tree walk. +** If pExpr does does not disqualify the expression from being a constant +** then do nothing. +** +** After walking the whole tree, if no nodes are found that disqualify +** the expression as constant, then we assume the whole expression +** is constant. See sqlite3ExprIsConstant() for additional information. +*/ +static int exprNodeIsConstant(void *pArg, Expr *pExpr){ + int *pN = (int*)pArg; + + /* If *pArg is 3 then any term of the expression that comes from + ** the ON or USING clauses of a join disqualifies the expression + ** from being considered constant. */ + if( (*pN)==3 && ExprHasAnyProperty(pExpr, EP_FromJoin) ){ + *pN = 0; + return 2; + } + + switch( pExpr->op ){ + /* Consider functions to be constant if all their arguments are constant + ** and *pArg==2 */ + case TK_FUNCTION: + if( (*pN)==2 ) return 0; + /* Fall through */ + case TK_ID: + case TK_COLUMN: + case TK_DOT: + case TK_AGG_FUNCTION: + case TK_AGG_COLUMN: +#ifndef SQLITE_OMIT_SUBQUERY + case TK_SELECT: + case TK_EXISTS: +#endif + *pN = 0; + return 2; + case TK_IN: + if( pExpr->pSelect ){ + *pN = 0; + return 2; + } + default: + return 0; + } +} + +/* +** Walk an expression tree. Return 1 if the expression is constant +** and 0 if it involves variables or function calls. +** +** For the purposes of this function, a double-quoted string (ex: "abc") +** is considered a variable but a single-quoted string (ex: 'abc') is +** a constant. +*/ +int sqlite3ExprIsConstant(Expr *p){ + int isConst = 1; + walkExprTree(p, exprNodeIsConstant, &isConst); + return isConst; +} + +/* +** Walk an expression tree. Return 1 if the expression is constant +** that does no originate from the ON or USING clauses of a join. +** Return 0 if it involves variables or function calls or terms from +** an ON or USING clause. +*/ +int sqlite3ExprIsConstantNotJoin(Expr *p){ + int isConst = 3; + walkExprTree(p, exprNodeIsConstant, &isConst); + return isConst!=0; +} + +/* +** Walk an expression tree. Return 1 if the expression is constant +** or a function call with constant arguments. Return and 0 if there +** are any variables. +** +** For the purposes of this function, a double-quoted string (ex: "abc") +** is considered a variable but a single-quoted string (ex: 'abc') is +** a constant. +*/ +int sqlite3ExprIsConstantOrFunction(Expr *p){ + int isConst = 2; + walkExprTree(p, exprNodeIsConstant, &isConst); + return isConst!=0; +} + +/* +** If the expression p codes a constant integer that is small enough +** to fit in a 32-bit integer, return 1 and put the value of the integer +** in *pValue. If the expression is not an integer or if it is too big +** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged. +*/ +int sqlite3ExprIsInteger(Expr *p, int *pValue){ + switch( p->op ){ + case TK_INTEGER: { + if( sqlite3GetInt32((char*)p->token.z, pValue) ){ + return 1; + } + break; + } + case TK_UPLUS: { + return sqlite3ExprIsInteger(p->pLeft, pValue); + } + case TK_UMINUS: { + int v; + if( sqlite3ExprIsInteger(p->pLeft, &v) ){ + *pValue = -v; + return 1; + } + break; + } + default: break; + } + return 0; +} + +/* +** Return TRUE if the given string is a row-id column name. +*/ +int sqlite3IsRowid(const char *z){ + if( sqlite3StrICmp(z, "_ROWID_")==0 ) return 1; + if( sqlite3StrICmp(z, "ROWID")==0 ) return 1; + if( sqlite3StrICmp(z, "OID")==0 ) return 1; + return 0; +} + +/* +** Given the name of a column of the form X.Y.Z or Y.Z or just Z, look up +** that name in the set of source tables in pSrcList and make the pExpr +** expression node refer back to that source column. The following changes +** are made to pExpr: +** +** pExpr->iDb Set the index in db->aDb[] of the database holding +** the table. +** pExpr->iTable Set to the cursor number for the table obtained +** from pSrcList. +** pExpr->iColumn Set to the column number within the table. +** pExpr->op Set to TK_COLUMN. +** pExpr->pLeft Any expression this points to is deleted +** pExpr->pRight Any expression this points to is deleted. +** +** The pDbToken is the name of the database (the "X"). This value may be +** NULL meaning that name is of the form Y.Z or Z. Any available database +** can be used. The pTableToken is the name of the table (the "Y"). This +** value can be NULL if pDbToken is also NULL. If pTableToken is NULL it +** means that the form of the name is Z and that columns from any table +** can be used. +** +** If the name cannot be resolved unambiguously, leave an error message +** in pParse and return non-zero. Return zero on success. +*/ +static int lookupName( + Parse *pParse, /* The parsing context */ + Token *pDbToken, /* Name of the database containing table, or NULL */ + Token *pTableToken, /* Name of table containing column, or NULL */ + Token *pColumnToken, /* Name of the column. */ + NameContext *pNC, /* The name context used to resolve the name */ + Expr *pExpr /* Make this EXPR node point to the selected column */ +){ + char *zDb = 0; /* Name of the database. The "X" in X.Y.Z */ + char *zTab = 0; /* Name of the table. The "Y" in X.Y.Z or Y.Z */ + char *zCol = 0; /* Name of the column. The "Z" */ + int i, j; /* Loop counters */ + int cnt = 0; /* Number of matching column names */ + int cntTab = 0; /* Number of matching table names */ + sqlite3 *db = pParse->db; /* The database */ + SrcList::SrcList_item *pItem; /* Use for looping over pSrcList items */ + SrcList::SrcList_item *pMatch = 0; /* The matching pSrcList item */ + NameContext *pTopNC = pNC; /* First namecontext in the list */ + Schema *pSchema = 0; /* Schema of the expression */ + + assert( pColumnToken && pColumnToken->z ); /* The Z in X.Y.Z cannot be NULL */ + zDb = sqlite3NameFromToken(db, pDbToken); + zTab = sqlite3NameFromToken(db, pTableToken); + zCol = sqlite3NameFromToken(db, pColumnToken); + if( db->mallocFailed ){ + goto lookupname_end; + } + + pExpr->iTable = -1; + while( pNC && cnt==0 ){ + ExprList *pEList; + SrcList *pSrcList = pNC->pSrcList; + + if( pSrcList ){ + for(i=0, pItem=pSrcList->a; inSrc; i++, pItem++){ + Table *pTab; + int iDb; + Column *pCol; + + pTab = pItem->pTab; + assert( pTab!=0 ); + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + assert( pTab->nCol>0 ); + if( zTab ){ + if( pItem->zAlias ){ + char *zTabName = pItem->zAlias; + if( sqlite3StrICmp(zTabName, zTab)!=0 ) continue; + }else{ + char *zTabName = pTab->zName; + if( zTabName==0 || sqlite3StrICmp(zTabName, zTab)!=0 ) continue; + if( zDb!=0 && sqlite3StrICmp(db->aDb[iDb].zName, zDb)!=0 ){ + continue; + } + } + } + if( 0==(cntTab++) ){ + pExpr->iTable = pItem->iCursor; + pSchema = pTab->pSchema; + pMatch = pItem; + } + for(j=0, pCol=pTab->aCol; jnCol; j++, pCol++){ + if( sqlite3StrICmp(pCol->zName, zCol)==0 ){ + const char *zColl = pTab->aCol[j].zColl; + IdList *pUsing; + cnt++; + pExpr->iTable = pItem->iCursor; + pMatch = pItem; + pSchema = pTab->pSchema; + /* Substitute the rowid (column -1) for the INTEGER PRIMARY KEY */ + pExpr->iColumn = j==pTab->iPKey ? -1 : j; + pExpr->affinity = pTab->aCol[j].affinity; + if( (pExpr->flags & EP_ExpCollate)==0 ){ + pExpr->pColl = sqlite3FindCollSeq(db, ENC(db), zColl,-1, 0); + } + if( inSrc-1 ){ + if( pItem[1].jointype & JT_NATURAL ){ + /* If this match occurred in the left table of a natural join, + ** then skip the right table to avoid a duplicate match */ + pItem++; + i++; + }else if( (pUsing = pItem[1].pUsing)!=0 ){ + /* If this match occurs on a column that is in the USING clause + ** of a join, skip the search of the right table of the join + ** to avoid a duplicate match there. */ + int k; + for(k=0; knId; k++){ + if( sqlite3StrICmp(pUsing->a[k].zName, zCol)==0 ){ + pItem++; + i++; + break; + } + } + } + } + break; + } + } + } + } + +#ifndef SQLITE_OMIT_TRIGGER + /* If we have not already resolved the name, then maybe + ** it is a new.* or old.* trigger argument reference + */ + if( zDb==0 && zTab!=0 && cnt==0 && pParse->trigStack!=0 ){ + TriggerStack *pTriggerStack = pParse->trigStack; + Table *pTab = 0; + if( pTriggerStack->newIdx != -1 && sqlite3StrICmp("new", zTab) == 0 ){ + pExpr->iTable = pTriggerStack->newIdx; + assert( pTriggerStack->pTab ); + pTab = pTriggerStack->pTab; + }else if( pTriggerStack->oldIdx != -1 && sqlite3StrICmp("old", zTab)==0 ){ + pExpr->iTable = pTriggerStack->oldIdx; + assert( pTriggerStack->pTab ); + pTab = pTriggerStack->pTab; + } + + if( pTab ){ + int iCol; + Column *pCol = pTab->aCol; + + pSchema = pTab->pSchema; + cntTab++; + for(iCol=0; iCol < pTab->nCol; iCol++, pCol++) { + if( sqlite3StrICmp(pCol->zName, zCol)==0 ){ + const char *zColl = pTab->aCol[iCol].zColl; + cnt++; + pExpr->iColumn = iCol==pTab->iPKey ? -1 : iCol; + pExpr->affinity = pTab->aCol[iCol].affinity; + if( (pExpr->flags & EP_ExpCollate)==0 ){ + pExpr->pColl = sqlite3FindCollSeq(db, ENC(db), zColl,-1, 0); + } + pExpr->pTab = pTab; + break; + } + } + } + } +#endif /* !defined(SQLITE_OMIT_TRIGGER) */ + + /* + ** Perhaps the name is a reference to the ROWID + */ + if( cnt==0 && cntTab==1 && sqlite3IsRowid(zCol) ){ + cnt = 1; + pExpr->iColumn = -1; + pExpr->affinity = SQLITE_AFF_INTEGER; + } + + /* + ** If the input is of the form Z (not Y.Z or X.Y.Z) then the name Z + ** might refer to an result-set alias. This happens, for example, when + ** we are resolving names in the WHERE clause of the following command: + ** + ** SELECT a+b AS x FROM table WHERE x<10; + ** + ** In cases like this, replace pExpr with a copy of the expression that + ** forms the result set entry ("a+b" in the example) and return immediately. + ** Note that the expression in the result set should have already been + ** resolved by the time the WHERE clause is resolved. + */ + if( cnt==0 && (pEList = pNC->pEList)!=0 && zTab==0 ){ + for(j=0; jnExpr; j++){ + char *zAs = pEList->a[j].zName; + if( zAs!=0 && sqlite3StrICmp(zAs, zCol)==0 ){ + Expr *pDup, *pOrig; + assert( pExpr->pLeft==0 && pExpr->pRight==0 ); + assert( pExpr->pList==0 ); + assert( pExpr->pSelect==0 ); + pOrig = pEList->a[j].pExpr; + if( !pNC->allowAgg && ExprHasProperty(pOrig, EP_Agg) ){ + sqlite3ErrorMsg(pParse, "misuse of aliased aggregate %s", zAs); + sqlite3_free(zCol); + return 2; + } + pDup = sqlite3ExprDup(db, pOrig); + if( pExpr->flags & EP_ExpCollate ){ + pDup->pColl = pExpr->pColl; + pDup->flags |= EP_ExpCollate; + } + if( pExpr->span.dyn ) sqlite3_free((char*)pExpr->span.z); + if( pExpr->token.dyn ) sqlite3_free((char*)pExpr->token.z); + memcpy(pExpr, pDup, sizeof(*pExpr)); + sqlite3_free(pDup); + cnt = 1; + pMatch = 0; + assert( zTab==0 && zDb==0 ); + goto lookupname_end_2; + } + } + } + + /* Advance to the next name context. The loop will exit when either + ** we have a match (cnt>0) or when we run out of name contexts. + */ + if( cnt==0 ){ + pNC = pNC->pNext; + } + } + + /* + ** If X and Y are NULL (in other words if only the column name Z is + ** supplied) and the value of Z is enclosed in double-quotes, then + ** Z is a string literal if it doesn't match any column names. In that + ** case, we need to return right away and not make any changes to + ** pExpr. + ** + ** Because no reference was made to outer contexts, the pNC->nRef + ** fields are not changed in any context. + */ + if( cnt==0 && zTab==0 && pColumnToken->z[0]=='"' ){ + sqlite3_free(zCol); + return 0; + } + + /* + ** cnt==0 means there was not match. cnt>1 means there were two or + ** more matches. Either way, we have an error. + */ + if( cnt!=1 ){ + char *z = 0; + char *zErr; + zErr = (char*)(cnt==0 ? "no such column: %s" : "ambiguous column name: %s"); + if( zDb ){ + sqlite3SetString(&z, zDb, ".", zTab, ".", zCol, (char*)0); + }else if( zTab ){ + sqlite3SetString(&z, zTab, ".", zCol, (char*)0); + }else{ + z = sqlite3StrDup(zCol); + } + if( z ){ + sqlite3ErrorMsg(pParse, zErr, z); + sqlite3_free(z); + pTopNC->nErr++; + }else{ + db->mallocFailed = 1; + } + } + + /* If a column from a table in pSrcList is referenced, then record + ** this fact in the pSrcList.a[].colUsed bitmask. Column 0 causes + ** bit 0 to be set. Column 1 sets bit 1. And so forth. If the + ** column number is greater than the number of bits in the bitmask + ** then set the high-order bit of the bitmask. + */ + if( pExpr->iColumn>=0 && pMatch!=0 ){ + int n = pExpr->iColumn; + if( n>=sizeof(Bitmask)*8 ){ + n = sizeof(Bitmask)*8-1; + } + assert( pMatch->iCursor==pExpr->iTable ); + pMatch->colUsed |= ((Bitmask)1)<pLeft); + pExpr->pLeft = 0; + sqlite3ExprDelete(pExpr->pRight); + pExpr->pRight = 0; + pExpr->op = TK_COLUMN; +lookupname_end_2: + sqlite3_free(zCol); + if( cnt==1 ){ + assert( pNC!=0 ); + sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList); + if( pMatch && !pMatch->pSelect ){ + pExpr->pTab = pMatch->pTab; + } + /* Increment the nRef value on all name contexts from TopNC up to + ** the point where the name matched. */ + for(;;){ + assert( pTopNC!=0 ); + pTopNC->nRef++; + if( pTopNC==pNC ) break; + pTopNC = pTopNC->pNext; + } + return 0; + } else { + return 1; + } +} + +/* +** This routine is designed as an xFunc for walkExprTree(). +** +** Resolve symbolic names into TK_COLUMN operators for the current +** node in the expression tree. Return 0 to continue the search down +** the tree or 2 to abort the tree walk. +** +** This routine also does error checking and name resolution for +** function names. The operator for aggregate functions is changed +** to TK_AGG_FUNCTION. +*/ +static int nameResolverStep(void *pArg, Expr *pExpr){ + NameContext *pNC = (NameContext*)pArg; + Parse *pParse; + + if( pExpr==0 ) return 1; + assert( pNC!=0 ); + pParse = pNC->pParse; + + if( ExprHasAnyProperty(pExpr, EP_Resolved) ) return 1; + ExprSetProperty(pExpr, EP_Resolved); +#ifndef NDEBUG + if( pNC->pSrcList && pNC->pSrcList->nAlloc>0 ){ + SrcList *pSrcList = pNC->pSrcList; + int i; + for(i=0; ipSrcList->nSrc; i++){ + assert( pSrcList->a[i].iCursor>=0 && pSrcList->a[i].iCursornTab); + } + } +#endif + switch( pExpr->op ){ + /* Double-quoted strings (ex: "abc") are used as identifiers if + ** possible. Otherwise they remain as strings. Single-quoted + ** strings (ex: 'abc') are always string literals. + */ + case TK_STRING: { + if( pExpr->token.z[0]=='\'' ) break; + /* Fall thru into the TK_ID case if this is a double-quoted string */ + } + /* A lone identifier is the name of a column. + */ + case TK_ID: { + lookupName(pParse, 0, 0, &pExpr->token, pNC, pExpr); + return 1; + } + + /* A table name and column name: ID.ID + ** Or a database, table and column: ID.ID.ID + */ + case TK_DOT: { + Token *pColumn; + Token *pTable; + Token *pDb; + Expr *pRight; + + /* if( pSrcList==0 ) break; */ + pRight = pExpr->pRight; + if( pRight->op==TK_ID ){ + pDb = 0; + pTable = &pExpr->pLeft->token; + pColumn = &pRight->token; + }else{ + assert( pRight->op==TK_DOT ); + pDb = &pExpr->pLeft->token; + pTable = &pRight->pLeft->token; + pColumn = &pRight->pRight->token; + } + lookupName(pParse, pDb, pTable, pColumn, pNC, pExpr); + return 1; + } + + /* Resolve function names + */ + case TK_CONST_FUNC: + case TK_FUNCTION: { + ExprList *pList = pExpr->pList; /* The argument list */ + int n = pList ? pList->nExpr : 0; /* Number of arguments */ + int no_such_func = 0; /* True if no such function exists */ + int wrong_num_args = 0; /* True if wrong number of arguments */ + int is_agg = 0; /* True if is an aggregate function */ + int i; + int auth; /* Authorization to use the function */ + int nId; /* Number of characters in function name */ + const char *zId; /* The function name. */ + FuncDef *pDef; /* Information about the function */ + int enc = ENC(pParse->db); /* The database encoding */ + + zId = (char*)pExpr->token.z; + nId = pExpr->token.n; + pDef = sqlite3FindFunction(pParse->db, zId, nId, n, enc, 0); + if( pDef==0 ){ + pDef = sqlite3FindFunction(pParse->db, zId, nId, -1, enc, 0); + if( pDef==0 ){ + no_such_func = 1; + }else{ + wrong_num_args = 1; + } + }else{ + is_agg = pDef->xFunc==0; + } +#ifndef SQLITE_OMIT_AUTHORIZATION + if( pDef ){ + auth = sqlite3AuthCheck(pParse, SQLITE_FUNCTION, 0, pDef->zName, 0); + if( auth!=SQLITE_OK ){ + if( auth==SQLITE_DENY ){ + sqlite3ErrorMsg(pParse, "not authorized to use function: %s", + pDef->zName); + pNC->nErr++; + } + pExpr->op = TK_NULL; + return 1; + } + } +#endif + if( is_agg && !pNC->allowAgg ){ + sqlite3ErrorMsg(pParse, "misuse of aggregate function %.*s()", nId,zId); + pNC->nErr++; + is_agg = 0; + }else if( no_such_func ){ + sqlite3ErrorMsg(pParse, "no such function: %.*s", nId, zId); + pNC->nErr++; + }else if( wrong_num_args ){ + sqlite3ErrorMsg(pParse,"wrong number of arguments to function %.*s()", + nId, zId); + pNC->nErr++; + } + if( is_agg ){ + pExpr->op = TK_AGG_FUNCTION; + pNC->hasAgg = 1; + } + if( is_agg ) pNC->allowAgg = 0; + for(i=0; pNC->nErr==0 && ia[i].pExpr, nameResolverStep, pNC); + } + if( is_agg ) pNC->allowAgg = 1; + /* FIX ME: Compute pExpr->affinity based on the expected return + ** type of the function + */ + return is_agg; + } +#ifndef SQLITE_OMIT_SUBQUERY + case TK_SELECT: + case TK_EXISTS: +#endif + case TK_IN: { + if( pExpr->pSelect ){ + int nRef = pNC->nRef; +#ifndef SQLITE_OMIT_CHECK + if( pNC->isCheck ){ + sqlite3ErrorMsg(pParse,"subqueries prohibited in CHECK constraints"); + } +#endif + sqlite3SelectResolve(pParse, pExpr->pSelect, pNC); + assert( pNC->nRef>=nRef ); + if( nRef!=pNC->nRef ){ + ExprSetProperty(pExpr, EP_VarSelect); + } + } + break; + } +#ifndef SQLITE_OMIT_CHECK + case TK_VARIABLE: { + if( pNC->isCheck ){ + sqlite3ErrorMsg(pParse,"parameters prohibited in CHECK constraints"); + } + break; + } +#endif + } + return 0; +} + +/* +** This routine walks an expression tree and resolves references to +** table columns. Nodes of the form ID.ID or ID resolve into an +** index to the table in the table list and a column offset. The +** Expr.opcode for such nodes is changed to TK_COLUMN. The Expr.iTable +** value is changed to the index of the referenced table in pTabList +** plus the "base" value. The base value will ultimately become the +** VDBE cursor number for a cursor that is pointing into the referenced +** table. The Expr.iColumn value is changed to the index of the column +** of the referenced table. The Expr.iColumn value for the special +** ROWID column is -1. Any INTEGER PRIMARY KEY column is tried as an +** alias for ROWID. +** +** Also resolve function names and check the functions for proper +** usage. Make sure all function names are recognized and all functions +** have the correct number of arguments. Leave an error message +** in pParse->zErrMsg if anything is amiss. Return the number of errors. +** +** If the expression contains aggregate functions then set the EP_Agg +** property on the expression. +*/ +int sqlite3ExprResolveNames( + NameContext *pNC, /* Namespace to resolve expressions in. */ + Expr *pExpr /* The expression to be analyzed. */ +){ + int savedHasAgg; + if( pExpr==0 ) return 0; +#if defined(SQLITE_TEST) || SQLITE_MAX_EXPR_DEPTH>0 + if( (pExpr->nHeight+pNC->pParse->nHeight)>SQLITE_MAX_EXPR_DEPTH ){ + sqlite3ErrorMsg(pNC->pParse, + "Expression tree is too large (maximum depth %d)", + SQLITE_MAX_EXPR_DEPTH + ); + return 1; + } + pNC->pParse->nHeight += pExpr->nHeight; +#endif + savedHasAgg = pNC->hasAgg; + pNC->hasAgg = 0; + walkExprTree(pExpr, nameResolverStep, pNC); +#if defined(SQLITE_TEST) || SQLITE_MAX_EXPR_DEPTH>0 + pNC->pParse->nHeight -= pExpr->nHeight; +#endif + if( pNC->nErr>0 ){ + ExprSetProperty(pExpr, EP_Error); + } + if( pNC->hasAgg ){ + ExprSetProperty(pExpr, EP_Agg); + }else if( savedHasAgg ){ + pNC->hasAgg = 1; + } + return ExprHasProperty(pExpr, EP_Error); +} + +/* +** A pointer instance of this structure is used to pass information +** through walkExprTree into codeSubqueryStep(). +*/ +typedef struct QueryCoder QueryCoder; +struct QueryCoder { + Parse *pParse; /* The parsing context */ + NameContext *pNC; /* Namespace of first enclosing query */ +}; + +#ifdef SQLITE_TEST + int sqlite3_enable_in_opt = 1; +#else + #define sqlite3_enable_in_opt 1 +#endif + +/* +** This function is used by the implementation of the IN (...) operator. +** It's job is to find or create a b-tree structure that may be used +** either to test for membership of the (...) set or to iterate through +** its members, skipping duplicates. +** +** The cursor opened on the structure (database table, database index +** or ephermal table) is stored in pX->iTable before this function returns. +** The returned value indicates the structure type, as follows: +** +** IN_INDEX_ROWID - The cursor was opened on a database table. +** IN_INDEX_INDEX - The cursor was opened on a database indec. +** IN_INDEX_EPH - The cursor was opened on a specially created and +** populated epheremal table. +** +** An existing structure may only be used if the SELECT is of the simple +** form: +** +** SELECT FROM +** +** If the mustBeUnique parameter is false, the structure will be used +** for fast set membership tests. In this case an epheremal table must +** be used unless is an INTEGER PRIMARY KEY or an index can +** be found with as its left-most column. +** +** If mustBeUnique is true, then the structure will be used to iterate +** through the set members, skipping any duplicates. In this case an +** epheremal table must be used unless the selected is guaranteed +** to be unique - either because it is an INTEGER PRIMARY KEY or it +** is unique by virtue of a constraint or implicit index. +*/ +#ifndef SQLITE_OMIT_SUBQUERY +int sqlite3FindInIndex(Parse *pParse, Expr *pX, int mustBeUnique){ + Select *p; + int eType = 0; + int iTab = pParse->nTab++; + + /* The follwing if(...) expression is true if the SELECT is of the + ** simple form: + ** + ** SELECT FROM
+ ** + ** If this is the case, it may be possible to use an existing table + ** or index instead of generating an epheremal table. + */ + if( sqlite3_enable_in_opt + && (p=pX->pSelect) && !p->pPrior + && !p->isDistinct && !p->isAgg && !p->pGroupBy + && p->pSrc && p->pSrc->nSrc==1 && !p->pSrc->a[0].pSelect + && !p->pSrc->a[0].pTab->pSelect + && p->pEList->nExpr==1 && p->pEList->a[0].pExpr->op==TK_COLUMN + && !p->pLimit && !p->pOffset && !p->pWhere + ){ + sqlite3 *db = pParse->db; + Index *pIdx; + Expr *pExpr = p->pEList->a[0].pExpr; + int iCol = pExpr->iColumn; + Vdbe *v = sqlite3GetVdbe(pParse); + + /* This function is only called from two places. In both cases the vdbe + ** has already been allocated. So assume sqlite3GetVdbe() is always + ** successful here. + */ + assert(v); + if( iCol<0 ){ + int iMem = pParse->nMem++; + int iAddr; + Table *pTab = p->pSrc->a[0].pTab; + int iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + sqlite3VdbeUsesBtree(v, iDb); + + sqlite3VdbeAddOp(v, OP_MemLoad, iMem, 0); + iAddr = sqlite3VdbeAddOp(v, OP_If, 0, iMem); + sqlite3VdbeAddOp(v, OP_MemInt, 1, iMem); + + sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead); + eType = IN_INDEX_ROWID; + + sqlite3VdbeJumpHere(v, iAddr); + }else{ + /* The collation sequence used by the comparison. If an index is to + ** be used in place of a temp-table, it must be ordered according + ** to this collation sequence. + */ + CollSeq *pReq = sqlite3BinaryCompareCollSeq(pParse, pX->pLeft, pExpr); + + /* Check that the affinity that will be used to perform the + ** comparison is the same as the affinity of the column. If + ** it is not, it is not possible to use any index. + */ + Table *pTab = p->pSrc->a[0].pTab; + char aff = comparisonAffinity(pX); + int affinity_ok = (pTab->aCol[iCol].affinity==aff||aff==SQLITE_AFF_NONE); + + for(pIdx=pTab->pIndex; pIdx && eType==0 && affinity_ok; pIdx=pIdx->pNext){ + if( (pIdx->aiColumn[0]==iCol) + && (pReq==sqlite3FindCollSeq(db, ENC(db), pIdx->azColl[0], -1, 0)) + && (!mustBeUnique || (pIdx->nColumn==1 && pIdx->onError!=OE_None)) + ){ + int iDb; + int iMem = pParse->nMem++; + int iAddr; + char *pKey; + + pKey = (char *)sqlite3IndexKeyinfo(pParse, pIdx); + iDb = sqlite3SchemaToIndex(db, pIdx->pSchema); + sqlite3VdbeUsesBtree(v, iDb); + + sqlite3VdbeAddOp(v, OP_MemLoad, iMem, 0); + iAddr = sqlite3VdbeAddOp(v, OP_If, 0, iMem); + sqlite3VdbeAddOp(v, OP_MemInt, 1, iMem); + + sqlite3VdbeAddOp(v, OP_Integer, iDb, 0); + VdbeComment((v, "# %s", pIdx->zName)); + sqlite3VdbeOp3(v,OP_OpenRead,iTab,pIdx->tnum,pKey,P3_KEYINFO_HANDOFF); + eType = IN_INDEX_INDEX; + sqlite3VdbeAddOp(v, OP_SetNumColumns, iTab, pIdx->nColumn); + + sqlite3VdbeJumpHere(v, iAddr); + } + } + } + } + + if( eType==0 ){ + sqlite3CodeSubselect(pParse, pX); + eType = IN_INDEX_EPH; + }else{ + pX->iTable = iTab; + } + return eType; +} +#endif + +/* +** Generate code for scalar subqueries used as an expression +** and IN operators. Examples: +** +** (SELECT a FROM b) -- subquery +** EXISTS (SELECT a FROM b) -- EXISTS subquery +** x IN (4,5,11) -- IN operator with list on right-hand side +** x IN (SELECT a FROM b) -- IN operator with subquery on the right +** +** The pExpr parameter describes the expression that contains the IN +** operator or subquery. +*/ +#ifndef SQLITE_OMIT_SUBQUERY +void sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){ + int testAddr = 0; /* One-time test address */ + Vdbe *v = sqlite3GetVdbe(pParse); + if( v==0 ) return; + + + /* This code must be run in its entirety every time it is encountered + ** if any of the following is true: + ** + ** * The right-hand side is a correlated subquery + ** * The right-hand side is an expression list containing variables + ** * We are inside a trigger + ** + ** If all of the above are false, then we can run this code just once + ** save the results, and reuse the same result on subsequent invocations. + */ + if( !ExprHasAnyProperty(pExpr, EP_VarSelect) && !pParse->trigStack ){ + int mem = pParse->nMem++; + sqlite3VdbeAddOp(v, OP_MemLoad, mem, 0); + testAddr = sqlite3VdbeAddOp(v, OP_If, 0, 0); + assert( testAddr>0 || pParse->db->mallocFailed ); + sqlite3VdbeAddOp(v, OP_MemInt, 1, mem); + } + + switch( pExpr->op ){ + case TK_IN: { + char affinity; + KeyInfo keyInfo; + int addr; /* Address of OP_OpenEphemeral instruction */ + + affinity = sqlite3ExprAffinity(pExpr->pLeft); + + /* Whether this is an 'x IN(SELECT...)' or an 'x IN()' + ** expression it is handled the same way. A virtual table is + ** filled with single-field index keys representing the results + ** from the SELECT or the . + ** + ** If the 'x' expression is a column value, or the SELECT... + ** statement returns a column value, then the affinity of that + ** column is used to build the index keys. If both 'x' and the + ** SELECT... statement are columns, then numeric affinity is used + ** if either column has NUMERIC or INTEGER affinity. If neither + ** 'x' nor the SELECT... statement are columns, then numeric affinity + ** is used. + */ + pExpr->iTable = pParse->nTab++; + addr = sqlite3VdbeAddOp(v, OP_OpenEphemeral, pExpr->iTable, 0); + memset(&keyInfo, 0, sizeof(keyInfo)); + keyInfo.nField = 1; + sqlite3VdbeAddOp(v, OP_SetNumColumns, pExpr->iTable, 1); + + if( pExpr->pSelect ){ + /* Case 1: expr IN (SELECT ...) + ** + ** Generate code to write the results of the select into the temporary + ** table allocated and opened above. + */ + int iParm = pExpr->iTable + (((int)affinity)<<16); + ExprList *pEList; + assert( (pExpr->iTable&0x0000FFFF)==pExpr->iTable ); + if( sqlite3Select(pParse, pExpr->pSelect, SRT_Set, iParm, 0, 0, 0, 0) ){ + return; + } + pEList = pExpr->pSelect->pEList; + if( pEList && pEList->nExpr>0 ){ + keyInfo.aColl[0] = sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft, + pEList->a[0].pExpr); + } + }else if( pExpr->pList ){ + /* Case 2: expr IN (exprlist) + ** + ** For each expression, build an index key from the evaluation and + ** store it in the temporary table. If is a column, then use + ** that columns affinity when building index keys. If is not + ** a column, use numeric affinity. + */ + int i; + ExprList *pList = pExpr->pList; + ExprList::ExprList_item *pItem; + + if( !affinity ){ + affinity = SQLITE_AFF_NONE; + } + keyInfo.aColl[0] = pExpr->pLeft->pColl; + + /* Loop through each expression in . */ + for(i=pList->nExpr, pItem=pList->a; i>0; i--, pItem++){ + Expr *pE2 = pItem->pExpr; + + /* If the expression is not constant then we will need to + ** disable the test that was generated above that makes sure + ** this code only executes once. Because for a non-constant + ** expression we need to rerun this code each time. + */ + if( testAddr>0 && !sqlite3ExprIsConstant(pE2) ){ + sqlite3VdbeChangeToNoop(v, testAddr-1, 3); + testAddr = 0; + } + + /* Evaluate the expression and insert it into the temp table */ + sqlite3ExprCode(pParse, pE2); + sqlite3VdbeOp3(v, OP_MakeRecord, 1, 0, &affinity, 1); + sqlite3VdbeAddOp(v, OP_IdxInsert, pExpr->iTable, 0); + } + } + sqlite3VdbeChangeP3(v, addr, (const char *)&keyInfo, P3_KEYINFO); + break; + } + + case TK_EXISTS: + case TK_SELECT: { + /* This has to be a scalar SELECT. Generate code to put the + ** value of this select in a memory cell and record the number + ** of the memory cell in iColumn. + */ + static const Token one = { (u8*)"1", 0, 1 }; + Select *pSel; + int iMem; + int sop; + + pExpr->iColumn = iMem = pParse->nMem++; + pSel = pExpr->pSelect; + if( pExpr->op==TK_SELECT ){ + sop = SRT_Mem; + sqlite3VdbeAddOp(v, OP_MemNull, iMem, 0); + VdbeComment((v, "# Init subquery result")); + }else{ + sop = SRT_Exists; + sqlite3VdbeAddOp(v, OP_MemInt, 0, iMem); + VdbeComment((v, "# Init EXISTS result")); + } + sqlite3ExprDelete(pSel->pLimit); + pSel->pLimit = sqlite3PExpr(pParse, TK_INTEGER, 0, 0, &one); + if( sqlite3Select(pParse, pSel, sop, iMem, 0, 0, 0, 0) ){ + return; + } + break; + } + } + + if( testAddr ){ + sqlite3VdbeJumpHere(v, testAddr); + } + + return; +} +#endif /* SQLITE_OMIT_SUBQUERY */ + +/* +** Duplicate an 8-byte value +*/ +static char *dup8bytes(Vdbe *v, const char *in){ + char *out = (char*)sqlite3DbMallocRaw(sqlite3VdbeDb(v), 8); + if( out ){ + memcpy(out, in, 8); + } + return out; +} + +/* +** Generate an instruction that will put the floating point +** value described by z[0..n-1] on the stack. +** +** The z[] string will probably not be zero-terminated. But the +** z[n] character is guaranteed to be something that does not look +** like the continuation of the number. +*/ +static void codeReal(Vdbe *v, const char *z, int n, int negateFlag){ + assert( z || v==0 || sqlite3VdbeDb(v)->mallocFailed ); + if( z ){ + double value; + char *zV; + assert( !isdigit(z[n]) ); + sqlite3AtoF(z, &value); + if( negateFlag ) value = -value; + zV = dup8bytes(v, (char*)&value); + sqlite3VdbeOp3(v, OP_Real, 0, 0, zV, P3_REAL); + } +} + + +/* +** Generate an instruction that will put the integer describe by +** text z[0..n-1] on the stack. +** +** The z[] string will probably not be zero-terminated. But the +** z[n] character is guaranteed to be something that does not look +** like the continuation of the number. +*/ +static void codeInteger(Vdbe *v, const char *z, int n, int negateFlag){ + assert( z || v==0 || sqlite3VdbeDb(v)->mallocFailed ); + if( z ){ + int i; + assert( !isdigit(z[n]) ); + if( sqlite3GetInt32(z, &i) ){ + if( negateFlag ) i = -i; + sqlite3VdbeAddOp(v, OP_Integer, i, 0); + }else if( sqlite3FitsIn64Bits(z, negateFlag) ){ + i64 value; + char *zV; + sqlite3Atoi64(z, &value); + if( negateFlag ) value = -value; + zV = dup8bytes(v, (char*)&value); + sqlite3VdbeOp3(v, OP_Int64, 0, 0, zV, P3_INT64); + }else{ + codeReal(v, z, n, negateFlag); + } + } +} + + +/* +** Generate code that will extract the iColumn-th column from +** table pTab and push that column value on the stack. There +** is an open cursor to pTab in iTable. If iColumn<0 then +** code is generated that extracts the rowid. +*/ +void sqlite3ExprCodeGetColumn(Vdbe *v, Table *pTab, int iColumn, int iTable){ + if( iColumn<0 ){ + int op = (pTab && IsVirtual(pTab)) ? OP_VRowid : OP_Rowid; + sqlite3VdbeAddOp(v, op, iTable, 0); + }else if( pTab==0 ){ + sqlite3VdbeAddOp(v, OP_Column, iTable, iColumn); + }else{ + int op = IsVirtual(pTab) ? OP_VColumn : OP_Column; + sqlite3VdbeAddOp(v, op, iTable, iColumn); + sqlite3ColumnDefault(v, pTab, iColumn); +#ifndef SQLITE_OMIT_FLOATING_POINT + if( pTab->aCol[iColumn].affinity==SQLITE_AFF_REAL ){ + sqlite3VdbeAddOp(v, OP_RealAffinity, 0, 0); + } +#endif + } +} + +/* +** Generate code into the current Vdbe to evaluate the given +** expression and leave the result on the top of stack. +** +** This code depends on the fact that certain token values (ex: TK_EQ) +** are the same as opcode values (ex: OP_Eq) that implement the corresponding +** operation. Special comments in vdbe.c and the mkopcodeh.awk script in +** the make process cause these values to align. Assert()s in the code +** below verify that the numbers are aligned correctly. +*/ +void sqlite3ExprCode(Parse *pParse, Expr *pExpr){ + Vdbe *v = pParse->pVdbe; + int op; + int stackChng = 1; /* Amount of change to stack depth */ + + if( v==0 ) return; + if( pExpr==0 ){ + sqlite3VdbeAddOp(v, OP_Null, 0, 0); + return; + } + op = pExpr->op; + switch( op ){ + case TK_AGG_COLUMN: { + AggInfo *pAggInfo = pExpr->pAggInfo; + AggInfo::AggInfo_col *pCol = &pAggInfo->aCol[pExpr->iAgg]; + if( !pAggInfo->directMode ){ + sqlite3VdbeAddOp(v, OP_MemLoad, pCol->iMem, 0); + break; + }else if( pAggInfo->useSortingIdx ){ + sqlite3VdbeAddOp(v, OP_Column, pAggInfo->sortingIdx, + pCol->iSorterColumn); + break; + } + /* Otherwise, fall thru into the TK_COLUMN case */ + } + case TK_COLUMN: { + if( pExpr->iTable<0 ){ + /* This only happens when coding check constraints */ + assert( pParse->ckOffset>0 ); + sqlite3VdbeAddOp(v, OP_Dup, pParse->ckOffset-pExpr->iColumn-1, 1); + }else{ + sqlite3ExprCodeGetColumn(v, pExpr->pTab, pExpr->iColumn, pExpr->iTable); + } + break; + } + case TK_INTEGER: { + codeInteger(v, (char*)pExpr->token.z, pExpr->token.n, 0); + break; + } + case TK_FLOAT: { + codeReal(v, (char*)pExpr->token.z, pExpr->token.n, 0); + break; + } + case TK_STRING: { + sqlite3DequoteExpr(pParse->db, pExpr); + sqlite3VdbeOp3(v,OP_String8, 0, 0, (char*)pExpr->token.z, pExpr->token.n); + break; + } + case TK_NULL: { + sqlite3VdbeAddOp(v, OP_Null, 0, 0); + break; + } +#ifndef SQLITE_OMIT_BLOB_LITERAL + case TK_BLOB: { + int n; + const char *z; + assert( TK_BLOB==OP_HexBlob ); + n = pExpr->token.n - 3; + z = (char*)pExpr->token.z + 2; + assert( n>=0 ); + if( n==0 ){ + z = ""; + } + sqlite3VdbeOp3(v, op, 0, 0, z, n); + break; + } +#endif + case TK_VARIABLE: { + sqlite3VdbeAddOp(v, OP_Variable, pExpr->iTable, 0); + if( pExpr->token.n>1 ){ + sqlite3VdbeChangeP3(v, -1, (char*)pExpr->token.z, pExpr->token.n); + } + break; + } + case TK_REGISTER: { + sqlite3VdbeAddOp(v, OP_MemLoad, pExpr->iTable, 0); + break; + } +#ifndef SQLITE_OMIT_CAST + case TK_CAST: { + /* Expressions of the form: CAST(pLeft AS token) */ + int aff, to_op; + sqlite3ExprCode(pParse, pExpr->pLeft); + aff = sqlite3AffinityType(&pExpr->token); + to_op = aff - SQLITE_AFF_TEXT + OP_ToText; + assert( to_op==OP_ToText || aff!=SQLITE_AFF_TEXT ); + assert( to_op==OP_ToBlob || aff!=SQLITE_AFF_NONE ); + assert( to_op==OP_ToNumeric || aff!=SQLITE_AFF_NUMERIC ); + assert( to_op==OP_ToInt || aff!=SQLITE_AFF_INTEGER ); + assert( to_op==OP_ToReal || aff!=SQLITE_AFF_REAL ); + sqlite3VdbeAddOp(v, to_op, 0, 0); + stackChng = 0; + break; + } +#endif /* SQLITE_OMIT_CAST */ + case TK_LT: + case TK_LE: + case TK_GT: + case TK_GE: + case TK_NE: + case TK_EQ: { + assert( TK_LT==OP_Lt ); + assert( TK_LE==OP_Le ); + assert( TK_GT==OP_Gt ); + assert( TK_GE==OP_Ge ); + assert( TK_EQ==OP_Eq ); + assert( TK_NE==OP_Ne ); + sqlite3ExprCode(pParse, pExpr->pLeft); + sqlite3ExprCode(pParse, pExpr->pRight); + codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op, 0, 0); + stackChng = -1; + break; + } + case TK_AND: + case TK_OR: + case TK_PLUS: + case TK_STAR: + case TK_MINUS: + case TK_REM: + case TK_BITAND: + case TK_BITOR: + case TK_SLASH: + case TK_LSHIFT: + case TK_RSHIFT: + case TK_CONCAT: { + assert( TK_AND==OP_And ); + assert( TK_OR==OP_Or ); + assert( TK_PLUS==OP_Add ); + assert( TK_MINUS==OP_Subtract ); + assert( TK_REM==OP_Remainder ); + assert( TK_BITAND==OP_BitAnd ); + assert( TK_BITOR==OP_BitOr ); + assert( TK_SLASH==OP_Divide ); + assert( TK_LSHIFT==OP_ShiftLeft ); + assert( TK_RSHIFT==OP_ShiftRight ); + assert( TK_CONCAT==OP_Concat ); + sqlite3ExprCode(pParse, pExpr->pLeft); + sqlite3ExprCode(pParse, pExpr->pRight); + sqlite3VdbeAddOp(v, op, 0, 0); + stackChng = -1; + break; + } + case TK_UMINUS: { + Expr *pLeft = pExpr->pLeft; + assert( pLeft ); + if( pLeft->op==TK_FLOAT || pLeft->op==TK_INTEGER ){ + Token *p = &pLeft->token; + if( pLeft->op==TK_FLOAT ){ + codeReal(v, (char*)p->z, p->n, 1); + }else{ + codeInteger(v, (char*)p->z, p->n, 1); + } + break; + } + /* Fall through into TK_NOT */ + } + case TK_BITNOT: + case TK_NOT: { + assert( TK_BITNOT==OP_BitNot ); + assert( TK_NOT==OP_Not ); + sqlite3ExprCode(pParse, pExpr->pLeft); + sqlite3VdbeAddOp(v, op, 0, 0); + stackChng = 0; + break; + } + case TK_ISNULL: + case TK_NOTNULL: { + int dest; + assert( TK_ISNULL==OP_IsNull ); + assert( TK_NOTNULL==OP_NotNull ); + sqlite3VdbeAddOp(v, OP_Integer, 1, 0); + sqlite3ExprCode(pParse, pExpr->pLeft); + dest = sqlite3VdbeCurrentAddr(v) + 2; + sqlite3VdbeAddOp(v, op, 1, dest); + sqlite3VdbeAddOp(v, OP_AddImm, -1, 0); + stackChng = 0; + break; + } + case TK_AGG_FUNCTION: { + AggInfo *pInfo = pExpr->pAggInfo; + if( pInfo==0 ){ + sqlite3ErrorMsg(pParse, "misuse of aggregate: %T", + &pExpr->span); + }else{ + sqlite3VdbeAddOp(v, OP_MemLoad, pInfo->aFunc[pExpr->iAgg].iMem, 0); + } + break; + } + case TK_CONST_FUNC: + case TK_FUNCTION: { + ExprList *pList = pExpr->pList; + int nExpr = pList ? pList->nExpr : 0; + FuncDef *pDef; + int nId; + const char *zId; + int constMask = 0; + int i; + sqlite3 *db = pParse->db; + u8 enc = ENC(db); + CollSeq *pColl = 0; + + zId = (char*)pExpr->token.z; + nId = pExpr->token.n; + pDef = sqlite3FindFunction(pParse->db, zId, nId, nExpr, enc, 0); + assert( pDef!=0 ); + nExpr = sqlite3ExprCodeExprList(pParse, pList); +#ifndef SQLITE_OMIT_VIRTUALTABLE + /* Possibly overload the function if the first argument is + ** a virtual table column. + ** + ** For infix functions (LIKE, GLOB, REGEXP, and MATCH) use the + ** second argument, not the first, as the argument to test to + ** see if it is a column in a virtual table. This is done because + ** the left operand of infix functions (the operand we want to + ** control overloading) ends up as the second argument to the + ** function. The expression "A glob B" is equivalent to + ** "glob(B,A). We want to use the A in "A glob B" to test + ** for function overloading. But we use the B term in "glob(B,A)". + */ + if( nExpr>=2 && (pExpr->flags & EP_InfixFunc) ){ + pDef = sqlite3VtabOverloadFunction(db, pDef, nExpr, pList->a[1].pExpr); + }else if( nExpr>0 ){ + pDef = sqlite3VtabOverloadFunction(db, pDef, nExpr, pList->a[0].pExpr); + } +#endif + for(i=0; ia[i].pExpr) ){ + constMask |= (1<needCollSeq && !pColl ){ + pColl = sqlite3ExprCollSeq(pParse, pList->a[i].pExpr); + } + } + if( pDef->needCollSeq ){ + if( !pColl ) pColl = pParse->db->pDfltColl; + sqlite3VdbeOp3(v, OP_CollSeq, 0, 0, (char *)pColl, P3_COLLSEQ); + } + sqlite3VdbeOp3(v, OP_Function, constMask, nExpr, (char*)pDef, P3_FUNCDEF); + stackChng = 1-nExpr; + break; + } +#ifndef SQLITE_OMIT_SUBQUERY + case TK_EXISTS: + case TK_SELECT: { + if( pExpr->iColumn==0 ){ + sqlite3CodeSubselect(pParse, pExpr); + } + sqlite3VdbeAddOp(v, OP_MemLoad, pExpr->iColumn, 0); + VdbeComment((v, "# load subquery result")); + break; + } + case TK_IN: { + int addr; + char affinity; + int ckOffset = pParse->ckOffset; + int eType; + int iLabel = sqlite3VdbeMakeLabel(v); + + eType = sqlite3FindInIndex(pParse, pExpr, 0); + + /* Figure out the affinity to use to create a key from the results + ** of the expression. affinityStr stores a static string suitable for + ** P3 of OP_MakeRecord. + */ + affinity = comparisonAffinity(pExpr); + + sqlite3VdbeAddOp(v, OP_Integer, 1, 0); + pParse->ckOffset = (ckOffset ? (ckOffset+1) : 0); + + /* Code the from " IN (...)". The temporary table + ** pExpr->iTable contains the values that make up the (...) set. + */ + sqlite3ExprCode(pParse, pExpr->pLeft); + addr = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeAddOp(v, OP_NotNull, -1, addr+4); /* addr + 0 */ + sqlite3VdbeAddOp(v, OP_Pop, 2, 0); + sqlite3VdbeAddOp(v, OP_Null, 0, 0); + sqlite3VdbeAddOp(v, OP_Goto, 0, iLabel); + if( eType==IN_INDEX_ROWID ){ + int iAddr = sqlite3VdbeCurrentAddr(v)+3; + sqlite3VdbeAddOp(v, OP_MustBeInt, 1, iAddr); + sqlite3VdbeAddOp(v, OP_NotExists, pExpr->iTable, iAddr); + sqlite3VdbeAddOp(v, OP_Goto, pExpr->iTable, iLabel); + }else{ + sqlite3VdbeOp3(v, OP_MakeRecord, 1, 0, &affinity, 1); /* addr + 4 */ + sqlite3VdbeAddOp(v, OP_Found, pExpr->iTable, iLabel); + } + sqlite3VdbeAddOp(v, OP_AddImm, -1, 0); /* addr + 6 */ + sqlite3VdbeResolveLabel(v, iLabel); + + break; + } +#endif + case TK_BETWEEN: { + Expr *pLeft = pExpr->pLeft; + ExprList::ExprList_item *pLItem = pExpr->pList->a; + Expr *pRight = pLItem->pExpr; + sqlite3ExprCode(pParse, pLeft); + sqlite3VdbeAddOp(v, OP_Dup, 0, 0); + sqlite3ExprCode(pParse, pRight); + codeCompare(pParse, pLeft, pRight, OP_Ge, 0, 0); + sqlite3VdbeAddOp(v, OP_Pull, 1, 0); + pLItem++; + pRight = pLItem->pExpr; + sqlite3ExprCode(pParse, pRight); + codeCompare(pParse, pLeft, pRight, OP_Le, 0, 0); + sqlite3VdbeAddOp(v, OP_And, 0, 0); + break; + } + case TK_UPLUS: { + sqlite3ExprCode(pParse, pExpr->pLeft); + stackChng = 0; + break; + } + case TK_CASE: { + int expr_end_label; + int jumpInst; + int nExpr; + int i; + ExprList *pEList; + ExprList::ExprList_item *aListelem; + + assert(pExpr->pList); + assert((pExpr->pList->nExpr % 2) == 0); + assert(pExpr->pList->nExpr > 0); + pEList = pExpr->pList; + aListelem = pEList->a; + nExpr = pEList->nExpr; + expr_end_label = sqlite3VdbeMakeLabel(v); + if( pExpr->pLeft ){ + sqlite3ExprCode(pParse, pExpr->pLeft); + } + for(i=0; ipLeft ){ + sqlite3VdbeAddOp(v, OP_Dup, 1, 1); + jumpInst = codeCompare(pParse, pExpr->pLeft, aListelem[i].pExpr, + OP_Ne, 0, 1); + sqlite3VdbeAddOp(v, OP_Pop, 1, 0); + }else{ + jumpInst = sqlite3VdbeAddOp(v, OP_IfNot, 1, 0); + } + sqlite3ExprCode(pParse, aListelem[i+1].pExpr); + sqlite3VdbeAddOp(v, OP_Goto, 0, expr_end_label); + sqlite3VdbeJumpHere(v, jumpInst); + } + if( pExpr->pLeft ){ + sqlite3VdbeAddOp(v, OP_Pop, 1, 0); + } + if( pExpr->pRight ){ + sqlite3ExprCode(pParse, pExpr->pRight); + }else{ + sqlite3VdbeAddOp(v, OP_Null, 0, 0); + } + sqlite3VdbeResolveLabel(v, expr_end_label); + break; + } +#ifndef SQLITE_OMIT_TRIGGER + case TK_RAISE: { + if( !pParse->trigStack ){ + sqlite3ErrorMsg(pParse, + "RAISE() may only be used within a trigger-program"); + return; + } + if( pExpr->iColumn!=OE_Ignore ){ + assert( pExpr->iColumn==OE_Rollback || + pExpr->iColumn == OE_Abort || + pExpr->iColumn == OE_Fail ); + sqlite3DequoteExpr(pParse->db, pExpr); + sqlite3VdbeOp3(v, OP_Halt, SQLITE_CONSTRAINT, pExpr->iColumn, + (char*)pExpr->token.z, pExpr->token.n); + } else { + assert( pExpr->iColumn == OE_Ignore ); + sqlite3VdbeAddOp(v, OP_ContextPop, 0, 0); + sqlite3VdbeAddOp(v, OP_Goto, 0, pParse->trigStack->ignoreJump); + VdbeComment((v, "# raise(IGNORE)")); + } + stackChng = 0; + break; + } +#endif + } + + if( pParse->ckOffset ){ + pParse->ckOffset += stackChng; + assert( pParse->ckOffset ); + } +} + +#ifndef SQLITE_OMIT_TRIGGER +/* +** Generate code that evalutes the given expression and leaves the result +** on the stack. See also sqlite3ExprCode(). +** +** This routine might also cache the result and modify the pExpr tree +** so that it will make use of the cached result on subsequent evaluations +** rather than evaluate the whole expression again. Trivial expressions are +** not cached. If the expression is cached, its result is stored in a +** memory location. +*/ +void sqlite3ExprCodeAndCache(Parse *pParse, Expr *pExpr){ + Vdbe *v = pParse->pVdbe; + VdbeOp *pOp; + int iMem; + int addr1, addr2; + if( v==0 ) return; + addr1 = sqlite3VdbeCurrentAddr(v); + sqlite3ExprCode(pParse, pExpr); + addr2 = sqlite3VdbeCurrentAddr(v); + if( addr2>addr1+1 + || ((pOp = sqlite3VdbeGetOp(v, addr1))!=0 && pOp->opcode==OP_Function) ){ + iMem = pExpr->iTable = pParse->nMem++; + sqlite3VdbeAddOp(v, OP_MemStore, iMem, 0); + pExpr->op = TK_REGISTER; + } +} +#endif + +/* +** Generate code that pushes the value of every element of the given +** expression list onto the stack. +** +** Return the number of elements pushed onto the stack. +*/ +int sqlite3ExprCodeExprList( + Parse *pParse, /* Parsing context */ + ExprList *pList /* The expression list to be coded */ +){ + ExprList::ExprList_item *pItem; + int i, n; + if( pList==0 ) return 0; + n = pList->nExpr; + for(pItem=pList->a, i=n; i>0; i--, pItem++){ + sqlite3ExprCode(pParse, pItem->pExpr); + } + return n; +} + +/* +** Generate code for a boolean expression such that a jump is made +** to the label "dest" if the expression is true but execution +** continues straight thru if the expression is false. +** +** If the expression evaluates to NULL (neither true nor false), then +** take the jump if the jumpIfNull flag is true. +** +** This code depends on the fact that certain token values (ex: TK_EQ) +** are the same as opcode values (ex: OP_Eq) that implement the corresponding +** operation. Special comments in vdbe.c and the mkopcodeh.awk script in +** the make process cause these values to align. Assert()s in the code +** below verify that the numbers are aligned correctly. +*/ +void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){ + Vdbe *v = pParse->pVdbe; + int op = 0; + int ckOffset = pParse->ckOffset; + if( v==0 || pExpr==0 ) return; + op = pExpr->op; + switch( op ){ + case TK_AND: { + int d2 = sqlite3VdbeMakeLabel(v); + sqlite3ExprIfFalse(pParse, pExpr->pLeft, d2, !jumpIfNull); + sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull); + sqlite3VdbeResolveLabel(v, d2); + break; + } + case TK_OR: { + sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull); + sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull); + break; + } + case TK_NOT: { + sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull); + break; + } + case TK_LT: + case TK_LE: + case TK_GT: + case TK_GE: + case TK_NE: + case TK_EQ: { + assert( TK_LT==OP_Lt ); + assert( TK_LE==OP_Le ); + assert( TK_GT==OP_Gt ); + assert( TK_GE==OP_Ge ); + assert( TK_EQ==OP_Eq ); + assert( TK_NE==OP_Ne ); + sqlite3ExprCode(pParse, pExpr->pLeft); + sqlite3ExprCode(pParse, pExpr->pRight); + codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op, dest, jumpIfNull); + break; + } + case TK_ISNULL: + case TK_NOTNULL: { + assert( TK_ISNULL==OP_IsNull ); + assert( TK_NOTNULL==OP_NotNull ); + sqlite3ExprCode(pParse, pExpr->pLeft); + sqlite3VdbeAddOp(v, op, 1, dest); + break; + } + case TK_BETWEEN: { + /* The expression "x BETWEEN y AND z" is implemented as: + ** + ** 1 IF (x < y) GOTO 3 + ** 2 IF (x <= z) GOTO + ** 3 ... + */ + int addr; + Expr *pLeft = pExpr->pLeft; + Expr *pRight = pExpr->pList->a[0].pExpr; + sqlite3ExprCode(pParse, pLeft); + sqlite3VdbeAddOp(v, OP_Dup, 0, 0); + sqlite3ExprCode(pParse, pRight); + addr = codeCompare(pParse, pLeft, pRight, OP_Lt, 0, !jumpIfNull); + + pRight = pExpr->pList->a[1].pExpr; + sqlite3ExprCode(pParse, pRight); + codeCompare(pParse, pLeft, pRight, OP_Le, dest, jumpIfNull); + + sqlite3VdbeAddOp(v, OP_Integer, 0, 0); + sqlite3VdbeJumpHere(v, addr); + sqlite3VdbeAddOp(v, OP_Pop, 1, 0); + break; + } + default: { + sqlite3ExprCode(pParse, pExpr); + sqlite3VdbeAddOp(v, OP_If, jumpIfNull, dest); + break; + } + } + pParse->ckOffset = ckOffset; +} + +/* +** Generate code for a boolean expression such that a jump is made +** to the label "dest" if the expression is false but execution +** continues straight thru if the expression is true. +** +** If the expression evaluates to NULL (neither true nor false) then +** jump if jumpIfNull is true or fall through if jumpIfNull is false. +*/ +void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){ + Vdbe *v = pParse->pVdbe; + int op = 0; + int ckOffset = pParse->ckOffset; + if( v==0 || pExpr==0 ) return; + + /* The value of pExpr->op and op are related as follows: + ** + ** pExpr->op op + ** --------- ---------- + ** TK_ISNULL OP_NotNull + ** TK_NOTNULL OP_IsNull + ** TK_NE OP_Eq + ** TK_EQ OP_Ne + ** TK_GT OP_Le + ** TK_LE OP_Gt + ** TK_GE OP_Lt + ** TK_LT OP_Ge + ** + ** For other values of pExpr->op, op is undefined and unused. + ** The value of TK_ and OP_ constants are arranged such that we + ** can compute the mapping above using the following expression. + ** Assert()s verify that the computation is correct. + */ + op = ((pExpr->op+(TK_ISNULL&1))^1)-(TK_ISNULL&1); + + /* Verify correct alignment of TK_ and OP_ constants + */ + assert( pExpr->op!=TK_ISNULL || op==OP_NotNull ); + assert( pExpr->op!=TK_NOTNULL || op==OP_IsNull ); + assert( pExpr->op!=TK_NE || op==OP_Eq ); + assert( pExpr->op!=TK_EQ || op==OP_Ne ); + assert( pExpr->op!=TK_LT || op==OP_Ge ); + assert( pExpr->op!=TK_LE || op==OP_Gt ); + assert( pExpr->op!=TK_GT || op==OP_Le ); + assert( pExpr->op!=TK_GE || op==OP_Lt ); + + switch( pExpr->op ){ + case TK_AND: { + sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull); + sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull); + break; + } + case TK_OR: { + int d2 = sqlite3VdbeMakeLabel(v); + sqlite3ExprIfTrue(pParse, pExpr->pLeft, d2, !jumpIfNull); + sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull); + sqlite3VdbeResolveLabel(v, d2); + break; + } + case TK_NOT: { + sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull); + break; + } + case TK_LT: + case TK_LE: + case TK_GT: + case TK_GE: + case TK_NE: + case TK_EQ: { + sqlite3ExprCode(pParse, pExpr->pLeft); + sqlite3ExprCode(pParse, pExpr->pRight); + codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op, dest, jumpIfNull); + break; + } + case TK_ISNULL: + case TK_NOTNULL: { + sqlite3ExprCode(pParse, pExpr->pLeft); + sqlite3VdbeAddOp(v, op, 1, dest); + break; + } + case TK_BETWEEN: { + /* The expression is "x BETWEEN y AND z". It is implemented as: + ** + ** 1 IF (x >= y) GOTO 3 + ** 2 GOTO + ** 3 IF (x > z) GOTO + */ + int addr; + Expr *pLeft = pExpr->pLeft; + Expr *pRight = pExpr->pList->a[0].pExpr; + sqlite3ExprCode(pParse, pLeft); + sqlite3VdbeAddOp(v, OP_Dup, 0, 0); + sqlite3ExprCode(pParse, pRight); + addr = sqlite3VdbeCurrentAddr(v); + codeCompare(pParse, pLeft, pRight, OP_Ge, addr+3, !jumpIfNull); + + sqlite3VdbeAddOp(v, OP_Pop, 1, 0); + sqlite3VdbeAddOp(v, OP_Goto, 0, dest); + pRight = pExpr->pList->a[1].pExpr; + sqlite3ExprCode(pParse, pRight); + codeCompare(pParse, pLeft, pRight, OP_Gt, dest, jumpIfNull); + break; + } + default: { + sqlite3ExprCode(pParse, pExpr); + sqlite3VdbeAddOp(v, OP_IfNot, jumpIfNull, dest); + break; + } + } + pParse->ckOffset = ckOffset; +} + +/* +** Do a deep comparison of two expression trees. Return TRUE (non-zero) +** if they are identical and return FALSE if they differ in any way. +** +** Sometimes this routine will return FALSE even if the two expressions +** really are equivalent. If we cannot prove that the expressions are +** identical, we return FALSE just to be safe. So if this routine +** returns false, then you do not really know for certain if the two +** expressions are the same. But if you get a TRUE return, then you +** can be sure the expressions are the same. In the places where +** this routine is used, it does not hurt to get an extra FALSE - that +** just might result in some slightly slower code. But returning +** an incorrect TRUE could lead to a malfunction. +*/ +int sqlite3ExprCompare(Expr *pA, Expr *pB){ + int i; + if( pA==0||pB==0 ){ + return pB==pA; + } + if( pA->op!=pB->op ) return 0; + if( (pA->flags & EP_Distinct)!=(pB->flags & EP_Distinct) ) return 0; + if( !sqlite3ExprCompare(pA->pLeft, pB->pLeft) ) return 0; + if( !sqlite3ExprCompare(pA->pRight, pB->pRight) ) return 0; + if( pA->pList ){ + if( pB->pList==0 ) return 0; + if( pA->pList->nExpr!=pB->pList->nExpr ) return 0; + for(i=0; ipList->nExpr; i++){ + if( !sqlite3ExprCompare(pA->pList->a[i].pExpr, pB->pList->a[i].pExpr) ){ + return 0; + } + } + }else if( pB->pList ){ + return 0; + } + if( pA->pSelect || pB->pSelect ) return 0; + if( pA->iTable!=pB->iTable || pA->iColumn!=pB->iColumn ) return 0; + if( pA->op!=TK_COLUMN && pA->token.z ){ + if( pB->token.z==0 ) return 0; + if( pB->token.n!=pA->token.n ) return 0; + if( sqlite3StrNICmp((char*)pA->token.z,(char*)pB->token.z,pB->token.n)!=0 ){ + return 0; + } + } + return 1; +} + + +/* +** Add a new element to the pAggInfo->aCol[] array. Return the index of +** the new element. Return a negative number if malloc fails. +*/ +static int addAggInfoColumn(sqlite3 *db, AggInfo *pInfo){ + int i; + pInfo->aCol = (AggInfo::AggInfo_col*)sqlite3ArrayAllocate( + db, + pInfo->aCol, + sizeof(pInfo->aCol[0]), + 3, + &pInfo->nColumn, + &pInfo->nColumnAlloc, + &i + ); + return i; +} + +/* +** Add a new element to the pAggInfo->aFunc[] array. Return the index of +** the new element. Return a negative number if malloc fails. +*/ +static int addAggInfoFunc(sqlite3 *db, AggInfo *pInfo){ + int i; + pInfo->aFunc = (AggInfo::AggInfo_func*)sqlite3ArrayAllocate( + db, + pInfo->aFunc, + sizeof(pInfo->aFunc[0]), + 3, + &pInfo->nFunc, + &pInfo->nFuncAlloc, + &i + ); + return i; +} + +/* +** This is an xFunc for walkExprTree() used to implement +** sqlite3ExprAnalyzeAggregates(). See sqlite3ExprAnalyzeAggregates +** for additional information. +** +** This routine analyzes the aggregate function at pExpr. +*/ +static int analyzeAggregate(void *pArg, Expr *pExpr){ + int i; + NameContext *pNC = (NameContext *)pArg; + Parse *pParse = pNC->pParse; + SrcList *pSrcList = pNC->pSrcList; + AggInfo *pAggInfo = pNC->pAggInfo; + + switch( pExpr->op ){ + case TK_AGG_COLUMN: + case TK_COLUMN: { + /* Check to see if the column is in one of the tables in the FROM + ** clause of the aggregate query */ + if( pSrcList ){ + SrcList::SrcList_item *pItem = pSrcList->a; + for(i=0; inSrc; i++, pItem++){ + AggInfo::AggInfo_col *pCol; + if( pExpr->iTable==pItem->iCursor ){ + /* If we reach this point, it means that pExpr refers to a table + ** that is in the FROM clause of the aggregate query. + ** + ** Make an entry for the column in pAggInfo->aCol[] if there + ** is not an entry there already. + */ + int k=0; + pCol = pAggInfo->aCol; + for(k=0; knColumn; k++, pCol++){ + if( pCol->iTable==pExpr->iTable && + pCol->iColumn==pExpr->iColumn ){ + break; + } + } + if( (k>=pAggInfo->nColumn) + && (k = addAggInfoColumn(pParse->db, pAggInfo))>=0 + ){ + pCol = &pAggInfo->aCol[k]; + pCol->pTab = pExpr->pTab; + pCol->iTable = pExpr->iTable; + pCol->iColumn = pExpr->iColumn; + pCol->iMem = pParse->nMem++; + pCol->iSorterColumn = -1; + pCol->pExpr = pExpr; + if( pAggInfo->pGroupBy ){ + int j, n; + ExprList *pGB = pAggInfo->pGroupBy; + ExprList::ExprList_item *pTerm = pGB->a; + n = pGB->nExpr; + for(j=0; jpExpr; + if( pE->op==TK_COLUMN && pE->iTable==pExpr->iTable && + pE->iColumn==pExpr->iColumn ){ + pCol->iSorterColumn = j; + break; + } + } + } + if( pCol->iSorterColumn<0 ){ + pCol->iSorterColumn = pAggInfo->nSortingColumn++; + } + } + /* There is now an entry for pExpr in pAggInfo->aCol[] (either + ** because it was there before or because we just created it). + ** Convert the pExpr to be a TK_AGG_COLUMN referring to that + ** pAggInfo->aCol[] entry. + */ + pExpr->pAggInfo = pAggInfo; + pExpr->op = TK_AGG_COLUMN; + pExpr->iAgg = k; + break; + } /* endif pExpr->iTable==pItem->iCursor */ + } /* end loop over pSrcList */ + } + return 1; + } + case TK_AGG_FUNCTION: { + /* The pNC->nDepth==0 test causes aggregate functions in subqueries + ** to be ignored */ + if( pNC->nDepth==0 ){ + /* Check to see if pExpr is a duplicate of another aggregate + ** function that is already in the pAggInfo structure + */ + AggInfo::AggInfo_func *pItem = pAggInfo->aFunc; + for(i=0; inFunc; i++, pItem++){ + if( sqlite3ExprCompare(pItem->pExpr, pExpr) ){ + break; + } + } + if( i>=pAggInfo->nFunc ){ + /* pExpr is original. Make a new entry in pAggInfo->aFunc[] + */ + u8 enc = ENC(pParse->db); + i = addAggInfoFunc(pParse->db, pAggInfo); + if( i>=0 ){ + pItem = &pAggInfo->aFunc[i]; + pItem->pExpr = pExpr; + pItem->iMem = pParse->nMem++; + pItem->pFunc = sqlite3FindFunction(pParse->db, + (char*)pExpr->token.z, pExpr->token.n, + pExpr->pList ? pExpr->pList->nExpr : 0, enc, 0); + if( pExpr->flags & EP_Distinct ){ + pItem->iDistinct = pParse->nTab++; + }else{ + pItem->iDistinct = -1; + } + } + } + /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry + */ + pExpr->iAgg = i; + pExpr->pAggInfo = pAggInfo; + return 1; + } + } + } + + /* Recursively walk subqueries looking for TK_COLUMN nodes that need + ** to be changed to TK_AGG_COLUMN. But increment nDepth so that + ** TK_AGG_FUNCTION nodes in subqueries will be unchanged. + */ + if( pExpr->pSelect ){ + pNC->nDepth++; + walkSelectExpr(pExpr->pSelect, analyzeAggregate, pNC); + pNC->nDepth--; + } + return 0; +} + +/* +** Analyze the given expression looking for aggregate functions and +** for variables that need to be added to the pParse->aAgg[] array. +** Make additional entries to the pParse->aAgg[] array as necessary. +** +** This routine should only be called after the expression has been +** analyzed by sqlite3ExprResolveNames(). +** +** If errors are seen, leave an error message in zErrMsg and return +** the number of errors. +*/ +int sqlite3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr){ + int nErr = pNC->pParse->nErr; + walkExprTree(pExpr, analyzeAggregate, pNC); + return pNC->pParse->nErr - nErr; +} + +/* +** Call sqlite3ExprAnalyzeAggregates() for every expression in an +** expression list. Return the number of errors. +** +** If an error is found, the analysis is cut short. +*/ +int sqlite3ExprAnalyzeAggList(NameContext *pNC, ExprList *pList){ + ExprList::ExprList_item *pItem; + int i; + int nErr = 0; + if( pList ){ + for(pItem=pList->a, i=0; nErr==0 && inExpr; i++, pItem++){ + nErr += sqlite3ExprAnalyzeAggregates(pNC, pItem->pExpr); + } + } + return nErr; +} diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/func.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/func.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,1575 @@ +/* +** 2002 February 23 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the C functions that implement various SQL +** functions of SQLite. +** +** There is only one exported symbol in this file - the function +** sqliteRegisterBuildinFunctions() found at the bottom of the file. +** All other code has file scope. +** +** $Id: func.cpp 1282 2008-11-13 09:31:33Z LarsPson $ +*/ +#include "sqliteInt.h" +#include +#include +#include +#include "vdbeInt.h" + + +/* +** Return the collating function associated with a function. +*/ +static CollSeq *sqlite3GetFuncCollSeq(sqlite3_context *context){ + return context->pColl; +} + +/* +** Implementation of the non-aggregate min() and max() functions +*/ +static void minmaxFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + int i; + int mask; /* 0 for min() or 0xffffffff for max() */ + int iBest; + CollSeq *pColl; + + if( argc==0 ) return; + mask = sqlite3_user_data(context)==0 ? 0 : -1; + pColl = sqlite3GetFuncCollSeq(context); + assert( pColl ); + assert( mask==-1 || mask==0 ); + iBest = 0; + if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; + for(i=1; i=0 ){ + iBest = i; + } + } + sqlite3_result_value(context, argv[iBest]); +} + +/* +** Return the type of the argument. +*/ +static void typeofFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const char *z = 0; + switch( sqlite3_value_type(argv[0]) ){ + case SQLITE_NULL: z = "null"; break; + case SQLITE_INTEGER: z = "integer"; break; + case SQLITE_TEXT: z = "text"; break; + case SQLITE_FLOAT: z = "real"; break; + case SQLITE_BLOB: z = "blob"; break; + } + sqlite3_result_text(context, z, -1, SQLITE_STATIC); +} + + +/* +** Implementation of the length() function +*/ +static void lengthFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + int len; + + assert( argc==1 ); + switch( sqlite3_value_type(argv[0]) ){ + case SQLITE_BLOB: + case SQLITE_INTEGER: + case SQLITE_FLOAT: { + sqlite3_result_int(context, sqlite3_value_bytes(argv[0])); + break; + } + case SQLITE_TEXT: { + const unsigned char *z = sqlite3_value_text(argv[0]); + if( z==0 ) return; + len = 0; + while( *z ){ + len++; + SQLITE_SKIP_UTF8(z); + } + sqlite3_result_int(context, len); + break; + } + default: { + sqlite3_result_null(context); + break; + } + } +} + +/* +** Implementation of the abs() function +*/ +static void absFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ + assert( argc==1 ); + switch( sqlite3_value_type(argv[0]) ){ + case SQLITE_INTEGER: { + i64 iVal = sqlite3_value_int64(argv[0]); + if( iVal<0 ){ + if( (iVal<<1)==0 ){ + sqlite3_result_error(context, "integer overflow", -1); + return; + } + iVal = -iVal; + } + sqlite3_result_int64(context, iVal); + break; + } + case SQLITE_NULL: { + sqlite3_result_null(context); + break; + } + default: { + double rVal = sqlite3_value_double(argv[0]); + if( rVal<0 ) rVal = -rVal; + sqlite3_result_double(context, rVal); + break; + } + } +} + +/* +** Implementation of the substr() function. +** +** substr(x,p1,p2) returns p2 characters of x[] beginning with p1. +** p1 is 1-indexed. So substr(x,1,1) returns the first character +** of x. If x is text, then we actually count UTF-8 characters. +** If x is a blob, then we count bytes. +** +** If p1 is negative, then we begin abs(p1) from the end of x[]. +*/ +static void substrFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const unsigned char *z; + const unsigned char *z2; + int len; + int p0type; + i64 p1, p2; + + assert( argc==3 || argc==2 ); + p0type = sqlite3_value_type(argv[0]); + if( p0type==SQLITE_BLOB ){ + len = sqlite3_value_bytes(argv[0]); + z = (const unsigned char*)sqlite3_value_blob(argv[0]); + if( z==0 ) return; + assert( len==sqlite3_value_bytes(argv[0]) ); + }else{ + z = sqlite3_value_text(argv[0]); + if( z==0 ) return; + len = 0; + for(z2=z; *z2; len++){ + SQLITE_SKIP_UTF8(z2); + } + } + p1 = sqlite3_value_int(argv[1]); + if( argc==3 ){ + p2 = sqlite3_value_int(argv[2]); + }else{ + p2 = SQLITE_MAX_LENGTH; + } + if( p1<0 ){ + p1 += len; + if( p1<0 ){ + p2 += p1; + p1 = 0; + } + }else if( p1>0 ){ + p1--; + } + if( p1+p2>len ){ + p2 = len-p1; + } + if( p0type!=SQLITE_BLOB ){ + while( *z && p1 ){ + SQLITE_SKIP_UTF8(z); + p1--; + } + for(z2=z; *z2 && p2; p2--){ + SQLITE_SKIP_UTF8(z2); + } + sqlite3_result_text(context, (char*)z, z2-z, SQLITE_TRANSIENT); + }else{ + if( p2<0 ) p2 = 0; + sqlite3_result_blob(context, (char*)&z[p1], p2, SQLITE_TRANSIENT); + } +} + +/* +** Implementation of the round() function +*/ +static void roundFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ + int n = 0; + double r; + char zBuf[500]; /* larger than the %f representation of the largest double */ + assert( argc==1 || argc==2 ); + if( argc==2 ){ + if( SQLITE_NULL==sqlite3_value_type(argv[1]) ) return; + n = sqlite3_value_int(argv[1]); + if( n>30 ) n = 30; + if( n<0 ) n = 0; + } + if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; + r = sqlite3_value_double(argv[0]); + sqlite3_snprintf(sizeof(zBuf),zBuf,"%.*f",n,r); + sqlite3AtoF(zBuf, &r); + sqlite3_result_double(context, r); +} + +/* +** Allocate nByte bytes of space using sqlite3_malloc(). If the +** allocation fails, call sqlite3_result_error_nomem() to notify +** the database handle that malloc() has failed. +*/ +static void *contextMalloc(sqlite3_context *context, int nByte){ + char *z = (char*)sqlite3_malloc(nByte); + if( !z && nByte>0 ){ + sqlite3_result_error_nomem(context); + } + return z; +} + +/* +** Implementation of the upper() and lower() SQL functions. +*/ +static void upperFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ + char *z1; + const char *z2; + int i, n; + if( argc<1 || SQLITE_NULL==sqlite3_value_type(argv[0]) ) return; + z2 = (char*)sqlite3_value_text(argv[0]); + n = sqlite3_value_bytes(argv[0]); + /* Verify that the call to _bytes() does not invalidate the _text() pointer */ + assert( z2==(char*)sqlite3_value_text(argv[0]) ); + if( z2 ){ + z1 = (char*)contextMalloc(context, n+1); + if( z1 ){ + memcpy(z1, z2, n+1); + for(i=0; z1[i]; i++){ + z1[i] = toupper(z1[i]); + } + sqlite3_result_text(context, z1, -1, sqlite3_free); + } + } +} +static void lowerFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ + char *z1; + const char *z2; + int i, n; + if( argc<1 || SQLITE_NULL==sqlite3_value_type(argv[0]) ) return; + z2 = (char*)sqlite3_value_text(argv[0]); + n = sqlite3_value_bytes(argv[0]); + /* Verify that the call to _bytes() does not invalidate the _text() pointer */ + assert( z2==(char*)sqlite3_value_text(argv[0]) ); + if( z2 ){ + z1 = (char*)contextMalloc(context, n+1); + if( z1 ){ + memcpy(z1, z2, n+1); + for(i=0; z1[i]; i++){ + z1[i] = tolower(z1[i]); + } + sqlite3_result_text(context, z1, -1, sqlite3_free); + } + } +} + +/* +** Implementation of the IFNULL(), NVL(), and COALESCE() functions. +** All three do the same thing. They return the first non-NULL +** argument. +*/ +static void ifnullFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + int i; + for(i=0; iSQLITE_MAX_LENGTH ){ + sqlite3_result_error_toobig(context); + return; + } + p = (unsigned char*)contextMalloc(context, n); + if( p ){ + sqlite3Randomness(n, p); + sqlite3_result_blob(context, (char*)p, n, sqlite3_free); + } +} + +/* +** Implementation of the last_insert_rowid() SQL function. The return +** value is the same as the sqlite3_last_insert_rowid() API function. +*/ +static void last_insert_rowid( + sqlite3_context *context, + int arg, + sqlite3_value **argv +){ + sqlite3 *db = (sqlite3*)sqlite3_user_data(context); + sqlite3_result_int64(context, sqlite3_last_insert_rowid(db)); +} + +/* +** Implementation of the changes() SQL function. The return value is the +** same as the sqlite3_changes() API function. +*/ +static void changes( + sqlite3_context *context, + int arg, + sqlite3_value **argv +){ + sqlite3 *db = (sqlite3*)sqlite3_user_data(context); + sqlite3_result_int(context, sqlite3_changes(db)); +} + +/* +** Implementation of the total_changes() SQL function. The return value is +** the same as the sqlite3_total_changes() API function. +*/ +static void total_changes( + sqlite3_context *context, + int arg, + sqlite3_value **argv +){ + sqlite3 *db = (sqlite3*)sqlite3_user_data(context); + sqlite3_result_int(context, sqlite3_total_changes(db)); +} + +/* +** A structure defining how to do GLOB-style comparisons. +*/ +struct compareInfo { + u8 matchAll; + u8 matchOne; + u8 matchSet; + u8 noCase; +}; + +/* +** For LIKE and GLOB matching on EBCDIC machines, assume that every +** character is exactly one byte in size. Also, all characters are +** able to participate in upper-case-to-lower-case mappings in EBCDIC +** whereas only characters less than 0x80 do in ASCII. +*/ +#if defined(SQLITE_EBCDIC) +# define sqlite3Utf8Read(A,B,C) (*(A++)) +# define GlogUpperToLower(A) A = sqlite3UpperToLower[A] +#else +# define GlogUpperToLower(A) if( A<0x80 ){ A = sqlite3UpperToLower[A]; } +#endif + +static const struct compareInfo globInfo = { '*', '?', '[', 0 }; +/* The correct SQL-92 behavior is for the LIKE operator to ignore +** case. Thus 'a' LIKE 'A' would be true. */ +static const struct compareInfo likeInfoNorm = { '%', '_', 0, 1 }; +/* If SQLITE_CASE_SENSITIVE_LIKE is defined, then the LIKE operator +** is case sensitive causing 'a' LIKE 'A' to be false */ +static const struct compareInfo likeInfoAlt = { '%', '_', 0, 0 }; + +/* +** Compare two UTF-8 strings for equality where the first string can +** potentially be a "glob" expression. Return true (1) if they +** are the same and false (0) if they are different. +** +** Globbing rules: +** +** '*' Matches any sequence of zero or more characters. +** +** '?' Matches exactly one character. +** +** [...] Matches one character from the enclosed list of +** characters. +** +** [^...] Matches one character not in the enclosed list. +** +** With the [...] and [^...] matching, a ']' character can be included +** in the list by making it the first character after '[' or '^'. A +** range of characters can be specified using '-'. Example: +** "[a-z]" matches any single lower-case letter. To match a '-', make +** it the last character in the list. +** +** This routine is usually quick, but can be N**2 in the worst case. +** +** Hints: to match '*' or '?', put them in "[]". Like this: +** +** abc[*]xyz Matches "abc*xyz" only +*/ +static int patternCompare( + const u8 *zPattern, /* The glob pattern */ + const u8 *zString, /* The string to compare against the glob */ + const struct compareInfo *pInfo, /* Information about how to do the compare */ + const int esc /* The escape character */ +){ + int c, c2; + int invert; + int seen; + u8 matchOne = pInfo->matchOne; + u8 matchAll = pInfo->matchAll; + u8 matchSet = pInfo->matchSet; + u8 noCase = pInfo->noCase; + int prevEscape = 0; /* True if the previous character was 'escape' */ + + while( (c = sqlite3Utf8Read(zPattern,0,&zPattern))!=0 ){ + if( !prevEscape && c==matchAll ){ + while( (c=sqlite3Utf8Read(zPattern,0,&zPattern)) == matchAll + || c == matchOne ){ + if( c==matchOne && sqlite3Utf8Read(zString, 0, &zString)==0 ){ + return 0; + } + } + if( c==0 ){ + return 1; + }else if( c==esc ){ + c = sqlite3Utf8Read(zPattern, 0, &zPattern); + if( c==0 ){ + return 0; + } + }else if( c==matchSet ){ + assert( esc==0 ); /* This is GLOB, not LIKE */ + assert( matchSet<0x80 ); /* '[' is a single-byte character */ + while( *zString && patternCompare(&zPattern[-1],zString,pInfo,esc)==0 ){ + SQLITE_SKIP_UTF8(zString); + } + return *zString!=0; + } + while( (c2 = sqlite3Utf8Read(zString,0,&zString))!=0 ){ + if( noCase ){ + GlogUpperToLower(c2); + GlogUpperToLower(c); + while( c2 != 0 && c2 != c ){ + c2 = sqlite3Utf8Read(zString, 0, &zString); + GlogUpperToLower(c2); + } + }else{ + while( c2 != 0 && c2 != c ){ + c2 = sqlite3Utf8Read(zString, 0, &zString); + } + } + if( c2==0 ) return 0; + if( patternCompare(zPattern,zString,pInfo,esc) ) return 1; + } + return 0; + }else if( !prevEscape && c==matchOne ){ + if( sqlite3Utf8Read(zString, 0, &zString)==0 ){ + return 0; + } + }else if( c==matchSet ){ + int prior_c = 0; + assert( esc==0 ); /* This only occurs for GLOB, not LIKE */ + seen = 0; + invert = 0; + c = sqlite3Utf8Read(zString, 0, &zString); + if( c==0 ) return 0; + c2 = sqlite3Utf8Read(zPattern, 0, &zPattern); + if( c2=='^' ){ + invert = 1; + c2 = sqlite3Utf8Read(zPattern, 0, &zPattern); + } + if( c2==']' ){ + if( c==']' ) seen = 1; + c2 = sqlite3Utf8Read(zPattern, 0, &zPattern); + } + while( c2 && c2!=']' ){ + if( c2=='-' && zPattern[0]!=']' && zPattern[0]!=0 && prior_c>0 ){ + c2 = sqlite3Utf8Read(zPattern, 0, &zPattern); + if( c>=prior_c && c<=c2 ) seen = 1; + prior_c = 0; + }else{ + if( c==c2 ){ + seen = 1; + } + prior_c = c2; + } + c2 = sqlite3Utf8Read(zPattern, 0, &zPattern); + } + if( c2==0 || (seen ^ invert)==0 ){ + return 0; + } + }else if( esc==c && !prevEscape ){ + prevEscape = 1; + }else{ + c2 = sqlite3Utf8Read(zString, 0, &zString); + if( noCase ){ + GlogUpperToLower(c); + GlogUpperToLower(c2); + } + if( c!=c2 ){ + return 0; + } + prevEscape = 0; + } + } + return *zString==0; +} + +/* +** Count the number of times that the LIKE operator (or GLOB which is +** just a variation of LIKE) gets called. This is used for testing +** only. +*/ +#ifdef SQLITE_TEST +int sqlite3_like_count = 0; +#endif + + +/* +** Implementation of the like() SQL function. This function implements +** the build-in LIKE operator. The first argument to the function is the +** pattern and the second argument is the string. So, the SQL statements: +** +** A LIKE B +** +** is implemented as like(B,A). +** +** This same function (with a different compareInfo structure) computes +** the GLOB operator. +*/ +static void likeFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const unsigned char *zA, *zB; + int escape = 0; + + zB = sqlite3_value_text(argv[0]); + zA = sqlite3_value_text(argv[1]); + + /* Limit the length of the LIKE or GLOB pattern to avoid problems + ** of deep recursion and N*N behavior in patternCompare(). + */ + if( sqlite3_value_bytes(argv[0])>SQLITE_MAX_LIKE_PATTERN_LENGTH ){ + sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1); + return; + } + assert( zB==sqlite3_value_text(argv[0]) ); /* Encoding did not change */ + + if( argc==3 ){ + /* The escape character string must consist of a single UTF-8 character. + ** Otherwise, return an error. + */ + const unsigned char *zEsc = sqlite3_value_text(argv[2]); + if( zEsc==0 ) return; + if( sqlite3Utf8CharLen((char*)zEsc, -1)!=1 ){ + sqlite3_result_error(context, + "ESCAPE expression must be a single character", -1); + return; + } + escape = sqlite3Utf8Read(zEsc, 0, &zEsc); + } + if( zA && zB ){ + compareInfo *pInfo = (compareInfo*)sqlite3_user_data(context); +#ifdef SQLITE_TEST + sqlite3_like_count++; +#endif + + sqlite3_result_int(context, patternCompare(zB, zA, pInfo, escape)); + } +} + +/* +** Implementation of the NULLIF(x,y) function. The result is the first +** argument if the arguments are different. The result is NULL if the +** arguments are equal to each other. +*/ +static void nullifFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + CollSeq *pColl = sqlite3GetFuncCollSeq(context); + if( sqlite3MemCompare(argv[0], argv[1], pColl)!=0 ){ + sqlite3_result_value(context, argv[0]); + } +} + +/* +** Implementation of the VERSION(*) function. The result is the version +** of the SQLite library that is running. +*/ +static void versionFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + sqlite3_result_text(context, sqlite3_version, -1, SQLITE_STATIC); +} + +/* Array for converting from half-bytes (nybbles) into ASCII hex +** digits. */ +static const char hexdigits[] = { + '0', '1', '2', '3', '4', '5', '6', '7', + '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' +}; + +/* +** EXPERIMENTAL - This is not an official function. The interface may +** change. This function may disappear. Do not write code that depends +** on this function. +** +** Implementation of the QUOTE() function. This function takes a single +** argument. If the argument is numeric, the return value is the same as +** the argument. If the argument is NULL, the return value is the string +** "NULL". Otherwise, the argument is enclosed in single quotes with +** single-quote escapes. +*/ +static void quoteFunc(sqlite3_context *context, int argc, sqlite3_value **argv){ + if( argc<1 ) return; + switch( sqlite3_value_type(argv[0]) ){ + case SQLITE_NULL: { + sqlite3_result_text(context, "NULL", 4, SQLITE_STATIC); + break; + } + case SQLITE_INTEGER: + case SQLITE_FLOAT: { + sqlite3_result_value(context, argv[0]); + break; + } + case SQLITE_BLOB: { + char *zText = 0; + char const *zBlob = (const char*)sqlite3_value_blob(argv[0]); + int nBlob = sqlite3_value_bytes(argv[0]); + assert( zBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */ + + if( 2*nBlob+4>SQLITE_MAX_LENGTH ){ + sqlite3_result_error_toobig(context); + return; + } + zText = (char *)contextMalloc(context, (2*nBlob)+4); + if( zText ){ + int i; + for(i=0; i>4)&0x0F]; + zText[(i*2)+3] = hexdigits[(zBlob[i])&0x0F]; + } + zText[(nBlob*2)+2] = '\''; + zText[(nBlob*2)+3] = '\0'; + zText[0] = 'X'; + zText[1] = '\''; + sqlite3_result_text(context, zText, -1, SQLITE_TRANSIENT); + sqlite3_free(zText); + } + break; + } + case SQLITE_TEXT: { + int i,j; + u64 n; + const unsigned char *zArg = sqlite3_value_text(argv[0]); + char *z; + + if( zArg==0 ) return; + for(i=0, n=0; zArg[i]; i++){ if( zArg[i]=='\'' ) n++; } + if( i+n+3>SQLITE_MAX_LENGTH ){ + sqlite3_result_error_toobig(context); + return; + } + z = (char*)contextMalloc(context, i+n+3); + if( z ){ + z[0] = '\''; + for(i=0, j=1; zArg[i]; i++){ + z[j++] = zArg[i]; + if( zArg[i]=='\'' ){ + z[j++] = '\''; + } + } + z[j++] = '\''; + z[j] = 0; + sqlite3_result_text(context, z, j, sqlite3_free); + } + } + } +} + +/* +** The hex() function. Interpret the argument as a blob. Return +** a hexadecimal rendering as text. +*/ +static void hexFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + int i, n; + const unsigned char *pBlob; + char *zHex, *z; + assert( argc==1 ); + pBlob = (const unsigned char*)sqlite3_value_blob(argv[0]); + n = sqlite3_value_bytes(argv[0]); + if( n*2+1>SQLITE_MAX_LENGTH ){ + sqlite3_result_error_toobig(context); + return; + } + assert( pBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */ + z = zHex = (char*)contextMalloc(context, n*2 + 1); + if( zHex ){ + for(i=0; i>4)&0xf]; + *(z++) = hexdigits[c&0xf]; + } + *z = 0; + sqlite3_result_text(context, zHex, n*2, sqlite3_free); + } +} + +/* +** The zeroblob(N) function returns a zero-filled blob of size N bytes. +*/ +static void zeroblobFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + i64 n; + assert( argc==1 ); + n = sqlite3_value_int64(argv[0]); + if( n>SQLITE_MAX_LENGTH ){ + sqlite3_result_error_toobig(context); + }else{ + sqlite3_result_zeroblob(context, n); + } +} + +/* +** The replace() function. Three arguments are all strings: call +** them A, B, and C. The result is also a string which is derived +** from A by replacing every occurance of B with C. The match +** must be exact. Collating sequences are not used. +*/ +static void replaceFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const unsigned char *zStr; /* The input string A */ + const unsigned char *zPattern; /* The pattern string B */ + const unsigned char *zRep; /* The replacement string C */ + unsigned char *zOut; /* The output */ + int nStr; /* Size of zStr */ + int nPattern; /* Size of zPattern */ + int nRep; /* Size of zRep */ + i64 nOut; /* Maximum size of zOut */ + int loopLimit; /* Last zStr[] that might match zPattern[] */ + int i, j; /* Loop counters */ + + assert( argc==3 ); + zStr = sqlite3_value_text(argv[0]); + if( zStr==0 ) return; + nStr = sqlite3_value_bytes(argv[0]); + assert( zStr==sqlite3_value_text(argv[0]) ); /* No encoding change */ + zPattern = sqlite3_value_text(argv[1]); + if( zPattern==0 || zPattern[0]==0 ) return; + nPattern = sqlite3_value_bytes(argv[1]); + assert( zPattern==sqlite3_value_text(argv[1]) ); /* No encoding change */ + zRep = sqlite3_value_text(argv[2]); + if( zRep==0 ) return; + nRep = sqlite3_value_bytes(argv[2]); + assert( zRep==sqlite3_value_text(argv[2]) ); + nOut = nStr + 1; + assert( nOut=SQLITE_MAX_LENGTH ){ + sqlite3_result_error_toobig(context); + sqlite3_free(zOut); + return; + } + zOld = zOut; + zOut = (unsigned char*)sqlite3_realloc(zOut, (int)nOut); + if( zOut==0 ){ + sqlite3_result_error_nomem(context); + sqlite3_free(zOld); + return; + } + memcpy(&zOut[j], zRep, nRep); + j += nRep; + i += nPattern-1; + } + } + assert( j+nStr-i+1==nOut ); + memcpy(&zOut[j], &zStr[i], nStr-i); + j += nStr - i; + assert( j<=nOut ); + zOut[j] = 0; + sqlite3_result_text(context, (char*)zOut, j, sqlite3_free); +} + +/* +** Implementation of the TRIM(), LTRIM(), and RTRIM() functions. +** The userdata is 0x1 for left trim, 0x2 for right trim, 0x3 for both. +*/ +static void trimFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const unsigned char *zIn; /* Input string */ + const unsigned char *zCharSet; /* Set of characters to trim */ + int nIn; /* Number of bytes in input */ + int flags; /* 1: trimleft 2: trimright 3: trim */ + int i; /* Loop counter */ + unsigned char *aLen; /* Length of each character in zCharSet */ + unsigned char **azChar; /* Individual characters in zCharSet */ + int nChar; /* Number of characters in zCharSet */ + + if( sqlite3_value_type(argv[0])==SQLITE_NULL ){ + return; + } + zIn = sqlite3_value_text(argv[0]); + if( zIn==0 ) return; + nIn = sqlite3_value_bytes(argv[0]); + assert( zIn==sqlite3_value_text(argv[0]) ); + if( argc==1 ){ + static const unsigned char lenOne[] = { 1 }; + static const unsigned char *azOne[] = { (u8*)" " }; + nChar = 1; + aLen = (u8*)lenOne; + azChar = (unsigned char **)azOne; + zCharSet = 0; + }else if( (zCharSet = sqlite3_value_text(argv[1]))==0 ){ + return; + }else{ + const unsigned char *z; + for(z=zCharSet, nChar=0; *z; nChar++){ + SQLITE_SKIP_UTF8(z); + } + if( nChar>0 ){ + azChar = (unsigned char**)contextMalloc(context, nChar*(sizeof(char*)+1)); + if( azChar==0 ){ + return; + } + aLen = (unsigned char*)&azChar[nChar]; + for(z=zCharSet, nChar=0; *z; nChar++){ + azChar[nChar] = (unsigned char *)z; + SQLITE_SKIP_UTF8(z); + aLen[nChar] = z - azChar[nChar]; + } + } + } + if( nChar>0 ){ + flags = (int)sqlite3_user_data(context); + if( flags & 1 ){ + while( nIn>0 ){ + int len; + for(i=0; i=nChar ) break; + zIn += len; + nIn -= len; + } + } + if( flags & 2 ){ + while( nIn>0 ){ + int len; + for(i=0; i=nChar ) break; + nIn -= len; + } + } + if( zCharSet ){ + sqlite3_free(azChar); + } + } + sqlite3_result_text(context, (char*)zIn, nIn, SQLITE_TRANSIENT); +} + +#ifdef SQLITE_SOUNDEX +/* +** Compute the soundex encoding of a word. +*/ +static void soundexFunc( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + char zResult[8]; + const u8 *zIn; + int i, j; + static const unsigned char iCode[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0, + 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0, + 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0, + }; + assert( argc==1 ); + zIn = (u8*)sqlite3_value_text(argv[0]); + if( zIn==0 ) zIn = (u8*)""; + for(i=0; zIn[i] && !isalpha(zIn[i]); i++){} + if( zIn[i] ){ + u8 prevcode = iCode[zIn[i]&0x7f]; + zResult[0] = toupper(zIn[i]); + for(j=1; j<4 && zIn[i]; i++){ + int code = iCode[zIn[i]&0x7f]; + if( code>0 ){ + if( code!=prevcode ){ + prevcode = code; + zResult[j++] = code + '0'; + } + }else{ + prevcode = 0; + } + } + while( j<4 ){ + zResult[j++] = '0'; + } + zResult[j] = 0; + sqlite3_result_text(context, zResult, 4, SQLITE_TRANSIENT); + }else{ + sqlite3_result_text(context, "?000", 4, SQLITE_STATIC); + } +} +#endif + +#ifndef SQLITE_OMIT_LOAD_EXTENSION +/* +** A function that loads a shared-library extension then returns NULL. +*/ +static void loadExt(sqlite3_context *context, int argc, sqlite3_value **argv){ + const char *zFile = (const char *)sqlite3_value_text(argv[0]); + const char *zProc; + sqlite3 *db = (sqlite3*)sqlite3_user_data(context); + char *zErrMsg = 0; + + if( argc==2 ){ + zProc = (const char *)sqlite3_value_text(argv[1]); + }else{ + zProc = 0; + } + if( zFile && sqlite3_load_extension(db, zFile, zProc, &zErrMsg) ){ + sqlite3_result_error(context, zErrMsg, -1); + sqlite3_free(zErrMsg); + } +} +#endif + +#ifdef SQLITE_TEST +/* +** This function generates a string of random characters. Used for +** generating test data. +*/ +static void randStr(sqlite3_context *context, int argc, sqlite3_value **argv){ + static const unsigned char zSrc[] = + "abcdefghijklmnopqrstuvwxyz" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "0123456789" + ".-!,:*^+=_|?/<> "; + int iMin, iMax, n, r, i; + unsigned char zBuf[1000]; + + /* It used to be possible to call randstr() with any number of arguments, + ** but now it is registered with SQLite as requiring exactly 2. + */ + assert(argc==2); + + iMin = sqlite3_value_int(argv[0]); + if( iMin<0 ) iMin = 0; + if( iMin>=sizeof(zBuf) ) iMin = sizeof(zBuf)-1; + iMax = sqlite3_value_int(argv[1]); + if( iMax=sizeof(zBuf) ) iMax = sizeof(zBuf)-1; + n = iMin; + if( iMax>iMin ){ + sqlite3Randomness(sizeof(r), &r); + r &= 0x7fffffff; + n += r%(iMax + 1 - iMin); + } + assert( ncnt++; + if( type==SQLITE_INTEGER ){ + i64 v = sqlite3_value_int64(argv[0]); + p->rSum += v; + if( (p->approx|p->overflow)==0 ){ + i64 iNewSum = p->iSum + v; + int s1 = p->iSum >> (sizeof(i64)*8-1); + int s2 = v >> (sizeof(i64)*8-1); + int s3 = iNewSum >> (sizeof(i64)*8-1); + p->overflow = (s1&s2&~s3) | (~s1&~s2&s3); + p->iSum = iNewSum; + } + }else{ + p->rSum += sqlite3_value_double(argv[0]); + p->approx = 1; + } + } +} +static void sumFinalize(sqlite3_context *context){ + SumCtx *p; + p = (SumCtx*)sqlite3_aggregate_context(context, 0); + if( p && p->cnt>0 ){ + if( p->overflow ){ + sqlite3_result_error(context,"integer overflow",-1); + }else if( p->approx ){ + sqlite3_result_double(context, p->rSum); + }else{ + sqlite3_result_int64(context, p->iSum); + } + } +} +static void avgFinalize(sqlite3_context *context){ + SumCtx *p; + p = (SumCtx*)sqlite3_aggregate_context(context, 0); + if( p && p->cnt>0 ){ + sqlite3_result_double(context, p->rSum/(double)p->cnt); + } +} +static void totalFinalize(sqlite3_context *context){ + SumCtx *p; + p = (SumCtx*)sqlite3_aggregate_context(context, 0); + sqlite3_result_double(context, p ? p->rSum : 0.0); +} + +/* +** The following structure keeps track of state information for the +** count() aggregate function. +*/ +typedef struct CountCtx CountCtx; +struct CountCtx { + i64 n; +}; + +/* +** Routines to implement the count() aggregate function. +*/ +static void countStep(sqlite3_context *context, int argc, sqlite3_value **argv){ + CountCtx *p; + p = (CountCtx*)sqlite3_aggregate_context(context, sizeof(*p)); + if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && p ){ + p->n++; + } +} +static void countFinalize(sqlite3_context *context){ + CountCtx *p; + p = (CountCtx*)sqlite3_aggregate_context(context, 0); + sqlite3_result_int64(context, p ? p->n : 0); +} + +/* +** Routines to implement min() and max() aggregate functions. +*/ +static void minmaxStep(sqlite3_context *context, int argc, sqlite3_value **argv){ + Mem *pArg = (Mem *)argv[0]; + Mem *pBest; + + if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; + pBest = (Mem *)sqlite3_aggregate_context(context, sizeof(*pBest)); + if( !pBest ) return; + + if( pBest->flags ){ + int max; + int cmp; + CollSeq *pColl = sqlite3GetFuncCollSeq(context); + /* This step function is used for both the min() and max() aggregates, + ** the only difference between the two being that the sense of the + ** comparison is inverted. For the max() aggregate, the + ** sqlite3_user_data() function returns (void *)-1. For min() it + ** returns (void *)db, where db is the sqlite3* database pointer. + ** Therefore the next statement sets variable 'max' to 1 for the max() + ** aggregate, or 0 for min(). + */ + max = sqlite3_user_data(context)!=0; + cmp = sqlite3MemCompare(pBest, pArg, pColl); + if( (max && cmp<0) || (!max && cmp>0) ){ + sqlite3VdbeMemCopy(pBest, pArg); + } + }else{ + sqlite3VdbeMemCopy(pBest, pArg); + } +} +static void minMaxFinalize(sqlite3_context *context){ + sqlite3_value *pRes; + pRes = (sqlite3_value *)sqlite3_aggregate_context(context, 0); + if( pRes ){ + if( pRes->flags ){ + sqlite3_result_value(context, pRes); + } + sqlite3VdbeMemRelease(pRes); + } +} + +/* +** group_concat(EXPR, ?SEPARATOR?) +*/ +static void groupConcatStep( + sqlite3_context *context, + int argc, + sqlite3_value **argv +){ + const char *zVal; + StrAccum *pAccum; + const char *zSep; + int nVal, nSep; + if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; + pAccum = (StrAccum*)sqlite3_aggregate_context(context, sizeof(*pAccum)); + + if( pAccum ){ + pAccum->useMalloc = 1; + if( pAccum->nChar ){ + if( argc==2 ){ + zSep = (char*)sqlite3_value_text(argv[1]); + nSep = sqlite3_value_bytes(argv[1]); + }else{ + zSep = ","; + nSep = 1; + } + sqlite3StrAccumAppend(pAccum, zSep, nSep); + } + zVal = (char*)sqlite3_value_text(argv[0]); + nVal = sqlite3_value_bytes(argv[0]); + sqlite3StrAccumAppend(pAccum, zVal, nVal); + } +} +static void groupConcatFinalize(sqlite3_context *context){ + StrAccum *pAccum; + pAccum = (StrAccum*)sqlite3_aggregate_context(context, 0); + if( pAccum ){ + if( pAccum->tooBig ){ + sqlite3_result_error_toobig(context); + }else if( pAccum->mallocFailed ){ + sqlite3_result_error_nomem(context); + }else{ + sqlite3_result_text(context, sqlite3StrAccumFinish(pAccum), -1, + sqlite3_free); + } + } +} + +/* +** This function registered all of the above C functions as SQL +** functions. This should be the only routine in this file with +** external linkage. +*/ +void sqlite3RegisterBuiltinFunctions(sqlite3 *db){ + static const struct { + char *zName; + signed char nArg; + u8 argType; /* ff: db 1: 0, 2: 1, 3: 2,... N: N-1. */ + u8 eTextRep; /* 1: UTF-16. 0: UTF-8 */ + u8 needCollSeq; + void (*xFunc)(sqlite3_context*,int,sqlite3_value **); + } aFuncs[] = { + { "min", -1, 0, SQLITE_UTF8, 1, minmaxFunc }, + { "min", 0, 0, SQLITE_UTF8, 1, 0 }, + { "max", -1, 1, SQLITE_UTF8, 1, minmaxFunc }, + { "max", 0, 1, SQLITE_UTF8, 1, 0 }, + { "typeof", 1, 0, SQLITE_UTF8, 0, typeofFunc }, + { "length", 1, 0, SQLITE_UTF8, 0, lengthFunc }, + { "substr", 2, 0, SQLITE_UTF8, 0, substrFunc }, + { "substr", 3, 0, SQLITE_UTF8, 0, substrFunc }, + { "abs", 1, 0, SQLITE_UTF8, 0, absFunc }, + { "round", 1, 0, SQLITE_UTF8, 0, roundFunc }, + { "round", 2, 0, SQLITE_UTF8, 0, roundFunc }, + { "upper", 1, 0, SQLITE_UTF8, 0, upperFunc }, + { "lower", 1, 0, SQLITE_UTF8, 0, lowerFunc }, + { "coalesce", -1, 0, SQLITE_UTF8, 0, ifnullFunc }, + { "coalesce", 0, 0, SQLITE_UTF8, 0, 0 }, + { "coalesce", 1, 0, SQLITE_UTF8, 0, 0 }, + { "hex", 1, 0, SQLITE_UTF8, 0, hexFunc }, + { "ifnull", 2, 0, SQLITE_UTF8, 1, ifnullFunc }, + { "random", -1, 0, SQLITE_UTF8, 0, randomFunc }, + { "randomblob", 1, 0, SQLITE_UTF8, 0, randomBlob }, + { "nullif", 2, 0, SQLITE_UTF8, 1, nullifFunc }, + { "sqlite_version", 0, 0, SQLITE_UTF8, 0, versionFunc}, + { "quote", 1, 0, SQLITE_UTF8, 0, quoteFunc }, + { "last_insert_rowid", 0, 0xff, SQLITE_UTF8, 0, last_insert_rowid }, + { "changes", 0, 0xff, SQLITE_UTF8, 0, changes }, + { "total_changes", 0, 0xff, SQLITE_UTF8, 0, total_changes }, + { "replace", 3, 0, SQLITE_UTF8, 0, replaceFunc }, + { "ltrim", 1, 1, SQLITE_UTF8, 0, trimFunc }, + { "ltrim", 2, 1, SQLITE_UTF8, 0, trimFunc }, + { "rtrim", 1, 2, SQLITE_UTF8, 0, trimFunc }, + { "rtrim", 2, 2, SQLITE_UTF8, 0, trimFunc }, + { "trim", 1, 3, SQLITE_UTF8, 0, trimFunc }, + { "trim", 2, 3, SQLITE_UTF8, 0, trimFunc }, + { "zeroblob", 1, 0, SQLITE_UTF8, 0, zeroblobFunc }, +#ifdef SQLITE_SOUNDEX + { "soundex", 1, 0, SQLITE_UTF8, 0, soundexFunc}, +#endif +#ifndef SQLITE_OMIT_LOAD_EXTENSION + { "load_extension", 1, 0xff, SQLITE_UTF8, 0, loadExt }, + { "load_extension", 2, 0xff, SQLITE_UTF8, 0, loadExt }, +#endif +#ifdef SQLITE_TEST + { "randstr", 2, 0, SQLITE_UTF8, 0, randStr }, + { "test_destructor", 1, 0xff, SQLITE_UTF8, 0, test_destructor}, + { "test_destructor_count", 0, 0, SQLITE_UTF8, 0, test_destructor_count}, + { "test_auxdata", -1, 0, SQLITE_UTF8, 0, test_auxdata}, + { "test_error", 1, 0, SQLITE_UTF8, 0, test_error}, +#endif + }; + static const struct { + char *zName; + signed char nArg; + u8 argType; + u8 needCollSeq; + void (*xStep)(sqlite3_context*,int,sqlite3_value**); + void (*xFinalize)(sqlite3_context*); + } aAggs[] = { + { "min", 1, 0, 1, minmaxStep, minMaxFinalize }, + { "max", 1, 1, 1, minmaxStep, minMaxFinalize }, + { "sum", 1, 0, 0, sumStep, sumFinalize }, + { "total", 1, 0, 0, sumStep, totalFinalize }, + { "avg", 1, 0, 0, sumStep, avgFinalize }, + { "count", 0, 0, 0, countStep, countFinalize }, + { "count", 1, 0, 0, countStep, countFinalize }, + { "group_concat", 1, 0, 0, groupConcatStep, groupConcatFinalize }, + { "group_concat", 2, 0, 0, groupConcatStep, groupConcatFinalize }, + }; + int i; + + for(i=0; ineedCollSeq = 1; + } + } + } +#ifndef SQLITE_OMIT_ALTERTABLE + sqlite3AlterFunctions(db); +#endif +#ifndef SQLITE_OMIT_PARSER + sqlite3AttachFunctions(db); +#endif + for(i=0; ineedCollSeq = 1; + } + } + } + sqlite3RegisterDateTimeFunctions(db); + if( !db->mallocFailed ){ + int rc = sqlite3_overload_function(db, "MATCH", 2); + assert( rc==SQLITE_NOMEM || rc==SQLITE_OK ); + if( rc==SQLITE_NOMEM ){ + db->mallocFailed = 1; + } + } +#ifdef SQLITE_SSE + (void)sqlite3SseFunctions(db); +#endif +#ifdef SQLITE_CASE_SENSITIVE_LIKE + sqlite3RegisterLikeFunctions(db, 1); +#else + sqlite3RegisterLikeFunctions(db, 0); +#endif +} + +/* +** Set the LIKEOPT flag on the 2-argument function with the given name. +*/ +static void setLikeOptFlag(sqlite3 *db, const char *zName, int flagVal){ + FuncDef *pDef; + pDef = sqlite3FindFunction(db, zName, strlen(zName), 2, SQLITE_UTF8, 0); + if( pDef ){ + pDef->flags = flagVal; + } +} + +/* +** Register the built-in LIKE and GLOB functions. The caseSensitive +** parameter determines whether or not the LIKE operator is case +** sensitive. GLOB is always case sensitive. +*/ +void sqlite3RegisterLikeFunctions(sqlite3 *db, int caseSensitive){ + struct compareInfo *pInfo; + if( caseSensitive ){ + pInfo = (struct compareInfo*)&likeInfoAlt; + }else{ + pInfo = (struct compareInfo*)&likeInfoNorm; + } + sqlite3CreateFunc(db, "like", 2, SQLITE_UTF8, pInfo, likeFunc, 0, 0); + sqlite3CreateFunc(db, "like", 3, SQLITE_UTF8, pInfo, likeFunc, 0, 0); + sqlite3CreateFunc(db, "glob", 2, SQLITE_UTF8, + (struct compareInfo*)&globInfo, likeFunc, 0,0); + setLikeOptFlag(db, "glob", SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE); + setLikeOptFlag(db, "like", + caseSensitive ? (SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE) : SQLITE_FUNC_LIKE); +} + +/* +** pExpr points to an expression which implements a function. If +** it is appropriate to apply the LIKE optimization to that function +** then set aWc[0] through aWc[2] to the wildcard characters and +** return TRUE. If the function is not a LIKE-style function then +** return FALSE. +*/ +int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocase, char *aWc){ + FuncDef *pDef; + if( pExpr->op!=TK_FUNCTION || !pExpr->pList ){ + return 0; + } + if( pExpr->pList->nExpr!=2 ){ + return 0; + } + pDef = sqlite3FindFunction(db, (char*)pExpr->token.z, pExpr->token.n, 2, + SQLITE_UTF8, 0); + if( pDef==0 || (pDef->flags & SQLITE_FUNC_LIKE)==0 ){ + return 0; + } + + /* The memcpy() statement assumes that the wildcard characters are + ** the first three statements in the compareInfo structure. The + ** asserts() that follow verify that assumption + */ + memcpy(aWc, pDef->pUserData, 3); + assert( (char*)&likeInfoAlt == (char*)&likeInfoAlt.matchAll ); + assert( &((char*)&likeInfoAlt)[1] == (char*)&likeInfoAlt.matchOne ); + assert( &((char*)&likeInfoAlt)[2] == (char*)&likeInfoAlt.matchSet ); + *pIsNocase = (pDef->flags & SQLITE_FUNC_CASE)==0; + return 1; +} diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/hash.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/hash.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,418 @@ +/* +** 2001 September 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This is the implementation of generic hash-tables +** used in SQLite. +** +** $Id: hash.cpp 1282 2008-11-13 09:31:33Z LarsPson $ +*/ +#include "sqliteInt.h" +#include + +/* Turn bulk memory into a hash table object by initializing the +** fields of the Hash structure. +** +** "pNew" is a pointer to the hash table that is to be initialized. +** keyClass is one of the constants SQLITE_HASH_INT, SQLITE_HASH_POINTER, +** SQLITE_HASH_BINARY, or SQLITE_HASH_STRING. The value of keyClass +** determines what kind of key the hash table will use. "copyKey" is +** true if the hash table should make its own private copy of keys and +** false if it should just use the supplied pointer. CopyKey only makes +** sense for SQLITE_HASH_STRING and SQLITE_HASH_BINARY and is ignored +** for other key classes. +*/ +void sqlite3HashInit(Hash *pNew, int keyClass, int copyKey){ + assert( pNew!=0 ); + assert( keyClass>=SQLITE_HASH_STRING && keyClass<=SQLITE_HASH_BINARY ); + pNew->keyClass = keyClass; +#if 0 + if( keyClass==SQLITE_HASH_POINTER || keyClass==SQLITE_HASH_INT ) copyKey = 0; +#endif + pNew->copyKey = copyKey; + pNew->first = 0; + pNew->count = 0; + pNew->htsize = 0; + pNew->ht = 0; +} + +/* Remove all entries from a hash table. Reclaim all memory. +** Call this routine to delete a hash table or to reset a hash table +** to the empty state. +*/ +void sqlite3HashClear(Hash *pH){ + HashElem *elem; /* For looping over all elements of the table */ + + assert( pH!=0 ); + elem = pH->first; + pH->first = 0; + if( pH->ht ) sqlite3_free(pH->ht); + pH->ht = 0; + pH->htsize = 0; + while( elem ){ + HashElem *next_elem = elem->next; + if( pH->copyKey && elem->pKey ){ + sqlite3_free(elem->pKey); + } + sqlite3_free(elem); + elem = next_elem; + } + pH->count = 0; +} + +#if 0 /* NOT USED */ +/* +** Hash and comparison functions when the mode is SQLITE_HASH_INT +*/ +static int intHash(const void *pKey, int nKey){ + return nKey ^ (nKey<<8) ^ (nKey>>8); +} +static int intCompare(const void *pKey1, int n1, const void *pKey2, int n2){ + return n2 - n1; +} +#endif + +#if 0 /* NOT USED */ +/* +** Hash and comparison functions when the mode is SQLITE_HASH_POINTER +*/ +static int ptrHash(const void *pKey, int nKey){ + uptr x = Addr(pKey); + return x ^ (x<<8) ^ (x>>8); +} +static int ptrCompare(const void *pKey1, int n1, const void *pKey2, int n2){ + if( pKey1==pKey2 ) return 0; + if( pKey1 0 ){ + h = (h<<3) ^ h ^ sqlite3UpperToLower[(unsigned char)*z++]; + nKey--; + } + return h & 0x7fffffff; +} +static int strCompare(const void *pKey1, int n1, const void *pKey2, int n2){ + if( n1!=n2 ) return 1; + return sqlite3StrNICmp((const char*)pKey1,(const char*)pKey2,n1); +} + +/* +** Hash and comparison functions when the mode is SQLITE_HASH_BINARY +*/ +static int binHash(const void *pKey, int nKey){ + int h = 0; + const char *z = (const char *)pKey; + while( nKey-- > 0 ){ + h = (h<<3) ^ h ^ *(z++); + } + return h & 0x7fffffff; +} +static int binCompare(const void *pKey1, int n1, const void *pKey2, int n2){ + if( n1!=n2 ) return 1; + return memcmp(pKey1,pKey2,n1); +} + +/* +** Return a pointer to the appropriate hash function given the key class. +** +** The C syntax in this function definition may be unfamilar to some +** programmers, so we provide the following additional explanation: +** +** The name of the function is "hashFunction". The function takes a +** single parameter "keyClass". The return value of hashFunction() +** is a pointer to another function. Specifically, the return value +** of hashFunction() is a pointer to a function that takes two parameters +** with types "const void*" and "int" and returns an "int". +*/ +static int (*hashFunction(int keyClass))(const void*,int){ +#if 0 /* HASH_INT and HASH_POINTER are never used */ + switch( keyClass ){ + case SQLITE_HASH_INT: return &intHash; + case SQLITE_HASH_POINTER: return &ptrHash; + case SQLITE_HASH_STRING: return &strHash; + case SQLITE_HASH_BINARY: return &binHash;; + default: break; + } + return 0; +#else + if( keyClass==SQLITE_HASH_STRING ){ + return &strHash; + }else{ + assert( keyClass==SQLITE_HASH_BINARY ); + return &binHash; + } +#endif +} + +/* +** Return a pointer to the appropriate hash function given the key class. +** +** For help in interpreted the obscure C code in the function definition, +** see the header comment on the previous function. +*/ +static int (*compareFunction(int keyClass))(const void*,int,const void*,int){ +#if 0 /* HASH_INT and HASH_POINTER are never used */ + switch( keyClass ){ + case SQLITE_HASH_INT: return &intCompare; + case SQLITE_HASH_POINTER: return &ptrCompare; + case SQLITE_HASH_STRING: return &strCompare; + case SQLITE_HASH_BINARY: return &binCompare; + default: break; + } + return 0; +#else + if( keyClass==SQLITE_HASH_STRING ){ + return &strCompare; + }else{ + assert( keyClass==SQLITE_HASH_BINARY ); + return &binCompare; + } +#endif +} + +/* Link an element into the hash table +*/ +static void insertElement( + Hash *pH, /* The complete hash table */ + Hash::_ht *pEntry, /* The entry into which pNew is inserted */ + HashElem *pNew /* The element to be inserted */ +){ + HashElem *pHead; /* First element already in pEntry */ + pHead = pEntry->chain; + if( pHead ){ + pNew->next = pHead; + pNew->prev = pHead->prev; + if( pHead->prev ){ pHead->prev->next = pNew; } + else { pH->first = pNew; } + pHead->prev = pNew; + }else{ + pNew->next = pH->first; + if( pH->first ){ pH->first->prev = pNew; } + pNew->prev = 0; + pH->first = pNew; + } + pEntry->count++; + pEntry->chain = pNew; +} + + +/* Resize the hash table so that it cantains "new_size" buckets. +** "new_size" must be a power of 2. The hash table might fail +** to resize if sqlite3_malloc() fails. +*/ +static void rehash(Hash *pH, int new_size){ + Hash::_ht *new_ht; /* The new hash table */ + HashElem *elem, *next_elem; /* For looping over existing elements */ + int (*xHash)(const void*,int); /* The hash function */ + + assert( (new_size & (new_size-1))==0 ); + + /* There is a call to sqlite3_malloc() inside rehash(). If there is + ** already an allocation at pH->ht, then if this malloc() fails it + ** is benign (since failing to resize a hash table is a performance + ** hit only, not a fatal error). + */ + sqlite3MallocBenignFailure(pH->htsize>0); + + new_ht = (Hash::_ht *)sqlite3MallocZero( new_size*sizeof(Hash::_ht) ); + if( new_ht==0 ) return; + if( pH->ht ) sqlite3_free(pH->ht); + pH->ht = new_ht; + pH->htsize = new_size; + xHash = hashFunction(pH->keyClass); + for(elem=pH->first, pH->first=0; elem; elem = next_elem){ + int h = (*xHash)(elem->pKey, elem->nKey) & (new_size-1); + next_elem = elem->next; + insertElement(pH, &new_ht[h], elem); + } +} + +/* This function (for internal use only) locates an element in an +** hash table that matches the given key. The hash for this key has +** already been computed and is passed as the 4th parameter. +*/ +static HashElem *findElementGivenHash( + const Hash *pH, /* The pH to be searched */ + const void *pKey, /* The key we are searching for */ + int nKey, + int h /* The hash for this key. */ +){ + HashElem *elem; /* Used to loop thru the element list */ + int count; /* Number of elements left to test */ + int (*xCompare)(const void*,int,const void*,int); /* comparison function */ + + if( pH->ht ){ + Hash::_ht *pEntry = &pH->ht[h]; + elem = pEntry->chain; + count = pEntry->count; + xCompare = compareFunction(pH->keyClass); + while( count-- && elem ){ + if( (*xCompare)(elem->pKey,elem->nKey,pKey,nKey)==0 ){ + return elem; + } + elem = elem->next; + } + } + return 0; +} + +/* Remove a single entry from the hash table given a pointer to that +** element and a hash on the element's key. +*/ +static void removeElementGivenHash( + Hash *pH, /* The pH containing "elem" */ + HashElem* elem, /* The element to be removed from the pH */ + int h /* Hash value for the element */ +){ + Hash::_ht *pEntry; + if( elem->prev ){ + elem->prev->next = elem->next; + }else{ + pH->first = elem->next; + } + if( elem->next ){ + elem->next->prev = elem->prev; + } + pEntry = &pH->ht[h]; + if( pEntry->chain==elem ){ + pEntry->chain = elem->next; + } + pEntry->count--; + if( pEntry->count<=0 ){ + pEntry->chain = 0; + } + if( pH->copyKey ){ + sqlite3_free(elem->pKey); + } + sqlite3_free( elem ); + pH->count--; + if( pH->count<=0 ){ + assert( pH->first==0 ); + assert( pH->count==0 ); + sqlite3HashClear(pH); + } +} + +/* Attempt to locate an element of the hash table pH with a key +** that matches pKey,nKey. Return a pointer to the corresponding +** HashElem structure for this element if it is found, or NULL +** otherwise. +*/ +HashElem *sqlite3HashFindElem(const Hash *pH, const void *pKey, int nKey){ + int h; /* A hash on key */ + HashElem *elem; /* The element that matches key */ + int (*xHash)(const void*,int); /* The hash function */ + + if( pH==0 || pH->ht==0 ) return 0; + xHash = hashFunction(pH->keyClass); + assert( xHash!=0 ); + h = (*xHash)(pKey,nKey); + assert( (pH->htsize & (pH->htsize-1))==0 ); + elem = findElementGivenHash(pH,pKey,nKey, h & (pH->htsize-1)); + return elem; +} + +/* Attempt to locate an element of the hash table pH with a key +** that matches pKey,nKey. Return the data for this element if it is +** found, or NULL if there is no match. +*/ +void *sqlite3HashFind(const Hash *pH, const void *pKey, int nKey){ + HashElem *elem; /* The element that matches key */ + elem = sqlite3HashFindElem(pH, pKey, nKey); + return elem ? elem->data : 0; +} + +/* Insert an element into the hash table pH. The key is pKey,nKey +** and the data is "data". +** +** If no element exists with a matching key, then a new +** element is created. A copy of the key is made if the copyKey +** flag is set. NULL is returned. +** +** If another element already exists with the same key, then the +** new data replaces the old data and the old data is returned. +** The key is not copied in this instance. If a malloc fails, then +** the new data is returned and the hash table is unchanged. +** +** If the "data" parameter to this function is NULL, then the +** element corresponding to "key" is removed from the hash table. +*/ +void *sqlite3HashInsert(Hash *pH, const void *pKey, int nKey, void *data){ + int hraw; /* Raw hash value of the key */ + int h; /* the hash of the key modulo hash table size */ + HashElem *elem; /* Used to loop thru the element list */ + HashElem *new_elem; /* New element added to the pH */ + int (*xHash)(const void*,int); /* The hash function */ + + assert( pH!=0 ); + xHash = hashFunction(pH->keyClass); + assert( xHash!=0 ); + hraw = (*xHash)(pKey, nKey); + assert( (pH->htsize & (pH->htsize-1))==0 ); + h = hraw & (pH->htsize-1); + elem = findElementGivenHash(pH,pKey,nKey,h); + if( elem ){ + void *old_data = elem->data; + if( data==0 ){ + removeElementGivenHash(pH,elem,h); + }else{ + elem->data = data; + if( !pH->copyKey ){ + elem->pKey = (void *)pKey; + } + assert(nKey==elem->nKey); + } + return old_data; + } + if( data==0 ) return 0; + new_elem = (HashElem*)sqlite3_malloc( sizeof(HashElem) ); + if( new_elem==0 ) return data; + if( pH->copyKey && pKey!=0 ){ + new_elem->pKey = sqlite3_malloc( nKey ); + if( new_elem->pKey==0 ){ + sqlite3_free(new_elem); + return data; + } + memcpy((void*)new_elem->pKey, pKey, nKey); + }else{ + new_elem->pKey = (void*)pKey; + } + new_elem->nKey = nKey; + pH->count++; + if( pH->htsize==0 ){ + rehash(pH,8); + if( pH->htsize==0 ){ + pH->count = 0; + if( pH->copyKey ){ + sqlite3_free(new_elem->pKey); + } + sqlite3_free(new_elem); + return data; + } + } + if( pH->count > pH->htsize ){ + rehash(pH,pH->htsize*2); + } + assert( pH->htsize>0 ); + assert( (pH->htsize & (pH->htsize-1))==0 ); + h = hraw & (pH->htsize-1); + insertElement(pH, &pH->ht[h], new_elem); + new_elem->data = data; + return 0; +} diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/hash.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/hash.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,110 @@ +/* +** 2001 September 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This is the header file for the generic hash-table implemenation +** used in SQLite. +** +** $Id: hash.h 1282 2008-11-13 09:31:33Z LarsPson $ +*/ +#ifndef _SQLITE_HASH_H_ +#define _SQLITE_HASH_H_ + +/* Forward declarations of structures. */ +typedef struct Hash Hash; +typedef struct HashElem HashElem; + +/* A complete hash table is an instance of the following structure. +** The internals of this structure are intended to be opaque -- client +** code should not attempt to access or modify the fields of this structure +** directly. Change this structure only by using the routines below. +** However, many of the "procedures" and "functions" for modifying and +** accessing this structure are really macros, so we can't really make +** this structure opaque. +*/ +struct Hash { + char keyClass; /* SQLITE_HASH_INT, _POINTER, _STRING, _BINARY */ + char copyKey; /* True if copy of key made on insert */ + int count; /* Number of entries in this table */ + int htsize; /* Number of buckets in the hash table */ + HashElem *first; /* The first element of the array */ + struct _ht { /* the hash table */ + int count; /* Number of entries with this hash */ + HashElem *chain; /* Pointer to first entry with this hash */ + } *ht; +}; + +/* Each element in the hash table is an instance of the following +** structure. All elements are stored on a single doubly-linked list. +** +** Again, this structure is intended to be opaque, but it can't really +** be opaque because it is used by macros. +*/ +struct HashElem { + HashElem *next, *prev; /* Next and previous elements in the table */ + void *data; /* Data associated with this element */ + void *pKey; int nKey; /* Key associated with this element */ +}; + +/* +** There are 4 different modes of operation for a hash table: +** +** SQLITE_HASH_INT nKey is used as the key and pKey is ignored. +** +** SQLITE_HASH_POINTER pKey is used as the key and nKey is ignored. +** +** SQLITE_HASH_STRING pKey points to a string that is nKey bytes long +** (including the null-terminator, if any). Case +** is ignored in comparisons. +** +** SQLITE_HASH_BINARY pKey points to binary data nKey bytes long. +** memcmp() is used to compare keys. +** +** A copy of the key is made for SQLITE_HASH_STRING and SQLITE_HASH_BINARY +** if the copyKey parameter to HashInit is 1. +*/ +/* #define SQLITE_HASH_INT 1 // NOT USED */ +/* #define SQLITE_HASH_POINTER 2 // NOT USED */ +#define SQLITE_HASH_STRING 3 +#define SQLITE_HASH_BINARY 4 + +/* +** Access routines. To delete, insert a NULL pointer. +*/ +void sqlite3HashInit(Hash*, int keytype, int copyKey); +void *sqlite3HashInsert(Hash*, const void *pKey, int nKey, void *pData); +void *sqlite3HashFind(const Hash*, const void *pKey, int nKey); +HashElem *sqlite3HashFindElem(const Hash*, const void *pKey, int nKey); +void sqlite3HashClear(Hash*); + +/* +** Macros for looping over all elements of a hash table. The idiom is +** like this: +** +** Hash h; +** HashElem *p; +** ... +** for(p=sqliteHashFirst(&h); p; p=sqliteHashNext(p)){ +** SomeStructure *pData = sqliteHashData(p); +** // do something with pData +** } +*/ +#define sqliteHashFirst(H) ((H)->first) +#define sqliteHashNext(E) ((E)->next) +#define sqliteHashData(E) ((E)->data) +#define sqliteHashKey(E) ((E)->pKey) +#define sqliteHashKeysize(E) ((E)->nKey) + +/* +** Number of entries in a hash table +*/ +#define sqliteHashCount(H) ((H)->count) + +#endif /* _SQLITE_HASH_H_ */ diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/helper.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/helper.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,43 @@ +/* +** 2004 May 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** Functions wrapping 'int64' and 'double' functions to pass values by reference. +*/ + +#include +#include "sqlite3.h" +#include + +EXPORT_C int sqlite3_bind_double_ref(sqlite3_stmt *stmt, int iCol, double *val) +{ + return sqlite3_bind_double(stmt,iCol,*val); +} + +EXPORT_C int sqlite3_bind_int64_ref(sqlite3_stmt *stmt, int iCol, sqlite_int64 *val) +{ + return sqlite3_bind_int64(stmt,iCol,*val); +} + +EXPORT_C void sqlite3_column_double_ref(sqlite3_stmt *stmt, int iCol, double *val) +{ + *val = sqlite3_column_double(stmt,iCol); +} + +EXPORT_C void sqlite3_column_int64_ref(sqlite3_stmt *stmt, int iCol, sqlite_int64 *val) +{ + *val = sqlite3_column_int64(stmt,iCol); +} + +EXPORT_C unsigned int sqlite3_strlen(char *ptr) +{ + return strlen(ptr); +} diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/insert.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/insert.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,1626 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains C code routines that are called by the parser +** to handle INSERT statements in SQLite. +** +** $Id: insert.cpp 1282 2008-11-13 09:31:33Z LarsPson $ +*/ +#include "sqliteInt.h" + +/* +** Set P3 of the most recently inserted opcode to a column affinity +** string for index pIdx. A column affinity string has one character +** for each column in the table, according to the affinity of the column: +** +** Character Column affinity +** ------------------------------ +** 'a' TEXT +** 'b' NONE +** 'c' NUMERIC +** 'd' INTEGER +** 'e' REAL +*/ +void sqlite3IndexAffinityStr(Vdbe *v, Index *pIdx){ + if( !pIdx->zColAff ){ + /* The first time a column affinity string for a particular index is + ** required, it is allocated and populated here. It is then stored as + ** a member of the Index structure for subsequent use. + ** + ** The column affinity string will eventually be deleted by + ** sqliteDeleteIndex() when the Index structure itself is cleaned + ** up. + */ + int n; + Table *pTab = pIdx->pTable; + sqlite3 *db = sqlite3VdbeDb(v); + pIdx->zColAff = (char *)sqlite3DbMallocZero(db, pIdx->nColumn+1); + if( !pIdx->zColAff ){ + return; + } + for(n=0; nnColumn; n++){ + pIdx->zColAff[n] = pTab->aCol[pIdx->aiColumn[n]].affinity; + } + pIdx->zColAff[pIdx->nColumn] = '\0'; + } + + sqlite3VdbeChangeP3(v, -1, pIdx->zColAff, 0); +} + +/* +** Set P3 of the most recently inserted opcode to a column affinity +** string for table pTab. A column affinity string has one character +** for each column indexed by the index, according to the affinity of the +** column: +** +** Character Column affinity +** ------------------------------ +** 'a' TEXT +** 'b' NONE +** 'c' NUMERIC +** 'd' INTEGER +** 'e' REAL +*/ +void sqlite3TableAffinityStr(Vdbe *v, Table *pTab){ + /* The first time a column affinity string for a particular table + ** is required, it is allocated and populated here. It is then + ** stored as a member of the Table structure for subsequent use. + ** + ** The column affinity string will eventually be deleted by + ** sqlite3DeleteTable() when the Table structure itself is cleaned up. + */ + if( !pTab->zColAff ){ + char *zColAff; + int i; + sqlite3 *db = sqlite3VdbeDb(v); + + zColAff = (char *)sqlite3DbMallocZero(db, pTab->nCol+1); + if( !zColAff ){ + return; + } + + for(i=0; inCol; i++){ + zColAff[i] = pTab->aCol[i].affinity; + } + zColAff[pTab->nCol] = '\0'; + + pTab->zColAff = zColAff; + } + + sqlite3VdbeChangeP3(v, -1, pTab->zColAff, 0); +} + +/* +** Return non-zero if the table pTab in database iDb or any of its indices +** have been opened at any point in the VDBE program beginning at location +** iStartAddr throught the end of the program. This is used to see if +** a statement of the form "INSERT INTO SELECT ..." can +** run without using temporary table for the results of the SELECT. +*/ +static int readsTable(Vdbe *v, int iStartAddr, int iDb, Table *pTab){ + int i; + int iEnd = sqlite3VdbeCurrentAddr(v); + for(i=iStartAddr; iopcode==OP_OpenRead ){ + VdbeOp *pPrior = &pOp[-1]; + int tnum = pOp->p2; + assert( i>iStartAddr ); + assert( pPrior->opcode==OP_Integer ); + if( pPrior->p1==iDb ){ + Index *pIndex; + if( tnum==pTab->tnum ){ + return 1; + } + for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){ + if( tnum==pIndex->tnum ){ + return 1; + } + } + } + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( pOp->opcode==OP_VOpen && pOp->p3==(const char*)pTab->pVtab ){ + assert( pOp->p3!=0 ); + assert( pOp->p3type==P3_VTAB ); + return 1; + } +#endif + } + return 0; +} + +#ifndef SQLITE_OMIT_AUTOINCREMENT +/* +** Write out code to initialize the autoincrement logic. This code +** looks up the current autoincrement value in the sqlite_sequence +** table and stores that value in a memory cell. Code generated by +** autoIncStep() will keep that memory cell holding the largest +** rowid value. Code generated by autoIncEnd() will write the new +** largest value of the counter back into the sqlite_sequence table. +** +** This routine returns the index of the mem[] cell that contains +** the maximum rowid counter. +** +** Two memory cells are allocated. The next memory cell after the +** one returned holds the rowid in sqlite_sequence where we will +** write back the revised maximum rowid. +*/ +static int autoIncBegin( + Parse *pParse, /* Parsing context */ + int iDb, /* Index of the database holding pTab */ + Table *pTab /* The table we are writing to */ +){ + int memId = 0; + if( pTab->autoInc ){ + Vdbe *v = pParse->pVdbe; + Db *pDb = &pParse->db->aDb[iDb]; + int iCur = pParse->nTab; + int addr; + assert( v ); + addr = sqlite3VdbeCurrentAddr(v); + memId = pParse->nMem+1; + pParse->nMem += 2; + sqlite3OpenTable(pParse, iCur, iDb, pDb->pSchema->pSeqTab, OP_OpenRead); + sqlite3VdbeAddOp(v, OP_Rewind, iCur, addr+13); + sqlite3VdbeAddOp(v, OP_Column, iCur, 0); + sqlite3VdbeOp3(v, OP_String8, 0, 0, pTab->zName, 0); + sqlite3VdbeAddOp(v, OP_Ne, 0x100, addr+12); + sqlite3VdbeAddOp(v, OP_Rowid, iCur, 0); + sqlite3VdbeAddOp(v, OP_MemStore, memId-1, 1); + sqlite3VdbeAddOp(v, OP_Column, iCur, 1); + sqlite3VdbeAddOp(v, OP_MemStore, memId, 1); + sqlite3VdbeAddOp(v, OP_Goto, 0, addr+13); + sqlite3VdbeAddOp(v, OP_Next, iCur, addr+4); + sqlite3VdbeAddOp(v, OP_Close, iCur, 0); + } + return memId; +} + +/* +** Update the maximum rowid for an autoincrement calculation. +** +** This routine should be called when the top of the stack holds a +** new rowid that is about to be inserted. If that new rowid is +** larger than the maximum rowid in the memId memory cell, then the +** memory cell is updated. The stack is unchanged. +*/ +static void autoIncStep(Parse *pParse, int memId){ + if( memId>0 ){ + sqlite3VdbeAddOp(pParse->pVdbe, OP_MemMax, memId, 0); + } +} + +/* +** After doing one or more inserts, the maximum rowid is stored +** in mem[memId]. Generate code to write this value back into the +** the sqlite_sequence table. +*/ +static void autoIncEnd( + Parse *pParse, /* The parsing context */ + int iDb, /* Index of the database holding pTab */ + Table *pTab, /* Table we are inserting into */ + int memId /* Memory cell holding the maximum rowid */ +){ + if( pTab->autoInc ){ + int iCur = pParse->nTab; + Vdbe *v = pParse->pVdbe; + Db *pDb = &pParse->db->aDb[iDb]; + int addr; + assert( v ); + addr = sqlite3VdbeCurrentAddr(v); + sqlite3OpenTable(pParse, iCur, iDb, pDb->pSchema->pSeqTab, OP_OpenWrite); + sqlite3VdbeAddOp(v, OP_MemLoad, memId-1, 0); + sqlite3VdbeAddOp(v, OP_NotNull, -1, addr+7); + sqlite3VdbeAddOp(v, OP_Pop, 1, 0); + sqlite3VdbeAddOp(v, OP_NewRowid, iCur, 0); + sqlite3VdbeOp3(v, OP_String8, 0, 0, pTab->zName, 0); + sqlite3VdbeAddOp(v, OP_MemLoad, memId, 0); + sqlite3VdbeAddOp(v, OP_MakeRecord, 2, 0); + sqlite3VdbeAddOp(v, OP_Insert, iCur, OPFLAG_APPEND); + sqlite3VdbeAddOp(v, OP_Close, iCur, 0); + } +} +#else +/* +** If SQLITE_OMIT_AUTOINCREMENT is defined, then the three routines +** above are all no-ops +*/ +# define autoIncBegin(A,B,C) (0) +# define autoIncStep(A,B) +# define autoIncEnd(A,B,C,D) +#endif /* SQLITE_OMIT_AUTOINCREMENT */ + + +/* Forward declaration */ +static int xferOptimization( + Parse *pParse, /* Parser context */ + Table *pDest, /* The table we are inserting into */ + Select *pSelect, /* A SELECT statement to use as the data source */ + int onError, /* How to handle constraint errors */ + int iDbDest /* The database of pDest */ +); + +/* +** This routine is call to handle SQL of the following forms: +** +** insert into TABLE (IDLIST) values(EXPRLIST) +** insert into TABLE (IDLIST) select +** +** The IDLIST following the table name is always optional. If omitted, +** then a list of all columns for the table is substituted. The IDLIST +** appears in the pColumn parameter. pColumn is NULL if IDLIST is omitted. +** +** The pList parameter holds EXPRLIST in the first form of the INSERT +** statement above, and pSelect is NULL. For the second form, pList is +** NULL and pSelect is a pointer to the select statement used to generate +** data for the insert. +** +** The code generated follows one of four templates. For a simple +** select with data coming from a VALUES clause, the code executes +** once straight down through. The template looks like this: +** +** open write cursor to
and its indices +** puts VALUES clause expressions onto the stack +** write the resulting record into
+** cleanup +** +** The three remaining templates assume the statement is of the form +** +** INSERT INTO
SELECT ... +** +** If the SELECT clause is of the restricted form "SELECT * FROM " - +** in other words if the SELECT pulls all columns from a single table +** and there is no WHERE or LIMIT or GROUP BY or ORDER BY clauses, and +** if and are distinct tables but have identical +** schemas, including all the same indices, then a special optimization +** is invoked that copies raw records from over to . +** See the xferOptimization() function for the implementation of this +** template. This is the second template. +** +** open a write cursor to
+** open read cursor on +** transfer all records in over to
+** close cursors +** foreach index on
+** open a write cursor on the
index +** open a read cursor on the corresponding index +** transfer all records from the read to the write cursors +** close cursors +** end foreach +** +** The third template is for when the second template does not apply +** and the SELECT clause does not read from
at any time. +** The generated code follows this template: +** +** goto B +** A: setup for the SELECT +** loop over the rows in the SELECT +** gosub C +** end loop +** cleanup after the SELECT +** goto D +** B: open write cursor to
and its indices +** goto A +** C: insert the select result into
+** return +** D: cleanup +** +** The fourth template is used if the insert statement takes its +** values from a SELECT but the data is being inserted into a table +** that is also read as part of the SELECT. In the third form, +** we have to use a intermediate table to store the results of +** the select. The template is like this: +** +** goto B +** A: setup for the SELECT +** loop over the tables in the SELECT +** gosub C +** end loop +** cleanup after the SELECT +** goto D +** C: insert the select result into the intermediate table +** return +** B: open a cursor to an intermediate table +** goto A +** D: open write cursor to
and its indices +** loop over the intermediate table +** transfer values form intermediate table into
+** end the loop +** cleanup +*/ +void sqlite3Insert( + Parse *pParse, /* Parser context */ + SrcList *pTabList, /* Name of table into which we are inserting */ + ExprList *pList, /* List of values to be inserted */ + Select *pSelect, /* A SELECT statement to use as the data source */ + IdList *pColumn, /* Column names corresponding to IDLIST. */ + int onError /* How to handle constraint errors */ +){ + Table *pTab; /* The table to insert into */ + char *zTab; /* Name of the table into which we are inserting */ + const char *zDb; /* Name of the database holding this table */ + int i, j, idx; /* Loop counters */ + Vdbe *v; /* Generate code into this virtual machine */ + Index *pIdx; /* For looping over indices of the table */ + int nColumn; /* Number of columns in the data */ + int base = 0; /* VDBE Cursor number for pTab */ + int iCont=0,iBreak=0; /* Beginning and end of the loop over srcTab */ + sqlite3 *db; /* The main database structure */ + int keyColumn = -1; /* Column that is the INTEGER PRIMARY KEY */ + int endOfLoop; /* Label for the end of the insertion loop */ + int useTempTable = 0; /* Store SELECT results in intermediate table */ + int srcTab = 0; /* Data comes from this temporary cursor if >=0 */ + int iSelectLoop = 0; /* Address of code that implements the SELECT */ + int iCleanup = 0; /* Address of the cleanup code */ + int iInsertBlock = 0; /* Address of the subroutine used to insert data */ + int iCntMem = 0; /* Memory cell used for the row counter */ + int newIdx = -1; /* Cursor for the NEW table */ + Db *pDb; /* The database containing table being inserted into */ + int counterMem = 0; /* Memory cell holding AUTOINCREMENT counter */ + int appendFlag = 0; /* True if the insert is likely to be an append */ + int iDb; + + int nHidden = 0; + +#ifndef SQLITE_OMIT_TRIGGER + int isView; /* True if attempting to insert into a view */ + int triggers_exist = 0; /* True if there are FOR EACH ROW triggers */ +#endif + + db = pParse->db; + if( pParse->nErr || db->mallocFailed ){ + goto insert_cleanup; + } + + /* Locate the table into which we will be inserting new information. + */ + assert( pTabList->nSrc==1 ); + zTab = pTabList->a[0].zName; + if( zTab==0 ) goto insert_cleanup; + pTab = sqlite3SrcListLookup(pParse, pTabList); + if( pTab==0 ){ + goto insert_cleanup; + } + iDb = sqlite3SchemaToIndex(db, pTab->pSchema); + assert( iDbnDb ); + pDb = &db->aDb[iDb]; + zDb = pDb->zName; + if( sqlite3AuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0, zDb) ){ + goto insert_cleanup; + } + + /* Figure out if we have any triggers and if the table being + ** inserted into is a view + */ +#ifndef SQLITE_OMIT_TRIGGER + triggers_exist = sqlite3TriggersExist(pParse, pTab, TK_INSERT, 0); + isView = pTab->pSelect!=0; +#else +# define triggers_exist 0 +# define isView 0 +#endif +#ifdef SQLITE_OMIT_VIEW +# undef isView +# define isView 0 +#endif + + /* Ensure that: + * (a) the table is not read-only, + * (b) that if it is a view then ON INSERT triggers exist + */ + if( sqlite3IsReadOnly(pParse, pTab, triggers_exist) ){ + goto insert_cleanup; + } + assert( pTab!=0 ); + + /* If pTab is really a view, make sure it has been initialized. + ** ViewGetColumnNames() is a no-op if pTab is not a view (or virtual + ** module table). + */ + if( sqlite3ViewGetColumnNames(pParse, pTab) ){ + goto insert_cleanup; + } + + /* Allocate a VDBE + */ + v = sqlite3GetVdbe(pParse); + if( v==0 ) goto insert_cleanup; + if( pParse->nested==0 ) sqlite3VdbeCountChanges(v); + sqlite3BeginWriteOperation(pParse, pSelect || triggers_exist, iDb); + + /* if there are row triggers, allocate a temp table for new.* references. */ + if( triggers_exist ){ + newIdx = pParse->nTab++; + } + +#ifndef SQLITE_OMIT_XFER_OPT + /* If the statement is of the form + ** + ** INSERT INTO SELECT * FROM ; + ** + ** Then special optimizations can be applied that make the transfer + ** very fast and which reduce fragmentation of indices. + */ + if( pColumn==0 && xferOptimization(pParse, pTab, pSelect, onError, iDb) ){ + assert( !triggers_exist ); + assert( pList==0 ); + goto insert_cleanup; + } +#endif /* SQLITE_OMIT_XFER_OPT */ + + /* If this is an AUTOINCREMENT table, look up the sequence number in the + ** sqlite_sequence table and store it in memory cell counterMem. Also + ** remember the rowid of the sqlite_sequence table entry in memory cell + ** counterRowid. + */ + counterMem = autoIncBegin(pParse, iDb, pTab); + + /* Figure out how many columns of data are supplied. If the data + ** is coming from a SELECT statement, then this step also generates + ** all the code to implement the SELECT statement and invoke a subroutine + ** to process each row of the result. (Template 2.) If the SELECT + ** statement uses the the table that is being inserted into, then the + ** subroutine is also coded here. That subroutine stores the SELECT + ** results in a temporary table. (Template 3.) + */ + if( pSelect ){ + /* Data is coming from a SELECT. Generate code to implement that SELECT + */ + int rc, iInitCode; + iInitCode = sqlite3VdbeAddOp(v, OP_Goto, 0, 0); + iSelectLoop = sqlite3VdbeCurrentAddr(v); + iInsertBlock = sqlite3VdbeMakeLabel(v); + + /* Resolve the expressions in the SELECT statement and execute it. */ + rc = sqlite3Select(pParse, pSelect, SRT_Subroutine, iInsertBlock,0,0,0,0); + if( rc || pParse->nErr || db->mallocFailed ){ + goto insert_cleanup; + } + + iCleanup = sqlite3VdbeMakeLabel(v); + sqlite3VdbeAddOp(v, OP_Goto, 0, iCleanup); + assert( pSelect->pEList ); + nColumn = pSelect->pEList->nExpr; + + /* Set useTempTable to TRUE if the result of the SELECT statement + ** should be written into a temporary table. Set to FALSE if each + ** row of the SELECT can be written directly into the result table. + ** + ** A temp table must be used if the table being updated is also one + ** of the tables being read by the SELECT statement. Also use a + ** temp table in the case of row triggers. + */ + if( triggers_exist || readsTable(v, iSelectLoop, iDb, pTab) ){ + useTempTable = 1; + } + + if( useTempTable ){ + /* Generate the subroutine that SELECT calls to process each row of + ** the result. Store the result in a temporary table + */ + srcTab = pParse->nTab++; + sqlite3VdbeResolveLabel(v, iInsertBlock); + sqlite3VdbeAddOp(v, OP_StackDepth, -1, 0); + sqlite3VdbeAddOp(v, OP_MakeRecord, nColumn, 0); + sqlite3VdbeAddOp(v, OP_NewRowid, srcTab, 0); + sqlite3VdbeAddOp(v, OP_Pull, 1, 0); + sqlite3VdbeAddOp(v, OP_Insert, srcTab, OPFLAG_APPEND); + sqlite3VdbeAddOp(v, OP_Return, 0, 0); + + /* The following code runs first because the GOTO at the very top + ** of the program jumps to it. Create the temporary table, then jump + ** back up and execute the SELECT code above. + */ + sqlite3VdbeJumpHere(v, iInitCode); + sqlite3VdbeAddOp(v, OP_OpenEphemeral, srcTab, 0); + sqlite3VdbeAddOp(v, OP_SetNumColumns, srcTab, nColumn); + sqlite3VdbeAddOp(v, OP_Goto, 0, iSelectLoop); + sqlite3VdbeResolveLabel(v, iCleanup); + }else{ + sqlite3VdbeJumpHere(v, iInitCode); + } + }else{ + /* This is the case if the data for the INSERT is coming from a VALUES + ** clause + */ + NameContext sNC; + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = pParse; + srcTab = -1; + assert( useTempTable==0 ); + nColumn = pList ? pList->nExpr : 0; + for(i=0; ia[i].pExpr) ){ + goto insert_cleanup; + } + } + } + + /* Make sure the number of columns in the source data matches the number + ** of columns to be inserted into the table. + */ + if( IsVirtual(pTab) ){ + for(i=0; inCol; i++){ + nHidden += (IsHiddenColumn(&pTab->aCol[i]) ? 1 : 0); + } + } + if( pColumn==0 && nColumn && nColumn!=(pTab->nCol-nHidden) ){ + sqlite3ErrorMsg(pParse, + "table %S has %d columns but %d values were supplied", + pTabList, 0, pTab->nCol, nColumn); + goto insert_cleanup; + } + if( pColumn!=0 && nColumn!=pColumn->nId ){ + sqlite3ErrorMsg(pParse, "%d values for %d columns", nColumn, pColumn->nId); + goto insert_cleanup; + } + + /* If the INSERT statement included an IDLIST term, then make sure + ** all elements of the IDLIST really are columns of the table and + ** remember the column indices. + ** + ** If the table has an INTEGER PRIMARY KEY column and that column + ** is named in the IDLIST, then record in the keyColumn variable + ** the index into IDLIST of the primary key column. keyColumn is + ** the index of the primary key as it appears in IDLIST, not as + ** is appears in the original table. (The index of the primary + ** key in the original table is pTab->iPKey.) + */ + if( pColumn ){ + for(i=0; inId; i++){ + pColumn->a[i].idx = -1; + } + for(i=0; inId; i++){ + for(j=0; jnCol; j++){ + if( sqlite3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zName)==0 ){ + pColumn->a[i].idx = j; + if( j==pTab->iPKey ){ + keyColumn = i; + } + break; + } + } + if( j>=pTab->nCol ){ + if( sqlite3IsRowid(pColumn->a[i].zName) ){ + keyColumn = i; + }else{ + sqlite3ErrorMsg(pParse, "table %S has no column named %s", + pTabList, 0, pColumn->a[i].zName); + pParse->nErr++; + goto insert_cleanup; + } + } + } + } + + /* If there is no IDLIST term but the table has an integer primary + ** key, the set the keyColumn variable to the primary key column index + ** in the original table definition. + */ + if( pColumn==0 && nColumn>0 ){ + keyColumn = pTab->iPKey; + } + + /* Open the temp table for FOR EACH ROW triggers + */ + if( triggers_exist ){ + sqlite3VdbeAddOp(v, OP_OpenPseudo, newIdx, 0); + sqlite3VdbeAddOp(v, OP_SetNumColumns, newIdx, pTab->nCol); + } + + /* Initialize the count of rows to be inserted + */ + if( db->flags & SQLITE_CountRows ){ + iCntMem = pParse->nMem++; + sqlite3VdbeAddOp(v, OP_MemInt, 0, iCntMem); + } + + /* Open tables and indices if there are no row triggers */ + if( !triggers_exist ){ + base = pParse->nTab; + sqlite3OpenTableAndIndices(pParse, pTab, base, OP_OpenWrite); + } + + /* If the data source is a temporary table, then we have to create + ** a loop because there might be multiple rows of data. If the data + ** source is a subroutine call from the SELECT statement, then we need + ** to launch the SELECT statement processing. + */ + if( useTempTable ){ + iBreak = sqlite3VdbeMakeLabel(v); + sqlite3VdbeAddOp(v, OP_Rewind, srcTab, iBreak); + iCont = sqlite3VdbeCurrentAddr(v); + }else if( pSelect ){ + sqlite3VdbeAddOp(v, OP_Goto, 0, iSelectLoop); + sqlite3VdbeResolveLabel(v, iInsertBlock); + sqlite3VdbeAddOp(v, OP_StackDepth, -1, 0); + } + + /* Run the BEFORE and INSTEAD OF triggers, if there are any + */ + endOfLoop = sqlite3VdbeMakeLabel(v); + if( triggers_exist & TRIGGER_BEFORE ){ + + /* build the NEW.* reference row. Note that if there is an INTEGER + ** PRIMARY KEY into which a NULL is being inserted, that NULL will be + ** translated into a unique ID for the row. But on a BEFORE trigger, + ** we do not know what the unique ID will be (because the insert has + ** not happened yet) so we substitute a rowid of -1 + */ + if( keyColumn<0 ){ + sqlite3VdbeAddOp(v, OP_Integer, -1, 0); + }else if( useTempTable ){ + sqlite3VdbeAddOp(v, OP_Column, srcTab, keyColumn); + }else{ + assert( pSelect==0 ); /* Otherwise useTempTable is true */ + sqlite3ExprCode(pParse, pList->a[keyColumn].pExpr); + sqlite3VdbeAddOp(v, OP_NotNull, -1, sqlite3VdbeCurrentAddr(v)+3); + sqlite3VdbeAddOp(v, OP_Pop, 1, 0); + sqlite3VdbeAddOp(v, OP_Integer, -1, 0); + sqlite3VdbeAddOp(v, OP_MustBeInt, 0, 0); + } + + /* Cannot have triggers on a virtual table. If it were possible, + ** this block would have to account for hidden column. + */ + assert(!IsVirtual(pTab)); + + /* Create the new column data + */ + for(i=0; inCol; i++){ + if( pColumn==0 ){ + j = i; + }else{ + for(j=0; jnId; j++){ + if( pColumn->a[j].idx==i ) break; + } + } + if( pColumn && j>=pColumn->nId ){ + sqlite3ExprCode(pParse, pTab->aCol[i].pDflt); + }else if( useTempTable ){ + sqlite3VdbeAddOp(v, OP_Column, srcTab, j); + }else{ + assert( pSelect==0 ); /* Otherwise useTempTable is true */ + sqlite3ExprCodeAndCache(pParse, pList->a[j].pExpr); + } + } + sqlite3VdbeAddOp(v, OP_MakeRecord, pTab->nCol, 0); + + /* If this is an INSERT on a view with an INSTEAD OF INSERT trigger, + ** do not attempt any conversions before assembling the record. + ** If this is a real table, attempt conversions as required by the + ** table column affinities. + */ + if( !isView ){ + sqlite3TableAffinityStr(v, pTab); + } + sqlite3VdbeAddOp(v, OP_Insert, newIdx, 0); + + /* Fire BEFORE or INSTEAD OF triggers */ + if( sqlite3CodeRowTrigger(pParse, TK_INSERT, 0, TRIGGER_BEFORE, pTab, + newIdx, -1, onError, endOfLoop) ){ + goto insert_cleanup; + } + } + + /* If any triggers exists, the opening of tables and indices is deferred + ** until now. + */ + if( triggers_exist && !isView ){ + base = pParse->nTab; + sqlite3OpenTableAndIndices(pParse, pTab, base, OP_OpenWrite); + } + + /* Push the record number for the new entry onto the stack. The + ** record number is a randomly generate integer created by NewRowid + ** except when the table has an INTEGER PRIMARY KEY column, in which + ** case the record number is the same as that column. + */ + if( !isView ){ + if( IsVirtual(pTab) ){ + /* The row that the VUpdate opcode will delete: none */ + sqlite3VdbeAddOp(v, OP_Null, 0, 0); + } + if( keyColumn>=0 ){ + if( useTempTable ){ + sqlite3VdbeAddOp(v, OP_Column, srcTab, keyColumn); + }else if( pSelect ){ + sqlite3VdbeAddOp(v, OP_Dup, nColumn - keyColumn - 1, 1); + }else{ + VdbeOp *pOp; + sqlite3ExprCode(pParse, pList->a[keyColumn].pExpr); + pOp = sqlite3VdbeGetOp(v, sqlite3VdbeCurrentAddr(v) - 1); + if( pOp && pOp->opcode==OP_Null ){ + appendFlag = 1; + pOp->opcode = OP_NewRowid; + pOp->p1 = base; + pOp->p2 = counterMem; + } + } + /* If the PRIMARY KEY expression is NULL, then use OP_NewRowid + ** to generate a unique primary key value. + */ + if( !appendFlag ){ + sqlite3VdbeAddOp(v, OP_NotNull, -1, sqlite3VdbeCurrentAddr(v)+3); + sqlite3VdbeAddOp(v, OP_Pop, 1, 0); + sqlite3VdbeAddOp(v, OP_NewRowid, base, counterMem); + sqlite3VdbeAddOp(v, OP_MustBeInt, 0, 0); + } + }else if( IsVirtual(pTab) ){ + sqlite3VdbeAddOp(v, OP_Null, 0, 0); + }else{ + sqlite3VdbeAddOp(v, OP_NewRowid, base, counterMem); + appendFlag = 1; + } + autoIncStep(pParse, counterMem); + + /* Push onto the stack, data for all columns of the new entry, beginning + ** with the first column. + */ + nHidden = 0; + for(i=0; inCol; i++){ + if( i==pTab->iPKey ){ + /* The value of the INTEGER PRIMARY KEY column is always a NULL. + ** Whenever this column is read, the record number will be substituted + ** in its place. So will fill this column with a NULL to avoid + ** taking up data space with information that will never be used. */ + sqlite3VdbeAddOp(v, OP_Null, 0, 0); + continue; + } + if( pColumn==0 ){ + if( IsHiddenColumn(&pTab->aCol[i]) ){ + assert( IsVirtual(pTab) ); + j = -1; + nHidden++; + }else{ + j = i - nHidden; + } + }else{ + for(j=0; jnId; j++){ + if( pColumn->a[j].idx==i ) break; + } + } + if( j<0 || nColumn==0 || (pColumn && j>=pColumn->nId) ){ + sqlite3ExprCode(pParse, pTab->aCol[i].pDflt); + }else if( useTempTable ){ + sqlite3VdbeAddOp(v, OP_Column, srcTab, j); + }else if( pSelect ){ + sqlite3VdbeAddOp(v, OP_Dup, i+nColumn-j+IsVirtual(pTab), 1); + }else{ + sqlite3ExprCode(pParse, pList->a[j].pExpr); + } + } + + /* Generate code to check constraints and generate index keys and + ** do the insertion. + */ +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( IsVirtual(pTab) ){ + pParse->pVirtualLock = pTab; + sqlite3VdbeOp3(v, OP_VUpdate, 1, pTab->nCol+2, + (const char*)pTab->pVtab, P3_VTAB); + }else +#endif + { + sqlite3GenerateConstraintChecks(pParse, pTab, base, 0, keyColumn>=0, + 0, onError, endOfLoop); + sqlite3CompleteInsertion(pParse, pTab, base, 0,0,0, + (triggers_exist & TRIGGER_AFTER)!=0 ? newIdx : -1, + appendFlag); + } + } + + /* Update the count of rows that are inserted + */ + if( (db->flags & SQLITE_CountRows)!=0 ){ + sqlite3VdbeAddOp(v, OP_MemIncr, 1, iCntMem); + } + + if( triggers_exist ){ + /* Close all tables opened */ + if( !isView ){ + sqlite3VdbeAddOp(v, OP_Close, base, 0); + for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){ + sqlite3VdbeAddOp(v, OP_Close, idx+base, 0); + } + } + + /* Code AFTER triggers */ + if( sqlite3CodeRowTrigger(pParse, TK_INSERT, 0, TRIGGER_AFTER, pTab, + newIdx, -1, onError, endOfLoop) ){ + goto insert_cleanup; + } + } + + /* The bottom of the loop, if the data source is a SELECT statement + */ + sqlite3VdbeResolveLabel(v, endOfLoop); + if( useTempTable ){ + sqlite3VdbeAddOp(v, OP_Next, srcTab, iCont); + sqlite3VdbeResolveLabel(v, iBreak); + sqlite3VdbeAddOp(v, OP_Close, srcTab, 0); + }else if( pSelect ){ + sqlite3VdbeAddOp(v, OP_Pop, nColumn, 0); + sqlite3VdbeAddOp(v, OP_Return, 0, 0); + sqlite3VdbeResolveLabel(v, iCleanup); + } + + if( !triggers_exist && !IsVirtual(pTab) ){ + /* Close all tables opened */ + sqlite3VdbeAddOp(v, OP_Close, base, 0); + for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){ + sqlite3VdbeAddOp(v, OP_Close, idx+base, 0); + } + } + + /* Update the sqlite_sequence table by storing the content of the + ** counter value in memory counterMem back into the sqlite_sequence + ** table. + */ + autoIncEnd(pParse, iDb, pTab, counterMem); + + /* + ** Return the number of rows inserted. If this routine is + ** generating code because of a call to sqlite3NestedParse(), do not + ** invoke the callback function. + */ + if( db->flags & SQLITE_CountRows && pParse->nested==0 && !pParse->trigStack ){ + sqlite3VdbeAddOp(v, OP_MemLoad, iCntMem, 0); + sqlite3VdbeAddOp(v, OP_Callback, 1, 0); + sqlite3VdbeSetNumCols(v, 1); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows inserted", P3_STATIC); + } + +insert_cleanup: + sqlite3SrcListDelete(pTabList); + sqlite3ExprListDelete(pList); + sqlite3SelectDelete(pSelect); + sqlite3IdListDelete(pColumn); +} + +/* +** Generate code to do a constraint check prior to an INSERT or an UPDATE. +** +** When this routine is called, the stack contains (from bottom to top) +** the following values: +** +** 1. The rowid of the row to be updated before the update. This +** value is omitted unless we are doing an UPDATE that involves a +** change to the record number. +** +** 2. The rowid of the row after the update. +** +** 3. The data in the first column of the entry after the update. +** +** i. Data from middle columns... +** +** N. The data in the last column of the entry after the update. +** +** The old rowid shown as entry (1) above is omitted unless both isUpdate +** and rowidChng are 1. isUpdate is true for UPDATEs and false for +** INSERTs and rowidChng is true if the record number is being changed. +** +** The code generated by this routine pushes additional entries onto +** the stack which are the keys for new index entries for the new record. +** The order of index keys is the same as the order of the indices on +** the pTable->pIndex list. A key is only created for index i if +** aIdxUsed!=0 and aIdxUsed[i]!=0. +** +** This routine also generates code to check constraints. NOT NULL, +** CHECK, and UNIQUE constraints are all checked. If a constraint fails, +** then the appropriate action is performed. There are five possible +** actions: ROLLBACK, ABORT, FAIL, REPLACE, and IGNORE. +** +** Constraint type Action What Happens +** --------------- ---------- ---------------------------------------- +** any ROLLBACK The current transaction is rolled back and +** sqlite3_exec() returns immediately with a +** return code of SQLITE_CONSTRAINT. +** +** any ABORT Back out changes from the current command +** only (do not do a complete rollback) then +** cause sqlite3_exec() to return immediately +** with SQLITE_CONSTRAINT. +** +** any FAIL Sqlite_exec() returns immediately with a +** return code of SQLITE_CONSTRAINT. The +** transaction is not rolled back and any +** prior changes are retained. +** +** any IGNORE The record number and data is popped from +** the stack and there is an immediate jump +** to label ignoreDest. +** +** NOT NULL REPLACE The NULL value is replace by the default +** value for that column. If the default value +** is NULL, the action is the same as ABORT. +** +** UNIQUE REPLACE The other row that conflicts with the row +** being inserted is removed. +** +** CHECK REPLACE Illegal. The results in an exception. +** +** Which action to take is determined by the overrideError parameter. +** Or if overrideError==OE_Default, then the pParse->onError parameter +** is used. Or if pParse->onError==OE_Default then the onError value +** for the constraint is used. +** +** The calling routine must open a read/write cursor for pTab with +** cursor number "base". All indices of pTab must also have open +** read/write cursors with cursor number base+i for the i-th cursor. +** Except, if there is no possibility of a REPLACE action then +** cursors do not need to be open for indices where aIdxUsed[i]==0. +** +** If the isUpdate flag is true, it means that the "base" cursor is +** initially pointing to an entry that is being updated. The isUpdate +** flag causes extra code to be generated so that the "base" cursor +** is still pointing at the same entry after the routine returns. +** Without the isUpdate flag, the "base" cursor might be moved. +*/ +void sqlite3GenerateConstraintChecks( + Parse *pParse, /* The parser context */ + Table *pTab, /* the table into which we are inserting */ + int base, /* Index of a read/write cursor pointing at pTab */ + char *aIdxUsed, /* Which indices are used. NULL means all are used */ + int rowidChng, /* True if the record number will change */ + int isUpdate, /* True for UPDATE, False for INSERT */ + int overrideError, /* Override onError to this if not OE_Default */ + int ignoreDest /* Jump to this label on an OE_Ignore resolution */ +){ + int i; + Vdbe *v; + int nCol; + int onError; + int addr; + int extra; + int iCur; + Index *pIdx; + int seenReplace = 0; + int jumpInst1=0, jumpInst2; + int hasTwoRowids = (isUpdate && rowidChng); + + v = sqlite3GetVdbe(pParse); + assert( v!=0 ); + assert( pTab->pSelect==0 ); /* This table is not a VIEW */ + nCol = pTab->nCol; + + /* Test all NOT NULL constraints. + */ + for(i=0; iiPKey ){ + continue; + } + onError = pTab->aCol[i].notNull; + if( onError==OE_None ) continue; + if( overrideError!=OE_Default ){ + onError = overrideError; + }else if( onError==OE_Default ){ + onError = OE_Abort; + } + if( onError==OE_Replace && pTab->aCol[i].pDflt==0 ){ + onError = OE_Abort; + } + sqlite3VdbeAddOp(v, OP_Dup, nCol-1-i, 1); + addr = sqlite3VdbeAddOp(v, OP_NotNull, 1, 0); + assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail + || onError==OE_Ignore || onError==OE_Replace ); + switch( onError ){ + case OE_Rollback: + case OE_Abort: + case OE_Fail: { + char *zMsg = 0; + sqlite3VdbeAddOp(v, OP_Halt, SQLITE_CONSTRAINT, onError); + sqlite3SetString(&zMsg, pTab->zName, ".", pTab->aCol[i].zName, + " may not be NULL", (char*)0); + sqlite3VdbeChangeP3(v, -1, zMsg, P3_DYNAMIC); + break; + } + case OE_Ignore: { + sqlite3VdbeAddOp(v, OP_Pop, nCol+1+hasTwoRowids, 0); + sqlite3VdbeAddOp(v, OP_Goto, 0, ignoreDest); + break; + } + case OE_Replace: { + sqlite3ExprCode(pParse, pTab->aCol[i].pDflt); + sqlite3VdbeAddOp(v, OP_Push, nCol-i, 0); + break; + } + } + sqlite3VdbeJumpHere(v, addr); + } + + /* Test all CHECK constraints + */ +#ifndef SQLITE_OMIT_CHECK + if( pTab->pCheck && (pParse->db->flags & SQLITE_IgnoreChecks)==0 ){ + int allOk = sqlite3VdbeMakeLabel(v); + assert( pParse->ckOffset==0 ); + pParse->ckOffset = nCol; + sqlite3ExprIfTrue(pParse, pTab->pCheck, allOk, 1); + assert( pParse->ckOffset==nCol ); + pParse->ckOffset = 0; + onError = overrideError!=OE_Default ? overrideError : OE_Abort; + if( onError==OE_Ignore ){ + sqlite3VdbeAddOp(v, OP_Pop, nCol+1+hasTwoRowids, 0); + sqlite3VdbeAddOp(v, OP_Goto, 0, ignoreDest); + }else{ + sqlite3VdbeAddOp(v, OP_Halt, SQLITE_CONSTRAINT, onError); + } + sqlite3VdbeResolveLabel(v, allOk); + } +#endif /* !defined(SQLITE_OMIT_CHECK) */ + + /* If we have an INTEGER PRIMARY KEY, make sure the primary key + ** of the new record does not previously exist. Except, if this + ** is an UPDATE and the primary key is not changing, that is OK. + */ + if( rowidChng ){ + onError = pTab->keyConf; + if( overrideError!=OE_Default ){ + onError = overrideError; + }else if( onError==OE_Default ){ + onError = OE_Abort; + } + + if( isUpdate ){ + sqlite3VdbeAddOp(v, OP_Dup, nCol+1, 1); + sqlite3VdbeAddOp(v, OP_Dup, nCol+1, 1); + jumpInst1 = sqlite3VdbeAddOp(v, OP_Eq, 0, 0); + } + sqlite3VdbeAddOp(v, OP_Dup, nCol, 1); + jumpInst2 = sqlite3VdbeAddOp(v, OP_NotExists, base, 0); + switch( onError ){ + default: { + onError = OE_Abort; + /* Fall thru into the next case */ + } + case OE_Rollback: + case OE_Abort: + case OE_Fail: { + sqlite3VdbeOp3(v, OP_Halt, SQLITE_CONSTRAINT, onError, + "PRIMARY KEY must be unique", P3_STATIC); + break; + } + case OE_Replace: { + sqlite3GenerateRowIndexDelete(v, pTab, base, 0); + if( isUpdate ){ + sqlite3VdbeAddOp(v, OP_Dup, nCol+hasTwoRowids, 1); + sqlite3VdbeAddOp(v, OP_MoveGe, base, 0); + } + seenReplace = 1; + break; + } + case OE_Ignore: { + assert( seenReplace==0 ); + sqlite3VdbeAddOp(v, OP_Pop, nCol+1+hasTwoRowids, 0); + sqlite3VdbeAddOp(v, OP_Goto, 0, ignoreDest); + break; + } + } + sqlite3VdbeJumpHere(v, jumpInst2); + if( isUpdate ){ + sqlite3VdbeJumpHere(v, jumpInst1); + sqlite3VdbeAddOp(v, OP_Dup, nCol+1, 1); + sqlite3VdbeAddOp(v, OP_MoveGe, base, 0); + } + } + + /* Test all UNIQUE constraints by creating entries for each UNIQUE + ** index and making sure that duplicate entries do not already exist. + ** Add the new records to the indices as we go. + */ + extra = -1; + for(iCur=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, iCur++){ + if( aIdxUsed && aIdxUsed[iCur]==0 ) continue; /* Skip unused indices */ + extra++; + + /* Create a key for accessing the index entry */ + sqlite3VdbeAddOp(v, OP_Dup, nCol+extra, 1); + for(i=0; inColumn; i++){ + int idx = pIdx->aiColumn[i]; + if( idx==pTab->iPKey ){ + sqlite3VdbeAddOp(v, OP_Dup, i+extra+nCol+1, 1); + }else{ + sqlite3VdbeAddOp(v, OP_Dup, i+extra+nCol-idx, 1); + } + } + jumpInst1 = sqlite3VdbeAddOp(v, OP_MakeIdxRec, pIdx->nColumn, 0); + sqlite3IndexAffinityStr(v, pIdx); + + /* Find out what action to take in case there is an indexing conflict */ + onError = pIdx->onError; + if( onError==OE_None ) continue; /* pIdx is not a UNIQUE index */ + if( overrideError!=OE_Default ){ + onError = overrideError; + }else if( onError==OE_Default ){ + onError = OE_Abort; + } + if( seenReplace ){ + if( onError==OE_Ignore ) onError = OE_Replace; + else if( onError==OE_Fail ) onError = OE_Abort; + } + + + /* Check to see if the new index entry will be unique */ + sqlite3VdbeAddOp(v, OP_Dup, extra+nCol+1+hasTwoRowids, 1); + jumpInst2 = sqlite3VdbeAddOp(v, OP_IsUnique, base+iCur+1, 0); + + /* Generate code that executes if the new index entry is not unique */ + assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail + || onError==OE_Ignore || onError==OE_Replace ); + switch( onError ){ + case OE_Rollback: + case OE_Abort: + case OE_Fail: { + int j, n1, n2; + char zErrMsg[200]; + sqlite3_snprintf(sizeof(zErrMsg), zErrMsg, + pIdx->nColumn>1 ? "columns " : "column "); + n1 = strlen(zErrMsg); + for(j=0; jnColumn && n1aCol[pIdx->aiColumn[j]].zName; + n2 = strlen(zCol); + if( j>0 ){ + sqlite3_snprintf(sizeof(zErrMsg)-n1, &zErrMsg[n1], ", "); + n1 += 2; + } + if( n1+n2>sizeof(zErrMsg)-30 ){ + sqlite3_snprintf(sizeof(zErrMsg)-n1, &zErrMsg[n1], "..."); + n1 += 3; + break; + }else{ + sqlite3_snprintf(sizeof(zErrMsg)-n1, &zErrMsg[n1], "%s", zCol); + n1 += n2; + } + } + sqlite3_snprintf(sizeof(zErrMsg)-n1, &zErrMsg[n1], + pIdx->nColumn>1 ? " are not unique" : " is not unique"); + sqlite3VdbeOp3(v, OP_Halt, SQLITE_CONSTRAINT, onError, zErrMsg, 0); + break; + } + case OE_Ignore: { + assert( seenReplace==0 ); + sqlite3VdbeAddOp(v, OP_Pop, nCol+extra+3+hasTwoRowids, 0); + sqlite3VdbeAddOp(v, OP_Goto, 0, ignoreDest); + break; + } + case OE_Replace: { + sqlite3GenerateRowDelete(pParse->db, v, pTab, base, 0); + if( isUpdate ){ + sqlite3VdbeAddOp(v, OP_Dup, nCol+extra+1+hasTwoRowids, 1); + sqlite3VdbeAddOp(v, OP_MoveGe, base, 0); + } + seenReplace = 1; + break; + } + } +#if NULL_DISTINCT_FOR_UNIQUE + sqlite3VdbeJumpHere(v, jumpInst1); +#endif + sqlite3VdbeJumpHere(v, jumpInst2); + } +} + +/* +** This routine generates code to finish the INSERT or UPDATE operation +** that was started by a prior call to sqlite3GenerateConstraintChecks. +** The stack must contain keys for all active indices followed by data +** and the rowid for the new entry. This routine creates the new +** entries in all indices and in the main table. +** +** The arguments to this routine should be the same as the first six +** arguments to sqlite3GenerateConstraintChecks. +*/ +void sqlite3CompleteInsertion( + Parse *pParse, /* The parser context */ + Table *pTab, /* the table into which we are inserting */ + int base, /* Index of a read/write cursor pointing at pTab */ + char *aIdxUsed, /* Which indices are used. NULL means all are used */ + int rowidChng, /* True if the record number will change */ + int isUpdate, /* True for UPDATE, False for INSERT */ + int newIdx, /* Index of NEW table for triggers. -1 if none */ + int appendBias /* True if this is likely to be an append */ +){ + int i; + Vdbe *v; + int nIdx; + Index *pIdx; + int pik_flags; + + v = sqlite3GetVdbe(pParse); + assert( v!=0 ); + assert( pTab->pSelect==0 ); /* This table is not a VIEW */ + for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){} + for(i=nIdx-1; i>=0; i--){ + if( aIdxUsed && aIdxUsed[i]==0 ) continue; + sqlite3VdbeAddOp(v, OP_IdxInsert, base+i+1, 0); + } + sqlite3VdbeAddOp(v, OP_MakeRecord, pTab->nCol, 0); + sqlite3TableAffinityStr(v, pTab); +#ifndef SQLITE_OMIT_TRIGGER + if( newIdx>=0 ){ + sqlite3VdbeAddOp(v, OP_Dup, 1, 0); + sqlite3VdbeAddOp(v, OP_Dup, 1, 0); + sqlite3VdbeAddOp(v, OP_Insert, newIdx, 0); + } +#endif + if( pParse->nested ){ + pik_flags = 0; + }else{ + pik_flags = OPFLAG_NCHANGE; + pik_flags |= (isUpdate?OPFLAG_ISUPDATE:OPFLAG_LASTROWID); + } + if( appendBias ){ + pik_flags |= OPFLAG_APPEND; + } + sqlite3VdbeAddOp(v, OP_Insert, base, pik_flags); + if( !pParse->nested ){ + sqlite3VdbeChangeP3(v, -1, pTab->zName, P3_STATIC); + } + + if( isUpdate && rowidChng ){ + sqlite3VdbeAddOp(v, OP_Pop, 1, 0); + } +} + +/* +** Generate code that will open cursors for a table and for all +** indices of that table. The "base" parameter is the cursor number used +** for the table. Indices are opened on subsequent cursors. +*/ +void sqlite3OpenTableAndIndices( + Parse *pParse, /* Parsing context */ + Table *pTab, /* Table to be opened */ + int base, /* Cursor number assigned to the table */ + int op /* OP_OpenRead or OP_OpenWrite */ +){ + int i; + int iDb; + Index *pIdx; + Vdbe *v; + + if( IsVirtual(pTab) ) return; + iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + v = sqlite3GetVdbe(pParse); + assert( v!=0 ); + sqlite3OpenTable(pParse, base, iDb, pTab, op); + for(i=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){ + KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx); + assert( pIdx->pSchema==pTab->pSchema ); + sqlite3VdbeAddOp(v, OP_Integer, iDb, 0); + VdbeComment((v, "# %s", pIdx->zName)); + sqlite3VdbeOp3(v, op, i+base, pIdx->tnum, (char*)pKey, P3_KEYINFO_HANDOFF); + } + if( pParse->nTab<=base+i ){ + pParse->nTab = base+i; + } +} + + +#ifdef SQLITE_TEST +/* +** The following global variable is incremented whenever the +** transfer optimization is used. This is used for testing +** purposes only - to make sure the transfer optimization really +** is happening when it is suppose to. +*/ +int sqlite3_xferopt_count; +#endif /* SQLITE_TEST */ + + +#ifndef SQLITE_OMIT_XFER_OPT +/* +** Check to collation names to see if they are compatible. +*/ +static int xferCompatibleCollation(const char *z1, const char *z2){ + if( z1==0 ){ + return z2==0; + } + if( z2==0 ){ + return 0; + } + return sqlite3StrICmp(z1, z2)==0; +} + + +/* +** Check to see if index pSrc is compatible as a source of data +** for index pDest in an insert transfer optimization. The rules +** for a compatible index: +** +** * The index is over the same set of columns +** * The same DESC and ASC markings occurs on all columns +** * The same onError processing (OE_Abort, OE_Ignore, etc) +** * The same collating sequence on each column +*/ +static int xferCompatibleIndex(Index *pDest, Index *pSrc){ + int i; + assert( pDest && pSrc ); + assert( pDest->pTable!=pSrc->pTable ); + if( pDest->nColumn!=pSrc->nColumn ){ + return 0; /* Different number of columns */ + } + if( pDest->onError!=pSrc->onError ){ + return 0; /* Different conflict resolution strategies */ + } + for(i=0; inColumn; i++){ + if( pSrc->aiColumn[i]!=pDest->aiColumn[i] ){ + return 0; /* Different columns indexed */ + } + if( pSrc->aSortOrder[i]!=pDest->aSortOrder[i] ){ + return 0; /* Different sort orders */ + } + if( pSrc->azColl[i]!=pDest->azColl[i] ){ + return 0; /* Different sort orders */ + } + } + + /* If no test above fails then the indices must be compatible */ + return 1; +} + +/* +** Attempt the transfer optimization on INSERTs of the form +** +** INSERT INTO tab1 SELECT * FROM tab2; +** +** This optimization is only attempted if +** +** (1) tab1 and tab2 have identical schemas including all the +** same indices and constraints +** +** (2) tab1 and tab2 are different tables +** +** (3) There must be no triggers on tab1 +** +** (4) The result set of the SELECT statement is "*" +** +** (5) The SELECT statement has no WHERE, HAVING, ORDER BY, GROUP BY, +** or LIMIT clause. +** +** (6) The SELECT statement is a simple (not a compound) select that +** contains only tab2 in its FROM clause +** +** This method for implementing the INSERT transfers raw records from +** tab2 over to tab1. The columns are not decoded. Raw records from +** the indices of tab2 are transfered to tab1 as well. In so doing, +** the resulting tab1 has much less fragmentation. +** +** This routine returns TRUE if the optimization is attempted. If any +** of the conditions above fail so that the optimization should not +** be attempted, then this routine returns FALSE. +*/ +static int xferOptimization( + Parse *pParse, /* Parser context */ + Table *pDest, /* The table we are inserting into */ + Select *pSelect, /* A SELECT statement to use as the data source */ + int onError, /* How to handle constraint errors */ + int iDbDest /* The database of pDest */ +){ + ExprList *pEList; /* The result set of the SELECT */ + Table *pSrc; /* The table in the FROM clause of SELECT */ + Index *pSrcIdx, *pDestIdx; /* Source and destination indices */ + SrcList::SrcList_item *pItem; /* An element of pSelect->pSrc */ + int i; /* Loop counter */ + int iDbSrc; /* The database of pSrc */ + int iSrc, iDest; /* Cursors from source and destination */ + int addr1, addr2; /* Loop addresses */ + int emptyDestTest; /* Address of test for empty pDest */ + int emptySrcTest; /* Address of test for empty pSrc */ + Vdbe *v; /* The VDBE we are building */ + KeyInfo *pKey; /* Key information for an index */ + int counterMem; /* Memory register used by AUTOINC */ + int destHasUniqueIdx = 0; /* True if pDest has a UNIQUE index */ + + if( pSelect==0 ){ + return 0; /* Must be of the form INSERT INTO ... SELECT ... */ + } + if( pDest->pTrigger ){ + return 0; /* tab1 must not have triggers */ + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( pDest->isVirtual ){ + return 0; /* tab1 must not be a virtual table */ + } +#endif + if( onError==OE_Default ){ + onError = OE_Abort; + } + if( onError!=OE_Abort && onError!=OE_Rollback ){ + return 0; /* Cannot do OR REPLACE or OR IGNORE or OR FAIL */ + } + assert(pSelect->pSrc); /* allocated even if there is no FROM clause */ + if( pSelect->pSrc->nSrc!=1 ){ + return 0; /* FROM clause must have exactly one term */ + } + if( pSelect->pSrc->a[0].pSelect ){ + return 0; /* FROM clause cannot contain a subquery */ + } + if( pSelect->pWhere ){ + return 0; /* SELECT may not have a WHERE clause */ + } + if( pSelect->pOrderBy ){ + return 0; /* SELECT may not have an ORDER BY clause */ + } + /* Do not need to test for a HAVING clause. If HAVING is present but + ** there is no ORDER BY, we will get an error. */ + if( pSelect->pGroupBy ){ + return 0; /* SELECT may not have a GROUP BY clause */ + } + if( pSelect->pLimit ){ + return 0; /* SELECT may not have a LIMIT clause */ + } + assert( pSelect->pOffset==0 ); /* Must be so if pLimit==0 */ + if( pSelect->pPrior ){ + return 0; /* SELECT may not be a compound query */ + } + if( pSelect->isDistinct ){ + return 0; /* SELECT may not be DISTINCT */ + } + pEList = pSelect->pEList; + assert( pEList!=0 ); + if( pEList->nExpr!=1 ){ + return 0; /* The result set must have exactly one column */ + } + assert( pEList->a[0].pExpr ); + if( pEList->a[0].pExpr->op!=TK_ALL ){ + return 0; /* The result set must be the special operator "*" */ + } + + /* At this point we have established that the statement is of the + ** correct syntactic form to participate in this optimization. Now + ** we have to check the semantics. + */ + pItem = pSelect->pSrc->a; + pSrc = sqlite3LocateTable(pParse, pItem->zName, pItem->zDatabase); + if( pSrc==0 ){ + return 0; /* FROM clause does not contain a real table */ + } + if( pSrc==pDest ){ + return 0; /* tab1 and tab2 may not be the same table */ + } +#ifndef SQLITE_OMIT_VIRTUALTABLE + if( pSrc->isVirtual ){ + return 0; /* tab2 must not be a virtual table */ + } +#endif + if( pSrc->pSelect ){ + return 0; /* tab2 may not be a view */ + } + if( pDest->nCol!=pSrc->nCol ){ + return 0; /* Number of columns must be the same in tab1 and tab2 */ + } + if( pDest->iPKey!=pSrc->iPKey ){ + return 0; /* Both tables must have the same INTEGER PRIMARY KEY */ + } + for(i=0; inCol; i++){ + if( pDest->aCol[i].affinity!=pSrc->aCol[i].affinity ){ + return 0; /* Affinity must be the same on all columns */ + } + if( !xferCompatibleCollation(pDest->aCol[i].zColl, pSrc->aCol[i].zColl) ){ + return 0; /* Collating sequence must be the same on all columns */ + } + if( pDest->aCol[i].notNull && !pSrc->aCol[i].notNull ){ + return 0; /* tab2 must be NOT NULL if tab1 is */ + } + } + for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){ + if( pDestIdx->onError!=OE_None ){ + destHasUniqueIdx = 1; + } + for(pSrcIdx=pSrc->pIndex; pSrcIdx; pSrcIdx=pSrcIdx->pNext){ + if( xferCompatibleIndex(pDestIdx, pSrcIdx) ) break; + } + if( pSrcIdx==0 ){ + return 0; /* pDestIdx has no corresponding index in pSrc */ + } + } +#ifndef SQLITE_OMIT_CHECK + if( pDest->pCheck && !sqlite3ExprCompare(pSrc->pCheck, pDest->pCheck) ){ + return 0; /* Tables have different CHECK constraints. Ticket #2252 */ + } +#endif + + /* If we get this far, it means either: + ** + ** * We can always do the transfer if the table contains an + ** an integer primary key + ** + ** * We can conditionally do the transfer if the destination + ** table is empty. + */ +#ifdef SQLITE_TEST + sqlite3_xferopt_count++; +#endif + iDbSrc = sqlite3SchemaToIndex(pParse->db, pSrc->pSchema); + v = sqlite3GetVdbe(pParse); + sqlite3CodeVerifySchema(pParse, iDbSrc); + iSrc = pParse->nTab++; + iDest = pParse->nTab++; + counterMem = autoIncBegin(pParse, iDbDest, pDest); + sqlite3OpenTable(pParse, iDest, iDbDest, pDest, OP_OpenWrite); + if( (pDest->iPKey<0 && pDest->pIndex!=0) || destHasUniqueIdx ){ + /* If tables do not have an INTEGER PRIMARY KEY and there + ** are indices to be copied and the destination is not empty, + ** we have to disallow the transfer optimization because the + ** the rowids might change which will mess up indexing. + ** + ** Or if the destination has a UNIQUE index and is not empty, + ** we also disallow the transfer optimization because we cannot + ** insure that all entries in the union of DEST and SRC will be + ** unique. + */ + addr1 = sqlite3VdbeAddOp(v, OP_Rewind, iDest, 0); + emptyDestTest = sqlite3VdbeAddOp(v, OP_Goto, 0, 0); + sqlite3VdbeJumpHere(v, addr1); + }else{ + emptyDestTest = 0; + } + sqlite3OpenTable(pParse, iSrc, iDbSrc, pSrc, OP_OpenRead); + emptySrcTest = sqlite3VdbeAddOp(v, OP_Rewind, iSrc, 0); + if( pDest->iPKey>=0 ){ + addr1 = sqlite3VdbeAddOp(v, OP_Rowid, iSrc, 0); + sqlite3VdbeAddOp(v, OP_Dup, 0, 0); + addr2 = sqlite3VdbeAddOp(v, OP_NotExists, iDest, 0); + sqlite3VdbeOp3(v, OP_Halt, SQLITE_CONSTRAINT, onError, + "PRIMARY KEY must be unique", P3_STATIC); + sqlite3VdbeJumpHere(v, addr2); + autoIncStep(pParse, counterMem); + }else if( pDest->pIndex==0 ){ + addr1 = sqlite3VdbeAddOp(v, OP_NewRowid, iDest, 0); + }else{ + addr1 = sqlite3VdbeAddOp(v, OP_Rowid, iSrc, 0); + assert( pDest->autoInc==0 ); + } + sqlite3VdbeAddOp(v, OP_RowData, iSrc, 0); + sqlite3VdbeOp3(v, OP_Insert, iDest, + OPFLAG_NCHANGE|OPFLAG_LASTROWID|OPFLAG_APPEND, + pDest->zName, 0); + sqlite3VdbeAddOp(v, OP_Next, iSrc, addr1); + autoIncEnd(pParse, iDbDest, pDest, counterMem); + for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){ + for(pSrcIdx=pSrc->pIndex; pSrcIdx; pSrcIdx=pSrcIdx->pNext){ + if( xferCompatibleIndex(pDestIdx, pSrcIdx) ) break; + } + assert( pSrcIdx ); + sqlite3VdbeAddOp(v, OP_Close, iSrc, 0); + sqlite3VdbeAddOp(v, OP_Close, iDest, 0); + sqlite3VdbeAddOp(v, OP_Integer, iDbSrc, 0); + pKey = sqlite3IndexKeyinfo(pParse, pSrcIdx); + VdbeComment((v, "# %s", pSrcIdx->zName)); + sqlite3VdbeOp3(v, OP_OpenRead, iSrc, pSrcIdx->tnum, + (char*)pKey, P3_KEYINFO_HANDOFF); + sqlite3VdbeAddOp(v, OP_Integer, iDbDest, 0); + pKey = sqlite3IndexKeyinfo(pParse, pDestIdx); + VdbeComment((v, "# %s", pDestIdx->zName)); + sqlite3VdbeOp3(v, OP_OpenWrite, iDest, pDestIdx->tnum, + (char*)pKey, P3_KEYINFO_HANDOFF); + addr1 = sqlite3VdbeAddOp(v, OP_Rewind, iSrc, 0); + sqlite3VdbeAddOp(v, OP_RowKey, iSrc, 0); + sqlite3VdbeAddOp(v, OP_IdxInsert, iDest, 1); + sqlite3VdbeAddOp(v, OP_Next, iSrc, addr1+1); + sqlite3VdbeJumpHere(v, addr1); + } + sqlite3VdbeJumpHere(v, emptySrcTest); + sqlite3VdbeAddOp(v, OP_Close, iSrc, 0); + sqlite3VdbeAddOp(v, OP_Close, iDest, 0); + if( emptyDestTest ){ + sqlite3VdbeAddOp(v, OP_Halt, SQLITE_OK, 0); + sqlite3VdbeJumpHere(v, emptyDestTest); + sqlite3VdbeAddOp(v, OP_Close, iDest, 0); + return 0; + }else{ + return 1; + } +} +#endif /* SQLITE_OMIT_XFER_OPT */ diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/journal.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/journal.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,238 @@ +/* +** 2007 August 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** @(#) $Id: journal.cpp 1282 2008-11-13 09:31:33Z LarsPson $ +*/ + +#ifdef SQLITE_ENABLE_ATOMIC_WRITE + +/* +** This file implements a special kind of sqlite3_file object used +** by SQLite to create journal files if the atomic-write optimization +** is enabled. +** +** The distinctive characteristic of this sqlite3_file is that the +** actual on disk file is created lazily. When the file is created, +** the caller specifies a buffer size for an in-memory buffer to +** be used to service read() and write() requests. The actual file +** on disk is not created or populated until either: +** +** 1) The in-memory representation grows too large for the allocated +** buffer, or +** 2) The xSync() method is called. +*/ + +#include "sqliteInt.h" + + +/* +** A JournalFile object is a subclass of sqlite3_file used by +** as an open file handle for journal files. +*/ +struct JournalFile { + sqlite3_io_methods *pMethod; /* I/O methods on journal files */ + int nBuf; /* Size of zBuf[] in bytes */ + char *zBuf; /* Space to buffer journal writes */ + int iSize; /* Amount of zBuf[] currently used */ + int flags; /* xOpen flags */ + sqlite3_vfs *pVfs; /* The "real" underlying VFS */ + sqlite3_file *pReal; /* The "real" underlying file descriptor */ + const char *zJournal; /* Name of the journal file */ +}; +typedef struct JournalFile JournalFile; + +/* +** If it does not already exists, create and populate the on-disk file +** for JournalFile p. +*/ +static int createFile(JournalFile *p){ + int rc = SQLITE_OK; + if( !p->pReal ){ + sqlite3_file *pReal = (sqlite3_file *)&p[1]; + rc = sqlite3OsOpen(p->pVfs, p->zJournal, pReal, p->flags, 0); + if( rc==SQLITE_OK ){ + p->pReal = pReal; + if( p->iSize>0 ){ + assert(p->iSize<=p->nBuf); + rc = sqlite3OsWrite(p->pReal, p->zBuf, p->iSize, 0); + } + } + } + return rc; +} + +/* +** Close the file. +*/ +static int jrnlClose(sqlite3_file *pJfd){ + JournalFile *p = (JournalFile *)pJfd; + if( p->pReal ){ + sqlite3OsClose(p->pReal); + } + sqlite3_free(p->zBuf); + return SQLITE_OK; +} + +/* +** Read data from the file. +*/ +static int jrnlRead( + sqlite3_file *pJfd, /* The journal file from which to read */ + void *zBuf, /* Put the results here */ + int iAmt, /* Number of bytes to read */ + sqlite_int64 iOfst /* Begin reading at this offset */ +){ + int rc = SQLITE_OK; + JournalFile *p = (JournalFile *)pJfd; + if( p->pReal ){ + rc = sqlite3OsRead(p->pReal, zBuf, iAmt, iOfst); + }else{ + assert( iAmt+iOfst<=p->iSize ); + memcpy(zBuf, &p->zBuf[iOfst], iAmt); + } + return rc; +} + +/* +** Write data to the file. +*/ +static int jrnlWrite( + sqlite3_file *pJfd, /* The journal file into which to write */ + const void *zBuf, /* Take data to be written from here */ + int iAmt, /* Number of bytes to write */ + sqlite_int64 iOfst /* Begin writing at this offset into the file */ +){ + int rc = SQLITE_OK; + JournalFile *p = (JournalFile *)pJfd; + if( !p->pReal && (iOfst+iAmt)>p->nBuf ){ + rc = createFile(p); + } + if( rc==SQLITE_OK ){ + if( p->pReal ){ + rc = sqlite3OsWrite(p->pReal, zBuf, iAmt, iOfst); + }else{ + memcpy(&p->zBuf[iOfst], zBuf, iAmt); + if( p->iSize<(iOfst+iAmt) ){ + p->iSize = (iOfst+iAmt); + } + } + } + return rc; +} + +/* +** Truncate the file. +*/ +static int jrnlTruncate(sqlite3_file *pJfd, sqlite_int64 size){ + int rc = SQLITE_OK; + JournalFile *p = (JournalFile *)pJfd; + if( p->pReal ){ + rc = sqlite3OsTruncate(p->pReal, size); + }else if( sizeiSize ){ + p->iSize = size; + } + return rc; +} + +/* +** Sync the file. +*/ +static int jrnlSync(sqlite3_file *pJfd, int flags){ + int rc; + JournalFile *p = (JournalFile *)pJfd; + rc = createFile(p); + if( rc==SQLITE_OK ){ + rc = sqlite3OsSync(p->pReal, flags); + } + return rc; +} + +/* +** Query the size of the file in bytes. +*/ +static int jrnlFileSize(sqlite3_file *pJfd, sqlite_int64 *pSize){ + int rc = SQLITE_OK; + JournalFile *p = (JournalFile *)pJfd; + if( p->pReal ){ + rc = sqlite3OsFileSize(p->pReal, pSize); + }else{ + *pSize = (sqlite_int64) p->iSize; + } + return rc; +} + +/* +** Table of methods for JournalFile sqlite3_file object. +*/ +static struct sqlite3_io_methods JournalFileMethods = { + 1, /* iVersion */ + jrnlClose, /* xClose */ + jrnlRead, /* xRead */ + jrnlWrite, /* xWrite */ + jrnlTruncate, /* xTruncate */ + jrnlSync, /* xSync */ + jrnlFileSize, /* xFileSize */ + 0, /* xLock */ + 0, /* xUnlock */ + 0, /* xCheckReservedLock */ + 0, /* xFileControl */ + 0, /* xSectorSize */ + 0 /* xDeviceCharacteristics */ +}; + +/* +** Open a journal file. +*/ +int sqlite3JournalOpen( + sqlite3_vfs *pVfs, /* The VFS to use for actual file I/O */ + const char *zName, /* Name of the journal file */ + sqlite3_file *pJfd, /* Preallocated, blank file handle */ + int flags, /* Opening flags */ + int nBuf /* Bytes buffered before opening the file */ +){ + JournalFile *p = (JournalFile *)pJfd; + memset(p, 0, sqlite3JournalSize(pVfs)); + if( nBuf>0 ){ + p->zBuf = sqlite3MallocZero(nBuf); + if( !p->zBuf ){ + return SQLITE_NOMEM; + } + }else{ + return sqlite3OsOpen(pVfs, zName, pJfd, flags, 0); + } + p->pMethod = &JournalFileMethods; + p->nBuf = nBuf; + p->flags = flags; + p->zJournal = zName; + p->pVfs = pVfs; + return SQLITE_OK; +} + +/* +** If the argument p points to a JournalFile structure, and the underlying +** file has not yet been created, create it now. +*/ +int sqlite3JournalCreate(sqlite3_file *p){ + if( p->pMethods!=&JournalFileMethods ){ + return SQLITE_OK; + } + return createFile((JournalFile *)p); +} + +/* +** Return the number of bytes required to store a JournalFile that uses vfs +** pVfs to create the underlying on-disk files. +*/ +int sqlite3JournalSize(sqlite3_vfs *pVfs){ + return (pVfs->szOsFile+sizeof(JournalFile)); +} +#endif diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/keywordhash.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/keywordhash.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,112 @@ +/***** This file contains automatically generated code ****** +** +** The code in this file has been automatically generated by +** +** $Header: /sqlite/sqlite/tool/mkkeywordhash.c,v 1.31 2007/07/30 18:26:20 rse Exp $ +** +** The code in this file implements a function that determines whether +** or not a given identifier is really an SQL keyword. The same thing +** might be implemented more directly using a hand-written hash table. +** But by using this automatically generated code, the size of the code +** is substantially reduced. This is important for embedded applications +** on platforms with limited memory. +*/ +/* Hash score: 165 */ +static int keywordCode(const char *z, int n){ + /* zText[] encodes 775 bytes of keywords in 526 bytes */ + static const char zText[526] = + "BEFOREIGNOREGEXPLAINSTEADDESCAPEACHECKEYCONSTRAINTERSECTABLEFT" + "HENDATABASELECTRANSACTIONATURALTERAISELSEXCEPTRIGGEREFERENCES" + "UNIQUERYATTACHAVINGROUPDATEMPORARYBEGINNEREINDEXCLUSIVEXISTSBETWEEN" + "OTNULLIKECASCADEFERRABLECASECOLLATECREATECURRENT_DATEDELETEDETACH" + "IMMEDIATEJOINSERTMATCHPLANALYZEPRAGMABORTVALUESVIRTUALIMITWHEN" + "WHERENAMEAFTEREPLACEANDEFAULTAUTOINCREMENTCASTCOLUMNCOMMITCONFLICT" + "CROSSCURRENT_TIMESTAMPRIMARYDEFERREDISTINCTDROPFAILFROMFULLGLOB" + "YIFINTOFFSETISNULLORDERESTRICTOUTERIGHTROLLBACKROWUNIONUSINGVACUUM" + "VIEWINITIALLY"; + static const unsigned char aHash[127] = { + 63, 92, 109, 61, 0, 38, 0, 0, 69, 0, 64, 0, 0, + 102, 4, 65, 7, 0, 108, 72, 103, 99, 0, 22, 0, 0, + 113, 0, 111, 106, 0, 18, 80, 0, 1, 0, 0, 56, 57, + 0, 55, 11, 0, 33, 77, 89, 0, 110, 88, 0, 0, 45, + 0, 90, 54, 0, 20, 0, 114, 34, 19, 0, 10, 97, 28, + 83, 0, 0, 116, 93, 47, 115, 41, 12, 44, 0, 78, 0, + 87, 29, 0, 86, 0, 0, 0, 82, 79, 84, 75, 96, 6, + 14, 95, 0, 68, 0, 21, 76, 98, 27, 0, 112, 67, 104, + 49, 40, 71, 0, 0, 81, 100, 0, 107, 0, 15, 0, 0, + 24, 0, 73, 42, 50, 0, 16, 48, 0, 37, + }; + static const unsigned char aNext[116] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, + 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 0, 0, + 17, 0, 0, 0, 36, 39, 0, 0, 25, 0, 0, 31, 0, + 0, 0, 43, 52, 0, 0, 0, 53, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 51, 0, 0, 0, 0, 26, 0, 8, 46, + 2, 0, 0, 0, 0, 0, 0, 0, 3, 58, 66, 0, 13, + 0, 91, 85, 0, 94, 0, 74, 0, 0, 62, 0, 35, 101, + 0, 0, 105, 23, 30, 60, 70, 0, 0, 59, 0, 0, + }; + static const unsigned char aLen[116] = { + 6, 7, 3, 6, 6, 7, 7, 3, 4, 6, 4, 5, 3, + 10, 9, 5, 4, 4, 3, 8, 2, 6, 11, 2, 7, 5, + 5, 4, 6, 7, 10, 6, 5, 6, 6, 5, 6, 4, 9, + 2, 5, 5, 7, 5, 9, 6, 7, 7, 3, 4, 4, 7, + 3, 10, 4, 7, 6, 12, 6, 6, 9, 4, 6, 5, 4, + 7, 6, 5, 6, 7, 5, 4, 5, 6, 5, 7, 3, 7, + 13, 2, 2, 4, 6, 6, 8, 5, 17, 12, 7, 8, 8, + 2, 4, 4, 4, 4, 4, 2, 2, 4, 6, 2, 3, 6, + 5, 8, 5, 5, 8, 3, 5, 5, 6, 4, 9, 3, + }; + static const unsigned short int aOffset[116] = { + 0, 2, 2, 6, 10, 13, 18, 23, 25, 26, 31, 33, 37, + 40, 47, 55, 58, 61, 63, 65, 70, 71, 76, 85, 86, 91, + 95, 99, 102, 107, 113, 123, 126, 131, 136, 141, 144, 148, 148, + 152, 157, 160, 164, 166, 169, 177, 183, 189, 189, 192, 195, 199, + 200, 204, 214, 218, 225, 231, 243, 249, 255, 264, 266, 272, 277, + 279, 286, 291, 296, 302, 308, 313, 317, 320, 326, 330, 337, 339, + 346, 348, 350, 359, 363, 369, 375, 383, 388, 388, 404, 411, 418, + 419, 426, 430, 434, 438, 442, 445, 447, 449, 452, 452, 455, 458, + 464, 468, 476, 480, 485, 493, 496, 501, 506, 512, 516, 521, + }; + static const unsigned char aCode[116] = { + TK_BEFORE, TK_FOREIGN, TK_FOR, TK_IGNORE, TK_LIKE_KW, + TK_EXPLAIN, TK_INSTEAD, TK_ADD, TK_DESC, TK_ESCAPE, + TK_EACH, TK_CHECK, TK_KEY, TK_CONSTRAINT, TK_INTERSECT, + TK_TABLE, TK_JOIN_KW, TK_THEN, TK_END, TK_DATABASE, + TK_AS, TK_SELECT, TK_TRANSACTION,TK_ON, TK_JOIN_KW, + TK_ALTER, TK_RAISE, TK_ELSE, TK_EXCEPT, TK_TRIGGER, + TK_REFERENCES, TK_UNIQUE, TK_QUERY, TK_ATTACH, TK_HAVING, + TK_GROUP, TK_UPDATE, TK_TEMP, TK_TEMP, TK_OR, + TK_BEGIN, TK_JOIN_KW, TK_REINDEX, TK_INDEX, TK_EXCLUSIVE, + TK_EXISTS, TK_BETWEEN, TK_NOTNULL, TK_NOT, TK_NULL, + TK_LIKE_KW, TK_CASCADE, TK_ASC, TK_DEFERRABLE, TK_CASE, + TK_COLLATE, TK_CREATE, TK_CTIME_KW, TK_DELETE, TK_DETACH, + TK_IMMEDIATE, TK_JOIN, TK_INSERT, TK_MATCH, TK_PLAN, + TK_ANALYZE, TK_PRAGMA, TK_ABORT, TK_VALUES, TK_VIRTUAL, + TK_LIMIT, TK_WHEN, TK_WHERE, TK_RENAME, TK_AFTER, + TK_REPLACE, TK_AND, TK_DEFAULT, TK_AUTOINCR, TK_TO, + TK_IN, TK_CAST, TK_COLUMNKW, TK_COMMIT, TK_CONFLICT, + TK_JOIN_KW, TK_CTIME_KW, TK_CTIME_KW, TK_PRIMARY, TK_DEFERRED, + TK_DISTINCT, TK_IS, TK_DROP, TK_FAIL, TK_FROM, + TK_JOIN_KW, TK_LIKE_KW, TK_BY, TK_IF, TK_INTO, + TK_OFFSET, TK_OF, TK_SET, TK_ISNULL, TK_ORDER, + TK_RESTRICT, TK_JOIN_KW, TK_JOIN_KW, TK_ROLLBACK, TK_ROW, + TK_UNION, TK_USING, TK_VACUUM, TK_VIEW, TK_INITIALLY, + TK_ALL, + }; + int h, i; + if( n<2 ) return TK_ID; + h = ((charMap(z[0])*4) ^ + (charMap(z[n-1])*3) ^ + n) % 127; + for(i=((int)aHash[h])-1; i>=0; i=((int)aNext[i])-1){ + if( aLen[i]==n && sqlite3StrNICmp(&zText[aOffset[i]],z,n)==0 ){ + return aCode[i]; + } + } + return TK_ID; +} +int sqlite3KeywordCode(const unsigned char *z, int n){ + return keywordCode((char*)z, n); +} diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/legacy.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/legacy.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,134 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** Main file for the SQLite library. The routines in this file +** implement the programmer interface to the library. Routines in +** other files are for internal use by SQLite and should not be +** accessed by users of the library. +** +** $Id: legacy.cpp 1282 2008-11-13 09:31:33Z LarsPson $ +*/ + +#include "sqliteInt.h" +#include + +/* +** Execute SQL code. Return one of the SQLITE_ success/failure +** codes. Also write an error message into memory obtained from +** malloc() and make *pzErrMsg point to that message. +** +** If the SQL is a query, then for each row in the query result +** the xCallback() function is called. pArg becomes the first +** argument to xCallback(). If xCallback=NULL then no callback +** is invoked, even for queries. +*/ +EXPORT_C int sqlite3_exec( + sqlite3 *db, /* The database on which the SQL executes */ + const char *zSql, /* The SQL to be executed */ + sqlite3_callback xCallback, /* Invoke this callback routine */ + void *pArg, /* First argument to xCallback() */ + char **pzErrMsg /* Write error messages here */ +){ + int rc = SQLITE_OK; + const char *zLeftover; + sqlite3_stmt *pStmt = 0; + char **azCols = 0; + + int nRetry = 0; + int nCallback; + + if( zSql==0 ) return SQLITE_OK; + + sqlite3_mutex_enter(db->mutex); + while( (rc==SQLITE_OK || (rc==SQLITE_SCHEMA && (++nRetry)<2)) && zSql[0] ){ + int nCol; + char **azVals = 0; + + pStmt = 0; + rc = sqlite3_prepare(db, zSql, -1, &pStmt, &zLeftover); + assert( rc==SQLITE_OK || pStmt==0 ); + if( rc!=SQLITE_OK ){ + continue; + } + if( !pStmt ){ + /* this happens for a comment or white-space */ + zSql = zLeftover; + continue; + } + + nCallback = 0; + + nCol = sqlite3_column_count(pStmt); + azCols = (char**)sqlite3DbMallocZero(db, 2*nCol*sizeof(const char *) + 1); + if( azCols==0 ){ + goto exec_out; + } + + while( 1 ){ + int i; + rc = sqlite3_step(pStmt); + + /* Invoke the callback function if required */ + if( xCallback && (SQLITE_ROW==rc || + (SQLITE_DONE==rc && !nCallback && db->flags&SQLITE_NullCallback)) ){ + if( 0==nCallback ){ + for(i=0; ierrMask)==rc ); + sqlite3_mutex_leave(db->mutex); + return rc; +} diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/loadext.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/loadext.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,516 @@ +/* +** 2006 June 7 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code used to dynamically load extensions into +** the SQLite library. +*/ +#ifndef SQLITE_OMIT_LOAD_EXTENSION + +#define SQLITE_CORE 1 /* Disable the API redefinition in sqlite3ext.h */ +#include "sqlite3ext.h" +#include "sqliteInt.h" +#include +#include + +/* +** Some API routines are omitted when various features are +** excluded from a build of SQLite. Substitute a NULL pointer +** for any missing APIs. +*/ +#ifndef SQLITE_ENABLE_COLUMN_METADATA +# define sqlite3_column_database_name 0 +# define sqlite3_column_database_name16 0 +# define sqlite3_column_table_name 0 +# define sqlite3_column_table_name16 0 +# define sqlite3_column_origin_name 0 +# define sqlite3_column_origin_name16 0 +# define sqlite3_table_column_metadata 0 +#endif + +#ifdef SQLITE_OMIT_AUTHORIZATION +# define sqlite3_set_authorizer 0 +#endif + +#ifdef SQLITE_OMIT_UTF16 +# define sqlite3_bind_text16 0 +# define sqlite3_collation_needed16 0 +# define sqlite3_column_decltype16 0 +# define sqlite3_column_name16 0 +# define sqlite3_column_text16 0 +# define sqlite3_complete16 0 +# define sqlite3_create_collation16 0 +# define sqlite3_create_function16 0 +# define sqlite3_errmsg16 0 +# define sqlite3_open16 0 +# define sqlite3_prepare16 0 +# define sqlite3_prepare16_v2 0 +# define sqlite3_result_error16 0 +# define sqlite3_result_text16 0 +# define sqlite3_result_text16be 0 +# define sqlite3_result_text16le 0 +# define sqlite3_value_text16 0 +# define sqlite3_value_text16be 0 +# define sqlite3_value_text16le 0 +# define sqlite3_column_database_name16 0 +# define sqlite3_column_table_name16 0 +# define sqlite3_column_origin_name16 0 +#endif + +#ifdef SQLITE_OMIT_COMPLETE +# define sqlite3_complete 0 +# define sqlite3_complete16 0 +#endif + +#ifdef SQLITE_OMIT_PROGRESS_CALLBACK +# define sqlite3_progress_handler 0 +#endif + +#ifdef SQLITE_OMIT_VIRTUALTABLE +# define sqlite3_create_module 0 +# define sqlite3_create_module_v2 0 +# define sqlite3_declare_vtab 0 +#endif + +#ifdef SQLITE_OMIT_SHARED_CACHE +# define sqlite3_enable_shared_cache 0 +#endif + +#ifdef SQLITE_OMIT_TRACE +# define sqlite3_profile 0 +# define sqlite3_trace 0 +#endif + +#ifdef SQLITE_OMIT_GET_TABLE +# define sqlite3_free_table 0 +# define sqlite3_get_table 0 +#endif + +#ifdef SQLITE_OMIT_INCRBLOB +#define sqlite3_bind_zeroblob 0 +#define sqlite3_blob_bytes 0 +#define sqlite3_blob_close 0 +#define sqlite3_blob_open 0 +#define sqlite3_blob_read 0 +#define sqlite3_blob_write 0 +#endif + +/* +** The following structure contains pointers to all SQLite API routines. +** A pointer to this structure is passed into extensions when they are +** loaded so that the extension can make calls back into the SQLite +** library. +** +** When adding new APIs, add them to the bottom of this structure +** in order to preserve backwards compatibility. +** +** Extensions that use newer APIs should first call the +** sqlite3_libversion_number() to make sure that the API they +** intend to use is supported by the library. Extensions should +** also check to make sure that the pointer to the function is +** not NULL before calling it. +*/ +const sqlite3_api_routines sqlite3_apis = { + sqlite3_aggregate_context, + sqlite3_aggregate_count, + sqlite3_bind_blob, + sqlite3_bind_double, + sqlite3_bind_int, + sqlite3_bind_int64, + sqlite3_bind_null, + sqlite3_bind_parameter_count, + sqlite3_bind_parameter_index, + sqlite3_bind_parameter_name, + sqlite3_bind_text, + sqlite3_bind_text16, + sqlite3_bind_value, + sqlite3_busy_handler, + sqlite3_busy_timeout, + sqlite3_changes, + sqlite3_close, + sqlite3_collation_needed, + sqlite3_collation_needed16, + sqlite3_column_blob, + sqlite3_column_bytes, + sqlite3_column_bytes16, + sqlite3_column_count, + sqlite3_column_database_name, + sqlite3_column_database_name16, + sqlite3_column_decltype, + sqlite3_column_decltype16, + sqlite3_column_double, + sqlite3_column_int, + sqlite3_column_int64, + sqlite3_column_name, + sqlite3_column_name16, + sqlite3_column_origin_name, + sqlite3_column_origin_name16, + sqlite3_column_table_name, + sqlite3_column_table_name16, + sqlite3_column_text, + sqlite3_column_text16, + sqlite3_column_type, + sqlite3_column_value, + sqlite3_commit_hook, + sqlite3_complete, + sqlite3_complete16, + sqlite3_create_collation, + sqlite3_create_collation16, + sqlite3_create_function, + sqlite3_create_function16, + sqlite3_create_module, + sqlite3_data_count, + sqlite3_db_handle, + sqlite3_declare_vtab, + sqlite3_enable_shared_cache, + sqlite3_errcode, + sqlite3_errmsg, + sqlite3_errmsg16, + sqlite3_exec, + sqlite3_expired, + sqlite3_finalize, + sqlite3_free, + sqlite3_free_table, + sqlite3_get_autocommit, + sqlite3_get_auxdata, + sqlite3_get_table, + 0, /* Was sqlite3_global_recover(), but that function is deprecated */ + sqlite3_interrupt, + sqlite3_last_insert_rowid, + sqlite3_libversion, + sqlite3_libversion_number, + sqlite3_malloc, + sqlite3_mprintf, + sqlite3_open, + sqlite3_open16, + sqlite3_prepare, + sqlite3_prepare16, + sqlite3_profile, + sqlite3_progress_handler, + sqlite3_realloc, + sqlite3_reset, + sqlite3_result_blob, + sqlite3_result_double, + sqlite3_result_error, + sqlite3_result_error16, + sqlite3_result_int, + sqlite3_result_int64, + sqlite3_result_null, + sqlite3_result_text, + sqlite3_result_text16, + sqlite3_result_text16be, + sqlite3_result_text16le, + sqlite3_result_value, + sqlite3_rollback_hook, + sqlite3_set_authorizer, + sqlite3_set_auxdata, + sqlite3_snprintf, + sqlite3_step, + sqlite3_table_column_metadata, + sqlite3_thread_cleanup, + sqlite3_total_changes, + sqlite3_trace, + sqlite3_transfer_bindings, + sqlite3_update_hook, + sqlite3_user_data, + sqlite3_value_blob, + sqlite3_value_bytes, + sqlite3_value_bytes16, + sqlite3_value_double, + sqlite3_value_int, + sqlite3_value_int64, + sqlite3_value_numeric_type, + sqlite3_value_text, + sqlite3_value_text16, + sqlite3_value_text16be, + sqlite3_value_text16le, + sqlite3_value_type, + sqlite3_vmprintf, + /* + ** The original API set ends here. All extensions can call any + ** of the APIs above provided that the pointer is not NULL. But + ** before calling APIs that follow, extension should check the + ** sqlite3_libversion_number() to make sure they are dealing with + ** a library that is new enough to support that API. + ************************************************************************* + */ + sqlite3_overload_function, + + /* + ** Added after 3.3.13 + */ + sqlite3_prepare_v2, + sqlite3_prepare16_v2, + sqlite3_clear_bindings, + + /* + ** Added for 3.4.1 + */ + sqlite3_create_module_v2, + + /* + ** Added for 3.5.0 + */ + sqlite3_bind_zeroblob, + sqlite3_blob_bytes, + sqlite3_blob_close, + sqlite3_blob_open, + sqlite3_blob_read, + sqlite3_blob_write, + sqlite3_create_collation_v2, + sqlite3_file_control, + sqlite3_memory_highwater, + sqlite3_memory_used, +#ifdef SQLITE_MUTEX_NOOP + 0, + 0, + 0, + 0, + 0, +#else + sqlite3_mutex_alloc, + sqlite3_mutex_enter, + sqlite3_mutex_free, + sqlite3_mutex_leave, + sqlite3_mutex_try, +#endif + sqlite3_open_v2, + sqlite3_release_memory, + sqlite3_result_error_nomem, + sqlite3_result_error_toobig, + sqlite3_sleep, + sqlite3_soft_heap_limit, + sqlite3_vfs_find, + sqlite3_vfs_register, + sqlite3_vfs_unregister, +}; + +/* +** Attempt to load an SQLite extension library contained in the file +** zFile. The entry point is zProc. zProc may be 0 in which case a +** default entry point name (sqlite3_extension_init) is used. Use +** of the default name is recommended. +** +** Return SQLITE_OK on success and SQLITE_ERROR if something goes wrong. +** +** If an error occurs and pzErrMsg is not 0, then fill *pzErrMsg with +** error message text. The calling function should free this memory +** by calling sqlite3_free(). +*/ +static int sqlite3LoadExtension( + sqlite3 *db, /* Load the extension into this database connection */ + const char *zFile, /* Name of the shared library containing extension */ + const char *zProc, /* Entry point. Use "sqlite3_extension_init" if 0 */ + char **pzErrMsg /* Put error message here if not 0 */ +){ + sqlite3_vfs *pVfs = db->pVfs; + void *handle; + int (*xInit)(sqlite3*,char**,const sqlite3_api_routines*); + char *zErrmsg = 0; + void **aHandle; + + /* Ticket #1863. To avoid a creating security problems for older + ** applications that relink against newer versions of SQLite, the + ** ability to run load_extension is turned off by default. One + ** must call sqlite3_enable_load_extension() to turn on extension + ** loading. Otherwise you get the following error. + */ + if( (db->flags & SQLITE_LoadExtension)==0 ){ + if( pzErrMsg ){ + *pzErrMsg = sqlite3_mprintf("not authorized"); + } + return SQLITE_ERROR; + } + + if( zProc==0 ){ + zProc = "sqlite3_extension_init"; + } + + handle = sqlite3OsDlOpen(pVfs, zFile); + if( handle==0 ){ + if( pzErrMsg ){ + char zErr[256]; + zErr[sizeof(zErr)-1] = '\0'; + sqlite3_snprintf(sizeof(zErr)-1, zErr, + "unable to open shared library [%s]", zFile); + sqlite3OsDlError(pVfs, sizeof(zErr)-1, zErr); + *pzErrMsg = sqlite3DbStrDup(db, zErr); + } + return SQLITE_ERROR; + } + xInit = (int(*)(sqlite3*,char**,const sqlite3_api_routines*)) + sqlite3OsDlSym(pVfs, handle, zProc); + if( xInit==0 ){ + if( pzErrMsg ){ + char zErr[256]; + zErr[sizeof(zErr)-1] = '\0'; + sqlite3_snprintf(sizeof(zErr)-1, zErr, + "no entry point [%s] in shared library [%s]", zProc,zFile); + sqlite3OsDlError(pVfs, sizeof(zErr)-1, zErr); + *pzErrMsg = sqlite3DbStrDup(db, zErr); + sqlite3OsDlClose(pVfs, handle); + } + return SQLITE_ERROR; + }else if( xInit(db, &zErrmsg, &sqlite3_apis) ){ + if( pzErrMsg ){ + *pzErrMsg = sqlite3_mprintf("error during initialization: %s", zErrmsg); + } + sqlite3_free(zErrmsg); + sqlite3OsDlClose(pVfs, handle); + return SQLITE_ERROR; + } + + /* Append the new shared library handle to the db->aExtension array. */ + db->nExtension++; + aHandle = (void**)sqlite3DbMallocZero(db, sizeof(handle)*db->nExtension); + if( aHandle==0 ){ + return SQLITE_NOMEM; + } + if( db->nExtension>0 ){ + memcpy(aHandle, db->aExtension, sizeof(handle)*(db->nExtension-1)); + } + sqlite3_free(db->aExtension); + db->aExtension = aHandle; + + db->aExtension[db->nExtension-1] = handle; + return SQLITE_OK; +} +EXPORT_C int sqlite3_load_extension( + sqlite3 *db, /* Load the extension into this database connection */ + const char *zFile, /* Name of the shared library containing extension */ + const char *zProc, /* Entry point. Use "sqlite3_extension_init" if 0 */ + char **pzErrMsg /* Put error message here if not 0 */ +){ + int rc; + sqlite3_mutex_enter(db->mutex); + rc = sqlite3LoadExtension(db, zFile, zProc, pzErrMsg); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/* +** Call this routine when the database connection is closing in order +** to clean up loaded extensions +*/ +void sqlite3CloseExtensions(sqlite3 *db){ + int i; + assert( sqlite3_mutex_held(db->mutex) ); + for(i=0; inExtension; i++){ + sqlite3OsDlClose(db->pVfs, db->aExtension[i]); + } + sqlite3_free(db->aExtension); +} + +/* +** Enable or disable extension loading. Extension loading is disabled by +** default so as not to open security holes in older applications. +*/ +EXPORT_C int sqlite3_enable_load_extension(sqlite3 *db, int onoff){ + sqlite3_mutex_enter(db->mutex); + if( onoff ){ + db->flags |= SQLITE_LoadExtension; + }else{ + db->flags &= ~SQLITE_LoadExtension; + } + sqlite3_mutex_leave(db->mutex); + return SQLITE_OK; +} + +/* +** The following object holds the list of automatically loaded +** extensions. +** +** This list is shared across threads. The SQLITE_MUTEX_STATIC_MASTER +** mutex must be held while accessing this list. +*/ +static struct { + int nExt; /* Number of entries in aExt[] */ + void **aExt; /* Pointers to the extension init functions */ +} autoext = { 0, 0 }; + + +/* +** Register a statically linked extension that is automatically +** loaded by every new database connection. +*/ +EXPORT_C int sqlite3_auto_extension(void *xInit){ + int i; + int rc = SQLITE_OK; + sqlite3_mutex *mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER); + sqlite3_mutex_enter(mutex); + for(i=0; i=autoext.nExt ){ + xInit = 0; + go = 0; + }else{ + xInit = (int(*)(sqlite3*,char**,const sqlite3_api_routines*)) + autoext.aExt[i]; + } + sqlite3_mutex_leave(mutex); + if( xInit && xInit(db, &zErrmsg, &sqlite3_apis) ){ + sqlite3Error(db, SQLITE_ERROR, + "automatic extension loading failed: %s", zErrmsg); + go = 0; + rc = SQLITE_ERROR; + sqlite3_free(zErrmsg); + } + } + return rc; +} + +#endif /* SQLITE_OMIT_LOAD_EXTENSION */ diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/main.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/main.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,1494 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** Main file for the SQLite library. The routines in this file +** implement the programmer interface to the library. Routines in +** other files are for internal use by SQLite and should not be +** accessed by users of the library. +** +** $Id: main.cpp 1282 2008-11-13 09:31:33Z LarsPson $ +*/ +#include "sqliteInt.h" +#include +#include +#include + +/* +** The version of the library +*/ +EXPORT_C const char *sqlite3_libversion(void){ return sqlite3_version; } +EXPORT_C int sqlite3_libversion_number(void){ return SQLITE_VERSION_NUMBER; } +EXPORT_C int sqlite3_threadsafe(void){ return SQLITE_THREADSAFE; } + +/* +** If the following function pointer is not NULL and if +** SQLITE_ENABLE_IOTRACE is enabled, then messages describing +** I/O active are written using this function. These messages +** are intended for debugging activity only. +*/ +void (*sqlite3_io_trace)(const char*, ...) = 0; + +/* +** If the following global variable points to a string which is the +** name of a directory, then that directory will be used to store +** temporary files. +** +** See also the "PRAGMA temp_store_directory" SQL command. +*/ +char *sqlite3_temp_directory = 0; + + +/* +** This is the default collating function named "BINARY" which is always +** available. +*/ +static int binCollFunc( + void *NotUsed, + int nKey1, const void *pKey1, + int nKey2, const void *pKey2 +){ + int rc, n; + n = nKey1lastRowid; +} + +/* +** Return the number of changes in the most recent call to sqlite3_exec(). +*/ +EXPORT_C int sqlite3_changes(sqlite3 *db){ + return db->nChange; +} + +/* +** Return the number of changes since the database handle was opened. +*/ +EXPORT_C int sqlite3_total_changes(sqlite3 *db){ + return db->nTotalChange; +} + +/* +** Close an existing SQLite database +*/ +EXPORT_C int sqlite3_close(sqlite3 *db){ + HashElem *i; + int j; + + if( !db ){ + return SQLITE_OK; + } + if( sqlite3SafetyCheck(db) ){ + return SQLITE_MISUSE; + } + sqlite3_mutex_enter(db->mutex); + +#ifdef SQLITE_SSE + { + extern void sqlite3SseCleanup(sqlite3*); + sqlite3SseCleanup(db); + } +#endif + + sqlite3ResetInternalSchema(db, 0); + + /* If a transaction is open, the ResetInternalSchema() call above + ** will not have called the xDisconnect() method on any virtual + ** tables in the db->aVTrans[] array. The following sqlite3VtabRollback() + ** call will do so. We need to do this before the check for active + ** SQL statements below, as the v-table implementation may be storing + ** some prepared statements internally. + */ + sqlite3VtabRollback(db); + + /* If there are any outstanding VMs, return SQLITE_BUSY. */ + if( db->pVdbe ){ + sqlite3Error(db, SQLITE_BUSY, + "Unable to close due to unfinalised statements"); + sqlite3_mutex_leave(db->mutex); + return SQLITE_BUSY; + } + assert( !sqlite3SafetyCheck(db) ); + + /* FIX ME: db->magic may be set to SQLITE_MAGIC_CLOSED if the database + ** cannot be opened for some reason. So this routine needs to run in + ** that case. But maybe there should be an extra magic value for the + ** "failed to open" state. + ** + ** TODO: Coverage tests do not test the case where this condition is + ** true. It's hard to see how to cause it without messing with threads. + */ + if( db->magic!=SQLITE_MAGIC_CLOSED && sqlite3SafetyOn(db) ){ + /* printf("DID NOT CLOSE\n"); fflush(stdout); */ + sqlite3_mutex_leave(db->mutex); + return SQLITE_ERROR; + } + + for(j=0; jnDb; j++){ + struct Db *pDb = &db->aDb[j]; + if( pDb->pBt ){ + sqlite3BtreeClose(pDb->pBt); + pDb->pBt = 0; + if( j!=1 ){ + pDb->pSchema = 0; + } + } + } + sqlite3ResetInternalSchema(db, 0); + assert( db->nDb<=2 ); + assert( db->aDb==db->aDbStatic ); + for(i=sqliteHashFirst(&db->aFunc); i; i=sqliteHashNext(i)){ + FuncDef *pFunc, *pNext; + for(pFunc = (FuncDef*)sqliteHashData(i); pFunc; pFunc=pNext){ + pNext = pFunc->pNext; + sqlite3_free(pFunc); + } + } + + for(i=sqliteHashFirst(&db->aCollSeq); i; i=sqliteHashNext(i)){ + CollSeq *pColl = (CollSeq *)sqliteHashData(i); + /* Invoke any destructors registered for collation sequence user data. */ + for(j=0; j<3; j++){ + if( pColl[j].xDel ){ + pColl[j].xDel(pColl[j].pUser); + } + } + sqlite3_free(pColl); + } + sqlite3HashClear(&db->aCollSeq); +#ifndef SQLITE_OMIT_VIRTUALTABLE + for(i=sqliteHashFirst(&db->aModule); i; i=sqliteHashNext(i)){ + Module *pMod = (Module *)sqliteHashData(i); + if( pMod->xDestroy ){ + pMod->xDestroy(pMod->pAux); + } + sqlite3_free(pMod); + } + sqlite3HashClear(&db->aModule); +#endif + + sqlite3HashClear(&db->aFunc); + sqlite3Error(db, SQLITE_OK, 0); /* Deallocates any cached error strings. */ + if( db->pErr ){ + sqlite3ValueFree(db->pErr); + } + sqlite3CloseExtensions(db); + + db->magic = SQLITE_MAGIC_ERROR; + + /* The temp-database schema is allocated differently from the other schema + ** objects (using sqliteMalloc() directly, instead of sqlite3BtreeSchema()). + ** So it needs to be freed here. Todo: Why not roll the temp schema into + ** the same sqliteMalloc() as the one that allocates the database + ** structure? + */ + sqlite3_free(db->aDb[1].pSchema); + sqlite3_mutex_leave(db->mutex); + sqlite3_mutex_free(db->mutex); + sqlite3_free(db); + return SQLITE_OK; +} + +/* +** Rollback all database files. +*/ +void sqlite3RollbackAll(sqlite3 *db){ + int i; + int inTrans = 0; + assert( sqlite3_mutex_held(db->mutex) ); + sqlite3MallocEnterBenignBlock(1); /* Enter benign region */ + for(i=0; inDb; i++){ + if( db->aDb[i].pBt ){ + if( sqlite3BtreeIsInTrans(db->aDb[i].pBt) ){ + inTrans = 1; + } + sqlite3BtreeRollback(db->aDb[i].pBt); + db->aDb[i].inTrans = 0; + } + } + sqlite3VtabRollback(db); + sqlite3MallocLeaveBenignBlock(); /* Leave benign region */ + + if( db->flags&SQLITE_InternChanges ){ + sqlite3ExpirePreparedStatements(db); + sqlite3ResetInternalSchema(db, 0); + } + + /* If one has been configured, invoke the rollback-hook callback */ + if( db->xRollbackCallback && (inTrans || !db->autoCommit) ){ + db->xRollbackCallback(db->pRollbackArg); + } +} + +/* +** Return a static string that describes the kind of error specified in the +** argument. +*/ +const char *sqlite3ErrStr(int rc){ + const char *z; + switch( rc & 0xff ){ + case SQLITE_ROW: + case SQLITE_DONE: + case SQLITE_OK: z = "not an error"; break; + case SQLITE_ERROR: z = "SQL logic error or missing database"; break; + case SQLITE_PERM: z = "access permission denied"; break; + case SQLITE_ABORT: z = "callback requested query abort"; break; + case SQLITE_BUSY: z = "database is locked"; break; + case SQLITE_LOCKED: z = "database table is locked"; break; + case SQLITE_NOMEM: z = "out of memory"; break; + case SQLITE_READONLY: z = "attempt to write a readonly database"; break; + case SQLITE_INTERRUPT: z = "interrupted"; break; + case SQLITE_IOERR: z = "disk I/O error"; break; + case SQLITE_CORRUPT: z = "database disk image is malformed"; break; + case SQLITE_FULL: z = "database or disk is full"; break; + case SQLITE_CANTOPEN: z = "unable to open database file"; break; + case SQLITE_EMPTY: z = "table contains no data"; break; + case SQLITE_SCHEMA: z = "database schema has changed"; break; + case SQLITE_TOOBIG: z = "String or BLOB exceeded size limit"; break; + case SQLITE_CONSTRAINT: z = "constraint failed"; break; + case SQLITE_MISMATCH: z = "datatype mismatch"; break; + case SQLITE_MISUSE: z = "library routine called out of sequence";break; + case SQLITE_NOLFS: z = "kernel lacks large file support"; break; + case SQLITE_AUTH: z = "authorization denied"; break; + case SQLITE_FORMAT: z = "auxiliary database format error"; break; + case SQLITE_RANGE: z = "bind or column index out of range"; break; + case SQLITE_NOTADB: z = "file is encrypted or is not a database";break; + default: z = "unknown error"; break; + } + return z; +} + +/* +** This routine implements a busy callback that sleeps and tries +** again until a timeout value is reached. The timeout value is +** an integer number of milliseconds passed in as the first +** argument. +*/ +static int sqliteDefaultBusyCallback( + void *ptr, /* Database connection */ + int count /* Number of times table has been busy */ +){ +#if OS_WIN || (defined(HAVE_USLEEP) && HAVE_USLEEP) + static const u8 delays[] = + { 1, 2, 5, 10, 15, 20, 25, 25, 25, 50, 50, 100 }; + static const u8 totals[] = + { 0, 1, 3, 8, 18, 33, 53, 78, 103, 128, 178, 228 }; +# define NDELAY (sizeof(delays)/sizeof(delays[0])) + sqlite3 *db = (sqlite3 *)ptr; + int timeout = db->busyTimeout; + int delay, prior; + + assert( count>=0 ); + if( count < NDELAY ){ + delay = delays[count]; + prior = totals[count]; + }else{ + delay = delays[NDELAY-1]; + prior = totals[NDELAY-1] + delay*(count-(NDELAY-1)); + } + if( prior + delay > timeout ){ + delay = timeout - prior; + if( delay<=0 ) return 0; + } + sqlite3OsSleep(db->pVfs, delay*1000); + return 1; +#else + sqlite3 *db = (sqlite3 *)ptr; + int timeout = ((sqlite3 *)ptr)->busyTimeout; + if( (count+1)*1000 > timeout ){ + return 0; + } + sqlite3OsSleep(db->pVfs, 1000000); + return 1; +#endif +} + +/* +** Invoke the given busy handler. +** +** This routine is called when an operation failed with a lock. +** If this routine returns non-zero, the lock is retried. If it +** returns 0, the operation aborts with an SQLITE_BUSY error. +*/ +int sqlite3InvokeBusyHandler(BusyHandler *p){ + int rc; + if( p==0 || p->xFunc==0 || p->nBusy<0 ) return 0; + rc = p->xFunc(p->pArg, p->nBusy); + if( rc==0 ){ + p->nBusy = -1; + }else{ + p->nBusy++; + } + return rc; +} + +/* +** This routine sets the busy callback for an Sqlite database to the +** given callback function with the given argument. +*/ +EXPORT_C int sqlite3_busy_handler( + sqlite3 *db, + int (*xBusy)(void*,int), + void *pArg +){ + if( sqlite3SafetyCheck(db) ){ + return SQLITE_MISUSE; + } + sqlite3_mutex_enter(db->mutex); + db->busyHandler.xFunc = xBusy; + db->busyHandler.pArg = pArg; + db->busyHandler.nBusy = 0; + sqlite3_mutex_leave(db->mutex); + return SQLITE_OK; +} + +#ifndef SQLITE_OMIT_PROGRESS_CALLBACK +/* +** This routine sets the progress callback for an Sqlite database to the +** given callback function with the given argument. The progress callback will +** be invoked every nOps opcodes. +*/ +EXPORT_C void sqlite3_progress_handler( + sqlite3 *db, + int nOps, + int (*xProgress)(void*), + void *pArg +){ + if( !sqlite3SafetyCheck(db) ){ + sqlite3_mutex_enter(db->mutex); + if( nOps>0 ){ + db->xProgress = xProgress; + db->nProgressOps = nOps; + db->pProgressArg = pArg; + }else{ + db->xProgress = 0; + db->nProgressOps = 0; + db->pProgressArg = 0; + } + sqlite3_mutex_leave(db->mutex); + } +} +#endif + + +/* +** This routine installs a default busy handler that waits for the +** specified number of milliseconds before returning 0. +*/ +EXPORT_C int sqlite3_busy_timeout(sqlite3 *db, int ms){ + if( sqlite3SafetyCheck(db) ){ + return SQLITE_MISUSE; + } + if( ms>0 ){ + db->busyTimeout = ms; + sqlite3_busy_handler(db, sqliteDefaultBusyCallback, (void*)db); + }else{ + sqlite3_busy_handler(db, NULL, NULL); + } + return SQLITE_OK; +} + +/* +** Cause any pending operation to stop at its earliest opportunity. +*/ +EXPORT_C void sqlite3_interrupt(sqlite3 *db){ + if( db && (db->magic==SQLITE_MAGIC_OPEN || db->magic==SQLITE_MAGIC_BUSY) ){ + db->u1.isInterrupted = 1; + } +} + + +/* +** This function is exactly the same as sqlite3_create_function(), except +** that it is designed to be called by internal code. The difference is +** that if a malloc() fails in sqlite3_create_function(), an error code +** is returned and the mallocFailed flag cleared. +*/ +int sqlite3CreateFunc( + sqlite3 *db, + const char *zFunctionName, + int nArg, + int enc, + void *pUserData, + void (*xFunc)(sqlite3_context*,int,sqlite3_value **), + void (*xStep)(sqlite3_context*,int,sqlite3_value **), + void (*xFinal)(sqlite3_context*) +){ + FuncDef *p; + int nName; + + assert( sqlite3_mutex_held(db->mutex) ); + if( sqlite3SafetyCheck(db) ){ + return SQLITE_MISUSE; + } + if( zFunctionName==0 || + (xFunc && (xFinal || xStep)) || + (!xFunc && (xFinal && !xStep)) || + (!xFunc && (!xFinal && xStep)) || + (nArg<-1 || nArg>127) || + (255<(nName = strlen(zFunctionName))) ){ + sqlite3Error(db, SQLITE_ERROR, "bad parameters"); + return SQLITE_ERROR; + } + +#ifndef SQLITE_OMIT_UTF16 + /* If SQLITE_UTF16 is specified as the encoding type, transform this + ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the + ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally. + ** + ** If SQLITE_ANY is specified, add three versions of the function + ** to the hash table. + */ + if( enc==SQLITE_UTF16 ){ + enc = SQLITE_UTF16NATIVE; + }else if( enc==SQLITE_ANY ){ + int rc; + rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF8, + pUserData, xFunc, xStep, xFinal); + if( rc==SQLITE_OK ){ + rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF16LE, + pUserData, xFunc, xStep, xFinal); + } + if( rc!=SQLITE_OK ){ + return rc; + } + enc = SQLITE_UTF16BE; + } +#else + enc = SQLITE_UTF8; +#endif + + /* Check if an existing function is being overridden or deleted. If so, + ** and there are active VMs, then return SQLITE_BUSY. If a function + ** is being overridden/deleted but there are no active VMs, allow the + ** operation to continue but invalidate all precompiled statements. + */ + p = sqlite3FindFunction(db, zFunctionName, nName, nArg, enc, 0); + if( p && p->iPrefEnc==enc && p->nArg==nArg ){ + if( db->activeVdbeCnt ){ + sqlite3Error(db, SQLITE_BUSY, + "Unable to delete/modify user-function due to active statements"); + assert( !db->mallocFailed ); + return SQLITE_BUSY; + }else{ + sqlite3ExpirePreparedStatements(db); + } + } + + p = sqlite3FindFunction(db, zFunctionName, nName, nArg, enc, 1); + assert(p || db->mallocFailed); + if( !p ){ + return SQLITE_NOMEM; + } + p->flags = 0; + p->xFunc = xFunc; + p->xStep = xStep; + p->xFinalize = xFinal; + p->pUserData = pUserData; + p->nArg = nArg; + return SQLITE_OK; +} + +/* +** Create new user functions. +*/ +EXPORT_C int sqlite3_create_function( + sqlite3 *db, + const char *zFunctionName, + int nArg, + int enc, + void *p, + void (*xFunc)(sqlite3_context*,int,sqlite3_value **), + void (*xStep)(sqlite3_context*,int,sqlite3_value **), + void (*xFinal)(sqlite3_context*) +){ + int rc; + sqlite3_mutex_enter(db->mutex); + assert( !db->mallocFailed ); + rc = sqlite3CreateFunc(db, zFunctionName, nArg, enc, p, xFunc, xStep, xFinal); + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +#ifndef SQLITE_OMIT_UTF16 +EXPORT_C int sqlite3_create_function16( + sqlite3 *db, + const void *zFunctionName, + int nArg, + int eTextRep, + void *p, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*) +){ + int rc; + char *zFunc8; + sqlite3_mutex_enter(db->mutex); + assert( !db->mallocFailed ); + zFunc8 = sqlite3Utf16to8(db, zFunctionName, -1); + rc = sqlite3CreateFunc(db, zFunc8, nArg, eTextRep, p, xFunc, xStep, xFinal); + sqlite3_free(zFunc8); + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} +#endif + + +/* +** Declare that a function has been overloaded by a virtual table. +** +** If the function already exists as a regular global function, then +** this routine is a no-op. If the function does not exist, then create +** a new one that always throws a run-time error. +** +** When virtual tables intend to provide an overloaded function, they +** should call this routine to make sure the global function exists. +** A global function must exist in order for name resolution to work +** properly. +*/ +EXPORT_C int sqlite3_overload_function( + sqlite3 *db, + const char *zName, + int nArg +){ + int nName = strlen(zName); + int rc; + sqlite3_mutex_enter(db->mutex); + if( sqlite3FindFunction(db, zName, nName, nArg, SQLITE_UTF8, 0)==0 ){ + sqlite3CreateFunc(db, zName, nArg, SQLITE_UTF8, + 0, sqlite3InvalidFunction, 0, 0); + } + rc = sqlite3ApiExit(db, SQLITE_OK); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +#ifndef SQLITE_OMIT_TRACE +/* +** Register a trace function. The pArg from the previously registered trace +** is returned. +** +** A NULL trace function means that no tracing is executes. A non-NULL +** trace is a pointer to a function that is invoked at the start of each +** SQL statement. +*/ +EXPORT_C void *sqlite3_trace(sqlite3 *db, void (*xTrace)(void*,const char*), void *pArg){ + void *pOld; + sqlite3_mutex_enter(db->mutex); + pOld = db->pTraceArg; + db->xTrace = xTrace; + db->pTraceArg = pArg; + sqlite3_mutex_leave(db->mutex); + return pOld; +} +/* +** Register a profile function. The pArg from the previously registered +** profile function is returned. +** +** A NULL profile function means that no profiling is executes. A non-NULL +** profile is a pointer to a function that is invoked at the conclusion of +** each SQL statement that is run. +*/ +EXPORT_C void *sqlite3_profile( + sqlite3 *db, + void (*xProfile)(void*,const char*,sqlite_uint64), + void *pArg +){ + void *pOld; + sqlite3_mutex_enter(db->mutex); + pOld = db->pProfileArg; + db->xProfile = xProfile; + db->pProfileArg = pArg; + sqlite3_mutex_leave(db->mutex); + return pOld; +} +#endif /* SQLITE_OMIT_TRACE */ + +/*** EXPERIMENTAL *** +** +** Register a function to be invoked when a transaction comments. +** If the invoked function returns non-zero, then the commit becomes a +** rollback. +*/ +EXPORT_C void *sqlite3_commit_hook( + sqlite3 *db, /* Attach the hook to this database */ + int (*xCallback)(void*), /* Function to invoke on each commit */ + void *pArg /* Argument to the function */ +){ + void *pOld; + sqlite3_mutex_enter(db->mutex); + pOld = db->pCommitArg; + db->xCommitCallback = xCallback; + db->pCommitArg = pArg; + sqlite3_mutex_leave(db->mutex); + return pOld; +} + +/* +** Register a callback to be invoked each time a row is updated, +** inserted or deleted using this database connection. +*/ +EXPORT_C void *sqlite3_update_hook( + sqlite3 *db, /* Attach the hook to this database */ + void (*xCallback)(void*,int,char const *,char const *,sqlite_int64), + void *pArg /* Argument to the function */ +){ + void *pRet; + sqlite3_mutex_enter(db->mutex); + pRet = db->pUpdateArg; + db->xUpdateCallback = xCallback; + db->pUpdateArg = pArg; + sqlite3_mutex_leave(db->mutex); + return pRet; +} + +/* +** Register a callback to be invoked each time a transaction is rolled +** back by this database connection. +*/ +EXPORT_C void *sqlite3_rollback_hook( + sqlite3 *db, /* Attach the hook to this database */ + void (*xCallback)(void*), /* Callback function */ + void *pArg /* Argument to the function */ +){ + void *pRet; + sqlite3_mutex_enter(db->mutex); + pRet = db->pRollbackArg; + db->xRollbackCallback = xCallback; + db->pRollbackArg = pArg; + sqlite3_mutex_leave(db->mutex); + return pRet; +} + +/* +** This routine is called to create a connection to a database BTree +** driver. If zFilename is the name of a file, then that file is +** opened and used. If zFilename is the magic name ":memory:" then +** the database is stored in memory (and is thus forgotten as soon as +** the connection is closed.) If zFilename is NULL then the database +** is a "virtual" database for transient use only and is deleted as +** soon as the connection is closed. +** +** A virtual database can be either a disk file (that is automatically +** deleted when the file is closed) or it an be held entirely in memory, +** depending on the values of the TEMP_STORE compile-time macro and the +** db->temp_store variable, according to the following chart: +** +** TEMP_STORE db->temp_store Location of temporary database +** ---------- -------------- ------------------------------ +** 0 any file +** 1 1 file +** 1 2 memory +** 1 0 file +** 2 1 file +** 2 2 memory +** 2 0 memory +** 3 any memory +*/ +int sqlite3BtreeFactory( + const sqlite3 *db, /* Main database when opening aux otherwise 0 */ + const char *zFilename, /* Name of the file containing the BTree database */ + int omitJournal, /* if TRUE then do not journal this file */ + int nCache, /* How many pages in the page cache */ + int vfsFlags, /* Flags passed through to vfsOpen */ + Btree **ppBtree /* Pointer to new Btree object written here */ +){ + int btFlags = 0; + int rc; + + + assert( sqlite3_mutex_held(db->mutex) ); + assert( ppBtree != 0); + + + if( omitJournal ){ + btFlags |= BTREE_OMIT_JOURNAL; + } + if( db->flags & SQLITE_NoReadlock ){ + btFlags |= BTREE_NO_READLOCK; + } + if( zFilename==0 ){ +#if TEMP_STORE==0 + /* Do nothing */ +#endif +#ifndef SQLITE_OMIT_MEMORYDB +#if TEMP_STORE==1 + if( db->temp_store==2 ) zFilename = ":memory:"; +#endif +#if TEMP_STORE==2 + if( db->temp_store!=1 ) zFilename = ":memory:"; +#endif +#if TEMP_STORE==3 + zFilename = ":memory:"; +#endif +#endif /* SQLITE_OMIT_MEMORYDB */ + } + + if( (vfsFlags & SQLITE_OPEN_MAIN_DB)!=0 && (zFilename==0 || *zFilename==0) ){ + vfsFlags = (vfsFlags & ~SQLITE_OPEN_MAIN_DB) | SQLITE_OPEN_TEMP_DB; + } + rc = sqlite3BtreeOpen(zFilename, (sqlite3 *)db, ppBtree, btFlags, vfsFlags); + + if( rc==SQLITE_OK ){ + sqlite3BtreeSetCacheSize(*ppBtree, nCache); + } + return rc; +} + +/* +** Return UTF-8 encoded English language explanation of the most recent +** error. +*/ +EXPORT_C const char *sqlite3_errmsg(sqlite3 *db){ + const char *z; + if( !db ){ + return sqlite3ErrStr(SQLITE_NOMEM); + } + if( sqlite3SafetyCheck(db) || db->errCode==SQLITE_MISUSE ){ + return sqlite3ErrStr(SQLITE_MISUSE); + } + sqlite3_mutex_enter(db->mutex); + assert( !db->mallocFailed ); + z = (char*)sqlite3_value_text(db->pErr); + if( z==0 ){ + z = sqlite3ErrStr(db->errCode); + } + sqlite3_mutex_leave(db->mutex); + return z; +} + +#ifndef SQLITE_OMIT_UTF16 +/* +** Return UTF-16 encoded English language explanation of the most recent +** error. +*/ +EXPORT_C const void *sqlite3_errmsg16(sqlite3 *db){ + /* Because all the characters in the string are in the unicode + ** range 0x00-0xFF, if we pad the big-endian string with a + ** zero byte, we can obtain the little-endian string with + ** &big_endian[1]. + */ + static const char outOfMemBe[] = { + 0, 'o', 0, 'u', 0, 't', 0, ' ', + 0, 'o', 0, 'f', 0, ' ', + 0, 'm', 0, 'e', 0, 'm', 0, 'o', 0, 'r', 0, 'y', 0, 0, 0 + }; + static const char misuseBe [] = { + 0, 'l', 0, 'i', 0, 'b', 0, 'r', 0, 'a', 0, 'r', 0, 'y', 0, ' ', + 0, 'r', 0, 'o', 0, 'u', 0, 't', 0, 'i', 0, 'n', 0, 'e', 0, ' ', + 0, 'c', 0, 'a', 0, 'l', 0, 'l', 0, 'e', 0, 'd', 0, ' ', + 0, 'o', 0, 'u', 0, 't', 0, ' ', + 0, 'o', 0, 'f', 0, ' ', + 0, 's', 0, 'e', 0, 'q', 0, 'u', 0, 'e', 0, 'n', 0, 'c', 0, 'e', 0, 0, 0 + }; + + const void *z; + if( !db ){ + return (void *)(&outOfMemBe[SQLITE_UTF16NATIVE==SQLITE_UTF16LE?1:0]); + } + if( sqlite3SafetyCheck(db) || db->errCode==SQLITE_MISUSE ){ + return (void *)(&misuseBe[SQLITE_UTF16NATIVE==SQLITE_UTF16LE?1:0]); + } + sqlite3_mutex_enter(db->mutex); + assert( !db->mallocFailed ); + z = sqlite3_value_text16(db->pErr); + if( z==0 ){ + sqlite3ValueSetStr(db->pErr, -1, sqlite3ErrStr(db->errCode), + SQLITE_UTF8, SQLITE_STATIC); + z = sqlite3_value_text16(db->pErr); + } + sqlite3ApiExit(0, 0); + sqlite3_mutex_leave(db->mutex); + return z; +} +#endif /* SQLITE_OMIT_UTF16 */ + +/* +** Return the most recent error code generated by an SQLite routine. If NULL is +** passed to this function, we assume a malloc() failed during sqlite3_open(). +*/ +EXPORT_C int sqlite3_errcode(sqlite3 *db){ + if( !db || db->mallocFailed ){ + return SQLITE_NOMEM; + } + if( sqlite3SafetyCheck(db) ){ + return SQLITE_MISUSE; + } + return db->errCode & db->errMask; +} + +/* +** Create a new collating function for database "db". The name is zName +** and the encoding is enc. +*/ +static int createCollation( + sqlite3* db, + const char *zName, + int enc, + void* pCtx, + int(*xCompare)(void*,int,const void*,int,const void*), + void(*xDel)(void*) +){ + CollSeq *pColl; + int enc2; + + if( sqlite3SafetyCheck(db) ){ + return SQLITE_MISUSE; + } + assert( sqlite3_mutex_held(db->mutex) ); + + /* If SQLITE_UTF16 is specified as the encoding type, transform this + ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the + ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally. + */ + enc2 = enc & ~SQLITE_UTF16_ALIGNED; + if( enc2==SQLITE_UTF16 ){ + enc2 = SQLITE_UTF16NATIVE; + } + + if( (enc2&~3)!=0 ){ + sqlite3Error(db, SQLITE_ERROR, "unknown encoding"); + return SQLITE_ERROR; + } + + /* Check if this call is removing or replacing an existing collation + ** sequence. If so, and there are active VMs, return busy. If there + ** are no active VMs, invalidate any pre-compiled statements. + */ + pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, strlen(zName), 0); + if( pColl && pColl->xCmp ){ + if( db->activeVdbeCnt ){ + sqlite3Error(db, SQLITE_BUSY, + "Unable to delete/modify collation sequence due to active statements"); + return SQLITE_BUSY; + } + sqlite3ExpirePreparedStatements(db); + + /* If collation sequence pColl was created directly by a call to + ** sqlite3_create_collation, and not generated by synthCollSeq(), + ** then any copies made by synthCollSeq() need to be invalidated. + ** Also, collation destructor - CollSeq.xDel() - function may need + ** to be called. + */ + if( (pColl->enc & ~SQLITE_UTF16_ALIGNED)==enc2 ){ + CollSeq *aColl = (CollSeq*)sqlite3HashFind(&db->aCollSeq, zName, strlen(zName)); + int j; + for(j=0; j<3; j++){ + CollSeq *p = &aColl[j]; + if( p->enc==pColl->enc ){ + if( p->xDel ){ + p->xDel(p->pUser); + } + p->xCmp = 0; + } + } + } + } + + pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, strlen(zName), 1); + if( pColl ){ + pColl->xCmp = xCompare; + pColl->pUser = pCtx; + pColl->xDel = xDel; + pColl->enc = enc2 | (enc & SQLITE_UTF16_ALIGNED); + } + sqlite3Error(db, SQLITE_OK, 0); + return SQLITE_OK; +} + +FILE * fpLogFile = NULL; + +/* +** This routine does the work of opening a database on behalf of +** sqlite3_open() and sqlite3_open16(). The database filename "zFilename" +** is UTF-8 encoded. +*/ +static int openDatabase( + const char *zFilename, /* Database filename UTF-8 encoded */ + sqlite3 **ppDb, /* OUT: Returned database handle */ + unsigned flags, /* Operational flags */ + const char *zVfs /* Name of the VFS to use */ +){ + sqlite3 *db; + int rc; + CollSeq *pColl; + + + /* Allocate the sqlite data structure */ + db = (sqlite3*)sqlite3MallocZero( sizeof(sqlite3) ); + if( db==0 ) goto opendb_out; + db->mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_RECURSIVE); + if( db->mutex==0 ){ + sqlite3_free(db); + db = 0; + goto opendb_out; + } + sqlite3_mutex_enter(db->mutex); + db->errMask = 0xff; + db->priorNewRowid = 0; + db->nDb = 2; + db->magic = SQLITE_MAGIC_BUSY; + db->aDb = db->aDbStatic; + db->autoCommit = 1; + db->nextAutovac = -1; + db->flags |= SQLITE_ShortColNames +#if SQLITE_DEFAULT_FILE_FORMAT<4 + | SQLITE_LegacyFileFmt +#endif +#ifdef SQLITE_ENABLE_LOAD_EXTENSION + | SQLITE_LoadExtension +#endif + ; + sqlite3HashInit(&db->aFunc, SQLITE_HASH_STRING, 0); + sqlite3HashInit(&db->aCollSeq, SQLITE_HASH_STRING, 0); +#ifndef SQLITE_OMIT_VIRTUALTABLE + sqlite3HashInit(&db->aModule, SQLITE_HASH_STRING, 0); +#endif + + db->pVfs = sqlite3OsDefaultVfs();//sqlite3_vfs_find(zVfs); + if( !db->pVfs ){ + rc = SQLITE_ERROR; + db->magic = SQLITE_MAGIC_CLOSED; + sqlite3Error(db, rc, "no such vfs: %s", (zVfs?zVfs:"(null)")); + goto opendb_out; + } + + /* Add the default collation sequence BINARY. BINARY works for both UTF-8 + ** and UTF-16, so add a version for each to avoid any unnecessary + ** conversions. The only error that can occur here is a malloc() failure. + */ + if( createCollation(db, "BINARY", SQLITE_UTF8, 0, binCollFunc, 0) || + createCollation(db, "BINARY", SQLITE_UTF16BE, 0, binCollFunc, 0) || + createCollation(db, "BINARY", SQLITE_UTF16LE, 0, binCollFunc, 0) || + (db->pDfltColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "BINARY", 6, 0))==0 + ){ + assert( db->mallocFailed ); + db->magic = SQLITE_MAGIC_CLOSED; + goto opendb_out; + } + + /* Also add a UTF-8 case-insensitive collation sequence. */ + createCollation(db, "NOCASE", SQLITE_UTF8, 0, nocaseCollatingFunc, 0); + + /* Set flags on the built-in collating sequences */ + db->pDfltColl->type = SQLITE_COLL_BINARY; + pColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "NOCASE", 6, 0); + if( pColl ){ + pColl->type = SQLITE_COLL_NOCASE; + } + + /* Open the backend database driver */ + db->openFlags = flags; + rc = sqlite3BtreeFactory(db, zFilename, 0, SQLITE_DEFAULT_CACHE_SIZE, + flags | SQLITE_OPEN_MAIN_DB, + &db->aDb[0].pBt); + if( rc!=SQLITE_OK ){ + sqlite3Error(db, rc, 0); + db->magic = SQLITE_MAGIC_CLOSED; + goto opendb_out; + } + db->aDb[0].pSchema = sqlite3SchemaGet(db, db->aDb[0].pBt); + db->aDb[1].pSchema = sqlite3SchemaGet(db, 0); + + + /* The default safety_level for the main database is 'full'; for the temp + ** database it is 'NONE'. This matches the pager layer defaults. + */ + db->aDb[0].zName = "main"; + db->aDb[0].safety_level = 3; +#ifndef SQLITE_OMIT_TEMPDB + db->aDb[1].zName = "temp"; + db->aDb[1].safety_level = 1; +#endif + + db->magic = SQLITE_MAGIC_OPEN; + if( db->mallocFailed ){ + goto opendb_out; + } + + /* Register all built-in functions, but do not attempt to read the + ** database schema yet. This is delayed until the first time the database + ** is accessed. + */ + sqlite3Error(db, SQLITE_OK, 0); + sqlite3RegisterBuiltinFunctions(db); + + /* Load automatic extensions - extensions that have been registered + ** using the sqlite3_automatic_extension() API. + */ + (void)sqlite3AutoLoadExtensions(db); + if( sqlite3_errcode(db)!=SQLITE_OK ){ + goto opendb_out; + } + +#ifdef SQLITE_ENABLE_FTS1 + if( !db->mallocFailed ){ + extern int sqlite3Fts1Init(sqlite3*); + rc = sqlite3Fts1Init(db); + } +#endif + +#ifdef SQLITE_ENABLE_FTS2 + if( !db->mallocFailed && rc==SQLITE_OK ){ + extern int sqlite3Fts2Init(sqlite3*); + rc = sqlite3Fts2Init(db); + } +#endif + +#ifdef SQLITE_ENABLE_FTS3 + if( !db->mallocFailed && rc==SQLITE_OK ){ + extern int sqlite3Fts3Init(sqlite3*); + rc = sqlite3Fts3Init(db); + } +#endif + +#ifdef SQLITE_ENABLE_ICU + if( !db->mallocFailed && rc==SQLITE_OK ){ + extern int sqlite3IcuInit(sqlite3*); + rc = sqlite3IcuInit(db); + } +#endif + sqlite3Error(db, rc, 0); + + /* -DSQLITE_DEFAULT_LOCKING_MODE=1 makes EXCLUSIVE the default locking + ** mode. -DSQLITE_DEFAULT_LOCKING_MODE=0 make NORMAL the default locking + ** mode. Doing nothing at all also makes NORMAL the default. + */ +#ifdef SQLITE_DEFAULT_LOCKING_MODE + db->dfltLockMode = SQLITE_DEFAULT_LOCKING_MODE; + sqlite3PagerLockingMode(sqlite3BtreePager(db->aDb[0].pBt), + SQLITE_DEFAULT_LOCKING_MODE); +#endif + +opendb_out: + if( db && db->mutex ){ + sqlite3_mutex_leave(db->mutex); + } + if( SQLITE_NOMEM==(rc = sqlite3_errcode(db)) ){ + sqlite3_close(db); + db = 0; + } + *ppDb = db; + return sqlite3ApiExit(0, rc); +} + +/* +** Open a new database handle. +*/ +EXPORT_C int sqlite3_open( + const char *zFilename, + sqlite3 **ppDb +){ + return openDatabase(zFilename, ppDb, + SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0); +} + +EXPORT_C int sqlite3_open_v2( + const char *filename, /* Database filename (UTF-8) */ + sqlite3 **ppDb, /* OUT: SQLite db handle */ + int flags, /* Flags */ + const char *zVfs /* Name of VFS module to use */ +){ + + return openDatabase(filename, ppDb, flags, zVfs); +} + +#ifndef SQLITE_OMIT_UTF16 +/* +** Open a new database handle. +*/ +EXPORT_C int sqlite3_open16( + const void *zFilename, + sqlite3 **ppDb +){ + char const *zFilename8; /* zFilename encoded in UTF-8 instead of UTF-16 */ + sqlite3_value *pVal; + int rc = SQLITE_NOMEM; + + assert( zFilename ); + assert( ppDb ); + *ppDb = 0; + pVal = sqlite3ValueNew(0); + sqlite3ValueSetStr(pVal, -1, zFilename, SQLITE_UTF16NATIVE, SQLITE_STATIC); + zFilename8 = (const char*)sqlite3ValueText(pVal, SQLITE_UTF8); + if( zFilename8 ){ + rc = openDatabase(zFilename8, ppDb, + SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0); + if( rc==SQLITE_OK && *ppDb ){ + rc = sqlite3_exec(*ppDb, "PRAGMA encoding = 'UTF-16'", 0, 0, 0); + if( rc!=SQLITE_OK ){ + sqlite3_close(*ppDb); + *ppDb = 0; + } + } + } + sqlite3ValueFree(pVal); + + return sqlite3ApiExit(0, rc); +} +#endif /* SQLITE_OMIT_UTF16 */ + +/* +** Register a new collation sequence with the database handle db. +*/ +EXPORT_C int sqlite3_create_collation( + sqlite3* db, + const char *zName, + int enc, + void* pCtx, + int(*xCompare)(void*,int,const void*,int,const void*) +){ + int rc; + sqlite3_mutex_enter(db->mutex); + assert( !db->mallocFailed ); + rc = createCollation(db, zName, enc, pCtx, xCompare, 0); + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/* +** Register a new collation sequence with the database handle db. +*/ +EXPORT_C int sqlite3_create_collation_v2( + sqlite3* db, + const char *zName, + int enc, + void* pCtx, + int(*xCompare)(void*,int,const void*,int,const void*), + void(*xDel)(void*) +){ + int rc; + sqlite3_mutex_enter(db->mutex); + assert( !db->mallocFailed ); + rc = createCollation(db, zName, enc, pCtx, xCompare, xDel); + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +#ifndef SQLITE_OMIT_UTF16 +/* +** Register a new collation sequence with the database handle db. +*/ +EXPORT_C int sqlite3_create_collation16( + sqlite3* db, + const char *zName, + int enc, + void* pCtx, + int(*xCompare)(void*,int,const void*,int,const void*) +){ + int rc = SQLITE_OK; + char *zName8; + sqlite3_mutex_enter(db->mutex); + assert( !db->mallocFailed ); + zName8 = sqlite3Utf16to8(db, zName, -1); + if( zName8 ){ + rc = createCollation(db, zName8, enc, pCtx, xCompare, 0); + sqlite3_free(zName8); + } + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} +#endif /* SQLITE_OMIT_UTF16 */ + +/* +** Register a collation sequence factory callback with the database handle +** db. Replace any previously installed collation sequence factory. +*/ +EXPORT_C int sqlite3_collation_needed( + sqlite3 *db, + void *pCollNeededArg, + void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*) +){ + if( sqlite3SafetyCheck(db) ){ + return SQLITE_MISUSE; + } + sqlite3_mutex_enter(db->mutex); + db->xCollNeeded = xCollNeeded; + db->xCollNeeded16 = 0; + db->pCollNeededArg = pCollNeededArg; + sqlite3_mutex_leave(db->mutex); + return SQLITE_OK; +} + +#ifndef SQLITE_OMIT_UTF16 +/* +** Register a collation sequence factory callback with the database handle +** db. Replace any previously installed collation sequence factory. +*/ +EXPORT_C int sqlite3_collation_needed16( + sqlite3 *db, + void *pCollNeededArg, + void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*) +){ + if( sqlite3SafetyCheck(db) ){ + return SQLITE_MISUSE; + } + sqlite3_mutex_enter(db->mutex); + db->xCollNeeded = 0; + db->xCollNeeded16 = xCollNeeded16; + db->pCollNeededArg = pCollNeededArg; + sqlite3_mutex_leave(db->mutex); + return SQLITE_OK; +} +#endif /* SQLITE_OMIT_UTF16 */ + +#ifndef SQLITE_OMIT_GLOBALRECOVER +/* +** This function is now an anachronism. It used to be used to recover from a +** malloc() failure, but SQLite now does this automatically. +*/ +EXPORT_C int sqlite3_global_recover(void){ + return SQLITE_OK; +} +#endif + +/* +** Test to see whether or not the database connection is in autocommit +** mode. Return TRUE if it is and FALSE if not. Autocommit mode is on +** by default. Autocommit is disabled by a BEGIN statement and reenabled +** by the next COMMIT or ROLLBACK. +** +******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ****** +*/ +EXPORT_C int sqlite3_get_autocommit(sqlite3 *db){ + return db->autoCommit; +} + +#ifdef SQLITE_DEBUG +/* +** The following routine is subtituted for constant SQLITE_CORRUPT in +** debugging builds. This provides a way to set a breakpoint for when +** corruption is first detected. +*/ +int sqlite3Corrupt(void){ + return SQLITE_CORRUPT; +} +#endif + +/* +** This is a convenience routine that makes sure that all thread-specific +** data for this thread has been deallocated. +** +** SQLite no longer uses thread-specific data so this routine is now a +** no-op. It is retained for historical compatibility. +*/ +EXPORT_C void sqlite3_thread_cleanup(void){ +} + +/* +** Return meta information about a specific column of a database table. +** See comment in sqlite3.h (sqlite.h.in) for details. +*/ +#ifdef SQLITE_ENABLE_COLUMN_METADATA +int sqlite3_table_column_metadata( + sqlite3 *db, /* Connection handle */ + const char *zDbName, /* Database name or NULL */ + const char *zTableName, /* Table name */ + const char *zColumnName, /* Column name */ + char const **pzDataType, /* OUTPUT: Declared data type */ + char const **pzCollSeq, /* OUTPUT: Collation sequence name */ + int *pNotNull, /* OUTPUT: True if NOT NULL constraint exists */ + int *pPrimaryKey, /* OUTPUT: True if column part of PK */ + int *pAutoinc /* OUTPUT: True if colums is auto-increment */ +){ + int rc; + char *zErrMsg = 0; + Table *pTab = 0; + Column *pCol = 0; + int iCol; + + char const *zDataType = 0; + char const *zCollSeq = 0; + int notnull = 0; + int primarykey = 0; + int autoinc = 0; + + /* Ensure the database schema has been loaded */ + if( sqlite3SafetyOn(db) ){ + return SQLITE_MISUSE; + } + sqlite3_mutex_enter(db->mutex); + rc = sqlite3Init(db, &zErrMsg); + if( SQLITE_OK!=rc ){ + goto error_out; + } + + /* Locate the table in question */ + pTab = sqlite3FindTable(db, zTableName, zDbName); + if( !pTab || pTab->pSelect ){ + pTab = 0; + goto error_out; + } + + /* Find the column for which info is requested */ + if( sqlite3IsRowid(zColumnName) ){ + iCol = pTab->iPKey; + if( iCol>=0 ){ + pCol = &pTab->aCol[iCol]; + } + }else{ + for(iCol=0; iColnCol; iCol++){ + pCol = &pTab->aCol[iCol]; + if( 0==sqlite3StrICmp(pCol->zName, zColumnName) ){ + break; + } + } + if( iCol==pTab->nCol ){ + pTab = 0; + goto error_out; + } + } + + /* The following block stores the meta information that will be returned + ** to the caller in local variables zDataType, zCollSeq, notnull, primarykey + ** and autoinc. At this point there are two possibilities: + ** + ** 1. The specified column name was rowid", "oid" or "_rowid_" + ** and there is no explicitly declared IPK column. + ** + ** 2. The table is not a view and the column name identified an + ** explicitly declared column. Copy meta information from *pCol. + */ + if( pCol ){ + zDataType = pCol->zType; + zCollSeq = pCol->zColl; + notnull = (pCol->notNull?1:0); + primarykey = (pCol->isPrimKey?1:0); + autoinc = ((pTab->iPKey==iCol && pTab->autoInc)?1:0); + }else{ + zDataType = "INTEGER"; + primarykey = 1; + } + if( !zCollSeq ){ + zCollSeq = "BINARY"; + } + +error_out: + if( sqlite3SafetyOff(db) ){ + rc = SQLITE_MISUSE; + } + + /* Whether the function call succeeded or failed, set the output parameters + ** to whatever their local counterparts contain. If an error did occur, + ** this has the effect of zeroing all output parameters. + */ + if( pzDataType ) *pzDataType = zDataType; + if( pzCollSeq ) *pzCollSeq = zCollSeq; + if( pNotNull ) *pNotNull = notnull; + if( pPrimaryKey ) *pPrimaryKey = primarykey; + if( pAutoinc ) *pAutoinc = autoinc; + + if( SQLITE_OK==rc && !pTab ){ + sqlite3SetString(&zErrMsg, "no such table column: ", zTableName, ".", + zColumnName, 0); + rc = SQLITE_ERROR; + } + sqlite3Error(db, rc, (zErrMsg?"%s":0), zErrMsg); + sqlite3_free(zErrMsg); + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} +#endif + +/* +** Sleep for a little while. Return the amount of time slept. +*/ +EXPORT_C int sqlite3_sleep(int ms){ + sqlite3_vfs *pVfs; + int rc; + pVfs = sqlite3_vfs_find(0); + + /* This function works in milliseconds, but the underlying OsSleep() + ** API uses microseconds. Hence the 1000's. + */ + rc = (sqlite3OsSleep(pVfs, 1000*ms)/1000); + return rc; +} + +/* +** Enable or disable the extended result codes. +*/ +EXPORT_C int sqlite3_extended_result_codes(sqlite3 *db, int onoff){ + sqlite3_mutex_enter(db->mutex); + db->errMask = onoff ? 0xffffffff : 0xff; + sqlite3_mutex_leave(db->mutex); + return SQLITE_OK; +} + +/* +** Invoke the xFileControl method on a particular database. +*/ +EXPORT_C int sqlite3_file_control(sqlite3 *db, const char *zDbName, int op, void *pArg){ + int rc = SQLITE_ERROR; + int iDb; + sqlite3_mutex_enter(db->mutex); + if( zDbName==0 ){ + iDb = 0; + }else{ + for(iDb=0; iDbnDb; iDb++){ + if( strcmp(db->aDb[iDb].zName, zDbName)==0 ) break; + } + } + if( iDbnDb ){ + Btree *pBtree = db->aDb[iDb].pBt; + if( pBtree ){ + Pager *pPager; + sqlite3BtreeEnter(pBtree); + pPager = sqlite3BtreePager(pBtree); + if( pPager ){ + sqlite3_file *fd = sqlite3PagerFile(pPager); + if( fd ){ + rc = sqlite3OsFileControl(fd, op, pArg); + } + } + sqlite3BtreeLeave(pBtree); + } + } + sqlite3_mutex_leave(db->mutex); + return rc; +} diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/malloc.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/malloc.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,241 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** Memory allocation functions used throughout sqlite. +** +** +** $Id: malloc.cpp 1282 2008-11-13 09:31:33Z LarsPson $ +*/ +#include "sqliteInt.h" +#include +#include + +/* +** This routine runs when the memory allocator sees that the +** total memory allocation is about to exceed the soft heap +** limit. +*/ +static void softHeapLimitEnforcer( + void *NotUsed, + sqlite3_int64 inUse, + int allocSize +){ + sqlite3_release_memory(allocSize); +} + +/* +** Set the soft heap-size limit for the current thread. Passing a +** zero or negative value indicates no limit. +*/ +EXPORT_C void sqlite3_soft_heap_limit(int n){ + sqlite3_uint64 iLimit; + int overage; + if( n<0 ){ + iLimit = 0; + }else{ + iLimit = n; + } + if( iLimit>0 ){ + sqlite3_memory_alarm(softHeapLimitEnforcer, 0, iLimit); + }else{ + sqlite3_memory_alarm(0, 0, 0); + } + overage = sqlite3_memory_used() - n; + if( overage>0 ){ + sqlite3_release_memory(overage); + } +} + +/* +** Release memory held by SQLite instances created by the current thread. +*/ +EXPORT_C int sqlite3_release_memory(int n){ +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT + return sqlite3PagerReleaseMemory(n); +#else + return SQLITE_OK; +#endif +} + + +/* +** Allocate and zero memory. +*/ +void *sqlite3MallocZero(unsigned n){ + + void *p = sqlite3_malloc(n); + if( p ){ + memset(p, 0, n); + } + + return p; +} + +/* +** Allocate and zero memory. If the allocation fails, make +** the mallocFailed flag in the connection pointer. +*/ +void *sqlite3DbMallocZero(sqlite3 *db, unsigned n){ + void *p = sqlite3DbMallocRaw(db, n); + if( p ){ + memset(p, 0, n); + } + return p; +} + +/* +** Allocate and zero memory. If the allocation fails, make +** the mallocFailed flag in the connection pointer. +*/ +void *sqlite3DbMallocRaw(sqlite3 *db, unsigned n){ + void *p = 0; + if( !db || db->mallocFailed==0 ){ + p = sqlite3_malloc(n); + if( !p && db ){ + db->mallocFailed = 1; + } + } + return p; +} + +/* +** Resize the block of memory pointed to by p to n bytes. If the +** resize fails, set the mallocFailed flag inthe connection object. +*/ +void *sqlite3DbRealloc(sqlite3 *db, void *p, int n){ + void *pNew = 0; + if( db->mallocFailed==0 ){ + pNew = sqlite3_realloc(p, n); + if( !pNew ){ + db->mallocFailed = 1; + } + } + return pNew; +} + +/* +** Attempt to reallocate p. If the reallocation fails, then free p +** and set the mallocFailed flag in the database connection. +*/ +void *sqlite3DbReallocOrFree(sqlite3 *db, void *p, int n){ + void *pNew; + pNew = sqlite3DbRealloc(db, p, n); + if( !pNew ){ + sqlite3_free(p); + } + return pNew; +} + +/* +** Make a copy of a string in memory obtained from sqliteMalloc(). These +** functions call sqlite3MallocRaw() directly instead of sqliteMalloc(). This +** is because when memory debugging is turned on, these two functions are +** called via macros that record the current file and line number in the +** ThreadData structure. +*/ +char *sqlite3StrDup(const char *z){ + char *zNew; + int n; + if( z==0 ) return 0; + n = strlen(z)+1; + zNew = (char*)sqlite3_malloc(n); + if( zNew ) memcpy(zNew, z, n); + return zNew; +} +char *sqlite3StrNDup(const char *z, int n){ + char *zNew; + if( z==0 ) return 0; + zNew = (char*)sqlite3_malloc(n+1); + if( zNew ){ + memcpy(zNew, z, n); + zNew[n] = 0; + } + return zNew; +} + +char *sqlite3DbStrDup(sqlite3 *db, const char *z){ + char *zNew = sqlite3StrDup(z); + if( z && !zNew ){ + db->mallocFailed = 1; + } + return zNew; +} +char *sqlite3DbStrNDup(sqlite3 *db, const char *z, int n){ + char *zNew = sqlite3StrNDup(z, n); + if( z && !zNew ){ + db->mallocFailed = 1; + } + return zNew; +} + +/* +** Create a string from the 2nd and subsequent arguments (up to the +** first NULL argument), store the string in memory obtained from +** sqliteMalloc() and make the pointer indicated by the 1st argument +** point to that string. The 1st argument must either be NULL or +** point to memory obtained from sqliteMalloc(). +*/ +void sqlite3SetString(char **pz, ...){ + va_list ap; + int nByte; + const char *z; + char *zResult; + + assert( pz!=0 ); + nByte = 1; + va_start(ap, pz); + while( (z = va_arg(ap, const char*))!=0 ){ + nByte += strlen(z); + } + va_end(ap); + sqlite3_free(*pz); + *pz = zResult = (char*)sqlite3_malloc(nByte); + if( zResult==0 ){ + return; + } + *zResult = 0; + va_start(ap, pz); + while( (z = va_arg(ap, const char*))!=0 ){ + int n = strlen(z); + memcpy(zResult, z, n); + zResult += n; + } + zResult[0] = 0; + va_end(ap); +} + + +/* +** This function must be called before exiting any API function (i.e. +** returning control to the user) that has called sqlite3_malloc or +** sqlite3_realloc. +** +** The returned value is normally a copy of the second argument to this +** function. However, if a malloc() failure has occured since the previous +** invocation SQLITE_NOMEM is returned instead. +** +** If the first argument, db, is not NULL and a malloc() error has occured, +** then the connection error-code (the value returned by sqlite3_errcode()) +** is set to SQLITE_NOMEM. +*/ +int sqlite3ApiExit(sqlite3* db, int rc){ + /* If the db handle is not NULL, then we must hold the connection handle + ** mutex here. Otherwise the read (and possible write) of db->mallocFailed + ** is unsafe, as is the call to sqlite3Error(). + */ + assert( !db || sqlite3_mutex_held(db->mutex) ); + if( db && db->mallocFailed ){ + sqlite3Error(db, SQLITE_NOMEM, 0); + db->mallocFailed = 0; + rc = SQLITE_NOMEM; + } + return rc & (db ? db->errMask : 0xff); +} diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/mem1.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/mem1.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,232 @@ +/* +** 2007 August 14 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the C functions that implement a memory +** allocation subsystem for use by SQLite. +** +** $Id: mem1.cpp 1282 2008-11-13 09:31:33Z LarsPson $ +*/ + +/* +** This version of the memory allocator is the default. It is +** used when no other memory allocator is specified using compile-time +** macros. +*/ +#if !defined(SQLITE_MEMDEBUG) && !defined(SQLITE_MEMORY_SIZE) \ + && !defined(SQLITE_MMAP_HEAP_SIZE) + +/* +** We will eventually construct multiple memory allocation subsystems +** suitable for use in various contexts: +** +** * Normal multi-threaded builds +** * Normal single-threaded builds +** * Debugging builds +** +** This initial version is suitable for use in normal multi-threaded +** builds. We envision that alternative versions will be stored in +** separate source files. #ifdefs will be used to select the code from +** one of the various memN.c source files for use in any given build. +*/ +#include "sqliteInt.h" + +/* +** All of the static variables used by this module are collected +** into a single structure named "mem". This is to keep the +** static variables organized and to reduce namespace pollution +** when this module is combined with other in the amalgamation. +*/ +static struct { + /* + ** The alarm callback and its arguments. The mem.mutex lock will + ** be held while the callback is running. Recursive calls into + ** the memory subsystem are allowed, but no new callbacks will be + ** issued. The alarmBusy variable is set to prevent recursive + ** callbacks. + */ + sqlite3_int64 alarmThreshold; + void (*alarmCallback)(void*, sqlite3_int64,int); + void *alarmArg; + int alarmBusy; + + /* + ** Mutex to control access to the memory allocation subsystem. + */ + sqlite3_mutex *mutex; + + /* + ** Current allocation and high-water mark. + */ + sqlite3_int64 nowUsed; + sqlite3_int64 mxUsed; + + +} mem; + +/* +** Enter the mutex mem.mutex. Allocate it if it is not already allocated. +*/ +static void enterMem(void){ + if( mem.mutex==0 ){ + mem.mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MEM); + } + sqlite3_mutex_enter(mem.mutex); +} + +/* +** Return the amount of memory currently checked out. +*/ +EXPORT_C sqlite3_int64 sqlite3_memory_used(void){ + sqlite3_int64 n; + enterMem(); + n = mem.nowUsed; + sqlite3_mutex_leave(mem.mutex); + return n; +} + +/* +** Return the maximum amount of memory that has ever been +** checked out since either the beginning of this process +** or since the most recent reset. +*/ +EXPORT_C sqlite3_int64 sqlite3_memory_highwater(int resetFlag){ + sqlite3_int64 n; + enterMem(); + n = mem.mxUsed; + if( resetFlag ){ + mem.mxUsed = mem.nowUsed; + } + sqlite3_mutex_leave(mem.mutex); + return n; +} + +/* +** Change the alarm callback +*/ +EXPORT_C int sqlite3_memory_alarm( + void(*xCallback)(void *pArg, sqlite3_int64 used,int N), + void *pArg, + sqlite3_int64 iThreshold +){ + enterMem(); + mem.alarmCallback = xCallback; + mem.alarmArg = pArg; + mem.alarmThreshold = iThreshold; + sqlite3_mutex_leave(mem.mutex); + return SQLITE_OK; +} + +/* +** Trigger the alarm +*/ +static void sqlite3MemsysAlarm(int nByte){ + void (*xCallback)(void*,sqlite3_int64,int); + sqlite3_int64 nowUsed; + void *pArg; + if( mem.alarmCallback==0 || mem.alarmBusy ) return; + mem.alarmBusy = 1; + xCallback = mem.alarmCallback; + nowUsed = mem.nowUsed; + pArg = mem.alarmArg; + sqlite3_mutex_leave(mem.mutex); + xCallback(pArg, nowUsed, nByte); + sqlite3_mutex_enter(mem.mutex); + mem.alarmBusy = 0; +} + +/* +** Allocate nBytes of memory +*/ +EXPORT_C void *sqlite3_malloc(int nBytes){ + sqlite3_int64 *p = 0; + if( nBytes>0 ){ + enterMem(); + if( mem.alarmCallback!=0 && mem.nowUsed+nBytes>=mem.alarmThreshold ){ + sqlite3MemsysAlarm(nBytes); + } + p = (sqlite3_int64*)malloc(nBytes+8); + if( p==0 ){ + sqlite3MemsysAlarm(nBytes); + p = (sqlite3_int64*)malloc(nBytes+8); + } + if( p ){ + p[0] = nBytes; + p++; + mem.nowUsed += nBytes; + if( mem.nowUsed>mem.mxUsed ){ + mem.mxUsed = mem.nowUsed; + } + } + sqlite3_mutex_leave(mem.mutex); + } + return (void*)p; +} + +/* +** Free memory. +*/ +EXPORT_C void sqlite3_free(void *pPrior){ + sqlite3_int64 *p; + int nByte; + if( pPrior==0 ){ + return; + } + assert( mem.mutex!=0 ); + p = (sqlite3_int64*)pPrior; + p--; + nByte = (int)*p; + sqlite3_mutex_enter(mem.mutex); + mem.nowUsed -= nByte; + free(p); + sqlite3_mutex_leave(mem.mutex); +} + +/* +** Change the size of an existing memory allocation +*/ +EXPORT_C void *sqlite3_realloc(void *pPrior, int nBytes){ + int nOld; + sqlite3_int64 *p; + if( pPrior==0 ){ + return sqlite3_malloc(nBytes); + } + if( nBytes<=0 ){ + sqlite3_free(pPrior); + return 0; + } + p = (sqlite3_int64*)pPrior; + p--; + nOld = (int)p[0]; + assert( mem.mutex!=0 ); + sqlite3_mutex_enter(mem.mutex); + if( mem.nowUsed+nBytes-nOld>=mem.alarmThreshold ){ + sqlite3MemsysAlarm(nBytes-nOld); + } + p = (sqlite3_int64*)realloc(p, nBytes+8); + if( p==0 ){ + sqlite3MemsysAlarm(nBytes); + p = (sqlite3_int64*)pPrior; + p--; + p = (sqlite3_int64*)realloc(p, nBytes+8); + } + if( p ){ + p[0] = nBytes; + p++; + mem.nowUsed += nBytes-nOld; + if( mem.nowUsed>mem.mxUsed ){ + mem.mxUsed = mem.nowUsed; + } + } + sqlite3_mutex_leave(mem.mutex); + return (void*)p; +} + +#endif /* !SQLITE_MEMDEBUG && !SQLITE_OMIT_MEMORY_ALLOCATION */ diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/mem2.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/mem2.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,573 @@ +/* +** 2007 August 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the C functions that implement a memory +** allocation subsystem for use by SQLite. +** +** $Id: mem2.cpp 1282 2008-11-13 09:31:33Z LarsPson $ +*/ + +/* +** This version of the memory allocator is used only if the +** SQLITE_MEMDEBUG macro is defined and SQLITE_OMIT_MEMORY_ALLOCATION +** is not defined. +*/ +#if defined(SQLITE_MEMDEBUG) + +/* +** We will eventually construct multiple memory allocation subsystems +** suitable for use in various contexts: +** +** * Normal multi-threaded builds +** * Normal single-threaded builds +** * Debugging builds +** +** This version is suitable for use in debugging builds. +** +** Features: +** +** * Every allocate has guards at both ends. +** * New allocations are initialized with randomness +** * Allocations are overwritten with randomness when freed +** * Optional logs of malloc activity generated +** * Summary of outstanding allocations with backtraces to the +** point of allocation. +** * The ability to simulate memory allocation failure +*/ +#include "sqliteInt.h" +#include + +/* +** The backtrace functionality is only available with GLIBC +*/ +#ifdef __GLIBC__ + extern int backtrace(void**,int); + extern void backtrace_symbols_fd(void*const*,int,int); +#else +# define backtrace(A,B) 0 +# define backtrace_symbols_fd(A,B,C) +#endif + +/* +** Each memory allocation looks like this: +** +** ------------------------------------------------------------------------ +** | Title | backtrace pointers | MemBlockHdr | allocation | EndGuard | +** ------------------------------------------------------------------------ +** +** The application code sees only a pointer to the allocation. We have +** to back up from the allocation pointer to find the MemBlockHdr. The +** MemBlockHdr tells us the size of the allocation and the number of +** backtrace pointers. There is also a guard word at the end of the +** MemBlockHdr. +*/ +struct MemBlockHdr { + struct MemBlockHdr *pNext, *pPrev; /* Linked list of all unfreed memory */ + int iSize; /* Size of this allocation */ + char nBacktrace; /* Number of backtraces on this alloc */ + char nBacktraceSlots; /* Available backtrace slots */ + short nTitle; /* Bytes of title; includes '\0' */ + int iForeGuard; /* Guard word for sanity */ +}; + +/* +** Guard words +*/ +#define FOREGUARD 0x80F5E153 +#define REARGUARD 0xE4676B53 + +/* +** Number of malloc size increments to track. +*/ +#define NCSIZE 1000 + +/* +** All of the static variables used by this module are collected +** into a single structure named "mem". This is to keep the +** static variables organized and to reduce namespace pollution +** when this module is combined with other in the amalgamation. +*/ +static struct { + /* + ** The alarm callback and its arguments. The mem.mutex lock will + ** be held while the callback is running. Recursive calls into + ** the memory subsystem are allowed, but no new callbacks will be + ** issued. The alarmBusy variable is set to prevent recursive + ** callbacks. + */ + sqlite3_int64 alarmThreshold; + void (*alarmCallback)(void*, sqlite3_int64, int); + void *alarmArg; + int alarmBusy; + + /* + ** Mutex to control access to the memory allocation subsystem. + */ + sqlite3_mutex *mutex; + + /* + ** Current allocation and high-water mark. + */ + sqlite3_int64 nowUsed; + sqlite3_int64 mxUsed; + + /* + ** Head and tail of a linked list of all outstanding allocations + */ + struct MemBlockHdr *pFirst; + struct MemBlockHdr *pLast; + + /* + ** The number of levels of backtrace to save in new allocations. + */ + int nBacktrace; + + /* + ** Title text to insert in front of each block + */ + int nTitle; /* Bytes of zTitle to save. Includes '\0' and padding */ + char zTitle[100]; /* The title text */ + + /* + ** These values are used to simulate malloc failures. When + ** iFail is 1, simulate a malloc failures and reset the value + ** to iReset. + */ + int iFail; /* Decrement and fail malloc when this is 1 */ + int iReset; /* When malloc fails set iiFail to this value */ + int iFailCnt; /* Number of failures */ + int iBenignFailCnt; /* Number of benign failures */ + int iNextIsBenign; /* True if the next call to malloc may fail benignly */ + int iIsBenign; /* All malloc calls may fail benignly */ + + /* + ** sqlite3MallocDisallow() increments the following counter. + ** sqlite3MallocAllow() decrements it. + */ + int disallow; /* Do not allow memory allocation */ + + /* + ** Gather statistics on the sizes of memory allocations. + ** sizeCnt[i] is the number of allocation attempts of i*8 + ** bytes. i==NCSIZE is the number of allocation attempts for + ** sizes more than NCSIZE*8 bytes. + */ + int sizeCnt[NCSIZE]; + +} mem; + + +/* +** Enter the mutex mem.mutex. Allocate it if it is not already allocated. +*/ +static void enterMem(void){ + if( mem.mutex==0 ){ + mem.mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MEM); + } + sqlite3_mutex_enter(mem.mutex); +} + +/* +** Return the amount of memory currently checked out. +*/ +sqlite3_int64 sqlite3_memory_used(void){ + sqlite3_int64 n; + enterMem(); + n = mem.nowUsed; + sqlite3_mutex_leave(mem.mutex); + return n; +} + +/* +** Return the maximum amount of memory that has ever been +** checked out since either the beginning of this process +** or since the most recent reset. +*/ +sqlite3_int64 sqlite3_memory_highwater(int resetFlag){ + sqlite3_int64 n; + enterMem(); + n = mem.mxUsed; + if( resetFlag ){ + mem.mxUsed = mem.nowUsed; + } + sqlite3_mutex_leave(mem.mutex); + return n; +} + +/* +** Change the alarm callback +*/ +int sqlite3_memory_alarm( + void(*xCallback)(void *pArg, sqlite3_int64 used, int N), + void *pArg, + sqlite3_int64 iThreshold +){ + enterMem(); + mem.alarmCallback = xCallback; + mem.alarmArg = pArg; + mem.alarmThreshold = iThreshold; + sqlite3_mutex_leave(mem.mutex); + return SQLITE_OK; +} + +/* +** Trigger the alarm +*/ +static void sqlite3MemsysAlarm(int nByte){ + void (*xCallback)(void*,sqlite3_int64,int); + sqlite3_int64 nowUsed; + void *pArg; + if( mem.alarmCallback==0 || mem.alarmBusy ) return; + mem.alarmBusy = 1; + xCallback = mem.alarmCallback; + nowUsed = mem.nowUsed; + pArg = mem.alarmArg; + sqlite3_mutex_leave(mem.mutex); + xCallback(pArg, nowUsed, nByte); + sqlite3_mutex_enter(mem.mutex); + mem.alarmBusy = 0; +} + +/* +** Given an allocation, find the MemBlockHdr for that allocation. +** +** This routine checks the guards at either end of the allocation and +** if they are incorrect it asserts. +*/ +static struct MemBlockHdr *sqlite3MemsysGetHeader(void *pAllocation){ + struct MemBlockHdr *p; + int *pInt; + + p = (struct MemBlockHdr*)pAllocation; + p--; + assert( p->iForeGuard==FOREGUARD ); + assert( (p->iSize & 3)==0 ); + pInt = (int*)pAllocation; + assert( pInt[p->iSize/sizeof(int)]==REARGUARD ); + return p; +} + +/* +** This routine is called once the first time a simulated memory +** failure occurs. The sole purpose of this routine is to provide +** a convenient place to set a debugger breakpoint when debugging +** errors related to malloc() failures. +*/ +static void sqlite3MemsysFailed(void){ + mem.iFailCnt = 0; + mem.iBenignFailCnt = 0; +} + +/* +** Allocate nByte bytes of memory. +*/ +void *sqlite3_malloc(int nByte){ + struct MemBlockHdr *pHdr; + void **pBt; + char *z; + int *pInt; + void *p = 0; + int totalSize; + + if( nByte>0 ){ + enterMem(); + assert( mem.disallow==0 ); + if( mem.alarmCallback!=0 && mem.nowUsed+nByte>=mem.alarmThreshold ){ + sqlite3MemsysAlarm(nByte); + } + nByte = (nByte+3)&~3; + if( nByte/8>NCSIZE-1 ){ + mem.sizeCnt[NCSIZE-1]++; + }else{ + mem.sizeCnt[nByte/8]++; + } + totalSize = nByte + sizeof(*pHdr) + sizeof(int) + + mem.nBacktrace*sizeof(void*) + mem.nTitle; + if( mem.iFail>0 ){ + if( mem.iFail==1 ){ + p = 0; + mem.iFail = mem.iReset; + if( mem.iFailCnt==0 ){ + sqlite3MemsysFailed(); /* A place to set a breakpoint */ + } + mem.iFailCnt++; + if( mem.iNextIsBenign || mem.iIsBenign ){ + mem.iBenignFailCnt++; + } + }else{ + p = malloc(totalSize); + mem.iFail--; + } + }else{ + p = malloc(totalSize); + if( p==0 ){ + sqlite3MemsysAlarm(nByte); + p = malloc(totalSize); + } + } + if( p ){ + z = p; + pBt = (void**)&z[mem.nTitle]; + pHdr = (struct MemBlockHdr*)&pBt[mem.nBacktrace]; + pHdr->pNext = 0; + pHdr->pPrev = mem.pLast; + if( mem.pLast ){ + mem.pLast->pNext = pHdr; + }else{ + mem.pFirst = pHdr; + } + mem.pLast = pHdr; + pHdr->iForeGuard = FOREGUARD; + pHdr->nBacktraceSlots = mem.nBacktrace; + pHdr->nTitle = mem.nTitle; + if( mem.nBacktrace ){ + void *aAddr[40]; + pHdr->nBacktrace = backtrace(aAddr, mem.nBacktrace+1)-1; + memcpy(pBt, &aAddr[1], pHdr->nBacktrace*sizeof(void*)); + }else{ + pHdr->nBacktrace = 0; + } + if( mem.nTitle ){ + memcpy(z, mem.zTitle, mem.nTitle); + } + pHdr->iSize = nByte; + pInt = (int*)&pHdr[1]; + pInt[nByte/sizeof(int)] = REARGUARD; + memset(pInt, 0x65, nByte); + mem.nowUsed += nByte; + if( mem.nowUsed>mem.mxUsed ){ + mem.mxUsed = mem.nowUsed; + } + p = (void*)pInt; + } + sqlite3_mutex_leave(mem.mutex); + } + mem.iNextIsBenign = 0; + return p; +} + +/* +** Free memory. +*/ +void sqlite3_free(void *pPrior){ + struct MemBlockHdr *pHdr; + void **pBt; + char *z; + if( pPrior==0 ){ + return; + } + assert( mem.mutex!=0 ); + pHdr = sqlite3MemsysGetHeader(pPrior); + pBt = (void**)pHdr; + pBt -= pHdr->nBacktraceSlots; + sqlite3_mutex_enter(mem.mutex); + mem.nowUsed -= pHdr->iSize; + if( pHdr->pPrev ){ + assert( pHdr->pPrev->pNext==pHdr ); + pHdr->pPrev->pNext = pHdr->pNext; + }else{ + assert( mem.pFirst==pHdr ); + mem.pFirst = pHdr->pNext; + } + if( pHdr->pNext ){ + assert( pHdr->pNext->pPrev==pHdr ); + pHdr->pNext->pPrev = pHdr->pPrev; + }else{ + assert( mem.pLast==pHdr ); + mem.pLast = pHdr->pPrev; + } + z = (char*)pBt; + z -= pHdr->nTitle; + memset(z, 0x2b, sizeof(void*)*pHdr->nBacktraceSlots + sizeof(*pHdr) + + pHdr->iSize + sizeof(int) + pHdr->nTitle); + free(z); + sqlite3_mutex_leave(mem.mutex); +} + +/* +** Change the size of an existing memory allocation. +** +** For this debugging implementation, we *always* make a copy of the +** allocation into a new place in memory. In this way, if the +** higher level code is using pointer to the old allocation, it is +** much more likely to break and we are much more liking to find +** the error. +*/ +void *sqlite3_realloc(void *pPrior, int nByte){ + struct MemBlockHdr *pOldHdr; + void *pNew; + if( pPrior==0 ){ + return sqlite3_malloc(nByte); + } + if( nByte<=0 ){ + sqlite3_free(pPrior); + return 0; + } + assert( mem.disallow==0 ); + pOldHdr = sqlite3MemsysGetHeader(pPrior); + pNew = sqlite3_malloc(nByte); + if( pNew ){ + memcpy(pNew, pPrior, nByteiSize ? nByte : pOldHdr->iSize); + if( nByte>pOldHdr->iSize ){ + memset(&((char*)pNew)[pOldHdr->iSize], 0x2b, nByte - pOldHdr->iSize); + } + sqlite3_free(pPrior); + } + return pNew; +} + +/* +** Set the number of backtrace levels kept for each allocation. +** A value of zero turns of backtracing. The number is always rounded +** up to a multiple of 2. +*/ +void sqlite3_memdebug_backtrace(int depth){ + if( depth<0 ){ depth = 0; } + if( depth>20 ){ depth = 20; } + depth = (depth+1)&0xfe; + mem.nBacktrace = depth; +} + +/* +** Set the title string for subsequent allocations. +*/ +void sqlite3_memdebug_settitle(const char *zTitle){ + int n = strlen(zTitle) + 1; + enterMem(); + if( n>=sizeof(mem.zTitle) ) n = sizeof(mem.zTitle)-1; + memcpy(mem.zTitle, zTitle, n); + mem.zTitle[n] = 0; + mem.nTitle = (n+3)&~3; + sqlite3_mutex_leave(mem.mutex); +} + +/* +** Open the file indicated and write a log of all unfreed memory +** allocations into that log. +*/ +void sqlite3_memdebug_dump(const char *zFilename){ + FILE *out; + struct MemBlockHdr *pHdr; + void **pBt; + int i; + out = fopen(zFilename, "w"); + if( out==0 ){ + fprintf(stderr, "** Unable to output memory debug output log: %s **\n", + zFilename); + return; + } + for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){ + char *z = (char*)pHdr; + z -= pHdr->nBacktraceSlots*sizeof(void*) + pHdr->nTitle; + fprintf(out, "**** %d bytes at %p from %s ****\n", + pHdr->iSize, &pHdr[1], pHdr->nTitle ? z : "???"); + if( pHdr->nBacktrace ){ + fflush(out); + pBt = (void**)pHdr; + pBt -= pHdr->nBacktraceSlots; + backtrace_symbols_fd(pBt, pHdr->nBacktrace, fileno(out)); + fprintf(out, "\n"); + } + } + fprintf(out, "COUNTS:\n"); + for(i=0; i%3d: %d\n", NCSIZE*8, mem.sizeCnt[NCSIZE-1]); + } + fclose(out); +} + +/* +** This routine is used to simulate malloc failures. +** +** After calling this routine, there will be iFail successful +** memory allocations and then a failure. If iRepeat is 1 +** all subsequent memory allocations will fail. If iRepeat is +** 0, only a single allocation will fail. If iRepeat is negative +** then the previous setting for iRepeat is unchanged. +** +** Each call to this routine overrides the previous. To disable +** the simulated allocation failure mechanism, set iFail to -1. +** +** This routine returns the number of simulated failures that have +** occurred since the previous call. +*/ +int sqlite3_memdebug_fail(int iFail, int iRepeat, int *piBenign){ + int n = mem.iFailCnt; + if( piBenign ){ + *piBenign = mem.iBenignFailCnt; + } + mem.iFail = iFail+1; + if( iRepeat>=0 ){ + mem.iReset = iRepeat; + } + mem.iFailCnt = 0; + mem.iBenignFailCnt = 0; + return n; +} + +int sqlite3_memdebug_pending(){ + return (mem.iFail-1); +} + +/* +** The following three functions are used to indicate to the test +** infrastructure which malloc() calls may fail benignly without +** affecting functionality. This can happen when resizing hash tables +** (failing to resize a hash-table is a performance hit, but not an +** error) or sometimes during a rollback operation. +** +** If the argument is true, sqlite3MallocBenignFailure() indicates that the +** next call to allocate memory may fail benignly. +** +** If sqlite3MallocEnterBenignBlock() is called with a non-zero argument, +** then all memory allocations requested before the next call to +** sqlite3MallocLeaveBenignBlock() may fail benignly. +*/ +void sqlite3MallocBenignFailure(int isBenign){ + if( isBenign ){ + mem.iNextIsBenign = 1; + } +} +void sqlite3MallocEnterBenignBlock(int isBenign){ + if( isBenign ){ + mem.iIsBenign = 1; + } +} +void sqlite3MallocLeaveBenignBlock(){ + mem.iIsBenign = 0; +} + +/* +** The following two routines are used to assert that no memory +** allocations occur between one call and the next. The use of +** these routines does not change the computed results in any way. +** These routines are like asserts. +*/ +void sqlite3MallocDisallow(void){ + assert( mem.mutex!=0 ); + sqlite3_mutex_enter(mem.mutex); + mem.disallow++; + sqlite3_mutex_leave(mem.mutex); +} +void sqlite3MallocAllow(void){ + assert( mem.mutex ); + sqlite3_mutex_enter(mem.mutex); + assert( mem.disallow>0 ); + mem.disallow--; + sqlite3_mutex_leave(mem.mutex); +} + +#endif /* SQLITE_MEMDEBUG && !SQLITE_OMIT_MEMORY_ALLOCATION */ diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/mem3.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/mem3.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,623 @@ +/* +** 2007 October 14 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the C functions that implement a memory +** allocation subsystem for use by SQLite. +** +** This version of the memory allocation subsystem omits all +** use of malloc(). All dynamically allocatable memory is +** contained in a static array, mem.aPool[]. The size of this +** fixed memory pool is SQLITE_MEMORY_SIZE bytes. +** +** This version of the memory allocation subsystem is used if +** and only if SQLITE_MEMORY_SIZE is defined. +** +** $Id: mem3.cpp 1282 2008-11-13 09:31:33Z LarsPson $ +*/ + +/* +** This version of the memory allocator is used only when +** SQLITE_MEMORY_SIZE is defined. +*/ +#if defined(SQLITE_MEMORY_SIZE) +#include "sqliteInt.h" + +#ifdef SQLITE_MEMDEBUG +# error cannot define both SQLITE_MEMDEBUG and SQLITE_MEMORY_SIZE +#endif + +/* +** Maximum size (in Mem3Blocks) of a "small" chunk. +*/ +#define MX_SMALL 10 + + +/* +** Number of freelist hash slots +*/ +#define N_HASH 61 + +/* +** A memory allocation (also called a "chunk") consists of two or +** more blocks where each block is 8 bytes. The first 8 bytes are +** a header that is not returned to the user. +** +** A chunk is two or more blocks that is either checked out or +** free. The first block has format u.hdr. u.hdr.size is the +** size of the allocation in blocks if the allocation is free. +** If the allocation is checked out, u.hdr.size is the negative +** of the size. Similarly, u.hdr.prevSize is the size of the +** immediately previous allocation. +** +** We often identify a chunk by its index in mem.aPool[]. When +** this is done, the chunk index refers to the second block of +** the chunk. In this way, the first chunk has an index of 1. +** A chunk index of 0 means "no such chunk" and is the equivalent +** of a NULL pointer. +** +** The second block of free chunks is of the form u.list. The +** two fields form a double-linked list of chunks of related sizes. +** Pointers to the head of the list are stored in mem.aiSmall[] +** for smaller chunks and mem.aiHash[] for larger chunks. +** +** The second block of a chunk is user data if the chunk is checked +** out. +*/ +typedef struct Mem3Block Mem3Block; +struct Mem3Block { + union { + struct { + int prevSize; /* Size of previous chunk in Mem3Block elements */ + int size; /* Size of current chunk in Mem3Block elements */ + } hdr; + struct { + int next; /* Index in mem.aPool[] of next free chunk */ + int prev; /* Index in mem.aPool[] of previous free chunk */ + } list; + } u; +}; + +/* +** All of the static variables used by this module are collected +** into a single structure named "mem". This is to keep the +** static variables organized and to reduce namespace pollution +** when this module is combined with other in the amalgamation. +*/ +static struct { + /* + ** True if we are evaluating an out-of-memory callback. + */ + int alarmBusy; + + /* + ** Mutex to control access to the memory allocation subsystem. + */ + sqlite3_mutex *mutex; + + /* + ** The minimum amount of free space that we have seen. + */ + int mnMaster; + + /* + ** iMaster is the index of the master chunk. Most new allocations + ** occur off of this chunk. szMaster is the size (in Mem3Blocks) + ** of the current master. iMaster is 0 if there is not master chunk. + ** The master chunk is not in either the aiHash[] or aiSmall[]. + */ + int iMaster; + int szMaster; + + /* + ** Array of lists of free blocks according to the block size + ** for smaller chunks, or a hash on the block size for larger + ** chunks. + */ + int aiSmall[MX_SMALL-1]; /* For sizes 2 through MX_SMALL, inclusive */ + int aiHash[N_HASH]; /* For sizes MX_SMALL+1 and larger */ + + /* + ** Memory available for allocation + */ + Mem3Block aPool[SQLITE_MEMORY_SIZE/sizeof(Mem3Block)+2]; +} mem; + +/* +** Unlink the chunk at mem.aPool[i] from list it is currently +** on. *pRoot is the list that i is a member of. +*/ +static void memsys3UnlinkFromList(int i, int *pRoot){ + int next = mem.aPool[i].u.list.next; + int prev = mem.aPool[i].u.list.prev; + assert( sqlite3_mutex_held(mem.mutex) ); + if( prev==0 ){ + *pRoot = next; + }else{ + mem.aPool[prev].u.list.next = next; + } + if( next ){ + mem.aPool[next].u.list.prev = prev; + } + mem.aPool[i].u.list.next = 0; + mem.aPool[i].u.list.prev = 0; +} + +/* +** Unlink the chunk at index i from +** whatever list is currently a member of. +*/ +static void memsys3Unlink(int i){ + int size, hash; + assert( sqlite3_mutex_held(mem.mutex) ); + size = mem.aPool[i-1].u.hdr.size; + assert( size==mem.aPool[i+size-1].u.hdr.prevSize ); + assert( size>=2 ); + if( size <= MX_SMALL ){ + memsys3UnlinkFromList(i, &mem.aiSmall[size-2]); + }else{ + hash = size % N_HASH; + memsys3UnlinkFromList(i, &mem.aiHash[hash]); + } +} + +/* +** Link the chunk at mem.aPool[i] so that is on the list rooted +** at *pRoot. +*/ +static void memsys3LinkIntoList(int i, int *pRoot){ + assert( sqlite3_mutex_held(mem.mutex) ); + mem.aPool[i].u.list.next = *pRoot; + mem.aPool[i].u.list.prev = 0; + if( *pRoot ){ + mem.aPool[*pRoot].u.list.prev = i; + } + *pRoot = i; +} + +/* +** Link the chunk at index i into either the appropriate +** small chunk list, or into the large chunk hash table. +*/ +static void memsys3Link(int i){ + int size, hash; + assert( sqlite3_mutex_held(mem.mutex) ); + size = mem.aPool[i-1].u.hdr.size; + assert( size==mem.aPool[i+size-1].u.hdr.prevSize ); + assert( size>=2 ); + if( size <= MX_SMALL ){ + memsys3LinkIntoList(i, &mem.aiSmall[size-2]); + }else{ + hash = size % N_HASH; + memsys3LinkIntoList(i, &mem.aiHash[hash]); + } +} + +/* +** Enter the mutex mem.mutex. Allocate it if it is not already allocated. +** +** Also: Initialize the memory allocation subsystem the first time +** this routine is called. +*/ +static void memsys3Enter(void){ + if( mem.mutex==0 ){ + mem.mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MEM); + mem.aPool[0].u.hdr.size = SQLITE_MEMORY_SIZE/8; + mem.aPool[SQLITE_MEMORY_SIZE/8].u.hdr.prevSize = SQLITE_MEMORY_SIZE/8; + mem.iMaster = 1; + mem.szMaster = SQLITE_MEMORY_SIZE/8; + mem.mnMaster = mem.szMaster; + } + sqlite3_mutex_enter(mem.mutex); +} + +/* +** Return the amount of memory currently checked out. +*/ +sqlite3_int64 sqlite3_memory_used(void){ + sqlite3_int64 n; + memsys3Enter(); + n = SQLITE_MEMORY_SIZE - mem.szMaster*8; + sqlite3_mutex_leave(mem.mutex); + return n; +} + +/* +** Return the maximum amount of memory that has ever been +** checked out since either the beginning of this process +** or since the most recent reset. +*/ +sqlite3_int64 sqlite3_memory_highwater(int resetFlag){ + sqlite3_int64 n; + memsys3Enter(); + n = SQLITE_MEMORY_SIZE - mem.mnMaster*8; + if( resetFlag ){ + mem.mnMaster = mem.szMaster; + } + sqlite3_mutex_leave(mem.mutex); + return n; +} + +/* +** Change the alarm callback. +** +** This is a no-op for the static memory allocator. The purpose +** of the memory alarm is to support sqlite3_soft_heap_limit(). +** But with this memory allocator, the soft_heap_limit is really +** a hard limit that is fixed at SQLITE_MEMORY_SIZE. +*/ +int sqlite3_memory_alarm( + void(*xCallback)(void *pArg, sqlite3_int64 used,int N), + void *pArg, + sqlite3_int64 iThreshold +){ + return SQLITE_OK; +} + +/* +** Called when we are unable to satisfy an allocation of nBytes. +*/ +static void memsys3OutOfMemory(int nByte){ + if( !mem.alarmBusy ){ + mem.alarmBusy = 1; + assert( sqlite3_mutex_held(mem.mutex) ); + sqlite3_mutex_leave(mem.mutex); + sqlite3_release_memory(nByte); + sqlite3_mutex_enter(mem.mutex); + mem.alarmBusy = 0; + } +} + +/* +** Return the size of an outstanding allocation, in bytes. The +** size returned omits the 8-byte header overhead. This only +** works for chunks that are currently checked out. +*/ +static int memsys3Size(void *p){ + Mem3Block *pBlock = (Mem3Block*)p; + assert( pBlock[-1].u.hdr.size<0 ); + return (-1-pBlock[-1].u.hdr.size)*8; +} + +/* +** Chunk i is a free chunk that has been unlinked. Adjust its +** size parameters for check-out and return a pointer to the +** user portion of the chunk. +*/ +static void *memsys3Checkout(int i, int nBlock){ + assert( sqlite3_mutex_held(mem.mutex) ); + assert( mem.aPool[i-1].u.hdr.size==nBlock ); + assert( mem.aPool[i+nBlock-1].u.hdr.prevSize==nBlock ); + mem.aPool[i-1].u.hdr.size = -nBlock; + mem.aPool[i+nBlock-1].u.hdr.prevSize = -nBlock; + return &mem.aPool[i]; +} + +/* +** Carve a piece off of the end of the mem.iMaster free chunk. +** Return a pointer to the new allocation. Or, if the master chunk +** is not large enough, return 0. +*/ +static void *memsys3FromMaster(int nBlock){ + assert( sqlite3_mutex_held(mem.mutex) ); + assert( mem.szMaster>=nBlock ); + if( nBlock>=mem.szMaster-1 ){ + /* Use the entire master */ + void *p = memsys3Checkout(mem.iMaster, mem.szMaster); + mem.iMaster = 0; + mem.szMaster = 0; + mem.mnMaster = 0; + return p; + }else{ + /* Split the master block. Return the tail. */ + int newi; + newi = mem.iMaster + mem.szMaster - nBlock; + assert( newi > mem.iMaster+1 ); + mem.aPool[mem.iMaster+mem.szMaster-1].u.hdr.prevSize = -nBlock; + mem.aPool[newi-1].u.hdr.size = -nBlock; + mem.szMaster -= nBlock; + mem.aPool[newi-1].u.hdr.prevSize = mem.szMaster; + mem.aPool[mem.iMaster-1].u.hdr.size = mem.szMaster; + if( mem.szMaster < mem.mnMaster ){ + mem.mnMaster = mem.szMaster; + } + return (void*)&mem.aPool[newi]; + } +} + +/* +** *pRoot is the head of a list of free chunks of the same size +** or same size hash. In other words, *pRoot is an entry in either +** mem.aiSmall[] or mem.aiHash[]. +** +** This routine examines all entries on the given list and tries +** to coalesce each entries with adjacent free chunks. +** +** If it sees a chunk that is larger than mem.iMaster, it replaces +** the current mem.iMaster with the new larger chunk. In order for +** this mem.iMaster replacement to work, the master chunk must be +** linked into the hash tables. That is not the normal state of +** affairs, of course. The calling routine must link the master +** chunk before invoking this routine, then must unlink the (possibly +** changed) master chunk once this routine has finished. +*/ +static void memsys3Merge(int *pRoot){ + int iNext, prev, size, i; + + assert( sqlite3_mutex_held(mem.mutex) ); + for(i=*pRoot; i>0; i=iNext){ + iNext = mem.aPool[i].u.list.next; + size = mem.aPool[i-1].u.hdr.size; + assert( size>0 ); + if( mem.aPool[i-1].u.hdr.prevSize>0 ){ + memsys3UnlinkFromList(i, pRoot); + prev = i - mem.aPool[i-1].u.hdr.prevSize; + assert( prev>=0 ); + if( prev==iNext ){ + iNext = mem.aPool[prev].u.list.next; + } + memsys3Unlink(prev); + size = i + size - prev; + mem.aPool[prev-1].u.hdr.size = size; + mem.aPool[prev+size-1].u.hdr.prevSize = size; + memsys3Link(prev); + i = prev; + } + if( size>mem.szMaster ){ + mem.iMaster = i; + mem.szMaster = size; + } + } +} + +/* +** Return a block of memory of at least nBytes in size. +** Return NULL if unable. +*/ +static void *memsys3Malloc(int nByte){ + int i; + int nBlock; + int toFree; + + assert( sqlite3_mutex_held(mem.mutex) ); + assert( sizeof(Mem3Block)==8 ); + if( nByte<=0 ){ + nBlock = 2; + }else{ + nBlock = (nByte + 15)/8; + } + assert( nBlock >= 2 ); + + /* STEP 1: + ** Look for an entry of the correct size in either the small + ** chunk table or in the large chunk hash table. This is + ** successful most of the time (about 9 times out of 10). + */ + if( nBlock <= MX_SMALL ){ + i = mem.aiSmall[nBlock-2]; + if( i>0 ){ + memsys3UnlinkFromList(i, &mem.aiSmall[nBlock-2]); + return memsys3Checkout(i, nBlock); + } + }else{ + int hash = nBlock % N_HASH; + for(i=mem.aiHash[hash]; i>0; i=mem.aPool[i].u.list.next){ + if( mem.aPool[i-1].u.hdr.size==nBlock ){ + memsys3UnlinkFromList(i, &mem.aiHash[hash]); + return memsys3Checkout(i, nBlock); + } + } + } + + /* STEP 2: + ** Try to satisfy the allocation by carving a piece off of the end + ** of the master chunk. This step usually works if step 1 fails. + */ + if( mem.szMaster>=nBlock ){ + return memsys3FromMaster(nBlock); + } + + + /* STEP 3: + ** Loop through the entire memory pool. Coalesce adjacent free + ** chunks. Recompute the master chunk as the largest free chunk. + ** Then try again to satisfy the allocation by carving a piece off + ** of the end of the master chunk. This step happens very + ** rarely (we hope!) + */ + for(toFree=nBlock*16; toFree=nBlock ){ + return memsys3FromMaster(nBlock); + } + } + } + + /* If none of the above worked, then we fail. */ + return 0; +} + +/* +** Free an outstanding memory allocation. +*/ +void memsys3Free(void *pOld){ + Mem3Block *p = (Mem3Block*)pOld; + int i; + int size; + assert( sqlite3_mutex_held(mem.mutex) ); + assert( p>mem.aPool && p<&mem.aPool[SQLITE_MEMORY_SIZE/8] ); + i = p - mem.aPool; + size = -mem.aPool[i-1].u.hdr.size; + assert( size>=2 ); + assert( mem.aPool[i+size-1].u.hdr.prevSize==-size ); + mem.aPool[i-1].u.hdr.size = size; + mem.aPool[i+size-1].u.hdr.prevSize = size; + memsys3Link(i); + + /* Try to expand the master using the newly freed chunk */ + if( mem.iMaster ){ + while( mem.aPool[mem.iMaster-1].u.hdr.prevSize>0 ){ + size = mem.aPool[mem.iMaster-1].u.hdr.prevSize; + mem.iMaster -= size; + mem.szMaster += size; + memsys3Unlink(mem.iMaster); + mem.aPool[mem.iMaster-1].u.hdr.size = mem.szMaster; + mem.aPool[mem.iMaster+mem.szMaster-1].u.hdr.prevSize = mem.szMaster; + } + while( mem.aPool[mem.iMaster+mem.szMaster-1].u.hdr.size>0 ){ + memsys3Unlink(mem.iMaster+mem.szMaster); + mem.szMaster += mem.aPool[mem.iMaster+mem.szMaster-1].u.hdr.size; + mem.aPool[mem.iMaster-1].u.hdr.size = mem.szMaster; + mem.aPool[mem.iMaster+mem.szMaster-1].u.hdr.prevSize = mem.szMaster; + } + } +} + +/* +** Allocate nBytes of memory +*/ +void *sqlite3_malloc(int nBytes){ + sqlite3_int64 *p = 0; + if( nBytes>0 ){ + memsys3Enter(); + p = memsys3Malloc(nBytes); + sqlite3_mutex_leave(mem.mutex); + } + return (void*)p; +} + +/* +** Free memory. +*/ +void sqlite3_free(void *pPrior){ + if( pPrior==0 ){ + return; + } + assert( mem.mutex!=0 ); + sqlite3_mutex_enter(mem.mutex); + memsys3Free(pPrior); + sqlite3_mutex_leave(mem.mutex); +} + +/* +** Change the size of an existing memory allocation +*/ +void *sqlite3_realloc(void *pPrior, int nBytes){ + int nOld; + void *p; + if( pPrior==0 ){ + return sqlite3_malloc(nBytes); + } + if( nBytes<=0 ){ + sqlite3_free(pPrior); + return 0; + } + assert( mem.mutex!=0 ); + nOld = memsys3Size(pPrior); + if( nBytes<=nOld && nBytes>=nOld-128 ){ + return pPrior; + } + sqlite3_mutex_enter(mem.mutex); + p = memsys3Malloc(nBytes); + if( p ){ + if( nOld=-1 && size<=1 ){ + fprintf(out, "%p size error\n", &mem.aPool[i]); + assert( 0 ); + break; + } + if( mem.aPool[i+(size<0?-size:size)-1].u.hdr.prevSize!=size ){ + fprintf(out, "%p tail size does not match\n", &mem.aPool[i]); + assert( 0 ); + break; + } + if( size<0 ){ + size = -size; + fprintf(out, "%p %6d bytes checked out\n", &mem.aPool[i], size*8-8); + }else{ + fprintf(out, "%p %6d bytes free%s\n", &mem.aPool[i], size*8-8, + i==mem.iMaster ? " **master**" : ""); + } + } + for(i=0; i0; j=mem.aPool[j].u.list.next){ + fprintf(out, " %p(%d)", &mem.aPool[j], mem.aPool[j-1].u.hdr.size*8-8); + } + fprintf(out, "\n"); + } + for(i=0; i0; j=mem.aPool[j].u.list.next){ + fprintf(out, " %p(%d)", &mem.aPool[j], mem.aPool[j-1].u.hdr.size*8-8); + } + fprintf(out, "\n"); + } + fprintf(out, "master=%d\n", mem.iMaster); + fprintf(out, "nowUsed=%d\n", SQLITE_MEMORY_SIZE - mem.szMaster*8); + fprintf(out, "mxUsed=%d\n", SQLITE_MEMORY_SIZE - mem.mnMaster*8); + sqlite3_mutex_leave(mem.mutex); + if( out==stdout ){ + fflush(stdout); + }else{ + fclose(out); + } +#endif +} + + +#endif /* !SQLITE_MEMORY_SIZE */ diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/mem4.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/mem4.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,398 @@ +/* +** 2007 August 14 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the C functions that implement a memory +** allocation subsystem for use by SQLite. +** +** $Id: mem4.cpp 1282 2008-11-13 09:31:33Z LarsPson $ +*/ + +/* +** This version of the memory allocator attempts to obtain memory +** from mmap() if the size of the allocation is close to the size +** of a virtual memory page. If the size of the allocation is different +** from the virtual memory page size, then ordinary malloc() is used. +** Ordinary malloc is also used if space allocated to mmap() is +** exhausted. +** +** Enable this memory allocation by compiling with -DSQLITE_MMAP_HEAP_SIZE=nnn +** where nnn is the maximum number of bytes of mmap-ed memory you want +** to support. This module may choose to use less memory than requested. +** +*/ +#if defined(SQLITE_MMAP_HEAP_SIZE) + +#if defined(SQLITE_MEMDEBUG) || defined(SQLITE_MEMORY_SIZE) +# error cannot use SQLITE_MMAP_HEAP_SIZE with either SQLITE_MEMDEBUG \ + or SQLITE_MEMORY_SIZE +#endif + +/* +** This is a test version of the memory allocator that attempts to +** use mmap() and madvise() for allocations and frees of approximately +** the virtual memory page size. +*/ +#include +#include +#include +#include "sqliteInt.h" +#include + + +/* +** All of the static variables used by this module are collected +** into a single structure named "mem". This is to keep the +** static variables organized and to reduce namespace pollution +** when this module is combined with other in the amalgamation. +*/ +static struct { + /* + ** The alarm callback and its arguments. The mem.mutex lock will + ** be held while the callback is running. Recursive calls into + ** the memory subsystem are allowed, but no new callbacks will be + ** issued. The alarmBusy variable is set to prevent recursive + ** callbacks. + */ + sqlite3_int64 alarmThreshold; + void (*alarmCallback)(void*, sqlite3_int64,int); + void *alarmArg; + int alarmBusy; + + /* + ** Mutex to control access to the memory allocation subsystem. + */ + sqlite3_mutex *mutex; + + /* + ** Current allocation and high-water mark. + */ + sqlite3_int64 nowUsed; + sqlite3_int64 mxUsed; + + /* + ** Current allocation and high-water marks for mmap allocated memory. + */ + sqlite3_int64 nowUsedMMap; + sqlite3_int64 mxUsedMMap; + + /* + ** Size of a single mmap page. Obtained from sysconf(). + */ + int szPage; + int mnPage; + + /* + ** The number of available mmap pages. + */ + int nPage; + + /* + ** Index of the first free page. 0 means no pages have been freed. + */ + int firstFree; + + /* First unused page on the top of the heap. + */ + int firstUnused; + + /* + ** Bulk memory obtained from from mmap(). + */ + char *mmapHeap; /* first byte of the heap */ + +} mem; + + +/* +** Enter the mutex mem.mutex. Allocate it if it is not already allocated. +** The mmap() region is initialized the first time this routine is called. +*/ +static void memsys4Enter(void){ + if( mem.mutex==0 ){ + mem.mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MEM); + } + sqlite3_mutex_enter(mem.mutex); +} + +/* +** Attempt to free memory to the mmap heap. This only works if +** the pointer p is within the range of memory addresses that +** comprise the mmap heap. Return 1 if the memory was freed +** successfully. Return 0 if the pointer is out of range. +*/ +static int mmapFree(void *p){ + char *z; + int idx, *a; + if( mem.mmapHeap==MAP_FAILED || mem.nPage==0 ){ + return 0; + } + z = (char*)p; + idx = (z - mem.mmapHeap)/mem.szPage; + if( idx<1 || idx>=mem.nPage ){ + return 0; + } + a = (int*)mem.mmapHeap; + a[idx] = a[mem.firstFree]; + mem.firstFree = idx; + mem.nowUsedMMap -= mem.szPage; + madvise(p, mem.szPage, MADV_DONTNEED); + return 1; +} + +/* +** Attempt to allocate nBytes from the mmap heap. Return a pointer +** to the allocated page. Or, return NULL if the allocation fails. +** +** The allocation will fail if nBytes is not the right size. +** Or, the allocation will fail if the mmap heap has been exhausted. +*/ +static void *mmapAlloc(int nBytes){ + int idx = 0; + if( nBytes>mem.szPage || nBytes mem.szPage ){ + mem.nPage = mem.szPage/sizeof(int); + } + mem.mmapHeap = mmap(0, mem.szPage*mem.nPage, PROT_WRITE|PROT_READ, + MAP_ANONYMOUS|MAP_SHARED, -1, 0); + if( mem.mmapHeap==MAP_FAILED ){ + mem.firstUnused = errno; + }else{ + mem.firstUnused = 1; + mem.nowUsedMMap = mem.szPage; + } + } + if( mem.mmapHeap==MAP_FAILED ){ + return 0; + } + if( mem.firstFree ){ + int idx = mem.firstFree; + int *a = (int*)mem.mmapHeap; + mem.firstFree = a[idx]; + }else if( mem.firstUnusedmem.mxUsedMMap ){ + mem.mxUsedMMap = mem.nowUsedMMap; + } + return (void*)&mem.mmapHeap[idx*mem.szPage]; + }else{ + return 0; + } +} + +/* +** Release the mmap-ed memory region if it is currently allocated and +** is not in use. +*/ +static void mmapUnmap(void){ + if( mem.mmapHeap==MAP_FAILED ) return; + if( mem.nPage==0 ) return; + if( mem.nowUsedMMap>mem.szPage ) return; + munmap(mem.mmapHeap, mem.nPage*mem.szPage); + mem.nowUsedMMap = 0; + mem.nPage = 0; +} + + +/* +** Return the amount of memory currently checked out. +*/ +sqlite3_int64 sqlite3_memory_used(void){ + sqlite3_int64 n; + memsys4Enter(); + n = mem.nowUsed + mem.nowUsedMMap; + sqlite3_mutex_leave(mem.mutex); + return n; +} + +/* +** Return the maximum amount of memory that has ever been +** checked out since either the beginning of this process +** or since the most recent reset. +*/ +sqlite3_int64 sqlite3_memory_highwater(int resetFlag){ + sqlite3_int64 n; + memsys4Enter(); + n = mem.mxUsed + mem.mxUsedMMap; + if( resetFlag ){ + mem.mxUsed = mem.nowUsed; + mem.mxUsedMMap = mem.nowUsedMMap; + } + sqlite3_mutex_leave(mem.mutex); + return n; +} + +/* +** Change the alarm callback +*/ +int sqlite3_memory_alarm( + void(*xCallback)(void *pArg, sqlite3_int64 used,int N), + void *pArg, + sqlite3_int64 iThreshold +){ + memsys4Enter(); + mem.alarmCallback = xCallback; + mem.alarmArg = pArg; + mem.alarmThreshold = iThreshold; + sqlite3_mutex_leave(mem.mutex); + return SQLITE_OK; +} + +/* +** Trigger the alarm +*/ +static void sqlite3MemsysAlarm(int nByte){ + void (*xCallback)(void*,sqlite3_int64,int); + sqlite3_int64 nowUsed; + void *pArg; + if( mem.alarmCallback==0 || mem.alarmBusy ) return; + mem.alarmBusy = 1; + xCallback = mem.alarmCallback; + nowUsed = mem.nowUsed; + pArg = mem.alarmArg; + sqlite3_mutex_leave(mem.mutex); + xCallback(pArg, nowUsed, nByte); + sqlite3_mutex_enter(mem.mutex); + mem.alarmBusy = 0; +} + +/* +** Allocate nBytes of memory +*/ +static void *memsys4Malloc(int nBytes){ + sqlite3_int64 *p = 0; + if( mem.alarmCallback!=0 + && mem.nowUsed+mem.nowUsedMMap+nBytes>=mem.alarmThreshold ){ + sqlite3MemsysAlarm(nBytes); + } + if( (p = mmapAlloc(nBytes))==0 ){ + p = malloc(nBytes+8); + if( p==0 ){ + sqlite3MemsysAlarm(nBytes); + p = malloc(nBytes+8); + } + if( p ){ + p[0] = nBytes; + p++; + mem.nowUsed += nBytes; + if( mem.nowUsed>mem.mxUsed ){ + mem.mxUsed = mem.nowUsed; + } + } + } + return (void*)p; +} + +/* +** Return the size of a memory allocation +*/ +static int memsys4Size(void *pPrior){ + char *z = (char*)pPrior; + int idx = mem.nPage ? (z - mem.mmapHeap)/mem.szPage : 0; + int nByte; + if( idx>=1 && idx0 ){ + memsys4Enter(); + p = memsys4Malloc(nBytes); + sqlite3_mutex_leave(mem.mutex); + } + return (void*)p; +} + +/* +** Free memory. +*/ +void sqlite3_free(void *pPrior){ + if( pPrior==0 ){ + return; + } + assert( mem.mutex!=0 ); + sqlite3_mutex_enter(mem.mutex); + memsys4Free(pPrior); + sqlite3_mutex_leave(mem.mutex); +} + + + +/* +** Change the size of an existing memory allocation +*/ +void *sqlite3_realloc(void *pPrior, int nBytes){ + int nOld; + sqlite3_int64 *p; + if( pPrior==0 ){ + return sqlite3_malloc(nBytes); + } + if( nBytes<=0 ){ + sqlite3_free(pPrior); + return 0; + } + nOld = memsys4Size(pPrior); + if( nBytes<=nOld && nBytes>=nOld-128 ){ + return pPrior; + } + assert( mem.mutex!=0 ); + sqlite3_mutex_enter(mem.mutex); + p = memsys4Malloc(nBytes); + if( p ){ + if( nOldid = id; + pNew->cnt = 0; + } + break; + } + default: { + assert( id-2 >= 0 ); + assert( id-2 < sizeof(aStatic)/sizeof(aStatic[0]) ); + pNew = &aStatic[id-2]; + pNew->id = id; + break; + } + } + return pNew; +} + +/* +** This routine deallocates a previously allocated mutex. +*/ +void sqlite3_mutex_free(sqlite3_mutex *p){ + assert( p ); + assert( p->cnt==0 ); + assert( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE ); + sqlite3_free(p); +} + +/* +** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt +** to enter a mutex. If another thread is already within the mutex, +** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return +** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK +** upon successful entry. Mutexes created using SQLITE_MUTEX_RECURSIVE can +** be entered multiple times by the same thread. In such cases the, +** mutex must be exited an equal number of times before another thread +** can enter. If the same thread tries to enter any other kind of mutex +** more than once, the behavior is undefined. +*/ +void sqlite3_mutex_enter(sqlite3_mutex *p){ + assert( p ); + assert( p->id==SQLITE_MUTEX_RECURSIVE || sqlite3_mutex_notheld(p) ); + p->cnt++; +} +int sqlite3_mutex_try(sqlite3_mutex *p){ + assert( p ); + assert( p->id==SQLITE_MUTEX_RECURSIVE || sqlite3_mutex_notheld(p) ); + p->cnt++; + return SQLITE_OK; +} + +/* +** The sqlite3_mutex_leave() routine exits a mutex that was +** previously entered by the same thread. The behavior +** is undefined if the mutex is not currently entered or +** is not currently allocated. SQLite will never do either. +*/ +void sqlite3_mutex_leave(sqlite3_mutex *p){ + assert( p ); + assert( sqlite3_mutex_held(p) ); + p->cnt--; + assert( p->id==SQLITE_MUTEX_RECURSIVE || sqlite3_mutex_notheld(p) ); +} + +/* +** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are +** intended for use inside assert() statements. +*/ +int sqlite3_mutex_held(sqlite3_mutex *p){ + return p==0 || p->cnt>0; +} +int sqlite3_mutex_notheld(sqlite3_mutex *p){ + return p==0 || p->cnt==0; +} +#endif /* SQLITE_MUTEX_NOOP_DEBUG */ diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/mutex.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/mutex.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,82 @@ +/* +** 2007 August 28 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** +** This file contains the common header for all mutex implementations. +** The sqliteInt.h header #includes this file so that it is available +** to all source files. We break it out in an effort to keep the code +** better organized. +** +** NOTE: source files should *not* #include this header file directly. +** Source files should #include the sqliteInt.h file and let that file +** include this one indirectly. +** +** $Id: mutex.h 1282 2008-11-13 09:31:33Z LarsPson $ +*/ + + +#ifdef SQLITE_MUTEX_APPDEF +/* +** If SQLITE_MUTEX_APPDEF is defined, then this whole module is +** omitted and equivalent functionality must be provided by the +** application that links against the SQLite library. +*/ +#else +/* +** Figure out what version of the code to use. The choices are +** +** SQLITE_MUTEX_NOOP For single-threaded applications that +** do not desire error checking. +** +** SQLITE_MUTEX_NOOP_DEBUG For single-threaded applications with +** error checking to help verify that mutexes +** are being used correctly even though they +** are not needed. Used when SQLITE_DEBUG is +** defined on single-threaded builds. +** +** SQLITE_MUTEX_PTHREADS For multi-threaded applications on Unix. +** +** SQLITE_MUTEX_W32 For multi-threaded applications on Win32. +** +** SQLITE_MUTEX_OS2 For multi-threaded applications on OS/2. +*/ +#define SQLITE_MUTEX_NOOP 1 /* The default */ +#if defined(SQLITE_DEBUG) && !SQLITE_THREADSAFE +# undef SQLITE_MUTEX_NOOP +# define SQLITE_MUTEX_NOOP_DEBUG +#endif +#if defined(SQLITE_MUTEX_NOOP) && SQLITE_THREADSAFE && OS_UNIX +# undef SQLITE_MUTEX_NOOP +# define SQLITE_MUTEX_PTHREADS +#endif +#if defined(SQLITE_MUTEX_NOOP) && SQLITE_THREADSAFE && OS_WIN +# undef SQLITE_MUTEX_NOOP +# define SQLITE_MUTEX_W32 +#endif +#if defined(SQLITE_MUTEX_NOOP) && SQLITE_THREADSAFE && OS_OS2 +# undef SQLITE_MUTEX_NOOP +# define SQLITE_MUTEX_OS2 +#endif + +#ifdef SQLITE_MUTEX_NOOP +/* +** If this is a no-op implementation, implement everything as macros. +*/ +#define sqlite3_mutex_alloc(X) ((sqlite3_mutex*)8) +#define sqlite3_mutex_free(X) +#define sqlite3_mutex_enter(X) +#define sqlite3_mutex_try(X) SQLITE_OK +#define sqlite3_mutex_leave(X) +#define sqlite3_mutex_held(X) 1 +#define sqlite3_mutex_notheld(X) 1 +#endif + +#endif /* SQLITE_MUTEX_APPDEF */ diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/opcodes.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/opcodes.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,151 @@ +/* Automatically generated. Do not edit */ +/* See the mkopcodec.awk script for details. */ +//#if !defined(SQLITE_OMIT_EXPLAIN) || !defined(NDEBUG) || defined(VDBE_PROFILE) || defined(SQLITE_DEBUG) +const char *sqlite3OpcodeName(int i){ + static const char *const azName[] = { "?", + /* 1 */ "MemLoad", + /* 2 */ "VNext", + /* 3 */ "Column", + /* 4 */ "SetCookie", + /* 5 */ "IfMemPos", + /* 6 */ "Sequence", + /* 7 */ "MoveGt", + /* 8 */ "RowKey", + /* 9 */ "OpenWrite", + /* 10 */ "If", + /* 11 */ "Pop", + /* 12 */ "VRowid", + /* 13 */ "CollSeq", + /* 14 */ "OpenRead", + /* 15 */ "Expire", + /* 16 */ "Not", + /* 17 */ "AutoCommit", + /* 18 */ "IntegrityCk", + /* 19 */ "Sort", + /* 20 */ "Function", + /* 21 */ "Noop", + /* 22 */ "Return", + /* 23 */ "NewRowid", + /* 24 */ "IfMemNeg", + /* 25 */ "Variable", + /* 26 */ "String", + /* 27 */ "RealAffinity", + /* 28 */ "VRename", + /* 29 */ "ParseSchema", + /* 30 */ "VOpen", + /* 31 */ "Close", + /* 32 */ "CreateIndex", + /* 33 */ "IsUnique", + /* 34 */ "NotFound", + /* 35 */ "Int64", + /* 36 */ "MustBeInt", + /* 37 */ "Halt", + /* 38 */ "Rowid", + /* 39 */ "IdxLT", + /* 40 */ "AddImm", + /* 41 */ "Statement", + /* 42 */ "RowData", + /* 43 */ "MemMax", + /* 44 */ "Push", + /* 45 */ "NotExists", + /* 46 */ "MemIncr", + /* 47 */ "Gosub", + /* 48 */ "Integer", + /* 49 */ "MemInt", + /* 50 */ "Prev", + /* 51 */ "VColumn", + /* 52 */ "CreateTable", + /* 53 */ "Last", + /* 54 */ "IncrVacuum", + /* 55 */ "IdxRowid", + /* 56 */ "MakeIdxRec", + /* 57 */ "ResetCount", + /* 58 */ "FifoWrite", + /* 59 */ "Callback", + /* 60 */ "Or", + /* 61 */ "And", + /* 62 */ "ContextPush", + /* 63 */ "DropTrigger", + /* 64 */ "DropIndex", + /* 65 */ "IsNull", + /* 66 */ "NotNull", + /* 67 */ "Ne", + /* 68 */ "Eq", + /* 69 */ "Gt", + /* 70 */ "Le", + /* 71 */ "Lt", + /* 72 */ "Ge", + /* 73 */ "IdxGE", + /* 74 */ "BitAnd", + /* 75 */ "BitOr", + /* 76 */ "ShiftLeft", + /* 77 */ "ShiftRight", + /* 78 */ "Add", + /* 79 */ "Subtract", + /* 80 */ "Multiply", + /* 81 */ "Divide", + /* 82 */ "Remainder", + /* 83 */ "Concat", + /* 84 */ "IdxDelete", + /* 85 */ "Negative", + /* 86 */ "Vacuum", + /* 87 */ "BitNot", + /* 88 */ "String8", + /* 89 */ "MoveLe", + /* 90 */ "IfNot", + /* 91 */ "DropTable", + /* 92 */ "MakeRecord", + /* 93 */ "Delete", + /* 94 */ "StackDepth", + /* 95 */ "AggFinal", + /* 96 */ "Dup", + /* 97 */ "Goto", + /* 98 */ "TableLock", + /* 99 */ "FifoRead", + /* 100 */ "Clear", + /* 101 */ "IdxGT", + /* 102 */ "MoveLt", + /* 103 */ "VerifyCookie", + /* 104 */ "AggStep", + /* 105 */ "Pull", + /* 106 */ "SetNumColumns", + /* 107 */ "AbsValue", + /* 108 */ "Transaction", + /* 109 */ "VFilter", + /* 110 */ "VDestroy", + /* 111 */ "ContextPop", + /* 112 */ "Next", + /* 113 */ "IdxInsert", + /* 114 */ "Distinct", + /* 115 */ "Insert", + /* 116 */ "Destroy", + /* 117 */ "ReadCookie", + /* 118 */ "ForceInt", + /* 119 */ "LoadAnalysis", + /* 120 */ "Explain", + /* 121 */ "IfMemZero", + /* 122 */ "OpenPseudo", + /* 123 */ "OpenEphemeral", + /* 124 */ "Null", + /* 125 */ "Real", + /* 126 */ "HexBlob", + /* 127 */ "Blob", + /* 128 */ "MemStore", + /* 129 */ "Rewind", + /* 130 */ "MoveGe", + /* 131 */ "VBegin", + /* 132 */ "VUpdate", + /* 133 */ "VCreate", + /* 134 */ "MemMove", + /* 135 */ "MemNull", + /* 136 */ "Found", + /* 137 */ "NullRow", + /* 138 */ "ToText", + /* 139 */ "ToBlob", + /* 140 */ "ToNumeric", + /* 141 */ "ToInt", + /* 142 */ "ToReal", + }; + return azName[i]; +} +//#endif diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/opcodes.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/opcodes.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,158 @@ +/* Automatically generated. Do not edit */ +/* See the mkopcodeh.awk script for details */ +#define OP_MemLoad 1 +#define OP_VNext 2 +#define OP_HexBlob 126 /* same as TK_BLOB */ +#define OP_Column 3 +#define OP_SetCookie 4 +#define OP_IfMemPos 5 +#define OP_Real 125 /* same as TK_FLOAT */ +#define OP_Sequence 6 +#define OP_MoveGt 7 +#define OP_Ge 72 /* same as TK_GE */ +#define OP_RowKey 8 +#define OP_Eq 68 /* same as TK_EQ */ +#define OP_OpenWrite 9 +#define OP_NotNull 66 /* same as TK_NOTNULL */ +#define OP_If 10 +#define OP_ToInt 141 /* same as TK_TO_INT */ +#define OP_String8 88 /* same as TK_STRING */ +#define OP_Pop 11 +#define OP_VRowid 12 +#define OP_CollSeq 13 +#define OP_OpenRead 14 +#define OP_Expire 15 +#define OP_AutoCommit 17 +#define OP_Gt 69 /* same as TK_GT */ +#define OP_IntegrityCk 18 +#define OP_Sort 19 +#define OP_Function 20 +#define OP_And 61 /* same as TK_AND */ +#define OP_Subtract 79 /* same as TK_MINUS */ +#define OP_Noop 21 +#define OP_Return 22 +#define OP_Remainder 82 /* same as TK_REM */ +#define OP_NewRowid 23 +#define OP_Multiply 80 /* same as TK_STAR */ +#define OP_IfMemNeg 24 +#define OP_Variable 25 +#define OP_String 26 +#define OP_RealAffinity 27 +#define OP_VRename 28 +#define OP_ParseSchema 29 +#define OP_VOpen 30 +#define OP_Close 31 +#define OP_CreateIndex 32 +#define OP_IsUnique 33 +#define OP_NotFound 34 +#define OP_Int64 35 +#define OP_MustBeInt 36 +#define OP_Halt 37 +#define OP_Rowid 38 +#define OP_IdxLT 39 +#define OP_AddImm 40 +#define OP_Statement 41 +#define OP_RowData 42 +#define OP_MemMax 43 +#define OP_Push 44 +#define OP_Or 60 /* same as TK_OR */ +#define OP_NotExists 45 +#define OP_MemIncr 46 +#define OP_Gosub 47 +#define OP_Divide 81 /* same as TK_SLASH */ +#define OP_Integer 48 +#define OP_ToNumeric 140 /* same as TK_TO_NUMERIC*/ +#define OP_MemInt 49 +#define OP_Prev 50 +#define OP_Concat 83 /* same as TK_CONCAT */ +#define OP_BitAnd 74 /* same as TK_BITAND */ +#define OP_VColumn 51 +#define OP_CreateTable 52 +#define OP_Last 53 +#define OP_IsNull 65 /* same as TK_ISNULL */ +#define OP_IncrVacuum 54 +#define OP_IdxRowid 55 +#define OP_MakeIdxRec 56 +#define OP_ShiftRight 77 /* same as TK_RSHIFT */ +#define OP_ResetCount 57 +#define OP_FifoWrite 58 +#define OP_Callback 59 +#define OP_ContextPush 62 +#define OP_DropTrigger 63 +#define OP_DropIndex 64 +#define OP_IdxGE 73 +#define OP_IdxDelete 84 +#define OP_Vacuum 86 +#define OP_MoveLe 89 +#define OP_IfNot 90 +#define OP_DropTable 91 +#define OP_MakeRecord 92 +#define OP_ToBlob 139 /* same as TK_TO_BLOB */ +#define OP_Delete 93 +#define OP_StackDepth 94 +#define OP_AggFinal 95 +#define OP_ShiftLeft 76 /* same as TK_LSHIFT */ +#define OP_Dup 96 +#define OP_Goto 97 +#define OP_TableLock 98 +#define OP_FifoRead 99 +#define OP_Clear 100 +#define OP_IdxGT 101 +#define OP_MoveLt 102 +#define OP_Le 70 /* same as TK_LE */ +#define OP_VerifyCookie 103 +#define OP_AggStep 104 +#define OP_Pull 105 +#define OP_ToText 138 /* same as TK_TO_TEXT */ +#define OP_Not 16 /* same as TK_NOT */ +#define OP_ToReal 142 /* same as TK_TO_REAL */ +#define OP_SetNumColumns 106 +#define OP_AbsValue 107 +#define OP_Transaction 108 +#define OP_VFilter 109 +#define OP_Negative 85 /* same as TK_UMINUS */ +#define OP_Ne 67 /* same as TK_NE */ +#define OP_VDestroy 110 +#define OP_ContextPop 111 +#define OP_BitOr 75 /* same as TK_BITOR */ +#define OP_Next 112 +#define OP_IdxInsert 113 +#define OP_Distinct 114 +#define OP_Lt 71 /* same as TK_LT */ +#define OP_Insert 115 +#define OP_Destroy 116 +#define OP_ReadCookie 117 +#define OP_ForceInt 118 +#define OP_LoadAnalysis 119 +#define OP_Explain 120 +#define OP_IfMemZero 121 +#define OP_OpenPseudo 122 +#define OP_OpenEphemeral 123 +#define OP_Null 124 +#define OP_Blob 127 +#define OP_Add 78 /* same as TK_PLUS */ +#define OP_MemStore 128 +#define OP_Rewind 129 +#define OP_MoveGe 130 +#define OP_VBegin 131 +#define OP_VUpdate 132 +#define OP_BitNot 87 /* same as TK_BITNOT */ +#define OP_VCreate 133 +#define OP_MemMove 134 +#define OP_MemNull 135 +#define OP_Found 136 +#define OP_NullRow 137 + +/* Opcodes that are guaranteed to never push a value onto the stack +** contain a 1 their corresponding position of the following mask +** set. See the opcodeNoPush() function in vdbeaux.c */ +#define NOPUSH_MASK_0 0xeeb4 +#define NOPUSH_MASK_1 0xf96b +#define NOPUSH_MASK_2 0xfbb6 +#define NOPUSH_MASK_3 0xfe64 +#define NOPUSH_MASK_4 0xffff +#define NOPUSH_MASK_5 0xeef7 +#define NOPUSH_MASK_6 0xf7f6 +#define NOPUSH_MASK_7 0x0ecf +#define NOPUSH_MASK_8 0x7f3f +#define NOPUSH_MASK_9 0x0000 diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/os.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/os.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,305 @@ + /* +** 2005 November 29 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains OS interface code that is common to all +** architectures. +*/ +#define _SQLITE_OS_C_ 1 +#include "sqliteInt.h" +#undef _SQLITE_OS_C_ + +/* +** The default SQLite sqlite3_vfs implementations do not allocate +** memory (actually, os_unix.c allocates a small amount of memory +** from within OsOpen()), but some third-party implementations may. +** So we test the effects of a malloc() failing and the sqlite3OsXXX() +** function returning SQLITE_IOERR_NOMEM using the DO_OS_MALLOC_TEST macro. +** +** The following functions are instrumented for malloc() failure +** testing: +** +** sqlite3OsOpen() +** sqlite3OsRead() +** sqlite3OsWrite() +** sqlite3OsSync() +** sqlite3OsLock() +** +*/ +#ifdef SQLITE_TEST + #define DO_OS_MALLOC_TEST if (1) { \ + void *pTstAlloc = sqlite3_malloc(10); \ + if (!pTstAlloc) return SQLITE_IOERR_NOMEM; \ + sqlite3_free(pTstAlloc); \ + } +#else + #define DO_OS_MALLOC_TEST +#endif + +/* +** The following routines are convenience wrappers around methods +** of the sqlite3_file object. This is mostly just syntactic sugar. All +** of this would be completely automatic if SQLite were coded using +** C++ instead of plain old C. +*/ +int sqlite3OsClose(sqlite3_file *pId){ + int rc = SQLITE_OK; +/* if( pId->pMethods ){ + rc = pId->pMethods->xClose(pId); + pId->pMethods = 0; + }*/ + rc = winClose(pId); + return rc; +} +int sqlite3OsRead(sqlite3_file *id, void *pBuf, int amt, i64 offset){ + DO_OS_MALLOC_TEST; + //return id->pMethods->xRead(id, pBuf, amt, offset); + return winRead(id, pBuf, amt, offset); +} +int sqlite3OsWrite(sqlite3_file *id, const void *pBuf, int amt, i64 offset){ + DO_OS_MALLOC_TEST; + //return id->pMethods->xWrite(id, pBuf, amt, offset); + return winWrite(id, pBuf, amt, offset); +} +int sqlite3OsTruncate(sqlite3_file *id, i64 size){ + //return id->pMethods->xTruncate(id, size); + return winTruncate(id, size); +} +int sqlite3OsSync(sqlite3_file *id, int flags){ + DO_OS_MALLOC_TEST; +// return id->pMethods->xSync(id, flags); + return winSync(id, flags); +} +int sqlite3OsFileSize(sqlite3_file *id, i64 *pSize){ +// return id->pMethods->xFileSize(id, pSize); + return winFileSize(id, pSize); +} +int sqlite3OsLock(sqlite3_file *id, int lockType){ + DO_OS_MALLOC_TEST; + //return id->pMethods->xLock(id, lockType); + return winLock(id, lockType); +} +int sqlite3OsUnlock(sqlite3_file *id, int lockType){ + //return id->pMethods->xUnlock(id, lockType); + return winUnlock(id, lockType); +} +int sqlite3OsCheckReservedLock(sqlite3_file *id){ + //return id->pMethods->xCheckReservedLock(id); + return winCheckReservedLock(id); +} +int sqlite3OsFileControl(sqlite3_file *id, int op, void *pArg){ + //return id->pMethods->xFileControl(id,op,pArg); + return winFileControl(id, op, pArg); +} + +#ifdef SQLITE_TEST + /* The following two variables are used to override the values returned + ** by the xSectorSize() and xDeviceCharacteristics() vfs methods for + ** testing purposes. They are usually set by a test command implemented + ** in test6.c. + */ + int sqlite3_test_sector_size = 0; + int sqlite3_test_device_characteristics = 0; + int sqlite3OsDeviceCharacteristics(sqlite3_file *id){ + int dc = id->pMethods->xDeviceCharacteristics(id); + return dc | sqlite3_test_device_characteristics; + } + int sqlite3OsSectorSize(sqlite3_file *id){ + if( sqlite3_test_sector_size==0 ){ + int (*xSectorSize)(sqlite3_file*) = id->pMethods->xSectorSize; + return (xSectorSize ? xSectorSize(id) : SQLITE_DEFAULT_SECTOR_SIZE); + } + return sqlite3_test_sector_size; + } +#else + int sqlite3OsSectorSize(sqlite3_file *id){ + //int (*xSectorSize)(sqlite3_file*) = id->pMethods->xSectorSize; + //return (xSectorSize ? xSectorSize(id) : SQLITE_DEFAULT_SECTOR_SIZE); + return winSectorSize(id); + } + int sqlite3OsDeviceCharacteristics(sqlite3_file *id){ +// return id->pMethods->xDeviceCharacteristics(id); + return winDeviceCharacteristics(id); + } +#endif + +/* +** The next group of routines are convenience wrappers around the +** VFS methods. +*/ +int sqlite3OsOpen( + sqlite3_vfs *pVfs, + const char *zPath, + sqlite3_file *pFile, + int flags, + int *pFlagsOut +){ + //return pVfs->xOpen(pVfs, zPath, pFile, flags, pFlagsOut); + return winOpen(pVfs, zPath, pFile, flags, pFlagsOut); +} +int sqlite3OsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){ + //return pVfs->xDelete(pVfs, zPath, dirSync); + return winDelete(pVfs, zPath, dirSync); +} +int sqlite3OsAccess(sqlite3_vfs *pVfs, const char *zPath, int flags){ +// return pVfs->xAccess(pVfs, zPath, flags); + return winAccess(pVfs, zPath, flags); +} +int sqlite3OsGetTempname(sqlite3_vfs *pVfs, int nBufOut, char *zBufOut){ +// return pVfs->xGetTempname(pVfs, nBufOut, zBufOut); + return winGetTempname(pVfs, nBufOut, zBufOut); +} +int sqlite3OsFullPathname( + sqlite3_vfs *pVfs, + const char *zPath, + int nPathOut, + char *zPathOut +){ +// return pVfs->xFullPathname(pVfs, zPath, nPathOut, zPathOut); + return winFullPathname(pVfs, zPath, nPathOut, zPathOut); +} +void *sqlite3OsDlOpen(sqlite3_vfs *pVfs, const char *zPath){ +// return pVfs->xDlOpen(pVfs, zPath); + return NULL; +} +void sqlite3OsDlError(sqlite3_vfs *pVfs, int nByte, char *zBufOut){ +// pVfs->xDlError(pVfs, nByte, zBufOut); + +} +void *sqlite3OsDlSym(sqlite3_vfs *pVfs, void *pHandle, const char *zSymbol){ +// return pVfs->xDlSym(pVfs, pHandle, zSymbol); + return NULL; +} +void sqlite3OsDlClose(sqlite3_vfs *pVfs, void *pHandle){ +// pVfs->xDlClose(pVfs, pHandle); +} +int sqlite3OsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){ +// return pVfs->xRandomness(pVfs, nByte, zBufOut); + return winRandomness(pVfs, nByte, zBufOut); +} +int sqlite3OsSleep(sqlite3_vfs *pVfs, int nMicro){ +// return pVfs->xSleep(pVfs, nMicro); + return winSleep(pVfs, nMicro); +} +int sqlite3OsCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){ +// return pVfs->xCurrentTime(pVfs, pTimeOut); + return winCurrentTime(pVfs, pTimeOut); +} + +int sqlite3OsOpenMalloc( + sqlite3_vfs *pVfs, + const char *zFile, + sqlite3_file **ppFile, + int flags, + int *pOutFlags +){ + int rc = SQLITE_NOMEM; + sqlite3_file *pFile; + pFile = (sqlite3_file *)sqlite3_malloc(pVfs->szOsFile); + if( pFile ){ + rc = sqlite3OsOpen(pVfs, zFile, pFile, flags, pOutFlags); + if( rc!=SQLITE_OK ){ + sqlite3_free(pFile); + }else{ + *ppFile = pFile; + } + } + return rc; +} +int sqlite3OsCloseFree(sqlite3_file *pFile){ + int rc = SQLITE_OK; + if( pFile ){ + rc = sqlite3OsClose(pFile); + sqlite3_free(pFile); + } + return rc; +} + +/* +** The list of all registered VFS implementations. This list is +** initialized to the single VFS returned by sqlite3OsDefaultVfs() +** upon the first call to sqlite3_vfs_find(). +*/ +static sqlite3_vfs *vfsList = 0; + +/* +** Locate a VFS by name. If no name is given, simply return the +** first VFS on the list. +*/ +EXPORT_C sqlite3_vfs *sqlite3_vfs_find(const char *zVfs){ + sqlite3_mutex *mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER); + sqlite3_vfs *pVfs = 0; + static int isInit = 0; + sqlite3_mutex_enter(mutex); + if( !isInit ){ + vfsList = sqlite3OsDefaultVfs(); + isInit = 1; + } + for(pVfs = vfsList; pVfs; pVfs=pVfs->pNext){ + if( zVfs==0 ) break; + if( strcmp(zVfs, pVfs->zName)==0 ) break; + } + sqlite3_mutex_leave(mutex); + return pVfs; +} + +/* +** Unlink a VFS from the linked list +*/ +static void vfsUnlink(sqlite3_vfs *pVfs){ + assert( sqlite3_mutex_held(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER)) ); + if( pVfs==0 ){ + /* No-op */ + }else if( vfsList==pVfs ){ + vfsList = pVfs->pNext; + }else if( vfsList ){ + sqlite3_vfs *p = vfsList; + while( p->pNext && p->pNext!=pVfs ){ + p = p->pNext; + } + if( p->pNext==pVfs ){ + p->pNext = pVfs->pNext; + } + } +} + +/* +** Register a VFS with the system. It is harmless to register the same +** VFS multiple times. The new VFS becomes the default if makeDflt is +** true. +*/ +EXPORT_C int sqlite3_vfs_register(sqlite3_vfs *pVfs, int makeDflt){ + sqlite3_mutex *mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER); + sqlite3_vfs_find(0); /* Make sure we are initialized */ + sqlite3_mutex_enter(mutex); + vfsUnlink(pVfs); + if( makeDflt || vfsList==0 ){ + pVfs->pNext = vfsList; + vfsList = pVfs; + }else{ + pVfs->pNext = vfsList->pNext; + vfsList->pNext = pVfs; + } + assert(vfsList); + sqlite3_mutex_leave(mutex); + return SQLITE_OK; +} + +/* +** Unregister a VFS so that it is no longer accessible. +*/ +EXPORT_C int sqlite3_vfs_unregister(sqlite3_vfs *pVfs){ + sqlite3_mutex *mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER); + sqlite3_mutex_enter(mutex); + vfsUnlink(pVfs); + sqlite3_mutex_leave(mutex); + return SQLITE_OK; +} diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/os.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/os.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,359 @@ +/* +** 2001 September 16 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This header file (together with is companion C source-code file +** "os.c") attempt to abstract the underlying operating system so that +** the SQLite library will work on both POSIX and windows systems. +** +** This header file is #include-ed by sqliteInt.h and thus ends up +** being included by every source file. +*/ +#ifndef _SQLITE_OS_H_ +#define _SQLITE_OS_H_ + +/* +** Figure out if we are dealing with Unix, Windows, or some other +** operating system. After the following block of preprocess macros, +** all of OS_UNIX, OS_WIN, OS_OS2, and OS_OTHER will defined to either +** 1 or 0. One of the four will be 1. The other three will be 0. +*/ + +#if defined(OS_OTHER) + +# if OS_OTHER==1 +# undef OS_UNIX +# define OS_UNIX 0 +# undef OS_WIN +# define OS_WIN 0 +# undef OS_OS2 +# define OS_OS2 0 +# else +# undef OS_OTHER +# endif +#endif +#if !defined(OS_UNIX) && !defined(OS_OTHER) && !defined(OS_SYMBIAN) +# define OS_OTHER 0 +# ifndef OS_WIN +# if defined(_WIN32) || defined(WIN32) || defined(__CYGWIN__) || defined(__MINGW32__) || defined(__BORLANDC__) +# define OS_WIN 1 +# define OS_UNIX 0 +# define OS_OS2 0 +# elif defined(__EMX__) || defined(_OS2) || defined(OS2) || defined(_OS2_) || defined(__OS2__) +# define OS_WIN 0 +# define OS_UNIX 0 +# define OS_OS2 1 +# else +# define OS_WIN 0 +# define OS_UNIX 1 +# define OS_OS2 0 +# endif +# else +# define OS_UNIX 0 +# define OS_OS2 0 +# endif +#else +# ifndef OS_WIN +# define OS_WIN 0 +# endif +#endif + +#ifdef OS_SYMBIAN +# define SQLITE_TEMPNAME_SIZE (MAX_PATH+50) +#endif + + +/* +** Define the maximum size of a temporary filename +*/ +#if OS_WIN +# include +# define SQLITE_TEMPNAME_SIZE (MAX_PATH+50) +#elif OS_OS2 +# if (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ >= 3) && defined(OS2_HIGH_MEMORY) +# include /* has to be included before os2.h for linking to work */ +# endif +# define INCL_DOSDATETIME +# define INCL_DOSFILEMGR +# define INCL_DOSERRORS +# define INCL_DOSMISC +# define INCL_DOSPROCESS +# define INCL_DOSMODULEMGR +# define INCL_DOSSEMAPHORES +# include +# define SQLITE_TEMPNAME_SIZE (CCHMAXPATHCOMP) +#else +#ifndef SQLITE_TEMPNAME_SIZE + # define SQLITE_TEMPNAME_SIZE 200 +#endif +#endif + +/* If the SET_FULLSYNC macro is not defined above, then make it +** a no-op +*/ +#ifndef SET_FULLSYNC +# define SET_FULLSYNC(x,y) +#endif + +/* +** The default size of a disk sector +*/ +#ifndef SQLITE_DEFAULT_SECTOR_SIZE +# define SQLITE_DEFAULT_SECTOR_SIZE 512 +#endif + +/* +** Temporary files are named starting with this prefix followed by 16 random +** alphanumeric characters, and no file extension. They are stored in the +** OS's standard temporary file directory, and are deleted prior to exit. +** If sqlite is being embedded in another program, you may wish to change the +** prefix to reflect your program's name, so that if your program exits +** prematurely, old temporary files can be easily identified. This can be done +** using -DSQLITE_TEMP_FILE_PREFIX=myprefix_ on the compiler command line. +** +** 2006-10-31: The default prefix used to be "sqlite_". But then +** Mcafee started using SQLite in their anti-virus product and it +** started putting files with the "sqlite" name in the c:/temp folder. +** This annoyed many windows users. Those users would then do a +** Google search for "sqlite", find the telephone numbers of the +** developers and call to wake them up at night and complain. +** For this reason, the default name prefix is changed to be "sqlite" +** spelled backwards. So the temp files are still identified, but +** anybody smart enough to figure out the code is also likely smart +** enough to know that calling the developer will not help get rid +** of the file. +*/ +#ifndef SQLITE_TEMP_FILE_PREFIX +# define SQLITE_TEMP_FILE_PREFIX "etilqs_" +#endif + +/* +** The following values may be passed as the second argument to +** sqlite3OsLock(). The various locks exhibit the following semantics: +** +** SHARED: Any number of processes may hold a SHARED lock simultaneously. +** RESERVED: A single process may hold a RESERVED lock on a file at +** any time. Other processes may hold and obtain new SHARED locks. +** PENDING: A single process may hold a PENDING lock on a file at +** any one time. Existing SHARED locks may persist, but no new +** SHARED locks may be obtained by other processes. +** EXCLUSIVE: An EXCLUSIVE lock precludes all other locks. +** +** PENDING_LOCK may not be passed directly to sqlite3OsLock(). Instead, a +** process that requests an EXCLUSIVE lock may actually obtain a PENDING +** lock. This can be upgraded to an EXCLUSIVE lock by a subsequent call to +** sqlite3OsLock(). +*/ +#define NO_LOCK 0 +#define SHARED_LOCK 1 +#define RESERVED_LOCK 2 +#define PENDING_LOCK 3 +#define EXCLUSIVE_LOCK 4 + +/* +** File Locking Notes: (Mostly about windows but also some info for Unix) +** +** We cannot use LockFileEx() or UnlockFileEx() on Win95/98/ME because +** those functions are not available. So we use only LockFile() and +** UnlockFile(). +** +** LockFile() prevents not just writing but also reading by other processes. +** A SHARED_LOCK is obtained by locking a single randomly-chosen +** byte out of a specific range of bytes. The lock byte is obtained at +** random so two separate readers can probably access the file at the +** same time, unless they are unlucky and choose the same lock byte. +** An EXCLUSIVE_LOCK is obtained by locking all bytes in the range. +** There can only be one writer. A RESERVED_LOCK is obtained by locking +** a single byte of the file that is designated as the reserved lock byte. +** A PENDING_LOCK is obtained by locking a designated byte different from +** the RESERVED_LOCK byte. +** +** On WinNT/2K/XP systems, LockFileEx() and UnlockFileEx() are available, +** which means we can use reader/writer locks. When reader/writer locks +** are used, the lock is placed on the same range of bytes that is used +** for probabilistic locking in Win95/98/ME. Hence, the locking scheme +** will support two or more Win95 readers or two or more WinNT readers. +** But a single Win95 reader will lock out all WinNT readers and a single +** WinNT reader will lock out all other Win95 readers. +** +** The following #defines specify the range of bytes used for locking. +** SHARED_SIZE is the number of bytes available in the pool from which +** a random byte is selected for a shared lock. The pool of bytes for +** shared locks begins at SHARED_FIRST. +** +** These #defines are available in sqlite_aux.h so that adaptors for +** connecting SQLite to other operating systems can use the same byte +** ranges for locking. In particular, the same locking strategy and +** byte ranges are used for Unix. This leaves open the possiblity of having +** clients on win95, winNT, and unix all talking to the same shared file +** and all locking correctly. To do so would require that samba (or whatever +** tool is being used for file sharing) implements locks correctly between +** windows and unix. I'm guessing that isn't likely to happen, but by +** using the same locking range we are at least open to the possibility. +** +** Locking in windows is manditory. For this reason, we cannot store +** actual data in the bytes used for locking. The pager never allocates +** the pages involved in locking therefore. SHARED_SIZE is selected so +** that all locks will fit on a single page even at the minimum page size. +** PENDING_BYTE defines the beginning of the locks. By default PENDING_BYTE +** is set high so that we don't have to allocate an unused page except +** for very large databases. But one should test the page skipping logic +** by setting PENDING_BYTE low and running the entire regression suite. +** +** Changing the value of PENDING_BYTE results in a subtly incompatible +** file format. Depending on how it is changed, you might not notice +** the incompatibility right away, even running a full regression test. +** The default location of PENDING_BYTE is the first byte past the +** 1GB boundary. +** +*/ +#ifndef SQLITE_TEST +#define PENDING_BYTE 0x40000000 /* First byte past the 1GB boundary */ +#else +extern unsigned int sqlite3_pending_byte; +#define PENDING_BYTE sqlite3_pending_byte +#endif + +#define RESERVED_BYTE (PENDING_BYTE+1) +#define SHARED_FIRST (PENDING_BYTE+2) +#define SHARED_SIZE 510 + +/* +** Functions for accessing sqlite3_file methods +*/ +int sqlite3OsClose(sqlite3_file*); +int sqlite3OsRead(sqlite3_file*, void*, int amt, i64 offset); +int sqlite3OsWrite(sqlite3_file*, const void*, int amt, i64 offset); +int sqlite3OsTruncate(sqlite3_file*, i64 size); +int sqlite3OsSync(sqlite3_file*, int); +int sqlite3OsFileSize(sqlite3_file*, i64 *pSize); +int sqlite3OsLock(sqlite3_file*, int); +int sqlite3OsUnlock(sqlite3_file*, int); +int sqlite3OsCheckReservedLock(sqlite3_file *id); +int sqlite3OsFileControl(sqlite3_file*,int,void*); +int sqlite3OsSectorSize(sqlite3_file *id); +int sqlite3OsDeviceCharacteristics(sqlite3_file *id); + +/* +** Functions for accessing sqlite3_vfs methods +*/ +int sqlite3OsOpen(sqlite3_vfs *, const char *, sqlite3_file*, int, int *); +int sqlite3OsDelete(sqlite3_vfs *, const char *, int); +int sqlite3OsAccess(sqlite3_vfs *, const char *, int); +int sqlite3OsGetTempname(sqlite3_vfs *, int, char *); +int sqlite3OsFullPathname(sqlite3_vfs *, const char *, int, char *); +void *sqlite3OsDlOpen(sqlite3_vfs *, const char *); +void sqlite3OsDlError(sqlite3_vfs *, int, char *); +void *sqlite3OsDlSym(sqlite3_vfs *, void *, const char *); +void sqlite3OsDlClose(sqlite3_vfs *, void *); +int sqlite3OsRandomness(sqlite3_vfs *, int, char *); +int sqlite3OsSleep(sqlite3_vfs *, int); +int sqlite3OsCurrentTime(sqlite3_vfs *, double*); + +/* +** Convenience functions for opening and closing files using +** sqlite3_malloc() to obtain space for the file-handle structure. +*/ +int sqlite3OsOpenMalloc(sqlite3_vfs *, const char *, sqlite3_file **, int,int*); +int sqlite3OsCloseFree(sqlite3_file *); + +/* +** Each OS-specific backend defines an instance of the following +** structure for returning a pointer to its sqlite3_vfs. If OS_OTHER +** is defined (meaning that the application-defined OS interface layer +** is used) then there is no default VFS. The application must +** register one or more VFS structures using sqlite3_vfs_register() +** before attempting to use SQLite. +*/ +#if OS_UNIX || OS_WIN || OS_OS2 || OS_SYMBIAN +sqlite3_vfs *sqlite3OsDefaultVfs(void); +#else +# define sqlite3OsDefaultVfs(X) 0 +#endif + + int winDelete( + sqlite3_vfs *pVfs, /* Not used on win32 */ + const char *zFilename, /* Name of file to delete */ + int syncDir /* Not used on win32 */ +); + + int winAccess( + sqlite3_vfs *pVfs, /* Not used on win32 */ + const char *zFilename, /* Name of file to check */ + int flags /* Type of test to make on this file */ +); + + int winGetTempname(sqlite3_vfs *pVfs, int nBuf, char *zBuf); + + int winFullPathname( + sqlite3_vfs *pVfs, /* Pointer to vfs object */ + const char *zRelative, /* Possibly relative input path */ + int nFull, /* Size of output buffer in bytes */ + char *zFull /* Output buffer */ +); + + int winRandomness(sqlite3_vfs *pVfs, int nBuf, char *zBuf); + + int winClose(sqlite3_file *id); + + int winRead( + sqlite3_file *id, /* File to read from */ + void *pBuf, /* Write content into this buffer */ + int amt, /* Number of bytes to read */ + sqlite3_int64 offset /* Begin reading at this offset */ +); + + int winWrite( + sqlite3_file *id, /* File to write into */ + const void *pBuf, /* The bytes to be written */ + int amt, /* Number of bytes to write */ + sqlite3_int64 offset /* Offset into the file to begin writing at */ +); + + int winTruncate(sqlite3_file *id, sqlite3_int64 nByte); + + int winSync(sqlite3_file *id, int flags); + + int symbianFileSize(sqlite3_file *id, sqlite3_int64 *pSize); + + int winLock(sqlite3_file *id, int locktype); + + int winCheckReservedLock(sqlite3_file *id); + + int winUnlock(sqlite3_file *id, int locktype); + + int symbianFileControl(sqlite3_file *id, int op, void *pArg); + + int winSectorSize(sqlite3_file *id); + + int winDeviceCharacteristics(sqlite3_file *id); + + int winOpen( + sqlite3_vfs *pVfs, /* Not used */ + const char *zName, /* Name of the file (UTF-8) */ + sqlite3_file *id, /* Write the SQLite file handle here */ + int flags, /* Open mode flags */ + int *pOutFlags /* Status return flags */ +); + int winFullPathname( + sqlite3_vfs *pVfs, /* Pointer to vfs object */ + const char *zRelative, /* Possibly relative input path */ + int nFull, /* Size of output buffer in bytes */ + char *zFull /* Output buffer */ +); + int winSleep(sqlite3_vfs *pVfs, int microsec); + int winCurrentTime(sqlite3_vfs *pVfs, double *prNow); + + int winFileSize(sqlite3_file *id, sqlite3_int64 *pSize); + + int winFileControl(sqlite3_file *id, int op, void *pArg); + +#endif /* _SQLITE_OS_H_ */ diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/os_common.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/os_common.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,127 @@ +/* +** 2004 May 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains macros and a little bit of code that is common to +** all of the platform-specific files (os_*.c) and is #included into those +** files. +** +** This file should be #included by the os_*.c files only. It is not a +** general purpose header file. +*/ + +/* +** At least two bugs have slipped in because we changed the MEMORY_DEBUG +** macro to SQLITE_DEBUG and some older makefiles have not yet made the +** switch. The following code should catch this problem at compile-time. +*/ +#ifdef MEMORY_DEBUG +# error "The MEMORY_DEBUG macro is obsolete. Use SQLITE_DEBUG instead." +#endif + + +/* + * When testing, this global variable stores the location of the + * pending-byte in the database file. + */ +#ifdef SQLITE_TEST +unsigned int sqlite3_pending_byte = 0x40000000; +#endif + +#ifdef SQLITE_DEBUG +int sqlite3_os_trace = 0; +#define OSTRACE1(X) if( sqlite3_os_trace ) sqlite3DebugPrintf(X) +#define OSTRACE2(X,Y) if( sqlite3_os_trace ) sqlite3DebugPrintf(X,Y) +#define OSTRACE3(X,Y,Z) if( sqlite3_os_trace ) sqlite3DebugPrintf(X,Y,Z) +#define OSTRACE4(X,Y,Z,A) if( sqlite3_os_trace ) sqlite3DebugPrintf(X,Y,Z,A) +#define OSTRACE5(X,Y,Z,A,B) if( sqlite3_os_trace ) sqlite3DebugPrintf(X,Y,Z,A,B) +#define OSTRACE6(X,Y,Z,A,B,C) \ + if(sqlite3_os_trace) sqlite3DebugPrintf(X,Y,Z,A,B,C) +#define OSTRACE7(X,Y,Z,A,B,C,D) \ + if(sqlite3_os_trace) sqlite3DebugPrintf(X,Y,Z,A,B,C,D) +#else +#define OSTRACE1(X) +#define OSTRACE2(X,Y) +#define OSTRACE3(X,Y,Z) +#define OSTRACE4(X,Y,Z,A) +#define OSTRACE5(X,Y,Z,A,B) +#define OSTRACE6(X,Y,Z,A,B,C) +#define OSTRACE7(X,Y,Z,A,B,C,D) +#endif + +/* +** Macros for performance tracing. Normally turned off. Only works +** on i486 hardware. +*/ +#ifdef SQLITE_PERFORMANCE_TRACE +__inline__ unsigned long long int hwtime(void){ + unsigned long long int x; + __asm__("rdtsc\n\t" + "mov %%edx, %%ecx\n\t" + :"=A" (x)); + return x; +} +static unsigned long long int g_start; +static unsigned int elapse; +#define TIMER_START g_start=hwtime() +#define TIMER_END elapse=hwtime()-g_start +#define TIMER_ELAPSED elapse +#else +#define TIMER_START +#define TIMER_END +#define TIMER_ELAPSED 0 +#endif + +/* +** If we compile with the SQLITE_TEST macro set, then the following block +** of code will give us the ability to simulate a disk I/O error. This +** is used for testing the I/O recovery logic. +*/ +#ifdef SQLITE_TEST +int sqlite3_io_error_hit = 0; +int sqlite3_io_error_pending = 0; +int sqlite3_io_error_persist = 0; +int sqlite3_diskfull_pending = 0; +int sqlite3_diskfull = 0; +#define SimulateIOError(CODE) \ + if( sqlite3_io_error_pending || sqlite3_io_error_hit ) \ + if( sqlite3_io_error_pending-- == 1 \ + || (sqlite3_io_error_persist && sqlite3_io_error_hit) ) \ + { local_ioerr(); CODE; } +static void local_ioerr(){ + IOTRACE(("IOERR\n")); + sqlite3_io_error_hit = 1; +} +#define SimulateDiskfullError(CODE) \ + if( sqlite3_diskfull_pending ){ \ + if( sqlite3_diskfull_pending == 1 ){ \ + local_ioerr(); \ + sqlite3_diskfull = 1; \ + sqlite3_io_error_hit = 1; \ + CODE; \ + }else{ \ + sqlite3_diskfull_pending--; \ + } \ + } +#else +#define SimulateIOError(A) +#define SimulateDiskfullError(A) +#endif + +/* +** When testing, keep a count of the number of open files. +*/ +#ifdef SQLITE_TEST +int sqlite3_open_file_count = 0; +#define OpenCounter(X) sqlite3_open_file_count+=(X) +#else +#define OpenCounter(X) +#endif diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/os_symbian.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/os_symbian.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,616 @@ +/* +** 2008 February 09 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains code that is specific to windows. +*/ +#include "sqliteInt.h" +#if OS_SYMBIAN /* This file is used for symbian only */ + +#define MAX_PATH 260 +/* +** A Note About Memory Allocation: +** +** This driver uses malloc()/free() directly rather than going through +** the SQLite-wrappers sqlite3_malloc()/sqlite3_free(). Those wrappers +** are designed for use on embedded systems where memory is scarce and +** malloc failures happen frequently. Win32 does not typically run on +** embedded systems, and when it does the developers normally have bigger +** problems to worry about than running out of memory. So there is not +** a compelling need to use the wrappers. +** +** But there is a good reason to not use the wrappers. If we use the +** wrappers then we will get simulated malloc() failures within this +** driver. And that causes all kinds of problems for our tests. We +** could enhance SQLite to deal with simulated malloc failures within +** the OS driver, but the code to deal with those failure would not +** be exercised on Linux (which does not need to malloc() in the driver) +** and so we would have difficulty writing coverage tests for that +** code. Better to leave the code out, we think. +** +** The point of this discussion is as follows: When creating a new +** OS layer for an embedded system, if you use this file as an example, +** avoid the use of malloc()/free(). Those routines work ok on windows +** desktops but not so well in embedded systems. +*/ + +#include +#include +#include +#include +#include +#include +#include +#include + +/* +** Macros used to determine whether or not to use threads. +*/ +#if defined(THREADSAFE) && THREADSAFE +# define SQLITE_W32_THREADS 1 +#endif + +/* +** Include code that is common to all os_*.c files +*/ +#include "os_common.h" + +/* +** The symbianFile structure is a subclass of sqlite3_file* specific to the win32 +** portability layer. +*/ + +typedef struct symbianFile symbianFile; +struct symbianFile { + int isOpen; + unsigned char locktype; /* Type of lock currently held on this file */ + short sharedLockByte; /* Randomly chosen byte used as a shared lock */ + char fileName[512]; + RFs session; + RFile file; +}; + +/***************************************************************************** +** The next group of routines implement the I/O methods specified +** by the sqlite3_io_methods object. +******************************************************************************/ + +/* +** Close a file. +** +** It is reported that an attempt to close a handle might sometimes +** fail. This is a very unreasonable result, but windows is notorious +** for being unreasonable so I do not doubt that it might happen. If +** the close fails, we pause for 100 milliseconds and try again. As +** many as MX_CLOSE_ATTEMPT attempts to close the handle are made before +** giving up and returning an error. +*/ +#define MX_CLOSE_ATTEMPT 3 +int winClose(sqlite3_file *id){ + int rc, cnt = 0; + symbianFile *pFile = (symbianFile*)id; + pFile->file.Close(); + pFile->session.Close(); + return SQLITE_OK; +} + +/* +** Some microsoft compilers lack this definition. +*/ +#ifndef INVALID_SET_FILE_POINTER +# define INVALID_SET_FILE_POINTER ((DWORD)-1) +#endif + +/* +** Read data from a file into a buffer. Return SQLITE_OK if all +** bytes were read successfully and SQLITE_IOERR if anything goes +** wrong. +*/ +int winRead( + sqlite3_file *id, /* File to read from */ + void *pBuf, /* Write content into this buffer */ + int amt, /* Number of bytes to read */ + sqlite3_int64 offset /* Begin reading at this offset */ +){ + int rc; + size_t got; + symbianFile *pFile = (symbianFile*)id; + assert( id!=0 ); + SimulateIOError(return SQLITE_IOERR_READ); + TInt tOffset = (TInt)offset; + rc = pFile->file.Seek(ESeekStart, tOffset); + if( rc!= KErrNone){ + return SQLITE_FULL; + } + + HBufC8* buf = HBufC8::NewL(amt) ; + TPtr8 ptr = buf->Des(); + + if (pFile->file.Read(ptr, amt) != KErrNone) + { + delete buf; + return SQLITE_IOERR_READ; + } + + got = buf->Length(); + + if( got == 0 ){ + delete buf; + TInt size = 0; + if (pFile->file.Size(size) != KErrNone) + { + return SQLITE_IOERR_READ; + } + if (size == 0) + { + return SQLITE_IOERR_SHORT_READ; + } + return SQLITE_IOERR_READ; + } + memcpy(pBuf, ptr.Ptr(), got); + delete buf; + if( got == amt ){ + return SQLITE_OK; + }else{ + memset(&((char*)pBuf)[got], 0, amt-got); + return SQLITE_IOERR_SHORT_READ; + } +} + +/* +** Write data from a buffer into a file. Return SQLITE_OK on success +** or some other error code on failure. +*/ +int winWrite( + sqlite3_file *id, /* File to write into */ + const void *pBuf, /* The bytes to be written */ + int amt, /* Number of bytes to write */ + sqlite3_int64 offset /* Offset into the file to begin writing at */ +){ + int rc; + symbianFile *pFile = (symbianFile*)id; + assert( id!=0 ); + SimulateIOError(return SQLITE_IOERR_WRITE); + SimulateDiskfullError(return SQLITE_FULL); + TInt tOffset = (TInt)offset; + rc = pFile->file.Seek(ESeekStart, tOffset); + if( rc!= KErrNone){ + return SQLITE_FULL; + } + + assert( amt>0 ); + + rc = SQLITE_OK; + TPtrC8 ptr((TUint8 *)pBuf,amt); + + if (pFile->file.Write(ptr, amt) != KErrNone) rc = SQLITE_FULL; + + return rc; +} + +/* +** Truncate an open file to a specified size +*/ +int winTruncate(sqlite3_file *id, sqlite3_int64 nByte){ + symbianFile *pFile = (symbianFile*)id; + + if (pFile->file.SetSize(nByte) != KErrNone) + { + return SQLITE_IOERR; + } + + return SQLITE_OK; +} + +#ifdef SQLITE_TEST +/* +** Count the number of fullsyncs and normal syncs. This is used to test +** that syncs and fullsyncs are occuring at the right times. +*/ +int sqlite3_sync_count = 0; +int sqlite3_fullsync_count = 0; +#endif + +/* +** Make sure all writes to a particular file are committed to disk. +*/ +int winSync(sqlite3_file *id, int flags){ + symbianFile *pFile = (symbianFile*)id; + OSTRACE3("SYNC %d lock=%d\n", pFile->h, pFile->locktype); +#ifdef SQLITE_TEST + if( flags & SQLITE_SYNC_FULL ){ + sqlite3_fullsync_count++; + } + sqlite3_sync_count++; +#endif + TInt error = pFile->file.Flush(); + if (error != KErrNone) + { + return SQLITE_IOERR; + }else{ + return SQLITE_OK; + } +} + +/* +** Determine the current size of a file in bytes +*/ +int winFileSize(sqlite3_file *id, sqlite3_int64 *pSize){ + symbianFile *pFile = (symbianFile*)id; + + TInt size = 0; + if (pFile->file.Size(size) != KErrNone) + { + return SQLITE_IOERR; + } + + *pSize = size; + + return SQLITE_OK; +} + + +/* +** Lock the file with the lock specified by parameter locktype - one +** of the following: +** +** (1) SHARED_LOCK +** (2) RESERVED_LOCK +** (3) PENDING_LOCK +** (4) EXCLUSIVE_LOCK +** +** Sometimes when requesting one lock state, additional lock states +** are inserted in between. The locking might fail on one of the later +** transitions leaving the lock state different from what it started but +** still short of its goal. The following chart shows the allowed +** transitions and the inserted intermediate states: +** +** UNLOCKED -> SHARED +** SHARED -> RESERVED +** SHARED -> (PENDING) -> EXCLUSIVE +** RESERVED -> (PENDING) -> EXCLUSIVE +** PENDING -> EXCLUSIVE +** +** This routine will only increase a lock. The winUnlock() routine +** erases all locks at once and returns us immediately to locking level 0. +** It is not possible to lower the locking level one step at a time. You +** must go straight to locking level 0. +*/ +int winLock(sqlite3_file *id, int locktype){ + int rc = SQLITE_OK; /* Return code from subroutines */ + int res = 1; /* Result of a windows lock call */ + int newLocktype; /* Set pFile->locktype to this value before exiting */ + int gotPendingLock = 0;/* True if we acquired a PENDING lock this time */ + symbianFile *pFile = (symbianFile*)id; + + assert( pFile!=0 ); + OSTRACE5("LOCK %d %d was %d(%d)\n", + pFile->h, locktype, pFile->locktype, pFile->sharedLockByte); + + // one smartphone only one application can control the database + + TInt size = 0; + if (pFile->file.Size(size) == KErrNone) return SQLITE_OK; + + return SQLITE_BUSY; +} + +/* +** This routine checks if there is a RESERVED lock held on the specified +** file by this or any other process. If such a lock is held, return +** non-zero, otherwise zero. +*/ +int winCheckReservedLock(sqlite3_file *id){ + int rc; + symbianFile *pFile = (symbianFile*)id; + assert( pFile!=0 ); + if( pFile->locktype>=RESERVED_LOCK ){ + rc = 1; + OSTRACE3("TEST WR-LOCK %d %d (local)\n", pFile->h, rc); + }else{ + TInt size = 0; + if (pFile->file.Size(size) == KErrNone) rc = 1; + OSTRACE3("TEST WR-LOCK %d %d (remote)\n", pFile->h, rc); + } + return rc; +} + +/* +** Lower the locking level on file descriptor id to locktype. locktype +** must be either NO_LOCK or SHARED_LOCK. +** +** If the locking level of the file descriptor is already at or below +** the requested locking level, this routine is a no-op. +** +** It is not possible for this routine to fail if the second argument +** is NO_LOCK. If the second argument is SHARED_LOCK then this routine +** might return SQLITE_IOERR; +*/ +int winUnlock(sqlite3_file *id, int locktype){ + int type; + symbianFile *pFile = (symbianFile*)id; + int rc = SQLITE_OK; + assert( pFile!=0 ); + return rc; +} + +/* +** Control and query of the open file handle. +*/ +int winFileControl(sqlite3_file *id, int op, void *pArg){ + switch( op ){ + case SQLITE_FCNTL_LOCKSTATE: { + *(int*)pArg = ((symbianFile*)id)->locktype; + return SQLITE_OK; + } + } + return SQLITE_ERROR; +} + +/* +** Return the sector size in bytes of the underlying block device for +** the specified file. This is almost always 512 bytes, but may be +** larger for some devices. +** +** SQLite code assumes this function cannot fail. It also assumes that +** if two files are created in the same file-system directory (i.e. +** a database and its journal file) that the sector size will be the +** same for both. +*/ +int winSectorSize(sqlite3_file *id){ + return SQLITE_DEFAULT_SECTOR_SIZE; +} + +/* +** Return a vector of device characteristics. +*/ +int winDeviceCharacteristics(sqlite3_file *id){ + return 0; +} + + +/*************************************************************************** +** Here ends the I/O methods that form the sqlite3_io_methods object. +** +** The next block of code implements the VFS methods. +****************************************************************************/ + +void ConvertToUnicode(RFs session, TDes16& aUnicode, const char *str) +{ + CCnvCharacterSetConverter *converter = CCnvCharacterSetConverter::NewL(); + converter->PrepareToConvertToOrFromL(KCharacterSetIdentifierUtf8, session); + + TPtrC8 ptr((const unsigned char*)str); + + int state = CCnvCharacterSetConverter::KStateDefault; + converter->ConvertToUnicode(aUnicode, ptr, state); + delete converter; +} + +/* +** Open a file. +*/ +int winOpen( + sqlite3_vfs *pVfs, /* Not used */ + const char *zName, /* Name of the file (UTF-8) */ + sqlite3_file *id, /* Write the SQLite file handle here */ + int flags, /* Open mode flags */ + int *pOutFlags /* Status return flags */ +){ + symbianFile *pFile = (symbianFile*)id; + TBuf16 filename; + + pFile->isOpen = 0; + memset(pFile, 0, sizeof(*pFile)); + strcpy(pFile->fileName, zName); + pFile->session.Connect(); + + ConvertToUnicode(pFile->session, filename, zName); + + int ret = 0; + if( flags & SQLITE_OPEN_CREATE ){ + if (BaflUtils::FileExists(pFile->session, filename) == 1) + { + ret = pFile->file.Open(pFile->session, filename, EFileStream | EFileWrite); + } + else + { + ret = pFile->file.Create(pFile->session, filename, EFileStream | EFileWrite); + } + } + else + if( flags & SQLITE_OPEN_READWRITE ){ + ret = pFile->file.Open(pFile->session, filename, EFileStream | EFileWrite); + }else{ + ret = pFile->file.Open(pFile->session, filename, EFileStream | EFileRead); + } + + OpenCounter(+1); + + if (ret != KErrNone) + { + return SQLITE_IOERR; + } + + pFile->isOpen = 1; + return SQLITE_OK; +} + +/* +** Delete the named file. +** +** Note that windows does not allow a file to be deleted if some other +** process has it open. Sometimes a virus scanner or indexing program +** will open a journal file shortly after it is created in order to do +** whatever does. While this other process is holding the +** file open, we will be unable to delete it. To work around this +** problem, we delay 100 milliseconds and try to delete again. Up +** to MX_DELETION_ATTEMPTs deletion attempts are run before giving +** up and returning an error. +*/ +#define MX_DELETION_ATTEMPTS 5 +int winDelete( + sqlite3_vfs *pVfs, /* Not used on win32 */ + const char *zFilename, /* Name of file to delete */ + int syncDir /* Not used on win32 */ +){ + SimulateIOError(return SQLITE_IOERR_DELETE); + TBuf16 filename; + + RFs session; + session.Connect(); + ConvertToUnicode(session, filename, zFilename); + BaflUtils::DeleteFile(session, filename); + OSTRACE2("DELETE \"%s\"\n", zFilename); + session.Close(); + return SQLITE_OK; +} + +/* +** Check the existance and status of a file. +*/ +int winAccess( + sqlite3_vfs *pVfs, /* Not used on win32 */ + const char *zFilename, /* Name of file to check */ + int flags /* Type of test to make on this file */ +){ + TBuf16 filename; + + RFs session; + session.Connect(); + ConvertToUnicode(session, filename, zFilename); + int ret = BaflUtils::FileExists(session, filename); + session.Close(); + + return ret; +} + + +/* +** Create a temporary file name in zBuf. zBuf must be big enough to +** hold at pVfs->mxPathname characters. +*/ +int winGetTempname(sqlite3_vfs *pVfs, int nBuf, char *zBuf){ + static char zChars[] = + "abcdefghijklmnopqrstuvwxyz" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "0123456789"; + int i, j; + char zTempPath[MAX_PATH+1]; + if( sqlite3_temp_directory ){ + sqlite3_snprintf(MAX_PATH-30, zTempPath, "%s", sqlite3_temp_directory); + } + else + { + } + + for(i=strlen(zTempPath); i>0 && zTempPath[i-1]=='\\'; i--){} + zTempPath[i] = 0; + sqlite3_snprintf(nBuf-30, zBuf, + "%s\\"SQLITE_TEMP_FILE_PREFIX, zTempPath); + j = strlen(zBuf); + sqlite3Randomness(20, &zBuf[j]); + for(i=0; i<20; i++, j++){ + zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ]; + } + zBuf[j] = 0; + OSTRACE2("TEMP FILENAME: %s\n", zBuf); + return SQLITE_OK; +} + +/* +** Turn a relative pathname into a full pathname. Write the full +** pathname into zOut[]. zOut[] will be at least pVfs->mxPathname +** bytes in size. +*/ +int winFullPathname( + sqlite3_vfs *pVfs, /* Pointer to vfs object */ + const char *zRelative, /* Possibly relative input path */ + int nFull, /* Size of output buffer in bytes */ + char *zFull /* Output buffer */ +){ + + /* WinCE has no concept of a relative pathname, or so I am told. */ + sqlite3_snprintf(pVfs->mxPathname, zFull, "%s", zRelative); + return SQLITE_OK; +} + + #define winDlOpen 0 + #define winDlError 0 + #define winDlSym 0 + #define winDlClose 0 + + +/* +** Write up to nBuf bytes of randomness into zBuf. +*/ +int winRandomness(sqlite3_vfs *pVfs, int nBuf, char *zBuf){ + + int i; + for (i=0; i +#include + +/* +** Macros for troubleshooting. Normally turned off +*/ +#if 0 +#define sqlite3DebugPrintf printf +#define PAGERTRACE1(X) sqlite3DebugPrintf(X) +#define PAGERTRACE2(X,Y) sqlite3DebugPrintf(X,Y) +#define PAGERTRACE3(X,Y,Z) sqlite3DebugPrintf(X,Y,Z) +#define PAGERTRACE4(X,Y,Z,W) sqlite3DebugPrintf(X,Y,Z,W) +#define PAGERTRACE5(X,Y,Z,W,V) sqlite3DebugPrintf(X,Y,Z,W,V) +#else +#define PAGERTRACE1(X) +#define PAGERTRACE2(X,Y) +#define PAGERTRACE3(X,Y,Z) +#define PAGERTRACE4(X,Y,Z,W) +#define PAGERTRACE5(X,Y,Z,W,V) +#endif + +/* +** The following two macros are used within the PAGERTRACEX() macros above +** to print out file-descriptors. +** +** PAGERID() takes a pointer to a Pager struct as its argument. The +** associated file-descriptor is returned. FILEHANDLEID() takes an sqlite3_file +** struct as its argument. +*/ +#define PAGERID(p) ((int)(p->fd)) +#define FILEHANDLEID(fd) ((int)fd) + +/* +** The page cache as a whole is always in one of the following +** states: +** +** PAGER_UNLOCK The page cache is not currently reading or +** writing the database file. There is no +** data held in memory. This is the initial +** state. +** +** PAGER_SHARED The page cache is reading the database. +** Writing is not permitted. There can be +** multiple readers accessing the same database +** file at the same time. +** +** PAGER_RESERVED This process has reserved the database for writing +** but has not yet made any changes. Only one process +** at a time can reserve the database. The original +** database file has not been modified so other +** processes may still be reading the on-disk +** database file. +** +** PAGER_EXCLUSIVE The page cache is writing the database. +** Access is exclusive. No other processes or +** threads can be reading or writing while one +** process is writing. +** +** PAGER_SYNCED The pager moves to this state from PAGER_EXCLUSIVE +** after all dirty pages have been written to the +** database file and the file has been synced to +** disk. All that remains to do is to remove or +** truncate the journal file and the transaction +** will be committed. +** +** The page cache comes up in PAGER_UNLOCK. The first time a +** sqlite3PagerGet() occurs, the state transitions to PAGER_SHARED. +** After all pages have been released using sqlite_page_unref(), +** the state transitions back to PAGER_UNLOCK. The first time +** that sqlite3PagerWrite() is called, the state transitions to +** PAGER_RESERVED. (Note that sqlite3PagerWrite() can only be +** called on an outstanding page which means that the pager must +** be in PAGER_SHARED before it transitions to PAGER_RESERVED.) +** PAGER_RESERVED means that there is an open rollback journal. +** The transition to PAGER_EXCLUSIVE occurs before any changes +** are made to the database file, though writes to the rollback +** journal occurs with just PAGER_RESERVED. After an sqlite3PagerRollback() +** or sqlite3PagerCommitPhaseTwo(), the state can go back to PAGER_SHARED, +** or it can stay at PAGER_EXCLUSIVE if we are in exclusive access mode. +*/ +#define PAGER_UNLOCK 0 +#define PAGER_SHARED 1 /* same as SHARED_LOCK */ +#define PAGER_RESERVED 2 /* same as RESERVED_LOCK */ +#define PAGER_EXCLUSIVE 4 /* same as EXCLUSIVE_LOCK */ +#define PAGER_SYNCED 5 + +/* +** If the SQLITE_BUSY_RESERVED_LOCK macro is set to true at compile-time, +** then failed attempts to get a reserved lock will invoke the busy callback. +** This is off by default. To see why, consider the following scenario: +** +** Suppose thread A already has a shared lock and wants a reserved lock. +** Thread B already has a reserved lock and wants an exclusive lock. If +** both threads are using their busy callbacks, it might be a long time +** be for one of the threads give up and allows the other to proceed. +** But if the thread trying to get the reserved lock gives up quickly +** (if it never invokes its busy callback) then the contention will be +** resolved quickly. +*/ +#ifndef SQLITE_BUSY_RESERVED_LOCK +# define SQLITE_BUSY_RESERVED_LOCK 0 +#endif + +/* +** This macro rounds values up so that if the value is an address it +** is guaranteed to be an address that is aligned to an 8-byte boundary. +*/ +#define FORCE_ALIGNMENT(X) (((X)+7)&~7) + +typedef struct PgHdr PgHdr; + +/* +** Each pager stores all currently unreferenced pages in a list sorted +** in least-recently-used (LRU) order (i.e. the first item on the list has +** not been referenced in a long time, the last item has been recently +** used). An instance of this structure is included as part of each +** pager structure for this purpose (variable Pager.lru). +** +** Additionally, if memory-management is enabled, all unreferenced pages +** are stored in a global LRU list (global variable sqlite3LruPageList). +** +** In both cases, the PagerLruList.pFirstSynced variable points to +** the first page in the corresponding list that does not require an +** fsync() operation before its memory can be reclaimed. If no such +** page exists, PagerLruList.pFirstSynced is set to NULL. +*/ +typedef struct PagerLruList PagerLruList; +struct PagerLruList { + PgHdr *pFirst; /* First page in LRU list */ + PgHdr *pLast; /* Last page in LRU list (the most recently used) */ + PgHdr *pFirstSynced; /* First page in list with PgHdr.needSync==0 */ +}; + +/* +** The following structure contains the next and previous pointers used +** to link a PgHdr structure into a PagerLruList linked list. +*/ +typedef struct PagerLruLink PagerLruLink; +struct PagerLruLink { + PgHdr *pNext; + PgHdr *pPrev; +}; + +/* +** Each in-memory image of a page begins with the following header. +** This header is only visible to this pager module. The client +** code that calls pager sees only the data that follows the header. +** +** Client code should call sqlite3PagerWrite() on a page prior to making +** any modifications to that page. The first time sqlite3PagerWrite() +** is called, the original page contents are written into the rollback +** journal and PgHdr.inJournal and PgHdr.needSync are set. Later, once +** the journal page has made it onto the disk surface, PgHdr.needSync +** is cleared. The modified page cannot be written back into the original +** database file until the journal pages has been synced to disk and the +** PgHdr.needSync has been cleared. +** +** The PgHdr.dirty flag is set when sqlite3PagerWrite() is called and +** is cleared again when the page content is written back to the original +** database file. +** +** Details of important structure elements: +** +** needSync +** +** If this is true, this means that it is not safe to write the page +** content to the database because the original content needed +** for rollback has not by synced to the main rollback journal. +** The original content may have been written to the rollback journal +** but it has not yet been synced. So we cannot write to the database +** file because power failure might cause the page in the journal file +** to never reach the disk. It is as if the write to the journal file +** does not occur until the journal file is synced. +** +** This flag is false if the page content exactly matches what +** currently exists in the database file. The needSync flag is also +** false if the original content has been written to the main rollback +** journal and synced. If the page represents a new page that has +** been added onto the end of the database during the current +** transaction, the needSync flag is true until the original database +** size in the journal header has been synced to disk. +** +** inJournal +** +** This is true if the original page has been written into the main +** rollback journal. This is always false for new pages added to +** the end of the database file during the current transaction. +** And this flag says nothing about whether or not the journal +** has been synced to disk. For pages that are in the original +** database file, the following expression should always be true: +** +** inJournal = (pPager->aInJournal[(pgno-1)/8] & (1<<((pgno-1)%8))!=0 +** +** The pPager->aInJournal[] array is only valid for the original +** pages of the database, not new pages that are added to the end +** of the database, so obviously the above expression cannot be +** valid for new pages. For new pages inJournal is always 0. +** +** dirty +** +** When true, this means that the content of the page has been +** modified and needs to be written back to the database file. +** If false, it means that either the content of the page is +** unchanged or else the content is unimportant and we do not +** care whether or not it is preserved. +** +** alwaysRollback +** +** This means that the sqlite3PagerDontRollback() API should be +** ignored for this page. The DontRollback() API attempts to say +** that the content of the page on disk is unimportant (it is an +** unused page on the freelist) so that it is unnecessary to +** rollback changes to this page because the content of the page +** can change without changing the meaning of the database. This +** flag overrides any DontRollback() attempt. This flag is set +** when a page that originally contained valid data is added to +** the freelist. Later in the same transaction, this page might +** be pulled from the freelist and reused for something different +** and at that point the DontRollback() API will be called because +** pages taken from the freelist do not need to be protected by +** the rollback journal. But this flag says that the page was +** not originally part of the freelist so that it still needs to +** be rolled back in spite of any subsequent DontRollback() calls. +** +** needRead +** +** This flag means (when true) that the content of the page has +** not yet been loaded from disk. The in-memory content is just +** garbage. (Actually, we zero the content, but you should not +** make any assumptions about the content nevertheless.) If the +** content is needed in the future, it should be read from the +** original database file. +*/ +struct PgHdr { + Pager *pPager; /* The pager to which this page belongs */ + Pgno pgno; /* The page number for this page */ + PgHdr *pNextHash, *pPrevHash; /* Hash collision chain for PgHdr.pgno */ + PagerLruLink free; /* Next and previous free pages */ + PgHdr *pNextAll; /* A list of all pages */ + u8 inJournal; /* TRUE if has been written to journal */ + u8 dirty; /* TRUE if we need to write back changes */ + u8 needSync; /* Sync journal before writing this page */ + u8 alwaysRollback; /* Disable DontRollback() for this page */ + u8 needRead; /* Read content if PagerWrite() is called */ + short int nRef; /* Number of users of this page */ + PgHdr *pDirty, *pPrevDirty; /* Dirty pages */ +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT + PagerLruLink gfree; /* Global list of nRef==0 pages */ +#endif +#ifdef SQLITE_CHECK_PAGES + u32 pageHash; +#endif + void *pData; /* Page data */ + /* Pager.nExtra bytes of local data appended to this header */ +}; + +/* +** For an in-memory only database, some extra information is recorded about +** each page so that changes can be rolled back. (Journal files are not +** used for in-memory databases.) The following information is added to +** the end of every EXTRA block for in-memory databases. +** +** This information could have been added directly to the PgHdr structure. +** But then it would take up an extra 8 bytes of storage on every PgHdr +** even for disk-based databases. Splitting it out saves 8 bytes. This +** is only a savings of 0.8% but those percentages add up. +*/ +typedef struct PgHistory PgHistory; +struct PgHistory { + u8 *pOrig; /* Original page text. Restore to this on a full rollback */ + u8 *pStmt; /* Text as it was at the beginning of the current statement */ + PgHdr *pNextStmt, *pPrevStmt; /* List of pages in the statement journal */ + u8 inStmt; /* TRUE if in the statement subjournal */ +}; + +/* +** A macro used for invoking the codec if there is one +*/ +#ifdef SQLITE_HAS_CODEC +# define CODEC1(P,D,N,X) if( P->xCodec!=0 ){ P->xCodec(P->pCodecArg,D,N,X); } +# define CODEC2(P,D,N,X) ((char*)(P->xCodec!=0?P->xCodec(P->pCodecArg,D,N,X):D)) +#else +# define CODEC1(P,D,N,X) /* NO-OP */ +# define CODEC2(P,D,N,X) ((char*)D) +#endif + +/* +** Convert a pointer to a PgHdr into a pointer to its data +** and back again. +*/ +#define PGHDR_TO_DATA(P) ((P)->pData) +#define PGHDR_TO_EXTRA(G,P) ((void*)&((G)[1])) +#define PGHDR_TO_HIST(P,PGR) \ + ((PgHistory*)&((char*)(&(P)[1]))[(PGR)->nExtra]) + +/* +** A open page cache is an instance of the following structure. +** +** Pager.errCode may be set to SQLITE_IOERR, SQLITE_CORRUPT, or +** or SQLITE_FULL. Once one of the first three errors occurs, it persists +** and is returned as the result of every major pager API call. The +** SQLITE_FULL return code is slightly different. It persists only until the +** next successful rollback is performed on the pager cache. Also, +** SQLITE_FULL does not affect the sqlite3PagerGet() and sqlite3PagerLookup() +** APIs, they may still be used successfully. +*/ +struct Pager { + sqlite3_vfs *pVfs; /* OS functions to use for IO */ + u8 journalOpen; /* True if journal file descriptors is valid */ + u8 journalStarted; /* True if header of journal is synced */ + u8 useJournal; /* Use a rollback journal on this file */ + u8 noReadlock; /* Do not bother to obtain readlocks */ + u8 stmtOpen; /* True if the statement subjournal is open */ + u8 stmtInUse; /* True we are in a statement subtransaction */ + u8 stmtAutoopen; /* Open stmt journal when main journal is opened*/ + u8 noSync; /* Do not sync the journal if true */ + u8 fullSync; /* Do extra syncs of the journal for robustness */ + u8 sync_flags; /* One of SYNC_NORMAL or SYNC_FULL */ + u8 state; /* PAGER_UNLOCK, _SHARED, _RESERVED, etc. */ + u8 tempFile; /* zFilename is a temporary file */ + u8 readOnly; /* True for a read-only database */ + u8 needSync; /* True if an fsync() is needed on the journal */ + u8 dirtyCache; /* True if cached pages have changed */ + u8 alwaysRollback; /* Disable DontRollback() for all pages */ + u8 memDb; /* True to inhibit all file I/O */ + u8 setMaster; /* True if a m-j name has been written to jrnl */ + u8 doNotSync; /* Boolean. While true, do not spill the cache */ + u8 exclusiveMode; /* Boolean. True if locking_mode==EXCLUSIVE */ + u8 changeCountDone; /* Set after incrementing the change-counter */ + u32 vfsFlags; /* Flags for sqlite3_vfs.xOpen() */ + int errCode; /* One of several kinds of errors */ + int dbSize; /* Number of pages in the file */ + int origDbSize; /* dbSize before the current change */ + int stmtSize; /* Size of database (in pages) at stmt_begin() */ + int nRec; /* Number of pages written to the journal */ + u32 cksumInit; /* Quasi-random value added to every checksum */ + int stmtNRec; /* Number of records in stmt subjournal */ + int nExtra; /* Add this many bytes to each in-memory page */ + int pageSize; /* Number of bytes in a page */ + int nPage; /* Total number of in-memory pages */ + int nRef; /* Number of in-memory pages with PgHdr.nRef>0 */ + int mxPage; /* Maximum number of pages to hold in cache */ + Pgno mxPgno; /* Maximum allowed size of the database */ + u8 *aInJournal; /* One bit for each page in the database file */ + u8 *aInStmt; /* One bit for each page in the database */ + char *zFilename; /* Name of the database file */ + char *zJournal; /* Name of the journal file */ + char *zDirectory; /* Directory hold database and journal files */ + char *zStmtJrnl; /* Name of the statement journal file */ + sqlite3_file *fd, *jfd; /* File descriptors for database and journal */ + sqlite3_file *stfd; /* File descriptor for the statement subjournal*/ + BusyHandler *pBusyHandler; /* Pointer to sqlite.busyHandler */ + PagerLruList lru; /* LRU list of free pages */ + PgHdr *pAll; /* List of all pages */ + PgHdr *pStmt; /* List of pages in the statement subjournal */ + PgHdr *pDirty; /* List of all dirty pages */ + i64 journalOff; /* Current byte offset in the journal file */ + i64 journalHdr; /* Byte offset to previous journal header */ + i64 stmtHdrOff; /* First journal header written this statement */ + i64 stmtCksum; /* cksumInit when statement was started */ + i64 stmtJSize; /* Size of journal at stmt_begin() */ + int sectorSize; /* Assumed sector size during rollback */ +#ifdef SQLITE_TEST + int nHit, nMiss; /* Cache hits and missing */ + int nRead, nWrite; /* Database pages read/written */ +#endif + void (*xDestructor)(DbPage*,int); /* Call this routine when freeing pages */ + void (*xReiniter)(DbPage*,int); /* Call this routine when reloading pages */ +#ifdef SQLITE_HAS_CODEC + void *(*xCodec)(void*,void*,Pgno,int); /* Routine for en/decoding data */ + void *pCodecArg; /* First argument to xCodec() */ +#endif + int nHash; /* Size of the pager hash table */ + PgHdr **aHash; /* Hash table to map page number to PgHdr */ +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT + Pager *pNext; /* Doubly linked list of pagers on which */ + Pager *pPrev; /* sqlite3_release_memory() will work */ + int iInUseMM; /* Non-zero if unavailable to MM */ + int iInUseDB; /* Non-zero if in sqlite3_release_memory() */ +#endif + char *pTmpSpace; /* Pager.pageSize bytes of space for tmp use */ + char dbFileVers[16]; /* Changes whenever database file changes */ +}; + +/* +** The following global variables hold counters used for +** testing purposes only. These variables do not exist in +** a non-testing build. These variables are not thread-safe. +*/ +#ifdef SQLITE_TEST +int sqlite3_pager_readdb_count = 0; /* Number of full pages read from DB */ +int sqlite3_pager_writedb_count = 0; /* Number of full pages written to DB */ +int sqlite3_pager_writej_count = 0; /* Number of pages written to journal */ +int sqlite3_pager_pgfree_count = 0; /* Number of cache pages freed */ +# define PAGER_INCR(v) v++ +#else +# define PAGER_INCR(v) +#endif + +/* +** The following variable points to the head of a double-linked list +** of all pagers that are eligible for page stealing by the +** sqlite3_release_memory() interface. Access to this list is +** protected by the SQLITE_MUTEX_STATIC_MEM2 mutex. +*/ +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT +static Pager *sqlite3PagerList = 0; +static PagerLruList sqlite3LruPageList = {0, 0, 0}; +#endif + + +/* +** Journal files begin with the following magic string. The data +** was obtained from /dev/random. It is used only as a sanity check. +** +** Since version 2.8.0, the journal format contains additional sanity +** checking information. If the power fails while the journal is begin +** written, semi-random garbage data might appear in the journal +** file after power is restored. If an attempt is then made +** to roll the journal back, the database could be corrupted. The additional +** sanity checking data is an attempt to discover the garbage in the +** journal and ignore it. +** +** The sanity checking information for the new journal format consists +** of a 32-bit checksum on each page of data. The checksum covers both +** the page number and the pPager->pageSize bytes of data for the page. +** This cksum is initialized to a 32-bit random value that appears in the +** journal file right after the header. The random initializer is important, +** because garbage data that appears at the end of a journal is likely +** data that was once in other files that have now been deleted. If the +** garbage data came from an obsolete journal file, the checksums might +** be correct. But by initializing the checksum to random value which +** is different for every journal, we minimize that risk. +*/ +static const unsigned char aJournalMagic[] = { + 0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd7, +}; + +/* +** The size of the header and of each page in the journal is determined +** by the following macros. +*/ +#define JOURNAL_PG_SZ(pPager) ((pPager->pageSize) + 8) + +/* +** The journal header size for this pager. In the future, this could be +** set to some value read from the disk controller. The important +** characteristic is that it is the same size as a disk sector. +*/ +#define JOURNAL_HDR_SZ(pPager) (pPager->sectorSize) + +/* +** The macro MEMDB is true if we are dealing with an in-memory database. +** We do this as a macro so that if the SQLITE_OMIT_MEMORYDB macro is set, +** the value of MEMDB will be a constant and the compiler will optimize +** out code that would never execute. +*/ +#ifdef SQLITE_OMIT_MEMORYDB +# define MEMDB 0 +#else +# define MEMDB pPager->memDb +#endif + +/* +** Page number PAGER_MJ_PGNO is never used in an SQLite database (it is +** reserved for working around a windows/posix incompatibility). It is +** used in the journal to signify that the remainder of the journal file +** is devoted to storing a master journal name - there are no more pages to +** roll back. See comments for function writeMasterJournal() for details. +*/ +/* #define PAGER_MJ_PGNO(x) (PENDING_BYTE/((x)->pageSize)) */ +#define PAGER_MJ_PGNO(x) ((PENDING_BYTE/((x)->pageSize))+1) + +/* +** The maximum legal page number is (2^31 - 1). +*/ +#define PAGER_MAX_PGNO 2147483647 + +/* +** The pagerEnter() and pagerLeave() routines acquire and release +** a mutex on each pager. The mutex is recursive. +** +** This is a special-purpose mutex. It only provides mutual exclusion +** between the Btree and the Memory Management sqlite3_release_memory() +** function. It does not prevent, for example, two Btrees from accessing +** the same pager at the same time. Other general-purpose mutexes in +** the btree layer handle that chore. +*/ +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT + static void pagerEnter(Pager *p){ + p->iInUseDB++; + if( p->iInUseMM && p->iInUseDB==1 ){ + sqlite3_mutex *mutex; + mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MEM2); + p->iInUseDB = 0; + sqlite3_mutex_enter(mutex); + p->iInUseDB = 1; + sqlite3_mutex_leave(mutex); + } + assert( p->iInUseMM==0 ); + } + static void pagerLeave(Pager *p){ + p->iInUseDB--; + assert( p->iInUseDB>=0 ); + } +#else +# define pagerEnter(X) +# define pagerLeave(X) +#endif + +/* +** Enable reference count tracking (for debugging) here: +*/ +#ifdef SQLITE_DEBUG + int pager3_refinfo_enable = 0; + static void pager_refinfo(PgHdr *p){ + static int cnt = 0; + if( !pager3_refinfo_enable ) return; + sqlite3DebugPrintf( + "REFCNT: %4d addr=%p nRef=%-3d total=%d\n", + p->pgno, PGHDR_TO_DATA(p), p->nRef, p->pPager->nRef + ); + cnt++; /* Something to set a breakpoint on */ + } +# define REFINFO(X) pager_refinfo(X) +#else +# define REFINFO(X) +#endif + +/* +** Add page pPg to the end of the linked list managed by structure +** pList (pPg becomes the last entry in the list - the most recently +** used). Argument pLink should point to either pPg->free or pPg->gfree, +** depending on whether pPg is being added to the pager-specific or +** global LRU list. +*/ +static void listAdd(PagerLruList *pList, PagerLruLink *pLink, PgHdr *pPg){ + pLink->pNext = 0; + pLink->pPrev = pList->pLast; + +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT + assert(pLink==&pPg->free || pLink==&pPg->gfree); + assert(pLink==&pPg->gfree || pList!=&sqlite3LruPageList); +#endif + + if( pList->pLast ){ + int iOff = (char *)pLink - (char *)pPg; + PagerLruLink *pLastLink = (PagerLruLink *)(&((u8 *)pList->pLast)[iOff]); + pLastLink->pNext = pPg; + }else{ + assert(!pList->pFirst); + pList->pFirst = pPg; + } + + pList->pLast = pPg; + if( !pList->pFirstSynced && pPg->needSync==0 ){ + pList->pFirstSynced = pPg; + } +} + +/* +** Remove pPg from the list managed by the structure pointed to by pList. +** +** Argument pLink should point to either pPg->free or pPg->gfree, depending +** on whether pPg is being added to the pager-specific or global LRU list. +*/ +static void listRemove(PagerLruList *pList, PagerLruLink *pLink, PgHdr *pPg){ + int iOff = (char *)pLink - (char *)pPg; + +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT + assert(pLink==&pPg->free || pLink==&pPg->gfree); + assert(pLink==&pPg->gfree || pList!=&sqlite3LruPageList); +#endif + + if( pPg==pList->pFirst ){ + pList->pFirst = pLink->pNext; + } + if( pPg==pList->pLast ){ + pList->pLast = pLink->pPrev; + } + if( pLink->pPrev ){ + PagerLruLink *pPrevLink = (PagerLruLink *)(&((u8 *)pLink->pPrev)[iOff]); + pPrevLink->pNext = pLink->pNext; + } + if( pLink->pNext ){ + PagerLruLink *pNextLink = (PagerLruLink *)(&((u8 *)pLink->pNext)[iOff]); + pNextLink->pPrev = pLink->pPrev; + } + if( pPg==pList->pFirstSynced ){ + PgHdr *p = pLink->pNext; + while( p && p->needSync ){ + PagerLruLink *pL = (PagerLruLink *)(&((u8 *)p)[iOff]); + p = pL->pNext; + } + pList->pFirstSynced = p; + } + + pLink->pNext = pLink->pPrev = 0; +} + +/* +** Add page pPg to the list of free pages for the pager. If +** memory-management is enabled, also add the page to the global +** list of free pages. +*/ +static void lruListAdd(PgHdr *pPg){ + listAdd(&pPg->pPager->lru, &pPg->free, pPg); +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT + if( !pPg->pPager->memDb ){ + sqlite3_mutex_enter(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU)); + listAdd(&sqlite3LruPageList, &pPg->gfree, pPg); + sqlite3_mutex_leave(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU)); + } +#endif +} + +/* +** Remove page pPg from the list of free pages for the associated pager. +** If memory-management is enabled, also remove pPg from the global list +** of free pages. +*/ +static void lruListRemove(PgHdr *pPg){ + listRemove(&pPg->pPager->lru, &pPg->free, pPg); +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT + if( !pPg->pPager->memDb ){ + sqlite3_mutex_enter(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU)); + listRemove(&sqlite3LruPageList, &pPg->gfree, pPg); + sqlite3_mutex_leave(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU)); + } +#endif +} + +/* +** This function is called just after the needSync flag has been cleared +** from all pages managed by pPager (usually because the journal file +** has just been synced). It updates the pPager->lru.pFirstSynced variable +** and, if memory-management is enabled, the sqlite3LruPageList.pFirstSynced +** variable also. +*/ +static void lruListSetFirstSynced(Pager *pPager){ + pPager->lru.pFirstSynced = pPager->lru.pFirst; +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT + if( !pPager->memDb ){ + PgHdr *p; + sqlite3_mutex_enter(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU)); + for(p=sqlite3LruPageList.pFirst; p && p->needSync; p=p->gfree.pNext); + assert(p==pPager->lru.pFirstSynced || p==sqlite3LruPageList.pFirstSynced); + sqlite3LruPageList.pFirstSynced = p; + sqlite3_mutex_leave(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU)); + } +#endif +} + +/* +** Return true if page *pPg has already been written to the statement +** journal (or statement snapshot has been created, if *pPg is part +** of an in-memory database). +*/ +static int pageInStatement(PgHdr *pPg){ + Pager *pPager = pPg->pPager; + if( MEMDB ){ + return PGHDR_TO_HIST(pPg, pPager)->inStmt; + }else{ + Pgno pgno = pPg->pgno; + u8 *a = pPager->aInStmt; + return (a && (int)pgno<=pPager->stmtSize && (a[pgno/8] & (1<<(pgno&7)))); + } +} + +/* +** Change the size of the pager hash table to N. N must be a power +** of two. +*/ +static void pager_resize_hash_table(Pager *pPager, int N){ + PgHdr **aHash, *pPg; + assert( N>0 && (N&(N-1))==0 ); + pagerLeave(pPager); + sqlite3MallocBenignFailure((int)pPager->aHash); + aHash = (PgHdr**)sqlite3MallocZero( sizeof(aHash[0])*N ); + pagerEnter(pPager); + if( aHash==0 ){ + /* Failure to rehash is not an error. It is only a performance hit. */ + return; + } + sqlite3_free(pPager->aHash); + pPager->nHash = N; + pPager->aHash = aHash; + for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){ + int h; + if( pPg->pgno==0 ){ + assert( pPg->pNextHash==0 && pPg->pPrevHash==0 ); + continue; + } + h = pPg->pgno & (N-1); + pPg->pNextHash = aHash[h]; + if( aHash[h] ){ + aHash[h]->pPrevHash = pPg; + } + aHash[h] = pPg; + pPg->pPrevHash = 0; + } +} + +/* +** Read a 32-bit integer from the given file descriptor. Store the integer +** that is read in *pRes. Return SQLITE_OK if everything worked, or an +** error code is something goes wrong. +** +** All values are stored on disk as big-endian. +*/ +static int read32bits(sqlite3_file *fd, i64 offset, u32 *pRes){ + unsigned char ac[4]; + int rc = sqlite3OsRead(fd, ac, sizeof(ac), offset); + if( rc==SQLITE_OK ){ + *pRes = sqlite3Get4byte(ac); + } + return rc; +} + +/* +** Write a 32-bit integer into a string buffer in big-endian byte order. +*/ +#define put32bits(A,B) sqlite3Put4byte((u8*)A,B) + +/* +** Write a 32-bit integer into the given file descriptor. Return SQLITE_OK +** on success or an error code is something goes wrong. +*/ +static int write32bits(sqlite3_file *fd, i64 offset, u32 val){ + char ac[4]; + put32bits(ac, val); + return sqlite3OsWrite(fd, ac, 4, offset); +} + +/* +** If file pFd is open, call sqlite3OsUnlock() on it. +*/ +static int osUnlock(sqlite3_file *pFd, int eLock){ + if( !pFd->isOpen ){ + return SQLITE_OK; + } + return sqlite3OsUnlock(pFd, eLock); +} + +/* +** This function determines whether or not the atomic-write optimization +** can be used with this pager. The optimization can be used if: +** +** (a) the value returned by OsDeviceCharacteristics() indicates that +** a database page may be written atomically, and +** (b) the value returned by OsSectorSize() is less than or equal +** to the page size. +** +** If the optimization cannot be used, 0 is returned. If it can be used, +** then the value returned is the size of the journal file when it +** contains rollback data for exactly one page. +*/ +#ifdef SQLITE_ENABLE_ATOMIC_WRITE +static int jrnlBufferSize(Pager *pPager){ + int dc; /* Device characteristics */ + int nSector; /* Sector size */ + int nPage; /* Page size */ + sqlite3_file *fd = pPager->fd; + + if( fd->pMethods ){ + dc = sqlite3OsDeviceCharacteristics(fd); + nSector = sqlite3OsSectorSize(fd); + nPage = pPager->pageSize; + } + + assert(SQLITE_IOCAP_ATOMIC512==(512>>8)); + assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8)); + + if( !fd->pMethods || (dc&(SQLITE_IOCAP_ATOMIC|(nPage>>8))&&nSector<=nPage) ){ + return JOURNAL_HDR_SZ(pPager) + JOURNAL_PG_SZ(pPager); + } + return 0; +} +#endif + +/* +** This function should be called when an error occurs within the pager +** code. The first argument is a pointer to the pager structure, the +** second the error-code about to be returned by a pager API function. +** The value returned is a copy of the second argument to this function. +** +** If the second argument is SQLITE_IOERR, SQLITE_CORRUPT, or SQLITE_FULL +** the error becomes persistent. Until the persisten error is cleared, +** subsequent API calls on this Pager will immediately return the same +** error code. +** +** A persistent error indicates that the contents of the pager-cache +** cannot be trusted. This state can be cleared by completely discarding +** the contents of the pager-cache. If a transaction was active when +** the persistent error occured, then the rollback journal may need +** to be replayed. +*/ +static void pager_unlock(Pager *pPager); +static int pager_error(Pager *pPager, int rc){ + int rc2 = rc & 0xff; + assert( + pPager->errCode==SQLITE_FULL || + pPager->errCode==SQLITE_OK || + (pPager->errCode & 0xff)==SQLITE_IOERR + ); + if( + rc2==SQLITE_FULL || + rc2==SQLITE_IOERR || + rc2==SQLITE_CORRUPT + ){ + pPager->errCode = rc; + if( pPager->state==PAGER_UNLOCK && pPager->nRef==0 ){ + /* If the pager is already unlocked, call pager_unlock() now to + ** clear the error state and ensure that the pager-cache is + ** completely empty. + */ + pager_unlock(pPager); + } + } + return rc; +} + +/* +** If SQLITE_CHECK_PAGES is defined then we do some sanity checking +** on the cache using a hash function. This is used for testing +** and debugging only. +*/ +#ifdef SQLITE_CHECK_PAGES +/* +** Return a 32-bit hash of the page data for pPage. +*/ +static u32 pager_datahash(int nByte, unsigned char *pData){ + u32 hash = 0; + int i; + for(i=0; ipPager->pageSize, + (unsigned char *)PGHDR_TO_DATA(pPage)); +} + +/* +** The CHECK_PAGE macro takes a PgHdr* as an argument. If SQLITE_CHECK_PAGES +** is defined, and NDEBUG is not defined, an assert() statement checks +** that the page is either dirty or still matches the calculated page-hash. +*/ +#define CHECK_PAGE(x) checkPage(x) +static void checkPage(PgHdr *pPg){ + Pager *pPager = pPg->pPager; + assert( !pPg->pageHash || pPager->errCode || MEMDB || pPg->dirty || + pPg->pageHash==pager_pagehash(pPg) ); +} + +#else +#define pager_datahash(X,Y) 0 +#define pager_pagehash(X) 0 +#define CHECK_PAGE(x) +#endif + +/* +** When this is called the journal file for pager pPager must be open. +** The master journal file name is read from the end of the file and +** written into memory supplied by the caller. +** +** zMaster must point to a buffer of at least nMaster bytes allocated by +** the caller. This should be sqlite3_vfs.mxPathname+1 (to ensure there is +** enough space to write the master journal name). If the master journal +** name in the journal is longer than nMaster bytes (including a +** nul-terminator), then this is handled as if no master journal name +** were present in the journal. +** +** If no master journal file name is present zMaster[0] is set to 0 and +** SQLITE_OK returned. +*/ +static int readMasterJournal(sqlite3_file *pJrnl, char *zMaster, int nMaster){ + int rc; + u32 len; + i64 szJ; + u32 cksum; + int i; + unsigned char aMagic[8]; /* A buffer to hold the magic header */ + + zMaster[0] = '\0'; + + rc = sqlite3OsFileSize(pJrnl, &szJ); + if( rc!=SQLITE_OK || szJ<16 ) return rc; + + rc = read32bits(pJrnl, szJ-16, &len); + if( rc!=SQLITE_OK ) return rc; + + if( len>=nMaster ){ + return SQLITE_OK; + } + + rc = read32bits(pJrnl, szJ-12, &cksum); + if( rc!=SQLITE_OK ) return rc; + + rc = sqlite3OsRead(pJrnl, aMagic, 8, szJ-8); + if( rc!=SQLITE_OK || memcmp(aMagic, aJournalMagic, 8) ) return rc; + + rc = sqlite3OsRead(pJrnl, zMaster, len, szJ-16-len); + if( rc!=SQLITE_OK ){ + return rc; + } + zMaster[len] = '\0'; + + /* See if the checksum matches the master journal name */ + for(i=0; ijournalOff; + if( c ){ + offset = ((c-1)/JOURNAL_HDR_SZ(pPager) + 1) * JOURNAL_HDR_SZ(pPager); + } + assert( offset%JOURNAL_HDR_SZ(pPager)==0 ); + assert( offset>=c ); + assert( (offset-c)journalOff = offset; +} + +/* +** The journal file must be open when this routine is called. A journal +** header (JOURNAL_HDR_SZ bytes) is written into the journal file at the +** current location. +** +** The format for the journal header is as follows: +** - 8 bytes: Magic identifying journal format. +** - 4 bytes: Number of records in journal, or -1 no-sync mode is on. +** - 4 bytes: Random number used for page hash. +** - 4 bytes: Initial database page count. +** - 4 bytes: Sector size used by the process that wrote this journal. +** +** Followed by (JOURNAL_HDR_SZ - 24) bytes of unused space. +*/ +static int writeJournalHdr(Pager *pPager){ + char zHeader[sizeof(aJournalMagic)+16]; + int rc; + + if( pPager->stmtHdrOff==0 ){ + pPager->stmtHdrOff = pPager->journalOff; + } + + seekJournalHdr(pPager); + pPager->journalHdr = pPager->journalOff; + + memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic)); + + /* + ** Write the nRec Field - the number of page records that follow this + ** journal header. Normally, zero is written to this value at this time. + ** After the records are added to the journal (and the journal synced, + ** if in full-sync mode), the zero is overwritten with the true number + ** of records (see syncJournal()). + ** + ** A faster alternative is to write 0xFFFFFFFF to the nRec field. When + ** reading the journal this value tells SQLite to assume that the + ** rest of the journal file contains valid page records. This assumption + ** is dangerous, as if a failure occured whilst writing to the journal + ** file it may contain some garbage data. There are two scenarios + ** where this risk can be ignored: + ** + ** * When the pager is in no-sync mode. Corruption can follow a + ** power failure in this case anyway. + ** + ** * When the SQLITE_IOCAP_SAFE_APPEND flag is set. This guarantees + ** that garbage data is never appended to the journal file. + */ + assert(pPager->fd->pMethods||pPager->noSync); + if( (pPager->noSync) + || (sqlite3OsDeviceCharacteristics(pPager->fd)&SQLITE_IOCAP_SAFE_APPEND) + ){ + put32bits(&zHeader[sizeof(aJournalMagic)], 0xffffffff); + }else{ + put32bits(&zHeader[sizeof(aJournalMagic)], 0); + } + + /* The random check-hash initialiser */ + sqlite3Randomness(sizeof(pPager->cksumInit), &pPager->cksumInit); + put32bits(&zHeader[sizeof(aJournalMagic)+4], pPager->cksumInit); + /* The initial database size */ + put32bits(&zHeader[sizeof(aJournalMagic)+8], pPager->dbSize); + /* The assumed sector size for this process */ + put32bits(&zHeader[sizeof(aJournalMagic)+12], pPager->sectorSize); + IOTRACE(("JHDR %p %lld %d\n", pPager, pPager->journalHdr, sizeof(zHeader))) + rc = sqlite3OsWrite(pPager->jfd, zHeader, sizeof(zHeader),pPager->journalOff); + pPager->journalOff += JOURNAL_HDR_SZ(pPager); + + /* The journal header has been written successfully. Seek the journal + ** file descriptor to the end of the journal header sector. + */ + if( rc==SQLITE_OK ){ + IOTRACE(("JTAIL %p %lld\n", pPager, pPager->journalOff-1)) + rc = sqlite3OsWrite(pPager->jfd, "\000", 1, pPager->journalOff-1); + } + return rc; +} + +/* +** The journal file must be open when this is called. A journal header file +** (JOURNAL_HDR_SZ bytes) is read from the current location in the journal +** file. See comments above function writeJournalHdr() for a description of +** the journal header format. +** +** If the header is read successfully, *nRec is set to the number of +** page records following this header and *dbSize is set to the size of the +** database before the transaction began, in pages. Also, pPager->cksumInit +** is set to the value read from the journal header. SQLITE_OK is returned +** in this case. +** +** If the journal header file appears to be corrupted, SQLITE_DONE is +** returned and *nRec and *dbSize are not set. If JOURNAL_HDR_SZ bytes +** cannot be read from the journal file an error code is returned. +*/ +static int readJournalHdr( + Pager *pPager, + i64 journalSize, + u32 *pNRec, + u32 *pDbSize +){ + int rc; + unsigned char aMagic[8]; /* A buffer to hold the magic header */ + i64 jrnlOff; + + seekJournalHdr(pPager); + if( pPager->journalOff+JOURNAL_HDR_SZ(pPager) > journalSize ){ + return SQLITE_DONE; + } + jrnlOff = pPager->journalOff; + + rc = sqlite3OsRead(pPager->jfd, aMagic, sizeof(aMagic), jrnlOff); + if( rc ) return rc; + jrnlOff += sizeof(aMagic); + + if( memcmp(aMagic, aJournalMagic, sizeof(aMagic))!=0 ){ + return SQLITE_DONE; + } + + rc = read32bits(pPager->jfd, jrnlOff, pNRec); + if( rc ) return rc; + + rc = read32bits(pPager->jfd, jrnlOff+4, &pPager->cksumInit); + if( rc ) return rc; + + rc = read32bits(pPager->jfd, jrnlOff+8, pDbSize); + if( rc ) return rc; + + /* Update the assumed sector-size to match the value used by + ** the process that created this journal. If this journal was + ** created by a process other than this one, then this routine + ** is being called from within pager_playback(). The local value + ** of Pager.sectorSize is restored at the end of that routine. + */ + rc = read32bits(pPager->jfd, jrnlOff+12, (u32 *)&pPager->sectorSize); + if( rc ) return rc; + + pPager->journalOff += JOURNAL_HDR_SZ(pPager); + return SQLITE_OK; +} + + +/* +** Write the supplied master journal name into the journal file for pager +** pPager at the current location. The master journal name must be the last +** thing written to a journal file. If the pager is in full-sync mode, the +** journal file descriptor is advanced to the next sector boundary before +** anything is written. The format is: +** +** + 4 bytes: PAGER_MJ_PGNO. +** + N bytes: length of master journal name. +** + 4 bytes: N +** + 4 bytes: Master journal name checksum. +** + 8 bytes: aJournalMagic[]. +** +** The master journal page checksum is the sum of the bytes in the master +** journal name. +** +** If zMaster is a NULL pointer (occurs for a single database transaction), +** this call is a no-op. +*/ +static int writeMasterJournal(Pager *pPager, const char *zMaster){ + int rc; + int len; + int i; + i64 jrnlOff; + u32 cksum = 0; + char zBuf[sizeof(aJournalMagic)+2*4]; + + if( !zMaster || pPager->setMaster) return SQLITE_OK; + pPager->setMaster = 1; + + len = strlen(zMaster); + for(i=0; ifullSync ){ + seekJournalHdr(pPager); + } + jrnlOff = pPager->journalOff; + pPager->journalOff += (len+20); + + rc = write32bits(pPager->jfd, jrnlOff, PAGER_MJ_PGNO(pPager)); + if( rc!=SQLITE_OK ) return rc; + jrnlOff += 4; + + rc = sqlite3OsWrite(pPager->jfd, zMaster, len, jrnlOff); + if( rc!=SQLITE_OK ) return rc; + jrnlOff += len; + + put32bits(zBuf, len); + put32bits(&zBuf[4], cksum); + memcpy(&zBuf[8], aJournalMagic, sizeof(aJournalMagic)); + rc = sqlite3OsWrite(pPager->jfd, zBuf, 8+sizeof(aJournalMagic), jrnlOff); + pPager->needSync = !pPager->noSync; + return rc; +} + +/* +** Add or remove a page from the list of all pages that are in the +** statement journal. +** +** The Pager keeps a separate list of pages that are currently in +** the statement journal. This helps the sqlite3PagerStmtCommit() +** routine run MUCH faster for the common case where there are many +** pages in memory but only a few are in the statement journal. +*/ +static void page_add_to_stmt_list(PgHdr *pPg){ + Pager *pPager = pPg->pPager; + PgHistory *pHist = PGHDR_TO_HIST(pPg, pPager); + assert( MEMDB ); + if( !pHist->inStmt ){ + assert( pHist->pPrevStmt==0 && pHist->pNextStmt==0 ); + if( pPager->pStmt ){ + PGHDR_TO_HIST(pPager->pStmt, pPager)->pPrevStmt = pPg; + } + pHist->pNextStmt = pPager->pStmt; + pPager->pStmt = pPg; + pHist->inStmt = 1; + } +} + +/* +** Find a page in the hash table given its page number. Return +** a pointer to the page or NULL if not found. +*/ +static PgHdr *pager_lookup(Pager *pPager, Pgno pgno){ + PgHdr *p; + if( pPager->aHash==0 ) return 0; + p = pPager->aHash[pgno & (pPager->nHash-1)]; + while( p && p->pgno!=pgno ){ + p = p->pNextHash; + } + return p; +} + +/* +** Clear the in-memory cache. This routine +** sets the state of the pager back to what it was when it was first +** opened. Any outstanding pages are invalidated and subsequent attempts +** to access those pages will likely result in a coredump. +*/ +static void pager_reset(Pager *pPager){ + PgHdr *pPg, *pNext; + if( pPager->errCode ) return; + for(pPg=pPager->pAll; pPg; pPg=pNext){ + IOTRACE(("PGFREE %p %d\n", pPager, pPg->pgno)); + PAGER_INCR(sqlite3_pager_pgfree_count); + pNext = pPg->pNextAll; + lruListRemove(pPg); + sqlite3_free(pPg); + } + assert(pPager->lru.pFirst==0); + assert(pPager->lru.pFirstSynced==0); + assert(pPager->lru.pLast==0); + pPager->pStmt = 0; + pPager->pAll = 0; + pPager->pDirty = 0; + pPager->nHash = 0; + sqlite3_free(pPager->aHash); + pPager->nPage = 0; + pPager->aHash = 0; + pPager->nRef = 0; +} + +/* +** Unlock the database file. +** +** If the pager is currently in error state, discard the contents of +** the cache and reset the Pager structure internal state. If there is +** an open journal-file, then the next time a shared-lock is obtained +** on the pager file (by this or any other process), it will be +** treated as a hot-journal and rolled back. +*/ +static void pager_unlock(Pager *pPager){ + if( !pPager->exclusiveMode ){ + if( !MEMDB ){ + if( pPager->fd->isOpen ){ + osUnlock(pPager->fd, NO_LOCK); + } + pPager->dbSize = -1; + IOTRACE(("UNLOCK %p\n", pPager)) + + /* If Pager.errCode is set, the contents of the pager cache cannot be + ** trusted. Now that the pager file is unlocked, the contents of the + ** cache can be discarded and the error code safely cleared. + */ + if( pPager->errCode ){ + pPager->errCode = SQLITE_OK; + pager_reset(pPager); + if( pPager->stmtOpen ){ + sqlite3OsClose(pPager->stfd); + sqlite3_free(pPager->aInStmt); + pPager->aInStmt = 0; + } + if( pPager->journalOpen ){ + sqlite3OsClose(pPager->jfd); + pPager->journalOpen = 0; + sqlite3_free(pPager->aInJournal); + pPager->aInJournal = 0; + } + pPager->stmtOpen = 0; + pPager->stmtInUse = 0; + pPager->journalOff = 0; + pPager->journalStarted = 0; + pPager->stmtAutoopen = 0; + pPager->origDbSize = 0; + } + } + + if( !MEMDB || pPager->errCode==SQLITE_OK ){ + pPager->state = PAGER_UNLOCK; + pPager->changeCountDone = 0; + } + } +} + +/* +** Execute a rollback if a transaction is active and unlock the +** database file. If the pager has already entered the error state, +** do not attempt the rollback. +*/ +static void pagerUnlockAndRollback(Pager *p){ + assert( p->state>=PAGER_RESERVED || p->journalOpen==0 ); + if( p->errCode==SQLITE_OK && p->state>=PAGER_RESERVED ){ + sqlite3PagerRollback(p); + } + pager_unlock(p); + assert( p->errCode || !p->journalOpen || (p->exclusiveMode&&!p->journalOff) ); + assert( p->errCode || !p->stmtOpen || p->exclusiveMode ); +} + +/* +** This routine ends a transaction. A transaction is ended by either +** a COMMIT or a ROLLBACK. +** +** When this routine is called, the pager has the journal file open and +** a RESERVED or EXCLUSIVE lock on the database. This routine will release +** the database lock and acquires a SHARED lock in its place if that is +** the appropriate thing to do. Release locks usually is appropriate, +** unless we are in exclusive access mode or unless this is a +** COMMIT AND BEGIN or ROLLBACK AND BEGIN operation. +** +** The journal file is either deleted or truncated. +** +** TODO: Consider keeping the journal file open for temporary databases. +** This might give a performance improvement on windows where opening +** a file is an expensive operation. +*/ +static int pager_end_transaction(Pager *pPager){ + PgHdr *pPg; + int rc = SQLITE_OK; + int rc2 = SQLITE_OK; + assert( !MEMDB ); + if( pPager->statestmtOpen && !pPager->exclusiveMode ){ + sqlite3OsClose(pPager->stfd); + pPager->stmtOpen = 0; + } + if( pPager->journalOpen ){ + if( pPager->exclusiveMode + && (rc = sqlite3OsTruncate(pPager->jfd, 0))==SQLITE_OK ){; + pPager->journalOff = 0; + pPager->journalStarted = 0; + }else{ + sqlite3OsClose(pPager->jfd); + pPager->journalOpen = 0; + if( rc==SQLITE_OK ){ + rc = sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0); + } + } + sqlite3_free( pPager->aInJournal ); + pPager->aInJournal = 0; + for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){ + pPg->inJournal = 0; + pPg->dirty = 0; + pPg->needSync = 0; + pPg->alwaysRollback = 0; +#ifdef SQLITE_CHECK_PAGES + pPg->pageHash = pager_pagehash(pPg); +#endif + } + pPager->pDirty = 0; + pPager->dirtyCache = 0; + pPager->nRec = 0; + }else{ + assert( pPager->aInJournal==0 ); + assert( pPager->dirtyCache==0 || pPager->useJournal==0 ); + } + + if( !pPager->exclusiveMode ){ + rc2 = osUnlock(pPager->fd, SHARED_LOCK); + pPager->state = PAGER_SHARED; + }else if( pPager->state==PAGER_SYNCED ){ + pPager->state = PAGER_EXCLUSIVE; + } + pPager->origDbSize = 0; + pPager->setMaster = 0; + pPager->needSync = 0; + lruListSetFirstSynced(pPager); + pPager->dbSize = -1; + + return (rc==SQLITE_OK?rc2:rc); +} + +/* +** Compute and return a checksum for the page of data. +** +** This is not a real checksum. It is really just the sum of the +** random initial value and the page number. We experimented with +** a checksum of the entire data, but that was found to be too slow. +** +** Note that the page number is stored at the beginning of data and +** the checksum is stored at the end. This is important. If journal +** corruption occurs due to a power failure, the most likely scenario +** is that one end or the other of the record will be changed. It is +** much less likely that the two ends of the journal record will be +** correct and the middle be corrupt. Thus, this "checksum" scheme, +** though fast and simple, catches the mostly likely kind of corruption. +** +** FIX ME: Consider adding every 200th (or so) byte of the data to the +** checksum. That way if a single page spans 3 or more disk sectors and +** only the middle sector is corrupt, we will still have a reasonable +** chance of failing the checksum and thus detecting the problem. +*/ +static u32 pager_cksum(Pager *pPager, const u8 *aData){ + u32 cksum = pPager->cksumInit; + int i = pPager->pageSize-200; + while( i>0 ){ + cksum += aData[i]; + i -= 200; + } + return cksum; +} + +/* Forward declaration */ +static void makeClean(PgHdr*); + +/* +** Read a single page from the journal file opened on file descriptor +** jfd. Playback this one page. +** +** If useCksum==0 it means this journal does not use checksums. Checksums +** are not used in statement journals because statement journals do not +** need to survive power failures. +*/ +static int pager_playback_one_page( + Pager *pPager, + sqlite3_file *jfd, + i64 offset, + int useCksum +){ + int rc; + PgHdr *pPg; /* An existing page in the cache */ + Pgno pgno; /* The page number of a page in journal */ + u32 cksum; /* Checksum used for sanity checking */ + u8 *aData = (u8 *)pPager->pTmpSpace; /* Temp storage for a page */ + + /* useCksum should be true for the main journal and false for + ** statement journals. Verify that this is always the case + */ + assert( jfd == (useCksum ? pPager->jfd : pPager->stfd) ); + assert( aData ); + + rc = read32bits(jfd, offset, &pgno); + if( rc!=SQLITE_OK ) return rc; + rc = sqlite3OsRead(jfd, aData, pPager->pageSize, offset+4); + if( rc!=SQLITE_OK ) return rc; + pPager->journalOff += pPager->pageSize + 4; + + /* Sanity checking on the page. This is more important that I originally + ** thought. If a power failure occurs while the journal is being written, + ** it could cause invalid data to be written into the journal. We need to + ** detect this invalid data (with high probability) and ignore it. + */ + if( pgno==0 || pgno==PAGER_MJ_PGNO(pPager) ){ + return SQLITE_DONE; + } + if( pgno>(unsigned)pPager->dbSize ){ + return SQLITE_OK; + } + if( useCksum ){ + rc = read32bits(jfd, offset+pPager->pageSize+4, &cksum); + if( rc ) return rc; + pPager->journalOff += 4; + if( pager_cksum(pPager, aData)!=cksum ){ + return SQLITE_DONE; + } + } + + assert( pPager->state==PAGER_RESERVED || pPager->state>=PAGER_EXCLUSIVE ); + + /* If the pager is in RESERVED state, then there must be a copy of this + ** page in the pager cache. In this case just update the pager cache, + ** not the database file. The page is left marked dirty in this case. + ** + ** An exception to the above rule: If the database is in no-sync mode + ** and a page is moved during an incremental vacuum then the page may + ** not be in the pager cache. Later: if a malloc() or IO error occurs + ** during a Movepage() call, then the page may not be in the cache + ** either. So the condition described in the above paragraph is not + ** assert()able. + ** + ** If in EXCLUSIVE state, then we update the pager cache if it exists + ** and the main file. The page is then marked not dirty. + ** + ** Ticket #1171: The statement journal might contain page content that is + ** different from the page content at the start of the transaction. + ** This occurs when a page is changed prior to the start of a statement + ** then changed again within the statement. When rolling back such a + ** statement we must not write to the original database unless we know + ** for certain that original page contents are synced into the main rollback + ** journal. Otherwise, a power loss might leave modified data in the + ** database file without an entry in the rollback journal that can + ** restore the database to its original form. Two conditions must be + ** met before writing to the database files. (1) the database must be + ** locked. (2) we know that the original page content is fully synced + ** in the main journal either because the page is not in cache or else + ** the page is marked as needSync==0. + */ + pPg = pager_lookup(pPager, pgno); + PAGERTRACE4("PLAYBACK %d page %d hash(%08x)\n", + PAGERID(pPager), pgno, pager_datahash(pPager->pageSize, aData)); + if( pPager->state>=PAGER_EXCLUSIVE && (pPg==0 || pPg->needSync==0) ){ + i64 offset = (pgno-1)*(i64)pPager->pageSize; + rc = sqlite3OsWrite(pPager->fd, aData, pPager->pageSize, offset); + if( pPg ){ + makeClean(pPg); + } + } + if( pPg ){ + /* No page should ever be explicitly rolled back that is in use, except + ** for page 1 which is held in use in order to keep the lock on the + ** database active. However such a page may be rolled back as a result + ** of an internal error resulting in an automatic call to + ** sqlite3PagerRollback(). + */ + void *pData; + /* assert( pPg->nRef==0 || pPg->pgno==1 ); */ + pData = PGHDR_TO_DATA(pPg); + memcpy(pData, aData, pPager->pageSize); + if( pPager->xReiniter ){ + pPager->xReiniter(pPg, pPager->pageSize); + } +#ifdef SQLITE_CHECK_PAGES + pPg->pageHash = pager_pagehash(pPg); +#endif + /* If this was page 1, then restore the value of Pager.dbFileVers. + ** Do this before any decoding. */ + if( pgno==1 ){ + memcpy(&pPager->dbFileVers, &((u8*)pData)[24],sizeof(pPager->dbFileVers)); + } + + /* Decode the page just read from disk */ + CODEC1(pPager, pData, pPg->pgno, 3); + } + return rc; +} + +/* +** Parameter zMaster is the name of a master journal file. A single journal +** file that referred to the master journal file has just been rolled back. +** This routine checks if it is possible to delete the master journal file, +** and does so if it is. +** +** Argument zMaster may point to Pager.pTmpSpace. So that buffer is not +** available for use within this function. +** +** +** The master journal file contains the names of all child journals. +** To tell if a master journal can be deleted, check to each of the +** children. If all children are either missing or do not refer to +** a different master journal, then this master journal can be deleted. +*/ +static int pager_delmaster(Pager *pPager, const char *zMaster){ + sqlite3_vfs *pVfs = pPager->pVfs; + int rc; + int master_open = 0; + sqlite3_file *pMaster; + sqlite3_file *pJournal; + char *zMasterJournal = 0; /* Contents of master journal file */ + i64 nMasterJournal; /* Size of master journal file */ + + /* Open the master journal file exclusively in case some other process + ** is running this routine also. Not that it makes too much difference. + */ + pMaster = (sqlite3_file *)sqlite3_malloc(pVfs->szOsFile * 2); + pJournal = (sqlite3_file *)(((u8 *)pMaster) + pVfs->szOsFile); + if( !pMaster ){ + rc = SQLITE_NOMEM; + }else{ + int flags = (SQLITE_OPEN_READONLY|SQLITE_OPEN_MASTER_JOURNAL); + rc = sqlite3OsOpen(pVfs, zMaster, pMaster, flags, 0); + } + if( rc!=SQLITE_OK ) goto delmaster_out; + master_open = 1; + + rc = sqlite3OsFileSize(pMaster, &nMasterJournal); + if( rc!=SQLITE_OK ) goto delmaster_out; + + if( nMasterJournal>0 ){ + char *zJournal; + char *zMasterPtr = 0; + int nMasterPtr = pPager->pVfs->mxPathname+1; + + /* Load the entire master journal file into space obtained from + ** sqlite3_malloc() and pointed to by zMasterJournal. + */ + zMasterJournal = (char *)sqlite3_malloc(nMasterJournal + nMasterPtr); + if( !zMasterJournal ){ + rc = SQLITE_NOMEM; + goto delmaster_out; + } + zMasterPtr = &zMasterJournal[nMasterJournal]; + rc = sqlite3OsRead(pMaster, zMasterJournal, nMasterJournal, 0); + if( rc!=SQLITE_OK ) goto delmaster_out; + + zJournal = zMasterJournal; + while( (zJournal-zMasterJournal)state>=PAGER_EXCLUSIVE && pPager->fd->isOpen ){ + i64 currentSize, newSize; + rc = sqlite3OsFileSize(pPager->fd, ¤tSize); + newSize = pPager->pageSize*(i64)nPage; + if( rc==SQLITE_OK && currentSize>newSize ){ + rc = sqlite3OsTruncate(pPager->fd, newSize); + } + } + if( rc==SQLITE_OK ){ + pPager->dbSize = nPage; + pager_truncate_cache(pPager); + } + return rc; +} + +/* +** Set the sectorSize for the given pager. +** +** The sector size is the larger of the sector size reported +** by sqlite3OsSectorSize() and the pageSize. +*/ +static void setSectorSize(Pager *pPager){ + assert(pPager->fd->pMethods||pPager->tempFile); + if( !pPager->tempFile ){ + /* Sector size doesn't matter for temporary files. Also, the file + ** may not have been opened yet, in whcih case the OsSectorSize() + ** call will segfault. + */ + pPager->sectorSize = sqlite3OsSectorSize(pPager->fd); + } + if( pPager->sectorSizepageSize ){ + pPager->sectorSize = pPager->pageSize; + } +} + +/* +** Playback the journal and thus restore the database file to +** the state it was in before we started making changes. +** +** The journal file format is as follows: +** +** (1) 8 byte prefix. A copy of aJournalMagic[]. +** (2) 4 byte big-endian integer which is the number of valid page records +** in the journal. If this value is 0xffffffff, then compute the +** number of page records from the journal size. +** (3) 4 byte big-endian integer which is the initial value for the +** sanity checksum. +** (4) 4 byte integer which is the number of pages to truncate the +** database to during a rollback. +** (5) 4 byte integer which is the number of bytes in the master journal +** name. The value may be zero (indicate that there is no master +** journal.) +** (6) N bytes of the master journal name. The name will be nul-terminated +** and might be shorter than the value read from (5). If the first byte +** of the name is \000 then there is no master journal. The master +** journal name is stored in UTF-8. +** (7) Zero or more pages instances, each as follows: +** + 4 byte page number. +** + pPager->pageSize bytes of data. +** + 4 byte checksum +** +** When we speak of the journal header, we mean the first 6 items above. +** Each entry in the journal is an instance of the 7th item. +** +** Call the value from the second bullet "nRec". nRec is the number of +** valid page entries in the journal. In most cases, you can compute the +** value of nRec from the size of the journal file. But if a power +** failure occurred while the journal was being written, it could be the +** case that the size of the journal file had already been increased but +** the extra entries had not yet made it safely to disk. In such a case, +** the value of nRec computed from the file size would be too large. For +** that reason, we always use the nRec value in the header. +** +** If the nRec value is 0xffffffff it means that nRec should be computed +** from the file size. This value is used when the user selects the +** no-sync option for the journal. A power failure could lead to corruption +** in this case. But for things like temporary table (which will be +** deleted when the power is restored) we don't care. +** +** If the file opened as the journal file is not a well-formed +** journal file then all pages up to the first corrupted page are rolled +** back (or no pages if the journal header is corrupted). The journal file +** is then deleted and SQLITE_OK returned, just as if no corruption had +** been encountered. +** +** If an I/O or malloc() error occurs, the journal-file is not deleted +** and an error code is returned. +*/ +static int pager_playback(Pager *pPager, int isHot){ + sqlite3_vfs *pVfs = pPager->pVfs; + i64 szJ; /* Size of the journal file in bytes */ + u32 nRec; /* Number of Records in the journal */ + int i; /* Loop counter */ + Pgno mxPg = 0; /* Size of the original file in pages */ + int rc; /* Result code of a subroutine */ + char *zMaster = 0; /* Name of master journal file if any */ + + /* Figure out how many records are in the journal. Abort early if + ** the journal is empty. + */ + assert( pPager->journalOpen ); + rc = sqlite3OsFileSize(pPager->jfd, &szJ); + if( rc!=SQLITE_OK || szJ==0 ){ + goto end_playback; + } + + /* Read the master journal name from the journal, if it is present. + ** If a master journal file name is specified, but the file is not + ** present on disk, then the journal is not hot and does not need to be + ** played back. + */ + zMaster = pPager->pTmpSpace; + rc = readMasterJournal(pPager->jfd, zMaster, pPager->pVfs->mxPathname+1); + assert( rc!=SQLITE_DONE ); + if( rc!=SQLITE_OK + || (zMaster[0] && !sqlite3OsAccess(pVfs, zMaster, SQLITE_ACCESS_EXISTS)) + ){ + zMaster = 0; + if( rc==SQLITE_DONE ) rc = SQLITE_OK; + goto end_playback; + } + pPager->journalOff = 0; + zMaster = 0; + + /* This loop terminates either when the readJournalHdr() call returns + ** SQLITE_DONE or an IO error occurs. */ + while( 1 ){ + + /* Read the next journal header from the journal file. If there are + ** not enough bytes left in the journal file for a complete header, or + ** it is corrupted, then a process must of failed while writing it. + ** This indicates nothing more needs to be rolled back. + */ + rc = readJournalHdr(pPager, szJ, &nRec, &mxPg); + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_DONE ){ + rc = SQLITE_OK; + } + goto end_playback; + } + + /* If nRec is 0xffffffff, then this journal was created by a process + ** working in no-sync mode. This means that the rest of the journal + ** file consists of pages, there are no more journal headers. Compute + ** the value of nRec based on this assumption. + */ + if( nRec==0xffffffff ){ + assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) ); + nRec = (szJ - JOURNAL_HDR_SZ(pPager))/JOURNAL_PG_SZ(pPager); + } + + /* If nRec is 0 and this rollback is of a transaction created by this + ** process and if this is the final header in the journal, then it means + ** that this part of the journal was being filled but has not yet been + ** synced to disk. Compute the number of pages based on the remaining + ** size of the file. + ** + ** The third term of the test was added to fix ticket #2565. + */ + if( nRec==0 && !isHot && + pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff ){ + nRec = (szJ - pPager->journalOff) / JOURNAL_PG_SZ(pPager); + } + + /* If this is the first header read from the journal, truncate the + ** database file back to its original size. + */ + if( pPager->journalOff==JOURNAL_HDR_SZ(pPager) ){ + rc = pager_truncate(pPager, mxPg); + if( rc!=SQLITE_OK ){ + goto end_playback; + } + } + + /* Copy original pages out of the journal and back into the database file. + */ + for(i=0; ijfd, pPager->journalOff, 1); + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_DONE ){ + rc = SQLITE_OK; + pPager->journalOff = szJ; + break; + }else{ + goto end_playback; + } + } + } + } + /*NOTREACHED*/ + assert( 0 ); + +end_playback: + if( rc==SQLITE_OK ){ + zMaster = pPager->pTmpSpace; + rc = readMasterJournal(pPager->jfd, zMaster, pPager->pVfs->mxPathname+1); + } + if( rc==SQLITE_OK ){ + rc = pager_end_transaction(pPager); + } + if( rc==SQLITE_OK && zMaster[0] ){ + /* If there was a master journal and this routine will return success, + ** see if it is possible to delete the master journal. + */ + rc = pager_delmaster(pPager, zMaster); + } + + /* The Pager.sectorSize variable may have been updated while rolling + ** back a journal created by a process with a different sector size + ** value. Reset it to the correct value for this process. + */ + setSectorSize(pPager); + return rc; +} + +/* +** Playback the statement journal. +** +** This is similar to playing back the transaction journal but with +** a few extra twists. +** +** (1) The number of pages in the database file at the start of +** the statement is stored in pPager->stmtSize, not in the +** journal file itself. +** +** (2) In addition to playing back the statement journal, also +** playback all pages of the transaction journal beginning +** at offset pPager->stmtJSize. +*/ +static int pager_stmt_playback(Pager *pPager){ + i64 szJ; /* Size of the full journal */ + i64 hdrOff; + int nRec; /* Number of Records */ + int i; /* Loop counter */ + int rc; + + szJ = pPager->journalOff; +#ifndef NDEBUG + { + i64 os_szJ; + rc = sqlite3OsFileSize(pPager->jfd, &os_szJ); + if( rc!=SQLITE_OK ) return rc; + assert( szJ==os_szJ ); + } +#endif + + /* Set hdrOff to be the offset just after the end of the last journal + ** page written before the first journal-header for this statement + ** transaction was written, or the end of the file if no journal + ** header was written. + */ + hdrOff = pPager->stmtHdrOff; + assert( pPager->fullSync || !hdrOff ); + if( !hdrOff ){ + hdrOff = szJ; + } + + /* Truncate the database back to its original size. + */ + rc = pager_truncate(pPager, pPager->stmtSize); + assert( pPager->state>=PAGER_SHARED ); + + /* Figure out how many records are in the statement journal. + */ + assert( pPager->stmtInUse && pPager->journalOpen ); + nRec = pPager->stmtNRec; + + /* Copy original pages out of the statement journal and back into the + ** database file. Note that the statement journal omits checksums from + ** each record since power-failure recovery is not important to statement + ** journals. + */ + for(i=0; ipageSize); + rc = pager_playback_one_page(pPager, pPager->stfd, offset, 0); + assert( rc!=SQLITE_DONE ); + if( rc!=SQLITE_OK ) goto end_stmt_playback; + } + + /* Now roll some pages back from the transaction journal. Pager.stmtJSize + ** was the size of the journal file when this statement was started, so + ** everything after that needs to be rolled back, either into the + ** database, the memory cache, or both. + ** + ** If it is not zero, then Pager.stmtHdrOff is the offset to the start + ** of the first journal header written during this statement transaction. + */ + pPager->journalOff = pPager->stmtJSize; + pPager->cksumInit = pPager->stmtCksum; + while( pPager->journalOff < hdrOff ){ + rc = pager_playback_one_page(pPager, pPager->jfd, pPager->journalOff, 1); + assert( rc!=SQLITE_DONE ); + if( rc!=SQLITE_OK ) goto end_stmt_playback; + } + + while( pPager->journalOff < szJ ){ + u32 nJRec; /* Number of Journal Records */ + u32 dummy; + rc = readJournalHdr(pPager, szJ, &nJRec, &dummy); + if( rc!=SQLITE_OK ){ + assert( rc!=SQLITE_DONE ); + goto end_stmt_playback; + } + if( nJRec==0 ){ + nJRec = (szJ - pPager->journalOff) / (pPager->pageSize+8); + } + for(i=nJRec-1; i>=0 && pPager->journalOff < szJ; i--){ + rc = pager_playback_one_page(pPager, pPager->jfd, pPager->journalOff, 1); + assert( rc!=SQLITE_DONE ); + if( rc!=SQLITE_OK ) goto end_stmt_playback; + } + } + + pPager->journalOff = szJ; + +end_stmt_playback: + if( rc==SQLITE_OK) { + pPager->journalOff = szJ; + /* pager_reload_cache(pPager); */ + } + return rc; +} + +/* +** Change the maximum number of in-memory pages that are allowed. +*/ +void sqlite3PagerSetCachesize(Pager *pPager, int mxPage){ + if( mxPage>10 ){ + pPager->mxPage = mxPage; + }else{ + pPager->mxPage = 10; + } +} + +/* +** Adjust the robustness of the database to damage due to OS crashes +** or power failures by changing the number of syncs()s when writing +** the rollback journal. There are three levels: +** +** OFF sqlite3OsSync() is never called. This is the default +** for temporary and transient files. +** +** NORMAL The journal is synced once before writes begin on the +** database. This is normally adequate protection, but +** it is theoretically possible, though very unlikely, +** that an inopertune power failure could leave the journal +** in a state which would cause damage to the database +** when it is rolled back. +** +** FULL The journal is synced twice before writes begin on the +** database (with some additional information - the nRec field +** of the journal header - being written in between the two +** syncs). If we assume that writing a +** single disk sector is atomic, then this mode provides +** assurance that the journal will not be corrupted to the +** point of causing damage to the database during rollback. +** +** Numeric values associated with these states are OFF==1, NORMAL=2, +** and FULL=3. +*/ +#ifndef SQLITE_OMIT_PAGER_PRAGMAS +void sqlite3PagerSetSafetyLevel(Pager *pPager, int level, int full_fsync){ + pPager->noSync = level==1 || pPager->tempFile; + pPager->fullSync = level==3 && !pPager->tempFile; + pPager->sync_flags = (full_fsync?SQLITE_SYNC_FULL:SQLITE_SYNC_NORMAL); + if( pPager->noSync ) pPager->needSync = 0; +} +#endif + +/* +** The following global variable is incremented whenever the library +** attempts to open a temporary file. This information is used for +** testing and analysis only. +*/ +#ifdef SQLITE_TEST +int sqlite3_opentemp_count = 0; +#endif + +/* +** Open a temporary file. +** +** Write the file descriptor into *fd. Return SQLITE_OK on success or some +** other error code if we fail. The OS will automatically delete the temporary +** file when it is closed. +*/ +static int sqlite3PagerOpentemp( + sqlite3_vfs *pVfs, /* The virtual file system layer */ + sqlite3_file *pFile, /* Write the file descriptor here */ + char *zFilename, /* Name of the file. Might be NULL */ + int vfsFlags /* Flags passed through to the VFS */ +){ + int rc; + assert( zFilename!=0 ); + +#ifdef SQLITE_TEST + sqlite3_opentemp_count++; /* Used for testing and analysis only */ +#endif + + vfsFlags |= SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | + SQLITE_OPEN_EXCLUSIVE | SQLITE_OPEN_DELETEONCLOSE; + rc = sqlite3OsOpen(pVfs, zFilename, pFile, vfsFlags, 0); + assert( rc!=SQLITE_OK || pFile->pMethods ); + return rc; +} + + +//void fopenTest() +//{ +// FILE *fp = fopen("c:\\data\\redfivelabs\\temp\\sqlite.log", "w+"); +// if (fp != NULL) +// { +// char tmp[256]; +// sprintf(tmp, "Hallo Welt"); +// fwrite(tmp, strlen(tmp), 1, fp); +// fclose(fp); +// } +// return 191280; +//} + +/* +** Create a new page cache and put a pointer to the page cache in *ppPager. +** The file to be cached need not exist. The file is not locked until +** the first call to sqlite3PagerGet() and is only held open until the +** last page is released using sqlite3PagerUnref(). +** +** If zFilename is NULL then a randomly-named temporary file is created +** and used as the file to be cached. The file will be deleted +** automatically when it is closed. +** +** If zFilename is ":memory:" then all information is held in cache. +** It is never written to disk. This can be used to implement an +** in-memory database. +*/ +int sqlite3PagerOpen( + sqlite3_vfs *pVfs, /* The virtual file system to use */ + Pager **ppPager, /* Return the Pager structure here */ + const char *zFilename, /* Name of the database file to open */ + int nExtra, /* Extra bytes append to each in-memory page */ + int flags, /* flags controlling this file */ + int vfsFlags /* flags passed through to sqlite3_vfs.xOpen() */ +){ + u8 *pPtr; + Pager *pPager = 0; + int rc = SQLITE_OK; + int i; + int tempFile = 0; + int memDb = 0; + int readOnly = 0; + int useJournal = (flags & PAGER_OMIT_JOURNAL)==0; + int noReadlock = (flags & PAGER_NO_READLOCK)!=0; + int journalFileSize = sqlite3JournalSize(pVfs); + int nDefaultPage = SQLITE_DEFAULT_PAGE_SIZE; + char *zPathname; + int nPathname; + + + /* The default return is a NULL pointer */ + *ppPager = 0; + + /* Compute the full pathname */ + nPathname = pVfs->mxPathname+1; + zPathname = (char*)sqlite3_malloc(nPathname); + if( zPathname==0 ){ + return SQLITE_NOMEM; + } + if( zFilename && zFilename[0] ){ +#ifndef SQLITE_OMIT_MEMORYDB + if( strcmp(zFilename,":memory:")==0 ){ + memDb = 1; + zPathname[0] = 0; + }else +#endif + { + + rc = sqlite3OsFullPathname(pVfs, zFilename, nPathname, zPathname); + } + }else{ + rc = sqlite3OsGetTempname(pVfs, nPathname, zPathname); + } + if( rc!=SQLITE_OK ){ + sqlite3_free(zPathname); + return rc; + } + + nPathname = strlen(zPathname); + + /* Allocate memory for the pager structure */ + pPager = (Pager*)sqlite3MallocZero( + sizeof(*pPager) + /* Pager structure */ + journalFileSize + /* The journal file structure */ + pVfs->szOsFile * 2 + /* The db and stmt journal files */ + 4*nPathname + 40 /* zFilename, zDirectory, zJournal, zStmtJrnl */ + ); + if( !pPager ){ + sqlite3_free(zPathname); + return SQLITE_NOMEM; + } + pPtr = (u8 *)&pPager[1]; + pPager->vfsFlags = vfsFlags; + pPager->fd = (sqlite3_file*)&pPtr[pVfs->szOsFile*0]; + pPager->stfd = (sqlite3_file*)&pPtr[pVfs->szOsFile*1]; + pPager->jfd = (sqlite3_file*)&pPtr[pVfs->szOsFile*2]; + pPager->zFilename = (char*)&pPtr[pVfs->szOsFile*2+journalFileSize]; + pPager->zDirectory = &pPager->zFilename[nPathname+1]; + pPager->zJournal = &pPager->zDirectory[nPathname+1]; + pPager->zStmtJrnl = &pPager->zJournal[nPathname+10]; + pPager->pVfs = pVfs; + memcpy(pPager->zFilename, zPathname, nPathname+1); + sqlite3_free(zPathname); + + + /* Open the pager file. + */ + if( zFilename && zFilename[0] && !memDb ){ + if( nPathname>(pVfs->mxPathname - sizeof("-journal")) ){ + rc = SQLITE_CANTOPEN; + }else{ + int fout = 0; + + rc = winOpen(pVfs, pPager->zFilename, pPager->fd, + pPager->vfsFlags, &fout); + readOnly = (fout&SQLITE_OPEN_READONLY); + + /* If the file was successfully opened for read/write access, + ** choose a default page size in case we have to create the + ** database file. The default page size is the maximum of: + ** + ** + SQLITE_DEFAULT_PAGE_SIZE, + ** + The value returned by sqlite3OsSectorSize() + ** + The largest page size that can be written atomically. + */ + if( rc==SQLITE_OK && !readOnly ){ + int iSectorSize = sqlite3OsSectorSize(pPager->fd); + if( nDefaultPagefd); + int ii; + assert(SQLITE_IOCAP_ATOMIC512==(512>>8)); + assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8)); + assert(SQLITE_MAX_DEFAULT_PAGE_SIZE<=65536); + for(ii=nDefaultPage; ii<=SQLITE_MAX_DEFAULT_PAGE_SIZE; ii=ii*2){ + if( iDc&(SQLITE_IOCAP_ATOMIC|(ii>>8)) ) nDefaultPage = ii; + } + } +#endif + if( nDefaultPage>SQLITE_MAX_DEFAULT_PAGE_SIZE ){ + nDefaultPage = SQLITE_MAX_DEFAULT_PAGE_SIZE; + } + } + } + }else if( !memDb ){ + /* If a temporary file is requested, it is not opened immediately. + ** In this case we accept the default page size and delay actually + ** opening the file until the first call to OsWrite(). + */ + tempFile = 1; + pPager->state = PAGER_EXCLUSIVE; + } + + if( pPager && rc==SQLITE_OK ){ + pPager->pTmpSpace = (char *)sqlite3_malloc(nDefaultPage); + } + + /* If an error occured in either of the blocks above. + ** Free the Pager structure and close the file. + ** Since the pager is not allocated there is no need to set + ** any Pager.errMask variables. + */ + if( !pPager || !pPager->pTmpSpace ){ + sqlite3OsClose(pPager->fd); + sqlite3_free(pPager); + return ((rc==SQLITE_OK)?SQLITE_NOMEM:rc); + } + + PAGERTRACE3("OPEN %d %s\n", FILEHANDLEID(pPager->fd), pPager->zFilename); + IOTRACE(("OPEN %p %s\n", pPager, pPager->zFilename)) + + /* Fill in Pager.zDirectory[] */ + memcpy(pPager->zDirectory, pPager->zFilename, nPathname+1); + for(i=strlen(pPager->zDirectory); i>0 && pPager->zDirectory[i-1]!='/'; i--){} + if( i>0 ) pPager->zDirectory[i-1] = 0; + + /* Fill in Pager.zJournal[] and Pager.zStmtJrnl[] */ + memcpy(pPager->zJournal, pPager->zFilename, nPathname); + memcpy(&pPager->zJournal[nPathname], "-journal", 9); + memcpy(pPager->zStmtJrnl, pPager->zFilename, nPathname); + memcpy(&pPager->zStmtJrnl[nPathname], "-stmtjrnl", 10); + + /* pPager->journalOpen = 0; */ + pPager->useJournal = useJournal && !memDb; + pPager->noReadlock = noReadlock && readOnly; + /* pPager->stmtOpen = 0; */ + /* pPager->stmtInUse = 0; */ + /* pPager->nRef = 0; */ + pPager->dbSize = memDb-1; + pPager->pageSize = nDefaultPage; + /* pPager->stmtSize = 0; */ + /* pPager->stmtJSize = 0; */ + /* pPager->nPage = 0; */ + pPager->mxPage = 100; + pPager->mxPgno = SQLITE_MAX_PAGE_COUNT; + /* pPager->state = PAGER_UNLOCK; */ + assert( pPager->state == (tempFile ? PAGER_EXCLUSIVE : PAGER_UNLOCK) ); + /* pPager->errMask = 0; */ + pPager->tempFile = tempFile; + assert( tempFile==PAGER_LOCKINGMODE_NORMAL + || tempFile==PAGER_LOCKINGMODE_EXCLUSIVE ); + assert( PAGER_LOCKINGMODE_EXCLUSIVE==1 ); + pPager->exclusiveMode = tempFile; + pPager->memDb = memDb; + pPager->readOnly = readOnly; + /* pPager->needSync = 0; */ + pPager->noSync = pPager->tempFile || !useJournal; + pPager->fullSync = (pPager->noSync?0:1); + pPager->sync_flags = SQLITE_SYNC_NORMAL; + /* pPager->pFirst = 0; */ + /* pPager->pFirstSynced = 0; */ + /* pPager->pLast = 0; */ + pPager->nExtra = FORCE_ALIGNMENT(nExtra); + assert(pPager->fd->pMethods||memDb||tempFile); + if( !memDb ){ + setSectorSize(pPager); + } + /* pPager->pBusyHandler = 0; */ + /* memset(pPager->aHash, 0, sizeof(pPager->aHash)); */ + *ppPager = pPager; +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT + pPager->iInUseMM = 0; + pPager->iInUseDB = 0; + if( !memDb ){ + sqlite3_mutex *mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MEM2); + sqlite3_mutex_enter(mutex); + pPager->pNext = sqlite3PagerList; + if( sqlite3PagerList ){ + assert( sqlite3PagerList->pPrev==0 ); + sqlite3PagerList->pPrev = pPager; + } + pPager->pPrev = 0; + sqlite3PagerList = pPager; + sqlite3_mutex_leave(mutex); + } +#endif + return SQLITE_OK; +} + +/* +** Set the busy handler function. +*/ +void sqlite3PagerSetBusyhandler(Pager *pPager, BusyHandler *pBusyHandler){ + pPager->pBusyHandler = pBusyHandler; +} + +/* +** Set the destructor for this pager. If not NULL, the destructor is called +** when the reference count on each page reaches zero. The destructor can +** be used to clean up information in the extra segment appended to each page. +** +** The destructor is not called as a result sqlite3PagerClose(). +** Destructors are only called by sqlite3PagerUnref(). +*/ +void sqlite3PagerSetDestructor(Pager *pPager, void (*xDesc)(DbPage*,int)){ + pPager->xDestructor = xDesc; +} + +/* +** Set the reinitializer for this pager. If not NULL, the reinitializer +** is called when the content of a page in cache is restored to its original +** value as a result of a rollback. The callback gives higher-level code +** an opportunity to restore the EXTRA section to agree with the restored +** page data. +*/ +void sqlite3PagerSetReiniter(Pager *pPager, void (*xReinit)(DbPage*,int)){ + pPager->xReiniter = xReinit; +} + +/* +** Set the page size to *pPageSize. If the suggest new page size is +** inappropriate, then an alternative page size is set to that +** value before returning. +*/ +int sqlite3PagerSetPagesize(Pager *pPager, u16 *pPageSize){ + int rc = SQLITE_OK; + u16 pageSize = *pPageSize; + assert( pageSize==0 || (pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE) ); + if( pageSize && pageSize!=pPager->pageSize + && !pPager->memDb && pPager->nRef==0 + ){ + char *pNew = (char *)sqlite3_malloc(pageSize); + if( !pNew ){ + rc = SQLITE_NOMEM; + }else{ + pagerEnter(pPager); + pager_reset(pPager); + pPager->pageSize = pageSize; + setSectorSize(pPager); + sqlite3_free(pPager->pTmpSpace); + pPager->pTmpSpace = pNew; + pagerLeave(pPager); + } + } + *pPageSize = pPager->pageSize; + return rc; +} + +/* +** Return a pointer to the "temporary page" buffer held internally +** by the pager. This is a buffer that is big enough to hold the +** entire content of a database page. This buffer is used internally +** during rollback and will be overwritten whenever a rollback +** occurs. But other modules are free to use it too, as long as +** no rollbacks are happening. +*/ +void *sqlite3PagerTempSpace(Pager *pPager){ + return pPager->pTmpSpace; +} + +/* +** Attempt to set the maximum database page count if mxPage is positive. +** Make no changes if mxPage is zero or negative. And never reduce the +** maximum page count below the current size of the database. +** +** Regardless of mxPage, return the current maximum page count. +*/ +int sqlite3PagerMaxPageCount(Pager *pPager, int mxPage){ + if( mxPage>0 ){ + pPager->mxPgno = mxPage; + } + sqlite3PagerPagecount(pPager); + return pPager->mxPgno; +} + +/* +** The following set of routines are used to disable the simulated +** I/O error mechanism. These routines are used to avoid simulated +** errors in places where we do not care about errors. +** +** Unless -DSQLITE_TEST=1 is used, these routines are all no-ops +** and generate no code. +*/ +#ifdef SQLITE_TEST +extern int sqlite3_io_error_pending; +extern int sqlite3_io_error_hit; +static int saved_cnt; +void disable_simulated_io_errors(void){ + saved_cnt = sqlite3_io_error_pending; + sqlite3_io_error_pending = -1; +} +void enable_simulated_io_errors(void){ + sqlite3_io_error_pending = saved_cnt; +} +#else +# define disable_simulated_io_errors() +# define enable_simulated_io_errors() +#endif + +/* +** Read the first N bytes from the beginning of the file into memory +** that pDest points to. +** +** No error checking is done. The rational for this is that this function +** may be called even if the file does not exist or contain a header. In +** these cases sqlite3OsRead() will return an error, to which the correct +** response is to zero the memory at pDest and continue. A real IO error +** will presumably recur and be picked up later (Todo: Think about this). +*/ +int sqlite3PagerReadFileheader(Pager *pPager, int N, unsigned char *pDest){ + int rc = SQLITE_OK; + memset(pDest, 0, N); + assert(MEMDB||pPager->fd->pMethods||pPager->tempFile); + if( pPager->fd->isOpen ){ + IOTRACE(("DBHDR %p 0 %d\n", pPager, N)) + rc = sqlite3OsRead(pPager->fd, pDest, N, 0); + if( rc==SQLITE_IOERR_SHORT_READ ){ + rc = SQLITE_OK; + } + } + return rc; +} + +/* +** Return the total number of pages in the disk file associated with +** pPager. +** +** If the PENDING_BYTE lies on the page directly after the end of the +** file, then consider this page part of the file too. For example, if +** PENDING_BYTE is byte 4096 (the first byte of page 5) and the size of the +** file is 4096 bytes, 5 is returned instead of 4. +*/ +int sqlite3PagerPagecount(Pager *pPager){ + i64 n = 0; + int rc; + assert( pPager!=0 ); + if( pPager->errCode ){ + return 0; + } + if( pPager->dbSize>=0 ){ + n = pPager->dbSize; + } else { + assert(pPager->fd->pMethods||pPager->tempFile); + if( (pPager->fd->isOpen) + && (rc = sqlite3OsFileSize(pPager->fd, &n))!=SQLITE_OK ){ + pPager->nRef++; + pager_error(pPager, rc); + pPager->nRef--; + return 0; + } + if( n>0 && npageSize ){ + n = 1; + }else{ + n /= pPager->pageSize; + } + if( pPager->state!=PAGER_UNLOCK ){ + pPager->dbSize = n; + } + } + if( n==(PENDING_BYTE/pPager->pageSize) ){ + n++; + } + if( n>pPager->mxPgno ){ + pPager->mxPgno = n; + } + return n; +} + + +#ifndef SQLITE_OMIT_MEMORYDB +/* +** Clear a PgHistory block +*/ +static void clearHistory(PgHistory *pHist){ + sqlite3_free(pHist->pOrig); + sqlite3_free(pHist->pStmt); + pHist->pOrig = 0; + pHist->pStmt = 0; +} +#else +#define clearHistory(x) +#endif + +/* +** Forward declaration +*/ +static int syncJournal(Pager*); + +/* +** Unlink pPg from its hash chain. Also set the page number to 0 to indicate +** that the page is not part of any hash chain. This is required because the +** sqlite3PagerMovepage() routine can leave a page in the +** pNextFree/pPrevFree list that is not a part of any hash-chain. +*/ +static void unlinkHashChain(Pager *pPager, PgHdr *pPg){ + if( pPg->pgno==0 ){ + assert( pPg->pNextHash==0 && pPg->pPrevHash==0 ); + return; + } + if( pPg->pNextHash ){ + pPg->pNextHash->pPrevHash = pPg->pPrevHash; + } + if( pPg->pPrevHash ){ + assert( pPager->aHash[pPg->pgno & (pPager->nHash-1)]!=pPg ); + pPg->pPrevHash->pNextHash = pPg->pNextHash; + }else{ + int h = pPg->pgno & (pPager->nHash-1); + pPager->aHash[h] = pPg->pNextHash; + } + if( MEMDB ){ + clearHistory(PGHDR_TO_HIST(pPg, pPager)); + } + pPg->pgno = 0; + pPg->pNextHash = pPg->pPrevHash = 0; +} + +/* +** Unlink a page from the free list (the list of all pages where nRef==0) +** and from its hash collision chain. +*/ +static void unlinkPage(PgHdr *pPg){ + Pager *pPager = pPg->pPager; + + /* Unlink from free page list */ + lruListRemove(pPg); + + /* Unlink from the pgno hash table */ + unlinkHashChain(pPager, pPg); +} + +/* +** This routine is used to truncate the cache when a database +** is truncated. Drop from the cache all pages whose pgno is +** larger than pPager->dbSize and is unreferenced. +** +** Referenced pages larger than pPager->dbSize are zeroed. +** +** Actually, at the point this routine is called, it would be +** an error to have a referenced page. But rather than delete +** that page and guarantee a subsequent segfault, it seems better +** to zero it and hope that we error out sanely. +*/ +static void pager_truncate_cache(Pager *pPager){ + PgHdr *pPg; + PgHdr **ppPg; + int dbSize = pPager->dbSize; + + ppPg = &pPager->pAll; + while( (pPg = *ppPg)!=0 ){ + if( pPg->pgno<=dbSize ){ + ppPg = &pPg->pNextAll; + }else if( pPg->nRef>0 ){ + memset(PGHDR_TO_DATA(pPg), 0, pPager->pageSize); + ppPg = &pPg->pNextAll; + }else{ + *ppPg = pPg->pNextAll; + IOTRACE(("PGFREE %p %d\n", pPager, pPg->pgno)); + PAGER_INCR(sqlite3_pager_pgfree_count); + unlinkPage(pPg); + makeClean(pPg); + sqlite3_free(pPg); + pPager->nPage--; + } + } +} + +/* +** Try to obtain a lock on a file. Invoke the busy callback if the lock +** is currently not available. Repeat until the busy callback returns +** false or until the lock succeeds. +** +** Return SQLITE_OK on success and an error code if we cannot obtain +** the lock. +*/ +static int pager_wait_on_lock(Pager *pPager, int locktype){ + int rc; + + /* The OS lock values must be the same as the Pager lock values */ + assert( PAGER_SHARED==SHARED_LOCK ); + assert( PAGER_RESERVED==RESERVED_LOCK ); + assert( PAGER_EXCLUSIVE==EXCLUSIVE_LOCK ); + + /* If the file is currently unlocked then the size must be unknown */ + assert( pPager->state>=PAGER_SHARED || pPager->dbSize<0 || MEMDB ); + + if( pPager->state>=locktype ){ + rc = SQLITE_OK; + }else{ + do { + rc = sqlite3OsLock(pPager->fd, locktype); + }while( rc==SQLITE_BUSY && sqlite3InvokeBusyHandler(pPager->pBusyHandler) ); + if( rc==SQLITE_OK ){ + pPager->state = locktype; + IOTRACE(("LOCK %p %d\n", pPager, locktype)) + } + } + return rc; +} + +/* +** Truncate the file to the number of pages specified. +*/ +int sqlite3PagerTruncate(Pager *pPager, Pgno nPage){ + int rc; + assert( pPager->state>=PAGER_SHARED || MEMDB ); + sqlite3PagerPagecount(pPager); + if( pPager->errCode ){ + rc = pPager->errCode; + return rc; + } + if( nPage>=(unsigned)pPager->dbSize ){ + return SQLITE_OK; + } + if( MEMDB ){ + pPager->dbSize = nPage; + pager_truncate_cache(pPager); + return SQLITE_OK; + } + pagerEnter(pPager); + rc = syncJournal(pPager); + pagerLeave(pPager); + if( rc!=SQLITE_OK ){ + return rc; + } + + /* Get an exclusive lock on the database before truncating. */ + pagerEnter(pPager); + rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK); + pagerLeave(pPager); + if( rc!=SQLITE_OK ){ + return rc; + } + + rc = pager_truncate(pPager, nPage); + return rc; +} + +/* +** Shutdown the page cache. Free all memory and close all files. +** +** If a transaction was in progress when this routine is called, that +** transaction is rolled back. All outstanding pages are invalidated +** and their memory is freed. Any attempt to use a page associated +** with this page cache after this function returns will likely +** result in a coredump. +** +** This function always succeeds. If a transaction is active an attempt +** is made to roll it back. If an error occurs during the rollback +** a hot journal may be left in the filesystem but no error is returned +** to the caller. +*/ +int sqlite3PagerClose(Pager *pPager){ +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT + if( !MEMDB ){ + sqlite3_mutex *mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MEM2); + sqlite3_mutex_enter(mutex); + if( pPager->pPrev ){ + pPager->pPrev->pNext = pPager->pNext; + }else{ + sqlite3PagerList = pPager->pNext; + } + if( pPager->pNext ){ + pPager->pNext->pPrev = pPager->pPrev; + } + sqlite3_mutex_leave(mutex); + } +#endif + + disable_simulated_io_errors(); + pPager->errCode = 0; + pPager->exclusiveMode = 0; + pager_reset(pPager); + pagerUnlockAndRollback(pPager); + enable_simulated_io_errors(); + PAGERTRACE2("CLOSE %d\n", PAGERID(pPager)); + IOTRACE(("CLOSE %p\n", pPager)) + assert( pPager->errCode || (pPager->journalOpen==0 && pPager->stmtOpen==0) ); + if( pPager->journalOpen ){ + sqlite3OsClose(pPager->jfd); + } + sqlite3_free(pPager->aInJournal); + if( pPager->stmtOpen ){ + sqlite3OsClose(pPager->stfd); + } + sqlite3OsClose(pPager->fd); + /* Temp files are automatically deleted by the OS + ** if( pPager->tempFile ){ + ** sqlite3OsDelete(pPager->zFilename); + ** } + */ + + sqlite3_free(pPager->aHash); + sqlite3_free(pPager->pTmpSpace); + sqlite3_free(pPager); + return SQLITE_OK; +} + +#if !defined(NDEBUG) || defined(SQLITE_TEST) +/* +** Return the page number for the given page data. +*/ +Pgno sqlite3PagerPagenumber(DbPage *p){ + return p->pgno; +} +#endif + +/* +** The page_ref() function increments the reference count for a page. +** If the page is currently on the freelist (the reference count is zero) then +** remove it from the freelist. +** +** For non-test systems, page_ref() is a macro that calls _page_ref() +** online of the reference count is zero. For test systems, page_ref() +** is a real function so that we can set breakpoints and trace it. +*/ +static void _page_ref(PgHdr *pPg){ + if( pPg->nRef==0 ){ + /* The page is currently on the freelist. Remove it. */ + lruListRemove(pPg); + pPg->pPager->nRef++; + } + pPg->nRef++; + REFINFO(pPg); +} +#ifdef SQLITE_DEBUG + static void page_ref(PgHdr *pPg){ + if( pPg->nRef==0 ){ + _page_ref(pPg); + }else{ + pPg->nRef++; + REFINFO(pPg); + } + } +#else +# define page_ref(P) ((P)->nRef==0?_page_ref(P):(void)(P)->nRef++) +#endif + +/* +** Increment the reference count for a page. The input pointer is +** a reference to the page data. +*/ +int sqlite3PagerRef(DbPage *pPg){ + pagerEnter(pPg->pPager); + page_ref(pPg); + pagerLeave(pPg->pPager); + return SQLITE_OK; +} + +/* +** Sync the journal. In other words, make sure all the pages that have +** been written to the journal have actually reached the surface of the +** disk. It is not safe to modify the original database file until after +** the journal has been synced. If the original database is modified before +** the journal is synced and a power failure occurs, the unsynced journal +** data would be lost and we would be unable to completely rollback the +** database changes. Database corruption would occur. +** +** This routine also updates the nRec field in the header of the journal. +** (See comments on the pager_playback() routine for additional information.) +** If the sync mode is FULL, two syncs will occur. First the whole journal +** is synced, then the nRec field is updated, then a second sync occurs. +** +** For temporary databases, we do not care if we are able to rollback +** after a power failure, so no sync occurs. +** +** If the IOCAP_SEQUENTIAL flag is set for the persistent media on which +** the database is stored, then OsSync() is never called on the journal +** file. In this case all that is required is to update the nRec field in +** the journal header. +** +** This routine clears the needSync field of every page current held in +** memory. +*/ +static int syncJournal(Pager *pPager){ + PgHdr *pPg; + int rc = SQLITE_OK; + + + /* Sync the journal before modifying the main database + ** (assuming there is a journal and it needs to be synced.) + */ + if( pPager->needSync ){ + if( !pPager->tempFile ){ + int iDc = sqlite3OsDeviceCharacteristics(pPager->fd); + assert( pPager->journalOpen ); + + /* assert( !pPager->noSync ); // noSync might be set if synchronous + ** was turned off after the transaction was started. Ticket #615 */ +#ifndef NDEBUG + { + /* Make sure the pPager->nRec counter we are keeping agrees + ** with the nRec computed from the size of the journal file. + */ + i64 jSz; + rc = sqlite3OsFileSize(pPager->jfd, &jSz); + if( rc!=0 ) return rc; + assert( pPager->journalOff==jSz ); + } +#endif + if( 0==(iDc&SQLITE_IOCAP_SAFE_APPEND) ){ + /* Write the nRec value into the journal file header. If in + ** full-synchronous mode, sync the journal first. This ensures that + ** all data has really hit the disk before nRec is updated to mark + ** it as a candidate for rollback. + ** + ** This is not required if the persistent media supports the + ** SAFE_APPEND property. Because in this case it is not possible + ** for garbage data to be appended to the file, the nRec field + ** is populated with 0xFFFFFFFF when the journal header is written + ** and never needs to be updated. + */ + i64 jrnlOff; + if( pPager->fullSync && 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){ + PAGERTRACE2("SYNC journal of %d\n", PAGERID(pPager)); + IOTRACE(("JSYNC %p\n", pPager)) + rc = sqlite3OsSync(pPager->jfd, pPager->sync_flags); + if( rc!=0 ) return rc; + } + + jrnlOff = pPager->journalHdr + sizeof(aJournalMagic); + IOTRACE(("JHDR %p %lld %d\n", pPager, jrnlOff, 4)); + rc = write32bits(pPager->jfd, jrnlOff, pPager->nRec); + if( rc ) return rc; + } + if( 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){ + PAGERTRACE2("SYNC journal of %d\n", PAGERID(pPager)); + IOTRACE(("JSYNC %p\n", pPager)) + rc = sqlite3OsSync(pPager->jfd, pPager->sync_flags| + (pPager->sync_flags==SQLITE_SYNC_FULL?SQLITE_SYNC_DATAONLY:0) + ); + if( rc!=0 ) return rc; + } + pPager->journalStarted = 1; + } + pPager->needSync = 0; + + /* Erase the needSync flag from every page. + */ + for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){ + pPg->needSync = 0; + } + lruListSetFirstSynced(pPager); + } + +#ifndef NDEBUG + /* If the Pager.needSync flag is clear then the PgHdr.needSync + ** flag must also be clear for all pages. Verify that this + ** invariant is true. + */ + else{ + for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){ + assert( pPg->needSync==0 ); + } + assert( pPager->lru.pFirstSynced==pPager->lru.pFirst ); + } +#endif + + return rc; +} + +/* +** Merge two lists of pages connected by pDirty and in pgno order. +** Do not both fixing the pPrevDirty pointers. +*/ +static PgHdr *merge_pagelist(PgHdr *pA, PgHdr *pB){ + PgHdr result, *pTail; + pTail = &result; + while( pA && pB ){ + if( pA->pgnopgno ){ + pTail->pDirty = pA; + pTail = pA; + pA = pA->pDirty; + }else{ + pTail->pDirty = pB; + pTail = pB; + pB = pB->pDirty; + } + } + if( pA ){ + pTail->pDirty = pA; + }else if( pB ){ + pTail->pDirty = pB; + }else{ + pTail->pDirty = 0; + } + return result.pDirty; +} + +/* +** Sort the list of pages in accending order by pgno. Pages are +** connected by pDirty pointers. The pPrevDirty pointers are +** corrupted by this sort. +*/ +#define N_SORT_BUCKET_ALLOC 25 +#define N_SORT_BUCKET 25 +#ifdef SQLITE_TEST + int sqlite3_pager_n_sort_bucket = 0; + #undef N_SORT_BUCKET + #define N_SORT_BUCKET \ + (sqlite3_pager_n_sort_bucket?sqlite3_pager_n_sort_bucket:N_SORT_BUCKET_ALLOC) +#endif +static PgHdr *sort_pagelist(PgHdr *pIn){ + PgHdr *a[N_SORT_BUCKET_ALLOC], *p; + int i; + memset(a, 0, sizeof(a)); + while( pIn ){ + p = pIn; + pIn = p->pDirty; + p->pDirty = 0; + for(i=0; ipPager; + + /* At this point there may be either a RESERVED or EXCLUSIVE lock on the + ** database file. If there is already an EXCLUSIVE lock, the following + ** calls to sqlite3OsLock() are no-ops. + ** + ** Moving the lock from RESERVED to EXCLUSIVE actually involves going + ** through an intermediate state PENDING. A PENDING lock prevents new + ** readers from attaching to the database but is unsufficient for us to + ** write. The idea of a PENDING lock is to prevent new readers from + ** coming in while we wait for existing readers to clear. + ** + ** While the pager is in the RESERVED state, the original database file + ** is unchanged and we can rollback without having to playback the + ** journal into the original database file. Once we transition to + ** EXCLUSIVE, it means the database file has been changed and any rollback + ** will require a journal playback. + */ + rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK); + if( rc!=SQLITE_OK ){ + return rc; + } + + pList = sort_pagelist(pList); + for(p=pList; p; p=p->pDirty){ + assert( p->dirty ); + p->dirty = 0; + } + while( pList ){ + + /* If the file has not yet been opened, open it now. */ + if( !pPager->fd->isOpen ){ + assert(pPager->tempFile); + rc = sqlite3PagerOpentemp(pPager->pVfs, pPager->fd, pPager->zFilename, + pPager->vfsFlags); + if( rc ) return rc; + } + + /* If there are dirty pages in the page cache with page numbers greater + ** than Pager.dbSize, this means sqlite3PagerTruncate() was called to + ** make the file smaller (presumably by auto-vacuum code). Do not write + ** any such pages to the file. + */ + if( pList->pgno<=pPager->dbSize ){ + i64 offset = (pList->pgno-1)*(i64)pPager->pageSize; + char *pData = CODEC2(pPager, PGHDR_TO_DATA(pList), pList->pgno, 6); + PAGERTRACE4("STORE %d page %d hash(%08x)\n", + PAGERID(pPager), pList->pgno, pager_pagehash(pList)); + IOTRACE(("PGOUT %p %d\n", pPager, pList->pgno)); + rc = sqlite3OsWrite(pPager->fd, pData, pPager->pageSize, offset); + PAGER_INCR(sqlite3_pager_writedb_count); + PAGER_INCR(pPager->nWrite); + if( pList->pgno==1 ){ + memcpy(&pPager->dbFileVers, &pData[24], sizeof(pPager->dbFileVers)); + } + } +#ifndef NDEBUG + else{ + PAGERTRACE3("NOSTORE %d page %d\n", PAGERID(pPager), pList->pgno); + } +#endif + if( rc ) return rc; +#ifdef SQLITE_CHECK_PAGES + pList->pageHash = pager_pagehash(pList); +#endif + pList = pList->pDirty; + } + return SQLITE_OK; +} + +/* +** Collect every dirty page into a dirty list and +** return a pointer to the head of that list. All pages are +** collected even if they are still in use. +*/ +static PgHdr *pager_get_all_dirty_pages(Pager *pPager){ + return pPager->pDirty; +} + +/* +** Return TRUE if there is a hot journal on the given pager. +** A hot journal is one that needs to be played back. +** +** If the current size of the database file is 0 but a journal file +** exists, that is probably an old journal left over from a prior +** database with the same name. Just delete the journal. +*/ +static int hasHotJournal(Pager *pPager){ + sqlite3_vfs *pVfs = pPager->pVfs; + if( !pPager->useJournal ) return 0; + if( !pPager->fd->isOpen ) return 0; + if( !sqlite3OsAccess(pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS) ){ + return 0; + } + if( sqlite3OsCheckReservedLock(pPager->fd) ){ + return 0; + } + if( sqlite3PagerPagecount(pPager)==0 ){ + sqlite3OsDelete(pVfs, pPager->zJournal, 0); + return 0; + }else{ + return 1; + } +} + +/* +** Try to find a page in the cache that can be recycled. +** +** This routine may return SQLITE_IOERR, SQLITE_FULL or SQLITE_OK. It +** does not set the pPager->errCode variable. +*/ +static int pager_recycle(Pager *pPager, PgHdr **ppPg){ + PgHdr *pPg; + *ppPg = 0; + + /* It is illegal to call this function unless the pager object + ** pointed to by pPager has at least one free page (page with nRef==0). + */ + assert(!MEMDB); + assert(pPager->lru.pFirst); + + /* Find a page to recycle. Try to locate a page that does not + ** require us to do an fsync() on the journal. + */ + pPg = pPager->lru.pFirstSynced; + + /* If we could not find a page that does not require an fsync() + ** on the journal file then fsync the journal file. This is a + ** very slow operation, so we work hard to avoid it. But sometimes + ** it can't be helped. + */ + if( pPg==0 && pPager->lru.pFirst){ + int iDc = sqlite3OsDeviceCharacteristics(pPager->fd); + int rc = syncJournal(pPager); + if( rc!=0 ){ + return rc; + } + if( pPager->fullSync && 0==(iDc&SQLITE_IOCAP_SAFE_APPEND) ){ + /* If in full-sync mode, write a new journal header into the + ** journal file. This is done to avoid ever modifying a journal + ** header that is involved in the rollback of pages that have + ** already been written to the database (in case the header is + ** trashed when the nRec field is updated). + */ + pPager->nRec = 0; + assert( pPager->journalOff > 0 ); + assert( pPager->doNotSync==0 ); + rc = writeJournalHdr(pPager); + if( rc!=0 ){ + return rc; + } + } + pPg = pPager->lru.pFirst; + } + + assert( pPg->nRef==0 ); + + /* Write the page to the database file if it is dirty. + */ + if( pPg->dirty ){ + int rc; + assert( pPg->needSync==0 ); + makeClean(pPg); + pPg->dirty = 1; + pPg->pDirty = 0; + rc = pager_write_pagelist( pPg ); + pPg->dirty = 0; + if( rc!=SQLITE_OK ){ + return rc; + } + } + assert( pPg->dirty==0 ); + + /* If the page we are recycling is marked as alwaysRollback, then + ** set the global alwaysRollback flag, thus disabling the + ** sqlite3PagerDontRollback() optimization for the rest of this transaction. + ** It is necessary to do this because the page marked alwaysRollback + ** might be reloaded at a later time but at that point we won't remember + ** that is was marked alwaysRollback. This means that all pages must + ** be marked as alwaysRollback from here on out. + */ + if( pPg->alwaysRollback ){ + IOTRACE(("ALWAYS_ROLLBACK %p\n", pPager)) + pPager->alwaysRollback = 1; + } + + /* Unlink the old page from the free list and the hash table + */ + unlinkPage(pPg); + assert( pPg->pgno==0 ); + + *ppPg = pPg; + return SQLITE_OK; +} + +#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT +/* +** This function is called to free superfluous dynamically allocated memory +** held by the pager system. Memory in use by any SQLite pager allocated +** by the current thread may be sqlite3_free()ed. +** +** nReq is the number of bytes of memory required. Once this much has +** been released, the function returns. The return value is the total number +** of bytes of memory released. +*/ +int sqlite3PagerReleaseMemory(int nReq){ + int nReleased = 0; /* Bytes of memory released so far */ + sqlite3_mutex *mutex; /* The MEM2 mutex */ + Pager *pPager; /* For looping over pagers */ + BusyHandler *savedBusy; /* Saved copy of the busy handler */ + int rc = SQLITE_OK; + + /* Acquire the memory-management mutex + */ + mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MEM2); + sqlite3_mutex_enter(mutex); + + /* Signal all database connections that memory management wants + ** to have access to the pagers. + */ + for(pPager=sqlite3PagerList; pPager; pPager=pPager->pNext){ + pPager->iInUseMM = 1; + } + + while( rc==SQLITE_OK && (nReq<0 || nReleasedneedSync || pPg->pPager->iInUseDB) ){ + pPg = pPg->gfree.pNext; + } + if( !pPg ){ + pPg = sqlite3LruPageList.pFirst; + while( pPg && pPg->pPager->iInUseDB ){ + pPg = pPg->gfree.pNext; + } + } + sqlite3_mutex_leave(sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU)); + + /* If pPg==0, then the block above has failed to find a page to + ** recycle. In this case return early - no further memory will + ** be released. + */ + if( !pPg ) break; + + pPager = pPg->pPager; + assert(!pPg->needSync || pPg==pPager->lru.pFirst); + assert(pPg->needSync || pPg==pPager->lru.pFirstSynced); + + savedBusy = pPager->pBusyHandler; + pPager->pBusyHandler = 0; + rc = pager_recycle(pPager, &pRecycled); + pPager->pBusyHandler = savedBusy; + assert(pRecycled==pPg || rc!=SQLITE_OK); + if( rc==SQLITE_OK ){ + /* We've found a page to free. At this point the page has been + ** removed from the page hash-table, free-list and synced-list + ** (pFirstSynced). It is still in the all pages (pAll) list. + ** Remove it from this list before freeing. + ** + ** Todo: Check the Pager.pStmt list to make sure this is Ok. It + ** probably is though. + */ + PgHdr *pTmp; + assert( pPg ); + if( pPg==pPager->pAll ){ + pPager->pAll = pPg->pNextAll; + }else{ + for( pTmp=pPager->pAll; pTmp->pNextAll!=pPg; pTmp=pTmp->pNextAll ){} + pTmp->pNextAll = pPg->pNextAll; + } + nReleased += ( + sizeof(*pPg) + pPager->pageSize + + sizeof(u32) + pPager->nExtra + + MEMDB*sizeof(PgHistory) + ); + IOTRACE(("PGFREE %p %d *\n", pPager, pPg->pgno)); + PAGER_INCR(sqlite3_pager_pgfree_count); + sqlite3_free(pPg); + pPager->nPage--; + }else{ + /* An error occured whilst writing to the database file or + ** journal in pager_recycle(). The error is not returned to the + ** caller of this function. Instead, set the Pager.errCode variable. + ** The error will be returned to the user (or users, in the case + ** of a shared pager cache) of the pager for which the error occured. + */ + assert( + (rc&0xff)==SQLITE_IOERR || + rc==SQLITE_FULL || + rc==SQLITE_BUSY + ); + assert( pPager->state>=PAGER_RESERVED ); + pager_error(pPager, rc); + } + } + + /* Clear the memory management flags and release the mutex + */ + for(pPager=sqlite3PagerList; pPager; pPager=pPager->pNext){ + pPager->iInUseMM = 0; + } + sqlite3_mutex_leave(mutex); + + /* Return the number of bytes released + */ + return nReleased; +} +#endif /* SQLITE_ENABLE_MEMORY_MANAGEMENT */ + +/* +** Read the content of page pPg out of the database file. +*/ +static int readDbPage(Pager *pPager, PgHdr *pPg, Pgno pgno){ + int rc; + i64 offset; + assert( MEMDB==0 ); + assert(pPager->fd->pMethods||pPager->tempFile); + if( !pPager->fd->isOpen ){ + return SQLITE_IOERR_SHORT_READ; + } + offset = (pgno-1)*(i64)pPager->pageSize; + rc = sqlite3OsRead(pPager->fd, PGHDR_TO_DATA(pPg), pPager->pageSize, offset); + PAGER_INCR(sqlite3_pager_readdb_count); + PAGER_INCR(pPager->nRead); + IOTRACE(("PGIN %p %d\n", pPager, pgno)); + if( pgno==1 ){ + memcpy(&pPager->dbFileVers, &((u8*)PGHDR_TO_DATA(pPg))[24], + sizeof(pPager->dbFileVers)); + } + CODEC1(pPager, PGHDR_TO_DATA(pPg), pPg->pgno, 3); + PAGERTRACE4("FETCH %d page %d hash(%08x)\n", + PAGERID(pPager), pPg->pgno, pager_pagehash(pPg)); + return rc; +} + + +/* +** This function is called to obtain the shared lock required before +** data may be read from the pager cache. If the shared lock has already +** been obtained, this function is a no-op. +** +** Immediately after obtaining the shared lock (if required), this function +** checks for a hot-journal file. If one is found, an emergency rollback +** is performed immediately. +*/ +static int pagerSharedLock(Pager *pPager){ + int rc = SQLITE_OK; + int isHot = 0; + + /* If this database is opened for exclusive access, has no outstanding + ** page references and is in an error-state, now is the chance to clear + ** the error. Discard the contents of the pager-cache and treat any + ** open journal file as a hot-journal. + */ + if( !MEMDB && pPager->exclusiveMode && pPager->nRef==0 && pPager->errCode ){ + if( pPager->journalOpen ){ + isHot = 1; + } + pager_reset(pPager); + pPager->errCode = SQLITE_OK; + } + + /* If the pager is still in an error state, do not proceed. The error + ** state will be cleared at some point in the future when all page + ** references are dropped and the cache can be discarded. + */ + if( pPager->errCode && pPager->errCode!=SQLITE_FULL ){ + return pPager->errCode; + } + + if( pPager->state==PAGER_UNLOCK || isHot ){ + sqlite3_vfs *pVfs = pPager->pVfs; + if( !MEMDB ){ + assert( pPager->nRef==0 ); + if( !pPager->noReadlock ){ + rc = pager_wait_on_lock(pPager, SHARED_LOCK); + if( rc!=SQLITE_OK ){ + return pager_error(pPager, rc); + } + assert( pPager->state>=SHARED_LOCK ); + } + + /* If a journal file exists, and there is no RESERVED lock on the + ** database file, then it either needs to be played back or deleted. + */ + if( hasHotJournal(pPager) || isHot ){ + /* Get an EXCLUSIVE lock on the database file. At this point it is + ** important that a RESERVED lock is not obtained on the way to the + ** EXCLUSIVE lock. If it were, another process might open the + ** database file, detect the RESERVED lock, and conclude that the + ** database is safe to read while this process is still rolling it + ** back. + ** + ** Because the intermediate RESERVED lock is not requested, the + ** second process will get to this point in the code and fail to + ** obtain its own EXCLUSIVE lock on the database file. + */ + if( pPager->statefd, EXCLUSIVE_LOCK); + if( rc!=SQLITE_OK ){ + pager_unlock(pPager); + return pager_error(pPager, rc); + } + pPager->state = PAGER_EXCLUSIVE; + } + + /* Open the journal for reading only. Return SQLITE_BUSY if + ** we are unable to open the journal file. + ** + ** The journal file does not need to be locked itself. The + ** journal file is never open unless the main database file holds + ** a write lock, so there is never any chance of two or more + ** processes opening the journal at the same time. + ** + ** Open the journal for read/write access. This is because in + ** exclusive-access mode the file descriptor will be kept open and + ** possibly used for a transaction later on. On some systems, the + ** OsTruncate() call used in exclusive-access mode also requires + ** a read/write file handle. + */ + if( !isHot ){ + rc = SQLITE_BUSY; + if( sqlite3OsAccess(pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS) ){ + int fout = 0; + int f = SQLITE_OPEN_READWRITE|SQLITE_OPEN_MAIN_JOURNAL; + assert( !pPager->tempFile ); + rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &fout); + assert( rc!=SQLITE_OK || pPager->jfd->pMethods ); + if( fout&SQLITE_OPEN_READONLY ){ + rc = SQLITE_BUSY; + sqlite3OsClose(pPager->jfd); + } + } + } + if( rc!=SQLITE_OK ){ + pager_unlock(pPager); + return ((rc==SQLITE_NOMEM||rc==SQLITE_IOERR_NOMEM)?rc:SQLITE_BUSY); + } + pPager->journalOpen = 1; + pPager->journalStarted = 0; + pPager->journalOff = 0; + pPager->setMaster = 0; + pPager->journalHdr = 0; + + /* Playback and delete the journal. Drop the database write + ** lock and reacquire the read lock. + */ + rc = pager_playback(pPager, 1); + if( rc!=SQLITE_OK ){ + return pager_error(pPager, rc); + } + assert(pPager->state==PAGER_SHARED || + (pPager->exclusiveMode && pPager->state>PAGER_SHARED) + ); + } + + if( pPager->pAll ){ + /* The shared-lock has just been acquired on the database file + ** and there are already pages in the cache (from a previous + ** read or write transaction). Check to see if the database + ** has been modified. If the database has changed, flush the + ** cache. + ** + ** Database changes is detected by looking at 15 bytes beginning + ** at offset 24 into the file. The first 4 of these 16 bytes are + ** a 32-bit counter that is incremented with each change. The + ** other bytes change randomly with each file change when + ** a codec is in use. + ** + ** There is a vanishingly small chance that a change will not be + ** detected. The chance of an undetected change is so small that + ** it can be neglected. + */ + char dbFileVers[sizeof(pPager->dbFileVers)]; + sqlite3PagerPagecount(pPager); + + if( pPager->errCode ){ + return pPager->errCode; + } + + if( pPager->dbSize>0 ){ + IOTRACE(("CKVERS %p %d\n", pPager, sizeof(dbFileVers))); + rc = sqlite3OsRead(pPager->fd, &dbFileVers, sizeof(dbFileVers), 24); + if( rc!=SQLITE_OK ){ + return rc; + } + }else{ + memset(dbFileVers, 0, sizeof(dbFileVers)); + } + + if( memcmp(pPager->dbFileVers, dbFileVers, sizeof(dbFileVers))!=0 ){ + pager_reset(pPager); + } + } + } + assert( pPager->exclusiveMode || pPager->state<=PAGER_SHARED ); + if( pPager->state==PAGER_UNLOCK ){ + pPager->state = PAGER_SHARED; + } + } + + return rc; +} + +/* +** Allocate a PgHdr object. Either create a new one or reuse +** an existing one that is not otherwise in use. +** +** A new PgHdr structure is created if any of the following are +** true: +** +** (1) We have not exceeded our maximum allocated cache size +** as set by the "PRAGMA cache_size" command. +** +** (2) There are no unused PgHdr objects available at this time. +** +** (3) This is an in-memory database. +** +** (4) There are no PgHdr objects that do not require a journal +** file sync and a sync of the journal file is currently +** prohibited. +** +** Otherwise, reuse an existing PgHdr. In other words, reuse an +** existing PgHdr if all of the following are true: +** +** (1) We have reached or exceeded the maximum cache size +** allowed by "PRAGMA cache_size". +** +** (2) There is a PgHdr available with PgHdr->nRef==0 +** +** (3) We are not in an in-memory database +** +** (4) Either there is an available PgHdr that does not need +** to be synced to disk or else disk syncing is currently +** allowed. +*/ +static int pagerAllocatePage(Pager *pPager, PgHdr **ppPg){ + int rc = SQLITE_OK; + PgHdr *pPg; + int nByteHdr; + + /* Create a new PgHdr if any of the four conditions defined + ** above are met: */ + if( pPager->nPagemxPage + || pPager->lru.pFirst==0 + || MEMDB + || (pPager->lru.pFirstSynced==0 && pPager->doNotSync) + ){ + if( pPager->nPage>=pPager->nHash ){ + pager_resize_hash_table(pPager, + pPager->nHash<256 ? 256 : pPager->nHash*2); + if( pPager->nHash==0 ){ + rc = SQLITE_NOMEM; + goto pager_allocate_out; + } + } + pagerLeave(pPager); + nByteHdr = sizeof(*pPg) + sizeof(u32) + pPager->nExtra + + MEMDB*sizeof(PgHistory); + pPg = (PgHdr*)sqlite3_malloc( nByteHdr + pPager->pageSize ); + pagerEnter(pPager); + if( pPg==0 ){ + rc = SQLITE_NOMEM; + goto pager_allocate_out; + } + memset(pPg, 0, nByteHdr); + pPg->pData = (void*)(nByteHdr + (char*)pPg); + pPg->pPager = pPager; + pPg->pNextAll = pPager->pAll; + pPager->pAll = pPg; + pPager->nPage++; + }else{ + /* Recycle an existing page with a zero ref-count. */ + rc = pager_recycle(pPager, &pPg); + if( rc==SQLITE_BUSY ){ + rc = SQLITE_IOERR_BLOCKED; + } + if( rc!=SQLITE_OK ){ + goto pager_allocate_out; + } + assert( pPager->state>=SHARED_LOCK ); + assert(pPg); + } + *ppPg = pPg; + +pager_allocate_out: + return rc; +} + +/* +** Make sure we have the content for a page. If the page was +** previously acquired with noContent==1, then the content was +** just initialized to zeros instead of being read from disk. +** But now we need the real data off of disk. So make sure we +** have it. Read it in if we do not have it already. +*/ +static int pager_get_content(PgHdr *pPg){ + if( pPg->needRead ){ + int rc = readDbPage(pPg->pPager, pPg, pPg->pgno); + if( rc==SQLITE_OK ){ + pPg->needRead = 0; + }else{ + return rc; + } + } + return SQLITE_OK; +} + +/* +** Acquire a page. +** +** A read lock on the disk file is obtained when the first page is acquired. +** This read lock is dropped when the last page is released. +** +** This routine works for any page number greater than 0. If the database +** file is smaller than the requested page, then no actual disk +** read occurs and the memory image of the page is initialized to +** all zeros. The extra data appended to a page is always initialized +** to zeros the first time a page is loaded into memory. +** +** The acquisition might fail for several reasons. In all cases, +** an appropriate error code is returned and *ppPage is set to NULL. +** +** See also sqlite3PagerLookup(). Both this routine and Lookup() attempt +** to find a page in the in-memory cache first. If the page is not already +** in memory, this routine goes to disk to read it in whereas Lookup() +** just returns 0. This routine acquires a read-lock the first time it +** has to go to disk, and could also playback an old journal if necessary. +** Since Lookup() never goes to disk, it never has to deal with locks +** or journal files. +** +** If noContent is false, the page contents are actually read from disk. +** If noContent is true, it means that we do not care about the contents +** of the page at this time, so do not do a disk read. Just fill in the +** page content with zeros. But mark the fact that we have not read the +** content by setting the PgHdr.needRead flag. Later on, if +** sqlite3PagerWrite() is called on this page or if this routine is +** called again with noContent==0, that means that the content is needed +** and the disk read should occur at that point. +*/ +static int pagerAcquire( + Pager *pPager, /* The pager open on the database file */ + Pgno pgno, /* Page number to fetch */ + DbPage **ppPage, /* Write a pointer to the page here */ + int noContent /* Do not bother reading content from disk if true */ +){ + PgHdr *pPg; + int rc; + + assert( pPager->state==PAGER_UNLOCK || pPager->nRef>0 || pgno==1 ); + + /* The maximum page number is 2^31. Return SQLITE_CORRUPT if a page + ** number greater than this, or zero, is requested. + */ + if( pgno>PAGER_MAX_PGNO || pgno==0 || pgno==PAGER_MJ_PGNO(pPager) ){ + return SQLITE_CORRUPT_BKPT; + } + + /* Make sure we have not hit any critical errors. + */ + assert( pPager!=0 ); + *ppPage = 0; + + /* If this is the first page accessed, then get a SHARED lock + ** on the database file. pagerSharedLock() is a no-op if + ** a database lock is already held. + */ + rc = pagerSharedLock(pPager); + if( rc!=SQLITE_OK ){ + return rc; + } + assert( pPager->state!=PAGER_UNLOCK ); + + pPg = pager_lookup(pPager, pgno); + if( pPg==0 ){ + /* The requested page is not in the page cache. */ + int nMax; + int h; + PAGER_INCR(pPager->nMiss); + rc = pagerAllocatePage(pPager, &pPg); + if( rc!=SQLITE_OK ){ + return rc; + } + + pPg->pgno = pgno; + assert( !MEMDB || pgno>pPager->stmtSize ); + if( pPager->aInJournal && (int)pgno<=pPager->origDbSize ){ +#if 0 + sqlite3CheckMemory(pPager->aInJournal, pgno/8); +#endif + assert( pPager->journalOpen ); + pPg->inJournal = (pPager->aInJournal[pgno/8] & (1<<(pgno&7)))!=0; + pPg->needSync = 0; + }else{ + pPg->inJournal = 0; + pPg->needSync = 0; + } + + makeClean(pPg); + pPg->nRef = 1; + REFINFO(pPg); + + pPager->nRef++; + if( pPager->nExtra>0 ){ + memset(PGHDR_TO_EXTRA(pPg, pPager), 0, pPager->nExtra); + } + nMax = sqlite3PagerPagecount(pPager); + if( pPager->errCode ){ + rc = pPager->errCode; + sqlite3PagerUnref(pPg); + return rc; + } + + /* Populate the page with data, either by reading from the database + ** file, or by setting the entire page to zero. + */ + if( nMax<(int)pgno || MEMDB || (noContent && !pPager->alwaysRollback) ){ + if( pgno>pPager->mxPgno ){ + sqlite3PagerUnref(pPg); + return SQLITE_FULL; + } + memset(PGHDR_TO_DATA(pPg), 0, pPager->pageSize); + pPg->needRead = noContent && !pPager->alwaysRollback; + IOTRACE(("ZERO %p %d\n", pPager, pgno)); + }else{ + rc = readDbPage(pPager, pPg, pgno); + if( rc!=SQLITE_OK && rc!=SQLITE_IOERR_SHORT_READ ){ + pPg->pgno = 0; + sqlite3PagerUnref(pPg); + return rc; + } + pPg->needRead = 0; + } + + /* Link the page into the page hash table */ + h = pgno & (pPager->nHash-1); + assert( pgno!=0 ); + pPg->pNextHash = pPager->aHash[h]; + pPager->aHash[h] = pPg; + if( pPg->pNextHash ){ + assert( pPg->pNextHash->pPrevHash==0 ); + pPg->pNextHash->pPrevHash = pPg; + } + +#ifdef SQLITE_CHECK_PAGES + pPg->pageHash = pager_pagehash(pPg); +#endif + }else{ + /* The requested page is in the page cache. */ + assert(pPager->nRef>0 || pgno==1); + PAGER_INCR(pPager->nHit); + if( !noContent ){ + rc = pager_get_content(pPg); + if( rc ){ + return rc; + } + } + page_ref(pPg); + } + *ppPage = pPg; + return SQLITE_OK; +} +int sqlite3PagerAcquire( + Pager *pPager, /* The pager open on the database file */ + Pgno pgno, /* Page number to fetch */ + DbPage **ppPage, /* Write a pointer to the page here */ + int noContent /* Do not bother reading content from disk if true */ +){ + int rc; + pagerEnter(pPager); + rc = pagerAcquire(pPager, pgno, ppPage, noContent); + pagerLeave(pPager); + return rc; +} + + +/* +** Acquire a page if it is already in the in-memory cache. Do +** not read the page from disk. Return a pointer to the page, +** or 0 if the page is not in cache. +** +** See also sqlite3PagerGet(). The difference between this routine +** and sqlite3PagerGet() is that _get() will go to the disk and read +** in the page if the page is not already in cache. This routine +** returns NULL if the page is not in cache or if a disk I/O error +** has ever happened. +*/ +DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno){ + PgHdr *pPg = 0; + + assert( pPager!=0 ); + assert( pgno!=0 ); + + pagerEnter(pPager); + if( pPager->state==PAGER_UNLOCK ){ + assert( !pPager->pAll || pPager->exclusiveMode ); + }else if( pPager->errCode && pPager->errCode!=SQLITE_FULL ){ + /* Do nothing */ + }else if( (pPg = pager_lookup(pPager, pgno))!=0 ){ + page_ref(pPg); + } + pagerLeave(pPager); + return pPg; +} + +/* +** Release a page. +** +** If the number of references to the page drop to zero, then the +** page is added to the LRU list. When all references to all pages +** are released, a rollback occurs and the lock on the database is +** removed. +*/ +int sqlite3PagerUnref(DbPage *pPg){ + Pager *pPager = pPg->pPager; + + /* Decrement the reference count for this page + */ + assert( pPg->nRef>0 ); + pagerEnter(pPg->pPager); + pPg->nRef--; + REFINFO(pPg); + + CHECK_PAGE(pPg); + + /* When the number of references to a page reach 0, call the + ** destructor and add the page to the freelist. + */ + if( pPg->nRef==0 ){ + + lruListAdd(pPg); + if( pPager->xDestructor ){ + pPager->xDestructor(pPg, pPager->pageSize); + } + + /* When all pages reach the freelist, drop the read lock from + ** the database file. + */ + pPager->nRef--; + assert( pPager->nRef>=0 ); + if( pPager->nRef==0 && (!pPager->exclusiveMode || pPager->journalOff>0) ){ + pagerUnlockAndRollback(pPager); + } + } + pagerLeave(pPager); + return SQLITE_OK; +} + +/* +** Create a journal file for pPager. There should already be a RESERVED +** or EXCLUSIVE lock on the database file when this routine is called. +** +** Return SQLITE_OK if everything. Return an error code and release the +** write lock if anything goes wrong. +*/ +static int pager_open_journal(Pager *pPager){ + sqlite3_vfs *pVfs = pPager->pVfs; + int flags = (SQLITE_OPEN_READWRITE|SQLITE_OPEN_EXCLUSIVE|SQLITE_OPEN_CREATE); + + int rc; + assert( !MEMDB ); + assert( pPager->state>=PAGER_RESERVED ); + assert( pPager->journalOpen==0 ); + assert( pPager->useJournal ); + assert( pPager->aInJournal==0 ); + sqlite3PagerPagecount(pPager); + pagerLeave(pPager); + pPager->aInJournal = (u8*)sqlite3MallocZero( pPager->dbSize/8 + 1 ); + pagerEnter(pPager); + if( pPager->aInJournal==0 ){ + rc = SQLITE_NOMEM; + goto failed_to_open_journal; + } + + if( pPager->tempFile ){ + flags |= (SQLITE_OPEN_DELETEONCLOSE|SQLITE_OPEN_TEMP_JOURNAL); + }else{ + flags |= (SQLITE_OPEN_MAIN_JOURNAL); + } +#ifdef SQLITE_ENABLE_ATOMIC_WRITE + rc = sqlite3JournalOpen( + pVfs, pPager->zJournal, pPager->jfd, flags, jrnlBufferSize(pPager) + ); +#else + rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, flags, 0); +#endif + assert( rc!=SQLITE_OK || pPager->jfd->pMethods ); + pPager->journalOff = 0; + pPager->setMaster = 0; + pPager->journalHdr = 0; + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_NOMEM ){ + sqlite3OsDelete(pVfs, pPager->zJournal, 0); + } + goto failed_to_open_journal; + } + pPager->journalOpen = 1; + pPager->journalStarted = 0; + pPager->needSync = 0; + pPager->alwaysRollback = 0; + pPager->nRec = 0; + if( pPager->errCode ){ + rc = pPager->errCode; + goto failed_to_open_journal; + } + pPager->origDbSize = pPager->dbSize; + + rc = writeJournalHdr(pPager); + + if( pPager->stmtAutoopen && rc==SQLITE_OK ){ + rc = sqlite3PagerStmtBegin(pPager); + } + if( rc!=SQLITE_OK && rc!=SQLITE_NOMEM && rc!=SQLITE_IOERR_NOMEM ){ + rc = pager_end_transaction(pPager); + if( rc==SQLITE_OK ){ + rc = SQLITE_FULL; + } + } + return rc; + +failed_to_open_journal: + sqlite3_free(pPager->aInJournal); + pPager->aInJournal = 0; + return rc; +} + +/* +** Acquire a write-lock on the database. The lock is removed when +** the any of the following happen: +** +** * sqlite3PagerCommitPhaseTwo() is called. +** * sqlite3PagerRollback() is called. +** * sqlite3PagerClose() is called. +** * sqlite3PagerUnref() is called to on every outstanding page. +** +** The first parameter to this routine is a pointer to any open page of the +** database file. Nothing changes about the page - it is used merely to +** acquire a pointer to the Pager structure and as proof that there is +** already a read-lock on the database. +** +** The second parameter indicates how much space in bytes to reserve for a +** master journal file-name at the start of the journal when it is created. +** +** A journal file is opened if this is not a temporary file. For temporary +** files, the opening of the journal file is deferred until there is an +** actual need to write to the journal. +** +** If the database is already reserved for writing, this routine is a no-op. +** +** If exFlag is true, go ahead and get an EXCLUSIVE lock on the file +** immediately instead of waiting until we try to flush the cache. The +** exFlag is ignored if a transaction is already active. +*/ +int sqlite3PagerBegin(DbPage *pPg, int exFlag){ + Pager *pPager = pPg->pPager; + int rc = SQLITE_OK; + pagerEnter(pPager); + assert( pPg->nRef>0 ); + assert( pPager->state!=PAGER_UNLOCK ); + if( pPager->state==PAGER_SHARED ){ + assert( pPager->aInJournal==0 ); + if( MEMDB ){ + pPager->state = PAGER_EXCLUSIVE; + pPager->origDbSize = pPager->dbSize; + }else{ + rc = sqlite3OsLock(pPager->fd, RESERVED_LOCK); + if( rc==SQLITE_OK ){ + pPager->state = PAGER_RESERVED; + if( exFlag ){ + rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK); + } + } + if( rc!=SQLITE_OK ){ + pagerLeave(pPager); + return rc; + } + pPager->dirtyCache = 0; + PAGERTRACE2("TRANSACTION %d\n", PAGERID(pPager)); + if( pPager->useJournal && !pPager->tempFile ){ + rc = pager_open_journal(pPager); + } + } + }else if( pPager->journalOpen && pPager->journalOff==0 ){ + /* This happens when the pager was in exclusive-access mode last + ** time a (read or write) transaction was successfully concluded + ** by this connection. Instead of deleting the journal file it was + ** kept open and truncated to 0 bytes. + */ + assert( pPager->nRec==0 ); + assert( pPager->origDbSize==0 ); + assert( pPager->aInJournal==0 ); + sqlite3PagerPagecount(pPager); + pagerLeave(pPager); + pPager->aInJournal = (u8*)sqlite3MallocZero( pPager->dbSize/8 + 1 ); + pagerEnter(pPager); + if( !pPager->aInJournal ){ + rc = SQLITE_NOMEM; + }else{ + pPager->origDbSize = pPager->dbSize; + rc = writeJournalHdr(pPager); + } + } + assert( !pPager->journalOpen || pPager->journalOff>0 || rc!=SQLITE_OK ); + pagerLeave(pPager); + return rc; +} + +/* +** Make a page dirty. Set its dirty flag and add it to the dirty +** page list. +*/ +static void makeDirty(PgHdr *pPg){ + if( pPg->dirty==0 ){ + Pager *pPager = pPg->pPager; + pPg->dirty = 1; + pPg->pDirty = pPager->pDirty; + if( pPager->pDirty ){ + pPager->pDirty->pPrevDirty = pPg; + } + pPg->pPrevDirty = 0; + pPager->pDirty = pPg; + } +} + +/* +** Make a page clean. Clear its dirty bit and remove it from the +** dirty page list. +*/ +static void makeClean(PgHdr *pPg){ + if( pPg->dirty ){ + pPg->dirty = 0; + if( pPg->pDirty ){ + assert( pPg->pDirty->pPrevDirty==pPg ); + pPg->pDirty->pPrevDirty = pPg->pPrevDirty; + } + if( pPg->pPrevDirty ){ + assert( pPg->pPrevDirty->pDirty==pPg ); + pPg->pPrevDirty->pDirty = pPg->pDirty; + }else{ + assert( pPg->pPager->pDirty==pPg ); + pPg->pPager->pDirty = pPg->pDirty; + } + } +} + + +/* +** Mark a data page as writeable. The page is written into the journal +** if it is not there already. This routine must be called before making +** changes to a page. +** +** The first time this routine is called, the pager creates a new +** journal and acquires a RESERVED lock on the database. If the RESERVED +** lock could not be acquired, this routine returns SQLITE_BUSY. The +** calling routine must check for that return value and be careful not to +** change any page data until this routine returns SQLITE_OK. +** +** If the journal file could not be written because the disk is full, +** then this routine returns SQLITE_FULL and does an immediate rollback. +** All subsequent write attempts also return SQLITE_FULL until there +** is a call to sqlite3PagerCommit() or sqlite3PagerRollback() to +** reset. +*/ +static int pager_write(PgHdr *pPg){ + void *pData = PGHDR_TO_DATA(pPg); + Pager *pPager = pPg->pPager; + int rc = SQLITE_OK; + + /* Check for errors + */ + if( pPager->errCode ){ + return pPager->errCode; + } + if( pPager->readOnly ){ + return SQLITE_PERM; + } + + assert( !pPager->setMaster ); + + CHECK_PAGE(pPg); + + /* If this page was previously acquired with noContent==1, that means + ** we didn't really read in the content of the page. This can happen + ** (for example) when the page is being moved to the freelist. But + ** now we are (perhaps) moving the page off of the freelist for + ** reuse and we need to know its original content so that content + ** can be stored in the rollback journal. So do the read at this + ** time. + */ + rc = pager_get_content(pPg); + if( rc ){ + return rc; + } + + /* Mark the page as dirty. If the page has already been written + ** to the journal then we can return right away. + */ + makeDirty(pPg); + if( pPg->inJournal && (pageInStatement(pPg) || pPager->stmtInUse==0) ){ + pPager->dirtyCache = 1; + }else{ + + /* If we get this far, it means that the page needs to be + ** written to the transaction journal or the ckeckpoint journal + ** or both. + ** + ** First check to see that the transaction journal exists and + ** create it if it does not. + */ + assert( pPager->state!=PAGER_UNLOCK ); + rc = sqlite3PagerBegin(pPg, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + assert( pPager->state>=PAGER_RESERVED ); + if( !pPager->journalOpen && pPager->useJournal ){ + rc = pager_open_journal(pPager); + if( rc!=SQLITE_OK ) return rc; + } + assert( pPager->journalOpen || !pPager->useJournal ); + pPager->dirtyCache = 1; + + /* The transaction journal now exists and we have a RESERVED or an + ** EXCLUSIVE lock on the main database file. Write the current page to + ** the transaction journal if it is not there already. + */ + if( !pPg->inJournal && (pPager->useJournal || MEMDB) ){ + if( (int)pPg->pgno <= pPager->origDbSize ){ + if( MEMDB ){ + PgHistory *pHist = PGHDR_TO_HIST(pPg, pPager); + PAGERTRACE3("JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno); + assert( pHist->pOrig==0 ); + pHist->pOrig = (u8*)sqlite3_malloc( pPager->pageSize ); + if( !pHist->pOrig ){ + return SQLITE_NOMEM; + } + memcpy(pHist->pOrig, PGHDR_TO_DATA(pPg), pPager->pageSize); + }else{ + u32 cksum; + char *pData2; + + /* We should never write to the journal file the page that + ** contains the database locks. The following assert verifies + ** that we do not. */ + assert( pPg->pgno!=PAGER_MJ_PGNO(pPager) ); + pData2 = CODEC2(pPager, pData, pPg->pgno, 7); + cksum = pager_cksum(pPager, (u8*)pData2); + rc = write32bits(pPager->jfd, pPager->journalOff, pPg->pgno); + if( rc==SQLITE_OK ){ + rc = sqlite3OsWrite(pPager->jfd, pData2, pPager->pageSize, + pPager->journalOff + 4); + pPager->journalOff += pPager->pageSize+4; + } + if( rc==SQLITE_OK ){ + rc = write32bits(pPager->jfd, pPager->journalOff, cksum); + pPager->journalOff += 4; + } + IOTRACE(("JOUT %p %d %lld %d\n", pPager, pPg->pgno, + pPager->journalOff, pPager->pageSize)); + PAGER_INCR(sqlite3_pager_writej_count); + PAGERTRACE5("JOURNAL %d page %d needSync=%d hash(%08x)\n", + PAGERID(pPager), pPg->pgno, pPg->needSync, pager_pagehash(pPg)); + + /* An error has occured writing to the journal file. The + ** transaction will be rolled back by the layer above. + */ + if( rc!=SQLITE_OK ){ + return rc; + } + + pPager->nRec++; + assert( pPager->aInJournal!=0 ); + pPager->aInJournal[pPg->pgno/8] |= 1<<(pPg->pgno&7); + pPg->needSync = !pPager->noSync; + if( pPager->stmtInUse ){ + pPager->aInStmt[pPg->pgno/8] |= 1<<(pPg->pgno&7); + } + } + }else{ + pPg->needSync = !pPager->journalStarted && !pPager->noSync; + PAGERTRACE4("APPEND %d page %d needSync=%d\n", + PAGERID(pPager), pPg->pgno, pPg->needSync); + } + if( pPg->needSync ){ + pPager->needSync = 1; + } + pPg->inJournal = 1; + } + + /* If the statement journal is open and the page is not in it, + ** then write the current page to the statement journal. Note that + ** the statement journal format differs from the standard journal format + ** in that it omits the checksums and the header. + */ + if( pPager->stmtInUse + && !pageInStatement(pPg) + && (int)pPg->pgno<=pPager->stmtSize + ){ + assert( pPg->inJournal || (int)pPg->pgno>pPager->origDbSize ); + if( MEMDB ){ + PgHistory *pHist = PGHDR_TO_HIST(pPg, pPager); + assert( pHist->pStmt==0 ); + pHist->pStmt = (u8*)sqlite3_malloc( pPager->pageSize ); + if( pHist->pStmt ){ + memcpy(pHist->pStmt, PGHDR_TO_DATA(pPg), pPager->pageSize); + } + PAGERTRACE3("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno); + page_add_to_stmt_list(pPg); + }else{ + i64 offset = pPager->stmtNRec*(4+pPager->pageSize); + char *pData2 = CODEC2(pPager, pData, pPg->pgno, 7); + rc = write32bits(pPager->stfd, offset, pPg->pgno); + if( rc==SQLITE_OK ){ + rc = sqlite3OsWrite(pPager->stfd, pData2, pPager->pageSize, offset+4); + } + PAGERTRACE3("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno); + if( rc!=SQLITE_OK ){ + return rc; + } + pPager->stmtNRec++; + assert( pPager->aInStmt!=0 ); + pPager->aInStmt[pPg->pgno/8] |= 1<<(pPg->pgno&7); + } + } + } + + /* Update the database size and return. + */ + assert( pPager->state>=PAGER_SHARED ); + if( pPager->dbSize<(int)pPg->pgno ){ + pPager->dbSize = pPg->pgno; + if( !MEMDB && pPager->dbSize==PENDING_BYTE/pPager->pageSize ){ + pPager->dbSize++; + } + } + return rc; +} + +/* +** This function is used to mark a data-page as writable. It uses +** pager_write() to open a journal file (if it is not already open) +** and write the page *pData to the journal. +** +** The difference between this function and pager_write() is that this +** function also deals with the special case where 2 or more pages +** fit on a single disk sector. In this case all co-resident pages +** must have been written to the journal file before returning. +*/ +int sqlite3PagerWrite(DbPage *pDbPage){ + int rc = SQLITE_OK; + + PgHdr *pPg = pDbPage; + Pager *pPager = pPg->pPager; + Pgno nPagePerSector = (pPager->sectorSize/pPager->pageSize); + + pagerEnter(pPager); + if( !MEMDB && nPagePerSector>1 ){ + Pgno nPageCount; /* Total number of pages in database file */ + Pgno pg1; /* First page of the sector pPg is located on. */ + int nPage; /* Number of pages starting at pg1 to journal */ + int ii; + int needSync = 0; + + /* Set the doNotSync flag to 1. This is because we cannot allow a journal + ** header to be written between the pages journaled by this function. + */ + assert( pPager->doNotSync==0 ); + pPager->doNotSync = 1; + + /* This trick assumes that both the page-size and sector-size are + ** an integer power of 2. It sets variable pg1 to the identifier + ** of the first page of the sector pPg is located on. + */ + pg1 = ((pPg->pgno-1) & ~(nPagePerSector-1)) + 1; + + nPageCount = sqlite3PagerPagecount(pPager); + if( pPg->pgno>nPageCount ){ + nPage = (pPg->pgno - pg1)+1; + }else if( (pg1+nPagePerSector-1)>nPageCount ){ + nPage = nPageCount+1-pg1; + }else{ + nPage = nPagePerSector; + } + assert(nPage>0); + assert(pg1<=pPg->pgno); + assert((pg1+nPage)>pPg->pgno); + + for(ii=0; iiaInJournal || pg==pPg->pgno || + pg>pPager->origDbSize || !(pPager->aInJournal[pg/8]&(1<<(pg&7))) + ) { + if( pg!=PAGER_MJ_PGNO(pPager) ){ + rc = sqlite3PagerGet(pPager, pg, &pPage); + if( rc==SQLITE_OK ){ + rc = pager_write(pPage); + if( pPage->needSync ){ + needSync = 1; + } + sqlite3PagerUnref(pPage); + } + } + }else if( (pPage = pager_lookup(pPager, pg)) ){ + if( pPage->needSync ){ + needSync = 1; + } + } + } + + /* If the PgHdr.needSync flag is set for any of the nPage pages + ** starting at pg1, then it needs to be set for all of them. Because + ** writing to any of these nPage pages may damage the others, the + ** journal file must contain sync()ed copies of all of them + ** before any of them can be written out to the database file. + */ + if( needSync ){ + for(ii=0; iineedSync = 1; + } + assert(pPager->needSync); + } + + assert( pPager->doNotSync==1 ); + pPager->doNotSync = 0; + }else{ + rc = pager_write(pDbPage); + } + pagerLeave(pPager); + return rc; +} + +/* +** Return TRUE if the page given in the argument was previously passed +** to sqlite3PagerWrite(). In other words, return TRUE if it is ok +** to change the content of the page. +*/ +#ifndef NDEBUG +int sqlite3PagerIswriteable(DbPage *pPg){ + return pPg->dirty; +} +#endif + +#ifndef SQLITE_OMIT_VACUUM +/* +** Replace the content of a single page with the information in the third +** argument. +*/ +int sqlite3PagerOverwrite(Pager *pPager, Pgno pgno, void *pData){ + PgHdr *pPg; + int rc; + + pagerEnter(pPager); + rc = sqlite3PagerGet(pPager, pgno, &pPg); + if( rc==SQLITE_OK ){ + rc = sqlite3PagerWrite(pPg); + if( rc==SQLITE_OK ){ + memcpy(sqlite3PagerGetData(pPg), pData, pPager->pageSize); + } + sqlite3PagerUnref(pPg); + } + pagerLeave(pPager); + return rc; +} +#endif + +/* +** A call to this routine tells the pager that it is not necessary to +** write the information on page pPg back to the disk, even though +** that page might be marked as dirty. +** +** The overlying software layer calls this routine when all of the data +** on the given page is unused. The pager marks the page as clean so +** that it does not get written to disk. +** +** Tests show that this optimization, together with the +** sqlite3PagerDontRollback() below, more than double the speed +** of large INSERT operations and quadruple the speed of large DELETEs. +** +** When this routine is called, set the alwaysRollback flag to true. +** Subsequent calls to sqlite3PagerDontRollback() for the same page +** will thereafter be ignored. This is necessary to avoid a problem +** where a page with data is added to the freelist during one part of +** a transaction then removed from the freelist during a later part +** of the same transaction and reused for some other purpose. When it +** is first added to the freelist, this routine is called. When reused, +** the sqlite3PagerDontRollback() routine is called. But because the +** page contains critical data, we still need to be sure it gets +** rolled back in spite of the sqlite3PagerDontRollback() call. +*/ +void sqlite3PagerDontWrite(DbPage *pDbPage){ + PgHdr *pPg = pDbPage; + Pager *pPager = pPg->pPager; + + if( MEMDB ) return; + pagerEnter(pPager); + pPg->alwaysRollback = 1; + if( pPg->dirty && !pPager->stmtInUse ){ + assert( pPager->state>=PAGER_SHARED ); + if( pPager->dbSize==(int)pPg->pgno && pPager->origDbSizedbSize ){ + /* If this pages is the last page in the file and the file has grown + ** during the current transaction, then do NOT mark the page as clean. + ** When the database file grows, we must make sure that the last page + ** gets written at least once so that the disk file will be the correct + ** size. If you do not write this page and the size of the file + ** on the disk ends up being too small, that can lead to database + ** corruption during the next transaction. + */ + }else{ + PAGERTRACE3("DONT_WRITE page %d of %d\n", pPg->pgno, PAGERID(pPager)); + IOTRACE(("CLEAN %p %d\n", pPager, pPg->pgno)) + makeClean(pPg); +#ifdef SQLITE_CHECK_PAGES + pPg->pageHash = pager_pagehash(pPg); +#endif + } + } + pagerLeave(pPager); +} + +/* +** A call to this routine tells the pager that if a rollback occurs, +** it is not necessary to restore the data on the given page. This +** means that the pager does not have to record the given page in the +** rollback journal. +** +** If we have not yet actually read the content of this page (if +** the PgHdr.needRead flag is set) then this routine acts as a promise +** that we will never need to read the page content in the future. +** so the needRead flag can be cleared at this point. +*/ +void sqlite3PagerDontRollback(DbPage *pPg){ + Pager *pPager = pPg->pPager; + + pagerEnter(pPager); + assert( pPager->state>=PAGER_RESERVED ); + if( pPager->journalOpen==0 ) return; + if( pPg->alwaysRollback || pPager->alwaysRollback || MEMDB ) return; + if( !pPg->inJournal && (int)pPg->pgno <= pPager->origDbSize ){ + assert( pPager->aInJournal!=0 ); + pPager->aInJournal[pPg->pgno/8] |= 1<<(pPg->pgno&7); + pPg->inJournal = 1; + pPg->needRead = 0; + if( pPager->stmtInUse ){ + pPager->aInStmt[pPg->pgno/8] |= 1<<(pPg->pgno&7); + } + PAGERTRACE3("DONT_ROLLBACK page %d of %d\n", pPg->pgno, PAGERID(pPager)); + IOTRACE(("GARBAGE %p %d\n", pPager, pPg->pgno)) + } + if( pPager->stmtInUse + && !pageInStatement(pPg) + && (int)pPg->pgno<=pPager->stmtSize + ){ + assert( pPg->inJournal || (int)pPg->pgno>pPager->origDbSize ); + assert( pPager->aInStmt!=0 ); + pPager->aInStmt[pPg->pgno/8] |= 1<<(pPg->pgno&7); + } + pagerLeave(pPager); +} + + +/* +** This routine is called to increment the database file change-counter, +** stored at byte 24 of the pager file. +*/ +static int pager_incr_changecounter(Pager *pPager, int isDirect){ + PgHdr *pPgHdr; + u32 change_counter; + int rc = SQLITE_OK; + + if( !pPager->changeCountDone ){ + /* Open page 1 of the file for writing. */ + rc = sqlite3PagerGet(pPager, 1, &pPgHdr); + if( rc!=SQLITE_OK ) return rc; + + if( !isDirect ){ + rc = sqlite3PagerWrite(pPgHdr); + if( rc!=SQLITE_OK ){ + sqlite3PagerUnref(pPgHdr); + return rc; + } + } + + /* Increment the value just read and write it back to byte 24. */ + change_counter = sqlite3Get4byte((u8*)pPager->dbFileVers); + change_counter++; + put32bits(((char*)PGHDR_TO_DATA(pPgHdr))+24, change_counter); + + if( isDirect && pPager->fd->isOpen ){ + const void *zBuf = PGHDR_TO_DATA(pPgHdr); + rc = sqlite3OsWrite(pPager->fd, zBuf, pPager->pageSize, 0); + } + + /* Release the page reference. */ + sqlite3PagerUnref(pPgHdr); + pPager->changeCountDone = 1; + } + return rc; +} + +/* +** Sync the database file for the pager pPager. zMaster points to the name +** of a master journal file that should be written into the individual +** journal file. zMaster may be NULL, which is interpreted as no master +** journal (a single database transaction). +** +** This routine ensures that the journal is synced, all dirty pages written +** to the database file and the database file synced. The only thing that +** remains to commit the transaction is to delete the journal file (or +** master journal file if specified). +** +** Note that if zMaster==NULL, this does not overwrite a previous value +** passed to an sqlite3PagerCommitPhaseOne() call. +** +** If parameter nTrunc is non-zero, then the pager file is truncated to +** nTrunc pages (this is used by auto-vacuum databases). +*/ +int sqlite3PagerCommitPhaseOne(Pager *pPager, const char *zMaster, Pgno nTrunc){ + int rc = SQLITE_OK; + + PAGERTRACE4("DATABASE SYNC: File=%s zMaster=%s nTrunc=%d\n", + pPager->zFilename, zMaster, nTrunc); + pagerEnter(pPager); + + /* If this is an in-memory db, or no pages have been written to, or this + ** function has already been called, it is a no-op. + */ + if( pPager->state!=PAGER_SYNCED && !MEMDB && pPager->dirtyCache ){ + PgHdr *pPg; + +#ifdef SQLITE_ENABLE_ATOMIC_WRITE + /* The atomic-write optimization can be used if all of the + ** following are true: + ** + ** + The file-system supports the atomic-write property for + ** blocks of size page-size, and + ** + This commit is not part of a multi-file transaction, and + ** + Exactly one page has been modified and store in the journal file. + ** + ** If the optimization can be used, then the journal file will never + ** be created for this transaction. + */ + int useAtomicWrite = ( + !zMaster && + pPager->journalOff==jrnlBufferSize(pPager) && + nTrunc==0 && + (0==pPager->pDirty || 0==pPager->pDirty->pDirty) + ); + if( useAtomicWrite ){ + /* Update the nRec field in the journal file. */ + int offset = pPager->journalHdr + sizeof(aJournalMagic); + assert(pPager->nRec==1); + rc = write32bits(pPager->jfd, offset, pPager->nRec); + + /* Update the db file change counter. The following call will modify + ** the in-memory representation of page 1 to include the updated + ** change counter and then write page 1 directly to the database + ** file. Because of the atomic-write property of the host file-system, + ** this is safe. + */ + if( rc==SQLITE_OK ){ + rc = pager_incr_changecounter(pPager, 1); + } + }else{ + rc = sqlite3JournalCreate(pPager->jfd); + } + + if( !useAtomicWrite && rc==SQLITE_OK ) +#endif + + /* If a master journal file name has already been written to the + ** journal file, then no sync is required. This happens when it is + ** written, then the process fails to upgrade from a RESERVED to an + ** EXCLUSIVE lock. The next time the process tries to commit the + ** transaction the m-j name will have already been written. + */ + if( !pPager->setMaster ){ + assert( pPager->journalOpen ); + rc = pager_incr_changecounter(pPager, 0); + if( rc!=SQLITE_OK ) goto sync_exit; +#ifndef SQLITE_OMIT_AUTOVACUUM + if( nTrunc!=0 ){ + /* If this transaction has made the database smaller, then all pages + ** being discarded by the truncation must be written to the journal + ** file. + */ + Pgno i; + int iSkip = PAGER_MJ_PGNO(pPager); + for( i=nTrunc+1; i<=pPager->origDbSize; i++ ){ + if( !(pPager->aInJournal[i/8] & (1<<(i&7))) && i!=iSkip ){ + rc = sqlite3PagerGet(pPager, i, &pPg); + if( rc!=SQLITE_OK ) goto sync_exit; + rc = sqlite3PagerWrite(pPg); + sqlite3PagerUnref(pPg); + if( rc!=SQLITE_OK ) goto sync_exit; + } + } + } +#endif + rc = writeMasterJournal(pPager, zMaster); + if( rc!=SQLITE_OK ) goto sync_exit; + rc = syncJournal(pPager); + } + if( rc!=SQLITE_OK ) goto sync_exit; + +#ifndef SQLITE_OMIT_AUTOVACUUM + if( nTrunc!=0 ){ + rc = sqlite3PagerTruncate(pPager, nTrunc); + if( rc!=SQLITE_OK ) goto sync_exit; + } +#endif + + /* Write all dirty pages to the database file */ + pPg = pager_get_all_dirty_pages(pPager); + rc = pager_write_pagelist(pPg); + if( rc!=SQLITE_OK ){ + while( pPg && !pPg->dirty ){ pPg = pPg->pDirty; } + pPager->pDirty = pPg; + goto sync_exit; + } + pPager->pDirty = 0; + + /* Sync the database file. */ + if( !pPager->noSync ){ + rc = sqlite3OsSync(pPager->fd, pPager->sync_flags); + } + IOTRACE(("DBSYNC %p\n", pPager)) + + pPager->state = PAGER_SYNCED; + }else if( MEMDB && nTrunc!=0 ){ + rc = sqlite3PagerTruncate(pPager, nTrunc); + } + +sync_exit: + if( rc==SQLITE_IOERR_BLOCKED ){ + /* pager_incr_changecounter() may attempt to obtain an exclusive + * lock to spill the cache and return IOERR_BLOCKED. But since + * there is no chance the cache is inconsistent, it is + * better to return SQLITE_BUSY. + */ + rc = SQLITE_BUSY; + } + pagerLeave(pPager); + return rc; +} + + +/* +** Commit all changes to the database and release the write lock. +** +** If the commit fails for any reason, a rollback attempt is made +** and an error code is returned. If the commit worked, SQLITE_OK +** is returned. +*/ +int sqlite3PagerCommitPhaseTwo(Pager *pPager){ + int rc; + PgHdr *pPg; + + if( pPager->errCode ){ + return pPager->errCode; + } + if( pPager->statedirty = 0; + pPg->inJournal = 0; + pHist->inStmt = 0; + pPg->needSync = 0; + pHist->pPrevStmt = pHist->pNextStmt = 0; + pPg = pPg->pDirty; + } + pPager->pDirty = 0; +#ifndef NDEBUG + for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){ + PgHistory *pHist = PGHDR_TO_HIST(pPg, pPager); + assert( !pPg->alwaysRollback ); + assert( !pHist->pOrig ); + assert( !pHist->pStmt ); + } +#endif + pPager->pStmt = 0; + pPager->state = PAGER_SHARED; + return SQLITE_OK; + } + assert( pPager->journalOpen || !pPager->dirtyCache ); + assert( pPager->state==PAGER_SYNCED || !pPager->dirtyCache ); + rc = pager_end_transaction(pPager); + rc = pager_error(pPager, rc); + pagerLeave(pPager); + return rc; +} + +/* +** Rollback all changes. The database falls back to PAGER_SHARED mode. +** All in-memory cache pages revert to their original data contents. +** The journal is deleted. +** +** This routine cannot fail unless some other process is not following +** the correct locking protocol or unless some other +** process is writing trash into the journal file (SQLITE_CORRUPT) or +** unless a prior malloc() failed (SQLITE_NOMEM). Appropriate error +** codes are returned for all these occasions. Otherwise, +** SQLITE_OK is returned. +*/ +int sqlite3PagerRollback(Pager *pPager){ + int rc; + PAGERTRACE2("ROLLBACK %d\n", PAGERID(pPager)); + if( MEMDB ){ + PgHdr *p; + for(p=pPager->pAll; p; p=p->pNextAll){ + PgHistory *pHist; + assert( !p->alwaysRollback ); + if( !p->dirty ){ + assert( !((PgHistory *)PGHDR_TO_HIST(p, pPager))->pOrig ); + assert( !((PgHistory *)PGHDR_TO_HIST(p, pPager))->pStmt ); + continue; + } + + pHist = PGHDR_TO_HIST(p, pPager); + if( pHist->pOrig ){ + memcpy(PGHDR_TO_DATA(p), pHist->pOrig, pPager->pageSize); + PAGERTRACE3("ROLLBACK-PAGE %d of %d\n", p->pgno, PAGERID(pPager)); + }else{ + PAGERTRACE3("PAGE %d is clean on %d\n", p->pgno, PAGERID(pPager)); + } + clearHistory(pHist); + p->dirty = 0; + p->inJournal = 0; + pHist->inStmt = 0; + pHist->pPrevStmt = pHist->pNextStmt = 0; + if( pPager->xReiniter ){ + pPager->xReiniter(p, pPager->pageSize); + } + } + pPager->pDirty = 0; + pPager->pStmt = 0; + pPager->dbSize = pPager->origDbSize; + pager_truncate_cache(pPager); + pPager->stmtInUse = 0; + pPager->state = PAGER_SHARED; + return SQLITE_OK; + } + + pagerEnter(pPager); + if( !pPager->dirtyCache || !pPager->journalOpen ){ + rc = pager_end_transaction(pPager); + pagerLeave(pPager); + return rc; + } + + if( pPager->errCode && pPager->errCode!=SQLITE_FULL ){ + if( pPager->state>=PAGER_EXCLUSIVE ){ + pager_playback(pPager, 0); + } + pagerLeave(pPager); + return pPager->errCode; + } + if( pPager->state==PAGER_RESERVED ){ + int rc2; + rc = pager_playback(pPager, 0); + rc2 = pager_end_transaction(pPager); + if( rc==SQLITE_OK ){ + rc = rc2; + } + }else{ + rc = pager_playback(pPager, 0); + } + /* pager_reset(pPager); */ + pPager->dbSize = -1; + + /* If an error occurs during a ROLLBACK, we can no longer trust the pager + ** cache. So call pager_error() on the way out to make any error + ** persistent. + */ + rc = pager_error(pPager, rc); + pagerLeave(pPager); + return rc; +} + +/* +** Return TRUE if the database file is opened read-only. Return FALSE +** if the database is (in theory) writable. +*/ +int sqlite3PagerIsreadonly(Pager *pPager){ + return pPager->readOnly; +} + +/* +** Return the number of references to the pager. +*/ +int sqlite3PagerRefcount(Pager *pPager){ + return pPager->nRef; +} + +#ifdef SQLITE_TEST +/* +** This routine is used for testing and analysis only. +*/ +int *sqlite3PagerStats(Pager *pPager){ + static int a[11]; + a[0] = pPager->nRef; + a[1] = pPager->nPage; + a[2] = pPager->mxPage; + a[3] = pPager->dbSize; + a[4] = pPager->state; + a[5] = pPager->errCode; + a[6] = pPager->nHit; + a[7] = pPager->nMiss; + a[8] = 0; /* Used to be pPager->nOvfl */ + a[9] = pPager->nRead; + a[10] = pPager->nWrite; + return a; +} +#endif + +/* +** Set the statement rollback point. +** +** This routine should be called with the transaction journal already +** open. A new statement journal is created that can be used to rollback +** changes of a single SQL command within a larger transaction. +*/ +static int pagerStmtBegin(Pager *pPager){ + int rc; + assert( !pPager->stmtInUse ); + assert( pPager->state>=PAGER_SHARED ); + assert( pPager->dbSize>=0 ); + PAGERTRACE2("STMT-BEGIN %d\n", PAGERID(pPager)); + if( MEMDB ){ + pPager->stmtInUse = 1; + pPager->stmtSize = pPager->dbSize; + return SQLITE_OK; + } + if( !pPager->journalOpen ){ + pPager->stmtAutoopen = 1; + return SQLITE_OK; + } + assert( pPager->journalOpen ); + pagerLeave(pPager); + assert( pPager->aInStmt==0 ); + pPager->aInStmt = (u8*)sqlite3MallocZero( pPager->dbSize/8 + 1 ); + pagerEnter(pPager); + if( pPager->aInStmt==0 ){ + /* sqlite3OsLock(pPager->fd, SHARED_LOCK); */ + return SQLITE_NOMEM; + } +#ifndef NDEBUG + rc = sqlite3OsFileSize(pPager->jfd, &pPager->stmtJSize); + if( rc ) goto stmt_begin_failed; + assert( pPager->stmtJSize == pPager->journalOff ); +#endif + pPager->stmtJSize = pPager->journalOff; + pPager->stmtSize = pPager->dbSize; + pPager->stmtHdrOff = 0; + pPager->stmtCksum = pPager->cksumInit; + if( !pPager->stmtOpen ){ + rc = sqlite3PagerOpentemp(pPager->pVfs, pPager->stfd, pPager->zStmtJrnl, + SQLITE_OPEN_SUBJOURNAL); + if( rc ){ + goto stmt_begin_failed; + } + pPager->stmtOpen = 1; + pPager->stmtNRec = 0; + } + pPager->stmtInUse = 1; + return SQLITE_OK; + +stmt_begin_failed: + if( pPager->aInStmt ){ + sqlite3_free(pPager->aInStmt); + pPager->aInStmt = 0; + } + return rc; +} +int sqlite3PagerStmtBegin(Pager *pPager){ + int rc; + pagerEnter(pPager); + rc = pagerStmtBegin(pPager); + pagerLeave(pPager); + return rc; +} + +/* +** Commit a statement. +*/ +int sqlite3PagerStmtCommit(Pager *pPager){ + pagerEnter(pPager); + if( pPager->stmtInUse ){ + PgHdr *pPg, *pNext; + PAGERTRACE2("STMT-COMMIT %d\n", PAGERID(pPager)); + if( !MEMDB ){ + /* sqlite3OsTruncate(pPager->stfd, 0); */ + sqlite3_free( pPager->aInStmt ); + pPager->aInStmt = 0; + }else{ + for(pPg=pPager->pStmt; pPg; pPg=pNext){ + PgHistory *pHist = PGHDR_TO_HIST(pPg, pPager); + pNext = pHist->pNextStmt; + assert( pHist->inStmt ); + pHist->inStmt = 0; + pHist->pPrevStmt = pHist->pNextStmt = 0; + sqlite3_free(pHist->pStmt); + pHist->pStmt = 0; + } + } + pPager->stmtNRec = 0; + pPager->stmtInUse = 0; + pPager->pStmt = 0; + } + pPager->stmtAutoopen = 0; + pagerLeave(pPager); + return SQLITE_OK; +} + +/* +** Rollback a statement. +*/ +int sqlite3PagerStmtRollback(Pager *pPager){ + int rc; + pagerEnter(pPager); + if( pPager->stmtInUse ){ + PAGERTRACE2("STMT-ROLLBACK %d\n", PAGERID(pPager)); + if( MEMDB ){ + PgHdr *pPg; + PgHistory *pHist; + for(pPg=pPager->pStmt; pPg; pPg=pHist->pNextStmt){ + pHist = PGHDR_TO_HIST(pPg, pPager); + if( pHist->pStmt ){ + memcpy(PGHDR_TO_DATA(pPg), pHist->pStmt, pPager->pageSize); + sqlite3_free(pHist->pStmt); + pHist->pStmt = 0; + } + } + pPager->dbSize = pPager->stmtSize; + pager_truncate_cache(pPager); + rc = SQLITE_OK; + }else{ + rc = pager_stmt_playback(pPager); + } + sqlite3PagerStmtCommit(pPager); + }else{ + rc = SQLITE_OK; + } + pPager->stmtAutoopen = 0; + pagerLeave(pPager); + return rc; +} + +/* +** Return the full pathname of the database file. +*/ +const char *sqlite3PagerFilename(Pager *pPager){ + return pPager->zFilename; +} + +/* +** Return the VFS structure for the pager. +*/ +const sqlite3_vfs *sqlite3PagerVfs(Pager *pPager){ + return pPager->pVfs; +} + +/* +** Return the file handle for the database file associated +** with the pager. This might return NULL if the file has +** not yet been opened. +*/ +sqlite3_file *sqlite3PagerFile(Pager *pPager){ + return pPager->fd; +} + +/* +** Return the directory of the database file. +*/ +const char *sqlite3PagerDirname(Pager *pPager){ + return pPager->zDirectory; +} + +/* +** Return the full pathname of the journal file. +*/ +const char *sqlite3PagerJournalname(Pager *pPager){ + return pPager->zJournal; +} + +/* +** Return true if fsync() calls are disabled for this pager. Return FALSE +** if fsync()s are executed normally. +*/ +int sqlite3PagerNosync(Pager *pPager){ + return pPager->noSync; +} + +#ifdef SQLITE_HAS_CODEC +/* +** Set the codec for this pager +*/ +void sqlite3PagerSetCodec( + Pager *pPager, + void *(*xCodec)(void*,void*,Pgno,int), + void *pCodecArg +){ + pPager->xCodec = xCodec; + pPager->pCodecArg = pCodecArg; +} +#endif + +#ifndef SQLITE_OMIT_AUTOVACUUM +/* +** Move the page pPg to location pgno in the file. +** +** There must be no references to the page previously located at +** pgno (which we call pPgOld) though that page is allowed to be +** in cache. If the page previous located at pgno is not already +** in the rollback journal, it is not put there by by this routine. +** +** References to the page pPg remain valid. Updating any +** meta-data associated with pPg (i.e. data stored in the nExtra bytes +** allocated along with the page) is the responsibility of the caller. +** +** A transaction must be active when this routine is called. It used to be +** required that a statement transaction was not active, but this restriction +** has been removed (CREATE INDEX needs to move a page when a statement +** transaction is active). +*/ +int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno){ + PgHdr *pPgOld; /* The page being overwritten. */ + int h; + Pgno needSyncPgno = 0; + + pagerEnter(pPager); + assert( pPg->nRef>0 ); + + PAGERTRACE5("MOVE %d page %d (needSync=%d) moves to %d\n", + PAGERID(pPager), pPg->pgno, pPg->needSync, pgno); + IOTRACE(("MOVE %p %d %d\n", pPager, pPg->pgno, pgno)) + + pager_get_content(pPg); + if( pPg->needSync ){ + needSyncPgno = pPg->pgno; + assert( pPg->inJournal || (int)pgno>pPager->origDbSize ); + assert( pPg->dirty ); + assert( pPager->needSync ); + } + + /* Unlink pPg from its hash-chain */ + unlinkHashChain(pPager, pPg); + + /* If the cache contains a page with page-number pgno, remove it + ** from its hash chain. Also, if the PgHdr.needSync was set for + ** page pgno before the 'move' operation, it needs to be retained + ** for the page moved there. + */ + pPg->needSync = 0; + pPgOld = pager_lookup(pPager, pgno); + if( pPgOld ){ + assert( pPgOld->nRef==0 ); + unlinkHashChain(pPager, pPgOld); + makeClean(pPgOld); + pPg->needSync = pPgOld->needSync; + }else{ + pPg->needSync = 0; + } + if( pPager->aInJournal && (int)pgno<=pPager->origDbSize ){ + pPg->inJournal = (pPager->aInJournal[pgno/8] & (1<<(pgno&7)))!=0; + }else{ + pPg->inJournal = 0; + assert( pPg->needSync==0 || (int)pgno>pPager->origDbSize ); + } + + /* Change the page number for pPg and insert it into the new hash-chain. */ + assert( pgno!=0 ); + pPg->pgno = pgno; + h = pgno & (pPager->nHash-1); + if( pPager->aHash[h] ){ + assert( pPager->aHash[h]->pPrevHash==0 ); + pPager->aHash[h]->pPrevHash = pPg; + } + pPg->pNextHash = pPager->aHash[h]; + pPager->aHash[h] = pPg; + pPg->pPrevHash = 0; + + makeDirty(pPg); + pPager->dirtyCache = 1; + + if( needSyncPgno ){ + /* If needSyncPgno is non-zero, then the journal file needs to be + ** sync()ed before any data is written to database file page needSyncPgno. + ** Currently, no such page exists in the page-cache and the + ** Pager.aInJournal bit has been set. This needs to be remedied by loading + ** the page into the pager-cache and setting the PgHdr.needSync flag. + ** + ** The sqlite3PagerGet() call may cause the journal to sync. So make + ** sure the Pager.needSync flag is set too. + */ + int rc; + PgHdr *pPgHdr; + assert( pPager->needSync ); + rc = sqlite3PagerGet(pPager, needSyncPgno, &pPgHdr); + if( rc!=SQLITE_OK ) return rc; + pPager->needSync = 1; + pPgHdr->needSync = 1; + pPgHdr->inJournal = 1; + makeDirty(pPgHdr); + sqlite3PagerUnref(pPgHdr); + } + + pagerLeave(pPager); + return SQLITE_OK; +} +#endif + +/* +** Return a pointer to the data for the specified page. +*/ +void *sqlite3PagerGetData(DbPage *pPg){ + return PGHDR_TO_DATA(pPg); +} + +/* +** Return a pointer to the Pager.nExtra bytes of "extra" space +** allocated along with the specified page. +*/ +void *sqlite3PagerGetExtra(DbPage *pPg){ + Pager *pPager = pPg->pPager; + return (pPager?PGHDR_TO_EXTRA(pPg, pPager):0); +} + +/* +** Get/set the locking-mode for this pager. Parameter eMode must be one +** of PAGER_LOCKINGMODE_QUERY, PAGER_LOCKINGMODE_NORMAL or +** PAGER_LOCKINGMODE_EXCLUSIVE. If the parameter is not _QUERY, then +** the locking-mode is set to the value specified. +** +** The returned value is either PAGER_LOCKINGMODE_NORMAL or +** PAGER_LOCKINGMODE_EXCLUSIVE, indicating the current (possibly updated) +** locking-mode. +*/ +int sqlite3PagerLockingMode(Pager *pPager, int eMode){ + assert( eMode==PAGER_LOCKINGMODE_QUERY + || eMode==PAGER_LOCKINGMODE_NORMAL + || eMode==PAGER_LOCKINGMODE_EXCLUSIVE ); + assert( PAGER_LOCKINGMODE_QUERY<0 ); + assert( PAGER_LOCKINGMODE_NORMAL>=0 && PAGER_LOCKINGMODE_EXCLUSIVE>=0 ); + if( eMode>=0 && !pPager->tempFile ){ + pPager->exclusiveMode = eMode; + } + return (int)pPager->exclusiveMode; +} + +#ifdef SQLITE_TEST +/* +** Print a listing of all referenced pages and their ref count. +*/ +void sqlite3PagerRefdump(Pager *pPager){ + PgHdr *pPg; + for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){ + if( pPg->nRef<=0 ) continue; + sqlite3DebugPrintf("PAGE %3d addr=%p nRef=%d\n", + pPg->pgno, PGHDR_TO_DATA(pPg), pPg->nRef); + } +} +#endif + +#endif /* SQLITE_OMIT_DISKIO */ diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/pager.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/pager.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,126 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This header file defines the interface that the sqlite page cache +** subsystem. The page cache subsystem reads and writes a file a page +** at a time and provides a journal for rollback. +** +** @(#) $Id: pager.h 1282 2008-11-13 09:31:33Z LarsPson $ +*/ + +#ifndef _PAGER_H_ +#define _PAGER_H_ + +/* +** The type used to represent a page number. The first page in a file +** is called page 1. 0 is used to represent "not a page". +*/ +typedef unsigned int Pgno; + +/* +** Each open file is managed by a separate instance of the "Pager" structure. +*/ +typedef struct Pager Pager; + +/* +** Handle type for pages. +*/ +typedef struct PgHdr DbPage; + +/* +** Allowed values for the flags parameter to sqlite3PagerOpen(). +** +** NOTE: This values must match the corresponding BTREE_ values in btree.h. +*/ +#define PAGER_OMIT_JOURNAL 0x0001 /* Do not use a rollback journal */ +#define PAGER_NO_READLOCK 0x0002 /* Omit readlocks on readonly files */ + +/* +** Valid values for the second argument to sqlite3PagerLockingMode(). +*/ +#define PAGER_LOCKINGMODE_QUERY -1 +#define PAGER_LOCKINGMODE_NORMAL 0 +#define PAGER_LOCKINGMODE_EXCLUSIVE 1 + +/* +** See source code comments for a detailed description of the following +** routines: +*/ +int sqlite3PagerOpen(sqlite3_vfs *, Pager **ppPager, const char*, int,int,int); +void sqlite3PagerSetBusyhandler(Pager*, BusyHandler *pBusyHandler); +void sqlite3PagerSetDestructor(Pager*, void(*)(DbPage*,int)); +void sqlite3PagerSetReiniter(Pager*, void(*)(DbPage*,int)); +int sqlite3PagerSetPagesize(Pager*, u16*); +int sqlite3PagerMaxPageCount(Pager*, int); +int sqlite3PagerReadFileheader(Pager*, int, unsigned char*); +void sqlite3PagerSetCachesize(Pager*, int); +int sqlite3PagerClose(Pager *pPager); +int sqlite3PagerAcquire(Pager *pPager, Pgno pgno, DbPage **ppPage, int clrFlag); +#define sqlite3PagerGet(A,B,C) sqlite3PagerAcquire(A,B,C,0) +DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno); +int sqlite3PagerRef(DbPage*); +int sqlite3PagerUnref(DbPage*); +int sqlite3PagerWrite(DbPage*); +int sqlite3PagerOverwrite(Pager *pPager, Pgno pgno, void*); +int sqlite3PagerPagecount(Pager*); +int sqlite3PagerTruncate(Pager*,Pgno); +int sqlite3PagerBegin(DbPage*, int exFlag); +int sqlite3PagerCommitPhaseOne(Pager*,const char *zMaster, Pgno); +int sqlite3PagerCommitPhaseTwo(Pager*); +int sqlite3PagerRollback(Pager*); +int sqlite3PagerIsreadonly(Pager*); +int sqlite3PagerStmtBegin(Pager*); +int sqlite3PagerStmtCommit(Pager*); +int sqlite3PagerStmtRollback(Pager*); +void sqlite3PagerDontRollback(DbPage*); +void sqlite3PagerDontWrite(DbPage*); +int sqlite3PagerRefcount(Pager*); +void sqlite3PagerSetSafetyLevel(Pager*,int,int); +const char *sqlite3PagerFilename(Pager*); +const sqlite3_vfs *sqlite3PagerVfs(Pager*); +sqlite3_file *sqlite3PagerFile(Pager*); +const char *sqlite3PagerDirname(Pager*); +const char *sqlite3PagerJournalname(Pager*); +int sqlite3PagerNosync(Pager*); +int sqlite3PagerMovepage(Pager*,DbPage*,Pgno); +void *sqlite3PagerGetData(DbPage *); +void *sqlite3PagerGetExtra(DbPage *); +int sqlite3PagerLockingMode(Pager *, int); +void *sqlite3PagerTempSpace(Pager*); + +#if defined(SQLITE_ENABLE_MEMORY_MANAGEMENT) && !defined(SQLITE_OMIT_DISKIO) + int sqlite3PagerReleaseMemory(int); +#endif + +#ifdef SQLITE_HAS_CODEC + void sqlite3PagerSetCodec(Pager*,void*(*)(void*,void*,Pgno,int),void*); +#endif + +#if !defined(NDEBUG) || defined(SQLITE_TEST) + Pgno sqlite3PagerPagenumber(DbPage*); + int sqlite3PagerIswriteable(DbPage*); +#endif + +#ifdef SQLITE_TEST + int *sqlite3PagerStats(Pager*); + void sqlite3PagerRefdump(Pager*); + int pager3_refinfo_enable; +#endif + +#ifdef SQLITE_TEST +void disable_simulated_io_errors(void); +void enable_simulated_io_errors(void); +#else +# define disable_simulated_io_errors() +# define enable_simulated_io_errors() +#endif + +#endif /* _PAGER_H_ */ diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/parse.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/parse.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,3537 @@ +/* Driver template for the LEMON parser generator. +** The author disclaims copyright to this source code. +*/ +/* First off, code is include which follows the "include" declaration +** in the input file. */ +#include +#line 56 "parse.y" + +#include "sqliteInt.h" + +/* +** An instance of this structure holds information about the +** LIMIT clause of a SELECT statement. +*/ +struct LimitVal { + Expr *pLimit; /* The LIMIT expression. NULL if there is no limit */ + Expr *pOffset; /* The OFFSET expression. NULL if there is none */ +}; + +/* +** An instance of this structure is used to store the LIKE, +** GLOB, NOT LIKE, and NOT GLOB operators. +*/ + +struct LikeOp { + Token eOperator; /* "like" or "glob" or "regexp" */ + int notValue; /* True if the NOT keyword is present */ +}; + +/* +** An instance of the following structure describes the event of a +** TRIGGER. "a" is the event type, one of TK_UPDATE, TK_INSERT, +** TK_DELETE, or TK_INSTEAD. If the event is of the form +** +** UPDATE ON (a,b,c) +** +** Then the "b" IdList records the list "a,b,c". +*/ +struct TrigEvent { int a; IdList * b; }; + +/* +** An instance of this structure holds the ATTACH key and the key type. +*/ +struct AttachKey { int type; Token key; }; + +#line 47 "parse.c" +/* Next is all token values, in a form suitable for use by makeheaders. +** This section will be null unless lemon is run with the -m switch. +*/ +/* +** These constants (all generated automatically by the parser generator) +** specify the various kinds of tokens (terminals) that the parser +** understands. +** +** Each symbol here is a terminal symbol in the grammar. +*/ +/* Make sure the INTERFACE macro is defined. +*/ +#ifndef INTERFACE +# define INTERFACE 1 +#endif +/* The next thing included is series of defines which control +** various aspects of the generated parser. +** YYCODETYPE is the data type used for storing terminal +** and nonterminal numbers. "unsigned char" is +** used if there are fewer than 250 terminals +** and nonterminals. "int" is used otherwise. +** YYNOCODE is a number of type YYCODETYPE which corresponds +** to no legal terminal or nonterminal number. This +** number is used to fill in empty slots of the hash +** table. +** YYFALLBACK If defined, this indicates that one or more tokens +** have fall-back values which should be used if the +** original value of the token will not parse. +** YYACTIONTYPE is the data type used for storing terminal +** and nonterminal numbers. "unsigned char" is +** used if there are fewer than 250 rules and +** states combined. "int" is used otherwise. +** sqlite3ParserTOKENTYPE is the data type used for minor tokens given +** directly to the parser from the tokenizer. +** YYMINORTYPE is the data type used for all minor tokens. +** This is typically a union of many types, one of +** which is sqlite3ParserTOKENTYPE. The entry in the union +** for base tokens is called "yy0". +** YYSTACKDEPTH is the maximum depth of the parser's stack. If +** zero the stack is dynamically sized using realloc() +** sqlite3ParserARG_SDECL A static variable declaration for the %extra_argument +** sqlite3ParserARG_PDECL A parameter declaration for the %extra_argument +** sqlite3ParserARG_STORE Code to store %extra_argument into yypParser +** sqlite3ParserARG_FETCH Code to extract %extra_argument from yypParser +** YYNSTATE the combined number of states. +** YYNRULE the number of rules in the grammar +** YYERRORSYMBOL is the code number of the error symbol. If not +** defined, then do no error processing. +*/ +#define YYCODETYPE unsigned char +#define YYNOCODE 248 +#define YYACTIONTYPE unsigned short int +#define YYWILDCARD 59 +#define sqlite3ParserTOKENTYPE Token +typedef union { + sqlite3ParserTOKENTYPE yy0; + int yy46; + struct LikeOp yy72; + Expr* yy172; + ExprList* yy174; + Select* yy219; + struct LimitVal yy234; + TriggerStep* yy243; + struct TrigEvent yy370; + SrcList* yy373; + Expr * yy386; + struct {int value; int mask;} yy405; + Token yy410; + IdList* yy432; + int yy495; +} YYMINORTYPE; +#ifndef YYSTACKDEPTH +#define YYSTACKDEPTH 100 +#endif +#define sqlite3ParserARG_SDECL Parse *pParse; +#define sqlite3ParserARG_PDECL ,Parse *pParse +#define sqlite3ParserARG_FETCH Parse *pParse = yypParser->pParse +#define sqlite3ParserARG_STORE yypParser->pParse = pParse +#define YYNSTATE 588 +#define YYNRULE 312 +#define YYERRORSYMBOL 138 +#define YYERRSYMDT yy495 +#define YYFALLBACK 1 +#define YY_NO_ACTION (YYNSTATE+YYNRULE+2) +#define YY_ACCEPT_ACTION (YYNSTATE+YYNRULE+1) +#define YY_ERROR_ACTION (YYNSTATE+YYNRULE) + +/* Next are that tables used to determine what action to take based on the +** current state and lookahead token. These tables are used to implement +** functions that take a state number and lookahead value and return an +** action integer. +** +** Suppose the action integer is N. Then the action is determined as +** follows +** +** 0 <= N < YYNSTATE Shift N. That is, push the lookahead +** token onto the stack and goto state N. +** +** YYNSTATE <= N < YYNSTATE+YYNRULE Reduce by rule N-YYNSTATE. +** +** N == YYNSTATE+YYNRULE A syntax error has occurred. +** +** N == YYNSTATE+YYNRULE+1 The parser accepts its input. +** +** N == YYNSTATE+YYNRULE+2 No such action. Denotes unused +** slots in the yy_action[] table. +** +** The action table is constructed as a single large table named yy_action[]. +** Given state S and lookahead X, the action is computed as +** +** yy_action[ yy_shift_ofst[S] + X ] +** +** If the index value yy_shift_ofst[S]+X is out of range or if the value +** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X or if yy_shift_ofst[S] +** is equal to YY_SHIFT_USE_DFLT, it means that the action is not in the table +** and that yy_default[S] should be used instead. +** +** The formula above is for computing the action when the lookahead is +** a terminal symbol. If the lookahead is a non-terminal (as occurs after +** a reduce action) then the yy_reduce_ofst[] array is used in place of +** the yy_shift_ofst[] array and YY_REDUCE_USE_DFLT is used in place of +** YY_SHIFT_USE_DFLT. +** +** The following are the tables generated in this section: +** +** yy_action[] A single table containing all actions. +** yy_lookahead[] A table containing the lookahead for each entry in +** yy_action. Used to detect hash collisions. +** yy_shift_ofst[] For each state, the offset into yy_action for +** shifting terminals. +** yy_reduce_ofst[] For each state, the offset into yy_action for +** shifting non-terminals after a reduce. +** yy_default[] Default action for each state. +*/ +static const YYACTIONTYPE yy_action[] = { + /* 0 */ 299, 901, 124, 587, 416, 174, 2, 425, 61, 61, + /* 10 */ 61, 61, 297, 63, 63, 63, 63, 64, 64, 65, + /* 20 */ 65, 65, 66, 212, 454, 214, 432, 438, 68, 63, + /* 30 */ 63, 63, 63, 64, 64, 65, 65, 65, 66, 212, + /* 40 */ 398, 395, 403, 458, 60, 59, 304, 442, 443, 439, + /* 50 */ 439, 62, 62, 61, 61, 61, 61, 265, 63, 63, + /* 60 */ 63, 63, 64, 64, 65, 65, 65, 66, 212, 299, + /* 70 */ 500, 501, 425, 496, 210, 82, 67, 427, 69, 156, + /* 80 */ 63, 63, 63, 63, 64, 64, 65, 65, 65, 66, + /* 90 */ 212, 67, 469, 69, 156, 432, 438, 573, 266, 58, + /* 100 */ 64, 64, 65, 65, 65, 66, 212, 404, 405, 429, + /* 110 */ 429, 429, 299, 60, 59, 304, 442, 443, 439, 439, + /* 120 */ 62, 62, 61, 61, 61, 61, 324, 63, 63, 63, + /* 130 */ 63, 64, 64, 65, 65, 65, 66, 212, 432, 438, + /* 140 */ 94, 65, 65, 65, 66, 212, 403, 212, 421, 34, + /* 150 */ 56, 305, 449, 450, 417, 481, 60, 59, 304, 442, + /* 160 */ 443, 439, 439, 62, 62, 61, 61, 61, 61, 495, + /* 170 */ 63, 63, 63, 63, 64, 64, 65, 65, 65, 66, + /* 180 */ 212, 299, 259, 524, 203, 571, 113, 415, 522, 458, + /* 190 */ 338, 324, 414, 20, 241, 347, 297, 403, 471, 531, + /* 200 */ 292, 454, 214, 570, 569, 472, 530, 432, 438, 151, + /* 210 */ 152, 404, 405, 421, 41, 213, 153, 533, 422, 496, + /* 220 */ 263, 568, 261, 427, 299, 60, 59, 304, 442, 443, + /* 230 */ 439, 439, 62, 62, 61, 61, 61, 61, 324, 63, + /* 240 */ 63, 63, 63, 64, 64, 65, 65, 65, 66, 212, + /* 250 */ 432, 438, 454, 340, 217, 429, 429, 429, 219, 550, + /* 260 */ 421, 41, 404, 405, 490, 567, 213, 299, 60, 59, + /* 270 */ 304, 442, 443, 439, 439, 62, 62, 61, 61, 61, + /* 280 */ 61, 652, 63, 63, 63, 63, 64, 64, 65, 65, + /* 290 */ 65, 66, 212, 432, 438, 103, 652, 549, 524, 519, + /* 300 */ 652, 216, 652, 67, 231, 69, 156, 534, 20, 66, + /* 310 */ 212, 60, 59, 304, 442, 443, 439, 439, 62, 62, + /* 320 */ 61, 61, 61, 61, 265, 63, 63, 63, 63, 64, + /* 330 */ 64, 65, 65, 65, 66, 212, 654, 324, 288, 77, + /* 340 */ 299, 456, 523, 170, 491, 155, 232, 380, 271, 270, + /* 350 */ 327, 654, 445, 445, 485, 654, 485, 654, 210, 421, + /* 360 */ 27, 456, 330, 170, 652, 391, 432, 438, 497, 425, + /* 370 */ 652, 652, 652, 652, 652, 652, 652, 252, 654, 422, + /* 380 */ 581, 291, 80, 652, 60, 59, 304, 442, 443, 439, + /* 390 */ 439, 62, 62, 61, 61, 61, 61, 210, 63, 63, + /* 400 */ 63, 63, 64, 64, 65, 65, 65, 66, 212, 299, + /* 410 */ 379, 585, 892, 494, 892, 306, 393, 368, 324, 654, + /* 420 */ 21, 324, 307, 324, 425, 654, 654, 654, 654, 654, + /* 430 */ 654, 654, 571, 654, 425, 432, 438, 532, 654, 654, + /* 440 */ 421, 49, 485, 421, 35, 421, 49, 329, 449, 450, + /* 450 */ 570, 582, 348, 60, 59, 304, 442, 443, 439, 439, + /* 460 */ 62, 62, 61, 61, 61, 61, 655, 63, 63, 63, + /* 470 */ 63, 64, 64, 65, 65, 65, 66, 212, 299, 420, + /* 480 */ 198, 655, 509, 419, 324, 655, 315, 655, 653, 425, + /* 490 */ 223, 316, 653, 525, 653, 238, 166, 118, 245, 350, + /* 500 */ 250, 351, 178, 314, 432, 438, 421, 34, 655, 254, + /* 510 */ 239, 213, 389, 213, 422, 653, 588, 398, 395, 406, + /* 520 */ 407, 408, 60, 59, 304, 442, 443, 439, 439, 62, + /* 530 */ 62, 61, 61, 61, 61, 335, 63, 63, 63, 63, + /* 540 */ 64, 64, 65, 65, 65, 66, 212, 299, 342, 655, + /* 550 */ 307, 257, 463, 547, 501, 655, 655, 655, 655, 655, + /* 560 */ 655, 655, 653, 655, 464, 653, 653, 653, 655, 655, + /* 570 */ 653, 161, 498, 432, 438, 653, 653, 465, 1, 502, + /* 580 */ 544, 418, 403, 585, 891, 176, 891, 343, 174, 503, + /* 590 */ 425, 60, 59, 304, 442, 443, 439, 439, 62, 62, + /* 600 */ 61, 61, 61, 61, 240, 63, 63, 63, 63, 64, + /* 610 */ 64, 65, 65, 65, 66, 212, 299, 381, 223, 422, + /* 620 */ 9, 93, 377, 582, 403, 118, 245, 350, 250, 351, + /* 630 */ 178, 177, 162, 325, 403, 183, 345, 254, 352, 355, + /* 640 */ 356, 227, 432, 438, 446, 320, 399, 404, 405, 357, + /* 650 */ 459, 209, 540, 367, 540, 425, 546, 302, 202, 299, + /* 660 */ 60, 59, 304, 442, 443, 439, 439, 62, 62, 61, + /* 670 */ 61, 61, 61, 402, 63, 63, 63, 63, 64, 64, + /* 680 */ 65, 65, 65, 66, 212, 432, 438, 225, 524, 404, + /* 690 */ 405, 489, 422, 397, 18, 824, 2, 578, 20, 404, + /* 700 */ 405, 194, 299, 60, 59, 304, 442, 443, 439, 439, + /* 710 */ 62, 62, 61, 61, 61, 61, 386, 63, 63, 63, + /* 720 */ 63, 64, 64, 65, 65, 65, 66, 212, 432, 438, + /* 730 */ 327, 370, 445, 445, 481, 422, 327, 373, 445, 445, + /* 740 */ 275, 519, 519, 8, 394, 299, 60, 70, 304, 442, + /* 750 */ 443, 439, 439, 62, 62, 61, 61, 61, 61, 378, + /* 760 */ 63, 63, 63, 63, 64, 64, 65, 65, 65, 66, + /* 770 */ 212, 432, 438, 243, 211, 167, 310, 224, 278, 196, + /* 780 */ 276, 55, 374, 519, 180, 181, 182, 519, 299, 119, + /* 790 */ 59, 304, 442, 443, 439, 439, 62, 62, 61, 61, + /* 800 */ 61, 61, 646, 63, 63, 63, 63, 64, 64, 65, + /* 810 */ 65, 65, 66, 212, 432, 438, 403, 646, 311, 253, + /* 820 */ 253, 646, 312, 646, 327, 5, 445, 445, 481, 542, + /* 830 */ 154, 519, 474, 541, 304, 442, 443, 439, 439, 62, + /* 840 */ 62, 61, 61, 61, 61, 369, 63, 63, 63, 63, + /* 850 */ 64, 64, 65, 65, 65, 66, 212, 72, 331, 277, + /* 860 */ 4, 253, 377, 428, 303, 253, 313, 487, 622, 173, + /* 870 */ 162, 455, 328, 72, 331, 265, 4, 265, 84, 158, + /* 880 */ 303, 404, 405, 265, 67, 646, 69, 156, 328, 333, + /* 890 */ 360, 646, 646, 646, 646, 646, 646, 646, 183, 458, + /* 900 */ 185, 352, 355, 356, 646, 333, 388, 477, 188, 253, + /* 910 */ 433, 434, 357, 422, 463, 458, 557, 179, 559, 75, + /* 920 */ 74, 336, 403, 147, 560, 210, 464, 226, 73, 322, + /* 930 */ 323, 436, 437, 427, 422, 75, 74, 488, 387, 465, + /* 940 */ 475, 334, 422, 512, 73, 322, 323, 72, 331, 427, + /* 950 */ 4, 210, 467, 324, 303, 318, 123, 19, 480, 144, + /* 960 */ 435, 157, 328, 513, 484, 429, 429, 429, 430, 431, + /* 970 */ 11, 346, 301, 452, 452, 421, 34, 254, 324, 333, + /* 980 */ 251, 429, 429, 429, 430, 431, 11, 404, 405, 458, + /* 990 */ 265, 164, 293, 421, 3, 422, 228, 229, 230, 104, + /* 1000 */ 421, 28, 324, 403, 294, 324, 265, 265, 265, 75, + /* 1010 */ 74, 656, 207, 478, 283, 309, 179, 338, 73, 322, + /* 1020 */ 323, 284, 337, 427, 421, 23, 656, 421, 32, 324, + /* 1030 */ 656, 561, 656, 205, 420, 549, 326, 526, 419, 204, + /* 1040 */ 324, 128, 206, 324, 476, 511, 510, 279, 385, 281, + /* 1050 */ 514, 421, 53, 656, 515, 429, 429, 429, 430, 431, + /* 1060 */ 11, 649, 421, 52, 258, 421, 98, 324, 404, 405, + /* 1070 */ 183, 301, 260, 352, 355, 356, 649, 76, 650, 78, + /* 1080 */ 649, 246, 649, 262, 357, 384, 280, 270, 264, 421, + /* 1090 */ 96, 300, 247, 650, 656, 324, 210, 650, 191, 650, + /* 1100 */ 656, 656, 656, 656, 656, 656, 656, 653, 656, 324, + /* 1110 */ 364, 160, 440, 656, 656, 324, 295, 421, 101, 324, + /* 1120 */ 390, 583, 653, 324, 269, 324, 653, 447, 653, 22, + /* 1130 */ 372, 421, 102, 412, 375, 324, 476, 421, 112, 376, + /* 1140 */ 272, 421, 114, 324, 649, 421, 16, 421, 99, 653, + /* 1150 */ 649, 649, 649, 649, 649, 649, 649, 421, 33, 324, + /* 1160 */ 584, 650, 324, 649, 273, 421, 97, 650, 650, 650, + /* 1170 */ 650, 650, 650, 650, 483, 274, 175, 506, 507, 556, + /* 1180 */ 650, 421, 24, 324, 421, 54, 566, 516, 324, 128, + /* 1190 */ 653, 324, 256, 359, 128, 128, 653, 653, 653, 653, + /* 1200 */ 653, 653, 653, 324, 653, 421, 115, 146, 324, 653, + /* 1210 */ 421, 116, 282, 421, 117, 324, 545, 324, 128, 285, + /* 1220 */ 553, 324, 175, 324, 233, 421, 25, 554, 324, 91, + /* 1230 */ 421, 36, 324, 286, 324, 577, 426, 421, 37, 421, + /* 1240 */ 26, 324, 451, 421, 38, 421, 39, 324, 332, 324, + /* 1250 */ 421, 40, 324, 453, 421, 42, 421, 43, 564, 292, + /* 1260 */ 91, 324, 470, 421, 44, 324, 580, 324, 290, 421, + /* 1270 */ 29, 421, 30, 324, 421, 45, 324, 518, 298, 324, + /* 1280 */ 473, 248, 517, 421, 46, 324, 354, 421, 47, 421, + /* 1290 */ 48, 520, 552, 563, 165, 421, 31, 401, 421, 10, + /* 1300 */ 7, 421, 50, 409, 410, 411, 321, 421, 51, 84, + /* 1310 */ 423, 341, 237, 83, 339, 57, 234, 79, 235, 215, + /* 1320 */ 236, 172, 85, 424, 349, 344, 468, 125, 505, 308, + /* 1330 */ 295, 242, 499, 482, 244, 504, 486, 249, 508, 296, + /* 1340 */ 105, 221, 521, 149, 361, 150, 365, 527, 528, 529, + /* 1350 */ 186, 88, 121, 535, 187, 132, 363, 189, 142, 220, + /* 1360 */ 222, 383, 141, 190, 537, 192, 548, 371, 195, 267, + /* 1370 */ 382, 538, 133, 555, 562, 317, 134, 135, 136, 92, + /* 1380 */ 574, 138, 95, 575, 576, 579, 111, 100, 400, 319, + /* 1390 */ 122, 17, 413, 623, 624, 168, 169, 441, 444, 71, + /* 1400 */ 460, 448, 457, 143, 159, 171, 461, 6, 462, 479, + /* 1410 */ 466, 13, 126, 81, 12, 127, 163, 492, 493, 218, + /* 1420 */ 86, 353, 106, 358, 255, 107, 120, 87, 108, 184, + /* 1430 */ 247, 362, 145, 536, 175, 129, 366, 193, 109, 268, + /* 1440 */ 289, 551, 131, 14, 130, 197, 89, 539, 199, 201, + /* 1450 */ 543, 200, 139, 558, 137, 565, 110, 15, 287, 572, + /* 1460 */ 140, 208, 148, 396, 392, 586, 902, 902, 902, 902, + /* 1470 */ 90, +}; +static const YYCODETYPE yy_lookahead[] = { + /* 0 */ 16, 139, 140, 141, 168, 21, 144, 23, 69, 70, + /* 10 */ 71, 72, 176, 74, 75, 76, 77, 78, 79, 80, + /* 20 */ 81, 82, 83, 84, 78, 79, 42, 43, 73, 74, + /* 30 */ 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + /* 40 */ 1, 2, 23, 58, 60, 61, 62, 63, 64, 65, + /* 50 */ 66, 67, 68, 69, 70, 71, 72, 147, 74, 75, + /* 60 */ 76, 77, 78, 79, 80, 81, 82, 83, 84, 16, + /* 70 */ 185, 186, 88, 88, 110, 22, 217, 92, 219, 220, + /* 80 */ 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, + /* 90 */ 84, 217, 218, 219, 220, 42, 43, 238, 188, 46, + /* 100 */ 78, 79, 80, 81, 82, 83, 84, 88, 89, 124, + /* 110 */ 125, 126, 16, 60, 61, 62, 63, 64, 65, 66, + /* 120 */ 67, 68, 69, 70, 71, 72, 147, 74, 75, 76, + /* 130 */ 77, 78, 79, 80, 81, 82, 83, 84, 42, 43, + /* 140 */ 44, 80, 81, 82, 83, 84, 23, 84, 169, 170, + /* 150 */ 19, 164, 165, 166, 23, 161, 60, 61, 62, 63, + /* 160 */ 64, 65, 66, 67, 68, 69, 70, 71, 72, 169, + /* 170 */ 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, + /* 180 */ 84, 16, 14, 147, 155, 147, 21, 167, 168, 58, + /* 190 */ 211, 147, 156, 157, 200, 216, 176, 23, 27, 176, + /* 200 */ 177, 78, 79, 165, 166, 34, 183, 42, 43, 78, + /* 210 */ 79, 88, 89, 169, 170, 228, 180, 181, 189, 88, + /* 220 */ 52, 98, 54, 92, 16, 60, 61, 62, 63, 64, + /* 230 */ 65, 66, 67, 68, 69, 70, 71, 72, 147, 74, + /* 240 */ 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + /* 250 */ 42, 43, 78, 209, 210, 124, 125, 126, 175, 11, + /* 260 */ 169, 170, 88, 89, 20, 227, 228, 16, 60, 61, + /* 270 */ 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + /* 280 */ 72, 1, 74, 75, 76, 77, 78, 79, 80, 81, + /* 290 */ 82, 83, 84, 42, 43, 175, 16, 49, 147, 147, + /* 300 */ 20, 210, 22, 217, 153, 219, 220, 156, 157, 83, + /* 310 */ 84, 60, 61, 62, 63, 64, 65, 66, 67, 68, + /* 320 */ 69, 70, 71, 72, 147, 74, 75, 76, 77, 78, + /* 330 */ 79, 80, 81, 82, 83, 84, 1, 147, 158, 131, + /* 340 */ 16, 161, 162, 163, 20, 155, 190, 99, 100, 101, + /* 350 */ 106, 16, 108, 109, 147, 20, 147, 22, 110, 169, + /* 360 */ 170, 161, 162, 163, 84, 188, 42, 43, 169, 23, + /* 370 */ 90, 91, 92, 93, 94, 95, 96, 225, 43, 189, + /* 380 */ 244, 245, 131, 103, 60, 61, 62, 63, 64, 65, + /* 390 */ 66, 67, 68, 69, 70, 71, 72, 110, 74, 75, + /* 400 */ 76, 77, 78, 79, 80, 81, 82, 83, 84, 16, + /* 410 */ 123, 19, 20, 20, 22, 208, 239, 208, 147, 84, + /* 420 */ 19, 147, 16, 147, 23, 90, 91, 92, 93, 94, + /* 430 */ 95, 96, 147, 98, 88, 42, 43, 181, 103, 104, + /* 440 */ 169, 170, 147, 169, 170, 169, 170, 164, 165, 166, + /* 450 */ 165, 59, 80, 60, 61, 62, 63, 64, 65, 66, + /* 460 */ 67, 68, 69, 70, 71, 72, 1, 74, 75, 76, + /* 470 */ 77, 78, 79, 80, 81, 82, 83, 84, 16, 107, + /* 480 */ 155, 16, 20, 111, 147, 20, 215, 22, 16, 88, + /* 490 */ 84, 215, 20, 181, 22, 221, 90, 91, 92, 93, + /* 500 */ 94, 95, 96, 208, 42, 43, 169, 170, 43, 103, + /* 510 */ 147, 228, 227, 228, 189, 43, 0, 1, 2, 7, + /* 520 */ 8, 9, 60, 61, 62, 63, 64, 65, 66, 67, + /* 530 */ 68, 69, 70, 71, 72, 186, 74, 75, 76, 77, + /* 540 */ 78, 79, 80, 81, 82, 83, 84, 16, 211, 84, + /* 550 */ 16, 20, 12, 185, 186, 90, 91, 92, 93, 94, + /* 560 */ 95, 96, 90, 98, 24, 93, 94, 95, 103, 104, + /* 570 */ 98, 147, 160, 42, 43, 103, 104, 37, 19, 39, + /* 580 */ 18, 169, 23, 19, 20, 155, 22, 147, 21, 49, + /* 590 */ 23, 60, 61, 62, 63, 64, 65, 66, 67, 68, + /* 600 */ 69, 70, 71, 72, 147, 74, 75, 76, 77, 78, + /* 610 */ 79, 80, 81, 82, 83, 84, 16, 55, 84, 189, + /* 620 */ 19, 21, 147, 59, 23, 91, 92, 93, 94, 95, + /* 630 */ 96, 201, 202, 147, 23, 90, 206, 103, 93, 94, + /* 640 */ 95, 145, 42, 43, 20, 142, 143, 88, 89, 104, + /* 650 */ 20, 148, 99, 100, 101, 88, 94, 150, 155, 16, + /* 660 */ 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + /* 670 */ 70, 71, 72, 147, 74, 75, 76, 77, 78, 79, + /* 680 */ 80, 81, 82, 83, 84, 42, 43, 212, 147, 88, + /* 690 */ 89, 80, 189, 141, 19, 133, 144, 156, 157, 88, + /* 700 */ 89, 155, 16, 60, 61, 62, 63, 64, 65, 66, + /* 710 */ 67, 68, 69, 70, 71, 72, 213, 74, 75, 76, + /* 720 */ 77, 78, 79, 80, 81, 82, 83, 84, 42, 43, + /* 730 */ 106, 224, 108, 109, 161, 189, 106, 230, 108, 109, + /* 740 */ 14, 147, 147, 68, 241, 16, 60, 61, 62, 63, + /* 750 */ 64, 65, 66, 67, 68, 69, 70, 71, 72, 213, + /* 760 */ 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, + /* 770 */ 84, 42, 43, 200, 192, 19, 182, 182, 52, 22, + /* 780 */ 54, 199, 236, 147, 99, 100, 101, 147, 16, 147, + /* 790 */ 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + /* 800 */ 71, 72, 1, 74, 75, 76, 77, 78, 79, 80, + /* 810 */ 81, 82, 83, 84, 42, 43, 23, 16, 182, 225, + /* 820 */ 225, 20, 182, 22, 106, 191, 108, 109, 161, 25, + /* 830 */ 22, 147, 22, 29, 62, 63, 64, 65, 66, 67, + /* 840 */ 68, 69, 70, 71, 72, 41, 74, 75, 76, 77, + /* 850 */ 78, 79, 80, 81, 82, 83, 84, 16, 17, 133, + /* 860 */ 19, 225, 147, 147, 23, 225, 182, 200, 112, 201, + /* 870 */ 202, 161, 31, 16, 17, 147, 19, 147, 121, 155, + /* 880 */ 23, 88, 89, 147, 217, 84, 219, 220, 31, 48, + /* 890 */ 16, 90, 91, 92, 93, 94, 95, 96, 90, 58, + /* 900 */ 155, 93, 94, 95, 103, 48, 91, 114, 155, 225, + /* 910 */ 42, 43, 104, 189, 12, 58, 188, 43, 188, 78, + /* 920 */ 79, 147, 23, 113, 188, 110, 24, 212, 87, 88, + /* 930 */ 89, 63, 64, 92, 189, 78, 79, 80, 123, 37, + /* 940 */ 203, 39, 189, 30, 87, 88, 89, 16, 17, 92, + /* 950 */ 19, 110, 147, 147, 23, 242, 243, 19, 147, 21, + /* 960 */ 92, 155, 31, 50, 147, 124, 125, 126, 127, 128, + /* 970 */ 129, 147, 98, 124, 125, 169, 170, 103, 147, 48, + /* 980 */ 147, 124, 125, 126, 127, 128, 129, 88, 89, 58, + /* 990 */ 147, 5, 147, 169, 170, 189, 10, 11, 12, 13, + /* 1000 */ 169, 170, 147, 23, 178, 147, 147, 147, 147, 78, + /* 1010 */ 79, 1, 26, 114, 28, 102, 43, 211, 87, 88, + /* 1020 */ 89, 35, 216, 92, 169, 170, 16, 169, 170, 147, + /* 1030 */ 20, 188, 22, 47, 107, 49, 16, 147, 111, 53, + /* 1040 */ 147, 22, 56, 147, 22, 91, 92, 188, 188, 188, + /* 1050 */ 178, 169, 170, 43, 178, 124, 125, 126, 127, 128, + /* 1060 */ 129, 1, 169, 170, 147, 169, 170, 147, 88, 89, + /* 1070 */ 90, 98, 147, 93, 94, 95, 16, 130, 1, 132, + /* 1080 */ 20, 92, 22, 147, 104, 99, 100, 101, 147, 169, + /* 1090 */ 170, 105, 103, 16, 84, 147, 110, 20, 232, 22, + /* 1100 */ 90, 91, 92, 93, 94, 95, 96, 1, 98, 147, + /* 1110 */ 233, 89, 92, 103, 104, 147, 97, 169, 170, 147, + /* 1120 */ 134, 20, 16, 147, 147, 147, 20, 20, 22, 22, + /* 1130 */ 147, 169, 170, 149, 147, 147, 114, 169, 170, 147, + /* 1140 */ 147, 169, 170, 147, 84, 169, 170, 169, 170, 43, + /* 1150 */ 90, 91, 92, 93, 94, 95, 96, 169, 170, 147, + /* 1160 */ 59, 84, 147, 103, 147, 169, 170, 90, 91, 92, + /* 1170 */ 93, 94, 95, 96, 20, 147, 22, 7, 8, 147, + /* 1180 */ 103, 169, 170, 147, 169, 170, 147, 20, 147, 22, + /* 1190 */ 84, 147, 20, 20, 22, 22, 90, 91, 92, 93, + /* 1200 */ 94, 95, 96, 147, 98, 169, 170, 191, 147, 103, + /* 1210 */ 169, 170, 147, 169, 170, 147, 20, 147, 22, 147, + /* 1220 */ 20, 147, 22, 147, 193, 169, 170, 20, 147, 22, + /* 1230 */ 169, 170, 147, 147, 147, 147, 161, 169, 170, 169, + /* 1240 */ 170, 147, 229, 169, 170, 169, 170, 147, 223, 147, + /* 1250 */ 169, 170, 147, 229, 169, 170, 169, 170, 20, 177, + /* 1260 */ 22, 147, 172, 169, 170, 147, 20, 147, 22, 169, + /* 1270 */ 170, 169, 170, 147, 169, 170, 147, 161, 161, 147, + /* 1280 */ 172, 172, 172, 169, 170, 147, 173, 169, 170, 169, + /* 1290 */ 170, 172, 194, 194, 6, 169, 170, 146, 169, 170, + /* 1300 */ 22, 169, 170, 146, 146, 146, 154, 169, 170, 121, + /* 1310 */ 189, 118, 197, 119, 116, 120, 194, 130, 195, 222, + /* 1320 */ 196, 112, 98, 198, 98, 115, 152, 152, 179, 40, + /* 1330 */ 97, 204, 171, 205, 204, 171, 205, 171, 173, 171, + /* 1340 */ 19, 84, 179, 174, 15, 174, 38, 171, 171, 171, + /* 1350 */ 151, 130, 60, 152, 151, 19, 152, 151, 214, 226, + /* 1360 */ 226, 15, 214, 152, 152, 151, 184, 152, 184, 234, + /* 1370 */ 152, 235, 187, 194, 194, 152, 187, 187, 187, 237, + /* 1380 */ 33, 184, 237, 152, 152, 137, 240, 159, 1, 246, + /* 1390 */ 243, 231, 20, 112, 112, 112, 112, 92, 107, 19, + /* 1400 */ 11, 20, 20, 19, 19, 22, 20, 117, 20, 114, + /* 1410 */ 20, 117, 19, 22, 22, 20, 112, 20, 20, 44, + /* 1420 */ 19, 44, 19, 44, 20, 19, 32, 19, 19, 96, + /* 1430 */ 103, 16, 21, 17, 22, 98, 36, 98, 19, 133, + /* 1440 */ 5, 1, 102, 19, 45, 122, 68, 51, 113, 115, + /* 1450 */ 45, 14, 102, 17, 113, 123, 14, 19, 136, 20, + /* 1460 */ 122, 135, 19, 3, 57, 4, 247, 247, 247, 247, + /* 1470 */ 68, +}; +#define YY_SHIFT_USE_DFLT (-62) +#define YY_SHIFT_MAX 396 +static const short yy_shift_ofst[] = { + /* 0 */ 39, 841, 986, -16, 841, 931, 931, 980, 123, -36, + /* 10 */ 96, 931, 931, 931, 931, 931, -45, 248, 174, 19, + /* 20 */ 346, -54, -54, 53, 165, 208, 251, 324, 393, 462, + /* 30 */ 531, 600, 643, 686, 643, 643, 643, 643, 643, 643, + /* 40 */ 643, 643, 643, 643, 643, 643, 643, 643, 643, 643, + /* 50 */ 643, 643, 729, 772, 772, 857, 931, 931, 931, 931, + /* 60 */ 931, 931, 931, 931, 931, 931, 931, 931, 931, 931, + /* 70 */ 931, 931, 931, 931, 931, 931, 931, 931, 931, 931, + /* 80 */ 931, 931, 931, 931, 931, 931, 931, 931, 931, 931, + /* 90 */ 931, 931, 931, 931, 931, 931, -61, -61, 6, 6, + /* 100 */ 406, 22, 61, 874, 562, 19, 19, 19, 19, 19, + /* 110 */ 19, 19, 226, 346, 63, -62, -62, -62, 131, 534, + /* 120 */ 540, 540, 392, 564, 516, 567, 19, 567, 19, 19, + /* 130 */ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, + /* 140 */ 19, 815, 287, -36, -36, -36, -62, -62, -62, 1106, + /* 150 */ 472, -15, -15, 808, 545, 244, 559, 624, 630, 902, + /* 160 */ 793, 899, 601, 611, 512, 19, 19, 372, 19, 19, + /* 170 */ 401, 19, 19, 1022, 19, 19, 718, 1022, 19, 19, + /* 180 */ 913, 913, 913, 19, 19, 718, 19, 19, 718, 19, + /* 190 */ 804, 553, 19, 19, 718, 19, 19, 19, 718, 19, + /* 200 */ 19, 19, 718, 718, 19, 19, 19, 19, 19, 938, + /* 210 */ 927, 810, 346, 849, 849, 947, 171, 171, 171, 973, + /* 220 */ 171, 346, 171, 346, 1019, 757, 757, 1288, 1288, 1288, + /* 230 */ 1288, 1278, -36, 1188, 1193, 1194, 1198, 1195, 1187, 1209, + /* 240 */ 1209, 1224, 1210, 1224, 1210, 1226, 1226, 1289, 1226, 1233, + /* 250 */ 1226, 1321, 1257, 1257, 1289, 1226, 1226, 1226, 1321, 1329, + /* 260 */ 1209, 1329, 1209, 1329, 1209, 1209, 1308, 1221, 1329, 1209, + /* 270 */ 1292, 1292, 1336, 1188, 1209, 1346, 1346, 1346, 1346, 1188, + /* 280 */ 1292, 1336, 1209, 1347, 1347, 1209, 1209, 1248, -62, -62, + /* 290 */ -62, -62, 335, 465, 1010, 280, 801, 1060, 1077, 868, + /* 300 */ 726, 685, 168, 756, 1020, 1107, 1154, 989, 1170, 954, + /* 310 */ 1167, 1172, 1173, 1196, 1200, 1207, 1238, 675, 1246, 1101, + /* 320 */ 1387, 1372, 1281, 1282, 1283, 1284, 1305, 1291, 1380, 1381, + /* 330 */ 1382, 1384, 1389, 1385, 1386, 1383, 1388, 1390, 1391, 1290, + /* 340 */ 1392, 1294, 1391, 1295, 1393, 1395, 1304, 1397, 1398, 1394, + /* 350 */ 1375, 1401, 1377, 1403, 1404, 1406, 1408, 1379, 1409, 1333, + /* 360 */ 1327, 1415, 1416, 1411, 1337, 1400, 1396, 1399, 1412, 1405, + /* 370 */ 1306, 1339, 1419, 1435, 1440, 1340, 1378, 1402, 1323, 1424, + /* 380 */ 1335, 1437, 1334, 1436, 1341, 1350, 1338, 1438, 1332, 1439, + /* 390 */ 1442, 1407, 1326, 1322, 1443, 1460, 1461, +}; +#define YY_REDUCE_USE_DFLT (-165) +#define YY_REDUCE_MAX 291 +static const short yy_reduce_ofst[] = { + /* 0 */ -138, 806, 503, 667, 190, -21, 44, 36, 38, 430, + /* 10 */ -141, 274, 91, 337, 271, 276, -126, 546, 285, 151, + /* 20 */ 180, -13, 283, 86, 86, 86, 86, 86, 86, 86, + /* 30 */ 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, + /* 40 */ 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, + /* 50 */ 86, 86, 86, 86, 86, 824, 831, 855, 858, 882, + /* 60 */ 893, 896, 920, 948, 962, 968, 972, 976, 978, 988, + /* 70 */ 996, 1012, 1015, 1036, 1041, 1044, 1056, 1061, 1068, 1070, + /* 80 */ 1074, 1076, 1081, 1085, 1087, 1094, 1100, 1102, 1105, 1114, + /* 90 */ 1118, 1120, 1126, 1129, 1132, 1138, 86, 86, 86, 86, + /* 100 */ 20, 86, 86, 23, 507, 594, 595, 636, 640, 684, + /* 110 */ 177, 541, 86, 200, 86, 86, 86, 86, 412, -164, + /* 120 */ -115, 368, 136, 136, 552, -6, 207, 573, 152, -90, + /* 130 */ 209, 475, 295, 728, 730, 736, 843, 859, 860, 715, + /* 140 */ 861, 29, 325, 724, 745, 753, 582, 668, 713, 83, + /* 150 */ 120, 0, 199, 256, 312, 156, 363, 156, 156, 349, + /* 160 */ 424, 440, 457, 486, 496, 526, 642, 634, 486, 716, + /* 170 */ 710, 774, 805, 737, 811, 817, 156, 737, 833, 845, + /* 180 */ 826, 872, 876, 890, 917, 156, 925, 936, 156, 941, + /* 190 */ 866, 877, 977, 983, 156, 987, 992, 993, 156, 1017, + /* 200 */ 1028, 1032, 156, 156, 1039, 1065, 1072, 1086, 1088, 984, + /* 210 */ 1016, 1031, 1075, 1013, 1024, 1025, 1090, 1108, 1109, 1082, + /* 220 */ 1110, 1116, 1119, 1117, 1113, 1098, 1099, 1151, 1157, 1158, + /* 230 */ 1159, 1152, 1121, 1122, 1123, 1124, 1115, 1125, 1097, 1174, + /* 240 */ 1175, 1127, 1128, 1130, 1131, 1161, 1164, 1149, 1166, 1165, + /* 250 */ 1168, 1169, 1133, 1134, 1163, 1176, 1177, 1178, 1171, 1199, + /* 260 */ 1201, 1203, 1204, 1206, 1211, 1212, 1135, 1136, 1214, 1215, + /* 270 */ 1182, 1184, 1144, 1179, 1218, 1185, 1189, 1190, 1191, 1180, + /* 280 */ 1197, 1148, 1223, 1142, 1145, 1231, 1232, 1146, 1228, 1160, + /* 290 */ 1147, 1143, +}; +static const YYACTIONTYPE yy_default[] = { + /* 0 */ 594, 819, 900, 709, 900, 819, 900, 900, 846, 713, + /* 10 */ 875, 817, 900, 900, 900, 900, 791, 900, 846, 900, + /* 20 */ 625, 846, 846, 742, 900, 900, 900, 900, 900, 900, + /* 30 */ 900, 900, 743, 900, 821, 816, 812, 814, 813, 820, + /* 40 */ 744, 733, 740, 747, 725, 859, 749, 750, 756, 757, + /* 50 */ 876, 874, 779, 778, 797, 900, 900, 900, 900, 900, + /* 60 */ 900, 900, 900, 900, 900, 900, 900, 900, 900, 900, + /* 70 */ 900, 900, 900, 900, 900, 900, 900, 900, 900, 900, + /* 80 */ 900, 900, 900, 900, 900, 900, 900, 900, 900, 900, + /* 90 */ 900, 900, 900, 900, 900, 900, 781, 803, 780, 790, + /* 100 */ 618, 782, 783, 678, 613, 900, 900, 900, 900, 900, + /* 110 */ 900, 900, 784, 900, 785, 798, 799, 800, 900, 900, + /* 120 */ 900, 900, 900, 900, 594, 709, 900, 709, 900, 900, + /* 130 */ 900, 900, 900, 900, 900, 900, 900, 900, 900, 900, + /* 140 */ 900, 900, 900, 900, 900, 900, 703, 713, 893, 900, + /* 150 */ 900, 900, 900, 669, 900, 900, 900, 900, 900, 900, + /* 160 */ 900, 900, 900, 900, 601, 599, 900, 701, 900, 900, + /* 170 */ 627, 900, 900, 711, 900, 900, 716, 717, 900, 900, + /* 180 */ 900, 900, 900, 900, 900, 615, 900, 900, 690, 900, + /* 190 */ 852, 900, 900, 900, 866, 900, 900, 900, 864, 900, + /* 200 */ 900, 900, 692, 752, 833, 900, 879, 881, 900, 900, + /* 210 */ 701, 710, 900, 900, 900, 815, 736, 736, 736, 648, + /* 220 */ 736, 900, 736, 900, 651, 746, 746, 598, 598, 598, + /* 230 */ 598, 668, 900, 746, 737, 739, 729, 741, 900, 718, + /* 240 */ 718, 726, 728, 726, 728, 680, 680, 665, 680, 651, + /* 250 */ 680, 825, 830, 830, 665, 680, 680, 680, 825, 610, + /* 260 */ 718, 610, 718, 610, 718, 718, 856, 858, 610, 718, + /* 270 */ 682, 682, 758, 746, 718, 689, 689, 689, 689, 746, + /* 280 */ 682, 758, 718, 878, 878, 718, 718, 886, 635, 861, + /* 290 */ 893, 898, 900, 900, 900, 900, 900, 900, 900, 900, + /* 300 */ 900, 900, 900, 765, 900, 900, 900, 900, 900, 900, + /* 310 */ 900, 900, 900, 900, 900, 900, 900, 839, 900, 900, + /* 320 */ 900, 900, 770, 766, 900, 767, 900, 695, 900, 900, + /* 330 */ 900, 900, 900, 900, 900, 900, 900, 900, 818, 900, + /* 340 */ 730, 900, 738, 900, 900, 900, 900, 900, 900, 900, + /* 350 */ 900, 900, 900, 900, 900, 900, 900, 900, 900, 900, + /* 360 */ 900, 900, 900, 900, 900, 900, 900, 854, 855, 900, + /* 370 */ 900, 900, 900, 900, 900, 900, 900, 900, 900, 900, + /* 380 */ 900, 900, 900, 900, 900, 900, 900, 900, 900, 900, + /* 390 */ 900, 885, 900, 900, 888, 595, 900, 589, 592, 591, + /* 400 */ 593, 597, 600, 622, 623, 624, 602, 603, 604, 605, + /* 410 */ 606, 607, 608, 614, 616, 634, 636, 620, 638, 699, + /* 420 */ 700, 762, 693, 694, 698, 621, 773, 764, 768, 769, + /* 430 */ 771, 772, 786, 787, 789, 795, 802, 805, 788, 793, + /* 440 */ 794, 796, 801, 804, 696, 697, 808, 628, 629, 632, + /* 450 */ 633, 842, 844, 843, 845, 631, 630, 774, 777, 810, + /* 460 */ 811, 867, 868, 869, 870, 871, 806, 719, 809, 792, + /* 470 */ 731, 734, 735, 732, 702, 712, 721, 722, 723, 724, + /* 480 */ 707, 708, 714, 727, 760, 761, 715, 704, 705, 706, + /* 490 */ 807, 763, 775, 776, 639, 640, 770, 641, 642, 643, + /* 500 */ 681, 684, 685, 686, 644, 663, 666, 667, 645, 647, + /* 510 */ 659, 660, 661, 662, 657, 658, 826, 827, 831, 829, + /* 520 */ 828, 664, 637, 626, 619, 670, 673, 674, 675, 676, + /* 530 */ 677, 679, 671, 672, 617, 609, 611, 720, 848, 857, + /* 540 */ 853, 849, 850, 851, 612, 822, 823, 683, 754, 755, + /* 550 */ 847, 860, 862, 759, 863, 865, 890, 687, 688, 691, + /* 560 */ 832, 872, 745, 748, 751, 753, 834, 835, 836, 837, + /* 570 */ 840, 841, 838, 873, 877, 880, 882, 883, 884, 887, + /* 580 */ 889, 894, 895, 896, 899, 897, 596, 590, +}; +#define YY_SZ_ACTTAB (int)(sizeof(yy_action)/sizeof(yy_action[0])) + +/* The next table maps tokens into fallback tokens. If a construct +** like the following: +** +** %fallback ID X Y Z. +** +** appears in the grammer, then ID becomes a fallback token for X, Y, +** and Z. Whenever one of the tokens X, Y, or Z is input to the parser +** but it does not parse, the type of the token is changed to ID and +** the parse is retried before an error is thrown. +*/ +#ifdef YYFALLBACK +static const YYCODETYPE yyFallback[] = { + 0, /* $ => nothing */ + 0, /* SEMI => nothing */ + 23, /* EXPLAIN => ID */ + 23, /* QUERY => ID */ + 23, /* PLAN => ID */ + 23, /* BEGIN => ID */ + 0, /* TRANSACTION => nothing */ + 23, /* DEFERRED => ID */ + 23, /* IMMEDIATE => ID */ + 23, /* EXCLUSIVE => ID */ + 0, /* COMMIT => nothing */ + 23, /* END => ID */ + 0, /* ROLLBACK => nothing */ + 0, /* CREATE => nothing */ + 0, /* TABLE => nothing */ + 23, /* IF => ID */ + 0, /* NOT => nothing */ + 0, /* EXISTS => nothing */ + 23, /* TEMP => ID */ + 0, /* LP => nothing */ + 0, /* RP => nothing */ + 0, /* AS => nothing */ + 0, /* COMMA => nothing */ + 0, /* ID => nothing */ + 23, /* ABORT => ID */ + 23, /* AFTER => ID */ + 23, /* ANALYZE => ID */ + 23, /* ASC => ID */ + 23, /* ATTACH => ID */ + 23, /* BEFORE => ID */ + 23, /* CASCADE => ID */ + 23, /* CAST => ID */ + 23, /* CONFLICT => ID */ + 23, /* DATABASE => ID */ + 23, /* DESC => ID */ + 23, /* DETACH => ID */ + 23, /* EACH => ID */ + 23, /* FAIL => ID */ + 23, /* FOR => ID */ + 23, /* IGNORE => ID */ + 23, /* INITIALLY => ID */ + 23, /* INSTEAD => ID */ + 23, /* LIKE_KW => ID */ + 23, /* MATCH => ID */ + 23, /* KEY => ID */ + 23, /* OF => ID */ + 23, /* OFFSET => ID */ + 23, /* PRAGMA => ID */ + 23, /* RAISE => ID */ + 23, /* REPLACE => ID */ + 23, /* RESTRICT => ID */ + 23, /* ROW => ID */ + 23, /* TRIGGER => ID */ + 23, /* VACUUM => ID */ + 23, /* VIEW => ID */ + 23, /* VIRTUAL => ID */ + 23, /* REINDEX => ID */ + 23, /* RENAME => ID */ + 23, /* CTIME_KW => ID */ + 0, /* ANY => nothing */ + 0, /* OR => nothing */ + 0, /* AND => nothing */ + 0, /* IS => nothing */ + 0, /* BETWEEN => nothing */ + 0, /* IN => nothing */ + 0, /* ISNULL => nothing */ + 0, /* NOTNULL => nothing */ + 0, /* NE => nothing */ + 0, /* EQ => nothing */ + 0, /* GT => nothing */ + 0, /* LE => nothing */ + 0, /* LT => nothing */ + 0, /* GE => nothing */ + 0, /* ESCAPE => nothing */ + 0, /* BITAND => nothing */ + 0, /* BITOR => nothing */ + 0, /* LSHIFT => nothing */ + 0, /* RSHIFT => nothing */ + 0, /* PLUS => nothing */ + 0, /* MINUS => nothing */ + 0, /* STAR => nothing */ + 0, /* SLASH => nothing */ + 0, /* REM => nothing */ + 0, /* CONCAT => nothing */ + 0, /* COLLATE => nothing */ + 0, /* UMINUS => nothing */ + 0, /* UPLUS => nothing */ + 0, /* BITNOT => nothing */ + 0, /* STRING => nothing */ + 0, /* JOIN_KW => nothing */ + 0, /* CONSTRAINT => nothing */ + 0, /* DEFAULT => nothing */ + 0, /* NULL => nothing */ + 0, /* PRIMARY => nothing */ + 0, /* UNIQUE => nothing */ + 0, /* CHECK => nothing */ + 0, /* REFERENCES => nothing */ + 0, /* AUTOINCR => nothing */ + 0, /* ON => nothing */ + 0, /* DELETE => nothing */ + 0, /* UPDATE => nothing */ + 0, /* INSERT => nothing */ + 0, /* SET => nothing */ + 0, /* DEFERRABLE => nothing */ + 0, /* FOREIGN => nothing */ + 0, /* DROP => nothing */ + 0, /* UNION => nothing */ + 0, /* ALL => nothing */ + 0, /* EXCEPT => nothing */ + 0, /* INTERSECT => nothing */ + 0, /* SELECT => nothing */ + 0, /* DISTINCT => nothing */ + 0, /* DOT => nothing */ + 0, /* FROM => nothing */ + 0, /* JOIN => nothing */ + 0, /* USING => nothing */ + 0, /* ORDER => nothing */ + 0, /* BY => nothing */ + 0, /* GROUP => nothing */ + 0, /* HAVING => nothing */ + 0, /* LIMIT => nothing */ + 0, /* WHERE => nothing */ + 0, /* INTO => nothing */ + 0, /* VALUES => nothing */ + 0, /* INTEGER => nothing */ + 0, /* FLOAT => nothing */ + 0, /* BLOB => nothing */ + 0, /* REGISTER => nothing */ + 0, /* VARIABLE => nothing */ + 0, /* CASE => nothing */ + 0, /* WHEN => nothing */ + 0, /* THEN => nothing */ + 0, /* ELSE => nothing */ + 0, /* INDEX => nothing */ + 0, /* ALTER => nothing */ + 0, /* TO => nothing */ + 0, /* ADD => nothing */ + 0, /* COLUMNKW => nothing */ +}; +#endif /* YYFALLBACK */ + +/* The following structure represents a single element of the +** parser's stack. Information stored includes: +** +** + The state number for the parser at this level of the stack. +** +** + The value of the token stored at this level of the stack. +** (In other words, the "major" token.) +** +** + The semantic value stored at this level of the stack. This is +** the information used by the action routines in the grammar. +** It is sometimes called the "minor" token. +*/ +struct yyStackEntry { + int stateno; /* The state-number */ + int major; /* The major token value. This is the code + ** number for the token at this stack level */ + YYMINORTYPE minor; /* The user-supplied minor token value. This + ** is the value of the token */ +}; +typedef struct yyStackEntry yyStackEntry; + +/* The state of the parser is completely contained in an instance of +** the following structure */ +struct yyParser { + int yyidx; /* Index of top element in stack */ + int yyerrcnt; /* Shifts left before out of the error */ + sqlite3ParserARG_SDECL /* A place to hold %extra_argument */ +#if YYSTACKDEPTH<=0 + int yystksz; /* Current side of the stack */ + yyStackEntry *yystack; /* The parser's stack */ +#else + yyStackEntry yystack[YYSTACKDEPTH]; /* The parser's stack */ +#endif +}; +typedef struct yyParser yyParser; + +#ifndef NDEBUG +#include +static FILE *yyTraceFILE = 0; +static char *yyTracePrompt = 0; +#endif /* NDEBUG */ + +#ifndef NDEBUG +/* +** Turn parser tracing on by giving a stream to which to write the trace +** and a prompt to preface each trace message. Tracing is turned off +** by making either argument NULL +** +** Inputs: +**
    +**
  • A FILE* to which trace output should be written. +** If NULL, then tracing is turned off. +**
  • A prefix string written at the beginning of every +** line of trace output. If NULL, then tracing is +** turned off. +**
+** +** Outputs: +** None. +*/ +void sqlite3ParserTrace(FILE *TraceFILE, char *zTracePrompt){ + yyTraceFILE = TraceFILE; + yyTracePrompt = zTracePrompt; + if( yyTraceFILE==0 ) yyTracePrompt = 0; + else if( yyTracePrompt==0 ) yyTraceFILE = 0; +} +#endif /* NDEBUG */ + +#ifndef NDEBUG +/* For tracing shifts, the names of all terminals and nonterminals +** are required. The following table supplies these names */ +static const char *const yyTokenName[] = { + "$", "SEMI", "EXPLAIN", "QUERY", + "PLAN", "BEGIN", "TRANSACTION", "DEFERRED", + "IMMEDIATE", "EXCLUSIVE", "COMMIT", "END", + "ROLLBACK", "CREATE", "TABLE", "IF", + "NOT", "EXISTS", "TEMP", "LP", + "RP", "AS", "COMMA", "ID", + "ABORT", "AFTER", "ANALYZE", "ASC", + "ATTACH", "BEFORE", "CASCADE", "CAST", + "CONFLICT", "DATABASE", "DESC", "DETACH", + "EACH", "FAIL", "FOR", "IGNORE", + "INITIALLY", "INSTEAD", "LIKE_KW", "MATCH", + "KEY", "OF", "OFFSET", "PRAGMA", + "RAISE", "REPLACE", "RESTRICT", "ROW", + "TRIGGER", "VACUUM", "VIEW", "VIRTUAL", + "REINDEX", "RENAME", "CTIME_KW", "ANY", + "OR", "AND", "IS", "BETWEEN", + "IN", "ISNULL", "NOTNULL", "NE", + "EQ", "GT", "LE", "LT", + "GE", "ESCAPE", "BITAND", "BITOR", + "LSHIFT", "RSHIFT", "PLUS", "MINUS", + "STAR", "SLASH", "REM", "CONCAT", + "COLLATE", "UMINUS", "UPLUS", "BITNOT", + "STRING", "JOIN_KW", "CONSTRAINT", "DEFAULT", + "NULL", "PRIMARY", "UNIQUE", "CHECK", + "REFERENCES", "AUTOINCR", "ON", "DELETE", + "UPDATE", "INSERT", "SET", "DEFERRABLE", + "FOREIGN", "DROP", "UNION", "ALL", + "EXCEPT", "INTERSECT", "SELECT", "DISTINCT", + "DOT", "FROM", "JOIN", "USING", + "ORDER", "BY", "GROUP", "HAVING", + "LIMIT", "WHERE", "INTO", "VALUES", + "INTEGER", "FLOAT", "BLOB", "REGISTER", + "VARIABLE", "CASE", "WHEN", "THEN", + "ELSE", "INDEX", "ALTER", "TO", + "ADD", "COLUMNKW", "error", "input", + "cmdlist", "ecmd", "cmdx", "cmd", + "explain", "transtype", "trans_opt", "nm", + "create_table", "create_table_args", "temp", "ifnotexists", + "dbnm", "columnlist", "conslist_opt", "select", + "column", "columnid", "type", "carglist", + "id", "ids", "typetoken", "typename", + "signed", "plus_num", "minus_num", "carg", + "ccons", "term", "expr", "onconf", + "sortorder", "autoinc", "idxlist_opt", "refargs", + "defer_subclause", "refarg", "refact", "init_deferred_pred_opt", + "conslist", "tcons", "idxlist", "defer_subclause_opt", + "orconf", "resolvetype", "raisetype", "ifexists", + "fullname", "oneselect", "multiselect_op", "distinct", + "selcollist", "from", "where_opt", "groupby_opt", + "having_opt", "orderby_opt", "limit_opt", "sclp", + "as", "seltablist", "stl_prefix", "joinop", + "on_opt", "using_opt", "seltablist_paren", "joinop2", + "inscollist", "sortlist", "sortitem", "nexprlist", + "setlist", "insert_cmd", "inscollist_opt", "itemlist", + "exprlist", "likeop", "escape", "between_op", + "in_op", "case_operand", "case_exprlist", "case_else", + "uniqueflag", "idxitem", "collate", "nmnum", + "plus_opt", "number", "trigger_decl", "trigger_cmd_list", + "trigger_time", "trigger_event", "foreach_clause", "when_clause", + "trigger_cmd", "database_kw_opt", "key_opt", "add_column_fullname", + "kwcolumn_opt", "create_vtab", "vtabarglist", "vtabarg", + "vtabargtoken", "lp", "anylist", +}; +#endif /* NDEBUG */ + +#ifndef NDEBUG +/* For tracing reduce actions, the names of all rules are required. +*/ +static const char *const yyRuleName[] = { + /* 0 */ "input ::= cmdlist", + /* 1 */ "cmdlist ::= cmdlist ecmd", + /* 2 */ "cmdlist ::= ecmd", + /* 3 */ "cmdx ::= cmd", + /* 4 */ "ecmd ::= SEMI", + /* 5 */ "ecmd ::= explain cmdx SEMI", + /* 6 */ "explain ::=", + /* 7 */ "explain ::= EXPLAIN", + /* 8 */ "explain ::= EXPLAIN QUERY PLAN", + /* 9 */ "cmd ::= BEGIN transtype trans_opt", + /* 10 */ "trans_opt ::=", + /* 11 */ "trans_opt ::= TRANSACTION", + /* 12 */ "trans_opt ::= TRANSACTION nm", + /* 13 */ "transtype ::=", + /* 14 */ "transtype ::= DEFERRED", + /* 15 */ "transtype ::= IMMEDIATE", + /* 16 */ "transtype ::= EXCLUSIVE", + /* 17 */ "cmd ::= COMMIT trans_opt", + /* 18 */ "cmd ::= END trans_opt", + /* 19 */ "cmd ::= ROLLBACK trans_opt", + /* 20 */ "cmd ::= create_table create_table_args", + /* 21 */ "create_table ::= CREATE temp TABLE ifnotexists nm dbnm", + /* 22 */ "ifnotexists ::=", + /* 23 */ "ifnotexists ::= IF NOT EXISTS", + /* 24 */ "temp ::= TEMP", + /* 25 */ "temp ::=", + /* 26 */ "create_table_args ::= LP columnlist conslist_opt RP", + /* 27 */ "create_table_args ::= AS select", + /* 28 */ "columnlist ::= columnlist COMMA column", + /* 29 */ "columnlist ::= column", + /* 30 */ "column ::= columnid type carglist", + /* 31 */ "columnid ::= nm", + /* 32 */ "id ::= ID", + /* 33 */ "ids ::= ID|STRING", + /* 34 */ "nm ::= ID", + /* 35 */ "nm ::= STRING", + /* 36 */ "nm ::= JOIN_KW", + /* 37 */ "type ::=", + /* 38 */ "type ::= typetoken", + /* 39 */ "typetoken ::= typename", + /* 40 */ "typetoken ::= typename LP signed RP", + /* 41 */ "typetoken ::= typename LP signed COMMA signed RP", + /* 42 */ "typename ::= ids", + /* 43 */ "typename ::= typename ids", + /* 44 */ "signed ::= plus_num", + /* 45 */ "signed ::= minus_num", + /* 46 */ "carglist ::= carglist carg", + /* 47 */ "carglist ::=", + /* 48 */ "carg ::= CONSTRAINT nm ccons", + /* 49 */ "carg ::= ccons", + /* 50 */ "ccons ::= DEFAULT term", + /* 51 */ "ccons ::= DEFAULT LP expr RP", + /* 52 */ "ccons ::= DEFAULT PLUS term", + /* 53 */ "ccons ::= DEFAULT MINUS term", + /* 54 */ "ccons ::= DEFAULT id", + /* 55 */ "ccons ::= NULL onconf", + /* 56 */ "ccons ::= NOT NULL onconf", + /* 57 */ "ccons ::= PRIMARY KEY sortorder onconf autoinc", + /* 58 */ "ccons ::= UNIQUE onconf", + /* 59 */ "ccons ::= CHECK LP expr RP", + /* 60 */ "ccons ::= REFERENCES nm idxlist_opt refargs", + /* 61 */ "ccons ::= defer_subclause", + /* 62 */ "ccons ::= COLLATE ids", + /* 63 */ "autoinc ::=", + /* 64 */ "autoinc ::= AUTOINCR", + /* 65 */ "refargs ::=", + /* 66 */ "refargs ::= refargs refarg", + /* 67 */ "refarg ::= MATCH nm", + /* 68 */ "refarg ::= ON DELETE refact", + /* 69 */ "refarg ::= ON UPDATE refact", + /* 70 */ "refarg ::= ON INSERT refact", + /* 71 */ "refact ::= SET NULL", + /* 72 */ "refact ::= SET DEFAULT", + /* 73 */ "refact ::= CASCADE", + /* 74 */ "refact ::= RESTRICT", + /* 75 */ "defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt", + /* 76 */ "defer_subclause ::= DEFERRABLE init_deferred_pred_opt", + /* 77 */ "init_deferred_pred_opt ::=", + /* 78 */ "init_deferred_pred_opt ::= INITIALLY DEFERRED", + /* 79 */ "init_deferred_pred_opt ::= INITIALLY IMMEDIATE", + /* 80 */ "conslist_opt ::=", + /* 81 */ "conslist_opt ::= COMMA conslist", + /* 82 */ "conslist ::= conslist COMMA tcons", + /* 83 */ "conslist ::= conslist tcons", + /* 84 */ "conslist ::= tcons", + /* 85 */ "tcons ::= CONSTRAINT nm", + /* 86 */ "tcons ::= PRIMARY KEY LP idxlist autoinc RP onconf", + /* 87 */ "tcons ::= UNIQUE LP idxlist RP onconf", + /* 88 */ "tcons ::= CHECK LP expr RP onconf", + /* 89 */ "tcons ::= FOREIGN KEY LP idxlist RP REFERENCES nm idxlist_opt refargs defer_subclause_opt", + /* 90 */ "defer_subclause_opt ::=", + /* 91 */ "defer_subclause_opt ::= defer_subclause", + /* 92 */ "onconf ::=", + /* 93 */ "onconf ::= ON CONFLICT resolvetype", + /* 94 */ "orconf ::=", + /* 95 */ "orconf ::= OR resolvetype", + /* 96 */ "resolvetype ::= raisetype", + /* 97 */ "resolvetype ::= IGNORE", + /* 98 */ "resolvetype ::= REPLACE", + /* 99 */ "cmd ::= DROP TABLE ifexists fullname", + /* 100 */ "ifexists ::= IF EXISTS", + /* 101 */ "ifexists ::=", + /* 102 */ "cmd ::= CREATE temp VIEW ifnotexists nm dbnm AS select", + /* 103 */ "cmd ::= DROP VIEW ifexists fullname", + /* 104 */ "cmd ::= select", + /* 105 */ "select ::= oneselect", + /* 106 */ "select ::= select multiselect_op oneselect", + /* 107 */ "multiselect_op ::= UNION", + /* 108 */ "multiselect_op ::= UNION ALL", + /* 109 */ "multiselect_op ::= EXCEPT|INTERSECT", + /* 110 */ "oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt", + /* 111 */ "distinct ::= DISTINCT", + /* 112 */ "distinct ::= ALL", + /* 113 */ "distinct ::=", + /* 114 */ "sclp ::= selcollist COMMA", + /* 115 */ "sclp ::=", + /* 116 */ "selcollist ::= sclp expr as", + /* 117 */ "selcollist ::= sclp STAR", + /* 118 */ "selcollist ::= sclp nm DOT STAR", + /* 119 */ "as ::= AS nm", + /* 120 */ "as ::= ids", + /* 121 */ "as ::=", + /* 122 */ "from ::=", + /* 123 */ "from ::= FROM seltablist", + /* 124 */ "stl_prefix ::= seltablist joinop", + /* 125 */ "stl_prefix ::=", + /* 126 */ "seltablist ::= stl_prefix nm dbnm as on_opt using_opt", + /* 127 */ "seltablist ::= stl_prefix LP seltablist_paren RP as on_opt using_opt", + /* 128 */ "seltablist_paren ::= select", + /* 129 */ "seltablist_paren ::= seltablist", + /* 130 */ "dbnm ::=", + /* 131 */ "dbnm ::= DOT nm", + /* 132 */ "fullname ::= nm dbnm", + /* 133 */ "joinop ::= COMMA|JOIN", + /* 134 */ "joinop ::= JOIN_KW JOIN", + /* 135 */ "joinop ::= JOIN_KW nm JOIN", + /* 136 */ "joinop ::= JOIN_KW nm nm JOIN", + /* 137 */ "on_opt ::= ON expr", + /* 138 */ "on_opt ::=", + /* 139 */ "using_opt ::= USING LP inscollist RP", + /* 140 */ "using_opt ::=", + /* 141 */ "orderby_opt ::=", + /* 142 */ "orderby_opt ::= ORDER BY sortlist", + /* 143 */ "sortlist ::= sortlist COMMA sortitem sortorder", + /* 144 */ "sortlist ::= sortitem sortorder", + /* 145 */ "sortitem ::= expr", + /* 146 */ "sortorder ::= ASC", + /* 147 */ "sortorder ::= DESC", + /* 148 */ "sortorder ::=", + /* 149 */ "groupby_opt ::=", + /* 150 */ "groupby_opt ::= GROUP BY nexprlist", + /* 151 */ "having_opt ::=", + /* 152 */ "having_opt ::= HAVING expr", + /* 153 */ "limit_opt ::=", + /* 154 */ "limit_opt ::= LIMIT expr", + /* 155 */ "limit_opt ::= LIMIT expr OFFSET expr", + /* 156 */ "limit_opt ::= LIMIT expr COMMA expr", + /* 157 */ "cmd ::= DELETE FROM fullname where_opt", + /* 158 */ "where_opt ::=", + /* 159 */ "where_opt ::= WHERE expr", + /* 160 */ "cmd ::= UPDATE orconf fullname SET setlist where_opt", + /* 161 */ "setlist ::= setlist COMMA nm EQ expr", + /* 162 */ "setlist ::= nm EQ expr", + /* 163 */ "cmd ::= insert_cmd INTO fullname inscollist_opt VALUES LP itemlist RP", + /* 164 */ "cmd ::= insert_cmd INTO fullname inscollist_opt select", + /* 165 */ "cmd ::= insert_cmd INTO fullname inscollist_opt DEFAULT VALUES", + /* 166 */ "insert_cmd ::= INSERT orconf", + /* 167 */ "insert_cmd ::= REPLACE", + /* 168 */ "itemlist ::= itemlist COMMA expr", + /* 169 */ "itemlist ::= expr", + /* 170 */ "inscollist_opt ::=", + /* 171 */ "inscollist_opt ::= LP inscollist RP", + /* 172 */ "inscollist ::= inscollist COMMA nm", + /* 173 */ "inscollist ::= nm", + /* 174 */ "expr ::= term", + /* 175 */ "expr ::= LP expr RP", + /* 176 */ "term ::= NULL", + /* 177 */ "expr ::= ID", + /* 178 */ "expr ::= JOIN_KW", + /* 179 */ "expr ::= nm DOT nm", + /* 180 */ "expr ::= nm DOT nm DOT nm", + /* 181 */ "term ::= INTEGER|FLOAT|BLOB", + /* 182 */ "term ::= STRING", + /* 183 */ "expr ::= REGISTER", + /* 184 */ "expr ::= VARIABLE", + /* 185 */ "expr ::= expr COLLATE ids", + /* 186 */ "expr ::= CAST LP expr AS typetoken RP", + /* 187 */ "expr ::= ID LP distinct exprlist RP", + /* 188 */ "expr ::= ID LP STAR RP", + /* 189 */ "term ::= CTIME_KW", + /* 190 */ "expr ::= expr AND expr", + /* 191 */ "expr ::= expr OR expr", + /* 192 */ "expr ::= expr LT|GT|GE|LE expr", + /* 193 */ "expr ::= expr EQ|NE expr", + /* 194 */ "expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr", + /* 195 */ "expr ::= expr PLUS|MINUS expr", + /* 196 */ "expr ::= expr STAR|SLASH|REM expr", + /* 197 */ "expr ::= expr CONCAT expr", + /* 198 */ "likeop ::= LIKE_KW", + /* 199 */ "likeop ::= NOT LIKE_KW", + /* 200 */ "likeop ::= MATCH", + /* 201 */ "likeop ::= NOT MATCH", + /* 202 */ "escape ::= ESCAPE expr", + /* 203 */ "escape ::=", + /* 204 */ "expr ::= expr likeop expr escape", + /* 205 */ "expr ::= expr ISNULL|NOTNULL", + /* 206 */ "expr ::= expr IS NULL", + /* 207 */ "expr ::= expr NOT NULL", + /* 208 */ "expr ::= expr IS NOT NULL", + /* 209 */ "expr ::= NOT expr", + /* 210 */ "expr ::= BITNOT expr", + /* 211 */ "expr ::= MINUS expr", + /* 212 */ "expr ::= PLUS expr", + /* 213 */ "between_op ::= BETWEEN", + /* 214 */ "between_op ::= NOT BETWEEN", + /* 215 */ "expr ::= expr between_op expr AND expr", + /* 216 */ "in_op ::= IN", + /* 217 */ "in_op ::= NOT IN", + /* 218 */ "expr ::= expr in_op LP exprlist RP", + /* 219 */ "expr ::= LP select RP", + /* 220 */ "expr ::= expr in_op LP select RP", + /* 221 */ "expr ::= expr in_op nm dbnm", + /* 222 */ "expr ::= EXISTS LP select RP", + /* 223 */ "expr ::= CASE case_operand case_exprlist case_else END", + /* 224 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr", + /* 225 */ "case_exprlist ::= WHEN expr THEN expr", + /* 226 */ "case_else ::= ELSE expr", + /* 227 */ "case_else ::=", + /* 228 */ "case_operand ::= expr", + /* 229 */ "case_operand ::=", + /* 230 */ "exprlist ::= nexprlist", + /* 231 */ "exprlist ::=", + /* 232 */ "nexprlist ::= nexprlist COMMA expr", + /* 233 */ "nexprlist ::= expr", + /* 234 */ "cmd ::= CREATE uniqueflag INDEX ifnotexists nm dbnm ON nm LP idxlist RP", + /* 235 */ "uniqueflag ::= UNIQUE", + /* 236 */ "uniqueflag ::=", + /* 237 */ "idxlist_opt ::=", + /* 238 */ "idxlist_opt ::= LP idxlist RP", + /* 239 */ "idxlist ::= idxlist COMMA idxitem collate sortorder", + /* 240 */ "idxlist ::= idxitem collate sortorder", + /* 241 */ "idxitem ::= nm", + /* 242 */ "collate ::=", + /* 243 */ "collate ::= COLLATE ids", + /* 244 */ "cmd ::= DROP INDEX ifexists fullname", + /* 245 */ "cmd ::= VACUUM", + /* 246 */ "cmd ::= VACUUM nm", + /* 247 */ "cmd ::= PRAGMA nm dbnm EQ nmnum", + /* 248 */ "cmd ::= PRAGMA nm dbnm EQ ON", + /* 249 */ "cmd ::= PRAGMA nm dbnm EQ minus_num", + /* 250 */ "cmd ::= PRAGMA nm dbnm LP nmnum RP", + /* 251 */ "cmd ::= PRAGMA nm dbnm", + /* 252 */ "nmnum ::= plus_num", + /* 253 */ "nmnum ::= nm", + /* 254 */ "plus_num ::= plus_opt number", + /* 255 */ "minus_num ::= MINUS number", + /* 256 */ "number ::= INTEGER|FLOAT", + /* 257 */ "plus_opt ::= PLUS", + /* 258 */ "plus_opt ::=", + /* 259 */ "cmd ::= CREATE trigger_decl BEGIN trigger_cmd_list END", + /* 260 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause", + /* 261 */ "trigger_time ::= BEFORE", + /* 262 */ "trigger_time ::= AFTER", + /* 263 */ "trigger_time ::= INSTEAD OF", + /* 264 */ "trigger_time ::=", + /* 265 */ "trigger_event ::= DELETE|INSERT", + /* 266 */ "trigger_event ::= UPDATE", + /* 267 */ "trigger_event ::= UPDATE OF inscollist", + /* 268 */ "foreach_clause ::=", + /* 269 */ "foreach_clause ::= FOR EACH ROW", + /* 270 */ "when_clause ::=", + /* 271 */ "when_clause ::= WHEN expr", + /* 272 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI", + /* 273 */ "trigger_cmd_list ::=", + /* 274 */ "trigger_cmd ::= UPDATE orconf nm SET setlist where_opt", + /* 275 */ "trigger_cmd ::= insert_cmd INTO nm inscollist_opt VALUES LP itemlist RP", + /* 276 */ "trigger_cmd ::= insert_cmd INTO nm inscollist_opt select", + /* 277 */ "trigger_cmd ::= DELETE FROM nm where_opt", + /* 278 */ "trigger_cmd ::= select", + /* 279 */ "expr ::= RAISE LP IGNORE RP", + /* 280 */ "expr ::= RAISE LP raisetype COMMA nm RP", + /* 281 */ "raisetype ::= ROLLBACK", + /* 282 */ "raisetype ::= ABORT", + /* 283 */ "raisetype ::= FAIL", + /* 284 */ "cmd ::= DROP TRIGGER ifexists fullname", + /* 285 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt", + /* 286 */ "cmd ::= DETACH database_kw_opt expr", + /* 287 */ "key_opt ::=", + /* 288 */ "key_opt ::= KEY expr", + /* 289 */ "database_kw_opt ::= DATABASE", + /* 290 */ "database_kw_opt ::=", + /* 291 */ "cmd ::= REINDEX", + /* 292 */ "cmd ::= REINDEX nm dbnm", + /* 293 */ "cmd ::= ANALYZE", + /* 294 */ "cmd ::= ANALYZE nm dbnm", + /* 295 */ "cmd ::= ALTER TABLE fullname RENAME TO nm", + /* 296 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt column", + /* 297 */ "add_column_fullname ::= fullname", + /* 298 */ "kwcolumn_opt ::=", + /* 299 */ "kwcolumn_opt ::= COLUMNKW", + /* 300 */ "cmd ::= create_vtab", + /* 301 */ "cmd ::= create_vtab LP vtabarglist RP", + /* 302 */ "create_vtab ::= CREATE VIRTUAL TABLE nm dbnm USING nm", + /* 303 */ "vtabarglist ::= vtabarg", + /* 304 */ "vtabarglist ::= vtabarglist COMMA vtabarg", + /* 305 */ "vtabarg ::=", + /* 306 */ "vtabarg ::= vtabarg vtabargtoken", + /* 307 */ "vtabargtoken ::= ANY", + /* 308 */ "vtabargtoken ::= lp anylist RP", + /* 309 */ "lp ::= LP", + /* 310 */ "anylist ::=", + /* 311 */ "anylist ::= anylist ANY", +}; +#endif /* NDEBUG */ + + +#if YYSTACKDEPTH<=0 +/* +** Try to increase the size of the parser stack. +*/ +static void yyGrowStack(yyParser *p){ + int newSize; + yyStackEntry *pNew; + + newSize = p->yystksz*2 + 100; + pNew = realloc(p->yystack, newSize*sizeof(pNew[0])); + if( pNew ){ + p->yystack = pNew; + p->yystksz = newSize; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sStack grows to %d entries!\n", + yyTracePrompt, p->yystksz); + } +#endif + } +} +#endif + +/* +** This function allocates a new parser. +** The only argument is a pointer to a function which works like +** malloc. +** +** Inputs: +** A pointer to the function used to allocate memory. +** +** Outputs: +** A pointer to a parser. This pointer is used in subsequent calls +** to sqlite3Parser and sqlite3ParserFree. +*/ +void *sqlite3ParserAlloc(void *(*mallocProc)(size_t)){ + yyParser *pParser; + pParser = (yyParser*)(*mallocProc)( (size_t)sizeof(yyParser) ); + if( pParser ){ + pParser->yyidx = -1; +#if YYSTACKDEPTH<=0 + yyGrowStack(pParser); +#endif + } + return pParser; +} + +/* The following function deletes the value associated with a +** symbol. The symbol can be either a terminal or nonterminal. +** "yymajor" is the symbol code, and "yypminor" is a pointer to +** the value. +*/ +static void yy_destructor(YYCODETYPE yymajor, YYMINORTYPE *yypminor){ + switch( yymajor ){ + /* Here is inserted the actions which take place when a + ** terminal or non-terminal is destroyed. This can happen + ** when the symbol is popped from the stack during a + ** reduce or during error processing or when a parser is + ** being destroyed before it is finished parsing. + ** + ** Note: during a reduce, the only symbols destroyed are those + ** which appear on the RHS of the rule, but which are not used + ** inside the C code. + */ + case 155: + case 189: + case 206: +#line 373 "parse.y" +{sqlite3SelectDelete((yypminor->yy219));} +#line 1302 "parse.c" + break; + case 169: + case 170: + case 194: + case 196: + case 204: + case 210: + case 218: + case 221: + case 223: + case 235: +#line 633 "parse.y" +{sqlite3ExprDelete((yypminor->yy172));} +#line 1316 "parse.c" + break; + case 174: + case 182: + case 192: + case 195: + case 197: + case 199: + case 209: + case 211: + case 212: + case 215: + case 216: + case 222: +#line 891 "parse.y" +{sqlite3ExprListDelete((yypminor->yy174));} +#line 1332 "parse.c" + break; + case 188: + case 193: + case 201: + case 202: +#line 490 "parse.y" +{sqlite3SrcListDelete((yypminor->yy373));} +#line 1340 "parse.c" + break; + case 205: + case 208: + case 214: +#line 507 "parse.y" +{sqlite3IdListDelete((yypminor->yy432));} +#line 1347 "parse.c" + break; + case 231: + case 236: +#line 994 "parse.y" +{sqlite3DeleteTriggerStep((yypminor->yy243));} +#line 1353 "parse.c" + break; + case 233: +#line 980 "parse.y" +{sqlite3IdListDelete((yypminor->yy370).b);} +#line 1358 "parse.c" + break; + case 238: +#line 1067 "parse.y" +{sqlite3ExprDelete((yypminor->yy386));} +#line 1363 "parse.c" + break; + default: break; /* If no destructor action specified: do nothing */ + } +} + +/* +** Pop the parser's stack once. +** +** If there is a destructor routine associated with the token which +** is popped from the stack, then call it. +** +** Return the major token number for the symbol popped. +*/ +static int yy_pop_parser_stack(yyParser *pParser){ + YYCODETYPE yymajor; + yyStackEntry *yytos = &pParser->yystack[pParser->yyidx]; + + if( pParser->yyidx<0 ) return 0; +#ifndef NDEBUG + if( yyTraceFILE && pParser->yyidx>=0 ){ + fprintf(yyTraceFILE,"%sPopping %s\n", + yyTracePrompt, + yyTokenName[yytos->major]); + } +#endif + yymajor = yytos->major; + yy_destructor( yymajor, &yytos->minor); + pParser->yyidx--; + return yymajor; +} + +/* +** Deallocate and destroy a parser. Destructors are all called for +** all stack elements before shutting the parser down. +** +** Inputs: +**
    +**
  • A pointer to the parser. This should be a pointer +** obtained from sqlite3ParserAlloc. +**
  • A pointer to a function used to reclaim memory obtained +** from malloc. +**
+*/ +void sqlite3ParserFree( + void *p, /* The parser to be deleted */ + void (*freeProc)(void*) /* Function used to reclaim memory */ +){ + yyParser *pParser = (yyParser*)p; + if( pParser==0 ) return; + while( pParser->yyidx>=0 ) yy_pop_parser_stack(pParser); +#if YYSTACKDEPTH<=0 + free(pParser->yystack); +#endif + (*freeProc)((void*)pParser); +} + +/* +** Find the appropriate action for a parser given the terminal +** look-ahead token iLookAhead. +** +** If the look-ahead token is YYNOCODE, then check to see if the action is +** independent of the look-ahead. If it is, return the action, otherwise +** return YY_NO_ACTION. +*/ +static int yy_find_shift_action( + yyParser *pParser, /* The parser */ + YYCODETYPE iLookAhead /* The look-ahead token */ +){ + int i; + int stateno = pParser->yystack[pParser->yyidx].stateno; + + if( stateno>YY_SHIFT_MAX || (i = yy_shift_ofst[stateno])==YY_SHIFT_USE_DFLT ){ + return yy_default[stateno]; + } + if( iLookAhead==YYNOCODE ){ + return YY_NO_ACTION; + } + i += iLookAhead; + if( i<0 || i>=YY_SZ_ACTTAB || yy_lookahead[i]!=iLookAhead ){ + if( iLookAhead>0 ){ +#ifdef YYFALLBACK + int iFallback; /* Fallback token */ + if( iLookAhead %s\n", + yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]); + } +#endif + return yy_find_shift_action(pParser, iFallback); + } +#endif +#ifdef YYWILDCARD + { + int j = i - iLookAhead + YYWILDCARD; + if( j>=0 && j %s\n", + yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[YYWILDCARD]); + } +#endif /* NDEBUG */ + return yy_action[j]; + } + } +#endif /* YYWILDCARD */ + } + return yy_default[stateno]; + }else{ + return yy_action[i]; + } +} + +/* +** Find the appropriate action for a parser given the non-terminal +** look-ahead token iLookAhead. +** +** If the look-ahead token is YYNOCODE, then check to see if the action is +** independent of the look-ahead. If it is, return the action, otherwise +** return YY_NO_ACTION. +*/ +static int yy_find_reduce_action( + int stateno, /* Current state number */ + YYCODETYPE iLookAhead /* The look-ahead token */ +){ + int i; + /* int stateno = pParser->yystack[pParser->yyidx].stateno; */ + + if( stateno>YY_REDUCE_MAX || + (i = yy_reduce_ofst[stateno])==YY_REDUCE_USE_DFLT ){ + return yy_default[stateno]; + } + if( iLookAhead==YYNOCODE ){ + return YY_NO_ACTION; + } + i += iLookAhead; + if( i<0 || i>=YY_SZ_ACTTAB || yy_lookahead[i]!=iLookAhead ){ + return yy_default[stateno]; + }else{ + return yy_action[i]; + } +} + +/* +** The following routine is called if the stack overflows. +*/ +static void yyStackOverflow(yyParser *yypParser, YYMINORTYPE *yypMinor){ + sqlite3ParserARG_FETCH; + yypParser->yyidx--; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt); + } +#endif + while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser); + /* Here code is inserted which will execute if the parser + ** stack every overflows */ +#line 44 "parse.y" + + sqlite3ErrorMsg(pParse, "parser stack overflow"); + pParse->parseError = 1; +#line 1527 "parse.c" + sqlite3ParserARG_STORE; /* Suppress warning about unused %extra_argument var */ +} + +/* +** Perform a shift action. +*/ +static void yy_shift( + yyParser *yypParser, /* The parser to be shifted */ + int yyNewState, /* The new state to shift in */ + int yyMajor, /* The major token to shift in */ + YYMINORTYPE *yypMinor /* Pointer ot the minor token to shift in */ +){ + yyStackEntry *yytos; + yypParser->yyidx++; +#if YYSTACKDEPTH>0 + if( yypParser->yyidx>=YYSTACKDEPTH ){ + yyStackOverflow(yypParser, yypMinor); + return; + } +#else + if( yypParser->yyidx>=yypParser->yystksz ){ + yyGrowStack(yypParser); + if( yypParser->yyidx>=yypParser->yystksz ){ + yyStackOverflow(yypParser, yypMinor); + return; + } + } +#endif + yytos = &yypParser->yystack[yypParser->yyidx]; + yytos->stateno = yyNewState; + yytos->major = yyMajor; + yytos->minor = *yypMinor; +#ifndef NDEBUG + if( yyTraceFILE && yypParser->yyidx>0 ){ + int i; + fprintf(yyTraceFILE,"%sShift %d\n",yyTracePrompt,yyNewState); + fprintf(yyTraceFILE,"%sStack:",yyTracePrompt); + for(i=1; i<=yypParser->yyidx; i++) + fprintf(yyTraceFILE," %s",yyTokenName[yypParser->yystack[i].major]); + fprintf(yyTraceFILE,"\n"); + } +#endif +} + +/* The following table contains information about every rule that +** is used during the reduce. +*/ +static const struct { + YYCODETYPE lhs; /* Symbol on the left-hand side of the rule */ + unsigned char nrhs; /* Number of right-hand side symbols in the rule */ +} yyRuleInfo[] = { + { 139, 1 }, + { 140, 2 }, + { 140, 1 }, + { 142, 1 }, + { 141, 1 }, + { 141, 3 }, + { 144, 0 }, + { 144, 1 }, + { 144, 3 }, + { 143, 3 }, + { 146, 0 }, + { 146, 1 }, + { 146, 2 }, + { 145, 0 }, + { 145, 1 }, + { 145, 1 }, + { 145, 1 }, + { 143, 2 }, + { 143, 2 }, + { 143, 2 }, + { 143, 2 }, + { 148, 6 }, + { 151, 0 }, + { 151, 3 }, + { 150, 1 }, + { 150, 0 }, + { 149, 4 }, + { 149, 2 }, + { 153, 3 }, + { 153, 1 }, + { 156, 3 }, + { 157, 1 }, + { 160, 1 }, + { 161, 1 }, + { 147, 1 }, + { 147, 1 }, + { 147, 1 }, + { 158, 0 }, + { 158, 1 }, + { 162, 1 }, + { 162, 4 }, + { 162, 6 }, + { 163, 1 }, + { 163, 2 }, + { 164, 1 }, + { 164, 1 }, + { 159, 2 }, + { 159, 0 }, + { 167, 3 }, + { 167, 1 }, + { 168, 2 }, + { 168, 4 }, + { 168, 3 }, + { 168, 3 }, + { 168, 2 }, + { 168, 2 }, + { 168, 3 }, + { 168, 5 }, + { 168, 2 }, + { 168, 4 }, + { 168, 4 }, + { 168, 1 }, + { 168, 2 }, + { 173, 0 }, + { 173, 1 }, + { 175, 0 }, + { 175, 2 }, + { 177, 2 }, + { 177, 3 }, + { 177, 3 }, + { 177, 3 }, + { 178, 2 }, + { 178, 2 }, + { 178, 1 }, + { 178, 1 }, + { 176, 3 }, + { 176, 2 }, + { 179, 0 }, + { 179, 2 }, + { 179, 2 }, + { 154, 0 }, + { 154, 2 }, + { 180, 3 }, + { 180, 2 }, + { 180, 1 }, + { 181, 2 }, + { 181, 7 }, + { 181, 5 }, + { 181, 5 }, + { 181, 10 }, + { 183, 0 }, + { 183, 1 }, + { 171, 0 }, + { 171, 3 }, + { 184, 0 }, + { 184, 2 }, + { 185, 1 }, + { 185, 1 }, + { 185, 1 }, + { 143, 4 }, + { 187, 2 }, + { 187, 0 }, + { 143, 8 }, + { 143, 4 }, + { 143, 1 }, + { 155, 1 }, + { 155, 3 }, + { 190, 1 }, + { 190, 2 }, + { 190, 1 }, + { 189, 9 }, + { 191, 1 }, + { 191, 1 }, + { 191, 0 }, + { 199, 2 }, + { 199, 0 }, + { 192, 3 }, + { 192, 2 }, + { 192, 4 }, + { 200, 2 }, + { 200, 1 }, + { 200, 0 }, + { 193, 0 }, + { 193, 2 }, + { 202, 2 }, + { 202, 0 }, + { 201, 6 }, + { 201, 7 }, + { 206, 1 }, + { 206, 1 }, + { 152, 0 }, + { 152, 2 }, + { 188, 2 }, + { 203, 1 }, + { 203, 2 }, + { 203, 3 }, + { 203, 4 }, + { 204, 2 }, + { 204, 0 }, + { 205, 4 }, + { 205, 0 }, + { 197, 0 }, + { 197, 3 }, + { 209, 4 }, + { 209, 2 }, + { 210, 1 }, + { 172, 1 }, + { 172, 1 }, + { 172, 0 }, + { 195, 0 }, + { 195, 3 }, + { 196, 0 }, + { 196, 2 }, + { 198, 0 }, + { 198, 2 }, + { 198, 4 }, + { 198, 4 }, + { 143, 4 }, + { 194, 0 }, + { 194, 2 }, + { 143, 6 }, + { 212, 5 }, + { 212, 3 }, + { 143, 8 }, + { 143, 5 }, + { 143, 6 }, + { 213, 2 }, + { 213, 1 }, + { 215, 3 }, + { 215, 1 }, + { 214, 0 }, + { 214, 3 }, + { 208, 3 }, + { 208, 1 }, + { 170, 1 }, + { 170, 3 }, + { 169, 1 }, + { 170, 1 }, + { 170, 1 }, + { 170, 3 }, + { 170, 5 }, + { 169, 1 }, + { 169, 1 }, + { 170, 1 }, + { 170, 1 }, + { 170, 3 }, + { 170, 6 }, + { 170, 5 }, + { 170, 4 }, + { 169, 1 }, + { 170, 3 }, + { 170, 3 }, + { 170, 3 }, + { 170, 3 }, + { 170, 3 }, + { 170, 3 }, + { 170, 3 }, + { 170, 3 }, + { 217, 1 }, + { 217, 2 }, + { 217, 1 }, + { 217, 2 }, + { 218, 2 }, + { 218, 0 }, + { 170, 4 }, + { 170, 2 }, + { 170, 3 }, + { 170, 3 }, + { 170, 4 }, + { 170, 2 }, + { 170, 2 }, + { 170, 2 }, + { 170, 2 }, + { 219, 1 }, + { 219, 2 }, + { 170, 5 }, + { 220, 1 }, + { 220, 2 }, + { 170, 5 }, + { 170, 3 }, + { 170, 5 }, + { 170, 4 }, + { 170, 4 }, + { 170, 5 }, + { 222, 5 }, + { 222, 4 }, + { 223, 2 }, + { 223, 0 }, + { 221, 1 }, + { 221, 0 }, + { 216, 1 }, + { 216, 0 }, + { 211, 3 }, + { 211, 1 }, + { 143, 11 }, + { 224, 1 }, + { 224, 0 }, + { 174, 0 }, + { 174, 3 }, + { 182, 5 }, + { 182, 3 }, + { 225, 1 }, + { 226, 0 }, + { 226, 2 }, + { 143, 4 }, + { 143, 1 }, + { 143, 2 }, + { 143, 5 }, + { 143, 5 }, + { 143, 5 }, + { 143, 6 }, + { 143, 3 }, + { 227, 1 }, + { 227, 1 }, + { 165, 2 }, + { 166, 2 }, + { 229, 1 }, + { 228, 1 }, + { 228, 0 }, + { 143, 5 }, + { 230, 11 }, + { 232, 1 }, + { 232, 1 }, + { 232, 2 }, + { 232, 0 }, + { 233, 1 }, + { 233, 1 }, + { 233, 3 }, + { 234, 0 }, + { 234, 3 }, + { 235, 0 }, + { 235, 2 }, + { 231, 3 }, + { 231, 0 }, + { 236, 6 }, + { 236, 8 }, + { 236, 5 }, + { 236, 4 }, + { 236, 1 }, + { 170, 4 }, + { 170, 6 }, + { 186, 1 }, + { 186, 1 }, + { 186, 1 }, + { 143, 4 }, + { 143, 6 }, + { 143, 3 }, + { 238, 0 }, + { 238, 2 }, + { 237, 1 }, + { 237, 0 }, + { 143, 1 }, + { 143, 3 }, + { 143, 1 }, + { 143, 3 }, + { 143, 6 }, + { 143, 6 }, + { 239, 1 }, + { 240, 0 }, + { 240, 1 }, + { 143, 1 }, + { 143, 4 }, + { 241, 7 }, + { 242, 1 }, + { 242, 3 }, + { 243, 0 }, + { 243, 2 }, + { 244, 1 }, + { 244, 3 }, + { 245, 1 }, + { 246, 0 }, + { 246, 2 }, +}; + +static void yy_accept(yyParser*); /* Forward Declaration */ + +/* +** Perform a reduce action and the shift that must immediately +** follow the reduce. +*/ +static void yy_reduce( + yyParser *yypParser, /* The parser */ + int yyruleno /* Number of the rule by which to reduce */ +){ + int yygoto; /* The next state */ + int yyact; /* The next action */ + YYMINORTYPE yygotominor; /* The LHS of the rule reduced */ + yyStackEntry *yymsp; /* The top of the parser's stack */ + int yysize; /* Amount to pop the stack */ + sqlite3ParserARG_FETCH; + yymsp = &yypParser->yystack[yypParser->yyidx]; +#ifndef NDEBUG + if( yyTraceFILE && yyruleno>=0 + && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){ + fprintf(yyTraceFILE, "%sReduce [%s].\n", yyTracePrompt, + yyRuleName[yyruleno]); + } +#endif /* NDEBUG */ + + /* Silence complaints from purify about yygotominor being uninitialized + ** in some cases when it is copied into the stack after the following + ** switch. yygotominor is uninitialized when a rule reduces that does + ** not set the value of its left-hand side nonterminal. Leaving the + ** value of the nonterminal uninitialized is utterly harmless as long + ** as the value is never used. So really the only thing this code + ** accomplishes is to quieten purify. + ** + ** 2007-01-16: The wireshark project (www.wireshark.org) reports that + ** without this code, their parser segfaults. I'm not sure what there + ** parser is doing to make this happen. This is the second bug report + ** from wireshark this week. Clearly they are stressing Lemon in ways + ** that it has not been previously stressed... (SQLite ticket #2172) + */ + memset(&yygotominor, 0, sizeof(yygotominor)); + + + switch( yyruleno ){ + /* Beginning here are the reduction cases. A typical example + ** follows: + ** case 0: + ** #line + ** { ... } // User supplied code + ** #line + ** break; + */ + case 0: + case 1: + case 2: + case 4: + case 5: + case 10: + case 11: + case 12: + case 20: + case 28: + case 29: + case 37: + case 44: + case 45: + case 46: + case 47: + case 48: + case 49: + case 55: + case 82: + case 83: + case 84: + case 85: + case 257: + case 258: + case 268: + case 269: + case 289: + case 290: + case 298: + case 299: + case 303: + case 304: + case 306: + case 310: +#line 96 "parse.y" +{ +} +#line 1982 "parse.c" + break; + case 3: +#line 99 "parse.y" +{ sqlite3FinishCoding(pParse); } +#line 1987 "parse.c" + break; + case 6: +#line 102 "parse.y" +{ sqlite3BeginParse(pParse, 0); } +#line 1992 "parse.c" + break; + case 7: +#line 104 "parse.y" +{ sqlite3BeginParse(pParse, 1); } +#line 1997 "parse.c" + break; + case 8: +#line 105 "parse.y" +{ sqlite3BeginParse(pParse, 2); } +#line 2002 "parse.c" + break; + case 9: +#line 111 "parse.y" +{sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy46);} +#line 2007 "parse.c" + break; + case 13: +#line 116 "parse.y" +{yygotominor.yy46 = TK_DEFERRED;} +#line 2012 "parse.c" + break; + case 14: + case 15: + case 16: + case 107: + case 109: +#line 117 "parse.y" +{yygotominor.yy46 = yymsp[0].major;} +#line 2021 "parse.c" + break; + case 17: + case 18: +#line 120 "parse.y" +{sqlite3CommitTransaction(pParse);} +#line 2027 "parse.c" + break; + case 19: +#line 122 "parse.y" +{sqlite3RollbackTransaction(pParse);} +#line 2032 "parse.c" + break; + case 21: +#line 127 "parse.y" +{ + sqlite3StartTable(pParse,&yymsp[-1].minor.yy410,&yymsp[0].minor.yy410,yymsp[-4].minor.yy46,0,0,yymsp[-2].minor.yy46); +} +#line 2039 "parse.c" + break; + case 22: + case 25: + case 63: + case 77: + case 79: + case 90: + case 101: + case 112: + case 113: + case 213: + case 216: +#line 131 "parse.y" +{yygotominor.yy46 = 0;} +#line 2054 "parse.c" + break; + case 23: + case 24: + case 64: + case 78: + case 100: + case 111: + case 214: + case 217: +#line 132 "parse.y" +{yygotominor.yy46 = 1;} +#line 2066 "parse.c" + break; + case 26: +#line 138 "parse.y" +{ + sqlite3EndTable(pParse,&yymsp[-1].minor.yy410,&yymsp[0].minor.yy0,0); +} +#line 2073 "parse.c" + break; + case 27: +#line 141 "parse.y" +{ + sqlite3EndTable(pParse,0,0,yymsp[0].minor.yy219); + sqlite3SelectDelete(yymsp[0].minor.yy219); +} +#line 2081 "parse.c" + break; + case 30: +#line 153 "parse.y" +{ + yygotominor.yy410.z = yymsp[-2].minor.yy410.z; + yygotominor.yy410.n = (pParse->sLastToken.z-yymsp[-2].minor.yy410.z) + pParse->sLastToken.n; +} +#line 2089 "parse.c" + break; + case 31: +#line 157 "parse.y" +{ + sqlite3AddColumn(pParse,&yymsp[0].minor.yy410); + yygotominor.yy410 = yymsp[0].minor.yy410; +} +#line 2097 "parse.c" + break; + case 32: + case 33: + case 34: + case 35: + case 36: + case 256: +#line 167 "parse.y" +{yygotominor.yy410 = yymsp[0].minor.yy0;} +#line 2107 "parse.c" + break; + case 38: +#line 228 "parse.y" +{sqlite3AddColumnType(pParse,&yymsp[0].minor.yy410);} +#line 2112 "parse.c" + break; + case 39: + case 42: + case 119: + case 120: + case 131: + case 241: + case 243: + case 252: + case 253: + case 254: + case 255: +#line 229 "parse.y" +{yygotominor.yy410 = yymsp[0].minor.yy410;} +#line 2127 "parse.c" + break; + case 40: +#line 230 "parse.y" +{ + yygotominor.yy410.z = yymsp[-3].minor.yy410.z; + yygotominor.yy410.n = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] - yymsp[-3].minor.yy410.z; +} +#line 2135 "parse.c" + break; + case 41: +#line 234 "parse.y" +{ + yygotominor.yy410.z = yymsp[-5].minor.yy410.z; + yygotominor.yy410.n = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] - yymsp[-5].minor.yy410.z; +} +#line 2143 "parse.c" + break; + case 43: +#line 240 "parse.y" +{yygotominor.yy410.z=yymsp[-1].minor.yy410.z; yygotominor.yy410.n=yymsp[0].minor.yy410.n+(yymsp[0].minor.yy410.z-yymsp[-1].minor.yy410.z);} +#line 2148 "parse.c" + break; + case 50: + case 52: +#line 251 "parse.y" +{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy172);} +#line 2154 "parse.c" + break; + case 51: +#line 252 "parse.y" +{sqlite3AddDefaultValue(pParse,yymsp[-1].minor.yy172);} +#line 2159 "parse.c" + break; + case 53: +#line 254 "parse.y" +{ + Expr *p = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy172, 0, 0); + sqlite3AddDefaultValue(pParse,p); +} +#line 2167 "parse.c" + break; + case 54: +#line 258 "parse.y" +{ + Expr *p = sqlite3PExpr(pParse, TK_STRING, 0, 0, &yymsp[0].minor.yy410); + sqlite3AddDefaultValue(pParse,p); +} +#line 2175 "parse.c" + break; + case 56: +#line 267 "parse.y" +{sqlite3AddNotNull(pParse, yymsp[0].minor.yy46);} +#line 2180 "parse.c" + break; + case 57: +#line 269 "parse.y" +{sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy46,yymsp[0].minor.yy46,yymsp[-2].minor.yy46);} +#line 2185 "parse.c" + break; + case 58: +#line 270 "parse.y" +{sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy46,0,0,0,0);} +#line 2190 "parse.c" + break; + case 59: +#line 271 "parse.y" +{sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy172);} +#line 2195 "parse.c" + break; + case 60: +#line 273 "parse.y" +{sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy410,yymsp[-1].minor.yy174,yymsp[0].minor.yy46);} +#line 2200 "parse.c" + break; + case 61: +#line 274 "parse.y" +{sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy46);} +#line 2205 "parse.c" + break; + case 62: +#line 275 "parse.y" +{sqlite3AddCollateType(pParse, &yymsp[0].minor.yy410);} +#line 2210 "parse.c" + break; + case 65: +#line 288 "parse.y" +{ yygotominor.yy46 = OE_Restrict * 0x010101; } +#line 2215 "parse.c" + break; + case 66: +#line 289 "parse.y" +{ yygotominor.yy46 = (yymsp[-1].minor.yy46 & yymsp[0].minor.yy405.mask) | yymsp[0].minor.yy405.value; } +#line 2220 "parse.c" + break; + case 67: +#line 291 "parse.y" +{ yygotominor.yy405.value = 0; yygotominor.yy405.mask = 0x000000; } +#line 2225 "parse.c" + break; + case 68: +#line 292 "parse.y" +{ yygotominor.yy405.value = yymsp[0].minor.yy46; yygotominor.yy405.mask = 0x0000ff; } +#line 2230 "parse.c" + break; + case 69: +#line 293 "parse.y" +{ yygotominor.yy405.value = yymsp[0].minor.yy46<<8; yygotominor.yy405.mask = 0x00ff00; } +#line 2235 "parse.c" + break; + case 70: +#line 294 "parse.y" +{ yygotominor.yy405.value = yymsp[0].minor.yy46<<16; yygotominor.yy405.mask = 0xff0000; } +#line 2240 "parse.c" + break; + case 71: +#line 296 "parse.y" +{ yygotominor.yy46 = OE_SetNull; } +#line 2245 "parse.c" + break; + case 72: +#line 297 "parse.y" +{ yygotominor.yy46 = OE_SetDflt; } +#line 2250 "parse.c" + break; + case 73: +#line 298 "parse.y" +{ yygotominor.yy46 = OE_Cascade; } +#line 2255 "parse.c" + break; + case 74: +#line 299 "parse.y" +{ yygotominor.yy46 = OE_Restrict; } +#line 2260 "parse.c" + break; + case 75: + case 76: + case 91: + case 93: + case 95: + case 96: + case 166: +#line 301 "parse.y" +{yygotominor.yy46 = yymsp[0].minor.yy46;} +#line 2271 "parse.c" + break; + case 80: +#line 311 "parse.y" +{yygotominor.yy410.n = 0; yygotominor.yy410.z = 0;} +#line 2276 "parse.c" + break; + case 81: +#line 312 "parse.y" +{yygotominor.yy410 = yymsp[-1].minor.yy0;} +#line 2281 "parse.c" + break; + case 86: +#line 318 "parse.y" +{sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy174,yymsp[0].minor.yy46,yymsp[-2].minor.yy46,0);} +#line 2286 "parse.c" + break; + case 87: +#line 320 "parse.y" +{sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy174,yymsp[0].minor.yy46,0,0,0,0);} +#line 2291 "parse.c" + break; + case 88: +#line 321 "parse.y" +{sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy172);} +#line 2296 "parse.c" + break; + case 89: +#line 323 "parse.y" +{ + sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy174, &yymsp[-3].minor.yy410, yymsp[-2].minor.yy174, yymsp[-1].minor.yy46); + sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy46); +} +#line 2304 "parse.c" + break; + case 92: + case 94: +#line 337 "parse.y" +{yygotominor.yy46 = OE_Default;} +#line 2310 "parse.c" + break; + case 97: +#line 342 "parse.y" +{yygotominor.yy46 = OE_Ignore;} +#line 2315 "parse.c" + break; + case 98: + case 167: +#line 343 "parse.y" +{yygotominor.yy46 = OE_Replace;} +#line 2321 "parse.c" + break; + case 99: +#line 347 "parse.y" +{ + sqlite3DropTable(pParse, yymsp[0].minor.yy373, 0, yymsp[-1].minor.yy46); +} +#line 2328 "parse.c" + break; + case 102: +#line 357 "parse.y" +{ + sqlite3CreateView(pParse, &yymsp[-7].minor.yy0, &yymsp[-3].minor.yy410, &yymsp[-2].minor.yy410, yymsp[0].minor.yy219, yymsp[-6].minor.yy46, yymsp[-4].minor.yy46); +} +#line 2335 "parse.c" + break; + case 103: +#line 360 "parse.y" +{ + sqlite3DropTable(pParse, yymsp[0].minor.yy373, 1, yymsp[-1].minor.yy46); +} +#line 2342 "parse.c" + break; + case 104: +#line 367 "parse.y" +{ + sqlite3Select(pParse, yymsp[0].minor.yy219, SRT_Callback, 0, 0, 0, 0, 0); + sqlite3SelectDelete(yymsp[0].minor.yy219); +} +#line 2350 "parse.c" + break; + case 105: + case 128: +#line 377 "parse.y" +{yygotominor.yy219 = yymsp[0].minor.yy219;} +#line 2356 "parse.c" + break; + case 106: +#line 379 "parse.y" +{ + if( yymsp[0].minor.yy219 ){ + yymsp[0].minor.yy219->op = yymsp[-1].minor.yy46; + yymsp[0].minor.yy219->pPrior = yymsp[-2].minor.yy219; + }else{ + sqlite3SelectDelete(yymsp[-2].minor.yy219); + } + yygotominor.yy219 = yymsp[0].minor.yy219; +} +#line 2369 "parse.c" + break; + case 108: +#line 390 "parse.y" +{yygotominor.yy46 = TK_ALL;} +#line 2374 "parse.c" + break; + case 110: +#line 394 "parse.y" +{ + yygotominor.yy219 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy174,yymsp[-5].minor.yy373,yymsp[-4].minor.yy172,yymsp[-3].minor.yy174,yymsp[-2].minor.yy172,yymsp[-1].minor.yy174,yymsp[-7].minor.yy46,yymsp[0].minor.yy234.pLimit,yymsp[0].minor.yy234.pOffset); +} +#line 2381 "parse.c" + break; + case 114: + case 238: +#line 415 "parse.y" +{yygotominor.yy174 = yymsp[-1].minor.yy174;} +#line 2387 "parse.c" + break; + case 115: + case 141: + case 149: + case 231: + case 237: +#line 416 "parse.y" +{yygotominor.yy174 = 0;} +#line 2396 "parse.c" + break; + case 116: +#line 417 "parse.y" +{ + yygotominor.yy174 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy174,yymsp[-1].minor.yy172,yymsp[0].minor.yy410.n?&yymsp[0].minor.yy410:0); +} +#line 2403 "parse.c" + break; + case 117: +#line 420 "parse.y" +{ + Expr *p = sqlite3PExpr(pParse, TK_ALL, 0, 0, 0); + yygotominor.yy174 = sqlite3ExprListAppend(pParse, yymsp[-1].minor.yy174, p, 0); +} +#line 2411 "parse.c" + break; + case 118: +#line 424 "parse.y" +{ + Expr *pRight = sqlite3PExpr(pParse, TK_ALL, 0, 0, 0); + Expr *pLeft = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-2].minor.yy410); + Expr *pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight, 0); + yygotominor.yy174 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy174, pDot, 0); +} +#line 2421 "parse.c" + break; + case 121: +#line 437 "parse.y" +{yygotominor.yy410.n = 0;} +#line 2426 "parse.c" + break; + case 122: +#line 449 "parse.y" +{yygotominor.yy373 = (SrcList*)sqlite3DbMallocZero(pParse->db, sizeof(*yygotominor.yy373));} +#line 2431 "parse.c" + break; + case 123: +#line 450 "parse.y" +{ + yygotominor.yy373 = yymsp[0].minor.yy373; + sqlite3SrcListShiftJoinType(yygotominor.yy373); +} +#line 2439 "parse.c" + break; + case 124: +#line 458 "parse.y" +{ + yygotominor.yy373 = yymsp[-1].minor.yy373; + if( yygotominor.yy373 && yygotominor.yy373->nSrc>0 ) yygotominor.yy373->a[yygotominor.yy373->nSrc-1].jointype = yymsp[0].minor.yy46; +} +#line 2447 "parse.c" + break; + case 125: +#line 462 "parse.y" +{yygotominor.yy373 = 0;} +#line 2452 "parse.c" + break; + case 126: +#line 463 "parse.y" +{ + yygotominor.yy373 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy373,&yymsp[-4].minor.yy410,&yymsp[-3].minor.yy410,&yymsp[-2].minor.yy410,0,yymsp[-1].minor.yy172,yymsp[0].minor.yy432); +} +#line 2459 "parse.c" + break; + case 127: +#line 468 "parse.y" +{ + yygotominor.yy373 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy373,0,0,&yymsp[-2].minor.yy410,yymsp[-4].minor.yy219,yymsp[-1].minor.yy172,yymsp[0].minor.yy432); + } +#line 2466 "parse.c" + break; + case 129: +#line 479 "parse.y" +{ + sqlite3SrcListShiftJoinType(yymsp[0].minor.yy373); + yygotominor.yy219 = sqlite3SelectNew(pParse,0,yymsp[0].minor.yy373,0,0,0,0,0,0,0); + } +#line 2474 "parse.c" + break; + case 130: +#line 486 "parse.y" +{yygotominor.yy410.z=0; yygotominor.yy410.n=0;} +#line 2479 "parse.c" + break; + case 132: +#line 491 "parse.y" +{yygotominor.yy373 = sqlite3SrcListAppend(pParse->db,0,&yymsp[-1].minor.yy410,&yymsp[0].minor.yy410);} +#line 2484 "parse.c" + break; + case 133: +#line 495 "parse.y" +{ yygotominor.yy46 = JT_INNER; } +#line 2489 "parse.c" + break; + case 134: +#line 496 "parse.y" +{ yygotominor.yy46 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0); } +#line 2494 "parse.c" + break; + case 135: +#line 497 "parse.y" +{ yygotominor.yy46 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy410,0); } +#line 2499 "parse.c" + break; + case 136: +#line 499 "parse.y" +{ yygotominor.yy46 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy410,&yymsp[-1].minor.yy410); } +#line 2504 "parse.c" + break; + case 137: + case 145: + case 152: + case 159: + case 174: + case 202: + case 226: + case 228: +#line 503 "parse.y" +{yygotominor.yy172 = yymsp[0].minor.yy172;} +#line 2516 "parse.c" + break; + case 138: + case 151: + case 158: + case 203: + case 227: + case 229: +#line 504 "parse.y" +{yygotominor.yy172 = 0;} +#line 2526 "parse.c" + break; + case 139: + case 171: +#line 508 "parse.y" +{yygotominor.yy432 = yymsp[-1].minor.yy432;} +#line 2532 "parse.c" + break; + case 140: + case 170: +#line 509 "parse.y" +{yygotominor.yy432 = 0;} +#line 2538 "parse.c" + break; + case 142: + case 150: + case 230: +#line 520 "parse.y" +{yygotominor.yy174 = yymsp[0].minor.yy174;} +#line 2545 "parse.c" + break; + case 143: +#line 521 "parse.y" +{ + yygotominor.yy174 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy174,yymsp[-1].minor.yy172,0); + if( yygotominor.yy174 ) yygotominor.yy174->a[yygotominor.yy174->nExpr-1].sortOrder = yymsp[0].minor.yy46; +} +#line 2553 "parse.c" + break; + case 144: +#line 525 "parse.y" +{ + yygotominor.yy174 = sqlite3ExprListAppend(pParse,0,yymsp[-1].minor.yy172,0); + if( yygotominor.yy174 && yygotominor.yy174->a ) yygotominor.yy174->a[0].sortOrder = yymsp[0].minor.yy46; +} +#line 2561 "parse.c" + break; + case 146: + case 148: +#line 533 "parse.y" +{yygotominor.yy46 = SQLITE_SO_ASC;} +#line 2567 "parse.c" + break; + case 147: +#line 534 "parse.y" +{yygotominor.yy46 = SQLITE_SO_DESC;} +#line 2572 "parse.c" + break; + case 153: +#line 560 "parse.y" +{yygotominor.yy234.pLimit = 0; yygotominor.yy234.pOffset = 0;} +#line 2577 "parse.c" + break; + case 154: +#line 561 "parse.y" +{yygotominor.yy234.pLimit = yymsp[0].minor.yy172; yygotominor.yy234.pOffset = 0;} +#line 2582 "parse.c" + break; + case 155: +#line 563 "parse.y" +{yygotominor.yy234.pLimit = yymsp[-2].minor.yy172; yygotominor.yy234.pOffset = yymsp[0].minor.yy172;} +#line 2587 "parse.c" + break; + case 156: +#line 565 "parse.y" +{yygotominor.yy234.pOffset = yymsp[-2].minor.yy172; yygotominor.yy234.pLimit = yymsp[0].minor.yy172;} +#line 2592 "parse.c" + break; + case 157: +#line 569 "parse.y" +{sqlite3DeleteFrom(pParse,yymsp[-1].minor.yy373,yymsp[0].minor.yy172);} +#line 2597 "parse.c" + break; + case 160: +#line 579 "parse.y" +{ + sqlite3ExprListCheckLength(pParse,yymsp[-1].minor.yy174,SQLITE_MAX_COLUMN,"set list"); + sqlite3Update(pParse,yymsp[-3].minor.yy373,yymsp[-1].minor.yy174,yymsp[0].minor.yy172,yymsp[-4].minor.yy46); +} +#line 2605 "parse.c" + break; + case 161: +#line 588 "parse.y" +{yygotominor.yy174 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy174,yymsp[0].minor.yy172,&yymsp[-2].minor.yy410);} +#line 2610 "parse.c" + break; + case 162: +#line 590 "parse.y" +{yygotominor.yy174 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy172,&yymsp[-2].minor.yy410);} +#line 2615 "parse.c" + break; + case 163: +#line 596 "parse.y" +{sqlite3Insert(pParse, yymsp[-5].minor.yy373, yymsp[-1].minor.yy174, 0, yymsp[-4].minor.yy432, yymsp[-7].minor.yy46);} +#line 2620 "parse.c" + break; + case 164: +#line 598 "parse.y" +{sqlite3Insert(pParse, yymsp[-2].minor.yy373, 0, yymsp[0].minor.yy219, yymsp[-1].minor.yy432, yymsp[-4].minor.yy46);} +#line 2625 "parse.c" + break; + case 165: +#line 600 "parse.y" +{sqlite3Insert(pParse, yymsp[-3].minor.yy373, 0, 0, yymsp[-2].minor.yy432, yymsp[-5].minor.yy46);} +#line 2630 "parse.c" + break; + case 168: + case 232: +#line 611 "parse.y" +{yygotominor.yy174 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy174,yymsp[0].minor.yy172,0);} +#line 2636 "parse.c" + break; + case 169: + case 233: +#line 613 "parse.y" +{yygotominor.yy174 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy172,0);} +#line 2642 "parse.c" + break; + case 172: +#line 623 "parse.y" +{yygotominor.yy432 = sqlite3IdListAppend(pParse->db,yymsp[-2].minor.yy432,&yymsp[0].minor.yy410);} +#line 2647 "parse.c" + break; + case 173: +#line 625 "parse.y" +{yygotominor.yy432 = sqlite3IdListAppend(pParse->db,0,&yymsp[0].minor.yy410);} +#line 2652 "parse.c" + break; + case 175: +#line 636 "parse.y" +{yygotominor.yy172 = yymsp[-1].minor.yy172; sqlite3ExprSpan(yygotominor.yy172,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); } +#line 2657 "parse.c" + break; + case 176: + case 181: + case 182: +#line 637 "parse.y" +{yygotominor.yy172 = sqlite3PExpr(pParse, yymsp[0].major, 0, 0, &yymsp[0].minor.yy0);} +#line 2664 "parse.c" + break; + case 177: + case 178: +#line 638 "parse.y" +{yygotominor.yy172 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[0].minor.yy0);} +#line 2670 "parse.c" + break; + case 179: +#line 640 "parse.y" +{ + Expr *temp1 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-2].minor.yy410); + Expr *temp2 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[0].minor.yy410); + yygotominor.yy172 = sqlite3PExpr(pParse, TK_DOT, temp1, temp2, 0); +} +#line 2679 "parse.c" + break; + case 180: +#line 645 "parse.y" +{ + Expr *temp1 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-4].minor.yy410); + Expr *temp2 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-2].minor.yy410); + Expr *temp3 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[0].minor.yy410); + Expr *temp4 = sqlite3PExpr(pParse, TK_DOT, temp2, temp3, 0); + yygotominor.yy172 = sqlite3PExpr(pParse, TK_DOT, temp1, temp4, 0); +} +#line 2690 "parse.c" + break; + case 183: +#line 654 "parse.y" +{yygotominor.yy172 = sqlite3RegisterExpr(pParse, &yymsp[0].minor.yy0);} +#line 2695 "parse.c" + break; + case 184: +#line 655 "parse.y" +{ + Token *pToken = &yymsp[0].minor.yy0; + Expr *pExpr = yygotominor.yy172 = sqlite3PExpr(pParse, TK_VARIABLE, 0, 0, pToken); + sqlite3ExprAssignVarNumber(pParse, pExpr); +} +#line 2704 "parse.c" + break; + case 185: +#line 660 "parse.y" +{ + yygotominor.yy172 = sqlite3ExprSetColl(pParse, yymsp[-2].minor.yy172, &yymsp[0].minor.yy410); +} +#line 2711 "parse.c" + break; + case 186: +#line 664 "parse.y" +{ + yygotominor.yy172 = sqlite3PExpr(pParse, TK_CAST, yymsp[-3].minor.yy172, 0, &yymsp[-1].minor.yy410); + sqlite3ExprSpan(yygotominor.yy172,&yymsp[-5].minor.yy0,&yymsp[0].minor.yy0); +} +#line 2719 "parse.c" + break; + case 187: +#line 669 "parse.y" +{ + if( yymsp[-1].minor.yy174 && yymsp[-1].minor.yy174->nExpr>SQLITE_MAX_FUNCTION_ARG ){ + sqlite3ErrorMsg(pParse, "too many arguments on function %T", &yymsp[-4].minor.yy0); + } + yygotominor.yy172 = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy174, &yymsp[-4].minor.yy0); + sqlite3ExprSpan(yygotominor.yy172,&yymsp[-4].minor.yy0,&yymsp[0].minor.yy0); + if( yymsp[-2].minor.yy46 && yygotominor.yy172 ){ + yygotominor.yy172->flags |= EP_Distinct; + } +} +#line 2733 "parse.c" + break; + case 188: +#line 679 "parse.y" +{ + yygotominor.yy172 = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0); + sqlite3ExprSpan(yygotominor.yy172,&yymsp[-3].minor.yy0,&yymsp[0].minor.yy0); +} +#line 2741 "parse.c" + break; + case 189: +#line 683 "parse.y" +{ + /* The CURRENT_TIME, CURRENT_DATE, and CURRENT_TIMESTAMP values are + ** treated as functions that return constants */ + yygotominor.yy172 = sqlite3ExprFunction(pParse, 0,&yymsp[0].minor.yy0); + if( yygotominor.yy172 ){ + yygotominor.yy172->op = TK_CONST_FUNC; + yygotominor.yy172->span = yymsp[0].minor.yy0; + } +} +#line 2754 "parse.c" + break; + case 190: + case 191: + case 192: + case 193: + case 194: + case 195: + case 196: + case 197: +#line 692 "parse.y" +{yygotominor.yy172 = sqlite3PExpr(pParse,yymsp[-1].major,yymsp[-2].minor.yy172,yymsp[0].minor.yy172,0);} +#line 2766 "parse.c" + break; + case 198: + case 200: +#line 704 "parse.y" +{yygotominor.yy72.eOperator = yymsp[0].minor.yy0; yygotominor.yy72.notValue = 0;} +#line 2772 "parse.c" + break; + case 199: + case 201: +#line 705 "parse.y" +{yygotominor.yy72.eOperator = yymsp[0].minor.yy0; yygotominor.yy72.notValue = 1;} +#line 2778 "parse.c" + break; + case 204: +#line 712 "parse.y" +{ + ExprList *pList; + pList = sqlite3ExprListAppend(pParse,0, yymsp[-1].minor.yy172, 0); + pList = sqlite3ExprListAppend(pParse,pList, yymsp[-3].minor.yy172, 0); + if( yymsp[0].minor.yy172 ){ + pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy172, 0); + } + yygotominor.yy172 = sqlite3ExprFunction(pParse, pList, &yymsp[-2].minor.yy72.eOperator); + if( yymsp[-2].minor.yy72.notValue ) yygotominor.yy172 = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy172, 0, 0); + sqlite3ExprSpan(yygotominor.yy172, &yymsp[-3].minor.yy172->span, &yymsp[-1].minor.yy172->span); + if( yygotominor.yy172 ) yygotominor.yy172->flags |= EP_InfixFunc; +} +#line 2794 "parse.c" + break; + case 205: +#line 725 "parse.y" +{ + yygotominor.yy172 = sqlite3PExpr(pParse, yymsp[0].major, yymsp[-1].minor.yy172, 0, 0); + sqlite3ExprSpan(yygotominor.yy172,&yymsp[-1].minor.yy172->span,&yymsp[0].minor.yy0); +} +#line 2802 "parse.c" + break; + case 206: +#line 729 "parse.y" +{ + yygotominor.yy172 = sqlite3PExpr(pParse, TK_ISNULL, yymsp[-2].minor.yy172, 0, 0); + sqlite3ExprSpan(yygotominor.yy172,&yymsp[-2].minor.yy172->span,&yymsp[0].minor.yy0); +} +#line 2810 "parse.c" + break; + case 207: +#line 733 "parse.y" +{ + yygotominor.yy172 = sqlite3PExpr(pParse, TK_NOTNULL, yymsp[-2].minor.yy172, 0, 0); + sqlite3ExprSpan(yygotominor.yy172,&yymsp[-2].minor.yy172->span,&yymsp[0].minor.yy0); +} +#line 2818 "parse.c" + break; + case 208: +#line 737 "parse.y" +{ + yygotominor.yy172 = sqlite3PExpr(pParse, TK_NOTNULL, yymsp[-3].minor.yy172, 0, 0); + sqlite3ExprSpan(yygotominor.yy172,&yymsp[-3].minor.yy172->span,&yymsp[0].minor.yy0); +} +#line 2826 "parse.c" + break; + case 209: + case 210: +#line 741 "parse.y" +{ + yygotominor.yy172 = sqlite3PExpr(pParse, yymsp[-1].major, yymsp[0].minor.yy172, 0, 0); + sqlite3ExprSpan(yygotominor.yy172,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy172->span); +} +#line 2835 "parse.c" + break; + case 211: +#line 749 "parse.y" +{ + yygotominor.yy172 = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy172, 0, 0); + sqlite3ExprSpan(yygotominor.yy172,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy172->span); +} +#line 2843 "parse.c" + break; + case 212: +#line 753 "parse.y" +{ + yygotominor.yy172 = sqlite3PExpr(pParse, TK_UPLUS, yymsp[0].minor.yy172, 0, 0); + sqlite3ExprSpan(yygotominor.yy172,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy172->span); +} +#line 2851 "parse.c" + break; + case 215: +#line 760 "parse.y" +{ + ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy172, 0); + pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy172, 0); + yygotominor.yy172 = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy172, 0, 0); + if( yygotominor.yy172 ){ + yygotominor.yy172->pList = pList; + }else{ + sqlite3ExprListDelete(pList); + } + if( yymsp[-3].minor.yy46 ) yygotominor.yy172 = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy172, 0, 0); + sqlite3ExprSpan(yygotominor.yy172,&yymsp[-4].minor.yy172->span,&yymsp[0].minor.yy172->span); +} +#line 2867 "parse.c" + break; + case 218: +#line 776 "parse.y" +{ + yygotominor.yy172 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy172, 0, 0); + if( yygotominor.yy172 ){ + yygotominor.yy172->pList = yymsp[-1].minor.yy174; + sqlite3ExprSetHeight(yygotominor.yy172); + }else{ + sqlite3ExprListDelete(yymsp[-1].minor.yy174); + } + if( yymsp[-3].minor.yy46 ) yygotominor.yy172 = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy172, 0, 0); + sqlite3ExprSpan(yygotominor.yy172,&yymsp[-4].minor.yy172->span,&yymsp[0].minor.yy0); + } +#line 2882 "parse.c" + break; + case 219: +#line 787 "parse.y" +{ + yygotominor.yy172 = sqlite3PExpr(pParse, TK_SELECT, 0, 0, 0); + if( yygotominor.yy172 ){ + yygotominor.yy172->pSelect = yymsp[-1].minor.yy219; + sqlite3ExprSetHeight(yygotominor.yy172); + }else{ + sqlite3SelectDelete(yymsp[-1].minor.yy219); + } + sqlite3ExprSpan(yygotominor.yy172,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); + } +#line 2896 "parse.c" + break; + case 220: +#line 797 "parse.y" +{ + yygotominor.yy172 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy172, 0, 0); + if( yygotominor.yy172 ){ + yygotominor.yy172->pSelect = yymsp[-1].minor.yy219; + sqlite3ExprSetHeight(yygotominor.yy172); + }else{ + sqlite3SelectDelete(yymsp[-1].minor.yy219); + } + if( yymsp[-3].minor.yy46 ) yygotominor.yy172 = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy172, 0, 0); + sqlite3ExprSpan(yygotominor.yy172,&yymsp[-4].minor.yy172->span,&yymsp[0].minor.yy0); + } +#line 2911 "parse.c" + break; + case 221: +#line 808 "parse.y" +{ + SrcList *pSrc = sqlite3SrcListAppend(pParse->db, 0,&yymsp[-1].minor.yy410,&yymsp[0].minor.yy410); + yygotominor.yy172 = sqlite3PExpr(pParse, TK_IN, yymsp[-3].minor.yy172, 0, 0); + if( yygotominor.yy172 ){ + yygotominor.yy172->pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0,0); + sqlite3ExprSetHeight(yygotominor.yy172); + }else{ + sqlite3SrcListDelete(pSrc); + } + if( yymsp[-2].minor.yy46 ) yygotominor.yy172 = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy172, 0, 0); + sqlite3ExprSpan(yygotominor.yy172,&yymsp[-3].minor.yy172->span,yymsp[0].minor.yy410.z?&yymsp[0].minor.yy410:&yymsp[-1].minor.yy410); + } +#line 2927 "parse.c" + break; + case 222: +#line 820 "parse.y" +{ + Expr *p = yygotominor.yy172 = sqlite3PExpr(pParse, TK_EXISTS, 0, 0, 0); + if( p ){ + p->pSelect = yymsp[-1].minor.yy219; + sqlite3ExprSpan(p,&yymsp[-3].minor.yy0,&yymsp[0].minor.yy0); + sqlite3ExprSetHeight(yygotominor.yy172); + }else{ + sqlite3SelectDelete(yymsp[-1].minor.yy219); + } + } +#line 2941 "parse.c" + break; + case 223: +#line 833 "parse.y" +{ + yygotominor.yy172 = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy172, yymsp[-1].minor.yy172, 0); + if( yygotominor.yy172 ){ + yygotominor.yy172->pList = yymsp[-2].minor.yy174; + sqlite3ExprSetHeight(yygotominor.yy172); + }else{ + sqlite3ExprListDelete(yymsp[-2].minor.yy174); + } + sqlite3ExprSpan(yygotominor.yy172, &yymsp[-4].minor.yy0, &yymsp[0].minor.yy0); +} +#line 2955 "parse.c" + break; + case 224: +#line 845 "parse.y" +{ + yygotominor.yy174 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy174, yymsp[-2].minor.yy172, 0); + yygotominor.yy174 = sqlite3ExprListAppend(pParse,yygotominor.yy174, yymsp[0].minor.yy172, 0); +} +#line 2963 "parse.c" + break; + case 225: +#line 849 "parse.y" +{ + yygotominor.yy174 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy172, 0); + yygotominor.yy174 = sqlite3ExprListAppend(pParse,yygotominor.yy174, yymsp[0].minor.yy172, 0); +} +#line 2971 "parse.c" + break; + case 234: +#line 878 "parse.y" +{ + sqlite3CreateIndex(pParse, &yymsp[-6].minor.yy410, &yymsp[-5].minor.yy410, + sqlite3SrcListAppend(pParse->db,0,&yymsp[-3].minor.yy410,0), yymsp[-1].minor.yy174, yymsp[-9].minor.yy46, + &yymsp[-10].minor.yy0, &yymsp[0].minor.yy0, SQLITE_SO_ASC, yymsp[-7].minor.yy46); +} +#line 2980 "parse.c" + break; + case 235: + case 282: +#line 885 "parse.y" +{yygotominor.yy46 = OE_Abort;} +#line 2986 "parse.c" + break; + case 236: +#line 886 "parse.y" +{yygotominor.yy46 = OE_None;} +#line 2991 "parse.c" + break; + case 239: +#line 896 "parse.y" +{ + Expr *p = 0; + if( yymsp[-1].minor.yy410.n>0 ){ + p = sqlite3PExpr(pParse, TK_COLUMN, 0, 0, 0); + sqlite3ExprSetColl(pParse, p, &yymsp[-1].minor.yy410); + } + yygotominor.yy174 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy174, p, &yymsp[-2].minor.yy410); + sqlite3ExprListCheckLength(pParse, yygotominor.yy174, SQLITE_MAX_COLUMN, "index"); + if( yygotominor.yy174 ) yygotominor.yy174->a[yygotominor.yy174->nExpr-1].sortOrder = yymsp[0].minor.yy46; +} +#line 3005 "parse.c" + break; + case 240: +#line 906 "parse.y" +{ + Expr *p = 0; + if( yymsp[-1].minor.yy410.n>0 ){ + p = sqlite3PExpr(pParse, TK_COLUMN, 0, 0, 0); + sqlite3ExprSetColl(pParse, p, &yymsp[-1].minor.yy410); + } + yygotominor.yy174 = sqlite3ExprListAppend(pParse,0, p, &yymsp[-2].minor.yy410); + sqlite3ExprListCheckLength(pParse, yygotominor.yy174, SQLITE_MAX_COLUMN, "index"); + if( yygotominor.yy174 ) yygotominor.yy174->a[yygotominor.yy174->nExpr-1].sortOrder = yymsp[0].minor.yy46; +} +#line 3019 "parse.c" + break; + case 242: +#line 919 "parse.y" +{yygotominor.yy410.z = 0; yygotominor.yy410.n = 0;} +#line 3024 "parse.c" + break; + case 244: +#line 925 "parse.y" +{sqlite3DropIndex(pParse, yymsp[0].minor.yy373, yymsp[-1].minor.yy46);} +#line 3029 "parse.c" + break; + case 245: + case 246: +#line 931 "parse.y" +{sqlite3Vacuum(pParse);} +#line 3035 "parse.c" + break; + case 247: +#line 939 "parse.y" +{sqlite3Pragma(pParse,&yymsp[-3].minor.yy410,&yymsp[-2].minor.yy410,&yymsp[0].minor.yy410,0);} +#line 3040 "parse.c" + break; + case 248: +#line 940 "parse.y" +{sqlite3Pragma(pParse,&yymsp[-3].minor.yy410,&yymsp[-2].minor.yy410,&yymsp[0].minor.yy0,0);} +#line 3045 "parse.c" + break; + case 249: +#line 941 "parse.y" +{ + sqlite3Pragma(pParse,&yymsp[-3].minor.yy410,&yymsp[-2].minor.yy410,&yymsp[0].minor.yy410,1); +} +#line 3052 "parse.c" + break; + case 250: +#line 944 "parse.y" +{sqlite3Pragma(pParse,&yymsp[-4].minor.yy410,&yymsp[-3].minor.yy410,&yymsp[-1].minor.yy410,0);} +#line 3057 "parse.c" + break; + case 251: +#line 945 "parse.y" +{sqlite3Pragma(pParse,&yymsp[-1].minor.yy410,&yymsp[0].minor.yy410,0,0);} +#line 3062 "parse.c" + break; + case 259: +#line 959 "parse.y" +{ + Token all; + all.z = yymsp[-3].minor.yy410.z; + all.n = (yymsp[0].minor.yy0.z - yymsp[-3].minor.yy410.z) + yymsp[0].minor.yy0.n; + sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy243, &all); +} +#line 3072 "parse.c" + break; + case 260: +#line 968 "parse.y" +{ + sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy410, &yymsp[-6].minor.yy410, yymsp[-5].minor.yy46, yymsp[-4].minor.yy370.a, yymsp[-4].minor.yy370.b, yymsp[-2].minor.yy373, yymsp[0].minor.yy172, yymsp[-10].minor.yy46, yymsp[-8].minor.yy46); + yygotominor.yy410 = (yymsp[-6].minor.yy410.n==0?yymsp[-7].minor.yy410:yymsp[-6].minor.yy410); +} +#line 3080 "parse.c" + break; + case 261: + case 264: +#line 974 "parse.y" +{ yygotominor.yy46 = TK_BEFORE; } +#line 3086 "parse.c" + break; + case 262: +#line 975 "parse.y" +{ yygotominor.yy46 = TK_AFTER; } +#line 3091 "parse.c" + break; + case 263: +#line 976 "parse.y" +{ yygotominor.yy46 = TK_INSTEAD;} +#line 3096 "parse.c" + break; + case 265: + case 266: +#line 981 "parse.y" +{yygotominor.yy370.a = yymsp[0].major; yygotominor.yy370.b = 0;} +#line 3102 "parse.c" + break; + case 267: +#line 983 "parse.y" +{yygotominor.yy370.a = TK_UPDATE; yygotominor.yy370.b = yymsp[0].minor.yy432;} +#line 3107 "parse.c" + break; + case 270: +#line 990 "parse.y" +{ yygotominor.yy172 = 0; } +#line 3112 "parse.c" + break; + case 271: +#line 991 "parse.y" +{ yygotominor.yy172 = yymsp[0].minor.yy172; } +#line 3117 "parse.c" + break; + case 272: +#line 995 "parse.y" +{ + if( yymsp[-2].minor.yy243 ){ + yymsp[-2].minor.yy243->pLast->pNext = yymsp[-1].minor.yy243; + }else{ + yymsp[-2].minor.yy243 = yymsp[-1].minor.yy243; + } + yymsp[-2].minor.yy243->pLast = yymsp[-1].minor.yy243; + yygotominor.yy243 = yymsp[-2].minor.yy243; +} +#line 3130 "parse.c" + break; + case 273: +#line 1004 "parse.y" +{ yygotominor.yy243 = 0; } +#line 3135 "parse.c" + break; + case 274: +#line 1010 "parse.y" +{ yygotominor.yy243 = sqlite3TriggerUpdateStep(pParse->db, &yymsp[-3].minor.yy410, yymsp[-1].minor.yy174, yymsp[0].minor.yy172, yymsp[-4].minor.yy46); } +#line 3140 "parse.c" + break; + case 275: +#line 1015 "parse.y" +{yygotominor.yy243 = sqlite3TriggerInsertStep(pParse->db, &yymsp[-5].minor.yy410, yymsp[-4].minor.yy432, yymsp[-1].minor.yy174, 0, yymsp[-7].minor.yy46);} +#line 3145 "parse.c" + break; + case 276: +#line 1018 "parse.y" +{yygotominor.yy243 = sqlite3TriggerInsertStep(pParse->db, &yymsp[-2].minor.yy410, yymsp[-1].minor.yy432, 0, yymsp[0].minor.yy219, yymsp[-4].minor.yy46);} +#line 3150 "parse.c" + break; + case 277: +#line 1022 "parse.y" +{yygotominor.yy243 = sqlite3TriggerDeleteStep(pParse->db, &yymsp[-1].minor.yy410, yymsp[0].minor.yy172);} +#line 3155 "parse.c" + break; + case 278: +#line 1025 "parse.y" +{yygotominor.yy243 = sqlite3TriggerSelectStep(pParse->db, yymsp[0].minor.yy219); } +#line 3160 "parse.c" + break; + case 279: +#line 1028 "parse.y" +{ + yygotominor.yy172 = sqlite3PExpr(pParse, TK_RAISE, 0, 0, 0); + if( yygotominor.yy172 ){ + yygotominor.yy172->iColumn = OE_Ignore; + sqlite3ExprSpan(yygotominor.yy172, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0); + } +} +#line 3171 "parse.c" + break; + case 280: +#line 1035 "parse.y" +{ + yygotominor.yy172 = sqlite3PExpr(pParse, TK_RAISE, 0, 0, &yymsp[-1].minor.yy410); + if( yygotominor.yy172 ) { + yygotominor.yy172->iColumn = yymsp[-3].minor.yy46; + sqlite3ExprSpan(yygotominor.yy172, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0); + } +} +#line 3182 "parse.c" + break; + case 281: +#line 1045 "parse.y" +{yygotominor.yy46 = OE_Rollback;} +#line 3187 "parse.c" + break; + case 283: +#line 1047 "parse.y" +{yygotominor.yy46 = OE_Fail;} +#line 3192 "parse.c" + break; + case 284: +#line 1052 "parse.y" +{ + sqlite3DropTrigger(pParse,yymsp[0].minor.yy373,yymsp[-1].minor.yy46); +} +#line 3199 "parse.c" + break; + case 285: +#line 1059 "parse.y" +{ + sqlite3Attach(pParse, yymsp[-3].minor.yy172, yymsp[-1].minor.yy172, yymsp[0].minor.yy386); +} +#line 3206 "parse.c" + break; + case 286: +#line 1062 "parse.y" +{ + sqlite3Detach(pParse, yymsp[0].minor.yy172); +} +#line 3213 "parse.c" + break; + case 287: +#line 1068 "parse.y" +{ yygotominor.yy386 = 0; } +#line 3218 "parse.c" + break; + case 288: +#line 1069 "parse.y" +{ yygotominor.yy386 = yymsp[0].minor.yy172; } +#line 3223 "parse.c" + break; + case 291: +#line 1077 "parse.y" +{sqlite3Reindex(pParse, 0, 0);} +#line 3228 "parse.c" + break; + case 292: +#line 1078 "parse.y" +{sqlite3Reindex(pParse, &yymsp[-1].minor.yy410, &yymsp[0].minor.yy410);} +#line 3233 "parse.c" + break; + case 293: +#line 1083 "parse.y" +{sqlite3Analyze(pParse, 0, 0);} +#line 3238 "parse.c" + break; + case 294: +#line 1084 "parse.y" +{sqlite3Analyze(pParse, &yymsp[-1].minor.yy410, &yymsp[0].minor.yy410);} +#line 3243 "parse.c" + break; + case 295: +#line 1089 "parse.y" +{ + sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy373,&yymsp[0].minor.yy410); +} +#line 3250 "parse.c" + break; + case 296: +#line 1092 "parse.y" +{ + sqlite3AlterFinishAddColumn(pParse, &yymsp[0].minor.yy410); +} +#line 3257 "parse.c" + break; + case 297: +#line 1095 "parse.y" +{ + sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy373); +} +#line 3264 "parse.c" + break; + case 300: +#line 1104 "parse.y" +{sqlite3VtabFinishParse(pParse,0);} +#line 3269 "parse.c" + break; + case 301: +#line 1105 "parse.y" +{sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);} +#line 3274 "parse.c" + break; + case 302: +#line 1106 "parse.y" +{ + sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy410, &yymsp[-2].minor.yy410, &yymsp[0].minor.yy410); +} +#line 3281 "parse.c" + break; + case 305: +#line 1111 "parse.y" +{sqlite3VtabArgInit(pParse);} +#line 3286 "parse.c" + break; + case 307: + case 308: + case 309: + case 311: +#line 1113 "parse.y" +{sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);} +#line 3294 "parse.c" + break; + }; + yygoto = yyRuleInfo[yyruleno].lhs; + yysize = yyRuleInfo[yyruleno].nrhs; + yypParser->yyidx -= yysize; + yyact = yy_find_reduce_action(yymsp[-yysize].stateno,yygoto); + if( yyact < YYNSTATE ){ +#ifdef NDEBUG + /* If we are not debugging and the reduce action popped at least + ** one element off the stack, then we can push the new element back + ** onto the stack here, and skip the stack overflow test in yy_shift(). + ** That gives a significant speed improvement. */ + if( yysize ){ + yypParser->yyidx++; + yymsp -= yysize-1; + yymsp->stateno = yyact; + yymsp->major = yygoto; + yymsp->minor = yygotominor; + }else +#endif + { + yy_shift(yypParser,yyact,yygoto,&yygotominor); + } + }else if( yyact == YYNSTATE + YYNRULE + 1 ){ + yy_accept(yypParser); + } +} + +/* +** The following code executes when the parse fails +*/ +static void yy_parse_failed( + yyParser *yypParser /* The parser */ +){ + sqlite3ParserARG_FETCH; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt); + } +#endif + while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser); + /* Here code is inserted which will be executed whenever the + ** parser fails */ + sqlite3ParserARG_STORE; /* Suppress warning about unused %extra_argument variable */ +} + +/* +** The following code executes when a syntax error first occurs. +*/ +static void yy_syntax_error( + yyParser *yypParser, /* The parser */ + int yymajor, /* The major type of the error token */ + YYMINORTYPE yyminor /* The minor type of the error token */ +){ + sqlite3ParserARG_FETCH; +#define TOKEN (yyminor.yy0) +#line 34 "parse.y" + + if( !pParse->parseError ){ + if( TOKEN.z[0] ){ + sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &TOKEN); + }else{ + sqlite3ErrorMsg(pParse, "incomplete SQL statement"); + } + pParse->parseError = 1; + } +#line 3362 "parse.c" + sqlite3ParserARG_STORE; /* Suppress warning about unused %extra_argument variable */ +} + +/* +** The following is executed when the parser accepts +*/ +static void yy_accept( + yyParser *yypParser /* The parser */ +){ + sqlite3ParserARG_FETCH; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt); + } +#endif + while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser); + /* Here code is inserted which will be executed whenever the + ** parser accepts */ + sqlite3ParserARG_STORE; /* Suppress warning about unused %extra_argument variable */ +} + +/* The main parser program. +** The first argument is a pointer to a structure obtained from +** "sqlite3ParserAlloc" which describes the current state of the parser. +** The second argument is the major token number. The third is +** the minor token. The fourth optional argument is whatever the +** user wants (and specified in the grammar) and is available for +** use by the action routines. +** +** Inputs: +**
    +**
  • A pointer to the parser (an opaque structure.) +**
  • The major token number. +**
  • The minor token number. +**
  • An option argument of a grammar-specified type. +**
+** +** Outputs: +** None. +*/ +void sqlite3Parser( + void *yyp, /* The parser */ + int yymajor, /* The major token code number */ + sqlite3ParserTOKENTYPE yyminor /* The value for the token */ + sqlite3ParserARG_PDECL /* Optional %extra_argument parameter */ +){ + YYMINORTYPE yyminorunion; + int yyact; /* The parser action. */ + int yyendofinput; /* True if we are at the end of input */ + int yyerrorhit = 0; /* True if yymajor has invoked an error */ + yyParser *yypParser; /* The parser */ + + /* (re)initialize the parser, if necessary */ + yypParser = (yyParser*)yyp; + if( yypParser->yyidx<0 ){ +#if YYSTACKDEPTH<=0 + if( yypParser->yystksz <=0 ){ + memset(&yyminorunion, 0, sizeof(yyminorunion)); + yyStackOverflow(yypParser, &yyminorunion); + return; + } +#endif + yypParser->yyidx = 0; + yypParser->yyerrcnt = -1; + yypParser->yystack[0].stateno = 0; + yypParser->yystack[0].major = 0; + } + yyminorunion.yy0 = yyminor; + yyendofinput = (yymajor==0); + sqlite3ParserARG_STORE; + +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sInput %s\n",yyTracePrompt,yyTokenName[yymajor]); + } +#endif + + do{ + yyact = yy_find_shift_action(yypParser,yymajor); + if( yyactyyerrcnt--; + if( yyendofinput && yypParser->yyidx>=0 ){ + yymajor = 0; + }else{ + yymajor = YYNOCODE; + } + }else if( yyact < YYNSTATE + YYNRULE ){ + yy_reduce(yypParser,yyact-YYNSTATE); + }else if( yyact == YY_ERROR_ACTION ){ + int yymx; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sSyntax Error!\n",yyTracePrompt); + } +#endif +#ifdef YYERRORSYMBOL + /* A syntax error has occurred. + ** The response to an error depends upon whether or not the + ** grammar defines an error token "ERROR". + ** + ** This is what we do if the grammar does define ERROR: + ** + ** * Call the %syntax_error function. + ** + ** * Begin popping the stack until we enter a state where + ** it is legal to shift the error symbol, then shift + ** the error symbol. + ** + ** * Set the error count to three. + ** + ** * Begin accepting and shifting new tokens. No new error + ** processing will occur until three tokens have been + ** shifted successfully. + ** + */ + if( yypParser->yyerrcnt<0 ){ + yy_syntax_error(yypParser,yymajor,yyminorunion); + } + yymx = yypParser->yystack[yypParser->yyidx].major; + if( yymx==YYERRORSYMBOL || yyerrorhit ){ +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sDiscard input token %s\n", + yyTracePrompt,yyTokenName[yymajor]); + } +#endif + yy_destructor(yymajor,&yyminorunion); + yymajor = YYNOCODE; + }else{ + while( + yypParser->yyidx >= 0 && + yymx != YYERRORSYMBOL && + (yyact = yy_find_reduce_action( + yypParser->yystack[yypParser->yyidx].stateno, + YYERRORSYMBOL)) >= YYNSTATE + ){ + yy_pop_parser_stack(yypParser); + } + if( yypParser->yyidx < 0 || yymajor==0 ){ + yy_destructor(yymajor,&yyminorunion); + yy_parse_failed(yypParser); + yymajor = YYNOCODE; + }else if( yymx!=YYERRORSYMBOL ){ + YYMINORTYPE u2; + u2.YYERRSYMDT = 0; + yy_shift(yypParser,yyact,YYERRORSYMBOL,&u2); + } + } + yypParser->yyerrcnt = 3; + yyerrorhit = 1; +#else /* YYERRORSYMBOL is not defined */ + /* This is what we do if the grammar does not define ERROR: + ** + ** * Report an error message, and throw away the input token. + ** + ** * If the input token is $, then fail the parse. + ** + ** As before, subsequent error messages are suppressed until + ** three input tokens have been successfully shifted. + */ + if( yypParser->yyerrcnt<=0 ){ + yy_syntax_error(yypParser,yymajor,yyminorunion); + } + yypParser->yyerrcnt = 3; + yy_destructor(yymajor,&yyminorunion); + if( yyendofinput ){ + yy_parse_failed(yypParser); + } + yymajor = YYNOCODE; +#endif + }else{ + yy_accept(yypParser); + yymajor = YYNOCODE; + } + }while( yymajor!=YYNOCODE && yypParser->yyidx>=0 ); + return; +} diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/parse.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/parse.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,152 @@ +#define TK_SEMI 1 +#define TK_EXPLAIN 2 +#define TK_QUERY 3 +#define TK_PLAN 4 +#define TK_BEGIN 5 +#define TK_TRANSACTION 6 +#define TK_DEFERRED 7 +#define TK_IMMEDIATE 8 +#define TK_EXCLUSIVE 9 +#define TK_COMMIT 10 +#define TK_END 11 +#define TK_ROLLBACK 12 +#define TK_CREATE 13 +#define TK_TABLE 14 +#define TK_IF 15 +#define TK_NOT 16 +#define TK_EXISTS 17 +#define TK_TEMP 18 +#define TK_LP 19 +#define TK_RP 20 +#define TK_AS 21 +#define TK_COMMA 22 +#define TK_ID 23 +#define TK_ABORT 24 +#define TK_AFTER 25 +#define TK_ANALYZE 26 +#define TK_ASC 27 +#define TK_ATTACH 28 +#define TK_BEFORE 29 +#define TK_CASCADE 30 +#define TK_CAST 31 +#define TK_CONFLICT 32 +#define TK_DATABASE 33 +#define TK_DESC 34 +#define TK_DETACH 35 +#define TK_EACH 36 +#define TK_FAIL 37 +#define TK_FOR 38 +#define TK_IGNORE 39 +#define TK_INITIALLY 40 +#define TK_INSTEAD 41 +#define TK_LIKE_KW 42 +#define TK_MATCH 43 +#define TK_KEY 44 +#define TK_OF 45 +#define TK_OFFSET 46 +#define TK_PRAGMA 47 +#define TK_RAISE 48 +#define TK_REPLACE 49 +#define TK_RESTRICT 50 +#define TK_ROW 51 +#define TK_TRIGGER 52 +#define TK_VACUUM 53 +#define TK_VIEW 54 +#define TK_VIRTUAL 55 +#define TK_REINDEX 56 +#define TK_RENAME 57 +#define TK_CTIME_KW 58 +#define TK_ANY 59 +#define TK_OR 60 +#define TK_AND 61 +#define TK_IS 62 +#define TK_BETWEEN 63 +#define TK_IN 64 +#define TK_ISNULL 65 +#define TK_NOTNULL 66 +#define TK_NE 67 +#define TK_EQ 68 +#define TK_GT 69 +#define TK_LE 70 +#define TK_LT 71 +#define TK_GE 72 +#define TK_ESCAPE 73 +#define TK_BITAND 74 +#define TK_BITOR 75 +#define TK_LSHIFT 76 +#define TK_RSHIFT 77 +#define TK_PLUS 78 +#define TK_MINUS 79 +#define TK_STAR 80 +#define TK_SLASH 81 +#define TK_REM 82 +#define TK_CONCAT 83 +#define TK_COLLATE 84 +#define TK_UMINUS 85 +#define TK_UPLUS 86 +#define TK_BITNOT 87 +#define TK_STRING 88 +#define TK_JOIN_KW 89 +#define TK_CONSTRAINT 90 +#define TK_DEFAULT 91 +#define TK_NULL 92 +#define TK_PRIMARY 93 +#define TK_UNIQUE 94 +#define TK_CHECK 95 +#define TK_REFERENCES 96 +#define TK_AUTOINCR 97 +#define TK_ON 98 +#define TK_DELETE 99 +#define TK_UPDATE 100 +#define TK_INSERT 101 +#define TK_SET 102 +#define TK_DEFERRABLE 103 +#define TK_FOREIGN 104 +#define TK_DROP 105 +#define TK_UNION 106 +#define TK_ALL 107 +#define TK_EXCEPT 108 +#define TK_INTERSECT 109 +#define TK_SELECT 110 +#define TK_DISTINCT 111 +#define TK_DOT 112 +#define TK_FROM 113 +#define TK_JOIN 114 +#define TK_USING 115 +#define TK_ORDER 116 +#define TK_BY 117 +#define TK_GROUP 118 +#define TK_HAVING 119 +#define TK_LIMIT 120 +#define TK_WHERE 121 +#define TK_INTO 122 +#define TK_VALUES 123 +#define TK_INTEGER 124 +#define TK_FLOAT 125 +#define TK_BLOB 126 +#define TK_REGISTER 127 +#define TK_VARIABLE 128 +#define TK_CASE 129 +#define TK_WHEN 130 +#define TK_THEN 131 +#define TK_ELSE 132 +#define TK_INDEX 133 +#define TK_ALTER 134 +#define TK_TO 135 +#define TK_ADD 136 +#define TK_COLUMNKW 137 +#define TK_TO_TEXT 138 +#define TK_TO_BLOB 139 +#define TK_TO_NUMERIC 140 +#define TK_TO_INT 141 +#define TK_TO_REAL 142 +#define TK_END_OF_FILE 143 +#define TK_ILLEGAL 144 +#define TK_SPACE 145 +#define TK_UNCLOSED_STRING 146 +#define TK_COMMENT 147 +#define TK_FUNCTION 148 +#define TK_COLUMN 149 +#define TK_AGG_FUNCTION 150 +#define TK_AGG_COLUMN 151 +#define TK_CONST_FUNC 152 diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/pragma.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/pragma.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,1194 @@ +/* +** 2003 April 6 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code used to implement the PRAGMA command. +** +** $Id: pragma.cpp 1282 2008-11-13 09:31:33Z LarsPson $ +*/ +#include "sqliteInt.h" +#include + +/* Ignore this whole file if pragmas are disabled +*/ +#if !defined(SQLITE_OMIT_PRAGMA) && !defined(SQLITE_OMIT_PARSER) + +/* +** Interpret the given string as a safety level. Return 0 for OFF, +** 1 for ON or NORMAL and 2 for FULL. Return 1 for an empty or +** unrecognized string argument. +** +** Note that the values returned are one less that the values that +** should be passed into sqlite3BtreeSetSafetyLevel(). The is done +** to support legacy SQL code. The safety level used to be boolean +** and older scripts may have used numbers 0 for OFF and 1 for ON. +*/ +static int getSafetyLevel(const char *z){ + /* 123456789 123456789 */ + static const char zText[] = "onoffalseyestruefull"; + static const u8 iOffset[] = {0, 1, 2, 4, 9, 12, 16}; + static const u8 iLength[] = {2, 2, 3, 5, 3, 4, 4}; + static const u8 iValue[] = {1, 0, 0, 0, 1, 1, 2}; + int i, n; + if( isdigit(*z) ){ + return atoi(z); + } + n = strlen(z); + for(i=0; i=0&&i<=2)?i:0); +} +#endif /* ifndef SQLITE_OMIT_AUTOVACUUM */ + +#ifndef SQLITE_OMIT_PAGER_PRAGMAS +/* +** Interpret the given string as a temp db location. Return 1 for file +** backed temporary databases, 2 for the Red-Black tree in memory database +** and 0 to use the compile-time default. +*/ +static int getTempStore(const char *z){ + if( z[0]>='0' && z[0]<='2' ){ + return z[0] - '0'; + }else if( sqlite3StrICmp(z, "file")==0 ){ + return 1; + }else if( sqlite3StrICmp(z, "memory")==0 ){ + return 2; + }else{ + return 0; + } +} +#endif /* SQLITE_PAGER_PRAGMAS */ + +#ifndef SQLITE_OMIT_PAGER_PRAGMAS +/* +** Invalidate temp storage, either when the temp storage is changed +** from default, or when 'file' and the temp_store_directory has changed +*/ +static int invalidateTempStorage(Parse *pParse){ + sqlite3 *db = pParse->db; + if( db->aDb[1].pBt!=0 ){ + if( !db->autoCommit ){ + sqlite3ErrorMsg(pParse, "temporary storage cannot be changed " + "from within a transaction"); + return SQLITE_ERROR; + } + sqlite3BtreeClose(db->aDb[1].pBt); + db->aDb[1].pBt = 0; + sqlite3ResetInternalSchema(db, 0); + } + return SQLITE_OK; +} +#endif /* SQLITE_PAGER_PRAGMAS */ + +#ifndef SQLITE_OMIT_PAGER_PRAGMAS +/* +** If the TEMP database is open, close it and mark the database schema +** as needing reloading. This must be done when using the TEMP_STORE +** or DEFAULT_TEMP_STORE pragmas. +*/ +static int changeTempStorage(Parse *pParse, const char *zStorageType){ + int ts = getTempStore(zStorageType); + sqlite3 *db = pParse->db; + if( db->temp_store==ts ) return SQLITE_OK; + if( invalidateTempStorage( pParse ) != SQLITE_OK ){ + return SQLITE_ERROR; + } + db->temp_store = ts; + return SQLITE_OK; +} +#endif /* SQLITE_PAGER_PRAGMAS */ + +/* +** Generate code to return a single integer value. +*/ +static void returnSingleInt(Parse *pParse, const char *zLabel, int value){ + Vdbe *v = sqlite3GetVdbe(pParse); + sqlite3VdbeAddOp(v, OP_Integer, value, 0); + if( pParse->explain==0 ){ + sqlite3VdbeSetNumCols(v, 1); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLabel, P3_STATIC); + } + sqlite3VdbeAddOp(v, OP_Callback, 1, 0); +} + +#ifndef SQLITE_OMIT_FLAG_PRAGMAS +/* +** Check to see if zRight and zLeft refer to a pragma that queries +** or changes one of the flags in db->flags. Return 1 if so and 0 if not. +** Also, implement the pragma. +*/ +static int flagPragma(Parse *pParse, const char *zLeft, const char *zRight){ + static const struct sPragmaType { + const char *zName; /* Name of the pragma */ + int mask; /* Mask for the db->flags value */ + } aPragma[] = { + { "full_column_names", SQLITE_FullColNames }, + { "short_column_names", SQLITE_ShortColNames }, + { "count_changes", SQLITE_CountRows }, + { "empty_result_callbacks", SQLITE_NullCallback }, + { "legacy_file_format", SQLITE_LegacyFileFmt }, + { "fullfsync", SQLITE_FullFSync }, +#ifdef SQLITE_DEBUG + { "sql_trace", SQLITE_SqlTrace }, + { "vdbe_listing", SQLITE_VdbeListing }, + { "vdbe_trace", SQLITE_VdbeTrace }, +#endif +#ifndef SQLITE_OMIT_CHECK + { "ignore_check_constraints", SQLITE_IgnoreChecks }, +#endif + /* The following is VERY experimental */ + { "writable_schema", SQLITE_WriteSchema|SQLITE_RecoveryMode }, + { "omit_readlock", SQLITE_NoReadlock }, + + /* TODO: Maybe it shouldn't be possible to change the ReadUncommitted + ** flag if there are any active statements. */ + { "read_uncommitted", SQLITE_ReadUncommitted }, + }; + int i; + const struct sPragmaType *p; + for(i=0, p=aPragma; izName)==0 ){ + sqlite3 *db = pParse->db; + Vdbe *v; + v = sqlite3GetVdbe(pParse); + if( v ){ + if( zRight==0 ){ + returnSingleInt(pParse, p->zName, (db->flags & p->mask)!=0 ); + }else{ + if( getBoolean(zRight) ){ + db->flags |= p->mask; + }else{ + db->flags &= ~p->mask; + } + + /* Many of the flag-pragmas modify the code generated by the SQL + ** compiler (eg. count_changes). So add an opcode to expire all + ** compiled SQL statements after modifying a pragma value. + */ + sqlite3VdbeAddOp(v, OP_Expire, 0, 0); + } + } + + return 1; + } + } + return 0; +} +#endif /* SQLITE_OMIT_FLAG_PRAGMAS */ + +/* +** Process a pragma statement. +** +** Pragmas are of this form: +** +** PRAGMA [database.]id [= value] +** +** The identifier might also be a string. The value is a string, and +** identifier, or a number. If minusFlag is true, then the value is +** a number that was preceded by a minus sign. +** +** If the left side is "database.id" then pId1 is the database name +** and pId2 is the id. If the left side is just "id" then pId1 is the +** id and pId2 is any empty string. +*/ +void sqlite3Pragma( + Parse *pParse, + Token *pId1, /* First part of [database.]id field */ + Token *pId2, /* Second part of [database.]id field, or NULL */ + Token *pValue, /* Token for , or NULL */ + int minusFlag /* True if a '-' sign preceded */ +){ + char *zLeft = 0; /* Nul-terminated UTF-8 string */ + char *zRight = 0; /* Nul-terminated UTF-8 string , or NULL */ + const char *zDb = 0; /* The database name */ + Token *pId; /* Pointer to token */ + int iDb; /* Database index for */ + sqlite3 *db = pParse->db; + Db *pDb; + Vdbe *v = sqlite3GetVdbe(pParse); + if( v==0 ) return; + + /* Interpret the [database.] part of the pragma statement. iDb is the + ** index of the database this pragma is being applied to in db.aDb[]. */ + iDb = sqlite3TwoPartName(pParse, pId1, pId2, &pId); + if( iDb<0 ) return; + pDb = &db->aDb[iDb]; + + /* If the temp database has been explicitly named as part of the + ** pragma, make sure it is open. + */ + if( iDb==1 && sqlite3OpenTempDatabase(pParse) ){ + return; + } + + zLeft = sqlite3NameFromToken(db, pId); + if( !zLeft ) return; + if( minusFlag ){ + zRight = sqlite3MPrintf(db, "-%T", pValue); + }else{ + zRight = sqlite3NameFromToken(db, pValue); + } + + zDb = ((iDb>0)?pDb->zName:0); + if( sqlite3AuthCheck(pParse, SQLITE_PRAGMA, zLeft, zRight, zDb) ){ + goto pragma_out; + } + +#ifndef SQLITE_OMIT_PAGER_PRAGMAS + /* + ** PRAGMA [database.]default_cache_size + ** PRAGMA [database.]default_cache_size=N + ** + ** The first form reports the current persistent setting for the + ** page cache size. The value returned is the maximum number of + ** pages in the page cache. The second form sets both the current + ** page cache size value and the persistent page cache size value + ** stored in the database file. + ** + ** The default cache size is stored in meta-value 2 of page 1 of the + ** database file. The cache size is actually the absolute value of + ** this memory location. The sign of meta-value 2 determines the + ** synchronous setting. A negative value means synchronous is off + ** and a positive value means synchronous is on. + */ + if( sqlite3StrICmp(zLeft,"default_cache_size")==0 ){ + static const VdbeOpList getCacheSize[] = { + { OP_ReadCookie, 0, 2, 0}, /* 0 */ + { OP_AbsValue, 0, 0, 0}, + { OP_Dup, 0, 0, 0}, + { OP_Integer, 0, 0, 0}, + { OP_Ne, 0, 6, 0}, + { OP_Integer, 0, 0, 0}, /* 5 */ + { OP_Callback, 1, 0, 0}, + }; + int addr; + if( sqlite3ReadSchema(pParse) ) goto pragma_out; + sqlite3VdbeUsesBtree(v, iDb); + if( !zRight ){ + sqlite3VdbeSetNumCols(v, 1); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "cache_size", P3_STATIC); + addr = sqlite3VdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize); + sqlite3VdbeChangeP1(v, addr, iDb); + sqlite3VdbeChangeP1(v, addr+5, SQLITE_DEFAULT_CACHE_SIZE); + }else{ + int size = atoi(zRight); + if( size<0 ) size = -size; + sqlite3BeginWriteOperation(pParse, 0, iDb); + sqlite3VdbeAddOp(v, OP_Integer, size, 0); + sqlite3VdbeAddOp(v, OP_ReadCookie, iDb, 2); + addr = sqlite3VdbeAddOp(v, OP_Integer, 0, 0); + sqlite3VdbeAddOp(v, OP_Ge, 0, addr+3); + sqlite3VdbeAddOp(v, OP_Negative, 0, 0); + sqlite3VdbeAddOp(v, OP_SetCookie, iDb, 2); + pDb->pSchema->cache_size = size; + sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size); + } + }else + + /* + ** PRAGMA [database.]page_size + ** PRAGMA [database.]page_size=N + ** + ** The first form reports the current setting for the + ** database page size in bytes. The second form sets the + ** database page size value. The value can only be set if + ** the database has not yet been created. + */ + if( sqlite3StrICmp(zLeft,"page_size")==0 ){ + Btree *pBt = pDb->pBt; + if( !zRight ){ + int size = pBt ? sqlite3BtreeGetPageSize(pBt) : 0; + returnSingleInt(pParse, "page_size", size); + }else{ + /* Malloc may fail when setting the page-size, as there is an internal + ** buffer that the pager module resizes using sqlite3_realloc(). + */ + if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, atoi(zRight), -1) ){ + db->mallocFailed = 1; + } + } + }else + + /* + ** PRAGMA [database.]max_page_count + ** PRAGMA [database.]max_page_count=N + ** + ** The first form reports the current setting for the + ** maximum number of pages in the database file. The + ** second form attempts to change this setting. Both + ** forms return the current setting. + */ + if( sqlite3StrICmp(zLeft,"max_page_count")==0 ){ + Btree *pBt = pDb->pBt; + int newMax = 0; + if( zRight ){ + newMax = atoi(zRight); + } + if( pBt ){ + newMax = sqlite3BtreeMaxPageCount(pBt, newMax); + } + returnSingleInt(pParse, "max_page_count", newMax); + }else + + /* + ** PRAGMA [database.]locking_mode + ** PRAGMA [database.]locking_mode = (normal|exclusive) + */ + if( sqlite3StrICmp(zLeft,"locking_mode")==0 ){ + const char *zRet = "normal"; + int eMode = getLockingMode(zRight); + + if( pId2->n==0 && eMode==PAGER_LOCKINGMODE_QUERY ){ + /* Simple "PRAGMA locking_mode;" statement. This is a query for + ** the current default locking mode (which may be different to + ** the locking-mode of the main database). + */ + eMode = db->dfltLockMode; + }else{ + Pager *pPager; + if( pId2->n==0 ){ + /* This indicates that no database name was specified as part + ** of the PRAGMA command. In this case the locking-mode must be + ** set on all attached databases, as well as the main db file. + ** + ** Also, the sqlite3.dfltLockMode variable is set so that + ** any subsequently attached databases also use the specified + ** locking mode. + */ + int ii; + assert(pDb==&db->aDb[0]); + for(ii=2; iinDb; ii++){ + pPager = sqlite3BtreePager(db->aDb[ii].pBt); + sqlite3PagerLockingMode(pPager, eMode); + } + db->dfltLockMode = eMode; + } + pPager = sqlite3BtreePager(pDb->pBt); + eMode = sqlite3PagerLockingMode(pPager, eMode); + } + + assert(eMode==PAGER_LOCKINGMODE_NORMAL||eMode==PAGER_LOCKINGMODE_EXCLUSIVE); + if( eMode==PAGER_LOCKINGMODE_EXCLUSIVE ){ + zRet = "exclusive"; + } + sqlite3VdbeSetNumCols(v, 1); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "locking_mode", P3_STATIC); + sqlite3VdbeOp3(v, OP_String8, 0, 0, zRet, 0); + sqlite3VdbeAddOp(v, OP_Callback, 1, 0); + }else +#endif /* SQLITE_OMIT_PAGER_PRAGMAS */ + + /* + ** PRAGMA [database.]auto_vacuum + ** PRAGMA [database.]auto_vacuum=N + ** + ** Get or set the (boolean) value of the database 'auto-vacuum' parameter. + */ +#ifndef SQLITE_OMIT_AUTOVACUUM + if( sqlite3StrICmp(zLeft,"auto_vacuum")==0 ){ + Btree *pBt = pDb->pBt; + if( sqlite3ReadSchema(pParse) ){ + goto pragma_out; + } + if( !zRight ){ + int auto_vacuum = + pBt ? sqlite3BtreeGetAutoVacuum(pBt) : SQLITE_DEFAULT_AUTOVACUUM; + returnSingleInt(pParse, "auto_vacuum", auto_vacuum); + }else{ + int eAuto = getAutoVacuum(zRight); + db->nextAutovac = eAuto; + if( eAuto>=0 ){ + /* Call SetAutoVacuum() to set initialize the internal auto and + ** incr-vacuum flags. This is required in case this connection + ** creates the database file. It is important that it is created + ** as an auto-vacuum capable db. + */ + int rc = sqlite3BtreeSetAutoVacuum(pBt, eAuto); + if( rc==SQLITE_OK && (eAuto==1 || eAuto==2) ){ + /* When setting the auto_vacuum mode to either "full" or + ** "incremental", write the value of meta[6] in the database + ** file. Before writing to meta[6], check that meta[3] indicates + ** that this really is an auto-vacuum capable database. + */ + static const VdbeOpList setMeta6[] = { + { OP_Transaction, 0, 1, 0}, /* 0 */ + { OP_ReadCookie, 0, 3, 0}, /* 1 */ + { OP_If, 0, 0, 0}, /* 2 */ + { OP_Halt, SQLITE_OK, OE_Abort, 0}, /* 3 */ + { OP_Integer, 0, 0, 0}, /* 4 */ + { OP_SetCookie, 0, 6, 0}, /* 5 */ + }; + int iAddr; + iAddr = sqlite3VdbeAddOpList(v, ArraySize(setMeta6), setMeta6); + sqlite3VdbeChangeP1(v, iAddr, iDb); + sqlite3VdbeChangeP1(v, iAddr+1, iDb); + sqlite3VdbeChangeP2(v, iAddr+2, iAddr+4); + sqlite3VdbeChangeP1(v, iAddr+4, eAuto-1); + sqlite3VdbeChangeP1(v, iAddr+5, iDb); + sqlite3VdbeUsesBtree(v, iDb); + } + } + } + }else +#endif + + /* + ** PRAGMA [database.]incremental_vacuum(N) + ** + ** Do N steps of incremental vacuuming on a database. + */ +#ifndef SQLITE_OMIT_AUTOVACUUM + if( sqlite3StrICmp(zLeft,"incremental_vacuum")==0 ){ + int iLimit, addr; + if( sqlite3ReadSchema(pParse) ){ + goto pragma_out; + } + if( zRight==0 || !sqlite3GetInt32(zRight, &iLimit) || iLimit<=0 ){ + iLimit = 0x7fffffff; + } + sqlite3BeginWriteOperation(pParse, 0, iDb); + sqlite3VdbeAddOp(v, OP_MemInt, iLimit, 0); + addr = sqlite3VdbeAddOp(v, OP_IncrVacuum, iDb, 0); + sqlite3VdbeAddOp(v, OP_Callback, 0, 0); + sqlite3VdbeAddOp(v, OP_MemIncr, -1, 0); + sqlite3VdbeAddOp(v, OP_IfMemPos, 0, addr); + sqlite3VdbeJumpHere(v, addr); + }else +#endif + +#ifndef SQLITE_OMIT_PAGER_PRAGMAS + /* + ** PRAGMA [database.]cache_size + ** PRAGMA [database.]cache_size=N + ** + ** The first form reports the current local setting for the + ** page cache size. The local setting can be different from + ** the persistent cache size value that is stored in the database + ** file itself. The value returned is the maximum number of + ** pages in the page cache. The second form sets the local + ** page cache size value. It does not change the persistent + ** cache size stored on the disk so the cache size will revert + ** to its default value when the database is closed and reopened. + ** N should be a positive integer. + */ + if( sqlite3StrICmp(zLeft,"cache_size")==0 ){ + if( sqlite3ReadSchema(pParse) ) goto pragma_out; + if( !zRight ){ + returnSingleInt(pParse, "cache_size", pDb->pSchema->cache_size); + }else{ + int size = atoi(zRight); + if( size<0 ) size = -size; + pDb->pSchema->cache_size = size; + sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size); + } + }else + + /* + ** PRAGMA temp_store + ** PRAGMA temp_store = "default"|"memory"|"file" + ** + ** Return or set the local value of the temp_store flag. Changing + ** the local value does not make changes to the disk file and the default + ** value will be restored the next time the database is opened. + ** + ** Note that it is possible for the library compile-time options to + ** override this setting + */ + if( sqlite3StrICmp(zLeft, "temp_store")==0 ){ + if( !zRight ){ + returnSingleInt(pParse, "temp_store", db->temp_store); + }else{ + changeTempStorage(pParse, zRight); + } + }else + + /* + ** PRAGMA temp_store_directory + ** PRAGMA temp_store_directory = ""|"directory_name" + ** + ** Return or set the local value of the temp_store_directory flag. Changing + ** the value sets a specific directory to be used for temporary files. + ** Setting to a null string reverts to the default temporary directory search. + ** If temporary directory is changed, then invalidateTempStorage. + ** + */ + if( sqlite3StrICmp(zLeft, "temp_store_directory")==0 ){ + if( !zRight ){ + if( sqlite3_temp_directory ){ + sqlite3VdbeSetNumCols(v, 1); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, + "temp_store_directory", P3_STATIC); + sqlite3VdbeOp3(v, OP_String8, 0, 0, sqlite3_temp_directory, 0); + sqlite3VdbeAddOp(v, OP_Callback, 1, 0); + } + }else{ + if( zRight[0] + && !sqlite3OsAccess(db->pVfs, zRight, SQLITE_ACCESS_READWRITE) + ){ + sqlite3ErrorMsg(pParse, "not a writable directory"); + goto pragma_out; + } + if( TEMP_STORE==0 + || (TEMP_STORE==1 && db->temp_store<=1) + || (TEMP_STORE==2 && db->temp_store==1) + ){ + invalidateTempStorage(pParse); + } + sqlite3_free(sqlite3_temp_directory); + if( zRight[0] ){ + sqlite3_temp_directory = zRight; + zRight = 0; + }else{ + sqlite3_temp_directory = 0; + } + } + }else + + /* + ** PRAGMA [database.]synchronous + ** PRAGMA [database.]synchronous=OFF|ON|NORMAL|FULL + ** + ** Return or set the local value of the synchronous flag. Changing + ** the local value does not make changes to the disk file and the + ** default value will be restored the next time the database is + ** opened. + */ + if( sqlite3StrICmp(zLeft,"synchronous")==0 ){ + if( sqlite3ReadSchema(pParse) ) goto pragma_out; + if( !zRight ){ + returnSingleInt(pParse, "synchronous", pDb->safety_level-1); + }else{ + if( !db->autoCommit ){ + sqlite3ErrorMsg(pParse, + "Safety level may not be changed inside a transaction"); + }else{ + pDb->safety_level = getSafetyLevel(zRight)+1; + } + } + }else +#endif /* SQLITE_OMIT_PAGER_PRAGMAS */ + +#ifndef SQLITE_OMIT_FLAG_PRAGMAS + if( flagPragma(pParse, zLeft, zRight) ){ + /* The flagPragma() subroutine also generates any necessary code + ** there is nothing more to do here */ + }else +#endif /* SQLITE_OMIT_FLAG_PRAGMAS */ + +#ifndef SQLITE_OMIT_SCHEMA_PRAGMAS + /* + ** PRAGMA table_info(
) + ** + ** Return a single row for each column of the named table. The columns of + ** the returned data set are: + ** + ** cid: Column id (numbered from left to right, starting at 0) + ** name: Column name + ** type: Column declaration type. + ** notnull: True if 'NOT NULL' is part of column declaration + ** dflt_value: The default value for the column, if any. + */ + if( sqlite3StrICmp(zLeft, "table_info")==0 && zRight ){ + Table *pTab; + if( sqlite3ReadSchema(pParse) ) goto pragma_out; + pTab = sqlite3FindTable(db, zRight, zDb); + if( pTab ){ + int i; + int nHidden = 0; + Column *pCol; + sqlite3VdbeSetNumCols(v, 6); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "cid", P3_STATIC); + sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P3_STATIC); + sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "type", P3_STATIC); + sqlite3VdbeSetColName(v, 3, COLNAME_NAME, "notnull", P3_STATIC); + sqlite3VdbeSetColName(v, 4, COLNAME_NAME, "dflt_value", P3_STATIC); + sqlite3VdbeSetColName(v, 5, COLNAME_NAME, "pk", P3_STATIC); + sqlite3ViewGetColumnNames(pParse, pTab); + for(i=0, pCol=pTab->aCol; inCol; i++, pCol++){ + const Token *pDflt; + if( IsHiddenColumn(pCol) ){ + nHidden++; + continue; + } + sqlite3VdbeAddOp(v, OP_Integer, i-nHidden, 0); + sqlite3VdbeOp3(v, OP_String8, 0, 0, pCol->zName, 0); + sqlite3VdbeOp3(v, OP_String8, 0, 0, + pCol->zType ? pCol->zType : "", 0); + sqlite3VdbeAddOp(v, OP_Integer, pCol->notNull, 0); + if( pCol->pDflt && (pDflt = &pCol->pDflt->span)->z ){ + sqlite3VdbeOp3(v, OP_String8, 0, 0, (char*)pDflt->z, pDflt->n); + }else{ + sqlite3VdbeAddOp(v, OP_Null, 0, 0); + } + sqlite3VdbeAddOp(v, OP_Integer, pCol->isPrimKey, 0); + sqlite3VdbeAddOp(v, OP_Callback, 6, 0); + } + } + }else + + if( sqlite3StrICmp(zLeft, "index_info")==0 && zRight ){ + Index *pIdx; + Table *pTab; + if( sqlite3ReadSchema(pParse) ) goto pragma_out; + pIdx = sqlite3FindIndex(db, zRight, zDb); + if( pIdx ){ + int i; + pTab = pIdx->pTable; + sqlite3VdbeSetNumCols(v, 3); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seqno", P3_STATIC); + sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "cid", P3_STATIC); + sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "name", P3_STATIC); + for(i=0; inColumn; i++){ + int cnum = pIdx->aiColumn[i]; + sqlite3VdbeAddOp(v, OP_Integer, i, 0); + sqlite3VdbeAddOp(v, OP_Integer, cnum, 0); + assert( pTab->nCol>cnum ); + sqlite3VdbeOp3(v, OP_String8, 0, 0, pTab->aCol[cnum].zName, 0); + sqlite3VdbeAddOp(v, OP_Callback, 3, 0); + } + } + }else + + if( sqlite3StrICmp(zLeft, "index_list")==0 && zRight ){ + Index *pIdx; + Table *pTab; + if( sqlite3ReadSchema(pParse) ) goto pragma_out; + pTab = sqlite3FindTable(db, zRight, zDb); + if( pTab ){ + v = sqlite3GetVdbe(pParse); + pIdx = pTab->pIndex; + if( pIdx ){ + int i = 0; + sqlite3VdbeSetNumCols(v, 3); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", P3_STATIC); + sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P3_STATIC); + sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "unique", P3_STATIC); + while(pIdx){ + sqlite3VdbeAddOp(v, OP_Integer, i, 0); + sqlite3VdbeOp3(v, OP_String8, 0, 0, pIdx->zName, 0); + sqlite3VdbeAddOp(v, OP_Integer, pIdx->onError!=OE_None, 0); + sqlite3VdbeAddOp(v, OP_Callback, 3, 0); + ++i; + pIdx = pIdx->pNext; + } + } + } + }else + + if( sqlite3StrICmp(zLeft, "database_list")==0 ){ + int i; + if( sqlite3ReadSchema(pParse) ) goto pragma_out; + sqlite3VdbeSetNumCols(v, 3); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", P3_STATIC); + sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P3_STATIC); + sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "file", P3_STATIC); + for(i=0; inDb; i++){ + if( db->aDb[i].pBt==0 ) continue; + assert( db->aDb[i].zName!=0 ); + sqlite3VdbeAddOp(v, OP_Integer, i, 0); + sqlite3VdbeOp3(v, OP_String8, 0, 0, db->aDb[i].zName, 0); + sqlite3VdbeOp3(v, OP_String8, 0, 0, + sqlite3BtreeGetFilename(db->aDb[i].pBt), 0); + sqlite3VdbeAddOp(v, OP_Callback, 3, 0); + } + }else + + if( sqlite3StrICmp(zLeft, "collation_list")==0 ){ + int i = 0; + HashElem *p; + sqlite3VdbeSetNumCols(v, 2); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", P3_STATIC); + sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P3_STATIC); + for(p=sqliteHashFirst(&db->aCollSeq); p; p=sqliteHashNext(p)){ + CollSeq *pColl = (CollSeq *)sqliteHashData(p); + sqlite3VdbeAddOp(v, OP_Integer, i++, 0); + sqlite3VdbeOp3(v, OP_String8, 0, 0, pColl->zName, 0); + sqlite3VdbeAddOp(v, OP_Callback, 2, 0); + } + }else +#endif /* SQLITE_OMIT_SCHEMA_PRAGMAS */ + +#ifndef SQLITE_OMIT_FOREIGN_KEY + if( sqlite3StrICmp(zLeft, "foreign_key_list")==0 && zRight ){ + FKey *pFK; + Table *pTab; + if( sqlite3ReadSchema(pParse) ) goto pragma_out; + pTab = sqlite3FindTable(db, zRight, zDb); + if( pTab ){ + v = sqlite3GetVdbe(pParse); + pFK = pTab->pFKey; + if( pFK ){ + int i = 0; + sqlite3VdbeSetNumCols(v, 5); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "id", P3_STATIC); + sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "seq", P3_STATIC); + sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "table", P3_STATIC); + sqlite3VdbeSetColName(v, 3, COLNAME_NAME, "from", P3_STATIC); + sqlite3VdbeSetColName(v, 4, COLNAME_NAME, "to", P3_STATIC); + while(pFK){ + int j; + for(j=0; jnCol; j++){ + char *zCol = pFK->aCol[j].zCol; + sqlite3VdbeAddOp(v, OP_Integer, i, 0); + sqlite3VdbeAddOp(v, OP_Integer, j, 0); + sqlite3VdbeOp3(v, OP_String8, 0, 0, pFK->zTo, 0); + sqlite3VdbeOp3(v, OP_String8, 0, 0, + pTab->aCol[pFK->aCol[j].iFrom].zName, 0); + sqlite3VdbeOp3(v, zCol ? OP_String8 : OP_Null, 0, 0, zCol, 0); + sqlite3VdbeAddOp(v, OP_Callback, 5, 0); + } + ++i; + pFK = pFK->pNextFrom; + } + } + } + }else +#endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */ + +#ifndef NDEBUG + if( sqlite3StrICmp(zLeft, "parser_trace")==0 ){ + if( zRight ){ + if( getBoolean(zRight) ){ + sqlite3ParserTrace(stderr, "parser: "); + }else{ + sqlite3ParserTrace(0, 0); + } + } + }else +#endif + + /* Reinstall the LIKE and GLOB functions. The variant of LIKE + ** used will be case sensitive or not depending on the RHS. + */ + if( sqlite3StrICmp(zLeft, "case_sensitive_like")==0 ){ + if( zRight ){ + sqlite3RegisterLikeFunctions(db, getBoolean(zRight)); + } + }else + +#ifndef SQLITE_INTEGRITY_CHECK_ERROR_MAX +# define SQLITE_INTEGRITY_CHECK_ERROR_MAX 100 +#endif + +#ifndef SQLITE_OMIT_INTEGRITY_CHECK + if( sqlite3StrICmp(zLeft, "integrity_check")==0 ){ + int i, j, addr, mxErr; + + /* Code that appears at the end of the integrity check. If no error + ** messages have been generated, output OK. Otherwise output the + ** error message + */ + static const VdbeOpList endCode[] = { + { OP_MemLoad, 0, 0, 0}, + { OP_Integer, 0, 0, 0}, + { OP_Ne, 0, 0, 0}, /* 2 */ + { OP_String8, 0, 0, "ok"}, + { OP_Callback, 1, 0, 0}, + }; + + /* Initialize the VDBE program */ + if( sqlite3ReadSchema(pParse) ) goto pragma_out; + sqlite3VdbeSetNumCols(v, 1); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "integrity_check", P3_STATIC); + + /* Set the maximum error count */ + mxErr = SQLITE_INTEGRITY_CHECK_ERROR_MAX; + if( zRight ){ + mxErr = atoi(zRight); + if( mxErr<=0 ){ + mxErr = SQLITE_INTEGRITY_CHECK_ERROR_MAX; + } + } + sqlite3VdbeAddOp(v, OP_MemInt, mxErr, 0); + + /* Do an integrity check on each database file */ + for(i=0; inDb; i++){ + HashElem *x; + Hash *pTbls; + int cnt = 0; + + if( OMIT_TEMPDB && i==1 ) continue; + + sqlite3CodeVerifySchema(pParse, i); + addr = sqlite3VdbeAddOp(v, OP_IfMemPos, 0, 0); + sqlite3VdbeAddOp(v, OP_Halt, 0, 0); + sqlite3VdbeJumpHere(v, addr); + + /* Do an integrity check of the B-Tree + */ + pTbls = &db->aDb[i].pSchema->tblHash; + for(x=sqliteHashFirst(pTbls); x; x=sqliteHashNext(x)){ + Table *pTab = (Table*)sqliteHashData(x); + Index *pIdx; + sqlite3VdbeAddOp(v, OP_Integer, pTab->tnum, 0); + cnt++; + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + sqlite3VdbeAddOp(v, OP_Integer, pIdx->tnum, 0); + cnt++; + } + } + if( cnt==0 ) continue; + sqlite3VdbeAddOp(v, OP_IntegrityCk, 0, i); + addr = sqlite3VdbeAddOp(v, OP_IsNull, -1, 0); + sqlite3VdbeOp3(v, OP_String8, 0, 0, + sqlite3MPrintf(db, "*** in database %s ***\n", db->aDb[i].zName), + P3_DYNAMIC); + sqlite3VdbeAddOp(v, OP_Pull, 1, 0); + sqlite3VdbeAddOp(v, OP_Concat, 0, 0); + sqlite3VdbeAddOp(v, OP_Callback, 1, 0); + sqlite3VdbeJumpHere(v, addr); + + /* Make sure all the indices are constructed correctly. + */ + for(x=sqliteHashFirst(pTbls); x; x=sqliteHashNext(x)){ + Table *pTab = (Table*)sqliteHashData(x); + Index *pIdx; + int loopTop; + + if( pTab->pIndex==0 ) continue; + addr = sqlite3VdbeAddOp(v, OP_IfMemPos, 0, 0); + sqlite3VdbeAddOp(v, OP_Halt, 0, 0); + sqlite3VdbeJumpHere(v, addr); + sqlite3OpenTableAndIndices(pParse, pTab, 1, OP_OpenRead); + sqlite3VdbeAddOp(v, OP_MemInt, 0, 1); + loopTop = sqlite3VdbeAddOp(v, OP_Rewind, 1, 0); + sqlite3VdbeAddOp(v, OP_MemIncr, 1, 1); + for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){ + int jmp2; + static const VdbeOpList idxErr[] = { + { OP_MemIncr, -1, 0, 0}, + { OP_String8, 0, 0, "rowid "}, + { OP_Rowid, 1, 0, 0}, + { OP_String8, 0, 0, " missing from index "}, + { OP_String8, 0, 0, 0}, /* 4 */ + { OP_Concat, 2, 0, 0}, + { OP_Callback, 1, 0, 0}, + }; + sqlite3GenerateIndexKey(v, pIdx, 1); + jmp2 = sqlite3VdbeAddOp(v, OP_Found, j+2, 0); + addr = sqlite3VdbeAddOpList(v, ArraySize(idxErr), idxErr); + sqlite3VdbeChangeP3(v, addr+4, pIdx->zName, P3_STATIC); + sqlite3VdbeJumpHere(v, jmp2); + } + sqlite3VdbeAddOp(v, OP_Next, 1, loopTop+1); + sqlite3VdbeJumpHere(v, loopTop); + for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){ + static const VdbeOpList cntIdx[] = { + { OP_MemInt, 0, 2, 0}, + { OP_Rewind, 0, 0, 0}, /* 1 */ + { OP_MemIncr, 1, 2, 0}, + { OP_Next, 0, 0, 0}, /* 3 */ + { OP_MemLoad, 1, 0, 0}, + { OP_MemLoad, 2, 0, 0}, + { OP_Eq, 0, 0, 0}, /* 6 */ + { OP_MemIncr, -1, 0, 0}, + { OP_String8, 0, 0, "wrong # of entries in index "}, + { OP_String8, 0, 0, 0}, /* 9 */ + { OP_Concat, 0, 0, 0}, + { OP_Callback, 1, 0, 0}, + }; + if( pIdx->tnum==0 ) continue; + addr = sqlite3VdbeAddOp(v, OP_IfMemPos, 0, 0); + sqlite3VdbeAddOp(v, OP_Halt, 0, 0); + sqlite3VdbeJumpHere(v, addr); + addr = sqlite3VdbeAddOpList(v, ArraySize(cntIdx), cntIdx); + sqlite3VdbeChangeP1(v, addr+1, j+2); + sqlite3VdbeChangeP2(v, addr+1, addr+4); + sqlite3VdbeChangeP1(v, addr+3, j+2); + sqlite3VdbeChangeP2(v, addr+3, addr+2); + sqlite3VdbeJumpHere(v, addr+6); + sqlite3VdbeChangeP3(v, addr+9, pIdx->zName, P3_STATIC); + } + } + } + addr = sqlite3VdbeAddOpList(v, ArraySize(endCode), endCode); + sqlite3VdbeChangeP1(v, addr+1, mxErr); + sqlite3VdbeJumpHere(v, addr+2); + }else +#endif /* SQLITE_OMIT_INTEGRITY_CHECK */ + +#ifndef SQLITE_OMIT_UTF16 + /* + ** PRAGMA encoding + ** PRAGMA encoding = "utf-8"|"utf-16"|"utf-16le"|"utf-16be" + ** + ** In its first form, this pragma returns the encoding of the main + ** database. If the database is not initialized, it is initialized now. + ** + ** The second form of this pragma is a no-op if the main database file + ** has not already been initialized. In this case it sets the default + ** encoding that will be used for the main database file if a new file + ** is created. If an existing main database file is opened, then the + ** default text encoding for the existing database is used. + ** + ** In all cases new databases created using the ATTACH command are + ** created to use the same default text encoding as the main database. If + ** the main database has not been initialized and/or created when ATTACH + ** is executed, this is done before the ATTACH operation. + ** + ** In the second form this pragma sets the text encoding to be used in + ** new database files created using this database handle. It is only + ** useful if invoked immediately after the main database i + */ + if( sqlite3StrICmp(zLeft, "encoding")==0 ){ + static const struct EncName { + char *zName; + u8 enc; + } encnames[] = { + { "UTF-8", SQLITE_UTF8 }, + { "UTF8", SQLITE_UTF8 }, + { "UTF-16le", SQLITE_UTF16LE }, + { "UTF16le", SQLITE_UTF16LE }, + { "UTF-16be", SQLITE_UTF16BE }, + { "UTF16be", SQLITE_UTF16BE }, + { "UTF-16", 0 }, /* SQLITE_UTF16NATIVE */ + { "UTF16", 0 }, /* SQLITE_UTF16NATIVE */ + { 0, 0 } + }; + const struct EncName *pEnc; + if( !zRight ){ /* "PRAGMA encoding" */ + if( sqlite3ReadSchema(pParse) ) goto pragma_out; + sqlite3VdbeSetNumCols(v, 1); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "encoding", P3_STATIC); + sqlite3VdbeAddOp(v, OP_String8, 0, 0); + for(pEnc=&encnames[0]; pEnc->zName; pEnc++){ + if( pEnc->enc==ENC(pParse->db) ){ + sqlite3VdbeChangeP3(v, -1, pEnc->zName, P3_STATIC); + break; + } + } + sqlite3VdbeAddOp(v, OP_Callback, 1, 0); + }else{ /* "PRAGMA encoding = XXX" */ + /* Only change the value of sqlite.enc if the database handle is not + ** initialized. If the main database exists, the new sqlite.enc value + ** will be overwritten when the schema is next loaded. If it does not + ** already exists, it will be created to use the new encoding value. + */ + if( + !(DbHasProperty(db, 0, DB_SchemaLoaded)) || + DbHasProperty(db, 0, DB_Empty) + ){ + for(pEnc=&encnames[0]; pEnc->zName; pEnc++){ + if( 0==sqlite3StrICmp(zRight, pEnc->zName) ){ + ENC(pParse->db) = pEnc->enc ? pEnc->enc : SQLITE_UTF16NATIVE; + break; + } + } + if( !pEnc->zName ){ + sqlite3ErrorMsg(pParse, "unsupported encoding: %s", zRight); + } + } + } + }else +#endif /* SQLITE_OMIT_UTF16 */ + +#ifndef SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS + /* + ** PRAGMA [database.]schema_version + ** PRAGMA [database.]schema_version = + ** + ** PRAGMA [database.]user_version + ** PRAGMA [database.]user_version = + ** + ** The pragma's schema_version and user_version are used to set or get + ** the value of the schema-version and user-version, respectively. Both + ** the schema-version and the user-version are 32-bit signed integers + ** stored in the database header. + ** + ** The schema-cookie is usually only manipulated internally by SQLite. It + ** is incremented by SQLite whenever the database schema is modified (by + ** creating or dropping a table or index). The schema version is used by + ** SQLite each time a query is executed to ensure that the internal cache + ** of the schema used when compiling the SQL query matches the schema of + ** the database against which the compiled query is actually executed. + ** Subverting this mechanism by using "PRAGMA schema_version" to modify + ** the schema-version is potentially dangerous and may lead to program + ** crashes or database corruption. Use with caution! + ** + ** The user-version is not used internally by SQLite. It may be used by + ** applications for any purpose. + */ + if( sqlite3StrICmp(zLeft, "schema_version")==0 + || sqlite3StrICmp(zLeft, "user_version")==0 + || sqlite3StrICmp(zLeft, "freelist_count")==0 + ){ + + int iCookie; /* Cookie index. 0 for schema-cookie, 6 for user-cookie. */ + sqlite3VdbeUsesBtree(v, iDb); + switch( zLeft[0] ){ + case 's': case 'S': + iCookie = 0; + break; + case 'f': case 'F': + iCookie = 1; + iDb = (-1*(iDb+1)); + assert(iDb<=0); + break; + default: + iCookie = 5; + break; + } + + if( zRight && iDb>=0 ){ + /* Write the specified cookie value */ + static const VdbeOpList setCookie[] = { + { OP_Transaction, 0, 1, 0}, /* 0 */ + { OP_Integer, 0, 0, 0}, /* 1 */ + { OP_SetCookie, 0, 0, 0}, /* 2 */ + }; + int addr = sqlite3VdbeAddOpList(v, ArraySize(setCookie), setCookie); + sqlite3VdbeChangeP1(v, addr, iDb); + sqlite3VdbeChangeP1(v, addr+1, atoi(zRight)); + sqlite3VdbeChangeP1(v, addr+2, iDb); + sqlite3VdbeChangeP2(v, addr+2, iCookie); + }else{ + /* Read the specified cookie value */ + static const VdbeOpList readCookie[] = { + { OP_ReadCookie, 0, 0, 0}, /* 0 */ + { OP_Callback, 1, 0, 0} + }; + int addr = sqlite3VdbeAddOpList(v, ArraySize(readCookie), readCookie); + sqlite3VdbeChangeP1(v, addr, iDb); + sqlite3VdbeChangeP2(v, addr, iCookie); + sqlite3VdbeSetNumCols(v, 1); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLeft, P3_TRANSIENT); + } + }else +#endif /* SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS */ + +#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) + /* + ** Report the current state of file logs for all databases + */ + if( sqlite3StrICmp(zLeft, "lock_status")==0 ){ + static const char *const azLockName[] = { + "unlocked", "shared", "reserved", "pending", "exclusive" + }; + int i; + Vdbe *v = sqlite3GetVdbe(pParse); + sqlite3VdbeSetNumCols(v, 2); + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "database", P3_STATIC); + sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "status", P3_STATIC); + for(i=0; inDb; i++){ + Btree *pBt; + Pager *pPager; + const char *zState = "unknown"; + int j; + if( db->aDb[i].zName==0 ) continue; + sqlite3VdbeOp3(v, OP_String8, 0, 0, db->aDb[i].zName, P3_STATIC); + pBt = db->aDb[i].pBt; + if( pBt==0 || (pPager = sqlite3BtreePager(pBt))==0 ){ + zState = "closed"; + }else if( sqlite3_file_control(db, db->aDb[i].zName, + SQLITE_FCNTL_LOCKSTATE, &j)==SQLITE_OK ){ + zState = azLockName[j]; + } + sqlite3VdbeOp3(v, OP_String8, 0, 0, zState, P3_STATIC); + sqlite3VdbeAddOp(v, OP_Callback, 2, 0); + } + }else +#endif + +#ifdef SQLITE_SSE + /* + ** Check to see if the sqlite_statements table exists. Create it + ** if it does not. + */ + if( sqlite3StrICmp(zLeft, "create_sqlite_statement_table")==0 ){ + extern int sqlite3CreateStatementsTable(Parse*); + sqlite3CreateStatementsTable(pParse); + }else +#endif + +#if SQLITE_HAS_CODEC + if( sqlite3StrICmp(zLeft, "key")==0 ){ + sqlite3_key(db, zRight, strlen(zRight)); + }else +#endif +#if SQLITE_HAS_CODEC || defined(SQLITE_ENABLE_CEROD) + if( sqlite3StrICmp(zLeft, "activate_extensions")==0 ){ +#if SQLITE_HAS_CODEC + if( sqlite3StrNICmp(zRight, "see-", 4)==0 ){ + extern void sqlite3_activate_see(const char*); + sqlite3_activate_see(&zRight[4]); + } +#endif +#ifdef SQLITE_ENABLE_CEROD + if( sqlite3StrNICmp(zRight, "cerod-", 6)==0 ){ + extern void sqlite3_activate_cerod(const char*); + sqlite3_activate_cerod(&zRight[6]); + } +#endif + } +#endif + + {} + + if( v ){ + /* Code an OP_Expire at the end of each PRAGMA program to cause + ** the VDBE implementing the pragma to expire. Most (all?) pragmas + ** are only valid for a single execution. + */ + sqlite3VdbeAddOp(v, OP_Expire, 1, 0); + + /* + ** Reset the safety level, in case the fullfsync flag or synchronous + ** setting changed. + */ +#ifndef SQLITE_OMIT_PAGER_PRAGMAS + if( db->autoCommit ){ + sqlite3BtreeSetSafetyLevel(pDb->pBt, pDb->safety_level, + (db->flags&SQLITE_FullFSync)!=0); + } +#endif + } +pragma_out: + sqlite3_free(zLeft); + sqlite3_free(zRight); +} + +#endif /* SQLITE_OMIT_PRAGMA || SQLITE_OMIT_PARSER */ diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/prepare.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/prepare.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,763 @@ +/* +** 2005 May 25 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the implementation of the sqlite3_prepare() +** interface, and routines that contribute to loading the database schema +** from disk. +** +** $Id: prepare.cpp 1282 2008-11-13 09:31:33Z LarsPson $ +*/ +#include "sqliteInt.h" +#include + +/* +** Fill the InitData structure with an error message that indicates +** that the database is corrupt. +*/ +static void corruptSchema(InitData *pData, const char *zExtra){ + if( !pData->db->mallocFailed ){ + sqlite3SetString(pData->pzErrMsg, "malformed database schema", + zExtra!=0 && zExtra[0]!=0 ? " - " : (char*)0, zExtra, (char*)0); + } + pData->rc = SQLITE_CORRUPT; +} + +/* +** This is the callback routine for the code that initializes the +** database. See sqlite3Init() below for additional information. +** This routine is also called from the OP_ParseSchema opcode of the VDBE. +** +** Each callback contains the following information: +** +** argv[0] = name of thing being created +** argv[1] = root page number for table or index. 0 for trigger or view. +** argv[2] = SQL text for the CREATE statement. +** +*/ +int sqlite3InitCallback(void *pInit, int argc, char **argv, char **azColName){ + InitData *pData = (InitData*)pInit; + sqlite3 *db = pData->db; + int iDb = pData->iDb; + + assert( sqlite3_mutex_held(db->mutex) ); + pData->rc = SQLITE_OK; + DbClearProperty(db, iDb, DB_Empty); + if( db->mallocFailed ){ + corruptSchema(pData, 0); + return SQLITE_NOMEM; + } + + assert( argc==3 ); + if( argv==0 ) return 0; /* Might happen if EMPTY_RESULT_CALLBACKS are on */ + if( argv[1]==0 ){ + corruptSchema(pData, 0); + return 1; + } + assert( iDb>=0 && iDbnDb ); + if( argv[2] && argv[2][0] ){ + /* Call the parser to process a CREATE TABLE, INDEX or VIEW. + ** But because db->init.busy is set to 1, no VDBE code is generated + ** or executed. All the parser does is build the internal data + ** structures that describe the table, index, or view. + */ + char *zErr; + int rc; + assert( db->init.busy ); + db->init.iDb = iDb; + db->init.newTnum = atoi(argv[1]); + rc = sqlite3_exec(db, argv[2], 0, 0, &zErr); + db->init.iDb = 0; + assert( rc!=SQLITE_OK || zErr==0 ); + if( SQLITE_OK!=rc ){ + pData->rc = rc; + if( rc==SQLITE_NOMEM ){ + db->mallocFailed = 1; + }else if( rc!=SQLITE_INTERRUPT ){ + corruptSchema(pData, zErr); + } + sqlite3_free(zErr); + return 1; + } + }else{ + /* If the SQL column is blank it means this is an index that + ** was created to be the PRIMARY KEY or to fulfill a UNIQUE + ** constraint for a CREATE TABLE. The index should have already + ** been created when we processed the CREATE TABLE. All we have + ** to do here is record the root page number for that index. + */ + Index *pIndex; + pIndex = sqlite3FindIndex(db, argv[0], db->aDb[iDb].zName); + if( pIndex==0 || pIndex->tnum!=0 ){ + /* This can occur if there exists an index on a TEMP table which + ** has the same name as another index on a permanent index. Since + ** the permanent table is hidden by the TEMP table, we can also + ** safely ignore the index on the permanent table. + */ + /* Do Nothing */; + }else{ + pIndex->tnum = atoi(argv[1]); + } + } + return 0; +} + +/* +** Attempt to read the database schema and initialize internal +** data structures for a single database file. The index of the +** database file is given by iDb. iDb==0 is used for the main +** database. iDb==1 should never be used. iDb>=2 is used for +** auxiliary databases. Return one of the SQLITE_ error codes to +** indicate success or failure. +*/ +static int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg){ + int rc; + BtCursor *curMain; + int size; + Table *pTab; + Db *pDb; + char const *azArg[4]; + int meta[10]; + InitData initData; + char const *zMasterSchema; + char const *zMasterName = SCHEMA_TABLE(iDb); + + /* + ** The master database table has a structure like this + */ + static const char master_schema[] = + "CREATE TABLE sqlite_master(\n" + " type text,\n" + " name text,\n" + " tbl_name text,\n" + " rootpage integer,\n" + " sql text\n" + ")" + ; +#ifndef SQLITE_OMIT_TEMPDB + static const char temp_master_schema[] = + "CREATE TEMP TABLE sqlite_temp_master(\n" + " type text,\n" + " name text,\n" + " tbl_name text,\n" + " rootpage integer,\n" + " sql text\n" + ")" + ; +#else + #define temp_master_schema 0 +#endif + + assert( iDb>=0 && iDbnDb ); + assert( db->aDb[iDb].pSchema ); + assert( sqlite3_mutex_held(db->mutex) ); + + /* zMasterSchema and zInitScript are set to point at the master schema + ** and initialisation script appropriate for the database being + ** initialised. zMasterName is the name of the master table. + */ + if( !OMIT_TEMPDB && iDb==1 ){ + zMasterSchema = temp_master_schema; + }else{ + zMasterSchema = master_schema; + } + zMasterName = SCHEMA_TABLE(iDb); + + /* Construct the schema tables. */ + sqlite3SafetyOff(db); + azArg[0] = zMasterName; + azArg[1] = "1"; + azArg[2] = zMasterSchema; + azArg[3] = 0; + initData.db = db; + initData.iDb = iDb; + initData.pzErrMsg = pzErrMsg; + rc = sqlite3InitCallback(&initData, 3, (char **)azArg, 0); + if( rc ){ + sqlite3SafetyOn(db); + rc = initData.rc; + goto error_out; + } + pTab = sqlite3FindTable(db, zMasterName, db->aDb[iDb].zName); + if( pTab ){ + pTab->readOnly = 1; + } + sqlite3SafetyOn(db); + + /* Create a cursor to hold the database open + */ + pDb = &db->aDb[iDb]; + if( pDb->pBt==0 ){ + if( !OMIT_TEMPDB && iDb==1 ){ + DbSetProperty(db, 1, DB_SchemaLoaded); + } + return SQLITE_OK; + } + sqlite3BtreeEnter(pDb->pBt); + rc = sqlite3BtreeCursor(pDb->pBt, MASTER_ROOT, 0, 0, 0, &curMain); + if( rc!=SQLITE_OK && rc!=SQLITE_EMPTY ){ + sqlite3SetString(pzErrMsg, sqlite3ErrStr(rc), (char*)0); + sqlite3BtreeLeave(pDb->pBt); + goto error_out; + } + + /* Get the database meta information. + ** + ** Meta values are as follows: + ** meta[0] Schema cookie. Changes with each schema change. + ** meta[1] File format of schema layer. + ** meta[2] Size of the page cache. + ** meta[3] Use freelist if 0. Autovacuum if greater than zero. + ** meta[4] Db text encoding. 1:UTF-8 2:UTF-16LE 3:UTF-16BE + ** meta[5] The user cookie. Used by the application. + ** meta[6] Incremental-vacuum flag. + ** meta[7] + ** meta[8] + ** meta[9] + ** + ** Note: The #defined SQLITE_UTF* symbols in sqliteInt.h correspond to + ** the possible values of meta[4]. + */ + if( rc==SQLITE_OK ){ + int i; + for(i=0; rc==SQLITE_OK && ipBt, i+1, (u32 *)&meta[i]); + } + if( rc ){ + sqlite3SetString(pzErrMsg, sqlite3ErrStr(rc), (char*)0); + sqlite3BtreeCloseCursor(curMain); + sqlite3BtreeLeave(pDb->pBt); + goto error_out; + } + }else{ + memset(meta, 0, sizeof(meta)); + } + pDb->pSchema->schema_cookie = meta[0]; + + /* If opening a non-empty database, check the text encoding. For the + ** main database, set sqlite3.enc to the encoding of the main database. + ** For an attached db, it is an error if the encoding is not the same + ** as sqlite3.enc. + */ + if( meta[4] ){ /* text encoding */ + if( iDb==0 ){ + /* If opening the main database, set ENC(db). */ + ENC(db) = (u8)meta[4]; + db->pDfltColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "BINARY", 6, 0); + }else{ + /* If opening an attached database, the encoding much match ENC(db) */ + if( meta[4]!=ENC(db) ){ + sqlite3BtreeCloseCursor(curMain); + sqlite3SetString(pzErrMsg, "attached databases must use the same" + " text encoding as main database", (char*)0); + sqlite3BtreeLeave(pDb->pBt); + return SQLITE_ERROR; + } + } + }else{ + DbSetProperty(db, iDb, DB_Empty); + } + pDb->pSchema->enc = ENC(db); + + size = meta[2]; + if( size==0 ){ size = SQLITE_DEFAULT_CACHE_SIZE; } + pDb->pSchema->cache_size = size; + sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size); + + /* + ** file_format==1 Version 3.0.0. + ** file_format==2 Version 3.1.3. // ALTER TABLE ADD COLUMN + ** file_format==3 Version 3.1.4. // ditto but with non-NULL defaults + ** file_format==4 Version 3.3.0. // DESC indices. Boolean constants + */ + pDb->pSchema->file_format = meta[1]; + if( pDb->pSchema->file_format==0 ){ + pDb->pSchema->file_format = 1; + } + if( pDb->pSchema->file_format>SQLITE_MAX_FILE_FORMAT ){ + sqlite3BtreeCloseCursor(curMain); + sqlite3SetString(pzErrMsg, "unsupported file format", (char*)0); + sqlite3BtreeLeave(pDb->pBt); + return SQLITE_ERROR; + } + + /* Ticket #2804: When we open a database in the newer file format, + ** clear the legacy_file_format pragma flag so that a VACUUM will + ** not downgrade the database and thus invalidate any descending + ** indices that the user might have created. + */ + if( iDb==0 && meta[1]>=4 ){ + db->flags &= ~SQLITE_LegacyFileFmt; + } + + /* Read the schema information out of the schema tables + */ + assert( db->init.busy ); + if( rc==SQLITE_EMPTY ){ + /* For an empty database, there is nothing to read */ + rc = SQLITE_OK; + }else{ + char *zSql; + zSql = sqlite3MPrintf(db, + "SELECT name, rootpage, sql FROM '%q'.%s", + db->aDb[iDb].zName, zMasterName); + sqlite3SafetyOff(db); +#ifndef SQLITE_OMIT_AUTHORIZATION + { + int (*xAuth)(void*,int,const char*,const char*,const char*,const char*); + xAuth = db->xAuth; + db->xAuth = 0; +#endif + rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0); +#ifndef SQLITE_OMIT_AUTHORIZATION + db->xAuth = xAuth; + } +#endif + if( rc==SQLITE_ABORT ) rc = initData.rc; + sqlite3SafetyOn(db); + sqlite3_free(zSql); +#ifndef SQLITE_OMIT_ANALYZE + if( rc==SQLITE_OK ){ + sqlite3AnalysisLoad(db, iDb); + } +#endif + sqlite3BtreeCloseCursor(curMain); + } + if( db->mallocFailed ){ + /* sqlite3SetString(pzErrMsg, "out of memory", (char*)0); */ + rc = SQLITE_NOMEM; + sqlite3ResetInternalSchema(db, 0); + } + if( rc==SQLITE_OK || (db->flags&SQLITE_RecoveryMode)){ + /* Black magic: If the SQLITE_RecoveryMode flag is set, then consider + ** the schema loaded, even if errors occured. In this situation the + ** current sqlite3_prepare() operation will fail, but the following one + ** will attempt to compile the supplied statement against whatever subset + ** of the schema was loaded before the error occured. The primary + ** purpose of this is to allow access to the sqlite_master table + ** even when its contents have been corrupted. + */ + DbSetProperty(db, iDb, DB_SchemaLoaded); + rc = SQLITE_OK; + } + sqlite3BtreeLeave(pDb->pBt); + +error_out: + if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){ + db->mallocFailed = 1; + } + return rc; +} + +/* +** Initialize all database files - the main database file, the file +** used to store temporary tables, and any additional database files +** created using ATTACH statements. Return a success code. If an +** error occurs, write an error message into *pzErrMsg. +** +** After a database is initialized, the DB_SchemaLoaded bit is set +** bit is set in the flags field of the Db structure. If the database +** file was of zero-length, then the DB_Empty flag is also set. +*/ +int sqlite3Init(sqlite3 *db, char **pzErrMsg){ + int i, rc; + int commit_internal = !(db->flags&SQLITE_InternChanges); + + assert( sqlite3_mutex_held(db->mutex) ); + if( db->init.busy ) return SQLITE_OK; + rc = SQLITE_OK; + db->init.busy = 1; + for(i=0; rc==SQLITE_OK && inDb; i++){ + if( DbHasProperty(db, i, DB_SchemaLoaded) || i==1 ) continue; + rc = sqlite3InitOne(db, i, pzErrMsg); + if( rc ){ + sqlite3ResetInternalSchema(db, i); + } + } + + /* Once all the other databases have been initialised, load the schema + ** for the TEMP database. This is loaded last, as the TEMP database + ** schema may contain references to objects in other databases. + */ +#ifndef SQLITE_OMIT_TEMPDB + if( rc==SQLITE_OK && db->nDb>1 && !DbHasProperty(db, 1, DB_SchemaLoaded) ){ + rc = sqlite3InitOne(db, 1, pzErrMsg); + if( rc ){ + sqlite3ResetInternalSchema(db, 1); + } + } +#endif + + db->init.busy = 0; + if( rc==SQLITE_OK && commit_internal ){ + sqlite3CommitInternalChanges(db); + } + + return rc; +} + +/* +** This routine is a no-op if the database schema is already initialised. +** Otherwise, the schema is loaded. An error code is returned. +*/ +int sqlite3ReadSchema(Parse *pParse){ + int rc = SQLITE_OK; + sqlite3 *db = pParse->db; + assert( sqlite3_mutex_held(db->mutex) ); + if( !db->init.busy ){ + rc = sqlite3Init(db, &pParse->zErrMsg); + } + if( rc!=SQLITE_OK ){ + pParse->rc = rc; + pParse->nErr++; + } + return rc; +} + + +/* +** Check schema cookies in all databases. If any cookie is out +** of date, return 0. If all schema cookies are current, return 1. +*/ +static int schemaIsValid(sqlite3 *db){ + int iDb; + int rc; + BtCursor *curTemp; + int cookie; + int allOk = 1; + + assert( sqlite3_mutex_held(db->mutex) ); + for(iDb=0; allOk && iDbnDb; iDb++){ + Btree *pBt; + pBt = db->aDb[iDb].pBt; + if( pBt==0 ) continue; + rc = sqlite3BtreeCursor(pBt, MASTER_ROOT, 0, 0, 0, &curTemp); + if( rc==SQLITE_OK ){ + rc = sqlite3BtreeGetMeta(pBt, 1, (u32 *)&cookie); + if( rc==SQLITE_OK && cookie!=db->aDb[iDb].pSchema->schema_cookie ){ + allOk = 0; + } + sqlite3BtreeCloseCursor(curTemp); + } + if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){ + db->mallocFailed = 1; + } + } + return allOk; +} + +/* +** Convert a schema pointer into the iDb index that indicates +** which database file in db->aDb[] the schema refers to. +** +** If the same database is attached more than once, the first +** attached database is returned. +*/ +int sqlite3SchemaToIndex(sqlite3 *db, Schema *pSchema){ + int i = -1000000; + + /* If pSchema is NULL, then return -1000000. This happens when code in + ** expr.c is trying to resolve a reference to a transient table (i.e. one + ** created by a sub-select). In this case the return value of this + ** function should never be used. + ** + ** We return -1000000 instead of the more usual -1 simply because using + ** -1000000 as incorrectly using -1000000 index into db->aDb[] is much + ** more likely to cause a segfault than -1 (of course there are assert() + ** statements too, but it never hurts to play the odds). + */ + assert( sqlite3_mutex_held(db->mutex) ); + if( pSchema ){ + for(i=0; inDb; i++){ + if( db->aDb[i].pSchema==pSchema ){ + break; + } + } + assert( i>=0 &&i>=0 && inDb ); + } + return i; +} + +/* +** Compile the UTF-8 encoded SQL statement zSql into a statement handle. +*/ +int sqlite3Prepare( + sqlite3 *db, /* Database handle. */ + const char *zSql, /* UTF-8 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + int saveSqlFlag, /* True to copy SQL text into the sqlite3_stmt */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const char **pzTail /* OUT: End of parsed string */ +){ + Parse sParse; + char *zErrMsg = 0; + int rc = SQLITE_OK; + int i; + + assert( ppStmt ); + *ppStmt = 0; + if( sqlite3SafetyOn(db) ){ + return SQLITE_MISUSE; + } + assert( !db->mallocFailed ); + assert( sqlite3_mutex_held(db->mutex) ); + + /* If any attached database schemas are locked, do not proceed with + ** compilation. Instead return SQLITE_LOCKED immediately. + */ + for(i=0; inDb; i++) { + Btree *pBt = db->aDb[i].pBt; + if( pBt ){ + int rc; + rc = sqlite3BtreeSchemaLocked(pBt); + if( rc ){ + const char *zDb = db->aDb[i].zName; + sqlite3Error(db, SQLITE_LOCKED, "database schema is locked: %s", zDb); + sqlite3SafetyOff(db); + return SQLITE_LOCKED; + } + } + } + + memset(&sParse, 0, sizeof(sParse)); + sParse.db = db; + if( nBytes>=0 && zSql[nBytes]!=0 ){ + char *zSqlCopy; + if( nBytes>SQLITE_MAX_SQL_LENGTH ){ + return SQLITE_TOOBIG; + } + zSqlCopy = sqlite3DbStrNDup(db, zSql, nBytes); + if( zSqlCopy ){ + sqlite3RunParser(&sParse, zSqlCopy, &zErrMsg); + sqlite3_free(zSqlCopy); + } + sParse.zTail = &zSql[nBytes]; + }else{ + sqlite3RunParser(&sParse, zSql, &zErrMsg); + } + + if( db->mallocFailed ){ + sParse.rc = SQLITE_NOMEM; + } + if( sParse.rc==SQLITE_DONE ) sParse.rc = SQLITE_OK; + if( sParse.checkSchema && !schemaIsValid(db) ){ + sParse.rc = SQLITE_SCHEMA; + } + if( sParse.rc==SQLITE_SCHEMA ){ + sqlite3ResetInternalSchema(db, 0); + } + if( db->mallocFailed ){ + sParse.rc = SQLITE_NOMEM; + } + if( pzTail ){ + *pzTail = sParse.zTail; + } + rc = sParse.rc; + +#ifndef SQLITE_OMIT_EXPLAIN + if( rc==SQLITE_OK && sParse.pVdbe && sParse.explain ){ + if( sParse.explain==2 ){ + sqlite3VdbeSetNumCols(sParse.pVdbe, 3); + sqlite3VdbeSetColName(sParse.pVdbe, 0, COLNAME_NAME, "order", P3_STATIC); + sqlite3VdbeSetColName(sParse.pVdbe, 1, COLNAME_NAME, "from", P3_STATIC); + sqlite3VdbeSetColName(sParse.pVdbe, 2, COLNAME_NAME, "detail", P3_STATIC); + }else{ + sqlite3VdbeSetNumCols(sParse.pVdbe, 5); + sqlite3VdbeSetColName(sParse.pVdbe, 0, COLNAME_NAME, "addr", P3_STATIC); + sqlite3VdbeSetColName(sParse.pVdbe, 1, COLNAME_NAME, "opcode", P3_STATIC); + sqlite3VdbeSetColName(sParse.pVdbe, 2, COLNAME_NAME, "p1", P3_STATIC); + sqlite3VdbeSetColName(sParse.pVdbe, 3, COLNAME_NAME, "p2", P3_STATIC); + sqlite3VdbeSetColName(sParse.pVdbe, 4, COLNAME_NAME, "p3", P3_STATIC); + } + } +#endif + + if( sqlite3SafetyOff(db) ){ + rc = SQLITE_MISUSE; + } + + if( saveSqlFlag ){ + sqlite3VdbeSetSql(sParse.pVdbe, zSql, sParse.zTail - zSql); + } + if( rc!=SQLITE_OK || db->mallocFailed ){ + sqlite3_finalize((sqlite3_stmt*)sParse.pVdbe); + assert(!(*ppStmt)); + }else{ + *ppStmt = (sqlite3_stmt*)sParse.pVdbe; + } + + if( zErrMsg ){ + sqlite3Error(db, rc, "%s", zErrMsg); + sqlite3_free(zErrMsg); + }else{ + sqlite3Error(db, rc, 0); + } + + rc = sqlite3ApiExit(db, rc); + /* sqlite3ReleaseThreadData(); */ + assert( (rc&db->errMask)==rc ); + return rc; +} +static int sqlite3LockAndPrepare( + sqlite3 *db, /* Database handle. */ + const char *zSql, /* UTF-8 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + int saveSqlFlag, /* True to copy SQL text into the sqlite3_stmt */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const char **pzTail /* OUT: End of parsed string */ +){ + int rc; + if( sqlite3SafetyCheck(db) ){ + return SQLITE_MISUSE; + } + sqlite3_mutex_enter(db->mutex); + sqlite3BtreeEnterAll(db); + rc = sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, ppStmt, pzTail); + sqlite3BtreeLeaveAll(db); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/* +** Rerun the compilation of a statement after a schema change. +** Return true if the statement was recompiled successfully. +** Return false if there is an error of some kind. +*/ +int sqlite3Reprepare(Vdbe *p){ + int rc; + sqlite3_stmt *pNew; + const char *zSql; + sqlite3 *db; + + assert( sqlite3_mutex_held(sqlite3VdbeDb(p)->mutex) ); + zSql = sqlite3_sql((sqlite3_stmt *)p); + if( zSql==0 ){ + return 0; + } + db = sqlite3VdbeDb(p); + assert( sqlite3_mutex_held(db->mutex) ); + rc = sqlite3LockAndPrepare(db, zSql, -1, 0, &pNew, 0); + if( rc ){ + if( rc==SQLITE_NOMEM ){ + db->mallocFailed = 1; + } + assert( pNew==0 ); + return 0; + }else{ + assert( pNew!=0 ); + } + sqlite3VdbeSwap((Vdbe*)pNew, p); + sqlite3_transfer_bindings(pNew, (sqlite3_stmt*)p); + sqlite3VdbeResetStepResult((Vdbe*)pNew); + sqlite3VdbeFinalize((Vdbe*)pNew); + return 1; +} + + +/* +** Two versions of the official API. Legacy and new use. In the legacy +** version, the original SQL text is not saved in the prepared statement +** and so if a schema change occurs, SQLITE_SCHEMA is returned by +** sqlite3_step(). In the new version, the original SQL text is retained +** and the statement is automatically recompiled if an schema change +** occurs. +*/ +EXPORT_C int sqlite3_prepare( + sqlite3 *db, /* Database handle. */ + const char *zSql, /* UTF-8 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const char **pzTail /* OUT: End of parsed string */ +){ + return sqlite3LockAndPrepare(db,zSql,nBytes,0,ppStmt,pzTail); +} +EXPORT_C int sqlite3_prepare_v2( + sqlite3 *db, /* Database handle. */ + const char *zSql, /* UTF-8 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const char **pzTail /* OUT: End of parsed string */ +){ + return sqlite3LockAndPrepare(db,zSql,nBytes,1,ppStmt,pzTail); +} + + +#ifndef SQLITE_OMIT_UTF16 +/* +** Compile the UTF-16 encoded SQL statement zSql into a statement handle. +*/ +static int sqlite3Prepare16( + sqlite3 *db, /* Database handle. */ + const void *zSql, /* UTF-8 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + int saveSqlFlag, /* True to save SQL text into the sqlite3_stmt */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const void **pzTail /* OUT: End of parsed string */ +){ + /* This function currently works by first transforming the UTF-16 + ** encoded string to UTF-8, then invoking sqlite3_prepare(). The + ** tricky bit is figuring out the pointer to return in *pzTail. + */ + char *zSql8; + const char *zTail8 = 0; + int rc = SQLITE_OK; + + if( sqlite3SafetyCheck(db) ){ + return SQLITE_MISUSE; + } + sqlite3_mutex_enter(db->mutex); + zSql8 = sqlite3Utf16to8(db, zSql, nBytes); + if( zSql8 ){ + rc = sqlite3LockAndPrepare(db, zSql8, -1, saveSqlFlag, ppStmt, &zTail8); + } + + if( zTail8 && pzTail ){ + /* If sqlite3_prepare returns a tail pointer, we calculate the + ** equivalent pointer into the UTF-16 string by counting the unicode + ** characters between zSql8 and zTail8, and then returning a pointer + ** the same number of characters into the UTF-16 string. + */ + int chars_parsed = sqlite3Utf8CharLen(zSql8, zTail8-zSql8); + *pzTail = (u8 *)zSql + sqlite3Utf16ByteLen(zSql, chars_parsed); + } + sqlite3_free(zSql8); + rc = sqlite3ApiExit(db, rc); + sqlite3_mutex_leave(db->mutex); + return rc; +} + +/* +** Two versions of the official API. Legacy and new use. In the legacy +** version, the original SQL text is not saved in the prepared statement +** and so if a schema change occurs, SQLITE_SCHEMA is returned by +** sqlite3_step(). In the new version, the original SQL text is retained +** and the statement is automatically recompiled if an schema change +** occurs. +*/ +EXPORT_C int sqlite3_prepare16( + sqlite3 *db, /* Database handle. */ + const void *zSql, /* UTF-8 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const void **pzTail /* OUT: End of parsed string */ +){ + return sqlite3Prepare16(db,zSql,nBytes,0,ppStmt,pzTail); +} +EXPORT_C int sqlite3_prepare16_v2( + sqlite3 *db, /* Database handle. */ + const void *zSql, /* UTF-8 encoded SQL statement. */ + int nBytes, /* Length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ + const void **pzTail /* OUT: End of parsed string */ +){ + return sqlite3Prepare16(db,zSql,nBytes,1,ppStmt,pzTail); +} + +#endif /* SQLITE_OMIT_UTF16 */ diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/printf.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/printf.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,904 @@ +/* +** The "printf" code that follows dates from the 1980's. It is in +** the public domain. The original comments are included here for +** completeness. They are very out-of-date but might be useful as +** an historical reference. Most of the "enhancements" have been backed +** out so that the functionality is now the same as standard printf(). +** +************************************************************************** +** +** The following modules is an enhanced replacement for the "printf" subroutines +** found in the standard C library. The following enhancements are +** supported: +** +** + Additional functions. The standard set of "printf" functions +** includes printf, fprintf, sprintf, vprintf, vfprintf, and +** vsprintf. This module adds the following: +** +** * snprintf -- Works like sprintf, but has an extra argument +** which is the size of the buffer written to. +** +** * mprintf -- Similar to sprintf. Writes output to memory +** obtained from malloc. +** +** * xprintf -- Calls a function to dispose of output. +** +** * nprintf -- No output, but returns the number of characters +** that would have been output by printf. +** +** * A v- version (ex: vsnprintf) of every function is also +** supplied. +** +** + A few extensions to the formatting notation are supported: +** +** * The "=" flag (similar to "-") causes the output to be +** be centered in the appropriately sized field. +** +** * The %b field outputs an integer in binary notation. +** +** * The %c field now accepts a precision. The character output +** is repeated by the number of times the precision specifies. +** +** * The %' field works like %c, but takes as its character the +** next character of the format string, instead of the next +** argument. For example, printf("%.78'-") prints 78 minus +** signs, the same as printf("%.78c",'-'). +** +** + When compiled using GCC on a SPARC, this version of printf is +** faster than the library printf for SUN OS 4.1. +** +** + All functions are fully reentrant. +** +*/ +#include "sqliteInt.h" + +/* +** Conversion types fall into various categories as defined by the +** following enumeration. +*/ +#define etRADIX 1 /* Integer types. %d, %x, %o, and so forth */ +#define etFLOAT 2 /* Floating point. %f */ +#define etEXP 3 /* Exponentional notation. %e and %E */ +#define etGENERIC 4 /* Floating or exponential, depending on exponent. %g */ +#define etSIZE 5 /* Return number of characters processed so far. %n */ +#define etSTRING 6 /* Strings. %s */ +#define etDYNSTRING 7 /* Dynamically allocated strings. %z */ +#define etPERCENT 8 /* Percent symbol. %% */ +#define etCHARX 9 /* Characters. %c */ +/* The rest are extensions, not normally found in printf() */ +#define etCHARLIT 10 /* Literal characters. %' */ +#define etSQLESCAPE 11 /* Strings with '\'' doubled. %q */ +#define etSQLESCAPE2 12 /* Strings with '\'' doubled and enclosed in '', + NULL pointers replaced by SQL NULL. %Q */ +#define etTOKEN 13 /* a pointer to a Token structure */ +#define etSRCLIST 14 /* a pointer to a SrcList */ +#define etPOINTER 15 /* The %p conversion */ +#define etSQLESCAPE3 16 /* %w -> Strings with '\"' doubled */ +#define etORDINAL 17 /* %r -> 1st, 2nd, 3rd, 4th, etc. English only */ + + +/* +** An "etByte" is an 8-bit unsigned value. +*/ +typedef unsigned char etByte; + +/* +** Each builtin conversion character (ex: the 'd' in "%d") is described +** by an instance of the following structure +*/ +typedef struct et_info { /* Information about each format field */ + char fmttype; /* The format field code letter */ + etByte base; /* The base for radix conversion */ + etByte flags; /* One or more of FLAG_ constants below */ + etByte type; /* Conversion paradigm */ + etByte charset; /* Offset into aDigits[] of the digits string */ + etByte prefix; /* Offset into aPrefix[] of the prefix string */ +} et_info; + +/* +** Allowed values for et_info.flags +*/ +#define FLAG_SIGNED 1 /* True if the value to convert is signed */ +#define FLAG_INTERN 2 /* True if for internal use only */ +#define FLAG_STRING 4 /* Allow infinity precision */ + + +/* +** The following table is searched linearly, so it is good to put the +** most frequently used conversion types first. +*/ +static const char aDigits[] = "0123456789ABCDEF0123456789abcdef"; +static const char aPrefix[] = "-x0\000X0"; +static const et_info fmtinfo[] = { + { 'd', 10, 1, etRADIX, 0, 0 }, + { 's', 0, 4, etSTRING, 0, 0 }, + { 'g', 0, 1, etGENERIC, 30, 0 }, + { 'z', 0, 4, etDYNSTRING, 0, 0 }, + { 'q', 0, 4, etSQLESCAPE, 0, 0 }, + { 'Q', 0, 4, etSQLESCAPE2, 0, 0 }, + { 'w', 0, 4, etSQLESCAPE3, 0, 0 }, + { 'c', 0, 0, etCHARX, 0, 0 }, + { 'o', 8, 0, etRADIX, 0, 2 }, + { 'u', 10, 0, etRADIX, 0, 0 }, + { 'x', 16, 0, etRADIX, 16, 1 }, + { 'X', 16, 0, etRADIX, 0, 4 }, +#ifndef SQLITE_OMIT_FLOATING_POINT + { 'f', 0, 1, etFLOAT, 0, 0 }, + { 'e', 0, 1, etEXP, 30, 0 }, + { 'E', 0, 1, etEXP, 14, 0 }, + { 'G', 0, 1, etGENERIC, 14, 0 }, +#endif + { 'i', 10, 1, etRADIX, 0, 0 }, + { 'n', 0, 0, etSIZE, 0, 0 }, + { '%', 0, 0, etPERCENT, 0, 0 }, + { 'p', 16, 0, etPOINTER, 0, 1 }, + { 'T', 0, 2, etTOKEN, 0, 0 }, + { 'S', 0, 2, etSRCLIST, 0, 0 }, + { 'r', 10, 3, etORDINAL, 0, 0 }, +}; +#define etNINFO (sizeof(fmtinfo)/sizeof(fmtinfo[0])) + +/* +** If SQLITE_OMIT_FLOATING_POINT is defined, then none of the floating point +** conversions will work. +*/ +#ifndef SQLITE_OMIT_FLOATING_POINT +/* +** "*val" is a double such that 0.1 <= *val < 10.0 +** Return the ascii code for the leading digit of *val, then +** multiply "*val" by 10.0 to renormalize. +** +** Example: +** input: *val = 3.14159 +** output: *val = 1.4159 function return = '3' +** +** The counter *cnt is incremented each time. After counter exceeds +** 16 (the number of significant digits in a 64-bit float) '0' is +** always returned. +*/ +static int et_getdigit(LONGDOUBLE_TYPE *val, int *cnt){ + int digit; + LONGDOUBLE_TYPE d; + if( (*cnt)++ >= 16 ) return '0'; + digit = (int)*val; + d = digit; + digit += '0'; + *val = (*val - d)*10.0; + return digit; +} +#endif /* SQLITE_OMIT_FLOATING_POINT */ + +/* +** Append N space characters to the given string buffer. +*/ +static void appendSpace(StrAccum *pAccum, int N){ + static const char zSpaces[] = " "; + while( N>=sizeof(zSpaces)-1 ){ + sqlite3StrAccumAppend(pAccum, zSpaces, sizeof(zSpaces)-1); + N -= sizeof(zSpaces)-1; + } + if( N>0 ){ + sqlite3StrAccumAppend(pAccum, zSpaces, N); + } +} + +/* +** On machines with a small stack size, you can redefine the +** SQLITE_PRINT_BUF_SIZE to be less than 350. But beware - for +** smaller values some %f conversions may go into an infinite loop. +*/ +#ifndef SQLITE_PRINT_BUF_SIZE +# define SQLITE_PRINT_BUF_SIZE 350 +#endif +#define etBUFSIZE SQLITE_PRINT_BUF_SIZE /* Size of the output buffer */ + +/* +** The root program. All variations call this core. +** +** INPUTS: +** func This is a pointer to a function taking three arguments +** 1. A pointer to anything. Same as the "arg" parameter. +** 2. A pointer to the list of characters to be output +** (Note, this list is NOT null terminated.) +** 3. An integer number of characters to be output. +** (Note: This number might be zero.) +** +** arg This is the pointer to anything which will be passed as the +** first argument to "func". Use it for whatever you like. +** +** fmt This is the format string, as in the usual print. +** +** ap This is a pointer to a list of arguments. Same as in +** vfprint. +** +** OUTPUTS: +** The return value is the total number of characters sent to +** the function "func". Returns -1 on a error. +** +** Note that the order in which automatic variables are declared below +** seems to make a big difference in determining how fast this beast +** will run. +*/ +static void vxprintf( + StrAccum *pAccum, /* Accumulate results here */ + int useExtended, /* Allow extended %-conversions */ + const char *fmt, /* Format string */ + va_list ap /* arguments */ +){ + int c; /* Next character in the format string */ + char *bufpt; /* Pointer to the conversion buffer */ + int precision; /* Precision of the current field */ + int length; /* Length of the field */ + int idx; /* A general purpose loop counter */ + int width; /* Width of the current field */ + etByte flag_leftjustify; /* True if "-" flag is present */ + etByte flag_plussign; /* True if "+" flag is present */ + etByte flag_blanksign; /* True if " " flag is present */ + etByte flag_alternateform; /* True if "#" flag is present */ + etByte flag_altform2; /* True if "!" flag is present */ + etByte flag_zeropad; /* True if field width constant starts with zero */ + etByte flag_long; /* True if "l" flag is present */ + etByte flag_longlong; /* True if the "ll" flag is present */ + etByte done; /* Loop termination flag */ + sqlite_uint64 longvalue; /* Value for integer types */ + LONGDOUBLE_TYPE realvalue; /* Value for real types */ + const et_info *infop; /* Pointer to the appropriate info structure */ + char buf[etBUFSIZE]; /* Conversion buffer */ + char prefix; /* Prefix character. "+" or "-" or " " or '\0'. */ + etByte errorflag = 0; /* True if an error is encountered */ + etByte xtype; /* Conversion paradigm */ + char *zExtra; /* Extra memory used for etTCLESCAPE conversions */ +#ifndef SQLITE_OMIT_FLOATING_POINT + int exp, e2; /* exponent of real numbers */ + double rounder; /* Used for rounding floating point values */ + etByte flag_dp; /* True if decimal point should be shown */ + etByte flag_rtz; /* True if trailing zeros should be removed */ + etByte flag_exp; /* True to force display of the exponent */ + int nsd; /* Number of significant digits returned */ +#endif + + length = 0; + bufpt = 0; + for(; (c=(*fmt))!=0; ++fmt){ + if( c!='%' ){ + int amt; + bufpt = (char *)fmt; + amt = 1; + while( (c=(*++fmt))!='%' && c!=0 ) amt++; + sqlite3StrAccumAppend(pAccum, bufpt, amt); + if( c==0 ) break; + } + if( (c=(*++fmt))==0 ){ + errorflag = 1; + sqlite3StrAccumAppend(pAccum, "%", 1); + break; + } + /* Find out what flags are present */ + flag_leftjustify = flag_plussign = flag_blanksign = + flag_alternateform = flag_altform2 = flag_zeropad = 0; + done = 0; + do{ + switch( c ){ + case '-': flag_leftjustify = 1; break; + case '+': flag_plussign = 1; break; + case ' ': flag_blanksign = 1; break; + case '#': flag_alternateform = 1; break; + case '!': flag_altform2 = 1; break; + case '0': flag_zeropad = 1; break; + default: done = 1; break; + } + }while( !done && (c=(*++fmt))!=0 ); + /* Get the field width */ + width = 0; + if( c=='*' ){ + width = va_arg(ap,int); + if( width<0 ){ + flag_leftjustify = 1; + width = -width; + } + c = *++fmt; + }else{ + while( c>='0' && c<='9' ){ + width = width*10 + c - '0'; + c = *++fmt; + } + } + if( width > etBUFSIZE-10 ){ + width = etBUFSIZE-10; + } + /* Get the precision */ + if( c=='.' ){ + precision = 0; + c = *++fmt; + if( c=='*' ){ + precision = va_arg(ap,int); + if( precision<0 ) precision = -precision; + c = *++fmt; + }else{ + while( c>='0' && c<='9' ){ + precision = precision*10 + c - '0'; + c = *++fmt; + } + } + }else{ + precision = -1; + } + /* Get the conversion type modifier */ + if( c=='l' ){ + flag_long = 1; + c = *++fmt; + if( c=='l' ){ + flag_longlong = 1; + c = *++fmt; + }else{ + flag_longlong = 0; + } + }else{ + flag_long = flag_longlong = 0; + } + /* Fetch the info entry for the field */ + infop = 0; + for(idx=0; idxflags & FLAG_INTERN)==0 ){ + xtype = infop->type; + }else{ + return; + } + break; + } + } + zExtra = 0; + if( infop==0 ){ + return; + } + + + /* Limit the precision to prevent overflowing buf[] during conversion */ + if( precision>etBUFSIZE-40 && (infop->flags & FLAG_STRING)==0 ){ + precision = etBUFSIZE-40; + } + + /* + ** At this point, variables are initialized as follows: + ** + ** flag_alternateform TRUE if a '#' is present. + ** flag_altform2 TRUE if a '!' is present. + ** flag_plussign TRUE if a '+' is present. + ** flag_leftjustify TRUE if a '-' is present or if the + ** field width was negative. + ** flag_zeropad TRUE if the width began with 0. + ** flag_long TRUE if the letter 'l' (ell) prefixed + ** the conversion character. + ** flag_longlong TRUE if the letter 'll' (ell ell) prefixed + ** the conversion character. + ** flag_blanksign TRUE if a ' ' is present. + ** width The specified field width. This is + ** always non-negative. Zero is the default. + ** precision The specified precision. The default + ** is -1. + ** xtype The class of the conversion. + ** infop Pointer to the appropriate info struct. + */ + switch( xtype ){ + case etPOINTER: + flag_longlong = sizeof(char*)==sizeof(i64); + flag_long = sizeof(char*)==sizeof(long int); + /* Fall through into the next case */ + case etORDINAL: + case etRADIX: + if( infop->flags & FLAG_SIGNED ){ + i64 v; + if( flag_longlong ) v = va_arg(ap,i64); + else if( flag_long ) v = va_arg(ap,long int); + else v = va_arg(ap,int); + if( v<0 ){ + longvalue = -v; + prefix = '-'; + }else{ + longvalue = v; + if( flag_plussign ) prefix = '+'; + else if( flag_blanksign ) prefix = ' '; + else prefix = 0; + } + }else{ + if( flag_longlong ) longvalue = va_arg(ap,u64); + else if( flag_long ) longvalue = va_arg(ap,unsigned long int); + else longvalue = va_arg(ap,unsigned int); + prefix = 0; + } + if( longvalue==0 ) flag_alternateform = 0; + if( flag_zeropad && precision=4 || (longvalue/10)%10==1 ){ + x = 0; + } + buf[etBUFSIZE-3] = zOrd[x*2]; + buf[etBUFSIZE-2] = zOrd[x*2+1]; + bufpt -= 2; + } + { + register const char *cset; /* Use registers for speed */ + register int base; + cset = &aDigits[infop->charset]; + base = infop->base; + do{ /* Convert to ascii */ + *(--bufpt) = cset[longvalue%base]; + longvalue = longvalue/base; + }while( longvalue>0 ); + } + length = &buf[etBUFSIZE-1]-bufpt; + for(idx=precision-length; idx>0; idx--){ + *(--bufpt) = '0'; /* Zero pad */ + } + if( prefix ) *(--bufpt) = prefix; /* Add sign */ + if( flag_alternateform && infop->prefix ){ /* Add "0" or "0x" */ + const char *pre; + char x; + pre = &aPrefix[infop->prefix]; + if( *bufpt!=pre[0] ){ + for(; (x=(*pre))!=0; pre++) *(--bufpt) = x; + } + } + length = &buf[etBUFSIZE-1]-bufpt; + break; + case etFLOAT: + case etEXP: + case etGENERIC: + realvalue = va_arg(ap,double); +#ifndef SQLITE_OMIT_FLOATING_POINT + if( precision<0 ) precision = 6; /* Set default precision */ + if( precision>etBUFSIZE/2-10 ) precision = etBUFSIZE/2-10; + if( realvalue<0.0 ){ + realvalue = -realvalue; + prefix = '-'; + }else{ + if( flag_plussign ) prefix = '+'; + else if( flag_blanksign ) prefix = ' '; + else prefix = 0; + } + if( xtype==etGENERIC && precision>0 ) precision--; +#if 0 + /* Rounding works like BSD when the constant 0.4999 is used. Wierd! */ + for(idx=precision, rounder=0.4999; idx>0; idx--, rounder*=0.1); +#else + /* It makes more sense to use 0.5 */ + for(idx=precision, rounder=0.5; idx>0; idx--, rounder*=0.1){} +#endif + if( xtype==etFLOAT ) realvalue += rounder; + /* Normalize realvalue to within 10.0 > realvalue >= 1.0 */ + exp = 0; + if( sqlite3_isnan(realvalue) ){ + bufpt = "NaN"; + length = 3; + break; + } + if( realvalue>0.0 ){ + while( realvalue>=1e32 && exp<=350 ){ realvalue *= 1e-32; exp+=32; } + while( realvalue>=1e8 && exp<=350 ){ realvalue *= 1e-8; exp+=8; } + while( realvalue>=10.0 && exp<=350 ){ realvalue *= 0.1; exp++; } + while( realvalue<1e-8 && exp>=-350 ){ realvalue *= 1e8; exp-=8; } + while( realvalue<1.0 && exp>=-350 ){ realvalue *= 10.0; exp--; } + if( exp>350 || exp<-350 ){ + if( prefix=='-' ){ + bufpt = "-Inf"; + }else if( prefix=='+' ){ + bufpt = "+Inf"; + }else{ + bufpt = "Inf"; + } + length = strlen(bufpt); + break; + } + } + bufpt = buf; + /* + ** If the field type is etGENERIC, then convert to either etEXP + ** or etFLOAT, as appropriate. + */ + flag_exp = xtype==etEXP; + if( xtype!=etFLOAT ){ + realvalue += rounder; + if( realvalue>=10.0 ){ realvalue *= 0.1; exp++; } + } + if( xtype==etGENERIC ){ + flag_rtz = !flag_alternateform; + if( exp<-4 || exp>precision ){ + xtype = etEXP; + }else{ + precision = precision - exp; + xtype = etFLOAT; + } + }else{ + flag_rtz = 0; + } + if( xtype==etEXP ){ + e2 = 0; + }else{ + e2 = exp; + } + nsd = 0; + flag_dp = (precision>0) | flag_alternateform | flag_altform2; + /* The sign in front of the number */ + if( prefix ){ + *(bufpt++) = prefix; + } + /* Digits prior to the decimal point */ + if( e2<0 ){ + *(bufpt++) = '0'; + }else{ + for(; e2>=0; e2--){ + *(bufpt++) = et_getdigit(&realvalue,&nsd); + } + } + /* The decimal point */ + if( flag_dp ){ + *(bufpt++) = '.'; + } + /* "0" digits after the decimal point but before the first + ** significant digit of the number */ + for(e2++; e2<0 && precision>0; precision--, e2++){ + *(bufpt++) = '0'; + } + /* Significant digits after the decimal point */ + while( (precision--)>0 ){ + *(bufpt++) = et_getdigit(&realvalue,&nsd); + } + /* Remove trailing zeros and the "." if no digits follow the "." */ + if( flag_rtz && flag_dp ){ + while( bufpt[-1]=='0' ) *(--bufpt) = 0; + assert( bufpt>buf ); + if( bufpt[-1]=='.' ){ + if( flag_altform2 ){ + *(bufpt++) = '0'; + }else{ + *(--bufpt) = 0; + } + } + } + /* Add the "eNNN" suffix */ + if( flag_exp || (xtype==etEXP && exp) ){ + *(bufpt++) = aDigits[infop->charset]; + if( exp<0 ){ + *(bufpt++) = '-'; exp = -exp; + }else{ + *(bufpt++) = '+'; + } + if( exp>=100 ){ + *(bufpt++) = (exp/100)+'0'; /* 100's digit */ + exp %= 100; + } + *(bufpt++) = exp/10+'0'; /* 10's digit */ + *(bufpt++) = exp%10+'0'; /* 1's digit */ + } + *bufpt = 0; + + /* The converted number is in buf[] and zero terminated. Output it. + ** Note that the number is in the usual order, not reversed as with + ** integer conversions. */ + length = bufpt-buf; + bufpt = buf; + + /* Special case: Add leading zeros if the flag_zeropad flag is + ** set and we are not left justified */ + if( flag_zeropad && !flag_leftjustify && length < width){ + int i; + int nPad = width - length; + for(i=width; i>=nPad; i--){ + bufpt[i] = bufpt[i-nPad]; + } + i = prefix!=0; + while( nPad-- ) bufpt[i++] = '0'; + length = width; + } +#endif + break; + case etSIZE: + *(va_arg(ap,int*)) = pAccum->nChar; + length = width = 0; + break; + case etPERCENT: + buf[0] = '%'; + bufpt = buf; + length = 1; + break; + case etCHARLIT: + case etCHARX: + c = buf[0] = (xtype==etCHARX ? va_arg(ap,int) : *++fmt); + if( precision>=0 ){ + for(idx=1; idx=0 && precisionetBUFSIZE ){ + bufpt = zExtra = (char*)sqlite3_malloc( n ); + if( bufpt==0 ) return; + }else{ + bufpt = buf; + } + j = 0; + if( needQuote ) bufpt[j++] = q; + for(i=0; (ch=escarg[i])!=0; i++){ + bufpt[j++] = ch; + if( ch==q ) bufpt[j++] = ch; + } + if( needQuote ) bufpt[j++] = q; + bufpt[j] = 0; + length = j; + /* The precision is ignored on %q and %Q */ + /* if( precision>=0 && precisionz ){ + sqlite3StrAccumAppend(pAccum, (const char*)pToken->z, pToken->n); + } + length = width = 0; + break; + } + case etSRCLIST: { + SrcList *pSrc = va_arg(ap, SrcList*); + int k = va_arg(ap, int); + SrcList::SrcList_item *pItem = &pSrc->a[k]; + assert( k>=0 && knSrc ); + if( pItem->zDatabase && pItem->zDatabase[0] ){ + sqlite3StrAccumAppend(pAccum, pItem->zDatabase, -1); + sqlite3StrAccumAppend(pAccum, ".", 1); + } + sqlite3StrAccumAppend(pAccum, pItem->zName, -1); + length = width = 0; + break; + } + }/* End switch over the format type */ + /* + ** The text of the conversion is pointed to by "bufpt" and is + ** "length" characters long. The field width is "width". Do + ** the output. + */ + if( !flag_leftjustify ){ + register int nspace; + nspace = width-length; + if( nspace>0 ){ + appendSpace(pAccum, nspace); + } + } + if( length>0 ){ + sqlite3StrAccumAppend(pAccum, bufpt, length); + } + if( flag_leftjustify ){ + register int nspace; + nspace = width-length; + if( nspace>0 ){ + appendSpace(pAccum, nspace); + } + } + if( zExtra ){ + sqlite3_free(zExtra); + } + }/* End for loop over the format string */ +} /* End of function */ + +/* +** Append N bytes of text from z to the StrAccum object. +*/ +void sqlite3StrAccumAppend(StrAccum *p, const char *z, int N){ + if( p->tooBig | p->mallocFailed ){ + return; + } + if( N<0 ){ + N = strlen(z); + } + if( N==0 ){ + return; + } + if( p->nChar+N >= p->nAlloc ){ + char *zNew; + if( !p->useMalloc ){ + p->tooBig = 1; + N = p->nAlloc - p->nChar - 1; + if( N<=0 ){ + return; + } + }else{ + p->nAlloc += p->nAlloc + N + 1; + if( p->nAlloc > SQLITE_MAX_LENGTH ){ + p->nAlloc = SQLITE_MAX_LENGTH; + if( p->nChar+N >= p->nAlloc ){ + sqlite3StrAccumReset(p); + p->tooBig = 1; + return; + } + } + zNew = (char*)sqlite3_malloc( p->nAlloc ); + if( zNew ){ + memcpy(zNew, p->zText, p->nChar); + sqlite3StrAccumReset(p); + p->zText = zNew; + }else{ + p->mallocFailed = 1; + sqlite3StrAccumReset(p); + return; + } + } + } + memcpy(&p->zText[p->nChar], z, N); + p->nChar += N; +} + +/* +** Finish off a string by making sure it is zero-terminated. +** Return a pointer to the resulting string. Return a NULL +** pointer if any kind of error was encountered. +*/ +char *sqlite3StrAccumFinish(StrAccum *p){ + if( p->zText ){ + p->zText[p->nChar] = 0; + if( p->useMalloc && p->zText==p->zBase ){ + p->zText = (char*)sqlite3_malloc( p->nChar+1 ); + if( p->zText ){ + memcpy(p->zText, p->zBase, p->nChar+1); + }else{ + p->mallocFailed = 1; + } + } + } + return p->zText; +} + +/* +** Reset an StrAccum string. Reclaim all malloced memory. +*/ +void sqlite3StrAccumReset(StrAccum *p){ + if( p->zText!=p->zBase ){ + sqlite3_free(p->zText); + p->zText = 0; + } +} + +/* +** Initialize a string accumulator +*/ +static void sqlite3StrAccumInit(StrAccum *p, char *zBase, int n){ + p->zText = p->zBase = zBase; + p->nChar = 0; + p->nAlloc = n; + p->useMalloc = 1; + p->tooBig = 0; + p->mallocFailed = 0; +} + +/* +** Print into memory obtained from sqliteMalloc(). Use the internal +** %-conversion extensions. +*/ +char *sqlite3VMPrintf(sqlite3 *db, const char *zFormat, va_list ap){ + char *z; + char zBase[SQLITE_PRINT_BUF_SIZE]; + StrAccum acc; + sqlite3StrAccumInit(&acc, zBase, sizeof(zBase)); + vxprintf(&acc, 1, zFormat, ap); + z = sqlite3StrAccumFinish(&acc); + if( acc.mallocFailed && db ){ + db->mallocFailed = 1; + } + return z; +} + +/* +** Print into memory obtained from sqliteMalloc(). Use the internal +** %-conversion extensions. +*/ +char *sqlite3MPrintf(sqlite3 *db, const char *zFormat, ...){ + va_list ap; + char *z; + va_start(ap, zFormat); + z = sqlite3VMPrintf(db, zFormat, ap); + va_end(ap); + return z; +} + +/* +** Print into memory obtained from sqlite3_malloc(). Omit the internal +** %-conversion extensions. +*/ +EXPORT_C char *sqlite3_vmprintf(const char *zFormat, va_list ap){ + char *z; + char zBase[SQLITE_PRINT_BUF_SIZE]; + StrAccum acc; + sqlite3StrAccumInit(&acc, zBase, sizeof(zBase)); + vxprintf(&acc, 0, zFormat, ap); + z = sqlite3StrAccumFinish(&acc); + return z; +} + +/* +** Print into memory obtained from sqlite3_malloc()(). Omit the internal +** %-conversion extensions. +*/ +EXPORT_C char *sqlite3_mprintf(const char *zFormat, ...){ + va_list ap; + char *z; + va_start(ap, zFormat); + z = sqlite3_vmprintf(zFormat, ap); + va_end(ap); + return z; +} + +/* +** sqlite3_snprintf() works like snprintf() except that it ignores the +** current locale settings. This is important for SQLite because we +** are not able to use a "," as the decimal point in place of "." as +** specified by some locales. +*/ +EXPORT_C char *sqlite3_snprintf(int n, char *zBuf, const char *zFormat, ...){ + char *z; + va_list ap; + StrAccum acc; + + if( n<=0 ){ + return zBuf; + } + sqlite3StrAccumInit(&acc, zBuf, n); + acc.useMalloc = 0; + va_start(ap,zFormat); + vxprintf(&acc, 0, zFormat, ap); + va_end(ap); + z = sqlite3StrAccumFinish(&acc); + return z; +} + +#if defined(SQLITE_TEST) || defined(SQLITE_DEBUG) || defined(SQLITE_MEMDEBUG) +/* +** A version of printf() that understands %lld. Used for debugging. +** The printf() built into some versions of windows does not understand %lld +** and segfaults if you give it a long long int. +*/ +void sqlite3DebugPrintf(const char *zFormat, ...){ + va_list ap; + StrAccum acc; + char zBuf[500]; + sqlite3StrAccumInit(&acc, zBuf, sizeof(zBuf)); + acc.useMalloc = 0; + va_start(ap,zFormat); + vxprintf(&acc, 0, zFormat, ap); + va_end(ap); + sqlite3StrAccumFinish(&acc); + fprintf(stdout,"%s", zBuf); + fflush(stdout); +} +#endif diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/random.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/random.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,103 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code to implement a pseudo-random number +** generator (PRNG) for SQLite. +** +** Random numbers are used by some of the database backends in order +** to generate random integer keys for tables or random filenames. +** +** $Id: random.cpp 1282 2008-11-13 09:31:33Z LarsPson $ +*/ +#include "sqliteInt.h" + + +/* +** Get a single 8-bit random value from the RC4 PRNG. The Mutex +** must be held while executing this routine. +** +** Why not just use a library random generator like lrand48() for this? +** Because the OP_NewRowid opcode in the VDBE depends on having a very +** good source of random numbers. The lrand48() library function may +** well be good enough. But maybe not. Or maybe lrand48() has some +** subtle problems on some systems that could cause problems. It is hard +** to know. To minimize the risk of problems due to bad lrand48() +** implementations, SQLite uses this random number generator based +** on RC4, which we know works very well. +** +** (Later): Actually, OP_NewRowid does not depend on a good source of +** randomness any more. But we will leave this code in all the same. +*/ +static int randomByte(void){ + unsigned char t; + + /* All threads share a single random number generator. + ** This structure is the current state of the generator. + */ + static struct { + unsigned char isInit; /* True if initialized */ + unsigned char i, j; /* State variables */ + unsigned char s[256]; /* State variables */ + } prng; + + /* Initialize the state of the random number generator once, + ** the first time this routine is called. The seed value does + ** not need to contain a lot of randomness since we are not + ** trying to do secure encryption or anything like that... + ** + ** Nothing in this file or anywhere else in SQLite does any kind of + ** encryption. The RC4 algorithm is being used as a PRNG (pseudo-random + ** number generator) not as an encryption device. + */ + if( !prng.isInit ){ + int i; + char k[256]; + prng.j = 0; + prng.i = 0; + sqlite3OsRandomness(sqlite3_vfs_find(0), 256, k); + for(i=0; i<256; i++){ + prng.s[i] = i; + } + for(i=0; i<256; i++){ + prng.j += prng.s[i] + k[i]; + t = prng.s[prng.j]; + prng.s[prng.j] = prng.s[i]; + prng.s[i] = t; + } + prng.isInit = 1; + } + + /* Generate and return single random byte + */ + prng.i++; + t = prng.s[prng.i]; + prng.j += t; + prng.s[prng.i] = prng.s[prng.j]; + prng.s[prng.j] = t; + t += prng.s[prng.i]; + return prng.s[t]; +} + +/* +** Return N random bytes. +*/ +void sqlite3Randomness(int N, void *pBuf){ + unsigned char *zBuf = (unsigned char*)pBuf; + static sqlite3_mutex *mutex = 0; + if( mutex==0 ){ + mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_PRNG); + } + sqlite3_mutex_enter(mutex); + while( N-- ){ + *(zBuf++) = randomByte(); + } + sqlite3_mutex_leave(mutex); +} diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/select.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/select.cpp Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,3667 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains C code routines that are called by the parser +** to handle SELECT statements in SQLite. +** +** $Id: select.cpp 1282 2008-11-13 09:31:33Z LarsPson $ +*/ +#include "sqliteInt.h" + + +/* +** Delete all the content of a Select structure but do not deallocate +** the select structure itself. +*/ +static void clearSelect(Select *p){ + sqlite3ExprListDelete(p->pEList); + sqlite3SrcListDelete(p->pSrc); + sqlite3ExprDelete(p->pWhere); + sqlite3ExprListDelete(p->pGroupBy); + sqlite3ExprDelete(p->pHaving); + sqlite3ExprListDelete(p->pOrderBy); + sqlite3SelectDelete(p->pPrior); + sqlite3ExprDelete(p->pLimit); + sqlite3ExprDelete(p->pOffset); +} + + +/* +** Allocate a new Select structure and return a pointer to that +** structure. +*/ +Select *sqlite3SelectNew( + Parse *pParse, /* Parsing context */ + ExprList *pEList, /* which columns to include in the result */ + SrcList *pSrc, /* the FROM clause -- which tables to scan */ + Expr *pWhere, /* the WHERE clause */ + ExprList *pGroupBy, /* the GROUP BY clause */ + Expr *pHaving, /* the HAVING clause */ + ExprList *pOrderBy, /* the ORDER BY clause */ + int isDistinct, /* true if the DISTINCT keyword is present */ + Expr *pLimit, /* LIMIT value. NULL means not used */ + Expr *pOffset /* OFFSET value. NULL means no offset */ +){ + Select *pNew; + Select standin; + sqlite3 *db = pParse->db; + pNew = (Select*)sqlite3DbMallocZero(db, sizeof(*pNew) ); + assert( !pOffset || pLimit ); /* Can't have OFFSET without LIMIT. */ + if( pNew==0 ){ + pNew = &standin; + memset(pNew, 0, sizeof(*pNew)); + } + if( pEList==0 ){ + pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db,TK_ALL,0,0,0), 0); + } + pNew->pEList = pEList; + pNew->pSrc = pSrc; + pNew->pWhere = pWhere; + pNew->pGroupBy = pGroupBy; + pNew->pHaving = pHaving; + pNew->pOrderBy = pOrderBy; + pNew->isDistinct = isDistinct; + pNew->op = TK_SELECT; + assert( pOffset==0 || pLimit!=0 ); + pNew->pLimit = pLimit; + pNew->pOffset = pOffset; + pNew->iLimit = -1; + pNew->iOffset = -1; + pNew->addrOpenEphm[0] = -1; + pNew->addrOpenEphm[1] = -1; + pNew->addrOpenEphm[2] = -1; + if( pNew==&standin) { + clearSelect(pNew); + pNew = 0; + } + return pNew; +} + +/* +** Delete the given Select structure and all of its substructures. +*/ +void sqlite3SelectDelete(Select *p){ + if( p ){ + clearSelect(p); + sqlite3_free(p); + } +} + +/* +** Given 1 to 3 identifiers preceeding the JOIN keyword, determine the +** type of join. Return an integer constant that expresses that type +** in terms of the following bit values: +** +** JT_INNER +** JT_CROSS +** JT_OUTER +** JT_NATURAL +** JT_LEFT +** JT_RIGHT +** +** A full outer join is the combination of JT_LEFT and JT_RIGHT. +** +** If an illegal or unsupported join type is seen, then still return +** a join type, but put an error in the pParse structure. +*/ +int sqlite3JoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){ + int jointype = 0; + Token *apAll[3]; + Token *p; + static const struct { + const char zKeyword[8]; + u8 nChar; + u8 code; + } keywords[] = { + { "natural", 7, JT_NATURAL }, + { "left", 4, JT_LEFT|JT_OUTER }, + { "right", 5, JT_RIGHT|JT_OUTER }, + { "full", 4, JT_LEFT|JT_RIGHT|JT_OUTER }, + { "outer", 5, JT_OUTER }, + { "inner", 5, JT_INNER }, + { "cross", 5, JT_INNER|JT_CROSS }, + }; + int i, j; + apAll[0] = pA; + apAll[1] = pB; + apAll[2] = pC; + for(i=0; i<3 && apAll[i]; i++){ + p = apAll[i]; + for(j=0; jn==keywords[j].nChar + && sqlite3StrNICmp((char*)p->z, keywords[j].zKeyword, p->n)==0 ){ + jointype |= keywords[j].code; + break; + } + } + if( j>=sizeof(keywords)/sizeof(keywords[0]) ){ + jointype |= JT_ERROR; + break; + } + } + if( + (jointype & (JT_INNER|JT_OUTER))==(JT_INNER|JT_OUTER) || + (jointype & JT_ERROR)!=0 + ){ + const char *zSp1 = " "; + const char *zSp2 = " "; + if( pB==0 ){ zSp1++; } + if( pC==0 ){ zSp2++; } + sqlite3ErrorMsg(pParse, "unknown or unsupported join type: " + "%T%s%T%s%T", pA, zSp1, pB, zSp2, pC); + jointype = JT_INNER; + }else if( jointype & JT_RIGHT ){ + sqlite3ErrorMsg(pParse, + "RIGHT and FULL OUTER JOINs are not currently supported"); + jointype = JT_INNER; + } + return jointype; +} + +/* +** Return the index of a column in a table. Return -1 if the column +** is not contained in the table. +*/ +static int columnIndex(Table *pTab, const char *zCol){ + int i; + for(i=0; inCol; i++){ + if( sqlite3StrICmp(pTab->aCol[i].zName, zCol)==0 ) return i; + } + return -1; +} + +/* +** Set the value of a token to a '\000'-terminated string. +*/ +static void setToken(Token *p, const char *z){ + p->z = (u8*)z; + p->n = z ? strlen(z) : 0; + p->dyn = 0; +} + +/* +** Set the token to the double-quoted and escaped version of the string pointed +** to by z. For example; +** +** {a"bc} -> {"a""bc"} +*/ +static void setQuotedToken(Parse *pParse, Token *p, const char *z){ + p->z = (u8 *)sqlite3MPrintf(0, "\"%w\"", z); + p->dyn = 1; + if( p->z ){ + p->n = strlen((char *)p->z); + }else{ + pParse->db->mallocFailed = 1; + } +} + +/* +** Create an expression node for an identifier with the name of zName +*/ +Expr *sqlite3CreateIdExpr(Parse *pParse, const char *zName){ + Token dummy; + setToken(&dummy, zName); + return sqlite3PExpr(pParse, TK_ID, 0, 0, &dummy); +} + + +/* +** Add a term to the WHERE expression in *ppExpr that requires the +** zCol column to be equal in the two tables pTab1 and pTab2. +*/ +static void addWhereTerm( + Parse *pParse, /* Parsing context */ + const char *zCol, /* Name of the column */ + const Table *pTab1, /* First table */ + const char *zAlias1, /* Alias for first table. May be NULL */ + const Table *pTab2, /* Second table */ + const char *zAlias2, /* Alias for second table. May be NULL */ + int iRightJoinTable, /* VDBE cursor for the right table */ + Expr **ppExpr /* Add the equality term to this expression */ +){ + Expr *pE1a, *pE1b, *pE1c; + Expr *pE2a, *pE2b, *pE2c; + Expr *pE; + + pE1a = sqlite3CreateIdExpr(pParse, zCol); + pE2a = sqlite3CreateIdExpr(pParse, zCol); + if( zAlias1==0 ){ + zAlias1 = pTab1->zName; + } + pE1b = sqlite3CreateIdExpr(pParse, zAlias1); + if( zAlias2==0 ){ + zAlias2 = pTab2->zName; + } + pE2b = sqlite3CreateIdExpr(pParse, zAlias2); + pE1c = sqlite3PExpr(pParse, TK_DOT, pE1b, pE1a, 0); + pE2c = sqlite3PExpr(pParse, TK_DOT, pE2b, pE2a, 0); + pE = sqlite3PExpr(pParse, TK_EQ, pE1c, pE2c, 0); + if( pE ){ + ExprSetProperty(pE, EP_FromJoin); + pE->iRightJoinTable = iRightJoinTable; + } + *ppExpr = sqlite3ExprAnd(pParse->db,*ppExpr, pE); +} + +/* +** Set the EP_FromJoin property on all terms of the given expression. +** And set the Expr.iRightJoinTable to iTable for every term in the +** expression. +** +** The EP_FromJoin property is used on terms of an expression to tell +** the LEFT OUTER JOIN processing logic that this term is part of the +** join restriction specified in the ON or USING clause and not a part +** of the more general WHERE clause. These terms are moved over to the +** WHERE clause during join processing but we need to remember that they +** originated in the ON or USING clause. +** +** The Expr.iRightJoinTable tells the WHERE clause processing that the +** expression depends on table iRightJoinTable even if that table is not +** explicitly mentioned in the expression. That information is needed +** for cases like this: +** +** SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.b AND t1.x=5 +** +** The where clause needs to defer the handling of the t1.x=5 +** term until after the t2 loop of the join. In that way, a +** NULL t2 row will be inserted whenever t1.x!=5. If we do not +** defer the handling of t1.x=5, it will be processed immediately +** after the t1 loop and rows with t1.x!=5 will never appear in +** the output, which is incorrect. +*/ +static void setJoinExpr(Expr *p, int iTable){ + while( p ){ + ExprSetProperty(p, EP_FromJoin); + p->iRightJoinTable = iTable; + setJoinExpr(p->pLeft, iTable); + p = p->pRight; + } +} + +/* +** This routine processes the join information for a SELECT statement. +** ON and USING clauses are converted into extra terms of the WHERE clause. +** NATURAL joins also create extra WHERE clause terms. +** +** The terms of a FROM clause are contained in the Select.pSrc structure. +** The left most table is the first entry in Select.pSrc. The right-most +** table is the last entry. The join operator is held in the entry to +** the left. Thus entry 0 contains the join operator for the join between +** entries 0 and 1. Any ON or USING clauses associated with the join are +** also attached to the left entry. +** +** This routine returns the number of errors encountered. +*/ +static int sqliteProcessJoin(Parse *pParse, Select *p){ + SrcList *pSrc; /* All tables in the FROM clause */ + int i, j; /* Loop counters */ + SrcList::SrcList_item *pLeft; /* Left table being joined */ + SrcList::SrcList_item *pRight; /* Right table being joined */ + + pSrc = p->pSrc; + pLeft = &pSrc->a[0]; + pRight = &pLeft[1]; + for(i=0; inSrc-1; i++, pRight++, pLeft++){ + Table *pLeftTab = pLeft->pTab; + Table *pRightTab = pRight->pTab; + + if( pLeftTab==0 || pRightTab==0 ) continue; + + /* When the NATURAL keyword is present, add WHERE clause terms for + ** every column that the two tables have in common. + */ + if( pRight->jointype & JT_NATURAL ){ + if( pRight->pOn || pRight->pUsing ){ + sqlite3ErrorMsg(pParse, "a NATURAL join may not have " + "an ON or USING clause", 0); + return 1; + } + for(j=0; jnCol; j++){ + char *zName = pLeftTab->aCol[j].zName; + if( columnIndex(pRightTab, zName)>=0 ){ + addWhereTerm(pParse, zName, pLeftTab, pLeft->zAlias, + pRightTab, pRight->zAlias, + pRight->iCursor, &p->pWhere); + + } + } + } + + /* Disallow both ON and USING clauses in the same join + */ + if( pRight->pOn && pRight->pUsing ){ + sqlite3ErrorMsg(pParse, "cannot have both ON and USING " + "clauses in the same join"); + return 1; + } + + /* Add the ON clause to the end of the WHERE clause, connected by + ** an AND operator. + */ + if( pRight->pOn ){ + setJoinExpr(pRight->pOn, pRight->iCursor); + p->pWhere = sqlite3ExprAnd(pParse->db, p->pWhere, pRight->pOn); + pRight->pOn = 0; + } + + /* Create extra terms on the WHERE clause for each column named + ** in the USING clause. Example: If the two tables to be joined are + ** A and B and the USING clause names X, Y, and Z, then add this + ** to the WHERE clause: A.X=B.X AND A.Y=B.Y AND A.Z=B.Z + ** Report an error if any column mentioned in the USING clause is + ** not contained in both tables to be joined. + */ + if( pRight->pUsing ){ + IdList *pList = pRight->pUsing; + for(j=0; jnId; j++){ + char *zName = pList->a[j].zName; + if( columnIndex(pLeftTab, zName)<0 || columnIndex(pRightTab, zName)<0 ){ + sqlite3ErrorMsg(pParse, "cannot join using column %s - column " + "not present in both tables", zName); + return 1; + } + addWhereTerm(pParse, zName, pLeftTab, pLeft->zAlias, + pRightTab, pRight->zAlias, + pRight->iCursor, &p->pWhere); + } + } + } + return 0; +} + +/* +** Insert code into "v" that will push the record on the top of the +** stack into the sorter. +*/ +static void pushOntoSorter( + Parse *pParse, /* Parser context */ + ExprList *pOrderBy, /* The ORDER BY clause */ + Select *pSelect /* The whole SELECT statement */ +){ + Vdbe *v = pParse->pVdbe; + sqlite3ExprCodeExprList(pParse, pOrderBy); + sqlite3VdbeAddOp(v, OP_Sequence, pOrderBy->iECursor, 0); + sqlite3VdbeAddOp(v, OP_Pull, pOrderBy->nExpr + 1, 0); + sqlite3VdbeAddOp(v, OP_MakeRecord, pOrderBy->nExpr + 2, 0); + sqlite3VdbeAddOp(v, OP_IdxInsert, pOrderBy->iECursor, 0); + if( pSelect->iLimit>=0 ){ + int addr1, addr2; + addr1 = sqlite3VdbeAddOp(v, OP_IfMemZero, pSelect->iLimit+1, 0); + sqlite3VdbeAddOp(v, OP_MemIncr, -1, pSelect->iLimit+1); + addr2 = sqlite3VdbeAddOp(v, OP_Goto, 0, 0); + sqlite3VdbeJumpHere(v, addr1); + sqlite3VdbeAddOp(v, OP_Last, pOrderBy->iECursor, 0); + sqlite3VdbeAddOp(v, OP_Delete, pOrderBy->iECursor, 0); + sqlite3VdbeJumpHere(v, addr2); + pSelect->iLimit = -1; + } +} + +/* +** Add code to implement the OFFSET +*/ +static void codeOffset( + Vdbe *v, /* Generate code into this VM */ + Select *p, /* The SELECT statement being coded */ + int iContinue, /* Jump here to skip the current record */ + int nPop /* Number of times to pop stack when jumping */ +){ + if( p->iOffset>=0 && iContinue!=0 ){ + int addr; + sqlite3VdbeAddOp(v, OP_MemIncr, -1, p->iOffset); + addr = sqlite3VdbeAddOp(v, OP_IfMemNeg, p->iOffset, 0); + if( nPop>0 ){ + sqlite3VdbeAddOp(v, OP_Pop, nPop, 0); + } + sqlite3VdbeAddOp(v, OP_Goto, 0, iContinue); + VdbeComment((v, "# skip OFFSET records")); + sqlite3VdbeJumpHere(v, addr); + } +} + +/* +** Add code that will check to make sure the top N elements of the +** stack are distinct. iTab is a sorting index that holds previously +** seen combinations of the N values. A new entry is made in iTab +** if the current N values are new. +** +** A jump to addrRepeat is made and the N+1 values are popped from the +** stack if the top N elements are not distinct. +*/ +static void codeDistinct( + Vdbe *v, /* Generate code into this VM */ + int iTab, /* A sorting index used to test for distinctness */ + int addrRepeat, /* Jump to here if not distinct */ + int N /* The top N elements of the stack must be distinct */ +){ + sqlite3VdbeAddOp(v, OP_MakeRecord, -N, 0); + sqlite3VdbeAddOp(v, OP_Distinct, iTab, sqlite3VdbeCurrentAddr(v)+3); + sqlite3VdbeAddOp(v, OP_Pop, N+1, 0); + sqlite3VdbeAddOp(v, OP_Goto, 0, addrRepeat); + VdbeComment((v, "# skip indistinct records")); + sqlite3VdbeAddOp(v, OP_IdxInsert, iTab, 0); +} + +/* +** Generate an error message when a SELECT is used within a subexpression +** (example: "a IN (SELECT * FROM table)") but it has more than 1 result +** column. We do this in a subroutine because the error occurs in multiple +** places. +*/ +static int checkForMultiColumnSelectError(Parse *pParse, int eDest, int nExpr){ + if( nExpr>1 && (eDest==SRT_Mem || eDest==SRT_Set) ){ + sqlite3ErrorMsg(pParse, "only a single result allowed for " + "a SELECT that is part of an expression"); + return 1; + }else{ + return 0; + } +} + +/* +** This routine generates the code for the inside of the inner loop +** of a SELECT. +** +** If srcTab and nColumn are both zero, then the pEList expressions +** are evaluated in order to get the data for this row. If nColumn>0 +** then data is pulled from srcTab and pEList is used only to get the +** datatypes for each column. +*/ +static int selectInnerLoop( + Parse *pParse, /* The parser context */ + Select *p, /* The complete select statement being coded */ + ExprList *pEList, /* List of values being extracted */ + int srcTab, /* Pull data from this table */ + int nColumn, /* Number of columns in the source table */ + ExprList *pOrderBy, /* If not NULL, sort results using this key */ + int distinct, /* If >=0, make sure results are distinct */ + int eDest, /* How to dispose of the results */ + int iParm, /* An argument to the disposal method */ + int iContinue, /* Jump here to continue with next row */ + int iBreak, /* Jump here to break out of the inner loop */ + char *aff /* affinity string if eDest is SRT_Union */ +){ + Vdbe *v = pParse->pVdbe; + int i; + int hasDistinct; /* True if the DISTINCT keyword is present */ + + if( v==0 ) return 0; + assert( pEList!=0 ); + + /* If there was a LIMIT clause on the SELECT statement, then do the check + ** to see if this row should be output. + */ + hasDistinct = distinct>=0 && pEList->nExpr>0; + if( pOrderBy==0 && !hasDistinct ){ + codeOffset(v, p, iContinue, 0); + } + + /* Pull the requested columns. + */ + if( nColumn>0 ){ + for(i=0; inExpr; + sqlite3ExprCodeExprList(pParse, pEList); + } + + /* If the DISTINCT keyword was present on the SELECT statement + ** and this row has been seen before, then do not make this row + ** part of the result. + */ + if( hasDistinct ){ + assert( pEList!=0 ); + assert( pEList->nExpr==nColumn ); + codeDistinct(v, distinct, iContinue, nColumn); + if( pOrderBy==0 ){ + codeOffset(v, p, iContinue, nColumn); + } + } + + if( checkForMultiColumnSelectError(pParse, eDest, pEList->nExpr) ){ + return 0; + } + + switch( eDest ){ + /* In this mode, write each query result to the key of the temporary + ** table iParm. + */ +#ifndef SQLITE_OMIT_COMPOUND_SELECT + case SRT_Union: { + sqlite3VdbeAddOp(v, OP_MakeRecord, nColumn, 0); + if( aff ){ + sqlite3VdbeChangeP3(v, -1, aff, P3_STATIC); + } + sqlite3VdbeAddOp(v, OP_IdxInsert, iParm, 0); + break; + } + + /* Construct a record from the query result, but instead of + ** saving that record, use it as a key to delete elements from + ** the temporary table iParm. + */ + case SRT_Except: { + int addr; + addr = sqlite3VdbeAddOp(v, OP_MakeRecord, nColumn, 0); + sqlite3VdbeChangeP3(v, -1, aff, P3_STATIC); + sqlite3VdbeAddOp(v, OP_NotFound, iParm, addr+3); + sqlite3VdbeAddOp(v, OP_Delete, iParm, 0); + break; + } +#endif + + /* Store the result as data using a unique key. + */ + case SRT_Table: + case SRT_EphemTab: { + sqlite3VdbeAddOp(v, OP_MakeRecord, nColumn, 0); + if( pOrderBy ){ + pushOntoSorter(pParse, pOrderBy, p); + }else{ + sqlite3VdbeAddOp(v, OP_NewRowid, iParm, 0); + sqlite3VdbeAddOp(v, OP_Pull, 1, 0); + sqlite3VdbeAddOp(v, OP_Insert, iParm, OPFLAG_APPEND); + } + break; + } + +#ifndef SQLITE_OMIT_SUBQUERY + /* If we are creating a set for an "expr IN (SELECT ...)" construct, + ** then there should be a single item on the stack. Write this + ** item into the set table with bogus data. + */ + case SRT_Set: { + int addr1 = sqlite3VdbeCurrentAddr(v); + int addr2; + + assert( nColumn==1 ); + sqlite3VdbeAddOp(v, OP_NotNull, -1, addr1+3); + sqlite3VdbeAddOp(v, OP_Pop, 1, 0); + addr2 = sqlite3VdbeAddOp(v, OP_Goto, 0, 0); + p->affinity = sqlite3CompareAffinity(pEList->a[0].pExpr,(iParm>>16)&0xff); + if( pOrderBy ){ + /* At first glance you would think we could optimize out the + ** ORDER BY in this case since the order of entries in the set + ** does not matter. But there might be a LIMIT clause, in which + ** case the order does matter */ + pushOntoSorter(pParse, pOrderBy, p); + }else{ + sqlite3VdbeOp3(v, OP_MakeRecord, 1, 0, &p->affinity, 1); + sqlite3VdbeAddOp(v, OP_IdxInsert, (iParm&0x0000FFFF), 0); + } + sqlite3VdbeJumpHere(v, addr2); + break; + } + + /* If any row exist in the result set, record that fact and abort. + */ + case SRT_Exists: { + sqlite3VdbeAddOp(v, OP_MemInt, 1, iParm); + sqlite3VdbeAddOp(v, OP_Pop, nColumn, 0); + /* The LIMIT clause will terminate the loop for us */ + break; + } + + /* If this is a scalar select that is part of an expression, then + ** store the results in the appropriate memory cell and break out + ** of the scan loop. + */ + case SRT_Mem: { + assert( nColumn==1 ); + if( pOrderBy ){ + pushOntoSorter(pParse, pOrderBy, p); + }else{ + sqlite3VdbeAddOp(v, OP_MemStore, iParm, 1); + /* The LIMIT clause will jump out of the loop for us */ + } + break; + } +#endif /* #ifndef SQLITE_OMIT_SUBQUERY */ + + /* Send the data to the callback function or to a subroutine. In the + ** case of a subroutine, the subroutine itself is responsible for + ** popping the data from the stack. + */ + case SRT_Subroutine: + case SRT_Callback: { + if( pOrderBy ){ + sqlite3VdbeAddOp(v, OP_MakeRecord, nColumn, 0); + pushOntoSorter(pParse, pOrderBy, p); + }else if( eDest==SRT_Subroutine ){ + sqlite3VdbeAddOp(v, OP_Gosub, 0, iParm); + }else{ + sqlite3VdbeAddOp(v, OP_Callback, nColumn, 0); + } + break; + } + +#if !defined(SQLITE_OMIT_TRIGGER) + /* Discard the results. This is used for SELECT statements inside + ** the body of a TRIGGER. The purpose of such selects is to call + ** user-defined functions that have side effects. We do not care + ** about the actual results of the select. + */ + default: { + assert( eDest==SRT_Discard ); + sqlite3VdbeAddOp(v, OP_Pop, nColumn, 0); + break; + } +#endif + } + + /* Jump to the end of the loop if the LIMIT is reached. + */ + if( p->iLimit>=0 && pOrderBy==0 ){ + sqlite3VdbeAddOp(v, OP_MemIncr, -1, p->iLimit); + sqlite3VdbeAddOp(v, OP_IfMemZero, p->iLimit, iBreak); + } + return 0; +} + +/* +** Given an expression list, generate a KeyInfo structure that records +** the collating sequence for each expression in that expression list. +** +** If the ExprList is an ORDER BY or GROUP BY clause then the resulting +** KeyInfo structure is appropriate for initializing a virtual index to +** implement that clause. If the ExprList is the result set of a SELECT +** then the KeyInfo structure is appropriate for initializing a virtual +** index to implement a DISTINCT test. +** +** Space to hold the KeyInfo structure is obtain from malloc. The calling +** function is responsible for seeing that this structure is eventually +** freed. Add the KeyInfo structure to the P3 field of an opcode using +** P3_KEYINFO_HANDOFF is the usual way of dealing with this. +*/ +static KeyInfo *keyInfoFromExprList(Parse *pParse, ExprList *pList){ + sqlite3 *db = pParse->db; + int nExpr; + KeyInfo *pInfo; + ExprList::ExprList_item *pItem; + int i; + + nExpr = pList->nExpr; + pInfo = (KeyInfo*)sqlite3DbMallocZero(db, sizeof(*pInfo) + nExpr*(sizeof(CollSeq*)+1) ); + if( pInfo ){ + pInfo->aSortOrder = (u8*)&pInfo->aColl[nExpr]; + pInfo->nField = nExpr; + pInfo->enc = ENC(db); + for(i=0, pItem=pList->a; ipExpr); + if( !pColl ){ + pColl = db->pDfltColl; + } + pInfo->aColl[i] = pColl; + pInfo->aSortOrder[i] = pItem->sortOrder; + } + } + return pInfo; +} + + +/* +** If the inner loop was generated using a non-null pOrderBy argument, +** then the results were placed in a sorter. After the loop is terminated +** we need to run the sorter and output the results. The following +** routine generates the code needed to do that. +*/ +static void generateSortTail( + Parse *pParse, /* Parsing context */ + Select *p, /* The SELECT statement */ + Vdbe *v, /* Generate code into this VDBE */ + int nColumn, /* Number of columns of data */ + int eDest, /* Write the sorted results here */ + int iParm /* Optional parameter associated with eDest */ +){ + int brk = sqlite3VdbeMakeLabel(v); + int cont = sqlite3VdbeMakeLabel(v); + int addr; + int iTab; + int pseudoTab = 0; + ExprList *pOrderBy = p->pOrderBy; + + iTab = pOrderBy->iECursor; + if( eDest==SRT_Callback || eDest==SRT_Subroutine ){ + pseudoTab = pParse->nTab++; + sqlite3VdbeAddOp(v, OP_OpenPseudo, pseudoTab, 0); + sqlite3VdbeAddOp(v, OP_SetNumColumns, pseudoTab, nColumn); + } + addr = 1 + sqlite3VdbeAddOp(v, OP_Sort, iTab, brk); + codeOffset(v, p, cont, 0); + if( eDest==SRT_Callback || eDest==SRT_Subroutine ){ + sqlite3VdbeAddOp(v, OP_Integer, 1, 0); + } + sqlite3VdbeAddOp(v, OP_Column, iTab, pOrderBy->nExpr + 1); + switch( eDest ){ + case SRT_Table: + case SRT_EphemTab: { + sqlite3VdbeAddOp(v, OP_NewRowid, iParm, 0); + sqlite3VdbeAddOp(v, OP_Pull, 1, 0); + sqlite3VdbeAddOp(v, OP_Insert, iParm, OPFLAG_APPEND); + break; + } +#ifndef SQLITE_OMIT_SUBQUERY + case SRT_Set: { + assert( nColumn==1 ); + sqlite3VdbeAddOp(v, OP_NotNull, -1, sqlite3VdbeCurrentAddr(v)+3); + sqlite3VdbeAddOp(v, OP_Pop, 1, 0); + sqlite3VdbeAddOp(v, OP_Goto, 0, sqlite3VdbeCurrentAddr(v)+3); + sqlite3VdbeOp3(v, OP_MakeRecord, 1, 0, &p->affinity, 1); + sqlite3VdbeAddOp(v, OP_IdxInsert, (iParm&0x0000FFFF), 0); + break; + } + case SRT_Mem: { + assert( nColumn==1 ); + sqlite3VdbeAddOp(v, OP_MemStore, iParm, 1); + /* The LIMIT clause will terminate the loop for us */ + break; + } +#endif + case SRT_Callback: + case SRT_Subroutine: { + int i; + sqlite3VdbeAddOp(v, OP_Insert, pseudoTab, 0); + for(i=0; iiLimit>=0 ){ + sqlite3VdbeAddOp(v, OP_MemIncr, -1, p->iLimit); + sqlite3VdbeAddOp(v, OP_IfMemZero, p->iLimit, brk); + } + + /* The bottom of the loop + */ + sqlite3VdbeResolveLabel(v, cont); + sqlite3VdbeAddOp(v, OP_Next, iTab, addr); + sqlite3VdbeResolveLabel(v, brk); + if( eDest==SRT_Callback || eDest==SRT_Subroutine ){ + sqlite3VdbeAddOp(v, OP_Close, pseudoTab, 0); + } + +} + +/* +** Return a pointer to a string containing the 'declaration type' of the +** expression pExpr. The string may be treated as static by the caller. +** +** The declaration type is the exact datatype definition extracted from the +** original CREATE TABLE statement if the expression is a column. The +** declaration type for a ROWID field is INTEGER. Exactly when an expression +** is considered a column can be complex in the presence of subqueries. The +** result-set expression in all of the following SELECT statements is +** considered a column by this function. +** +** SELECT col FROM tbl; +** SELECT (SELECT col FROM tbl; +** SELECT (SELECT col FROM tbl); +** SELECT abc FROM (SELECT col AS abc FROM tbl); +** +** The declaration type for any expression other than a column is NULL. +*/ +static const char *columnType( + NameContext *pNC, + Expr *pExpr, + const char **pzOriginDb, + const char **pzOriginTab, + const char **pzOriginCol +){ + char const *zType = 0; + char const *zOriginDb = 0; + char const *zOriginTab = 0; + char const *zOriginCol = 0; + int j; + if( pExpr==0 || pNC->pSrcList==0 ) return 0; + + switch( pExpr->op ){ + case TK_AGG_COLUMN: + case TK_COLUMN: { + /* The expression is a column. Locate the table the column is being + ** extracted from in NameContext.pSrcList. This table may be real + ** database table or a subquery. + */ + Table *pTab = 0; /* Table structure column is extracted from */ + Select *pS = 0; /* Select the column is extracted from */ + int iCol = pExpr->iColumn; /* Index of column in pTab */ + while( pNC && !pTab ){ + SrcList *pTabList = pNC->pSrcList; + for(j=0;jnSrc && pTabList->a[j].iCursor!=pExpr->iTable;j++); + if( jnSrc ){ + pTab = pTabList->a[j].pTab; + pS = pTabList->a[j].pSelect; + }else{ + pNC = pNC->pNext; + } + } + + if( pTab==0 ){ + /* FIX ME: + ** This can occurs if you have something like "SELECT new.x;" inside + ** a trigger. In other words, if you reference the special "new" + ** table in the result set of a select. We do not have a good way + ** to find the actual table type, so call it "TEXT". This is really + ** something of a bug, but I do not know how to fix it. + ** + ** This code does not produce the correct answer - it just prevents + ** a segfault. See ticket #1229. + */ + zType = "TEXT"; + break; + } + + assert( pTab ); + if( pS ){ + /* The "table" is actually a sub-select or a view in the FROM clause + ** of the SELECT statement. Return the declaration type and origin + ** data for the result-set column of the sub-select. + */ + if( iCol>=0 && iColpEList->nExpr ){ + /* If iCol is less than zero, then the expression requests the + ** rowid of the sub-select or view. This expression is legal (see + ** test case misc2.2.2) - it always evaluates to NULL. + */ + NameContext sNC; + Expr *p = pS->pEList->a[iCol].pExpr; + sNC.pSrcList = pS->pSrc; + sNC.pNext = 0; + sNC.pParse = pNC->pParse; + zType = columnType(&sNC, p, &zOriginDb, &zOriginTab, &zOriginCol); + } + }else if( pTab->pSchema ){ + /* A real table */ + assert( !pS ); + if( iCol<0 ) iCol = pTab->iPKey; + assert( iCol==-1 || (iCol>=0 && iColnCol) ); + if( iCol<0 ){ + zType = "INTEGER"; + zOriginCol = "rowid"; + }else{ + zType = pTab->aCol[iCol].zType; + zOriginCol = pTab->aCol[iCol].zName; + } + zOriginTab = pTab->zName; + if( pNC->pParse ){ + int iDb = sqlite3SchemaToIndex(pNC->pParse->db, pTab->pSchema); + zOriginDb = pNC->pParse->db->aDb[iDb].zName; + } + } + break; + } +#ifndef SQLITE_OMIT_SUBQUERY + case TK_SELECT: { + /* The expression is a sub-select. Return the declaration type and + ** origin info for the single column in the result set of the SELECT + ** statement. + */ + NameContext sNC; + Select *pS = pExpr->pSelect; + Expr *p = pS->pEList->a[0].pExpr; + sNC.pSrcList = pS->pSrc; + sNC.pNext = pNC; + sNC.pParse = pNC->pParse; + zType = columnType(&sNC, p, &zOriginDb, &zOriginTab, &zOriginCol); + break; + } +#endif + } + + if( pzOriginDb ){ + assert( pzOriginTab && pzOriginCol ); + *pzOriginDb = zOriginDb; + *pzOriginTab = zOriginTab; + *pzOriginCol = zOriginCol; + } + return zType; +} + +/* +** Generate code that will tell the VDBE the declaration types of columns +** in the result set. +*/ +static void generateColumnTypes( + Parse *pParse, /* Parser context */ + SrcList *pTabList, /* List of tables */ + ExprList *pEList /* Expressions defining the result set */ +){ + Vdbe *v = pParse->pVdbe; + int i; + NameContext sNC; + sNC.pSrcList = pTabList; + sNC.pParse = pParse; + for(i=0; inExpr; i++){ + Expr *p = pEList->a[i].pExpr; + const char *zOrigDb = 0; + const char *zOrigTab = 0; + const char *zOrigCol = 0; + const char *zType = columnType(&sNC, p, &zOrigDb, &zOrigTab, &zOrigCol); + + /* The vdbe must make its own copy of the column-type and other + ** column specific strings, in case the schema is reset before this + ** virtual machine is deleted. + */ + sqlite3VdbeSetColName(v, i, COLNAME_DECLTYPE, zType, P3_TRANSIENT); + sqlite3VdbeSetColName(v, i, COLNAME_DATABASE, zOrigDb, P3_TRANSIENT); + sqlite3VdbeSetColName(v, i, COLNAME_TABLE, zOrigTab, P3_TRANSIENT); + sqlite3VdbeSetColName(v, i, COLNAME_COLUMN, zOrigCol, P3_TRANSIENT); + } +} + +/* +** Generate code that will tell the VDBE the names of columns +** in the result set. This information is used to provide the +** azCol[] values in the callback. +*/ +static void generateColumnNames( + Parse *pParse, /* Parser context */ + SrcList *pTabList, /* List of tables */ + ExprList *pEList /* Expressions defining the result set */ +){ + Vdbe *v = pParse->pVdbe; + int i, j; + sqlite3 *db = pParse->db; + int fullNames, shortNames; + +#ifndef SQLITE_OMIT_EXPLAIN + /* If this is an EXPLAIN, skip this step */ + if( pParse->explain ){ + return; + } +#endif + + assert( v!=0 ); + if( pParse->colNamesSet || v==0 || db->mallocFailed ) return; + pParse->colNamesSet = 1; + fullNames = (db->flags & SQLITE_FullColNames)!=0; + shortNames = (db->flags & SQLITE_ShortColNames)!=0; + sqlite3VdbeSetNumCols(v, pEList->nExpr); + for(i=0; inExpr; i++){ + Expr *p; + p = pEList->a[i].pExpr; + if( p==0 ) continue; + if( pEList->a[i].zName ){ + char *zName = pEList->a[i].zName; + sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, strlen(zName)); + continue; + } + if( p->op==TK_COLUMN && pTabList ){ + Table *pTab; + char *zCol; + int iCol = p->iColumn; + for(j=0; jnSrc && pTabList->a[j].iCursor!=p->iTable; j++){} + assert( jnSrc ); + pTab = pTabList->a[j].pTab; + if( iCol<0 ) iCol = pTab->iPKey; + assert( iCol==-1 || (iCol>=0 && iColnCol) ); + if( iCol<0 ){ + zCol = "rowid"; + }else{ + zCol = pTab->aCol[iCol].zName; + } + if( !shortNames && !fullNames && p->span.z && p->span.z[0] ){ + sqlite3VdbeSetColName(v, i, COLNAME_NAME, (char*)p->span.z, p->span.n); + }else if( fullNames || (!shortNames && pTabList->nSrc>1) ){ + char *zName = 0; + char *zTab; + + zTab = pTabList->a[j].zAlias; + if( fullNames || zTab==0 ) zTab = pTab->zName; + sqlite3SetString(&zName, zTab, ".", zCol, (char*)0); + sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, P3_DYNAMIC); + }else{ + sqlite3VdbeSetColName(v, i, COLNAME_NAME, zCol, strlen(zCol)); + } + }else if( p->span.z && p->span.z[0] ){ + sqlite3VdbeSetColName(v, i, COLNAME_NAME, (char*)p->span.z, p->span.n); + /* sqlite3VdbeCompressSpace(v, addr); */ + }else{ + char zName[30]; + assert( p->op!=TK_COLUMN || pTabList==0 ); + sqlite3_snprintf(sizeof(zName), zName, "column%d", i+1); + sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, 0); + } + } + generateColumnTypes(pParse, pTabList, pEList); +} + +#ifndef SQLITE_OMIT_COMPOUND_SELECT +/* +** Name of the connection operator, used for error messages. +*/ +static const char *selectOpName(int id){ + char *z; + switch( id ){ + case TK_ALL: z = "UNION ALL"; break; + case TK_INTERSECT: z = "INTERSECT"; break; + case TK_EXCEPT: z = "EXCEPT"; break; + default: z = "UNION"; break; + } + return z; +} +#endif /* SQLITE_OMIT_COMPOUND_SELECT */ + +/* +** Forward declaration +*/ +static int prepSelectStmt(Parse*, Select*); + +/* +** Given a SELECT statement, generate a Table structure that describes +** the result set of that SELECT. +*/ +Table *sqlite3ResultSetOfSelect(Parse *pParse, char *zTabName, Select *pSelect){ + Table *pTab; + int i, j; + ExprList *pEList; + Column *aCol, *pCol; + sqlite3 *db = pParse->db; + + while( pSelect->pPrior ) pSelect = pSelect->pPrior; + if( prepSelectStmt(pParse, pSelect) ){ + return 0; + } + if( sqlite3SelectResolve(pParse, pSelect, 0) ){ + return 0; + } + pTab = (Table*)sqlite3DbMallocZero(db, sizeof(Table) ); + if( pTab==0 ){ + return 0; + } + pTab->nRef = 1; + pTab->zName = zTabName ? sqlite3DbStrDup(db, zTabName) : 0; + pEList = pSelect->pEList; + pTab->nCol = pEList->nExpr; + assert( pTab->nCol>0 ); + pTab->aCol = aCol = (Column*)sqlite3DbMallocZero(db, sizeof(pTab->aCol[0])*pTab->nCol); + for(i=0, pCol=aCol; inCol; i++, pCol++){ + Expr *p, *pR; + char *zType; + char *zName; + int nName; + CollSeq *pColl; + int cnt; + NameContext sNC; + + /* Get an appropriate name for the column + */ + p = pEList->a[i].pExpr; + assert( p->pRight==0 || p->pRight->token.z==0 || p->pRight->token.z[0]!=0 ); + if( (zName = pEList->a[i].zName)!=0 ){ + /* If the column contains an "AS " phrase, use as the name */ + zName = sqlite3DbStrDup(db, zName); + }else if( p->op==TK_DOT + && (pR=p->pRight)!=0 && pR->token.z && pR->token.z[0] ){ + /* For columns of the from A.B use B as the name */ + zName = sqlite3MPrintf(db, "%T", &pR->token); + }else if( p->span.z && p->span.z[0] ){ + /* Use the original text of the column expression as its name */ + zName = sqlite3MPrintf(db, "%T", &p->span); + }else{ + /* If all else fails, make up a name */ + zName = sqlite3MPrintf(db, "column%d", i+1); + } + if( !zName || db->mallocFailed ){ + db->mallocFailed = 1; + sqlite3_free(zName); + sqlite3DeleteTable(pTab); + return 0; + } + sqlite3Dequote(zName); + + /* Make sure the column name is unique. If the name is not unique, + ** append a integer to the name so that it becomes unique. + */ + nName = strlen(zName); + for(j=cnt=0; jzName = zName; + + /* Get the typename, type affinity, and collating sequence for the + ** column. + */ + memset(&sNC, 0, sizeof(sNC)); + sNC.pSrcList = pSelect->pSrc; + zType = sqlite3DbStrDup(db, columnType(&sNC, p, 0, 0, 0)); + pCol->zType = zType; + pCol->affinity = sqlite3ExprAffinity(p); + pColl = sqlite3ExprCollSeq(pParse, p); + if( pColl ){ + pCol->zColl = sqlite3DbStrDup(db, pColl->zName); + } + } + pTab->iPKey = -1; + return pTab; +} + +/* +** Prepare a SELECT statement for processing by doing the following +** things: +** +** (1) Make sure VDBE cursor numbers have been assigned to every +** element of the FROM clause. +** +** (2) Fill in the pTabList->a[].pTab fields in the SrcList that +** defines FROM clause. When views appear in the FROM clause, +** fill pTabList->a[].pSelect with a copy of the SELECT statement +** that implements the view. A copy is made of the view's SELECT +** statement so that we can freely modify or delete that statement +** without worrying about messing up the presistent representation +** of the view. +** +** (3) Add terms to the WHERE clause to accomodate the NATURAL keyword +** on joins and the ON and USING clause of joins. +** +** (4) Scan the list of columns in the result set (pEList) looking +** for instances of the "*" operator or the TABLE.* operator. +** If found, expand each "*" to be every column in every table +** and TABLE.* to be every column in TABLE. +** +** Return 0 on success. If there are problems, leave an error message +** in pParse and return non-zero. +*/ +static int prepSelectStmt(Parse *pParse, Select *p){ + int i, j, k, rc; + SrcList *pTabList; + ExprList *pEList; + SrcList::SrcList_item *pFrom; + sqlite3 *db = pParse->db; + + if( p==0 || p->pSrc==0 || db->mallocFailed ){ + return 1; + } + pTabList = p->pSrc; + pEList = p->pEList; + + /* Make sure cursor numbers have been assigned to all entries in + ** the FROM clause of the SELECT statement. + */ + sqlite3SrcListAssignCursors(pParse, p->pSrc); + + /* Look up every table named in the FROM clause of the select. If + ** an entry of the FROM clause is a subquery instead of a table or view, + ** then create a transient table structure to describe the subquery. + */ + Table *pTab; + for(i=0, pFrom=pTabList->a; inSrc; i++, pFrom++){ + if( pFrom->pTab!=0 ){ + /* This statement has already been prepared. There is no need + ** to go further. */ + assert( i==0 ); + return 0; + } + if( pFrom->zName==0 ){ +#ifndef SQLITE_OMIT_SUBQUERY + /* A sub-query in the FROM clause of a SELECT */ + assert( pFrom->pSelect!=0 ); + if( pFrom->zAlias==0 ){ + pFrom->zAlias = + sqlite3MPrintf(db, "sqlite_subquery_%p_", (void*)pFrom->pSelect); + } + assert( pFrom->pTab==0 ); + pFrom->pTab = pTab = + sqlite3ResultSetOfSelect(pParse, pFrom->zAlias, pFrom->pSelect); + if( pTab==0 ){ + return 1; + } + /* The isEphem flag indicates that the Table structure has been + ** dynamically allocated and may be freed at any time. In other words, + ** pTab is not pointing to a persistent table structure that defines + ** part of the schema. */ + pTab->isEphem = 1; +#endif + }else{ + /* An ordinary table or view name in the FROM clause */ + assert( pFrom->pTab==0 ); + pFrom->pTab = pTab = + sqlite3LocateTable(pParse,pFrom->zName,pFrom->zDatabase); + if( pTab==0 ){ + return 1; + } + pTab->nRef++; +#if !defined(SQLITE_OMIT_VIEW) || !defined (SQLITE_OMIT_VIRTUALTABLE) + if( pTab->pSelect || IsVirtual(pTab) ){ + /* We reach here if the named table is a really a view */ + if( sqlite3ViewGetColumnNames(pParse, pTab) ){ + return 1; + } + /* If pFrom->pSelect!=0 it means we are dealing with a + ** view within a view. The SELECT structure has already been + ** copied by the outer view so we can skip the copy step here + ** in the inner view. + */ + if( pFrom->pSelect==0 ){ + pFrom->pSelect = sqlite3SelectDup(db, pTab->pSelect); + } + } +#endif + } + } + + /* Process NATURAL keywords, and ON and USING clauses of joins. + */ + if( sqliteProcessJoin(pParse, p) ) return 1; + + /* For every "*" that occurs in the column list, insert the names of + ** all columns in all tables. And for every TABLE.* insert the names + ** of all columns in TABLE. The parser inserted a special expression + ** with the TK_ALL operator for each "*" that it found in the column list. + ** The following code just has to locate the TK_ALL expressions and expand + ** each one to the list of all columns in all tables. + ** + ** The first loop just checks to see if there are any "*" operators + ** that need expanding. + */ + for(k=0; knExpr; k++){ + Expr *pE = pEList->a[k].pExpr; + if( pE->op==TK_ALL ) break; + if( pE->op==TK_DOT && pE->pRight && pE->pRight->op==TK_ALL + && pE->pLeft && pE->pLeft->op==TK_ID ) break; + } + rc = 0; + if( knExpr ){ + /* + ** If we get here it means the result set contains one or more "*" + ** operators that need to be expanded. Loop through each expression + ** in the result set and expand them one by one. + */ + ExprList::ExprList_item *a = pEList->a; + ExprList *pNew = 0; + int flags = pParse->db->flags; + int longNames = (flags & SQLITE_FullColNames)!=0 && + (flags & SQLITE_ShortColNames)==0; + + for(k=0; knExpr; k++){ + Expr *pE = a[k].pExpr; + if( pE->op!=TK_ALL && + (pE->op!=TK_DOT || pE->pRight==0 || pE->pRight->op!=TK_ALL) ){ + /* This particular expression does not need to be expanded. + */ + pNew = sqlite3ExprListAppend(pParse, pNew, a[k].pExpr, 0); + if( pNew ){ + pNew->a[pNew->nExpr-1].zName = a[k].zName; + }else{ + rc = 1; + } + a[k].pExpr = 0; + a[k].zName = 0; + }else{ + /* This expression is a "*" or a "TABLE.*" and needs to be + ** expanded. */ + int tableSeen = 0; /* Set to 1 when TABLE matches */ + char *zTName; /* text of name of TABLE */ + if( pE->op==TK_DOT && pE->pLeft ){ + zTName = sqlite3NameFromToken(db, &pE->pLeft->token); + }else{ + zTName = 0; + } + for(i=0, pFrom=pTabList->a; inSrc; i++, pFrom++){ + Table *pTab = pFrom->pTab; + char *zTabName = pFrom->zAlias; + if( zTabName==0 || zTabName[0]==0 ){ + zTabName = pTab->zName; + } + if( zTName && (zTabName==0 || zTabName[0]==0 || + sqlite3StrICmp(zTName, zTabName)!=0) ){ + continue; + } + tableSeen = 1; + for(j=0; jnCol; j++){ + Expr *pExpr, *pRight; + char *zName = pTab->aCol[j].zName; + + /* If a column is marked as 'hidden' (currently only possible + ** for virtual tables), do not include it in the expanded + ** result-set list. + */ + if( IsHiddenColumn(&pTab->aCol[j]) ){ + assert(IsVirtual(pTab)); + continue; + } + + if( i>0 ){ + SrcList::SrcList_item *pLeft = &pTabList->a[i-1]; + if( (pLeft[1].jointype & JT_NATURAL)!=0 && + columnIndex(pLeft->pTab, zName)>=0 ){ + /* In a NATURAL join, omit the join columns from the + ** table on the right */ + continue; + } + if( sqlite3IdListIndex(pLeft[1].pUsing, zName)>=0 ){ + /* In a join with a USING clause, omit columns in the + ** using clause from the table on the right. */ + continue; + } + } + pRight = sqlite3PExpr(pParse, TK_ID, 0, 0, 0); + if( pRight==0 ) break; + setQuotedToken(pParse, &pRight->token, zName); + if( zTabName && (longNames || pTabList->nSrc>1) ){ + Expr *pLeft = sqlite3PExpr(pParse, TK_ID, 0, 0, 0); + pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight, 0); + if( pExpr==0 ) break; + setQuotedToken(pParse, &pLeft->token, zTabName); + setToken(&pExpr->span, + sqlite3MPrintf(db, "%s.%s", zTabName, zName)); + pExpr->span.dyn = 1; + pExpr->token.z = 0; + pExpr->token.n = 0; + pExpr->token.dyn = 0; + }else{ + pExpr = pRight; + pExpr->span = pExpr->token; + pExpr->span.dyn = 0; + } + if( longNames ){ + pNew = sqlite3ExprListAppend(pParse, pNew, pExpr, &pExpr->span); + }else{ + pNew = sqlite3ExprListAppend(pParse, pNew, pExpr, &pRight->token); + } + } + } + if( !tableSeen ){ + if( zTName ){ + sqlite3ErrorMsg(pParse, "no such table: %s", zTName); + }else{ + sqlite3ErrorMsg(pParse, "no tables specified"); + } + rc = 1; + } + sqlite3_free(zTName); + } + } + sqlite3ExprListDelete(pEList); + p->pEList = pNew; + } + if( p->pEList && p->pEList->nExpr>SQLITE_MAX_COLUMN ){ + sqlite3ErrorMsg(pParse, "too many columns in result set"); + rc = SQLITE_ERROR; + } + if( db->mallocFailed ){ + rc = SQLITE_NOMEM; + } + return rc; +} + +/* +** pE is a pointer to an expression which is a single term in +** ORDER BY or GROUP BY clause. +** +** If pE evaluates to an integer constant i, then return i. +** This is an indication to the caller that it should sort +** by the i-th column of the result set. +** +** If pE is a well-formed expression and the SELECT statement +** is not compound, then return 0. This indicates to the +** caller that it should sort by the value of the ORDER BY +** expression. +** +** If the SELECT is compound, then attempt to match pE against +** result set columns in the left-most SELECT statement. Return +** the index i of the matching column, as an indication to the +** caller that it should sort by the i-th column. If there is +** no match, return -1 and leave an error message in pParse. +*/ +static int matchOrderByTermToExprList( + Parse *pParse, /* Parsing context for error messages */ + Select *pSelect, /* The SELECT statement with the ORDER BY clause */ + Expr *pE, /* The specific ORDER BY term */ + int idx, /* When ORDER BY term is this */ + int isCompound, /* True if this is a compound SELECT */ + u8 *pHasAgg /* True if expression contains aggregate functions */ +){ + int i; /* Loop counter */ + ExprList *pEList; /* The columns of the result set */ + NameContext nc; /* Name context for resolving pE */ + + + /* If the term is an integer constant, return the value of that + ** constant */ + pEList = pSelect->pEList; + if( sqlite3ExprIsInteger(pE, &i) ){ + if( i<=0 ){ + /* If i is too small, make it too big. That way the calling + ** function still sees a value that is out of range, but does + ** not confuse the column number with 0 or -1 result code. + */ + i = pEList->nExpr+1; + } + return i; + } + + /* If the term is a simple identifier that try to match that identifier + ** against a column name in the result set. + */ + if( pE->op==TK_ID || (pE->op==TK_STRING && pE->token.z[0]!='\'') ){ + sqlite3 *db = pParse->db; + char *zCol = sqlite3NameFromToken(db, &pE->token); + if( zCol==0 ){ + return -1; + } + for(i=0; inExpr; i++){ + char *zAs = pEList->a[i].zName; + if( zAs!=0 && sqlite3StrICmp(zAs, zCol)==0 ){ + sqlite3_free(zCol); + return i+1; + } + } + sqlite3_free(zCol); + } + + /* Resolve all names in the ORDER BY term expression + */ + memset(&nc, 0, sizeof(nc)); + nc.pParse = pParse; + nc.pSrcList = pSelect->pSrc; + nc.pEList = pEList; + nc.allowAgg = 1; + nc.nErr = 0; + if( sqlite3ExprResolveNames(&nc, pE) ){ + if( isCompound ){ + sqlite3ErrorClear(pParse); + return 0; + }else{ + return -1; + } + } + if( nc.hasAgg && pHasAgg ){ + *pHasAgg = 1; + } + + /* For a compound SELECT, we need to try to match the ORDER BY + ** expression against an expression in the result set + */ + if( isCompound ){ + for(i=0; inExpr; i++){ + if( sqlite3ExprCompare(pEList->a[i].pExpr, pE) ){ + return i+1; + } + } + } + return 0; +} + + +/* +** Analyze and ORDER BY or GROUP BY clause in a simple SELECT statement. +** Return the number of errors seen. +** +** Every term of the ORDER BY or GROUP BY clause needs to be an +** expression. If any expression is an integer constant, then +** that expression is replaced by the corresponding +** expression from the result set. +*/ +static int processOrderGroupBy( + Parse *pParse, /* Parsing context. Leave error messages here */ + Select *pSelect, /* The SELECT statement containing the clause */ + ExprList *pOrderBy, /* The ORDER BY or GROUP BY clause to be processed */ + int isOrder, /* 1 for ORDER BY. 0 for GROUP BY */ + u8 *pHasAgg /* Set to TRUE if any term contains an aggregate */ +){ + int i; + sqlite3 *db = pParse->db; + ExprList *pEList; + + if( pOrderBy==0 ) return 0; + if( pOrderBy->nExpr>SQLITE_MAX_COLUMN ){ + const char *zType = isOrder ? "ORDER" : "GROUP"; + sqlite3ErrorMsg(pParse, "too many terms in %s BY clause", zType); + return 1; + } + pEList = pSelect->pEList; + if( pEList==0 ){ + return 0; + } + for(i=0; inExpr; i++){ + int iCol; + Expr *pE = pOrderBy->a[i].pExpr; + iCol = matchOrderByTermToExprList(pParse, pSelect, pE, i+1, 0, pHasAgg); + if( iCol<0 ){ + return 1; + } + if( iCol>pEList->nExpr ){ + const char *zType = isOrder ? "ORDER" : "GROUP"; + sqlite3ErrorMsg(pParse, + "%r %s BY term out of range - should be " + "between 1 and %d", i+1, zType, pEList->nExpr); + return 1; + } + if( iCol>0 ){ + CollSeq *pColl = pE->pColl; + int flags = pE->flags & EP_ExpCollate; + sqlite3ExprDelete(pE); + pE = sqlite3ExprDup(db, pEList->a[iCol-1].pExpr); + pOrderBy->a[i].pExpr = pE; + if( pColl && flags ){ + pE->pColl = pColl; + pE->flags |= flags; + } + } + } + return 0; +} + +/* +** Analyze and ORDER BY or GROUP BY clause in a SELECT statement. Return +** the number of errors seen. +** +** The processing depends on whether the SELECT is simple or compound. +** For a simple SELECT statement, evry term of the ORDER BY or GROUP BY +** clause needs to be an expression. If any expression is an integer +** constant, then that expression is replaced by the corresponding +** expression from the result set. +** +** For compound SELECT statements, every expression needs to be of +** type TK_COLUMN with a iTable value as given in the 4th parameter. +** If any expression is an integer, that becomes the column number. +** Otherwise, match the expression against result set columns from +** the left-most SELECT. +*/ +static int processCompoundOrderBy( + Parse *pParse, /* Parsing context. Leave error messages here */ + Select *pSelect, /* The SELECT statement containing the ORDER BY */ + int iTable /* Output table for compound SELECT statements */ +){ + int i; + ExprList *pOrderBy; + ExprList *pEList; + sqlite3 *db; + int moreToDo = 1; + + pOrderBy = pSelect->pOrderBy; + if( pOrderBy==0 ) return 0; + if( pOrderBy->nExpr>SQLITE_MAX_COLUMN ){ + sqlite3ErrorMsg(pParse, "too many terms in ORDER BY clause"); + return 1; + } + db = pParse->db; + for(i=0; inExpr; i++){ + pOrderBy->a[i].done = 0; + } + while( pSelect->pPrior ){ + pSelect = pSelect->pPrior; + } + while( pSelect && moreToDo ){ + moreToDo = 0; + for(i=0; inExpr; i++){ + int iCol; + Expr *pE, *pDup; + if( pOrderBy->a[i].done ) continue; + pE = pOrderBy->a[i].pExpr; + pDup = sqlite3ExprDup(db, pE); + if( pDup==0 ){ + return 1; + } + iCol = matchOrderByTermToExprList(pParse, pSelect, pDup, i+1, 1, 0); + sqlite3ExprDelete(pDup); + if( iCol<0 ){ + return 1; + } + pEList = pSelect->pEList; + if( pEList==0 ){ + return 1; + } + if( iCol>pEList->nExpr ){ + sqlite3ErrorMsg(pParse, + "%r ORDER BY term out of range - should be " + "between 1 and %d", i+1, pEList->nExpr); + return 1; + } + if( iCol>0 ){ + pE->op = TK_COLUMN; + pE->iTable = iTable; + pE->iAgg = -1; + pE->iColumn = iCol-1; + pE->pTab = 0; + pOrderBy->a[i].done = 1; + }else{ + moreToDo = 1; + } + } + pSelect = pSelect->pNext; + } + for(i=0; inExpr; i++){ + if( pOrderBy->a[i].done==0 ){ + sqlite3ErrorMsg(pParse, "%r ORDER BY term does not match any " + "column in the result set", i+1); + return 1; + } + } + return 0; +} + +/* +** Get a VDBE for the given parser context. Create a new one if necessary. +** If an error occurs, return NULL and leave a message in pParse. +*/ +Vdbe *sqlite3GetVdbe(Parse *pParse){ + Vdbe *v = pParse->pVdbe; + if( v==0 ){ + v = pParse->pVdbe = sqlite3VdbeCreate(pParse->db); + } + return v; +} + + +/* +** Compute the iLimit and iOffset fields of the SELECT based on the +** pLimit and pOffset expressions. pLimit and pOffset hold the expressions +** that appear in the original SQL statement after the LIMIT and OFFSET +** keywords. Or NULL if those keywords are omitted. iLimit and iOffset +** are the integer memory register numbers for counters used to compute +** the limit and offset. If there is no limit and/or offset, then +** iLimit and iOffset are negative. +** +** This routine changes the values of iLimit and iOffset only if +** a limit or offset is defined by pLimit and pOffset. iLimit and +** iOffset should have been preset to appropriate default values +** (usually but not always -1) prior to calling this routine. +** Only if pLimit!=0 or pOffset!=0 do the limit registers get +** redefined. The UNION ALL operator uses this property to force +** the reuse of the same limit and offset registers across multiple +** SELECT statements. +*/ +static void computeLimitRegisters(Parse *pParse, Select *p, int iBreak){ + Vdbe *v = 0; + int iLimit = 0; + int iOffset; + int addr1, addr2; + + /* + ** "LIMIT -1" always shows all rows. There is some + ** contraversy about what the correct behavior should be. + ** The current implementation interprets "LIMIT 0" to mean + ** no rows. + */ + if( p->pLimit ){ + p->iLimit = iLimit = pParse->nMem; + pParse->nMem += 2; + v = sqlite3GetVdbe(pParse); + if( v==0 ) return; + sqlite3ExprCode(pParse, p->pLimit); + sqlite3VdbeAddOp(v, OP_MustBeInt, 0, 0); + sqlite3VdbeAddOp(v, OP_MemStore, iLimit, 1); + VdbeComment((v, "# LIMIT counter")); + sqlite3VdbeAddOp(v, OP_IfMemZero, iLimit, iBreak); + sqlite3VdbeAddOp(v, OP_MemLoad, iLimit, 0); + } + if( p->pOffset ){ + p->iOffset = iOffset = pParse->nMem++; + v = sqlite3GetVdbe(pParse); + if( v==0 ) return; + sqlite3ExprCode(pParse, p->pOffset); + sqlite3VdbeAddOp(v, OP_MustBeInt, 0, 0); + sqlite3VdbeAddOp(v, OP_MemStore, iOffset, p->pLimit==0); + VdbeComment((v, "# OFFSET counter")); + addr1 = sqlite3VdbeAddOp(v, OP_IfMemPos, iOffset, 0); + sqlite3VdbeAddOp(v, OP_Pop, 1, 0); + sqlite3VdbeAddOp(v, OP_Integer, 0, 0); + sqlite3VdbeJumpHere(v, addr1); + if( p->pLimit ){ + sqlite3VdbeAddOp(v, OP_Add, 0, 0); + } + } + if( p->pLimit ){ + addr1 = sqlite3VdbeAddOp(v, OP_IfMemPos, iLimit, 0); + sqlite3VdbeAddOp(v, OP_Pop, 1, 0); + sqlite3VdbeAddOp(v, OP_MemInt, -1, iLimit+1); + addr2 = sqlite3VdbeAddOp(v, OP_Goto, 0, 0); + sqlite3VdbeJumpHere(v, addr1); + sqlite3VdbeAddOp(v, OP_MemStore, iLimit+1, 1); + VdbeComment((v, "# LIMIT+OFFSET")); + sqlite3VdbeJumpHere(v, addr2); + } +} + +/* +** Allocate a virtual index to use for sorting. +*/ +static void createSortingIndex(Parse *pParse, Select *p, ExprList *pOrderBy){ + if( pOrderBy ){ + int addr; + assert( pOrderBy->iECursor==0 ); + pOrderBy->iECursor = pParse->nTab++; + addr = sqlite3VdbeAddOp(pParse->pVdbe, OP_OpenEphemeral, + pOrderBy->iECursor, pOrderBy->nExpr+1); + assert( p->addrOpenEphm[2] == -1 ); + p->addrOpenEphm[2] = addr; + } +} + +#ifndef SQLITE_OMIT_COMPOUND_SELECT +/* +** Return the appropriate collating sequence for the iCol-th column of +** the result set for the compound-select statement "p". Return NULL if +** the column has no default collating sequence. +** +** The collating sequence for the compound select is taken from the +** left-most term of the select that has a collating sequence. +*/ +static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){ + CollSeq *pRet; + if( p->pPrior ){ + pRet = multiSelectCollSeq(pParse, p->pPrior, iCol); + }else{ + pRet = 0; + } + if( pRet==0 ){ + pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr); + } + return pRet; +} +#endif /* SQLITE_OMIT_COMPOUND_SELECT */ + +#ifndef SQLITE_OMIT_COMPOUND_SELECT +/* +** This routine is called to process a query that is really the union +** or intersection of two or more separate queries. +** +** "p" points to the right-most of the two queries. the query on the +** left is p->pPrior. The left query could also be a compound query +** in which case this routine will be called recursively. +** +** The results of the total query are to be written into a destination +** of type eDest with parameter iParm. +** +** Example 1: Consider a three-way compound SQL statement. +** +** SELECT a FROM t1 UNION SELECT b FROM t2 UNION SELECT c FROM t3 +** +** This statement is parsed up as follows: +** +** SELECT c FROM t3 +** | +** `-----> SELECT b FROM t2 +** | +** `------> SELECT a FROM t1 +** +** The arrows in the diagram above represent the Select.pPrior pointer. +** So if this routine is called with p equal to the t3 query, then +** pPrior will be the t2 query. p->op will be TK_UNION in this case. +** +** Notice that because of the way SQLite parses compound SELECTs, the +** individual selects always group from left to right. +*/ +static int multiSelect( + Parse *pParse, /* Parsing context */ + Select *p, /* The right-most of SELECTs to be coded */ + int eDest, /* \___ Store query results as specified */ + int iParm, /* / by these two parameters. */ + char *aff /* If eDest is SRT_Union, the affinity string */ +){ + int rc = SQLITE_OK; /* Success code from a subroutine */ + Select *pPrior; /* Another SELECT immediately to our left */ + Vdbe *v; /* Generate code to this VDBE */ + int nCol; /* Number of columns in the result set */ + ExprList *pOrderBy; /* The ORDER BY clause on p */ + int aSetP2[2]; /* Set P2 value of these op to number of columns */ + int nSetP2 = 0; /* Number of slots in aSetP2[] used */ + + /* Make sure there is no ORDER BY or LIMIT clause on prior SELECTs. Only + ** the last (right-most) SELECT in the series may have an ORDER BY or LIMIT. + */ + if( p==0 || p->pPrior==0 ){ + rc = 1; + goto multi_select_end; + } + pPrior = p->pPrior; + assert( pPrior->pRightmost!=pPrior ); + assert( pPrior->pRightmost==p->pRightmost ); + if( pPrior->pOrderBy ){ + sqlite3ErrorMsg(pParse,"ORDER BY clause should come after %s not before", + selectOpName(p->op)); + rc = 1; + goto multi_select_end; + } + if( pPrior->pLimit ){ + sqlite3ErrorMsg(pParse,"LIMIT clause should come after %s not before", + selectOpName(p->op)); + rc = 1; + goto multi_select_end; + } + + /* Make sure we have a valid query engine. If not, create a new one. + */ + v = sqlite3GetVdbe(pParse); + if( v==0 ){ + rc = 1; + goto multi_select_end; + } + + /* Create the destination temporary table if necessary + */ + if( eDest==SRT_EphemTab ){ + assert( p->pEList ); + assert( nSetP2pOrderBy; + switch( p->op ){ + case TK_ALL: { + if( pOrderBy==0 ){ + int addr = 0; + assert( !pPrior->pLimit ); + pPrior->pLimit = p->pLimit; + pPrior->pOffset = p->pOffset; + rc = sqlite3Select(pParse, pPrior, eDest, iParm, 0, 0, 0, aff); + p->pLimit = 0; + p->pOffset = 0; + if( rc ){ + goto multi_select_end; + } + p->pPrior = 0; + p->iLimit = pPrior->iLimit; + p->iOffset = pPrior->iOffset; + if( p->iLimit>=0 ){ + addr = sqlite3VdbeAddOp(v, OP_IfMemZero, p->iLimit, 0); + VdbeComment((v, "# Jump ahead if LIMIT reached")); + } + rc = sqlite3Select(pParse, p, eDest, iParm, 0, 0, 0, aff); + p->pPrior = pPrior; + if( rc ){ + goto multi_select_end; + } + if( addr ){ + sqlite3VdbeJumpHere(v, addr); + } + break; + } + /* For UNION ALL ... ORDER BY fall through to the next case */ + } + case TK_EXCEPT: + case TK_UNION: { + int unionTab; /* Cursor number of the temporary table holding result */ + int op = 0; /* One of the SRT_ operations to apply to self */ + int priorOp; /* The SRT_ operation to apply to prior selects */ + Expr *pLimit, *pOffset; /* Saved values of p->nLimit and p->nOffset */ + int addr; + + priorOp = p->op==TK_ALL ? SRT_Table : SRT_Union; + if( eDest==priorOp && pOrderBy==0 && !p->pLimit && !p->pOffset ){ + /* We can reuse a temporary table generated by a SELECT to our + ** right. + */ + unionTab = iParm; + }else{ + /* We will need to create our own temporary table to hold the + ** intermediate results. + */ + unionTab = pParse->nTab++; + if( processCompoundOrderBy(pParse, p, unionTab) ){ + rc = 1; + goto multi_select_end; + } + addr = sqlite3VdbeAddOp(v, OP_OpenEphemeral, unionTab, 0); + if( priorOp==SRT_Table ){ + assert( nSetP2addrOpenEphm[0] == -1 ); + p->addrOpenEphm[0] = addr; + p->pRightmost->usesEphm = 1; + } + createSortingIndex(pParse, p, pOrderBy); + assert( p->pEList ); + } + + /* Code the SELECT statements to our left + */ + assert( !pPrior->pOrderBy ); + rc = sqlite3Select(pParse, pPrior, priorOp, unionTab, 0, 0, 0, aff); + if( rc ){ + goto multi_select_end; + } + + /* Code the current SELECT statement + */ + switch( p->op ){ + case TK_EXCEPT: op = SRT_Except; break; + case TK_UNION: op = SRT_Union; break; + case TK_ALL: op = SRT_Table; break; + } + p->pPrior = 0; + p->pOrderBy = 0; + p->disallowOrderBy = pOrderBy!=0; + pLimit = p->pLimit; + p->pLimit = 0; + pOffset = p->pOffset; + p->pOffset = 0; + rc = sqlite3Select(pParse, p, op, unionTab, 0, 0, 0, aff); + /* Query flattening in sqlite3Select() might refill p->pOrderBy. + ** Be sure to delete p->pOrderBy, therefore, to avoid a memory leak. */ + sqlite3ExprListDelete(p->pOrderBy); + p->pPrior = pPrior; + p->pOrderBy = pOrderBy; + sqlite3ExprDelete(p->pLimit); + p->pLimit = pLimit; + p->pOffset = pOffset; + p->iLimit = -1; + p->iOffset = -1; + if( rc ){ + goto multi_select_end; + } + + + /* Convert the data in the temporary table into whatever form + ** it is that we currently need. + */ + if( eDest!=priorOp || unionTab!=iParm ){ + int iCont, iBreak, iStart; + assert( p->pEList ); + if( eDest==SRT_Callback ){ + Select *pFirst = p; + while( pFirst->pPrior ) pFirst = pFirst->pPrior; + generateColumnNames(pParse, 0, pFirst->pEList); + } + iBreak = sqlite3VdbeMakeLabel(v); + iCont = sqlite3VdbeMakeLabel(v); + computeLimitRegisters(pParse, p, iBreak); + sqlite3VdbeAddOp(v, OP_Rewind, unionTab, iBreak); + iStart = sqlite3VdbeCurrentAddr(v); + rc = selectInnerLoop(pParse, p, p->pEList, unionTab, p->pEList->nExpr, + pOrderBy, -1, eDest, iParm, + iCont, iBreak, 0); + if( rc ){ + rc = 1; + goto multi_select_end; + } + sqlite3VdbeResolveLabel(v, iCont); + sqlite3VdbeAddOp(v, OP_Next, unionTab, iStart); + sqlite3VdbeResolveLabel(v, iBreak); + sqlite3VdbeAddOp(v, OP_Close, unionTab, 0); + } + break; + } + case TK_INTERSECT: { + int tab1, tab2; + int iCont, iBreak, iStart; + Expr *pLimit, *pOffset; + int addr; + + /* INTERSECT is different from the others since it requires + ** two temporary tables. Hence it has its own case. Begin + ** by allocating the tables we will need. + */ + tab1 = pParse->nTab++; + tab2 = pParse->nTab++; + if( processCompoundOrderBy(pParse, p, tab1) ){ + rc = 1; + goto multi_select_end; + } + createSortingIndex(pParse, p, pOrderBy); + + addr = sqlite3VdbeAddOp(v, OP_OpenEphemeral, tab1, 0); + assert( p->addrOpenEphm[0] == -1 ); + p->addrOpenEphm[0] = addr; + p->pRightmost->usesEphm = 1; + assert( p->pEList ); + + /* Code the SELECTs to our left into temporary table "tab1". + */ + rc = sqlite3Select(pParse, pPrior, SRT_Union, tab1, 0, 0, 0, aff); + if( rc ){ + goto multi_select_end; + } + + /* Code the current SELECT into temporary table "tab2" + */ + addr = sqlite3VdbeAddOp(v, OP_OpenEphemeral, tab2, 0); + assert( p->addrOpenEphm[1] == -1 ); + p->addrOpenEphm[1] = addr; + p->pPrior = 0; + pLimit = p->pLimit; + p->pLimit = 0; + pOffset = p->pOffset; + p->pOffset = 0; + rc = sqlite3Select(pParse, p, SRT_Union, tab2, 0, 0, 0, aff); + p->pPrior = pPrior; + sqlite3ExprDelete(p->pLimit); + p->pLimit = pLimit; + p->pOffset = pOffset; + if( rc ){ + goto multi_select_end; + } + + /* Generate code to take the intersection of the two temporary + ** tables. + */ + assert( p->pEList ); + if( eDest==SRT_Callback ){ + Select *pFirst = p; + while( pFirst->pPrior ) pFirst = pFirst->pPrior; + generateColumnNames(pParse, 0, pFirst->pEList); + } + iBreak = sqlite3VdbeMakeLabel(v); + iCont = sqlite3VdbeMakeLabel(v); + computeLimitRegisters(pParse, p, iBreak); + sqlite3VdbeAddOp(v, OP_Rewind, tab1, iBreak); + iStart = sqlite3VdbeAddOp(v, OP_RowKey, tab1, 0); + sqlite3VdbeAddOp(v, OP_NotFound, tab2, iCont); + rc = selectInnerLoop(pParse, p, p->pEList, tab1, p->pEList->nExpr, + pOrderBy, -1, eDest, iParm, + iCont, iBreak, 0); + if( rc ){ + rc = 1; + goto multi_select_end; + } + sqlite3VdbeResolveLabel(v, iCont); + sqlite3VdbeAddOp(v, OP_Next, tab1, iStart); + sqlite3VdbeResolveLabel(v, iBreak); + sqlite3VdbeAddOp(v, OP_Close, tab2, 0); + sqlite3VdbeAddOp(v, OP_Close, tab1, 0); + break; + } + } + + /* Make sure all SELECTs in the statement have the same number of elements + ** in their result sets. + */ + assert( p->pEList && pPrior->pEList ); + if( p->pEList->nExpr!=pPrior->pEList->nExpr ){ + sqlite3ErrorMsg(pParse, "SELECTs to the left and right of %s" + " do not have the same number of result columns", selectOpName(p->op)); + rc = 1; + goto multi_select_end; + } + + /* Set the number of columns in temporary tables + */ + nCol = p->pEList->nExpr; + while( nSetP2 ){ + sqlite3VdbeChangeP2(v, aSetP2[--nSetP2], nCol); + } + + /* Compute collating sequences used by either the ORDER BY clause or + ** by any temporary tables needed to implement the compound select. + ** Attach the KeyInfo structure to all temporary tables. Invoke the + ** ORDER BY processing if there is an ORDER BY clause. + ** + ** This section is run by the right-most SELECT statement only. + ** SELECT statements to the left always skip this part. The right-most + ** SELECT might also skip this part if it has no ORDER BY clause and + ** no temp tables are required. + */ + if( pOrderBy || p->usesEphm ){ + int i; /* Loop counter */ + KeyInfo *pKeyInfo; /* Collating sequence for the result set */ + Select *pLoop; /* For looping through SELECT statements */ + int nKeyCol; /* Number of entries in pKeyInfo->aCol[] */ + CollSeq **apColl; /* For looping through pKeyInfo->aColl[] */ + CollSeq **aCopy; /* A copy of pKeyInfo->aColl[] */ + + assert( p->pRightmost==p ); + nKeyCol = nCol + (pOrderBy ? pOrderBy->nExpr : 0); + pKeyInfo = (KeyInfo*)sqlite3DbMallocZero(pParse->db, + sizeof(*pKeyInfo)+nKeyCol*(sizeof(CollSeq*) + 1)); + if( !pKeyInfo ){ + rc = SQLITE_NOMEM; + goto multi_select_end; + } + + pKeyInfo->enc = ENC(pParse->db); + pKeyInfo->nField = nCol; + + for(i=0, apColl=pKeyInfo->aColl; idb->pDfltColl; + } + } + + for(pLoop=p; pLoop; pLoop=pLoop->pPrior){ + for(i=0; i<2; i++){ + int addr = pLoop->addrOpenEphm[i]; + if( addr<0 ){ + /* If [0] is unused then [1] is also unused. So we can + ** always safely abort as soon as the first unused slot is found */ + assert( pLoop->addrOpenEphm[1]<0 ); + break; + } + sqlite3VdbeChangeP2(v, addr, nCol); + sqlite3VdbeChangeP3(v, addr, (char*)pKeyInfo, P3_KEYINFO); + pLoop->addrOpenEphm[i] = -1; + } + } + + if( pOrderBy ){ + ExprList::ExprList_item *pOTerm = pOrderBy->a; + int nOrderByExpr = pOrderBy->nExpr; + int addr; + u8 *pSortOrder; + + /* Reuse the same pKeyInfo for the ORDER BY as was used above for + ** the compound select statements. Except we have to change out the + ** pKeyInfo->aColl[] values. Some of the aColl[] values will be + ** reused when constructing the pKeyInfo for the ORDER BY, so make + ** a copy. Sufficient space to hold both the nCol entries for + ** the compound select and the nOrderbyExpr entries for the ORDER BY + ** was allocated above. But we need to move the compound select + ** entries out of the way before constructing the ORDER BY entries. + ** Move the compound select entries into aCopy[] where they can be + ** accessed and reused when constructing the ORDER BY entries. + ** Because nCol might be greater than or less than nOrderByExpr + ** we have to use memmove() when doing the copy. + */ + aCopy = &pKeyInfo->aColl[nOrderByExpr]; + pSortOrder = pKeyInfo->aSortOrder = (u8*)&aCopy[nCol]; + memmove(aCopy, pKeyInfo->aColl, nCol*sizeof(CollSeq*)); + + apColl = pKeyInfo->aColl; + for(i=0; ipExpr; + if( (pExpr->flags & EP_ExpCollate) ){ + assert( pExpr->pColl!=0 ); + *apColl = pExpr->pColl; + }else{ + *apColl = aCopy[pExpr->iColumn]; + } + *pSortOrder = pOTerm->sortOrder; + } + assert( p->pRightmost==p ); + assert( p->addrOpenEphm[2]>=0 ); + addr = p->addrOpenEphm[2]; + sqlite3VdbeChangeP2(v, addr, p->pOrderBy->nExpr+2); + pKeyInfo->nField = nOrderByExpr; + sqlite3VdbeChangeP3(v, addr, (char*)pKeyInfo, P3_KEYINFO_HANDOFF); + pKeyInfo = 0; + generateSortTail(pParse, p, v, p->pEList->nExpr, eDest, iParm); + } + + sqlite3_free(pKeyInfo); + } + +multi_select_end: + return rc; +} +#endif /* SQLITE_OMIT_COMPOUND_SELECT */ + +#ifndef SQLITE_OMIT_VIEW +/* Forward Declarations */ +static void substExprList(sqlite3*, ExprList*, int, ExprList*); +static void substSelect(sqlite3*, Select *, int, ExprList *); + +/* +** Scan through the expression pExpr. Replace every reference to +** a column in table number iTable with a copy of the iColumn-th +** entry in pEList. (But leave references to the ROWID column +** unchanged.) +** +** This routine is part of the flattening procedure. A subquery +** whose result set is defined by pEList appears as entry in the +** FROM clause of a SELECT such that the VDBE cursor assigned to that +** FORM clause entry is iTable. This routine make the necessary +** changes to pExpr so that it refers directly to the source table +** of the subquery rather the result set of the subquery. +*/ +static void substExpr( + sqlite3 *db, /* Report malloc errors to this connection */ + Expr *pExpr, /* Expr in which substitution occurs */ + int iTable, /* Table to be substituted */ + ExprList *pEList /* Substitute expressions */ +){ + if( pExpr==0 ) return; + if( pExpr->op==TK_COLUMN && pExpr->iTable==iTable ){ + if( pExpr->iColumn<0 ){ + pExpr->op = TK_NULL; + }else{ + Expr *pNew; + assert( pEList!=0 && pExpr->iColumnnExpr ); + assert( pExpr->pLeft==0 && pExpr->pRight==0 && pExpr->pList==0 ); + pNew = pEList->a[pExpr->iColumn].pExpr; + assert( pNew!=0 ); + pExpr->op = pNew->op; + assert( pExpr->pLeft==0 ); + pExpr->pLeft = sqlite3ExprDup(db, pNew->pLeft); + assert( pExpr->pRight==0 ); + pExpr->pRight = sqlite3ExprDup(db, pNew->pRight); + assert( pExpr->pList==0 ); + pExpr->pList = sqlite3ExprListDup(db, pNew->pList); + pExpr->iTable = pNew->iTable; + pExpr->pTab = pNew->pTab; + pExpr->iColumn = pNew->iColumn; + pExpr->iAgg = pNew->iAgg; + sqlite3TokenCopy(db, &pExpr->token, &pNew->token); + sqlite3TokenCopy(db, &pExpr->span, &pNew->span); + pExpr->pSelect = sqlite3SelectDup(db, pNew->pSelect); + pExpr->flags = pNew->flags; + } + }else{ + substExpr(db, pExpr->pLeft, iTable, pEList); + substExpr(db, pExpr->pRight, iTable, pEList); + substSelect(db, pExpr->pSelect, iTable, pEList); + substExprList(db, pExpr->pList, iTable, pEList); + } +} +static void substExprList( + sqlite3 *db, /* Report malloc errors here */ + ExprList *pList, /* List to scan and in which to make substitutes */ + int iTable, /* Table to be substituted */ + ExprList *pEList /* Substitute values */ +){ + int i; + if( pList==0 ) return; + for(i=0; inExpr; i++){ + substExpr(db, pList->a[i].pExpr, iTable, pEList); + } +} +static void substSelect( + sqlite3 *db, /* Report malloc errors here */ + Select *p, /* SELECT statement in which to make substitutions */ + int iTable, /* Table to be replaced */ + ExprList *pEList /* Substitute values */ +){ + if( !p ) return; + substExprList(db, p->pEList, iTable, pEList); + substExprList(db, p->pGroupBy, iTable, pEList); + substExprList(db, p->pOrderBy, iTable, pEList); + substExpr(db, p->pHaving, iTable, pEList); + substExpr(db, p->pWhere, iTable, pEList); + substSelect(db, p->pPrior, iTable, pEList); +} +#endif /* !defined(SQLITE_OMIT_VIEW) */ + +#ifndef SQLITE_OMIT_VIEW +/* +** This routine attempts to flatten subqueries in order to speed +** execution. It returns 1 if it makes changes and 0 if no flattening +** occurs. +** +** To understand the concept of flattening, consider the following +** query: +** +** SELECT a FROM (SELECT x+y AS a FROM t1 WHERE z<100) WHERE a>5 +** +** The default way of implementing this query is to execute the +** subquery first and store the results in a temporary table, then +** run the outer query on that temporary table. This requires two +** passes over the data. Furthermore, because the temporary table +** has no indices, the WHERE clause on the outer query cannot be +** optimized. +** +** This routine attempts to rewrite queries such as the above into +** a single flat select, like this: +** +** SELECT x+y AS a FROM t1 WHERE z<100 AND a>5 +** +** The code generated for this simpification gives the same result +** but only has to scan the data once. And because indices might +** exist on the table t1, a complete scan of the data might be +** avoided. +** +** Flattening is only attempted if all of the following are true: +** +** (1) The subquery and the outer query do not both use aggregates. +** +** (2) The subquery is not an aggregate or the outer query is not a join. +** +** (3) The subquery is not the right operand of a left outer join, or +** the subquery is not itself a join. (Ticket #306) +** +** (4) The subquery is not DISTINCT or the outer query is not a join. +** +** (5) The subquery is not DISTINCT or the outer query does not use +** aggregates. +** +** (6) The subquery does not use aggregates or the outer query is not +** DISTINCT. +** +** (7) The subquery has a FROM clause. +** +** (8) The subquery does not use LIMIT or the outer query is not a join. +** +** (9) The subquery does not use LIMIT or the outer query does not use +** aggregates. +** +** (10) The subquery does not use aggregates or the outer query does not +** use LIMIT. +** +** (11) The subquery and the outer query do not both have ORDER BY clauses. +** +** (12) The subquery is not the right term of a LEFT OUTER JOIN or the +** subquery has no WHERE clause. (added by ticket #350) +** +** (13) The subquery and outer query do not both use LIMIT +** +** (14) The subquery does not use OFFSET +** +** (15) The outer query is not part of a compound select or the +** subquery does not have both an ORDER BY and a LIMIT clause. +** (See ticket #2339) +** +** In this routine, the "p" parameter is a pointer to the outer query. +** The subquery is p->pSrc->a[iFrom]. isAgg is true if the outer query +** uses aggregates and subqueryIsAgg is true if the subquery uses aggregates. +** +** If flattening is not attempted, this routine is a no-op and returns 0. +** If flattening is attempted this routine returns 1. +** +** All of the expression analysis must occur on both the outer query and +** the subquery before this routine runs. +*/ +static int flattenSubquery( + sqlite3 *db, /* Database connection */ + Select *p, /* The parent or outer SELECT statement */ + int iFrom, /* Index in p->pSrc->a[] of the inner subquery */ + int isAgg, /* True if outer SELECT uses aggregate functions */ + int subqueryIsAgg /* True if the subquery uses aggregate functions */ +){ + Select *pSub; /* The inner query or "subquery" */ + SrcList *pSrc; /* The FROM clause of the outer query */ + SrcList *pSubSrc; /* The FROM clause of the subquery */ + ExprList *pList; /* The result set of the outer query */ + int iParent; /* VDBE cursor number of the pSub result set temp table */ + int i; /* Loop counter */ + Expr *pWhere; /* The WHERE clause */ + SrcList::SrcList_item *pSubitem; /* The subquery */ + + /* Check to see if flattening is permitted. Return 0 if not. + */ + if( p==0 ) return 0; + pSrc = p->pSrc; + assert( pSrc && iFrom>=0 && iFromnSrc ); + pSubitem = &pSrc->a[iFrom]; + pSub = pSubitem->pSelect; + assert( pSub!=0 ); + if( isAgg && subqueryIsAgg ) return 0; /* Restriction (1) */ + if( subqueryIsAgg && pSrc->nSrc>1 ) return 0; /* Restriction (2) */ + pSubSrc = pSub->pSrc; + assert( pSubSrc ); + /* Prior to version 3.1.2, when LIMIT and OFFSET had to be simple constants, + ** not arbitrary expresssions, we allowed some combining of LIMIT and OFFSET + ** because they could be computed at compile-time. But when LIMIT and OFFSET + ** became arbitrary expressions, we were forced to add restrictions (13) + ** and (14). */ + if( pSub->pLimit && p->pLimit ) return 0; /* Restriction (13) */ + if( pSub->pOffset ) return 0; /* Restriction (14) */ + if( p->pRightmost && pSub->pLimit && pSub->pOrderBy ){ + return 0; /* Restriction (15) */ + } + if( pSubSrc->nSrc==0 ) return 0; /* Restriction (7) */ + if( (pSub->isDistinct || pSub->pLimit) + && (pSrc->nSrc>1 || isAgg) ){ /* Restrictions (4)(5)(8)(9) */ + return 0; + } + if( p->isDistinct && subqueryIsAgg ) return 0; /* Restriction (6) */ + if( (p->disallowOrderBy || p->pOrderBy) && pSub->pOrderBy ){ + return 0; /* Restriction (11) */ + } + + /* Restriction 3: If the subquery is a join, make sure the subquery is + ** not used as the right operand of an outer join. Examples of why this + ** is not allowed: + ** + ** t1 LEFT OUTER JOIN (t2 JOIN t3) + ** + ** If we flatten the above, we would get + ** + ** (t1 LEFT OUTER JOIN t2) JOIN t3 + ** + ** which is not at all the same thing. + */ + if( pSubSrc->nSrc>1 && (pSubitem->jointype & JT_OUTER)!=0 ){ + return 0; + } + + /* Restriction 12: If the subquery is the right operand of a left outer + ** join, make sure the subquery has no WHERE clause. + ** An examples of why this is not allowed: + ** + ** t1 LEFT OUTER JOIN (SELECT * FROM t2 WHERE t2.x>0) + ** + ** If we flatten the above, we would get + ** + ** (t1 LEFT OUTER JOIN t2) WHERE t2.x>0 + ** + ** But the t2.x>0 test will always fail on a NULL row of t2, which + ** effectively converts the OUTER JOIN into an INNER JOIN. + */ + if( (pSubitem->jointype & JT_OUTER)!=0 && pSub->pWhere!=0 ){ + return 0; + } + + /* If we reach this point, it means flattening is permitted for the + ** iFrom-th entry of the FROM clause in the outer query. + */ + + /* Move all of the FROM elements of the subquery into the + ** the FROM clause of the outer query. Before doing this, remember + ** the cursor number for the original outer query FROM element in + ** iParent. The iParent cursor will never be used. Subsequent code + ** will scan expressions looking for iParent references and replace + ** those references with expressions that resolve to the subquery FROM + ** elements we are now copying in. + */ + iParent = pSubitem->iCursor; + { + int nSubSrc = pSubSrc->nSrc; + int jointype = pSubitem->jointype; + + sqlite3DeleteTable(pSubitem->pTab); + sqlite3_free(pSubitem->zDatabase); + sqlite3_free(pSubitem->zName); + sqlite3_free(pSubitem->zAlias); + pSubitem->pTab = 0; + pSubitem->zDatabase = 0; + pSubitem->zName = 0; + pSubitem->zAlias = 0; + if( nSubSrc>1 ){ + int extra = nSubSrc - 1; + for(i=1; ipSrc = 0; + return 1; + } + } + p->pSrc = pSrc; + for(i=pSrc->nSrc-1; i-extra>=iFrom; i--){ + pSrc->a[i] = pSrc->a[i-extra]; + } + } + for(i=0; ia[i+iFrom] = pSubSrc->a[i]; + memset(&pSubSrc->a[i], 0, sizeof(pSubSrc->a[i])); + } + pSrc->a[iFrom].jointype = jointype; + } + + /* Now begin substituting subquery result set expressions for + ** references to the iParent in the outer query. + ** + ** Example: + ** + ** SELECT a+5, b*10 FROM (SELECT x*3 AS a, y+10 AS b FROM t1) WHERE a>b; + ** \ \_____________ subquery __________/ / + ** \_____________________ outer query ______________________________/ + ** + ** We look at every expression in the outer query and every place we see + ** "a" we substitute "x*3" and every place we see "b" we substitute "y+10". + */ + pList = p->pEList; + for(i=0; inExpr; i++){ + Expr *pExpr; + if( pList->a[i].zName==0 && (pExpr = pList->a[i].pExpr)->span.z!=0 ){ + pList->a[i].zName = + sqlite3DbStrNDup(db, (char*)pExpr->span.z, pExpr->span.n); + } + } + substExprList(db, p->pEList, iParent, pSub->pEList); + if( isAgg ){ + substExprList(db, p->pGroupBy, iParent, pSub->pEList); + substExpr(db, p->pHaving, iParent, pSub->pEList); + } + if( pSub->pOrderBy ){ + assert( p->pOrderBy==0 ); + p->pOrderBy = pSub->pOrderBy; + pSub->pOrderBy = 0; + }else if( p->pOrderBy ){ + substExprList(db, p->pOrderBy, iParent, pSub->pEList); + } + if( pSub->pWhere ){ + pWhere = sqlite3ExprDup(db, pSub->pWhere); + }else{ + pWhere = 0; + } + if( subqueryIsAgg ){ + assert( p->pHaving==0 ); + p->pHaving = p->pWhere; + p->pWhere = pWhere; + substExpr(db, p->pHaving, iParent, pSub->pEList); + p->pHaving = sqlite3ExprAnd(db, p->pHaving, + sqlite3ExprDup(db, pSub->pHaving)); + assert( p->pGroupBy==0 ); + p->pGroupBy = sqlite3ExprListDup(db, pSub->pGroupBy); + }else{ + substExpr(db, p->pWhere, iParent, pSub->pEList); + p->pWhere = sqlite3ExprAnd(db, p->pWhere, pWhere); + } + + /* The flattened query is distinct if either the inner or the + ** outer query is distinct. + */ + p->isDistinct = p->isDistinct || pSub->isDistinct; + + /* + ** SELECT ... FROM (SELECT ... LIMIT a OFFSET b) LIMIT x OFFSET y; + ** + ** One is tempted to try to add a and b to combine the limits. But this + ** does not work if either limit is negative. + */ + if( pSub->pLimit ){ + p->pLimit = pSub->pLimit; + pSub->pLimit = 0; + } + + /* Finially, delete what is left of the subquery and return + ** success. + */ + sqlite3SelectDelete(pSub); + return 1; +} +#endif /* SQLITE_OMIT_VIEW */ + +/* +** Analyze the SELECT statement passed in as an argument to see if it +** is a simple min() or max() query. If it is and this query can be +** satisfied using a single seek to the beginning or end of an index, +** then generate the code for this SELECT and return 1. If this is not a +** simple min() or max() query, then return 0; +** +** A simply min() or max() query looks like this: +** +** SELECT min(a) FROM table; +** SELECT max(a) FROM table; +** +** The query may have only a single table in its FROM argument. There +** can be no GROUP BY or HAVING or WHERE clauses. The result set must +** be the min() or max() of a single column of the table. The column +** in the min() or max() function must be indexed. +** +** The parameters to this routine are the same as for sqlite3Select(). +** See the header comment on that routine for additional information. +*/ +static int simpleMinMaxQuery(Parse *pParse, Select *p, int eDest, int iParm){ + Expr *pExpr; + int iCol; + Table *pTab; + Index *pIdx; + int base; + Vdbe *v; + int seekOp; + ExprList *pEList, *pList, eList; + ExprList::ExprList_item eListItem; + SrcList *pSrc; + int brk; + int iDb; + + /* Check to see if this query is a simple min() or max() query. Return + ** zero if it is not. + */ + if( p->pGroupBy || p->pHaving || p->pWhere ) return 0; + pSrc = p->pSrc; + if( pSrc->nSrc!=1 ) return 0; + pEList = p->pEList; + if( pEList->nExpr!=1 ) return 0; + pExpr = pEList->a[0].pExpr; + if( pExpr->op!=TK_AGG_FUNCTION ) return 0; + pList = pExpr->pList; + if( pList==0 || pList->nExpr!=1 ) return 0; + if( pExpr->token.n!=3 ) return 0; + if( sqlite3StrNICmp((char*)pExpr->token.z,"min",3)==0 ){ + seekOp = OP_Rewind; + }else if( sqlite3StrNICmp((char*)pExpr->token.z,"max",3)==0 ){ + seekOp = OP_Last; + }else{ + return 0; + } + pExpr = pList->a[0].pExpr; + if( pExpr->op!=TK_COLUMN ) return 0; + iCol = pExpr->iColumn; + pTab = pSrc->a[0].pTab; + + /* This optimization cannot be used with virtual tables. */ + if( IsVirtual(pTab) ) return 0; + + /* If we get to here, it means the query is of the correct form. + ** Check to make sure we have an index and make pIdx point to the + ** appropriate index. If the min() or max() is on an INTEGER PRIMARY + ** key column, no index is necessary so set pIdx to NULL. If no + ** usable index is found, return 0. + */ + if( iCol<0 ){ + pIdx = 0; + }else{ + CollSeq *pColl = sqlite3ExprCollSeq(pParse, pExpr); + if( pColl==0 ) return 0; + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + assert( pIdx->nColumn>=1 ); + if( pIdx->aiColumn[0]==iCol && + 0==sqlite3StrICmp(pIdx->azColl[0], pColl->zName) ){ + break; + } + } + if( pIdx==0 ) return 0; + } + + /* Identify column types if we will be using the callback. This + ** step is skipped if the output is going to a table or a memory cell. + ** The column names have already been generated in the calling function. + */ + v = sqlite3GetVdbe(pParse); + if( v==0 ) return 0; + + /* If the output is destined for a temporary table, open that table. + */ + if( eDest==SRT_EphemTab ){ + sqlite3VdbeAddOp(v, OP_OpenEphemeral, iParm, 1); + } + + /* Generating code to find the min or the max. Basically all we have + ** to do is find the first or the last entry in the chosen index. If + ** the min() or max() is on the INTEGER PRIMARY KEY, then find the first + ** or last entry in the main table. + */ + iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); + assert( iDb>=0 || pTab->isEphem ); + sqlite3CodeVerifySchema(pParse, iDb); + sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName); + base = pSrc->a[0].iCursor; + brk = sqlite3VdbeMakeLabel(v); + computeLimitRegisters(pParse, p, brk); + if( pSrc->a[0].pSelect==0 ){ + sqlite3OpenTable(pParse, base, iDb, pTab, OP_OpenRead); + } + if( pIdx==0 ){ + sqlite3VdbeAddOp(v, seekOp, base, 0); + }else{ + /* Even though the cursor used to open the index here is closed + ** as soon as a single value has been read from it, allocate it + ** using (pParse->nTab++) to prevent the cursor id from being + ** reused. This is important for statements of the form + ** "INSERT INTO x SELECT max() FROM x". + */ + int iIdx; + KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx); + iIdx = pParse->nTab++; + assert( pIdx->pSchema==pTab->pSchema ); + sqlite3VdbeAddOp(v, OP_Integer, iDb, 0); + sqlite3VdbeOp3(v, OP_OpenRead, iIdx, pIdx->tnum, + (char*)pKey, P3_KEYINFO_HANDOFF); + if( seekOp==OP_Rewind ){ + sqlite3VdbeAddOp(v, OP_Null, 0, 0); + sqlite3VdbeAddOp(v, OP_MakeRecord, 1, 0); + seekOp = OP_MoveGt; + } + if( pIdx->aSortOrder[0]==SQLITE_SO_DESC ){ + /* Ticket #2514: invert the seek operator if we are using + ** a descending index. */ + if( seekOp==OP_Last ){ + seekOp = OP_Rewind; + }else{ + assert( seekOp==OP_MoveGt ); + seekOp = OP_MoveLt; + } + } + sqlite3VdbeAddOp(v, seekOp, iIdx, 0); + sqlite3VdbeAddOp(v, OP_IdxRowid, iIdx, 0); + sqlite3VdbeAddOp(v, OP_Close, iIdx, 0); + sqlite3VdbeAddOp(v, OP_MoveGe, base, 0); + } + eList.nExpr = 1; + memset(&eListItem, 0, sizeof(eListItem)); + eList.a = &eListItem; + eList.a[0].pExpr = pExpr; + selectInnerLoop(pParse, p, &eList, 0, 0, 0, -1, eDest, iParm, brk, brk, 0); + sqlite3VdbeResolveLabel(v, brk); + sqlite3VdbeAddOp(v, OP_Close, base, 0); + + return 1; +} + +/* +** This routine resolves any names used in the result set of the +** supplied SELECT statement. If the SELECT statement being resolved +** is a sub-select, then pOuterNC is a pointer to the NameContext +** of the parent SELECT. +*/ +int sqlite3SelectResolve( + Parse *pParse, /* The parser context */ + Select *p, /* The SELECT statement being coded. */ + NameContext *pOuterNC /* The outer name context. May be NULL. */ +){ + ExprList *pEList; /* Result set. */ + int i; /* For-loop variable used in multiple places */ + NameContext sNC; /* Local name-context */ + ExprList *pGroupBy; /* The group by clause */ + + /* If this routine has run before, return immediately. */ + if( p->isResolved ){ + assert( !pOuterNC ); + return SQLITE_OK; + } + p->isResolved = 1; + + /* If there have already been errors, do nothing. */ + if( pParse->nErr>0 ){ + return SQLITE_ERROR; + } + + /* Prepare the select statement. This call will allocate all cursors + ** required to handle the tables and subqueries in the FROM clause. + */ + if( prepSelectStmt(pParse, p) ){ + return SQLITE_ERROR; + } + + /* Resolve the expressions in the LIMIT and OFFSET clauses. These + ** are not allowed to refer to any names, so pass an empty NameContext. + */ + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = pParse; + if( sqlite3ExprResolveNames(&sNC, p->pLimit) || + sqlite3ExprResolveNames(&sNC, p->pOffset) ){ + return SQLITE_ERROR; + } + + /* Set up the local name-context to pass to ExprResolveNames() to + ** resolve the expression-list. + */ + sNC.allowAgg = 1; + sNC.pSrcList = p->pSrc; + sNC.pNext = pOuterNC; + + /* Resolve names in the result set. */ + pEList = p->pEList; + if( !pEList ) return SQLITE_ERROR; + for(i=0; inExpr; i++){ + Expr *pX = pEList->a[i].pExpr; + if( sqlite3ExprResolveNames(&sNC, pX) ){ + return SQLITE_ERROR; + } + } + + /* If there are no aggregate functions in the result-set, and no GROUP BY + ** expression, do not allow aggregates in any of the other expressions. + */ + assert( !p->isAgg ); + pGroupBy = p->pGroupBy; + if( pGroupBy || sNC.hasAgg ){ + p->isAgg = 1; + }else{ + sNC.allowAgg = 0; + } + + /* If a HAVING clause is present, then there must be a GROUP BY clause. + */ + if( p->pHaving && !pGroupBy ){ + sqlite3ErrorMsg(pParse, "a GROUP BY clause is required before HAVING"); + return SQLITE_ERROR; + } + + /* Add the expression list to the name-context before parsing the + ** other expressions in the SELECT statement. This is so that + ** expressions in the WHERE clause (etc.) can refer to expressions by + ** aliases in the result set. + ** + ** Minor point: If this is the case, then the expression will be + ** re-evaluated for each reference to it. + */ + sNC.pEList = p->pEList; + if( sqlite3ExprResolveNames(&sNC, p->pWhere) || + sqlite3ExprResolveNames(&sNC, p->pHaving) ){ + return SQLITE_ERROR; + } + if( p->pPrior==0 ){ + if( processOrderGroupBy(pParse, p, p->pOrderBy, 1, &sNC.hasAgg) ){ + return SQLITE_ERROR; + } + } + if( processOrderGroupBy(pParse, p, pGroupBy, 0, &sNC.hasAgg) ){ + return SQLITE_ERROR; + } + + if( pParse->db->mallocFailed ){ + return SQLITE_NOMEM; + } + + /* Make sure the GROUP BY clause does not contain aggregate functions. + */ + if( pGroupBy ){ + ExprList::ExprList_item *pItem; + + for(i=0, pItem=pGroupBy->a; inExpr; i++, pItem++){ + if( ExprHasProperty(pItem->pExpr, EP_Agg) ){ + sqlite3ErrorMsg(pParse, "aggregate functions are not allowed in " + "the GROUP BY clause"); + return SQLITE_ERROR; + } + } + } + + /* If this is one SELECT of a compound, be sure to resolve names + ** in the other SELECTs. + */ + if( p->pPrior ){ + return sqlite3SelectResolve(pParse, p->pPrior, pOuterNC); + }else{ + return SQLITE_OK; + } +} + +/* +** Reset the aggregate accumulator. +** +** The aggregate accumulator is a set of memory cells that hold +** intermediate results while calculating an aggregate. This +** routine simply stores NULLs in all of those memory cells. +*/ +static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo){ + Vdbe *v = pParse->pVdbe; + int i=0; + AggInfo::AggInfo_func *pFunc; + if( pAggInfo->nFunc+pAggInfo->nColumn==0 ){ + return; + } + for(i=0; inColumn; i++){ + sqlite3VdbeAddOp(v, OP_MemNull, pAggInfo->aCol[i].iMem, 0); + } + for(pFunc=pAggInfo->aFunc, i=0; inFunc; i++, pFunc++){ + sqlite3VdbeAddOp(v, OP_MemNull, pFunc->iMem, 0); + if( pFunc->iDistinct>=0 ){ + Expr *pE = pFunc->pExpr; + if( pE->pList==0 || pE->pList->nExpr!=1 ){ + sqlite3ErrorMsg(pParse, "DISTINCT in aggregate must be followed " + "by an expression"); + pFunc->iDistinct = -1; + }else{ + KeyInfo *pKeyInfo = keyInfoFromExprList(pParse, pE->pList); + sqlite3VdbeOp3(v, OP_OpenEphemeral, pFunc->iDistinct, 0, + (char*)pKeyInfo, P3_KEYINFO_HANDOFF); + } + } + } +} + +/* +** Invoke the OP_AggFinalize opcode for every aggregate function +** in the AggInfo structure. +*/ +static void finalizeAggFunctions(Parse *pParse, AggInfo *pAggInfo){ + Vdbe *v = pParse->pVdbe; + int i; + AggInfo::AggInfo_func *pF; + for(i=0, pF=pAggInfo->aFunc; inFunc; i++, pF++){ + ExprList *pList = pF->pExpr->pList; + sqlite3VdbeOp3(v, OP_AggFinal, pF->iMem, pList ? pList->nExpr : 0, + (const char*)pF->pFunc, P3_FUNCDEF); + } +} + +/* +** Update the accumulator memory cells for an aggregate based on +** the current cursor position. +*/ +static void updateAccumulator(Parse *pParse, AggInfo *pAggInfo){ + Vdbe *v = pParse->pVdbe; + int i; + AggInfo::AggInfo_func *pF; + AggInfo::AggInfo_col *pC; + + pAggInfo->directMode = 1; + for(i=0, pF=pAggInfo->aFunc; inFunc; i++, pF++){ + int nArg; + int addrNext = 0; + ExprList *pList = pF->pExpr->pList; + if( pList ){ + nArg = pList->nExpr; + sqlite3ExprCodeExprList(pParse, pList); + }else{ + nArg = 0; + } + if( pF->iDistinct>=0 ){ + addrNext = sqlite3VdbeMakeLabel(v); + assert( nArg==1 ); + codeDistinct(v, pF->iDistinct, addrNext, 1); + } + if( pF->pFunc->needCollSeq ){ + CollSeq *pColl = 0; + ExprList::ExprList_item *pItem; + int j; + assert( pList!=0 ); /* pList!=0 if pF->pFunc->needCollSeq is true */ + for(j=0, pItem=pList->a; !pColl && jpExpr); + } + if( !pColl ){ + pColl = pParse->db->pDfltColl; + } + sqlite3VdbeOp3(v, OP_CollSeq, 0, 0, (char *)pColl, P3_COLLSEQ); + } + sqlite3VdbeOp3(v, OP_AggStep, pF->iMem, nArg, (const char*)pF->pFunc, P3_FUNCDEF); + if( addrNext ){ + sqlite3VdbeResolveLabel(v, addrNext); + } + } + for(i=0, pC=pAggInfo->aCol; inAccumulator; i++, pC++){ + sqlite3ExprCode(pParse, pC->pExpr); + sqlite3VdbeAddOp(v, OP_MemStore, pC->iMem, 1); + } + pAggInfo->directMode = 0; +} + + +/* +** Generate code for the given SELECT statement. +** +** The results are distributed in various ways depending on the +** value of eDest and iParm. +** +** eDest Value Result +** ------------ ------------------------------------------- +** SRT_Callback Invoke the callback for each row of the result. +** +** SRT_Mem Store first result in memory cell iParm +** +** SRT_Set Store results as keys of table iParm. +** +** SRT_Union Store results as a key in a temporary table iParm +** +** SRT_Except Remove results from the temporary table iParm. +** +** SRT_Table Store results in temporary table iParm +** +** The table above is incomplete. Additional eDist value have be added +** since this comment was written. See the selectInnerLoop() function for +** a complete listing of the allowed values of eDest and their meanings. +** +** This routine returns the number of errors. If any errors are +** encountered, then an appropriate error message is left in +** pParse->zErrMsg. +** +** This routine does NOT free the Select structure passed in. The +** calling function needs to do that. +** +** The pParent, parentTab, and *pParentAgg fields are filled in if this +** SELECT is a subquery. This routine may try to combine this SELECT +** with its parent to form a single flat query. In so doing, it might +** change the parent query from a non-aggregate to an aggregate query. +** For that reason, the pParentAgg flag is passed as a pointer, so it +** can be changed. +** +** Example 1: The meaning of the pParent parameter. +** +** SELECT * FROM t1 JOIN (SELECT x, count(*) FROM t2) JOIN t3; +** \ \_______ subquery _______/ / +** \ / +** \____________________ outer query ___________________/ +** +** This routine is called for the outer query first. For that call, +** pParent will be NULL. During the processing of the outer query, this +** routine is called recursively to handle the subquery. For the recursive +** call, pParent will point to the outer query. Because the subquery is +** the second element in a three-way join, the parentTab parameter will +** be 1 (the 2nd value of a 0-indexed array.) +*/ +int sqlite3Select( + Parse *pParse, /* The parser context */ + Select *p, /* The SELECT statement being coded. */ + int eDest, /* How to dispose of the results */ + int iParm, /* A parameter used by the eDest disposal method */ + Select *pParent, /* Another SELECT for which this is a sub-query */ + int parentTab, /* Index in pParent->pSrc of this query */ + int *pParentAgg, /* True if pParent uses aggregate functions */ + char *aff /* If eDest is SRT_Union, the affinity string */ +){ + int i, j; /* Loop counters */ + WhereInfo *pWInfo; /* Return from sqlite3WhereBegin() */ + Vdbe *v; /* The virtual machine under construction */ + int isAgg; /* True for select lists like "count(*)" */ + ExprList *pEList; /* List of columns to extract. */ + SrcList *pTabList; /* List of tables to select from */ + Expr *pWhere; /* The WHERE clause. May be NULL */ + ExprList *pOrderBy; /* The ORDER BY clause. May be NULL */ + ExprList *pGroupBy; /* The GROUP BY clause. May be NULL */ + Expr *pHaving; /* The HAVING clause. May be NULL */ + int isDistinct; /* True if the DISTINCT keyword is present */ + int distinct; /* Table to use for the distinct set */ + int rc = 1; /* Value to return from this function */ + int addrSortIndex; /* Address of an OP_OpenEphemeral instruction */ + AggInfo sAggInfo; /* Information used by aggregate queries */ + int iEnd; /* Address of the end of the query */ + sqlite3 *db; /* The database connection */ + + db = pParse->db; + if( p==0 || db->mallocFailed || pParse->nErr ){ + return 1; + } + if( sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0) ) return 1; + memset(&sAggInfo, 0, sizeof(sAggInfo)); + + pOrderBy = p->pOrderBy; + if( IgnorableOrderby(eDest) ){ + p->pOrderBy = 0; + } + if( sqlite3SelectResolve(pParse, p, 0) ){ + goto select_end; + } + p->pOrderBy = pOrderBy; + +#ifndef SQLITE_OMIT_COMPOUND_SELECT + /* If there is are a sequence of queries, do the earlier ones first. + */ + if( p->pPrior ){ + if( p->pRightmost==0 ){ + Select *pLoop, *pRight = 0; + int cnt = 0; + for(pLoop=p; pLoop; pLoop=pLoop->pPrior, cnt++){ + pLoop->pRightmost = p; + pLoop->pNext = pRight; + pRight = pLoop; + } + if( SQLITE_MAX_COMPOUND_SELECT>0 && cnt>SQLITE_MAX_COMPOUND_SELECT ){ + sqlite3ErrorMsg(pParse, "too many terms in compound SELECT"); + return 1; + } + } + return multiSelect(pParse, p, eDest, iParm, aff); + } +#endif + + /* Make local copies of the parameters for this query. + */ + pTabList = p->pSrc; + pWhere = p->pWhere; + pGroupBy = p->pGroupBy; + pHaving = p->pHaving; + isAgg = p->isAgg; + isDistinct = p->isDistinct; + pEList = p->pEList; + if( pEList==0 ) goto select_end; + + /* + ** Do not even attempt to generate any code if we have already seen + ** errors before this routine starts. + */ + if( pParse->nErr>0 ) goto select_end; + + /* If writing to memory or generating a set + ** only a single column may be output. + */ +#ifndef SQLITE_OMIT_SUBQUERY + if( checkForMultiColumnSelectError(pParse, eDest, pEList->nExpr) ){ + goto select_end; + } +#endif + + /* ORDER BY is ignored for some destinations. + */ + if( IgnorableOrderby(eDest) ){ + pOrderBy = 0; + } + + /* Begin generating code. + */ + v = sqlite3GetVdbe(pParse); + if( v==0 ) goto select_end; + + /* Generate code for all sub-queries in the FROM clause + */ +#if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) + for(i=0; inSrc; i++){ + const char *zSavedAuthContext = 0; + int needRestoreContext; + SrcList::SrcList_item *pItem = &pTabList->a[i]; + + if( pItem->pSelect==0 || pItem->isPopulated ) continue; + if( pItem->zName!=0 ){ + zSavedAuthContext = pParse->zAuthContext; + pParse->zAuthContext = pItem->zName; + needRestoreContext = 1; + }else{ + needRestoreContext = 0; + } +#if defined(SQLITE_TEST) || SQLITE_MAX_EXPR_DEPTH>0 + /* Increment Parse.nHeight by the height of the largest expression + ** tree refered to by this, the parent select. The child select + ** may contain expression trees of at most + ** (SQLITE_MAX_EXPR_DEPTH-Parse.nHeight) height. This is a bit + ** more conservative than necessary, but much easier than enforcing + ** an exact limit. + */ + pParse->nHeight += sqlite3SelectExprHeight(p); +#endif + sqlite3Select(pParse, pItem->pSelect, SRT_EphemTab, + pItem->iCursor, p, i, &isAgg, 0); + if( db->mallocFailed ){ + goto select_end; + } +#if defined(SQLITE_TEST) || SQLITE_MAX_EXPR_DEPTH>0 + pParse->nHeight -= sqlite3SelectExprHeight(p); +#endif + if( needRestoreContext ){ + pParse->zAuthContext = zSavedAuthContext; + } + pTabList = p->pSrc; + pWhere = p->pWhere; + if( !IgnorableOrderby(eDest) ){ + pOrderBy = p->pOrderBy; + } + pGroupBy = p->pGroupBy; + pHaving = p->pHaving; + isDistinct = p->isDistinct; + } +#endif + + /* Check for the special case of a min() or max() function by itself + ** in the result set. + */ + if( simpleMinMaxQuery(pParse, p, eDest, iParm) ){ + rc = 0; + goto select_end; + } + + /* Check to see if this is a subquery that can be "flattened" into its parent. + ** If flattening is a possiblity, do so and return immediately. + */ +#ifndef SQLITE_OMIT_VIEW + if( pParent && pParentAgg && + flattenSubquery(db, pParent, parentTab, *pParentAgg, isAgg) ){ + if( isAgg ) *pParentAgg = 1; + goto select_end; + } +#endif + + /* If possible, rewrite the query to use GROUP BY instead of DISTINCT. + ** GROUP BY may use an index, DISTINCT never does. + */ + if( p->isDistinct && !p->isAgg && !p->pGroupBy ){ + p->pGroupBy = sqlite3ExprListDup(db, p->pEList); + pGroupBy = p->pGroupBy; + p->isDistinct = 0; + isDistinct = 0; + } + + /* If there is an ORDER BY clause, then this sorting + ** index might end up being unused if the data can be + ** extracted in pre-sorted order. If that is the case, then the + ** OP_OpenEphemeral instruction will be changed to an OP_Noop once + ** we figure out that the sorting index is not needed. The addrSortIndex + ** variable is used to facilitate that change. + */ + if( pOrderBy ){ + KeyInfo *pKeyInfo; + if( pParse->nErr ){ + goto select_end; + } + pKeyInfo = keyInfoFromExprList(pParse, pOrderBy); + pOrderBy->iECursor = pParse->nTab++; + p->addrOpenEphm[2] = addrSortIndex = + sqlite3VdbeOp3(v, OP_OpenEphemeral, pOrderBy->iECursor, pOrderBy->nExpr+2, (char*)pKeyInfo, P3_KEYINFO_HANDOFF); + }else{ + addrSortIndex = -1; + } + + /* If the output is destined for a temporary table, open that table. + */ + if( eDest==SRT_EphemTab ){ + sqlite3VdbeAddOp(v, OP_OpenEphemeral, iParm, pEList->nExpr); + } + + /* Set the limiter. + */ + iEnd = sqlite3VdbeMakeLabel(v); + computeLimitRegisters(pParse, p, iEnd); + + /* Open a virtual index to use for the distinct set. + */ + if( isDistinct ){ + KeyInfo *pKeyInfo; + assert( isAgg || pGroupBy ); + distinct = pParse->nTab++; + pKeyInfo = keyInfoFromExprList(pParse, p->pEList); + sqlite3VdbeOp3(v, OP_OpenEphemeral, distinct, 0, + (char*)pKeyInfo, P3_KEYINFO_HANDOFF); + }else{ + distinct = -1; + } + + /* Aggregate and non-aggregate queries are handled differently */ + if( !isAgg && pGroupBy==0 ){ + /* This case is for non-aggregate queries + ** Begin the database scan + */ + pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, &pOrderBy); + if( pWInfo==0 ) goto select_end; + + /* If sorting index that was created by a prior OP_OpenEphemeral + ** instruction ended up not being needed, then change the OP_OpenEphemeral + ** into an OP_Noop. + */ + if( addrSortIndex>=0 && pOrderBy==0 ){ + sqlite3VdbeChangeToNoop(v, addrSortIndex, 1); + p->addrOpenEphm[2] = -1; + } + + /* Use the standard inner loop + */ + assert(!isDistinct); + if( selectInnerLoop(pParse, p, pEList, 0, 0, pOrderBy, -1, eDest, + iParm, pWInfo->iContinue, pWInfo->iBreak, aff) ){ + goto select_end; + } + + /* End the database scan loop. + */ + sqlite3WhereEnd(pWInfo); + }else{ + /* This is the processing for aggregate queries */ + NameContext sNC; /* Name context for processing aggregate information */ + int iAMem; /* First Mem address for storing current GROUP BY */ + int iBMem; /* First Mem address for previous GROUP BY */ + int iUseFlag; /* Mem address holding flag indicating that at least + ** one row of the input to the aggregator has been + ** processed */ + int iAbortFlag; /* Mem address which causes query abort if positive */ + int groupBySort; /* Rows come from source in GROUP BY order */ + + + /* The following variables hold addresses or labels for parts of the + ** virtual machine program we are putting together */ + int addrOutputRow; /* Start of subroutine that outputs a result row */ + int addrSetAbort; /* Set the abort flag and return */ + int addrInitializeLoop; /* Start of code that initializes the input loop */ + int addrTopOfLoop; /* Top of the input loop */ + int addrGroupByChange; /* Code that runs when any GROUP BY term changes */ + int addrProcessRow; /* Code to process a single input row */ + int addrEnd; /* End of all processing */ + int addrSortingIdx; /* The OP_OpenEphemeral for the sorting index */ + int addrReset; /* Subroutine for resetting the accumulator */ + + addrEnd = sqlite3VdbeMakeLabel(v); + + /* Convert TK_COLUMN nodes into TK_AGG_COLUMN and make entries in + ** sAggInfo for all TK_AGG_FUNCTION nodes in expressions of the + ** SELECT statement. + */ + memset(&sNC, 0, sizeof(sNC)); + sNC.pParse = pParse; + sNC.pSrcList = pTabList; + sNC.pAggInfo = &sAggInfo; + sAggInfo.nSortingColumn = pGroupBy ? pGroupBy->nExpr+1 : 0; + sAggInfo.pGroupBy = pGroupBy; + if( sqlite3ExprAnalyzeAggList(&sNC, pEList) ){ + goto select_end; + } + if( sqlite3ExprAnalyzeAggList(&sNC, pOrderBy) ){ + goto select_end; + } + if( pHaving && sqlite3ExprAnalyzeAggregates(&sNC, pHaving) ){ + goto select_end; + } + sAggInfo.nAccumulator = sAggInfo.nColumn; + for(i=0; ipList) ){ + goto select_end; + } + } + if( db->mallocFailed ) goto select_end; + + /* Processing for aggregates with GROUP BY is very different and + ** much more complex than aggregates without a GROUP BY. + */ + if( pGroupBy ){ + KeyInfo *pKeyInfo; /* Keying information for the group by clause */ + + /* Create labels that we will be needing + */ + + addrInitializeLoop = sqlite3VdbeMakeLabel(v); + addrGroupByChange = sqlite3VdbeMakeLabel(v); + addrProcessRow = sqlite3VdbeMakeLabel(v); + + /* If there is a GROUP BY clause we might need a sorting index to + ** implement it. Allocate that sorting index now. If it turns out + ** that we do not need it after all, the OpenEphemeral instruction + ** will be converted into a Noop. + */ + sAggInfo.sortingIdx = pParse->nTab++; + pKeyInfo = keyInfoFromExprList(pParse, pGroupBy); + addrSortingIdx = + sqlite3VdbeOp3(v, OP_OpenEphemeral, sAggInfo.sortingIdx, + sAggInfo.nSortingColumn, + (char*)pKeyInfo, P3_KEYINFO_HANDOFF); + + /* Initialize memory locations used by GROUP BY aggregate processing + */ + iUseFlag = pParse->nMem++; + iAbortFlag = pParse->nMem++; + iAMem = pParse->nMem; + pParse->nMem += pGroupBy->nExpr; + iBMem = pParse->nMem; + pParse->nMem += pGroupBy->nExpr; + sqlite3VdbeAddOp(v, OP_MemInt, 0, iAbortFlag); + VdbeComment((v, "# clear abort flag")); + sqlite3VdbeAddOp(v, OP_MemInt, 0, iUseFlag); + VdbeComment((v, "# indicate accumulator empty")); + sqlite3VdbeAddOp(v, OP_Goto, 0, addrInitializeLoop); + + /* Generate a subroutine that outputs a single row of the result + ** set. This subroutine first looks at the iUseFlag. If iUseFlag + ** is less than or equal to zero, the subroutine is a no-op. If + ** the processing calls for the query to abort, this subroutine + ** increments the iAbortFlag memory location before returning in + ** order to signal the caller to abort. + */ + addrSetAbort = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeAddOp(v, OP_MemInt, 1, iAbortFlag); + VdbeComment((v, "# set abort flag")); + sqlite3VdbeAddOp(v, OP_Return, 0, 0); + addrOutputRow = sqlite3VdbeCurrentAddr(v); + sqlite3VdbeAddOp(v, OP_IfMemPos, iUseFlag, addrOutputRow+2); + VdbeComment((v, "# Groupby result generator entry point")); + sqlite3VdbeAddOp(v, OP_Return, 0, 0); + finalizeAggFunctions(pParse, &sAggInfo); + if( pHaving ){ + sqlite3ExprIfFalse(pParse, pHaving, addrOutputRow+1, 1); + } + rc = selectInnerLoop(pParse, p, p->pEList, 0, 0, pOrderBy, + distinct, eDest, iParm, + addrOutputRow+1, addrSetAbort, aff); + if( rc ){ + goto select_end; + } + sqlite3VdbeAddOp(v, OP_Return, 0, 0); + VdbeComment((v, "# end groupby result generator")); + + /* Generate a subroutine that will reset the group-by accumulator + */ + addrReset = sqlite3VdbeCurrentAddr(v); + resetAccumulator(pParse, &sAggInfo); + sqlite3VdbeAddOp(v, OP_Return, 0, 0); + + /* Begin a loop that will extract all source rows in GROUP BY order. + ** This might involve two separate loops with an OP_Sort in between, or + ** it might be a single loop that uses an index to extract information + ** in the right order to begin with. + */ + sqlite3VdbeResolveLabel(v, addrInitializeLoop); + sqlite3VdbeAddOp(v, OP_Gosub, 0, addrReset); + pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, &pGroupBy); + if( pWInfo==0 ) goto select_end; + if( pGroupBy==0 ){ + /* The optimizer is able to deliver rows in group by order so + ** we do not have to sort. The OP_OpenEphemeral table will be + ** cancelled later because we still need to use the pKeyInfo + */ + pGroupBy = p->pGroupBy; + groupBySort = 0; + }else{ + /* Rows are coming out in undetermined order. We have to push + ** each row into a sorting index, terminate the first loop, + ** then loop over the sorting index in order to get the output + ** in sorted order + */ + groupBySort = 1; + sqlite3ExprCodeExprList(pParse, pGroupBy); + sqlite3VdbeAddOp(v, OP_Sequence, sAggInfo.sortingIdx, 0); + j = pGroupBy->nExpr+1; + for(i=0; iiSorterColumnpTab, pCol->iColumn, pCol->iTable); + j++; + } + sqlite3VdbeAddOp(v, OP_MakeRecord, j, 0); + sqlite3VdbeAddOp(v, OP_IdxInsert, sAggInfo.sortingIdx, 0); + sqlite3WhereEnd(pWInfo); + sqlite3VdbeAddOp(v, OP_Sort, sAggInfo.sortingIdx, addrEnd); + VdbeComment((v, "# GROUP BY sort")); + sAggInfo.useSortingIdx = 1; + } + + /* Evaluate the current GROUP BY terms and store in b0, b1, b2... + ** (b0 is memory location iBMem+0, b1 is iBMem+1, and so forth) + ** Then compare the current GROUP BY terms against the GROUP BY terms + ** from the previous row currently stored in a0, a1, a2... + */ + addrTopOfLoop = sqlite3VdbeCurrentAddr(v); + for(j=0; jnExpr; j++){ + if( groupBySort ){ + sqlite3VdbeAddOp(v, OP_Column, sAggInfo.sortingIdx, j); + }else{ + sAggInfo.directMode = 1; + sqlite3ExprCode(pParse, pGroupBy->a[j].pExpr); + } + sqlite3VdbeAddOp(v, OP_MemStore, iBMem+j, jnExpr-1); + } + for(j=pGroupBy->nExpr-1; j>=0; j--){ + if( jnExpr-1 ){ + sqlite3VdbeAddOp(v, OP_MemLoad, iBMem+j, 0); + } + sqlite3VdbeAddOp(v, OP_MemLoad, iAMem+j, 0); + if( j==0 ){ + sqlite3VdbeAddOp(v, OP_Eq, 0x200, addrProcessRow); + }else{ + sqlite3VdbeAddOp(v, OP_Ne, 0x200, addrGroupByChange); + } + sqlite3VdbeChangeP3(v, -1, (const char*)pKeyInfo->aColl[j], P3_COLLSEQ); + } + + /* Generate code that runs whenever the GROUP BY changes. + ** Change in the GROUP BY are detected by the previous code + ** block. If there were no changes, this block is skipped. + ** + ** This code copies current group by terms in b0,b1,b2,... + ** over to a0,a1,a2. It then calls the output subroutine + ** and resets the aggregate accumulator registers in preparation + ** for the next GROUP BY batch. + */ + sqlite3VdbeResolveLabel(v, addrGroupByChange); + for(j=0; jnExpr; j++){ + sqlite3VdbeAddOp(v, OP_MemMove, iAMem+j, iBMem+j); + } + sqlite3VdbeAddOp(v, OP_Gosub, 0, addrOutputRow); + VdbeComment((v, "# output one row")); + sqlite3VdbeAddOp(v, OP_IfMemPos, iAbortFlag, addrEnd); + VdbeComment((v, "# check abort flag")); + sqlite3VdbeAddOp(v, OP_Gosub, 0, addrReset); + VdbeComment((v, "# reset accumulator")); + + /* Update the aggregate accumulators based on the content of + ** the current row + */ + sqlite3VdbeResolveLabel(v, addrProcessRow); + updateAccumulator(pParse, &sAggInfo); + sqlite3VdbeAddOp(v, OP_MemInt, 1, iUseFlag); + VdbeComment((v, "# indicate data in accumulator")); + + /* End of the loop + */ + if( groupBySort ){ + sqlite3VdbeAddOp(v, OP_Next, sAggInfo.sortingIdx, addrTopOfLoop); + }else{ + sqlite3WhereEnd(pWInfo); + sqlite3VdbeChangeToNoop(v, addrSortingIdx, 1); + } + + /* Output the final row of result + */ + sqlite3VdbeAddOp(v, OP_Gosub, 0, addrOutputRow); + VdbeComment((v, "# output final row")); + + } /* endif pGroupBy */ + else { + /* This case runs if the aggregate has no GROUP BY clause. The + ** processing is much simpler since there is only a single row + ** of output. + */ + resetAccumulator(pParse, &sAggInfo); + pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0); + if( pWInfo==0 ) goto select_end; + updateAccumulator(pParse, &sAggInfo); + sqlite3WhereEnd(pWInfo); + finalizeAggFunctions(pParse, &sAggInfo); + pOrderBy = 0; + if( pHaving ){ + sqlite3ExprIfFalse(pParse, pHaving, addrEnd, 1); + } + selectInnerLoop(pParse, p, p->pEList, 0, 0, 0, -1, + eDest, iParm, addrEnd, addrEnd, aff); + } + sqlite3VdbeResolveLabel(v, addrEnd); + + } /* endif aggregate query */ + + /* If there is an ORDER BY clause, then we need to sort the results + ** and send them to the callback one by one. + */ + if( pOrderBy ){ + generateSortTail(pParse, p, v, pEList->nExpr, eDest, iParm); + } + +#ifndef SQLITE_OMIT_SUBQUERY + /* If this was a subquery, we have now converted the subquery into a + ** temporary table. So set the SrcList_item.isPopulated flag to prevent + ** this subquery from being evaluated again and to force the use of + ** the temporary table. + */ + if( pParent ){ + assert( pParent->pSrc->nSrc>parentTab ); + assert( pParent->pSrc->a[parentTab].pSelect==p ); + pParent->pSrc->a[parentTab].isPopulated = 1; + } +#endif + + /* Jump here to skip this query + */ + sqlite3VdbeResolveLabel(v, iEnd); + + /* The SELECT was successfully coded. Set the return code to 0 + ** to indicate no errors. + */ + rc = 0; + + /* Control jumps to here if an error is encountered above, or upon + ** successful coding of the SELECT. + */ +select_end: + + /* Identify column names if we will be using them in a callback. This + ** step is skipped if the output is going to some other destination. + */ + if( rc==SQLITE_OK && eDest==SRT_Callback ){ + generateColumnNames(pParse, pTabList, pEList); + } + + sqlite3_free(sAggInfo.aCol); + sqlite3_free(sAggInfo.aFunc); + return rc; +} + +#if defined(SQLITE_DEBUG) +/* +******************************************************************************* +** The following code is used for testing and debugging only. The code +** that follows does not appear in normal builds. +** +** These routines are used to print out the content of all or part of a +** parse structures such as Select or Expr. Such printouts are useful +** for helping to understand what is happening inside the code generator +** during the execution of complex SELECT statements. +** +** These routine are not called anywhere from within the normal +** code base. Then are intended to be called from within the debugger +** or from temporary "printf" statements inserted for debugging. +*/ +void sqlite3PrintExpr(Expr *p){ + if( p->token.z && p->token.n>0 ){ + sqlite3DebugPrintf("(%.*s", p->token.n, p->token.z); + }else{ + sqlite3DebugPrintf("(%d", p->op); + } + if( p->pLeft ){ + sqlite3DebugPrintf(" "); + sqlite3PrintExpr(p->pLeft); + } + if( p->pRight ){ + sqlite3DebugPrintf(" "); + sqlite3PrintExpr(p->pRight); + } + sqlite3DebugPrintf(")"); +} +void sqlite3PrintExprList(ExprList *pList){ + int i; + for(i=0; inExpr; i++){ + sqlite3PrintExpr(pList->a[i].pExpr); + if( inExpr-1 ){ + sqlite3DebugPrintf(", "); + } + } +} +void sqlite3PrintSelect(Select *p, int indent){ + sqlite3DebugPrintf("%*sSELECT(%p) ", indent, "", p); + sqlite3PrintExprList(p->pEList); + sqlite3DebugPrintf("\n"); + if( p->pSrc ){ + char *zPrefix; + int i; + zPrefix = "FROM"; + for(i=0; ipSrc->nSrc; i++){ + struct SrcList_item *pItem = &p->pSrc->a[i]; + sqlite3DebugPrintf("%*s ", indent+6, zPrefix); + zPrefix = ""; + if( pItem->pSelect ){ + sqlite3DebugPrintf("(\n"); + sqlite3PrintSelect(pItem->pSelect, indent+10); + sqlite3DebugPrintf("%*s)", indent+8, ""); + }else if( pItem->zName ){ + sqlite3DebugPrintf("%s", pItem->zName); + } + if( pItem->pTab ){ + sqlite3DebugPrintf("(table: %s)", pItem->pTab->zName); + } + if( pItem->zAlias ){ + sqlite3DebugPrintf(" AS %s", pItem->zAlias); + } + if( ipSrc->nSrc-1 ){ + sqlite3DebugPrintf(","); + } + sqlite3DebugPrintf("\n"); + } + } + if( p->pWhere ){ + sqlite3DebugPrintf("%*s WHERE ", indent, ""); + sqlite3PrintExpr(p->pWhere); + sqlite3DebugPrintf("\n"); + } + if( p->pGroupBy ){ + sqlite3DebugPrintf("%*s GROUP BY ", indent, ""); + sqlite3PrintExprList(p->pGroupBy); + sqlite3DebugPrintf("\n"); + } + if( p->pHaving ){ + sqlite3DebugPrintf("%*s HAVING ", indent, ""); + sqlite3PrintExpr(p->pHaving); + sqlite3DebugPrintf("\n"); + } + if( p->pOrderBy ){ + sqlite3DebugPrintf("%*s ORDER BY ", indent, ""); + sqlite3PrintExprList(p->pOrderBy); + sqlite3DebugPrintf("\n"); + } +} +/* End of the structure debug printing code +*****************************************************************************/ +#endif /* defined(SQLITE_TEST) || defined(SQLITE_DEBUG) */ diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/sqlite3.def --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/sqlite3.def Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,94 @@ +EXPORTS +sqlite3_aggregate_context +sqlite3_aggregate_count +sqlite3_bind_blob +sqlite3_bind_double +sqlite3_bind_int +sqlite3_bind_int64 +sqlite3_bind_null +sqlite3_bind_parameter_count +sqlite3_bind_parameter_index +sqlite3_bind_parameter_name +sqlite3_bind_text +sqlite3_bind_text16 +sqlite3_busy_handler +sqlite3_busy_timeout +sqlite3_changes +sqlite3_close +sqlite3_collation_needed +sqlite3_collation_needed16 +sqlite3_column_blob +sqlite3_column_bytes +sqlite3_column_bytes16 +sqlite3_column_count +sqlite3_column_decltype +sqlite3_column_decltype16 +sqlite3_column_double +sqlite3_column_int +sqlite3_column_int64 +sqlite3_column_name +sqlite3_column_name16 +sqlite3_column_text +sqlite3_column_text16 +sqlite3_column_type +sqlite3_commit_hook +sqlite3_complete +sqlite3_complete16 +sqlite3_create_collation +sqlite3_create_collation16 +sqlite3_create_function +sqlite3_create_function16 +sqlite3_data_count +sqlite3_errcode +sqlite3_errmsg +sqlite3_errmsg16 +sqlite3_exec +sqlite3_finalize +sqlite3_free +sqlite3_free_table +sqlite3_get_auxdata +sqlite3_get_table +sqlite3_interrupt +sqlite3_last_insert_rowid +sqlite3_libversion +sqlite3_mprintf +sqlite3_open +sqlite3_open16 +sqlite3_prepare +sqlite3_prepare16 +;sqlite3_progress_handler +sqlite3_reset +sqlite3_result_blob +sqlite3_result_double +sqlite3_result_error +sqlite3_result_error16 +sqlite3_result_int +sqlite3_result_int64 +sqlite3_result_null +sqlite3_result_text +sqlite3_result_text16 +sqlite3_result_text16be +sqlite3_result_text16le +sqlite3_result_value +;sqlite3_set_authorizer +sqlite3_set_auxdata +sqlite3_snprintf +sqlite3_step +sqlite3_total_changes +sqlite3_trace +sqlite3_user_data +sqlite3_value_blob +sqlite3_value_bytes +sqlite3_value_bytes16 +sqlite3_value_double +sqlite3_value_int +sqlite3_value_int64 +sqlite3_value_text +sqlite3_value_text16 +sqlite3_value_text16be +sqlite3_value_text16le +sqlite3_value_type +sqlite3_vmprintf +sqlite3_malloc +sqlite3_free +sqlite3_strlen \ No newline at end of file diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/sqlite3.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/sqlite3.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,3859 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This header file defines the interface that the SQLite library +** presents to client programs. If a C-function, structure, datatype, +** or constant definition does not appear in this file, then it is +** not a published API of SQLite, is subject to change without +** notice, and should not be referenced by programs that use SQLite. +** +** Some of the definitions that are in this file are marked as +** "experimental". Experimental interfaces are normally new +** features recently added to SQLite. We do not anticipate changes +** to experimental interfaces but reserve to make minor changes if +** experience from use "in the wild" suggest such changes are prudent. +** +** The official C-language API documentation for SQLite is derived +** from comments in this file. This file is the authoritative source +** on how SQLite interfaces are suppose to operate. +** +** The name of this file under configuration management is "sqlite.h.in". +** The makefile makes some minor changes to this file (such as inserting +** the version number) and changes its name to "sqlite3.h" as +** part of the build process. +** +** @(#) $Id: sqlite3.h 1420 2009-01-13 15:06:30Z teknolog $ +*/ +#ifndef _SQLITE3_H_ +#define _SQLITE3_H_ +#include /* Needed for the definition of va_list */ +/* +** Make sure we can call this stuff from C++. +*/ +#ifdef __cplusplus +extern "C" { +#endif + +//#define EXPORT_C + +//#define /*IMPORT_C*/ + +/* +** Add the ability to override 'extern' +*/ +#ifndef SQLITE_EXTERN +# define SQLITE_EXTERN extern +#endif + +/* +** Make sure these symbols where not defined by some previous header +** file. +*/ +#ifdef SQLITE_VERSION +# undef SQLITE_VERSION +#endif +#ifdef SQLITE_VERSION_NUMBER +# undef SQLITE_VERSION_NUMBER +#endif + +/* +** CAPI3REF: Compile-Time Library Version Numbers {F10010} +** +** {F10011} The #define in the sqlite3.h header file named +** SQLITE_VERSION resolves to a string literal that identifies +** the version of the SQLite library in the format "X.Y.Z", where +** X is the major version number, Y is the minor version number and Z +** is the release number. The X.Y.Z might be followed by "alpha" or "beta". +** {END} For example "3.1.1beta". +** +** The X value is always 3 in SQLite. The X value only changes when +** backwards compatibility is broken and we intend to never break +** backwards compatibility. The Y value only changes when +** there are major feature enhancements that are forwards compatible +** but not backwards compatible. The Z value is incremented with +** each release but resets back to 0 when Y is incremented. +** +** {F10014} The SQLITE_VERSION_NUMBER #define resolves to an integer +** with the value (X*1000000 + Y*1000 + Z) where X, Y, and Z are as +** with SQLITE_VERSION. {END} For example, for version "3.1.1beta", +** SQLITE_VERSION_NUMBER is set to 3001001. To detect if they are using +** version 3.1.1 or greater at compile time, programs may use the test +** (SQLITE_VERSION_NUMBER>=3001001). +** +** See also: [sqlite3_libversion()] and [sqlite3_libversion_number()]. +*/ +#define SQLITE_VERSION "3.5.4" +#define SQLITE_VERSION_NUMBER 3005004 + +/* +** CAPI3REF: Run-Time Library Version Numbers {F10020} +** +** {F10021} The sqlite3_libversion_number() interface returns an integer +** equal to [SQLITE_VERSION_NUMBER]. {END} The value returned +** by this routine should only be different from the header values +** if the application is compiled using an sqlite3.h header from a +** different version of SQLite than library. Cautious programmers might +** include a check in their application to verify that +** sqlite3_libversion_number() always returns the value +** [SQLITE_VERSION_NUMBER]. +** +** {F10022} The sqlite3_version[] string constant contains the text of the +** [SQLITE_VERSION] string. {F10023} The sqlite3_libversion() function returns +** a pointer to the sqlite3_version[] string constant. {END} The +** sqlite3_libversion() function +** is provided for DLL users who can only access functions and not +** constants within the DLL. +*/ +const char sqlite3_version[] = SQLITE_VERSION; +/*IMPORT_C*/ const char *sqlite3_libversion(void); +/*IMPORT_C*/ int sqlite3_libversion_number(void); + + +void LogMessage(char *message); + +/* +** CAPI3REF: Test To See If The Library Is Threadsafe {F10100} +** +** {F10101} The sqlite3_threadsafe() routine returns nonzero +** if SQLite was compiled with its mutexes enabled or zero if +** SQLite was compiled with mutexes disabled. {END} If this +** routine returns false, then it is not safe for simultaneously +** running threads to both invoke SQLite interfaces. +** +** Really all this routine does is return true if SQLite was +** compiled with the -DSQLITE_THREADSAFE=1 option and false if +** compiled with -DSQLITE_THREADSAFE=0. If SQLite uses an +** application-defined mutex subsystem, malloc subsystem, collating +** sequence, VFS, SQL function, progress callback, commit hook, +** extension, or other accessories and these add-ons are not +** threadsafe, then clearly the combination will not be threadsafe +** either. Hence, this routine never reports that the library +** is guaranteed to be threadsafe, only when it is guaranteed not +** to be. +*/ +/*IMPORT_C*/ int sqlite3_threadsafe(void); + +/* +** CAPI3REF: Database Connection Handle {F12000} +** +** Each open SQLite database is represented by pointer to an instance of the +** opaque structure named "sqlite3". It is useful to think of an sqlite3 +** pointer as an object. The [sqlite3_open()], [sqlite3_open16()], and +** [sqlite3_open_v2()] interfaces are its constructors +** and [sqlite3_close()] is its destructor. There are many other interfaces +** (such as [sqlite3_prepare_v2()], [sqlite3_create_function()], and +** [sqlite3_busy_timeout()] to name but three) that are methods on this +** object. +*/ +typedef struct sqlite3 sqlite3; + + +/* +** CAPI3REF: 64-Bit Integer Types {F10200} +** +** Because there is no cross-platform way to specify such types +** SQLite includes typedefs for 64-bit signed and unsigned integers. +** {F10201} The sqlite_int64 and sqlite3_int64 types specify a +** 64-bit signed integer. {F10202} The sqlite_uint64 and +** sqlite3_uint64 types specify a 64-bit unsigned integer. {END} +** +** The sqlite3_int64 and sqlite3_uint64 are the preferred type +** definitions. The sqlite_int64 and sqlite_uint64 types are +** supported for backwards compatibility only. +*/ +#ifdef SQLITE_INT64_TYPE + typedef SQLITE_INT64_TYPE sqlite_int64; + typedef unsigned SQLITE_INT64_TYPE sqlite_uint64; +#elif defined(_MSC_VER) || defined(__BORLANDC__) + typedef __int64 sqlite_int64; + typedef unsigned __int64 sqlite_uint64; +#else + typedef long long int sqlite_int64; + typedef unsigned long long int sqlite_uint64; +#endif +typedef sqlite_int64 sqlite3_int64; +typedef sqlite_uint64 sqlite3_uint64; + +/* +** If compiling for a processor that lacks floating point support, +** substitute integer for floating-point +*/ +#ifdef SQLITE_OMIT_FLOATING_POINT +# define double sqlite3_int64 +#endif + +/* +** CAPI3REF: Closing A Database Connection {F12010} +** +** {F12011} The sqlite3_close() interfaces destroys an [sqlite3] object +** allocated by a prior call to [sqlite3_open()], [sqlite3_open16()], or +** [sqlite3_open_v2()]. {F12012} Sqlite3_close() releases all +** memory used by the connection and closes all open files. {END}. +** +** {F12013} If the database connection contains +** [sqlite3_stmt | prepared statements] that have not been finalized +** by [sqlite3_finalize()], then sqlite3_close() returns SQLITE_BUSY +** and leaves the connection open. {F12014} Giving sqlite3_close() +** a NULL pointer is a harmless no-op. {END} +** +** {U12015} Passing this routine a database connection that has already been +** closed results in undefined behavior. {U12016} If other interfaces that +** reference the same database connection are pending (either in the +** same thread or in different threads) when this routine is called, +** then the behavior is undefined and is almost certainly undesirable. +*/ +/*IMPORT_C*/ int sqlite3_close(sqlite3 *); + +/* +** The type for a callback function. +** This is legacy and deprecated. It is included for historical +** compatibility and is not documented. +*/ +typedef int (*sqlite3_callback)(void*,int,char**, char**); + +/* +** CAPI3REF: One-Step Query Execution Interface {F12100} +** +** {F12101} The sqlite3_exec() interface evaluates zero or more +** UTF-8 encoded, semicolon-separated SQL statements in the zero-terminated +** string of its second argument. {F12102} The SQL +** statements are evaluated in the context of the database connection +** specified by in the first argument. +** {F12103} SQL statements are prepared one by one using +** [sqlite3_prepare()] or the equivalent, evaluated +** using one or more calls to [sqlite3_step()], then destroyed +** using [sqlite3_finalize()]. {F12104} The return value of +** sqlite3_exec() is SQLITE_OK if all SQL statement run +** successfully. +** +** {F12105} If one or more of the SQL statements handed to +** sqlite3_exec() are queries, then +** the callback function specified by the 3rd parameter is +** invoked once for each row of the query result. {F12106} +** If the callback returns a non-zero value then the query +** is aborted, all subsequent SQL statements +** are skipped and the sqlite3_exec() function returns the [SQLITE_ABORT]. +** +** {F12107} The 4th parameter to sqlite3_exec() is an arbitrary pointer +** that is passed through to the callback function as its first parameter. +** +** {F12108} The 2nd parameter to the callback function is the number of +** columns in the query result. {F12109} The 3rd parameter to the callback +** is an array of pointers to strings holding the values for each column +** as extracted using [sqlite3_column_text()]. NULL values in the result +** set result in a NULL pointer. All other value are in their UTF-8 +** string representation. {F12117} +** The 4th parameter to the callback is an array of strings +** obtained using [sqlite3_column_name()] and holding +** the names of each column, also in UTF-8. +** +** {F12110} The callback function may be NULL, even for queries. A NULL +** callback is not an error. It just means that no callback +** will be invoked. +** +** {F12112} If an error occurs while parsing or evaluating the SQL +** then an appropriate error message is written into memory obtained +** from [sqlite3_malloc()] and *errmsg is made to point to that message +** assuming errmsg is not NULL. +** {U12113} The calling function is responsible for freeing the memory +** using [sqlite3_free()]. +** {F12116} If [sqlite3_malloc()] fails while attempting to generate +** the error message, *errmsg is set to NULL. +** {F12114} If errmsg is NULL then no attempt is made to generate an +** error message. Is the return code SQLITE_NOMEM or the original +** error code? What happens if there are multiple errors? +** Do we get code for the first error, or is the choice of reported +** error arbitrary? +** +** {F12115} The return value is is SQLITE_OK if there are no errors and +** some other [SQLITE_OK | return code] if there is an error. +** The particular return value depends on the type of error. {END} +*/ +/*IMPORT_C*/ int sqlite3_exec( + sqlite3*, /* An open database */ + const char *sql, /* SQL to be evaluted */ + int (*callback)(void*,int,char**,char**), /* Callback function */ + void *, /* 1st argument to callback */ + char **errmsg /* Error msg written here */ +); + +/* +** CAPI3REF: Result Codes {F10210} +** KEYWORDS: SQLITE_OK +** +** Many SQLite functions return an integer result code from the set shown +** above in order to indicates success or failure. +** +** {F10211} The result codes shown here are the only ones returned +** by SQLite in its default configuration. {F10212} However, the +** [sqlite3_extended_result_codes()] API can be used to set a database +** connectoin to return more detailed result codes. {END} +** +** See also: [SQLITE_IOERR_READ | extended result codes] +** +*/ +#define SQLITE_OK 0 /* Successful result */ +/* beginning-of-error-codes */ +#define SQLITE_ERROR 1 /* SQL error or missing database */ +#define SQLITE_INTERNAL 2 /* Internal logic error in SQLite */ +#define SQLITE_PERM 3 /* Access permission denied */ +#define SQLITE_ABORT 4 /* Callback routine requested an abort */ +#define SQLITE_BUSY 5 /* The database file is locked */ +#define SQLITE_LOCKED 6 /* A table in the database is locked */ +#define SQLITE_NOMEM 7 /* A malloc() failed */ +#define SQLITE_READONLY 8 /* Attempt to write a readonly database */ +#define SQLITE_INTERRUPT 9 /* Operation terminated by sqlite3_interrupt()*/ +#define SQLITE_IOERR 10 /* Some kind of disk I/O error occurred */ +#define SQLITE_CORRUPT 11 /* The database disk image is malformed */ +#define SQLITE_NOTFOUND 12 /* NOT USED. Table or record not found */ +#define SQLITE_FULL 13 /* Insertion failed because database is full */ +#define SQLITE_CANTOPEN 14 /* Unable to open the database file */ +#define SQLITE_PROTOCOL 15 /* NOT USED. Database lock protocol error */ +#define SQLITE_EMPTY 16 /* Database is empty */ +#define SQLITE_SCHEMA 17 /* The database schema changed */ +#define SQLITE_TOOBIG 18 /* String or BLOB exceeds size limit */ +#define SQLITE_CONSTRAINT 19 /* Abort due to constraint violation */ +#define SQLITE_MISMATCH 20 /* Data type mismatch */ +#define SQLITE_MISUSE 21 /* Library used incorrectly */ +#define SQLITE_NOLFS 22 /* Uses OS features not supported on host */ +#define SQLITE_AUTH 23 /* Authorization denied */ +#define SQLITE_FORMAT 24 /* Auxiliary database format error */ +#define SQLITE_RANGE 25 /* 2nd parameter to sqlite3_bind out of range */ +#define SQLITE_NOTADB 26 /* File opened that is not a database file */ +#define SQLITE_ROW 100 /* sqlite3_step() has another row ready */ +#define SQLITE_DONE 101 /* sqlite3_step() has finished executing */ +/* end-of-error-codes */ + +/* +** CAPI3REF: Extended Result Codes {F10220} +** +** In its default configuration, SQLite API routines return one of 26 integer +** [SQLITE_OK | result codes]. However, experience has shown that +** many of these result codes are too course-grained. They do not provide as +** much information about problems as programmers might like. In an effort to +** address this, newer versions of SQLite (version 3.3.8 and later) include +** support for additional result codes that provide more detailed information +** about errors. {F10221} The extended result codes are enabled or disabled +** for each database connection using the [sqlite3_extended_result_codes()] +** API. {END} +** +** Some of the available extended result codes are listed above. +** We expect the number of extended result codes will be expand +** over time. {U10422} Software that uses extended result codes should expect +** to see new result codes in future releases of SQLite. {END} +** +** {F10223} The symbolic name for an extended result code always contains +** a related primary result code as a prefix. {F10224} Primary result +** codes contain a single "_" character. {F10225} Extended result codes +** contain two or more "_" characters. {F10226} The numeric value of an +** extended result code can be converted to its +** corresponding primary result code by masking off the lower 8 bytes. {END} +** +** The SQLITE_OK result code will never be extended. It will always +** be exactly zero. +*/ +#define SQLITE_IOERR_READ (SQLITE_IOERR | (1<<8)) +#define SQLITE_IOERR_SHORT_READ (SQLITE_IOERR | (2<<8)) +#define SQLITE_IOERR_WRITE (SQLITE_IOERR | (3<<8)) +#define SQLITE_IOERR_FSYNC (SQLITE_IOERR | (4<<8)) +#define SQLITE_IOERR_DIR_FSYNC (SQLITE_IOERR | (5<<8)) +#define SQLITE_IOERR_TRUNCATE (SQLITE_IOERR | (6<<8)) +#define SQLITE_IOERR_FSTAT (SQLITE_IOERR | (7<<8)) +#define SQLITE_IOERR_UNLOCK (SQLITE_IOERR | (8<<8)) +#define SQLITE_IOERR_RDLOCK (SQLITE_IOERR | (9<<8)) +#define SQLITE_IOERR_DELETE (SQLITE_IOERR | (10<<8)) +#define SQLITE_IOERR_BLOCKED (SQLITE_IOERR | (11<<8)) +#define SQLITE_IOERR_NOMEM (SQLITE_IOERR | (12<<8)) + +/* +** CAPI3REF: Flags For File Open Operations {F10230} +** +** {F10231} Some combination of the these bit values are used as the +** third argument to the [sqlite3_open_v2()] interface and +** as fourth argument to the xOpen method of the +** [sqlite3_vfs] object. +*/ +#define SQLITE_OPEN_READONLY 0x00000001 +#define SQLITE_OPEN_READWRITE 0x00000002 +#define SQLITE_OPEN_CREATE 0x00000004 +#define SQLITE_OPEN_DELETEONCLOSE 0x00000008 +#define SQLITE_OPEN_EXCLUSIVE 0x00000010 +#define SQLITE_OPEN_MAIN_DB 0x00000100 +#define SQLITE_OPEN_TEMP_DB 0x00000200 +#define SQLITE_OPEN_TRANSIENT_DB 0x00000400 +#define SQLITE_OPEN_MAIN_JOURNAL 0x00000800 +#define SQLITE_OPEN_TEMP_JOURNAL 0x00001000 +#define SQLITE_OPEN_SUBJOURNAL 0x00002000 +#define SQLITE_OPEN_MASTER_JOURNAL 0x00004000 + +/* +** CAPI3REF: Device Characteristics {F10240} +** +** {F10241} The xDeviceCapabilities method of the [sqlite3_io_methods] +** object returns an integer which is a vector of the these +** bit values expressing I/O characteristics of the mass storage +** device that holds the file that the [sqlite3_io_methods] +** refers to. {END} +** +** {F10242} The SQLITE_IOCAP_ATOMIC property means that all writes of +** any size are atomic. {F10243} The SQLITE_IOCAP_ATOMICnnn values +** mean that writes of blocks that are nnn bytes in size and +** are aligned to an address which is an integer multiple of +** nnn are atomic. {F10244} The SQLITE_IOCAP_SAFE_APPEND value means +** that when data is appended to a file, the data is appended +** first then the size of the file is extended, never the other +** way around. {F10245} The SQLITE_IOCAP_SEQUENTIAL property means that +** information is written to disk in the same order as calls +** to xWrite(). +*/ +#define SQLITE_IOCAP_ATOMIC 0x00000001 +#define SQLITE_IOCAP_ATOMIC512 0x00000002 +#define SQLITE_IOCAP_ATOMIC1K 0x00000004 +#define SQLITE_IOCAP_ATOMIC2K 0x00000008 +#define SQLITE_IOCAP_ATOMIC4K 0x00000010 +#define SQLITE_IOCAP_ATOMIC8K 0x00000020 +#define SQLITE_IOCAP_ATOMIC16K 0x00000040 +#define SQLITE_IOCAP_ATOMIC32K 0x00000080 +#define SQLITE_IOCAP_ATOMIC64K 0x00000100 +#define SQLITE_IOCAP_SAFE_APPEND 0x00000200 +#define SQLITE_IOCAP_SEQUENTIAL 0x00000400 + +/* +** CAPI3REF: File Locking Levels {F10250} +** +** {F10251} SQLite uses one of the following integer values as the second +** argument to calls it makes to the xLock() and xUnlock() methods +** of an [sqlite3_io_methods] object. {END} +*/ +#define SQLITE_LOCK_NONE 0 +#define SQLITE_LOCK_SHARED 1 +#define SQLITE_LOCK_RESERVED 2 +#define SQLITE_LOCK_PENDING 3 +#define SQLITE_LOCK_EXCLUSIVE 4 + +/* +** CAPI3REF: Synchronization Type Flags {F10260} +** +** {F10261} When SQLite invokes the xSync() method of an +** [sqlite3_io_methods] object it uses a combination of the +** these integer values as the second argument. +** +** {F10262} When the SQLITE_SYNC_DATAONLY flag is used, it means that the +** sync operation only needs to flush data to mass storage. Inode +** information need not be flushed. {F10263} The SQLITE_SYNC_NORMAL means +** to use normal fsync() semantics. {F10264} The SQLITE_SYNC_FULL flag means +** to use Mac OS-X style fullsync instead of fsync(). +*/ +#define SQLITE_SYNC_NORMAL 0x00002 +#define SQLITE_SYNC_FULL 0x00003 +#define SQLITE_SYNC_DATAONLY 0x00010 + + +/* +** CAPI3REF: OS Interface Open File Handle {F11110} +** +** An [sqlite3_file] object represents an open file in the OS +** interface layer. Individual OS interface implementations will +** want to subclass this object by appending additional fields +** for their own use. The pMethods entry is a pointer to an +** [sqlite3_io_methods] object that defines methods for performing +** I/O operations on the open file. +*/ +typedef struct sqlite3_file sqlite3_file; +struct sqlite3_file { + int isOpen; + //const struct sqlite3_io_methods *pMethods; /* Methods for an open file */ +}; + +/* +** CAPI3REF: OS Interface File Virtual Methods Object {F11120} +** +** Every file opened by the [sqlite3_vfs] xOpen method contains a pointer to +** an instance of the this object. This object defines the +** methods used to perform various operations against the open file. +** +** The flags argument to xSync may be one of [SQLITE_SYNC_NORMAL] or +** [SQLITE_SYNC_FULL]. The first choice is the normal fsync(). +* The second choice is an +** OS-X style fullsync. The SQLITE_SYNC_DATA flag may be ORed in to +** indicate that only the data of the file and not its inode needs to be +** synced. +** +** The integer values to xLock() and xUnlock() are one of +**
    +**
  • [SQLITE_LOCK_NONE], +**
  • [SQLITE_LOCK_SHARED], +**
  • [SQLITE_LOCK_RESERVED], +**
  • [SQLITE_LOCK_PENDING], or +**
  • [SQLITE_LOCK_EXCLUSIVE]. +**
+** xLock() increases the lock. xUnlock() decreases the lock. +** The xCheckReservedLock() method looks +** to see if any database connection, either in this +** process or in some other process, is holding an RESERVED, +** PENDING, or EXCLUSIVE lock on the file. It returns true +** if such a lock exists and false if not. +** +** The xFileControl() method is a generic interface that allows custom +** VFS implementations to directly control an open file using the +** [sqlite3_file_control()] interface. The second "op" argument +** is an integer opcode. The third +** argument is a generic pointer which is intended to be a pointer +** to a structure that may contain arguments or space in which to +** write return values. Potential uses for xFileControl() might be +** functions to enable blocking locks with timeouts, to change the +** locking strategy (for example to use dot-file locks), to inquire +** about the status of a lock, or to break stale locks. The SQLite +** core reserves opcodes less than 100 for its own use. +** A [SQLITE_FCNTL_LOCKSTATE | list of opcodes] less than 100 is available. +** Applications that define a custom xFileControl method should use opcodes +** greater than 100 to avoid conflicts. +** +** The xSectorSize() method returns the sector size of the +** device that underlies the file. The sector size is the +** minimum write that can be performed without disturbing +** other bytes in the file. The xDeviceCharacteristics() +** method returns a bit vector describing behaviors of the +** underlying device: +** +**
    +**
  • [SQLITE_IOCAP_ATOMIC] +**
  • [SQLITE_IOCAP_ATOMIC512] +**
  • [SQLITE_IOCAP_ATOMIC1K] +**
  • [SQLITE_IOCAP_ATOMIC2K] +**
  • [SQLITE_IOCAP_ATOMIC4K] +**
  • [SQLITE_IOCAP_ATOMIC8K] +**
  • [SQLITE_IOCAP_ATOMIC16K] +**
  • [SQLITE_IOCAP_ATOMIC32K] +**
  • [SQLITE_IOCAP_ATOMIC64K] +**
  • [SQLITE_IOCAP_SAFE_APPEND] +**
  • [SQLITE_IOCAP_SEQUENTIAL] +**
+** +** The SQLITE_IOCAP_ATOMIC property means that all writes of +** any size are atomic. The SQLITE_IOCAP_ATOMICnnn values +** mean that writes of blocks that are nnn bytes in size and +** are aligned to an address which is an integer multiple of +** nnn are atomic. The SQLITE_IOCAP_SAFE_APPEND value means +** that when data is appended to a file, the data is appended +** first then the size of the file is extended, never the other +** way around. The SQLITE_IOCAP_SEQUENTIAL property means that +** information is written to disk in the same order as calls +** to xWrite(). +*/ +/*typedef struct sqlite3_io_methods sqlite3_io_methods; +struct sqlite3_io_methods { + int iVersion; + int (*xClose)(sqlite3_file*); + int (*xRead)(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst); + int (*xWrite)(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst); + int (*xTruncate)(sqlite3_file*, sqlite3_int64 size); + int (*xSync)(sqlite3_file*, int flags); + int (*xFileSize)(sqlite3_file*, sqlite3_int64 *pSize); + int (*xLock)(sqlite3_file*, int); + int (*xUnlock)(sqlite3_file*, int); + int (*xCheckReservedLock)(sqlite3_file*); + int (*xFileControl)(sqlite3_file*, int op, void *pArg); + int (*xSectorSize)(sqlite3_file*); + int (*xDeviceCharacteristics)(sqlite3_file*); +};*/ + +/* +** CAPI3REF: Standard File Control Opcodes {F11310} +** +** These integer constants are opcodes for the xFileControl method +** of the [sqlite3_io_methods] object and to the [sqlite3_file_control()] +** interface. +** +** {F11311} The [SQLITE_FCNTL_LOCKSTATE] opcode is used for debugging. This +** opcode cases the xFileControl method to write the current state of +** the lock (one of [SQLITE_LOCK_NONE], [SQLITE_LOCK_SHARED], +** [SQLITE_LOCK_RESERVED], [SQLITE_LOCK_PENDING], or [SQLITE_LOCK_EXCLUSIVE]) +** into an integer that the pArg argument points to. {F11312} This capability +** is used during testing and only needs to be supported when SQLITE_TEST +** is defined. +*/ +#define SQLITE_FCNTL_LOCKSTATE 1 + +/* +** CAPI3REF: Mutex Handle {F17110} +** +** The mutex module within SQLite defines [sqlite3_mutex] to be an +** abstract type for a mutex object. {F17111} The SQLite core never looks +** at the internal representation of an [sqlite3_mutex]. {END} It only +** deals with pointers to the [sqlite3_mutex] object. +** +** Mutexes are created using [sqlite3_mutex_alloc()]. +*/ +typedef struct sqlite3_mutex sqlite3_mutex; + +/* +** CAPI3REF: OS Interface Object {F11140} +** +** An instance of this object defines the interface between the +** SQLite core and the underlying operating system. The "vfs" +** in the name of the object stands for "virtual file system". +** +** The iVersion field is initially 1 but may be larger for future +** versions of SQLite. Additional fields may be appended to this +** object when the iVersion value is increased. +** +** The szOsFile field is the size of the subclassed [sqlite3_file] +** structure used by this VFS. mxPathname is the maximum length of +** a pathname in this VFS. +** +** Registered vfs modules are kept on a linked list formed by +** the pNext pointer. The [sqlite3_vfs_register()] +** and [sqlite3_vfs_unregister()] interfaces manage this list +** in a thread-safe way. The [sqlite3_vfs_find()] interface +** searches the list. +** +** The pNext field is the only fields in the sqlite3_vfs +** structure that SQLite will ever modify. SQLite will only access +** or modify this field while holding a particular static mutex. +** The application should never modify anything within the sqlite3_vfs +** object once the object has been registered. +** +** The zName field holds the name of the VFS module. The name must +** be unique across all VFS modules. +** +** {F11141} SQLite will guarantee that the zFilename string passed to +** xOpen() is a full pathname as generated by xFullPathname() and +** that the string will be valid and unchanged until xClose() is +** called. {END} So the [sqlite3_file] can store a pointer to the +** filename if it needs to remember the filename for some reason. +** +** {F11142} The flags argument to xOpen() includes all bits set in +** the flags argument to [sqlite3_open_v2()]. Or if [sqlite3_open()] +** or [sqlite3_open16()] is used, then flags includes at least +** [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]. {END} +** If xOpen() opens a file read-only then it sets *pOutFlags to +** include [SQLITE_OPEN_READONLY]. Other bits in *pOutFlags may be +** set. +** +** {F11143} SQLite will also add one of the following flags to the xOpen() +** call, depending on the object being opened: +** +**
    +**
  • [SQLITE_OPEN_MAIN_DB] +**
  • [SQLITE_OPEN_MAIN_JOURNAL] +**
  • [SQLITE_OPEN_TEMP_DB] +**
  • [SQLITE_OPEN_TEMP_JOURNAL] +**
  • [SQLITE_OPEN_TRANSIENT_DB] +**
  • [SQLITE_OPEN_SUBJOURNAL] +**
  • [SQLITE_OPEN_MASTER_JOURNAL] +**
{END} +** +** The file I/O implementation can use the object type flags to +** changes the way it deals with files. For example, an application +** that does not care about crash recovery or rollback, might make +** the open of a journal file a no-op. Writes to this journal are +** also a no-op. Any attempt to read the journal return SQLITE_IOERR. +** Or the implementation might recognize the a database file will +** be doing page-aligned sector reads and writes in a random order +** and set up its I/O subsystem accordingly. +** +** {F11144} SQLite might also add one of the following flags to the xOpen +** method: +** +**
    +**
  • [SQLITE_OPEN_DELETEONCLOSE] +**
  • [SQLITE_OPEN_EXCLUSIVE] +**
+** +** {F11145} The [SQLITE_OPEN_DELETEONCLOSE] flag means the file should be +** deleted when it is closed. {F11146} The [SQLITE_OPEN_DELETEONCLOSE] +** will be set for TEMP databases, journals and for subjournals. +** {F11147} The [SQLITE_OPEN_EXCLUSIVE] flag means the file should be opened +** for exclusive access. This flag is set for all files except +** for the main database file. {END} +** +** {F11148} At least szOsFile bytes of memory is allocated by SQLite +** to hold the [sqlite3_file] structure passed as the third +** argument to xOpen. {END} The xOpen method does not have to +** allocate the structure; it should just fill it in. +** +** {F11149} The flags argument to xAccess() may be [SQLITE_ACCESS_EXISTS] +** to test for the existance of a file, +** or [SQLITE_ACCESS_READWRITE] to test to see +** if a file is readable and writable, or [SQLITE_ACCESS_READ] +** to test to see if a file is at least readable. {END} The file can be a +** directory. +** +** {F11150} SQLite will always allocate at least mxPathname+1 byte for +** the output buffers for xGetTempname and xFullPathname. {F11151} The exact +** size of the output buffer is also passed as a parameter to both +** methods. {END} If the output buffer is not large enough, SQLITE_CANTOPEN +** should be returned. As this is handled as a fatal error by SQLite, +** vfs implementations should endeavor to prevent this by setting +** mxPathname to a sufficiently large value. +** +** The xRandomness(), xSleep(), and xCurrentTime() interfaces +** are not strictly a part of the filesystem, but they are +** included in the VFS structure for completeness. +** The xRandomness() function attempts to return nBytes bytes +** of good-quality randomness into zOut. The return value is +** the actual number of bytes of randomness obtained. The +** xSleep() method cause the calling thread to sleep for at +** least the number of microseconds given. The xCurrentTime() +** method returns a Julian Day Number for the current date and +** time. +*/ +typedef struct sqlite3_vfs sqlite3_vfs; +struct sqlite3_vfs { + int iVersion; /* Structure version number */ + int szOsFile; /* Size of subclassed sqlite3_file */ + int mxPathname; /* Maximum file pathname length */ + sqlite3_vfs *pNext; /* Next registered VFS */ + const char *zName; /* Name of this virtual file system */ + void *pAppData; /* Pointer to application-specific data */ +/* int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*, + int flags, int *pOutFlags); + int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir); + int (*xAccess)(sqlite3_vfs*, const char *zName, int flags); + int (*xGetTempname)(sqlite3_vfs*, int nOut, char *zOut); + int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut); + void *(*xDlOpen)(sqlite3_vfs*, const char *zFilename); + void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg); + void *(*xDlSym)(sqlite3_vfs*,void*, const char *zSymbol); + void (*xDlClose)(sqlite3_vfs*, void*); + int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut); + int (*xSleep)(sqlite3_vfs*, int microseconds); + int (*xCurrentTime)(sqlite3_vfs*, double*);*/ + /* New fields may be appended in figure versions. The iVersion + ** value will increment whenever this happens. */ +}; + +/* +** CAPI3REF: Flags for the xAccess VFS method {F11190} +** +** {F11191} These integer constants can be used as the third parameter to +** the xAccess method of an [sqlite3_vfs] object. {END} They determine +** the kind of what kind of permissions the xAccess method is +** looking for. {F11192} With SQLITE_ACCESS_EXISTS, the xAccess method +** simply checks to see if the file exists. {F11193} With +** SQLITE_ACCESS_READWRITE, the xAccess method checks to see +** if the file is both readable and writable. {F11194} With +** SQLITE_ACCESS_READ the xAccess method +** checks to see if the file is readable. +*/ +#define SQLITE_ACCESS_EXISTS 0 +#define SQLITE_ACCESS_READWRITE 1 +#define SQLITE_ACCESS_READ 2 + +/* +** CAPI3REF: Enable Or Disable Extended Result Codes {F12200} +** +** {F12201} The sqlite3_extended_result_codes() routine enables or disables the +** [SQLITE_IOERR_READ | extended result codes] feature on a database +** connection if its 2nd parameter is +** non-zero or zero, respectively. {F12202} +** By default, SQLite API routines return one of only 26 integer +** [SQLITE_OK | result codes]. {F12203} When extended result codes +** are enabled by this routine, the repetoire of result codes can be +** much larger and can (hopefully) provide more detailed information +** about the cause of an error. +** +** {F12204} The second argument is a boolean value that turns extended result +** codes on and off. {F12205} Extended result codes are off by default for +** backwards compatibility with older versions of SQLite. +*/ +/*IMPORT_C*/ int sqlite3_extended_result_codes(sqlite3*, int onoff); + +/* +** CAPI3REF: Last Insert Rowid {F12220} +** +** {F12221} Each entry in an SQLite table has a unique 64-bit signed +** integer key called the "rowid". {F12222} The rowid is always available +** as an undeclared column named ROWID, OID, or _ROWID_ as long as those +** names are not also used by explicitly declared columns. {F12223} If +** the table has a column of type INTEGER PRIMARY KEY then that column +** is another an alias for the rowid. +** +** {F12224} This routine returns the rowid of the most recent +** successful INSERT into the database from the database connection +** shown in the first argument. {F12225} If no successful inserts +** have ever occurred on this database connection, zero is returned. +** +** {F12226} If an INSERT occurs within a trigger, then the rowid of the +** inserted row is returned by this routine as long as the trigger +** is running. {F12227} But once the trigger terminates, the value returned +** by this routine reverts to the last value inserted before the +** trigger fired. +** +** {F12228} An INSERT that fails due to a constraint violation is not a +** successful insert and does not change the value returned by this +** routine. {F12229} Thus INSERT OR FAIL, INSERT OR IGNORE, INSERT OR ROLLBACK, +** and INSERT OR ABORT make no changes to the return value of this +** routine when their insertion fails. {F12231} When INSERT OR REPLACE +** encounters a constraint violation, it does not fail. The +** INSERT continues to completion after deleting rows that caused +** the constraint problem so INSERT OR REPLACE will always change +** the return value of this interface. +** +** {UF12232} If another thread does a new insert on the same database connection +** while this routine is running and thus changes the last insert rowid, +** then the return value of this routine is undefined. +*/ +/*IMPORT_C*/ sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*); + +/* +** CAPI3REF: Count The Number Of Rows Modified {F12240} +** +** {F12241} This function returns the number of database rows that were changed +** or inserted or deleted by the most recently completed SQL statement +** on the connection specified by the first parameter. {F12242} Only +** changes that are directly specified by the INSERT, UPDATE, or +** DELETE statement are counted. Auxiliary changes caused by +** triggers are not counted. {F12243} Use the [sqlite3_total_changes()] function +** to find the total number of changes including changes caused by triggers. +** +** {F12244} Within the body of a trigger, the sqlite3_changes() interface +** can be called to find the number of +** changes in the most recently completed INSERT, UPDATE, or DELETE +** statement within the body of the same trigger. +** +** {F12245} All changes are counted, even if they are later undone by a +** ROLLBACK or ABORT. {F12246} Except, changes associated with creating and +** dropping tables are not counted. +** +** {F12247} If a callback invokes [sqlite3_exec()] or [sqlite3_step()] +** recursively, then the changes in the inner, recursive call are +** counted together with the changes in the outer call. +** +** {F12248} SQLite implements the command "DELETE FROM table" without +** a WHERE clause by dropping and recreating the table. (This is much +** faster than going through and deleting individual elements from the +** table.) Because of this optimization, the change count for +** "DELETE FROM table" will be zero regardless of the number of elements +** that were originally in the table. {F12251} To get an accurate count +** of the number of rows deleted, use +** "DELETE FROM table WHERE 1" instead. +** +** {UF12252} If another thread makes changes on the same database connection +** while this routine is running then the return value of this routine +** is undefined. +*/ +/*IMPORT_C*/ int sqlite3_changes(sqlite3*); + +/* +** CAPI3REF: Total Number Of Rows Modified {F12260} +*** +** {F12261} This function returns the number of database rows that have been +** modified by INSERT, UPDATE or DELETE statements since the database handle +** was opened. {F12262} The count includes UPDATE, INSERT and DELETE +** statements executed as part of trigger programs. {F12263} All changes +** are counted as soon as the statement that makes them is completed +** (when the statement handle is passed to [sqlite3_reset()] or +** [sqlite3_finalize()]). {END} +** +** See also the [sqlite3_change()] interface. +** +** {F12265} SQLite implements the command "DELETE FROM table" without +** a WHERE clause by dropping and recreating the table. (This is much +** faster than going +** through and deleting individual elements form the table.) Because of +** this optimization, the change count for "DELETE FROM table" will be +** zero regardless of the number of elements that were originally in the +** table. To get an accurate count of the number of rows deleted, use +** "DELETE FROM table WHERE 1" instead. +** +** {U12264} If another thread makes changes on the same database connection +** while this routine is running then the return value of this routine +** is undefined. {END} +*/ +/*IMPORT_C*/ int sqlite3_total_changes(sqlite3*); + +/* +** CAPI3REF: Interrupt A Long-Running Query {F12270} +** +** {F12271} This function causes any pending database operation to abort and +** return at its earliest opportunity. {END} This routine is typically +** called in response to a user action such as pressing "Cancel" +** or Ctrl-C where the user wants a long query operation to halt +** immediately. +** +** {F12272} It is safe to call this routine from a thread different from the +** thread that is currently running the database operation. {U12273} But it +** is not safe to call this routine with a database connection that +** is closed or might close before sqlite3_interrupt() returns. +** +** If an SQL is very nearly finished at the time when sqlite3_interrupt() +** is called, then it might not have an opportunity to be interrupted. +** It might continue to completion. +** {F12274} The SQL operation that is interrupted will return +** [SQLITE_INTERRUPT]. {F12275} If the interrupted SQL operation is an +** INSERT, UPDATE, or DELETE that is inside an explicit transaction, +** then the entire transaction will be rolled back automatically. +** {F12276} A call to sqlite3_interrupt() has no effect on SQL statements +** that are started after sqlite3_interrupt() returns. +*/ +/*IMPORT_C*/ void sqlite3_interrupt(sqlite3*); + +/* +** CAPI3REF: Determine If An SQL Statement Is Complete {F10510} +** +** These routines are useful for command-line input to determine if the +** currently entered text seems to form complete a SQL statement or +** if additional input is needed before sending the text into +** SQLite for parsing. These routines return true if the input string +** appears to be a complete SQL statement. A statement is judged to be +** complete if it ends with a semicolon and is not a fragment of a +** CREATE TRIGGER statement. These routines do not parse the SQL and +** so will not detect syntactically incorrect SQL. +** +** {F10511} These functions return true if the given input string +** ends with a semicolon optionally followed by whitespace or +** comments. {F10512} For sqlite3_complete(), +** the parameter must be a zero-terminated UTF-8 string. {F10513} For +** sqlite3_complete16(), a zero-terminated machine byte order UTF-16 string +** is required. {F10514} These routines return false if the terminal +** semicolon is within a comment, a string literal or a quoted identifier +** (in other words if the final semicolon is not really a separate token +** but part of a larger token) or if the final semicolon is +** in between the BEGIN and END keywords of a CREATE TRIGGER statement. +** {END} +*/ +/*IMPORT_C*/ int sqlite3_complete(const char *sql); +/*IMPORT_C*/ int sqlite3_complete16(const void *sql); + +/* +** CAPI3REF: Register A Callback To Handle SQLITE_BUSY Errors {F12310} +** +** {F12311} This routine identifies a callback function that might be +** invoked whenever an attempt is made to open a database table +** that another thread or process has locked. +** {F12312} If the busy callback is NULL, then [SQLITE_BUSY] +** or [SQLITE_IOERR_BLOCKED] +** is returned immediately upon encountering the lock. +** {F12313} If the busy callback is not NULL, then the +** callback will be invoked with two arguments. {F12314} The +** first argument to the handler is a copy of the void* pointer which +** is the third argument to this routine. {F12315} The second argument to +** the handler is the number of times that the busy handler has +** been invoked for this locking event. {F12316} If the +** busy callback returns 0, then no additional attempts are made to +** access the database and [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED] is returned. +** {F12317} If the callback returns non-zero, then another attempt +** is made to open the database for reading and the cycle repeats. +** +** The presence of a busy handler does not guarantee that +** it will be invoked when there is lock contention. {F12319} +** If SQLite determines that invoking the busy handler could result in +** a deadlock, it will go ahead and return [SQLITE_BUSY] or +** [SQLITE_IOERR_BLOCKED] instead of invoking the +** busy handler. {END} +** Consider a scenario where one process is holding a read lock that +** it is trying to promote to a reserved lock and +** a second process is holding a reserved lock that it is trying +** to promote to an exclusive lock. The first process cannot proceed +** because it is blocked by the second and the second process cannot +** proceed because it is blocked by the first. If both processes +** invoke the busy handlers, neither will make any progress. Therefore, +** SQLite returns [SQLITE_BUSY] for the first process, hoping that this +** will induce the first process to release its read lock and allow +** the second process to proceed. +** +** {F12321} The default busy callback is NULL. {END} +** +** {F12322} The [SQLITE_BUSY] error is converted to [SQLITE_IOERR_BLOCKED] +** when SQLite is in the middle of a large transaction where all the +** changes will not fit into the in-memory cache. {F12323} SQLite will +** already hold a RESERVED lock on the database file, but it needs +** to promote this lock to EXCLUSIVE so that it can spill cache +** pages into the database file without harm to concurrent +** readers. {F12324} If it is unable to promote the lock, then the in-memory +** cache will be left in an inconsistent state and so the error +** code is promoted from the relatively benign [SQLITE_BUSY] to +** the more severe [SQLITE_IOERR_BLOCKED]. {F12325} This error code promotion +** forces an automatic rollback of the changes. {END} See the +** +** CorruptionFollowingBusyError wiki page for a discussion of why +** this is important. +** +** {F12326} Sqlite is re-entrant, so the busy handler may start a new +** query. {END} (It is not clear why anyone would every want to do this, +** but it is allowed, in theory.) {U12327} But the busy handler may not +** close the database. Closing the database from a busy handler will delete +** data structures out from under the executing query and will +** probably result in a segmentation fault or other runtime error. {END} +** +** {F12328} There can only be a single busy handler defined for each database +** connection. Setting a new busy handler clears any previous one. +** {F12329} Note that calling [sqlite3_busy_timeout()] will also set or clear +** the busy handler. +** +** {F12331} When operating in [sqlite3_enable_shared_cache | shared cache mode], +** only a single busy handler can be defined for each database file. +** So if two database connections share a single cache, then changing +** the busy handler on one connection will also change the busy +** handler in the other connection. {F12332} The busy handler is invoked +** in the thread that was running when the lock contention occurs. +*/ +/*IMPORT_C*/ int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*); + +/* +** CAPI3REF: Set A Busy Timeout {F12340} +** +** {F12341} This routine sets a [sqlite3_busy_handler | busy handler] +** that sleeps for a while when a +** table is locked. {F12342} The handler will sleep multiple times until +** at least "ms" milliseconds of sleeping have been done. {F12343} After +** "ms" milliseconds of sleeping, the handler returns 0 which +** causes [sqlite3_step()] to return [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED]. +** +** {F12344} Calling this routine with an argument less than or equal to zero +** turns off all busy handlers. +** +** {F12345} There can only be a single busy handler for a particular database +** connection. If another busy handler was defined +** (using [sqlite3_busy_handler()]) prior to calling +** this routine, that other busy handler is cleared. +*/ +/*IMPORT_C*/ int sqlite3_busy_timeout(sqlite3*, int ms); + +/* +** CAPI3REF: Convenience Routines For Running Queries {F12370} +** +** This next routine is a convenience wrapper around [sqlite3_exec()]. +** {F12371} Instead of invoking a user-supplied callback for each row of the +** result, this routine remembers each row of the result in memory +** obtained from [sqlite3_malloc()], then returns all of the result after the +** query has finished. {F12372} +** +** As an example, suppose the query result where this table: +** +** 
+**        Name        | Age
+**        -----------------------
+**        Alice       | 43
+**        Bob         | 28
+**        Cindy       | 21
+**
+** +** If the 3rd argument were &azResult then after the function returns +** azResult will contain the following data: +** +** 
+**        azResult[0] = "Name";
+**        azResult[1] = "Age";
+**        azResult[2] = "Alice";
+**        azResult[3] = "43";
+**        azResult[4] = "Bob";
+**        azResult[5] = "28";
+**        azResult[6] = "Cindy";
+**        azResult[7] = "21";
+**
+** +** Notice that there is an extra row of data containing the column +** headers. But the *nrow return value is still 3. *ncolumn is +** set to 2. In general, the number of values inserted into azResult +** will be ((*nrow) + 1)*(*ncolumn). +** +** {U12374} After the calling function has finished using the result, it should +** pass the result data pointer to sqlite3_free_table() in order to +** release the memory that was malloc-ed. Because of the way the +** [sqlite3_malloc()] happens, the calling function must not try to call +** [sqlite3_free()] directly. Only [sqlite3_free_table()] is able to release +** the memory properly and safely. {END} +** +** {F12373} The return value of this routine is the same as +** from [sqlite3_exec()]. +*/ +/*IMPORT_C*/ int sqlite3_get_table( + sqlite3*, /* An open database */ + const char *sql, /* SQL to be executed */ + char ***resultp, /* Result written to a char *[] that this points to */ + int *nrow, /* Number of result rows written here */ + int *ncolumn, /* Number of result columns written here */ + char **errmsg /* Error msg written here */ +); +/*IMPORT_C*/ void sqlite3_free_table(char **result); + +/* +** CAPI3REF: Formatted String Printing Functions {F17400} +** +** These routines are workalikes of the "printf()" family of functions +** from the standard C library. +** +** {F17401} The sqlite3_mprintf() and sqlite3_vmprintf() routines write their +** results into memory obtained from [sqlite3_malloc()]. +** {U17402} The strings returned by these two routines should be +** released by [sqlite3_free()]. {F17403} Both routines return a +** NULL pointer if [sqlite3_malloc()] is unable to allocate enough +** memory to hold the resulting string. +** +** {F17404} In sqlite3_snprintf() routine is similar to "snprintf()" from +** the standard C library. The result is written into the +** buffer supplied as the second parameter whose size is given by +** the first parameter. {END} Note that the order of the +** first two parameters is reversed from snprintf(). This is an +** historical accident that cannot be fixed without breaking +** backwards compatibility. {F17405} Note also that sqlite3_snprintf() +** returns a pointer to its buffer instead of the number of +** characters actually written into the buffer. {END} We admit that +** the number of characters written would be a more useful return +** value but we cannot change the implementation of sqlite3_snprintf() +** now without breaking compatibility. +** +** {F17406} As long as the buffer size is greater than zero, sqlite3_snprintf() +** guarantees that the buffer is always zero-terminated. {F17407} The first +** parameter "n" is the total size of the buffer, including space for +** the zero terminator. {END} So the longest string that can be completely +** written will be n-1 characters. +** +** These routines all implement some additional formatting +** options that are useful for constructing SQL statements. +** All of the usual printf formatting options apply. In addition, there +** is are "%q", "%Q", and "%z" options. +** +** {F17410} The %q option works like %s in that it substitutes a null-terminated +** string from the argument list. But %q also doubles every '\'' character. +** %q is designed for use inside a string literal. {END} By doubling each '\'' +** character it escapes that character and allows it to be inserted into +** the string. +** +** For example, so some string variable contains text as follows: +** +** 
+**  char *zText = "It's a happy day!";
+**
+** +** One can use this text in an SQL statement as follows: +** +** 
+**  char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES('%q')", zText);
+**  sqlite3_exec(db, zSQL, 0, 0, 0);
+**  sqlite3_free(zSQL);
+**
+** +** Because the %q format string is used, the '\'' character in zText +** is escaped and the SQL generated is as follows: +** +** 
+**  INSERT INTO table1 VALUES('It''s a happy day!')
+**
+** +** This is correct. Had we used %s instead of %q, the generated SQL +** would have looked like this: +** +** 
+**  INSERT INTO table1 VALUES('It's a happy day!');
+**
+** +** This second example is an SQL syntax error. As a general rule you +** should always use %q instead of %s when inserting text into a string +** literal. +** +** {F17411} The %Q option works like %q except it also adds single quotes around +** the outside of the total string. Or if the parameter in the argument +** list is a NULL pointer, %Q substitutes the text "NULL" (without single +** quotes) in place of the %Q option. {END} So, for example, one could say: +** +** 
+**  char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES(%Q)", zText);
+**  sqlite3_exec(db, zSQL, 0, 0, 0);
+**  sqlite3_free(zSQL);
+**
+** +** The code above will render a correct SQL statement in the zSQL +** variable even if the zText variable is a NULL pointer. +** +** {F17412} The "%z" formatting option works exactly like "%s" with the +** addition that after the string has been read and copied into +** the result, [sqlite3_free()] is called on the input string. {END} +*/ +/*IMPORT_C*/ char *sqlite3_mprintf(const char*,...); +/*IMPORT_C*/ char *sqlite3_vmprintf(const char*, va_list); +/*IMPORT_C*/ char *sqlite3_snprintf(int,char*,const char*, ...); + +/* +** CAPI3REF: Memory Allocation Subsystem {F17300} +** +** {F17301} The SQLite core uses these three routines for all of its own +** internal memory allocation needs. {END} "Core" in the previous sentence +** does not include operating-system specific VFS implementation. The +** windows VFS uses native malloc and free for some operations. +** +** {F17302} The sqlite3_malloc() routine returns a pointer to a block +** of memory at least N bytes in length, where N is the parameter. +** {F17303} If sqlite3_malloc() is unable to obtain sufficient free +** memory, it returns a NULL pointer. {F17304} If the parameter N to +** sqlite3_malloc() is zero or negative then sqlite3_malloc() returns +** a NULL pointer. +** +** {F17305} Calling sqlite3_free() with a pointer previously returned +** by sqlite3_malloc() or sqlite3_realloc() releases that memory so +** that it might be reused. {F17306} The sqlite3_free() routine is +** a no-op if is called with a NULL pointer. Passing a NULL pointer +** to sqlite3_free() is harmless. {U17307} After being freed, memory +** should neither be read nor written. Even reading previously freed +** memory might result in a segmentation fault or other severe error. +** {U17309} Memory corruption, a segmentation fault, or other severe error +** might result if sqlite3_free() is called with a non-NULL pointer that +** was not obtained from sqlite3_malloc() or sqlite3_free(). +** +** {F17310} The sqlite3_realloc() interface attempts to resize a +** prior memory allocation to be at least N bytes, where N is the +** second parameter. The memory allocation to be resized is the first +** parameter. {F17311} If the first parameter to sqlite3_realloc() +** is a NULL pointer then its behavior is identical to calling +** sqlite3_malloc(N) where N is the second parameter to sqlite3_realloc(). +** {F17312} If the second parameter to sqlite3_realloc() is zero or +** negative then the behavior is exactly the same as calling +** sqlite3_free(P) where P is the first parameter to sqlite3_realloc(). +** {F17313} Sqlite3_realloc() returns a pointer to a memory allocation +** of at least N bytes in size or NULL if sufficient memory is unavailable. +** {F17314} If M is the size of the prior allocation, then min(N,M) bytes +** of the prior allocation are copied into the beginning of buffer returned +** by sqlite3_realloc() and the prior allocation is freed. +** {F17315} If sqlite3_realloc() returns NULL, then the prior allocation +** is not freed. +** +** {F17316} The memory returned by sqlite3_malloc() and sqlite3_realloc() +** is always aligned to at least an 8 byte boundary. {END} +** +** {F17381} The default implementation +** of the memory allocation subsystem uses the malloc(), realloc() +** and free() provided by the standard C library. {F17382} However, if +** SQLite is compiled with the following C preprocessor macro +** +**
SQLITE_MEMORY_SIZE=NNN
+** +** where NNN is an integer, then SQLite create a static +** array of at least NNN bytes in size and use that array +** for all of its dynamic memory allocation needs. {END} Additional +** memory allocator options may be added in future releases. +** +** In SQLite version 3.5.0 and 3.5.1, it was possible to define +** the SQLITE_OMIT_MEMORY_ALLOCATION which would cause the built-in +** implementation of these routines to be omitted. That capability +** is no longer provided. Only built-in memory allocators can be +** used. +** +** The windows OS interface layer calls +** the system malloc() and free() directly when converting +** filenames between the UTF-8 encoding used by SQLite +** and whatever filename encoding is used by the particular windows +** installation. Memory allocation errors are detected, but +** they are reported back as [SQLITE_CANTOPEN] or +** [SQLITE_IOERR] rather than [SQLITE_NOMEM]. +*/ +/*IMPORT_C*/ void *sqlite3_malloc(int); +/*IMPORT_C*/ void *sqlite3_realloc(void*, int); +/*IMPORT_C*/ void sqlite3_free(void*); + +/* +** CAPI3REF: Memory Allocator Statistics {F17370} +** +** In addition to the basic three allocation routines +** [sqlite3_malloc()], [sqlite3_free()], and [sqlite3_realloc()], +** the memory allocation subsystem included with the SQLite +** sources provides the interfaces shown here. +** +** {F17371} The sqlite3_memory_used() routine returns the +** number of bytes of memory currently outstanding (malloced but not freed). +** {F17372} The value returned by sqlite3_memory_used() includes +** any overhead added by SQLite, but not overhead added by the +** library malloc() that backs the sqlite3_malloc() implementation. +** {F17373} The sqlite3_memory_highwater() routines returns the +** maximum number of bytes that have been outstanding at any time +** since the highwater mark was last reset. +** {F17374} The byte count returned by sqlite3_memory_highwater() +** uses the same byte counting rules as sqlite3_memory_used(). {END} +** In other words, overhead added internally by SQLite is counted, +** but overhead from the underlying system malloc is not. +** {F17375} If the parameter to sqlite3_memory_highwater() is true, +** then the highwater mark is reset to the current value of +** sqlite3_memory_used() and the prior highwater mark (before the +** reset) is returned. {F17376} If the parameter to +** sqlite3_memory_highwater() is zero, then the highwater mark is +** unchanged. +*/ +/*IMPORT_C*/ sqlite3_int64 sqlite3_memory_used(void); +/*IMPORT_C*/ sqlite3_int64 sqlite3_memory_highwater(int resetFlag); + +/* +** CAPI3REF: Compile-Time Authorization Callbacks {F12500} +** +** {F12501} This routine registers a authorizer callback with a particular +** database connection, supplied in the first argument. {F12502} +** The authorizer callback is invoked as SQL statements are being compiled +** by [sqlite3_prepare()] or its variants [sqlite3_prepare_v2()], +** [sqlite3_prepare16()] and [sqlite3_prepare16_v2()]. {F12503} At various +** points during the compilation process, as logic is being created +** to perform various actions, the authorizer callback is invoked to +** see if those actions are allowed. The authorizer callback should +** return SQLITE_OK to allow the action, [SQLITE_IGNORE] to disallow the +** specific action but allow the SQL statement to continue to be +** compiled, or [SQLITE_DENY] to cause the entire SQL statement to be +** rejected with an error. {F12504} If the authorizer callback returns +** any value other than [SQLITE_IGNORE], [SQLITE_OK], or [SQLITE_DENY] +** then [sqlite3_prepare_v2()] or equivalent call that triggered +** the authorizer shall +** fail with an SQLITE_ERROR error code and an appropriate error message. {END} +** +** When the callback returns [SQLITE_OK], that means the operation +** requested is ok. {F12505} When the callback returns [SQLITE_DENY], the +** [sqlite3_prepare_v2()] or equivalent call that triggered the +** authorizer shall fail +** with an SQLITE_ERROR error code and an error message explaining that +** access is denied. {F12506} If the authorizer code (the 2nd parameter +** to the authorizer callback is anything other than [SQLITE_READ], then +** a return of [SQLITE_IGNORE] has the same effect as [SQLITE_DENY]. +** If the authorizer code is [SQLITE_READ] and the callback returns +** [SQLITE_IGNORE] then the prepared statement is constructed to +** insert a NULL value in place of the table column that would have +** been read if [SQLITE_OK] had been returned. {END} +** +** {F12510} The first parameter to the authorizer callback is a copy of +** the third parameter to the sqlite3_set_authorizer() interface. +** {F12511} The second parameter to the callback is an integer +** [SQLITE_COPY | action code] that specifies the particular action +** to be authorized. {END} The available action codes are +** [SQLITE_COPY | documented separately]. {F12512} The third through sixth +** parameters to the callback are zero-terminated strings that contain +** additional details about the action to be authorized. {END} +** +** An authorizer is used when preparing SQL statements from an untrusted +** source, to ensure that the SQL statements do not try to access data +** that they are not allowed to see, or that they do not try to +** execute malicious statements that damage the database. For +** example, an application may allow a user to enter arbitrary +** SQL queries for evaluation by a database. But the application does +** not want the user to be able to make arbitrary changes to the +** database. An authorizer could then be put in place while the +** user-entered SQL is being prepared that disallows everything +** except SELECT statements. +** +** {F12520} Only a single authorizer can be in place on a database connection +** at a time. Each call to sqlite3_set_authorizer overrides the +** previous call. {F12521} A NULL authorizer means that no authorization +** callback is invoked. {F12522} The default authorizer is NULL. {END} +** +** Note that the authorizer callback is invoked only during +** [sqlite3_prepare()] or its variants. {F12523} Authorization is not +** performed during statement evaluation in [sqlite3_step()]. {END} +*/ +/*IMPORT_C*/ int sqlite3_set_authorizer( + sqlite3*, + int (*xAuth)(void*,int,const char*,const char*,const char*,const char*), + void *pUserData +); + +/* +** CAPI3REF: Authorizer Return Codes {F12590} +** +** The [sqlite3_set_authorizer | authorizer callback function] must +** return either [SQLITE_OK] or one of these two constants in order +** to signal SQLite whether or not the action is permitted. See the +** [sqlite3_set_authorizer | authorizer documentation] for additional +** information. +*/ +#define SQLITE_DENY 1 /* Abort the SQL statement with an error */ +#define SQLITE_IGNORE 2 /* Don't allow access, but don't generate an error */ + +/* +** CAPI3REF: Authorizer Action Codes {F12550} +** +** The [sqlite3_set_authorizer()] interface registers a callback function +** that is invoked to authorizer certain SQL statement actions. {F12551} The +** second parameter to the callback is an integer code that specifies +** what action is being authorized. These are the integer action codes that +** the authorizer callback may be passed. {END} +** +** These action code values signify what kind of operation is to be +** authorized. {F12552} The 3rd and 4th parameters to the authorization +** callback function will be parameters or NULL depending on which of these +** codes is used as the second parameter. {F12553} The 5th parameter to the +** authorizer callback is the name of the database ("main", "temp", +** etc.) if applicable. {F12554} The 6th parameter to the authorizer callback +** is the name of the inner-most trigger or view that is responsible for +** the access attempt or NULL if this access attempt is directly from +** top-level SQL code. +*/ +/******************************************* 3rd ************ 4th ***********/ +#define SQLITE_CREATE_INDEX 1 /* Index Name Table Name */ +#define SQLITE_CREATE_TABLE 2 /* Table Name NULL */ +#define SQLITE_CREATE_TEMP_INDEX 3 /* Index Name Table Name */ +#define SQLITE_CREATE_TEMP_TABLE 4 /* Table Name NULL */ +#define SQLITE_CREATE_TEMP_TRIGGER 5 /* Trigger Name Table Name */ +#define SQLITE_CREATE_TEMP_VIEW 6 /* View Name NULL */ +#define SQLITE_CREATE_TRIGGER 7 /* Trigger Name Table Name */ +#define SQLITE_CREATE_VIEW 8 /* View Name NULL */ +#define SQLITE_DELETE 9 /* Table Name NULL */ +#define SQLITE_DROP_INDEX 10 /* Index Name Table Name */ +#define SQLITE_DROP_TABLE 11 /* Table Name NULL */ +#define SQLITE_DROP_TEMP_INDEX 12 /* Index Name Table Name */ +#define SQLITE_DROP_TEMP_TABLE 13 /* Table Name NULL */ +#define SQLITE_DROP_TEMP_TRIGGER 14 /* Trigger Name Table Name */ +#define SQLITE_DROP_TEMP_VIEW 15 /* View Name NULL */ +#define SQLITE_DROP_TRIGGER 16 /* Trigger Name Table Name */ +#define SQLITE_DROP_VIEW 17 /* View Name NULL */ +#define SQLITE_INSERT 18 /* Table Name NULL */ +#define SQLITE_PRAGMA 19 /* Pragma Name 1st arg or NULL */ +#define SQLITE_READ 20 /* Table Name Column Name */ +#define SQLITE_SELECT 21 /* NULL NULL */ +#define SQLITE_TRANSACTION 22 /* NULL NULL */ +#define SQLITE_UPDATE 23 /* Table Name Column Name */ +#define SQLITE_ATTACH 24 /* Filename NULL */ +#define SQLITE_DETACH 25 /* Database Name NULL */ +#define SQLITE_ALTER_TABLE 26 /* Database Name Table Name */ +#define SQLITE_REINDEX 27 /* Index Name NULL */ +#define SQLITE_ANALYZE 28 /* Table Name NULL */ +#define SQLITE_CREATE_VTABLE 29 /* Table Name Module Name */ +#define SQLITE_DROP_VTABLE 30 /* Table Name Module Name */ +#define SQLITE_FUNCTION 31 /* Function Name NULL */ +#define SQLITE_COPY 0 /* No longer used */ + +/* +** CAPI3REF: Tracing And Profiling Functions {F12280} +** +** These routines register callback functions that can be used for +** tracing and profiling the execution of SQL statements. +** +** {F12281} The callback function registered by sqlite3_trace() is invoked +** at the first [sqlite3_step()] for the evaluation of an SQL statement. +** {F12282} Only a single trace callback can be registered at a time. +** Each call to sqlite3_trace() overrides the previous. {F12283} A +** NULL callback for sqlite3_trace() disables tracing. {F12284} The +** first argument to the trace callback is a copy of the pointer which +** was the 3rd argument to sqlite3_trace. {F12285} The second argument +** to the trace callback is a zero-terminated UTF8 string containing +** the original text of the SQL statement as it was passed into +** [sqlite3_prepare_v2()] or the equivalent. {END} Note that the +** host parameter are not expanded in the SQL statement text. +** +** {F12287} The callback function registered by sqlite3_profile() is invoked +** as each SQL statement finishes. {F12288} The first parameter to the +** profile callback is a copy of the 3rd parameter to sqlite3_profile(). +** {F12289} The second parameter to the profile callback is a +** zero-terminated UTF-8 string that contains the complete text of +** the SQL statement as it was processed by [sqlite3_prepare_v2()] or +** the equivalent. {F12290} The third parameter to the profile +** callback is an estimate of the number of nanoseconds of +** wall-clock time required to run the SQL statement from start +** to finish. {END} +** +** The sqlite3_profile() API is currently considered experimental and +** is subject to change. +*/ +/*IMPORT_C*/ void *sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*); +/*IMPORT_C*/ void *sqlite3_profile(sqlite3*, + void(*xProfile)(void*,const char*,sqlite3_uint64), void*); + +/* +** CAPI3REF: Query Progress Callbacks {F12910} +** +** {F12911} This routine configures a callback function - the +** progress callback - that is invoked periodically during long +** running calls to [sqlite3_exec()], [sqlite3_step()] and +** [sqlite3_get_table()]. {END} An example use for this +** interface is to keep a GUI updated during a large query. +** +** {F12912} The progress callback is invoked once for every N virtual +** machine opcodes, where N is the second argument to this function. +** {F12913} The progress callback itself is identified by the third +** argument to this function. {F12914} The fourth argument to this +** function is a void pointer passed to the progress callback +** function each time it is invoked. {END} +** +** {F12915} If a call to [sqlite3_exec()], [sqlite3_step()], or +** [sqlite3_get_table()] results in fewer than N opcodes being executed, +** then the progress callback is never invoked. {END} +** +** {F12916} Only a single progress callback function may be registered for each +** open database connection. Every call to sqlite3_progress_handler() +** overwrites the results of the previous call. {F12917} +** To remove the progress callback altogether, pass NULL as the third +** argument to this function. {END} +** +** {F12918} If the progress callback returns a result other than 0, then +** the current query is immediately terminated and any database changes +** rolled back. {F12919} +** The containing [sqlite3_exec()], [sqlite3_step()], or +** [sqlite3_get_table()] call returns SQLITE_INTERRUPT. {END} This feature +** can be used, for example, to implement the "Cancel" button on a +** progress dialog box in a GUI. +*/ +/*IMPORT_C*/ void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*); + +/* +** CAPI3REF: Opening A New Database Connection {F12700} +** +** {F12701} These routines open an SQLite database file whose name +** is given by the filename argument. +** {F12702} The filename argument is interpreted as UTF-8 +** for [sqlite3_open()] and [sqlite3_open_v2()] and as UTF-16 +** in the native byte order for [sqlite3_open16()]. +** {F12703} An [sqlite3*] handle is returned in *ppDb, even +** if an error occurs. {F12723} (Exception: if SQLite is unable +** to allocate memory to hold the [sqlite3] object, a NULL will +** be written into *ppDb instead of a pointer to the [sqlite3] object.) +** {F12704} If the database is opened (and/or created) +** successfully, then [SQLITE_OK] is returned. {F12705} Otherwise an +** error code is returned. {F12706} The +** [sqlite3_errmsg()] or [sqlite3_errmsg16()] routines can be used to obtain +** an English language description of the error. +** +** {F12707} The default encoding for the database will be UTF-8 if +** [sqlite3_open()] or [sqlite3_open_v2()] is called and +** UTF-16 in the native byte order if [sqlite3_open16()] is used. +** +** {F12708} Whether or not an error occurs when it is opened, resources +** associated with the [sqlite3*] handle should be released by passing it +** to [sqlite3_close()] when it is no longer required. +** +** {F12709} The [sqlite3_open_v2()] interface works like [sqlite3_open()] +** except that it acccepts two additional parameters for additional control +** over the new database connection. {F12710} The flags parameter can be +** one of: +** +**
    +**
  1. [SQLITE_OPEN_READONLY] +**
  2. [SQLITE_OPEN_READWRITE] +**
  3. [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE] +**
+** +** {F12711} The first value opens the database read-only. +** {F12712} If the database does not previously exist, an error is returned. +** {F12713} The second option opens +** the database for reading and writing if possible, or reading only if +** if the file is write protected. {F12714} In either case the database +** must already exist or an error is returned. {F12715} The third option +** opens the database for reading and writing and creates it if it does +** not already exist. {F12716} +** The third options is behavior that is always used for [sqlite3_open()] +** and [sqlite3_open16()]. +** +** {F12717} If the filename is ":memory:", then an private +** in-memory database is created for the connection. {F12718} This in-memory +** database will vanish when the database connection is closed. {END} Future +** version of SQLite might make use of additional special filenames +** that begin with the ":" character. It is recommended that +** when a database filename really does begin with +** ":" that you prefix the filename with a pathname like "./" to +** avoid ambiguity. +** +** {F12719} If the filename is an empty string, then a private temporary +** on-disk database will be created. {F12720} This private database will be +** automatically deleted as soon as the database connection is closed. +** +** {F12721} The fourth parameter to sqlite3_open_v2() is the name of the +** [sqlite3_vfs] object that defines the operating system +** interface that the new database connection should use. {F12722} If the +** fourth parameter is a NULL pointer then the default [sqlite3_vfs] +** object is used. {END} +** +** Note to windows users: The encoding used for the filename argument +** of [sqlite3_open()] and [sqlite3_open_v2()] must be UTF-8, not whatever +** codepage is currently defined. Filenames containing international +** characters must be converted to UTF-8 prior to passing them into +** [sqlite3_open()] or [sqlite3_open_v2()]. +*/ +/*IMPORT_C*/ int sqlite3_open( + const char *filename, /* Database filename (UTF-8) */ + sqlite3 **ppDb /* OUT: SQLite db handle */ +); +/*IMPORT_C*/ int sqlite3_open16( + const void *filename, /* Database filename (UTF-16) */ + sqlite3 **ppDb /* OUT: SQLite db handle */ +); +/*IMPORT_C*/ int sqlite3_open_v2( + const char *filename, /* Database filename (UTF-8) */ + sqlite3 **ppDb, /* OUT: SQLite db handle */ + int flags, /* Flags */ + const char *zVfs /* Name of VFS module to use */ +); + +/* +** CAPI3REF: Error Codes And Messages {F12800} +** +** {F12801} The sqlite3_errcode() interface returns the numeric +** [SQLITE_OK | result code] or [SQLITE_IOERR_READ | extended result code] +** for the most recent failed sqlite3_* API call associated +** with [sqlite3] handle 'db'. {U12802} If a prior API call failed but the +** most recent API call succeeded, the return value from sqlite3_errcode() +** is undefined. {END} +** +** {F12803} The sqlite3_errmsg() and sqlite3_errmsg16() return English-language +** text that describes the error, as either UTF8 or UTF16 respectively. +** {F12804} Memory to hold the error message string is managed internally. +** {U12805} The +** string may be overwritten or deallocated by subsequent calls to SQLite +** interface functions. {END} +** +** {F12806} Calls to many sqlite3_* functions set the error code and +** string returned by [sqlite3_errcode()], [sqlite3_errmsg()], and +** [sqlite3_errmsg16()] overwriting the previous values. {F12807} +** Except, calls to [sqlite3_errcode()], +** [sqlite3_errmsg()], and [sqlite3_errmsg16()] themselves do not affect the +** results of future invocations. {F12808} Calls to API routines that +** do not return an error code (example: [sqlite3_data_count()]) do not +** change the error code returned by this routine. {F12809} Interfaces that +** are not associated with a specific database connection (examples: +** [sqlite3_mprintf()] or [sqlite3_enable_shared_cache()] do not change +** the return code. {END} +** +** {F12810} Assuming no other intervening sqlite3_* API calls are made, +** the error code returned by this function is associated with the same +** error as the strings returned by [sqlite3_errmsg()] and [sqlite3_errmsg16()]. +*/ +/*IMPORT_C*/ int sqlite3_errcode(sqlite3 *db); +/*IMPORT_C*/ const char *sqlite3_errmsg(sqlite3*); +/*IMPORT_C*/ const void *sqlite3_errmsg16(sqlite3*); + +/* +** CAPI3REF: SQL Statement Object {F13000} +** +** An instance of this object represent single SQL statements. This +** object is variously known as a "prepared statement" or a +** "compiled SQL statement" or simply as a "statement". +** +** The life of a statement object goes something like this: +** +**
    +**
  1. Create the object using [sqlite3_prepare_v2()] or a related +** function. +**
  2. Bind values to host parameters using +** [sqlite3_bind_blob | sqlite3_bind_* interfaces]. +**
  3. Run the SQL by calling [sqlite3_step()] one or more times. +**
  4. Reset the statement using [sqlite3_reset()] then go back +** to step 2. Do this zero or more times. +**
  5. Destroy the object using [sqlite3_finalize()]. +**
+** +** Refer to documentation on individual methods above for additional +** information. +*/ +typedef struct sqlite3_stmt sqlite3_stmt; + +/* +** CAPI3REF: Compiling An SQL Statement {F13010} +** +** To execute an SQL query, it must first be compiled into a byte-code +** program using one of these routines. +** +** {F13011} The first argument "db" is an [sqlite3 | SQLite database handle] +** obtained from a prior call to [sqlite3_open()], [sqlite3_open_v2()] +** or [sqlite3_open16()]. {F13012} +** The second argument "zSql" is the statement to be compiled, encoded +** as either UTF-8 or UTF-16. The sqlite3_prepare() and sqlite3_prepare_v2() +** interfaces uses UTF-8 and sqlite3_prepare16() and sqlite3_prepare16_v2() +** use UTF-16. {END} +** +** {F13013} If the nByte argument is less +** than zero, then zSql is read up to the first zero terminator. +** {F13014} If nByte is non-negative, then it is the maximum number of +** bytes read from zSql. When nByte is non-negative, the +** zSql string ends at either the first '\000' or '\u0000' character or +** until the nByte-th byte, whichever comes first. {END} +** +** {F13015} *pzTail is made to point to the first byte past the end of the +** first SQL statement in zSql. These routines only compiles the first +** statement in zSql, so *pzTail is left pointing to what remains +** uncompiled. {END} +** +** {F13016} *ppStmt is left pointing to a compiled +** [sqlite3_stmt | SQL statement structure] that can be +** executed using [sqlite3_step()]. Or if there is an error, *ppStmt may be +** set to NULL. {F13017} If the input text contains no SQL (if the input +** is and empty string or a comment) then *ppStmt is set to NULL. +** {U13018} The calling procedure is responsible for deleting the +** compiled SQL statement +** using [sqlite3_finalize()] after it has finished with it. +** +** {F13019} On success, [SQLITE_OK] is returned. Otherwise an +** [SQLITE_ERROR | error code] is returned. {END} +** +** The sqlite3_prepare_v2() and sqlite3_prepare16_v2() interfaces are +** recommended for all new programs. The two older interfaces are retained +** for backwards compatibility, but their use is discouraged. +** {F13020} In the "v2" interfaces, the prepared statement +** that is returned (the [sqlite3_stmt] object) contains a copy of the +** original SQL text. {END} This causes the [sqlite3_step()] interface to +** behave a differently in two ways: +** +**
    +**
  1. {F13022} +** If the database schema changes, instead of returning [SQLITE_SCHEMA] as it +** always used to do, [sqlite3_step()] will automatically recompile the SQL +** statement and try to run it again. {F12023} If the schema has changed in +** a way that makes the statement no longer valid, [sqlite3_step()] will still +** return [SQLITE_SCHEMA]. {END} But unlike the legacy behavior, +** [SQLITE_SCHEMA] is now a fatal error. {F12024} Calling +** [sqlite3_prepare_v2()] again will not make the +** error go away. {F12025} Note: use [sqlite3_errmsg()] to find the text +** of the parsing error that results in an [SQLITE_SCHEMA] return. {END} +**
    2. +** +**
  2. +** {F13030} When an error occurs, +** [sqlite3_step()] will return one of the detailed +** [SQLITE_ERROR | result codes] or +** [SQLITE_IOERR_READ | extended result codes]. {F13031} +** The legacy behavior was that [sqlite3_step()] would only return a generic +** [SQLITE_ERROR] result code and you would have to make a second call to +** [sqlite3_reset()] in order to find the underlying cause of the problem. +** {F13032} +** With the "v2" prepare interfaces, the underlying reason for the error is +** returned immediately. {END} +**
    3. +**
+*/ +/*IMPORT_C*/ int sqlite3_prepare( + sqlite3 *db, /* Database handle */ + const char *zSql, /* SQL statement, UTF-8 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const char **pzTail /* OUT: Pointer to unused portion of zSql */ +); +/*IMPORT_C*/ int sqlite3_prepare_v2( + sqlite3 *db, /* Database handle */ + const char *zSql, /* SQL statement, UTF-8 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const char **pzTail /* OUT: Pointer to unused portion of zSql */ +); +/*IMPORT_C*/ int sqlite3_prepare16( + sqlite3 *db, /* Database handle */ + const void *zSql, /* SQL statement, UTF-16 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const void **pzTail /* OUT: Pointer to unused portion of zSql */ +); +/*IMPORT_C*/ int sqlite3_prepare16_v2( + sqlite3 *db, /* Database handle */ + const void *zSql, /* SQL statement, UTF-16 encoded */ + int nByte, /* Maximum length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const void **pzTail /* OUT: Pointer to unused portion of zSql */ +); + +/* +** CAPIREF: Retrieving Statement SQL {F13100} +** +** {F13101} If the compiled SQL statement passed as an argument was +** compiled using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()], +** then this function returns a pointer to a zero-terminated string +** containing a copy of the original SQL statement. {F13102} The +** pointer is valid until the statement +** is deleted using sqlite3_finalize(). +** {F13103} The string returned by sqlite3_sql() is always UTF8 even +** if a UTF16 string was originally entered using [sqlite3_prepare16_v2()] +** or the equivalent. +** +** {F13104} If the statement was compiled using either of the legacy +** interfaces [sqlite3_prepare()] or [sqlite3_prepare16()], this +** function returns NULL. +*/ +/*IMPORT_C*/ const char *sqlite3_sql(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Dynamically Typed Value Object {F15000} +** +** {F15001} SQLite uses the sqlite3_value object to represent all values +** that are or can be stored in a database table. {END} +** SQLite uses dynamic typing for the values it stores. +** {F15002} Values stored in sqlite3_value objects can be +** be integers, floating point values, strings, BLOBs, or NULL. +*/ +typedef struct Mem sqlite3_value; + +/* +** CAPI3REF: SQL Function Context Object {F16001} +** +** The context in which an SQL function executes is stored in an +** sqlite3_context object. {F16002} A pointer to an sqlite3_context +** object is always first parameter to application-defined SQL functions. +*/ +typedef struct sqlite3_context sqlite3_context; + +/* +** CAPI3REF: Binding Values To Prepared Statements {F13500} +** +** {F13501} In the SQL strings input to [sqlite3_prepare_v2()] and its +** variants, literals may be replace by a parameter in one +** of these forms: +** +**
    +**
  • ? +**
  • ?NNN +**
  • :AAA +**
  • @AAA +**
  • $VVV +**
+** +** In the parameter forms shown above NNN is an integer literal, +** AAA is an alphanumeric identifier and VVV is a variable name according +** to the syntax rules of the TCL programming language. {END} +** The values of these parameters (also called "host parameter names") +** can be set using the sqlite3_bind_*() routines defined here. +** +** {F13502} The first argument to the sqlite3_bind_*() routines always +** is a pointer to the [sqlite3_stmt] object returned from +** [sqlite3_prepare_v2()] or its variants. {F13503} The second +** argument is the index of the parameter to be set. {F13504} The +** first parameter has an index of 1. {F13505} When the same named +** parameter is used more than once, second and subsequent +** occurrences have the same index as the first occurrence. +** {F13506} The index for named parameters can be looked up using the +** [sqlite3_bind_parameter_name()] API if desired. {F13507} The index +** for "?NNN" parameters is the value of NNN. +** {F13508} The NNN value must be between 1 and the compile-time +** parameter SQLITE_MAX_VARIABLE_NUMBER (default value: 999). {END} +** See limits.html for additional information. +** +** {F13509} The third argument is the value to bind to the parameter. {END} +** +** {F13510} In those +** routines that have a fourth argument, its value is the number of bytes +** in the parameter. To be clear: the value is the number of bytes in the +** string, not the number of characters. {F13511} The number +** of bytes does not include the zero-terminator at the end of strings. +** {F13512} +** If the fourth parameter is negative, the length of the string is +** number of bytes up to the first zero terminator. {END} +** +** {F13513} +** The fifth argument to sqlite3_bind_blob(), sqlite3_bind_text(), and +** sqlite3_bind_text16() is a destructor used to dispose of the BLOB or +** text after SQLite has finished with it. {F13514} If the fifth argument is +** the special value [SQLITE_STATIC], then the library assumes that the +** information is in static, unmanaged space and does not need to be freed. +** {F13515} If the fifth argument has the value [SQLITE_TRANSIENT], then +** SQLite makes its own private copy of the data immediately, before +** the sqlite3_bind_*() routine returns. {END} +** +** {F13520} The sqlite3_bind_zeroblob() routine binds a BLOB of length N that +** is filled with zeros. {F13521} A zeroblob uses a fixed amount of memory +** (just an integer to hold it size) while it is being processed. {END} +** Zeroblobs are intended to serve as place-holders for BLOBs whose +** content is later written using +** [sqlite3_blob_open | increment BLOB I/O] routines. {F13522} A negative +** value for the zeroblob results in a zero-length BLOB. {END} +** +** {F13530} The sqlite3_bind_*() routines must be called after +** [sqlite3_prepare_v2()] (and its variants) or [sqlite3_reset()] and +** before [sqlite3_step()]. {F13531} +** Bindings are not cleared by the [sqlite3_reset()] routine. +** {F13532} Unbound parameters are interpreted as NULL. {END} +** +** {F13540} These routines return [SQLITE_OK] on success or an error code if +** anything goes wrong. {F13541} [SQLITE_RANGE] is returned if the parameter +** index is out of range. {F13542} [SQLITE_NOMEM] is returned if malloc fails. +** {F13543} [SQLITE_MISUSE] is returned if these routines are called on a +** virtual machine that is the wrong state or which has already been finalized. +*/ +/*IMPORT_C*/ int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*)); +/*IMPORT_C*/ int sqlite3_bind_double(sqlite3_stmt*, int, double); +/*IMPORT_C*/ int sqlite3_bind_int(sqlite3_stmt*, int, int); +/*IMPORT_C*/ int sqlite3_bind_int64(sqlite3_stmt*, int, sqlite3_int64); +/*IMPORT_C*/ int sqlite3_bind_null(sqlite3_stmt*, int); +/*IMPORT_C*/ int sqlite3_bind_text(sqlite3_stmt*, int, const char*, int n, void(*)(void*)); +/*IMPORT_C*/ int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*)); +/*IMPORT_C*/ int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*); +/*IMPORT_C*/ int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n); + +/* +** CAPI3REF: Number Of Host Parameters {F13600} +** +** {F13601} Return the largest host parameter index in the precompiled +** statement given as the argument. {F13602} When the host parameters +** are of the forms like ":AAA", "$VVV", "@AAA", or "?", +** then they are assigned sequential increasing numbers beginning +** with one, so the value returned is the number of parameters. +** {F13603} However +** if the same host parameter name is used multiple times, each occurrance +** is given the same number, so the value returned in that case is the number +** of unique host parameter names. {F13604} If host parameters of the +** form "?NNN" are used (where NNN is an integer) then there might be +** gaps in the numbering and the value returned by this interface is +** the index of the host parameter with the largest index value. {END} +** +** {U13605} The prepared statement must not be [sqlite3_finalize | finalized] +** prior to this routine returning. Otherwise the results are undefined +** and probably undesirable. +*/ +/*IMPORT_C*/ int sqlite3_bind_parameter_count(sqlite3_stmt*); + +/* +** CAPI3REF: Name Of A Host Parameter {F13620} +** +** {F13621} This routine returns a pointer to the name of the n-th +** parameter in a [sqlite3_stmt | prepared statement]. {F13622} +** Host parameters of the form ":AAA" or "@AAA" or "$VVV" have a name +** which is the string ":AAA" or "@AAA" or "$VVV". +** In other words, the initial ":" or "$" or "@" +** is included as part of the name. {F13626} +** Parameters of the form "?" or "?NNN" have no name. +** +** {F13623} The first host parameter has an index of 1, not 0. +** +** {F13624} If the value n is out of range or if the n-th parameter is +** nameless, then NULL is returned. {F13625} The returned string is +** always in the UTF-8 encoding even if the named parameter was +** originally specified as UTF-16 in [sqlite3_prepare16()] or +** [sqlite3_prepare16_v2()]. +*/ +/*IMPORT_C*/ const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int); + +/* +** CAPI3REF: Index Of A Parameter With A Given Name {F13640} +** +** {F13641} This routine returns the index of a host parameter with the +** given name. {F13642} The name must match exactly. {F13643} +** If no parameter with the given name is found, return 0. +** {F13644} Parameter names must be UTF8. +*/ +/*IMPORT_C*/ int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName); + +/* +** CAPI3REF: Reset All Bindings On A Prepared Statement {F13660} +** +** {F13661} Contrary to the intuition of many, [sqlite3_reset()] does not +** reset the [sqlite3_bind_blob | bindings] on a +** [sqlite3_stmt | prepared statement]. {F13662} Use this routine to +** reset all host parameters to NULL. +*/ +/*IMPORT_C*/ int sqlite3_clear_bindings(sqlite3_stmt*); + +/* +** CAPI3REF: Number Of Columns In A Result Set {F13710} +** +** {F13711} Return the number of columns in the result set returned by the +** [sqlite3_stmt | compiled SQL statement]. {F13712} This routine returns 0 +** if pStmt is an SQL statement that does not return data (for +** example an UPDATE). +*/ +/*IMPORT_C*/ int sqlite3_column_count(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Column Names In A Result Set {F13720} +** +** {F13721} These routines return the name assigned to a particular column +** in the result set of a SELECT statement. {F13722} The sqlite3_column_name() +** interface returns a pointer to a zero-terminated UTF8 string +** and sqlite3_column_name16() returns a pointer to a zero-terminated +** UTF16 string. {F13723} The first parameter is the +** [sqlite3_stmt | prepared statement] that implements the SELECT statement. +** The second parameter is the column number. The left-most column is +** number 0. +** +** {F13724} The returned string pointer is valid until either the +** [sqlite3_stmt | prepared statement] is destroyed by [sqlite3_finalize()] +** or until the next call sqlite3_column_name() or sqlite3_column_name16() +** on the same column. +** +** {F13725} If sqlite3_malloc() fails during the processing of either routine +** (for example during a conversion from UTF-8 to UTF-16) then a +** NULL pointer is returned. +*/ +/*IMPORT_C*/ const char *sqlite3_column_name(sqlite3_stmt*, int N); +/*IMPORT_C*/ const void *sqlite3_column_name16(sqlite3_stmt*, int N); + +/* +** CAPI3REF: Source Of Data In A Query Result {F13740} +** +** {F13741} These routines provide a means to determine what column of what +** table in which database a result of a SELECT statement comes from. +** {F13742} The name of the database or table or column can be returned as +** either a UTF8 or UTF16 string. {F13743} The _database_ routines return +** the database name, the _table_ routines return the table name, and +** the origin_ routines return the column name. {F13744} +** The returned string is valid until +** the [sqlite3_stmt | prepared statement] is destroyed using +** [sqlite3_finalize()] or until the same information is requested +** again in a different encoding. +** +** {F13745} The names returned are the original un-aliased names of the +** database, table, and column. +** +** {F13746} The first argument to the following calls is a +** [sqlite3_stmt | compiled SQL statement]. +** {F13747} These functions return information about the Nth column returned by +** the statement, where N is the second function argument. +** +** {F13748} If the Nth column returned by the statement is an expression +** or subquery and is not a column value, then all of these functions +** return NULL. {F13749} Otherwise, they return the +** name of the attached database, table and column that query result +** column was extracted from. +** +** {F13750} As with all other SQLite APIs, those postfixed with "16" return +** UTF-16 encoded strings, the other functions return UTF-8. {END} +** +** These APIs are only available if the library was compiled with the +** SQLITE_ENABLE_COLUMN_METADATA preprocessor symbol defined. +** +** {U13751} +** If two or more threads call one or more of these routines against the same +** prepared statement and column at the same time then the results are +** undefined. +*/ +/*IMPORT_C*/ const char *sqlite3_column_database_name(sqlite3_stmt*,int); +/*IMPORT_C*/ const void *sqlite3_column_database_name16(sqlite3_stmt*,int); +/*IMPORT_C*/ const char *sqlite3_column_table_name(sqlite3_stmt*,int); +/*IMPORT_C*/ const void *sqlite3_column_table_name16(sqlite3_stmt*,int); +/*IMPORT_C*/ const char *sqlite3_column_origin_name(sqlite3_stmt*,int); +/*IMPORT_C*/ const void *sqlite3_column_origin_name16(sqlite3_stmt*,int); + +/* +** CAPI3REF: Declared Datatype Of A Query Result {F13760} +** +** The first parameter is a [sqlite3_stmt | compiled SQL statement]. +** {F13761} If this statement is a SELECT statement and the Nth column of the +** returned result set of that SELECT is a table column (not an +** expression or subquery) then the declared type of the table +** column is returned. {F13762} If the Nth column of the result set is an +** expression or subquery, then a NULL pointer is returned. +** {F13763} The returned string is always UTF-8 encoded. {END} +** For example, in the database schema: +** +** CREATE TABLE t1(c1 VARIANT); +** +** And the following statement compiled: +** +** SELECT c1 + 1, c1 FROM t1; +** +** Then this routine would return the string "VARIANT" for the second +** result column (i==1), and a NULL pointer for the first result column +** (i==0). +** +** SQLite uses dynamic run-time typing. So just because a column +** is declared to contain a particular type does not mean that the +** data stored in that column is of the declared type. SQLite is +** strongly typed, but the typing is dynamic not static. Type +** is associated with individual values, not with the containers +** used to hold those values. +*/ +/*IMPORT_C*/ const char *sqlite3_column_decltype(sqlite3_stmt *, int i); +/*IMPORT_C*/ const void *sqlite3_column_decltype16(sqlite3_stmt*,int); + +/* +** CAPI3REF: Evaluate An SQL Statement {F13200} +** +** After an [sqlite3_stmt | SQL statement] has been prepared with a call +** to either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] or to one of +** the legacy interfaces [sqlite3_prepare()] or [sqlite3_prepare16()], +** then this function must be called one or more times to evaluate the +** statement. +** +** The details of the behavior of this sqlite3_step() interface depend +** on whether the statement was prepared using the newer "v2" interface +** [sqlite3_prepare_v2()] and [sqlite3_prepare16_v2()] or the older legacy +** interface [sqlite3_prepare()] and [sqlite3_prepare16()]. The use of the +** new "v2" interface is recommended for new applications but the legacy +** interface will continue to be supported. +** +** In the lagacy interface, the return value will be either [SQLITE_BUSY], +** [SQLITE_DONE], [SQLITE_ROW], [SQLITE_ERROR], or [SQLITE_MISUSE]. +** With the "v2" interface, any of the other [SQLITE_OK | result code] +** or [SQLITE_IOERR_READ | extended result code] might be returned as +** well. +** +** [SQLITE_BUSY] means that the database engine was unable to acquire the +** database locks it needs to do its job. If the statement is a COMMIT +** or occurs outside of an explicit transaction, then you can retry the +** statement. If the statement is not a COMMIT and occurs within a +** explicit transaction then you should rollback the transaction before +** continuing. +** +** [SQLITE_DONE] means that the statement has finished executing +** successfully. sqlite3_step() should not be called again on this virtual +** machine without first calling [sqlite3_reset()] to reset the virtual +** machine back to its initial state. +** +** If the SQL statement being executed returns any data, then +** [SQLITE_ROW] is returned each time a new row of data is ready +** for processing by the caller. The values may be accessed using +** the [sqlite3_column_int | column access functions]. +** sqlite3_step() is called again to retrieve the next row of data. +** +** [SQLITE_ERROR] means that a run-time error (such as a constraint +** violation) has occurred. sqlite3_step() should not be called again on +** the VM. More information may be found by calling [sqlite3_errmsg()]. +** With the legacy interface, a more specific error code (example: +** [SQLITE_INTERRUPT], [SQLITE_SCHEMA], [SQLITE_CORRUPT], and so forth) +** can be obtained by calling [sqlite3_reset()] on the +** [sqlite3_stmt | prepared statement]. In the "v2" interface, +** the more specific error code is returned directly by sqlite3_step(). +** +** [SQLITE_MISUSE] means that the this routine was called inappropriately. +** Perhaps it was called on a [sqlite3_stmt | prepared statement] that has +** already been [sqlite3_finalize | finalized] or on one that had +** previously returned [SQLITE_ERROR] or [SQLITE_DONE]. Or it could +** be the case that the same database connection is being used by two or +** more threads at the same moment in time. +** +** Goofy Interface Alert: +** In the legacy interface, +** the sqlite3_step() API always returns a generic error code, +** [SQLITE_ERROR], following any error other than [SQLITE_BUSY] +** and [SQLITE_MISUSE]. You must call [sqlite3_reset()] or +** [sqlite3_finalize()] in order to find one of the specific +** [SQLITE_ERROR | result codes] that better describes the error. +** We admit that this is a goofy design. The problem has been fixed +** with the "v2" interface. If you prepare all of your SQL statements +** using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] instead +** of the legacy [sqlite3_prepare()] and [sqlite3_prepare16()], then the +** more specific [SQLITE_ERROR | result codes] are returned directly +** by sqlite3_step(). The use of the "v2" interface is recommended. +*/ +/*IMPORT_C*/ int sqlite3_step(sqlite3_stmt*); + +/* +** CAPI3REF: Number of columns in a result set {F13770} +** +** Return the number of values in the current row of the result set. +** +** {F13771} After a call to [sqlite3_step()] that returns [SQLITE_ROW], +** this routine +** will return the same value as the [sqlite3_column_count()] function. +** {F13772} +** After [sqlite3_step()] has returned an [SQLITE_DONE], [SQLITE_BUSY], or +** a [SQLITE_ERROR | error code], or before [sqlite3_step()] has been +** called on the [sqlite3_stmt | prepared statement] for the first time, +** this routine returns zero. +*/ +/*IMPORT_C*/ int sqlite3_data_count(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Fundamental Datatypes {F10265} +** +** {F10266}Every value in SQLite has one of five fundamental datatypes: +** +**
    +**
  • 64-bit signed integer +**
  • 64-bit IEEE floating point number +**
  • string +**
  • BLOB +**
  • NULL +**
{END} +** +** These constants are codes for each of those types. +** +** Note that the SQLITE_TEXT constant was also used in SQLite version 2 +** for a completely different meaning. Software that links against both +** SQLite version 2 and SQLite version 3 should use SQLITE3_TEXT not +** SQLITE_TEXT. +*/ +#define SQLITE_INTEGER 1 +#define SQLITE_FLOAT 2 +#define SQLITE_BLOB 4 +#define SQLITE_NULL 5 +#ifdef SQLITE_TEXT +# undef SQLITE_TEXT +#else +# define SQLITE_TEXT 3 +#endif +#define SQLITE3_TEXT 3 + +/* +** CAPI3REF: Results Values From A Query {F13800} +** +** These routines return information about +** a single column of the current result row of a query. In every +** case the first argument is a pointer to the +** [sqlite3_stmt | SQL statement] that is being +** evaluated (the [sqlite3_stmt*] that was returned from +** [sqlite3_prepare_v2()] or one of its variants) and +** the second argument is the index of the column for which information +** should be returned. The left-most column of the result set +** has an index of 0. +** +** If the SQL statement is not currently point to a valid row, or if the +** the column index is out of range, the result is undefined. +** These routines may only be called when the most recent call to +** [sqlite3_step()] has returned [SQLITE_ROW] and neither +** [sqlite3_reset()] nor [sqlite3_finalize()] has been call subsequently. +** If any of these routines are called after [sqlite3_reset()] or +** [sqlite3_finalize()] or after [sqlite3_step()] has returned +** something other than [SQLITE_ROW], the results are undefined. +** If [sqlite3_step()] or [sqlite3_reset()] or [sqlite3_finalize()] +** are called from a different thread while any of these routines +** are pending, then the results are undefined. +** +** The sqlite3_column_type() routine returns +** [SQLITE_INTEGER | datatype code] for the initial data type +** of the result column. The returned value is one of [SQLITE_INTEGER], +** [SQLITE_FLOAT], [SQLITE_TEXT], [SQLITE_BLOB], or [SQLITE_NULL]. The value +** returned by sqlite3_column_type() is only meaningful if no type +** conversions have occurred as described below. After a type conversion, +** the value returned by sqlite3_column_type() is undefined. Future +** versions of SQLite may change the behavior of sqlite3_column_type() +** following a type conversion. +** +** If the result is a BLOB or UTF-8 string then the sqlite3_column_bytes() +** routine returns the number of bytes in that BLOB or string. +** If the result is a UTF-16 string, then sqlite3_column_bytes() converts +** the string to UTF-8 and then returns the number of bytes. +** If the result is a numeric value then sqlite3_column_bytes() uses +** [sqlite3_snprintf()] to convert that value to a UTF-8 string and returns +** the number of bytes in that string. +** The value returned does not include the zero terminator at the end +** of the string. For clarity: the value returned is the number of +** bytes in the string, not the number of characters. +** +** Strings returned by sqlite3_column_text() and sqlite3_column_text16(), +** even zero-length strings, are always zero terminated. The return +** value from sqlite3_column_blob() for a zero-length blob is an arbitrary +** pointer, possibly even a NULL pointer. +** +** The sqlite3_column_bytes16() routine is similar to sqlite3_column_bytes() +** but leaves the result in UTF-16 instead of UTF-8. +** The zero terminator is not included in this count. +** +** These routines attempt to convert the value where appropriate. For +** example, if the internal representation is FLOAT and a text result +** is requested, [sqlite3_snprintf()] is used internally to do the conversion +** automatically. The following table details the conversions that +** are applied: +** +**
+**
+**
Internal
Type 		Requested
Type 		Conversion +** +**
NULL INTEGER Result is 0 +**
NULL FLOAT Result is 0.0 +**
NULL TEXT Result is NULL pointer +**
NULL BLOB Result is NULL pointer +**
INTEGER FLOAT Convert from integer to float +**
INTEGER TEXT ASCII rendering of the integer +**
INTEGER BLOB Same as for INTEGER->TEXT +**
FLOAT INTEGER Convert from float to integer +**
FLOAT TEXT ASCII rendering of the float +**
FLOAT BLOB Same as FLOAT->TEXT +**
TEXT INTEGER Use atoi() +**
TEXT FLOAT Use atof() +**
TEXT BLOB No change +**
BLOB INTEGER Convert to TEXT then use atoi() +**
BLOB FLOAT Convert to TEXT then use atof() +**
BLOB TEXT Add a zero terminator if needed +**
+** +** +** The table above makes reference to standard C library functions atoi() +** and atof(). SQLite does not really use these functions. It has its +** on equavalent internal routines. The atoi() and atof() names are +** used in the table for brevity and because they are familiar to most +** C programmers. +** +** Note that when type conversions occur, pointers returned by prior +** calls to sqlite3_column_blob(), sqlite3_column_text(), and/or +** sqlite3_column_text16() may be invalidated. +** Type conversions and pointer invalidations might occur +** in the following cases: +** +**
    +**

  • The initial content is a BLOB and sqlite3_column_text() +** or sqlite3_column_text16() is called. A zero-terminator might +** need to be added to the string.

    • +** +**

  • The initial content is UTF-8 text and sqlite3_column_bytes16() or +** sqlite3_column_text16() is called. The content must be converted +** to UTF-16.

    • +** +**

  • The initial content is UTF-16 text and sqlite3_column_bytes() or +** sqlite3_column_text() is called. The content must be converted +** to UTF-8.

    • +**
+** +** Conversions between UTF-16be and UTF-16le are always done in place and do +** not invalidate a prior pointer, though of course the content of the buffer +** that the prior pointer points to will have been modified. Other kinds +** of conversion are done in place when it is possible, but sometime it is +** not possible and in those cases prior pointers are invalidated. +** +** The safest and easiest to remember policy is to invoke these routines +** in one of the following ways: +** +**
    +**
  • sqlite3_column_text() followed by sqlite3_column_bytes()
    • +**
  • sqlite3_column_blob() followed by sqlite3_column_bytes()
    • +**
  • sqlite3_column_text16() followed by sqlite3_column_bytes16()
    • +**
+** +** In other words, you should call sqlite3_column_text(), sqlite3_column_blob(), +** or sqlite3_column_text16() first to force the result into the desired +** format, then invoke sqlite3_column_bytes() or sqlite3_column_bytes16() to +** find the size of the result. Do not mix call to sqlite3_column_text() or +** sqlite3_column_blob() with calls to sqlite3_column_bytes16(). And do not +** mix calls to sqlite3_column_text16() with calls to sqlite3_column_bytes(). +** +** The pointers returned are valid until a type conversion occurs as +** described above, or until [sqlite3_step()] or [sqlite3_reset()] or +** [sqlite3_finalize()] is called. The memory space used to hold strings +** and blobs is freed automatically. Do not pass the pointers returned +** [sqlite3_column_blob()], [sqlite3_column_text()], etc. into +** [sqlite3_free()]. +** +** If a memory allocation error occurs during the evaluation of any +** of these routines, a default value is returned. The default value +** is either the integer 0, the floating point number 0.0, or a NULL +** pointer. Subsequent calls to [sqlite3_errcode()] will return +** [SQLITE_NOMEM]. +*/ +/*IMPORT_C*/ const void *sqlite3_column_blob(sqlite3_stmt*, int iCol); +/*IMPORT_C*/ int sqlite3_column_bytes(sqlite3_stmt*, int iCol); +/*IMPORT_C*/ int sqlite3_column_bytes16(sqlite3_stmt*, int iCol); +/*IMPORT_C*/ double sqlite3_column_double(sqlite3_stmt*, int iCol); +/*IMPORT_C*/ int sqlite3_column_int(sqlite3_stmt*, int iCol); +/*IMPORT_C*/ sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol); +/*IMPORT_C*/ const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol); +/*IMPORT_C*/ const void *sqlite3_column_text16(sqlite3_stmt*, int iCol); +/*IMPORT_C*/ int sqlite3_column_type(sqlite3_stmt*, int iCol); +/*IMPORT_C*/ sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol); + +/* +** CAPI3REF: Destroy A Prepared Statement Object {F13300} +** +** The sqlite3_finalize() function is called to delete a +** [sqlite3_stmt | compiled SQL statement]. If the statement was +** executed successfully, or not executed at all, then SQLITE_OK is returned. +** If execution of the statement failed then an +** [SQLITE_ERROR | error code] or [SQLITE_IOERR_READ | extended error code] +** is returned. +** +** This routine can be called at any point during the execution of the +** [sqlite3_stmt | virtual machine]. If the virtual machine has not +** completed execution when this routine is called, that is like +** encountering an error or an interrupt. (See [sqlite3_interrupt()].) +** Incomplete updates may be rolled back and transactions cancelled, +** depending on the circumstances, and the +** [SQLITE_ERROR | result code] returned will be [SQLITE_ABORT]. +*/ +/*IMPORT_C*/ int sqlite3_finalize(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Reset A Prepared Statement Object {F13330} +** +** The sqlite3_reset() function is called to reset a +** [sqlite3_stmt | compiled SQL statement] object. +** back to its initial state, ready to be re-executed. +** Any SQL statement variables that had values bound to them using +** the [sqlite3_bind_blob | sqlite3_bind_*() API] retain their values. +** Use [sqlite3_clear_bindings()] to reset the bindings. +*/ +/*IMPORT_C*/ int sqlite3_reset(sqlite3_stmt *pStmt); + +/* +** CAPI3REF: Create Or Redefine SQL Functions {F16100} +** +** The following two functions are used to add SQL functions or aggregates +** or to redefine the behavior of existing SQL functions or aggregates. The +** difference only between the two is that the second parameter, the +** name of the (scalar) function or aggregate, is encoded in UTF-8 for +** sqlite3_create_function() and UTF-16 for sqlite3_create_function16(). +** +** The first argument is the [sqlite3 | database handle] that holds the +** SQL function or aggregate is to be added or redefined. If a single +** program uses more than one database handle internally, then SQL +** functions or aggregates must be added individually to each database +** handle with which they will be used. +** +** The second parameter is the name of the SQL function to be created +** or redefined. +** The length of the name is limited to 255 bytes, exclusive of the +** zero-terminator. Note that the name length limit is in bytes, not +** characters. Any attempt to create a function with a longer name +** will result in an SQLITE_ERROR error. +** +** The third parameter is the number of arguments that the SQL function or +** aggregate takes. If this parameter is negative, then the SQL function or +** aggregate may take any number of arguments. +** +** The fourth parameter, eTextRep, specifies what +** [SQLITE_UTF8 | text encoding] this SQL function prefers for +** its parameters. Any SQL function implementation should be able to work +** work with UTF-8, UTF-16le, or UTF-16be. But some implementations may be +** more efficient with one encoding than another. It is allowed to +** invoke sqlite3_create_function() or sqlite3_create_function16() multiple +** times with the same function but with different values of eTextRep. +** When multiple implementations of the same function are available, SQLite +** will pick the one that involves the least amount of data conversion. +** If there is only a single implementation which does not care what +** text encoding is used, then the fourth argument should be +** [SQLITE_ANY]. +** +** The fifth parameter is an arbitrary pointer. The implementation +** of the function can gain access to this pointer using +** [sqlite3_user_data()]. +** +** The seventh, eighth and ninth parameters, xFunc, xStep and xFinal, are +** pointers to C-language functions that implement the SQL +** function or aggregate. A scalar SQL function requires an implementation of +** the xFunc callback only, NULL pointers should be passed as the xStep +** and xFinal parameters. An aggregate SQL function requires an implementation +** of xStep and xFinal and NULL should be passed for xFunc. To delete an +** existing SQL function or aggregate, pass NULL for all three function +** callback. +** +** It is permitted to register multiple implementations of the same +** functions with the same name but with either differing numbers of +** arguments or differing perferred text encodings. SQLite will use +** the implementation most closely matches the way in which the +** SQL function is used. +*/ +/*IMPORT_C*/ int sqlite3_create_function( + sqlite3 *, + const char *zFunctionName, + int nArg, + int eTextRep, + void*, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*) +); +/*IMPORT_C*/ int sqlite3_create_function16( + sqlite3*, + const void *zFunctionName, + int nArg, + int eTextRep, + void*, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*) +); + +/* +** CAPI3REF: Text Encodings {F10267} +** +** These constant define integer codes that represent the various +** text encodings supported by SQLite. +*/ +#define SQLITE_UTF8 1 +#define SQLITE_UTF16LE 2 +#define SQLITE_UTF16BE 3 +#define SQLITE_UTF16 4 /* Use native byte order */ +#define SQLITE_ANY 5 /* sqlite3_create_function only */ +#define SQLITE_UTF16_ALIGNED 8 /* sqlite3_create_collation only */ + +/* +** CAPI3REF: Obsolete Functions +** +** These functions are all now obsolete. In order to maintain +** backwards compatibility with older code, we continue to support +** these functions. However, new development projects should avoid +** the use of these functions. To help encourage people to avoid +** using these functions, we are not going to tell you want they do. +*/ +/*IMPORT_C*/ int sqlite3_aggregate_count(sqlite3_context*); +/*IMPORT_C*/ int sqlite3_expired(sqlite3_stmt*); +/*IMPORT_C*/ int sqlite3_transfer_bindings(sqlite3_stmt*, sqlite3_stmt*); +/*IMPORT_C*/ int sqlite3_global_recover(void); +/*IMPORT_C*/ void sqlite3_thread_cleanup(void); +/*IMPORT_C*/ int sqlite3_memory_alarm(void(*)(void*,sqlite3_int64,int),void*,sqlite3_int64); + +/* +** CAPI3REF: Obtaining SQL Function Parameter Values {F15100} +** +** The C-language implementation of SQL functions and aggregates uses +** this set of interface routines to access the parameter values on +** the function or aggregate. +** +** The xFunc (for scalar functions) or xStep (for aggregates) parameters +** to [sqlite3_create_function()] and [sqlite3_create_function16()] +** define callbacks that implement the SQL functions and aggregates. +** The 4th parameter to these callbacks is an array of pointers to +** [sqlite3_value] objects. There is one [sqlite3_value] object for +** each parameter to the SQL function. These routines are used to +** extract values from the [sqlite3_value] objects. +** +** These routines work just like the corresponding +** [sqlite3_column_blob | sqlite3_column_* routines] except that +** these routines take a single [sqlite3_value*] pointer instead +** of an [sqlite3_stmt*] pointer and an integer column number. +** +** The sqlite3_value_text16() interface extracts a UTF16 string +** in the native byte-order of the host machine. The +** sqlite3_value_text16be() and sqlite3_value_text16le() interfaces +** extract UTF16 strings as big-endian and little-endian respectively. +** +** The sqlite3_value_numeric_type() interface attempts to apply +** numeric affinity to the value. This means that an attempt is +** made to convert the value to an integer or floating point. If +** such a conversion is possible without loss of information (in other +** words if the value is a string that looks like a number) +** then the conversion is done. Otherwise no conversion occurs. The +** [SQLITE_INTEGER | datatype] after conversion is returned. +** +** Please pay particular attention to the fact that the pointer that +** is returned from [sqlite3_value_blob()], [sqlite3_value_text()], or +** [sqlite3_value_text16()] can be invalidated by a subsequent call to +** [sqlite3_value_bytes()], [sqlite3_value_bytes16()], [sqlite3_value_text()], +** or [sqlite3_value_text16()]. +** +** These routines must be called from the same thread as +** the SQL function that supplied the sqlite3_value* parameters. +** Or, if the sqlite3_value* argument comes from the [sqlite3_column_value()] +** interface, then these routines should be called from the same thread +** that ran [sqlite3_column_value()]. +** +*/ +/*IMPORT_C*/ const void *sqlite3_value_blob(sqlite3_value*); +/*IMPORT_C*/ int sqlite3_value_bytes(sqlite3_value*); +/*IMPORT_C*/ int sqlite3_value_bytes16(sqlite3_value*); +/*IMPORT_C*/ double sqlite3_value_double(sqlite3_value*); +/*IMPORT_C*/ int sqlite3_value_int(sqlite3_value*); +/*IMPORT_C*/ sqlite3_int64 sqlite3_value_int64(sqlite3_value*); +/*IMPORT_C*/ const unsigned char *sqlite3_value_text(sqlite3_value*); +/*IMPORT_C*/ const void *sqlite3_value_text16(sqlite3_value*); +/*IMPORT_C*/ const void *sqlite3_value_text16le(sqlite3_value*); +/*IMPORT_C*/ const void *sqlite3_value_text16be(sqlite3_value*); +/*IMPORT_C*/ int sqlite3_value_type(sqlite3_value*); +/*IMPORT_C*/ int sqlite3_value_numeric_type(sqlite3_value*); + +/* +** CAPI3REF: Obtain Aggregate Function Context {F16210} +** +** The implementation of aggregate SQL functions use this routine to allocate +** a structure for storing their state. +** {F16211} The first time the sqlite3_aggregate_context() routine is +** is called for a particular aggregate, SQLite allocates nBytes of memory +** zeros that memory, and returns a pointer to it. +** {F16212} On second and subsequent calls to sqlite3_aggregate_context() +** for the same aggregate function index, the same buffer is returned. {END} +** The implementation +** of the aggregate can use the returned buffer to accumulate data. +** +** {F16213} SQLite automatically frees the allocated buffer when the aggregate +** query concludes. {END} +** +** The first parameter should be a copy of the +** [sqlite3_context | SQL function context] that is the first +** parameter to the callback routine that implements the aggregate +** function. +** +** This routine must be called from the same thread in which +** the aggregate SQL function is running. +*/ +/*IMPORT_C*/ void *sqlite3_aggregate_context(sqlite3_context*, int nBytes); + +/* +** CAPI3REF: User Data For Functions {F16240} +** +** {F16241} The sqlite3_user_data() interface returns a copy of +** the pointer that was the pUserData parameter (the 5th parameter) +** of the the [sqlite3_create_function()] +** and [sqlite3_create_function16()] routines that originally +** registered the application defined function. {END} +** +** {U16243} This routine must be called from the same thread in which +** the application-defined function is running. +*/ +/*IMPORT_C*/ void *sqlite3_user_data(sqlite3_context*); + +/* +** CAPI3REF: Function Auxiliary Data {F16270} +** +** The following two functions may be used by scalar SQL functions to +** associate meta-data with argument values. If the same value is passed to +** multiple invocations of the same SQL function during query execution, under +** some circumstances the associated meta-data may be preserved. This may +** be used, for example, to add a regular-expression matching scalar +** function. The compiled version of the regular expression is stored as +** meta-data associated with the SQL value passed as the regular expression +** pattern. The compiled regular expression can be reused on multiple +** invocations of the same function so that the original pattern string +** does not need to be recompiled on each invocation. +** +** {F16271} +** The sqlite3_get_auxdata() interface returns a pointer to the meta-data +** associated by the sqlite3_set_auxdata() function with the Nth argument +** value to the application-defined function. +** {F16272} If no meta-data has been ever been set for the Nth +** argument of the function, or if the cooresponding function parameter +** has changed since the meta-data was set, then sqlite3_get_auxdata() +** returns a NULL pointer. +** +** {F16275} The sqlite3_set_auxdata() interface saves the meta-data +** pointed to by its 3rd parameter as the meta-data for the N-th +** argument of the application-defined function. {END} Subsequent +** calls to sqlite3_get_auxdata() might return this data, if it has +** not been destroyed. +** {F16277} If it is not NULL, SQLite will invoke the destructor +** function given by the 4th parameter to sqlite3_set_auxdata() on +** the meta-data when the corresponding function parameter changes +** or when the SQL statement completes, whichever comes first. {END} +** +** In practice, meta-data is preserved between function calls for +** expressions that are constant at compile time. This includes literal +** values and SQL variables. +** +** These routines must be called from the same thread in which +** the SQL function is running. +*/ +/*IMPORT_C*/ void *sqlite3_get_auxdata(sqlite3_context*, int N); +/*IMPORT_C*/ void sqlite3_set_auxdata(sqlite3_context*, int N, void*, void (*)(void*)); + + +/* +** CAPI3REF: Constants Defining Special Destructor Behavior {F10280} +** +** These are special value for the destructor that is passed in as the +** final argument to routines like [sqlite3_result_blob()]. If the destructor +** argument is SQLITE_STATIC, it means that the content pointer is constant +** and will never change. It does not need to be destroyed. The +** SQLITE_TRANSIENT value means that the content will likely change in +** the near future and that SQLite should make its own private copy of +** the content before returning. +** +** The typedef is necessary to work around problems in certain +** C++ compilers. See ticket #2191. +*/ +typedef void (*sqlite3_destructor_type)(void*); +#define SQLITE_STATIC ((sqlite3_destructor_type)0) +#define SQLITE_TRANSIENT ((sqlite3_destructor_type)-1) + +/* +** CAPI3REF: Setting The Result Of An SQL Function {F16400} +** +** These routines are used by the xFunc or xFinal callbacks that +** implement SQL functions and aggregates. See +** [sqlite3_create_function()] and [sqlite3_create_function16()] +** for additional information. +** +** These functions work very much like the +** [sqlite3_bind_blob | sqlite3_bind_*] family of functions used +** to bind values to host parameters in prepared statements. +** Refer to the +** [sqlite3_bind_blob | sqlite3_bind_* documentation] for +** additional information. +** +** {F16402} The sqlite3_result_blob() interface sets the result from +** an application defined function to be the BLOB whose content is pointed +** to by the second parameter and which is N bytes long where N is the +** third parameter. +** {F16403} The sqlite3_result_zeroblob() inerfaces set the result of +** the application defined function to be a BLOB containing all zero +** bytes and N bytes in size, where N is the value of the 2nd parameter. +** +** {F16407} The sqlite3_result_double() interface sets the result from +** an application defined function to be a floating point value specified +** by its 2nd argument. +** +** {F16409} The sqlite3_result_error() and sqlite3_result_error16() functions +** cause the implemented SQL function to throw an exception. +** {F16411} SQLite uses the string pointed to by the +** 2nd parameter of sqlite3_result_error() or sqlite3_result_error16() +** as the text of an error message. {F16412} SQLite interprets the error +** message string from sqlite3_result_error() as UTF8. {F16413} SQLite +** interprets the string from sqlite3_result_error16() as UTF16 in native +** byte order. {F16414} If the third parameter to sqlite3_result_error() +** or sqlite3_result_error16() is negative then SQLite takes as the error +** message all text up through the first zero character. +** {F16415} If the third parameter to sqlite3_result_error() or +** sqlite3_result_error16() is non-negative then SQLite takes that many +** bytes (not characters) from the 2nd parameter as the error message. +** {F16417} The sqlite3_result_error() and sqlite3_result_error16() +** routines make a copy private copy of the error message text before +** they return. {END} Hence, the calling function can deallocate or +** modify the text after they return without harm. +** +** {F16421} The sqlite3_result_toobig() interface causes SQLite +** to throw an error indicating that a string or BLOB is to long +** to represent. {F16422} The sqlite3_result_nomem() interface +** causes SQLite to throw an exception indicating that the a +** memory allocation failed. +** +** {F16431} The sqlite3_result_int() interface sets the return value +** of the application-defined function to be the 32-bit signed integer +** value given in the 2nd argument. +** {F16432} The sqlite3_result_int64() interface sets the return value +** of the application-defined function to be the 64-bit signed integer +** value given in the 2nd argument. +** +** {F16437} The sqlite3_result_null() interface sets the return value +** of the application-defined function to be NULL. +** +** {F16441} The sqlite3_result_text(), sqlite3_result_text16(), +** sqlite3_result_text16le(), and sqlite3_result_text16be() interfaces +** set the return value of the application-defined function to be +** a text string which is represented as UTF-8, UTF-16 native byte order, +** UTF-16 little endian, or UTF-16 big endian, respectively. +** {F16442} SQLite takes the text result from the application from +** the 2nd parameter of the sqlite3_result_text* interfaces. +** {F16444} If the 3rd parameter to the sqlite3_result_text* interfaces +** is negative, then SQLite takes result text from the 2nd parameter +** through the first zero character. +** {F16447} If the 3rd parameter to the sqlite3_result_text* interfaces +** is non-negative, then as many bytes (not characters) of the text +** pointed to by the 2nd parameter are taken as the application-defined +** function result. +** {F16451} If the 4th parameter to the sqlite3_result_text* interfaces +** or sqlite3_result_blob is a non-NULL pointer, then SQLite calls that +** function as the destructor on the text or blob result when it has +** finished using that result. +** {F16453} If the 4th parameter to the sqlite3_result_text* interfaces +** or sqlite3_result_blob is the special constant SQLITE_STATIC, then +** SQLite assumes that the text or blob result is constant space and +** does not copy the space or call a destructor when it has +** finished using that result. +** {F16454} If the 4th parameter to the sqlite3_result_text* interfaces +** or sqlite3_result_blob is the special constant SQLITE_TRANSIENT +** then SQLite makes a copy of the result into space obtained from +** from [sqlite3_malloc()] before it returns. +** +** {F16461} The sqlite3_result_value() interface sets the result of +** the application-defined function to be a copy the [sqlite3_value] +** object specified by the 2nd parameter. {F16463} The +** sqlite3_result_value() interface makes a copy of the [sqlite3_value] +** so that [sqlite3_value] specified in the parameter may change or +** be deallocated after sqlite3_result_value() returns without harm. +** +** {U16491} These routines are called from within the different thread +** than the one containing the application-defined function that recieved +** the [sqlite3_context] pointer, the results are undefined. +*/ +/*IMPORT_C*/ void sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*)); +/*IMPORT_C*/ void sqlite3_result_double(sqlite3_context*, double); +/*IMPORT_C*/ void sqlite3_result_error(sqlite3_context*, const char*, int); +/*IMPORT_C*/ void sqlite3_result_error16(sqlite3_context*, const void*, int); +/*IMPORT_C*/ void sqlite3_result_error_toobig(sqlite3_context*); +/*IMPORT_C*/ void sqlite3_result_error_nomem(sqlite3_context*); +/*IMPORT_C*/ void sqlite3_result_int(sqlite3_context*, int); +/*IMPORT_C*/ void sqlite3_result_int64(sqlite3_context*, sqlite3_int64); +/*IMPORT_C*/ void sqlite3_result_null(sqlite3_context*); +/*IMPORT_C*/ void sqlite3_result_text(sqlite3_context*, const char*, int, void(*)(void*)); +/*IMPORT_C*/ void sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*)); +/*IMPORT_C*/ void sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*)); +/*IMPORT_C*/ void sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*)); +/*IMPORT_C*/ void sqlite3_result_value(sqlite3_context*, sqlite3_value*); +/*IMPORT_C*/ void sqlite3_result_zeroblob(sqlite3_context*, int n); + +/* +** CAPI3REF: Define New Collating Sequences {F16600} +** +** {F16601} +** These functions are used to add new collation sequences to the +** [sqlite3*] handle specified as the first argument. +** +** {F16602} +** The name of the new collation sequence is specified as a UTF-8 string +** for sqlite3_create_collation() and sqlite3_create_collation_v2() +** and a UTF-16 string for sqlite3_create_collation16(). {F16603} In all cases +** the name is passed as the second function argument. +** +** {F16604} +** The third argument may be one of the constants [SQLITE_UTF8], +** [SQLITE_UTF16LE] or [SQLITE_UTF16BE], indicating that the user-supplied +** routine expects to be passed pointers to strings encoded using UTF-8, +** UTF-16 little-endian or UTF-16 big-endian respectively. {F16605} The +** third argument might also be [SQLITE_UTF16_ALIGNED] to indicate that +** the routine expects pointers to 16-bit word aligned strings +** of UTF16 in the native byte order of the host computer. +** +** {F16607} +** A pointer to the user supplied routine must be passed as the fifth +** argument. {F16609} If it is NULL, this is the same as deleting the collation +** sequence (so that SQLite cannot call it anymore). +** {F16611} Each time the application +** supplied function is invoked, it is passed a copy of the void* passed as +** the fourth argument to sqlite3_create_collation() or +** sqlite3_create_collation16() as its first parameter. +** +** {F16612} +** The remaining arguments to the application-supplied routine are two strings, +** each represented by a [length, data] pair and encoded in the encoding +** that was passed as the third argument when the collation sequence was +** registered. {END} The application defined collation routine should +** return negative, zero or positive if +** the first string is less than, equal to, or greater than the second +** string. i.e. (STRING1 - STRING2). +** +** {F16615} +** The sqlite3_create_collation_v2() works like sqlite3_create_collation() +** excapt that it takes an extra argument which is a destructor for +** the collation. {F16617} The destructor is called when the collation is +** destroyed and is passed a copy of the fourth parameter void* pointer +** of the sqlite3_create_collation_v2(). +** {F16618} Collations are destroyed when +** they are overridden by later calls to the collation creation functions +** or when the [sqlite3*] database handle is closed using [sqlite3_close()]. +*/ +/*IMPORT_C*/ int sqlite3_create_collation( + sqlite3*, + const char *zName, + int eTextRep, + void*, + int(*xCompare)(void*,int,const void*,int,const void*) +); +/*IMPORT_C*/ int sqlite3_create_collation_v2( + sqlite3*, + const char *zName, + int eTextRep, + void*, + int(*xCompare)(void*,int,const void*,int,const void*), + void(*xDestroy)(void*) +); +/*IMPORT_C*/ int sqlite3_create_collation16( + sqlite3*, + const char *zName, + int eTextRep, + void*, + int(*xCompare)(void*,int,const void*,int,const void*) +); + +/* +** CAPI3REF: Collation Needed Callbacks {F16700} +** +** {F16701} +** To avoid having to register all collation sequences before a database +** can be used, a single callback function may be registered with the +** database handle to be called whenever an undefined collation sequence is +** required. +** +** {F16702} +** If the function is registered using the sqlite3_collation_needed() API, +** then it is passed the names of undefined collation sequences as strings +** encoded in UTF-8. {F16703} If sqlite3_collation_needed16() is used, the names +** are passed as UTF-16 in machine native byte order. {F16704} A call to either +** function replaces any existing callback. +** +** {F16705} When the callback is invoked, the first argument passed is a copy +** of the second argument to sqlite3_collation_needed() or +** sqlite3_collation_needed16(). {F16706} The second argument is the database +** handle. {F16707} The third argument is one of [SQLITE_UTF8], +** [SQLITE_UTF16BE], or [SQLITE_UTF16LE], indicating the most +** desirable form of the collation sequence function required. +** {F16708} The fourth parameter is the name of the +** required collation sequence. {END} +** +** The callback function should register the desired collation using +** [sqlite3_create_collation()], [sqlite3_create_collation16()], or +** [sqlite3_create_collation_v2()]. +*/ +/*IMPORT_C*/ int sqlite3_collation_needed( + sqlite3*, + void*, + void(*)(void*,sqlite3*,int eTextRep,const char*) +); +/*IMPORT_C*/ int sqlite3_collation_needed16( + sqlite3*, + void*, + void(*)(void*,sqlite3*,int eTextRep,const void*) +); + +/* +** Specify the key for an encrypted database. This routine should be +** called right after sqlite3_open(). +** +** The code to implement this API is not available in the public release +** of SQLite. +*/ +/*IMPORT_C*/ int sqlite3_key( + sqlite3 *db, /* Database to be rekeyed */ + const void *pKey, int nKey /* The key */ +); + +/* +** Change the key on an open database. If the current database is not +** encrypted, this routine will encrypt it. If pNew==0 or nNew==0, the +** database is decrypted. +** +** The code to implement this API is not available in the public release +** of SQLite. +*/ +/*IMPORT_C*/ int sqlite3_rekey( + sqlite3 *db, /* Database to be rekeyed */ + const void *pKey, int nKey /* The new key */ +); + +/* +** CAPI3REF: Suspend Execution For A Short Time {F10530} +** +** {F10531} The sqlite3_sleep() function +** causes the current thread to suspend execution +** for at least a number of milliseconds specified in its parameter. +** +** {F10532} If the operating system does not support sleep requests with +** millisecond time resolution, then the time will be rounded up to +** the nearest second. {F10533} The number of milliseconds of sleep actually +** requested from the operating system is returned. +** +** {F10534} SQLite implements this interface by calling the xSleep() +** method of the default [sqlite3_vfs] object. {END} +*/ +/*IMPORT_C*/ int sqlite3_sleep(int); + +/* +** CAPI3REF: Name Of The Folder Holding Temporary Files {F10310} +** +** If this global variable is made to point to a string which is +** the name of a folder (a.ka. directory), then all temporary files +** created by SQLite will be placed in that directory. If this variable +** is NULL pointer, then SQLite does a search for an appropriate temporary +** file directory. +** +** It is not safe to modify this variable once a database connection +** has been opened. It is intended that this variable be set once +** as part of process initialization and before any SQLite interface +** routines have been call and remain unchanged thereafter. +*/ +SQLITE_EXTERN char *sqlite3_temp_directory; + +/* +** CAPI3REF: Test To See If The Database Is In Auto-Commit Mode {F12930} +** +** {F12931} The sqlite3_get_autocommit() interfaces returns non-zero or +** zero if the given database connection is or is not in autocommit mode, +** respectively. {F12932} Autocommit mode is on +** by default. {F12933} Autocommit mode is disabled by a BEGIN statement. +** {F12934} Autocommit mode is reenabled by a COMMIT or ROLLBACK. {END} +** +** If certain kinds of errors occur on a statement within a multi-statement +** transactions (errors including [SQLITE_FULL], [SQLITE_IOERR], +** [SQLITE_NOMEM], [SQLITE_BUSY], and [SQLITE_INTERRUPT]) then the +** transaction might be rolled back automatically. {F12935} The only way to +** find out if SQLite automatically rolled back the transaction after +** an error is to use this function. {END} +** +** {U12936} If another thread changes the autocommit status of the database +** connection while this routine is running, then the return value +** is undefined. {END} +*/ +/*IMPORT_C*/ int sqlite3_get_autocommit(sqlite3*); + +/* +** CAPI3REF: Find The Database Handle Of A Prepared Statement {F13120} +** +** {F13121} The sqlite3_db_handle interface +** returns the [sqlite3*] database handle to which a +** [sqlite3_stmt | prepared statement] belongs. +** {F13122} the database handle returned by sqlite3_db_handle +** is the same database handle that was +** the first argument to the [sqlite3_prepare_v2()] or its variants +** that was used to create the statement in the first place. +*/ +/*IMPORT_C*/ sqlite3 *sqlite3_db_handle(sqlite3_stmt*); + + +/* +** CAPI3REF: Commit And Rollback Notification Callbacks {F12950} +** +** {F12951} The sqlite3_commit_hook() interface registers a callback +** function to be invoked whenever a transaction is committed. +** {F12952} Any callback set by a previous call to sqlite3_commit_hook() +** for the same database connection is overridden. +** {F12953} The sqlite3_rollback_hook() interface registers a callback +** function to be invoked whenever a transaction is committed. +** {F12954} Any callback set by a previous call to sqlite3_commit_hook() +** for the same database connection is overridden. +** {F12956} The pArg argument is passed through +** to the callback. {F12957} If the callback on a commit hook function +** returns non-zero, then the commit is converted into a rollback. +** +** {F12958} If another function was previously registered, its +** pArg value is returned. Otherwise NULL is returned. +** +** {F12959} Registering a NULL function disables the callback. +** +** {F12961} For the purposes of this API, a transaction is said to have been +** rolled back if an explicit "ROLLBACK" statement is executed, or +** an error or constraint causes an implicit rollback to occur. +** {F12962} The rollback callback is not invoked if a transaction is +** automatically rolled back because the database connection is closed. +** {F12964} The rollback callback is not invoked if a transaction is +** rolled back because a commit callback returned non-zero. +** Check on this {END} +** +** These are experimental interfaces and are subject to change. +*/ +/*IMPORT_C*/ void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*); +/*IMPORT_C*/ void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*); + +/* +** CAPI3REF: Data Change Notification Callbacks {F12970} +** +** {F12971} The sqlite3_update_hook() interface +** registers a callback function with the database connection identified by the +** first argument to be invoked whenever a row is updated, inserted or deleted. +** {F12972} Any callback set by a previous call to this function for the same +** database connection is overridden. +** +** {F12974} The second argument is a pointer to the function to invoke when a +** row is updated, inserted or deleted. +** {F12976} The first argument to the callback is +** a copy of the third argument to sqlite3_update_hook(). +** {F12977} The second callback +** argument is one of [SQLITE_INSERT], [SQLITE_DELETE] or [SQLITE_UPDATE], +** depending on the operation that caused the callback to be invoked. +** {F12978} The third and +** fourth arguments to the callback contain pointers to the database and +** table name containing the affected row. +** {F12979} The final callback parameter is +** the rowid of the row. +** {F12981} In the case of an update, this is the rowid after +** the update takes place. +** +** {F12983} The update hook is not invoked when internal system tables are +** modified (i.e. sqlite_master and sqlite_sequence). +** +** {F12984} If another function was previously registered, its pArg value +** is returned. {F12985} Otherwise NULL is returned. +*/ +/*IMPORT_C*/ void *sqlite3_update_hook( + sqlite3*, + void(*)(void *,int ,char const *,char const *,sqlite3_int64), + void* +); + +/* +** CAPI3REF: Enable Or Disable Shared Pager Cache {F10330} +** +** {F10331} +** This routine enables or disables the sharing of the database cache +** and schema data structures between connections to the same database. +** {F10332} +** Sharing is enabled if the argument is true and disabled if the argument +** is false. +** +** {F10333} Cache sharing is enabled and disabled +** for an entire process. {END} This is a change as of SQLite version 3.5.0. +** In prior versions of SQLite, sharing was +** enabled or disabled for each thread separately. +** +** {F10334} +** The cache sharing mode set by this interface effects all subsequent +** calls to [sqlite3_open()], [sqlite3_open_v2()], and [sqlite3_open16()]. +** {F10335} Existing database connections continue use the sharing mode +** that was in effect at the time they were opened. {END} +** +** Virtual tables cannot be used with a shared cache. {F10336} When shared +** cache is enabled, the [sqlite3_create_module()] API used to register +** virtual tables will always return an error. {END} +** +** {F10337} This routine returns [SQLITE_OK] if shared cache was +** enabled or disabled successfully. {F10338} An [SQLITE_ERROR | error code] +** is returned otherwise. {END} +** +** {F10339} Shared cache is disabled by default. {END} But this might change in +** future releases of SQLite. Applications that care about shared +** cache setting should set it explicitly. +*/ +/*IMPORT_C*/ int sqlite3_enable_shared_cache(int); + +/* +** CAPI3REF: Attempt To Free Heap Memory {F17340} +** +** {F17341} The sqlite3_release_memory() interface attempts to +** free N bytes of heap memory by deallocating non-essential memory +** allocations held by the database labrary. {END} Memory used +** to cache database pages to improve performance is an example of +** non-essential memory. {F16342} sqlite3_release_memory() returns +** the number of bytes actually freed, which might be more or less +** than the amount requested. +*/ +/*IMPORT_C*/ int sqlite3_release_memory(int); + +/* +** CAPI3REF: Impose A Limit On Heap Size {F17350} +** +** {F16351} The sqlite3_soft_heap_limit() interface +** places a "soft" limit on the amount of heap memory that may be allocated +** by SQLite. {F16352} If an internal allocation is requested +** that would exceed the soft heap limit, [sqlite3_release_memory()] is +** invoked one or more times to free up some space before the allocation +** is made. {END} +** +** {F16353} The limit is called "soft", because if +** [sqlite3_release_memory()] cannot +** free sufficient memory to prevent the limit from being exceeded, +** the memory is allocated anyway and the current operation proceeds. +** +** {F16354} +** A negative or zero value for N means that there is no soft heap limit and +** [sqlite3_release_memory()] will only be called when memory is exhausted. +** {F16355} The default value for the soft heap limit is zero. +** +** SQLite makes a best effort to honor the soft heap limit. +** {F16356} But if the soft heap limit cannot honored, execution will +** continue without error or notification. {END} This is why the limit is +** called a "soft" limit. It is advisory only. +** +** Prior to SQLite version 3.5.0, this routine only constrained the memory +** allocated by a single thread - the same thread in which this routine +** runs. Beginning with SQLite version 3.5.0, the soft heap limit is +** applied to all threads. {F16357} The value specified for the soft heap limit +** is an upper bound on the total memory allocation for all threads. {END} In +** version 3.5.0 there is no mechanism for limiting the heap usage for +** individual threads. +*/ +/*IMPORT_C*/ void sqlite3_soft_heap_limit(int); + +/* +** CAPI3REF: Extract Metadata About A Column Of A Table {F12850} +** +** This routine +** returns meta-data about a specific column of a specific database +** table accessible using the connection handle passed as the first function +** argument. +** +** The column is identified by the second, third and fourth parameters to +** this function. The second parameter is either the name of the database +** (i.e. "main", "temp" or an attached database) containing the specified +** table or NULL. If it is NULL, then all attached databases are searched +** for the table using the same algorithm as the database engine uses to +** resolve unqualified table references. +** +** The third and fourth parameters to this function are the table and column +** name of the desired column, respectively. Neither of these parameters +** may be NULL. +** +** Meta information is returned by writing to the memory locations passed as +** the 5th and subsequent parameters to this function. Any of these +** arguments may be NULL, in which case the corresponding element of meta +** information is ommitted. +** +** 
+** Parameter     Output Type      Description
+** -----------------------------------
+**
+**   5th         const char*      Data type
+**   6th         const char*      Name of the default collation sequence 
+**   7th         int              True if the column has a NOT NULL constraint
+**   8th         int              True if the column is part of the PRIMARY KEY
+**   9th         int              True if the column is AUTOINCREMENT
+**
+** +** +** The memory pointed to by the character pointers returned for the +** declaration type and collation sequence is valid only until the next +** call to any sqlite API function. +** +** If the specified table is actually a view, then an error is returned. +** +** If the specified column is "rowid", "oid" or "_rowid_" and an +** INTEGER PRIMARY KEY column has been explicitly declared, then the output +** parameters are set for the explicitly declared column. If there is no +** explicitly declared IPK column, then the output parameters are set as +** follows: +** +** 
+**     data type: "INTEGER"
+**     collation sequence: "BINARY"
+**     not null: 0
+**     primary key: 1
+**     auto increment: 0
+**
+** +** This function may load one or more schemas from database files. If an +** error occurs during this process, or if the requested table or column +** cannot be found, an SQLITE error code is returned and an error message +** left in the database handle (to be retrieved using sqlite3_errmsg()). +** +** This API is only available if the library was compiled with the +** SQLITE_ENABLE_COLUMN_METADATA preprocessor symbol defined. +*/ +/*IMPORT_C*/ int sqlite3_table_column_metadata( + sqlite3 *db, /* Connection handle */ + const char *zDbName, /* Database name or NULL */ + const char *zTableName, /* Table name */ + const char *zColumnName, /* Column name */ + char const **pzDataType, /* OUTPUT: Declared data type */ + char const **pzCollSeq, /* OUTPUT: Collation sequence name */ + int *pNotNull, /* OUTPUT: True if NOT NULL constraint exists */ + int *pPrimaryKey, /* OUTPUT: True if column part of PK */ + int *pAutoinc /* OUTPUT: True if column is auto-increment */ +); + +/* +** CAPI3REF: Load An Extension {F12600} +** +** {F12601} The sqlite3_load_extension() interface +** attempts to load an SQLite extension library contained in the file +** zFile. {F12602} The entry point is zProc. {F12603} zProc may be 0 +** in which case the name of the entry point defaults +** to "sqlite3_extension_init". +** +** {F12604} The sqlite3_load_extension() interface shall +** return [SQLITE_OK] on success and [SQLITE_ERROR] if something goes wrong. +** +** {F12605} +** If an error occurs and pzErrMsg is not 0, then the +** sqlite3_load_extension() interface shall attempt to fill *pzErrMsg with +** error message text stored in memory obtained from [sqlite3_malloc()]. +** {END} The calling function should free this memory +** by calling [sqlite3_free()]. +** +** {F12606} +** Extension loading must be enabled using [sqlite3_enable_load_extension()] +** prior to calling this API or an error will be returned. +*/ +/*IMPORT_C*/ int sqlite3_load_extension( + sqlite3 *db, /* Load the extension into this database connection */ + const char *zFile, /* Name of the shared library containing extension */ + const char *zProc, /* Entry point. Derived from zFile if 0 */ + char **pzErrMsg /* Put error message here if not 0 */ +); + +/* +** CAPI3REF: Enable Or Disable Extension Loading {F12620} +** +** So as not to open security holes in older applications that are +** unprepared to deal with extension loading, and as a means of disabling +** extension loading while evaluating user-entered SQL, the following +** API is provided to turn the [sqlite3_load_extension()] mechanism on and +** off. {F12622} It is off by default. {END} See ticket #1863. +** +** {F12621} Call the sqlite3_enable_load_extension() routine +** with onoff==1 to turn extension loading on +** and call it with onoff==0 to turn it back off again. {END} +*/ +/*IMPORT_C*/ int sqlite3_enable_load_extension(sqlite3 *db, int onoff); + +/* +** CAPI3REF: Make Arrangements To Automatically Load An Extension {F12640} +** +** {F12641} This function +** registers an extension entry point that is automatically invoked +** whenever a new database connection is opened using +** [sqlite3_open()], [sqlite3_open16()], or [sqlite3_open_v2()]. {END} +** +** This API can be invoked at program startup in order to register +** one or more statically linked extensions that will be available +** to all new database connections. +** +** {F12642} Duplicate extensions are detected so calling this routine multiple +** times with the same extension is harmless. +** +** {F12643} This routine stores a pointer to the extension in an array +** that is obtained from sqlite_malloc(). {END} If you run a memory leak +** checker on your program and it reports a leak because of this +** array, then invoke [sqlite3_reset_auto_extension()] prior +** to shutdown to free the memory. +** +** {F12644} Automatic extensions apply across all threads. {END} +** +** This interface is experimental and is subject to change or +** removal in future releases of SQLite. +*/ +/*IMPORT_C*/ int sqlite3_auto_extension(void *xEntryPoint); + + +/* +** CAPI3REF: Reset Automatic Extension Loading {F12660} +** +** {F12661} This function disables all previously registered +** automatic extensions. {END} This +** routine undoes the effect of all prior [sqlite3_automatic_extension()] +** calls. +** +** {F12662} This call disabled automatic extensions in all threads. {END} +** +** This interface is experimental and is subject to change or +** removal in future releases of SQLite. +*/ +/*IMPORT_C*/ void sqlite3_reset_auto_extension(void); + + +/* +****** EXPERIMENTAL - subject to change without notice ************** +** +** The interface to the virtual-table mechanism is currently considered +** to be experimental. The interface might change in incompatible ways. +** If this is a problem for you, do not use the interface at this time. +** +** When the virtual-table mechanism stablizes, we will declare the +** interface fixed, support it indefinitely, and remove this comment. +*/ + +/* +** Structures used by the virtual table interface +*/ +typedef struct sqlite3_vtab sqlite3_vtab; +typedef struct sqlite3_index_info sqlite3_index_info; +typedef struct sqlite3_vtab_cursor sqlite3_vtab_cursor; +typedef struct sqlite3_module sqlite3_module; + +/* +** A module is a class of virtual tables. Each module is defined +** by an instance of the following structure. This structure consists +** mostly of methods for the module. +*/ +struct sqlite3_module { + int iVersion; + int (*xCreate)(sqlite3*, void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVTab, char**); + int (*xConnect)(sqlite3*, void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVTab, char**); + int (*xBestIndex)(sqlite3_vtab *pVTab, sqlite3_index_info*); + int (*xDisconnect)(sqlite3_vtab *pVTab); + int (*xDestroy)(sqlite3_vtab *pVTab); + int (*xOpen)(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor); + int (*xClose)(sqlite3_vtab_cursor*); + int (*xFilter)(sqlite3_vtab_cursor*, int idxNum, const char *idxStr, + int argc, sqlite3_value **argv); + int (*xNext)(sqlite3_vtab_cursor*); + int (*xEof)(sqlite3_vtab_cursor*); + int (*xColumn)(sqlite3_vtab_cursor*, sqlite3_context*, int); + int (*xRowid)(sqlite3_vtab_cursor*, sqlite3_int64 *pRowid); + int (*xUpdate)(sqlite3_vtab *, int, sqlite3_value **, sqlite3_int64 *); + int (*xBegin)(sqlite3_vtab *pVTab); + int (*xSync)(sqlite3_vtab *pVTab); + int (*xCommit)(sqlite3_vtab *pVTab); + int (*xRollback)(sqlite3_vtab *pVTab); + int (*xFindFunction)(sqlite3_vtab *pVtab, int nArg, const char *zName, + void (**pxFunc)(sqlite3_context*,int,sqlite3_value**), + void **ppArg); + + int (*xRename)(sqlite3_vtab *pVtab, const char *zNew); +}; + +/* +** The sqlite3_index_info structure and its substructures is used to +** pass information into and receive the reply from the xBestIndex +** method of an sqlite3_module. The fields under **Inputs** are the +** inputs to xBestIndex and are read-only. xBestIndex inserts its +** results into the **Outputs** fields. +** +** The aConstraint[] array records WHERE clause constraints of the +** form: +** +** column OP expr +** +** Where OP is =, <, <=, >, or >=. +** The particular operator is stored +** in aConstraint[].op. The index of the column is stored in +** aConstraint[].iColumn. aConstraint[].usable is TRUE if the +** expr on the right-hand side can be evaluated (and thus the constraint +** is usable) and false if it cannot. +** +** The optimizer automatically inverts terms of the form "expr OP column" +** and makes other simplifications to the WHERE clause in an attempt to +** get as many WHERE clause terms into the form shown above as possible. +** The aConstraint[] array only reports WHERE clause terms in the correct +** form that refer to the particular virtual table being queried. +** +** Information about the ORDER BY clause is stored in aOrderBy[]. +** Each term of aOrderBy records a column of the ORDER BY clause. +** +** The xBestIndex method must fill aConstraintUsage[] with information +** about what parameters to pass to xFilter. If argvIndex>0 then +** the right-hand side of the corresponding aConstraint[] is evaluated +** and becomes the argvIndex-th entry in argv. If aConstraintUsage[].omit +** is true, then the constraint is assumed to be fully handled by the +** virtual table and is not checked again by SQLite. +** +** The idxNum and idxPtr values are recorded and passed into xFilter. +** sqlite3_free() is used to free idxPtr if needToFreeIdxPtr is true. +** +** The orderByConsumed means that output from xFilter will occur in +** the correct order to satisfy the ORDER BY clause so that no separate +** sorting step is required. +** +** The estimatedCost value is an estimate of the cost of doing the +** particular lookup. A full scan of a table with N entries should have +** a cost of N. A binary search of a table of N entries should have a +** cost of approximately log(N). +*/ +struct sqlite3_index_info { + /* Inputs */ + int nConstraint; /* Number of entries in aConstraint */ + struct sqlite3_index_constraint { + int iColumn; /* Column on left-hand side of constraint */ + unsigned char op; /* Constraint operator */ + unsigned char usable; /* True if this constraint is usable */ + int iTermOffset; /* Used internally - xBestIndex should ignore */ + } *aConstraint; /* Table of WHERE clause constraints */ + int nOrderBy; /* Number of terms in the ORDER BY clause */ + struct sqlite3_index_orderby { + int iColumn; /* Column number */ + unsigned char desc; /* True for DESC. False for ASC. */ + } *aOrderBy; /* The ORDER BY clause */ + + /* Outputs */ + struct sqlite3_index_constraint_usage { + int argvIndex; /* if >0, constraint is part of argv to xFilter */ + unsigned char omit; /* Do not code a test for this constraint */ + } *aConstraintUsage; + int idxNum; /* Number used to identify the index */ + char *idxStr; /* String, possibly obtained from sqlite3_malloc */ + int needToFreeIdxStr; /* Free idxStr using sqlite3_free() if true */ + int orderByConsumed; /* True if output is already ordered */ + double estimatedCost; /* Estimated cost of using this index */ +}; +#define SQLITE_INDEX_CONSTRAINT_EQ 2 +#define SQLITE_INDEX_CONSTRAINT_GT 4 +#define SQLITE_INDEX_CONSTRAINT_LE 8 +#define SQLITE_INDEX_CONSTRAINT_LT 16 +#define SQLITE_INDEX_CONSTRAINT_GE 32 +#define SQLITE_INDEX_CONSTRAINT_MATCH 64 + +/* +** This routine is used to register a new module name with an SQLite +** connection. Module names must be registered before creating new +** virtual tables on the module, or before using preexisting virtual +** tables of the module. +*/ +/*IMPORT_C*/ int sqlite3_create_module( + sqlite3 *db, /* SQLite connection to register module with */ + const char *zName, /* Name of the module */ + const sqlite3_module *, /* Methods for the module */ + void * /* Client data for xCreate/xConnect */ +); + +/* +** This routine is identical to the sqlite3_create_module() method above, +** except that it allows a destructor function to be specified. It is +** even more experimental than the rest of the virtual tables API. +*/ +/*IMPORT_C*/ int sqlite3_create_module_v2( + sqlite3 *db, /* SQLite connection to register module with */ + const char *zName, /* Name of the module */ + const sqlite3_module *, /* Methods for the module */ + void *, /* Client data for xCreate/xConnect */ + void(*xDestroy)(void*) /* Module destructor function */ +); + +/* +** Every module implementation uses a subclass of the following structure +** to describe a particular instance of the module. Each subclass will +** be tailored to the specific needs of the module implementation. The +** purpose of this superclass is to define certain fields that are common +** to all module implementations. +** +** Virtual tables methods can set an error message by assigning a +** string obtained from sqlite3_mprintf() to zErrMsg. The method should +** take care that any prior string is freed by a call to sqlite3_free() +** prior to assigning a new string to zErrMsg. After the error message +** is delivered up to the client application, the string will be automatically +** freed by sqlite3_free() and the zErrMsg field will be zeroed. Note +** that sqlite3_mprintf() and sqlite3_free() are used on the zErrMsg field +** since virtual tables are commonly implemented in loadable extensions which +** do not have access to sqlite3MPrintf() or sqlite3Free(). +*/ +struct sqlite3_vtab { + const sqlite3_module *pModule; /* The module for this virtual table */ + int nRef; /* Used internally */ + char *zErrMsg; /* Error message from sqlite3_mprintf() */ + /* Virtual table implementations will typically add additional fields */ +}; + +/* Every module implementation uses a subclass of the following structure +** to describe cursors that point into the virtual table and are used +** to loop through the virtual table. Cursors are created using the +** xOpen method of the module. Each module implementation will define +** the content of a cursor structure to suit its own needs. +** +** This superclass exists in order to define fields of the cursor that +** are common to all implementations. +*/ +struct sqlite3_vtab_cursor { + sqlite3_vtab *pVtab; /* Virtual table of this cursor */ + /* Virtual table implementations will typically add additional fields */ +}; + +/* +** The xCreate and xConnect methods of a module use the following API +** to declare the format (the names and datatypes of the columns) of +** the virtual tables they implement. +*/ +/*IMPORT_C*/ int sqlite3_declare_vtab(sqlite3*, const char *zCreateTable); + +/* +** Virtual tables can provide alternative implementations of functions +** using the xFindFunction method. But global versions of those functions +** must exist in order to be overloaded. +** +** This API makes sure a global version of a function with a particular +** name and number of parameters exists. If no such function exists +** before this API is called, a new function is created. The implementation +** of the new function always causes an exception to be thrown. So +** the new function is not good for anything by itself. Its only +** purpose is to be a place-holder function that can be overloaded +** by virtual tables. +** +** This API should be considered part of the virtual table interface, +** which is experimental and subject to change. +*/ +/*IMPORT_C*/ int sqlite3_overload_function(sqlite3*, const char *zFuncName, int nArg); + +/* +** The interface to the virtual-table mechanism defined above (back up +** to a comment remarkably similar to this one) is currently considered +** to be experimental. The interface might change in incompatible ways. +** If this is a problem for you, do not use the interface at this time. +** +** When the virtual-table mechanism stabilizes, we will declare the +** interface fixed, support it indefinitely, and remove this comment. +** +****** EXPERIMENTAL - subject to change without notice ************** +*/ + +/* +** CAPI3REF: A Handle To An Open BLOB {F17800} +** +** An instance of the following opaque structure is used to +** represent an blob-handle. A blob-handle is created by +** [sqlite3_blob_open()] and destroyed by [sqlite3_blob_close()]. +** The [sqlite3_blob_read()] and [sqlite3_blob_write()] interfaces +** can be used to read or write small subsections of the blob. +** The [sqlite3_blob_bytes()] interface returns the size of the +** blob in bytes. +*/ +typedef struct sqlite3_blob sqlite3_blob; + +/* +** CAPI3REF: Open A BLOB For Incremental I/O {F17810} +** +** {F17811} This interfaces opens a handle to the blob located +** in row iRow,, column zColumn, table zTable in database zDb; +** in other words, the same blob that would be selected by: +** +** 
+**     SELECT zColumn FROM zDb.zTable WHERE rowid = iRow;
+**
{END} +** +** {F17812} If the flags parameter is non-zero, the blob is opened for +** read and write access. If it is zero, the blob is opened for read +** access. {END} +** +** {F17813} On success, [SQLITE_OK] is returned and the new +** [sqlite3_blob | blob handle] is written to *ppBlob. +** {F17814} Otherwise an error code is returned and +** any value written to *ppBlob should not be used by the caller. +** {F17815} This function sets the database-handle error code and message +** accessible via [sqlite3_errcode()] and [sqlite3_errmsg()]. +** We should go through and mark all interfaces that behave this +** way with a similar statement +*/ +/*IMPORT_C*/ int sqlite3_blob_open( + sqlite3*, + const char *zDb, + const char *zTable, + const char *zColumn, + sqlite3_int64 iRow, + int flags, + sqlite3_blob **ppBlob +); + +/* +** CAPI3REF: Close A BLOB Handle {F17830} +** +** Close an open [sqlite3_blob | blob handle]. +** +** {F17831} Closing a BLOB shall cause the current transaction to commit +** if there are no other BLOBs, no pending prepared statements, and the +** database connection is in autocommit mode. +** {F17832} If any writes were made to the BLOB, they might be held in cache +** until the close operation if they will fit. {END} +** Closing the BLOB often forces the changes +** out to disk and so if any I/O errors occur, they will likely occur +** at the time when the BLOB is closed. {F17833} Any errors that occur during +** closing are reported as a non-zero return value. +** +** {F17839} The BLOB is closed unconditionally. Even if this routine returns +** an error code, the BLOB is still closed. +*/ +/*IMPORT_C*/ int sqlite3_blob_close(sqlite3_blob *); + +/* +** CAPI3REF: Return The Size Of An Open BLOB {F17805} +** +** {F16806} Return the size in bytes of the blob accessible via the open +** [sqlite3_blob | blob-handle] passed as an argument. +*/ +/*IMPORT_C*/ int sqlite3_blob_bytes(sqlite3_blob *); + +/* +** CAPI3REF: Read Data From A BLOB Incrementally {F17850} +** +** This function is used to read data from an open +** [sqlite3_blob | blob-handle] into a caller supplied buffer. +** {F17851} n bytes of data are copied into buffer +** z from the open blob, starting at offset iOffset. +** +** {F17852} If offset iOffset is less than n bytes from the end of the blob, +** [SQLITE_ERROR] is returned and no data is read. {F17853} If n is +** less than zero [SQLITE_ERROR] is returned and no data is read. +** +** {F17854} On success, SQLITE_OK is returned. Otherwise, an +** [SQLITE_ERROR | SQLite error code] or an +** [SQLITE_IOERR_READ | extended error code] is returned. +*/ +/*IMPORT_C*/ int sqlite3_blob_read(sqlite3_blob *, void *z, int n, int iOffset); + +/* +** CAPI3REF: Write Data Into A BLOB Incrementally {F17870} +** +** This function is used to write data into an open +** [sqlite3_blob | blob-handle] from a user supplied buffer. +** {F17871} n bytes of data are copied from the buffer +** pointed to by z into the open blob, starting at offset iOffset. +** +** {F17872} If the [sqlite3_blob | blob-handle] passed as the first argument +** was not opened for writing (the flags parameter to [sqlite3_blob_open()] +*** was zero), this function returns [SQLITE_READONLY]. +** +** {F17873} This function may only modify the contents of the blob; it is +** not possible to increase the size of a blob using this API. +** {F17874} If offset iOffset is less than n bytes from the end of the blob, +** [SQLITE_ERROR] is returned and no data is written. {F17875} If n is +** less than zero [SQLITE_ERROR] is returned and no data is written. +** +** {F17876} On success, SQLITE_OK is returned. Otherwise, an +** [SQLITE_ERROR | SQLite error code] or an +** [SQLITE_IOERR_READ | extended error code] is returned. +*/ +/*IMPORT_C*/ int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset); + +/* +** CAPI3REF: Virtual File System Objects {F11200} +** +** A virtual filesystem (VFS) is an [sqlite3_vfs] object +** that SQLite uses to interact +** with the underlying operating system. Most builds come with a +** single default VFS that is appropriate for the host computer. +** New VFSes can be registered and existing VFSes can be unregistered. +** The following interfaces are provided. +** +** {F11201} The sqlite3_vfs_find() interface returns a pointer to +** a VFS given its name. {F11202} Names are case sensitive. +** {F11203} Names are zero-terminated UTF-8 strings. +** {F11204} If there is no match, a NULL +** pointer is returned. {F11205} If zVfsName is NULL then the default +** VFS is returned. {END} +** +** {F11210} New VFSes are registered with sqlite3_vfs_register(). +** {F11211} Each new VFS becomes the default VFS if the makeDflt flag is set. +** {F11212} The same VFS can be registered multiple times without injury. +** {F11213} To make an existing VFS into the default VFS, register it again +** with the makeDflt flag set. {U11214} If two different VFSes with the +** same name are registered, the behavior is undefined. {U11215} If a +** VFS is registered with a name that is NULL or an empty string, +** then the behavior is undefined. +** +** {F11220} Unregister a VFS with the sqlite3_vfs_unregister() interface. +** {F11221} If the default VFS is unregistered, another VFS is chosen as +** the default. The choice for the new VFS is arbitrary. +*/ +/*IMPORT_C*/ sqlite3_vfs *sqlite3_vfs_find(const char *zVfsName); +/*IMPORT_C*/ int sqlite3_vfs_register(sqlite3_vfs*, int makeDflt); +/*IMPORT_C*/ int sqlite3_vfs_unregister(sqlite3_vfs*); + +/* +** CAPI3REF: Mutexes {F17000} +** +** The SQLite core uses these routines for thread +** synchronization. Though they are intended for internal +** use by SQLite, code that links against SQLite is +** permitted to use any of these routines. +** +** The SQLite source code contains multiple implementations +** of these mutex routines. An appropriate implementation +** is selected automatically at compile-time. The following +** implementations are available in the SQLite core: +** +**
    +**
  • SQLITE_MUTEX_OS2 +**
  • SQLITE_MUTEX_PTHREAD +**
  • SQLITE_MUTEX_W32 +**
  • SQLITE_MUTEX_NOOP +**
+** +** The SQLITE_MUTEX_NOOP implementation is a set of routines +** that does no real locking and is appropriate for use in +** a single-threaded application. The SQLITE_MUTEX_OS2, +** SQLITE_MUTEX_PTHREAD, and SQLITE_MUTEX_W32 implementations +** are appropriate for use on os/2, unix, and windows. +** +** If SQLite is compiled with the SQLITE_MUTEX_APPDEF preprocessor +** macro defined (with "-DSQLITE_MUTEX_APPDEF=1"), then no mutex +** implementation is included with the library. The +** mutex interface routines defined here become external +** references in the SQLite library for which implementations +** must be provided by the application. This facility allows an +** application that links against SQLite to provide its own mutex +** implementation without having to modify the SQLite core. +** +** {F17011} The sqlite3_mutex_alloc() routine allocates a new +** mutex and returns a pointer to it. {F17012} If it returns NULL +** that means that a mutex could not be allocated. {F17013} SQLite +** will unwind its stack and return an error. {F17014} The argument +** to sqlite3_mutex_alloc() is one of these integer constants: +** +**
    +**
  • SQLITE_MUTEX_FAST +**
  • SQLITE_MUTEX_RECURSIVE +**
  • SQLITE_MUTEX_STATIC_MASTER +**
  • SQLITE_MUTEX_STATIC_MEM +**
  • SQLITE_MUTEX_STATIC_MEM2 +**
  • SQLITE_MUTEX_STATIC_PRNG +**
  • SQLITE_MUTEX_STATIC_LRU +**
{END} +** +** {F17015} The first two constants cause sqlite3_mutex_alloc() to create +** a new mutex. The new mutex is recursive when SQLITE_MUTEX_RECURSIVE +** is used but not necessarily so when SQLITE_MUTEX_FAST is used. {END} +** The mutex implementation does not need to make a distinction +** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does +** not want to. {F17016} But SQLite will only request a recursive mutex in +** cases where it really needs one. {END} If a faster non-recursive mutex +** implementation is available on the host platform, the mutex subsystem +** might return such a mutex in response to SQLITE_MUTEX_FAST. +** +** {F17017} The other allowed parameters to sqlite3_mutex_alloc() each return +** a pointer to a static preexisting mutex. {END} Four static mutexes are +** used by the current version of SQLite. Future versions of SQLite +** may add additional static mutexes. Static mutexes are for internal +** use by SQLite only. Applications that use SQLite mutexes should +** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or +** SQLITE_MUTEX_RECURSIVE. +** +** {F17018} Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST +** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc() +** returns a different mutex on every call. {F17034} But for the static +** mutex types, the same mutex is returned on every call that has +** the same type number. {END} +** +** {F17019} The sqlite3_mutex_free() routine deallocates a previously +** allocated dynamic mutex. {F17020} SQLite is careful to deallocate every +** dynamic mutex that it allocates. {U17021} The dynamic mutexes must not be in +** use when they are deallocated. {U17022} Attempting to deallocate a static +** mutex results in undefined behavior. {F17023} SQLite never deallocates +** a static mutex. {END} +** +** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt +** to enter a mutex. {F17024} If another thread is already within the mutex, +** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return +** SQLITE_BUSY. {F17025} The sqlite3_mutex_try() interface returns SQLITE_OK +** upon successful entry. {F17026} Mutexes created using +** SQLITE_MUTEX_RECURSIVE can be entered multiple times by the same thread. +** {F17027} In such cases the, +** mutex must be exited an equal number of times before another thread +** can enter. {U17028} If the same thread tries to enter any other +** kind of mutex more than once, the behavior is undefined. +** {F17029} SQLite will never exhibit +** such behavior in its own use of mutexes. {END} +** +** Some systems (ex: windows95) do not the operation implemented by +** sqlite3_mutex_try(). On those systems, sqlite3_mutex_try() will +** always return SQLITE_BUSY. {F17030} The SQLite core only ever uses +** sqlite3_mutex_try() as an optimization so this is acceptable behavior. {END} +** +** {F17031} The sqlite3_mutex_leave() routine exits a mutex that was +** previously entered by the same thread. {U17032} The behavior +** is undefined if the mutex is not currently entered by the +** calling thread or is not currently allocated. {F17033} SQLite will +** never do either. {END} +** +** See also: [sqlite3_mutex_held()] and [sqlite3_mutex_notheld()]. +*/ +/*IMPORT_C*/ sqlite3_mutex *sqlite3_mutex_alloc(int); +/*IMPORT_C*/ void sqlite3_mutex_free(sqlite3_mutex*); +/*IMPORT_C*/ void sqlite3_mutex_enter(sqlite3_mutex*); +/*IMPORT_C*/ int sqlite3_mutex_try(sqlite3_mutex*); +/*IMPORT_C*/ void sqlite3_mutex_leave(sqlite3_mutex*); + +/* +** CAPI3REF: Mutex Verifcation Routines {F17080} +** +** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routines +** are intended for use inside assert() statements. {F17081} The SQLite core +** never uses these routines except inside an assert() and applications +** are advised to follow the lead of the core. {F17082} The core only +** provides implementations for these routines when it is compiled +** with the SQLITE_DEBUG flag. {U17087} External mutex implementations +** are only required to provide these routines if SQLITE_DEBUG is +** defined and if NDEBUG is not defined. +** +** {F17083} These routines should return true if the mutex in their argument +** is held or not held, respectively, by the calling thread. {END} +** +** {X17084} The implementation is not required to provided versions of these +** routines that actually work. +** If the implementation does not provide working +** versions of these routines, it should at least provide stubs +** that always return true so that one does not get spurious +** assertion failures. {END} +** +** {F17085} If the argument to sqlite3_mutex_held() is a NULL pointer then +** the routine should return 1. {END} This seems counter-intuitive since +** clearly the mutex cannot be held if it does not exist. But the +** the reason the mutex does not exist is because the build is not +** using mutexes. And we do not want the assert() containing the +** call to sqlite3_mutex_held() to fail, so a non-zero return is +** the appropriate thing to do. {F17086} The sqlite3_mutex_notheld() +** interface should also return 1 when given a NULL pointer. +*/ +/*IMPORT_C*/ int sqlite3_mutex_held(sqlite3_mutex*); +/*IMPORT_C*/ int sqlite3_mutex_notheld(sqlite3_mutex*); + +/* +** CAPI3REF: Mutex Types {F17001} +** +** {F17002} The [sqlite3_mutex_alloc()] interface takes a single argument +** which is one of these integer constants. {END} +*/ +#define SQLITE_MUTEX_FAST 0 +#define SQLITE_MUTEX_RECURSIVE 1 +#define SQLITE_MUTEX_STATIC_MASTER 2 +#define SQLITE_MUTEX_STATIC_MEM 3 /* sqlite3_malloc() */ +#define SQLITE_MUTEX_STATIC_MEM2 4 /* sqlite3_release_memory() */ +#define SQLITE_MUTEX_STATIC_PRNG 5 /* sqlite3_random() */ +#define SQLITE_MUTEX_STATIC_LRU 6 /* lru page list */ + +/* +** CAPI3REF: Low-Level Control Of Database Files {F11300} +** +** {F11301} The [sqlite3_file_control()] interface makes a direct call to the +** xFileControl method for the [sqlite3_io_methods] object associated +** with a particular database identified by the second argument. {F11302} The +** name of the database is the name assigned to the database by the +** ATTACH SQL command that opened the +** database. {F11303} To control the main database file, use the name "main" +** or a NULL pointer. {F11304} The third and fourth parameters to this routine +** are passed directly through to the second and third parameters of +** the xFileControl method. {F11305} The return value of the xFileControl +** method becomes the return value of this routine. +** +** {F11306} If the second parameter (zDbName) does not match the name of any +** open database file, then SQLITE_ERROR is returned. {F11307} This error +** code is not remembered and will not be recalled by [sqlite3_errcode()] +** or [sqlite3_errmsg()]. {U11308} The underlying xFileControl method might +** also return SQLITE_ERROR. {U11309} There is no way to distinguish between +** an incorrect zDbName and an SQLITE_ERROR return from the underlying +** xFileControl method. {END} +** +** See also: [SQLITE_FCNTL_LOCKSTATE] +*/ +/*IMPORT_C*/ int sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*); + +/*IMPORT_C*/ int sqlite3_openTest( + const char *zFilename +); + +/*IMPORT_C*/ int sqlite3_bind_double_ref(sqlite3_stmt *stmt, int iCol, double *val); + +/*IMPORT_C*/ int sqlite3_bind_int64_ref(sqlite3_stmt *stmt, int iCol, sqlite_int64 *val); + +/*IMPORT_C*/ void sqlite3_column_double_ref(sqlite3_stmt *stmt, int iCol, double *val); + +/*IMPORT_C*/ void sqlite3_column_int64_ref(sqlite3_stmt *stmt, int iCol, sqlite_int64 *val); + +/*IMPORT_C*/ unsigned int sqlite3_strlen(char *ptr); + +/* +** Undo the hack that converts floating point types to integer for +** builds on processors without floating point support. +*/ +#ifdef SQLITE_OMIT_FLOATING_POINT +# undef double +#endif + +#ifdef __cplusplus +} /* End of the 'extern "C"' block */ +#endif +#endif diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/sqlite3ext.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/sqlite3ext.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,350 @@ +/* +** 2006 June 7 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This header file defines the SQLite interface for use by +** shared libraries that want to be imported as extensions into +** an SQLite instance. Shared libraries that intend to be loaded +** as extensions by SQLite should #include this file instead of +** sqlite3.h. +** +** @(#) $Id: sqlite3ext.h 1282 2008-11-13 09:31:33Z LarsPson $ +*/ +#ifndef _SQLITE3EXT_H_ +#define _SQLITE3EXT_H_ +#include "sqlite3.h" + +typedef struct sqlite3_api_routines sqlite3_api_routines; + +/* +** The following structure hold pointers to all of the SQLite API +** routines. +** +** WARNING: In order to maintain backwards compatibility, add new +** interfaces to the end of this structure only. If you insert new +** interfaces in the middle of this structure, then older different +** versions of SQLite will not be able to load each others shared +** libraries! +*/ +struct sqlite3_api_routines { + void * (*aggregate_context)(sqlite3_context*,int nBytes); + int (*aggregate_count)(sqlite3_context*); + int (*bind_blob)(sqlite3_stmt*,int,const void*,int n,void(*)(void*)); + int (*bind_double)(sqlite3_stmt*,int,double); + int (*bind_int)(sqlite3_stmt*,int,int); + int (*bind_int64)(sqlite3_stmt*,int,sqlite_int64); + int (*bind_null)(sqlite3_stmt*,int); + int (*bind_parameter_count)(sqlite3_stmt*); + int (*bind_parameter_index)(sqlite3_stmt*,const char*zName); + const char * (*bind_parameter_name)(sqlite3_stmt*,int); + int (*bind_text)(sqlite3_stmt*,int,const char*,int n,void(*)(void*)); + int (*bind_text16)(sqlite3_stmt*,int,const void*,int,void(*)(void*)); + int (*bind_value)(sqlite3_stmt*,int,const sqlite3_value*); + int (*busy_handler)(sqlite3*,int(*)(void*,int),void*); + int (*busy_timeout)(sqlite3*,int ms); + int (*changes)(sqlite3*); + int (*close)(sqlite3*); + int (*collation_needed)(sqlite3*,void*,void(*)(void*,sqlite3*,int eTextRep,const char*)); + int (*collation_needed16)(sqlite3*,void*,void(*)(void*,sqlite3*,int eTextRep,const void*)); + const void * (*column_blob)(sqlite3_stmt*,int iCol); + int (*column_bytes)(sqlite3_stmt*,int iCol); + int (*column_bytes16)(sqlite3_stmt*,int iCol); + int (*column_count)(sqlite3_stmt*pStmt); + const char * (*column_database_name)(sqlite3_stmt*,int); + const void * (*column_database_name16)(sqlite3_stmt*,int); + const char * (*column_decltype)(sqlite3_stmt*,int i); + const void * (*column_decltype16)(sqlite3_stmt*,int); + double (*column_double)(sqlite3_stmt*,int iCol); + int (*column_int)(sqlite3_stmt*,int iCol); + sqlite_int64 (*column_int64)(sqlite3_stmt*,int iCol); + const char * (*column_name)(sqlite3_stmt*,int); + const void * (*column_name16)(sqlite3_stmt*,int); + const char * (*column_origin_name)(sqlite3_stmt*,int); + const void * (*column_origin_name16)(sqlite3_stmt*,int); + const char * (*column_table_name)(sqlite3_stmt*,int); + const void * (*column_table_name16)(sqlite3_stmt*,int); + const unsigned char * (*column_text)(sqlite3_stmt*,int iCol); + const void * (*column_text16)(sqlite3_stmt*,int iCol); + int (*column_type)(sqlite3_stmt*,int iCol); + sqlite3_value* (*column_value)(sqlite3_stmt*,int iCol); + void * (*commit_hook)(sqlite3*,int(*)(void*),void*); + int (*complete)(const char*sql); + int (*complete16)(const void*sql); + int (*create_collation)(sqlite3*,const char*,int,void*,int(*)(void*,int,const void*,int,const void*)); + int (*create_collation16)(sqlite3*,const char*,int,void*,int(*)(void*,int,const void*,int,const void*)); + int (*create_function)(sqlite3*,const char*,int,int,void*,void (*xFunc)(sqlite3_context*,int,sqlite3_value**),void (*xStep)(sqlite3_context*,int,sqlite3_value**),void (*xFinal)(sqlite3_context*)); + int (*create_function16)(sqlite3*,const void*,int,int,void*,void (*xFunc)(sqlite3_context*,int,sqlite3_value**),void (*xStep)(sqlite3_context*,int,sqlite3_value**),void (*xFinal)(sqlite3_context*)); + int (*create_module)(sqlite3*,const char*,const sqlite3_module*,void*); + int (*data_count)(sqlite3_stmt*pStmt); + sqlite3 * (*db_handle)(sqlite3_stmt*); + int (*declare_vtab)(sqlite3*,const char*); + int (*enable_shared_cache)(int); + int (*errcode)(sqlite3*db); + const char * (*errmsg)(sqlite3*); + const void * (*errmsg16)(sqlite3*); + int (*exec)(sqlite3*,const char*,sqlite3_callback,void*,char**); + int (*expired)(sqlite3_stmt*); + int (*finalize)(sqlite3_stmt*pStmt); + void (*free)(void*); + void (*free_table)(char**result); + int (*get_autocommit)(sqlite3*); + void * (*get_auxdata)(sqlite3_context*,int); + int (*get_table)(sqlite3*,const char*,char***,int*,int*,char**); + int (*global_recover)(void); + void (*interruptx)(sqlite3*); + sqlite_int64 (*last_insert_rowid)(sqlite3*); + const char * (*libversion)(void); + int (*libversion_number)(void); + void *(*malloc)(int); + char * (*mprintf)(const char*,...); + int (*open)(const char*,sqlite3**); + int (*open16)(const void*,sqlite3**); + int (*prepare)(sqlite3*,const char*,int,sqlite3_stmt**,const char**); + int (*prepare16)(sqlite3*,const void*,int,sqlite3_stmt**,const void**); + void * (*profile)(sqlite3*,void(*)(void*,const char*,sqlite_uint64),void*); + void (*progress_handler)(sqlite3*,int,int(*)(void*),void*); + void *(*realloc)(void*,int); + int (*reset)(sqlite3_stmt*pStmt); + void (*result_blob)(sqlite3_context*,const void*,int,void(*)(void*)); + void (*result_double)(sqlite3_context*,double); + void (*result_error)(sqlite3_context*,const char*,int); + void (*result_error16)(sqlite3_context*,const void*,int); + void (*result_int)(sqlite3_context*,int); + void (*result_int64)(sqlite3_context*,sqlite_int64); + void (*result_null)(sqlite3_context*); + void (*result_text)(sqlite3_context*,const char*,int,void(*)(void*)); + void (*result_text16)(sqlite3_context*,const void*,int,void(*)(void*)); + void (*result_text16be)(sqlite3_context*,const void*,int,void(*)(void*)); + void (*result_text16le)(sqlite3_context*,const void*,int,void(*)(void*)); + void (*result_value)(sqlite3_context*,sqlite3_value*); + void * (*rollback_hook)(sqlite3*,void(*)(void*),void*); + int (*set_authorizer)(sqlite3*,int(*)(void*,int,const char*,const char*,const char*,const char*),void*); + void (*set_auxdata)(sqlite3_context*,int,void*,void (*)(void*)); + char * (*snprintf)(int,char*,const char*,...); + int (*step)(sqlite3_stmt*); + int (*table_column_metadata)(sqlite3*,const char*,const char*,const char*,char const**,char const**,int*,int*,int*); + void (*thread_cleanup)(void); + int (*total_changes)(sqlite3*); + void * (*trace)(sqlite3*,void(*xTrace)(void*,const char*),void*); + int (*transfer_bindings)(sqlite3_stmt*,sqlite3_stmt*); + void * (*update_hook)(sqlite3*,void(*)(void*,int ,char const*,char const*,sqlite_int64),void*); + void * (*user_data)(sqlite3_context*); + const void * (*value_blob)(sqlite3_value*); + int (*value_bytes)(sqlite3_value*); + int (*value_bytes16)(sqlite3_value*); + double (*value_double)(sqlite3_value*); + int (*value_int)(sqlite3_value*); + sqlite_int64 (*value_int64)(sqlite3_value*); + int (*value_numeric_type)(sqlite3_value*); + const unsigned char * (*value_text)(sqlite3_value*); + const void * (*value_text16)(sqlite3_value*); + const void * (*value_text16be)(sqlite3_value*); + const void * (*value_text16le)(sqlite3_value*); + int (*value_type)(sqlite3_value*); + char *(*vmprintf)(const char*,va_list); + /* Added ??? */ + int (*overload_function)(sqlite3*, const char *zFuncName, int nArg); + /* Added by 3.3.13 */ + int (*prepare_v2)(sqlite3*,const char*,int,sqlite3_stmt**,const char**); + int (*prepare16_v2)(sqlite3*,const void*,int,sqlite3_stmt**,const void**); + int (*clear_bindings)(sqlite3_stmt*); + /* Added by 3.4.1 */ + int (*create_module_v2)(sqlite3*,const char*,const sqlite3_module*,void*,void (*xDestroy)(void *)); + /* Added by 3.5.0 */ + int (*bind_zeroblob)(sqlite3_stmt*,int,int); + int (*blob_bytes)(sqlite3_blob*); + int (*blob_close)(sqlite3_blob*); + int (*blob_open)(sqlite3*,const char*,const char*,const char*,sqlite3_int64,int,sqlite3_blob**); + int (*blob_read)(sqlite3_blob*,void*,int,int); + int (*blob_write)(sqlite3_blob*,const void*,int,int); + int (*create_collation_v2)(sqlite3*,const char*,int,void*,int(*)(void*,int,const void*,int,const void*),void(*)(void*)); + int (*file_control)(sqlite3*,const char*,int,void*); + sqlite3_int64 (*memory_highwater)(int); + sqlite3_int64 (*memory_used)(void); + sqlite3_mutex *(*mutex_alloc)(int); + void (*mutex_enter)(sqlite3_mutex*); + void (*mutex_free)(sqlite3_mutex*); + void (*mutex_leave)(sqlite3_mutex*); + int (*mutex_try)(sqlite3_mutex*); + int (*open_v2)(const char*,sqlite3**,int,const char*); + int (*release_memory)(int); + void (*result_error_nomem)(sqlite3_context*); + void (*result_error_toobig)(sqlite3_context*); + int (*sleep)(int); + void (*soft_heap_limit)(int); + sqlite3_vfs *(*vfs_find)(const char*); + int (*vfs_register)(sqlite3_vfs*,int); + int (*vfs_unregister)(sqlite3_vfs*); +}; + +/* +** The following macros redefine the API routines so that they are +** redirected throught the global sqlite3_api structure. +** +** This header file is also used by the loadext.c source file +** (part of the main SQLite library - not an extension) so that +** it can get access to the sqlite3_api_routines structure +** definition. But the main library does not want to redefine +** the API. So the redefinition macros are only valid if the +** SQLITE_CORE macros is undefined. +*/ +#ifndef SQLITE_CORE +#define sqlite3_aggregate_context sqlite3_api->aggregate_context +#define sqlite3_aggregate_count sqlite3_api->aggregate_count +#define sqlite3_bind_blob sqlite3_api->bind_blob +#define sqlite3_bind_double sqlite3_api->bind_double +#define sqlite3_bind_int sqlite3_api->bind_int +#define sqlite3_bind_int64 sqlite3_api->bind_int64 +#define sqlite3_bind_null sqlite3_api->bind_null +#define sqlite3_bind_parameter_count sqlite3_api->bind_parameter_count +#define sqlite3_bind_parameter_index sqlite3_api->bind_parameter_index +#define sqlite3_bind_parameter_name sqlite3_api->bind_parameter_name +#define sqlite3_bind_text sqlite3_api->bind_text +#define sqlite3_bind_text16 sqlite3_api->bind_text16 +#define sqlite3_bind_value sqlite3_api->bind_value +#define sqlite3_busy_handler sqlite3_api->busy_handler +#define sqlite3_busy_timeout sqlite3_api->busy_timeout +#define sqlite3_changes sqlite3_api->changes +#define sqlite3_close sqlite3_api->close +#define sqlite3_collation_needed sqlite3_api->collation_needed +#define sqlite3_collation_needed16 sqlite3_api->collation_needed16 +#define sqlite3_column_blob sqlite3_api->column_blob +#define sqlite3_column_bytes sqlite3_api->column_bytes +#define sqlite3_column_bytes16 sqlite3_api->column_bytes16 +#define sqlite3_column_count sqlite3_api->column_count +#define sqlite3_column_database_name sqlite3_api->column_database_name +#define sqlite3_column_database_name16 sqlite3_api->column_database_name16 +#define sqlite3_column_decltype sqlite3_api->column_decltype +#define sqlite3_column_decltype16 sqlite3_api->column_decltype16 +#define sqlite3_column_double sqlite3_api->column_double +#define sqlite3_column_int sqlite3_api->column_int +#define sqlite3_column_int64 sqlite3_api->column_int64 +#define sqlite3_column_name sqlite3_api->column_name +#define sqlite3_column_name16 sqlite3_api->column_name16 +#define sqlite3_column_origin_name sqlite3_api->column_origin_name +#define sqlite3_column_origin_name16 sqlite3_api->column_origin_name16 +#define sqlite3_column_table_name sqlite3_api->column_table_name +#define sqlite3_column_table_name16 sqlite3_api->column_table_name16 +#define sqlite3_column_text sqlite3_api->column_text +#define sqlite3_column_text16 sqlite3_api->column_text16 +#define sqlite3_column_type sqlite3_api->column_type +#define sqlite3_column_value sqlite3_api->column_value +#define sqlite3_commit_hook sqlite3_api->commit_hook +#define sqlite3_complete sqlite3_api->complete +#define sqlite3_complete16 sqlite3_api->complete16 +#define sqlite3_create_collation sqlite3_api->create_collation +#define sqlite3_create_collation16 sqlite3_api->create_collation16 +#define sqlite3_create_function sqlite3_api->create_function +#define sqlite3_create_function16 sqlite3_api->create_function16 +#define sqlite3_create_module sqlite3_api->create_module +#define sqlite3_create_module_v2 sqlite3_api->create_module_v2 +#define sqlite3_data_count sqlite3_api->data_count +#define sqlite3_db_handle sqlite3_api->db_handle +#define sqlite3_declare_vtab sqlite3_api->declare_vtab +#define sqlite3_enable_shared_cache sqlite3_api->enable_shared_cache +#define sqlite3_errcode sqlite3_api->errcode +#define sqlite3_errmsg sqlite3_api->errmsg +#define sqlite3_errmsg16 sqlite3_api->errmsg16 +#define sqlite3_exec sqlite3_api->exec +#define sqlite3_expired sqlite3_api->expired +#define sqlite3_finalize sqlite3_api->finalize +#define sqlite3_free sqlite3_api->free +#define sqlite3_free_table sqlite3_api->free_table +#define sqlite3_get_autocommit sqlite3_api->get_autocommit +#define sqlite3_get_auxdata sqlite3_api->get_auxdata +#define sqlite3_get_table sqlite3_api->get_table +#define sqlite3_global_recover sqlite3_api->global_recover +#define sqlite3_interrupt sqlite3_api->interruptx +#define sqlite3_last_insert_rowid sqlite3_api->last_insert_rowid +#define sqlite3_libversion sqlite3_api->libversion +#define sqlite3_libversion_number sqlite3_api->libversion_number +#define sqlite3_malloc sqlite3_api->malloc +#define sqlite3_mprintf sqlite3_api->mprintf +#define sqlite3_open sqlite3_api->open +#define sqlite3_open16 sqlite3_api->open16 +#define sqlite3_prepare sqlite3_api->prepare +#define sqlite3_prepare16 sqlite3_api->prepare16 +#define sqlite3_prepare_v2 sqlite3_api->prepare_v2 +#define sqlite3_prepare16_v2 sqlite3_api->prepare16_v2 +#define sqlite3_profile sqlite3_api->profile +#define sqlite3_progress_handler sqlite3_api->progress_handler +#define sqlite3_realloc sqlite3_api->realloc +#define sqlite3_reset sqlite3_api->reset +#define sqlite3_result_blob sqlite3_api->result_blob +#define sqlite3_result_double sqlite3_api->result_double +#define sqlite3_result_error sqlite3_api->result_error +#define sqlite3_result_error16 sqlite3_api->result_error16 +#define sqlite3_result_int sqlite3_api->result_int +#define sqlite3_result_int64 sqlite3_api->result_int64 +#define sqlite3_result_null sqlite3_api->result_null +#define sqlite3_result_text sqlite3_api->result_text +#define sqlite3_result_text16 sqlite3_api->result_text16 +#define sqlite3_result_text16be sqlite3_api->result_text16be +#define sqlite3_result_text16le sqlite3_api->result_text16le +#define sqlite3_result_value sqlite3_api->result_value +#define sqlite3_rollback_hook sqlite3_api->rollback_hook +#define sqlite3_set_authorizer sqlite3_api->set_authorizer +#define sqlite3_set_auxdata sqlite3_api->set_auxdata +#define sqlite3_snprintf sqlite3_api->snprintf +#define sqlite3_step sqlite3_api->step +#define sqlite3_table_column_metadata sqlite3_api->table_column_metadata +#define sqlite3_thread_cleanup sqlite3_api->thread_cleanup +#define sqlite3_total_changes sqlite3_api->total_changes +#define sqlite3_trace sqlite3_api->trace +#define sqlite3_transfer_bindings sqlite3_api->transfer_bindings +#define sqlite3_update_hook sqlite3_api->update_hook +#define sqlite3_user_data sqlite3_api->user_data +#define sqlite3_value_blob sqlite3_api->value_blob +#define sqlite3_value_bytes sqlite3_api->value_bytes +#define sqlite3_value_bytes16 sqlite3_api->value_bytes16 +#define sqlite3_value_double sqlite3_api->value_double +#define sqlite3_value_int sqlite3_api->value_int +#define sqlite3_value_int64 sqlite3_api->value_int64 +#define sqlite3_value_numeric_type sqlite3_api->value_numeric_type +#define sqlite3_value_text sqlite3_api->value_text +#define sqlite3_value_text16 sqlite3_api->value_text16 +#define sqlite3_value_text16be sqlite3_api->value_text16be +#define sqlite3_value_text16le sqlite3_api->value_text16le +#define sqlite3_value_type sqlite3_api->value_type +#define sqlite3_vmprintf sqlite3_api->vmprintf +#define sqlite3_overload_function sqlite3_api->overload_function +#define sqlite3_prepare_v2 sqlite3_api->prepare_v2 +#define sqlite3_prepare16_v2 sqlite3_api->prepare16_v2 +#define sqlite3_clear_bindings sqlite3_api->clear_bindings +#define sqlite3_bind_zeroblob sqlite3_api->bind_zeroblob +#define sqlite3_blob_bytes sqlite3_api->blob_bytes +#define sqlite3_blob_close sqlite3_api->blob_close +#define sqlite3_blob_open sqlite3_api->blob_open +#define sqlite3_blob_read sqlite3_api->blob_read +#define sqlite3_blob_write sqlite3_api->blob_write +#define sqlite3_create_collation_v2 sqlite3_api->create_collation_v2 +#define sqlite3_file_control sqlite3_api->file_control +#define sqlite3_memory_highwater sqlite3_api->memory_highwater +#define sqlite3_memory_used sqlite3_api->memory_used +#define sqlite3_mutex_alloc sqlite3_api->mutex_alloc +#define sqlite3_mutex_enter sqlite3_api->mutex_enter +#define sqlite3_mutex_free sqlite3_api->mutex_free +#define sqlite3_mutex_leave sqlite3_api->mutex_leave +#define sqlite3_mutex_try sqlite3_api->mutex_try +#define sqlite3_open_v2 sqlite3_api->open_v2 +#define sqlite3_release_memory sqlite3_api->release_memory +#define sqlite3_result_error_nomem sqlite3_api->result_error_nomem +#define sqlite3_result_error_toobig sqlite3_api->result_error_toobig +#define sqlite3_sleep sqlite3_api->sleep +#define sqlite3_soft_heap_limit sqlite3_api->soft_heap_limit +#define sqlite3_vfs_find sqlite3_api->vfs_find +#define sqlite3_vfs_register sqlite3_api->vfs_register +#define sqlite3_vfs_unregister sqlite3_api->vfs_unregister +#endif /* SQLITE_CORE */ + +#define SQLITE_EXTENSION_INIT1 const sqlite3_api_routines *sqlite3_api; +#define SQLITE_EXTENSION_INIT2(v) sqlite3_api = v; + +#endif /* _SQLITE3EXT_H_ */ diff -r 5f8e5adbbed9 -r 29cda98b007e engine/sqlite/src/sqliteInt.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/engine/sqlite/src/sqliteInt.h Thu Feb 25 14:29:19 2010 +0000 @@ -0,0 +1,2073 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** Internal interface definitions for SQLite. +** +** @(#) $Id: sqliteInt.h 1282 2008-11-13 09:31:33Z LarsPson $ +*/ +#ifndef _SQLITEINT_H_ +#define _SQLITEINT_H_ + +/* +** The macro unlikely() is a hint that surrounds a boolean +** expression that is usually false. Macro likely() surrounds +** a boolean expression that is usually true. GCC is able to +** use these hints to generate better code, sometimes. +*/ +#if defined(__GNUC__) +# define likely(X) __builtin_expect((X),1) +# define unlikely(X) __builtin_expect((X),0) +#else +# define likely(X) !!(X) +# define unlikely(X) !!(X) +#endif + + +/* +** These #defines should enable >2GB file support on Posix if the +** underlying operating system supports it. If the OS lacks +** large file support, or if the OS is windows, these should be no-ops. +** +** Ticket #2739: The _LARGEFILE_SOURCE macro must appear before any +** system #includes. Hence, this block of code must be the very first +** code in all source files. +** +** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch +** on the compiler command line. This is necessary if you are compiling +** on a recent machine (ex: RedHat 7.2) but you want your code to work +** on an older machine (ex: RedHat 6.0). If you compile on RedHat 7.2 +** without this option, LFS is enable. But LFS does not exist in the kernel +** in RedHat 6.0, so the code won't work. Hence, for maximum binary +** portability you should omit LFS. +** +** Similar is true for MacOS. LFS is only supported on MacOS 9 and later. +*/ +#ifndef SQLITE_DISABLE_LFS +# define _LARGE_FILE 1 +# ifndef _FILE_OFFSET_BITS +# define _FILE_OFFSET_BITS 64 +# endif +# define _LARGEFILE_SOURCE 1 +#endif + + +#include "sqliteLimit.h" + +/* +** For testing purposes, the various size limit constants are really +** variables that we can modify in the testfixture. +*/ +#ifdef SQLITE_TEST + #undef SQLITE_MAX_LENGTH + #undef SQLITE_MAX_COLUMN + #undef SQLITE_MAX_SQL_LENGTH + #undef SQLITE_MAX_EXPR_DEPTH + #undef SQLITE_MAX_COMPOUND_SELECT + #undef SQLITE_MAX_VDBE_OP + #undef SQLITE_MAX_FUNCTION_ARG + #undef SQLITE_MAX_VARIABLE_NUMBER + #undef SQLITE_MAX_PAGE_SIZE + #undef SQLITE_MAX_PAGE_COUNT + #undef SQLITE_MAX_LIKE_PATTERN_LENGTH + + #define SQLITE_MAX_LENGTH sqlite3MAX_LENGTH + #define SQLITE_MAX_COLUMN sqlite3MAX_COLUMN + #define SQLITE_MAX_SQL_LENGTH sqlite3MAX_SQL_LENGTH + #define SQLITE_MAX_EXPR_DEPTH sqlite3MAX_EXPR_DEPTH + #define SQLITE_MAX_COMPOUND_SELECT sqlite3MAX_COMPOUND_SELECT + #define SQLITE_MAX_VDBE_OP sqlite3MAX_VDBE_OP + #define SQLITE_MAX_FUNCTION_ARG sqlite3MAX_FUNCTION_ARG + #define SQLITE_MAX_VARIABLE_NUMBER sqlite3MAX_VARIABLE_NUMBER + #define SQLITE_MAX_PAGE_SIZE sqlite3MAX_PAGE_SIZE + #define SQLITE_MAX_PAGE_COUNT sqlite3MAX_PAGE_COUNT + #define SQLITE_MAX_LIKE_PATTERN_LENGTH sqlite3MAX_LIKE_PATTERN_LENGTH + + extern int sqlite3MAX_LENGTH; + extern int sqlite3MAX_COLUMN; + extern int sqlite3MAX_SQL_LENGTH; + extern int sqlite3MAX_EXPR_DEPTH; + extern int sqlite3MAX_COMPOUND_SELECT; + extern int sqlite3MAX_VDBE_OP; + extern int sqlite3MAX_FUNCTION_ARG; + extern int sqlite3MAX_VARIABLE_NUMBER; + extern int sqlite3MAX_PAGE_SIZE; + extern int sqlite3MAX_PAGE_COUNT; + extern int sqlite3MAX_LIKE_PATTERN_LENGTH; +#endif + + +/* +** The SQLITE_THREADSAFE macro must be defined as either 0 or 1. +** Older versions of SQLite used an optional THREADSAFE macro. +** We support that for legacy +*/ +#if !defined(SQLITE_THREADSAFE) +#if defined(THREADSAFE) +# define SQLITE_THREADSAFE THREADSAFE +#else +# define SQLITE_THREADSAFE 1 +#endif +#endif + +/* +** We need to define _XOPEN_SOURCE as follows in order to enable +** recursive mutexes on most unix systems. But Mac OS X is different. +** The _XOPEN_SOURCE define causes problems for Mac OS X we are told, +** so it is omitted there. See ticket #2673. +** +** Later we learn that _XOPEN_SOURCE is poorly or incorrectly +** implemented on some systems. So we avoid defining it at all +** if it is already defined or if it is unneeded because we are +** not doing a threadsafe build. Ticket #2681. +** +** See also ticket #2741. +*/ +#if !defined(_XOPEN_SOURCE) && !defined(__DARWIN__) && SQLITE_THREADSAFE +# define _XOPEN_SOURCE 500 /* Needed to enable pthread recursive mutexes */ +#endif + +#if defined(SQLITE_TCL) || defined(TCLSH) +# include +#endif + +/* +** Many people are failing to set -DNDEBUG=1 when compiling SQLite. +** Setting NDEBUG makes the code smaller and run faster. So the following +** lines are added to automatically set NDEBUG unless the -DSQLITE_DEBUG=1 +** option is set. Thus NDEBUG becomes an opt-in rather than an opt-out +** feature. +*/ +#if !defined(NDEBUG) && !defined(SQLITE_DEBUG) +# define NDEBUG 1 +#endif + +#include "sqlite3.h" +#include "hash.h" +#include "parse.h" +#include +#include +#include +#include +#include + +#define sqlite3_isnan(X) ((X)!=(X)) + +/* +** If compiling for a processor that lacks floating point support, +** substitute integer for floating-point +*/ +#ifdef SQLITE_OMIT_FLOATING_POINT +# define double sqlite_int64 +# define LONGDOUBLE_TYPE sqlite_int64 +# ifndef SQLITE_BIG_DBL +# define SQLITE_BIG_DBL (0x7fffffffffffffff) +# endif +# define SQLITE_OMIT_DATETIME_FUNCS 1 +# define SQLITE_OMIT_TRACE 1 +# undef SQLITE_MIXED_ENDIAN_64BIT_FLOAT +#endif +#ifndef SQLITE_BIG_DBL +# define SQLITE_BIG_DBL (1e99) +#endif + +/* +** OMIT_TEMPDB is set to 1 if SQLITE_OMIT_TEMPDB is defined, or 0 +** afterward. Having this macro allows us to cause the C compiler +** to omit code used by TEMP tables without messy #ifndef statements. +*/ +#ifdef SQLITE_OMIT_TEMPDB +#define OMIT_TEMPDB 1 +#else +#define OMIT_TEMPDB 0 +#endif + +/* +** If the following macro is set to 1, then NULL values are considered +** distinct when determining whether or not two entries are the same +** in a UNIQUE index. This is the way PostgreSQL, Oracle, DB2, MySQL, +** OCELOT, and Firebird all work. The SQL92 spec explicitly says this +** is the way things are suppose to work. +** +** If the following macro is set to 0, the NULLs are indistinct for +** a UNIQUE index. In this mode, you can only have a single NULL entry +** for a column declared UNIQUE. This is the way Informix and SQL Server +** work. +*/ +#define NULL_DISTINCT_FOR_UNIQUE 1 + +/* +** The "file format" number is an integer that is incremented whenever +** the VDBE-level file format changes. The following macros define the +** the default file format for new databases and the maximum file format +** that the library can read. +*/ +#define SQLITE_MAX_FILE_FORMAT 4 +#ifndef SQLITE_DEFAULT_FILE_FORMAT +# define SQLITE_DEFAULT_FILE_FORMAT 1 +#endif + +/* +** Provide a default value for TEMP_STORE in case it is not specified +** on the command-line +*/ +#ifndef TEMP_STORE +# define TEMP_STORE 1 +#endif + +/* +** GCC does not define the offsetof() macro so we'll have to do it +** ourselves. +*/ +#ifndef offsetof +#define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD)) +#endif + +/* +** Check to see if this machine uses EBCDIC. (Yes, believe it or +** not, there are still machines out there that use EBCDIC.) +*/ +#if 'A' == '\301' +# define SQLITE_EBCDIC 1 +#else +# define SQLITE_ASCII 1 +#endif + +/* +** Integers of known sizes. These typedefs might change for architectures +** where the sizes very. Preprocessor macros are available so that the +** types can be conveniently redefined at compile-type. Like this: +** +** cc '-DUINTPTR_TYPE=long long int' ... +*/ +#ifndef UINT32_TYPE +# define UINT32_TYPE unsigned int +#endif +#ifndef UINT16_TYPE +# define UINT16_TYPE unsigned short int +#endif +#ifndef INT16_TYPE +# define INT16_TYPE short int +#endif +#ifndef UINT8_TYPE +# define UINT8_TYPE unsigned char +#endif +#ifndef INT8_TYPE +# define INT8_TYPE signed char +#endif +#ifndef LONGDOUBLE_TYPE +# define LONGDOUBLE_TYPE long double +#endif +typedef sqlite_int64 i64; /* 8-byte signed integer */ +typedef sqlite_uint64 u64; /* 8-byte unsigned integer */ +typedef UINT32_TYPE u32; /* 4-byte unsigned integer */ +typedef UINT16_TYPE u16; /* 2-byte unsigned integer */ +typedef INT16_TYPE i16; /* 2-byte signed integer */ +typedef UINT8_TYPE u8; /* 1-byte unsigned integer */ +typedef UINT8_TYPE i8; /* 1-byte signed integer */ + +/* +** Macros to determine whether the machine is big or little endian, +** evaluated at runtime. +*/ +#ifdef SQLITE_AMALGAMATION +const int sqlite3One; +#else +extern const int sqlite3one; +#endif +#if defined(i386) || defined(__i386__) || defined(_M_IX86) +# define SQLITE_BIGENDIAN 0 +# define SQLITE_LITTLEENDIAN 1 +# define SQLITE_UTF16NATIVE SQLITE_UTF16LE +#else +# define SQLITE_BIGENDIAN (*(char *)(&sqlite3one)==0) +# define SQLITE_LITTLEENDIAN (*(char *)(&sqlite3one)==1) +# define SQLITE_UTF16NATIVE (SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE) +#endif + +/* +** An instance of the following structure is used to store the busy-handler +** callback for a given sqlite handle. +** +** The sqlite.busyHandler member of the sqlite struct contains the busy +** callback for the database handle. Each pager opened via the sqlite +** handle is passed a pointer to sqlite.busyHandler. The busy-handler +** callback is currently invoked only from within pager.c. +*/ +typedef struct BusyHandler BusyHandler; +struct BusyHandler { + int (*xFunc)(void *,int); /* The busy callback */ + void *pArg; /* First arg to busy callback */ + int nBusy; /* Incremented with each busy call */ +}; + +/* +** Defer sourcing vdbe.h and btree.h until after the "u8" and +** "BusyHandler typedefs. +*/ +#include "btree.h" +#include "vdbe.h" +#include "pager.h" + + +/* +** Name of the master database table. The master database table +** is a special table that holds the names and attributes of all +** user tables and indices. +*/ +#define MASTER_NAME "sqlite_master" +#define TEMP_MASTER_NAME "sqlite_temp_master" + +/* +** The root-page of the master database table. +*/ +#define MASTER_ROOT 1 + +/* +** The name of the schema table. +*/ +#define SCHEMA_TABLE(x) ((!OMIT_TEMPDB)&&(x==1)?TEMP_MASTER_NAME:MASTER_NAME) + +/* +** A convenience macro that returns the number of elements in +** an array. +*/ +#define ArraySize(X) (sizeof(X)/sizeof(X[0])) + +/* +** Forward references to structures +*/ +typedef struct AggInfo AggInfo; +typedef struct AuthContext AuthContext; +typedef struct CollSeq CollSeq; +typedef struct Column Column; +typedef struct Db Db; +typedef struct Schema Schema; +typedef struct Expr Expr; +typedef struct ExprList ExprList; +typedef struct FKey FKey; +typedef struct FuncDef FuncDef; +typedef struct IdList IdList; +typedef struct Index Index; +typedef struct KeyClass KeyClass; +typedef struct KeyInfo KeyInfo; +typedef struct Module Module; +typedef struct NameContext NameContext; +typedef struct Parse Parse; +typedef struct Select Select; +typedef struct SrcList SrcList; +typedef struct StrAccum StrAccum; +typedef struct Table Table; +typedef struct TableLock TableLock; +typedef struct Token Token; +typedef struct TriggerStack TriggerStack; +typedef struct TriggerStep TriggerStep; +typedef struct Trigger Trigger; +typedef struct WhereInfo WhereInfo; +typedef struct WhereLevel WhereLevel; + +#include "os.h" +#include "mutex.h" + + +/* +** If X is a character that can be used in an identifier then +** IdChar(X) will be true. Otherwise it is false. +** +** For ASCII, any character with the high-order bit set is +** allowed in an identifier. For 7-bit characters, +** sqlite3IsIdChar[X] must be 1. +** +** For EBCDIC, the rules are more complex but have the same +** end result. +** +** Ticket #1066. the SQL standard does not allow '$' in the +** middle of identfiers. But many SQL implementations do. +** SQLite will allow '$' in identifiers for compatibility. +** But the feature is undocumented. +*/ +#ifdef SQLITE_ASCII +const char sqlite3IsAsciiIdChar[] = { +/* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */ + 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 2x */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, /* 3x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 4x */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, /* 5x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 6x */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, /* 7x */ +}; +#define IdChar(C) (((c=C)&0x80)!=0 || (c>0x1f && sqlite3IsAsciiIdChar[c-0x20])) +#endif +#ifdef SQLITE_EBCDIC +const char sqlite3IsEbcdicIdChar[] = { +/* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */ + 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, /* 4x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, /* 5x */ + 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, /* 6x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, /* 7x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, /* 8x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, /* 9x */ + 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, /* Ax */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Bx */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, /* Cx */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, /* Dx */ + 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, /* Ex */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, /* Fx */ +}; +#define IdChar(C) (((c=C)>=0x42 && sqlite3IsEbcdicIdChar[c-0x40])) +#endif + +/* +** Each database file to be accessed by the system is an instance +** of the following structure. There are normally two of these structures +** in the sqlite.aDb[] array. aDb[0] is the main database file and +** aDb[1] is the database file used to hold temporary tables. Additional +** databases may be attached. +*/ +struct Db { + char *zName; /* Name of this database */ + Btree *pBt; /* The B*Tree structure for this database file */ + u8 inTrans; /* 0: not writable. 1: Transaction. 2: Checkpoint */ + u8 safety_level; /* How aggressive at synching data to disk */ + void *pAux; /* Auxiliary data. Usually NULL */ + void (*xFreeAux)(void*); /* Routine to free pAux */ + Schema *pSchema; /* Pointer to database schema (possibly shared) */ +}; + +/* +** An instance of the following structure stores a database schema. +** +** If there are no virtual tables configured in this schema, the +** Schema.db variable is set to NULL. After the first virtual table +** has been added, it is set to point to the database connection +** used to create the connection. Once a virtual table has been +** added to the Schema structure and the Schema.db variable populated, +** only that database connection may use the Schema to prepare +** statements. +*/ +struct Schema { + int schema_cookie; /* Database schema version number for this file */ + Hash tblHash; /* All tables indexed by name */ + Hash idxHash; /* All (named) indices indexed by name */ + Hash trigHash; /* All triggers indexed by name */ + Hash aFKey; /* Foreign keys indexed by to-table */ + Table *pSeqTab; /* The sqlite_sequence table used by AUTOINCREMENT */ + u8 file_format; /* Schema format version for this file */ + u8 enc; /* Text encoding used by this database */ + u16 flags; /* Flags associated with this schema */ + int cache_size; /* Number of pages to use in the cache */ +#ifndef SQLITE_OMIT_VIRTUALTABLE + sqlite3 *db; /* "Owner" connection. See comment above */ +#endif +}; + +/* +** These macros can be used to test, set, or clear bits in the +** Db.flags field. +*/ +#define DbHasProperty(D,I,P) (((D)->aDb[I].pSchema->flags&(P))==(P)) +#define DbHasAnyProperty(D,I,P) (((D)->aDb[I].pSchema->flags&(P))!=0) +#define DbSetProperty(D,I,P) (D)->aDb[I].pSchema->flags|=(P) +#define DbClearProperty(D,I,P) (D)->aDb[I].pSchema->flags&=~(P) + +/* +** Allowed values for the DB.flags field. +** +** The DB_SchemaLoaded flag is set after the database schema has been +** read into internal hash tables. +** +** DB_UnresetViews means that one or more views have column names that +** have been filled out. If the schema changes, these column names might +** changes and so the view will need to be reset. +*/ +#define DB_SchemaLoaded 0x0001 /* The schema has been loaded */ +#define DB_UnresetViews 0x0002 /* Some views have defined column names */ +#define DB_Empty 0x0004 /* The file is empty (length 0 bytes) */ + + +/* +** Each database is an instance of the following structure. +** +** The sqlite.lastRowid records the last insert rowid generated by an +** insert statement. Inserts on views do not affect its value. Each +** trigger has its own context, so that lastRowid can be updated inside +** triggers as usual. The previous value will be restored once the trigger +** exits. Upon entering a before or instead of trigger, lastRowid is no +** longer (since after version 2.8.12) reset to -1. +** +** The sqlite.nChange does not count changes within triggers and keeps no +** context. It is reset at start of sqlite3_exec. +** The sqlite.lsChange represents the number of changes made by the last +** insert, update, or delete statement. It remains constant throughout the +** length of a statement and is then updated by OP_SetCounts. It keeps a +** context stack just like lastRowid so that the count of changes +** within a trigger is not seen outside the trigger. Changes to views do not +** affect the value of lsChange. +** The sqlite.csChange keeps track of the number of current changes (since +** the last statement) and is used to update sqlite_lsChange. +** +** The member variables sqlite.errCode, sqlite.zErrMsg and sqlite.zErrMsg16 +** store the most recent error code and, if applicable, string. The +** internal function sqlite3Error() is used to set these variables +** consistently. +*/ +struct sqlite3 { + sqlite3_vfs *pVfs; /* OS Interface */ + int nDb; /* Number of backends currently in use */ + Db *aDb; /* All backends */ + int flags; /* Miscellanous flags. See below */ + int openFlags; /* Flags passed to sqlite3_vfs.xOpen() */ + int errCode; /* Most recent error code (SQLITE_*) */ + int errMask; /* & result codes with this before returning */ + u8 autoCommit; /* The auto-commit flag. */ + u8 temp_store; /* 1: file 2: memory 0: default */ + u8 mallocFailed; /* True if we have seen a malloc failure */ + char nextAutovac; /* Autovac setting after VACUUM if >=0 */ + int nTable; /* Number of tables in the database */ + CollSeq *pDfltColl; /* The default collating sequence (BINARY) */ + i64 lastRowid; /* ROWID of most recent insert (see above) */ + i64 priorNewRowid; /* Last randomly generated ROWID */ + int magic; /* Magic number for detect library misuse */ + int nChange; /* Value returned by sqlite3_changes() */ + int nTotalChange; /* Value returned by sqlite3_total_changes() */ + sqlite3_mutex *mutex; /* Connection mutex */ + struct sqlite3InitInfo { /* Information used during initialization */ + int iDb; /* When back is being initialized */ + int newTnum; /* Rootpage of table being initialized */ + u8 busy; /* TRUE if currently initializing */ + } init; + int nExtension; /* Number of loaded extensions */ + void **aExtension; /* Array of shared libraray handles */ + struct Vdbe *pVdbe; /* List of active virtual machines */ + int activeVdbeCnt; /* Number of vdbes currently executing */ + void (*xTrace)(void*,const char*); /* Trace function */ + void *pTraceArg; /* Argument to the trace function */ + void (*xProfile)(void*,const char*,u64); /* Profiling function */ + void *pProfileArg; /* Argument to profile function */ + void *pCommitArg; /* Argument to xCommitCallback() */ + int (*xCommitCallback)(void*); /* Invoked at every commit. */ + void *pRollbackArg; /* Argument to xRollbackCallback() */ + void (*xRollbackCallback)(void*); /* Invoked at every commit. */ + void *pUpdateArg; + void (*xUpdateCallback)(void*,int, const char*,const char*,sqlite_int64); + void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*); + void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*); + void *pCollNeededArg; + sqlite3_value *pErr; /* Most recent error message */ + char *zErrMsg; /* Most recent error message (UTF-8 encoded) */ + char *zErrMsg16; /* Most recent error message (UTF-16 encoded) */ + union { + int isInterrupted; /* True if sqlite3_interrupt has been called */ + double notUsed1; /* Spacer */ + } u1; +#ifndef SQLITE_OMIT_AUTHORIZATION + int (*xAuth)(void*,int,const char*,const char*,const char*,const char*); + /* Access authorization function */ + void *pAuthArg; /* 1st argument to the access auth function */ +#endif +#ifndef SQLITE_OMIT_PROGRESS_CALLBACK + int (*xProgress)(void *); /* The progress callback */ + void *pProgressArg; /* Argument to the progress callback */ + int nProgressOps; /* Number of opcodes for progress callback */ +#endif +#ifndef SQLITE_OMIT_VIRTUALTABLE + Hash aModule; /* populated by sqlite3_create_module() */ + Table *pVTab; /* vtab with active Connect/Create method */ + sqlite3_vtab **aVTrans; /* Virtual tables with open transactions */ + int nVTrans; /* Allocated size of aVTrans */ +#endif + Hash aFunc; /* All functions that can be in SQL exprs */ + Hash aCollSeq; /* All collating sequences */ + BusyHandler busyHandler; /* Busy callback */ + int busyTimeout; /* Busy handler timeout, in msec */ + Db aDbStatic[2]; /* Static space for the 2 default backends */ +#ifdef SQLITE_SSE + sqlite3_stmt *pFetch; /* Used by SSE to fetch stored statements */ +#endif + u8 dfltLockMode; /* Default locking-mode for attached dbs */ +}; + +/* +** A macro to discover the encoding of a database. +*/ +#define ENC(db) ((db)->aDb[0].pSchema->enc) + +/* +** Possible values for the sqlite.flags and or Db.flags fields. +** +** On sqlite.flags, the SQLITE_InTrans value means that we have +** executed a BEGIN. On Db.flags, SQLITE_InTrans means a statement +** transaction is active on that particular database file. +*/ +#define SQLITE_VdbeTrace 0x00000001 /* True to trace VDBE execution */ +#define SQLITE_InTrans 0x00000008 /* True if in a transaction */ +#define SQLITE_InternChanges 0x00000010 /* Uncommitted Hash table changes */ +#define SQLITE_FullColNames 0x00000020 /* Show full column names on SELECT */ +#define SQLITE_ShortColNames 0x00000040 /* Show short columns names */ +#define SQLITE_CountRows 0x00000080 /* Count rows changed by INSERT, */ + /* DELETE, or UPDATE and return */ + /* the count using a callback. */ +#define SQLITE_NullCallback 0x00000100 /* Invoke the callback once if the */ + /* result set is empty */ +#define SQLITE_SqlTrace 0x00000200 /* Debug print SQL as it executes */ +#define SQLITE_VdbeListing 0x00000400 /* Debug listings of VDBE programs */ +#define SQLITE_WriteSchema 0x00000800 /* OK to update SQLITE_MASTER */ +#define SQLITE_NoReadlock 0x00001000 /* Readlocks are omitted when + ** accessing read-only databases */ +#define SQLITE_IgnoreChecks 0x00002000 /* Do not enforce check constraints */ +#define SQLITE_ReadUncommitted 0x00004000 /* For shared-cache mode */ +#define SQLITE_LegacyFileFmt 0x00008000 /* Create new databases in format 1 */ +#define SQLITE_FullFSync 0x00010000 /* Use full fsync on the backend */ +#define SQLITE_LoadExtension 0x00020000 /* Enable load_extension */ + +#define SQLITE_RecoveryMode 0x00040000 /* Ignore schema errors */ +#define SQLITE_SharedCache 0x00080000 /* Cache sharing is enabled */ +#define SQLITE_Vtab 0x00100000 /* There exists a virtual table */ + +/* +** Possible values for the sqlite.magic field. +** The numbers are obtained at random and have no special meaning, other +** than being distinct from one another. +*/ +#define SQLITE_MAGIC_OPEN 0xa029a697 /* Database is open */ +#define SQLITE_MAGIC_CLOSED 0x9f3c2d33 /* Database is closed */ +#define SQLITE_MAGIC_BUSY 0xf03b7906 /* Database currently in use */ +#define SQLITE_MAGIC_ERROR 0xb5357930 /* An SQLITE_MISUSE error occurred */ + +/* +** Each SQL function is defined by an instance of the following +** structure. A pointer to this structure is stored in the sqlite.aFunc +** hash table. When multiple functions have the same name, the hash table +** points to a linked list of these structures. +*/ +struct FuncDef { + i16 nArg; /* Number of arguments. -1 means unlimited */ + u8 iPrefEnc; /* Preferred text encoding (SQLITE_UTF8, 16LE, 16BE) */ + u8 needCollSeq; /* True if sqlite3GetFuncCollSeq() might be called */ + u8 flags; /* Some combination of SQLITE_FUNC_* */ + void *pUserData; /* User data parameter */ + FuncDef *pNext; /* Next function with same name */ + void (*xFunc)(sqlite3_context*,int,sqlite3_value**); /* Regular function */ + void (*xStep)(sqlite3_context*,int,sqlite3_value**); /* Aggregate step */ + void (*xFinalize)(sqlite3_context*); /* Aggregate finializer */ + char zName[1]; /* SQL name of the function. MUST BE LAST */ +}; + +/* +** Each SQLite module (virtual table definition) is defined by an +** instance of the following structure, stored in the sqlite3.aModule +** hash table. +*/ +struct Module { + const sqlite3_module *pModule; /* Callback pointers */ + const char *zName; /* Name passed to create_module() */ + void *pAux; /* pAux passed to create_module() */ + void (*xDestroy)(void *); /* Module destructor function */ +}; + +/* +** Possible values for FuncDef.flags +*/ +#define SQLITE_FUNC_LIKE 0x01 /* Candidate for the LIKE optimization */ +#define SQLITE_FUNC_CASE 0x02 /* Case-sensitive LIKE-type function */ +#define SQLITE_FUNC_EPHEM 0x04 /* Ephermeral. Delete with VDBE */ + +/* +** information about each column of an SQL table is held in an instance +** of this structure. +*/ +struct Column { + char *zName; /* Name of this column */ + Expr *pDflt; /* Default value of this column */ + char *zType; /* Data type for this column */ + char *zColl; /* Collating sequence. If NULL, use the default */ + u8 notNull; /* True if there is a NOT NULL constraint */ + u8 isPrimKey; /* True if this column is part of the PRIMARY KEY */ + char affinity; /* One of the SQLITE_AFF_... values */ +#ifndef SQLITE_OMIT_VIRTUALTABLE + u8 isHidden; /* True if this column is 'hidden' */ +#endif +}; + +/* +** A "Collating Sequence" is defined by an instance of the following +** structure. Conceptually, a collating sequence consists of a name and +** a comparison routine that defines the order of that sequence. +** +** There may two seperate implementations of the collation function, one +** that processes text in UTF-8 encoding (CollSeq.xCmp) and another that +** processes text encoded in UTF-16 (CollSeq.xCmp16), using the machine +** native byte order. When a collation sequence is invoked, SQLite selects +** the version that will require the least expensive encoding +** translations, if any. +** +** The CollSeq.pUser member variable is an extra parameter that passed in +** as the first argument to the UTF-8 comparison function, xCmp. +** CollSeq.pUser16 is the equivalent for the UTF-16 comparison function, +** xCmp16. +** +** If both CollSeq.xCmp and CollSeq.xCmp16 are NULL, it means that the +** collating sequence is undefined. Indices built on an undefined +** collating sequence may not be read or written. +*/ +struct CollSeq { + char *zName; /* Name of the collating sequence, UTF-8 encoded */ + u8 enc; /* Text encoding handled by xCmp() */ + u8 type; /* One of the SQLITE_COLL_... values below */ + void *pUser; /* First argument to xCmp() */ + int (*xCmp)(void*,int, const void*, int, const void*); + void (*xDel)(void*); /* Destructor for pUser */ +}; + +/* +** Allowed values of CollSeq flags: +*/ +#define SQLITE_COLL_BINARY 1 /* The default memcmp() collating sequence */ +#define SQLITE_COLL_NOCASE 2 /* The built-in NOCASE collating sequence */ +#define SQLITE_COLL_REVERSE 3 /* The built-in REVERSE collating sequence */ +#define SQLITE_COLL_USER 0 /* Any other user-defined collating sequence */ + +/* +** A sort order can be either ASC or DESC. +*/ +#define SQLITE_SO_ASC 0 /* Sort in ascending order */ +#define SQLITE_SO_DESC 1 /* Sort in ascending order */ + +/* +** Column affinity types. +** +** These used to have mnemonic name like 'i' for SQLITE_AFF_INTEGER and +** 't' for SQLITE_AFF_TEXT. But we can save a little space and improve +** the speed a little by number the values consecutively. +** +** But rather than start with 0 or 1, we begin with 'a'. That way, +** when multiple affinity types are concatenated into a string and +** used as the P3 operand, they will be more readable. +** +** Note also that the numeric types are grouped together so that testing +** for a numeric type is a single comparison. +*/ +#define SQLITE_AFF_TEXT 'a' +#define SQLITE_AFF_NONE 'b' +#define SQLITE_AFF_NUMERIC 'c' +#define SQLITE_AFF_INTEGER 'd' +#define SQLITE_AFF_REAL 'e' + +#define sqlite3IsNumericAffinity(X) ((X)>=SQLITE_AFF_NUMERIC) + +/* +** Each SQL table is represented in memory by an instance of the +** following structure. +** +** Table.zName is the name of the table. The case of the original +** CREATE TABLE statement is stored, but case is not significant for +** comparisons. +** +** Table.nCol is the number of columns in this table. Table.aCol is a +** pointer to an array of Column structures, one for each column. +** +** If the table has an INTEGER PRIMARY KEY, then Table.iPKey is the index of +** the column that is that key. Otherwise Table.iPKey is negative. Note +** that the datatype of the PRIMARY KEY must be INTEGER for this field to +** be set. An INTEGER PRIMARY KEY is used as the rowid for each row of +** the table. If a table has no INTEGER PRIMARY KEY, then a random rowid +** is generated for each row of the table. Table.hasPrimKey is true if +** the table has any PRIMARY KEY, INTEGER or otherwise. +** +** Table.tnum is the page number for the root BTree page of the table in the +** database file. If Table.iDb is the index of the database table backend +** in sqlite.aDb[]. 0 is for the main database and 1 is for the file that +** holds temporary tables and indices. If Table.isEphem +** is true, then the table is stored in a file that is automatically deleted +** when the VDBE cursor to the table is closed. In this case Table.tnum +** refers VDBE cursor number that holds the table open, not to the root +** page number. Transient tables are used to hold the results of a +** sub-query that appears instead of a real table name in the FROM clause +** of a SELECT statement. +*/ +struct Table { + char *zName; /* Name of the table */ + int nCol; /* Number of columns in this table */ + Column *aCol; /* Information about each column */ + int iPKey; /* If not less then 0, use aCol[iPKey] as the primary key */ + Index *pIndex; /* List of SQL indexes on this table. */ + int tnum; /* Root BTree node for this table (see note above) */ + Select *pSelect; /* NULL for tables. Points to definition if a view. */ + int nRef; /* Number of pointers to this Table */ + Trigger *pTrigger; /* List of SQL triggers on this table */ + FKey *pFKey; /* Linked list of all foreign keys in this table */ + char *zColAff; /* String defining the affinity of each column */ +#ifndef SQLITE_OMIT_CHECK + Expr *pCheck; /* The AND of all CHECK constraints */ +#endif +#ifndef SQLITE_OMIT_ALTERTABLE + int addColOffset; /* Offset in CREATE TABLE statement to add a new column */ +#endif + u8 readOnly; /* True if this table should not be written by the user */ + u8 isEphem; /* True if created using OP_OpenEphermeral */ + u8 hasPrimKey; /* True if there exists a primary key */ + u8 keyConf; /* What to do in case of uniqueness conflict on iPKey */ + u8 autoInc; /* True if the integer primary key is autoincrement */ +#ifndef SQLITE_OMIT_VIRTUALTABLE + u8 isVirtual; /* True if this is a virtual table */ + u8 isCommit; /* True once the CREATE TABLE has been committed */ + Module *pMod; /* Pointer to the implementation of the module */ + sqlite3_vtab *pVtab; /* Pointer to the module instance */ + int nModuleArg; /* Number of arguments to the module */ + char **azModuleArg; /* Text of all module args. [0] is module name */ +#endif + Schema *pSchema; /* Schema that contains this table */ +}; + +/* +** Test to see whether or not a table is a virtual table. This is +** done as a macro so that it will be optimized out when virtual +** table support is omitted from the build. +*/ +#ifndef SQLITE_OMIT_VIRTUALTABLE +# define IsVirtual(X) ((X)->isVirtual) +# define IsHiddenColumn(X) ((X)->isHidden) +#else +# define IsVirtual(X) 0 +# define IsHiddenColumn(X) 0 +#endif + +/* +** Each foreign key constraint is an instance of the following structure. +** +** A foreign key is associated with two tables. The "from" table is +** the table that contains the REFERENCES clause that creates the foreign +** key. The "to" table is the table that is named in the REFERENCES clause. +** Consider this example: +** +** CREATE TABLE ex1( +** a INTEGER PRIMARY KEY, +** b INTEGER CONSTRAINT fk1 REFERENCES ex2(x) +** ); +** +** For foreign key "fk1", the from-table is "ex1" and the to-table is "ex2". +** +** Each REFERENCES clause generates an instance of the following structure +** which is attached to the from-table. The to-table need not exist when +** the from-table is created. The existance of the to-table is not checked +** until an attempt is made to insert data into the from-table. +** +** The sqlite.aFKey hash table stores pointers to this structure +** given the name of a to-table. For each to-table, all foreign keys +** associated with that table are on a linked list using the FKey.pNextTo +** field. +*/ +struct FKey { + Table *pFrom; /* The table that constains the REFERENCES clause */ + FKey *pNextFrom; /* Next foreign key in pFrom */ + char *zTo; /* Name of table that the key points to */ + FKey *pNextTo; /* Next foreign key that points to zTo */ + int nCol; /* Number of columns in this key */ + struct sColMap { /* Mapping of columns in pFrom to columns in zTo */ + int iFrom; /* Index of column in pFrom */ + char *zCol; /* Name of column in zTo. If 0 use PRIMARY KEY */ + } *aCol; /* One entry for each of nCol column s */ + u8 isDeferred; /* True if constraint checking is deferred till COMMIT */ + u8 updateConf; /* How to resolve conflicts that occur on UPDATE */ + u8 deleteConf; /* How to resolve conflicts that occur on DELETE */ + u8 insertConf; /* How to resolve conflicts that occur on INSERT */ +}; + +/* +** SQLite supports many different ways to resolve a constraint +** error. ROLLBACK processing means that a constraint violation +** causes the operation in process to fail and for the current transaction +** to be rolled back. ABORT processing means the operation in process +** fails and any prior changes from that one operation are backed out, +** but the transaction is not rolled back. FAIL processing means that +** the operation in progress stops and returns an error code. But prior +** changes due to the same operation are not backed out and no rollback +** occurs. IGNORE means that the particular row that caused the constraint +** error is not inserted or updated. Processing continues and no error +** is returned. REPLACE means that preexisting database rows that caused +** a UNIQUE constraint violation are removed so that the new insert or +** update can proceed. Processing continues and no error is reported. +** +** RESTRICT, SETNULL, and CASCADE actions apply only to foreign keys. +** RESTRICT is the same as ABORT for IMMEDIATE foreign keys and the +** same as ROLLBACK for DEFERRED keys. SETNULL means that the foreign +** key is set to NULL. CASCADE means that a DELETE or UPDATE of the +** referenced table row is propagated into the row that holds the +** foreign key. +** +** The following symbolic values are used to record which type +** of action to take. +*/ +#define OE_None 0 /* There is no constraint to check */ +#define OE_Rollback 1 /* Fail the operation and rollback the transaction */ +#define OE_Abort 2 /* Back out changes but do no rollback transaction */ +#define OE_Fail 3 /* Stop the operation but leave all prior changes */ +#define OE_Ignore 4 /* Ignore the error. Do not do the INSERT or UPDATE */ +#define OE_Replace 5 /* Delete existing record, then do INSERT or UPDATE */ + +#define OE_Restrict 6 /* OE_Abort for IMMEDIATE, OE_Rollback for DEFERRED */ +#define OE_SetNull 7 /* Set the foreign key value to NULL */ +#define OE_SetDflt 8 /* Set the foreign key value to its default */ +#define OE_Cascade 9 /* Cascade the changes */ + +#define OE_Default 99 /* Do whatever the default action is */ + + +/* +** An instance of the following structure is passed as the first +** argument to sqlite3VdbeKeyCompare and is used to control the +** comparison of the two index keys. +** +** If the KeyInfo.incrKey value is true and the comparison would +** otherwise be equal, then return a result as if the second key +** were larger. +*/ +struct KeyInfo { + sqlite3 *db; /* The database connection */ + u8 enc; /* Text encoding - one of the TEXT_Utf* values */ + u8 incrKey; /* Increase 2nd key by epsilon before comparison */ + u8 prefixIsEqual; /* Treat a prefix as equal */ + int nField; /* Number of entries in aColl[] */ + u8 *aSortOrder; /* If defined an aSortOrder[i] is true, sort DESC */ + CollSeq *aColl[1]; /* Collating sequence for each term of the key */ +}; + +/* +** Each SQL index is represented in memory by an +** instance of the following structure. +** +** The columns of the table that are to be indexed are described +** by the aiColumn[] field of this structure. For example, suppose +** we have the following table and index: +** +** CREATE TABLE Ex1(c1 int, c2 int, c3 text); +** CREATE INDEX Ex2 ON Ex1(c3,c1); +** +** In the Table structure describing Ex1, nCol==3 because there are +** three columns in the table. In the Index structure describing +** Ex2, nColumn==2 since 2 of the 3 columns of Ex1 are indexed. +** The value of aiColumn is {2, 0}. aiColumn[0]==2 because the +** first column to be indexed (c3) has an index of 2 in Ex1.aCol[]. +** The second column to be indexed (c1) has an index of 0 in +** Ex1.aCol[], hence Ex2.aiColumn[1]==0. +** +** The Index.onError field determines whether or not the indexed columns +** must be unique and what to do if they are not. When Index.onError=OE_None, +** it means this is not a unique index. Otherwise it is a unique index +** and the value of Index.onError indicate the which conflict resolution +** algorithm to employ whenever an attempt is made to insert a non-unique +** element. +*/ +struct Index { + char *zName; /* Name of this index */ + int nColumn; /* Number of columns in the table used by this index */ + int *aiColumn; /* Which columns are used by this index. 1st is 0 */ + unsigned *aiRowEst; /* Result of ANALYZE: Est. rows selected by each column */ + Table *pTable; /* The SQL table being indexed */ + int tnum; /* Page containing root of this index in database file */ + u8 onError; /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */ + u8 autoIndex; /* True if is automatically created (ex: by UNIQUE) */ + char *zColAff; /* String defining the affinity of each column */ + Index *pNext; /* The next index associated with the same table */ + Schema *pSchema; /* Schema containing this index */ + u8 *aSortOrder; /* Array of size Index.nColumn. True==DESC, False==ASC */ + char **azColl; /* Array of collation sequence names for index */ +}; + +/* +** Each token coming out of the lexer is an instance of +** this structure. Tokens are also used as part of an expression. +** +** Note if Token.z==0 then Token.dyn and Token.n are undefined and +** may contain random values. Do not make any assuptions about Token.dyn +** and Token.n when Token.z==0. +*/ +struct Token { + const unsigned char *z; /* Text of the token. Not NULL-terminated! */ + unsigned dyn;// : 1; /* True for malloced memory, false for static */ + unsigned n;// : 31; /* Number of characters in this token */ +}; + +/* +** An instance of this structure contains information needed to generate +** code for a SELECT that contains aggregate functions. +** +** If Expr.op==TK_AGG_COLUMN or TK_AGG_FUNCTION then Expr.pAggInfo is a +** pointer to this structure. The Expr.iColumn field is the index in +** AggInfo.aCol[] or AggInfo.aFunc[] of information needed to generate +** code for that node. +** +** AggInfo.pGroupBy and AggInfo.aFunc.pExpr point to fields within the +** original Select structure that describes the SELECT statement. These +** fields do not need to be freed when deallocating the AggInfo structure. +*/ +struct AggInfo { + u8 directMode; /* Direct rendering mode means take data directly + ** from source tables rather than from accumulators */ + u8 useSortingIdx; /* In direct mode, reference the sorting index rather + ** than the source table */ + int sortingIdx; /* Cursor number of the sorting index */ + ExprList *pGroupBy; /* The group by clause */ + int nSortingColumn; /* Number of columns in the sorting index */ + struct AggInfo_col { /* For each column used in source tables */ + Table *pTab; /* Source table */ + int iTable; /* Cursor number of the source table */ + int iColumn; /* Column number within the source table */ + int iSorterColumn; /* Column number in the sorting index */ + int iMem; /* Memory location that acts as accumulator */ + Expr *pExpr; /* The original expression */ + } *aCol; + int nColumn; /* Number of used entries in aCol[] */ + int nColumnAlloc; /* Number of slots allocated for aCol[] */ + int nAccumulator; /* Number of columns that show through to the output. + ** Additional columns are used only as parameters to + ** aggregate functions */ + struct AggInfo_func { /* For each aggregate function */ + Expr *pExpr; /* Expression encoding the function */ + FuncDef *pFunc; /* The aggregate function implementation */ + int iMem; /* Memory location that acts as accumulator */ + int iDistinct; /* Ephermeral table used to enforce DISTINCT */ + } *aFunc; + int nFunc; /* Number of entries in aFunc[] */ + int nFuncAlloc; /* Number of slots allocated for aFunc[] */ +}; + +/* +** Each node of an expression in the parse tree is an instance +** of this structure. +** +** Expr.op is the opcode. The integer parser token codes are reused +** as opcodes here. For example, the parser defines TK_GE to be an integer +** code representing the ">=" operator. This same integer code is reused +** to represent the greater-than-or-equal-to operator in the expression +** tree. +** +** Expr.pRight and Expr.pLeft are subexpressions. Expr.pList is a list +** of argument if the expression is a function. +** +** Expr.token is the operator token for this node. For some expressions +** that have subexpressions, Expr.token can be the complete text that gave +** rise to the Expr. In the latter case, the token is marked as being +** a compound token. +** +** An expression of the form ID or ID.ID refers to a column in a table. +** For such expressions, Expr.op is set to TK_COLUMN and Expr.iTable is +** the integer cursor number of a VDBE cursor pointing to that table and +** Expr.iColumn is the column number for the specific column. If the +** expression is used as a result in an aggregate SELECT, then the +** value is also stored in the Expr.iAgg column in the aggregate so that +** it can be accessed after all aggregates are computed. +** +** If the expression is a function, the Expr.iTable is an integer code +** representing which function. If the expression is an unbound variable +** marker (a question mark character '?' in the original SQL) then the +** Expr.iTable holds the index number for that variable. +** +** If the expression is a subquery then Expr.iColumn holds an integer +** register number containing the result of the subquery. If the +** subquery gives a constant result, then iTable is -1. If the subquery +** gives a different answer at different times during statement processing +** then iTable is the address of a subroutine that computes the subquery. +** +** The Expr.pSelect field points to a SELECT statement. The SELECT might +** be the right operand of an IN operator. Or, if a scalar SELECT appears +** in an expression the opcode is TK_SELECT and Expr.pSelect is the only +** operand. +** +** If the Expr is of type OP_Column, and the table it is selecting from +** is a disk table or the "old.*" pseudo-table, then pTab points to the +** corresponding table definition. +*/ +struct Expr { + u8 op; /* Operation performed by this node */ + char affinity; /* The affinity of the column or 0 if not a column */ + u16 flags; /* Various flags. See below */ + CollSeq *pColl; /* The collation type of the column or 0 */ + Expr *pLeft, *pRight; /* Left and right subnodes */ + ExprList *pList; /* A list of expressions used as function arguments + ** or in " IN (aCol[] or ->aFunc[] */ + int iRightJoinTable; /* If EP_FromJoin, the right table of the join */ + Select *pSelect; /* When the expression is a sub-select. Also the + ** right side of " IN (