[shotwell/wip/phako/google-photos: 3/3] Replace Picasaweb with Google Photos publishing



commit 7db10ddf1fd0605840ee75953c2a14a9512a4f75
Author: Jens Georg <mail jensge org>
Date:   Mon Jan 21 21:13:28 2019 +0100

    Replace Picasaweb with Google Photos publishing
    
    Picasaweb API will cease to work end of March 2019
    
    Fixes #97

 data/gsettings/org.yorba.shotwell.gschema.xml      |  16 +-
 data/org.gnome.Shotwell.appdata.xml.in             |   2 +-
 help/C/share-upload.page                           |   8 +-
 meson_options.txt                                  |   2 +-
 .../shotwell/ShotwellAuthenticatorFactory.vala     |   9 +-
 plugins/common/RESTSupport.vala                    |  12 +
 plugins/common/Resources.vala                      |   7 +-
 plugins/shotwell-publishing/PhotosPublisher.vala   | 547 +++++++++++++++
 .../shotwell-publishing/PhotosPublishingPane.vala  | 150 ++++
 plugins/shotwell-publishing/PhotosService.vala     |  58 ++
 plugins/shotwell-publishing/PhotosUploader.vala    | 104 +++
 plugins/shotwell-publishing/PicasaPublishing.vala  | 772 ---------------------
 plugins/shotwell-publishing/google-photos.svg      |   1 +
 ...ui => google_photos_publishing_options_pane.ui} | 105 ++-
 plugins/shotwell-publishing/meson.build            |  11 +-
 .../org.gnome.Shotwell.Publishing.gresource.xml    |   4 +-
 .../shotwell-publishing/shotwell-publishing.vala   |   8 +-
 src/plugins/StandardHostInterface.vala             |   3 -
 src/publishing/Publishing.vala                     |   2 +-
 19 files changed, 981 insertions(+), 840 deletions(-)
---
diff --git a/data/gsettings/org.yorba.shotwell.gschema.xml b/data/gsettings/org.yorba.shotwell.gschema.xml
index 9f6a4fd0..68593654 100644
--- a/data/gsettings/org.yorba.shotwell.gschema.xml
+++ b/data/gsettings/org.yorba.shotwell.gschema.xml
@@ -412,7 +412,7 @@
     <child name="facebook" schema="org.yorba.shotwell.sharing.facebook" />
     <child name="flickr" schema="org.yorba.shotwell.sharing.flickr" />
     <child name="gallery3" schema="org.yorba.shotwell.sharing.publishing-gallery3" />
-    <child name="picasa" schema="org.yorba.shotwell.sharing.picasa" />
+    <child name="org-gnome-shotwell-publishing-google-photos" 
schema="org.yorba.shotwell.sharing.org-gnome-shotwell-publishing-google-photos" />
     <child name="youtube" schema="org.yorba.shotwell.sharing.youtube" />
 </schema>
 
@@ -486,17 +486,17 @@
     </key>
 </schema>
 
-<schema id="org.yorba.shotwell.sharing.picasa" path="/org/yorba/shotwell/sharing/picasa/">
+<schema id="org.yorba.shotwell.sharing.org-gnome-shotwell-publishing-google-photos" 
path="/org/yorba/shotwell/sharing/org-gnome-shotwell-publishing-google-photos/">
     <key name="refresh-token" type="s">
         <default>""</default>
         <summary>refresh token</summary>
-        <description>The OAuth token used to refresh the Picasa Web Albums session for the currently logged 
in user, if any.</description>
+        <description>The OAuth token used to refresh the Google Photos session for the currently logged in 
user, if any.</description>
     </key>
 
     <key name="default-size" type="i">
         <default>2</default>
         <summary>default size</summary>
-        <description>A numeric code representing the default size for photos uploaded to Picasa Web 
Albums</description>
+        <description>A numeric code representing the default size for photos uploaded to Google Photos 
Albums</description>
     </key>
 
     <key name="last-album" type="s">
@@ -508,7 +508,7 @@
     <key name="strip-metadata" type="b">
         <default>false</default>
         <summary>remove sensitive info from uploads</summary>
-        <description>Whether images being uploaded to Picasa should have their metadata removed 
first</description>
+        <description>Whether images being uploaded to Google Photos should have their metadata removed 
first</description>
     </key>
 </schema>
 
@@ -721,10 +721,10 @@
         <description>True if the Flickr publishing plugin is enabled, false otherwise</description>
     </key>
 
-    <key name="publishing-picasa" type="b">
+    <key name="org-gnome-shotwell-publishing-google-photos" type="b">
         <default>true</default>
-        <summary>enable picasa publishing plugin</summary>
-        <description>True if the Picasa Web Albums publishing plugin is enabled, false 
otherwise</description>
+        <summary>enable Google Photos publishing plugin</summary>
+        <description>True if the Google Photos publishing plugin is enabled, false otherwise</description>
     </key>
 
     <key name="publishing-youtube" type="b">
diff --git a/data/org.gnome.Shotwell.appdata.xml.in b/data/org.gnome.Shotwell.appdata.xml.in
index dddbebbb..3586c1b4 100644
--- a/data/org.gnome.Shotwell.appdata.xml.in
+++ b/data/org.gnome.Shotwell.appdata.xml.in
@@ -17,7 +17,7 @@
     </p>
     <p>
       When ready, Shotwell can upload your photos to various web sites, such as Facebook, Flickr,
-      Picasa (Google Plus), and more.
+      Google Photos, and more.
     </p>
     <p>
       Shotwell supports JPEG, PNG, TIFF, and a variety of RAW file formats.
diff --git a/help/C/share-upload.page b/help/C/share-upload.page
index 76740a5e..2cbcbd5b 100644
--- a/help/C/share-upload.page
+++ b/help/C/share-upload.page
@@ -4,7 +4,7 @@
 
     <info>
         <link type="guide" xref="index#share"/>
-        <desc>Publish photos to Facebook, Flickr, Picasa Web Albums, or other sites.</desc>
+        <desc>Publish photos to Flickr, Google Photos, or other sites.</desc>
         
         <link type="next" xref="share-send" />
     </info>
@@ -17,7 +17,7 @@
     <list>
     <item><p><link href="https://facebook.com";>Facebook</link></p></item>
     <item><p><link href="https://flickr.com";>Flickr</link></p></item>
-    <item><p><link href="https://picasaweb.google.com";>Picasa Web Albums</link> and <link 
href="http://plus.google.com";>Google+</link></p></item>
+    <item><p><link href="https://photos.google.com";>Google Photos</link></p></item>
     <item><p><link href="https://youtube.com";>YouTube</link> (videos only)</p></item>
     <item><p><link href="https://tumblr.com";>Tumblr</link> (videos only)</p></item>
     <item><p>Any site running the <link href="http://piwigo.org";>Piwigo</link> photo gallery software 
(photos only)</p></item>
@@ -33,7 +33,5 @@
 </p>
     <note style="advanced"><p>You will be only able to publish images with at most the permission you 
granted to the Shotwell Facebook application</p></note>
     
-    <p>Similarly, publishing to Flickr requires you to log in and permit Shotwell Connect to access your 
account.</p>
-    
-    <p>If you have a Google account, but have not yet used Picasa Web Albums, you will need to log in to 
Picasa using a browser once before you can publish to this service.</p>
+    <p>Similarly, publishing to Flickr, YouTube or Google Photos requires you to log in and permit Shotwell 
Connect to access your account.</p>
 </page>
diff --git a/meson_options.txt b/meson_options.txt
index 30e3f3bf..3c81a5cd 100644
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -1,5 +1,5 @@
 option('unity-support', type: 'boolean', value : 'false', description: 'Enable Ubuntu Unity support')
-option('publishers', type: 'string', value : 'flickr,picasa,piwigo,youtube,gallery3,tumblr', description: 
'The list of publishing plugins to build')
+option('publishers', type: 'string', value : 'flickr,googlephotos,piwigo,youtube,gallery3,tumblr', 
description: 'The list of publishing plugins to build')
 option('extra-plugins', type : 'boolean', value : 'true', description: 'Enable building and installation of 
extra publishing plugins')
 option('trace', type: 'string', value : '', description: 'Enable various trace  options (available: dtors, 
import, md5, metadata-writer, monitoring, pixbuf-cache, reflow, reflow-items)')
 option('measure', type: 'string', value : '', description : 'Enable various timing measurements(available : 
enhance, import, pipeline, view-filtering, thumbnail-cache)')
diff --git a/plugins/authenticator/shotwell/ShotwellAuthenticatorFactory.vala 
b/plugins/authenticator/shotwell/ShotwellAuthenticatorFactory.vala
index 0d813acf..36fb2902 100644
--- a/plugins/authenticator/shotwell/ShotwellAuthenticatorFactory.vala
+++ b/plugins/authenticator/shotwell/ShotwellAuthenticatorFactory.vala
@@ -14,9 +14,9 @@ namespace Publishing.Authenticator {
             var list = new Gee.ArrayList<string>();
             list.add("flickr");
             list.add("facebook");
-            list.add("picasa");
             list.add("youtube");
             list.add("tumblr");
+            list.add("google-photos");
 
             return list;
         }
@@ -28,14 +28,13 @@ namespace Publishing.Authenticator {
                     return new Shotwell.Flickr.Flickr(host);
                 case "facebook":
                     return new Shotwell.Facebook.Facebook(host);
-                case "picasa":
-                    return new Shotwell.Google.Google("https://picasaweb.google.com/data/";, _("You are not 
currently logged into Picasa Web Albums.\n\nClick Log in to log into Picasa Web Albums in your Web browser. 
You will have to authorize Shotwell Connect to link to your Picasa Web Albums account."), host);
-
                 case "youtube":
                     return new Shotwell.Google.Google("https://gdata.youtube.com/";, _("You are not currently 
logged into YouTube.\n\nYou must have already signed up for a Google account and set it up for use with 
YouTube to continue. You can set up most accounts by using your browser to log into the YouTube site at least 
once."), host);
                 case "tumblr":
                     return new Shotwell.Tumblr.Tumblr(host);
-                default:
+                case "google-photos":
+                    return new Shotwell.Google.Google("https://www.googleapis.com/auth/photoslibrary";, 
_("You are not currently logged into Google Photos.\n\nYou must have already signed up for a Google account 
and set it up for use with Google Photos.\n\nYou will have to authorize Shotwell to link to your Google 
Photos account."), host);
+               default:
                     return null;
             }
         }
diff --git a/plugins/common/RESTSupport.vala b/plugins/common/RESTSupport.vala
index 482fd2cd..5cd3768b 100644
--- a/plugins/common/RESTSupport.vala
+++ b/plugins/common/RESTSupport.vala
@@ -444,6 +444,18 @@ public class Transaction {
     public void add_argument(string name, string value) {
         arguments += new Argument(name, value);
     }
+
+    public void set_argument(string name, string value) {
+        foreach (var arg in arguments) {
+            if (arg.key == name) {
+                arg.value = value;
+
+                return;
+            }
+        }
+
+        add_argument(name, value);
+    }
     
     public string? get_endpoint_url() {
         return (endpoint_url != null) ? endpoint_url : parent_session.get_endpoint_url();
diff --git a/plugins/common/Resources.vala b/plugins/common/Resources.vala
index 29c7294e..ecbf2f87 100644
--- a/plugins/common/Resources.vala
+++ b/plugins/common/Resources.vala
@@ -42,7 +42,7 @@ public Gdk.Pixbuf[]? load_icon_set(GLib.File? icon_file) {
     try {
         icon = new Gdk.Pixbuf.from_file(icon_file.get_path());
     } catch (Error err) {
-        warning("couldn't load icon set from %s.", icon_file.get_path());
+        warning("couldn't load icon set from %s: %s", icon_file.get_path(), err.message);
     }
     
     if (icon != null) {
@@ -57,9 +57,10 @@ public Gdk.Pixbuf[]? load_icon_set(GLib.File? icon_file) {
 public Gdk.Pixbuf[]? load_from_resource (string resource_path) {
     Gdk.Pixbuf? icon = null;
     try {
-        icon = new Gdk.Pixbuf.from_resource (resource_path);
+        debug ("Loading icon from %s", resource_path);
+        icon = new Gdk.Pixbuf.from_resource_at_scale (resource_path, 24, 24, true);
     } catch (Error error) {
-        warning ("Couldn't load icon set from %s", resource_path);
+        warning ("Couldn't load icon set from %s: %s", resource_path, error.message);
     }
 
     if (icon != null) {
diff --git a/plugins/shotwell-publishing/PhotosPublisher.vala 
b/plugins/shotwell-publishing/PhotosPublisher.vala
new file mode 100644
index 00000000..ca9a2ec1
--- /dev/null
+++ b/plugins/shotwell-publishing/PhotosPublisher.vala
@@ -0,0 +1,547 @@
+/* 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 ();
+            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 00000000..32ccf8a7
--- /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.Binding.SYNC_CREATE);
+        new_album_radio.bind_property("active", new_album_entry, "sensitive", GLib.Binding.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 00000000..8e328f41
--- /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 00000000..83137ee9
--- /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/google-photos.svg b/plugins/shotwell-publishing/google-photos.svg
new file mode 100644
index 00000000..498de5aa
--- /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+PDdBWW2211VZbbbXVV
 ltttdVWW
 2211VZb 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+BTx1IBqkaUAanX94BTOeEcS2Ea6stWf2Hg9sxGLkquiqqa
 A2iNxWIv
 s0A6hxAN3qK 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+P5Sd
 nBxA/iMz
 x+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 
FwwjgRZfNImy6YKA5IKBBAKiPoj6yRBSyJDDSaHjZvbAj92LU
 c6353iNO
 j6vQBEood4OFEqj/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+5GsmygpCcsupGqabxmnG
 y96lJIk0
 CYOUzZSCsDnWZlYpoy0CLLX 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+TNuvI6j
 cBPRCYqg
 ZQ2aRtKH5kdfB/+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/6FSt9Cg1NanqpCSob3lH
 30bZeB+y
 a4dWLdYz9ogYJE6Igmy4ImOnL2UqWsB 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 TXZ0VBNbTG8ZSKtGNohp7SfUpjUZVNsDm
 cmtlyFoW
 lDOR3l6sv+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 mtXSjvzO0v1SKIkdFTCFkMaOdNbw4
 WDSUgDS2
 SQCn84eQp6Mlgrov8nI1p+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
 +SUKBHsD
 UZqamtFt24JIOXe4F5SUEAFLQPI85HSyQCHqa7BfkY/ 
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 qz31C386AiJCqzMKmEqUN
 CuVYFX7R
 3rbiFrqDFaX5AXSmIf+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 bdXwNsxekg41UvVDn
 nkj8qxbp
 ZAalNpqQHqMK6mk+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 vlHZFGDW4wZVi
 GY1SWlbp
 eNQaiUBbTUgPfxalWrXUCohmk0BOHK7VUMuVVXcyTciy7o5fFIVd0jV 
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 ND91XjCeT
 e1c7a3Nu
 NClWdwOojwGNxVNGpR0E8sVlKhBqUGpAelDrK1+tpk3BBsFkpUaguOXh3Q+ 
nVxZpZokTMWVlToKbm7XIHIDamFu1yFbMrmzMqJZ2FZn4KwZt0GpQamtj04hxY0Bbceh5N38s+uC 
/9mhDufKZgA5XMtKiBYwqkzvzVMFJtk4DhYgcuXkI3EpbcOdoJTDt1nPW4NSg1ID0iNZ3VwN9Rsj 
SIiO1SBBniQw85KyKgoQ1qoKw/wwL2ppBiOFDVY+Eq7BhHO1hCWcS2Y32SZ0nurX7Za8vcSKKBuU 
GpQakD76VUMmLAmFq/O5v20FnsrYnikj6cZF3a0EtXgpe0q4pZoQ0h7gdWnAAkq2Uy6pCd6g1KDU 
gPQxLjwXUGGlkvwSh1eoFBZthWsVpOQyKxAwKBUfiUwtIYSybVJSS+TTASiHbpaBW0KJGpQalBqQ 
Pj2RdEIlJRCV2Kzeijsb21DUEaxglK8vmTk/nwe/KbJyeIde0Y3uK1mJAJWyAJ3NvYLSxgYADUoN 
Sg1IH4XhvfSRCE+fJ1y9BGHjgK5DOMowyj7SKYPbFBPOR5ikEgE3u3WAv1dxk9cnef9bHvbWoNSg 
1ID03tfwgE9pHqIt4ZRaRijPWKr8o9KLUnlJtFBH9YnWmTdcVHXPs27Bze0UvhmUZltxNyg1KDUg 
PcJ11ya4rRaTsPjzS/gWqgM5LB6HKNcvVTucKFwcQn5CxCNqqcPlbKWqFOAIlLoGpQalBqRP3ldK 
qf/ZcTvzkGimiGxj7SKW6p1yoUyghHqwW1JKVI8sybvk2kaUGUqhQalBqQHpk1rH65GOqqYq9b95 
ANvliEuj27ZAuSVsw2URJbqCchChjy8hn8XdlFKDUgPSZ6aMzn0ZqAJPOqDTBgK0gNLKPyoZN4AF 
mDC4EqvaTCzzhqWAcgUl2cutQalBqQHps/hzt4CFG7dAnHvcGVjr1D8cCdtwo82kysAdg5Ka4A1K DUoNS
 J+cXDp1Q
 JpvlOd0U5VRywfyvIJ7HarhQkXN/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 o
 NSA1NbdA
 jlaCCHfQmlmbM/rkhZQgm0o5bKABqUGpQaktorjPT8A8UwznNZjuCsI+RylGmYLKEGD 
UoNSA1JbdzG41zfEJYx8AjfhsjygVks1lKBBqUGpAamt+4fYfHhbBaZseS+hVM9halBqUGpAaus9 
CKsMqhWUFjvjNig1KDUgtXWetbTYgWSR+ie8/SAtUIIGpQalBqS27veVxFPwWp5mUILsKzUoNSg1 
ILX1UCb3ov+t3jmpgIkgmd4GogalBqUGpLbuL5pbHZRb00wqMFWmd4NSg1IDUlvviiDcPBzpnF66 
BqUGpQaktu5N/dx2AOJGvLaUTA1KDUoNSG3dkUTnHWB3OgbnbScExVdqUGpQakBq690cbsK3pNSm 
WmpQalBqQGrrnhTVnWcxLdRSg1KDUgNSW49GcTUoNSg1ILV1/2w5sgXTauZ2g1KDUgNSW+89lsNt 
ODUoNSg1ILX1qEBF2KDUoNSA1NYHUkdbFdwNSg1KDUhtfSjvegYmbFBqUGpAauseNdA7F082KDUo 
NSC19SjVU4NSg1IDUlsNSg1KDUoNSG01KDUofV5QakBqUGpQalBqQGqLbnOyEW4dYdKg1KDUgNTW 
gyieoxccAVODUoNSA1Jbj4hcDUoNSg1IbTUoNSg1KDUgfa7AaVBqUPp8oNSA1JRSg1KDUgNSWw1K 
DUoNSg1IDUoNSg1KDUhtNSg1KDUoNSA1KDUoNSg1ILXVoNSg1KDUgNSg1KDUoIQNSG01KDUoNSg1 
ILXVoNSg9KlAqQGpQalBqUGpAamtBqUPB6V8XYNSA1JbnzqUYBNKiAVMHxpKfBukCkqRr6N7hBKf 
JmhQakBq68NDiQp45rBaqKUtKNFRKPHDdHeFEt0ZSpNcfg9QYpUE5FC6ZihNDUqfN5DkS2rzc0n3 
/BGnM252l+dCH4ZT9wkl3IJSOA9KeBRKCo1NKGF3DEp4NpQCX4f+mPEBoHTDUHrFUMIGpaaQHv
 wj /Y4Qo
 fdNn7tDqdziBJToBJToIaDUKUA0zLoPKNWe0ikoTXwe7wClHUMpMJSQoXS9CaU+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/mhN7k9MISV1tBYY9l1434
 LjPr9g T
 oqiB/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/gONU
 qPL/P20Q
 Bp 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 
y8ww1pXUGmT1YwrJ4ATkQmYLPMaV6jK9KSGW1ES5LlZlCB15eSUfWZOWUAaU8y
 R31gfR4k
 mp62aV 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+yi2lZQESLB3m8
 l9dz/pcY
 Ruj0ohocy+ 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 
RloVRqaivoAL1hwrP8IP0WV7VwMJTvfC1f2ICUSzv43WPhPScSWWcm
 g095Mox8
 KYshUZTMGvL6qp 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 
ilIKbvdIpJX8J3IZH0pYh34Zru4nv9FCNxFE6AKMldjR0G3SCg
 KqQrcLPr
 9XOcaPesG420eT6PGG 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+w
 mcBO83/N
 8TmUesx8JTsWt0swhg/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/r5Syq
 JJjZHs3x
 chKSX1kTBaZau+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 
G8IXNqTt6DFbFUcuUv8WnqFn2sANazO2UedcRf
 eRYvGRXC
 WBTWKPFraJhxSUZ5rRl734QFO3Ey0b 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 
mDyiqySvsGVlFC31gcnMLurITACDUsn2GG
 ds2mDKop
 CNKAzuIwWse6U8NCPvzoP8yalqj24Hz8cK 
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 Gwdv5w1Y9LKlcAFTvRGWfcbSQUeLqk
 D6jFQSHR
 FISKchRlC2xMJKb0SaZeyWBjdVFd35vSw1Sph3 
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 fTCtPKao6dnJfCk3v3XcjYEpUu
 oW8K2Ski
 OAwZ9PtG+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 6nAKXoDt236hD6k06wrU3q
 hfS1ZKgD
 ra57MC0jmTI/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//970
 DysKa2+k
 j/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+fMJ4ZtbXu
 h/x4/x5x
 8LkGpjO/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/
 zsiizlL5
 m1f3IgfdQe0omw7T9x2PYTDtuGL1bmtg6L+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 tvyjlG
 Fb1SA99p
 1rtzaPXKukv2WV9D1WScPSS/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 /c
 F9I/45dE
 EjB7xm+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/DQ3MCglj8ZVU8fhmFTL5FNKYZP93FJUuoDmAjR5JIGI
 y hXFHex
 0CfvDJqidg1HF41vesjvZuZEs19q/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+opS6rJSlH28vXICtYUUz
 dpczE 7V
 wRHQxO08SHgsNpp1Y2Dlo/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 
XfPPz1wV1SFaSe133QkYSagWEoweubp9P495h9BtoZSke1ZKAlKLiZSwLkM4IgGTdKm
 94rf3GWj
 H 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/GTw0Q
 QBzz+voB
 1Py3r +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/UXqfaogYfVLwGCODgw4jXDAEZhBBCCCGEEEIIIYQ
 QQgghhBB
 CCCGEEEII 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+brX2Sg
 fb19+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/J52s
 QfO Oeic
 ynv1BuCnvnYEEbhZBdlD+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/OqKUnDiV4UjAaQ7Q1VXSiAsUMlxdvV0CUb7vIt
 5GMJc8o 
 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/N7gO9Tl9rRKl9rUyl0GwVRpcZRlcMjs9OHKIdx
 Ss6ULbsx
 MqI 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+JK41WoCVrG0IdaCWXicgKWRRxRQEIAnbUVBMJPaNQGGVGqjilMq5UApud
 zzwrUyTo
 EM0g+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+k8
 KuY0hymx
 fwHRFJDBTik 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 
NT4Kl8WNHayGRtmapldRJEooQEvdo4Zo6hcBXweDOkpdIUiSZ2Joa
 K62A1PxP
 lMJ9RVGBX6lzk2U 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+pnVy2KpvWWXV0yVk1MuQob
 amhWqm8l
 kLGUvQooZdm06KGaQIj 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/DdVKZ
 TU2/yiWr
 wIlTJxJC7P4Q9BlVas31P0z 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+cxayTXzSlO2mEiGbWQEK1i
 M3v4Q7XW
 EGEBkZ8224TTEUtmQwdYFNZViXV 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 
lXpVaQ9V4FquXYolbTeAbkLBnKQPbovTonJ21
 YYqpTSwq
 GnDUrGN+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 M7Shk27ooBAaYNQUkY6l0RAPjbKKAqm2l
 VaFkPmqV
 bTdbsdbrY92eETkGdylImYjNUY71cbB1T4c 
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 RnMyznSyGfbesK77vKmyisa0xmA3E
 dUPTDam+
 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+Et1odyr0DqTpUcnHeX03
 fFImZp9g
 BaqWTM7ogETQDWaq3IJZrhaWFNHOjFSdh/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 3dPNbBDZbQqQVhURdg22q
 Rt3qxMns
 f4szxvbuBMd8AQ6W7uMsGUvaRI/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/ng
 fCYiukdi
 QgDBnDs7rceEei2HE3L6FZSuuX06u+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 d3SifSDzdQSg6
 3zJv4wfb
 qGOHtnMfjggaaf/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 V5OZVVE0q
 X9sYKLbo
 oRw9G+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 xergN
 FjfvgbtP
 lsNOjg0z4YRqMNrLEOasAh7Hv+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
 /04Xzusd
 fw/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 YfTNb
 WD0iVRqv/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+lAfAHjTrr
 OwYaaf N
 bQfh1bnYYQbMOozaB8ERtAGqfUjZFdqjVYzZveHUbgLjNJ5GF3sUwERXfCUblRGdy18fPt8TOxP 
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+
 /HQkiHkc
 PI FdKn5v28y8Nx9UZYvR43YCQgCg4jh5EDydfZEAwtZcrP26NHsPOEcEsFhSFUG0O0AUYFOg4jh5ED 
ydetwDUOU4OmknBFHaH9uasxEuAVmFj44PCzw8hh5B7SJw6fMKTm+/AMFzNp2T9aaxkB+3yoj0fJ 
0Mn3I4ywB5LDyGHkQPpkLSU8e2dcuwbUzIYzqkq1ksPIYeTrkwUSrKbL8JaPDTUQ6zJpYCdAQqs/ 
GksCcMVTchg5jHx9wgoJ3vEYw5uOU2xQWk31m5/FQ3IYOYx8uYf0DlEednVGoNEZWuJBOFtzZFP8 
kJq57TByGDmQPm3IwC0OSBuudZ4Qwsrs7C0ZhhLhocw9GjJtKFm0CiiHkcPIgfTMQzJ8Jzjd/fiU 
jFqBTLBSaSVUFDW1SPsnU3vkMHIYfZLL65BuPhTRbDiLtThSK6tbJQAavxp7KMp9QVQQ2uLHFRiB 
wsZh5DByhfQpetxbbR72e1wN7Voz7CiEoNYtgcFQTfXXVhBcwKhCyGHkMHIgfTpaaAswsHSKKliq 
JMIt90mLJK2yMge7hGgAJqsG6DByGPlyhXTTgTi2hrQRITh28t9YSsDhHXS9bKka2XSCtvDMYeQw 
ciB9ImGZuQ5wFSQ43gfDoiutqR0ZVovDuJHByK7PZYzsoogkdMNgYBQcRg4jB5Ivc4jCIrgLfboe 
u8KjvvxxHBBgPSps6qjCSEO0DkQOI4eRA+nZrHQHJXRbBYUrHhOi7S7BATjrhnZvKw07hxjviMFm 
/CJgAEE5qZPDyGHkQHpWKiatutJnjzUAXEwL6X/ACjXo+tOG3UDGfjjcts5htSJb0/vYao0EQKj+ 
Ubmvw8hh5EB6nrHVfbxrDHV32fXHjDuANP+IeQXd9eXpoCkqUHUUjG/UtYSIf1TVkMPIYeRA+vhd 
oXPwgiE0qyGWfYoWeiEaGK2NrsUxFBTlBdjBKGzBqGbY5gYgmB1GDiMH0nMRSh
 UiYbOvfv
 WaAgkc 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/AUSoo
 4KjELfzU
 8wAYeRw8iB 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 
TF0SpeetkT3IMLpXuW8L2dp4276JtlV2L72js5k1h5HDyNcjAumtCJ
 LJFjKyKs
 G1Q5IAI2GbtZw0 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+M
 ztUySYSO
 r+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/ybTz
 T3MLK711
 oYBYeRLwfSg65pYiUU37Iu 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 
JygoPE2sYkgxzUXZlDmOBTIzgJnmmB9fprhFGcavrn
 eU8bPQdp
 etnhG0vdSGedhgaKUNuWEYtgag 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 
/A8st4FAbQ1Gc2KvKu0Te2kOI18OpLUDdKN95B
 f58k/z5W
 W7ys7W3u8xXObz6e01VGP7eMqhG7CP 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/ 
WooCHSkjalsYNShVSAXsZhpFCGYTSAnDIJ
 lts01GTU
 MzqZYuqkxCrrrlUZhrmFZ8o8S3U1ip9y8l 
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+1Ambd5xWAYlu8
 jq6QIZRJ
 DV4v5Nhs8cHEa+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/w2L
 tn296c2E
 t6Se0iP+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 nTIpACLPiZp86TlLUy9ypo
 760mgiAS
 kiBdEuP+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 sj0Y3GzW7adDKcDx2I
 dvZOSW7N
 s171CiIRzVHNGEybf5hH4VuEp7KsOTSMKEshslvGghXflKNULU 
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 ubAFJ10ZUuGr9u
 M33yyBVY
 Fjl8CnhG4EIGDqWCV0dzXkIPLl64kD6d3AZFVTGAG1cuMP8wAsCxy7 
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+C0B
 qjAYfvAw
 GH47T8IAUxgM8ITB8HsBSGEwLAYwGH4n 
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/Tu9EIBH8wCk
 LoHUqtEe
 oq9enVahACgMBnjC8F1ubi9u2kDPg1GbF0OT 
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 jSvB2EM4ncN1U4qPXkkMMwDU3aS4
 qMRE99cs
 xwBBWWrzhR/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/tRUqHi
 5hX4Oa0Z
 nUS9UgJyVJ8uvTYBrLy+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 1ykumOObMQv2WN20pBmz
 NKXOQaQK
 MGXCThFm8pthhWYGagKfqlC936LDOsVNK1AVuE5OgZsfYyPm 
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 1z5NZzkCoDAY4Al7
 ueAU1+yy
 T3WNUl5y22TUUkoOMolB3rhJWRWlz6rRTynhJ8JtLiBlc0oWsI3q 
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 mc0PAOpZG84f
 AVAY4AmD
 PWNwkjvOGtvcJ+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/NA
 AVAYDPCE
 vVxwLgrLmIPKXaN2Ns3bFaCllpO72GXjvt1pYlGrPG2cc5VtyyYx6OQ2gCZT 
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 wQBP
 GMA53ri6
 axtX7gqU8yDj1kxP4Xk1u/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 
 5vGWe3bL
 NTt23dKJ2wBQABQGeMIAzvcG5+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+D9R08GunozgHgAKgMMAT4AQ4PzFwXv7dA
 EAB UBjg
 CQM4PzlwlmvOqs3TKrQ8FgAKgMIAT4AT4Px0wPn+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 
JwAKgAKggCfACXACnAAoAAqAAp4AJ8AJcMIAUAAUAJ1ezI8S4AQ4YQAoAAqAAp4AJ8AJc
 AKgACgA 
 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+iaA8vAmXP8ZudvwQezChyeJQaI4vbhvb7UMZ
 RbXgoJTo
 Gni 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 
6ZDAKQ3faanK0i0prkkK0AwZAadAMpajBEAuAWJLBOtUVGAT29Tz1CjOGtfcV
 JQj1XmqJ
 IUzUEfg 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/JffzY
 e2u/eooC
 nMQ59TM2pwg 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 
UiXcNwCUd8ICjkw4HNj9Xl7RFUex9V3YfvPxIPlYbtvzSULvNrJrT
 7lrd8cuz
 pk7CGm3IFK4xM5B 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/gC3sw8HwHv4X7UU3ANo5E
 G66dE9Bl
 LfFEfOJutDuvjz4mZ7a 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 
y6WrEHku8VFaKV9t2eeSVslTWKKr16fMWzIxUMoj0Hbai
 Og4jn/m7
 Fu5r4inkfv2T9+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+rnKyvC0p0UhUqldwk
 vEcxr9UP
 I07mfWpCjQIrKtw38+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/zbfuemfLcyrI95bKVV
 yJv9k57Q
 dVEoZQktiwq/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 N0BrhZzPRzcqHLMCXNSVq9D03AbAy7Ath
 WU8UlJIE
 ndw5LZvbA/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/1WGzO3xdKboHF1dKmyB1qQ
 cemQ1Hzo
 bdfGN1VE4va10obA6PTB80Gyv2RIw1O+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 hdVBgDfYkF0dPPh6sysuDzaQb
 Hs8JsCxZ
 pKtEnwoQ5sGwNwaSj0C74artrT0o4tcs3SfYdVgJwzi 
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 Jqza6lE7OvDUlxpkhcEuk
 5l8fpeVC
 qVeiY4n1tuD/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/ahgM9oFgy
 wORMCCDy
 VFYJxVZcK4aKmgZCjcg7bNqjWs3A7PAtEKUTsRBqXPvMrVhsKww 
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 rlvWjNoYbD8us
 WeiKNem0
 7+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 CbJaHkuvB
 T0gOKTXH
 +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 NZDst
 RVfhOGx9
 e+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 8
 ixR4rYNo
 K/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/DvvMhHZH4nYuug6
 MO 1fYx3
 hmlYEr4WRLuDk7LXFxSnAKzY+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+gFNY4UKg8GeqXWKshwrXyCOaGPI2e
 JsXSg3 y
 UiU2nXHdTbfXgZr+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+xDm66LcJ2TghVAHg66n3HR7m9dhahkxx5TZyC5fR
 826SA0y/
 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+fcyPFA
 aDfVJA 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+aPJcMzPG3loAHvKMnxhMBjsfa
 0ow7NLbo
 2TyrSqvYGp 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 
YTAY7CnaFhBHNoLkWVi6NTDvrzKfLDSfOjwf4vW1IO1hugXUU1Ad2V
 1AC4PBYB
 /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 Tg2nxSG7qq
 sqMyszI8
 LN7tH5vPeauZmHR2ZEZmTEtWpv93D38PRwN/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 1zHADh
 cTZEdtz3
 cta/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 MA
 aBTA0uBx
 XD6VGvj8lrdhEdSs8qILFJ/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+tpvbQjSgmNoGITewtgchDMyT
 Y PK7U0P
 lv9d96PAvJ3hRCcEMAurEs8VroNa9wrrNdf/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 
dkglDWpcC5QSAYaVEQOHTe6Rv3a6bw4iDtHYIzqPtHf1gA8pLGPgfPpCvSEPyS6DUJ0dcwj
 91TsM xa
 4bQKvqZ571+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+UkSRxDccN58sgwfVjz
 fMnS2UlI
 h 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+pFjLulYDPZ9zp5IiAM
 dqR+ubP5
 2TDCa 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/mYpPadxoVN7tMI2MLoLQxiD
 ESsg8oX4
 bEveThaEj 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 
oXzcc0pDoWOP5SwZTIPqxcziPBN2nzNdbwPXOkvmoEnT30esPKJkEBL
 gJJmzghZ
 ei80jZrN5P97L 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 
NAnHVPnEoHGUGNlBQyfNmgUzwyvl49CRchAznHN6PrgaKn1k9Ww
 Of9668Rz
 rs/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+peNaa316SVjpZAJetuLET3
 MihaCSYm
 qmtPIwGH4gHzrGorZALzg 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 
tQ90HUb0jQPo2XoUJmHYfI1zhpAa0PrmdhaC8V91glq
 X4f1T/Nz
 RHL5ej2BdhaLXTFjIdTlc545S 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 
XVRUkJSbEN9e23720BblHGdm9HABuAkfh52FYXU
 27JAPdF1
 G9C2eaN5PdpdkENIlcHSdreS0sfhH 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/DOc
 n+7V6N2F
 E3wiA/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+xi4
 qH+g7kBK
 YXA/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/spWsQaQ0
 QH866DKW
 Md8a6RkKUesl2aU8ZmngWFeR1RJ32jgl8OqsnkgiL 
9yGGTicRlshwSZh0obQZaXCnnqL6QFF6IyUMMx/Io0BZZ68yorehKKG93PRCJuxWpuHrTNi8FuhR 
P82EfU1g2dInvqGLpAN5NdSgy9x4Gp1XHuG5JQ83gGdBv95Om2tw5NUiKZLNDYGjnvVYDfHSuKOf 
BQGtg1nPaKh9hbo418SYtAxEKNm2y5S9j9aIWMKnZKGTp/jdjK7hg57SV1MawMADalZGdOMZdLqH 
Nbfqu4dKCYWpeT7JkMHiuA44hidwSRr/Awq/8JjHpN4n2X7gE5qqhKoGVVoyiDpB3osPc7OxKmSU 
eQ7o0KkgpMonapEheFZNTo4CnmDZNLN0DD6So9eSkKCjO6xKH6ybVeZTdaaWef8YOsih2DRBoz7Q 
uRvRdDw+IAA9YyOa3sezWSbsJrdrA9BaJiwb0USfrz7fN9DnmbDn9E1sQaa44evhBR13HyHdBDai 
ef3scylEBRaUPNcS8YKXIUlZCfE3xZ4Q7x662uUo8+Q7XXtb9yhRT1YZr4VmmB2VmSgvqx7MHl9T 
Sg4dRI+/cwjlWS7b+3I9kYdloZqymDvjIfp9GufbUp2ujHJWDAoI/fG45AnVA89iyYhdFUZ3zpRO 
+T4PYrEK09HicdtPUIUmyKgNHtQhSywnHdczhrwkk31fWkDmEMo1Puo3a6ZLm1Vjpx2neRiElLDJ 
3PIMH63It5IQMbeTlgmBn2Zlnl43SmP2mOyrtrlZO6150321MqKZpdLS+gmd7F9MP6fLUvG3AkBP 
LzOiZ5kw9oF+NjOiax9oSxpv83AnPtD4GnDgwUoam0iikSeSoU+D40N1AOUOr1gA6MCR2xGK2pGV 
Lb1ZI2k9R7DHEoRc5xHKjJcJlLA4uHgIRDg9aKs5QFE9TAuhfFmgDB9XSap4cqW0uT35LOvV0pW6 yTOE7Hm5MHGSHYMVGB0RgsF
 dAE6tdqo
 TTT2WA2r42NpfPltD4yptkgAbNAfaiQjmOUuCFetEgUIn 
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
 +BVBGt2Y
 F5Fm1UHrRsOyknBTptMY/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 Yn8eBELWfiyrAUj
 vMe5QnjN
 K0SnpHlU6MpswDbZKJWRlA7mMXgrmE2bo6Dre5ioqkMRWsrGbut53 
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 luW1QVf20XU
 tR2nkkGp
 WBYvWT0uCQNUQCyqQlQ5GD7t0ZW5O/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 ycEidZH
 gEPOJeSV
 75tm4HI5hqtoAMFduVytyQi6wXpGh1Zk0r8ZaDdbACjo1eHAOmiLQfChgVkfz 
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 tX3
 oQAUoXAh
 toPIm1sK193GZv589QOEcRDhZGglmiqlaNFJ9mjwHA+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
  8Apmr5t
 CHY5h1m1LB3M9utPdn215ncXN64GGdzAU6p1NRFyaGR1sYFm9gKGHYjyu47WN66BPDB/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+fUGRlxYpJs6IRamU
 poO1 243
 J4CMZMkZRLN4PxNEMaoYTDDZliAO3QTJiYM2rdT1QKEZ1BaGhhpCn5+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+cHLZnSDKG5KZ0M
 SgwhPoge
  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+Xi1UpON4BqGOZ0zPINTNIORFij4zyCEUFiDk
 HfQTCAkw
 QuX1 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+Rfb1gDUINQgdL0QwjcIpxqLGoAa
 hBqE3hpC
 4QCI8IAx 3WDUANQg1CD01hDy8Kr+pTmQBFSXwKh5Rg1ADUINQleCUAjF12HIHAzL3hAvDUwNQA1CDUKLEMq3 
q58cRPXlqiFZA08DUINQg9CVIIR4ueO8ChtosGkAahBqELoEQngAQhNfaMEIwkPqBpvcaQBqEGoQ 
ugRCUEGoYkYGElSgmgugpdqgJaGETRk1ADUINQhdBiG7nvw8Uzj5shZ6HZO2f0sPuwGobQ1CdxxC 
Jfy6QoMqLCily1QPNgo1ADUINQjVEAr7CghvanpiA1ADUINQg9AEQgGK7zMbv4ErYdnxO0Q7JhqA 
GoQahA5mx5Q8EwjNQTQXLwuhWyNQA1CDUIPQ1SCEyxDaM6WXPKClwWb0ebT1xRqAGoQahI6DEMwh 
VPlAdc3QfEzHUtasAaYBqEGoQeitIDSrA6rrhhabVBfXFMPj1M5cQdHn1QDWANQgdJ8hNDGfYcKX 
ulNjXrjY7J4GoAahBqHrgdCsSx4PzI/GSzyha2fSfausbgBqELpbEAoKIcPLGoRCnabPQJqOcZ0o 
nwydhVGvOAmzlucHNf+oAahB6D5ASAGUf3YIhQIly44B7lVH47oKUogALvk7DS4NQA1CDUJzCGEN 
IbpKE8VTpelh1hMG0/sWa4EOQacBqQGoQeh+QygtQIhZ4/cnWAjJ5hmxKXwAcS8wO+DlNAg1ADUI 
3VsI4QEIsUddQjIoIdlSXZDDp/J3sPZ7cMknutRp3n/efQVWA1CD0D2EUBAIuVldUvJgiggqoxmy 
+Tzp2wizgUPzL77t+w1ADUINQksQggpCuUDR1FBRJ4AL8LHfxUmd0FQtXX2Z59UdpwGobQ1CHz6E 
uD6ohpDf1pCqsn3QQBQqGBl8lkKkeX2Qf9fXNTGxAahtDUJ3AEJepIgKH1cr9GnJ/W5Ol56xCkaA 
0y56XB7rceMq5656RA1ADUL3CkJgCsgtHL4/5LAKHTCTjNg0xMKw9pir
 HbAaI/OY
 bmyMKzYAta1B 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 
GoRuN4QEPBWEsABmAIFQGB1CdWYsVJky1HS9ZcTAPCJwKFWqCCdt
 HA4U2Fc8
 k8mLeISxDHsIOlYN 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 
Brse9fEJiARGaD4QlpYNBwurHweSpuurIWdSBuSLjklYBsWE
 nqblJ+uI
 sZpKFYsmCmlvT7j9O2sD UIPQvYEQOoRgCqH8mtJFb79fmdNqSOfq6VRMalE6AiQoTauJPgqHT2678NS9aZvFNelx36aemsxY 
QrG9KulxqnKijgRoAGpbg9D7hlAQCGGGEIYphILXCKlC0pU1EHJWDOtwzEd8oBcvKpAkfe99Yz66 
w1L0WCYrTpb7gdl411CPgq2UDTpwMHtGoVZFoYZTBaZDAui2pOQbgBqE7hSE6Pd2cwjJ/ajqBueq 
B4sxbbOkc4bM0vTs+ZRQzI3qApZcMR2qBQ6lNgitYhrrKmm2llkhAdaD63FlVY4AVVhWh2JQ2jai 
D0YDOAoqDJ94S1LyDUANQncKQmq9KoSwQIgfyxCapONz6FW9Xu4Xs4JFgDzs3pTSiNMO+tGBY0rJ 
M2KYV2FVR1nuDz60DEvBYpW2n0iTWMZ71NBBb8OXIkbLjEElhMYFI3pXwrMWgrWtQegmIBQWIBTM 
02EIqUqaQQhnEKqrpjXUyj1kkzaNetA9qFcEDqSQixS1kFHUkDo9plRKIyv/DNUkRZh4R8HT9rUp 
nTNnaT/DFausWUe3Pdzy5100D6htDUI3DyFYghBaSp7eqgBJUvMzCEHJmIEqotGLFmWutIVlDqJZ 
z5h30Gubh8EH84hXzMv/ZP8HrVoaq1EeniFbN6WxNqbTzP9RpSOZNamArj2fObBOjgzdGoDa1iD0 
phDiC9h9uQGVQjQ04OxByFVTKB31AiFt4XAQIWbQ6HXVQR+q9LzPnJaSRPeFoHTVQz07CG22dDXA 
DKvJiTgf4QFgxvU0/IIFKNUg2trt9xmSNQA1CN0LCNF9O4cQ1jVBGl6xv1O1bqB5QVNfqBQpWk2Q 
gsrqhKxfzAea6ZhXmaKY4WPhmN4vyojt46SlPZCKIQ1YrXVoI18RwzTrhXVWrFY9GKZd8ZMDHpZv 
NwC1rUHoJj0hZDMaFUQGIVRlo+oIp6GXGNYedoWSHfNU
 fahAJMPM
 UMOzYBcAe9+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 
NX3W73lnawBq252HEB2V4xxCiAsQYkUjoZfXDWmt
 UPGF3MAO
 excs685LhXWdjhcx4quwgq3CamvS 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+DtmOMrz0D9iw8joe9nR9t
 y+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/WHgvWLiUw0WXsn7UH9I
 ihTVhEaw
 lVhBfhbRE22ER1IIWQEisv8TyigOud3HHXIB 
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/ehvGza9pJ
 GoDadv8g
 1JN44DrEUUKvxCGYpOpT8X64ahotQ6bmtIVNDI6s 
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 xdKZ4ul8lpAVH4rHQzCil8kr
 acy6430k
 x2C+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/C6KC9sOv
 f1fCLz4h
 /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 DiN6IXGAGCTa
 upW0u8Lg
 ZDWEch9n/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 ojM2gXWd
 Zl2/NEkB
 oygjBhKpl8DD0aJdRhkcD9LGuun0vq7TlSvY34Fdhg7GJDU+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 2phT
 RN4P6axi
 GH+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 
 nYzGUlFS
 0mJKsapmbP9GZNONntdpB+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-pa
 th="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-o
 pacity=".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
similarity index 63%
rename from plugins/shotwell-publishing/picasa_publishing_options_pane.ui
rename to plugins/shotwell-publishing/google_photos_publishing_options_pane.ui
index 11e79afe..8685b965 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 45058b85..eeac1773 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 5e8ce1cc..af9ebf0b 100644
--- a/plugins/shotwell-publishing/org.gnome.Shotwell.Publishing.gresource.xml
+++ b/plugins/shotwell-publishing/org.gnome.Shotwell.Publishing.gresource.xml
@@ -3,13 +3,13 @@
   <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 3515f5fc..52c82ec1 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
 
diff --git a/src/plugins/StandardHostInterface.vala b/src/plugins/StandardHostInterface.vala
index 857c8ff7..d0f3ed4e 100644
--- a/src/plugins/StandardHostInterface.vala
+++ b/src/plugins/StandardHostInterface.vala
@@ -26,9 +26,6 @@ public class StandardHostInterface : Object, Spit.HostInterface {
             case "org.yorba.shotwell.publishing.facebook":
                 return "facebook";
             
-            case "org.yorba.shotwell.publishing.picasa":
-                return "picasa";
-            
             case "org.yorba.shotwell.publishing.flickr":
                 return "flickr";
                 
diff --git a/src/publishing/Publishing.vala b/src/publishing/Publishing.vala
index 6c30b910..455013c2 100644
--- a/src/publishing/Publishing.vala
+++ b/src/publishing/Publishing.vala
@@ -9,9 +9,9 @@ namespace Publishing {
 public void init() throws Error {
     string[] core_ids = new string[0];
     core_ids += "org.yorba.shotwell.publishing.facebook";
-    core_ids += "org.yorba.shotwell.publishing.picasa";
     core_ids += "org.yorba.shotwell.publishing.flickr";
     core_ids += "org.yorba.shotwell.publishing.youtube";
+    core_ids += "org.yorba.shotwell.publishing.gnome-photos";
     
     Plugins.register_extension_point(typeof(Spit.Publishing.Service), _("Publishing"),
         Resources.PUBLISH, core_ids);


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]