From 145d33ef9e4c94a6ae9f6c07c7c7c80cb82ecd7e Mon Sep 17 00:00:00 2001 From: Richard Mwewa <74001397+rly0nheart@users.noreply.github.com> Date: Sun, 3 Dec 2023 18:54:23 +0000 Subject: [PATCH] Add files via upload --- RPST GUI/RPST/ApiHandler.vb | 55 + RPST GUI/RPST/ApplicationEvents.vb | 29 + RPST GUI/RPST/Assets/ApiHandler.vb | 84 + RPST GUI/RPST/Assets/PostsProcessor.vb | 115 + RPST GUI/RPST/Assets/Settings.vb | 230 ++ RPST GUI/RPST/Assets/Utilities.vb | 173 ++ RPST GUI/RPST/LICENSE | 21 + RPST GUI/RPST/LICENSE.rtf | 19 + .../RPST/My Project/Application.Designer.vb | 45 + RPST GUI/RPST/My Project/Application.myapp | 12 + .../RPST/My Project/Resources.Designer.vb | 63 + RPST GUI/RPST/My Project/Resources.resx | 120 + RPST GUI/RPST/README.md | 52 + RPST GUI/RPST/RPST.vbproj | 87 + RPST GUI/RPST/RPST.vbproj.user | 14 + RPST GUI/RPST/Resources/icon-small.ico | Bin 0 -> 9662 bytes RPST GUI/RPST/Resources/icon.ico | Bin 0 -> 26547 bytes RPST GUI/RPST/Resources/icon.png | Bin 0 -> 49048 bytes RPST GUI/RPST/Windows/AboutBox.Designer.vb | 259 ++ RPST GUI/RPST/Windows/AboutBox.resx | 1491 ++++++++++ RPST GUI/RPST/Windows/AboutBox.vb | 82 + RPST GUI/RPST/Windows/MainWindow.Designer.vb | 311 +++ RPST GUI/RPST/Windows/MainWindow.resx | 2475 +++++++++++++++++ RPST GUI/RPST/Windows/MainWindow.vb | 203 ++ RPST GUI/RPST/Windows/PostsWindow.Designer.vb | 203 ++ RPST GUI/RPST/Windows/PostsWindow.resx | 622 +++++ RPST GUI/RPST/Windows/PostsWindow.vb | 3 + 27 files changed, 6768 insertions(+) create mode 100644 RPST GUI/RPST/ApiHandler.vb create mode 100644 RPST GUI/RPST/ApplicationEvents.vb create mode 100644 RPST GUI/RPST/Assets/ApiHandler.vb create mode 100644 RPST GUI/RPST/Assets/PostsProcessor.vb create mode 100644 RPST GUI/RPST/Assets/Settings.vb create mode 100644 RPST GUI/RPST/Assets/Utilities.vb create mode 100644 RPST GUI/RPST/LICENSE create mode 100644 RPST GUI/RPST/LICENSE.rtf create mode 100644 RPST GUI/RPST/My Project/Application.Designer.vb create mode 100644 RPST GUI/RPST/My Project/Application.myapp create mode 100644 RPST GUI/RPST/My Project/Resources.Designer.vb create mode 100644 RPST GUI/RPST/My Project/Resources.resx create mode 100644 RPST GUI/RPST/README.md create mode 100644 RPST GUI/RPST/RPST.vbproj create mode 100644 RPST GUI/RPST/RPST.vbproj.user create mode 100644 RPST GUI/RPST/Resources/icon-small.ico create mode 100644 RPST GUI/RPST/Resources/icon.ico create mode 100644 RPST GUI/RPST/Resources/icon.png create mode 100644 RPST GUI/RPST/Windows/AboutBox.Designer.vb create mode 100644 RPST GUI/RPST/Windows/AboutBox.resx create mode 100644 RPST GUI/RPST/Windows/AboutBox.vb create mode 100644 RPST GUI/RPST/Windows/MainWindow.Designer.vb create mode 100644 RPST GUI/RPST/Windows/MainWindow.resx create mode 100644 RPST GUI/RPST/Windows/MainWindow.vb create mode 100644 RPST GUI/RPST/Windows/PostsWindow.Designer.vb create mode 100644 RPST GUI/RPST/Windows/PostsWindow.resx create mode 100644 RPST GUI/RPST/Windows/PostsWindow.vb diff --git a/RPST GUI/RPST/ApiHandler.vb b/RPST GUI/RPST/ApiHandler.vb new file mode 100644 index 0000000..d2a56d4 --- /dev/null +++ b/RPST GUI/RPST/ApiHandler.vb @@ -0,0 +1,55 @@ +Imports System.IO +Imports System.Net.Http +Imports Newtonsoft.Json +Imports Newtonsoft.Json.Linq + +''' +''' Handles requests to Reddit and Github APIs. +''' +Public Class ApiHandler + Public Property LogFile As String = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "RedditPostScrapingTool", "logs", $"debug.log") + Public Property Headers As String = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/11.1.2 Safari/605.1.15" + Public Property UpdatesEndpoint As String = "https://api.github.com/repos/bellingcat/reddit-post-scraping-tool/releases/latest" + + ''' + ''' Asyncrosnously scrape Reddit data. + ''' + ''' Json object containing scraped data. + Public Async Function ScrapeRedditAsync(subreddit As String, listing As String, limit As Integer, timeframe As String) As Task(Of JObject) + Dim ApiEndpoint As String = $"https://www.reddit.com/r/{subreddit}/{listing}.json?limit={limit}&t={timeframe}" + Return Await GetJObjectFromEndpointAsync(endpoint:=ApiEndpoint) + End Function + + ''' + ''' Asyncrosnously gets remote version information from the repository release page. + ''' + ''' Json object containing update data. + Public Async Function CheckUpdatesAsync() As Task(Of JObject) + Return Await GetJObjectFromEndpointAsync(endpoint:=UpdatesEndpoint) + End Function + + ''' + ''' Asyncronously retrieves a JObject from the specified endpoint. + ''' + ''' The URL endpoint to retrieve data from. + ''' A JObject containing the retrieved data. + Private Async Function GetJObjectFromEndpointAsync(endpoint As String) As Task(Of JObject) + Try + Using httpClient As New HttpClient() + httpClient.DefaultRequestHeaders.Add("User-Agent", Headers) + Dim response As HttpResponseMessage = Await httpClient.GetAsync(endpoint) + If response.IsSuccessStatusCode Then + Dim json As String = response.Content.ReadAsStringAsync().Result + Dim data As JObject = JsonConvert.DeserializeObject(Of JObject)(json) + Return data + Else + MessageBox.Show(response.ReasonPhrase, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error) + End If + End Using + Catch ex As Exception + My.Computer.FileSystem.WriteAllText(LogFile, $"{DateTime.Now}: {ex}{Environment.NewLine}", True) + MessageBox.Show($"{ex.Message}. Please see the debug log '{LogFile}' for more information.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error) + End Try + Return New JObject() + End Function +End Class diff --git a/RPST GUI/RPST/ApplicationEvents.vb b/RPST GUI/RPST/ApplicationEvents.vb new file mode 100644 index 0000000..f9974e1 --- /dev/null +++ b/RPST GUI/RPST/ApplicationEvents.vb @@ -0,0 +1,29 @@ +Imports Microsoft.VisualBasic.ApplicationServices + +Namespace My + ' The following events are available for MyApplication: + ' Startup: Raised when the application starts, before the startup form is created. + ' Shutdown: Raised after all application forms are closed. This event is not raised if the application terminates abnormally. + ' UnhandledException: Raised if the application encounters an unhandled exception. + ' StartupNextInstance: Raised when launching a single-instance application and the application is already active. + ' NetworkAvailabilityChanged: Raised when the network connection is connected or disconnected. + + ' **NEW** ApplyApplicationDefaults: Raised when the application queries default values to be set for the application. + + ' Example: + ' Private Sub MyApplication_ApplyApplicationDefaults(sender As Object, e As ApplyApplicationDefaultsEventArgs) Handles Me.ApplyApplicationDefaults + ' + ' ' Setting the application-wide default Font: + ' e.Font = New Font(FontFamily.GenericSansSerif, 12, FontStyle.Regular) + ' + ' ' Setting the HighDpiMode for the Application: + ' e.HighDpiMode = HighDpiMode.PerMonitorV2 + ' + ' ' If a splash dialog is used, this sets the minimum display time: + ' e.MinimumSplashScreenDisplayTime = 4000 + ' End Sub + + Partial Friend Class MyApplication + + End Class +End Namespace diff --git a/RPST GUI/RPST/Assets/ApiHandler.vb b/RPST GUI/RPST/Assets/ApiHandler.vb new file mode 100644 index 0000000..89486e4 --- /dev/null +++ b/RPST GUI/RPST/Assets/ApiHandler.vb @@ -0,0 +1,84 @@ +Imports System.IO +Imports System.Net.Http +Imports Newtonsoft.Json +Imports Newtonsoft.Json.Linq + +''' +''' Handles requests to Reddit and Github APIs. +''' +Public Class ApiHandler + Public Property LogFile As String = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "RedditPostScrapingTool", "logs", $"debug.log") + Public Property Headers As String = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/11.1.2 Safari/605.1.15" + Public Property UpdatesEndpoint As String = "https://api.github.com/repos/bellingcat/reddit-post-scraping-tool/releases/latest" + + ''' + ''' Asyncrosnously scrape Reddit data. + ''' + ''' Json object containing scraped data. + Public Async Function AsyncGetPosts(subreddit As String, listing As String, limit As Integer, timeframe As String) As Task(Of JArray) + Dim PostsEndpoint As String = $"https://www.reddit.com/r/{subreddit}/{listing}.json?limit={limit}&t={timeframe}" + Return Await PaginatedPosts(endpoint:=PostsEndpoint, limit:=limit) + End Function + + ''' + ''' Retrieves posts in a paginated manner until the specified limit is reached. + ''' + ''' The API endpoint for retrieving posts. + ''' The limit on the number of posts to retrieve. + ''' A Task(Of JArray) representing the asynchronous operation, which upon completion returns a JArray of posts. + Private Async Function PaginatedPosts(endpoint As String, limit As Integer) As Task(Of JArray) + Dim allPosts As New JArray() + Dim lastPostId As String = "" + Dim useAfter As Boolean = limit > 100 + + While allPosts.Count < limit + Dim endpointWithAfter As String = If(useAfter And Not String.IsNullOrEmpty(lastPostId), $"{endpoint}&after={lastPostId}", endpoint) + Dim postsData As JObject = Await AsyncGetData(endpoint:=endpointWithAfter) + Dim postsChildren As JArray = postsData("data")("children") + + If postsChildren.Count = 0 Then + Exit While + End If + + allPosts.Merge(postsChildren) + + lastPostId = postsChildren.Last("data")("id").ToString() + End While + + Return allPosts + End Function + + + ''' + ''' Asyncrosnously gets remote version information from the repository release page. + ''' + ''' Json object containing update data. + Public Async Function CheckUpdatesAsync() As Task(Of JObject) + Return Await AsyncGetData(endpoint:=UpdatesEndpoint) + End Function + + ''' + ''' Asyncronously retrieves a JObject from the specified endpoint. + ''' + ''' The URL endpoint to retrieve data from. + ''' A JObject containing the retrieved data. + Private Async Function AsyncGetData(endpoint As String) As Task(Of JObject) + Try + Using httpClient As New HttpClient() + httpClient.DefaultRequestHeaders.Add("User-Agent", Headers) + Dim response As HttpResponseMessage = Await httpClient.GetAsync(endpoint) + If response.IsSuccessStatusCode Then + Dim json As String = response.Content.ReadAsStringAsync().Result + Dim data As JObject = JsonConvert.DeserializeObject(Of JObject)(json) + Return data + Else + MessageBox.Show(response.ReasonPhrase, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error) + End If + End Using + Catch ex As Exception + My.Computer.FileSystem.WriteAllText(LogFile, $"{DateTime.Now}: {ex}{Environment.NewLine}", True) + MessageBox.Show($"{ex.Message}. Please see the debug log '{LogFile}' for more information.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error) + End Try + Return New JObject() + End Function +End Class diff --git a/RPST GUI/RPST/Assets/PostsProcessor.vb b/RPST GUI/RPST/Assets/PostsProcessor.vb new file mode 100644 index 0000000..ae9dde5 --- /dev/null +++ b/RPST GUI/RPST/Assets/PostsProcessor.vb @@ -0,0 +1,115 @@ +Imports Newtonsoft.Json.Linq + +Public Class PostsProcessor + Private Shared ReadOnly ApiHandler As New ApiHandler() + + ''' + ''' Checks if the given Reddit post contains the given keyword in its text. + ''' + ''' The Reddit post to check. + ''' The keyword to check for. + ''' True if the post contains the keyword, False otherwise. + Public Shared Function PostContainsKeyword(post As JObject, keyword As String) As Boolean + Return post("data")("selftext").ToString.ToLower(Globalization.CultureInfo.InvariantCulture).Contains(keyword.ToLower(System.Globalization.CultureInfo.InvariantCulture)) + End Function + + + ''' + ''' Collects user inputs, fetches Reddit posts based on the inputs, checks if posts contain the keyword, and saves posts to a JSON file if necessary. + ''' + ''' Indicates whether to save the posts to a JSON file. + ''' + ''' This function initializes the DataGridView, iterates over each post, adds the posts containing the keyword to the DataGridView and updates the UI. + ''' It also shows a message if the keyword was not found in any of the posts or if the inputs are empty. + ''' + Public Shared Async Sub ProcessRedditPosts(settings) + ' Collect inputs from the user. + Dim inputs = Utilities.CollectInputs() + + If inputs.HasValue Then + ' Fetch Reddit posts based on the inputs. + Dim processor As New PostsProcessor() + Dim posts As JArray = Await ApiHandler.AsyncGetPosts(subreddit:=inputs.Value.Subreddit, listing:=inputs.Value.Listing, limit:=inputs.Value.Limit, timeframe:=inputs.Value.Timeframe) + Dim totalPosts As Integer = 0 + Dim keywordFound As Boolean = False + Dim foundPosts As Integer = 0 + Dim foundPostsList As New JArray + + PostsWindow.DataGridViewPosts.Rows.Clear() + PostsWindow.DataGridViewPosts.Columns.Clear() + + PostsWindow.DataGridViewPosts.Columns.Add("PostCount", "Index") + PostsWindow.DataGridViewPosts.Columns.Add("PostAuthor", "Author") + PostsWindow.DataGridViewPosts.Columns.Add("PostID", "ID") + PostsWindow.DataGridViewPosts.Columns.Add("PostTitle", "Title") + PostsWindow.DataGridViewPosts.Columns.Add("PostText", "Text") + PostsWindow.DataGridViewPosts.Columns.Add("PostSubreddit", "Subreddit") + PostsWindow.DataGridViewPosts.Columns.Add("SubredditVisibility", "Subreddit Type") + PostsWindow.DataGridViewPosts.Columns.Add("PostThumbnail", "Thumbnail") + PostsWindow.DataGridViewPosts.Columns.Add("PostIsNSFW", "NSFW") + PostsWindow.DataGridViewPosts.Columns.Add("PostIsGilded", "Is Gilded") + PostsWindow.DataGridViewPosts.Columns.Add("PostUpvotes", "Upvotes") + PostsWindow.DataGridViewPosts.Columns.Add("PostUpvoteRatio", "Upvote Ratio") + PostsWindow.DataGridViewPosts.Columns.Add("PostDownvotes", "Downvotes") + PostsWindow.DataGridViewPosts.Columns.Add("PostIsCrosspostable", "↪️ Is Shareable") + PostsWindow.DataGridViewPosts.Columns.Add("PostScore", "Score") + PostsWindow.DataGridViewPosts.Columns.Add("PostCategory", "Category") + PostsWindow.DataGridViewPosts.Columns.Add("PostDomain", "Domain") + PostsWindow.DataGridViewPosts.Columns.Add("PostPermalink", "Permalink") + PostsWindow.DataGridViewPosts.Columns.Add("PostCreatedAt", "Created At") + + ' Iterate over each post. + For Each post In posts + totalPosts += 1 + ' Check if the post contains the keyword + If PostsProcessor.PostContainsKeyword(post, inputs.Value.Keyword.ToLower(Globalization.CultureInfo.InvariantCulture)) Then + foundPosts += 1 + foundPostsList.Add(post) + + PostsWindow.DataGridViewPosts.Rows.Add(totalPosts, + post("data")("author"), + post("data")("id"), + post("data")("title"), + post("data")("selftext"), + post("data")("subreddit_name_prefixed"), + post("data")("subreddit_type"), + post("data")("thumbnail"), + post("data")("over_18"), + post("data")("gilded"), + post("data")("ups"), + post("data")("upvote_ratio"), + post("data")("downs"), + post("data")("is_crosspostable"), + post("data")("score"), + post("data")("category"), + post("data")("domain"), + post("data")("permalink"), + post("data")("created")) + + PostsWindow.Text = $"Showing {foundPosts}/{inputs.Value.Limit} {inputs.Value.Listing} posts containing the word {inputs.Value.Keyword}, from r/{inputs.Value.Subreddit}" + PostsWindow.Show() + keywordFound = True + End If + Next + + ' Check if the keyword was found in any posts + If Not keywordFound Then + MessageBox.Show($"Keyword `{inputs.Value.Keyword}` was not found in any of the " + posts("data")("children").Count.ToString(Globalization.CultureInfo.InvariantCulture) _ + + $" {inputs.Value.Listing} posts from r/{inputs.Value.Subreddit}", "Not Found", MessageBoxButtons.OK, MessageBoxIcon.Warning) + End If + + + If settings.SaveToJson Then + ' Save posts to a JSON file if SaveToJson is True. + Utilities.SavePostsToJson(posts:=foundPostsList) + End If + + If settings.SaveToCsv Then + ' Save posts to a CSV file if SaveToCsv is True. + Utilities.SavePostsToCSV(posts:=foundPostsList) + End If + Else + End If + End Sub + +End Class diff --git a/RPST GUI/RPST/Assets/Settings.vb b/RPST GUI/RPST/Assets/Settings.vb new file mode 100644 index 0000000..09a4f12 --- /dev/null +++ b/RPST GUI/RPST/Assets/Settings.vb @@ -0,0 +1,230 @@ +Imports System.IO +Imports System.Text.Json +Imports Newtonsoft.Json.Linq + + +Public Class SettingsManager + + ''' + ''' Represents the Dark Mode property. + ''' Indicates whether the dark mode is enabled or disabled. + ''' + Public Property DarkMode As Boolean + Public Property SaveToJson As Boolean + Public Property SaveToCsv As Boolean + + Private ReadOnly settingsFilePath As String = Path.Combine( + Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), + "RPST", + "settings.json" + ) + + ''' + ''' Loads application settings from the 'settings.json' file. + ''' If the settings file doesn't exist, it creates a new file with default settings. + ''' + Public Sub LoadSettings() + ' Check if the settings.json file exists + ' and load the configurations from it + If File.Exists(settingsFilePath) Then + Dim json As String = File.ReadAllText(settingsFilePath) + Dim options As New JsonSerializerOptions With {.PropertyNameCaseInsensitive = True} + Dim settings = JsonSerializer.Deserialize(Of SettingsManager)(json, options) + + DarkMode = settings.DarkMode + SaveToJson = settings.SaveToJson + SaveToCsv = settings.SaveToCsv + + MainWindow.DarkModeToolStripMenuItem.Checked = settings.DarkMode + MainWindow.ToJSONToolStripMenuItem.Checked = settings.SaveToJson + MainWindow.ToCSVToolStripMenuItem.Checked = settings.SaveToCsv + Else + ' Settings file does not exist + ' Create a new file with default settings 'False' + Dim defaultSettings = New SettingsManager With {.DarkMode = False, .SaveToCsv = False, .SaveToJson = False} + Dim jsonOutput = JsonSerializer.Serialize(defaultSettings) + File.WriteAllText(settingsFilePath, jsonOutput) + + + SaveToJson = False + SaveToCsv = False + MainWindow.ToJSONToolStripMenuItem.Checked = False + MainWindow.ToCSVToolStripMenuItem.Checked = False + + If Utilities.IsSystemDarkTheme() Then + DarkMode = True + MainWindow.DarkModeToolStripMenuItem.Checked = True + Else + DarkMode = False + MainWindow.DarkModeToolStripMenuItem.Checked = False + End If + End If + End Sub + + + ''' + ''' Retrieves application settings from a JSON file. + ''' + ''' A Dictionary containing the names and values of all settings. + ''' If the settings file doesn't exist, returns a Dictionary with default values. + Private Function GetSettings() As Dictionary(Of String, Object) + Dim settings As New Dictionary(Of String, Object) + If File.Exists(settingsFilePath) Then + ' Read and parse the JSON settings file. + Dim json As String = File.ReadAllText(settingsFilePath) + Dim jObject As JObject = JObject.Parse(json) + + ' Loop through each property in the JObject and add it to the settings Dictionary. + For Each item As JProperty In jObject.Properties() + settings.Add(item.Name, item.Value.ToObject(Of Object)()) + Next + Else + End If + Return settings + End Function + + ''' + ''' Saves the provided settings to the 'settings.json' file. + ''' + ''' An instance of the SettingsManager containing the configurations to be saved. + Private Sub SaveSettings(settings) + Dim jsonOutput = JsonSerializer.Serialize(settings) + File.WriteAllText(settingsFilePath, jsonOutput) + End Sub + + + ''' + ''' Applies the current settings to the application's interface. This includes + ''' toggling SaveToJson, SaveToCsv, and applying the visual theme based on the Dark Mode setting. + ''' + Public Sub ApplySettings() + ' Retrieve the current settings + Dim settings As Dictionary(Of String, Object) = GetSettings() + + ' Apply the SaveToJson setting to the menu item checkbox + MainWindow.ToJSONToolStripMenuItem.Checked = CBool(settings("SaveToJson")) + + ' Apply the SaveToCsv setting to the menu item checkbox + MainWindow.ToCSVToolStripMenuItem.Checked = CBool(settings("SaveToCsv")) + + ' Apply the color scheme based on the Dark Mode setting + ApplyColorScheme(isDarkMode:=CBool(settings("DarkMode"))) + End Sub + + ''' + ''' Applies the color scheme based on the given Dark Mode setting. + ''' Colors are defined in a mapping for easier maintenance and flexibility. + ''' + ''' Indicates whether Dark Mode is enabled. + Public Shared Sub ApplyColorScheme(ByVal isDarkMode As Boolean) + ' Initialize color mapping + Dim colorMap As New Dictionary(Of String, Color) + + If isDarkMode Then + ' Dark Mode colors + colorMap("MainBackground") = ColorTranslator.FromHtml("#FF121212") + colorMap("TextBoxBackground") = ColorTranslator.FromHtml("#FF2E2E2E") + colorMap("Foreground") = SystemColors.Control + colorMap("MenuBackground") = ColorTranslator.FromHtml("#FF121212") + colorMap("AboutBackground") = ColorTranslator.FromHtml("#FF121212") + colorMap("AboutForeground") = SystemColors.Control + colorMap("TabPageBackground") = ColorTranslator.FromHtml("#FF2E2E2E") + colorMap("TabPageForeground") = SystemColors.Control + colorMap("ButtonForeground") = Color.Black + Else + ' Light Mode colors + colorMap("MainBackground") = Color.Gainsboro + colorMap("TextBoxBackground") = SystemColors.Control + colorMap("Foreground") = ColorTranslator.FromHtml("#FF121212") + colorMap("MenuBackground") = Color.Gainsboro + colorMap("AboutBackground") = Color.Gainsboro + colorMap("AboutForeground") = SystemColors.WindowText + colorMap("TabPageBackground") = SystemColors.Control + colorMap("TabPageForeground") = SystemColors.WindowText + colorMap("ButtonForeground") = Color.Black + End If + + ' Applying Main Form colors + MainWindow.BackColor = colorMap("MainBackground") + MainWindow.TextBoxKeyword.BackColor = colorMap("TextBoxBackground") + MainWindow.TextBoxSubreddit.BackColor = colorMap("TextBoxBackground") + MainWindow.NumericUpDownLimit.BackColor = colorMap("TextBoxBackground") + MainWindow.ComboBoxListing.BackColor = colorMap("TextBoxBackground") + MainWindow.ComboBoxTimeframe.BackColor = colorMap("TextBoxBackground") + MainWindow.TextBoxKeyword.ForeColor = colorMap("Foreground") + MainWindow.TextBoxSubreddit.ForeColor = colorMap("Foreground") + MainWindow.NumericUpDownLimit.ForeColor = colorMap("Foreground") + MainWindow.ComboBoxListing.ForeColor = colorMap("Foreground") + MainWindow.ComboBoxTimeframe.ForeColor = colorMap("Foreground") + MainWindow.LabelKeyword.ForeColor = colorMap("Foreground") + MainWindow.LabelSubreddit.ForeColor = colorMap("Foreground") + MainWindow.LabelLimit.ForeColor = colorMap("Foreground") + MainWindow.LabelListing.ForeColor = colorMap("Foreground") + MainWindow.LabelTimeframe.ForeColor = colorMap("Foreground") + + ' Applying Right-Click Menu colors + MainWindow.SettingsToolStripMenuItem.BackColor = colorMap("MenuBackground") + MainWindow.DarkModeToolStripMenuItem.BackColor = colorMap("MenuBackground") + MainWindow.SavePostsToolStripMenuItem.BackColor = colorMap("MenuBackground") + MainWindow.ToJSONToolStripMenuItem.BackColor = colorMap("MenuBackground") + MainWindow.ToCSVToolStripMenuItem.BackColor = colorMap("MenuBackground") + MainWindow.AboutToolStripMenuItem.BackColor = colorMap("MenuBackground") + MainWindow.CheckForUpdatesToolStripMenuItem.BackColor = colorMap("MenuBackground") + MainWindow.QuitToolStripMenuItem.BackColor = colorMap("MenuBackground") + MainWindow.SettingsToolStripMenuItem.ForeColor = colorMap("Foreground") + MainWindow.DarkModeToolStripMenuItem.ForeColor = colorMap("Foreground") + MainWindow.SavePostsToolStripMenuItem.ForeColor = colorMap("Foreground") + MainWindow.ToJSONToolStripMenuItem.ForeColor = colorMap("Foreground") + MainWindow.ToCSVToolStripMenuItem.ForeColor = colorMap("Foreground") + MainWindow.AboutToolStripMenuItem.ForeColor = colorMap("Foreground") + MainWindow.CheckForUpdatesToolStripMenuItem.ForeColor = colorMap("Foreground") + MainWindow.QuitToolStripMenuItem.ForeColor = colorMap("Foreground") + + ' Applying About Box colors + AboutBox.BackColor = colorMap("AboutBackground") + AboutBox.TabPageAbout.BackColor = colorMap("TabPageBackground") + AboutBox.TabPageAuthor.BackColor = colorMap("TabPageBackground") + AboutBox.ForeColor = colorMap("AboutForeground") + AboutBox.LabelProgramName.ForeColor = colorMap("AboutForeground") + AboutBox.LabelDescription.ForeColor = colorMap("AboutForeground") + AboutBox.LabelCopyright.ForeColor = colorMap("AboutForeground") + AboutBox.LabelVersion.ForeColor = colorMap("AboutForeground") + AboutBox.LabelAuthor.ForeColor = colorMap("AboutForeground") + AboutBox.ButtonClose.ForeColor = colorMap("ButtonForeground") + + ' Updating Dark Mode Text + If isDarkMode Then + MainWindow.DarkModeToolStripMenuItem.Text = "Dark Mode: Disable" + Else + MainWindow.DarkModeToolStripMenuItem.Text = "Dark Mode: Enable" + End If + End Sub + + ''' + ''' Toggles specific settings on or off based on the provided parameters. + ''' + ''' A Boolean indicating if the setting option should be enabled or not. + ''' A String specifying the type of setting to toggle ('json', 'csv', or 'darkmode'). + Public Sub ToggleSettings(enabled As Boolean, saveTo As String) + ' Read the existing settings from the settings file + Dim json As String = File.ReadAllText(settingsFilePath) + Dim options As New JsonSerializerOptions With {.PropertyNameCaseInsensitive = True} + Dim settings As SettingsManager = JsonSerializer.Deserialize(Of SettingsManager)(json, options) + + ' Update the settings based on the specified saveTo parameter + If saveTo.ToLower(Globalization.CultureInfo.InvariantCulture) = "json" Then + settings.SaveToJson = enabled + ElseIf saveTo.ToLower(Globalization.CultureInfo.InvariantCulture) = "csv" Then + settings.SaveToCsv = enabled + ElseIf saveTo.ToLower(Globalization.CultureInfo.InvariantCulture) = "darkmode" Then + settings.DarkMode = enabled + Else + ' Handle unexpected value of saveTo (if needed) + End If + + ' Save the updated settings back to the settings file + SaveSettings(settings) + ' Apply the updated settings to the application + ApplySettings() + End Sub +End Class \ No newline at end of file diff --git a/RPST GUI/RPST/Assets/Utilities.vb b/RPST GUI/RPST/Assets/Utilities.vb new file mode 100644 index 0000000..cda4fb3 --- /dev/null +++ b/RPST GUI/RPST/Assets/Utilities.vb @@ -0,0 +1,173 @@ +Imports System.IO +Imports Microsoft.Win32 +Imports Newtonsoft.Json +Imports Newtonsoft.Json.Linq + +Public Class Utilities + + ''' + ''' Determines if the Windows system theme is in dark mode. + ''' + ''' + ''' True if the dark mode is enabled, otherwise false. + ''' + Public Shared Function IsSystemDarkTheme() As Boolean + Dim registryKey As RegistryKey = Registry.CurrentUser.OpenSubKey( + "Software\Microsoft\Windows\CurrentVersion\Themes\Personalize" + ) + If registryKey IsNot Nothing Then + Dim appsUseLightTheme As Object = registryKey.GetValue("AppsUseLightTheme") + Return appsUseLightTheme IsNot Nothing AndAlso CType(appsUseLightTheme, Integer) = 0 + Else + Return False + End If + End Function + + ''' + ''' Shows the license notice in a messagebox. + ''' + ''' + ''' Result of the Dialog (Yes/No). + ''' + Public Shared Function LicenseAgreement() + Dim result As DialogResult = MessageBox.Show($"{My.Application.Info.Copyright} + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the ""Software""), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.", "MIT License", MessageBoxButtons.OK, MessageBoxIcon.Information) + + Return result + End Function + + ''' + ''' Checks for the existence of the 'logs' directory under the 'RPST' directory within the user's AppData\Roaming folder. + ''' If the directory does not exist, it creates one. + ''' + ''' + ''' The directory path is 'C:\Users\\AppData\Roaming\RPST\logs'. + ''' If the 'RPST' or 'logs' directories do not exist, the function will create them. + ''' If the directories already exist, the function will not perform any actions. + ''' + Public Shared Sub PathFinder() + Dim directoryPath As String = Path.Combine( + Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), + "RPST", "logs" + ) + + If Not Directory.Exists(directoryPath) Then + Directory.CreateDirectory(directoryPath) + End If + End Sub + + + ''' + ''' Collects and validates user inputs from StartForm and returns them as a Tuple. + ''' + ''' + ''' Tuple containing: + ''' Keyword (String) - Keyword entered by user in theMainWindow. + ''' Subreddit (String) - Subreddit entered by user in theMainWindow. + ''' Listing (String) - Listing chosen by user in the StartForm, defaults to 'top' if none is selected. + ''' Limit (Integer) - Limit entered by user in the StartForm, defaults to 10 if the entered value is over 100. + ''' Timeframe (String) - Timeframe chosen by user in the StartForm, defaults to 'all' if none is selected. + ''' + ''' + ''' If keyword or subreddit are empty, Displays a warning and returns nothing. + ''' + Public Shared Function CollectInputs() As (Keyword As String, Subreddit As String, Listing As String, Limit As Integer, Timeframe As String)? + Dim keyword As String = MainWindow.TextBoxKeyword.Text.Trim() + Dim subreddit As String = MainWindow.TextBoxSubreddit.Text.Trim() + ' Convert the Listing and Subreddit to lowercase using InvariantCulture. + Dim listing As String = If(String.IsNullOrEmpty(MainWindow.ComboBoxListing.Text), "top", MainWindow.ComboBoxListing.Text.ToLower(Globalization.CultureInfo.InvariantCulture).Trim()) + Dim timeframe As String = If(String.IsNullOrEmpty(MainWindow.ComboBoxTimeframe.Text), "all", MainWindow.ComboBoxTimeframe.Text.ToLower(Globalization.CultureInfo.InvariantCulture).Trim()) + Dim limit As Integer = MainWindow.NumericUpDownLimit.Value + + ' Validate inputs. + If String.IsNullOrEmpty(keyword) AndAlso String.IsNullOrEmpty(subreddit) Then + MessageBox.Show("Keyword and Subreddit should not be empty.", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning) + Return Nothing + ElseIf String.IsNullOrEmpty(keyword) Then + MessageBox.Show("Keyword field should not be empty.", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning) + Return Nothing + ElseIf String.IsNullOrEmpty(subreddit) Then + MessageBox.Show("Subreddit field should not be empty.", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning) + Return Nothing + End If + Return (keyword, subreddit, listing, limit, timeframe) + End Function + + + ''' + ''' Saves the gives posts' data to a JSON file. + ''' + ''' The object containing posts to be saved. + ''' + ''' This function allows the user to select a location to save the posts. + ''' If the user confirms the save location, the posts will be serialized + ''' to JSON with an indented format and written to the chosen file. + ''' A success message will be displayed to the user upon successful save. + ''' + Public Shared Sub SavePostsToJson(posts As Object) + Dim saveFileDialog As New SaveFileDialog With { + .Filter = "JSON files (*.json)|*.json", + .Title = "Save posts to JSON" + } + + If saveFileDialog.ShowDialog() = DialogResult.OK Then + Dim fileName As String = saveFileDialog.FileName + Dim serializerSettings As New JsonSerializerSettings With { + .Formatting = Formatting.Indented + } + Dim json As String = JsonConvert.SerializeObject(posts, serializerSettings) + + File.WriteAllText(fileName, json) + + MessageBox.Show($"Posts saved to {fileName}", "Saved", MessageBoxButtons.OK, MessageBoxIcon.Information) + End If + End Sub + + + ''' + ''' Saves Reddit posts contained in a JArray to a CSV file. + ''' + ''' A JArray containing the Reddit posts to be saved. + ''' + ''' This function displays a SaveFileDialog to allow the user to specify the file name and location. + ''' It then iterates through the JArray to write each post's details (totalPosts, title, subreddit, author, score) into the selected CSV file. + ''' + Public Shared Sub SavePostsToCSV(posts As JArray) + Dim saveFileDialog As New SaveFileDialog With { + .Filter = "CSV files (*.csv)|*.csv", + .Title = "Save posts to CSV" + } + + If saveFileDialog.ShowDialog() = DialogResult.OK Then + Dim fileName As String = saveFileDialog.FileName + Using csvWriter As New StreamWriter(fileName) + ' Write the header. + csvWriter.WriteLine("Index,Author,ID,Subreddit,Visibility,Thumbnail,NSFW,Gilded,Upvotes,Upvote Ratio,Downvotes,Award,Top Award,Is cross-postable?,Score,Category,Text,Domain,Permalink,Created At,Approved At,Approved By") + + Dim postCount As Integer = 0 + For Each post In posts + postCount += 1 + csvWriter.WriteLine($"{postCount},{post("data")("author")},{post("data")("id")},{post("data")("subreddit_name_prefixed")},{post("data")("subreddit_type")},{post("data")("thumbnail")},{post("data")("over_18")},{post("data")("gilded")},{post("data")("ups")},{post("data")("upvote_ratio")},{post("data")("downs")},{post("data")("total_awards_received")},{post("data")("top_awarded_type")},{post("data")("is_crosspostable")},{post("data")("score")},{post("data")("category")},{post("data")("selftext")},{post("data")("domain")},{post("data")("permalink")},{post("data")("created")},{post("data")("approved_at_utc")},{post("data")("approved_by")}") + Next + End Using + + MessageBox.Show($"Posts saved to {fileName}", "Saved", MessageBoxButtons.OK, MessageBoxIcon.Information) + End If + End Sub +End Class diff --git a/RPST GUI/RPST/LICENSE b/RPST GUI/RPST/LICENSE new file mode 100644 index 0000000..edb9e84 --- /dev/null +++ b/RPST GUI/RPST/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2023 Richard Mwewa + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/RPST GUI/RPST/LICENSE.rtf b/RPST GUI/RPST/LICENSE.rtf new file mode 100644 index 0000000..d2d7702 --- /dev/null +++ b/RPST GUI/RPST/LICENSE.rtf @@ -0,0 +1,19 @@ +{\rtf1\ansi\ansicpg1252\cocoartf2577 +\cocoatextscaling0\cocoaplatform0{\fonttbl\f0\fswiss\fcharset0 Helvetica;} +{\colortbl;\red255\green255\blue255;} +{\*\expandedcolortbl;;} +\paperw11900\paperh16840\margl1440\margr1440\vieww13560\viewh17700\viewkind0 +\pard\tx0\tx566\tx1133\tx1700\tx2267\tx2834\tx3401\tx3968\tx4535\tx5102\tx5669\tx6236\tx6803\pardirnatural\partightenfactor0 + +{ + {\header The MIT License (MIT)} +The MIT License (MIT)\par + \fs20\li0\fi0 Copyright (c) 2023 Richard Mwewa +\par\par +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +\par\par +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +\par\par +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\par +} +} diff --git a/RPST GUI/RPST/My Project/Application.Designer.vb b/RPST GUI/RPST/My Project/Application.Designer.vb new file mode 100644 index 0000000..73f46c2 --- /dev/null +++ b/RPST GUI/RPST/My Project/Application.Designer.vb @@ -0,0 +1,45 @@ +'------------------------------------------------------------------------------ +' +' This code was generated by a tool. +' Runtime Version:4.0.30319.42000 +' +' Changes to this file may cause incorrect behavior and will be lost if +' the code is regenerated. +' +'------------------------------------------------------------------------------ + +Option Strict On +Option Explicit On + + +Namespace My + + 'NOTE: This file is auto-generated; do not modify it directly. To make changes, + ' or if you encounter build errors in this file, go to the Project Designer + ' (go to Project Properties or double-click the My Project node in + ' Solution Explorer), and make changes on the Application tab. + ' + Partial Friend Class MyApplication + + _ + Public Sub New() + MyBase.New(Global.Microsoft.VisualBasic.ApplicationServices.AuthenticationMode.Windows) + Me.IsSingleInstance = false + Me.EnableVisualStyles = true + Me.SaveMySettingsOnExit = true + Me.ShutDownStyle = Global.Microsoft.VisualBasic.ApplicationServices.ShutdownMode.AfterMainFormCloses + Me.HighDpiMode = HighDpiMode.DpiUnaware + End Sub + + _ + Protected Overrides Sub OnCreateMainForm() + Me.MainForm = Global.RPST.MainWindow + End Sub + + + Protected Overrides Function OnInitialize(ByVal commandLineArgs As System.Collections.ObjectModel.ReadOnlyCollection(Of String)) As Boolean + Me.MinimumSplashScreenDisplayTime = 2000 + Return MyBase.OnInitialize(commandLineArgs) + End Function + End Class +End Namespace diff --git a/RPST GUI/RPST/My Project/Application.myapp b/RPST GUI/RPST/My Project/Application.myapp new file mode 100644 index 0000000..0f377ee --- /dev/null +++ b/RPST GUI/RPST/My Project/Application.myapp @@ -0,0 +1,12 @@ + + + true + MainWindow + false + 0 + true + 0 + true + + 2000 + \ No newline at end of file diff --git a/RPST GUI/RPST/My Project/Resources.Designer.vb b/RPST GUI/RPST/My Project/Resources.Designer.vb new file mode 100644 index 0000000..cc0c0d8 --- /dev/null +++ b/RPST GUI/RPST/My Project/Resources.Designer.vb @@ -0,0 +1,63 @@ +'------------------------------------------------------------------------------ +' +' This code was generated by a tool. +' Runtime Version:4.0.30319.42000 +' +' Changes to this file may cause incorrect behavior and will be lost if +' the code is regenerated. +' +'------------------------------------------------------------------------------ + +Option Strict On +Option Explicit On + +Imports System + +Namespace My.Resources + + 'This class was auto-generated by the StronglyTypedResourceBuilder + 'class via a tool like ResGen or Visual Studio. + 'To add or remove a member, edit your .ResX file then rerun ResGen + 'with the /str option, or rebuild your VS project. + ''' + ''' A strongly-typed resource class, for looking up localized strings, etc. + ''' + _ + Friend Module Resources + + Private resourceMan As Global.System.Resources.ResourceManager + + Private resourceCulture As Global.System.Globalization.CultureInfo + + ''' + ''' Returns the cached ResourceManager instance used by this class. + ''' + _ + Friend ReadOnly Property ResourceManager() As Global.System.Resources.ResourceManager + Get + If Object.ReferenceEquals(resourceMan, Nothing) Then + Dim temp As Global.System.Resources.ResourceManager = New Global.System.Resources.ResourceManager("RPST.Resources", GetType(Resources).Assembly) + resourceMan = temp + End If + Return resourceMan + End Get + End Property + + ''' + ''' Overrides the current thread's CurrentUICulture property for all + ''' resource lookups using this strongly typed resource class. + ''' + _ + Friend Property Culture() As Global.System.Globalization.CultureInfo + Get + Return resourceCulture + End Get + Set + resourceCulture = value + End Set + End Property + End Module +End Namespace diff --git a/RPST GUI/RPST/My Project/Resources.resx b/RPST GUI/RPST/My Project/Resources.resx new file mode 100644 index 0000000..29dcb1b --- /dev/null +++ b/RPST GUI/RPST/My Project/Resources.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/RPST GUI/RPST/README.md b/RPST GUI/RPST/README.md new file mode 100644 index 0000000..f301177 --- /dev/null +++ b/RPST GUI/RPST/README.md @@ -0,0 +1,52 @@ +![rpst](https://github.com/bellingcat/reddit-post-scraping-tool/assets/74001397/b9ec50b2-d2cb-419f-b8f0-d170b0630875) + +## Note + +> Use [Knew Karma](https://github.com/bellingcat/knewkarma) for more advanced and improved features. + +# RPST (Reddit Post Scraping Tool) + +Retrieve **Reddit** posts that contain the specified **keyword** from a specified **subreddit**. + +[![Upload Python Package](https://github.com/bellingcat/reddit-post-scraping-tool/actions/workflows/python-publish.yml/badge.svg)](https://github.com/rly0nheart/reddit-post-scraping-tool/actions/workflows/python-publish.yml) [![CodeQL](https://github.com/bellingcat/reddit-post-scraping-tool/actions/workflows/codeql.yml/badge.svg)](https://github.com/rly0nheart/reddit-post-scraping-tool/actions/workflows/codeql.yml) ![.Net](https://img.shields.io/badge/.NET-5C2D91?style=flat&logo=.net&logoColor=white) ![Python](https://img.shields.io/badge/python-3670A0?style=flat&logo=python&logoColor=ffdd54) + +# ✅ Features + +## *GUI* + +- [x] Dark mode (*Right-click>Settings>Dark Mode*). +- [x] Saves results to a JSON/CSV file (*Right-click>Settings>Save posts>to JSON/to CSV*). +- [x] Logs errors to a file. +- [x] In-App feature to check for Updates. + +## *CLI* + +- [x] Saves results to JSON (*specifiy* `--json`). +- [x] Saves results to CSV (*specify* `--csv`). +- [x] Automatically checks for new updates, and notifies user if updates were found. + +# 📃 TODO + +## *GUI* + +- [ ] Make it installable with a setup.exe/setup.msi file. + +# 🖥️ Tested environments + +## *GUI* + +- [x] Microsoft Windows 11 + +## *CLI* + +- [x] Android Termux +- [x] Microsoft Windows 11 +- [x] Ubuntu 22.04 - latest versions + +# 📖 Documentation + +[Refer to the Wiki](https://github.com/bellingcat/reddit-post-scraping-tool/wiki) for installation instructions, in +addition to all other documentation. + +*** +[![me](https://github.com/bellingcat/knewkarma/assets/74001397/efd19c7e-9840-4969-b33c-04087e73e4da)](https://about.me/rly0nheart) diff --git a/RPST GUI/RPST/RPST.vbproj b/RPST GUI/RPST/RPST.vbproj new file mode 100644 index 0000000..7bc0df6 --- /dev/null +++ b/RPST GUI/RPST/RPST.vbproj @@ -0,0 +1,87 @@ + + + + WinExe + net6.0-windows + RPST.My.MyApplication + true + WindowsForms + Resources\icon.ico + Richard Mwewa + Retrieve Reddit posts that contain the specified keyword from a specified subreddit. + © 2023 Richard Mwewa. All rights reserved. + https://github.com/bellingcat/reddit-post-scraping-tool + README.md + https://github.com/bellingcat/reddit-post-scraping-tool + 2.0.0.0 + 2.0.0.0 + LICENSE + True + 2.0.0 + reddit;scraper;reddit-scraper;osint + + 6.0-recommended + RPST + Richard Mwewa + en + $(AssemblyName) (Reddit Post Scraping Tool) + RPST + Reddit Post Scraping Tool. + icon.png + + + + + + + + + + + + + + + + + + + True + True + Application.myapp + + + True + True + Resources.resx + + + + + + My.Resources + VbMyResourcesResXFileCodeGenerator + Resources.Designer.vb + + + + + + True + \ + + + MyApplicationCodeGenerator + Application.Designer.vb + + + True + \ + + + True + \ + + + + diff --git a/RPST GUI/RPST/RPST.vbproj.user b/RPST GUI/RPST/RPST.vbproj.user new file mode 100644 index 0000000..c1bdef1 --- /dev/null +++ b/RPST GUI/RPST/RPST.vbproj.user @@ -0,0 +1,14 @@ + + + + + Form + + + Form + + + Form + + + \ No newline at end of file diff --git a/RPST GUI/RPST/Resources/icon-small.ico b/RPST GUI/RPST/Resources/icon-small.ico new file mode 100644 index 0000000000000000000000000000000000000000..1d468c73e11e800e7fec3c55301ad66491e72550 GIT binary patch literal 9662 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 Z&GkcrctEaam+@N1b*`@Y_ee62{|6$f{jLB2 literal 0 HcmV?d00001 diff --git a/RPST GUI/RPST/Resources/icon.ico b/RPST GUI/RPST/Resources/icon.ico new file mode 100644 index 0000000000000000000000000000000000000000..3444786c191d2371ef0c2ad3f763319a9620bd78 GIT binary patch literal 26547 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 DknC#N literal 0 HcmV?d00001 diff --git a/RPST GUI/RPST/Resources/icon.png b/RPST GUI/RPST/Resources/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..892563c31445d6316d567d63f91cb02556fc3a44 GIT binary patch literal 49048 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 literal 0 HcmV?d00001 diff --git a/RPST GUI/RPST/Windows/AboutBox.Designer.vb b/RPST GUI/RPST/Windows/AboutBox.Designer.vb new file mode 100644 index 0000000..b7420df --- /dev/null +++ b/RPST GUI/RPST/Windows/AboutBox.Designer.vb @@ -0,0 +1,259 @@ + _ +Partial Class AboutBox + Inherits System.Windows.Forms.Form + + 'Form overrides dispose to clean up the component list. + _ + Protected Overrides Sub Dispose(ByVal disposing As Boolean) + Try + If disposing AndAlso components IsNot Nothing Then + components.Dispose() + End If + Finally + MyBase.Dispose(disposing) + End Try + End Sub + + 'Required by the Windows Form Designer + Private components As System.ComponentModel.IContainer + + 'NOTE: The following procedure is required by the Windows Form Designer + 'It can be modified using the Windows Form Designer. + 'Do not modify it using the code editor. + _ + Private Sub InitializeComponent() + Dim resources As ComponentModel.ComponentResourceManager = New ComponentModel.ComponentResourceManager(GetType(AboutBox)) + PictureBoxLogo = New PictureBox() + LabelProgramName = New Label() + LabelDescription = New Label() + TabControl1 = New TabControl() + TabPageAbout = New TabPage() + LabelCopyright = New Label() + LinkLabelLicense = New LinkLabel() + LinkLabelReadtheWiki = New LinkLabel() + TabPageAuthor = New TabPage() + LinkLabelEmail = New LinkLabel() + LinkLabelBMC = New LinkLabel() + LinkLabelAboutMe = New LinkLabel() + LabelAuthor = New Label() + LabelVersion = New Label() + ButtonClose = New Button() + CType(PictureBoxLogo, ComponentModel.ISupportInitialize).BeginInit() + TabControl1.SuspendLayout() + TabPageAbout.SuspendLayout() + TabPageAuthor.SuspendLayout() + SuspendLayout() + ' + ' PictureBoxLogo + ' + PictureBoxLogo.BackColor = Color.Transparent + PictureBoxLogo.Image = CType(resources.GetObject("PictureBoxLogo.Image"), Image) + PictureBoxLogo.Location = New Point(12, 12) + PictureBoxLogo.Name = "PictureBoxLogo" + PictureBoxLogo.Size = New Size(62, 64) + PictureBoxLogo.SizeMode = PictureBoxSizeMode.StretchImage + PictureBoxLogo.TabIndex = 0 + PictureBoxLogo.TabStop = False + ' + ' LabelProgramName + ' + LabelProgramName.AutoSize = True + LabelProgramName.Font = New Font("Segoe UI Semibold", 9.75F, FontStyle.Bold, GraphicsUnit.Point) + LabelProgramName.ForeColor = SystemColors.ControlText + LabelProgramName.Location = New Point(80, 33) + LabelProgramName.Name = "LabelProgramName" + LabelProgramName.Size = New Size(44, 17) + LabelProgramName.TabIndex = 3 + LabelProgramName.Text = "Name" + ' + ' LabelDescription + ' + LabelDescription.AutoSize = True + LabelDescription.Font = New Font("Segoe UI", 9F, FontStyle.Regular, GraphicsUnit.Point) + LabelDescription.ForeColor = SystemColors.ControlText + LabelDescription.Location = New Point(6, 7) + LabelDescription.Name = "LabelDescription" + LabelDescription.Size = New Size(67, 15) + LabelDescription.TabIndex = 4 + LabelDescription.Text = "Description" + ' + ' TabControl1 + ' + TabControl1.Controls.Add(TabPageAbout) + TabControl1.Controls.Add(TabPageAuthor) + TabControl1.Font = New Font("Segoe UI", 9F, FontStyle.Regular, GraphicsUnit.Point) + TabControl1.Location = New Point(12, 91) + TabControl1.Name = "TabControl1" + TabControl1.SelectedIndex = 0 + TabControl1.Size = New Size(322, 152) + TabControl1.TabIndex = 8 + ' + ' TabPageAbout + ' + TabPageAbout.BackColor = Color.Transparent + TabPageAbout.Controls.Add(LabelCopyright) + TabPageAbout.Controls.Add(LinkLabelLicense) + TabPageAbout.Controls.Add(LabelDescription) + TabPageAbout.Controls.Add(LinkLabelReadtheWiki) + TabPageAbout.Font = New Font("Segoe UI Semibold", 9F, FontStyle.Bold, GraphicsUnit.Point) + TabPageAbout.Location = New Point(4, 24) + TabPageAbout.Name = "TabPageAbout" + TabPageAbout.Padding = New Padding(3) + TabPageAbout.Size = New Size(314, 124) + TabPageAbout.TabIndex = 0 + TabPageAbout.Text = "About" + ' + ' LabelCopyright + ' + LabelCopyright.AutoSize = True + LabelCopyright.Font = New Font("Segoe UI", 9F, FontStyle.Regular, GraphicsUnit.Point) + LabelCopyright.Location = New Point(6, 97) + LabelCopyright.Name = "LabelCopyright" + LabelCopyright.Size = New Size(60, 15) + LabelCopyright.TabIndex = 7 + LabelCopyright.Text = "Copyright" + ' + ' LinkLabelLicense + ' + LinkLabelLicense.AutoSize = True + LinkLabelLicense.Font = New Font("Segoe UI", 9F, FontStyle.Regular, GraphicsUnit.Point) + LinkLabelLicense.Location = New Point(6, 52) + LinkLabelLicense.Name = "LinkLabelLicense" + LinkLabelLicense.Size = New Size(84, 15) + LinkLabelLicense.TabIndex = 5 + LinkLabelLicense.TabStop = True + LinkLabelLicense.Text = "🗒️ MIT License" + ' + ' LinkLabelReadtheWiki + ' + LinkLabelReadtheWiki.AutoSize = True + LinkLabelReadtheWiki.Font = New Font("Segoe UI", 9F, FontStyle.Regular, GraphicsUnit.Point) + LinkLabelReadtheWiki.Location = New Point(6, 74) + LinkLabelReadtheWiki.Name = "LinkLabelReadtheWiki" + LinkLabelReadtheWiki.Size = New Size(94, 15) + LinkLabelReadtheWiki.TabIndex = 6 + LinkLabelReadtheWiki.TabStop = True + LinkLabelReadtheWiki.Text = "📖 Read the Wiki" + ' + ' TabPageAuthor + ' + TabPageAuthor.BackColor = Color.Transparent + TabPageAuthor.Controls.Add(LinkLabelEmail) + TabPageAuthor.Controls.Add(LinkLabelBMC) + TabPageAuthor.Controls.Add(LinkLabelAboutMe) + TabPageAuthor.Controls.Add(LabelAuthor) + TabPageAuthor.ForeColor = SystemColors.ControlText + TabPageAuthor.Location = New Point(4, 24) + TabPageAuthor.Name = "TabPageAuthor" + TabPageAuthor.Padding = New Padding(3) + TabPageAuthor.Size = New Size(314, 124) + TabPageAuthor.TabIndex = 1 + TabPageAuthor.Text = "Author" + ' + ' LinkLabelEmail + ' + LinkLabelEmail.AutoSize = True + LinkLabelEmail.Location = New Point(6, 89) + LinkLabelEmail.Name = "LinkLabelEmail" + LinkLabelEmail.Size = New Size(51, 15) + LinkLabelEmail.TabIndex = 3 + LinkLabelEmail.TabStop = True + LinkLabelEmail.Text = "📧 Email" + ' + ' LinkLabelBMC + ' + LinkLabelBMC.AutoSize = True + LinkLabelBMC.Location = New Point(3, 66) + LinkLabelBMC.Name = "LinkLabelBMC" + LinkLabelBMC.Size = New Size(111, 15) + LinkLabelBMC.TabIndex = 2 + LinkLabelBMC.TabStop = True + LinkLabelBMC.Text = "🍵 Buy Me A Coffee" + ' + ' LinkLabelAboutMe + ' + LinkLabelAboutMe.AutoSize = True + LinkLabelAboutMe.Location = New Point(6, 43) + LinkLabelAboutMe.Name = "LinkLabelAboutMe" + LinkLabelAboutMe.Size = New Size(75, 15) + LinkLabelAboutMe.TabIndex = 1 + LinkLabelAboutMe.TabStop = True + LinkLabelAboutMe.Text = "🔗 About.me" + ' + ' LabelAuthor + ' + LabelAuthor.AutoSize = True + LabelAuthor.Font = New Font("Segoe UI", 9F, FontStyle.Bold, GraphicsUnit.Point) + LabelAuthor.Location = New Point(6, 15) + LabelAuthor.Name = "LabelAuthor" + LabelAuthor.Size = New Size(96, 15) + LabelAuthor.TabIndex = 0 + LabelAuthor.Text = "Richard Mwewa" + ' + ' LabelVersion + ' + LabelVersion.AutoSize = True + LabelVersion.Font = New Font("Segoe UI", 8.25F, FontStyle.Regular, GraphicsUnit.Point) + LabelVersion.Location = New Point(80, 53) + LabelVersion.Name = "LabelVersion" + LabelVersion.Size = New Size(45, 13) + LabelVersion.TabIndex = 9 + LabelVersion.Text = "Version" + ' + ' ButtonClose + ' + ButtonClose.Location = New Point(275, 249) + ButtonClose.Name = "ButtonClose" + ButtonClose.Size = New Size(61, 23) + ButtonClose.TabIndex = 6 + ButtonClose.Text = "&Close" + ButtonClose.UseVisualStyleBackColor = True + ' + ' AboutBox + ' + AutoScaleDimensions = New SizeF(7F, 15F) + AutoScaleMode = AutoScaleMode.Font + BackColor = Color.Gainsboro + CancelButton = ButtonClose + ClientSize = New Size(346, 285) + Controls.Add(ButtonClose) + Controls.Add(LabelVersion) + Controls.Add(TabControl1) + Controls.Add(LabelProgramName) + Controls.Add(PictureBoxLogo) + FormBorderStyle = FormBorderStyle.FixedSingle + Icon = CType(resources.GetObject("$this.Icon"), Icon) + MaximizeBox = False + MinimizeBox = False + Name = "AboutBox" + ShowInTaskbar = False + StartPosition = FormStartPosition.CenterScreen + Text = "About" + CType(PictureBoxLogo, ComponentModel.ISupportInitialize).EndInit() + TabControl1.ResumeLayout(False) + TabPageAbout.ResumeLayout(False) + TabPageAbout.PerformLayout() + TabPageAuthor.ResumeLayout(False) + TabPageAuthor.PerformLayout() + ResumeLayout(False) + PerformLayout() + End Sub + + Friend WithEvents PictureBoxLogo As PictureBox + Friend WithEvents LabelProgramName As Label + Friend WithEvents LabelDescription As Label + Friend WithEvents LicenseRichTextBox As RichTextBox + Friend WithEvents DataGridView1 As DataGridView + Friend WithEvents TabControl1 As TabControl + Friend WithEvents TabPageAbout As TabPage + Friend WithEvents TabPageAuthor As TabPage + Friend WithEvents LabelVersion As Label + Friend WithEvents LinkLabelLicense As LinkLabel + Friend WithEvents ButtonClose As Button + Friend WithEvents LabelCopyright As Label + Friend WithEvents LinkLabelReadtheWiki As LinkLabel + Friend WithEvents LabelAuthor As Label + Friend WithEvents LinkLabelAboutMe As LinkLabel + Friend WithEvents LinkLabelEmail As LinkLabel + Friend WithEvents LinkLabelBMC As LinkLabel +End Class diff --git a/RPST GUI/RPST/Windows/AboutBox.resx b/RPST GUI/RPST/Windows/AboutBox.resx new file mode 100644 index 0000000..12018ea --- /dev/null +++ b/RPST GUI/RPST/Windows/AboutBox.resx @@ -0,0 +1,1491 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + + iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vAAADrwBlbxySQAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAANbLSURBVHhe7L0F + eBxHtr+dvXv37qX/he/yYmIrZsmyZYbEcZjBccjsJA7ThtmJIbSbZJNsYMPsmJmZ7ZhZzDJDHAa7vt+p + rpqp6a4Z9Ugz0vTMOc/zPjUeyVKrp+u851T39JzAwcGRfvFGXt4v1nYb3HF150FDVnQZ8MyKzoMmLes0 + YPPyjgOLlnYcULOs08CjizsO/HFxB2LAl4vzBtUszhtYsihv4FaM0/Dc80s7Dr5+ec7gLuvyhv1C/VgO + Dg4ODg6OVIt1va5usbbbgLtXdR04c2WXAUeXd+4vlnceIJZ3GiiWdRwglnYcCAaIJZKBAqKXLAQQv1jY + 3mEB0W6gmJc7CMjxu/ntB69b3G7gnxbnDT1t7Al9f65+JQcHBwcHB0djxMpTBrZb06P/n1Z17Ve9qkt/ + sbJrf7GCpJ8o+bejcbCYi3/PaTtIzM6RHJqXO+SzRbnX9VKbwcHBwcHBwZHs2Jwz4J/WdOt33+pu/Xau + gvBJ/A0l/1lOAYBxsJiVjedzBhfPbTv4SdomtXkcHBwcHBwciYzVnfv9y/qe/R9a3a3/XiAaW/4zwYzs + wWJ6m8FiZutBX8zOGfLmzHZD/kttLgcHBwcHB0d9Ymzrvn+3oXu/J9D1H0HXL1JN/jPaDBLTWzuPp7cZ + 9NXs7MEvzMy67Zdq8zk4ODg4ODjijU3d+p21rlu/gjXdSfypLf9pGKe2GiSmtMK/Ww3ZPSd7aD/1Z3Bw + cHBwcHD4iQ09+/7X590HTFjbrd/xoMifIPlPaTVEjYOPT8seOn9+m+v+R/1ZHBwcHBwcHNHi89P6df+8 + e78KyF8EVf6TwaSWDnh8aEb2kIvVn8fBwcHBwcFhhjjhhJ+t6zngwbXd+v8QJPnrZX+b/CcSLUDzwcdm + tr7u1eEnnPA36s/l4ODg4ODgKDz33F+u7XHNVHT+Iu3kDyY0BxintLx26crf9P0H9WdzcHBwcHBkbizv + PvT/bejRf3G6y388RmJiiyE7Z7a7jd8uyMHBwcGRuUEX+63r3n9Dpsh/XLPBYiyY1Hxw+dTm152kdgMH + BwcHB0fmxJYe1/z7+p79dmSa/Gn87GQ812LI7qUth/2f2h0cHBwcHBzpHzV5F/7j2p7XrM1U+X8mxyH4 + viGlk3IH/5vaLRwcHBwcHOkbom/fn2/o0W9mpsufHo/BOLH50E1jWw//O7V7ODg4ODg40jPWde//VtDk + TyRD/mOyBotPwOTm105Vu4eDg4ODgyP9Yn33/ldA/sdZ/mH5O+Bnt7j+D2o3cXBwcHBwpE+s6zao6efd + +h1h+bvlD5ri+awh381uOay92l0cHBwcHBzBjzfy8n6xrnv/zSx/u/w/VqAIqHgjb9gv1G7j4ODg4OAI + dqzr2f9RvuAvtvw/ajJYfNhkkJjc7LpX1G7j4ODg4OAIbqzu3O83n3fv9yXLv3b5f4jxo6aDv5/e5rqW + avdxcHBwcHAEM9Z2HzCV5e9P/pqxWUPXqN3HwcHBwcERvNjQtd/pLP/45P/BSYPE+yfhdzUf1lftRg4O + Dg4OjmDFmu7XLGH5xy//98CYptfuULuRg4ODg4MjOLG5x1WdIf/jLP/45f/+ic44Pev6i9Tu5ODg4ODg + CEas6dZvNsu/7vJ/D+NnTa7dpHYnBwcHBwdH6sfqUwafvLpr/2Ms/7rLn3j3xMHHx7e6tp3arRwcHBwc + HKkdq7v2ezaV5U8EQP7iHTCu6XWfqN3KwcHBwcGR2oECoJTlX3/5v/N7/J+ThhxRu5WDg4ODgyN1Y023 + Ab1TVf4BWfYPyf+dEweJtzGOy7qW3xLIwcHBwZHasaZb/zdZ/omTP/FJk2vnqt3LwcHBwcGRmrG6y4B8 + ln/i5P/W7wfi/w3dr3YvBwcHBwdH6sXqzlf/z8ouA46x/BMn/7d+N0i8+buBxyc0G9pE7WYODg4ODo7U + itVd+w1l+Sdc/mCQGNt02MNqN3NwcHBwcKRWrO484P1UkT+RLvL/K8ZPTrpusdrNHBwcHBwcJ5wwbNiw + X1xzzTX/7ofzzz8/qSzt0n89d/6Jlz+N7584pFy95BwcHBwcmRJ9+/b93yuuuOJq8AwezwLbwZHLL79c + uOnTp4+Vyy67zMOll15q5ZJLLvFw8cUXW7noootCzOvSj+WfBPm/AfD1b9ThwMHBwcGRzgHB/9eVV155 + J8aNQLhJNflfccHFYhnLPynyl/x2kBibNeS/1OHBwcHBwZFuAbmfik5/PPjeLX1NqsmfuPWcS1n+SZT/ + G78dKMY2vfFSdZhwcHBwcKRLXH311TmQ/jwgCJv4iVSUP3H/WX1Y/kmU/+tUADS54Q/qcOHg4ODgCHrQ + RXwQ/tPgx6DK/8ILLxSPnXF5o8ifyAT5vwY+a3rDCHXYcHBwcHAEOa666qpfQfjLtfiDKn9i5Ol9ufNP + ovyJMU2vf1kdOhwcHBwcQQ3IvyeEX5MO8ieeO+0Kln8S5f/qbweIT0+6/gN1+HBwcHBwBDEg9csh/B/S + Rf7E872uYPknUf6v/mag+OTE6yaqQ4iDg4ODI2gB2fcBofP96SB/4tnTnAKA5Z8c+b/6G1oBGPahOow4 + ODg4OIIUkH138G26yZ8Y0ftyvuAvifKXKwAnXf8XdShxcHBwcAQlrr766v+E8NPmnL/JBRdcIB5FAcCd + f/Lk/wrGj08aNkodThwcHBwcQQkIf2y6yp+47/Q+LP8kyv8v4JOTht2rDicODg4OjiAEhD80neVP3HTW + JSz/JMr/ld/0F2Oa3HCZOqQ4ODg4OFI9IHb6IJ+j6Sx/os95F4r5LP+kyZ/GiU1v/G91WHFwcHBwpHpA + +q+nu/yJ888/X8zowPJPhvzpMb73W3VIcXBwcHCkekDOv4f45Vv+bOIn4pT/MbAAcr8L39cNj39z1lln + /ZP6dY0eC9oNWs/yT7z8X/l1f/HOb4dWq93MwcHBwZHqAfG/kCD5H4fsP8LYRP3olAwUAJ+y/BMv/1d+ + PUC8//trV6rdzMHBwcGRynHhhRf+I+R/xCZ+Ig757wNnqB+b0rGw46BhLP/Ey/8l8PGJwx5Xu5mDg4OD + I5Xjyiuv7GcTPxGH/CsuueSSE9WPTPlYl9f//+blDjpeF/kTLH+7/F/Gcx80H3CS2s0cHBwcHKkcEP0U + t/iJOORPqwfN1Y8LTMxrO6iYO//Eyf8lPH7jd0OOqN3LwcHBwZHKce655/4S8v7SFD8Rh/yJ/urHBSrm + 5w76kOWfOPkT75143VK1ezk4ODg4UjmuuOKKU+oj/8suu2yx+lGBiwVtB53F8k+c/IlPT7z5SrV7OTg4 + ODhSOSD8e+shf/r66epHBTLm5Ayu4nP+iZH/678Z9JXarRwcHBwcqR4Q+Id1lT8oxo/4mfOTghnzcwe9 + wp1//eX/Z/Dhb6+fonYrBwcHB0eqB8S/so7ypzv4Pat+TGBjXvsBLVEAHGf510/+L/26nxjf5NYOardy + cHBwcKR6QP4VdZE/gX/3UT8m0DE7Z/BSXvavu/z//Kt+4p3fXlugdicHBwcHRxACsv+yLvInUDy0Uj8m + 0LGk3Q2nQP5yFYA7//jl/+df9RefnDjsErU7OTg4ODiCEBD+T3WRP3HxxRf/Vv2YwMfs7CFrWf7xy/9F + yP/N3w4uV7uRg4ODgyMoAel/Xxf50yf4pVMBMC930PmQ/3GWf3zyf/HX/cQnTW64Wu1GDg4ODo6gBMR/ + uC7yVwVAN/Vj0iJmZg9ZwPL3L/8XIP93fnfdNrX7ODg4ODiCFJB8vlv6mljyJ/DvG9SPSYtYlHvjiVNa + Dv6G5e9P/i//esBP408c1kLtPg4ODg6OIAVEP98tfsItfsKUv2Ki+jFpE7PaDH2W5V+7/Gnp/8PfDntP + 7TYODg4OjqAFZP9yHeVPfIev/Z/6UWkRi3r1+tsprYYWsvxjy/+N3w4+uOiE4X+rdhsHBwcHR9ACwh9a + R/mLSy65hMan1Y9Km1jS5rqWk1oO+Zrlb5f/K78a8NNHJ97URe0uDg4ODo4gBgTerK7yV3yPf7dRPy5t + Ymb29ddPbD74OMs/Uv4v4t8fnXjDE2o3cXBwcHAEOSD/kjrKX7Pl3HPP/Rf149ImprUeOp7lH5b/C7+6 + Rrz3W/64Xw4ODo60CUj9T/WQP70dkMa5KAJ+qX5kWoQ4oe/Pp7Qasprl78j/rd8MrRh7Qt+/U7uHg4OD + gyPo0bdv3+aQ/rG6yt9gVq9evf5e/di0iJW/6fsPk1oM2Z7p8n/jN0P3j21y/7+q3cLBwcHBkS7Rp0+f + mfWUvybtioApba77HxQA1Zkq/9d+M+jLT39766/U7uDg4ODgSKeA5M90S18Th/zFRRddRKRdETCt7cBf + T2h+bUmmyf/13ww+MrHJLc3UbuDg4ODgSMP4GWS/MQHy10xPt2sCpmff9O8Tmw/dmjnL/oP3zjjx5v9V + fz4HBwcHR7oGhN8DHE+A/CUXXnhh2q0ELDpx8N9PaDZ0ebrL/+3fXrsD25dWrx0HBwcHR4yA5D9OkPw1 + abcSQDG5+XXPfpo1+Kd0kz/+ffz9313/mfozOTg4ODgyJSD6fwMVpvgJm/iJWuSvSbuVAIrJLa87b0zW + 0EPpIn98//ef/u7GAerP4+Dg4ODItIDET4H0f0iQ/DVpuRIwn94hcPK1Sz9qGmz5v/PboVv4Sn8ODg4O + jhMg+JsTJf8LLrhAgsdpWQRQTG8+9KIxWUOqgyb/134z6Oinv7/hWvVncHBwcHD4iT3P5fxTzdNNflf+ + VLMmlaNOyil/qmlexcgmHQh67DzXrEn1yKa/rRn+q39U/y0wgQJgRKLkbxQBaXk6gOKlrNt+OeHka1// + sMngb1Nd/i//esCP7/9+2IfD+c5+aR+UeygHpWue4uBIeKx7I+8XlU82ya4c2aRPxaimd1eObvpy5cis + aZWjmm4GVeBbIOLkG1CJn7NJ/ayXKkZm/aFyxMmXlT+Z1VoM75VyH6+KIuDFRMmfOP/884m0XQmgGPtf + N//zhJOve+Gjk4Z8lWryf+XXA398/3fXT57Y4pb/UJvLEeCgPIX81MaTpyjHUK5xco4tF8WCcltVKE+N + bPpyxQj87JEn96kY3rQN/U716zk4gh9S9qNP7lw1KusuHOwfqMnzvTEhEstIxYgshydDfF/5RNaGiuFZ + 75c/cfIdFU826ZgKRQHE/3QC5a9J25UAHYtQCIw/+foXPzppaE1jy/+N3ww69NHvb/jrnJx7/kltHkfA + QuapkSd1qhrZ5E7I/v3KUU02Ip80QJ4iPHlqI/igfHjWnZXDm3VaN4yLAo6ABEm1fGSTHlUjm47AJFqC + g/1rz8GfLKJPKoEJJSqI4YrHT8Z48lcYF5U/3uyJqkezuoq+J/xc/RkNGlQEJFD+mrQvAnSMy7qx19im + 1014/6QhRxtK/vh/37/7+2tXf3LisEvUZnAEKMTYE35ePbJpNzQkTyB3LAapm6ceP/lr5KrFlKfKhjft + 1lh5ioPDGuVP/e7fq0Y3HVQ5uulYHOCHPAd8QxD/pHJ4TPGo5GDFI1ljyh9uNqD4/iYN+uEsZhFgEz8R + h/zFeeedR2RMEaBjzIk3dRnT9PqXPz7x2m3vnDjw+0TJ/+VfDzj21u+G1nz4++snfnriDVcOP+GEv1G/ + kiMgUTr8xH+rGtV0IDr8zypHZR205pFkk6g89Wizz8ofbTaQ/ib153FwNFwUP93kX6tGZw3AQT0dJG+p + zA+hSYVJVPdJ5fBIM4eHm30HJlc+dPI1++9r/v+cvzq5QUWATfxEHeSfsUWAjjfyhv1iXNZ1vcZn3fjA + J02u/fTDk679/N3fD61+5/eDD771uyFf/RVd/Ou/GXjsNYDi4Ie//nbQ12/9bvCht38/ZM97v79240cn + XTfu05NueGTs72/szRf0BTMKh2f9C2Tfv2JUk6nIFd95ckdDkhj5W/JU86mVDzfv11B5iiODw7mytekb + laOafOU5wBuD5Mjf4aEQ35Y/1Gxs+QPNzlC7IWkB2XuKgHrIX5OxRQBHZkY4TzX9MiJfNBbJkX/UPCVO + OOFnaldwcNQv9g1v/c84iG8D2yMO6samYeQvyh8kmovyByRbK+5rdnPN8LykvaXHLAISIH9x7rnninPO + OYeLAI60DnrrcMWorFsqRzfdZs0XjUXDyN+Vp5ptK3ugxa177snhC1M56hYlo076n8pRWcMb7XxZLBpH + /qL8/hBHyu9r/ufKu5r9Wu2uhAYVAYmSv4aLAI50jD3Dm/63k6eaHvDkicamUeSvcPLUF5Snqu7L+o3a + XRwcsYNuwIOD9q84gBv33H40Gl/+ApPK4d4W35Xd0/wvySgE3EWATfyETfyEKX8uAjjSLaqeyfpNxaim + ryEnNO65/Wg0vvwj8lT5vS1f40KAI2rsHp31X6ikn8bBW5cb8TQMjTWp7PIPc0+L7zG+UXZny/9TuzMh + oYsAm/gJm/iJKPLXcBHAEdgw8lRdbsTTMKSW/D15quK+5vzZFBxO0LmzqlFNn8SBm7oTikhd+TvcLfmq + 7K7mj1Te9Zt/ULu33gHRP+0WP2ETP1GL/LkI4Ahk0K10K0c1eRy5oOHes18XUlf+4Tz1hxZfg8drhiXv + WiaOFA8hTvhZ1cisvjhoyzwHcaoRDPnTxAItRdldLSoxDkzU1bgQfkQRYBM/4VP+krPPPpuLAI5ARPXI + rAvRpJRac0MqEQT5m3nqDy2rEpmnOAISZSNOblkxquly60GcagRN/rIAUNzZclHl7S1PVru9XqGLAJv4 + iTjlr+EigCNlo3rESc3VHUXtuSGVCJ78Q3mq/M6WS0ruaN5c7XaOdA15z+tRTe7HAZuaF864Cbb8He5o + +W3pna2Gbx/eut43k4HUn06g/LkI4EjJoFuKqzyVutcjmQRY/qE8dWfLH0rvaPl0IvIURwpG1aiTc3Gw + bvUcvKlKesg/zO2tNlbc3rKNejnqHJB7RBHgFj9hEz9hkb8466yzCC4COFIi6CN01YeG2fNCqpEe8jfy + VMvNJbe1bqteDo6gB53rRzV9Bw7WYHT9RPrJ3+G2Vt+W39b6fjG8fveSh+RlEeAWP2ETPxFD/lwEcDR6 + yGuSRjUdhvmf2hf5maSd/EN56rtE5CmORo7Kkc1+XTm66QLrwZuqpK/8TWaV3NHmf9TLVKeA7J9OoPw1 + XARwNHiUjfr9/1WNypprzQepSvrKP0Tpra3n4nsS+tZmjgaKitEn9cQButt68KYqmSD/WxW3tKouu7lN + N/Vy1SnMIsAmfiIO+Wu4COBosKge3bQ75n6NJxekMhkg/3Cear2v7NbWvdXLxRGEUEtpP3gO3FQms+RP + E0uU3dz6x/KbWt+vXrY6BRUBNvETdZC/hosAjqSHylOpecfRaGSU/InE5CmOBojCl7J+WTmqyYfWAzeV + CU0qTKLMkb+kFJTc1PqtdcPyfqFexrgDYvcUAW7xExbRx4KLAI6kBF1pDvm/a80FqUxmyj+Up0pvav3e + 9r78LoGUjPKnfvfvOEgXew7aVCfD5Y9JJSm5sfX80jtz/029nHEHBB8qAtziJyyC9wMXARwJjdLhJ/4b + 5v1CTx5IdVj+Ok8tzx/W7D/Vy8mRClE2ovlJlaOydloP3FSG5e9wo+KG7G0lt7T8vXpZ4w6I/mm3+AmL + 2OOBiwCOhETpUyeeiHmfWh8r7geWf0SeKruxTWHxDYm5wRlHPYPu6oeDtNpz0KY6LP9I+d/YBgWApKbo + xpw63y8Awo8oAixCrwtcBHDUK2pGn9gC877KkwdSHZZ/tDy1u3hYdrZ6eTkaI2pGZbXHQbrfc9CmOiz/ + aJNKlA6T7C29vnWuepnjDl0EWEReH7gI4KhTqJuQ7fPkgVSH5V9bnjpUcm3rTupl5mjIqB7ZtBsO0iOe + gzbVYfnXNqlE6fWSek2uM88882mLxOsLFwEccUXl6JM7Y94f8uSBVIfl7zdPHS67Iburerk5GiJURR3g + SYVJxPKPNakcrss+Un5ddp562eMOLgI4GjOqnj6pbeWorIPWXJDKsPzjy1PXZ39RfH3rjupl50hmVD7Z + JBsH6QHPQZvqsPzjlb+k7No2+8uHtG6lXv64g4sAjsYI+iS/qlFN91hzQSrD8q9Tniq9Nvtw2bVt26mX + nyMZIT8ec3TTvdYDN5Vh+dd1UjkMza4uH5rdRB0GcQcXAd4oHJ71L/TWWYIeq6c5EhCVTzXNwrwP1t39 + CJZ/ffPU7uLBufzugGREzfBm/4mDtNBz0KY6LP/6TipRAvC4qHBIu/9Sh0PcEeQioHT4iX9f/lSzJlWj + s7rimDq3YmSTqytGN7mpalTWgzi2nsFzb6AwHqvuJ78WFIBiUAHoVBlxGNiPUUIfpw6HwSGIAGRVVI7M + KsZYUDni5LVVT+J3jMgaW/nkyW9UPtn0maoRWQ/iGL6p4omTr658oum5+HpXelsu3ZRLbX5GRdXoFv+B + /Znv2b+pTihPEQ2Yp9JH/jJPgZKiATn/rQ4HjkRE5fO/+QccpCs9B22qE5pUmEQs//pMKlEyhMhZVjr4 + xDoLNxWLgOKnm/wrfQRs1agm51eOyroODMex8yaYDjaD5F89ro9TEy0CE/P4NY7j0LHsPqaHZ+2rGH7y + 5srhJ08vH57118rHsh6vHN7surLHTj6/8tEW2cX3N/lXtRvSIqhQw/5c4dm/qY77NXe9vix/EFeeyl5b + MyzvH9VhwVGfoI9kxEE60XPQpjqhSYVJ1JCTKn3lL0oG54jiwTmfihNO+Jk6POKOxigC1r2R9wvq4KtH + NDmj0vlo6jcqRjedh5G69OOhY6Yx0MepSWLkr8DxS5jHeMSx3uwQWFf5WLOx5Y81G17+WFbf8keb5tUM + /1WgEqj82PHRTcda93Eq437NXa8vyx/UIU+VDMoZxx8nnICoGtl0hPXATWUaa1KlufxDDMx5SB0edYpk + FQHD+/b654pRTdtUjc4aUDW6yZ8qRzaZA+GX4Jg45jlGUgF9nJo0qPxdmMf9oyf/BIorHj55dsWjzf5U + +Wjz/uWPZrUWw3v9rXoZUyoqRzd5zLqPUxn3a+56fVn+oB55qnRgzuPq8OCoS1SPzLoQB2pqJs9oNNak + yhT5D5IcKx2cc446TOoU9S0Czj3nLDH4kl5i+ICu4t2b24uF9+FvHZn1k/WYSEX0cWqSOvJXxz+B493k + 4WY/gO2VDzf7oPyR5neUP9ysx557cv5JvayNEuWjTjoT+zQ4rz3hfs1dry/LHyQgTxUPyD5PHSYc8UTl + iCYn40CNfeFSqtFYkyqz5E8rAMTBsgE5J6nDpU4RTxEw8JLTxBMDu4gxt7UTax9uKcpH4jW1HQNBQB+n + JsGQv52Hmv1U8WCzbRUPnfw2GFz5SMPdp71m5Em/xz4N1tuS3a+56/Vl+YPE5alDhYPaNFWHC4efUB/r + u9F68KYqjTWpMlP+omQA0Xb1ol71WxK2FQHnnH2m7O5HDeoixt6eKzY92tz+mgcRfZyaBFv+XuQcabYH + TMMcub/8/mY96CN41UuesFAf67vOup9TFfdr7np9Wf4gwXmqdEDuOv4Y4TgCk+qP1oM3VWmsSZXZ8nfo + 3/ZJddjUOc4798xnbrr8VPHy9R3EnHuzRSG9brbXOejo49QkPeUfnivh+fIlnptb9kDzRysfPLmz6HvC + z9XLX+eoHJn1lHU/pyru19z1+rL8QZLyVOmAtk+pw4YjVlSOzjoVB2twzvs31qRi+ZP8iWOl/XN7qcPH + d+wZ3vS/q0Zm9cVr+AZev92e1zXd0MepSebIPxJn3hwAY8sfaDGs6r6s36jDwndUjD6pJ/Zr8K75YPk3 + Wp4qGpDTWx0+HLYoHX7iv+FgDc5HZjbWpNITKhGTKtjyFyX9JKW7hjb/f+owsgZdPV7+VNM8ep+9WrZt + 3LffNST6ODXJbPnb5lAx+HP5Pc3OKLwt9k2M6M6J2K/lnv2cqrhfc9fry/IHDZOnKor75qXVvS8SGjhY + 6QYo9oM41WisSeVNXHWfVOkhf1FyjRxfUodRKPY/0/z/VYxqelXlqCbj8Jp96XkNMwF9nJqw/L1zKJKj + 5fe2HFt+T/Mr9g1v/c/qcApF1aisV637OhVxv+au15flDxowTxVf0/Y1dRhxmKGW/oPRlTXWpLIlrrpO + qjSSPyYVyD1W1C+3O91ARr59dGTTDyD+r6yvX6agj1MTlr93Drkx59S9Lb4F01AQDKQ7F1aNzOqCfRuM + U5Tu19z1+rL8QcPnqeNFV/OpgIhQt/ql+5fbD+RUorEmlS1x1XVSpZv88bUybBP211G8Rt95XrNMRB+n + Jix/7xxyY84p99y6p8V3FQ80/0puO+1P235PFdyvuev1ZfmDhs5T1+SK4qslu0oH86eJhgKd2uPWgzjV + aKxJZUtcdZ1U6SJ/QNtA+0m+JrbXK1PRx6kJy987h9yYc8o9t0xojmGkbah4HPuL9q/tdWgs3K+56/Vl + +YOGylNe+Yviq3JFyVW59bqbadpE5chmvw7EUm1jTSpb4qrrpEoD+dPPpL+zgva77XXKdPRxasLy984h + N+accs8tEz3PXNA2yf1H+9v2ujQU7tfc9fqy/EED5KlY8ld8WXFVu18pDWZuVI7K+th6IKcSjTWpbImr + rpMqyPLH99M2VjyKJGt7fRgHfZyasPy9c8iNOafcc8tEzzMTOec0LUUF/V/adtrPttcombhfc9fry/IH + ycxT/uUviq/MFSVX5r6vNJiZUTn65M44cFP7wr/GmlS2xFXXSRVE+Q90zuvTvqkM8m13Gwp9nJqw/L1z + yI05p9xzy0TPMxOX/OX803OP/o3fS/vH+nolGvdr7np9Wf4gGXmqjvKXXNHuePFV7TooHWZeqI9EtR/Q + qUBoUmESNeSk0hMqEZMqYPIvxfO03SQb62vCeNHHqQnL3zuH3Jhzyj23TPQ8M4klfzf0PfQ30Gtie/3q + i/s1d72+LH+Q4DyVAPlLSvq2m6V0mFlRPrJJD+vBnCqEJhUmUUNOKlviquukCpD86WfQ3yf3te31YOzo + 49SE5e+dQ27MOaXRc8tEzzOTkPiJWuRvCg7QNtF+tb6WdcH9mrteX5Y/SGCeSqT8i/s6lFzR7hSlxcwJ + HLyLPQdzqhCaVJhEDTmp9IRKxKQKgvwB/e5y7B/r68DERh+nJix/7xxyY84p99wy0fPMpB7yj5iX+Pm0 + b+RrZntt/eB+zV2vL8sfJCJPJVH+ksvbLVVazIzAwdrLekCnAqFJhUnUkJPKlrjqOqn0hErVSYWvld2F + bh/70voaMLWjj1MTlr93Drkx55R7bpnoeWaSKPmHwPzD99LfGvd1Lu7X3PX6svxBffNUw8hfUnJ5+55K + j+kfOICnew7oVCA0qTCJGnJS2RJXXSeVmWBSbFLR12m75b617X/GH/o4NWH5e+eQG3NOueeWiZ5nJsmQ + v56foBz/pr+n8km8jrbX3MT9mrteX5Y/qEeeamj5F/dBAdAnb7LSY3pH9YiTmuMgTr1baYYmFSZRQ04q + W+Kq66QyE0wKTarS6/j8fsLQx6kJy987h9yYc0qj55aJnmcmSZZ/xFzFWH5fjNUx92vuen1Z/qCOeaqx + 5F/cp70ouqz98YJL27dUmkzfwEGceh/4E5pUmEQNOalsiauuk8pMMCkyqUqvR8ePv0nuW9t+Z+JDH6cm + LH/vHHJjzin33DLR88ykIeVvguc8hYD7NXe9vix/UIc8lQLy17yuNJmeUfx0k3/Fgfx16IBOBUKTCpOo + ISeVLXHVdVKZCSYVJhX+D/2t1v3N1A19nJqw/L1zyI05p9xzy0TPM5PGkr85ZwFtH71mEa+56/VNWp4y + 97dtn7r3H8u/rvIXRZe2/6b0ktx/U7pMv0Aiu82T2BqTUCLFJGrISWVLXHWdVGaCaeRJpTv+Ctu+ZuqO + Pk5NWP7eOeTGnFPuuWWi55lJisjfhLarEq+T+/Vl+YM48lSKyl9SfEneTUqX6ReVo5pstCa4xiCUSDGJ + 3MkzmZPKlrjqOqnMBNOYk+padPzYZrk/bfuaqTv6ODVh+XvnkBtzTrnnlomeZyYpKP/QHAa03fSasfwV + fvNUisu/6BI5bla6TK9Qt/21J7mGJpRIkSDdyTOZk8qWuOo6qcwE01iTCs/RXc7kPrTtZ6Z+mNIPHbME + 9reJefwaxzHL30DPLRM9z0xC4idST/4R4O+iTyNMeJ4y97dtn7r3X6w8Ze4T29/u/huTkaeCIn9JHo15 + SpvpE+j+X7EmuYbGnUhdSZPlD2qbVBhpO+Q+s+1jpv6Y0ncfsyz/8BxyY84p99wy0fPMJCjyV/NZzml8 + D10sWO5+7SJeJ+xr87UxXgOWvyJV5H9xnii8qMMLSpvpEWL4CX+DpFbjSXINjTuRupImyx/UMqlK8TNp + n1j3L5MYTOm7j1mWf3gOuTHnlHtumeh5ZhJE+Rvzmr6f9pfn9XK/NsZrwPJXpJD8JRfl1ZAzlT6DH1Wj + mp5mTXQNiTuRupImyx/EmFRl+Hr5A3zL3qRjSt99zLL8w3PIjTmn3HPLRM8zk4DL34R+f8VD+nXCvjZf + G+M1YPkrUk/+kpLz0+jOgFWjsl61JruGwp1IXUmT5Q+iTSr8m7argvafbd8yiUMfpyYsf+8ccmPOKffc + MtHzzCQkfiLY8g/P8Vby74j2WrD8FSkq/6ILwQXtX1b6DH4guVV4kl1D4U6krqTJ8gdRJlU5frYUi22/ + MonFlL77mGX5h+eQG3NOueeWiZ5nJmkp/zD0/fS3m68By1+RyvJ3qFD6DHZUPtkk25rwGgJ3InUlTZY/ + sEyqMnwff0JfA2JK333MsvzDc8iNOafcc8tEzzOTNJe/OdfLbm0tKmg/svyDIn9RdEEHUXB+GtwauHJ0 + 0/usSS/ZuBOpK2my/IFlUpXj9/JyfwOij1MTlr93Drkx55R7bpnoeWaSQfIPg59zF10oiL/Zvb9t+9S9 + /1j+DSp/ovCCvD8ojQY3kOQWepJesgklUiRId/J0J0pbQoxIfkhgZsIzEltayR/fT3+vdX8yycGUfuiY + JdRxazt+jeOY5W+g55aJnmcmGSl/Bc17/By5v9z72LYvI/YZ/lZbnjL3ie1vd/+N5t/k+Rtc25rB8i86 + HwXA+R3mKo0GMwpfyvolEt23nsSXTEKJFAnSnTzdidKWECOSHxKYmfCMxJYu8i/DhKLtkfvMtj+Z5KCP + UxOWv3cOuTHnlHtumeh5ZpLp8jcoux1//72Wferefyz/RpG/LADO6/DN9r6t/07pNHhRPbppd2vySxah + RIoE6U6e7kRpS4gRyQ8JzEx4RmJLG/nj/9Pfb92XTPIwpR86Zgl13NqOX+M4Zvkb6LlloueZCcs/Epr/ + +H+Ugzz7MmKf4W+15Slzn9j+dvffaP5Nnr8B2+PeViNPZaj8JQXn5XVWOg1eNOj5/1AiRYJ0J093orQl + xIjkhwRmJjwjsaWF/PGYto0/tKcRMKUfOmYJddzajl/jOGb5G+i5ZaLnmQnLPxJTroC207P/WP6NLn+H + AF8HgIQ32ZMAk0EokSJBupOnO1HaEmJE8kMCMxOekdjSQv74Pvo7rfuRSS6m9EPHLKGOW9vxaxzHLH8D + PbdM9DwzYflHYspVcx2tBgDsg/A+w99qy1PmPrH97e6/0fybPH8Dfrd7WyO2K8Plfy6eO6/DBKXT4AWS + XpUnCSaaUCJFgnQnT3eitCXEiOSHBGYmPCOxpYP8y/E7+Qr/RkIfpyYsf+8ccmPOKffcMtHzzITlH4kp + Vw3kHxLt9dlyG1n+ikaWv+ScjsG8H0DV6Bb/YU2EiSSUSJEg3cnTnShtCTEi+SGBmQnPSGyBl/8N6Pof + am7fh0zyMaUfOmYJddzajl/jOGb5G5jSd88zE5Z/JKZcNab8DeHK1QDaB+59o/eF7W93/43m3+T5G/B7 + 3dsasV3hbclw+Uu2n931/1NaDU5UjWja25oME4U7kbqSJssfYDLR/6/EPrDuQyb5mNJ3H7Ms//AccmPO + KffcMjGlHzHnNCz/CLlqosg/BP2b/h73PrH97e6/0fybPH8Dfq97WyO2S/1uln+IgrM6nqK0GpyoGtnk + TmtCTATuROpKmix/ojW2j97eh31i24dM8jGl7z5mWf7hOeTGnFPuuWViSj9izmlY/hFyDUmWUKJ1C9eg + DNKlbZD7IFl5KmK78PvMbWH5i8KzO4qiszvcqrQanEACfMOTEBOBO5G6kibL33lMf5d1/zENgyl99zHL + 8g/PITfmnHLPLRNT+hFzTsPyj5BrSLKEEq1buCYkfy1f/D/5N7r/dvffaP5Nnr8Bv9e9rRHbhd9nbov+ + 3UQGy19yVse/KK0GJ6pGZc21Jsb64E6krqTJ8sdExf+RArHtP6ZhMKXvPmZZ/uE55MacU+65ZWJKP2LO + aVj+EXINSZZQonUL1wTSjRAwQd97M/4e99/M8k+2/ImZSqvBCSTCAk9irA/uROpKmix/unCHl/wbHVP6 + 7mOW5R+eQ27MOeWeWyam9CPmnIblHyHXkGQJJVq3cE0gXY/8CSlifA3b4/kbzb/J8zfg97q3NWK78DPN + bfH8Tsg9s+UvCs/suFNpNRghhp/wN0iG33mSY11xJ1JX0sx0+ZcBeb7ftu+YhsOUvvuYZfmH55Abc065 + 55aJKf2IOadh+UfINSRZQonWLVwTSDeW/LWQ5dsFaTUgzjzl2T73tnh+J+TO8gedvhUnnPAzpdfUj4pn + mv/KmiDrQiiRIkG6k6c7UdoSYkTyQwIzE56R2AIrf3yN/jbrvmMaDlP6oWOWUMet7fg1jmOWv4Epffc8 + M2H5R2LKNSRZQonWLVwTSNeP/LWU6f+U3YT84/57bNtu2z73tnh+p/N7WP6dROEZnURpr47/q/Sa+lE1 + 6uRca5KMl1AiRYJ0J093orQlxIjkhwRmJjwjsQVW/vj/lU8Y+4tpHEzph45ZQh23tuPXOI5Z/gam9N3z + zITlH4kp15BkCSVat3BNIN145B8C/5bb6vkb8Hvd2xqxXfh95rZ4fqfr92S4/IniM7pmK72mflSNanK6 + NVHGQyiRIkG6k6c7UdoSYkTyQwIzE56R2AIrfySsCpKMbd8xDYcp/dAxS6jj1nb8Gscxy9/AlL57npmw + /CMx5RqSLKFE6xauCaRbJ/kbyG2wbbtt+9zb4vmdrp/P8ld06aX0mvpRMbLpldZk6ZdQIkWCdCdPd6K0 + JcSI5IcEZiY8I7EFVf70e/mDfFIAU/qhY5ZQx63t+DWOY5a/gSl99zwzYflHYso1JFlCidYtXBNIt17y + 13IG8ney/JMj/9OJzpcrvaZ+VIxucpM1YfohlEiRIN3J050obQkxIvkhgZkJz0hsgZQ/4Iv9UgRT+qFj + llDHre34NY5jlr+BKX33PDNh+UdiyjUkWUKJ1i1cE0g3UfIPgf8Tsa0R24Wvmdvi+Z34/7afz/IXBQ43 + KL2mfiBB3utJmH4IJVIkSHfydCdKW0KMSH5IYGbCMxJbUOVPf4d1vzENiyn90DFLqOPWdvwaxzHL38CU + vnuembD8IzHlGpIsoUTrFq4JpJtw+WtRD8bP9mwXnjO3xfM76f8ZuH9mpsu/dyeRf3qX4HwscMWopg9b + E2cs3InUlTQzWv54TH+jdb8xDYspffcxy/IPzyE35pxyzy0TU/oRc07D8vcIVkqWUKJ1C9cE0k2a/DVU + BND2yO2ix+p3q98f+Tvp+w3cP5PlDzqL/NM6P6j0mvpROTLrCWvyjIY7kbqSZkbLH1+X4rDtN6ZhMaXv + PmZZ/uE55MacU+65ZWJKP2LOaVj+HvFLyRJKtG7hmkC6SZe/lja+VnotXRsQ+fsjfye+z/bzzZ/D8hcF + p6EA6N1luNJr6kflqKynrQnUhjuRupJmJsu/7OZW8u+37jemYTGl7z5mWf7hOeTGnFPuuWViSj9izmlY + /oGRv5Y2/i1/r/r9kb8T32f7+bafk+HyJwpP6zxa6TX1A8nxOWsSdeNOpK6kmcnyL8X38nv8UwRT+u5j + luUfnkNuzDnlnlsmpvQj5pyG5R84+WsGthWl9PMjfie+z/bzbT+H5S8KekmeU3pN/agY2XSUNZGauBOp + K2lmsvzp//B7/FMEU/ruY5blH55Dbsw55Z5bJqb0I+achuUfWPlrgdM42Phdtp9v+zksfy1/0Gmk0mvq + R+WoJo9bk6kmlEiRIN3J050obQkxIvkhgZkJz0hsgZQ//q/cJ7b9xjQspvRDxyyB18fEPH6N45jlb2BK + 3z3PTFj+6SV/Df17MIHvdf98289h+RvyB6d2flTpNfWjalTWg9aESoQSKRKkO3m6E6UtIUYkPyQwM+EZ + iS2Q8sfP4c4/RTClHzpmCXXc2o5f4zhm+RuY0nfPMxOWf3rK35T5QGD+fNvPMb+f5U/yB53uU3pN/UAB + cFfMpGpLnu5EaUuIEckPCcxMeEZiC6T8kazkvrHtN6Zh0cepCcvfO4fcmHPKPbdMTOlHzDkNyz8t5a+h + IsD8mSz/WuQPTul8h9Jr6kfF6CZDoiZVW/J0J0pbQoxIfkhgZsIzElsg5Y//KwXj3mdMw2NKP3TMEuq4 + tR2/xnHM8jcwpe+eZyYs/8yRv4b+v/vnuL+f5a/k30Xkn9J1oNJr6kfF6KyLrEnVljzdidKWECOSHxKY + mfCMxBZI+d/a2tkn5v5iGgdT+qFjlsDrY2Iev8ZxzPI3MKXvnmcmLP/Mk78Su/y6+/+6vofl38WhZ6fz + lV5TP6pHN+3uSao6kbqSZkbLH9/PnX+KYErffcyy/MNzyI05p9xzy8SUfsSc07D8M0n+Ibmb/9fzPfg6 + yx/y7yIKu3fuovSa+lE94qTmEUk1yPI3E40tobgTh5koPIkBk1knAHxd7ge3iJiGx5S++5hl+YfnkBtz + Trnnlokp/Yg5p2H5Z6T8teDN72f5e+RPFPXqmqX0mvpRODzrXzyJ1JU0M1n+9D1SHDYZMQ2LKX33Mcvy + D88hN+accs8tE1P6EXNOw/LPaPkTeBz5PcbXWP6S7b16/bPSazACifQQy1+DyawTAJ4nIVhlxDQsLH/7 + 3HHPITfmnHLPLRNT+hFzTsPyz3j5h2D5R5N/QY8u+5RWgxNIpBtY/gQmcygJQP74G60yYhoWlr997rjn + kBtzTrnnlokp/Yg5p2H5s/wNSPLuf7P8Sf40rlVaDU4gmU5wJ83Mlj9/nn/KwPK3zx33HHJjzin33DIx + pR8x5zQsf5a/gSl7978zXf4gv3uXz5RWgxOVTzR91kyaGS1/THjaLquMmIaF5W+fO+455MacU+65ZWJK + P2LOaVj+LH8DU/ZuWP6ioDsVAF2D80mAOqqeyBqgk2amy78Mv9cqI6ZhYfnb5457Drkx55R7bpmY0o+Y + cxqWP8vfwCZ9Qouf5U/yF/ndul3lWDVAUfVks7Ysf3WXPxKNTUhMw+EWP8Hy984hN+accs8tE1P6EXNO + w/Jn+RvYxE+w/F3y7yoKu3dvrbQanNg+vPXfIVF+H0qQtoQYkfyQwMyEZyS2pMrfTDC2hOJOHGai8CQG + TGYzAeD7pVRsQmIaDpa/fe6455Abc06555aJKf2IOadh+bP8DWziJ0z5azJc/uC7dXl5v1BaDVYgKW5O + afmbicaWUNyJw0wUnsSAyWwmAPxbysMmJKbhYPnb5457Drkx55R7bpmY0o+YcxqWP8vfwCZ+wiZ/cwUg + M+Uv8rt23ah0GryoGN70dWtCjEh+SGBmwjMSW2DlD+hvsgqJaThY/va5455Dbsw55Z5bJqb0I+achuXP + 8jewiZ+IJX+zAMg8+ROvKJ0GL8ofyxrgSYgRyQ8JzEx4RmILsvxpe6xCYhoOlr997rjnkBtzTmlM6bvn + mQnLPxKWf/3lr5EFAASfWfIXBV27Xq10GrwoH96sSURCjEh+SGBmwjMSW6Dlf1tLyAYCsUmJaRhY/va5 + 455Dbsw55Z5bJqb0I+achuXP8jewiZ/wK391DUCRWQBkgPyJ4h49fqd0GsxAAqzxJEF3wjMSW5DlX4av + V5BobFJiGgaWv33uuOeQG3NOueeWiSn9iDmnYfmz/A1s4ifilL8DRE9FQIbIP79Ltwql0eBGxeNZ70cm + PyQwM+EZiS3I8ico4VulxDQMLH/73HHPITfmnHLPLRNT+hFzTsPyZ/kb2MRP1En+Cl0ApL38JW8pjQY3 + kAivDic/JDAz4RmJLdDyxySnbbZKiWkYWP5hzLnjnkNuzDnlnlsmpvQj5pyG5e8RP8Hyj6Q+8lfvBCjq + A9Jf/mJX526XK40GNyqHt/7/kPx+8iQ8I7EFXf70O6xSYhoGlr997rjnkBtzTrnnlokp/Yg5p2H5e8RP + sPwjSYD8Q9AqQBrLP79zt5+2d+36/ymNBjvKH2m+Ml3lT1+TcrGJiUk+LH/73HHPITfmnHLPLRNT+hFz + TsPy94ifYPlHkkj5E7QKkL7yJ5YpfQY/Kh4++R5bggu8/DFScreKiUk+LH/73HHPITfmnHLPLRNT+hFz + TsPy94ifYPlHkgT5S+jdAOkpf7Grc9c7lD6DH9UPN/0tEtxxM7EFXv6AtsEqJib5sPztc8c9h9yYc8o9 + t0xM6UfMOQ3LP0L6GpZ/JMmSv6S9KKbrANJM/vmduh3D879W+kyPKH+o+Uqd2NJB/mU304f8QCQ2OTHJ + heVvnzvuOeTGnFPuuWViSj9izmlY/hHS17D8I0m2/OkdAQStAqSP/ImlSpvpEygA7qDElhbyBxWP8a1+ + E8JTzUTVH9uL6pdPFdWv9BJVL3YVVc/l2r+XYPnb5457Drkx55R7bpmY0o+YcxqWf4T0NbXIv+yWrshZ + vfFanIt9f7YovaU7vieX5V9f+eubAl2YNvIX+R263qK0mT5R9WCL/0BC+y7o8ido26xyYjyQ0Gvev0bs + nvqw2Lv0bbF/2yJxsLJIHDxwWBw68p049JWIzuGvxMG9e8WB0u1i34ZpYs/8P4vd4+4U1X+9SFQ+k83y + d2MK38ScUxpT+u55ZsLyj8TIA5qyWzrjeLpSVL16n6gZ/5rYu2yW2L9rpzhYs18cPPiV/djWHP4Ox/hh + caC4ROxdswTz5H1R9daTomLUUFF6e2+Wf23y19AFgekg/47dvsvP6/WfSpvpFUhmn1kTmC1RuZNSisif + PuK3wiI6xkEKf+ytYt+qT8WBmkp70ksEXx4TByoKxb6Vn4qaMbeJqmfbs/xtmHPKPbdMTOlHzDkNyz+U + A27tKCqfu07snoKCdusGcfDoT/ZjNAFQEbF32RxR9eaTyH3nsPxt8icubS8Kz88LuvzFro7dP1a6TL8o + f6DZGZ4EZktU7qQUS/5mgrElFHfiMBOFJzFgcrsTgCn/67Jl8reJL5OpfqeP2LvyQ3GgutyTwBoMJOED + hevFnplPi6rnu7P8CXNOueeWiSn9iDmnYfmX3dMbhebzYv+2TUkVfm3sLy0Xu2d8Isof78fydxUAtAoQ + ZPnLAqBz99OULtMvxPAT/gYJq8iTuGwJKiIRIYHY5G8mGltCcScOM1F4EgMmujsBuORP22ETYCZS9efu + Ys+cZ8XBqhJrompUaHWgYJ3YPekRUTk6h+XvnlsmpvQj5pwmg+V/S56o+ssfxN41ixtV+tE4UFwqaj57 + DbnxPIg+w+WvuSC48i/o2K1AnHDCz5Qu0zPK729xW0TisiWoiESEBJIC8qfvkUvMFhlmEtUfDhT7d65A + AjruSUgpyeGvxd4VH4mqF051iZ/lHyH9iDmnyUz5lz94ttgzd4w4eOhr+zGVaqDg3bdutagceX1my19R + eC4EHzD5O/S4WWkyfaNmeN4/Ikkd8CQqd1JKJfnT0j+StU2ImUGWqPn0enGgcKM9AQWAg0d/FHvXThJV + L53F8jfnmUmGy7/8wXPFnnnjxMEvfrQeQ0Fg/86dovKFe1AA5Gak/OkzAgovzAue/Dt0P7g556x/UppM + 7yi7v9koa4KKSERIICki/7LbWlukmBnsHnOzOFC2y5psAgl1S+tniKoXz2T5m2Sw/MsfvkDsXTlHHhvW + YyaA7N+5S1Q+d0fGyT8EnQYIjvxFfl73J5Qe0z9K7239v0hO30QkqIhEhASSIvKX3T86RZsc05nqV04T + +7cttiaXdIC6vD1L3xcVo3JY/pkq/1vzRM2EV8XBI99bj5F0YO+61aLs7ksyS/7ERXmBkf+uDt2/Lsrp + 9t9Kj5kRZfe1+JMnKaWa/K/NlttnE2S6UvV0C3lxX63v0U8TDlRViJoPrmf5Z5j8q166VRwor7IeE2nH + oe9EzaeviZLBnTJD/gTdF4DeEZDqnT8oaN/jGaXFzImau5v9J5LS0chEhASSQvKn78mk2/1Wv3NF476V + rxHZt3GOqHyqI8vfFL6JORfdczIE5p8pfdtcdc9ZN0mWf/kfeoq9qxZYj4F0Z39JuSh/dEBmyF9zVmrL + Pz+v+5cZ1/3rQOIZHU5ESCCpJH9QgWRsE2X6kSX2zBghL5SzJY5M4eDu3aL6jatY/m7MueiekyEw/0zp + 2+aqe866SbL8K0ZdLQ5UVFtf+0zh4Bc/iepPXxPF/SDbdJc/kPcFSF35i1153Z9UOsy8KL0z99+QgPan + ovzL8H8y4Y5/Vc93kLfntSWLTOMgcfQnsXv2S6LiseYsf8Kci+45GQLzz5S+ba6656ybZMr/xmxR89HT + gb66P1HIYxzsXbtalNxwelrLX6KvBUhN+e8tzsv7V6XDzIyKP7S8KdXkT5/UVY7EbRNmOlH9Tl9xcM8e + a6LINHRiPPClw75Ni0XlyDyWv5sI8ROYf6b0bXPVPWfdJFH+ZXd2E/vW030r7K97JqGP8YP6GC/fLcoe + GpDW8pec3yEV5S/y23e7Xmkwc0P0PeHnSDabPQlHJxhbQnEnDjNReBKDkRB8yp9+jk2Y6UTNJ9eLQ4e/ + sSaKTMMtf2I/2FtaICqfOYXl756TITD/TOnb5qp7zrpJpvzvPU3sL0ijt7DWA7f89TG+/8C3onz0bXbx + E0GXv6LwjI4pJX+wUfTt+3OlwcyOsjtb97YmGltCcScOM1F4EoOREHzKvwQjLfvapJku7J5wd8af79dE + kz+x7yiKgKoqUfn82Sz/CPETmH+m9G1z1T1n3SRR/uUPnSsOlFdYX/NMI6r86RgnjhwTFa8MT1v5S2gV + IFXk37778Z3tep6q9MdBUXpny/cjEo0tobgTh5koPInBSAh+5Q/o99ikmS7QxX6BuY1vkqlN/rIAIPYd + EZWvXsnyD4H5Z0rfNlc1pvBNkij/ypFXigN7Dllf80yjVvnr4/yL46LyvT+np/wJujvgmR1TQf6g29tK + exw6qm5p8R9ld7TY25jyJyqHp+/b/ujz9G1JIhPxLX/FngNficpX+rL8U1z+FaOvCc49/JOMb/nrYxxU + fvRqWspfQqsAjSz//Hbd92xv3fX/U9rjMAMFwDXWhOJOHGai8CQGIyHEKX/6XTZxpgN7pj5mTRKZSNzy + J74QYveew6Ly+XNZ/m7MuaoxhW+SRPmXP3axOLjviPU1zzTqIn95jIOKN55JP/kr6O2Ajdf5S65QuuOw + RdntrSdaE0mS5V8yJH0/63/3ZzeJQ1+m3seZNgZ1lr+ipnq3qHi6F8s/1eR//+niQGVmv8dfUx/5S44c + E2XP3pt28pcFwLl5jSf/dj3GKc1xRIvym7L/vfy2VhURiaQB5F+Kn2+TZ9Cp+aC/OPhF+t7rPB7qLX/J + cVFdnC8qnuzI8neL35yzbpIo/7K7eogDJcXW1zzTqLf81TFec/B7UTr8prSSf9EFDoX0boAGl3/3qp2d + Ov2H0hxHrCi/peWZSBrHIhKHmSg8icFICHWQf8mQHEHv97YJNMhUvXqmOHT4K2uiyDQSJf+aIygAiC2r + cMy0ZPk3tvxvaiv2bV1vfc0zjYTJn4pcOsZ3HxUlt16UVvIvuqCD/KjgBpb/sV3tu/VWeuPwE0gSzzaU + /Oln2AQaaJ5pJQ6U7rAmikwj4fIHVaByxsss/0aUP7F7ylvW1zzTSLj89TG+PV8U9+uSNvLXyAsBG0b+ + Ir9991FKaxx+g24QVHpL67nJln/J4BxR/lD63fN/3+ox1kSRaSRL/jI5Hv5JlL8xhOVvEz+RZPlXPndt + Wn2Gf11Jlvw15ZPGpJX86d0AhWd1ahD5gwV8w586RtGNOf+NRFGZTPnLRDLSLtGgUjP2NmuiyDSSKn/i + 8HFRUbVflI/qyfJ3k2T5l91zqji4e7/1dc8kki1/OsaJ0uceShv5awpOTbr8Kwrb9fwvpTOOukTpTS27 + ICl8F5kYjGRQD/nL7h/J1ybRoFL9yql83h80hPxlAUBsXC7KH4R8Wf4OSZY/fbjPvk1rrK97JtFQ8pfH + eM1RUXzjeWkj/0LijE7JlP+3+bndOiqNcdQnSm5scwWSwTFPQqin/Om5yhF2kQaV/Vsz87POTRpU/qCc + +PBelj+RbPmD6rcfsb7umUSDyl8d46WLFqaP/InzOoYLgMTK//iu3O79lL44EhFlN7V5KKHyB5T0bBIN + KvL9/kaSyEQaRf6HjosyOhXweEeWf5LlT5/ud2DPQetrnyk0hvz1cV4y4o40kb9D/mmdEy1/PO55n9IW + RyKj7MY2b8pEkAD5lwzKSa8b/zzbRhyoqbQmjEyh0eSvmfchyz+J8if2zB1rfe0zhcaUvzzGi2pE8TXd + 0kL+RMHZHRMr/3Y9X1O64kh00NWUEP+YRMifkoxVpAFl7+LXrQkjU2h0+YPSgz+Jshf7svyTJP/KEVdm + 9FX/jS5/OsZByQdvpIX8Nfk9OidE/vntekxY1KvX3ypdcSQj1g3L+0XZ9W2m1Uf+BCVom0iDSNVLPcXB + L36wJo1MICXkryjZuIrlnwT5U9GfyTf8SRX5y2N873ei+Nqz0kL+hed2EAWnd0rEsv+cwqxzf6k0xZHM + qLyr6z+UXp+9oK7yL8XX0umtf3tXfGBNGplASsn/oEPZS9ew/BMs/8pnBltf/0wgpeSvjvGSzz5MC/lL + zumAAgCSr/Oyf/cFpb16/b3SE0dDRM2wvH+E/GfFK/+SgTkyIdpEGkSqXugsDh351po40p1UlH8xjWsX + sfwTKH/Z/W9YaT0G0p2UlD8d57u/EUWDTw++/BV0T4C6yb/HzMquXf9BaYmjIWN739Z/V3Jtm/HxyJ+o + eDR9Lv7L1HP/qSp/TdnzfVj+CZJ/xRN9xaEvj1uPg3QmZeWvKPrwzbSQf+G5HUXBmZ3qIP+eU3jZv5Fj + 0fBef1syNOcDv/IvvTZ9Lv6rei5XHDx01Jo80plUl38RjStms/wTIH9i76rMu7dFysufqPpSFPU/NfDy + l9AHBNEpAJ/yz2/f/V2+xW+KhDjhhJ8VD80ZXpv8SwbkiHIkS5tMg8iemSOtySOdCYL8iw4cF4X7fxJl + I3qx/Osp//L7z8y4K/8DIX86xom/PJsW8pcFwCldfHb+PZ4m5yj9cKRKlA7OHgzx/xBN/iUD2orKNHrv + /4HS7dYEkq4ERv6Kkgl/YvnXQ/5EzbiXrMdCuhIo+RPrt6WF/GUBQLcGji3/H3e27zFM6YYjFaN4UM7p + EP9+m/zpHQM2kQaR6tfPsSaQdCVo8i+gMb+Q5V8P+RMHSkqsx0M6Ejj5q+O86Na+gZe/Rr4TwC7/fTtz + e/RSmuFI5Sjsl/MbiH+1KX+CkqZNpkFk75K/WpNIOhJE+Uv24//8qQ/Lv47yrxh5jfV4SEeCKn86xgs/ + eCct5F94dkdR0LOLRf7d1u/M7XWi0gtHEKJ08Il/jwLgTS3/kv5tRcXjabL8P/pkcXDPbmsiSTeCLP98 + UDzrPZZ/HeRPN/naM/sT6zGRbgRZ/nSM5xfuEUV9IGNT+poAyV8WAGd0cnf+r/GV/gEOFAGXowA4SAnF + KtMAUvPuVdZEkm4EXf6S0j0s/zrIv3RYdkZ83n/g5Q92gcK7hwRe/ppdnbpB/D2O7MztcY3SCEeQo+iq + Nr8tu7tFmU2mQWTP/D9bk0k6kQ7yp8RIlD11HsvfRjT5g4rHLrEeF+lEusifKHjz1bSQP1HQo3NxYU7n + 3yh9cKRDVI5qstom0yCyP3+tNaGkC+kk/52g6OMnWP5uYsifqPlgtPXYSBfSSf6SpWvSQv6FZ0mWKG1w + pEOUP/W7f4c4f3KLNJA820Yc/OJ7a1JJB9JN/jv34WvLZrH8TWqRP7F35Xzr8ZEOpJv86RjfWfOtKOrb + NR3kT/xYfEbevyp9cAQ9qkZm9bXKNIDUfDjImlTSgXSU/859x8TOioOi/J5WLH/Ch/xLh+WIg3sPW4+R + oJOW8scxvgMUPHBDOshfUnRWp0uUPjiCHpUjm7xlk2kQ2bPwFWtiCTrpKn9KjETp0xex/P3IH1Q83sd6 + jASddJY/kf/2G2khf1kAnNnhNaUPjqAHxFnuFmlQ2bd5rjW5BJl0l/92UPzmXSx/H/Ivva6NqHrtAetx + EmTSXf50jO+aPT8t5F94JhUAnUqVPjiCHOWjs1rZRBpUDlQUWRNMUMkE+W/fe0wUTniJ5e9D/nS3zpoJ + 6fUJl5kgf2LHxoK0kH/hmZ0kxad3aqY0whHUqBrZ5E6bSAPJ6GZpdQFgpsh/G8hfPI3l70P+xN7ls63H + SxDJFPnL47z6W1F4CbrnNJA/UXBWx9uVRjiCGhDnBI9IA0r1K72tSSaIZJL8iR2bt7L8fcif2J+/y3rM + BI2Mkr+icOiFaSF/yRmdxiqNcAQ1IM4qt0iDSs0n11kTTdDINPlLqr4S5XdDvDbxEyx/h+tzxKFD31qP + myCRifLfCgoeujVd5E9UKI1wBDGqnsn6jU2kQWX31EesySZIZKL8KTESpQ92YfnHkj8ov72n9bgJEpkq + f2LXcyPSRf6SXWd2/5XSCUfQonJkkz42kQaVPbOftiacoJDJ8t+yBwXA471Z/jHkX3otCoD7gv0x15ks + fzrGd738p7SRP1F0Ot8PILABaT7rlmiQ2bPgJWvSCQKZLn+ieNSFLP8Y8icqHr3MevwEgUyXP7HzzdfT + Rv6S3p2fUjrhCFpUjmqyxCbSoLJv2TvWxJPqsPyPic1UADx3Fcs/hvxlATBigPUYSnVY/g47PvggfeR/ + umSh0glHkEKMPeHnkOaXbokGmX2rP7Mmn1SG5e/Inyj681CWfwz5E5XP3WA9jlIZln/4ON8+dnw6yV8U + nN7pqOjb9+dKKxxBiapRJ+faJBpk9m2YZk1AqQrLPyx/ovC121n+MeQvC4A/32U9llIVln/kcb5t6qx0 + kr+k6KwObZRWOIISFaOaDrZJNMjsWzfZmoRSEZZ/pPw37UYB8JebWf4x5F86NFtUvXiH9XhKRVj+kcf5 + JrBt0vS0kj9R2LvzAKUVjqBE5aisp20SDTL7Vn5sTUSpBsvfK3+i6PlBLP8Y8icqnw7GvS5Y/l750zG+ + 7dPPlPjTQ/4FvSUjlVY4ghIQ5iS3QIPO3iV/tSajVILlb5f/RioAnu7L8o8h/xJQ/sTV1uMqlWD52+VP + x/j2d95NN/kT45RWOIISVaOa7rBJNMjsnf+CNSGlCiz/6PInSp48j+UfQ/5E2YMXW4+tVIHlH13+xI5X + X0k3+dMpgC1KKxxBCPUOgO/cAg06u2eOtCalVIDlH1v+sgB49FSWfwz5ywLg7jOtx1cqwPKPLX9ixwvP + pZX8C3p3pvE7fidAgKJyRJOTbQINOnsm3W9NTI0Ny792+ROl9+ax/GPInyi9sYv1GGtsWP61y5/YOfrx + NJM/OK2z2HVKp5OUXjhSPapGN7nAJtCgU/Ne6p0fZfn7k/+mon0s/1rkXzLE4cDew9ZjrbFg+fuTP5F/ + 53VpJ3+iqFfXc5ReOFI9KkY1vdsm0KBT9UJqdUcsf3/yJ7auXcPy9yF/Yt+WjdbjrTFg+fuXP1F41Zlp + J3+isHfnO5VeOFI9UAC8bhNo4BnZVBw8+IU1UTU0LH//8id2zP6M5Q/R1yb/kiE5Ys+8SdZjrqFh+ccn + /03Fh9NS/g6dXlV64Uj1qByZNc0q0CAD+RMHijZbk1VDwvKPT/7Ero+fYfm7xU9I6WtyJNUfN/67XVj+ + 8cmf2LJ8U5rKv7PI79V5stILR6oHhPm5R6BBRsmfaOy7AbL845c/UfjyjSx/N1L6Gkf+JYNzROXzjXs3 + QJZ/5HHuR/7EtglT01L+Bb0kq5VeOFI9IM0Kj0SDiiF/ojHfCsjyr5v8iZKHTmP5m0jpa8LyJ8ruOst6 + /DUELP+6yZ+gtwCmqfyJUqUXjlQOIU74GcSZHvcAcMmfqH79AmviSjYs/7rLf/P2Ipa/iZS+JlL+mv1l + 5dbjMJmw/OsufyL/hqvSVf7Et0oxHKkc5U/97t+tMg0aFvlXjiBOFgf3H7ImsGTB8g8nxXjlT+yY8QnL + XyOlr7HLn9gzZ7z1WEwWLP/6yX9T/n50/5ByespfUti5878ozXCkapSNOLmlVahBIqr8syT7N822JrFk + wPKvn/yJglfvZPkTUvoaiD6K/EsG5Yiqlxvuplcs//rJn9g6ZU5ay7/g1M5iZ49OzZRmOFI1IMheVqkG + hVrkT+yZOtyayBINy7/+8t9Y85MofaAHy19KXwPJx5A/UXZrL3Hoy+PW4zKRsPzrL39i5zOj0lr+RP6p + nXoqzXCkalSManqVVaxBwIf8ieqXzrAms0TC8k+A/MGWTVtZ/lL6Ggi+Fvlr9ufvsh6biYLlH3mc11X+ + RP7gS9Ja/kThqZ36Ks1wpGpUjG5yk1WuqY5P+Vc+6ZDM+wGw/BMjf2LXR8+w/ENA7D7lT1R/9KL1+EwE + LP/EyZ/e/5/u8pec0ukGpRmOVI2qUVl3WQWbysQpf2LP1Cetia2+sPwTJ/+NNT+KkgdPY/lLIPU45F8y + MEeU3na6OHT0mPU4rQ8s/8jjvD7yJ3Y891QGyF9yh9IMR6oGCoAHrZJNVeogf6Lq2Q7i4Bc/WBNcXWH5 + J1D+YNuKpSx/CYQep/w1+9atsh6rdYXln1j5b6z6ThRccYZL/Oko/y6i8JQu9yvNcKRqVI7KGm4VbSpS + R/lLnsgS+zbNtya5usDyT6z8iYI37mH510P+RNVfHrYer3WB5Z9g+YOtMxe6xJ+e8lcFwONKMxypGigA + nrbKNtWop/yJmk9utia6eGH5J17+m0qPiNI/tGf510P+kus6i4MHvrIet/HA8k+8/ImdD/0hI+QvC4BT + O49WmuFI1YBcX/TINtVIgPwriCebi4OVJdaE5xeWf+LlT+wc/zrLv77yH0C0Fbsnvms9dv3C8k+O/Ddv + KBaF50HCGSB/Ir9nl+eVZjhSNSpGNX3NKt1UIVHyV9RMeMCa9PzA8g8nxUTKf1PF1857/1n+9ZY/UXpL + b3Ho0HfWY7g2WP7JkT+xY8RjGSP/gp4S/kjgVI+qUU3ftYo3FUiw/CuG09daiAM1VdbkFwuWf3LkT+yY + 8h7LP0Hy1+ye/qn1OI4Fyz958t+0pVIUXtA5k+RPvKM0w5GqUTm66SdW+TY2SZC/ZveUJ6wJMBos/+TJ + f2PVt85b/2ziJ1j+ccufKLv9bHHwiP93vbD8kyd/Qt75L7PkDzp/ojTDkapROSrrY6uAG5Mkyl8yMlsc + 3LPHmgjdsPyTKH+wY/rHdvETLP86yb+kv8OeWf4+IIjln1z5b95eLQov7JZh8pd8pDTDkaqBAuBtq4Qb + i2TLf/jJkppP77AmQxOWfzgpJkP+m0sOipL7urP8kyB/ovSGU8SBPYetx7aG5Z9c+RM7H747E+Uv8nt0 + eUtphiNVo2pUk79YRdwYNJD8Kx532L9liTUpEiz/cFJMhvyJgjcfZvknSf6aqjdGWI9vguWffPlvmb8y + I+Vf0KOLKOzR9RWlGY5UjYpRTZ63yrihaWD5E1UvnikOHfFeLc3yT778t67fLMpua8PyT6L8S/rR2A6F + rvdzMFj+kcd5MuS/sfJbkT+4T0bK3ykAuvxRaYYjVQMFwGirkBuSRpC/Zs/cv1gTI8s/efLfVP2DKB7R + h+WfbPkryh+8KuIzAlj+DSB/sP31NzJW/oqRSjMcqRqVo5o8bpVyQ9GI8q94DIzIFgdK81n+rqSYLPkT + O8e/xvJvIPlrasa9zfJXx3hDyH/zml2i4KLumSx/UdC986NKMxypGigA7reKuSFobPkrql44UxxEdmT5 + G4kRSSwZiXHrmjWi9PZsln8Dyr/kGjCgvdi7aQPL3zzGCcsxWm9KvxT5Q/tmtvxlAdD1XqUZjlSNqpFN + 7rTKOdmkiPw1NZ/cyfJXJEv+m4r3e9/zz/JPuvyLFaW3nC327z7M8qdjnLAco4lg55OPsvy7g25dblOa + 4UjVqBrVdJhV0MkkxeRf8ajDnlXjWf5IYElJjDU/iqLnr2P5N5L8i6/JlVSMvkUcOHqc5W87RhPA1k/H + s/xJ/iC/e5frlGY4UjUg30utkk4WKSp/yZM5Ym/RdpZ/Etg19hWWfyPLv/hqh+qxb7H8k8CWVdtEwYU9 + WP6KXd27XKQ0w5GqUTU6q6tV1MkgleWvGd1Z7C0rZfknkB1zJ4uy2yB2ln+jy19yTTtRPXsSyz+BbN5c + LgquPJvlr8jv3pWe66w0w5GqUf5UsyZWWSeaIMj/EaKZqHzudLFn936WfwLYtnRR5EV/LP/GlX+oCGgv + apYsYPkngE35B0T+4MtY/ob8iR3duv1eaYYjVWPPczn/ZBV2IgmQ/DWVf75A7Nn/Bcu/Hmxdt0GU3pXH + 8k81+V+lGNhZ1GzYwPKvB5tKjor8Yf1Z/i7553frKiq7dv0HpRmOVA5I+kuPtBNFAOUveRhFwBv9xZ4D + X7P868DWjVtE6T1dWP6pKn/NtaeKmq07WP51ofRLsev2YSx/i/zBEaUXjlQPiLrQI+5EEGD5aypfulTU + 7D7A8o+DratWidK7O7H8U13+ipKB3UT1qpUs/zjYlL9f7LpxAMvfLn9il9ILR6pHxaimy60Crw9pIP9Q + EfDc6aKmrJTl74Nti+eK0jvbsfwDIv/iKxX9OorKBbNY/j7YtKVS5A/qw/KPLn9iidILR6pH5ais8VaJ + 15U0kr/kIRQBo9ElFWxn+cdgx7SPIj/gh+UfDPlrrmonKsZ9wPKPweZ1BaLgqvNY/rHlL/K7dv1M6YUj + 1QPSftEj8bqShvLXVA5vLypXz2D5u9hU+Y3If/uxsPhZ/sGTP3FFO0nZq0+Jqv3fsfxdbJ00SxRecirL + vzb5S7r9SemFI9WjYnSTm6wyj5c0ln+IB8FH94nK/V+z/MHm7cWieMRlLP80kb+m9O6rRUV+OcsfbKr4 + Vux4/o9e8bP8LeIHXbuKgm7dhim9cKR6VI1o2tsq9HjIEPmXa/50vqgoKsho+W9fNEeU3tOZ5Z9m8pf0 + bYft6iHK5s7MaPlv3lQq8m+4huUfh/yJwq5dT1V64Uj1qBzZ7NdWqfsl0+T/YHNJxWPtRfnCj0T5gR8z + Sv6bivaL/DceiBQ/yz+t5G9S+sLjoqzyUEbJf1P1j2LbR2NE4aWWJX+Wf0z5E9s7dvxfpReOVA8hTvgZ + RH7UI3Y/ZKj8yx8weOFSUbZtY/rLv+ZHeVvfkvu6s/wzRP6Sy8HAU0XJuI9F2YGf0l7+W1ZvE/m3DBaF + 50LeLP+45Q/4HgBBi6pRTddZBR8Llr9BC1H24f2irOpgWsp/y8atouipq73iZ/mnv/wNSu6+WpSu35KW + 8t9UfFjseP45UXB+Z5Z/3eVPrFFa4QhKVI7K+tgq+Wiw/MPcbzC8syid9ooorj6SFvLfsnmnKHjt7si3 + 97H8M1L+kj6gb54ofvYhUbK1MC3kT+Lf/voboqBPb0f8LP/6yF/kd+76vtIKR1CicnSTx6yit8Hyt8tf + c19zUfZwO1E6dpQoqtgbSPlv2bxd5P/1AVF2exTxEyz/zJN/iPZ4DoXAk3eKonVbAyn/TQUHHPFfdhqk + 34Hlnwj5dyG6PKS0whGUqBqZ1dcqezcs/1rlH8FDbUXpZyNE0Y4dqS//6u/EtiXzRNHz16Ljh9wJm/gJ + ln9myx8UEZcpHrtVFM5fKAr3fJ/y8t+8ZrvY8dzTouDiHkr8LP/Eyb+rKOjS5TKlFY6gRNmI5idZhW/C + 8o9P/pp7W0jKnjlfFE9+WRQUV6aU/OmDe3Z9OFqUPtAjLH6WP8vfr/xN+vcShS+MFAWrN4p8HMOpIv9N + O/eIbR9+IvJv7GdIn+WfaPkTRR07/lZphSNIUTWq6R6r+AmWf73kH8F9EN8rQ0TRjLdF/rbtYufenxpU + /psqvhLbViwVuz55TpQMPy9S+ix/ln9d5X9pJIU3XSoKXv+zyF+8Quys/Lph5V/zo+z0t7/3gdh5z42i + 8HyI9zy3+Fn+iZY//l2jdMIRtKgcmTWN5Z9k+d/jpeyRzqLkjVtFwewPxa5NG8X2iiMJlf+mgmqxbeVy + sXPsS6Lo2f6i7K4cUXY7RE6w/Fn+SZC/5BKDyyGne4aK/LdeEzuXrBY78ncnVP6bSo6ILSu3iG0fjxE7 + H7lbFPbt7QjfhOWfXPkTnbtOUjrhCFpUjG76CMsf4m5A+ZffbeEPKAoe7S6KXxwgCt9/TORPe1vsmvMZ + EucssX3lUrF93edi2+btYuv2Erl8v3X1KrFt2QKxfcE0sWM2EuC4l0XBG38QxaP7iNJ72ouyOyBuLXwT + lj/LvyHkr7k4L5IreorC2/qJ/BEPiF1vvS52jB0vdkzFMT53sdi2ZK3Yumab2LK5VGxZu1NsWbZebJ23 + XGydNldsGztRbH8fnf0zI0T+XcNE4dVniaLzIXSNW/ws/4aRv1MAPKB0whG0qB7R5AyWP2hk+YdpKSm7 + Kwp3WrjDDcTN8mf5p5r8iYuicKGFCzQdwkD2Gpa/QaPJv5vY1bn7aUonHEGL4qeb/CvEf4zl74Llz/Jn + +bP8Wf4x5Q+OFXbu/C9KJxxBjKpRTXew/A1Y/ix/lj/LP9XkLwsACDx15C8KunTbqjTCEdSoGtn0XZa/ + guXP8mf5s/xTTf6p1/k7BUDnbm8rjXAENVAADGL5A5Y/y5/lz/JPNfnLAgACTzH5E7s6d+uvNMIR1Cgd + fuL/QvzHWf4ubOInWP4sf5Y/y78h5J+inb+kS3cxferWRbM3HDhDqYQjqAH5b2b5G9jET7D8Wf4sf5Z/ + pssfrL2wn/jzpBLx8uRS8f78qqNTVu6dPG/LoWylFI4gBeT/LMtfYRM/wfJn+bP8Wf4sf5HfqZuYeefT + Uv4vT3H4y9Qy8dq0cvHpkt01s9YdGF1YKH6p9MKR6lH1RJPTWf7AJn6C5c/yZ/mz/BtC/rIAgMBTWP7E + Ry/NipD/q9NQAEwvF6+DN8CHC6q/mbH2wPjlG77+ldIMR6rG9uGt/w7i/5Llb4Hlz/Jn+bP8Wf4h+W/v + 0Vu8Mqkoqvz/OrNC8ib4YF71j9PXHJi9YuuRpko3HKkYlSNOnsHyd8HyZ/mz/Fn+DSH/ACz7a5YNuN2X + /N+eXSl5Z06l+GB+9U8zPz8wZ8GGw79XyuFIpah88uTbWf4GLH+WP8uf5d8Q8pcFAAQeAPkTkx9/Ky75 + vzu3Srw3D2D8eEHNj7PWHRi3aOPhf1Pq4UiFKB3e4kRI/zjLH7D8Wf4sf5Y/y98j/12de4i3P1pfJ/l/ + MK9afDi/GkVAtRi3bPfXCzceemb4cPE3SkEcjR0Q/iqWP8TN8mf5s/xZ/smWf4CW/TWr+wytt/w/WogR + fLq4RkxZta9y0ZYjfC+BVIiqJ7PuZPm7YPmz/Fn+LP9Ey18WABB4gOSf37GbmPr4mwmTPzEGjF22+9i8 + 9Qembd++75+VijgaI8pGtfw/yP8nlr+C5c/yZ/mz/Fn+Uv67OvUQb3+2JbHyX7pbjFuyW45TV+87sHjr + 4UuVjjgaIyD9xSx/wPJn+bP8Wf6Jln8Al/1J/sSqK29ImvzHL9sjJizfIyYt33t84aZDY9atE79QSuJo + yID4b2L5W2D5R8LyZ/kTLP+MkD8x5cn3kir/iVQArNgrJq/cK+asO1i8ZCffWrjBY/forP+C8H9k+Ruw + /CNh+bP8CZZ/xsh/V5ee4p1x2xpE/sSU1fvE9NX7vl256+hQpSaOhgpIfw7LX8Hyj4Tlz/InWP4ZI39i + 5TW3NKj8p1IBsGa/mLH2wPElWw5/JIT4udITR7KjcnhWf5Y/YPlHwvJn+RMs/4ySPzH5mTENL3/FzM8P + iMVbjqxatE/wuwQaIgpfyvolxL+P5e+C5c/yZ/mz/DNM/ttOPUe8NbWk0eQ/i1h3QCzafLhkY+m3JypN + cSQzyoZn/bEcsvcA2XuA7D1A/uUQfgQQvRXI3gOkXxaiuQNk7wGy9wDRW4HsPUD2HiB7D5B+GMgblEL0 + ViB7DxB+JK1EKWTvAbL3ANFbgfw93BymRHOThRvdtBYlN0RhmIXrLVxHtInkWgtDHYrdDDHJdhhsYZCF + gRYGEDle+lvoZ+GaHFEUoq3D1RauisKVFq7I9dLXwuUW+pi0kxQSl1m41MIlFi5u7+WiKFxo4QJNXpjz + wxRozrNwrpsODudYONvCWRbOJDpGcoaF0x3yTXqbdHI4zUIvC6daQAEQQU8LPSx0D7MLBYCkm4WuFrpY + 6NzVSycLHS106Crm3fV0o8t/zvqDYu6Gg2LRpsP7thR9nac0xZGsqHygaRY6+2P+unwXDxPo4E0gdSsQ + vIcHUACEQNdOQOy+uvx7owCxx9/lK+4yQecPrB0+ITt7F7e7QdcOsfvq8iF1KxC72elL0NVronf5AFKP + BF27rcMnonb5LiD2aF1+BJA6EdnpA4g9DLr2uLt8F5B6PF2+B4i9OERu9C7f1uETELuHOnX5Ckg9DDr/ + uLt8C347fCLU5dvgzt/b/aN7D3jnn9+hG4qAHuLDj9alhPzngfkbD9FKwNHNJUd7KlVxJCvKHj15vtPJ + A0jdw0MWHiScDj5EhNAN7rdwHzr+ELpzt3CPhbujAIl7gMw93GnhDhPIG5RC4lZu8wO6c4g93m4+AnTw + EUv5LtHLbp6g7t2Np5tHNw6pW4HY/Xf0ELdJDMnH7ujReRMQuweI3X83D3G7gdg9RIhe4bubj0JfC5er + Lt4koqNXXGbhUhN0/jE7egsX2UDX7qfDJ0JdvsH5GqPjR1evid7lg3PcoGuPu8t3cQZh7/IjQHdPRHT7 + p5mgc4+ry3fRk0D3HkeXH6JbmPi7fAtxdPke8hxWXn1zSsmfWACWbDn8zbriL85XquJIRlQ9ltW38eSv + uNfCPRbujsIfqABwcZeFO2vDKQhKUQhYud3CbW5QANxq4RYLN0fhJkIXAYobw4SW9G+wMMwNCgDbUj4h + l/NdXGthKKGLAMUQC4Mdit0MMlFFQNTlfBf9LfQjdBFgcI2Fqy1clQPhayDuaNgKAsJaEEDccS/xKyKK + AciflvcJXQSY+C4IIG6Wf/3lbyNNlv0duonJL0xMOfkv2nwYHBJLtx/+Zn3x1xcoXXEkOsTwXn9b9lBW + NRARPGjhAeLkSO6Pwn0W7jWBuOMR/R+i4Ff0d1i43QTytwpdcauFW9y4RB4hdBc3uoDkK5+/TuyZO0bs + 375JHCivFPt2bhN7Fk8WVS/fiu9B5x9T9OB6NxC3TfJEVNG7GELYRR8B5E5Eyh4MNIG44xa9i2sISNyn + 6D1cCemHgLijCT0aSe38HQqJSyxcbOEiCxeiAHBzQRTOt3CeBgWA5twwBZpzLJztBgUAcZaFMy2cYeF0 + AgVAbfR2yDc5zUQVAb0snGrhFAuy+zfoYaG7hW5hdsnuH3S10MVCZwudUAC46Wihg4U8TVexpfcF4p1Z + 5Skp/yVbD4ulYNnWw1+vK/ryNKUsjkRHxUMnj/R2+S4ge18dPoGu3oPZ3ce7xG/r8Ik6LfErlPAdnPP2 + 4SV8F746enTnNqIu7ytubiOqXv+D2F9UIA59JaKyf9d2UfHMwMyWvwQST2Tnb3b2tRUESZV/gpb9/Xb4 + RKjLt5HhnX8il/0NUqnzJ+bf90JKy5/GZduPiBU7jhxdX/pNF6UsjkTGjjt//39lD578bVj0LtDRe0BH + bwXdvYd70PGHQAEQT5d/VxTq1OUrbjNBARCtw49GIjr/m1qjs79Z7M/fYRW+jYNHj4ldLz7qlf11biBu + m+SJqKJ3MZiwiz4CyJ2IlL0biDsonb9N8sTlFuokegU6+jCQv1v4Jg0l/1DHb0gfYtdEFz3Qnb6bRHf+ + qsu3kbTOvyehiwBFHTr/0Pl/dPoe0Ol7QKfvAZ2+B3T6HtDpR6erZGeXXuKDCdus8v8oivw/g/THWuQ/ + EfKfZJG/xi3/ORC/LABc8l8I+S9W4tfyX07sOCJW7jx6aHP1d82VtjgSGeUPZL1Zdl+W8HAvAXGbRAjd + 4G47pSGaOUDsHiB1D3dGAWL3ALF7gOA93GoCeYMSSNzKzRZuctNSlEDoHm6Iwo0Q/xv3igMlxVbJ18qX + x8WOJ28Ny/5aNxC3TfJEVNG7GGRhoIUBDsVu+pugACD6+eQaC1cTKADcXGXhSgtXZEPuGhQARF8Ll0eh + j4XLUAC4udTCJRYuNkEB4F7WN7Eu8Vvwu7xPhJb4Dc7VoADQnBMm+hI/OMsNxB2P6G34lT8ET0QIv5cJ + 5O1X9CHZG/QgIO+4RK/oGibmEr8NyN677G+ho4UOFvI0XUIsuuXxwMh/xY4vUAB8IdYUfFmxuejL/1ba + 4khUlD3y+5PQwf/g7ead5fsQ6N6tQOw2wh0+uu1oy/l+z+MTtS7nK1RnHwFk78bbzSsgew8QfiRGZ2+C + AsALxP/qnXUXv8Ge8v1i/TVdkyh/e5dvw9PtDzCBfOPu8l1I2aOD99nle9DCl0C40bp8W4dP9LEBaSe6 + 8/fd5Vvw2+ET5nl9TUj6kR2/JmU7/0TL302COv9GP+cfInwKYGfHHuKTMesDJf9VVADsOirWF331eWGh + +KVSF0eiovzerDFOxw/uIdDB++jwy/5g4S50/CHQtUfr6O+wcHs00LXH3eUrbjGBvIG1wydkZ+/iRjeW + 7p4Y5uLGNuj474f4S6wyryvrXnhFfH4JJDu0lQLdNqRuBWL3ANF7QFcfW+gK1dUXuUEH7wt09R7Q5Xu4 + ikDX7gZdvYeILl/RN1sUhshxQEfvAR29lctstPWCTt8DOn0P6PjDoGsHBQS6eg/o6j1cYAEdvQd09FbQ + 4UcHnbvG7PiT2flL0bvoTdhFHwEET0QK3wTyTonOX9HFQmefJLjz39W+i1h27X1S/DHlvwjyB5+R+KPJ + n877gymrIH9glT+Ysw7yp/P+YN4Gi/y3QPyKZdsgfgIFQIT8dx6VBQCxseTrcUpbHImKioeatoH8jzWq + /KMRMPmXkvj/+oDYX1ZmFXh9qdhcIMbn5ojPL4a0qQAYEoXBFgZZGEjoIiAGapm/yE1/E4g7WkHQgPIP + g+4/GigArKAAaJBlf8je1xK/jYQt+xucE6ZAc7aFs9yoIuBMC2f45HTCVhC4OM0h36SXiSoCTrVwioWe + FmQBUAvdLXQLswvFgMQsBOItCBItf7Azr5sY9/4KKf/3If8PLPL/BOKnAsAt//EQvywADPlPhvipAJjm + kr9mtkv+uvtfaMhfsxTilwWAkv8KiJ8KgNWQ/2ol/88LvhRrwZbSb+5T6uJIVJTf3XS6L8kTELyHOyH9 + EBB3NNFbO/wo3GbhVgu3WLjZBAUAcVMUbrRwgxsUEMOiU3Zja1H91oMQf7lV3ImCLgic0LGjmJibLdZf + 1EaUQOweIHZfQP7Rzu9HALkTkef4QT+TNg4Qu/1cvguI3sOVRLY/IHsPNvn7lTyBTt/DpRYusXBxbThF + gFwFuMjChRYusHA+CgA350XhXAvnaAzpQ+waq/Q19ZW/FL2L3oRd9BFA8ESE8E81gbyj4Uf+PQgIPA7R + h+gaJqbobVjlb6GjhQ4W8jRGIdDeYVW/WwMv/3VFX4mNRV9/v7X0215KXRyJiPI7m3e3yt5NouVvkzxR + a0cfAy18CQQdrcMnPF0+gOwjiezyQ1xPHX+2qHrrYXGgrMIq7GQwtffpYmJOjpiUm4MiAPKF9Gvv8l0M + IPB/a0PJPrLTB5B+GHTtcXf5LiB/312+DUg/4cv+6OrjX+K3AeHSkj+BTr/Rlv11Z18bqSZ/RdI6//rI + 3yBVO3/NuDcXBl7+68EGsKnk6907q8R/KH1xJCJK7zp5sVXwGgjewx2QfgiIOx7R27p5wiZ1GxGiV0R0 + 95B/NMkTHtEDdPMervdC99iX4i+vtEo6mUzu0VMWABPb5ojJugiIJnobNvlD6h5Udx8pe3CNCcQdt+ht + QOJ+5B/q8A0uN0G3TUDqvjp8wtbl2/Db+V9kgs4/7i7fgq3Dj0Z9On+P6MGZbiDuaKK3UR/5Q/C+On8/ + oo9GXeUf0fkruljo7JMkdf7EmiuuTRv5byz5Wmwq/lpsLft2ulIXRyKi8rZmnUrvyDoGIHIXt1u4LUuU + hDg5OrdauCUKNzfzcpOFGy3cYNJcUhyNYRaud9NCFF8XSQmJ/437k77UH40DB78T49q2DRUAk9pmiynt + ssX6C7XYDfpb6OeTaxyK3FxtggKAuMrClRauiAYKADd9LVxuoU8bdPAadP/EZRYujcIlNtD9u4HYPUDw + Hi40gbhBAQGxe4DYPZxnA92/G0jdCiTv4WwLZ4XJ15xp4Qw37aJzuoXeFk4j2kfSy8KpDrtMTjHJi05P + Cz0sdO8QSTcLXS10MYG8o2EVvYW4RW/QPjY72ncRE95e5JH/Jxb501X/41zyDxUALvnTOMMl/9kQvywA + DPkvgPwXQP6LXPKXBQDkv9yQ/yrIfxXETwUAiV/LP1QAQP4bIf9NGDeXfiN2VH93s9IXRyKi9M6sSeGO + XnG7BYg9DLr2aFg7/CjU2tErbOfsI0CHHq3DJ3x1+S1FyXVhSm/Ihvjp4r7GEb+manuJGEfyNwuA3Gwx + tX222GArAkxkEWDv8iNAZ09EdvpAC18C+cbd5buQskfXHneXr9DCl0C4BDp636Cr9+B3iV939Sa6qzeI + Kn8b1oIAkk6I/NG5x6K+nX/ULt8FZG/t9N0kuvOXy/y1gALAAwoADygANHF3/jb5J7Hz3wlWDLwzLeW/ + uewbsaXs26+K9n2XpfTFUd8oe+22dhVPX/RD5es3ierPRonds94We5ZMEHs+XyD27Vgv9pcWi/3lFZID + +4+ALwLD/r2HxL6yCof8HWLvptViz8q5ombOp6L60+dExSt3iLIn+6Do6SKKr0XHD0puyBFV7zwh9lfW + iIMQcGNTuGCltQCYkttGTEcRsP5CyBkdvB36mkEMyRe6QVfvAV29B3T0vuhLoGt3g67eQ0SXr7jMBAVA + rC7fhq3zr1OXr7jABPKPJXUbts7fr+QJs7vXGF2+jTp1/nF1+TbQ1Seq8/fb5bvpTkDeJhB7vJ3/Tkhe + ArH7opOFjhY6WMiz0F7TycoOsL1DNzH207VpKv9vxLbyb8WOym+XKn1x+A0hxM8OfClaHvhKDIBYngNz + wG4tmkznAHbOvvydYn/VbuvXG4stH423rwCgAJiGcXr7NmLjBdTptwzTj8BzJtdYuNohcpkfXGWCAoGA + 7H0B2XuA/ONZ4vdgk78Nm/iJ+sjfhqUgKCBQDHg438J5Fs6lAsAn51g4WwPZWwqCQC37RwB5E+Zyf7wF + gSwADLr5pKuJtyAI0dlCJxuW1QAUAB5QAHhAAeBgrAJA+BpdBCy9+bG0lv+2im/FdpC/54frldo4bAHh + /82Br0XHQ1+JByD9aZDJAbdcmNRn7R9fjroCIAuAdm3ETBQBG1AEyK4fYo/W5UegxG7t9ENAuMSVFq6w + AKnbO3wI103Ecn4MIPYCN5C6B0jdysUWIHFfaLGbRAgewgX5BLp6D+jqfYFO3wO6fCsQu4eQ4CFdzZlh + dsUCUrcCsXuA2D1A9HYgbxPI3oNN+Knc+dvw3flD0G46WIDYfWFInzp/YkvXU8WYKTvEhxA/FQCm/MeQ + +C3yn2CR/1QlflP+NM5yyX8uxE8FgCl/zRJD/ssg/+UQPxUAWv7EGoif+NyQ/3pIfwPkTxf+afkTWyH/ + rRA/FQA7qr4TO6u+P7h171f/o3THQXHokPhXCP9qCP9DyGOvWyZM8Fh69wORBUAO5C+LgHABMIOKgLzW + YsP5rUQhOvgI0MV7uNKhwM0VJq2jg47ew+UW+hBtvKCT98WlJhB3NNHbJE9cZMEmdRsRoldYuvl8Ah28 + h3N9gu7dAzp5K2dZOFODAsDCLg06ew+nu4G44xa9i14E5O1T9DtNevqkh4XuLroReZGgk/fQJTY7UABI + 0NV7QFfvoaMFdPC+QIfvob0mLPod7cJs1+R2EvPv+5Mj/wWQP6QfVf5gArE8ivxXO8xYC/kDq/yp+wcL + NkH+myzy3wrxywLgC6f7BxHyz4f8weeFkD9YT0D8EfJXbC2D/Kn7l8v/30l2Vn8v8mu+f1+pL3OjUoh/ + OHRUXAg+OPil+BoIJn2Y22+QjwKgtZjZvrWYlddGbDSLgBjyjw26fwKyt5/LdwHZe4D8refybUD2HiLk + r7jEwsVxYC0ILFxg4XwTQ/42/BYE8cjfRqgQgOwtS/zxyT8GvS2cZqEXoYsAxanR2WlyignkHa0g8CN/ + CQRu4i4GfBUE1P0DyN4XKAA8oADw0MFCXiw6hgldB2AUB+06is2nnCk+mV2cMfLfVfWdyK/+/lj+7h86 + KhVmVuz/WuRBEG+g2//qAETBpCdTep/pbwUARcAsFAFz8lo7RYBN7OjsichOH/Q1QdceDYjd3uW7uIyA + cP0QRfT5IbId0NF7gMB9cyGE6wZdvQefQt8VDYjdwzkWIHAPkLlv0PU7QLr1Fj2EHE/n75Z8SPSuLt8G + xO6r8/ctehcZ2PkTM5/+MG75T165L7jyBwU134vCmh9WKCWmf+zZI/4JUrgFbDMlwaQn+w79IMa1bRdX + ATBbFQGbzkMH7kf+EUDcRH3kL4HE3dRJ/gp07765yAK6eg/o6n2Bjj8M5B+jKLB3+TbQtfvt/CF7Dwld + 9lf47fJt+O380d0Tkd2+CeRdn4LAJn8btRQEOzSdLXTyibUgsIAOPzq2gsAAnT+x9tKBGSl/WQDs/l4U + 13zfRykyPWPPl+K/938phkMKdLG6VRZM+lG5q0KMzW7ruwCg0wC6AJhL1wScp8Qe0eHXwuUW+li4zMKl + BAoAP1xi4eLWkLgG4o4m9GhcaKFWqcfgPC+7iHMtnGPhbBvU/bs4KwpnWjhDg+7fwk7N6RZ6u8l1gMR9 + AdF7OJWAvE1scu/pkx4WulvoZkMXAYquFrpY6BzGKn2NVfQWbKK3YZN+ewvtwmzX5Dps69BFTPhwZUj+ + hCn/sZB+qAAwlv0nQfxUAJjyn07iN+Q/C+KXBYAh//mQ/3zIf6Eh/8WQ/hLI37noz5E/sRLyX2nIfzVY + C+mHCgCIXxYAkP8mSJ8g+W+B/LdA/FQAbFfy3wH574T4ZQGg5F8A+Rft+UEU7f1hC73LTekyfWL/1+JX + EMHL4DtTDExmULhoTVwFgLkCMI+KgA6txEYUAb6X/ePq8l1EW/aP0uV7MLt423K/xra8TySsy1dEiB9d + O4i6xG8DnX5qL/srzI5fA9nbu3wXkL+103eDAsDT+UeIH/KN1uXbcHf+svtH915bl28jQJ3/dg26fs2i + O0dluvxFMSjd99OVSpvBD9nxHxXPQwLfuKXAZA5bxkyOLACApwDAOANYC4C8VmJeh9Zi07ku4Ud0+BB3 + 3KJ3YevwCVuXb8Nv52/r8KNRJ9Er0NGHgfxjAbF7QFfvAR29b9Dpe0DX79A2DLp6za5YoNuPBOKOR/Q2 + bPJXoo8AgicihW+BO38vRudvY+Np54oxc8tY/nt/FKX7f9wR+FUA/AG/OPiVuAPJ/4hbBkzmsfb5V0MF + wASjAJhsFADTZAHQOvIUAJjbvpVTAID5tBJwTkuRfznoY9LK4TILl/rkEgLidhMhdcVFdnaFaOMAgXu4 + IArn++Q8C+fWRrZkJ3GOhbMtnGUjxwukbgWS93C6pq2VHRrI3cNpUejlk1MtnELkRtLTJz1M2jlA7B4g + dl9A7hFA7B6k4KOzXdPJQkefdMjzkmehfSw6hIHgNds0tORvMOOlCSx/kv8+h7K9P12qVBq8OHBUXLL/ + S1EEBMMQS+9/JK4VgMgCQK0AUAEAFnRsKTadA1lr6aObl6CD9wU6eg828RM2+dvwK/9oWAsCSNsNunpf + KOE75Eh2EujqPaCr90V95R8CstcY8g8B2ddOrgM6ff/n922g6zZBp+9BdfY7TLTwa8NPQdCVgMBro5aC + YDs6/Kig0/eATt8DunpfoNP3YEo/lvxdrBxwi/jYJf8xFvnTjX4mrdwXkv8UyH8qxE9o+U+H/Ge65K8L + AC3/BZA+FQCElr+88A/ylzf6UfJfAfFTAUDiJ9ZA+qECQMmfbvazEdInqAAg+W+G+KkA2AbxywIA8ndu + +IMCAOKXBQDkXwj5F0L8VACUQP4lED9RduAnUb7/p2VKp8GJ/V+L/0O3N96d/BlmzoChsVcAMEasAIDZ + wFwBIGQB0KGlWNixldh0dkuxCx2+BB28L9Dle7iYgLjdREg9Bhe2FjtDtHGAwD2ge/cNunoP6OR9cY4J + uva4u3wLcUveha3zN4Rea5dvw2+Xb8Nv5686/O1RaecAsXuA3D1A9rXSxULn2qACAPjt/DvYoALARZI7 + /y1dTxHjJm8Ly38x5I9x7NIo8qcr/sEUJX6P/D+H/FEAOB/ta5H/ZvpoX4fFJH5T/tT9g5U7IH/q/kGE + /Asgf7CuCOInUABsLDHkXwr5U/cPtlV8J7aDHVWG/FEI5APnin/In7p/IOWvKNv/E8lfVBw8JioPiE5K + rakd8t78X4mBSPQHzaTPMJopZ5wb3ykAVQDQKoC9AGgpFqmVgFARYFJf+duIIn9fXBCF8y1A9r6A7D1A + +mHQ/ZsFgBu/BcGZcXCGhdM1ZiEQZoemt4XT3EDc0eRvw6/8bcQoCCLo7pNuLroSegUgBigAPED6mpjy + t+G7ILCQZ6G9xigE2oXZFoPZo9/zJX+59J9B8ieqDh0boxSburH3K/E/+4+KGe6EzzCafV8cE2Pbto9e + ALQ1VwDUKQBVAIROAaAICJ0CyEMB0KGVWIRCYFGnVmLj2a2E91y+C4jejn053wMkbiMseQg36lJ+FGxS + r3U5XwGB+6H+ooek/Xb+htS92Dv/EJC6byB2DxC7B4jeTm4kELsHiJ2wCl8C+fpd4idsYo9zid9G3J2/ + jUbo/IlV/W9h+UeRf+WhY6L68PHvCneL/1KqTb04cFRcigS/30z2DOOmoqBGfNambbgAyI5VALQOrQKY + KwBz1CoAFQDzzQJArQRsPLul2AnR74TUPVwUjdZeIHMP6NQ9oFPf4YfzonCujTZe0Ml7OLs2ssNA7B4g + dl+ge/eATt5K71igc7d09Ns1vfzQ1gFi9wCp+6KnhR7R2WbS3STXAV28B3T1tdKFaBcJOnlfdDJp7wCJ + +wIdvAd08B7Qzfuincbo6nPDbI3Bxp5niLEz8sWnkP4Yl/xlAWDIfyLETwWAKf9pJH6X/GUBYMh/HuQ/ + zyX/RRC/LACU/HUBsMKQ/yqIn9DylwUAxC8LAMh/A+S/AeKnAmCzkj+xFeKXBYCSvywAIH5ZAMjz/j+I + AoifCoBiJX4aSyF+WQBA/ETFIXT/h4+LqkPg8LG7lG5TJ4QQf4fE/qqZ5BkmGnsPfCcW3XGvzxWA+AuA + xRgXd2ohNp2FIsBWALixFgPgQgsX1Ea4IPAA0fsGso99Lj8GkL4bWQic5ZMzLdjkH42YBUEt8rdhLQDA + qT45xUJPAmKvDSX/CCD9MLnRQQHgAcKvFRQEHjpb6BQmshBw0dFCBxuQd1IKgvZiqybXRgcx/cXxaSx/ + 1f1Hkz9d7OdD/tUYd38htintpkYc+Eb8eh/2FRAMEw+bPhwvJiAp2FYApkYrAMDcdqoAAPMJWwHQoYVY + 2qml2HgmioBYQpdAuD67fBu+unxrhx8FSDz+Ll8RIXMIF2wn0MH7AgL3AIH7BpL3cJoG0o2FL8lDutHw + 2+XbiCH6yG7fBOIlIHZfnT9E7gXira3zt0ndYKsGYvcAsfsCYvcAifsiJHh08xpLl2+lbZ5Ydv19LH8f + 8q85IqgAoDFP6bdxA0m8J9hjJnWGiYeCRWvF1J6n+l8BMAsA6v5jFQB4vIRWAswiwMRaDABrZ2/h/FYQ + vgbijib/aPiVv41a5V8L1i7fBooINxC9Fcg+OrV0/jb5R8NTFABbl2/D1vnb5K+o07K/Dd8FgQt0+h5k + x6+xFwUSFACp3fm3F+t7nSM+m1/Ky/4+5S85Ip5RCm682Pel6IsE/q07oTNMvFQWVIvZF17sFAAg2grA + LIjfvQIwL1QAAIxUBJD8nQKghVgClqEIoJWAHRcaXEBA3G4ipB6D8yycGwfnWDgbBYAfzrJwpgnEDbZH + A2L3cLpPekfhtFgYqwC9wmzTnOqHHAdI3AOk7osePuluoZsJCoBodLXQxQbkHZfovWzVdLTQwSd51P27 + aO+TdhrI3CL6LbFoC9p3FlPeWxSS/2eQf+i9/kr+sgAw5K8x5T8D8pfv9Vfynw3xUwGg5T8f0qcCgCD5 + ywIA8l9iyH855L8c4qcCgMS/EqyG/Nco+a+F+GUBYMif2AT5b1Ly3wLxywIA8t+u5C9v+EMFgJJ/PsRP + BUCREj+NJRC/LAAgfqL80DFRCelXynP+KAAg/xrq/MOUN+qdAfd9Ie5A4j7mTuQMU1dqqr8QCwYMqqUA + 0CsA9G6AVq4CoJVRABgrAKoAIGglYAc6fKv4oxFF/ttDtI4OOnor59iAKN2gq/eA7t0P2wjI3gNk7wt0 + 9B7QyfsGsneAMGOBjt6Dlr0f4ioIIF4Td4dvdPlbowJpEujqPaCrrxXI3gNk7wtD+lvQ4UcFnb4HdPpe + IGE36PQ9oKv3BQoADzb5K+Y/9koS5E83+zkoxT9v00HIn7p/h0VbqQCgm/0chvyp+z8C+R9x7vS38wvI + /wvI/yjkfxTyR/df8CXkD4qo+6eb/XwF+aMAKHWgK/43lX0D+X8D+VP3/y3kT93/t5A/qKbun2728x3k + /z3kjyIA6Dv9yRv+7Kfu/0eInwqAnyD/nyB/56r/KozVR9D9f+Flzxeis9JxwwWqjr/Ze1S8bkvgDFNf + 9uz/Tiy99c7IAqCtrQBoJeYAXysAGJdhXN6xOYqA5mLTGS3sUrehO3sXHvn7lnwU0NV7QFfvC3T8YSB/ + DSTuC2uXjw7dL2Z3H4tG7/ztorcRIXx09b5Ap+8Bnb4XCLw2+Ruij0miO38bfjt/g5jyp84fLO9/c5rK + nzr/5Mrf4dhIpeWGCcj/byH/D4BgmGSx58gxsfL+h50CAIXAdF0AgFmACoA5EqMAaN9SLMgLrwAswkgF + wBJaAVAFgENzsZxOB/RuaUg8CudaOMcEwo2GTejRcHXuElPksbAI3enefdLbBqTrBgK3YsrcA6Rr6ei3 + aiBw30DivoDoPXQnIN7aqFXqkGY03FK3kSDRx+7oLUDivoDYPUDy0YHIfYjexrrTzhHjZpd45b8M4qcC + AFjlvwbiJ1AAeORPt/kF8zZC/htd8tf3+EcB4Jz3N+QP5Gf769v8Qvoh+RdC/mAdCgD6XH9ZAOj7/JP8 + Mep7/Du3+aXP91fyRyGwCyO91z8fBYC+z7+UP0a6xa+8x/8ByJ9u9YsCgMRfeRDyx+ic94/JOqXm5Md2 + If4OyXm8O1kzTDKgImDVg48mrQBY2am52Hg6igB0+b7lD7aFaO0A2fsGsveADt4X6O49nGECcYOt0YDs + fQHZe4DofQPxe0AX74tT3EDc0fArfxuyILCzxaSbSVsHFAK+QKfvAcKvFcg+Fps1KAQ8oKv3BWTvAbL3 + BcTv0D42KAA8QPzExo5dxJSPl8ur/k35j4P8Zfev5E9MNuQ/FeKnAoBWALT8ZQFgyH8u5D/XkD+N+kN+ + SP7OeX+nACDxh+7zr+S/CtIPFQBK/tT900V/dI9/kj9d9LcR8pc3/FH3+N8K+W+D+KkA2A7pOxf+OR/y + s4u6fyBv9qPkL6/8pwJAyZ+6f7roT9/wxznvXyvHy74W/6cUnbxA5//zfV+IMbZEzTBJ44vjYs3wEVEK + ANcpAFkAOKcAZBGQ10IsBiR/gk4FLJOFgFMArMC4srOzEhCWugLdvY2tbs62cFYcQOK+gOA9nB4HvX1y + GgoAN73i4FQN5G1hiwZy99AzDnr4pDuhZG6Vegy6+qSLhc42qAAw6GShY2ziF72F9j5pFwujEMgNs0nT + NjZzR7/D8q+//CVVh8VApenkhDrn/6EnOTNMA0ArAavvf9j/CgBGpwBoqQoAZwXAVgCs6NRcrKKVAFsR + YALZh0G3Ha2bj4ato7cB2cfu8m0Ynb+to7fR24Ktm4+Grcu34Vf+HiBMAl29L9DVe3CLPxo2+UcA+Ubr + /G1dvhspfHTvtWF0+SEge01Ep+/GJn8bCen8a8EoCEJA+pqlNz6YhvJ3lv4bWv4Ox95Sqk580NsMkITf + cCdlhmlI9hz+SSy/8SZZBIQKgFxnBYDeCTAPY2gFIFQAtJCEVgBI/rIQQAGAYkAXACsxOkVAC2+HT9i6 + fBu2Dj8aELuvLt9GRHcPcYMt0YDYPaCr9wU6et+g63eAvOMSPbB1+NGI2uXbgLx9in6zCbr6MOi6CYjc + F5B9raDT94Xs+B02QfISSNwX6PR9gU7fAzr86KCD10DsvlBdP7HmgivEmEVV3PknTP6SXUrXiY+9X4rH + bQmZYRqa3fu/E0v693MKADCHUKcBwgVA5AqAUwC0FEswhgqADqoAwChPAyhWdUYRcFpLj9S3hGgdHQjc + CoTtC8jcF71NINxY+JY6ZOnGFHlt2KRusFkDgXuAwCOBdKMBifvCLXSP1GPQxQTyjYZN7G6kyNF1m5hd + eywgcY1V8Bqb1G2gg/dgyjwWNqkbbNRA8B5ywqw75UwxfkZ+SP5OARCW/wSX/Gk05T8d8p9hyF9/tr+W + /zwlfi1/WQAY8idI/Fr+9Ln+hJa/LAAgflkAQP70Xv91EL/+bP8NkD+N+nP9t0D+WyF+WQBA+vLKf4z0 + Xn+SPyFv9gP5yyIA4pcFAMRPBUAp5E/v9dc3/KH3/FdB6HXg+O4vk/DhQHu/EAP2HBXHgWCYVKCq8pBY + dOH5qgBQKwARBYCxAtBerwBEKQCMFQBnFaCZWI1/b3IXASa6gzc5Mw4ge19A9rExOn+/8rdhLQiiEOry + bUD2loIgpvyj4SkKooAu3w7knZSCIAadXXQidBEQA6PLt5GQzt/W5duwdvwayN5nQRACBYBmQ+fuYtJn + q1n+iZe/pPqwuEhpOzGBiuJUJNzv3QmYYRqb8m2lYm73znIFYLYqAOieAPOoAGjfCjgFABUCzoWA+loA + yF8WAs3luwGWy0IARQBGWQSgAFiFcXXn5mL9qS3FZgjboXV0IGvfQNy+QHcfmzaSTQQk7gGy9gVk7RtI + 3BcQuAfIunZyHCBsX0DivoDEo7HRBBIP09YBXbwvIPJagcx90cEkNzoQuwdI3Au6bzeQuC8g8Vhs0JDg + 3aDjD9Guo5j2l8lpJn+19J8C8ieqvxCPK3XXP6oPit/u+ULsA3SnIYZJOQrmLRdz22dHrAA4BYCDswKg + TgGoAoBWAHQBQCsAVADIVQB3AaBWAjb2QhFwFoRL2OQfDZv8bdRD/hLI3heQvS/QyfvmFA06bg1kr7EW + AhprARAFdPS+6EZA7LWh5B8BpO8LdPa1gs5/E4RfK5B9LDai65fY5G/Dd0FgAR1+dCB7S0EQkr8NsxDI + bS/mjHiTO/8kyl8xXum7flEoxC+RYNe6Ey7DpBqbX35NzFanAeQKQLuWzmkAjLIIoFMAgOQfXgFojpFW + AFAEyEKACoBm6lqAZhI6FbAK45rOzeRKwKYzWvnndButvUDmHk7zx0ail09OtdHGC2Tum54+6eGHbAdI + 3AOk7ouuPunisCEqOQ4QuS8g+1rpaKFDbNaj+5fk+aS9T9r5JFeTG5u2tbPgzifFGMj/M0P+40j8K/aF + 5D9JiV/LX2LIXxYAhvznQP5zDPnTuMCQ/yLIf7GS/1JIn6ACgMS/HKyE9EMFAMQvCwAl/88hfioA5D3+ + IX95n3+InwqAzZD/FohfFgBK/lQE7IT8dyr5y3v8Q/6yCID4ZQEA8VMBUAL5l0H6+j7/FZB/JeSdIPKV + wusXe46Kv9qSLcOkHDjwV91yi6sAaGUUAM51APIUAEZ5HQAVAigC6FoA8xRAuABoLuVPKwFrOjlsOAVF + gE3ibmxSt+ESelQg8DDOsv3GaNikbsMm9GjYpB4CMtVoiZvYhB4Nm9Rt2KQuUcv4Gkg8GiHJEzap27CJ + 3Y2Ue9vagdg9QOK+gMR9gc7dF5C4LyByjVvwEeREsqzfzY78qfsHWv6y+9fyXwXxKyLkvxbipwIAzFzn + kr+6ze98eatfl/z1B/wA+Ql/pvzpE/7Up/ut1h/yo+VPH/JD3T+I+JAf9QE/mysgf9etfgn6gB8qAGgF + IF99wp+zAuB8wE/xfoifQAEQ+pAf2f1D2lQAJI6fKivFPyiN1y1qjog+oY8aZJgAUFlxSCw8s1eoAJDX + AGCUFwJGKQBoFcBdAKwkPAUAnQpoJtaCDae2iNHhR8Emfxs2+UcjoiiIATp9L3Te3wVEbwWS9wW6eI29 + w1d0dwNxR8MmfxvWYsACuvvYqAIBsvcFhF8rKAh8gY5fk7yCwCfo+h0M+duA7Gtj5cVXh9/ux/JPtvwl + 5QdFK6Xy+KPyG/FrJNSD7gTLMKlOwYIVKABae1cAZCHgFABUCLhXAJZhlEUARmcVAAWALASoCGguVhO0 + CoDn19KFgae0FBshbF9A1r6ArGMDWYINBITtCwjcFxC4byBxh+zYQOC+gcQ9QNi+gLgjuvloQNjE+tqA + tH0BaXtpGwkk7gtIXLMuFpC4L9DV+wIS9wVE7gt0+yarzrlUjF1QzvJvQPlLDonzlM7jC7rT3+6jYoEt + uTJMENgw+mnrKQBfBQDJXxcAkL68DkAWAM4KABUAtBpA0DUBG9Hdh+htA+L2UxBYhe9lA4EO3hen2IC4 + EyL/WkBnXzsQdzT527DJ34YsCOysN+lsAnlHwyZ/N9ZiwII8rx8Lb0EQE8jeF+jqfVHLOf94CoLVp58v + xs4uCsl/rEv+hJY/jVMM+U+D/OV5fyX/mRA/FQBa/nOV+GURAPHLAkDJX573N+RP0Pl++dn+kP5KXQBA + /LIAgPzpc/1J/sR6yH+9kv9GiF8WAJB/qACA9KkAIOiz/XdA/LIAgPTpvD9B8pcFAMRPBQCd+y+F9AlZ + AED+dN4/aRwStyilxxd7vhC325IqwwSFmv3fiyWXnC/mt2sFXCsA6lQAFQBL5NjcuSeALAScFYBQEQBk + EYCRVgBChYAa13ZqLtad0lKsh8CtQNZ1BgIP0yY2kLgvIHDfQOLRgTA1ELhmXSwgcN9A4r6AxNehs68V + SNwXELkvIHIv6LpNIHFfQOKaz2MBifsCXb0vIHFfQOS+QLdvsurUM8X46TvSSP7fxpY/Ov+UkT9x6Nhz + Sun+o+aQ+B0S6FF3QmWYoFG0dJ2Y37519AIgBAoAFAPeAqCZWIHHKzE6BYDzbgCnAHCQKwGdm4l1PVpA + 2q1cKJFHlXoM0Kn7pqdPrCKPArpzX3QLsy4WXd24RF4bUvQ+QCfvi04mkHc0rKJ3ga7dF3m1oQoBSNwX + 6NZ9gW7eF2019m4+muhtrOl5hhg/bSvLv7HkDyoPH/tAad1/IHFOdSdShgkq6x95NFQAOBcD0lsB9cWA + tgKgRVwrAM47A5zx857GSoBN/jZs8o8AcgXrCHTwvkD37guI3jeQvQOEGQtbNx8Nm+ht2EQvgTRrQ3X2 + n9cGZO8LCN8Lum4TdPW+MLv7WED2vrB1+TZsXb4NQ/prYwHhm6zu1ktMnLCBl/0bUf5E+ZHjM5TW/UX1 + EXFlDZImw6QLlZVICqf3cK4DoAKgnSoAMMp3AlAhoAqApRhlEUAFgCwCnBUAWglYiXEVRvmOAIwkfxrp + eoDVnU6W/6bTAWt7tICsW/sD3btv0MH7oocNQ+QeofvA1tEbfB4LdPuRZEcHUvcFOnhfoLuPDeQdVeoW + 0MXXCjr5eFkLyUsgcV+gq/cFunpfoOt3UEKPhkv0NlZ3PUVM/GytlL8sAJT8ZQFgyF9D8pcY8pcFgCH/ + 2ZD/bCV/jZb/Ash/oSH/JZD/EiX/ZZD/MkP+sgBQ8l8N+a+F/Ncq+a+D/NdB/LIAgPhlAaA6f9n9Q/q6 + ANgO+W+H+GUBgM6fCgCiAOInCiF+WQBA/iWQPiELAMi/nMTccKxRaq89KoX4h5ovjpcDJE6GSR92fDYR + 8ldvB9QFgBR/S0sBoC4GlAUA5C8LgOaqAHBWAJwCwBnX0EpAJ306AAUAxs97tLQLvzYipA+5xsLW0duw + yT8aNvmHQMdt6fI/j4VN8vFgk78E4jSxdfQ2zE4+Fjb527B19X4wu/tYQPa+sHX5Nmxdvg3Ivi6d/6ru + 6PzHsvxTRP5EkdJ77bH7C/GYLXkyTNCppo8OvqKPWgVwCgAqBGgFYLEcmzvvCJCFAIoAtRJAKwBUCKzI + c1YCSPh0PQCNGud0gLMCQMXAGjxH49ruLcXnELlv0L27WRsNdPW+6N7GP+jW6ww6+9rJdoDAfYEO3hfo + 5KOxJio5DpC4L9DZ1wo6eV+090k7v7T1gq7eF+j6fZFTO6u69xYTx63zyh/jeLrLH4iQ/2qIn0AB4JE/ + 3eYXzN7gkj+KgfmbIX5CLv0b8t8G+dPSPyDxh+S/y2FVAcRPoACQ8qelf7CuGPKnpX8Qkn855C/Rt/pV + 8q+C/GnpH+ysgfipAAAFeyB/ULgP8gfyLX8HIH9QCsoOQsZUADQ8u5XeYwe95x+J8it34mSYdKFwwXKx + IDe8AuAUAC3DBQCKAVkAYJQFAJCrALIAcKAVALoWYBUKArkagHE1RlkEYHQKADXSNQHdWkHkbWoH3Xe9 + gMB9AVn7BtKOtWQfEroNm9CjYZO6DYh7LaRdKxB2nYHIfYHuvFbQmcdijcYmcL/YpG7DLfQIcsOgi68L + K3ueJcZPdi74Sw/5o/MPvvyJQ0rxsaPmi2Ov2pImw6QTq4ddL1cA5LsBVCFABcAiVQDIiwFVIRBaBTCK + AHlTIALi16NzWkCvBqAY0KNeEejeSqxB1x4VdOr1oruNNl4gdd9A/HWmixt03NGA2H3h6eBjs9qko0lO + dCD2OoGu3hfo6n2Brt4fbb1A9r6A+GOxSkOdfS0s732eGDttZ/gWv5D+WEP+xERD/pMN+U+F/KcZ8tcf + 8kPynwX5zzHkPw/ilwWAXPo/IhZC/FQAkPwX09K/kv9SsBzyX6HkvxLilwUA5L8G0ieoACD5f05L/0r+ + sgCA/CPv86+X/r8X22jpX8mflv6JfIifKID4ZQEgl/6PSWQBAPnT0n8j8pVSfPSoOSx+X3Pk+PdAMEw6 + U7p+Z/jtgEYBsLidWgHAaK4AyAIAY6gAUEWAewXAOR1A8leQ+HUBQNcFdGsl1qJT98MawiZwv9iEHg2b + wENAphqbvOPBJnUbSuBecmoHEiescjexSdyGTeJ+sEk9AkiWsAnchk3gfjGk7iU3DLr4urD8jAvEZzML + 00j+qvtPD/kTPyrNR4/qI8feqkZyZJhMYM3NN8a3AmApADwrALIAUKcDIlYAnMfy1sHdWsbo/CHcWNhE + 7xeb+KNhLQTCrNags68ddNzRgOx9AfnXmRTs/FfFAl29P9B5u4HsfQHx1xlX57/0vMvFmLnl3PmnrvyJ + n5Tm7UHdP5Lij+4kyTDpStGKDbIAkBcDYqS3Ay5C5y/fEqhWAmh0rgeILAT0tQB0USAVAzSukkWBfpsg + rQqokeQvx/CqwKqurcQqCH0VxOwbiLnOQNa+gbQdsuMHsvYN5OwfCM8Ewo7GShMIus5A2rUCYcdPWwcI + 2xcQdp2BsKOTGwZdvGZFHCy+8jrx2cIqj/zHL3fEz/JPGb5WqrdH1RfHXrAlSYZJZ1YPHRyzAAjJHzKn + AkBeB4DRkb59BSD0WI3OhYFqNQAjnQ6Qz3VrKVaj63dAp0wFQTxFgU308WCTv41QQRAvEHc8RYFV/D5B + d0+sjArEW5+CwCZ/v1iLAAvo6v0Bede1SLAWAj5Btx8CRcO8Gx8Uny7ZE5L/Z0bnP86Qv0bLf7Ihf1kA + GPKfZchfouQvCwBD/sRiJX+CxE8sg/yXQ/yyAID4ZQGg5L9aFQCfK/kT65X8N0D+GyF+KgA2QfyyAFDy + 3wrxUwGwA/LfAfETu5T88yF+WQBA/kWQPiELAMi/FOJNIQ4r1Xuj+JD4VyTDL9zJkWHSnYL5y8WCXOdi + wEVyRAGAQkBeC4BRrgAQVAQYrADydAA9lsWA0/mT/OnfcjWAUEWBUxw4yNUAQq0ErITMQ0DMvoCY6wUE + HR0I08IKDWTtG8i5zkDcKyDtWoGg6wwEXScgbF9A2GHaxgeEXWcgbF9A5prlfmnbXsx8+M8s/+DIX5Qe + Pr5H6d4b1UfEPbbkyDBpz+FjYtlF5/orADDKAgBjuABQdwjEGC4A1OkAVRTIAoCeI+ljlAWAHGlVoIVY + 2RlFgE3yhE3eNqwij4PO9aCTGxQM0fB05nHQIToraiPPJ+1tKJnHIkL0cZLrE5vA/QJxx8Iqek22QfuO + YuqfPksz+TtL/1Hlr8QfWPk7lCjdR4YQ4mdVR44XAsEwmciWv75jFAAkf3cBoC8GVO8KiCgAgKcAIMFH + WQHAc04B4IyalV1aixUQfq1A9l4gKTdmx14XbN18PED2dQayt3b6bmwdvV9sXb0fbPKvheXtSZwAXb0v + 0MHXGcg+OrmxyYnNss49xIR3F3HnHzz50wrAWqX8yED3f6YtKTJMplBRhYTSuZ1YSAVAbnN5LcBijFQI + yGsBqAiA6M2VAPmOAAmEr8aVGOWdAnUxoEe1AiBXAzCS/DW6AKDiYGVnFAFWwSvQqdcLdOu+QBevWR4X + 2Q4QeJ1Bt15n0MHXGXT6XkjetYAO3hfo4OtM23qQo0EBYGFZLNDxa5b0Pk+MmbhVyv9TiN8pACB/KgAM + +U8g8a90mETiV/KfAvnLAgBM//wQCgC68M+RP93ql27zS+Knca6WvywAjjgFAFgE+S8i+WNcsuOoZBmk + T8gCIB/yJ1AArC505E+sLfpGrKUCAKwr/VasJyB/eeEfoFv9ytv9ogDYCvlvoQIAbK/+QWxHAUDshPh3 + 7QZ7fxL5wCkAjkmKQPGB47IASGFmKeVHBhLgWHdCZJhMY939D6oCgC4EDBcAoZUAyD20EqAKgNBbAyVO + IUAFAP2bZK9XB/Q7A5yLBZXs1b9DKwP0XAfndMByyN4X6NTrBTr1OqNlX1ds8pdAVibo1qOxrDbQsdcJ + iL3OQPZhIM94QAdfZ9Dh1xmb/EPkioVXXi8+mV+eZvJH9x9L/kr8aSJ/elfCR0r54ag5Kv4Tye97dzJk + mEyjYNEqKf8FagVgkS4AMOpVAHMlQBYAYHk7R/jLMOqVgFAxQCMVArL7dx5L8cvnVHEQ8RwKABQCyzq1 + EkvRsccEnXq9QMdeZzq6yY4PdOt1Bt16nUFX74+cSCDzeFmiQQdfZ9DB1xl0/Q7o3uOFOn4it72Y8eCL + 4uPFu7nzD7L8QfHBYy8o7Yej6oi4wZYMGSbTqDz0k1h6+inyHQF0LYAsADDKAgCjLAAwytMAVAAApwBQ + xQAVAPIxCgCMsgDQIxUAcoToMUrh6xHQqQDnuRbO4w4t0CW3EssgajvZXtBV1wuIWWOVdm3YZO0XKWiI + sy64ZV0fDIHHDYQdpm18oAuvMxB2vHhEb2Fpp+5i8mszWf5pIH+i9KC4Q2k/HEh8C9yJkGEylfVPjpQr + API0AMZwIUCrAVQAhFcC6DSAczqgmSwEaHSKAvxbrQro1YHl1P3LURcETtFgrgLIxygAQo/pEwlRBCyB + 8GsFXXnCQWdfO9nRgdjrDAqCaCyuDXTwdQYiTxgoBOoMOvg6g67foW38QPzEQrqt76TtUv6fGPIfA/nL + i/6U/Akt/wmG/CcZ8pcFgCH/mUr+s5T4tfxDBQDkPx/ipwKA5L8Q8qeRxL8YLDXkvxzilwWAvOjva7FK + yX8N5L8G4pcFAMQvCwDIf32ZKgAgfoIu/CPxa7Yp+W8DOyD/nZD/TohfFgCQfwGkT8gCAPIvhliDQsl+ + cZHSvhO7vxT/VXnk+I9AMAxzXBQsW+fcE8AoAKT8MeoVAHkaAM9RARCJUwDQCgD9Wwpf/pseqwJAPlZf + 04+pAFCjWQDQagCNyzqgCAiJGRKsDzZR+8Um6niAnO3k1A6684QCQdcJyDkWVplrbLK2Agn7wSZwvyjR + e8jJFfMG3Sk+XlCdhvJ3rvzPRPkTJYdEjlK/E1VHxLDKw0h8DMM4HDomlpxximUFQF0MGCoEHOnTqQB3 + AeCsADiC1wVAaAWARK+otQDIcwoAWglY1rF1cjp/o5tfHBfolgmIPaGgIKgzto7eD+0IiDdR2OTvF2tB + 4JNaOv9FtbA4r5OYOvod8fGi3dz5p5n8wfFd+8X/U+p3AglvsicBMkyGs/aBh5xVgLa2UwH6mgBnFUCv + BsjrAnId8S9FISALA0hdFgY0qusCIq8ZcEYTus+ALA4g/uV4HB5bCLrYbhG6+BAQcL2AcBMORFxnIONo + LIxKTnQg4zoBEScUyNkfbb1AzAkFXb6Vsy4Sn03YlKbyz+zOXxF5E6B1QvwCye4Ld/JjmExnx4QZSNxU + AJD0AUZH/A7yOgCMUvxqXEZvD5SjAz1ejueWqa9p8ZPgnQIAz6nRQT9HBYB+rqUaw88t6YAiwCZzjU3K + 9cEj6pz4gIgTCgSdUHLR/dYFyFljFXe82GTtF5vQ/ZLTTsy+/gHx0cIaKf+Posl/+T4xVsl/PORP4icm + kvgN+esCgOQ/DeKnAoDkP8OQP41zlPxlAaDkTyxU8qeRxE8sgfR1AbAM4pcFAOS/EvJfCfFTAUDyXw3x + UwFA8pcFgJK/LACU/DdC/pshfc1WyJ/EvxVsh/x3QP47IH5ZAED++ZA+IQsAyL8IMg0kh45PUep3ouqI + 6G1LfgyT6ZRXIBG1b43E7KwA0OheAViM55xCQK0GQOZLcp3On1YA6DldCDirAc7qQMSqgBrD3T895xQD + zvNUODiEH7eEmLFtkL0vIPFYLIgFhJ9w0LUnhhwHSDxhoFuvM+jgE0pOvLSNDWTvZmHn7mL8K1PER9T1 + x5I/wfK3izUwHBuh1O9ExZFjoyqQ7BiG8bLiqiuQiFtIaCXAXA2QhQBGvRIQGlEUkPD1NQLypkF6JNkD + eqxXBZxiQYldFgP0nBY9PddSfl8kLcVSfG1RXmu7tGvDJmVfQDLR0DJOFErI8xMFBJ0wIOcwbeMDIk4o + kHjdyBVzLxkgPppe5JU/GEOY8kf3P44+2leJPyT/VU4BMGWNS/50m18wc70hfxQC9Na/OZsgfkLLX7Fw + qyP+kPy3Q/47IX+wjNDyBysLIH9a+gdS/rT0Dz4vgfzBujIlfxQC+j7/VABsrlTyx7i1CvJHAUBFwHYS + fw3YA/kDZ+kf8gcFoHA/BEoFQIApPCj6KvU7gSS32J30GIZx2Pj0c5B/c1UANFcFQHOjAHAkH0JK31kB + WNKumVwlkI/V1/R1ARL1tRCy83dGpwCgxygG0O07Iz3nFAdLVQFAX1uIImA+pF4vIPeEgw49obQzgXjr + i03sdSWiIEgA6ObjA0K3ME8D4ZvM79BFTH7ybfHBghqWf4bIn0AB8Bulfuf8P5Lc1+6kxzCMw/bJs8WC + HLUCgFGuAhgrADSS3OU1AbIYaCGLAr0C4BQAanVAitv5mpS4ewR6dYCuKXBWBwjIPvR14zlVACyhIqA9 + igCbhGMwLxYQbiQ5yQEiTiiQccKAiGMDmcaDKeRE4JK6P3LFvIuuFh9N2RmSv0TJP1QAQP5jIP7QeX9D + /jRq+dM4WclfFgCG/Gco+c+E/En8xGyIXxYAtPQP6esCYAHkv0DJfxHkv0jJP1QAQPq6ACD5r6Clf0Di + X6UKgLUQP/E55L8O8tcX/8kCAPLfBOlvUvLfAvmT+OXyP+S/HfLfDvHLAkAu/R+TyAIA8qel/6CDAqBU + qd+Jyi9EZ1vSYxjGoTi/BgWAswJAo3MaQK0EYCRI+Pp6AHltAEa9IuA8DhcH+t0C8jMFlPjDxQGhv4bH + BD2XC8nr50Kjek6OzuOF7dvYZa7xSD0BoBtPBnNNck1y6gfEnVDQfSeU7Hhp6xvq+qeMeke8D/Gnt/xB + LPkr8WeS/B2OfajU70TFIXGLLekxDBNmyWmnqAJArQAonALAEb4WP430vJS/UQDor+nrAuSnCyrxh0aJ + +n5ABYDz9XABEB5bOj9Djs5jGuejCJgL2XuArOsGJBMP6MITik3iicQm9VqBUOMB3XpCscjdZI6LuTm5 + Yo4815+fAfLnzj8aBfvFDUr9TlQeOvaGLeExDBNm9S23iPmqADAvBpTvClAFAF0YGFEA0POyAHCETaMs + AEj29G96rL4WGkn0cqSvt1QFAD2nuvxQIeD8m4RPjxfntpLfv4TGdq0EnSO3yhnMiQWE2yBAvPEDmcUD + xJswIN2kYxF3IphHn9v/3BjxwcIa7vwzWP5EwV7RRKnfibJDx1eXI8ExDBOdDc+9KAuA+aoACBM+FeBc + F+AUBDQ6RQH9O1wUyCKBigJ6nh4bX6PRQT2n/02dPeTufCyx82/na85zi2iUqMcoChahCJjbvo2YjQ6+ + 7uQ4QNhJB4JPOujc68usWOT4pW3dgdD9MjunnZgx8Hbxwewy8b4h/w8N+X9syP9TQ/6fGfLXkPQnGvKf + bMh/KsRPBQDJf7ohf3rrn5a/fMufkj9B8p8P8VMBQPJfCPkvVvKXBYCSP7FCyZ8g8WvWKPmvhfg/V52/ + fNsfFQCQ/0ZIfyPkT0XAZsiflv7l8j/kvw3y3wbxywIA8t8J6ROyAID8C0iY6cUOpX0nhBB/g+T2pTvZ + MQwTydbPJot5kD8VABKSvywGmsuRpG+eEtArA1QAyOdJznqURYH6txsInFYKnO+nzt55LpLwcwsh+4U0 + ovMPjZA/jQuoCGiXLWZBsEkHgk0eEBqBTrzBsUk40VjkXV/m9DpHfPLeUvHe/GqWP8tfUrj/2J+U+p0o + PiR+Z0t26cyOyi/EpqK9omjfd9avNzY7q47K7Svc+631643NruovU3r7kkX+ys2O+LOV+ENA8FQAqIsD + aZQixyhXABRS6qookF1/xGPna/oUQXhVgB7r5xzxy3/L7w8/R4WCLAjoeYhf4xQFrWsvAqzSbSBsnXQi + sXbgdQFijQeLlBNOGy+zO3YTE558S7wL8WeO/J1lf5Z/bHYdEL2V+p2oPCxOLT+EBJemlOz7QcxH4n75 + 9XfFbXfcJQYOGiSuvvpqyVVXXSUGDxkq7n/oMfH+mMni8x2V1p+RTEr2/ygWrtoqXvnr++L2O+8WAwdG + bt+gwUPEvQ88It79ZKJYu73C+jOSSemBn8SiNdvFq29+KO78w7327bv/YfH2h+PE6i2l1p+RLpRWHnVW + AFAA6FUAsxAIvT1Qv0tAFQLhdwuor8vH+mvO8xFfUyJ3/q0ey+dUp6+fo38bzy0g2ct/o/N3MR9FwOzc + NmImZO8byLlRgLQTS9vagbBjMSMRQNjJZGZunpg+6E7x3qzSsPwhfY/8wceLXfIH9Ln+HvmvgPxJ/Kb8 + 6bw/mLrWkP865z7/JP0I+W90CoC5mw35b4H86bw/oPP9IfnvcFi6C+InSP75ED8VAGBVoSH/YoifKIX8 + SfwEigD5IT8oADZWQP4Qv5R/JcRPBQCd+yfxE7shf+Cc94f8wS6Qvw+ipAIgPdm3SIi/Vep3ovywGGRL + dkGn7OAxMX3BKnHLbXeIa665JoQpL+LKK6+UXHHFFZKHHn1SrNpcYv2ZiURvHxUlcW3fY0+KlZuKrT8z + 0SxYtUXcdfd9cW3f3fc9JAsG289LBxb26inmGQWAWQhQASAvDlQFgF4ZoAJAfl1+TY2qKIh4LvQ1Errz + eIF+HJK8M4a/5jxHj+eT7Nsq4bdtjcet5aiZB2a3zRYzciGMZAKhNgo26SYbi4jt5CaWNpHMPruP+Ojj + teLdedUx5U+jlr8sAJT8ZQGg5D/OkP8EQ/6TDPlPUfInpiv5z1Dil0UApD9byX8O5B++6C8sfxI/sQjy + X6zkvwTilwUA5L8c8l+u5L8S8l+p5L8a4qcCYA3krwsAffGf0/1/LzZQ9y8LgB9k9y9XACB+WQBA/LIA + kN3/MYksACB/6v7Tln3HXlHaD0fpwWPDy5DY0on1+bshogcjxOVHXn379g3x59ffFcXozm0/v75sLt4v + 7nvw0Xpt359e/qso3veD9efXly2lB1EIPVGv7Xv6+VdE4d7vrD8/yCy9/DJZANBKQMT1AECuBJCYIX5n + VcApAPQ1AlLa6nt0AeAUDO6vacET6rGSfGhUX3PED+RI4qfHNDrMBfPk2FrMwTgH44zcbDENnXaDgS68 + wckh2qYGKACSxaweZ4jPXpgk3pkL8Wec/CF+lr9vCvaJU5T2w1F2+NibtkQXVBZ/vlNcf8ONdZbX5Zdf + LunTp49cet9efsT6e+rK0vX54oYbb07I9lG3vbXskPX31JVVW0rFTbfclpDtu/2ue8Smon3W3xNUVlw/ + TMylAkAXAWrU1wU4hYAj/Pm6EIDs5fMkbT2qosAKiV2O9DMM2eOxFLx6jkZH+I70SfTzchzxU7dPkPj1 + SPIn5ua2QREAQaJb94BOOmWwybQBmaqBaBuX3DDo9omZnXuKscPfFm/PqWb5s/z9UEYX/CvthwNJbZI7 + yQWVxWt3iAEDByZEXsRll10mbrvzblGw51vr74uX5RsL5Tn0RG7fTbfcLvJrvrb+vnhZvbVMDBkyNGHb + RwxDsbOj8qj19wWR1Si6nAKgpSoAnHE+RpK2lDK+LlcFjKLAKQxI3s73OLKnfxuP5f9zRK+/Rj9fP54P + uc9To/ya/LfzHI1zQ/92Ov65OY74aZxjMLttGxQCbcR0dMpTIdqYmCJMRazCTASGdP2gxJxsZuR1FZNu + HynenFXB8mf5+2bXfvGoUn5kIKktcye5ILKxcG/COn8tV+LSSy8Vj498RpQePGb9vX6hTv3Gm25J+PYR + DzzyhCg58JP19/qFJH3r7XcmbPvMbbzn/oeTdrqioVn31J9qXQGYn+10/DQ6z6kVAP11+Vh/zXk+4mtq + BYDeZkhyl92+6vznqdH5GmQvu/3IAoBG2emT8KnrJ+kbzIL8Z6mRioApEH2DAGGnLJB+KjOjXScx5boH + xVszS8Wbs6uk/N825E9o+RMkfQ3JP3TFP6SvCwCSP0Hylyj5S5T8QwUA5D/FkD99vC/JX0PynwX5ywv/ + IP85ED8VACT/eRC/LAAgfoLkvwjilwUAxC8LACX/ZRC/LAAg/xUQvywAIH5ZAED+ayB+WQBA/LIAUPJf + D/E7BcAPYhPET2yG+GUBAPETdNU/iX+7LgAg/11SjmnPT9sPid8p5UcGktp2d5ILGiTnBx5+PGHy0uIi + +Ws+mTTb+rv98ugToxK+feY2vjdmsvX3+mXEU39M2PbZ9uFf3//M+nuDxsbX35EFwFx05nMhaXMlwBE4 + RnydHlNxsMB4HP6a8b3mc6GvhXF+Lv0OR/LekYRP2+KIX+O3AJiV00bQ+XKrFFMZiySnoBO3ktMeBUhe + w5GTOKa17yomk/inlkjxvzkL8p8N+aMAeFcXAOB9KgAUHy5EAaCgT/f7ePFu8QmQV/wD+oQ/+XY/QJ/p + L0EhQHf6k6za73yuP5gMnO7/gJgK6Ir/qZ8fkG/309Db/uQKAEYqAGZvpiLgsJhnrgJsQxEAFqq3/NHV + /3Tlv7z6X36+v1MEyFUAKgLU2/5CKwAlKAJK6K1/38gCwCkCnLv9rav4TqwHVAjQCoBcBdArANUoAgCt + AtBV/3IVAOzY46wAZAT7jk9XuvcGklq1O8kFjekLVydMXm5xEZdcconoP3BQnZfa5y7fmPDtM7eRtu+a + fv3rvNRO100kavts+5C278orr0r49QqNwaZ3PxVzIOo5qgDQhQCNshAgMePrGpI6PS9XDfTXpLz1GH4u + 9D0KKXb5c9Vjl+znSEjwzkhyDz2G+GdD7rP0CGZq2mbLcQa9IyAHYJyMImBS29zo5AQMiD8CdNAT23cO + DFM7nyIm3fCIeHNasSP+OSDezn8ROn/q/uXy/17Jp2DMsn2Ssej4Jctp+f+Ag1z6PyiZBCavORR6zz99 + vK9cAZDv93eYia5/5gbd/R+B/NH9g3mbv4D80f3T8v+2oxItf30KQJ4GAEt3qlUAeRogchWATgPQCoCz + CuC891++/x8FAC3/f04FAFhPpwAUG/UKAMRP0CoAiV+uAlABAPnr0wCZQMERcYbSvTdKDx0/CERQKUH3 + T++fT4S83OLS8iIuvvhi8dcPxlq3oTbc70io7/a55aq37y9vfWT9/bXx4CPDE7J9tn1obt/zf3nL+vuD + xKaPJog5bVQBAGHLAkCNIbnTqEhoAZCtCgAa8fwcjBI8NxvjbMhfj7LDzwZqnIlxhh5J/hinY5yeDVAE + TMM4CUXARHTXSQfdekMzPrejGNehWwy6x0decpjU/Qwx7pYR4nV0/K/NrBRvzKwSb6Drp/HNWdUoApzu + n4oApxCoCfH+gt0hPlzoFAH6Pf+hQmApCgE6BYCOX2IWAkAXAhPAxFVUCDgrAbQKMHnNgdA1AKFCgK4F + wDgDRcAMKgaoENh4RMyiYgDMQQFAzEMBMG8rCgGwYNuXkoXbUQBs/0os2vGVWAyW7PwahcDXKARQBOR/ + I1mOAoCQxUDolIBTCKxGEeCcEnBOB8hTAnQ6gAqByh8kdEpgc9WPKAhQDIAt1T+hIMggdv+4VQjxM6V7 + b6Cr+dKW6ILCso2FCZGXW1xueRE33HybdRtisXp7RUK3L5pcicFDr7NuQyw2Fu0T/fr1q/f22fahe/v6 + 9R8oCzbbdgSFzeOmidlUALQhAYfHuRhJ5LIgwNdlUYDReY4KBvU1zxh+HF5ZcJ6nx7Pl1/EYz5HsZyvZ + y6+1cYQ/C49nyRHgOeexEr+C5D+jDY0k/Wwp/mlyJPlni6ltAMZJkOUEdMwpSZt6kNNejEVXPbZTCtLx + FDGx1/lizAMvi9emlYlXZ1RA/hUQPwqA2QDjX9UqwNtzq8Rb8zACWgV4R50CeM9YBXgf8v9ArwRA+h/p + AkDJ/1ND/p9p+avrAOhCQOc0AF0HgBFMgvgnrdkvJn+OQkAxdf1BeR3ANDoNQNcBbHSglQB5PYA8FaBW + BLY6qwFyRUCtBsyXKwEoAnY4LN6JQmAXCgF5KgBFAK0EQPoOX4vlED9B1wVQAbCyBKM8JeAUAbIQKFcr + AigAZCFA1wVUoRBQbKxGIVCTWWzZ/dNgpXp7IKl9705yQYLOLSdKrlpcNnlddNFFkrU7qqzbEY13P52U + sO2LJVe9fSs2l1i3IxofT5hZ7+2z7cNo27dw7Q7rdgSFLZPnpk4BQP8m2eM5KX3q/PVodP6yAFArAKHO + H+M0tQIwLYfk30ZMpRHQSsAEdOoTZDGQPozt2E181u00/3T1S+86MbZbbzHx3CvEB6M/Fn+ZVi5eg/gj + 5B+iShYAb9FpAEAjif9tXQDMrxHvEVL+NZC/JrwK8NESFABAFgAKKgL0hYBmETAO8h+/CsUAoBWAiVQE + rKW7ADroiwGnUgFAFwSud5AXBFIhoC4KnKmKAHlRINCnBORFgaoIkKcGUAgs0IUAFQHylACtBKjTAgW0 + IhA+LRAqBIqcUwPy9IAuAsq+c24NLE8NoBBQrK9wVgQyiuofKtYJ8QulensgqR1zJ7kgoS/+q69ctbhi + yevCCy8UH46fYd2OaDz6xOgGkz9t39sfT7BuRzRGPP2nBpM/bd+rb39s3Y6gsHXGIhQAkLEUf3h0CgBH + 1k4B4IzOc0rsEZgFgEPoZ0Hi9POk8NHR07/1cr+UPp6jx063T6J3Rtnt4znd9c+E1KX05QjZt1HCl12/ + Hp3Of0obQGN2jhxJmOPRdacE6OATwbjs9mJMjzPFp93PalTG9jhHTLjiRvH2awvFK9MqxF+mQvrTK8Wr + 4LUZEL5c+lfY5K+W/523AEL8hCwAdjvdv2QP5I/un1i8V3wMPlmyT3yqUdcByFWA5c4qAL0LYJw8BeCs + BMi3AlIRQCsA6lSAvh7AKQLo3QAOM9Yfdk4DYJy54Qge02mAL8RsxRy6JkBdF0CnAWQBoE4HzKcCANCp + gEXbqQD42jkdgEJArgbIUwJUADgrAnRKYGXht2IlCgBiVfF3YjVYU+LgnBL4HoXA93JcV/6DLAAyjQ1V + x25Smo8eSGo/uJNckKCb1tRXrlpctcmLeO6lN6zbEY077rqn3tvnV67EqGf/bN2OaNz7wMN13j7bPqxt + +x4f+ax1O4LClinzZAEggaz1Y5K3I2167AifRue5Fs73GJIPrx6En9M/U8qeHpPggVzqV0jpR6CkT8v7 + rsczSPgYpfjBNIVc7g+NSv6tnXFymxyQLSZhnNC6rRhH4kwXWueKMZ16iU9OOa9RGHfGZeLTW0aJVz/b + DvGXO0wth/hRBADq/l+H9DV03v+vKADenE2nACrlKE8BABr18r9zDwC1AqCgz/13TgGg+wf6bYAScxVA + FgDOvQBCRQCgiwFpBYDeDugUAnQaQK0CrD0QKgKI0CqAKgSmUxFA1wFodCGgCoC56pQAvTUw4i2CtBqw + gwqBo5LFu8LvEpCrAfkO+l4BckWgSF8XoFYC1EWCejSvD8gsvi17Y10t3T9FkK8BoPPJ/fr3bzD5X3DB + BWL4qOes2xIN+rCchpI/bd+Dj42wbkc0ht1wU4PJn7bv7vsfsW5HUNgyYSakG5a1LgCk4AkpdKcAME8V + yK9HSN75WuhnmKPs8tWyPoQul/kVMwkSvxqd8/utVKdP0nceT5dQx++M1PFL6dMou/42quOH9AmSP8ZJ + 2TkgW0zEOBFFwHhaOkcX7gFCDSKf5eSJj0+7QHzU+8IG4ePeF4lxlw4R7w9/R7w0tUy8DGi5n+RPI4lf + y58u+gvJX573D0Pyf2uuw9vgHXkNAIqA+RgX0DUADlr+sgCA+GUBoJb/afxkKd0LwBnp0//GLHf4bAVd + D0BFwD4xDuIft2qfcw0AFQFqFUCuBED+kyD/yUr+dBpAo08FTN8YviBw5ibngsBZ8noAFAEQf0QhQAWA + OhUwH9JfoFi40ykCFmGkAmBxPgoBIIuAAgd6q6B8u6A6JbCymK4L+FasBDTK0wJlmcnq0q+HKcXHjpKD + xw8CyDR4FOz5Xi5f11WuWlx+5UU8PHy0dVtsFB9wCpS6bl+8ciXue+hx67ZEY8jQa+PePts+9Lt9d9x9 + v3U7gsKmTyeLWa0hZxI0CVuD55yuXRUA8jk14t/O8+p7jefMn6F/ptPZO6OUvRrdSNnLTt8ZnW6/lRoJ + 6vhbq64/jOz4MUrpy24ftHZGkv5EjBNoBUCCAgB8RvJsSNCtJ4tPupwmPjzj0qTy6blXiE+vf1S8+u5q + 8dKUMil/gsT/sur8/zLd4dUZYKZz7p8IFwAVId6E9AmnAKDTAM6FgO/QWwEhfl0EvL/QQV8HoFcAaPxY + iZ/GTyF/TagIAGNXoghYuVcWABp9MeDENep0gCwCDsgiwF0ITNuAIgDQhYFmIaCLAPnuACoGtjjM3eas + AoQuDsS/ZSFAKwKqAFi4CyOQKwIKXQTQBYLORYJOIaCvD3CKgcwEhc92621/bYGkVuNOckFi6LXXNZj8 + zz//fDHimRet2xGNG266pcHkT9v32IhnrNsRjdvu+EODyZ+27366a6FlO4LChvfHKjkDdOv6MQk8UvB4 + HkVB6LEcw2J3nnfkrp8Ljw6O5MPL+uGl/bD0w+J3RB8WPxFe6tfSd5b5DfFD8sTE1k7HT8LX4h8voeVz + KgDaiTHpQnae+OCMy8T7Z1+RUD465wrxyVW3irdHfCxenFQq/jwZ0ieoAAAR8qdz/4CW/1+d4Zz7J15X + b/v7KxUACnkPAHX+n+QvIfmr5X99CsB8FwChLwCkkVYANPqtgPoUgDwNQKzYL1cBQncGpGsB0P07pwLU + 6QAqAORpAMhfMeVzukvgITF1/WExTZ0C0NB1AXQ6gFYC5GkBXQgAenugvC5gK71FUBUCejUAI90vQK4G + UCFApwbUvQOW5H8lCb1bgE4HqHcMyLcMUgGQyZT+eI7Se+2BpLbDneSCBH3gTLxy1eKKV17Ea+9+at2O + aNBtcOPdvrrKlXjxtfes2xGNhx8b4Xv7bPsw3u179sXXrdsRFNa98paYCbHPhKxNtOwdibdwxta6y2/h + fA8Ifb/6Hv1vYgZ+BiGFT48xTm8N0RPqsezwaQTTJCR+Z5wK+U/Fc1PxeAoeT2lNwnfGyWCSYiLEP5FG + dP3EBDA+RI4Yh3EcxrESyB/jZxg/pe45TfiwUy/x7rlX15v3zrtafNLnOvHB3X8WL326TbwA8ZP8X5zs + FAB/VvJ/GdLX0IV/8uI/vfQfQi//07sA0PkTc1AEgDeBLACoEJAFQLXs/uUKgCwAFAtrJPodADTS2wA1 + sghQKwH6OgBZCCyntwaqFQB9KiCiCHBuD6yLAHchMGUdigAwVYJCAMgiAAUArQTQKE8J6BUBWgWg1QAU + Ac69Ao6ETgnI0wIoAmQxQIWAKgJkIaCKAPluAaALgSURxUDmsrL4u+h3/bMFktoyd5ILEqP/+FKDyf+8 + 884Ts5ZusG5HNOhjextK/rR9k+ettG5HNF5+4/0Gkz9t39hpC63bERTWjP6TjwJAYTwnv4fELh+Hu32n + u3eem4GRRO88p6QPgetuX3f6DpA+RhOn23dG3e2bXf8kPHaW+U2cpX4S/3ga0e2Pw0hdPy39y/PmcgWA + xlzxKfgEXXQ68N6Zl4l3LxxQJz687FrxwS0jxCtvLRMvTCyB+B2k+KcQYfm/Mg0FAHiFTgFMRwEQWvp3 + CoDQ+X90+1r+sgAw5a+W/+UpAHXuX57/pwJAnwIIyT9MxCkAJX9ZACzbK4k4BbAizDgUAhJ5GgAFgD4N + oAsAjOapADoNIFFFgLwWgOSv0DcKImZtVvcKoCIAj+Wtg7c6tw2ei3HeNhQBdGqATgeo1QBZCNDpALo2 + QBUBi3Y5qwGL9YoA5J/JLCv6+puVld9lKbX7i+JDxyfZEl1QmDx3hW+5anHVVV59Lu8rCvf+YN2OaMxa + st739tVXrhdffInYtftb63ZEY/7qbbVun20f1mX7LsTXt1UctW5HUFjxwGNOAaCLAGM0xS+lr8fQY4hd + fr+SPrp1KXz1nLMC4DxHo9PtowCQjyF92e0DGvGcM+rOn7p+yJ5GdPfOYxI/df+QPwh1/SR+jNT5TyDx + A+r4HVAAYHQ6fyJXjME4Ro4OH0vaBZ6P2nUTb184WLx9kT/ev+x68cGNT4pXX54n/jihWPwJvDAB4qcC + QBYBTvf/Z7n8XypeItS5/5epEKDuX64AOBf/6av/XyNQBLwuz/87mIUAXQAokYWA8S4AQl0MqE8FhE4D + EGoFIHQ/AFUM6IsCw6cD9ohPqQhQBQFdCyBBISBXA1QxQCsBshiQpwRirAaoQiBUDKiCQBcF5l0DJaGC + QN08SF8fYFwoSMWALAhUMeCcGgjfSGjRTmdFIJNZVvj140rr/qP44LG3ipHYgsqO6q/FNdf0q1WuWlx1 + lRfx2MhnrdsQi/y934sBAwfVun31lStx/yNPWrchFoX7fhSDh14bdfts+7Cu23fXvQ9ZtyFILL3pdilq + kjZ17I68ndGUvfs5vbQvJU/Sl1/Xsneem45RLvnLx04BQIKXy/1K/Fr2VADQGF7uby1lrwuAkPgxOvIP + FwATUACEl/3D8tdL/jSS/LX4P8VIy/8aWkL/uFWu+IgkGnDePfV88dal10Xlvb43ifdvHin+8peF4o/j + SfolDlL6pVL6Gvey/0uQPfHyFEf6mgj507l/eeW/IX/IXhNd/s5NgCSQ/buA3gaoMeX/waI9Qt8RMJr8 + wxcEOm8L1O8K+IxOCZD86XQAyZ9OCUD8xMQ1B0NMgvgJ58LAQ2IyFQB0XQAVAUr+02g1gE4LqJUAibph + ECGvDYD4CX0LYXmdAMTvrAgclTgFwJdiPpA3EKK7CGY4S/K/3r5IiL9VWvcfKACesCW6IPHn199LuvyJ + JesLrb+/Nl57d0zS5X/uueeim99u/f218fbHE5Muf9q+GUvWW39/kFhw+RVcAKgCQHbRQadNnnj7woHi + zctvlLwN3h9wt3jn7pfEi2+sEM9B+iR+Lf8/qgLgeRQAmvB5/zKJvPiPOn9VCITP/ROO+F+hIkCe91dA + /M4dAMOE3gYoTwO4LgRE1+/gFAFUAGhC9wNYGC4E5D0BVCFA6CIg+jsD9okxVACo+wNo5FsEjSLAWQVw + PjwoohDQqFMDzrUBVAzoCwUjTxHIlQBdCNCFggq6RoAIFQNbnUJgri4G6HMF1I2EMpWFO776YdGOb7oo + pccXxQfFEFuiCxLbKr8UAwcNTpr8SV7DR//J+rv9sLPmGzF4yLVJlf9Dj4+y/m4/0CrFtdffkFT53/3A + o9bfHTRm9+jOBUA6FQBgTKdTf3p/2KPizUffFX/6YLN4blyRAuJX0HK/Jtayv1z61ysAHvnT1f/O6Fz9 + T/KnWwA7vA7pS1AIhN4FYKwCvEWoiwAj7gaolv8JeUMg87bAIXQRoC8KDN8cyFkNoIsCHUL3B8BINwgK + 3SiIVgNQFOg7BRLyVIC6QFBfH+B8doC6PgBQASCRRQDdOCh8zwBC3kJYETotAEJFgLxWgFYFnNMCoUKA + 3j2gCoFMZvHOr0YrnccfhftFL1uiCxpjps6PKq76yuvKq64R64v2W3+vXybMWhoSrN6+RMn18iuuFGt3 + 7bb+Xr9MW7gmZgFVn+27rM/lYuW2CuvvDRKF1V+HhM0FgC4AgncqYEyb9scn5+QdmJXbceLstnmnUR58 + d2718mfHFolnIX5CFwF/BCR9fc7f7P4jigAlf3nxH60AALrpj0af+5dFgL4IUF4I6PD6TBQB4HU8jlgF + MIsAdUGgPh3grAQ4KwA0RhQCESsBxi2C1YpA6HoA45oAKgIky4xCQCFPB1AxgDH0LgG1GkAjFQF6RUBj + XijorAo4BcFkFABT1H0D9CkCQt47QKFPEYQKAn2KQEG3FtarApnMvK1frB8+3Od7/m1RelicaEt2QeT5 + V97yiKu+8roAX5+zYov198XLy29+GNq+RMn1fDw/a9lG6++LF/q440TLn8bJ81ZZf1/Q2PF5fkjYXAAE + pwD4tHW74xMh/Bm5HRbOa9vhrjk5Of+k0l8o6Lapr0wr+1KKf3xxaOk/nmV/88p/3fnL9/0b0PL/X9D5 + a/E78neW/+X5f/lOgPA1AGH5h08BhK4FMOT/Drp++lAguh5Ay99ZBXDkLwuARXuc0wHqNIC8LgDiD10X + QNcEQPbyHgEYQ6cDIHt5bYC8T4ADfXBQ6BMEIf9xkL0+LRA+NaCQpwWU/OU1AuEVgSkQP2GuCIRODWw8 + giIAbFL3ESDkaoBzN8GMZ8sXX8wv+K6JOoTrFnTHICS3r9zJLojQBW1PPPWnkLjqK6+LLrpYjEfnbvtd + daHowDHx1J9eSZhcqTj5ZMo86++qC7R9f3z5rwktTj4YN8P6u4LIxvGzQsLmAiB1C4BP27Q7hg5/z6x2 + HWbMa9/++kW9ev29Sncx4+NlNXno6I/R0j/xJ10EqELgeQ1d/KeQRYBc/ldFAIg4BUAXAIZOAzjv/38V + hYDs/gGd/5enAlAY6IsAZSGg7waoCRUD9NkAVAA4pwD0KE8JyIIARQCQHxKkTgU4KwEoAjA6HxTkIK8J + kB8WpKAiAOMnS1AEKGQRIAsC54ZB+rMDNBHXBxBGUaBPDejVANs7BkLvGlDoawXoOgFNxLUCG5wbCjFH + ji/a9UU/dejWLwoPHl9ThASXDhRCYm9+NEFKrD7yuuqa/mLB2p3W31FfPpo4W/S5/PJ6bR8t+89avsn6 + 8+tLQrav7xVi+pL11p8fVHYs3/z+4k45H8/Nyy6cldvmmxnZjuS5APBKuKH4BKC7PzojN2/zrNwOb8zN + yztLnHDCz1Rqizs+XLj3D38cXwjxF4Uwz/8/P7EY4idoFaAE8nfe++++DoDuBUBv/QufAgDT6HMAwrw6 + HSOgMXQtAJ0GULxBmKcD6JbABJ0CcJ0KcFYEHJy3BprXBTjo2wQ7qGsDQvcLqBEfYTRPDch7BpinBkBo + VQDQWwX1LYTDbxt0biak7yEwXrOabinsQB8v7NxWeH9oZUCOnzuECoLQaQKw/qBz4SAjmbP1yF/UIVv/ + KDp47E1bwgsyc1duFbffdW/c8qKuevTzfxEbSw9Zf26iWPj5LnHnPQ/EvX30+MlnXhTriw9Yf26iWLyh + UNzzwKNxbx/x+Kg/is8L9lp/bpApPCAuVlNGBjrLv53VKbfv3I7ZY+fkZhfPbtvqa/khPVL2XAAkGjp3 + P6lt+y+mtc3bMiuvw1vzc3Mv2d6379+plyNhgU55RvicvyN9h/A5//ApgDD6FABhyl+fBiDpv6Kk/xfI + ntDXAWj561MBzukAAOEToRUAJX4t/xD6VIAGwnfuEkinBsI3CSLkuwMIKf/d4gPI3jk14KCvC5ArAlQE + 6AIA0pdvHaQiAN2/hlYC5DsGCPW2wfApAnWtAL2FkID8x0P8EyTOigCNoWsFIP7QaQKIP3y9QPhagUxn + 1uYvVgkh6lzkeqLogLi96ACSXJpRuP+YmDhnhXjg0RGiT5/LY8qr34BB4qnnXxUrt1Vaf1aymDJ/tfyA + ocsv7xtz+2hFYtRzL4vlm8usPydZTF+0Tjzy5NOyo4+1fXSh5Ihn/ozCocj6c9KBwr2iqZoyMePznm07 + Le2c+9z8Dtkr5rbPrp7TrvW3M9q0Ps4FgD/o547Laf/NtJy8olnt8mbPa99h5KK8zj3q09nHG3+dVVko + l/4V4eV/VQQAvfzvnAIIY97/X54G0CsAishVAON0gDwl4PD6DPN0gIMuApxTAQpZDKAACF0f4JwSkKcF + VDGgVwKc1YDwqYHQWwU9pwYU+tSAcXrAWRFQhQCdGtAFgSwK9IoAFQV6VcC4aFCvDADn9sIO+sOGzFMF + dJpAjnKFIHy6INOZtv5Q+bItR/5dHaaJicKDoqst4aUTO2q+FVMXrhV//XC8eOHVd8XTL7wmXnz9ffHB + +Jli8fpCWSzY/l9DsXP3d1K2dPqC7udP2/cCxvfHzRAL1u5q9O3bted7MXPpRvHWRxND20fje2Oni/mr + dzT69iWd/cf316fqJnktzMvpvCAv+5GFHXImz8/L3javXZv9s9q2/n5Wm1bHM60A+KxNO+rmv5qam1c+ + Mzdv+ey8vDfn5OXdPK1dp7YNKfpoMXxR6d+jGz8QefFf5E1/wvJX5/8N6Uv0uX+5CuCcAgjdClheEBhe + AbDdE0AWALPULYIh+/DNgZzrACIuDIwif/1ZAeHVAEf+EiV/27sEQhcJKvmHioAle+XFgvKCQYPQqQFa + DZA4Fw/KVQFdBMiVASoAzGsFFOpaAX3xoF4dmGTcWyDTmbLu0JElBV+2VIdo4mK7EH+HJPeNJ+kxDKOZ + oqZLUmJtx9b/O79j+yvn5rV9en6HNuPntc9eNad9dtGc3DYH5ua2+WZW2zY/0e2AU70AoHPy6N5/nNg2 + 7+iU3PbVM9q13zSzXd7cWXl5b81u3+GhOe07Xri0Xbv/Un92Sse0lZW/hqi/1Rf+hS7+U0VAqBBQ6CLA + LARCpwGo+9dFANBvBXS/HfD/b+/MY+O47jsuu3bjpo0Lp0gbFL2MNgjiACRFsUJbp0UaQEbRBkXQNij8 + l3skLtI/EjcBWqAuYANtAMe6T4sUJd7iIfFccnntckkul5d4SSIlihTvvQ+S4i0e+/rezJvZN7NDHRaP + 5e73A3ww+tPmvJnfd3+/NzNqCKBGRgHyhkDx6QBmBg0BTDEMSIGABgB5b4BBIJA6AnIQ0IQBIQioYUAK + BPJGQc1mQSrrBMiBgKoEARoAlK6AEgjkroASCiKBQA4FfAOhJhAEyQ32SKFuE2GiW9YdXKsbWJQeWd0V + RgJh+yi90UEIox0Jkv/kl8q+woKC9Wjqd2xHU96zpCX9t+VIyhlrWnJeU1pKTUNqsoN6pz41aaw2JdlZ + dzjZW5eS5DWnJIfMh5Pna6jVyUmLpqSk1aqk5BVTMj0mJ69WJqesVCYnr1QmJS+aUlLmmJWHU4LVKSlu + 0+HDLupUTWrKsDkt9Zb5SKq1LvXwzca0tPS61NSfNxz5459Yjx75fkNa2tuOP0v6Tf6fGTcU2X3JtHiv + KV0AZfe/+ASApgtAVUYAUZsAueIIQNMJ4MqjAG0I0AcBoycDDLsCVDUEPEMQkDoCilFhQFYdEVDFQKCo + 2TQohgEq2zwoHVkYeIZAAKVQtGEeWPxHviR3h9Hg1idGNz4IYZg8nCVv80sFJBgFLe6/oMV8XZn9K/N/ + qQOgBgBFJQCwNwLKKiHgiUGAFv1n6QZIQYA/IhgdCFhHQN4TYBQE5K6ALAsAyqbBqBGBEAjkUGDQGaBG + 9grIypsHI24bCpRA0BY5aroEumCQyNJAtFk7sPg+X4q7x0iIHDO68UEIwwtsTMYvFZCA5Dt875yrmtpQ + ir5a/PmvflWh/R89ApCfBlDlRV9b/OX3Amj3BLCPBfGPBtFCL382WBcAePHP4IU/KgDQX/+KrPArshcI + iUohgBb9yMeFPCSbFnumEgKkIEALvyT99S+PCVgI4PsGaMEXVR4nlIOAMC7gik8UiEEg4XX4t6r75z7g + S3B3GR0lX6A3ukXdjQ/ChHckGC7jlwlIYPKafcfOV7BOAB8BaMYAtPgzeSdA+hQw6wRwpXEAV+wCKJ8I + vshk4wCq9J0AQfaSIOnIA4H8hIAcCphSR4DJgoCiFAhoCNDJwoASDNhYQNw4KMlfJKS8TEjpCoiqnQEW + BthR+TcLBopKd8BoDwELA/QohwKfqvTyISUgJLiFrb7Nmt7Qf/CltzfQm51Jf/ODMNF9GCC734IDB4KC + 1uDRC6bJtUjhl42MAHgAqKRHgxGA2g1gmkTlroDSCZCOfBQgGwkA4rsC5BBgvFFQ2SMg7xPYZjTA3iHA + 1XQGRPmIQBwTRDoE1CZZ9f0CXLVLwBXHBdLIgAYAtUsAVWkA2DD1h37Il9zeMRokPzK6AUKYwIbHZsnv + 8UsEgEP0Bp10oWZqSX4TIA8BFeyNgLL6IBAxOghIYUAIAawDoAQBUTEIqCMCWvjFRwalY62s/PbASCgQ + w4AaCoRAcIUGAKYYCORQIGoUCLhWpi4YcNVQQAOA1CkQQgF7CZEYChLdglbvamX//Pf5UttbJvzkqyPB + 8CaVtT0hhMFwF788AFApafV8hRZdr/gYoPQoIC30iuJegHO00DOjAgAt9tEfDBJVPh6klRX7S7zoqyGA + Fnq9YkdAfHSQ7RVQ1AYBl6S4Z0Czb4AWe7VLwEOArFv6EJESAtQwQAu/rLCXgAUBrtghSHRpsJyvHVj4 + Fl9i+wO94TXrboAQJqwPAuRn/NIAQEN6es+r1xpcg+IoQFHsAigbBJXHA/WKgUDZEyCpBAKdbD+A1BXg + ewMklWCgU9wroCh2BtJrnZIZTCUc6IwEBBoG6FEeHQjhQJQFA73K2ECUhQOoer3FN1Pbv/oHfGntH6NB + 8u9GN0IIE9Dw+Bz5fX5pAGDIVYuzkP7iD0fGALoAoHYEBGmx37YrQDXaHxDdHZDV7xVQg4CuQ2DUJdCE + AaFTIHcLqPWKLACwsYEwOuBjAuPRgRwGRFmngHUQtJ0DWNLud5hM7i/y5bS/jPvIb9Eb34buRghhwvkg + GHbwywKAJ5Ld5Hv/vGlyXfo6oPSFQDkIqKMB0ecNBDQEqK8S1msQCKRQwNTvG1CCgC4cqPsHmHwPgawu + GPB/6/cSKEHBKCBst7cgsxHSULRV7PDv3Ff9dorRQLh8JEBvghAmsKN+8i/8kgDgqeS2uL9Bi2ggahyg + GQnw9wUoI4FtxgLM85XytwT06kcEmg6BJBsRaDUaF8idghmtZvloNDqI6hgoKuOCbcYIaiCQdEFqjtXz + qKpr9rt86cQWD/zkr41uiBAmkIvDAfIlfkkA8GwQ8tK1hplSWuzD4psCNYrdACEQSNLCL4UDXRiQNOoO + SOrCgS4URIIB6w5EhwOmGgyUoxoQdPJuQaR7oA0IhqMFVacUFhLd622BvpK+xdj9HgYh5OUHgfAklUCY + iA4Hti7zywGA5+a6I/T3tLAuy48KascBRipjAb2s8EtHWuj1GoYBkywbD8hHg0CgGxcYqtlXICqEA10Y + 0KsfJyS6Vxucj292+D/kSyS2GfGTD41ujBAmgnT9p/BLAYDPxdAQ+eUrdTN1NACExe8ISNJQoGjYJaCy + 0YF0ZAHhKWr2E+g6B+JbCA1DA1d9O6EUFOQQIQYHtYugyIKCcuRKew+i1HYVEtHcZs/9kvZHf8SXRuwz + 9Ih8edgfXqQSCBPJB/5wA78MAHhhStpCxy6bZ2bZSGA79cVflRZ3tUugURgbKKMDqtwx0AaAKGmRj+4g + aPcZSNLiLgaAJ0oLfSQMGI8ZEtHMeudySaf/J3wpHCzueTYv3fNtEQgTyWE3+St+CQCwY1y1OE/SAvxY + +bRw5BPDTONgoPdJAUGvNjDw0EADwJOMCguKPDSIagOEYiQ8JLL0V/9WYVugOr8z9Do//QePezPka0Pe + rU0qgTARvOcNDxJCXuKXAAA7SknP7K9nN3ktZyumtk7Ron+qlMqOXBYElOMzSUOANhhMPps0DLBjVCfh + KUY/uTAFBVkIyrF6Bq93h77JT/nB5q5nvfCOe4NAmAjedm2+y5c+ALtGkcP3h5n1zs7T5ePhk6VjRPTU + to5H1HURRKP2G2ynsA/BSPWdBlGKgYNbkdiyDku21fvwRmfoHX6K44NbrrWvDzjXN6gEwnj2jmv9HnsC + hi99AHad/FbPWxn1MwOnaBA4cXOMiJ5UpMV/p1VDRRlX/Lekcbh4moZBI56l4Sfb6hktdcz+DT+l8ceA + ez2vf2adQBjP3vZs/gNf8gDsKYUtod+91uCqor8k10/coAFAUQgEz6oaHLZ1/PNZ+mQ1HYo4l/7qD2dZ + XQN59sC3+SmMX27Pkzf7ptfXeqcfEwjjUufjXsz+wX6TZSOv5Vrdly6YpueO33hIjtMQEAtqQkkCe7F6 + aiW/2VPCAhs/ZYnBgHP95K3JNQJhvNkzuRYedG78JV/qAMQEeTbPtzMbnF1nKsY3PqVh4EWVAwV8Xk+X + j7Nf+4PFbf73+KlJPNhrUemN0tdNb5gQxpmlfJkDEJPktPjfo2Gg72zl5ManJbSgw131dNl4OLPBNVrQ + 4vkovSdGvtS333RPr/+oY2yVQBgvdk2sLd9z45O/4OCQ1+T926xGd/VF01TwBP2FalTA4HNK/46f1Uyv + 5DS5HUXtgQ9KZmZ+hf+5gQKbkXaOL7c7RpcJhPFg9+Tj/+HLG4ADR0H1/Bt5dt9Pr1rcTexLhKfLJrYM + CxzUeLJ0PHzZPDOX3eRuK7QHPippmX+T/0nBk+gYefyNtpHlVSqB8CDb/nCVvfTnl/jSBiAuuHlr7nCO + zfdxttVdn1HvGr9YPf3obMXE5vGSMcNiGM+eKZ/Y+sw8vZjZ4JrMbfJar9t9v7juCH7HZiOv8D8XeF7s + IyuftD5YIhAeWEeWNnsn1v+EL2kA4h72hEGZw/enha2efyps8X2U2+xNz7F5y7Kt3gZmlsXVkWVxd2dZ + nN00PHQp5jR5OrOoOU3uziyruzPH5unIbooNc22e2rxmnzmv2VteYPelF9p9Hxd1BH5Q0hk6VmCff4P/ + r4OdJL2HvGofWbrbcn+JQHgQdYytnOTLGQAAwPPQOfr4raahxeWme4sEwoNk8/DSHbQAAQDgBWgfXfnA + MrhAIDwoNg7OL7cOLb7FlzAAAIDPS8vwUk2jdGOFMLa1DC2E7SPL7/OlCwAA4EXo6XF/0XL30cP6248I + hLFsy/2lbL5sAQAA7ARtw2tfr78zv1g7MEcgjEUtgwu3bQRzfwAA2HGaR5beNffPbVEJhLEkDQCBTif5 + Hb5UAQAA7DSNt+c+NvXOEghjxZq+2VXL0Oqf8yUKAABgt7AMLeRV9cwSCPdbU+/cpnXw0bt8aQIAANhN + CCEvN9xZtFR0hwiE++atUNhyf+GnfFkCAADYC2w22ys1fXOOss4ggXCvLaU2Dj76X74cAQAA7CU228Rr + 1X3z/exmDOGe2RUiDXcWL/BlCAAAYD8wj4Zer+yeHbzh8BMId932ADEPzKfz5QcAAGA/sdnIa1W9oe6i + Nh+BcDet6Zs7y5cdAACAWIB9PbC6d7a10O4jEO60xQ7/Vv3d+Q/5cgMAABBLEEJequ6fzbve6iUQ7pRF + dt967cDsv/FlBgAAIFapuhX8JL/Zs5Vv8xAIX8TCFu9yTe/sd/nSAgAAEOuY++d/WNjqXcujN3EIP48l + dr+nrG8umS8pAAAAB4WmgcVvlrQHXDlWN4HweSztCHZVDpMv8aUEAADgoGEb8v9aVc+sPcvqIhA+zVyb + Z9PUG/wFXz4AAAAOOhW9wQ+zre71qw1OAqGR+c2eWfPA/Dt8yQAAAIgXytuDR+lN3nWl3kkgVMysmyE3 + 2/1t1Xfm3+BLBQAAQLyRTsirVT2hzKxG92ZGnZPAxDbX5lms7gv9K18eAAAA4h3zwPLhojb/2GXzDIGJ + 55W6mXBpZ9Bqx69+AABIPNiLg8q6gv9Hi8HapeppAhPDbKvbW4Vn+wEAAJR1LfxGkd1X+lnN9NZF0zSB + 8WkGDXrFDv/Zjwl5mZ96AAAA4NCh6s7Akbxm78AF02T4fNUkgfHhZzVTG8Vt/mJzZ+h1fqoBAACAaCpv + Lbyd3+y7e940Sc5VwoPqpZqpzYIWT01J99JX+akFAAAAnk5Z5+y3cpq8HecrJrfOlE8QeDCkv/gfF9p9 + ZZV9gd/mpxIAAAB4fqq65t+83uqtvlA9uX6qbJzA2DSjfmauyBE4YR4d/QI/dQAAAMCLY7ORVwrt/v+6 + 1uiaOlU2QU6WjsN99lzF5FZuk3ugvGvue/w0AQAAALvHzU7/14o6gtcyG1yBEzfHyfGbY3CPpL/2w1fq + XdMFdt8nlW0BfLAHAADA/lDWNZdc0OLNv1I342HF6dOShwTurGcrJjevNbruF7d5f15tx8t7AAAAxBj5 + 5tDrxXbfz3Jtbvtl8/T8iRtjhgUNPtnTZRNbGfUz7oJmb/mNjuDfsZc28T8xAAAAEPvk3vb+6g1H6J/z + W7zFVy2u4Ys1U0voEmg9Uz6xdbl2JpRldfcUtgUuld0KHUPBBwAAEHew4lbZFkgrdvh/XGj3pee2eK3X + LO57GXVON+saXDBNrrGW92kaFJjHbxgXzliVdT2U//ZzlZMbF0xTK+m0wF9pcE3RIj+Q3+wxFbb6Tl1v + C75X0jX/Jv+zAAAAiCsOHfp/aDKeMgR5W58AAAAASUVORK5CYII= + + + + + AAABAAEAAAAAAAEAIACdZwAAFgAAAIlQTkcNChoKAAAADUlIRFIAAAEAAAABAAgGAAAAXHKoZgAAZ2RJ + REFUeNrtnXeYJFd16H/nVnX39OSZzTknrXIOSEKAJJICIETGNsHYBgwGR2w/y4AwBvsZAzbGfoBJNiCi + yYggC0WUtVppg6RdbQ6zs5OnQ9U974+qjtM907PbPdMz2/f75pvu6u5bVbfu79xzzzn3XKFRZlV58Hlv + RADfglWFiDSJpyutmoutcrGqbFZlhap2qkrcKgAJVfpV2a0qTyE8opa7jThPJ3xv2MGgjiAKL37sC41G + nkVFGk0wO8qjl76BFoV+gbQqjpj5Fq5W5SXAJVZloSrNakEBVUE18xqsBscArJJU5QjI/cD3Rbl9eMQ7 + GGuK0BxxSPmWa7d8vtHoDQHQKPVQHrj89YiA5wuu0m3hJou8WZXzUWI2A3we/OHIXwr+AsGgKingceA/ + jZpvjFp7NOYEv79ua0MbaAiARpm2svMlL+FY3zwcx8NtT4nX33SVqv6xhReqShSFk4Q/7zVpkDsRPtYS + 4+fDo9iU47K4r49L993WeBgNAdAoU1kevvzVJJLdRCIjiHitqs7bFf1jqyxWFaoMPxp+BzgiyD+7yKfT + MHAoCksShuu3/7/GQ5mBxWk0wcwrB867jv1Nc2mWEYwwR1VuVfhTq3RVG/7Mb2z4OUqLhSssLHRE7o97 + OtwzmOQta87j64cebTycGVbcRhPMvLK7pZtWfxQRO0+tfFzhjVZxpgD+zHcjVvUtFtoiRt4zpzV2yBto + KJMzsTSe2gwrD176RowoRmj3lI9ZeLtVzBTCX/DfiHzJNc57VfU4Cq/c8bnGQ5pBxTSaYOaU+5/3ehBF + 1HHSyh9aeEst4NcK4VfAs/qGtG//uNWJRIwI39nwtsaDagiARqlFSUsax0bwxH+ZKu+xSqSWBr+J4A// + O561f3A8lbyxP5nEMY0uNZNKYwowQ8oDl74eRABZqug3rHLJdKn9Y/4riPBQzDE3WWU3GG7e2fAKzITS + ENczpAjQmU6Lor9tlYvqCf5QYzgv6evbFrR0GCONcWUm9atGqfNyX2j4E3Sdr/J9VdlQT/BnfivIriZj + rrPoVscYXt3QAuq+NDSAGfGUDHYkha/mlaqyvh7hD7QAXZWy9qbXPvN5GqaAhgBolGoV34em6BxVrkeR + 6bD2TwQ/4X9f9bqvrXnLgmTaNp5bQwA0ysmW+y5+PcFMTc5DOb2aI/8krf0Twq8oProxbbnYU+W2tW9v + PMA6L41IwBqWN7/5zRhjSKVSBcettQwPD2PtxKPkXSNJzk20Eld7kYV2VepK7c+HP9QoWjzsBbsGh793 + VndHoxM0BMCpUV7zmteEICoakjA6Ooq1Fs/zCo4DxONxRCR7LP/z/Nd7Ed7YT/yZiJ6v1Necvxh+Da9d + kIvO6OxqT/l2oNEzGgJg1oMvIlhrg84v0gGsATYCi0WkLRKJRDJgZ0pGKOSXfAGQKc+6nv7FQq/l9b2t + F8Z9CWGrX/gVwaIrh/1UqyoNAdAQALOzvPa1r8XzPAC+9rWvcfPNN68TketU9WXAGUC7qsaK4S5+Pd4x + QtAE8LOw1Tf84fc6EDPfYg80ekpDAMy68upXvxrf9zGBr6vj5ptv/h3gHaq6gTC2ohzwpUb5iV43W4Oj + YGcA/OElxx0xS1R5tNFbGgJgVpWbb74ZVcUYg6quVtW/BW5W1WilQE8GfkWJWJAwh1+9w6/BN11VbcvV + 0CgNATBLirU2A/9G4F+AF0wK6El+VwEpsPzXN/wKCBiUiDb4bwiA2VRuvvnmzMv5wMdqDX+mpEXDyL/p + DfKpBP7gusWzMNLgv/5LIxCowvLKV74y89IF3gW8bCrgByWJBkbAaQ7ymRj+8LxoStFe25gC1H1paAAV + ll27drF+/XpU9TICg5+ZAGhV1X5gVFX9kxEUw8Y6aXRuVE2kEviZNviD1waGPLXP2cYcoCEAZktZu3Yt + 1tqYiPyOqs6fAOgnVPVrwK+BA0CiuL6J3IKZkhbVVcloV9x3vqBwfj3DH94NBqc3Ks5QQwNoCIBZUW66 + 6SYARGSTql49DsQKfAf4S2DbeHXmRwHmvy4uy1MRPnRo0cFfNA087Cvn1zP8mTgFNfpIVyzWN5BONTpP + QwDM/GKtxXVdVPVKYFEZ+CEY8f8I2JM58O1vf/ukzp0671X8NDpgHcuDqrxVwalP+LP2CTViHt4/MpKK + L+2BXY3+U8+lYQSsoDiOQ+jnPw+QMvAPAZ8A9lhrsdaeNPwAjxPHBCDeDeyvX/iD9wKHXJw7HRHM8a5G + 52kIgFlTWoG14xjxtlhrf50JEvrud79blZOe/9BXEAMRh2cUfl3P8AM4Yu5pl9j2JnF58/YvN3pNQwDM + /BKCHlPVeWXgB9jiOM5xEeFb3/pWVc8vTUlGUyYpmG8AQ9Pr5y8PPzDqIF8/lB4YXd46r9FxGgJgVgkB + A0TLwI+qDkajUd/3/eqfOxXBMeCK3KHK/06vn780/KrgiLk75rg/b3aj9CQaCwEbAmB2FV9VR8fx3c8d + HR2NSA0y4l798JeJRNIMpxgQkX8BeusNfhEGIuJ8+nhq9Pi8eCs3PfvpRo9pCIDZUcIEHQngcBn4ITAQ + LgS48cYbqy99fIeoo8SM+QXIV+sJfhVwxflaN/GfdLnNDKWTjU7TEACzTggMAdvLwI+qblDVV4cLhbj+ + +uurev6rH/0inhdl1CPlivkHQX5dH/ArLvJATNyP9cpoctRJ8vpnP9voMA0BMHuK53mIiKeq96pqugT8 + ABHgvZ7nvdh1Xay1vPzlL6/qdbQu3E5Ls0vCS+9x4K+AZ6cbfgezLybuX/alR55Z5HayYffqRodpCIBZ + 1kjhqC4idwA7x3EFLgP+OZ1OX93c3IyqVlUIXHXHHSSSlhbjcMi4dwq8T+HAdMFvkKMRcd//pDlw+4Jo + B/12hKu4pdFhZlBxGk0wcdm2bRsbN24kXNyzALiyBPyZl3OAizzP2xaNRp/1PI8NGzawY8eOqlzLV488 + zGvnnk0Llq7TBraPHo0/h3KxVTqmGP6DMXHf98o5Z399aDSFpz6/tec/Gp2lIQBmZznrrLMyabz3AVeq + 6oIS8Gdez1HVi62121zXfdZaW1Uh8F89j3LT3LNJHG1ib2L0qQ43ulWV06yyeIrU/idi4v7h/ww99+2I + 9fBR3rrvc41OMgPLjNsb8MHPnsd5D29nz7IFmMlcfRhBJ9ZwwDnIhenzkFvumNS5b7jhhsx04HXAZ4CO + CZb07gDeqao/z6T6/tGPflS1tvjuhrdiRBhMp4k57oa0tX/lW32lQnMt4EdIumK+FxP3Q73e8BOLIu2k + 1OOte78woyF48LPncd6jO9izbAESpDWnonRmYZo2RVj+XA8PXbCa89/xUEMAVLPs+/A6HHXxJJW9WlFw + HEj72iRimkBjIDFEm1GiCkaC7fNSwAhIEkgqJPDSCYiEzzf4Vnx4lHQswuKPjL9y5cYbb8y4BKPGmD9V + 1b8EmsrAn3m9A3in67o/TyaTiEiVhcDbiDuG46k0cce0jPr2FZ7VP/SVc1RxqxThZwV5LCLm060mdtuQ + TQ52Oa0kNDUj1f6Df7cSN5ImmWhCswQoUV9JOtIkmCaUGKIxoBnK9CklqWgiltJEypigXcN2jiSG8aJR + ln9od0MATLbs/charIAJg91VFLHE1Ei3qKxBdSPCWmA5weq8+UAbgSXehPcVJKeBNMoAyFGUgyjPqfIM + ylOCPKtKr1WTNH5wrogPvihL/25nyWu74YYbgoYTaVbVDwDvV9WmMvBnXu8A3uU4zu2pVAoR4cc//nHV + 2uvnp7+Nrb1plrS4jKSTxJzYIl/1FZ7qG3zVM1S1zTJ+Gi+F3KJelXBhj4wYZIsj5utR43yz1w7t7ZZW + jmoPy2UZr9s7c4J9nvvwWlQFYywCWDU4aMyKdktuH4f8PjUPaB+nTw0CR1A5iLIH5WlV2aYqz6jRXvGd + pFgLKkQs+AJLP7K9IQDKlSO3bKa/5TjxVHPQ+VRRkVaE9SiXApcAZwGLQ9grX8qsBNEqYS9XxUNlEDiA + 8iiWe1XlXkF3eGqGHBtoGV5ymKbOBSy+pVCty2gCQLOq/jnwJxkhMI4g2KGq73Jd9/ZkMgiU+elPf1rV + Nrxt3dsQETzf55AdZaFpmeOrvSht7ZWqXOajq1XpVIir5vIMZhpJYVSVAUfMPtB7XGN+GcG9e8fQ4aOr + WuYRURcV5Xf2zoxR/9DHz2R4+CjRaAuoYkTxlVZB1gOXAhcDZ9ekTyn3oXIPKjs81SHHAmpIuAk6ku0s + /IfHGwIA4MBHV3PNn5/Nj299LEgnpeKq6CrgWuAlBBF28zhRl+XYB0VW79Ps5xblCMpDwO1q5adG2Wkt + Pgq9i1uYu3eIZf+UM+LlawLW2j9X1T8BmiZI+bVDVd8VjUZvHx0dRUSqLgQAvr3md4mqMICHr8qbdn2e + /179tq60+osEs8mzdpmv2uypdVEwIp4RM+qI7PN8fTJinMPnt8zvvXvooHUQOqPNpKzH63f924wAf9/f + r6Xv1wN0XNIWtL1xHFF/Nco1eX1q/tT2KX6Gmh2o+qLCnpHNrGx5jKUfe/rUFACHPn4myZFeHLcpgEO0 + CeQ84LXhQ1rJyXopKntQ5Om/aPDgdqP8GOUb+Ho/YpL4ipUorh5n2T/tywqB0CbQDGSFQBn4M6+zmkBm + OlALIZApX1v9DgTB0zRp9QGDVcVXi6+BbcCIICIYBM9aIsYhLg6O285Tz/zjjPHsH7hlMV5TO+Kngucq + xIDz661Picpv1EoCVfxYiqZjXSz+9+kxHk6LANhz6xoUwWAxYqJW9ULg7eFDqs460hN7UHmfASo9KD8C + Pq++fw+4aeMrKsKKf34KgOuuuy5zxoqnAxmbgDHm9sz2Yj/72c9mCGb1WfbeujqcNhoEG1HMRcDbgJfW + XZ+CH6F8QXzutkIaLyBx5T9vm90CYN+t61icWs++2DaWjSbY19R0OvB7wKsJVLLqlOo8qPzvH1XlG6h8 + dqjV2dI6YHlkQTvnHepn+Sef4rrrrhtjE6DMdKDYJuA4zu3pdBqA22+/vUHypMFfRc/SXczdu4ZUvItY + 4vhpCr8P3FzvfQqV21D+zW9r2WL6h1nxiafY9YebWf2prbNPAOz9yJrwdBbFdIrqm4B3A+uqeqLqP6is + vxdlB8qnVeTLWPoyjbfyk09mQ35VtUAIlIG/wCbgum5DCJxwn1JEDSidKvrGsE+tn0F9aifwL6p8SVSO + a7gZ7MpPPTl7BMDeW9cELvdhH9PinIvyV8DLCBNszJAHlflNCpUfiHKrjrgPS8xHgZX/upWXvexlqCrW + 2mZjTMF0oBIXYWY60BACE5d9YZ/SpINE/bM1WBx13YzrU8HxNCo/QLmV0ehDxNKgQZ+a0QLgub9bjuPH + UPFBiKDyGuCvqy6hpw7+/Dq2o3zIWHObj6bUs0hLjD/YvihzRc1AxS7ChhCorOy6ZSXRWCTYo1GIWOXm + sE9tmHF9auw5dqByq1G+5ispR1xGvVE2/PuOmrVnzdYC7P7QOlZ0z2cgMYKKdorKnwEfBJbMAvhBmYvK + iyzELDwsSHL1px/nJ3d9jB/3twOkgfvDVGIXEeyYWwp+CBcQqer2zNqBNWvW8OyzzzaIzysHPrKSYx1n + EE8dQZUO4E/DPrV0FsAPyhxUXmiVJmt5RNDEfYcH+fgVK/jkQ0dq0qY10QD2f3gNvm8wrsUiiwX9MPAm + arEPwfTAn11bEKpvXwL+WqweTKohYi3vPLA86yIUkbIuwqLS0ATKlL0fWYdrfNK+AewiQTJ9KjJL4C/q + U3wV5a9E2W8dF2MtKz+7peq3WnUNYO8HV2N8xUZAYAXwz8DrqUXugemHHxQHlXNQVqNyv4v0k05zXdsg + 3x/MaQLh/V+kquMJwYYmUKLs/9AqBCHca3CFIJ8I+1T1Ndjphz/Tp85GZTUq9+Nrn2Nc3nP2Aj7xyOGq + 3m5VNYADt6yn9WcR+l+eAGUF8Gmgumlx6gv+4nN8XyzvVpHnzHZIrXV514H54bk1axMg1ATGKSekCey+ + dS2o4hhB1Yar2ipsy+x/KTxGJumnkGoSjA+r/qJ2c9Lisu8jG3lmwTCrD8cQdLkqnyYw9s28PlUZ/MXn + +CHIu9TqbjfVSooR1n65emHEVRMAegvsjq/B9RVRWaIB/DeeQvBn3n8b5d2oHsAIKz+3hWuvuSYrBETk + hIXAv129l1Q0QuvwyLgP1MaaheRwRBAXcAVxFXXJLWoxBMsdIgQv0mQWuqgoYAU8VTzAQ/GczkjaP5ZW + NVJSYCgWQwrFYfkHq7MfmCrs+eAqjCuALAY+CbzqFII/8/57auWdIuxXdVi14hHkljoTAHtuXUdwK7YL + 5J+A3zoF4c8srvmiWt4rIn0qwprPP8bVV2f3FJ2UELDKu2654ODt82MJ4q7FWIuKY1Rss4o0i2o3yHyC + aLfM31yClWxtBDsaZf5HCaB3w78MvZoBHSQNpFCGgEGUIYVBYAClJ1xVeRQ4inIEpA8YseKNGD/i5Ro9 + 18W+9ubtvPk/zpz0Apg9f7sGHBBDJ8o/Ab99CsKfqedLovJeq3JcfcParzxSPwJg762rEQRRYlb4W+D9 + zE6DXyUPClQ8lI+J8kGFJFZY/ZXKhEBuLb5gRGly7I7NXaN/8kdnHjyY8lkPspzAk7ICWEYQ7RYP4Y4x + 2XnxeOp/XnahPKB9lCSQDP8fB/aiPAc8h8puhJ1i2acw0Nd20VDnwH2AZJ+XJ2AUVn20/PLYfbeuQUVR + 0ZhY8zdhW828PlUd+DN96h9E9RZFkqiw+suPTb8A2PuRtaCWpYn17Gva+VaCDTJbT2H4M+cYRHlPtGP0 + C6njzQjCqq88WiAEQP4c4f2qNANEjNLsWubF0yxtSTE/nmZBPM3KtmR/d8xLhyN5rKptOjn4i35Tsp4k + MIRyDHgaZRvwFPC4Bgti+gRJad7v4t4wKacpuzJuz0dWYVQYjgrNKX6bQPVvO4Xhz+9T7+1w7ef7PIMq + J20POGkBsO8fNqHJJCCXAP9FsOLqVIc/8/5ZlNcr3B/dNxdz7R6stTgCD/c08+1nu1vTaj7aGfN+b3lr + 0lnSnGJZa4q5TR7NrsU1Njtyai3atPrwl/vcQ+lT2IfKFuAR0IdF2YaRY+rjZdrTdaDvwm20P7kWRC8G + vgpUP9f4zIM/834X8Hqxct9oa4rTPntyIcMnJQD2fmRN5sLnAV8kWM3XgL/w+z9U5bfcpYlj0p5GRFpA + loJeIHBR2srlaStnNLnWOKK1A3764M+rU/LSDtEP7AIeQPkNyn0gu61l2IlZaPXnivKfBCHjDfgLv/8j + VX4L6EGFNf/96NQLgL0fXg/GQhQhqX8GfJhq+2VnPvygeLj6N5H1wz9AuBK4GjiHYO4ezTyEmgJfX/CX + +l6aIL3Ww8CvUP7XdHgvwegtVHveP/PhB8VT+GsP5+9dtRpRYfnXTswoeOIC4O+XghcFuBDkNoJcag34 + M98XkIhFWnxMmzckLf4wgXV++lKx1yf8uXYNjlngGK7GJWJbJaKBxVCqdP8zH/5M8tE9KDcBDwyklXO+ + dWIGwRNq1uc+vBojBpA42M8ShGSe2vDboDnFVSTuI60e0uwjkSkb22cD/GM/Fw2iGaKWrDBowJ/5+5Ig + vwc6igqrvzF5LeCE1CtfLcYYUPtCoLq7YM4k+DOvBSRuMW0+0uIhURuE2tQJ+zMW/sxzSQqaMuBooFVF + LeJOQiuYnfCDyg0K30Dlh+YEJ0qT1gD2f2gV1hhQ2hC+DNxwysLvKCZukVYP0+wTZOGvszKT4Q/r0eJj + melVk0UidvxVJrMX/kxd30N5EzDo+8L67zw8qe4x6QU6sWQq8xCuBF5wKsIvjmI6PdzFSZyFCUyH14C/ + 1vDnFwuaNNh+F9sfQUecIPH+qQc/KFehcoWokDqBLjhpxWE03gRoE8jrqFZwxgyBX1yQljSmzUNiNqc/ + 1SH7sw5+LX29mgqmBzKqSJOPNFlw9FSBH1TaVXm9Kr9oMiQm200mNQXYe+uazMsLgO8T7JQ76+EXR5FW + H9Mezu/rvZwi8Jf6LGuEjYUGw9kNf6auwwQrJB9QK6z7XuUpxic3BRAhsucZCJb4zm74LWAU0+7hLEzi + zE014K9X+PO/nhbsQAR7PIIdcVBfCq9/9sEPygJUXhZvTk66u0xOAKjiLV89j2DXntkJvw3qlFYfZ0Eq + AL9pBoB/KsNfIAgkKwh0wMX2u+ioCQT67IQ/0y7Xjg7G5sokp6MVC4C9H86o/3IOsGnWwZ8x8MUsZm4K + Z14KifszZwP1BvxjzqOApgx20MUOuGjazFb4QTkN5RwUdr78vOoLAFCIOChcTrDWfHbB74LpTOMsSGLa + vBMPOGnAXzfw57S60Gsw4KLDDmpltsEPSjsql7vGQSdhla7cCyACnt9OsEvv7IEfkGaL6UjPHFW/AX/l + 8OfX44MddSBtghgC184W+DPfvzjl+e2CGai+AAjKEk5U/a9D+MVVpM3DtPkza8RvwD95+PN/kxbUcyAq + hVGbMxt+VDlNgq3OKxYAFU0B9n14XeZiTge6Zjz8gMR9zLxUEMTTgP/UgT9/WpAw2GEnCDOe+fADdIOc + DrDtmgsr6kYVagCCYhHMJoL0UzMXfqOYtsCnPyPBb8B/8vDnH/MM6gMRgXw378yDH5Q4KpuMWLwKrdcV + CgAfYyWqhrUzGX6JWkxHsEpvxpYG/NWDP1NPaCTEz0wJdCbCnzm21lqJumJT1RMAAoi0MJl0X/UEPyDN + PqYzXT/Lcxvw1wf8RbYB6zvBasNsOPGMgh+UFSDNKNUTAOF54sDCGQe/gGnzZrbK34C/9vBn7je0DeBq + sOQ4/zz1Dz8oi1DiCH2VdKtJxAFIJ5X4/+sIfnEUpyuF6Ug34G/APzH8+RCmDZoyqJ1R8INKh2A6s9cy + QZmEG1A7mWgjxnqCP2IxXTPUt9+Af/rgz6tHPQFrcslH6h9+gIgqnZV2r8nEAbSN+/16gj8Wwj8TFu80 + 4K9L+LPHfEGtBEFDUvfwo4rLJJbpT0YARCk3Zagn+ON+AH89JuhowD+z4M/rW5o2gWHQUM/wg4oBYlD1 + KQBuSQFQT/A3+zhd6SAhRAP+BvzVgD9TwvUD4miwf2p9wg+KmQzXkxEAtqhJ6gd+BNMSuPka8Dfgrzr8 + efWoJ7k9lusPfghWAlUc6DIZAZAKhUAdwu9hOme4m68Bf33Dn3/cl9wG6/UFPwT7KlQUAzBZATAMmT3c + 6gR+zYz8Dfgb8E8R/FkhQLBCNt87MP3wg4oXslp1AdBPsMljbeFnEvCH0X0N+BvwTyn8+fCJBi1dH/CD + kg5ZraIACC7oODBSL5lWM9b+xpy/Af+0wJ+FVwKjYH3ADzACcrzYXFeuVBYJGJxkGJUjdQF/6OdvwN+A + f1rhzxRbN/CDclhVRyrkv0IBYEEsowQbEk4v/JkIv4afvwF/PcBfFC8wzfCjKnuxZkQrDAWucC2Ag+en + RlR5ZlpzrIc78jQi/Brw1xX8pX4zPfCD8oyKN0o1BcBiZxhjYqBsRyU9LfALwVr++Axey9+Af5bDL9MN + fxplu1iH7ubm6gmAbV5neELZAvRPOfyAafUwLV4D/gb89Q2/5P1uauEHpV9gC8Bzx49XTwBsvmVr5uVu + lN1TCr+CNIUpvGZKjv4G/Kcm/JljUuI6ag8/KM+qym5UOP+hyrYHm9TOQOLQi3L/lMIfCeb9M9ri34D/ + 1IE//C+iRQzUHH6A33hKr04ClYoFwLIzHkRT+KjchZKcCvgRMO0zfFlvA/5TDv7M7YiZQvhVEqjc5YJ9 + dG7lewRWHAm474lLMxd4H8puYEOtd1cxrR7SUkdGv/yJXeZJSvikVQnSx2QAldznKg34Twj+8Iby/0NI + lqDWhsckd1zDNp9O+DOvhWCI9WoOPyGT9wGc0RutvgBYdstWnvvABsDsA/9XqGyoJfwSCzL4Tvu8X8NO + 5kSQpg6kdT7SthjTtghiHYgbBzcG1gNvFE0No0OHsQP70aHDaKIfUiNBHSLZztWAvxz8CjbsBJFmTEsH + 0rEQ07UY0zEfYs1ItAmMi6ZTkB5Fhwewxw9hew9hB3rQkQFIp3LtnW23KYSfsG9L8NyzY0Nt4AflDnz2 + Y2Dzb+6tvgAAOBJLMn805oF8H3gDSlst4MeAdHgwbcE+4WjuxDAdyzCLz8fMPx1n/ulI+xKINCNuExgz + VkBZwEugXgJN9GF7dmAPPoa//wG0ZyeaGAg7hmnAX1CPDQ2+rZiF63BXn4uz9DScxRuQtm6INCGRWOFS + 3ExdnkXTCUglsH2H8fc8ibfrcbxnHsH2HIB0AnCKjHNTAH9WC9BgBWHt4B8E+R8c9dh8DzxYeU+f1Pi6 + 7y824ltFhC5VvoVyVS32VTOtPmZOahpG/wB8iXVgll6Eu/pFOEsvRtoWgeuWfuATtawEQkFHj2OPbMV7 + +ud4z/wKHdgfdhBzasOvFhBM12Lc067A3XQF7vIzkNau3JZdlbS5FL1Oe9jjh/B2PkT60V/i7XwIHR4I + PhSZGvjz2yBtslOBKsMP8EuBm0COq42w4aE7aiMAAPZ84HRsKoEY53dR+TQQqRr8ChIBMz859YY/tUi0 + FWfllbinvQqz5AIk1lIgmE6qZDRR38f27MB78vukt/0I7d9HgZp6ysAfTIpN12IiZ7+YyLkvw1m0Dlyn + 6m2uoyN4Tz9C6u7v4m29Gx0dCu0IUwM/EGQUSppcWp3qwZ9G5Z1GvP9I2zinTQL+ExMAf74JtYrCElG+ + g3JBtUZ+VDBzUoHPf8rAVxCDWXAGkXPegrv6BRBtrk4HHK/VrcU//CTpB7+Av/PnaGq4hDYwS+G3Fom1 + 4G6+itgVb8RZdjo4kp9upvrtLaCjo6S33Eny51/B3/VEYEQsmIrVCP7M67RBU1JN+EHlN1hegXBAxbDx + wV9PqmmcybblP93Vw/sunYP1zKAENoRrUHFOGn4bLPF1urxJRiecDPzBqB858w3ErvxLnCXngYlMzblF + MG3zcVZdjrQvRnueRkeO56mnsxD+0JJv5i6n6aXvIfait2PmLmHMCFyTZw0SieAsWUvktEtREeyBZyGV + HOs1qAX8YTh7sHJQqgV/GuWjXlR/5aaFDQ/fNelmcU6kLd972TyCOAfZC3KxKitPduRHmNo8/mqRjuVE + n/enRM79HSTeVftOWEoOuBHM/NMwi85G+/ejfXvHQjdb4Edw119C/BUfIHL6VYgbmZ42b27FXX8B0rUQ + u3cHOtxP6SlYFeEPm1IgyCt48vCD8mvQDxorwyB86tCeqREAn7inhz+7oJOkiQyL6iDKS4DYCcNvg737 + nM4pcvupxczdSOyqW3DXXgvGZbpKxr0t7Qswyy5Eh3vQY89kjWOzBn4xRM6+lvgr/xJnydppAb+gzY2D + WboBs3gt/t7t6EBPoXGw2vBn24HAI1CQQ2Dy8KsyCHzAtzzYFHFZO0nV/6QEAMB7L52XudjdEmwaes6J + 7qiKUZw5UxTxpxaz4ExiL/ggzrILmc6SH9uiALE2ZOkF6GgfemT7GCEwc+F3iF5wI/Hr/wTTOX/64dc8 + j/O8pZjlm7B7tqPHj+QFbtUA/rBZRUA9czLwg/IVVT5pRDxQPnVg79QKgH+67xh/cMUCHB9PlGdAno8y + b7Lwq4JptkFuv1qP/moxc9YRu+qDmCXn1kVHLO6UROPIonNg8BB6dOfMhx8hcs6Lid/wJ4E/v47gz7Sr + dC/ALF6LfXYLOtA7QSThScCfFYgEWoBvThT+rSjvF+GAEzOs+81dJ9wmJ2Vuax72Mb4BvK2ifARlcLLw + IyBt3pTAL22LiV7xl5gl59Ul/Bm3uLZ0I1e+H1l5GVg7o1197obLaHr5+wK/fh3Cn4nglrVn4b76fUj3 + QrC2dvCHTUP+NvWTg38Q5e/EylZFSQ2cnMfspATA0n/ZFiRE9CPg6zdR/h0VWzH8CtJkMfFaq/5BWGnk + /N/DWXFF/cKfGemtQvtiuPy96JzVeR/MIPitxcxfRdNL3o3pXli/8AOKoqrI5ktxXvw7EIsXtnk14Q+Z + EEeDFa6Tg9+i/LsxfBNHEYTNW+89qbY5aYfbyk9txXdcrDhJVfm4wg8rhT9whU1NTn93w/VETnsV01kq + gl81fK+w6Ezk4t+HaGuZDlmv8CvS1ErsRb+Ls3xz7fz7VYM/FxBkLr0Oc+FLxlZSLfjzVF2J6GTgB+UH + Ah/zfU2mPZ+ND9990u1TFY/76oOPM2/bE6ByGMufo/ymkr3UJWIxtU7xpRbTvY7IuW+FaHxmwE82UA7d + cC2sv5YCemdAbH/kzGuInHVtXQjcCeHPfF8VbWpGrn4jsmh13lSgyvBnzuloMPhVBv/9wF8ocmTjQ9ey + ecOyqrRRVQSA3AZH129CUFTlSUHeh/LkePADSEutF/wouDHcs96E6V4zbWroCcGf6aCROHrem6BrRXbB + TF3DrxYzdxnRy9+ARGPT3uaVw5+5fIVFq+H5N0MkNs79niT8SrCpiGsrgf8pkPeh+qSIsOO8nyK33VY/ + AgBg1WeeAgRBQPy7Ud4DsrMk/AriKKa19qO/s+hc3HUvnbZlxScOf6bNFJ2/CXvadYWPq15X9Ykhet51 + OEs2zjz485/J+VfDqjMCgVAL+DPNFdHC7cXGwr8T5D1ivHsQFwU2PHpP1dqqqkG3Kz/zRHDRfhQvmfg5 + yjtRniq1l7rE/Rr7/RXcJtyNNyLN02OBPmn4s80m6KaXol3Lwy/VKfzWYuYsJ3L2i6dd4J4M/GoV2rvh + kpdltYBawJ9d+u5qOfi3gbwznTS3oy6gbHz411Vtr6pH3a/69y2A4jQ1E7Xcrso7UB4s6EwSRP7VNOZf + FTN3E87K509rRzxp+DWYm9ru1di1L6xf+MP3kdNfgJm/aloF7knBr3mfnf48WLousAXUAv7MVzLT4EL4 + HxL4XZ/R22Px4MDGR35d9TarCYIr//1xrK+MAoj8GpW3AD9GUWwg8SRua7ziTnBXXom0zJvyzlhV+DOv + jcGuvQriHaUNgtMNv1WkpRP39OcHK/tmMvwEWoB2zEVPv6xEYFCV4A/bUFzNrpAOLpQfg7zFGvm1qy2o + FTZUweI/ZQIAYO3ntgTbp3sKsEUtb0X5NMiwxC0SqaH6r4rEuwOf/xT3xZrAHwar2HkbsfNPI5tfql7g + D41/zpJNOIvXT5vArRr8mjf1Ou0SaO0K05RVH/6AQg20AMswyr+g8jbQx42nKD4bHrmzZm1X04W3a76w + BRB8k0SQg/j8GUbfJ63esdqCaTFz1iPda2YH/JnfNbVjl18QPLZ6gh9ADO7a85F425QKgJrBn3m9aBW6 + aE2h7aWa8If/JWp7EN6vvvlTRA/4g+1YETY+endN26/mK+/XfPFxXJsEdXCWJUYjG4Z+ZFq947U+r1lw + BhJrn7LOWFv4c8f8haejYwKDpj97r8Rag8QeU6hx1Rx+VTTehq7YxMRJQ04c/lAA9Lpzkz9wulKj6vhE + gU2P3lXzNpyS1Bur/nM3kY39mDYfVM5EWFjTbuE2Y+ZtnrLEIlMFvyrYOWvQljl5doA6yNuvirTNxSxY + PeUCt2bwZ35nBLt8YxBEVi4a8yThD18vAjlTYha3y2fd0z+eknacqtw7GY8HwMVAay1PJNFmTNfUWKKn + En5FsbE2tGNp/cAf3p+ZsxSJt88u+DPPbcFytCleS/hBaVOVi4MI/6krUyYAwuS4bcAFte4eEm1HmufN + OvhVFXXj2PbFQb31AH/42nQtDvL169S0+ZTBr4ptnwPxtqKGqir8mXouEEurTqEImDIBEJa5wMaaC4DW + +RCJ1/gsUwx/+Nq6EWzrwmARSV3AH2TcNJ3zg4y+swn+zPFYHO2YWxStV3X4QdkIMncqjahTIgAOfHR1 + 5uV6YE7NTxhtC9J81aghpwv+zO9stAWMUyfwA+JArLWmBsBpgx9Q46BNrYUVVB9+gDmorkdh17UXzR4B + EImkMyPWZoJpQE17irhNiDi1qn5a4UdBI/EAunqAXwHj1FT9n1b4NRQA0aZaww9KG7DZqhJ1pyZP5ZQI + gEQihggusGlK7sqJ5KK3ZhH8uRHJHdt5pnOXXpGgzWch/GgQEITj1hp+NNhJcJMr4o4k0rNHAITN2QKs + mpLT+alctNxsg18BL7y/eoBfCWLlvdTsgz9zzNpgs9Hawp95vcpXmnWK7ABTIgACM5G2AMum4mSaHkW1 + ekuN6wl+BcRLgPWnH/7MYWvR1GhVbQB1Az+Ab4MNRGoPP8ByQVqnyhk4JQIgaEhZCHRNibhJDoBfnUSj + 9QY/CpIYDFeoTTP8mWuyPjoyWDUbQN3An/mu7yHDgxQku60J/AIqXarMn1UaQFiWA81TcSI7fATSw7MP + fgAviRk4NA6oUwx/+Nr2HYa0V7U2rxv4ESQxgvT1BM1QU/ghZGTFVEFZcwGw75+XZF7OB5pqf0sCySF0 + 6PDsg18E8RKY/gO5R1cH8INgew+iqcRJaV31B3/QRNJ3FBLDlNw+rLrwQ7DD1nwUdl5Ue1dgzQWAOy8R + bIMU+P8dpqBoahjb++wJd8a6hD/sbDLSh+nbX1fwg2B79qHDfbML/gwkB3cjoyNM2vMyefhBcUNWcFK1 + twPUXAAkn+0kGmQ86a49+WGDegnskScC482sgT+4NefIDmSkl9Kj0TTAH/7XwV78/TtPSOjWM/x4Hua5 + bZBOTgX8mf/dbtyQaql9PvWaCwABEr5Eai4AChreYA8/gSb6J9Uh6xp+AGtxDz6BJEuNRtMFPyCCJkbw + n3ti0nsA1DX8IsjIAGb3U0XtVlP4Abq9Yc81U6Av114ACBijLrWMABzT8II99gz26FOzB34RZOQ47nMP + jL3v6YQ/ewOQ3vEAOtRXsdCta/jDNjd7dmAOPpcDuvbwhxGBEilIQDJjBQCCqDFAdGrgD/5roh9/1525 + VE4zGf6wM7oHn8A5+nSJDjTN8IfXZw88jffcExUJgLqHH8D3cbfciwwPhJGlUwI/IDHBmKmIBai5AAg6 + vNZGAEzQ8N7uO9GB/eN2yBkBP4CXIrL9l0EMQMH8vw7gz9gBRgZJP3YHpP2ZD78YTM9BnC33jW3D2sIP + EFV0CjbMm7pQ4OoLgIkaXgz22DN4T98+8+EXg3N4O5Gn76xT+HPn8rbcib9ve9meNSPgD7/lPHwH5tBu + wJlK+EGJomKYAgkwBQJAQESA6i1vqrThfY/0k/+DDhwaowXMGPgB/DSxLd/HDBzOS1FdZ/CrgBjs8cOk + 7v8heP7MhV8M5tghIvf+pPA+pgZ+AlZ0SmKBp0AAaPBEIF2t6ipueDHYI0+RfuJbBbaAGQW/GNy9DxN5 + 8qdloa0L+PM+Tz34E7ynHy3cyWymwA9gfdy7foDZ+zSImWr4QUmjRmeFBhDaACyQqkJlk2j48Du+R/qx + b+Afejy3f+WMgV+Q0X6afvNlzNCRYPSvc/gRQfuOkvz5l9HhwYI2nxHwG4PZ9SSRO/8nWE8y9fADpAS1 + U6ECTEkcgATe4ZPTAE4E/lAL0P79pO/7LHakr6CauoYfwFqij32byDN3hfdT5/DnCYH01rtJ3vXdYIed + mQK/CDJwnOgPv4j0HAxG/6mHHyClitXZoAGIgigWSE45/Hkd0nv6V6Qf+hLq+zMDfjFEdt1D033/CV6S + 4tj/uoU/vA5NJUn+7Eukn7wfNTMDfjyPyO1fx3307umEH5SkKv6s8AKoGBCTBgamBf7MMd/De+jLeE9+ + f0bA7xzZTvyOT2EGjpBdQjEj4A/vXRzs8SMkvvsp/D07S0wF6gj+8AIi9/+UyM9vC1T/6YMfhQFrOPml + lfUgAHAc1Et6wLHpgZ/c3HSkD+9//xF/58/rGn5zfA/x2z+Gc2BLkPtvpsGfN/3yn32CxNf/Af/wPlTq + FH4R3Ed+TfSbn0GG+ym5zmLK4BdAjhkVb1ZEArbF54IbBeidNvizQsCgg4fwfvlR7M5fkjGz1hX8vbtp + /tlHiTx7LzNL7S+CP++e/G33k/zax7CH9gRCoG7gD+7HefhOov/9CeTYYca4LqYa/uCmelFYOQVpAWue + ejSRGsy87AW8is5ZC/izUt2gx5/D/9ktmMQAbHo56riBsWqa4XcOPUnzzz+Ou+t+subTmQy/5n7rP3Yn + ycQIkVe/H1ZsIrOxybTO+X0P9/7bid32r0jvoZzLbzrhD4zlvQBHpiAxcM3XG/3D7Yd53wu7ARYDNzJR + RGAt4de8h58YRPc+CH4a5q5HI/Fp8/OjHpEdv6L5Zx/F3fdoOArNEvjzgNOjB7C7nkA65sG8ZUG67emA + 3xhkeIDoT/+b6Hf+A+nvoS5G/qCMgvwnsHP1vffOfAEAZARAE/A6oGVa4c+8FoF0At33MPTuRrtWoC3z + go46JfAHkXMydJSm+79M8/9+CtO7N5zzzyL487QARKCvB33qN2g6hSxYicZbUJUpivALVf7d24je9mki + d3wXSYzUE/yg9AGfAo58et++mrM5NbsPBG1/RJVjBKnBphf+/Mb3PXTbz+DQU3DWzejpN6Kt88O5qtYA + /gAESY3g7rqXpt98GXfPw2C9mW3wmwj+7OUbdPA4+oP/hz71G+RFb0BPuwSa4kG7Wa3Bwp5gOiV9R3Hv + /QmRX30bc3hfrj3rB36AHuDoVHE5ZQJAlRFgL6U2B5kW+PO+I8DxPciv/xl2/hI97XpY9wK0bWE2EWQ+ + 8JOHPxz9JMjo6+57jOhj3yHyzF1IYiAcgWaBwW8i+PPvw/ro9ofQvTvh9Evh4pej684JNYJcO58w/BK2 + ubXI8SO4j96Fe/cPcXY9BV56uv385eAHZQ+qw7XY2Gb6BIAKqBnG+M/UFfxFHgJ8H9n3MM7BLejj30LW + PB9/5aXYuevQWHvOjZU/MpFvzJK80+ceoKRHMQOHcJ/7DZGdd+DufQQZDd1NYmZOhF814C/yEDAyhN7/ + U9hyL6w7B06/DDZegHYvglgsbFvJEwJaGM2J5J0mELKoIiODmIO7cbbci/voXZh9T0M6BL9+4Qd41lVv + 2J+a2fnUCICUHyXmJn2FJwnCgk1dwU9Rp/R95OATOAe3Yh7+L3T+JvyFZ2AXnIY/ZzUa7wQ3jhoXFSdY + uakK1kesD14CSQ5h+vbhHn4K5+BW3ANbMQMHgx10Mp2wBLSnDPxhPZoRliOD8MgdyJZ7oHshzorTsCtP + Q5dtgHlLoKkFIrFg01djAvCtRa1FvDSkEshQP+bgLsxz23B2PYnZsxMZ7Av2UCho87qF3wJPeiZiI6kT + D5ytOwHgGD9zn1uBQaCj7uAvEASh+qggw8eRZ+/CPHs3RJrRaCva3I1tW4RtakfdOOpGg80j0glIDWMG + j2AGjyLJISQ5FO7iI4Hcy9+09FSHv/g+jRMI3yN74fAenAd+jhNvRZta0I65aNd8NNYM0SbUcSGVCsAf + HsAcOwyDfcjoECRGw4pNmJNuytfznwj8AAOobAXFOlOjAUzNRAPYe+saCLYG+yXK2rqFX8erJ3dxWhzN + UnB+Kfqb+DynNPzj1TNmp87S1635bS1TmsCzWvCDslOsvgCRfet/U3sXIEylFyC40d5wGrB25sEf1iGS + 4z2zU0z+jjFSJ9t1zQb4M+0gee0qY5+5lm3rmQS/oNHo001zuvseesV7ue0f17O4q5nhZJprzptTMy6n + bGsw31rEmGHgNzMT/rDzTvB5A/4qwl/BM58t8APsPf/FZ/zsDz71wcTytddGIqb7zq2HGRzx+NWjx/nJ + A5NfSlNXAsCIYH0Lyv0gAw34G/A34A/vWRUv2szhlacvTSb9PxoYSd92fCD1vRXzW/7QdcyK3/+3BxhN + +fzysV5+8mDPzBQAy/762bDBZCvwXAP+BvwzFn6qCD8gqox2zmVk3lJEFJS2dNo+bzTp/1P/SOoHf/u6 + M/7cMbJiyzPH8XzluV7lV4/3zSwBEHQqg6pzNNACGvA34J+h8Gv14M8YNQeWrMNvacch0JZDj6XxrZ6e + TNmPDCfS31u+oPUPXGO6H9x6CGttVbSBKRUAI6kYJki09guURAP+BvynPPwofjTG8VWbIRLJwm8k2BrE + hJHjVvWsZNr/xHAy/dWmqPOCJfNixojwp3+ym/99anIr7adNAMTcdJicV+5R2NWAvwH/jIFfawF/Rv1f + wOCy9cEa0CL4g9dhZn0h4lt9cTJt/+vpfSN/6Tqm+4U3txF3HH695Xj9C4BVt2wL12XoAeDOBvwN+GcM + /FQf/szr/pWbSLV35wE/Fn6TEQzBGoEFvm//ZjTlfc6NyBl7j6UwrsOdW/vrWwAALP1rUB8P5afASAP+ + BvynLvyKF41zfM2Z4EYC6CeAP/MdRBxVbkx79qtdze5L/uiaTxNxhHufnJwQmHIBcOjvstrU3SCPnwz8 + WmX4tSrwF3a0CWGYEJZCUHWSv6mkzmpc2/jC7sTboLbwV3ANEyfwPGFBjlWGFyxncMUGHNGK4RcRHCNB + bJRyhufb//j4D//gTUs6oo5xhHu3Vy4EpiwUOL8891drkFgMTaX/Arg1jOOcFPxVG/nzzqVl1wZQfvQL + FrHnhQPnFp3oCWo05Tq4noBQm2iEq0xAVX4erQSE8c5VdN9VMRSXFHgTaTOT1BYnqzGF17n7mtez/8ob + Q/AnB3/+dMExciziyl93dEb/3+ion1YLF29on5DFKQsFLihG0GQagR+q8vsoyypqvJJSV8dVRwueermR + hDC2f9zOXVRHuGhdmjtxlp2BmbcSUqN4zz2OPfwsqpby23jruIKo4AaVEsJknHq0eOTSyoTneO1TwWhZ + 2UhY+etqak4Vj/xlQR1HkEzyOnIDhyXZOZ++jeciRjDoCcMfbL3JHKt8ZHAgTXtb7N8TCc9/4OkhLljb + Oi6K06IBAOz+i7WgRBH5V4G3Tk7FPPmRLx+kkjuwlBNEeeC76y8leuErcVacjcRaQH1s7wFG7/gyqfu+ + ifjJvOs48Tm2Fj+yE5nzjxEmUkFHr2y0VSqBqVpaxOSf+eTm/NWwc0z8jMQqhy68ml03vA3Jzv9Lwy9G + xhgHpWi6kP1vpNdxzPvPXd/2xa27R9SocPbq5voTAKrK3g+sx6q+QCy3gXRXNCqEjS/V6rjjdjgZA75p + 6cTdcBnRC1+Fs/IcpClOwQo1A3Z4mP6vfhB97PuBwaaylWAlvzcWrvyRvdCfXCBs8r+Td4OqRbsLo0Wd + Pr/ecjBoHqyTM+gxQVufkE2i3HkqNfhNQgBoqcGn7LPUMn1T8Zrb2f6G9zO49kwcNM/9N0n4M4bD8Heh + lnDAdcw7Up73g9amGAKcsSpeksPpmQIAT/3RSlqiEYzovVbldlRfU9mcn9LGFybfcSoy+GVG/JYuIhuf + R/TCV+CsOheJNQXpG2zR+S04LS04F9zE0Xt/TVe8L8zuJIWwlYO2WOCNucaiD0verxZOVUq1x6S/U0Yg + l5pejQFOx382IRQ67vOTscIqe31FbVqg2WkJAaQlplFS+nNydWi5TjfJ6ZlYpX/tmQwvW4/Jh1/AEEAs + oWpfIAxCwA0UCIggRCD8LFg8uVhV/z4ejRzwrP9wpxsvy+G0CYDTPvEc+29dSfpYZBTRL4O8BKW9ZMNW + YvCTMlK+DNwTzuFsYNgzrd24Gy8netErcFaei8RipcGnULBEF6/g2FAnfn8/cxeAER3bgZTSpJ+sq29C + ICcSkFr+PJmRuhz8WgqmCUZadOw0bIw2pxNfW576UHpaUkZ4lqqj6IJ0MraMkvDnBIMXb6HnnCshHsdg + c/AXje650T9fGORBXzANyAmN8O804EMRx/mdIU0d2bp3lM3L4vUjAI4NKqYVhj/3h6Tv+dIdtM25HXhV + qYczaWv/BN8Z0zmya83DHXhVMa1dRDZdTvSiUNWvAPwCRKzFSyuHjxjEKHPmaKAJ6ESQnoBBrYLvaZXq + yT0TreC74xkpdeL5doXCvHLXIRXUVwyyFAq78YTruEIxvF+19K89g6E1m3OGvwy4JeAXkw91HvSm8HeF + hsHM73ixou9panb/xktZb/uhFBsWRqdHAPT2KskuiA7l2soOQ+y1n3Rb3/pJM/jZ3/+BDva8WFq6WyTe + gTS1ghMFJ8IYU4WWOclEU4J8b6P1g/x8yRHscB/afxQ72AO+xV13EdELb8BdVTjiK5UZTVQg3d+HTYzi + Wzhy2CBq6e7WXLJXrVTlHzsalfZTlwaywGjKBN6QCjwCWsF3Khol8655rHAqc70lhb2OY/Ev/50x91yu + jSsWJOWEXf45LOnmNo5efC3a3Byo/xlV3xQLgsJ5fUGQUN53xwqC3FoCETEi8g4v6d/t+/qjSGws7jUX + AD1Dwd1bAviNYKwwF2UDcLaB0/1h1je/4V9Wa2KoCcdFnEiQ/DFMpV1xmcx3M/N730f9NKSTaGoE0kmk + a3EWfLWVyZ6CyxBI9vRgUykEwfpw9IggKJ1dFGoCYzQdrRyichpPAQySM5hWCn+J72WuTVUyZtiikV5K + wF3O3lHahFG5wbASUGX83xZcU4n7GaMp6lhhW9Gy4cKT9m2+kKE1m5EQ/mJ3nilS+4vhlzxVv+B3ImOM + iGFm9DmI/Gkkah7x0/7BHQdSrF8cra0AODSozPOh1wkbYwDoYAFwvlWuQbkMWA10ELhAg11y4u3lH3Cl + UE+qCIHAcSEaR1o7c/X4JyBU8q4heawHm0oGP9cgL2jP0aCzdXQWOc9Kuqsm6uSVzPkpE0xDBXCUuzYd + qxIXX7yW+bGW4O+Erm2skNByxtIJ20/LSCNK2GwmMmaO85m1pDrm0nPJtRBrys39TWDUK4A/NOoVGv/I + CYPMlIAShkIKPwtfP0+UN69eHP37XQfTqGomdqC6AuDQoNKuMAwcd0CViAhn0s71KC9V2Ai0VvSgp6No + hccqqCcQACkck9t8xPrQ2yOIKu0dOU3gpPz8Ja5TdQIQykJQ6rxSXjhVMn3Ig1YYxxYxHmT54I9nMC1u + m4m0g3GF0zjtVirIagIBo2LoPf8qRpevywv6CeE3RfCP0QooOyUQKTIUjqkTjOCI8NbnDqW+b0Se3HXU + y15m1QRAz2Bw9yPBIBcT4WIjvAl4CcHGoKdMUU9JHesJowtNrpcGG9VwvDdAob2dwoSikx5dxvHzT1RH + hd/TcesoBW+JmIICprXIJlGJqj6J69N8l1CxG1LKX2uBq6+S9ptooNDsacQqI8vX0XvpteC6oesvHKVN + nsGvyKiXD78UTQkkD34JVIhsnZh8r0BWMKwT4c3xWOQDybRvqyYAeoYUY4LRzVGML5xjhN8HbgDmnkrg + ZwYHP5kkeax8thbrQ19v0Efa2vO6Ybkgk5KdvPC1TiRAJhkzkfW8VFRnGRqLrlnHnoCy3oAx72USwrFs + GGWRQNCin2g2sEkq8TSVaTcpuATFb4rTc+UNpOYuDIN+Ql9+EfzlIvykXHBQmZE/Fy6cqzOs/+ZUyv+y + CFv3HbMsnWNOTgAcHQzu2PPAGBZ58HbgrcDyUw78fMCTKVI9PYy3v5u1MHA86GgtbZkxaxJW+pIQVAIS + E08NioNeTsTaX3Q947vmJvBynOy1TGiTkAIbR+nrlbEVjxPNmF9f3xmXMHDGxbm5PkXquxSN7vnaQP6c + v9DPXxAslG8PkGwm9bzvBbaBVUbkVcvmmK37eoMrPCEB0DOi+InsW0eEF6jyAeAKpmGJcb0VP5EgeazE + Bq9a2F+thcH+YMxoaWXiDj4hcHkvxlV3GTcqrzI/epEFvYAaKSFsZJzPqUC4jfdZnto/xq4xcdtVZpCs + QADlnzZ8wMmFy+l5wSvQeHM49y9U3wut+Ix1+RVF/0merSBfMBQaAgs9AYacxiCGV+47rp8TYf+BPp28 + ADgyGIxT4oJAp8I7gXcDC0518HMMCdHObpL79xSO6mOnnFgLQ/1Br2lumditN/5nFajiE3T2iq3zBb1d + y4JZPLIWCo8KhVnZz6XEveskBEcFHpKK2j4ngPJVfxuLc+SFN5Fcujrn8y+auxeM2ibfuJdnD2BiW0Gm + XkTHfha+D3ZKk41GeL4qX1VlcluQHh4IA1mCre5WK3ycQAC00yjZDuI0t9C2aTOpw4dI7t8LBHaSzAY3 + kg0AyXkCvFRwzHUl6zqcqCOXXNJb8rcVGgYnfF/JQphxvAYVvy8tCLX4WialJZQ6XsE0ptR5KPMsir53 + /OKrOXbVKxDXLWm1Lxili+DPhveSWexTaCswZZYFl/zMFNgRXBFJCPJDEfyKBcDhQQ2erQURzgH+Bbge + pmgf4xlWYvPm0nnuBXiDA4zuehqsn8nwGs7HcgIgSJMY2lIEXLcIgnE6tFKBwBhHgMhEKv9kBUDm0MlM + ZcbRDgpWgpatq7wAEcaN0ykhHIo9Cvk1lf6pWMvI6k0cvvHt2I7usvBLgVGPwuMmXBhkyHMR5guLwteZ + vlXqMylyMYK2ifB9FY5VBO+RwTBqKQ3qcAXwbwKXlG6KRskA5bS20HHW+WgqyciObcEOwpIJ/MjbPjQv + 4NFLBVA6GU2gGFrN7+SVeA3C9Q3FG5Zq7vc6oYdAqCgcO+88QcRg8TknL2S0LJxF96VSvk1KTnPK/VYm + jLMYI2TyP7eWdNc8Dr3q90muXJ/1+RfM3U2+wY/MOv6c/744HqD4s/zFQVmhUcJjYArtA5Lbz7IZeBh4 + fEIBcHgwcIz4PuDwfOAzwBkNzCuTBCYeo+30c9B0mpHtW8HzsoYb8uGXnNPA9zK7WhcCWlIFriR4qbjz + llrfPm4dMikNIz+wLvcnuY1+yVtpPc77cUOFy17D+J/reAKsuA6doE3yj4UXbKNNHH3Zmxg874q8UX6s + Wp51040BuMRqwKLP8gOFilcKlltFWOSQcoCDHvLTcQXAwXDkVwvGcFkI/2kNsicpBKIRWjefhR0ZZmT7 + VsTaHPxSNDaHTmTfC5R745SIoMtXZCehPo/t5JLT4CYTM5A9No6br9J6JoA2p/ILZefjJXILFAckacEy + 5hJaa0X2BBnr5y84tdB/2UvpvfomJJKX5bdm8EsB4MWrAU1p+DPFN/DdsgJgpyqpKMQSgHB6CP/ZRY+r + USqTAZhYhJZNZ5LuOUri6e0F8OfvgJ0TAmD9nBCA/FReFcJfAbjjd/5x1OSic+kJ1TNZgTURoOXr0InU + +iLBWHpqUOLrmSQfqgyeeQk9N74NbWnPBeWUAFzy4C8d+ju+wU9OfOTPL67Aj8u6ATuOgzVghUWi/D1w + AaWSsjRKRRJAfXDa21n8tnfj9Rxh6IG7yDpti1zqWU+2hVTCompwY0XQTAgM5YUEjJ8BOUfNOHVXbhAs + X095qMcKFJ1Yeyj6TU5zkkm0kY7bbiU/spbRNafTc8Nb8Du6s6G+ZhLwSwXwZyP6Cub2hUuIpTL4AdoV + Ti+pARwcVNQAQlzgb4E30Bj4qyIInLZWmlasYfjxh/D7erOuHsi5CDPdLTMdsDb0HJiCbn0C1vXyPE44 + ypY7VvIccoJTivx/cuLXkOchOZHzFx4rYe0vSO5pSS5aydHXvIvUsrUIOnZhT1YlZ4yrT8YY9Ur9rrgO + KVwnkDUW5lYR5hn8SpOrRIBtYwTAgd4gOsAdBI3yZuADQLRBb/WEQGTefJyWNoYfvhdNp8IlmxKO/kWS + W4L1/OrbXCBJQceeQDUes+IwX/UuoVVUPI8vricrtiYBmOQlaM3/baXq+vj3o5OCvJS6P4FAtBZvzkKO + vvoPSGw4O4C/FMTZUb/QUi/jxfaXdPmVXw1YwZy/VDkwZgogrUAC/FbOAf4MaGlQW/3S+fxrGX3yMY5/ + 97+CFWN50yspE03rJS0OgolUCAkUpDBTyiTWHC/YpSww+Rc5zrxwXAFSGEas5cKEy9YnpVf1Vdo2Za6j + XLhysa/f65xHzyvfwejmCwrgL4zZJ5OeK/DBl0jxlYvWCwX+mM8oiuwb+7vM64nilorK0gIN4OCAomlA + aRHhI8BVDVRrUyTiEFuygpHHHsLvPZJL4gBjBuXsdABQP1SQTaW++SL4ywW0VCwAiqGbQICUq6MIVB2v + Hj05cMcVIBUKxEKDn8Vv7+bYq97ByLlXFKTuLlDthUK1vUT0n0j5xJ+moI6qjvyZkihcuOMEqiaiNyr6 + Cg0fTKE/t/F38n+KWogsW0H3TW9EmuKFOxOVGHnyU9fZlGLTmslYnvuD/EzmecdCaLVE6uviWILiiy04 + LmjoUsveh5bw7zPedYV1qOQdL7628a6hBPwlmm3iPyn6P/5frnKL197NsVe8neHzrszLw1d65M8Z6YpW + 9ZVYE5CNDzH5r8fXGIpH/kn+dWU1gP19fuAfdWQJ8A/AqsY4XWs1QIgsXEJy5zbSe54NekvxAEVhpGBW + yvvFB0qPekoZF12Fan8uzkWCoUBPcuQvUtk1bw1+ZaN/oXqULxiz1ziu5kHl5yo+porfMZfeV/0uIxdc + hRgzdiVfkZ9fxvXlF3kJKMzkk5/uq0BjKGFjONEemLUBiEoQH+TzajIuv0apbVHFaW+n64bXMLrlIXR4 + sLCfFrgHQ2NgGP2vAng2TKdocqnNS/VlzZu2V9LpxwiBEkttmcw8O3NTud8Vb9oxYYQelF3lWGDgHDP/ + n+y0oJRwVLCKN2cBva/8PUbPuaxwBB+zOo+80Tkz9x+7cq/kij8pWicSSv+CkT+cE57AnL+4RB2AfX2a + eT7LgI9yiqXwmt4iuHPnk3x6G6ndT4cPduw6gQwmmV2Gsthk9iAVKVBnJ+wVk7KQl5jzTxaoceCflAFy + grY8Ofhz0ZGa2SKCYB6TXric3le/k8TZlyDGFI7MZfz8E0X4SdGKv5xrb6wnQGRSQT4VD0EugFWIGMWq + XEcjzn9qiyqmuZmOa25g5MG70ZHhkhG/GRdh1lYQfiaAhpoAxsn16RNJcDoeuKWMbBPVWdbafwLAT/Y8 + E0WsaYk71dLLGpMrN9H3yneQXHd6QS7/UiO/MWM/MwVaQN4IHk758vP5F4/u5bwEJznyZ0rKOTCQGTNM + t8IHBVY3VvhNIf+Eq/+6uhnZ8jDpA3uDuSWlNADy9hnMex0mngRB5QTmuSU+V8qM/OPVOWaaMV7o6Dgh + zZqVeJUHHpW8PqlYsJTJ6Uli80Ucf827SIcr+8ad8+ct7ZVSXgFTeuQfGxtQHANQ9ZE/UwacweSbufLK + LoAXEGT2iTWwnPoi8Tg6NMTIQ/cGMcAlon5zX85fKiw512FoYLMi46yyk7F/OvZY4ah9AkOCjmOpL7VG + oCAISCaUUYWrDDWYAo25Ty1S50usTixpNlA0EmP44mvoe9U78OcvKR/eS2lXn8gEBr8SAqSkga96Br9S + 5YD7f/7PakRwVPVlQFsDxekrzedfgjNvAf6h/WRGQNW82IBiY17+IJk55tnAnWtMCcNaGSjLjqpQ0eKP + CacOlfyugvl6AaNSeL6SqcFLx8COmzzVWrSti8EX3czw5S+DeMtJwy+TgL8guWdt4Qc46oZ5zBYrXDm+ + d7VRalosuIuW0nTa2Qwd2AdOqNpLcRBK2G8l8Nzks501FPo2HN1M0TZ7E+zCciKGwzHfKae6aFXq14nc + BcUrJkt+VuZ3avEWr2bg5b9N8syLEMcJ9KFSufgY6+cvztYrpijTrymc/4+J7CM358dU1dpfruxzw+dy + PrCynjbpOfWKYpqaiJ99IUP/+9Ng84CsDzAEntwClzFdvCBOVRFrESPY/CTN1QB8wu9pGd5LaB3juSbl + RK+3aJlxJfVYBdcleeblDLz49XhL1wSjO4Wx+IVz97Hwj1Xzx1vxVwh/fsafKRj5M2W3m+gUifXpJUBz + A8JpFgEK8U1n4rR34fceDQODQuyLs1wXW7FlbJJQ4/uoAV/M5EHXceCtlsCYVFJPqex0k6mTIKbfdnQz + fOWNjFz+crS1A4MtyrQ7duSXchF+5az9RVGCZOMFcrv5SOhKmIKRH2AE2O5G+7Uz1AAaZdolALgLlxBZ + thLv2JEA+gqlf4GtIK8+scEqQitm3N+WL6Vi7iu8oEomk5MWRmU+k/FuRMY6NFTBGFJrz2To2teR2ngu + 4jgYtTnVnSIrfihoc0tyw8SdRZtxBnn4CzftyHwvm7ef/Dql6PPw/WTae/JlENjqAkuBtQ366kEAKKal + leiq9Yw+fD9qgkwzkBMEkp/RVwo7eemsPIohsAlYMRVp76UPahnoGB+6SQi/8vWV+KAi9yClDX7Wou1d + jF78YoavuB7bPS/r/2CcGP18Pz/5oz1l9uor/l525B+7dmCK5vz55TmBXS6WzQidDfrqpEQcoivXQCQK + arMuucxoEHgBpMDtN5aXnO2A0D1mCOqyE47KUgGQJaAbL9y4UoGj41xLpabpcW0LFoyLt+Eshl94M8kN + ZyOuGyzlpXBd/th5fWGQz5j4/aIFOmXdfiUSgkzhnD+/POr70uuqsIkpXPOfnxFXNZhPkV05prOuvkmf + XyGyZHmwQnBkiOywUTJNLmO2GysERgu04gB/U2gTmATgJSNty76Xsdem41VWKEkm3dITbB0mgD9nEYlL + X8roxddg27sxEqa7p/wqu1Kx/cXwl/9d0fqAcM6f1QqmZ+QHSAP3iqNpF1gNmJr5/zJ57kSwvs+RIwfZ + s+tpjh87iu95tLZ3sHT5ahYvW0Essyx2gv6RX9/RI4fYs+tpeo8dwfc8Wto6WLpiFUuWray8vhB8q5aj + hw+yZ9dOensy9bWzZHlQX1O8eeL6Tra5FNz5i5CmOHZ4KMeOMGafgPJegML3mhcxaFCs2rHTgZOZi+sE + B8ut6Cs5UsuJXUO576qF5jYSZ13GyOXX4y1dE8Tyh4uqDPkbc5baqLNozi8l5vxSIg/AmOOMsQcU2ADy + g7tq6YsP6j6kcL8ArirL5EQat3L2EYS+473cd+ftPPbgvfQfP0Y6lcKqYowh3tzCmvWnceXV17Fi9bos + COWXdgj9x49n6+s7fox0Kjmmvite9HJWrlk/cX0iDPT3cf9dv+DRB+7m+LGegvqa4s2sWruRK6+5jlVr + N2a171o9I9PWgWnrwOs5kpcJJE+7FfKcgYyx0UnR9t46ZnecIBbOMlHiuBMBcCL//AnCPNliLUSa8Nac + zujl15HceC5Em0LwtUS8fuGcPLt5ixTN+cfZpTebrC1//p8N2y6uI2/kL0pZXvO2Ue5F2aWA7O61TwEb + a3UuEeHY0cP84JtfZtsTj2CtzRvtFFXFWou1lnkLFnHDa36bzWedX1bdFhF6jx3lB7d9iae2PDxufXPn + L+SGm3+b08+5YNz6+np7+ME3v8zWxx/C+n7Z+ubMW8D1r34zZ5x7Ue0ejgj+QD8HPvAuRh/9DeIYpKLx + UUr3G8kkBAnqzoYGi+BjgrDhE+lsWuL0J9ppq9XZMzfnuvhL15G45KUkz7gYbW0vWMRTyl9fKsJPKojw + Kx7tC+srvyZApn7Onykp4B0W/jNuBBforiX8idFRfv7Db/HUloezxzJgZf4yxw8f3M/3b/synd1zWbJs + 5RhoRYRkIsEvfvgtnnz8oQnrO3LoAP/zzS/R2T2HpStXo3Zsr00lE/zix99h66MPhIyUr6/n8EG+/83g + +pavXluiviq1mxvBaWunlOVbJ+VZk4KpQoEZQRUjQcpxW42RudLVeiJUvcfngW8XrSJx/gtJnHkZtnNu + MM9Xmxuh80b1kuvuw0vNpmErGMXzP8wJbMlbzlCwy1MB3EW/y6V2Rac28m6HCr8M00ngAq01m3IIbH/y + MbY+9kDuWRXBlf8nIhzY9xz33PEzXvG6t+A4zpj6dj71OE888puK6zu0fy933/FTXvWGt+E4hTlQxcDT + 27ey5aH78jLLlK8PEQ4f3Mddv/oJr176DlzXrc0jcgzEmsJ9AIssaJrreHmNUMJNLwVZv8iDPzM90Dyd + 0zLxIpyS4JVIpzeRa9A6kXDpcgU9byK/pSq4UeyilSTPvoLk5ovwO+cG8/YwWYLk7cKSv4xKQ6GQS8oq + eRGXBVkXst/LLsu2gAlMDDaT/gsJzmg1XMqbAT3jxQm0i6xvp+ROp7UtIvK9lfPM3n3HYW234GqY8rsW + l5FOpdi25WGSo6OIMePClf/35JaHef611zN3/sICLcBLp3lqy8MkRkcmVd9TWx7hWM9R5i9cXFCfn/Z4 + asvDjI4OI1JpfbDtiUfpOXqYhYuXVt8zoKFkikTGHxnKWNzHTCF1/FR7WZuABBGxk9blK9qGu7BYwEai + VJxVqMSXRBVicfzFa0iecSmp9Wdh27sCw152NWXgDlWR/DvNtVqmbUzo4ZE8D0TYHoGhUDN5V4Jqbai+ + Ww3gF8nGawi5HZeNDXbUzsQPqA3zt9RACapwQN4rRr+585DVqBsMrm5w+zWRNCRHRzm4f09W5awEMICB + vl4OHdjLvAUL89zZwXTi4P69k6+v/zgH9+9hwaLFhfUlRjm0f092JKy0vsGBfg7ue45FS5bWQH3TMHzU + odCVllsaqGVDc6VA29asbMi3D+SWwWbNgUphnEGlq/JKJQmqpD18DxUX60Yq0jmCgVJzJ2rpwFuxkdTG + 80ktX482twbzdqvZRJpjrouxAlMlNzIXOCbyNK9CcSi57dRDI6qgiA3m+1a0YGpBni3AKohoHvzTsOJG + +JY60S3i+Zy1ULICwFMlWotpmed5jI4MB+8rBFZV8dIew4ODY+rzPY/RkSEy/u3J1DcyVFSfBvWNDA+H + m0dOoj4vzXBRfdV8SqoW9bzSO+NqBd64/Hl/QeptGbPzbv57QbGa+55U8pAnNXJnBIBFvRQ23jrWvVkO + fDeKdi0gvWozqTVn4M1bApFoqF6H47OQVamzckzyvRx5Ow9kBaCOTX1gcr+xqqHtIAgWshkzhko2gChU + CrIJxXL+AM1OAHLHdVrYB3YL+kWTTPhdLQ4SpgN1VRkFotUeyYLwSEMkEkWtDSPSKgNMjBAN58D5GbBy + 9YUj4WTqixbVJ2F90Wj4kCuvz8jY66tqw/kWm0qV1K7LJ8mRskwW/7fkjf6hkNA8G4ItqHOSFqJKJUdy + FNtisU0tlNnNM5jmtbTjL1pNevkG0kvWoC3tuYxJVgNrvUrBnopSNpuKjMltKgXDvBRFM+Y2axSV3Jzd + 5qq2eXP8DPaimpv/Z0d+QcQyPUVURP4z1h5/LDmU5ue7I9lPXKAP6Kj2KRWINcWZM38hB/c/F8ykKoDL + Wku8uZX5i5YU+q81qG/ugkXs37trcvXFW5i/eGlRzgglFoszd/4i9u56Gkzl9bXGW1iwaGnNBLn6Pv7w + UNmVssXbfOWnwtY8uPNzchSk984L282Mn+SN/IXnkRN7+BNJOd9DhvuxLR3BBDnzkI2BeCt2zmLSS1bj + LV6N39YdjvYBTEHGpNxEWkTz1vtkRnrJ6jGFuYfzd2HVvIzHpSRxDviMoS8Y+fM3MwtHdi30KEje/D/z + 2fQURYT7jcvnRwdG1TWGd5yfuxhX4RiwovrnVaKxJtafdhZPPf4QnudlwZsIsNXrT2POvIVFnV2JxmKs + O+0snnj0Abx0uuL6Vq3bxNwFi7IpozIlEouy7rQz2fLw/aTTqYrrW7l2A/NCAVULIWDTafzBgZIjVi4z + kBQsgMvN/YNRTPNI1qLjxVOArGCgUAhUxPKJj0rI6BBmZABv7hJoasHrXog/fxneghX4bV0QjeXyImo4 + f87unVgQCpUNwMncS36mJMmPdchEUlE0yo/BRjEF+ZiDub5IBvh8N6JmDYHBSJ/3n2mc8wc33G8M/+CP + 2L2mxfC8VU0Fn7rAAeDcWp1+89kX8tiD97LjycdK+tgL4fLp7JrD817wYqJNsTF+dlU47czzeeyBe9j2 + xCMV1dfR2c3zXvgSYk1NJevbdOZ5rNlwD08+/lAF9VnaOjp53gteQlM8XrM4AJscxevrrWwZvoyN9Kt0 + MC70CIy1ktcqJjVMw9frqO520skHEue/8NqR+atW2XhrMNJnwAlH+ny4c3Vokd1Rcnsq5i+SCt9rWStl + fnrlTM1B/gWbHycQVmvCixfRIiGQl8Q1lBsGauRfr7wY0S84uD9QJ/BKFBcXeK5WJ1dV2jo6ufaG1zI4 + 0Mf+PbvKQub7Pi2tbbz4xteyZsPpJeFSVVrbO8L6+tn33NNZkEvV19zSyrU3vIZ1m84sW19LazvXhNe3 + 59mdWaBK1RdvbuHa629mw+ln1wx+BPy+Pk9HRwQR5wR+Pt6ygDHfrfXYFLKQBnodIwdQ7neNPOnA/RH0 + 2Zc+/dNjnz7zC6/TkcRnVLXdaJ5BLxeCU/7isyKF8s6L/M1Xy914ZmPWrP4QHMxM+zOqvQ07XAH0mmf1 + z/tMa966E7S9yK9w5B/TeMlYxHD5mtYx33H+8M/+Zg1BRuCaRLUo0DlnLstWrWN4cIC+4z2kkslseK21 + Po7jsnTlGq579Zu54HkvwHHccS3dHd1zWLF6HcNDgxw/NrY+Y1yWLF/Ny1/9Ji66/IUT19fVzfLV6xkZ + HqTvWA/JMfU5LF62kpe/+k1cfMU1OG6ktqox+suhH33z//qJ0QfFSL8gjoAnQkTAzQ1uMmab7JLz9vwI + thKGMS14LeORNiHsBhICx1wj+xzhTkfkG03GfMUxfLTZkc+c1RX59oFR/z5gv8DIw+/5N7rWrN42mki3 + WKuXkQ2Rl+zon90MpWi0zRcS+dun5W+uUvCsixa9FKcXzL3Pm3gWJRvVAnuBFmQiznye8SjZafxTeMYY + 3p1K69b2Fvj5V9q4446/HfvMnu6xLwS+DsypsTRidGSYZ7Zv5eltW+g5fBDP92jv6GLl2o1sPP0cuufO + L2rgCeobHebZ7U/y9LYtHD18AM/zaOvoZOXqDWw841y65y2ASdSXGB3h2R1PsvOpTH1p2to7WbFmPRtP + P5c58xcwRueuTWN98PAH/+hvBn59B26UFpvw2hyhC5FzPWuXqa/zROR0YJm12qoQB1qBmAYmsULbQB7o + YzfDlAI7wBgPQf4YHEDlKyRRho0w6oj0Ac95qtujIkejRvb4yuOu4VhHRAafHkyPdEQdrELMCHEXUsOj + NC+cz1V33MFnf7wXEYi4pnNoJP2ptGffmMFaJPdsJH+fxPzjRQIim3AjIxqyqnne5/mfSf5rybvP4nNK + QZhvdtHPmOsTJthArWYlL2Skx3XMO4+PJr+xuCOOceGqjaXt/LKzxy4DfiywuZYXJnmS2fqWVCqJqhKJ + RHEjbhjVqRU1Ws3rs0oqmQjri+BGIpOq7yTbahT4LeC27ZeuJNLeiXo+JlzMY1X57mN7ee2Fq9o93zZ7 + aeuKmPkYXYeyQJVW32pEkW6BRQhdIO0KLQoRVYwiRlGTFRaBI80GO+CJL0JSkWFV+i0ct8phgb6IkaQr + 9CNy2Lf6rMLRZkfS8YiM3LZncOjKeS24oYSIGGhyhLZYhFTa46oHHyx7z5/7wV6sAXFYPJLw/9339WXk + KS35cfoixQpNKS2hMHa/ENxygiX3m0LBUXQdxecacw0ZcTk9+IvIoOOYDyyY0/KZ/sGEL8C1Z5V38smO + HhsX+Bzwuim82mxjVi2UNmsVr9P6Ki/7EK5BeWrtHMm2U+YR//Tic4imPNQI1lp8T3OLmIIGxbPCy69e + LXfdv6/J9zSqqq5n1bUa5H2wglhfUUSCDTVUwxVqKogag3VFvIiYdJNr0hf+eH7ivy49QNTJBdn5Grxu + cgTXgFUhGYty4333TLrb3/KrXfzy/z7OTW87k3iTu2Y06X/G9/XqDEoFcObZ9pCxo3wxoLnfSenfFU0j + xvyuhLApFh6FG7VMXxFh2HWcD7e1xP9v2kunQHnZOZ3j/2bnMQvKe4B/Ytptlo0C/Bi4GRhaN3fyUdq/ + uWAzLZriqGnBDyeoqgGwmcAlG2o5mrdE2OT1dhMubAmSWwrGWDqbRkl4ES675/Ga3PTXfn2YBYvbeOzR + wzS3RtclE+lP+lZfnAO6UEsrLQSKAoIKBELe6F4K6vwRHxkjAAoEA0WrB8NIQSqNoKxi0ZwPZDDiykda + WyKfSKdJgHD9+Z0TC42dPRbgAuCHCvMaEmB6Sl7H+UtP7Uei4rBm7qn1NL5y92Hmz2tj27bDxGOR5cmU + 9w++rzdp0UrcfBiz8/Uct2PALziWf7xgRM98qiUERwntoVgwTWO/MUZ6XNfc0t4e/Y9Uwk+pKq+4cG5F + v5cdPRaBdoVvAlc3UJzWcgy4DrjXIKw9xQQAwFfv7OH1l8/hMz/aS8yRuUnP3pL27VtUiRdY+QvALQwE + KhAGRd8vpSnkC5ZCDaK0AMn4FGXaH4/gGHk64pi/2LRq/rd3Hey1VpVXXTS34hpcR4WUsQOOlZ8ivKjA + DdooU1cCTe4hhK3AKQk/wBuumEvkzoOMJn3cZrenpTX6p8PDqac8z37AWhYTRgXmkrfkmi+3Tq8oDFg1 + u8oxuyRIi9yGaJEwKBIMBcBrGZfq1HUUEVHH8AvHkf/Tm/Dv3XWgF9/CTZfMnVRt8vRRJdxdfjPwQ2oR + FtwolRRf4T2I/otYw/r5DSn82Z/sxRjh7dd8m8/++MYrU2n9P761z89G6ZI/cuel8CihmksRsMV7KhTz + XFhP/qYMueCkqZzv50drOoa+iOt8LhaL/ONwMnlwfnOMpLW8+rL5k65XALYfVYwQsVY/rfC7DRanvgg8 + RaD+PyNIQwBkhMBP9xKNuPT1DtHe3jI/kUr/nufrO6zVxYV5e3INOSaUqRh+SpFbOjefjImpknGXMNcO + fjBgHcfcG42aj89tb/pR/3A6ffWm+dy36zjXX3Rimf0E4OB2n74OULgK+KbWME9go5R9EB/pSpm/Goii + GxY24M8v/3X3MVas7GbrlgO86qrFctsv917kefpuz9eXW2vbKTVrLVLlC1+WipSEknIhW5dM33IeIZjr + R5zPx5vc/xwYSB3s7oziecobn7/wZPsdbO1X/BEPgbgqn1fltY1uN6Xw7xKRG4AtjhhOW2RO+TYpVT7/ + swNEIw79w0m6O5vj/QOjV6XS3ts9X69S1Y685ftUpKKPN5KX0hqmsGS2fnMc82zUdb4Rizpf/u0Xvv3J + L/7qP5g3P8bQoMfNF88/6fNk7+sz2/dwaesiLPpCtXwd1Tk0ytQIACN/19ri/tXoqG/PWOQWBP80SmH5 + xoO97H+2n445TQwNpWhri7QkRr1L02n7es+3V6vqEjteRz8ZSKamN2AMCccxT7qu+U4s6n7rpssXbfvW + rw9qLO7ie5Y3n+SoX/LeHtifIIKD45pYMuF90qo2bAFT8rjZ6hh5pcIOxzGcvSTSaJQKylfuPMjrLl/I + 5362j1TKZ+GctmhP3/D6lGevsVav9X17llXmqaqZrO5e41DvsecL9gxIGEf2OUbujEWdn0Qjzp3/c+eO + wy+9bD3tzTE83+cNz19Qi/6XK/ftGs1EOZ3l+/abqo1dg2sKv5AyxvzRsaHhf13U0c7Zyxqj/2TLF36l + pEZ2EIm2MZpIMzySZMGC9raR4dQq39fnpX17jsCFnm/no3QCTVandYluZknHoGOkz3HNMwL3N8WcR8XI + fcsWtx58dnd/OuIa2lqa8H2fN1RxxB9XAGw7qvQNJHh2cJTlzbH3KHwc1caQVKvGN/I/Udf5LVX6XMdw + 3opoo1FOonzxf48QiboMD46SSHioWjZvXOTu3nOsK5mycxwjZ6U9f0Uq5bcaYYlxzCKCdHhRUKeE//Ck + JYUEO/EkVDnm+Xa/Y6SnKeYeFyNP+Z7u6O5sGvjmLx7rv+q89YhAa3MEM6gMLYJ3nL+49n2w+MB9z4yQ + DhaKdKq1/89afVWja9Wg4UV2O468zle9b0NHC4salv+qlq/+oI+DFz/J/CfWMJpIkUz6OI7gW2VgMME1 + Fy+L7OtJNCXTNmJ9a1StSEGygZJ4TLaoa0QdR/zm5kjqJWe0j37iu7s0FnGDvAEK7a0xmtwYVn1ee8Xc + KW+nknf4yYce5/TmVTgiZ3u+/W+rtds78JSEH0aN4f2Pbnr2M+dvW0dLU4TzVjVG/6kot911DMVFdZS0 + D74NFkaBze0gFLBbDQEQLqYSHFcwxmGgv43mlhHecHlnvfTFseW+nUl8L8WxFLQ4epPn62cVbcQGVKeo + 45h/jcfcP/U8OwLw/E2tjVZplPoRAAB3PjWID8Sbo25f3+gf+77eomisoaieIPVhYxsjP4pEI2/Dtwdd + heef2d5onEapPwEA8IutA1hVDLQk03pr2rPvCowljXIixRi5N+Kat6naJ1ec1cVh4KqG1b9R6lUAAPzw + keOIgmPoTKT1475v3xJmR26UCkrGjOwYeTQadX43lfAf6JrbTDoJL9ocbzRQo9S3AFBVvvfoIK5aQOek + Uv7fe779baChCVRYjJFHYlH3XaOp1D3zulrx1edFmxqqf6PMAAEA8Ktf7aKnu4OopxgxXcmUd0s6bd+h + qrFGE47fuI5j7orFnPemPPtQZ3MTClxzZlujcRpl5giAQAgoPa1HiKhDNGpahobT7017+sfWamdjOlBY + Mqn2HGP+JxY1f5ZI2e1zO2OkPeVl53Y1GqhRZp4AgGA68O37e3AdQ3dLk3vo+MirkmnvQ56v66ZzB5R6 + K0ZkMOI6/xGNRv7eptNH5ixoJjmS5iVnNzypjTKDBUCmfOe+HlzXsPWZPlYvaz1/NOH9jefrS1QbHgLX + kR3RiHPr3O6mrw8MeskD9x9i6RVLeGVj5G+U2SIAAL7/UC9RR+gZShJ1nTnJhP/WZMp/p+fb5adiQxoj + I9GI8+2mqPn4s/sGHt+4uhPfh5sumdfoZY0y+wQAwHfu6eHGS+bw9buP8prL5vFfdx6+cDThvdvz9Hqr + 2q5TnSR9qkuwnb11HPNQNGr+eV5n03ePDySHO9tiJFM+r2rA3yizWQBkyjfvPUY06tLXP0xbczTeN5S6 + JpX23+Z59vnh3nXVO9n08p4txoh1jGyNuOaL8Sb3v/t7EwfmLWjhQH+Sc5e0cvmZnY3e1SinhgAA+Pb9 + Axw8dJDurk76BhPM7WptGxhKXJVK+29Ie/Yqa3XejNYIwms3wqjrmkejrvl6U5Pz3Ucf3//cmacvpbUr + RnrU47WXzp+hN9goDQFQhfK9BwZYu7yNR7cdZWAowYI5zU29A8kzU2n/5b7Va9Npu1FV21VniNdABCOk + jJF9rmP+tynq/CDW5N65Z89gz+LFzbQ0N+F5Hq+/fMHMuJ9GaZRaCoBM+Z/7+7juwg6++r+HGEl4/P0n + 7udvP3DF3NHR1DmJpHeJql7mebreBrkH24IlmfXAuyBCEuiNuGa/iNwTizq/cYzcvWhh2/49+/vTsZhL + d1eEZFJ5zSWNEb9RGgJg3PL1e4/iOoaBwRSJpMf+YwOctWZe57G+xBzHMRekPH9zKukvdhyzGWGF9bXD + Wo1ZVVMrwSDByK7GMWnHyLDAQc/qU46RXfEmd7cq9zZFnX1vumphz2d+tNcaEVpaIhwdTbOmtYkbntcw + 8DXKzC//H2KEQtrPXsHrAAAAAElFTkSuQmCC + + + \ No newline at end of file diff --git a/RPST GUI/RPST/Windows/AboutBox.vb b/RPST GUI/RPST/Windows/AboutBox.vb new file mode 100644 index 0000000..57b89f2 --- /dev/null +++ b/RPST GUI/RPST/Windows/AboutBox.vb @@ -0,0 +1,82 @@ +Imports System.Runtime + +Public Class AboutBox + ReadOnly settings As New SettingsManager() + + ''' + ''' Handles the Load event for the AboutBox form. + ''' + ''' The source of the event. + ''' The event data. + Private Sub AboutBox_Load(sender As Object, e As EventArgs) Handles MyBase.Load + Me.Text = $"About {My.Application.Info.AssemblyName}" + + settings.LoadSettings() + settings.ToggleSettings(settings.DarkMode, "darkmode") + + LabelProgramName.Text = My.Application.Info.ProductName + LabelDescription.Text = "Retrieve Reddit posts that contain the specified keyword +from a specified subreddit. " + LabelVersion.Text = $"Version {My.Application.Info.Version}" + LabelCopyright.Text = My.Application.Info.Copyright + End Sub + + ''' + ''' Handles the LinkClicked event for the LinkLabelLicense control. + ''' Opens A MessageBox showing the License Notice. + ''' + ''' The source of the event. + ''' The event data. + Private Sub LinkLabelLicense_LinkClicked(sender As Object, e As LinkLabelLinkClickedEventArgs) Handles LinkLabelLicense.LinkClicked + Utilities.LicenseAgreement() + End Sub + + ''' + ''' Handles the LinkClicked event for the LinkLabelReadtheWiki control. + ''' Opens the Wiki URL in the default browser. + ''' + ''' The source of the event. + ''' The event data. + Private Sub LinkLabelReadtheWiki_LinkClicked(sender As Object, e As LinkLabelLinkClickedEventArgs) Handles LinkLabelReadtheWiki.LinkClicked + Shell("cmd /c start https://github.com/bellingcat/reddit-post-scraping-tool/wiki") + End Sub + + ''' + ''' Handles the LinkClicked event for the LinkLabelAboutMe control. + ''' Opens A MessageBox showing the License Notice. + ''' + ''' The source of the event. + ''' The event data. + Private Sub LinkLabelAboutMe_LinkClicked(sender As Object, e As LinkLabelLinkClickedEventArgs) Handles LinkLabelAboutMe.LinkClicked + Shell("cmd /c start https://about.me/rly0nheart") + End Sub + + ''' + ''' Handles the LinkClicked event for the LinkLabelBMC control. + ''' Opens A MessageBox showing the License Notice. + ''' + ''' The source of the event. + ''' The event data. + Private Sub LinkLabelBMC_LinkClicked(sender As Object, e As LinkLabelLinkClickedEventArgs) Handles LinkLabelBMC.LinkClicked + Shell("cmd /c start https://buymeacoffee.com/_rly0nheart") + End Sub + + ''' + ''' Handles the LinkClicked event for the LinkLabelEmail control. + ''' Opens A MessageBox showing the License Notice. + ''' + ''' The source of the event. + ''' The event data. + Private Sub LinkLabelEmail_LinkClicked(sender As Object, e As LinkLabelLinkClickedEventArgs) Handles LinkLabelEmail.LinkClicked + Shell("cmd /c start mailto:rly0nheart@duck.com") + End Sub + + ''' + ''' Handles the Click event for ButtonOK event. + ''' + ''' The source of the event. + ''' The event data. + Private Sub ButtonOK_Click(sender As Object, e As EventArgs) Handles ButtonClose.Click + Me.Close() + End Sub +End Class diff --git a/RPST GUI/RPST/Windows/MainWindow.Designer.vb b/RPST GUI/RPST/Windows/MainWindow.Designer.vb new file mode 100644 index 0000000..4685cb6 --- /dev/null +++ b/RPST GUI/RPST/Windows/MainWindow.Designer.vb @@ -0,0 +1,311 @@ + +Partial Class MainWindow + Inherits System.Windows.Forms.Form + + 'Form overrides dispose to clean up the component list. + + Protected Overrides Sub Dispose(ByVal disposing As Boolean) + Try + If disposing AndAlso components IsNot Nothing Then + components.Dispose() + End If + Finally + MyBase.Dispose(disposing) + End Try + End Sub + + 'Required by the Windows Form Designer + Private components As System.ComponentModel.IContainer + + 'NOTE: The following procedure is required by the Windows Form Designer + 'It can be modified using the Windows Form Designer. + 'Do not modify it using the code editor. + + Private Sub InitializeComponent() + components = New ComponentModel.Container() + Dim resources As System.ComponentModel.ComponentResourceManager = New System.ComponentModel.ComponentResourceManager(GetType(MainWindow)) + TextBoxKeyword = New TextBox() + TextBoxSubreddit = New TextBox() + ButtonSearch = New Button() + ComboBoxTimeframe = New ComboBox() + ComboBoxListing = New ComboBox() + LabelKeyword = New Label() + LabelSubreddit = New Label() + LabelLimit = New Label() + LabelListing = New Label() + LabelTimeframe = New Label() + ContextMenuStripRightClick = New ContextMenuStrip(components) + SettingsToolStripMenuItem = New ToolStripMenuItem() + DarkModeToolStripMenuItem = New ToolStripMenuItem() + SavePostsToolStripMenuItem = New ToolStripMenuItem() + ToJSONToolStripMenuItem = New ToolStripMenuItem() + ToCSVToolStripMenuItem = New ToolStripMenuItem() + AboutToolStripMenuItem = New ToolStripMenuItem() + CheckForUpdatesToolStripMenuItem = New ToolStripMenuItem() + QuitToolStripMenuItem = New ToolStripMenuItem() + NumericUpDownLimit = New NumericUpDown() + ToolTip = New ToolTip(components) + ContextMenuStripRightClick.SuspendLayout() + CType(NumericUpDownLimit, ComponentModel.ISupportInitialize).BeginInit() + SuspendLayout() + ' + ' TextBoxKeyword + ' + TextBoxKeyword.BackColor = SystemColors.Window + TextBoxKeyword.ForeColor = SystemColors.WindowText + TextBoxKeyword.Location = New Point(118, 20) + TextBoxKeyword.Name = "TextBoxKeyword" + TextBoxKeyword.PlaceholderText = "*Keyword" + TextBoxKeyword.Size = New Size(100, 23) + TextBoxKeyword.TabIndex = 0 + ToolTip.SetToolTip(TextBoxKeyword, "[required] The keyword to search for.") + ' + ' TextBoxSubreddit + ' + TextBoxSubreddit.Location = New Point(118, 49) + TextBoxSubreddit.Name = "TextBoxSubreddit" + TextBoxSubreddit.PlaceholderText = "*Subreddit" + TextBoxSubreddit.Size = New Size(100, 23) + TextBoxSubreddit.TabIndex = 4 + ToolTip.SetToolTip(TextBoxSubreddit, "[required] The subreddit to search in.") + ' + ' ButtonSearch + ' + ButtonSearch.Location = New Point(165, 165) + ButtonSearch.Name = "ButtonSearch" + ButtonSearch.Size = New Size(55, 28) + ButtonSearch.TabIndex = 6 + ButtonSearch.Text = "Search" + ToolTip.SetToolTip(ButtonSearch, "Hitting ENTER will also start the scraping process.") + ButtonSearch.UseVisualStyleBackColor = True + ' + ' ComboBoxTimeframe + ' + ComboBoxTimeframe.AutoCompleteCustomSource.AddRange(New String() {"Hour", "Day", "Week", "Month", "Year"}) + ComboBoxTimeframe.AutoCompleteSource = AutoCompleteSource.CustomSource + ComboBoxTimeframe.FormattingEnabled = True + ComboBoxTimeframe.Items.AddRange(New Object() {"Hour", "Day", "Week", "Month", "Year"}) + ComboBoxTimeframe.Location = New Point(118, 136) + ComboBoxTimeframe.Name = "ComboBoxTimeframe" + ComboBoxTimeframe.Size = New Size(100, 23) + ComboBoxTimeframe.TabIndex = 8 + ComboBoxTimeframe.Text = "All" + ToolTip.SetToolTip(ComboBoxTimeframe, "The time period for the posts. Default value is `All`.") + ' + ' ComboBoxListing + ' + ComboBoxListing.AutoCompleteCustomSource.AddRange(New String() {"Controversial", "Hot", "Best", "New", "Rising"}) + ComboBoxListing.AutoCompleteSource = AutoCompleteSource.CustomSource + ComboBoxListing.BackColor = SystemColors.Window + ComboBoxListing.FormattingEnabled = True + ComboBoxListing.Items.AddRange(New Object() {"Controversial", "Hot", "Best", "New", "Rising"}) + ComboBoxListing.Location = New Point(118, 107) + ComboBoxListing.Name = "ComboBoxListing" + ComboBoxListing.Size = New Size(100, 23) + ComboBoxListing.TabIndex = 9 + ComboBoxListing.Text = "Top" + ToolTip.SetToolTip(ComboBoxListing, "The type of post listings. Default value is `Top`.") + ' + ' LabelKeyword + ' + LabelKeyword.AutoEllipsis = True + LabelKeyword.Font = New Font("Segoe UI Semibold", 9F, FontStyle.Bold Or FontStyle.Underline, GraphicsUnit.Point) + LabelKeyword.ForeColor = Color.Black + LabelKeyword.Location = New Point(19, 23) + LabelKeyword.Name = "LabelKeyword" + LabelKeyword.Size = New Size(71, 20) + LabelKeyword.TabIndex = 10 + LabelKeyword.Text = "Keyword:" + ' + ' LabelSubreddit + ' + LabelSubreddit.AutoEllipsis = True + LabelSubreddit.Font = New Font("Segoe UI Semibold", 9F, FontStyle.Bold Or FontStyle.Underline, GraphicsUnit.Point) + LabelSubreddit.ForeColor = Color.Black + LabelSubreddit.Location = New Point(19, 51) + LabelSubreddit.Name = "LabelSubreddit" + LabelSubreddit.Size = New Size(71, 23) + LabelSubreddit.TabIndex = 11 + LabelSubreddit.Text = "Subreddit:" + ' + ' LabelLimit + ' + LabelLimit.AutoEllipsis = True + LabelLimit.Font = New Font("Segoe UI Semibold", 9F, FontStyle.Bold Or FontStyle.Underline, GraphicsUnit.Point) + LabelLimit.ForeColor = Color.Black + LabelLimit.Location = New Point(19, 80) + LabelLimit.Name = "LabelLimit" + LabelLimit.Size = New Size(56, 23) + LabelLimit.TabIndex = 12 + LabelLimit.Text = "Limit:" + ' + ' LabelListing + ' + LabelListing.AutoEllipsis = True + LabelListing.Font = New Font("Segoe UI Semibold", 9F, FontStyle.Bold Or FontStyle.Underline, GraphicsUnit.Point) + LabelListing.ForeColor = Color.Black + LabelListing.Location = New Point(19, 108) + LabelListing.Name = "LabelListing" + LabelListing.Size = New Size(56, 23) + LabelListing.TabIndex = 13 + LabelListing.Text = "Listing:" + ' + ' LabelTimeframe + ' + LabelTimeframe.AutoEllipsis = True + LabelTimeframe.Font = New Font("Segoe UI Semibold", 9F, FontStyle.Bold Or FontStyle.Underline, GraphicsUnit.Point) + LabelTimeframe.ForeColor = Color.Black + LabelTimeframe.Location = New Point(19, 137) + LabelTimeframe.Name = "LabelTimeframe" + LabelTimeframe.Size = New Size(81, 23) + LabelTimeframe.TabIndex = 14 + LabelTimeframe.Text = "Timeframe:" + ' + ' ContextMenuStripRightClick + ' + ContextMenuStripRightClick.Items.AddRange(New ToolStripItem() {SettingsToolStripMenuItem, AboutToolStripMenuItem, CheckForUpdatesToolStripMenuItem, QuitToolStripMenuItem}) + ContextMenuStripRightClick.Name = "ContextMenuStrip1" + ContextMenuStripRightClick.Size = New Size(172, 92) + ' + ' SettingsToolStripMenuItem + ' + SettingsToolStripMenuItem.DropDownItems.AddRange(New ToolStripItem() {DarkModeToolStripMenuItem, SavePostsToolStripMenuItem}) + SettingsToolStripMenuItem.Image = CType(resources.GetObject("SettingsToolStripMenuItem.Image"), Image) + SettingsToolStripMenuItem.Name = "SettingsToolStripMenuItem" + SettingsToolStripMenuItem.Size = New Size(171, 22) + SettingsToolStripMenuItem.Text = "Settings" + ' + ' DarkModeToolStripMenuItem + ' + DarkModeToolStripMenuItem.CheckOnClick = True + DarkModeToolStripMenuItem.Image = CType(resources.GetObject("DarkModeToolStripMenuItem.Image"), Image) + DarkModeToolStripMenuItem.Name = "DarkModeToolStripMenuItem" + DarkModeToolStripMenuItem.Size = New Size(132, 22) + DarkModeToolStripMenuItem.Text = "Dark Mode" + ' + ' SavePostsToolStripMenuItem + ' + SavePostsToolStripMenuItem.AutoToolTip = True + SavePostsToolStripMenuItem.DropDownItems.AddRange(New ToolStripItem() {ToJSONToolStripMenuItem, ToCSVToolStripMenuItem}) + SavePostsToolStripMenuItem.Image = CType(resources.GetObject("SavePostsToolStripMenuItem.Image"), Image) + SavePostsToolStripMenuItem.Name = "SavePostsToolStripMenuItem" + SavePostsToolStripMenuItem.Size = New Size(132, 22) + SavePostsToolStripMenuItem.Text = "Save posts" + ' + ' ToJSONToolStripMenuItem + ' + ToJSONToolStripMenuItem.AutoToolTip = True + ToJSONToolStripMenuItem.CheckOnClick = True + ToJSONToolStripMenuItem.Image = CType(resources.GetObject("ToJSONToolStripMenuItem.Image"), Image) + ToJSONToolStripMenuItem.Name = "ToJSONToolStripMenuItem" + ToJSONToolStripMenuItem.Size = New Size(116, 22) + ToJSONToolStripMenuItem.Text = "to JSON" + ' + ' ToCSVToolStripMenuItem + ' + ToCSVToolStripMenuItem.AutoToolTip = True + ToCSVToolStripMenuItem.CheckOnClick = True + ToCSVToolStripMenuItem.Image = CType(resources.GetObject("ToCSVToolStripMenuItem.Image"), Image) + ToCSVToolStripMenuItem.Name = "ToCSVToolStripMenuItem" + ToCSVToolStripMenuItem.Size = New Size(116, 22) + ToCSVToolStripMenuItem.Text = "to CSV" + ' + ' AboutToolStripMenuItem + ' + AboutToolStripMenuItem.AutoToolTip = True + AboutToolStripMenuItem.Image = CType(resources.GetObject("AboutToolStripMenuItem.Image"), Image) + AboutToolStripMenuItem.Name = "AboutToolStripMenuItem" + AboutToolStripMenuItem.Size = New Size(171, 22) + AboutToolStripMenuItem.Text = "About RPST" + ' + ' CheckForUpdatesToolStripMenuItem + ' + CheckForUpdatesToolStripMenuItem.AutoToolTip = True + CheckForUpdatesToolStripMenuItem.Image = CType(resources.GetObject("CheckForUpdatesToolStripMenuItem.Image"), Image) + CheckForUpdatesToolStripMenuItem.Name = "CheckForUpdatesToolStripMenuItem" + CheckForUpdatesToolStripMenuItem.Size = New Size(171, 22) + CheckForUpdatesToolStripMenuItem.Text = "Check for Updates" + ' + ' QuitToolStripMenuItem + ' + QuitToolStripMenuItem.AutoToolTip = True + QuitToolStripMenuItem.Font = New Font("Segoe UI Semibold", 9F, FontStyle.Bold, GraphicsUnit.Point) + QuitToolStripMenuItem.Image = CType(resources.GetObject("QuitToolStripMenuItem.Image"), Image) + QuitToolStripMenuItem.Name = "QuitToolStripMenuItem" + QuitToolStripMenuItem.Size = New Size(171, 22) + QuitToolStripMenuItem.Text = "Quit" + ' + ' NumericUpDownLimit + ' + NumericUpDownLimit.Location = New Point(118, 78) + NumericUpDownLimit.Maximum = New Decimal(New Integer() {10000, 0, 0, 0}) + NumericUpDownLimit.Minimum = New Decimal(New Integer() {200, 0, 0, 0}) + NumericUpDownLimit.Name = "NumericUpDownLimit" + NumericUpDownLimit.ReadOnly = True + NumericUpDownLimit.Size = New Size(100, 23) + NumericUpDownLimit.TabIndex = 15 + ToolTip.SetToolTip(NumericUpDownLimit, "Number of posts to go through. Default value is `10`.") + NumericUpDownLimit.Value = New Decimal(New Integer() {200, 0, 0, 0}) + ' + ' ToolTip + ' + ToolTip.AutoPopDelay = 5000 + ToolTip.BackColor = Color.Gainsboro + ToolTip.InitialDelay = 500 + ToolTip.ReshowDelay = 100 + ToolTip.ToolTipIcon = ToolTipIcon.Info + ToolTip.ToolTipTitle = "Tip" + ' + ' MainWindow + ' + AutoScaleDimensions = New SizeF(7F, 15F) + AutoScaleMode = AutoScaleMode.Font + BackColor = SystemColors.Control + ClientSize = New Size(239, 211) + ContextMenuStrip = ContextMenuStripRightClick + Controls.Add(ComboBoxTimeframe) + Controls.Add(TextBoxKeyword) + Controls.Add(LabelTimeframe) + Controls.Add(LabelKeyword) + Controls.Add(ComboBoxListing) + Controls.Add(NumericUpDownLimit) + Controls.Add(LabelListing) + Controls.Add(ButtonSearch) + Controls.Add(LabelLimit) + Controls.Add(LabelSubreddit) + Controls.Add(TextBoxSubreddit) + FormBorderStyle = FormBorderStyle.FixedSingle + Icon = CType(resources.GetObject("$this.Icon"), Icon) + MaximizeBox = False + Name = "MainWindow" + StartPosition = FormStartPosition.CenterScreen + Text = "RPST" + ContextMenuStripRightClick.ResumeLayout(False) + CType(NumericUpDownLimit, ComponentModel.ISupportInitialize).EndInit() + ResumeLayout(False) + PerformLayout() + End Sub + + Friend WithEvents TextBoxKeyword As TextBox + Friend WithEvents TextBoxSubreddit As TextBox + Friend WithEvents ButtonSearch As Button + Friend WithEvents ComboBoxTimeframe As ComboBox + Friend WithEvents ComboBoxListing As ComboBox + Friend WithEvents LabelKeyword As Label + Friend WithEvents LabelSubreddit As Label + Friend WithEvents LabelLimit As Label + Friend WithEvents LabelListing As Label + Friend WithEvents LabelTimeframe As Label + Friend WithEvents ContextMenuStripRightClick As ContextMenuStrip + Friend WithEvents SavePostsToolStripMenuItem As ToolStripMenuItem + Friend WithEvents ToJSONToolStripMenuItem As ToolStripMenuItem + Friend WithEvents ToCSVToolStripMenuItem As ToolStripMenuItem + Friend WithEvents NumericUpDownLimit As NumericUpDown + Friend WithEvents AboutToolStripMenuItem As ToolStripMenuItem + Friend WithEvents CheckForUpdatesToolStripMenuItem As ToolStripMenuItem + Friend WithEvents QuitToolStripMenuItem As ToolStripMenuItem + Friend WithEvents ToolTip As ToolTip + Friend WithEvents SettingsToolStripMenuItem As ToolStripMenuItem + Friend WithEvents DarkModeToolStripMenuItem As ToolStripMenuItem + Friend WithEvents SaveFoundPostsToolStripMenuItem As ToolStripMenuItem +End Class diff --git a/RPST GUI/RPST/Windows/MainWindow.resx b/RPST GUI/RPST/Windows/MainWindow.resx new file mode 100644 index 0000000..fdf1bd9 --- /dev/null +++ b/RPST GUI/RPST/Windows/MainWindow.resx @@ -0,0 +1,2475 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 243, 22 + + + 38, 22 + + + + + iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vAAADrwBlbxySQAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAFBnSURBVHhe7Z0H + nB11vb6potL/iIrtqti9XnuhCKETIIEAC6FFaoRQQg/dxQIIWAC996KICqgQBIRQhJBsyqYvqYT03nvf + ZE+Z9/+d5cdlmfNLsuWUmTnP8/k8LsLuOXNmvvO+M6fM2QEAAAAAAGKEHtauqtXHzP/SnTpOP1V3+/lj + s4/9u7vt53+bfzdftP/W336ONBvMmeZsc3XEvKkWNprv/LeF5iznBDO8nQa73Tr7+Zr5pN3n/9jPu+zf + XW8/L7L/f6rZyf7/1+3np8w93KIDlBSb3t20VseY92qdhplzzE3O2Wa9/bdfNv+O/a77MwCAymNl+VHz + O2ZXK9Mr7efd5uP2z4PNt8yVZsuyTooZc6451B7P38xf2j+Hj6+r+S3zw24VALQZO1Td20q9jxX8YlOt + dJHW60at0l7uZgAASocV3U7mZ83jrQAvt5+/sp//Mieam0xfeVaLm80Z7tmFR8wbbP2cpJ/pQPXVzm4V + ArwHK/Ljm8vcX/KtcZkdCHR1NwcA0DHCwrLy+pJ5uhXabfla/SO4U2PNRlPYZreYE8y+ti7vtHXa3fym + rd8PulUOVYZV905W3g9FyrwjPmD/u5O7eQCA7aP7tLuV0UFWRpdaOT0c1GqkuckUltzAnBGu9+aDLdsW + brNAirGi3tkK+y+RAi+Gf7f/3cXdDQDAu1jJ7GJ+w+xppfOIlc8EM+fKCCvvSts2d5j/z20ySCFaY2f+ + a62qS+E6/dbdDQBUM7pHe1uZnGBlf5eVyxCTM/tkuFR36kS3GSFFWEGfaEUdFBR38QzsAONkd3cAUC3o + Lu1vhX+GFf5DViLh2X2+RalgsgxsO95vkb6j27yQcLRce1hBL48UdilcZoeQvJwEkGas7D9oHm1FcY8V + RoNJ4adM27Z/sG3Mm7tSgBVzn0hRl9Lr3d0CQFrQT/W1/J3qk6vVICuHJjMsCUy3d7jNDwnFKnlXK+Vl + kZIupUvtf3lDIECSCd8ZbmXf1Urgf815LUoBq8ds+EkNNxKQQLRGR3hKurSu0eHu7gEgKehm7Welf37w + Ez1v4d+Y/4mVAFa7U1TDBYWSihXy/QUFXXrvdXcPAHFGtfpE/g5dGdRqoJV+zlMAWOXm7tCZblwgYVgZ + j4+Uczkc5+4eAOKGlf6Hrex72dn+EAv4fDTwESO+4UYHEoQV8b5mvkUxl8u81mgftxgAUGms9PexM7kL + gp/oVc70sa3a/HzKjRIkBK1WF085l8d16uwWAwAqQfgxrmytjrYz/cfMjTkLcsT2aAeNPd1YQUKwA4B7 + 7Uw8fFNe+V2ru9xiAEA5aarVf2Z/ovus9Bf7whyxzdbqD268ICFYEY8qKObyOcwtBgCUGjvbf3/uDtVY + WPcvCG/EjlqrF92oQQLQCn3MSjh8Ld5XzuUwr+X6qFscACgFTbfraxbQD1n5rzXDd2wjFt38HWpwIwcJ + QKvVy1PK5XUtLxsBFB0723+fhfJZ5rCWIY1YQoe68YMEYAXcv6CQy+1aveIWBwA6im7RR+xMrI+F8fxI + OCOW1tv1nBtDiDlWvPtaAWcKCrn8Nmm19naLBQDtIXO7vpu5Q09k71CTKcRyawcBD7pxhJgTi6f/35GX + AQDaR7ZWh2ZvVz9fICOWUzsAOM2NJcQcK96xBUVcOce7xQKA7RG+vm9n/Odb6L4ZDWHECpm3ufyQG1GI + MVqlgzwlXFnX6jtu8QDAh67X7na2f62F7aJI+CJWVl7/TwxWuH8pKODK+0e3eADQEjuz2iNzm3pbyC42 + w7BFjJe36lA3rhBjws/da7UaTcXMTdqgD7vFBAAr/n0sXO8wV70nbBHj5UtuZCHm2Jn2/Z7yjYv3uMUE + qF6an+q/TX0yt2uNKcQYu7bxVn3SjS7EGK3XflayGyKlGyc32tLt7xYXoLrQNfqAnU1da6G6PBKyiHE0 + 23SbTnHjCzHHCvbuSOHG0Z+7xQWoDtRTu1qYXmrlvzASsIhxNZ+5Q+e5EYaY03zd/3if/b/jelvWA9xi + A6Sbpjt0moXp9Ei4IsbZ1Ta3J7sRhgRgxfp4pGjj6yr9xS02QDrJ3qqD7QxqmCdcEePsgM21+rQbY0gA + zZ/7X62goGjja2DL/AO3+ADpYctt+nz2dv0zc5uFKWIyzJsDsrepkxtjSAhWpztpjUZ7SjbuNtj/7uQe + BkCyUa32arpN95pNphBj7kLzKSv+izbU8vnspGJn0td4yjUZrtGV7mEAJBPtoB0zt6uHhemSFuGKGC9v + 1Sz7+ZjNas+m2/VVN76QYLRSX7YijeNFf1rrZjuAYRYhmWRu1fcsVEe+J2gR46AV/pZb9fstt6mr+vB1 + rGnD6nMXK8/RZvimuuS6Wm/Y/+7qHhZA/Amv4GdnUg9Y0OYLghexMjZmblN/+xleYOrbblQhpVh5/qyg + TJNrrXtYAPHlnaf7LWiXRcIXsRKutDP9P9lZ/gm6Uru5MYWUY4V5rJlrUaBJN6/VOsE9PID4Eb67P3Or + XvOEMGI5XWU+tuVWdVGt3ufGE6oErdAXrDDXRAo0Da7Wcn3OPUyAeBCG7ObbdacdADSZQqyA6630H918 + h45QjXZ2owlVhpX/nlaUb0aKM01OMfdyDxegsmRu0TfsTGusKcQK2GD2tIPQPdxIQpVi9birleNLLcoy + na7UC/a/u7iHDVB+wi/tsbOu+y18cy3CGLH03qZ5m2/TT+3ngW4cocqxQtzRyvHPBWWZVlfqCftfLhIE + 5WfzrTrMgnhGQTAjltYBTbeqG0/xQxStyv9GqwIrxypyZf737uEDlB7V6v121nWPBTFn/VguN1vpP9Z0 + i/7LjSHAe9Dq/F3egqwGV+f56mAoPZtu17ftzH+yKcQyOL/xVl2/9ibt60YQ4D2o+Wn//K+9xVhNrs7/ + jpcDoCTYWf8ujbeojwVyUySgEUvh7C23qXf4bJMbQYACrPB20cr8n7XSChDNfPieAK4WCMVjy0363OZb + NNoT0ojFdpLN2tm8vg/b4+2P+gUv+Yuwqn1By/k0DBQBC+Me5npTiKVyyy16ozF8Y98O2tGNHsBWCS+E + Y0X3ZqT48F2naqW+5FYXQNvQjdrTgvnxaFAjFtm5W97+/D6vXUKr0Gp1toJbEyk8LHSdVqirW20ArcPO + xL5nwTwzEtSIxXSxFf+lVv28XgmtInxtWyvzP7Niy0eKDrduTivyteF7JdxqBNg6m+xsrPEWNZlCLIEb + zHvCZ5jcyAFsl+bv818ZjImUG7be0bwkAFslDGQL5qdaBDViMQ0ab9VjG2r1YTdyANsl/FibVukaK7DN + kULDtttoBwFXhevUrV6AHXbYeIu+YQE9IxLYiMXxVjWYP3DjBtAqrKy+a6U1MlJi2HHf0God4lYzVDOb + btHFFtKbC0IbseMu3XyzLuCd/dAWtEIHaFX+YSsqXusvnYHZV6v0SbfaoZpQ+NW9N+t/G2+2oEYsrjnz + gdV9tLcbN4DtoiXaXyvzd1sxbWhRVFha19s6v0vr9SG3GSDtbLhZ+1tA17UIbMTieJOm24Hl4W7UALZL + c/GH71RfEX5szUoJK+FGOxB4QCv0MbdZII1sukXf2nSz5plCLKLZxvDd/VdqNzdqANtEq/QDK50/W/k0 + RsoIK2ejbZNHtVLfd5sJ0sLGm3WBBfWWSHAjdtTRG/voa27MALaK1mpfK5deVjTjI8WD8XO8bavLwm3m + Nh8kkfAqa4036z5PcCN2xKaNN6kP1+2HbaHF+pAVSQ8rlH5mU4uCwWSYM+u1XL1tO37cbVZIAlb+e1hQ + PxcJbsQOaQeUU8KXk9yYAfwfWqN9tEInaUX+l1YcI828KxJMvuG2tG0ablvbxrat3WaHuNF4qz5uYd0Q + DW/Ejmjl/5iu1+5uzKDKab5E7wodYaVwn5VD+NQ+hV89htt6wtvb3maAryKOB4036nubbtISU4hFcsWm + PjrZjRhUOVqq3ZufFl4RLG5RCFjdrmj+RMcq7eXGBMqNhXSXjTdpkynEothHAzfdogPciEGVo5U62cJ+ + eST8Ed9xmVaoixsXKBd2lnahBXa2IMAR22dgPsC39kGIpJ21PP+QBXwQCXzEqIFW5n8bzowbHygV4eVW + N9yk2kh4I3bE9Rtu1uluxKDKCb9ERivyj3uCHnHrLs//NZwdN0ZQbMKzMwvrv0TCG7EjTlp/s77gRgxg + h+Yz/+VhoCO21fyDboygmOgafcDC+sVIeCN2xL/zLn9oSfh6rj/YEVvpCp3kxgmKwfJa7bGxj173BDhi + ewzCl5H49j5oiVZrbwvwpQWBjtg2F/PpgCKx4Xp9eEMfjTWFWAS3bLxR57jxAvg/tFw3e8Icse0u0w1u + rKC9bO6jT1lgT4sEOGJ7XbH+Bv3QjRfA/6EZ2s2Ce3FBkCO2z0WS3ufGC9rKuhv0+Q03ar4nxBHb7o2a + tPk6/YcbL4D3YGdsx3pCHLH9LtVRbrygLay/WV+y0F5UEOKI7XPgqlpek4OtoxX5e70hjthu83e78YLW + QvljUb1Jz4efIHHjBeDFAntYYYAjdsihbrygNWy4WV+x0F5SEOKI7XB9H/1VtdrFjRfAVrGwnhMJb8SO + OsuNF2yPTTfpmxbYK80wuBE75o26h4/5QWuxsN4UCW/EjrrRjRdsi43X678ssFeaYXAjdsTAvM6NFkCr + 0LJgoynEIrrBjRdsDQvrL5pLXHgjdsRg3Y26wo0WQKuxsJ4dCW/EjjrTjRf4CK/BbqG9OBLiiO2R8od2 + Y2E9LBLeiB2VNwFujXU36XMW2osiIY7YHoN1N+hKN1oAbUbL8vd6Ahyx/S7N3+XGC1qy5jr9h52tzfcE + OWJb5cwfOoyW6RhviCO216U60o0XvEN4bX8L7GmmEDssZ/5QBJovBbwsWFwQ4ojtc6Emcyng97DqSu1l + of1GQYgjtsO1N+gWN1oAHUbL1ccT5IjtkE8ivYfwamxrb9RgX5Ajttkb9Ds3WgBFofnrgJcFSwrDHLFN + LtIK7enGCtRTu1pov2ihHQY3Yse8Xo9xkR8oBXbmdpwFeBAJdMTWGmi5TnDjBGFQW2j/uSDEEdtnv/CA + 0o0XQNHR0vyDnmBH3L7L8791YwQhdub/c0+II7bd6zWUL/aBUiNpRzsI+KOWWqAjttZl+b/Y7OzkxgjW + Xq9L1lpwIxbB2Rtu1v5utABKigX5znYQ8IAFe1AQ9Ijv1WYk/+twZtz4gJ2tnWihnY2EOGJ7XLeqj77q + RgugbGipulrAL4sEPuI7LtUSnejGBULW3ajvWWhvioQ4YnvMrL1RR7nRAig7Wq49LORvsLDnQADfcUn4 + UT87QNzdjQmErLhRH7PQXhgJccT2epkbLYCKImkXOxA4Qkvy91kBTDDzLQoB023OHNd8yeglOjycBTcW + 8A7Le2mPtddrvCnEjrruev3KjRZA7NAa7RM+/aul+butHIabHBCkx7Dw623b3mXb+ITwGhFus4MP1Wqn + dTfoeV+QI7bDV1XDm2ogOWih9tMy9bDi6Gc2uSLB5OhKX721Qge4zQqtYfX1um+NBTdiEZy//jp9yI0W + QOJofnZgmS7VkmBspGQwbi4LGmxb9eQsv51YYF8QCXDE9rpl3XX6rhstgMSjJfqeluYfsbLZVFA+WCk3 + 2jb5gxbrO24zQXtYda1+EIZ2JMQR2+Xa69TTjRZAqrCy+ZCW5GutfNZGygjL5wYr/ge0XB91mwXay8be + +oiF9oJoiCO208fdaAGkluYDgcXhm8uC9aawLK6z4v9Z+D4NtxmgI6hW77PAro8EOGJ7Hb+Ay/xCFRG+ + 0cxK6WErp3ykrLB4BlqSf4wz/iKz+jo9vOY6C27EDrr2Om1efY2+5kYLoKoIX4e2ohoeKS7suGO0TAe7 + 1QzFYtV1utgOAIRYFK/lYj9Q3YRfItP88bMlQWOkxLDtbtIS9bJ1yleGF5vV1+u/LLQbC0IcsX2+zHf7 + A7yNFutLVmCjI4WGrXeUFumLbnVCMVlxo/a0wJ4aCXDEdrnqOi1b1lsfceMFAMbblxzO32lllouUG25d + W1e6nUv0lpA11+lpX5AjtsNg9fV8ixbA1tBiHW/FtjpSdFjoKltXx7rVBqVgzfW62hPiiO3zWj3kRgsA + toKW6UAruEmRwsN3nWDr6LNudUEpWHmNvmehnSkIccT2OSf84ig3XgCwDd7+OuKgX6T4cGnwHF/HW2LC + oF51raaZQiyK1+k4N14A0Aok7awl+Ue9RViNLs0/zuv9ZWDltXrcG+KI7fNPbrQAoA2EH2vT4vyvtNgK + sJpdlP+drYud3GqBUmHl38MT4IjtdfHam7SvGy8AaAd2EPALbzFWhfmfudUApWTtDTrQAntdJMAR2+3K + a9TNjRcAdICqfCZgSZ43DpcD1WoXC+zR0QBHbK+rr9VzbrwAoIM0vxywJP8nb1Gm0vxjPO1fJiywa6MB + jtgBG9der8+48QKAIhC+CU5Lghf8hZkq/xU+VvewoZSsuFrfWnmtMqYQi6EdAPzEjRcAFJHmjwguDiZF + CjM9hp/z56N+5WHGldrNAnvSymssuBGL47zFPfVBN2IAUGS0RJ+2slxZUJ7Jd1V4IST3MKHUrLhGv/YE + OGK7XXGturrxAoASoUU6xgozFynQJJu3A5vO7uFBqVneW4dZYOejAY7YXu2A8mU3XgBQYrQoX+sp0mS6 + RHe4hwWlZsE1+oAF9vRogCN2wNyq6/QVN2IAUGKa3xS4OBhZUKbJs8Eey67uYUGpWXWN7vcEOGK7tZl6 + 2I0XAJQJLdaXtChoNJVQN2mhvuAeDpQaC+vvrbCzNTN8yhaxGDauulKfcCMGAGXEDgKu8hRrQtTl7mFA + qVGt3rf8Wk3yBDhiu115tX7uRgwAykx4wRwtDkb5CzbWhk/9c7GfcmFhfWc0vBE74vJrtHJ1H+3tRgwA + KoAW6iAr1CBSsHE20AJ93y0+lJoV1+oLK67WFlOIRfRqN2IAUEG0OP9XT9HG1PyjbrGh1GgH7WhBXRcJ + bsSOujC8mJQbMwCoIJqrA6xc1xeWbexcr+X6qFtsKDUrr9GPPOGN2FE5+weIEVqYv8tTuPFycZ73DJWL + tZdp3+VXa5kpxCK6Ynkv7eHGDABigBZqPyvZOD8LsFFLtL9bXCg1y67Ww57wRuyYvdXHjRgAxAgtyt/n + Kd6YmL/bLSaUmvAz/xbW+YLwRuyAdlC5asWN2tONGQDECC3TR6xs43hxIM7+y4V7499IX4AjdkSbK77u + FyDGaGH+US200o2Ti/J/dIsHpcaC+vzlvS2wEYvrhvB9JW7MACCGhJ+x95ZwJZ2v77jFg1ISPj1rQb04 + EtyIxfAhN2YAEGOsdMcWlHDlHO8WC0rNsqt13zILa8QiG6y8Ql9yYwYAMUYL85eZVr6xsKdbLCgly6/S + 5y2omyLBjdhhl/bWS27MACDmaJ72teLNRIq4EjZpFpcLLwsW1M9GgxuxSB7jxgwAEoAWBK96CrnMBi+7 + xYFSsvRK/cBCOoiENmIxnBx+ssSNGgAkACvgSwsLucwuyF3iFgdKRRjOFtLDIqGNWByv0qVu1AAgITRf + E2BhPldQyuUzrzlc97/kLLlSpy+9SkIsgRtXXam93KgBQILQwtwITzGXydwwtxhQKtRTu1pIT4+ENmKx + 5Ks7ARKKFuXv8ZdzWbzLLQaUivDpWU9oIxbF5b11qBs1AEgYdhZ+ohZYGVfE3AluMaAUzDlf77cDgAW+ + 4EbsqEuu0jTe/AeQXMKP4FkZ5wrLueSGr//v4xYDSsGy3rrOF9yIxdAOAG50owYACcXKeFyknMshV/8r + JeH3sS/trWW+4EYsgtkVV+sAN24AkFCsjO+LlHM5vNfdPZQCOzu73QzP0hCLb2+96EYNABKMFmQ7eQq6 + xOpwd/dQbOZcrX2WXKm1phBL4eKrdJ4bNwBIMGrQrlqYX+ov6hIY3pfdp7t7KDZLrtBPfKGNWCQ3r+7J + 9bsB0oIV840FRV0q5+evd3cLxSZ87d8CekUksBGL5tIr9KwbNwBIAVquPayclxWUdbENz/6Xand3t1Bs + LJxv8oU2YrFcepW6u3EDgJQQfi7fSjooKO3iGWh+7mR3d1BsFvfUBy2gl0UDG7GIbgqfZXIjBwApwkr6 + gUhpF8/5+d+4u4FSsPgqXbvYQhqxhD7txg0AUoakna2oHzXDwi6mf7Pb3sXdDRSb8Jr/Fs4LImGNWGzP + cSMHACnEinonzcs/6Cnx9hi+pPBAeJvu5qEULLpCFyy+wgIasXTml16qD7uRA4AUo/nZ46zAF0YKvS0u + 1fxcV3dzUCrC67FbOL8ZCWvEorrkCg13IwcAVYBWaE/Ny/e2Ml8QKfdtudT+ppZr/ZeJpZfrJF9gIxbV + K3WbGzkAqCI0We/TvOxRWpC/x87q663kZ5kbnfbPuaH23+5u/h37XfdnUA4snAcXhDVisb1c33IjBwAA + lWZJL313kYUzYim1A4DFfPUvAECMWHS5nvAFNmKRfdSNHAAAVJrwHdkWzFsiQY1YdBdfoXPd2AEAQKWx + YK5ddLkFNGKJXdxbn3JjBwAAlaShp3a1YF4YDWrEEjjbjR0AAFSaxb10jieoEUvhn93YAQBApVl4uYaZ + Qiy1i67QBW7sAACgkiy4Ql/zBTViKZx3mT7rRg8AACqJHQA85AtqxBK4yI0dAABUkgXX6AMWyqsjIY1Y + Ehdcrn+50QMoOZqh3TQve4zm5e/VvNww+znH3OScbf+u3n7+svl37HfdnwFUB4su14W+oEYsib10uxs9 + gJKhWdrbir2PudhUK11k3mgHAnu5mwFINxbII80wmBFL7oLLdYIbPYCSoAXZ412Z+0q+NS7ja2ch9cy/ + VP+5IAxlxDI5p5c+6sYPoKhI2knz8w95Cr29PhDeprt5gHRhgXxfNKARS+hCN3oARcWKemcr7L9ECrzj + zs3/3W57F3c3AOlANdrZAnlxJKARS+bCy/W8Gz+AomJF/ZAZFnbxnZP/rbsbgHSw4DJ19oU0Ysm8XHe6 + 8QMoGpqbO9GKOigo7uIZaE7uZHd3AMlnYS896Q1pxBI5/3J1d+MHUBS0XHtYQS+PFHYpXKal2t3dLUBy + mXO19rFAbowGNGIptYPOb7gRBCgKCj/q5y/sUni9u1uA5GJhfNH8y+yMDLF85hf31AfdCAJ0GDVoVyvl + ZZGSLqVLeUMgJJ75vfSaJ6ARS+kcN34ARUFzs0d4Srq0ztHh7u4BkseSK7W/hXE2Es6IpfYVN4IARcEK + +f6Cgi6997q7B0geFsSXR4IZseQuuFR8lAqKipXx+Eg5l8Nx7u4BkoeF8ZBoOCOW3F7q5UYQoMNonva1 + Ms5Hyrkc5jVH+7jFAEgOC6/UJyyM8wXhjFhi5/VSFzeGAB1G83JdPOVcJnOd3WIAJId5l+qqeWEYI5bZ + OXwEEIqIFfG9mmNlXBnvcosBkBzmX6o6OwgQYrld3FMfcmMI0GE0JzfKU8xlMjfMLQZAMlh4ufazIM5G + gxmxDG7WDtrRjSJAh9B8fcyKOF9YzGUzfB8A32oJyWH+ZbrAE8yI5XCGG0OADqO5+V6eUi63Pd3iAMSf + eZfpBU8wI5beH2ugG0OADqO5QX9PIZfZgOtaQDJYep52tyBuLAhmxPL4hBtFgA7R/PG/OflMYSGX3SbN + 0t5usQDiy/zL1HWuBTFiJZxzqR5wowjQIWLy9P878jIAxB87A/tfXzAjlkM7AKh1owjQIax0x0ZKuJKO + d4sFEF/m9tTcuT+2MEasgPN+rN5uFAHajebqIE8JV9ZZ+o5bPID4saCnvuYLZcRyaQcAPdw4ArQbK9y/ + FBRwpZ2b/6NbPID4YeHbxxfKiOXSZpDLAEOHCD93r9n5RlMxc5Nm6sNuMQHixdxLNcgXyojlcv5l+qEb + R4B2YUV7f6R44+Os/D1uMQHiQ/jxvzk/VpMpxEo581L9pxtJgDajhdrPinZDQfHGx42aof3d4gLEg7mX + qLMvkBHL6fyeOtCNJECb0Zz83Z7SjZs/d4sLEA9mX6r7fYGMWE5n9dSn3EgCtInm6/7H++z/Hddrrg5w + iw1Qeeb01HhTiBW1F1+cAu3DivXxSNHG2b+4xQaoLOG3/1n45gvCGLHMhrPoxhKg1TR/7n92PoiUbJwN + NEc/cIsPUDlmX6IzfGGMWG5nXKm93FgCtApJO2l2brSnZOPtnHxDuOzuYQBUhtk99TtTiJV2zvl6vxtL + gFahWflrvAWbDK90DwOgMljwTogGMWIlVC1nRNB6NFdfthKN40V/WutmzdBX3cMBKC+zempvC95cNIgR + K6FqtLMbTYBtojrtolm50ZplRZps31CDdnUPC6B8zPqxTvAFMWIlXHCNPuBGE2Cb2NnzzzxlmlT5Fkwo + P3N+rLt8QYxYCcNnpNxoAmwVzc4ea6WZi5Roks1rVu4E9/AAysPsSzTEFGIcnHkpX5YC20az9AUrzDWR + Ak2DqzVTn3MPE6C01NVql1mXqNEUYhyccbE+4cYToABN1Z5WlG9GijNNTtEMPgoLZWDGRfqmL4QRK+X0 + C/VZN54A7yF8o5xmBS95SjNlBi+Eb3B0DxugNMzsqR/7QhixUs69WF924wnwf0ja0crxz4VlmVqf4CJB + UFIscB+JBjBiJZ39Y33djSfA/2GF+JtIQVaDv3cPH6D4WOBOiAYwYiWdczHXR4f3YkV4V6QYq8eZfHUw + lICl52l3C9xcNIARK+rF4qNQ0Ix72v/XBaVYff6OlwOgqMy8RAfPvNgOMBHjZQ83olDFNF/lb2b+z6YN + BWpG/gmuFghFY8Yl6uUJX8SKOuMiXeNGFKqU5o/6zQxe8hZhNRt+OmCy9nCrCaD9WNg+HA1fxBjIa55V + THghHCu7NwvKD99xquboS251AbSPGRdrlCd8ESvrJfpfN6JQZWhmrrMV3JpI4WGh6zQj19WtNoC2EX7j + moXtpoLwRaywsy7W025MoUpovsDPzPzPzHyLksNtm9OMfC0XDII2M/1ifdkXvogxsM6NKVQBmq4v25n/ + GE/BYavMjeYlAWgTMy7W6WZ43XXEuDnJjSmkmPBjbXYGe42V2ObCUsM22mhexUcFoVXMuEh3mOE7rhHj + 5mo3ppBSNEvf1azcyEiJYcd9QzN1iFvNAH6mX6R/eIIXMRbOOV/7uFGFFKG5OkAzcw+bedMKC0tgYAdX + fe1A4JNutQO8FwvZ8dHQRYyL0y/RN9yoQgrQDO2vGdm7rZw2RMoKS+d6zcrepWn6kNsMALYz1monC9lN + 0dBFjIszL9Ipblwhwbjir9WMXPixNdu4WAE3amb2AU3Vx9xmgWom/L716RayiHHVDgK4GmCC0YzMD+wM + 9M9WPo2RMsLKGW6LRzU98323maAasbOr432hixgbL9QDblwhIWie9tWMfC9zfKR4MHaG2yh/WbjN3OaD + amHaRbrCG7qI8fF5N64QY8LXl+1Mv4eVSj+z6b0lgwkwZ9Zrer63bcuPu80KacYOAH5tZ1jhWRZiLJ1x + oSa6cYUYoTnaR9NzJ2lm9pdWHCPNvCsSTL7hthzZvG3DbWzb2m12SBN2APAvX+gixshN4eWq3chChXj7 + Er3ZIzQ9e597ap/Crx7zmp6f0Lztwxngq4jTgYXrpEjYIsbOqRfqi25kocxognZvflp4Zm6xpxiwOl3x + 9ic6tJcbE0ga2kE7TrtQG00hxtmpF6nGjS2UEQv6k83lLYIfsaXLzC5uXCBJzL5YH/GFLWLcnH6hfurG + FsqApJ0t2B8yAxf0iFsz0Mzsb8OZceMDSWDa+fquL2wRY+dF+pcbWygxb38xT+7xSMgjbs+/8gVECcKC + tVtB0CLG09lubKHEWJA/pOkW6Iht90E3RhB3pp+vK6ddYOGKGH+DGefwhqNSY+XfxRPqiG3xJDdOEGem + X6h7PEGLGEunXKCD3ehCCdAs7W3hvTQS5ohtdTGfDkgAU8/XE1MtWBGToB0AXOFGF0qApuVv9oQ5YjvM + 3+DGCuKKhWpdNGQR4+qUC/UPN7pQZOyMbTcL7sWFQY7YLhdpst7nxgviiIXqlGjIIsbYhW50ochoRvZY + T4gjtt9p2aPceEEcmXqhVntCFjG2Tu6hT7nxhSKi6dl7vSGO2F6nZe924wVxo6GndrVADaIBixhnp1yg + s9wIQxHRtNwwb4gjtt+hbrwgbkzroY9PPd9CFTFBTjlfv3MjDEXEwnpOJLwRO+osN14QNyb30DctTMNA + RUyMdhAwzo0wFBEL602R8EbsqBvdeEHcmPIjHesLWMSYm+OCQMVH03IbTSEW0Q1uvCBuvHW+unvCFTH2 + vvUjnejGGIqEhfXsSHgjdtSZbrwgbky9QJf5whUxAXK98SJjYT0sEt6IHZU3AcYVC9GbIqGKmBR5c1GR + 0dTsvZ4AR+yA2bvceEHcsBC9OxKqiIlx8kX6nBtlKAKanj3GH+KI7XRq9kg3XhA33jpf/2MKMYlOPl9X + ulGGItB8KeBpucUFIY7YPhdyKeAY89aP9HczfEMVYhJ92Y0yFAlNzffxBDliO8xf58YK4ogFaL9IoCIm + ycYFNfqAG2coAs1fBzwtt6QwzBHb5CJN1Z5urCCOTOmhAZ5QRUyMU87TcW6coUhoSvY4C/AgEuiIrTWc + nRPcOEFcsQAdEQ1UxIT5P26coYhYgD/YItARW+/07G/dGEGcmdJD4z2BipgkV9R10i5upKFISNpRU3N/ + NIXYaqfl/mKzs5MbI4gzk3+kaaYQk+xb5+sYN9JQRCzId9bU7AMW7EFB0CO+10BTsr8OZ8aND8QdC8/5 + 0TBFTKCPuJGGEmDh3tVc1iLsEd91Wm6ppue4NHfSmNxDy00hJtxVDT21qxtrKAGarD00NX+DBT4HAviO + SzQlf50maHc3JpAkLDjXRoIUMZG+dZ5413EZUJ120dTsEeZ9dkAwwUogHykFTK852+bjmi8ZPSV7eDgL + biwgiVhwbogGKWISfauH/uLGGsqI5mif8OlfK4S7rSCGmxwQpEcr/Fx9eD1/TcudEF4jwm12SAMWnJui + QYqYUNfOOV/vd6MNFUJTtJ+VRQ+zn5VHU4sywWT4dulPzffWWzrAbVZII2/2UJMpxDRoBwFnu9GGGND8 + 7MDU/KWakh8bKRmMnfkG2049OcuvIiwwc74gRUyk56nOjTbEDE3LfM+K5hFz03uLByvoRk3J/UFTM99x + mwmqCQvNoCBEEZNrMKWHvuDGG2KIpulDmpKttfJZGykjLJ8bmq/vMFkfdZsFqhE7Y8qb4ZkTYlr8pRtv + iDHuQOAuOwNdbwrL4jq9lf1Z+D4NtxmgmrGwbIqEJ2LSXco1AZJD+EYzK6aHzXyLosLiGl7J8THO+OE9 + WFhujIQnYvI9V6e5EYeEEL4ObUU1PFJc2HHHaEr2YLeaAd5l0nlaYwoxZf7bjTgkiPBLZJo/fjYl1xgp + MWy7m/RWvlf4pU5u9QK8FwvKZZHgREyD+bfO1ufdmEPC0DR9yQpsdKTQsLW+lRulqfqiW50AfiwoF0eC + EzEd9tB/uzGHBNJ8yeEp2Tut0HIFBYdbM2dn/bdziV5oFRaU8wqCEzEdbp50lj7iRh0SiqZmj7diWx0p + Oix0lR0wHetWG8D2mXSuZppCTKk/caMOCUYzdKCm5Cd5Sg+bzU/QdH3WrS6A1mFnSVM8oYmYFpcPr9EH + 3LhDgmn+OuIpuX6F5VflTs09x9fxQruYeK4mmEJMreeppxt3SDiSdrbSe7SgBKvVt3KP83p/9TC5RntM + 6aH9Jp6tfd2/6hgTz9Fwb2gipsepqtVObuQh4YQfa9Pk7K+s/MICrGZ/F35s0q0WSCETztUXraNvsgwb + Yi5tkWmhWXPshHP0PxPOU5e+NdrZ/VnrsRt4pcUNIqbVU9zIQ0rQlOwvPKVYJWZ/5lYDpJCJPXSQZdbr + kQzbngsmnaeb2/SV6Hbk8KTnhhDT5nieBUgfVflMwOTcQ+7hQ8qYeqH2tKx6IpJdbXXam2frCHeT28Z+ + +eHIHyOm0/NU48YeUkLzywFv5f5UUJLp9TGe9k8nk8/RVyynphXkVvvMm1e4m946E87VfRPPsT9ATL+T + 2/U6GcSa5gsGTc694CnLtPkv3vCXTsadrc9bPi2J5FWHtX6vdXfhZ/y5un1C+IuIVeD4c3SuG31IEc0f + EXwrP8lTmikxP4GP+qWTCefpw5ZNc6NZVSztQOBsd1eFTDhbV/n+CDGlTq/rxFlUGtEUfdrKcmVheSbe + VZqkA93DhJRhBf2UJ6eK6aax5+gr7u7ei/3HH0V+GTHVjj9HF7rxh5Sht7LHWGHmIgWaZPOanOvsHh6k + jIln62RfRpXAV9xdvpeJ5+oUzy8jptk5MzprN7cLQMrQ5Gytp0iT6ZT8He5hQcoIM8iyaHYkm0rneTrS + 3fW7jD9bR3h/GTHF2pF3H7cLQMpoflPgW7mRBWWaOPMNatCu7mFByphwrm7wZVMJfdrd9buErw14fhEx + 7a5vOFcHuN0AUoYm6kuanGs0w8/NJ9FNmqIvuIcDKaPhLH3IMmhtJJNK7eaR52gvtwhvE15TeLz9R8Sq + 82w96nYDSCGanL/KU6zJ8M385e5hQAqx7HnIm0kldsJZ6uIW4W20g3a0hdlihoGIWE3m7QD4225XgJQR + XjDHynRUQbnG3nwDF/tJLxPP0pcsezKRLCqXhS992r+cG/klxGpxaHgQ7HYFSBmakj3ISjUoLNnYasua + +b5bfEghljmvRTKonP7ZLca72L8cEfklxKpxwtnq7nYFSCF6M/dXT9HGVV6WSjHjz9IZvgwqm+foKbco + 72L/4bmCX0SsEu0AYN6E87jKWlrRWzrAinV9pGjjqC2jPuoWG1JG+F3+ljcLovlTTsedo7+7xXkX+w// + E/1FxGpywln6jdsdIIVocvYuT+HGzOzP3eJCCplwju71ZU+ZLXyGaexZumOc/UfEKjY3obt47TWlaIr2 + s5KN87MAGzVD+7vFhZQx/ix91TImE8mcSlj45UB2VNDT84uIVeXYszVxco3e53YLSBl2hn2fp3hjYvZu + t5iQMlSrnSxf6qN5UyHPd4v1LuO668RxZ9l/RKxy7SDgdrdbQMrQJH3EyjaOFwfi7D/FjO+ua3xZUxG7 + q5NbrHd540x92fvLiNXnlq1+cxYkHk3KPao3rXTj5R/d4kHKmHCePmOZsiGSMRXTTnD+wy3au9Sdr/fb + f8xHfxmxGrUj9hHh03Zu94AUEX7G3lPAlXVS5jtu8SBFhNcXsTzpH82XCprd6leh239cEPllxOr1bPV2 + uwakDL2ZH+st4oqYH+8WC1KGnW1f5s2WStlds92iFTL2LA02hYjNbhl7pr7udg9IEZqUv8xfxhVwcr6n + WyxIEQ1n6kDLkA2RTKm0A9ziFWJHCI96/gCxmp08vEYfcLsIpARN1L5WvpmCMi6/TWrQ3m6xICWET7Nb + n4705Ell7a5H3CIWYv/xNu8fIVaxb5yl37pdBFKEle+rkTKuhC+7xYEUYblxZzRHYqF1vFvEQuwXzrJf + CH8JEd81eONMneR2E0gJmpS/1FPI5fYStziQEiwvvmNmWuRHbLSTmXPdYhYy/mx9z/dHiKhlo2u4Rnua + cNcEyHlKuVzmue5/uhh3vvYZ112zPPkRC8edoUPcohYyqof28/0RItrRc3e9yNcGpwtNyo3wFHO5HOYW + A1JAmA2WE89EcyNOTjhPH3aL68dCbrkZhh0iRj1Tt7pdBVKA3sze4ynm8jgpe5dbDEgBb5ylq72ZER+X + u0XdOvYgBnr+EBHfNj/2THV2uwskHE3KnWhaGVfAibkT3GJAwhl3pr5r2dAUyYq4+bpb3K0ztrse8Pwh + Ir7rynHd9Wm3y0CCCT+CZ2WcKyjn0pvXOO3jFgMSTPjSuWXCnEhGxM/WfJrJfrFnwR8iYtTxDV30Qbfb + QILRpOw400q5rHL1vxTQt0Y7Wxa8EsmGWNpwli52i711xtbooDfOtD9AxO35hNttIMFYGd8XKedyeK+7 + e0gwlgG/iWRCbG3oru+7xd469V21Z8OZCkwh4nbt5XYdSChWxp0i5Vx6J2YPd3cPCWXMmerhyYO4GoTd + 7hZ929gvz4n8MSL6zYw5S8e4XQcSiBq0q5Xy0oKSLp1Lw/t0dw8JZPSZ+q7t+5sjWRBnt/4lQFHsl/tF + /hgRt+56vjQo2ejN7I2eoi6V17u7hQQyvkYfbzhDCzw5EFvfOEPPu8XfPvYHd0dvABG36cKR5+gTbheC + hKHJ2sOKeVmkqEvhUk3Q7u5uIWHYPr6X7esTIvt+7B1zhn7hHsL2GXOmuvtuBBG36RuTa7SH240gYYSf + y7eCDiKFXUwDu4+T3d1BwmjoqV3tzP81z34ff7vrbPcwto/9wYEFN4CI2/cMvRh+NMjtSpAwrKQfiJR2 + 8ZyY/Y27G0ggtn8/UrC/J0Q7qf9P9zC2T3hN4zFnaIUZPnWAiG3QDgJ+73YlSBjqq53tLP1RK+uwsIto + 5m+q0y7ubiBhWIne6dvXE+L6Np+U2B+9FLkRRGy9tW5XgoQhaSc7CHjQX+RtNtCE7APhbbqbh4Qx+kz1 + 8uzfSbK/eyitx/7oJ5EbQcQ22HCG+rjdCRKIxmePswJfGCn0trhUE3Jd3c1BArHyP8f25Xx0306So8/Q + T93DaT2ja3S878YQsdUG4dmD26UggWiq9tSETG8r8wWRct+WVvzZWq71n2zeOFMn2T6ciezTSbTtXzo1 + qpv2sz8MIjeEiG0z33CGfuR2K0gomqz3WakfZeV+j/2s18TcLPvnjW9r/zwpO9T++e7m37HfdX8GCWV0 + dx1l+25jZF9OokHY5e5htQ374xmRG0PEtpsLP1rrdisAiDFvdNcPbZ/dENmHk+pU97Dazugz9IQZvoaA + iB2zyezidi0AiCFjuquT7aebWuy3idYOAP7qHlrbGXW6rhxdYzeEiMWwyfapGrd7AUCMsP3zcHNji/01 + 8Y46Q5e6h9d2xpymb/puFBHbbc52St4TABAjxtToGNs3U1X+zm+4h9h2VKud7AZWRm4QETtmYPZ2uxkA + VJBRp+sk2x83t9g/0+LGuk4dvPiUHRk957lhROyYge1bN7jdDAAqwOjTdY7ti9nIvpkKLV8GuofZfkaf + oat8N46IRfFOt6sBQBkJXx+3/S8f2R9T45jT9RP3UNvP8Bp9bZTdGCKWzP/mC4QAykP4XTdWkHd69sNU + Ofp0HewecvsJV5bd2LLojSNiUX01/K5xt9sBQAkIXxO38n/Ys/+lzXXh1xe7h90x7Maejtw4IhZZC6aJ + o7vrk263A4AiUlejPWw/eym636XU59zD7jijT1evUafbjSJiaT1N88OX3dyuBwBFwPapj9v+NbZgf0up + I0/T5e6hd5yRNfqK704QsSRusB247V/gAQAFhNezCQ+sPftZarX8+Lx7+B2n+X0Ap2th9E4QsWRminoU + D1CFWPGfZfvS5si+lXbnuodfPEaerj+YQsTyaTvzEw1d9EG3GwJAKwhPWkecrlrbh4LoPpV2LTP+6FZD + 8bAbPjl6R4hYBms0fsxp+qzbFQFgGzTUaG8r/2e9+1IVOOI0neFWRfGYcJ52txvfHL0zRCyL68yT3e4I + AB6Gn6Zv2n4yq8V+U23mh9Rof7c6ioudifzbc4eIWB6DUafrnvA7OtwuCQAO2zd62D7SGNlnqs0GtzqK + z4hTdeXI0+xOELGSvjSyqz7idkuAqqa+q/a0feLxyD5SnZ6un7nVUnxG1egz3jtFxLI66jQtH3Gaurhd + E6AqGX2qvmv7w/To/lGthi+BuFVTGix03jLDNxogYoW1Hf6x8P05bvcEqArCd/lb4fW2faApuk9UsXPC + 9eJWUWmwwLnPc8eIWCFtn3xzVDd93e2iAKmmvkafsrkfGN0PUL92q6h0DK/R4Z47RsTKusW8ljcIQlpx + n+2/2OZ8XYu5R+fIGh3qVlXpCAPGzjgW+xYAESvryFM1fPRp+qrbXQFSQcOpOsDK/3nfzKN5upaW7eDf + DgB+510IRIyDW0acqp9MrtH73C4LkEjCs37rmwttptdGZhxbaAf+/+tWWekZ3k2HW8AIEWPtdDsz6OR2 + W4BEMbxGn7MZ7h+ZafQ4spuOcaut9DS/DHCqFplCxFgbmA+Hn5V2uy9ArGnoqV2HdVMfm9stLeYYt+6a + sj/bZ3f6UGQhEDG+LhjRTeeU/GNCAB0gPJMddqqmeeYXt+5jbvWVj/rT9UPPgiBivB09/HQd7HZjgFgQ + Pt0//DT19cwrbs/TdIpbjeWDlwEQE2swvJv+Ut9VH3O7M0BFCL+5zwrsPpvJpsiMYmvspnV28PQBtzrL + y4jT9IB3oRAxCW4wb647X+93uzRAWQhf57fyutzmb1mLecQ2OuzUEnz3f2sZcaoO8S0UIibKebYvXxyG + stu1AUqCu47MWTZzMyMziO0wfCnerdryE76hyI5AZgzrZkciiJh0Z9pZWY++NdrZ7eIARcNm63ibsXGR + mcP2O7Pib+oddopu8ywYIibXKRwIQLGo76ZDbaYGRmYMO+op+olbxZVj8Mn6pC1MvmDhEDHpTrTwPrVs + lxiF1BCemdafqq5WUmM8c4UdNxh6mj7rVndlsYV5NbJwiJgep9uBwKUVe7cxJIbmN/edqrNtZniqv7QO + dqu88gw/RWd5FhAR0+UK8x4+PghRwitNWg/0tjP+eZGZwRI4vJsudKu+8oQfI7KFWh1dSERMpY313fS/ + Q7vpCy4CoEqxwj/QvN9mYl1kRrB0bhrZWXu5TRAP6k/Vf1soCBGrxnz9KepvBwI9eHmgegjfEzL0NB1t + RdTXZiAXmQksvU+4TREfhp2q71oYCBGr0uUWTPfVd9UXXSRAygjf8G3b+I6hp2iBZ/tjmRx2io51myRe + 2MJNii4sIlaVgZXEYAupc7nCYPJp6KIPhtvStmt/M3zGx7fNsXzOju3Hc4eerF6eBUbE6nSdlcdjQ7vp + pLJ/XSm0m7BghnXTkbbdHrVtuD6yTbGSdtMNbjPFj7oa7WELubZgoRGx2l3TfDBwsrpwyeH4Eb6ub+Vy + qG2fB+pP1hLP9sPK2ziqm/Zzmyye2EI+GFloRMSWrrCDgYetaE4In2J20QFlJnzjZnhA1rwtTtGyyDbC + +PmI23TxJXwT0NBTFJhCRNymJ2uz/fy32ZuPFZaeulP1CTvw+rGt735mY/M2wERoB2rfcJsx3tjCvhZd + eETEVjjL/H34voH+NdrbRQq0k6Enal87yOo25BQ9ZOv1rRbrGZPlULdJ4099V3X1PABExLaYtwOBCfbz + 9/XddM6wU/UfLmJgKww/SR8fcrJOt/X1a1tvY8ycW5eYYOtP1pluE8ef8F2kdtQ52wyf4kNELJYLreCe + tJ9XhW9aq+ZnCcKrwQ3uqsOGdlVv8++2Tua1WE+YHhcl7o2zQ7rqBs8DQUQsqnZ2NMd+vmA/f1F/is4Y + 3E1fruukXVwUJZ4w/MP3Vg05RafYwc8t9lifNmeaQfj4Md3aNr/DjUJyCD+uYAu/KfpgEBHL4GZzsh0U + vOhe/77OSvTUIV30reE1+n8upmJD89n8yfpa+N4HW+7LbbnvtZ/PmVPNjOl7jJh+m+pO0EfdmCQLO3J5 + 0AyPYBAR4+Ra801zsBXvs/bzD+YvhnbVtYO76kdhEQ/qpoPswOHb9V301fC710NfD09sTtS+4TVPXMy9 + fW388M12zjCwh52iA8O/HdJNhw/pqhPtPs60A5HLzNvtfsJcfNL+/SD7OdlcY/qWETF+1/1vLeGbduwB + ZCIPCNuoBUlu7KXBjJk/D0Ys/kNu0Npnc4M312VH50dk38qPzs0PxmSXqCG7Rm9kc83aP4f/Lvxv4e80 + DcqODv8m/NvpdwYjx14WzAhv03dfiIgYCwM7EP26q9NkYke5j3seGG7DEWdq7fSfBiNXP5UblKnPjgsa + shut2FVMw9sMb3v1k7m68KBg+FmchSAixsau6udqNLmEb8ixB5MveHD4Hkedr4XzH8gNabIzeyvopmhh + l8Fcdlh24pI/5QY1XBLM8S0jIiKWya46xNVosgmPZMzwAWEL62u0cf5vckOyw7Nvegq5ouZHZt8Mly1c + Rt+yIyJiieyiOlefyae+iw71PsgqdVyvYNr6frkhVrQbosUbOxuy69c/nxscLrPvsSAiYnEd1FXHuPpM + B/aghg62B1bNjr0smNbYPzvcSjUww3JNlJkh2TcmXBG85XtsiIhYFEe72kwPQ7voJM8DrQrHXx5M2Twg + O9pKNJHFHzFoGpAdOe6yYKrvsSIiYvsd0kWnuNpMD9pBOw7qqvG+B5xWh52hNWufzdVZaYYfzfOVaZIN + 1r+YHTWiu9b6HjsiIrZN68g3w650tZku7AF2jT7gVHqygnm/zg0JRmdXeoozbS6fe19QHz5m77pARMTW + eo6ry/QRHtkM7qJRngedGkecq2VNg7NveIoy1YbvD7DHvtS3ThARcbvOStN3WHgZcqKOs4MApdEptwTD + g4bsMl9BVoPB6OyqqXcEo33rBhERt+6gk3SBq8l0M6irhgwKH3BKHHyKMmufyQ32lWIVGti6GDSkm7b4 + 1hUiIhY4OfwafVeR6aauiw71rIBEWn+mVmcGZ8d6irCqDa8qOPwsrfStM0REfNfBXdXV1WN1YA/6tehK + SJpjLgzmBqNys3wFiOFLArl5Yy4KZvvWHSIiNj/9PzK17/zfGgNP1vd9KyMpTrg6mKgx2bW+4sN3Dd8X + MNHWlW8dIiJWvSfqh64Wqwt78C8UrIwEOPGaYIKV/wZT2Co3vXl9MM63LhERq9gXXB1WH4NP1JdtBWQj + KyTWTryO8m+nGyddF4z3rVNExCo0P/CkhH/ff0epO0n/YyoJTry6ufw3RYoNW+vo7PrxVwWTfOsWEbGq + 7KK/uBqsXoZ01v62ItZ6V1CMHHV+MC8YlV3pLTZsi6tHXxDM8a1jRMQqcXP/LvqUq8HqZuBJutGzgmLj + sDO0Kj8yN8dTZtgObV3Orz9Tq3zrGhEx9XbR/a7+4OXO2s1WyuyClRQDB5+iLZkh2fAd/94yw/aZGZQd + O+gUZXzrHBExrQ46Sate76b9XP1ByKATVeNbWZV2zdO5Qb4Cw4675pncYN86R0RMqwO7qJerPWiJrZwh + 0ZVVSafeEoy2ogqixYXFc+odwSjfukdETKFjq+aSv21lQBd9a+BJzR+NUKUdfk6wJBiVWaUxGSsqLJW2 + jlcOO1tLfdsAETFFBgNO0GGu7sDHwBP014En2sqqpLahmgZlxvoKC4tvU11mTLjOvdsCETEd8rG/7fHq + sfqwrajVkRVXVmfenavXaCsnLJuz78sN9W0LRMQUuPb1rvqIqznYFgNO0qWeFVgWh5ymNcHozApfSWHp + DNf5kNO11rdNEBGTbN1J6u3qDbZHba12qjtRw30rstSuey47xFdQWHrX9M0O8m0TRMQE+2bDt7Wrqzdo + DXUn6BsDTlTWVLkcc0kwzYooHy0mLJvZ0T2D6b5tg4iYQIOBXXS4qzVoC7byfh1ZmSV1c//sSE8pYRnd + /Fp2lG/bICImzpP0N1dn0Fbqu2pPW4kLClZqCWy4NJhiBRRECwnLbjDmsmCabxshIibINa911cdcnUF7 + GHiCThtwgq3MErv59cxoTxlhBdz0SnaEbxshIibI812NQUd4/QS96Fm5RXPUhcF0Kx7O/uNjMObiYIZv + WyEixt3XO+vf2kE7ugqDjhA+jWIrdXV0JRfLtc9kB3tKCCvoumezQ3zbChEx5q7jq36LjK3UC163lVts + 607VRo3KrPeVEFbOYFRmY7htfNsMETG2nqierragmNjKfa5gZXfQeb/NDbYDAGH8nPXL3FDfNkNEjKkD + eeq/RIQvBdgKXh1Z4R0yOyTzpq98sPJmBmUm+rYZImIM3fhqF33G1RWUgv6d1cOz4tvlsLODRVY0QbR4 + MD4OOy+Y79t2iIhxsv+JutLVFJSS1zvrWd8GaKsLHsoN8pUOxsdwG/m2HSJijBwWXsLeVRSUkn8fpwPs + IGCVGX7cot1mBmXG+UoH42PTgEyDb9shIsbETa+dpM+7eoJSI2mncVfnL5/UJxgx/8HcoNV9s/Vb+mfe + yA7OTAyGZ6aa86w81phNzUUyMrM2/P/BiOzC8DX/za9lR67pmw3f/Jdt/u8YZ7cMPFkb+9uOhogYN18/ + Xr1cNUEp0HB9QKOzR2lU08+tEIabm1sUBKbchQ/nBnEQgIgx9DlXU1BMNLrxkxqV7aPRmTorgS3RUsCq + c0vTgMwbCx7MDRp2XjDPsyMiIpbN1zprwetHaT9XWdBRms/0RzXVmP0s8Hl6Hrdqdmjmrdn35YbwzAAi + VsD8q511pKsu6Agas+WLFup/MsOr8nkDH9HryMyG8LLBIy8KZnh2UkTE4nuCfubqC9qLhjd9zQL8MTNn + hmGO2F6Dza9lRjdcFkz27rCIiEXwtRM0quHb2tXVGLQVjc58Q6OyL4ShHQlxxI5qBwLZUaMuCqa9drzt + rIiIxfI4rXnleH3aVRm0BU3Q7hrVdI+FNGf8WGqz4UsDg07TKu+OjIjYds9ydQZtwYr/bI1sWuwJasSS + GYzMrJh5T27oa50VeHZmRMTW+oirM2gtGtn4CY3IvO4LZ8Ry2fR6ZszgGi3z7NSIiNu2sya9eqx2d7UG + raH54j0jM0ujYYxYCYMRmZWTb8mN8u7giIh+V//7OH3O1RpsD9VpF/daP2/yw7gZhJeB7n+iMp4dHRGx + peHn/Tu7aoPtoZH6iIVsfSR0EWNleFXBum5a8art5IiIW/FmV22wPTRq82csXKdHwxYxjgbDMnOH/yiY + 9epxtqMjIr7X57SDdnT1Btui+bP9I5uW+IIWMbaOyKxu6BVM8uz8iFi9vlnXSXu4eoNtoeHZwy1I15ph + oCImzY3jegfjPCGAiNUnb/prLa78N0cCFTFRBsMzG964MhjrCQNErB7zVv4nunqDbaFhmW9YeHLmj6kw + GJHZ2NArmOgJBUSsBo/Vra7eYFtozJbPakTTEl+QIibW4ZlV9ecGc+0sQIhYPdoBQF/e9NcKNET7W1hO + KwhPxBSYr8/MG3iqVvpCAhFT6ah+XfRBV3GwNZov8jMiUx8NTcQ0mRmYGf9aZzX9+1gLB0RMr8dpWr9O + +pCrONgWGtH0S19gIqbN1f/IDvIGBiKmw+O04rVj9HlXb7AtNCLX2YIxHw1KxJQavHlzbpQ3OBAx0b56 + rBpfOV4HuXqDbeG+1W9FJCARU20wPLOyriZY6gsQREyseSv/U129wfawMHw9Go6I1WBT/8wbrxyn4BUL + DkRMvi8fqytdtcH20IimczTcwhCxSp3201y9L0gQMVm+fIzud9UG20MjtZeGZxf5QhGxahyWWf76yVrr + CxRETIjHqW9trXZy9Qbbw4LvQW8gIlaZa/6RHfTKMRYiiJg8j9bAuk56v6s22B7Nl/odnslFgxCxSs2N + uDCY5g0XRIyzw/h2vzai4U39PCGIWLU2vpQd4QkXRIyp/z5G4148Ufu6WoPWoKGZr1vgBdEARKxyg2Hn + B9NetmBBxNg78fWjtJ+rNWgtFnRPRYIPEc3wWQBP0CBivJz+7+N0gKs0aC2q3/JFCzpe+0f0GwzrEczw + BA4ixsCXjtHslzvrE67SoC1YwP0pEniI2MLVT2YH+4IHESvuwheP1mddnUFb0ATtbgG3IRp4iNjCYZl1 + r56ojZ7wQcTKuczK/8uuzqCtqD7zIwu3MOAQcRtOvys35OWjLXQQMQ6ueOlofc1VGbQHC7bXo0GHiIVm + BmbetMARIlbcxf8+Ql91NQbtQcMbP27BlosGHSL6rTsjWOAJI0Qsn/P68Z3+HUfDsn18IYeIfmffnxvs + CSRELI+zXzhWn3EVBh1BwzN1vpBDRL9bXs284QklRCy9k58/Rh9z9QUdQXV6vwXa5mjAIeI2zbzWRWs9 + 4YSIpbOhXyd9yNUXdBSNyB7tCTdE3I4TbsiN8gQUIpbGIS931l6uuqAYaFjTL3zhhojbdukj2boXj5IQ + seQO7Mu3+hUfC7Lh0WBDxO275bXMWE9QIWIRfekoPWdn/ru5yoJiIWknC7LGaLAh4vYN6jMbXjpaOV9o + IWLH7XeU/ljXSbu4yoJiohGbP616CzNEbJdDzg1m+oILETtk3rzOVRWUAg3NHu8LNURsnRNuzI2KBBci + dszNZndXU1AqNDTT2xdqiNg65/46NygSXojYflf2O1qHuoqCUmIB9t/RQEPE1rvyb9lB/Sy4ELGDHq0Z + XNq3jKi+6RVfqCFi62x8KTuq35EWXojYEYdxgZ8yYwE2PBpoiNh6s3WZKZ4wQ8RW+sKRerxvjd7nagnK + hQXYpGigIWLrzQ/OzPaFGiJu18Cs1Q7a0VUSlBMLsLnRQEPE1hsMyS6OhBoibt/1Lxyh01wVQSWwAFsV + DTREbINDM2s84YaIW3fqv47SV1wNQaWwAGsqCDREbItNL1ioIeL2tfJ/vu/R2ttVEFQSO3tpMsOzGERs + n1t8QYeI7zFn9uH1/hhh4bUqEmaI2BaHZFa+cIQFHCJuzZXPH6VjXO1AXLAAm1sQaIjYaoMhmXmewEPE + 0CM19oXD9BlXORAnLMAmRQMNEVtvvi4zxRt8iFVuvyP0p7pOer+rG4gbGpIZ7gs1RGydmf6ZCb7wQ6xi + w4/49XQ1A3FFQ5te8YUaIrbOxhczDc9b6CFic/mPer6TPucqBuKMBdjvo4GGiK135d+yA31BiFhl5syf + 1nXSLq5eIO5YgF0VDTREbL2z78+9FglCxGpz3vNH6jBXK5AUNCR7nC/UELF1jrkyGPZ8JwtBxOr06b7H + 6f+5SoEkobrNn44GGiK23te7BbM8oYiYdnmjX9KRtJOGZBrN8IImiNg2N71wpLKecERMsyOfO1IHuhqB + JGMhNjwSaojYCptezUz8lwUiYpXYaPbpW6OdXX1A0tHgpp9rSJMFGiK2xSUPZ1+PBCRiKrWz/qHPH6Ev + utqAtKAhm4/yhRsibtuRlwX1vrBETJFrnztCPfkSn5SiOr3fwmxzNNwQcZtu6neU1noCEzEdHq6X/nWY + PumqAtKKhmYGegIOEbfillcyDRaQYUgips3Vzx3OO/yrBgu0G6MBh4hbd86vsoMsJIWYMv/W94fa31UD + VAMa3vhxC7VcNOQQ0Wv+1ZODBZ7wREyqU5/tpONdJUC1oSGZ1z1Bh4gRm17JjPIEKGIS3fhcJ9W+3Fm7 + uSqAakSDMz/yhR0ivtfJt+cGeIIUMUkG5mN9O+mjrgKgmtGr2l2DmzaYQkS/weCmTf2O0dpImCImyVHP + /VDfc9EP8DYavOURX+gh4tuu/lum3hOoiElw5XOHqXftDtrJRT7Au6huy+cs5HLR0EPEZnOvnxHMfNbC + FDFBZswH+h6tvV3UA/ixkHsyEnqIaG58LlP37GEWqIjJMP/sD/X35zvpcy7eAbaN6pu+amGXj4YfYpUb + 1J0VTPKELGLsfO6H6v/MD/UtF+sArcfC7vlI+CFWtZv+lRnuC1rEOPnMYRpmZ/2HuygHaDsamvm6hV42 + GoKIVWp2QPdgui9wEePgc4dpjHmsi3CAjqHBmd96ghCx6lz25+wAX+gixsApzx6uGr6tD4qK6rWnhd/C + aBgiVpNBXWZpv+O0+hkLW8QYOe2fh+lHfWu0s4tsgOKiQU1n+UIRsVqc0Cc32BO+iBXRSn+cnfX3oPih + LGhQpr8dCAix2mzsl3njmR9a8CJW3vp/HqouLpYByoPqNn7UwnBJNBwRU21dZvlLJwVLPUGMWC5zdtbf + 137ycT6oHKrbcryFYr4gJBHTaX7MFbn6SBgjlssm87F/dtKXXAQDVBYNbrrbE5SIqXPxH7KvRQIZsRwu + M+8yD3CxCxAPVKddNGjLUF9gIqbFppcz4545TJl/WiAjlsl6m7mz+U5+iDV2EPAhC8mp0dBETIP5AU1z + X+wcrPQENGKx3fDPw/Rw34P1DRevAPFHgzd/xsJycTQ8EZNsMLBpyb9PDmZ7ghqxmL5pxX/5E9/XXi5S + AZKF6pr+00JzdTREERPquvCLfv55qAU0YvFtsuJ/si/X6Ie0oMHZwyw4GyNBipg0G4ddHIzzhDZih3zm + UDXYz97PHqwPu9gESA+qy/zAAnRlJFARk2Fd01rKH4vs1KcP0e1W/p91MQmQXjSw6asWpAvMMFARE2Ew + ILNswNnBxKcttBE76Cor/of7HqpD+VIeqDpUt/nTFqpToyGLGEfzrzfNe/XUYJYnyBFb64anf6gn7Gy/ + c10n7eKiEKA60asbPqxBWwb7AhcxLja9nBn7wvFa4Ql0xO25ws70H7OfNY8dq91d9AFAiPpqZwvZWoWX + DfaEL2IFDZb/OTv4mcOVjYQ64la1wn/LvPuZQ/SD2h20k4s6ANgaGrD5SAvcJZEARqyMA7esGH1FbsjT + h1ioI27bvNlg5V/b94f6ios0AGgLem3TxzSo6VVvICOWyWBg06v/7pb/nYX6khYhj/iuh2qB/fyr/exh + pb+/izAA6CgatKWLHQjM84UzYgldrIGZHm4Mmwk/mtX3UPXse4j6mqtNYVW6ou/B6vfUoepj8/Bt3rkP + UEL0qna3QA7fG9AUCWnEYpvVoMwDennbl1oN37ltJXCQnfXdZoUwwNzQoiAwXa5vLvxDdM2Th+rrFD5A + BdDrTf9lAf2cGbQIbMSO+/YbT581/9ONW5sIDwj+eZC+aWVxhfk3c44rD0yaB2u6/fybnd33fvIQ/YCP + 6QHEiOaLBw1seszCOvt/AY7YHt8u/n4akPmWG6+i8Y9D9LGnDtZpViS/skIZbD/XvqdoMA4udWf3t9v2 + Ob7vQfp/bvMBQJzR4C2f14Atf7SDgQ2mENvgeg3c8gfVbfmcG6eSEz51/OTBOtAK53Qrm59b+bxkLmpR + RlhaF5r9nz5E9z19qGqeOVj/4TYNACQV1en9GtBUY/azYM9Ggh7xHfNW+vUamOlpM7OHG5+K8/fv6yNP + H6xjnzpYV9nBwX+bA8xFZvh0NLbNwM7iZ5svh0VvhX9R+DR+329rb7e6ASCtNH98sG7LdRby/S3wGyMF + gNXnJtVlXrPivzacDTcmiSAsrScP1nefPEg9njpId5lP2UHCCHOxGZiqUrPmPHOo+YT5C/Pcvofq21xh + DwCa0cvaTXWbO1kJ/PTtMz8rA39JYHq0bdy8re/UwOzh4Qy4cUgVL3fWbnaW+zk74z3SDhIusAKstZ9/ + tp8vmQ3mAnOL6SvQOBuW+zJznPm8+aCdxd9gj637Uz/QIc98X5/oW6Od3WoAAGgdknbUgM3/ode3HKMB + W67QwMzvVNf0siuM8eYsc5XZZPrKBStnuE3CbRNuI9tWts3CbVeXeUh1Wy5/e5vatrVt7DY3GE98X3s9 + eai+EJbnUwfpFCvUS5oL9SDdaaX6K/Nh98xCeOAw2HzD/t2sd7T/v9xc3cKWzzxscv8udP47f2MHJWPt + /4cHIQ1PHaL+oXaw8ozd5yPmvfbPN9nPH5s1/zhIR5nf/McP9OlwWd1iAwAAAABAvNhhh/8PnI0jiJtE + 8e4AAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vAAADrwBlbxySQAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAACNdSURBVHhe7d0L + sN51fedxwBt2d7qtO7PabUe77W7Vdre7W2ov28vYzuzM7s6stu4wKgiG3BQrtwSUS0IfseScIMSCmBAS + ASkixmsrWhEk4AW8t7VVEVDqJjkhJ+eSkAROIvTZ3+/w3ynz5G+S55zn+39+z3Ne75nX6LQWznP8/v98 + Trj0OA1G7Y1ff87kpu2/NXn9jsVT1+8YTT4+tXHHN6c2bv9++ve7k8eTNgy4qWRbuu0Hpq7ffk/699en + mz9/avOO/71r064XVo+DJA13U5u2/Wp6Ab49+UyyP6l7YcJC8u00Dq6dvn7sjx+58ZETq0dFkga/8feO + v2hy4/bz0k89f5u0gR9rOtm8e9O2V7bb7eOrR0iSBqs9N+z6hfQH/o2T148d6njJAUf3DxObtp+e/1RZ + 9UhJUtlNbBx72eTGsS2TG3c8lbSBeXkkjehl7Vb7hOoRk6Sy2rZu2/N3b9zRmti4YyZpAz31zcnrd/y3 + 6nGTpDKavG7sf6QX1D92vLCA3noq/2m1R29+9F9Uj54k9ad2q/3s6qf+pzpeVECcB3Zdt/0/V4+hJDXb + 5KbtP5deRF/qeDEBzXh88rodS6rHUZKaaWLT2MvTT/4/TNpA/4xfv2PU3zIoqZEmrt/5ivTiGe98EQH9 + Mb5x7Kb8p+OqR1SSet+uDTt+J71w9ne+gID+mti4/SP+mQGSQtp5/c5f2bVxx+R4etkAJRq7/aFrHnpe + 9chK0vwbu3bsJePXjW1P2kDRPtre2PYrAZLmX/6JIr1UvtHxkgHK5VcCJM2/XRvG1u9KLxVgcDxqBEia + T+Mbd55c93IBBoI/HSCp+7Zt3vaC9ALZ3fFCAQaIXwmQ1HXjG8Y21b1QgMFiBEg65nZev/MV6aXxVJJf + HsDgMwIkHb30svhix8sDGHA7/TUBko7Uzg07X1n38gCGgl8JkFTf2IaxO3duSD8tAMPJCJDU2Y4NO/5r + 7QsDGC7r/ekASc9o5/qd19S+LIDh41cCJOXyTwPppTB+2EsCGF5GgKQd1+149Vh6IQALjBEgLex2Xrfz + htqXAzD8jABp4ZZeAo8c9lIAFg4jQFp45f9//zvSCwBY2IwAaYG1fcPORXUvA2Dh2b5+7KNf97cISguj + sfVjV+1Ynx5+gCS9E/xKgLQQyg973UsAWLiMAGkBtH39zoe2pwceoIMRIA1r7Vb7hPSQ/6jjoQf4//w1 + AdIwNnnN5E/WPPAAz+RXAqRha9uGbT+7LT3gAEdhBEjD1NjGsZfVPOgAdYwAaVgau3bs17at35kebIBj + 4q8JkIahH64fO6nmAQc4Er8SIA16eQD83/fubAN0Y9t7jQBpoDMAgLkyAqQBzgAA5sMIkAa0PAB+mB5i + gHkwAqRBywAAesQIkAYpAwDoISNAGpTyAPjH9OAC9IgRIA1CBgAQwAiQSs8AAIIYAVLJzQ6Aa9PDCtBr + 7zECpGLLA+CR9KACRPiBESCVmQEARDMCpAIzAIAmGAFSYT2cBsAP8sMJEM0IkMrJAAAaZQRIZWQAAI0z + AqT+ZwAAfWEESP0tD4Dvp4cRoHFGgNS/Hr46DYD3zD6IAP1gBEj9yAAACmAESE2XB8DD6QEE6DMjQGoy + AwAoiBEgNZUBABTGCJCayAAACmQESNHlAfDQex5tA5Tk4fc8agRIkRkAQKmMACkwAwAomREgBZUHwIPX + PNoGKJgRIPU6AwAYEEaA1MsMAGCAGAFSr/puGgDfSw8WwIAwAqReZAAAA8gIkOabAQAMKCNAmk8GADDA + jABpruUB8EB6kAAG0XeNAGluGQDAoDMCpDk0OwCuTg8RwAD77tVGgNRVeQCkByc/PACDzgiQjjUDABgy + RoB0LBkAwBAyAqSjZQAAQ8oIkI5UHgDfSQ8LwBAyAqQflwEADDkjQKrLAAAWACNA6iwPgG+nBwRgyBkB + 0jObHQB/nh4OgGFnBEj/nAEALChGgPR0BgCw4BgB0nHHfSsNgH9IDwTAQmIEaMFnAAALlRGgBd23rt6d + BsCu9DAALDxGgBZseQD8fXoIABYsI0ALMQMAIDECtNAyAAAqRoAWUnkAfOvdu9oAZEaAFkgGAEAnI0AL + IAMAoI4RoCHPAAD4cYwADXF5APxdOnQADmcEaGgzAACOzAjQUGYAABydEaChKw+Av03HDcDRGAEaogwA + gG4YARqSvnVlGgDr0lEDcIyMAA1BBgDAXBgBGvC+kQbA36RjBqBbRoAGOAMAYD6MAA1oBgDAfBkBGsDy + APhmOmAA5u4bRoAGLQMAoDeMAA1UBgBA7xgBGpgMAIDeMgI0EOUB8I2r0sEC0DtGgErPAAAIYgSo5AwA + gEBGgEotD4CvXzXeBiDIunEjQOVlAADE+9q68Y9ubbWfXb16pf5nAAA0Zdct7Xb7+Or1K/U3AwCgUaPV + 61fqb3kAfC0dJQANWTf+1uoVLPUvAwCgcYe+8u5dv129hqX+NDsArkwHCUBzrtr1w/vW7X1B9SqWmu/L + aQB8NR0jAI37UPUqlprPAADon69dNf6/qtex1GwGAED/fOXK8Ye2th45sXolS82VB0A6wHyEAPTHxdUr + WWouAwCg7/Z8fXTqX1WvZamZDACAEux6W/ValprJAAAowqP3rdv2/OrVLMWXB8CX0/EB0F/3XzW+qHo1 + S/HNDoB3peMDoM9231m9mqX4DACAYjz15bWTP1e9nqXY8gC4Px0eACXYvaJ6PUuxGQAA5bjvXeN3VK9n + KTYDAKAoB77daj+3ekVLcRkAAIW5YtfvVK9oKa48AO5LBwdAGdIA8A8FUnwGAEBhrhx/X/WKluIyAADK + 8qV3jX+hekVLcX0hDYAvXZEODoBS7Kpe0VJcBgBAeT59zUPPq17TUkxPD4Dd6eAAKMVX1jz2r6vXtBST + AQBQnvtHdv589ZqWYsoD4Ivp2AAox32jj/6n6jUtxWQAAJQnv5ur17QUkwEAUB4DQOHlI/tCPjYAymEA + KDoDAKBABoCi+8JIGgBr07EBUI70bq5e01JM+cg+n44NgHIYAArPAAAojwGg8AwAgPIYAArPAAAojwGg + 8PKR3ZuODQbQk+lF+fC9V+z+3OfXTmy5Z3Tixiz/+/S/uzv5fv7PVP9ZGCgGgMIzABggP7p37cRn0h/0 + L7hnZOIVx/L/LS3/Z/J/Ng2Dt907On7H07+N2t82FMUAUHgGAAPgwXuvGD/nS+969N9UZzvn7rp81wvT + gDh39rdZ//uCIhgACu/udGT3pGODAn1n6+ju123Z0n5Wda49K/8277li9+vT7+OBjt8nFCG/m6tzlWKa + HQCj6eCgHAe2juxuHcsv8c+3r29sP+fe0fFz0u9zX8fXAH1lACg8A4DCfPvu0clfqc6zse5eu/ul94zs + /ruarwf6wgBQeAYAxRjZffPW1iMnVqfZePet2/b8rSO7b6n92qBhBoDCy0e2NR0b9NM9IxNXt1rtE6qz + 7Fvtdvv49PJdW/c1QpMMAIVnANBvd4+Mr6nOsZi2rh0frftaoSkGgMIzAOizzfmn7uociyl/TXePTtxQ + 8/VCIwwAhZeP7O58bNC8r2xptZ9bnWJx5b9DYOva8ftqvm6IZwAoOgOAPpn63JXTL6nOsNi2juz8+fS1 + Tnd87RDPAFB0BgD9kH6yXlKdYPFtHd39prrPAKEMAEU3OwBGJtKxQUPWTHylhL/i/1jLX2v6uu8/7HNA + KANAweUj+1w6NmjKXWvGf686v4Hprst3/0HdZ4EoBoDCMwBo1uS91ekNXOlZ+UL9Z4LeMwAUngFAk+4e + nXh1dXoD191rJl5T95kgggGg8PKR3ZWODRowUfLf9ne08td+18ju3TWfC3rOAFB4BgANem91dgPbnSMT + G2o+F/ScAaDwDACacvea3a+qzm5gu3PNxGvqPhv0mgGg8AwAGvLk1tb0T1VnN7Dlz5A/S8dng54zABTe + HenI7kzHBsG+W53cwJc+y/c6Phv0XH43VycnxTQ7ANakg4NIl098ojq5gS99nk8e9vmgxwwAhWcA0IS7 + RiavrE5u4LtzZPe6us8IvWQAKLx8ZJ9NxwaR7hyZuKQ6uYHvsyOTq+s+I/SSAaDwDACacMeaibOrkxv4 + Pnv55Dl1nxF6yQBQeAYATUh3trw6uYEvf5a6zwi9ZAAovHxk6aez/BMaxBmyAVD7GaGXDABFZwDQCAMA + umMAKDoDgEYYANAdA0DRGQA0wgCA7hgAii4f2Wcun2hDpDsuH6IBkD5L3WeEXjIAFJ4BQBMMAOiOAaDw + DACaYABAdwwAhZeP7K/TsUGs4RkA+bPUf0boHQNA4RkANMMAgG4YAArPAKAZBgB0wwBQeAYAzTAAoBsG + gMK7PR3Zp9OxQaRhGwB1nxF6Kb+bq5OTYnp6AEymg4M4f3351BANgKk0AOo/J/SKAaDwbr8sDYA/SwcH + gYZuANR8Ruil/G6uTk6KKR/Zp9KxQaTbh2gA5M9S9xmhlwwAhWcA0AQDALpjACg8A4AmGADQHQNA4RkA + NMEAgO4YAAovH9nt+dgg0pANgNrPCL1kACg6A4BGGADQHQNA0RkANMIAgO4YAIouH9kn07FBpGEbAHWf + EXrJAFB4swPgnengINDtlw3RAEifpe4zQi8ZAArPAKAJBgB0xwBQePnI/iodG4QaogGQP0vtZ4QeMgAU + ngFAIwwA6IoBoPAMABphAEBXDACFZwDQCAMAumIAKLyPpyP7y3RsEGnYBkDdZ4Reyu/m6uSkmAwAmmAA + QHcMAIVnANAEAwC6YwAovHxkn7hssg2RPj5EAyB/lrrPCL1kACg8A4AmGADQHQNA4RkANMEAgO4YAArP + AKAJBgB0xwBQePnIPj57bBBpuAZA/WeEXjIAFJwBQDMMAOiOAaDgDACaYQBAdwwABffxy/ac9LHLptoQ + adgGQN1nhF7K7+bq5KSYDACaYABAdwwAhTc7AN6RDg4CDd0AqPmM0EsGgMIzAGiCAQDdMQAUXj6yj6Zj + g1BDNADyZ6n9jNBDBoDCMwBohAEAXTEAFJ4BQCMMAOiKAaDwtqQj+0g6Nog0bAOg7jNCL+V3c3VyUkwG + AE0wAKA7BoDCMwBoggEA3TEAFJ4BQBMMAOiOAaDw8pF9uDXVhkhbWsMzAPJnqfuM0EsGgMIzAIrwZPJA + 8omPtKav+vA7pi5K/3p2/gPNsLjtnRMvr05u4Mufpe4zDqp8a/nmPtyaXpdvsLrFfJN1t0pDDACFZwD0 + ze7kvVta06/6eGv6p6r/OqQiyjf54XdMv/ojran11a3W3TCBDACFl48s/RSQf4mWZtybX6wbN7afU/1X + IBXdllb7uR9qTf9Rut3Pd9wykQwARWcANOa+5Herb7s0kKUh8Pvpju9/xl0TxQBQdAZAuKkt75hc0m63 + j6++5dJA12q1T/jQOyaXpdue7rh1eskAUHT5yD6Ujo0I01/9aGvPL1TfammoSn+QenHypfrbZ74MAIVn + AMS4rTW92Z/n17CX//qA21qTN9Y9A8yPAaDwDIDeu601NeKX/LVQyree7n608zlgfgwAhbdldRoAf5oO + jl5ZW31rpQXVh1rTV9Y8D8xRfjdX31oppnxkt6VjowdaUze3j/OTvxZm+fbTM3BL7bNB1wwAhWcA9Ehr + 6ltbztv2/OrbKi3Ibmw9cmJ6Hv7msOeDrhkACs8A6IHW1P4tq3a/tPqWSgu621ZNvDw9FwcOe07oigGg + 8D6QjuyD6diYuzQALqy+nZJSH2xNr6p7Vjh2+d1cfTulmJ4eANPp4JiT1p7v5L8Vqvp2Skp9+qz289Lz + 8b3DnheOmQGg8AyAebp0z2urb6WkZ3TbpVOn1j4zHBMDQOEZAPPQmn54y8ntZ1XfSknPKD8b6Rl5sPbZ + 4agMAIWXj+zWdGx07wOXTp9TfRsl1XRra3pF3bPD0RkACm92AFyaDo5u/ejWi/e/sPo2SqopPyOzz0r9 + M8QRGAAKzwCYq6nPVN9CSUfo1tXTd9Y/QxyJAaDw8pF9IB8bXbn10j0XVN9CSUfolkunLqp7hjgKA0DR + GQBz88HWnl+vvoWSjtAHWnt/o+4Z4igMAEVnAMzJk/kfeVp9CyUdofys5Gem4xniaAwARWcAzMnD1bdP + 0jGUnplHOp4hjsYAUHT5yG5Jx0YXVk/fWX37JB1D6bm567DniCMyABSeAdC9tM4/Un37JB1D6bn5WOdz + xJEZAArPAJiDP52+sfr2STqG0nNz02HPEUdkACi8fGR/sXq6zbG7ZbUBIHXTX6yavqnuWeLHMwAUngEw + J/4UgNRF6Zn5WMczxFEYAArPAOievwhQ6q703Hyu8zniyAwAhXdTOrKb07HRFX8boNRF6Zl5pOMZ4ijy + u7n69kkxGQBz4h8EJB1j+VnJz0zHM8RRGAAKzwCYm1tW731F9S2UdIRuXr33N+ueIY7MAFB4BsBc7Xlb + 9S2UdIRuXjV1Uf0zxJEYAAovH9n707HRrak7qm+hpCOUnpe7Dn9+OBoDQOEZAHP2oxtb4y+qvo2Sarr1 + 4v0vzM9Kx7PDMTAAFN7sAFiVDo6u3XzJ9LnVt1FSTe+/ZHpF3bPD0RkACi8f2U352JiLh7e22s+uvpWS + ntGWk9vPSs/Igx3PDMfKAFB0BsD83Lh66nXVt1LSM7rxkunT6p4ZjpEBoOgMgPl5/6qpB7a02s+tvp2S + Utec1X5eej789D8fBoCie3oA7EkHxzxcVH07JaVuumTvpTXPCd0wABRdPrIb07ExLwduvOixl1XfUmlB + d8NF+345PROPdzwjdMkAUHgGQG+kxf73G1tjP1F9W6UF2Y2t9onpefjbzueD7hkACs8A6KXpW9rHtY+v + vrXSgqrVap+QnoMPHv5cMBcGgMLLR3ZDOjZ6I42Aa6tvrbSget/qvVfVPRPMjQGg8GYHwCXp4OidVXtG + /UqAFkr51tNPrFfUPgvMmQGg8AyAMDf42wM17OUbv2HV3vfX3D/zZAAoPAMg1NduWrXnF6tvtTRU3fz2 + qRenG7+/4+bpEQNA4W1KR/a+dGyEmd68as+b8l8gVX3LpYEu3/INq/acmW57T8et00P53Vx9y6WYDIDG + fGXTqulXVt92aSB738XTf/C+i/d8tea+6TEDQOEZAA1bNf3FNARe468P0KCUbzXf7Psumf5S7U0TwgBQ + ePnINqdjo3GTmy7ZsyG9VP94c2vvC6r/OqQiyjeZ/6C/+eI91+Vb7bhdGmAAKDwDoAhPJQ9uvmTvX22+ + eO+6TRfvuWTzqulz0kBYPjRW7Xt5dXIDX/4stZ9xQM3eWr65dHtpkH7y6Vucvcm6W6UhBoDCMwBoQv4D + TXVyA9/sHzRrPiP0kgGg8DZduOektP7bEGrIBkDtZ4ReSu/m6uSkmAwAGmEAQHcMAEVnANAIAwC6YwAo + OgOARhgA0B0DQNHlI7s+HRtEGrYBUPcZoZcMAIVnANAEAwC6YwAoPAOAJhgA0B0DQOHlI9uYjg1CDdEA + yJ+l9jNCDxkACs8AoBEGAHTFAFB4swPgonRwEOnCIRoA6bPUfkboIQNA4RkANMIAgK4YAApvfTqy6y7a + 24ZIwzYA6j4j9FJ+N1cnJ8VkANAEAwC6YwAoPAOAJhgA0B0DQOHlI9uQjg0ipTsbmgGQP0vdZ4ReMgAU + ngFAEwwA6I4BoPAMAJpgAEB3DACFZwDQBAMAumMAKLx8ZOsvzMcGkYZrANR/RuglA0DBGQA0wwCA7hgA + Cs4AoBkGAHTHAFBw+cjem44NIg3bAKj7jNBLBoDCMwBoggEA3TEAFJ4BQBMMAOiOAaDwDACaYABAdwwA + hZeP7Np0bBBreAZA/iz1nxF6xwBQeAYAzTAAoBsGgMKbHQBvTwcHkYZtANR9RughA0DhXZ2O7D3p2CDS + sA2Aus8IvZTfzdXJSTEZADTBAIDuGAAKzwCgCQYAdMcAUHj5yK5JxwaR0p0NzQDIn6XuM0IvGQAKzwCg + CQYAdMcAUHgGAE0wAKA7BoDCMwBoggEA3TEAFF4+sqvzsUGkIRsAtZ8ReskAUHSzA+Bt6dgg1BANgPRZ + 6j8j9JABoOieHgCPpYODSPuGaADsSwOg7jNCDxkAii4f2Z+nY4NIwzYA6j4j9JIBoPAMAJpgAEB3DACF + ZwDQBAMAumMAKDwDgCYYANAdA0Dh5SN7dzo2iDU8AyB/lvrPCL1jACg8A4BmGADQDQNA4RkANMMAgG4Y + AArvypV7Tlp3wWNtiDRsA6DuM0Iv5XdzdXJSTAYATTAAoDsGgMIzAGiCAQDdMQAUngFAEwwA6I4BoPDy + kV2Vjg0iXTlEAyB/lrrPCL1kACg8A4BGnL/37OrkBr70Wc6t/YzQQwaAwjMAaMT5+y6pTm7gS59lde1n + hB4yABRePrIr87FBrCurkxv40mdZ1/HZoPcMAEVnANCE9BPNJ6qTG/jS5/lk5+eDnjMAFN3sADg/HRvE + eqA6uYEvfZYHOz4b9J4BoOjykb0rHRsEe3Lkwj0/XZ3dwLbuvL0vSJ/lqY7PBj1nACg8A4AGvbo6u4Ht + igv2/Z+azwU9ZwAoPAOA5uxdX53dwJY+x3WHfy7oPQNA4RkANGii1Wo/tzq9gSt/7fkzdHwmCGEAKLx8 + ZFekY4MmrF352B9VpzdwrV257zV1nwkiGAAKzwCgYfdVpzdwpZ/KvlDzeSCEAaDwDAAad8Fjv1ed38D0 + rvP3/WHtZ4EgBoDCG0lHtjYdGzQlvdy+2mq1T6hOsPjy1zp6/mNfrvssECW/m6sTlGIaWXngpLUr97Wh + SekPqMuqEyy+0RX7zqz7DBApv5urE5RiMgDok6mRc6d/vjrDYhs5b88vpK91T8fXDuEMAIVnANAvV6yc + /VMBxf5tgRuXt5+Tvs77O79uaIIBoPDykY2mY4P+2H9D+7j28dU5FlP+mkbPf+z99V8zxDMAFJ4BQL+t + XbF/tDrHYlq7cv8VdV8rNMUAUHgGACUYWbHv6hL+zoDZn/xX7l9b9zVCkwwAhZePbGT22KDvbll3Xvv5 + 1Wk2XhogP7Fm5b4P1nxd0AcGgIIzACjK+fu+c/n5+/5jdZ6NtWblYy9Lv/9vHfb1QN8YAArOAKBAj6ch + 0LrmrPbzqjMNK/+V/qMr95+Tfp/7Or4G6DMDQMHNDoAV6digPN8bWbn/1C0nt59VnWvParXazx5dsf8N + I+fte7Dm9wv9ZwAounxka9KxQcEevnzl/vOuuGD/i6qznXOXn3vgZ9as2L8i/zY7fh9QFANA4RkADJAn + 16zcd+ealY9duOb8vb95LH+KIP2kf+Kfrdj7W7P/Nyv23TX726j/bUNRDACFZwAwwJ5KP83/IP3r3Zev + 2PeR9Af5m7LZf5/+Z9X/Lv1nav9voWgGgMLLR5ZemG0AymEAKDwDAKA8BoDCMwAAymMAKDwDAKA8BoDC + uywd2Z+lYwOgHPndXL2mpZhmB8B56eAAKIYBoPAMAIDyGAAKLx/ZO9OxAVAOA0DhGQAA5TEAFJ4BAFAe + A0Dh5SO7LB8bAOUwABSdAQBQIANA0T09APangwOgGAaAojMAAApkACi6y84+cNI7zt3fBqAc+d1cvaal + mAwAgPIYAArPAAAojwGg8PKRtdKxAVAOA0DhGQAA5TEAFJ4BAFAeA0DhGQAA5TEAFN7qdGR/mo4NgHLk + d3P1mpZiMgAAymMAKLzZAXBOOjgAimEAKLx8ZJemYwOgHAaAwjMAAMpjACg8AwCgPAaAwjMAAMpjACi8 + fGSr87EBUA4DQNEZAAAFMgAUnQEAUCADQNHlI1uVjg2AchgACm92AJydDg6AYhgACs8AACiPAaDw8pFd + ko4NgHIYAArPAAAojwGg8AwAgPIYAArPAAAojwGg8C5MR3bx2QfaAJQjv5ur17QUkwEAUB4DQOEZAADl + MQAUXj6yi8460AagHAaAwjMAAMpjACg8AwCgPAaAwjMAAMpjACi8fGQX5mMDoBwGgKIzAAAKZAAoOgMA + oEAGgKLLR/b2dGwAlMMAUHgGAEB5DACFNzsA3poODoBiGAAKzwAAKI8BoPDykb0tHRsA5TAAFJ4BAFAe + A0DhGQAA5TEAFN7KdGQXpGMDoBz53Vy9pqWYDACA8hgACs8AACiPAaDwDACA8hgACm/lmQdOOv9PDrQB + KEd+N1evaSkmAwCgPAaAwjMAAMpjACi8fGQr87EBUA4DQNE9PQAeTwcHQDEMAEVnAAAUyABQdPnIVqRj + A6AcBoDCMwAAymMAKDwDAKA8BoDCmx0Ab0kHB0AxDACFl4/svHRsAJTDAFB4BgBAeQwAhWcAAJTHAFB4 + Z6cjOzcdGwDlyO/m6jUtxWQAAJTHAFB4BgBAeQwAhWcAAJTHAFB4+cjOSccGQDkMAIU3OwDOTAcHQDEM + AIVnAACUxwBQePnIzp49NgDKYQAoOAMAoEQGgIIzAABKZAAoOAMAoEQGgILLR3ZWOjYAymEAKDwDAKA8 + BoDCMwAAymMAKLx8ZG998+NtAMphACg8AwCgPAaAwjMAAMpjACi8M9OR/cmbn2gDUI78bq5e01JMBgBA + eQwAhWcAAJTHAFB4BgBAeQwAhZeP7C3p2AAohwGg8AwAgPIYAApvdgC8KR0cAMUwABRePrIz87EBUA4D + QNEZAAAFMgAUnQEAUCADQNEZAAAFMgAUXT6yN6djA6AcBoDCMwAAymMAKDwDAKA8BoDCy0f2pnRsAJTD + AFB4Zy5NA2B5OjgAipHfzdVrWorJAAAojwGg8AwAgPIYAApvaTqy5enYAChHfjdXr2kpJgMAoDwGgMIz + AADKYwAovHxky9KxAVAOA0DhGQAA5TEAFJ4BAFAeA0Dh5SNbuiwdGwDlMAAU3fLlB36t9vgA6Jv8bq5e + 01JMy5cffNnSZTPp4AAoxbJlM79UvaalmN785sd/tu74AOif5csP/Ez1mpZiOvWs9k8uSccGQDne8pb2 + v6xe01JMrVb7hHRsP+o8PgD65tBxx7WPr17TUlzp2B7qOD4A+mX5zAPV61mKbfGymduTNgBF+Mvq9SzF + lo7tqo7jA6Bfls9cUb2epdiWLHnijYuXpqMDoO/SO/m06vUsxbZ8+RMvrjtCAJqXBsBLqtezFN+ipTM/ + OCMdHgD9kwbA96rXstRMaQBsrjtGAJqT3sUbqtey1EyLl828qu4YAWhOehf/z+q1LDVTq9V+dlqejyZ5 + gQLQvF35XVy9lqXmSuvz6pqDBKAJS2auql7HUrMtWnbov9QeJQDhTl968Fer17HUfIuWzdxRd5gAhPpU + 9RqW+tMblzzx+29cMtMGoDmnL37id6vXsNS/0jF+vvM4AQhzd/X6lfrbaYsP/Xo6yKc6DhSA3nvq9CWH + fqN6/Ur977TFMxtPT8cJQJw3Lp65tnrtSmW0ZEn7Bek4xzuPFYDeSD/9P3rKme2frl67UjmdtvTga+qO + FoB5+6fTlx58dfW6lcorHel7Oo4WgHk6bcnMuuo1K5XZWWe1n5cO9etJPlgA5mvxE189+eT2c6vXrFRu + p5/++M+mo/3Hw44YgG5tO335Ey+uXq9S+Z2yaOY/nLb40K7TFh9M6xWAOZg4benBl1evVWlwOn3xj377 + DYsP7kvaAHRl36lLD/1W9TqVBq/8Dwl6w+KZ8ZrjBqBG+sl/Mv8AVb1GpcHtjW+c+cU3LDn4cN2hA/DP + Tl188JH0Q9NLq9enNPi9bvGBf3vqkpnPp+POBw5ApzMObV20aP+LqtemNDydfHL7WWnhttKhP3XY4QMs + XP906uJDV7+y1X529bqUhrM3LJ357+ngf9DxAAAsOPlPj552xhN/WL0epeHv5JPbz69+NeCJzgcCYAE4 + lN6Bo4sWtU+sXovSwuq1y2Z+KT0It56y+OCTSRtgyOV33S1vWDLz76vXoLSwO23pE//ulDMOXX3KGQdn + kjbAkDmU/sB/s7/CX/oxnbyk/YJTFh9afsrimS/WPEAAg+bbpyw6+PbXL93/wuo1J+lonXrGwV9+3Rkz + 57/+jIOfSvYlbYDCPfb6RQdvf/2imRXpX19Wvc4kzbX8t8ecsuTQb5yy+NCi9FCNvO6Mgx9ND9rXku+/ + /oyZ8fSvj1cPH0Ck9K45tCv9a3r3HPxa9S5ak99Nr1106BX+Vr5B6bjj/h81C5i9dvi9qgAAAABJRU5E + rkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vAAADrwBlbxySQAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAACNdSURBVHhe7d0L + sN51fedxwBt2d7qtO7PabUe77W7Vdre7W2ov28vYzuzM7s6stu4wKgiG3BQrtwSUS0IfseScIMSCmBAS + ASkixmsrWhEk4AW8t7VVEVDqJjkhJ+eSkAROIvTZ3+/w3ynz5G+S55zn+39+z3Ne75nX6LQWznP8/v98 + Trj0OA1G7Y1ff87kpu2/NXn9jsVT1+8YTT4+tXHHN6c2bv9++ve7k8eTNgy4qWRbuu0Hpq7ffk/699en + mz9/avOO/71r064XVo+DJA13U5u2/Wp6Ab49+UyyP6l7YcJC8u00Dq6dvn7sjx+58ZETq0dFkga/8feO + v2hy4/bz0k89f5u0gR9rOtm8e9O2V7bb7eOrR0iSBqs9N+z6hfQH/o2T148d6njJAUf3DxObtp+e/1RZ + 9UhJUtlNbBx72eTGsS2TG3c8lbSBeXkkjehl7Vb7hOoRk6Sy2rZu2/N3b9zRmti4YyZpAz31zcnrd/y3 + 6nGTpDKavG7sf6QX1D92vLCA3noq/2m1R29+9F9Uj54k9ad2q/3s6qf+pzpeVECcB3Zdt/0/V4+hJDXb + 5KbtP5deRF/qeDEBzXh88rodS6rHUZKaaWLT2MvTT/4/TNpA/4xfv2PU3zIoqZEmrt/5ivTiGe98EQH9 + Mb5x7Kb8p+OqR1SSet+uDTt+J71w9ne+gID+mti4/SP+mQGSQtp5/c5f2bVxx+R4etkAJRq7/aFrHnpe + 9chK0vwbu3bsJePXjW1P2kDRPtre2PYrAZLmX/6JIr1UvtHxkgHK5VcCJM2/XRvG1u9KLxVgcDxqBEia + T+Mbd55c93IBBoI/HSCp+7Zt3vaC9ALZ3fFCAQaIXwmQ1HXjG8Y21b1QgMFiBEg65nZev/MV6aXxVJJf + HsDgMwIkHb30svhix8sDGHA7/TUBko7Uzg07X1n38gCGgl8JkFTf2IaxO3duSD8tAMPJCJDU2Y4NO/5r + 7QsDGC7r/ekASc9o5/qd19S+LIDh41cCJOXyTwPppTB+2EsCGF5GgKQd1+149Vh6IQALjBEgLex2Xrfz + htqXAzD8jABp4ZZeAo8c9lIAFg4jQFp45f9//zvSCwBY2IwAaYG1fcPORXUvA2Dh2b5+7KNf97cISguj + sfVjV+1Ynx5+gCS9E/xKgLQQyg973UsAWLiMAGkBtH39zoe2pwceoIMRIA1r7Vb7hPSQ/6jjoQf4//w1 + AdIwNnnN5E/WPPAAz+RXAqRha9uGbT+7LT3gAEdhBEjD1NjGsZfVPOgAdYwAaVgau3bs17at35kebIBj + 4q8JkIahH64fO6nmAQc4Er8SIA16eQD83/fubAN0Y9t7jQBpoDMAgLkyAqQBzgAA5sMIkAa0PAB+mB5i + gHkwAqRBywAAesQIkAYpAwDoISNAGpTyAPjH9OAC9IgRIA1CBgAQwAiQSs8AAIIYAVLJzQ6Aa9PDCtBr + 7zECpGLLA+CR9KACRPiBESCVmQEARDMCpAIzAIAmGAFSYT2cBsAP8sMJEM0IkMrJAAAaZQRIZWQAAI0z + AqT+ZwAAfWEESP0tD4Dvp4cRoHFGgNS/Hr46DYD3zD6IAP1gBEj9yAAACmAESE2XB8DD6QEE6DMjQGoy + AwAoiBEgNZUBABTGCJCayAAACmQESNHlAfDQex5tA5Tk4fc8agRIkRkAQKmMACkwAwAomREgBZUHwIPX + PNoGKJgRIPU6AwAYEEaA1MsMAGCAGAFSr/puGgDfSw8WwIAwAqReZAAAA8gIkOabAQAMKCNAmk8GADDA + jABpruUB8EB6kAAG0XeNAGluGQDAoDMCpDk0OwCuTg8RwAD77tVGgNRVeQCkByc/PACDzgiQjjUDABgy + RoB0LBkAwBAyAqSjZQAAQ8oIkI5UHgDfSQ8LwBAyAqQflwEADDkjQKrLAAAWACNA6iwPgG+nBwRgyBkB + 0jObHQB/nh4OgGFnBEj/nAEALChGgPR0BgCw4BgB0nHHfSsNgH9IDwTAQmIEaMFnAAALlRGgBd23rt6d + BsCu9DAALDxGgBZseQD8fXoIABYsI0ALMQMAIDECtNAyAAAqRoAWUnkAfOvdu9oAZEaAFkgGAEAnI0AL + IAMAoI4RoCHPAAD4cYwADXF5APxdOnQADmcEaGgzAACOzAjQUGYAABydEaChKw+Av03HDcDRGAEaogwA + gG4YARqSvnVlGgDr0lEDcIyMAA1BBgDAXBgBGvC+kQbA36RjBqBbRoAGOAMAYD6MAA1oBgDAfBkBGsDy + APhmOmAA5u4bRoAGLQMAoDeMAA1UBgBA7xgBGpgMAIDeMgI0EOUB8I2r0sEC0DtGgErPAAAIYgSo5AwA + gEBGgEotD4CvXzXeBiDIunEjQOVlAADE+9q68Y9ubbWfXb16pf5nAAA0Zdct7Xb7+Or1K/U3AwCgUaPV + 61fqb3kAfC0dJQANWTf+1uoVLPUvAwCgcYe+8u5dv129hqX+NDsArkwHCUBzrtr1w/vW7X1B9SqWmu/L + aQB8NR0jAI37UPUqlprPAADon69dNf6/qtex1GwGAED/fOXK8Ye2th45sXolS82VB0A6wHyEAPTHxdUr + WWouAwCg7/Z8fXTqX1WvZamZDACAEux6W/ValprJAAAowqP3rdv2/OrVLMWXB8CX0/EB0F/3XzW+qHo1 + S/HNDoB3peMDoM9231m9mqX4DACAYjz15bWTP1e9nqXY8gC4Px0eACXYvaJ6PUuxGQAA5bjvXeN3VK9n + KTYDAKAoB77daj+3ekVLcRkAAIW5YtfvVK9oKa48AO5LBwdAGdIA8A8FUnwGAEBhrhx/X/WKluIyAADK + 8qV3jX+hekVLcX0hDYAvXZEODoBS7Kpe0VJcBgBAeT59zUPPq17TUkxPD4Dd6eAAKMVX1jz2r6vXtBST + AQBQnvtHdv589ZqWYsoD4Ivp2AAox32jj/6n6jUtxWQAAJQnv5ur17QUkwEAUB4DQOHlI/tCPjYAymEA + KDoDAKBABoCi+8JIGgBr07EBUI70bq5e01JM+cg+n44NgHIYAArPAAAojwGg8AwAgPIYAArPAAAojwGg + 8PKR3ZuODQbQk+lF+fC9V+z+3OfXTmy5Z3Tixiz/+/S/uzv5fv7PVP9ZGCgGgMIzABggP7p37cRn0h/0 + L7hnZOIVx/L/LS3/Z/J/Ng2Dt907On7H07+N2t82FMUAUHgGAAPgwXuvGD/nS+969N9UZzvn7rp81wvT + gDh39rdZ//uCIhgACu/udGT3pGODAn1n6+ju123Z0n5Wda49K/8277li9+vT7+OBjt8nFCG/m6tzlWKa + HQCj6eCgHAe2juxuHcsv8c+3r29sP+fe0fFz0u9zX8fXAH1lACg8A4DCfPvu0clfqc6zse5eu/ul94zs + /ruarwf6wgBQeAYAxRjZffPW1iMnVqfZePet2/b8rSO7b6n92qBhBoDCy0e2NR0b9NM9IxNXt1rtE6qz + 7Fvtdvv49PJdW/c1QpMMAIVnANBvd4+Mr6nOsZi2rh0frftaoSkGgMIzAOizzfmn7uociyl/TXePTtxQ + 8/VCIwwAhZeP7O58bNC8r2xptZ9bnWJx5b9DYOva8ftqvm6IZwAoOgOAPpn63JXTL6nOsNi2juz8+fS1 + Tnd87RDPAFB0BgD9kH6yXlKdYPFtHd39prrPAKEMAEU3OwBGJtKxQUPWTHylhL/i/1jLX2v6uu8/7HNA + KANAweUj+1w6NmjKXWvGf686v4Hprst3/0HdZ4EoBoDCMwBo1uS91ekNXOlZ+UL9Z4LeMwAUngFAk+4e + nXh1dXoD191rJl5T95kgggGg8PKR3ZWODRowUfLf9ne08td+18ju3TWfC3rOAFB4BgANem91dgPbnSMT + G2o+F/ScAaDwDACacvea3a+qzm5gu3PNxGvqPhv0mgGg8AwAGvLk1tb0T1VnN7Dlz5A/S8dng54zABTe + HenI7kzHBsG+W53cwJc+y/c6Phv0XH43VycnxTQ7ANakg4NIl098ojq5gS99nk8e9vmgxwwAhWcA0IS7 + RiavrE5u4LtzZPe6us8IvWQAKLx8ZJ9NxwaR7hyZuKQ6uYHvsyOTq+s+I/SSAaDwDACacMeaibOrkxv4 + Pnv55Dl1nxF6yQBQeAYATUh3trw6uYEvf5a6zwi9ZAAovHxk6aez/BMaxBmyAVD7GaGXDABFZwDQCAMA + umMAKDoDgEYYANAdA0DRGQA0wgCA7hgAii4f2Wcun2hDpDsuH6IBkD5L3WeEXjIAFJ4BQBMMAOiOAaDw + DACaYABAdwwAhZeP7K/TsUGs4RkA+bPUf0boHQNA4RkANMMAgG4YAArPAKAZBgB0wwBQeAYAzTAAoBsG + gMK7PR3Zp9OxQaRhGwB1nxF6Kb+bq5OTYnp6AEymg4M4f3351BANgKk0AOo/J/SKAaDwbr8sDYA/SwcH + gYZuANR8Ruil/G6uTk6KKR/Zp9KxQaTbh2gA5M9S9xmhlwwAhWcA0AQDALpjACg8A4AmGADQHQNA4RkA + NMEAgO4YAAovH9nt+dgg0pANgNrPCL1kACg6A4BGGADQHQNA0RkANMIAgO4YAIouH9kn07FBpGEbAHWf + EXrJAFB4swPgnengINDtlw3RAEifpe4zQi8ZAArPAKAJBgB0xwBQePnI/iodG4QaogGQP0vtZ4QeMgAU + ngFAIwwA6IoBoPAMABphAEBXDACFZwDQCAMAumIAKLyPpyP7y3RsEGnYBkDdZ4Reyu/m6uSkmAwAmmAA + QHcMAIVnANAEAwC6YwAovHxkn7hssg2RPj5EAyB/lrrPCL1kACg8A4AmGADQHQNA4RkANMEAgO4YAArP + AKAJBgB0xwBQePnIPj57bBBpuAZA/WeEXjIAFJwBQDMMAOiOAaDgDACaYQBAdwwABffxy/ac9LHLptoQ + adgGQN1nhF7K7+bq5KSYDACaYABAdwwAhTc7AN6RDg4CDd0AqPmM0EsGgMIzAGiCAQDdMQAUXj6yj6Zj + g1BDNADyZ6n9jNBDBoDCMwBohAEAXTEAFJ4BQCMMAOiKAaDwtqQj+0g6Nog0bAOg7jNCL+V3c3VyUkwG + AE0wAKA7BoDCMwBoggEA3TEAFJ4BQBMMAOiOAaDw8pF9uDXVhkhbWsMzAPJnqfuM0EsGgMIzAIrwZPJA + 8omPtKav+vA7pi5K/3p2/gPNsLjtnRMvr05u4Mufpe4zDqp8a/nmPtyaXpdvsLrFfJN1t0pDDACFZwD0 + ze7kvVta06/6eGv6p6r/OqQiyjf54XdMv/ojran11a3W3TCBDACFl48s/RSQf4mWZtybX6wbN7afU/1X + IBXdllb7uR9qTf9Rut3Pd9wykQwARWcANOa+5Herb7s0kKUh8Pvpju9/xl0TxQBQdAZAuKkt75hc0m63 + j6++5dJA12q1T/jQOyaXpdue7rh1eskAUHT5yD6Ujo0I01/9aGvPL1TfammoSn+QenHypfrbZ74MAIVn + AMS4rTW92Z/n17CX//qA21qTN9Y9A8yPAaDwDIDeu601NeKX/LVQyree7n608zlgfgwAhbdldRoAf5oO + jl5ZW31rpQXVh1rTV9Y8D8xRfjdX31oppnxkt6VjowdaUze3j/OTvxZm+fbTM3BL7bNB1wwAhWcA9Ehr + 6ltbztv2/OrbKi3Ibmw9cmJ6Hv7msOeDrhkACs8A6IHW1P4tq3a/tPqWSgu621ZNvDw9FwcOe07oigGg + 8D6QjuyD6diYuzQALqy+nZJSH2xNr6p7Vjh2+d1cfTulmJ4eANPp4JiT1p7v5L8Vqvp2Skp9+qz289Lz + 8b3DnheOmQGg8AyAebp0z2urb6WkZ3TbpVOn1j4zHBMDQOEZAPPQmn54y8ntZ1XfSknPKD8b6Rl5sPbZ + 4agMAIWXj+zWdGx07wOXTp9TfRsl1XRra3pF3bPD0RkACm92AFyaDo5u/ejWi/e/sPo2SqopPyOzz0r9 + M8QRGAAKzwCYq6nPVN9CSUfo1tXTd9Y/QxyJAaDw8pF9IB8bXbn10j0XVN9CSUfolkunLqp7hjgKA0DR + GQBz88HWnl+vvoWSjtAHWnt/o+4Z4igMAEVnAMzJk/kfeVp9CyUdofys5Gem4xniaAwARWcAzMnD1bdP + 0jGUnplHOp4hjsYAUHT5yG5Jx0YXVk/fWX37JB1D6bm567DniCMyABSeAdC9tM4/Un37JB1D6bn5WOdz + xJEZAArPAJiDP52+sfr2STqG0nNz02HPEUdkACi8fGR/sXq6zbG7ZbUBIHXTX6yavqnuWeLHMwAUngEw + J/4UgNRF6Zn5WMczxFEYAArPAOievwhQ6q703Hyu8zniyAwAhXdTOrKb07HRFX8boNRF6Zl5pOMZ4ijy + u7n69kkxGQBz4h8EJB1j+VnJz0zHM8RRGAAKzwCYm1tW731F9S2UdIRuXr33N+ueIY7MAFB4BsBc7Xlb + 9S2UdIRuXjV1Uf0zxJEYAAovH9n707HRrak7qm+hpCOUnpe7Dn9+OBoDQOEZAHP2oxtb4y+qvo2Sarr1 + 4v0vzM9Kx7PDMTAAFN7sAFiVDo6u3XzJ9LnVt1FSTe+/ZHpF3bPD0RkACi8f2U352JiLh7e22s+uvpWS + ntGWk9vPSs/Igx3PDMfKAFB0BsD83Lh66nXVt1LSM7rxkunT6p4ZjpEBoOgMgPl5/6qpB7a02s+tvp2S + Utec1X5eej789D8fBoCie3oA7EkHxzxcVH07JaVuumTvpTXPCd0wABRdPrIb07ExLwduvOixl1XfUmlB + d8NF+345PROPdzwjdMkAUHgGQG+kxf73G1tjP1F9W6UF2Y2t9onpefjbzueD7hkACs8A6KXpW9rHtY+v + vrXSgqrVap+QnoMPHv5cMBcGgMLLR3ZDOjZ6I42Aa6tvrbSget/qvVfVPRPMjQGg8GYHwCXp4OidVXtG + /UqAFkr51tNPrFfUPgvMmQGg8AyAMDf42wM17OUbv2HV3vfX3D/zZAAoPAMg1NduWrXnF6tvtTRU3fz2 + qRenG7+/4+bpEQNA4W1KR/a+dGyEmd68as+b8l8gVX3LpYEu3/INq/acmW57T8et00P53Vx9y6WYDIDG + fGXTqulXVt92aSB738XTf/C+i/d8tea+6TEDQOEZAA1bNf3FNARe468P0KCUbzXf7Psumf5S7U0TwgBQ + ePnINqdjo3GTmy7ZsyG9VP94c2vvC6r/OqQiyjeZ/6C/+eI91+Vb7bhdGmAAKDwDoAhPJQ9uvmTvX22+ + eO+6TRfvuWTzqulz0kBYPjRW7Xt5dXIDX/4stZ9xQM3eWr65dHtpkH7y6Vucvcm6W6UhBoDCMwBoQv4D + TXVyA9/sHzRrPiP0kgGg8DZduOektP7bEGrIBkDtZ4ReSu/m6uSkmAwAGmEAQHcMAEVnANAIAwC6YwAo + OgOARhgA0B0DQNHlI7s+HRtEGrYBUPcZoZcMAIVnANAEAwC6YwAoPAOAJhgA0B0DQOHlI9uYjg1CDdEA + yJ+l9jNCDxkACs8AoBEGAHTFAFB4swPgonRwEOnCIRoA6bPUfkboIQNA4RkANMIAgK4YAApvfTqy6y7a + 24ZIwzYA6j4j9FJ+N1cnJ8VkANAEAwC6YwAoPAOAJhgA0B0DQOHlI9uQjg0ipTsbmgGQP0vdZ4ReMgAU + ngFAEwwA6I4BoPAMAJpgAEB3DACFZwDQBAMAumMAKLx8ZOsvzMcGkYZrANR/RuglA0DBGQA0wwCA7hgA + Cs4AoBkGAHTHAFBw+cjem44NIg3bAKj7jNBLBoDCMwBoggEA3TEAFJ4BQBMMAOiOAaDwDACaYABAdwwA + hZeP7Np0bBBreAZA/iz1nxF6xwBQeAYAzTAAoBsGgMKbHQBvTwcHkYZtANR9RughA0DhXZ2O7D3p2CDS + sA2Aus8IvZTfzdXJSTEZADTBAIDuGAAKzwCgCQYAdMcAUHj5yK5JxwaR0p0NzQDIn6XuM0IvGQAKzwCg + CQYAdMcAUHgGAE0wAKA7BoDCMwBoggEA3TEAFF4+sqvzsUGkIRsAtZ8ReskAUHSzA+Bt6dgg1BANgPRZ + 6j8j9JABoOieHgCPpYODSPuGaADsSwOg7jNCDxkAii4f2Z+nY4NIwzYA6j4j9JIBoPAMAJpgAEB3DACF + ZwDQBAMAumMAKDwDgCYYANAdA0Dh5SN7dzo2iDU8AyB/lvrPCL1jACg8A4BmGADQDQNA4RkANMMAgG4Y + AArvypV7Tlp3wWNtiDRsA6DuM0Iv5XdzdXJSTAYATTAAoDsGgMIzAGiCAQDdMQAUngFAEwwA6I4BoPDy + kV2Vjg0iXTlEAyB/lrrPCL1kACg8A4BGnL/37OrkBr70Wc6t/YzQQwaAwjMAaMT5+y6pTm7gS59lde1n + hB4yABRePrIr87FBrCurkxv40mdZ1/HZoPcMAEVnANCE9BPNJ6qTG/jS5/lk5+eDnjMAFN3sADg/HRvE + eqA6uYEvfZYHOz4b9J4BoOjykb0rHRsEe3Lkwj0/XZ3dwLbuvL0vSJ/lqY7PBj1nACg8A4AGvbo6u4Ht + igv2/Z+azwU9ZwAoPAOA5uxdX53dwJY+x3WHfy7oPQNA4RkANGii1Wo/tzq9gSt/7fkzdHwmCGEAKLx8 + ZFekY4MmrF352B9VpzdwrV257zV1nwkiGAAKzwCgYfdVpzdwpZ/KvlDzeSCEAaDwDAAad8Fjv1ed38D0 + rvP3/WHtZ4EgBoDCG0lHtjYdGzQlvdy+2mq1T6hOsPjy1zp6/mNfrvssECW/m6sTlGIaWXngpLUr97Wh + SekPqMuqEyy+0RX7zqz7DBApv5urE5RiMgDok6mRc6d/vjrDYhs5b88vpK91T8fXDuEMAIVnANAvV6yc + /VMBxf5tgRuXt5+Tvs77O79uaIIBoPDykY2mY4P+2H9D+7j28dU5FlP+mkbPf+z99V8zxDMAFJ4BQL+t + XbF/tDrHYlq7cv8VdV8rNMUAUHgGACUYWbHv6hL+zoDZn/xX7l9b9zVCkwwAhZePbGT22KDvbll3Xvv5 + 1Wk2XhogP7Fm5b4P1nxd0AcGgIIzACjK+fu+c/n5+/5jdZ6NtWblYy9Lv/9vHfb1QN8YAArOAKBAj6ch + 0LrmrPbzqjMNK/+V/qMr95+Tfp/7Or4G6DMDQMHNDoAV6digPN8bWbn/1C0nt59VnWvParXazx5dsf8N + I+fte7Dm9wv9ZwAounxka9KxQcEevnzl/vOuuGD/i6qznXOXn3vgZ9as2L8i/zY7fh9QFANA4RkADJAn + 16zcd+ealY9duOb8vb95LH+KIP2kf+Kfrdj7W7P/Nyv23TX726j/bUNRDACFZwAwwJ5KP83/IP3r3Zev + 2PeR9Af5m7LZf5/+Z9X/Lv1nav9voWgGgMLLR5ZemG0AymEAKDwDAKA8BoDCMwAAymMAKDwDAKA8BoDC + uywd2Z+lYwOgHPndXL2mpZhmB8B56eAAKIYBoPAMAIDyGAAKLx/ZO9OxAVAOA0DhGQAA5TEAFJ4BAFAe + A0Dh5SO7LB8bAOUwABSdAQBQIANA0T09APangwOgGAaAojMAAApkACi6y84+cNI7zt3fBqAc+d1cvaal + mAwAgPIYAArPAAAojwGg8PKRtdKxAVAOA0DhGQAA5TEAFJ4BAFAeA0DhGQAA5TEAFN7qdGR/mo4NgHLk + d3P1mpZiMgAAymMAKLzZAXBOOjgAimEAKLx8ZJemYwOgHAaAwjMAAMpjACg8AwCgPAaAwjMAAMpjACi8 + fGSr87EBUA4DQNEZAAAFMgAUnQEAUCADQNHlI1uVjg2AchgACm92AJydDg6AYhgACs8AACiPAaDw8pFd + ko4NgHIYAArPAAAojwGg8AwAgPIYAArPAAAojwGg8C5MR3bx2QfaAJQjv5ur17QUkwEAUB4DQOEZAADl + MQAUXj6yi8460AagHAaAwjMAAMpjACg8AwCgPAaAwjMAAMpjACi8fGQX5mMDoBwGgKIzAAAKZAAoOgMA + oEAGgKLLR/b2dGwAlMMAUHgGAEB5DACFNzsA3poODoBiGAAKzwAAKI8BoPDykb0tHRsA5TAAFJ4BAFAe + A0DhGQAA5TEAFN7KdGQXpGMDoBz53Vy9pqWYDACA8hgACs8AACiPAaDwDACA8hgACm/lmQdOOv9PDrQB + KEd+N1evaSkmAwCgPAaAwjMAAMpjACi8fGQr87EBUA4DQNE9PQAeTwcHQDEMAEVnAAAUyABQdPnIVqRj + A6AcBoDCMwAAymMAKDwDAKA8BoDCmx0Ab0kHB0AxDACFl4/svHRsAJTDAFB4BgBAeQwAhWcAAJTHAFB4 + Z6cjOzcdGwDlyO/m6jUtxWQAAJTHAFB4BgBAeQwAhWcAAJTHAFB4+cjOSccGQDkMAIU3OwDOTAcHQDEM + AIVnAACUxwBQePnIzp49NgDKYQAoOAMAoEQGgIIzAABKZAAoOAMAoEQGgILLR3ZWOjYAymEAKDwDAKA8 + BoDCMwAAymMAKLx8ZG998+NtAMphACg8AwCgPAaAwjMAAMpjACi8M9OR/cmbn2gDUI78bq5e01JMBgBA + eQwAhWcAAJTHAFB4BgBAeQwAhZeP7C3p2AAohwGg8AwAgPIYAApvdgC8KR0cAMUwABRePrIz87EBUA4D + QNEZAAAFMgAUnQEAUCADQNEZAAAFMgAUXT6yN6djA6AcBoDCMwAAymMAKDwDAKA8BoDCy0f2pnRsAJTD + AFB4Zy5NA2B5OjgAipHfzdVrWorJAAAojwGg8AwAgPIYAApvaTqy5enYAChHfjdXr2kpJgMAoDwGgMIz + AADKYwAovHxky9KxAVAOA0DhGQAA5TEAFJ4BAFAeA0Dh5SNbuiwdGwDlMAAU3fLlB36t9vgA6Jv8bq5e + 01JMy5cffNnSZTPp4AAoxbJlM79UvaalmN785sd/tu74AOif5csP/Ez1mpZiOvWs9k8uSccGQDne8pb2 + v6xe01JMrVb7hHRsP+o8PgD65tBxx7WPr17TUlzp2B7qOD4A+mX5zAPV61mKbfGymduTNgBF+Mvq9SzF + lo7tqo7jA6Bfls9cUb2epdiWLHnijYuXpqMDoO/SO/m06vUsxbZ8+RMvrjtCAJqXBsBLqtezFN+ipTM/ + OCMdHgD9kwbA96rXstRMaQBsrjtGAJqT3sUbqtey1EyLl828qu4YAWhOehf/z+q1LDVTq9V+dlqejyZ5 + gQLQvF35XVy9lqXmSuvz6pqDBKAJS2auql7HUrMtWnbov9QeJQDhTl968Fer17HUfIuWzdxRd5gAhPpU + 9RqW+tMblzzx+29cMtMGoDmnL37id6vXsNS/0jF+vvM4AQhzd/X6lfrbaYsP/Xo6yKc6DhSA3nvq9CWH + fqN6/Ur977TFMxtPT8cJQJw3Lp65tnrtSmW0ZEn7Bek4xzuPFYDeSD/9P3rKme2frl67UjmdtvTga+qO + FoB5+6fTlx58dfW6lcorHel7Oo4WgHk6bcnMuuo1K5XZWWe1n5cO9etJPlgA5mvxE189+eT2c6vXrFRu + p5/++M+mo/3Hw44YgG5tO335Ey+uXq9S+Z2yaOY/nLb40K7TFh9M6xWAOZg4benBl1evVWlwOn3xj377 + DYsP7kvaAHRl36lLD/1W9TqVBq/8Dwl6w+KZ8ZrjBqBG+sl/Mv8AVb1GpcHtjW+c+cU3LDn4cN2hA/DP + Tl188JH0Q9NLq9enNPi9bvGBf3vqkpnPp+POBw5ApzMObV20aP+LqtemNDydfHL7WWnhttKhP3XY4QMs + XP906uJDV7+y1X529bqUhrM3LJ357+ngf9DxAAAsOPlPj552xhN/WL0epeHv5JPbz69+NeCJzgcCYAE4 + lN6Bo4sWtU+sXovSwuq1y2Z+KT0It56y+OCTSRtgyOV33S1vWDLz76vXoLSwO23pE//ulDMOXX3KGQdn + kjbAkDmU/sB/s7/CX/oxnbyk/YJTFh9afsrimS/WPEAAg+bbpyw6+PbXL93/wuo1J+lonXrGwV9+3Rkz + 57/+jIOfSvYlbYDCPfb6RQdvf/2imRXpX19Wvc4kzbX8t8ecsuTQb5yy+NCi9FCNvO6Mgx9ND9rXku+/ + /oyZ8fSvj1cPH0Ck9K45tCv9a3r3HPxa9S5ak99Nr1106BX+Vr5B6bjj/h81C5i9dvi9qgAAAABJRU5E + rkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vAAADrwBlbxySQAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAACYcSURBVHhe7d0L + kJ3lfd9xjB1f2k7aOtPYbTJJ2rSJnTRpG2rHbppO2pnONO00bjJDbbDBQhLyJQHMxQgDsg84SAKDHO4I + sLkYYxA4ThpywWAExsb3XJw4xuEWV0iLVrurBUkgCcjp8ywvNT56xe7ZPf/3POc9n+/MZ+w2RDrvy3Pe + 9ydxySEajbobv/4D01c9+qbpK7cun7ly6/rkMzMbt/7pzMZHH0r/fUfyZNKFETeTbEln+/6ZKx+9O/33 + K9OZP2Xm6q3/c/tV219TfR0kqd3NXLXl59MDcHXyJ8nupO6BCePkW2kcXLLzym2//sg1j7yy+qpI0ug3 + eenka6c3Pnpi+lXPnydd4KB2JlfvuGrLr3S73ZdUXyFJGq1mP779X6QX/8bpK7ft73nIAfP7q6mrHj06 + /6Wy6islSWU3tXHb66Y3bts0vXHrs0kXWJJH0og+ttvpHlp9xSSprLZs2PKqHRu3dqY2bt2bdIGB+tPp + K7f+h+rrJkllNH3Ftv+WHlB/2/PAAgbr2fyX1R67/rG/X331JGk4dTvdl1W/6n+250EFxLl/+xWP/pvq + ayhJzTZ91aM/mh5EX+x5MAHNeHL6iq0rqq+jJDXT1FXbXp9+5f/dpAsMz+SVW9f7RwYlNdLUlRNvSA+e + yd4HETAckxu3XZv/clz1FZWkwbf98q2/lB44u3sfQMBwTW189Fb/zgBJIU1cOfGz2zdunZ5MDxugRNtu + e+CiB15RfWUlaeltu2Tbj09ese3RpAsU7dPdjV2/EyBp6eVfUaSHyjd6HjJAufxOgKSlt/3ybZdtTw8V + YHQ8ZgRIWkqTGycOr3u4ACPBXw6Q1H9brt7y6vQA2dHzQAFGiN8JkNR3k5dvu6rugQKMFiNA0oKbuHLi + Demh8WySHx7A6DMCJM1felh8oefhAYy4CX9PgKQXa+LyiV+pe3gAreB3AiTVt+3ybXdMXJ5+tQC0kxEg + qbetl2/9d7UPDKBdLvOXAyS9oInLJi6qfVgA7eN3AiTl8q8G0kNh8oCHBNBeRoCkrVdsfcu29EAAxowR + II13E1dMfLz24QC0nxEgjW/pIfDIAQ8FYHwYAdL4lf/v/W9NDwBgvBkB0pj16OUTy+oeBsD4efSybZ/+ + un9EUBqPtl227YKtl6UvP0CSngl+J0Aah/KXve4hAIwvI0Aagx69bOKBR9MXHqCHESC1tW6ne2j6kj/d + 86UHeJ6/J0BqY9MXTf9gzRce4IX8ToDUtrZcvuVHtqQvOMA8jACpTW3buO11NV90gDpGgNSWtl2y7Re2 + XDaRvtgAC+LvCZDa0Hcv23ZYzRcc4MX4nQBp1MsD4P9eOtEF6MeWS40AaaQzAIDFMgKkEc4AAJbCCJBG + tDwAvpu+xABLYARIo5YBAAyIESCNUgYAMEBGgDQq5QHwt+mLCzAgRoA0ChkAQAAjQCo9AwAIYgRIJTc3 + AC5JX1aAQbvYCJCKLQ+AR9IXFSDCw0aAVGYGABDNCJAKzAAAmmAESIX1YBoAD+cvJ0A0I0AqJwMAaJQR + IJWRAQA0zgiQhp8BAAyFESANtzwAHkpfRoDGGQHS8HrwwjQALp77IgIMgxEgDSMDACiAESA1XR4AD6Yv + IMCQGQFSkxkAQEGMAKmpDACgMEaA1EQGAFAgI0CKLg+ABy5+rAtQkgcvfswIkCIzAIBSGQFSYAYAUDIj + QAoqD4C/ueixLkDBjABp0BkAwIgwAqRBZgAAI8QIkAbVt9MA+E76YgGMCCNAGkQGADCCjABpqRkAwIgy + AqSlZAAAI8wIkBZbHgD3py8SwCj6thEgLS4DABh1RoC0iOYGwIXpSwQwwr59oREg9VUeAOmLk788AKPO + CJAWmgEAtIwRIC0kAwBoISNAmi8DAGgpI0B6sfIA+Ov0ZQFoISNAOlgGANByRoBUlwEAjAEjQOotD4Bv + pS8IQMsZAdILmxsAv5O+HABtZwRI38sAAMaKESA9lwEAjB0jQDrkkG+mAfBX6QsBME6MAI19BgAwrowA + jXXfvHBHGgDb05cBYPwYARrb8gD4y/QlABhbRoDGMQMAIDECNG4ZAAAVI0DjVB4A3/zo9i4AmRGgMckA + AOhlBGgMMgAA6hgBankGAMDBGAFqcXkA/EU66AAcyAhQazMAAF6cEaBWZgAAzM8IUOvKA+DP0+EGYD5G + gFqUAQDQDyNALemb56cBsCEdagAWyAhQCzIAABbDCNCI9400AP4sHWYA+mUEaIQzAACWwgjQiGYAACyV + EaARLA+AP00HGIDF+4YRoFHLAAAYDCNAI5UBADA4RoBGJgMAYLCMAI1EeQB844J0YAEYHCNApWcAAAQx + AlRyBgBAICNApZYHwNcvmOwCEGTDpBGg8jIAAOJ9bcPkpzd3ui+rHr3S8DMAAJqy/YZut/uS6vErDTcD + AKBR66vHrzTc8gD4WjqUADRkw+RvVY9gaXgZAACN2/+Vj25/c/UYlobT3AA4Px1IAJpzwfbv3rfh8VdX + j2Kp+b6cBsBX02EEoHE3V49iqfkMAIDh+doFk/+9ehxLzWYAAAzPV86ffGBz55FXVo9kqbnyAEgHMB9C + AIbj9OqRLDWXAQAwdLNfXz/zD6vHstRMBgBACbafWj2WpWYyAACK8Nh9G7a8qno0S/HlAfDldPgAGK4v + XTC5rHo0S/HNDYCPpMMHwJDtuKN6NEvxGQAAxXj2y+dO/2j1eJZiywPgS+ngAVCCHSdVj2cpNgMAoBz3 + fWTy9urxLMVmAAAUZc+3Ot2XV49oKS4DAKAw523/peoRLcWVB8B96cABUIY0APxLgRSfAQBQmPMnP1Y9 + oqW4DACAsnzxI5P3Vo9oKa570wD44nnpwAFQiu3VI1qKywAAKM8fXfTAK6rHtBTTcwNgRzpwAJTiK2uf + +KHqMS3FZAAAlOdL6yZ+onpMSzHlAfCFdNgAKMd96x/7ueoxLcVkAACUJz+bq8e0FJMBAFAeA0Dh5UN2 + bz5sAJTDAFB0BgBAgQwARXfvujQAzk2HDYBypGdz9ZiWYsqH7PPpsAFQDgNA4RkAAOUxABSeAQBQHgNA + 4RkAAOUxABRePmT3pMMGI+iZ9KB88J7zdnzu8+dObbp7/dQ1Wf7v6X92V/JQ/mOqPxZGigGg8AwARsjT + 95w79Sfppf/+u9dNvWEh/9fS8h+T/9g0DE69Z/3k7c/9GLU/NhTFAFB4BgAj4G/uOW/yhC9+5LEfro7t + orvznO2vSQPifXM/Zv3PBUUwABTeXemQ3Z0OGxTorzev3/G2TZu6L62O68DKP+bd5+04Iv0c9/f8nFCE + /GyujqsU09wAWJ8OHJRjz+Z1OzoL+S3+pfb1jd0fuGf95Anp59zV8xlgqAwAhWcAUJhv3bV++mer49lY + d52746fvXrfjL2o+DwyFAaDwDACKsW7H9Zs7j7yyOpqNd9+GLa/avG7HDbWfDRpmACi8fMg2p8MGw3T3 + uqkLO53uodWxHFrdbvcl6eF7bt1nhCYZAArPAGDY7lo3ubY6jsW0+dzJ9XWfFZpiACg8A4Ahuzr/qrs6 + jsWUP9Nd66c+XvN5oREGgMLLh+yufNigeV/Z1Om+vDqKxZX/CYHN507eV/O5IZ4BoOgMAIZk5nPn7/zx + 6hgW2+Z1Ez+RPuvOns8O8QwARWcAMAzpV9YrqiNYfJvX73hX3TVAKANA0c0NgHVT6bBBQ9ZOfaWEv+N/ + oeXPmj73lw64DghlACi4fMg+lw4bNOXOtZO/XB2/kenOc3b857prgSgGgMIzAGjW9D3V0Ru50nfl3vpr + gsEzABSeAUCT7lo/9Zbq6I1cd62d+o26a4IIBoDCy4fsznTYoAFTJf9jf/OVP/ud63bsqLkuGDgDQOEZ + ADTo0urYjWx3rJu6vOa6YOAMAIVnANCUu9bu+LXq2I1sd6yd+o26a4NBMwAUngFAQ57Z3Nn5j6pjN7Ll + a8jX0nNtMHAGgMK7PR2yO9Jhg2Dfro7cyJeu5Ts91wYDl5/N1ZGTYpobAGvTgYNI50z9XnXkRr50PX9w + wPXBgBkACs8AoAl3rps+vzpyI98d63ZsqLtGGCQDQOHlQ/bZdNgg0h3rps6ojtzI99l102vqrhEGyQBQ + eAYATbh97dTx1ZEb+T57zvQJddcIg2QAKDwDgCakc7aqOnIjX76WumuEQTIAFF4+ZOlXZ/lXaBCnZQOg + 9hphkAwARWcA0AgDAPpjACg6A4BGGADQHwNA0RkANMIAgP4YAIouH7I/OWeqC5FuP6dFAyBdS901wiAZ + AArPAKAJBgD0xwBQeAYATTAAoD8GgMLLh+yP02GDWO0ZAPla6q8RBscAUHgGAM0wAKAfBoDCMwBohgEA + /TAAFJ4BQDMMAOiHAaDwbkuH7I/SYYNIbRsAddcIg5SfzdWRk2J6bgBMpwMHcf74nJkWDYCZNADqrxMG + xQBQeLednQbAb6cDB4FaNwBqrhEGKT+bqyMnxZQP2R+mwwaRbmvRAMjXUneNMEgGgMIzAGiCAQD9MQAU + ngFAEwwA6I8BoPAMAJpgAEB/DACFlw/ZbfmwQaSWDYDaa4RBMgAUnQFAIwwA6I8BoOgMABphAEB/DABF + lw/ZH6TDBpHaNgDqrhEGyQBQeHMD4MPpwEGg285u0QBI11J3jTBIBoDCMwBoggEA/TEAFF4+ZP8nHTYI + 1aIBkK+l9hphgAwAhWcA0AgDAPpiACg8A4BGGADQFwNA4RkANMIAgL4YAArvM+mQ/X46bBCpbQOg7hph + kPKzuTpyUkwGAE0wAKA/BoDCMwBoggEA/TEAFF4+ZL939nQXIn2mRQMgX0vdNcIgGQAKzwCgCQYA9McA + UHgGAE0wAKA/BoDCMwBoggEA/TEAFF4+ZJ+ZO2wQqV0DoP4aYZAMAAVnANAMAwD6YwAoOAOAZhgA0B8D + QMF95uzZw3737JkuRGrbAKi7Rhik/GyujpwUkwFAEwwA6I8BoPDmBsBZ6cBBoNYNgJprhEEyABSeAUAT + DADojwGg8PIh+3Q6bBCqRQMgX0vtNcIAGQAKzwCgEQYA9MUAUHgGAI0wAKAvBoDC25QO2a3psEGktg2A + umuEQcrP5urISTEZADTBAID+GAAKzwCgCQYA9McAUHgGAE0wAKA/BoDCy4fsls5MFyJt6rRnAORrqbtG + GCQDQOEZAEV4Nrk/+b1bOtMfTS+Y027t7Dz+lrNm3pWsTv9/H07/s08kX052JXU/RtEMgCLsSp/9S+k/ + 01maPnvubKUzls9aPnP57KX/2e8n+SzmM1n3Y9AQA0DhGQBDM5Vcvqmz89c2dR5/dfWnY942d7ovu/Xs + qV987oE982cv+PGKZgAMR/qs38gv+k2dqTfms1Ndwrz97tonfuiWs3a+Jf0YVybTL/wxaYYBoPDyIUsP + ifygoBn33tzZ+b82buz+QPWnYEnd9OGp19/cmbk0/bhP9vw8pWnVAOi5ttLsSS+QS27tTL2u+shLalOn + +/JNZ+389fTjfrHn5yGSAaDoDICm7PzKzWfP/FJ12wfe73Z2/fCmzvTvpJ/r6QN/7iIYAPH239LZuWHT + 2l3/pPqoA++Ws2d+OZ3lr9b83AyaAaDoDIBwO2/uTC/vdLqHVrc8tJs6M/86/Zxf6PkMJTAAYt2bBuDP + VB8xtHyWb+lMr0w/52zPZ2CQDABFlw/ZzemwEWHnV2/68OxPVre6sTZt6r40jY5O+gzPHPiZhiM90Fo1 + AOqucUj+Lv25vnBQf0mpn9J9+LHkizWfiQEwABSeARDjps70NcN4KL+wTWfN/I/0WXb3frZhMABC7L7p + rJlfrT7WUMpnPH2O63o+FwNgACg8AyDE+m63+5LqFg+1NETelD7PVM/na5wBMHBTnzp76herjzTU8llP + n+fcns/HEhkACm/TmjQAPpQOHANx04dmLq5ubTHddObU69Nnm+j9rE1q3QCoucbGdGYmN62Z+bnq4xTT + zZ2d59d+XhYlP5urWyvFlA9ZemnlFxdL1Zm5oXtIGb/y7y2/MNLnm6z93E1o0QDI11J7jU0o9OWfy2c/ + fwdqPzd9MwAUngEwMH+56cQtr6pua5Hl3wlIn3Oi53M3wwBYuoJf/s93TeeRV6bP+mcHfHb6ZgAoPANg + ADozu28c0L90Jbqh/U6AAbA0I/Dyf765oZn/BsW662DBDACF98l0yD6VDhuLd2Nn5tTqdo5E+QGdPvdE + 73VEatsAqLvGMOnlf8OIvPyfL92j02qvhQXLz+bqdkoxPTcAdqYDxyI98EfHdV9R3c6R6bkRMJtGQO01 + DdxNndkWDYDZNADqr3PgOjtH7uWfy//64DSM76+9JhbEAFB4BsDS3NiZ/d/VrRy58oslv2DqrmvQDIBF + GNGX//N96oOzb629LhbEAFB4BsCSPLTp8O5Lq1s5kjX1OwEGQJ9G/OWfy9+NdC0PHHBtLIgBoPDyIbsx + HTb6lx7Sx1e3caTLL5ob0wun7hoH5ZMtGgD5WuqucWBa8PJ/vk9+cOcJtdfIvAwAhTc3AD6YDhz9evrG + 03e/prqNI1/+nYAbPzg7UXOdA5HOWXsGQLqWumsckNa8/HPXd3b9cLqmp3uukQUwABSeAbA4n1wzc3t1 + C1vT3O8EpBdQ77UOggGwIK16+T9fuq7P9lwnC2AAKLx8yD6ZDxv9WTN7SnULW1X+nYAbPjg7UXvNS9Gy + AVB7jUvTypd/7oY1s6fWXC/zMQAUnQGwSJ3H31jdwtYVMgIMgBfT2pd/7obO9Jtqrpn5GACKzgBYlKfz + P+dc3cJWll9I6Tone6578QyAg2n1yz+X/z0Z6Tqf6blu5mMAKDoDYFEerG5fqxvo7wQYAHVa//J/vnSt + D/dcO/MxABRdPmQ3pMPGwqUv52er29f68gvqE/lFVXMf+tG2AVB3jf2Yu6dj8vLP3bBm5x1194GDMwAU + ngGwKJuq2zcWXV/9TkDNfVgwA+B7xu3ln0uj+da6e8HBGQAKzwDoX3qYfby6fWPTUkeAAfCccXz559K1 + X9t7L3hxBoDCy4fsE2vSg4mFO3P8BkAuj4BPrJmdqL0n82rPAMjXUn+N8xrLl38ufWeurbkfvAgDQOEZ + AP27Yc14/SWAF7b4ETD2A2BsX/65dP239twP5mEAKDwDoH/5b2iqbt9Yll9k6T5M9t6XFzfWA2CsX/65 + dA/u7LknzMMAUHjXpkN2fTps9OWh6vaNbfl3Aq5fMztRc29qtW0A1F3jQYz9yz+X7sMjPfeFeeRnc3X7 + pJgMgEV5pu3/IqCFlF9s6V5M9tybWmM6ALz8Uxcd131FuhfP9Nwb5mEAKDwDYLEe/8XqFo51C/2dgDEc + AF7+VdetmX5zzf1hHgaAwjMAFue6M2ffX93CsW8hI2DMBoCX/wv6xJmzq2vuEfMwABRePmTXpcNG38b6 + bwTs7Zr0wkv3ZLLnHv1/6Zy1ZgDka6m7xspkvhfVH6pUuid39twjFsAAUHgGwKI9c01n8rXVbVQq/07A + dWtmJ2ru1bgMAC//nvJ3JN2XZ3ruEwtgACi8uQFwZjpwLMYJ1W1U1dzvBJy5c7LnPrVvAPRcX+LlX9P1 + Z+x8X829YgEMAIWXD9m1+bCxGA9v7nRfVt1KVeXfCbj2zNmJ77tXLRsA33dtXv61bTq8+9J0bx7suVcs + lAGg6AyApbnujNm3VrdSLyi/ENP9mfz/96q9A8DL/yCl+/K2F9wn+mUAKDoDYMkezP+cc3U79YK+73cC + 2jkAvPwPUv73ZFy7Zud3qvvEYhgAiu65ATCbDhyLdc0Zs6dVt1M9XX/mrudGQOsGwKyX/4t03Rmzp7/w + O8IiGACKLh+ya9JhY0n2fPwDu36muqXqKb8orztj569X/8+RL1+Ll//Bu3bN9M/m70TPd4Q+GQAKzwAY + lMf/amNn29+rbqs0ll3T6b4yfR/+/MDvB/0yABSeATA41545e2On0z20urXSWJXPfv4O1H036J8BoPDy + Ift4OmwMxsfOmL20urXSWPWxNY9fUPedYHEMAIU3NwDOSAeOgbnm9Mc/VN1eaSzKZ77uu8DiGQAKzwCI + YQRoXLrm9NnVdd8BlsYAUHgGQBwjQG3Pyz+OAaDwrkqH7GPpsBHECFBLuzq9/GvPPAORn83VrZZiMgAa + YASoZXn5xzMAFJ4B0BAjQC3Jy78ZBoDCy4fs6nTYiGcEaNTLL/+6s83gGQAKzwBolhGgUc3Lv1kGgMIz + AJpnBGjU8vJvngGg8K46bfawq05Ph42GGQEaja5ML//6M0yo9Gyu/hRIMRkAw2QEqOy8/IfIAFB0BsCw + GQEqMy//ITMAFJ0BUAIjQGXl5V8AA0DR5UOWvuxdhssIUCml87i693zSPANA4RkA5TACNOzSOfTyL4QB + oPAMgLIYARpW6fx5+RfEAFB4+ZBtTIeNkhgBarYr0su//iwyLAaAwjMASmUEqJm8/MtkACi8uQHwgXTg + KM9pRoBiu+K09PKvO3sMnQGg8AyAwhkBCsrLv2wGgMK7LB2yKz7weJdyGQEadPnlX3fWKEd+Nld/uqSY + DIDRYARoUHn5jwYDQOEZAKPDCNBS8/IfHQaAwsuH7PJ02BgRRoAWWfqur649UxTJAFB4BsAIMgLUZ17+ + o8cAUHgGwIgyArTAvPxHkwGg8AyAEWYEaJ68/EeXAaDw8iG77LR82BhFRoAOVn75150ZRoUBoOAMgNFn + BKg3L/82MAAUnAHQDkaAns/Lvy0MAAWXD9ml6bDRCkbAmJdf/jXnghFkACg8A6B1jIAxzcu/XQwAhWcA + tJIRMGZ5+bePAaDwDIDWMgLGJC//djIAFF4+ZJekw0b7pIeIEdDyLkkv/7o/94w+A0DhGQDtZgS0Ny// + djMAFN7cAFidDhytdempRkDbmnv51/y5pj0MAIV3YTpkF6fDRssZAa0pv/xr/xzTKvnZXP0pl2IyAMaI + ETDyefmPDwNA4RkAY8YIGNm8/MeLAaDw8iG7KB02xocRMHpdlF7+dX8uaS8DQOEZAOPJCBidvPzHkwGg + 8AyA8WUElJ+X//gyABSeATDejIBy8/IfbwaAwsuH7MJ82BhfRkBx5Zd/7Z8rxocBoOjmBsCp6bAx7oyA + Qrro1PTyr/9zxDgxABTdcwPgiXTgYJcRMOQuOvWJ9PKv+3PD2DEAFF0+ZL+TDhtkRsDwSvd/de+fD8aX + AaDwDAB6GQHNl+67lz/fxwBQeAYAdYyA5kr328ufAxgACs8A4GCMgPjSffbyp5YBoPDyIftoOmxQzwiI + Kj3kV9ffczAA1EAGAPMzAgadlz/zMQAUngHAwhgBg8rLn4UwABTe+SfPHrbh/U90YT4fPcUIWGoXpJd/ + 3b2FXvnZXB0bKSYDgH4YAYvPy59+GAAKzwCgX0ZA/3n50y8DQOEZACyGEbDwvPxZDANA4eVDdkE6bNA3 + I2De8su/9t7BPAwAhWcAsCRGwEHz8mcpDACFZwCwZEbAAXn5s1QGgMLLh+z8fNhgCYyA7/WR9PKvu0fQ + FwNA0RkADIoR4OXPABkAim5uAJySDhsMwDiPgI+ckl7+NfcEFsUAUHT5kKUHVxcGZ/xGQLru1QfeB1g8 + A0DhGQDEGJ8RkK7Xy5+BMwAUngFAnPaPgHSdXv6EMAAUngFArPaOgHR9Xv6EMQAUXj5k56XDBlHaOALO + TS//umuFQTEAFJ4BQBPaNAK8/GmCAaDwDACa0oYR4OVPUwwAhbcuHbL0UOtCM0Z3BKTPv/rA64EY+dlc + HT0ppnUn7zns3JN3daExJ43eCEgP5NW11wJB8rO5On5STAYAQzFCI8DLn2EwABSeAcDQjMAI8PJnWAwA + hZcP2fp02GAYSh4B69LLv+4zQxMMAIVnADBsJY6A/JnqPis0xQBQeAYAJVh30q4LO53uodWxHFrdQ7ov + WX/y7nPrPiM0yQBQePmQrZs7bDB0N2w4sfuq6mg2Xv65156861M1nwuGwABQcAYARTll11+vP3H3z1XH + s7HWnvzE69LP/xcHfB4YGgNAwRkAFOekXXvWn/zEaZ1O9+XVMQ3rouO6r0g/1+n556z9LDA0BoCCmxsA + J6XDBuX5TvLWTYd3X1od14GVf8x1J+8+Iv34D7zg54NyGACKLh+ytemwQcEePOfk3Secc8Lu11THdtGd + 9/7dr1170u73pR/zoZ6fA4piACg8A4AR8kzy2XNOfOL9v33S429ayF8iyH/M2vc98eZ1Jz2xOv3v3ln9 + GHU/NhTFAFB4BgAjLL/MH1p74q7Ppf/ctO6k3ddk+b8nd6Vf6T9c/TF1/7tQNANA4eVDdk46bACUwwBQ + eAYAQHkMAIVnAACUxwBQeAYAQHkMAIV3djpkv50OGwDlyM/m6jEtxTQ3AE5MBw6AYhgACs8AACiPAaDw + 8iH7cDpsAJTDAFB4BgBAeQwAhWcAAJTHAFB4+ZCdnQ8bAOUwABSdAQBQIANA0T03AHanAwdAMQwARWcA + ABTIAFB0Zx+/57Cz3re7C0A58rO5ekxLMRkAAOUxABSeAQBQHgNA4eVD1kmHDYByGAAKzwAAKI8BoPAM + AIDyGAAKzwAAKI8BoPDWpEP2oXTYAChHfjZXj2kpJgMAoDwGgMKbGwAnpAMHQDEMAIWXD9kH02EDoBwG + gMIzAADKYwAoPAMAoDwGgMIzAADKYwAovHzI1uTDBkA5DABFZwAAFMgAUHQGAECBDABFlw/ZmemwAVAO + A0DhzQ2A49OBA6AYBoDCMwAAymMAKLx8yM5Ihw2AchgACs8AACiPAaDwDACA8hgACs8AACiPAaDwTkuH + 7PTj93QBKEd+NlePaSkmAwCgPAaAwjMAAMpjACi8fMg+cNyeLgDlMAAUngEAUB4DQOEZAADlMQAUngEA + UB4DQOHlQ3ZaPmwAlMMAUHQGAECBDABFZwAAFMgAUHT5kK1Ohw2AchgACs8AACiPAaDw5gbAb6UDB0Ax + DACFZwAAlMcAUHj5kJ2aDhsA5TAAFJ4BAFAeA0DhGQAA5TEAFN7J6ZC9Px02AMqRn83VY1qKyQAAKI8B + oPAMAIDyGAAKzwAAKI8BoPBOfs+ew075zT1dAMqRn83VY1qKyQAAKI8BoPAMAIDyGAAKLx+yk/NhA6Ac + BoCie24APJkOHADFMAAUnQEAUCADQNHlQ3ZSOmwAlMMAUHgGAEB5DACFZwAAlMcAUHhzA+C96cABUAwD + QOHlQ3ZiOmwAlMMAUHgGAEB5DACFZwAAlMcAUHjHp0P2vnTYAChHfjZXj2kpJgMAoDwGgMIzAADKYwAo + PAMAoDwGgMLLh+yEdNgAKIcBoPDmBsB70oEDoBgGgMIzAADKYwAovHzIjp87bACUwwBQcAYAQIkMAAVn + AACUyABQcAYAQIkMAAWXD9lx6bABUA4DQOEZAADlMQAUngEAUB4DQOHlQ/Zb736yC0A5DACFZwAAlMcA + UHgGAEB5DACF9550yH7z3U91AShHfjZXj2kpJgMAoDwGgMIzAADKYwAoPAMAoDwGgMLLh+y96bABUA4D + QOEZAADlMQAU3twAeFc6cAAUwwBQePmQvScfNgDKYQAoOgMAoEAGgKIzAAAKZAAoOgMAoEAGgKLLh+zd + 6bABUA4DQOEZAADlMQAUngEAUB4DQOHlQ/audNgAKIcBoPDeszINgFXpwAFQjPxsrh7TUkwGAEB5DACF + ZwAAlMcAUHgr0yFblQ4bAOXIz+bqMS3FZAAAlMcAUHgGAEB5DACFlw/ZsemwAVAOA0DhGQAA5TEAFJ4B + AFAeA0Dh5UO28th02AAohwGg6Fat2vMLtYcPgKHJz+bqMS3FtGrVvtetPHZvOnAAlOLYY/f+VPWYlmJ6 + 97uf/JG6wwfA8KxateefVo9pKaa3H9f9wRXpsAFQjve+t/sPqse0FFOn0z00Hbanew8fAEOz/5BDui+p + HtNSXOmwPdBz+AAYllV7768ez1Jsy4/de1vSBaAIv189nqXY0mG7oOfwATAsq/aeVz2epdhWrHjqnctX + pkMHwNClZ/JR1eNZim3Vqqd+rO4QAtC8NAB+vHo8S/EtW7n34WPSwQNgeNIA+E71WJaaKQ2Aq+sOIwDN + Sc/iy6vHstRMy4/d+2t1hxGA5qRn8a9Wj2WpmTqd7svS8nwsyQsUgOZtz8/i6rEsNVdanxfWHEgAmrBi + 7wXV41hqtmXH7v+3tYcSgHBHr9z389XjWGq+Zcfuvb3uYAIQ6g+rx7A0nN654qn/9M4Ve7sANOfo5U/9 + x+oxLA2vdBg/33s4AQhzV/X4lYbbUcv3//t0IJ/tOaAADN6zR6/Y/8bq8SsNv6OW7914dDqcAMR55/K9 + l1SPXamMVqzovjodzsnewwrAYKRf/T925Hu6/7h67ErldNTKfb9Rd2gBWLK/O3rlvrdUj1upvNIhvbjn + 0AKwREet2LuhesxKZXbccd1XpIP69SQfWACWavlTXz388O7Lq8esVG5HH/3kj6RD+7cHHGIA+rXl6FVP + /Vj1eJXK78hle//VUcv3bz9q+b60XgFYhKmjVu57ffVYlUano5c//eZ3LN+3K+kC0Jddb1+5/03V41Qa + vfK/JOgdy/dO1hxuAGqkX/lP519AVY9RaXR75zv3/uQ7Vux7sO6gA/A9b1++75H0i6afrh6f0uj3tuV7 + /tnbV+z9fDrc+YAD0OuY/ZuXLdv92uqxKbWnww/vvjQt3E466M8ecPABxtffvX35/gt/pdN9WfW4lNrZ + O1bu/a/pwD/c8wUAGDv5L48edcxT/6V6PErt7/DDu6+qfjfgqd4vBMAY2J+egeuXLeu+snosSuPVW4/d + +1Ppi3Djkcv3PZN0AVouP+tueMeKvf+yegxK491RK5/650ces//CI4/ZtzfpArTM/vTiv97f4S8dpMNX + dF995PL9q45cvvcLNV8ggFHzrSOX7Vt9xMrdr6kec5Lm6+3H7PuZtx2z95Qjjtn3h8mupAtQuCeOWLbv + tiOW7T0p/efrqseZpMWW//GYI1fsf+ORy/cvS1+qdW87Zt+n0xfta8lDRxyzdzL955PVlw8gUnrW7N+e + /jM9e/Z9rXoWrc3Pprcu2/8G/yjfqHTIIf8PJnMwfXskDE0AAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vAAADrwBlbxySQAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAD7HSURBVHhe7d0J + eFXVvfB/tbW2trbW1trettZOt622t9PtZNt7e299+3b804nbOiuzhDBmJuCBhBCGjEwJqFi1gjiLIgiK + U9EqoIgoihYRSHLGnCkTkuz/b+HqfXFnAxnOztnD9/s8n4dqBfZea52zzrRPTiKi7BVf0fLZ1uVNl8ca + Dy6OLT+4QewRMdElDJ84LNQ574stP/Bo6/KD18UaD1wTa9z/NcMwTtZDRURE5O7iNwQ/F208GJANb5fe + AHFs+6MrDtbFG5r+XQ8fERGRu4quOPB92dDujS4/2C0M9NOKg1sijU2/5VUBIiJyRa3Lms+LLj9wh2xi + Pb02NfTfkQcC+7+nh5eIiMhZqWeq8ox/fLTxYEoYyKjD0YaDC/au3PtePdxERETZL7Qk9IHI8qbbI7JZ + wT7yQOA59UFKPexERETZK9z4xicijU0vWG1YsEUozIcEiYgom6n3+2Xzf81ik4K9EqEVTT/W00BERDR0 + JRcf+IhsRLtNGxOGTiK0/MA39HQQERHZn7Fm13tkA/pbWDYiZNWB0JLQx/W0EBER2Vt4eVOVxWaEbFje + tNlYY7xLTw0REZE9RZYfvEg2np5eGxGy6MA0PT1ERESZT730H2o8+LIw4Chtzcuaz9PTRERElNnCjc3T + Qg1NBpwnuKzpr3qaiIiIMldTY9PpstG0mDceOMbhSGPTl/V0ERERZaZgQ/P4oGw0cK7QsqYVerqIiIgy + k2ww280bDhwnFb4+fIaeMiIiosHVsqzlqxabDRyp+Qo9bURERIMr1NBUbL3ZwGlaGg7epqeNiIhocLUs + a3q05cjmAhdo5YuBiIho0BkB4xTZVFKmTQYO1sTVAERENNjCyw/8q9UmAyc7eLGePiIiooElm8mw5mVN + BtxDHgSU6ekjIiIaWM0NzXlWmwycrHmVnj4iIqKB1bKsqcF6k4GDbdXTR0RENLDk2eQmiw0GzpbQ00dE + RDSwmpY17RMG3KVlWcvH9BQSERH1rz31e06TzaTbvLnA+Q4uOXihnkYiIqL+1by4+QKrzQXO17y0+Uo9 + jURERP3rYMPBYQdlM4H7NHEpIBERDbSDDc15VpsL3IBLAYmIaIA1LWlqOLhUNhO4EZcCEhHRwJJnkZss + Nha4A5cCEhHRwDqwtGmfMOBOXApIRET9Tl0CKJtIt3lTgXtwKSAREfW7fYubL7DaVOAmXApIRET97M3F + B4ftl00E7iUPArgUkIiI+tebS5rzrDYVuMeBpc2r9XQSERH1rTeXtDTsX9osGwncSh4AcCkgERH1r/3L + mjdZbSpwFS4FJCKi/vXm4uZ9by5pNuBur3EpIBER9TV1CaBsHt3mzQTu88aSIJcCEhFR31KXAFptJnCf + fVwKSEREfe3NxS3D9qnNA6735tIWLgUkIqK+9caS5jyrzQSuxKWARETUt/YtaWmw2EjgTlwKSEREfeuN + Jc2bhAFP4FJAIiLqW28sbt5nsZHApbgUkIiITpi6BFA2jW7zJgI341JAIiI6QeoSwDcWy6YBz9i7mEsB + iYjoBO1d3DJMNgy1acAj3ljMpYBERHSC/rGoOc9qE4GLcSkgERGdqL2LWxosNxG4GZcCEhHR8fvH4uZN + woCncCkgEREdP9ks9pk2D3gAlwISEdExU5cAymbRbd484H6vLTr4Qz3NRERE72zP4uYLrDYPuN9eLgUk + IqJjtWdxy7DXZbOA9/yDSwGJiOhYqUsAX18kGwY8R+aWSwGJiMi61xe3NFhtHvCEbXqaiYiI3tlr9c2b + XpPNAp7EpYBERGSdbBL7TJsGvIRLAYmIyJy6BFA2ie5emwY8hEsBiYjIlLoE0HrTgGdwKSAREZlTlwDu + WdRiwLte41JAIiIy99qiYJ7VpgFP4VJAIiJ6Z/LssMFiw4CnBLkUkIiI3tmr9S2bhAFP41JAIiJ6Z7I5 + 7DNtFvAgLgUkIqL/TV0CKJtDt3mzgPfsXhTkUkAiIno7dQngK7I5wAfquBSQiIh0u+tahlluFvCc3Yta + yvW0ExGR33u1LphntVnAk7gUkIiI3m53fUuDxUYBD9pdz6WARESkkwcAm4RsDvABLgUkIqK3k01hn2mT + gIdxKSARER25BHB3XUu3MOATXApIRES7qpsveFk2BfgJlwISEfk+eUY4zHqTgFe9VMelgEREvu/lumCe + 1SYB79rNpYBERPRybUuD1SYBD+NSQCIieqmuZZNQLwvDP5J6+omIyK/JZrDPtDnAB3ZwKSARkX9TlwDK + ZtBt3hzgfVwKSETk49QlgLtkM4AP1TdfpZcBERH5LdkIhu2qlc0A/sOlgERE/m1XXTDPcnOAH3ApIBGR + X5NNoMG0KcA3uBSQiMiXvVgf/PqLtS27hAFfSu2sDf4fwzBO1kuCiIi82t6Ve9+7q7Z5+M66lo0WGwL8 + ac+Ltc2FOxZwWSCRr3phafzDL9WFfrmrNjjzxdrQqhdrg0+K11+sCb4hv4bFa/Lvn3mxLnj7rrpQ+c6a + 4O9fWdj0Uf3bySWpT/vvrGmpl/lsFXKnD/TSqe4DdtY0/4RXBdyVPHh7/8764M/kNj59Z13wlp21wafk + Pn23zGmL/HpAfn1d3Y/L/75L/nflrprQH5+vjnxS/3byU7uq95+1szY0UWyWhfKWMPqpR2yThZa3s+rg + p/UfSw7LCBinvFDXMkzm6rGj5g7og9BLL9QFx6hXjPRyIof1XE3rmTtrW0bKhr5J5uxQ7zk8sRdqg9vl + fvzalxY3fUb/seTVnq8K/+sLNcEbZeI7zAthELplET6gNprNAePd+q+iLLalev/75IY99sW64CsW8wX0 + R1DW0kxe9XNOsmFfKPPyF9F+1DwN1pH78Rdr+HIoz7W9vvnsnXUt18skHzZNeqapl5pm7aprOlf/1TSE + vT3PwWtlHkKmeQEGq03W1tKX6kJf1MuNhjD1bP+F2tAEmYedpnmxw/odteEv6b+a3NzOmuDl8qw/Kowh + dPiFmpb7d1S3/GbNGuNd+lDIpl6qCX9iZ02oVsa93TQPQKZ1y237tuermy/Qy49sbEdVy/dlzFeKtqPm + YCh0qld+uP92aVsbm06XSVQLx2pyh9L+HTXBwI766Kf0oVGGUhv/CzWhGhljNn4MNR4I2NTWytiH5Had + I2O8wzTmWdDyqLqf0YdGbkh9yE823SetJzRr5A4juPGF2tBwPiswuNRL/TKWlWKonxUAZt07qkNrd9WE + vqGXJw2wF+rC35bxbBSpo8bXCQ6+WBX8uj5McnJvPysMvmKaQIcJvaleXuIylP6lLtmUB3YLZAzZ+OE0 + 6gH+rTsWtXxWL1fqQ3vqox+U2/Q14jnTeDpNTD1A0YdNTky9dKQWkjBcolvwqsAJ2tponCo3wDEyVsGj + xg5wokPPy7NY9SqVXr5kkdpM1TjJeKVM4+dkYZnX8/UpkJNSH9bYUR3cZDFpbvHGC7UtpdsXhf9Fn5Lv + U1/Goh4cydi8ZhorwOmissFN3RXY9R69nH3f7nnhM56vDY6VsdlmGiv3qA7+Q73FrE+JnJJsnnMtJ8x9 + 3nqhNnjXjurQz9UX2ejT813qWl8Ziy2msQHc5vXnq0P/4+dvFnTps/1jq215wM/3zY5LJuR7ssC6heEx + B0Sln75tUD26fr66pU7O24vzCZ96rib42I66lq/qZe759gb2vve5t1+922g1Hq5XHRynT5WymXqJTSbk + xV4T5C3qfcU7ZdH9zKuPPNVbOM9VB8fLecaOOm/AS9TteJ763nq97D3X81Whb8o5NoikPmevSvAhbgck + j6wLZGNUj8j8Yr8sPk+9KrCjJvwtOa+nTecJeFNN8OCOquAVevm7viPP9qvk2X61PNu3Ol/PCq3SQ0DZ + aGdt8ByZCHkkZjU5nndInjHfvr0meJFb319UV23IeTSK7qPOC/CLB5+raT5P3xxc1/aq4NflCdhSOQ+/ + 3gf3PL8w9CM9HDTUySOw62QTNHyvJvja81UhV/08823VoZ9vrw69aXk+gH+0qduuW97a26yf7ctxbzSd + h19t5wOBWUi91ySD322aDL/rkgcDa5z8qoB61i/H2Sh6jjpuwO+eVD+tVN9MHNfWhZEvy/1KpRxn1HTc + vre9umWkHiYaqp6rCj5mNRn4X3uc9qrA9prQL+S49puOE8Db2tVt1ik/gGZP/Z7TeLbfJ0H1xEYPG9nd + tqqWP22XgUefdG6vDq16vqr5v7L1qsDT9dEPynHcZDouANYez+ZnA9TliturWurlOFpNx4Vj2FYdnK+H + j+xsS/X+98mAv2GeAPTJq9vlGcZQfk3p89XN35W/d4/pOAAcX2JbVfAyfTOyvX8+25e/d6PoOeo40Ddd + Tn4LxzPJjSJgMfjon67tNn9WQP25z1W3TJK/65Dp7wbQV3I7fa6m9Ux9s8p4O2rDX1Lv7cvfFe71d6Of + QvfpYSU7Uj9TXwY63XvgMQivZPpVgWeqDn56e3XLoxZ/F4D+2/tcVfBCffMadDzbt4+6ukkPM2W6rVXB + W7dVySDDDh3iFlnAP9bDPaC2VQd/t70qGDX92QAG55DctvIH84rdtpqmr2yrCtVw+7TVLn6yqw1trwn+ + QAa3xzTYsIE80DryqsDWhU0f1cN/wtQnl+X3BkT30X8WgEwKre3PWwLq2f5Weba/bWFwo/x+7j+HgIz3 + RD38lInUFy3Iwn/GarBhq055tnDCzwqoBwry3z1k8fsBZFp18NWt1S1f0zc/y56bH/qiPJCvlP8+1Ov3 + w26x/jx5ohP0bHVopDyqUo+skC0LQ7vl18K/Lz7wET0tR9paE/6W/Pu97/hvAditXZ4UXaVvhkfaFTDe + I/9enu2HN8qvPUf9txhqC0NL9LTQYFLXkMuANvcaYGRLuyzuG5+pCl4odzRj5J87Tf8/gCHyrHpPf2H0 + /K1V4QXyzyHz/4+seetEr9JQH3p2YXi+xeACAOBc1cGH9TZGA2nr/ODnZSB5hgkAcB11VZTezqi/PVsV + vPdZGUQAAFzodfUTFPWWRn3tmaqWn1oMJgAArvFMVahYb2vUl9QXKTy7MPSCMAAAcLHU9nnhf9HbG52o + ZxaEJj4jAwcAgAfcqLc3Ol5PzI1/WAYrYho8AADcqufZ6sh39TZHx0oGarFp4AAAcLun7Prpq57o6YXR + 8/++MPSWMAAA8JJnqoKX6e2OzP29KrTBatAAAPCAA5uXhD6gtzz6Z39fGPytxWABAOAZTy8Mleltj1Tq + h1jIwLxqHigAADym46ma5vP09kfyiKhIqEdGAAB43Rq9/fm7p2uD5zy9IJQQBgAAfvDUgvBP9Dbo3+SR + 0EqrwQEAwMOeX7PGeJfeCv3XU/PD33pqQahbyKMhAAD8Y8uC8Fi9Hfor9YUIWxaEHrcaFAAAfCC0uab1 + TL0t+qenFoYvtRgMAAB8JFilt0V/tKV6//vkpPdZDwYAAL7x1jOVzRfo7dH7bVkQnL1FThwAAL/72/zQ + Q3p79HbPVEU/LSfcZh4AAAD86sn5oV/qbdK7yYneZj5xAAB8bs+6+j2n6a3Sez01P/jDv80P9Qj1kgcA + ANCenB+eordLb2UEjFPkBJ81nzAAADgi8cz80Mf1tumdtswPj/nb/LCcIAAAsPLk/HCD3ja90ZPzwmfI + STVbnSwAAPhf3U8sDH9bb5/uT05ooTwAUI9sAADA8T2pvi1Xb6Hubcvc0BfkZDpNJwcAAI7hifmh4Xob + dW9Pzgvfb3VyAADgmN7cGmg6XW+l7uuJBZGLnpATAQAA/RUq1dupu9ocMN4tJ/Bi7xMCAAB90PZkZexc + va26pyfnhSc/MU9OAAAADMiT88M3623VHW2pTpz1+LxQ5HE5eAAAMGA9T1aGfqS3V+cnB7zMdAIAAGBg + tqlv09VbrHN7sjJ6gRzsW6aDBwAAA/TYvMiVept1bk/MCz1kdfAAAGBgnpgXbnm6PvpBvdU6ryfmh3/9 + mBwoAADIuIDebp2V+tpCObjnTAcLAAAyI/V4RfPZett1TnJg/5/pQAEAQGY571WAR+eFHxQGAACwTdPW + RuNUvfVmv83zop96tDLcLQwAAGCfzfPDv9bbb/Z7rDKSY3WQAAAgw+aFV+jtN/vJAa3rdYAAAMAOTXr7 + zW7q0/+bK8OtwgAAAPZ7bEHLZ/U2nL02zw19wergAACAPR6pDP2P3oaz1yMVoV9aHRwAALDJvNB0vQ1n + r4crI9c8IgcDAACGTIPehrPXw5WhUosDAwAAtoncobfh7LW5MlJmfXAAAMAOD88Nr9XbcPZ6pCIy55G5 + EQMAAAyV6AN6G85emyoiBQ/LwQAAgCFSEfmr3oaz18MV4dGWBwcAAGyxaW5kid6Gs9cjcyI/tTo4AABg + j00V0al6G85eD5dHPimPRNSjEQAAMAQergz/Rm/D2U0OZr/54AAAgC16Ns0JnqO34Oy2aW54tcUBAgCA + zNutt9/st7EycoXFAQIAgIyLLtTbb/bbHGg9c+PcSKcwAACAfTZURL6nt19ntLEivHpjhRwcAACwy8vq + x/DrrdcZbaqI/sDiQAEAQIY8NDc8Tm+7zuqhishmYQAAgIw7uDbQdLrecp3VprmR78gB9pgOGAAADNbc + 6Ci93TqzjXMj11seOIChEn+oIvr8hjmRezZUROo3zo1eK7fLCQ/NDV8sdyA/kwfqFz1UEf7PDXPD31Y2 + VsZ+pP6dsqEi+seNFZFr5PeVbqgI18h/d5v8eX8XwaP+fABD75nNAePdeqt1ZnJn8iG589gv1CcVAdjn + kPj7hjnRxofmRHLWV4R+vD6QOEvfFDPehgUt73+oPPzv8iBh5Pq5kVq5Q9osf3/qqOMBYI/O9ZXRC/RN + 0dmpOyI5YHXnZHUiAAamQzwkG2/JhsrQfzjhvUD1jOTIKwkVkYkb5kTukF/j+lgBZM41+ibnjtQBm04A + QP8dlI11yYaK8K8d++Gfo1IPCI48AZgTqRAvWZwPgH6JLtc3L3e1YW70WusTAnAcLesrIovVs/xAwDhF + 35xc2cbK2NfkfMo2zI28ajpHACfwUEXkTse/73+81s8Jz14/J2IAOK7u9eXhBx+siPx+a6Nxqr75eCb1 + xSUbykP/sWFO5GY51w7TuQMwkdvKXWsCxnv0Tci9rZ8THSUndMh8ggAiCbl9LHxwbut5+ubi+e6fG//w + g3PC+XLu+01jAeBttWvWGO/SNxn392BZ+CfrKyJBixMF/Gj/g+XRqesC0Q/qm4jvUq90bCgPX7q+PPq8 + xfgAftS5viI8Wt9EvNXa8sgnH5wT2SIMwKdC6+ZECjcH9r5X3yx8n3p7YF15+Dfr50SfsxgvwC/2ryuP + fl/fLLyZek9DHuUstTh5wMvi6ysiBW74JH+2Uh94lAcCl8oDpH0W4wd4V0Xk4XUVzWfrm4L3Uzd0OfG2 + XgMBeEv3g+WRmzbNCZ6jlz6doDXV+9+nXiWRsUuaxhLwmh7Z/Ou8+MHfE7ZubuibD84J/8NiUAAveEat + cb3cqZ+tmxf9lIzhXaYxBbwiub48+ge93P2Z+urSB8vDD8ojfgPwiHZR6KlP8WYx9fkAGc/9R40v4Hav + rJ/tkq/2tTv13t8D5dGydXOiPUIGB3CtJ+6fG/+cXtqUoe4OtJ75YHnsJovxBtzmjnvnhc/QS5v+2fo5 + sV+tK4/GhAG4zFsPlEUDPOu3t3Vl0T/KWEdNYw+4wWF1H6GuetHLmcytLQt98YHy6AvCAFzijbXlke/q + JUw2t7Yydq48ENhiMQ+AQ0VC68oi/62XMB0vdY20DNrK3oMIOMu68tjmDYGWj+mlS0OU+n50uUOttJoT + wEnkPmKbn77pM2PdXx6dLAN4yDyggBOoDYiX/LPbA3MiV8mzq06r+QGybV15tHFdvXGaXq7U3x4sj/1I + BrLJPLBAFr31QFlsrF6ilOXkTvb76iVWi3kCsiTSua4s6s2v9B3q1Eus95fHHrlfBhbIsuS6ObFf6KVJ + DmldWfzza8ujuy3mCxhac6L7H5gd+Z5empSJ1FcIy4OARZYDDgyNlgdmx76mlyQ5rHUVqbPXlke2W8wb + MFQeWhtIflQvScp0D8yJXSKDnDYNOmC3pvv44g7Ht7Ey9iGZq7+Z5g6wW8/9fCZoaFo7u/Xra8ujrwsD + sJvcuPfeVxb/rF5+5PDWBEIfWFse22w1l4ANEmvLIr/Vy4+GIvVz1NeWxe5eWyYTANjnwP0BvtnPbamf + uihz97hpLoFM231PRfR8vexoKFPfqHR/WaxQJqHbNClABkRC3Ljdm3o74L6y6LPWcwsMzv2zY/eoNaaX + G2Wre+fEfiU39JgwgAxJqLea9BIjl6Y+kHXv7OgrFvMLDNRb95ZFp/GVvg5qbSB2rkzMs6aJAvpNHt0f + Ej/TS4tcnnoLR+Y1aJ5nYADC95RFLtJLi5yU+grhteXR6y0mDeize8ti1+glRR7pvtmR78jctpnnGui7 + 2NYHyls/o5cUObX7yiK56lmc9SQCx3bv7GiVXkbkse6dHbvMas6BE7m3PLJMfReNXkrk9OTG/sN7y6IH + hTyjA/qgPPaI+iEzegmRB7unLFZvOfeAtY57ZkdH6eVDbkp9M5hM4MOmCQWsNN05J/wJvXTIozU2GqfK + XD9mmnvAypt382O+3Z26wd83O1pnMbnAPx1eWx77kV4y5PHWlkc+eV9ZNGqxDoC3lUfX31WR/IheMuT2 + 7p4Vu/ie2dG0MICj3T07WqaXCfmke2ZFfme1FuB7PbI2+EpfL7Y2EPmyTPBLpgmHr8W2qleJ9BIhHyUP + /K63XhPwqeS9ZZHf6+VBXuzuQOuZ986OrLWYfPhOpFM9KNRLg3zWvfPCZ8g62Nd7XcB3yqI715aFvqiX + Bnk59Q1O95TFCmXiD/daCPANeSBYqpcE+bS7Z8V+YbU24CurNixoeb9eEuSX7iqL/vzu2dGoUO8Dw19e + 4LpeUqkNwGJ9wPveUk8E9TIgP6Z+zOvdZdHnLBYHvKvnnvLohXoJkM+7d07wHFkTCdMagYfJg77me8tb + /0MvAfJzKwN73ysPAq6zWijwoshf9dQTHemusli+9VqB58yKPqt+doyeeqK3u3t2bMxds2NdwoBntd/J + 93mTKfV20F2zW1+xWC/wkDtnxxp564+O2V2zoz+QhXLAvHDgDXdyzT8doztntf7Oas3AE9plfi/XU010 + 7NTPEL9rVnTTXbNk4cBLWu+fG/+wnmaiXt01q/XvFusGLnb3rNi+O2dHvqOnmOjEqR8KI4unUvQcvZjg + XnfOjpXo6SWy7I5A7JdWaweutW5NIHGWnl6i/nXnrOif7pwVSwkDrhZeEwh9QE8r0TGTtbLFtHbgPt13 + BaKzAgHjFD2tRANrTVn4S/JIcpfFIoNrRAN6OomO2x2B1t9aryG4gdxXJ9TnOfR0Eg0+9bWhsqjusFpw + cLxOefb/cT2VRMdNfVOorJmXTGsI7rDj7rL45/VUEmUudcdw+6xY4R2zYoeFAddYrqeQqE/dMTs2zmId + wdluvYmv9CW7uz0Q/Zkstohp8cGpArF/01NH1KfWBppOl7XT2mstwYkO3TG7daKeOiL7uzvQep4svLhp + IcJ5ntZTRtSv7gzEllisJziMekKmp4xoaFKfLpXF12lejHCY2dEResqI+pV65chyTcFR7prd+nU9ZURD + k/o62dsD6tEnHCzFe4I0mGQNbTWtKTjMGj7xT0PdnYHIRVaLEY5yi54uogF1eyCaZ7Gu4CSzotP0dBEN + TbfPio21XIxwjlmtw/R0EQ2oVeXRT8ta6um1tuAki/V0EQ1NawKx+cKAYyXUj3nW00U04GQtbTGtLTjL + A3qqiIamNYHoXRYLEc6xWk8V0aBaMyuWb7G+4By79VQRDU2y6HaYFiEc5LZZrVfqqSIaVKsDsa9arTE4 + Rgff+U9D2m2BWFQYcKSeO+eEP6GnimjQyZraZ1pjcJA15ZFP6qkisrd19cZpsuh6zIsQjrFNTxVRRpI1 + tdy0xuAgq2bHfqynisjeVgVazzMvQDjH6kBrlZ4qooy0elbsUqu1BmdYHYj9WU8Vkb2tmRH9wW3XysKD + I8kDgN/rqSLKSEce9FusNTjDmkBsgp4qInu7bWb0D6tl0cGZbi7h/X/KfLLR7Ldab8i+VYFoQE8Tkb2t + mhnLsVqEcIS9epqIMtpt17bebrHe4AC38WVANFStDsTKrRYhHOFuPU1EGe22QGupxXqDE/C9HzRUrQrE + lq6SRQcH4qVAsqnVM1uHWa45ZF8guklPE5G9rbo2/tdV17bKwoPT3Doz/gc9TUQZbU1p/LNWaw4OEGh9 + Xk8Tkb3JglvbawHCEVaXRr6ip4kooxknGSfLGmszrzk4QKD1gJ4mInuTxfak5SJEdgVae9YGmk7X00SU + 8W69tnWX5dpDdgVaO/UUEdmb3AnsEAacJt6sp4jIlm4NtN5vvfaQbWsCoQ/oaSKyr1tntr4pDDhNfIue + IiJb+uvM1sXWaw9ZF0h+VE8TkX3JYov3Wnxwgjv0FBHZ0q0zYkUW6w4OcEsg+ik9TUT2Jc8CuoQBh7k2 + vkxPEZEt3TojPspy7SH7AvHP6Wkisi9ZbN29Fh+y79rWMj1FRLZ0y8zW31muPWTdrYHIl/U0EdnTmuHG + u6wWH7Lvlhmtk/U0EdnSzTNiP7Zae8i+m2e0fl1PE5E9rQzsfa/V4kP2qZdn9TQR2dJfA63fsFp7cIBA + 4rt6mojs6fqC8Bm3yGKD88idwOV6mohs6abSyFes1h6y79ZA7Ed6mojsaU0gcZbV4oMTxP+kp4nIltQH + zazXHrIv/lM9TUT2dGtJ+hzrxQcH+J2eJiJb+sv0yCct1h0c4K+B2C/1NBHZk3oAcPOMIx84gcPInQAP + AMjW1AMAq7UHB5gZ+5WeJiJ7Um8BWC4+ZB1vAZDdqbcArNYeHGBm/P/oaSKyJ/UhQMvFh6y7iQ8Bks2p + DwFarT04QGnrT/Q0EdmTugzwJllscJ6buQyQbG5loPUbVmsP2XfjjNgP9TQR2ZP6IiCrxYfs+8uM1ql6 + mohsSdbZf5rXHZzhlhmJ7+hpIrIvWWzd5sWH7PvLjPgcPUVEtnRTaevvrdYesk+9OqOnici+ZLF1mRcf + su/mmbEGPUVEtnTTzPhoq7WH7LtxRvQCPU1E9iWLLf4XWXBwFpkXfhww2dpNM2JFVmsP2XdzIPEFPU1E + 9iWLbZ958cEBZsaf0lNEZEs3zmxdbLn2kH3FyY/oaSKyr5tKW1/4S6ksODhMvFlPEZEtyRp7wHrtIdsa + xxin6mkisq8bS1sfFwYcp6cx0HS6niaijHdjafwli3WH7EvrKSKyN1lsa02LDw5xQ3H0fD1NRBnNOMk4 + WdZYm3nNwRGa9DQR2ZsstltMiw8O8ZfS+B/1NBFlNHn2/3mrNQcniL+kp4nI3lZOjy+RBacWHZxmRuss + PU1EGW1laetvLdccnIAPANPQJJtM2UpZdHCgGYl79DQRZbSVpYkZlmsOWXfDjPg6PU1E9nZjaSLHahHC + AabH9+ppIspo8izzdss1h6yTublBTxORva0sbf291SKEM6if2a6niihjrSxNHLRab8g+9aqsniYie1s5 + PfH9G2TRwbH4ICBltBsC8c9ZrDM4xMoZifF6qojs7brprZ+5YbosPDiSPECr0VNFlJFkTV1utdbgDNdP + b/2dnioie1sTMN4ji67HvAjhGNv1VBFlJFlTK0xrDA6iXpXVU0Vkf7LowuZFCMfoaSxp+4SeKqJBJ2vq + TdMag4PcVBg7V08Vkf1dPz3+vDDgUCWtV+mpIhpUK2fEvma5xuAU3epVWT1dRPZ3Q0n8TouFCIe4bnp8 + tZ4qokElzzALrNYYnOGG0vg+PVVEQ9P1pfH5VosRjpFcM2X/+/R0EQ2460viT1usLzjHw3qqiIam60rj + Y+VZpnqmCYfik8E02BoLY+fKWuoxry04ynI9XURD03Ul8Z9aLEQ4SWl8lZ4uogEl66ig17qCs5TEC/V0 + EQ1N6rsALBcjnCS1JBD6gJ4yon63Ynp8m8W6goOs4Iu/aKgLBIxTVpTEO4UBByuOj9RTRtSvVpTE/s1y + TcFRlpe0fkNPGdHQtKyo9TxZfHHzYoTj/F1PGVG/krWz1LSW4EDXF8V/pqeMyP6WlyT+ryy8iHkhwqli + /6anjqhPNQaaTpe1wwN8dzi0Ynpiop46InsyTjJOXl4SL5QFd9i0AOFk0+PX6Skk6lPLpyfGW64lOFdx + /Nab8lrer6eQKHNdXxA+o7Ekfqc8ADDgOp1L8tMf11NJdNzU53tkzbxqWkNwh5dXlKa+oqeSaPA1Fie/ + LAvrJdNCg4usKGmdraeT6LitKG79vdUagmsklvMdIJSJlpck/iwLKm1aYHCZFSXxiHoVR08r0TGT9fK0 + ef3AdbrlQcAs9WqOnlaivicL592yiCobZTHBGxqKE6V6eoksW16c/LXV2oFrrbsukDhLTy/RibuhOHW2 + LJxNpoUE94tzZ0DHSn3IV9bIM6Y1A/fbt7wo8R09zUTHbvn05IWNxYmDjcWycOA9JfFyPdVE72h5UfwP + lmsGXtC+vDhxuZ5qot41FsXHyELpMi0ceEu7+hInPeVER1I/T15u/69arBd4SUm8Uc21nnaik05aGTDe + Kzf+6xuKE+p9Ynjfaj31REdqKIoXW6wTeNOz6qc86qknP7e0KP45WRDPmRYIvK1naXHyx3oJkM9rLGn7 + hKyJpGmNwNuaGwpT/6GXAPmx5SWJX8hCiJoWBvzh5fpc4zS9FMjHNZQk11isD3jfWw1F8UL14U+9FMgP + qQmXZ/6Fy4oT3cKAP8kdwEy9JMinyRr4pdXagK+s4iuEfVJNoPVMmfC1pgUAf+psKE6dr5cG+az6QPSD + y4qT+y3WBXwnvrOhNPFFvTTIi6mv9JXJfrn35MPHtvGpYH+2rCix0mI9wL+Sy4rif9DLg7xUQ1Hi4qXF + ibTFpMP3knP0MiGfpO7ordcCfK6noSRZuWa48S69VMjNNY4xTl1SlKhbWpQwgGPoXlqc+k+9ZMjjLZke + /bTMecy0BoD/pzixfnFx8iN6yZAbqy9Onb20MPmI5QQD79S8qKDtX/TSIY+mnhDIXD9hmnvAypvLChLf + 1UuH3NSy4uQPZQKbTBMKHM/f+DyAt5M5Xmaac+B4OpcWJUfp5UNuaHFxYuKSosQhYQD9VKuXEXmspcXJ + Ky3mG+iLZTw5cHjqK30XF8ZvsJg8oM+WFiZy9JIij7SkMPkjmdsO81wD/bB18fTWz+glRU5KJucLS4qS + O0wTBgzEYdkwfqOXFrm8+vz452VOQ6Y5BgYivLQofpFeWuSE5Bnbr5YUJlotJgsYqOSyotZv6iVGLm1Z + XupjMpd7THMLDMZb8mRzGl8hnOXUBCwuihcuLkp0CwPIsFA93xTo2hoLYx9aXJjYZjGvQCbco9aYXm40 + lKmv8VxSGL/bYlKADIofUD8xUi87ckmNgabTZf6e6D2fQEbt5knCELckv/Ub8sj+dWEAQ2Dvorz4Z/Xy + I4d3fUH4jEVF8Uct5hGwQ2JRQfK3evmRndUXJC5dVJhoEwYwhJrrSlJf1cuQHFrN5NYzFxUktljMH2Cn + nsVFibpAwHi3XoqUyWRg31NfmFhsMfDAUAmqV5/0kiSHVVuSPmdRYfJ5i3kDhspDjdOSH9VLkjKR+orW + xYWJv1kMNjDUUvJA9Fd6aZJDWlKU+ILMzaumuQKyILl/cXHie3pp0mCqK0z+SO5wm4QBOMTh+sL4NXqJ + UpaT+4gLZU7CpjkCsqlT7iNG6yVKA6m+IDFZBvIt08ACzlAQX8h7ftmtrig5SuZC7mwt5gfIskUFycb6 + XOM0vVypL1VPMd4ng7fSPJiA0ywqjD+2JD/9cb10aYhSd6pH7lwt5gRwmG01Ra3n6aVLx6suP/FFeWa1 + 02IQAYdK7l9UnPyhXsJkczVF8c/JuD/bex4AxwotKor/t17CZJUM0q/qChOtwgBc5nBtQbJS/bx5vZzJ + hmqL4sNlrLmPgBsdritKBAIB4xS9nEmlBqS2MFFWV5DoEQbgYk9VFyW+oJc2ZajqKYmzZGxXmcYacJ/C + 5B3zCsJn6KXt79QNu74gtb6uICmDA3hCu9zQ1SN9fn54BqovTP5G7jQPWIwz4FavVBemLtBL3J/VF7V9 + s7YguVcYgPcknqstSnxHL3fqZ+qDUzKOa3uPK+AJydr81B/0cvdXtYWJy2oLUm0WgwJ4SU9tYXJNXWHs + XL306QSpH+RTU5AIyNi1m8YS8Joe2QfrfPPZIfWyaF1+YqnFQABeJo/2kyVLAqEP6JsCmVoz3HhXXUHy + Shmr/aaxA7wtP/lwfXHqbH1T8GbVU9o/KSe7pdfJA/4RFoXqWa6+Wfi+Ix8Czk8Nl3HZfdQ4AX6zv74g + 8X19s/BWNUWpn9QUJIPCAJBskht8ofrpdfom4rvUq4E1+cmrZCxeNI0N4FedtYVJb32FsDohObFDphMF + oN4aKExWL8qLf1bfXDyfuvLnyIOfguRB01gAENUFqTr1lpi+ybi3moJEudUJAniH7pqC1EPVhan/8eLl + g8ZJxsk1Ran/lnO8Vc6103TuAMzyk/e4+r6gqiAxuzpfHs0A6I9wdX5iWVVB6r/c/iygJj/9jZq8ZIWc + 0z9M5wjgBKryk3e78gqB6oLEBKsTAtAvzfJMoKE6LznMDVcQqDsr9cBF7rjmVasvO7E+JwB9JLel6/XN + yx3V5KV+Igd+yHwiAAalSzwst68ZapNdkNfyfn2Ty1pqw5cH+9+tyktMVs9W5PiSRx0vgEyQJ9T6Jufs + 1Kea5RnLQcuTAJBJb9UUpLbKxrtCNuCJ6kGBndcS1+dGP1hVkPh+VV5ydHVealFVQfKx6vxUm8VxAcis + rurC9Nf0TdG5LcxL3iB3SOplCwDZkJdMya87F+Yn76vKTyxemJ+YpR4gLCxIXCr//MuavPRF6sHCwmnx + byty5/Jj9e+q8+M/q8pP/am6IDVeNvaZ8t/UVeclb5df1YOM6Dv+DgBDS26HgYDxbr3VOq8jLwXmJ3t6 + HTgAABicvNRYvd06LznAR3sdMAAAGLyCZJMTPvvTq/n5yR8ulAMEAAA2KUiN19uuc1pYkLjN8mABAECm + 7FZfrKW33uynPvm/MC/ZJQwAAGCfBXnJH+jtN/vNz09eJQekDgoAANhI9txqvf1mvwV5idusDhIAAGTc + br39Zj85mIOmgwMAADapmdz2Cb0FZ695Be2fsjo4AABgm9/obTh7zZua/ul8ORgAADA05k1LTtPbcPaS + RyGjrQ4OAADYY0FeYonehrPX/PxkkdXBAQAAe8zLS6zS23D2koMon3fkYAAAwBB5QG/D2atyWqps3rSU + AQAAhkp6rd6Gs9f8aalS64MDAAB2qMxL3aG34ewlBzLOfGAAAMBWy/Q2nL0qprb9slIOBgAADJVkid6G + s9fcKYkvWB8cAACwRV7qf/Q2nL3UjyWUg4n0OjgAAGCLhdM6PqO34ew2d1py3Vw5IAAAYLuDevvNfnIw + 400HBwAA7NGot9/sp34gkBxQt+kAAQBAhlXmJX6lt19nNHdKct3cqXJwAADALk2NY4xT9dbrjMqnJH9T + IQcHAADsIQ8ArtXbrnNSVwPIwW03HywAAMiIVEVu6my97TqriqnJX1scMAAAGKQ5U1MBvd06s/KpqQ1y + kOpAAQBAZrQEcqMf1FutM6uYljpfDvQt04EDAIABS1+ht1lnJwe7tPfBAwCAAdgaCBin6C3W2QWmJM6a + My0VsTgJAADQdz3l05I/0turOyqblp5ULgcPAAAGaEryJr2tuqdAwHi3HPzO8inqBAAAQD+1VU7qOFdv + q+5qztT0Ty1OCAAAnMCcqanpejt1Z2VT0mvL5EQAAECfvRkYY5yut1J3VpYf/7ycSKfpxAAAwLFMTv1R + b6PubvbU5ALLEwQAAO80OfWE+np9vYW6u3kF4TNmT0k1CQMAABxT9+xpbd/W26c3mj05OcriRAEAwP+z + TG+b3kl9i9GsKelnZ09JywkCAACTVsf+tL/BVj41eaGcYI/phAEAwNT0ZL1derNZk9OrhQEAALRJ6Zcb + xxin6q3SmwVy2z8lJ5vudfIAAPhW2y/0NuntAlNSs6wHAAAA37lfb4/er3qK8b7A5PQbwgAAwMcOlU1K + fklvj/4oMCV9icVAAADgH5PSC/W26J/UtxzJyT/eazAAAPCHYGBy65l6W/RXs6e2fVMGoNs0IAAAeN6s + SW2j9XbozwKT0jdcKwMBAICPPDd8uPEuvRX6s5JJ6XPkkVDcYnAAAPCkGVNS/6m3QX83c1K68NpJMigA + AHjd5PRtevujQMB4z8yJ6VfkgYABAICHtQcmd5yntz9SzZzYNsxioAAA8IxrJ6Vm6W2Pjk4GZ715sAAA + 8IgDeXnG+/WWR0cXyE2dLwN0yDRgAAC43+T0pXq7I6tmTGpbNEMGCgAA70htOekk42S91ZFVRdfEPyyD + Fe49eAAAuFL39Cnt39XbHB0veaQ0wWIAAQBwndJJ6Rv09kYnSn07kgzYC0INHAAAbpUsmdz2Cb29UV8q + nZD679KJMngAALhVbrpQb2vUn2ZMTN1jOaAAADjc9Imp13NzjdP0lkb9qWhK5+emT0x3ChlIAADco3Ry + 22/1dkYDqXRSutJqYAEAcKxJ6Yf1NkYDraAgfIYMZlOvwUW2dE6f2LamNDd9Ucmk9BXyz+2m/x/AkEk1 + Fuemzj/yRGlSOmj93yALDs+YkP6a3sZoMJXkto2wGGAMrd0luenC4pzkR/S0HKlkctu35P/7h+m/BWCr + ttT0Sak/6ZvhkdQPVZN/N1z+/42i553/PYZUbtsiPS002GRhn1Iyse3vwsCQ6hRHnu0f7xus1IMCuUPa + YPq9AGyRfrVkYuqr+uZnWenEzi+WTGqvlP8+1Pv3w2axwLTkR/VUUCYqntz+AxnYHtNAwxbpV9Sz/f4s + YvXdDfJ7A6L7nX8WgAy6LzC59Ux9szth6hPo0ye1Dy+e2LZRfi/3n0NAxnuCHn7KZMWT0rdaDTgyoqN4 + YvstxbkdP9bDPaCmT2wbJn9W1PRnAxicrpJJ6WmD+S750smpr8h9aI38Wdw+7bMrEDDerYecMtn0Ke2f + LM5tSwsDmZJ+pUi9t5+bOlsP86CTO6pz5M9e3/vvAjAA/yjOaf+BvnkNOvWqQNGE9uHy524UPUf9PRik + kgnp/6uHmeyoaELbtVYDj37pkkeqa2TjP+57+4PLOLlkQvsk9XeZ/m4AfdZ+U2C88QF9o8p4pZOSXyrJ + ba8syW0LW//96CsZw3v0sJJdTZlivE8Ge6958HFisuG/muln+yeqaFLbd+Tv3mM+FgDHlZBnk5fom5Ht + 8arAoHUV53T+qx5OsjNZqH+ymABY6yyekF5VMjH1X9n6WdSB3OgHi3LbVlocG4Be0o9Oz+n4jL75DHnq + CoPiCW31ciytvY8NVopy2+fr4aOhSJ7JPiqbigw8jmGPerafNy71MT1kWa9oYvrnclxvmo4TwNva1G1W + XfasbzJZ7Z+vCshxbTQdJ94pWDgm9iE9bDQUlUxOf0MG/rBpIvyuq8j29/YHl7qhFE1oa5Rj7TEdO+Bj + 6cfzJ3Z+Ud9MHFfxhOSX5VlupTzbjVofv6+N0MNEQ5kM/ArTRPiS3Chfc9qz/RMlx/szOfZ95nMBfMZR + z/pPVOAq4728KvAO290yd55LXW5WmNsWF4YPHRK3O/nZ/olSnw2Qc1gquvU5AX5yf+GkjnP1zcF1Feam + vy7noG6/iaPOyU96iie0/1APB2WjwonpPIuJ8bL9BbntldPHt39aD4Hrk0fR35Tzesp0noA3TWg7IJvn + FXr5u75/viog57ax17l62cT2v+ohoGwVCBjvKZjQtlNuVOqG5VWHxJ3qZXOvvtykzqtoQts4Oc/oUecN + eEmXrPGKwBjjdL3sPdeRB/M5bQ2FOe1Ji/P3kvj0ce2f1KdN2aw4p/17MiGHTRPkBQe89mz/RE2Zkjir + KCddJ+febRoLwLWKJqQfLcxJXaCXuef731cFJrRtNI+FJ+S2jdWnSk6oYEJbuTA84C1ZYHflj0//3M8f + LpEHPt+XsXjSNDaA2+yRtfxHvax9WdHEtm/LODSK1FHj4mZr3fq5K8+mfhqdbJwbLSbLLd7Iz20rlV// + RZ8SSfkT2v9QMCH9qmmsAKeLyNqdpN6i1EvZ9xUUhM9Qz5xlbLaZxspNXiu6Jv5hfUrkpNQ15jJBblpc + 6mXujXJHMVzuKPgJUsdozBjjVBmrMaLlqLEDnKirICddN7kfP7LXj7n0VYGQ+j4EfQrkxNSlgfkT2l4S + hoO9mZ/TNnMKHyLpV+pONS+3vVLGL20aTyDbDssD+ZunZfErfN1Ybm70g3JfeI2M33Om8XSaSP749Df0 + YZOTUy/R5E9IP24xidnULXi2n4GmjUl+VB6NB2Q8E0eNL5AN6na9ZhrPDAfdtIlt35axbMyb0JY6anyd + 4A3m12WpnxqYn9u2wmIyh9p+tVkV5LZ/Sh8aZSj1ak9BbrpKxrjNNOaA3WTjT99aMD71Fb0cKUOpt3Lz + c9py5P57h8W4D7H2h+WZ/8f1oZHbystp/7NMZKj3xNrqsGz69+fltv1GfThRHwrZlLqByp1xtYw7DwRg + t+6CCelV03JT5+vlRzamrgaSBwMrZdyH+rbdUZCTLvbzlVieSV1bLouoMS+n7S1h2OiA/D2z3Pz1nm6u + OCf5kbzxbTNkDlos5gYYjPS0nLbF+bmdn9fLjYawI5//Gd8+IW9C206Luckomee1U8Z3fkH/1eSV1I1X + NojrZJLbzZM+CN3iATGM9/adkfoSErkRj5I5eUnPETBQzbLpTFcPLvXyoiw3dXz7hTInf5G5yeT9+GF5 + 4nBvXk779/RfQ15NPZqUyc7Jz2nfJBN/yLQQ+kJt+s9MG5+eJovRN9/S576Mk2Wefz0tp/0R0/wBxyUP + IF+UTWak+pn4ejGRw9L34yPEQzJnXeY57IMe8ax61ZD7cZ925DKU8emfyQ2+JG+8uown/Zhs7K/KP78u + 9svmsVt+fVr+3Wr5dZYsmGHqLQX928klTR6f+orMYa3MYUyoO3jArHNqTvtf83M7fqyXDbkk9fMVpuak + f5qXky6WebxR/E3sEnIffuS+XJF/l75Nfi1T9+OTJqXP0b+diPyQekY3dUL78Gnj2zbKgzu50wfa9+Tl + tBfm5qbO1suEiIi83NTc9Nfl2YA8S7DcFOB9qbzczov4XnciIh82NaejYapsBvClbXoZEBGR35o6oT3P + YmOAH4xvX62XARER+a0pOW3Dem0M8IfxbeV6GRARkd+akpO6QJ4JqmeD8J2Oq/QyICIiv6WuCpgyvr1b + GPCXyRPaf6iXARER+bEpOe37rDYIeFveuNTH9BIgIiI/JpvBJvPmAM9L6uknIiK/Nnl8R8Nk2RTgK1wC + SETk92QzyDNtDvA+LgEkIvJ76lJAiw0CnsYlgEREvk9dCmi9ScCrplzTcaWefiIi8mvqUsBJ49u7hQF/ + 4BJAIiI60qRr2vcJA/7AJYBERHSkSePaN1ltFPCitoSediIi8nuTxnc0TJTNAd6XO45LAImISDdxfHue + 1WYB78m9hksAiYhINzGnbZjVZgEPGsclgEREpFOXAlpuFvAgLgEkIiKduhQw95r2bqFeIoaHTRjHJYBE + RHRUsjnsM28W8J5xXAJIRERHlzuufZPVhgEv4RJAIiIylTOuo2HCuCMvEcO7uASQiIje2YSx7XkWGwa8 + hEsAiYjIXM7YtmGWmwY8Q+a4TE83ERHR2+XkdF2QM67DgIdxCSAREZlTlwLKJtHda9OAZ0zgEkAiIrJK + Nol95k0D3sElgEREZJlsEpvMmwY8g0sAiYjIuvHjOhqEAS/q5BJAIiKybvzY9jzrzQOud00HlwASEZF1 + OWO7ho0fK5sFPOeasR1cAkhERNbljO66QDYKtVnAa8ZwCSARER0jdSmgbBbdvTYPuN44LgEkIqLjJZvF + PvPmAffjEkAiIjpu48Z2bLLaQOBqXAJIRETHb9yYjgZ5EGDASzq36uklIiKybuzY9jzrTQRudc1YLgEk + IqITNHZs1zCrTQTuNZZLAImI6ESNHt11gWwYatOAR4zhEkAiIjpR6lLAsWM6uoUBbxg9uv1CPb1ERETH + TjaNfeZNBO7FJYBERNSnZNPYZN5E4FpcAkhERH1rzJiOBqHeO4bLjeUSQCIi6mujR7fnWW0mcCUuASQi + or6lLgW02EjgQqNHcwkgERH1MXUp4Gi1ecD15EEAlwASEVHfUpcCyubRbd5M4EJcAkhERP1JNo99vTYT + uA6XABIRUb8aNapj06jRHQbca/RoLgEkIqJ+JptHg9WmAjfhEkAiIupnI0d35skGojYRuBWXABIRUX8b + NaprmOWmAtcYySWARETU39SlgCOPbCJwLS4BJCKi/qYuBZRNpLvXpgLX4BJAIiIaULKJ7DNvKnAPLgEk + IqIBNWJU56YRspHAlbgEkIiIBtbVozsbLDYWuAOXABIR0cAaObIzb8Qo2UzgPiM7VulpJCIi6l9Xj+oa + Zrm5wPGuHsklgERENMCuHN11wdVqM4H7jOQSQCIiGmDqUkDZTLp7bS5wPi4BJCKiwSSbyb5emwsc73Iu + ASQiosF01ajOTcKAi3AJIBERDTbZTBosNxk4GZcAEhHR4Lp6ZGeexQYDJ+MSQCIiGmzqUkDLTQaOdSWX + ABIR0WC76qrOL145Um0qcIurRnb9WU8fERHRQDNOlk0lYd5k4FwjRnR+SU8eERHRwJNNZbN5k4FjxYYP + N96lp46IiGjgXTGqq+gK2VzgBh2r9bQRERENLvWVwNabDZzm8pEdl+tpIyIiGnxXjurcZrXhwFFSI0YY + Z+gpIyIiGnyXj+gcZ7HhwEFkjhr1dBEREWWmq64y3iubzMHL1UYDJzp8GZ/+JyIiO5JNZopp04FDXDay + 62Y9TURERJlt+HDjPZeP6HpJGHCU5KWj2j+lp4mIiCjzXTKi478uG9HVIww4w6UjOifr6SEiIrIv2XTm + mzchZMflIw49EggYp+ipISIisq8xY4xTLxvZ+bjVhoShc/mIrjcvvzz1MT0tRERE9jd8pHHWpSO6XhYG + siJx8aiuf9PTQURENHRdMabjXNmI9pg2JtgvftnVb12op4GIiGjou+qq9McvG9G1w2KTgi0OBS8Zdejb + eviJiIiy1/DxxgcuHdm12nrDQgZt+/NVHefpYSciInJCxsmXjDg05pIRXQlhIKPeks1/7i9yjdP0YBMR + ETmrK67oOPeSq7tWix5hYHAuvrrz8Uuu5CV/IiJySX8ecejfZQO7Uxw+ekND36iN/9KrO3+th5OIiMhd + qfesL766a6Z4QcjGhmORjX/fJVcfqv7T1Ye+pYePiIjI/Q1Xbw+M6Lr04hGH6i8e0fWgbHovy68x+bXz + 6I3Q4w6rc/7zVV3/uPjqQ4/IM/0V6rMTl17ddb76HIUeKiLKaCed9P8DSNpSLt0DrRQAAAAASUVORK5C + YII= + + + + + iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vAAADrwBlbxySQAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAADerSURBVHhe7d0H + eBzVuf9xURNIgHuTPEkgIY3k8k/Ik3pTIbkhl9y0y725CQ64Yku2LEuWZbl3xl1ykyVX2RAIIWBErwFs + MBhjmgktxrgb21ptX/VdyWX+7zGHGEZjayVtmRl9f8/zwUjanT1nZt5zzkhbcgghzo5pmGeGqvdfGF17 + 8BuRtbW/iFQf6hNd68uPVtdOiK45NE/+f2V0Te3t4oHYmtr10bW1W+T/t4pdYq+IfpCvXf41P+j49yy3 + q90bWVO7U/7dqrZ5fNvyGOL2dx9THlu1Qdqi2qTaptqo2mrWmGfo5hNCCCHEmoYbD35MTZoymf63TKyF + xyfVNYdulYn3yWj1oTfl34B8/5iwTNiOd+x421Uf1tZuUH2S/58rRhzvq/RZ9V3vBkIIIcRbMU3ztMif + ai8OVR+6MrLGNyy8prZcrpbvkcnxNdEszF6uSci+OHS37JuySLVvaGjtwZ+pfab2nd6NhBBCiHMTuunA + RTKJXSUTfYlM8tUysW0WjXqiQxfJvkzIv9sia301kepa4/ifGdbUXWYa5ul6lxNCCCGZi/qbvJqIwqsP + DZKJqVKsFxFhIiPUbw02v7vI8pVEq31X7Lt534f14SGEEEJ6HvVr6NCaQ/8WXuMbGK6uXS5eFglhwlHk + mBx6Sf5dro5VcPXBr+hDSAghhHQeX7Xv3PDaQz+Xq8wbQtWHHpUJJfK+SQbuEo6s8T0SWVM7I7Tq4M8O + Ljl4jj7MhBBCenv8t/o/ov5uH6quNWTCWC+4uveuw2KrerJhaHXt1bGb9/2LPg0IIYR4Perv9+pvxjIB + zJTJYIueFOwmC3jf4dDx5xLU3hBZU/tjdW7o04QQQogXEqg+cIkM9kUy2N8vV/oNwgQ68tXLv/eF19QW + +tf6v6hPH0IIIW6Jehe60Frfd2UwN8TWEwM80BWH9sjCsVL9icis3nqWPr0IIYQ4Kepv+cHVh64Jra69 + LVhdG7Yf0IFuC8mC4NbAGt8f1BNF9WlHCCEkG1EDsXoylxqYZdJvEiaQAfHg6tqHAqsPDYpW77lAn46E + EELSmdBNofMCq+sGBVf7HhYJYQJZJOegWgz4BgRXBD+qT1NCCCGpiFmz7ex3r/R9t8qA22QZgAGnOP6b + gWB1XR91zurTlxBCSFei3oEvWO27Qq6s1oioMAEXiQSqfasDq2ov16c0IYSQUyVUHbrQv9pXIgPoG5YB + FXCrHbIQMHzLfZ/XpzkhhBCVbTXbzg6urrtGJv5HZLA8Yhk8Aa84Iuf4w4FVvj+Y1SYvKySE9N6Elh24 + KLi6dqIMjActAyXgdf7A6rqyulV1X9DlQAgh3o76LPfAmtqrZACskauhw8IEerGj/lW+9XXHnzhonqHL + hBBCvJNIVeR8GehKZcDbYxkAAbxrd92q2pHqTa102RBCiHsTWBn4kvpVpwxuMctgB8BegyyWK8OrDn5G + lxEhhLgndSvr/qNuVd0Ddat8R4UJoMsSvpW+G+tW131NlxUhhDgz6rX7/tW1V/tW+Z6zGcwAdJN/lW+z + qi1VY7rcCCEk+1EvaZKrlEEyUG2zDlwAUse/2veqqjVeRkgIyWrU6/dlMCqUgemgdaACkFbv+Fb7ClQN + 6nIkhJD0570rft8q325hAsiad3wrffmmYZ6py5MQQlIf9Rr+upV1fWTQ2WkZhABk177jCwHeS4AQksqo + Jx7Vvvvkvtcsgw4AZ3nr+HMEWAgQQnqa2pW1V9Wu8r0iTAAusdr3j0Mr6/rwqgFCSJdzcHXdb2Qg2dph + YAHgGodW+V7yrfb9Spc1IYScPL7lvu/4Vvo21q6UAQSAR9Q+eXDlwW/oMieEkBM5uOrgZw6t9FXLYHGk + 4+ABwAOOSo3f6l/l/6Que0JIb07optB5h1b55sjA0CJMAJ4XObiytpiXDhLSi1O7ovZqGQwOWAYHAL3D + 24dW1v1WDweEkN6QQ6sPffPgSt8mmwEBQO+z/p3ldZfp4YEQ4sXsq9j3LwdX+Cpl8j8sTADQ2tXYsKc6 + eoEeLgghXoh6LfChFXWDpMiDlqIHgH86tMLnP7Ci9lo9dBBC3JwD1YFLpKifOLiyTgocAJKwou4RX7Xv + c3oYIYS4KVurzbOkkCeK+AcKGwCS0ywmqs8A0cMKIcTpeWdZ7eWygt9+YEWdCQA9stK/ef8K31f18EII + cWIOLjl4zsHldWVStEc6FDEAdF+7Glt2Ve36kB5uCCFOibrqlyLdYSlaAEilNw+t9P9QDzuEkGwmuCL4 + 0f0r6la8s6LumDABIM2OvLPCt9S/0P8RPQwRQjKdA8t8/y6T/w6bAgWAdNu7f3ngR3o4IoRkIup1/e+s + 8Je8s7yuzaYoASBTDgvDrDHP0MMTISRd2b2i9mK56n9amADgEFv2L/N/UQ9ThJBUR1ba1+xfXhexKT4A + yLb6/St8/fVwRQhJRd6+KXTevuX+apuCAwBnWVl3qxqz9PBFCOlu9lbVfV+u+ncJEwBcYp96abIexggh + XclGwzxz37I6Qwrp8D4pKABwEzV27V3um8YTBAnpQnZU+z6xf4VvvV1RAYCrLKt7eu/SwKf08EYIOVn2 + L/d9R4pmX4ciAgCX2r+87uC+5f4f6GGOEGLN3hV1g/Yur2sVJgB4TGLvCt8wPdwRQlTUB2zsXeZfY1Mw + AOA1t6oPLtPDHyG9N7uqDn1WCuIFS4EAgGftWV73yr5VdV/QwyAhvS/7Vtb9hxSD31ocANALhPZUBa7S + wyEhvSPqvfz3LPOXyCq4XajVMAD0RkfERDUm6uGREO/GV+07V074u/Ysk5MfAGDuXVa3jucFEE9Hvb5f + rvw32xUAAPRyL/J+AcST2VMZ/MruZb6du+VEBwB0JIuAvTtX+L6qh01C3J/dy2ov311VF7I74QEAHxDd + tazuZ3r4JMS92b3Mf62c0HHLCQ4AOLm2Xct8A/QwSoi7op7VKqtYQ07kY5YTGwDQuWNqDNVDKiHuyDZj + 29ly4v551zK/CQDovt3LAzdvrTbP0sMrIc7NvorYv+xa7n/K7kQGAHTdzir/BjW26mGWEOdlT6Xvc3Ky + brOevACAHntTvXW6Hm4JcU62V9R9Yecy/x5ZqarVKgAgxXZU+ffvXhH8sh52Ccl+dizz/T+Z/A/ZnbAA + gNSRRUDd7kr/1/XwS0j2sqsq+G05KYPWkxQAkDaBnRXBb+lhmJDMZ8fSuu/JajQi1KoUAJA5sV3LAz/S + wzEhmcvOpb6fygnYaDkhAQCZ07yTjxQmmcyOZXW/lhOv1XIiAgAyL/H2Mv//6OGZkPRlV5X/anXCWU5A + AED2tL1dVXeNHqYJSX22V/n7vl3lPyxMAICjHNleVTdYD9eEpC47KgMD5QQ7ajnhAADOcfTtZQE+RIik + LjsqAr97u1Ku/CvlBAMAONmRtyvr/qiHb0K6n7eWBn6xvdKfECYAwBXa3qqq+60exgnpet5eFrhcTqRm + y4kFAHC+1u0VdT/TwzkhyWfbUv8P5ARqtJxQAAD3aN5RGbxCD+uEdJ4dVYFvyokTsZxIAAD3qX+rwvcd + PbwTcvJsXx76t7cq/X5hAgA8Ibitqu5repgnpGPerApcIidKreXEAQC436GdFYEv6eGekBN5c3HtxXKC + 7LecMAAA79j7etWhz+phnxD19r6R87dV+t8QJgDA07a9WhH7Fz38k96crdXmWXJCrN+2VE4MAIDnvbXU + v3Gbse1sPQ2Q3hjTNE97qyJwi90JAgDwsEr/TXoqIL0x2yrqDNsTAwDgeW9V+Kfq6YD0pvyj0n/dP5b6 + jwkTANArHXuzMjBQTwukN+Stpb6fyoFPWE4EAEDv07atwv9zPT0QL+fNCt9X/7E0EBVy4AEACEReXxq6 + VE8TxIvZscj3iTeXBnYJEwCA99krPqWnC+KlbFly8Bw5uM+/72ADAPA+wZe2VvvO1dMG8ULUy/3eqAzc + ZX/AAQB4T/AOPXUQL+SNpcGJb1QETAAAkjBGTx/EzXm9wv9zOZiHLQcXAICTOfxmRd3P9DRC3Bj1AT9y + IIOWAwsAQGcCr1dF+OAgN2ZX1a4PvVERfMnmoAIAkIwX1FyipxXilrxeEVz7uhxAAAC6bWlglZ5WiBsi + q7Z82wMJAEBXLfXn6emFODmvLan7vhywRIcDCABAdywNxN9cEvp3Pc0QJ+bF5Yc+/lpFYJ8wAQBIFVkI + vLN1ke8TerohTspGwzxTDtKT1oMGAECKPF5TY56hpx3ilLy6OGC8tkQOEAAAafL6Ev8UPe0QJ+TVpXXf + kwPTbj1QAACk2OHXF/t/qKcfks1sWxH86KtLAjuFCQBA2lUEdr9dHjpPT0MkW5HV2K22BwgAgDR5bUnw + Rj0NkWzk7xXBa+wODAAA6fbaYv+1ejoimYx6j+a/LwlEhAkAQBbEtlb6PqenJZKJmIZ5+itLgk/ZHAwA + ADJnceAZXhqYwbyy2D/V9kAAAJBhr1QEJujpiaQzrywKfVd2eJv1AAAAkCXt6m3o9TRF0hH1kr9XlgR2 + vrJYVlwAADjFosDbry/0f0RPVyTV+fviwErbHQ8AQLYtCSzR0xVJZV5eWPcz2cHHOuxwAACc4eiriwM/ + 1tMWSUW2VvvO3bo4uEuYAAA42BvbDPNsPX2RnkZ2aKVlBwMA4ExLgtP09EV6kr9XBH4kO/RIhx0MAIAz + Jf6+KPI1PY2R7mRX1a4PyY7cbtmxAAA43bPqTev0dEa6mpcXh254WXYkAABus3VxYISezkhX8sKC4Fdk + B8atOxQAAJdoeKE88lk9rZFk8/Ki0IaXF8kOBADAvR7W0xpJJi8uCl7/kuw4AABcb2Hwj3p6I6fKs/Pr + /1V2VtB2JwIA4D7+rWXRC/Q0R04W2VHLLTsOAAB3Wxys0NMcscvLC/1ff3FR8LAwAQDwkMMvLAx8Q093 + 5P0xTfO0FxcGn7bZaQAAuN/i4CY11+lpj7yXlxYHBtjuMAAAPIInBFqyuTx0nuwYn3VHAUiJXS8sDqyR + RfaIlxb7/3PLkuCX1ZNtt1abZ6kPLVH/r76nfvbSokCh3H6tus/77g8gdQ5sNXzn6umPvLgwOOcF2TEA + UiWw7fmFwYnPLfJ9XpdZl/N8Rd0XZFuT1LY6bh9A94Vm6DLr3dmyJPyZFxYGW4QJoMc2P78wdLUur5RF + Bq0rnl8UfMjm8QB0XdPWitCFurx6b2RH/NmyYwB03fYXF4Z/rssqbXl+YeAqeay3LY8NoIueXxi8UZdV + 78wLi0LflZ1wVKidAaDrjmxZGJil/pavyyrtebRq14fkcecIahfoviMvLg58U5dV74vsgI2WHQIgeXWZ + uOo/WdRvA6QNAUubACQttF6XU+/KCwuCv7HfIQCSsPPFhf4v6nLKWl6uCHxJ2rLL0jYASdqyIPgrXU69 + I+qNEKTjW607AkBS3nxuof+TupyynheWBj6l2mRpI4DkvNKr3hxoy8LA/22RjgPomucWBg+8tDhysS4l + x2RzeeiiLYuC++zaDKATC4J9dCl5O6Zhni4dfr3DDgDQmUaZaC/VpeS4PF8e/qq0scnSZgCde3ujYZ6p + S8m7eX5B8FqbzgPoxHMLAwN0GTk21DfQbXm6jLyZmhrzjOcWBN8SJoCuCP1Fl5Hj89yCwO32fQBwCgfU + S2x1GXkvWxYEBtl0GsCp1W9y0buGvTA38Clpc8zSBwCdKQ8U6jLyVtTfN55bGNolVzLSUQDJ2rIwNFqX + kWvyXHlorF1fAJySN38LsHlBaKhNZwGcWsCNnxym2ixtD1r6AqATm8tDBbqMvBH1NqWyANgvTABdEZyi + y8h1eXZBcJp9nwCcwjuZfGvvtOfZBeEim04COLWj6tMydRm5Luq9AaQPRyx9AtCZhaHhuozcHX31f6BD + BwGc0rMLw4/pMnJtNi8IPmHXNwCnEt7nifcFeHZBMPdZ6RCArvHC3wI3l4dH2vUNwKltWhh2/Pt+nDLq + /Y2lI9usHQPQOSe/61+y2bQo8jW7vgE4tc0Lwm+4+jMCNpWHf/dsuXQGQFcFdBm5OscvAspDIUvfACRh + U1not7qU3JdN5cEtm1QnAHTV07qMXB/py7OWvgFIgiwCNukyclc2LQj9h12HAHTumfJQtS4l10f6s9ba + PwDJeaYs8GNdSu6JNPwBa0cAJEcWAIYuJddH+jPL2j8ASSoL361LyR3ZOD/4ZWn40Q4dAZAUWQCM1eXk + +kh/xlv7ByBpR56dH/iSLifn55nycKUMYGoQA9ANT5eFR+hycn1UX+z6CCA5sghYrMvJ2dlcHjrvmbJQ + g10nACRn04JQqS4p1+fpstAYuz4CSFrjC1WR83VJOTcUO9BzsuKfrkvK9ZH+GNb+Aeiap8uDo3RJOTOm + YZ7+dHloj5DGAui2snCVLivXZ+OC4HLbPgLoit1qjtVl5bw8My/4m6fLpKEAeuSZMvd/DsB7kf6st/YP + QNc9VRb4pS4r50Ua+KC1wQC6YX5ovy4r10euXA7Y9hFAV92ny8pZ2VwW/Zw07oilsQC66ck57v0o4Pfy + zJzIxXZ9A9AtR55cFPu8Li/n5Omy8NyN0kAAqeLyTwOTbJwfHGzfNwDdMt9hbxJWY5hnS8PqOjQUQLc9 + VR66XZeYayNXLHfa9Q1A90hN1W40zDN1iWU/G8uD19g1FED3SaG3PGq44LW/J8n6sugF0o+4tV8Aeqg8 + /DtdZtmPNOjRp6RRAFLrybLQMF1mrouMC8Pt+gSgZ6S2HtRllt2oJypJg45YGwggJXbV1Jhn6HJzTVSb + pe07LH0BkBqHN80NXajLLXt5qjw82aZxAFJk4/zgtbrcXBNpdz9rPwCk0PzQeF1u2ctT88PbhTQGQJq8 + 8/hC/0d0yTk+Dxm+c6XN+yx9AJBab+uSy07Wl0WveFIaAiDt5uiyc3yenBeeb9N+ACm2sTzyQ112mc+T + ZZE1do0CkHLtUm8/1qXn2OiLgsOWtgNIh3nhlbr0Mhv12n9pQLRDgwCkxVPzwwc2zGv8uC5Bx2XjosZP + SDsPWtsNIF1Coa3V5lm6BDOXDfPCv9sgDQCQOevnh19w4vMBtiw5eI4MRpvt2gwgfdaXhX6ryzBzeXJe + 6E67xgBIuwfVb+B0KWY9qi3SpocsbQSQAU/OC/9Vl2Jmsrk8dJ48cIu1IQAy5kknvEvgRiP40Q3zQ3+z + aR+AzGhRdahLMv1ZXxYeZNMIAJm1deP82Bd0WWY8G+YHviRt+LulTQAybH1ZqJ8uy/Rn/fzIw+vVgwLI + Kin+6Pp54d/r0sxYNsyLXCMXAjG7NgHIuAd0aaY36gM+ZMBpEyYAx3jobxn4bYB66295rFstjw0guxIZ + +ZPghvmh/jYPDiD7WtbPDy15ojx0kS7XlEVtc/28UMXxx7B/bABZtGF+JP1vGf7E3PC9T8iDAXCshAwI + t62fG/llTz5ISN1XBpVfPT4v/Fe1TctjAHCWGl266Yl6/bE8SIvlQQE41dxQSP6teXx+uHD9nMgPHzMa + PqbLuUPUzzbMi/xIFvlFcp+79H3ttwvAaZrV53Dock59Hp8XucbmQQG4S4PYJ97Q1P+r79ndFoBbzA// + n56uU5/H54VvEyYAAHCcW/R0ndqovwfKxsOWBwMAAM4Q7Mnzfk6ax8uCP7V5MAAA4BB/mxf5kZ62U5fH + 50cW2D0YAABwhsfmhefqaTt1eWxueLswAQCAU4Ve19N2aqLe89v+gQAAgJOk9F1BH5sTHmn3IAAAwFke + nxvK19N3z/O3ueEHhAkAABzvLj199ywbDfNM2Vi9ZeMAAMCBHpsbjqXk5YB/mxO9wu4BAACAMz0yL/wD + PY13P4/NCc202zgAAHCoeeFpehrvfh6dG94iTAAA4BaRZ/Q03r08UB46TzZyWKiNAQAAd2jr0acDPjI7 + 8qtH58iGAACAq/xtbvg/9XTe9TwyOzrvEdkIAABwF1kEzNTTedcjG3jOukEAAOB8j86JbtTTeddSs+Tg + ObKBNusGAQCAK8Q3Gvs+rKf15PPo7PDPbTYGAABc4uF50Z/oaT35PDwnMkOYAADArcJT9LSefOSOf+u4 + IQAA4Bpzow/oaT25mKZ5mtwx3GFDAADANR6aEwnoqT25PDA7dKncSd0RAAC42KOz6y/R03vneWhWeNBD + s+WOAADA3eZE++vpvfM8PCe8wnYjAADAVR6cHa3S03vneXB25GUhdwIAAC73op7eT50awzz7wdnhhM0G + AACA+8Srq82z9DR/8jwyN/YtmzsDAACXenhu9Ot6mj95HpgVybW7MwAAcKk54YF6mj95HpgTXfaA3BgA + AHiDLAKW6Gn+5JEbbrbeEQAAuNeDszv5ZEDDME+XGzZZ7wgAAFwtpt7lV0/3HXOPUf+l+2dFTAAA4C33 + GJHP6um+Y+6dHf1vuzsBAACXmxn5pZ7uO+b+2dGJtncCAADuNjtSqqf7jrlvduQW2zsBAABXe2B25EY9 + 3XfMfTMjL98nNwIAAJ6zRU/3H4x6dqD8sMlyYwAA4A0Ntq8EuH9O5GKbGwMAAI94wAhdpKf9E7l3dv3P + 750VNQEAgDfdPyv6Ez3tn8h9s6L5djcGAAAeMTM2RE/7J3KPES2/d6b6IQAA8Kg5eto/kXtnRe6xuSEA + APCI+2ZG1+lp/0TumRl9XZgAAMCztupp/0Tkm02WGwEAAG+p19P+u7l3XuPHbW4EAAA85jYjcr6e/nNy + aozYt+6WbwIAAG+714h+XU//OTnyjautNwAAAN5z18zor/X0n5Nz16xood2NAACAt9wzK5qvp/+cnLuN + 6Hy7GwEAAG+5y4jM1tN/Ts5dRvQvQr4JAAA87s96+lcLgMgGmxsA8I64eFXcKcrvmhmdKFcCRYr6/+Pf + e/dn6jYJYbcNAJ4Qe0JP/+pVANE37W8EwK3uNqK75d+598yMXXmzse/Dutw7jbptjVH/c3Vfsee97QHw + BpnzX9PlfnwBEBTqmwDc7ahYJ66w/dzvLkZtQ21LBo079bbtHhOAu9QdL/CNhnmmfEFhA+63bp0R+rfj + hZ2G1MwOXVpjxGpsHheAuxwxDPP0nHvmhi60+SEA99h1pxG+Ss/Tac9dRuS/5DF3W9oAwEXuNZo+mXPH + rNi375QvALhR7O6asugFem7OWB4oD50nj397x/YAcIN16t0Aa2ZGfmH3QwCOdrRmZqxEz8dZS40RGSNt + OWZpGwCnmxm7MudOI/JH2x8CcKr2O2dG++o5OOupMaL9jrfJvq0AHGidEft9zroZ0eF33iDfAOB8crUt + hTtIz72OyTojep2072iH9gJwpJoZkbwcGVAmrJMvALjAjOz/2v9kWWdExti2GYDj3DkjMjbnDiM6z+6H + ABzGiK7Tc61jI228zbbtABzljhsis1XBrrT7IQBH2fXAhNB5ep51bG4zIufLmLLbpv0AnGWZ+g3A7XfI + FwCcK5Ov8+9p/joj8ku7PgBwjtuN6G0564zYg3fcEJNvAHAkF/zq3xoZV+627QsAZzBi9+fIfzbY/hBA + 9hmxIzXTGi/V86prcrsR/n/S/qMd+gPAIaKP58j/PNfxBwAcwYVX/+9F2n9Xh/4AcAYjtinn9htirwoT + gPPcNj16uZ5PXZe/GrGf2vUJgAMYsa05t8+Ivn37DPkCgKPcMSO218zp+Uf6Ziuq7dKPPdZ+AXCEbbIA + iB2wfBOAA9xxQ/1cPZe6NrffUD/frm8Asm5/zl9nxILCBOA4V+p51LX5q1F/lU2/AGSfXy0AopZvAsi6 + +vjNxr4P63nUtakpPXiO9CfRsX8AsiysFgCNlm8CyL5X9Rzq+khf3rD0DUD2xVRxtli+CSDr3PvyP2tu + nx67y76PALKoKee2GfXx2+QLAA5yQ/18PX+6PrfdEC237SOAbGqVBUDssOWbALJtenSSnj9dn79Mj06x + 7SOAbGpXC4Bjlm8CyDKZNEfq+dP1kf4UW/sHIOuOyuo8dkzIgAPAOerz9fzp+qi+2PcRQBYdXwActnwT + QNaxAACQVu1qAZCwfBNA1rEAAJBWrTm3To+1CBOAc3htAWDXRwBZ1aQWAI2WbwLIMhYAANIsphYAUcs3 + AWQZCwAAaRZWC4Cg5ZsAsowFAIA08+f8eXrsgDABOMctHloAqL7Y9RFAVu2TBUD0bZsfAMgiFgAA0umW + 6bFtOX+eFntVmACcw3MLAJs+AsiqrWoB8Nwt8gUAB/HYAsC2jwCyaVPOLVNjG2x+ACCbWAAASKvo41Kc + sQftfwgga1gAAEiv+3JumVZ/u5AvADiG5xYANn0EkEWx23Junlq/4mb5AoBzeG0BYNdHANkUq8q5eXr9 + XPsfAsgWFgAA0is2K+eWqfUT7H8IIFtYAABIq6mxMTl/kuL8k3wBwEE8tABgjAGcKDYk56Yp9X/801T5 + AoCTeGcBIH2x9A1Alt00NfZ/OTdPqf+F3Q8BZBULAABpc9OU2JU5N02PfdPuhwCyigUAgLS5ZXrkspyb + jeZP3yRfAHAOKVBPLQDs+ggge6qNxk/k1PQxz5Avjlp/CCB7WAAASKPDhmGefrxA5Yug5YcAsogFAID0 + ifl0eebk3Di1/k1hAnCGtR5aAKi+2PURQNa8qsvz+AJgg+WHALKIBQCANHpcl6csAKbF/mJzAwBZwgIA + QPo03KLLMydnzZT6eWunyKADwBk8tgCw7SOALInN0uUpBTq5foT9jQBkBQsAAGmyZnL9MF2eOTk3Tmn4 + rd2NAGQJCwAAaXLjpIZf6fKUAp0S/YbdjQBkCQsAAGnyp8lNX9PlmZOzclL9v66RbwJwBq8tAOz6CCA7 + qozI+bo83418s8l6IwDZwQIAQJrEdGmeyJqp9a/Z3BBAFrAAAJAOa6fUv6xL80Sqp9TfLUwADuChBYDq + i20fAWTe5Pp1ujRPRFYGZbY3BpB5LAAApMccXZonol4XKCsDtToAkG2TPLQAkL7Y9hFAxq2eHBuiS/NE + qqfErrS7MYAsYAEAIA3WTo7+RJfmiaydEPns6skNsjoAkG1eWwDY9RFA5lVPablQl+aJmDnmafLDRuuN + AWQeCwAAadCg5npdmh/MqskNL9ncAUCGsQAAkAZbdFl2jCwAbhEmgOxa6aEFgOqLXR8BZNiU+rW6LDtm + 1eTGCbZ3ApBRLAAApNrKyQ2jdVl2zMopDb+1uxOAzGIBACDVVkyq/y9dlh2zdlr9F+3uBCCzWAAASLmp + rZ/RZdkxhmGevnJSQ6OQAQhA9nhrAWDfRwAZFNUlefLIjTZZ7gQg41gAAEilxid1SZ48KyY1VNrfGUDm + sAAAkDorJtUv0iV58qyY1DhYFgFyYwDZ4rUFgF0fAWRUf12SJ0/VxNg3be4IIINYAABIpeUTmy7TJXny + GIZ5ptw4br0zgMxhAQAgdepb1dyuS/LUWTG54WX7jQDIBBYAAFJl+eSGF3U5dh658fLl6k4AssQ7CwDV + F/s+AsgEWQQs1eXYeWQBMNBuIwAyhQUAgNSQBUBfXY6dp3J8w1eWT5Q7AsgOry0A7PoIICOWjav/oi7H + zqM+L7hqYkNombojgIzz2gLAro8AMiKgSzH5LJvQ8IjNhgBkAAsAAKlRf58uxeQjC4Dp9hsDkG4sAACk + Rv0kXYrJp3JC7MoquTOAzKv00AJA9cWujwDSb9nkxst1KSafJaXmOXLnhHVjANKPBQCAnqtvrSo2P6RL + sWupmtCw2X6jANKJBQCAnmt8Spdh1yN3nmu/UQDpxAIAQE9VTmowdBl2PUsnNvyyUm0EQGZ5bAFg20cA + 6TUhdqUuw65nhRH8aOWEhsNCNgQgczy0AJC+2PcRQBq1VRu+c3UZdi+VExqfE7IxAJnT5KEFQJMsAOz6 + CCCNntYl2P1UTGgwlsrGAGSO1xYAdn0EkD4VE5qm6hLsfionNv7YbuMA0ocFAIAemdTwPV2C3Y9hmGdW + Tmist30AAGnBAgBAD0Rr+phn6BLsWWRj91k2DiCNWAAA6K6KCQ136vLreZZMaCqsOL5RAJnhnQWA6ot9 + HwGkxfjGobr8ep5FY2Oft30QAGnCAgBAtxyrmtD6WV1+qYls9B+WBwGQNiwAAHTd0gkNf9ell7osGd84 + X5gA0s9rCwC7PgJIvcUTGmbp0ktdFk1svMLuwQCkHgsAAN2xdFzDD3TppS7qJQWy8ZD1wQCkHgsAAN0Q + MAzzdF16qc2ScY232jwggBRjAQCgy8Y1/kmXXeqzeHzTHxbLgwBIr0UeWgCovtj1EUBqLZrQ+DtddqmP + +mQheZBm64MCSC0WAAC6ZFxj05JS8xxddumJPNDdHR4YQEqxAADQNQ3rdMmlL4vGN/RdJA8GII08tgCw + 7SOAlFk8vqmPLrn0pXxC6Dx5sLj1wQGkEAsAAMlrXTjO/xFdcunNorGNDy0aJw8KID3GemgBIH2x7SOA + lFg8rvFeXW7pz6KxDQMXyoMCSA+vLQDs+gggVZqu0+WW/qhfNciDNndsBIBUYAEAIEkyF2fo1//vZdHY + hnU2DQGQAiwAACTpL7rUMpfFYxr/x6YhAFKABQCAZMjF+K91qWUu1fnmWQvGNYaFCSDFPLQAUH2x7SOA + ngqquViXWmYjD77a0hgAqcACAEBnxjYs12WW+SwY33i5baMA9AwLAACdKJ/Q8H1dZtmJNGJ7uWoIgJTx + 2gLAro8AemBs4z90iWUvZWMbJ5WPbZLGAEgVzy0AbPoIoCeax+oSy14WjG/+tDTmcMfGAeguFgAATuGw + mnt1iWU35eMaH7FpIIBuYgEA4GQWjGm6X5dX9jN/TNMfyqRRAFJjvocWAKovdn0E0E3jGv9Xl1f2Yxjm + mdKo2g6NBNAtLAAAnIQva6/9P1mkUbMtjQTQTSwAANgpH9N0gy4t52TOmNaLpdCPCDV4AegZTy0ALH0D + 0D2H55S2fkaXlrMyf2zzgzYNBtB1LAAAfNCYpsx97n9XUza25de2jQbQVSwAAHzQ+Ob/0mXlvBiGefq8 + MU27ZZWiVioAustrCwC7PgJIXmnTTjXH6rJyZqSRI2URYALoPq8tAOz6CKBLRuiScm6MfPPceWObwjaN + B5AkFgAA3ieycJz/I7qknJ25Y5rm2HQAQJLmlzYV6HJyfVRf7PoIIDkyp87S5eT8GOOaPikNjgvVcABd + VeqAD/pIUeaWNo637SOAZCQc877/yWbOmOYbbToCIDmGLiXXR/oyy9I3AMlbrUvJPZld0nipNPyopSMA + klHaVK1LyfXhYgDotmOzRzd9VZeSuzK3tPlhmw4B6NzTuoxcH+nLs5a+AUiOcz71r6uRxl85RzoBoMsC + uoxcHTPHPE36ErL0DUAS5pU2/kSXkjszp7T5xTml0hkAXaL+jKbLyLWZVdp0mV3fAJza3DGNL+kycm/m + ljb3s+scgFOb7YY3/ugks0c3Fdv1DcCpSe1co8vIvTEM88zZpY37Z6sOAUjanDFNj+kycm2kH+ut/QJw + arIA2FPTxzxDl5G7o65k7DoJ4JSOOvajP5OIarv04YilTwA6M6ZxmC4j98cwzLPnlDbvs+0ogJOaU9o4 + RZeR6yJXMdPs+gTgVBr3qzlTl5E3Mmt0Y+4s6RyALgm55j3A3xfVZml70NIXAJ3zzOeA/DPquQDSsZ2W + jgLoxOzS5lJdRq6JXMWMt+sLgFPx4NX/e5k1pnnArNJm6SSALmiYO7rlQl1Gjo8xvvnT0uZ6Sx8AdGL2 + mJbhuoy8F/WsRunkNmunAXTqr7qMHJ/Zo5vX2bQfwKl59+r/vcwsaeozc3SzCaDLBuoycmykjX0tbQaQ + hFmjmwfrMvJu1FuDSmdftXYeQGdamozipq/pUnJcZpU2XSbtbO7YbgCdeMszr/vvLDNLW/7XZgcA6NxB + oyT+OV1Kjol6zb+0bb+lrQCSYIxu+r0uJe9H/RbAGN38kpCOA+iiN+eWNH9Kl1PWo570J236h6WNAJLz + kpoTdTn1jhilzb+y2REAktKyyyhNfEmXU9ZilDZ8Wa5e9ti3EUBnZpY0/0KXU++KdP4J684AkLSALKSv + 0uWU8cjA9UtpQ9DSJgDJe1SXU++LetKQ7IDDlh0CIHlHjZKmuVXF5od0WaU9hmF+2Chpnn/8se3bBKBz + 7bNHN31Vl1XvjDG6ZfkNsjMAdJ8MJjuN0ub/0mWVtqg/3d0wumWXXRsAJE9qdqkuq96bSSPq/1V2RNhu + BwHoGllQb55R2nJ1ToqfVGSUNF4hk/8Gu8cE0GWRyUWNH9fl1bszY1RT8Q0lslMApMp2o6RlSk+eKKju + O2N0y1S1Lcu2AfTAjNFNI3SZEfVBQTNKmrcJE0CqNe25YVTzTTLoFMnXv5g2quErRmnDx9TbjirqSkR9 + T/1M3eb4bUua9564P4AUeqNPb3nTn2QzY1Tzf9rsKAAAvKR3vuyvs0wvaX7IZmcBAOABTffq6Y5YM624 + /hLZSYmOOw0AAFdrU39q09MdsYvspEXTZWcBAOAh8/U0R06WiROjF8iO8lt2HAAAbuWbMCF0np7myKky + fVTTdTY7EAAA15lR0vQHPb2RZDJ9dNP902THAQDgYg/paY0kG2Nky0XTRjXHhAkAgAs1TC1t/Yye1khX + Mm1UU5HNDgUAwPGmj2rJ19MZ6WoMwzx96qiWZ6fKjgQAwEWeSfVncvS6TCtpvFR2ZNyyYwEAcKrEtN7+ + Ub+pytTilhk2OxgAAOcpaZmipy/S06gPC5Kd+mqHnQwAgLO8np9vnqWnL5KKTC1u/f6UUS1HhAkAgAMd + nTy69Ud62iKpzJRRzUttdjgAANlX3LpIT1ck1THyzXOnjGrdbrvjAQDInrfUHKWnK5KOTClq+c7k4pY2 + YQIA4ACJScUt39bTFElnJo9snmRzAAAAyLgpxc1j9fRE0h31BkGTi1uftDsQAABkTvPTak7S0xPJRNT7 + K8vOj3Q8GAAAZER0amHrxXpaIpnM5OLW30+SgwAAQKZNHNX6Rz0dkWxEDsLN1oMCAEBajWyp1tMQyVbG + jTM/Mqm4eYftAQIAIPV2TZgQOk9PQySbmTCy5d8nFre0CxMAgDRqn1zS+gM9/RAnRBYB020OFAAAKTOp + uHminnaIU9Knj3nGxJEtTwgTAIA0eJSX/Dk0paUNH5MDtNdywAAA6JFJI1v2Ty5q/LiebogTM76w+VsT + Rra0ChMAgBSIjy9q+Y6eZoiTM6GoeaDNAQQAoMvGFzcP1tMLcUNktbba7kACAJCsiSNbqvS0QtyS/Hzz + rPEjWzYLEwCAbthiGObZelohbsro0S0XygrOZ3NQAQA4FX9pQetn9HRC3JjxI1svlwPZbjmwAACczOGx + RfGf6mmEuDkTipvH2hxgAAA6GFfcOkpPH8T9MU8bW9i8blyRHFgAAE5ifFHrbXriIF5Jaal5jhzcLdaD + DQCAMrao5UUj3zxXTxvESxmb3/iJcYXNO+0OPACg9xpf1LJnXEHTJ/V0QbyY8cWJS+RgB2Wlp1Z7AACE + xxQl/k1PE8TLGV8c/8nYotaEkAMPAOjF4urVYnp6IL0hY0a2XisH/pjlRAAA9B7HxhbG++tpgfSmjCmM + Tx8jJwEAoPeRyX+Sng5Ib4ycAKvsTgwAgIcVttyopwHSW6M+M2BMUcsTticIAMCD4o8ZhnmmngZIb05x + sXl+aWHr62MK5cQAAHhY/B8T86MX6OGfkJwc9aEPsgjYI0wAgPeMHtG6e8LIlov0sE/IiZTkxz8nJ8l+ + 60kDAHC9g+NGxr+oh3tCOmbU8MRX5ESps5w4AAD3Co4ubPuqHuYJOXlKRjR/Y3RRa2S0nDgAAFeLjSlo + +bYe3gnpPCVFrT+QE6fRciIBAFyjpaGksOV7elgnJPmMHtl6uZxEzR1PKgCAw7WWjoj/hx7OCel6SooS + v5ATKWE5sQAATlXU2jamqOU3747ihPQgo0e0/K6ksPWwMAEAjnakZERrHz18E9LzlIyID5CT6qgwAQCO + dHR0AR/uQ9KQUQWt18kJ1m454QAA2Xdk1Ij49Xq4JiT1KS5suXrUiNa4MAEAjtBWXNj6ez1ME5K+jCqM + XyknXJPlBAQAZF5LSUHzL/XwTEj6Uzwi/pNRI1oabE5GAEBmNI0siP9cD8uEZC6yAPiunIBhywkJAEi/ + aPGI1h/q4ZiQzKeoqOkyOQl9wgQAZEBhq794ePM39TBMSPZSMiJxaXFB60HbExUAkEo+deGlh19Csp+i + ovjn5cTcZTlRAQCps684P3GJHnYJcU6Kh7Z+dmRB/M2RBa0mACB1igtaXx85suUiPdwS4rwUFpoflUXA + I3YnMACgO1qeyM+PXqCHWUKcG8Mwzxw5Ir7K/kQGACSrqKDlpvx88yw9vBLijowcnigpKogfFXISAwC6 + 4NjIgrihh1NC3JfC4a3XyIkct5zYAICTS4wcEe+nh1FC3Jui4a0/khM6aDnBAQAdRYqGx3+qh09C3B/1 + 0pWiEfEdNic7AOBde0aMSFyqh01CvJOiosaPFxbENwkTAPABzxcUNH1SD5eEeC+lpeY5Iwrid9ic/ADQ + W902eLD5YT1MEuLtjBieyC8cHm8XJgD0UodHDG+dqIdFQnpPRoyI/2TE8HidMAGgVymIBwv4KF/Sm1NQ + 0PoZWQVvsS0QAPCmzbytLyES9c6BI4YnymyKBAC8prpPH/NsPfwRQlSkMAaIlvcVCgB4RbygIJ6rhztC + iDWFw5q/JYWyt0AKBgA84p3CYS3f08McIeRkUe8XIAXzmKWAAMB9CuKP5uU1fEwPb4SQztKnj3nGiPz4 + FCmg9g4FBQDO16Ze4mcY5ul6WCOEdCXDh7f8+/Dh8R3CBACX2Dt8eOuP9DBGCOlu1LsHFuS3Vg7Pl8IC + AAfLz4/fWlhoflQPX4SQVERW1L+XAgtbCw4Asi8RKxjWep0ergghqU5hYfOnpdj+1rH4ACBLhsefVG9q + pocpQkj6Yp42bFiiJD8/3ibUr9wAIBvahcET/QjJcAoK2r4uxffG+4oRADJle35+y3f0cEQIyXTy881z + 8/MTFVKMRyzFCQDpcGTYsMRiNfboYYgQks3kFbR8e1h+4pVhUqAAkCZv5BW0fl8PO4QQp0R9qNCw4a0T + pUjjlqIFgJ6Iy5W/wYf4EOLw5OUlviwF+5SlgAGg64bFNw8d2vZVPbwQQpwf87ShQ+ODhg6LR4QJAF1U + r15txDP8CXFp8vNbLswblrjbprgB4CRaHxoypPViPYwQQtycYcPa/jh0WMIvpLgBwJZPxoo/6GGDEOKV + 5OebF+QNS5RJkbdZih5A79Y+dGiisn+xeb4eLgghXkxubuLS3GGJx2QxYALo3WQseCg/P3GJHh4IIb0h + eXmJq2UA2G8dEAB4n0z828Wv9XBACOltUe/mlTesbaIMCA3WAQKAF8Uj8q96dv+ZehgghPTmqFcL5OYn + quWK4IhQVwcAvOWwqvH8/MZP6LInhJATUW/4IVcHj9gMHgDca31eXtvXdZkTQsjJM2RY4pe5QxOvCBOA + W8VfHjo08Qtd1oQQkmzM09QTBWUgeaPjwALAwbbLFX8fVcO6mAkhpOtRTxaSK4m8IUMTB4QJwLH2Dxka + H9Knj3mGLl9CCOl51CeByUJgkAwyeyyDDoDsemfwsETJ4MHmh3W5EkJI6vO+hcBuyyAEILOY+AkhmY9a + CMjgUzA4L7FvsAxGADJmz+Bh8WF8Pj8hJKtRHxcqi4Crrx8af9lmoAKQOq9InQ3iTXwIIY5Lbn78iuuH + Jh6yGbgAdM9RVVO5wxJX6TIjhBDnZsiw1h8PzkvcLYPXEctgBiA58SFDE9Xqw7t0WRFCiHsyeHD8C7IQ + KLs+Lx65Pi9hAuhU/fW5icrc3JaLdBkRQoh7k5trnnf90MQoGdx2WQY7AO/aOSgvUag+oEuXDSGEeCfq + CYODchNXyWBXIw6/b/ADeiP19/31g/Pa+vDmPYSQXpMB+S0XDsprmyhXPe8IE+hFfKKsX17887ocCCGk + 9+VnhnnmgLy238nV0IMyKB5+3yAJeEm7uP/63MT/qHNen/6EEEJUBg9u/rQMkiXiNT1oAu6Wm9iuftPV + d2jzp/RpTggh5FQZPLT1hzKArhShDwyogPMF5Up/+cAhrT/QpzMhhJCuRj05Sj1xcGBe260D8xKNwgQc + Z2iiVf6tEVfn55tn6dOXEEJIKjJwoPmRQXlt/WSQvV/Ejw+8QLa8O+nfN2BoW19evkcIIRlKnz7mOTL4 + Xj0wt+1W0ShMIANaxUMDctsH9e9vnq9PR0IIIdmIWgz0z237vwFD2m4ZkJsIDpCBGkid9oCcXzerV6uo + c02fdoQQQpwU9WZD/Ya2f1cGbkOu1LbKv8c+OJgDSdkmytTzT3jZHiGEuDCD8uOfG5jbni+D+d0iqgd3 + 4ANksRiRf2v657YPu25I68X69CGEEOKFqFcUDBzS/oN+eW3T+ucmnumf29YuTPRKbQNyE0/3H9I2tV9e + +/fVuaFPE0IIIV6PeuZ239zDV8iCYKJc+a2XSaHVMknAO9RiT/1JqKxvXuJqnsBHCCHkn/l1sfmhAYMP + /0QmiSkDhrQ9KIsC9eQvu8kEjtful38f6J/XNlkt8uQK/2x9mAkhhJDOc+31iUv65bb1lwmlSiaUF0X8 + xCQDh1C/uXlBjlGlTPj9+uUmvqQPHyGEEJKaqGeE9x3Wdlm/vLY+sjAwxEMy4QTlXxMZ0SD7e3M/mexF + vrq6V7+50YeHEEIIyWz69TP/9fjzCWRS6jdEJqch7ev7DZGFwRCZtNAdMtG3bRW39hvcNrHv4MTV717Z + m6fpXU4IIYQ4N9fltlzUL+/wT/sPbs+VyWxu/yFtd8rk9oqof99k11vFjk/yQ9rWqX3Td0j7kOPPwchv + uVDvPkIIIcR7Uc9E73t922X9Bid+8+5vDtpm9x3S9me54n1c/n1D1IkjwnQZ1ea6vrltr+u+/Pm6wW2z + VB+vzU38WvU5N9c8T+8GQgghhHSMedrAgU2fvDav7ev9cuNXyoT6e5lI8/rmJsaqBUO/we3L+w5uu+26 + IW33yBX0+r5DEptk4t0qk+52sUeE5evoPw1paxXWCbvVcpuwUPfdLl/LtmSbsu3jj3H8sdqXHV+sSBuu + U7/ZON6m+JVqYldt5df0hDg9OTn/H5nfwhdG2q02AAAAAElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vAAADrwBlbxySQAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAD6lSURBVHhe7d0J + fF11nf9/NmVxAUQFHUABFUdwGRkFR1xYxu1BxxmxP8cZZXz81XRvmiZt0qYtt23aJk2atNma2zRJWzYJ + FFrCVgqUrnQFRIoiFIYpIqBt7r4n5//5pt9qODnpltx7z/J6Ph7vRzA2yf3u55x7v+ecBAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgGzZ + 7Tfe8/wdxrm/azXO39VuXKqyZ2XyC3tWpK5SeaY9fWNfVma+/2xHZqSK+u/D3z/879TPHP75nR3GBep3 + bvAZp+k/AwAAsmlvp/He3SuMy57tSH+7b7Fu7xkjmSH/u+6ZjswqyUPy/e3y9RVJUGJkOYFnVmRe1n/z + IcmqQ6+lZ+azHT1j97RnfiIHEt9SBw7qYEQXAwAA9KcWyWfajI+rs+6+Bb6jp/TZ9oxfFtn18r/3yQKb + 0QuvU3NQyrRbvnY+05Gu3LOip0BdaXhuRfKKbZ3GmboaAABwp85O49TnVhqfeaY982NZCOfImfJ9e2SB + 37Mik5avhkeT2dOR/qN8vXdPR8+tctBz857lxqcMn3GKrjYAAJxDzuo//MyK9A172nom7e7ILJfFfpck + KjHIMUXV1c6+upM6VHW5Y6Vxnq5eAADsQb3f/Uxb5hZZtPx72tN75WuvXsjI8GbfnrbMqt0dPYXqLROu + FAAAckbO7s/a3Za+Vi1Cz7RnOmVR+qtpkSK5S0iyfk9b2renIzNC2uZs3UwAAAyN+pCeLPjXyZl9lSw2 + 6lJ+Wi8+xH5JP9OR2bG7PT1314r019m2CAA4Lmrf+662zC275QxfEpAYxJGJSLr2tPcU7F5lXKybFwCA + Q9SZYt9l/fZ05e72nt2yaPT2W0SIe7Jvl/qcRkdmxIYO4wzd/AAAL/ntKuN9uzoy/ykLwmpZGKKmhYK4 + P+E9bZm7JP/B/QgAwOXUWZ86++v7JLksAKYFgXg3MUmXettnb5Pxft1dAABOphb9ncszI2RyXyUJSQxC + jpDYzrZDBwPqKpHuRgAAJ1D7w/e0p78rk/idkrCe2Ak53qgDxpU7l6e/aRjGybp7AQDsRt1Tf/fynlKZ + tF/tN4kTMuTsbkv/cVdb2rfbz24CALAFdY/9Xe3pG3e1Zzplok6bJ25ChjkZyfrdyzMj1T0idDcEAOSK + emiMOiOThf910wRNSK7yphx8Vqq+qLslACAb1PuwuzoyP9gpZ2CSXolBiA3SI+na0Z6+XndVAMBweLne + OH1HW+aWne3pF3a2pWXCJcS2eW5Xe6qAGw0BwBA80258ZMfydKlMqn8yTbKE2D1v7WhL+3iMMQAchz3L + E5+SCXTJzuXpqMQgxMFJ7FieWvV0a/IfdfcGAJjtbk9dLQt/l0yaPaZJlBCnp2dHW/qeXcuTV+ruDgDY + 1pH8/I7l6U5Jr8QgxMXplQOBrp3LUl/S3R8AvGfnsuQVMiGy8BMvRl0R6NrRlvqiHg4A4H7b25OfU++L + yiSYMU2KhHgtPZLO3f7kZ/XwAAD32dWWuFwW/jv0pGc1GRLi1cjBcGrVbn/iMj1cAMD5ti41Prq9LePf + LpOcxCCEDJqkpPrZDuMcPXwAwHnUvdK3L0sVbm9NByQGIeSYc0CNnQ0+4zQ9nADAGZ5enhmxozXzisXE + Rgg59vxhx/LMSD2sAMC+1A1PdrSmH7GYyAghJ57121uTX9DDDADsY3urcf725ZllMlFlTBMXIWR4kt7R + mmnm9sIAbMHwGadsW54a//SydPBpmaQIIVnPO9tbMz/TQxAAcm97S+LTMhltME1OhJDc5KktbYnL9XAE + gOxTn+6XM/5SmYASpgmJEJLbxCS+vZ3Ge/XwBIDs2NGa/oZMOL/vNwERQvKf325vTV2jh6mnbOgwztjR + Gr9k6/LkleqeI/rbAIaLnPWfvX1ZpkXO/HslBiHEdul5elmmYXu98UE9bF3LMIyTZT66eduy9Dopd/Ld + 9ZB5Rb7O3dRufET/cwAnaps/8+8y0P4kMQgh9s5Wf+r/trWkb9DD13V2NhkXbGtNb7QquykHtrZmfqx/ + DMDx2NJmfGDbskybxcAihNg7vdv86Tp1eVwPZ1fYtjzxqW3LUq9blHew9Gxdlvq1/nEAx2JLa+oaWfxf + sRhQhBDn5AVZAL+kh7WjHVr80/tN5TuWpLa2pL+mfw2Awah7j2/1p30yaNKmQUQIcWaSW5elS9U9O/Qw + d5whLP6H0prepX8VACtPL41/UiaKzZYDiBDi7LSmt6mFVA93x1Dz0rZlmdcsy3Qcedqfulr/SgD9bWlN + /VIW/7DEIIS4NsEt/sz/6GFve+qARV7zflMZTiyt6Rr9awEom5uNc7f506stBwwhxJXZsiy1crffOEtP + A7Y0rIu/ZNuy9F79qwFsbkl9cas/88pWvwwQQojX8qJ6eqeeDmyl7+1If+Y1i9c8tCw3PqH/BOBdW5Zl + /lsGRHTAACGEeCmhbf7MSD0t2ELWFn/JNn9qlP4zgPc8XG+cvtmfXrJFBgMhhEh61ZygnvGhp4m8UYv/ + Fln8LV7j8GRZeo3+U4C3bG81LpRBsG3AoCCEkJb0pi1txsf1dJFzWV/8DyWiToL0nwS8YdOy9Lek879l + GgyEENI/72xelr5RTxs5k6PFvy9bW9PX6z8LuJt6aIZ0+jJJpv8gIISQQZLe6k+N0VNI1qlP+2/2p/db + vI6sZKuf7YDwAPWMcBnIq6wGASGEHClb/Rm/ujOonk6yIpdn/v3CdkC427blxoc2t6Q3SAxCCDnBPJqt + xwtvUIt/S+Y1i7+Z9WxtZDsgXGpbU+JT0slfMnd6QiQHdd7e3JLZdyjpt/p9v1di9XPEu3luY5NxkZ5e + hoWeo/ab/k7OsmUp2wHhQlv86Ws3taT/atXpiWsS3OxP/3aTP71WFvB2ae9q+V7plpbULzf5M/++pTn9 + jU0tyc9tbzXOV3d6PJHtXZ2dxqnqZzc0GRdsWZa8YmNL+publ2b+Y5M/9astLelpm5ema+TsrUP+9kPy + t/dKYvq1EXfmza3LUl/R3WNI8r34q0gfZjsg3GWLP/Nf0rkT5s5OHBh/6n9lkX1YFvhGmaxKNi3N3Ly5 + OXXVjkbjPN3cttN3wOFPXS0HBj/ZtDQ9dcvSTLOUYb2U5+0B5SNOTHRTS+bHurlPiB0Wf52w+oyUflmA + c+lP+s/c3JLqlUjnJg5KaFNLapssnC3y32PV2fuGDuMc3bSusXWp8VG1vWzT0lSRlLNdsksSk1jVCbFv + 1FtEpbpZj8vfF3/L35vzbGpJ36BfGuBM6lO6soB0SKRDE5unR/K8LILNm1qSP9vqT1ymDt50U3qOepth + oz/5eamT0Zv8qVXy9RVdT8Tm2bw0VXM8fXeDLP6y4O63+l35iiqDfnmA86g7Wm1sSd9n1bmJLRKRM40n + Ny1NzpEzn++t9xtn66bDIB5vNc7f5E/+u5qcpf62SdL96pPYKNK3l6uDON10g7Lj4q/DdkA4k3qUp5xF + PmrRqUl+s29jS8q/uSUxgluODt26Vcb7VF2qOpW6fd1U1yTvSa/Z0GGcoZtrALXVT/7dawN/zh7Z2hhn + OyCcRZ1JbmpObd60VDoxyXdCG5em79vcnCrY2BQb1q1SGGhLY/IKqe9iqff1kkS/diD5SktynTpQ0030 + N31n/kvlzN/qZ2ySjWwHhJNs8Bsflk67R6I6L8lPDmxsTi3f2JT+jh2eoOZV6kD4qaWpn29sTj8gbZIw + tRHJbbapbaO6afoWfzlQ22/x72wWtgPCIdSebOm0zw/sxCQHCcgZw6qnWhIj2D5kP+otMdU2m1rSndJW + HAzkJ3u3NEQ/ri77y3+/Zvr/7JnmFE8HhP1tbI1fIp31VctOTLKVmOT2jc2Jf2OScI4NdcY5Mlb+R9pu + o6RXtyXJTV52xpn/38N2QNja5mWJz8igesOq85Ks5Ldytj9eLSS6CeBQfWOnJVm5cWnyzxbtTIgK2wFh + T1v88YulgzrjcpqzE1eXjzc05/5Z6Mg+tV1Nta1+iyBtanvi7bAdEPazoTV24VPNqVefkk5Kshb1mYpR + 2XriGezniaWxf3hqaXKetP1fTX2BeDRPsB0QdqJunSqL/4sSgwx/NjantjzVlBjh5TvxeV3fjbSaUrdI + f9hr7h/EW1EnAbpbAPmltvpJp/yduZOSISf1VHO686mm4XmqGdzB8BmnqLcHnmpOdkkf6TX1GeKBsB0Q + tqD20kqHfNbcQcmQ0r2hOVmpLv3qagYsbWpMfVkOEldLn+FAwFvh6YDIL/U+tHTEHaaOSU48EbXw979B + CXAsNixNXtl3tYgDAc9k49L09br5gdzq8htnbWhObZYYZGiRwRx9sjm5UL2VoqsXOCEbl6b+SQ4E1kq/ + 6jX3M+KyNLEdEHmgtijpSca6Y5JjTXzD0tRidcdEXbXAsHiyOXXVhuZkl0WfIy6JnDiwHRC5J52v0dwZ + ybFHBm6PfG3dUB+7UFcpkBVPNaWvk772TP/+R9wTtgMip55sSk+16ojkmLNdco2uTiDrfD7jlKeakyPl + wPN1U18kTg/bAZErT8gk8mRTqkdikONNer98vYV9/MiXQ5/bSZdKPwy/u28S54btgMiBx5vT35AOFx/Y + AclREtnQlC7fVmucqasSyKuNTbGLnmhO3WXRV4nzEu5kOyCyaUND8rNPNqYOWHQ+coTIwt/5WEP047oa + AVt5siH9Xemnr5r7LXFYGnk6ILJkU73xEelkLw/odOQISb75ZEPy5kM1CNiXujL1RFPSJwf4Seu+TOye + DU3Jat2cwPDZ0GGcsaEptdOq0xHL9Epa1vuNs3UVAo7wZH3qi3IQsMPUn4kT0sh2QGSBdKwVT0gHI8eU + l55oTH9TVx3gOOr+HjLmJ0pfjpj6NrF72A6I4SSdavyATkasknmiKblAXS3RVQc42mMtiU8/3pR62qKv + E5tG2ovtgBgeTzSl/+WJxlTSqqORfmlMvc5ZP9xog8847YnmdCnzgDPyONsBMRw2+Y2PyaL2Jxn4aoEj + g6Up3clDe+B2cmb5FenvfxjQ/4ndEnm43jhdNxtw/Hb7jfdIR9pi6ljk3Qk+2Zgq0FUGuF7fToHGZKX0 + /R7TWCB2SgNPB8QQPN6YapUYxDoyyLasa4hfoqsL8JT1jckfyjjoNo8LYpvwdECcGPUhEosORQ6l9/Gm + ZJX6lLSuLsCTnqhPXCZzxTMWY4TkP2wHxPF7oj71Vek8SVNnIocSWs9NfYC/UTteZFxwtdCGYTsgjsuG + JuP90nFeMnck0peXnmxMXqGrCkA/TzSmfi5jJGoaMySfYTsgjsf6htTK9dJxiCkN6dVb2owP6GoCYOHx + 5uQXZLy8PGD8kDyF7YA4Rusbkv8lBwCy2JF+yTzWmC7lsb3AsXm80Tjv8YbURouxRHKfcKePpwPiKNSn + 2aWzBEydx+uJrKtPjNBVBOAYqUXn8cZUh8WYIjnOOrYD4kjUXb7k7H+bRDoM0Xlz3ZLUVbqKAJyAxxoS + hTKWekxji+Q2PB0Qg5MOUmHqMJ7OYw3JF/j0LDA81tcnfyTjKmoeZyRnYTsgrD1Wn/6WLHgZiVr4PJ91 + Dan1PL4XGF7qatq6huSfrcYcyX44ocEADzYb50rn+D9zZ/Fq1jcm29Ttj3X1ABhG6qZBMs5eNY87koPU + sx0QJo81JjssO4sXU5+s1NUCIEs2NEUukPH23IDxR7KadfVJtgPi79Y1xK+XjtFr7iieDIs/kDN9Vx4b + k1stxyLJVng6IA5ZV228TzrEPln41OLn5fQ+tiQxWVcLgBzpm4Pqk4+axiPJYtRJn65+eNlj9amGdapD + eDs965bwGF8gX9QZqSxMD1qMTZKFyLzP0wG97pHG9NekM/SYO4fHkpHB8AtdJQDy4JG6+CdlLL5mGpsk + S5GDLbYDepl6apd0hD+YO4bHkpb8WFcJgDx4tCnxKRmH+/uNS5KDPMR2QO96dEmyyqpTeCi96xpSv9TV + ASAPWPzzF7YDetRjdakvPVqfTEkMj6b30YbUaF0dAPJALf4yFvebxibJXdgO6DWdncap0vB7TB3BU1nX + kCjS1QEgD1j8bRGeDug16szXoiN4Jo/UJ2foqgCQByz+9gnbAT1E3XTj0SWJvzy6RBrfg3lkSapWVwWA + PHi0Vhb/JbL4W4xPkvs8soSnA3qGLID1Vp3AI2nX1QAgD1j8bRm2A3rBw/XJz8nRXkqijvq8lfrUBt7r + AvJHLf4yFvcPGJsk72E7oAdIQ68zN7xHsvf+OuMcXQ0AcozF3+ZhO6C7ydn/jy0b3v15k6NbIH9Y/B0R + tgO6VWetcaY08GumBvdCog8tTl2tqwFAjrH4OyY8HdCt5Ox/lkWDuz2ZdYsTN+kqAJBjLP5OS/wG3XRw + i7WLI+c/vFiO7hYnDY+lVFcBgBxTi7+Mwf2mMUlsHZ4O6DoP16XqrRvbvXmkLrnGMIyTdRUAyKGuJYlP + yzh8wzwuie3DdkA36VoSv1gaNWFqZHdnSfKl9ZXG2boKAOQQi7+zwwemXUQWwzarRnZxwo/WJq/QxQeQ + Qyz+zs8ji9kO6AoPLUp8Rho0bW5gF6f3kcXJkbr4AHKIxd8dUW+f6iaFkz1Ul7z7IWlQr0Q6b6UuOoAc + Uou/jME3zGOSODJsB3S6h+pSX5KG7DU1rIuT2LLBZ5ymiw8gR9Sn/WUM7h84JolTw3ZAh3twcfIhq4Z1 + Y6SsYTUJ6aIDyBHO/N2Zh+t4OqBjPVyX/vpDddKQHokcAPxMFx1AjvQt/nWy+FuMSeLw1LId0LEerEs9 + 9qA0okdypy42gBxZW5v4lIy9/aaxSFyUh2rYDug4XYtSX5TG6zU3pkuz/8Fm41xddAA5oM78Zey9YRqL + xGV5iO2AzvPg4uRdVo3pwmQerE1/QxcbQA48WJe4VMYei783wnZAJ3mgIX6JNFra1IiuTNfi5AJdbAA5 + 8HC98UEZey+YxyJxbcKdPuO9uvlhdw/WphosGtGNeWmDzzhDFxtADsi4qzaNQ+LyPFwXv143P+ysqyb0 + 4a66RFRiuDy9Dy2Of1MXG0AOqM/adC1OxC3GI3FzFid4OqATdNUlb+2qlQZzf5bqIgPIEZlf/ttiLBKX + 58HaBNsB7a7Lb5wljfWOufFcmDfvrzPO0cUGkCNyNrjIYjwSD4TtgDYng3OcVcO5LQ/UJn+oiwwgh2Ts + 3WY1Jon788CiBNsB7crnM06RRtpnbjTXpS7RqYsMIMceqE34LcclcX0erE2wHdCuHqhLfF8Gp5wduzrh + rtrYP+giA8ixrkWJyRbjkngjbAe0K2mcNabGcl8WJct1cQHkwQO1ySssxybxRLoW8XRA23m4PnahNE7a + 3Fguy2udtcaZusgA8kTG4uOmsUk8kq5atgPaztpFcZ9VY7kpaxclR+riAsgjfRUgYR6jxBNhO6CdbPAZ + p61dlHhDIouka7NRFxeADaxZlPyJjMuMaZwSD4TtgDaitsRZNZKL0rN2UeqfdHEB2MTa2sT3ZHy+bRqv + xOVZw3ZA+5AGecTcQG7KA4sSrbqoAGyms9I4e82iZLkcDPzRavwSV4btgHbwQHX8EmkMOUO2bCQ3JL66 + KnahLi4AG1OPCH6gJlEg47ZLjd1+45i4K5GH643TdbMjXx6ojS+waBz3pDaxWBcVgIOoHTtr6hI3rlmU + qHxgUeJFy/FNHBs5+eTpgPmk7vwng+tPEvWejBsTfWhh5AJdXAAOtnZx4vI1NYkiGdfrJPF+45w4MGtr + 2A6YV+oIzKph3BI5yqzSRQXgIv2vDkhe7D/uiWPCdsB8kgZoNTWImxK+rzr8UV1UAC62ui5x6f36swMy + 9rk64JCsZjtgfqj7Ma+pSf51TY00hAtzf018ri4qAA/puzpQra8OVCdetJofiE3CdsD8kIExwrJB3JFu + nvUPQFlb1e+zAzWJeL95guQ597MdMD/W1MTvul81gAsjZVugiwkAf3P46sB9ixKV91cnXrSaP0hOw3bA + XOvyGWdJxYdNDeGWpNj3D+BYHP7sgKRLzkjj/eYRkqPcx3bA3Lq/JvlTq4ZwR5IrdDEB4JhxdSA/ua86 + Ua2bALkglf6AuRFck4WpL+liAsAJ4+pAzsJ2wFx5cIFx7n01iaTEcGEe08UEgGGj3ja9b1HiJlmsmlbX + JF61mHvIEMJ2wBy5vzr+s/uqpdJdmPsXJr6jiwkAWXP46oAsXl0y98TNcxE5vqyuZjtgTty3MH6nVQM4 + PgsTzxuGcbIuJgDkRN/VgYWJm+6vTjTJQvaq5fxEjha2A2ZbZ6dx6n3V8QMWle/4cAQJwA64OnD8kfmb + 7YDZtrom/k2rynd6dOf5oC4mANiC2lkg89ONMk9VSl7sP28Rc9gOmFWraxJV0hnVgum2LNdFBADbUlcH + ZB4uuLcm0SXzVtw0j3k697IdMLvkKGuvVcU7PfdWx67WRQQARzh8dUBSKXnx8Hzm1aj1SVcNhpvaZmFV + 6U7PvQsTz+siAoBjcXVAwnbA7Li3OjHessIdHlUuXUQAcAUPXx3gw9zZsHph4hGJ4bLE1I2NdBEBwJVW + L0hcKvNdwb0LE13yNd5vDnRVpHxsBxxuap+qVGxcoirYRYnfoYsIAJ6g5vN7FiZukrPlJpkH9w2cFx2c + 6kS402e8VxcVw0E6y3csK9vpqU6M0EUEAE/qf3VA4vgTPbYDDrPVVfE5VhXt8HRz4wgA+Ds3XB2Q11+l + i4PhsHph/Kl7F8alcl2U6jiP/QWAI+isSly+ujo2SebMdZL4u+ZQ+2aDfvkYKnWWfM/CeEwiR1buiRwp + /kAXEQBwFIevDtxTHWuSOXSfeU61UX6vXzKGqrMyfq1FBTs8iYN8UAQATpz67EDnwkTBPQtjXTKvxgfO + s/lJ58L4Tv0SMVT3VMWnSQw35d6qOLf+BYBh8rerA1WxJplj95nn3Nwm0alfFoZKKvThgRXs8PDcfwDI + GvXZATkYmHRPZXydzLnxAXNwFnPvwvj/p18GhkI9/lcaMGhVyQ5OiMv/AJAbOb468JfOSuNs/acxFL9Z + GP1yp1Squ5K4XxcPAJBjh68OdFbG18mcHB84Rw8hlYkx+s9gqDoXJgotK9nJWZgo0MUDAOTR4asDd1fF + mmR+3jdgvj6O3F0ZX6l/LYbD3VXxu6wq2tGpjF+siwcAsJETvDrQe/fCRJV6y1r/GgwHqdg/mCra6XlB + Fw0AYGPHcHVADhAS93cuiF6lfwTDZVW18T6p4B5ThTs60pmqdfEAAA5y16LYRbLg/+s9lckfdlbFvqrW + KP1/YbjdVRn7l7sr+95XcU+q4tfp4gEAACvq05SWi6hzE2H7HwAARyEL5jLTAur0PKGLBgAABtNZGd9l + sYg6Nwvic3TRAACAlQ0+47TfVMbjEsMtubsy8V1dPAAAYOU385JXWi2iDk4Pt4cEAOAo7qqK/9xiEXVw + Ys/pogEAgMH8piqx0HohdWyaddEAAMBgflOZuP83C2ThdEnuqoz/ly4aAAAYjCyaz9+lFk6X5DcLE5fp + ogEAACuGYZwsi2bEvIg6NXcuiIdUmXTxAACAldvmRT9mtZA6OFt10QAAwGDurIxfa7GIOjlLddEAAMBg + ZMH8hWkBdXTuXJAYq4sGAAAGc8f8+Nw7+xZOl6Qyfq0uGgAAGMyd8+N3SgyXpLfD132OLhoAABiMLJo7 + TIuok/OaLhYAADgSWTT/alpEHZs7FsQf1sUCAACD6fIZZ1ktpE7NHfNjjbpoAABgMKvmxi+5o2/hdEti + JbpoAABgMHfNj11tvZA6M3cuiN2siwYAAAZzZ0VihNVC6tgsiF6liwYAAAZz54L4rywXUoem0xf8kC4a + AAAYzG3z49Nvnxc3XJKQLhYAADiS2+fH6m6fF5PF0wWpiD2niwUAAI5EFs47BiykDs1t82IP6GIBAIAj + kYXzcfNC6txE23SxAADAkdw+P/689WLqwFTEqnSxAADAkdxWEfvzbbJ4uiSlulgAAOBIZNGMmhZRx2bV + /PgvdbEAwLNWzQtfKSd3N9/uMz6ovwUMJAtnj3khdWpWVkR/qIsFAJ61an70B3pezEh23zYv6lM3STMM + 42T9T+B19fXG6XKUaLglqyri1+qiAYBnqbnQao6UvHV7RWzVqorYSK4OeFyHr/sciw7i2Nw5P/lZXTQA + 8Kzb50Q+bzVHmpK+bW5sy23zYqV3zOEW6p5z27zox+RIUM6c3ZE750XO10UDAM9aVRm/2GqOPEr2raqI + ++XryE6f8X79q+BWdyxIXGrqAI5OW5XxAV00APAsdXXXao48jsRWVUTXq6sDt81NXK5/LdxkxZzwFRYN + 79iozzToogGAZ/l8xikyJ/aa58gTT/yFlRWx6pXz4tf5/cZ79J+Bk8kR3j9bN7YzwydcAeAQmRNT5jly + mBKRdN02L1rQXhG7SP85OM2Kivg35ajOcEmSulgA4HkyJ0ZNc2RWsqIiunfl3FjlyrmJG7k64CCrZke+ + Kw1nuCRhXSwA8LxVc+MBi3ky2zkg6VwxJ1rQ5ot+XL8U2JEcvX1VGuvVfo3n5BzQxQIAz5M58S+mOTLX + 6ZHsllSq+xKozyXolwY7afclLlVHbNJQXZKExKox7Z43dXEAwPPUnGiaI/MddUDSuWJO/JY7FgTO1S8T + duL3GWep93JWzYktkcb6v36NZ/f8ry4CAHiemhNNc6SdkpHsXjk36pOTT25RbFfq6oA0VOGKudH1K+bG + UhLDlqmIvaZfMgB4nsyLrw+YJ+2bt2WdWdVRERvprzx4ti4C7ETdHaqjIjpiRUXcLw32hqkB85039MsE + AM+TOfEt0xzplGQkW+SAoFRdHdDFgd2oGwn1NdKhqwPpfg2Yj7ytXxYAeJ7MiQdNc6RT86r6wLouFuxo + 5fzQeeryjb468GdTA+Yi7AIAAE3mxKhpjnRwEt/RxYLddXYap6pLN4cu4cS2SHolRpYT0n8eADxP5sSM + aY50bHjUu4O1zw9/pGN2bGSH+pDHnFi3xMhC4vrPAYCnqT33FnOkY8NnAVxC3Spy5ez4dXJUV90xJ/6C + VWOfYHrYSgIAJ53UWWucaTFHOjar5ib/URcNbtLhi1ygbgzRMTfW2TEnGrRq/GMNjwMGgEOPA7aaIx0b + X/yTumhwK5/POK2tIn5tx+xYpTT67gGd4Chp9cUu1L8KADzrtnnRj1nNkU5N67zI+bpo8Ap1E6L2OdGC + 9jmxLklcYhwpalui/lEA8KyOOZHPW82RTg1Xdz1OvafVPjdxo3SGJZL/7d85/paK2L/ofw4AntUxN/5t + yznSoVFXh3XRgENXBzpmxwrb50TXt8+OJSVG2+zo9/X/DQCe1e6L/VjNiS5JShcLGOh2n/HBttmxm5f7 + wlfqbwGAZ7XPjo6yWEgdmmhQFwsAABxJ++z4NOvF1JHhOS8AAByLNl9sUZssni7JHl0sAABwJG2+6EqL + hdShiT+siwUAAI5k+Zz4Q9aLqQMjBzO6WAAA4EjaZ8dfsFxMnZmFulgAAOBI2mZHwxJZPN2QyBRdLAAA + MJilvvBHl/uihlvS5ovcoosGAAAGs9wX+6rVQurcRL6niwYAAAbTOjv2E+uF1Jlp90W/rIsGAAAG0+qL + lFktpE4NT3kFAOAYLPNFW1r7Fk53pL7eOF0XDQAADEYOANZZLaQOzVu6WAAA4Ehk0fyTaRF1crbqYgEA + gMGsnB86z2IRdXK4CyAAAEfTNit8XeutsnC6JMt90Vm6aAAAYDDLZsUKl8nC6ZrMivy3LhoAABjMMl90 + ueVC6tC0+mLX6KIBAIDByAHATquF1Klpnxb+iC4aAACw4vMZp8gBQMRqIXVogrpoAABgMMt8ic9YLKKO + jd8XfUYXDQAADMY/K/I/frVwuiRyEHCPLhoAABiMLJp+/yxZPF2SllnR+bpoAABgMLJovmheRJ2cllmx + n+iiAQAAK81lgXNl0ewxL6JOTvOM0OW6eAAAwErLrOgIq0XUwYmoXQ26eAAAwErLrFilHASo983dkm26 + aAAAYDCyYG42LaDOzq3RJl00AABgpcNnnCGLZnzAIurg+GdGC3TxAACAlaWzIt+1WkSdnGUzo1/RxcNw + a/IZ728uj10jFf3DphmR7/h98Yv1/wUAcBA5AFi8dGbUcFEytUXGmbp4GC7+mbGrpXK7JIl+lX04+yRN + S2dEb/L7jLP0jwAAbGzpzNgfTHO507NXFw3DoXOkcaocJdZKxfaaKnqwxFtmRtc1z4xNYi8mANhTsy9x + qcX87fDE7tDFw1AZJxknL50Ru926oo85XB0AAJuRE7Wxprna8WmZEZugi4ehkqOpiVaVPIRwdQAAbEDm + Y/WWrtU87di0zIx8URcPQ1Hn6z6neWb0gMTIYrg6AAA5Vj/BOF3m34hpPnZ6DnIHwGEilfkrU+VmO3EJ + VwcAIMtaZkR/YJp/3ZAuXTwMlVTmvabKzXW4OgAAWdA8I7rCYs51dmZEpujiYaikg+yWSKXaImnJFmng + Umnoq/RLBAAcp77L/zOigX7zqyvSODN2tS4ihqppZuz3VpVsi5RH9y0t5+oAABwvmUP/bcCc6vxE/AXG + e3QRMVTNM2IbmqRiHZC4ZF1jOZ8dAICjaZwRu8M0h7oh63XxMByaZkaqmmZEpGIdlvLwvqbyaFMjVwcA + 4F3UbXJlngwNmDcdnuby6CxdRAyHxlmRG6wq2mHhswMAoDXNCP/YYp50fBpmhL+ti4jh0Okz3ts0Ixq2 + qmzHhqsDADysaWa003JudHYi6rHGuogYLo0zwmsbpYJdmrQcCGyRr1wdAOB6jdNC58l8F+83B7ojM8Nr + dBExnBrKo6Mby6WCvZFXG8vD/oby8Mh634EP6ioAAFeQOW6yac5zRZpmRH+ti4jh1FQeu8iqwj2QQ1cH + pnN1AIA7yLy21zTPuSG99b7YhbqIGG5SwW7sNMcbrg4AcKym8tC1FvOa49NUHnlGFxHZ0DgjUmNV8R4O + VwcAOErDjMhKi7nMBQnP1UVENshCd0ODVDQZNK82cHUAgE35Sw+eLfNU1DRvuSL15bFrdDGRDT6f8V45 + 0gpZVT4ZkHSDvjqwhKsDAGygcUZ4nMVc5fjUl0f+0jnSOFUXE9lSXx5eY9UA5Kh5tYH7DgDIE+Mk42SZ + h/aa5iVXRA4AVuliIpvUdkCrBiDHFa4OAMgpdfJhMRe5Io3Tw/9PFxPZ1Fge/0TDdKl0Mpx5tWF6tKlx + GlcHAGSHnHA8aTH3uCFx9dkGXUxkW/30yF6JQbKSdP306Bb5WrqkjKsDAIZOzSWmecY1WTI9eq8uJnJB + Kr3G3Agka3m1YTo7CwCcODlLvstibnFFZG68WRcTubBkeuQGq4YgWQ9XBwAcF/W27aG5w3JOcXqC6rHG + uqjIBbUdUCo+ZGoIkvtwdQDAEdVPi9RZzB2uSEN5ZIUuJnJpyfTwmiXSAMQ2iS8pj6xbPD1StHhG6HLd + TAA8rMYX+vCS6dGwxXzhjpRFvqeLilxaUh4dbdkgxC55VQ7S/Iu5OgB4lpwUVFvMDW7JOz6fcZouKnJp + UXnsoiXTpBGIE5JePC26pb6Mzw4AXtE0JXKBjP2oaS5wUaKNuqjIB2mEvQMbhTggh64OlHF1AHCrxdMi + SyzGvmvSMC30dV1U5IOcUdZYNQxxVOISPjsAuEj91NiFemxbjXk35HV1a2NdXOTDkumRG+Qo0yCuyqt1 + XB0AHG3xtHCLxdh2UcKzdVGRL2o7oDRGaGDjEJek77MDi/nsAOAYat+/jN2kaSy7KRlVRl1c5JOcLa6x + aCDiykRflsyo5L7bgG3JAftt1uPXHVlSFnlAFxX5JgvCKKtGIq7O24unR76ruwAAm6gvj10j47PXNF5d + luhNurjIN325yaKRiMuTUZ8T0N0AQJ6pD8XJuNxuGqduy+udI41TdZFhB7Vlkb11ZRGDeCuLyyLx+mnh + z+luACCP6qZFfm41Tt2V6ExdXNiFLAQ11o1FXJ9pkcd0NwCQJ02+d94v4/FPA8anu5JumBr9uC4y7EJt + B7RoLOKVTA3/o+4KAPKgrixcYTk2XZTFZeH7dHFhJ2o7YF1ZNGzVaMT9qS2LFOmuACDH6srin1Rvx1mN + TTdlcSkfPLat2rLwGlkI1GJAPJa6aeEW3Q0A5JiMwS7zmHRfoi/LieYpusiwm0Wl0VHWDUc8kNt0NwCQ + Q7Wl4f+0GI+uy6LS8BhdZNiRejqgVcMRT2Sh7gYAcqS2KPghGXtvmcaiG/N2bZFxpi427Eoaaq+p4YgH + UlcW+anuAgByRMZdh9V4dF1KozN0kWFntVMjNbWlqsGIhxLj1sBAbsnif6OMvV7TWHRhomF1pUMXG3a2 + aGrkhkWlYfV+DfFKyiLzdfMDyAG/zzhLxt4rA8aiC1NbGqrVxYbdqe2A0mhhcyMSl2Zq+HfqBiS6+QHk + wKLS0CLL8ei+pJaUxi/WxYYTSKOtMTUicWfeqC4JXKKbHUAOVJeFr5ex12Mai65MbVlolS42nKK2LDza + qjGJe1JbGt5fWxb8lG5yADlQN6n7HBl/r5vHo0vTWz09fKUuOpyipjj+CYvGJC4Jiz+QHzL+7jWPR7em + tjTyoC42nKamNLxXYhDXhcUfyIOastCvLMaja1M9LXi1LjqcpmZqqKZmqjQkcVNY/IE8WDglcJmMv5Bp + PLo2i0p56I+jqe2AVg1LHBsWfyAP/AXGe2qmhHZajEm3pqe6hPf+HU1tB5SG9MwRq8vD4g/kSU1puN5i + TLo4fPLfFRZODa+tlgYljg6LP5AnNVMiP7UYk25OSr3doYsPJ5OjudEWDUycExZ/IE9qSyOfr54aiViM + S9dGThqX6uLD6RZNjl1k1cjEEWHxB/JE7feXMfiyaUy6PfGqqbELdRXADapLw3stGprYOyz+QJ74fMYp + cub/oMW4dHUWTg3V6CqAW6hGtWpsYtuw+AN5JGPwVtOY9EJCNcWhD+sqgFtUTY3csHCKHN0RJ2T/AhZ/ + IG9kDN4s6ek3Jj2SUJmuAriJ2g4oDRwa2ODEZmHxB/Koamr0n2UcRk3j0gt5pX6CcbquBriNNPBaU4MT + e4XFH8gj9VRNGYdvmcalRxK6SVcD3Khqani0dcMTG4TFH8ij2qLgh2Qc/sE0Lr2Sx3Q1wK3UdkCLhif5 + D4s/kEf6LdInTOPSK0lWTQ1drqsCblY5Jby3Shqd2CYs/kAeGScZJ8sieIfF2PREFk4JVeuqgNtVTQnV + WHUCkpew+AN5phZAi7HplbxVWXrwbF0VcLuqyZEbqkqk4Um+s39BEYs/kE8yDitM49JbKY78j64KeIF6 + r0saPjygI5BchsUfyLOqklCpxdj0TqaEn1Zvf+jqgFdIw6+17BAkF2HxB/Ksckp4nMXY9FLSCyZH/0lX + B7xkQXF4dKV0ApLzsPgDeVY5JXKLjMUe09j0VBaUhH26OuA1NcXxT1h1CpLVsPgDeSbj8D8lmX7j0nsp + Dr/AHf88TjrC3gEdg2QrLP5AnlUVR/5bxmLaNDa9lp7KyaF/0VUCr1LbAS06B8lKIg9yxA3kj3rPX8Zi + 78Cx6bFMCdXqKoGXzZscuWGBdAiSm1QWh5+smvqXD+jqB5AjC0pCpVZj0nMpjrzmG/vO+3W1wMvUdsAF + xeGQRDoGyU1CO3nWNpA7fYu/5Vj0XHqriiP/qqsFkMExObzGoqOQ7OZ3VVOjH9dNACAL1P52GWuLTWPP + s6mcHF6mqwY4RDrFKKvOQrKbyuLIqwunBC7TzQBgGKnP28yfHL7Daux5M6H/5Xa/GKCiOP4J6w5DcpA/ + LyiOXqWbAsAwUI/0lbG10TTWvJx0ZXHoWl09wLvNLw7vlRgkL4kvKI78VDcFgCGYWxK4RMbU701jzNNZ + MDl8q64eYKAFxaEaq45DcpbeedyVCxiS+SXBq2UsvW0aW57OvOLw5s6Rxqm6ioCB1HbA+cUh6TAkvwne + 5fMZZ+hmAXCMFpSE/mP+5HDUelx5Nt0LJnV/UlcRYE1tB5TOEjZ1HpKPlISemj8tdJ5uGgBHIHPXKeoS + t4ydngFjyeORehmpqwk4snmTQ2vmT5aOQ+yQl+eVRL6gmwaABd+k7nNkrHSZxg6RyHzeqqsJOLqKovBo + 6TSq4xB7JD6vOPQr3TwA+pEz3M/KGPm9acyQQ3mZO47iuFQUd3/CoiOR/KeVzwUAfzevKPhf8yaHoxZj + hciJA8/4xwmRzrPX1JmILRLes6AocKluJsCT/AXGe+ZPDi+xHiNE5xe6uoDjM684VGPRoYg90j1/cujf + dFMBnjJ3SvDTMgZ2msYEeVeCjbq6gOOntgNWSEcitk1vRVHIX13y1vt0kwGuJwvbLdL3w6axQPplbnFo + m9rNpasMOH6qA0lnCpk7F7Fd9s2fFPq6bjbAldS96ysmh++06P/k3fmzj4eLYTjMmxRaK2eZBrF90nOL + QpXqfVHddIBrzJscvm5eUWi/Rb8n706qgvv8Y7jMnRweZdHJiH3z9NyJwU/r5gMczVfw5lkVk0KLpF/3 + mPo5sci8onCBrjpg6NR2QKuORmydSMXk4ETu+Q0nm1sUuVH68j5T3yaDhZv9IBvmFIX2zpUORhyXHfMm + Rb6kmxFwBF9R8ENy1t8h/bfX1J/J4NlWP8E4XVchMHykc9WYOhtxTtJzisJLfGPfeb9uTsC25Ex2hPTZ + N0x9mBwhUmf7fCXhj+oqBIbX7MmRG6w6HnFOZJJ4bd6k4Pd1kwK24pvU/Unpp13mfkuOmnd8RcFP6WoE + hp/aDigdLWzqeMSRCd7tKzx4sW5aIK/UPSzmTgpWSN+MD+yr5CiJzZkU+pquSiB75k4KrbXogMSZSfa9 + LTDhwAd18wI5ZZxknFwxOTxyblH4dYv+SY6enrmTwj/S1QlklywYo+Vo0yCuyl/mFgUL2S2AXKooCvzz + 7KLQVov+SI4xatzq6gSyT20HtOqIxPmZOyn4rJxNXK+bGsgK9T7/nKLQbdLnes19kBx7ZheGanWVArmj + tgNadUjikhSGHlJnZ7q5gWHhmxC7cE5hcKn0seSAPkeON/f4fMYpumqB3JEjzxqLDkncFXV29oBvUuDL + utmBE+KbErlAfdZEDizjpj5GTiSFoSdri4wzdfUCuTV7YuSG2dIRiTcyZ1Jw/ZyJgat08wPHZP640Hmz + JwV90odC5j5FTjCFoaerpv7lA7qKgdxT2wGlM4YHdE7i5qgrAqu5IoCjUZ8T8k0K10mfYY4Y3uxST0LU + 1QzkjywGay06KPFGtswuDI9k1wD6802KfEn6xipJul9fIcOT59UVFV3VQH6p7YAWnZR4K6/MLgoWqpu4 + 6G4BD/IVhq6dUxTqsugfZHjyR/U5Cl3dQP5VjOv+xOxC6ZyEFIb+KovAvIqi2D/o7gGXU5ei5xSGx0rb + 7zX1BTK8eYVxBVuSSX+vxCBEp8c3MbhevT3gLzDeo7sJXER9GNQ3KeSXto6Y2p4Mf/bPHR+4RFc9YC/S + QWtMHZaQw/mzpNI3OfQZ3V3gUH2f5i8MFkl7vtivfUl2s3/uxOCndRMA9qO2A1p0XDtnv+Rl0/dIdtMr + 2Shnjb/wTeo+R3cd2JzaZz67MHyztF2nJKHbkuQmr6i7JeqmAOxJbQeUzhoydV67Zr96XOa8wsj5vsLg + sxb/P8l+MpItsycGC+dPCH9EdyPYRP0E4/TZRaERcrC2Stop2K/dSO7yIu/5wzFkslhj0Yntlr7FX7/k + kxaMCZwr39tq+jckt1FnlV1yMHYLe5vzRy36vonBH8g4XiHtEejXPiT32clWPzjKrMLwqFul89o471r8 + Dyspeet9t04Kr7P49yTHkYlPDgaCj/smhkpmFkU+r5sIWeIrClzqKwyPlbqXA7BQxNweJPeRA7CneCw3 + HKd8cuyiWydKJ7ZnLBf/w/rewpgY6rT4OZLPFIbeVu2irg5I+31INxdOkO8Xxhm+CZEbZbGv9E0M77as + c5K3SLs8XMS9/eFU0on3mju1DXLExf+wkSONU2WxWW7x88QGkbbJSLZLan0Twj+aPin6Md10GIQ6aJJF + 5SapvwVSb5vka7x/nRL7RNqnU52I6KYDnMc3IVRj1bnzmGNa/P/OONmGZSCDZ5/ktlkTwmN8hZEvqIM4 + 3ZCeox4J6xsX+oy6WiJ14pfslUWlV9cTsXFkzlnm5b4Ll5g1MXLDLOnQNslxLv5/N2tCqFR+vtf0+4j9 + E5+lLm0XhjpmFYaKZxUG/tU31n23TlVn9lLO62ZOCE6UBaRVyr1DEulXD8QZ6Z1ZGCrTzQo4m7qENWti + MCyRzp3PnPjif5gsHjfL74oO/N3EgfmLTLRPyGLpnzUxMG3WhOBPZ04Kfc3ObyP4Roc/6psQ/Kr0w5/M + mhAolQOalpkTg+vk9b9hUT7iuARi0rYjdXMD7iCde83Azp7LDH3xP2xmYfAr8jvfHPg3iIsSl/xeFtdH + 5OuKWycGF80sDEyXRXeUb0L3j2ZOCH/LNzF8pTpYKFPbRn9hnKG7xzHzFbx5Vt/Pjo1coH5X3+9Uv3ti + oED9LfU31d+W19AlBycvyH/L2bzlayVuSGHwbTm4u0Z3D8A91MRp2elzkuFb/A8rn3zgIvm9z1n/PeLx + dEsOqgldvu7ry6H/Vt8LyFernyHezoszuK8/3OrQgmnZ8bOc4V/8D/ONfef9MycE11r/XUIIOXrU21Dc + BhuuJ4vlXomRu8jiPzY7i/9h6lO6syaEKq3/PiGEHDEdbPODJ8yaEKixGABZSvYX//5mjg+Mlr+bHvg6 + CCFkQNIzJ4Ym6+kDcL9ZEwM3WAyELCS3i/9h8ne/IX//TwNfDyGE/C3vqLlQTxuAN6hLXdL5Q6bBMMzJ + z+J/2LQJ4Y/I61g/8HURQkhwi2989ON6ugC8RQbAWtOAGMbkd/E/rO9zARODPnlNPQNfIyHEkxkf8vN+ + PzxNvVc+QwbD8Mcei39/5RNCI+S1HRz4WgkhHkp45sTgf+ppAfCu8rEHLrIYIEOM/Rb/w8rHdX9CXuPO + ga+ZEOKB/HH6xPCVejoAMHN8cO+M8TI4hiX2XfwPU4/ynDE+0G79+gkhLs1dPMMfMJkxLlBjMVhOIPZf + /PuTA5+fyesODCwHIcRFCaixroc9gP6mjQt9rVwGylAyXRb/Mgct/oeVFh68uHxc6EmrMhFCHJ+nZ0wI + XKaHOwArMlB2mQbOMcepi/9h6hnt5eNDJVKWhLlshBBHJlU+ITCd5/cDx0BfBUiZBtFR4/TFv7/pYw5+ + oXx84HmrchJCHJOXZo4NfkUPawDHQha/Ahk8PabBNGhmjA++7pbF/7AJE4zT1WcipHzHXA+EELsk5C8p + eet9ejgDOB4zJgR+LAPpwMCBZcq40JPTCyPn6x9znekTu69TBziWZSeE2CrqSuSMcaGb9PAFcKLU7XOn + jw/OkbwskcH1tyQkj8ri/x/6n7ra1Kl/+cC0ccElUuZMvzoghNgnPdPGBxvUWNXDFsBw8RWEPjx9dPjK + stHdn1SXx/W3PaVsbPAr08cFn5UYhBCbZHzgd+VjgtfoYQoA2eHzGafJ2UahTDzhARMRISSXSU0fF6r0 + 6gkJgDyZMT5wSfm44CMWkxIhJPvZPGNs+B/1cASA3CsfG/ypTEZvmSYnQkh2cmDa+NAvTzrJOFkPQQDI + n7IxgXPVB5CmjQumJAYhZNiTltT7ioIf0sMOAOxj2rjQZ6aPC3WaJi5CyFAyNri+dHzk83qYAYB9TR8X + uEEOBp6znMwIIceal8rGB0bqYQUAzqCeKzB9bPAWmcT+bJrUCCFHzsGycYFSGUPv1cMJAJxHPXdcbVWa + NjYYl6jLmYQQ66QkDdPGhc7TwwcAnE9tGywbG+yQpCUGIeRvSZeNC64oGxO4VA8XAHAfdSfFsnEhf9+k + Zz0ZEuKV9MhY6Jw6JnS5Hh4A4H59VwQ4ECDeTG/ZmGBX6YTuL+rhAADeoy576gOBjGmSJMSNWT99XODL + uvsDAKaNCn9u6tjgb0rHBnskBiEuivTp0Oqy0d3/pLs7AMCsZHzgkqnjQpUyaXabJlFCnJZ42Zjgqmnj + Q5/V3RsAcDRq+6BMoIWlY4KvSwxCHJOxwbfKxgZ9bOcDgCEYOdI4tXRsaIRMrE8PmGgJsVdeUgetRUXG + mbr7AgCGw5Qx3d8qGxNcWzom0CORCZeQvEf1xUfLxga+wxP6ACDLpk44cOHUMYFSyWsSg5Dcp/tN+VrJ + zXsAIA/U8wZKxgRulDOwTpmMk++eoAkZ9mSkr62fMiYwUvreabobAgDySc7EzpUJukDy234TNiHDkf+T + VJYWHLxYdzcAgB2Vjj14benoYIdM2oF+kzghx5NA6Zjgyqlju6/jvX0AcJgJE4zT5WBgxNQx3avUhG6a + 4AkxJyp9pWvK2O5bfAVvnqW7EQDAydTBQMmogyNKRnevmjI6EJAYhEhiU0bLoj+q+5aSn7/1Pt1dAABu + 5PuFcUbJqO4fysR/uywAQdOCQFyektGB8NTRgbvlv28uKtrPnn0A8CL1ae7SgoPXlowKVMqisFsWhd7+ + iwVxTfZNHd29RO0aUVeDdPMDAHBIyejwR9U2L/1WwQHTIkIcEnWWry7tTx0TKJg89sBFunkBADg6dRvi + klGhr00Z0z1bFpRtkpRELS7EfklKVBtVTBkd+jr79AEAw6agwHhP8ZjAVcWjugtloemUvCOxWoxI9hOU + rC8Z3e1Tl/V5Lx8AkFNFYwKX9n2CXL2/PDqwW9KjFygyrOl+U752qoMvdRCm7gKpmwAAgPxTdySUher6 + ktHBifJ1WfHowA75Gj60iJFjSFjO6LfL12VSh+Nl4f920S+DH9LVCwCAkxgnTykIXFZc0P3vJQXBmbK4 + dZaMCvxekpIYHk1S8oe+upA6UXWj6oi77gEAPEFdMVCXtCcXBEbKglhaPCrgLx4dWC9f90nSEsPBOShR + b4t0Th4VqJT/Lij5deBG9baJ+oClrgIAANCf+iT7pNHdnywe1f3NyaMDN8sCOlq+lhcXBGtLRgVXyvcf + lO89Lfmj5IDEahEezqi/of7WNvnbXcWjgyvkdSwqLghMl+8VyPd+pF5rya8Cl/ApfAAAckR9MK7vikJB + 6MPqLLsvvz5wRd/OBYmciV+vzsCLfx38vrrioFI0Kvg99T31/x3+d8Wjwp87/PPTxoXOU7+TM3YAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AIDsOemk/x9cNB0T/DNhjgAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vAAADrwBlbxySQAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAD5YSURBVHhe7d0H + eFzVnfdxUbMQCJuENxvSEzbJm8CTtptOCgQ2xctuCg7ghi3Zsiz3KhdsxkWW5C65yoZQwhuIqaaYYoON + cUwzoRpjjAvYGklT1KUZjWzf93/kY2yurjQjacot39/zfB7ZKjP3nvu/53/uaGaURQixdwyfcWaw/OBF + NesOfSu8ruKqcPnhvjXr/Lk15RVTatYeni//XlWztuJvYkPt2opNNesqdsi/d4q9Yr+o+TB/TD4aH9b+ + OdP3VewPr614Rz7uVLfZfttyH+Jvx+9T7lttg2yL2ia1bWob1bYa640z9OYTQgghxJz6mw99QjVNaab/ + LY01v72prj18hzTep2rKD78hH6vl88eEqWHb3rH2bVf7sK5is9on+XehGNG+r7LPat/1MBBCCCHuimEY + p4X/UvH5YPnhy8Nr/cNCaytK5Gr5PmmOr4omYXhco5CxOHyvjE1xuNw/NLju0C/VmKmx08NICCGE2DfB + W97/jDSxK6XRj5UmXy6Nbbto0I0O3SRjGZWPu8Lr/OvD5RW+9l8zrK28xPAZp+shJ4QQQtIX9Tt51YhC + aw4PksZUKjaJsDCQFupRg+3HF1n+sTXl/ssO3HrgX/ThIYQQQnof9TB0cO3hr4XW+geGyitWiJdEVBiw + FTkmh1+UjyvUsQqsOfRVfQgJIYSQ+PGX+88NrTt8hVxl3hQsP7xRGkr4lCYDZwmF1/ofDa+tmBVcfeiX + h5YcOkcfZkIIIV5P1R1VH1W/tw+WV/ikYWwSXN27V5vYqZ5sGFxTcXXtrQf+VZcBIYQQt0f9/l79zlga + wGxpBjt0U7BqFnC/tmD7cwkqbgqvrfiJqg1dJoQQQtyQ6vL3L5bJfqRM9g/KlX69MICO/HXy8YHQ2or8 + qnVVX9blQwghxClR70IXXOf/D5nMfWLnyQke6I7D+2ThWKp+RWSU7zxLlxchhBA7Rf0uP7Dm8DXBNRV3 + BsorQtYTOtBjQVkQ3FG91v8n9URRXXaEEEIyETURqydzqYlZmn6jMIA0iATWVDxcvebwoJryfRfociSE + EJLKBG8Jnl+9pnJQYI3/EREVBpBBUoNqMeAfEFgZOE+XKSGEkGTEWL/r7ONX+v47ZMJtNE3AgF20PzIQ + KK/sq2pWly8hhJDuRL0DX6Dcf5lcWa0VNcIAHCRcXe5fU7264qe6pAkhhHSVYHnwoqo1/rEygb5umlAB + p9ojCwGff4X/i7rMCSGEqOxav+vswJrKa6TxPyqT5RHT5Am4xRGp8UeqV/v/ZJQbvKyQEOLdBJe//5nA + mooCmRgPmSZKwO2qqtdUFleurvySPh0IIcTdUX/LvXptxZUyAa6Xq6E2YQAedrRqtX9TZfsTB40z9GlC + CCHuSbgs/DGZ6MbLhLfPNAECOO7dytUVo9SbWunThhBCnJvqVdVfUQ91yuRWa5rsAFirl8VyaWj1oc/q + 04gQQpyTylWVv6hcXbmhcrX/qDAAdFvUv8p/c+Waym/q04oQQuwZ9dr9qjUVV/tX+/9hMZkB6KGq1f7t + 6txS55g+3QghJPNRL2mSq5RBMlHtMk9cAJKnao3/FXWu8TJCQkhGo16/L5NRvkxMh8wTFYCUes+/xp+n + zkF9OhJCSOpz4orfv9r/rjAAZMx7/lX+XMNnnKlPT0IISX7Ua/grV1X2lUnnHdMkBCCzDrQvBHgvAUJI + MqOeeFRx/Ml9r5omHQD28lb7cwRYCBBCepuKVRVXVqz2vywMAA6xxv/m4VWVfXnVACGk2zm0pvJ3MpHs + 7DCxAHCMw6v9L/rX+H+jT2tCCOk8/hX+7/lX+bdUrJIJBIBLVDx1aNWhb+nTnBBCTubQ6kOfPbzKXy6T + xZGOkwcAFzgq5/gdVaurPqVPe0KIlxO8JXj+4dX+eTIxNAsDgOuFD62qGM1LBwnxcCpWVlwtk8H7pskB + gDe8fXhVZR89HRBCvJDDaw5/+9Aq/zaLCQGA92x6b0XlJXp6IIS4MQeWHvjXQyv9pdL824QBAFpMzQ37 + ymsu0NMFIcQNUa8FPryycpCc5AHTSQ8AHzi80l/1/sqKa/XUQQhxct4vr75YTuonD62qlBMcABKwsvJR + f7n/C3oaIYQ4KTvLjbPkRC4QkQ+d2ACQmCZRoP4GiJ5WCCF2z3vLK34qK/jd76+sNACgV1ZVbT+40v8N + Pb0QQuyYQ0sOnXNoRWWxnLRHOpzEANBzMTW37C3b+xE93RBC7BJ11S8n6R7TSQsAyfTG4VVVP9LTDiEk + kwmsDJx3cGXlyvdWVh4TBgCk2JH3VvqXVS2s+qiehggh6c77y/3/Kc1/j8UJCgCptv/giuof6+mIEJKO + qNf1v7eyaux7KypbLU5KAEiXNuEz1htn6OmJEJKqvLuy4vNy1b9VGABgEzsOLq/6sp6mCCHJjqy0rzm4 + ojJscfIBQKbVHVzp76+nK0JIMvL2LcHzD6yoKrc44QDAXlZV3qHmLD19EUJ6mv1llT+Qq/69wgAAhzig + XpqspzFCSHeyxWeceWB5pU9OpLYDckIBgJOouWv/Cv+NPEGQkG5kT7n/woMr/ZusTioAcJTllVv3L6v+ + Nz29EUI6y8EV/u/JSXOgw0kEAA51cEXloQMrqn6opzlCiDn7V1YO2r+iskUYAOAy0f0r/cP0dEcIUVF/ + YGP/8qq1FicMALjNHeoPl+npjxDvZm/Z4c/JCfG86QQBANfat6Ly5QOrK7+kp0FCvJcDqyp/ISdDlfnk + AAAPCO4rq75ST4eEeCPqvfz3La8aK6vgmFCrYQDwoiOiQM2JenokxL3xl/vPlYK/Z99yKX4AgLF/eeXd + PC+AuDrq9f1y5b/d6gQAAI97gfcLIK7MvtLAV99d7n/nXSl0AEBHsgjY/85K/zf0tEmI8/Pu8oqfvltW + GbQqeADAh9TsXV75Sz19EuLcvLu86lop6IipwAEAnWvdu9w/QE+jhDgr6lmtsor1SSEfMxU2ACC+Y2oO + 1VMqIc7ILt+us6Vwb9+7vMoAAPTcuyuqb91Zbpylp1dC7JsDS2v/de+KqqetChkA0H3vlFVtVnOrnmYJ + sV/2lfq/IMW6y1y8AIBee0O9dbqebgmxT3YvrfzSO8ur9slKVa1WAQBJtqes6uC7KwP/rqddQjKfPcv9 + /1ea/2GrggUAJI8sAirfLa26VE+/hGQue8sC35WiDJiLFACQMtXvLA18R0/DhKQ/e5ZVfl9Wo2GhVqUA + gPSp3bui+sd6OiYkfXlnmf/nUoANpoIEAKRP0zv8SWGSzuxZXvlbKbwWUyECANIv+vbyqv/R0zMhqcve + sqqrVcGZChAAkDmtb5dVXqOnaUKSn91lVde/XVbVJgwAgK0c2V1WOVhP14QkL3tKqwdKgR01FRwAwD6O + vr28mj8iRJKXPUurf/92qVz5l0qBAQDs7MjbpZV/1tM3IT3PW8uqr9pdWhUVBgDAEVrfKqvso6dxQrqf + t5dX/1QKqclUWAAA+2vZvbTyl3o6JyTx7FpW9UMpoAZTQQEAnKNpT2ngMj2tExI/e8qqvy2FEzYVEgDA + eereWur/np7eCek8u1cEv/ZWaVWVMAAArhDYVVb5TT3NE9Ixb5RVXyyFUmEqHACA8x1+Z2n1V/R0T8jJ + vLG44vNSIAdNBQMAcI/9r5Ud/pye9glRb+8b/tiu0qrXhQEAcLVdryyt/Vc9/RMvZ2e5cZYUxKZdy6Qw + AACu99ayqi27fLvO1m2AeDGGYZz21tLq26wKBADgYqVVt+hWQLyYXUsrfZaFAQBwvbeWVs3Q7YB4KW+W + Vl335rKqY8IAAHjSsTdKqwfqtkC8kLeW+X8uBz5qKgQAgPe07lpadYVuD8TNeWOp/xtvLquuEXLgAQCo + Dr+2LPh13SaIG7Nnkf/CN5ZV7xUGAACn2C/+TbcL4qbsWHLoHDm4z51ysAEAOEXgxZ3l/nN12yBuiHq5 + 3+ul1fdYH3AAAE4I3KVbB3FDXl8WKHh9abUBAEACJuj2QZyc15ZWXSEHs810cAEA6EzbG0srf6nbCHFi + 1B/4kQMZMB1YAADiqX6tLMwfDnJi9pbt/cjrSwMvWhxUAAAS8bzqJbqtEKfktaWBda/JAQQAoMeWVa/W + bYU4IbJqy7U8kAAAdNeyqhzdXoid8+qSyh/IAYt2OIAAAPTEsurIG0uC/6nbDLFjXlhx+JOvLq0+IAwA + AJJFFgLv7Vzkv1C3G2KnbPEZZ8pBesp80AAASJIn1q83ztBth9glryyu9r26RA4QAAAp8tqSqum67RA7 + 5JVlld+XAxMzHygAAJKs7bXFVT/S7YdkMrtWBs57ZUn1O8IAACDllla/+3ZJ8HzdhkimIquxOywPEAAA + KfLqksDNug2RTOSfSwPXWB0YAABS7dXFVdfqdkTSGfUezf9cUh0WBgAAGVC7s9T/Bd2WSDpi+IzTX14S + eNriYAAAkD6Lq5/hpYFpzMuLq2ZYHggAANLs5aXVU3R7IqnMy4uC/yED3mo+AAAAZEhMvQ29blMkFVEv + +Xt5SfU7Ly+WFRcAAHaxqPrt1xZWfVS3K5Ls/HNx9SrLgQcAINOWVC/R7YokMy8trPylDPCxDgMOAIA9 + HH1lcfVPdNsiycjOcv+5OxcH9goDAAAbe32Xzzhbty/S28iAlpoGGAAAe1oSuFG3L9Kb/HNp9Y9lQI90 + GGAAAOwp+s9F4W/qNkZ6kr1lez8iA7nbNLAAANjds+pN63Q7I93NS4uDN70kAwkAgNPsXFw9Qrcz0p08 + vyDwVRnAiHlAAQBwiPrnS8Kf022NJJqXFgU3v7RIBhAAAOd6RLc1kkheWBS44UUZOAAAHG9h4M+6vZGu + 8mxR3cdlsAKWgwgAgPNU7SyuuUC3OdJZZKBWmAYOAABnWxxYqtscscpLC6sufWFRoE0YAAC4SNvzC6u/ + pdsdOTWGYZz2wsLAVotBAwDA+RYHtqlep9seOZEXF1cPsBwwAABcgicEmrK9JHi+DIzfPFAAALjM+zt9 + /nN1+yPPLQoUPi8DAwCA+wVn6fbn7exYEvrs8wsDzcIAAMADGncuDV6k26B38/zC4F8tBgcAANd6bmHg + Zt0GvZkdiwPflUE4KtRgAADgFUefWxD8nm6H3ovs/GaLQQEAwP0WBZ7W7dBbeX5B4HeWAwIAgEfsWBD4 + jW6L3slzi6pfsBoMAAA85FXDZ5yuW6P7s2Nh9R92yI4DAOB5CwJ9dXt0d9TbIKoVj+UgAADgMf9YGNiz + xWecqduke/PcgsC1VgMAAICH5eg26c6sX2+c8Y8FgbeEAQAAPvD+xrK9H9Ht0n3ZsaB6kMVOAwCAkup8 + 3S7dlfar/5Lgnn8sCMqOAgAAE3c+CrB9QXCoxc4CAABte0kwT7dNd2RnuXGWLAD2CwMAAHTKXY8CPLsg + NNJiJwEAgNnC4HDdPp2dXT7jbNmh9zvsIAAAsBA64Ir3BXh2QSD7WdkhAACQmG0LQwN0G3Vm1Lv+yY7s + Mu8YAADo3PYFoddVD9Xt1Hl5dmHoD8+WyM4AAIBu2VYc7KPbqfOyrSSwY5vaCQAA0C2yCNim26mzsm1B + 8BdWOwQAABLzTHH1T3RbdU5kwzeYdwQAAHRDcehe3VadkS1FgX+XDT/aYUcAAEB3HHm2qPorur3aP8+U + hEqfkQ0HUuyQeGZrSeieZ4oDt8uJsnZbSWi9fO5R8ZaICqufAxIVfaY4uEs+PqpqS9WYqrX2misJbpOv + HT7le4GUkLpbrNurvbOpuOYC2eAG8w4AvbYg+OK24uBsmYh/tcUXOE+XXKdRf4Bqe3H4Epms8/WE3dzh + NoEPaxJ/lwk3b9ui8DcNn3G6LqdOo2pxy8LQlVtLgnOkRneabg9IhrrtJcHzdcnZN9sWBMdbbDzQU8Hj + E2vgq7rEehw1UW8rDg2Qq7bnLe4HnhZ4Tj72f2Jh1Ud1ufQ4z84Pfu2ZktA8uc1Qx/sBemZrSWCMLjF7 + Rq2WZbLeJ2RjgV6Rxh8Yk4wJ2SpbioK/lPvYZrpPeIxMrFufKQ78XJdFUqNqd0tJcJzUccjqvoFuejeR + R6QylmfmB363tVg2FOi5o1uLAit3LKn/hC6rlEW9y5Y0gP5yn37TNsD9KrYWBa9PxzutbZ7f8Emps9Vy + n8dM2wB0y9PF1b/WZWW/yAn1sNVGAwmq3lIU+I0up7RlyyL/hdSulwSe3FxY/W/68KctzxSFrpD7Z7GJ + 3nhAl5O98tSi2i/Kxh0xbSyQEPV7+UxMyidy/NGAwAzZFq7S3OvY1pLQtEy+v/qWBYFPy3a8YNouIFFt + W0rCn9PlZJ9sLQ4VbpENBHpgk12e4fp0cWiQbE/MtH1wviNbioJD9WHOaNRzA7aWBB+12EYgvqKgT5eS + PbLeZ5wtG1bZYUOB+DbuLDfO0qVki2wtCv1BtotFgHvE1DHVh9cWUTUv27XRtJ1AXFuLgxVbfMaZupQy + ny0lgWusNhSI4/lUPcu/t2ER4Bq2a/4n0v4qATkHTNsLxFcS+r0uo8xHNmjj07JRQDdUZvJ3/onkKWkc + sp0x03bDOWLqGOrDacuo5wTIdlaZthvokvTch3QJZTZPzQt9VjboiHkDgS4c3VwSvkqXkK0j29pHRE/Z + djiD7Zv/iWwuCV4u28sciu5o21YYvEiXUObydElomsXGAZ0rCqzU5eOI8EiA4zim+Z+IbPMq0z4AXSsK + Ttblk7k8XRTaLWRjgATMD4XVG6Po8nFM5ITrI9sf7bA/sBvHNX+VZ4vqPi4TetBif4DOvK3LJzPZVFxz + mZxsBpAoWQDY+/2su4hs/x+EajCW+4aMc2TzP5HNxeGxpv0BurSlJPwjXT7pz1PF4bVWGwVYCwYf9vnP + 1eXjyMh+sAiwJ0c3fxX1qgDZh9Ap+wR0bX5olS6f9Ea99l82oKbDBgGd2FwUnKPLx9GRfWERYC+Ob/4n + IhP6XNO+AV0IBjPyPiqb54d+v1k2AEjUk0n4k752yabiYB/Zp6h5H5F2rmn+Kk8tqL7YYh+BTqm5SJdP + +vLU/ODfrTYG6MSLunRcE9V4ZL9ipv1E+riq+Z+IXFy9ZLGvgKWn5of+ny6d9ES9b7vccbN5Q4DObLLb + +1cnKTwSkDGubP4q6ldlFvsLdKZ5iy9wni6f1EdWqDdYbATQKZmsr9Dl47qwCEg71zZ/Fdm/K037C3RJ + 5qB+unxSn01F4Uc2qTsFEnMsrSvUDORJaUiynzHTfiP5Ymqs9bC7MuoRVtnPY6b9BrqyQZdParOpuOaC + TfNDrcIAEnRYl4+rs6kw2Ef2NWradySP65v/ici++k37DnQlutEX/pgun9Rlc1Gwv8WdA13ZqsvH9Wl/ + JEAalWn/0Xueaf4qmwvDz1iMAdCpzUXha3X5pC5yRw88KXcGJOqJwtC9unw8EfVIgOx31DwO6DFPNX+V + JwtD91uMA9CV9bp8UhP1Lm5yJ82mOwXiuU2XkGfCIiBpPNf8VWS/7zCNAxBPs3o3SV1Cyc8T88PXWNwp + 0KVNRaFbdAl5Kqpxyf7HzOOBhHmy+avIvv/FNBZAfKk8X56YH7pTGED3BO/WJeS5PF4Y7CNjEO04JojD + s81fRfZ/vWk8gESk5tHW9euNM+TGQ6Y7A+IrCm7UZeTJqEYm4xDrMC7ojKebv4osmh+zGBcgnoDq1bqM + kpcnigM/t7gzIL7C0Fu6jDwbHglImOebv8oTRaG3LcYGiOux+eEf6zJKXp4oCi+wujMgAdGUrEodFhYB + cdH8JfrR1lbT2AAJeXx+qFCXUvLyuFzFCQPokTnhS3QpeTqPzQv9QcYj1mF8EFNjo4fJ03misOZSi/EB + EhR8TZdScrK5qPor1ncEJEZWpiN0OXk+6pEAGZOoeYw8jOZ/SmQ8RprGB+iWx4pqv6TLqfeRG6Qg0SuP + FYbu0eVEJDwS8AGavykyJveaxgjolicKg7m6nHofmbw3CDWJAz2V3j9Z6YCoRwJkXKKmcfISmr8pG0qC + 58u4tJjGCeiu5Fxw7Sw3zpIbqzfdONATA3RZER3VAGVcYqZx8gKav0Uenx8aaDFWQHfVJOWJ14/Nq7nM + 4saBnnhRlxU5JR58JIDm30lkbJ4zjRXQI4/OD/1Ql1XP8/i84GyrGwd6YuP84C90aZFT4qFFAM2/k0gN + XG4xXkDPzA/dqEur59lYGNohDCA5gs8ahnGaLi9ySlRjlDGKdRwz16D5dxJ1Tqhzw2LMgB55tDC8TZdX + z6KekLKxMNwm5AaBJJlX01+XGDHl+CIgLIsAi3FzNpp/F3mssGaAxZgBvdGq/oKvLrHu57HC8K83zpMb + ApLLv3F+4//RZUZMaV8EzJNFgPXYORHNv4uoc0HGqNI0ZkCvPVYY+pUus+7n0bk18x+VGwFSYCO/Cug8 + jxTW9Hl0XihqMW5OE3uY5t9p1Dkgx/khi3EDek0WAbN1qXU/j84Nb7e6USAZHikMzdClRiyiGqeMU8w8 + bg5C848Taf43WowbkBxzQ1t1qXUv65ccOkduoLXDDQLJc+yRueEcXXLEIg5+JIDmHydybAfIOB0zjRuQ + TJEtvgP/oksu8WycG7rC4saAZGujUXQdBz4SQPOPE31M20zjBiTdI/NrfqbLLvE8Mi88SxhAGtAw4kSN + jxon07jZEccyThx0LOEKoem69BKP/OBjHW8ISBkaR5yoXwfIyRy1GDu74BjGiQOOIdymsGaDLr/Eop6Z + Kj8Y6nBDQGrRQOLExg2EYxcnNH9kwsPzwtW6BBPLhrnBr8sPqR8E0o1GEieqkcgYRS3GLlM4ZnFiw2MG + D9k4t+5iXYrx8/Cc0KCH58oPAplBQ4mT9oYyVxqK9filE8cqTmx0rOBV3Xn31UfmhVZa3giQPjSWOLFB + Y+EYxQnNH3bw0NyaMl2S8fPQ3PBLQn4IyBwpXBpMnKjxUeNkNX6pxLGJn0wdG8DCC7osu856n3H2Q7Ji + tbgBIO1oNPGzQa4y03nOckziJ93HBIgjUl5unKXLs/M8Wlj7HYsfBjKGhhM/6Wo4HIv4ofnDjh4prLlU + l2jn2TAnnG31w0Am0XjiJ9WNh2MQPzR/2Na80EBdpp1nw7ya5RvkmwEbij1IA+oyqgFtkAZkMXa9xdjH + SQrHHug1WQQs0aXaeeQbt5t/ELARGlGcpKARMeZxQvOH3T00t2aLLlfr+HzG6fKNjeYfBGyGhhQnanzU + OJnGrScY6zhJ4lgDqVSr3uVXl23H3Oer+8qDc8IG4ACxB2fTmLrKhtk1fR6cE4pajF2iGOM4ScIYA2lz + ny/8OV26HXP/3Jr/tvohwKZoUHHSiwbF2MYJzR+OMzv8a12+HfPg3JoCyx8C7ItGFSc9aFSMaZzQ/OFI + c8PjdQl3zANzw7dZ/hBgbzSsOOlGw2Is44TmD6faMDd8sy7jjnlgdvilB+SbAAeiccXJfdK4HpDGZTF2 + JzCGcZLAGAJ2tkOX8oejnh0oX2w0fTPgJDSwOOmigTF2cULzhwvUW74S4MF54c9bfDPgNDSyOFHjo8aJ + MUs8FmMGONIGX/AzuqxP5v65dVfcP6fGAFwgdt/sWhpaF1FXszJOUcYqfk4ZK6taAxzlwTk1P9OlfTL3 + zw4Ps/pmwKFobHGixocx6jpqfFQtmWoLcK7ZtUN0eZ/Mfb6akvtnqy8CrsEigPQ47Vf+s+XK37q2AKea + p0v8ZO6fE77P4hsBp2MRQLodmj/c6oHZNXfrMj8ZKfjXhAG4EIsAknCkXvqI6Cn1A7jJTl3qJyOfbDR9 + E+AmLAJI3KgaOV4rljUEuEGdLvfjuX9+wyctvglwGxYBpNNIfXDlD0+40xf+mC77rKz1vtrv3CufBDyA + RQDpEJkU+0htRE21ArjS/b6aS3XpZ2XJJ642fwPgYiwCyAeh+cNr7pld81td/llZ98ypybf6JsDFWAQQ + mj886b45Nbn6FMjKutdXU2T1TYDLsQjwcGj+8Kp7fOG5+jTIyrrHV/NXIZ8EPCe2nkWA56KOuTr2ploA + vOJ2fSqoBUD4KYtvALyCRYCHsl6u/OWYR001AHhI7ZP6dGh/BODNjt8AeAqLAA+E5g+0e02fEuplgDVB + YQAexyLAxVHNX45x1HTMAS+qbD8ptviMM+U/R01fBLyKRYALQ/MHPuTI+vXGGVn3FQYvsvgi4GUsAlwU + mj9gYX7j/8m6a07td/8u/wHwISwCXBDV/OVYRk3HFvC8u9W7Aa6fHb7K6osAWAQ4OerYqWNoOqYAlNm1 + l6sFwLWWXwSgsAhwYLjyB7p2t6/2j1l3z6oZ/veb5BMArKlFwCwWAU7J+lm6+VsdSwDt1s8K52TdNaum + 4G75D4AuyCLgLhYBto/MZ33kWEUtjyGAD/x9Vnhi1l2+mvlWXwRgwiLA1qH5A4m766bw3Cw5YVZZfRGA + BRYBtgzNH+i25eoRgL/dJf8BkCAWAbaKOhbtx8TqWAGw9DdfzZ1Zd/tqH7rrplr5BICE+WpZBNgg6spf + jkXU8hgB6NTdN9U+kCUnz2arLwKIg0VARkPzB3qj5oks+cc/On4BQEJYBGQkNH+gl3y127L+dlPtK8IA + 0EMsAtIa1fxlzKOWxwJAYny1O7P+Nqvm7b/Nkv8A6A0WAWlIe/OfJc3f+hgASNwuWQDUvm/6JICeYRGQ + wtD8gaQ6kPX/ZtUGhAEgKWJ3sghIetSYqrE1jTWAnqtSC4Aa0ycB9A6LgCRGXfnLmEZNYwygd0JqAdBg + +iSA3mMRkITQ/IGUqVULgGbTJwEkB4uAXoTmD6RUY9Zf5QSTScoAkBIsAnqQv0rzZ24CUqpFPbmmzfRJ + AMnFIqAbofkDaRFTC4Bjpk8CSD4WAQmE5g+kzdGsv86sPSYMACnFAiCBtC8AZtZGTWMHIPnaFwBtpk8C + SC6afzfCIgBIi5haAHCiAalD8+9BWAQAKdeSdcfM2mZhAEi62O00/x5HLQJkDKOmMQWQHI1qAdBg+iSA + 3qP5JyEsAoCUqVULgBrTJwH0Ds0/iWERAKRESC0AAqZPAug5mn8KosZUja1prAH0XFXW7TNr3xcGgF6j + +acwt82q6SNjHDWNOYCeOSALgJq3Lb4AoHto/mkIiwAgOW6bWbsr6/Yba18RBoAei90+g+afrtw2XRYB + N8oiwPpYAEjMTrUA+Mdt8h8APULzz0DUIkDGPmo6FgASty3rthm1my2+ACA+mn8GwyIA6I2aJ7Jum1n7 + kPUXAXSB5m+DsAgAeuyBrNturPubkP8ASBDN30ZRx0IdE9MxAtCl2juzbp1Rt/JW+Q+AhND8bZjbptf3 + kWMTNR0rAJ2qLcu6dWZdofUXAZjQ/G0cFgFAd9TOybptRt0U6y8COAXN3wFhEQAkaEbthKy/zKzL/Yv8 + B0CnYrfQ/B2Tm2URIMcsajqGAD6kdkjWLdPr/vyXGfIfAFZo/g5M+yJghiwCrI8p4Hnt89qt0+uusvoi + AJq/k6OOnTqGpmMKQNwyvfbyrFtm1n7b6ouAx9H8XRAeCQCs3TYzfEnWrb6mT98i/wHwAZq/i6IWAXJM + o6ZjDHhaua/hwqz1fY0z5D9HzV8EPIrm78KwCAA+pM3nM05vPznkPwHTFwEvovm7OCwCgBNq/fq0kBNj + Rt0bwgA8jObvgahFgBzrqOnYA17zij4l2hcAm01fBLyE5u+hsAgA6p7Qp4OcEDfW/tXiGwAvoPl7MOqY + q2NvqgXAI+pv06dCVtba6XXz102vMwCPia2l+Xs26pEAqYGoqSYAD6ido0+DrKx10+pGWH8T4Fo0f8Ii + AJ60dlrdMH0KfHASWH4j4EI0f/JBWATAa26eWv8bXf5ZWeum13zL6psAF6L5kw5hEQAv+cu0xm/q0s/K + WjW17uNr5ZOAy9H8Sacpl0WA1EjUVDOA65T5wh/TZX888slG8zcBLkLzJ3GjaqS9VqxrCHCDWl3uJ7N2 + Rt2rFt8IuAHNnyQcHgmAm62bXveSLvWTKZ9ed68wAJeh+ZNuRy0CpHaiploCnG9a3d26zE9GVgbFlt8M + OBfNn/Q4LALgUvN0iZ9M+dS6obIyUKsDwA1ia6fS/LuKGh/GqOuo8VG1ZKotwLHWTKsdosv7ZMqn115u + 9c2AA9H846T96naaXN0yVnFzylhZ1RrgKOum1fxMl/bJrJsS/tyaafWyOgAcLbZ6agMNrYuo8VHjxJgl + HosxAxypfHrzRbqsT8bIMk6TLzaYvxlwEBpZnKirWRmnqGncGLsE0sXYAU5Rr3q9LukPZ/W0+hctfgBw + AhpYnCTQwBjDOGERAIfboUu5Y2QBcJswAIehccXJKmlcMk5R07hZYSzjpBtjCdjL9Lp1uow7ZvW0himW + PwTYFw0rTnrQsBjTOGERACdaNa1+nC7hjtFFbfmDgA3RqOKkF42KsY0TFgFwmpVT6/5Ll2/HrLux7stW + PwTYEA0qTpLQoBjjOGERAEeZ0fJZXbod4/MZp6+aWt8gDMDGaExxosZHjZNp3HqCsY6TJI41kEo1umQ7 + j3zTNtMPAXZCQ4qTVQX1fWScoqZx6w3GPE5SMOZAkjU8pcu186ycWl9q/cNAxtGI4iSFjYixjxMWAbCz + lVPrFulS7TwrpzYMlkWAfDNgK7EVNKAuoxqQjFPUNG7JxDGIkzQcA6Cn+usy7TxlBbXftvhBIJNoPHGS + xsbDsYgTFgGwoxUFjZfoEu08Pp9xpnxzxPzDQIbQcOIkAw2HYxInLAJgL3Utqrfr8uw6K6fVv2R9I0Ba + 0WjiRI2PGifTuKUDxyZOMnhsgA9ZMa3+BV2W8SPfvGKF+iEgc2gwcaKuMmWcoqZxSyeOUZzY4BgBahGw + TJdk/MgCYKDVjQBpQmOJExs1Fo5VnLAIQKbJAuB6XY7xUzq5/qsrCuQHgfSjocRJe0MpkIZiPX6ZwDGL + ExseM3jI8kl1X9alGD/q7wWXFdQHl6sfBNKHRhIncl72kXGKmsbNDjh2cWLjYwd3q9YlmHiWT6l/1OKG + gFShgcSJAxoIxzBOWAQg/eoe0OWXeGQBMNP6xoCko3HEiRofNU6mcbMjjmWcOOhYwhXqpurSSzylU2ov + l9WqAaRYWykNo8uo8ZFxipnGzc5iHNOuo49pm2ncgKQrLWi4TJdd4lky3jhHfjhqvjEgiY6VTW3I1iVH + LCJj1Ec48TxkERAnZVPq+8s4HTONG5BEdS1lo42P6JLrXuQGnu14g0BylE6pm6ZLjVjEgVf+ZiwC4kQm + 6OkW4wYkScPTutS6H/nhQusbBXpto3q1iS41YoqMj1Ov/M1YBHSR9ldcTa3fYDFuQK+VTq336VLrfsqm + 1v1XqboRILkqFk1suFCXGTFFNUwZo5hpzJyMRUAXUeeCjJHfNGZAry2fWneFLrPuZ6UvcF7plPo2YQDJ + Uja5G+9K5bGUTpLmP0UapsW4OVxM7ZveTWKKTNb9LMYM6I3Wcp//XF1iPcuyKQ3bS6c0yI0BSbGVh/6t + c7z5N0jztxw3N2AR0EnUOSHj84xpvIDe2KrLq+dZOqXeJ4sAA0iGJZMbfqZLi5ySpQX1fWR8oubxciEW + AZ2kbHLjLyzGC+iRpVMaZ+jS6nlKCxp+YnXjQHfJijTxP0npoXio+Z/AIqCTyNjsMI0V0DNT67+vy6rn + 8fmMM2XirrO8A6Ablk6p76/LiuioRihjEzOPlQewCLDIsoL6ARZjBXRXeH1f4wxdVr2L3NgDphsHuqmx + WT2pVJcUkXjwyt+MRYApCydVfVTGpck0TkC3yMXW33VJ9T5LpjTmL22/UaCHChrW63IikiXS+GRcYh3G + yXtiaiz0sBCJjMk9pjECumVZQcMwXU69z6KJtV+0uhMgUbKIzNPl5PmoK38Zk6h5jDyMRcAp4YILvXSs + bErL53Q5JSdyo2+a7gRIWNnExm/qUvJ0uPLvFIsAnSUFjZdYjA+QoPpXdCklL0smNxQJ9TIuoLuiSXtC + ioOzdFJ9HzUWprHBSSwCJD6fcbqMBXWCHlk8pX6OLqXkZVFBw2VWdwYkYJcuI8+G5p8wFgESGYfdpnEB + ErJsUv0PdRklL+oKTm48aL4zIK4pDRt1GXkyqqHJOMQ6jAs64/lFgIzBY6YxARJRrR5B0mWU3MhJeYfF + HQJdm1J/ly4hz4Ur/x7z9CJAzpm/W4wJ0LVJDX/RJZT8LJ7c+KfFcidAt0xpuFmXkKeiGpjsf6zDeCBR + nl0EyL7fYhoLIK5FUxp+r0so+VF/WUjupMl8p0BXFk1quE2XkGeyUK78Zd+j5rFAt3lyESD7fIfFWACd + m9TQuGS8cY4uodRE7ujeDncMdO1eXT6eCM0/6Ty3CJB9vt80BkAc9Xfr8kldFk2uv36R3BmQqIWTk/Bn + KR2ShdKoZJ9j5jFAr8XU2Ophdn0WTWl4xmIMgE4tnNT4Z10+qUvJlOD5cmcR850DXTisy8fVUVf+sq9R + 074jeTyzCJAFgN9i/4HOtKi/I6HLJ7VZNLHh4UWT5E6BxBxbme/uPwTUfuU/Sa78rfcfyeP6RUD7RZac + M6b9Bjo3ueEBXT6pz6KJ9QPlJDSARC2e0PQrXT6ui7ryl32MmvcZKePqRcCiiXVXmfYXiKPxOl0+qY96 + qEHutKnjRgCdScHbU9ogNP+Mce0iQGpqnmlfga5IL07Tw/8nIkV6l8WGAJ1o3KlLxzWR/fqDUI3IYn+R + Bq5cBMi58rJpP4Gu/FWXTvqyeELD/1hsCNCpkikNX9fl4/hw5W8brloELJrY8H9N+wd0adHE+t/q8klf + fD7j7AWTGkLCABIyuX6uLh9HR066P8j+xDrsHzLFNYuAkkn18yz2D+hMQHrxmbp80hu58zWmjQG6Ekr7 + 76qSHJq/bTl+EeDLD5wn+xE27RfQuYn1K3T5pD8LJjf81HKjgE4snFQ/TpeP40Lztz1HLwJkMh9vsU9A + p2Q+Tf6f/u1OZCN2l8iGAAkKL5rYcKEuH8ekeFJ9H9n2qGlfYD+OXAQsGV//Cdn2oGlfgM5NbHhTl0/m + IhtSUDKxUTYGSNhqXT6OiGooss0x0z7Avhy3CFgwqXGNxX4AXWiaqMsnc1kwuenTsjFtHTcO6NSxBRMa + /luXkK3TfuU/sTFq2n7Yn2MWAcUTm34t23vUtP1AV9pU79UllNnISuQRiw0EulJlmwLuJFz5O57tFwGF + 45ovku2sNm030KUFExof1CWU+RRNaPxTsWwU0D1NL9j1VQFF0jhkG2MdtxkOE1PHUh9WW0XVfvHEhhct + thno2qSG/9VllPmU5xpnyUb5O2wkEEfJpIbHVP3oUrJFaP6uY7tFgKp5VfsW2wrEczhjr/3vLLJRc00b + CSRqk/oLaLqUMpriCU2DZHto/u5zRK6ahunDnNGoK39p/o9abCMQV8mExpt0KdknxQWRLxTJSSYMoPua + ns/kcwKMLOO0ogmNM2VbjnXcNrjEseKJDdPVsdaHPe1Rv/MvmtjwosW2AYlomze+5bO6nOwVmcQfsthg + IDGTGgPFE5vT/r7W6n0JpHYfsdwmuNGmTCw2Cyc0/Uru22/aFiBxExrv1+Vkv6jJ23KjgcQdnT+pcZV6 + YxRdVimLuhIsntA0QO6TSdl7/MWTmvql49GA+dMaPik1vUbuk0eX0DuTm/5Ll5X94vMZp8+f0PiurFLU + SgXouYmNoeKJTWNT9SqBwgmNl8v9PNvhfuE1z8wf3/gLXRZJjXpv/6KJTeNlTgxb3C/QPeMb31E9VpeX + PSMbOUoK3gCSQhYCYu78CQ1f0yXW46gnGs6f2DRw/oSmFyzvC941vun5wglNA1TT1uXS48wd2/B1WVQU + yu2GO9wP0EPSW/N1idk36opNNpbCRwo0vCSLgdlF45uuTORVA+v7GmcUTmq8VK72R4p75TZaOt4m8CHN + Yr0YUTy+8RJVQ7qcOo2qxcKJTVcdX6g2vqxvB0gamb+CvlzjXF1y9o5s7DyrnQCSrEJsa2/u4xvukI/r + 5P8yeTc8Jh93i1Zh9XNAolQN7S4a37BRPq5vr7HjtaYWlNuEqkGrnwOSRuptjm6v9o9vUuOnZIMjQm04 + AADomajd3za9Q+ZNaLrZYkcAAEDi1ui26pyoJ8LIhh817QgAAEjMsbnjGr+h26qzUji+6RGLHQIAAPHZ + 56/+dTey8ZfPk50AAADdNLHhMt1OnZl545temDdedgQAACSkcELDi7qNOjeF45v6We0cAACwNndc4zW6 + jTo36u8Wzx3fcHCu2iEAANAlWQDsS+RNqByRuRMaR1jtJAAAMJnQMEy3T+enPNc4S61oLHcUAACc8J7P + Z5yt26c7MmdcQ/Yc2TkAANCpXN023RP1+wzZsbdNOwoAAI5z39X/icyZ0DRgzvgm2UkAAHCquROah+t2 + 6b4cfxSgaZd5pwEA8LiDrr36P5HZYxv7zh7XZAAAgOPmjGsarNuke2NkGafJzr5i3nkAADzqbfWeObpN + ujuzxzf/r8UAAADgOb5xjX/U7dEb8Y1rel7IjgMA4FkvqUfGdWv0Rnzjm35jMRAAAHjG7LFNV+m26K3I + zj9uHgwAADxik26H3otvdOM3ZQBipgEBAMDt2uaMb7xEt0NvxjeuecVNMhgAAHjIUt0GvZupI+o+Liuh + kMXgAADgRuFpIxs+qdugtzNrTOPom8bKoAAA4HK+Mc15uv0R9QYIs8Y2vS4MAABc7E3PvOlPopk1pulX + FgMFAICbePNlf/Eyc2zTwxaDBQCACzTer9sdMefG0XUXyyBFOw4aAACO1nrjmPqv6nZHrCKDtGimDBYA + AC5SpNsc6SwFBTUXyEBVmQYOAACn8k+ZEjxftznSVWaOabzOYgABAHCcWWMb/6TbG0kkM8c1PnijDBwA + AA72sG5rJNH4RjV/5sYxTbXCAADAgepnjG/5rG5rpDu5cUzjSIsBBQDA9maOac7V7Yx0Nz6fcfqMMc3P + zpCBBADAQZ7JyjJO0+2M9CQ3jm34ugxkxDSwAADYVfTGcY3f0G2M9CYzRjfPshhgAADsZ2zzdN2+SG+j + /nCCDOorHQYZAAB7eS031zhLty+SjMwY3fKD6WOajwgDAAAbOjptXMuPddsiycz0MU3LLAYcAIDMG92y + SLcrkuz4co1zp49p2W058AAAZM5bqkfpdkVSkekjm783bXRzqzAAALCB6NTRzd/VbYqkMtNGNU21OAAA + AKTd9NFNE3V7IqmOeoOgaaNbnrI6EAAApE/TVtWTdHsi6Yh6f2UZ/HDHgwEAQFrUzMhv+bxuSySdmTa6 + 5Y9T5SAAAJBuBWNa/qzbEclE5CDcaj4oAACk1Kjmct2GSKYyaZLx0amjm/ZYHiAAAJJv75QpwfN1GyKZ + zJRRzf9ZMLo5JgwAAFIoNm1syw91+yF2iCwCZlocKAAAkmbq6KYC3XaIXdK3r3FGwajmJ4UBAEAKbOQl + fzbN+PH1n5ADtN90wAAA6JWpo5oPThvZ8EndbogdMzm/6TtTRjW3CAMAgCSITB7Z/D3dZoidM2Vk00CL + AwgAQLdNHt00WLcX4oTIam2N1YEEACBRBaOay3RbIU5Jbq5x1uRRzduFAQBAD+zw+YyzdVshTsq4cc0X + yQrOb3FQAQDoStX4vJbP6nZCnJjJo1p+KgcyZjqwAAB0pm3iyMjPdRshTs6U0U0TLQ4wAAAdTBrdMka3 + D+L8GKdNzG+6e9JIObAAAHRi8siWO3XjIG7J+PHGOXJwd5gPNgAAysSRzS/4co1zddsgbsrE3IYLJ+U3 + vWN14AEA3jV5ZPO+SXmNn9Ltgrgxk0dHL5aDHZCVnlrtAQAQmjAy+jXdJoibM3l05GcTR7ZEhRx4AICH + RdSrxXR7IF7IhFEt18qBP2YqBACAdxybmB/pr9sC8VIm5EdmTpAiAAB4jzT/qbodEC9GCmC1VWEAAFws + v/lm3QaIV6P+ZsCEkc1PWhYIAMCFIo/7fMaZug0QL2f0aONj4/NbXpuQL4UBAHCxyJsFuTUX6OmfkKws + 9UcfZBGwTxgAAPcZN6Ll3Smjmj+jp31CTmZsbuQLUiQHzUUDAHC8Q5NGRb6sp3tCOmbM8OhXpVAqTYUD + AHCuwLj81m/oaZ6QzjN2RNO3xo1sCY+TwgEAOFrthLzm7+rpnZD4GTuy5YdSOA2mQgIAOEZz/dj85u/r + aZ2QxDNuVMtPpYiaOhYVAMDmWsaPiPxCT+eEdD9jR0avkkKKmgoLAGBXI1taJ4xs/t3xWZyQXmTciObf + j81vaRMGAMDWjowd0dJXT9+E9D5jR0QGSFEdFQYAwJaOjsvjj/uQFGRMXst1UmAxU8EBADLvyJgRkRv0 + dE1I8jM6v/nqMSNaIsIAANhC6+j8lj/qaZqQ1GVMfuRyKbhGUwECANKveWxe06/19ExI6jN6RORnY0Y0 + 11sUIwAgPRpH5UWu0NMyIemLLAD+QwowZCpIAEDq1Ywe0fIjPR0Tkv6MHNl4iRShXxgAgDTIb6kaPbzp + 23oaJiRzGTsi+vXReS2HLAsVAJBMfnXhpadfQjKfkSMjX5TC3GsqVABA8hwYnRu9WE+7hNgno4e2fG5U + XuSNUXktBgAgeUbntbw2alTzZ/R0S4j9kp9vnCeLgEetChgA0BPNT+bm1lygp1lC7Bufzzhz1IjIautC + BgAkamRe8y25ucZZenolxBkZNTw6dmRe5KiQIgYAdMOxUXkRn55OCXFe8oe3XCOFHDEVNgCgc9FRIyL9 + 9DRKiHMzcnjLj6WgA6YCBwB0FB45PPJzPX0S4vyol66MHBHZY1HsAIDj9o0YEf26njYJcU9Gjmz4ZH5e + ZJswAAAf8lxeXuOn9HRJiPsyfrxxzoi8yF0WxQ8AXnXn4MHGv+hpkhB3Z8TwaG7+8EhMGADgUW0jhrcU + 6GmREO9kxIjIz0YMj1QKAwA8JS8SyONP+RIvJy+v5bOyCt5heYIAgDtt5219CZGodw4cMTxabHGSAIDb + lPfta5ytpz9CiIqcGANE8yknCgC4RSQvL5KtpztCiDn5w5q+IyfK/jw5YQDAJd7LH9b8fT3NEUI6i3q/ + ADlhHjedQADgPHmRjTk59Z/Q0xshJF769jXOGJEbmS4nUKzDCQUA9teqXuLn8xmn62mNENKdDB/e/J/D + h0f2CAMAHGL/8OEtP9bTGCGkp1HvHpiX21I6PFdOLACwsdzcyB35+cZ5evoihCQjsqL+o5xgIfMJBwCZ + F63NG9ZynZ6uCCHJTn5+06flZHus48kHABkyPPKUelMzPU0RQlIX47Rhw6Jjc3MjrUI95AYAmRATPp7o + R0iak5fXeqmcfK+fcjICQLrszs1t/p6ejggh6U5urnFubm50qZyMR0wnJwCkwpFhw6KL1dyjpyFCSCaT + k9f83WG50ZeHyQkKACnyek5eyw/0tEMIsUvUHxUaNrylQE7SiOmkBYDeiMiVv48/4kOIzZOTE/13OWGf + Np3AANB9wyLbhw5t/YaeXggh9o9x2tChkUFDh0XCwgCAbqpTrzbiGf6EODS5uc0X5QyL3mtxcgNAJ1oe + HjKk5fN6GiGEODnDhrX+eeiwaJWQkxsALPllrviTnjYIIW5Jbq5xQc6waLGc5K2mkx6At8WGDo2W9h9t + fExPF4QQNyY7O/r17GHRx2UxYADwNpkLHs7NjV6spwdCiBeSkxO9WiaAg+YJAYD7SePfLX6rpwNCiNei + 3s0rZ1hrgUwI9eYJAoAbRcLyUT27/0w9DRBCvBz1aoHs3Gi5XBEcEerqAIC7tKlzPDe34UJ92hNCyMmo + N/yQq4NHLSYPAM61KSen9VJ9mhNCSOcZMiz66+yh0ZeFAcCpIi8NHRq9Sp/WhBCSaIzT1BMFZSJ5vePE + AsDGdssVf191DuuTmRBCuh/1ZCG5ksgZMjT6vjAA2NbBIUMjQ/r2Nc7Qpy8hhPQ+6i+ByUJgkEwy+0yT + DoDMem/wsOjYwYONf9GnKyGEJD+nLATeNU1CANKLxk8ISX/UQkAmn7zBOdEDg2UyApA2+wYPiwzj7/MT + QjIa9edCZRFw9Q1DIy9ZTFQAkudlOc8G8SY+hBDbJTs3ctkNQ6MPW0xcAHrmqDqnsodFr9SnGSGE2DdD + hrX8ZHBO9F6ZvI6YJjMAiYkMGRotV3+8S59WhBDinAweHPmSLASKb8iJhG/IiRoA4qq7ITtamp3d/Bl9 + GhFCiHOTnW2cf8PQ6BiZ3PaaJjsAx70zKCear/5Alz5tCCHEPVFPGByUHb1SJrv1ou2UyQ/wIvX7/U2D + c1r78uY9hBDPZEBu80WDcloL5KrnPWEAHuIXxf1yIl/UpwMhhHgvv/QZZw7Iaf29XA09JJNi2ymTJOAm + MfHgDdnR/1E1r8ufEEKIyuDBTZ+WSXKseFVPmoCzZUd3q0e6rh/a9G+6zAkhhHSVwUNbfiQT6CoR/NCE + CthfQK70Vwwc0vJDXc6EEEK6G/XkKPXEwYE5rXcMzIk2CAOwnaHRFvm4Xlydm2ucpcuXEEJIMjJwoPHR + QTmt/WSSfVBE2ideIFOON/0HBgxtvZ6X7xFCSJrSt69xjky+Vw/Mbr1DNAgDSIMW8fCA7Nig/v2Nj+ly + JIQQkomoxUD/7NY/DBjSetuA7GhggEzUQPLEqqW+blWvVlG1psuOEEKInaLebKjf0Nh/yMTtkyu1nfLx + 2IcncyAhu0Sxev4JL9sjhBAHZlBu5AsDs2O5MpnfK2r05A58iCwWw/Jxff/s2LDrhrR8XpcPIYQQN0S9 + omDgkNgP++W03tg/O/pM/+zWmDDgSa0DsqNb+w9pndEvJ/YDVRu6TAghhLg96pnb12e3XSYLggK58tsk + TaHF1CTgHmqxp34lVHx9TvRqnsBHCCHkg/x2tPGRAYPbfiZNYvqAIa0PyaJAPfnLqpnA9mJV8nFD/5zW + aWqRJ1f4Z+vDTAghhMTPtTdEL+6X3dpfGkqZNJQXRORkk4FNqEdunpdjVCoNv1+/7OhX9OEjhBBCkhP1 + jPDrh7Ve0i+nta8sDHziYWk4AfloIC3qZby395NmL3LV1b165EYfHkIIISS96dfP+Hj78wmkKfUbIs1p + SGxTvyGyMBgiTQs9IY2+dae4o9/g1oLrB0evPn5lb5ymh5wQQgixb67Lbv5Mv5y2n/cfHMuWZlbYf0jr + 36W5vSzqTml2XlXb3uSHtN6txub6IbEh7c/ByG2+SA8fIYQQ4r6oZ6Jff0PrJf0GR393/JGD1rnXD2m9 + Xa54n5CPr4tKcUQYDqO2ufL67NbX9L7cft3g1jlqH6/Njv5W7XN2tnG+HgZCCCGEdIxx2sCBjZ+6Nqf1 + 0n7Zkculof5RGmnO9dnRiWrB0G9wbMX1g1vvvG5I631yBb3p+iHRbdJ4d0rT3S32iZD8v+YDQ1pbhLlh + t5i+JyTUz+6W/8ttyW3KbbffR/t9xZa3L1ZkG65Tj2y0b1PkctXY1bbyMD0hdk9W1v8Ht7OwSdH8LzMA + AAAASUVORK5CYII= + + + + + AAABAAEAAAAAAAEAIACdZwAAFgAAAIlQTkcNChoKAAAADUlIRFIAAAEAAAABAAgGAAAAXHKoZgAAZ2RJ + REFUeNrtnXeYJFd16H/nVnX39OSZzTknrXIOSEKAJJICIETGNsHYBgwGR2w/y4AwBvsZAzbGfoBJNiCi + yYggC0WUtVppg6RdbQ6zs5OnQ9U974+qjtM907PbPdMz2/f75pvu6u5bVbfu79xzzzn3XKFRZlV58Hlv + RADfglWFiDSJpyutmoutcrGqbFZlhap2qkrcKgAJVfpV2a0qTyE8opa7jThPJ3xv2MGgjiAKL37sC41G + nkVFGk0wO8qjl76BFoV+gbQqjpj5Fq5W5SXAJVZloSrNakEBVUE18xqsBscArJJU5QjI/cD3Rbl9eMQ7 + GGuK0BxxSPmWa7d8vtHoDQHQKPVQHrj89YiA5wuu0m3hJou8WZXzUWI2A3we/OHIXwr+AsGgKingceA/ + jZpvjFp7NOYEv79ua0MbaAiARpm2svMlL+FY3zwcx8NtT4nX33SVqv6xhReqShSFk4Q/7zVpkDsRPtYS + 4+fDo9iU47K4r49L993WeBgNAdAoU1kevvzVJJLdRCIjiHitqs7bFf1jqyxWFaoMPxp+BzgiyD+7yKfT + MHAoCksShuu3/7/GQ5mBxWk0wcwrB867jv1Nc2mWEYwwR1VuVfhTq3RVG/7Mb2z4OUqLhSssLHRE7o97 + OtwzmOQta87j64cebTycGVbcRhPMvLK7pZtWfxQRO0+tfFzhjVZxpgD+zHcjVvUtFtoiRt4zpzV2yBto + KJMzsTSe2gwrD176RowoRmj3lI9ZeLtVzBTCX/DfiHzJNc57VfU4Cq/c8bnGQ5pBxTSaYOaU+5/3ehBF + 1HHSyh9aeEst4NcK4VfAs/qGtG//uNWJRIwI39nwtsaDagiARqlFSUsax0bwxH+ZKu+xSqSWBr+J4A// + O561f3A8lbyxP5nEMY0uNZNKYwowQ8oDl74eRABZqug3rHLJdKn9Y/4riPBQzDE3WWU3GG7e2fAKzITS + ENczpAjQmU6Lor9tlYvqCf5QYzgv6evbFrR0GCONcWUm9atGqfNyX2j4E3Sdr/J9VdlQT/BnfivIriZj + rrPoVscYXt3QAuq+NDSAGfGUDHYkha/mlaqyvh7hD7QAXZWy9qbXPvN5GqaAhgBolGoV34em6BxVrkeR + 6bD2TwQ/4X9f9bqvrXnLgmTaNp5bQwA0ysmW+y5+PcFMTc5DOb2aI/8krf0Twq8oProxbbnYU+W2tW9v + PMA6L41IwBqWN7/5zRhjSKVSBcettQwPD2PtxKPkXSNJzk20Eld7kYV2VepK7c+HP9QoWjzsBbsGh793 + VndHoxM0BMCpUV7zmteEICoakjA6Ooq1Fs/zCo4DxONxRCR7LP/z/Nd7Ed7YT/yZiJ6v1Necvxh+Da9d + kIvO6OxqT/l2oNEzGgJg1oMvIlhrg84v0gGsATYCi0WkLRKJRDJgZ0pGKOSXfAGQKc+6nv7FQq/l9b2t + F8Z9CWGrX/gVwaIrh/1UqyoNAdAQALOzvPa1r8XzPAC+9rWvcfPNN68TketU9WXAGUC7qsaK4S5+Pd4x + QtAE8LOw1Tf84fc6EDPfYg80ekpDAMy68upXvxrf9zGBr6vj5ptv/h3gHaq6gTC2ohzwpUb5iV43W4Oj + YGcA/OElxx0xS1R5tNFbGgJgVpWbb74ZVcUYg6quVtW/BW5W1WilQE8GfkWJWJAwh1+9w6/BN11VbcvV + 0CgNATBLirU2A/9G4F+AF0wK6El+VwEpsPzXN/wKCBiUiDb4bwiA2VRuvvnmzMv5wMdqDX+mpEXDyL/p + DfKpBP7gusWzMNLgv/5LIxCowvLKV74y89IF3gW8bCrgByWJBkbAaQ7ymRj+8LxoStFe25gC1H1paAAV + ll27drF+/XpU9TICg5+ZAGhV1X5gVFX9kxEUw8Y6aXRuVE2kEviZNviD1waGPLXP2cYcoCEAZktZu3Yt + 1tqYiPyOqs6fAOgnVPVrwK+BA0CiuL6J3IKZkhbVVcloV9x3vqBwfj3DH94NBqc3Ks5QQwNoCIBZUW66 + 6SYARGSTql49DsQKfAf4S2DbeHXmRwHmvy4uy1MRPnRo0cFfNA087Cvn1zP8mTgFNfpIVyzWN5BONTpP + QwDM/GKtxXVdVPVKYFEZ+CEY8f8I2JM58O1vf/ukzp0671X8NDpgHcuDqrxVwalP+LP2CTViHt4/MpKK + L+2BXY3+U8+lYQSsoDiOQ+jnPw+QMvAPAZ8A9lhrsdaeNPwAjxPHBCDeDeyvX/iD9wKHXJw7HRHM8a5G + 52kIgFlTWoG14xjxtlhrf50JEvrud79blZOe/9BXEAMRh2cUfl3P8AM4Yu5pl9j2JnF58/YvN3pNQwDM + /BKCHlPVeWXgB9jiOM5xEeFb3/pWVc8vTUlGUyYpmG8AQ9Pr5y8PPzDqIF8/lB4YXd46r9FxGgJgVgkB + A0TLwI+qDkajUd/3/eqfOxXBMeCK3KHK/06vn780/KrgiLk75rg/b3aj9CQaCwEbAmB2FV9VR8fx3c8d + HR2NSA0y4l798JeJRNIMpxgQkX8BeusNfhEGIuJ8+nhq9Pi8eCs3PfvpRo9pCIDZUcIEHQngcBn4ITAQ + LgS48cYbqy99fIeoo8SM+QXIV+sJfhVwxflaN/GfdLnNDKWTjU7TEACzTggMAdvLwI+qblDVV4cLhbj+ + +uurev6rH/0inhdl1CPlivkHQX5dH/ArLvJATNyP9cpoctRJ8vpnP9voMA0BMHuK53mIiKeq96pqugT8 + ABHgvZ7nvdh1Xay1vPzlL6/qdbQu3E5Ls0vCS+9x4K+AZ6cbfgezLybuX/alR55Z5HayYffqRodpCIBZ + 1kjhqC4idwA7x3EFLgP+OZ1OX93c3IyqVlUIXHXHHSSSlhbjcMi4dwq8T+HAdMFvkKMRcd//pDlw+4Jo + B/12hKu4pdFhZlBxGk0wcdm2bRsbN24kXNyzALiyBPyZl3OAizzP2xaNRp/1PI8NGzawY8eOqlzLV488 + zGvnnk0Llq7TBraPHo0/h3KxVTqmGP6DMXHf98o5Z399aDSFpz6/tec/Gp2lIQBmZznrrLMyabz3AVeq + 6oIS8Gdez1HVi62121zXfdZaW1Uh8F89j3LT3LNJHG1ib2L0qQ43ulWV06yyeIrU/idi4v7h/ww99+2I + 9fBR3rrvc41OMgPLjNsb8MHPnsd5D29nz7IFmMlcfRhBJ9ZwwDnIhenzkFvumNS5b7jhhsx04HXAZ4CO + CZb07gDeqao/z6T6/tGPflS1tvjuhrdiRBhMp4k57oa0tX/lW32lQnMt4EdIumK+FxP3Q73e8BOLIu2k + 1OOte78woyF48LPncd6jO9izbAESpDWnonRmYZo2RVj+XA8PXbCa89/xUEMAVLPs+/A6HHXxJJW9WlFw + HEj72iRimkBjIDFEm1GiCkaC7fNSwAhIEkgqJPDSCYiEzzf4Vnx4lHQswuKPjL9y5cYbb8y4BKPGmD9V + 1b8EmsrAn3m9A3in67o/TyaTiEiVhcDbiDuG46k0cce0jPr2FZ7VP/SVc1RxqxThZwV5LCLm060mdtuQ + TQ52Oa0kNDUj1f6Df7cSN5ImmWhCswQoUV9JOtIkmCaUGKIxoBnK9CklqWgiltJEypigXcN2jiSG8aJR + ln9od0MATLbs/charIAJg91VFLHE1Ei3qKxBdSPCWmA5weq8+UAbgSXehPcVJKeBNMoAyFGUgyjPqfIM + ylOCPKtKr1WTNH5wrogPvihL/25nyWu74YYbgoYTaVbVDwDvV9WmMvBnXu8A3uU4zu2pVAoR4cc//nHV + 2uvnp7+Nrb1plrS4jKSTxJzYIl/1FZ7qG3zVM1S1zTJ+Gi+F3KJelXBhj4wYZIsj5utR43yz1w7t7ZZW + jmoPy2UZr9s7c4J9nvvwWlQFYywCWDU4aMyKdktuH4f8PjUPaB+nTw0CR1A5iLIH5WlV2aYqz6jRXvGd + pFgLKkQs+AJLP7K9IQDKlSO3bKa/5TjxVHPQ+VRRkVaE9SiXApcAZwGLQ9grX8qsBNEqYS9XxUNlEDiA + 8iiWe1XlXkF3eGqGHBtoGV5ymKbOBSy+pVCty2gCQLOq/jnwJxkhMI4g2KGq73Jd9/ZkMgiU+elPf1rV + Nrxt3dsQETzf55AdZaFpmeOrvSht7ZWqXOajq1XpVIir5vIMZhpJYVSVAUfMPtB7XGN+GcG9e8fQ4aOr + WuYRURcV5Xf2zoxR/9DHz2R4+CjRaAuoYkTxlVZB1gOXAhcDZ9ekTyn3oXIPKjs81SHHAmpIuAk6ku0s + /IfHGwIA4MBHV3PNn5/Nj299LEgnpeKq6CrgWuAlBBF28zhRl+XYB0VW79Ps5xblCMpDwO1q5adG2Wkt + Pgq9i1uYu3eIZf+UM+LlawLW2j9X1T8BmiZI+bVDVd8VjUZvHx0dRUSqLgQAvr3md4mqMICHr8qbdn2e + /179tq60+osEs8mzdpmv2uypdVEwIp4RM+qI7PN8fTJinMPnt8zvvXvooHUQOqPNpKzH63f924wAf9/f + r6Xv1wN0XNIWtL1xHFF/Nco1eX1q/tT2KX6Gmh2o+qLCnpHNrGx5jKUfe/rUFACHPn4myZFeHLcpgEO0 + CeQ84LXhQ1rJyXopKntQ5Om/aPDgdqP8GOUb+Ho/YpL4ipUorh5n2T/tywqB0CbQDGSFQBn4M6+zmkBm + OlALIZApX1v9DgTB0zRp9QGDVcVXi6+BbcCIICIYBM9aIsYhLg6O285Tz/zjjPHsH7hlMV5TO+Kngucq + xIDz661Picpv1EoCVfxYiqZjXSz+9+kxHk6LANhz6xoUwWAxYqJW9ULg7eFDqs460hN7UHmfASo9KD8C + Pq++fw+4aeMrKsKKf34KgOuuuy5zxoqnAxmbgDHm9sz2Yj/72c9mCGb1WfbeujqcNhoEG1HMRcDbgJfW + XZ+CH6F8QXzutkIaLyBx5T9vm90CYN+t61icWs++2DaWjSbY19R0OvB7wKsJVLLqlOo8qPzvH1XlG6h8 + dqjV2dI6YHlkQTvnHepn+Sef4rrrrhtjE6DMdKDYJuA4zu3pdBqA22+/vUHypMFfRc/SXczdu4ZUvItY + 4vhpCr8P3FzvfQqV21D+zW9r2WL6h1nxiafY9YebWf2prbNPAOz9yJrwdBbFdIrqm4B3A+uqeqLqP6is + vxdlB8qnVeTLWPoyjbfyk09mQ35VtUAIlIG/wCbgum5DCJxwn1JEDSidKvrGsE+tn0F9aifwL6p8SVSO + a7gZ7MpPPTl7BMDeW9cELvdhH9PinIvyV8DLCBNszJAHlflNCpUfiHKrjrgPS8xHgZX/upWXvexlqCrW + 2mZjTMF0oBIXYWY60BACE5d9YZ/SpINE/bM1WBx13YzrU8HxNCo/QLmV0ehDxNKgQZ+a0QLgub9bjuPH + UPFBiKDyGuCvqy6hpw7+/Dq2o3zIWHObj6bUs0hLjD/YvihzRc1AxS7ChhCorOy6ZSXRWCTYo1GIWOXm + sE9tmHF9auw5dqByq1G+5ispR1xGvVE2/PuOmrVnzdYC7P7QOlZ0z2cgMYKKdorKnwEfBJbMAvhBmYvK + iyzELDwsSHL1px/nJ3d9jB/3twOkgfvDVGIXEeyYWwp+CBcQqer2zNqBNWvW8OyzzzaIzysHPrKSYx1n + EE8dQZUO4E/DPrV0FsAPyhxUXmiVJmt5RNDEfYcH+fgVK/jkQ0dq0qY10QD2f3gNvm8wrsUiiwX9MPAm + arEPwfTAn11bEKpvXwL+WqweTKohYi3vPLA86yIUkbIuwqLS0ATKlL0fWYdrfNK+AewiQTJ9KjJL4C/q + U3wV5a9E2W8dF2MtKz+7peq3WnUNYO8HV2N8xUZAYAXwz8DrqUXugemHHxQHlXNQVqNyv4v0k05zXdsg + 3x/MaQLh/V+kquMJwYYmUKLs/9AqBCHca3CFIJ8I+1T1Ndjphz/Tp85GZTUq9+Nrn2Nc3nP2Aj7xyOGq + 3m5VNYADt6yn9WcR+l+eAGUF8Gmgumlx6gv+4nN8XyzvVpHnzHZIrXV514H54bk1axMg1ATGKSekCey+ + dS2o4hhB1Yar2ipsy+x/KTxGJumnkGoSjA+r/qJ2c9Lisu8jG3lmwTCrD8cQdLkqnyYw9s28PlUZ/MXn + +CHIu9TqbjfVSooR1n65emHEVRMAegvsjq/B9RVRWaIB/DeeQvBn3n8b5d2oHsAIKz+3hWuvuSYrBETk + hIXAv129l1Q0QuvwyLgP1MaaheRwRBAXcAVxFXXJLWoxBMsdIgQv0mQWuqgoYAU8VTzAQ/GczkjaP5ZW + NVJSYCgWQwrFYfkHq7MfmCrs+eAqjCuALAY+CbzqFII/8/57auWdIuxXdVi14hHkljoTAHtuXUdwK7YL + 5J+A3zoF4c8srvmiWt4rIn0qwprPP8bVV2f3FJ2UELDKu2654ODt82MJ4q7FWIuKY1Rss4o0i2o3yHyC + aLfM31yClWxtBDsaZf5HCaB3w78MvZoBHSQNpFCGgEGUIYVBYAClJ1xVeRQ4inIEpA8YseKNGD/i5Ro9 + 18W+9ubtvPk/zpz0Apg9f7sGHBBDJ8o/Ab99CsKfqedLovJeq3JcfcParzxSPwJg762rEQRRYlb4W+D9 + zE6DXyUPClQ8lI+J8kGFJFZY/ZXKhEBuLb5gRGly7I7NXaN/8kdnHjyY8lkPspzAk7ICWEYQ7RYP4Y4x + 2XnxeOp/XnahPKB9lCSQDP8fB/aiPAc8h8puhJ1i2acw0Nd20VDnwH2AZJ+XJ2AUVn20/PLYfbeuQUVR + 0ZhY8zdhW828PlUd+DN96h9E9RZFkqiw+suPTb8A2PuRtaCWpYn17Gva+VaCDTJbT2H4M+cYRHlPtGP0 + C6njzQjCqq88WiAEQP4c4f2qNANEjNLsWubF0yxtSTE/nmZBPM3KtmR/d8xLhyN5rKptOjn4i35Tsp4k + MIRyDHgaZRvwFPC4Bgti+gRJad7v4t4wKacpuzJuz0dWYVQYjgrNKX6bQPVvO4Xhz+9T7+1w7ef7PIMq + J20POGkBsO8fNqHJJCCXAP9FsOLqVIc/8/5ZlNcr3B/dNxdz7R6stTgCD/c08+1nu1vTaj7aGfN+b3lr + 0lnSnGJZa4q5TR7NrsU1Njtyai3atPrwl/vcQ+lT2IfKFuAR0IdF2YaRY+rjZdrTdaDvwm20P7kWRC8G + vgpUP9f4zIM/834X8Hqxct9oa4rTPntyIcMnJQD2fmRN5sLnAV8kWM3XgL/w+z9U5bfcpYlj0p5GRFpA + loJeIHBR2srlaStnNLnWOKK1A3764M+rU/LSDtEP7AIeQPkNyn0gu61l2IlZaPXnivKfBCHjDfgLv/8j + VX4L6EGFNf/96NQLgL0fXg/GQhQhqX8GfJhq+2VnPvygeLj6N5H1wz9AuBK4GjiHYO4ezTyEmgJfX/CX + +l6aIL3Ww8CvUP7XdHgvwegtVHveP/PhB8VT+GsP5+9dtRpRYfnXTswoeOIC4O+XghcFuBDkNoJcag34 + M98XkIhFWnxMmzckLf4wgXV++lKx1yf8uXYNjlngGK7GJWJbJaKBxVCqdP8zH/5M8tE9KDcBDwyklXO+ + dWIGwRNq1uc+vBojBpA42M8ShGSe2vDboDnFVSTuI60e0uwjkSkb22cD/GM/Fw2iGaKWrDBowJ/5+5Ig + vwc6igqrvzF5LeCE1CtfLcYYUPtCoLq7YM4k+DOvBSRuMW0+0uIhURuE2tQJ+zMW/sxzSQqaMuBooFVF + LeJOQiuYnfCDyg0K30Dlh+YEJ0qT1gD2f2gV1hhQ2hC+DNxwysLvKCZukVYP0+wTZOGvszKT4Q/r0eJj + melVk0UidvxVJrMX/kxd30N5EzDo+8L67zw8qe4x6QU6sWQq8xCuBF5wKsIvjmI6PdzFSZyFCUyH14C/ + 1vDnFwuaNNh+F9sfQUecIPH+qQc/KFehcoWokDqBLjhpxWE03gRoE8jrqFZwxgyBX1yQljSmzUNiNqc/ + 1SH7sw5+LX29mgqmBzKqSJOPNFlw9FSBH1TaVXm9Kr9oMiQm200mNQXYe+uazMsLgO8T7JQ76+EXR5FW + H9Mezu/rvZwi8Jf6LGuEjYUGw9kNf6auwwQrJB9QK6z7XuUpxic3BRAhsucZCJb4zm74LWAU0+7hLEzi + zE014K9X+PO/nhbsQAR7PIIdcVBfCq9/9sEPygJUXhZvTk66u0xOAKjiLV89j2DXntkJvw3qlFYfZ0Eq + AL9pBoB/KsNfIAgkKwh0wMX2u+ioCQT67IQ/0y7Xjg7G5sokp6MVC4C9H86o/3IOsGnWwZ8x8MUsZm4K + Z14KifszZwP1BvxjzqOApgx20MUOuGjazFb4QTkN5RwUdr78vOoLAFCIOChcTrDWfHbB74LpTOMsSGLa + vBMPOGnAXzfw57S60Gsw4KLDDmpltsEPSjsql7vGQSdhla7cCyACnt9OsEvv7IEfkGaL6UjPHFW/AX/l + 8OfX44MddSBtghgC184W+DPfvzjl+e2CGai+AAjKEk5U/a9D+MVVpM3DtPkza8RvwD95+PN/kxbUcyAq + hVGbMxt+VDlNgq3OKxYAFU0B9n14XeZiTge6Zjz8gMR9zLxUEMTTgP/UgT9/WpAw2GEnCDOe+fADdIOc + DrDtmgsr6kYVagCCYhHMJoL0UzMXfqOYtsCnPyPBb8B/8vDnH/MM6gMRgXw378yDH5Q4KpuMWLwKrdcV + CgAfYyWqhrUzGX6JWkxHsEpvxpYG/NWDP1NPaCTEz0wJdCbCnzm21lqJumJT1RMAAoi0MJl0X/UEPyDN + PqYzXT/Lcxvw1wf8RbYB6zvBasNsOPGMgh+UFSDNKNUTAOF54sDCGQe/gGnzZrbK34C/9vBn7je0DeBq + sOQ4/zz1Dz8oi1DiCH2VdKtJxAFIJ5X4/+sIfnEUpyuF6Ug34G/APzH8+RCmDZoyqJ1R8INKh2A6s9cy + QZmEG1A7mWgjxnqCP2IxXTPUt9+Af/rgz6tHPQFrcslH6h9+gIgqnZV2r8nEAbSN+/16gj8Wwj8TFu80 + 4K9L+LPHfEGtBEFDUvfwo4rLJJbpT0YARCk3Zagn+ON+AH89JuhowD+z4M/rW5o2gWHQUM/wg4oBYlD1 + KQBuSQFQT/A3+zhd6SAhRAP+BvzVgD9TwvUD4miwf2p9wg+KmQzXkxEAtqhJ6gd+BNMSuPka8Dfgrzr8 + efWoJ7k9lusPfghWAlUc6DIZAZAKhUAdwu9hOme4m68Bf33Dn3/cl9wG6/UFPwT7KlQUAzBZATAMmT3c + 6gR+zYz8Dfgb8E8R/FkhQLBCNt87MP3wg4oXslp1AdBPsMljbeFnEvCH0X0N+BvwTyn8+fCJBi1dH/CD + kg5ZraIACC7oODBSL5lWM9b+xpy/Af+0wJ+FVwKjYH3ADzACcrzYXFeuVBYJGJxkGJUjdQF/6OdvwN+A + f1rhzxRbN/CDclhVRyrkv0IBYEEsowQbEk4v/JkIv4afvwF/PcBfFC8wzfCjKnuxZkQrDAWucC2Ag+en + RlR5ZlpzrIc78jQi/Brw1xX8pX4zPfCD8oyKN0o1BcBiZxhjYqBsRyU9LfALwVr++Axey9+Af5bDL9MN + fxplu1iH7ubm6gmAbV5neELZAvRPOfyAafUwLV4D/gb89Q2/5P1uauEHpV9gC8Bzx49XTwBsvmVr5uVu + lN1TCr+CNIUpvGZKjv4G/Kcm/JljUuI6ag8/KM+qym5UOP+hyrYHm9TOQOLQi3L/lMIfCeb9M9ri34D/ + 1IE//C+iRQzUHH6A33hKr04ClYoFwLIzHkRT+KjchZKcCvgRMO0zfFlvA/5TDv7M7YiZQvhVEqjc5YJ9 + dG7lewRWHAm474lLMxd4H8puYEOtd1cxrR7SUkdGv/yJXeZJSvikVQnSx2QAldznKg34Twj+8Iby/0NI + lqDWhsckd1zDNp9O+DOvhWCI9WoOPyGT9wGc0RutvgBYdstWnvvABsDsA/9XqGyoJfwSCzL4Tvu8X8NO + 5kSQpg6kdT7SthjTtghiHYgbBzcG1gNvFE0No0OHsQP70aHDaKIfUiNBHSLZztWAvxz8CjbsBJFmTEsH + 0rEQ07UY0zEfYs1ItAmMi6ZTkB5Fhwewxw9hew9hB3rQkQFIp3LtnW23KYSfsG9L8NyzY0Nt4AflDnz2 + Y2Dzb+6tvgAAOBJLMn805oF8H3gDSlst4MeAdHgwbcE+4WjuxDAdyzCLz8fMPx1n/ulI+xKINCNuExgz + VkBZwEugXgJN9GF7dmAPPoa//wG0ZyeaGAg7hmnAX1CPDQ2+rZiF63BXn4uz9DScxRuQtm6INCGRWOFS + 3ExdnkXTCUglsH2H8fc8ibfrcbxnHsH2HIB0AnCKjHNTAH9WC9BgBWHt4B8E+R8c9dh8DzxYeU+f1Pi6 + 7y824ltFhC5VvoVyVS32VTOtPmZOahpG/wB8iXVgll6Eu/pFOEsvRtoWgeuWfuATtawEQkFHj2OPbMV7 + +ud4z/wKHdgfdhBzasOvFhBM12Lc067A3XQF7vIzkNau3JZdlbS5FL1Oe9jjh/B2PkT60V/i7XwIHR4I + PhSZGvjz2yBtslOBKsMP8EuBm0COq42w4aE7aiMAAPZ84HRsKoEY53dR+TQQqRr8ChIBMz859YY/tUi0 + FWfllbinvQqz5AIk1lIgmE6qZDRR38f27MB78vukt/0I7d9HgZp6ysAfTIpN12IiZ7+YyLkvw1m0Dlyn + 6m2uoyN4Tz9C6u7v4m29Gx0dCu0IUwM/EGQUSppcWp3qwZ9G5Z1GvP9I2zinTQL+ExMAf74JtYrCElG+ + g3JBtUZ+VDBzUoHPf8rAVxCDWXAGkXPegrv6BRBtrk4HHK/VrcU//CTpB7+Av/PnaGq4hDYwS+G3Fom1 + 4G6+itgVb8RZdjo4kp9upvrtLaCjo6S33Eny51/B3/VEYEQsmIrVCP7M67RBU1JN+EHlN1hegXBAxbDx + wV9PqmmcybblP93Vw/sunYP1zKAENoRrUHFOGn4bLPF1urxJRiecDPzBqB858w3ErvxLnCXngYlMzblF + MG3zcVZdjrQvRnueRkeO56mnsxD+0JJv5i6n6aXvIfait2PmLmHMCFyTZw0SieAsWUvktEtREeyBZyGV + HOs1qAX8YTh7sHJQqgV/GuWjXlR/5aaFDQ/fNelmcU6kLd972TyCOAfZC3KxKitPduRHmNo8/mqRjuVE + n/enRM79HSTeVftOWEoOuBHM/NMwi85G+/ejfXvHQjdb4Edw119C/BUfIHL6VYgbmZ42b27FXX8B0rUQ + u3cHOtxP6SlYFeEPm1IgyCt48vCD8mvQDxorwyB86tCeqREAn7inhz+7oJOkiQyL6iDKS4DYCcNvg737 + nM4pcvupxczdSOyqW3DXXgvGZbpKxr0t7Qswyy5Eh3vQY89kjWOzBn4xRM6+lvgr/xJnydppAb+gzY2D + WboBs3gt/t7t6EBPoXGw2vBn24HAI1CQQ2Dy8KsyCHzAtzzYFHFZO0nV/6QEAMB7L52XudjdEmwaes6J + 7qiKUZw5UxTxpxaz4ExiL/ggzrILmc6SH9uiALE2ZOkF6GgfemT7GCEwc+F3iF5wI/Hr/wTTOX/64dc8 + j/O8pZjlm7B7tqPHj+QFbtUA/rBZRUA9czLwg/IVVT5pRDxQPnVg79QKgH+67xh/cMUCHB9PlGdAno8y + b7Lwq4JptkFuv1qP/moxc9YRu+qDmCXn1kVHLO6UROPIonNg8BB6dOfMhx8hcs6Lid/wJ4E/v47gz7Sr + dC/ALF6LfXYLOtA7QSThScCfFYgEWoBvThT+rSjvF+GAEzOs+81dJ9wmJ2Vuax72Mb4BvK2ifARlcLLw + IyBt3pTAL22LiV7xl5gl59Ul/Bm3uLZ0I1e+H1l5GVg7o1197obLaHr5+wK/fh3Cn4nglrVn4b76fUj3 + QrC2dvCHTUP+NvWTg38Q5e/EylZFSQ2cnMfspATA0n/ZFiRE9CPg6zdR/h0VWzH8CtJkMfFaq/5BWGnk + /N/DWXFF/cKfGemtQvtiuPy96JzVeR/MIPitxcxfRdNL3o3pXli/8AOKoqrI5ktxXvw7EIsXtnk14Q+Z + EEeDFa6Tg9+i/LsxfBNHEYTNW+89qbY5aYfbyk9txXdcrDhJVfm4wg8rhT9whU1NTn93w/VETnsV01kq + gl81fK+w6Ezk4t+HaGuZDlmv8CvS1ErsRb+Ls3xz7fz7VYM/FxBkLr0Oc+FLxlZSLfjzVF2J6GTgB+UH + Ah/zfU2mPZ+ND9990u1TFY/76oOPM2/bE6ByGMufo/ymkr3UJWIxtU7xpRbTvY7IuW+FaHxmwE82UA7d + cC2sv5YCemdAbH/kzGuInHVtXQjcCeHPfF8VbWpGrn4jsmh13lSgyvBnzuloMPhVBv/9wF8ocmTjQ9ey + ecOyqrRRVQSA3AZH129CUFTlSUHeh/LkePADSEutF/wouDHcs96E6V4zbWroCcGf6aCROHrem6BrRXbB + TF3DrxYzdxnRy9+ARGPT3uaVw5+5fIVFq+H5N0MkNs79niT8SrCpiGsrgf8pkPeh+qSIsOO8nyK33VY/ + AgBg1WeeAgRBQPy7Ud4DsrMk/AriKKa19qO/s+hc3HUvnbZlxScOf6bNFJ2/CXvadYWPq15X9Ykhet51 + OEs2zjz485/J+VfDqjMCgVAL+DPNFdHC7cXGwr8T5D1ivHsQFwU2PHpP1dqqqkG3Kz/zRHDRfhQvmfg5 + yjtRniq1l7rE/Rr7/RXcJtyNNyLN02OBPmn4s80m6KaXol3Lwy/VKfzWYuYsJ3L2i6dd4J4M/GoV2rvh + kpdltYBawJ9d+u5qOfi3gbwznTS3oy6gbHz411Vtr6pH3a/69y2A4jQ1E7Xcrso7UB4s6EwSRP7VNOZf + FTN3E87K509rRzxp+DWYm9ru1di1L6xf+MP3kdNfgJm/aloF7knBr3mfnf48WLousAXUAv7MVzLT4EL4 + HxL4XZ/R22Px4MDGR35d9TarCYIr//1xrK+MAoj8GpW3AD9GUWwg8SRua7ziTnBXXom0zJvyzlhV+DOv + jcGuvQriHaUNgtMNv1WkpRP39OcHK/tmMvwEWoB2zEVPv6xEYFCV4A/bUFzNrpAOLpQfg7zFGvm1qy2o + FTZUweI/ZQIAYO3ntgTbp3sKsEUtb0X5NMiwxC0SqaH6r4rEuwOf/xT3xZrAHwar2HkbsfNPI5tfql7g + D41/zpJNOIvXT5vArRr8mjf1Ou0SaO0K05RVH/6AQg20AMswyr+g8jbQx42nKD4bHrmzZm1X04W3a76w + BRB8k0SQg/j8GUbfJ63esdqCaTFz1iPda2YH/JnfNbVjl18QPLZ6gh9ADO7a85F425QKgJrBn3m9aBW6 + aE2h7aWa8If/JWp7EN6vvvlTRA/4g+1YETY+endN26/mK+/XfPFxXJsEdXCWJUYjG4Z+ZFq947U+r1lw + BhJrn7LOWFv4c8f8haejYwKDpj97r8Rag8QeU6hx1Rx+VTTehq7YxMRJQ04c/lAA9Lpzkz9wulKj6vhE + gU2P3lXzNpyS1Bur/nM3kY39mDYfVM5EWFjTbuE2Y+ZtnrLEIlMFvyrYOWvQljl5doA6yNuvirTNxSxY + PeUCt2bwZ35nBLt8YxBEVi4a8yThD18vAjlTYha3y2fd0z+eknacqtw7GY8HwMVAay1PJNFmTNfUWKKn + En5FsbE2tGNp/cAf3p+ZsxSJt88u+DPPbcFytCleS/hBaVOVi4MI/6krUyYAwuS4bcAFte4eEm1HmufN + OvhVFXXj2PbFQb31AH/42nQtDvL169S0+ZTBr4ptnwPxtqKGqir8mXouEEurTqEImDIBEJa5wMaaC4DW + +RCJ1/gsUwx/+Nq6EWzrwmARSV3AH2TcNJ3zg4y+swn+zPFYHO2YWxStV3X4QdkIMncqjahTIgAOfHR1 + 5uV6YE7NTxhtC9J81aghpwv+zO9stAWMUyfwA+JArLWmBsBpgx9Q46BNrYUVVB9+gDmorkdh17UXzR4B + EImkMyPWZoJpQE17irhNiDi1qn5a4UdBI/EAunqAXwHj1FT9n1b4NRQA0aZaww9KG7DZqhJ1pyZP5ZQI + gEQihggusGlK7sqJ5KK3ZhH8uRHJHdt5pnOXXpGgzWch/GgQEITj1hp+NNhJcJMr4o4k0rNHAITN2QKs + mpLT+alctNxsg18BL7y/eoBfCWLlvdTsgz9zzNpgs9Hawp95vcpXmnWK7ABTIgACM5G2AMum4mSaHkW1 + ekuN6wl+BcRLgPWnH/7MYWvR1GhVbQB1Az+Ab4MNRGoPP8ByQVqnyhk4JQIgaEhZCHRNibhJDoBfnUSj + 9QY/CpIYDFeoTTP8mWuyPjoyWDUbQN3An/mu7yHDgxQku60J/AIqXarMn1UaQFiWA81TcSI7fATSw7MP + fgAviRk4NA6oUwx/+Nr2HYa0V7U2rxv4ESQxgvT1BM1QU/ghZGTFVEFZcwGw75+XZF7OB5pqf0sCySF0 + 6PDsg18E8RKY/gO5R1cH8INgew+iqcRJaV31B3/QRNJ3FBLDlNw+rLrwQ7DD1nwUdl5Ue1dgzQWAOy8R + bIMU+P8dpqBoahjb++wJd8a6hD/sbDLSh+nbX1fwg2B79qHDfbML/gwkB3cjoyNM2vMyefhBcUNWcFK1 + twPUXAAkn+0kGmQ86a49+WGDegnskScC482sgT+4NefIDmSkl9Kj0TTAH/7XwV78/TtPSOjWM/x4Hua5 + bZBOTgX8mf/dbtyQaql9PvWaCwABEr5Eai4AChreYA8/gSb6J9Uh6xp+AGtxDz6BJEuNRtMFPyCCJkbw + n3ti0nsA1DX8IsjIAGb3U0XtVlP4Abq9Yc81U6Av114ACBijLrWMABzT8II99gz26FOzB34RZOQ47nMP + jL3v6YQ/ewOQ3vEAOtRXsdCta/jDNjd7dmAOPpcDuvbwhxGBEilIQDJjBQCCqDFAdGrgD/5roh9/1525 + VE4zGf6wM7oHn8A5+nSJDjTN8IfXZw88jffcExUJgLqHH8D3cbfciwwPhJGlUwI/IDHBmKmIBai5AAg6 + vNZGAEzQ8N7uO9GB/eN2yBkBP4CXIrL9l0EMQMH8vw7gz9gBRgZJP3YHpP2ZD78YTM9BnC33jW3D2sIP + EFV0CjbMm7pQ4OoLgIkaXgz22DN4T98+8+EXg3N4O5Gn76xT+HPn8rbcib9ve9meNSPgD7/lPHwH5tBu + wJlK+EGJomKYAgkwBQJAQESA6i1vqrThfY/0k/+DDhwaowXMGPgB/DSxLd/HDBzOS1FdZ/CrgBjs8cOk + 7v8heP7MhV8M5tghIvf+pPA+pgZ+AlZ0SmKBp0AAaPBEIF2t6ipueDHYI0+RfuJbBbaAGQW/GNy9DxN5 + 8qdloa0L+PM+Tz34E7ynHy3cyWymwA9gfdy7foDZ+zSImWr4QUmjRmeFBhDaACyQqkJlk2j48Du+R/qx + b+Afejy3f+WMgV+Q0X6afvNlzNCRYPSvc/gRQfuOkvz5l9HhwYI2nxHwG4PZ9SSRO/8nWE8y9fADpAS1 + U6ECTEkcgATe4ZPTAE4E/lAL0P79pO/7LHakr6CauoYfwFqij32byDN3hfdT5/DnCYH01rtJ3vXdYIed + mQK/CDJwnOgPv4j0HAxG/6mHHyClitXZoAGIgigWSE45/Hkd0nv6V6Qf+hLq+zMDfjFEdt1D033/CV6S + 4tj/uoU/vA5NJUn+7Eukn7wfNTMDfjyPyO1fx3307umEH5SkKv6s8AKoGBCTBgamBf7MMd/De+jLeE9+ + f0bA7xzZTvyOT2EGjpBdQjEj4A/vXRzs8SMkvvsp/D07S0wF6gj+8AIi9/+UyM9vC1T/6YMfhQFrOPml + lfUgAHAc1Et6wLHpgZ/c3HSkD+9//xF/58/rGn5zfA/x2z+Gc2BLkPtvpsGfN/3yn32CxNf/Af/wPlTq + FH4R3Ed+TfSbn0GG+ym5zmLK4BdAjhkVb1ZEArbF54IbBeidNvizQsCgg4fwfvlR7M5fkjGz1hX8vbtp + /tlHiTx7LzNL7S+CP++e/G33k/zax7CH9gRCoG7gD+7HefhOov/9CeTYYca4LqYa/uCmelFYOQVpAWue + ejSRGsy87AW8is5ZC/izUt2gx5/D/9ktmMQAbHo56riBsWqa4XcOPUnzzz+Ou+t+subTmQy/5n7rP3Yn + ycQIkVe/H1ZsIrOxybTO+X0P9/7bid32r0jvoZzLbzrhD4zlvQBHpiAxcM3XG/3D7Yd53wu7ARYDNzJR + RGAt4de8h58YRPc+CH4a5q5HI/Fp8/OjHpEdv6L5Zx/F3fdoOArNEvjzgNOjB7C7nkA65sG8ZUG67emA + 3xhkeIDoT/+b6Hf+A+nvoS5G/qCMgvwnsHP1vffOfAEAZARAE/A6oGVa4c+8FoF0At33MPTuRrtWoC3z + go46JfAHkXMydJSm+79M8/9+CtO7N5zzzyL487QARKCvB33qN2g6hSxYicZbUJUpivALVf7d24je9mki + d3wXSYzUE/yg9AGfAo58et++mrM5NbsPBG1/RJVjBKnBphf+/Mb3PXTbz+DQU3DWzejpN6Kt88O5qtYA + /gAESY3g7rqXpt98GXfPw2C9mW3wmwj+7OUbdPA4+oP/hz71G+RFb0BPuwSa4kG7Wa3Bwp5gOiV9R3Hv + /QmRX30bc3hfrj3rB36AHuDoVHE5ZQJAlRFgL6U2B5kW+PO+I8DxPciv/xl2/hI97XpY9wK0bWE2EWQ+ + 8JOHPxz9JMjo6+57jOhj3yHyzF1IYiAcgWaBwW8i+PPvw/ro9ofQvTvh9Evh4pej684JNYJcO58w/BK2 + ubXI8SO4j96Fe/cPcXY9BV56uv385eAHZQ+qw7XY2Gb6BIAKqBnG+M/UFfxFHgJ8H9n3MM7BLejj30LW + PB9/5aXYuevQWHvOjZU/MpFvzJK80+ceoKRHMQOHcJ/7DZGdd+DufQQZDd1NYmZOhF814C/yEDAyhN7/ + U9hyL6w7B06/DDZegHYvglgsbFvJEwJaGM2J5J0mELKoIiODmIO7cbbci/voXZh9T0M6BL9+4Qd41lVv + 2J+a2fnUCICUHyXmJn2FJwnCgk1dwU9Rp/R95OATOAe3Yh7+L3T+JvyFZ2AXnIY/ZzUa7wQ3jhoXFSdY + uakK1kesD14CSQ5h+vbhHn4K5+BW3ANbMQMHgx10Mp2wBLSnDPxhPZoRliOD8MgdyJZ7oHshzorTsCtP + Q5dtgHlLoKkFIrFg01djAvCtRa1FvDSkEshQP+bgLsxz23B2PYnZsxMZ7Av2UCho87qF3wJPeiZiI6kT + D5ytOwHgGD9zn1uBQaCj7uAvEASh+qggw8eRZ+/CPHs3RJrRaCva3I1tW4RtakfdOOpGg80j0glIDWMG + j2AGjyLJISQ5FO7iI4Hcy9+09FSHv/g+jRMI3yN74fAenAd+jhNvRZta0I65aNd8NNYM0SbUcSGVCsAf + HsAcOwyDfcjoECRGw4pNmJNuytfznwj8AAOobAXFOlOjAUzNRAPYe+saCLYG+yXK2rqFX8erJ3dxWhzN + UnB+Kfqb+DynNPzj1TNmp87S1635bS1TmsCzWvCDslOsvgCRfet/U3sXIEylFyC40d5wGrB25sEf1iGS + 4z2zU0z+jjFSJ9t1zQb4M+0gee0qY5+5lm3rmQS/oNHo001zuvseesV7ue0f17O4q5nhZJprzptTMy6n + bGsw31rEmGHgNzMT/rDzTvB5A/4qwl/BM58t8APsPf/FZ/zsDz71wcTytddGIqb7zq2HGRzx+NWjx/nJ + A5NfSlNXAsCIYH0Lyv0gAw34G/A34A/vWRUv2szhlacvTSb9PxoYSd92fCD1vRXzW/7QdcyK3/+3BxhN + +fzysV5+8mDPzBQAy/762bDBZCvwXAP+BvwzFn6qCD8gqox2zmVk3lJEFJS2dNo+bzTp/1P/SOoHf/u6 + M/7cMbJiyzPH8XzluV7lV4/3zSwBEHQqg6pzNNACGvA34J+h8Gv14M8YNQeWrMNvacch0JZDj6XxrZ6e + TNmPDCfS31u+oPUPXGO6H9x6CGttVbSBKRUAI6kYJki09guURAP+BvynPPwofjTG8VWbIRLJwm8k2BrE + hJHjVvWsZNr/xHAy/dWmqPOCJfNixojwp3+ym/99anIr7adNAMTcdJicV+5R2NWAvwH/jIFfawF/Rv1f + wOCy9cEa0CL4g9dhZn0h4lt9cTJt/+vpfSN/6Tqm+4U3txF3HH695Xj9C4BVt2wL12XoAeDOBvwN+GcM + /FQf/szr/pWbSLV35wE/Fn6TEQzBGoEFvm//ZjTlfc6NyBl7j6UwrsOdW/vrWwAALP1rUB8P5afASAP+ + BvynLvyKF41zfM2Z4EYC6CeAP/MdRBxVbkx79qtdze5L/uiaTxNxhHufnJwQmHIBcOjvstrU3SCPnwz8 + WmX4tSrwF3a0CWGYEJZCUHWSv6mkzmpc2/jC7sTboLbwV3ANEyfwPGFBjlWGFyxncMUGHNGK4RcRHCNB + bJRyhufb//j4D//gTUs6oo5xhHu3Vy4EpiwUOL8891drkFgMTaX/Arg1jOOcFPxVG/nzzqVl1wZQfvQL + FrHnhQPnFp3oCWo05Tq4noBQm2iEq0xAVX4erQSE8c5VdN9VMRSXFHgTaTOT1BYnqzGF17n7mtez/8ob + Q/AnB3/+dMExciziyl93dEb/3+ion1YLF29on5DFKQsFLihG0GQagR+q8vsoyypqvJJSV8dVRwueermR + hDC2f9zOXVRHuGhdmjtxlp2BmbcSUqN4zz2OPfwsqpby23jruIKo4AaVEsJknHq0eOTSyoTneO1TwWhZ + 2UhY+etqak4Vj/xlQR1HkEzyOnIDhyXZOZ++jeciRjDoCcMfbL3JHKt8ZHAgTXtb7N8TCc9/4OkhLljb + Oi6K06IBAOz+i7WgRBH5V4G3Tk7FPPmRLx+kkjuwlBNEeeC76y8leuErcVacjcRaQH1s7wFG7/gyqfu+ + ifjJvOs48Tm2Fj+yE5nzjxEmUkFHr2y0VSqBqVpaxOSf+eTm/NWwc0z8jMQqhy68ml03vA3Jzv9Lwy9G + xhgHpWi6kP1vpNdxzPvPXd/2xa27R9SocPbq5voTAKrK3g+sx6q+QCy3gXRXNCqEjS/V6rjjdjgZA75p + 6cTdcBnRC1+Fs/IcpClOwQo1A3Z4mP6vfhB97PuBwaaylWAlvzcWrvyRvdCfXCBs8r+Td4OqRbsLo0Wd + Pr/ecjBoHqyTM+gxQVufkE2i3HkqNfhNQgBoqcGn7LPUMn1T8Zrb2f6G9zO49kwcNM/9N0n4M4bD8Heh + lnDAdcw7Up73g9amGAKcsSpeksPpmQIAT/3RSlqiEYzovVbldlRfU9mcn9LGFybfcSoy+GVG/JYuIhuf + R/TCV+CsOheJNQXpG2zR+S04LS04F9zE0Xt/TVe8L8zuJIWwlYO2WOCNucaiD0verxZOVUq1x6S/U0Yg + l5pejQFOx382IRQ67vOTscIqe31FbVqg2WkJAaQlplFS+nNydWi5TjfJ6ZlYpX/tmQwvW4/Jh1/AEEAs + oWpfIAxCwA0UCIggRCD8LFg8uVhV/z4ejRzwrP9wpxsvy+G0CYDTPvEc+29dSfpYZBTRL4O8BKW9ZMNW + YvCTMlK+DNwTzuFsYNgzrd24Gy8netErcFaei8RipcGnULBEF6/g2FAnfn8/cxeAER3bgZTSpJ+sq29C + ICcSkFr+PJmRuhz8WgqmCUZadOw0bIw2pxNfW576UHpaUkZ4lqqj6IJ0MraMkvDnBIMXb6HnnCshHsdg + c/AXje650T9fGORBXzANyAmN8O804EMRx/mdIU0d2bp3lM3L4vUjAI4NKqYVhj/3h6Tv+dIdtM25HXhV + qYczaWv/BN8Z0zmya83DHXhVMa1dRDZdTvSiUNWvAPwCRKzFSyuHjxjEKHPmaKAJ6ESQnoBBrYLvaZXq + yT0TreC74xkpdeL5doXCvHLXIRXUVwyyFAq78YTruEIxvF+19K89g6E1m3OGvwy4JeAXkw91HvSm8HeF + hsHM73ixou9panb/xktZb/uhFBsWRqdHAPT2KskuiA7l2soOQ+y1n3Rb3/pJM/jZ3/+BDva8WFq6WyTe + gTS1ghMFJ8IYU4WWOclEU4J8b6P1g/x8yRHscB/afxQ72AO+xV13EdELb8BdVTjiK5UZTVQg3d+HTYzi + Wzhy2CBq6e7WXLJXrVTlHzsalfZTlwaywGjKBN6QCjwCWsF3Khol8655rHAqc70lhb2OY/Ev/50x91yu + jSsWJOWEXf45LOnmNo5efC3a3Byo/xlV3xQLgsJ5fUGQUN53xwqC3FoCETEi8g4v6d/t+/qjSGws7jUX + AD1Dwd1bAviNYKwwF2UDcLaB0/1h1je/4V9Wa2KoCcdFnEiQ/DFMpV1xmcx3M/N730f9NKSTaGoE0kmk + a3EWfLWVyZ6CyxBI9vRgUykEwfpw9IggKJ1dFGoCYzQdrRyichpPAQySM5hWCn+J72WuTVUyZtiikV5K + wF3O3lHahFG5wbASUGX83xZcU4n7GaMp6lhhW9Gy4cKT9m2+kKE1m5EQ/mJ3nilS+4vhlzxVv+B3ImOM + iGFm9DmI/Gkkah7x0/7BHQdSrF8cra0AODSozPOh1wkbYwDoYAFwvlWuQbkMWA10ELhAg11y4u3lH3Cl + UE+qCIHAcSEaR1o7c/X4JyBU8q4heawHm0oGP9cgL2jP0aCzdXQWOc9Kuqsm6uSVzPkpE0xDBXCUuzYd + qxIXX7yW+bGW4O+Erm2skNByxtIJ20/LSCNK2GwmMmaO85m1pDrm0nPJtRBrys39TWDUK4A/NOoVGv/I + CYPMlIAShkIKPwtfP0+UN69eHP37XQfTqGomdqC6AuDQoNKuMAwcd0CViAhn0s71KC9V2Ai0VvSgp6No + hccqqCcQACkck9t8xPrQ2yOIKu0dOU3gpPz8Ja5TdQIQykJQ6rxSXjhVMn3Ig1YYxxYxHmT54I9nMC1u + m4m0g3GF0zjtVirIagIBo2LoPf8qRpevywv6CeE3RfCP0QooOyUQKTIUjqkTjOCI8NbnDqW+b0Se3HXU + y15m1QRAz2Bw9yPBIBcT4WIjvAl4CcHGoKdMUU9JHesJowtNrpcGG9VwvDdAob2dwoSikx5dxvHzT1RH + hd/TcesoBW+JmIICprXIJlGJqj6J69N8l1CxG1LKX2uBq6+S9ptooNDsacQqI8vX0XvpteC6oesvHKVN + nsGvyKiXD78UTQkkD34JVIhsnZh8r0BWMKwT4c3xWOQDybRvqyYAeoYUY4LRzVGML5xjhN8HbgDmnkrg + ZwYHP5kkeax8thbrQ19v0Efa2vO6Ybkgk5KdvPC1TiRAJhkzkfW8VFRnGRqLrlnHnoCy3oAx72USwrFs + GGWRQNCin2g2sEkq8TSVaTcpuATFb4rTc+UNpOYuDIN+Ql9+EfzlIvykXHBQmZE/Fy6cqzOs/+ZUyv+y + CFv3HbMsnWNOTgAcHQzu2PPAGBZ58HbgrcDyUw78fMCTKVI9PYy3v5u1MHA86GgtbZkxaxJW+pIQVAIS + E08NioNeTsTaX3Q947vmJvBynOy1TGiTkAIbR+nrlbEVjxPNmF9f3xmXMHDGxbm5PkXquxSN7vnaQP6c + v9DPXxAslG8PkGwm9bzvBbaBVUbkVcvmmK37eoMrPCEB0DOi+InsW0eEF6jyAeAKpmGJcb0VP5EgeazE + Bq9a2F+thcH+YMxoaWXiDj4hcHkvxlV3GTcqrzI/epEFvYAaKSFsZJzPqUC4jfdZnto/xq4xcdtVZpCs + QADlnzZ8wMmFy+l5wSvQeHM49y9U3wut+Ix1+RVF/0merSBfMBQaAgs9AYacxiCGV+47rp8TYf+BPp28 + ADgyGIxT4oJAp8I7gXcDC0518HMMCdHObpL79xSO6mOnnFgLQ/1Br2lumditN/5nFajiE3T2iq3zBb1d + y4JZPLIWCo8KhVnZz6XEveskBEcFHpKK2j4ngPJVfxuLc+SFN5Fcujrn8y+auxeM2ibfuJdnD2BiW0Gm + XkTHfha+D3ZKk41GeL4qX1VlcluQHh4IA1mCre5WK3ycQAC00yjZDuI0t9C2aTOpw4dI7t8LBHaSzAY3 + kg0AyXkCvFRwzHUl6zqcqCOXXNJb8rcVGgYnfF/JQphxvAYVvy8tCLX4WialJZQ6XsE0ptR5KPMsir53 + /OKrOXbVKxDXLWm1Lxili+DPhveSWexTaCswZZYFl/zMFNgRXBFJCPJDEfyKBcDhQQ2erQURzgH+Bbge + pmgf4xlWYvPm0nnuBXiDA4zuehqsn8nwGs7HcgIgSJMY2lIEXLcIgnE6tFKBwBhHgMhEKv9kBUDm0MlM + ZcbRDgpWgpatq7wAEcaN0ykhHIo9Cvk1lf6pWMvI6k0cvvHt2I7usvBLgVGPwuMmXBhkyHMR5guLwteZ + vlXqMylyMYK2ifB9FY5VBO+RwTBqKQ3qcAXwbwKXlG6KRskA5bS20HHW+WgqyciObcEOwpIJ/MjbPjQv + 4NFLBVA6GU2gGFrN7+SVeA3C9Q3FG5Zq7vc6oYdAqCgcO+88QcRg8TknL2S0LJxF96VSvk1KTnPK/VYm + jLMYI2TyP7eWdNc8Dr3q90muXJ/1+RfM3U2+wY/MOv6c/744HqD4s/zFQVmhUcJjYArtA5Lbz7IZeBh4 + fEIBcHgwcIz4PuDwfOAzwBkNzCuTBCYeo+30c9B0mpHtW8HzsoYb8uGXnNPA9zK7WhcCWlIFriR4qbjz + llrfPm4dMikNIz+wLvcnuY1+yVtpPc77cUOFy17D+J/reAKsuA6doE3yj4UXbKNNHH3Zmxg874q8UX6s + Wp51040BuMRqwKLP8gOFilcKlltFWOSQcoCDHvLTcQXAwXDkVwvGcFkI/2kNsicpBKIRWjefhR0ZZmT7 + VsTaHPxSNDaHTmTfC5R745SIoMtXZCehPo/t5JLT4CYTM5A9No6br9J6JoA2p/ILZefjJXILFAckacEy + 5hJaa0X2BBnr5y84tdB/2UvpvfomJJKX5bdm8EsB4MWrAU1p+DPFN/DdsgJgpyqpKMQSgHB6CP/ZRY+r + USqTAZhYhJZNZ5LuOUri6e0F8OfvgJ0TAmD9nBCA/FReFcJfAbjjd/5x1OSic+kJ1TNZgTURoOXr0InU + +iLBWHpqUOLrmSQfqgyeeQk9N74NbWnPBeWUAFzy4C8d+ju+wU9OfOTPL67Aj8u6ATuOgzVghUWi/D1w + AaWSsjRKRRJAfXDa21n8tnfj9Rxh6IG7yDpti1zqWU+2hVTCompwY0XQTAgM5YUEjJ8BOUfNOHVXbhAs + X095qMcKFJ1Yeyj6TU5zkkm0kY7bbiU/spbRNafTc8Nb8Du6s6G+ZhLwSwXwZyP6Cub2hUuIpTL4AdoV + Ti+pARwcVNQAQlzgb4E30Bj4qyIInLZWmlasYfjxh/D7erOuHsi5CDPdLTMdsDb0HJiCbn0C1vXyPE44 + ypY7VvIccoJTivx/cuLXkOchOZHzFx4rYe0vSO5pSS5aydHXvIvUsrUIOnZhT1YlZ4yrT8YY9Ur9rrgO + KVwnkDUW5lYR5hn8SpOrRIBtYwTAgd4gOsAdBI3yZuADQLRBb/WEQGTefJyWNoYfvhdNp8IlmxKO/kWS + W4L1/OrbXCBJQceeQDUes+IwX/UuoVVUPI8vricrtiYBmOQlaM3/baXq+vj3o5OCvJS6P4FAtBZvzkKO + vvoPSGw4O4C/FMTZUb/QUi/jxfaXdPmVXw1YwZy/VDkwZgogrUAC/FbOAf4MaGlQW/3S+fxrGX3yMY5/ + 97+CFWN50yspE03rJS0OgolUCAkUpDBTyiTWHC/YpSww+Rc5zrxwXAFSGEas5cKEy9YnpVf1Vdo2Za6j + XLhysa/f65xHzyvfwejmCwrgL4zZJ5OeK/DBl0jxlYvWCwX+mM8oiuwb+7vM64nilorK0gIN4OCAomlA + aRHhI8BVDVRrUyTiEFuygpHHHsLvPZJL4gBjBuXsdABQP1SQTaW++SL4ywW0VCwAiqGbQICUq6MIVB2v + Hj05cMcVIBUKxEKDn8Vv7+bYq97ByLlXFKTuLlDthUK1vUT0n0j5xJ+moI6qjvyZkihcuOMEqiaiNyr6 + Cg0fTKE/t/F38n+KWogsW0H3TW9EmuKFOxOVGHnyU9fZlGLTmslYnvuD/EzmecdCaLVE6uviWILiiy04 + LmjoUsveh5bw7zPedYV1qOQdL7628a6hBPwlmm3iPyn6P/5frnKL197NsVe8neHzrszLw1d65M8Z6YpW + 9ZVYE5CNDzH5r8fXGIpH/kn+dWU1gP19fuAfdWQJ8A/AqsY4XWs1QIgsXEJy5zbSe54NekvxAEVhpGBW + yvvFB0qPekoZF12Fan8uzkWCoUBPcuQvUtk1bw1+ZaN/oXqULxiz1ziu5kHl5yo+porfMZfeV/0uIxdc + hRgzdiVfkZ9fxvXlF3kJKMzkk5/uq0BjKGFjONEemLUBiEoQH+TzajIuv0apbVHFaW+n64bXMLrlIXR4 + sLCfFrgHQ2NgGP2vAng2TKdocqnNS/VlzZu2V9LpxwiBEkttmcw8O3NTud8Vb9oxYYQelF3lWGDgHDP/ + n+y0oJRwVLCKN2cBva/8PUbPuaxwBB+zOo+80Tkz9x+7cq/kij8pWicSSv+CkT+cE57AnL+4RB2AfX2a + eT7LgI9yiqXwmt4iuHPnk3x6G6ndT4cPduw6gQwmmV2Gsthk9iAVKVBnJ+wVk7KQl5jzTxaoceCflAFy + grY8Ofhz0ZGa2SKCYB6TXric3le/k8TZlyDGFI7MZfz8E0X4SdGKv5xrb6wnQGRSQT4VD0EugFWIGMWq + XEcjzn9qiyqmuZmOa25g5MG70ZHhkhG/GRdh1lYQfiaAhpoAxsn16RNJcDoeuKWMbBPVWdbafwLAT/Y8 + E0WsaYk71dLLGpMrN9H3yneQXHd6QS7/UiO/MWM/MwVaQN4IHk758vP5F4/u5bwEJznyZ0rKOTCQGTNM + t8IHBVY3VvhNIf+Eq/+6uhnZ8jDpA3uDuSWlNADy9hnMex0mngRB5QTmuSU+V8qM/OPVOWaaMV7o6Dgh + zZqVeJUHHpW8PqlYsJTJ6Uli80Ucf827SIcr+8ad8+ct7ZVSXgFTeuQfGxtQHANQ9ZE/UwacweSbufLK + LoAXEGT2iTWwnPoi8Tg6NMTIQ/cGMcAlon5zX85fKiw512FoYLMi46yyk7F/OvZY4ah9AkOCjmOpL7VG + oCAISCaUUYWrDDWYAo25Ty1S50usTixpNlA0EmP44mvoe9U78OcvKR/eS2lXn8gEBr8SAqSkga96Br9S + 5YD7f/7PakRwVPVlQFsDxekrzedfgjNvAf6h/WRGQNW82IBiY17+IJk55tnAnWtMCcNaGSjLjqpQ0eKP + CacOlfyugvl6AaNSeL6SqcFLx8COmzzVWrSti8EX3czw5S+DeMtJwy+TgL8guWdt4Qc46oZ5zBYrXDm+ + d7VRalosuIuW0nTa2Qwd2AdOqNpLcRBK2G8l8Nzks501FPo2HN1M0TZ7E+zCciKGwzHfKae6aFXq14nc + BcUrJkt+VuZ3avEWr2bg5b9N8syLEMcJ9KFSufgY6+cvztYrpijTrymc/4+J7CM358dU1dpfruxzw+dy + PrCynjbpOfWKYpqaiJ99IUP/+9Ng84CsDzAEntwClzFdvCBOVRFrESPY/CTN1QB8wu9pGd5LaB3juSbl + RK+3aJlxJfVYBdcleeblDLz49XhL1wSjO4Wx+IVz97Hwj1Xzx1vxVwh/fsafKRj5M2W3m+gUifXpJUBz + A8JpFgEK8U1n4rR34fceDQODQuyLs1wXW7FlbJJQ4/uoAV/M5EHXceCtlsCYVFJPqex0k6mTIKbfdnQz + fOWNjFz+crS1A4MtyrQ7duSXchF+5az9RVGCZOMFcrv5SOhKmIKRH2AE2O5G+7Uz1AAaZdolALgLlxBZ + thLv2JEA+gqlf4GtIK8+scEqQitm3N+WL6Vi7iu8oEomk5MWRmU+k/FuRMY6NFTBGFJrz2To2teR2ngu + 4jgYtTnVnSIrfihoc0tyw8SdRZtxBnn4CzftyHwvm7ef/Dql6PPw/WTae/JlENjqAkuBtQ366kEAKKal + leiq9Yw+fD9qgkwzkBMEkp/RVwo7eemsPIohsAlYMRVp76UPahnoGB+6SQi/8vWV+KAi9yClDX7Wou1d + jF78YoavuB7bPS/r/2CcGP18Pz/5oz1l9uor/l525B+7dmCK5vz55TmBXS6WzQidDfrqpEQcoivXQCQK + arMuucxoEHgBpMDtN5aXnO2A0D1mCOqyE47KUgGQJaAbL9y4UoGj41xLpabpcW0LFoyLt+Eshl94M8kN + ZyOuGyzlpXBd/th5fWGQz5j4/aIFOmXdfiUSgkzhnD+/POr70uuqsIkpXPOfnxFXNZhPkV05prOuvkmf + XyGyZHmwQnBkiOywUTJNLmO2GysERgu04gB/U2gTmATgJSNty76Xsdem41VWKEkm3dITbB0mgD9nEYlL + X8roxddg27sxEqa7p/wqu1Kx/cXwl/9d0fqAcM6f1QqmZ+QHSAP3iqNpF1gNmJr5/zJ57kSwvs+RIwfZ + s+tpjh87iu95tLZ3sHT5ahYvW0Essyx2gv6RX9/RI4fYs+tpeo8dwfc8Wto6WLpiFUuWray8vhB8q5aj + hw+yZ9dOensy9bWzZHlQX1O8eeL6Tra5FNz5i5CmOHZ4KMeOMGafgPJegML3mhcxaFCs2rHTgZOZi+sE + B8ut6Cs5UsuJXUO576qF5jYSZ13GyOXX4y1dE8Tyh4uqDPkbc5baqLNozi8l5vxSIg/AmOOMsQcU2ADy + g7tq6YsP6j6kcL8ArirL5EQat3L2EYS+473cd+ftPPbgvfQfP0Y6lcKqYowh3tzCmvWnceXV17Fi9bos + COWXdgj9x49n6+s7fox0Kjmmvite9HJWrlk/cX0iDPT3cf9dv+DRB+7m+LGegvqa4s2sWruRK6+5jlVr + N2a171o9I9PWgWnrwOs5kpcJJE+7FfKcgYyx0UnR9t46ZnecIBbOMlHiuBMBcCL//AnCPNliLUSa8Nac + zujl15HceC5Em0LwtUS8fuGcPLt5ixTN+cfZpTebrC1//p8N2y6uI2/kL0pZXvO2Ue5F2aWA7O61TwEb + a3UuEeHY0cP84JtfZtsTj2CtzRvtFFXFWou1lnkLFnHDa36bzWedX1bdFhF6jx3lB7d9iae2PDxufXPn + L+SGm3+b08+5YNz6+np7+ME3v8zWxx/C+n7Z+ubMW8D1r34zZ5x7Ue0ejgj+QD8HPvAuRh/9DeIYpKLx + UUr3G8kkBAnqzoYGi+BjgrDhE+lsWuL0J9ppq9XZMzfnuvhL15G45KUkz7gYbW0vWMRTyl9fKsJPKojw + Kx7tC+srvyZApn7Onykp4B0W/jNuBBforiX8idFRfv7Db/HUloezxzJgZf4yxw8f3M/3b/synd1zWbJs + 5RhoRYRkIsEvfvgtnnz8oQnrO3LoAP/zzS/R2T2HpStXo3Zsr00lE/zix99h66MPhIyUr6/n8EG+/83g + +pavXluiviq1mxvBaWunlOVbJ+VZk4KpQoEZQRUjQcpxW42RudLVeiJUvcfngW8XrSJx/gtJnHkZtnNu + MM9Xmxuh80b1kuvuw0vNpmErGMXzP8wJbMlbzlCwy1MB3EW/y6V2Rac28m6HCr8M00ngAq01m3IIbH/y + MbY+9kDuWRXBlf8nIhzY9xz33PEzXvG6t+A4zpj6dj71OE888puK6zu0fy933/FTXvWGt+E4hTlQxcDT + 27ey5aH78jLLlK8PEQ4f3Mddv/oJr176DlzXrc0jcgzEmsJ9AIssaJrreHmNUMJNLwVZv8iDPzM90Dyd + 0zLxIpyS4JVIpzeRa9A6kXDpcgU9byK/pSq4UeyilSTPvoLk5ovwO+cG8/YwWYLk7cKSv4xKQ6GQS8oq + eRGXBVkXst/LLsu2gAlMDDaT/gsJzmg1XMqbAT3jxQm0i6xvp+ROp7UtIvK9lfPM3n3HYW234GqY8rsW + l5FOpdi25WGSo6OIMePClf/35JaHef611zN3/sICLcBLp3lqy8MkRkcmVd9TWx7hWM9R5i9cXFCfn/Z4 + asvDjI4OI1JpfbDtiUfpOXqYhYuXVt8zoKFkikTGHxnKWNzHTCF1/FR7WZuABBGxk9blK9qGu7BYwEai + VJxVqMSXRBVicfzFa0iecSmp9Wdh27sCw152NWXgDlWR/DvNtVqmbUzo4ZE8D0TYHoGhUDN5V4Jqbai+ + Ww3gF8nGawi5HZeNDXbUzsQPqA3zt9RACapwQN4rRr+585DVqBsMrm5w+zWRNCRHRzm4f09W5awEMICB + vl4OHdjLvAUL89zZwXTi4P69k6+v/zgH9+9hwaLFhfUlRjm0f092JKy0vsGBfg7ue45FS5bWQH3TMHzU + odCVllsaqGVDc6VA29asbMi3D+SWwWbNgUphnEGlq/JKJQmqpD18DxUX60Yq0jmCgVJzJ2rpwFuxkdTG + 80ktX482twbzdqvZRJpjrouxAlMlNzIXOCbyNK9CcSi57dRDI6qgiA3m+1a0YGpBni3AKohoHvzTsOJG + +JY60S3i+Zy1ULICwFMlWotpmed5jI4MB+8rBFZV8dIew4ODY+rzPY/RkSEy/u3J1DcyVFSfBvWNDA+H + m0dOoj4vzXBRfdV8SqoW9bzSO+NqBd64/Hl/QeptGbPzbv57QbGa+55U8pAnNXJnBIBFvRQ23jrWvVkO + fDeKdi0gvWozqTVn4M1bApFoqF6H47OQVamzckzyvRx5Ow9kBaCOTX1gcr+xqqHtIAgWshkzhko2gChU + CrIJxXL+AM1OAHLHdVrYB3YL+kWTTPhdLQ4SpgN1VRkFotUeyYLwSEMkEkWtDSPSKgNMjBAN58D5GbBy + 9YUj4WTqixbVJ2F90Wj4kCuvz8jY66tqw/kWm0qV1K7LJ8mRskwW/7fkjf6hkNA8G4ItqHOSFqJKJUdy + FNtisU0tlNnNM5jmtbTjL1pNevkG0kvWoC3tuYxJVgNrvUrBnopSNpuKjMltKgXDvBRFM+Y2axSV3Jzd + 5qq2eXP8DPaimpv/Z0d+QcQyPUVURP4z1h5/LDmU5ue7I9lPXKAP6Kj2KRWINcWZM38hB/c/F8ykKoDL + Wku8uZX5i5YU+q81qG/ugkXs37trcvXFW5i/eGlRzgglFoszd/4i9u56Gkzl9bXGW1iwaGnNBLn6Pv7w + UNmVssXbfOWnwtY8uPNzchSk984L282Mn+SN/IXnkRN7+BNJOd9DhvuxLR3BBDnzkI2BeCt2zmLSS1bj + LV6N39YdjvYBTEHGpNxEWkTz1vtkRnrJ6jGFuYfzd2HVvIzHpSRxDviMoS8Y+fM3MwtHdi30KEje/D/z + 2fQURYT7jcvnRwdG1TWGd5yfuxhX4RiwovrnVaKxJtafdhZPPf4QnudlwZsIsNXrT2POvIVFnV2JxmKs + O+0snnj0Abx0uuL6Vq3bxNwFi7IpozIlEouy7rQz2fLw/aTTqYrrW7l2A/NCAVULIWDTafzBgZIjVi4z + kBQsgMvN/YNRTPNI1qLjxVOArGCgUAhUxPKJj0rI6BBmZABv7hJoasHrXog/fxneghX4bV0QjeXyImo4 + f87unVgQCpUNwMncS36mJMmPdchEUlE0yo/BRjEF+ZiDub5IBvh8N6JmDYHBSJ/3n2mc8wc33G8M/+CP + 2L2mxfC8VU0Fn7rAAeDcWp1+89kX8tiD97LjycdK+tgL4fLp7JrD817wYqJNsTF+dlU47czzeeyBe9j2 + xCMV1dfR2c3zXvgSYk1NJevbdOZ5rNlwD08+/lAF9VnaOjp53gteQlM8XrM4AJscxevrrWwZvoyN9Kt0 + MC70CIy1ktcqJjVMw9frqO520skHEue/8NqR+atW2XhrMNJnwAlH+ny4c3Vokd1Rcnsq5i+SCt9rWStl + fnrlTM1B/gWbHycQVmvCixfRIiGQl8Q1lBsGauRfr7wY0S84uD9QJ/BKFBcXeK5WJ1dV2jo6ufaG1zI4 + 0Mf+PbvKQub7Pi2tbbz4xteyZsPpJeFSVVrbO8L6+tn33NNZkEvV19zSyrU3vIZ1m84sW19LazvXhNe3 + 59mdWaBK1RdvbuHa629mw+ln1wx+BPy+Pk9HRwQR5wR+Pt6ygDHfrfXYFLKQBnodIwdQ7neNPOnA/RH0 + 2Zc+/dNjnz7zC6/TkcRnVLXdaJ5BLxeCU/7isyKF8s6L/M1Xy914ZmPWrP4QHMxM+zOqvQ07XAH0mmf1 + z/tMa966E7S9yK9w5B/TeMlYxHD5mtYx33H+8M/+Zg1BRuCaRLUo0DlnLstWrWN4cIC+4z2kkslseK21 + Po7jsnTlGq579Zu54HkvwHHccS3dHd1zWLF6HcNDgxw/NrY+Y1yWLF/Ny1/9Ji66/IUT19fVzfLV6xkZ + HqTvWA/JMfU5LF62kpe/+k1cfMU1OG6ktqox+suhH33z//qJ0QfFSL8gjoAnQkTAzQ1uMmab7JLz9vwI + thKGMS14LeORNiHsBhICx1wj+xzhTkfkG03GfMUxfLTZkc+c1RX59oFR/z5gv8DIw+/5N7rWrN42mki3 + WKuXkQ2Rl+zon90MpWi0zRcS+dun5W+uUvCsixa9FKcXzL3Pm3gWJRvVAnuBFmQiznye8SjZafxTeMYY + 3p1K69b2Fvj5V9q4446/HfvMnu6xLwS+DsypsTRidGSYZ7Zv5eltW+g5fBDP92jv6GLl2o1sPP0cuufO + L2rgCeobHebZ7U/y9LYtHD18AM/zaOvoZOXqDWw841y65y2ASdSXGB3h2R1PsvOpTH1p2to7WbFmPRtP + P5c58xcwRueuTWN98PAH/+hvBn59B26UFpvw2hyhC5FzPWuXqa/zROR0YJm12qoQB1qBmAYmsULbQB7o + YzfDlAI7wBgPQf4YHEDlKyRRho0w6oj0Ac95qtujIkejRvb4yuOu4VhHRAafHkyPdEQdrELMCHEXUsOj + NC+cz1V33MFnf7wXEYi4pnNoJP2ptGffmMFaJPdsJH+fxPzjRQIim3AjIxqyqnne5/mfSf5rybvP4nNK + QZhvdtHPmOsTJthArWYlL2Skx3XMO4+PJr+xuCOOceGqjaXt/LKzxy4DfiywuZYXJnmS2fqWVCqJqhKJ + RHEjbhjVqRU1Ws3rs0oqmQjri+BGIpOq7yTbahT4LeC27ZeuJNLeiXo+JlzMY1X57mN7ee2Fq9o93zZ7 + aeuKmPkYXYeyQJVW32pEkW6BRQhdIO0KLQoRVYwiRlGTFRaBI80GO+CJL0JSkWFV+i0ct8phgb6IkaQr + 9CNy2Lf6rMLRZkfS8YiM3LZncOjKeS24oYSIGGhyhLZYhFTa46oHHyx7z5/7wV6sAXFYPJLw/9339WXk + KS35cfoixQpNKS2hMHa/ENxygiX3m0LBUXQdxecacw0ZcTk9+IvIoOOYDyyY0/KZ/sGEL8C1Z5V38smO + HhsX+Bzwuim82mxjVi2UNmsVr9P6Ki/7EK5BeWrtHMm2U+YR//Tic4imPNQI1lp8T3OLmIIGxbPCy69e + LXfdv6/J9zSqqq5n1bUa5H2wglhfUUSCDTVUwxVqKogag3VFvIiYdJNr0hf+eH7ivy49QNTJBdn5Grxu + cgTXgFUhGYty4333TLrb3/KrXfzy/z7OTW87k3iTu2Y06X/G9/XqDEoFcObZ9pCxo3wxoLnfSenfFU0j + xvyuhLApFh6FG7VMXxFh2HWcD7e1xP9v2kunQHnZOZ3j/2bnMQvKe4B/Ytptlo0C/Bi4GRhaN3fyUdq/ + uWAzLZriqGnBDyeoqgGwmcAlG2o5mrdE2OT1dhMubAmSWwrGWDqbRkl4ES675/Ga3PTXfn2YBYvbeOzR + wzS3RtclE+lP+lZfnAO6UEsrLQSKAoIKBELe6F4K6vwRHxkjAAoEA0WrB8NIQSqNoKxi0ZwPZDDiykda + WyKfSKdJgHD9+Z0TC42dPRbgAuCHCvMaEmB6Sl7H+UtP7Uei4rBm7qn1NL5y92Hmz2tj27bDxGOR5cmU + 9w++rzdp0UrcfBiz8/Uct2PALziWf7xgRM98qiUERwntoVgwTWO/MUZ6XNfc0t4e/Y9Uwk+pKq+4cG5F + v5cdPRaBdoVvAlc3UJzWcgy4DrjXIKw9xQQAwFfv7OH1l8/hMz/aS8yRuUnP3pL27VtUiRdY+QvALQwE + KhAGRd8vpSnkC5ZCDaK0AMn4FGXaH4/gGHk64pi/2LRq/rd3Hey1VpVXXTS34hpcR4WUsQOOlZ8ivKjA + DdooU1cCTe4hhK3AKQk/wBuumEvkzoOMJn3cZrenpTX6p8PDqac8z37AWhYTRgXmkrfkmi+3Tq8oDFg1 + u8oxuyRIi9yGaJEwKBIMBcBrGZfq1HUUEVHH8AvHkf/Tm/Dv3XWgF9/CTZfMnVRt8vRRJdxdfjPwQ2oR + FtwolRRf4T2I/otYw/r5DSn82Z/sxRjh7dd8m8/++MYrU2n9P761z89G6ZI/cuel8CihmksRsMV7KhTz + XFhP/qYMueCkqZzv50drOoa+iOt8LhaL/ONwMnlwfnOMpLW8+rL5k65XALYfVYwQsVY/rfC7DRanvgg8 + RaD+PyNIQwBkhMBP9xKNuPT1DtHe3jI/kUr/nufrO6zVxYV5e3INOSaUqRh+SpFbOjefjImpknGXMNcO + fjBgHcfcG42aj89tb/pR/3A6ffWm+dy36zjXX3Rimf0E4OB2n74OULgK+KbWME9go5R9EB/pSpm/Goii + GxY24M8v/3X3MVas7GbrlgO86qrFctsv917kefpuz9eXW2vbKTVrLVLlC1+WipSEknIhW5dM33IeIZjr + R5zPx5vc/xwYSB3s7oziecobn7/wZPsdbO1X/BEPgbgqn1fltY1uN6Xw7xKRG4AtjhhOW2RO+TYpVT7/ + swNEIw79w0m6O5vj/QOjV6XS3ts9X69S1Y685ftUpKKPN5KX0hqmsGS2fnMc82zUdb4Rizpf/u0Xvv3J + L/7qP5g3P8bQoMfNF88/6fNk7+sz2/dwaesiLPpCtXwd1Tk0ytQIACN/19ri/tXoqG/PWOQWBP80SmH5 + xoO97H+2n445TQwNpWhri7QkRr1L02n7es+3V6vqEjteRz8ZSKamN2AMCccxT7qu+U4s6n7rpssXbfvW + rw9qLO7ie5Y3n+SoX/LeHtifIIKD45pYMuF90qo2bAFT8rjZ6hh5pcIOxzGcvSTSaJQKylfuPMjrLl/I + 5362j1TKZ+GctmhP3/D6lGevsVav9X17llXmqaqZrO5e41DvsecL9gxIGEf2OUbujEWdn0Qjzp3/c+eO + wy+9bD3tzTE83+cNz19Qi/6XK/ftGs1EOZ3l+/abqo1dg2sKv5AyxvzRsaHhf13U0c7Zyxqj/2TLF36l + pEZ2EIm2MZpIMzySZMGC9raR4dQq39fnpX17jsCFnm/no3QCTVandYluZknHoGOkz3HNMwL3N8WcR8XI + fcsWtx58dnd/OuIa2lqa8H2fN1RxxB9XAGw7qvQNJHh2cJTlzbH3KHwc1caQVKvGN/I/Udf5LVX6XMdw + 3opoo1FOonzxf48QiboMD46SSHioWjZvXOTu3nOsK5mycxwjZ6U9f0Uq5bcaYYlxzCKCdHhRUKeE//Ck + JYUEO/EkVDnm+Xa/Y6SnKeYeFyNP+Z7u6O5sGvjmLx7rv+q89YhAa3MEM6gMLYJ3nL+49n2w+MB9z4yQ + DhaKdKq1/89afVWja9Wg4UV2O468zle9b0NHC4salv+qlq/+oI+DFz/J/CfWMJpIkUz6OI7gW2VgMME1 + Fy+L7OtJNCXTNmJ9a1StSEGygZJ4TLaoa0QdR/zm5kjqJWe0j37iu7s0FnGDvAEK7a0xmtwYVn1ee8Xc + KW+nknf4yYce5/TmVTgiZ3u+/W+rtds78JSEH0aN4f2Pbnr2M+dvW0dLU4TzVjVG/6kot911DMVFdZS0 + D74NFkaBze0gFLBbDQEQLqYSHFcwxmGgv43mlhHecHlnvfTFseW+nUl8L8WxFLQ4epPn62cVbcQGVKeo + 45h/jcfcP/U8OwLw/E2tjVZplPoRAAB3PjWID8Sbo25f3+gf+77eomisoaieIPVhYxsjP4pEI2/Dtwdd + heef2d5onEapPwEA8IutA1hVDLQk03pr2rPvCowljXIixRi5N+Kat6naJ1ec1cVh4KqG1b9R6lUAAPzw + keOIgmPoTKT1475v3xJmR26UCkrGjOwYeTQadX43lfAf6JrbTDoJL9ocbzRQo9S3AFBVvvfoIK5aQOek + Uv7fe779baChCVRYjJFHYlH3XaOp1D3zulrx1edFmxqqf6PMAAEA8Ktf7aKnu4OopxgxXcmUd0s6bd+h + qrFGE47fuI5j7orFnPemPPtQZ3MTClxzZlujcRpl5giAQAgoPa1HiKhDNGpahobT7017+sfWamdjOlBY + Mqn2HGP+JxY1f5ZI2e1zO2OkPeVl53Y1GqhRZp4AgGA68O37e3AdQ3dLk3vo+MirkmnvQ56v66ZzB5R6 + K0ZkMOI6/xGNRv7eptNH5ixoJjmS5iVnNzypjTKDBUCmfOe+HlzXsPWZPlYvaz1/NOH9jefrS1QbHgLX + kR3RiHPr3O6mrw8MeskD9x9i6RVLeGVj5G+U2SIAAL7/UC9RR+gZShJ1nTnJhP/WZMp/p+fb5adiQxoj + I9GI8+2mqPn4s/sGHt+4uhPfh5sumdfoZY0y+wQAwHfu6eHGS+bw9buP8prL5vFfdx6+cDThvdvz9Hqr + 2q5TnSR9qkuwnb11HPNQNGr+eV5n03ePDySHO9tiJFM+r2rA3yizWQBkyjfvPUY06tLXP0xbczTeN5S6 + JpX23+Z59vnh3nXVO9n08p4txoh1jGyNuOaL8Sb3v/t7EwfmLWjhQH+Sc5e0cvmZnY3e1SinhgAA+Pb9 + Axw8dJDurk76BhPM7WptGxhKXJVK+29Ie/Yqa3XejNYIwms3wqjrmkejrvl6U5Pz3Ucf3//cmacvpbUr + RnrU47WXzp+hN9goDQFQhfK9BwZYu7yNR7cdZWAowYI5zU29A8kzU2n/5b7Va9Npu1FV21VniNdABCOk + jJF9rmP+tynq/CDW5N65Z89gz+LFzbQ0N+F5Hq+/fMHMuJ9GaZRaCoBM+Z/7+7juwg6++r+HGEl4/P0n + 7udvP3DF3NHR1DmJpHeJql7mebreBrkH24IlmfXAuyBCEuiNuGa/iNwTizq/cYzcvWhh2/49+/vTsZhL + d1eEZFJ5zSWNEb9RGgJg3PL1e4/iOoaBwRSJpMf+YwOctWZe57G+xBzHMRekPH9zKukvdhyzGWGF9bXD + Wo1ZVVMrwSDByK7GMWnHyLDAQc/qU46RXfEmd7cq9zZFnX1vumphz2d+tNcaEVpaIhwdTbOmtYkbntcw + 8DXKzC//H2KEQtrPXsHrAAAAAElFTkSuQmCC + + + \ No newline at end of file diff --git a/RPST GUI/RPST/Windows/MainWindow.vb b/RPST GUI/RPST/Windows/MainWindow.vb new file mode 100644 index 0000000..0604248 --- /dev/null +++ b/RPST GUI/RPST/Windows/MainWindow.vb @@ -0,0 +1,203 @@ +Imports Newtonsoft.Json.Linq + +Public Class MainWindow + ReadOnly settings As New SettingsManager() + ReadOnly ApiHandler As New ApiHandler() + + ''' + ''' Event handler for the form load event. + ''' It loads settings, toggles dark mode if necessary, checks for directories, logs first time launch, and sets the form title. + ''' + ''' The source of the event. + ''' An EventArgs that contains the event data. + Private Sub MainWindow_Load(sender As Object, e As EventArgs) Handles MyBase.Load + Utilities.PathFinder() + + settings.LoadSettings() + settings.ToggleSettings(enabled:=settings.DarkMode, saveTo:="darkmode") + settings.ToggleSettings(enabled:=settings.SaveToJson, saveTo:="json") + settings.ToggleSettings(enabled:=settings.SaveToCsv, saveTo:="csv") + + Me.Text = My.Application.Info.AssemblyName + End Sub + + + ''' + ''' Event handler for the 'About' menu item click. + ''' It shows the 'About' box. + ''' + ''' The source of the event. + ''' An EventArgs that contains the event data. + Private Sub ToolStripMenuItemAbout_Click(sender As Object, e As EventArgs) Handles AboutToolStripMenuItem.Click + AboutBox.Show() + End Sub + + + ''' + ''' Event handler for the 'Check Updates' menu item click. + ''' It checks for application updates and provides update information if a newer version is available. + ''' + ''' The source of the event. + ''' An EventArgs that contains the event data. + Private Async Sub ToolStripMenuItemCheckUpdates_Click(sender As Object, e As EventArgs) Handles CheckForUpdatesToolStripMenuItem.Click + Dim data As JObject = Await ApiHandler.CheckUpdatesAsync() + If data("tag_name").ToString = My.Application.Info.Version.ToString Then + MessageBox.Show($"You're running the latest version v{My.Application.Info.Version} of {Me.Text}. Check again soon! :)", $"{Me.Text} v{My.Application.Info.Version}", MessageBoxButtons.OK, MessageBoxIcon.Information) + Else + Dim confirm As DialogResult = MessageBox.Show($"A new version v{data("tag_name")} of {Me.Text} is available, would you like to get it? + +{data("body")} +", $"{Me.Text} v{data("tag_name")}", MessageBoxButtons.YesNo, MessageBoxIcon.Question) + If confirm = DialogResult.Yes Then + Shell($"cmd /c start {data("html_url")}") + End If + End If + End Sub + + + ''' + ''' Event handler for the 'Quit' menu item click. + ''' It asks the user for confirmation and closes the program if the user agrees. + ''' + ''' The source of the event. + ''' An EventArgs that contains the event data. + Private Sub ToolStripMenuItemQuit_Click(sender As Object, e As EventArgs) Handles QuitToolStripMenuItem.Click + Dim result As DialogResult = MessageBox.Show("This will close the program, continue?", "Quit", MessageBoxButtons.YesNo, MessageBoxIcon.Question) + If result = DialogResult.Yes Then + Me.Close() + End If + End Sub + + + ''' + ''' Handles the click event of the ScrapeButton. + ''' Collects inputs, fetches Reddit posts based on the inputs, + ''' and processes Reddit posts. + ''' + ''' The sender of the event. + ''' The EventArgs instance containing the event data. + Private Sub ButtonScrape_Click(sender As Object, e As EventArgs) Handles ButtonSearch.Click + settings.LoadSettings() + PostsProcessor.ProcessRedditPosts(settings:=settings) + End Sub + + + ''' + ''' Handles the KeyDown event for the TextBoxKeyword. + ''' Processes Reddit posts when the Enter key is pressed. + ''' + ''' The source of the event. + ''' The instance containing the event data. + Private Sub TextBoxKeyword_KeyDown(sender As Object, e As KeyEventArgs) Handles TextBoxKeyword.KeyDown + settings.LoadSettings() + + ' Check if the Enter key is pressed + If e.KeyCode = Keys.Enter Then + ' Prevent the beep sound that usually comes with the Enter key in a single-line TextBox + e.SuppressKeyPress = True + PostsProcessor.ProcessRedditPosts(settings:=settings) + End If + End Sub + + + ''' + ''' Handles the KeyDown event for the TextBoxSubreddit. + ''' Processes Reddit posts when the Enter key is pressed. + ''' + ''' The source of the event. + ''' The instance containing the event data. + Private Sub TextBoxSubreddit_KeyDown(sender As Object, e As KeyEventArgs) Handles TextBoxSubreddit.KeyDown + settings.LoadSettings() + + ' Check if the Enter key is pressed + If e.KeyCode = Keys.Enter Then + ' Prevent the beep sound that usually comes with the Enter key in a single-line TextBox + e.SuppressKeyPress = True + PostsProcessor.ProcessRedditPosts(settings:=settings) + End If + End Sub + + + ''' + ''' Handles the KeyDown event for the NumericUpDownLimit. + ''' Processes Reddit posts when the Enter key is pressed. + ''' + ''' The source of the event. + ''' The instance containing the event data. + Private Sub NumericUpDownLimit_KeyDown(sender As Object, e As KeyEventArgs) Handles NumericUpDownLimit.KeyDown + settings.LoadSettings() + + ' Check if the Enter key is pressed + If e.KeyCode = Keys.Enter Then + ' Prevent the beep sound that usually comes with the Enter key in a single-line TextBox + e.SuppressKeyPress = True + PostsProcessor.ProcessRedditPosts(settings:=settings) + End If + End Sub + + + ''' + ''' Handles the KeyDown event for the ComboBoxListing. + ''' Processes Reddit posts when the Enter key is pressed. + ''' + ''' The source of the event. + ''' The instance containing the event data. + Private Sub ComboBoxListing_KeyDown(sender As Object, e As KeyEventArgs) Handles ComboBoxListing.KeyDown + settings.LoadSettings() + + ' Check if the Enter key is pressed + If e.KeyCode = Keys.Enter Then + ' Prevent the beep sound that usually comes with the Enter key in a single-line TextBox + e.SuppressKeyPress = True + PostsProcessor.ProcessRedditPosts(settings:=settings) + End If + End Sub + + + ''' + ''' Handles the KeyDown event for the ComboBoxTimeframe. + ''' Processes Reddit posts when the Enter key is pressed. + ''' + ''' The source of the event. + ''' The instance containing the event data. + Private Sub ComboBoxTimeframe_KeyDown(sender As Object, e As KeyEventArgs) Handles ComboBoxTimeframe.KeyDown + settings.LoadSettings() + + ' Check if the Enter key is pressed + If e.KeyCode = Keys.Enter Then + ' Prevent the beep sound that usually comes with the Enter key in a single-line TextBox + e.SuppressKeyPress = True + PostsProcessor.ProcessRedditPosts(settings:=settings) + End If + End Sub + + ''' + ''' Event handler for the 'Dark Mode' checkbox change event. + ''' It toggles the dark mode of the application based on the checkbox status. + ''' + ''' The source of the event. + ''' An EventArgs that contains the event data. + Private Sub ToolStripMenuItemDarkMode_CheckedChanged(sender As Object, e As EventArgs) Handles DarkModeToolStripMenuItem.CheckedChanged + settings.ToggleSettings(enabled:=DarkModeToolStripMenuItem.Checked, saveTo:="darkmode") + End Sub + + ''' + ''' Event handler for the 'to CSV' checkbox change event. + ''' It toggles the dark mode of the application based on the checkbox status. + ''' + ''' The source of the event. + ''' An EventArgs that contains the event data. + Private Sub ToCSVToolStripMenuItem_CheckedChanged(sender As Object, e As EventArgs) Handles ToCSVToolStripMenuItem.CheckedChanged + settings.ToggleSettings(enabled:=ToCSVToolStripMenuItem.Checked, saveTo:="csv") + End Sub + + ''' + ''' Event handler for the 'to JSON' checkbox change event. + ''' It toggles the dark mode of the application based on the checkbox status. + ''' + ''' The source of the event. + ''' An EventArgs that contains the event data. + Private Sub ToJSONToolStripMenuItem_CheckedChanged(sender As Object, e As EventArgs) Handles ToJSONToolStripMenuItem.CheckedChanged + settings.ToggleSettings(enabled:=ToJSONToolStripMenuItem.Checked, saveTo:="json") + End Sub +End Class diff --git a/RPST GUI/RPST/Windows/PostsWindow.Designer.vb b/RPST GUI/RPST/Windows/PostsWindow.Designer.vb new file mode 100644 index 0000000..3ec1940 --- /dev/null +++ b/RPST GUI/RPST/Windows/PostsWindow.Designer.vb @@ -0,0 +1,203 @@ + +Partial Class PostsWindow + Inherits System.Windows.Forms.Form + + 'Form overrides dispose to clean up the component list. + + Protected Overrides Sub Dispose(ByVal disposing As Boolean) + Try + If disposing AndAlso components IsNot Nothing Then + components.Dispose() + End If + Finally + MyBase.Dispose(disposing) + End Try + End Sub + + 'Required by the Windows Form Designer + Private components As System.ComponentModel.IContainer + + 'NOTE: The following procedure is required by the Windows Form Designer + 'It can be modified using the Windows Form Designer. + 'Do not modify it using the code editor. + + Private Sub InitializeComponent() + Dim resources As System.ComponentModel.ComponentResourceManager = New System.ComponentModel.ComponentResourceManager(GetType(PostsWindow)) + DataGridViewPosts = New DataGridView() + postIndex = New DataGridViewTextBoxColumn() + postAuthor = New DataGridViewTextBoxColumn() + postId = New DataGridViewTextBoxColumn() + postTitle = New DataGridViewTextBoxColumn() + postText = New DataGridViewTextBoxColumn() + postSubreddit = New DataGridViewTextBoxColumn() + postSubredditType = New DataGridViewTextBoxColumn() + postThumbnail = New DataGridViewTextBoxColumn() + postIsNSFW = New DataGridViewTextBoxColumn() + postIsGilded = New DataGridViewTextBoxColumn() + postUpvotes = New DataGridViewTextBoxColumn() + postUpvoteRatio = New DataGridViewTextBoxColumn() + postIsShareable = New DataGridViewTextBoxColumn() + postScore = New DataGridViewTextBoxColumn() + postCategory = New DataGridViewTextBoxColumn() + postDomain = New DataGridViewTextBoxColumn() + postPermalink = New DataGridViewTextBoxColumn() + postCreatedAt = New DataGridViewTextBoxColumn() + CType(DataGridViewPosts, ComponentModel.ISupportInitialize).BeginInit() + SuspendLayout() + ' + ' DataGridViewPosts + ' + DataGridViewPosts.BackgroundColor = Color.Gainsboro + DataGridViewPosts.ColumnHeadersHeightSizeMode = DataGridViewColumnHeadersHeightSizeMode.AutoSize + DataGridViewPosts.Columns.AddRange(New DataGridViewColumn() {postIndex, postAuthor, postId, postTitle, postText, postSubreddit, postSubredditType, postThumbnail, postIsNSFW, postIsGilded, postUpvotes, postUpvoteRatio, postIsShareable, postScore, postCategory, postDomain, postPermalink, postCreatedAt}) + DataGridViewPosts.Dock = DockStyle.Fill + DataGridViewPosts.Location = New Point(0, 0) + DataGridViewPosts.Name = "DataGridViewPosts" + DataGridViewPosts.ReadOnly = True + DataGridViewPosts.RowHeadersVisible = False + DataGridViewPosts.RowTemplate.Height = 25 + DataGridViewPosts.Size = New Size(501, 365) + DataGridViewPosts.TabIndex = 3 + ' + ' postIndex + ' + postIndex.HeaderText = "Index" + postIndex.Name = "postIndex" + postIndex.ReadOnly = True + ' + ' postAuthor + ' + postAuthor.HeaderText = "Author" + postAuthor.Name = "postAuthor" + postAuthor.ReadOnly = True + ' + ' postId + ' + postId.HeaderText = "ID" + postId.Name = "postId" + postId.ReadOnly = True + ' + ' postTitle + ' + postTitle.HeaderText = "Title" + postTitle.Name = "postTitle" + postTitle.ReadOnly = True + ' + ' postText + ' + postText.HeaderText = "Text" + postText.Name = "postText" + postText.ReadOnly = True + ' + ' postSubreddit + ' + postSubreddit.HeaderText = "Subreddit" + postSubreddit.Name = "postSubreddit" + postSubreddit.ReadOnly = True + ' + ' postSubredditType + ' + postSubredditType.HeaderText = "Subreddit Type" + postSubredditType.Name = "postSubredditType" + postSubredditType.ReadOnly = True + ' + ' postThumbnail + ' + postThumbnail.HeaderText = "Thumbnail" + postThumbnail.Name = "postThumbnail" + postThumbnail.ReadOnly = True + ' + ' postIsNSFW + ' + postIsNSFW.HeaderText = "Is NSFW" + postIsNSFW.Name = "postIsNSFW" + postIsNSFW.ReadOnly = True + ' + ' postIsGilded + ' + postIsGilded.HeaderText = "Is Gilded" + postIsGilded.Name = "postIsGilded" + postIsGilded.ReadOnly = True + ' + ' postUpvotes + ' + postUpvotes.HeaderText = "Upvotes" + postUpvotes.Name = "postUpvotes" + postUpvotes.ReadOnly = True + ' + ' postUpvoteRatio + ' + postUpvoteRatio.HeaderText = "Upvote Ratio" + postUpvoteRatio.Name = "postUpvoteRatio" + postUpvoteRatio.ReadOnly = True + ' + ' postIsShareable + ' + postIsShareable.HeaderText = "Is Shareable" + postIsShareable.Name = "postIsShareable" + postIsShareable.ReadOnly = True + ' + ' postScore + ' + postScore.HeaderText = "Score" + postScore.Name = "postScore" + postScore.ReadOnly = True + ' + ' postCategory + ' + postCategory.HeaderText = "Category" + postCategory.Name = "postCategory" + postCategory.ReadOnly = True + ' + ' postDomain + ' + postDomain.HeaderText = "Domain" + postDomain.Name = "postDomain" + postDomain.ReadOnly = True + ' + ' postPermalink + ' + postPermalink.HeaderText = "Permalink" + postPermalink.Name = "postPermalink" + postPermalink.ReadOnly = True + ' + ' postCreatedAt + ' + postCreatedAt.HeaderText = "Created At" + postCreatedAt.Name = "postCreatedAt" + postCreatedAt.ReadOnly = True + ' + ' PostsWindow + ' + AutoScaleDimensions = New SizeF(7F, 15F) + AutoScaleMode = AutoScaleMode.Font + ClientSize = New Size(501, 365) + Controls.Add(DataGridViewPosts) + Icon = CType(resources.GetObject("$this.Icon"), Icon) + Name = "PostsWindow" + StartPosition = FormStartPosition.CenterScreen + Text = "Posts" + CType(DataGridViewPosts, ComponentModel.ISupportInitialize).EndInit() + ResumeLayout(False) + End Sub + + Friend WithEvents DataGridViewPosts As DataGridView + Friend WithEvents postIndex As DataGridViewTextBoxColumn + Friend WithEvents postAuthor As DataGridViewTextBoxColumn + Friend WithEvents postId As DataGridViewTextBoxColumn + Friend WithEvents postTitle As DataGridViewTextBoxColumn + Friend WithEvents postText As DataGridViewTextBoxColumn + Friend WithEvents postSubreddit As DataGridViewTextBoxColumn + Friend WithEvents postSubredditType As DataGridViewTextBoxColumn + Friend WithEvents postThumbnail As DataGridViewTextBoxColumn + Friend WithEvents postIsNSFW As DataGridViewTextBoxColumn + Friend WithEvents postIsGilded As DataGridViewTextBoxColumn + Friend WithEvents postUpvotes As DataGridViewTextBoxColumn + Friend WithEvents postUpvoteRatio As DataGridViewTextBoxColumn + Friend WithEvents postIsShareable As DataGridViewTextBoxColumn + Friend WithEvents postScore As DataGridViewTextBoxColumn + Friend WithEvents postCategory As DataGridViewTextBoxColumn + Friend WithEvents postDomain As DataGridViewTextBoxColumn + Friend WithEvents postPermalink As DataGridViewTextBoxColumn + Friend WithEvents postCreatedAt As DataGridViewTextBoxColumn +End Class diff --git a/RPST GUI/RPST/Windows/PostsWindow.resx b/RPST GUI/RPST/Windows/PostsWindow.resx new file mode 100644 index 0000000..d21e154 --- /dev/null +++ b/RPST GUI/RPST/Windows/PostsWindow.resx @@ -0,0 +1,622 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + True + + + True + + + True + + + True + + + True + + + True + + + True + + + True + + + True + + + True + + + True + + + True + + + True + + + True + + + True + + + True + + + True + + + True + + + + + AAABAAEAAAAAAAEAIACdZwAAFgAAAIlQTkcNChoKAAAADUlIRFIAAAEAAAABAAgGAAAAXHKoZgAAZ2RJ + REFUeNrtnXeYJFd16H/nVnX39OSZzTknrXIOSEKAJJICIETGNsHYBgwGR2w/y4AwBvsZAzbGfoBJNiCi + yYggC0WUtVppg6RdbQ6zs5OnQ9U974+qjtM907PbPdMz2/f75pvu6u5bVbfu79xzzzn3XKFRZlV58Hlv + RADfglWFiDSJpyutmoutcrGqbFZlhap2qkrcKgAJVfpV2a0qTyE8opa7jThPJ3xv2MGgjiAKL37sC41G + nkVFGk0wO8qjl76BFoV+gbQqjpj5Fq5W5SXAJVZloSrNakEBVUE18xqsBscArJJU5QjI/cD3Rbl9eMQ7 + GGuK0BxxSPmWa7d8vtHoDQHQKPVQHrj89YiA5wuu0m3hJou8WZXzUWI2A3we/OHIXwr+AsGgKingceA/ + jZpvjFp7NOYEv79ua0MbaAiARpm2svMlL+FY3zwcx8NtT4nX33SVqv6xhReqShSFk4Q/7zVpkDsRPtYS + 4+fDo9iU47K4r49L993WeBgNAdAoU1kevvzVJJLdRCIjiHitqs7bFf1jqyxWFaoMPxp+BzgiyD+7yKfT + MHAoCksShuu3/7/GQ5mBxWk0wcwrB867jv1Nc2mWEYwwR1VuVfhTq3RVG/7Mb2z4OUqLhSssLHRE7o97 + OtwzmOQta87j64cebTycGVbcRhPMvLK7pZtWfxQRO0+tfFzhjVZxpgD+zHcjVvUtFtoiRt4zpzV2yBto + KJMzsTSe2gwrD176RowoRmj3lI9ZeLtVzBTCX/DfiHzJNc57VfU4Cq/c8bnGQ5pBxTSaYOaU+5/3ehBF + 1HHSyh9aeEst4NcK4VfAs/qGtG//uNWJRIwI39nwtsaDagiARqlFSUsax0bwxH+ZKu+xSqSWBr+J4A// + O561f3A8lbyxP5nEMY0uNZNKYwowQ8oDl74eRABZqug3rHLJdKn9Y/4riPBQzDE3WWU3GG7e2fAKzITS + ENczpAjQmU6Lor9tlYvqCf5QYzgv6evbFrR0GCONcWUm9atGqfNyX2j4E3Sdr/J9VdlQT/BnfivIriZj + rrPoVscYXt3QAuq+NDSAGfGUDHYkha/mlaqyvh7hD7QAXZWy9qbXPvN5GqaAhgBolGoV34em6BxVrkeR + 6bD2TwQ/4X9f9bqvrXnLgmTaNp5bQwA0ysmW+y5+PcFMTc5DOb2aI/8krf0Twq8oProxbbnYU+W2tW9v + PMA6L41IwBqWN7/5zRhjSKVSBcettQwPD2PtxKPkXSNJzk20Eld7kYV2VepK7c+HP9QoWjzsBbsGh793 + VndHoxM0BMCpUV7zmteEICoakjA6Ooq1Fs/zCo4DxONxRCR7LP/z/Nd7Ed7YT/yZiJ6v1Necvxh+Da9d + kIvO6OxqT/l2oNEzGgJg1oMvIlhrg84v0gGsATYCi0WkLRKJRDJgZ0pGKOSXfAGQKc+6nv7FQq/l9b2t + F8Z9CWGrX/gVwaIrh/1UqyoNAdAQALOzvPa1r8XzPAC+9rWvcfPNN68TketU9WXAGUC7qsaK4S5+Pd4x + QtAE8LOw1Tf84fc6EDPfYg80ekpDAMy68upXvxrf9zGBr6vj5ptv/h3gHaq6gTC2ohzwpUb5iV43W4Oj + YGcA/OElxx0xS1R5tNFbGgJgVpWbb74ZVcUYg6quVtW/BW5W1WilQE8GfkWJWJAwh1+9w6/BN11VbcvV + 0CgNATBLirU2A/9G4F+AF0wK6El+VwEpsPzXN/wKCBiUiDb4bwiA2VRuvvnmzMv5wMdqDX+mpEXDyL/p + DfKpBP7gusWzMNLgv/5LIxCowvLKV74y89IF3gW8bCrgByWJBkbAaQ7ymRj+8LxoStFe25gC1H1paAAV + ll27drF+/XpU9TICg5+ZAGhV1X5gVFX9kxEUw8Y6aXRuVE2kEviZNviD1waGPLXP2cYcoCEAZktZu3Yt + 1tqYiPyOqs6fAOgnVPVrwK+BA0CiuL6J3IKZkhbVVcloV9x3vqBwfj3DH94NBqc3Ks5QQwNoCIBZUW66 + 6SYARGSTql49DsQKfAf4S2DbeHXmRwHmvy4uy1MRPnRo0cFfNA087Cvn1zP8mTgFNfpIVyzWN5BONTpP + QwDM/GKtxXVdVPVKYFEZ+CEY8f8I2JM58O1vf/ukzp0671X8NDpgHcuDqrxVwalP+LP2CTViHt4/MpKK + L+2BXY3+U8+lYQSsoDiOQ+jnPw+QMvAPAZ8A9lhrsdaeNPwAjxPHBCDeDeyvX/iD9wKHXJw7HRHM8a5G + 52kIgFlTWoG14xjxtlhrf50JEvrud79blZOe/9BXEAMRh2cUfl3P8AM4Yu5pl9j2JnF58/YvN3pNQwDM + /BKCHlPVeWXgB9jiOM5xEeFb3/pWVc8vTUlGUyYpmG8AQ9Pr5y8PPzDqIF8/lB4YXd46r9FxGgJgVgkB + A0TLwI+qDkajUd/3/eqfOxXBMeCK3KHK/06vn780/KrgiLk75rg/b3aj9CQaCwEbAmB2FV9VR8fx3c8d + HR2NSA0y4l798JeJRNIMpxgQkX8BeusNfhEGIuJ8+nhq9Pi8eCs3PfvpRo9pCIDZUcIEHQngcBn4ITAQ + LgS48cYbqy99fIeoo8SM+QXIV+sJfhVwxflaN/GfdLnNDKWTjU7TEACzTggMAdvLwI+qblDVV4cLhbj+ + +uurev6rH/0inhdl1CPlivkHQX5dH/ArLvJATNyP9cpoctRJ8vpnP9voMA0BMHuK53mIiKeq96pqugT8 + ABHgvZ7nvdh1Xay1vPzlL6/qdbQu3E5Ls0vCS+9x4K+AZ6cbfgezLybuX/alR55Z5HayYffqRodpCIBZ + 1kjhqC4idwA7x3EFLgP+OZ1OX93c3IyqVlUIXHXHHSSSlhbjcMi4dwq8T+HAdMFvkKMRcd//pDlw+4Jo + B/12hKu4pdFhZlBxGk0wcdm2bRsbN24kXNyzALiyBPyZl3OAizzP2xaNRp/1PI8NGzawY8eOqlzLV488 + zGvnnk0Llq7TBraPHo0/h3KxVTqmGP6DMXHf98o5Z399aDSFpz6/tec/Gp2lIQBmZznrrLMyabz3AVeq + 6oIS8Gdez1HVi62121zXfdZaW1Uh8F89j3LT3LNJHG1ib2L0qQ43ulWV06yyeIrU/idi4v7h/ww99+2I + 9fBR3rrvc41OMgPLjNsb8MHPnsd5D29nz7IFmMlcfRhBJ9ZwwDnIhenzkFvumNS5b7jhhsx04HXAZ4CO + CZb07gDeqao/z6T6/tGPflS1tvjuhrdiRBhMp4k57oa0tX/lW32lQnMt4EdIumK+FxP3Q73e8BOLIu2k + 1OOte78woyF48LPncd6jO9izbAESpDWnonRmYZo2RVj+XA8PXbCa89/xUEMAVLPs+/A6HHXxJJW9WlFw + HEj72iRimkBjIDFEm1GiCkaC7fNSwAhIEkgqJPDSCYiEzzf4Vnx4lHQswuKPjL9y5cYbb8y4BKPGmD9V + 1b8EmsrAn3m9A3in67o/TyaTiEiVhcDbiDuG46k0cce0jPr2FZ7VP/SVc1RxqxThZwV5LCLm060mdtuQ + TQ52Oa0kNDUj1f6Df7cSN5ImmWhCswQoUV9JOtIkmCaUGKIxoBnK9CklqWgiltJEypigXcN2jiSG8aJR + ln9od0MATLbs/charIAJg91VFLHE1Ei3qKxBdSPCWmA5weq8+UAbgSXehPcVJKeBNMoAyFGUgyjPqfIM + ylOCPKtKr1WTNH5wrogPvihL/25nyWu74YYbgoYTaVbVDwDvV9WmMvBnXu8A3uU4zu2pVAoR4cc//nHV + 2uvnp7+Nrb1plrS4jKSTxJzYIl/1FZ7qG3zVM1S1zTJ+Gi+F3KJelXBhj4wYZIsj5utR43yz1w7t7ZZW + jmoPy2UZr9s7c4J9nvvwWlQFYywCWDU4aMyKdktuH4f8PjUPaB+nTw0CR1A5iLIH5WlV2aYqz6jRXvGd + pFgLKkQs+AJLP7K9IQDKlSO3bKa/5TjxVHPQ+VRRkVaE9SiXApcAZwGLQ9grX8qsBNEqYS9XxUNlEDiA + 8iiWe1XlXkF3eGqGHBtoGV5ymKbOBSy+pVCty2gCQLOq/jnwJxkhMI4g2KGq73Jd9/ZkMgiU+elPf1rV + Nrxt3dsQETzf55AdZaFpmeOrvSht7ZWqXOajq1XpVIir5vIMZhpJYVSVAUfMPtB7XGN+GcG9e8fQ4aOr + WuYRURcV5Xf2zoxR/9DHz2R4+CjRaAuoYkTxlVZB1gOXAhcDZ9ekTyn3oXIPKjs81SHHAmpIuAk6ku0s + /IfHGwIA4MBHV3PNn5/Nj299LEgnpeKq6CrgWuAlBBF28zhRl+XYB0VW79Ps5xblCMpDwO1q5adG2Wkt + Pgq9i1uYu3eIZf+UM+LlawLW2j9X1T8BmiZI+bVDVd8VjUZvHx0dRUSqLgQAvr3md4mqMICHr8qbdn2e + /179tq60+osEs8mzdpmv2uypdVEwIp4RM+qI7PN8fTJinMPnt8zvvXvooHUQOqPNpKzH63f924wAf9/f + r6Xv1wN0XNIWtL1xHFF/Nco1eX1q/tT2KX6Gmh2o+qLCnpHNrGx5jKUfe/rUFACHPn4myZFeHLcpgEO0 + CeQ84LXhQ1rJyXopKntQ5Om/aPDgdqP8GOUb+Ho/YpL4ipUorh5n2T/tywqB0CbQDGSFQBn4M6+zmkBm + OlALIZApX1v9DgTB0zRp9QGDVcVXi6+BbcCIICIYBM9aIsYhLg6O285Tz/zjjPHsH7hlMV5TO+Kngucq + xIDz661Picpv1EoCVfxYiqZjXSz+9+kxHk6LANhz6xoUwWAxYqJW9ULg7eFDqs460hN7UHmfASo9KD8C + Pq++fw+4aeMrKsKKf34KgOuuuy5zxoqnAxmbgDHm9sz2Yj/72c9mCGb1WfbeujqcNhoEG1HMRcDbgJfW + XZ+CH6F8QXzutkIaLyBx5T9vm90CYN+t61icWs++2DaWjSbY19R0OvB7wKsJVLLqlOo8qPzvH1XlG6h8 + dqjV2dI6YHlkQTvnHepn+Sef4rrrrhtjE6DMdKDYJuA4zu3pdBqA22+/vUHypMFfRc/SXczdu4ZUvItY + 4vhpCr8P3FzvfQqV21D+zW9r2WL6h1nxiafY9YebWf2prbNPAOz9yJrwdBbFdIrqm4B3A+uqeqLqP6is + vxdlB8qnVeTLWPoyjbfyk09mQ35VtUAIlIG/wCbgum5DCJxwn1JEDSidKvrGsE+tn0F9aifwL6p8SVSO + a7gZ7MpPPTl7BMDeW9cELvdhH9PinIvyV8DLCBNszJAHlflNCpUfiHKrjrgPS8xHgZX/upWXvexlqCrW + 2mZjTMF0oBIXYWY60BACE5d9YZ/SpINE/bM1WBx13YzrU8HxNCo/QLmV0ehDxNKgQZ+a0QLgub9bjuPH + UPFBiKDyGuCvqy6hpw7+/Dq2o3zIWHObj6bUs0hLjD/YvihzRc1AxS7ChhCorOy6ZSXRWCTYo1GIWOXm + sE9tmHF9auw5dqByq1G+5ispR1xGvVE2/PuOmrVnzdYC7P7QOlZ0z2cgMYKKdorKnwEfBJbMAvhBmYvK + iyzELDwsSHL1px/nJ3d9jB/3twOkgfvDVGIXEeyYWwp+CBcQqer2zNqBNWvW8OyzzzaIzysHPrKSYx1n + EE8dQZUO4E/DPrV0FsAPyhxUXmiVJmt5RNDEfYcH+fgVK/jkQ0dq0qY10QD2f3gNvm8wrsUiiwX9MPAm + arEPwfTAn11bEKpvXwL+WqweTKohYi3vPLA86yIUkbIuwqLS0ATKlL0fWYdrfNK+AewiQTJ9KjJL4C/q + U3wV5a9E2W8dF2MtKz+7peq3WnUNYO8HV2N8xUZAYAXwz8DrqUXugemHHxQHlXNQVqNyv4v0k05zXdsg + 3x/MaQLh/V+kquMJwYYmUKLs/9AqBCHca3CFIJ8I+1T1Ndjphz/Tp85GZTUq9+Nrn2Nc3nP2Aj7xyOGq + 3m5VNYADt6yn9WcR+l+eAGUF8Gmgumlx6gv+4nN8XyzvVpHnzHZIrXV514H54bk1axMg1ATGKSekCey+ + dS2o4hhB1Yar2ipsy+x/KTxGJumnkGoSjA+r/qJ2c9Lisu8jG3lmwTCrD8cQdLkqnyYw9s28PlUZ/MXn + +CHIu9TqbjfVSooR1n65emHEVRMAegvsjq/B9RVRWaIB/DeeQvBn3n8b5d2oHsAIKz+3hWuvuSYrBETk + hIXAv129l1Q0QuvwyLgP1MaaheRwRBAXcAVxFXXJLWoxBMsdIgQv0mQWuqgoYAU8VTzAQ/GczkjaP5ZW + NVJSYCgWQwrFYfkHq7MfmCrs+eAqjCuALAY+CbzqFII/8/57auWdIuxXdVi14hHkljoTAHtuXUdwK7YL + 5J+A3zoF4c8srvmiWt4rIn0qwprPP8bVV2f3FJ2UELDKu2654ODt82MJ4q7FWIuKY1Rss4o0i2o3yHyC + aLfM31yClWxtBDsaZf5HCaB3w78MvZoBHSQNpFCGgEGUIYVBYAClJ1xVeRQ4inIEpA8YseKNGD/i5Ro9 + 18W+9ubtvPk/zpz0Apg9f7sGHBBDJ8o/Ab99CsKfqedLovJeq3JcfcParzxSPwJg762rEQRRYlb4W+D9 + zE6DXyUPClQ8lI+J8kGFJFZY/ZXKhEBuLb5gRGly7I7NXaN/8kdnHjyY8lkPspzAk7ICWEYQ7RYP4Y4x + 2XnxeOp/XnahPKB9lCSQDP8fB/aiPAc8h8puhJ1i2acw0Nd20VDnwH2AZJ+XJ2AUVn20/PLYfbeuQUVR + 0ZhY8zdhW828PlUd+DN96h9E9RZFkqiw+suPTb8A2PuRtaCWpYn17Gva+VaCDTJbT2H4M+cYRHlPtGP0 + C6njzQjCqq88WiAEQP4c4f2qNANEjNLsWubF0yxtSTE/nmZBPM3KtmR/d8xLhyN5rKptOjn4i35Tsp4k + MIRyDHgaZRvwFPC4Bgti+gRJad7v4t4wKacpuzJuz0dWYVQYjgrNKX6bQPVvO4Xhz+9T7+1w7ef7PIMq + J20POGkBsO8fNqHJJCCXAP9FsOLqVIc/8/5ZlNcr3B/dNxdz7R6stTgCD/c08+1nu1vTaj7aGfN+b3lr + 0lnSnGJZa4q5TR7NrsU1Njtyai3atPrwl/vcQ+lT2IfKFuAR0IdF2YaRY+rjZdrTdaDvwm20P7kWRC8G + vgpUP9f4zIM/834X8Hqxct9oa4rTPntyIcMnJQD2fmRN5sLnAV8kWM3XgL/w+z9U5bfcpYlj0p5GRFpA + loJeIHBR2srlaStnNLnWOKK1A3764M+rU/LSDtEP7AIeQPkNyn0gu61l2IlZaPXnivKfBCHjDfgLv/8j + VX4L6EGFNf/96NQLgL0fXg/GQhQhqX8GfJhq+2VnPvygeLj6N5H1wz9AuBK4GjiHYO4ezTyEmgJfX/CX + +l6aIL3Ww8CvUP7XdHgvwegtVHveP/PhB8VT+GsP5+9dtRpRYfnXTswoeOIC4O+XghcFuBDkNoJcag34 + M98XkIhFWnxMmzckLf4wgXV++lKx1yf8uXYNjlngGK7GJWJbJaKBxVCqdP8zH/5M8tE9KDcBDwyklXO+ + dWIGwRNq1uc+vBojBpA42M8ShGSe2vDboDnFVSTuI60e0uwjkSkb22cD/GM/Fw2iGaKWrDBowJ/5+5Ig + vwc6igqrvzF5LeCE1CtfLcYYUPtCoLq7YM4k+DOvBSRuMW0+0uIhURuE2tQJ+zMW/sxzSQqaMuBooFVF + LeJOQiuYnfCDyg0K30Dlh+YEJ0qT1gD2f2gV1hhQ2hC+DNxwysLvKCZukVYP0+wTZOGvszKT4Q/r0eJj + melVk0UidvxVJrMX/kxd30N5EzDo+8L67zw8qe4x6QU6sWQq8xCuBF5wKsIvjmI6PdzFSZyFCUyH14C/ + 1vDnFwuaNNh+F9sfQUecIPH+qQc/KFehcoWokDqBLjhpxWE03gRoE8jrqFZwxgyBX1yQljSmzUNiNqc/ + 1SH7sw5+LX29mgqmBzKqSJOPNFlw9FSBH1TaVXm9Kr9oMiQm200mNQXYe+uazMsLgO8T7JQ76+EXR5FW + H9Mezu/rvZwi8Jf6LGuEjYUGw9kNf6auwwQrJB9QK6z7XuUpxic3BRAhsucZCJb4zm74LWAU0+7hLEzi + zE014K9X+PO/nhbsQAR7PIIdcVBfCq9/9sEPygJUXhZvTk66u0xOAKjiLV89j2DXntkJvw3qlFYfZ0Eq + AL9pBoB/KsNfIAgkKwh0wMX2u+ioCQT67IQ/0y7Xjg7G5sokp6MVC4C9H86o/3IOsGnWwZ8x8MUsZm4K + Z14KifszZwP1BvxjzqOApgx20MUOuGjazFb4QTkN5RwUdr78vOoLAFCIOChcTrDWfHbB74LpTOMsSGLa + vBMPOGnAXzfw57S60Gsw4KLDDmpltsEPSjsql7vGQSdhla7cCyACnt9OsEvv7IEfkGaL6UjPHFW/AX/l + 8OfX44MddSBtghgC184W+DPfvzjl+e2CGai+AAjKEk5U/a9D+MVVpM3DtPkza8RvwD95+PN/kxbUcyAq + hVGbMxt+VDlNgq3OKxYAFU0B9n14XeZiTge6Zjz8gMR9zLxUEMTTgP/UgT9/WpAw2GEnCDOe+fADdIOc + DrDtmgsr6kYVagCCYhHMJoL0UzMXfqOYtsCnPyPBb8B/8vDnH/MM6gMRgXw378yDH5Q4KpuMWLwKrdcV + CgAfYyWqhrUzGX6JWkxHsEpvxpYG/NWDP1NPaCTEz0wJdCbCnzm21lqJumJT1RMAAoi0MJl0X/UEPyDN + PqYzXT/Lcxvw1wf8RbYB6zvBasNsOPGMgh+UFSDNKNUTAOF54sDCGQe/gGnzZrbK34C/9vBn7je0DeBq + sOQ4/zz1Dz8oi1DiCH2VdKtJxAFIJ5X4/+sIfnEUpyuF6Ug34G/APzH8+RCmDZoyqJ1R8INKh2A6s9cy + QZmEG1A7mWgjxnqCP2IxXTPUt9+Af/rgz6tHPQFrcslH6h9+gIgqnZV2r8nEAbSN+/16gj8Wwj8TFu80 + 4K9L+LPHfEGtBEFDUvfwo4rLJJbpT0YARCk3Zagn+ON+AH89JuhowD+z4M/rW5o2gWHQUM/wg4oBYlD1 + KQBuSQFQT/A3+zhd6SAhRAP+BvzVgD9TwvUD4miwf2p9wg+KmQzXkxEAtqhJ6gd+BNMSuPka8Dfgrzr8 + efWoJ7k9lusPfghWAlUc6DIZAZAKhUAdwu9hOme4m68Bf33Dn3/cl9wG6/UFPwT7KlQUAzBZATAMmT3c + 6gR+zYz8Dfgb8E8R/FkhQLBCNt87MP3wg4oXslp1AdBPsMljbeFnEvCH0X0N+BvwTyn8+fCJBi1dH/CD + kg5ZraIACC7oODBSL5lWM9b+xpy/Af+0wJ+FVwKjYH3ADzACcrzYXFeuVBYJGJxkGJUjdQF/6OdvwN+A + f1rhzxRbN/CDclhVRyrkv0IBYEEsowQbEk4v/JkIv4afvwF/PcBfFC8wzfCjKnuxZkQrDAWucC2Ag+en + RlR5ZlpzrIc78jQi/Brw1xX8pX4zPfCD8oyKN0o1BcBiZxhjYqBsRyU9LfALwVr++Axey9+Af5bDL9MN + fxplu1iH7ubm6gmAbV5neELZAvRPOfyAafUwLV4D/gb89Q2/5P1uauEHpV9gC8Bzx49XTwBsvmVr5uVu + lN1TCr+CNIUpvGZKjv4G/Kcm/JljUuI6ag8/KM+qym5UOP+hyrYHm9TOQOLQi3L/lMIfCeb9M9ri34D/ + 1IE//C+iRQzUHH6A33hKr04ClYoFwLIzHkRT+KjchZKcCvgRMO0zfFlvA/5TDv7M7YiZQvhVEqjc5YJ9 + dG7lewRWHAm474lLMxd4H8puYEOtd1cxrR7SUkdGv/yJXeZJSvikVQnSx2QAldznKg34Twj+8Iby/0NI + lqDWhsckd1zDNp9O+DOvhWCI9WoOPyGT9wGc0RutvgBYdstWnvvABsDsA/9XqGyoJfwSCzL4Tvu8X8NO + 5kSQpg6kdT7SthjTtghiHYgbBzcG1gNvFE0No0OHsQP70aHDaKIfUiNBHSLZztWAvxz8CjbsBJFmTEsH + 0rEQ07UY0zEfYs1ItAmMi6ZTkB5Fhwewxw9hew9hB3rQkQFIp3LtnW23KYSfsG9L8NyzY0Nt4AflDnz2 + Y2Dzb+6tvgAAOBJLMn805oF8H3gDSlst4MeAdHgwbcE+4WjuxDAdyzCLz8fMPx1n/ulI+xKINCNuExgz + VkBZwEugXgJN9GF7dmAPPoa//wG0ZyeaGAg7hmnAX1CPDQ2+rZiF63BXn4uz9DScxRuQtm6INCGRWOFS + 3ExdnkXTCUglsH2H8fc8ibfrcbxnHsH2HIB0AnCKjHNTAH9WC9BgBWHt4B8E+R8c9dh8DzxYeU+f1Pi6 + 7y824ltFhC5VvoVyVS32VTOtPmZOahpG/wB8iXVgll6Eu/pFOEsvRtoWgeuWfuATtawEQkFHj2OPbMV7 + +ud4z/wKHdgfdhBzasOvFhBM12Lc067A3XQF7vIzkNau3JZdlbS5FL1Oe9jjh/B2PkT60V/i7XwIHR4I + PhSZGvjz2yBtslOBKsMP8EuBm0COq42w4aE7aiMAAPZ84HRsKoEY53dR+TQQqRr8ChIBMz859YY/tUi0 + FWfllbinvQqz5AIk1lIgmE6qZDRR38f27MB78vukt/0I7d9HgZp6ysAfTIpN12IiZ7+YyLkvw1m0Dlyn + 6m2uoyN4Tz9C6u7v4m29Gx0dCu0IUwM/EGQUSppcWp3qwZ9G5Z1GvP9I2zinTQL+ExMAf74JtYrCElG+ + g3JBtUZ+VDBzUoHPf8rAVxCDWXAGkXPegrv6BRBtrk4HHK/VrcU//CTpB7+Av/PnaGq4hDYwS+G3Fom1 + 4G6+itgVb8RZdjo4kp9upvrtLaCjo6S33Eny51/B3/VEYEQsmIrVCP7M67RBU1JN+EHlN1hegXBAxbDx + wV9PqmmcybblP93Vw/sunYP1zKAENoRrUHFOGn4bLPF1urxJRiecDPzBqB858w3ErvxLnCXngYlMzblF + MG3zcVZdjrQvRnueRkeO56mnsxD+0JJv5i6n6aXvIfait2PmLmHMCFyTZw0SieAsWUvktEtREeyBZyGV + HOs1qAX8YTh7sHJQqgV/GuWjXlR/5aaFDQ/fNelmcU6kLd972TyCOAfZC3KxKitPduRHmNo8/mqRjuVE + n/enRM79HSTeVftOWEoOuBHM/NMwi85G+/ejfXvHQjdb4Edw119C/BUfIHL6VYgbmZ42b27FXX8B0rUQ + u3cHOtxP6SlYFeEPm1IgyCt48vCD8mvQDxorwyB86tCeqREAn7inhz+7oJOkiQyL6iDKS4DYCcNvg737 + nM4pcvupxczdSOyqW3DXXgvGZbpKxr0t7Qswyy5Eh3vQY89kjWOzBn4xRM6+lvgr/xJnydppAb+gzY2D + WboBs3gt/t7t6EBPoXGw2vBn24HAI1CQQ2Dy8KsyCHzAtzzYFHFZO0nV/6QEAMB7L52XudjdEmwaes6J + 7qiKUZw5UxTxpxaz4ExiL/ggzrILmc6SH9uiALE2ZOkF6GgfemT7GCEwc+F3iF5wI/Hr/wTTOX/64dc8 + j/O8pZjlm7B7tqPHj+QFbtUA/rBZRUA9czLwg/IVVT5pRDxQPnVg79QKgH+67xh/cMUCHB9PlGdAno8y + b7Lwq4JptkFuv1qP/moxc9YRu+qDmCXn1kVHLO6UROPIonNg8BB6dOfMhx8hcs6Lid/wJ4E/v47gz7Sr + dC/ALF6LfXYLOtA7QSThScCfFYgEWoBvThT+rSjvF+GAEzOs+81dJ9wmJ2Vuax72Mb4BvK2ifARlcLLw + IyBt3pTAL22LiV7xl5gl59Ul/Bm3uLZ0I1e+H1l5GVg7o1197obLaHr5+wK/fh3Cn4nglrVn4b76fUj3 + QrC2dvCHTUP+NvWTg38Q5e/EylZFSQ2cnMfspATA0n/ZFiRE9CPg6zdR/h0VWzH8CtJkMfFaq/5BWGnk + /N/DWXFF/cKfGemtQvtiuPy96JzVeR/MIPitxcxfRdNL3o3pXli/8AOKoqrI5ktxXvw7EIsXtnk14Q+Z + EEeDFa6Tg9+i/LsxfBNHEYTNW+89qbY5aYfbyk9txXdcrDhJVfm4wg8rhT9whU1NTn93w/VETnsV01kq + gl81fK+w6Ezk4t+HaGuZDlmv8CvS1ErsRb+Ls3xz7fz7VYM/FxBkLr0Oc+FLxlZSLfjzVF2J6GTgB+UH + Ah/zfU2mPZ+ND9990u1TFY/76oOPM2/bE6ByGMufo/ymkr3UJWIxtU7xpRbTvY7IuW+FaHxmwE82UA7d + cC2sv5YCemdAbH/kzGuInHVtXQjcCeHPfF8VbWpGrn4jsmh13lSgyvBnzuloMPhVBv/9wF8ocmTjQ9ey + ecOyqrRRVQSA3AZH129CUFTlSUHeh/LkePADSEutF/wouDHcs96E6V4zbWroCcGf6aCROHrem6BrRXbB + TF3DrxYzdxnRy9+ARGPT3uaVw5+5fIVFq+H5N0MkNs79niT8SrCpiGsrgf8pkPeh+qSIsOO8nyK33VY/ + AgBg1WeeAgRBQPy7Ud4DsrMk/AriKKa19qO/s+hc3HUvnbZlxScOf6bNFJ2/CXvadYWPq15X9Ykhet51 + OEs2zjz485/J+VfDqjMCgVAL+DPNFdHC7cXGwr8T5D1ivHsQFwU2PHpP1dqqqkG3Kz/zRHDRfhQvmfg5 + yjtRniq1l7rE/Rr7/RXcJtyNNyLN02OBPmn4s80m6KaXol3Lwy/VKfzWYuYsJ3L2i6dd4J4M/GoV2rvh + kpdltYBawJ9d+u5qOfi3gbwznTS3oy6gbHz411Vtr6pH3a/69y2A4jQ1E7Xcrso7UB4s6EwSRP7VNOZf + FTN3E87K509rRzxp+DWYm9ru1di1L6xf+MP3kdNfgJm/aloF7knBr3mfnf48WLousAXUAv7MVzLT4EL4 + HxL4XZ/R22Px4MDGR35d9TarCYIr//1xrK+MAoj8GpW3AD9GUWwg8SRua7ziTnBXXom0zJvyzlhV+DOv + jcGuvQriHaUNgtMNv1WkpRP39OcHK/tmMvwEWoB2zEVPv6xEYFCV4A/bUFzNrpAOLpQfg7zFGvm1qy2o + FTZUweI/ZQIAYO3ntgTbp3sKsEUtb0X5NMiwxC0SqaH6r4rEuwOf/xT3xZrAHwar2HkbsfNPI5tfql7g + D41/zpJNOIvXT5vArRr8mjf1Ou0SaO0K05RVH/6AQg20AMswyr+g8jbQx42nKD4bHrmzZm1X04W3a76w + BRB8k0SQg/j8GUbfJ63esdqCaTFz1iPda2YH/JnfNbVjl18QPLZ6gh9ADO7a85F425QKgJrBn3m9aBW6 + aE2h7aWa8If/JWp7EN6vvvlTRA/4g+1YETY+endN26/mK+/XfPFxXJsEdXCWJUYjG4Z+ZFq947U+r1lw + BhJrn7LOWFv4c8f8haejYwKDpj97r8Rag8QeU6hx1Rx+VTTehq7YxMRJQ04c/lAA9Lpzkz9wulKj6vhE + gU2P3lXzNpyS1Bur/nM3kY39mDYfVM5EWFjTbuE2Y+ZtnrLEIlMFvyrYOWvQljl5doA6yNuvirTNxSxY + PeUCt2bwZ35nBLt8YxBEVi4a8yThD18vAjlTYha3y2fd0z+eknacqtw7GY8HwMVAay1PJNFmTNfUWKKn + En5FsbE2tGNp/cAf3p+ZsxSJt88u+DPPbcFytCleS/hBaVOVi4MI/6krUyYAwuS4bcAFte4eEm1HmufN + OvhVFXXj2PbFQb31AH/42nQtDvL169S0+ZTBr4ptnwPxtqKGqir8mXouEEurTqEImDIBEJa5wMaaC4DW + +RCJ1/gsUwx/+Nq6EWzrwmARSV3AH2TcNJ3zg4y+swn+zPFYHO2YWxStV3X4QdkIMncqjahTIgAOfHR1 + 5uV6YE7NTxhtC9J81aghpwv+zO9stAWMUyfwA+JArLWmBsBpgx9Q46BNrYUVVB9+gDmorkdh17UXzR4B + EImkMyPWZoJpQE17irhNiDi1qn5a4UdBI/EAunqAXwHj1FT9n1b4NRQA0aZaww9KG7DZqhJ1pyZP5ZQI + gEQihggusGlK7sqJ5KK3ZhH8uRHJHdt5pnOXXpGgzWch/GgQEITj1hp+NNhJcJMr4o4k0rNHAITN2QKs + mpLT+alctNxsg18BL7y/eoBfCWLlvdTsgz9zzNpgs9Hawp95vcpXmnWK7ABTIgACM5G2AMum4mSaHkW1 + ekuN6wl+BcRLgPWnH/7MYWvR1GhVbQB1Az+Ab4MNRGoPP8ByQVqnyhk4JQIgaEhZCHRNibhJDoBfnUSj + 9QY/CpIYDFeoTTP8mWuyPjoyWDUbQN3An/mu7yHDgxQku60J/AIqXarMn1UaQFiWA81TcSI7fATSw7MP + fgAviRk4NA6oUwx/+Nr2HYa0V7U2rxv4ESQxgvT1BM1QU/ghZGTFVEFZcwGw75+XZF7OB5pqf0sCySF0 + 6PDsg18E8RKY/gO5R1cH8INgew+iqcRJaV31B3/QRNJ3FBLDlNw+rLrwQ7DD1nwUdl5Ue1dgzQWAOy8R + bIMU+P8dpqBoahjb++wJd8a6hD/sbDLSh+nbX1fwg2B79qHDfbML/gwkB3cjoyNM2vMyefhBcUNWcFK1 + twPUXAAkn+0kGmQ86a49+WGDegnskScC482sgT+4NefIDmSkl9Kj0TTAH/7XwV78/TtPSOjWM/x4Hua5 + bZBOTgX8mf/dbtyQaql9PvWaCwABEr5Eai4AChreYA8/gSb6J9Uh6xp+AGtxDz6BJEuNRtMFPyCCJkbw + n3ti0nsA1DX8IsjIAGb3U0XtVlP4Abq9Yc81U6Av114ACBijLrWMABzT8II99gz26FOzB34RZOQ47nMP + jL3v6YQ/ewOQ3vEAOtRXsdCta/jDNjd7dmAOPpcDuvbwhxGBEilIQDJjBQCCqDFAdGrgD/5roh9/1525 + VE4zGf6wM7oHn8A5+nSJDjTN8IfXZw88jffcExUJgLqHH8D3cbfciwwPhJGlUwI/IDHBmKmIBai5AAg6 + vNZGAEzQ8N7uO9GB/eN2yBkBP4CXIrL9l0EMQMH8vw7gz9gBRgZJP3YHpP2ZD78YTM9BnC33jW3D2sIP + EFV0CjbMm7pQ4OoLgIkaXgz22DN4T98+8+EXg3N4O5Gn76xT+HPn8rbcib9ve9meNSPgD7/lPHwH5tBu + wJlK+EGJomKYAgkwBQJAQESA6i1vqrThfY/0k/+DDhwaowXMGPgB/DSxLd/HDBzOS1FdZ/CrgBjs8cOk + 7v8heP7MhV8M5tghIvf+pPA+pgZ+AlZ0SmKBp0AAaPBEIF2t6ipueDHYI0+RfuJbBbaAGQW/GNy9DxN5 + 8qdloa0L+PM+Tz34E7ynHy3cyWymwA9gfdy7foDZ+zSImWr4QUmjRmeFBhDaACyQqkJlk2j48Du+R/qx + b+Afejy3f+WMgV+Q0X6afvNlzNCRYPSvc/gRQfuOkvz5l9HhwYI2nxHwG4PZ9SSRO/8nWE8y9fADpAS1 + U6ECTEkcgATe4ZPTAE4E/lAL0P79pO/7LHakr6CauoYfwFqij32byDN3hfdT5/DnCYH01rtJ3vXdYIed + mQK/CDJwnOgPv4j0HAxG/6mHHyClitXZoAGIgigWSE45/Hkd0nv6V6Qf+hLq+zMDfjFEdt1D033/CV6S + 4tj/uoU/vA5NJUn+7Eukn7wfNTMDfjyPyO1fx3307umEH5SkKv6s8AKoGBCTBgamBf7MMd/De+jLeE9+ + f0bA7xzZTvyOT2EGjpBdQjEj4A/vXRzs8SMkvvsp/D07S0wF6gj+8AIi9/+UyM9vC1T/6YMfhQFrOPml + lfUgAHAc1Et6wLHpgZ/c3HSkD+9//xF/58/rGn5zfA/x2z+Gc2BLkPtvpsGfN/3yn32CxNf/Af/wPlTq + FH4R3Ed+TfSbn0GG+ym5zmLK4BdAjhkVb1ZEArbF54IbBeidNvizQsCgg4fwfvlR7M5fkjGz1hX8vbtp + /tlHiTx7LzNL7S+CP++e/G33k/zax7CH9gRCoG7gD+7HefhOov/9CeTYYca4LqYa/uCmelFYOQVpAWue + ejSRGsy87AW8is5ZC/izUt2gx5/D/9ktmMQAbHo56riBsWqa4XcOPUnzzz+Ou+t+subTmQy/5n7rP3Yn + ycQIkVe/H1ZsIrOxybTO+X0P9/7bid32r0jvoZzLbzrhD4zlvQBHpiAxcM3XG/3D7Yd53wu7ARYDNzJR + RGAt4de8h58YRPc+CH4a5q5HI/Fp8/OjHpEdv6L5Zx/F3fdoOArNEvjzgNOjB7C7nkA65sG8ZUG67emA + 3xhkeIDoT/+b6Hf+A+nvoS5G/qCMgvwnsHP1vffOfAEAZARAE/A6oGVa4c+8FoF0At33MPTuRrtWoC3z + go46JfAHkXMydJSm+79M8/9+CtO7N5zzzyL487QARKCvB33qN2g6hSxYicZbUJUpivALVf7d24je9mki + d3wXSYzUE/yg9AGfAo58et++mrM5NbsPBG1/RJVjBKnBphf+/Mb3PXTbz+DQU3DWzejpN6Kt88O5qtYA + /gAESY3g7rqXpt98GXfPw2C9mW3wmwj+7OUbdPA4+oP/hz71G+RFb0BPuwSa4kG7Wa3Bwp5gOiV9R3Hv + /QmRX30bc3hfrj3rB36AHuDoVHE5ZQJAlRFgL6U2B5kW+PO+I8DxPciv/xl2/hI97XpY9wK0bWE2EWQ+ + 8JOHPxz9JMjo6+57jOhj3yHyzF1IYiAcgWaBwW8i+PPvw/ro9ofQvTvh9Evh4pej684JNYJcO58w/BK2 + ubXI8SO4j96Fe/cPcXY9BV56uv385eAHZQ+qw7XY2Gb6BIAKqBnG+M/UFfxFHgJ8H9n3MM7BLejj30LW + PB9/5aXYuevQWHvOjZU/MpFvzJK80+ceoKRHMQOHcJ/7DZGdd+DufQQZDd1NYmZOhF814C/yEDAyhN7/ + U9hyL6w7B06/DDZegHYvglgsbFvJEwJaGM2J5J0mELKoIiODmIO7cbbci/voXZh9T0M6BL9+4Qd41lVv + 2J+a2fnUCICUHyXmJn2FJwnCgk1dwU9Rp/R95OATOAe3Yh7+L3T+JvyFZ2AXnIY/ZzUa7wQ3jhoXFSdY + uakK1kesD14CSQ5h+vbhHn4K5+BW3ANbMQMHgx10Mp2wBLSnDPxhPZoRliOD8MgdyJZ7oHshzorTsCtP + Q5dtgHlLoKkFIrFg01djAvCtRa1FvDSkEshQP+bgLsxz23B2PYnZsxMZ7Av2UCho87qF3wJPeiZiI6kT + D5ytOwHgGD9zn1uBQaCj7uAvEASh+qggw8eRZ+/CPHs3RJrRaCva3I1tW4RtakfdOOpGg80j0glIDWMG + j2AGjyLJISQ5FO7iI4Hcy9+09FSHv/g+jRMI3yN74fAenAd+jhNvRZta0I65aNd8NNYM0SbUcSGVCsAf + HsAcOwyDfcjoECRGw4pNmJNuytfznwj8AAOobAXFOlOjAUzNRAPYe+saCLYG+yXK2rqFX8erJ3dxWhzN + UnB+Kfqb+DynNPzj1TNmp87S1635bS1TmsCzWvCDslOsvgCRfet/U3sXIEylFyC40d5wGrB25sEf1iGS + 4z2zU0z+jjFSJ9t1zQb4M+0gee0qY5+5lm3rmQS/oNHo001zuvseesV7ue0f17O4q5nhZJprzptTMy6n + bGsw31rEmGHgNzMT/rDzTvB5A/4qwl/BM58t8APsPf/FZ/zsDz71wcTytddGIqb7zq2HGRzx+NWjx/nJ + A5NfSlNXAsCIYH0Lyv0gAw34G/A34A/vWRUv2szhlacvTSb9PxoYSd92fCD1vRXzW/7QdcyK3/+3BxhN + +fzysV5+8mDPzBQAy/762bDBZCvwXAP+BvwzFn6qCD8gqox2zmVk3lJEFJS2dNo+bzTp/1P/SOoHf/u6 + M/7cMbJiyzPH8XzluV7lV4/3zSwBEHQqg6pzNNACGvA34J+h8Gv14M8YNQeWrMNvacch0JZDj6XxrZ6e + TNmPDCfS31u+oPUPXGO6H9x6CGttVbSBKRUAI6kYJki09guURAP+BvynPPwofjTG8VWbIRLJwm8k2BrE + hJHjVvWsZNr/xHAy/dWmqPOCJfNixojwp3+ym/99anIr7adNAMTcdJicV+5R2NWAvwH/jIFfawF/Rv1f + wOCy9cEa0CL4g9dhZn0h4lt9cTJt/+vpfSN/6Tqm+4U3txF3HH695Xj9C4BVt2wL12XoAeDOBvwN+GcM + /FQf/szr/pWbSLV35wE/Fn6TEQzBGoEFvm//ZjTlfc6NyBl7j6UwrsOdW/vrWwAALP1rUB8P5afASAP+ + BvynLvyKF41zfM2Z4EYC6CeAP/MdRBxVbkx79qtdze5L/uiaTxNxhHufnJwQmHIBcOjvstrU3SCPnwz8 + WmX4tSrwF3a0CWGYEJZCUHWSv6mkzmpc2/jC7sTboLbwV3ANEyfwPGFBjlWGFyxncMUGHNGK4RcRHCNB + bJRyhufb//j4D//gTUs6oo5xhHu3Vy4EpiwUOL8891drkFgMTaX/Arg1jOOcFPxVG/nzzqVl1wZQfvQL + FrHnhQPnFp3oCWo05Tq4noBQm2iEq0xAVX4erQSE8c5VdN9VMRSXFHgTaTOT1BYnqzGF17n7mtez/8ob + Q/AnB3/+dMExciziyl93dEb/3+ion1YLF29on5DFKQsFLihG0GQagR+q8vsoyypqvJJSV8dVRwueermR + hDC2f9zOXVRHuGhdmjtxlp2BmbcSUqN4zz2OPfwsqpby23jruIKo4AaVEsJknHq0eOTSyoTneO1TwWhZ + 2UhY+etqak4Vj/xlQR1HkEzyOnIDhyXZOZ++jeciRjDoCcMfbL3JHKt8ZHAgTXtb7N8TCc9/4OkhLljb + Oi6K06IBAOz+i7WgRBH5V4G3Tk7FPPmRLx+kkjuwlBNEeeC76y8leuErcVacjcRaQH1s7wFG7/gyqfu+ + ifjJvOs48Tm2Fj+yE5nzjxEmUkFHr2y0VSqBqVpaxOSf+eTm/NWwc0z8jMQqhy68ml03vA3Jzv9Lwy9G + xhgHpWi6kP1vpNdxzPvPXd/2xa27R9SocPbq5voTAKrK3g+sx6q+QCy3gXRXNCqEjS/V6rjjdjgZA75p + 6cTdcBnRC1+Fs/IcpClOwQo1A3Z4mP6vfhB97PuBwaaylWAlvzcWrvyRvdCfXCBs8r+Td4OqRbsLo0Wd + Pr/ecjBoHqyTM+gxQVufkE2i3HkqNfhNQgBoqcGn7LPUMn1T8Zrb2f6G9zO49kwcNM/9N0n4M4bD8Heh + lnDAdcw7Up73g9amGAKcsSpeksPpmQIAT/3RSlqiEYzovVbldlRfU9mcn9LGFybfcSoy+GVG/JYuIhuf + R/TCV+CsOheJNQXpG2zR+S04LS04F9zE0Xt/TVe8L8zuJIWwlYO2WOCNucaiD0verxZOVUq1x6S/U0Yg + l5pejQFOx382IRQ67vOTscIqe31FbVqg2WkJAaQlplFS+nNydWi5TjfJ6ZlYpX/tmQwvW4/Jh1/AEEAs + oWpfIAxCwA0UCIggRCD8LFg8uVhV/z4ejRzwrP9wpxsvy+G0CYDTPvEc+29dSfpYZBTRL4O8BKW9ZMNW + YvCTMlK+DNwTzuFsYNgzrd24Gy8netErcFaei8RipcGnULBEF6/g2FAnfn8/cxeAER3bgZTSpJ+sq29C + ICcSkFr+PJmRuhz8WgqmCUZadOw0bIw2pxNfW576UHpaUkZ4lqqj6IJ0MraMkvDnBIMXb6HnnCshHsdg + c/AXje650T9fGORBXzANyAmN8O804EMRx/mdIU0d2bp3lM3L4vUjAI4NKqYVhj/3h6Tv+dIdtM25HXhV + qYczaWv/BN8Z0zmya83DHXhVMa1dRDZdTvSiUNWvAPwCRKzFSyuHjxjEKHPmaKAJ6ESQnoBBrYLvaZXq + yT0TreC74xkpdeL5doXCvHLXIRXUVwyyFAq78YTruEIxvF+19K89g6E1m3OGvwy4JeAXkw91HvSm8HeF + hsHM73ixou9panb/xktZb/uhFBsWRqdHAPT2KskuiA7l2soOQ+y1n3Rb3/pJM/jZ3/+BDva8WFq6WyTe + gTS1ghMFJ8IYU4WWOclEU4J8b6P1g/x8yRHscB/afxQ72AO+xV13EdELb8BdVTjiK5UZTVQg3d+HTYzi + Wzhy2CBq6e7WXLJXrVTlHzsalfZTlwaywGjKBN6QCjwCWsF3Khol8655rHAqc70lhb2OY/Ev/50x91yu + jSsWJOWEXf45LOnmNo5efC3a3Byo/xlV3xQLgsJ5fUGQUN53xwqC3FoCETEi8g4v6d/t+/qjSGws7jUX + AD1Dwd1bAviNYKwwF2UDcLaB0/1h1je/4V9Wa2KoCcdFnEiQ/DFMpV1xmcx3M/N730f9NKSTaGoE0kmk + a3EWfLWVyZ6CyxBI9vRgUykEwfpw9IggKJ1dFGoCYzQdrRyichpPAQySM5hWCn+J72WuTVUyZtiikV5K + wF3O3lHahFG5wbASUGX83xZcU4n7GaMp6lhhW9Gy4cKT9m2+kKE1m5EQ/mJ3nilS+4vhlzxVv+B3ImOM + iGFm9DmI/Gkkah7x0/7BHQdSrF8cra0AODSozPOh1wkbYwDoYAFwvlWuQbkMWA10ELhAg11y4u3lH3Cl + UE+qCIHAcSEaR1o7c/X4JyBU8q4heawHm0oGP9cgL2jP0aCzdXQWOc9Kuqsm6uSVzPkpE0xDBXCUuzYd + qxIXX7yW+bGW4O+Erm2skNByxtIJ20/LSCNK2GwmMmaO85m1pDrm0nPJtRBrys39TWDUK4A/NOoVGv/I + CYPMlIAShkIKPwtfP0+UN69eHP37XQfTqGomdqC6AuDQoNKuMAwcd0CViAhn0s71KC9V2Ai0VvSgp6No + hccqqCcQACkck9t8xPrQ2yOIKu0dOU3gpPz8Ja5TdQIQykJQ6rxSXjhVMn3Ig1YYxxYxHmT54I9nMC1u + m4m0g3GF0zjtVirIagIBo2LoPf8qRpevywv6CeE3RfCP0QooOyUQKTIUjqkTjOCI8NbnDqW+b0Se3HXU + y15m1QRAz2Bw9yPBIBcT4WIjvAl4CcHGoKdMUU9JHesJowtNrpcGG9VwvDdAob2dwoSikx5dxvHzT1RH + hd/TcesoBW+JmIICprXIJlGJqj6J69N8l1CxG1LKX2uBq6+S9ptooNDsacQqI8vX0XvpteC6oesvHKVN + nsGvyKiXD78UTQkkD34JVIhsnZh8r0BWMKwT4c3xWOQDybRvqyYAeoYUY4LRzVGML5xjhN8HbgDmnkrg + ZwYHP5kkeax8thbrQ19v0Efa2vO6Ybkgk5KdvPC1TiRAJhkzkfW8VFRnGRqLrlnHnoCy3oAx72USwrFs + GGWRQNCin2g2sEkq8TSVaTcpuATFb4rTc+UNpOYuDIN+Ql9+EfzlIvykXHBQmZE/Fy6cqzOs/+ZUyv+y + CFv3HbMsnWNOTgAcHQzu2PPAGBZ58HbgrcDyUw78fMCTKVI9PYy3v5u1MHA86GgtbZkxaxJW+pIQVAIS + E08NioNeTsTaX3Q947vmJvBynOy1TGiTkAIbR+nrlbEVjxPNmF9f3xmXMHDGxbm5PkXquxSN7vnaQP6c + v9DPXxAslG8PkGwm9bzvBbaBVUbkVcvmmK37eoMrPCEB0DOi+InsW0eEF6jyAeAKpmGJcb0VP5EgeazE + Bq9a2F+thcH+YMxoaWXiDj4hcHkvxlV3GTcqrzI/epEFvYAaKSFsZJzPqUC4jfdZnto/xq4xcdtVZpCs + QADlnzZ8wMmFy+l5wSvQeHM49y9U3wut+Ix1+RVF/0merSBfMBQaAgs9AYacxiCGV+47rp8TYf+BPp28 + ADgyGIxT4oJAp8I7gXcDC0518HMMCdHObpL79xSO6mOnnFgLQ/1Br2lumditN/5nFajiE3T2iq3zBb1d + y4JZPLIWCo8KhVnZz6XEveskBEcFHpKK2j4ngPJVfxuLc+SFN5Fcujrn8y+auxeM2ibfuJdnD2BiW0Gm + XkTHfha+D3ZKk41GeL4qX1VlcluQHh4IA1mCre5WK3ycQAC00yjZDuI0t9C2aTOpw4dI7t8LBHaSzAY3 + kg0AyXkCvFRwzHUl6zqcqCOXXNJb8rcVGgYnfF/JQphxvAYVvy8tCLX4WialJZQ6XsE0ptR5KPMsir53 + /OKrOXbVKxDXLWm1Lxili+DPhveSWexTaCswZZYFl/zMFNgRXBFJCPJDEfyKBcDhQQ2erQURzgH+Bbge + pmgf4xlWYvPm0nnuBXiDA4zuehqsn8nwGs7HcgIgSJMY2lIEXLcIgnE6tFKBwBhHgMhEKv9kBUDm0MlM + ZcbRDgpWgpatq7wAEcaN0ykhHIo9Cvk1lf6pWMvI6k0cvvHt2I7usvBLgVGPwuMmXBhkyHMR5guLwteZ + vlXqMylyMYK2ifB9FY5VBO+RwTBqKQ3qcAXwbwKXlG6KRskA5bS20HHW+WgqyciObcEOwpIJ/MjbPjQv + 4NFLBVA6GU2gGFrN7+SVeA3C9Q3FG5Zq7vc6oYdAqCgcO+88QcRg8TknL2S0LJxF96VSvk1KTnPK/VYm + jLMYI2TyP7eWdNc8Dr3q90muXJ/1+RfM3U2+wY/MOv6c/744HqD4s/zFQVmhUcJjYArtA5Lbz7IZeBh4 + fEIBcHgwcIz4PuDwfOAzwBkNzCuTBCYeo+30c9B0mpHtW8HzsoYb8uGXnNPA9zK7WhcCWlIFriR4qbjz + llrfPm4dMikNIz+wLvcnuY1+yVtpPc77cUOFy17D+J/reAKsuA6doE3yj4UXbKNNHH3Zmxg874q8UX6s + Wp51040BuMRqwKLP8gOFilcKlltFWOSQcoCDHvLTcQXAwXDkVwvGcFkI/2kNsicpBKIRWjefhR0ZZmT7 + VsTaHPxSNDaHTmTfC5R745SIoMtXZCehPo/t5JLT4CYTM5A9No6br9J6JoA2p/ILZefjJXILFAckacEy + 5hJaa0X2BBnr5y84tdB/2UvpvfomJJKX5bdm8EsB4MWrAU1p+DPFN/DdsgJgpyqpKMQSgHB6CP/ZRY+r + USqTAZhYhJZNZ5LuOUri6e0F8OfvgJ0TAmD9nBCA/FReFcJfAbjjd/5x1OSic+kJ1TNZgTURoOXr0InU + +iLBWHpqUOLrmSQfqgyeeQk9N74NbWnPBeWUAFzy4C8d+ju+wU9OfOTPL67Aj8u6ATuOgzVghUWi/D1w + AaWSsjRKRRJAfXDa21n8tnfj9Rxh6IG7yDpti1zqWU+2hVTCompwY0XQTAgM5YUEjJ8BOUfNOHVXbhAs + X095qMcKFJ1Yeyj6TU5zkkm0kY7bbiU/spbRNafTc8Nb8Du6s6G+ZhLwSwXwZyP6Cub2hUuIpTL4AdoV + Ti+pARwcVNQAQlzgb4E30Bj4qyIInLZWmlasYfjxh/D7erOuHsi5CDPdLTMdsDb0HJiCbn0C1vXyPE44 + ypY7VvIccoJTivx/cuLXkOchOZHzFx4rYe0vSO5pSS5aydHXvIvUsrUIOnZhT1YlZ4yrT8YY9Ur9rrgO + KVwnkDUW5lYR5hn8SpOrRIBtYwTAgd4gOsAdBI3yZuADQLRBb/WEQGTefJyWNoYfvhdNp8IlmxKO/kWS + W4L1/OrbXCBJQceeQDUes+IwX/UuoVVUPI8vricrtiYBmOQlaM3/baXq+vj3o5OCvJS6P4FAtBZvzkKO + vvoPSGw4O4C/FMTZUb/QUi/jxfaXdPmVXw1YwZy/VDkwZgogrUAC/FbOAf4MaGlQW/3S+fxrGX3yMY5/ + 97+CFWN50yspE03rJS0OgolUCAkUpDBTyiTWHC/YpSww+Rc5zrxwXAFSGEas5cKEy9YnpVf1Vdo2Za6j + XLhysa/f65xHzyvfwejmCwrgL4zZJ5OeK/DBl0jxlYvWCwX+mM8oiuwb+7vM64nilorK0gIN4OCAomlA + aRHhI8BVDVRrUyTiEFuygpHHHsLvPZJL4gBjBuXsdABQP1SQTaW++SL4ywW0VCwAiqGbQICUq6MIVB2v + Hj05cMcVIBUKxEKDn8Vv7+bYq97ByLlXFKTuLlDthUK1vUT0n0j5xJ+moI6qjvyZkihcuOMEqiaiNyr6 + Cg0fTKE/t/F38n+KWogsW0H3TW9EmuKFOxOVGHnyU9fZlGLTmslYnvuD/EzmecdCaLVE6uviWILiiy04 + LmjoUsveh5bw7zPedYV1qOQdL7628a6hBPwlmm3iPyn6P/5frnKL197NsVe8neHzrszLw1d65M8Z6YpW + 9ZVYE5CNDzH5r8fXGIpH/kn+dWU1gP19fuAfdWQJ8A/AqsY4XWs1QIgsXEJy5zbSe54NekvxAEVhpGBW + yvvFB0qPekoZF12Fan8uzkWCoUBPcuQvUtk1bw1+ZaN/oXqULxiz1ziu5kHl5yo+porfMZfeV/0uIxdc + hRgzdiVfkZ9fxvXlF3kJKMzkk5/uq0BjKGFjONEemLUBiEoQH+TzajIuv0apbVHFaW+n64bXMLrlIXR4 + sLCfFrgHQ2NgGP2vAng2TKdocqnNS/VlzZu2V9LpxwiBEkttmcw8O3NTud8Vb9oxYYQelF3lWGDgHDP/ + n+y0oJRwVLCKN2cBva/8PUbPuaxwBB+zOo+80Tkz9x+7cq/kij8pWicSSv+CkT+cE57AnL+4RB2AfX2a + eT7LgI9yiqXwmt4iuHPnk3x6G6ndT4cPduw6gQwmmV2Gsthk9iAVKVBnJ+wVk7KQl5jzTxaoceCflAFy + grY8Ofhz0ZGa2SKCYB6TXric3le/k8TZlyDGFI7MZfz8E0X4SdGKv5xrb6wnQGRSQT4VD0EugFWIGMWq + XEcjzn9qiyqmuZmOa25g5MG70ZHhkhG/GRdh1lYQfiaAhpoAxsn16RNJcDoeuKWMbBPVWdbafwLAT/Y8 + E0WsaYk71dLLGpMrN9H3yneQXHd6QS7/UiO/MWM/MwVaQN4IHk758vP5F4/u5bwEJznyZ0rKOTCQGTNM + t8IHBVY3VvhNIf+Eq/+6uhnZ8jDpA3uDuSWlNADy9hnMex0mngRB5QTmuSU+V8qM/OPVOWaaMV7o6Dgh + zZqVeJUHHpW8PqlYsJTJ6Uli80Ucf827SIcr+8ad8+ct7ZVSXgFTeuQfGxtQHANQ9ZE/UwacweSbufLK + LoAXEGT2iTWwnPoi8Tg6NMTIQ/cGMcAlon5zX85fKiw512FoYLMi46yyk7F/OvZY4ah9AkOCjmOpL7VG + oCAISCaUUYWrDDWYAo25Ty1S50usTixpNlA0EmP44mvoe9U78OcvKR/eS2lXn8gEBr8SAqSkga96Br9S + 5YD7f/7PakRwVPVlQFsDxekrzedfgjNvAf6h/WRGQNW82IBiY17+IJk55tnAnWtMCcNaGSjLjqpQ0eKP + CacOlfyugvl6AaNSeL6SqcFLx8COmzzVWrSti8EX3czw5S+DeMtJwy+TgL8guWdt4Qc46oZ5zBYrXDm+ + d7VRalosuIuW0nTa2Qwd2AdOqNpLcRBK2G8l8Nzks501FPo2HN1M0TZ7E+zCciKGwzHfKae6aFXq14nc + BcUrJkt+VuZ3avEWr2bg5b9N8syLEMcJ9KFSufgY6+cvztYrpijTrymc/4+J7CM358dU1dpfruxzw+dy + PrCynjbpOfWKYpqaiJ99IUP/+9Ng84CsDzAEntwClzFdvCBOVRFrESPY/CTN1QB8wu9pGd5LaB3juSbl + RK+3aJlxJfVYBdcleeblDLz49XhL1wSjO4Wx+IVz97Hwj1Xzx1vxVwh/fsafKRj5M2W3m+gUifXpJUBz + A8JpFgEK8U1n4rR34fceDQODQuyLs1wXW7FlbJJQ4/uoAV/M5EHXceCtlsCYVFJPqex0k6mTIKbfdnQz + fOWNjFz+crS1A4MtyrQ7duSXchF+5az9RVGCZOMFcrv5SOhKmIKRH2AE2O5G+7Uz1AAaZdolALgLlxBZ + thLv2JEA+gqlf4GtIK8+scEqQitm3N+WL6Vi7iu8oEomk5MWRmU+k/FuRMY6NFTBGFJrz2To2teR2ngu + 4jgYtTnVnSIrfihoc0tyw8SdRZtxBnn4CzftyHwvm7ef/Dql6PPw/WTae/JlENjqAkuBtQ366kEAKKal + leiq9Yw+fD9qgkwzkBMEkp/RVwo7eemsPIohsAlYMRVp76UPahnoGB+6SQi/8vWV+KAi9yClDX7Wou1d + jF78YoavuB7bPS/r/2CcGP18Pz/5oz1l9uor/l525B+7dmCK5vz55TmBXS6WzQidDfrqpEQcoivXQCQK + arMuucxoEHgBpMDtN5aXnO2A0D1mCOqyE47KUgGQJaAbL9y4UoGj41xLpabpcW0LFoyLt+Eshl94M8kN + ZyOuGyzlpXBd/th5fWGQz5j4/aIFOmXdfiUSgkzhnD+/POr70uuqsIkpXPOfnxFXNZhPkV05prOuvkmf + XyGyZHmwQnBkiOywUTJNLmO2GysERgu04gB/U2gTmATgJSNty76Xsdem41VWKEkm3dITbB0mgD9nEYlL + X8roxddg27sxEqa7p/wqu1Kx/cXwl/9d0fqAcM6f1QqmZ+QHSAP3iqNpF1gNmJr5/zJ57kSwvs+RIwfZ + s+tpjh87iu95tLZ3sHT5ahYvW0Essyx2gv6RX9/RI4fYs+tpeo8dwfc8Wto6WLpiFUuWray8vhB8q5aj + hw+yZ9dOensy9bWzZHlQX1O8eeL6Tra5FNz5i5CmOHZ4KMeOMGafgPJegML3mhcxaFCs2rHTgZOZi+sE + B8ut6Cs5UsuJXUO576qF5jYSZ13GyOXX4y1dE8Tyh4uqDPkbc5baqLNozi8l5vxSIg/AmOOMsQcU2ADy + g7tq6YsP6j6kcL8ArirL5EQat3L2EYS+473cd+ftPPbgvfQfP0Y6lcKqYowh3tzCmvWnceXV17Fi9bos + COWXdgj9x49n6+s7fox0Kjmmvite9HJWrlk/cX0iDPT3cf9dv+DRB+7m+LGegvqa4s2sWruRK6+5jlVr + N2a171o9I9PWgWnrwOs5kpcJJE+7FfKcgYyx0UnR9t46ZnecIBbOMlHiuBMBcCL//AnCPNliLUSa8Nac + zujl15HceC5Em0LwtUS8fuGcPLt5ixTN+cfZpTebrC1//p8N2y6uI2/kL0pZXvO2Ue5F2aWA7O61TwEb + a3UuEeHY0cP84JtfZtsTj2CtzRvtFFXFWou1lnkLFnHDa36bzWedX1bdFhF6jx3lB7d9iae2PDxufXPn + L+SGm3+b08+5YNz6+np7+ME3v8zWxx/C+n7Z+ubMW8D1r34zZ5x7Ue0ejgj+QD8HPvAuRh/9DeIYpKLx + UUr3G8kkBAnqzoYGi+BjgrDhE+lsWuL0J9ppq9XZMzfnuvhL15G45KUkz7gYbW0vWMRTyl9fKsJPKojw + Kx7tC+srvyZApn7Onykp4B0W/jNuBBforiX8idFRfv7Db/HUloezxzJgZf4yxw8f3M/3b/synd1zWbJs + 5RhoRYRkIsEvfvgtnnz8oQnrO3LoAP/zzS/R2T2HpStXo3Zsr00lE/zix99h66MPhIyUr6/n8EG+/83g + +pavXluiviq1mxvBaWunlOVbJ+VZk4KpQoEZQRUjQcpxW42RudLVeiJUvcfngW8XrSJx/gtJnHkZtnNu + MM9Xmxuh80b1kuvuw0vNpmErGMXzP8wJbMlbzlCwy1MB3EW/y6V2Rac28m6HCr8M00ngAq01m3IIbH/y + MbY+9kDuWRXBlf8nIhzY9xz33PEzXvG6t+A4zpj6dj71OE888puK6zu0fy933/FTXvWGt+E4hTlQxcDT + 27ey5aH78jLLlK8PEQ4f3Mddv/oJr176DlzXrc0jcgzEmsJ9AIssaJrreHmNUMJNLwVZv8iDPzM90Dyd + 0zLxIpyS4JVIpzeRa9A6kXDpcgU9byK/pSq4UeyilSTPvoLk5ovwO+cG8/YwWYLk7cKSv4xKQ6GQS8oq + eRGXBVkXst/LLsu2gAlMDDaT/gsJzmg1XMqbAT3jxQm0i6xvp+ROp7UtIvK9lfPM3n3HYW234GqY8rsW + l5FOpdi25WGSo6OIMePClf/35JaHef611zN3/sICLcBLp3lqy8MkRkcmVd9TWx7hWM9R5i9cXFCfn/Z4 + asvDjI4OI1JpfbDtiUfpOXqYhYuXVt8zoKFkikTGHxnKWNzHTCF1/FR7WZuABBGxk9blK9qGu7BYwEai + VJxVqMSXRBVicfzFa0iecSmp9Wdh27sCw152NWXgDlWR/DvNtVqmbUzo4ZE8D0TYHoGhUDN5V4Jqbai+ + Ww3gF8nGawi5HZeNDXbUzsQPqA3zt9RACapwQN4rRr+585DVqBsMrm5w+zWRNCRHRzm4f09W5awEMICB + vl4OHdjLvAUL89zZwXTi4P69k6+v/zgH9+9hwaLFhfUlRjm0f092JKy0vsGBfg7ue45FS5bWQH3TMHzU + odCVllsaqGVDc6VA29asbMi3D+SWwWbNgUphnEGlq/JKJQmqpD18DxUX60Yq0jmCgVJzJ2rpwFuxkdTG + 80ktX482twbzdqvZRJpjrouxAlMlNzIXOCbyNK9CcSi57dRDI6qgiA3m+1a0YGpBni3AKohoHvzTsOJG + +JY60S3i+Zy1ULICwFMlWotpmed5jI4MB+8rBFZV8dIew4ODY+rzPY/RkSEy/u3J1DcyVFSfBvWNDA+H + m0dOoj4vzXBRfdV8SqoW9bzSO+NqBd64/Hl/QeptGbPzbv57QbGa+55U8pAnNXJnBIBFvRQ23jrWvVkO + fDeKdi0gvWozqTVn4M1bApFoqF6H47OQVamzckzyvRx5Ow9kBaCOTX1gcr+xqqHtIAgWshkzhko2gChU + CrIJxXL+AM1OAHLHdVrYB3YL+kWTTPhdLQ4SpgN1VRkFotUeyYLwSEMkEkWtDSPSKgNMjBAN58D5GbBy + 9YUj4WTqixbVJ2F90Wj4kCuvz8jY66tqw/kWm0qV1K7LJ8mRskwW/7fkjf6hkNA8G4ItqHOSFqJKJUdy + FNtisU0tlNnNM5jmtbTjL1pNevkG0kvWoC3tuYxJVgNrvUrBnopSNpuKjMltKgXDvBRFM+Y2axSV3Jzd + 5qq2eXP8DPaimpv/Z0d+QcQyPUVURP4z1h5/LDmU5ue7I9lPXKAP6Kj2KRWINcWZM38hB/c/F8ykKoDL + Wku8uZX5i5YU+q81qG/ugkXs37trcvXFW5i/eGlRzgglFoszd/4i9u56Gkzl9bXGW1iwaGnNBLn6Pv7w + UNmVssXbfOWnwtY8uPNzchSk984L282Mn+SN/IXnkRN7+BNJOd9DhvuxLR3BBDnzkI2BeCt2zmLSS1bj + LV6N39YdjvYBTEHGpNxEWkTz1vtkRnrJ6jGFuYfzd2HVvIzHpSRxDviMoS8Y+fM3MwtHdi30KEje/D/z + 2fQURYT7jcvnRwdG1TWGd5yfuxhX4RiwovrnVaKxJtafdhZPPf4QnudlwZsIsNXrT2POvIVFnV2JxmKs + O+0snnj0Abx0uuL6Vq3bxNwFi7IpozIlEouy7rQz2fLw/aTTqYrrW7l2A/NCAVULIWDTafzBgZIjVi4z + kBQsgMvN/YNRTPNI1qLjxVOArGCgUAhUxPKJj0rI6BBmZABv7hJoasHrXog/fxneghX4bV0QjeXyImo4 + f87unVgQCpUNwMncS36mJMmPdchEUlE0yo/BRjEF+ZiDub5IBvh8N6JmDYHBSJ/3n2mc8wc33G8M/+CP + 2L2mxfC8VU0Fn7rAAeDcWp1+89kX8tiD97LjycdK+tgL4fLp7JrD817wYqJNsTF+dlU47czzeeyBe9j2 + xCMV1dfR2c3zXvgSYk1NJevbdOZ5rNlwD08+/lAF9VnaOjp53gteQlM8XrM4AJscxevrrWwZvoyN9Kt0 + MC70CIy1ktcqJjVMw9frqO520skHEue/8NqR+atW2XhrMNJnwAlH+ny4c3Vokd1Rcnsq5i+SCt9rWStl + fnrlTM1B/gWbHycQVmvCixfRIiGQl8Q1lBsGauRfr7wY0S84uD9QJ/BKFBcXeK5WJ1dV2jo6ufaG1zI4 + 0Mf+PbvKQub7Pi2tbbz4xteyZsPpJeFSVVrbO8L6+tn33NNZkEvV19zSyrU3vIZ1m84sW19LazvXhNe3 + 59mdWaBK1RdvbuHa629mw+ln1wx+BPy+Pk9HRwQR5wR+Pt6ygDHfrfXYFLKQBnodIwdQ7neNPOnA/RH0 + 2Zc+/dNjnz7zC6/TkcRnVLXdaJ5BLxeCU/7isyKF8s6L/M1Xy914ZmPWrP4QHMxM+zOqvQ07XAH0mmf1 + z/tMa966E7S9yK9w5B/TeMlYxHD5mtYx33H+8M/+Zg1BRuCaRLUo0DlnLstWrWN4cIC+4z2kkslseK21 + Po7jsnTlGq579Zu54HkvwHHccS3dHd1zWLF6HcNDgxw/NrY+Y1yWLF/Ny1/9Ji66/IUT19fVzfLV6xkZ + HqTvWA/JMfU5LF62kpe/+k1cfMU1OG6ktqox+suhH33z//qJ0QfFSL8gjoAnQkTAzQ1uMmab7JLz9vwI + thKGMS14LeORNiHsBhICx1wj+xzhTkfkG03GfMUxfLTZkc+c1RX59oFR/z5gv8DIw+/5N7rWrN42mki3 + WKuXkQ2Rl+zon90MpWi0zRcS+dun5W+uUvCsixa9FKcXzL3Pm3gWJRvVAnuBFmQiznye8SjZafxTeMYY + 3p1K69b2Fvj5V9q4446/HfvMnu6xLwS+DsypsTRidGSYZ7Zv5eltW+g5fBDP92jv6GLl2o1sPP0cuufO + L2rgCeobHebZ7U/y9LYtHD18AM/zaOvoZOXqDWw841y65y2ASdSXGB3h2R1PsvOpTH1p2to7WbFmPRtP + P5c58xcwRueuTWN98PAH/+hvBn59B26UFpvw2hyhC5FzPWuXqa/zROR0YJm12qoQB1qBmAYmsULbQB7o + YzfDlAI7wBgPQf4YHEDlKyRRho0w6oj0Ac95qtujIkejRvb4yuOu4VhHRAafHkyPdEQdrELMCHEXUsOj + NC+cz1V33MFnf7wXEYi4pnNoJP2ptGffmMFaJPdsJH+fxPzjRQIim3AjIxqyqnne5/mfSf5rybvP4nNK + QZhvdtHPmOsTJthArWYlL2Skx3XMO4+PJr+xuCOOceGqjaXt/LKzxy4DfiywuZYXJnmS2fqWVCqJqhKJ + RHEjbhjVqRU1Ws3rs0oqmQjri+BGIpOq7yTbahT4LeC27ZeuJNLeiXo+JlzMY1X57mN7ee2Fq9o93zZ7 + aeuKmPkYXYeyQJVW32pEkW6BRQhdIO0KLQoRVYwiRlGTFRaBI80GO+CJL0JSkWFV+i0ct8phgb6IkaQr + 9CNy2Lf6rMLRZkfS8YiM3LZncOjKeS24oYSIGGhyhLZYhFTa46oHHyx7z5/7wV6sAXFYPJLw/9339WXk + KS35cfoixQpNKS2hMHa/ENxygiX3m0LBUXQdxecacw0ZcTk9+IvIoOOYDyyY0/KZ/sGEL8C1Z5V38smO + HhsX+Bzwuim82mxjVi2UNmsVr9P6Ki/7EK5BeWrtHMm2U+YR//Tic4imPNQI1lp8T3OLmIIGxbPCy69e + LXfdv6/J9zSqqq5n1bUa5H2wglhfUUSCDTVUwxVqKogag3VFvIiYdJNr0hf+eH7ivy49QNTJBdn5Grxu + cgTXgFUhGYty4333TLrb3/KrXfzy/z7OTW87k3iTu2Y06X/G9/XqDEoFcObZ9pCxo3wxoLnfSenfFU0j + xvyuhLApFh6FG7VMXxFh2HWcD7e1xP9v2kunQHnZOZ3j/2bnMQvKe4B/Ytptlo0C/Bi4GRhaN3fyUdq/ + uWAzLZriqGnBDyeoqgGwmcAlG2o5mrdE2OT1dhMubAmSWwrGWDqbRkl4ES675/Ga3PTXfn2YBYvbeOzR + wzS3RtclE+lP+lZfnAO6UEsrLQSKAoIKBELe6F4K6vwRHxkjAAoEA0WrB8NIQSqNoKxi0ZwPZDDiykda + WyKfSKdJgHD9+Z0TC42dPRbgAuCHCvMaEmB6Sl7H+UtP7Uei4rBm7qn1NL5y92Hmz2tj27bDxGOR5cmU + 9w++rzdp0UrcfBiz8/Uct2PALziWf7xgRM98qiUERwntoVgwTWO/MUZ6XNfc0t4e/Y9Uwk+pKq+4cG5F + v5cdPRaBdoVvAlc3UJzWcgy4DrjXIKw9xQQAwFfv7OH1l8/hMz/aS8yRuUnP3pL27VtUiRdY+QvALQwE + KhAGRd8vpSnkC5ZCDaK0AMn4FGXaH4/gGHk64pi/2LRq/rd3Hey1VpVXXTS34hpcR4WUsQOOlZ8ivKjA + DdooU1cCTe4hhK3AKQk/wBuumEvkzoOMJn3cZrenpTX6p8PDqac8z37AWhYTRgXmkrfkmi+3Tq8oDFg1 + u8oxuyRIi9yGaJEwKBIMBcBrGZfq1HUUEVHH8AvHkf/Tm/Dv3XWgF9/CTZfMnVRt8vRRJdxdfjPwQ2oR + FtwolRRf4T2I/otYw/r5DSn82Z/sxRjh7dd8m8/++MYrU2n9P761z89G6ZI/cuel8CihmksRsMV7KhTz + XFhP/qYMueCkqZzv50drOoa+iOt8LhaL/ONwMnlwfnOMpLW8+rL5k65XALYfVYwQsVY/rfC7DRanvgg8 + RaD+PyNIQwBkhMBP9xKNuPT1DtHe3jI/kUr/nufrO6zVxYV5e3INOSaUqRh+SpFbOjefjImpknGXMNcO + fjBgHcfcG42aj89tb/pR/3A6ffWm+dy36zjXX3Rimf0E4OB2n74OULgK+KbWME9go5R9EB/pSpm/Goii + GxY24M8v/3X3MVas7GbrlgO86qrFctsv917kefpuz9eXW2vbKTVrLVLlC1+WipSEknIhW5dM33IeIZjr + R5zPx5vc/xwYSB3s7oziecobn7/wZPsdbO1X/BEPgbgqn1fltY1uN6Xw7xKRG4AtjhhOW2RO+TYpVT7/ + swNEIw79w0m6O5vj/QOjV6XS3ts9X69S1Y685ftUpKKPN5KX0hqmsGS2fnMc82zUdb4Rizpf/u0Xvv3J + L/7qP5g3P8bQoMfNF88/6fNk7+sz2/dwaesiLPpCtXwd1Tk0ytQIACN/19ri/tXoqG/PWOQWBP80SmH5 + xoO97H+2n445TQwNpWhri7QkRr1L02n7es+3V6vqEjteRz8ZSKamN2AMCccxT7qu+U4s6n7rpssXbfvW + rw9qLO7ie5Y3n+SoX/LeHtifIIKD45pYMuF90qo2bAFT8rjZ6hh5pcIOxzGcvSTSaJQKylfuPMjrLl/I + 5362j1TKZ+GctmhP3/D6lGevsVav9X17llXmqaqZrO5e41DvsecL9gxIGEf2OUbujEWdn0Qjzp3/c+eO + wy+9bD3tzTE83+cNz19Qi/6XK/ftGs1EOZ3l+/abqo1dg2sKv5AyxvzRsaHhf13U0c7Zyxqj/2TLF36l + pEZ2EIm2MZpIMzySZMGC9raR4dQq39fnpX17jsCFnm/no3QCTVandYluZknHoGOkz3HNMwL3N8WcR8XI + fcsWtx58dnd/OuIa2lqa8H2fN1RxxB9XAGw7qvQNJHh2cJTlzbH3KHwc1caQVKvGN/I/Udf5LVX6XMdw + 3opoo1FOonzxf48QiboMD46SSHioWjZvXOTu3nOsK5mycxwjZ6U9f0Uq5bcaYYlxzCKCdHhRUKeE//Ck + JYUEO/EkVDnm+Xa/Y6SnKeYeFyNP+Z7u6O5sGvjmLx7rv+q89YhAa3MEM6gMLYJ3nL+49n2w+MB9z4yQ + DhaKdKq1/89afVWja9Wg4UV2O468zle9b0NHC4salv+qlq/+oI+DFz/J/CfWMJpIkUz6OI7gW2VgMME1 + Fy+L7OtJNCXTNmJ9a1StSEGygZJ4TLaoa0QdR/zm5kjqJWe0j37iu7s0FnGDvAEK7a0xmtwYVn1ee8Xc + KW+nknf4yYce5/TmVTgiZ3u+/W+rtds78JSEH0aN4f2Pbnr2M+dvW0dLU4TzVjVG/6kot911DMVFdZS0 + D74NFkaBze0gFLBbDQEQLqYSHFcwxmGgv43mlhHecHlnvfTFseW+nUl8L8WxFLQ4epPn62cVbcQGVKeo + 45h/jcfcP/U8OwLw/E2tjVZplPoRAAB3PjWID8Sbo25f3+gf+77eomisoaieIPVhYxsjP4pEI2/Dtwdd + heef2d5onEapPwEA8IutA1hVDLQk03pr2rPvCowljXIixRi5N+Kat6naJ1ec1cVh4KqG1b9R6lUAAPzw + keOIgmPoTKT1475v3xJmR26UCkrGjOwYeTQadX43lfAf6JrbTDoJL9ocbzRQo9S3AFBVvvfoIK5aQOek + Uv7fe779baChCVRYjJFHYlH3XaOp1D3zulrx1edFmxqqf6PMAAEA8Ktf7aKnu4OopxgxXcmUd0s6bd+h + qrFGE47fuI5j7orFnPemPPtQZ3MTClxzZlujcRpl5giAQAgoPa1HiKhDNGpahobT7017+sfWamdjOlBY + Mqn2HGP+JxY1f5ZI2e1zO2OkPeVl53Y1GqhRZp4AgGA68O37e3AdQ3dLk3vo+MirkmnvQ56v66ZzB5R6 + K0ZkMOI6/xGNRv7eptNH5ixoJjmS5iVnNzypjTKDBUCmfOe+HlzXsPWZPlYvaz1/NOH9jefrS1QbHgLX + kR3RiHPr3O6mrw8MeskD9x9i6RVLeGVj5G+U2SIAAL7/UC9RR+gZShJ1nTnJhP/WZMp/p+fb5adiQxoj + I9GI8+2mqPn4s/sGHt+4uhPfh5sumdfoZY0y+wQAwHfu6eHGS+bw9buP8prL5vFfdx6+cDThvdvz9Hqr + 2q5TnSR9qkuwnb11HPNQNGr+eV5n03ePDySHO9tiJFM+r2rA3yizWQBkyjfvPUY06tLXP0xbczTeN5S6 + JpX23+Z59vnh3nXVO9n08p4txoh1jGyNuOaL8Sb3v/t7EwfmLWjhQH+Sc5e0cvmZnY3e1SinhgAA+Pb9 + Axw8dJDurk76BhPM7WptGxhKXJVK+29Ie/Yqa3XejNYIwms3wqjrmkejrvl6U5Pz3Ucf3//cmacvpbUr + RnrU47WXzp+hN9goDQFQhfK9BwZYu7yNR7cdZWAowYI5zU29A8kzU2n/5b7Va9Npu1FV21VniNdABCOk + jJF9rmP+tynq/CDW5N65Z89gz+LFzbQ0N+F5Hq+/fMHMuJ9GaZRaCoBM+Z/7+7juwg6++r+HGEl4/P0n + 7udvP3DF3NHR1DmJpHeJql7mebreBrkH24IlmfXAuyBCEuiNuGa/iNwTizq/cYzcvWhh2/49+/vTsZhL + d1eEZFJ5zSWNEb9RGgJg3PL1e4/iOoaBwRSJpMf+YwOctWZe57G+xBzHMRekPH9zKukvdhyzGWGF9bXD + Wo1ZVVMrwSDByK7GMWnHyLDAQc/qU46RXfEmd7cq9zZFnX1vumphz2d+tNcaEVpaIhwdTbOmtYkbntcw + 8DXKzC//H2KEQtrPXsHrAAAAAElFTkSuQmCC + + + \ No newline at end of file diff --git a/RPST GUI/RPST/Windows/PostsWindow.vb b/RPST GUI/RPST/Windows/PostsWindow.vb new file mode 100644 index 0000000..ca28595 --- /dev/null +++ b/RPST GUI/RPST/Windows/PostsWindow.vb @@ -0,0 +1,3 @@ +Public Class PostsWindow + +End Class \ No newline at end of file