diff options
Diffstat (limited to 'plugins')
16 files changed, 977 insertions, 823 deletions
diff --git a/plugins/authenticator/shotwell/FlickrPublishingAuthenticator.vala b/plugins/authenticator/shotwell/FlickrPublishingAuthenticator.vala index 97629ed..5188ed6 100644 --- a/plugins/authenticator/shotwell/FlickrPublishingAuthenticator.vala +++ b/plugins/authenticator/shotwell/FlickrPublishingAuthenticator.vala @@ -15,6 +15,7 @@ namespace Publishing.Authenticator.Shotwell.Flickr { internal const string SERVICE_WELCOME_MESSAGE = _("You are not currently logged into Flickr.\n\nClick Log in to log into Flickr in your Web browser. You will have to authorize Shotwell Connect to link to your Flickr account."); + internal const string SERVICE_DISCLAIMER = "<b>This product uses the Flickr API but is not endorsed or certified by SmugMug, Inc.</b>"; internal class AuthenticationRequestTransaction : Publishing.RESTSupport.OAuth1.Transaction { public AuthenticationRequestTransaction(Publishing.RESTSupport.OAuth1.Session session) { @@ -55,7 +56,8 @@ namespace Publishing.Authenticator.Shotwell.Flickr { public override void on_page_load() { var uri = new Soup.URI(get_view().get_uri()); if (uri.scheme == "shotwell-auth" && this.auth_code == null) { - this.error(); + var form_data = Soup.Form.decode (uri.query); + this.auth_code = form_data.lookup("oauth_verifier"); } if (this.auth_code != null) { @@ -108,7 +110,7 @@ namespace Publishing.Authenticator.Shotwell.Flickr { debug("ACTION: installing login welcome pane"); host.set_service_locked(false); - host.install_welcome_pane(SERVICE_WELCOME_MESSAGE, on_welcome_pane_login_clicked); + host.install_welcome_pane("%s\n\n%s".printf(SERVICE_WELCOME_MESSAGE, SERVICE_DISCLAIMER), on_welcome_pane_login_clicked); } private void on_welcome_pane_login_clicked() { diff --git a/plugins/authenticator/shotwell/GoogleAuthenticator.vala b/plugins/authenticator/shotwell/GoogleAuthenticator.vala index f561197..75d8f37 100644 --- a/plugins/authenticator/shotwell/GoogleAuthenticator.vala +++ b/plugins/authenticator/shotwell/GoogleAuthenticator.vala @@ -23,7 +23,8 @@ namespace Publishing.Authenticator.Shotwell.Google { public override void on_page_load() { var uri = new Soup.URI(get_view().get_uri()); if (uri.scheme == REVERSE_CLIENT_ID && this.auth_code == null) { - this.error(); + var form_data = Soup.Form.decode (uri.query); + this.auth_code = form_data.lookup("code"); } if (this.auth_code != null) { diff --git a/plugins/authenticator/shotwell/ShotwellAuthenticatorFactory.vala b/plugins/authenticator/shotwell/ShotwellAuthenticatorFactory.vala index 0d813ac..36fb290 100644 --- a/plugins/authenticator/shotwell/ShotwellAuthenticatorFactory.vala +++ b/plugins/authenticator/shotwell/ShotwellAuthenticatorFactory.vala @@ -14,9 +14,9 @@ namespace Publishing.Authenticator { var list = new Gee.ArrayList<string>(); list.add("flickr"); list.add("facebook"); - list.add("picasa"); list.add("youtube"); list.add("tumblr"); + list.add("google-photos"); return list; } @@ -28,14 +28,13 @@ namespace Publishing.Authenticator { return new Shotwell.Flickr.Flickr(host); case "facebook": return new Shotwell.Facebook.Facebook(host); - case "picasa": - return new Shotwell.Google.Google("https://picasaweb.google.com/data/", _("You are not currently logged into Picasa Web Albums.\n\nClick Log in to log into Picasa Web Albums in your Web browser. You will have to authorize Shotwell Connect to link to your Picasa Web Albums account."), host); - case "youtube": return new Shotwell.Google.Google("https://gdata.youtube.com/", _("You are not currently logged into YouTube.\n\nYou must have already signed up for a Google account and set it up for use with YouTube to continue. You can set up most accounts by using your browser to log into the YouTube site at least once."), host); case "tumblr": return new Shotwell.Tumblr.Tumblr(host); - default: + case "google-photos": + return new Shotwell.Google.Google("https://www.googleapis.com/auth/photoslibrary", _("You are not currently logged into Google Photos.\n\nYou must have already signed up for a Google account and set it up for use with Google Photos.\n\nYou will have to authorize Shotwell to link to your Google Photos account."), host); + default: return null; } } diff --git a/plugins/common/RESTSupport.vala b/plugins/common/RESTSupport.vala index 482fd2c..5cd3768 100644 --- a/plugins/common/RESTSupport.vala +++ b/plugins/common/RESTSupport.vala @@ -444,6 +444,18 @@ public class Transaction { public void add_argument(string name, string value) { arguments += new Argument(name, value); } + + public void set_argument(string name, string value) { + foreach (var arg in arguments) { + if (arg.key == name) { + arg.value = value; + + return; + } + } + + add_argument(name, value); + } public string? get_endpoint_url() { return (endpoint_url != null) ? endpoint_url : parent_session.get_endpoint_url(); diff --git a/plugins/common/Resources.vala b/plugins/common/Resources.vala index 29c7294..ecbf2f8 100644 --- a/plugins/common/Resources.vala +++ b/plugins/common/Resources.vala @@ -42,7 +42,7 @@ public Gdk.Pixbuf[]? load_icon_set(GLib.File? icon_file) { try { icon = new Gdk.Pixbuf.from_file(icon_file.get_path()); } catch (Error err) { - warning("couldn't load icon set from %s.", icon_file.get_path()); + warning("couldn't load icon set from %s: %s", icon_file.get_path(), err.message); } if (icon != null) { @@ -57,9 +57,10 @@ public Gdk.Pixbuf[]? load_icon_set(GLib.File? icon_file) { public Gdk.Pixbuf[]? load_from_resource (string resource_path) { Gdk.Pixbuf? icon = null; try { - icon = new Gdk.Pixbuf.from_resource (resource_path); + debug ("Loading icon from %s", resource_path); + icon = new Gdk.Pixbuf.from_resource_at_scale (resource_path, 24, 24, true); } catch (Error error) { - warning ("Couldn't load icon set from %s", resource_path); + warning ("Couldn't load icon set from %s: %s", resource_path, error.message); } if (icon != null) { diff --git a/plugins/shotwell-publishing/PhotosPublisher.vala b/plugins/shotwell-publishing/PhotosPublisher.vala new file mode 100644 index 0000000..d878158 --- /dev/null +++ b/plugins/shotwell-publishing/PhotosPublisher.vala @@ -0,0 +1,551 @@ +/* Copyright 2016 Software Freedom Conservancy Inc. + * Copyright 2019 Jens Georg <mail@jensge.org> + * + * This software is licensed under the GNU LGPL (version 2.1 or later). + * See the COPYING file in this distribution. + */ + +namespace Publishing.GooglePhotos { +internal const string DEFAULT_ALBUM_NAME = N_("Shotwell Connect"); + +internal class Album { + public string name; + public string id; + + public Album(string name, string id) { + this.name = name; + this.id = id; + } +} + +internal class PublishingParameters { + public const int ORIGINAL_SIZE = -1; + + private string? target_album_name; + private string? target_album_id; + private bool album_public; + private bool strip_metadata; + private int major_axis_size_pixels; + private int major_axis_size_selection_id; + private string user_name; + private Album[] albums; + private Spit.Publishing.Publisher.MediaType media_type; + + public PublishingParameters() { + this.user_name = "[unknown]"; + this.target_album_name = null; + this.target_album_id = null; + this.major_axis_size_selection_id = 0; + this.major_axis_size_pixels = ORIGINAL_SIZE; + this.album_public = false; + this.albums = null; + this.strip_metadata = false; + this.media_type = Spit.Publishing.Publisher.MediaType.PHOTO; + } + + public string get_target_album_name() { + return target_album_name; + } + + public void set_target_album_name(string target_album_name) { + this.target_album_name = target_album_name; + } + + public void set_target_album_entry_id(string target_album_id) { + this.target_album_id = target_album_id; + } + + public string get_target_album_entry_id() { + return this.target_album_id; + } + + public string get_user_name() { + return user_name; + } + + public void set_user_name(string user_name) { + this.user_name = user_name; + } + + public Album[] get_albums() { + return albums; + } + + public void set_albums(Album[] albums) { + this.albums = albums; + } + + + public void set_major_axis_size_pixels(int pixels) { + this.major_axis_size_pixels = pixels; + } + + public int get_major_axis_size_pixels() { + return major_axis_size_pixels; + } + + public void set_major_axis_size_selection_id(int selection_id) { + this.major_axis_size_selection_id = selection_id; + } + + public int get_major_axis_size_selection_id() { + return major_axis_size_selection_id; + } + + public void set_strip_metadata(bool strip_metadata) { + this.strip_metadata = strip_metadata; + } + + public bool get_strip_metadata() { + return strip_metadata; + } + + public void set_media_type(Spit.Publishing.Publisher.MediaType media_type) { + this.media_type = media_type; + } + + public Spit.Publishing.Publisher.MediaType get_media_type() { + return media_type; + } +} + +private class MediaCreationTransaction : Publishing.RESTSupport.GooglePublisher.AuthenticatedTransaction { + private const string ENDPOINT_URL = "https://photoslibrary.googleapis.com/v1/mediaItems:batchCreate"; + private string[] upload_tokens; + private string[] titles; + private string album_id; + + public MediaCreationTransaction(Publishing.RESTSupport.GoogleSession session, + string[] upload_tokens, + string[] titles, + string album_id) { + base(session, ENDPOINT_URL, Publishing.RESTSupport.HttpMethod.POST); + assert(upload_tokens.length == titles.length); + this.upload_tokens = upload_tokens; + this.album_id = album_id; + this.titles = titles; + } + + public override void execute () throws Spit.Publishing.PublishingError { + var builder = new Json.Builder(); + builder.begin_object(); + builder.set_member_name("albumId"); + builder.add_string_value(this.album_id); + builder.set_member_name("newMediaItems"); + builder.begin_array(); + for (var i = 0; i < this.upload_tokens.length; i++) { + builder.begin_object(); + builder.set_member_name("description"); + builder.add_string_value(this.titles[i]); + builder.set_member_name("simpleMediaItem"); + builder.begin_object(); + builder.set_member_name("uploadToken"); + builder.add_string_value(this.upload_tokens[i]); + builder.end_object(); + builder.end_object(); + } + builder.end_array(); + builder.end_object(); + set_custom_payload(Json.to_string (builder.get_root (), false), "application/json"); + + base.execute(); + } +} + +private class AlbumCreationTransaction : Publishing.RESTSupport.GooglePublisher.AuthenticatedTransaction { + private const string ENDPOINT_URL = "https://photoslibrary.googleapis.com/v1/albums"; + private string title; + + public AlbumCreationTransaction(Publishing.RESTSupport.GoogleSession session, + string title) { + base(session, ENDPOINT_URL, Publishing.RESTSupport.HttpMethod.POST); + this.title = title; + } + + public override void execute () throws Spit.Publishing.PublishingError { + var builder = new Json.Builder(); + builder.begin_object(); + builder.set_member_name("album"); + builder.begin_object(); + builder.set_member_name("title"); + builder.add_string_value(this.title); + builder.end_object(); + builder.end_object(); + set_custom_payload(Json.to_string (builder.get_root (), false), "application/json"); + + base.execute(); + } +} + +private class AlbumDirectoryTransaction : Publishing.RESTSupport.GooglePublisher.AuthenticatedTransaction { + private const string ENDPOINT_URL = "https://photoslibrary.googleapis.com/v1/albums"; + private Album[] albums = new Album[0]; + + public AlbumDirectoryTransaction(Publishing.RESTSupport.GoogleSession session) { + base(session, ENDPOINT_URL, Publishing.RESTSupport.HttpMethod.GET); + this.completed.connect(on_internal_continue_pagination); + } + + public Album[] get_albums() { + return this.albums; + } + + private void on_internal_continue_pagination() { + try { + debug(this.get_response()); + var json = Json.from_string (this.get_response()); + var object = json.get_object (); + if (!object.has_member ("albums")) { + return; + } + + var pagination_token_node = object.get_member ("nextPageToken"); + var response_albums = object.get_member ("albums").get_array(); + response_albums.foreach_element( (a, b, element) => { + var album = element.get_object(); + var is_writable = album.get_member("isWriteable"); + if (is_writable != null && is_writable.get_boolean()) + albums += new Album(album.get_string_member("title"), album.get_string_member("id")); + }); + + if (pagination_token_node != null) { + this.set_argument ("pageToken", pagination_token_node.get_string ()); + Signal.stop_emission_by_name (this, "completed"); + Idle.add(() => { + try { + this.execute(); + } catch (Spit.Publishing.PublishingError error) { + this.network_error(error); + } + + return false; + }); + } + } catch (Error error) { + critical ("Got error %s while trying to parse response, delegating", error.message); + this.network_error(new Spit.Publishing.PublishingError.MALFORMED_RESPONSE(error.message)); + } + } +} + +public class Publisher : Publishing.RESTSupport.GooglePublisher { + private Spit.Publishing.Authenticator authenticator; + private bool running = false; + private PublishingParameters publishing_parameters; + private Spit.Publishing.ProgressCallback progress_reporter; + + public Publisher(Spit.Publishing.Service service, + Spit.Publishing.PluginHost host) { + base(service, host, "https://www.googleapis.com/auth/photoslibrary"); + + this.publishing_parameters = new PublishingParameters(); + load_parameters_from_configuration_system(publishing_parameters); + + var media_type = Spit.Publishing.Publisher.MediaType.NONE; + foreach(Spit.Publishing.Publishable p in host.get_publishables()) + media_type |= p.get_media_type(); + + publishing_parameters.set_media_type(media_type); + } + + private void load_parameters_from_configuration_system(PublishingParameters parameters) { + parameters.set_major_axis_size_selection_id(get_host().get_config_int("default-size", 0)); + parameters.set_strip_metadata(get_host().get_config_bool("strip-metadata", false)); + parameters.set_target_album_name(get_host().get_config_string("last-album", null)); + } + + private void save_parameters_to_configuration_system(PublishingParameters parameters) { + get_host().set_config_int("default-size", parameters.get_major_axis_size_selection_id()); + get_host().set_config_bool("strip_metadata", parameters.get_strip_metadata()); + get_host().set_config_string("last-album", parameters.get_target_album_name()); + } + + protected override void on_login_flow_complete() { + debug("EVENT: OAuth login flow complete."); + this.publishing_parameters.set_user_name (this.authenticator.get_authentication_parameter()["UserName"].get_string()); + + get_host().install_account_fetch_wait_pane(); + get_host().set_service_locked(true); + + AlbumDirectoryTransaction txn = new AlbumDirectoryTransaction(get_session()); + txn.completed.connect(on_initial_album_fetch_complete); + txn.network_error.connect(on_initial_album_fetch_error); + + try { + txn.execute(); + } catch (Spit.Publishing.PublishingError error) { + on_initial_album_fetch_error(txn, error); + } + } + + private void on_initial_album_fetch_complete(Publishing.RESTSupport.Transaction txn) { + txn.completed.disconnect(on_initial_album_fetch_complete); + txn.network_error.disconnect(on_initial_album_fetch_error); + + if (!is_running()) + return; + + debug("EVENT: finished fetching album information."); + + display_account_information((AlbumDirectoryTransaction)txn); + } + + private void on_initial_album_fetch_error(Publishing.RESTSupport.Transaction txn, + Spit.Publishing.PublishingError error) { + txn.completed.disconnect(on_initial_album_fetch_complete); + txn.network_error.disconnect(on_initial_album_fetch_error); + + if (!is_running()) + return; + + debug("EVENT: fetching album information failed; response = '%s'.", + txn.get_response()); + + if (txn.get_status_code() == 403 || txn.get_status_code() == 404) { + do_logout(); + } else { + // If we get any other kind of error, we can't recover, so just post it to the user + get_host().post_error(error); + } + } + + private void display_account_information(AlbumDirectoryTransaction txn) { + debug("ACTION: parsing album information"); + this.publishing_parameters.set_albums(txn.get_albums()); + + show_publishing_options_pane(); + } + + private void show_publishing_options_pane() { + debug("ACTION: showing publishing options pane."); + + var opts_pane = new PublishingOptionsPane(this.publishing_parameters, this.authenticator.can_logout()); + opts_pane.publish.connect(on_publishing_options_publish); + opts_pane.logout.connect(on_publishing_options_logout); + get_host().install_dialog_pane(opts_pane); + + get_host().set_service_locked(false); + } + + private void on_publishing_options_logout() { + if (!is_running()) + return; + + debug("EVENT: user clicked 'Logout' in the publishing options pane."); + + do_logout(); + } + + private void on_publishing_options_publish() { + if (!is_running()) + return; + + debug("EVENT: user clicked 'Publish' in the publishing options pane."); + + save_parameters_to_configuration_system(publishing_parameters); + + if (publishing_parameters.get_target_album_entry_id () != null) { + do_upload(); + } else { + do_create_album(); + } + } + + private void do_create_album() { + debug("ACTION: Creating album"); + assert(publishing_parameters.get_target_album_entry_id () == null); + + get_host().set_service_locked(true); + + var txn = new AlbumCreationTransaction(get_session(), publishing_parameters.get_target_album_name()); + txn.completed.connect(on_album_create_complete); + txn.network_error.connect(on_album_create_error); + + try { + txn.execute(); + } catch (Spit.Publishing.PublishingError error) { + on_album_create_error(txn, error); + } + } + + private void on_album_create_complete(Publishing.RESTSupport.Transaction txn) { + txn.completed.disconnect(on_album_create_complete); + txn.network_error.disconnect(on_album_create_error); + + if (!is_running()) + return; + + debug("EVENT: finished creating album information: %s", txn.get_response()); + + try { + var node = Json.from_string(txn.get_response()); + var object = node.get_object(); + publishing_parameters.set_target_album_entry_id (object.get_string_member ("id")); + + do_upload(); + } catch (Error error) { + on_album_create_error(txn, new Spit.Publishing.PublishingError.MALFORMED_RESPONSE (error.message)); + } + } + + private void on_album_create_error(Publishing.RESTSupport.Transaction txn, + Spit.Publishing.PublishingError error) { + txn.completed.disconnect(on_initial_album_fetch_complete); + txn.network_error.disconnect(on_initial_album_fetch_error); + + if (!is_running()) + return; + + debug("EVENT: creating album failed; response = '%s'.", + txn.get_response()); + + if (txn.get_status_code() == 403 || txn.get_status_code() == 404) { + do_logout(); + } else { + // If we get any other kind of error, we can't recover, so just post it to the user + get_host().post_error(error); + } + } + + protected override void do_logout() { + debug("ACTION: logging out user."); + get_session().deauthenticate(); + + if (this.authenticator.can_logout()) { + this.authenticator.logout(); + this.authenticator.authenticate(); + } + } + + private void do_upload() { + debug("ACTION: uploading media items to remote server."); + + get_host().set_service_locked(true); + + progress_reporter = get_host().serialize_publishables( + publishing_parameters.get_major_axis_size_pixels(), + publishing_parameters.get_strip_metadata()); + + // Serialization is a long and potentially cancellable operation, so before we use + // the publishables, make sure that the publishing interaction is still running. If it + // isn't the publishing environment may be partially torn down so do a short-circuit + // return + if (!is_running()) + return; + + Spit.Publishing.Publishable[] publishables = get_host().get_publishables(); + Uploader uploader = new Uploader(get_session(), publishables, publishing_parameters); + + uploader.upload_complete.connect(on_upload_complete); + uploader.upload_error.connect(on_upload_error); + + uploader.upload(on_upload_status_updated); + } + + private void on_upload_status_updated(int file_number, double completed_fraction) { + if (!is_running()) + return; + + debug("EVENT: uploader reports upload %.2f percent complete.", 100.0 * completed_fraction); + + assert(progress_reporter != null); + + progress_reporter(file_number, completed_fraction); + } + + private void on_upload_complete(Publishing.RESTSupport.BatchUploader uploader, + int num_published) { + if (!is_running()) + return; + + debug("EVENT: uploader reports upload complete; %d items published.", num_published); + + uploader.upload_complete.disconnect(on_upload_complete); + uploader.upload_error.disconnect(on_upload_error); + + var txn = new MediaCreationTransaction(get_session(), + ((Uploader) uploader).upload_tokens, + ((Uploader) uploader).titles, + publishing_parameters.get_target_album_entry_id()); + + txn.completed.connect(on_media_creation_complete); + txn.network_error.connect(on_media_creation_error); + + try { + txn.execute(); + } catch (Spit.Publishing.PublishingError error) { + on_media_creation_error(txn, error); + } + } + + private void on_upload_error(Publishing.RESTSupport.BatchUploader uploader, + Spit.Publishing.PublishingError err) { + if (!is_running()) + return; + + debug("EVENT: uploader reports upload error = '%s'.", err.message); + + uploader.upload_complete.disconnect(on_upload_complete); + uploader.upload_error.disconnect(on_upload_error); + + get_host().post_error(err); + } + + private void on_media_creation_complete(Publishing.RESTSupport.Transaction txn) { + txn.completed.disconnect(on_media_creation_complete); + txn.network_error.disconnect(on_media_creation_error); + + if (!is_running()) + return; + + debug("EVENT: Media creation reports success."); + + get_host().set_service_locked(false); + get_host().install_success_pane(); + } + + private void on_media_creation_error(Publishing.RESTSupport.Transaction txn, + Spit.Publishing.PublishingError err) { + txn.completed.disconnect(on_media_creation_complete); + txn.network_error.disconnect(on_media_creation_error); + + if (!is_running()) + return; + + debug("EVENT: Media creation reports error: %s", err.message); + + get_host().post_error(err); + } + + public override bool is_running() { + return running; + } + + public override void start() { + debug("GooglePhotos.Publisher: start() invoked."); + + if (is_running()) + return; + + running = true; + + this.authenticator.authenticate(); + } + + public override void stop() { + debug("GooglePhotos.Publisher: stop() invoked."); + + get_session().stop_transactions(); + + running = false; + } + + protected override Spit.Publishing.Authenticator get_authenticator() { + if (this.authenticator == null) { + this.authenticator = Publishing.Authenticator.Factory.get_instance().create("google-photos", get_host()); + } + + return this.authenticator; + } +} +} // namespace Publishing.GooglePhotos diff --git a/plugins/shotwell-publishing/PhotosPublishingPane.vala b/plugins/shotwell-publishing/PhotosPublishingPane.vala new file mode 100644 index 0000000..d1b00d6 --- /dev/null +++ b/plugins/shotwell-publishing/PhotosPublishingPane.vala @@ -0,0 +1,150 @@ +/* Copyright 2016 Software Freedom Conservancy Inc. + * Copyright 2019 Jens Georg <mail@jensge.org> + * + * This software is licensed under the GNU LGPL (version 2.1 or later). + * See the COPYING file in this distribution. + */ + +namespace Publishing.GooglePhotos { +[GtkTemplate (ui = "/org/gnome/Shotwell/Publishing/google_photos_publishing_options_pane.ui")] +internal class PublishingOptionsPane : Gtk.Box, Spit.Publishing.DialogPane { + private struct SizeDescription { + public string name; + public int major_axis_pixels; + } + + private const SizeDescription size_descriptions[] = { + { N_("Small (640 × 480 pixels)"), 640}, + { N_("Medium (1024 × 768 pixels)"), 1024 }, + { N_("Recommended (1600 × 1200 pixels)"), 1600}, + { N_("Google+ (2048 × 1536 pixels)"), 2048}, + { N_("Original Size"), PublishingParameters.ORIGINAL_SIZE } + }; + + [GtkChild] + private Gtk.Button logout_button; + [GtkChild] + private Gtk.Button publish_button; + [GtkChild] + private Gtk.RadioButton existing_album_radio; + [GtkChild] + private Gtk.ComboBoxText existing_albums_combo; + [GtkChild] + private Gtk.ComboBoxText size_combo; + [GtkChild] + private Gtk.Label publish_to_label; + [GtkChild] + private Gtk.Label login_identity_label; + [GtkChild] + private Gtk.CheckButton strip_metadata_check; + [GtkChild] + private Gtk.RadioButton new_album_radio; + [GtkChild] + private Gtk.Entry new_album_entry; + + public signal void publish(); + public signal void logout(); + + private PublishingParameters parameters; + + public PublishingOptionsPane(PublishingParameters parameters, bool can_logout) { + Object(); + this.parameters = parameters; + + if (!can_logout) { + logout_button.parent.remove(logout_button); + } + + // populate any widgets whose contents are programmatically-generated. + login_identity_label.set_label(_("You are logged into Google Photos as %s.").printf( + parameters.get_user_name())); + strip_metadata_check.set_active(parameters.get_strip_metadata()); + + if((parameters.get_media_type() & Spit.Publishing.Publisher.MediaType.PHOTO) == 0) { + publish_to_label.set_label(_("Videos will appear in:")); + size_combo.set_visible(false); + size_combo.set_sensitive(false); + } + else { + publish_to_label.set_label(_("Photos will appear in:")); + foreach(SizeDescription desc in size_descriptions) { + size_combo.append_text(desc.name); + } + size_combo.set_visible(true); + size_combo.set_sensitive(true); + size_combo.set_active(parameters.get_major_axis_size_selection_id()); + } + + existing_album_radio.bind_property("active", existing_albums_combo, "sensitive", GLib.BindingFlags.SYNC_CREATE); + new_album_radio.bind_property("active", new_album_entry, "sensitive", GLib.BindingFlags.SYNC_CREATE); + + publish_button.clicked.connect (on_publish_clicked); + logout_button.clicked.connect (on_logout_clicked); + } + + // DialogPane interface + public Gtk.Widget get_widget() { + return this; + } + + public Spit.Publishing.DialogPane.GeometryOptions get_preferred_geometry() { + return Spit.Publishing.DialogPane.GeometryOptions.NONE; + } + + public void on_pane_installed() { + int default_album_id = -1; + string last_album = parameters.get_target_album_name(); + + var albums = parameters.get_albums(); + + for (int i = 0; i < albums.length; i++) { + existing_albums_combo.append_text(albums[i].name); + // Activate last known album id. If none was chosen, either use the old default (Shotwell connect) + // or the new "Default album" album for Google Photos + if (albums[i].name == last_album || + ((albums[i].name == DEFAULT_ALBUM_NAME || albums[i].name == _("Default album")) && default_album_id == -1)) + default_album_id = i; + } + + if (default_album_id >= 0) { + existing_albums_combo.set_active(default_album_id); + existing_album_radio.set_active(true); + } + + if (albums.length == 0) { + existing_album_radio.set_sensitive(false); + new_album_radio.set_active(true); + } + } + + public void on_pane_uninstalled() { + } + + private void on_publish_clicked() { + // size_combo won't have been set to anything useful if this is the first time we've + // published to Google Photos, and/or we've only published video before, so it may be negative, + // indicating nothing was selected. Clamp it to a valid value... + int size_combo_last_active = (size_combo.get_active() >= 0) ? size_combo.get_active() : 0; + + parameters.set_major_axis_size_selection_id(size_combo_last_active); + parameters.set_major_axis_size_pixels( + size_descriptions[size_combo_last_active].major_axis_pixels); + parameters.set_strip_metadata(strip_metadata_check.get_active()); + + Album[] albums = parameters.get_albums(); + + if (new_album_radio.get_active()) { + parameters.set_target_album_name(new_album_entry.get_text()); + } else { + parameters.set_target_album_name(albums[existing_albums_combo.get_active()].name); + parameters.set_target_album_entry_id(albums[existing_albums_combo.get_active()].id); + } + + publish(); + } + + private void on_logout_clicked() { + logout(); + } + } +} diff --git a/plugins/shotwell-publishing/PhotosService.vala b/plugins/shotwell-publishing/PhotosService.vala new file mode 100644 index 0000000..8e328f4 --- /dev/null +++ b/plugins/shotwell-publishing/PhotosService.vala @@ -0,0 +1,58 @@ +/* Copyright 2016 Software Freedom Conservancy Inc. + * Copyright 2019 Jens Georg <mail@jensge.org> + * + * This software is licensed under the GNU LGPL (version 2.1 or later). + * See the COPYING file in this distribution. + */ + +namespace Publishing.GooglePhotos { + +public class Service : Object, Spit.Pluggable, Spit.Publishing.Service { + private const string ICON_FILENAME = "google-photos.svg"; + + private static Gdk.Pixbuf[] icon_pixbuf_set = null; + + static construct { + icon_pixbuf_set = Resources.load_from_resource(Resources.RESOURCE_PATH + "/" + ICON_FILENAME); + } + + public Service(GLib.File resource_directory) {} + + public int get_pluggable_interface(int min_host_interface, int max_host_interface) { + return Spit.negotiate_interfaces(min_host_interface, max_host_interface, + Spit.Publishing.CURRENT_INTERFACE); + } + + public unowned string get_id() { + return "org.gnome.shotwell.publishing.google-photos"; + } + + public unowned string get_pluggable_name() { + return "Google Photos"; + } + + public void get_info(ref Spit.PluggableInfo info) { + info.authors = "Jens Georg"; + info.copyright = _("Copyright 2019 Jens Georg <mail@jensge.org>"); + info.translators = Resources.TRANSLATORS; + info.version = _VERSION; + info.website_name = Resources.WEBSITE_NAME; + info.website_url = Resources.WEBSITE_URL; + info.is_license_wordwrapped = false; + info.license = Resources.LICENSE; + info.icons = icon_pixbuf_set; + } + + public Spit.Publishing.Publisher create_publisher(Spit.Publishing.PluginHost host) { + return new Publishing.GooglePhotos.Publisher(this, host); + } + + public Spit.Publishing.Publisher.MediaType get_supported_media() { + return (Spit.Publishing.Publisher.MediaType.PHOTO | + Spit.Publishing.Publisher.MediaType.VIDEO); + } + + public void activation(bool enabled) { + } +} +} // namespace GooglePhotos diff --git a/plugins/shotwell-publishing/PhotosUploader.vala b/plugins/shotwell-publishing/PhotosUploader.vala new file mode 100644 index 0000000..83137ee --- /dev/null +++ b/plugins/shotwell-publishing/PhotosUploader.vala @@ -0,0 +1,104 @@ +/* Copyright 2016 Software Freedom Conservancy Inc. + * Copyright 2019 Jens Georg <mail@jensge.org> + * + * This software is licensed under the GNU LGPL (version 2.1 or later). + * See the COPYING file in this distribution. + */ + +namespace Publishing.GooglePhotos { + +internal class UploadTransaction : Publishing.RESTSupport.GooglePublisher.AuthenticatedTransaction { + private PublishingParameters parameters; + private Publishing.RESTSupport.GoogleSession session; + private Spit.Publishing.Publishable publishable; + private MappedFile mapped_file; + + public UploadTransaction(Publishing.RESTSupport.GoogleSession session, + PublishingParameters parameters, Spit.Publishing.Publishable publishable) { + base(session, "https://photoslibrary.googleapis.com/v1/uploads", + Publishing.RESTSupport.HttpMethod.POST); + assert(session.is_authenticated()); + + this.session = session; + this.parameters = parameters; + this.publishable = publishable; + } + + public Spit.Publishing.Publishable get_publishable() { + return this.publishable; + } + + public override void execute() throws Spit.Publishing.PublishingError { + var basename = publishable.get_param_string(Spit.Publishing.Publishable.PARAM_STRING_BASENAME); + + // attempt to map the binary image data from disk into memory + try { + mapped_file = new MappedFile(publishable.get_serialized_file().get_path(), false); + } catch (FileError e) { + string msg = "Google Photos: couldn't read data from %s: %s".printf( + publishable.get_serialized_file().get_path(), e.message); + warning("%s", msg); + + throw new Spit.Publishing.PublishingError.LOCAL_FILE_ERROR(msg); + } + + unowned uint8[] photo_data = (uint8[]) mapped_file.get_contents(); + photo_data.length = (int) mapped_file.get_length(); + + // bind the binary image data read from disk into a Soup.Buffer object so that we + // can attach it to the multipart request, then actaully append the buffer + // to the multipart request. Then, set the MIME type for this part. + Soup.Buffer bindable_data = new Soup.Buffer(Soup.MemoryUse.TEMPORARY, photo_data); + + // create a message that can be sent over the wire whose payload is the multipart container + // that we've been building up + var outbound_message = new Soup.Message ("POST", get_endpoint_url()); + outbound_message.request_headers.append("Authorization", "Bearer " + + session.get_access_token()); + outbound_message.request_headers.append("X-Goog-Upload-File-Name", basename); + outbound_message.request_headers.append("X-Goog-Upload-Protocol", "raw"); + outbound_message.request_headers.set_content_type("application/octet-stream", null); + outbound_message.request_body.append_buffer (bindable_data); + set_message(outbound_message); + + // send the message and get its response + set_is_executed(true); + send(); + } +} + +internal class Uploader : Publishing.RESTSupport.BatchUploader { + private PublishingParameters parameters; + + public string[] upload_tokens = new string[0]; + public string[] titles = new string[0]; + + public Uploader(Publishing.RESTSupport.GoogleSession session, + Spit.Publishing.Publishable[] publishables, PublishingParameters parameters) { + base(session, publishables); + + this.parameters = parameters; + } + + protected override Publishing.RESTSupport.Transaction create_transaction( + Spit.Publishing.Publishable publishable) { + var txn = new UploadTransaction((Publishing.RESTSupport.GoogleSession) get_session(), + parameters, get_current_publishable()); + txn.completed.connect(this.on_transaction_completed); + + return txn; + } + + private void on_transaction_completed (Publishing.RESTSupport.Transaction txn) { + txn.completed.disconnect (on_transaction_completed); + + this.upload_tokens += txn.get_response(); + var title = ((UploadTransaction)txn).get_publishable().get_publishing_name(); + var publishable = ((UploadTransaction)txn).get_publishable(); + if (title == null || title == "") { + title = publishable.get_param_string(Spit.Publishing.Publishable.PARAM_STRING_BASENAME); + } + this.titles += title; + } +} +} diff --git a/plugins/shotwell-publishing/PicasaPublishing.vala b/plugins/shotwell-publishing/PicasaPublishing.vala deleted file mode 100644 index d72ce6d..0000000 --- a/plugins/shotwell-publishing/PicasaPublishing.vala +++ /dev/null @@ -1,770 +0,0 @@ -/* Copyright 2016 Software Freedom Conservancy Inc. - * - * This software is licensed under the GNU Lesser General Public License - * (version 2.1 or later). See the COPYING file in this distribution. - */ - -public class PicasaService : Object, Spit.Pluggable, Spit.Publishing.Service { - private const string ICON_FILENAME = "picasa.png"; - - private static Gdk.Pixbuf[] icon_pixbuf_set = null; - - public PicasaService(GLib.File resource_directory) { - if (icon_pixbuf_set == null) - icon_pixbuf_set = - Resources.load_from_resource(Resources.RESOURCE_PATH + "/" + ICON_FILENAME); - } - - public int get_pluggable_interface(int min_host_interface, int max_host_interface) { - return Spit.negotiate_interfaces(min_host_interface, max_host_interface, - Spit.Publishing.CURRENT_INTERFACE); - } - - public unowned string get_id() { - return "org.yorba.shotwell.publishing.picasa"; - } - - public unowned string get_pluggable_name() { - return "Picasa Web Albums"; - } - - public void get_info(ref Spit.PluggableInfo info) { - info.authors = "Lucas Beeler"; - info.copyright = _("Copyright 2016 Software Freedom Conservancy Inc."); - info.translators = Resources.TRANSLATORS; - info.version = _VERSION; - info.website_name = Resources.WEBSITE_NAME; - info.website_url = Resources.WEBSITE_URL; - info.is_license_wordwrapped = false; - info.license = Resources.LICENSE; - info.icons = icon_pixbuf_set; - } - - public Spit.Publishing.Publisher create_publisher(Spit.Publishing.PluginHost host) { - return new Publishing.Picasa.PicasaPublisher(this, host); - } - - public Spit.Publishing.Publisher.MediaType get_supported_media() { - return (Spit.Publishing.Publisher.MediaType.PHOTO | - Spit.Publishing.Publisher.MediaType.VIDEO); - } - - public void activation(bool enabled) { - } -} - -namespace Publishing.Picasa { - -internal const string DEFAULT_ALBUM_NAME = _("Shotwell Connect"); - -public class PicasaPublisher : Publishing.RESTSupport.GooglePublisher { - private const string DEFAULT_ALBUM_FEED_URL = "https://picasaweb.google.com/data/feed/api/user/default/albumid/default"; - private bool running; - private Spit.Publishing.ProgressCallback progress_reporter; - private PublishingParameters publishing_parameters; - private Spit.Publishing.Authenticator authenticator; - - public PicasaPublisher(Spit.Publishing.Service service, - Spit.Publishing.PluginHost host) { - base(service, host, "https://picasaweb.google.com/data/"); - - this.publishing_parameters = new PublishingParameters(); - load_parameters_from_configuration_system(publishing_parameters); - - Spit.Publishing.Publisher.MediaType media_type = Spit.Publishing.Publisher.MediaType.NONE; - foreach(Spit.Publishing.Publishable p in host.get_publishables()) - media_type |= p.get_media_type(); - publishing_parameters.set_media_type(media_type); - - this.progress_reporter = null; - } - - private Album[] extract_albums_helper(Xml.Node* document_root) - throws Spit.Publishing.PublishingError { - Album[] result = new Album[0]; - - Xml.Node* doc_node_iter = null; - if (document_root->name == "feed") - doc_node_iter = document_root->children; - else if (document_root->name == "entry") - doc_node_iter = document_root; - else - throw new Spit.Publishing.PublishingError.MALFORMED_RESPONSE("response root node " + - "isn't a <feed> or <entry>"); - - // Add album that will push to the default feed for all the new users - result += new Album(_("Default album"), DEFAULT_ALBUM_FEED_URL); - - for ( ; doc_node_iter != null; doc_node_iter = doc_node_iter->next) { - if (doc_node_iter->name != "entry") - continue; - - string name_val = null; - string url_val = null; - Xml.Node* album_node_iter = doc_node_iter->children; - for ( ; album_node_iter != null; album_node_iter = album_node_iter->next) { - if (album_node_iter->name == "title") { - name_val = album_node_iter->get_content(); - } else if (album_node_iter->name == "id") { - // we only want nodes in the default namespace -- the feed that we get back - // from Google also defines <entry> child nodes named <id> in the gphoto and - // media namespaces - if (album_node_iter->ns->prefix != null) - continue; - url_val = album_node_iter->get_content(); - } - } - - // If default album is present in the result list, just skip it because we added it on top anyway - if (url_val == DEFAULT_ALBUM_FEED_URL) { - continue; - } - - result += new Album(name_val, url_val); - } - - return result; - } - - private void load_parameters_from_configuration_system(PublishingParameters parameters) { - parameters.set_major_axis_size_selection_id(get_host().get_config_int("default-size", 0)); - parameters.set_strip_metadata(get_host().get_config_bool("strip-metadata", false)); - parameters.set_target_album_name(get_host().get_config_string("last-album", null)); - } - - private void save_parameters_to_configuration_system(PublishingParameters parameters) { - get_host().set_config_int("default-size", parameters.get_major_axis_size_selection_id()); - get_host().set_config_bool("strip_metadata", parameters.get_strip_metadata()); - get_host().set_config_string("last-album", parameters.get_target_album_name()); - } - - protected override void on_login_flow_complete() { - debug("EVENT: OAuth login flow complete."); - - - publishing_parameters.set_user_name(get_session().get_user_name()); - - do_fetch_account_information(); - } - - private void on_initial_album_fetch_complete(Publishing.RESTSupport.Transaction txn) { - txn.completed.disconnect(on_initial_album_fetch_complete); - txn.network_error.disconnect(on_initial_album_fetch_error); - - if (!is_running()) - return; - - debug("EVENT: finished fetching account and album information."); - - do_parse_and_display_account_information((AlbumDirectoryTransaction) txn); - } - - private void on_initial_album_fetch_error(Publishing.RESTSupport.Transaction bad_txn, - Spit.Publishing.PublishingError err) { - bad_txn.completed.disconnect(on_initial_album_fetch_complete); - bad_txn.network_error.disconnect(on_initial_album_fetch_error); - - if (!is_running()) - return; - - debug("EVENT: fetching account and album information failed; response = '%s'.", - bad_txn.get_response()); - - if (bad_txn.get_status_code() == 403 || bad_txn.get_status_code() == 404) { - do_logout(); - } else { - // If we get any other kind of error, we can't recover, so just post it to the user - get_host().post_error(err); - } - } - - private void on_publishing_options_logout() { - if (!is_running()) - return; - - debug("EVENT: user clicked 'Logout' in the publishing options pane."); - - do_logout(); - } - - private void on_publishing_options_publish() { - if (!is_running()) - return; - - debug("EVENT: user clicked 'Publish' in the publishing options pane."); - - save_parameters_to_configuration_system(publishing_parameters); - - do_upload(); - } - - private void on_upload_status_updated(int file_number, double completed_fraction) { - if (!is_running()) - return; - - debug("EVENT: uploader reports upload %.2f percent complete.", 100.0 * completed_fraction); - - assert(progress_reporter != null); - - progress_reporter(file_number, completed_fraction); - } - - private void on_upload_complete(Publishing.RESTSupport.BatchUploader uploader, - int num_published) { - if (!is_running()) - return; - - debug("EVENT: uploader reports upload complete; %d items published.", num_published); - - uploader.upload_complete.disconnect(on_upload_complete); - uploader.upload_error.disconnect(on_upload_error); - - do_show_success_pane(); - } - - private void on_upload_error(Publishing.RESTSupport.BatchUploader uploader, - Spit.Publishing.PublishingError err) { - if (!is_running()) - return; - - debug("EVENT: uploader reports upload error = '%s'.", err.message); - - uploader.upload_complete.disconnect(on_upload_complete); - uploader.upload_error.disconnect(on_upload_error); - - get_host().post_error(err); - } - - private void do_fetch_account_information() { - debug("ACTION: fetching account and album information."); - - get_host().install_account_fetch_wait_pane(); - get_host().set_service_locked(true); - - AlbumDirectoryTransaction directory_trans = - new AlbumDirectoryTransaction(get_session()); - directory_trans.network_error.connect(on_initial_album_fetch_error); - directory_trans.completed.connect(on_initial_album_fetch_complete); - - try { - directory_trans.execute(); - } catch (Spit.Publishing.PublishingError err) { - // don't post the error here -- some errors are recoverable so let's let the error - // handler function sort out whether the error is recoverable or not. If the error - // isn't recoverable, the error handler will post the error to the host - on_initial_album_fetch_error(directory_trans, err); - } - } - - private void do_parse_and_display_account_information(AlbumDirectoryTransaction transaction) { - debug("ACTION: parsing account and album information from server response XML"); - - Publishing.RESTSupport.XmlDocument response_doc; - try { - response_doc = Publishing.RESTSupport.XmlDocument.parse_string( - transaction.get_response(), AlbumDirectoryTransaction.validate_xml); - } catch (Spit.Publishing.PublishingError err) { - get_host().post_error(err); - return; - } - - try { - publishing_parameters.set_albums(extract_albums_helper(response_doc.get_root_node())); - } catch (Spit.Publishing.PublishingError err) { - get_host().post_error(err); - return; - } - - do_show_publishing_options_pane(); - } - - private void do_show_publishing_options_pane() { - debug("ACTION: showing publishing options pane."); - Gtk.Builder builder = new Gtk.Builder(); - - try { - builder.add_from_resource(Resources.RESOURCE_PATH + "/" + "picasa_publishing_options_pane.ui"); - } catch (Error e) { - warning("Could not parse UI file! Error: %s.", e.message); - get_host().post_error( - new Spit.Publishing.PublishingError.LOCAL_FILE_ERROR( - _("A file required for publishing is unavailable. Publishing to Picasa can’t continue."))); - return; - } - - var opts_pane = new PublishingOptionsPane(builder, publishing_parameters, this.authenticator.can_logout()); - opts_pane.publish.connect(on_publishing_options_publish); - opts_pane.logout.connect(on_publishing_options_logout); - get_host().install_dialog_pane(opts_pane); - - get_host().set_service_locked(false); - } - - private void do_upload() { - debug("ACTION: uploading media items to remote server."); - - get_host().set_service_locked(true); - - progress_reporter = get_host().serialize_publishables( - publishing_parameters.get_major_axis_size_pixels(), - publishing_parameters.get_strip_metadata()); - - // Serialization is a long and potentially cancellable operation, so before we use - // the publishables, make sure that the publishing interaction is still running. If it - // isn't the publishing environment may be partially torn down so do a short-circuit - // return - if (!is_running()) - return; - - Spit.Publishing.Publishable[] publishables = get_host().get_publishables(); - Uploader uploader = new Uploader(get_session(), publishables, publishing_parameters); - - uploader.upload_complete.connect(on_upload_complete); - uploader.upload_error.connect(on_upload_error); - - uploader.upload(on_upload_status_updated); - } - - private void do_show_success_pane() { - debug("ACTION: showing success pane."); - - get_host().set_service_locked(false); - get_host().install_success_pane(); - } - - protected override void do_logout() { - debug("ACTION: logging out user."); - get_session().deauthenticate(); - - if (this.authenticator.can_logout()) { - this.authenticator.logout(); - this.authenticator.authenticate(); - } - } - - public override bool is_running() { - return running; - } - - public override void start() { - debug("PicasaPublisher: start( ) invoked."); - - if (is_running()) - return; - - running = true; - - this.authenticator.authenticate(); - } - - public override void stop() { - debug("PicasaPublisher: stop( ) invoked."); - - get_session().stop_transactions(); - - running = false; - } - - protected override Spit.Publishing.Authenticator get_authenticator() { - if (this.authenticator == null) { - this.authenticator = Publishing.Authenticator.Factory.get_instance().create("picasa", get_host()); - } - - return this.authenticator; - } -} - -internal class Album { - public string name; - public string url; - - public Album(string name, string url) { - this.name = name; - this.url = url; - } -} - -internal class AlbumDirectoryTransaction : - Publishing.RESTSupport.GooglePublisher.AuthenticatedTransaction { - private const string ENDPOINT_URL = "https://picasaweb.google.com/data/feed/api/user/" + - "default"; - - public AlbumDirectoryTransaction(Publishing.RESTSupport.GoogleSession session) { - base(session, ENDPOINT_URL, Publishing.RESTSupport.HttpMethod.GET); - } - - public static string? validate_xml(Publishing.RESTSupport.XmlDocument doc) { - Xml.Node* document_root = doc.get_root_node(); - if ((document_root->name == "feed") || (document_root->name == "entry")) - return null; - else - return "response root node isn't a <feed> or <entry>"; - } -} - -internal class UploadTransaction : - Publishing.RESTSupport.GooglePublisher.AuthenticatedTransaction { - private PublishingParameters parameters; - private const string METADATA_TEMPLATE = "<?xml version=\"1.0\" ?><atom:entry xmlns:atom='http://www.w3.org/2005/Atom' xmlns:mrss='http://search.yahoo.com/mrss/'> <atom:title>%s</atom:title> %s <atom:category scheme='http://schemas.google.com/g/2005#kind' term='http://schemas.google.com/photos/2007#photo'/> %s </atom:entry>"; - private Publishing.RESTSupport.GoogleSession session; - private string mime_type; - private Spit.Publishing.Publishable publishable; - private MappedFile mapped_file; - - public UploadTransaction(Publishing.RESTSupport.GoogleSession session, - PublishingParameters parameters, Spit.Publishing.Publishable publishable) { - base(session, parameters.get_target_album_feed_url(), - Publishing.RESTSupport.HttpMethod.POST); - assert(session.is_authenticated()); - this.session = session; - this.parameters = parameters; - this.publishable = publishable; - if (publishable.get_media_type() == Spit.Publishing.Publisher.MediaType.VIDEO) { - try { - var info = this.publishable.get_serialized_file().query_info(FileAttribute.STANDARD_CONTENT_TYPE, FileQueryInfoFlags.NONE); - this.mime_type = ContentType.get_mime_type(info.get_content_type()); - } catch (Error err) { - this.mime_type = "video/mpeg"; - } - } else { - this.mime_type = "image/jpeg"; - } - } - - public override void execute() throws Spit.Publishing.PublishingError { - // create the multipart request container - Soup.Multipart message_parts = new Soup.Multipart("multipart/related"); - - string summary = ""; - if (publishable.get_publishing_name() != "") { - summary = "<atom:summary>%s</atom:summary>".printf( - Publishing.RESTSupport.decimal_entity_encode(publishable.get_publishing_name())); - } - - string[] keywords = publishable.get_publishing_keywords(); - string keywords_string = ""; - if (keywords.length > 0) { - for (int i = 0; i < keywords.length; i++) { - string[] tmp; - - if (keywords[i].has_prefix("/")) - tmp = keywords[i].substring(1).split("/"); - else - tmp = keywords[i].split("/"); - - if (keywords_string.length > 0) - keywords_string = string.join(", ", keywords_string, string.joinv(", ", tmp)); - else - keywords_string = string.joinv(", ", tmp); - } - - keywords_string = Publishing.RESTSupport.decimal_entity_encode(keywords_string); - keywords_string = "<mrss:group><mrss:keywords>%s</mrss:keywords></mrss:group>".printf(keywords_string); - } - - string metadata = METADATA_TEMPLATE.printf(Publishing.RESTSupport.decimal_entity_encode( - publishable.get_param_string(Spit.Publishing.Publishable.PARAM_STRING_BASENAME)), - summary, keywords_string); - Soup.Buffer metadata_buffer = new Soup.Buffer(Soup.MemoryUse.COPY, metadata.data); - message_parts.append_form_file("", "", "application/atom+xml", metadata_buffer); - - // attempt to map the binary image data from disk into memory - try { - mapped_file = new MappedFile(publishable.get_serialized_file().get_path(), false); - } catch (FileError e) { - string msg = "Picasa: couldn't read data from %s: %s".printf( - publishable.get_serialized_file().get_path(), e.message); - warning("%s", msg); - - throw new Spit.Publishing.PublishingError.LOCAL_FILE_ERROR(msg); - } - unowned uint8[] photo_data = (uint8[]) mapped_file.get_contents(); - photo_data.length = (int) mapped_file.get_length(); - - // bind the binary image data read from disk into a Soup.Buffer object so that we - // can attach it to the multipart request, then actaully append the buffer - // to the multipart request. Then, set the MIME type for this part. - Soup.Buffer bindable_data = new Soup.Buffer(Soup.MemoryUse.TEMPORARY, photo_data); - - message_parts.append_form_file("", publishable.get_serialized_file().get_path(), mime_type, - bindable_data); - // create a message that can be sent over the wire whose payload is the multipart container - // that we've been building up - Soup.Message outbound_message = - Soup.Form.request_new_from_multipart(get_endpoint_url(), message_parts); - outbound_message.request_headers.append("Authorization", "Bearer " + - session.get_access_token()); - set_message(outbound_message); - - // send the message and get its response - set_is_executed(true); - send(); - } -} - -internal class PublishingOptionsPane : Spit.Publishing.DialogPane, GLib.Object { - private class SizeDescription { - public string name; - public int major_axis_pixels; - - public SizeDescription(string name, int major_axis_pixels) { - this.name = name; - this.major_axis_pixels = major_axis_pixels; - } - } - - private const string DEFAULT_SIZE_CONFIG_KEY = "default_size"; - private const string LAST_ALBUM_CONFIG_KEY = "last_album"; - - private Gtk.Builder builder = null; - private Gtk.Box pane_widget = null; - private Gtk.Label login_identity_label = null; - private Gtk.Label publish_to_label = null; - private Gtk.ComboBoxText existing_albums_combo = null; - private Gtk.CheckButton public_check = null; - private Gtk.ComboBoxText size_combo = null; - private Gtk.CheckButton strip_metadata_check = null; - private Gtk.Button publish_button = null; - private Gtk.Button logout_button = null; - private SizeDescription[] size_descriptions; - private PublishingParameters parameters; - - public signal void publish(); - public signal void logout(); - - public PublishingOptionsPane(Gtk.Builder builder, PublishingParameters parameters, bool can_logout) { - size_descriptions = create_size_descriptions(); - - this.builder = builder; - assert(builder != null); - assert(builder.get_objects().length() > 0); - - this.parameters = parameters; - - // pull in all widgets from builder. - pane_widget = (Gtk.Box) builder.get_object("picasa_pane_widget"); - login_identity_label = (Gtk.Label) builder.get_object("login_identity_label"); - publish_to_label = (Gtk.Label) builder.get_object("publish_to_label"); - existing_albums_combo = (Gtk.ComboBoxText) builder.get_object("existing_albums_combo"); - public_check = (Gtk.CheckButton) builder.get_object("public_check"); - size_combo = (Gtk.ComboBoxText) builder.get_object("size_combo"); - strip_metadata_check = (Gtk.CheckButton) this.builder.get_object("strip_metadata_check"); - publish_button = (Gtk.Button) builder.get_object("publish_button"); - logout_button = (Gtk.Button) builder.get_object("logout_button"); - - if (!can_logout) { - logout_button.parent.remove(logout_button); - } - - // populate any widgets whose contents are programmatically-generated. - login_identity_label.set_label(_("You are logged into Picasa Web Albums as %s.").printf( - parameters.get_user_name())); - strip_metadata_check.set_active(parameters.get_strip_metadata()); - - - if((parameters.get_media_type() & Spit.Publishing.Publisher.MediaType.PHOTO) == 0) { - publish_to_label.set_label(_("Videos will appear in:")); - size_combo.set_visible(false); - size_combo.set_sensitive(false); - } - else { - publish_to_label.set_label(_("Photos will appear in:")); - foreach(SizeDescription desc in size_descriptions) { - size_combo.append_text(desc.name); - } - size_combo.set_visible(true); - size_combo.set_sensitive(true); - size_combo.set_active(parameters.get_major_axis_size_selection_id()); - } - - // connect all signals. - logout_button.clicked.connect(on_logout_clicked); - publish_button.clicked.connect(on_publish_clicked); - } - - private void on_publish_clicked() { - // size_combo won't have been set to anything useful if this is the first time we've - // published to Picasa, and/or we've only published video before, so it may be negative, - // indicating nothing was selected. Clamp it to a valid value... - int size_combo_last_active = (size_combo.get_active() >= 0) ? size_combo.get_active() : 0; - - parameters.set_major_axis_size_selection_id(size_combo_last_active); - parameters.set_major_axis_size_pixels( - size_descriptions[size_combo_last_active].major_axis_pixels); - parameters.set_strip_metadata(strip_metadata_check.get_active()); - - Album[] albums = parameters.get_albums(); - - parameters.set_target_album_name(albums[existing_albums_combo.get_active()].name); - parameters.set_target_album_entry_url(albums[existing_albums_combo.get_active()].url); - publish(); - } - - private void on_logout_clicked() { - logout(); - } - - private SizeDescription[] create_size_descriptions() { - SizeDescription[] result = new SizeDescription[0]; - - result += new SizeDescription(_("Small (640 × 480 pixels)"), 640); - result += new SizeDescription(_("Medium (1024 × 768 pixels)"), 1024); - result += new SizeDescription(_("Recommended (1600 × 1200 pixels)"), 1600); - result += new SizeDescription(_("Google+ (2048 × 1536 pixels)"), 2048); - result += new SizeDescription(_("Original Size"), PublishingParameters.ORIGINAL_SIZE); - - return result; - } - - public void installed() { - int default_album_id = -1; - string last_album = parameters.get_target_album_name(); - - Album[] albums = parameters.get_albums(); - - for (int i = 0; i < albums.length; i++) { - existing_albums_combo.append_text(albums[i].name); - // Activate last known album id. If none was chosen, either use the old default (Shotwell connect) - // or the new "Default album" album for Google Photos - if (albums[i].name == last_album || - ((albums[i].name == DEFAULT_ALBUM_NAME || albums[i].name == _("Default album")) && default_album_id == -1)) - default_album_id = i; - } - - if (default_album_id >= 0) { - existing_albums_combo.set_active(default_album_id); - } - } - - public Gtk.Widget get_widget() { - return pane_widget; - } - - public Spit.Publishing.DialogPane.GeometryOptions get_preferred_geometry() { - return Spit.Publishing.DialogPane.GeometryOptions.NONE; - } - - public void on_pane_installed() { - installed(); - } - - public void on_pane_uninstalled() { - } -} - -internal class PublishingParameters { - public const int ORIGINAL_SIZE = -1; - - private string? target_album_name; - private string? target_album_url; - private bool album_public; - private bool strip_metadata; - private int major_axis_size_pixels; - private int major_axis_size_selection_id; - private string user_name; - private Album[] albums; - private Spit.Publishing.Publisher.MediaType media_type; - - public PublishingParameters() { - this.user_name = "[unknown]"; - this.target_album_name = null; - this.major_axis_size_selection_id = 0; - this.major_axis_size_pixels = ORIGINAL_SIZE; - this.target_album_url = null; - this.album_public = false; - this.albums = null; - this.strip_metadata = false; - this.media_type = Spit.Publishing.Publisher.MediaType.PHOTO; - } - - public string get_target_album_name() { - return target_album_name; - } - - public void set_target_album_name(string target_album_name) { - this.target_album_name = target_album_name; - } - - public void set_target_album_entry_url(string target_album_url) { - this.target_album_url = target_album_url; - } - - public string get_target_album_entry_url() { - return target_album_url; - } - - public string get_target_album_feed_url() { - string entry_url = get_target_album_entry_url(); - string feed_url = entry_url.replace("entry", "feed"); - - return feed_url; - } - - public string get_user_name() { - return user_name; - } - - public void set_user_name(string user_name) { - this.user_name = user_name; - } - - public Album[] get_albums() { - return albums; - } - - public void set_albums(Album[] albums) { - this.albums = albums; - } - - public void set_major_axis_size_pixels(int pixels) { - this.major_axis_size_pixels = pixels; - } - - public int get_major_axis_size_pixels() { - return major_axis_size_pixels; - } - - public void set_major_axis_size_selection_id(int selection_id) { - this.major_axis_size_selection_id = selection_id; - } - - public int get_major_axis_size_selection_id() { - return major_axis_size_selection_id; - } - - public void set_strip_metadata(bool strip_metadata) { - this.strip_metadata = strip_metadata; - } - - public bool get_strip_metadata() { - return strip_metadata; - } - - public void set_media_type(Spit.Publishing.Publisher.MediaType media_type) { - this.media_type = media_type; - } - - public Spit.Publishing.Publisher.MediaType get_media_type() { - return media_type; - } -} - -internal class Uploader : Publishing.RESTSupport.BatchUploader { - private PublishingParameters parameters; - - public Uploader(Publishing.RESTSupport.GoogleSession session, - Spit.Publishing.Publishable[] publishables, PublishingParameters parameters) { - base(session, publishables); - - this.parameters = parameters; - } - - protected override Publishing.RESTSupport.Transaction create_transaction( - Spit.Publishing.Publishable publishable) { - return new UploadTransaction((Publishing.RESTSupport.GoogleSession) get_session(), - parameters, get_current_publishable()); - } -} - -} - diff --git a/plugins/shotwell-publishing/flickr.png b/plugins/shotwell-publishing/flickr.png Binary files differdeleted file mode 100644 index b6cae3e..0000000 --- a/plugins/shotwell-publishing/flickr.png +++ /dev/null diff --git a/plugins/shotwell-publishing/google-photos.svg b/plugins/shotwell-publishing/google-photos.svg new file mode 100644 index 0000000..498de5a --- /dev/null +++ b/plugins/shotwell-publishing/google-photos.svg @@ -0,0 +1 @@ +<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="64" height="64" viewBox="0 0 192 192"><defs><path id="a" d="M179.17 96H140V52L99.4 11.4c-.36-.35-.85-.57-1.4-.57-1.1 0-2 .9-2 2V52H52L11.4 92.6c-.35.36-.58.85-.58 1.4 0 1.1.9 2 2 2H52v44l40.6 40.6c.36.35.85.57 1.4.57 1.1 0 2-.9 2-2V140h44l40.6-40.6c.35-.36.58-.85.58-1.4-.01-1.1-.9-2-2.01-2z"/></defs><clipPath id="b"><use xlink:href="#a" overflow="visible"/></clipPath><path clip-path="url(#b)" fill="#4285F4" d="M179.17 96c1.1 0 2 .9 2 2 0 .55-.22 1.04-.57 1.4L140 140 96 96h83.17z"/><g clip-path="url(#b)"><image overflow="visible" opacity=".2" width="284" height="284" xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAASQAAAEgCAYAAAAdaA76AAAACXBIWXMAAC4jAAAuIwF4pT92AAAA GXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAcP1JREFUeNrsvUuPZNt157fWPudE ZlVW1dXlQ48WJVI0RbAHBgRo0oA9UM/7Q/gLeOaJP0d/FGsueWDAMNCAABvoBptNS1S3ZIoSyXtv PTIjztnL67Uf5xGRkVWZVVlVe18GKzJeGRlx4hf/9V+PDdBWW2211VZbbbXVVltttdVWW2211VZb bbXVVltttdVWW2211VZbbbXVVltttdVWW2211VZbbbXVVltttdVWW2211VZbbbXVVltttdVWW221 1VZbbbXVVltttfVhF7a/YXNROzTaaqsB6TE/5wapttpqQHqUz7PBqa22HmCFRw4hfHcY/ZXzY3n6 i0fw3Npqq62PQQ3d4fRXfKIHOP3FHZ9HW2219SmFQnd4Ln91hsL59/x4vz7jsf4dy6U/P+N2/5ZP f91Curba+sSBdOZzOAahc8Fz13UKVGfDqYGprbY+IiDh3SH0UAB6W0CdBacGprbaesRAes8g+i98 3+vFZX/EkHhxj3C6FUwNSm219QiBdAcYnQuhLeC86zoXWEs4NTC11dbHAiS8PxAdg5A8xnff4SkK TH71FoC6E5galNpq6wMDCc8Lz07BaAtCNYB+fg9KScDz/BZAnYJTA1NbbT12IJ0Bo7uAKEHoDgD6 Mz79TvXz3/Dpt3eF1BJO9wKmBqW22nqPQHoHGNUgOgNCP/kVwtXhyNP4McyVz0/59M32TX/2LYKv Lu8JTjWYmlpqq60PCaRbYPSuIGIA/fhQcaaCzv6fEeLhbs92xyAKF2tgHQXUFpzeCUwNSm01ID1O GJ0AUVZCDqAFfH7Ap6vq5ofDVxjjuPlshuEFhTDkn/+WT682IeWA2oTTuWBqUGqrrQ8BpLeA0VIV fbMAUa2GGET7mwyhBKA1eL7Hpyd3eNr/lU9vZqCaAUrh9HcnlNMSTLeppQalttp6aCDdP4xqRbQA 0S5DyOAzTV8j0fhOf0DXPSfEYQWoXzCgNuG0Cab/8K5qqUGprQakh3nMc2C0FaIlVTQH0fcYQpcn IDRNL/nnyX/6XT5dnPG0/4lPNw6kKwZSfxRQMzidDaYGpbbaet9AegcYbamiPzkKomk6ZAgVABl8 YnzFjzW9/R+BTx1IBqkaUAanX94BTOeEcS2Ea6stWf2Hg9sxGLkquiqqaA2iNxWIvs0A6hxAN3qK 8Y0D6kshRf6NMV6vQIV4yYDp/Kff8GnPp5cYwhO+XKByCURP+Xa/1scWCDKw+PxTPv8c/oDhNAwD /WL/a3wl4Nl9n+BHf4fwU779Nwwm+Ht/Xf7c1ZL8vITSX6JB56+OQQkblNpqCunB1NEtMHq+hNHv bygiAdGYAWMQeqEAil8weIYCHpr4Z4qnn3x3QZDA9Fv++ZBA9RsIocvQMvX0a1ZK/Uo1KZiWiuln w0ItnfKWmlJqqwHpccBoEaL9AJJhXWC0BFGCUIwR4UsG0FDDRz7oA193cyuMZn9IuGC4vORzhwKp DKivM5zOAlOC0k+/cbV0eUYI13ylthqQ3hOQzoNRCtGm6QsGTn8cRF9EVUIGoWcGJocPCYhAzj/P kelV3DM65nAS9Ey4Y/AE839AQrIL/7kACrugcMKvGEyH42B6O7XUoNRWW/cFpHdURxKmMYwutkO0 GkYxvjwJIoPQFYMnZvBEhhBkCF1t2GavFEIWju0YJmEBqld8eaeAmsHpq26mmkJ4fhpMDUpttfUh gHRXGB0YRt9hGO02YTRNT/i23UwVUXiVQUTTmxmECoCu+DxlGBEdEJ5Geaj1es1/RGRQ+CYsiIOD SWAU9PwrhtM4g9MNhb7PYOq6A99u2lBMX9Nu9+SWEK5Bqa227gNI7xCqzQ3s793880kYTS92rIo6 VkUXGOU2GyCKsUeBCj1h+HQCoqesmiLWn9sYD5ViggWA0s8MGrwGfMNKaAp+/RuF0yu+3YQ3hGHY ANMbBtPOQ7lX1PcXZ6ql2le6vGtZQINSW5/M6t6POvoNWlj0Az7t7fxPXiM8+9ERGF0xjHoUEMX4 FOMXA6siDs/iJf88KYyu4sBahBUQQ2iaIBAFpCcj0k4owfedKBBDiviCGOV6QDnxn4wUyX9GFOOb 6YDl+p7V1DXfhn9P3yHs+DY7DgUngWFgNO1Z1wyMjYAj3TDa+P5SdnBxA/iMzx+ugEb+22AHouiI BMB7Duu+wzD8Gr/F3HvDz+sQ/gDg279GeM08uZHbM6DhJ2BlAX+Lpp5yoy8asP5XPv3vYB139+4D ttXWpwak/8mh839harnYVEeVif2DeIDLeIPjSAIEV0YRlyFanBgs4zXLnwuGUY+BP9TTxP/EfYCn DKwdhMjEIL5eAAQCGQWPAKgAKUOJYjD4FBjpdfrzpMpMQGW3ETgh4gUDZ8fnR+TH3DFyOtEzGUyi yGD3kv82vu9hz2GglB7svG7qAPLciF7Bt0LYgJJ4W187lL7i0z82KLXVgPQw6uh/nIdq3zpIXMTq hkXS4SuEw1XOpkmYFlXZzGFErJ5EFV1ON0yMQcMzeiIgQox0EwxCfBkDiiLHVlLWyNDZMUk4egv9 BeumgU89YNeNQf7tOwpDH/gy1Mv7CXCIrII4KBsZblEUlABNAMXnSdXVqHCCHT/HEeZgiq/5uQhY +Iona7UUOAIkfu5EvwPPp9/iNYPq0P1hg1Jbbd0/kE6po41QjcOf7+1/o6GaqBTpR0ueEdFzDtOm FYyCZto4HLs8BFNE+wpEgyqiSwbJDgbs+HrqY5Cwizo+D6aAYhwZVlRUUeTb8EmVUWDodHKfiB0D auD7DlOHE4dvEQxO8mfz3URhMZhCBaYDY4dRxgCJ+rJertSSVHzXIdwLDuEUSvJ3f4cB9Oq3CHtR Wq8blNpqQLp/IC3U0SpU+10O1SRc+62m9kXVxHiB04vDURjREwYVduYlaTjG/8bAINqHXpTRjsO0 QVQNKGjkNhJ7gcJnDPJLgGB1shAuuBIaFDh6PlDo+IGHISicosBMwzi/nv9PwTSRPA8c6BotjHuz UksYpS2lyyFcgtLvqa/0DA/f5etfvWxQaqsB6f7DtQ119B35kFEVqk3qGxF9iZYl45DtRVQDextG FwwjgRZfNImy6YKA5IKBBAKiPoj6yRBSyJDDSaHjZvbAj92LUc6353iNOj6vQBEood4OFEqj/SzP meUTdAFDfwj9SKya+HmqapLXwjKAeMEAmvgljYOGcZO0sbhawicHhtKuCuFuNnwlgdL3Af6wNrsb lNpqQLondSSZtaBhTlZHm6GamdiS2qdwOAqjCG80RFMfh3pWIgMOOw61+gQfA1KBkECK1ZGEXziF vusxhC50fHnH4Z1UFOm/ckJmTcfaKzDo+IfYSZaOTAVRx485JSWlYOp7YsUUWAV14i1JaTj/eyPP JYdxw1TUEv+JSBcMmJHV1bSXavCFr3TM7G5QaqsB6S2A9L8dMbPDTB39gD/PKas2ji9zqEZ0xR9Y Vhz4lGF0EyyTtoRRsBCNYbRjlcQffOnnCPKzKBhL71cQCr00eDBwJg3V+H/Bn7sY1QoxC9Uk/S/P gYnAj8UkMlgJvjoGjQAqgsJJFZ5k8ORfBlPXT2qER2ZHrMI42PEfM7Fi4jDNvKWDZeIuRy8PKL5S g1Jbbd0bkFK4dsLM/sk/ZnX0jNVR5+pIxoHIB93UUQrVJHR6yh/yfYDYLWAkNUUcou0w4NAzBBgm mlE7SFYt8Gc6DOL5KIQENlp67aEaq5xePCEGEasgvgYhDCj/ys/pxNRQMJHElQ4pSdt1gZ+vwqkz MGnPnIGJNZma4BzGgdU29Wpcq1qaRGVd4I4JWUK4/cxX4rDNzW75902DUlsNSA9qZos62n0JP5wm vJheZ3WUUvyThGg7DtUghWpMFPGHpNARo4ZMpGrpwDCSgiApmhRgBfWTaCCBTeAoSqSKqyYJ3fhf yZoJUySDBtEychrahWBhHYbyM5MgkAOKlV2I4neZ4tGmEdIabA7rGE6dFVY6mARSfccaSMM4vQ8o uBicrOQghXARGaraT1d8JYES4nOG0SuH0rcYSsRQetWg1NZntfoH/w2yQaPMSHvza4aHnPkj0Oax ejqkzFELXwAcXrpvxKroyRut+5GsmygpCcsupGqabxmnGy96lJIk0CYOUzZSCsDnWZlYpoy0CLLX UCqmkAtM/dAGaYP1swlPWM+MwqpObHfpZ2PMjBJbCW7UZmKUTYxJfo6S+ItjVEINEAdG4f4gbSpg nr08wiVT87qPl+NrDtH68Dq+YZRdUXixj9PX/LpMNzIsTqAENijuS/gD/Ar+IR7g9aUPffsZP+mv pJL72LC3k4Pe2pC3tj51hXRGdu13+Ju8/xNWRxxlcbh2OExzdZSN7DpUUwXCcBlVCVHsccecYm2i mS+DUY8aokn2i3/m8K1TRdSLQlKMsGKKalirWupQTkIOVkF8PoTViR9Kwja/Df/A7OEoDUVqRQnP VD0FVU2gEyl76VNh3SWlB+Ix9aqK5AUStbSTAk73loj4tZBITvrtvGZppGtIZjcd+LHHGze7LQM3 q1WaFVA2pdRWA9LGQX1muMafUpkY0sUbUUlSnIhm4vIH+aJDwOduZMcqVBsNOtQHyaZhODAfDoGm AqNeejvkLmJOS1YsaNjVyeXiI4Ek1PhSAZD5SJaJs8xZdFObZidN76uHxOoqaB2S/lvDSaGlYBII TXoZ/yphDaoGkcmWYqLzn9ZNIFGkS5OdQWmaKl/pppjd41Bl4BqU2mpAuif/6Humjv6MP5hPJdV9 ic/2Lysz+wsNp6YXDJ+wX6gjDrf6noHAJ2kViYcAA8OI5Q1o3VEXEoxAs2qjwQjMQ+ok+wbyuKyY EMzYFuUEoFOL5P8QR8mPiQZanxhAIUT5nxZB5qxZgpNASaSUgwk6UTyS9rcBuF2QAXISPl7wr9fC c+yYN2p46+xvfiaDFFLuxX7CCylIgH2DUltt3T+QjodrczPb6o7iRdhQRxzCobSEjFrEGHaCiE77 0zStP0AFIw6jFEYMG2khYVpJaCYBGkNEFE9XICRhGgVL/cuJ7CQ+tVymRZDR65f4cXFyK5z/ieJN kTXsqmISs1vjO52OZNk3Vj06KG6QYgFWS+TNuvI6jcBPRCYqgZQ2aRtKH5kdfB/+tRfUoNRWW/cE pLr+aFEM6dm1L6Utn4E0D9desBK64c/6tFBHAhhmAMPJQjXhAYdqcdK2kMFSaxZudVMFI9DgTPwj sMwZS6DYKYYkTAPPunn2TT0j1jfkzhClSWzmEQWrwA4abootFGT0kQAtBpsIkMAkhIteIOlhHLpa UuEkHf/apQtS4gQD7UB9JXtskHolGJGh1DGULqws4HLfoNRWA9LbGdpb/lEo4doN4dXN17NwbZpe h+mFdM2P2o/2TIqMWJAk7yhqw+sUuh0DSj76/DOLj06rhlStMGS0YRYXMLIQjfUUw4hvAVJhLYXZ 7iOhUAo1+JIBR1vOtuTONIHG/886TrED7i1Jg66pplREKQrP4KS1SuR466KqJbmsDzp3SdNtKCl9 llQdh6hRqwKsJgl2g0JpEGinsgCBUi6gbFBqqwHpLQ1t949+n4HUfR9/OMZVuEY0qplNtAusArCX plcpfHTvSNTRBZ90RKM2yUqvmgFDDWfzjLoZjKyOqJMADd07oqi37ORCI0hQuJD+C0H/w0lKi4Kd ptR8q7AzyYS6SG8tNZIShql9bpdruIcKJu11U7UUXC2Zmgpdz+pIphh4vCaojKBKSYoQ6gzcMF1D qVVKBZQNSm19His82CNf/4pFyPWRK78Ul1cyXfCMLlhZ8AflqaTbb2wWkpx2By0HkFnYtBtxEAkR yYetdWJeY4GRVmV3Qhz5m7TzI4p91AnVGHak7WuEUx8D9GJ4MzA6BkJvrWysafgOnkjr1RrCyLcV J4hvr5QkOQnc9PrIxGDl1ocwdV03se6Z+DI+yc98Xh6Ycc/hpk4dYHiKvwUW6Mnf0EMYLsQqF/Ne 6q2GEHcMs7ALl+Nr/gWMPCmNGBneL3aMTWk+vvTpCL/h1+X34F8dDvj0+pf8unwf4EcHhC/k9dY6 JbBtyeX819XrLnVK/6FSt9Cg1NanqpCSob3lH30bZeB+ya4dWLdYz9ogYJE6Igmy4ImOnL2UqWsB vaLaIqug9UQMkr5L6qXzMK2T27Ag6RSwUhwpWTIkg5HERQYYMbTV5NY40UM2q04SMPhJ5ZPIHTOV ImiyTGclmSkOZkAFV0E6YVLiQDO5ycM4UFrGRQjnI5W0NMBezK5PGTgGCmPXlFJoSqmtBqS7A2nL 0P5S51Sn+iPzj57q/CD+dmd18Fqza6pqIisfaXzVcM1aO8Q/YkoFS9mzOuDzg3hBErb12mMmWTbJ pnkmTaqNNHPW6fyjoLGetOBrlk1CNjG6NdsGUSEGalGLmhLbWQzvYGa40FTqGrUw0oxuwZCl11IZ NxmrJGIjI5dl00a5nxZA6cwkCfY8hNNpAPLo5L6SuFPqK2lhgBZR6n1ku/AFlCbJ4uGAunFlg1Jb DUjHDlQB0j+dNLR/OF7ixTRm/yhKs2zKrvHn+RmHKSGyKnpy0EyawOiSASWf4giDeUeqjqQzn8Mh MbFJR0p2ZP6SxGSetmcgCXUkwUVaaa09tlozkEEk1xnUtEBSScRPSsETgv2LKnPA+9wsrLXqbtTa AQWdQUv77KKSSXvltLdNnzLaBAMJ2KIWQWVfiaxEUp6YbOMUdX63NOeieUoLKO3iQftzG5TaakA6 CqRjGba5of3lGDfS/dJIu9dk1k7DtejhmpnZYUgMEfUzhQF1yJpm1UDCMAGK+kYTq55Oix8VRkHC MQEJq54gZyWsE8VEXQaR3I7vJz0oUhIAuhWt1iR1VpuEBh9VSeh1SKaOvLhSJI2DCW1Am9w21QxY tYA23AYFkXrooqEkPShxI2jEGA1MXQdQMnAAMyjJGlCLLhuU2mqm9r0b2r8H0mUbv7jmMOwZf+4n UxBbi0bd2JEGycL3Nr9anWT9sHv3q87KxpTqD9oWIrZxr0WMSKqKVC2JqcxA7GXsmnlNYnorpKTn TXZ0VBNbTG8ZSKtGNohp7SfUpjUZVNsDmcmtlyFoWlDOR3l6sv+SlWqaWc6Ph2FU8Kl9JaFjnMTa lspzfk5913Ua9ZnRPUEY+B5PBHqR/46Jn7HMDg+78ETaeBnwcboIzehuqwHprZd099vW0ba10aRb XhNdqa9ET25ydu2ST0FApBMfBxw4pEGFUO+D0dAG8Wutkaf8Y8q0gc000upsSdFHU07igttSEAm0 SOdBClCmXtWS9qlgV078MxhwZNRbyrSROcwrMAUtQUCxp/kyIQn/HgGc/H6ZU6I7T0o9tzyfzjJu QUJQqbHin7ud1gwkKAnGdnhtfXoNSm01IN3D2su4kYOete2NZHufKV/9jPb86XxSRY2XHK5cMLQG GxOymyRK8iH6I9pOHw4luUxDoymYb+RwUqWk7bQMnl6rsiU0I/OdgoPIAUSdhXCe2l+eQOscZVNc VUG6QVsoymkGJhCFNMltxNvS0gKZE8fip1NIxVHDRAkNpSwgdiixpkDToSRU4tvuLiTQa1Bqq3lI d/OQxND+AZxK+f+wu8Rh/1LHjdg+a8PM0F77RySV2Sw2RtQ2Ealx1PqiTttdZZQIdAYRN7LVJ5Ix s+IbsagSo0mzavqz1SV13sGvdUeiflBBIwpFPSHxoDzTBp0D2k9ombh0AjOIZGybXuP7IQFa5aSa QXqjYOl+NGiaDS4Pqfvjql+uppFoImtBAe2D0z4W6YvrdYCSlHJbq4n0vw3WEjdA85TaagrpTksG sr245TYasq39I4IRTP30oOGafCJFi+CkeSxr35irI03Fp5DNYSIjS3T2o44UQYVUUEhFC9fks+8q SSGFMjhE/rUwLZ/A1ZEroqyelopJfkYJ2dDVUhDwyUBtDeHk/nq5dq6oE99JsaaoJfn9UtJAHsL1 k5nyES5ZKQVXSs1TaqsB6Y5LDt4vT3MoGdq6r9k+Q4l0jzYJ4fijRzut19FRs3IdjSiuM8rIWJVF mtXSjvzO0v1SKIkdFTCFkMaOdNbw4WDSUgDS2SQCn84eQp6Mlgrov8nI1p+BMoQA3VeiAidwrwkc UpB8JzfKUTwrrVQQg0gyeiTGtzT0aq0USDU50hpK0hLTyfmdQ+mGoTQ1KLXVQrbjIduyKPJUyv/b 2lAbdUTQoK0hg3TAP5F6o0mbZXu61KpmHcI2aLW0hW5ofWiibDRn3snGZ+YTac2iekSo8yBBU1la CNlrrZL6RaT1SGST2bSGCfS2YN6SFg5JCaPOk/R6pJArtwHQ4ZbDN7Rh2Whhm5yxKZG+R5uVVtp5 286EtNIbfJyA75gL2gjnm5iQ9pTYxICoDyukFC3Hoa5sJOfhmxa1a/9bC9/aagrpnHWyhw00w/aM rlhGfOE8fMoXXkDcWZuF3cj2OdNues+u6V5rOVwLHA91WgKQ1ZE4NN7bZj1uak5ZVOY9KKJaJCHG CqizRlzobC5ucIMbNMQikmwZaZYsqZ6ASf3odrQDyeAjMsWUygQQi1pCcCXlqipEUVxgaskNblNR /MdGU01CXFFNMsB3rpTIjW5q4VtbDUhvvyzlH+OrWYathGvaUgK2qwd4/VGn6X71i/qYs2sEk4dr ne+pNvkmjqovtNE26OXmJRmMLMWvMJK0v42x1dEkkvInU0myc6OHZhbCLU/gPtEsLNOwjQatRxIZ 4+GdQsoBpbfV0C9qQ24CVATzrDKUOvJapQWUaOy6iRqU2mpAepADbypmthQ+SvYNHEZmaO9w+ZR6 mRkrjo8oIsGFDHTrfOyH7CArKsoqt7W7Po8VcbNbWz2CzTQisjlJZFMizd/R5lr02bhWjyQmNHq6 P6X8k/pJcJr5Re4jZbWUFFIqoFQYihWmE/57hQ8kI1zKAuQvrKE0iafU6VBKPl+gNHaRzzcotfW5 e0hn9LG5h/Sdr6uh/hd4OPwmaMJMUv67sWoZAd12WromLuIBzYg230g8HG2+te4Nb6KVnjOdh6T1 PRpi8YfVBlqLChJcaVuJn5eQS+SUKBHsDUZqamtFt24JIOXe4F5SUEAFLQPI85HSyQCHqa7BfkY/ WUOutojY5DYjrntJqHO5wXwlNYzA/Kfolwd7fUlbdu07Qm9lJQKkplM9KcAeT5DYPKW2GpBu62Nj IEkN0lP+wt/vb8I0XR/pYTMgRYaRblUUBrTdZ7VPPmhho4Rb+gnWTFXQtgwdHZIbbKXxwne9RjWq FSjkXo2CCdQLspokv1+wTJuBSF+DjmzOtk0KKPDR7n7KdUlopjZlMDmU1NS24W5ek0Rmc6uUA9sO Do0k+lKi/3+ClT2MQimaV4ad/iENSm21kO0e1uHwlUyGXF9R1SBJut/8o0uwYuvRmlHV0J48lIsz /wg650UK1yDNJCrekYVsUnRo3fqmvro8XTLYbG2bk+TFknIDRAuZyL2eHIp5TZKm/DVc00oEPY8p 7V+FbXYfpbCXB5CUn5vBDcncxl4NbVVyYOd1hIrUKnVW1S3FDmp6L8M30PMtfGurAekt16oG6cmN xHQKo3ihQZkezLt0VPeTZdQUQPKxj+Yf0WTNtmAn2S0khFEbbnVAv4ubQKWdRH0lbba1mh9CU1Jk KTiDkE4E8JokS/PZqVzWazlBhhNVYBLgVJ5R5S3luiWH1yoDJ4DCClAKJSqtJg1KbTUgvc36BcKf Xd9epX1s6eaKO9kiWzv7bUfsaLU6qoI0Q27p/pkqSipJZI9m3+wUJt1pJKTh/yFn3oKFXDrfyEGU Uv7k1doatvX5ZJCxcSWU1FMQ6AyUFBNtpP0ZVBlK6fKqiFJ/p4WIvVUvYDG9G5TaakB6H+s5mECQ 9dT6uihl2iYo288P7vVGU0XqkthANHCFpApLzZqQfB7bZbZSRwlAqSZJ1Ij2s6E13FrqnbSlQwGl TbfeXJtOdco/p/3jLJwD6ejHMCikAA1UCp+gKmoJJfB/TUHFPoV3UQHVoNRWA9IDrd/zQKzG0ZWf qz31C386AiJCqzMKmEqUNCuVYFX7R3rbiFrqDFaX5AXSmIf+5zIA9YfK1kYANi1SM3ZexU3W4kFS O5R9JPF6jtQjKYD0NkMKz6wWSTtizUvSGUtScl2VBWAJ8Ux1TVJiIBm+AqVgz6tBqa0GpLOXdPr/ Gyh9bP+aT1fbUdmiqZbo4M20Yy6OtGFsVD9Fq0HykM3UkCskc6ytKFJh5MPbci9bmuZY1FJST2Dp +pBGk/iuR1oPhG50p18Kbma731PVI5H2u608IzRvaRbCZVUkikmSY7Toe7PGXO1rS1CKqWapQamt BqT7M7R9MNscTiNAkT98dgIdlJ9DtqKIUoAnH0dVQwlUqpKiFVeSh2vg0/N1blKtjrAUSeYSAoeR jSlR+FAaT6JtJlAAZB5P8pG8mx+6NKitNrUThCSEM0DRUKBkGTesDXBXTihFklbvUEFJ/vzQoNRW A9JDLMmwRVFKEHEVru3SM+ow+0eeWbMyAIeVGtpJJXl/m8LNNnm0cC2G9DMt/CTziWzTSIGR7V2k KXg/odUr5SFuCqne2VjS/HX/WlUiUPtDloVDH1OCJRsHpbI7+0uiqlZQYlBGalBqqwHp/RDqkE1t 84/SU+rLMexne8+omaGdwGQ9+dZci7YPWg7XdIta69HXf/X3hICltQRtJ1ur0tYeXI8NdU6Sh3B6 MjNc0/3mFSkwqMq8FbVk/pFCR6arJV8JFv7RMSiF6jLtfWtQaqsB6R1XmaV9al0urG1VQpp5kwya k4g87a/HcxWyVectlPPJAK6adM8QcDAldYS6TXZRTuB7tJHNbkQbuaSZt2xy+4msgdYUVFVjlGuT zFvyUgAJ06iCTRjqtH8K33RqQFyWB0jzLWmY6KFhg1JbDUjvL4ybbJeRFJbJtmQSeGkxZEjtFmAp f5EZBqPOYRTAbhcAs3+k2xkBea2SGd2QKrk90+aNZb5Xke1g6z97YaR35Nuwts7YaeGcN8h2gIuh bdXwNsxekg41UvVDnnkj8qxbpZAalNpqQHqMK6mk+qKkhrpidtvGi9EgFGKGUQiU90rTTjjrVbWQ Likm3SzSVdOsFMB2sKU0pA0sdFNFZJm3UodkYVpXh2s5PDNvabCiyqA+Epp5PeQM3AxaW1BKj9Og 1FYD0sNzR3YloYvFyJFh42lVNUj6OSYDEczDtPwvpZ+9JonM8M51SWiD3cCruLGqSyLysvBkaDug VCnpCWx8iZcFWAmAGtCdDQE31ZRUEixCtAKgc6AUtbSgQamtBqQPsHbVEZortL1K24/f6gBOxQDd 7F9TQeT7t1kJgHlJ3o2vg5RMJUHZYDIkVSTVAeQA0tAsZd10NAnaNIE0u8jDN61P0pncNDO3oTKv KZZ+tzoDl7J0DUpttfUegLScFnnGPSoALVVSCt3qlH/M1dp5BG4FqVQSkMM1V0X2b/GWUtGkwSjk 7Y9I9742xWQnrz3KIZtn2hByaGdqCTOUEBaD28zEHpBwsFolHPg+gxZNUpdbTRqU2mpAepD1JTMp Ht86W9fFLU+nKgOo1VHIAKpCNw/lZNvFXDRJGUwWxonHFK08AGysv/tUGUTgldpE85OpojSC1uYp KZjmO5JY2cDCV6IqjCtp/9TrJiFdHEinS3Y9ev1S85TaakD6oGuYH5+pp43i1kGbUv5VWEdmaFeQ ymFaruQuoZyWAnjYBn4eYbbTiIdrWMI3q0MyHwms/QM8C4e01U4COcNmBjcegVLKwkUzv0UxyRQA CQnT7KQGpbYakB4opNOUv/exxWnRx1YpoySQNDTzjv8liIgMFVSZ3FT/62BKYVuq6tYeuCMwIkhb z1pol2clQU7/2wSB6DOTfL5RPfcIYzG4q3YRPKqU0nVkPW8yMQBMMTWl1FYD0gOsMi1y20eyokjr /F8DamVq22TqHLr5+Wxoe3tJMMPbZielEM4zbh7Gof5uyHO0qerqdZ/I5m4D5LBNR+cKGNCbcin1 vlHZFGDW4wZViGY1SWlbpeNQaiUBbTUgPfxalWrXUCohmk0BOHK7VUMuVVXcyTciy7o5fFIVd0jV 3BgrZSSKKVpJgO6Mq4qq88ycA8gv82ZbymDysgDrfetyWh+r8zQvCyhKKVVtNyg1KDUgfSAanX4K /VH4VAdt6MB3irVwTZwiSk23iz9XLy9gsvDOzO2kotSX8vEkSSn5qds436Whbw4mzYq5iurJywaQ 1nVHsAUl3+etQalBqQHpQ666m//o6jzMS0WRwf+AmIorvTQAszoqGTYfTZL72zxk89tYBXeqSdKh bW6CA2YIzUzuFaDyNEqHU28GN1apexuPC2p60zaUsIYSDGsoRds8oEGprQakh4LRCHQrjI7dd37A Fl+qqKN5jxth2jhNLSMwYKGoJPebFnuv5aZc1U9V2OaNdl3ylNLJe9y6YnCj7Q+H2NWzkxA2lBLV UFI1tICS9cY1KLXVgPTB1jJU64/cJmwcu8UUL1t2Y1FMudWkQIuwbAKpGwLoOEpIXlKVcVP4hOQd 2UYArpzIZ3drFi5thxSr3UaqGd0NSg1KbX1MQNoK3sDrksqfUMoAtFXWlJFdgVkx+cwkmE2WLOez se070wqMco1SHbqVUw7b/HalWNJm71p/m++gC26EU7oc5p5Qg1KDUgPS+15XR0TO2y+cowqryxxE CUL5FHwz2VSbhGmTgKyORClVMEL/L6xOi7ANyUM5qkK4lHVLpQBQpk7OoKTD3Ww0SYNSg1ID0key VjVMYRm6QbW9UrptqG5MGVRUVW/n7bFlb+1KKeUiSQ/d5tttl40DEqCyj5RAhQlaaVJArlPq1lCq hrc1KDUoNSA9vtUfLaLcANSsxYRmgErwyTVJyT9KoZsDSPYhoQwjUjmV/COE4ifVnlIpkixgQspN t+m63JiboUSVUqoGvqnp7VDCBqUGpQakj+GZr83sUIdq2V/CuUoKAZZV4O456SlQUUpWFpBHVxbF ND91XjCeTe1c7a3NuNClWdwOojwGNxVNGpR0E8sVlKhBqUGpAelDrK1+tpk3BBsFkpUaguOXh3Q+ nVxZpZokTMWVlToKbm7XIHIDamFu1yFbMrmzMqJZ2FZn4KwZt0GpQamtj04hxY0Bbceh5N38s+uC /9mhDufKZgA5XMtKiBYwqkzvzVMFJtk4DhYgcuXkI3EpbcOdoJTDt1nPW4NSg1ID0iNZ3VwN9Rsj SIiO1SBBniQw85KyKgoQ1qoKw/wwL2ppBiOFDVY+Eq7BhHO1hCWcS2Y32SZ0nurX7Za8vcSKKBuU GpQakD76VUMmLAmFq/O5v20FnsrYnikj6cZF3a0EtXgpe0q4pZoQ0h7gdWnAAkq2Uy6pCd6g1KDU gPQxLjwXUGGlkvwSh1eoFBZthWsVpOQyKxAwKBUfiUwtIYSybVJSS+TTASiHbpaBW0KJGpQalBqQ Pj2RdEIlJRCV2Kzeijsb21DUEaxglK8vmTk/nwe/KbJyeIde0Y3uK1mJAJWyAJ3NvYLSxgYADUoN Sg1IH4XhvfSRCE+fJ1y9BGHjgK5DOMowyj7SKYPbFBPOR5ikEgE3u3WAv1dxk9cnef9bHvbWoNSg 1ID03tfwgE9pHqIt4ZRaRijPWKr8o9KLUnlJtFBH9YnWmTdcVHXPs27Bze0UvhmUZltxNyg1KDUg PcJ11ya4rRaTsPjzS/gWqgM5LB6HKNcvVTucKFwcQn5CxCNqqcPlbKWqFOAIlLoGpQalBqRP3ldK qf/ZcTvzkGimiGxj7SKW6p1yoUyghHqwW1JKVI8sybvk2kaUGUqhQalBqQHpk1rH65GOqqYq9b95 ANvliEuj27ZAuSVsw2URJbqCchChjy8hn8XdlFKDUgPSZ6aMzn0ZqAJPOqDTBgK0gNLKPyoZN4AF mDC4EqvaTCzzhqWAcgUl2cutQalBqQHps/hzt4CFG7dAnHvcGVjr1D8cCdtwo82kysAdg5Ka4A1K DUoNSJ+cXDp1QJpvlOd0U5VRywfyvIJ7HarhQkXN/6VVFq4McWtQalBqQPrUeBPP2L1k809fbBZQ h2v5IXOJJFZwmkELsTodN7eXp7xhQIYSaSV3g1KDUgPSR7+6O/yF4Q6XElQqp6ZV6Wgjmp9Si8lK LRHioimXCpQ6G8nUoNSg1ID0aQZqG6EaAZ1zQFbG0TIRRzg7rindZlECkMI03CgBWJyojMVtUGpQ akBqntKMWHjk4J1n2ZIy2vSRKi+JlmqJ8vSA2WC3BqUGpQakzxRE61cgTYk89uosZBLOLkbvqq1V UhreDSndn9USzjajPA0laFBqUGpA+qzCuUoRHQ3nMHtJ6efc+Y+efSOos3Tkl6GHflSppVnGDU9D CRqUGpQakD7fVQoiqQ7HiGAelm2FfnXhZGk18czdfMYSLkK3DCXti+salBqUGpA++lXG3Ib7hROs S4+S8Y1eKkAbxZJ1hs3AhKkcQAG0aDGhPLIEG5QalBqQ2nKhs/SZaH2wrtpSql1zdZRbdarARN7r htacm7ZSwpmnVO331qDUoNSA9Fn9yWdVAMBsPACVTBstK7qRkmWUNqP02QHz8SXZW9LBb8nsXvS9 NSg1KDUgtXXr8RiWt0plSQlG9dSAsulkARPmNhTMpQGEDUoNSg1In1UktpVBO6tIMuXXNlL/Ka2/ hNGqJgkKmGi2u0mDUoNSA1Jb51AIzz4oAyxgtDLBKzAltdSg1KDUVgPSHal07KCkjQLJ49m2ecYt ww7Ja4/IQbMFpWZ0Nyg1ILV1DFBboR/VgwBgUZtE26HeLITDtGllmihZQQkXcGpQalBqQPpcQrRj 3hIeVUtYb6+05U8hHJ+XlEI4qvvcUgkALqZLNig1KDUgfQKkeYcDCW97zCONuLSo2K6nTtKiWZfw Fihhg1KDUgNSW3eE1raPVDnji/G3ixndyexuUGpQakBqVDnvYMMFeM7XVwt3e7FZQLW10gJK2KDU oNSA1NbdAjlaCCHfQmlmbM/rkhZQgm0o5bKABqUGpQaktorjPT8A8UwznNZjuCsI+RylGmYLKEGD UoNSA1JbdzG41zfEJYx8AjfhsjygVks1lKBBqUGpAamt+4fYfHhbBaZseS+hVM9halBqUGpAaus9 CKsMqhWUFjvjNig1KDUgtXWetbTYgWSR+ie8/SAtUIIGpQalBqS27veVxFPwWp5mUILsKzUoNSg1 ILX1UCb3ov+t3jmpgIkgmd4GogalBqUGpLbuL5pbHZRb00wqMFWmd4NSg1IDUlvviiDcPBzpnF66 BqUGpQaktu5N/dx2AOJGvLaUTA1KDUoNSG3dkUTnHWB3OgbnbScExVdqUGpQakBq690cbsK3pNSm WmpQalBqQGrrnhTVnWcxLdRSg1KDUgNSW49GcTUoNSg1ILV1/2w5sgXTauZ2g1KDUgNSW+89lsNt ODUoNSg1ILX1qEBF2KDUoNSA1NYHUkdbFdwNSg1KDUhtfSjvegYmbFBqUGpAauseNdA7F082KDUo NSC19SjVU4NSg1IDUlsNSg1KDUoNSG01KDUofV5QakBqUGpQalBqQGqLbnOyEW4dYdKg1KDUgNTW gyieoxccAVODUoNSA1Jbj4hcDUoNSg1IbTUoNSg1KDUgfa7AaVBqUPp8oNSA1JRSg1KDUgNSWw1K DUoNSg1IDUoNSg1KDUhtNSg1KDUoNSA1KDUoNSg1ILXVoNSg1KDUgNSg1KDUoIQNSG01KDUoNSg1 ILXVoNSg9KlAqQGpQalBqUGpAamtBqUPB6V8XYNSA1JbnzqUYBNKiAVMHxpKfBukCkqRr6N7hBKf JmhQakBq68NDiQp45rBaqKUtKNFRKPHDdHeFEt0ZSpNcfg9QYpUE5FC6ZihNDUqfN5DkS2rzc0n3 /BGnM252l+dCH4ZT9wkl3IJSOA9KeBRKCo1NKGF3DEp4NpQCX4f+mPEBoHTDUHrFUMIGpaaQHvwj /Y4QofdNn7tDqdziBJToBJToIaDUKUA0zLoPKNWe0ikoTXwe7wClHUMpMJSQoXS9CaU+8q+dnuD9 QimtTSg1IH2oFbc+gnhSKb0rIeiTexGpwKpAKREJ86t6HEq4DSUsvtIWlOg0lCRc07DtFJQggWgG JezXUJLLcAElxgjDSqAUWBnxvwwlBlTk8C7y74snoMR/K9/4LChdjq+R7xQylCJDaVpD6fvwFK72 vz4TSkklbUIJG5DOWocjCLnrmu6IqHsAS7y/j/8HJM+toVt1KRYo5dtVUKIMJQcXrqBEIFDy7Nsa SnL+JJRwDSVVLxWU+HcOaygxgFZQOpZ9iwoluY4pU6AE0ZTSDErE1IoGJYwashUopfAtQekmxMhs 2/HZJZSeMZT6NZT2+0v84zi8JZTOVcwfdvWfXgwlx/U70kE+UnTqfaTFDtm05Q9h+be+HR5hEJ68 4GFBh6eu9isdSvzp1PS+vkYKHcJiiHnmn4xtSM4nJRS/MRjtpRPFpG9SyH8pzf9w8kvyq43lVad8 O35sJH9adn3CpFzuvx78CZSf9R0iRaX96285OTrTZX57hpJdpik0ZgFfFoWe/CcIUxlKEELUSFJ+ r8Rzk3KJvxg5cuv5DmO/ozgdmEgRGEoQR7nRG34mT4AFVIS9Qile90/5Xk9ifPYGwssdTOOeb3MJ 4yjg+Q2fXsMf757QLxhKr3bf51fx7/wlUSjRGkB/6deLSvq3fPrrs9/4ppC21rh8ycZ3j9nu9IGt PmsnIbYKA4nS/Wh2PZ1pslN1ehcI3fExTm3PVJncyoPsIblSosp3EhJhVkrOlBNKCZZKqfOfu+NK CbuilMzshqSMVCml6/3ypICSGhKfCc9USnI7RgljZKGUyFQZqyIOwlyhkYRvzKuuKCUhVDcEjtZU KQ2slPj3cej2hpUSh3BnK6WnrJTesFI6mFL6EQPrOf8LtVK6/mhN7k9MISV1tBYY9l1434LjPr9g ToqiB/4WOydZuL6RKSXMSqmY3Fhga1BypeQIK38nVpo0LJUSzW5QlE5RSjRTSq56qNalBFArpWLF +xWYuUn2GKqUir6dKSU9iiZ9mEBSHsWcJL+P/H8UgS5KKYArJVZS/MiseTg8A4YSjBO4NARgKMGB lVJcKKWncYyv4QYnGCA+O6hSUu7Bd2maBD5PXSkBK6Vv46sf/QvBz/mirwAqpeR/8YuPSil9eiHb +XGZSZd4GwdwGcJRfT3dDSzHngfOH/p9fmnd9TgsoRusTaUqUMKaW+mQz6zwD33QeMiybhb/rL+6 58Gc/UMeN5Iqowwl4QBlBp4HJWVHHb5RdZ3fD1NkSIowDd8mPtfp/QyQCUqsnxRK9sAa4kX+MxOU uoGhMvL5aQNK/AiXT+N0Tfg0XgSGUkxQml5fAkw3rK++xb9tDxPHffv91wVKP/wXYCgRfHVZvYIC pz/6qKD0YUK2V6ciL1HaOPeE8GE+oH7Y5n9vB0d6w3A79MI5rOqPcAnbaIMCy99/H9Haqejt1OPf rVarmGl16FYrIDe5YdlikszvnI0L1W1CdfLQDVNY14GFbyJPxNBORndnWTUOoyQDh9T5fTWEk/CL PPyCZYgGyfS2TBvQInyDKntnt+PfJVk3/v0cxlkoGfy5jD1FycRJxs3CNw3xJAyL/JyZSl1HQTy1 qD/3uBt2DJodUuxwGl8Hjs4YX0Gh1MUDi7IB4/MDTh3/GyVs28mfyFB6oeEbRUkG/el91Cg1D+mu IdmIs6JH2g7Xjvk7sfrAxfUHcAmUdL94NElBt32ACTKEbpEmeOSx6J5O5wD3XQpHceE/Lf2klHkz SFHJyFXpfwMTzsGE2V9iAM2gJFGRnCookXpG5h2J32MeFCqY8CwoefsInb5OzkcrITAfSX0sKdTs +HdF968WUOI4T7NtwqQOFUoKKfWU+O/GniF7gSyRMF6+EU1VQYmfwov9CkoAf/gONUqPL/P20QBp 1FT+23xebvuQxTUBIh1RTTQPI1bKjSolhTMSYLlPDSg6Dob6dJ9h6rHT24d4Vpu0PLDrosksohbl AIj5ZUWvV7K8WagUU2V649wA15jJeuASlFALLckBZFDiN7Q3IzxVdju0yAzvTaXk4NGU/jnAUihN XobQaRkAWSW5PmfSQiZ+ziE6lCD0nf0dMUFJZNEkPw8hSrdJPGhpwNP4BMPhFcaRVZZC6SVf9w1D 6au3LJx8vCb3R+Qh4VwNxal4F3hMHdX3iZVS2lQtx7JfVHwhBDpORUlkY4nmcOEnVdZKMYLPNJ3w Q8b29/G7scAaZ3I0lwzknD3WIWCYGUHkqpWg9s/1GnQLRwGVHR1MrKR8dapZyCn+6mH9jD0VTLen VFJAqbSAf5v5VyCxF1F+fL2K9EDQWlC5cyShUeQvuRgsTThJpYAk5PgY7lkHjVIiEKWSEmAYAQ5q fA+Al3zxzTVDZgpPYRffTPK1fIPhxQ6mr/f8QKUcoO9/j74P13BP5QCfK5DkxRweBl7HqrGziY20 MriXN/PbotXe0BxOXknj+W61QxG34ELklqvejlK7aYLSCjiPIQ1LJy9avLbL9plSuAS0YVHjqkBo 7jTjDEzofXL2+up4k8qFoxnPqf7lWF9P6ctEWUTkL//s1zJc7H3GGXgSpxK4kMzVjtVlYPVIamGT Hygkj6eXEZrJLco7qpQjgZL8qDemXj1ypg8olC5YaO3jxGKJSXbBn4/9ECHukeJTeTx+tDcsoxhK 04kapR/tCX4+eObtzib3BzO4H4dCwv7On8KSxl+qoy0QFe/I7pdJ45DJlKKqvo6KIMLlx41y9i3B KOV19IjEha+in6mSYK6hBDCvgq594scmirYgfyr6LH8/FdUzV0mFOQkomH7A/C5USmldR4kp70cz y8ww1pXUGmT1YwrJ4ATkQmYLPMaV6jK9KSGW1ES5LlZlCB15eSUfWZOWUAaU8yR31gfR4kmp62aV 1DF5JgnyBEpyzXATduME+3jJwomjwd2IW4WT3WsGyyQlms9hmXn7e/hTePkjVkk/k8xbrZKWUDpt Cn6iQPqN/21dlTxjSRoPpCJJngV2Jyqsz6i+jhswsihND455dn9mcpcIgpbmtn270sohzonh+vHQ /adUMAizepxZ1YtBi0rMWRUVED6a4tnTPX+ABIuiUaxTiHS6ODwn2N1CqoqMVqFbSuB531u+sTbn KuypFDmlTHxX4CSZWm3YJc/fk6Xyy/cNVWUBKRzDxEPRVOiayW8b9DEqmJmEs/BNRZRVGwWGU2RY RRLFFLooX4eoKULwmxAplDqYxAGbboiYYVbNfa2QSuUAdH2JT+MIuUbp+QHgm0uE6YZV0gWHbfLs /xAOh1/yb/wliycO3Tah9HhDt0fvIY1HnPdp4R3VhY+GGcpqZw6O6N/J6XB0lRSXWbatDBrV2bUU gOgnYha2ZT/XzYhidmcopUPdnmnNSny8zbm0DM9o5XPROf4XFVG0VEtHQ7fiKcVSRJleUhUgqVLS SoCsRom8PKlzbUOlXil1sWhgZoBKSgtKfB0olxT5W4oFQJWvRFaMnkPCLK8kdJMHCEGVeTD/Sv8n KilKcq5T04j6GGiK0oRiNUq7YaDDyA8cRy0H4OgMcP80isn9msO2OF2Bmtxfv+IPxN5Dt+tz/KRz iybfu0p6cCCFcEVS+g6dJELCKhYJksQwdbtWRfphjwsMhQ1M4ZI7i7CnCs3qEgBpSnKjyA8yuYiQ lmBK4MkWaLmcVmEbzEzX2YetxBLlHS8RQPncbXHggUTQWQcc3Wq2rylFdzDjCWmVBJiFeQAL2Wlf AvpmhuInKajMl4GqH02vDMIMA5NhBTCF3MaoBB7ywktKTriBR6xpSqrIpJZxRS/z6+zosL43CpBU lHTxqTbSyzHErhRORvWOjI9RPiYceqH1xU0omTc4SFIP+yi2lZQESLB3m8l9dz/pcYRuj0ohocy+ iuQwGvMxVg5SneowL6ypVI0rpiNFhwogUgaB9wiAfytWkMEZgKp/Y4oJcn8BzVQNYQpA7AOUb1+a 2eb1wpjDuHXOdU6lDxvD4SYPj7vedCpTuVFAusUnqrwkrMrX5+EbZcN7Hr5pop1UNeX30MsBNBxD m0Ipz6kzpVyBY+axY4ESmHlkusutIC92TcrKE3XpSn/YFCYKEKXljmEUo/pMJp+SnySZN6kBkPkE QiUtnDzb5O4ULGs/iXby10jR5McRuj0iIN24xySvy6E2gvRLUGBjxuHcVyou0KyPzb6MMBnZKa2S M2ruKRVzO+oXXHDwKL/KNyZ4+0ACF8FSJUExlfw7OZsNOO9Z2JwSgAs19CjDNrr9ohW81mopJQoI z2gypjpkoy2V5G0s6DJX3uVQJe9yeGVvIZJXeZMVWSpwOocLeeaNMMPFDGyA4hdBbi1BS/kTVNTJ WbmqHMDnHbghbn9252Ekep2APBkztqNMgcsmtwg6DsmGQ9DpACKm5FdcPsXaT4qdhG4TceiGKXTr +wv1k46Hbtf8768enUr6SOqQxuqpzsI1r6Q+5iXVDjGmb0q/j0Eqeus5ZpCU0masvtlxVuxIa5M7 m+LVkIxsH9Wip4YQHvkU0iMdoLUEB54AF60htYYRlUEicEvzc36MKh+m7lFRSbVaMm2k9k3+YiFX OqRNaKqUXBl1ZnKrVd0BZNAYZiyey7BJPpViKJUbuWyCmcntULIeuy4pfJ0AICZ3kC/C2K1Mbqnm 5PNj3AuD+E/saTcgHkaTcxq2XcaQ/KS3C93+B1hn3T68SnpAIP09n674dHEiROMXJ95Qehp7fULa jjgHsk4FzaYUYZS3b4IybDBCCsHsmF2EbohuWlOulk6AQcuMkc1R8kxKZW5WFdcmyBHnl+WKmJQf RloVRqaivoAL1hwrP8IP0WV7VwMJTvfC1f2ICUSzv43WPhPScSWWcmg095Mox8KYshUZTMGvL6qp qBbLzSuMtIBSlBMkE1yTaF05DjCa/yQl1hkw5JI9N94GD9fSl19VTqD/Ra0sj3Y7mc0tCAyU4Wcm N5L5SYEjtxhGGVwZrV/K/CQvmpSeXQ7jbgvdAL7UrBsN54ZuH1YlPUKFdHCl0+mhhJjgFBM0MmQk jDPSgIdgOgNMq7itjmSuaLwGqQKNxfn5fGrYrsxNNFwF+27Sx/M4L1USoE+TyBXE0XzqbLpi7ovL gQRZ80MxwfHuMHgUimn544a3nUPlDT8JoSrpWXhy9ZcBnmjI00/9hkryGSCWkRMlg2TTBDSrpoVD EnVRrkch9IZdyopIhhfZLCYCmPtJQfSURvpVOIdRuYJU/KTqfsEiu878JDQ/ifQnOZjmfhIdFH/U 8zPX+qSRwo5vOOqN8dzQbZ1129O6GPnxqKT+8RzaVXGk1iTVRnZcDPpIYdtUfcPmWqVKKdk3Xoxp jrZl2eTdtDIS+zaCXGPilbp6mRpUwdtCYw4R8uiNDKfgYVoS3GVoYslxV3Gc35+OjJxMRZKPvcuQ NkK4tT2/USKwBFHd/1c1NJ89xgXXF2ByeopKoqKSPD7nkMcDOR0CaRn+zms3QlJMdeiWfSEDlqbM 5i0kGN0SKqFbvo48jNMvWtvcwA63jpLPVUFsHrpNJs4WoRuxQiI68C+d4CnsSugWd87Y7/qokm/c 4H7yrirpYwDSf8d/0P/Jf9i/Ah0yBf+RT1+cfW9tHkEL2yFBg0XSGEC7EeewoZxly2FZTBW0k5nT uRgyGc9FJUVLzBRVhOkLLPsDUSFjU0pDCdvqrFutknJYF/UbWf+tvq29Y6SG0RxOG7l+XFf7PF5/ +/ZygIoSGTT+gtLstuXvpnmT8uKU1dNGUDd/XdHxVsaehPyzwQgt0sGkn/j9U+Hj5QN6DFiRtVQ4 ilIKbvdIpJX8J3IZH0pYh34Zru4nv9FCNxFE6AKMldjR0G3SCgKqQrcLPr9XOcaPesG420eT6PGG bz8gfcGi6ptLkvlJ4/j1hsH91irpwcO296KQQnjCr+XkIwNZd4qZBwdXLINUe3mDdpzPPxqL94sZ Skkd2b+e+fIDNnlHmA9ejFRS/PJro7yvZnZLaYingSOk2/kB72FbzN+p1YGNpcIy/4ml883Sz1Cq jr0MkBCOw4jwiGVEj2TEKG71pW2FT0dS/7SCFS0q1Oeh3BxE9aTtOvTbau2ZvSlJhqkkCzT3mny+ pAZIAhAsJnjAFFg7RNDVUwnBUNO/fCwbnPJ1Egr67U+Gbr4xpr0eAXLdE/PKZpZwCNaJ6x2ER7I5 AE2j4k+ybiSDBVghRZiCNuHun+pUgDdSVinV3lImwGFbCF+q3fGxqKT3AKRfunLqFoY2/2ppHTna NxUpmYx2stS/fGvolw3WADJVZMVn9oAJOq66POOBpqpdHWEKu0xRaRWIVvar/2hlk+721N/Ssc4/ Lz6zNZhKGo0W58MsPKMTNtKjGS1KZ3lbuK2gcCu0ywUVtRG+NLprvw+q3nyatebYF8ttnls96sQO QS8gE/2C5PoJNGXiGxLYLihkKoe8spfVjByIOgiOPF8bynUGJw38bRZ4uQ59m+2klspQST3GvIwg tcbw+dHr2zoc4oijdr+gul8yqmRWMMkAWqok/OZL3ViAVRKep5Lq9WFU0j0C6Y9ZWn5z8tscwwVZ w/aRv2efvJNpq0GW0gz4UUY6yPtmAIJykM7CNTlQoyodKTdTs1u+EoOo4ciHnf2rqjvEVM+GpUVT J0LMVFJqIq9Hsa4/jbgCUn0eZ6WcMB9fi8do8GFVEr7jAbi9h8uRQXsFPnWOchtKyWTGWXErHJ+I l75e0kwSrGaReIYfbVSENutjdCNcDHKZHqKXm9us1+tmBBQcYuTAsSSIqB89UD0uyyBSOIFDLkFP D0A5oEPwV+yIwW0qCXawMLj53w2VdL6XdKe6pI9EIYnq+wmcBO83/N8TmUesx8JTsWt0swhg/vtG EVXtjx10UqIqXzgj6PubATU5gKKGZiVcE+jIAJqcaZPbMIDk+IpWqGYhGdiYGjQ1Fb2jLeY666KS SthWevqXneepoLGMYs3dmfXAMlzlxG+dqf3od2S/m5+0vsNSFWGedb3Iys2zbqmAcVWeAVXm9QRm c0wXIBdYuu8XPK8KNpNExLmBJljKI1/vntRcJfnP2q7mSsvV0UIl2W8wFaYZwaBmdjDMUJqqqUM0 Qx8nmiqVtOPTKBN3ZeOBSJsqafrmjfailGJJYJUEGyop1SV9dCGbyLe/uvvdpEbr+fLC106vsEj7 B6qFlLlFtbGd1FL0sI0URtHi7xTGWUIErdXaGhEEShL0BQ3LLGwL3kmkTdhRHzyNWvMKpQwjLHb4 bPMwH3/jFcOlaI+W7Q4FSjjzh1YjlD4KBN0BPisvap6Qw/UmCrRyzmkGJyqFh3U4nZMPZaOQfP1W 8SXljSwpNcKVbKpv2ZRDuKScqNqyKZnW5iXNVBLquEi7TTUwqVJJKtvlbsIwcTelVeCISppk0Buu VNJErugORJcs/PekO9/KQ8jkAFY7eLwuaWt9WHO7v8PX39kfEtmR5QfDFxTGcp8QLvl9kJDOnWph kWQnZdv0zeZaD9Ow1AeJCrIBWWDqVttJSF1qy7RFT/MbiCJ2CigN08QXkh9iAY+iKp23dy2rJOsa wAmKOgKozaP59J2Qh7NlMNVNoUsoVT1vmzroI+XRGdKJVqoIYb2jy8pHgirTmecfrcbCFBhFqvsS 698QoR6ttDGqOEDpoaT5e0eaj/Hpf66cbO5uMcu9zCCEXGoQTntJqMUlumOvKHvZDcBCN6vXnKkk O5wpqSQOxy748r2miXfW0RJHuOLbvWaVFLsr3K5LGl0ZbYVtn6KpvfsWhf0N9v0T4hdhXSgimTbN YIqpzS/SNb84vWwYwUGxNtii+Ui45SNhlfqP/r5SyqJJjZHs3xchKSX1kTBaZau+vVHbbLUvyOCE Kd1PDifps8acTZuqjVhxYzs2qob5ZDCRzxb06uwjMza2FBF+oiw62XZCm4nF3F6bp9zWRZRrEOXJ C1kdxfqLI+IMUpCGRm5LvfSeBM/jyyGLBojgcAruKZGmhgMUP8h9J5P6Bg8HV+1H2p2C+1Iu+1Xl q1IC64ux3ykbdTN87FMyqZugYdrAj5/rkgyMkWUSBIbRxAe8NqZ8SRZ5XPufd8zc/vBh24Nn2bru mexDhXlIGysltQehDGkLeOCXfdBDx9pHJgXWBNbAiLMDKeqUPPUb0RSuAaiquFZVpFpIgaOXuWrK YZx7RSiYwjD5WDXUYlvzf6Y02rFMM4Jq4EjlKKUabcIyC3LlIRUKEVXqKORA5pOSRUe8sHW2jciL VmcXV+3KuTexrlsqtUs0D9EKjHznR4/zEbP6XaimdMysSUpU78gVll8cxRvMxQIp1Cu7J9gkpJxJ K3VJ5PVOTBqpwwSN00gtTY0AybM2QTrZiA/GoG6pgnKQ3ZckyTeijY4j63FzcxvU3I70htm2ZW6r MXL4isO2wcxt3Zfs5lGEbe+3Uru7WM1EEihdM5QGtK22UM1tfjuEYSFSqQ+y06TfE51uhxS0ObpX Hav+EcNFwzQ907mJrUWPkjCLVm+Gk1XlyjuPU9RRyjGl+QVbk8MFvDENsZ4+RlA28KnHHdrADP+W SxPkZ/VLJUxDhHng8Cn4R2f4Sputb5sbJ2zsf0ewKIrM5+tG1gKpDK5YFb0mQEXvLat8JvTC2cS6 PKJm9cRLkQEtOqRxFrYtM67ey5S+rHyEigHFSg+CZmfEdEAJ7PTr2M1tzOY29lJjpBuzyFhJwEvq GTP+AYm6CWU2t4HDNvidSDbEzcztedjG60f/zGHb8CjCtncA0v/MT/zf8x/w6/nFl0zh7hKNuNZg G8IXNqTt6DFbFUcuUv8WnqFn2sANazO2UedcRfeRYvGRXCWBTWKPFraJhxSUZ5rRl734QFO3Ey0b NH1waOoB8cQalX4U6xIPFuIlA1IrgYHyFLi6ShhmM6LD/OheVw186utUfdKx7BsW/2jhLSFWw/Jo YWKnPjOogGStHPoFZOq59KjlsTXZ10ym04mcHWHykeZuVKAMoQSiedhm+t8uI/tO1OMh2FhJaxhY hm3S56mugn6n8kc47sYctiXlwmEbnA7bHme27YP0sqVqbe1OrIsjZSgb9mRFsDY3xg8Gfr3JwjcF j+zP10cVPAqezrJm4J5Q9PYP60eTCvvJx5wGj+cYTBKnC6A8VCOvMxBuIVaKNJBP5epcBqXv32RM JjChG5ipAx2qb0rI09oQ8laXG8b2R5fsv2MNwPxPo9qGww3zG1cmd5YwZaJ+DSFYgWgOIx+152Ue mpLXymo1HL2V0fwmwOJNxjLQr4gsPPaHo49RwopM9fiZNBLCbldtninfj0HnmZhgD7rlnG2HMg/b +PE0bNvx3fZ2mZYteAnAZdSwTbM70qii2bbBD+jv5mybwenwqA6cewSSxJY/hO1+tl96+4j0Il7Q S3yJpRZJ3o3BapFgrA7KzsGk3yFqZJuP5Ib1JN8RUcI3N6vJwzbKZnV0GGlYls1ttKgPTHNhGhmI 6enYdvOzwt9U6eIDvqp0szdlGoxk+61AeTOwov6rKuESAGxO9C2fz0/HRqKzb7TVpYaz7pl5bwpW c6vSoCsqjaoL4zumMSGYAGXlHQ4jiF5dHTFNfsiV/kRVRTjl6oC00dvRFaCUECSPqSTyAni4plvJ uUdlM011V3D1t8mHcKsHNJVsmzWX8+U7MY3gEmSXkhFtzNNTHelzxbB5A9aCTvFatk3iSLDLr989 +EgfgUL6G7ilOPKrUkWQU/+sjG74hfFM2yF01KsScmN7OpiGCeg+krZqSxFl9HrbSg25OlKVxPCR mDyiqySvsGVlFC31gcnMLurITACDUsn2GGds2mDKopCNKAzuIwWse6U8NCPvzoP8yalqj24Hz8cK JjpXK92G4lVZP1YhWz2pk1Yp/hzGpa57G4GGaVO26JuVRLS5Rg4j9Do0n+CQeh+xGlkTc4M25CZt wvm7enqDdfeaAqRp3lqq69kU+6KKON9zLlb7Aw9grSRgkIqyXclF/u4zH+lm5SPB13uI0xuwzPcx H+nOWQt6hECSjv//gto+AtY+IrVI31twKXx1SXR1QJlNJU0/+p2kRfkl04bUa4KrNrbFxpNa2WmC knUzE4kUPAGsuNEqsD2lLzCiYCqJI2mbbSMjAQL6kMi0R0iazWy7jUZIUMrKn0KHaQcLD9USgLTu CHwDw1mLSZrCvJpYhp+sGnoAJbUyvFcFk3mTz6yafBItJfik3ta8Pa2N+I++WUj0+egGI8/Autdk 6smKZ6uJEb61Vu6hy5NHq/aVPJ2mbOy2Uk9eKBuq5gSNSaNPXQ5efmAl5OYjTe5LkUPKxj5HybjB 3EfKL9m0B+rCZs/W993pfTlTRh+u2fZBPaR++IIGlnzT9E/+oVvvz5YzbfwKD4GJHTuaG9teiY2x DN2fvJN/kk2GQSQQWVat+EhSjWE1SQYmCa6jzbmZ1CVKTUuujNJBY6NqKE8BzCNIXWh7U6RX20bz jawexTMnaWxk1OZN/wqf9VDNwISflHd0h6zbWV+sC3WEefJk9eGam9w+XT/vnZc3ZPAp2aZ0I6Wy AAvT7AuOCpzAsrEZTL7Ng5eRAFVTJiLGNDon7/cNc78p0HliIlQsoQWi48JvFH9J8jKjGtt44TXH 9T3c2E41v+YbzeuR5Dztf41wa7PtowbSGe0jXhypL12uRZqn/pEVkc4VdmN73tPmRY8ohnagDq0k QL7F5ABRV1qLhlwladgWGFEx8BVqL4mdJ7KH0TQF+4oJiLkFJPtHSRnpjEcq85TT1sve2BAqMAW0 Gwdv5w1Y9LKlcAFTvRGWfcbSQUeLqkD6jFQSHRFISKchRlC2xMJKb0SaZeyWBjdVFd35vSw1Sph3 k83KSC2AMhtLvEYrCTEwWSjnG9jE2cTRlKHzkchFTS2hlKbXhBOA7m6PiHYMELEzaETfbbV6mQ8O MZePk/hDS2P78a2HUUi3pP6l6/9VeElP4jVmY1veyC0faWQOyEAHLYbs4qQVGqOkHDRT52alptti XGbW1MxW99w8I212M08HfWYkpnHYAdI40rL3n0/8I20vCv6NKbnBYBNM0YZ9gW9IG7xrXGe/Y3I9 sVQ/uhcw+0YkI1aAtgiqDQCWdhAsygRyqOajjSCP/sQqfLPkvatsCpRHEaX9jOy+7kVa5aHW+/sX n8dPcnxNXtIxVUWWuf0IUvuRAwq9GFe/j9Rzilb9pMW8HqLGNP04wxXOOhC0Urs7fjXDiD9c4nXz obqX0kzERz8O+e5AulM/26lMG82M7YHwUj7J5iNJJTcRX3YYdS4fJKWkb7YO9IvmKYGOOA+MKFVL tUrSqexRZgFOBUApEIc8DhKcOGnb2fneWpA2ttF9kWX+cSCfIJg2KFQ4SQuBVw4QeLyfWg+C1x2l spiwCMmoKCRqPEqcwa2NApZhm+/akPeR8ctnu8zkad7RvSSfM7TMwlmhT/T9sr1Bl3KYBhlABiMi rVPTy2PO0EGeqWXXxTLmGOshgkUt6eQJ4V5M3211UK8z5DcwImHVWIzuPIDHVZKk/Skpoyv+j2SP 25xp04xe9agl03bb+suPYcj/sjhS0oE/BPibJ0czbRvGNs58JCmQVJOgX4dtkxjYMZiHJHXxjJwg pfeS2Z+ySpLuRHkPHED6dYdVmGaXmREEbhZhBaOQCjAxeAGdUjSmrm2ymjdho8GJcgNt2mhLw7aQ vYCwtD1mKgnn+yR93jRaSybYNrWxqKPUIZKHYVmglnaWKVm4SFVHYgnnbBeQmBu5kyqyQupsctv2 fTCtPKao6dnJfCk3v3XcjYEpUuoW8K2SkiOAwZ9PtG+taAWYmn45ejQcig+Lc8Nc5mun79eP9Qi4 x5BtO9MmXf87rWV4zbTwnrZut/CR3vA7dUFlNhLQVtjmPU+miILVYJtKSv8G2RQdo2XsFUQB5p5R 9PfbsrcpykqhWbVVju7TpTPaOs+2WE+Sls7K2AHby4I0UeizswNlheQhBMIKRFV25RZzl+jTg9Sy b+12fwmPGOKpz222sS3VJUlFTflOI6nqkaIPdZtPCCgjTUwt2c4kDidDXFZGaAWWUwnVZItHuz73 T2qdmiumGKt57FgyfvpvKFlA8JBOv6sm231nNQqwI9zKhkg/qCaCprd4Z/4U4L9/BfD/3AD8ts64 LQe2PWwt0sNWalfGtr6+4WrbR3rNF+1eq8AIHPLCwCoKLWxT/yjotxNaq4eFbyyKAmWVJPk2/ooK CqASuqkSijpvVEM254FixlKtZOEb5c3/yMaV2Ih1fecpeiGlD+jSkRHB2vp15wo0q5yw7m1Km7QF SIZ2KuKmeevIUWUUoOrs/FQNozuqpqqtjcL8cv8KKBsIkJcZuQmO5TxWWyxhJWuweE7RNxWNlPrg VO1YCTVRHlUzuW80ZU9JJhQpmLTwNtUwWS+lhnZW7GvDTkNpe8mZDywlC5D+xjx4kCrrDGB/8ChR O9x8sF3vQjF+7grpdmNb0Ks+0m85Anr+lX9sLwwAwYafS9i207nXlm07yEyqOKlKmjrZ5tOUjioi VUlj1FSajxhBVUlMKVZjHBJOKpoVY8G6BLxSNm3il3Iu5MPXwcaWclyoX0PWPASGxRBSRi1azVFI M2u0Uxt9Vrtb9AYaVU24zqzNs263fng/wYFteAdLkubGNi524p5nqnx3oVohkffBYd5lxub0KzJ8 C2w9ImLaOsupEL3URKu4MV1mP0vRrY5BLspI+yKrnWu0ZSnDKnlMpqC83IBsiqkO/5dh/u43BR2S 6nAKXoDt236hD6k06wrU3qhfS1ZKgDra57MC0jmTI/8jh21frAskJURTpWCjSErYNlGdbdNe58MU 7YNvzbPpm8JUkr5z+i9KcSTDSCST6CYNrKIMNI769ktcl6DkW6f5ZutaC6CFlVFjMej0+0vycwoa 2WFUuq9tWqAZ2TIeMAb7Kka3n0KZMhjc3EiYc6CEGVzCxsfuUwvR3u4zgZuzk9b9bwDLjpNyP9Wz s80qXfxkD8f1kY6KdJVE1Q7FZuwkXzHWZrd5R+SKB93s1sSHnjd/iew+PgKHcslAVkdRj1mdXlpG o9TbdE15gAFCNslHmxWGYfTQbdg+aKRnhF7B6/6ZVivpKxgudXTPJ66Qbje2U4Fk8ZFA65FYLcGr mMK2HeFlr1JjHw40hHRw9DR2opL4DeMzrJKwqz0iCc10d22O2DznEXUg6KQFttkziuhQorSRW/aM 5Dsy+EY0Oj4gYGd15MIwsr2ZyMeRSvmTFkJqT1HweMDCs5CTzQk6s+rsqgRgQym1tfKtV9m1LW+J KspX2y/5hi55y86AudUtbeVghwHmwsn8hefgsDiPYsrCYZpGmbJuuT6JvG5JJbjDyMG0AS5TSlGf hamjoMcimr1l4Amp8tvGItllAqZJ/x7xV4EqdKc2tFQNIBM0iO4An/8M8H9zFPPV5UcFpFtS/2tj u/hIqR7pml+mJ5DDtrBjGAw525ZeTBQvqTdzm+R819n8UAnGAA1KQfJrusuebEIl1Y92XnZdEBcp 2lTQ7BkplBxEvvdaoLRLqBamRNnGRr61dIofgwk0fFMnQX4O1nliM49CUkUhzbtJ2Tb7BC3DLYPY LaFY2Dz7+TlJyyvo2PTJAiZEWBQZYtmVhqrtu1ODRYaPh3Lk/2LZWt3mz1jGrezVR1V1d1WTZN6R +0sZRpNtrRWj7WIityEP+2bqSHZZI5/3X4Vr+nXJlBP/aPLoIP39nUUUQUuNfPt3uW5ceUjYXYBN z5hfPrBYwHCs4//970DysKa2+kj/L27tZKshWrfTlrCXuKOn4TW/qJN1GvGLygijXUCf1dBHFkcy mCrae6KZjFxTGSeDUhr+GfRnvrH8ngwlKTOIOjY96u40nu71esigs43VK9Jh66x2OsiFkNp8EnRf QNJxlza/JrjznCKAKrYIM6UEqVXuTr7Q51KahHe2mOgomJDq+ewpRMO8DyPkUM0z/rmbv0xTwpSM 042QMVd36yCSUsk93+lYsyFUiikFRFjANPeXQgnpXGVFLbtFA1TQHXXIdlgKXv7CpzF47B804UNS AhCWr4kIrqdaRhCCdK6/4pDiqoK1rF/xSQD15C2tmr9+rEA65iPNw7afD/P0v7wYMf4mZ9uQkSTb H+GbnvDCwicFk6uk5CVZtrOTOiN5d7PBbQNnxU8aJdUmRtAUzD8yomjcBlqkFAJC3kPdxyXrN6Bu 8Bd0C4gCJoeQ+kU62C2rIwoeppWdRdAPe8zbaISN3rUWpt2vvlqOv8UyKHjmNeWd+9yXQaRqqrYP gk2d+rm1hLwHW+uJrEI2teGnUE7UtOb8bTutpJIsoxa1rDq3oshRGr1kQL420ed4kbU/yQEWrC9T qx7lC5SPZKnBEwgF7e+PNGq4JkduSI3m+gVuE5XEzH6tUNJv59mSXtJd9fN/cygNj+YdfUCFdDxs S9k2+PoKpqtvtEjyJX9FXOGe0h7ntUpKtuQh9FHKJWE0OI0MJwvdovlGMuvFarrNL1IoydHTS9u/ SttoX5SdeUbmRIJ6RpItERmlNpMKLf0vQ0ga/lU52fwaiqH6NJQtj0KozOlkbaQiybtkzULFsPgJ AwyP7BYez9OIRJsZPR+kRdXc4RSmWRKNCCovPE0AoDwsLpCH8TGNyyItGEmhEZXRpQA+Ic1Vkmb7 c+eANjnpIHjzl1CdTlNVKuJj9KxbSAMG9eegG1ao0ELbfSfNBVuFawd5TqNt1pQzbK8UPvyFryrp 1Ecd+fMJ4ZtbXuh/x4/x5x8LkGpjO/lI87BtK9uWiiTF3Ib40kaPvAlZJQGHat2BD59+1ABdJpSM A8ReZ1NZY/4UdESbKyBVM+YlR5uWFjQYY24poLo0JETzaCH4uCxBkfpDDiIq+22lMM2mUFiriM+q mVVo14Y2zjJmyz2eT8HIIUQRz6/T+WRdJPBK5jMhtQYTUj0Ct+p7sz090/7DlIbMlBslheT9khau pSGPKnsw5IxbMrop2sA+2zwi2PloE0sUOKaMxNiWVK90NYnVqV7SZCpMEBXN8JZvWX5sVUdSdDdN zlg+HWAzXEN8YuGn7OLDv/h1v+OPSbQM29eX0E3yWbsg2TAS0dpP/s5jlo9ZId2tp60a2FZn26wc lEF0RCXxHfiNGcM1iEoy3aNbQx4mGwaA1qDDjLH6QXOuwVP9VuXKgLNt+ORQ6qXhTQ67zsurfSvj IGBSJIly0hywbn8cdcq6HnPBwzRlTeeA8l0hQ2ezjXPxI2Gd2p9XW2/BaKmEWlPbXP0szexwC6AI toopbdutPPc27QeZZpn4XCMHD6XRJVgacFM/Gtk27pY1SyzTJlsrgNTdbnTisc1Wcn9J4aQpmJjN 76i3LQCLOWzT3XC8NIAfQ1LLDsFDyFsYGJz2HK7JE5FUDF5LrbBOYE3+kXzwtgztrnvO9z+Gov8D ZI9pgD/6GEO2Uz7SXxR4rcK2W1TSJb+Q+Ebl6g2/6LvB5KmGbh3Gwb87hTtTJw60vteQoSSvfSeq SDr1e5FBfgiBWkV8fQe2XalveyxgEgk9mUJSvS/YChWAUvZXhk4mlRSxtISkymzA0smfU9mLCu0E ogaht1dTxwA1nwKQxxTl28d5ZXdV0e0j+xK0fKR1tYuJpujMT8I8wsQVU9Rwzbbl8to2DfrAhghq CJZmeGutUsiz3zOMfMAgpqxbnlbZxVHh5IALY7SjVp7JpXc78WfmWlAp+7L1JOEayrgf9ZWSf/R1 NrRLhu0/A/zsiizlL5m1f3IgfdQe0omw7T9x2PYTDtuGL1bmtg6L+nrIKukVXcJTek34RvZ36avQ 7UZF0yRRF7++h2EHvTeRSX//HEq6/6dYPuIrWTVspE5NbBvDZ7lVmgRMZb8sCHm3US3LVn3lANJN AVLzm7ejVENuKWfaHE7hmDLyFhJqILpvQCHWgIp5m9ti9ZUeOMjz/H2ceh7+RmWQugXgVitE3ori G9cGUz9kmxwH3bPRygk6a8i1nW6IvBfOqgk6Lb5VVUSwgNGomTnP5GlvJh9DUZui5HDGyXr7tQVA IDOwOiJXR+I/HPiDcGn1KayOXocdTSDzwxhAv+1ZHz2BeSfS4zO03wVIZ4Ztnm1L6cUNc9uue+kq ae95dqY7B3cQ3lhfkYZuHe32/Gb3Pi6C34xxYFQFc3wTlHTwte79qN+C2gHZKWK0EK0jfmxWTFaI xkDSen3y6mvdoQ+81mgyAOnlU7Cd2otvRFTqjChVZ0MdtvlHY9YiUhRRS7M9dIh3RD0h5gIjwEDV vuieiUOqtvnOoxt942xKhQWx3jrJNw7w+ZPiXEcrbBQQqRGt4JHpgeIqZY9JLivmd6WMahgNYm+y OuI7jlbSKdk31ALiMWqCGHpTR2+uRS1ZGzgrHEn3h/4J33ZHMDGwUPyjnmRHaeRYT/2jo4b2+69B ukeFtBW2LYokj6qkykt6cdDi1pd4Q1eiZqUM4FIuO2hGYR+GuOu8k0f9JEaVeFMhh2/iKYnRDb22 xloqNOph0Zn2SdshqUrqgsAmWI1usPEiBqOgnrmNX7Idj73H1tpxLTQLtgMEQoFR8YwI047K9uMx RdRKAO4nU3dLeJfUk++1htW4bkzmuRZTz5two3W9pdG3vmFpity8LIAUItaga91Jrog0IybeEZlX JAa3GqAKHwVUar5dwWgwb4mvP4RJxzbPQrXDBR/TA+koJVVHg/4+UVKqjgJDJ2fXXp0I13j9tI7Q tvyjlGFb1SA99p1rtzaPXKukv2WV9D1WScPSS/rNDvAFv7jdjl/CFLp1HLqJSXfgd+8Q9geG0mCz zQuU+K3pRtujLZrBJzsNd9FHlgYfZSVqKWrSP0IK3dRREk0kiTKDkU6v0aFKk3pJHaUN+8TgDh6a +XY0el1X5h35z/7sMoTy0JE0MVJKFLCx6P7XBHkOWtq6KlUyztQT5ttTnoOdsnCx2l3NQRQpeVIK ocm3Q0oTRnXfEgheLa0wilPawp0qEGFkVWSbmGrtXdDOS7GZ4mRfi66MtLKbxgDuG41W5xQYRHuK N/LAYSQdwyTh2/WUvaOZOvp6R+vs2n9jdfSE5cBg/lG44vt8eP/oAYB0bM1VErBK2sy4wZ7Drh3M Q7c9wDXrncuBeTEwlK4ZSmEGJRr3eBhk7zxXSZLD6IOihdSB4gNG1ZJsta2Zs1DAZB1CXhopLLLQ zQ5FdF9JAWUzkNxT4mfYWStIKt51EPXeEUBV5qxL+zVD5XE0D+lh1JIeOamNcGaBJ1jNgOQaJ3fT E+XLQE0dnwyAvnOyzz+OZchb2sVaAnyDkNgDHdmAtmC7QSYQ6eA2eX5RM2nIsdioh5lcLp0IHv7x fcegG1oUGHUXYo3GfSfW+aiPE8R+YIUk7VcBLlkdveHjfjiqjrruy5Jde2ThGsC773CxuL+EbX8B c5UkYdu/ASuSvAb4ya8Qrv6E2cMq6eaf8TL+PkzTAcfxAqfpmt+jlzi92DE2nmI8vAxPWerIWyZ1 Q/Fi4K+YCz5/rVl5hpJ138sGeXK9ROZDJxNhggpfieY7LRcTAAXdO73TocbWua/hGV/XKRyC9ZrZ fGz1kHzOkZ1RmFRA8jAs2FY0s079rJJ8S5sTS9TX/AYdQHOYzlNBy0tLk9otB+1cIdWbUZbrpjKy LamkUhmeq72nNFhtolmnvs8k0u3eJ98PzjaZjLpLiWXYyMaNhD7i6PtoC5T4spGPWC2jzMqo16LM /cF9I/45dEEjB7xm+MWRrvun0qIQsWM49QdXRwdXR3tVR133Nf3j7gmDi7/Bd/9C8POUXZP1C/Jw bQEkCdn+F9hoGXnsIdspc9tLABYqKRz+PwZRqt7+Nt/mmWXdxE/iF/YV3XBgN7Cu4Nj55hA0BA6X RSkJEzjSE++ok+Bq5Chb1FKYtG9fiq+FIbGf9OupUz9Jq92ijqDlbyZeOrxbjrGuyzvYesLVABV9 91HdWp2/xjoN4ULKxQDWkEpbk6ZpqCcgk8rzjqe229r+HsRNJymFaLcBDevWwzw7CSt33FpQrDAS tcCQbOJfmucGpny8LijNK/ZtuiayXjQL37y4MupYeM3OTdpxYmoJJ1M7/niqjGh0k1zMbwnT+Ei+ 2R/4N+/0PHLcpr7RtRT+XqtSSn1rCUZ4+NqsgbPU0bFw7WiF9oMcpO8KpEW2LZnbWyUA215SbXCP 479gzrrN/KTDBpQkWzpxcDfES7nZoJWTNgptHOkg6fyhk6qmEPjrK+rG6Ays3nSzqKFerUaGEkuk lHeJ2baUqF/GCpTdbfUr06pSvOk7uJGtRbf+GvBlnd3aLkfYnt4nUWQH2LYbeTAFNc22S9rAWoLQ lN6i0Y9pzGa3VXdEb3OzxKvNWgplcoADyDL5YQ6hrJ5kDH+ef6MKSqqv+WCxOiacVBXFkc+PWswb 1SDXfydWRlbzFMQ34p9Dd0nhWlpUDEavOWxbhmpBJ2k8n3lH/zC4OhLv6Kc3zJ9vPZpw7T0qpCNe 0tWfMJRADe7L7vf5ut854ictocTvu3pKB52ffhOfcHh3Axc7BYgmUbJakkNlCBLG8TeJ7eamCbN+ klFuSgtRKX0qiZMUf9+nXswZoBzB/CtknqRtaGpbvdUGdjQQCQpXsKl9I/SROm09lIpa66hFK0o1 jlsbWWe3DhWY+JbWaWHbjVj9kcMHbEi/DQ3MCglj8ZVU8fhmFTL5FNKYZP93FJUuoDmAjR5JIGIy hXFHex0CfvDJqidg1HF41vesjvZuZEs19q/1Y76pjmZmtuxU+6tzs2uP1kM68hjHvKRrv7zyk4Yv +H3ZwfcOX+FwuBJSwDS95DCOIRP37icdmCX873TAqzi4p9QjPZEgu5PJkCFOsuNCj5c08GPehGgZ MzOr+XKFBINp0ASG+EqdXUY6I9d9Iasv6m3EP2YPqENMo3HA94TMhY0UsLBqYVRX1510huqSgL5Z SG8vjMLZQzezC6VKZu5JYQ0u23E7KyZXvB6y+c9TTL1uevsRay/JoANj50PX0RXUKIpJ25nwINm5 SfO5GraxUtJaIw7R9uI6yGN42CY79eB1pOMwulLfSMdf4CtVR30vMPolq6PhiHeUgHS54R29n3T/ fSqkM4skF9Xbsv4Tn378zwQX30HLun0FB4aS7HRru41LfRIrpReslLqVUoL4hp/+k0m7RcATtTdS rH3giDlqozNHab1UZPOxwOAapWJDWn06GrTEw01qUU0OJ9ncUwtpFUjRZ5WgKShXSDNd7xvupilI 8wrs6C9x6js4tsJ7iM4/g3WH6Bezgb02yGezg6aOTBfVe76FPIdtRG/H9rywJeP44Bu7SgnJ+dHz ttFANFqGLjmV2haF5kXJ9+9eBwhemiISPxQP9q8b2MdglHwjxGsP1fp5qCbq6GffVFbRMXX04dzB B3qcO6gkz7r9gEmyY6V02FJKrJDgS+kgvEBVQ1PPakmiclFIrISesOJBz8a5WpKo/YKVFF7oTp+Y wGS5jW6umpKa0V1BAxYF1CmkSBPAAZeNsOmyAeo6I5ozv80/eqRR3TEgFYU0Qhpjkm6XvKNgkMnw MegkX0rGhljK3y4X1bRUQ2XvQdLdmnHf0Y1sWhJCVlYY7LbnwijofocFRpJV2+2e0C8YRq80VPs7 gJ8N76KOHr1COqKSTlVvb2Td3E8yk3tDKcm+wF+9gPjFyF8Ar0+opS6rJSlH28vXICtYUUzdpczE 7VwRHQxO08SHgsNpp1Y2Dlo/ILBxd3qa0kBjz8FMBVZ+WRzAd8Wp36sBqHWJPOJFZfsgOFTJh8nB pEO3bIy1qqKy55mBJniKNZUOSH2/zbwexcMUX2ov1nqnpnWHvsdaUkN4I+EZg2igmziZLg82kNCm uNsYHmuYfapQet1f8tfsK92DbRtGxcROHf2lReQYjO6kjh5Uv+PDPt6WSnp7pSROTIxvZr6S2oBx 52rpeuEtmRLSIyAmj4mPsF2POlmUoabbijqczBsakfL5qUBKvvViAs5QNkY1q7MC0bDYpfaMd5im ViR5r8Kno7c9tIt/VAFq8XgzdSRbdWkNP4NoTwofU1AjZeA5pFAV0aQQ0tvsR/eI5CC7sTKCrIh2 6hXpXDcdyVOrIulFewkyVnDLMzJl9HztG/1Ms2pbRvajUEfvAUjnQOmHmEsBboES0bd11xItnswh 3HU2vCkO+Eza9jnEq8GkM9gUSKKOJgWTPNVLARHfDi7lK0mKKwuUTAH1s5/T/TJEdql/c5hZDENl Z1B8W9gMAK0k4MSqFc09AKwqT509MlaA2scMnAK+vYMpbdRol6Wwzx7bf76RLzWGkHRQqpoaPSyT A+karPLaQjOZglNAlFRRl1WR5HrxqzeaTdPalJMwEt+I1dE3w6OG0X2GbHcM3eqVRt1ew7HwLcbf lzdc65Ry8SSHchbCdRzCveLP7jOSxpBX0xsOrwZ4JtuH3Iy6dbYePE90DzfdOknbO/h76UYztweg w6CXFUD1Cij7FrwAAZ0BaaxUUY8aoU3lfUrXT1n0X8xe4rspIYK32xL5c3Kww9sDaPO7+CajKOTb ppBOQjYZK5Pue6OQsus7v61sbnrI98E9K6J4wxxC3XNbL+8mnyFhgwcsdBvt/LUcPIOBqBMQPXMQ XfPPz1wV1SFaSe133QkYSagWEoweubp9P495h9BtoZSke1ZKAlKLiZSwLkM4IgGTdKm94rf3GWjH GoNJRpxciR/EoZyoMG0xkkndT6W5bZgppxTWGXiGSgkd8FJLTQZVUrl5v4aTQovOgs38fm29/3Cu v1M4N1dPN3M1lG7j4JEvkBu+bvKDxMI2v71MSNZBadH8H/+5qCG57I2qpLkiKuEZfMVK6MCqqEuq 6KnDqM8Gtsx5/ofhxRxGx32jR6WOHgpI9wglkcnf0TqlH/BFEsLF3Pv2W8mWMVCenQSTjqSJN1q/ pHMjOZxLcNIixicMoe5S963VSiKFUnQo+V6zDir5hrHS3UWzh0Ory5fIm19+ss0x/QuqRWGPZxlD 3NtZHrLXWaHKuagQCkfgZrdN4CnXWRiG+bKDFVG+GVYQktu8whv1iBRethuPgcjDMzxMujlGUUX9 TBUNrIpm2bSfflN5RufCCD5JIL0llGABJobSjxlKz38885XiQi0lb0kOihpMMEhN//VCNUVWTRcV nESiXxVASdjGCgq6pxlSBpUDFmfh6cmJjwVgx9YcWG19iHV9MiSu4bKtsuS611CybkMFHrmvQ8rh U27zZgYpgdCold4XDqIbM6i7ixWIkldkGbSr0yHanWD0ONTRBwDS20BpHcIt1VIB01Ixyc9Psvmt Tdf8RtTKqQaUgWcNqVoJGawMSjpW5Fb4QKWUDnhfRmxb9xXCFZCcHfLhAkYVdOaPKaM/xB/aVQDa 5XAsq6mVGrrMaXzrhYKjIMqqSG70kcPooYH0FlA6I4SDH58FJoDfXaimAidNik1rQJm6MUg95/9C jDOAFFgB2Aje/n5AcwXvvavws1rGhXuGV3nQGjjltjt6yeAZ820uVgBSUzwrIYOQZOiKGnrqvWg3 KxABvFl7RVJ+/bNvLfyi5w6Zt4LRJweke4DSd/n086NgkjBOPs+HBZhkLVXT/8/e3eu2DUNhGD4t UvRny9KpF9H7v4oOnTJ16FQUKJCgLRDAbnWkSOLPOSIpWhJJfe8U2Ags2/GTw0QQBzz+voB1Py3r +ld9Aoo8pEyoxhisuwmkZ0w+p5imZnieeo6eDJTeeku8AR6+7dHCp7+vB4i//uVMQj5CnAnRmw6i tKmIqsBoL5AyURKWcEGY+Ifkk4iTOTnZQJGH1PSuOFiNOzVcGal/gOh0ME3QjA3gTPcb8Lj4mBPQ DF0cQq87hL69zGbxU1E9GO0J0kqU0mEal3JLOC0BNS/PTKgGrPjM7iufQnB/Sdo9xgYNFQuNA0n0 903g0ITOmIwPg/PDA8hFiLMg6hHic9seBIhip6JyMdobpAiUKHJacpZxFkzkTU3k4MT/9r9cHhWg xj4Sn190vf5+FTpB0cdLa0ANlZqNiZQLjL68s+GZwZEA4t9u32WE3GmIEyFKmYqoSIyOACnwmCnT kjIxfeY3sMPpYuNkTk42UKQiZeaDZcO1DFYYNVTK34k+WGDo2dBo4Nj3+fiYAHHiJMS97277+m64 fmEyRHVgdBRIkShRIkzC1CThxG/g809reiIRKbKwGlDSwUJoBoc8dFx4xmyAaCVC2RAVgdGRIEU8 dgxM2nKOZJz4Crl/TKBspNwpSkpGi1TEUAv5uLhJ2Lgt4jMCdNcB9IUUhCgBovowOhqkxGkpBabA 5BREyoDKTJmsEJLBEdAJ4pOLUBJERWFUCkiJ01IIphBOJE9QElSkYSUlAIYaTUFGQ4dT4YkBKAYh F6L6MCoJpI1gWgJKQioAlYYWOm9BaDR0aAGfHITqhKhUkFbClIJTCKklrGgdXqjhJGQoAZ0UfLIh KhqjkkFKOLZb4JQCVQ5gqI1igLkFOiGAohEqHqIaQFpxjBJOt0BqS8hQnVPR1ru7qltYU+LGjVVd DbC2HTESj3cJqD2QQigXn1UIVQdRrSBlHncIKKCFjsAmG5+qEWoBpA2exxqsEMppNTxNIdQiSDs/ J+CFNgPmVACdAaQzP0/UXqfaogYfVLwGCODgw4jXDAEZhBBCCCGEEEIIIYQQQgghhBBCCCGEEEII IdRs/wUYAJ1pbQd8AF7EAAAAAElFTkSuQmCC" transform="matrix(.24 0 0 .24 88 88)"/><path fill="#3367D6" d="M96 96v44h44z"/></g><path clip-path="url(#b)" fill="#1A237E" fill-opacity=".1" d="M96 96h-1l44 44h1z"/><path clip-path="url(#b)" fill="#8BC34A" d="M96 179.17c0 1.1-.9 2-2 2-.55 0-1.04-.22-1.4-.57L52 140l44-44v83.17z"/><g clip-path="url(#b)"><image overflow="visible" opacity=".1" width="284" height="284" xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAASQAAAEkCAYAAACG+UzsAAAACXBIWXMAAC4jAAAuIwF4pT92AAAA GXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAZxRJREFUeNrsvVuPZEmS3+fmJyIy q6q7Z2Z7tmdWu1pBepYAApQAvZFPxIJPAj+hvgAB6W1A7MO+UhIBgksIEp8Ecme2e+7Tl6rKjDhu cnMzczf3c07kpbIqM6vMG9GZGffKPOcXf/vbxUPw5cuXL1++fPny5cuXL1++fPny5cuXL1++fPny 5cuXL1++fPny5cuXL1++fPn6SBb4r8B/Z74efKH/Cvzk8t+BL4eXn4z+7/Tly4HlJ6rDx5cDyk9e /3f48uWA8hP5sd73/V/rX+XLX/kZ8+zXv86XXz4LYDx7OMEn/n7hRqD8JF/mez77z/Pl0s/nZ7++ zpe393zsy3z5328E2vsAybOEE3xC73H5PP8yX746B5S/yUD5+e2e/R9+A+Hq6Cfvp7B+/mcYXt3h k+brX2Sgfb19+7/Jl1+9N6A8KzDBR/rebgefNeB0YCF5dLjdK15fh5CSn6yfwjrkYyLGOzzg9/ly 3ABZhtXXXy8V2BJS7wqWZwEm+IjeV/+Yv5GQqQufzJUFPJ8tgXMXsHz3HYTTyU/QT3l99hmG/f4d QLYGqxVIPRygnjSY4Jm/n20IWQBV1WMUzxZ47gKZec5/Xq9r+6TXNOWj8JaH7Tl4dbAaITUA6heB fa37A+bJHrTwTN8HrENIQrARQGvw2QLPCJm3b+FOodhfBzYyfX186z/ny+s73P/iAguwbgOvNVhV SGVA/fzzdTj1yumuoEEH0ru9hyWIVAn9w9RCsBFAa/Cx4FmDjoLllNr93hzz/W74G9IxM/m5+1Gu N/ly02fT5S5DSJTOLn/9L7AOsZtgNQLqJjjdXzWhA+lBQGTVUAbRddiG0Dn4EHgO+efX1z1sOrDQ C77g53l7BW5e+1oJuRgwBKMCln8MhRQjxBRYa7CykLKAuhFOf/euYMJPHUjwTiD67YYaWoOQBdAa fAp48hPPhzOwuWA60WvNM9zLN/oy3Dph5+sR1+8Cf7jddREgCErVB7oKiwI2uv2QwQJf97DagpQC 6kY4/bEH0//2fKEET/Q110Oz3/7PGUT/Ta+GboLQX1LIJQBS1TN/le8DBj4CnC2/iGCCJ4HRPf7F 9P4mhBD9fH/yC6f8F77nHyrmw/Yiw+UPcR1qVQENsHpxiWH3mwapgwDqV/nyBm4Hpwqm/xPDd7++ r1rCTw1It4fRAkRf5D/yqwyiXQ+i20AorADo7bGHz+f5ueIKcBQm5Qa98Uf5su/vk3D73+aZuOez bsqY7TIsor3Pn0LJiNnHn4DAgQHiEljf58efzPX7fYZRPqbhukFKAfXmbVNQ3+y24dSB6Yf8Ovl4 /Pm/XwPTk4fSU+oJ61XRPwnNrP7ucDOIzkJoABApnpTvO2MDSkwQwACHDiqCzAgTuu+r/J52sQfO Oeicynv1BuCnvnYEEbhZBdlD+ft8PCDgor5In6cA7NsGLdj3Cuwy//xHo6hGQB3+kMO8Ix3LrJz+ Md/3rfhUN4Hpv/rivmEcfuxAujuMxvDsJhAd8DyEXuX7TPJ7BlI0GUDhCwbPnGABnAkaZCxQ6DpS 3XRMzel2oMGXFAr4Cf/k1dHrfLlF4+IUG7hOK4e3BdvrIq6xMoiut5Aq99s1SL3eNwVV4JTfDyTx n35LPudSNVkwff75dhj3DKAETwZGY4j23V/0qujq6hYg2q9DqCqgAUD0/UuU+wh0FDiosMlhIsYe Si/Fi1Jg3QimKfiElOew5vPnoYLIqqg3AqXJQEjBRvefjaJSUJHKeptfaDaqqAJqvw6nAp3TUjX9 OoPpuGuKiSC0qpb+r2cBJXgyMFoL0awqevPmdiCySgjzdeFzUlkMmhFApJIUPukFFBVDr/WCDGgU 0NDRI2pJwTPypai2jX9rMdIvQ3BH+4kvMltS+3a+QRlZhsU4hGwEIwnjLLDimwaqFPl0J0iRga2A KgrqByw+0BqcOtWUwZQymA77FspdXm6opecBJXgyMFoL0awqIjD9NMPmixtAVCCUfz59lo+LDBOF EJ6WAKIDheBDR0IS8BBcIF8HFjQZKJeRD7RRCc3qH20oJHoYCMEIaD5C+WmtqHVDRh1tRm3A8Bj/ 0qqOCsjy/yI2QHXAElAROOhgLUoqUbqfAaXPc5XvkzaU0wgmyuppKHcYwrhRLd0PSp8EkJYwWgvR RlU05T/A8c/ydZ9tgMiooQtJsx9Ponaydj5dZADFBiACBEgGjZ7r4pK/V+jUUGwKcn0DDx0fZIKX P9cBuvLstAEe/KC+na/bHaXrJxzElYzbFQGE4XIdTMGjgCoJ2IqSUuDlg/OKPiMtqKJk4AZAkYLa YYPTm9j8p/3rXjUpmDSUO/yWwzi6/R/OqKUnDiV4UjAaQ7Q1VXSiAsUMlxdvV0CUb7vIt5GMJc8o iRKigkTMYJpBgCO3HS7kfaLAKfL1BCH6u5fU/qTX8XvX79ka4MfTgXkwURmGXjEldGH0pFUSLI9Y ALQcKn9cSO0ETVZdCdgUYnCFJamGop5GUNF1rP57QE355yPdn8AU+HFkgP8A/H4UTIfA0PouH6Rp WqolmO8DpScRusGTgtFaiPZqQxXFaw7Nrl/lQ+GiB9FJ1NAliP9DtxGEDvQJRIqpB9CO/vJ7+oRj dVUycCi3I6shOjqKQNrzEYymhqkqJ/M324+AUnihh22PqohgqXysSjqGvtWDYMU5EGNai1FdHncs PCl/3WvACq4UGDYRBFTX5CVhg1RiQCmcgsAJyFPK93oLrJr21/m+cw+mCwnlyuuvqKUXv89gu26G 98NA6aMD0u1h9BenPkQ7vVyqomsxoSk0oz+YBdGePCBRQ3NWRqqEZlI4lPbIt+/27A+VGqKZUx+7 JOpp30xqhc1eQzk5GBVaSp4CMqOKbLnKTuCECZxFT0IRYXeYHs3pltbUE2AlVYFLaI+nm2ZRTPxH F9VzDAUsdNUpH7RYHsuPI09JARVX4FTU1oQFQm/pjeX/7Y1iuj4wpPY/nFFLv2PD+9f7ZwWl3QcH nHbnX/1o3bwmGF1S0eKfc4j2OrHyIVV0MVMKP8PoZb7kI+Ul/X3zz4muIxBNFJ5BAcecn2e3zwDb QQFF+aPn72GCkvanLv49AcIA6EgKiXqKZg7G6Hlgx8qJjkdSUlD/pcBR2ayGqNxmIWUglELwTNsT WSN0qLBRP0tgIZHkj4qqilo4x1XZnNov6fwTFkCRzwTAoApSh0THEeTbi5858esRoAg8JJtPpUuA IUR+1FU+3o859KIs3O7A50LIoWA8cqfT9/Sh+JKPNVJLn2XAfX+gUBFY0n8JBUpf5Q/vX5PiyucW Qal+yAbufJj/RT4n/zafc18/iT/N7gO9Tl9rRKl9rUyl0GwVRpcZRlcMjs9OHKIdxSs6ULbsxMqI PKI9gQc5LFMQkUIi8NDlkF8vTlx/VMIzghCBieL2/HzUMlLUzU6UUWJDvFRqC2xY5kD3b9KfUOqa QP5HfhWa33A5SHfbQFqrCPf1bgrobMX1aYCOibYhDI9F/gNqGwgqkECUFd12kr89ap0SQ2oGNqLL +yHo0F2ISAQi8pRmLNAiKBXQHbE8ZgGm0MB0nFh9XdBxno+pa2LlFxTCwa2h9H2mmaqkb6iMJd+X zk1WSXBGCcH7VknwAZ7r5lCNDOxVGJ0YRtO1hGjiFQH9kfL1xwPBhnvQSDkRiEjV0AlO4MGsiE5Y DrHqE9H7mWa+jqBEXydRSsSdtJOQzoAmJXmOnXgKApCxBMCGZLVWqX70rnwWeMLt/a45rA8wQiuA sNp/Y10kDGCzRjdBphTLFl41EIGAqCigmUFUErsKohPDh0BUQkfyjPL9jknDPSxKq8CsgCrfJo/b 03UZVG9MGEcwuTIhHGXtCEpj+Eah3S9Jtb/g1pT7h27PAkjnjeybYETg+SsqdjwDoxKi0YkuINoL eMgT2hsQEaimiaEyIysnnPj2XWBIleLGJKFdSeuz0Q2iVugyRSgHl0KHa5g4hCufqGpyY+8LRQnr ug/ZtRol2BCsDqn3Ap51gxtX755MCFc9pwFSpHBOCatiiuofURg38/URGDoEH1LadD/ylRROcZbb kT0oAlgqz9+DiSYQUNbtdOTbSFGRgR6vGFIEpbd79qIOK1B6le9/+DU//6/Igljxk/7rCwxf5NDt f800+v8ez0t63yEbnPWNbGqfDOziGW3A6CAhGsFoJyBSVUQAoToj8ojo51OOxQg4cRK4CHROKeY/ MoPoRBAiwCB7UEHUUjnY1BQPWqUt9w0cjmloxwkz/rqrghYWf7LVKu64AR8P3e53mE0rkLpxrf+y J7n+JK41WoCVrG0IdaCWXicgKWRRxRQEIAnbUVBMJPaNQGGVGqjilMq5UApudzzwrUyToEM0g+N0 5F7MQ75tlyOG4xWHcNQMQFCirDMpHhu+vREf7EBZ6g0/6W6h25P2kM5/pJ/zjQhONrX/OjXPaIQR qDKS+Q7HDJ6dKCE4MnzUI8Ic8FPhY/GVYuTix5kNbQILnmLJvhGEKLUPiQGEYojHwPfng1xAFZoi Yo+Tf47m31/UUieNjDc09pvYWkp9kMPoHQ/F9gskdYBrSgqtcm2QWXueKCGdPqzYzicO0VQBzaBQ Qqnkxwopgs+cuKKWDOzSMpKaAkqRlBMrmrn4SlgyvSny/UlB0eNLJm5O5f1QdphS/OnE7+mQoXQ9 QCl9kV/+u+Yp0Xl29eP8hnLo9qX4SXpcqp9Ufj3/7NEN7t17/tgyzbKHpo7KKNhMaarAJu/traT2 KZu2BaMTwYjgISEaiEraUQgmqoigdMLI4RfBJ8VqYEP+nh5bVBNBykBIi03oMfRnL2lb8Y3oUqAD BkgGRK08wIRu8v1kq30h9O0lXiz58Av7o2/xUTnhMt2GInYMzCqo5HsN2bCeyAwcus8OpElWe4i0 TCCyMkoCqGjhRI8RlRRjyscnq6YCJqBjOxVwlcflk6Zk8WKsIdwOUjhlMB2PbIuOULqic+2LHIq9 ziFZBhDVL50umslNk1P/8QrKc51XSeFDm9vvN2RTdfTLL9Z9I6o1ogpsKli8zr84LXg8B6MpNu+I /kiqimJWRbuSVYulhy3KVwKR/EU58ybf14q3yLETKx9ohzI0GCmYCogmc6hjD6NJYSQg6kK18e+H XpP03gUTnP8Nl7qgoDViwiTpI0sCIlVGqpVR0/jmtgovUUolfCMfCdGEcljVE6CEcBkspS5OwZRY MZG6o8fTdUgfnifykRKHcBk68zEf6/seSlR/BwKlC4HSNU0GSBxGHo+cebugf+xVH7ptq6QPHra9 K5DgVuqI6h3WQjX1jagCm4oeqc6IUvtU8Pgy/2LVM7IwQoJK1qwgnk+k8KuY0hymxfwHRFJDBTik doB/Rg7lZlJAwCFYIUeBTqwAmsKgjMyFnhMNjPj4FRMbQWYeDaCRnjpY+TDvsnC+HjxsCyvRWA2/ jDekcEJRTfpXLr2KBChVTCi1Q9iuQzlaCoyMcuLvG4wK8SQUS6SOMmyKlQBMwvIBC6mUBZTkGz13 FDJmGEGOAKjmacoxHVVjVyjNXH6wpxKACwrlUDoLQvlgDz/wufQ9PWkm19VPOHT7SxIK0gZlN8G4 vUp6ZiFbUUf5f7/80Q2h2sShGs8tglJnVFL7xjPqYDQbGGX4pIlDNA7DGEqEgCRQSlRsRJ5SiGJU x6qMUH4uoRuFehY+ga8TxzJAaH5SFIgUCEnzrXpKk1zf+UrnPmdcKT2sIsLztjWY+8EAsWRUE2ft pNBRwFNrkJD7yvRaMF+DARQGo4iKQk8ljEP6Wo5NLMdepBBNK7zFEC9eU+KMX2GaGN4UAQSBEnUY 7MToJk/pxQHD6RJK2wjVKamfdHiTo7X8HH/KH/wno5KYXCteEkoi6mx49l7U07sA6RbqaMPIXgvV SjvISy56VBhRNo0M7L1m0k4DjNBAqKghBpFCBqKCSVRT8Y3EqlTYJFVHsYcRPabCB8pcJJSsXE3j S2OUKp36Jxr8pLXO8drfhp7pf2jrchPxSZNj2MEKbLchsDrCyGYwBIUXqx1OmGHV0TjAqHw/N3WE KTXTGyUPS8eMgImuS3RcTYnbkSiYkpokemgJ5SAWaBU1L5MqgCq0T7E0rRCUSBnRB+2BJhHIpheX JnSLKHAbVNKalxT+eb787YeXR+9NIVV19NkZdWRCNesbUZ0RKoRmzqapgb2AUf6DTKR+sIVqdPYT bAg8xcguiki+lpwJ02GS+6nho4EVaigHRiVJCYCFEWiXpimSjO2jWjwkCcls3y1uD3MbVwyfNqzu NT4Kl8WNHayGRtmapldRJEooQEvdo4Zo6hcBXweDOkpdIUiSZ2JoaK62A1PxPlMJ9RVGBX6lzk2U EtmdpKBKBBAKuCh8S2WQEncfEGz2B+5SoFqFEzWRm9CNGtNpgsBPVlRSMhk3XY8Ytr2fXrYi934u AfvbDXVEVL/iUK2MiyXfCJtvRCn7Umc0NQN7FUblLxZLKEcwIjMbQa4TQJG/hKKMKohAYBTkeSnM K9DRMK0Biht1I/e20cEUGTr6MwiEEIw6QtVa5iRBWNeWuF6nNAwQ+DQFz22odM68xnWDG1HB08zq 4h9hy6jVGqSS7dKgTeqOkKEUgY0Yq5LoTaOkQ/gfEIPIngIA7oNM5ZihrFoUGEVhFUd4qRzbMYWq lIL4omRwU51daX3aMYhKkW+ZBofhBZnd+Xaq/qa+8jWVFH6WT89v+N98dQXl97Mdtj1jhVTrjn6T Fc9n59VRDdVeQenaL42yL3g8bZKix9LGseMaI5Ko5BmR8rEwQvlaVFIBycQfLUEVUJTQbKogQlFL WvKo3/MRqpk38Z2QgaSqiEM38YqgCX7AFoYpdjh5Jxm6GtPB7aJfN5c28ve3k0oATWVZw9qqJ2iE qhm0YMIytIopmEyZqCT+ub0KijoqLSmZJJT9JfjwpIgGpqKoZcBSCk04gWQ7SrlB5JCuJmbKnTOM gDsOkkw3LbVLlJDZs69EhZsLlZT60TdX+TkuYNvc7sO2D+Yj7d7hKFlftSpbwrUb1ZFk1WiiXjKh 2iS+ERU9Up1RSelLi0eS1P8Io4S8HwipHMqXlZSpqKC6V0hSEJW2Wr6PqKTyOIJVNDCqkFJoSegm YRnUMI8PijKuIkId6NY+wMfs23ro5gMBzosdvMnU7lRQ7xEFM0wt1AjJmNXmtoYi/uhCUVV8SxKY LUO0OtuhKKeSJiuhWSoWQup8yqQaWj7Y1qAERjEFOfbL16KeEh9ze87SUWbulPiItCqpZPyz8jlm BUQZt9eRR59QaVI49ub2GLY9Yw+pnVy2KpvWWXV0yVk1MuQobamhWqm8lkLGUvQooZdm06KGaQIj EBgR3UqWjdSQhVH5pJrYVyphG98PRDGV60QdqbeE6i3pAdN9L2a3wAbAFEoKbADbTACsJrg1X0MH rprc8XXLIw7PqksYzRHAOgoGEDtAQVVJ2BSWMa01ja/KiY3D1Pwk+R4EWBVK4iHJq1bfEWKoflF7 U2ETSmVKpXwgh1JnF0qP5pT4OJwSv2Ma0kZdCKSSqJEWr9kKodE6VKS5R3OQmbBtXGXbeAwf2kd6 2JBty8y+lTqiCuyJR4hof9qkodrECslm09TA7pQRCGRKHl7CMwFTDvJESIsyElDp9yjKKoiqajBS azmaEE1LAUDCMfWGBkBFLd7tM3CbWhND8JzbHb0i3ACViZ7RwsuACkwFdqohHIdsNW1vwNS+byGa 2MLyH8dG5FdCByXoEiPBhO4lISOWZSlVivr6UoApO1NS+QoE9ZP4mwQt4TOJSorGS+KBhCG8mHia wPir0rCtfD/4SLpbyQf2kXb3+lw6G66tmNnlk/8W6oiGq5FBRyfzaWYwEYioHWTWtH5kuVoNbFVB VfFMRR3hPEnBoyqlKXDbJF8HAieUMI0/sibJpKmKEgUlJjeCldix/T5kxIkUudS+t5qBM78ztqHg 7K8WHUw3K6CtDJt0zq/7RPY5xchGSetXdaPgW6b1MaR6mzjgoWkubBAK4hkFU/0vX9WSTNimQqDU HtFhmMTLKnq9fNhSXSSWYw/FT9LQLcokC1VJ9F7oA7y0q+Svl/lxx7LlF/BrfBHKvkw/CZJtk7Bt 00f68Gv3YIdODdfEzF6Ea/n714n/XDWzhlzQpeqojAjZsyqaJFRD4MLHuRp7rY4IK0RiVUYEo5Sm AqbySZUmCdkmyaRN1U8CBVRo4RsDS2uZYkt3DUa3NuKiCdeqA4ttomT5hBsAgyv+UTyH/I8ZUDe0 dwS8nYdkVRF0cZu+DLZsp76mUUrGvl6Eamx0p3o/DdVKZTU2/yiWrwIlTJxJC7P4Q9BlVas31P0z kctVuCScs3jSLF6eX1RWOT8UTPIBWK4rDeEoPixDieI1Ctsu821X00q2La8Xckacxl9qZ2w/s5Ct 9q0dt8O1sjXHFd+f9k27wHV1VAxsYPKXME0aZUHUUSksk9Q+1xhN4hmxMgJgAIGoIxQIFTiBqCKY DIiMcpIMXBDgFSUl4VtJ80NsBZIQa7AWZGQJQqitJ9pSslA9KyoJ7ydKP8mk21IWLX+B1eDGFpLV okkItZ/M/h+kJkfbQEpXPyR5TB+qNRObwzLEJMfQ3MIz2TQCsIX1CXXEjRlvW5Wb1AQBmwhShMQZ tBIVIA8LnOSYmuTDfccRyO4gY3gi1zgR0GbNIW9k22i9yWppXjOwv7Lx2gfpa3s4IGl2LfyI/+E3 hWvzBaf3adwI7Q5Sdv8QdQTGOyKTWxtlg0AJxNieJbVPmTJN78cgICHgGHUEAqUoiojDNYUXm+Kt UHIyMGLvSMM6zcZhLZzUgcpqWEArAQD+BItrp5OHZQ+UdwurGbTqHZmQrIkybesY0/vYbifIgPGP pN4IasFjMmASr0gqr7nEe67V+zaxAdBCNKivxfqK65pEayFPDCjeJnf6Mv5EHaFUeAfJ+JaJqBNW q4AmC9Bn9gvJ/m7C5Iyx/YxDNkMl8Y/OhmufszykDmR8IRs5npqJTb/gSSdCRu49A2mUJXMvaeim GTL1kVQZJeMbwVQBxIqofQW5nkxxGEAE6i+FXiX14VtTTHWDSdCxJqGCye5gUosl1VZwKN3PW8Jl OFcLGYd0fx2shk2B6B+kZtBsD5qBVB0DIFk1Vk/JWOHmUia32cKplnkF81MFpo4mQX0PsZUWlA9X Ge5W+i4ltb+TXZVTm4yqBbr09RDYQ6Jxz3RO7VFG7U4bv8xLideeJ5DOnzxjMeRauFY2ggxQtrem vwH9Lkhm0lZFBCAayH+cxayTXzSlO2mEiGbWQEK1iM3v4Q7XWEGEBkZ8224TTEUtmQwdYFNZViXV Cu8VLwmqSjI1SPqRCP3BiYPFAQ6lW6khHH0k2DC/EbsKbRz8Ig3NNE2/8IyMcW0BpMY2qCpaM65r yGaCHBsGhjZFQMsH9DaGUeRNAXQeBBqvUs8HNGGb1PgBGmFG24PRzsxqxyMujO2aabuCcJHW1dM3 30CZ9/3MFBKEfzn4R+fCNShZs1Am75U05YllaJwkpTnxdkMlRBMQgYIIeYCamtuoFdhSZxTD1Kki hU2BEer1PZiqWgIO4cqn1JCF0x440OJIjKZiu4EJNGTTDSpr4Vto2FkJ1dCOWHI4LZtj0aqeDUMc +8chNCVSa4eCKXiMGwpJ5hSFqlSShHhNFWk2jWuPmnHdyj+Gj/AKHI3q22vFoR8OtQBJkyYSqkWx MHRI4CRHFIGpzIqfzdwu5Obd+ut4GYqxjbobydv2/tKZ1hytRXp2IdtXg3+k669Fu3Th2hccrpFh TUOlSsXGIfBAfgnZyP2nvdFoBjYZ2jCrYSyGdtIKagnTBCJJlFIZJJKMOgojjHZVIWGGVYURqsE9 VTXUDO8oQ9w0uwcVTK2+BFqVNjYY6azurjAS1zylcxr0OYIKH5JSi8yZBRjK2KGuWhv7wWoKGTCT H6tCkowZipkdTKFjqBAynhHpfJA6tOodbmu6NsgtiqGdaj9kHQ4YNX3fvKGoYT+GqpTQ7LpcppEE iUB0/g3ard+x7LZcdkORDNsTXg/oIa34R4eVYiwaZf1StheiwWv0S9rJkH6YWosI9eqQeipaSKq2 59DS8SiNstqnBkkUjab2Jc1fVZKBEe+crrBq3yuMgsm8Ffho4WWA2qQbDIzUSwoh1PoT0Pnase9x q95SWK/U9rWRLbNiaVRDqi1jM61bmBQWTbEVEtqPphm1WktkWkQUSKDmtZkoirNpmIZB4WlY2HRZ lXpVaQ9V4FquXYolbTeAbkLBnKQPbovTonJ21YYqpTSwqGnDUrGN+CjD+x/J1A69FHxNWxuJf/Sl +kepZdfKUHTJGszI6ijIdkMnqUuigfzF2Aae9BhUHclQNW2UBVCjW5VP7BWSgRFn3VQl7drtBCFT wxSwFU5CaFMCbMFkp5Jq1i1IP5yBUf1wB1OuBGdZ9DHC6q7FjgscoYnUVjr46/1i85KwDknDmnLH 6tm0FH69n1FDQfrz+QnnwTcaWoNCG/Smqq4gA6MpqGwlBQw6MPQwAKptJm07d4S2M06vyFg1qUWC VbHh4mw/Pe3D4+GANBrao390cQ0y8yUU15+6+kvTYYGU7KZAEnRidVFCOlJGJwnRonxiSEe/qiOs GbHJdOy30Mtm09rXnfS+7QRSDVrRlgRoCKeqaKVgErUUQNtIQDMewVR1q7+93UKyFpZ9tLoJ7x/i rab1BzVlQzKd+lh7zqCf8ljjoaqGtOAxSVa1FTryX3Su9UU9iExriv6MEpZp45peF1o2tirs0ECn IgxNGYkqwynYkKz/zaRkZ7kvf5c/1JjgduunP82qanpWQBJD2/SvWUNblVIRQ3Sd9Y/ko0Sza/RL 3MuMlyQztEvZ4SR/uNTaNzTLVdVRBVEDT1CoDCqpZdgERjCopMgFllEUUxgyb0H63TT9D2YaAGAz FhGNb7T4JIWFElrNtMFHRqUb2vVxI0xb+jJLtdVXWbeAZvSO7JgQtB5SaOY1e4YSpkkGVT9kxi78 7h8lP9eRJKsgivV5rdJCnTha24/MisHArn2YoQ4UqL+384fL6Y6H04sX+cyAJwsk2Da0B/+oM7S3 /CPkba4VWiC7wWq4lnT4mQ7Wj63JtTh5kv2qI0SghVUVUjACSkK2BYx2K+GdVnW3jBvUJlzT76Yl AG00fK3atr83DLDcWlsPsnMb0X9sM5HgppvGFH5YDFnDxS9m3J6z9466eddoZhpp2j0wPHjcbCzZ M7Shk27ooBAaYNQUkY6l0RAPjbKKAqm2lVaFkPmqVbTdbsdbrY92eETkGdylImYjNUY71cbB1T4c ZJZ3us2nyTP1kKqh/XN5iQ3/SLMTpYGWJCfNCZ5buJZMuKa7g9SYG9oGjtqVX1PyoVVgJzShG/Tp fgsjm3nr1BRKjZKEhwjWWG+bBITQWkoCWAi1DQGqFTFsDIkBPu4Q7RaHOCyqHO2NaEKY3juyykjl ZttR5BbKqPSoxQqlUIepwSKs7qHUP2czt0zzrfWCBERgqrcXDDBK6DZG/9aGNcVy1c0u6fvXvBVS 2Qb+W5FK+wYpeDoH3vsBUjW0D/wL/vzE6mfLP6JJd9oxr8ooxj5c04PEKqBYR4dA1xjblIyGWrbO aFo1uxlWO5kasBbitSZchY9tvAWzn5sdwlWPHLAzkoYJAJ+Gc7SgzU3/UrBYsZk1AyUYVFEwLSCL 4fsBu1R+kDS8woOzbaamDDprqD03xK7/DaoPJQZ5nf5g5mThojqpqaKbfiFzqMqJvt0N0Op2372W TqZ9KMP7y8vPDJ4yzP84AO8biWymjxhI1dC+gvxvhfD5DHUrdNT9y/LPF5ecWaN+r93MQ6TKW5rb SVsOjqmN+LBbFSVRR9wQC0YdxdpEW0eN2DojWAJHFRIgh3K4AFebOlmBF9puJTiOKNHTRb2kYLdS +pQAdH+nG1dcNwQciiCX3lFTRqEbJdJCKG3TkGLHOrExtYFp5ivabJ0+V82cNT/I7j4DpY8xdKHZ zSdNAw9AP3zf7qRbtvOesG7pVN7qdahTMCUJLTsnt80w18OZEF5Q+wow7Lr1d+FD7zzyMEBay7BZ Q1t/rxS2TTJzBYTa1j8qPnXg5lqarw0ic5Oc9JOBEZqB/HWeURR/R0O32rE/dZk3Su1HNbBra0mD URA4Ya3ujgZcOtzNhGwCphaimapdGJ1p6JyPc741PtNNJG/aMXbL517fvgg3nnvFL+puM0WOFUYo RnMyznSyGfbesK77vKmyisa0xmA3EdUPTDam+diNt/gbWvAUqKa2N1zdcBJbI3Dp+Jd94ej2eGJv dsrXTfnkmuU+bzNodvlOb7TF88zfxG75/vJl/mhWLPy694WfDZCujusZtm79KIRXiesl1NDWKtUS zkl1dpC2kRq6lZ1GQjD7iXa7zhb5rDOw0dQKmUFsGrbhAKaAQ1g2ZtxKFXeswNL5S2FFISmYOmCq 84iw4hXBMAvHnoPPWzV1xwDcJpW/EqKtQWpQR2ihZLJpwfhJDJJkICLhWWkJMTzRp+g8oljVVDDG dfMvjQqufzq4heg1G0924JF/m4FS3Rll5p1s9T1S+DWFNrZEgUKnEoEo6S4pUx/SEWxoq+3rA4/T pvVLCkousAgEmhQZjZz6xVmRhE8TSOPayrDRlixH3lG4/s2oteaITS3o6V1S/8C9bOW3bExsjIJ0 bI2uNVwyldSqjtBk4LSuCLHVHNnMWvWPYDS5W8+czuAOaNL+5t3bg7XBBbY6ndbP0OcMJbjPgTps bT0e8Eat4OgdmWLHeh1qq4aa1Aom3r4a0HxW9Fn7qoawg5EZNTNmTs+druNmAGZQAUB/fdmIUhWY QElH6dLM7FigJBtWkjLKimiSt0QR2y7ydADbpQRvOLn3NlOIWrKmawzf0mTJ/Fiav02n0ptkGg9k aQ3S10UkfbBU77sB6V+Ftl22TRm8DOyd9Z5S21CRjOxZJjWQoQ0mDZrMqE++Q/OSYlBT25bVx9pT 1KATlxDSQf867lZUUxj8pFJgiTvTcjJ1w9xqBbiGi2CNdTDTAU2dSbQ+AtwuD/5JWEvnQ7S2dbWl hYWXCalMpgtMB30QANkNIEOXuh9eu2ZMsVflWsoBjbdplcW4UEC2IB8HTwvMhIGk/x4xyctmkVHC tMjNehP0nln5/UR5riMnpCl0I4VUPrePrHxmgtX3+ZJBdr3n9zP9Nn+9Wje0H6EG6V2BBGU27+VK D9tp+Et1odyr0DqTpUcnHeX03fFImZp9gBaqWTM7ogETQDWaq3IJZrhaWFNHOjFSdh/Bvgm3hmlS 1d1GmiyNbZ23Xb2iCswQWs/THdTRR0civPN9rIE7gmgRotl+NezT8KDjQ8DGkZLeN31mnScJaD5I wIyIMQ8Ja7vjYhcpNhU3AHIEkfG3FD7d/QhKkwCOBvfPDJxST5QVU5lae8KijmZ5zNUVD8q4IgjR VEkl6Jhhe1qG9rsrpHktUaCTG6QGiXrYrpErs8ugqL18tFyGOlKTwrZSh6RbxMg2MWgya7bosCu9 H2fSmE5prvlotUO9OjJ7s4FN9RsYDRsEaIFksFXbIAPbTAgZTC3SWvp/HTqfgiTCMwzGzuXGrjDC bE1Us14WTmjg1L63c5DaPmkMJR0Zo7OrYQzHwGTMFhYfmjKEvnUFw1IB9ZOc+lqoDlAJpUJ8ANPc oEQqap45VKOjsaT209I/Ko83/hF5RxSNUEkS9Zbq4fk13f+SVdRoaP/i7Qdn0vtL+5fJ4YlTlMGk /E8yAuEy/wKOssMB1STto4R5JEhObHRHPZnBGtrcuFq3u65QgGB3qm1mNtTMWzDqKdRygan5TqEZ 2BZMC1Pb9Lahggibh1RBOVRrd02U0OWyP34WwQaQFipodJN6hWMbaLVbv0ophVLtnI8LEC28IAyL XCdKBaSGi/UVZUcQWKiiJWTq0DdY30rJfk1m7lIb1CabCijkZqzKiEI5AtGO1E2+7gR8WyleKVse YcmcpTdYwq4rOs1zuLYnRbVnuF38KT/2OoQ3u3YKqaF9O/8Inw+QaGj4IcPmOhNmP/cb1KuHtJtb D5c2m+60KlugBGPGJdqUf5vUWFtFEEyvW+s1qz6T7qWmmTiI3R5tNbUP/Z5tTWWN4Vo0m1FCX5cE 61k2NRwxwND9MLSUfAxiqItxcFMTdn6LHQyFODy2z55pt34FE9hdEGXXWN39xfpBBkYBlr9wqOGg 3dPNbBDZbQqQVhURdg22qRt3qxMnsf4szxvbuBMd8AQ6W7uMsGUvaRI/iXyhMtERaHNI9peur/kI LOGaGA3XwN6RPd4m2kAyrodrL/5tPgW/eZSjZneXj7dbLy2KnBEWNUgKJR1KVaZE7mXypzkgkiol uS9PyxtgZHeRNd/bPjOtpLY7iQSbiTNeU7BwgmZg4xDOrY0haXVJzdiu40gEOAAtkT1Wa3eh3MfS v7aiiqDj1bB1EY6D+C2gtO9srM/RLv4kD1dVFIwpPdQMDTOvz9UvACyN8w46gKuQ0UFusPW4cRvu OiBuUEZUX2TM7eIbRYYPHVonqT/Coykpp/te8e9Qs2uHO4ZrH7j+6P2HbMkOZ7M1SKGfycJjhKFL WSTVxbuwGKAc0ZzkWkg57igL1qRsxZPVS1KQSCGlhmtL5TMtwsA2STJ2tzUDW55TB7RVSFnggBlb C6Yw7rl7Srj4buyTQhsDhaV60uwRdiAIdfB+A0To3Gb+myYzsiN0fqIqnpblh8VrdtLOQA9kuD+C 3XVkGzJt7Elq40s6RaQASkUV2V1wdTOBUjWeb8MplaZfTByu7fJ1pJKoADKKtwTXrHSOopJ2VHB8 5K/Xkl2Lp7uFa1R/9JsPG669Zw/JLip6PLI0nIwZXmqQpFiWZiWBPXnNKI9oTeF6oKsSCYsdZdu+ aWZUicmCdfOMbNd+sPOzW51RZ4pD29U2jNMjsW233YUCY6atbjti0QPnPqgfV+jcg41w45sfaoxC M7MXYRpgHXSnYAo64mOwA7qcPhgFHdpcoTV46nA2gKX5XFVQN9CtD8HG60K3lbbZGMCCSed1K5x0 u6WgtUe8IwnKpmrFrKYwK/H7PMk0rzLSR7wluv64w5KxLp4Sfc1q6SKfeN/H24dr5B/98JwV0tg2 spqVS/1MX7BzgLB5vWiGmqHxWLhEw3T7a0YO+mwW1k0crc/UT3esTbEwtoD0leDYqSCzdTe067FW aY/PvzROm2G6VH/ngfCYiukdiQgDBnDs7rceEei2HE3L6FZSuuX06u+kFS+CVj3WosmhL85syBjs KBIYvR8Z+G/HlEgYBnbDyBE6ReHMHXxGdVR3t40NTgHbpagj4DQ0waqk+XFQR8Ub4vd9VFObiiTf sOF9tW9m9rf06Z8vl5eshNbCtaKO/o9Hya49PJDOto10n2ACJxzqsfZ9HcEy5R+qdxRMeUDzjUJT RMHMmTGbO7aB/NbQbl37nUIKxh+qw9ybclIoAfbztfusX6/4uoJPXA/PYFUdPX74ttULhbcBGY7z pkOwFYasHk1HK/Zt9ji03bddadWw1k8z0x1oCiq77bOHaZINSqpqWv1SbTmpu4yYWdtkepYNvVTd tOH/dKnQ6fykHkxJIKQwotCMQio1wafUNqtMUqWt6ogeS5BK6iGd+H7HPRvYambTaVXVUaRiyAyd /Fy/gWW4ZtXR2w8frn24kM0a2lqlXRJmB9r4UZSSxHKlry0uhwvWkGcyNXHB9nWPw9Gar4TYjwu1 ZQSagateUyfvjToy2TT9GWsxppYV9C0kAfrdbFXHYbdfW+h2IMF3yye8R410hzcC2L95tD6N+Uej sfbXKg6xz7a1jhqor9PvgDb2gYR+ftJKrVILq7CpFgmdcDCsFTZQxlEYCJVh/7PcrqGauW8pWZzr 4/V+xWOKc92Om1RRLeTTthFRRVPkPbBLur8oq3xd/ko/V+9o16sjahuhsK9TR7/PwKEk3YsnZWY/ HJC00/981s3MIMZmPhNcqDzgiNCZkTC8OzThGprN87qQCPoG1q7SFsxGexY81V9o4Vo1tVVpgR3W 1cOm1UgNhZF6fzTD/62BDUtP7ElS6AbtA1uflggrPg10sAK05nJvVCP2ux6tuT46o7xtALlWPjAU TdZh/zZsGtRRB5p1ddN2qTUQgiWwStYtNUUE5nXRwAsFTuW+sb12FMMbUoMSQYu2yS7tITNvvR2t d3SifSDzdQSg63zJv4wfbqGOHtnMfjggaaf/fVeUf2cyVbGqksDAqIxQmtrnoA5ehLp3udnRoxYn 6lhQHbhlVMowA7tv+7CTIMGMy22Dt3rF1E8f6EEEy8zPCJ1RMT2XjP5iXzlcuReejeI4vd8/D9x4 4C+ft5/HbbbKhtZkW3eltRCCYYcRtKFWg86awlEVNF7ovoAaujWVRPe33lJ5zsQqqRjbGTZRQKQl BOW6xNvSashm645IHcXiIeWnyQA6FDDl779nn6mqo2/puqyOduvq6JHN7PcXsq11+t/xY5dLKZLA oqtmBt0Hr7suSqEhmkI3Lf23agWi2ZgP+sbJUBt0rfdjQGOLHm02zdxuYdTSzUPdi4UP2qzb1rkL jwwevBumRq9pax8wXLu5HzoCN6kxux0S9pXbAM0H6vdZaxBS/6cazXox4Rc/pimfCiZkuOAZSMEA MiyPSfW2EqKBvE7SEE5gSD9HKTkQVUSAKVXZYmhPB1ZJVJ1NaX7qe7u+4OsP1/kcpKbaA+8GTV3+ lFnbVEdiZv/mcYvgHh5Ia53+m6FcGk63PRdDLk5D1OFtodb4MFDkEzXa7arBGKHQtqypW9dox7YJ HQFW/CPo7mN9qa7vCUx2DQdjO/T1MAFsuHbT+Ap4IoIJbiXZN7ZKC7WDHkNYjGIcfCTs/KXQd9xY WwqxC8sW+6x1ldu4SM931dPQwqcGmKaQoP48wGdURwQbSsSjUUlla1P+HgVAqN4SKvhWQjXgDB9q qJavm6YMpSBfjxyynU6S/t8xrKiP7epM3VFRR5f3VUfPeMj/nRRRPiD3IBAT6OwGUW5tl+5nbL6M +j0YWptA51Nos6Tul47BmN19KGW79W37h4Z5nfKCobkXhwxbCJszdFaRM2bVHruVpBusf9NG3zh8 ZyRvwH7bjtAPrb7NjqrMIoEX9N39XV+bnNAKnjCAqPk9/VfEeRGqMXxOK6rn1Ido5j7jhR+TKtB4 V5OZVVE0qX9sYKLbooRw9G+N0iJSfKMMpZOEagVGRwnVCEBv2Jd9TSdRVkdkZO9/H8IfMqi+y7+4 w6iO/t+sjv7Tk1BH1cG51yqzkB7wXWwO5qBNI+MydMHuhDZD2WvvUuhMb517jGC2uwZruMLgjCyh AoNP1aukZnKHsIRUN+1yZXJBvcTh52AM8se41D8QbF86X8zMlzYlG4sG4843gvMswn5CpB010rat VnW0LEqsvhCIuazhWMmOmRBNQiis6udUVE/NoqGC6FRBhHqf0W/S55GQLIqvVLJm2DyjoqLyzxEk hEMuByigSpzWJ1Obao+o5ojCMgrRIshXCtXy5ZpS/xSqZfC8yJBKO1ZHamSfsirardQdffmnEP42 w+jfP746ejeF9FeBJ4jcZ12G9dElZGbv9AA1e5OD8ZHQnCx2sGKtRZIQjpRMgmZmQzWn5LpFqGYU k82SrVRcL05AVWrj1jmmdQTWTkroT0Z4iJT7g3tEsMikL9L7XVtMF1vV/9taoRv3+oGms7AVaMix YI3pQRVpCIbahpHqho/NtG5eD5jMGIPjJErnxKoIWzimcEJsiqj8vGJot8eMId2cP1znmqWrQBSF NGfwaHqfYEX/wcyp/bjP731OrIpuCNW2jGxSRa9eYRm+dvu6o2fuIY1LCybLLKSX/LeguSza61aq 4aG1rdV6NoTFiViHiUZrQYA5L6Droo96SpgCOxiNZPMp3YoWTa/csM1xO2PARB2tOLM3xAeVhbAY T2u9k8c4JO4Ku675ooMvBpN/70KyG18Bhs2f22S2tg22raQ240ZAvSCBUukBWylM5Ml/cxeuwTmA 2HBN4MQwMqrJhHAVZHIbDjVIAHNfLqDV2MiXKb+v3cRhHL13yqZRaJak2TbN0lCb2JA/TtuhGhnZ L/K5tv8j3ipU+/rGmP0ZhGy3WV9Sut6Mp8UpdKU8NpNUc1W7QSpMRliEXmDg5ud8U0tWydh2A7Qh xergNFjfvgbtPlsNOjg0z4YRqMNrLEOasAh7Hv+yDjA0Plu95+b+YnDzQY5haE41kBs3ZETsDOq2 bXULz7A78RUsafB1TtVsXoKowQU1TCNFFE/d4/U+NqwDvb/8XMM2CeHYH+Lvk2beBKqpTIBsNU+T QkiMblJG9O/VUI1aQqj2SEO1t/n7OYdlcXe3UO3t49UdfVggHc68wpyGotwE62/p3MB7hHZ3WNvv bAAT2Mph6KINHLYn6tCBLfMWhj3WlnVFMAC0B946iCA8zUFI5wGFtq1nhNKN/xYcf10m4jPV1KqE tGgRkvSVYW9WdwWKxkOCtAodFKiMYMHqB5mfFS5BoCQGdqphV7ugKDGY8mOjgRFdn+R7Ma4pHCsN tvRcM4NoEr+LzWxqqOWWFRroj+IbnY4cqlUYXWEZRau+EWXVXr3mwmvKqj2DUO0JZNlMNinhPTrK cVG6YsKuPnmObdJWNcNriCBD+AHXANNLMxizcdpQbsM1LTGwo2sNjPCmudoI60z44Bm1cyUAeI8/ VLDl2UYa9VtRQxinP6Y28gN7JQQwZM+qWc29ZjCETlX9rIRnXchVTesGLPqaULyjGsYNKkkfB8aX 0lICLYAUExsIVhKipYlMb649ontQawj9i6N4RbtDCsdSb5RKKh+l9uhqWvGNJKv2TX78G1JLA4ye aKj2YRTSfY7Zu3sf47S/NYgsFUxXdDiEZrBq7Jr7YJ/O7xpgYaijGlL+q69is1ptPNMy/fghBJHN qN1yIwK8ISzDTUCNGVXT7mF6zpoakllBwcAI5m7EB4EoQkvfgylKtJmypoZaaIYmi9YM6+G+ch8U A1wvLTQ7dWpJFRNGDtdi0pYQTu3P4nsxjFLLqKmXNHFVNnlK844HsVGv2vEgvtGRCyBpn7VL8o1+ z6Ha1UYB5BMN1Z6AQrrpbZ3MCSlZMdz6dQ0lMmhaR8a6PhjDQAjnYWHI1nYmDc2TwiGVvZFAgrCx q/04Xzusdfw/DJVu2lF2vbEXNtpCbv9EYDr1rRQDo47QziIyHfbjBersIKOGQvNrxuppxMHzAfV8 ekVUFJB8VQBBWN7HKiw1qzX8C+a1EJtKotsnMCFbqUFi72gnQJ0jh3AEoWmfSuV16eIfTWyUUO1t /n5e8Y3eYA3VzhVAvn2aY0mfKJDM+T2F5XjmtU9o2MoJDXOHVkfH4tpzwSpRbNZuDBebQWsHxp1R dAOMbO/eexGiZ8AGgNsB2Y1Zerwhnu4zZ/X3BH22TKuqdexHa/2waXs7GM2M/+iaVhsUyldbtAit TqgAYgVAuBK6jT4TmhIBhRF9pXAsyWtF6WMj+BRYSchGftEUm89VwjVTiZ3SsviRYFVgtF+HUfGN svL5NTXT3hCqnS+AfFRQxfCsVg1t1k627dMFzt0Pt+97v73TzHPAMhxcg5EawviIu4+gef37vAtc eETDNkWdTDUhGYwtHm1GNmDrOasV1LUXTAAE620cKH5PF0rBAJy4DN1GVXQTjGp2zagiAtGkTbUy jhY1k1ZCNr4+hXZbQu5dK5XYhLQT/7tPEqYdksBopfiRYPQFgSb/Hrdg9OV/elIFkM8HSGk8KRG2 f2W3zOpAZ1YM290MGS84B8MF1GxhZFhvdl9TRwOM8Altg3RXKIEdwr/4JZihauM4kO77ZDJqJiyD VNsu1LwuZrUUOOKifkgAUeBj2z56qFjoIKxl2ZZwgkE1WRDV7JoWTEIztDWUZGU0FxiBVmOLWU+G Ne9Uy+l9hdFhz2HatJJR+27Xih/337OJvQqjW/tGT2I9PSA9xPzoeEtRA3c47c4DcGyLuMNTPoc9 2fD8Fbj4441bGbXCRrAtHhZGYDwiTdmjmUEErV5HjeJRFVUYBRuqnQEONi8JNtSQbQtJplygqz+q IDQhYZIQTcI0+gpT6mBE/65Tkn+zpvcNjGp6n7r5LxhGUw7XvqVpkAQjMrFPXPz4+lJ27xlN7H+X YfTNbWD0iVRqv/Nbu2uGGe5IhDuHKGcwBmuG7vY/AW79z4OHIsmDPk+dArkVqlnfCHoTu9/ccZg3 jXbqonyVhlQ+8Yd5RTg2wN4CRuXnY38bHDfvm4ZQrimzU/WHSoiIzS9K8t5ibL1zs3pGUmtEbSOl 1qiMqWU47w8MI0rvU2o/5Z/3Mt/odVZGJ63E/n2GUb7uOxp0OPG88a74McNo9x9C+Prts4DRE/eQ 4D7/ijM7d9z4hLfwi+AObxPPqKxbqaOHKJa8+3NoJu6mQSNboRpu+EYdjEwKfxNGoYdR9Y+Giuse RqcGI+zDqgWMRB1ZX+g2MLIGtoUP2tICgRGZ2TGKGsrfpxUYocJozztgHPY8XqSDEZnYJ07vny4y jHJIVtL7P/A7tZXYFKp99VWD0RM3sZ+5qf2BQr7NynC4C9Dg7PPAe1FE7+E5ETdhhLDcsqhP8bf9 xhYwgnMw0vBthNGGX2Q78+E0dOWvh2JB1FEzqY+r9z0Ho1K1Hft+uNoSkmYeOStZtTVlNEtKv8Ao A+hAGbYTb2dU2kMERpcmo2ZhdLYSW2D09+QtPQ8YPfGQ7SHNovtCCe57csOHB8dDIAvOpSAH3wjW trnGzjeqhY2wAiM0bSDdz32N0Vof2iaMQl/cGEwY1reCHKt3tFZvFLZqkEYYgTHWk/GLpGtfYZTi zBCCBiMyskvIexAYBa49UhhR4eM0pPdHGN2U3n9mMHreCik+xIf+WufGO5rMH8Mu2Lj9Tb/L6y1g 1M+sNjCyBZArMOp60/CWMLpFyj6YUK2pquMqjHBsnD0HI22cLY2wYoKfgVHZ+HG/DaPNwscbYKTp /WcIo+etkOCdfq3wEE/SzknYeO4nJYDwbt7RSux71sS+K4xMcSNuwmgrrT/fCkYwmtTI6qjzic7A KJjiynADjLSBVoshCUZ4Bka4T2XYGm1TNM9ll4uzMLpN4aOtNXr7PE/rj89D+lAfAHjTrrOwYaaf NbQfh1bnYYQbMOozaB8ERtAGqfUjZFdqjVYzZveHUbgLjNJ5GF3sUwERXfCUblRGdy18fPt8TOxP BEgfTJ7Asyf0+4RRN1b2XWA0TG5UGMGizUOzbCswImWETwNGpTVEYFTS/A6jjx1Ivp4CjMBuxvgu MDJ+0VOHkbaDnINRmZXtMHIgOYweAUah79x/dBhtZNMeCkZRKsodRg4kXw6jG2GEQxmAw8iB5Mth 9GgwAoeRA8mXw8hh5DByIDmMHEYOIweSL4eRw8hh5EByGDmMHEYOJF8OI4eRw8iB5DByGDmMPhYY OZAcRg4jh5EDyZfDyGHkMHIgPWfQOIwcRh85jBxIrowcRg4jB5Ivh5HDyGHkQHqe4EGHkcPoU4CR A+kx13Kg/hqE3mXsrMPIYeRA8vWBgeYwchg5kHw5jBxGDiMHki+HkcPIgeTLYeQwchg5kD4CiDzQ geUwchg5kHy5MnIYOYwcSJ8WaBxGDiOHUVk7p8KHXrL19mIH7jOwchg5jFwh+Xp/QDqjkuhnh5HD yBWSrw8UpzVtpN9thW4OI4eRA8nXY0Rw24enw8hh5EDy9V7RM1BoUx9hcBg5jNxD8vUOEZkeaHju oLvhYESHkcPIFZKvu4AHbjiwUHiPd4nVcPPAdRg5jBxIvm4BJgIFnDWvw61CsuAwchh5yObrfflF a4cg3vnxDiOHkQPJ1/vxlRxGDiNfHrI9PfUEN4KoXuMwchg5kHw9FGbuepBWGMGYrXMYOYw8ZPP1 rmEZoMAKb/0cDUboMHIYuULydR/H591hVkO0CqPgMHIYOZB8vZ84roEHFqrKYeQw8uVAei9yadE+ S2EbQmXTNojsAS3wgeAwchg5kHzdJ1CzkmiURwylNY+pV0UOI4eRA8nXg7nbKIyBBhqAHj6L47ip omqAO4wcRp/e8izbgieA2/A4A6E7Cyq0wGl3chg5jFwh+bqnR3STn6331OJGWDmIh+/HQkiHkcPI FdKn5v28y8Nx9UZYvR43YCQgCg4jh5EDydfZEAwtZcrP26NHsPOEcEsFhSFUG0O0AUYFOg4jh5ED ydetwDUOU4OmknBFHaH9uasxEuAVmFj44PCzw8hh5B7SJw6fMKTm+/AMFzNp2T9aaxkB+3yoj0fJ 0Mn3I4ywB5LDyGHkQPpkLSU8e2dcuwbUzIYzqkq1ksPIYeTrkwUSrKbL8JaPDTUQ6zJpYCdAQqs/ GksCcMVTchg5jHx9wgoJ3vEYw5uOU2xQWk31m5/FQ3IYOYx8uYf0DlEednVGoNEZWuJBOFtzZFP8 kJq57TByGDmQPm3IwC0OSBuudZ4Qwsrs7C0ZhhLhocw9GjJtKFm0CiiHkcPIgfTMQzJ8Jzjd/fiU jFqBTLBSaSVUFDW1SPsnU3vkMHIYfZLL65BuPhTRbDiLtThSK6tbJQAavxp7KMp9QVQQ2uLHFRiB wsZh5DByhfQpetxbbR72e1wN7Voz7CiEoNYtgcFQTfXXVhBcwKhCyGHkMHIgfTpaaAswsHSKKliq JMIt90mLJK2yMge7hGgAJqsG6DByGPlyhXTTgTi2hrQRITh28t9YSsDhHXS9bKka2XSCtvDMYeQw ciB9ImGZuQ5wFSQ43gfDoiutqR0ZVovDuJHByK7PZYzsoogkdMNgYBQcRg4jB5Ivc4jCIrgLfboe u8KjvvxxHBBgPSps6qjCSEO0DkQOI4eRA+nZrHQHJXRbBYUrHhOi7S7BATjrhnZvKw07hxjviMFm /CJgAEE5qZPDyGHkQHpWKiatutJnjzUAXEwL6X/ACjXo+tOG3UDGfjjcts5htSJb0/vYao0EQKj+ Ubmvw8hh5EB6nrHVfbxrDHV32fXHjDuANP+IeQXd9eXpoCkqUHUUjG/UtYSIf1TVkMPIYeRA+vhd oXPwgiE0qyGWfYoWeiEaGK2NrsUxFBTlBdjBKGzBqGbY5gYgmB1GDiMH0nMRShUiYbOvfvWaAgkc vKdx0P5gSoPt5of1iK0WQ1YFtt40qwBipTQbL2mAETqMHEYOpOcFpI1Izu4kWzs7TO10/QJofCML La6sbiGZDt0PqzPYgrm/qiLQFhGBUs2uoZjYQUI0SD2M0JWRw8iB9NGsLnsGJtFlq6gVQjg+RvvV 2u6yCiy9D4B1taHzjgqKwLSGGDO7y6KdgxE4jBxGDqSPyj5aeDxhZUcQQFNFbaBkdwQBm13DZl6H vj0ERG215lkxs4uySgY8Cqe5gamDkTWxHUYOIwfSs1JCZ83sofsew3bNEi4KGVuYVt1vrTlAHlML YCUX9hAr9UuSVYN+15AQRs9odhg5jBxIHwGRwpkCo+XdsR8rAqsGdjBjRgxgwPpOQ9OtCfXAbPCI aIxsqTVi1XS+8BEESA4jh5ED6THXHG6uMTo3iA2X6mm9i397quNahz4irjw3dO9JB/ZjMOpIM2xo RtKO6X2HkcPIgfREF52r0zuEb5qZN+oJcXSP2HwGq2jMiNlgoBI6tRONipKZ2vpaAqMKL2Nm14LH NRPbYeQw8vUMQrahQBFgo2t/65iEpo4S8SHqcLTlUDY0aqib6mj60Hh3o8QD2HT7I6O9FESIdt5R 38VfQzVrYpvsmsPIYeRAehY+0c2zhxC3trJewgxMxmzhH4VgsmpYh6jR2F9VWgQlMKP/qyqyUyDz BXDo6KcTGgUAgzoqoACGhsPIYeRAeuQVt/rKBpDgxvVdv62CyxjOgDY8C6Fv6egvdfNGNDOySwjG 6ghMQVMdM6L3FfgUNWZCNTazt2GEcBqqsh1GDiMH0uOJIDCHGJ0j003eNq4el11XP0pdkN4v9n5S H7Q11dRtUyTqqIkoszOtea6aUVuMpTWjRWrodqpg2oJRgYnDyGHkQHrENYfFdA8Ym10twLBP44fF VtehFjgi2GLFpozaJOx+5jX3mAWGUdVfEFrfiKWePP8458gY2mBS/AUSoo4KjELfzU8wAYeRw8iB 9MgrbYVq7TBUQKXhELVjaaHrJxuPZdlDzc5AkpR9VUS0AaRp/QDZAoCLj0xXrTbQAgOszj2yhrYo JAyzpPyNQgJrXmtDbQ8Yh5HDyIH0DJZVQbYiCEW9VBhhU0Qos4xqin70joJk0YoprU8YK8AQ2Myu om1tJxH1i+zgNYWRKiQ4Db1qp6KYcPSPHEYOIwfS01+j8qkFkCjmNrTBamAUEZhRstCFbKYqG4Zs GdvYoXbo6quBzcj1o0VgqDkCG6qFcdjaadEe4jByGDmQnqKfNOEypIPhe9vS0TXe2xolrPdF7JUR DHVHzTtidcThlvpHQwBpAIY6mnZI89uKbOhqj26AEdLPDiOHkQPpAyqd2x2H2k2SsD2m6963Y0Hq DrGhS+vrHCOAIbVfjWiBD4JRPaGZ2bXyyLxBbRepHpLUH9VO/mGsiPpGMN8MIzwubncY+XIgvWcg ESDKqX8KZwbmm73N7AA1rT8yCqi2f0DzjmCsLxJA9T6S1BmVDFnoAMUd/dAZ67V8QFtE7M6z3d5q pu6oQmejGltCNAJSByOTcXMY+XIgvVcqmRDsjGdUs/hmKmPrPWsHcIOOWD6m9gi7vjWFUap3wpKe b1EZgKb5wbxZAyN5DEMIK4zQDGAba46K+gEDEIWRhGhbMAoOI18OpMcxrOtJXyIpXHSNVMUkPlJR LN1AtdD3opmmVzRg0pQ/t3dw9gyad928I7TkDM34hvVdRLjOqFVmL3rUMiRCFMAUj+gonlEPG4eR LwfSe14xbh90UU7pURWtGdutk8wY12HovLeqyMw1AlU3KOooqI9k52RrR+6K2dXVLLEyshMhIahS 0lT/SmYtcYU2Yh+yoYLHYeTLgfRhfKMSSQG7MnTaoXg/uyGUIxM7GlUC3e4frRaprz3CbqxIX5md TF0SpeetkT3IMLpXuW8L2dp4276JtlV2L72js5k1h5HDyNcjAumtCJLJFjKyKsG1Q5IAI2GbtZw0 PAPgoEprj2w7SPe1eEMNSuzxiB6T6mvo930siAGELlRDgSdUv8gUQ4JtFZmHrbCl8BHnzcyabRdx GPlyIL2vV6KD+jXw0LW1LbDNmoNRRMauQfPQJGEb2l1ih4zaWrhWK7U125YUSshjQjqBRNfF1bqE rsXEFkRKv1pJ98cU7KwjMO0haciW4dAu4jDy5UB64PW7fLmceAB+SVStkSaUnBKD5rg9WiSIeV1U 0lBDBAYy2FtJtWO/mdjJTIOUuqMCkaaOsO5qBP2eSVY32ZEldp81MCGbaZ7tzGw4rfepbfzsMPLl QHqAdU1AiusRWzBsSsaoVm8p5QN9Cm1KYwp2NnbfZN/FfWAAJZMbeQPIBiJt68inkQxP06ZZm12T WgGddIRWKA19b3YnWmz+0dLInldDNIeRL1+P6CHNbB+xONkY1G93gy1FkzpdhM4XUUltiL56RCue kW0JqdtYo1EzUFP9wcAIQpTnB5nHZswlaMoIZRgb2q2xdd7RYjujG7Y0chj5ciA93tpqGdGm2ZNR UVE79OnUT1qneMYzEmXU1ItCTOuFYpuNjWaUiCijWvUU+XbbqBu6okqBEq5VZvdbYSt0UlgpiHQY +fL1NAojo9b9SClQnRoJyGhAk9mSfjUwObTNjJpRMfpzrcpGM6jfhn51+mNsYZxcVQsx684iw35r Up0NnYk91xnZamRbc7tL88vX1FVuO4x8fTIr3vuR/zpfvn6Ad3BV/KJQM2QawkVJ5c8CpjpqBLQd pOForDeycEIdJashmwzcx2E3EAg2Pd9UDtQaIm35mEtVtR0f0qsdSdnDkWGDywxag9Kx3F8fY2Hk ysiXK6Q7rF8ac/rdmYicajNF0WuHry14LMWSCeu22N1Mo+IP2T3R2lgQnlEUOTOG0O8zYnaqDVJ/ 1EWVYL2qtt8a1paRYUtsG7bBef9ISwHG6xxGvhxI77D+c778+MztUySYSOr+SrygoTZJ1dBYV2TD pkU7iJ1HpF6RqCI79wir+oGaOatAEzO7bnEEBlhmflLN4NUSAju4f+7AVMMu4BaRhL2q0q9pyMAF NI91GPlyIN1vvc6XL8ZXyQd3PEI1sulCBzQcse5OWzJuYZiZDTISSGqDqAapZtzATHe0rSSmPkgN ZzQNr0wgkK2JgoGSHdLWZmbXigJjaEM3GRK7MA9tq4h4RyV0SwwWMDuL9Gppdhj5ciC96/r5n2H4 1QQ3mtZ0Zk8RZaYQn+jaYAvSzwbiFSUBV4l0TFaLfSC791momTOo6qel9zXDBl0Xvu6pBq2bX+Ye NbUl9zHFlbrvGnTPi8bE7nvXtAbJdvmXkSLAhZEBZ1OHNHhFDiNfDqT7rVeX+SCdb3ffMc1/Lafx NIwaovwWn+NYJ36oMopiYut21Qqx0G1d3bd0dDVCopBwKILkmqMo3w99a1aRBetJYdlnLZh915ii rRBSFREYLwlNhs0qJoeRLwfSI64kKqlWYAN727wvm8m2GU/JzjCqUDKqKEhVtgVHCdFKewfIFtXq C1XkhDbXSEfUghleu9zHbS1c0y2yrUqy5nTxj1B3FtG2EquQZoeRLwfSQ6zPPsPw3XcbodufQvj+ EMJeVFEI1Tpi1XRkgXQCbDvMBlYuM40jMSa2HawWax2QHcyvkEpGJfFIWqz+kR1cYksGTEg3nlxF hKVhwqQNBefOQ2o1RhujR6BXRc1XMs/jMPLlQLrf2u/PDOunQYgXHCPR6XiIGCY6OZKoIIrQBD7F Yhk8ojmYOiUDpbaBY+vkD2bIfg3VUCqaFrtFmmwdYC2URNO30lpbmjLCaphLQy2ue0htQuQstUf9 PO3mLZnygOgw8uVAevB1yAf/21M7sYuBnc8tAlEM3Fk/qamt2kTno4FaPQKmGau53IVsBhI8OsQU RNptiAKY7Fq3T0kDTXW4V9RRCOZ1h2Zas++aHeRvu/ybTzT3MLK711oYBYeRLwfSg65pYiUU37Iu GI3tt2JWE5SuRQ3Fk6TvI9bqbPWTcNjYMY2V2dCKH2PgTv5qNg8D1tq87SApfqxgxHHUyLiNkjHK x3BN/SQwM5D6Tn8TlhkDu1wfDbgoAxdl622HkS8H0rutS6o7ilBCsYv8/ZuVWG5+yzACMpNUKbWM O39N0iJiN4LslNEwqD/J1Ebd7UNBBPPG+cPbYtvtj3gSpZQm4KiOTGlBByMDJVE0Y/q/L5hkQEU0 Ckofh6yMyhxuTA4jXw6k9QMObq+OdIxQftgfIpnS8mpmamTMJ0ypS7qSOqQdCRpWRScN07ApJYQ2 ERJmOz62QQhlNnYtgEwtXGtVBVhnK3HZgG5pZGBk5h7ZTFw3OUB3p62qaF60jqAJ4UqqP0oYJuqI qrOjhmVD2EaTLC2MSDFFGQTnMPLlCumu6x9D6SGhrNrFRIZ1mxo55ZMCIwPgKDiZjsyQ2ez4UbdC iwyh2kcGqlAi1yyByXiVcSJpWxlZ70j72iQA1MmWBke1eRdWgFRG1YKoMRld21Vrg8Jobv1oCqtR RSWGUSowmjOsGXZpbjAKDiNfDqS7rYsLDLu3+fP/rZxvQTZ/reqJwzkt8kExvKdZNguikSNzU0MF Rqn1q6EZH1sgkZIUNDYDu4waAaghG1jA1DEjum12axVJ0OYftBbblYJITL2pPfSywaCQwEII2vVF HW3ACBxGvhxId1kYXq6EcWRm/xdYNthSP9vrI4S9Fj/mRSfPVGuIghjbDIE4MXjmxM24GrLxDiSi bOgkrWGamtggJ/8w2daY2aBDl2pBJdSWlpryH9tFwDTqYl9WABJiqfcTBxCV9xObYtJqbja32XhX /8jCKDmMfH1aa7rDfZfw+VW+7i+/zoD5SVZE+QB/m5URsYLA8+qUT91XPO3nIsdhkG875vtMWYYc JygoPE2sYkgxzUXZlDmOBTIzgJnmmB9fprhFGcavrneU8bPQdpetnhG0vdSGedhgaKUNuWEYtgag O4gks012X5Vdq7NNiGa/7xpurVckXhKU2UoGZJE3l3QY+XKFdI9VZiJ9HZrkObfyfeILVVFci3TU TNtJuCPG9kzbZs8CjxLiIe8WqWEWtHYRglZSlaS1Rmg3dQxdyQAG7GZil3EjEKqpbU+85WONf6RG usxBgqFaG0v5gdYkmeybGNST+kuyS0lN8+eQLcXkMPLlQLrv0o7/sX2EiiPJpI7XrRaJMm34ps+0 nWYGD5y47RTENwLxnGb1kCL3qWmBI6uhjLbUWj7GDR017LINstYhCjpXe6EH+8LJscMfTesIK6JU oQNRIINznQRgs2gFnql9j/Ms43AzjIDrqBxGvhxI91za8W/bR0ot0h7CdT6Ov8/fvyy3rWfadAu0 iLKjyIlnadMVKZn0v4BKe9eS8YA0dNPXT/V7NHOWYoNRVVtBFNXy/MMFwPoqbVsYiZJl0xCMJ0Cm DFT1jVJN6ceUavhGKf048eNmhVFwGPlyID2sO0XnPoVzP858icwCHdRGqudtJB+Je9qShGbzJCoo y6Q5ci2Sjhch3yfN2GXQwKoi2TkEZY9tHi0iJjaGOuWxmtnFyE4mVOsruXFQR7ZtpIZrMG59ZGZx Y5LUvlxHrSAlFCOviBUTeUXFN8r3TQ4jX77eD5DWUv9Fn3ybD/4XkvafSuVPuLoSWElhNYmLWdQQ +UbkH81Sg0QnKZnbqpKwAgVqBl+VESDW8bS6q22om0MymDRUW7pHa/VHpm2k2xwg1ZBMh7VxXx2H blYdlftHvl+tNRIYwQaMMMOImpCjw8iXA+me6mgj9U/G9vxCNM1rfnlSMTvjI1E9UgnPRB0lARPI dtdVJfFWJWUESQp136S2dZputYbWzAZpBxGVJZ39aaGPer9pbBtBqZiuMMEGJYVQKQOIqfOUICui /A8st4FAbQ1Gc2KvKu0Te2kOI18OpLUDdKN95Bf58k/z5WW7ys7W3u8xXObz6e01VGP7eMqhG7CP RGFbCYUm1hkUtpEioO9xxhLipJkNaA3XCEQzNIVTOkWwBXF15K1Mk4zSHsKFlS3Mq7VKqpZWx9Wa qQKq1Kg2ShROM6qlarsoIc2ymRElBKbEXtFOqrsnmVJwSqneXt79IRUoTxSqOYx8fRpruuP9l0D6 NdUifZ/Fz3+bQ7TLVot0PEL4KcHnJ1kVTRDeZKDs6HzN0NojV2pf7XmPj9NR1ErxmaHUKpW6pPx1 oq+T7h7LDbsFGVNo2xiJfxShvU8utMRy/7oBbZ1MibXmCO3oW1FARY1BX42NoLO5ZdQI2Noj7Z/j 77lIUlpJYqqKqhRQTuwVgXpG+fYTqSCBkSoj8s8O9FwyAcFh5MsV0i3WrwKPEllL/Rdj+zf5PJWe tsu47iNRVo3T/9LfJoXXVMWt5raqpEQKZiKTl8cBgKbotIMEWssHmqwa1hYRrMha1h6Zk1KzbBry yR5v7B/1YZstoERROuUNiXKapKq7mNiipGa6D/07Skc/rsIoHTlcdRj5ciDdcY2p/y1jW30kOsnS m6yA9kPYdmTfiMKVWb5SaJfER6KTTGEULWOkpxZ148mqgmKbux11pgkYvwl05wAWOQIjgJb9Kx4W oqgdsw0SiqoRdYNRB8WJryR+0I58I4Kqwohun+VrFLjRo2aG3mFiGFFWbecw8uVAenhjm3yk1/l8 e5laPdIun3zHiXcZubqCUhZQmmsps0a+Tz4xKcwrbSRkZkesu8VawaNfo2xCCRDL3aKFklLLlAmg dJ9UmRRF8AStcQptB1xrbKPuipuK7xVEFakpHeQrgWYSWFH1NflF5IuBhHQTgacANxVTv8AoOox8 uYd0bw+Jrvsn+f8//jqEP6z0tH1pfKTrHHJdZHUDV1koHdgDStRwO7Hq2e94HlGkPjiqUyqFkrw/ WooCHSkjalsYNShVSAXsZhpFCGYTSAnDIJlts01GTUMzqZYuqkxCrrrlUZhrmFZ8o8S3U1ip9y8l BrGFeVp9PUkt0yS1RcWcP7F6Ouwpm+Yw8uVAegcgLY3t3Y5N7etrBlLModn1HsIRpdE233a6gHDg xFm43kHZm+1EmbdIFkqG0iTbEE1sJcMsBrek+4v/E5dQigKjKO0iOMAoQtvhFlTtWBjJVzW9QQxo 7VdDMGFZTBVcurFA0CxZaqZ1lOciBVUqoVBgFBlGIDCaHUa+HEjvDqTv8vX/ff76s/8pq6I934dU Eq3vKbtGiukFlH2QyKc9IGfbrgg8GTB4oPnboZjWViXReNtJAFQSbVOodUaa5o8GSsWDipJNK8Y4 ynwj2ZXEwGiZXTMZtmBCMmid/6XuSFP6YmZPSfrOxMiOMqak/JyQ7z9RuCblAjM/N41XsTA6HbnE 4Yquz78gcBj5cg/ppnV+lO24iy35SDSx9kf5+8Mf8gn3JYQ30kZC2TZ8gUVNxet88mSVRMrg6rp5 SUUtlSplCn8in+AgGbcoyazaJsIlA2V328SNcaUqO7FMotAvmnEkAWHz31iru03vXG09IbBNonqK FyQ7nASspjaZ8kUFlQJPgVgx5vkrwYhH1GYQ5X/r1ZGH0hGMUobR5DDy5QrpYX0kG7aVeqT8/fFl m48U8vUph21X+eeJPKNThtaOvaSZOEkTHGeBDL3EzNkwnXtdEvpJtlcymwNQISF9LcIqiWISBk0S tlV1FOUCMt6kFFMyXJJ6SAQZGbBfO/AlFEMJ50o1OakiKZqMsp13lKJHKGY7K6/9gcM1eg2CEQqM rgVG+wyjS4eRLwfSw/hIX/7TZdj2mgxrCt1+kk+HDJvrJGEblQDkcO0CWO2ol0Tn806qsJMUS/KI bKpDkuLI0jYSiqcEsh03praf24QyoVbG3UZRN3yD2fPNbKNd4DMxlABbz5qm9dXkVn+JsnooxjRl AEGzaKSgEmfq4j6V+1Ambd5xWAYlu8jq6QIZRJDV4v5Nhs8cHEa+PGR711ULJDfCtp9Rp/9vs2LK ULrSsO2Ks+4/AEMpXOUQ7sCnzfFImSi+nfZrI5CdgEsBSg1R8YiksJGydVOrK4rcXct9+TOPJSGT HKWyG4spvnF+lpaQUFQLqSaMDLQylUD67GIdi8IgovuV9H5ktTOrQqJShTmVOqrTiQs8d/n9k0cU 87/vgGxeE50vr/j+r/O/k2D0IkNn+i2GVw4jX66QHj5se0M+0vWKuT2oJPp+Jwb3PDPQink98x5u pV/tpIMjuUK7+EkmhNMdkJI8PkLb9RYlZKPwbQrc4xZDu632q4lRjTIcrtQmiSIqlddExMjKK6kq ku+nXQvLWEXxcx4Ianue97QnGFFRaP4lHK7YN3pTlFEoMNr/PsPoNWYYBYeRLwfSfYBE44/+aiNs e5sB89kph27X+fS4zJAKXJO0l4zbaSqcKiU+V1S5HTh0S3tuQSFvaZKZaiWVL1uE1H9BrPtIFhhR Rm6SUK5sElAEDRZAlf3gpIVEQ7UoDb1BfR8QAzpqc6zUIw0gosfvJJ2vqkhT+lQMqmDa7yStTyop /3zcSVo/k/lFfq4f8nMeLxqMXv6AOQx2GPnykO2eCzOQYDNsI9VyKQPayEPSyu1XpH6+zYopQ+l7 Ct1ohm0+ca8PYnLnn4va2udQ5xjDROpoH8rYDioJwB0VYUZpHyODmWqZ2g4ic+LmXAIXaPctSsg2 nLcwcZkAZfiS7n5CI1GAryuhGXAVOSh8xD+aNI0P/P1J4EM/k180i3ldaoz2rcboRb79O7nuBTUe O4x8uUJ6GGP7XNhGQKrmtlFJ1OhPRi5c96GbZt3K+H4auLiTZl0SQzN3+5NImlPb71G3fQQZhUs/ TzFIWBYk/Ao1y4apNd6iVnAHzpal2Pwh0AZZUUelz07qmghYO2Sjm9L4O1FFBLOdhmgzh2jkHZ3o 5wwTTeu/JuVE41kcRr58Te/w2Ltn296c2Et6Se0iP+aM2ymth2507s8nBlqFEu1GLaKO/OVp17r7 J02aRW6wnbRJVkI1ui6VLbnFTwLpjYtYf9bCRZAU/RQ4FCv3oz3kEFthpAyTU7hFMa5RYEQpfWoD oefbBwHRRf75TVZGp5ZJA4LRd/nf/CcMf7jKl/xs1w4jXw6khwGSVm1/9dsQ/vhnS5V0neHzU2qs fcvtIxQ1ksG9J7lzRXGd8ZMStZMYKElnBkEJ5OeJRg5R05soJBnLncM0hY9s1Q0MKapNYg5hdyH4 TDKIVkFFT0ZFmQSiWcoE6LUo65dk+FsJz2ZN//eqqMCINsY05vX+mszrUNP6l9/m6zLA/5Af/x39 Iy9JZTmMfDmQHixsO2dun04t47Z7uwzdCEqnHRdHHgyUrnecfeMODyxjTqKoo1KdPYCJwDJJ832p sKbn3jFkUJtvZbZSCcMm2e0EGUwnlKpwkAmWE4dinPrnveWK6kmSqaN5TsXzaqqIQrEaool5/Zoe dxG6GqPf06YHGT7TBVeuO4x8OZAeEErf36CSKOOm1dtgQrdjbH7Sad9DqZjb+eeLHXfvJwEVqaWS WhcwkXKJM4dzXIXNCilpyIYMpLLXm/GPUk3fC4B2GUyihGYZPTIBv/ZJapQIVgQjmlZA/lA49aqo C9Eiw4iKIF+8yjf9EcPnb7jG6PWL/NwHNv8dRr4cSO9TJf0pq6Q/51CMoDTPzeD+gpSGCd2oy5+g RPO34wAl9pPphBalhFKdjQym/QHrCNvSNyZwKqJpljBtx0onyNZKUUKukvI/Ya2untXwljCNygT2 U/OIopjZe+q1oy79KywTbddU0f7UQrTiF70IqzVG9Dt5+dJh5MuB9B6AxCrpH/LX/+6HDAwZS0IK wBrctBHAj8gHyifdnKEEK1CynhIpDxpTfbrmEO6w03FrDUy0ZVIphpywztHmNhEO0XR/M+0k0Uxb nTIpACLPiZp86TlLUy9ypo760mgiASkiBdEuP+aqGNf5dY0qehE5i6YhWvGLMqBfXi0zaS9f0pTN rCq/yiD6+/x7+X8cRr4cSA+qkrJA4rEk37FKKlXYQ+hGULq4hrC/Yj9phBJcN6ObNpzcy8SQsnHk 0YAJzfbXyBk2Cq1IsewlrCvbGUnYReGXhmBFKe34cjpK7IdS4CjNsaTKqJiRXpMmOkJiEJEqOhIt M1wmAlG+XVURwWgM0X6fn/N3sMyk0e/lz/88w+jfZZD9xxD+TYbR3+fnfnP2d+8w8uVAurVK0tCN VNJPjcFtQzeCEhVTllKAFSiRp7Sn3YSuQmd272WGtoJpzsqEoHUR24RInk0USsar7Ocm02W1faRe SvaubZdUwzmFUAYHXrMxTmHjjhQbMIjodvoHXFA7SH6NN8ApfbwIXUr/1TWHaOQXUdg5jeb1TxlG u/8Qwi8ERj84jHw5kB4+dBsNbhu60fdUCkA/bkHpcOItlGiDgE4tgQUTQYMLKtMFz+o+RAYHnfDa RqIqyV7IRyoFlBlmV1EAJEooiAeVWRgOVGt0YN8oZOBgVkQ78q8SVVyHGp7BgauuSRXtvuOU/h9i U0UL89ph5MvXTerm4VTSz/P//5d8+fyrEH71P0K4fkVhWyjbJVEDLV0IUPt8cn+VoUQnbfiLEN4g z+bGK26iJWCRsqDZ3Okz2Z+N9oDLwHopk0VoKyXqY+P5RzxTqdQuvuT+trX3Cq+x7oxSplICe0ME qUn8p6sdZ+mobSV8j0WlkRF+ke//LfWhkcG0x9IATOl8+re8zCD7Oj/8j+RHXXKpAoFoL1nHal7/ KYS//SaEr6mz32Hky4H0tKD010U6QdnL7erHUBQR+U6Uzv+Ssmf5+6RgImB9HtrebPn2y5lnJqmd pJDafIsnbTGRLbQp7Jq4/URDzPQ9cjvLfh1E9ODLb/Pz5NCMzPg/RA4h0yVXiY+qiNbdMmkOI18e sj0Y3GzW7adDKcDx2IdvZOSW7Ns171CiIRzVHNGEybf5hH4VuEp7KsOTSMKEshslvGghXflKNULU pjHJyJPAGbu3fPcCKgrR0o7bPfQxQLuivKHZ1uxhkT9EdhGN4CWP6A09jmqP8mMpla/h2atMwN8V WIVadb0aot0pk+Yw8uUK6cFVEq3bKKUy2DGHaVQM+aWGcPlEvvoJq6XybEcOx+g8LaFckpc5NOVU 1xdMIXrenexWW7L5gX2j8K34U7J2OxlRcuQ7vc6PnVVyHXgqAK1LKmX4LSsiDc9KdDmoorUQbfcN +0UOI1++3huQ3g1KBIzvv98I4WhsyQqYyukqHhOtnwQJ6SyQDje8LQGPros9h2PX5vEKobIr758w qzcGzBaIFoWOWRW9+Lf5uv+bVRFlH90v8uXrUYF0HkqFDWfU0l8OYAo/IxAAFy+GpXK677o4UNiG lVEWQrSKIsrA+jpug8hVkS9fTwJIDwslWqqWLmXDDwXTfMGbkZRzdwVO9373BKALmmktZtMAIfK4 4m1AtKKKvnYY+fL1oYF0PyjN/yKEb5BmcK+HcDrlURUTrVU46fpZKMb51dUQwtlo7sCtJuGbBp8C IKpbugplouMahMr72AARrfupIoeRLwfSk4HSz/M3P+QT+1f/Q6+WLJhUMdF1BBpVTboIUC/y5Y1A ihKJc9o+z3VTAILRC6nO/mUItWVjC0K0VkF0b1XkMPLlQHoir8F1SlnMhL9ZUUs3gUmXAooEz5zu /k4j79pd2lAUQFsQorUKot/dRxU5jHz5+kBAuj2U1tTS/M/WwUTLwmkNUPddFkC3gRC17r+cGohu l0FzEPny9UhAustr9WppC0wjnNYAdZ9l4aPLQmhNDVG494twVxA5jHz5ekQg3Q1KqpYWYKJz+J8v 4bQGqPusET4jhNbUUHAQ+fL1HIF019dcAZNccROc3nUVAJE7/nc9hKwaur1Z7TDy5euJAum+r9tC ubAFJ10ZUuGr9uM33yyBVYFjl8CnhG4EIGDqWCV0dzXkIPLl64kD6d3AZFVTGAG1cuMP8wAsCxy7 vu4VUH/1uwDFYeTL1zMA0kO8h3VAvct6dwA5iHz5eqZAel/v5bbP9z6g4SDy5euZA+kpvyeHkC9f n/jJ/1zA5CDy5esTO+mf2vt0CPny5eHRo75nh5AvXw6kR/k3OHx8+fLly5cvX758+fLly5cvX758 +fLly5cvX758+fLly5cvX758+fLly5cvX758+fLly5cvX758+fLly5cvX758+fLly5cvX758+fLl y5cvX758+fLly5cvX758+fLly5cvX758+fLly9di/f8CDAB5bVneh1w0YgAAAABJRU5ErkJggg==" transform="matrix(.24 0 0 .24 44 88)"/><path fill="#0F9D58" d="M96 96H52v44z"/></g><g clip-path="url(#b)"><image overflow="visible" opacity=".2" width="455" height="284" xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAc8AAAEkCAYAAABJ+7pqAAAACXBIWXMAAC4jAAAuIwF4pT92AAAA GXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAY/pJREFUeNrsvduPJEmW3mfH3COz qrp7+rKzFy0BCStCqyEILlbYFwICwfnT91EvhAYUCS4IAZQetDMEema6py9VmRHhR3bMjpkdMzeP iMzKysrM+k61d9w8LhkX+/l3rs7BYDAYDAaDwWAwGAwGg8FgMBgMBoPBYDAYDAaDwWAwGAwGg8Fg MBgMBoPBYDAYDAaDwWAwGAwGg8FgMBgMBoPBYDAYDAaDwWAwGAwGg8FgMBgMBoPBYDAYDAaDwWAw GAwGg8Fgn44R3gIY7Fn8xhhvJQwGeMJg+C0BqjAYfvAwGH47T8IAUxgM8ITB8HsBSGEwLAYwGH4n gCgMhkUBBsPv44M/zkPBDxCFwQBPGOxJ/ibW9/973e5jv9Ht4UEIkMJggCcM9tF+D3QWlF/pdjFJ DTG/0+08UO8DQwAUBgM8YbBH+x3QJiwjKPXKb7937vufusf+LGyfn3n4H8P2U3vVl5+x++WXiZrf /aYF6hqmd4UiIAqDAZ4w2AeGpgXmEJYKyMMhbQ9h85y2DNYtmLYgBURhMMATBvso3/203z+E7d90 wPz2b87D8u1b5969e7/f2atX7F6/vgCm/60F6f8Vtv9wZzACoDAY4AmDvSc0s8ocAfPwqoXlCJTL krbebm/lvtQBkd3V1Xpf79N2CqgRpu/GIL2fGgVEYTDAEwa7+Pt+AprhtlPAtKAcwVHsl7rJfseO TxMlSH7r0tabhasF6hZIv3TvC1EAFAYDPGH4nl+w3yXQHAGzh+U34bqvA3tuj87tj/X6XdiuzryK 8FBuby7vpgDNybk/hof5g1/DdAuk5yEKFQqDAZ4w2HuozRzT3ILmOWAKLD87VFBmSC5fOnfzZqxC LzEB5PXPAY7ft1AVoP40V5ieAukWRGtMFCoUBgM8YbA7glOU5q/PQPMcMAWW8wiU4YYlqMZ9oN7x eLff2xQAuQv398dWimagHr5PV58D6SmI/uOdVCgACoMBnrBP/Lvdqs3DrwI0/9V5aJ4E5i7BbL9v n/t1gN9VuJ3v8RfcBhC+ndrrdzuOzy1PdgqkZyH6X9jN/3RXFQqAwmCAJ+yTBWevNn8fYHi4TrcK OH/+mYbQdGG/wCR3I9m2n62B+Srsc2UU5vGY7uNHzHmjm9jPunW2yEMFIE4GoLfh8rt5ANKfAkh/ Cq9L7zOC6Js3JiZ649yfTfdRoQAoDIsM3gLYJwvOU2rz3bsBNI3KjMB0a2Cy7hvBKY97tX49AtRF qChAzFA8ps37FpTZ5ttw/Tu9EIBH8wCkLoHUqtEeoq9enVahACgMBnjC8F1ubi9u2kDPg1GbF0OT qKjMETAtLAWQu/Cc1xqHjKUpC1Xs8Pafkf+SKYA0J//cLALrCtYC0wFIsxqd+Q4QVRU6qwqFGxcG O2kT3gLYJ6M2/33Y/iqc+fHvAjh9AKevLlqB3c2NuGnJfR4I+WUA5PyLAMtvwvUBiDcBnDfhuqtw +5tw6sVNG7bjLuzz2rvjNQXYBViG55oCJGnx8ZQFqnvvFol5hn35VYD0FK4L5JLTfktpumE/ue9N uE4AHcBJHJ4zPPZVvDncFn66t+Gxjld6+408b4Ahy3OGv8tRTFSS2+nzdJ/5J4q1pW9ln3AarooH CnI6vUp/56u/du6vw+W//F04kAjP9bsL3lsYDPCEwV4oOH/tkpv2t/8LuZ8EnIcKTlGbNwE+XwWQ /Hm4/jqcLp+F636xAc0AQYl37q9aYAYiBhWaYHkMIDxceefD6dVM8ZQoXOa07xTuM4fNy/lw3Y7S 5VkgqaCcw89zlucK972dEyRdeB0i9gSmcwdSFxRkfLybDYiGy6/D3/l1uJ88x58OSW0zK0DDfjdh /++/SJD+n78FQGEwwBP2yYPz938bIBSo8NNPQX3+SFFlCjh/EU5/GdTmVQAjvwlQ/IqS2lzG0HxH Ajif3LYZmEFJisuWwukuwM4HUArgXFCgAidx2R7DvqIkI3DDY81eAKmbT5uUs+xvKcZE5X7s0unE LgE2EPMYQLoXhSrA3leQHsO+N0FN0xZEhYifpce6ekvuS04Q/YkTQOUAQmBK1wGi4T0QHgOgMBi+ 8LBP6Lv7D+H2rfimzaQVcH4d1ObyOcW45m24315AFUAicIzxzOt039tYnhJAFWB0lJTWWdy24eSY 4LUI6KS0JVxeRE3ukpoTF+zCmiQkr3zQqzZbVILa4k+Sh7zEQMOpuJWlVtRTuE7inPIYAa3y8g6S jSvB2EM4ncN1U4qPXkkMMwDU3aS4qMRE99csxwBBWWrzhR/Z/THc9qerdUbuOA6KGCgMBuUJe7Hg /HduO76Z3bSfhe0XQVEegtp890Vy0d4GKF6H6wSeEtMUNfnuKinNa4GpqNNAmOlK3a7helGAx/AE XlTnnNQnUaRehOgxqM+oBOVUXLhCL5dUpTOb3CfeLm7bQ7r9wHU/Ads0J6UqIJZ4pcA1unvl6XYp KYn2MWwaYR6VqChMjYmKvTOuXMnwFRV6DLf9tHRu3EEcVDKMf4sDchgM8IS9JHBSAWes3xRw7tfx zeKmzbHNLwM0WUo2qov2IK7RzxKodssamryICzZsQq8pXE+iAw0sOblueUow5UCjRZKEwulhSW5c H/abI1jD9WHbs7prBW5eni/FSoVkAt8I6Qam4fycVK0Ud8q/2a8hGlXnqxQr3e2rK/dWVPEreexw Xfjbv+rcuDYO6gJAv2kASgAoDPCEwV4COHNGrU0M+uGHdXxT3LT0eYDYNwGqAT63i1GbGtf0lKAZ Y5pTUosZmgdVmXNUkAl8Puw3RWlIEaICS0n7ETjSkgDIkWxZZYrfNQEyg1KuE/VJEchJgU7HpFgF uke5rwJ14pTJK+pSYqgSCxXgJTVaISpcpUNyK8v/jiYeWlToVeqUJMlHb96lx+njoBJnzYlEf3NR HBQAhQGeMNizAOev3ToxyJahZHDevKpuWolrfiGBw1tVm69TxuscS0zCZVWW3kBTXLPynKIwYwat KMoAygMnUArsWFSngFEgGTGabqMIUz1PKW4qQIyXj+l2cQWnjFuFZoYrC4xTAtHBpftNU3otolij C7eDqNz3EODnw98oQBUvc8zcPSYV+nnkf3gv5urG/fy2AjSXs8TSljsnEgGgMMATBns24DyVGBTB +Yvqpn19SC5ZAYoP8NiJK/fWx+xZf51KSMRd6qO6U2hyyvghhWYEnmYBieoUKE7Ox0xbuZ0nhWws QElqNWb8cNonbpyui/tRUqHi5hX4Oa0ZnUS9UgJyVJ8uvTYBrLy+HqLx3Ql/v4wzE8ko7mI5SNix qlB5D6StH6cDjOzGJQNQ6RgogrqpBwVAYTDAE/ZywTlMDPpFzaaVbdkFcKqbVlSdqE2v5SPZResi rHxUmitoChzlunA6KQDlcoSjq+UqC2kiUb5NQbna4j4JkBLfpKMiNytZrzWgrK5gn1y4I4jGx1lS +Ut25Yofl7MKDQDdS59b48bdG4CeTCQCQGGAJwz2MsFZugVpYtDPn7Xxzd5NexDXqCQESVKPxDoD DKdJkoB8AZ9AU+KgxFNyyepti1dYist2See9gSiH/eX6iD7dN0PUbhGSWhMqj+01BhqTjjRpSB7F gpQzOJfUSCEmGhmITlOtG92JW/cq9VuYl7UbV0zioFKCI6uDJBItpisRAAqDAZ6wFwxOcdPGbkGf h0U/JwaFhf9aetJqfNO6afeU3KsS29wfUmJP7AqkcU2BYzzPoiKnAseY+LMEMB4NMF0FaAGly0p0 SgCdxsrTKXzZmQQiSiqYVU3GLNuYzERR2UbukjZVoNQEwXECqqjSuI8oynD94WhjoeH6zo0bASre XXkOTSR6Hfb/+t0gExcAhQGeMNjLAmfJqP0yqaacGEQGnNZNG5OAlpQh61VtymmOTUpMMynNKQIx dhASaKqrVfbhZWoUpYBWIpOuAFTByelxInBz7POQr8/ZuhWctKTrY2JRhuSi0JxS6QotFaLxMXx6 tni/KXWbzyrURaDK7E+3cuMKQK+6RKL5TbiO15m4ACgM8ITBXhg4Y8cgAWdQltNbTQwKwLx9XeOb Kzet8yu1mRVkguKU1KaAUqScqs6U5CP3n0rcMiYOOVWTfopu25Q0NNXHE4Cyun7Z69+u96EE0egu zo0UTExTzk/5vKhQn94fmRtKmoEbwajt/SJMjQrddONqOYscS8y3NZGI3qT7A6AwGOAJ+5TAKWUW 1ykumOObMQv2WN20pBmzNKXOQaQKMGXCThFm8pthhWYGagKfqlC936LDOsVNK1AVuE5OgZsfYyPm GSHpFKCscVRKm7hOnSYLkfPlvHNZceZ+uOk9iyeeFNmxHVFqssDptuzGlWYL7GocdK8xz90+JQ0B oDAY4An7hMAZM2qvUmKQtLybpSzFJVUpl31sOpDctLHUhFJCUFWbWoayqAs2KkNVmDF+WSHK6taN CpUUvuUxEkwLgF0bC222nKlLvnYTIoVcfkxPRZGWfz5dylNX5NRPrqpQTr13WRWrAFbKbyJ7pV+v 1568S2LyQToiHFMmruwLgMJggCfsBYKzND9YKjglvim9ad0+AOwmJQZJDHDS+Ka4RY9MqvpIFaC6 U1VtsktAnLyCc0mxS6fqMmXj5P0SZElhGdWnz5BNoGWNffrs2tXNuVwnqpepxkSJKlQT7bQMhrK7 VwHKmp0bvbm5lV+rQutV6broCtY4qHipcyKRvC8RmJpIlAE6aqYAgMIATxjsuYLTND/I4JTG5rEd nbgfJZ45p3hnAmdqvxdrNMmAzGS+ZhCSQo8zEGnSms0MT1WjTsHrEjAtSFnh6d1UYcn58QxEjfIs CUbaO5e1Z25ptuDVhatAZW04z1aXGhUaE5A4AXFyen5JcdACUImJcupKFBXo7GIs1QK0b6YAgMIA TxjsmYLTNj+w4BRX7awZtaWkZNK+taazT3ankqtQ9CUOOalrVjfWeGY+pQrMokZd3ZgUpFwzctlr Jq5COAOVVMGWeKsFam6YoElDMXlJ46CL1n9mmMYpLRoSZc3UTe7brFPVFJo5kUhgez3rp3PQZGAD ULE9AAoDPGGwlwdOKUW5WtJYsThsek4ZtbUpewKSNHXP7lE2LtUMraw2MxRT4z1Vk3YzqjRJvApR lrEmbFy95BWmvqjT+FxkMnGp7tu09DMKkxSgFpZkR5wZFRrfVR21yea9jyWhArxZ78bptpyJ6xSg 1z5NZzkCoDAY4Al7ueAU1+yyT3WNUl5y22TUUkoOMolB3rhJWRWlz6rRTynhJ8JtLiBlc0oWsI3q nNXtO2kyUVaZNQZaa0CnGtfMbuB82VED0gzJAlHXgZOSiza2BeR028I5+UgfkZN7Nsc+83JArmbi yoFHFKxdLSgACgM8YbAXCM7DnlLJSYDk/phrJNUV2rTN0xISPV9a6vkEz6o6Z63tTHBkudxBs1Gf MQ46N8q0OW/inSWxyKjNPvM2lctQaaLQA5MNNG3pSn5fPeUmC+nmZamglLPxZVH9HEhVqew35yYL ACgMBnjCPh1w5mYDeeqJwGh2vjQ3iNf7DMXsnlUFGjNlZwPIubpsOxVKBrQNLHlu4Jrdt7nUxbpu bTZuBShV9bmhOovaNNAs+8WG8BmIej9tKl+OJVSNLlofmj8qAaBcB4DCYIAn7FMBZ26E4Ki2yJPu QtSWhixcLy+cYpakylIokTJmZ4XfXN2uNFCfWW1GgM7Oum+dq67g7MJljY+S8+W6pgtRjnfay6pC G4hSG+PM/5z2uY3vchxpVoEmtqhQzRUsPvWWLwCNwJ0pNjGaHQAKgwGesJcPTp+GThcXbcRSBabn Gm/0XLNifc6K9VmFzlqrmRWlAnUFxwxWC85+H1WdviYgleYLvo2BtuDMqtMqUU2AcrlUhYzepJoA lMtXczJQLlfJLf9cin8eNaEoxkJzNm5+mCm5dwFQGAzwhL10cB4TZOamEYG2y8tuVE79auW6ZVWb qVmylIE5V8XJBoxCED9VZermAlYL2D4+amOktelC2zTBmfO5Y1GJeVJVob0CjZezvMylKTmQqQlB uZSFS7u/qlotwhcFKgAKgwGesBcGzjzd5DCtwWndnqyZtcyaIDSlcpHsrvU5runnmigk52O5iXXh VhWaoVngylNRoNwoz27Lj1eSjLZb9pGWp8TYZSlXMV2RFHlkQOq0zy2xSSTS8zkOWnrLawKRV08v mc0PAOpZG84fAVAY4AmDPWNwkjvOGtvcJ+DsjLuWB+DMbfNiYhAZZUhVeUZQ0lwUpVN41iSirDSt 63Y21w9cu6YExtaKtnpv6sDZZd86U/9pY5xkazvN9SYJKBtr04Tkns3N5CtA7ScpzxLdusfUXD4O cslTWwBQGOAJgz1PcPqZYu/ZZZ9gsvNrcJKO/+IcX9RaztoxqMIyqkJO57PSzEqyJhLNCtLqwq3x zrmDZXbx1uQjcuts26RcTZOEDRVqM2/zdJUKTV/ioAWcenspY1lyElGFYGxoxK4Alan9RCXhNmbj LqmBQnYDA6AwwBMGe6bgjLHOM+Bk7xuFSTme6W2tZddaT2FKrt2iGjXqtFGeClkyypNLvLSr7XR9 w4SpSXBaNY3vEoWctupjbQDh7ZQVqgq0fDQWiDnL1mTkOm3lF0UubwNUhnHPpSsRAAoDPGGwZwnO 232CSA/ORQdNT5NNyNFsWm2dtzhVmmSUJtfs2bUbtp4vJS2dymz309hpX9JiYqaOt8HJXeKQc7bu k4wS7ZomkKUlFVpmoLJRo/EaE+wsyUSLxkCpBajAcQFAYYAnDPaSwZmyWnmxSUGmJy13qpMNTLOK zOc5xzR3nUt23lSevCpradVugaZv45zUqU3uXLbrtJ7al5a0lRAzmZjmOPaZuw7l83G3JUFNxpUB oDAY4An7JMEpDeDTBBNvs2G1oxCXbkAKO55MPLPbaFdjo25elaaMFKrbzLjtrx9l2rZAbaHpV4lB xDnW2aYLuaJIc7MEWrlvE3krQBkAhcEATxjAGcG52GxaTRqiORW15BgmV/i16nNnMm93jeuWOtdt G/PcgCcP1OdmgpCp77QxT9Our3QFyqrTuTp4jE3eLZnK0dwwwahPABQGAzxhnyg4vZ90eHTXNSiD M05Oyck/Na5JCs9adpLds3pK6Toeqsv5bsrT92PN/Mlt22XbNknIsGzinXqa4Vkkp16b3bsWoOlh at2Kz/NAAVAYDPCEvVxwLgrLmIPKXaN2Ns3bFaCllpO72GXjvt1pYlGrPG2cc5VtyyYx6OQ2gCZT GUtmlaftX1uctCXxx7Toc67GPV0PTefaGGgbE6WiQFMNaHLvAqAwGOAJe/HgJK3fjPFMr2BkU4YS R411KpHmokp9Vp1NkpC5zHOjWm3v26JCadpWn2fgSWSzbdtuQs7UcOpIlWYMWVagvojJVMvZ16uQ s5IzA1UTjGwJCwAKgwGesJcBToFmbPLutsBpO/jYOKNRmwq3nElLJda5M1C1AN2Zes+dWzdDaMtU eNN16w3ITzVFaEeSrTJsiZqW8BacDSR9hWiOa1p37joNtyrQLYAuXMUsAAoDPGGwZwXO6Tw4aT39 hE0rvaw0cwMEMvHNCsvdQIWO4pzGTZtVLaeaUmpGkk1mMHcdU1ZctJzHoWRIrmd6rjfXJAfZeWNF k3Iddk0m0EnUum6tGN0GKOkIMwAUBnjCYM8MnP48ODnFOtm1TQ9ybNI3IJSEoF2JdVqIuqEbt3X5 DpOIyAzKZlWYtN1hqLpo+81CdAxOtwFN5lq44vTRijvXKNRGi54FqANAYYAnDPbiwWndtAo2P4Bd iXVatakQTUlAO+PiHbluu5IUmzDUZNcacNKgXIVtp6C1+zYnCTlXJ6aUydYFpmnzg0+Vshu3+ZQB UBgM8IQBnBeAk0+WmcwdRBWWvNtQml2LPjJQ5R6cfTME2xi+qs+t1nxt0pAhHdPqs6PBp5ljpWw/ bQJAYTDAEwZwboCTejetVZrN1kG0qfXcde7arcxaWxpT1WY7+Dor0M5N6zaUp1GkTK6r8Rxhc10X 6gapQgAoDAZ4wgDOBm68oS5PNTywECUDUOpKVU634rPu2+3M2qo+T8U2/Up1kilVoZNac/sTXgPU PhIACoMBnrBPC5xu1lFkfcu8S7sDGWjazkNk4TpSnQOYDl225xKDzqjQ4q5t8Uf3wId9FO4eBQCF wQBPGMA53ri6axtX7gqU8yDj1kxP4Xk1u/P94EkaC6VxmcqoQUJx4VLpSNR3EToLUAJAYTDAE/ZJ g7NPDBpDc0uBtgAlG+8cuWzPgnO6AJyd2qRt1y2NGh0wnfhkT0MUAIXBAE8YwLkJTubdBgQ3Yp99 fJMvSRbqoTnKsqUxRN2Jms6+PZ/9HJku/txTQ3kAFAYDPGEA5zlwcnbL9s0MAiD9TmOatZZzc8rK RZm2Xl26uXbTb7Tj612z5wA6UqXt50nl7mTmjq1LWIpblwBQGAzwhAGcm+DsoTgrNM+oTRr0saUz cc5eeZKp57TwJG9odwacua6zgWeHu3J2RMQRQB0ACoMBnjCAcwzOpqtQgebutLt22H7PxjZrHekY mgOlSd12Eph9/NO1kGwwR5uQbD/itoGtt98LABQGAzxhAKcFZ9P5hy6Nd84dIMddhU6qTvYb/WoH cU4eZNueinuOrj8Hz8a321eFAqAwGOAJAzg7cDLt7gHOOrOTNVmoTGvh/BpOzOmM+9IF8Mzg3IKj JvlwBRxzN5qM2sHXlwGUAFAAFAZ4wgDOU+C8EJi8zqolndPZuGlPgnPQ8P2S7FraVpjUxTkjlFzu U5vjoiPX7rmvBgAKgMIATxjAacEZ4Md+A5y5ztOqUe5csia+SVst+DYThdaQtI0L0vk7ZNe6dXat nZDSgm8QG+WNOk919QKgACgM8IQBnAmcIzdt3xyBToFz0EnozuCso8bIJAvRKs55x/imswAbJBU1 AKU1BmntxgVAAVAY4Alwfkrg5K6R+0lwnuhre2nD960mCHSiGcIIks11vgUfjQDqhhAd4m3Q5H21 7yUA7fYDQGGAJwzgfDHgnN8DnH1D9zU06SRAvdue1dnFNumy1ntrTLlNkNLJ74DNqr0vQB0ACoMB ngAnwNmCkzfBmfc7pzinM+C8T1zzlNu2vY06RAKgACgM8IQBnB8BnK3LluJ+owbvI0ieAKe24Wta 5vGWe3bLNTt23dKJ2wBQABQGeMIAzvcG5+lmB7M739z9guSgTZftVteg85m123Ckje8BnTkFQAFQ GOAJcAKcdwLn5C7vFnRurNjktodXr5u9Uz9n8xzQhrFPdwawp5QqAAqAwgBPgBPgfC9wTu7cZJRh MhBPg960Z5TnycSgOyhQpq6L0KUAdQAoAAoDPGEA52ODM7fl83foHnTJmLER1E5k3pJ2EqJzrl0A FACFAZ4wgPPBwXlJLWcHUOrnc/oTLttLs2vdGfdtt2/ub0unXLOXunkBUAAUBngCnADnncB5SZeg qQVnnsc5Sv4ZQrRLGBptlzQ8WIFqazTZORA7ABQAhQGeACfA+YHBSX4NzpUrdstNe5+aTnfGjTuA X3MRAAVAYYAnDOD82OBk3566c67a+wL0EuANFKZCozkFQAFQGOAJAzg/jqu2g2RRnvdVlg8FzwH4 MjhPghEABUBhgCfACXA+Cjg3+tMO45zngJqhcireeS72SXcEHwAKgMIAT4AT4Hx0cNIJcJ4Dpvns CiwNPZzJmKW+Rd85IBIACoDCAE8YwPmcwHmJyuwnp6QFf91byFzKEL0YYufcvQAoAAoDPAFOgPPJ gPOSCSiuUZJ0wYQU2rjvRRADQAFQGOAJAzifZozz7klCdHIu51hF0p0bGZwC4zkXLwAKgMIAT4AT 4HwQcJK7+xzOU27UU233tm6/K8AueU4AFACFAZ4AJ8D5wcF5x3pNombRPw2wbeVp70sn3bjnvj8A KAAKAzwBToDzyYLTnQDnAJrcQ9dtKs8yuJoAUAAUBnjCAM6XBM6LWu25qk5Xu5+r37yr+xYABUBh gCfACXA+C3CeAZap8RxGO4cQvUstJwAKgMIAT4AT4Hwp4BxAc/QNWEMUAAVAYYAnDOD8JMA5aMPX w4A3SlpW4zkveS4AFACFAZ4AJ8D57MG5BsEamqe+D9R08GunozgHgAKgMMAT4AQ4PzFwXv7dAEAB UBjgCQM4PzlwlmvOqs3TKrQ8FgAKgMIAT4AT4Px0wPn+3xcCQAFQGOAJcAKcLxKc1IKTmR70e9MA lABQABQGeAKcAOdLAKe7Kzi3+tpeAFAHgAKgMMAT4AQ4PylwXlTpCYACoFg2AU+AE+AEOO+iMM99 ZwBQABQGeAKcAOcnAs6H/e4AoAAoDPAEOAFOgBMABUABUMATBnACnA+16AGgACgACngCnAAnwAmA AqAAKOAJAzgBzsdZ5ABQABQABTwBToAT4ARAAVAAFPAEOAFOgPNxFjUAFAAFQAFPgBPgBDgBUAAU AAU8AU6AE+AEQAFQABTwhAGcACc/1cULAAVAAVDAE+AEOAFOABQABUABT4AT4AQ4AVAAFAAFPGEA J8D5ZBcpABQABUABT4AT4AQ4AVAAFAAFPAFOgBPgBEABUAAU8AQ4AU6AEwAFQAFQwBMGcAKcL2kR AkABUAAU8AQ4AU6AEwAFQAFQwBPgBDgBTgAUAAVAAU+AE+AEOAFQABQABTwBToAT4Px0vtsAKAAK AzwBToAT4ARAAVAAFPAEOAFOgBMABUABUMAT4AQ4AU4AFAAFQAFPgBPgBDgBUAAUAAU8AU6AE+AE QAFQABQGeAKcACcWDQAUAMVvAfAEOAFOgBMABUABUMAT4AQ4AU4AFAAFQAFPgBPgBDgBUAAUAAU8 AU6AE+AEQAFQABTwBDgBToATBoACoPjNAJ4AJ8CJRQAABUABUMAT4AQ4AU4AFAAFQAFPgBPgBDgB UAAUAAU8AU6AE+AEQAFQABTwBDgBToATBoACoPhtfQLwBDgBTvy4AVAAFAAFPAFOgBPgBEABUAAU 8AQ4AU6AEwAFQAFQwBPgBDgBTgAUAAVAAU+AE+AEOGEAKAAKgL5QeAKcACfACYACoAAo4AlwApwA JwAKgAKggCfACXACnAAoAAqAAp4AJ8AJcMIAUAAUAJ1ezI8S4AQ4YQAoAAqAAp4AJ8AJcAKgACgA CngCnAAnwAmAAqAAKOAJcAKcACcMAAVAP0WATs/2RwdwApwwABQABUABT4AT4AQ4AVAAFAAFPAFO gBPghAGgAOiL/G1Pz+rH9djgzBvACXDCAFAAFAB9ovB8euAUxUmiOv0EcAKcMAAUAAVAnxo8AU6A E+AEQAFQABTwfKAf0sOCk8K3xU/eHeRbE2B5BDgBThgACoACoM8Tnttv3D+E2/79Q4IzQPLgEzh5 nwABcAKcMAAUAAVAnxk8T4Pz310AzuXzAM3wId0cz4NzH749LLD8GOCM2w7gBDhhACgA+vzXgulJ /mAyOL/6e+e++zfkfvbb4Lz5Mnwox/CBv7sMnHSUr5l/fHAywAlwwgBQAPSFAHR6kj+U/zX8/1cB nN/+XYBn+CB/+qmC8zaA83UA57WC8+2B3PS2gvMmgJPCfdwGOAUSM43BOU0JLi8XnBaaACcMAD29 7xMBKK2f4aEAGu9P9XEB0CcNz/OZtf82/O/HAM7fBwD+8EMLzi8COL8I4DxsgNOHD30K95syOAMw BZCkkJjdNjit4vTxPlOE3YOB0yk46X3AeQqel4KTBqcAJwwAPa9ILwGou8NruASg9AEBGv8DQJ8+ PC8oSQn/Oyg4D5IMFMC4Dx/QIYDys/ChfBVOOXwQb+cEztfhsnwiN9cUleUc7jf34Iy/uDU4UwME A85lislE0hShKs55DM5wHdP8QcBJK2gCnDAA9HEAeu6+lwB0+3lpa38a/J2PAlA6C1ABpTjzZn3C 5QCAPiF4mpKU/zGA88sETolzvnsXwHjj3Jtw+qWA87Nw/WtyVwGMn4VtuQqKVD6NfUDebQLnHD7l /dHHb4OUpjiNby5RTVZwphinj0AcgTOCcQOcFnT0QcE5XeCufS7gBDxhD7OOPC+A1st0KUDp6QCU IznT7bO+BgD0UeF5YS3n/xTAOUgQ+iaA8vAmXP8ZudvwQezChyeJQaI4vbhvb7UMZRbXgoJToGni m5NRngJOVnCyuG79FPdwS41xpm9MAlSBo17PDezWUGQL1uj63V0MTn4fcJKNafr3AyfR6YUE4IR9 FPV5DqADyNFDALQF2+UApfcGqHMKt0sASva5zgM0Ve+FdXMZA3SRKxWgy4UAnT8PazKL6DkPULnb b5/fF3R6Aj8EcoGZ7pdnSlJuX0uCULg97H8V3u1duP5WOgVJfODGu1s5neWIx+sPy8duQgJK+cQm 8gqm5KqNEF2muB9FldmBkys4CzRpPg/OePuu3jYCpylbqeCcOtfvOXD69Xn5G7keMFSQ9sD059Um 0dB5VME5ckIBnrBHxCt13yoaq8TCEqI7fhcH8KVCsQvV7SmADvY/EX6lMwBds/0EQCWCKfBU1Uln AMoKXZ7oYoBSEDtTAOY5gP5NBCidAOiTXDceA56XJQi9O1GSYpsgXIXrZIslKbuAqKBI9wKJKZWn JBj6eDhFqjxrdm1KBBKlmdVmyajldUatG7hpz4KTd+1tF7lrp871eyk4e4D6ClD3AODkh3TXAqCw uxhf7L497Vo1Su9igJ5y0RqKXbLvGYAOH4O2X08BKF3wK+sBysaZRAmGpEsCL1QAGl243Z8rVy8n ACrewtuwVHkFqCja2wsAevUvyP15uN9f/u7ZAfRjwrONc373zXZJyskmCALJybtJ6zedgjN2EaLk qiWNd3p10a7ASRvgVLXJBZwJcn6gHKuCNNdvqU4y22Z27VaCkN8+PQvOU/A0x8NUwcknwLm9ADyU aw4GYF6mPsdXUKM+q2J7DwW6ebf3KWUZ/BQ33cQZoDQE6GkFWt+ioiwVoPJzLwDN2bU9QJ0BaNh3 CRckxyRy+ZCWnsMJgMq6/qOUxxiAuuuw/bVzYfl/bgD90PC8W5yzz6z9IpwewtHJu3mjCYK4GQI4 6ZDAKQ3faanK0i0prkkK0AwZAadAMpajBEAuAWJLBOtUVGAT29Tz1CjOGtfcVJQj1XmqJIUzUEfg 9KcB2oCT7gBPt3H5zJE03Ud1wmAPv8Y0sU++FGr0Hgvzlr+YLlSjtHb90j1WVrpQN5dj4g2FaxRp BBtRUab2p32091YAyp+xm/VKyUORZTCs2buwzEh47bhUgF7J/u9cXMOlpF7WeXm+o6TxKkB/GwD6 /zyPBKLpg36pT90mcc5fdR2Ecmbtl3tyf5YThExmLV+nBCE+ahMEiXlqKUpMDjoqOE1i0MRJgUo9 pwCTckatwFLA6acKLpfUJ1Gt4bRxTptZywpQOhHHPAtP7tQmjd20tKU8eZQgdElikB9Dk2wqw4lM Q3oI1QmDPdBKQxdSxX63NxOIaEMBn4Ev0zAOShfRjy5ZMjcPYkcK3pdz1CjOVemMBaj5s60KNflF SXnqBa/3XSSB0wBUnny5TrUJr44JsDeSbxRg+vpniglIN1oEMU2plvRGHvBPgaH/37PJwP0Y8Gwb IfQdhEYJQvKm58zaKTZB0LFiARzx6CW6ZdOpzzFPSuedtttzOtBaQCSNEBZK8HRFcc5teQrZOOY6 xkm9i/Y+8FypzfkCaNr45mQShO7bco86NXlmkaB1ihARAAr7WODkteA8EzOkLXjda22zKnJT+w2e gdb3J3rvZZY3vL/5N9ok0Gd39igT19c3NQPUhxul8q8cJ+j9WQG65KShY1qSDldptXp1SLffzGmF +8U+3ftn40IWJXrz+i4lLC8Wnner57Tu2uvbNs4pyUGzyazdhTd+L/HMqZakkMY3Z4Vm3ljVmcDU c4p3invWbalNPV3VWsZGCS0caRj3vBCeGlfNzzmKddIldZzxb3vYOs4cT9n8LGm8DBABorDHhWb+ KvId1yY662K9dF0zWaxMJ+OgdEaF5oSerd9YvI3Pv6TNVCXq3LfmvVuUuDYOGk99cuMWgKraLH+u eTzO6ntOJ1dLOpV13Yc1XXrZ7Hfhf6/D5eUhakA/+jrz+PAs7tq/JffzYe2u/eooCnMQ59TM2pwg 5I8ms5aS6zYOutZyFNY4p/dJnS3OJAZpIwQiE9+kVC5Cbktlal9addWO4MmdGze6elnds3Yr9Z+X JgeNGiD4zmV7z+Qgc55OHDmvLm8kK2SIjjaAFXYfQI6/SxvQ5MtWp7OhCXfuwc+5XO/Y49b+Ai0o Nfa4+Xet4MnDXZryE/0tck4Uyg8fnoi9lq20bqWaSEQa+zyqq3eqhwdxH07OsOjKXZJOkCoJ8R7K 7Zc0UcgZuH/1u3M1oB91PZkfXXXK9m2Q8z+4jbKUcGRy+4bc8ZiSgvxrhede45y7lP7DmiAk73h2 2U5a0ykfhJdYZ4DsUZNoYtmKJhGVWk512wpEpebTxiDZ1eYIZDJjbSu+nH1bIEv2MTbKWWjd6IDK c/Xxyw6Wm80PLlGWW1MjqAnz8NkvZN5xvWicXbeIQQTYxcb32pkv2JUqZLKManyvPFjL2J0uQfEn XhQPJCTr7z7fyvpw3N6NT//Ja1jy+tUSN89bXzonZZmzazkdrCxGgUbFGYgo9Z+Lrg6iHI/6ciXL Nu4n0VDxBob1dVqWuAwepDfukty3Egrd3aTH3V8HmfFNWLf/5NzXP6YX8CdXX8j8RRoK8stw6Yvf WPxv8eajrCvzoz7bV06za/8quWsFkJLuHLO2dMTY8RfJhXt1m45Wbn3Sd3GU2JQShCSdOdZ1Hkwj hLAdFaCp5Z6CMnYT0pKUoj61YYKp76wNESbXNy+Q+3IpMZka9bjqQVviqAaeNK3UZYXzqekoPUDp HpvbgObWV5E7gPLGfdic0BPypsA+PbLyXXYeqrMxFPmMKBjlB4wS88avg1e/uw6iClLeUOU9Xdlc rmqTV39vA12yh8xsn7YcU/hcC5pb+EmizzGJT896KCLlf0fJtl1S9v2Sko4OYQ2fd2uAvgtApi+l UiXcNwCUd8ICjkw4HNj9Xl7RFUex9V3YfvPxIPlYbtvzSULvNrJrT7lrd8cuzpk7CGm3IFK4xM5B JkEoxjpV2XlKsU5S92yMF2bAlZhnUpn5fOuiVTdtd9tmx6BhLec6vknNdX4N0JxRe3FW7R1ctTlO s+oW9GTjDDDYe2vXYW4Pb2Wu0p0ee3gguepIdCmkafOYmIZ6eu3pISM8met5MpCkwePmDkQZmhGi +eUtuXFCutLrYxy1kUJsoiCuWq5NFCSZaNESltdHVzJwKcD185v3TSD6KOvS4ynPqDrVXRtd5p3q 3A/ctctVctXKUGs/UVreJXFI4p7irp2Sy9Yz1RIVThNUSGs9F0o50cU1ypp56yajCGejPscqsva5 nc2kldHUk94Vu6Usz6nMHNdUyN0pc3bk2Ri12OPmfIw7mKPS9c+RAVPYs3X0UqPSXBtGsA1f+4Aj n1uwNxQo+9p93RSPrN240+By67ulwb3WruCqNuN9uCpX0n2SX4mLSs37FDVLesr6mpaqQhN8ta1f JLBvjjvkHqIuSRZ2UZ3h5GqmeN0kiUMTu9twnd+n+xzD+n37JlwOSvPrd27lvn0tTPjfyP3yFbuv fnOJcHtUZfqQyvMC1XkiSWgvY8V2KbtW+tbuwxs7CShv0zBrcdlKnrQ0PZiOphEC20YIaTLKYl20 1mVrGiAwjTv99GqyTxRqmiE09++ThwbzOHnqmiCMMmtt7aZpgPCQinN0SuOj480enDDYMzDaiuIT b/CW77i+ndmfun0H3YLusrbymfuQ/bvYlSDMKuOBNl5LAWl9n7LijNm36qGaJte4lOXxFl9VfFaj ssNxSnHUq40EotxEfrMD0cX1n8/WbXs6w/aX2oJPDkqkNEVqO3MLvimozNsvgurkNI9TkoLeTWk+ Z2z2Pvs45JrMhJQtdy1xBZKc95RLUdQ1q67bnPlKJgO2cdv2WbXm+tJZiFtXbg9j6oE5rOfsXLV8 ajrKPWo5N4q31y4mWodtNqrTLtO/gC3sw8HwHv4X7UU3ANo5EG66dE9BlLfFEfOJutDuvjz4mZ7a igjl9tHN3059j4im7KRCVIDobRu/fpyZeeyYZHRUl27SMEmhCgQ5LX1xpNmy0URe8lx+Tvo4dyAq DRSepvt2erCv9F1V535fW/Atr1vVKW/eHIA57VNt55S7CJWm70ltevLqFk0KNAJSgMmme5BA1Wt7 PY1zOo11Eq07/sQ4KFcgUlPbaSBq1CbzuiSFDDC5TE2ZmvMNQKk7vfNYMW/nEXVBjBagfDK+SZdR EnCEPUm68mmi8mnYtck03an9jXAn1S50Hd9tjc+1rLz2+BKtvba8zrStCtM85lCxdsuEANHldn1a wuJqfLO08vPpNfpjqheN0qZ0TqDYri+XsMgDLvuN+Kc2UJCZzWJN/NOUr/wutu97EvbhY55bsU6x Hafh1vvPtB3UklrwxSMOKVuZUgu+2LvWp23RakypIzr6pD/l37L4uGW45rin07Z8KZlaFSn1ZSFd nDJn4SqEa4Zt6/7NHYro5JzNqSjk9nwHxNwpiM+VnRgIxqPD/lC6T7k3afjarJIcb8QJqP2hnvzl M/gJe1rG7k4lKyPwUe/W3Sw3cd1vkU0tc/e729y8W9el2G3S2KT6SGlybTpsG8csmbaj0pTusuxT 4p72lPIjcp1DFsc1Zohy+luXeiieCj+DLIjrsy9LwyHsFPNRFh11NqcuRNdBdoort4l/StvVPxMX bXj8H8Nt3fsYy1eu3AXZt48W+/yQylNVZ9je/VVQnV8OYp0SVH61Vp2TDIhT1elzEwRPpSHCkuOb AkTvC+j8pLFPrpCknNzjjRq09Zl6O52aesJzqzhpNMNzq3xlqwFCbq3XJg3ROcVJ7WVapcpdGN8c KM5z8RTQEvb8aLp9C432oREkBwAd1CwXlUhb0N36FfGZYOb6sTLorMu1dUnz+m/NCUH55WuyUJuB y6WrEHku8VFaKV9t2eeSVslTWKKr16fMWzIxUMoj0HbaiOg4jn/m7Fu5r4inkfv2T9+eU5+Psk49 hPKkk6rzq0DQn//WxTSsUYbtSHVOnepkZzJtOalMJ7FQCUwvubsQpebvrrbnyxm3lFWo8232K3cZ sbSu+cwN5MlVSFtXa1KxZiaoq0BkM82FGzBSBSG3334+pzhPtlXZUJzNqasFXJ1gpYsWI7qLgwoG ezyP7R3cpzSC4CBeeBKgW10M+LQC5WFeQq9GWwVaTjkpUC60m2otSd5EFrqqUlNGbZwjVq4rqpOq 6myV6BT9sPF8zNvgCNOoOgWwS3r++C+qbh9LV6Tu/hBdjPXtjZ3HZ1rVfy7XYfsste+jyAdXsm// 7F1SpX+i3EDepezbz0SU8VOo/fzwbttvjctW7PZWVGfYOCUFpQHX6ehjf+2S9A+qc/ZpkefY09ZF cEZXLfuoSCNsY2ZtGkOWmiGo+9NTcYOSNkRYOpcpN6rPuFkXA0CqY8ra2GS9zNy3yxupSIV/+ZFY gG67acvU+OFBCpuwx6BejE6tITwAMbvLxiPZo18oUdjzUJrj3fiCbNsu7sljiNKwh14FZ209Mira zMD05nfYQ9R3rluFJnNZu9JzaEqrG7h0aTHuXQ1CKmR5CNQpgTLGP9Pzxb9EISoNEvySbo8x0ihk gpTQrm+knrFjLic84b6V9V+WUmHATkoQD/qqTPMEueaHfxF48ZNzv/6n9Mr/w8nDow8K1g8FT23F J6rzX6ZuQuKyFXdtVp3ui7D9Ily+TSCUuk6Z68bhTZwkL0dmdd5SSY+OWVtLOpU3X85LQHqKSUMp U7cozny6VMVZY45Gbeb9ymSVzo3KNvt1Ksk8NKrf5Jq4lB6TmtFoZVD3CKAjYhHd4bMfJTTwGYiy G2f5vc/zwmDPGbSjDNkemr3ivMNvgKh7nK02mhWi4l1j6mFaYUtZhcZV0DeK0zWx0GV1W1KoRnVy VakxJqpKMt+PeGqUrPw7+nQ+rnKyvC0p0UhUqldwkvEcxr9UPI07mfWpCjQIrKtw38+FE2F7dx2e IyjSr96F/YK6GqnPX4bn++JxIPmh4HnGZRv+97P8hX9sE4UEgNKl6d1xow1ffrMnhajT/rWiQhWg Ry1lWbSBQJznyVQHQivEcvs+MiBzFqgN9GrrvtYF64vbloc9aE0cUr/obODYqE5a/2BKTdNJJceX fRTcgZE3YEmnFOijxw9gsI+nSvuMVjdSpnyBEh1tp5VRm/TXuXCZFF69WqzwZNZmBSaZyLpgV+As atUoVOO6zYlEGab5MTzXpKWSbDRw3y6U1KcIlyNxUZ/eJbFzu6QVcRf2FXjG2OeO18lDgqYjpyV9 oD6/DerT/dNH/UJ9WLfttz8798MPA5etgJNNNyFOEJRJKclXnhZ0UldtybAVcE4m1umTK+DImjhD ubjIx31a1dkBtMQ3zeU85qu4Y1OLP6aplMSQ82t4coUykR//EGgQxzyVJMB9QsMgQHmqRK2Mgd9o eL1aFLYmDg76cUJwwp6y0cluzOtr7+K6LawcxEKJO2XpnO0QVB+2FkqenPNJp2KiClFSJVrct51A oF6NLqvruADZl4lUSdX64mmLbllOIzmYTc++adFBHKTetbTuLPpaU/knJ/XsqciJ5ZgAKS5gGTN5 mJLL9o28vADNd+H8OfV5Pvb5QVXph5mqkqen/Hw87bJ1t3qXN9LGKdwzXL6RqSk+KVAWuJKWosyp LZ8c6AhEo2PUpw9kii5cb9wbdKHqVBiy6eRDNh66vg9vTDWh/GXvgckDtXmnomuqP9ahWtxIDjIK lB23ypZ5S7JedqxOUKOwp60y+R73WTtb2PQzOKFCnVWh3F6mDVcvbazzo4YmQ2VqIBrXq6U2VtH1 q8RAm3afHUg5C4Z16Up2zVYXsY8Fm0mUmPvHxrdJeabMWvEEchQ2In7imhnvlzoJHTh5E7P6XI6p gOEgMdAL1af72wDWcL/zbfuemfLcyrI95bKVVyJv9k57QdVEoZQktiwq/zWJaNGYZx56HUG6+Dw0 R0tWWujZhKGsVLnEKHUfHkA2q9pGbZqes025yJbidOqG2ZryvhVHYTOLj924ptOclrhKhSI1MD0P zYuWGgZAYU9QdL732DsecJQHXh8+AVIu+7U1mIO6y4FTiLQ93Qqkuq6U6gNz0B4VIy9mjVv0d18T gjJIq5jIrthl5aFbqc+c+xFjml7joj7FRU3yUHYBx7p7ec5cIUFJ/MQMXqZGfS6iPmW02RXFFn9v DqmP281nKQvXqk9RnWLi0PzIdZ/vA086T1CNd17isj0c04DU8rXQRCG5bdLFf9EPgtRNKx+oQFQ+ mEk/nNjzltYp4V5ji2y/HFzVY86a5TLBhNaw7LPkdLw6Z7dx727RAbHM52ItGyUl0RYzh74vRRkp zpEbloa5Qfwe+bIQn7CXpVVN7eRKkPIGXLfAad21W7HQXrXWnzGPXLjltM2hsGtcm1uRD/yXchtt es+mBF5u3bbO2RI/fSyv1ylwY6N4uS+lkBqrqJB/s4bVFk32jKWHuvruF9JEUC6Ds+Uvz7HPQ868 ncldSWdxPaC4ueHquv2X5H55yx9LfX64mGeOd1qXrbwBVy71Jyz2JrVr4gDX6Tpl10qpSnbZLuqy nTi5bI8ZnjoIW/5NXN22rNMMmGriERs4elf3ibfRuvFAP8WENjpqEhu3Svkyn+6tSbYquQGfTivg fBQ4/nmvodnHSdxqxmY9UKYLDn9ARdingsuhp7bZZ61bbL7BBepzdTm5O0kVW1Wgfa0mu9PzRAdZ ujYuystKAPCZtp9Ma/XJZjBF8uYtaVpVjrMqUDn/XRoXzVOaFhUZcQoW1eShSW+XBNApLOwHae8n HspXaQxzLFVh6QPA7iep/1RoiAezJA6p+nwhbtt1vNO6bG/lTejinfI+SJatAFCukqOQq8k1E3yi N0BrhZzPRzcqHLMCXNSVq9D03AbAy7AthWU8UlJIEndw5LZvbA/OVEVy4qiwcW+6E0eeNnsufSnT 12Jx212fT3UQcmasWB2Lu+m0aOZ5wmCfMEdLK7otxHLX1/1cI4XtLNwKzsUkGbWwHEL7FDiby+Y8 b7cHrKLAn4Ys99ctGv/MbuI8ADslDLGKiZh5KyUrS/XOyXYo6ySr6zY5lE/VfX4l7/kocej40RKH Hl559vHOFiTreOfep8YI8rftiuiictQy5VqneDAjcz31yKTEPPWL4F2nNNPtOcur+TJ1sMzKlGyb O9qYFcKumVTCq6PCUT3Y4AcUkxEWHeptAHp2VsQ2OG3bAj6Zctg1Q0D2LOxTt+HoMDc8EKbN3/o5 FarZrRaWGaL9PiMX70Y815a7lPUoh5J8D9ITiY9kQlzd2uPLWpkrEbKb1yQsqdtWtklDaXkdj7HP XPd50IRPqetXBRrTm5Y0gWVJ+UfxIYv4OLqnljj0gdy2XbyzB6iNd8bLMT256raSCW1cjosCNgeb p5Kw49yoU09023pa11ANWmPxAJijShBq0gfs4C3tsuHO1XzZOiwFJ+csueUCaJ4GZwtDumCILwwG 2yTSlkxd1VTfT4GuPVDaQo/OxUh59ZPOwrlArlnPnFn7nPGQ9VOZxmDtVafvM389FQXq2AiWJcU8 Y1GEQjSXFbLL5S0piahA8ZDa9pXJ2i61cJXEIX63VpAf0XU7P8qzNMlCW9/TLt7JJqss54ctuZ5I +966hUzWZ4VgcW42FR3WTWG+TDSaTJKzSUfqLYOVB6KNz2+x3dWiMYVz4DwHTZuQ1MPyEkgCpDDY 2Gt0Yp8+Lko2PONOgPPcGqHgjJJrOb2vOVgf5d+TGfSQEiWdAaZr1kAewHSV0WuuYy0FJF/XrZwo lGGaQ2uUEzmX5D2cdZejq/0aklpNiUMyMPuoiUON6zbc8WvB+Kjf7fGj9Lu9LzzvtuieSxaS+k4y Mc7YdZ/1WGzO3xdKboHF1dKmyB1qQcemQ1HzobdfGN1VE4va10obA6PTB80Gyv2RIw1O+x9H7+49 N7ZoDM38Y+CzwAQgYbAPA1ZuRGrtX3u5C3d8gL2YNUV9lzR2765KY7iREsZfZpIZeT2yvoWrcd36 geu2tAxsQ2G5gxprH9tJY5yLlujFnuTH2rKvcd1q4lAqGU09z3vXrfAjZ93e3XX74FD9MMqzz7Qt 9nUCZmmOEJ7+lTaAv1WHJl0ZvZUBGiV+Zh81R0wuN5A3sUjffWXzF4btF6i4NTbearJxB5f6OXat rNbgHIF0BDILTd+5ii+DJz00MFG3CfsU7V51oWOQ0kn3rXPns3B7QC41o3Xlzq37Nb1pS8zUjbt0 dmtghiD1Iwm5eu7YuFpzuz0q66lp+pL3WTSspu5j1nJCl2FqmJxFhNdDj6M0RVgGb++XARth/9sf B7dJiPCrF+K2vd3KtJU3bFfheTxWfIjJvte+/cDljS+44LQPmS5TVD5h/Qx5y/2w/VXvodl0KGF3 wZedOtdrKkheu3R9pzTby9y4aevfzUOAutWcBr4rOAFMGATlPUHKzeGy9Sf1wKRmRbnEhWsASgag zm5crudzYaLNFW/jEFzBSMYLx6X/Sr0ur7VEbSvB3AQ+ht7i9KukOv2iDkRdk0vZoUvAZJn1Ge63 E4D2cU/jgn4iGY4PCU9TprLhul3M3yxJQnzUTFuXXLrx5iVJRwvO7Bv3NpPWxClZR5b1sfyTbZlL 66muW54pLbHtqqi5ro9R9gDtR9FuTZZfjPJ0Q8W5Bc5+IFhflnJRBQrVzwYG+2TF54XQ7GZBl/Vj e44oF3fuWIG2AOXVFJRtgMaD8+b6bbcurRo3lEV5tazktWBdGFcTNLmAU8ULVZcvm/a+TK6oWl+g nJbqZoyqjXvqY3Mf95SSRm7jnqXb0A/J23m+29ATVp5f6fbzxu17GYC9b9+wyEuurRkXhSY3x3Ej hdVBgDfYkF0dPPh6sysuDzaQbHs8JsCxZpKtEnwoQ5sGwNwaSj0C74artrT0o4tcs3SfYdVgJwzi 844/Fb7o0eK60tSQbrtwh+C0iUSuQjKtR5Kxv+hklTZOOlrP6qKXh2RXgJ4+frbzhSsEoytXEy4z NMvosRz75OxZTK33xH3LZnKWCKIDp2DtTl+tFVun4p5Nt6FjGlP2iN7b+XG/pPpmvj6mN2Rvvm/8 QKOVi5YjbjJiibZbZVF39Fe+eJQbHyfAsdZkkoUeU3OMmWIF9gtroWmVZt/s2bmtOCeZIAV3zuH7 /OxhMNjDo5W6X30B1Aqa5pT5RGnKIAZqE4mItdTtqJc1Nsq6dilkqxhInY2q4mTNFeFS3UbEZ7L2 qW0i2pyhRnVGcMrgDq+JnrH2M/Wml1dM6pKdd+ZPWlzjoTy51ptuQ5evgQ+mSOeP8nWctF5z/1AP uLiTsYtSizmYddccoVFtMSWfNjujMqPCPFbGcee+yV86srFNhWWp5Vwrzbb1n/1ymkYGXOtviOqR 3/ZPGLiEwT4URmkDqmzdwI2Pl1slOlCgpbduiWWuwUmmwTvn28hQJ65P6s41sVEy50uDBloacJNr obru37t1MN4lGnla1csXT6PryulnV1uEa9N4dqeagZvcmd6kKc8x+mxfpvK8t+mXLx5fiYL06zqn 8qUkReNKaVaA2gy1OhV9aV20xj3bNFxmoxR5ULJCvrTeGtZysjdZvgacdXTKulSGjNJkt+7S1/ld AE0Y7AMsQyfWpmYZMBDlDq1bpSy0cuV2pStUzzMNVChXpakrZQIpL6tYac7i5S0vnK0s4Lpq3umN 4tpWoTnk0DBUAq1qH1vF5zQfZiPjNv7VPw4U5ONn3H4ceM6xd+24hbrXGpVFZ+nlkXhkvqhk4BET f5ib25laWKbO/7YLUOuerSN58heM9Avbu1fNd6OfIM+55V5NBS5N3mkx48uOa7dtVpOlzdb659qk Jqza6lE7OvDUlxpkhcEuk5l8fpeVCqVeiY4n1tuD/S0FuvaSdbFPtpfbTaopG5eus3Bduus2oL1U MWIBT6cUqcmnHOWocD7QN6OFY1u+LuM2rqOSEGQybmOlxu7JfEMeF57zzHFCyo/72O+gAtPnD4mK a5KqBkytDQWoXZZW8VjkolCyR0zmCEq7+nDN163z7ci4Vq1bNX7p7FGkLYa2v646dJbZm7mfBshb nTxKUwfTrIEtIPtC5lN1qXT5ogCDwe4pNfub+cw+XRxUF5E6n7dToLz2krWeraX2w23Aad25SwNO IgWpG5S7WDW6UepC1MZlKbvcbGptv75QG6DaXo7IrKiUewymO0+KqFyusq9x0k8Onl7bKh0UmJNR n7dkIBgbwme+mC4e2tMpf5ikPntRlEcyR0YLt0dvPg+BzY2ZF41pZlhaNXgc91Pn/pB0KpCOEwbY AtPO/9SpLWTrTVtXbW2f5brGDVRdw+S64bh3/MUzuAmD3Zmd9B5Hocw1jJhh2ShToz5N5msrAlyn QPsSlqUMmWAymbZGcSZwGleuiZE2rt8CUvP4TQN7Lt1rSD2DWZ2Sfc3EjlfJU3ezZeC6rRUafOGn 90FXvI8X85Qv0zxX960mYznaFzSVdz1+3D65aFPAOblHjz1ITQC8JPFkRWiOstL09awwszI8dr7N rZEkkxkjNJ6Ll2ObuSsH0+lSlAaafc64mRFKfJdj3vVLJ/hsYbA7+m7vK1bZNQOYVs3cFZyca847 F25J2mnDTe34sqW6cws0lzhzM4OVCxCPRijY245Gefau3QGwlypYcgJSTgIiy3/q/maqitvW1fr4 WOu3J9d9PmF7WHhKopPEbP9icNtuYnc1U+nMl9/Id9lFGz2eqceh9ykxSP6JU3TR8g+f3SCcgsrx Q/AGnM28vCXOLqPGtZHij6lp8VIyaFuwHYc/npSNO2lsc2ukjwEo0fZ4MXLNRJgcB8j9GXLhcX1u OqEc6a6/ahgM9oFgywORMCCDyVFYJxVZcK4aKmgZCjcg7bNqjWs3A7PAtEKUTsRBqXPvMrVhsKww szdv4Vzep7erNln0fAasHzSkyOz06rIV1SleySU78z4FeH6nW4bn69cc525Kf9vospUbD+Zpfwpv 2lWCZulR4VVZkm2MIANV01hrljd1SR+Sz+Bc0ofLqiJZh7JGUJKdrF7jj9GtkdtQ9fHNol0n8wWf 8kc8HBZbXLRNBm1tltw0pOc1RMv/S4CTBgfB1Irj9zpGBlVhsPf9BdHoYU6WeXCzrtWftkmoyMmH AxXqbA05d67VLpaZmyiU887CM6vQYwEoddDkpnZU9/FL0CuaGJldtLliIStSTqtkqSPVyTOyZkep 0ukT2nH6M+SiqCupYdydbD3+0uBZvdvfBGjuPyf344+aDJRtr1t+Wj0gmnZpSjhp36YYH9Q3e1Hl 6Vk/ziW5Obx+aIt13VpffQbW4quLNk9Uza5U/RTXfvniONbHm8ZuWq4uWmmgQM3YHt+5Yvv+tc7U b5r07ZXKrMBsmMmAIAz2sY02Wputk3XNL5+M4rSxTrMfd2qzJXM/lqwvXenimBoPbctWWoiSgejq vjZRaOHoFSwuW6prMS/V/bxkd65LiZ5xfT7auaPdzGbqXrbY27Dd1KVYwnySdPoilWe2V+Fhdyal eBeOLL6XzvqH8TMSpffnRpCTJqfGD2zepw78jrV0ZU7JQOXDYqWqUaDZ3UsLF/VJRvnJJ9inULel kxWcKSGpKs5+S4lAXjNdvdXJnbKs3TeIqDRYNn6dVln28Uly3XQEgBIGe7p6tfuVGpLSyrXLqyNi Im7GH1400ozMFBaT38EWpk3zhKO5/WhU6XHgtq0qlMzjkmb+LpowlBWpLQMU7+Bx4dK9yBvgHmLe SnjGffrbrrTzkLhsRZcc9vpyFJ7eaynjS4Znb/JH3/gqOuXoYX+VuDf5+jXjNN86Jg0Rmbhnzt4y rlvWjNoYbD8usWeiKNem07+6ZZd8ean9aInW9c1ZZdbBtn4MTq3ZZPIFlnZgbOkcxN2EFKqFwlZx Uj/IeuSvYEATBnu2eF2NBqsJNDnFkWyrPMdmGeCNOGjOxl1qUpFx5XKXUFRHm9WmCm7lxl2GKpRs Iwbtp1tbmKbnl3WZlkWTgNIaLc/vqTYJzIOwF6PAc8nq7ZzWfJmsdRwtdd+7FBd83vC8bwKy1nru yL09JJbtwkvYB2UqqlRUp8Q/s+Mzu285q0lOAegE0fBxTNI8eEljbWIjhCW1eVJwEZmx2Fy9pDUx pz0ijIc45cjN6yEPr6Bp3bSupDG17fZsslB6btMMQUHa1HX2cGx8tIAmDPYiINrFRNspSKxrlHXx ssnIXTdmSUtI7V1bM3PXzeRXWwPRFqStCj02MU/tbKAgzaqzAtQttZZ+0SQhf9TqiOwCnrlV43FZ 1QzkrSShIKquFmEGX/5+PzvlmfsL/nl7tWTcvvqR3IHqU9PP4b26Tl2HvIl77gWk4XQ+cFKV2X3L SYlKg1xm0z3IqfrkVIrCOsE8C9vUxaKOO8ttp4pXxOc2fQpQMnWbbGKcxk3LZdgOrZSnpR+b2Cfl wy8y7fYGapMtWEc8hcFgTxqVW91vicbXsy5GZI/wG8h28Oy7E60SiDbgyTWhyLpluSlbMeCMiZfH kjhU3b+a4RvU5mIbzwfALse2u1sellHmZcWHqBCNKlVctWeyaz09Gdftw8MzlqsEaf0XPyR4rjJu D26VNBQ/nynpvL3n5Ns+cBpRpm/64qoLILsEovrkpD79RBrcTrWbZZCrQip3CCoNhZyr3Tzi0d1k vnC+LUfJnYNKUlCKd8YWfF1z93re4I7q/Lu+npON4myaJp8cXVt/M+f6m8BgsAdWj1u/NLrsl5c7 9DC3btymGSdZj5grWay1xoU3YJrHjXUqtHQgMuCkFobUxEkrOBebrZvjntldqy0CiRfTI7xmBdvm CbJaHkuvBT0gOKTXH+Odmmm7D0DlXbguPN5hkRAfn08U+q/uMZvCfwh4svsuvC3ilv5Vl3Frk4Ze hTfi1SsXh52K4LvahfcwbHIb3wb8zKnpXYTfJC7dmhqd/ee+1HYubpqo4FUgtSikSlcp6gded19A BScpLNPosTbOya6Cs2Trmlins8rTJArl0hQ2irPpk7tSnHSybeT6CgASBvv4WOU77OvKQTsNHqVO bmKTf9G6devIMy6K1Y5XrHWZS2nqwl0v3NR5qG/R17pxmZdGjVLXiJ5c9vppgwa5dEzQnBSqsWoi zxkzarNUSHDqMCf7XEk5i4D0XVhdg+A6TKlgIrdz/YNuYtfXSZxFE7H2uPHQD5cw1Gfc5qQhZ1y3 y5zinvPbVBgrrts5vPG3LsU/XfwQqB7FSI1n+IB8UV0paJmOjDQRJ2bX6nBqzWolOzrPa1N3br9w 8bhIIEpLA9HU8KDGN6uyHMzlbLoGdc0Qcqeg3FHIgI9Ptd5bqcsLD29hMNiTUanbrf649cC6tv6T TdtRNrfnAdu8aizfZeDyxlzQ1fDstj/uSIGWfZeqPovyLPeXAdW6JpuxZ3EpXBJQj1oZMU/pbz+K 91HjnbnKsIRcc5nKz2H7kWP1inDjepc8lNPUej0fUXx+wGzbjbhn77p9N3FSnwJXOeIQxSjxz0kL Z33KOrs9pPKTWQuE4r/44dVJ5U4v5yfyOUmoTF1J533uy+jXzZfZdT1qu7Z7bLJrR3FOMsd/dlIK GZCyo+6H1KpN3lCXYCUM9jzxyduHwNUt29zPNFMg6+blkkRZ1KjrhYAVB0sHUlu6wnVsWdehKK2Z 9XJx3Uqpn7YAzP10i4uYDXCpNrOJZYO5tHBmzYHiCE25TnJhlsCDw6F12V5L6WG4TUo9hRmvwv3e zRrWM/0DPv889Rb4r48rPuf3/GrQJjcl7vmrQ3LdHo8p7ilvZu+6fStu1mNSn07KV8L1sww8VfXp NZDstRVfhOGx9e+neSlLAWT2TGRPQQxZmi+YVZvZJeudmYhSGiuYtntc2+7ZKSn9yLLax9ZV9Zkn rCsIrdJse9aeVpeAJwz2MmzVXIHsUDJn1CiXxgJE7fzicmvewU7epNr1hwYKNMORTRw05oD4pbne KtEoTixgqW3AQLZpg5YVHtVNm8tWyKjO2OQmrPXHKT3brnPZvp0ElrUxwlaykHg4Xz1+m/YP8Yw1 7pldtyKt89FC77olfQmTHGlMSX0u7yiOnhGQUhSpAaLSwukgxz9eGyOktCw+mPFmNqRYJpezSfM2 Mzy7JstMi6uxTaM2uXPRcq0hLcoz15SquziXprApTXGatEQjpXlh7JJ7voKmMNjTkpp8+a72Eg0O kDMsI9pMfLQmD7l1Gz+XEyErONPFpY4WYzPHmGuJS1GNet2SFai3cc48kLsHp2nhJ5entO+U26dq jgodU6VErzplHb+VbFtJc1GX7WFK9Z6vdwmgm/HOVbIQX/SuP123bee6tVm3f5BvQZThNXFoCpCZ rPoUGa/AlczbSYXh/qiNkfOklCkFqCdNGGq+hVxBmhUpUdsfMgXEfXw8MvFON4pxMjUDspkttWvd JpukIGJqxom1LlmyJ4PP+jQdicFPGOxZcZP4vB/PQNM29ay9Empj+eLuNYkd3I82syUizgqJRa9b Ckxzyz25LtduEtcSFwEpm1inBWeB65Rdx0t5PTQvUX3G3BYNl/Wq8yAu2bDWX+3D+SCWJKQXV94f Ait+TCG+Ybzz8ZOFHgKel7tubdbtzZKIZhOHfgpv3JsAVFGfhystGIlHI5TaNR0Sv+IM0GP6Yhw0 OUjyfI5HryBM0t72kKQc22RWJVh74MZZnOWD9iZhKMU2i2uW2hhnmc+ZOy+UQd6mi5Brs2ebhKFL miCAjDDYM3LFvt9vlrrEhzKcxDSN77sPpfpJzeuwmbm5pI/zKMduVKOpVig1fMzt+Vy3ySYGmhOE 8ixR4rYNoK/qk3OGr6/KU3JZYg9cjWdKa74pq06fzovQPcwJT9Fl+zaxwM9uM975yMlCH1J5Gtft f0pdhHLiUP7je/VpY59ydPJW6z6lcYI0jhfluT+kCSzxzTsu4QjGh4eoAHUC0BTaNkdevh6RaVuh XLArqb6U+9/qMOtU37kU5cm5tV9WoEZ9MiVtmgHKWXWWtnua9duwkNr65/7nd8eh1RhwDYM9Z9Dy +LfcdPWrF3LXoZpCwaUahUy80yYU9UlFTfhK3bXEXX/cPNYxwzQ2e08TVXIzBCbTbSi6avP8ZG7A OWlXOKfglNyX2CVIYqGHE6pTOtC9TVm24q79YU7iy7psd/8tMea7Ij4fbUX8sG7bU4lDvfrcvQr7 cAoUX71z7ia8QdMc39/kvpXaz0UAyvFle6kq6QAa51QvVL5AUVXKF0L87KznxT3rKkjTUZavKpRT 4wWBaJqbt267J3eRZCZ21UUbUavZtZzJ6dvS56xET4crITdhsE8Cnrztxu0ns9j4Z1nfcpe90Wiz 0qDA1fmbztW1z2bmEpt4pplMZYZv+E6h5tpOl5M1J9N8oQOnqCG5Xdb9o4TgJnXXSl3nkrJr+ZqD cOKV6vRva5btPqyn1yq+rMv2N99dojofHKoPAc8t1+1afU5/XpXndXizfpD7vUvq0/a7vY5+8+q+ nZfUtmm6Epgu7iA03QAoSfbQYqaSHLVpQmxaXAOhpIFQ1pZ+ElBdnHYmkiYJfmmSgkoLPk0CWpY8 Ns30rDXTUgSkTudsp/Bsbg6/8S4ygZ0w2Cdio6Wc6My4+wxAM7aLjZ+s3J5BGxWfq/1kjfok12bG 5szcVN+X4pNcmhjUtn8CPO811in3kVZ80jJ10bZ8A3DGvBRO4JT7Wndt7CIn9f6BA9fSFGGgOr8L 53/YJdVp7SOVqDyO8jylPiVxSDJvfx/eqG+C+txJs4RXadpKTh6SD+4gfW/DvvMhHZH4nYuug6MO 1fYx3hmlYEr4WRLuDk7LXFxSnAKzY+xLyzpdJTVg4CVPWUlJSEkZLqXtnuhU6ZG7mCbz2X1bsmvN 19E1GbbapOGY4rBsZ5v2fWsJLlgY7JNWogOYlpREBWbmJrmBEu0UamkGQxWeNffDwDSPdMzt9XwF KuW5yUvKHYkJQ7nkxOes3LAeS0ehAtQOnDPHdT9Cd04t96Y9u53X28RdexOUZ3icvfY9f/UquXB7 1Tly2X5Adfkx4TlWn599llRfdt/KIOw3f3IRUvvwxoSDkHgUMv8cIBve/xvxcx8qQKfrxflbahRo nK6SpKDbH1UR+qRC/VHh59cQZd0vZsXqY4jypDKChcrj5kbzXrtAOufKqW/611Ylmb/8ct/Ux9HV 3guDHxANwAqDwV4iMdtIZGO5N3uPha6lnwUmGSXqDGBJQcna2jRCOaZ45GYzCYwRmIu6aXXsY8m+ 9bVOMz9OVpsxtfKoE1XmdFlgOWXFebMG55VP7tqDuGtvA0jDfW7DOi59bEVhTj+mDNufw32s6swu 26g6f8sfy2X7kPA8PaJsK/N2lTz0XXqct7v0pr1xGv8MMLm56gEabtsv7hgAKL1tBWiScetiKvSS ZnhqQtBxih3mVxCV817ByQ1IF+0OFPbxtTtQmbvJ1DR6z1lxrhlSRu2AeOuatdPSXQVqUaZgJwz2 6bhwR+vBYM0n4sF1acf6EHVyC5lm8prKU5Wo1wyOJU80qcAUwRh7iKvq9Ko6IzT1csyg9ZpAxMkV K+eXfYJodM8u1VUr143ASbcpringfBcue4GnuGu/4yi6/jCntXFLdX7nPtqIz8doyzDOvM11n1l9 /j688d8cyL2WIyHNvv3ZJYCKCr1xa4DOu3T+GOuFXKwlomNSiKTDsWNsUj5wr7AUiLIqR5/nba5B GuHpXVWlqgg5z+P0tQkCOddEFY6utoxfuWZ5wz87+gFNY4UKg8GeqXWKshwrXyCOaGPI2eJsXSg3 yUiU2nXHdTbfXgZr+9z2L0EzAtKnDm45trnkIdecXLHxsoJS7iPuWmlgI48RXbNT6h4k549xRvO2 4hRwSs/aQ9hfxJKo4euwpl+9re7aXNcp4BSPZVSdvwuq8z8G1fm9VZ2PHvR6SHheqD7/z6A+/y6o z7+q7lu5r8DxDy7FP1+LRH8dAPr2DEDDl3CZdFrYMbnY5cPbzUGFinv2mADqM0QFnJRAKbeTXif9 dGWwdmqVl+DLEabqijUu3BgaiEO7q9LM9Zv2rVhy4pDhHzON36ENNy4UKAz20ly1rjQ7P3vwfAKe ZXfbSY1Msm3uh0upvC9RVjsr6CnnIdTari8mF1F106ZufQFgPkEy5Y4ksC7q6vXHBFtRpVm57m/T 9KurXQLnrbhwZZD1AJxHBWeJcwo4jbtWEkt9l2G7C/d79f2lqvODQfWxGgIm9fmPcjb80b+ST0Xd tz1AJf756o/h8tdjgErLppJEJC2c5IML4Jt2FICaIBljnvqGx6MjlyAqm7h5ZROFKpm5POug7EVV Z/xy15mcUaWWGk6Kb1lpAc8dELlrisB1iI/PDexHatIOZOGuvAVZRDDYywOoAWJpWuZPK9VYdUe1 tbvrgWmuq6WhXDL+Y0xycbkfaIpV5ibzoijj8BTWVJEEyNgiVfJ+DklxRqU5pRinKMtFXbQ77VW7 X9LqJfFOAaf0tp33qUPcKXCWOOcPAZzhcX5HY3dtVJ3/d98U4aMskg8/z3NbLhmA/ifn/kLdt7bv bS5fkSyrNxsAfWUAGhNuwwe7E4jeJhU6SWs/BeRxnwAZP0inSjRss7hcZ3WxLsmVK6+DfW1i5RWo WWmWms3c7k9HnTWwYwPQrCindPVR7+O3ijwZYhMG+yQ5yic8Td4cWCtBi5PrqPHSIja5aZtN5jB8 UogevQJVY51RD0heCCkIXVKfU+xDm66LcJ2TghVAHg66n3HR7m9dhahkxx5TZyC5fR826SA0y/N9 z7F2vwdnH+ccums/d+4vw/P/UxBg/+guaYrwQaH6+K3oo9Tu3Le27+0SAPp7+ZQ7gO6D7L8JG91Q lPZxDtychmiLAi0qNHwLbhWiO4XoYZ8AupsoKsE85URAKtfJ27Cou3bJfXYVmvIhsqnhnFP2dU3+ USjGb9Ps6lzRTlHmy+Q6wMJbC4PBTrlqO0Va4Ok7FZubXR9VsWonIuVmnKXpcvm5gjJ3KIr9wyk1 oBfAxhEZUwWmePM8J5UpYyGPPiUP8T6tZBGiXly0Yb93OtfTJbUrMU3ai7dQwBn2md0KnFcBnLKs /0G6Ds1JSL1+XcEZ3bUfP0noMZZpOnnbV+H/vw7br7507r8rQCXp56efFKDywd9QnPn5eTg0ei3z PD+TMpZw220q+bg+puzZWP1xHSAn6cxy3V6vE3fplBTltCR3bnT7L1mNJnety1PrRIHKvlP2i1AZ BZuBOmePh7h1pwrK3Hg+qlMT78yHJ1Pvnc1lVMAkDAY7Ac7eU2XLWgSCBytSSV22eYQnGaC6lBfi jmkfuV90wWZQlgdJvcNl2MZRR0F6n/rmymlMBNLe4kW1+nSdT+61uOYtu6Q4pTOcUzdtLkeRrFoS aGpyEH3rKjhNnFPg+fnn1V37l//xyajOD61x3h+gNzcUj1hiFq4A9KsE0P0+ffpvwvVXkjgUPsVD rGtJs0J7iLpdgiIdavzSZSjOCaQRrtpqb1kSAKdFOwVpurSdgpLi7/VvXBZVpp2et9/9HqwIZ8Jg sLusoAWQblwfaqG4up/rEop8ukMDyhIvTc9jgZkfw+l+rM0PRORkaAowY/l9AGCEpuSmCDRFD03a WlXLUa5+Slm1P4ZF+b/L4xlw9tm1dwPni4bn3QH6l+G9eBM+zZuvw2cSSCpuXN5XFXrlUlchiYVa iIo795ibUYlSDRCdZ1WjXKegpLIZ8bVXtRpvkeu0Bd9i4ceqKvN14t6dqyeFF+O+fcyPFAaDfVJA LU0PLFAPafMazzyYOxdIUnLF5vtFUPoUIvOHnOVqkovkNun6dkgJRE7jp5NRmlIaI9Dc3SZo7hSa f9LOQdZNK+AU9+3vdLLW5eD86KrzQ8Pz/QAq27t35N7qlBVRktaNy1+egai4Fq4pHs1IolBKLEpq NDZ1F9fELrl7BbAZprHpQYQmFUUZ4bhLdaXTkt29NUFuyYD17ec3+gh79QmDwWCXmFWdq1W2v37J MUqbnVunUsk6aCGZF60MYW9hOSVY+n1a8KRURRg5+XRb455VpSkuYnHR3mhsU7KEejftj3LbLoE3 u2mlXCWKl6cNzseA5/0BKnZKhX4eAPjOxEJj1quF6CGNKbNqlI8JpLvwWNdaRpIbGmSYuuv0vJKx e5XBuCQwppZWern7uJYNpSm2003+JzCH/ITBYPdZSuMKs9etPbtSo7FOvQewN0DVspVYTBCuE9fq wSd4STmJu1F14BWW6sqVPrN7HVQt67GTRKCpVZo/uaQ0m9jm9+4iN63Y/cD54uB5d4De/lvn/vjX qQ60B6hVoV9nV65c/HwNUbFejfLrBNKY5u3WMNVJaWlO52KgKABWsC4K1it7oDeAqv3rvXPbzRBg MBjsUjMNFZYNXGRIWrt1SUn6yQyUvkmg9Lo2LTnWmcZvxvhmVpepfjMpzOVtmrFcVOacoEnqnm2U poGmFFBYtflMwfmY8LwbQP8+nHn3vwcV+hcVoNmNew6i8iDZnRvfTgWpAFFAeq2Dsw8HKWNZw5S1 XCUDNScJxTooqnWduddBfi3ObSvPRHHdYDAY7H3tRret1ZRqI/UMytxvgUoykAJSs2dvVFVGxUpr WEYxqQpT1tQMTGdUZnSwbUBzP4htNm7az8Na/s/srv4P99TB+djwvBygXylAf/WL8AH9q1aFnoNo ducK5KwatSAtilTHmlmYJgiGxwwAJlWa+aPJcMzPG3loAHvKMnxhMBjsfa0ow7NLbo2TyrSqvYGp HXmWmsTIXM1wnYIyKss5KUtZN2WfW2lukO9kgJnnb+5+TM83gubunNr8f9m9+lMabv3Ewfkx4Hnp c26r0AiiMxAV+H3jjBp1a0UaE38EmMcKzKhMj/WLIVBlTvscTSePoj4DmGXLQD0eT3+8jEQhGAz2 EKsona8Sn6x7VtZNSb58u046KpB0rhSPrkApS6LCMteWZoWZKSdC4lVYHP8Qzlv3rFXA59Tmb5xt gnAJFD9aAgk94ec9rUJPQTR+WB1IrSIdwXQEVAvLNwF81z0gTQeEc3DsAQyDwWDvY5Npln4RYLuu CjfSsCC7aLulqwdlgeUVx/7kQresMK+WCkyvKtPGNCNYO2i+v9r8qOD8mPC8y3NfDtHomrgApLLd DmDqJFnptgVqw8nwePsBXC8x1uYMn4Xzn+F3D4PB3sMkm/XnjdKVs9CdUuzyqK34RtaDMsE4AHCX YCnZRyNgjlRmfs4CzfdWmx8dnB8bnncDaObbrxWi7wYQHalRsR6k/qDt8fT9j0C9UqDu3WqItYWr PI4A9j4AzRCe8duHwWDvYYdWRN7JChizfe9WzWJHoPyDXi+wlLnMMiXlne5/DpgNNP+Lew+1+STA +RTgeX8V6jol6v51AOkfx2p0S5FmeyWPHKB604Ezq9RoWptyezgBWBgMBnviljNtrwLYruYERwvI Zr8BKC0sxS4BpvvPMs+zQvN+avPJgPMpwfM+r6V150Y1uoxBegqm2bagKhm1twGsez3Ms4p1yxro wmAw2CNbD8JNiOqyOwLkOVBmGwLzawWmqkynwLw/NJ8UOJ8aPN8fom4DpGLnYGrtErCesgxdGAwG +xgmy9e7O+xvAbkFyREoG1iKZWB6BeZ3dWi1LL/f3guAT9LN91RLJ+je9xuBNAKxg+kIqJeA9Rxo YTAY7CnaFhBHNoLkWVi6NTDvrzKfLDSfOjwf4vW1IO1hugXUU1Ad2V1AC4PBYB/LTgHxJCCz/WdX Y5cbsHw/hflswPkc4Pmwr/OX4XE+767rgVqgmt20/3oN1y27C3RhMBjsQ9sQgqdsBEi3DcqHg+Wz geZzg+eHe80joJ6D65Y10IXBYLCPbEMInrDfKCBHJnkcPwS4/fMHeaXPrnzhObeLe5zX/tdh+yI8 133Dmn+vGwwGg31oyxmt97EPC8cXAcyXAs/n8bcIfP8H/KZhMNgj2G/D9s9P+hW+mAL5l9yoHE3Y YTAYDLAEYPC3wmAwGEAJoOC9gMFgMAASwMB7B4PBYAAiDAaDwWAwGAwGg8FgMBgMBoPBYDAYDAaD wWAwGAwGg8FgMBgMBoPBYDAYDAaDwWAwGAwGg8FgMBjsSdj/L8AAOnKBDF9LsKQAAAAASUVORK5C YII=" transform="matrix(.24 0 0 .24 2.83 44)"/><path fill="#FFC107" d="M12.83 96c-1.1 0-2-.9-2-2 0-.55.22-1.04.57-1.4L52 52l44 44H12.83z"/></g><path clip-path="url(#b)" fill="#263238" fill-opacity=".1" d="M52 139v1l44-44v-1z"/><g clip-path="url(#b)"><image overflow="visible" opacity=".2" width="284" height="284" xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAASAAAAEkCAYAAACPEuyWAAAACXBIWXMAAC4jAAAuIwF4pT92AAAA GXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAeINJREFUeNrsvc2OJFl253fPNXOP yMzKrOrqrm5OT7NBkBIhgAK0oDa9Eao3XHE7C60oPcA8A8Fn0BP0elYCZtXAoHJWAjTQQgA5mCEk Tg2nxSG7qqsqMyszI8LN7tH5vPeauZmHR2ZEZmTEtWpv93D38PRwN/vZ//zPxw2hbW1rW9va1ra2 ta1tbWtb29rWtra1rW1ta1vb2ta2trWtbW1rW9va1ra2ta1tbWtb29rWtra17Q03aB9B+7zadq0b to+gHVDv5DP4on129377ZQNWA9B1/I1vApPP2/F377enNwsubAfnHfqbvmgwadsHAK5f3iMowV39 G75okGnbHYLTL+8ojOCuvO8vbgg2/1vzydr2Ftu/vCZIPL2jQIIP+b1+8ZbAOQYu31zy+F+0Y+ze b7868NinNwSpp4dhhB/sQX3b3+ObQmcJNt9cA0z+oLr966aW7s32Z9VB/uVbAuvTt4TShwwj+FDe 2xdXhM4cON8cAZo/mIPkz672hp9dtAPzvmwfb6/w5F9PwfXlEWB6Uyg9/cBABLf9PR0LnjXg/MUK aA5BJoPks/3H5u/j//62qZ77vv0PP5ge3E/nT/jqALh+fRhMa1C6DEYrIMJbfbDfpvdzVfCsKZw1 2Mwh8/mRUPnB7OcXQzsA7/v2uJ/+/O0RsHo6g9METAeg9Ksrwui2gwhu2/s4Bjy12vnmEHT+bB02 c8j84ABU/v5Vee5/1463tl2y/Yfq9s8fTg92h9W3h8A0h9IKkOYw+hBBdBsANIHPMeD55gilI9BZ Ac4PViCzBpdXY7n9/OJqn9kftuPxTmx/d4XnPtmWA/thtw6pGk5LYGIo7QFpAUZXBdFtghB8CPBZ A88idEzp1NCZA2cJNgyZx3T9/80AMwfI66TX/7Q77rN72I7dO7G9OvJ5P9kEfBAvhxdDag6nJSh9 ewmM3gREt0kNwfuGz2UhF8PnEHiefX45dObAWYLNH1aAqeEyB8jv/4wep9+7SO2gbNv+tiX4/ITg 8l9+sw6vGlJ/dwBKNZDWYFSroj82iFwFRO8bQvC+4XMV1bMGnh9cAp05cBw2X57vg4YB81/O1j+X 1zHADhcTZEdtz3cta/ahbE82Vz8gWaBs6Bt+kNZ/9/dPC6BezaC0BqQ1GH3L3pGroqdXB9H7hhDc VvjMVc/fHgBPvwKd5yvAcdh89lPaYWYhFwPmE1wHx86Uz09X3vuz4fBnOrRpMR/M1l9ydHzc7x+s /2DXm7gOse8WAPX7XxOUDgBpDUZDX6miI0C0BqFZSIZ3FUAH4VOrnnm49czjtAPgmSudf2bhVAYO /fzVj8vffHpKn/T59DP4Hf3MqvZHM6DMwfF7DKW0//kNH1/+Ibwcmgr6ELZH/eEDsX+2f99pDPjN AsQcVl/T5cIAVcMJMOBZ/UJf62OvDsBoSRXNFZF7RG+ghvCuAehS+FwWbn3+mXo8S+Cp1c7rCjw1 dE75U4XyN7OqgTSFjYPGASM/f1LA4XzZCJSmtHk50qtvZjJ+4W8dmwr6ILZudnQ8nz9hZ6DqAAtw nsndz2qAfVdA9CoGrOHEYGIoYQUk5scTrAAwg9F/jfuq6NVMETmI3kQNvUsIwW2Gz1z1uMezBJ65 2iGqLELnBSkcB87vLKzKsDGeEOBgk1XPx+FlRHneI/q5zyEe3zelzUPU7+tVwvzv9e04vjPbvOb0 YQR8IaCCPSptCUoMsOd2l0LqGe+LBU4GJoeSA+kfZgrpfAajuSr65wSisdsPzeZh2ZIaet8QgtsO n7nqeUjwqUOtGjzndPvE1M5zgs5nM+i4wqmBw6rmRwabl/GJ/O7H6IBRrcNgYaj0MxXTPcDJ59fX Smhhayn5D3NbS8EzVOZQevk9nfQMPg4tBtUrgdQuPLTfeUk/PkoFSsMCkH64UXX0+GRBGZkqelyB aB6azcOy2wihdwYgvAp8jFQ/6PdVTzdOPZ4XBJ8l8NReDisdhs43Iz2HwqkHBiIGDoPkU1M0I/ah M9Dw/Wd036OPFCzysykbB8lFmIKG7z9L8tzFz3VJDZ3jm323DxoX3mh7fcRzTgAOKp8qRMPTOAXU MAaBTA0uBxXD6VGvj8lrdhEdSs8qILFJ/ej7gA6jWhn9kGC0BqJ5aPZqQQ3VIdllEJrtxPghAmhV /RyEj4Vctdfz8xXV46FWDZ6fVuHVQ1M6FwSdRwYdVzhz4LCiAQMNv3ai2wMU6Lwczfw2cJw4aIwG QwWfudo5T8vfX3rD7yA2lrzRlo77bBe/rJMIe8qIITTKY4Vu53QfQ2zIANKwyeH0SsxqQN6zHEo1 kM7oOU9QYbTbqDJCeo2dqaI1ENUe0TwsYzX0cw/JnrKxcDmE3oUKgvcBH97+yh5/E/iw6nFzOZLM 2dDPnB4/Y1N5p/4NmNrhx9iqeT48gU9FTXVwkhCWgOOKhvaoEm6x6nlQ4PLQYMLgiAaac/Cnls9z JECd1jv+gio6b8WMt3o7mVGe+JMPwrOZ9yOP0X46RoUcQ4yB5ZDqz/MTBTYOpZ5AcwYFSONrvWYY PewGU0bP0VXRp/R7/7gCos9+S7fjvhr6+24Wkg30Xm8JhG4cQIdCrz3P519M4eN+DxvNnN3iOh5X PXxw/9ZUj3s8rHq2M/D0BB5XOwyelwPCR48UOrQThHN6zIHzykB0vi2g4b+D43kHCINla7cZIB29 ka39rReVyqFbwMJolw6ejfc+/90RUNo2NrzVdmhs0yZeroRE7Ub58vLjW1NHr8/0PoYXQ2lnkIqJ zmv62gKmc4eSAQk6C5cCoMMonAFuxT8axNQO+FzCsdcrIMqp/JkaWgrJbguE4Cbhc1no9Zczw5k9 nxo+7vfMvZ5a9XxE17XHs3k0Bc8TAs8Luma1w7A5tbAqqxyCjgPnNd2O+ub12jyfi60CjwHDYOlT Aciu8mPkZ3vsxMKkc8+InRw40zp8CGzHWEKtiOjttkMfMfNiA1wetrKdK2zQXua8qCX5mUtAGGIM L74+s+fx7zCcGExIUEn6PlAENz12worotTwPGUYnBBwK+cU/On+tpvbQjSgmNoGITewtgchDMyTY PK7U0Plv9d96PAvJ3hRCcEMAurEs8VroNa9wrrNdf/NVCbv+5BL4uOp5bqrnhameV6SK+vPHsKNv hmQPXDxIMND1iYVY9M0DQ+HhAzG05XbPPhHvJAwj+ncenHKvF3JRmQClo8d5j+kMMHx9sUG3f2Cs VMumSvnLThbtZ+mo30zUy86U1K6EaW99ALXt7eG0g8n3aR/3TpVT5MeRDxzUb1QhNNrzNp185+IL 9TsFDYMIE2Kvv0TAQayBxEqKTjzyOKkkPKEddRjZ9uHXRhy2gD2D6awLF7TPDt1jggng5tFz9ojC 9jtVdbyPf7IR8EH4sb7rF1+H8M/oPj6WGEISVRCE+ETPJ/xvPw/47KlGInxM/iosz0H/oqgguM5d 8CZOplcLvQw+f0+hl2e7fm5h1yH4sJH8mvQqez2vSPV8vNH6nRfDY+jp23HFw2EWKyEJzUztsLL5 KEoIJbcv6JqronesVuh2UjJDSrLjAH+z0aqe6UFRRxfAWbaN+EIOjrgJUP/h/Fg/+2gSlsxZDZxj wqoBm/i51rMvrB9IF8XbyWiKUAoOB/N2fF/fDkU1EQDwgoBFoTraSUiel+h6S3Q7kzAsSOjF1/xz oh1qG0UNsQjmME3CqJFg5KrIw7OBQrOBAPS4H/EZPA+PKLzbvVQ19KRK3bOBnS40JFtTQn/yWcmO 1Sn6S0Kx2w2gK4Ve/yKEPzT4KLIDsOH8d2cBfrgCn2w0P6Zrus0ZsNPxMYVb9OsEn/6Uvi/6zubg 4YwXiIpRr4eOenDo9OrpcKgF5xv6/cQhV2DlBAP9a2AAir2BCFmtg0Br63CwTxOwQJjf6EjQ2ayo F4dKPEKiYpM+17ujVnv/sO/P7UEKTK12oJEymHSlPQg5f8WR2YVBi2+j/W4aDFQMINzhawnJCA6s dkglDWpcC5QSAYaVEQOHTe6Rv3a6bw4iDtHYIzqPtHf1gA8pLGPgfPpCvSEPyS6DUJ0dcwj91TsM xa4bQKvqZ571+lf88yW+z9cEmyX4/JBB80SObXjFKshUz46AAw84rY78OsCmcjcDDysZ2KL6OCxV Ez9Oj20MRAwe2HCLBmw2QbJl9LXD4KAJViXd82Oawgc1j+V+T8NvKiihPUdAtNmX/ENa/x7mD2wa N65t210S1vZxWui12wVRQZUoCg4ZSceDgqsX+BAgdvY4PSOx6SzmMgq8iCIElh2yShoNRrDjUEuV Ef+MF2xCqypyEPUDJIKHeEGcP6nV0NA/l5fecUhGz7kMQn9TZcf+ripWrP2gv7xhQ/qdAGhR/bBE otDrs6/0d5Z8H852zeHDIvjhE/mdCXxY9XAFcg8Kn26U0AkuDEYMIVY844iRIRI1/JKwiQHk0GGF s0NmFGe/UMDCimboFUASonFoBerhJIOKPC/kokW53YVpUeLAuyXsQ0RA1R9n1LUY7PrN6LVCw36c 7soX3IpThWGuflwpXRi0hp2qJLZ8GHIKnymUWPHofXTbYET7igCnH0GhJHEfAYhAxEB61LM7oGqI s2ejqaHhNaDUEtFOv+tfIJ3Q8CGFZJdBqE7RiynNEPpXEpQcDMWuUwVduwn9xbHGc9XVztvPx/06 n9/NPJ8XdNmswIdDrgyfE4Rhh5HBwsZytFArovg6MZLaIYmsF9xwVTRE2mPYD4yIAquxD+LX0JkN xiDKTM5rQ6fwGRQy/BphN1gxY5dVPWD5oqD64qCbfWvZExoXvpR+GTrTSuvWbfamm3o4Q/kEhymQ vGnYvZ9eFA5O6oGy6weqlmDIkTIOwGGU+kByv4VlGUgDVPdtUEZ0IP8sxgASvbDjyukeOT2LLI0Y TLRvCqBYDUGH4aNTPduxSR3xMe2gL8KrR3SifqleFversa2xI+AkOqm7Mf1f6Xj7uY2P5SiENcFT +r9fPw3g657dtCF9nSfUS8Ovv5wZz39j6sdDr9r3+ZhCL67z+UkSRxDccN58sgwfVjzfMnS2UlIh zxWQbDBKooFgNBIoKE6KCpoNQYe+swTiEfF9RBEBEKiaUTD1GpqJqhHoIKROdrvsBbnZPNIuvekr XwdDPl0mzCl+N6Ann1c39Xpg79vp1k47TRO91Q5bjybA7A3lO8fqExZfx/whh1KtgHbDQF+T1vV0 Bha+P43ylcrzaOdL6PAJBUaJft7QnsYeUKKH6OSJCXekjEJyRcT/NAOJlAyDaaKG+i2FZjkkUyXE mbUlJfT6N5p9+x3d/sPTqR+0FIrdpAq61tPnFyuZryX18/ff7ode7A19babzBamfT87p+Zxmd/g8 WofPc4IPbBUQ/FwOtcIWNXwaVfXQvhY7+poTp91Z8bA3RLtD6lDui6OGVwydcQzKC4IWKxv7zAU2 9Ashdno7mAoyy1GCdYFTp8WIDptoHrUrHqyYkkKY6Pp5K6uY2mP5BVgMJNp25W0sH180D2cJUjFo Wj2hgifm21L8JxAatZcCiyICvS1h3CgVXig7J72cqiR5vO/opQaQx/nEllwpRd4zNwwiOCdFRPsb pp2cLFMiBRQrNdTvQhouQhw7xP40pnDWiebZrSih9OMQuE6IjzdPz0v2mSDEUcm3nwV8FspCnZeo oFvjAcGx6qf2fpayXg9+ptmt2nT+/rGZzuePYw0fTrVzuJVM+aSBFA9nsxw4bDB3qoKGcRMjBfF8 qpBEBX/halBHue6Chmn89XemeBwyXafAQX0OKyTaAeRxBkxnJnP08Kur4RMMPvpYZyCCCiFw6LuI 5dtKV0zFd/ecL5eZQB5OQVpGOdr5ICtV0HMMWMjlCgiLX8RGHwZTQB2rH4GPhlsMpCh7SuCdMvHP 9HzOwutjdDuyQhpJaHeinNKOy+/puRF2uKH7zbRO7A3RbinhWr9jc5r+3Y4VVUy1EnpIkPvohaqf QLD5p2g9ZDM/iOikXfefvTsVdF0KaPGgWFM/tffjPV61+pFjLulYDPZ9zp5IiAMdqR+ubP52TDCa 8gmsWir4nG5U/cg3Rz+HDZ9bNpEVTh8hcohFIVKMpnqQBTHBYktnJjQI0W4RxZDmb5dvoygiPncB ZCWkoRnf50qnC2pKC2DYrAaFDxqUIhQIWfQMYRKWIexBo5t+uhGqEO2I7T63m8ERT8jhVvSQbAov D7UcNqk8XUAUUUFjkEJ5Pu0w8tioRjKHQqxdNLpmpRXZhEzjOESQgB9jn2iXod/t6KGdgIiTrwSd UaQzQQmgT5tEaojVN0aWaz2K8uLddNjQa2wISufcBJtirYT6/gXQMRQuSALxwBkuVuTath9yPyWf 9Dk8o2f+zXtQQTfqYPqb9j/Ci4PqtDtfn3vWi780M5499NqkYjpvOPQiSJw+5M5ihc/QI38fYhJz e8Vmo6EQPR5BUuUbwg6IAkLONdAXTDG3AClFOgkBqyQFD8NGodJxxK1hWNTdlEEFBhxTe3pOS9Ir JgG5wMkAwYoq9no7VupHAabyKJkpXfmZqpq6Sr3AmvnctuvYvBjUiwr5Q8++zyhfKM7jXd7xknWh s4cjMLLwjHkUdcAhOnDQ7qedxCAkqXx6iU7UjwJsTHwK5P2JX4f2TaCzLMjNyAVBsgfSb20gpl1K FO1RSIZdj4F9xx0pIN7ne3przKyOXlq6oQlC3JY09M8lm/I8aDj2mN7gi1kotmZI/4WpIBYUtQr6 fMp6fK8A+uKSx2W8qi2d8zd+ch8vVz/bj+1oJ/gE0piBQq8t93JdaKp97BU+rHriFsXvGQ0+KSh8 GDz8rdMtBkzkmh6GEPJX3kl7hgAJDTz8M8fqDAtRSASdGO12Eshk6AR9XQ3FBEKdZM0ioHtAUIdY NXTE0K4VT5wCJoWikprd/I5AVB9IXCDIUU1StRMMMnpeKqoHRPmw2oGgXRcaYjF1xDPiPSdohisK cOghgxH/07S/057FexQLKgVRbwqaO4qYd7z/mYpPadxoVN7tMI2MLoLQxiDESsg8oX4bEveThaEj 3fQkPOTWjZe6H7EfdEYq6MmPS7sGv+ZorRri0R6hgt52uzYAfX7J4z6/e2I+m/p5FHRY95L66elL 4KmFkUIvPo+cW+h1QZePTkKu8UmkfLishw3oOXw2HKZ1AiFCDKlXqa5A3lsEQhSPxVSBJxp4BD0o 9UJ8P+fp5TlyThNYdAyQyD1n/LN3zYt8xpIpM4tBwKOgQo+sFErRky/1AYGAl3g4qTHprbd5x7tT Ibr7Z9+P1JOmYF6yhm6j/T6rITRJLOcx5ohCSarI0IAEYheiqh8MVmGGicCSWAk5iDqBzwgcjhFg 6DYnS/imwJBVV+CCMqSdPna7MAwSjgVS7CUcIwidsxRiFcSFbbQnverlhI7wQjygcMp/7Ik20HIz 9/9jhrRYs0N1YD8tfWJzFfS2Ydh1AOgo/8c3/8N+XjmE/0jA+Rld/+6A+mHIcH+Xh165yNCqnUXB sBKikCxR2LXtooRB4t0YfFgBCYQISrRTsVkdBUmqiSPtNlGEbieFimxMC4Tk8ST6iPGn8ALZfQRM lmPVsCwICMH2EdHboIazqJ1aCbm5XKuiVPlCk7T9wucMN/HF3ZEN3/B5MWgTaLJqHjepR02hY0q5 eVS/bDQQqeQVFHlYFlVY8S4nMBplNxul8EN2GxAdJLlYqEBEr5f62I2JkQPaLC1+Ip/nIv8WiNfI PhJBKDiEOBxzT6g74bITOoFTqMYJG25A23ZP6LeeS4fs60H6GcNZVBX0j6aCXBzUXhBHL2t1QZ+/ 5fd0Yx5Q7f/82tou6m1uPlM8Ct8RiE53OuOH1c9LYN9nqn74KGcF9JDU0qAjOcTb4cwXp9rFp+Ha dfrOGSBEG1E8Dh8YFSqc6Yqxl/sQDDymiCQ1r3gAeSUBTQS5D8WKBh11z+o6ez8wapQOPs7DQZT9 oXzcc0pDoWOP5SwZTIPqxcziPBN2nzNdbwPXOkvmoEnT30esPKJkEBLgJJmzghZei80jZrN5P97L zBtE4ZlAiHayNFrmS3wfjsLV+0nAeyfjiDZNenSjqyEuGWElxoPxeroeuf2+U7ndkRLiNFjHaon7 GOmY6Tr2RykMGzibpn7QxY5CMXgSdhSK/eR1wN2KCqq9IIleZirowEeOtwZAe+HXzP8Js/DL636+ Rx0ezyKWR6hu8AnP4RH106O2PFycaNglodeWw7EADyRrZQWGnIIn0IyEmm4JPgk7ho8qIFZC/FyF EJvS8lxWPwIm4pSEXqCQAultVsNaLWeGhNwXwUS1aO04h48rG96RQEuHSiq+Vjie1l9TPzHuncVb KPZm4VcxltM0Y+ih2WhwQjTlY6l4NmV4yJhlwBQ8rI0dTAYejrdpn0hGKG19DnaxhiAHEbeZcdsY 3cEes9a+sv3M/pDk6MVxYkWvbT4GoTFFmRdE6j/07AltkBQRD66i1+GRMxwZdHri5lDs0UnAMz6O FlTQPCMm7PlMRYSroOsMw95pHf/c/5mHXyd2kfDrkyCzT3jwydz7qdVPJ36NhV5pE+npqm7EsNPH GCR78KHdZQADjUKo42sQKLF6jgInMPBIaJ8sK4ZoSiioB6SJUgn+jRsFPmYZOFT21VAVllWd8ejl iHFCl6NAgy1bdlgdLYzhwOnnjC6HYoCsgqwSWqSOvEYU/YKjv4SsMhfRjWm1BBOqbcON7hSGoYyI EsNAPB/+V5KUxHKFDwiQEvvcoKNgsrvd0c7LxUGohKLfdCXEtSVsTA9hFx6MahDwAAdRQhaK8R7l odjp+AQGUkFPFlTQPCMmx+wP1IwOK2b024Rh1wKgL4583pL/c27hl//MDZ9c9PRPoCqILwOpn49Y /YwyHiMMlfoRCPFMHz7ARy6r0EpormaW7FZUGAlcuP6H4MNmtcKFYaTKRyHEeVF+Pv8PRCEl/tnC NAnHVPnEoHGUGNlBQyfNmgUzwyvl49CRchAznHN6PrgaKn1k9WwOf9668Rzrs/kipZpCyp8Lzo2f NLP1a1NazV4rzkqqgtD8naSxl0FI0uo8c8yhlNx0HvVslgxGAiHWSbwvooZfo9jbfBJja5LLZFFD /ChQIoUDVkWkEKLdzgwoKTxi2ymIdD+h+Gvsd3EcVYpz9q4Oxc47jiIAXw8dbFdU0ItKBb04YEZf Vxh2LQBaI+BfrNz/uPKHPPxy/4ezX9ukK1hsgoZffccpRvV/Bst88V/KS6LwhML+hJfQ0dBr0Pob bTrtbNphFIhQ6NPJtUOnuu7EcAZ+nBPzIGGZKaIuqx/zgPilIXgIFsxvDBqKaWuGqqRsTM/CMDGt oz+WFQufGuPM55mooRouWeXglUzXcI/gBLOPBS/zimA6EVcrL8wfipZyTwVCjBxNLGiLmIVo4v8I kKTVS1Pt6iPHpJM5kjiVDCLbBeRVk5jRUU+h0huEmlWNxCD9rQwhfqcywgPlTC2vFHhERyLp09PB QtTiPsiXFopdjJYx5kTOGYdjT+B3pII2pII+XlBBtRl9TBh2q0xoz4D9wQFCscz7bwxAvH2S1P8R 1fOxjqy4sPBLl8FR5fNQZKek7HkUqgCGe7W2sofoyFXOFPD3Jxkq7qjppBte0+oMHQ3HuAvHrjmM 6uSarWjUEbwCHNRKDFFBSaoxSCUlKVWUlo0MJvWD5BpNAZnhnG9XgNFKfs94RaspqmBUd9XX98el VHxc9TfudSbs0JYWfojVCqRSx2NfENr9Hnal5KcATX5Kp3rS3i7xeziiQvV5FERs+7E7FBLt0SNP pdLQPbH5I2WGoImNEa3OTLDHIVdUFaT5fhs4FLXxh3E22m7PLRgj749j5J62uE3SrsESTEpZxhMN yWoVxF4Q/3ucEXuwLRMdH83M6GPCsDf1gW4EQHsFS5/tP2e+JA2HVt/7D0yfnTYq8xuUFSyCzt71 8GsXdLjYsNHrUbweHbkB1lDK+peNaa316SVjpZAJetuLET3MihaCSYmqmtPIwGH4gHzrGorZALzg F5B9QSql9XFRNzkMQzeqy8SA4hPFnAWDWRbMfCEs4In7igUmaujqaeiWJXPXbjpwkr2dlDNkYN6P Ps/T8SJNwdRPhpAoHb5TMl/MGlB9kjik4mgpg4h3S9nNk0xk4FMm/yzBWlRxzahK1sPDY8j5tpyt Uqd9GvxvdIIg7Eba1Ttu69BQTPyDbcmK1SpoewH4jFTQ9uPnuHuhTd9cHZ1mZvRSGHaVKOhWmdCX bT+0P5g3XgSQD7oz93/Y63kgxrS8aVt7SYy4Cwu/OhlHp0A6V/dQTOpOB4FphZhmuiR1L1DgDFmK Chy9T24HM6Vp1+k4DzbwtfhDAqFOesQkvHcQiToCzaJhNqNzWFZ+rkxqrQ+qVI/r8eILScfirB/g kBp6u4zQ3VU5h//2rH2SKZ3KlLZAScMttVyCqB6pKFWTGq2PJhcasq+jNk003cIOs+xfGUQsYzjo AnYXNVqzfUQ9IJTshvUNRRPICTV6j5IyQzGgVW8JiDquS+q4ZoSuOX9Gz5NjZ5yqIAbeI+zFsOY/ 7BS10DJeEoa5tfKra/qObhxAv7bvcZ6Cn2fAJga0peH5GzrttGVjkOV0bHqhj1G1EKynZ16gFWx1 ekCDjsSQMGfserCh8hIseYFhJ6GYCBYGU8fSFUpGrFPlFPUaUMCEmoXlM5dWUcveY7VEWAGpypBJ rZHBJkxqg2KGUm5atdQ8WmglJ9FQ6oRqWCyqoT2P6Ggv6G6rnJW/GebKR78QhQ2UWc7MB7CwyybR SzgmBz7vUdoExtQQn8cyYbKsgYBGongFkZYESaeZlhBZTSunt5KE6ajhlu01Yj0KeLCTHSrJGojY 867Jg1npMe6QR/nX5VeQy1FSv9PogFuU6Jh6uAGJKnhpKjxFuNiREuo/pt96Jgs8sBl9auvQr4Vh tQ90HUb0jQPo2XoUJmHYfI1zhpAa0PrmdhaC8V91glqX4f1T/NzRHL5ej2BdhaLXTFjIdTlc545S zGXGsfVwBZ3Qogc7Sw3+RqMXHDp8xBPiJi/U24ieCYviD8n4DgeP1RYJACR9r60d2tUoO2FpZI2Y FVEVdhVfqPKDsGrVmIMHLxlsv6iQ7uvazqnU+NQT4VKVovdplu79SLIpWkimc1RywaGGZrqL2Tpf HLxpSIaQXRszpB1Eo+TS+bQlu6gqH2lDtWcL23RHxOTnKY37ZEY0lwINHHZRzEWhmFZk03vb9IEr qrkwCPkfZQB11kem9oWeuDcbHmrPY4w72H0UxIzmkzwng54cCMOezbzef3mbBpJdx/bchrvzG7sw 8PA32xl0GDi8hA6vxTXakPkh6F4QN0Hq3VOVTdKxG5oskOWUUeb4RPHwiDBiTCedF8S44MSoqBtJ hIm/I/AJBh+2++TcJFaRGtmgKrmTaz1xqmgBa2PVcVTSyKEZMg3NsFJEWExnH/GRfaA6C+Zqqc6U yd8Z17Ja8a0N5w+1rmip3mfa/JUmd2vpsvs+NkrVm07ZHNTXyyl4RoJ7P3WPFzuRFnaZ+vGKC53i ARayK1p4/wQ7GVp6nS1rg5CCR3S3VNOOprGS5uk79FCMX6zTMeeiyqIW5boXxMcMq6ALC8POzIyG AbMZTbDB8yobtmr2PL0+I/rWAWhAH9r+JJvQqpZsKLwdbGdaZKVHvBrRIVi4oje1J2vkSdFaSyOA sQFkOtunUj+idIIGZJLtsvS6qJ1gINICVIZPJ/ETalgm8PF2DggWkkUtVrRuelNH4lB660b0eUJo 1fyzcMyyaCbWpgoG/c78M8JymLF8/1UE0AebKcPLfKG8aImHYypIggZODqGYlY6oEw27POWOPlpD wCSKxzxq/uJlSoeM+tFpKtEankdt5TGkSY49gA97kgWfUl5PTHaMJHVIYlh2osV53BAvdsjXfJYV XVRUkJSbEN9e23720BblHGdm9HABuAkfh52FYXU27JAPdF1G9C2eaN5PdpdkENIlcHSdreS0sfhH TjdozaGeURLBrKFx1OEuOr0wdHbWsTGrqn5UmVijqhjTXqhoFQJckqqKyDJkmgSXWqFKOfGcOm3h mGTLTBUZcFLwdH0Ez+lGMPhoN7z6AVX9UKj8oRpGcXrcrY7wOMIXuXOZ+boeKIbVeiC0CMvT7UIf sNGp6CCSVKvUB6GDSerrUQsPDUZJG1HNdDYQ8RBDeUmwE59VOstazaDLrRQIRcx99jz6k6MtidZE 0svJMeoSz5IXU1sa5VSYpKmaZ0Frdgw2XLAL4GZ0/yBI0yofCJxR5jBs+wmFYJYNYx/oZxZx1D5Q zZ7rMqJvHEC/oE/q/6C/9el1hO/SKKMTB/vZ2WyQ+p/cCRjk1KBpcfkkWSFZUZecCSCHZGiFgiih GZ81RIl4E2rwqmmGDLeWSViu9UAWmkH2hWTkeKfjYspFiiKjhWG5nSOCYQRMuemUcXS/qCihOkQz UzQDx0GLlVd0hCi4V+U/uGQ+LxQpergVSiQkqUqsCo8VD3pgJ/DdLebZPqZ2rPBQQJQzXswKPQkm yD3ITIuodiFqQ5r4Tfr+uExaujmskkOexDOsOonitfs+1iqIXQipgeMfRQXx4gs7VVhb6bvPyRz2 VjkMe6R/GFwE9YFkHPKPKcqY+UD/1/FG9O0B0M/s+qsVI3p9e2Fe/HTrRChgHbLB4lkN6t+ZDX7X cRpybkumfMwNFFU0aqmzzf9R9ROlQlXMYzGWoQrNrFve/SAtaDQj27p5BEIya0hOn/J7OSwLpsQk TARdwSPGouJyOAZF7XjIVUMHJ2Z1PErd3DcvOh2EUCq8cmeYv66Un6shUSgwMo9aFI8WSVfVzmJV gma8kpa16nBWFS3SYYEa1UVVQjphXCaWCfZY5giE3H+ysWYIPngxQnQVZECLRKTEC8BIq+tGr2VO Oq89P+g4G97ROBv2PfujvIJwH3BjPhB/DOcn+7V6N2FE3wiA/pze0L8+4iz7Y6Lrb3bT5z3WtbJh um6lbrxetjj5OuLS4bK4YnFfQQnrYfAyYF5PUdEXv4nlZ0mPG5T4lJVDM+uS9255bdOwtHsFH4vx c6YsaqjGkVzUohCrQ9J0CGjNUYGQgQb8hFxnyVDPoFJaC9oZWdUHzYGEe3CBBUP5vhUswgGjOk08 oVKE7l+GShFFgFZXaKo9+WRDDbvsOmr9cuK0CEy+U894BZPiYmrn8Ms7QkBHCSFY24cEhFIEy3U+ /M+gRugxePkHm5MdN5OJYk9gCyjISVp8Ug3DQKEnt08fgiykGMLHASofKMx8oGON6Kum4q8FQL8M 04bUP6XLv66f8HTZoXpAH9tvwzQV/4LeOq+dzR7Pk8iTV/XAOtHRlmAZCnlOrP7SfgaiMUzqZaaf Cuyd+YvyRo3Qk4VAksa3JZxlXAIaiIKrnGgFjVn5mCISNkY08MjpDVQFqasgFWpakQ3au2ar/lqZ QFSvAEtkIGUmtSqqBtvXGbK1dL1XQH7Ima2byJLhLEFW9XflkatKGzDVA+gpd9RaiwwhdwoCd7Sr llX4cMAmzV6Go6SukENIBRiq1YiSSFcFJMPvpUm102Fn3C2vWTSQwllN5Wuio+dGesngezeArFFH YViwMGxbZcMecSZ5w6mvZR8oWAzyujKiQ7hyKHPzAFrzd35lZpXEX0dsXpC46XmRtwCvQN+gKB+Y ZnNEkp6HslbWTE/jEWfCMUzMW6gzStFUkfb6xRyqBQvNZMILWFbLzkAQfWBZBR8VaX6/h2UQvJ7V qrKlGs1aOPI0h6kyCpU6CvbYBJ5xxYTGpUUjYdUwubNgwpnimRUg4hxEpnaCTeEpmS8V4KaAIpdI SzGifiuQipjSbHnwYQmGH/C1fkT6RBNL4OGcCOUgM2Ckv4tjtQ7R0vha1CpeUGRbWr/2OJglwP2r 7GvSgcMZdrUXNqp8pCbISht5YUI+xi4qH+g7kBKYXA/0Rz/T5Xnq8RyfHzje3yQVf6Me0JcHHvs9 /oMupjs7T+vfqpqRAIxDTngNuOVKTiMx8+b8XPvx1GdDXgMXdzoEXlNStLPwQCYruMhrN122TlSc egSl3qbchqzPoy6WEsqsaM2gQTapo+QvDD6SOdPK6GiV2tGMbvBaIWlMxJKaB68Zwjosy6umuisA ltqBQ/BZOBzhbuXcrx5+Tb/SKYjyNeSCQxOOOoZVx6pa+7MmKhU+aCAKqnO0/1ALYLV7R+au1muS iaeTMJnnE3JaX3xu4DpC7uPg/ufEszo6WTtMs7cCnS5PDeEMWAc91/SjeZu670hE0bkplXhqRPGB BgMBQ+jCPgduDn9B++HZbmpEX5YJu2oq/p2m4f/7jwP+9bMAf0u3/zgqoKAyqbMa+S6Ehw9VBfG0 p1f24fEStlv6aC94kAGP6ADzgHgYNy9Zq8lrtEVE5WeB0Vit4xRkATjP3uPhbEk1sVAzaLKbJauw lmFhCcGC89wCot5M1LBL0+81fPRaYiyrjEYb7Qo23ExX2IhYlvoBg56N8qhBhBWI4pKCgeVj8eqk Was1uv2hFlwmiPfEs63jJkMMK1AVIxjKqhZ2Kkgye0wgpHsJfTVjKN+f7BzJis4EYzEUnwfyGmJJ x1JHGYwYpHeDFbJ2J3U669Vaf2K0lrQIOQwDWZVFaMevtdFs8MALP292ouN29o435gOdV0a0FyTy X8wm9NyIvu5M2HUACI89b/7IKgmfPKDfeR3gJd3+iO//mqDyqc4kOWNTeqcqaNMB8gRE7mMf6ePe nHEjnWa1BnVJ5JDofXXLoew47gHllQtCXVgGmBfh0sOxPsutKiNXQtUgsTJm1Qw/qcqX8NyyWjY5 0bNiYD1jBh+tmtYeM4gVdGIIPiy/gpAWV8pu54a1vQUtVtNCTITJ9wFvo3MmCuoDVUeesICVA6bO iGENpGTr4Jb7NEtlM3/spWsQaQ0QH866DKWMd8a6RkKUesl2aU8ZmngWFeR1RJ32jgl8OqsnkgiL 9yGGTicRlshwSZh0obQZaXCnnqL6QFF6IyUMMx/Io0BZZ68yorehKKG93PRCJuxWpuHrTNi8FuhR P82EfU1g2dInvqGLpAN5NdSgy9x4Gp1XHuG5JQ83gGdBv95Om2tw5NUiKZLNDYGjnvVYDfHSuKOf BQGtg1nPaKh9hbo418SYtAxEKNm2y5S9j9aIWMKnZKGTp/jdjK7hg57SV1MawMADalZGdOMZdLqH Nbfqu4dKCYWpeT7JkMHiuA44hidwSRr/Awq/8JjHpN4n2X7gE5qqhKoGVVoyiDpB3osPc7OxKmSU eQ7o0KkgpMonapEheFZNTo4CnmDZNLN0DD6So9eSkKCjO6xKH6ybVeZTdaaWef8YOsih2DRBoz7Q uRvRdDw+IAA9YyOa3sezWSbsJrdrA9BaJiwb0USfrz7fN9DnmbDn9E1sQaa44evhBR13HyHdBDai ef3scylEBRaUPNcS8YKXIUlZCfE3xZ4Q7x662uUo8+Q7XXtb9yhRT1YZr4VmmB2VmSgvqx7MHl9T Sg4dRI+/cwjlWS7b+3I9kYdloZqymDvjIfp9GufbUp2ujHJWDAoI/fG45AnVA89iyYhdFUZ3zpRO +T4PYrEK09HicdtPUIUmyKgNHtQhSywnHdczhrwkk31fWkDmEMo1Puo3a6ZLm1Vjpx2neRiElLDJ 3PIMH63It5IQMbeTlgmBn2Zlnl43SmP2mOyrtrlZO6150321MqKZpdLS+gmd7F9MP6fLUvG3AkBP LzOiZ5kw9oF+NjOiax9oSxpv83AnPtD4GnDgwUoam0iikSeSoU+D40N1AOUOr1gA6MCR2xGK2pGV Lb1ZI2k9R7DHEoRc5xHKjJcJlLA4uHgIRDg9aKs5QFE9TAuhfFmgDB9XSap4cqW0uT35LOvV0pW6 yTOE7Hm5MHGSHYMVGB0RgsFdAE6tdqoTTT2WA2r42NpfPltD4yptkgAbNAfaiQjmOUuCFetEgUIn 2OLbaLk1YQrInA1RUZ3VFGXwaHsZ164mD8utbSeZwazQkVOslWykLpQqa9TG7gHL9751a4KA8yDo eA6/PKH7dxsLsa6Qin+bYsR33gvmRjT7QA9fB3AjuvaBthyCncsoSfWBLqY+0NCpo4wd/S96G3JQ K3cw+FidHtoapaizL9EWOdCx4Dmu17DLH7KuK28EzEZhKEopTHyBWRp37wCua3VsIUMpdsQZVEKB j9YbaXreh5r58z2ss9cOk1AMzHsqOZ5cwKAwWh8hBHcQOmt/7MzzyXCyCD1/ZC5ccuWzhj3JB/k4 iPRzVt+n/vhMCfkSBBw3d9nIjl5LFDqt+pDwXMpkhSklvIrBVbMpIRvjq7ctZB+xDL6zPVXuK0a0 FiRKbi3odFHedR6Fkgn7biip+Pl2tpJGfpslm/vrPblc7gP99XbqA7ER/YczH4jCq/A9q5yeJaKG YSf8zfHQ7QtekVbVSq/1oJhIDfW8Tjb03AImPhDLHFdCnLyUZneQPEX0vp6g5ct2RnJVg3nWr+06 e1AKpSxeRG8qRWtLA64QPcypBv5gyWaFWt14jZDDJwRbKtoUkoMHc1hXXie592QJOns/UJ3Zp5MV Kx9+tqoG3PUK6br3K1UpeZiWTBl8sLRd2NAM827AoGS/iDq9oBQX6s4DDBg5Q5qJDRZ+y9CNThfZ kSRr9AZl0FG9Bh4d9wv1fqIv5icbVUj6xcFo88YlBFQVJPDpiURD3ElmZrRMGEPohG4ygF5RDEbH JboBXdcC3dR2ra1A8wKkP7Vr9oF+5j7QLAzjeiD2gV5XYdjv/BTDYRiBhb9WDsPO2R8i1bO9KGGY QAjVgguj9QQPoClNC8OC1lOICgJftQBsnq+u+J1seEuyJp6ks+50CV1feE7X/LE6EPGAsaikLK19 R4UJlJZm00zSWHmBTZ0+BVBGt2YF5Fm1UHrRsOyknBTptMY/dO4h6FmV07pyqW93Jvs7e359iVb5 wAVwl16k6vs2XlAvS+85VH+vfwah+mz080EbQwXVxUZTYfndYP+eVX900hdovyuvrUu6S9/g5Pex 8gDzNWrLoP2se5Ku9JtnmVu5B2CZrOlZ2ISYM7V8ju83GoKhhF0x+0AOXZ7Fzk2pZ+IBab3Qp/bY zmqB+DYXI/7xG9b6vLMQ7Fgf6NgwbEOwPuPqzCoMYxP6gh5/uCU1tLMFAaKaz2lUFeTwSbJIm4Vh aUh8Ihp1He7o4BHVah6QhPB59Av4GS/lGo8AZVVLH7cJPjEjw80qZSEv34IrUtFVUcCZN1NlbbHK pHlKv4aSTY8pIVnwWVllnbG6A94WWIAwfWP1tMVZDc3lA+/TbU2PwcEfJ16Q23s+e8dqBU3AuJIF T7/nOsWkntDsM7AKZ95tQh5k1mnYFXVvVZMvppwV9aZnP6lw+b1Y1/pc+8c1hpYOWQvdpejIR1Tb SmY2zkWbJuX731iYBXbbU/FMw4tZKv4sPYMfBp0LxMcaj05eK0a85NPHd6mAcC0d77c5DGNKLYVh lo4PHoZxNoz7wgaShK/ghSz3TjRChlAPpoboU+eBStKaR6ondkSJEXS5XMkuqGKJrnxEyGrthjcT Ive+C3pAFo2LWseR1FEEnXCHCjF0j9cUjS13gbVKQsty1D9PAJX39GVV5NkvH93qZrPfniuisqiG +PPgxY9YZUs8wwbBGmW1ZTurnGDS3+T/RBmFMB0tEhaeA+V1buVl8W/Bcr95Ka74ctW6/K6viuJQ KKqofA6mAlWF2u9JqWys1ai14mBWrliF1zYn2tWQF55GqJqUNeOGOUSrpij46ike90HX9/LmegMO txVtq4M++tB9Sz/3WYpsZCjg1tQRb+fp5s4R1z6N4dIw7KvlMOyfqjBsRzA67fXiYdiDXkucQecS Yn8eBELWfiyrAUjvMe5QnjNK0SnpHlU6MpswDbZKJWRlA7mMXgrmE2bo6Dre5ioqkMRWsrGbut53 0qlR/rv6enZ6TNlsrMIyrIzrysHGpS9lcl21WvipuJhVGGvwBF8csaq+rnd6sHRuBZRYhWL5eSlM IFVf4jEXfM+XhfdU/gYof+sMUJ2XmQWblKGNxRq6OYhkMph+zG4El8+6ymxiPS/cerl0lphNWLDq 9+jV9Ta+t0pMgGl0fi8wvei/EnUeg0pbq7tPWqykF6sDGjda+awX9f/O4f2K12sH0GVh2C/smHv2 sV5LGBaLCjr/WucZuAoa2MPZFBU0kAradqo9dlEV0bibqqAg67np5Do+PkdTQRo2QfZ3vOo0mArS xSkdOEUFMc4UTAolVA9JoGVVRHWGLKnHhJbrr5WRrXdnw6RglkU7lE2r1gQzM7t0zlfedsmmYbnP 1ygLWJ9xJ/7RBE7VZR021tlfX45RSu/ykt/H+nvsHMBYVFB0OPlngPXrVL9jy+xkCOUBdlUYFSGW NeEgL2EpkIlYEg7yI5jikZOMLmjp4BHzOWK1sKXVaNhgvaptp9SCVRfPhm5Cadv38PlhtZu9HNOl QJJ2DNv+4pYB6GAYVpvRF1UYVqugdDZVQbUZXaugkVeCvNDzCYe6cxUkU3ZIBfF6pzrGG1JnKiiD CGo/J62qIFNCo6xgiUUF6ZrevP4Gl96DqyCtyNaFnpKNcjCllT0Fz/dnhWTNAmhGBB76sjDPig4w GViPxbxOVZgGVRat8o4ERgavaFmUOZwcYvsAMpO0vszUT4fvXwXZDO/l91grNYdurQprKIfpZ6Kv N4FQ+R0oClQ/T1NB4GazKNZYL1YJnoTIq7VE83F0QmwBj5Vv+H6QsKTcUyiPQWVUQ714QRVahWI2 y+OPcwHT4S0vVLhSpPjF+1RAh8KwJTP6MhXEHtCaCtqyz7YBPCWw8KqQcy9I6n5GNY5TDsdkIWa9 luW1QVf20XUtR2nkkGpWBYvWT0uCQNUQCyqQlQ5GD7t0ZW5O/IM+pkvtKsAUTLmATfcZ1Owa5rSu qaOJL4THjBSJVUItxiqvX9LpdRf93lr1NZC8tN/24+ghho2w8Vq4oy6Qu0n2L/GGL/W/dfg9WuvL DC7V5xJj9dkZsF0NgUMIrU0iwwkKoEpRaXkdC7UmGa1Unyi8oTnWqjbm0DvF8ntx4WBOSyNVNjq2 uH7eTooRVQVxFuzCwjKuhuZ2jDc9/j9/zwDCp29oRi+poI/ssuYFhR1PaxbfNnFHvGQcBgaLqqBo S+lKICVN6gye0TJaFoLlNbuTAsWGSqnPoypIIGSAshZpCc0MNqOOtyvpe1E9kFVQ9o0se6a1k9ZR DVhaPaxkFrNiwqyUJiMjFj94nK68imvgmakkh045YMuy0qEK2arGksl/BzyX9+INHfp3J+8bppAt pTQVlJfDVPfXZiGwQQjzi1WfPxYoeRgm78BWaLHewfo7DJjnnOcZ4dl0jr5UagUv9LRuWdK7Plv1 XhWtWQcxpW2cVq6GzrA6Qgn9+hqSnzc2EvhYM9pV0OsjvaDQv0BXQYOoIA3FZA7cTo1nUT4xJQpn MfH6FEnDo858HqkLwkEGhtscl9EMaQGNXoIqGilplLWcRBnJkiqsjEQdgSgkBZY9FyoVhKC9skHu y7BzFaTV12pw+1riIa/jAeX2tOr66BpBmH3RvmNjzqpAKGqh2vFncAmz6lr1LMolFPF2qy86UbJ6 3zOfTP/eAqOJ+oEpkCvfzUOxWuV4yGeftzQdA0KuXi+jWT1EQoVRDZm8TJPNe/JlmRBLSBbzQRzz PKzc61UpodF+B035XMfBfx0d8TcGoDUV9KVBaK6ChgUviOuC3AsSJfR9wGewCzuC0ED70gkvV9LJ KBNeD1uvd6pyJCSDHVFIpn8n/s/KUBO4ytHBTiMaeHTtptFWsLRQDKah2DiBjaqfIA3G/Dqot4OB ycEidZHgEPOJeSV75tm4HI5hqtoAMFduVytyQi6wXpGh1Zk0r8ZaDdbACjo1eHAOmiLQfChgVkfz yzzcCzPD+z1mw/ZUoHkunlrX+duaIq9hlAGTcKJ+JuGrLzQ5UUFQQKXtFHHxs8LaQJaSIA29RNJX mTArbQcI06WZvGwjZ+DVwMwNpwwevtQFf+nk9pRq3RSA8DIvqFZBaxkxrguqVdCLHd0mCD3oBwnF uC5orAxp9oPYkOZQbORQa0g5FOvZSK4MaV1ebhQIST+fpucFOrJWJSqEBEYSamXgDAob/h0FjhvU 8jrMQYea9t9zOeSIbnbn+/jfExWlc4S9LMDS96aCHESpDsemqzJAyaTBdKzEASiFasmfEKr50hB8 EFtek34VLksXW4E21xUd+3s3eUmlpGD1OQUOmM1gyylZaLpflwUlK2k/417Ii7jy72GwpFp+jzmk qtVNTi5U7Tb+WKrWh3Oz2XeGZN+lV0NL7xfqenr1UX+epqHakzsCoIMqKMxU0FpG7LGFYnVdkBzC FoqxCvJQ7DFbehcyITxxKJYsFOt7DsWGSSjGaoQ9H87gJxzsoBePR9SPqhcpNVX4eCjFy3IH9sFh EHXEYFFHaqjAYiEayAIoWMEKzbjW37Vl7mXmo6b6M4CysW0ZtUoNVWND8tLleZ1yPDz3pipPnQyy r4fbY8hSfVJNHapK64NQwenv1Gf593XZUywLxvy+SkJXNh6u5vAVln4Xp/+mt6TX0wrysmNYTS7A UkzombCEXqkeYTK6Mk5Xxp2DyrcuTKcxAFT12bbucF3FfkxrxB98gAA6SgX94iuF0FwFPbYesWQq KJzwCo8roRhBSJcjKaFYN2oodjFwCEY8SiUUi6aGtIqdgJJGUyigHo52kI1SIAR8cSWLVZgVBlFD 7gcphAZEU0Tq/dBzgsLKgCX/RjavPfyz0Mx/BldC0sOWvCUEalO6XqMKoILSJIO26hlhOUAW4VNC tX3oQAUoXAhtoPIm1sK193GZv589QOEcRDhZGglmiqlaNFJ9mjwHA+oZTRCmUyVVRWnKLsRqJlOq +gLBl4uyCmf3c2pvJ7fPxL2llkwtLY3QXT7kH11yMD/6EBXQMSrIQzFWQWxIswpyQ/rLmSGd1kIx LKFYN2hqnuGyG9Xe24yQLsIuJVNArIRGvgRZQ9uKEc0DElNYoSNrOpmnI2oGagiBPzbI9ALIBrSB SAaGjOb98KgigRGxYvDfRQORjiICh082tkPwzBlMw7OQIZRMCNUqCKshWvWpF8MBB3sJPtOWsKpV pAJMbZauqI+pHJpdbjL0mh/9S9Cs3z/A5O+GyTJHRc7Uvz+ZbhBKGJbHsGQ463A5yMsh5SXEMafb 5wPk6u+gTLlEmKfbPeQy7yevgVd/15798pqfsKCa7pIHdLQKCgcM6ccWiv1onIZirzwUe2mhWKeh WL8BPSgpFBu1QDFtekjnQfwgErS7tOUVmEEzT5vAty3jFcZRPJdkZrGoIRnqoWGU+kM8SZdVjygd aSAuIRqXZw0VrAaezWj9+K6a3JwWmE3u9zqioOa13+/eU10ygFZTVIEoN8/WWTOsZl3Xg9SgQOzS 7FmoFFANnjXIrHpDlwDqhna+PZUz599cwc0zhViFY25MQ1WNjFNlFObhXPZxbA5UCbVmtVxxGlbV iqc+QYQ4+ZxXCeIP0klZVsDAhUrhixUYvbQaoGe7m2/TeBcr8+IxKohDsa9WQjHPin36DT12UmqD iOYEpR16KIbnMTGMuD2DQzD3gyiw5ftS6lPasTNtflCQQSyeHWPPZRzpJJXDMAimhIDLGlnFmCmt YFBFY6FXyD6PQMhCL8mgDSE/p5jS6hVlOHHZhXtH9m+bCip+kJYJlNqhlPvNqurqMAvPIExbPvZK 1rNKgsXG2PVK7H3orAFlzZN5l5cV4MFc3WVzfpIxVOWBs6WPZrDaW+wxg3q2eGS5tqZjfzwWVROr 8Apmr5tCHY5h1m1LB3M9utPdn215ncXN64GGdzAU6p1NRFyaGR1sYFm9gKGHYjyu47WN66BPDB/S p8VDy6T57kR1Lq+oQaFYCCcDvuZBAcPjwEoonEobRujGEHcdh2CkiHoMceRiIJI4aUix64Pk1LmA 2r9DmcYxEimirGaQbPSUrpibAmLMRXvBVzH1MbymNwDypGEoFmQeVQZlHgdOa5VT7hGyifqy8OEI bl3KEHp7Dai4EXxBczTvQV4h2bD72gvyqX57Z0k0HwgPKIkVKAEe8pfmiup9tT1O33T96ePsYTQI 2Vz68tlVY3bBJpmUcRO2+8RYQrF66ST7hSXQTTKU9YfmYFoY1r2nnurXwio861WS751AxpnyObeh ZHcxBJuooKuEYgyhofKD6qzY3A/iUEz9oBf4CagfJOEYqZuhk9CY64K0JWNUU7ozU5qVCw8hi6P1 gHF3exqtZgf42RaC8YXXh+PhcpLRHFAmV7L4CgNnxtT/YXVjqieoH2QhloVvIZvVOTNmYVl5rvzb al7nlL2GaV406dXadtsVT8IA+9XV+2ooW0QLs4rKbGQ4uJLE2nEOa8YPZt/jHV/CZKTJRLkteS44 S4HXKsgGRc9N+j0FlH1hDBPltADzXLNjo4fy68wPzhT2lRDUwO/2vstVX6T2glJ4f1t8l+ehq4Ri V/GDdtkPGgg8FIaxCuopblowpWNUCCVQU7rzzBiFXvRpmPfDvo5CKEkYZZkxYFWa5GduUyPlNPBI oogajhVw4JAhZCGWXhhY6hFJ+IayvJmEcWJUg/lDnmkrYBIAZgiFEgp6aAZ5KZdgzdG59WMSli2G aXkA/0zQVCb2ZeEZLoEnTKEz3/He5WVeC4VhkkmCNc9rrkBwYQXafZU4GQi3WgpRVTAXcC0ckaUg MS4etDg7K3RHxDe3ZeRufNf/4JIKqiukDxUorvlBF+4HvWTVVOqD3JR+fUGRlxYpJs6IRamUpoO1 243J4CMZMkZRLN4PxNEMaoYTDDZliAO3QTJiYM2rdT1QKEZ1BaGhhpCn5+cQCnW2DFUdzbyicZ4Z C1jS9+BZMc3qTVP1ixDKU/jzSMAqNMGr7KjzMOsy6BxrHr9l/c/BfxunK6btRYqzOdm5iGienVrw w8rrx0vD2D1vKE4fgKWjdt5wmiofKX/u1TM24XZu7xpAq6HYUpsG+0HPZql5hpBXSa+Z0tuT7yem dLAixc2G3WTNjHGl9GbkBZ1UCbE9xBkwhlCS5XCtoVTg5FCC0SBBv86FhsBVjKxqOO0ucMnAKTVC exCSjBlqOIaV6sGc2le1xdOt7b7BIDPPjDmc8tiQ4PVDOiokp/JhXjuUB6znPlf0RRnrpte1OUVw hZNoXD5r33hmbO216/eD1Tjcmbk8CZPm721uyMfZ7Tmf4Q3ssBxyxaP+1sUvpn/P9tutU0DH+EF1 geLFgh/UnQZ8XLVq1EWKu+/p6NvukmfG+gtZGiPtDEIMHgquuHNebifCC0PIvaAQrRmVYZM0Pc/3 QfKDX4GAMvAjcEW1eEAKmRmEgimhaSYsK6GA7icJiARiArOcFbNsm44DGbMnFBRYNYQAQ6kj8nBM M2VozrTPPvJ5VKXJy1d9wGqJoho4UNQQXFEZrYHnfe3wcxDVYRVcEmYuGGCwdnzD7LWneanlxybg W1A+S1nI2hfyCYglDutv/bJK8X39w8f6QUum9LhgSp87hFArpXf9IOl5botnCO0IQp6eZ3VzZu0a A6fnR87MD1IjlNAHkGmNEH2jAiGi1Nghl1QohEZQsxmxalyNBUKQTegKQjAxpgusPDxTE3sIBiF7 rpjV5hO5n5TT+VCqp827KuZ00P42K7TMpnSa9JOZT+RLz5SmWJgUNNYGNcymOB4LpNs0u34PQvvq B5YB6oWGU4tnKdV+SHmseUn+L8IbHrjo8NGCMqjDryHdPh7F9/f9H+cHLZnSDKG5KZ0MSgwhPoge vNyH0MtOsl7SKS8L2LIp3ctoFakRYr7QYS4FinMIcY0Qr+fMYVqyfjCQxtNcgOgmtNX5VJ7QDEJ4 AELm/2RjuvKO5PWsPkhVkCohqdwuExqLOR1sXjUEyDOJqgLGNG1qDehr8FWL8QUI9YofU9a8aUh2 7HYdBUBXBSK8zZs9CJY3B3M8Mgu5917maqwpoKv7QUtFigyh38T9zNjpRkH0tVbHCIQeVBA6Pyvp eTajRzOlE0OIrgeCUIyDVEQ7hJKsllEg1JNUCpaaDxlCaSygCQaZyoT2x1gZAU/NL0qI3uquhhCE ScuG/mwQkrS9FkMOmCuoFU4GIe8tSzlDpsWRCacQSvXg/FLQWAxqCPt+UG1MrwIJpyl8fAvovK0p HY6EUXxr+lwPaJfCqjXl9LbbtgHo6hByU9ozY3MI4TclPc+ZMW/XcAjxcj4vzykUMwhFgxDXCEn3 /KhKiIfA6igMTc3XEEpWLS1KyBpWAdQTmkMorEBIe8dK1qv2jrBSPTraw9o9HESSXZtBCK2Vw8sF rIr6MgiFaZX0JDMWqiWrcd8PWgzFlto7rqKS1qBzHSb0Gl+WfJdDKfY4gwDA1ZUN4nIWLb7Do7L+ Jx7cYwBdCULzzNgShF4vpOcdQh9tvk8fcXr6MgjJNMWB53HozGiDkBT5zSAUUbJgV4KQqKBQPCEK kXYOIawLGDFkA9syYHsQsiFng0MI1yGUYAFCHopVBjWWFYlLfRDWDa4zCO3B6A1UENywV3QIQsf8 Xl3XA0cCZ+1vgrf8G6576+45gDKEwiUQqjNjNYQeHgkhLVT8Pm1nEBou9iEUujTOIaTD6acQYoXy JhAKVkUdrIK6QChkCGl4NoWQFSRmCIUjIGRwGfFqEEp4RQhNvdoCoWNU0LvwJw4dwAv1PNd2tGO4 9cmoew8g+Z5+eQmE/s0KhF4vFCq+Xi1UpON4BqGOZ0zPINTNIORFij4zyCEUFiDkHfQTCAkwQuX1 wA5nEPJUPhZTu8qQlVS+QwikK/9yCIVsSk8hFEJJzy9BCDwcW4HQbPbQnCMY8N0C5toMmZW7FwsI caGzfdW/QWiQur0ACkuhmEOItzUIDTMIvWYz+ggIscnCEDrZ8JphyxDaGoRCp0WKXil9CEJaRJiG oyGEGUKqeCoIZRW0AKFQQcgHoV0FQjaXqJriuQehtAQhmBY0hsq8XjSlXQVdtqrHTWbUriXT1aBx twG05geFUGqEvgyXFyp+dnochLZbrZg+BCE0CKU1CEEFoagQEmM6ziDkdT4rEArST1YghEdCCG00 iIdobwihtAoh2IcQLkAIFlL1ULV5HAOh9xWGHRojcuXXfMsjas2gPva9dA1AN2tKh3B5oeKxEMLN kNYgtDEIDZdBKFQQCu8eQsGyYeA1Rj5LCEp2LLwFhBCPhxBeI4TgA4rabtPBCw1ANw+hL8NyoeJ1 Quj1AoR4jMcehFIFIXxzCIXrgFCYQGgonfRvDiFbWrpB6AM/0BuAPjAIhQUIRVl6+eYglEIpYHxb CIW3hxDa6Nd0FQiFpoTadkcAdOsglG4YQqBzom4LhHKW7CoQCg1CbbtDALpXEIIGoQahBqAGoQah BqG2NQA1CDUINQg1ADUINQg1CLWtAahBqEGoQagBqEGoQahBqG33G0ANQg1CDUINQA1CDUINQm27 vwBqEGoQahBqAGoQahD6MCDUQNUA1CDUINSUUNvuHIAahBqEjoJQI1QDUINQg9CNQ2j+eFNHDUAN Qg1C7wxCNYgOwaeBqQGoQahB6MYg1MKvBqAGoQah9wKh+jkNPg1ADUINQu8UQk35NAA1CDUI3QoI ta0BqEGoQeiDgVCDWQNQg1CDUFNCDUANQg1CdxNC1UoebWsAahBqELp+CB0DIryiYd2A1QDUINQg dBSE1kDUwrQGoAahBqF3BqEaRDV8sloC+Rfb1gDUINQgdL0QwjcIpxqLGoAahBqE3hpC4QCI8IAx 3WDUANQg1CD01hDy8Kr+pTmQBFSXwKh5Rg1ADUINQleCUAjF12HIHAzL3hAvDUwNQA1CDUKLEMq3 q58cRPXlqiFZA08DUINQg9CVIIR4ueO8ChtosGkAahBqELoEQngAQhNfaMEIwkPqBpvcaQBqEGoQ ugRCUEGoYkYGElSgmgugpdqgJaGETRk1ADUINQhdBiG7nvw8Uzj5shZ6HZO2f0sPuwGobQ1CdxxC Jfy6QoMqLCily1QPNgo1ADUINQjVEAr7CghvanpiA1ADUINQg9AEQgGK7zMbv4ErYdnxO0Q7JhqA GoQahA5mx5Q8EwjNQTQXLwuhWyNQA1CDUIPQ1SCEyxDaM6WXPKClwWb0ebT1xRqAGoQahI6DEMwh VPlAdc3QfEzHUtasAaYBqEGoQeitIDSrA6rrhhabVBfXFMPj1M5cQdHn1QDWANQgdJ8hNDGfYcKX ulNjXrjY7J4GoAahBqHrgdCsSx4PzI/GSzyha2fSfausbgBqELpbEAoKIcPLGoRCnabPQJqOcZ0o nwydhVGvOAmzlucHNf+oAahB6D5ASAGUf3YIhQIly44B7lVH47oKUogALvk7DS4NQA1CDUJzCGEN IbpKE8VTpelh1hMG0/sWa4EOQacBqQGoQeh+QygtQIhZ4/cnWAjJ5hmxKXwAcS8wO+DlNAg1ADUI 3VsI4QEIsUddQjIoIdlSXZDDp/J3sPZ7cMknutRp3n/efQVWA1CD0D2EUBAIuVldUvJgiggqoxmy +Tzp2wizgUPzL77t+w1ADUINQksQggpCuUDR1FBRJ4AL8LHfxUmd0FQtXX2Z59UdpwGobQ1CHz6E uD6ohpDf1pCqsn3QQBQqGBl8lkKkeX2Qf9fXNTGxAahtDUJ3AEJepIgKH1cr9GnJ/W5Ol56xCkaA 0y56XB7rceMq5656RA1ADUL3CkJgCsgtHL4/5LAKHTCTjNg0xMKw9pirHbAaI/OYbmyMKzYAta1B 6IOAkILHIBRcARV4VNl3B9HkErCIH11LbDa8DGZrj2VA7IVvgGuh2VWbzhqA2tYg9IFACGcQqkzp BLNO+bA/rH5SMV1nvybm8+Eu+UtXJbuPXa8NQA1C9xZCYVIpXTyisACkYlpP78c6Owb1DGq81IS+ bEXWBqC2NQjdIQjhDEKoNUCTFo1K8ewpIlc4S1muBYDgoXGueMBcvk9FiQ1ADUL3BkL0O6NDSFLx oCCq1E9u5XCfCEvmC/cyZfV8ITi8vthVNmgKqG0NQh82hHAGITAQOYTAIGSFhyksNKSG5XGtSyHa xCTay37N7Ok3hdRdVEYNQA1CdxJCYQYhKz7MEFIo0d8NpYnVfaGshnAZTmExe+aPWdPqvG9soWJ6 GTBvx5ixAahtDUK3H0I6ngP5MYaQgod9IZiuJ1Y3p/o8oXlBIsyGlC2NcV3vsl9zh95wB2oAaluD 0PuHkPw7ByCEOfOFUhHNtUJBx3RkH8inK2ZFBFMfKBck4p6BPVkKei0ThoeQcU8yZA1ADUJ3FULj GoTofn+8UkOlYDFUI15DVSdUh2NQMmNV6h1ys6pACKslfnB/PCvU6fojl4q+azOjG4AahO4khHAF Qny/1QHJdYYRh2MlQ6awgQyZ5FmuUM+PxlIVPRlmhiU0C7Uqgr0VWfdGut63uUANQA1CdxNCYRlC UCAkisjqgaxQEZMWLbIxXakhqHvGivKZAsZnTKN7QlOPBwARMawNvV9SPPcBRg1ADUJ3E0J+X+DX XYSQqh/UUExAlAfao/lDkiVzEOWK6TD9GVeqp1XdTJnj84aqmUMVdARSEwB90AZzA1CD0L2HEOmR cQIheb5AaJBOec2YVaFY8YWAL2ggstBslk7PUxRd/YQqYzZTQYuec73cT/DwrfZ5ZpMY/XdSA1Db GoRuN4QEPBWEsABmAIFQGB1CdWYsVJky1HS9ZcTAPCJwKFWqCCdtHA4U2Fc8k8mLeISxDHsIOlYN DQ1AbWsQel8QMuDIfQwhqCDE1/QaBUJhWjWNMG3NQFNEYS/cwulo1+CrbVQ9ZTjrhHcczcGD9Uyh yYqtq9g57BNhA1DbGoTeN4TA75tBKBiExJQOkEMwDNmYtsrpepCZKiI3rMNCgaKHX3khRJJhda+Y e0MabpXlfuyxZXysqKTr6Bt73QDUtgahdwshe54qHkAxp0UJoTWuYm5iTQi1QV1qg3ymkKfXvX0j t2vUaXecTlLMnfVlgSCcutXrodmeTxSWFVV3ILS7qG6PDUBtaxC6eU/IIWSvp+EZ6v1eC5Q76StT OnfMl14xrFRRHnQfMLdl7KkgYU1VM1StKTZ3ePbqhOZpeYPXohqK07XpV52g22JiNwA1CN0LCCEa cCQEE7WjoZim4EcMpSARpUEV3JTWeqFQRncAmioCa2DFvPpGHvXqPWUcflmA5R3yVTsH5gxYrZYm amY/Lb+oamLxjvYkjcOmv4VV1A1ADUL3CkJQQQhC/jdsjIen6ifmtIJGQjXLlGn9UMoXqPrFFgeZ TZf+mbk8ewPN3AvCA+HW3ICGufe8EFfBLRw01ADUIHS/wrEwS9ErZOTfkFAMrZPezGnzhdQPcmMa y8gOrBc+xOIF+WgOwQFUWTIoq7CGxTnUsOcFKWBgLxRb5EmSF82Yu+2J+AagBqE7D6EMIoNQVkHS jpEhxKl3Tc/btZvTYCFZNqYrU3qSIYNqyR/3jcT6Ac161SoIpp3zdXSVu+jZuNYQLuQZQzP/J9VR 2rgfoGG43SBqAGoQuvMQMgN6J495OJZVEP87blZX4zwmkxQ1JEOZG6QgKoWKUxiFPPReU+/m7eRm VqzS8P6cTB8wozqDBj0tj/PGMa+GxtrnmQdqw+0znRuAGoTuHYTQQy+vkMYCIVU68lwb1aEQQg21 Brse9fEJiARGaD4QlpYNBwurHweSpuurIWdSBuSLjklYBsWEnqblJ+uIsZpKFYsmCmlvT7j9O2sD UIPQvYEQOoRgCqH8mtJFb79fmdNqSOfq6VRMalE6AiQoTauJPgqHT2678NS9aZvFNelx36aemsxY QrG9KulxqnKijgRoAGpbg9D7hlAQCGGGEIYphILXCKlC0pU1EHJWDOtwzEd8oBcvKpAkfe99Yz66 w1L0WCYrTpb7gdl411CPgq2UDTpwMHtGoVZFoYZTBaZDAui2pOQbgBqE7hSE6Pd2cwjJ/ajqBueq B4sxbbOkc4bM0vTs+ZRQzI3qApZcMR2qBQ6lNgitYhrrKmm2llkhAdaD63FlVY4AVVhWh2JQ2jai D0YDOAoqDJ94S1LyDUANQncKQmq9KoSwQIgfyxCapONz6FW9Xu4Xs4JFgDzs3pTSiNMO+tGBY0rJ M2KYV2FVR1nuDz60DEvBYpW2n0iTWMZ71NBBb8OXIkbLjEElhMYFI3pXwrMWgrWtQegmIBQWIBTM 02EIqUqaQQhnEKqrpjXUyj1kkzaNetA9qFcEDqSQixS1kFHUkDo9plRKIyv/DNUkRZh4R8HT9rUp nTNnaT/DFausWUe3Pdzy5100D6htDUI3DyFYghBaSp7eqgBJUvMzCEHJmIEqotGLFmWutIVlDqJZ z5h30Gubh8EH84hXzMv/ZP8HrVoaq1EeniFbN6WxNqbTzP9RpSOZNamArj2fObBOjgzdGoDa1iD0 phDiC9h9uQGVQjQ04OxByFVTKB31AiFt4XAQIWbQ6HXVQR+q9LzPnJaSRPeFoHTVQz07CG22dDXA DKvJiTgf4QFgxvU0/IIFKNUg2trt9xmSNQA1CN0LCNF9O4cQ1jVBGl6xv1O1bqB5QVNfqBQpWk2Q gsrqhKxfzAea6ZhXmaKY4WPhmN4vyojt46SlPZCKIQ1YrXVoI18RwzTrhXVWrFY9GKZd8ZMDHpZv NwC1rUHoJj0hZDMaFUQGIVRlo+oIp6GXGNYedoWSHfNUfahAJMPMUMOzYBcAe9+WntfCxNI9n2cM gYZfCHmUa5m6CFXvmLWIodUMeWdYCb/SJLw6NIrjsu1h/+5S9A1ADUL3CkJaaMggAlY7+cKeUIBZ xbQVMpovVJZ9Vm+ozJcGec1BG1j1Ird9eiIW+Fj63vwdTcnn1gzrF3Po1APMwmSox6xtwyqro8mm aJ6O1wcMg4df/IdfvvVGryfvAEQNQA1C9wBCuAehpQH2wczq4KEYztP0UAoWffWNepTHvhmtTaxm Rvv6Y+DXYM2qtja9FS4iFEu6NqL5mbi0hhhU5nK0VP2o5jN2bESr7yTPS2EZQa8W7tu8Azo0ALXt 7kMoXAFCIhLmYNLXoLdtvk/uFdNsWFWk6On4YKl5W/55OtRMfh+kZaMKzaxxVdo0ko3lKMPtoUrP 1xXVdr+rnwIfy4DZpYRi9NLn5Xs+iQqn99W20QDUtnsAIViGEOxBaDK2g6umczvHrF4IPV3v/hBo dg3rbnoss4O8SNHho0qIwjNVP+hhmnlD1RD7vFR0yZZlbwgmEVpUU2pSJe3bpEo63R4jugGobXcf QnAJhEL2hHLYxZ4Q1ml6nEEIJyAqixrass/BYOTFiq6KMnzUvM7FiqKEggZftsJhyl6QFSmCpeDr offmOMvz0gw+nYRg1roxKF05DU+fMV2W/Z0XKzvHlw1AbWsQuj4ISWreesfmPhGn4zH3iUk7x87v 95Q8WGhXloCWeUI6zsNDL7tIx3ywoWYSxmEOx/K1g0gyZgImV0V8K7kf5HVCcm211PTJSb02oI1y tbDMTSmp/UnFH4o2pe18YQdYM6lfNgC1rUHozSBU1E4FoVCFXgBTszrXBUHuphdQVVXSEGqFg9qy ITDyNcb0gj7SFXzMK2bogM2WRlM/HJKF3C8Wqroga2KtVtgItmyr3c8aBztH1VgM6no8tM+EPs+G NX3W73lnawBq252HEB2V4xxCiAsQYkUjoZfXDWmtUPGF3MAOexcs685LhXWdjhcx4quwgq3CamvS O4R04L12yUPV3W41RCUkM4GTqhR8HYLxPewFefjV+XKuC60YEQqcTukzfxjffUtGA1Db7j6EYAFC EYYwgxCHWlqciBZuVSl5CAVaAKVnLEyN56o1Q70ksC56LNmwKXSCjXnFUitUhWU2pky66UmxJKwG nAXLfukEkLzKqgBnHEpdQL1AIf/+fBbQSRRQ8fN0++7d1AA1ALXtbkMIFUK4BCGt0Zn4PFC1aYA3 sbpCylXTlpKfqKfSM+aqqZ4rXafovW0DK/iI8gH1frIXBKAgkmZWmHg/GLS+x2ETrSjRIGXpfGLw aDDyGR48/RpU+WwsK8bwOYdiQD/s6P4dP375zvGLaxj62gDUtrsLoXgYQuj9XiiHJr1Y8CZUT8er Qe0ZMg/JIOxk1lCwmqF8yd3zVbtG+RmxQCgEX/yQwcPhGuT16DGvN5ZHdPjwe2WOgihle5rBYyl4 nREEagVhHj4mqgcX0u91GDaIYX18Xv5nTQG1rUHoAITCMoRU9YShgwpCeWyHDjZLWKXpLWsmKkmm K9ZzhzyMMx+JvaOimsbqYsPutWdMV9bA0eETJgWMpn4kLBMwaQe8hGc4NaaDGEIYsm9UTUzkFx+t ENG4wiC6MCP6hJ/7nl3oBqC23V0IpSmEUH2eQdb74jnRqKtgaMq9qhOCspKGZsI05ALc75Cv505n GNnrzi55xQ3QKmydKy2p+7LSqlRIo8IHoLRs2ONeC5TyJEULxRBtJmNVMS1V0KjuOYdmPai5xYpo JAKde9n0FTf+Tv32rxqA2tYgtAIhmEKIO9aTwSGJ8sChQxhKE2rdohEmGTL0AkRf3JDDsuL/5Pqg kDNmOkkRtRteB90HTdWDZMZCUUJ2CTr6VdQbgKof94OCDTMzzGS1Q39Wij4jiO6PqRQfohQd2vpj 4gXtvF8sbJOGbK+DtmOMrz0D9iw8joe9nR9ty+0vFx7/ZQNQ2xqEgtbiVBCCyLcVQhE87Eps1RKQ oBjUaB3zumpqLkRMoTS3uhpChKppNUxvh5CHmkEoq2vIMDMf56oNqAIf9YB0SR8bViZqKPkERfWQ bWIiKIySNsxHM6D5tlQcWQqe/5HN4P1iCTc7mAwh4w55zn7xE8WAJpa+oJ9/R499Zd/tjzdXM5uf NgC1rUFoCqEusSoZh74jYCQwQ1hM4EEbRdMQY54nnSudta6HABI1RT+dK11WX52ACOuln20Co12y QV08nwHV86mWgg6qftAXQVS7WbNnkKyz3pbzgWpxQ1VCA71MN5a+sNE6V5k5O1s7/tyUD4PIO+E9 DX9hF37Oj+g7eXCDlGgAatu9gJAsHogWjhGE6LmsaMasfEShJGtgrZpY0U3okMMunHTO++CykEe5 hnqmkNUBWRpeh9pnQEEOu2x2kM2Qhsk8aRDFhlkR+WoawiJfXSOVjnm1hUDS8HSEa6e8puD1Nqgn 5On3uhP+eXX7Y/oOvv4Hvf1724B/+wYKpwGobfcOQtsujXMIcco7WjhGx7YVKhKIGBqkfEDrc+h2 0pofhUDOkAUzoVHnQWuWDFz1TAzokpY3AxpDvpjpDWo+W2GiL3KoBYvFlJYMmHhARf2AdcgzjCg2 0/Gu5v+g+z/SUKbjyzwORFU+uQbI0+9cB3RqFdBcB7SpChC39N28tiwZf0/eqPrVkftGA1Db7iWE CDGphlDUloyRjuDEEKLDmo49hZBWMcOoldFhiKJYksIIqwwZYgGNtnPsrCdsF3AGIqyMbCxeUF6L vvKSMBvTIWfEtA6Igckgksetgz6PcSUgJZ0ZhKJyBEJR/J8x+z/SrjGAeEOujlCXA5HNixA59OI2 DOuWl61VQretQegNITTMIERHZ4oCmX0IcXaMDuUx+Vxn5LCMQORNrFB8obySamVC22KIVqgI1VB7 94g0GwZ2MaWk/WHgvWLiUw0WXsn7UH9IihTVhEawlVhBfhbRE22ER1IIWQEisv8TyigOud3HHXIB EKug7kLhFM9KFv4VmAn9nf68NA3xnz+4fig1ALXtTkMoEITGGYTAwjGwcKzrxiGi9oexmcypeW5i VdhoiFYteDgBjIdpuvJqyD1lop5s8L0OKjPYoDe4ViHZZGaQjXA1TwjMLNfmVQ3JVAjpyI6kK28I hGJemgf0X4paAd2JuhGTSNLy0cIx+lCQjeiXL70K+rmgdK5+vrTrR/3yF//nb9GS0QDUtjsNoW4B QhfAbjOMdGSPo6Towxhx1CV1LEXOiohrhUhT0O1klcxVSAZhEpYBFO8HZkY0+BgQLXq0lpBqnCtY +KXZt1wzpL1gkMOvspyPxF/8t2gNtEGI3qak61nddLr+M/JnMuy0+LCLGn6xfGLwoIVfffIaoJ3U AM37wBZnAT2dfr8NQG1rEKogNFaekEOI/gXOeqVe4KONoFKhzLVBEKR/TGAUQRRRqRVSX2gakpU+ shpECarHfIFD2BvhISGX1v6ArT/vM6bZjEabsAg+8F7XDZNKafF+MniiVk5LCCat8/QbMVoINmjb BRONFJ2k8jorJvIMGKfgOw+/2Ii2GqBLt6+uZ2dpAGrbnYTQsAChFPkYHUY6EgU+MdrgMMuSsRJh 7wdDbt3I5nTyRlaEwS9YqR4HEfpgM8Sy4moNpNK4KiM7tDctWP2PL+sjyseqpTl2sqFmEjTRz1GB lNCHlxGQ0ojRh9rr35wLFNn/6cWMps/sQufB9uf0uXKIZhkw9oDos0evAWK+cA3QvAjR2zCuoxO+ AahtdxZC3QKEokMoDuPJKBXR9OO0XihG1hBqTkdtLBVTuLMBZRySSao+q6EFELnZ7JkuTbPnYWXe Wxb1uaJ4PCOm7RnASix5ZsxT8FkNlVVXcxZMEu1J4ZQs/MJoTR4kkrgAkVVQp/VC4dx8IFY/o2XA sMqAnVoNEBchcg2Qf3/ehvGza9pJGoDadv8g1JN44DrEUUKvxCGYpOpT8X64ahotQ6bmtIVNDI6s hlI1TbEe76GhlwFGu+z1MlaXwaYlKpSsNgjcE0rBiidVnbFVpQa0vMcMobn6SdaGwe9M+zpU6agS Uk+I/Z/efCDuAUMJwV6gDyLjDNi8BuhvF77cX13DDtK1Y6RtN70RaODf0vX/Ut33U7o8psv/SY/9 Z7r+n+jy8asQ/uNXAV7+EUFoE8I/7ujooj30IR2SW7p+xvNtLuho5IFZ9Mtb1GZKr2WOpyn0JFR2 40mIdF+/1WUoeDogENA6lhX0OjFJKWLoIlfvdSFGTYoThWQVdu5ZiFpMTL/DryBHsMwmhKhrk+bx qJFXsYg6KIxbG/QVOEVu85pBw6IoYR8vpZPsIvfpooFecOjqRrwpW0MsJRUpIafhY7Clfei+jhu8 UEOz0V6P/ka+5rwYPb5j1cPKCAde44Ob3DpAAjLuevr5AkjtRIzdy/DojBQSfU4jfUYjXQ/PQ/iO rj+iy45OBgylLx+pb/Qn/z6E/92+y8+r7/WX4WoraDQF1LZ7oYRY+dRKiGRM4iqhjpQQHb7sG4kC kbR2Kmn6FNWclvDMQjJENZZBsmVBMmViUkvZn497Lal7hJztGiaXoDVH2qzqKspnBfHzk01TlFFi WkbghrRdj575CjL7R8KxyO8o6pB6WVbMVBCHX2v+z/MVA9ozYJ6Cv8x7ftpCsLY1CC0Y01yAWEEo 9kGqpDsOh7rdyBDqxGdRUxosTc/6qpPVNbRy2up8dKyH1Q159sv9IUnbWxpeGlyhMq7RMl+Yh5eJ 7xNtbrSWAiSBWijridn0RPZ3CnwCh2WyQoaFl6y+FCqJwysg9SOhWCzh17bTVej5uvZ/NpUBvaPP kg3ot6AMNgC1rUGIILQFhVC/kQMvQ4jokjYEJgq70mYkAUEQYoURrX8MLU3PMOL7k1VOi84AbWZl xdKZ4ul8lpAVH4rHQzCil8kracy6430kx2C+zqgtIGnUJlkHEugyzjY/ulNPiLN5YjzTzxxVsmrD rmPniCAlio9TZkmGTUtUuZMQimLKkNPwtf/TP1P/hy8c47EBzRmw2oDOWyWD/vwts2ENQG270xDC zfdpCULRINT1CiE69OmA3eVOeknTmzlNNNCudQ7JBAyqhhQitv6XKaKkKXMZeCYgQQ3RtH2DgBT1 EuzaH9P0v3bNl9VUYXTj2RUQe0NJ4FMmKLLk6vh5oy7jzO8shZ0oH75wiHaWFDqvziSWE0XkM4B6 otPjUQsQvQWDDWjOgNUG9FIK/k/fcmdoAGrbnYbQ0JPwMAi9rCC0YSXExu1oIRn7Qqx9bJxHtAwZ ISKNmvLOIZllyfLge+meZ/gEnT2tjaSqknySolRVx6AjQOyC5gt5/Q+/TqeV1DaryFSYT0oMBT7Z iO7kOchV35IJ04JCVT/0Trj6edxpQ+qOs19Jw6+zVxp+ef3Pkv/jZvIT6wH76yoF/6tr2hEagNp2 byAUDEIXG0lBM3i4TyqHZNHGeXDVdGKeIIxuTnuxIqfqQ9AWDvaGOF1fTGob4yHjPSx1bz8zkJIZ 2LG6SNrfKrIhd+dbh779e96SEbl5loslK/hwuKihl2XaxGRX74eBtO1BUvGcBdteaAh2bu0XD+ix DYVf+Ey9n1MCkfg/XytwDhnQX17TTtDS8G17r9uX7yhFD6cpnLEfnE6gJ81AgNIDgNP3W10+lLNG /JqdpemZKBvo+KDVAyVJ70OIqBPfZdYyok0b5HQ8v0inKyXLQa9pb5/XE30199klimLRhQc1JU+w SVbnI787Sle8ZPct7HL4yGiOZCFlYqWzQ5I52HHHGD2nG+T1cCTY0G3cEHxZJVHcyen4cN69DJ+e UfhF4In0mQx0efVNCJ/SzycnGpZdnOhn9eqRGtB/Qt/Fv7Xv6vPqe/vlG4CpKaC23Rsl9ICUUCIl hFwJdCH1MGknvWNBDGk+sOs0/Ykc+eoLcWwGlRrSVTc0LNNqadRBYoQuGeVhbR4SbqUwRsuAhZhX yJBLx5k0n1WdQu4BS+IxjRLq9bk7HsY5fAg00phqFdB0TVfcakI/s8/DOXxXP6OpHyKxmM+sfjYW fj2vGlAZ3Gv+zyED+mlTQG1rSmhdCbHa2ZASOpfBh6c8Nxn4jM8ChlUPhR9SXsgFi+wV8dHFjstJ z+qG20C7EHvpNNeSwE5mMsuRL6Zu0NJDbgaVqamol450C3Ya7uG0GFGLE4OqJA6hYhyTzDaUyEl8 HVuOR7phZRqiPl8hxA1iomhY/XDP16hFkHxhxTMwhLqp+nmwi9iRIuLiQx5zeEp/BzC8twF/+LuA z4f9AsTfPtECxF/8+4B0UxTQ/zz7Dv+qeUBta0rosBIKpIR2pIR2/QtkJdSTEuI6oYEP9qGk6fng 3pkvxHOFEgkhrxdyNSShT1SfSMZ7yNIbYMPNtLOde8voRdW0NuMaqkvw6zAOEEYzp7WDYrRBZOIP 6axoAdIIroC4y5+Hc/Bt+uuGpOl6bb4V9cOG8zhTP2w8B/r72Xwe6B08t+yXpN/PNP2+5v8cYUBj A1DbGoQOQOjBDEJ4HiU7xsZ0rhXi+houWqTQiDNMnJrfSJZsJx31Uj3defhlZnVU45jDKakfMhgF S5kFu0iKXtf+yrdRkILyu75ss4RpNsVxFNgFbZw1+PQdpBo+nOnqes16MbhGrvsh+GwNRKzSBruN XBj0TAcNXVSAYbX4T3E6hD6HX0+v14BuIVjb7mU49gkddI9YczxIYRvHsBu4dwxC3MrgLmB/mkuO +62GVxElJJN0lMx354qd3kznUcOypIGUdIVxaBbB/BcE/f+evRppAhVT2EOv+tJZmMWqi0sLebAa 2DI8kuFKoKNUO5nliBJ+wQ4dPqx8doMY0tp6wWHkTsxo7DeRgCzUCxuuEt8kHF4FfLzhxwgwBJyB wq/P6PV/C6KC9sOvf1fCLz4h/PQtDegGoLbdCwj9lC7PzwuEejogN8SO15wBe8ANrCNs8CRs6Ih+ TnJgsHoXqHwhdl92oza1MixkLFhvC5KidLli7LXxVHpb2bnpxKsRqQO6XjJqqyo4lsp/GUAKKQaR DJYfxVtS8AR9zZ7VV9ghkniTKm56/U2vXtD5oIAy3ydJuz3djhdRhxWR6tt2QxhfaAn2OX1G39Pf 9JCB800IP6LrbqvZL3xg4Zdlv37xShXodwv+z//6ht9zC8HadufDMQ4pfjRSWGbhGP/M9S4fEQJ2 39NB/monFdMIWivEGbJu5guxgdxZHxlnzKIPOZM2DjrOu0EH4JtHNIAODJMGUtSwjP2igTNoKxdW OvwcLn60Ea0yuRFMCWl1IWjFdp/k3z5nsUbwOdsBXej3ezWdxfdBhc9AyucBct3PC8kEDt+r98Me 0KnN/jm32h/+XA9lv768Rv+nAaht9wJCj7dTCMkBd6KZH4GQpOl3UrDoafraF+ILp+rHTSlaZG9I GkBnIGKjWg5vBo9UUxOsOi0y9OLCaBc0oIiZbY/JlMOov5esOdafOxB42O/p6KdoBnlQz0eW5ZGa IVY/BJ/H1nh6whd045liR/6bk3pifPnOZv+kmfk8r36+rgmILQRr270Mx+hgDd+QvvkxBS+vSDZ0 j/Sxng6r70MpWPQ0PWFHfaEdgWwrR5+k6jlF3/UQOBKTEYaMlV6XPe64kUs6twhhHY8R0lWUef3A nh6Vsfco7RLBB8bni8xqltUsGDrI/g97SB0XV3Oo1SXOxMlyzKOm57HnVPqg/hEv0ZNM+TB8OvaJ OD1/BrK2zwWpnzN68/0LNZ1f0d/+gN532qj3w22039Nn9kOC9X+it/npgfDruvyfBqC23WkIPaMD amsQ+g1B6LMKQi/OCoTqWqFP6PaFmdPsC52hTt/ZnhCcCDNsUPPsDdhqjRCpk7CT7isFkRRV2yKB DiN6IXGAGCTaupW0u8LgZDWEch9n/bET8SPQGel3+kHXgd8F7e1iU3kk8PRcmoRqOHutD4Ps1Dwg Dr3Y99lZ6MUlCDwV++Gm1P0wmNn7YfUzN5+ffSzp+xD+XQh/EsoAsuvyfxqA2nanITT+kbYWMIQi 7elfLUDoJ0Se11WG7CM60MWcPicwnI7hFVxI0aJnyfg5aMC54Nrnrcw7DA9AslLIKqjb6BAfKS7m 1LgOWxYgbfiazZmNVinK6EWvWOTLDpGfQ1CTpXWCjtPAniHD3e0Ema1lzXjsBqsgGe6B2oR62kkY tg8fBs4rDbsYPr/j0Iv+IfZ+OPPFIepc/bx4ktXPavaLt796Q/+nAahtdxpCv6kg9HgFQt9dBPjh rkAIWBERPc4kJEvhNYVkjzpTQ6POOOxPOHTTkYYclnFv2W5DYIimhuixKOl7AsRWYWTtY9o0BgIH fg1N29t/OwTtB7NldXyURs9QGfS5Gm5x1ovCKpl5LdCTymc2nLcr8GGz/aOoRYdbC71+QqHXszMN vdgnY79sSf38Iqxnv94m/GoAatu9hNApKZltku5vAotC6MxqhXgWcu0LfUq3dw85NCI1hEUNsdzp LSxjEIkiolCJwbTrxetRn4d+vuAQzmCzo+edbCXlLiuWii1kK5puohQX4oUWEpIS0t9JsvKpKh4H z+aCu1/VSzrh9D9dzl7ruI05fD4i+Lzaacqds14eennTqYdenPlaUz9L85/fNvxqAGrbnYbQf2IQ LUCIWw54+Dr3gnV0BPxDVSs094U+Jj685Jml51M1dI4yZ1pAFA1E/LSHrG7MrIYTHndKwNGZ93Qt MAlSeJhjriBQ6qTqyIbYqxISpcOAESh1pJhIBZ2PGuYlKWbk7n3QkRvnEemtB2LpnvLhlVHPe/V+ uAyB/34OvX5QhV5c93OZ+rnu8KsBqG13GkJ80Hy7AKHTc4WQjN6wgsU1X6gOyWo19Dqch0cwBREr ojM2gXWdZl2/NEkBoygjBhKpl8DD0aJdRhkcD9LGuun0vq7TlSvY34Fdhg7GJDU+4QGB6SwKeHjM oXSdsep5sPmeoLMLfaeG847nQRt8PprBJ81CLy5Z6HstYfh/t8vq57rDrwagtt1pCP3tDEK//zyE //xlgOG/DeF/PF1P06+FZLUagkdSQY3LIJK2iHBB0GFzehd0dhAakCDp7bNBViKUvnnOiY0GGrTH GTismi4IUJxVY+BcKHiQO0t5BFoKUVQVq54NqZ5xm5A73Lm2iT2fl/SLS/DhrBcpN/Siw0cWeknb BcHn/2fvbHrauKIwfMcmMR8iiKpUVUuVrPoHWLXZgLrNf6j6C7vpHqQqzSq7/oBEIVGltETUDsbG zPS898M+XN87DK4NFryPNOAZ22MrYR6958zcO7jw8Lr088sc/v8oIHKvJfS9T0NWQv+6vtDbk+lr hcJpevSFciUZ0lBPBPMEwQP3vEiICI1kO2Zs5G4pCBlBbi2UUV5IdnpUO19HYcKEZf5CQlvOYOYx 3NVCXmf6XjjyftNHKrKzyRdXxLPmU0/p+z2fR046aDivZ+SD0mvb932eqNKrOym9ql9VwqlJPxUF RCihjISaXisUmtOpkmzUn6ShMJas58es21sJKhG12kNzLqqZlpG/xymSTQe3zMF+XH9HLxCNXyS9 SDnmk46dCt92iVq4zsectSfiqULqGbl+z/kjf60Pxjlk5LPpT7lDPhuJ0mtXlV6LSj8UELn3EjKm 2bVCoTmdKsnWfRoKvaGxiDDco5wkos1RaQZDKaYSMmoXhRWSvYGgvHdDRHQxFtPVZR1DJy7dxD8Q DpIOpHNe9EQmQ9N5dFH1WiPzWIkHA9fsaXZfcuE6HxFqVj7hlHuY76eu9NpbUPqhgMiDl5BuTuu+ kC7J/op6QyjLUI5hHJZORLiI8bNKRdXFREamPXRCKgbimGE1kmW1GIqYsDhBuaUnOx9WPVkqWZBy 2phTRN4P6axiGH+vrDBEpFTi6bVduYWzekg9OLK/OjHVpzM3Bu5vWR+0ppvOwJZev4/lU9t4nmf6 oYAIJRQk9M4Y3RfSJVlIQ92W6w2FsiyIKCQi2yMytlltcFq772WEZNRXQmqvlOasKM1au8TN52Vx gnLLqMKM9D1ZIJtixQ7NqMpuabZKl7QgnU30pcxV8VxCPCtuZkOM7xrK9wyn2rfluQ7Eirme19xg 3SCf4eNJ32fX1Dee55l+QME/V3JPKfblx2Hiidey/CbPP/PrP/nfr3Yk9cibTocikVN3bKzIwf6u b4rd0r2mixQkj5/KY0kV9jWdLzHu1D3/cSCv9fv758I9/7UsJ/6x8aPLR5WkKuzvcvr7QS44c9Yt 1EE+dBcNYiDpCb6X7G1LEtjA+MRjnHjCtBqpkis0nDdi+Ry52QSCfN5kSq9IGHMREBMQedBJaHya XveFJA3pU/UhDYWyDAcwEhH6PzoRoUc03HSTliEVYTK07bZLRtjWd7e8sMu2cWO9WoWTiV4wWL7t nreJyr5HVjpoLOPaJVk+yffoqMRzLonn8syJB2O7UiUXBqI1kU+u9Jp3+mECIg+Cff93fphIQkal oZ9lOa5JQzi9jfJqTRLRWSIRdUVWg1W3/VtZPnxhilX1eUhHO/5xp+F3H4T3yrLTmRz45xDpiane +/WQeFBarnrxYDtKru9UyYWzXS8RqP5w6yn55BrPR3OWDwVEWJIlSrIgIkjIVk0/uu26LAO50sxE MsoJ6SZAOLhWB3ctDdLpyEbM6YzHsXhC6jk1k9QD+WCCMUzcFhrON5QPBUTIIiWEx6k0hBj1WNLQ c1n/M0pEWkQo7T5EMkoJSYspx/vEtpR07Ocq8aDXo1NPKLm2ZpDPIvo+FBChhDISMtekoVCWpURk MjKyCcZvexp9ZvcifwwG0QTe+t+xdHTisbIxV3s9Jiq58LupfBZVelFA5MFLyDRMQ0CfKdMi0qVZ nYzGUlFS0mJKsapmbP9GZNONntdpB+s68Yx7Pb7RHKceswTyoYDIg5YQfjRJQ3UiCqUZ0KkollEQ EsamnZU3/7LrXkZaOHHa0YlnXG5dk3rw+67kQwERUlOS5USk+0M4ql8NplNRLKOUkGYhFo5OO0Yn noR4mqSe25QPBURIg5IsFtEztX2qWe1TEU63BxkFIZmElGZBC2ecdkxz8eRSz23LhwIi5AZpqK40 y6UiLSQTSUnzPLHtZeY7xMKx0sE1Qsfjj58Sz3Wp5y7kQwERMkMaqhPRlIxSQlJiCuwkPuOjXjma fj4knSAdUyOe61KPuQP5UECEzElEORklhRRbw6QF9YO68jm1A510TKbUqhNPlHpuXT4UECENjo8m IsrJKCWkICXNcb2frqSblHCapp1lSD0UECELFFEso1hIOSldx5vEtheRPPYa7OeuUw8FRMgtiSgn pJyYcrzIiGLvBt9hWVIPBUTIHI6dfbVyOONOXjd83d6M+z9Qj5dJPBQQIQtIRf9HRvMkSjtLJx4K iJBbkNFtCekgWl/GtEMBEXIHx9Z+5gWziOkgs33Zkw4FRMiSHW/7M+zgaHpTxX9WQgghhBBCCCGE EEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEFLHfwIMAGtshuWK E+cGAAAAAElFTkSuQmCC" transform="matrix(.24 0 0 .24 44 44)"/><path fill="#FF9800" d="M96 96V52H52z"/></g><path clip-path="url(#b)" fill="#BF360C" fill-opacity=".1" d="M53 52h-1l44 44h1z"/><path clip-path="url(#b)" fill="#DB4437" d="M96 12.83c0-1.1.9-2 2-2 .55 0 1.04.22 1.4.57L140 52 96 96V12.83z"/><path clip-path="url(#b)" fill="#AD1457" d="M96 96h44V52z"/><path clip-path="url(#b)" fill="#fff" fill-opacity=".1" d="M96 95v1l44-44v-1z"/><path clip-path="url(#b)" fill="#BF360C" fill-opacity=".1" d="M12.83 95c-.93 0-1.71-.64-1.93-1.5-.04.16-.07.33-.07.5 0 1.1.9 2 2 2H96l-1-1H12.83z"/><path clip-path="url(#b)" fill="#F5F5F5" d="M92 92l4-12 4 12 12 4-12 4-4 12-4-12-12-4z"/><path clip-path="url(#b)" fill="#fff" fill-opacity=".2" d="M52 52L11.4 92.6c-.35.36-.58.85-.58 1.4 0 .17.03.34.07.5a2 2 0 0 1 .5-.9L52 53h44v-1H52zm46-40.17c.55 0 1.04.22 1.4.57l40.1 40.1.5-.5-40.6-40.6c-.36-.35-.85-.57-1.4-.57-1.1 0-2 .9-2 2v1a2 2 0 0 1 2-2z"/><path clip-path="url(#b)" fill="#fff" fill-opacity=".1" d="M181.1 98.5c.04-.16.07-.33.07-.5 0-1.1-.9-2-2-2H96l1 1h82.17c.93 0 1.71.64 1.93 1.5z"/><path clip-path="url(#b)" fill="#004D40" fill-opacity=".1" d="M94 180.17c-.55 0-1.04-.22-1.4-.57l-40.1-40.1-.5.5 40.6 40.6c.36.35.85.57 1.4.57 1.1 0 2-.9 2-2v-1a2 2 0 0 1-2 2z"/><path clip-path="url(#b)" fill="#1A237E" fill-opacity=".1" d="M180.6 98.4L140 139H96v1h44l40.6-40.6c.35-.36.58-.85.58-1.4 0-.17-.03-.34-.07-.5-.1.34-.27.65-.51.9z"/><radialGradient id="c" cx="51.82" cy="51.802" r="137.69" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#fff" stop-opacity=".1"/><stop offset="1" stop-color="#fff" stop-opacity="0"/></radialGradient><path fill="url(#c)" d="M179.17 96H140V52L99.4 11.4c-.36-.35-.85-.57-1.4-.57-1.1 0-2 .9-2 2V52H52L11.4 92.6c-.35.36-.58.85-.58 1.4 0 1.1.9 2 2 2H52v44l40.6 40.6c.36.35.85.57 1.4.57 1.1 0 2-.9 2-2V140h44l40.6-40.6c.35-.36.58-.85.58-1.4-.01-1.1-.9-2-2.01-2z"/><path fill="none" d="M0 0h192v192H0z"/></svg>
\ No newline at end of file diff --git a/plugins/shotwell-publishing/picasa_publishing_options_pane.ui b/plugins/shotwell-publishing/google_photos_publishing_options_pane.ui index 11e79af..8685b96 100644 --- a/plugins/shotwell-publishing/picasa_publishing_options_pane.ui +++ b/plugins/shotwell-publishing/google_photos_publishing_options_pane.ui @@ -1,10 +1,14 @@ <?xml version="1.0" encoding="UTF-8"?> -<!-- Generated with glade 3.20.0 --> +<!-- Generated with glade 3.22.0 --> <interface domain="shotwell"> <requires lib="gtk+" version="3.14"/> - <object class="GtkBox" id="picasa_pane_widget"> + <template class="PublishingGooglePhotosPublishingOptionsPane" parent="GtkBox"> <property name="visible">True</property> <property name="can_focus">False</property> + <property name="margin_start">18</property> + <property name="margin_end">18</property> + <property name="margin_top">18</property> + <property name="margin_bottom">18</property> <property name="orientation">vertical</property> <property name="spacing">1</property> <child> @@ -14,10 +18,10 @@ <object class="GtkLabel" id="login_identity_label"> <property name="visible">True</property> <property name="can_focus">False</property> + <property name="halign">start</property> <property name="margin_top">12</property> <property name="margin_bottom">32</property> - <property name="label" translatable="no">'you are logged in as $name' -(populated in the application code)</property> + <property name="label">'you are logged in as $name' (populated in the application code)</property> </object> <packing> <property name="expand">False</property> @@ -30,24 +34,36 @@ <object class="GtkBox" id="album_gallery_layout_box"> <property name="visible">True</property> <property name="can_focus">False</property> - <property name="margin_left">32</property> - <property name="margin_right">32</property> + <property name="margin_start">32</property> + <property name="margin_end">32</property> <property name="orientation">vertical</property> <child> - <placeholder/> + <object class="GtkLabel" id="publish_to_label"> + <property name="visible">True</property> + <property name="can_focus">False</property> + <property name="halign">start</property> + <property name="label">$mediatype will appear in (populated in code)</property> + </object> + <packing> + <property name="expand">True</property> + <property name="fill">True</property> + <property name="position">0</property> + </packing> </child> <child> <object class="GtkGrid" id="album_choice_area_grid"> <property name="visible">True</property> <property name="can_focus">False</property> - <property name="margin_left">24</property> - <property name="margin_right">24</property> - <property name="row_spacing">8</property> + <property name="margin_start">24</property> + <property name="margin_end">24</property> + <property name="row_spacing">6</property> + <property name="column_spacing">12</property> <property name="column_homogeneous">True</property> <child> <object class="GtkComboBoxText" id="existing_albums_combo"> <property name="visible">True</property> <property name="can_focus">False</property> + <property name="tooltip_text" translatable="yes">Shotwell can only publish into albums that it created by itself, so this list might be empty despite the fact that you already have albums in your Google Photos account</property> </object> <packing> <property name="left_attach">1</property> @@ -68,31 +84,59 @@ </object> <packing> <property name="left_attach">0</property> - <property name="top_attach">2</property> + <property name="top_attach">3</property> <property name="width">2</property> </packing> </child> <child> - <object class="GtkLabel" id="publish_to_label"> + <object class="GtkLabel" id="label1"> <property name="visible">True</property> <property name="can_focus">False</property> - <property name="halign">start</property> - <property name="label" translatable="no">$mediatype will appear in -(populated in code)</property> + <property name="halign">end</property> + <property name="label" translatable="yes">Photo _size preset</property> + <property name="use_underline">True</property> + <property name="mnemonic_widget">size_combo</property> </object> <packing> <property name="left_attach">0</property> - <property name="top_attach">0</property> + <property name="top_attach">2</property> </packing> </child> <child> - <object class="GtkLabel" id="label1"> + <object class="GtkComboBoxText" id="size_combo"> <property name="visible">True</property> <property name="can_focus">False</property> - <property name="halign">start</property> - <property name="label" translatable="yes">Photo _size preset:</property> - <property name="use_underline">True</property> - <property name="mnemonic_widget">size_combo</property> + </object> + <packing> + <property name="left_attach">1</property> + <property name="top_attach">2</property> + </packing> + </child> + <child> + <object class="GtkRadioButton" id="existing_album_radio"> + <property name="label" translatable="yes">An existing album</property> + <property name="visible">True</property> + <property name="can_focus">True</property> + <property name="receives_default">False</property> + <property name="halign">end</property> + <property name="active">True</property> + <property name="draw_indicator">True</property> + </object> + <packing> + <property name="left_attach">0</property> + <property name="top_attach">0</property> + </packing> + </child> + <child> + <object class="GtkRadioButton" id="new_album_radio"> + <property name="label" translatable="yes">A new album named</property> + <property name="visible">True</property> + <property name="can_focus">True</property> + <property name="receives_default">False</property> + <property name="halign">end</property> + <property name="active">True</property> + <property name="draw_indicator">True</property> + <property name="group">existing_album_radio</property> </object> <packing> <property name="left_attach">0</property> @@ -100,9 +144,9 @@ </packing> </child> <child> - <object class="GtkComboBoxText" id="size_combo"> + <object class="GtkEntry" id="new_album_entry"> <property name="visible">True</property> - <property name="can_focus">False</property> + <property name="can_focus">True</property> </object> <packing> <property name="left_attach">1</property> @@ -128,15 +172,10 @@ <placeholder/> </child> <child> - <object class="GtkBox" id="button_area_box"> + <object class="GtkButtonBox"> <property name="visible">True</property> <property name="can_focus">False</property> - <property name="margin_left">112</property> - <property name="margin_right">112</property> - <property name="margin_top">48</property> - <property name="margin_bottom">24</property> - <property name="spacing">128</property> - <property name="homogeneous">True</property> + <property name="layout_style">spread</property> <child> <object class="GtkButton" id="logout_button"> <property name="label" translatable="yes">_Logout</property> @@ -172,5 +211,11 @@ <property name="position">4</property> </packing> </child> + </template> + <object class="GtkSizeGroup"> + <widgets> + <widget name="existing_album_radio"/> + <widget name="new_album_radio"/> + </widgets> </object> </interface> diff --git a/plugins/shotwell-publishing/meson.build b/plugins/shotwell-publishing/meson.build index 45058b8..eeac177 100644 --- a/plugins/shotwell-publishing/meson.build +++ b/plugins/shotwell-publishing/meson.build @@ -1,11 +1,15 @@ shotwell_publishing_sources = [ 'shotwell-publishing.vala', 'FacebookPublishing.vala', - 'PicasaPublishing.vala', 'FlickrPublishing.vala', 'TumblrPublishing.vala', 'YouTubePublishing.vala', - 'PiwigoPublishing.vala'] + 'PiwigoPublishing.vala', + 'PhotosPublisher.vala', + 'PhotosService.vala', + 'PhotosPublishingPane.vala', + 'PhotosUploader.vala' +] shotwell_publishing_resources = gnome.compile_resources('publishing-resource', 'org.gnome.Shotwell.Publishing.gresource.xml', @@ -16,9 +20,6 @@ shared_module('shotwell-publishing', dependencies : [gtk, soup, gexiv2, gee, sw_plugin, json_glib, webkit, sw_plugin_common_dep, xml, gdata, gcr, gcr_ui, authenticator_dep], - vala_args : [ - '--gresources', 'org.gnome.Shotwell.Publishing.gresource.xml' - ], c_args : ['-DPLUGIN_RESOURCE_PATH="/org/gnome/Shotwell/Publishing"', '-DGCR_API_SUBJECT_TO_CHANGE'], install: true, diff --git a/plugins/shotwell-publishing/org.gnome.Shotwell.Publishing.gresource.xml b/plugins/shotwell-publishing/org.gnome.Shotwell.Publishing.gresource.xml index 5e8ce1c..436ea9e 100644 --- a/plugins/shotwell-publishing/org.gnome.Shotwell.Publishing.gresource.xml +++ b/plugins/shotwell-publishing/org.gnome.Shotwell.Publishing.gresource.xml @@ -2,14 +2,13 @@ <gresources> <gresource prefix="/org/gnome/Shotwell/Publishing"> <file>facebook.png</file> - <file>flickr.png</file> - <file>picasa.png</file> <file>piwigo.png</file> <file>youtube.png</file> <file>tumblr.png</file> + <file>google-photos.svg</file> <file>facebook_publishing_options_pane.ui</file> <file>flickr_publishing_options_pane.ui</file> - <file>picasa_publishing_options_pane.ui</file> + <file>google_photos_publishing_options_pane.ui</file> <file>piwigo_authentication_pane.ui</file> <file>piwigo_publishing_options_pane.ui</file> <file>piwigo_ssl_failure_pane.ui</file> diff --git a/plugins/shotwell-publishing/shotwell-publishing.vala b/plugins/shotwell-publishing/shotwell-publishing.vala index 3515f5f..52c82ec 100644 --- a/plugins/shotwell-publishing/shotwell-publishing.vala +++ b/plugins/shotwell-publishing/shotwell-publishing.vala @@ -6,7 +6,7 @@ extern const string _VERSION; -// "core services" are: Facebook, Flickr, Picasa Web Albums, Piwigo and YouTube +// "core services" are: Flickr, Google Photos, Piwigo, Tumblr and YouTube private class ShotwellPublishingCoreServices : Object, Spit.Module { private Spit.Pluggable[] pluggables = new Spit.Pluggable[0]; @@ -28,9 +28,9 @@ private class ShotwellPublishingCoreServices : Object, Spit.Module { } #endif -#if HAVE_PICASA - if (authenicators.contains("picasa")) { - pluggables += new PicasaService(resource_directory); +#if HAVE_GOOGLEPHOTOS + if (authenicators.contains("google-photos")) { + pluggables += new Publishing.GooglePhotos.Service(resource_directory); } #endif |
