summaryrefslogtreecommitdiff
path: root/plugins/shotwell-publishing
diff options
context:
space:
mode:
authorJörg Frings-Fürst <debian@jff.email>2019-04-28 16:45:36 +0200
committerJörg Frings-Fürst <debian@jff.email>2019-04-28 16:45:36 +0200
commit6710aa856175300e598b23b701c0d2741f2cb6b3 (patch)
tree43987fa58a25c81413e68cddad697e6301c5936f /plugins/shotwell-publishing
parent5e9f4eea451a77ba3b93db3747841ed2bd969e9f (diff)
New upstream version 0.30.4upstream/0.30.4
Diffstat (limited to 'plugins/shotwell-publishing')
-rw-r--r--plugins/shotwell-publishing/PhotosPublisher.vala551
-rw-r--r--plugins/shotwell-publishing/PhotosPublishingPane.vala150
-rw-r--r--plugins/shotwell-publishing/PhotosService.vala58
-rw-r--r--plugins/shotwell-publishing/PhotosUploader.vala104
-rw-r--r--plugins/shotwell-publishing/PicasaPublishing.vala770
-rw-r--r--plugins/shotwell-publishing/flickr.pngbin689 -> 0 bytes
-rw-r--r--plugins/shotwell-publishing/google-photos.svg1
-rw-r--r--plugins/shotwell-publishing/google_photos_publishing_options_pane.ui (renamed from plugins/shotwell-publishing/picasa_publishing_options_pane.ui)105
-rw-r--r--plugins/shotwell-publishing/meson.build11
-rw-r--r--plugins/shotwell-publishing/org.gnome.Shotwell.Publishing.gresource.xml5
-rw-r--r--plugins/shotwell-publishing/shotwell-publishing.vala8
11 files changed, 951 insertions, 812 deletions
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
deleted file mode 100644
index b6cae3e..0000000
--- a/plugins/shotwell-publishing/flickr.png
+++ /dev/null
Binary files differ
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