From c5885bb41b2d8531dfdd178621a1aea7521c1001 Mon Sep 17 00:00:00 2001 From: Richard Mwewa <74001397+rly0nheart@users.noreply.github.com> Date: Fri, 10 Feb 2023 19:29:02 +0200 Subject: [PATCH] Add files via upload --- .../Reddit Post Scraping Tool.sln | 25 + .../Reddit Post Scraping Tool/ApiHandler.vb | 33 + .../ApplicationEvents.vb | 29 + .../My Project/Application.Designer.vb | 37 + .../My Project/Application.myapp | 10 + .../My Project/Resources.Designer.vb | 63 + .../My Project/Resources.resx | 120 ++ .../PostsForm.Designer.vb | 56 + .../Reddit Post Scraping Tool/PostsForm.resx | 60 + .../Reddit Post Scraping Tool/PostsForm.vb | 3 + .../Reddit Post Scraping Tool.vbproj | 54 + .../Reddit Post Scraping Tool.vbproj.user | 11 + .../StartForm.Designer.vb | 276 ++++ .../Reddit Post Scraping Tool/StartForm.resx | 1278 +++++++++++++++++ .../Reddit Post Scraping Tool/StartForm.vb | 111 ++ .../Reddit Post Scraping Tool/rpst.ico | Bin 0 -> 16069 bytes 16 files changed, 2166 insertions(+) create mode 100644 Reddit Post Scraping Tool/Reddit Post Scraping Tool.sln create mode 100644 Reddit Post Scraping Tool/Reddit Post Scraping Tool/ApiHandler.vb create mode 100644 Reddit Post Scraping Tool/Reddit Post Scraping Tool/ApplicationEvents.vb create mode 100644 Reddit Post Scraping Tool/Reddit Post Scraping Tool/My Project/Application.Designer.vb create mode 100644 Reddit Post Scraping Tool/Reddit Post Scraping Tool/My Project/Application.myapp create mode 100644 Reddit Post Scraping Tool/Reddit Post Scraping Tool/My Project/Resources.Designer.vb create mode 100644 Reddit Post Scraping Tool/Reddit Post Scraping Tool/My Project/Resources.resx create mode 100644 Reddit Post Scraping Tool/Reddit Post Scraping Tool/PostsForm.Designer.vb create mode 100644 Reddit Post Scraping Tool/Reddit Post Scraping Tool/PostsForm.resx create mode 100644 Reddit Post Scraping Tool/Reddit Post Scraping Tool/PostsForm.vb create mode 100644 Reddit Post Scraping Tool/Reddit Post Scraping Tool/Reddit Post Scraping Tool.vbproj create mode 100644 Reddit Post Scraping Tool/Reddit Post Scraping Tool/Reddit Post Scraping Tool.vbproj.user create mode 100644 Reddit Post Scraping Tool/Reddit Post Scraping Tool/StartForm.Designer.vb create mode 100644 Reddit Post Scraping Tool/Reddit Post Scraping Tool/StartForm.resx create mode 100644 Reddit Post Scraping Tool/Reddit Post Scraping Tool/StartForm.vb create mode 100644 Reddit Post Scraping Tool/Reddit Post Scraping Tool/rpst.ico diff --git a/Reddit Post Scraping Tool/Reddit Post Scraping Tool.sln b/Reddit Post Scraping Tool/Reddit Post Scraping Tool.sln new file mode 100644 index 0000000..8768cbe --- /dev/null +++ b/Reddit Post Scraping Tool/Reddit Post Scraping Tool.sln @@ -0,0 +1,25 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.4.33213.308 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{F184B08F-C81C-45F6-A57F-5ABD9991F28F}") = "Reddit Post Scraping Tool", "Reddit Post Scraping Tool\Reddit Post Scraping Tool.vbproj", "{46C2541E-6F65-461A-A479-F65D445C36EA}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {46C2541E-6F65-461A-A479-F65D445C36EA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {46C2541E-6F65-461A-A479-F65D445C36EA}.Debug|Any CPU.Build.0 = Debug|Any CPU + {46C2541E-6F65-461A-A479-F65D445C36EA}.Release|Any CPU.ActiveCfg = Release|Any CPU + {46C2541E-6F65-461A-A479-F65D445C36EA}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {11BEF8E8-2590-4D78-9D49-C518F26F3D47} + EndGlobalSection +EndGlobal diff --git a/Reddit Post Scraping Tool/Reddit Post Scraping Tool/ApiHandler.vb b/Reddit Post Scraping Tool/Reddit Post Scraping Tool/ApiHandler.vb new file mode 100644 index 0000000..2179f32 --- /dev/null +++ b/Reddit Post Scraping Tool/Reddit Post Scraping Tool/ApiHandler.vb @@ -0,0 +1,33 @@ +Imports System.Net.Http +Imports Newtonsoft.Json +Imports Newtonsoft.Json.Linq + +Public Class ApiHandler + Public 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 Function ScrapeReddit(subreddit, listing, limit, timeframe) As JObject + Try + Dim ApiEndpoint As String = $"https://reddit.com/r/{subreddit}/{listing}.json?limit={limit}&t={timeframe}').json()" + Dim httpClient As New HttpClient() + httpClient.DefaultRequestHeaders.Add("User-Agent", headers) + Dim response As HttpResponseMessage = httpClient.GetAsync(ApiEndpoint).Result + If response.IsSuccessStatusCode Then + Dim json As String = response.Content.ReadAsStringAsync().Result + Dim data As JObject = JsonConvert.DeserializeObject(Of JObject)(json) + Return data + Else + ' handle the case when the response status is not successful + ' return an empty JObject or throw an exception + Return New JObject() + MessageBox.Show(response.ReasonPhrase, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error) + End If + Catch ex As Exception + ' handle the exception + ' return an empty JObject or throw an exception + Return New JObject() + Dim logfile As String = "debuglog.txt" + My.Computer.FileSystem.WriteAllText(logfile, DateTime.Now.ToString() + ": " + ex.ToString() & Environment.NewLine, True) + MessageBox.Show(ex.Message + $". Please see the debug log file '{logfile}' for more information.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error) + End Try + Return New JObject() + End Function +End Class diff --git a/Reddit Post Scraping Tool/Reddit Post Scraping Tool/ApplicationEvents.vb b/Reddit Post Scraping Tool/Reddit Post Scraping Tool/ApplicationEvents.vb new file mode 100644 index 0000000..f9974e1 --- /dev/null +++ b/Reddit Post Scraping Tool/Reddit Post Scraping Tool/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/Reddit Post Scraping Tool/Reddit Post Scraping Tool/My Project/Application.Designer.vb b/Reddit Post Scraping Tool/Reddit Post Scraping Tool/My Project/Application.Designer.vb new file mode 100644 index 0000000..861d627 --- /dev/null +++ b/Reddit Post Scraping Tool/Reddit Post Scraping Tool/My Project/Application.Designer.vb @@ -0,0 +1,37 @@ +'------------------------------------------------------------------------------ +' +' 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 + End Sub + + + Protected Overrides Sub OnCreateMainForm() + Me.MainForm = StartForm + End Sub + End Class +End Namespace diff --git a/Reddit Post Scraping Tool/Reddit Post Scraping Tool/My Project/Application.myapp b/Reddit Post Scraping Tool/Reddit Post Scraping Tool/My Project/Application.myapp new file mode 100644 index 0000000..fbb5858 --- /dev/null +++ b/Reddit Post Scraping Tool/Reddit Post Scraping Tool/My Project/Application.myapp @@ -0,0 +1,10 @@ + + + true + Form1 + false + 0 + true + 0 + true + \ No newline at end of file diff --git a/Reddit Post Scraping Tool/Reddit Post Scraping Tool/My Project/Resources.Designer.vb b/Reddit Post Scraping Tool/Reddit Post Scraping Tool/My Project/Resources.Designer.vb new file mode 100644 index 0000000..cc0c0d8 --- /dev/null +++ b/Reddit Post Scraping Tool/Reddit Post Scraping Tool/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/Reddit Post Scraping Tool/Reddit Post Scraping Tool/My Project/Resources.resx b/Reddit Post Scraping Tool/Reddit Post Scraping Tool/My Project/Resources.resx new file mode 100644 index 0000000..29dcb1b --- /dev/null +++ b/Reddit Post Scraping Tool/Reddit Post Scraping Tool/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/Reddit Post Scraping Tool/Reddit Post Scraping Tool/PostsForm.Designer.vb b/Reddit Post Scraping Tool/Reddit Post Scraping Tool/PostsForm.Designer.vb new file mode 100644 index 0000000..dd8e8df --- /dev/null +++ b/Reddit Post Scraping Tool/Reddit Post Scraping Tool/PostsForm.Designer.vb @@ -0,0 +1,56 @@ + _ +Partial Class PostsForm + 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() + Me.DataGridViewPosts = New System.Windows.Forms.DataGridView() + CType(Me.DataGridViewPosts, System.ComponentModel.ISupportInitialize).BeginInit() + Me.SuspendLayout() + ' + 'DataGridViewPosts + ' + Me.DataGridViewPosts.ColumnHeadersHeightSizeMode = System.Windows.Forms.DataGridViewColumnHeadersHeightSizeMode.AutoSize + Me.DataGridViewPosts.Dock = System.Windows.Forms.DockStyle.Fill + Me.DataGridViewPosts.Location = New System.Drawing.Point(0, 0) + Me.DataGridViewPosts.Name = "DataGridViewPosts" + Me.DataGridViewPosts.ReadOnly = True + Me.DataGridViewPosts.RowTemplate.Height = 25 + Me.DataGridViewPosts.Size = New System.Drawing.Size(800, 450) + Me.DataGridViewPosts.TabIndex = 3 + ' + 'PostsForm + ' + Me.AutoScaleDimensions = New System.Drawing.SizeF(7.0!, 15.0!) + Me.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font + Me.ClientSize = New System.Drawing.Size(800, 450) + Me.Controls.Add(Me.DataGridViewPosts) + Me.Name = "PostsForm" + Me.ShowIcon = False + Me.ShowInTaskbar = False + Me.Text = "PostsForm" + CType(Me.DataGridViewPosts, System.ComponentModel.ISupportInitialize).EndInit() + Me.ResumeLayout(False) + + End Sub + + Friend WithEvents DataGridViewPosts As DataGridView +End Class diff --git a/Reddit Post Scraping Tool/Reddit Post Scraping Tool/PostsForm.resx b/Reddit Post Scraping Tool/Reddit Post Scraping Tool/PostsForm.resx new file mode 100644 index 0000000..b5ae26c --- /dev/null +++ b/Reddit Post Scraping Tool/Reddit Post Scraping Tool/PostsForm.resx @@ -0,0 +1,60 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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/Reddit Post Scraping Tool/Reddit Post Scraping Tool/PostsForm.vb b/Reddit Post Scraping Tool/Reddit Post Scraping Tool/PostsForm.vb new file mode 100644 index 0000000..6305945 --- /dev/null +++ b/Reddit Post Scraping Tool/Reddit Post Scraping Tool/PostsForm.vb @@ -0,0 +1,3 @@ +Public Class PostsForm + +End Class \ No newline at end of file diff --git a/Reddit Post Scraping Tool/Reddit Post Scraping Tool/Reddit Post Scraping Tool.vbproj b/Reddit Post Scraping Tool/Reddit Post Scraping Tool/Reddit Post Scraping Tool.vbproj new file mode 100644 index 0000000..e4906a4 --- /dev/null +++ b/Reddit Post Scraping Tool/Reddit Post Scraping Tool/Reddit Post Scraping Tool.vbproj @@ -0,0 +1,54 @@ + + + + WinExe + net6.0-windows + Sub Main + true + WindowsForms + rpst.ico + + + + + + + + + + + + + + + + + + + True + True + Application.myapp + + + True + True + Resources.resx + + + + + + My.Resources + VbMyResourcesResXFileCodeGenerator + Resources.Designer.vb + + + + + + MyApplicationCodeGenerator + Application.Designer.vb + + + + \ No newline at end of file diff --git a/Reddit Post Scraping Tool/Reddit Post Scraping Tool/Reddit Post Scraping Tool.vbproj.user b/Reddit Post Scraping Tool/Reddit Post Scraping Tool/Reddit Post Scraping Tool.vbproj.user new file mode 100644 index 0000000..d86fe8d --- /dev/null +++ b/Reddit Post Scraping Tool/Reddit Post Scraping Tool/Reddit Post Scraping Tool.vbproj.user @@ -0,0 +1,11 @@ + + + + + Form + + + Form + + + \ No newline at end of file diff --git a/Reddit Post Scraping Tool/Reddit Post Scraping Tool/StartForm.Designer.vb b/Reddit Post Scraping Tool/Reddit Post Scraping Tool/StartForm.Designer.vb new file mode 100644 index 0000000..bb3db99 --- /dev/null +++ b/Reddit Post Scraping Tool/Reddit Post Scraping Tool/StartForm.Designer.vb @@ -0,0 +1,276 @@ + +Partial Class StartForm + 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() + Me.components = New System.ComponentModel.Container() + Dim resources As System.ComponentModel.ComponentResourceManager = New System.ComponentModel.ComponentResourceManager(GetType(StartForm)) + Me.KeywordTextBox = New System.Windows.Forms.TextBox() + Me.LimitTextBox = New System.Windows.Forms.TextBox() + Me.SubredditTextBox = New System.Windows.Forms.TextBox() + Me.Button1 = New System.Windows.Forms.Button() + Me.Panel2 = New System.Windows.Forms.Panel() + Me.MenuStrip1 = New System.Windows.Forms.MenuStrip() + Me.ToolsToolStripMenuTools = New System.Windows.Forms.ToolStripMenuItem() + Me.SaveResultsJsonToolStripMenuItem = New System.Windows.Forms.ToolStripMenuItem() + Me.TimeframeComboBox = New System.Windows.Forms.ComboBox() + Me.ListingComboBox = New System.Windows.Forms.ComboBox() + Me.Label1 = New System.Windows.Forms.Label() + Me.Label2 = New System.Windows.Forms.Label() + Me.Label3 = New System.Windows.Forms.Label() + Me.Label4 = New System.Windows.Forms.Label() + Me.Label5 = New System.Windows.Forms.Label() + Me.ContextMenuStrip1 = New System.Windows.Forms.ContextMenuStrip(Me.components) + Me.ToolStripMenuItemAbout = New System.Windows.Forms.ToolStripMenuItem() + Me.ToolStripMenuItemDeveloper = New System.Windows.Forms.ToolStripMenuItem() + Me.ToolStripSeparator1 = New System.Windows.Forms.ToolStripSeparator() + Me.ToolStripMenuItemExit = New System.Windows.Forms.ToolStripMenuItem() + Me.Panel2.SuspendLayout() + Me.MenuStrip1.SuspendLayout() + Me.ContextMenuStrip1.SuspendLayout() + Me.SuspendLayout() + ' + 'KeywordTextBox + ' + Me.KeywordTextBox.Location = New System.Drawing.Point(89, 49) + Me.KeywordTextBox.Name = "KeywordTextBox" + Me.KeywordTextBox.PlaceholderText = "Keyword" + Me.KeywordTextBox.Size = New System.Drawing.Size(100, 23) + Me.KeywordTextBox.TabIndex = 0 + ' + 'LimitTextBox + ' + Me.LimitTextBox.Location = New System.Drawing.Point(89, 107) + Me.LimitTextBox.Name = "LimitTextBox" + Me.LimitTextBox.PlaceholderText = "Limit (1-100)" + Me.LimitTextBox.Size = New System.Drawing.Size(100, 23) + Me.LimitTextBox.TabIndex = 3 + ' + 'SubredditTextBox + ' + Me.SubredditTextBox.Location = New System.Drawing.Point(89, 78) + Me.SubredditTextBox.Name = "SubredditTextBox" + Me.SubredditTextBox.PlaceholderText = "Subreddit" + Me.SubredditTextBox.Size = New System.Drawing.Size(100, 23) + Me.SubredditTextBox.TabIndex = 4 + ' + 'Button1 + ' + Me.Button1.Location = New System.Drawing.Point(251, 215) + Me.Button1.Name = "Button1" + Me.Button1.Size = New System.Drawing.Size(76, 28) + Me.Button1.TabIndex = 6 + Me.Button1.Text = "Scrape" + Me.Button1.UseVisualStyleBackColor = True + ' + 'Panel2 + ' + Me.Panel2.Controls.Add(Me.MenuStrip1) + Me.Panel2.Dock = System.Windows.Forms.DockStyle.Top + Me.Panel2.Location = New System.Drawing.Point(0, 0) + Me.Panel2.Name = "Panel2" + Me.Panel2.Size = New System.Drawing.Size(355, 30) + Me.Panel2.TabIndex = 7 + ' + 'MenuStrip1 + ' + Me.MenuStrip1.Items.AddRange(New System.Windows.Forms.ToolStripItem() {Me.ToolsToolStripMenuTools}) + Me.MenuStrip1.Location = New System.Drawing.Point(0, 0) + Me.MenuStrip1.Name = "MenuStrip1" + Me.MenuStrip1.Size = New System.Drawing.Size(355, 24) + Me.MenuStrip1.TabIndex = 0 + Me.MenuStrip1.Text = "MenuStrip1" + ' + 'ToolsToolStripMenuTools + ' + Me.ToolsToolStripMenuTools.DropDownItems.AddRange(New System.Windows.Forms.ToolStripItem() {Me.SaveResultsJsonToolStripMenuItem}) + Me.ToolsToolStripMenuTools.Image = CType(resources.GetObject("ToolsToolStripMenuTools.Image"), System.Drawing.Image) + Me.ToolsToolStripMenuTools.Name = "ToolsToolStripMenuTools" + Me.ToolsToolStripMenuTools.Size = New System.Drawing.Size(62, 20) + Me.ToolsToolStripMenuTools.Text = "Tools" + ' + 'SaveResultsJsonToolStripMenuItem + ' + Me.SaveResultsJsonToolStripMenuItem.CheckOnClick = True + Me.SaveResultsJsonToolStripMenuItem.Image = CType(resources.GetObject("SaveResultsJsonToolStripMenuItem.Image"), System.Drawing.Image) + Me.SaveResultsJsonToolStripMenuItem.Name = "SaveResultsJsonToolStripMenuItem" + Me.SaveResultsJsonToolStripMenuItem.Size = New System.Drawing.Size(169, 22) + Me.SaveResultsJsonToolStripMenuItem.Text = "Save results (Json)" + ' + 'TimeframeComboBox + ' + Me.TimeframeComboBox.FormattingEnabled = True + Me.TimeframeComboBox.Items.AddRange(New Object() {"Hour", "Day", "Week", "Month", "Year"}) + Me.TimeframeComboBox.Location = New System.Drawing.Point(89, 166) + Me.TimeframeComboBox.Name = "TimeframeComboBox" + Me.TimeframeComboBox.Size = New System.Drawing.Size(100, 23) + Me.TimeframeComboBox.TabIndex = 8 + Me.TimeframeComboBox.Text = "All" + ' + 'ListingComboBox + ' + Me.ListingComboBox.FormattingEnabled = True + Me.ListingComboBox.Items.AddRange(New Object() {"Controversial", "Hot", "Best", "New", "Rising"}) + Me.ListingComboBox.Location = New System.Drawing.Point(89, 137) + Me.ListingComboBox.Name = "ListingComboBox" + Me.ListingComboBox.Size = New System.Drawing.Size(100, 23) + Me.ListingComboBox.TabIndex = 9 + Me.ListingComboBox.Text = "Top" + ' + 'Label1 + ' + Me.Label1.AutoEllipsis = True + Me.Label1.Font = New System.Drawing.Font("Segoe UI Semibold", 9.0!, System.Drawing.FontStyle.Underline, System.Drawing.GraphicsUnit.Point) + Me.Label1.Location = New System.Drawing.Point(12, 49) + Me.Label1.Name = "Label1" + Me.Label1.Size = New System.Drawing.Size(56, 23) + Me.Label1.TabIndex = 10 + Me.Label1.Text = "Keyword" + ' + 'Label2 + ' + Me.Label2.AutoEllipsis = True + Me.Label2.Font = New System.Drawing.Font("Segoe UI Semibold", 9.0!, System.Drawing.FontStyle.Underline, System.Drawing.GraphicsUnit.Point) + Me.Label2.Location = New System.Drawing.Point(12, 78) + Me.Label2.Name = "Label2" + Me.Label2.Size = New System.Drawing.Size(63, 23) + Me.Label2.TabIndex = 11 + Me.Label2.Text = "Subreddit" + ' + 'Label3 + ' + Me.Label3.AutoEllipsis = True + Me.Label3.Font = New System.Drawing.Font("Segoe UI Semibold", 9.0!, CType((System.Drawing.FontStyle.Bold Or System.Drawing.FontStyle.Underline), System.Drawing.FontStyle), System.Drawing.GraphicsUnit.Point) + Me.Label3.Location = New System.Drawing.Point(12, 107) + Me.Label3.Name = "Label3" + Me.Label3.Size = New System.Drawing.Size(56, 23) + Me.Label3.TabIndex = 12 + Me.Label3.Text = "Limit" + ' + 'Label4 + ' + Me.Label4.AutoEllipsis = True + Me.Label4.Font = New System.Drawing.Font("Segoe UI Semibold", 9.0!, CType((System.Drawing.FontStyle.Bold Or System.Drawing.FontStyle.Underline), System.Drawing.FontStyle), System.Drawing.GraphicsUnit.Point) + Me.Label4.Location = New System.Drawing.Point(12, 137) + Me.Label4.Name = "Label4" + Me.Label4.Size = New System.Drawing.Size(56, 23) + Me.Label4.TabIndex = 13 + Me.Label4.Text = "Listing" + ' + 'Label5 + ' + Me.Label5.AutoEllipsis = True + Me.Label5.Font = New System.Drawing.Font("Segoe UI Semibold", 9.0!, CType((System.Drawing.FontStyle.Bold Or System.Drawing.FontStyle.Underline), System.Drawing.FontStyle), System.Drawing.GraphicsUnit.Point) + Me.Label5.Location = New System.Drawing.Point(12, 168) + Me.Label5.Name = "Label5" + Me.Label5.Size = New System.Drawing.Size(71, 23) + Me.Label5.TabIndex = 14 + Me.Label5.Text = "Timeframe" + ' + 'ContextMenuStrip1 + ' + Me.ContextMenuStrip1.Items.AddRange(New System.Windows.Forms.ToolStripItem() {Me.ToolStripMenuItemAbout, Me.ToolStripMenuItemDeveloper, Me.ToolStripSeparator1, Me.ToolStripMenuItemExit}) + Me.ContextMenuStrip1.Name = "ContextMenuStrip1" + Me.ContextMenuStrip1.Size = New System.Drawing.Size(128, 76) + ' + 'ToolStripMenuItemAbout + ' + Me.ToolStripMenuItemAbout.Image = CType(resources.GetObject("ToolStripMenuItemAbout.Image"), System.Drawing.Image) + Me.ToolStripMenuItemAbout.Name = "ToolStripMenuItemAbout" + Me.ToolStripMenuItemAbout.Size = New System.Drawing.Size(127, 22) + Me.ToolStripMenuItemAbout.Text = "About" + ' + 'ToolStripMenuItemDeveloper + ' + Me.ToolStripMenuItemDeveloper.Image = CType(resources.GetObject("ToolStripMenuItemDeveloper.Image"), System.Drawing.Image) + Me.ToolStripMenuItemDeveloper.Name = "ToolStripMenuItemDeveloper" + Me.ToolStripMenuItemDeveloper.Size = New System.Drawing.Size(127, 22) + Me.ToolStripMenuItemDeveloper.Text = "Developer" + ' + 'ToolStripSeparator1 + ' + Me.ToolStripSeparator1.Name = "ToolStripSeparator1" + Me.ToolStripSeparator1.Size = New System.Drawing.Size(124, 6) + ' + 'ToolStripMenuItemExit + ' + Me.ToolStripMenuItemExit.Image = CType(resources.GetObject("ToolStripMenuItemExit.Image"), System.Drawing.Image) + Me.ToolStripMenuItemExit.Name = "ToolStripMenuItemExit" + Me.ToolStripMenuItemExit.Size = New System.Drawing.Size(127, 22) + Me.ToolStripMenuItemExit.Text = "Exit" + ' + 'StartForm + ' + Me.AutoScaleDimensions = New System.Drawing.SizeF(7.0!, 15.0!) + Me.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font + Me.ClientSize = New System.Drawing.Size(355, 255) + Me.ContextMenuStrip = Me.ContextMenuStrip1 + Me.Controls.Add(Me.Label5) + Me.Controls.Add(Me.Label4) + Me.Controls.Add(Me.Label3) + Me.Controls.Add(Me.Label2) + Me.Controls.Add(Me.Label1) + Me.Controls.Add(Me.ListingComboBox) + Me.Controls.Add(Me.TimeframeComboBox) + Me.Controls.Add(Me.SubredditTextBox) + Me.Controls.Add(Me.LimitTextBox) + Me.Controls.Add(Me.Panel2) + Me.Controls.Add(Me.Button1) + Me.Controls.Add(Me.KeywordTextBox) + Me.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle + Me.Icon = CType(resources.GetObject("$this.Icon"), System.Drawing.Icon) + Me.MainMenuStrip = Me.MenuStrip1 + Me.MaximizeBox = False + Me.Name = "StartForm" + Me.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen + Me.Text = "Reddit Post Scraping Tool" + Me.Panel2.ResumeLayout(False) + Me.Panel2.PerformLayout() + Me.MenuStrip1.ResumeLayout(False) + Me.MenuStrip1.PerformLayout() + Me.ContextMenuStrip1.ResumeLayout(False) + Me.ResumeLayout(False) + Me.PerformLayout() + + End Sub + + Friend WithEvents KeywordTextBox As TextBox + Friend WithEvents LimitTextBox As TextBox + Friend WithEvents SubredditTextBox As TextBox + Friend WithEvents Button1 As Button + Friend WithEvents Panel2 As Panel + Friend WithEvents TimeframeComboBox As ComboBox + Friend WithEvents ListingComboBox As ComboBox + Friend WithEvents Label1 As Label + Friend WithEvents Label2 As Label + Friend WithEvents Label3 As Label + Friend WithEvents Label4 As Label + Friend WithEvents Label5 As Label + Friend WithEvents MenuStrip1 As MenuStrip + Friend WithEvents ToolsToolStripMenuTools As ToolStripMenuItem + Friend WithEvents SaveResultsJsonToolStripMenuItem As ToolStripMenuItem + Friend WithEvents ContextMenuStrip1 As ContextMenuStrip + Friend WithEvents ToolStripMenuItemAbout As ToolStripMenuItem + Friend WithEvents ToolStripMenuItemDeveloper As ToolStripMenuItem + Friend WithEvents ToolStripSeparator1 As ToolStripSeparator + Friend WithEvents ToolStripMenuItemExit As ToolStripMenuItem +End Class diff --git a/Reddit Post Scraping Tool/Reddit Post Scraping Tool/StartForm.resx b/Reddit Post Scraping Tool/Reddit Post Scraping Tool/StartForm.resx new file mode 100644 index 0000000..86eec76 --- /dev/null +++ b/Reddit Post Scraping Tool/Reddit Post Scraping Tool/StartForm.resx @@ -0,0 +1,1278 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + 17, 17 + + + + + iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vAAADrwBlbxySQAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAC36SURBVHhe7d1t + jOVnfd7xVUppGrUkTfPQB1VVm0Sq1BRVRVH6olItZnbZWTDF82B7Zk2Eqsgvonp3ZpeHnTVJVqqUpphC + E7BlAwbMGjt2sMWDjXfBzyaxjQO2MTYE4wC2Y2gI2CaAQsA+PWf3jDDj79/813vP/Tvnd39v6SNec9/S + dV2ec2Z22ySdpaVDL9y5fPDFc7vXF+eWD5y7c2X9fXMr63869Jmhh4a+OfS9oYH6efDhbyk5eve+Xnra + OToBdz/wWDM+df9fPjW7tPamHUv7ty8tLb1wHNMeT5lzyimHXrDrzPVf37m8fmAYRh8b+s4zw0knjwpD + udC790Ulp25UlJn98P/7nsFL5/d+d2Zh9UuzC6tHtp+++vpTl/f/3DjKPZ7+5+UrB16ya2X9D4YB9P82 + B5LKosJQLvTufT2z3PTjUUlmRnfwTLPze74zu7B2+2gQzM2d86JxxHs8P3qGpf9Pdu0+sD4MnT/fHELa + OlQYyoXevS8KdXWjksyM7qDT/HAQLKw+tmNx31tftrT2s+Po97R85pbWf37XysFDw7B5fHP4aOtRYSgX + eve+MMjViUoyM7qDvmYWV782u7j2lqWlQ/9oXAeeVs7s0ht+etfKgbcMQ+a7m0NH9VBhKBd6974ouNWN + SjIzuoPn4enRxwQzZ+z/tXE9eDKfueVzTx2GyyObw0b1UWEoF3r3viCs9RyoJDOjOzgZo58KvPSM/b85 + rgpPpvOKlTf+ytzy+k0UNIpBhaFc6N37opBWNyrJzOgOSphd2Pv47OK+Q+Pq8Ez72bV8YGEYKH7OP2Go + MJQLvXtfFM7qRiWZGd1BSTMLq9/asbj2W+Ma8UzbOeU1h35y/Ct9GDCKRYWhXOjd+6JQVjcqyczoDrbC + 6KOB7Yv7Zsa14pmGs/3M1/+LXcvr91CwaDJQYSgXeve+KIzVjUoyM7qDrTS7sPbpl5118J+PK8Yzqefl + Kwf+7TBAHtwcKJosVBjKhd69LwphdaOSzIzuYKvNzO/5wezi/v85rhrPpJ3RX/Ibhod/xW8KUGEoF3r3 + viiA1Y1KMjO6g1pmFlYfmTvjdb80rh3PJJxx+T+5OUg0magwlAu9e18UvOpGJZkZ3UFNx38asO93x/Xj + iTxzZ7zxl4ah8bXNIaLJRYWhXOjd+6LQVTcqyczoDiJsX1p94CVnn/1T4yry1D7HvvC3sv4XFCKaXFQY + yoXevS8KW3WjksyM7iDKzMLqEzMLe188riRPrbO0tPYP/bb/dKLCUC707n1R0KoblWRmdAeRZk475wez + C/vPHleTp8bZuXLwnRQemnxUGMqF3r0vCll1o5LMjO5gEmxfXL1sXE+erTy7lg+eTsGh6UCFoVzo3fui + cFU3KsnM6A4mxegfGBrXlGcrzrG/7b+y/q3NoaHpQYWhXOjd+6JgVTcqyczoDibJ7OLa/YcOHXrBuLI8 + Jc8wIG7YHBiaLlQYyoXevS8KVXWjksyM7mDSzC6sPnbKa1Z/ZlxbnhJnbuXAbgoMTRcqDOVC794XBaq6 + UUlmRncwiWbnV7++47TX/sK4vjwnc+Z2H3rRMBz+cnNYaPpQYSgXeve+KEzVjUoyM7qDSTW7sPqk/45A + gbNr5cBbKCw0fagwlAu9e18UpOpGJZkZ3cEkm13Y++TM8sFfHFeZ50TPjle/9heGwfDdzUGh6USFoVzo + 3fuiEFU3KsnM6A4mnT8JOIkzt3Lw9ykoNJ2oMJQLvXtfFKDqRiWZGd3BNHAEPI8zu/SGnx6GwhObQ0LT + iwpDudC790XhqW5UkpnRHUwLR8AJnl27D6xTSGh6UWEoF3r3vig41Y1KMjO6g2nidwJO4MytHPg8hYSm + FxWGcqF374tCU92oJDOjO5g2/iSgx5nbfe5/poDQdKPCUC707n1RYKoblWRmdAfTyBHwY86u3QfPp4DQ + dKPCUC707n1RWKoblWRmdAfTyhHQcU455dALhmHw15vDQdOPCkO50Lv3RUGpblSSmdEdTDO/EwDHH//n + RYWhXOjd+6KQVDcqyczoDqadPwnYdPz2f15UGMqF3r0vCkh1o5LMjO4gA0fAM84wCD62ORiUAxWGcqF3 + 74vCUd2oJDOjO8jCETA8S0uHXjgMgu9sDgblQIWhXOjd+6JgVDcqyczoDjJp/jsBO5cPvpiCQTlQYSgX + eve+KBTVjUoyM7qDbJr+ScDOlQNLFAzKgQpDudC790WBqG5UkpnRHWTU7AjYubL+RgoG5UCFoVzo3fui + MFQ3KsnM6A6yanIEDAfA+ygYlAMVhnKhd++LglDdqCQzozvIrLkRMAyBT2wOBeVBhaFc6N37ohBUNyrJ + zOgOsmvqi4Fzy+v3UTAoByoM5ULv3hcFoLpRSWZGd9CCZn4SMAyBL28OBeVBhaFc6N37ovBTNyrJzOgO + WtHECBiGwDc2h4LyoMJQLvTufVHwqRuVZGZ0By1JPwKGIfC9zaGgPKgwlAu9e18UeupGJZkZ3UFrUo8A + CgXlQYWhXOjd+6LAUzcqyczoDlqUdgRQKCgPKgzlQu/eF4WdulFJZkZ30KqUI4BCQXlQYSgXeve+KOjU + jUoyM7qDlqUbARQKyoMKQ7nQu/dFIaduVJKZ0R20LtUIoFBQHlQYyoXevS8KOHWjksyM7kCJRgCFgvKg + wlAu9O59UbipG5VkZnQHOi7FCKBQUB5UGMqF3r0vCjZ1o5LMjO5APzT1I4BCQXlQYSgXeve+KNTUjUoy + M7oD/aipHgEUCsqDCkO50Lv3RYGmblSSmdEd6NmmdgRQKCgPKgzlQu/eF4WZulFJZkZ3IDaVI4BCQXlQ + YSgXeve+KMjUjUoyM7oDdZu6EUChoDyoMJQLvXtfFGLqRiWZGd2BnttUjQAKBeVBhaFc6N37ogBTNyrJ + zOgO9ONNzQigUFAeVBjKhd69LwovdaOSzIzuQP1MxQigUFAeVBjKhd69LwoudaOSzIzuQP1N/AigUFAe + VBjKhd69LwotdaOSzIzuQCdmokcAhYLyoMJQLvTufVFgqRuVZGZ0BzpxEzsCKBSUBxWGcqF374vCSt2o + JDOjO9DzM5EjgEJBeVBhKBd6974oqNSNSjIzugM9fxM3AigUlAcVhnKhd++LQkrdqCQzozvQyZmoEUCh + oDyoMJQLvXtfFFDqRiWZGd2BTt7EjAAKBeVBhaFc6N37onBSNyrJzOgOVMZEjAAKBeVBhaFc6N37omBS + NyrJzOgOVE74CKBQUB5UGMqF3r0vCiV1o5LMjO5AZYWOAAoF5UGFoVzo3fuiQFI3KsnM6A5UXtgIoFBQ + HlQYyoXevS8KI3WjksyM7kBbI2QEUCgoDyoM5ULv3hcFkbpRSWZGd6CtU30EUCgoDyoM5ULv3heFkLpR + SWZGd6CtVXUEUCgoDyoM5ULv3hcFkLpRSWZGd6CtV20EUCgoDyoM5ULv3heFj7pRSWZGd6A6qowACgXl + QYWhXOjd+6LgUTcqyczoDlTPlo8ACgXlQYWhXOjd+6LQUTcqyczoDlTXzMLeJ3ac9tpfGFd22UOhoDyo + MJQLvXtfFDjqRiWZGd2B6ptd2PvNU16z+jPj2i53KBSUBxWGcqF374vCRt2oJDOjO1CM2fnVr8/NnfOi + cXWXORQKyoMKQ7nQu/dFQaNuVJKZ0R0ozuzi2peHtf0Tx9u7wKFQUB5UGMqF3r0vChl1o5LMjO5AsWaX + 1m4f1/fJHwoF5UGFoVzo3fuigFE3KsnM6A4Ub/vi2uXjCj+5Q6GgPKgwlAu9e18ULupGJZkZ3YEmw47T + 96+Na/z5HwoF5UGFoVzo3fuiYFE3KsnM6A40GWbm9z41c8b+XxtX+fM7FArKgwpDudC790XBom5UkpnR + HWhyzCzs+ZuT+s0ACgXlQYWhXOjd+6JQUTcqyczoDjRZZhfWPjWu8xM/FArKgwpDudC790WBom5UkpnR + HWjybD9932+PK/3EDoWC8qDCUC707n1RmKgblWRmdAeaPDOnnfOD7Qt7fmVc6/0PhYLyoMJQLvTufVGY + qBuVZGZ0B5pMMwurXxrXev9DoaA8qDCUC717XxQk6kYlmRndgSbX7OK+Q+Nq73coFJQHFYZyoXfvi0JE + 3agkM6M70OSamd/7/RP6lwMpFJQHFYZyoXfvi0JE3agkM6M70GSbWVj7k3G9//hDoaA8qDCUC717XxQg + 6kYlmRndgSbdnsHs0v7/Mq745z4UCsqDCkO50Lv3xQGiLlSSmdEdaPLNLKx+ZVzxz30oFJQHFYZyoXfv + i8JD3agkM6M70JQ4Y/9vjmu++1AoKA8qDOVC794XBoc6UUlmRneg6TA7v/r1cc13HwoF5UGFoVzo3fui + 4FA3KsnM6A40PXYsrv3WuOr5UCgoDyoM5ULv3heFhrpRSWZGd6DpMbuw96/HVc+HQkF5UGEoF3r3vig0 + 1I1KMjO6A02XmaXXnTGu+2cfCgXlQYWhXOjd+6LAUDcqyczoDjRdZhb2fnFc988+FArKgwpDudC790WB + oW5UkpnRHWj6nLL0uv84rvwfPRQKyoMKQ7nQu/dFYaFuVJKZ0R1o+swurl0/rvwfPRQKyoMKQ7nQu/dF + YaFuVJKZ0R1oCs3v/f6w7n/ieOs/41AoKA8qDOVC794XhoU6UUlmRneg6bTj9NfuGdf+Dw+FgvKgwlAu + 9O59UVCoG5VkZnQHmk6zi6sPjmv/h4dCQXlQYSgXeve+KCjUjUoyM7oDTa2n5+bOedG4+o8fCgXlQYWh + XOjd+4KQ0HOgksyM7kDTa3Zx36Fx9R8/FArKgwpDudC790UhoW5UkpnRHWh6PetjAAoF5UGFoVzo3fui + kFA3KsnM6A40vWYW9jx16NChF4zr3wGQHRWGcqF374tCQt2oJDOjO9B0m11aWxnXvwMgOyoM5ULv3hcF + hLpRSWZGd6DpNru4dnRc/w6A7KgwlAu9e18UEOpGJZkZ3YGm2+zC3m+O698BkB0VhnKhd++LAkLdqCQz + ozvQtNszOOWUQz/pAGgAFYZyoXfviwNCXagkM6M70PTbvrDvLAdAA6gwlAu9e18UDupGJZkZ3YGm3/bF + tSsdAA2gwlAu9O59UTioG5VkZnQHmn4zC3u/6ABoABWGcqF374vCQd2oJDOjO9D0m11Y/bYDoAFUGMqF + 3r0vCgd1o5LMjO5AGewZHPuDQBQKyoMKQ7nQu/fF4aAuVJKZ0R0oh+2L+2YcAMlRYSgXeve+KBjUjUoy + M7oD5bBjcd+6AyA5KgzlQu/eFwWDulFJZkZ3oBy2L629zwGQHBWGcqF374uCQd2oJDOjO1AOs0urn3AA + JEeFoVzo3fuiYFA3KsnM6A6Uw+zC6kMOgOSoMJQLvXtfFAzqRiWZGd2BchgOgL9yACRHhaFc6N37omBQ + NyrJzOgOlMPMwt5vOwCSo8JQLvTufVEwqBuVZGZ0B8phOAD+zgGQHBWGcqF374uCQd2oJDOjO1AOM/N7 + n3IAJEeFoVzo3fuiYFA3KsnM6A6UxtMOgOSoMJQLvXtfEAp6DlSSmdEdKA8HQHJUGMqF3r0vCgV1o5LM + jO5AeTgAkqPCUC707n1RKKgblWRmdAfKwwGQHBWGcqF374tCQd2oJDOjO1AeDoDkqDCUC717XxQK6kYl + mRndgfJwACRHhaFc6N37olBQNyrJzOgOlIcDIDkqDOVC794XhYK6UUlmRnegPBwAyVFhKBd6974oFNSN + SjIzugPl4QBIjgpDudC790WhoG5UkpnRHSgPB0ByVBjKhd69LwoFdaOSzIzuQHk4AJKjwlAu9O59USio + G5VkZnQHysMBkBwVhnKhd++LQkHdqCQzoztQHg6A5KgwlAu9e18UCupGJZkZ3YHycAAkR4WhXOjd+6JQ + UDcqyczoDpSHAyA5KgzlQu/eF4WCulFJZkZ3oDwcAMlRYSgXeve+KBTUjUoyM7oD5eEASI4KQ7nQu/dF + oaBuVJKZ0R0oDwdAclQYyoXevS8KBXWjksyM7kB5OACSo8JQLvTufVEoqBuVZGZ0B8rDAZAcFYZyoXfv + i0JB3agkM6M7UB4OgOSoMJQLvXtfFArqRiWZGd2B8nAAJEeFoVzo3fuiUFA3KsnM6A6UhwMgOSoMaQOF + vrSBSkN5OACSo9CXNlDoSxuoNJSHAyA5Cn1pA4W+tIFKQ3k4AJKj0Jc2UOhLG6g0lIcDIDkKfWkDhb60 + gUpDeTgAkqPQlzZQ6EsbqDSUhwMgOQp9aQOFvrSBSkN5OACSo9CXNlDoSxuoNJSHAyA5Cn1pA4W+tIFK + Q3k4AJKj0Jc2UOhLG6g0lIcDIDkKfWkDhb60gUpDeTgAkqPQlzZQ6EsbqDSUhwMgOQp9aQOFvrSBSkN5 + OACSo9CXNlDoSxuoNJSHAyA5Cn1pA4W+tIFKQ3k4AJL7/Jcex+CXRij0peO+iqWhPBwAyd39wNcw+KUR + Dn7pscGnh6g0lIcDILmPf+LzGPzSCAW/NHLnvQ9jaSgPB0ByF73/egx+aYSCXxq55vq7sTSUhwMguf9x + 8AIMfmmEgl8a+e3//R4sDeXhAEju5WedO/j0A1/F8Jco+KXR5/+zC3uxNJSHA6ABb77oQxj+EoW/dPmH + /gQLQ7k4ABrwyt/47cEnP/MoFoDaRuGvtn36/scGr9j9eiwM5eIAaMT6710y+MJXnsQSULuoANS2//vO + D2JZKB8HQEPOv+QIloDaRQWgdn3o6F1YFMrJAdCQXbsPDq645g4sArWJSkBtuuXOB/3iX2McAI0ZjYA/ + fPe1fhygY6gI1J6PXH+35d8gB0CjDvyvS/xioLAM1BY/82+XA6Bho98OePNFH/TvBDSMCkH5jX7P/48+ + 9CeDly+/DotBbXAA6NjHAqO/GHjhpR8ffOy2zx0bBP4rgm2gclA2Xz1W+J+89+HBNTfcPfidN13ij/t1 + jANAahiFgqQ2OACkhlEoSGqDA0BqGIWCpDY4AKSGUShIaoMDQGoYhYKkNjgApIZRKEhqgwNAahiFgqQ2 + OACkhlEoSGqDA0BqGIWCpDY4AKSGUShIaoMDQGoYhYKkNjgApIZRKEhqgwNAahiFgqQ2OACkhlEoSGqD + A0BqGIWCpDY4AKSGUShIaoMDQGoYhYKkNjgApIZRKEhqgwNAahiFgqQ2OACkhlEoSGqDA0BqGIWCpDY4 + AKSGUShIaoMDQGoYhYKkNjgApIZRKEhqgwNAahiFgqQ2OACkhlEoSGqDA0BqGIWCpDY4AKSGUShIaoMD + QGoYhYKkNjgApIZRKEhqgwNAahiFgqQ2OACkhlEoSGqDA0BqGIWCpDY4AKSGUShIaoMDQGoYhYKkNjgA + pIZRKEhqgwNAahiFgqQ2OACkhlEoSGqDA0BqGIWCpDY4AKSGUShIaoMDQGoYhYKkNjgApIZRKEhqgwNA + ahiFgqQ2OACkhlEoSGqDA0BqGIWCpDY4AKSGUShIaoMDQGoYhYKkNjgApIZRKEhqgwNAahiFgqQ2OACk + hlEoSGqDA0BqGIWCpDY4AKSGUShIaoMDQGoYhYKkNjgApIZRKEhqgwNAahiFgqQ2OACkhlEoSGqDA0Bq + GIWCpDY4AKSGUShIaoMDQGoYhYKkNjgApIZRKEhqgwNAahiFgqQ2OAAmyVnnDk793XcMFq66bXD6PQ8P + znz0bwbL3/zBYOXJgbQlTvvCY9LWePCxwfyDXx2c9rlHB6/6xH2DXW99/+ClS2tYRIrhAJgEr/mdwWmX + HBksP/ptDGlpq2BwS1tkNAheefTOwexZr8dCUl0OgGCv/D+XDc78ypMYztJWo5CWttr8F746OPWSa7GU + VI8DIMrug4PTLrt+sPLE0xjMUg0UzlItr7r1M4OXLuzFctLWcwBEGJb/0o2fwUCWaqJQlqq65y8cAUEc + AAHmr7wZw1iqDQNZquxVN9+DBaWt5QCobPSZPwWxFIHCWIrwCr8TUJ0DoKbX/M7gzC8/gUEsRaAglkI8 + +NXBzKvfgEWlreEAqOi0S45iCEtRMIilIKNfEaSi0tZwANRy1rn+nr8mDoWwFGX064H+saB6HACVnHro + HRjAUiQKYSnS3FsOY1mpPAdAJfNXfwIDWIpEASxFetVt92FZqTwHQCVn3PMwBrAUiQJYijT/wKNYVirP + AVCJn/9rElEAS5GOfQ8AykrlOQAqWfmG/6qfJg8FsBTLAVCLA6ASCl8pGgewFIvKSuU5ACqh8JWiUfhK + 0aisVJ4DoBIKXykaha8UjcpK5TkAKqHwlaJR+ErRqKxUngOgEgpfKRqFrxSNykrlOQAqofCVolH4StGo + rFSeA6ASCl8pGoWvFI3KSuU5ACqh8JWiUfhK0aisVJ4DoBIKXykaha8UjcpK5TkAKqHwlaJR+ErRqKxU + ngOgEgpfKRqFrxSNykrlOQAqofCVolH4StGorFSeA6ASCl8pGoWvFI3KSuU5ACqh8JWiUfhK0aisVJ4D + oBIKXykaha8UjcpK5TkAKqHwlaJR+ErRqKxUngOgEgpfKRqFrxSNykrlOQAqofCVolH4StGorFSeA6AS + Cl8pGoWvFI3KSuU5ACqh8JWiUfhK0aisVJ4DoBIKXykaha8UjcpK5TkAKqHwlaJR+ErRqKxUngOgEgpf + KRqFrxSNykrlOQAqofCVolH4StGorFSeA6ASCl8pGoWvFI3KSuU5ACqh8JWiUfhK0aisVJ4DoBIKXyka + ha8UjcpK5TkAKqHwlaJR+ErRqKxUngOgEgpfKRqFrxSNykrlOQAqofCVolH4StGorFSeA6ASCl8pGoWv + FI3KSuU5ACqh8JWiUfhK0aisVJ4DoBIKXykaha8UjcpK5TkAKqHwlaJR+ErRqKxUngOgEgpfKRqFrxSN + ykrlOQAqofCVolH4StGorFSeA6ASCl8pGoWvFI3KSuU5ACqh8JWiUfhK0aisVJ4DoBIKXykaha8UjcpK + 5TkAKqHwlaJR+ErRqKxUngOgEgpfKRqFrxSNykrlOQAqofCVolH4StGorFSeA6ASCl8pGoWvFI3KSuU5 + ACqh8JWiUfhK0aisVJ4DoBIKXykaha8UjcpK5TkAKqHwlaJR+ErRqKxUngOgkj//yrekiXPbpx6TJg6V + lcpzAFRC4StFo/CVolFZqTwHQCUUvlI0Cl8pGpWVynMAVELhK0Wj8JWiUVmpPAdAJRS+UjQKXykalZXK + cwBUQuErRaPwlaJRWak8B0AlFL5SNApfKRqVlcpzAFRC4StFo/CVolFZqTwHQCUUvlI0Cl8pGpWVynMA + VELhK0Wj8JWiUVmpPAdAJRS+UjQKXykalZXKcwBUQuErRaPwlaJRWak8B0AlFL5SNApfKRqVlcpzAFRC + 4StFo/CVolFZqTwHQCUUvlI0Cl8pGpWVynMAVELhK0Wj8JWiUVmpPAdAJRS+UjQKXykalZXKcwBUQuEr + RaPwlaJRWak8B0AlFL5SNApfKRqVlcpzAFRC4StFo/CVolFZqTwHQCUUvlI0Cl8pGpWVynMAVELhK0Wj + 8JWiUVmpPAdAJRS+UjQKXykalZXKcwBUQuErRaPwlaJRWak8B0AlFL5SNApfKRqVlcpzAFRC4StFo/CV + olFZqTwHQCUUvlI0Cl8pGpWVynMAVELhK0Wj8JWiUVmpPAdAJRS+UjQKXykalZXKcwBUQuErRaPwlaJR + Wak8B0AlFL5SNApfKRqVlcpzAFRC4StFo/CVolFZqTwHQCUUvlI0Cl8pGpWVynMAVELhK0Wj8JWiUVmp + PAdAJRS+UjQKXykalZXKcwBUQuErRaPwlaJRWak8B0AlFL5SNApfKRqVlcpzAFRC4StFo/CVolFZqTwH + QCUUvlI0Cl8pGpWVynMAVELhK0Wj8JWiUVmpPAdAJRS+UjQKXykalZXKcwBUQuErRaPwlaJRWak8B0Al + FL5SNApfKRqVlcpzAFRC4StFo/CVolFZqTwHQCUUvlI0Cl8pGpWVynMAVELhK0Wj8JWiUVmpPAdAJRS+ + UjQKXykalZXKcwBUQuErRaPwlaJRWak8B0AlFL5SNApfKRqVlcpzAFRC4StFo/CVolFZqTwHQCUUvlI0 + Cl8pGpWVynMAVELhK0Wj8JWiUVmpPAdAJRS+UjQKXykalZXKcwBUQuErRaPwlaJRWak8B0AlFL5SNApf + KRqVlcpzAFRC4StFo/CVolFZqTwHQCUUvlI0Cl8pGpWVynMAVELhK0Wj8JWiUVmpPAdAJRS+UjQKXyka + lZXKcwBUQuErRaPwlaJRWak8B0AlFL6t+/yXnxzcce8jg4/ccPfg8FW3DN5x6dHB+e+9ZvD293xElbzp + 7X+kaq4YnHf+lYO3XnjV4ML3XTf4wHWfHpbdo88qPzkAanEAVEIF2KoHvvT44Oitnx284/1HsJRUDxeV + ahkNgosvv2Fw0ycfxiJsFZWVynMAVEJF2KJb7/ri4J2XfQzLSPVRKam+N19w5eCyD/4plmGLqKxUngOg + EirD1nz05vuwhBSHykhxLrjkusEtd/mxAJWVynMAVEKF2IrRZ/1/fO2dWECKRSWkWG9794ebHwFUVirP + AVAJFWMrrrnxXiwfxaMCUryLLj2KxdgKKiuV5wCohIqxBaPP/Kl4NBmofDQZLvvg7ViOLaCyUnkOgEqo + HLMbfdv/XZd/HItHk4GKR5PhvPOvGNx4Z5u/HUBlpfIcAJVQQWZ35JbPYuloclDxaHKMfkWQCjI7KiuV + 5wCohAoys9EX//w9/8lHpaPJMfr1wBb/WBCVlcpzAFRCJZnZHfc8jIWjyUKlo8ly1XV3Y0lmRmWl8hwA + lVBJZvbhG+7GwtFkocLRZLnw8BEsycyorFSeA6ASKsnMDl99MxaOJgsVjibLWy+6CksyMyorlecAqIRK + MjM//58OVDiaLMe/B8BFmRWVlcpzAFRCJZnZBe+9FgtHk4UKR5OHSjIzKiuV5wCohEoyMwfAdKCy0eSh + ksyMykrlOQAqoZLMzI8ApgOVjSaLHwFoqzgAKqGSzOzwVbdg4WiyUOFosvglQG0VB0AlVJKZfeR6fw1w + GlDhaLJcdPg6LMnMqKxUngOgEirJzO649xEsHE0WKhxNlquP+IeAtDUcAJVQSWZ27E8BX3oUS0eTgwpH + k2P0+f8td/mngLU1HACVUElmd/TW+7F0NDmodDQ53n3FjViQ2VFZqTwHQCVUkNl97ktPDC6+7GNYPJoM + VDqaDKP/+r/pk/5zwNo6DoBKqCBbcNtdD2HxaDJQ8WgyXP6h27EcW0BlpfIcAJVQObbi2pvuxfJRPCoe + xRt9f4aKsRVUVirPAVAJFWMrRl8I/MBH78QCUiwqH8V628UfbvKLf89EZaXyHACVUDG25qM334clpDhU + QIpz0eEjzZf/CJWVynMAVEKF2KJb/+yhwbsu/ziWkeqjElJ9oy/8XdbwZ/6bUVmpPAdAJVSGrRr9dsDR + 2+4fvPP9/p2AaFRGqmdU/Bdffv3g5rsewSJsFZWVynMAVEJF2LrRdwPuvPeRwTU33DM4fPUtxwaB/4pg + XVRK2hrnnX+88Ed/23/0o/6rjtztj/s7UFmpPAdAJVSAUjQKXykalZXKcwBUQuErRaPwlaJRWak8B0Al + FL5SNApfKRqVlcpzAFRC4StFo/CVolFZqTwHQCUUvlI0Cl8pGpWVynMAVELhK0Wj8JWiUVmpPAdAJRS+ + UjQKXykalZXKcwBUQuErRaPwlaJRWak8B0AlFL5SNApfKRqVlcpzAFRC4StFo/CVolFZqTwHQCUUvlI0 + Cl8pGpWVynMAVELhK0Wj8JWiUVmpPAdAJRS+UjQKXykalZXKcwBUQuErRaPwlaJRWak8B0AlFL5SNApf + KRqVlcpzAFRC4StFo/CVolFZqTwHQCUUvlI0Cl8pGpWVynMAVELhK0Wj8JWiUVmpPAdAJRS+UjQKXyka + lZXKcwBUQuErRaPwlaJRWak8B0AlFL5SNApfKRqVlcpzAFRC4StFo/CVolFZqTwHQCUUvlI0Cl8pGpWV + ynMAVELhK0Wj8JWiUVmpPAdAJRS+UjQKXykalZXKcwBUQuErRaPwlaJRWak8B0AlFL5SNApfKRqVlcpz + AFRC4StFo/CVolFZqTwHQCUUvlI0Cl8pGpWVynMAVELhK0Wj8JWiUVmpPAdAJRS+rfv8l58c3HHvI4OP + 3HD34PBVtwzecenRwfnvvWbw9vd8RJW86e1/pGquGJx3/pWDt1541eDC9103+MB1nx6W3aPPKj85AGpx + AFRCBdiqB770+ODorZ8dvOP9R7CUVA8XlWoZDYKLL79hcNMnH8YibBWVlcpzAFRCRdiiW+/64uCdl30M + y0j1USmpvjdfcOXgsg/+KZZhi6isVJ4DoBIqw9Z89Ob7sIQUh8pIcS645LrBLXf5sQCVlcpzAFRChdiK + 0Wf9f3ztnVhAikUlpFhve/eHmx8BVFYqzwFQCRVjK6658V4sH8WjAlK8iy49isXYCiorlecAqISKsQWj + z/ypeDQZqHw0GS774O1Yji2gslJ5DoBKqByzG33b/12XfxyLR5OBikeT4bzzrxjceGebvx1AZaXyHACV + UEFmd+SWz2LpaHJQ8WhyjH5FkAoyOyorlecAqIQKMrPRF//8Pf/JR6WjyTH69cAW/1gQlZXKcwBUQiWZ + 2R33PIyFo8lCpaPJctV1d2NJZkZlpfIcAJVQSWb24RvuxsLRZKHC0WS58PARLMnMqKxUngOgEirJzA5f + fTMWjiYLFY4my1svugpLMjMqK5XnAKiESjIzP/+fDlQ4mizHvwfARZkVlZXKcwBUQiWZ2QXvvRYLR5OF + CkeTh0oyMyorlecAqIRKMjMHwHSgstHkoZLMjMpK5TkAKqGSzMyPAKYDlY0mix8BaKs4ACqhkszs8FW3 + YOFoslDhaLL4JUBtFQdAJVSSmX3ken8NcBpQ4WiyXHT4OizJzKisVJ4DoBIqyczuuPcRLBxNFiocTZar + j/iHgLQ1HACVUElmduxPAV96FEtHk4MKR5Nj9Pn/LXf5p4C1NRwAlVBJZnf01vuxdDQ5qHQ0Od59xY1Y + kNlRWak8B0AlVJDZfe5LTwwuvuxjWDyaDFQ6mgyj//q/6ZP+c8DaOg6ASqggW3DbXQ9h8WgyUPFoMlz+ + oduxHFtAZaXyHACVUDm24tqb7sXyUTwqHsUbfX+GirEVVFYqzwFQCRVjK0ZfCPzAR+/EAlIsKh/FetvF + H27yi3/PRGWl8hwAlVAxtuajN9+HJaQ4VECKc9HhI82X/wiVlcpzAFRChdiiW//socG7Lv84lpHqoxJS + faMv/F3W8Gf+m1FZqTwHQCVUhq0a/XbA0dvuH7zz/f6dgGhURqpnVPwXX3794Oa7HsEibBWVlcpzAFRC + Rdi60XcD7rz3kcE1N9wzOHz1LccGgf+KYF1UStoa551/vPBHf9t/9KP+q47c7Y/7O1BZqTwHQCVUgFI0 + Cl8pGpWVynMAVELhK0Wj8JWiUVmpPAdAJRS+UjQKXykalZXKcwBUQuErRaPwlaJRWak8B0AlFL5SNApf + KRqVlcpzAFRC4StFo/CVolFZqTwHQCUUvlI0Cl8pGpWVynMAVELhK0Wj8JWiUVmpPAdAJRS+UjQKXyka + lZXKcwBUQuErRaPwlaJRWak8B0AlFL5SNApfKRqVlcpzAFRC4StFo/CVolFZqTwHQCUUvlI0Cl8pGpWV + ynMAVELhK0Wj8JWiUVmpvNEA+N7mslJ5FL5SNApfKRqVlcobDYBvbC4rlUfhK0Wj8JWiUVmprJmFPU+N + BsCXN5eVyqPwlaJR+ErRqLBU2Pze72+bW16/jwpLZVH4StEofKVoWFgqamZ+73e3za0cvI0KS2VR+ErR + KHylaFRYKmtmYfWJbTtX1t9HhaWyKHylaBS+UjQqLJU1u7j64La55QPnUmGpLApfKRqFrxSNCktlzS6s + Htk2t3t9kQpLZVH4StEofKVoVFgqa/vp+35/287lgy+mwlJZFL5SNApfKRoVlsqaXVz7b9uWlg69cFhQ + 395cWCqLwleKRuErRaPCUlFPv+Tss39q2+gMC+ro5sJSWRS+UjQKXykaFJYKml1Y/atj5T86O5fXD1Bp + qRwKXykaha8UjUpL5cwurl0zrv9t23aduf7rVFoqh8JXikbhK0Wj0lI52xf2nTWu/23bTjnl0AvmVg5+ + nYpLZVD4StEofKVoVFoqY2Z+71NLS0svHNf/8bNzZf3tVFwqg8JXikbhK0Wj4lIZ2xfW7hnX/g+PHwNs + LQpfKRqFrxSNiktlbF/a/+px7f/o2bWy/jkqL508Cl8pGoWvFI2KSydvZn7P347r/tnH3wbYOhS+UjQK + XykalZdO3valtWvHdf/sM7v0hp8eltXjm8tLJ4/CV4pG4StFo/LSydrz9K6V/f96XPd8di4f/D0qMJ0c + Cl8pGoWvFI0LTCdjdnH1tnHNd5+Z31j/p8PC+pvNBaaTQ+ErRaPwlaJRgekkzJ8z2LGw/9+Na/65z7Cw + zttcYDo5FL5SNApfKRqWmJ632YW128f1/uPPK//76//x3PL6o1Rken4ofKVoFL5SNCoxPT8z83ueesXS + uf9yXO/9zs7lA8tUZHp+KHylaBS+UjQqMj0/s4trbxnX+omdYXHdsLnI9PxQ+ErRKHylaFRkOnEzC6vf + GNf5iZ+XnXXgl4fl9eTmMtOJo/CVolH4StGozHSi9jw9t/S6/zqu8+d3di0fPJ0KTSeGwleKRuErReNC + 04nYfvq+t49r/OTOrt3rF1KpqT8KXykaha8UjQpN/c0urt07ru+TP6e85tBPDkvsU5tLTf1R+ErRKHyl + aFRq6mdmYe+35+bOedG4vsucuaX1nx8W2Z9vLjb1Q+ErRaPwlaJRsenHm1nY83fDAfDicW2XPXNnvPGX + 5navf5UKTs+NwleKRuErRaNy03Obnd/z1PbFtR3jut6a87KzDv6nYaH5mwEniMJXikbhK0WjgtNzmD/n + 6e2n718e1/TWnl273/AfhqX2l5tLTt0ofKVoFL5SNCw5odFf+ptdWlsZ13Ods+PVb/w3cysHvkBlp2ej + 8JWiUfhK0ajoBOb3fn/H0v7t41que3Ytve6fDcvN3w7ogcJXikbhK0XDstOPGH3bf8dpr/3VcR3HnLm5 + c/7BrpX1P6DS0w9R+ErRKHylaFR4+qHZhdWHXra09rPjGo4/O3cfOG1YdI9vLj4dR+ErRaPwlaJR6Wlo + /pynZxf3/+G4difrHPs1wZX16zeXnxwAmkwUvlI0LL/GzSys/vVJ/23/Gmdu+dxTh6X38OYSbBmFrxSN + wleKRgXYqvG3/C8a1+t0nLndh140LL7zhr7zzCJsFYWvFI3CV4pGRdic+dFn/Wu3zywf/MVxrU7fOXV5 + /8/tWjl4aFiC39xcii2h8JWiUfhK0bAQGzFz2jlPb19Yu2fL/qRvxHnVaw79zNzKgTfsWln/HBVkdhS+ + UjQKXykaFWN2M/N7/nb70tq1O87c96/GtZnzvGz5Df9+buXg7w+L8WubizIrCl8pGoWvFI0KMqNh6T+9 + fWn1gR2La781rMafON6QjZylpaW/9/KVAy/ZtXJw79CVw6J8YnNxZkHhK0Wj8JWiUVnmsGf0bf5vbF9c + ++io9F9y9tk/Na5Dz/Ay/v7LX33wV3ctH1jYtfvA+q6VA+8Zlucndi2v3zP834eGvjH0vVGhThsKXyka + ha8UjctzKjz90vk9fzczv/e7swurT84urj44u7h2dHZp7U07Tt//Kgu/0UPhK0Wj8JWijWPTs6Vn27b/ + D8ts3yH0IIMnAAAAAElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vAAADrwBlbxySQAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAADywSURBVHhe7Z0L + fFxVnfi3oLzVFZ88fILvx/pchNW1Autu3S1LMgxJ02TSJDWu5R9AUEARiVbdVkEWdYHSNrW1IlQXRBAV + FRWQlyjP0vSBhT6GtIACglBoO//fac/A9PQkuTNzH+ec+/1+Pt9PUWhy783M+f7uzdyZvwMAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcJW+vr59p02b9g5xotja3d3d39PT81nxLHGOdqH8 + uyXay2r+WblA/F9xlniqOENslb9zSG9v7/6Dg4O76G8FAAAAaVIqlQ6QIP+r+GmJ87cl8lfIn3eLj4mV + JJXv9Yy4Vv75d6IaGM6R7ejs7+9/qd48AAAAaJIJEtg3iwp1Vv5b8c+iNc4Z+4QMBqdwhQAAAKBOisXi + bhJSden+DPEn4sOiLbYue47eHQAAABiN3t7e16vf00s41eX0R2pC6q2lUukjevcAAABAM0G9oE6i/3WJ + 5b1mPAPxJ3pfAQAAcs0EOSs+VKL/DYnj/UYsg1P280G93wAAAPmjs7NzPwniaeKK2kDmwE2y+xO2HwUA + AIAcMDg4+Dw5Az5KIvhj+fMZI4x58V59OAAAAMKmt7f3BRK+E8TVNSHMq7P0YQEAAAgT9Sp+Cd7/iIm/ + CY8nblS/+tCHBwAAICwkdG/u7u6+SP7cUhO/vPuUHJMj9CECAAAIh66urtf19PTMkdhtNuKXdzeJk/Vh + AgAACAOJ22vFRSLh39mnxI/pQwUAAOA/csa/t8RtUHxSxw53lDN/AAAIB/WhNt3d3SWJ2wM1scMdJf4A + ABAO6l37JGx31IQOd5bL/gAAEAb6cv8skd/zjy1n/gAAEAbd3d3/LlEL/n36Y5D4AwCA//T19e0rQbu4 + JnA4ulz2BwAA/+np6TlczvzXGpFDu5z5AwCA3wwMDOwuMVO/6+dd/KJJ/AEAwG8kZG8W79Rhw/Hlsj8A + APhN9/aP6X2kJm44tpz5AwCAvxSLxV0lZOqS/1YdNhxf4g8AAP7S1dX1cgnZr2vChuPLZX8AAPCX7u7u + t0nI7qsJG44vZ/4QnQceeOBt4gzx1HK53PXggw/up/8VAEAmSPyPkJD9pSZsOL7EH6Kxdu3aAyT6PxUr + hptGRkYuEF+u/1MAgNToESRkT9eEDceX+EM0Nm7ceLCEfo0RftNHxM+sXLlyd/3XAAASRc78Zxphw/Hl + d/4QDYn/G+Tsfp0R+7G8Xyzpvw4AkAQTJGLn1EQNo8mZP0SjgfjX+ut169a9S38pAIBY0Lf5za+JGkaT + +EM0mox/1S3iIvlar9RfFgCgYQYHB58nEVtUEzWMJvGHaMQU/1ofFwdXr169h/4WAAB1IWf+u/X09Fxu + hA3Hl9/5QzQSiH+t6oWEpUqlMkF/OwCAcdGX/b9fEzWMJmf+EI2E41/rjfJ9PqC/LQDAWEzo7u6ea4QN + x5f4QzRSjH9VXh8AAOMi8f+GETYcX+IP0cgg/rXy+gAAsNLT0zPbCBuOL7/zh2hkHP9aeX0AADyLROzj + NVHDaHLmD9FwKP613sTrAwDyTalUmtTd3f2METccW+IP0XA0/lW3iov4oCGA/NHX1/d2CdkjNWHD8SX+ + EA3H418rrw8AyBG9vb37S8jW1IQNx5f4QzQk/gd7Ev9aeX0AQOAMDAzs3t3d/Xsjbji2vOAPoqHiLyFd + WxNW37xpw4YNh+rdAYCAkJBdWBM2HF/O/CEaAcS/qnp9wJJyufxqvWsA4Dk9PT2dRtxwbIk/RCOg+Ne6 + 7fUBa9eu3VPvJgB4SKlUeqfE7ImauOHYEn+IRqDxr1XtG68PAPCQ/v7+F0nMVtXEDceW3/lDNHIQ/1pv + 5vUBAH4hMeOjfaPLmT9EI2fxr8rrAwA8oVQqtRiBw9El/hCNnMa/1idEXh8A4CidnZ37SdAeqgkcji7x + h2gQ/x3k9QEA7jFBgnZlTeBwdIk/RIP4j6p6fcBh+jABQIZI0PiQn2jygj+IBvEf1+rrA16jDxkApMz0 + 6dNfIVH7c03k0C5n/hAN4l+X6vUBs+SY7aMPHwCkRHd390VG6HBniT9Eg/g3pv48BF4fAJASEv+PGqHD + nSX+EI0NGza8XiJG/JuwXC7/Tv58vz6kAJAAxWJxTwkbb/gztsQfoqFucZNwLauNGTasen3AIjmmB+jD + CwAxImE7syZ0uLO84A+iI2euJxkRw+ZVny9whhzbvfRhBoAm0Z/x/3hN7HBHOfOH+pBQ3VwTLozXNSMj + I1N4fQBA80jc5tfEDneU+EP9SKT+bEQL4/cG8R/1IQeAOtGf9Le5Jnj4nMQfGkPCpLBFC+N168jIyHfX + rVt3oD70ABARCdzPa4KHz0n8oXEkTFcaocJkVa8POJPXBwBEo7u7+5+M6OF2iT80h5yVHmUECtNRvT6g + g9cHAIyNRO5XNdHD7RJ/aB4VIInRdUacMD1vlEHgEP3jAIAaSqXSoUb4kPhDnJTL5fdJiLYYYcL03CJD + wEwZxnbRPxIAECR0V9eED4k/JIFEaIERJUzfL+ofB0DukdB9oCZ8SPwhKR588MH9JUB/NYKE6bpFfSaD + /pEA5BqJ3WU18cu7xB+SpVwun26JEqboyMjIl/WPAyC39PX1vUaCx33/2yX+kDyrV6/eQyK02owSpqcM + YT/SPw6A3NLT03OWEcE8u0gfFoBkkTPQNluYMDWv0z8KgFzS39+/l0TvYSOCuba7u/sL+vAAJItE6Foj + SpieDACQayR2x9kimHcZAiAV1q9f/24JEbcFZiMDAOQaid2dZvzwWc/QhwkgOSRE3zHChOnIAAC5Rc5y + 32uJHtbIlQBInA0bNrxCYvSYESdMXgYAyC0SuG+bwcOdZQiAxJEYnWHECZOXAQBySbFY3E3C9qAteLiz + DAGQKGvXrt1TgnSfEShMVgYAyCUStaIZORxbhgBIlJGRkSmWSGFyMgBALunp6bncFjkcWzlun9eHECBe + 9KcFcltgejIAQO6YMWPGPhKzJ824YTS5EgCJUS6X3yNh4rbAdGQAgNwhZ7FttrBhdBkCIDEkTAuNUGEy + MgBA7pAB4BJb1LA+GQIgEdauXXuAxOlxI1YYvwwAkCskXHuIj9WGDBuXIQASQeL0BSNWGL8MAJAr5Oz/ + P2whw8blhYEQO9wWmIoMAJArJFjfNAOGzcuVAIidkZGRDku0MD4ZACBXSKyWmfHCeGQIgFjRtwVeZ0QL + 45MBAHLD9OnTD7SFC+OTIQBipVwuv1dCxW2BycgAALlBAtVrBgvjlyEAYmVkZOS7lnhh8zIAQG6QMF1k + CxbGLy8MhNjgtsDEZACA3CBhWmOGCpOTKwEQGxKrM414YfMyAEAu6Ozs3M8WKUxWhgCIBW4LTEQGAMgF + EqNWM06YjgwBEAvlcnmqJWLYuAwAkAt6enpm2+KE6cgQAE2jbgscGRm53hIybEwGAMgFEqHfmFHCdGUI + gKaRAeAQCddWI2TYmAwAkAcmSIAeNYOE6cvdAeEhg93b1BU28XKl/O+ZfX19B+t/HT8yBCy2xAzrlwEA + gqdUKr3aFiPMRoaAMOjv73++/CzPkp/pVvNnLEPAM+JX5T+bsP2/jhFuC4xNBgAIHhkAJpkLFGYrQ4Df + FIvF3eTn+CPz52rxa/qvxIvEa9CIGdYvAwAEjyxCnzEWJXRAhgA/qSP+ys0ygL9b/9X40LcF3m8EDeuT + AQCCRxah7xiLEjoiLwz0C3XZX35ul5k/x3E8W//1eCmXy52WqGF0GQAgeGQBusVYkNAhuRLgB3We+T+r + DHm/118iXrgtsGnX6kMJECyyCG00FyV0S64EuE2DZ/5VN+ovEz8yAHxAQsZtgY07Wx9KgOCQs5Y9ZQHa + 6VXK6J4MAW7SZPy3KV9jL/3l4qdcLn/PEjaMLkMABElvb++bbAsSuilDgFvEEX9lqVR6o/6S8bN+/fpX + ScSeMKKG9ckQAMEhQfmobUFCd2UIcIO44q+Un+kR+ssmgwTsi0bQsH4ZAiAoenp6ptsWJHRbXhiYLY2+ + 4G805efZo790MoyMjOwtrrNEDeuTIQCCQRafz5mLEfohQ0A2xB1/ZSpXdcrlcpclaFi/DAEQBLL4nG0u + RuiP/DogXeK87G/4Tf0tkkPdFijxutmIGTYmQwB4jyw8C4yFCD2TISAdEoy/8jv62yQLtwXGKkMAeI0s + PD82FiL0UIaAZEk4/srL9LdKnnK5fJElZtiYDAHgLbLwXG8sROipDAHJkEL8lb/S3y551q1bd6CEi9sC + 45MhALxEFp47jYUIPZYXBsZLEi/4G8Vb9bdMB4nWl4yIYXMyBIB3yMKzwliI0HO5EhAPKZ35V12hv206 + lMvlvSRaa4yIYXMyBIBXyMKz2liIMAC5EtAcKZ75V31Af+v0kGB1GwHD5mUIAG+QhadsLEQYiFwJaIyU + z/yrjuhvnx7cFpiYDAHgBbLwPGQsRBiQDAH1kVH8lekPAIoNGzYcKsHitsD4ZQgA55GF51FjIcLA5NcB + 0cjgsn+t6f8KoIrE6vtGvDAeGQLAaWTh+YuxEGGAciVgbDI8869a1puSPtwWmKgMAeAssvBsMBYiDFSG + ADsOxF+Z3QCgGBkZmWmJF8YjQwA4iURhrWUxwkBlCNgRR+KvXK83KRs2bty4j4RqvREujE+GAHAOWXju + NRYiDFxeE7CdjH/nb3qf3qzskEhNM6KF8fpFfagBnEAWnmXGQoQ5MO9XAhw68696m9607KhUKrtIpG4x + ooXxyhAAziALzx+MhQhzYl6vBDh25l/1t3rzsoXbAlORIQCcQM4Ef2FZjDAn5u1KgINn/lV/pDcxeyRQ + lxjBwvhlCIDMkbPASyyLEebIvAwBDsdfXY1ZqDcze9avX/8qCRS3BSYvQwBkiiw+55uLEebP0IcAl+Ov + lAHgXL2pbjAyMvJlS7AwfhkCIDNk8fmKuRhhPg31NQGO/s5/B2UAm6k31w24LTBVGQIgE2TxOclcjDC/ + hjYE+BB/7X/pTXYHCVPRCBUmJ0MApI4s+G2WxQhzbCi/DnD9sn+tpVJpkt5st+BXAanKEACpIovPB8zF + CNH3IcCn+CtlEH+r3nT3KJfLR0ucbjVihcnIOwZCavT29u5vW5AQfR0CfIu/Up6HL9Cb7y4bNmx4hXiY + eGTaShjPM0IZsgwBkAqDg4O7yAL0lLkgISp9GwJ8jL/4sN58GItyuXyiJZahyhAAqSAL0CpjQUJ8Vl+G + AE/jry7//1HvAowHQwBAvMgi9DNzUUKs1fW7Azx6tb/NH+rdgCgwBADEhyxAZxsLEuJOunolwNcz/6q+ + v+AyExgCAOJBFqFec1FCtOlarHyPv7JUKrXo3YF6YAgAaJ6enp5DbAsTok1XhoAQ4q+U43mQ3iWoF4YA + gOaYMWPGPrIQbTUXJsTRzHoICCX+4uPqThy9W9AIDAEAzSEL0b3GwoQ4plm9MNDzF/yZ3qR3C5qBIQCg + cWQh+r6xMCGOa9pDQGDxV1dS5updg2ZhCABoDFmMTjQXJ8QopvXrgIAu+9faq3cP4oAhAKB+SqXSoZbF + CTGSSQ8BgcZf+Qa9ixAXDAEA9TEwMLC7LEa8JTA2bFJDQMDxH9G7CHHDEABQH7Ig3WwsUIh1GfdrAkL7 + nX+tMjD9QO8mJAFDAEB0ZPGebVuoEOsxrisBAZ/5b1OO0/F6VyEpGAIAotHb23ukbaFCrNdmh4DQ468s + lUrv1rsLScIQADA+sijtIf6tdpFCbNRGfx0Q8mX/qjIgPSj7uaveZUgahgCA8ZHF6efmYoXYqPVeCcjD + mb9ShqOFepchLRgCAMZGFqZP2xYsxEaNOgTkJf7aot5tSBOGAIDRkQHgrZbFCrEpx/t1QB4u+9f4tAw7 + L9K7DmnDEAAwOrJY32NZtBCbcrQrATk781f+Uu86ZAVDAIAdWajPtSxaiE1rDgE5jL/yRL37kCUMAQA7 + UiwWX9fW1rbGsmghxmL11wE5u+xfdasMQQdte7JB9jAEAGxHFuS3HnPMMetEdaZmW7wQ4/JMMW/xV8PP + DfrpBq7AEAB5p7W19f0S/odU/JVTp061LmCI2LgyAHxSP+XAJRgCIK/Imf/hEv3HqvFXHnvssdYFDBEb + dlOpVHqJftqBazAEQN6Q2BfFTbXxr9rV1WVbxBCxAeXs/1L9tANXYQiAvCCRL4nP1Ea/1ilTplgXMkSs + Xzn7b9FPPXAZhgAInWKxeIJEfqsZfVPbQoaIdfvQwMDA7vrpB67DEACBMkHCPmiGfjQ7Ozttixki1ucs + /fwDX2AIgJCQs/5dC4XCHFvoR7Otrc22mCFidDeLr9VPQ/AJhgAIAfWmKxL0JWbgo1gqlWyLGiJGsLu7 + +wf6aQg+whAAPjN58uS9JOQ/NcMe1fb2duvChojjKwPAP+unIvgKQwD4yNFHH/33cvZ/vS3s9cg7AyLW + rzxv7tJPRfAdhgDwiSlTprxC4n2bGfNG7OjosC5wiDimvfrpCCHAEAA+0N7e/loJ9woz5I1aLBa5CoBY + n/er197opySEAkMAuEyhUHibRHu9GfFm5SoAYl1+XD8lITQYAsBFJP7vk1g/aMY7DrkKgBhZzv5DhyEA + XEIiPVHc4UN94parAIiR5Ow/DzAEgAvI2cZREugnzWDHLVcBEMd1dX9///P1UxNChyEAskSi3CVxHvVD + feKWqwCIoysDcp9+akJeYAiALJAgnyyO+6E+cctVAESrt8tAvqt+ekKeYAiANJEQn2qGOS15d0DEne3t + 7T1SPz0hjzAEQAqoT/Q7x4xy2nZ1dVkXQcSc+n/6+Ql5hiEAkmLixInPk/h+x4xxFvJJgYjP+lR3d/dB + +mkKeYchAOJGf6jPVWaIs3Tq1Km2xRAxb/J5/7AjDAEQF+pDfSS415kBzlpuC0SctkYG4RfqpyrAczAE + QLPE+aE+SSjbZ1sUEXOhDMBH6acqwM4wBECjtLa2vqZQKCy3hdcleUEg5tGenp6F+qkKMDoMAVAvEv43 + i2tswXVNfhWAOfSBvr6+ffXTFWBsGALyw4UXXvjGoaGh/xCPXLhw4Uv0/x0ZOfN/v4Q1kQ/1SUp+FYB5 + Ugbegn66AkSDISBsJPiHz58//3axUuNm8RIZBA7Q/9mYyNn0hyWoj5qB9UF+FYA5cYl+ugLUB0NAmMyb + N+8TOva18a+1vGDBgnfo/9xKoVCYLCH9mxlWX+RXARi68vheWyqV6r6qB/AsDAFhIXH/uLilJvajuXHu + 3Lnv1H9tBySgU8Wna4Pqo7xNMIaqxP8Z8Z/0UxagcRgCwkCiHjX+VXcaAuTM+QSJZ+of6pOUvEEQBupp + +ikL0DwMAX4jMa83/lWfHQIkmJl9qE+S8noADMmenp5rZFDnk/4gXhgC/EQi3mj8q2785Cc/ucgWzxDk + 9QAYkCOdnZ376ac+QLwwBPiFxLvZ+G/z/PPPV2cW1oCGIB8YhAG4SfyQfuoDJANDgB9IuGOJf9XQh4CO + jg7boorohfLc7NFPfYBkYQhwGwl2rPGvGvoQ0NnZaV1cER33a/qpD5AODAFuIqFOJP5VQx8CeFEg+qQ8 + F6/iRX+QCQwBbiGBTjT+VRkCEJ1waX9//4v00x8gfRgC3EDCnEr8q4Y8BBx77LHcGYCuu6ZUKr1aP/0B + soMhIFskyKnGvypDAGImbuzq6nqLfvoDZA9DQDZIiDOJf9WQhwB1eyBDADrmI/J8e49++gO4A0NAukiA + M41/1dCHAMsijJiFT4jc6w/uwhCQDhJeJ+JflSsBiIm6qVQqTdJPfwB3YQhIFgmuU/GvGvIQoD49kCEA + M/Jv4sf00x/AfRgCkkFC62T8q3IlADFWH+/t7T1SP/0B/IEhIF4ksE7HvypDAGIs/qVUKh2qn/4A/sEQ + EA8SVi/iX5UhALEpN8iZ/z/opz+AvzAENIcE1av4Vw15COB9AjAp5XG1Us7836if/gD+wxDQGBJSL+Nf + NeQhoFgs8rbBGLe/k+fLy/TTHyAcGALqQwLqdfyrhj4ETJ061baQI9brEnEP/fQHCA+GgGhIOIOIf9WQ + hwBlR0eHbUFHjOJWcVCe9hO2P/sBAoYhYGwkmEHFv2roQwAvDsQGfFQeMwX91AfIBwwBdoaGhj4psdxq + xjMU1RCgFj5bQENQ/UqgVCqZizyizWV8qA/kFoaAHQk9/lW//e1vb3tnPVtAQ1ANAZ2dnbYFH7Hq9yT+ + e+unPkA+YQjYTl7iX/XUU0+1xjMkp0yZYlv4Mcd2d3f/taenZ7p+2gNA3oeAvMVfec4551ijGZrq/QL4 + lQBqb+H+fgALeR0C8hh/5YUXXmgNZoiqXwlwl0Cu3SzOksfBbvppDwAmeRsC8hp/pXoxoC2WIavuEuBq + QO68W37mvJ8/QBTyMgTccsstFRkAchl/5axZs6yRzIPqagC3Cwbv0+KsgYGB3fXSBgBRCH0IuPnmm61R + zJMzZsywxjEvqtcG8DbCwXott/cBNEGoQwDxn1+ZOXOmNYp5VN0OydWAYFwndsnyxTv6ATRLaEOAvuxv + jWJenD179razX1sM8ywvEvTaJ8RZvb29L9BLFwDEgQwBJ9li6pvEn/iPpzo2vIGQV6r38Fcf4PNavVwB + QNz4PgQQf+JfjwwC7tvd3f0L8b16iQKAJPF1CCD+xL9RGQTcU4W/t7f3fXpZAoC08G0IIP7EPw7V8eOO + gUxVb+SzpKen5z16KQKALPBlCCD+xD9uq+8oyF0DqfmYRH8Ob98L4BCuDwHEn/gnqRoE1AcNMQgkoxzX + lfLnSVOnTn2hXnIAwCVcHQKIP/FPU/X2wrxOIBafFJf09vYeKcsL9/EDuI5rQwDxJ/5ZWb0qwGsF6nKL + eH1PT88n+vv7X6SXFQDwBVeGAOJP/F1Rv1Zgk8TtTh05W/zy6rboiyeUSqUD9DICAL4iQ0Cm7xhI/Im/ + Yz4tTlLPjenTpx/Y3d19nATvSvFx0RbFoJX9/6uc5V8ufrKzs3O/bYsGAIRDVkMA8Sf+jrmlWCy26afF + Dsj/v5uc9X5EojhLYvhH+TPUqwObJfq/lz+/Ivv54f7+/ufrQwAAoZL2EED8ib9rSuRP0E+HcZkxY8Y+ + vb29H5RQnirBvEL+fEgH1DcfE9Vl/Vni5I6OjhfrXQSAPJHWEED8ib+Dfl4/DRpicHBwFxkI3iRnzcdI + SM+UoeAH8ucy+fMZ+dMW3lRV2yHbdo/88xL55y+IBfnnN8im86p9ANhO0kMA8Sf+Dvpt/fCPnYGBgd3V + m+FIbP9FAjxdwjtT/nmR+GtRvdBwvahuo7OGO6Lq76uP071Dvsc18qf6+l+S79Wnbs2Tf36D+hWG3iQA + gNFJaggg/sTfQRers3f90M+Mrq6uvSXer+rr6ztYwv1e7T+pgFeVf39Y9d+p/0799/39/XvpLwEAEA9x + DwHEn/g76BUTJ058nn7IAwBAlbiGAOJP/B30BnXWrR/qAABg0uwQQPyJv4PeyavdAQAi0OgQQPyJv2sW + CoVVxWLxlfqhDQAA41HvEED851fOOuusSnt7uzVEmInrJf6v0w9pAACIStQhgPjPr1x66aWVe5Ytqwwv + X1754223Va67/vrKz6++unLpZZdVFi9eXLngggsqZ599dmXmzJmVz372s5WBgYFKX18fA0NyPiLxf5d+ + KAMAQL2MNwQQ/x3j34h3L11a+f2tt1auve66ypU/+Unl4ksuqSxYsKBy3vnnbxsaBgcHKyeffHJlxnHH + VXp6erZ9gI0lePicT8gx+qB+CAMAQKOMNgQQ/+bj34i1A4O6ynD55Zdvu8pQHRi+8pWvVE477bRnB4ac + vSbh2Q/3AQCAGDCHAOKfTfwb9fY77thhYFBXGS6cO/fZgeHzZ5xROf74430fGLaI7fohCwAAcVEdAoi/ + X/FvxNrXMSz+3vcqX/7yl30YDE7UD1UAAIibq6+++hLiH3b8R/OGG26onHTSSbbwuuAZ+iEKAABxI/H7 + uLilNoZ5M6/xr3rXXXdVTjnlFFuAs/R/9UMUAADiRuJH/HMe/6ouDQGFQuF7Lny4DwBAkEj8iD/x30FH + hoCri3zsLQBAMkj8iD/xt5rlECDhv5EP9wEASAiJH/En/mOa0RDAh/sAACSFxI/4E/9IpjkEqA/3aW1t + 3U8/TAEAIE4kfsSf+NdlSkPAhra2tjfqhykAAMSJxI/4E/+GTHgI4MN9AACSQuJH/Il/UyY0BPxN/JB+ + mAIAQJxI/Ig/8Y/FmIeApwuFwsf0wxQAAOJE4kf8iX+sxjQEbJX4d+uHKQAAxInEj/gT/0SMYQjgw30A + AJJA4kf8iX+iNjEEnKkfpgAAECcSP+JP/FOxgSGAD/cBAEgCiR/xJ/6pWscQcBEf7gMAkAASP+JP/DMx + whBw9aRJk3bXD1UAAIgLiR/xJ/6ZOtoQwIf7AAAkhMSP+BN/JzSHAIn/XeK++qEKAABxIfEj/sTfKWuG + gHv5cB8AgASQ+BF/4u+kd99999YrrriipB+qAAAQFxI/4k/83XZ4+AnxcP2QBQCAZpH4EX/i74cMAQAA + 8SDxI/7E3y8ZAgAAmkPiR/yJv5/KELBs2bKJ+qEMAABRkfgRf+LvtwwBAAD1IfGbJm6tjWHevOyyy4h/ + AP7pT396avXq1Z/SD20AABiNBQsWvFkCuMkMYp4k/mEo8a888MAD21yzZs1J+iEOAAA2hoaGpIH2MOZB + 4h+G1fiPjIxsU/3zfffd92n9MAcAABOJ4BozinmR+IehGf/aIYArAQAAoyAhfMoMYx4k/mE4WvyrciUA + AGAUJIZrzTiGLvEPw/HiX5UhAADAYOLEic+bPXv2clskQ5X4h2HU+FdlCAAA0BSLxX2OOeaYq6ZNm1aZ + N2+eNZahSfzDsN74V2UIAIDc097evr/E/4/Vz1T/1Kc+ZQ1mSBL/MGw0/lUZAgAgt7S0tLxdon9/Nf5V + P/3pTwd7JYB3+AvDZuNflSEAAHJHsVg8XGL/iBn/qiEOAcQ/DOOKf1WGAADIDRL4kripNvg2QxoCiH8Y + xh3/qgwBABA8cuZ/gsR9qxn70QxhCCD+YZhU/KsyBABAkKjb/CToF5iBj6LPQwDxD8Ok41+VIQAAgkLd + 5if+xBb3qPo4BBD/MEwr/lUZAgAgCFpbW/eT+P/BFvV69WkIWLBgAfEPwLTjX5UhAAC8plAovE3CvdNt + fs3owxAwe/bsygUXXGANCvpjVvGvyhAAAF6ib/P7ixnwOHR5CFDxP/bYYytnn322NSroh1nHvypDAAB4 + hUS6KD5ZG+24dXEIqMZfbd+XZs60hgXd15X4V2UIAAAvqPc2v2Z0aQiojb/y1NNOs8YF3da1+FdlCAAA + Z9G3+c2tBjAtXRgCzPgrBwYGrIFBd3U1/lUZAgDAOdRtfhK9K2sDmKYnn3xyZkOALf7K3t5ea2TQTV2P + f1WGAABwBnWbnwTvVjOAaas+RTDtIWC0+Cvb2toqy4aHrbFBt/Ql/lUZAgAgc+TM/60Su/vM+GVlmkPA + WPGvesedd1qDg+7oW/yrMgQAQGbImf9HJHKJ3ObXjGkMAVHir7zhxhut0UE39DX+VRkCACB1JG6J3+bX + jEkOAVHjr/zFL35hDQ9mr+/xr8oQAACpoW/z22LGzjWTGALqib/yRz/6kTU+mK2hxL8qQwAAJIqEf9dC + oXCeLXSuGucQUG/8lRdddJE1QJidocW/KkMAACRCV1fX3hK0K8zA+WAcQ0Aj8VfOle9rixBmY6jxr8oQ + AACxImf+r5SYZX6bXzM2MwQ0Gn/l/5x7rjVEmL6hx78qQwAAxIJrt/k1YyNDQDPxV37lq1+1xgjTNS/x + r8oQAABNIQE7THywNmi+W88Q0Gz8laeffro1SJieeYt/VYYAAGgIOfOXfrl7m18zRnnb4FmzZjUdf+WJ + J55ojRKmY17jX5UhAADqwpfb/Jrx+OOPr1xwwQU7hV8NBmeccUZFjoH179Xr9OnTrWHC5M17/KsyBADA + uEj0dpVo/a8ZsVBtb2/fdoZ+5plnVr70pS9VTjnllEp3d7f1v23UKVOmWOOEyUr8d5QhAABGRd3mJwPA + j20Rw+a86+67rZHCZCT+dtUxWbNmzcn6KQ8A8Oxtfr83w4XxePMtt1hDhfFL/MeWIQAAnkXif7BEaoUZ + LYzPa665xhorjFfiH02GAABQ8T9UAhXUbX4uesWVV1qDhfFJ/OuTIQAgxxQEidPfzFhh/F58ySXWaGE8 + Ev/GZAgAyCFy5h/8bX4uOX9oyBoubF7i35wMAQA5QcKvbvP7thkoTNZvfutb1nhhcxL/eGQIAAgc/Wl+ + l5txwuRV7ypoCxg2LvGPV4YAgEBpaWl5iYTod2aYMB3VOwvaIoaNSfyTkSEAIDDa2toOkghxm1+Gqs8e + sIUM65f4JytDAEAgtLa2fkACtNEMEqbrJz7xCWvMsD6JfzoyBAB4joSnVeQ2Pwfs7Oy0Bg2jS/zTlSEA + wFO4zc8t5edRuWfZMmvYcHyJfzYyBAB4hLrNr1AofMsWIczWW//wB2vccGyJf7YyBAB4wLRp0/aQ0Fxi + hgfd8LfXXmsNHI4u8XdDhgAAh1G3+cnZ//W28KAbXvXTn1ojh3aJv1syBAA4iLrNr1AoLLdFB93xBz/8 + oTV0uLPE300ZAgAcgtv8/HHhwoXW2OGOEn+3ZQgAcIBisdgiYeE2P08877zzrMHD5yT+fsgQAJAh3Obn + n1//+tet0cPtEn+/ZAgASJ8JEpPZZlzQfQcHB63hQ+LvqwwBACkxadKk3SUk3ObnqZ/5zGes8cu7xN9v + GQIAEqZYLO4rEbnOjAr644zjjrMGMM8S/zBkCABIiEKh8HoJyLAZFPTLadOmWSOYV4l/WDIEAMSMxP8Q + iccGMybon8cee2xl2fCwNYZ5k/iHKUMAQExI/I+WcDxhhgT99Y+33WYNYp4k/mHLEADQJNzmF6bXXX+9 + NYp5kfjnQ4YAgMZQt/kNmuHAMPzZz39uDWMeJP75kiEAoA70bX7fN6OB4XjpZZdZ4xi6xD+fMgQAREDf + 5netGQwMy8WLF1sDGbLEP98yBACMAbf55cc5c+ZYIxmqxB+VDAEAFuTM/x8lDNzmlxPPPvtsayhDlPhj + rQwBADVwm1/+/NLMmdZYhibxR5sMAQCCxP94CcJmMxAYtqeedpo1mCFJ/HEsGQIgz3CbX44dGBiwRjMU + iT9GUQ8Bn9JrIkD4cJsfTunoqNy9dKk1nr5L/DGq6nGyatWqJ5ctWzZRL48A4aJu8xN/a4sC5sslS5ZY + A+qzxB+jqh4nK1et2v7YGR5+giEAgkbC/zpZ+JeZIcB82jd9elCfCUD8Mao7xL8qQwCESmtr6/tl0R8x + I4D59sQTT6zcfscdOy6EHkr8MarW+FdlCIDQkIX+P0Vu80Orx59wQuW222+3L4geSPwxqmPGv6oMAeLh + evkE8BdZ4KeLz9Qu+Iimvg4BxB+jGin+VRkCwHO4zQ/r0rchgPhjVOuKf1WGAPARfZvfReYCjzievgwB + xB+j2lD8qzIEgE90dHS8mNv8sBldHwKIP0a1qfhXZQgAH+A2P4xLV4cA4o9RjSX+VRkCwGUKhcL7ZOHm + Nj+MTdeGAOKPUY01/lUZAsBFWltbPyIL9qPmAo7YrK4MAcQfo5pI/KsyBIBLFItFWaePeap20UaM06zf + LIj4Y1QTjX9VGQKWrVz5Yb0EA2RDQZAFmnv8MXGzuhJA/DGqqcT/OR9duXLlu/VSDJAu0v6jZWF+2lyo + EZMy7SsBxB+jmnL8q5bvueee/fSSDJAOshgfIW6qXZwR0zCtKwHEH6OaUfy3Ozz8m0qlsqtemgGSpVgs + vkMW4kfMhRkxLZO+EkD8MaqZxl+7bPnyk/XyDJAc7e3t+8sCvNZckBHTNqkrAcQfo+pC/LWPDQ8P76+X + aYD46e/vf76c/V9vW4wRszDuKwHEH6PqUPyrztVLNUD8FAqFb9kWYcQsjetKAPHHqDoYf+XTq1atepVe + rgHiQ9/rb12AEbO22SsBxB+j6mj8t7ls+fL/1ks2QDy0trYeKIvsw+aiG4BlGWyukT8vEE8W2+V/H1Uo + FI6UP98r/3ui/PPH5M+i/Hmc/HmO/P8/kT9XiltF29fEjGz0SgDxx6i6HH/tmkqlMkEv3QBNoz7T/1fm + YuupD0rIF0nE+9ra2g7S+9cQ8jVeJl9LoX4togYC2/fDlK33SgDxx6h6EP9tLlu27DC9TAE0hwTu47aF + 1iP/JvtwsThZvYhR71bsyNc/RL7XN8UNNd8bMzDqlQDij1H1Jf7bHB4+Qy9LAI0zZcqUV8iC+mdzgfXE + hyXKX5R9eKnenVSYNGnS7vK9p4srarYFU3a8KwHEH6PqVfy3+0u9HAE0jiyk3zUXVg9Un0h4SrFY3Efv + RibI999VbJNtubdm2zBFR7sSQPwxqh7GX7lBL0MAjSFnz++WRXSLuag67hXt7e1O3QYjQ8Cesl2D4pM1 + 24kpaQ4BxB+j6mn8t3nvvfe+SC9BAPUji+e15mLqsOsktE5/PrZ60aFs442WbceErf46gPhjVH2Ov3LF + ihVv0UsPQH1IqP7dtpA66lWyvS/Tm+406kWIhULha7LN3EKYsp855ZRKuVy2LvaItfoef+Xy5cvfr5cd + gPqQBfNmcwF10K0S/tNlc72751WGAPXeAo8Z+4PJeqfwCVnct9oWfURlCPFXygDwIb3cAERHovpvlsXT + NTdLRD+uN9lL5DirNxrilsF0XC/H+9XquN+3dm0HQwDaDCX+yntWrnzPtoUGoB5ksXT9TX/Uff2T9eZ6 + jezHG2R//mTsH8bro3Kc36kP+Tbuv//+LoYArDWk+CuXrlp1sH64A0RDFsq3yYLp8u+nN4utenODQM5M + Xyf7VK7ZR4zPp8WP6kO9A1wJwKqhxV/csnr16j30Qx0gGrJYXlizeLqm+p3/NL2pQdHS0vIPsn+PGPuL + zTnu44UrARhg/JX36Yc4QDRksdxHFs2/GouoS35Ob2qQtLa2fkT28Rljn7Fxz9SHdky4EpBfA41/ZXjF + ih/ohzdANAqFQrdlEXXFq2QTg/+EK9nPzxr7jQ0oj+XvyeGM/HhhCMifwcZfXLZ8+f/TD22AaBS3fyyu + dUHN2HVpv59/VgwODu4iP4efWY4BRvfnjXzoE78OyI8hx195zz33vEE/rAHGR3/oj4tv+7tVXRrXm5kL + WlpaXi77/aBxHDCCMjzdPnXq1BfqQ1k3XAkI39DjL96iH84A0ZCFs9+2oGZtoVBYpDcxV7j683Dc9XF8 + DgRXAsI1B/FXbwB0nH4oA0RDFs+fGoupCz4qC/r+ehNzhfpVgOz/TcbxwNF9VN1JoQ9f03AlIDzzEH/x + oTvuuGNv/TAGGJ9p06btIQuoi59U92m9ibmkUCgcYjkmuLObxCP0YYsNrgSEY07ir17891n98AWIRrFY + PNxYUF3wYdmuTD/P3wXkOFxtHBfc0UTfG4IrAf6bl/jfceedT1988cUH6YcuQDTkTPPLloU1U2VR/4Le + vFyj3xvAeoxwm2foQ5UYXAnw17zEX3nppZdW5s+fv3Lu3LkH6ocuwPhIbH9rWViz9HHZpn315uUeOR68 + FsCiDK7z9CFKHK4E+Gee4n/Nr3+t4l915cKFCw/QD12A0ZHQ7iqLqWvv/vddvXkgyM+IOwIM5ZhcI+6m + D1EqcCXAH/MU/1t+//vK0NBQ7QCgXMEQAOMii+g7bAtslso2/ZvePBA6OjpeLMflKfM45VV5fNwlvkgf + nlThSoD75in+f7zttoqE3ox/VYYAGBtZUEvmApuxIxMnTnye3jzQSPAusxyr3FkoFNZkfWsoVwLcNU/x + v/322yuLFy+2hb9WhgAYHVlUv2oushk7X28a1CDh67Ucq7y50+f6ZwVXAtwzT/G/4847o8S/KkMA2JFF + 9VJjkc3akt40qEHC93rLscqTTxeLxX/Rh8MJGALckfiPK0MA7IwsrEuNhTZTW1tbX6M3DQzk+NxnHq+c + qO7179KHwSkYArKX+EeWIQB2RBbXx4zFNkvv15sFFuT4LDaOVy6U+J+uD4GTMARkp4r/KuJfj8tkCHiJ + fuhCnlGvpLYtuFkp2/MzvWlgQY7R581jFrpp3uvfDAwB6Uv8G/amJUuW7KkfupBX2tra3mJbdLNSFvtv + 6U0DC3KMiuYxC9yrfLojhCEgPYl/087RD1vIK7LAfshYcLN2QG8aWCgWi++yHLNQvVNdodK77g0MAclL + /ONx3rx5Rf2whTwiC+y/WxbezJTtOUZvGlhoaWl5ue24Bei61tZWb9/PnCEgOYl/rD4wZ84c74ZsiAkJ + bodl8c1M2R7eAXAM5PjsaTtugenMvf7NwBAQv8Q/foeGhmbphyzkDVlspxuLb6ZK4D6oNw1GQY7TM+Zx + C0j1uf4T9a56D0NAfBL/xHycuwJyiiy2n6hZfDNXzvzerTcNRkGO06PmcQvEreJUvZvBwBDQvMQ/cT+n + H66QJ2TBnVGzAGdua2vrB/SmwSjIcVJnydbj57mf1bsYHAwBjUv8U3GFfqhCnpAz7uMsC3FmyvYcqTcN + LBSLxd1sx8135ece/C1JDAH1S/zTc2ho6D36oQp5QRZf134FcLTeNLAgA8C+tuPmuV7d698MDAHRJf7p + KgPAKfphCnlBguLUXQDidL1pYKGtre2NlmPms7fKY3AfvXu5gCFgfIl/Jl6lH6KQF9QZt2VRzkzZnv/W + mwYWJJZOvW9Dk671+V7/ZmAIGF3in5lr9cMT8oIE5XDLwpyll+pNAwtyfE40jpev/lm9DbXerVzCELCz + xD9Tty5atGhv/fCEPNDS0vJ2y+KcpXfrTQMLhULhPMsx882nZPD8sN6lXMMQ8JzEP3vnzZt3sH5oQh6Y + MmXKSy0LdJZuPvroo/9ebx4YyPH5o3G8fNPZz/XPCoYA4u+KCxYseJd+WEJOmCCLsmv3lf+H3jaoQQ1G + cmw2G8fKN0/VuwM15HkIIP7uOHfuXN6HJW/IovwnY5HO2rP0pkENclz+0zhOvnm+3hWwkMchgPi75bx5 + 896uH46QF4rF4s8si3VmyvbcpTcNavD89/9XyM91V70rMAp5GgKIv3vOmTPn1fqhCHlBFudvGot15krs + vP80uDhRb5Qjx2WDeZw8MXf3+jdDHoYA4u+kmwYHB3PxhlxQg8TWqbcDVso2fU1vHggSUF/v///TlClT + XqF3AyIS8hBA/J11WD/8IE9IXD5oWbizdm1e3h42CjIQXWw5Rq77sGz3m/UuQJ2EOAQQf6ddpB96kCcm + T568lyzWLr66PLiPhm0EGdBeJ8fiGePYuO4m2e7D9S5Ag4Q0BBB/5+3TDzvIG7JgLzUWcBdcOjg4uIve + xNwiZ9G+vfhvq2xzp958aJIQhgDi77ybxf31Qw7yhizaQ8Yi7oQSksl6E3NJa2vrfnIcnjSPi8vKmf9n + 9OZDTPg8BBB/L/ylfqhBHpHQdtsWcwdcMWnSpN31ZuYO+bkssBwTZ5XtDf5z/bPCxyGA+PvhvHnz2vXD + DPJIe3v7q2wLuiPm8nOqZb8PE7fWHAfXvZIXbiaLT0MA8ffGe7n9D1RwVhoLuiv+NW8fG6vv+/fmff+L + xeItXV1dfJJYCvgwBBB/fxwaGuL1OuDmGwLV+BuJTG7eSU72d6ax/y7Lvf4p4/IQQPy98vpKpTJBP6wg + z8hCfoSxsLvmmXpTg6a1tfUjsq++fOjPwzKYvUlvOqSIi0MA8ffKx+fOnfsW/XCCvNPf3/98WdD/bCzw + LrlZxVFvbpDoV/0/YOy3qz4p8f+g3nTIAJeGAOLvl0NDQz36YQSwHVnUFxqLvGv+uaWlJchPrJo6deoL + Zf9uM/bXVbeIRb3pkCEuDAHE3y8l/t/SDx+A55Azun8xFnoXXd/e3v5avclBIMd9N9mvq439dNmT9aaD + A2Q5BBB/v5w3b953+b0/WFEvtJPFfZ2x2LvocCh3Bqj3OZD9+T9j/5y1UChw9uAgWQwBxN87L+GWPxgT + WeRnm4u+o97f1tbm9YtY9GX/Xxn75bI/UkOi3nxwjDSHAOLvncQfxkeiepAs9Op3vLYAuOZDra2tH9Cb + 7hX6BX/e3Osv3qQ+OEpvPjhKGkMA8fdO4g/RkcX+SmPxd9mnxVNls735vZa6m0G2eX3NPrgu9/p7RJJD + APH3TuIP9SEL/iQjAD54ebFY3FfvgpPo11gMir7c5698SLabe/09I4khgPh7J/GHhpggi/5dlhi4blmc + qrZ/+264gxzPQ8U/GNvrun8TD9O7AJ4R5xBA/L2T+EPjFAqFKUYMvFFC+1vZ/nfqXckUdelctmm+6NMH + +yi3yHE8Ru8GeEocQwDx907iD80hi7+6XD1sRMEnVXCvyOpFgnL8Xi3f/1zxCb09XikD1Kf0roDnNDME + EH/vJP4QDxKxLlscfFP24xq1L+I+etcSQb7+rhLOf5XvuVhUL060bo8Hnqt3CQKhkSGA+Hsn8Yf4kAfT + LhIDX96eNorqbPwi9esNdRue3s2mOOqoo14gX+9j8nXV2f6I/j4+e6n6uevdg4CoZwgg/t5J/CF+JG5H + WiIRisvEueLJcvZ+lPimjo6OF+td3wEVehkaXqOPxwxRBf8m8RnR9rW9U/b/RnFPvcsQIFGGAOLvncQf + kkOi8BNbMAL3cVF9OuJfav6/kF0pP+eX6R85BMxYQwDx907iD8miznwlECqItnCg/z7U1tb2Rv3jhhxg + GwKIv3cSf0gHicTnjWhgGD4pcq9/DqkdAoi/dxJ/SI/i9o+sXVoTDvRf9ZkPrfpHDDlEDQHlcnkL8fdK + 4g/pUygU3i3B2FQTEPRYGepO0D9ayDFLV6w4ROL4sBnL0CT+AE0i4TjDDAl66Tf0jxTg7+5ZufI9Eslg + hwDiDxADEydOfJ7E4wYjJuiRcub/Q1lIuNcfdiDUIYD4A8RIe3v7qyQkG82woBfezOf6w2iENgQQf4AE + kJAcIfr0sba5t1AorGppaXm5/hECWAllCAgk/hctWbJkV/2jAXCHYrF4ui006KQb29raDtI/OoAx8X0I + IP4AyTNBzioXWWKDbsnn+kPd+DoEEH+AlOjv739+sVi8xggOuiP3+kPD+DYEEH+AlGlpaXmJRObumuig + Ow7oHxNAQ/gyBBB/gIxQLy6T2Awb8cFsPUv/eACawvUhgPgDZEx7e/trC4XCGkuIMH2XcK8/xImrQwDx + B3AE/cmBK40YYbr+ctKkSbvrHwlAbLg2BBB/AMcoFouvFO+yhAmT9yY59vvoHwVA7CxfvvwfJb6ZDwG3 + 3X478QdwEf2agJuNOGGy3tzR0fFi/SMASIwVK1a8ZXh4+H5bmNPw1j/8obJo0SJbUH2Sd/iDcJk2bdoe + EqXvG5HCBJSz/uunTp36Qn3oARJHBoD9xd/YAp2k1157bWXBd75jC6pPEn8IH/VCNAnULHFrbbAwVn/e + 1dW1tz7kAKlRqVR2Xb58+RckzE+aoY7bu5curfz4xz+2xdQ3iT/kCzlDPUpC9RcjXNi8Q+rNmPRhBsiE + patWHTy8YsXlEuqtZrhj8Oml99wzf9GiRbdbYuqbxB/yiQwBb5Jg3WkEDBtzixzP0/ShBXCCFStWvGv5 + 8uUXSbSfMiLeiH8ZHh4+d+m9975afe3zzjvvxUNDQ7daouqLxB/yjX5dgPqVgHqLWlvYcHwfkvj/mz6k + AM6xevXqv5d498kw8H8S8geNsI/lffJ3viO2rFy5cqdbWT0eAog/QBWJ2BG8aVBD3qzea0EfRgDnqVQq + E9SvCCTqk4ZXrDhePF2ctc3h4VPF/5J/d4R4gP4rY+LhEED8AUwmT568lwRNXQ3YXBM4tPuMOEvO/HfT + hw8gt3g0BBB/gLEoFArvk7DdYgQPn/MOdYz04QIAwYMhgPgDRGSChK4ooVttxC/PPiEOctYPYMfhIYD4 + A9SL/rXAKeJGHcE8ukUGoUXt7e2v0ocFAEbBwSGA+AM0g5z17iMhPFXM2yBwVUtLyz/owwAAEZgzZ85L + Jbx3GCHOQt7bHyAu1KfaSRRLMhCE/OFC6l0Sr5Cz/kP0bgNAnagrARLg64wgp+kQZ/4AyTBBAnmkeLHE + 8qmaePrsI7I/32pra3uL3kcAaII5c+bsJSH+oRHmpN0sfk5vAgAkSbFY3FfiOSD+TvTtDYXUO/j9Vuzj + /fsBkkGCfJz4pA50kq4TP6K/LQCkiYT0ADmLPl7C+kvR1SsDm2U7r5c/T25tbT1QbzoAJMjcuXMPlDgv + qol1nD4jnrt48WI+gRPABdQdBDIMfExCe454s/i0aAty4sp2LJc/54vt6oqF3kQASBkJ9QfFK8Wtoi3m + 9fiUeP7Q0NDr9ZcHABeR8O4pZ9z/rK8QXCj/+0b58xEV6BhV79C3Qr72D+XPM+V7HT1lypRX6E0AAEeY + O3fu6yTcp+tbBtXv7W2Bt/mE+Avx4+qFhvrLAYCPdHR0vFgGg/eoWEu4PymeLvH+hvzvOaJ6keES8VL9 + p3KheL78uy+Ln5J/LokT29vbXztx4kRe9QvgGXPmzHmRBP2j4oB4rrhQ/KEMB0vE+fPmzZstf04XD1uy + ZAlvxAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB7xd3/3/wHbKpk+maAobAAAAABJ + RU5ErkJggg== + + + + 132, 17 + + + + iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vQAADr0BR/uQrQAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAC/+SURBVHhe7d0J + lB1VnfhxVgWV1RkRCOmq6oYAAVHi6KAwbCK44IwoyDAu89f54zYjzsxxnL/LnOjoDA5KMOmq6gdEZJGB + RtkiEIwiKKsso7JvUVAgZOmlbr3e0t33f2/nx4jVNySdfkst3+85nxNEkvSrunVvva1qKyIiIiIiIiIi + IiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIi + IiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIi + IiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiImpWC2p6+7nRwG6dsXqN+TWwgiXp + wZ1RfYEVdKfHBlH6to6o/g4/Uidb9p/tv7P/3//+d+b3vPD75c/azf7Z8tcQERFRM+tarF8edCf7dYTq + aD9WpwSx+qT59cvm13P8KLk4iJLr/Si9yyzkTxqDhm4y+3eYvyu9a8PfbX8Gtcj8uy9N/Wz2hML8rEHP + 4L72Z5eHQURERC/OPqveZ0l9L/us2y6eXpR83vxaM1YYdlEfN1wLcVH0GfcYvUGUnml+Pd2+2tDVrebP + OVvvKJuBiIionB21UG9nnhkf4IXqA2YR/Lp5Bn2tsdL8c9EX+NlYv2Eb2G1htkmsTrHbyG4r2WxERETF + yb5fHoTJ4V6YnmEWNvts/lajbrgWQUw3FkTqQfNrbxCqhX6YnNhRq+8pm5eIiCgH9ept7cvZZrE63Y+S + i8yv9mV716KG2XvWj9Jl9m0Se4I1v1e/TPYCERFRc5sfrn7V1LP7qffq02VmUbLvcbsWKzRdmppfb536 + bEGYnGhfeZHdRERENLv2qulXBD31d5qFZrHxS6PK79nnnd03/+OH6tv2q418yJCIiGaU/e67WUhON3oN + ZbgWG+TfsLHCvlpjv2Uhu5eIiGhD9pni1IVwNnxN7aEXLSAolalvXdgPZZ7ctXjdzrL7iYioSs05f3B3 + P0w+ZhaD5cbIhgUCFTLsR8kNQZx8lM8OEBGVPG9R/65+mH5YPrw3mlkQUF32swO32q9t7ldL/kSGCxER + FTn7IT77CXEzwdv383mmj00xY8ScIJoTRd4mICIqWPb74WYiPzmI1FXmV/tBMNdED2zKsBepH/ihej/X + HCAiynH2pjnyQb7nMxM5MFv2eg81e5dEGW5ERNTO7B3nzMRsb2trb54zabgmb6CR7M2NTrdvL8kwJCKi + VmVvGiPP9te8aGIGWmnAqHlh+noZlkRE1IzsrXP9OP2QH6V3ZiZioN3uMOPyg3aMynAlIqLZNm/pmp3k + znpPZyZdIG+es3cw5NoCRESzyIv7PXmZvz8zyQJ5p+w9Cfzu4Q4ZzkREtKk64vob5Na66zOTKlA0E/a6 + Al40+OcyvImIKFsQDb7LTJg3ZyZQoBSCSN1k7ywpw52IiOyNeMyzpLtckyZQPumd9uqUMvyJiKpXECaH + 22dF7kkSKDcvUrcF3emxcjgQEZW/jp7kMPu+qGtSBCroVnMycKQcHkRE5css+q8zk529KY9rEgSqbkUQ + 1v9MDhciouLnR8k8P1ZXmwmOS/UCL20yCNWVQc/gvnL4EBEVL3v/ffkeP7fhBWZmzF5HIKj17SKHExFR + AVqot7H3UzeTGHflA2Znrb0K5la9els5uoiI8llHqI42k9YvM5MYgNl5yIvT4+UwIyLKT0FteK5cvc81 + eQFoiHTZ3GggkMOOiKh92Xui8z4/0FLDfqy+NudsvaMchkRErc3vVn9hJqNHMpMTgNZ40l5FUw5HIqLm + Zz/dbyafmsHX+oD2MsdgctHe3cmr5fAkImpO9hrmQaR+75iIALTPc/abN3KYEhE1ro5afU8zyXw/M+kA + yJV0WWc4tI8ctkREs0jrreU7/eumTzYAcmhg6toBC/U2chQTEc2srsVDc7hbH1BYK+bEQ3vL4UxEtHkF + oTrJTCBrMxMKgGLpD8L0r+WwJiLaePZ7/fYa5I6JBEBhJRfND1e/Sg5zIqI/zt6K1EwWj02fPAAUX7qy + M0zeIoc7EZGpV2/rRcnnzSQxNn3SAFAi64NQLeTmQkS04Rr+sbrFMVEAKKtQ3c49BYgqnL2oj5kM+qdN + DgCqoK8jqr9DpgMiqkRaby0v+U9kJgQA1TJpb+bFNQOIKlDX4nU7B5G6yjERAKgoL0yumxsN7CbTBBGV + Lb8nPcQc7E9mD34AMB73o/R1Ml0QUVkKovQ0c4DXMwc8ALzYsBcmfyvTBhEVuaMW6u3se3yOAx0ANqa2 + oKa3l2mEiIrWfrXkT8yB/PPMgQ0Am+PmvbuTV8t0QkRFqas20GkO4EcyBzQAbDYvUk/4UTJPphUiynsd + Pclh5uBdnT2YAWALrDMnAUfI9EJEec0P1fvNATuUOYABYDZG7AeJZZohorzlhekZ5kDl4j4AmmFy6j4C + RJSfNnzSX8WOAxYAGso80VjKNwSIcpC9x7e9ipfrQAWApgjVj4Ja3y4yDRFRq+tarP7UHIz3TTs4AaD5 + 7rFfNZbpiIhalRemr/Vj9WvHQQkArfLQnHhob5mWiKjZTd3Df+q63c4DEgBaKF05NxoIZHoiombVsWTA + twec+0AEgLZ4KugZ3FemKSJqdB2hOsAcaM9kDjwAaL9QrQqWpAfLdEVEjaqju36oOcjWTDvoACA/+rzu + wTfLtEVEs60zTt5qDqyBzIEGAHk0YOcsmb6IaEvbsPinqeMgA4C8Up1h8haZxohopnlh+npzIPVlDiwA + KIKBoKf+RpnOiGhz64zVQeYAWps5oACgSNZ0dav5Mq0R0abqDAe7zIHzbOZAAoAiet6rJfvL9EZEG6sz + HNrHj9LfOA4iACiqp72435Npjoiy+eele5gD5ZHMgQMAZfB4R62+p0x3RPRC9qYaXqQecBw0AFAW9+/d + nbxapj0i6lq8bmdzYHBXPwBVcM+8pWt2kumPqLotqOntzQFxY+YAAYASS244aqHeTqZBomrmRSpyHyAA + UGrnyTRIVL3MWfAXHAcFAFRE8jmZDomqkx+rU8wBMDH9gACAypgMovQ0mRaJyl8QJoebgT+cORAAoIqG + uW8AVaKu2kCnGfCrMwcAAFTZ2qBncF+ZJonKl/3+qxnoj2YGPgBUnhepJ7oWqz+V6ZKoPMnX/X6eHfQA + gP91M18PpNLlh2qJY7ADAF7Ei5OzZdokKn72U66ugQ4AcAjTD8v0SVTc/Ch9nRnQ9WkDHACwMUMdcf0N + Mo0SFa+50cBu9oMtjsENAHhpj3uL+neV6ZSoQC3U23hhcp1jUAMANku6zM6lMqsSFSM/VF91D2gAwGaL + 1ZdlWiXKf0GcvNsMXC7zCwCzNxH01N8p0ytRfvPifs8M2P7MAAYAbLl1neHQPjLNEuWwhXobM1Bvzgxc + AMDs/WyrXr2tzLZE+cqL1L85Bi2QG52x0oddmOpjLq3rE6/YwP6z/Xf2/3P9HiAvgjj5V5luifJT0FN/ + oxmgY9kBC7STXdy/cPOIvvax9frhtRN6ZFxvNPv/2f/mGvPf2t9z9Pfqzj8TaKP1Xvfgm2XaJWp/e5y1 + 6pVmYHKTH+TCm7+b6v+8fVQ/um5ClvYt7xFzQvAft4/oN5k/0/V3AW3w+Lyla3aS6ZeovQVxeoFjkAIt + dcTFdX3Br8f08HpZvRvYmDmXuPLR9bwqgLyoyfRL1L6CUJ3kGJxAyxx4rtLn3D06tUg3u/Xm77AnGQed + xysCaLuTZRoman1z4qG9zSBclxmUQMucds2QflZNyvLcup4xf+epVw85fyagRfr4aiC1p4V6myBSNzkG + JdB09hP7i34xqsdbv/b/b/bv/uZdo9ocB86fEWi6UP1oK623llmZqDUFsfqkc0ACTbZfj5r6VH9eutr8 + LPuan8n1swLNl/ydTMtEzW+fJfW9zMDjan9ouf1rSt/y9Et8l69N/fSp8amfzfUzA002YN+OlemZqLkF + kbrKMQiBpuqKlb7hyfw888+24jfrdRevBKAdYnWFTM9EzcsMtFOcAxBoskseGJOlNr9deP+Y82cHmq0j + Tt4r0zRR4wtqfbuYgfZMduABzfYPPxqWJTb/fXbFsPMxAE32rLeof1eZrokamxel33EMOqCpjrykrutj + bfy4/wxTo5NTFyVyPRagmYJIxTJdEzWujlAdbQbYZHbAAc1202/z+77/xrr5qXHnYwGabLIzVsfItE00 + +/aq6Vd4kXrCMdiApvrEDcV56T/b313PWwFoi0e9C/QOMn0Tza4gSs90DDKgqewFduzNeIraQ+Zn5yJB + aAcz7r4i0zfRljc3GgjMgBrJDjCg2U4v8LP/F/rYdbwKgLYY8uJ+T6Zxoi3Lj9XVjsEFNN1tv8vfBX9m + 2s/NY3A9NqAFLpNpnGjm2Q+TOAYV0HSHXZi29Tr/jWrCPIbDLuLOgWiTbvUXMp0TzaBeva0ZQL+aNqCA + FjjzjlFZQovf124bcT5GoAXuszduk1mdaPPiZj9op1tL8PL/C/GVQLRTECcflWmdaNPZq0mZgbMmO5CA + VrB3+yvShX821dB6PfWYXI8VaIHn7VVcZXoneumCSC1yDCKgJU68oi5LZ3l6Vy9XBkT7BHH6DZneiTZe + ZzjYZQbMaHYAAa1yxorif/0vm72XgeuxAi0yGvQM7ivTPJE7vvaHdjvnF+X5AOALnX3XqPOxAi3DLYPp + peqM6gvMQOF6/2gre0vdsvWdX3GbYLTdZEdcf4NM90R/nBkgyzMDBmi5Kx4u3wmAfUyuxwq0VnqtTPdE + f6gzTN7iHjBAa137ePHu/rep7GNyPVag1bzuwTfLtE+0oSBSN7kGC9BqZXwF4PKHeAUAubFcpn0i+9J/ + coRjkABtccGvy3cCsJTPACBPuEQwvZAfq1ucgwRog2/eVb5vAfzXnXwLALnyM5n+qcp5cXq8Y3AAbfPp + G8t3HYBPLOc6AMiXjlAdLcsAVTU/Su90DQ6gXU64vHxXAnz7ZVwJEPniReo2WQaoigXR4LtcAwNop65Y + 6cGR8twLwD4W+5hcjxVoqzB9uywHVLV47x959ePflOergMtX8hVA5NYKWQ6oSgU99Tc6BgOQC//2sxFZ + PovfF28ecT5GIA+4OmAFMzv+suxAAPLi0O+kemxCVtACZx+DfSyuxwjkQ3KxLAtUhfzu4Q6z49dPHwhA + fvxoZfHfBlj+JC//I/fGgtrwXFkeqOxxv38UwalXD8kyWtxOuWrI+diAfEnOkuWBylzX4nU7mx0+OH0A + APlz97PjspQWrzueGXc+JiCHkqDWt4ssE1TWvCj5vGPnA7n0gauHdBG/EGh/5vdfybN/FEic/rMsE1TG + FtT09mZHPz1txwM5duWjxfssQC+3/0XRxOp3do2Q5YLKljnD+5BzxwM59sYLUr1mqDivAzxfn+ST/yik + IE7/RpYLKlt+lN7l2ulA3p12zZAeL8A5wIT5GT94LS/9o6BCdbssF1SmgiXpwc4dDhTEWXfm/y6BZ97B + Xf9QbJ2xOkiWDSpL5sxuiWtnA0Vi76uf1y6+n/f9UXxBrM6RZYPK0Jyz9Y5mx/ZldzRQNObZydQH7PLW + ZQ+NTf1srp8ZKJh13gV6B1k+qOjx4T+USWCcc3d+3g6I7xud+plcPytQREGY/rUsH1T0zA79WXYHA0X3 + jz8e1vWx9n0y0P7dn10x7PzZgCIzJ7Q3yfJBRc6Pknlmh05mdzBQBm+7tK5/+Xzrrxb4P6vG9THm73b9 + TEAJTAY9g/vKMkJFzZwAfMuxc4HSsO+9f+mWEd0/0vxXA/qGJ/UXbh7h/X6UXhClZ8oyQkVsfq9+mdmR + q7M7Fiij+eel+qu3juhVaeNPBNYNTU597uCQpVzgBxURqlVcGbDA+bE6xbljgRLbv6b0p24c1j/+zfqp + +/FvaaPjWq8wf8Ynlw/reebPdP1dQJkFoTpJlhMqWuYE4GrXTgWq4sBzlf7wsiEd3js6tZiv7J/Q6x0n + Bfbf2f/P/jf2v/3QtUNTv9f1ZwKVEasrZDmhIjVv6ZqdzA4cnrZDAUw9o7fX67d4dg9sVH1+uPpVsqxQ + UeK7/wCA2fJidaosK1SU/Chd5tqZAABsriBSV8myQkXIW9S/q9lxI9kdCQDADI0Etb5dZHmhvBdEyf9x + 7EQAALZA+kFZXijv+VFyg3snAgAwU+kyWV4oz82NBnYzO2x0+g4EAGCLjM05f3B3WWYor5ln/3/n2HkA + AGwxL0z+VpYZymtmRy3P7jgAAGbDnABcJ8sM5bE9zlr1SrOj+PQ/AKDRhveq6VfIckN5yw+TEx07DQCA + WfPC9ARZbihv+bEKXTsNAIBZC9W3ZbmhvOVF6gnnTgMAYPYeleWG8pQfJfMcOwsAgIbpqg10yrJDecmL + 0s+6dhYAAA30aVl2KC+ZnXJjZicBANBgXBUwV805W+9odszQ9B0FAEAjpal3gd5Blh9qd0FP/Z3uHQUA + QIP1pMfJ8kPtzuyQxdN2EAAATZF8S5Yfandmh/xq+g4CAKAJwuRuWX6onXUtXrez2SHj03YQAADNsX5+ + uPpVsgxRu/Li9HjHzgEAoGk6Y3WMLEPUrvxQfdW1cwAAaJpYfVmWIWpXXqR+4tw5AAA0z3JZhqgt9ept + zU5QmZ0CAECzDdo1SFYjanUd3fVDHTsFAIAWSF8nyxG1OrMD/mH6DgHKoTNW+rCLUn38ZXV94hXNc8yl + df2GpanzZwCwcUGoPiXLEbU6swMuy+4QoKgOOFfpT9wwrC+8f0w/uGZCD6/XLa1veFLf9rtxffZdo/ov + v193/owA/sCL1PdkOaJWZ3bA09kdAhTNseYZ+KUPjulkdFKW4nz0ZP+E/o/bR/T883h1AHBLfivLEbUy + L0xf694hQDEcdmGqr31svZ7I17o/rf6RSf3120b0vj3uxwFUWWesXiPLErUqP0zf7toZQBF86ZYRXR/L + +cqf6dF1E/pdvbw1ALwYFwRqQ36c/rNrZwB5Zl9Ov+6JFr+538BGxrX+fzePOB8bUEVelH5WliVqVX6U + fNe1M4C8ev3SVN/znFlBS1B836jzMQJV44XpUlmWqFWZDX9fdkcAeXXw+am+f/WELJ/lqPseTgIA7gzY + 4o5aqLczG3542o4AcqirR+nbf1+OZ/7Z7GcZXI8ZqJAhrgjYwrq61XzHTgByyb5cXtbWT2j9vh8MOR83 + UB3JPFmeqNl5sTrVvROAfDn5qqHcf81vtq3sn9Dzau7HD1TEybI8UbMzG/vrmY0P5I596f+RteV6339j + 2asHurYBUAmh+qosT9Ts/Chd5twJQI587qYRWR7Ln72mwaHf4YqBqKYgUlfJ8kTNzpwArHTtBCAv7I18 + nuivxrP/F/r23bwKgMp6XJYnamYLanp7s7HHMxsfyJXTrhmSZbE6rUondZc58XFtD6DkxvgmQAuaGw0E + jo0P5MoVD4/JslitPnQt3whANQW14bmyTFGzCrrTY10bH8gT+2y4ii395ZhzewBl50XqSFmmqFn5YfIx + 18YH8uK4/67Lcli9Hlo74dwmQNl5UfoRWaaoWZkN/e/ZDQ/kyWdWDMtyWL3shYG4bTCqKAjVQlmmqFn5 + obrEtfGBvDjnF+W98t/mdOyl3DIYVZR8V5YpalZmQ986fcMD+XHJA9X8AOALnXo1HwREBcXqFlmmqFmZ + Df3MtA0P5MhVjxb3fv+N6GPXDTu3C1ByT8kyRc2oa7F+udnIE5mNDuTKNY9V+wTg0zdyAoBKGp/fq18m + yxU1uqA72c+x0YFcufTBar8FwAkAqqqrNtApyxU1us5YHePa6ECeRPdW+0OAnACgqrxYHSXLFTU6P1an + uDY6kCdVugmQK04AUFVBrN4nyxU1uiBUn3JtdCBP3nNFdS8EZOMEAFXlxerjslxRo/Nj9WXXRgfyxN4Q + Z3CkmpcCtnECgOpKviDLFTW6IFbnuDc6kC/LV1b3mwCcAKC6km/JckWNjqsAoig+ZRbBqsYJAKoruVCW + K2p0ZuPe4N7oQL7Mqym9dqiabwNwAoDqSn8oyxU1Oj9M7nZvdCB/vnFHNb8OyAkAqiu9U5YranRm4650 + b3Qgfw46L9XP16v3KgAnAKiwx2W5okZnNm6S2dhArp1RwVsDcwKACuuX5Yoamb3Gstm4k5mNDeTeDU9W + 6xsBnACgwiYX1PT2smxRo5pz/uDujo0N5N4hS1P924EJWR7LHycAqLKg1reLLFvUqDpq9T1dGxsogiMv + qevVFfk8ACcAqLLOWL1Gli1qVH73cIdrYwNFccLldb0qLf9JACcAqLLOcGgfWbaoUXErYJTBERfX9aPr + yv12ACcAqDJuCdyEOmN1kGtjA0Vz4LlKX/7QmCyX5YsTAFTZ3B51oCxb1Kg6uuuHujY2UFSnXTOkH+sr + 36sBnACgyrwwfb0sW9SoOnqSw1wbGygye+fAz6wY1g+sKc+JACcAqDKve/DNsmxRo/IidaRrYwNl8Y7L + 6zq8d1Tft2pcjxf4fIATAFRbcoQsW9So/J70OPfGBspn/9qGE4KP3zCs/+WmEX1ZgT4zwAkAqiyI0rfJ + skWNKoiTd7s2NlAFdlEtSpwAoMqCnvo7ZdmiRhWE6iTXxgaqgBMAoBg64uS9smxRo+IEAFXGCQBQDJwA + NCHeAkCVcQIAFANvATQhPgSIKuMEACgGPgTYhPgaIKqMEwCgKPgaYMPjQkCoMk4AgGLgQkBNiEsBo8o4 + AQCKgUsBNyFuBoQq4wQAKAZuBtSEgp7BfV0bG6gCTgCAYuB2wE3I7x7ucG1soAo4AQCKoWvx0BxZtqhR + ddTqe7o2NlAFnAAAxdAZq9fIskWNas75g7u7NjZQBZwAAMUQ1Pp2kWWLGtWCmt7ebNzJ7MYGqoATAKAQ + Jo9aqLeTZYsamdm4g5mNDVQCJwBAIfTJckWNzmzcJzMbG6gETgCAQnhMlitqdH6U/MKxwYHS4wQAKIQ7 + ZLmiRhdEyfWODQ6UHicAQBGky2S5okbnR8nF7o0OlBsnAEARJN+V5YoaXRCpRe6NDpQbJwBAAYTJN2W5 + okZnNvCXpm1woAI4AQDyL4iS/yfLFTW6IFafdG10oOw4AQAK4XRZrqjRmY17cmZjA5XACQCQf0GoTpLl + ihpdR6iOdm10oOw4AQDyz4vUkbJcUaMLupP9XBsdKDtOAID841bATaxrsX652cgT2Y0OlB0nAEDujc/v + 1S+T5YqaURCp3zs2PFBqnAAAufeULFPUrMxGvjWz0YHS4wQAyL2bZZmiZsXVAFFFnAAAecdVAJue2dD/ + Pn3DA+XGCQCQb0GoFsoyRc3KD5OPuTY+UGacAAD55kXpR2SZombVGatjXBsfKDNOAICc61Z/IcsUNau5 + 0UDg3PhAiXECAORbUBueK8sUNaujFurtzMZen934QJlxAgDk2thWvXpbWaaomflRutKxA4DS4gQAyLXH + ZXmiZmc29jWZjQ+UGicAQH4FobpSlidqdn6svubaCUBZcQIA5BdfAWxhXqg+4NoJQFlxAgDkVxCr98ny + RM2uI1QHuHYCUFacAAD5FfQM7ivLEzW9Xr2t2ehD2Z0AlBUnAEBu1bdaqLeR1YlaURCrex07AiglTgCA + vErvkmWJWlUQpxe4dwZQPpwAAHmVni/LErWqIEr/yb0zgPLhBADIJy9Mz5BliVqVOQF4m2tnAGXECQCQ + Tx2hOlqWJWpVXYvVn7p2BlBGnAAA+WTXIlmWqJWZjf9UdmcAZcQJAJBH6UpZjqjVebG61L1TgHLhBADI + o+RiWY6o1fmx+nv3TgHKhRMAIH+8SH1CliNqdR1x/Q2unQKUDScAQP4ES9KDZTmilrfhioCD2Z0ClA0n + AEDuDHAFwDZndsKKzE4BSocTACBfgii5XpYhalf2NoyunQOUCScAQM6E6ouyDFG78nvS45w7BygRTgCA + fPFidZQsQ9Su5i1ds5PZGePZnQOUCScAQK6M7VXTr5BliNqZ2Rn/k9k5QKlwAgDkCXcAzE1+qL7t3klA + OXACAORImHxTlh9qdx1R/R3OnQSUBCcAQH4E3emxsvxQu5tztt7R7JR6dicBZcEJAJAXadq1WL9clh/K + Q36U3ODeWUDxcQIA5EV6rSw7lJe8MD3DvbOA4uMEAMiHIFSfkmWH8lLQnezn2llAGXACAORDV22gU5Yd + ylNepJ5w7TCg6DgBAHLhEVluKG+ZndOd2VlAKXACALRfEKlFstxQ3gri5N2unQYUHScAQPt5cXq8LDeU + t/Y4a9UrzU4azu40oOg4AQDabsh+5VyWG8pjfB0QZcQJANBu6Q9lmaG8FsTJR907DyguTgCANgvTD8sy + Q3nNW9S/q9lZo9N2HlBgnAAAbTUS1Pp2kWWG8pwXJtc5diBQWJwAAG0Uq6tleaG8Z1+qce5EoKA4AQDa + J4jS02R5obzXtXjdzman8W0AlAYnAEDbDNs1RZYXKkJmp12T2YlAYXECALTN92VZoaIUxOnfOHYkUEic + AABtEqtTZFmhojRv6ZqdzM4bmrYzgQLiBABoi7q9wJwsK1SkvEj9wLFDgcLhBABoi8tkOaGi5Yfq/Y4d + ChQOJwBA63lR8leynFDRmt+rX2Z24vPZnQoUDScAQIuFatWCmt5elhMqYn6UnOXcuUCBcAIAtJYXpv8p + ywgVtaA72c/szMnszgWKhBMAoKUmg57BfWUZoSLnx+oWxw4GCoMTAKB1vEj9RJYPKnp+lH7QtZOBouAE + AGgdL1anyvJBRc+7QO9gduq67E4GioITAKBl1to1Q5YPKkNmpy7O7GSgMDgBAFrDi5OzZdmgshQsSQ92 + 7WygCDgBAFqjq1vNl2WDypQfpXe6djiQR52x0oddlOrjL6vrb9wxKstr/rM/q/2Z7c8eOB4XkFdepG6T + 5YLKFh8GRJ4dcK7Sn7hhWF94/5h+cM2EHl4vK2qBs4/hAfNYvvvrMX26eWz719yPHcgD7vtf4uxVncxO + fiq704F2OvbSur70wTGdjE7KslneBkcm9ffMYz3GPGbXtgDaJla/48p/Jc+Pks85dz7QYoddmOprH1uv + J8q/7k9r3Dzmqx5dr//cbAPXtgFaLQjTf5Rlgspa1+J1O5udPZDd+UArfemWEV0fq+DKn0mNTuov3jzi + 3EZACw0Gtb5dZJmgMudHybccAwBouvnnpfq6J0rw5n6Du/bx9frAc93bDGi2IErPlOWByl7X4qE5ZqeP + ZQcB0EyvX5rqe54blyWPsv3y+XF96Hd4SwAtN9YZDu0jywNVIS9WlzoGAtAUB5+f6vtXT8hSRxvr4bUT + +hBzouTahkBzJBfKskBVqTOqL3APBqCxunqUvv33PPPf3H729Ljuit3bEmg0L0xfL8sCVSmz83+aHQxA + o8X3FeciPnlp8T2jzm0JNNiNshxQ1eqI6u9wDAigYU6+aqiSX/ObbXabnfSDIec2BRoliNK3yXJAVcwM + gjuygwJoBPvS/yNred9/S7NXEOStADTRrbIMUFXze9LjHAMDmLXP3TQiSxltaZ9dwY2F0BxerI6SZYCq + nBkMN2cHBzAb9kY+T/Tz7H+2PdY3wQ2F0Hix+rFM/1T1gjA53DlIgC102jVDsoTRbPvA1XwWAI2WHCHT + P9FWW9kzQvdAAWbuiofHZPmi2XbZQ2PObQxsiSBKrpdpn2hDHT3JYa7BAmyJVSkf/W9Udlu6tjGwReLB + N8m0T/SH7Jmhc8AAM3Dcf9dl6aJGZW+Z7NrWwIzE6mqZ7on+OLk64OS0QQPMwGdWDMuyRY3q72/k2wCY + tUmu+kcvWRCqKx0DB9hs5/yCK/81urPv4sqAmKVQXS7TPJG7rtpApxksI9MGD7CZLnmADwA2uovv54OA + mJWRznCwS6Z5oo3nh8k3HQMI2CxXPcr9/hvdlWaburY1sJm+LtM70Us3b+mancyAeS4zgIDNcs1jnAA0 + OrtNXdsa2KRQrepavG5nmd6JNp0fJv/XOZiATbj0Qd4CaHT2bRXXtgY2xYvSj8i0TrSZLdTbmMFzT3Yw + AZsS3cuHABtdN7cHxhYIYnWvnctlVifa/Drj5K1mEPG1QMwINwFqfP/0Y74GiBmbtJd5l+mcaOaZQfT9 + zKACXtJ7ruBCQI3uRLNNXdsa2KhQXSLTONGW1bFkwDeDaXja4AI2wt7DfnCESwE3Krst7TZ1bWtgI4aC + 2vBcmcaJtjw/Vl9zDDBgo5av5JsAjer6J/gGAGYoVl+W6ZtodnUt1i/3Q/Wwc6ABDp+6kcsBN6qP38D7 + /5iRR7wL9A4yfRPNPi9SR5qBxQcCsVnm1ZReO8TbALNtdX1yalu6tjHgMMEH/6gpmcF1XmawARv1jTv4 + OuBs+4/bR5zbFtiIbpmuiRpbUOvbJYjU7x2DDpjmoPNS/bx5Bktb1nNqUs8329C1bQGHZ7xF/bvKdE3U + +IJYvc8x8ACnM7g18Bb3aW4BjBnwupO/lGmaqHlxy2DMxA1P8o2AmXYdn/zHzFwm0zNRc+uo1fc0A64v + MwABp0OWpvq3AxOytNGmerJ/Qh98Pi/9Y7MN7LOkvpdMz0TNz4vVxx0DEXA68pL61Cfa6aWz35w4+ntc + 9Q+bL4iTj8q0TNSitN7aDL4V2cEIbMwJl9f1qpSTgI31nNk2b7+MxR8zstzOxTIrE7WuOfHQ3mYArs0M + SGCjjri4rh9dx9sB2R5eO6HfehEv+2NG1ti3Y2U6Jmp9HXHyXsfABDbqwHOVvvyhMVn6qp19PeTSB8f0 + AWabuLYVsHHJe2QaJmpffpSe7x6gwMadds2Qfqyvuq8G2FdCTr16yLltgJfiRSqS6Zeove1x1qpXmkH5 + SHaQApti73L3mRXD+oE11TkRuH/1hP6HHw3rTu7why3z0F41/QqZfonaX2dUX2AG5mhmoAKb7R2X13V4 + 76i+b9W4Hi/R+YB9LPeax7TknlF9PB/yw+yMBWH9z2TaJcpPfqi+6BiwwIztX9twQmDvhPcvN43or/x8 + ZOreArPxX3eO6p77xnTvQ2P6h4+v1zeu3GCZ+Wf77+z/Z/8b1++dCfuz2p/Z/uz2MXAzHzRO8jmZboly + 1kK9TRCpm9wDFwCwxWJ1y1a9eluZbYnyV1AbnmsGK1cJBIDGWWO/di3TLFF+83vS48yAHc8MYADAzE14 + YXqCTK9E+c+L1L85BjIAYAaCOPlXmVaJCpLWW5uTgB+4BjQAYLNcw6V+qZDNW7pmJz9UDzsGNQDgpT0a + 1Pp2kemUqHgFS9KD/ShNHYMbAOCmurrVfJlGiYqbF6tTHQMcADDdpB+rU2T6JCp+QaQWOQY6AOCPpP8l + 0yZROVpQ09ubwX3z9MEOALC8SP3kqIV6O5k2icrTnPMHdzeDnJsGAUBWqB6eGw3sJtMlUfnqWDLgm8H+ + /LTBDwDVtaYzHOySaZKovNm7WZkBX88cAABQRUMdPclhMj0SlT8/VO83A38icyAAQJVMBKE6SaZFourk + RcnnHQcEAFRCEKX/JNMhUfUyB0F39qAAgAqoyTRIVNF69bZ+lF7rODgAoJSCKLmer/sRmabuGRCpe7IH + CQCUT3rX/HD1q2T6I6L9asmfmIPj/ukHCwCURKx+vXd38mqZ9ojohTpj9RruHgigpB7rqNX3lOmOiLJ1 + LR6a40fpbxwHDwAU1dN+93CHTHNEtLHsFbHMAfNM5gACgOIJ1So/SubJ9EZEm8oeMBsOHMcBBQDFsIb7 + +hNtQX5Peog5gPoyBxQAFMFAZ1RfINMZEc20zjB5izmQVObAAoA8U1zfn6gByc2D1mUOMADIo377xEWm + LyKabR1x/Q3mwFqdOdAAIE/W+fHgm2TaIqJG5dWS/YNI/d5x0AFAuz0XLEkPlumKiBpdx5IB3xxoT2YO + PABoo+S39uvLMk0RUbMKasNzzUH32PSDEABa7pHOcGgfmZ6IqNn556V7mAPvV5kDEQBaJojUg/ssqe8l + 0xIRtSp7Uw1zEHIXQQBtkN415/zB3WU6IqJWZ2+raQ7EZe4DFACaYnnX4nU7yzRERG2rV29rDsjuzAEK + AI0Xq3OPWqi3k9mHiPKQF6ZnmAN0YtoBCwCzNxmEaqFMN0SUt8wBepI5UIcyBy4AzMawF6oPyDRDRHnN + 6x58szlgn88cwACwJdYGYXK4TC9ElPfmRgOBH6qHHQczAGyux4OewX1lWiGioiRfE7w5c0ADwCZ5kfqJ + eSKxm0wnRFS07Kd1gyg90xzQk9kDHAA2oragpreXaYSIipwXq1P9KE0dBzoAvED5sTpFpg0iKkv2boLm + AH8oc8ADgPVYZ6wOkumCiMrWvKVrdvIi9QPHwQ+gstJl3qL+XWWaIKLSpvXWXpR83hz449MnAgAVMj51 + cZ+FehuZHYioCnlheoKZANZlJgQA1bDG70mPk+mAiKqWvY+3mQh+mpkYAJSY/Ypf1+KhOTINEFFls28J + bLiPwGh2ogBQKmO85E9E0wp66m80E8QjmQkDQBmE6uGO7vqhcrgTEf1xc87WO5qJ4tvOCQRAQSUX7XHW + qlfKYU5EtPG8KPkrM3GsmT6RACgQcwwn75HDmoho89pnSX0vM4GsyEwoAIpheUetvqcczkREM0zrrf0w + /bCZTNZmJhcA+dRvnG6PXTmKiYi2PC9MX2vfR8xMNAByJV02Jx7aWw5bIqLGFcTJu81E8/T0iQdAGz0b + xOp9cpgSETWnoNa3i3xTYCIzCQFoLXub71rX4nU7y+FJRNT8OuPkrWby4e6CQHs83hGqo+VwJCJqbd4F + eocgUl8xk9FQZnIC0Bx1P1Zf7lqsXy6HIRFR+7LXFZcPCdqXJF2TFoBZS5d5cb8nhx0RUX7y48E3mYnq + jukTF4BZuCcIk8PlMCMiyml/uHbAc5lJDMDMPGucvlWv3laOLiKi/GevPW7vPGYmsOEXTWgANm3UftOG + T/cTUaHrqg10+rG6wkxqfD4AeGmTZuG/fG40EMjhQ0RU/DpjdZCZ4HqnJjn35AdU2Qpu10tEpc6P0teZ + yc6eCLgmQaBqVgRh/c/k8CAiKn8dPclhdvLLTIZAVdzqxeooORyIiKqX/XqTmQx/mpkcgXIK1e1Bd3qs + DH8iIvLD9O1+rH7snDSBogvVj4IofZsMdyIiyub3pIeYCbNmjPzRBAoUz5jRy3v8REQzyAvT18p1BPpe + NKECRZDY7/F3hkP7yHAmIqKZNm/pmp3MycAZZlJ9KjPJAnnzrD1p9Rb17yrDl4iIZtuCmt4+iNO/sR+i + cky8QNt4kbotiNLTjlqot5PhSkREzcirJfubCfdMM/muzk7GQIv0GzX7mRUZlkRE1KrsPdHNJHyyYa8n + wBUG0Qr3GKfvVdOvkGFIRETtLOgZ3Fc+NPj0iyZroBGes684dYaDXTLciIgob9nPCnTEyXvlBkRDmYkc + 2Fx1e2MeL0r+yo4pGV5ERFSE5pytd/TD5EQ/Si7yozR1TPLAiw2bcbLMD9MP22+fyDAiIqIiZ9+z3XAy + MHUjIi4yhBeYsbBh0ef++0REJc9+T9sLk781rjMLAG8TVI/Z5+kPvSj9SFDr20WGBRERVSn7NoG9Rrt8 + rdB+wtu1YKD4njTsJaZP5uV9IiKaVseSAd8sEqcb9q2CQcO1mCD/6sYKL0o+3xGqA2T3EhERbTrvAr2D + 35Me50fJt/wwudssKOtftMAgX8y+SX5h9tM37Ss69hoRshuJiIhml/0gYRAmh9tnlVMfHIvUuswihNZR + xq1Tb92EyYm8l09ERK1rod6mq1vNt58gN4tRLYjUgy9aoNBYzxq99sZQnVF9gd32sheIiIjan/2GgX2V + wCxWp9tbwppfb+UaBDMyuuFEKrlo6pUW8+ze3hpaNi8REVGB6tXbBt3JfmZxO9mcFHzVLHBXeZF6wvzv + sRctfFVjH/vjQaiuNNvjK2a7vN9uI7utZKsRERGVt7nRwG72JW2zGJ684bMFU19Vszc3sl9bGzdci2dR + 9Bn2q5W98jXL0+0H9MxjDrh1LhER0Uaa36tfZm9A40XqSPNM+SQvVh83z5S/6MXJ2X6UXGgvZmMW1TuM + xwx7e1rXItxI9u+wf5f5O+3fnVw49bNM/Uzq41M/o/lZu2oDnVw/n4iIqEXZZ9X2FYU55w/ubp9lT+lR + B9pXGKbE6hj7DNwL0xPMIm5vo3yy/Wf77zpCdfQL/539PS/8fvmzduOleSIiIiIiIiIiIiIiIiIiIiIi + IiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIi + IiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIi + IiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIioua11Vb/H5RJBVvCTy+9AAAAAElFTkSuQmCC + + + + + iVBORw0KGgoAAAANSUhEUgAAAgAAAAIACAYAAAD0eNT6AAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAADimSURBVHhe7d1Z + cFXXnt9xqnMr6Twk1Z3qqjwkqa5UqrqSl7zlpSuV3Hvrpqek+96+bWYNCMQ8aETzCBJCCCTmeR4FCBDz + IEYBAg1IICSBEBgDtgHb2MbzdL1y/seijfEfOGefvc/Z++zvr+rzYlt77bMkr/U/56y91hBCCCGEEEII + IYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEII + IYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEII + IYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEII + IYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEII + IYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEII + ia+UlZk/mlZz8z9PWtjz15MX9A6dXNc7YUptT8bkBT25AAC4WUr1tTn/UHzliL06Gn9XfGXLb4uu1P6+ + rKvgH8uu/s9flplfDE6b3s3kqu4/nVzX97sptb2LJtf2dgV8GWAAAPCa5Lnd5pdZlx33q4C/ym374v8V + dlz9fUnnnFGFnX8+OK26O9MXD/yrwLv6vw+8u98V6LBvXuxAAAC8KFoFwM9kXzZ/m9/+5PfFXatGzu/4 + s8Hp1j1Jr+v6k0l1PcWBTnr/xU4DAMDrYlYAPOc3M1v/8PeF7Sdd8alARu2Dfz2prrc00DlPX+wsAADi + hRsKgGd+ld36/T8Udpz+XVnXnwxOx9FNYOL/9ZTa3htaRwEAEE/cVAA885uctm9+V3SldHBadj5jyu7+ + 8eDCPrWTAACIN24sAJ75vwXtdxxfHzB1wY2/mFzbd03rHAAA4pWbCwAhTw78Y3n7/xmcru3NlIU9/yPQ + CSzyAwD4jtsLAPHr7Nbv3yhpnzg4bduTyXW9fxvogM9e7BAAAPzACwWA+FX2ZfP74o6iwek7skyqu/7L + wItnEx8AgG95pQB45rclnbmD07i1TF54/b8HXvhHL3YEAAB+4rUCQB4V/F1J+8jB6Ty8pC68/u8DL/rd + FzsBAAC/8VoBIH4zs/W7fyrr/q+D03pokYN7Jtf2Hdc6AQAAv/FiASD+Jq/9w7AOGJq8oDdf6wAAAPzI + qwWA+G1R5+HB6f3VmTDv+n8JvFgW/QEAMMjLBcCvsy+bocWd/3twmn95Ai/00IsvHAAAP/NyASD+tqD9 + /cFpXs/g8/7qiwcAwK+8XgCI35d05A9O9z9PoAA4r71wAAD8LB4KgL/Oa/9kcLr/aQY3/FFfOAAAfhYP + BYD4x/KuqYPT/o8JvMCGF18wAACInwLg7wraHgxO+z9kclX3nwZe4FcvvmAAABA/BcCvAkYVdv754PQ/ + ZMikBX2TtRcMAADipwAQvy25snlw+g9+/H/0xRcLAAB+EE8FwN/ltz8KTv5lZWd+EXhxn7z4YgEAwA/i + qQD4dXbr92PKzvzxkCkLrv+l9mIBAMAP4qkAEP9U1jl2yKQFvTO0FwsAAH4QbwXA74qv7BwyqbZnmfZi + AQDAD+KtAPj7oitXAwVA70ntxQIAgB/EWwHwN3ntH8gTALdefKEAAOBH8VYA/FVO29dSADx88YV6Xfr8 + TrOodL/ZnrvBHMhaak6l1ZgT6bVm98xVZmPBVlNeedZMWdCj/mwsZCy+atbuOmqOHt9hLjWvM72ty821 + SyvN2dObzf7Du031hmYzpc499ztl8XWTubfF5J07ZQo7jpmS3kOmuPuwKbjcZHJPnzHpW9vMZBfdLwBE + Kt4KgN/MbP1OCoDPXnyhXjVn9klzMm2euZWabu6Mm/FK1yblm/rc9SazplO9VjTM33zWXL+8wnz7Zpkx + bxW/0sc355iTTVvNzGWxu9+0re2m+PohU/lkp5nzdMcrzX642+RfPGmmrbimXgsAvCTeCoBfZ7d9LwXA + 9y++UK/Jn3vJNKUvUCf61+mbkG3WF2wzUxdcV6/thOJVbcF3+NpE/zpf3p5lGg/vNlMXRu8d9rTVXab4 + 2mFTqUz0r1PxwU6Td/qMmRLF+wUAu8VbAfDL7MtGCgD1xXpF9ezjpnf8THVyD4d8TZBe06W2YSd51/9J + f4U6uYejr3WZyVrq/P2mbWs3sx/tVif3cJT2H+DTAACeFXcFQICnC4AlJfvM7XFp6oRuRduUUpM5r0Nt + yw7rdh01390tVSd0Kx73zDO5y6+obdkha2+LqfywXp3QrZj1YI+Ztuqq2hYAuBkFgItUVJwyt1Iz1Ik8 + Es3T55hpDnwdMHfDefPNnXJ1Io/Enc5FZvrCbrXNSKRt6rB18n+m/M1GM2URXwcA8BYKAJeYOa/d9EzM + VSdwOzTkrFbbtSpnWad5erNSncDtcP7MRrVdq6Yu6zaz321QJ3A7FLUfU9sFALeiAHCJfdkr1InbLgOp + 6aZ4znm1bSvkcT5t4rbL92+VmKoN9t1v/oUmdeK2k6wt0NoGADeiAHCBwqqLtn7v/zIn0uar7YdLVvx/ + +6Z93/u/TH/7ErX9cMmKfyc++n+RLArU2gcAN6IAcIHdM9eoE7YT8qovqfcQjqambeqE7YSy1ZHfr2zu + o03YTpixwbkFjABgJwoAF+icVKRO1k5YW7hDvYdwyEp9bbJ2wr7DDeo9hKP8rX3qZO2E3DNn1HsAALeh + AIix4jnN6kTtlDMzqtX7CJW8I9cmaqfc7lis3keopq/uUidqp5TdaVTvAwDchgIgxurKDqoTtVOuTspX + 7yNUK+pPqBO1U2SDIe0+QpWx87I6UTul4v1d6n0AgNtQAMTY6sKd6kTtFHkaYEqt9WfWt+/br07UTpGn + AabVWd/DIOvQBXWidpIcLKTdCwC4CQVAjG3J36RO1E7KmG/98B05yU+bqJ0Uyc6AOU1n1UnaSfLUgXYv + AOAmFAAxtqawXp2knSKPG0ZySNCOxkZ1knaKfAIQya6A2YfOq5O0k6Yu4RMAAO5HARBjC6O8BkCODNbu + I1QrdkR3DcCntyrV+whVxq7orgGo/IA1AAC8gQIgxsorz6oTtVPOTa9S7yNUFWtb1InaKXe7Fqr3Earp + 6zrVidopZXf3qfcBAG5DARBjsiDv2sQ8dbJ2woaCbep9hEru98MbVepk7YSDRyN/Rz3rwV51snZCXvMp + 9R4AwG0oAFzA6XMAnlc096J6D+E4c8rZcwCeV7ku8vvNv3BSnaydkLaF8wAAeAMFgAvI1wC3U50/CyDS + j/+fkUn5+7sl6oRtp0g//n9mxoZOU/mx82cBlMmxwEr7AOBGFAAucThzkTpp22l25Wm1bSsuN69TJ207 + 1W2xb1vdgrYT6qRtJ9l0SGsbANyIAsAl8qsvmZvjs9SJ2w6HMiPbUvdFhSvbzJe3Z6kTtx06L65S27Vq + 2qqrpuK9XerEbYeS64fVdgHArSgAXGRB2WFHjgVum1Jq0mrs35xmydZT5g937T8W+FFPjclcclVtMxIZ + 9a1mzkf6BB6J2W/vMdOWX1PbBAC3ogBwGVmlr03iVl2bmG/y5jr30fTuA3uDm/VoE7kVT/srTcnqVrUt + O8w8es5UKpO4VRWPd5sZ663vrAgAsUIB4EKLSveb/vGZ6oQejktTy01utXOT6TNrdx01X98pUyf0cLzd + Pd8UrWxT27BT5t4WU/lkpzqhh6P8bqOZtoZtfwF4EwWAS82qOBOYwGepE/vr3EpNN7tz1pjp86P3sXTV + hvPmra46dWJ/ne/ulpqzpzebtMXRu9+0jVdM2cB+dWJ/rY92mILWExz6A8DTKABcTDbdWVLSaFqnlKkT + /YvkUwNZ7CcLCrXrOU3uVz4NkHfy2kT/om/ulJmOC2tM6erYrJ6XR/bk0wB5fE+d6F9Q+WG9Kb52hI/8 + AcQFCgCPyJ97yawv2G4OZi4xZ2fMNW1TSszFabPNifQFpmHmKlNbdsjMiOI7/teR7/EbDu4NPi54s32p + eXi9xtzrqjPdl1aYc4F3+6t3HjPpUXzH/zryUX7OibOm8MoxU3rjoCl/a68pDxQGxdcPBd/tZ+1r4ZAf + AHGFAgAAAB+iAAAAwIcoAAAA8CEKAAAAfIgCAAAAH6IAAADAhygAAADwIQoAAAB8iAIAAAAfogAAAMCH + KAAAAPAhCgAAAHyIAgAAAB+iAAAAwIcoAAAA8CEKAAAAfIgCAAAAH6IAAADAhygAAADwIQoAAAB8iAIA + AAAfogAAAMCHKAAAAPAhCgAAAHyIAgAAAB+iAAAAwIcoAAAA8CEKAAAAfIgCAAAAH4rLAmD6rL1fTC9v + MAAAQDe+eK/5h5nH48qQrBkzDAAAeLnpkyaZkW+8EVcoAAAAeA0KAAAAfIgCAAAAH6IAAADAhygAAADw + IQoAAAB8iAIAAAAfogAAAMCHKAAAAPAhCgAAAHyIAgAAAB+iAAAAwIcoAAAA8CEKAAAAfIgCAAAAH6IA + AADAhygAAADwIQoAAAB8iAIAAAAfogAAAMCHKAAAAPAhCgAAAHyIAgAAAB+iAAAAwIcoAAAA8CEKAAAA + fIgCAAAAH6IAAADAhygAAADwIQoAAAB8iAIAAAAfogAAAMCHKAAAAPAhCgAAAHyIAgAAAB+iAAAAwIco + AAAA8CEKAACwIC97pvrPAa+gAAA8rqSoxOzed8x09L5tBh59be68963pvffUnLp4zSxdutpkp6WpP4fw + 5M/MMVt37DMtXXf+uZ9vvv2ZaW6/adZt2GZmZmSoP+e0+fMXmmOnW033nQ+C93T78Tem69Zjs//oOVM5 + q1L9GUBQAAAeJhOPTEIy8L/MubY+U1JYrP48QrNw4TJz/e6Hav8+IwXYnIoq9eedkJeVbY6cbFHv5Znb + gUJlV6A4pAiEhgIA8Kgt2/eog77myo13TXFBkXodvNqSJSuDE6nWry/qu/+JqZpTrV7HTrmZWeZ8+031 + HjSHm1ooAvAzFACABy1bvjb4Ua822L/MudZeJoEwlQSKphsPPlX782U6bz40uYF359r17LL34Cm17Vep + bzisXgv+RQEAeIy8w+x/53N1kH+dhXVL1WtCd+jERbUfX2fj1t3q9exQWlTyz2sQwiEF44oV69Rrwp8o + AAAPkY/xr91+Xx3gQ3H01GX1uvi50uJSM/DwK7UfX6e1+y31mnbYvnO/2mYopHCMxlcU8AYKAMAjcjIy + TUvXbXVgD1VX/yP12vi5fYdOq30YCnm37dTXAKcudKlthkoKSNaDQFAAAB5x8PgFdUAPx437n6jXxk8V + 5Oa/9umK15HHM7VrR+pi54DaXjikkJSCUrs+/IMCAPCALTv2qQN5uK6/+US9Pn5q554jav+FoyA3T712 + pJpb+9T2wnXk1CX1+vAPCgDA5RYvWWlp0ZfmbGuv2gZ+JDv8yUZKWv+FSjbl0a5th30WngB4GSkstTbg + DxQAgItVzKoIfmyvDd5WyMZBWjv4UTj7K7xM4+Ez6rXtUFNTp7ZphaxVWLJ0ldoO4h8FAOBS8j20LNrT + Bm4rrg28F9w9TmsLP5DtfCN5ykLIpOr0Fryy/bDWthWyzwFbBvsTBQDgQjIRNbfdUAdsK+QrhDr2AHgt + +YRE679wnLzQpV7bTuWl5WFvUPQqUmhKwam1hfhFAQC4kBzkog3UVvFd7+vNTE8Pbpms9V845lUvUK9v + t0ULl9m2NkRc6OiP2YFGiA0KAMBlNm7eqQ7QVrHaOzQrVq5X+y8c8qmNdm2nbN2+V70Pq2TnQ60dxCcK + AMBFFsxfaHn3OQ3Pe4fu8rW7ah+GQ04N1K7tJDv2h3jehk31ajuIPxQAgEuUl5SZ3nsfq4OyFfIoGscA + h0Y+Ttf6MByt1+/F5LAl+dj+fEe/ek9WyMmHdbVL1LYQXygAABeQZ8/bex+oA7IV/e9+Yarn1qht4efC + OVr3ZWJ50E5xfmHwKQ/tvqyQfRBmlc1S20L8oAAAYkzeNZ66eE0diK0Invq2aoPaFn5uXvV8tR/DIavo + ZRGhdv1oqaqca25aPCVSIwsiC3Jy1bYQHygAgBjbc+CkOgBbVd9wSG0HukgP1xFu2WBp6bI1wQJQu0cr + zlzuiXlhA+dQAAAxtHrNZnXgtaqp+UpMvof2KtlpMdIJU85XyMnMUq8fC1IAavdplRSoWjvwPgoAIEZq + 5tWaWw+/VAddK2QRGjv9hUcekdT6MhyydbB27ViRAvD4mTb1Xq1iC+n4RAEAxEBpcam5fvdDdbC1Qq5V + 6tDxs/FK+ivSRy5lsZws4NSuH0u5mVnm0tU31Xu2QvqpdsEitS14FwUAEGVODM6yf4DWFl5ODuzR+jMc + OxsOq9d2A3kEVB4F1e7bCnlEVR5V1dqCN1EAAFEU/Hj2bLs6wFq1dv1WtS28nOx7H+mK+f7AzxflFajX + d4u5VfOCj4Rq928FXzPFFwoAIIp27jmiDqxWNew/obaDV9tlw+9h36HT6rXdxu6FpifPd7LQNE5QAABR + snz5Wh7RcgF5B9sX4Y6L8rVLWbF3Pg6XQlF7HVa5+asPhI4CAIiCqjnVtm7S0tH3jslnkxZL7DhA53BT + i3ptt5J37CcvXFVfixVSyK5cvVFtC95BAQA4rLigyFy7/b46kFoR3Ka1tFxtC68mByNFujBOJr/KWZXq + 9d1MnlZo67mvviYrZG2B7KKotQVvoAAAHCQbxFzsuq0OoFYEH8eq46AWq+R5dq1fwyHfgWvX9oLy4lLT + 89ZH6uuyovvNJxw45WEUAICD5Hx1beC0iqNarZP1Ep03H6r9Go551QvU63vF/Jq6iPc/eJ4co5zLkwGe + RAEAOGRbfaM6YFrVeOSs2g5Cs2LlerVfw9Hc2qde22vk0VHt9Vl15PRltR24GwUA4IBFi1eYgUdfq4Ol + FXLeu5z7rrWF0Mg7Va1vw7Gwbql6bS+SglJ7jVZtDRS8WjtwLwoAwGaVsyrMjfufqIOkFV23HpvC3Hy1 + LYRm0cJlat+GQzbBiafn3+UrkTMt3eprtUIWRy5dukptC+5EAQDYSHaY6+x/pA6QVtx8+zNPrjh3m/Pt + N9X+DcfyFevUa3tZQW6eLesinpG/1zkVVWpbcB8KAMAm8hF9c9sNdWC0Qt5RLVmyUm0LoZNH1bT+DUdX + oKiL102XZpfPNn12fmI18Nj1WyTjBxQAgE0OHGtWB0Sr3HbMrFfZsQFOvJ+3sHDhMnPbxjUrF67cYs2K + B1AAADbYuGWXOhBaJefUa+0gPLIeI9Ltl2XjID9MZlJwaq/fKq/tluhHFABAhOrqltr67uli50Bwxzqt + LYRHCimtj8Php09iDh6/oPaBVRs371TbgTtQAAARkPPR5Zx0bfCz4trAe6Y4v1BtC+EpLSqJeMMb2XZZ + ttDVrh+PgutYbFgw+Yw8CiuPxGptIfYoAACL8mfmmPa+t9WBzwrZW716bo3aFsJnx3Pu9T489U6eZJFH + T7X+sKIvUETJQkOtLcQWBQBggawIP33xmjrgWSHfU8tOdVpbCJ9MYpGevtgf+Hm/rmavqpwbfKRP6xcr + rtx41xRweqXrUAAAFuw7eEod6Kzasfug2g6s2bn3qNrP4ZDfsXZtv1i6dHXECyifd/Zyj8mO00cpvYoC + AAjT6rVb1AHOqhPNV+Jqh7lYk+/s5WNnra9DJWsHyorL1Ov7iRSmWv9YtdfnRZXbUAAAYaipqTO3Hn6p + Dm5WtHa/ZfI4Sc1WW3bsU/s6HDzC9gMpTI+dblX7yKp1G7erbSH6KACAEMk7wp67H6qDmhXX33wSXKmu + tQVr5PFJeW5f6+9QycfebL/8o9zMLNPSdUftKyvk05XaBYvUthBdFABACORj5bae++qAZsWtd78wNR4/ + V96N5N2l1t/haGq+ol7bz0oKikz37ffV/rKi797HwUdotbYQPRQAwGvIx6DHz7arA5lVq1dvUtuCdfJk + hh0H28yjMFNVzakOPhmh9ZkVHb1vBx+l1dpCdFAAAK9hx4ry5+1uPK62g8jIY5Raf4fjXFufem38YMWK + dbY+GXDyQhcLYGOIAgB4BTkC1s4BT85fj9dT5WJNFlRqfR4O2dZZuzZ+JAWs1ndW7dpzRG0HzqMAAF7C + 7o882/veMflshuKIRYuWq30ejtbr93g3GgLpo1OBd+5aH1ohBfbK1RvVtuAsCgBA4ciip9JytS1Ezo79 + 65cvX6teGz/nxKLYedXz1bbgHAoA4AU58tjTVZsfe6pdrLaFyM2bO1/t93DIVrW8+w9PeXGprY/Fdr/5 + xJTwWGxUUQAAz5FJ4Oipy+oAZdX6TTvUtmCPkxeuqv0ejrXrt6rXxqvNr6mL+MTF58k6jlw2xooaCgDg + Odt37lcHJqsaD51W24E9KmdVRLxIUzYOkmNwtevj9dass3dr7OPnOvg0JkooAIBBS+w+/KS1l8NPHHbk + 1CW178OxeVuDem2ETgpdrW+t2hYoxLV2YC8KACCgYnalufHgU3UwskLOUy/MzVfbgj1kG+VIP37uvfc0 + uKBNuz5CFzweu6Vb7WMrpBCXglxrC/ahAIDvydnxXf2P1IHICikk2EveeY1Hzqr9H476hsPqtRE+2dVP + dvfT+tmKm29/ZuZUVKltwR4UAPA1+e73vA2PkD0z8Ohrs3jJSrUt2KcovzDiPRrk5/mUxl6zy2ebvvuf + qP1txdWBx8HftdYWIkcBAF9rONCkDjxWbeL75KiwY3vmfZxN74iFdUvN7UAhrPW5FWcv97Ao0CEUAPAt + ebdi56K/Qycuqu3AXvKdfd+9p+rvIFSydqC0uFS9PiK3aetutd+tYj2AMygA4FvyDlAbbKy40NHPo2RR + snXHPvV3EI7DTS3qtWEfKYi1vrdCPgXQ2kBkKADgW3ZtZdol31PmFahtwF45GZnB5/a130Oo5FMfeepD + uz7sIwWxFMba7yBc/e9+QYHtAAoA+FakHyOLm+98zkrlKJJdFbXfQziamq+o14b9pDCWhXza7yFcJYXF + ahuwjgIAvtV772N1oAlHcNX/4hXq9WEveda88+ZD9fcQjprqBer1Yb/ykjJb/j8TPA1gPwoA+FZLlz0H + /sgnCbKgUGsD9lmxaoPa/+E419anXhv2K8jJNR1976i/h3DduP8JTwI4gAIAvrWz4bA62Fghp8nJgKe1 + A3vIQTFa34ejrm6pem3YSz6tOXO5R/0dWHHiXIfaDiJDAQDfku8UZXGRNuBYIQOeDHxaW4jMosUr1D4P + hxQQvIuMDjufsJFFmzU1dWo7iAwFAHzN7ueV2VzGGedtWE2+fPla9dqwlxytrPW/VQePX1DbQeQoAOBr + 8o7w2OlWdeCxat3G7WpbsGbe3PlqP4dDvqLh3b/z5J36rYdfqr8DK+RTm9ysbLUtRI4CAL6Xm5ll24JA + IbvMLViwSG0L4Tt14araz+GQd6XatWGfsuIy03P3Q7X/rbj+5hNTUlSitgV7UAAAASUFRRFvMPO8vnsf + m/LScrUthK5yVkXE2zV3336fTWQcJtsz27Wxlrj17hfBT360tmAfCgBg0NyqeRGfMPc8ORpVjkjV2kJo + jpy+rPZtODZzQJOj5KuV42fb1b63Qgq+VWs2qW3BXhQAwHNWrFhn6wFBJy908d2zRXJYj3ydovVrqHrv + PQ2+O9WuD3vYcTLj83btO6a2A/tRAAAv2N14XB2YrJIBUmsHr9Z45Kzan+GobzisXhv2WG5zwXympZtH + aaOIAgB4gbxjPxV4564NUFbIALly9Ua1Lehk29dI92iQcxoKc/PV6yNyVXOq7f/KjM20oooCAFCwqCm2 + 5GNgrR/DsZc9GRwTXDR7+321361g0WxsUAAAL1FeXGrrY03dPNYUElk42Xf/E7UPQyVrB2QNgXZ9RCZH + Hpu9au9js7W1i9W24CwKAOAV5rOxSdRtrW9U+y4ch05cVK+NyMjXY0dPRf5kxvPkiGetLTiPAgB4jTXr + tqgDl1VysAlPBuhyMjIj3o9B1lxUzK5Ur4/I7Nh1QO1zq/YdOq22g+igAABC0BgYqLQBzKrtO/er7fjd + +o071P4Kx4nmK+q1EZklS1fbuuL/bGuvyWbFf0xRAAAhkEeTTrd0qwOZFTKQyp4DWlt+JX3cefOh2l/h + qKleoF4f1sknKjcefKr2txXB47Nz89S2ED0UAECIZHGaPKqkDWhW3Hz7MzOnokpty4/kUUmtn8JxLvCu + Urs2rCvIzTdd/Y/U/rZCConKWXxF4wYUAEAYZpfPjniF+vOuDjwOPvOuteU3skBS66Nw1NUuUa8Na+QM + hfPtN9W+tmLg0ddm8eIValuIPgoAIEwL65aa24GBTBvgrLh45VZw8ZvWll/IpKD1TTguXX1TvTasO3js + vNrXVm3aulttB7FBAQBYsGlbgzrAWXW4qUVtxy8udPSr/RKOZcvXqteGNfyNxz8KAMAi3h3ZQxbtaf0R + DllUxqOV9uFTLn+gAAAscuT70SUr1bbi2amL19T+CIfs1aBdG+FjnYt/UAAAEWCFdGTk8bJIny2XPeml + GNOuj/DwpIu/UAAAEeIZaevs2FZWvqvWro3wOLHXhWwepLUFd6AAAGzALmnhKy8pi/h75t57T4MnN2rX + R3js3u1yG7tduh4FAGAT2d5XGwitkgFZayde7D96Tn3d4ahvOKReG+Gx+7yL45x34QkUAIBNOCktdLIo + rP/dL9TXHKqb73xuCnPz1esjdHLipRzJq/WxFZx46R0UAICNOCs9NLv3HVNfbzj2HDipXhuhKy8uNT13 + P1T714ruN5+YkqIStS24DwUAYLOSgqLgynRtgLSi797Hpry0XG3Li2SleaSPmUlhVBqYvLTrIzSydqKt + 577av1bcevcLM696vtoW3IkCAHBA1Zxq0//O5+pAaUV73zsmPydXbctrttU3qq8xHIdOXFSvjdDI11Wn + LnSpfWuFLICVw5y0tuBeFACAQ5avWGfrkwFnWrqDj2ppbXmF7AYnHxNrry9U0qfy6KV2fYRmd+NxtW+t + 2rXniNoO3I0CAHDQzr1H1QHTKvnuXGvHKzZsqldfVzhOnOtQr43QrLC5MD15oYsV/x5FAQA4SAbG42fb + 1YHTqlVrNqltuZ18etFpw66J1XNr1Ovj9eZWzbP1qynZNVDWdGhtwf0oAACHObHYSg7Q0dpyM/mOWHs9 + 4ZANkrRr4/WCi1PvfKD2qxXBxaklZWpb8AYKACAKyorLbH3c6roHH7eS58O11xKO2rol6rXxarnyeGqX + zY+nLliktgXvoAAAoqSmps7cevilOqBa4aUNV+SUQ+01hOPS1TfVa+PV5GuoY6db1T61at3G7Wpb8BYK + ACCKVq+1d8vVE81XPLEA68KVW+r9h2PpsjXqtfFqO3YfVPvTqr0HT6ntwHsoAIAo2xcYQLWB1artgQFe + a8ctZL2Cdt/hkBMSWWkePimabD2k6nJP3B9S5ScUAECUBY9dvXhNHWCtkAF+xcr1altuYMdrlcNqtGvj + 5aoq5wbPS9D604rgMdVxshkVfkABAMSAPDrV3ve2OtBaIQfryCNeWluxNKeiKuJ3oLKt8syMDPX60Mkh + SV23Hqv9aUXfvadmVtkstS14FwUAECPyCFXvvY/VAdeKqwOPTXF+odpWrNix+GzT1t3qtaGTYqm5/aba + l1YMPPraLFq8Qm0L3kYBAMRQXd1SczswwGoDrxUXOweC2+1qbUWbFDiRvrbewDtP2UdBuz50B49fUPvS + qo2bd6rtwPsoAIAY2xh4h6sNvFYdOdmithNt+4+eU+8vHDsaDqnXhm7L9j1qP1p1uMkdf0twBgUA4AIH + jjWrA7BVm7c1qO1Ei3wVIesStHsLlSxgk++ytevj5xYuXBb8uF7rSyvk0U3WXsQ3CgDABYLf27bdUAdi + K2Th3ZIlK9W2osGO0+b2HDipXhs/N7t8tum7/4naj1Z0DTw2RXkFaluIHxQAgEsUBN7t2nFYzjM33/7M + VM6K/rG58oRDpJORbDVbWlyqXh8/VZCbZzpvPlT70Qr5u5GnN7S2EF8oAAAXqZxVYW7Y+U7u1uOof4y+ + bed+9V7CcejERfXa+CnZlOdcW5/ah1bIJ0dLl65S20L8oQAAXEYeubLzu9xzrb1R270tJzPLdL/5RL2P + UMkkJIWQdn38VOORs2ofWrW1vlFtB/GJAgBwoW2BgVgboK2SiUJrx24bNtWr7YfjxLkO9dr4qbXrt6r9 + Z9WR05fVdhC/KAAAl5IBWRuorVq9epPajl1ki2M71jBUz61Rr48fzaueH1wnofWfFS1X7wQ/vdHaQvyi + AABcSgZkGZi1AdsK2c7VyfUAK1dvVNsNx9nWXvXa+JEUWh299m0jLVstlxQUqW0hvlEAAC5WHBiYrwUG + aG3gtmLrjn1qO3Y439GvthmO2trF6rXxI3m8U+s7K/rf+dyVZ0ggOigAAJermlNt26luFwKTtNZGpOQR + xkgP/WnpuqNeGz914Kg9m0bJ70s+tdHagD9QAAAeIMf9RjrBir57H6vXj5QdZ/7L2fXatfFTdnzSInY2 + HFavD/+gAAA8YueeI+pAHo4bDz5Vrx2pBfMXqu2FqqPvHZOdlqZeGz8lBz5pfRiOE81X6G9QAABeIQP2 + 8bPt6oAeqvbeB+q1IzWrtFxtL1Rr1m1Rr4ufi/RvoPX6PZOXla1eG/5CAQB4iAzcMoBrA3so5Ptj7bp2 + kNXkWpuvI4scOXQmdBu37FL7MRTX737IFsv4ZxQAgMfIAC4DuTbAv4qsIXDyGfsduw+q7b4O582HpzA3 + L7h6X+vLV7n18EtTM69WvSb8iQIA8CAZyGVA1wb6l3F6f305BEjOHtDafhn5NIN3/+Gzcu7/ug3b1GvB + vygAAI+SVfOh7gYnj/9F43vfqsq5pvfex+o9vEi+MigvKVOvg1eT9SBHTrao/apxcv8HeBcFAOBhsnHO + q7bflY/9Dx47H9VFX3I2/etWqje39pmSohL15xEa2RFw++6DrywCpRhzegtoeBcFAOBxsmWwDPJyiI6s + 8r828J652HXb7Dlw0lTMrlR/xmnyDnXx4hXmcFNL8GN+WejX1nM/+DVEbd0S9WdgTUlhsalvOGSa22+a + qwOPTXvfO+ZMS3fwYKaC3Dz1ZwBBAQAAgA9RAAAA4EMUAAAA+BAFAAAAPkQBAACAD1EAAADgQxQAAAD4 + EAUAAAA+RAEAAIAPUQAAAOBDFAAAAPgQBQAAAD5EAQAAgA9RAAAA4EMUAAAA+BAFAAAAPkQBAACAD1EA + AADgQxQAAAD4EAUAAAA+RAEAAIAPUQAAAOBDFAAAAPgQBQAAAD5EAQAAgA9RAAAA4EMUAAAA+BAFAAAA + PkQBAACAD1EAAADgQxQAAAD4EAUAAAA+RAEAAIAPUQAAAOBDFAAAAPgQBQAAAD5EAQAAgA9RAAAA4EMU + AAAA+BAFAAAAPkQBAACAD1EAAADgQxQAAAD4EAUAAAA+RAHgYsUzsk19+kLTmrnN3Mzca97KOugKNzL3 + mMsZW8y29AWmYEameu9OKSkqMZu2NZjjZ9rMhY5+c/na3bh0seu2OXnhqtm975ipnluj9kU0zJqRa/am + LzEdmdvNQOY+9e/BDv1Z+4J/5zsDf+8lgb977V6iobYiwzTVzzQ9p/LMW5cKzINWhGKgOd+0H8kz9auy + TdHMNLVv4T4UAC6UPSPNNKYvNZ9mnzHfZl9wtY+yTprt6XXq67DTzIwMs2f/CXPr4Zfmznvf+s6ZS9dN + aXGp2jdOyJmRbk5mrDVfZjerv3cnfZZ91hzIWB78/0C7NyeUF6Sb3sCkb94qRoQ+v1lk9q6PXRGH0FEA + uIwMem2Bd0LawOhmpzPWqa/HDrmZWaa5/aY6MfrJ9bsfmjkVVWof2SlvRkbwEyft9xxNVzJ3mJlRKAKq + yzLM055CdTKDdZcP5prsNL3P4Q4UAC5zLGOVOhh6wa70RepritTRU5fVCdGPrg48NgW5eWo/2UU+itd+ + v7HQlLFWvUe7FGTNMO9fZfJ3yqEtM9V+hztQALhIRVq++SoGH7na5ZPsM8F1C9prs2rB/IXqROhnDQea + 1L6yw5K0WervNlbk/4eqtEL1Xu1woj5Hnbhgj28GioJfr2h9j9ibNmGCOol6mWcLgBMZa9RB0Esa0her + r82q42fb1UnQz27c/yS4JkLrr0i1Z25Xf6+xdMqhTwHk4+lPenn377QjW/kUwK2mjB+vTqJe5tkC4G7m + AXUA9JJrWbvU12ZV372P1UnQ72pqnFl4+VHWKfX3Gkv3sw6p9xopWfGvTViw1+0LBWr/I/YmjRunTqJe + 5tkC4MPsk+oA6CV2DtZ5Wdnq5IdvzcrVG9U+i4Qs/tN+p7H2SdZp9X4jtX5RljphwV4fXHPuKxxEZvyY + Meok6mWeLQCexEEBIM90a6/NipzMLHXyw7dmxcr1ap9FIndGuvkm+7z6e42lj7OdKQDWUQBExftdFABu + lZKQoE6iXubZAuBO1n51APSSzsx69bVZJY++aROg382bO1/tr0i5sQiVr8a0e43U/Fl8BRAN/efy1f5H + 7CUOH65Ool7m2QLgiIcfAXxGdi7UXptVR062qBOgn/W89ZGZme7MyurLmVvU32ssHc9Yrd5rpGQR4MfX + WQTotAObWAToRhnTpqkTqNd5tgAon5FjPs8+pw6CXiC7Atq9NXBV5Vxz+/E36kToVzsanFkUJ+anlbjq + a4Avs86Z2WnO7XtwcMtMddKCPb7oLzLFuWwN7Ebx+ASA8GwBIPZmLFUHQreTSWNzujN71jcePqNOhH7U + 0ft2cHGk1k92OZu5Qf0dx8L+jOXqPdolNzPNvN1WoE5eiNyuNWwJ7FbjkpLUCdTrPF0AiLMZ69XB0K1k + 8pe927XXYgd55r2p+Yo6IfpJV/8jU15SpvaRnWT73c7MHervOpqaMzdG5TyA2QVp5r0uvgqwmxyqpPU3 + Yi9z+nQzetgwdQL1Os8XAEJO2vsgu0kdGN3kUdYxsyZ9rvoa7JSdlma2bN9j+u49VSfHeCZfgRxuajEF + udFbTCUT7770pcFH8LTfu5OeZDWZ7YG/f+2+nCIn2Mne9X94U5/MELoPuwvNpiVZaj/DHaZOnKhOnvEg + LgoAkZuWYdalzTWnM9cHd2i7klnvCnJYkZwUtzKtMnhqnHbvTsmfmWNWrNpgGg+dDh4JfPxcR9w6cLTZ + bNy625RH8RTAFxXOyAp+tSNfC8iRwNrfgx3k71sOlFqXXh3cj0C7l2iYXZgePMmu5UCuuXoiDyG6cjTX + nNmdY9bUZZmcdL1v4R5jExPVyTMexE0BAACAndKmTlUnznhBAQAAgCJeF/89QwEAAMAL0gPv/kcNHapO + nPGCAgAAgBekxPF3/89QAAAA8Jx4PPtfQwEAAMAg2fY3IQ73/ddQAAAAMMgPH/0/QwEAAEDAxLFj1Yky + XlEAAAB8b2qcHvjzKhQAAABfmzZxYtw/8qehAAAA+NbUCRPMaB9O/oICAADgS5NTU335zv8ZCgAAgK/I + Eb/jk5PVSdFPKAAAAL4hB/wkjxqlToh+QwEAAIh78q5/QkqKGaVMhH5FAQAAiFsy8U9JTTUJI0aok6Cf + UQAAAOKOTPyTxo0ziT7Z1tcKCgAAQFyQSV+e6R+blOTr1f2hogAAAHhS2pQpwR38JqakmOTRo/l+P0xD + kkaONAAAuJ2s3pfv8kcPG8Y7fBsM0f4hAACIbxQALpE0OtGkZxaY/JJqU1A23xWyc8vNxAlT1fuNhnHJ + KSY/r8hUVNaYyjnz40ZpWaVJm57uincwGSNSzZzELFOXnO+YBUl5pnT0DDN+WIJ6D9E0Pnm4KZuZaGrL + U8zC2WMRonklY0xBeqJJGB7bv9mUoSNNSeBvaX5Srvq3ZpeKxEyTNmKceg/xhAIgxqZOzTDr97aYpp4v + zOmb37rSvosPzKx5K83oYdFZTSuTftP5q2bg0dfmznvfxq2uW4/NqnXbTPKo0Wo/OCVx6HCzYWyleTf9 + sPk2+0LUfJXVbDqnbjVFo6er9+WkkqxEc+1EpvnuTpExbxXDok/7CsyRLVPNhEAhpfWzU7JGTjAtkzeY + L7LOqX9bTrmfdsCsHFNmRr8Rn183UADEUMX81eZk31fqpOtG249dN2OTnTsvW94Rb9i6R50s49nl7ntm + 2pRpap/YbfLwZNM/vUEd7KLlm+zzZue4GjMqCoPqqKFvmIbVk833d/UJDdZ8dD3flGYnqn1ut1Up5ear + 7Gb1bylauqfuMOOHR+f1RhMFQIyUzlmiTrJut+v0gEkc6cw7Vj9O/s90DbxnJqZOUPvFLinDRpm7aY3q + ABcL9ePmqfdpp92rJqkTGCL3ZX+hyZ3u7Nc6y5KL1L+dWBiYsdckD42vzYQoAGJgQuokV3/k/zoL1+5T + X1ck8nILze3H36iTo18cbGpR+8YuxyYuVwe2WJFPAvJHT1Hv1Q6FGQm883fYvUszzehhev9HauqIFPN5 + 1ln1bydWGsbXqvfqVRQAMbBsyzF1YvUKKV7GJKWor82q482d6qToN5npWWr/RGrK8OSYf4yqaZ2ySb1f + O3QczlAnLdhLFglq/R+pwxOWqH8zsfRZoCAZOzR+DhKiAIi2oUPNkY4P1InVS0oqF+uvz4JxyWPMwMOv + 1AnRb9Zu3Kn2UaTWpMxSB7RYk0VdsrJbu+dIpIweZr65zYK/aGhpTFN/B5F6nHFM/ZuJtUXJBer9ehEF + QJSNG5OqTqheY+fXALm5hepk6EdOfQ1wdMIydTBzg9xRk9V7joQ8sqZNVrDfg8s56u8gEqnDRqt/K24Q + T18DUABE2aRJ09UJ1WuWbz2hvj4r5Ll4bTL0o5Pnr6p9FKmzk9aog5kbzErMUO85ErPzktXJCvZ7ci1f + /R1EYvqIserfihtIMa3dsxdRAETZmMQx6oTqNQtW7VZfnxXZ2bnqZOhHjUeb1T6K1MEJi9XBzA2yR01U + 7zkSOdMT1MkK9rt7cab6O4jEmKEj1L8VN6hPrVHv2YsoAGJANtbRJlUvyS2co742K5JGjjI33v5MnRD9 + ZsnydWofRUq+t9QGs1h7mnnKJLwxTL3nSCQMe8N8dqNQnbBgr6Ydzmzs9NaM/erfTKxVJmSq9+tFFAAx + MH/FTnVS9YrDV56YxMCkrb02q/YeOqNOiH5y690vzaTx9r8bFrJyWSZbbUCLpaZJK9X7tcPpndPVCQv2 + Ks9JUvs/UtvHzVP/ZmLp/YzjwZ00tfv1IgqAGEhOSApMot59EkC2BdZeVySmTp5q+t/9Qp0Y/WLzjv1q + 39hly7gqdVCLlU+zzgSf9dbu1Q7TU0ear27xJICTOo/Yv37jGXk6xG1PAqxIKVXv1asoAGIkI7vIk5sB + rdl11rFDbOZW1/l2M6Azl3pM4gj7H4d7nmy9K8/dawNbtH2dfT54oIt2n3aSQ3/YDMgZj6/kOn4mgJwb + 4ZbNgE5PWq3eo5dRAMRQelahOdT+njrRus6Nb8zi9QccPxBodsU803vvqTpJxqv9x86b5NHROSlPPr48 + PnF5cBc+bZCLho8yT5q5SfYvHHsZOcmO9QD2unkm20xOic62uIWjp5lHMfwkQP5faRy/MC4PBKIAiDHZ + V3/u4s1m95nb5lRgklUn3xg62vWRWVV/2kyfEb0BW44BXr+lwbT1PFAnzHggix7lmf+ionK1D5xWFBhU + myevi+q6gHtpB0xD6oLgM97aPTlpfNJws3ftZPNOW446oeH1vr1TZLpPZJrFs8cGD1nS+tkpY4aNNFvG + VpmB6XujVrx+GChU5V2/E/tUuAUFgIvIu+vUcRPNhAlTXEHWKmj3GU3ysfjkCZPNlElT4oYUONprjZVx + gQl5xohxjpk+IsUkuWjhVNKIocH1AWkTRyFE8m4/2pP+y8hTI7J2RPtbs0s8bff7KhQAAAD4EAUAAAA+ + NMSpFd0AAMCdAnP/90MShg37g/YvAQBAfBo9bNh3QxJGjPhG+5cAACA+JQwf/vWQ5JEjn2j/EgAAxKfk + UaM+GJKSkHBd+5cAACA+Beb+q0NSEhP3aP8SAADEp7FJSTuHjB8zZrz2LwEAQHxKTU5OGTJmzJg/lscB + tP8AAADEF5nzhw4d+i+HSJJHjXpP+48AAEB8SR458mFw8peMTUzcqv1HAAAgvqQmJW0cnP6HDJmSkvKf + 2BEQAID4N3XcuD8fnP5/SPKoUQ+0/xAAAMSHMaNH3x+c9n/M+KSk6dp/DAAA4kNqcvLUwWn/p0kaOfKp + 9gMAAMDbkkeN+mhwuv95UpOSCrQfAgAA3jYhMTFncLrXE6gQHmk/CAAAvCl59OgfH/17WcYnJPwlTwQA + ABAfZE6fmJz8vwan+VdnbELCEe0iAADAW8YmJh4cnN5fn7Kysl8kjRr1vnYhAADgDbLT79ChQ//F4PQe + WlITE/9bwrBh32kXBAAA7iZz+Pjx4/9icFoPL6ljxvyeg4IAAPAWmbsnpqQMH5zOrSU1OXmGdnEAAOA+ + owImJCdnDE7jkSU1MbGQJwMAAHA3eec/NimpYHD6tifjkpKSE4YN+4PWIAAAiK3Rgck/NTl5wuC0bW8m + jx37m8QRI77QGgYAALGRNGLE5xPGjv3V4HTtTEaPHv1vUxISrmo3AAAAoitl9Og748aN+3eD07TzkQUG + ScOHf6XdDAAAcFbC8OHfyBq9wWk5upFPA8YmJjbxqCAAANExuNDv+NixY//N4HQcu0xPTf2P4xITT7BI + EAAAZ4wePvwPMvFPmjTpPwxOv+6JfCIQKARmJ48a9YDHBgEAiIzMpXJKb2py8qoJI0f+2eB06+5IhSLF + QEpCQqesTqQgAADg1WSuTAzMmYG588r45ORyV77bt5A/kqOGJyQm5oxLTq4dl5S0OSUxsXFcQsIRAAD8 + JjgHBubC4JyYnJwtc6TMlT9MmYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGE + EEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGE + EEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGE + EEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGE + EEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBBCCCGE + EEIIIYQQQgghhBBCCCGEEEIIIYQQQgghhBASHxky5P8DKc1/iQt/UAsAAAAASUVORK5CYII= + + + + + iVBORw0KGgoAAAANSUhEUgAAAA8AAAAPCAYAAAA71pVKAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + vgAADr4B6kKxwAAAAR9JREFUOE+Nkj1uwkAQRn0JcpSkDCJBLkKkeEXNBWjsg4WSDjrEGaBwkBDESmmS + Kgqbeasde1k5CsXn8czOm5n9SdJ81Oj4kt0cjSlEK9HpkJkfrPcL1sP8FjTmjiQHZJmNRXz3kC7K+8fb + C9iDW02KQdX+6dmW/eFGC+ioK014H4+dQkhjHrZugv6wR9dCu5FQv87s53xuq8nEgVh84gp75cAXXUm0 + 57P9Wi7tx3TqLD7xCF4DnxTWTgp8V1VTiPjbIA3hOuk6IDoqiMWPujpd3ZkmEVxfvWcOLBrb7fnP02ZU + 1oh1wHLacs/cG4mIItgwkf/Qb+6Zl8KLEWeji/+ofWF8tICv2AU4db7tpoCMIspFa1EN4C0+8V6bP0p+ + AY7pF0Fg9EWkAAAAAElFTkSuQmCC + + + + + AAABAAEAAAAAAAEAIACvPgAAFgAAAIlQTkcNChoKAAAADUlIRFIAAAEAAAABAAgGAAAAXHKoZgAAPnZJ + REFUeNrtvXmcXNdZ5/09595be/Wi1i5LsoVsq1urHdtxHBLiYIgJIQkhbxLIggNDhoSwBHgnwzDMDDMv + fCYMLwGGMG8y4ElIwJCQkIWQhRBnc4ITO7a2lixLlqy9W1JvtVfde877x6nbKrWq1d3V1d21nO/nU5+2 + S1W37nKe33nOc57zHLBYLBaLxWKxWCwWi8VisVgsFovFYrFYLBaLxWKxWCwWi8VisVgsFovFYrFYLG2B + sLfAYrmec+fONe1YmzZtsgJgsbSp0XtAL9APbAY2AEkgAUSAEpAHssB54AwwAUwBfquLgRUAizX66+kF + dgB3VV+7aww/BriAU/N5v/oqVoXgHHAAeKL6ehbItKIYWAGwWMM3uMAg8KPAg8A+YBUgF/EzPnClKgJf + AL5SFQPVKkJgBcDS7cbvAS8A3gr8BHDTEtlFAJwCPgX8DXCw+t6KioAVAEvXcPz4caampkgmkwRBQG9v + 7xDwS8BPAeuW8VTOVEXgQ8Bztf+w3EJgBcDSFQwPD+N5HoVCAc/zViWTybc5jvNvMWP9leIp4I+BTwCF + lRABKwCWjufgwYM4jsPk5CSpVGqflPJ30+n0jzuO47TA6eWAjwD/HeMZLKsIyBa4ARbLknH48GEcx2Fw + cFAkk8nX+b7/t57nvbpFjB/MzMK7gL8CXhi+2cw8hBthPQBLxxL2/P39/c7o6OjbfN9/n+d5a/r7+5Gy + Jfu+w8B7gH8O31hqT8B6AJaONX4pJfF43B0dHf1F3/f/CFiTSCRa1fgBdgIfBF4TvrHUnoAVAEvHMTw8 + jOM4DA0NMTk5+Xbf939Pa93nui7RaLTVT/8W4P3AjyyHCNghgKWjOHz4MJ7nceXKFZLJ5GsrlcqHtNZr + AFKpFOl0um0uBfg54LvhG0sxHLACYGkJ3vGOdzSnQQvBO9/5ThzHubNSqfy1UmoHgJSSVatW4XleO92W + rwA/i1ljsCQC4NqmZ2kxY5eYyHgcs9gmjll4k6i+72By7ouYufM8Js++CBTvv//+UjqdXjU5OflfQ+MH + 8DwP12275v7DwG8CvwWUzp0713QRsAJgWUmj9zCr7LZVX1uqr62YlXe91c+Ei28cjNeqMGm0ASbffgK4 + AFz46le/ejaVSt20YcOGV1zzQ56HEG3n8Arg54HHgE8uxQ9YAbAst9EPVI39BZiVdi+oGnsKaDRCtxEY + 0lqzbt2668b5Qoh2c/1r6QF+HfhX4FyzvQArAJblMPo0Zkntg8ADwK2Ynr+pyTie57F7925SqRRa6+n3 + pZTt6P7Xci/wEPD7gG7mga0AWJbK8CVwG2Z57Y9hevvVS/X7WmvWr1/P5s2brzF+AMdxWnnufz5I4G2Y + NQPHmukFWAGwNNvwXUxv/zPA64CbWYZ8E9d1ue2224hGo3UFoA3H/zO5FXgj8N+aeVCbCGRplvG7mFz2 + 9wOfwUSvty1HG9Nas2bNGjZv3ly/kUvZCQIggDdggqRNSw6yHoBlsYYPpnd6J/AmTOms5bUMIdi8eTOx + WOy63j/89w7hNuClwMeadUDrAVgWY/y9wC9gpqjesxLGr7UmFovN2vt3mABEMPGUpuUzWw/A0ojhC+DF + GDf/FZhCmc2iyNXkngvAJGbNfL76Cqq/FwPiWuuBdevW3drb27u+Xu8PtHsAcCb3YaZNjzcjGGgFwLJQ + 409ipqTeW22IiyWDqaL7FKZO3ing+ep7Ga5W3A2TfjRXk4Kcc+fOyYceeui3Pc9772w/MJswtCnrgL3A + 8WYczAqAZSHGfzPwH4C3YFJ0G+UK8CTwdUzF3GHgMqb3nw8KqNx99938wR/8QezkyZO3BEFAlwhAHDOl + 2pTMQCsAlvka/8uA/wfj+jdCATgEfKn6OoDZPOM6PvShD83rgL/8y7/M2bNnezHTjt0iAAC7MJmTWSsA + lqU2fgG8HvgDjAewUHLANzElr74KjDRq8DPxfR8hRL9Sqv9Gn1NKddrjuRkzFLMCYFlS43cxy1F/j4WX + zc4D/4IpePkVTDBv0UZfixACKeVQEAQ9N/pcEARorTtpNmA1Zk3FiBUAy1IZfwxTM/8/An0LOITGjO// + BPgsM9z8Zhh+rQBgph5jcwmAUorWqQO6aOLAekzsxAqApenGH8GsQPttzDr8+XIBeBj435hI/pIYfkh1 + bJ9gjnwWpRRBEHSSADiYIcCisQJgmWn8DvAOTBGKhRj/N4D/gonsq6U0/FoB0FpH5vqcUopKpUIkEqFD + cBf4bKwAWOZl/GAW8fwXTJR5PuS5urHF6eUw/FoBAJz5RPkrlUonxQEkxkuzAmBpqvG/umrIA/P8+gXM + 6rSPVIVg2YwfpmMAgRBizqm+crlMEATtXhcgJABKVgAszTT+FwDvw1TXmQ8nMKnAn659c7mMPxQAIURl + PtN8QRBQKpU6SQDyVgAszWIt8LvMf6PMg8CvYeb1l93wZ4hADhNzmDPhv1QqkUgkOmEY4GPSpBeNXQ3Y + pcyI+L8Hs8psPjyJWQG44sZf5STz7A3L5TKlUokOII8ZflkBsCzK+MFU7XnnPNvCEeBXgcdbwfiVUiil + nmGWlOKZaK0pFAqdkBo8AoxbAbAsltsxc/298/js85jcgMdawfjBlAFzHCcrhJiY73dKpRLlcrndn9sp + TIq1FQDLwqjp/T3MttS75vG1K5jlv19sFeMPBSCRSEwA35/vd7TW5HK5dl8fcIAmBQGtAHQvLwfePI/P + VTB1/v6+lYwfIB6PMzk5WZJSPr2QwF6pVKJQKLTrc8thllA3BSsAXURN778a487PZ77/H4APYKaeWsb4 + Q0OWUiKlfJwFjolzuVy7DgXOYTyAppQGtwLQnbwBuH8en9uPmR6caDXjB9ixYwdSShzHOSSEOLiQ7wZB + QCaT4UaFRFqUr1PdLLQZWAHoEmp6/42Ykl5z7ZWVxWQFDrfydUUiETKZzISU8vML/W65XCabzbZTPCAP + fAGTB2AFwNIQPwHsm8fnPo1Zzgu0Xu8fopQiHo8jpfyiEOLsgi0qnyebzbbL1OAh4NvNPKAVgC6gpvdf + i9liaq7e/3nMev58Kxs/wNDQEK7r0tPTMyyl/Gwjx2gTEQiAv6ZaBKRZW4NZAegufhxTUPJGKOAvMRl/ + bYHWmsnJSd9xnI8KIUYb+X4ulyOTybTycOAAJiDbVKwAdA89mL3l5lpGegTT02ho7d4/ZNeuXTiOQzwe + f0JK+YlGRSSXyzE1NdWKgcEyRpTPAE3dHtwKQIdT4/7vYe7eXwOPAM+1i/HXGnChUPBd1/0zKeXRRo9T + KBSYmJhotTUD/1J9Lk3HCkD38CBzz/s/A3y8HS9u9+7deJ7H+Pj4USnlnwghGp7kL5fLTE5OrvgMgdYa + 3/fHfN//00qlMgbN7f2tAHQ4Nb3/OuBH5/GVTwLPQnv1/iFBENDf3080Gv1rKeXfLvZYmUyG8fFxisXi + sgcIK5UKmUxGZzKZv8zn818tFotL8jtWALqDFwJDc3zmEvC5dr7IXbt2hfX/Mq7r/m41Q3BRlMtlJiYm + GB8fp1AoLKlHoLUODT8Uni8CfxgEQRma3/uDLQjSDQjgh5i7iux3gcPQnr1/SDQaDYcCz0UikX/v+/7D + SqlbFmuY4SpCz/OIRqNEo1Fc1110cRGtNUqp6VoFYekyKeV+z/N+u1wuj955551Ldr+sB9D59GLKfd2I + AJNhlm33i92xYwelUolkMkmhUPia4zi/JoS42Ixja60pl8tkMhnGxsYYHx8nk8lQLBbxfR+l1KxDhWoF + 4+kS5aVSiVwux+TkJGNjY0xOTlIoFELjP+Z53q+WSqWnenp6ePbZZ5fsflkPoEOpGf9vwaz7vxHnqanw + 0+4MDQ1x6NAhkskkx48f/+wtt9wSD4Lg/UqpDc36DaUUpVKJUqkU1iYM1yXgOM70e6Hxh+IQCsBsYiGl + PO553i/n8/mv9/X1US6XGRoaWrJ7ZQWg87mTuaP/B6jOMbez+1/Lrl27OHDgANu3b+fs2bN/t2HDhjzw + x0qpbc3+rdre3fcbT9OXUj7luu6vF4vFr/X29qKUWlLjBzsE6HQkZu5/rtTfJ+kA938me/bsQWvN5s2b + KRaLn3Nd9+1Sysda8Vwdx/l8JBL52VKp9LV0Ok0QBAwODi5LA7F0Lmnmjv7naKO034Wye/dutNb09vZS + Lpe/4XnezziO8xdCiJaoCCKEmHQc5488z/u5SqVycGBgAK01O3fuXJbftwLQ2aSAzXN8ZhRT5rtj3P+Z + 7Nq1C601a9euRWt9OhaL/arjOO+SUu5fQcPXUsrHPM97KJVK/ZbWenT//v3L1vOH2BhAZ7OeuXf2PQmM + dfqNGBwc5OhRkyEcBEG+WCx+OJlMfj0Igl8MguCntdabl+tcpJTPSik/4nnew4VC4UK4aelDDz207PfF + egAdSM0MwFbm3kTyeZpUYLLV2bFjB3v27EEIQV9fH1rrk6tXr/4tz/Ne5TjO+6SUzwohlmQlkBCiIqU8 + 6Lrub0cikVfu3bv395RSF1avXo3jOOzevXtF7on1ADqbLfMQgNOYwp9dQzi+PnToEFNTU0prfeD2228/ + ePz48Q8ppX5EKfVKrfXdwBqtdcM2IoQoCyEuCiEek1J+WUr5laeeeursvn37OHr0KFJKbr755hW9F1YA + Opu55r0rGA+gK9m1y1REP3z4MKdOndJa6+eCIPhgIpH4aKVSuVlrfa9Sahdwt9Z6o1IqJYRIYWZVHIwH + rar3sQLkhBBTQoiTWuunHMcZllJ+O5lMnpmYmCgJIbj33nuXfZxvBaA7kcy9xXcRuAidGwCcD6FHcPTo + UXp6esjlcnml1DAwXO2t+8vlcsxxnNVSyu1a6z4gqbX2hBBFIUQGGA+C4JSUciwej+eGh4entm7dOp0w + dMcdd3DixAm2b9/eUtfeEZuldzvnzp275v+feOIJPvjBD3qbNm36EKYA6GyM+77/Ez/4gz/42IMPPrjg + 312KxSmtxJEjRxBCEAQBlUoFrTVSmrBZmMVXuxZAKYWUkkgkguu6aK257bbbWvoarQfQRoY9DyQQeelL + XyqFEMlHH320Vyk1nZYavsJ0Vc/zxNDQ0OYHHnhge6lU8jFubIBxa9Us/12u/p33+bWrULSKm76UWA+g + fYzdBaI1r15Mkc+1wJqav6uAmFIqMTIyckelUlnrum64jx6u6yKlDHPXVSwWm5BSlqsG7gOl6qtY89+1 + 741hlg6P1vwdBSZnfNbvRFGwAmBZakP3MGP3VcAtwHbgphojDw09XSMGMepM6c5nqeoiCl2oGSKRmSEI + l4CzwHGu5hpkmWPGwQqDFYBuMvhk1ZA3Vg391pq/WzC9fBITcW5HAkyq8SRmuvHZqiCEf89XhSNnBcEK + QKcbvMBk5W3FrNDbWTX27Vzt0WNdcpuKXPUYjldfhzG7/D6P2YpMW0GwAtDuRt+Dcd/vwKzKuwvTu69i + 7hV63UYFM0x4FrP77RPAU5hhxJQVAysA7WD0SYw7v7fG4Acx6/Gj9q4tiBJwBbNPQSgI+zHDhpwVAysA + rWT0twEvB16Gqb+/BojbO9ZUClxdufg1TAWjY1YMrACshNEnMGP3lwEPAHdjSm/b+7k8aMweed8DvlIV + hOPUWdRkxcAKQLMMPwZsw1TY/RHgHkyuvV1RubIo4AKmqvE/A1/H7GxUtELQIgLQQEYbK/Hw6pynwEzH + PYDZWONFmDF+u07LdToBJkbwHeDLGO/gNDNmFJarPT3xxBOL+v5dd9215Oe4JAJwA4N3MGPjOCYKHqn+ + t8CM8cqYDLJC9VVZDlGoc74RYBfwOuA1mKq6NmrfXlQwW519BvgUcKjavpakDc1h7F5Nu3dr2r2uafeV + mnYfLJcgNE0AZjH6FCZzbWfVoLZipsU2YZJcIlVRENWLrmDmhy9gpn9OY6LABzHKPtFMIahzzr3Ai4H/ + C9Pjb7R21BGcx3gEnwAewyQmNaUNzWL4fdW2sxszC7Sl2u43YPI9wuXEutruy9VzOldt989XBeswJvCZ + XSoxWLQA1DGidPWi7wdeiilKuYa5d6aZjSIwjon4fhuzU+rTmCmihsSgzjlvBl4BvAGzjVaPtZmOZAp4 + HLMB6peolkJfaPuZxegHgH3ADwP3YWaG+mk8uSuHSZQaBr4BPIrpDDPNFIKGBaCOEd0E/BjGbX5B1eiX + gkmMOn4O494do7o6ba6HOOOcBcYzeT3w2qpQWTe/O6hUDevTwN9jelo9nzY0w/hl1dBfA/wExsvtXaJz + voSp3vwpzC5OZ5shBAsWgDqGfwvw0xi3eecyGpHGRHs/A3wUkyRS9yHWOedbgbcAbwZ+wNpDV3MC+Gvg + Y1R3Rq7XhmYYvsAke721avzbWL4ZtQpGsD4BPIJZaNWwECzopGcY0gDGZX5H9Was5JTiSeAjwIe5cYmr + LcCbgJ9l7nr5lu5iuNqG/hYTewLMasmLF6/ZWnArpsjKz2I6v5VCYzq9D2GGNFcaEYF5GW0d1/kHgf+A + yX6LtMgD1BgX6X3AZ7k24rse+Cng5zDjNDt3b6mHwsSXHgY+SbVc2sWLF9FaR4BXA+/FDHFbJYemjMmK + /H3gW9R4wfMRgjkvYobx9wC/APwaZszfikwCfwm8H5MZ9mrg32ASd+wY3zIfKpjEor8APnvu3LmElPI9 + wM+zdGP8xXIW+GPgf1OzeGouERALMP5NwO9ixj2t0uvPhga+ickpuI/uWWZraS5F4NuTk5NuoVB4ida6 + 1TNny5h42H/GTCnOKQJinsY/CPwh8ErbJizdhlKKQqFALpcjCIJ2OOV/An4TM214QxEQ8zD+ncCfY+b0 + LZaupVKpkMvlKBaLiymltlx8A3gXZsZgVhEQcxj/IPC/MAtgLJauR2s97Q34vt/qp/t14J3cwBO4UTR8 + I/D/WuO3WK4ihCCRSNDf308ikZhX4dUV5IeqNjxrSvs1AlDT+6eA3wEebOWrs1hWCtd16enpobe3F9dt + 6e01HqzacgquT2OWdYwfzHTHQ7RgvQCtNUEQtMMYzNLhCCGIx+P09/cTi7XsRJOo2vLPh2/UikC9IcA9 + mHn+lruicJ81rXWru16WLsJ1XXp7e0mlUq3aLmNVm75n5j9IuKb378FkOt3calcQBAG5XA4hRKu7XJYu + REpJKpWit7cXx2nJejE3V227B656ATM9gFdjVvS1FOVymampKVzXJRq1xXUtrUk4JOjr6yMSaclcuR+r + 2vjVc67p/ddiVhi1zHy/1ppisUg2myWRSJBMJlvl1CyWGxIEAZlMphVzBr6BWbk7Ctd6AK8C7m2Vs1RK + kc1mmZycJBqNkkgkbKuytA2O47RqXODeqq1TKwBpTGGMlvBblFJkMhmy2SyRSKSVgysWy6wIIUgmk6TT + aaRsmQWokaqtp2sF4E5MKayWMP6pqSny+TyO47TazbNYOkEEXli1+WkBeAVmv7oVJQgCpqamKBQKCCFI + p9N4nl3Ba2l/EokEPT09rTJDsKpq80hMZZ/7Wsn4wxvWwskVFsuCicfjrSQC9wEDLqY+3u0rbfyTk5OU + SiUAIpEIyWTSjvstHUcsFkMIwdTU1EovJroduFVisoNWzP33ff8a4w8TKlo0mcJiWTTRaLQV1hCsAu6R + VSVYkeh/6PaHxg/GTWrRJAqLpWlEIpGVHg5EgNslZgiw7IRTfbXG77puOyyxtFiaQjQaXekp7lslplT2 + sqK1JpfLTQf84Op0ic3zt3QTiURiJUVgi2QFqpzm83lyudw170WjUeLxuG0Rlq4jmUyuVKZrr6SaEbRc + hLn9tfnRUkrr+lu6FiEEqVRqJaa90xJYtuV15XKZTCaDUuqa96PRqA38WboaKSU9PT3LbQdRidmPfMnx + fZ9MJnPd3KeUkng8bnt/S9fjOA49PT3LGQcrSOrsPd5swqBfuVy+7t9s72+xXMXzvOUMCmYlMLHUv1Is + Fq+J+IfY3t9iuZ5YLLZcQcEJyY130100vu9fF/QLiUQitve3WGYQTokvg208L5mxJ3oz0VqTzWbr5jwL + Iabzojv0KV77ar0Cy6188+rcv+7CcRxSqdRSLyF+1gWOYjZBbPocRKFQoFgs1v0313U7q/cPG6oGggr4 + PvgVUApcFxyv+tcxn9Gamp2crcELYTQyCMx9C++hlOB6V++hqN67LigLH+bGzMyZaRJF4KiL2QZ5jBvs + HtIIvu+Ty+VmrYcWjUY7Y8GPkKACyE7BhdPo547C2Ij5/9wUulJBJFKQTEO6DzbdjLjlduhfA9G4EYFu + 3eMg9IxKBRi/hD75DJw7BZkJyGXQ+SzC8yDZA6keWLUOsW0HbNhi7qd0QKuOvkXJZJJyuUylUmn2oceA + 77rACWC4mQJwI9cfTPCv7av7CmEa37mT6O9/C/3Mfhg9D/lstVFW3VYR2nfVyL0IuqcfsXk77HkhYtdd + pnGrbvIIBEgB2Sn0oSfgwOPoM8dhahwq5aufEbXaqEFIdCIFazcibt+DuPMlsHGLEeEOFVHHcUgmk0xO + Tja7uOgwcMIFxoFvAw8068ilUmlW1x/MVEdbV/oRAi6PoL/7KPp7X4NLF0wDnB6zOte192mCAMYuoa+M + wPCT6Ft3IX7wQcSOfRCJdr43IASUS+ijT6O/9UV49hCUi8aIhTC9+mz3DozAnnwGfeoY+vuPIe5+GeKe + +2H1uo69d7FYjGKxeEObaoBvA+NhWfAXAZ8FVi/2qEopJiYmrlnlN5Oenp42LfEtAA1Hn0b941/D6eOm + txeNBmq06fkTScQ9L0f86Ouhd1XnurVCwuQY+st/j/7uVyGfM55AowHS8N5v2Y581Zthx76rz6jDKJVK + TExMXJdF2yCXMfsDfMf5jd/4DTBewD00oTJQoVAgn8/P+u9tW/BDCAgqptf/1P+BC6ebEKGufr9SgTPH + YfQcYtNWEyvoOOMXJkbyyb9EP/F14+pLyaJmR8J7P34ZfXwY4knEhs0m0NphOI5DEATNigV8BfhzoBJ2 + XTng45jIYMMEQUA+n7/hWMVxnPYM/qkA/diX0Z96GMZHq423icahNfrg46i/+QCcf34RXkUrGr+E88+j + /uYD6IOPXx0uNQspYXwU/amH0Y992QRlO4xwW/Im2E6xaus5uHZjkC8A31zUkYvFORUqEom0X5lvIdAH + v4v+4sehkJ3TOB0pibguMc8jHvGIei6u48yd8yAknDyC/txHYfJKZ8x/CwGTV8w1nTwy570TQuA6DlHP + JR7xiHkeEdfFmavNCAmFLPqLH0cf/G5H5g54nteMFYPfrNo6AO6mTZvCzUHHgA9i4gGphR5VKTVnkEII + 0X7BPyHh+WPoz30MMuOzNmABRDyXeCRC1HVxHDnt3Jppf03FDyhWKhTLFfzZxnJCog8/CV/6BOK1D4EX + pX3HtNWA35c+Ya7pBsbvSkmsavCea8Sy9v4FgaLk+xTKZcoVv/4dERIy4+jPfQzRtxq23tZx8ZRYLEah + UGg0FpCt2vgYwF133XXd5qBfBP6hkSPPp/eXUraXAAgzR62/+hm4cGbWBuw6Dn3JBAPpFKlYFM91kEKY + RiwEUgicagPvSyYY6EmRjEZm9wiUMrGG4SerQbI2RQr08JPo7z5qEqLq3mJBMhphoCdFXzJBLOLhSHnd + /fNch1QsykDafM6dzRUWEi6cMc+sVOg4T8DzvMVMof9D1cavPiKATZs2hf+fA/4QOLaQo4abeM41T9l2 + 438h0M/sN4Y4S0OKuC6rUgmSsShyno3NqwpGTzxW/ztCQCGP/taXIDPZno1YCMhMmmso5OtegxSCnniM + vmQCb57tQgpBMhZlVSpBZLZls6IqPM/s7zgBCHcgbiCF/ljVtnNgev9pAZjBAeB/hB+cD+Vyue5S35m4 + rts+uf9CQC5rGnA+V7chea5Df/IGDXGOB5mOx0jHY/XbqJRwYhh96Hu05zoCYc79xHDdgKkQ1Fz/wq8v + 4rr0JxN4rlP/2eVz5tnlsh3pBSzQk85VbfrAdc0s/I8aLwDgY8D/B8xroFEqleaVpdRuvT9nn4NTz8za + e/XG4/Ub4AJIxaIkZlsTUS7Bgcfbz5WtDp048Li5hjokIhFSscVlg3quQ288PrsXdeoZ8ww7TACklAsJ + BqqqLX8sfCPs/a8RgBkiUAT+O/CpuY4eBMENk36uPg/RXgKgNfrEYZN5VqcBxaMRopHFxzOEEKRisfpR + biHQZ07AlVHaywsQcGXUnHude+dISapJK0GjEY94NFJfAPJZ8ww7MENwAWtpPlW15eJM479OAGZwGfh3 + wD/d6OjlcnleWxy1lQCELuTx4bqNR0ppgnhN+jnPdYhHZmnEUxPok0fbzv71yaMwNVFfPCORRXtONT9F + MjrL1LLW5hnOMoRrZxzHmc9q2n+q2vDl2T5w3V2bMRQ4CfwKMyKHV++vnlfv33YCAJCdhJGzdRtOxHHm + HbSaL7HILPERv2xWyAVtlNwSBOac/XLddhCLNLfmnec4RJxZYgEjZ82z7DCEEESj0Rt5UV+s2u7J8I2Z + vX9dAagjAieAdwF/B1zTCpVS8wr+hYrVVgHA7FTNyrQZAuA2/1o8x5kl2UVAdsKskW8LN0CYc81O1D1f + R8qmi6cQgshsHkWlbJ5lByYGzZJUF1Rt9V1V253V+GcVgDoicBL4JeCPqZkdKJfL805ICOd02wWdnTQF + KergOM3PZBTVXIG6ZKeMUbWJ/RsBmKp/76RcknYw6zPxffMsOxAp5cxhQK5qo7/EHD3/nAJQRwSuAL+D + cSuOhQIw3zXK7VX6S0AhB4F/Xc9hElPkUvziLNFs0PnqubQLgW/Ouc7lyJoMv6Yag6gjLEKY+1bI0Ykl + 2WZk1h6r2ubvVG11TuOfUwDqiEABeFgI8cYgCD5ZqVT8hZxsW+F61fnr6wVOL1FUWddLcNWA57XX4iAh + zTnreV5jM+5d3Weir5YU61AikYjvOM7fa63fCDxMzT4fcxk/wLyiMaEIVNcMMDU19bTv+3/h+/6PMs+t + xdprCKBNlR7XNfPY4tqGppYgv1wDStU3DpHsaa9G7HqIZE9dU1fKSECzW4LS6noR0JhnmOqhU6steZ43 + NTAw8P5isfj01NTUvA0/ZEHdyqZNm3jrW99KoVDA9/2dLGBfwbbyAHTV6Jz6+ljxmy8AgVIEdeMpGlJp + 05DbYT5b66rRpesa3ezXuThmfSaOa55l5xZaSjuOsyOZTKKUWpDxL1gAAD7wgQ+wceNGRyl160Jc4fYa + AmhI90Kqt24jLvl+0xtxqTLLMYWEVevazgNg1bq6w5ZAKUqV5sYzAmVWCtZ9jqle8yw7VwE8YAiuG64v + jQAopRgbG+sVQuzt1DuK1pDsMdV767SbIDDLepuF0ppCvelUrSGehG072i8VeNsOc+51OolCuYxqojdT + rFQI6uVJaMwzTPZ0eq3F7UBDNfYWLACVSoVyuZzQWm/o5DuKF4HtO83f69sVuWKpaV5AoVymXK8H0xrW + bEBsvLm9GrDW5pzXbKh73uXquv5mEChFrliq37/f4Bl2oACkGvliQ6FlIcQtWuuehbWJNlNgrRC37IBV + a+sWlSj7AZlCcdHXVfZ9MoVSffsWAnHbbhPEajMBINVjzr2O56I1ZAql+qK3wDaVKRQp+0Hd58eqteYZ + dvjeAcBaoKEOecECUB3L37ZQxWk/AdAwsA5x10uuL/NdJVcqkymWGr62ih8wkSvg13VfNQysRbzgJdeX + ym4HpGPOfWBtXfHyA3PtFb+xFGetNZliiVxpFk9COObZDXRuufAa4sCmRr64IAF45plnUEqhlFqFCT4s + 6IG1nQhIB3H3y8zmE3Xc/bAHmswXFjwcKFYqjOVys/eCQiDu+iHYdEt79mBawaZbzDXMEr8o+z5judyC + 4ymBUkzmC7N7YErBxi3m2bWjeC6cKLAGrk7VL4kACCFCAUgs1JiVatNGvGYD4sWvmHXTDq012WKJK5kc + udKN4wJaa8p+wEQuz1g2N3vvpxTctA1x7w+3dwOWjrmGm7bNWhKs4geMZXNM5PKU/eCGnUSgFLmSudfZ + 2TwvrSESNc9szYZucP/BdMZrG/nigpZlKaXYs2ePPHjw4II3EFHKJGq0427A4p774eJpU2FmlgZa9n0q + OR9XOkRc19QFlAKBQGlFEGjKgU/FD27sLWgF/asRr3pz+zfgUEBf9Wb0Ix+Aict1pwaVMiJaKFfwXIeI + 4+I4JuVao1HKFFQt+z6+Cm7s0UuJeNEPm2fWXTS0qc+CBEBrzenTp6NCiPWNCkD7NWINsTjiFW8wG1Ac + /O6sablaQyUIqAQBlELPt1rzf74GE0siHnwjYujOzhi7am2u5cE3oj/9YSjmZr1/gVIEZUWRiskUFGaX + n3nfBq0Qu+4xzyoW77ZNV3sBhxkrdudiQUMArTVBELg0MOdY/W7bNmJ6BxCvfTti9z3TG3nM52t6Icaf + 6kW88k2IF97fWctXhUC88H7EK99kEnPm4dWEpdTnZcPVjUbE7nsQr3079A50447L0aoALIgFC4BSygES + XSUAoYGuuwnxpneZ8aUXmXVcu2BxUQrW3oR4wy8ifuhV5tid1IC1Bi+C+KFXId7wi7D2JnPNzbhGpcyx + X/wKxJveBetu6pZx/0xiNDCrt+AhgNbaqf7YggXA99toSetsItC7CvGan4UNW8zuthdON7ZBqHEPzH52 + Q3cgXv4auPn2q+93GtqszBN3vhixajX6q59BDz9lluo2ssdieM833Wx2V77n/qrb35XGDw16AAuuzaS1 + FjSYQBQEQdsGAq9pyLE44iU/hhi8w2zg8eQ3YeySqT4TjvvhaqOuNehwX7x4Em6+zfRcO/ZBLNEdjVdr + uHkH4me2wNGn0Y99CU4dM0Iwc8/A6+6fri6PjsCqNYgXvKS6Nfj6eQ/LOpiGbHJBAiCEQEoZAKVGfsz3 + /fYXgNoGuWYj4sfehLj7Zejnjpg6/iefMdVwAt9UxtHKrCp0PfNauxGxfSfiB3bClh+AZLra63dRz6WV + EdE77jPZgqdPoE8cRh8/DKPnzX3zK9WCLNX1/I5Z1ituuR1+YAixbdAYvnTM8brb+AHKzLOM/6IEQAgR + UFN0YCEEQYDv+/OpZto+DVkIY9TrboK7XorITkFmAp2dulrKK5E0i4tSvdDTB/GU2fIrHP93I+FQJ5GC + wX2I2/ciCllTBTk7CbkpU83X9Yzhp3rMtumpHrNfYmj03evyz6S45AIAhB5AvpEzVEp1lgBc05gD00v1 + DUDf6qtTgOYDNX+qDV91fY91rRCAEYNEGiE2V/+x5v5dc+86b/vvJlBigVOACxYAIQSRSKSstR5r9Cwr + TVxG27INerrBWuy9WzZyjQjAglOBz58/X9Fan1+MALRlWrDF0tpcpgHpXHAeQCwWQ0qZazSQ5/t+53sB + FsvyEgCXGvniggRgcHAwnAnI0EDAARa2m5DFYpkXpVAAFloWrNGCIGdocCYAFrahiMVimZcAXGzkiwsW + gGo68DDQ8HYrvu/Pe0sxi8UyJxPA2WURANd1cV13UkrZ8EyA1ppisdieqwMtltbjVFUEll4AHMchGo1m + gKOLOeNyudzei4MsltbhWWr27FxSAZBSMj4+XgAOL+aMgyCgWCzaR2exLJ5jQEMr7RqKAUQiERzHOSKE + WJQFF4tF6wVYLItjCni60S8vWAAGBwdDIfgeDc49hlQqFTslaLEsjnNUh+PLsjMQgOd5RKPRy1LKo4s9 + +0KhYKcELZbGeRqTBdgQDQmA4zhcuXJlCvj2Ys/eegEWS8No4Hs0uDy/YQHQWpNMJpFSfksIMbWoK9Ca + fD5vvQCLZeFcAr61mAM0JACDg4NIKXEc52khxLOLvYpyuUyhUMBisSyI/cAz0Nj4v2EBABMHuO+++y4L + If6lGVeSz+fbqmZgtThK+1c3srQzj2JmARqmYQHQWvONb3wDx3G+KoTILPZKfN8nn8/T6oQGn8vlmJqa + mj5nKwSWZeYS8NVFt+fFfPnAgQM4jtNfKpU+rZR66WJPRkpJX18f0Wi0ZY1/cnKS73//+zz77LMUCgVS + qRS33347O3fupL+/H2jDjVAt7cingbcAuUbdf2igJFgt0WiUycnJ8Ugk8mml1EsWKyhKKXK5HJ7nIaWk + lRBCMDU1xRe+8AWOHDky/f6VK1c4c+YMhw8f5t5772XHjh1Eo1ErAktw/0Mvqy03mm0u5aoA5BZ7oEVZ + WRAERKNRpJT/JIR4vhlXViqVWnIooLXmwIEDHD169JrxfyhU58+f5x//8R/57Gc/y5kzZzqj+nGLGD7A + 1NQUx48f59ixY1y6dAmlVDff32dogvsPi/QAhoaGGB4eJplMnhgbG/tCEATvbMZJ5fN5IpFIyxQPFUJQ + KBQ4ceIESqm63okQgkqlwqFDhzhz5gx33nkn+/bto6+vb1pALAs3/LGxMQ4ePMiRI0cYHx9Ha00ikWDX + rl286EUvIplMduO9/QzV5b+Lcf8XLQBg3PaJiQnfcZyPKaVer7Ves9hjBkFAJpOhr68Px2mN7bGVUhSL + xTl7nTBO8PWvf52jR4+yb98+hoaG6OnpsUKwAMOfmppieHiYp556ipGRkWvuW6lU4rHHHqNSqfDAAw/g + um433aJTwMdpUunURd+5Xbt2cejQITzPeyIIgi8EQfC2ZpxYuVwml8uRTqdX3NXTWuO6Lj09PZw7d25e + IqC15sKFC4yOjnLgwAH27dvH4OAg6XTaCsENDD+Xy3Hs2DGefPJJzp8/TxAEdadblVIcOHCAoaEhtm7d + 2k338x+AYVh8798UAQCTzuv7fllK+RGl1Ku11n3NOG4+n8fzPOLx+Irf9Wg0yo4dOzhx4gSVSmVeoiSE + QCnFuXPnuHjx4rQQ3HrrrfT09EwLRbcbvtaa8fFxjh07xqFDh7hw4cL0PZ7tPgshyOfznD17lptvvrlb + 7uM54G9ooPz3kgpALBYjCAJc1/22UurzQRC8uRnH1VqTyWSQUq741KDWmqGhIcbGxvjXf/1XyuXyvD2T + UAjOnDnD+fPnWbNmDbfffjs7duxg7dq1eJ7XVZHt0LArlQqXL1/myJEjHDlyhMuXL+P7PlLKed/bLksh + /3sWsfS37rNo1oG+//3vI6VESnlfpVL5pNZ6fbOO7Xkevb29eJ634g23XC5z+PBhHn/8cS5evNhQtD/8 + TjqdZtu2bQwNDbF582bi8ThSyo4Ug9DolVJks1nOnDnDsWPHOHnyJJOTkwu+j1protEor3vd6xgcHOwG + ITgO/CRwCJrj/jdVAI4cOYJSilQq5YyNjf2PIAje08yrj0QiLRMUFEIwNjbGE088wf79+8lmsw3FKUJD + j8VirFu3jm3btnHLLbewbt26a4Y97SoGodFrrSkUCoyOjnL8+HGOHz/O5cuXKZVKDadTa60ZHBzkNa95 + DfF4vNO9JwX8DvD74RstJwAABw8eDJV8R6VS+YxS6rZmHj8ej9PT09MSSUJCCIIg4Pnnn+c73/kOzz33 + HL7vNxywDBtwIpFg7dq102KwevVqYrEYjuNMf6ZVG3t47eG9yefzjIyMcPr0aU6fPs3FixcXnTodBmRv + u+02HnjgAQYGBrph6PQE8FPA6WYaf9MFAIwncPLkSTZu3PjuIAj+SGvdVL89mUy2xMxAbaMvFAocOnSI + J598kpGRkUUlqYRegZSSeDzOwMAAGzduZOPGjWzYsIGenp5wd6ZrGv5yG0Ht9YUGXywWyWQyjIyMcPbs + Wc6cOcPY2Nh0BejFLJ4K78mGDRu48847GRoaIpFIdIPxZ4F/iwn+NdX4l0QADh8+HCbL9JXL5Y8EQfDq + Zje8VCpFKpVqmScUNuqJiQkOHz7M/v37m5KtVtvjh7Mhq1evZsOGDaxZs4ZVq1bR19dHLBYL6zTOKggL + NZR65x2+F+7rUC6XmZycZHR0lJGRES5evMj4+DjFYvGaIOli74EQgjVr1rBv3z527dpFb2/viojeCvFh + 4Jeo7sjd8gIA8IEPfID77rsPx3FeXKlUPq613tjM40spSafTJBKJlnpStVNahw8f5sCBA1y6dKlpacG1 + wUHXdYlEIsTjcfr6+hgYGKC/v590Ok0ymSSZTBKPx3FdF8dxcBznuhTmmbn14UspRRAE069isUg+nyeT + yTA+Ps7ExATj4+NMTk5SKBQolUrXDH+ada1SSvr7+9m1axd79+5l1apV3TZ1egx4PXBwKYx/yQTg6NGj + KKUYHBwU+/fv/60gCP6r1rqp0TspJalUikQi0XI54WEjDdNYh4eHp6e4mllDYGZMQEo5bfCu6+J5HolE + gkQiQTQanX6/9gUm89L3/em/vu9TKBSmX+EeDuHGruHvNdPgQ5RSuK7LunXrGBoaYnBwkFWrVl035OkC + CsB7gA+Gb7SNAIAJCFYbZX+pVHpYKfXapTC0VCpFMplsyYUhoRBMTk5y/Phxjhw5wtmzZ6f3Q1iqc16s + +197/jf6/2aebzitt2nTJnbv3s327du7PVnqYeBXqK74WwrjX1IBAPjmN79JOp1GSnmH7/t/p5S6dSmM + LJlMkkqlWnZ1WHhehUKBs2fPMjw8zIkTJ5iampqOE3TbyrbQ6B3Hobe3l5tvvpnbb7+drVu3Tg/tujhL + 8nvAz2Dm/pfM+JdcAI4ePTo9Jk4kEm8JguDPtdbppTCwRCJBKpVquToCM8+zNgPuxIkTPPfcc1y4cGG6 + MGoni0Fo9KFob9y4kVtvvZVt27bR39/fdRmRs3AJeDvw+fCNthUAgEOHDgHgeV4kn8//J6XUe7XWS7J8 + K5FIhB5Hyz/l0MiLxSKXL1/m5MmTPPfcc1y8eHF6r4ROEIPanj7Mcdi6dSvbtm1j7dq1xGKx6c9ZyAP/ + AfifmOSfJTX+ZREAMKXDqpHnnnK5/CdBEDy0VL8Vj8dJp9Mts4x4vkIAZohw6dIlnn/+ec6dO8fIyAjZ + bJZyubzoefTlMvbwrxACz/Ome/qtW7eyefNmVq1a1RFZjkuAD/wR8J+B4nIY/7IJAMD+/fvDBry+Uqn8 + hVLqx5fqtyKRCOl0umUKijQiBuFy6JGREc6fP8/58+e5dOnSdFQ+zH1fikj8Qo0dmF6wlUgkWLNmDevW + rWPdunWsX7+enp6ea8qkWaOvy0eBXwXGl8v4l1UAwko569evx3GcQd/3P6yUumepfs9xHNLpNLFYrG3d + 6Npc+lKpRDab5fLly4yNjTE2NsaVK1cYHx+nUCiES7KvMa4bLaW9kVHf6P2wZw8Tk3p7e+nv72dgYIB1 + 69axevVq4vE40Wh0+tytwc/Jl4BfAM6Eb3ScAIBJE/Y8j4mJCSKRyEuqIrBtKQ0oTIpph7jAXNdS+zcI + AsrlMqVSaToxJ5vNksvlrnkVCoVpYQiTfGqTfmqFZmaiUGjkiURi+m86naavr2866SgajeJ53nROgTX4 + BfMkJuh3cLmNf9kFAGB4eBiAbDZLNBr9Sd/3P9iMMmI3IhaLkU6nO6501Mx8fGA6iy9M7An3XgwTfGoT + foIgmA7Q1SYQOY5DJBIhFotdk0kYvkJDD7EG3zAngZ8DvrYSxr8iAgAmSUgIwc6dO8X+/fvfEQTB+7TW + vUv5m57nTfdY3cBC3f+5jNkaedMZAX5Za/2J8Jkst/GvmADA1ZmBeDzuZrPZnw+C4Pe11quW8jellCST + SRKJRNsPCSztidYa3/evKKX+b8dxPiKEUI7jrIjxr6gA1IpAf3+/vHz58luCIPjDpR4OgKnvl0wmu8Yb + sLQGQRBQKBSuVCqV905NTX149erVQSwWY8uWLSt2TivaDe7ZsyfMFFR79+79K8dx3i2lvLDUvxsGzjKZ + DEEQYLEsJVprisUik5OTl/L5/K+PjY39n1QqFVQqlRU1flhhDyDkwIEDSCm5dOkSq1atek0QBH+qlFqW + OxOJRKa9AbuTj6XZBEEQzsZcBH49Eok8ElY83rdv34qfX8u0+DAwmM/nicViD/q+/z+VUtuX5SaYWATJ + ZLLbNpmwLBG1uRu+758UQrwnCILPhO3rjjvuaInzbKku7+DBg0gpyefzRKPR+33f/xOl1O7l+v1w/XxY + cstiaYRyuUw+nw93ktrvuu57SqXSo+Fip1Yx/pYTADAZg1JKstkssVhsn+/7v6eUeuWy3ZBqplsoBHZY + YJkvlUpluohKtSzelzzPe28+n9+fTqfxfZ89e/a01Dm3ZOs+fPgwnueFW4WvrVQqv62U+jda62WrASaE + mI4PRCIRKwSWWamtoFQNKpeklB9zHOd3lFIXUqkUvu8zODjYcufekn7uzp07UUrxne98B6XUaCKReK/j + OO+RUp5brnMIx3Bh7btwRZ7FEhIEAdlsdjoNu7qP4aiU8rdc1/01rfWFffv2UalUWtL4oUU9gFrC4OCp + U6fYsmXLy6tDgnuX+zyklMRiMeLxeNutMrQ0l3Cn6Hw+T6VSuWpMQjwlpfyP69at+8Lo6KgG4x3cdddd + LXstbeHXHjx4EMdxyOVyxGKxbb7v/zel1BuWqrDIfIQgLMVthwbdg+/7lEqlaxZYVQmklJ9yHOc/lUql + o+HS51aY5usIAQCzkjAejzM5OYnneb3lcvndQRD8itZ67UqcT+1quZk1+S2dg9aaSqVCsVicXlR1jQEJ + Meo4zp85jvNnQRCMRyIRgiBg9+7dbXF9bdV9HT16lGKxiOM49PX1yfHx8Zf5vv/vtdYvb3bZ8XnfQCFw + XXfaK7B5BJ2BUopyuXxdAZbaj0gpv+Y4zu+vX7/+0YsXLyqlFI7jtFykv2MEICTMFyiVSkQikdW+7/98 + EATv1lrftJLn5TgO0WjUDg/amCAIpt382j0QrjEaIUaFEP/Ldd0/r1Qqo7FYDKVU2/T6bS8AYLyB9evX + c/r0aXbv3s3BgwfvDYLg3ymlflxrvaJRunB4EI1GiUQiuK5rxaCFCXv7UqlEuVy+zs2vwRdCPCqlfF9P + T8+jmUxGDQwMMDU1xc6dO9vy2tu+VYaJQ+VymUgk0lsul9+slHrPcqURz4XjONeIQbhFl2XljT4slhIa + /Y2meYUQz0kp/0xK+VdBEFwJd2tuh0BfRwsAGG9gZGSEVatWMTo6ypo1a/YEQfCbSqmf1Fq3zC6iYaWd + 8GXFYPmNPozkhwG9uXI7hBCZaoT//efOndu/YcMGPM/D93327t3b9veko1rf4cOHa72BRLlcfkUQBL+o + tX6p1jrWSucaikFYU8+KQfMJayDW7mbs+369gF49ylLKbzmO82fxePyL+Xy+4LouSqm2CvJ1lQCA8QYK + hQKu61Iul4nFYn2VSuUnlFLv0FrfuxK5Azd8ANUCnKEghAU2rSA0ZvDVijtUKpXpV1j7cJ4EQognpJQf + cl330+VyeSwWi1GpVEilUmzf3hIjSysAcxHmDWQyGYrFIvF4fI3v+z+llPoFrfU+rXVLpkGHghDu7hu+ + arfztlwl7OFrDV4pNd9e/hr9EEIcklL+pZTy70ql0sVwn4Nyudy2Qb6uFYBaIfA8j3w+Ty6XI51Ob/J9 + /6eVUm9XSg21/AOqKdFdu623lLKrRKG2rHltZeOwh2/A4Gvv8TEhxEellB8rFAqnwn0NgiBg165dHX1f + u6ZLGR4exnEcSqUSFy5cYOPGjT8QBMFblFJv1FrftlKJRI0IQu2wYWY571AU2lkYQkMPgmDa0EOjD935 + JizMUlLKo1LKv5VSPvLud7/7+J/+6Z8SRvc7aZxvBaCGMFBYqVTYvXs3hw4d2hoEwY9X1xbcpbVOtuWD + rBr9TDGY+aoVh5UQiVrjDV312ldo5GGvvgQbjZSklN8XQjziuu5n3/jGNz7/yCOPIKXsKsPvWgGoJwSl + UolEItHv+/5LlFJvVEo9sFJrDJZCGGoFop4o1ArDzM/P/O/w/2fu81drqDN3Hqpn6LXj9OXYTUgIcQX4 + ppTyE1LKfy6VSpdisRjRaBSlVMsu17UCsMQcOXIE13UpFov4vk8ikYiWSqU9QRC8Xmv9aqXUbbRo3YSl + EIr5/H89Aahl5nsrWEdBCSFOCCE+L6X8pJTy+77v56WURCIRlFIdP8a3AjBPjh49yvj4OOl0miAI2LNn + j6gOD16llHqd1nrvUm9cYmlSoxZiXAixX0r5KSnl51evXn1qZGRE1W622u4ZfFYAlpDahKJisUg6ne71 + fX9nEAQPaK1/VGu9U2vdZ+9US5GRUh4Bvuw4zpcdxzmQz+cnw7UYWuu2XKxjBWAFOXLkyPTMQRAETE1N + MTAw0B8EwZ6qGPyI1npQa91j79aKkBNCnAC+IqX8suM4T46Ojl5evXo1tW7+0FDLz/ZaAWh1hoeHp4OG + QRBw/vx5tm7dOuD7/h1KqR+uisGtVgyWuMEKMSmEOA48KqX8BvC99evXj5w/f16HU6OA7e2tACyfGDzy + yCO89a1vXaOU2hsEwd1a67uBvVrrde06rdhCFIUQl4QQB4UQ33Yc5ztSyoM7d+689PTTTwNM7+HQCYtz + rAC0oRgIIaZTUIMgIJVKJUql0gBwRxAEdwD3VrMO17baoqQWpFw1+GeB70gpDyilvheNRkcKhUI2zIIM + x/WdmqJrBaANOXLkCFLK6RRVMBuR9vb2pkul0mohxN2+7+8VQtynlLoF6AN6tNZd+RyqU4tTwLiU8pTW + +rtSyoNa68dd1x2ZnJycTCaTaK2n059tMM8KQNsJQqVSma4yc+XKFTZu3NhXKpXSUsrtWuudQRBsEELs + rsYQ+oE+rXVH7V0uhKhoraeEEFNCiFNa66ccxzkjhDiktX4mEolkDh06NHHrrbdOG7zWGiFE12XnWQHo + UMLYQeghhMk1mUyGtWvXpkqlUlIptVpKuTcIgq1a61uEEHu11muUUlEgIYRIAJFW3KRECOFrrQtATkpZ + EEKMaK0PAaeklBe01oe01uc8z8u+7W1vm3z44Yen5+U9z5s+Trcn51gB6CKOHDmCEGJ60YtSCiEESilW + r17tZrPZ3kqlEg2CIOa67hZgi9Z6dRAESa11v5TyFmCT1rpfax3TWkeEEB7gAk7NS1KT0ThH+SsADSjA + B3ytdRkzPq9U/2aBUa31SeCilDIrpRzTWp9VSp10HCcTiUSKiURi6sqVK35t9mAYqXcch2Kx2NIbZ1gB + sCw7YWBx5vLX2r0HlFLceeedPPvss8lKpRILgiDi+74rpewXQvQKIZJAAohXA48xrbWH8R5crbVTjT2I + qqErIYTCFMTwq4ZfEkLkgCkhxITW+koQBFNSykBK6Uspi67r5nO5nF+7XiAsjx2O233fR0ppe3YrAJZm + CUQ8HqdYLF63dHa21X61Pf7MhTvzXQcQfi9cVBSKVDicecELXmAfjsVisVgsFovFYrFYLBaLxWKxWCwW + i8VisVgsFovFYrFYLBaLxWKxWCwWi8VisSwF/z/asEghz8EDCAAAAABJRU5ErkJggg== + + + \ No newline at end of file diff --git a/Reddit Post Scraping Tool/Reddit Post Scraping Tool/StartForm.vb b/Reddit Post Scraping Tool/Reddit Post Scraping Tool/StartForm.vb new file mode 100644 index 0000000..e57aa01 --- /dev/null +++ b/Reddit Post Scraping Tool/Reddit Post Scraping Tool/StartForm.vb @@ -0,0 +1,111 @@ +Imports Newtonsoft.Json +Imports Newtonsoft.Json.Linq +Imports System.Reflection +Imports System.Windows.Forms.VisualStyles.VisualStyleElement.ProgressBar +Imports System.Windows.Forms.VisualStyles.VisualStyleElement.StartPanel + +Public Class StartForm + Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click + Dim ApiHandler As New ApiHandler + Dim Keyword As String = KeywordTextBox.Text + Dim Subreddit As String = SubredditTextBox.Text + Dim Listing As String = ListingComboBox.Text.ToLower() + Dim Limit As String = LimitTextBox.Text + Dim Timeframe As String = TimeframeComboBox.Text.ToLower() + Dim FoundPosts As Integer = 0 + Dim TotalPosts As Integer = 0 + + ' Clear the Columns and Rows before adding Items to them + PostsForm.DataGridViewPosts.Rows.Clear() + PostsForm.DataGridViewPosts.Columns.Clear() + + PostsForm.DataGridViewPosts.Columns.Add("PostCount", "Post Number") + PostsForm.DataGridViewPosts.Columns.Add("PostAuthor", "Author") + PostsForm.DataGridViewPosts.Columns.Add("PostID", "ID") + PostsForm.DataGridViewPosts.Columns.Add("PostSubreddit", "Subreddit") + PostsForm.DataGridViewPosts.Columns.Add("SubredditVisibility", "Subreddit Visibility") + PostsForm.DataGridViewPosts.Columns.Add("PostThumbnail", "Thumbnail") + PostsForm.DataGridViewPosts.Columns.Add("PostIsNSFW", "NSFW") + PostsForm.DataGridViewPosts.Columns.Add("PostIsGilded", "Gilded") + PostsForm.DataGridViewPosts.Columns.Add("PostUpvotes", "Upvotes") + PostsForm.DataGridViewPosts.Columns.Add("PostUpvoteRatio", "Upvote Ratio") + PostsForm.DataGridViewPosts.Columns.Add("PostDownvotes", "Downvotes") + PostsForm.DataGridViewPosts.Columns.Add("PostAwards", "Awards") + PostsForm.DataGridViewPosts.Columns.Add("PostTopAward", "Top Award") + PostsForm.DataGridViewPosts.Columns.Add("PostIsCrosspostable", "Is Crosspostable?") + PostsForm.DataGridViewPosts.Columns.Add("PostScore", "Score") + PostsForm.DataGridViewPosts.Columns.Add("PostText", "Text") + PostsForm.DataGridViewPosts.Columns.Add("PostCategory", "Category") + PostsForm.DataGridViewPosts.Columns.Add("PostDomain", "Domain") + PostsForm.DataGridViewPosts.Columns.Add("PostPermalink", "Permalink") + PostsForm.DataGridViewPosts.Columns.Add("PostCreatedAt", "Created At") + PostsForm.DataGridViewPosts.Columns.Add("PostApprovedAt", "Approved At") + PostsForm.DataGridViewPosts.Columns.Add("PostApprovedBy", "Approved By") + + If Limit = "" Then + Limit = "10" + ElseIf Limit > 100 Then + MessageBox.Show("Limit should not be over 100. Defaulting to 10", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning) + End If + + If Listing = "" Then + Listing = "top" + End If + + If Timeframe = "" Then + Timeframe = "all" + End If + + If Keyword = "" Then + MessageBox.Show("Keyword should not be emtpy", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning) + ElseIf Subreddit = "" Then + MessageBox.Show("Subreddit should not be emtpy", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning) + Else + PostsForm.Text = $"Reddit Post Scraping Tool - {Keyword}" + Dim Posts As JObject = ApiHandler.ScrapeReddit(Subreddit, Listing, Limit, Timeframe) + For Each Post In Posts("data")("children") + TotalPosts += 1 + If Post("data")("selftext").ToString.ToLower().Contains(KeywordTextBox.Text.ToLower()) Then + FoundPosts += 1 + PostsForm.DataGridViewPosts.Rows.Add(TotalPosts, 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")("selftext"), + Post("data")("category"), Post("data")("domain"), Post("data")("permalink"), Post("data")("created"), + Post("data")("approved_at_utc"), Post("data")("approved_by")) + End If + Next + MessageBox.Show($"Keyword `{Keyword}` was found in {FoundPosts}/" + Posts("data")("children").Count.ToString _ + + $" {Listing} posts from r/{Subreddit}", "Information", MessageBoxButtons.OK, MessageBoxIcon.Information) + PostsForm.Show() + If SaveResultsJsonToolStripMenuItem.Checked Then + Dim saveFileDialog As New SaveFileDialog() + + saveFileDialog.Filter = "JSON files (*.json)|*.json" + saveFileDialog.Title = "Save JSON File" + + If saveFileDialog.ShowDialog() = DialogResult.OK Then + Dim fileName As String = saveFileDialog.FileName + Dim serializerSettings As New JsonSerializerSettings() + serializerSettings.Formatting = Formatting.Indented + Dim json As String = JsonConvert.SerializeObject(Posts("data")("children")(0), serializerSettings) + + System.IO.File.WriteAllText(fileName, json) + + MessageBox.Show($"Results saved to {fileName} successfully!", "Success", MessageBoxButtons.OK, MessageBoxIcon.Information) + End If + End If + End If + End Sub + + Private Sub ToolStripMenuItemExit_Click(sender As Object, e As EventArgs) Handles ToolStripMenuItemExit.Click + Dim result As DialogResult = MessageBox.Show("This will close the program, continue?", "Exit", MessageBoxButtons.YesNo, MessageBoxIcon.Question) + If result = DialogResult.Yes Then + Me.Close() + End If + End Sub + + Private Sub StartForm_Load(sender As Object, e As EventArgs) Handles MyBase.Load + Me.Text = $"Reddit Post Scraping Tool v{My.Application.Info.Version.ToString}" + End Sub +End Class diff --git a/Reddit Post Scraping Tool/Reddit Post Scraping Tool/rpst.ico b/Reddit Post Scraping Tool/Reddit Post Scraping Tool/rpst.ico new file mode 100644 index 0000000000000000000000000000000000000000..1e4b713bb456cac92a8471a5f7171180c2bd1c1f GIT binary patch literal 16069 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 literal 0 HcmV?d00001