commit a30112bc0e20936927160fa2afd937d217bc8282 Author: SchreiberM Date: Wed Jan 25 13:21:40 2017 +0100 MS diff --git a/DD_Clipboard_Searcher.sln b/DD_Clipboard_Searcher.sln new file mode 100644 index 0000000..2e14afd --- /dev/null +++ b/DD_Clipboard_Searcher.sln @@ -0,0 +1,22 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 2013 +VisualStudioVersion = 12.0.21005.1 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{F184B08F-C81C-45F6-A57F-5ABD9991F28F}") = "DD_Clipboard_Searcher", "DD_Clipboard_Searcher\DD_Clipboard_Searcher.vbproj", "{09BC9934-1A38-4752-8873-639B42779CDB}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {09BC9934-1A38-4752-8873-639B42779CDB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {09BC9934-1A38-4752-8873-639B42779CDB}.Debug|Any CPU.Build.0 = Debug|Any CPU + {09BC9934-1A38-4752-8873-639B42779CDB}.Release|Any CPU.ActiveCfg = Release|Any CPU + {09BC9934-1A38-4752-8873-639B42779CDB}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/DD_Clipboard_Searcher/App.config b/DD_Clipboard_Searcher/App.config new file mode 100644 index 0000000..43615fd --- /dev/null +++ b/DD_Clipboard_Searcher/App.config @@ -0,0 +1,18 @@ + + + + +
+ + + + + + + + + False + + + + \ No newline at end of file diff --git a/DD_Clipboard_Searcher/Class1.vb b/DD_Clipboard_Searcher/Class1.vb new file mode 100644 index 0000000..1014cb2 --- /dev/null +++ b/DD_Clipboard_Searcher/Class1.vb @@ -0,0 +1,69 @@ +Imports Microsoft.VisualBasic.ControlChars +Imports System.Runtime.InteropServices + +Public Class ClipboardWatcher : Inherits NativeWindow : Implements IDisposable + _ + Private Shared Function SetClipboardViewer(ByVal hWnd As IntPtr) As IntPtr + End Function + + Public Event Changed As EventHandler + + Private _hview As IntPtr + + 'nur eine globale Instanz zulassen + Public Shared Singleton As New ClipboardWatcher + + Private Sub New() + MyBase.CreateHandle(New CreateParams) + _hview = SetClipboardViewer(MyBase.Handle) + End Sub + + Protected Overrides Sub WndProc(ByRef m As Message) + Const WM_DRAWCLIPBOARD As Integer = &H308 + Select Case m.Msg + Case WM_DRAWCLIPBOARD + Dim CapTxt As String = clsWINDOWSApi.GetCaption() + Console.WriteLine("Window-Title: " & CapTxt) + If CapTxt.ToUpper.StartsWith("DD") Then Exit Sub + RaiseEvent Changed(Me, EventArgs.Empty) + End Select + MyBase.WndProc(m) + End Sub + +#Region " IDisposable Support " + ' Für diese Klasse ist korrekte Ressourcenbereinigung besonders wichtig, da + ' mit systemübergreifenden Ressourcen gearbeitet wird + + ' So ermitteln Sie überflüssige Aufrufe + Private disposedValue As Boolean = False + + Protected Overridable Sub Dispose(ByVal disposing As Boolean) + If Not Me.disposedValue Then + If disposing Then + ' TODO: Verwaltete Ressourcen freigeben, wenn sie explizit + ' aufgerufen werden + End If + MyBase.DestroyHandle() + Dim H As IntPtr = SetClipboardViewer(_hview) + End If + Me.disposedValue = True + End Sub + + ' Dieser Code wird von Visual Basic hinzugefügt, um das Dispose-Muster + ' richtig zu implementieren. + Public Sub Dispose() Implements IDisposable.Dispose + ' Sie sollten diesen Code nicht ändern, sondern stattdessen ihren + ' Bereinigungscode oben in + ' Dispose(ByVal disposing As Boolean) einfügen. + Dispose(True) + GC.SuppressFinalize(Me) + End Sub + + Protected Overrides Sub Finalize() + MyBase.Finalize() + Dispose(False) + End Sub + +#End Region + +End Class diff --git a/DD_Clipboard_Searcher/ClassInit.vb b/DD_Clipboard_Searcher/ClassInit.vb new file mode 100644 index 0000000..4e9ab3c --- /dev/null +++ b/DD_Clipboard_Searcher/ClassInit.vb @@ -0,0 +1,138 @@ +Imports System.ComponentModel +Imports DD_LIB_Standards +Public Class ClassInit + Public _lizenzManager As clsLicenseManager + Public Sub InitLogger() + ClassLogger.Init("") + End Sub + Public Function InitDatabase() + Dim dbResult As Boolean + clsDatabase.GUI = True + If MyConnectionString <> String.Empty Then + dbResult = clsDatabase.Init(MyConnectionString) + Else + MsgBox("No Databaseconnection configured. (First Start or Appdata not accessible)" & vbNewLine & "Basic-Config will be loaded.", MsgBoxStyle.Information) + ERROR_INIT = "NO DB-CONNECTION" + frmConfig_Basic.ShowDialog() + dbResult = clsDatabase.Init(MyConnectionString) + InitBasics() + End If + If dbResult = False Then + ERROR_INIT = "FAILED DBCONNECTION" + MsgBox("Error in init database. (Connection failed) More information in the logfile.", MsgBoxStyle.Critical) + Return False + Else + Return True + End If + End Function + Public Function InitBasics() + Dim configResult As Boolean + configResult = LoadMyConfig() + If configResult = False Then + Throw New Exception("Unexpected error inm Initialisieren der Basis-Einstellungen. Weitere Informationen finden Sie in der Logdatei.") + Else + Return False + End If + End Function + Public Shared Function InitUserLogin(Optional _User As String = "") + Try + If _User = "" Then + USER_USERNAME = Environment.UserName + Else + USER_USERNAME = _User + End If + Dim sql = String.Format("SELECT * FROM TBDD_USER WHERE (LOWER(USERNAME) = LOWER('{0}'))", USER_USERNAME) + ClassLogger.Add(">> Login time: " & Now.ToString, False) + ClassLogger.Add(">> Username: " & USER_USERNAME, False) + Dim USER_DT As DataTable = clsDatabase.Return_Datatable(sql, True) + If USER_DT.Rows.Count = 0 Then + ClassLogger.Add(" - User '" & USER_USERNAME & "' not listed in Useradminsitration!", False) + 'MsgBox("Achtung: Sie sind nicht in der Userverwaltung hinterlegt." & vbNewLine & "Bitte setzen Sie sich mit dem Systembetreuer in Verbindung!", MsgBoxStyle.Critical, "Achtung:") + 'Me.Close() + Dim msg = String.Format("You are not listed in the Useradministration." & vbNewLine & "Please contact the admin.") + MsgBox(msg, MsgBoxStyle.Exclamation) + Return False + Else + USER_GUID = USER_DT.Rows(0).Item("GUID") + USER_LANGUAGE = USER_DT.Rows(0).Item("LANGUAGE") + DT_CLIENT_USER = clsDatabase.Return_Datatable("SELECT T.*, T1.CLIENT_NAME FROM TBDD_CLIENT_USER T,TBDD_CLIENT T1 WHERE T.CLIENT_ID = T1.GUID AND T.USER_ID = " & USER_GUID, True) + + Dim Access_right As Boolean = USER_DT.Rows(0).Item("MODULE_DDCBSEARCHER") + If Access_right = False Then + ClassLogger.Add(" - User: " & USER_USERNAME & " nicht für Modul freigegben!", False) + 'MsgBox("Achtung: Sie sind nicht für die Nutzung dieses Moduls freigeschaltet." & vbNewLine & "Bitte setzen Sie sich mit dem Systembetreuer in Verbindung!", MsgBoxStyle.Critical, "Achtung:") + Dim msg = String.Format("Sie sind nicht für die Nutzung dieses Moduls freigeschaltet." & vbNewLine & "Bitte setzen Sie sich mit dem Systembetreuer in Verbindung!") + + If USER_LANGUAGE <> "de-DE" Then + msg = String.Format("You are not authorized for using this module." & vbNewLine & "Please contact the admin.") + End If + MsgBox(msg, MsgBoxStyle.Exclamation, "Attention:") + Return False + Else + 'Am System anmelden + clsLicense.Refresh_Licence(0) + 'Am System anmelden + sql = String.Format("UPDATE TBDD_USER SET LOGGED_IN = 1, LOGGED_WHERE = '{0}' WHERE GUID = {1}", Environment.MachineName, USER_GUID) + clsDatabase.Execute_non_Query(sql) + sql = "DELETE FROM TBDD_USER_MODULE_LOG_IN WHERE USER_ID = " & USER_GUID & " AND MODULE= 'DD_CLIPB_SEARCH'" + If clsDatabase.Execute_non_Query(sql, True) = True Then + + End If + + sql = String.Format("INSERT INTO TBDD_USER_MODULE_LOG_IN (USER_ID,CLIENT_ID,MODULE) VALUES ({0},{1},'DD_CLIPB_SEARCH')", USER_GUID, 0) + clsDatabase.Execute_non_Query(sql) + + USER_IS_ADMIN = USER_DT.Rows(0).Item("RECORD_ADMIN") + If USER_IS_ADMIN = True Then + If ESC_Hidden = True Then + 'frmLoginUserSelect.ShowDialog() + ESC_Hidden = False + If USER_USERNAME <> "" Then + InitUserLogin(USER_USERNAME) + End If + + End If + ' 'Admin + ' pageAdmin.Visible = True + End If + + WD_UNICODE = clsDatabase.Execute_Scalar("SELECT WD_UNICODE FROM TBGH_WINDREAM_CONFIGURATION WHERE GUID = 1") + + + sql = String.Format("SELECT COUNT(*) AS Expr1 FROM TBDD_USER_MODULE_LOG_IN WHERE UPPER(MODULE) = UPPER('DD_CLIPB_SEARCH') AND CLIENT_ID = {0}", 0) + Dim anzahl = clsDatabase.Execute_Scalar(sql) + USERS_LOGGED_IN = CInt(anzahl) + If LogErrorsOnly = False Then ClassLogger.Add(" >> User# logged in: " & anzahl.ToString, False) + '#### + + If LICENSE_COUNT < USERS_LOGGED_IN And LICENSE_EXPIRED = False Then + Dim msg = String.Format("Die Anzahl der aktuell angemeldeten User (" & USERS_LOGGED_IN.ToString & ") überschreitet die Anzahl der aktuellen Lizenzen!" & vbNewLine & "Anzahl der Lizenzen: " & LICENSE_COUNT.ToString & vbNewLine & "Bitte setzen Sie sich mit dem Systembetreuer in Verbindung!") + + If USER_LANGUAGE <> "de-DE" Then + msg = String.Format("The number of logged Users (" & USERS_LOGGED_IN.ToString & ") exceeds the number of licenses." & vbNewLine & _ + "Number of licenses: " & LICENSE_COUNT.ToString & vbNewLine & "Please contact Your admin!") + End If + MsgBox(msg, MsgBoxStyle.Exclamation) + ClassLogger.Add(" >> The number of logged Users (" & USERS_LOGGED_IN.ToString & ") exceeds the number of licenses (" & LICENSE_COUNT & ") ", False) + If USER_IS_ADMIN = False Then + 'Anmeldung wieder herausnehmen + sql = "DELETE FROM TBDD_USER_MODULE_LOG_IN WHERE USER_ID = " & USER_GUID & " AND MODULE= 'DD_CLIPB_SEARCH'" + clsDatabase.Execute_non_Query(sql, True) + ClassLogger.Add(" - logged out the user", False) + Return False + End If + End If + Return True + 'LabelLoggedIn.Caption = "Anzahl Angemeldete User: " & anzahl.ToString + End If + End If + Catch ex As Exception + ClassLogger.Add("Unexpected Error in InitUserLogin: " & ex.Message, True) + MsgBox("Unexpected Error in InitUserLogin: " & ex.Message, MsgBoxStyle.Critical) + Return False + End Try + + End Function + + +End Class diff --git a/DD_Clipboard_Searcher/ClassLayout.vb b/DD_Clipboard_Searcher/ClassLayout.vb new file mode 100644 index 0000000..85f8091 --- /dev/null +++ b/DD_Clipboard_Searcher/ClassLayout.vb @@ -0,0 +1,165 @@ +Imports System.Xml +Imports System.IO + +Public Class ClassWindowLocation + + Public Shared Sub LoadFormLocationSize(ByRef form As Form, Optional Prefix As String = "") + Try + Dim LayoutPath As String + LayoutPath = Path.Combine(Application.UserAppDataPath(), Prefix & form.Name & "-PositionSize.xml") + + Dim layout As ClassLayout = New ClassLayout(LayoutPath) + Dim settings As System.Collections.Generic.List(Of ClassSetting) + settings = layout.Load() + + If settings.Count = 0 Then + settings.Add(New ClassSetting("PositionX", form.Location.X)) + settings.Add(New ClassSetting("PositionY", form.Location.Y)) + settings.Add(New ClassSetting("Width", form.Size.Width)) + settings.Add(New ClassSetting("Height", form.Size.Height)) + layout.Save(settings) + End If + + For Each s As ClassSetting In settings + Dim x, y, w, h As Integer + + Select Case s._name + Case "PositionX" + x = Integer.Parse(s._value) + Case "PositionY" + y = Integer.Parse(s._value) + Case "Width" + w = Integer.Parse(s._value) + Case "Height" + h = Integer.Parse(s._value) + End Select + + If x = 5000 Then + form.WindowState = FormWindowState.Maximized + Else + If x > 0 Then + form.Location = New Point(x, y) + form.Size = New Size(w, h) + + End If + End If + + Next + Catch notFoundEx As System.IO.FileNotFoundException + ClassLogger.Add("Window Position & Size added for Form " & form.Name) + Catch ex As Exception + MsgBox("Error while loading Window Position!" & vbNewLine & ex.Message, MsgBoxStyle.Critical) + End Try + End Sub + + Public Shared Sub SaveFormLocationSize(ByRef form As Form, Optional Prefix As String = "") + Try + Dim _path As String + _path = Path.Combine(Application.UserAppDataPath(), Prefix & form.Name & "-PositionSize.xml") + Dim layout As ClassLayout = New ClassLayout(_path) + Dim settings As System.Collections.Generic.List(Of ClassSetting) = New System.Collections.Generic.List(Of ClassSetting) + Dim width As Integer + Dim height As Integer + Dim x As Integer + Dim y As Integer + If form.WindowState = FormWindowState.Maximized Then + width = 5000 + height = 5000 + x = 5000 + y = 5000 + Else + width = form.Size.Width + height = form.Size.Height + x = form.Location.X + y = form.Location.Y + End If + + settings.Add(New ClassSetting("PositionX", x)) + settings.Add(New ClassSetting("PositionY", y)) + settings.Add(New ClassSetting("Width", width)) + settings.Add(New ClassSetting("Height", height)) + + layout.Save(settings) + Catch notFoundEx As System.IO.FileNotFoundException + ClassLogger.Add("Window Position & Size added for Form " & form.Name) + Catch ex As Exception + MsgBox("Error while saving Window Position!" & vbNewLine & ex.Message, MsgBoxStyle.Critical) + End Try + + + End Sub + +End Class + + +'------------------------------------------------------------------- + +Public Class ClassSetting + Public _name As String + Public _value As String + + Public Sub New(name As String, value As String) + _name = name + _value = value + End Sub +End Class + +Public Class ClassLayout + Private _filename As String + Private _reader As XmlReader + Private _settings As XmlWriterSettings + + Public Sub New(filename As String) + _filename = filename + + _settings = New XmlWriterSettings() + _settings.Encoding = System.Text.Encoding.UTF8 + _settings.Indent = True + End Sub + + Public Sub Save(settings As System.Collections.Generic.List(Of ClassSetting)) + Dim w = XmlTextWriter.Create(_filename, _settings) + + w.WriteStartDocument() + w.WriteStartElement("Settings") + + For Each setting As ClassSetting In settings + w.WriteStartElement("Setting") + w.WriteAttributeString("name", setting._name) + w.WriteAttributeString("value", setting._value.ToString()) + w.WriteEndElement() + Next + + w.WriteEndElement() + w.WriteEndDocument() + + w.Dispose() + w.Close() + End Sub + + Public Function Load() As System.Collections.Generic.List(Of ClassSetting) + Dim Result As List(Of ClassSetting) = New List(Of ClassSetting)() + + If Not File.Exists(_filename) Then + Return Result + End If + + _reader = XmlReader.Create(_filename) + + While _reader.Read() + If _reader.IsStartElement() Then + If _reader.Name = "Setting" Then + Dim name As String = _reader("name") + ' Dim value As Integer = Integer.Parse(_reader("value")) + Dim setting As ClassSetting = New ClassSetting(name, _reader("value")) 'value) + Result.Add(setting) + End If + End If + End While + + _reader.Dispose() + _reader.Close() + + Return Result + End Function +End Class diff --git a/DD_Clipboard_Searcher/ClassLogger.vb b/DD_Clipboard_Searcher/ClassLogger.vb new file mode 100644 index 0000000..130f468 --- /dev/null +++ b/DD_Clipboard_Searcher/ClassLogger.vb @@ -0,0 +1,201 @@ +Imports System.IO +Imports DD_LIB_Standards +Public Class ClassLogger + Public Shared DateiSpeicherort As String = Nothing + Public Shared DateiPrefix As String = "" + Public Shared Datei As IO.File = Nothing + Public Shared logDateiname As String = "" + Private Shared StreamWriter As IO.StreamWriter = Nothing + Private Shared HasInformedAboutError As Boolean = False + ' eine Art Konstruktor + Public Shared Sub Init(ByVal speicherort As String, Optional ByVal prefix As String = "", Optional ByVal appendFile As Boolean = True) + ' initialisiert den Speicherort + ClassLogger.SetSpeicherort(speicherort) + ' wenn ein Prfix gesetzt wurde + If Not prefix = "" Then + ' initialisiert das Prefix + ClassLogger.SetPrefix(prefix) + End If + Dim str As String = ClassLogger.DateiSpeicherort & "\" & ClassLogger.DateiPrefix & System.DateTime.Now.ToString("yyyy_MM_dd") & ".txt" + Dim anz As Integer = 1 + Do While File.Exists(str) + Dim info As New FileInfo(str) + Dim length As Long = info.Length + If length > 5000000 Then + str = IO.Path.GetDirectoryName(str) + str = str & "\" & ClassLogger.DateiPrefix & System.DateTime.Now.ToString("yyyy_MM_dd") & "(" & anz.ToString & ").txt" + anz = anz + 1 + Else + Exit Do + End If + Loop + ClassLogger.logDateiname = str + If Not appendFile Then + ' der Versuch die Datei zu löschen + My.Computer.FileSystem.WriteAllText(ClassLogger.logDateiname, String.Empty, False) + End If + ' testen ob sich die Datei öffnen und beschreiben lässt + 'ClassNILogger.CheckIsLogWritable() + End Sub + + ' legt den Speicherort fest + Public Shared Sub SetSpeicherort(ByVal speicherort As String) + Dim f As String = Application.UserAppDataPath() & "\Log" + + If speicherort = "" Then + If IO.Directory.Exists(f) = False Then + IO.Directory.CreateDirectory(f) + End If + ClassLogger.DateiSpeicherort = f + Else + ClassLogger.DateiSpeicherort = speicherort + End If + ' clsLogger.LOGFILE_PATH = ClassLogger.DateiSpeicherort + End Sub + + ' legt das Prefix für den Dateinamen fest + Public Shared Sub SetPrefix(ByVal prefix As String) + ClassLogger.DateiPrefix = prefix + End Sub + + Public Shared Sub Add(ByVal information As String, Optional ByVal ACHTUNG As Boolean = True) + If ClassLogger.OpenFile Then + Try + If ACHTUNG Then + ClassLogger.StreamWriter.WriteLine("#ATTENTION# (" & System.DateTime.Now & "): " & information) + Else + ClassLogger.StreamWriter.WriteLine(information) + End If + ClassLogger.CloseFile() + Catch e As Exception + ClassLogger.ShowErrorMessage() + End Try + Else + ClassLogger.ShowErrorMessage() + End If + End Sub + 'Public Shared Sub Add(ByVal ex As Exception) + ' If ClassLogger.OpenFile Then + ' Try + ' ClassLogger.StreamWriter.WriteLine("##### Exception (" & System.DateTime.Now & ")") + ' ClassLogger.StreamWriter.WriteLine("##### Error: " & ex.Message & " Source [" & ex.Source & "]") + ' ClassLogger.CloseFile() + ' Catch e As Exception + ' ClassLogger.ShowErrorMessage() + ' End Try + ' Else + ' ClassLogger.ShowErrorMessage() + ' End If + 'End Sub + ' öffnet eine Datei zum Schreiben + Private Shared Function OpenFile() + Try + ' wenn ein Speicherort festgelegt wurde + If Not ClassLogger.DateiSpeicherort = Nothing Then + ' den Dateienamen definieren + Dim dateiname As String = ClassLogger.logDateiname + ' Datei anlegen wenn noch nicht vorhanden + My.Computer.FileSystem.WriteAllText(dateiname, String.Empty, True) + ' die Datei zum Schreiben öffnen + ClassLogger.StreamWriter = New IO.StreamWriter(dateiname, True, System.Text.Encoding.UTF8) + End If + ' wenn die Datei erfolgreich geöffnet wurde + If ClassLogger.StreamWriter IsNot Nothing Then + Return True + Else + Return False + End If + Catch ex As Exception + Return False + End Try + + End Function + + ' öffnet eine Datei zum Schreiben + Private Shared Function OpenFile(ByVal DateiSpeicherort As String, ByVal DateiPrefix As String) + + Try + + ' wenn ein Speicherort festgelegt wurde + If Not DateiSpeicherort = Nothing And ClassLogger.CheckIsLogWritable() Then + + ' den Dateienamen definieren + Dim dateiname As String = ClassLogger.logDateiname + ' Datei anlegen wenn noch nicht vorhanden + My.Computer.FileSystem.WriteAllText(dateiname, String.Empty, True) + + ' die Datei zum Schreiben öffnen + ClassLogger.StreamWriter = New IO.StreamWriter(dateiname, True, System.Text.Encoding.UTF8) + End If + + ' wenn die Datei erfolgreich geöffnet wurde + If ClassLogger.StreamWriter IsNot Nothing Then + Return True + Else + Return False + End If + + Catch ex As Exception + Return False + End Try + + End Function + + + ' schliesst die geöffnete Datei + Private Shared Sub CloseFile() + + ' wenn eine Datei geöffnet ist + If ClassLogger.StreamWriter IsNot Nothing Then + ' die Datei schliessen + ClassLogger.StreamWriter.Close() + ClassLogger.StreamWriter = Nothing + End If + End Sub + + + Public Shared Function CheckIsLogWritable() + + If ClassLogger.OpenFile Then + Try + ClassLogger.CloseFile() + Catch e As Exception + ClassLogger.ShowErrorMessage() + Return False + End Try + Else + ClassLogger.ShowErrorMessage() + Return False + End If + + Return True + End Function + + + Public Shared Function CheckIsLogWritable(ByVal vDateiSpeicherort As String, ByVal vDateiPrefix As String) + + If ClassLogger.OpenFile(vDateiSpeicherort, vDateiPrefix) Then + Try + ClassLogger.CloseFile() + Catch e As Exception + ClassLogger.ShowErrorMessage() + Return False + End Try + Else + ClassLogger.ShowErrorMessage() + Return False + End If + + Return True + End Function + + + Private Shared Sub ShowErrorMessage() + If Not ClassLogger.HasInformedAboutError Then + MsgBox("Please make sure You can access the logpath and are able to write to the file. This may be due to security privileges or storage place in the drive." & _ + vbNewLine & vbNewLine & "A logfile won't be written from now on." & vbNewLine & vbNewLine & "You won't be informed about further logdetails from now on.", _ + MsgBoxStyle.Information, "Error opening Logfile") + ClassLogger.HasInformedAboutError = True + End If + End Sub +End Class diff --git a/DD_Clipboard_Searcher/DD_Clipboard_Searcher.vbproj b/DD_Clipboard_Searcher/DD_Clipboard_Searcher.vbproj new file mode 100644 index 0000000..f2f65cb --- /dev/null +++ b/DD_Clipboard_Searcher/DD_Clipboard_Searcher.vbproj @@ -0,0 +1,181 @@ + + + + + Debug + AnyCPU + {09BC9934-1A38-4752-8873-639B42779CDB} + WinExe + DD_Clipboard_Searcher.My.MyApplication + DD_Clipboard_Searcher + DD_Clipboard_Searcher + 512 + WindowsForms + v4.5.1 + true + + + AnyCPU + true + full + true + true + bin\Debug\ + DD_Clipboard_Searcher.xml + 42016,41999,42017,42018,42019,42032,42036,42020,42021,42022 + + + AnyCPU + pdbonly + false + true + true + bin\Release\ + DD_Clipboard_Searcher.xml + 42016,41999,42017,42018,42019,42032,42036,42020,42021,42022 + + + On + + + Binary + + + Off + + + On + + + + False + ..\..\DDLibStandards\DD_LIB_Standards\bin\Debug\DD_LIB_Standards.dll + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + frmLicense.vb + + + Form + + + Form + + + frmMain.vb + Form + + + frmConfig_Basic.vb + + + Form + + + frmSplash.vb + + + Form + + + + + + True + Application.myapp + + + True + True + Resources.resx + + + True + Settings.settings + True + + + + + frmLicense.vb + + + frmMain.vb + + + frmConfig_Basic.vb + + + frmSplash.vb + + + VbMyResourcesResXFileCodeGenerator + Resources.Designer.vb + My.Resources + Designer + + + + + MyApplicationCodeGenerator + Application.Designer.vb + + + SettingsSingleFileGenerator + My + Settings.Designer.vb + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/DD_Clipboard_Searcher/DD_Clipboard_Searcher.vbproj.user b/DD_Clipboard_Searcher/DD_Clipboard_Searcher.vbproj.user new file mode 100644 index 0000000..57fae2e --- /dev/null +++ b/DD_Clipboard_Searcher/DD_Clipboard_Searcher.vbproj.user @@ -0,0 +1,6 @@ + + + + ShowAllFiles + + \ No newline at end of file diff --git a/DD_Clipboard_Searcher/My Project/Application.Designer.vb b/DD_Clipboard_Searcher/My Project/Application.Designer.vb new file mode 100644 index 0000000..a89d677 --- /dev/null +++ b/DD_Clipboard_Searcher/My Project/Application.Designer.vb @@ -0,0 +1,38 @@ +'------------------------------------------------------------------------------ +' +' This code was generated by a tool. +' Runtime Version:4.0.30319.36366 +' +' 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 = Global.DD_Clipboard_Searcher.frmMain + End Sub + End Class +End Namespace diff --git a/DD_Clipboard_Searcher/My Project/Application.myapp b/DD_Clipboard_Searcher/My Project/Application.myapp new file mode 100644 index 0000000..ddd964a --- /dev/null +++ b/DD_Clipboard_Searcher/My Project/Application.myapp @@ -0,0 +1,10 @@ + + + true + frmMain + false + 0 + true + 0 + true + \ No newline at end of file diff --git a/DD_Clipboard_Searcher/My Project/AssemblyInfo.vb b/DD_Clipboard_Searcher/My Project/AssemblyInfo.vb new file mode 100644 index 0000000..c5998de --- /dev/null +++ b/DD_Clipboard_Searcher/My Project/AssemblyInfo.vb @@ -0,0 +1,35 @@ +Imports System +Imports System.Reflection +Imports System.Runtime.InteropServices + +' Allgemeine Informationen über eine Assembly werden über die folgenden +' Attribute gesteuert. Ändern Sie diese Attributwerte, um die Informationen zu ändern, +' die mit einer Assembly verknüpft sind. + +' Die Werte der Assemblyattribute überprüfen + + + + + + + + + + +'Die folgende GUID bestimmt die ID der Typbibliothek, wenn dieses Projekt für COM verfügbar gemacht wird + + +' Versionsinformationen für eine Assembly bestehen aus den folgenden vier Werten: +' +' Hauptversion +' Nebenversion +' Buildnummer +' Revision +' +' Sie können alle Werte angeben oder die standardmäßigen Build- und Revisionsnummern +' übernehmen, indem Sie "*" eingeben: +' + + + diff --git a/DD_Clipboard_Searcher/My Project/Resources.Designer.vb b/DD_Clipboard_Searcher/My Project/Resources.Designer.vb new file mode 100644 index 0000000..3902ed0 --- /dev/null +++ b/DD_Clipboard_Searcher/My Project/Resources.Designer.vb @@ -0,0 +1,103 @@ +'------------------------------------------------------------------------------ +' +' Dieser Code wurde von einem Tool generiert. +' Laufzeitversion:4.0.30319.36366 +' +' Änderungen an dieser Datei können falsches Verhalten verursachen und gehen verloren, wenn +' der Code erneut generiert wird. +' +'------------------------------------------------------------------------------ + +Option Strict On +Option Explicit On + +Imports System + +Namespace My.Resources + + 'Diese Klasse wurde von der StronglyTypedResourceBuilder automatisch generiert + '-Klasse über ein Tool wie ResGen oder Visual Studio automatisch generiert. + 'Um einen Member hinzuzufügen oder zu entfernen, bearbeiten Sie die .ResX-Datei und führen dann ResGen + 'mit der /str-Option erneut aus, oder Sie erstellen Ihr VS-Projekt neu. + ''' + ''' Eine stark typisierte Ressourcenklasse zum Suchen von lokalisierten Zeichenfolgen usw. + ''' + _ + Friend Module Resources + + Private resourceMan As Global.System.Resources.ResourceManager + + Private resourceCulture As Global.System.Globalization.CultureInfo + + ''' + ''' Gibt die zwischengespeicherte ResourceManager-Instanz zurück, die von dieser Klasse verwendet wird. + ''' + _ + 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("DD_Clipboard_Searcher.Resources", GetType(Resources).Assembly) + resourceMan = temp + End If + Return resourceMan + End Get + End Property + + ''' + ''' Überschreibt die CurrentUICulture-Eigenschaft des aktuellen Threads für alle + ''' Ressourcenzuordnungen, die diese stark typisierte Ressourcenklasse verwenden. + ''' + _ + Friend Property Culture() As Global.System.Globalization.CultureInfo + Get + Return resourceCulture + End Get + Set + resourceCulture = value + End Set + End Property + + ''' + ''' Sucht eine lokalisierte Ressource vom Typ System.Drawing.Bitmap. + ''' + Friend ReadOnly Property control_start_blue() As System.Drawing.Bitmap + Get + Dim obj As Object = ResourceManager.GetObject("control_start_blue", resourceCulture) + Return CType(obj,System.Drawing.Bitmap) + End Get + End Property + + ''' + ''' Sucht eine lokalisierte Ressource vom Typ System.Drawing.Bitmap. + ''' + Friend ReadOnly Property folder_Open_16xLG() As System.Drawing.Bitmap + Get + Dim obj As Object = ResourceManager.GetObject("folder_Open_16xLG", resourceCulture) + Return CType(obj,System.Drawing.Bitmap) + End Get + End Property + + ''' + ''' Sucht eine lokalisierte Ressource vom Typ System.Drawing.Bitmap. + ''' + Friend ReadOnly Property KeyDown_8461() As System.Drawing.Bitmap + Get + Dim obj As Object = ResourceManager.GetObject("KeyDown_8461", resourceCulture) + Return CType(obj,System.Drawing.Bitmap) + End Get + End Property + + ''' + ''' Sucht eine lokalisierte Ressource vom Typ System.Drawing.Bitmap. + ''' + Friend ReadOnly Property StatusAnnotations_Stop_16xLG() As System.Drawing.Bitmap + Get + Dim obj As Object = ResourceManager.GetObject("StatusAnnotations_Stop_16xLG", resourceCulture) + Return CType(obj,System.Drawing.Bitmap) + End Get + End Property + End Module +End Namespace diff --git a/DD_Clipboard_Searcher/My Project/Resources.resx b/DD_Clipboard_Searcher/My Project/Resources.resx new file mode 100644 index 0000000..8547f0a --- /dev/null +++ b/DD_Clipboard_Searcher/My Project/Resources.resx @@ -0,0 +1,133 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + ..\Resources\folder_Open_16xLG.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\KeyDown_8461.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\StatusAnnotations_Stop_16xLG.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\control_start_blue.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + \ No newline at end of file diff --git a/DD_Clipboard_Searcher/My Project/Settings.Designer.vb b/DD_Clipboard_Searcher/My Project/Settings.Designer.vb new file mode 100644 index 0000000..5d4c4e2 --- /dev/null +++ b/DD_Clipboard_Searcher/My Project/Settings.Designer.vb @@ -0,0 +1,85 @@ +'------------------------------------------------------------------------------ +' +' Dieser Code wurde von einem Tool generiert. +' Laufzeitversion:4.0.30319.36366 +' +' Änderungen an dieser Datei können falsches Verhalten verursachen und gehen verloren, wenn +' der Code erneut generiert wird. +' +'------------------------------------------------------------------------------ + +Option Strict On +Option Explicit On + + +Namespace My + + _ + Partial Friend NotInheritable Class MySettings + Inherits Global.System.Configuration.ApplicationSettingsBase + + Private Shared defaultInstance As MySettings = CType(Global.System.Configuration.ApplicationSettingsBase.Synchronized(New MySettings()),MySettings) + +#Region "Funktion zum automatischen Speichern von My.Settings" +#If _MyType = "WindowsForms" Then + Private Shared addedHandler As Boolean + + Private Shared addedHandlerLockObject As New Object + + _ + Private Shared Sub AutoSaveSettings(ByVal sender As Global.System.Object, ByVal e As Global.System.EventArgs) + If My.Application.SaveMySettingsOnExit Then + My.Settings.Save() + End If + End Sub +#End If +#End Region + + Public Shared ReadOnly Property [Default]() As MySettings + Get + +#If _MyType = "WindowsForms" Then + If Not addedHandler Then + SyncLock addedHandlerLockObject + If Not addedHandler Then + AddHandler My.Application.Shutdown, AddressOf AutoSaveSettings + addedHandler = True + End If + End SyncLock + End If +#End If + Return defaultInstance + End Get + End Property + + _ + Public Property WDSearch_maximized() As Boolean + Get + Return CType(Me("WDSearch_maximized"),Boolean) + End Get + Set + Me("WDSearch_maximized") = value + End Set + End Property + End Class +End Namespace + +Namespace My + + _ + Friend Module MySettingsProperty + + _ + Friend ReadOnly Property Settings() As Global.DD_Clipboard_Searcher.My.MySettings + Get + Return Global.DD_Clipboard_Searcher.My.MySettings.Default + End Get + End Property + End Module +End Namespace diff --git a/DD_Clipboard_Searcher/My Project/Settings.settings b/DD_Clipboard_Searcher/My Project/Settings.settings new file mode 100644 index 0000000..702cf78 --- /dev/null +++ b/DD_Clipboard_Searcher/My Project/Settings.settings @@ -0,0 +1,9 @@ + + + + + + False + + + \ No newline at end of file diff --git a/DD_Clipboard_Searcher/Resources/KeyDown_8461.png b/DD_Clipboard_Searcher/Resources/KeyDown_8461.png new file mode 100644 index 0000000..07a219c Binary files /dev/null and b/DD_Clipboard_Searcher/Resources/KeyDown_8461.png differ diff --git a/DD_Clipboard_Searcher/Resources/StatusAnnotations_Stop_16xLG.png b/DD_Clipboard_Searcher/Resources/StatusAnnotations_Stop_16xLG.png new file mode 100644 index 0000000..0e4a3ad Binary files /dev/null and b/DD_Clipboard_Searcher/Resources/StatusAnnotations_Stop_16xLG.png differ diff --git a/DD_Clipboard_Searcher/Resources/control_start_blue.png b/DD_Clipboard_Searcher/Resources/control_start_blue.png new file mode 100644 index 0000000..6f11fcb Binary files /dev/null and b/DD_Clipboard_Searcher/Resources/control_start_blue.png differ diff --git a/DD_Clipboard_Searcher/Resources/folder_Open_16xLG.png b/DD_Clipboard_Searcher/Resources/folder_Open_16xLG.png new file mode 100644 index 0000000..bc8ef0b Binary files /dev/null and b/DD_Clipboard_Searcher/Resources/folder_Open_16xLG.png differ diff --git a/DD_Clipboard_Searcher/bin/Debug/DD_Clipboard_Searcher.exe b/DD_Clipboard_Searcher/bin/Debug/DD_Clipboard_Searcher.exe new file mode 100644 index 0000000..a10697e Binary files /dev/null and b/DD_Clipboard_Searcher/bin/Debug/DD_Clipboard_Searcher.exe differ diff --git a/DD_Clipboard_Searcher/bin/Debug/DD_Clipboard_Searcher.exe.config b/DD_Clipboard_Searcher/bin/Debug/DD_Clipboard_Searcher.exe.config new file mode 100644 index 0000000..43615fd --- /dev/null +++ b/DD_Clipboard_Searcher/bin/Debug/DD_Clipboard_Searcher.exe.config @@ -0,0 +1,18 @@ + + + + +
+ + + + + + + + + False + + + + \ No newline at end of file diff --git a/DD_Clipboard_Searcher/bin/Debug/DD_Clipboard_Searcher.pdb b/DD_Clipboard_Searcher/bin/Debug/DD_Clipboard_Searcher.pdb new file mode 100644 index 0000000..fd1637e Binary files /dev/null and b/DD_Clipboard_Searcher/bin/Debug/DD_Clipboard_Searcher.pdb differ diff --git a/DD_Clipboard_Searcher/bin/Debug/DD_Clipboard_Searcher.vshost.exe b/DD_Clipboard_Searcher/bin/Debug/DD_Clipboard_Searcher.vshost.exe new file mode 100644 index 0000000..c0dfecc Binary files /dev/null and b/DD_Clipboard_Searcher/bin/Debug/DD_Clipboard_Searcher.vshost.exe differ diff --git a/DD_Clipboard_Searcher/bin/Debug/DD_Clipboard_Searcher.vshost.exe.config b/DD_Clipboard_Searcher/bin/Debug/DD_Clipboard_Searcher.vshost.exe.config new file mode 100644 index 0000000..43615fd --- /dev/null +++ b/DD_Clipboard_Searcher/bin/Debug/DD_Clipboard_Searcher.vshost.exe.config @@ -0,0 +1,18 @@ + + + + +
+ + + + + + + + + False + + + + \ No newline at end of file diff --git a/DD_Clipboard_Searcher/bin/Debug/DD_Clipboard_Searcher.vshost.exe.manifest b/DD_Clipboard_Searcher/bin/Debug/DD_Clipboard_Searcher.vshost.exe.manifest new file mode 100644 index 0000000..f96b1d6 --- /dev/null +++ b/DD_Clipboard_Searcher/bin/Debug/DD_Clipboard_Searcher.vshost.exe.manifest @@ -0,0 +1,11 @@ + + + + + + + + + + + diff --git a/DD_Clipboard_Searcher/bin/Debug/DD_Clipboard_Searcher.xml b/DD_Clipboard_Searcher/bin/Debug/DD_Clipboard_Searcher.xml new file mode 100644 index 0000000..8e9dee8 --- /dev/null +++ b/DD_Clipboard_Searcher/bin/Debug/DD_Clipboard_Searcher.xml @@ -0,0 +1,66 @@ + + + + +DD_Clipboard_Searcher + + + + + + Get all top-level window information + + List of window information objects + + + Get all child windows for the specific windows handle (hwnd). + + List of child windows for parent window + + + Callback function that does the work of enumerating top-level windows. + + Discovered Window handle + 1=keep going, 0=stop + + + Callback function that does the work of enumerating child windows. + + Discovered Window handle + 1=keep going, 0=stop + + + Build the ApiWindow object to hold information about the Window object. + + + + Gibt die zwischengespeicherte ResourceManager-Instanz zurück, die von dieser Klasse verwendet wird. + + + + Überschreibt die CurrentUICulture-Eigenschaft des aktuellen Threads für alle + Ressourcenzuordnungen, die diese stark typisierte Ressourcenklasse verwenden. + + + + Sucht eine lokalisierte Ressource vom Typ System.Drawing.Bitmap. + + + + Sucht eine lokalisierte Ressource vom Typ System.Drawing.Bitmap. + + + + Sucht eine lokalisierte Ressource vom Typ System.Drawing.Bitmap. + + + + Sucht eine lokalisierte Ressource vom Typ System.Drawing.Bitmap. + + + + Eine stark typisierte Ressourcenklasse zum Suchen von lokalisierten Zeichenfolgen usw. + + + + \ No newline at end of file diff --git a/DD_Clipboard_Searcher/bin/Debug/DD_LIB_Standards.dll b/DD_Clipboard_Searcher/bin/Debug/DD_LIB_Standards.dll new file mode 100644 index 0000000..3b9e71d Binary files /dev/null and b/DD_Clipboard_Searcher/bin/Debug/DD_LIB_Standards.dll differ diff --git a/DD_Clipboard_Searcher/bin/Debug/DD_LIB_Standards.pdb b/DD_Clipboard_Searcher/bin/Debug/DD_LIB_Standards.pdb new file mode 100644 index 0000000..2f3b37e Binary files /dev/null and b/DD_Clipboard_Searcher/bin/Debug/DD_LIB_Standards.pdb differ diff --git a/DD_Clipboard_Searcher/bin/Debug/DD_LIB_Standards.xml b/DD_Clipboard_Searcher/bin/Debug/DD_LIB_Standards.xml new file mode 100644 index 0000000..93a9bc3 --- /dev/null +++ b/DD_Clipboard_Searcher/bin/Debug/DD_LIB_Standards.xml @@ -0,0 +1,222 @@ + + + + +DD_LIB_Standards + + + + + + Konstruktor der Lizenz + + Name des Moduls + Gültigkeitsdatum der Lizenz + + + + Liefert oder setzt den Namen des Moduls für diese Lizenz + + + + + + + Liefert oder setzt das Gültigkeitsdatum der Lizenz für das Modul + + + + + + + Liefert ob die Lizenz schon abgelaufen ist + + + + + + + Liefert den Typend er Lizenz + + + + + + + Liefert die Anzahl der Profile + + + + + + + Returns the cached ResourceManager instance used by this class. + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + Konstruktor für die Lizenzen-Sammlung + + In Array übertragene Lizenzinformationen + + + + Fügt der Lizenz-Sammlung eine Lizenz hinzu + + Name des Moduls, für das eine Lizenz angelegt werden soll + Datum der Gültigkeit der Lizenz + + + + Liefert eine Lizenz an Hand des Modulnamens + + Name des zu suchenden Moduls + liefert ein Lizenzobjekt + + + + liefert eine Sammlung von Lizenzobjekten + + + + + + + liefert eine Lizenz an Hand des Modulnamens + + Name des zu suchenden Moduls + + + + + + Liefert oder setzt den Firmennamen des Lizenzeigentümers + + + + + + + Checks wether a file is existing in windream + + full filepath to the file + Returns true when file exists, false if not + + + + Returns a windream-type as Integer. + + Name of indexfield + Returns integer, which describes the type + + + + Creates a personified session + + Domainname as string + ServerName as string + UserName as string + Password as string + Returns true when file exists, false if not + + + + Creates a windream session with the actual user + + + + Konstruktor für den Lizenz-Manager + + Passwort zum Entschlüsseln des Lizenzkeys + verschlüsselter Lizenzkey + + + + Konstruktor für den Lizenz-Manager ohne License load + + Passwort zum Entschlüsseln des Lizenzkeys + + + + Lädt alle Lizenzen aus dem Lizenz-Array + + + + + Codiert eine Zeichenkette + + zu verschlüsselnde Zeichenkette + das zur Verschlüsselung verwendete Passwort + liefert eine verschlüsselte Zeichenkette + + + + Decodiert den verschlüsselten Lizenzkey + + verschlüsselter Lizenzkey + + + + + Zerlegt den entschlüsselten Lizenzkey + + entschlüsselter Lizenzkey + + + + + Liefert das Passwort zum Entschlüsseln des Lizenzschlüssels + + + + + + + Liefert eine Sammlung von Lizenzobjekten + + + + + + + Liefert oder setzt den Lizenzschlüssel + + + + + + + Creates a new version of the file + + full filepath to the file + Comment + Returns true when version was created exists, false if not + + + + Deletes a file in windream + + full filepath to the file + Returns true when file was deleted, false if not + + + + Passes indexvalues to a windream-file + + full filepath to the file + Indexname of Index + Value for indexing + _objecttype + Returns true when indexing was successfull, false if not + + + + \ No newline at end of file diff --git a/DD_Clipboard_Searcher/clsLicense.vb b/DD_Clipboard_Searcher/clsLicense.vb new file mode 100644 index 0000000..22fd180 --- /dev/null +++ b/DD_Clipboard_Searcher/clsLicense.vb @@ -0,0 +1,48 @@ +Imports DD_LIB_Standards +Public Class clsLicense + Private Shared lic_string As String + Private Shared Sub Get_License(CLIENT_ID As Integer) + Dim sql As String = String.Format("SELECT LICENSE_DDCBSEARCHER FROM TBDD_CLIENT WHERE GUID = {0}", CLIENT_ID) + + lic_string = clsDatabase.Execute_Scalar(sql) + End Sub + Public Shared Sub Refresh_Licence(CLIENT_ID As Integer) + Try + Dim _lizenzManager = New clsLicenseManager("#DigitalData35452!#", "") + Get_License(CLIENT_ID) + + If lic_string = "" Then + LICENSE_COUNT = 0 + LICENSE_DATE = "1900-01-01" + ERROR_INIT = "NO LICENSE" + Exit Sub + End If + + Dim licString = _lizenzManager.DecodeLicenseKey(lic_string) + Dim split() = licString.ToString.Split("#") + + If lic_string <> "" Then + LICENSE_COUNT = split(0) + LICENSE_DATE = CDate(split(1)) + End If + + If CDate(split(1)) < CDate(Now.ToShortDateString) Then + MsgBox("Your license evaluated!" & vbNewLine & "Last valid date: " & split(1) & vbNewLine & "Please contact Digital Data.", MsgBoxStyle.Exclamation) + LICENSE_EXPIRED = True + LICENSE_COUNT = 0 + ERROR_INIT = "NO LICENSE" + End If + Catch ex As Exception + MsgBox(ex.Message, MsgBoxStyle.Exclamation, "Error in licensemanager:") + End Try + End Sub + + Public Shared Function license_is_Valid() + If LICENSE_EXPIRED Then + MsgBox("Your license has expired!" & vbNewLine & "Last valid date: " & LICENSE_DATE & vbNewLine & "Please contact Digital Data!", MsgBoxStyle.Exclamation) + Return False + Else : Return True + + End If + End Function +End Class diff --git a/DD_Clipboard_Searcher/clsSearch.vb b/DD_Clipboard_Searcher/clsSearch.vb new file mode 100644 index 0000000..cc5a2eb --- /dev/null +++ b/DD_Clipboard_Searcher/clsSearch.vb @@ -0,0 +1,147 @@ +Imports DD_LIB_Standards +Imports System.IO +Imports System.Text + +Public Class clsSearch + + + ''Fenster position ermitteln/auslesen + 'Private Declare Function FindWindow Lib "user32" Alias "FindWindowA" (ByVal lpClassName As String, ByVal lpWindowName As String) As Integer + Private Declare Function GetWindowRect Lib "user32.dll" (ByVal hWnd As IntPtr, ByRef lpRect As RECT) As Int32 + Private Declare Function ShowWindow Lib "user32" (ByVal handle As IntPtr, ByVal nCmdShow As Integer) As Integer + + Private Structure RECT + Dim Left As Integer + Dim Top As Integer + Dim Right As Integer + Dim Bottom As Integer + End Structure + + Private Shared fileContents As String + Public Shared Function RUN_WD_SEARCH(BaseSearch As String) + Try + Dim extension = Path.GetExtension(BaseSearch) + Dim windream_temp_search As String = "" + If IO.File.Exists(BaseSearch) = False Then + ClassLogger.Add("Die Windream-Suche existiert nicht oder ist nicht zugreifbar!", True) + MsgBox("Die Windream-Suche existiert nicht oder ist nicht zugreifbar!", MsgBoxStyle.Critical) + Return Nothing + End If + + fileContents = "" + 'Eine tempfile generieren + Dim tempFilename1 = My.Computer.FileSystem.GetTempFileName() + 'Nur den Filenamen ohne Erweiterung + Dim tempName = Path.GetFileNameWithoutExtension(tempFilename1) + 'tempfile löschen + If My.Computer.FileSystem.FileExists(tempFilename1) Then + My.Computer.FileSystem.DeleteFile(tempFilename1) + End If + + Dim temppath = Path.GetTempPath + Dim EncodingFormat As Encoding + + If WD_UNICODE = True Then + EncodingFormat = Encoding.GetEncoding(1252) '1252 + If LogErrorsOnly = False Then ClassLogger.Add(" ...Unicode is used (Encoding.GetEncoding(1252))", False) + Else + If LogErrorsOnly = False Then ClassLogger.Add(" ...UTF8 (Encoding.GetEncoding(65001))", False) + EncodingFormat = Encoding.GetEncoding(65001) + End If + + If LogErrorsOnly = False Then ClassLogger.Add(" ...ReadAlltext: " & BaseSearch, False) + fileContents = My.Computer.FileSystem.ReadAllText(BaseSearch, EncodingFormat) ', System.Text.Encoding.Unicode + If LogErrorsOnly = False Then ClassLogger.Add(" ...fileContents geladen", False) + fileContents = fileContents.Replace("Í", "Ö") + fileContents = fileContents.Replace("@Clipboard", CURR_MATCH_RESULT) + + Try + 'Die windream File zusammensetzen + windream_temp_search = temppath & tempName & extension + Try + 'Die File schreiben + My.Computer.FileSystem.WriteAllText(windream_temp_search, fileContents, False, EncodingFormat) + If LogErrorsOnly = False Then ClassLogger.Add(" ...wrote Text to windream_temp_search: " & windream_temp_search, False) + ' XML-Datei öffnen und laden + Dim Stream As New IO.StreamReader(CStr(windream_temp_search), EncodingFormat) + Dim Reader As New System.Xml.XmlTextReader(Stream) + + ' XML-Datei initialisieren + Dim xml As New System.Xml.XmlDocument() + ' XML-Datei öffnen und laden + xml.Load(Reader) + Reader.Close() + xml.Save(windream_temp_search) + If LogErrorsOnly = False Then ClassLogger.Add(" ...Xml Generiert: " & windream_temp_search, False) + Catch ex As Exception + ClassLogger.Add("TempFile could not be created: " & ex.Message, True) + MsgBox(ex.Message, MsgBoxStyle.Critical, "Unerwarteter Fehler in Write XmlSearch:") + End Try + + CURRENT_WD_TEMPSEARCH = windream_temp_search + TEMP_FILES.Add(CURRENT_WD_TEMPSEARCH) + Try + Dim myhWnd As IntPtr + Dim p As New Process() + p.StartInfo.FileName = windream_temp_search + If My.Settings.WDSearch_maximized = True Then + p.StartInfo.WindowStyle = ProcessWindowStyle.Maximized + Else + p.StartInfo.WindowStyle = ProcessWindowStyle.Normal + End If + p.Start() + + myhWnd = p.MainWindowHandle + Threading.Thread.Sleep(1000) + Dim rctMain As RECT + GetWindowRect(p.MainWindowHandle, rctMain) + If LogErrorsOnly = False Then + ClassLogger.Add(" ...Top-Position: " & rctMain.Top.ToString, False) + ClassLogger.Add(" ...Left-Position: " & rctMain.Left.ToString, False) + ClassLogger.Add(" ...Right-Position: " & rctMain.Right.ToString, False) + ClassLogger.Add(" ...Bottom-Position: " & rctMain.Bottom.ToString, False) + End If + Catch ex As Exception + MsgBox(ex.Message, MsgBoxStyle.Critical, "Unexpected error in Ausführen der windream-Suche:") + ClassLogger.Add("Unexpected error while executing search: " & ex.Message, True) + Return "Unexpected error while executing search" + End Try + Dim psList() As Process + Try + psList = Process.GetProcesses() + + For Each p As Process In psList + Console.WriteLine(p.Id.ToString() + " " + p.ProcessName) + If p.ProcessName.Contains("indream.Find") Then + AppActivate(p.Id) + If My.Settings.WDSearch_maximized = False Then + Dim rctMain As RECT + GetWindowRect(p.MainWindowHandle, rctMain) + If rctMain.Left = 0 Or rctMain.Right = 0 Then + ShowWindow(p.MainWindowHandle, 3) ' SW_MAXIMIZE + End If + End If + ' SetForeGroundWindow( p.MainWindowHandle) + End If + + Next p + + Catch ex As Exception + ClassLogger.Add("Unexpected error while Setting foreground: " & ex.Message, True) + End Try + Return "" + Catch ex As Exception + ClassLogger.Add("Unexpected error in Create Search: " & ex.Message, True) + MsgBox("Error in Create Search:" & vbNewLine & ex.Message, MsgBoxStyle.Critical) + Return "Unexpected error in Create Search" + End Try + + Catch ex As Exception + ClassLogger.Add("Unexpected error in RUN_WD_SEARCH: " & ex.Message, True) + MsgBox("Error in RUN_WD_SEARCH:" & vbNewLine & ex.Message, MsgBoxStyle.Critical) + Return "Unerwarteter Unexpected error in RUN_WD_SEARCH" + End Try + + + End Function +End Class diff --git a/DD_Clipboard_Searcher/clsWINDOWSApi.vb b/DD_Clipboard_Searcher/clsWINDOWSApi.vb new file mode 100644 index 0000000..2787ccd --- /dev/null +++ b/DD_Clipboard_Searcher/clsWINDOWSApi.vb @@ -0,0 +1,68 @@ +Public Class clsWINDOWSApi + Private Declare Function GetForegroundWindow Lib "user32.dll" Alias "GetForegroundWindow" () As IntPtr + Private Declare Auto Function GetWindowText Lib "user32.dll" (ByVal hWnd As System.IntPtr, ByVal lpString As System.Text.StringBuilder, ByVal cch As Integer) As Integer + Private Declare Function GetWindowThreadProcessId Lib "user32.dll" (ByVal hwnd As IntPtr, ByRef lpdwProcessID As Integer) As Integer + Private Declare Function GetWindowText Lib "user32.dll" Alias "GetWindowTextA" (ByVal hWnd As IntPtr, ByVal WinTitle As String, ByVal MaxLength As Integer) As Integer + Private Declare Function GetWindowTextLength Lib "user32.dll" Alias "GetWindowTextLengthA" (ByVal hwnd As Int32) As Integer + + Private Shared Function GetClassName(ByVal hWnd As System.IntPtr, _ + ByVal lpClassName As System.Text.StringBuilder, _ + ByVal nMaxCount As Integer) As Integer + ' Leave function empty + End Function + Public Shared Function GetCaption() As String + Dim Caption As New System.Text.StringBuilder(256) + Dim hWnd As IntPtr = GetForegroundWindow() + Dim pid As Integer = 0 + GetWindowThreadProcessId(hWnd, pid) + If pid = 0 Then Exit Function + Return Caption.ToString() + End Function + Public Shared Function IsRelevantWindow(windowname As String) + Try + Dim enumerator1 As New clsWindowApi + 'Jedes Formularwindow durchlaufen + For Each top As clsWindowApi.ApiWindow In enumerator1.GetTopLevelWindows() + If LogErrorsOnly = False Then ClassLogger.Add(" ... top-window Name: " & top.MainWindowTitle, False) + If top.MainWindowTitle.Contains(windowname) Or top.MainWindowTitle.ToLower = windowname.ToLower Then + Console.WriteLine(top.MainWindowTitle) + Return False + End If + Next top + Catch ex As Exception + MsgBox("Error in IsRelevantWindowt:" & vbNewLine & ex.Message, MsgBoxStyle.Critical) + ClassLogger.Add(">> Error in IsRelevantWindow:" & ex.Message, False) + Return False + End Try + End Function + Private Shared m_LastHwnd As Long + Public Shared Sub TEST() + '—– Get the Handle to the Current Forground Window —– + Dim hWnd As IntPtr = GetForegroundWindow() + If hWnd = IntPtr.Zero Then Exit Sub + '—– Find the Length of the Window’s Title —– + Dim TitleLength As Int32 + TitleLength = GetWindowTextLength(hWnd) + '—– Find the Window’s Title —– + Dim WindowTitle As String = StrDup(TitleLength + 1, "*") + GetWindowText(hWnd, WindowTitle, TitleLength + 1) + '—– Find the PID of the Application that Owns the Window —– + Dim pid As Integer = 0 + GetWindowThreadProcessId(hWnd, pid) + If pid = 0 Then Exit Sub + '—– Get the actual PROCESS from the process ID —– + Dim proc As Process = Process.GetProcessById(pid) + If proc Is Nothing Then Exit Sub + Dim msg = pid.ToString & vbNewLine + + msg &= vbNewLine & "Procname: " & proc.ProcessName + + msg &= vbNewLine & "MainWindowTitle: " & proc.MainWindowTitle + + msg &= vbNewLine & "WindowTitle: " & WindowTitle + + msg &= vbNewLine & TitleLength.ToString + MsgBox(msg) + End Sub + +End Class diff --git a/DD_Clipboard_Searcher/clsWindowApivb.vb b/DD_Clipboard_Searcher/clsWindowApivb.vb new file mode 100644 index 0000000..caf5c83 --- /dev/null +++ b/DD_Clipboard_Searcher/clsWindowApivb.vb @@ -0,0 +1,179 @@ +Imports System.Data +Imports System.Runtime.InteropServices +Imports System.Text +Imports System.Collections.Generic +Public Class clsWindowApi + Public Class ApiWindow + Public MainWindowTitle As String = "" + Public ClassName As String = "" + Public hWnd As Int32 + End Class + + Private Delegate Function EnumCallBackDelegate(ByVal hwnd As Integer, ByVal lParam As Integer) As Integer + + ' Top-level windows. + Private Declare Function EnumWindows Lib "user32" _ + (ByVal lpEnumFunc As EnumCallBackDelegate, ByVal lParam As Integer) As Integer + + ' Child windows. + Private Declare Function EnumChildWindows Lib "user32" _ + (ByVal hWndParent As Integer, ByVal lpEnumFunc As EnumCallBackDelegate, ByVal lParam As Integer) As Integer + + ' Get the window class. + Private Declare Function GetClassName _ + Lib "user32" Alias "GetClassNameA" _ + (ByVal hwnd As Integer, ByVal lpClassName As StringBuilder, ByVal nMaxCount As Integer) As Integer + + ' Test if the window is visible--only get visible ones. + Private Declare Function IsWindowVisible Lib "user32" _ + (ByVal hwnd As Integer) As Integer + + ' Test if the window's parent--only get the one's without parents. + Private Declare Function GetParent Lib "user32" _ + (ByVal hwnd As Integer) As Integer + + ' Get window text length signature. + Private Declare Function SendMessage _ + Lib "user32" Alias "SendMessageA" _ + (ByVal hwnd As Int32, ByVal wMsg As Int32, ByVal wParam As Int32, ByVal lParam As Int32) As Int32 + + ' Get window text signature. + Private Declare Function SendMessage _ + Lib "user32" Alias "SendMessageA" _ + (ByVal hwnd As Int32, ByVal wMsg As Int32, ByVal wParam As Int32, ByVal lParam As StringBuilder) As Int32 + + Private _listChildren As New List(Of ApiWindow) + Private _listTopLevel As New List(Of ApiWindow) + + Private _topLevelClass As String = "" + Private _childClass As String = "" + + ''' + ''' Get all top-level window information + ''' + ''' List of window information objects + Public Overloads Function GetTopLevelWindows() As List(Of ApiWindow) + + EnumWindows(AddressOf EnumWindowProc, &H0) + + Return _listTopLevel + + End Function + + Public Overloads Function GetTopLevelWindows(ByVal className As String) As List(Of ApiWindow) + + _topLevelClass = className + + Return Me.GetTopLevelWindows() + + End Function + + ''' + ''' Get all child windows for the specific windows handle (hwnd). + ''' + ''' List of child windows for parent window + Public Overloads Function GetChildWindows(ByVal hwnd As Int32) As List(Of ApiWindow) + + ' Clear the window list. + _listChildren = New List(Of ApiWindow) + + ' Start the enumeration process. + EnumChildWindows(hwnd, AddressOf EnumChildWindowProc, &H0) + + ' Return the children list when the process is completed. + Return _listChildren + + End Function + + Public Overloads Function GetChildWindows(ByVal hwnd As Int32, ByVal childClass As String) As List(Of ApiWindow) + + ' Set the search + _childClass = childClass + + Return Me.GetChildWindows(hwnd) + + End Function + + ''' + ''' Callback function that does the work of enumerating top-level windows. + ''' + ''' Discovered Window handle + ''' 1=keep going, 0=stop + Private Function EnumWindowProc(ByVal hwnd As Int32, ByVal lParam As Int32) As Int32 + + ' Eliminate windows that are not top-level. + If GetParent(hwnd) = 0 AndAlso CBool(IsWindowVisible(hwnd)) Then + + ' Get the window title / class name. + Dim window As ApiWindow = GetWindowIdentification(hwnd) + + ' Match the class name if searching for a specific window class. + If _topLevelClass.Length = 0 OrElse window.ClassName.ToLower() = _topLevelClass.ToLower() Then + _listTopLevel.Add(window) + End If + + End If + + ' To continue enumeration, return True (1), and to stop enumeration + ' return False (0). + ' When 1 is returned, enumeration continues until there are no + ' more windows left. + + Return 1 + + End Function + + ''' + ''' Callback function that does the work of enumerating child windows. + ''' + ''' Discovered Window handle + ''' 1=keep going, 0=stop + Private Function EnumChildWindowProc(ByVal hwnd As Int32, ByVal lParam As Int32) As Int32 + + Dim window As ApiWindow = GetWindowIdentification(hwnd) + + ' Attempt to match the child class, if one was specified, otherwise + ' enumerate all the child windows. + If _childClass.Length = 0 OrElse window.ClassName.ToLower() = _childClass.ToLower() Then + _listChildren.Add(window) + End If + + Return 1 + + End Function + + ''' + ''' Build the ApiWindow object to hold information about the Window object. + ''' + Private Function GetWindowIdentification(ByVal hwnd As Integer) As ApiWindow + + Const WM_GETTEXT As Int32 = &HD + Const WM_GETTEXTLENGTH As Int32 = &HE + + Dim window As New ApiWindow() + + Dim title As New StringBuilder() + + ' Get the size of the string required to hold the window title. + Dim size As Int32 = SendMessage(hwnd, WM_GETTEXTLENGTH, 0, 0) + + ' If the return is 0, there is no title. + If size > 0 Then + title = New StringBuilder(size + 1) + + SendMessage(hwnd, WM_GETTEXT, title.Capacity, title) + End If + + ' Get the class name for the window. + Dim classBuilder As New StringBuilder(64) + GetClassName(hwnd, classBuilder, 64) + + ' Set the properties for the ApiWindow object. + window.ClassName = classBuilder.ToString() + window.MainWindowTitle = title.ToString() + window.hWnd = hwnd + + Return window + + End Function +End Class diff --git a/DD_Clipboard_Searcher/frmConfig_Basic.Designer.vb b/DD_Clipboard_Searcher/frmConfig_Basic.Designer.vb new file mode 100644 index 0000000..8cd13d7 --- /dev/null +++ b/DD_Clipboard_Searcher/frmConfig_Basic.Designer.vb @@ -0,0 +1,319 @@ + _ +Partial Class frmConfig_Basic + Inherits System.Windows.Forms.Form + + 'Das Formular überschreibt den Löschvorgang, um die Komponentenliste zu bereinigen. + _ + 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 + + 'Wird vom Windows Form-Designer benötigt. + Private components As System.ComponentModel.IContainer + + 'Hinweis: Die folgende Prozedur ist für den Windows Form-Designer erforderlich. + 'Das Bearbeiten ist mit dem Windows Form-Designer möglich. + 'Das Bearbeiten mit dem Code-Editor ist nicht möglich. + _ + Private Sub InitializeComponent() + Dim resources As System.ComponentModel.ComponentResourceManager = New System.ComponentModel.ComponentResourceManager(GetType(frmConfig_Basic)) + Me.TabControl1 = New System.Windows.Forms.TabControl() + Me.TabPage1 = New System.Windows.Forms.TabPage() + Me.chkbxUserAut = New System.Windows.Forms.CheckBox() + Me.Label5 = New System.Windows.Forms.Label() + Me.cmbDatenbank = New System.Windows.Forms.ComboBox() + Me.Label4 = New System.Windows.Forms.Label() + Me.Label1 = New System.Windows.Forms.Label() + Me.Label2 = New System.Windows.Forms.Label() + Me.Label3 = New System.Windows.Forms.Label() + Me.txtActualConnection = New System.Windows.Forms.TextBox() + Me.txtServer = New System.Windows.Forms.TextBox() + Me.txtUser = New System.Windows.Forms.TextBox() + Me.txtPasswort = New System.Windows.Forms.TextBox() + Me.BtnConnect = New System.Windows.Forms.Button() + Me.TabPage2 = New System.Windows.Forms.TabPage() + Me.chkWDMaximized = New System.Windows.Forms.CheckBox() + Me.chkLogErrorsOnly = New System.Windows.Forms.CheckBox() + Me.Button1 = New System.Windows.Forms.Button() + Me.btnApplicationFolder = New System.Windows.Forms.Button() + Me.LinkLabel1 = New System.Windows.Forms.LinkLabel() + Me.TabControl1.SuspendLayout() + Me.TabPage1.SuspendLayout() + Me.TabPage2.SuspendLayout() + Me.SuspendLayout() + ' + 'TabControl1 + ' + Me.TabControl1.Controls.Add(Me.TabPage1) + Me.TabControl1.Controls.Add(Me.TabPage2) + Me.TabControl1.Dock = System.Windows.Forms.DockStyle.Fill + Me.TabControl1.Location = New System.Drawing.Point(0, 0) + Me.TabControl1.Name = "TabControl1" + Me.TabControl1.SelectedIndex = 0 + Me.TabControl1.Size = New System.Drawing.Size(676, 186) + Me.TabControl1.TabIndex = 1 + ' + 'TabPage1 + ' + Me.TabPage1.Controls.Add(Me.chkbxUserAut) + Me.TabPage1.Controls.Add(Me.Label5) + Me.TabPage1.Controls.Add(Me.cmbDatenbank) + Me.TabPage1.Controls.Add(Me.Label4) + Me.TabPage1.Controls.Add(Me.Label1) + Me.TabPage1.Controls.Add(Me.Label2) + Me.TabPage1.Controls.Add(Me.Label3) + Me.TabPage1.Controls.Add(Me.txtActualConnection) + Me.TabPage1.Controls.Add(Me.txtServer) + Me.TabPage1.Controls.Add(Me.txtUser) + Me.TabPage1.Controls.Add(Me.txtPasswort) + Me.TabPage1.Controls.Add(Me.BtnConnect) + Me.TabPage1.Location = New System.Drawing.Point(4, 22) + Me.TabPage1.Name = "TabPage1" + Me.TabPage1.Padding = New System.Windows.Forms.Padding(3) + Me.TabPage1.Size = New System.Drawing.Size(668, 160) + Me.TabPage1.TabIndex = 0 + Me.TabPage1.Text = "Datenbank-Verbindung" + Me.TabPage1.UseVisualStyleBackColor = True + ' + 'chkbxUserAut + ' + Me.chkbxUserAut.AutoSize = True + Me.chkbxUserAut.ImeMode = System.Windows.Forms.ImeMode.NoControl + Me.chkbxUserAut.Location = New System.Drawing.Point(510, 36) + Me.chkbxUserAut.Name = "chkbxUserAut" + Me.chkbxUserAut.Size = New System.Drawing.Size(155, 17) + Me.chkbxUserAut.TabIndex = 47 + Me.chkbxUserAut.Text = "Windows-Authentifizierung" + Me.chkbxUserAut.UseVisualStyleBackColor = True + ' + 'Label5 + ' + Me.Label5.AutoSize = True + Me.Label5.ImeMode = System.Windows.Forms.ImeMode.NoControl + Me.Label5.Location = New System.Drawing.Point(5, 115) + Me.Label5.Name = "Label5" + Me.Label5.Size = New System.Drawing.Size(138, 13) + Me.Label5.TabIndex = 46 + Me.Label5.Text = "Aktueller ConnectionString:" + ' + 'cmbDatenbank + ' + Me.cmbDatenbank.FormattingEnabled = True + Me.cmbDatenbank.Location = New System.Drawing.Point(8, 82) + Me.cmbDatenbank.Name = "cmbDatenbank" + Me.cmbDatenbank.Size = New System.Drawing.Size(252, 21) + Me.cmbDatenbank.TabIndex = 39 + ' + 'Label4 + ' + Me.Label4.AutoSize = True + Me.Label4.ImeMode = System.Windows.Forms.ImeMode.NoControl + Me.Label4.Location = New System.Drawing.Point(5, 62) + Me.Label4.Name = "Label4" + Me.Label4.Size = New System.Drawing.Size(63, 13) + Me.Label4.TabIndex = 44 + Me.Label4.Text = "Datenbank:" + ' + 'Label1 + ' + Me.Label1.AutoSize = True + Me.Label1.ImeMode = System.Windows.Forms.ImeMode.NoControl + Me.Label1.Location = New System.Drawing.Point(5, 14) + Me.Label1.Name = "Label1" + Me.Label1.Size = New System.Drawing.Size(74, 13) + Me.Label1.TabIndex = 41 + Me.Label1.Text = "Server-Name:" + ' + 'Label2 + ' + Me.Label2.AutoSize = True + Me.Label2.ImeMode = System.Windows.Forms.ImeMode.NoControl + Me.Label2.Location = New System.Drawing.Point(299, 14) + Me.Label2.Name = "Label2" + Me.Label2.Size = New System.Drawing.Size(80, 13) + Me.Label2.TabIndex = 42 + Me.Label2.Text = "Benutzername:" + ' + 'Label3 + ' + Me.Label3.AutoSize = True + Me.Label3.ImeMode = System.Windows.Forms.ImeMode.NoControl + Me.Label3.Location = New System.Drawing.Point(423, 14) + Me.Label3.Name = "Label3" + Me.Label3.Size = New System.Drawing.Size(55, 13) + Me.Label3.TabIndex = 43 + Me.Label3.Text = "Passwort:" + ' + 'txtActualConnection + ' + Me.txtActualConnection.Anchor = CType(((System.Windows.Forms.AnchorStyles.Top Or System.Windows.Forms.AnchorStyles.Left) _ + Or System.Windows.Forms.AnchorStyles.Right), System.Windows.Forms.AnchorStyles) + Me.txtActualConnection.BackColor = System.Drawing.Color.WhiteSmoke + Me.txtActualConnection.Location = New System.Drawing.Point(8, 131) + Me.txtActualConnection.Name = "txtActualConnection" + Me.txtActualConnection.ReadOnly = True + Me.txtActualConnection.Size = New System.Drawing.Size(528, 21) + Me.txtActualConnection.TabIndex = 45 + ' + 'txtServer + ' + Me.txtServer.ForeColor = System.Drawing.SystemColors.WindowText + Me.txtServer.Location = New System.Drawing.Point(8, 34) + Me.txtServer.Name = "txtServer" + Me.txtServer.Size = New System.Drawing.Size(288, 21) + Me.txtServer.TabIndex = 36 + ' + 'txtUser + ' + Me.txtUser.ForeColor = System.Drawing.SystemColors.WindowText + Me.txtUser.Location = New System.Drawing.Point(302, 34) + Me.txtUser.Name = "txtUser" + Me.txtUser.Size = New System.Drawing.Size(118, 21) + Me.txtUser.TabIndex = 37 + ' + 'txtPasswort + ' + Me.txtPasswort.ForeColor = System.Drawing.SystemColors.WindowText + Me.txtPasswort.Location = New System.Drawing.Point(426, 34) + Me.txtPasswort.Name = "txtPasswort" + Me.txtPasswort.Size = New System.Drawing.Size(64, 21) + Me.txtPasswort.TabIndex = 38 + Me.txtPasswort.UseSystemPasswordChar = True + ' + 'BtnConnect + ' + Me.BtnConnect.Image = CType(resources.GetObject("BtnConnect.Image"), System.Drawing.Image) + Me.BtnConnect.ImageAlign = System.Drawing.ContentAlignment.MiddleLeft + Me.BtnConnect.ImeMode = System.Windows.Forms.ImeMode.NoControl + Me.BtnConnect.Location = New System.Drawing.Point(302, 82) + Me.BtnConnect.Name = "BtnConnect" + Me.BtnConnect.Size = New System.Drawing.Size(253, 25) + Me.BtnConnect.TabIndex = 40 + Me.BtnConnect.Text = "Verbindung zur Datenbank herstellen" + Me.BtnConnect.TextAlign = System.Drawing.ContentAlignment.MiddleRight + Me.BtnConnect.UseVisualStyleBackColor = True + ' + 'TabPage2 + ' + Me.TabPage2.Controls.Add(Me.chkWDMaximized) + Me.TabPage2.Controls.Add(Me.chkLogErrorsOnly) + Me.TabPage2.Controls.Add(Me.Button1) + Me.TabPage2.Controls.Add(Me.btnApplicationFolder) + Me.TabPage2.Controls.Add(Me.LinkLabel1) + Me.TabPage2.Location = New System.Drawing.Point(4, 22) + Me.TabPage2.Name = "TabPage2" + Me.TabPage2.Padding = New System.Windows.Forms.Padding(3) + Me.TabPage2.Size = New System.Drawing.Size(668, 160) + Me.TabPage2.TabIndex = 1 + Me.TabPage2.Text = "Weitere Einstellungen" + Me.TabPage2.UseVisualStyleBackColor = True + ' + 'chkWDMaximized + ' + Me.chkWDMaximized.AutoSize = True + Me.chkWDMaximized.ImeMode = System.Windows.Forms.ImeMode.NoControl + Me.chkWDMaximized.Location = New System.Drawing.Point(8, 40) + Me.chkWDMaximized.Name = "chkWDMaximized" + Me.chkWDMaximized.Size = New System.Drawing.Size(162, 17) + Me.chkWDMaximized.TabIndex = 8 + Me.chkWDMaximized.Text = "windream-search maximiert?" + Me.chkWDMaximized.UseVisualStyleBackColor = True + ' + 'chkLogErrorsOnly + ' + Me.chkLogErrorsOnly.AutoSize = True + Me.chkLogErrorsOnly.ImeMode = System.Windows.Forms.ImeMode.NoControl + Me.chkLogErrorsOnly.Location = New System.Drawing.Point(8, 17) + Me.chkLogErrorsOnly.Name = "chkLogErrorsOnly" + Me.chkLogErrorsOnly.Size = New System.Drawing.Size(100, 17) + Me.chkLogErrorsOnly.TabIndex = 7 + Me.chkLogErrorsOnly.Text = "Log Errors Only" + Me.chkLogErrorsOnly.UseVisualStyleBackColor = True + ' + 'Button1 + ' + Me.Button1.Image = Global.DD_Clipboard_Searcher.My.Resources.Resources.folder_Open_16xLG + Me.Button1.ImageAlign = System.Drawing.ContentAlignment.MiddleLeft + Me.Button1.ImeMode = System.Windows.Forms.ImeMode.NoControl + Me.Button1.Location = New System.Drawing.Point(462, 71) + Me.Button1.Name = "Button1" + Me.Button1.Size = New System.Drawing.Size(198, 23) + Me.Button1.TabIndex = 6 + Me.Button1.Text = "Open Log-Folder" + Me.Button1.TextAlign = System.Drawing.ContentAlignment.MiddleRight + Me.Button1.UseVisualStyleBackColor = True + ' + 'btnApplicationFolder + ' + Me.btnApplicationFolder.Image = Global.DD_Clipboard_Searcher.My.Resources.Resources.folder_Open_16xLG + Me.btnApplicationFolder.ImageAlign = System.Drawing.ContentAlignment.MiddleLeft + Me.btnApplicationFolder.ImeMode = System.Windows.Forms.ImeMode.NoControl + Me.btnApplicationFolder.Location = New System.Drawing.Point(462, 45) + Me.btnApplicationFolder.Name = "btnApplicationFolder" + Me.btnApplicationFolder.Size = New System.Drawing.Size(198, 23) + Me.btnApplicationFolder.TabIndex = 2 + Me.btnApplicationFolder.Text = "Open AppFolder User" + Me.btnApplicationFolder.TextAlign = System.Drawing.ContentAlignment.MiddleRight + Me.btnApplicationFolder.UseVisualStyleBackColor = True + ' + 'LinkLabel1 + ' + Me.LinkLabel1.AutoSize = True + Me.LinkLabel1.Font = New System.Drawing.Font("Segoe UI", 9.75!) + Me.LinkLabel1.ImeMode = System.Windows.Forms.ImeMode.NoControl + Me.LinkLabel1.Location = New System.Drawing.Point(459, 16) + Me.LinkLabel1.Name = "LinkLabel1" + Me.LinkLabel1.Size = New System.Drawing.Size(201, 17) + Me.LinkLabel1.TabIndex = 1 + Me.LinkLabel1.TabStop = True + Me.LinkLabel1.Text = "Link zu Support-Tool Digital Data" + ' + 'frmConfig_Basic + ' + Me.AutoScaleDimensions = New System.Drawing.SizeF(6.0!, 13.0!) + Me.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font + Me.ClientSize = New System.Drawing.Size(676, 186) + Me.Controls.Add(Me.TabControl1) + Me.Font = New System.Drawing.Font("Tahoma", 8.25!, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, CType(0, Byte)) + Me.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog + Me.Icon = CType(resources.GetObject("$this.Icon"), System.Drawing.Icon) + Me.MaximizeBox = False + Me.MinimizeBox = False + Me.Name = "frmConfig_Basic" + Me.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen + Me.Text = "Grundeinstellungen" + Me.TabControl1.ResumeLayout(False) + Me.TabPage1.ResumeLayout(False) + Me.TabPage1.PerformLayout() + Me.TabPage2.ResumeLayout(False) + Me.TabPage2.PerformLayout() + Me.ResumeLayout(False) + + End Sub + Friend WithEvents TabControl1 As System.Windows.Forms.TabControl + Friend WithEvents TabPage1 As System.Windows.Forms.TabPage + Friend WithEvents chkbxUserAut As System.Windows.Forms.CheckBox + Friend WithEvents Label5 As System.Windows.Forms.Label + Friend WithEvents cmbDatenbank As System.Windows.Forms.ComboBox + Friend WithEvents Label4 As System.Windows.Forms.Label + Friend WithEvents Label1 As System.Windows.Forms.Label + Friend WithEvents Label2 As System.Windows.Forms.Label + Friend WithEvents Label3 As System.Windows.Forms.Label + Friend WithEvents txtActualConnection As System.Windows.Forms.TextBox + Friend WithEvents txtServer As System.Windows.Forms.TextBox + Friend WithEvents txtUser As System.Windows.Forms.TextBox + Friend WithEvents txtPasswort As System.Windows.Forms.TextBox + Friend WithEvents BtnConnect As System.Windows.Forms.Button + Friend WithEvents TabPage2 As System.Windows.Forms.TabPage + Friend WithEvents chkWDMaximized As System.Windows.Forms.CheckBox + Friend WithEvents chkLogErrorsOnly As System.Windows.Forms.CheckBox + Friend WithEvents Button1 As System.Windows.Forms.Button + Friend WithEvents btnApplicationFolder As System.Windows.Forms.Button + Friend WithEvents LinkLabel1 As System.Windows.Forms.LinkLabel +End Class diff --git a/DD_Clipboard_Searcher/frmConfig_Basic.resx b/DD_Clipboard_Searcher/frmConfig_Basic.resx new file mode 100644 index 0000000..3dd12d1 --- /dev/null +++ b/DD_Clipboard_Searcher/frmConfig_Basic.resx @@ -0,0 +1,170 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAABl0RVh0U29m + dHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAJVSURBVDhPpZLNi5JRFMYHWsyqPyBa1SqCilm1bBNR + EbSIoU2BxVRQm2gVFESLGCvLJjIQyhmRScRvx89XRdHZzMLPVBxmFHXwgyujos44qePTvbdm0N6gRS8c + znvgPr9z73POFID/ionC5/NNe73eWUEQTG63O+NyuQZOp/OH3W6PrKys6KxW6yWz2XxkXDMuPk3FiXg8 + jlqthk6ng/39fQyHQ2xvb6NQKCAUCsFoNIYNBsNxEYB2DRSLRYxGI1r+/RsMBojFYtDpdGpaTgI8Hg/Z + 29v7J4AQAq1WS2g5CaDvJb1eD9VqFc1mE7u7u1zQ7/fRarWQz+cRDodRqVSwvLwsBjgcDsJE9XqdH85k + Mkin00gkElxIPUIwGES5XIZGoxEDqNNkZ2cHjUaDdymVSjwzXyKRCDeQxdbWFpaWlsQAm81Gut0ufyMT + 5XI5fpjdZm1tDX6/H4FAgINVKpUYYLFYCBsd84CJ19fX+eg2NjawuroKxbc3ePL5Nu6/v45bry6Orjw9 + +3wCYDKZSLvd5h2y2Sx//+bmJv//pJXipf4O7CkF4hUBcu9D3JSfwflHx2SHALoc5MDtVCqFZDLJuzMz + Ja8vw/r9A6yZj/QoIPPdg9z3gAF6hwC6HISJ2TOYcBxw7dkMnKkvXHzw2ZIKBvglZkGX4yqdbzcajfLV + ZYayqbB84fFJvBXuYl6QcPG8RyK+AQs63xNqtfrr4uJii2bo9Xq2dZh7MYsbslN4J8zxziyzesKDP0Op + VB5VKBQzCwsL52Qy2TQ9LKXRZtf+naUApn4Cytwc5qi3odMAAAAASUVORK5CYII= + + + + + AAABAAIAEBAQAAEABAAoAQAAJgAAABAQAAABAAgAaAUAAE4BAAAoAAAAEAAAACAAAAABAAQAAAAAAIAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAgAAAAICAAIAAAACAAIAAgIAAAICAgADAwMAAAAD/AAD/ + AAAA//8A/wAAAP8A/wD//wAA////AAAAAAAAAAAAAA/wAAAAAAAA948AAAAAAA+Hd/AAAAAAD4d3fwAA + AAAA93d3///wAAAPd3d3d48AAAD3d3d3ePAAAA93d3d38AAAD3d3d3fwAAAPd3f/d/AAAA93d/D38AAA + D4d3fw/wAAAA+Hd38AAAAAAP///wAAAAAAAAAAAA//8AAOf/AADD/wAAgf8AAID/AADABwAA4AMAAPAB + AAD4AQAA+AEAAPgBAAD4EQAA+AkAAPwHAAD+BwAA//8AACgAAAAQAAAAIAAAAAEACAAAAAAAAAEAAAAA + AAAAAAAAAAEAAAABAAAAAAAAQkJCAE1NTQBZWVkAZGRkAIaGhgCcnJwAp6enAL6+vgDr6+sA9vb2APr6 + +gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAD///8AAAAAAAAAAAAAAAAAAAAAAAAAAAsLAAAAAAAAAAAAAAAAAAoGBwoAAAAA + AAAAAAAAAAsHAQEFCgAAAAAAAAAAAAALBwEBAQUKAAAAAAAAAAAAAAoEAQEBBQoKCgoLAAAAAAAACQQB + AQECAQEDCAoAAAAAAAAJBAEBAQEBAQEICwAAAAAAAAkBAQEBAQEBAwoAAAAAAAAKAQEBAQUFAQEKAAAA + AAAACgEBAQUKCgUBCgAAAAAAAAoDAQEFCgAKBgoAAAAAAAALCAEBAQUKAAoLAAAAAAAAAAoIAwEBBgoA + AAAAAAAAAAAACwoKCgoLAAAAAAAAAAAAAAAAAAAAAAAAAP//AADn/wAAw/8AAIH/AACA/wAAwAcAAOAD + AADwAQAA+AEAAPgBAAD4AQAA+BEAAPgJAAD8BwAA/gcAAP//AAA= + + + \ No newline at end of file diff --git a/DD_Clipboard_Searcher/frmConfig_Basic.vb b/DD_Clipboard_Searcher/frmConfig_Basic.vb new file mode 100644 index 0000000..5d1c532 --- /dev/null +++ b/DD_Clipboard_Searcher/frmConfig_Basic.vb @@ -0,0 +1,199 @@ +Imports System.Threading +Imports System.Globalization +Imports DD_LIB_Standards +Public Class frmConfig_Basic + Dim formloaded As Boolean = False + Private Sub BtnConnect_Click(sender As Object, e As EventArgs) Handles BtnConnect.Click + Try + Dim con As String + If chkbxUserAut.Checked Then + con = "Server=" & Me.txtServer.Text & ";Database=" & Me.cmbDatenbank.Text & ";Trusted_Connection=True;" + Else + con = "Server=" & Me.txtServer.Text & ";Database=" & Me.cmbDatenbank.Text & ";User Id=" & Me.txtUser.Text & ";Password=" & Me.txtPasswort.Text & ";" + End If + + + Dim connection As New SqlClient.SqlConnection(con) 'csb.ConnectionString) + 'während Verbindungsaufbau Sanduhr-Mauszeiger + Cursor = Cursors.WaitCursor + connection.Open() + Cursor = Cursors.Default + 'DialogResult = Windows.Forms.DialogResult.OK + Dim result As MsgBoxResult + Dim msg = "Die Verbindung wurde erfolgreich aufgebaut!" & vbNewLine & "Möchten Sie diese Verbindung nun in der Anwendung speichern?" + If USER_LANGUAGE <> "de-DE" Then + msg = "Connection was successfully opened!" & vbNewLine & "Would You like to save it?" + End If + result = MessageBox.Show(msg, "Database-Connection", MessageBoxButtons.YesNo, MessageBoxIcon.Question) + If result = MsgBoxResult.Yes Then + CONNECTION_CHANGED = True + 'Set the construction string + MyConnectionString = con 'csb.ConnectionString + clsDatabase.Init(MyConnectionString) + My.Settings.Save() + If chkbxUserAut.Checked = False Then + Dim wrapper As New clsEncryption("!35452didalog=") + Dim cipherText As String = wrapper.EncryptData(Me.txtPasswort.Text) + Dim pw As String = cipherText + con = "Server=" & Me.txtServer.Text & ";Database=" & Me.cmbDatenbank.Text & ";User Id=" & Me.txtUser.Text & ";Password=" & pw & ";" + End If + SaveConfigValue("MyConnectionString", con) + Dim csb As New SqlClient.SqlConnectionStringBuilder + csb.ConnectionString = MyConnectionString + Dim constr = connection.ConnectionString + If chkbxUserAut.Checked = False Then + constr = constr.Replace(csb.Password, "XXXXX") + End If + Me.txtActualConnection.Text = constr + End If + Catch ex As Exception + Cursor = Cursors.Default + MsgBox("Error in Connectionbuild: " & vbNewLine & ex.Message, MsgBoxStyle.Exclamation) + End Try + End Sub + + Private Sub cmbDatenbank_MouseClick(sender As Object, e As MouseEventArgs) Handles cmbDatenbank.MouseClick + Load_Databases() + End Sub + Sub Load_Databases() + Try + Me.Cursor = Cursors.WaitCursor + Dim csb As New SqlClient.SqlConnectionStringBuilder + csb.DataSource = Me.txtServer.Text + csb.IntegratedSecurity = False + csb.UserID = Me.txtUser.Text + csb.Password = Me.txtPasswort.Text + + Dim con As String + If chkbxUserAut.Checked Then + con = "Data Source=" & Me.txtServer.Text & ";Trusted_Connection=True;" + Else + 'con = "Server=" & Me.txtServer.Text & ";Database=" & Me.cmbDatenbank.Text & ";User Id=" & Me.txtUser.Text & ";Password=" & Me.txtPasswort.Text & ";" + con = "Server=" & Me.txtServer.Text & ";User Id=" & Me.txtUser.Text & ";Password=" & Me.txtPasswort.Text & ";" + End If + Dim connection As New SqlClient.SqlConnection(con) 'csb.ConnectionString) + connection.Open() + Dim cmd As New SqlClient.SqlCommand("sp_databases", connection) + cmd.CommandType = CommandType.StoredProcedure + ' Ausführen und Ergebnis in einer ListBox anzeigen + Dim dr As SqlClient.SqlDataReader = cmd.ExecuteReader + If dr.HasRows Then + cmbDatenbank.Items.Clear() + Do While dr.Read + cmbDatenbank.Items.Add(dr("Database_Name")) + Loop + cmbDatenbank.DroppedDown = True + Else + MsgBox("The standard-databases could not be retrieved. The default database will be set!" & vbNewLine & "Check rights in sql-server for user: " & Me.txtUser.Text, MsgBoxStyle.Exclamation) + End If + connection.Close() + Catch ex As Exception + If ex.Message.ToLower.Contains("he standard-databases") Or ex.Message.ToLower.Contains("ie standard-datenbanken") Then + cmbDatenbank.Text = "DD_ECM" + End If + MsgBox(ex.Message, MsgBoxStyle.Critical, "Error in Load Databases:") + End Try + Cursor = Cursors.Default + End Sub + + Private Sub frmConfig_Basic_FormClosing(sender As Object, e As FormClosingEventArgs) Handles Me.FormClosing + + End Sub + + Private Sub frmConfig_Basic_Load(sender As Object, e As EventArgs) Handles MyBase.Load + If Not MyConnectionString = String.Empty Then + CONNECTION_CHANGED = False + Try + Dim csb As New SqlClient.SqlConnectionStringBuilder + csb.ConnectionString = MyConnectionString + + Dim constr = MyConnectionString + If Not MyConnectionString.Contains("Trusted") Then + constr = constr.Replace(csb.Password, "XXXXX") + txtUser.Text = csb.UserID + chkbxUserAut.Checked = False + Else + chkbxUserAut.Checked = True + End If + + Try + txtServer.Text = csb.DataSource + cmbDatenbank.Text = csb.InitialCatalog + Catch ex As Exception + + End Try + + Me.txtActualConnection.Text = constr + chkLogErrorsOnly.Checked = LogErrorsOnly + Catch ex As Exception + MsgBox("Fehler in FormLoad: " & vbNewLine & ex.Message, MsgBoxStyle.Critical) + End Try + + + + End If + End Sub + + Private Sub chkbxloadWDDocs_CheckedChanged(sender As Object, e As EventArgs) + + End Sub + + Private Sub LinkLabel1_LinkClicked(sender As Object, e As LinkLabelLinkClickedEventArgs) Handles LinkLabel1.LinkClicked + ' Specify that the link was visited. + Me.LinkLabel1.LinkVisited = True + ' Navigate to a URL. + System.Diagnostics.Process.Start("http://www.didalog.de/Support") + End Sub + + Private Sub btnApplicationFolder_Click(sender As Object, e As EventArgs) Handles btnApplicationFolder.Click + Process.Start(Application.UserAppDataPath()) + End Sub + + Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click + Process.Start(ClassLogger.DateiSpeicherort) + End Sub + + Private Sub chkLogErrorsOnly_CheckedChanged(sender As Object, e As EventArgs) Handles chkLogErrorsOnly.CheckedChanged + LogErrorsOnly = chkLogErrorsOnly.Checked + SaveConfigValue("LogErrorsOnly", LogErrorsOnly) + End Sub + + + Private Sub frmConfig_Basic_Shown(sender As Object, e As EventArgs) Handles Me.Shown + formloaded = True + End Sub + + Private Sub TabControl1_SelectedIndexChanged(sender As Object, e As EventArgs) Handles TabControl1.SelectedIndexChanged + Select Case TabControl1.SelectedIndex + Case 1 + + + + End Select + End Sub + + Private Sub chkbxUserAut_CheckedChanged(sender As Object, e As EventArgs) Handles chkbxUserAut.CheckedChanged + If chkbxUserAut.Checked Then + Me.txtPasswort.Enabled = False + Me.txtUser.Enabled = False + Else + Me.txtPasswort.Enabled = True + Me.txtUser.Enabled = True + End If + End Sub + + Private Sub txtActualConnection_TextChanged(sender As Object, e As EventArgs) Handles txtActualConnection.TextChanged + + End Sub + + Private Sub cmbDatenbank_SelectedIndexChanged(sender As Object, e As EventArgs) Handles cmbDatenbank.SelectedIndexChanged + + End Sub + + Private Sub txtPasswort_Leave(sender As Object, e As EventArgs) Handles txtPasswort.Leave + + End Sub + Private Sub txtPasswort_TextChanged(sender As Object, e As EventArgs) Handles txtPasswort.TextChanged + + End Sub +End Class \ No newline at end of file diff --git a/DD_Clipboard_Searcher/frmLicense.Designer.vb b/DD_Clipboard_Searcher/frmLicense.Designer.vb new file mode 100644 index 0000000..76e3bd5 --- /dev/null +++ b/DD_Clipboard_Searcher/frmLicense.Designer.vb @@ -0,0 +1,199 @@ + _ +Partial Class frmLicense + Inherits System.Windows.Forms.Form + + 'Das Formular überschreibt den Löschvorgang, um die Komponentenliste zu bereinigen. + _ + 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 + + 'Wird vom Windows Form-Designer benötigt. + Private components As System.ComponentModel.IContainer + + 'Hinweis: Die folgende Prozedur ist für den Windows Form-Designer erforderlich. + 'Das Bearbeiten ist mit dem Windows Form-Designer möglich. + 'Das Bearbeiten mit dem Code-Editor ist nicht möglich. + _ + Private Sub InitializeComponent() + Dim resources As System.ComponentModel.ComponentResourceManager = New System.ComponentModel.ComponentResourceManager(GetType(frmLicense)) + Me.txtPW = New System.Windows.Forms.TextBox() + Me.lblPW = New System.Windows.Forms.Label() + Me.grbBoxlicense = New System.Windows.Forms.GroupBox() + Me.lblClient = New System.Windows.Forms.Label() + Me.cmbClients = New System.Windows.Forms.ComboBox() + Me.Label5 = New System.Windows.Forms.Label() + Me.dtpGueltig_GI = New System.Windows.Forms.DateTimePicker() + Me.btnnewLicenses = New System.Windows.Forms.Button() + Me.txtNewlicences = New System.Windows.Forms.TextBox() + Me.lblnewlicenses = New System.Windows.Forms.Label() + Me.btnPW_check = New System.Windows.Forms.Button() + Me.grbBoxlicense.SuspendLayout() + Me.SuspendLayout() + ' + 'txtPW + ' + Me.txtPW.Location = New System.Drawing.Point(109, 6) + Me.txtPW.Margin = New System.Windows.Forms.Padding(3, 4, 3, 4) + Me.txtPW.Name = "txtPW" + Me.txtPW.Size = New System.Drawing.Size(207, 21) + Me.txtPW.TabIndex = 32 + Me.txtPW.UseSystemPasswordChar = True + ' + 'lblPW + ' + Me.lblPW.AutoSize = True + Me.lblPW.ImeMode = System.Windows.Forms.ImeMode.NoControl + Me.lblPW.Location = New System.Drawing.Point(12, 9) + Me.lblPW.Name = "lblPW" + Me.lblPW.Size = New System.Drawing.Size(91, 13) + Me.lblPW.TabIndex = 31 + Me.lblPW.Text = "Master Passwort:" + ' + 'grbBoxlicense + ' + Me.grbBoxlicense.Controls.Add(Me.lblClient) + Me.grbBoxlicense.Controls.Add(Me.cmbClients) + Me.grbBoxlicense.Controls.Add(Me.Label5) + Me.grbBoxlicense.Controls.Add(Me.dtpGueltig_GI) + Me.grbBoxlicense.Controls.Add(Me.btnnewLicenses) + Me.grbBoxlicense.Controls.Add(Me.txtNewlicences) + Me.grbBoxlicense.Controls.Add(Me.lblnewlicenses) + Me.grbBoxlicense.Location = New System.Drawing.Point(15, 41) + Me.grbBoxlicense.Margin = New System.Windows.Forms.Padding(3, 4, 3, 4) + Me.grbBoxlicense.Name = "grbBoxlicense" + Me.grbBoxlicense.Padding = New System.Windows.Forms.Padding(3, 4, 3, 4) + Me.grbBoxlicense.Size = New System.Drawing.Size(469, 140) + Me.grbBoxlicense.TabIndex = 30 + Me.grbBoxlicense.TabStop = False + Me.grbBoxlicense.Text = "Lizenzanzahl ändern:" + Me.grbBoxlicense.Visible = False + ' + 'lblClient + ' + Me.lblClient.AutoSize = True + Me.lblClient.Font = New System.Drawing.Font("Verdana", 9.75!) + Me.lblClient.ImeMode = System.Windows.Forms.ImeMode.NoControl + Me.lblClient.Location = New System.Drawing.Point(7, 20) + Me.lblClient.Name = "lblClient" + Me.lblClient.Size = New System.Drawing.Size(140, 16) + Me.lblClient.TabIndex = 19 + Me.lblClient.Text = "Mandantenauswahl:" + ' + 'cmbClients + ' + Me.cmbClients.Font = New System.Drawing.Font("Tahoma", 9.75!) + Me.cmbClients.FormattingEnabled = True + Me.cmbClients.Location = New System.Drawing.Point(10, 39) + Me.cmbClients.Name = "cmbClients" + Me.cmbClients.Size = New System.Drawing.Size(262, 24) + Me.cmbClients.TabIndex = 18 + ' + 'Label5 + ' + Me.Label5.AutoSize = True + Me.Label5.ImeMode = System.Windows.Forms.ImeMode.NoControl + Me.Label5.Location = New System.Drawing.Point(7, 106) + Me.Label5.Name = "Label5" + Me.Label5.Size = New System.Drawing.Size(55, 13) + Me.Label5.TabIndex = 16 + Me.Label5.Text = "Gültigkeit:" + Me.Label5.TextAlign = System.Drawing.ContentAlignment.TopRight + ' + 'dtpGueltig_GI + ' + Me.dtpGueltig_GI.Format = System.Windows.Forms.DateTimePickerFormat.[Short] + Me.dtpGueltig_GI.Location = New System.Drawing.Point(168, 100) + Me.dtpGueltig_GI.Name = "dtpGueltig_GI" + Me.dtpGueltig_GI.Size = New System.Drawing.Size(104, 21) + Me.dtpGueltig_GI.TabIndex = 15 + Me.dtpGueltig_GI.Value = New Date(2099, 12, 31, 0, 0, 0, 0) + ' + 'btnnewLicenses + ' + Me.btnnewLicenses.Font = New System.Drawing.Font("Tahoma", 9.75!, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, CType(0, Byte)) + Me.btnnewLicenses.Image = Global.DD_Clipboard_Searcher.My.Resources.Resources.KeyDown_8461 + Me.btnnewLicenses.ImageAlign = System.Drawing.ContentAlignment.MiddleLeft + Me.btnnewLicenses.ImeMode = System.Windows.Forms.ImeMode.NoControl + Me.btnnewLicenses.Location = New System.Drawing.Point(307, 91) + Me.btnnewLicenses.Margin = New System.Windows.Forms.Padding(3, 4, 3, 4) + Me.btnnewLicenses.Name = "btnnewLicenses" + Me.btnnewLicenses.Size = New System.Drawing.Size(145, 30) + Me.btnnewLicenses.TabIndex = 5 + Me.btnnewLicenses.Text = "Erneuere Lizenz" + Me.btnnewLicenses.TextAlign = System.Drawing.ContentAlignment.MiddleRight + Me.btnnewLicenses.UseVisualStyleBackColor = True + ' + 'txtNewlicences + ' + Me.txtNewlicences.Location = New System.Drawing.Point(241, 74) + Me.txtNewlicences.Margin = New System.Windows.Forms.Padding(3, 4, 3, 4) + Me.txtNewlicences.Name = "txtNewlicences" + Me.txtNewlicences.Size = New System.Drawing.Size(31, 21) + Me.txtNewlicences.TabIndex = 4 + Me.txtNewlicences.Text = "1" + ' + 'lblnewlicenses + ' + Me.lblnewlicenses.AutoSize = True + Me.lblnewlicenses.ImeMode = System.Windows.Forms.ImeMode.NoControl + Me.lblnewlicenses.Location = New System.Drawing.Point(7, 77) + Me.lblnewlicenses.Name = "lblnewlicenses" + Me.lblnewlicenses.Size = New System.Drawing.Size(113, 13) + Me.lblnewlicenses.TabIndex = 3 + Me.lblnewlicenses.Text = "Anzahl User-Lizenzen:" + ' + 'btnPW_check + ' + Me.btnPW_check.Image = Global.DD_Clipboard_Searcher.My.Resources.Resources.KeyDown_8461 + Me.btnPW_check.ImageAlign = System.Drawing.ContentAlignment.MiddleLeft + Me.btnPW_check.ImeMode = System.Windows.Forms.ImeMode.NoControl + Me.btnPW_check.Location = New System.Drawing.Point(322, 1) + Me.btnPW_check.Margin = New System.Windows.Forms.Padding(3, 4, 3, 4) + Me.btnPW_check.Name = "btnPW_check" + Me.btnPW_check.Size = New System.Drawing.Size(162, 32) + Me.btnPW_check.TabIndex = 33 + Me.btnPW_check.Text = "Open License Manager" + Me.btnPW_check.TextAlign = System.Drawing.ContentAlignment.MiddleRight + Me.btnPW_check.UseVisualStyleBackColor = True + ' + 'frmLicense + ' + Me.AutoScaleDimensions = New System.Drawing.SizeF(6.0!, 13.0!) + Me.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font + Me.ClientSize = New System.Drawing.Size(490, 188) + Me.Controls.Add(Me.btnPW_check) + Me.Controls.Add(Me.txtPW) + Me.Controls.Add(Me.lblPW) + Me.Controls.Add(Me.grbBoxlicense) + Me.Font = New System.Drawing.Font("Tahoma", 8.25!, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, CType(0, Byte)) + Me.Icon = CType(resources.GetObject("$this.Icon"), System.Drawing.Icon) + Me.MaximizeBox = False + Me.MinimizeBox = False + Me.Name = "frmLicense" + Me.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent + Me.Text = "License Manager" + Me.grbBoxlicense.ResumeLayout(False) + Me.grbBoxlicense.PerformLayout() + Me.ResumeLayout(False) + Me.PerformLayout() + + End Sub + Friend WithEvents btnPW_check As System.Windows.Forms.Button + Friend WithEvents txtPW As System.Windows.Forms.TextBox + Friend WithEvents lblPW As System.Windows.Forms.Label + Friend WithEvents grbBoxlicense As System.Windows.Forms.GroupBox + Friend WithEvents lblClient As System.Windows.Forms.Label + Friend WithEvents cmbClients As System.Windows.Forms.ComboBox + Friend WithEvents Label5 As System.Windows.Forms.Label + Friend WithEvents dtpGueltig_GI As System.Windows.Forms.DateTimePicker + Friend WithEvents btnnewLicenses As System.Windows.Forms.Button + Friend WithEvents txtNewlicences As System.Windows.Forms.TextBox + Friend WithEvents lblnewlicenses As System.Windows.Forms.Label +End Class diff --git a/DD_Clipboard_Searcher/frmLicense.resx b/DD_Clipboard_Searcher/frmLicense.resx new file mode 100644 index 0000000..43835f4 --- /dev/null +++ b/DD_Clipboard_Searcher/frmLicense.resx @@ -0,0 +1,1025 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + + AAABAA0AMDAQAAEABABoBgAA1gAAACAgEAABAAQA6AIAAD4HAAAYGBAAAQAEAOgBAAAmCgAAEBAQAAEA + BAAoAQAADgwAADAwAAABAAgAqA4AADYNAAAgIAAAAQAIAKgIAADeGwAAGBgAAAEACADIBgAAhiQAABAQ + AAABAAgAaAUAAE4rAAAAAAAAAQAgAN1dAAC2MAAAMDAAAAEAIACoJQAAk44AACAgAAABACAAqBAAADu0 + AAAYGAAAAQAgAIgJAADjxAAAEBAAAAEAIABoBAAAa84AACgAAAAwAAAAYAAAAAEABAAAAAAAgAQAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAACAAACAAAAAgIAAgAAAAIAAgACAgAAAgICAAMDAwAAAAP8AAP8AAAD/ + /wD/AAAA/wD/AP//AAD///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAABzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAe4cAAAAAAAAAAAAAAAAAAAAAAA + AAAAADe5MAAAAAAAAAAAAAAAAAAAAAAAAAAAA7W3lwAAAAAAAAAAAAAAAAAAAAAAAAAAB7W5NwAAAAAA + AAAAAAAAAAAAAAAAAAAACbW4gAAAAAAAAAAAAAAAAAAAAAAAAAAAA3mLUAAAAAAAAAAAAAAAAAAAAAAA + AAAACbe3cAAAAAAAAAAAAAAAAAAAAAAAAAAAB7e5dwAAAAAAAAAAAAAAAAAAAAAAAAAAA4mLtwAAAAAA + AAAAAAAAAAAAAAAAAAAACbe3gAAAAAAAAAAAAAAAAAAAAAAAAAAAA4OJcAAAAAAAAAAAAAAAAAAAAAAA + AAAAA7e3NwAAAAAAAAAAAAAAAAAAAAAAAAAAB7W5hwAAAAAAAAAAAAAAAAAAAAAAAAAACbe3twAAAAAA + AAAAAAAAAAAAAAAAAAAAA4mJtQAAAAAAAAAAAAAAAAAAAAAAAAAAA7e3hwAAAAAAAAAAAAAAAAAAAAAA + AAAACYOJtwAAAAAAAAAAAAAAAAAAAAAAAAAAA4O3tQAAAAAAAAAAAAAAAAAAAAAAAAAAA7eDhwAAAAAA + AAAAAAAAAAAAAAAAAAAAB4m3tQAAAAAAAAAAAAAAAAAAAAAAAAAACbOJgwAAAAAAAAAAAAAAAAAAAAAA + AAAAA4ODNwAAAAAAAAAAAAAAAAAAAAAAAAAAA4uLiBcAAAAAAAAAAAAAAAAAAAAAAAAHeLi4uDNwAAAA + AAAAAAAAAAAAAAAAAAB7j7i4v5gzcAAAAAAAAAAAAAAAAAAAAAe4i4uLj7eXNwAAAAAAAAAAAAAAAAAA + AHt5uLi4u4uLeQAAAAAAAAAAAAAAAAAAALibi3uLi3uJi3AAAAAAAAAAAAAAAAAAB4uLe4t7d7i4uBcA + AAAAAAAAAAAAAAAACIm3m3uYuLi4m3cAAAAAAAAAAAAAAAAAeLi5i3uLm4uLibcAAAAAAAAAAAAAAAAA + v3t4/////4i4t5cAAAAAAAAAAAAAAAAAf5e3d4d4eHh5t7kAAAAAAAAAAAAAAAAAv7UAAAAAAAAIuYMA + AAAAAAAAAAAAAAAAf3MAAAAAAAAHe5cAAAAAAAAAAAAAAAAAiIlwAAAAAAAHmLcAAAAAAAAAAAAAAAAA + CPNwAAAAAAAHt3cAAAAAAAAAAAAAAAAAC/g3AAAAAAB5i5AAAAAAAAAAAAAAAAAACIiXcAAAAAd7eHAA + AAAAAAAAAAAAAAAAAH/zN3AAB3N4twAAAAAAAAAAAAAAAAAAAAiPg3Fzc5i4kAAAAAAAAAAAAAAAAAAA + AAB7+Ig5iIt3AAAAAAAAAAAAAAAAAAAAAAAAeI//+4cAAAAAAAAAAAAAAAAAAAAAAAAAAId3cAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////////AAD///////8AAP///P///wAA///4f/// + AAD///B///8AAP//4D///wAA///gP///AAD//+B///8AAP//4H///wAA///gf///AAD//+A///8AAP// + 4D///wAA///gf///AAD//+B///8AAP//4D///wAA///gP///AAD//+A///8AAP//4D///wAA///gP/// + AAD//+A///8AAP//4D///wAA///gP///AAD//+A///8AAP//4D///wAA///gP///AAD//+AP//8AAP// + gAf//wAA//8AAf//AAD//gAA//8AAP/8AAD//wAA//wAAH//AAD/+AAAP/8AAP/4AAA//wAA//AAAD// + AAD/8AAAP/8AAP/wAAA//wAA//D/+D//AAD/8P/4P/8AAP/wf/g//wAA//h/+D//AAD/+D/wf/8AAP/4 + H+B//wAA//wHgP//AAD//gAB//8AAP//AAP//wAA///AD///AAD///B///8AAP///////wAAKAAAACAA + AABAAAAAAQAEAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAIAAAACAgACAAAAAgACAAICA + AACAgIAAwMDAAAAA/wAA/wAAAP//AP8AAAD/AP8A//8AAP///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAA3AAAAAAAAAAAAAAAAAAADeXAAAAAAAAAAAAAAAAAAOLNwAAAAAAAAAAAAAAAAAJt4MAAAAAAAAAAA + AAAAAAB7l3AAAAAAAAAAAAAAAAAAODtQAAAAAAAAAAAAAAAAAJt4MAAAAAAAAAAAAAAAAAB4mwAAAAAA + AAAAAAAAAAAAO3dwAAAAAAAAAAAAAAAAAJg7UAAAAAAAAAAAAAAAAAA7e3AAAAAAAAAAAAAAAAAAeJgw + AAAAAAAAAAAAAAAAAJt7UAAAAAAAAAAAAAAAAAA4ODAAAAAAAAAAAAAAAAAAODlwAAAAAAAAAAAAAAAA + AJuLdwAAAAAAAAAAAAAAAAeLi4NwAAAAAAAAAAAAAAB7i4uJNwAAAAAAAAAAAAAHuLi4u3NwAAAAAAAA + AAAAe4m4uJi5cAAAAAAAAAAAAIm4uJuLizcAAAAAAAAAAAe4v4//iLiXAAAAAAAAAAAIg3dzc4OJtwAA + AAAAAAAAB7UAAAAAB7UAAAAAAAAAAACDcAAAAHt3AAAAAAAAAAAAiBAAAAB4EAAAAAAAAAAAAHgxcAAD + i3AAAAAAAAAAAAAI+HMDWLUAAAAAAAAAAAAAAHiI+LdwAAAAAAAAAAAAAAAAi3eAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAP///////z////4f///8H////B////wf///8H////B////w////8H////B////wf///8 + H////B////wf///8H////A////gH///wA///4AH//8AB///AAP//gAD//4AA//+P+P//x/D//8fx///B + 4f//4AP///AH///8H///////KAAAABgAAAAwAAAAAQAEAAAAAAAgAQAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAIAAAIAAAACAgACAAAAAgACAAICAAACAgIAAwMDAAAAA/wAA/wAAAP//AP8AAAD/AP8A//8AAP// + /wAAAAAAAAMwAAAAAAAAAAAAADeTAAAAAAAAAAAAAJuHAAAAAAAAAAAAADgwAAAAAAAAAAAAADuXAAAA + AAAAAAAAAJi3AAAAAAAAAAAAADcwAAAAAAAAAAAAADe1AAAAAAAAAAAAAJuDAAAAAAAAAAAAAHexAAAA + AAAAAAAAADm3AAAAAAAAAAAAADg5AAAAAAAAAAAAALi3AAAAAAAAAAAAB7i4MAAAAAAAAAAAOLi7eQAA + AAAAAAAHu5t7i3AAAAAAAACLePiIu5AAAAAAAAB7d7e3d7cAAAAAAAB3kAAAB3cAAAAAAAB4cAAAC5AA + AAAAAAALgwAAeHAAAAAAAAAHiHNXtwAAAAAAAAAAuIiLcAAAAAAAAAAAAHt4AAAAAAD/5/8A/8P/AP/D + /wD/x/8A/8P/AP/D/wD/x/8A/8P/AP/D/wD/w/8A/8P/AP/D/wD/w/8A/4H/AP8A/wD+AH8A/AB/APwA + PwD8fj8A/H5/AP48fwD+AP8A/wH/AP/D/wAoAAAAEAAAACAAAAABAAQAAAAAAIAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAgAAAgAAAAICAAIAAAACAAIAAgIAAAICAgADAwMAAAAD/AAD/AAAA//8A/wAAAP8A + /wD//wAA////AAAAAAAwAAAAAAAAA4MAAAAAAAADsAAAAAAAAAmDAAAAAAAAC3AAAAAAAAADgwAAAAAA + AAO3AAAAAAAAB4MAAAAAAAA7i1AAAAAAB7iYtQAAAAB7iLiLcAAAADiYc4tQAAAAe3AAe3AAAACLg3e1 + gAAAAAiYuHgAAAAAAIt7gAAA/38AAP4/AAD+fwAA/j8AAP5/AAD+PwAA/j8AAP4/AAD8HwAA+A8AAPAH + AADwBwAA8ccAAPAHAAD4DwAA/B8AACgAAAAwAAAAYAAAAAEACAAAAAAAAAkAAAAAAAAAAAAAAAEAAAAB + AAAAAAAAI0JnAD9PagA/U3EANlJ4AD1WeQBOUVUAUFNYAFJZXQBdXFwAYF5cAExXaABOWWoASFp1AFNj + ewBcbH0AY2NjAGlpaQBra2wAbW1tAGxvdQBibX4Ab3F1AHNzcwB3d3gAcnZ/ABFPlAAkUYIANVuEADpc + gwA+Xo8AIlmaADxfkwA/c5gAIV60ACxjoAAnbaIALWunAC5mrwArbKkAM2mlADhvogAxa60APm2sADZy + rgAiYbMAKGe1AChttgAkZrsAKmO4ADBntQAxbbUAPG+xADlttgArcLgANXOyADlyswA7dLsAQ16bAEpq + igBbbIUAUnaNAEJnkwBGbpUASmuWAENjngBKdZYAYG+JAGl3ggBpeYkAQ2WiAEBopgBAaqkAR3GtABZk + ywAVaM0AM3rCADaQvwB/gYMAbIWXAHCHmQB8hpoAS4KyAESKtgBMiLMASoG9AEaJvwBMj7gAW46zAFyP + ugBfkbQAYYmkAGyKrABtkKwAcZOsAHmTrABslLcAYZq7AGydvgB6mrUAcpu6AC+HzgA0gMkAJ4fVAC+A + 3AA0htMAOIbVADOC2QA8hdgANYncADuJ2gA4m94ANIrmADyJ4QA0jO0AM5biADuS5AA3m+cAM5TqADyc + 7AA1kvQAOpbyADOd9wA6mvcAMJf4AD2h9wA6pvgAN6z/ADyr+AA8tvoAP7n5AFeEwQBVh84AXojMAFOX + yABWmswATIfWAE6P0wBEitsASYzaAFCM0gBPkNoARJrYAEie3ABbntMAUZ7fAFqb3wBunMIAX6PUAF2n + 2wBbqN4AeqfIAGym0QBzsNoAQ5TkAEOZ5ABNnuQASZzpAFWX5ABZnuEAQqLtAFSk4QBZouMAWqjnAFeq + 7wBerOkARKX0AEii9ABBpfgARqz6AFKt9gBFsfEATbX3AEKz+gBLsvoAQrr7AEu5/gBRs/YAWrzxAFSz + /ABRvvsAaqXmAGGt4QBgr+wAdq7oAH6t6wB1u+sAYrf0AG219wBjvP4ARMP/AEzE/ABGy/8AS8n9AFHF + +wBYxv0AU8z9AFjK/ABC1f8AVNP/AFrT/ABS2f8AXdv+AGzM+QB6wvMAdMD6AH3H/wBm1fwAY93+AGrd + /gBk4P8AauT/AICJnQCEl7MAgp62AIqfuwCKorsAjqfAAJevwwCBrtAAhrbmAIu98gCrxtkAj83kAI7F + 6gCVyeoAmcjpAInQ7ACd3O0AjMP0AIPK/wCazvIAkNH+AJ/c/gCv0/UAtN/3ALDb/QCK4v8Aq+P/ALzj + /wCx7vkAqfD/AMvn/QDE6v8A1O3/ANrv/wDC+v8A3PH/ANX7/wDf//8A5/T/AOX5/wDp+f8A9f//APv/ + /wD///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAD1nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGcB/EwAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABNNa92DAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACbGKnVoShMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAC2BMnNvShcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AC16MtNl5QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC18ItNpCQAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC2+LdNpEwAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC3JLtNmIRMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAC3HKtNMsxcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AC3EN9JM7gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC3EN8RMCgAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC3EN785UxcAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC2vKsQ1vxEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAC2+J744sBMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AC2+Jb80sBEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC3HKMQ0sBEAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC3KKMpHsBMAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC3KKNNHsBMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAC3KI9NHsBMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + ADDHH9NHsBMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDHGtM6rRAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDQJNM6RwgAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACfS0NDR0d8BFwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABEh+PS0tDS0+QuGwwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEK7 + 7/PQ0tLQ0fBxcDYcFgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVLDmzMTIytDK0PCQiXRq + HBYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYqaSgrMLIyMjIyMTEspWcoh0AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAACxvZumsLTEyMjIxMLC0M+WvJwOAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAIfopaCprbS/wsLCv7TQ09DLo6csTgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMzsc6mo + foGvgoKCgc/QyMjHoXltDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYuvdd6h4ra+Cgq+vtMPDyLTE + o3BwPwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAhvqfoH/t+P////3//fn28dG+q21wOAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAjv9tVllcX9XX2djY1mNkYmFXf254TAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAj/9tHQAAAAAAAAAAAAAAAADUoGl7TAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlPyeBAAA + AAAAAAAAAAAAAABRnWmoKQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA2/PdIBkAAAAAAAAAAAAAAAA8 + bJ2lOwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOn0OQYAAAAAAAAAAAAAAABAcbORRQAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAJj8uR0TAAAAAAAAAAAAAEOMmrNSAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAN7h9YgDEwAAAAAAAAAAFYOLvbdQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABk8/KL + HQgXAAAAABQOhYjNzFsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAl/P33FU+BQINHkmEkr26 + WwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGDg+/XquIputeXOvbZPAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAk+Lv/P//9OeZWgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAADa1l1eXwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////////AAD///////8AAP///P///wAA///4f/// + AAD///B///8AAP//4D///wAA///gP///AAD//+B///8AAP//4H///wAA///gf///AAD//+A///8AAP// + 4D///wAA///gf///AAD//+B///8AAP//4D///wAA///gP///AAD//+A///8AAP//4D///wAA///gP/// + AAD//+A///8AAP//4D///wAA///gP///AAD//+A///8AAP//4D///wAA///gP///AAD//+AP//8AAP// + gAf//wAA//8AAf//AAD//gAA//8AAP/8AAD//wAA//wAAH//AAD/+AAAP/8AAP/4AAA//wAA//AAAD// + AAD/8AAAP/8AAP/wAAA//wAA//D/+D//AAD/8P/4P/8AAP/wf/g//wAA//h/+D//AAD/+D/wf/8AAP/4 + H+B//wAA//wHgP//AAD//gAB//8AAP//AAP//wAA///AD///AAD///B///8AAP///////wAAKAAAACAA + AABAAAAAAQAIAAAAAAAABAAAAAAAAAAAAAAAAQAAAAEAAAAAAAAjK0AALDRGACs1TAApN1QAKDhQACA5 + XQAfQXQAOE5iADxQcQBTV1wAWl1hAFhZZABNX3YAVWFvAFRpfABcansAXm17AF92fwBpaWkAdXV1AHB3 + ewB2eHoAeXl5AC9bhwAsXYoANFyCADRdjwA4XYkAOVqTAD1lhAA5Y5QAOmWVAD9llAA3apwALGWkAChp + pAAzbKMANm2gADlsowA8baAAOHmvACVluQA+e7IAPni1ADV7uAA6fLkAQ2mLAERqigBIaYwASW+SAG15 + hgB+f4AAKnrNADZ8xAAwfc4AP4e7AD+EvgA+jLsAWoKdAGaFnwBEiKwASI++AGyKrABglK8AZpC6AHWT + sAB9mrMAcpe/AH6hvAA/kdcAN4niACyQ4AA5nuUAMZHtADuW7AA5pe4APafzADul+AA7q/oAOK//AECK + zQBXl8YAW5vAAF+l2gBAlOgASp7wAE+k4wBXvekAQqjwAEat8gBJrvcAQ675AEy59wBItvgATLr4AE2+ + +ABQt/MAVLH3AFG59QBRvvgAVLv8AGek5gBpq/MAZLz/AHy2+QBNwf8AVsH2AF/B9wBYxfQAUcL5AFbA + +ABWwv8AUMT8AFbM+gBWyP8AV878AF3N+gBYyv8AWM//AFvT/ABf0f8AXtT+AF3Z/wBe3v8AZcD5AGvG + /wBsxP8AaMn6AGLW/QBl1f0AYtj/AGXb/wBi3v8Aad3/AGzd/wB20f8AfNP/AGni/wCDkaEAiZ2nAI+c + pQCQnKQAjaCpAJGlvwCUs9EAk8TWAIfe/gCQ2P8AqNnvALPa4gCp3P8AhuH/AJvl/wCp7v8AtOP7ALfn + /wCy8f8Au/L/AL73/wDB+P8A2P7/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKkwj + DQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACp6NkscAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + Kno2bDEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqby46NAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAACpjLjgOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKnYrbzIAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAqcytvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACpuJT4PAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAKm8lbjEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqdSdwMQAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAACqKIW4xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKoYhbjEAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAqgyJwMQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACp6JS0eAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKoZ2bD0QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABKGhoZ8 + WBoXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAk4KKg3xvNxgTAAAAAAAAAAAAAAAAAAAAAAAAAAAAUoBh + b3p6cm5cShkUAAAAAAAAAAAAAAAAAAAAAAAAADxhWllgb25uX4ZqSAgAAAAAAAAAAAAAAAAAAAAAAAAA + VFtNXmBfal+CgnNQJBQAAAAAAAAAAAAAAAAAAAAAAI5/Toidn5+enpqYck81CwAAAAAAAAAAAAAAAAAA + AAAAjH84Pz8/Pz8/Pz8/SUcKAAAAAAAAAAAAAAAAAAAAAACPiQYAAAAAAAAAAABGVQsAAAAAAAAAAAAA + AAAAAAAAAACZBxMAAAAAAAAAi1ZRFgAAAAAAAAAAAAAAAAAAAAAAAJJmAgAAAAAAAAAhaB4AAAAAAAAA + AAAAAAAAAAAAAAAAQqArAQsAAAAACWdXFgAAAAAAAAAAAAAAAAAAAAAAAAAARaGVOwUDBB1pfRAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAQ5GWnJyXlFMzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBEQUKMAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////////P////h////wf///8 + H////B////wf///8H////D////wf///8H////B////wf///8H////B////wf///8D///+Af///AD///g + Af//wAH//8AA//+AAP//gAD//4/4///H8P//x/H//8Hh///gA///8Af///wf//////8oAAAAGAAAADAA + AAABAAgAAAAAAEACAAAAAAAAAAAAAAABAAAAAQAAAAAAADpffQBCRVsAQU1oAEZXdQBUWXUAYGN1AB9N + gQAmUYQALVmJADVfjQA5Y48AHlqoABxorgAlZbkAQmKAAENslQBWeJoAaHCAAHJ6iABUdaMASnm9ABZ3 + 0gBHgK8AXoGoAFiFqgBMhL0AUoK0AF+LsgBBkb8AZ4WpAGaHrQBiiqsAbIqsAGSSugB7l7MAcJO8AC2G + zAA6iMkAPZrVADaV2gA5nt4AJYfiACSM9gA2nv8APqnlAD+n6gA/qO8ALKv8ADOp9wA7qvEANa/8AD+w + 9wA4svoAP7b6ADO4/AA2uvwAOLz8AEOOzgBZn8UAQqPVAEqm0ABJptUAQqjcAHSu0wBIluEAVa7pAEKv + /wBDtPYAQLT6AEK++QBEu/8ARb/9AEq5/wByuOYAMcT/ADfM/wBLw/QARsL+AEXE/ABPxv8AQ8n+AEjN + /ABeyf8ATdL8AE/c/ABV0/oAVt78AHnR/wBU4v0AX+f9AGrx/wCKmK8AiqCzAICy1QCFyvAAiNv/AJzd + /wCk1vAAlfb/AJr//wCu5PwAre//ALnq+wCh+f8Aov3/AKb//wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////AAAAAAAAAAAAAAAADg4AAAAAAAAAAAAAAAAA + AAAAAAAAAAAMMSoHAAAAAAAAAAAAAAAAAAAAAAAAAAAMREMQAAAAAAAAAAAAAAAAAAAAAAAAAAAMLwoA + AAAAAAAAAAAAAAAAAAAAAAAAAAAMLigJAAAAAAAAAAAAAAAAAAAAAAAAAAAMLUceAAAAAAAAAAAAAAAA + AAAAAAAAAAAMKRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMJzYLAAAAAAAAAAAAAAAAAAAAAAAAAAAMPkUK + AAAAAAAAAAAAAAAAAAAAAAAAAAAMPjQKAAAAAAAAAAAAAAAAAAAAAAAAAAAMPC8KAAAAAAAAAAAAAAAA + AAAAAAAAAAAMTSUKAAAAAAAAAAAAAAAAAAAAAAAAAABQWlkLAAAAAAAAAAAAAAAAAAAAAAAAADtWV1VH + CAAAAAAAAAAAAAAAAAAAAAAAHUdPVFJRNg0AAAAAAAAAAAAAAAAAAAA6MzA4OThHV0sBAAAAAAAAAAAA + AAAAAF0/T2NqamhkW0wWAAAAAAAAAAAAAAAAABlJISEhISEhISErEgAAAAAAAAAAAAAAACBCBgAAAAAA + ABwsEwAAAAAAAAAAAAAAACNgBQAAAAAAAEEmAAAAAAAAAAAAAAAAAABAXwIAAAAAFFMRAAAAAAAAAAAA + AAAAAAAbZ2UPAwQVWBcAAAAAAAAAAAAAAAAAAAAAGl5iZmFKIgAAAAAAAAAAAAAAAAAAAAAAAAAkGR5c + AAAAAAAAAAAAAP/n/wD/w/8A/8P/AP/H/wD/w/8A/8P/AP/H/wD/w/8A/8P/AP/D/wD/w/8A/8P/AP/D + /wD/gf8A/wD/AP4AfwD8AH8A/AA/APx+PwD8fn8A/jx/AP4A/wD/Af8A/8P/ACgAAAAQAAAAIAAAAAEA + CAAAAAAAAAEAAAAAAAAAAAAAAAEAAAABAAAAAAAAP09nAD9QaQA8UmwAMk9+AFRkegA7W4AAOl+HAE1n + hABUZ4cAVGqDAFR5nAAnfscAPoS7AE2FngBLjKoARYy7AE2SsgBsiqwANIfHADSHyABOjcEASZrNAFCQ + wQBamMEASZ3QAEKg0QBUs90AbKTJAEim6ABSuuIAVrvhAE23+QBVtPMAVbr3AFO3+QBIzfwAXsDwAFfB + +QBcxvkAU8v+AErR/ABf0voAW9f8AGnG9QBl1foAa9b7AHDU8wBx1fUAcd78AFTi/QB94/oAdOn+AIai + uACVqbsAnrnOAIKw1QCUutsAocTgAI3j/gCP7P4Ak+7+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///8AAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAMJAcAAAAA + AAAAAAAAAAAADBoAAAAAAAAAAAAAAAAAAAwpBwAAAAAAAAAAAAAAAAAMGgAAAAAAAAAAAAAAAAAADDIH + AAAAAAAAAAAAAAAAAAwrBgAAAAAAAAAAAAAAAAAMMQYAAAAAAAAAAAAAAAATJSgbAgAAAAAAAAAAAAAU + IiYgLh0BAAAAAAAAAAAVJiM9PCE7HgoAAAAAAAAADScSEhISEi0CAAAAAAAAABUrCAAAABceBQAAAAAA + AAA5GTMOCQssDzYAAAAAAAAAADgZLzQvETUAAAAAAAAAAAAAOhwQGDcAAAAAAP9/AAD+PwAA/n8AAP4/ + AAD+fwAA/j8AAP4/AAD+PwAA/B8AAPgPAADwBwAA8AcAAPHHAADwBwAA+A8AAPwfAACJUE5HDQoaCgAA + AA1JSERSAAABAAAAAQAIBgAAAFxyqGYAACAASURBVHic7L13nBzped/5fd6q7gmYGWCQgQUWG7B5uYkr + UqKYTiQlynJQsGTZ0uf8kXw+ncP5nGifbVk6SZYln08SZeVAWaIoUaQp0gzLsGLaXWxebsAmpEWOk6dn + unu6u+p974/3favequkBsNyEAev3QaGqqyt1Tz+/J77PCxUqVKhQoUKFChUqVKhQoUKFChUqVKhQoUKF + ChUqVLjMIG/0A1R41fFa/U3Na3TdCm8gKgJY/Xgj/4YVKaxyVASw+nChv9nF/E37HXMhYX6l71e4BFER + wOrA+f5O5ffkPO9d6Fr9hNic5/2VhL4ig1WCigAubVxIgPttS7CtLnCtleAFWJf2mdL75yOHC+2vcAmg + IoBLDxcr9FLaVufZ1++64et+mr3f4t/Tffb1W5evWeESQ0UAlw7OJ/hloS8LvH+tgv391ivdxyPU/KbP + OmU5AfR7/c24DRXeAFQEcGlgJe0s9Bd6VVoiIPrAP/z2q6/ZMX7N2Ej96loc7Ygi2a6UbFZK1ithLSJr + wAxiJDbGJMboJa1ppVrPp1rP9Hp6sttLz7aWeqdn55eOHTo2+9KffOq5Y1gBT92i+6xDAvAkAf2tBFZ4 + XeENQEUAbywuRvBDrR4RCPyv/rv3fdsVW0bvGByMb4sidcvWTeM3jA4P1yKlGB8fw6QpG9auAZOCTsH0 + 7NovJgWdgE7odnvMLi7R66XMt3o0l1Jm20lvotE7tNRN9i82e8+fPNvY+6v//YkngQTokZNCuGiWk0JF + BJcoKgJ443A+v94LuyeACIi/++3XjP7oX7/1neNjg28bGRl+29bNG28bH9/I2rUbGFkzbAXaGCvUXriN + toJvUjAJaE8CiSOBJCOBbJ/Wdju1JHFmvstEo8e5Rc2Jmd6z7U7vyYnp1mMf/8KBh/YfmW4AXSwppMH6 + fGQA53cTKrxOqAjg9Uc/rV8W/NC0j3/3F77vbVs3jbxndHTku67YvvNNG7dcwYYNW+3ZRgdLmm9nwuzI + gJ7bTiwhpIHQG3ds2gu20wIJYBJINZ1eytGZhJMNzUtTvecXW72Hj5yce+A3P/LUo0DH3qhgISRc2Crw + qIjgdUZFAK8vylq/n8aPgOiuW7at+Vf/4G1/Y3ztwPt3Xb37/VuvuHZw/cYrQMRqeb9ArvmNN+vTnARM + arW+cS6A8UTQLZKA7pXWK5MAxspyp5twZDrh+QndPjGbPDA12/rqH33iuXvPTC4ukJOBJwRPBOVAIlBZ + A28UKgJ4fXA+c99regXE3/uu69b+xA/d8YMbN677wSt2XvOOXdffxsDASH64EbtZIAFTtAC84GfbTuOb + FEwncAW6TsB7geAn+f5lJOCukTrCQTsS0ZycTzkwrXn2TPrIxEzrr/7inn2fO3xibg5YwroIoZvQL3hY + kcAbgIoAXntcSOsrIAbij/23H/mRLZvW/Z1rbnzTu7dfeTNRfQBMGArwJECJBErmv3HK1ujAz+9aIU97 + Vvtrbw10HAEk+fvZ2hOCtvsSJ7tZENHkFoe28txoax47pXn6dPLQ2cnmF3/ljx7/DNAiJwJvFZQzCZU1 + 8AagIoDXFisJfxbJB2of+qW/9c7tW8b+7jU33PIj197yVolqg6AFxB8WnGbCWp+SFaANREMQDYCqgarb + 89UaUBGIu5b0+bP3GtCbh/Y56ExB8yTM781JIPWBwSQnGa37kgBGc66RsucE+sC53r0vHZ/79Ic+sfdB + ikTgLQLt1hdbR1DhVURFAK8d+gl/wdz/Z3//27e+9zuv+Yld1+z+yd23vXXz8OgVWGPAm+vucFF2W/yl + IucKGJC6FfCobq0F5Y5JLYEYEUSpXPhfLlpnYG4vTD8BjcOlmIDPGDjBL5EAWnNwKuW+o2byyMTSp7+0 + 58jHv/HcuZNAm6JFEAYLKxJ4HVERwGuDcgVfmMePgNqf/Ncfet+unRt/avftb3nPFdfcATLoNGovONQL + vksKZEQwANGw1fRGWUNAsCa6pBitXVjAOOoRJIoRVQcVIRJaES8DaRvOPQhnH4D5l4B0eUygDwksdVIe + PGl46Gjy0OETc5/4408+93VgEWsReGugx3KXoCKB1xgVAbz6WKmYxwt//X/+7o/9ox27dv7jW77jvdsH + h7dawdZL9ixTzgJ67a1AjYKssZcUBRiMTjBpkqXwTNpFdxYwS4vopQXSzgLp0jRpdw66LXq9DibpYbTB + 9FJ0mmISzcCGu5HaIMO7biFet4n6us3n/5SLJ+Hk5+HM1/I4wXlIAK05OpvyxUNm4sCp1id+7Y+f+DDQ + wFoDbXIi8EFCnymA/vGBCq8CKgJ4dbFSQU8ExP/pX7736rvftP2f7r797v/t2tvfAQzb4JzpUajsNQW+ + gGgEZNhZABqTWp/b6A6kXXRrCt08S9o4TjJ1EL0whV5qortddLeF7lgy0L0uppugtcakBqMNOjWuKNBt + JxqtDWp4PfWr72LNNd/JutvezeCO6/t/4l4bTn0ejn0Ouo0LksBST3PPAc0Txzqfvv/xk3/60FOnDgEL + WJdgiTxtWLYEKhJ4DVARwKuH8wl/7Q9/6Qe+/bprt/2Lm77jf/meTTtuBR1hFZ+xAT8TmPgooAZqBFiD + jQtoq+l1F5N20M1z6MYxkunnMTPHSFsz6KUGpttAd1qYJEUnGqM1JtUuQWCF2wo/6IwEAgJwhKC1wfTc + cdpQ23g1oze9nU3v/QmGrrxx+adfmoQjn4CTX74gCUDKfYc19x5MHnr+4NRHPv3lg49iXYImOQmEmYKK + BF4jRG/0A1wm6Cf8MU74//yDP/L+q3dt/g9vfs/feOe6zTdYQZeOS+cFJr4399UIyFqgboU17WGSJmZp + hnR6H8mJr9J76Qskpx9GTz2PWTyKbk1gluYxvbZL8Tm5CZ/Ib7osgAiIe6PwAVyxkY85ikDamqN97Bmm + vvInTD3wlwgRg1dci6oN2BPjNbDp22DLt0PjEHTm8myDKT4DRrhqHNYPsrMdDe/esmmk+dyBqVPkR/v1 + SoJeKa5XCRUBvHKsJPwKqH38N370B3dff9XP3v3d3/+mwdEdztzvFAXfb5sayDqQYau5e13oLaHbkyQT + T9E99HmSE18nnXgGvXAMOhPQXUQnXRf4M6GuNADGGDEarVMjBmOVMSbIIJpiUWGpRk8cRfi1QjDteeb3 + fpnpr/wp7bOHGdp1K/HwmD2hvg52fDcoBTPPn5cEto3B7nE2nl4a2H3F1rHO3v2TJylq+/P1GahI4FVA + 9SW+MqwU8Iuxwv+3r772yv94x7v/2q64thGkC5JiU3sRiOMJI8AwsNF6BN0lTLeJ6S6STO0nObEH3TiC + 6UxBbwHEpwmNFeDU2E1r2os2htMvpQuTs6Z1rpG2Hj3dmZpcTFoi6FQbo8QG11JtxX7DkBq4dVO8ceOw + Gh4flpFd62WjdRlyd8H4rEJWduDJxBobW3/o37L5/f+AaGg0/3YWj8Fzv+7Shyu7A2fmEj70jfT0vqON + D//ZZ1/4LDCHdQna2JLisJQ4LBqitF3hZaIigG8eFxD+v/ODV19z5c/e8e7v3RXXN2PdW22FXlxoICOB + MWAjoNC9NqY9T2/yeXrH9pDM7IPWaUyyiIit9hOASGGMRidoROTU/u7inn3dc5/at3jsywenT1Cswe9X + h19GYcjxO64cvuI9u4Z33bU1vurq9fEWdG4pmDQ3GZyZAQbU0Dq2/tAH2PzdP5lftdeGF/4bnHs4Ly3G + MUpAAqfnE/7w8eT0i0cbf/IX97z4OWAeGxz0JBAOP65ShK8SKgL45lAu8vGRuxioffSDP/z+66676j/d + /q73747rm8A0HEX4dF6NrMBHtgHjgGB6XdKF07Rf+iLd4w/CwilM0kDogJjMdwfQgp4+bjoff7Bx9Lcf + mXzh7EJnnjyVFi4hEYQCBLlh7j9HlrHwnwWobx6ORv/uLSM3f991w3dsXaM2ZBaA8QTgLuaIYfimt7Pr + H36QgQ3byUyGIx+HQ3/hMhgrWALzCX/weHr8mUMzf/Spew/+FcstAf9ZqjqBVwkVAbx8rFThFwO1D/3S + 93/HzTde+Ut3v+ev3RkPbAMa1lwXBVILSCAG2WV9fg2GHu1jz7L4+K+iGyeRZAEhQaTn72BEEAzp3seT + 2f/y9Znn7z0wfRQrGEvB0iEXGE8A4UAcbwGEVkC56UgM1HEEAAwAQ8DAu68c3vXjtw699S3bB27MhL8k + hsaADI2x7fs/wKb3/QTGpPaY01+D53+j6A7oEgk0Un730d7Bh/dO/N6XHzr2MDBLniYMLYEyCVQE8E2g + CgK+fPQbzRcD8c//8++69s5bd/7M7d/5zrcPjV5pNT8+xx8cLgrUlSDrAYPudVh45h4W7/95q/W7C7a4 + hhSDG4NjkKef7E39+O+cfuC/3nf2qZem22exgjHnllm3TLv1TLBv3i2NYFkMloXS62awbmIJpQksHZ3v + TX/mYPvFPSc6L+5aG4/sGI03iUgxs6CApMPCc1+lN3WWkZvehtRqMHIlDGyGqSdy0S0FBkcHYKTGhjNL + 9fHWUu/IxHRrkWKFYLk4qPx3qfAyUBHAy8P50n31f/tT7/j3d7397T+8dtNNoBexSguyUl5PANHVoDYC + oNuLTH3t5+h8488w6QJGLwEaI8b0ekZ3EmNOH0sXf/YT00/9u3tOPnxusTuFFeA5ciGfdtv+tSeFBrlw + NykKdMstvi7fb4dLa4X9SxOttPHpg60XJluc3TUebxgfUmOeCEQEUYIItE88R+PZ+xi77T02QLhmBwxu + siSADTBmcLbJ9jFQkVyxyNDQk8+fe5r+w4dhuf1RkcDLREUAF49+fn9mLv/P3/vxf3Lz7bf8621X3Qmm + C6ZJlkTP1gpqu0FtAiBZmOLMH/8ovWOPYVQXTII26I5BN9p0zkwlra882jr2v/+Pkw8+ebp5AlMQ/OnS + OtT2odCHQt4JljBO0Cltl5clAuEPr/HCVHfio88vPr15OOba9fGOOJKY7CNbIkgbk8zs+Thr73gv8ehG + zPAOGNgEk98AMct1uRGu3SDMdNS1a9aN6WcPTB2kfybgfLUCFS4CFQFcPPqZ/hFQ+/Cv/O333XDdlT9z + 413vGLWDembIR+4Fw2/jqyDaDkDSmOT0h74fvXAKlFWDBkO3h55v0j5wqjP7iUcXDnzkydl9M81kxhjm + ybV9uMxgSWGBXMOXhb1XWhKWBweT0tIrbft4QhhzyIjjvuNLR4/MmxN3bBu6eqQer7EZD/fxFZB2mHv0 + 04zd/l7i0Q2wxnU3mn0xr18Iv2YN12+KODindtQG6lMvnZg7Tf/BQpUr8ApQEcDFYUXh/0c/9tbt33n3 + Nf/xzW9/1+1qYBskZ21025bZ5adEm6Fm6+mT+QlO/f7fQi9MgNKI1BBRpCl6pknr6aPtsx99bOHAnpcW + TkwtptOpyQR/yi3e3A+1fYtcOPt14OnX1luXXvfbX272GWYXvMXQA7qHZ7szXz229MKbNg9s3La2tkWM + QsQtaEzSYf7xzzB6+/uIRzdgRnfbQUWtM/bbLYlyjGHbmAzvm1WjEzPtfY3FTpNiOjCMB4QZjQoXiYoA + Lg4hARRM/5/5P7/rH9959+3/6+iG6yCdtea/BKcJEK2F+u0git78BKd+5wdIW5NIHNlFwIgxza7pfunJ + xtHffWDuxRfPtE/PttOZ1Bhv5k+Ra33v3/sUmRf6Dss78/bzn8sa1PR5T/dZwgYertNotnSBpNFJ25/c + t/j8jrEBdeOW2nWivAGkEKXQSZf5xz7L6G3vIx4Zh7W3wPRe6M7br6xEAuuHhB6ytUldP3dgal/p861k + CVREcJGoCODCWFH7f+i//NC7br3p6p+9+qZvW4MAyXTu64enD94Naoi0Oc/x3/pB0uY5VCxIJM5EVpjU + 6D/+8vyLv7Fn+rmz872pVpLOGcMMudb35r4XfN9dJ8yPh4IRCv3F+MwrleCGxBBeLySYstuQfuVI8+j6 + wVrv9m0DN4uSvOJZCTrtMv/YZ1j7lh9ADY9iRq+Ck1+331XBHbAhgivXKfZNs1Wr6Mzx042z9I8HrPR3 + q3AeVARwYZS1vy+Sqf/zn3zHf7z9zW9+c7zmSuieJk+Ck/v99Ruhtg2TdDj15/+czvGnURGoWOWDcRTm + dz4/++wHH5rY2+rq+RQTmvyTFLW+j+KXu+msFCmHlYX+YlAmg7IlEVoEISGk9x9rndw4FHfftK1+S5gd + QIFJOjQPPM74W/4mUh+z39nMfrt2ZcYeNYHxNWro4KyqP7Nv4kmKsYyQ7F7pZ/2WQ0UA58eKOf+P/vqP + /uitt17zrzbteJOQTINukwX8jLHraB0MvxmA6Xv/gIVHPmLz5Zq83R/wm1+Ye/ZXHpx8JtUsGJb5+z6t + 58tivblf1vivR2VcSAb9iCAkAw2k9x1tndw0PNC7dWvtFhEy0lNKSBsT9BpzjN7+PvTQDph6xroCIoBB + gk+wZURxrMEVamBw7tCx2aMUhwz3Kw+Gygq4ICoCOD/8D8gn8WMg+p53XLf+e95143+47c63XK3q49A9 + Q+G35n7AjLwDVJ2FvV9l4hP/dz68FsEYg1KKj9y/8MJ//vq5J7EC7oV/ktzs94G+MOoe+vYXqoZ7JUSw + kgD1y8OvFFQ0Xz/SPHHt+GDths31G7L0oAgqEpZOPE+0ZiNDV96KWbMdTj2AHRwF5WGK28eUPHFaDx47 + Nf/MUjdtk8ceLpQZqLACKgJYGStp/9p//sD7/96b77z+p8Y23wTds2A6eb7fnzJwFQxcTbIwzak//qeY + pXkQK/SeBPbsb534v+458wh5RV8o/LPkhTzlBpr9IuBlvJpCcD5NulIgMXXva8B86dDike+6dmTX5tFo + uy0Sksxgah1+irG7fwAZWg/taVg87mL6UnAHxgaFhURtbiRx49Cx2cMUv5OV4gGVFXAeqAsfUoFgoMyd + t2xfs23zuh/etvN6+1NLF8haY/tRbsQwdCukKdNf/h10c9r9LAUjgkE4Pttr/OsvTjyG9ekb5EU9vpS3 + rPn7tcrq94N/LTRgv2uWMwbe9w9rBRbc55gFpv/1Fyb+cKZtzhAJxM4KiBWSLHL24z+NGhzB7HwvJlrj + lL9gRGHEbWv43hsG2Dg+9JahwXg9MIIdR10n78EQMnGFC6CyAPpjJe1f/5X/8H0/eNstu/6PtVtuhs4Z + 0N3iz02ANTdj6ttZfP7LzN33J6SL0+4qtqnGUs/0/uVnJ/ccmOqcwwpIOdo/j430h/7+hczc19PsvZBF + 4NeFWMFsO+0tdKNz77xm8K1RRIwS+53EQm/yBNHoZgauvB2TtJH5Q0FGwLlUBoZiaKSycbYTTR05OX+U + 4ojHfrGQCudBZQFcGF77KyDeunH0r1+xc7fdlS7aoh/tfnN+Zp7BGzDtBWbu/W2S+bOI2KCgGIMY4aNP + Nl58+ETrNLnp77W/D/aVhb9fCazHG/GDX+kZwkBggn3+JfIBR3Mfe2b6ifsOde6xBUL52AE1oJi69zcQ + iWDz26zGR/KJj1D2JhresqPO5vXDdwGjWAtgADty0f+dygRVWQQroCKAlSGlJfrNn/tb37F18/h7oqHN + 0DlFNpIlJIHBazDUmHv003TOHLBDYUWcqSW8ONmd+uUHpveSm/6eAPyIvUXyYJ8XpHLUHS4NTdfvefxz + hiTQwX6ueWD+H33q5J+fmdeHlbLZABFsXUTSYO7RT6FGNsHGuynMgqTBy/b14xHXbxu85a6bt9zGxZNA + hT6oCGA5ygZ95gLs2Lr2PTt37RokXgvJPLnPT04Cw7eRNCaY/9pvo0xSKAo0Cv37j80+hy3i8QLh03zz + WFLo1/3mUm+DVX42/7z+M/i4QBP7Oec++Wzz4+J7oihbH6AGIqbv/TXSpRZmy1ucByCWWQzZa60N7949 + UN++ZeQOrPAPYQnAj8wMYwGhO1ehhIoALgwFRO9527VjWzaOfc/ouu3W9zc9sg6angTidZhohMZjn0J3 + FkGMHfrvUl/3v9Q6cc/+xWPYfL7X/n6cvhf+sk97qQu/Rz8S8O5AOG6gCTR+7f6zDxycSB9TkbKd0RwZ + RAMRsw98GLXheszwdtePUGVhAGsJCHduqzM2MnDj2EjdBwMHKQYDv8m50L61UBFAf4TaQwHqx7//rnds + 27z2Bmrj0JksCb9bj9yGWWqy+Mw9GJ3Y8ldXE2TQ5lf3zDyDFX4fHffNOXx1X7+ONyEuVeH3WClTEFoB + vrlI49fum/tTIlBKoZRCIiEaENovftl2TFr/JvsXcCSQRT81DBjDW64a2nHTtRtux1oAQ1gC8G3NyhZA + hT6oCKCIsvmftckaXzv0ti3brrR+adqkMBWWXw/upHngAXRzCjGprWQTMCLcf6x9bN9UdwZr/i9Q7MwT + lvauNN79Uhd+j3JMILQGvCXQBha/+OLM/oPnzKNeZJWyaUGTNGg+/3Vk+5tdKtCFW4wKrizcurXOpvHh + 6+nvBpT/llCRwTJUBHB++AxAvGnDyLsG12yC7gT5dNyB8Ne2gRZaz34JOougrPQrZYf6fejxxj5sRLyJ + JQC/+GG85SKf1Sj8Hv0Cg+V4QAtY+B/fmP+EqAhRUeYKxAOKxqN/hhrZCkObLOmKT7L4mIDhzm0DrBmu + XYMlAO8CeCsgbMNUYQVUBNAfhZF/v/rTf/3uDWuHb6S2DjrTZI3yQxIYuZHuxFF6k0cwaQ+MsjN9AacW + e/MPHWudw2m+YPEj+vrl+i8nlIuFfHqw9fsPn3tqoaVPW1G1DCB1IW2eJJmfxKy7xU1eIllBkC8VHtQp + t185vOPm3Ruux1oAgxQzAdXv+wKovqAcZTMxI4Ertqy9c8uWbSCxy/2b5SRQ28riC18mbU6jIpWlt0Tg + i/tbR8i1nm+46XP9KwX8Vqv29+j3OcqBwSWg+cjh5B7lGyUrEBUR1WIWnvwMsn43eRrAWQJG3GK4dn3M + pvXD15C7AJ4AynGAyhLog4oA+iML/gFqoB7ftm58E/TmsSW/pkgC0RCGiKXDjyK9FgaDQeN7ef/h47MH + KRKAb9vlCaA8om21C79Hv3iA/6zeCmj/1v3n7hVlG4b4uVJkQNE5/iTR+t15CtC4WYowjiqF6zcOMLqm + vhOr/X0gsMbKZcEVEQSoCGBlZAVAG8eH7iQag95MLvghCQxeSzJ9BNOdAdEIBiWCKNg32ZmYaiY+0Ocj + 4N70v5jGFpcTQisgiwc8dXLh7PQCB632t0SgYkE3T9BrTGLWXJEZW/Yq3h2AGzbUGByIt2G1v5/DIKwH + qOIA50FFAMsRag31gX/4rqs3jA1eRTwC3TmyqH9AAiZeT/fMs0jSCSIHtvHFg0ebp8nN3bCzbnl03+Wm + /T1WsgIK5cIHzyaPEolzAUAiWxjUOfY0DIwHfGuymAAC6VLC7q1Dm67YMupJwDdsqQYGXQQqArBY0f+/ + 6srxa4cGRmLUECSLruQ3JAHQpkbvzIvoTgslLv/vLnT/kfYp8u68YRsvH/j7VhvAEhJBghs5+MiR9qMo + gUhBZAOoUV3RPf0cMrKp2CnMxQSMFozR7BivRxvWDW4lzwKEFgBURLAiKgJYGQKosTUDV60dX+eE3w32 + 8SSgDTCAWVqid+4gknQwBpQR4y2BB4+0Jsn9Xb+ETSy+FUz/MkJXQAO9/+/eY0/7WdLtWiGDEen0PtTa + ne4Mlw3IyoJtYHB8UDG6pr6JnABWGhNQ1QOUUBHAchQDgLVo58iatZYAvBrKSCAl1XWSuZOkizMY3UOh + IRJRkWLfue4kxQExoebv18PvcieCfsVBPhbQnWuog8r1DMRNoqyTBdJu4sx+FwhEsisYY9gxVmNwIF6P + FfxyGrDS/udB/EY/wCUMAVQUqW1xfQ0kLZcB8NkljTE225QunEP32gipncHTGCMi4oJ/vvqtPFvvhTT/ + t8KPNowHdFtdzm1Qcp1yeX6jNKqmMNEweRDAnmb82ABgOBLq9WgtVvi9+d8vDXi5E+zLRmUB9EcWAxhb + U9+JGoS07XRXmuWkxWiMKNLGFHYyT4MgiJ0p05xZTJsUi1/OV/Bzueer+32+giWw2FHnUBIMDlIuDnDQ + 9QewZn8QfgEDV66LiSM1Qj5fgyeAKgtwAVQWQBHlH6iMDEYbUQPWAkC7KrQ0O8zIELpxDtKuHfQTGUxq + lc3zZzvTFKfb8hF/WC785ee4XNGP5AyQHpvsHbjpuhhS+7Yog6oLUb2OyZqu+G7BJvsChxRESoZZLvyX + 8/f4qqAigP6BoWwgkAhriGqQduzPVEyBBFQ0RLIwgdEdlBGMikBpbZTSM62kQ7EOPmzkqYLF7/tWMFEL + oywJvvfFrmmIa5qKtt+ziQydU88wYPKvxgb/7JYYMIlGKRkkb90WBfe4nK2qV4yKAFaG/eEYM4iqgV6y + WQARiAyZBRANottN27AqtsEpg0InqcSiwqCXCa7rf/y+J2O/EuDLESHZ+s8faGuVzadCLHb+hFghUYzR + Q3YUpvt2xKUCDKCTFBHqFAW+EvqLQEUA54cYTR2pgXY1Oyay2klZd0ANDLrmH7bwXxlMqgxpolKyBvf2 + WuQ/+BpW6L0p8a00q01WZOWWLG+fGhOJRKDEtlKLQGpWpk2vvSx4YDcMpBolEhb/hPn/8L5VILCEigCW + o6A5NMaOUzVBaz5jtRMKVDSE7jVQxoYAjRiJRNEiTbVkkwXEWKEfwNaru7OpsfKsNpczQjeghqvjf/Tw + 3Nkfi4cxRhATYUyKREL37H5qcYRSkXXB0GBA3FdmtAHJhL5MAhXOg4oA+iMkgdRlpPMYANpZAtiS304L + EylQ1ifVoKPBqBZF4n/gdazgD2ODgZF73a8S8HImgmWVluTkOHzL9uFrUQpJtTsyghhMZw4TrccYHUwX + 5uoBxCAiaG00/c3+yhU4DyoCuBBM2sMkkc/955krAzoC00VqNcS44L4CEVEspZ2//wN3vPuffuDm99iq + FjdPl8l2oQAAIABJREFUtnJegN8WBcpZw76BIG6fxE5U3PGFY3z4IBiVmOXHgmpFX7QkvkiuNIwZKGQ3 + yp2OsrSnS9lrgMTdM823derunbrt4D2M3Yfbrx3vmdRaVu6YtNtBRQotAjpFfMGPcZOKGu3aL4r750g5 + Vmhtktfk73+ZoyKAC0BrltDpoFP/ZA1ABWsNJF0krkOyBNgeAJEyUh+o1b99YE5Gt8DQNdfnAh+5sSoi + ELmEt/JjYD0pRKU15KThSuTEPYRxxOSFriDIaUAOKTAEMuRe98jG2Xth16nb13Pn4QTWD4H29+k5l8gJ + sBd+03PHd4PzusF5CZiuvZZ229o2V006bZqT05g0QQlo5QgzceZ+UATk6zCMMweUiki16b0+v4jLC5Wf + 1B9BjEk37Q83dj9gkx9hNKRLqNpQZtQarIIerFmd33zuIZZOvkQ2zC20fnVgEWdpLkX+IzdOkwfn+XGw + JngG3yzDk4G/ZmFRkLZAN92ucswsyEYWSEY5EgqupaLckvHBfG+pIGSVPMptK5U/kv+SAovGGENrdtoS + qru2UoIS11mh5y0OnVs4xlkjxiBxRKrNUvh36/e3rLAcFQEsR+EH0+6mc6RLoOrFkYC+Lq23gAyN2hlu + AHHmfBRZC1YEWnsfIJmdDK5ucoEyEmg2f4A4gQrIAAKhd8TgBUL7Y9yf0zXLsJB8n4glgLSV7/ekJKGw + umfzbosnCHH7/HWz97HvG+2IIbivCe7tr6HyYLwBWjPT+cfObhMhKkaMoNPAtTEGyYZi288ucUzS0+3g + 7+fvWuECqAjg/DATc0vHSBwBIIHg2Wif6c4Tj4zbo30bMCVo3Ay4SjCkNB75HOncDJmweRLJQlRO8LyP + 6zU9AUFAQfMVqgdEQNL8Oj7LGPTQs9vKdTVuOo1NUYhRgYZ2Gj6TyjiwYoIxz5mREdnnyiwBAkLxVkA+ + HaURaM9MkSZd+90phUSqUMkvGmprRhE0ojWCtuE/RwiC5sVzS3R6aZOAIv0twr9l6XUFKgI4HwxgWu3e + uTRZAjVIVoDuSUAMpjWNqo84c9fNdackj9M5QhBSFp/8PCZZcpcPg9OSm8eQm/j+MYy7pycMMcVzs+MC + AiEQ/IKWd0Lea1oiCGtxQpM/I4Igu5aRTegSeHdB2fspyW5fIA/lw02umEqEzvw0JrWBv6wCUEBQdlEC + qbFxALBsYHQg/NbyUQN1Ot1kkVzzfysOsf6mUBHA+bWFWep0Ty0szEI8lGt+gESje110cwE1uh4RIVLK + yo4IEjmN5gkhEui1aT76PzFdFwiTyMYBQoH3/ryPC3hLwf+0Ux1YBAmhNVKICwB5rMG5B/59714kTdvk + NNTqnkiyETle20fOuFD5+ZllEMQGTGDqh5YOOo8JGEO3MYnuNjO+EiXYCUOVrQIUrPWUGuJYuSyLQcTY + 6L8nADQvnG2z1Ekb5OMtQjeg0vznQUUARZTNRzM91z7WWlyAaBiMwRiN0QnGpdGMbhOv2USkxClB5X7M + 1s/1MiQISoFenKX56MfJBDxQ4MtMf8jJIHQVjLbEoVXpZ+595eA6BWPBm/jBNXUT0gY2kKeKQu+vk8Ur + /HtB9W7mPvh7uOCiBIsKkk0i9FrTJEsNJ/hO07tpwokcEUQu9dd1qcVQ8MXNGGhSRAwto1hodmfIx11c + zHDrClQEsBIyDXLw6PTR5uJsSjSM0RrSxKbYUksCUayJx7djYoX2k1wqbE87JSjJp70iUkgtwnQXaD32 + MXcnb6p7E98H7XxuHqvBfaAvW5KArrzVWzL9s59/+Nrkx3mfP1mEdAFwGtyb/Rkh+Ch/SETk/r3EOXGI + KR7j50Zz66QzT9KaQ+IaqNhNDOqnCs8tJk9W3ZkmUZQgvtmq+9DiFxFOzHb0bKMw8lKXlgoroKoDWBkG + MB/97HPHfuqH33rmultHd9i9xtapa+urGgyqpojHriBtnLQ/dOXnBQgCYS5A6AVJL07ReuTDDH/HT9hb + +TEG8SBEo7kWjsecVvVaW0AGQQ2c58lLik8N2HOWHdeDZCE/3gu7//iF4GNpuEJnOiefzE1x5ki3Ab1G + 8CzWd09nHyRZPJsRhESC0W7idFdwJCi01ogCvZSSLnQZ2jTsipmwAUAkW8uaYb6x/9TM9GxrGttsxTdc + 6ecKVCihIoDlCCPJGkhfPHL6yXemzR2mtg5aEyARtumf6wvQmSTefDXpwimUF/Ys6B0Iv8pNZhHBdBbo + HHyKgbf+G4jXvv6fVGpQW//NnVsvnmcWTvsttO5hnKtiFk8i6Zx1nVrnELFDKzCgsYJu+SfCFhYZ+x0a + g+52qA0MOlK11xbn2lgKMBxv12gtJVPkgh/2XqgE/wKoCKA/PAGkQNJodl9ozk3+zeHaGEafzQ7IzO3W + BPVN19E79giYFJVV9FktBzg/N0idYbkgPbOH9j0PoerjyPo7rJ7feDeIHd0i49e7g925A2uRwW9SaMtI + ljCts8GndrKiarA0m30Vxhir0buT+NJg030J033eBSB1fr4fpqttPb/RVlABSFMn8JYdlZvdh+zY2Aq7 + scSqG11UpJ1r4P8qBiPGOTLCCzOahcXOOfLWa2ULgPOsv+VREYCFd4zDdWYFHD89t3d66gzD23fYwJ+x + qSzjCMC0Z1DbbycaGkV352wAS3BzA4R+bTFgJl6zGZC0AdMPYGKFmdsDStDl8yJ/vvWXs0i7d80jFyD0 + xxtjrQ/jA34m/3TavmczBNjPlFnyGhlZi6wZda+D2AM+/mDsM2Dsc7nsg3GugmQmUEAIUWyPT22dvzEm + jzdiQFy/f2LodOidmmFwrO6E3+SZSf8xlLB/ssNso3OGfNJR33atnAWohL4PqiDgcpRdAP1bH/nG00dP + nTrJwHqMURitMWlqF60xnUVMZ55ow3VkNfsitrW1W4hVMaYWA7GCSNkUoZIs/SVxVDjP98sXFdslju37 + NYXELuUYRzagFsVWYyqFRBGCymsUYv88Ys9Vkl1foig7T6kIaS4grUVXkZfPc2gtGRf0U7G9tlI52SmF + +IrCMMCnBN8fRSJlY401cQkDm4EQFbkIP5glAz1B1ex5Pg6plE0FgkGGx/jG4dnJE2cax8mF3xNAlQm4 + CFQEsDKyGACQfOOFI1/XvZb1fbW2Gk1rTJpgdIqeP0m88VokckEtsRkAcfGATENHkRVWJ+QqVkisoOaF + Nhd4mxKLrFBHkSvGcwJfi5xwuSIaJfm9YifkkRQIwgqlgjh2Quvu6cmpJjagH1uCoL0A7UVEYiSqI1EN + UTUr0L54R8UuCxCQgS+I8lZAluOPXMGPPd9gnw1l3PHiyEBIphrEwyrPJGIsEfjXkeGxCeHMucZpim3X + fSAwzAJUJLACKgLoj0z74/rWn51afHzi7EkY3miFPkntOrWj4fT8cWR0F7WxrVZLRsZl1EwmbCq22l4p + QSmFiiIr2LETjMhrUslr4b1gZ0IfZeZ/JuBO4P198IIZeaH36tNZGpAHJP06PFYFZNGet0Sg/DkgzgIQ + FWdCbQc+uK7cUf4cEtlnttcXe05kPU/xbpSKnPVjCY9E0zsxz8Bab9VYN8NXGPtH/sbZlNlG5wRudiGW + z7tQmf4XQEUAOco/lEIg8JNfOvDIiTOnzsnQNuvnOjeA1LkD3Xn0/Clk/Q32h28ilya3wqci5dL8CuII + ajFSj5BaZF9ngu+0vfLCHTkBt79+6z64LIOoXFijKBB+q1Wz7ciZ+FGUWRmZVZGRhmTHZi01IxdnaDeg + vehMfifYfoSgyp/BCqv3c2rF2gEBiSI3hNdkroWKXPWfRFm03yx2bc4/jtxHEGv6K0ueRGCG1vLg/pmp + E2cahynOuhRqf1P6W/b7O39LoyKA5TClJQWSl07Mzn/1sWe/0E1TZHibrQbUGqNTt2jS+aOoddeiaoPu + m7VCpbwfHEdQt4IqXli9cCgnoFHgqyuvNd1SCwQ+jouCK5BNsa28P53HBLLAoB9n72sSVG56e+sie5aQ + FFrz0Jwnq/v3Qi++viGv/MuCnqrmXAN7TWPIBD8rK0acT48NEhpD58UTrNlcd7fyboy/vI0BPDZZ5+SZ + +eOdbhrOvOwtAD/pamUBXAAVAZwfBTfgyMnZB86cOprKmu1ZVaANBtpCF904TrrURsZvsL/WyA5ryQfE + SOY/EwnEkfOr4zxY5n1rH6xT4iyEPLCWCbz4IJsfTCPFJTP3o9w/h9yGziN7OSF4onBVS+H1pbNgXQLf + ySgLBLqgpL+HdyMyF8O7DMpH8jJyc2WTmcdhFrvoxS5qKMoGH4pzd/ICwRr3HU3Sydn2Eazgt8hnXfbC + X/n/F4GKAFZGGAdIgO4ffHzv43v3H9orozuReMjNV5daInATh+qZw6h1N6Fia3YTBTXusfvRe39YotzE + r9kyYbyJngmTK7eNfGYhyrR1RgpeiEO/vuDjGwjH4vcjivAa4TFZ2Z5btReQVsO5AATH2tSGJyWM+3w2 + gpcLuycGce6Q4KyBCJPC0tNHGN4yQDa0uiaZJWATLMLZ3hj3PnHs6IkzDU8AflnJ/6/M/xVQEUAR/X4w + mRsAdB54av8npyZOIqO7nBWgXWlw6spdD5F2Uthwh01pxQpi7xubPCIe1WwaLBYkjsGn27JgnicLnw1Q + lkC83y3BU0fB634C7mvxPVlApokLmr9gAVAScPe+MdCag9a8ywj4VmaeTHxKz11KKXeMAjdISFQ9s4q8 + y4ICPTGP6WiisUH7XWCDi3bbkoAR4S+eT5ieXTqM1fxNt3gXwMcAqvz/RaAigJXhfzjhCLPun33mxb96 + 7sCBI7LuaiByowNNFgcATTpzAFl7CyZeY3/kXoMrl8v35n0UW20eR0gttj5wZjqTB+28uZyFwLHH+BgA + 5NZCprlZTgKYwB1R+evCaEPy62StvHygIti3OAvN2UyTZyk+cJaEcw18atLHFtzzZhaE/yy9lKVnjjC4 + tU5W6ZPdXrKA5LxZx/37Zk4fPjG3j5wAWhSnXa/KgC8SFQGcH2E1WQJ0z003G1948KmPtdpN1LqrslJY + E3QKSmePkMyeQ8busrITKZdLrznBzSv5svy85Pn5LACYaftAA4ssF86C1vaE0Occ/9q37SofW7AQgrUn + HcLrYUlgcdaa/167Z2a/P0cBkeMQY9N8Luhnj7Wdjzv7TqHiGKnH+b0d4flOwMYIn32pxpHjMweSVC+Q + a/8WVvv7AqDK/L9IVASwHGXzPywI6gGdv/zSwc8//PQLL6n1uzHOCsDoLA4gAunkC5iR3ejadvDVeApU + zUXafYDPm80+DRjXigE/b4aHWnmZ755rSGC58EORKAqWQKj6g+P9dmhh+K8mJJzWPDTnAhfEEZtvd57F + JLw1EzT+cO+bhQ7do9PEWwbxYw9sKwOTNyfWhjkzzscfPnnqyMm5F8iFf5FiCtBbAJX5fxGILnzItySk + z9obpWp+oWPG12rzbW+64Z1D9bro5jlXJu+HvRhM0kZ3U6KNbyLqHgSlUD7IF0su4JFyyjN2vrCPovs7 + h8KsWKbRKQl72UJAitfwrzPz3xRJwo+GINgXCr6B4CC7XmrZ9wb8kGM3VEckuJQLRBrISnlFoNejed9e + 4tEYqfuCIinewkCqFb/7RM189bETj0/MtF4CZoFpYAZokMcAqhLgl4GKAFaG9HntIllEjz179sRbb9v6 + bTfefOc2PX8Sk3bsUY4IEMG0pmBgC2rNVuL0DESxi+7n1XY+DmCFNs6FV7mBM4UAWyjgoWD3WaCkzf3r + 0CIw+BZdhWND+O5EAQ9knxPIVHR3yZHAUMnScDEQo/Nv0AX2MELniX0kjSXU2jo+tWlPFXJyMhxqbuSX + P3nw0LMHJvcAc1jhn3bbvhagXARUmf8XQEUAK6OfFQBkbXejer3XuPOGne9ZO7Yh0gun8sOcCSxKYZYa + qA23ISolYsYF+lxkP0uJedOeom/vCcELwjIBp2QhlLU9y8+B3KzPtHtg3peFPRPI8Jvp4zZoAx3XmXtg + kLLMiSgEU7AukkPHaR+YQG2oZzaWhF+1WP5JZA2/+mDSeeSZUw83FjungCm3zAAL5EFAH6ytBP4iURHA + +XFeV+DZA1OTu64Y2XzXXXffrDoNTHfRyZodv24j3l10p43adDeSzqFU0w3C6RPk8zn4bDYgclfBC88y + 7U++X8InDSP45NvS7yOZwGUI3+v3VZCb56a0DZYEBKj36UCUXcWQnplk8fGjmLHATcjmMsjl1xjhM0c3 + 8OEvvvDMwWOzT2KF3pv+c1gCKBcAVdr/IlERwPnRzw3wawWo01Ozx2+5eu3br7xy91qzcJLcbPcjASPo + LaK7KTJ+M0qfQSldDJD5gFyk8qv7AhoRGxT0UpZJi1eZJZN/mYVAbvqXLYFM5TpV69vzZOcEyMTJFF/7 + 7VDcltr2WgNDJQp195+bZ+HB50npQc26OpL5/Lnzb4BzciW/+KnDJ/fuO/dgt5dOYoV/ChsD8Nrf+/5h + E5AKF4GKAC6MUK8SbCtAJqZbvcS0Z+66aec71q0dj017Gt/oEjfGnjiCzizaDCJjtxClJ13mzJfUOkuA + YF1ou+3Kbn1+PLNDQrO+XAPg9vnOwCXhsudILvCQkwCGfOISyTr2ZPENb5GU3YJsIhMTBAaHCseaxSYL + 9z9Lp70EA7HzQASyCUqD5xvezM98bqb96DPHH5mcbR0m1/7e96+0/ytERQAXRtlmhiBGD6jnDk6d27xp + YPS2m6+/bUBp6DWzGnqiyI4EjCLoTKMZgzU3EHMKROfpu4IpHywqsAqywCC5oPsCoX6WAMFxhPvcf1nw + TwLBDt5D8nZf4VeQdQciEDFT3AZot+x60LoDZmGRxn17aTdaUI8D4vHPR0ZIpjbCn+4f5ZNffeGJQ8fn + nsIKv/f9vfb35b9h6q/Cy0BFABeHsgVQJgX1tceO7rvp6nU3X3/d7iti3QSd5C6AilCiIIox7Qm0rIWh + G1DmNKL6BPjCxZhi4Y5yHTWz9tslwS4p+eInMKVP0sfMzwTba3mTWxJQzBgYd40wNeiv4d9zJJAutmjc + /xytuSZSq+FbhRHyiPu8IjF7FnfxwY898cLe/ZN7yFN+3vf3RUC+9DfM+1fa/2WgIoCLQz8roOwaqFNT + c4evuWLdm6/asX2dJA17gG/lFUXWko9jaE+gZQwzfCORPoNImkf883bCxdfhpJveEvBzARSexBOCBE9d + fvx+DEGJEILsgA5kKZuxOCAIf7yfu0CK73VOTTH3+GGWmj2oR0jhPHtN8ddGODN6Kz//sedOvHBw4qGl + TjKBFXzv/4dpv0r7v0JUBHDx6BcHCF/Lmclmc7a1eHrzhrV3Xbtzyxp6rqde5OvgrZBLHGGWpjBmELPm + diSdQdEkHClnr+qFO7QK3O18TCD04UOhz16XfP7sLcm1dAZT3PQxAW+al/3+TOuX3IHAAlg4MsnsgVk6 + idj+g97gCbKOITH1dt7JP/vQU1N7Xzz7yORs6wh50G+a5aZ/eeRfpf1fJioCuHiE6rP8A8veO3R8boYo + mb9qx6Y3b9s4Xke37bBg5YcHW2tARQq6c5hEkNG7QHdRZibw+0PhDZxl31RfAhJYlotjOZFArp3LE4cU + TPrSpzMlIUeKFkHfY8CkhulnTjB7tEUSxa4pimv4aSQzLkzgUiQ7buPnPnti8eGnjj186tzCPop+v6/4 + q0z/VxEVAbw8rGRDh563ee7g1JlU0va2Letvu2Lz2hq6kzX6sJ2AfF28gnQBvbQII7eAWo9KT4No8MNs + MxLwRYj+9s49EN/ZPV3+tOFThZrWFNRvfmx2TnickM036Pd5n9+7A9lre83FkzOce/Iks1MJZrDumqIY + O7hXivcRUYiG9Mrb+Ll7Tra++tCBh4+emnuO5cI/Ty78XfLxGZXAvwJUBPDysWKIjeDH+PS+ieNG0dm8 + Ye0tO7esrUOSt90qtPuKEJYw7VlMtBEzeCNi2oiZdX6/N/1NkRBE5Xa0JwFfbhs+VRigKz9yXxoLSaFk + 9hesBym+p6HX7nHm8SNMHlqgrWOigRgl4sodXIMPpFh5LKCvvoufv+dY62sPH3z48InZZ1gu/GHKr+z3 + V9r/FaAigJePfv5/Xzy979zRRExrw7qRm67cPj6ASfIx/rHrnx+7Pv8k0JkCE8PwjWDWIHoWkS7ZmP3s + jk74wjp+P6efm1Une7KCj00xaFd+/CyiXzrEbxtNZoUEGYNk9DpOP/Qsxx4+ysyMhsEB2+wTyeZItIMh + w+CkawV+w3fw/3z64MJXHzr4iBN+H/EPg36h8Jen/aqE/xWgIoBvDucLCIZayew9MHm8sdSd7aXq2puv + 3jgSKePmBPCTf7h1HKPiCEwLeougxjC1azE6QunJ3C0oJx+yoKAE7kBQuJM9Vcn/L5j5FLfDcwvvk7sD + frJQDZ0r3s+Tf34vzaWEaLBGraaIIuUqlhWR8r0RcxdAaoPM7rybn/7ok9P3PfqSN/tnsVp/Eqv5ZylG + /Ffy+yt8k6gI4JvHSnGAUCMZwOw7MnO60e6eSY26eteOdePDQ35yDd99140S9HMEiIF0ETEJhjGIdwFD + iJoL7h7Y0D4wCDZFaLSzBPxxJn+yfuXA4TXLT1/+dFC0Igwk627h8FcewPQ61OuxJQBlp0WPRKz5jx/C + IMTjm9k/ej0/++GHTj7+zIkw4DdJHvGfozjM93zNPisi+CZREcArw0rmfyg+GjBHTs1PHjo1v3+umWzY + vXP9jnXrRhC0CwbiugOT9QSQKEJMAnTslaJ1qJFh6M0Ed8/N6ayEF3ISIKjiCzV/WMlHsL/85P51OVNY + iCsY0nU3c/gr90PapT4QUa/HKCVEYqdJt/6/dQeGr7qBe2eG+YXf/8oLz+4/99CU7ew7Sy78XvP7dJ8v + 9V1pnH8l/K8AFQG8clyIBDKNNTXbXtjz1MmnZpo9NT46dM32retqcZQ3xszm4cum+vLZAoPQQ9Zth9bx + wJx3tzeZes8fSWp2nyllB5aZ9MH+UJTCcH0/L9sHCFEkYzdy5MsPILpHfSCmPuBcADeRhxIhiuv0dt3G + r913ov3Hn3r0G3v3Tz7Q6abe1PcBv9Dn79fmuwr6vcqoCODVwflIAIrz1KV7908cPDm1OLGwmGzffdXG + dWuG6og4a0Bi6wJIlPfEV651+PAwNI/0SUa625Qbe6ha0R0oPxWl47NrlqyELDtgguCftxg0ydqbOPrV + PYhJGByKqdcjlIrsjD6RMLx1J4dHruHf//cHTt3/6EsPHzo+9zR5Uw8v+NPYVJ8P+K3U4qsS/lcRFQG8 + ergYSyDrWHvk5NyZZw9NPP/i0VmzbnTwyiu2rIvjSOxhWVttFyDEbjM0BM1jy/3xzA0gtwp8nl7V7Fon + +WOa8FhKPr0pFfoE1wqDiME6GbuRI197iIiEgcGYWi0ijhS1NSPonTfz23tOL/3mX+zZu3ffxIOuus+P + 6vORfl/k4wN+oc9fCf9riIoAXl2sRALefA1nGkoWmt3WswfO7X/p5OypFw/PjuzcNrpl8/q1YBLr0/uI + uy/hHRqCxWN9Lh9oaowbvutL7bQlAe8OhIKcxQOCa/g0XT/XINP+4a0NydgNHL3vIRQJA4M16kM1Bnfs + 5rH2CP/uD75+6JFnTjxy6Njsk248vxf+sLzXC3851VcJ/2uM+MKHVHgZKGcCvOBHwfuGvHVVAnQefPLE + /Q8+eWLv/qNT7/22N+1850/97Tuu2r51nT1duw5X4gN6ge/vV6bMO+JIwKcMDahBp9275H59Sfi1swz8 + oJ5+KFcJiiAmRSkhjutsuHY3e1s1/uAjT585emJ238FjM89iK/jmg2WO3NxvUjT5++X5K+F/jVBZAK8N + zlsbQHGykQQ3p/2hY9PHnnrh9NPPHJxcPHWmMb5uNB7bvHFtbgmsGYXG0aIG90Lrb1M2532xkHcHsHMa + 2kP6yFU5WxCmD6E44s+5CunIbpqnJzhYH+eXP/fC2U9+5cWnn9l/7qHJYvfecPFa3wf7fHlv2NOvEv7X + ARUBvHbo5w6UMwN+3kE/50C3003bB49OHd3z5LEnnntpav75/WeH6vV07fhopAbXb4LFE2SFP5lgBlZB + 2JknE9LAKFE16wroJDfp/bll/94/sYTHkccJ3GUX67v4l7/+hbN//qXn9z6779xjU7OtI2lqvKB7c983 + 8pgnH9TjTf6wtr88rXe4rvAqY8Uy1gqvCsrxesFPlWPXsVvqwCAwBKwBRoBRYAwYu+vmrXfu3j7+lo99 + /N/czpk99kqFabuCtd8uvw47/wrQa4PuLH/igmtAkRTCAGEwE9LM6LuTu777Fz9/7Pi5KayAz7pljryg + Z5HiHH7e1z+fyQ+V8L+mqGIAry3KMQHIf+heItNg6WEFY4l82uvW6bOLT7/lqiuuBjsBqdXyQUwAbBxA + CLr3BKa89jEEf0uBeAASA8lSfg3v/4cpP8iF31sculiPY0xqsELtfX2f2+9n6i9RFPxyoK8S/tcRFQG8 + 9vAk4LfLa1/H690BTwJeWJZqUVSvx6pdLPwJERgYqScIyU338u2z7MKgJYa0ExCFF3B/SkkeMxENgoFG + ewJoYYV9jtwK8IE+/5nKgt/P5C9vV3iNUBHA64N+JOAH2XtrIEwRemugByQDtWikHsftogUQCjjuUl5z + BzECKMYLjLuduOvUXNfexM9s1M//D15r19LcWwECRifGGNPDavkmVugXyM3+Jazwh9ZOpfUvAVQE8Poh + lNTwdb/AYGHAy2AtWowi6dnW2T7AZwJz3RUQZQ1DTFFwM83vb53aOoHUVQhGg/ZavaUgpuCfylBI/XlL + wT21iUfRxJo8mBe6L/0i/OXBPJXwv4GoCOD1Rz9rwKPfGHdVi6NOpFRSEPDwiLAqEKyQelfA7nDHBbcr + mPlAPGQJIe0G1w2qAAsNQPLrpMM7mDi+sHj8xMQCOQF4oc+sGJYLf/mzV8L/BqDSVM53AAAdjElEQVQi + gDcG57MGvDuQuO00VioVwWSj+8p+ebk/QFjKW35dMOvFVRymuTtgxAUGS/cR+twXTDzGh/7ygb0UhT8k + gFDw+wl/JfhvICoCeGNRtga8LU+wncSxSsTOIlKiDll+pcJAndIdwjk+Mo2ugwvg5vQz0G0Hh0pJ+AFR + JCPX8tQTB05/8Hc/9zzW3PdLmOILe/dVwn+JoSKANx6hSIf6OYuQq0zd9oIgoDs1m8+vlP4LLx3u8gFE + kxar/LLYgoLaoHUHei4wqCgQgKmtJR3eyoGD56bf9vc+/FlsoC/M83sSqEz+SxwVAVw6KNnyuVsgSowS + jJ0wtDRLj0ntYCEdCLQPAhY4hfycwh3DmgKwmQZj5/QzBrod0IZ07W6M2Calra7p/dHvPfzcv/jg/Y9R + rPEPZ+zp17O/X+CvwhuIigAuPZSJIEfSyP15H+BTimT0APv+8iV0z9X4d5cgitBpj9v+ya+jTu4pVgYa + A2M7OfVX/y/NxR4S10Fsk06oIfUaxkS2Mzkx8w3pfOWpvWcn23Fz/9ne9GcfOnZIaxPm/H3Zr5+150Jd + fCpcIqgI4NJGUXD0nJ11d3A4n7FXa1qPnWT6VAd0D5NqRAm6t2gvoP0MweXUoOZLT3zXeW4piPc8YOAD + f3rvk1jBDvP8vtTX1/w3sOk/L/yZG0Ol/S9JqAsfUuHSgUBnyU29TZ6mS1NeWnyLEy2N7i6BKExacsF9 + jMBPKQYIprT4S5u8tsiiXOo74ZZJt/iqv3LRTyXwlzAqC2BVwWnzJRehHxzGS6kASS9hcO0QQs2GBBRA + rySCpq9I3rrpqxij3cQlbq6C2jBrtu3muW/sn8EG9TwB+GG9fly/1/xhBqAaz78KUBHAqoKGSNk4QEYC + Q1lcQFTE8PgwJu2AMehEg/GyGCAs5nHFQRu31Nm4NraxAFXDIKjBEWo3fDutyaOGPM/vScD7/GFTDx/8 + 6ze0t8IliIoAVhVUsVvPUhuMpnduCQPMz2riwQSTJhhjGNmg+tcLBBC3sx5HjA5HzmxQtm9AvQaxYnBA + GVz3Iqym9ym/sNa/XyuvEBURXIKoCGA1QSS3AHxgr9VGVN3671ENRNk5BrTtMmxTfD4IGA4gKhYAiRpy + L93gRBODtn0EjI6hOFzZj+wrV/xVpv8qQ0UAqwpO+JXk6cA4ylJ8RlsfHqNtTXFcA/ETjLpLZBN+OsHP + xvnEbjLSOBhdbNuJSSSeMXyJckKx2s8vVc5/laEigNUEUbkFYHeQVQMCqla3FoDUgQSNq/jzx4ZVhIV+ + gIJE9Uzg7UBlBdQAccP9C4IdDl0ua/xK+FcRKgJYbfBDhbK237hmn6DcTEKYFBXVULVBiq3AJHcdElsn + 4GMAaVNgxLkM4oqPtYEE0rYuC/lKQl8J/CpDRQCrCRLZUuAadrivc+PFTw2uIlRUx5gEwU0xRjAsWKfF + 8f4BVFRzjT6UPUaJswjcfS1WEvpQ8Cvtv4pQEcCqQjBwULnXBojsn1FEgYqIXLcg7xLk5r9adi0J/X2J + IdJ5ExAV50RwYVQWwCpERQCrCX4wkG/m4d0BV7ar4hpKKecieMEtCW9pWG9GAMoFAVNjCSUjDKnE+jJG + RQCrDSIQRZYEfERfOQtARdYdiKwZHw0MYXrTrljQEYda7gKI4KwIgajujovyg1RoOVS4nFD9ZVcbglGA + 1kxX1vQXRwAqBhFrExgDyTwsNoNzfXcBVbhcpvFFcveiPHNwhcsOlQWwqqBcDQDB3H/kProz2SVcq8hW + DEYCw2vImoc45DEAZ+5nMw0Fo5IrHrhsURHAakI4X58KhdQX9VgBFpfPVzU3K7AINFs2uDcyQtgAxFcK + i7ifgiFPMYrbUcUALltULsBqQzgVmHcDJPIxfav1DTYlGLsgoHKavdWy7oB3E5yy97UAmWVgSmN4VDWF + 5OWKygJYTfD1/H4bgr4ANgZgCUEhIkjkXADv14uyvQSUwOCIPUdMRh7Fe4HtHWiWZQ4qXD6oCGA1IZwW + PJwDIPDVJdPkBhXH2FmAnJr3ir3ZhKGGP4Xs5HCWIW/+n6dDWYXVj4oAVhNCbdw3Qi9FQsDYAGE2fsA1 + EDVAeyG4TCjownLBryyAyxVVDGC1oTCkN99X4APnFkjk+gHUXBzAjxyMouBQ40TeuxcGP+13PhVZhcsV + lQWwquDLdN3LPAFgX0poARgkUojYgUJEYsf3i0CSBuf4S0lJ2Cuz/1sBFQGsJmTNPbxP75t8eEMuiBHg + xgZAXs+vjCsjjvzRedwgNPmziUe8RVBZAZcrKgJYbTCs4LgtJwPbC8TtEzfOXwXDgzH2bZ/7L8w45G8W + ZB4qXHaoYgCrCk4bax1M0b2SdvYaPegL6OsBgvEACtPH2g98jEr5X9aoLIDVBJMGIwHDun7p67GLz/17 + oU+16w8itjeAPTWbAMS+DioMs4tWeuJyRfWXXVXQOQHoCzXh8Q1ByE14bwEEJf6CnxIsoJDstcoPrHBZ + oiKA1QSdFjvtp0Gabpm2Dmr4M4te8sXvUoEFkMUPVHBM5QNczqhcgFUFnQt9dCHu9s08dbiLrC9AsKug + 4cW3Eg8CghUuW1QEsJqgUyuc2vnpShVdgVLLbzsHIKVqXpM3+MiMgdJ5vm44qzOoBgNdrqgIYFVB5/MC + GFexp0pDeYIRwibxXUP9m8WBRD4GkKEw0Ch0AUpTi1W4bFARwGqCzwJ4EvA5/kKPf5OZ8Dp1bfuzgqE+ + 4wgExI8xyK7jXYCqCOhyR0UAqwnG5KXAmlyg7Zu2BZgY1+/DYPykIAXTvnieeFPfXaN4fLCvwmWJigBW + FZK8FZhvCKLDtACWBNwMQKaXYnTq8v+uAtCPBgTXC8C4eF8pjpBfkYoELl9UBLCaYIxr2+2LdfxUX1ZI + jU5z7W00JiQH30rMUEwDZu9TDCIK9vomHzhU4fJDRQCrCcZnAfxrX9YbaGijrfAbg040mMRZAM5iyITb + pwDD+IHbm7UE8LGBKgh4uaIigFUFV6GXOr9dKWsRGGfKG+2UuBVmnSSWNFJNMItIqR+AD/hpSyhZU5Bw + +r+qFPByRUUAqwrBWADExQPySUJNOIenMZjUuMyBT+V54bZmfRYDKFsQhdbgVBbAZYyqFHg1wQRjAYwv + 9S2Z8IHJnvZ6efFQqiFxKcGwEtAPBgqFPAwEljsEV7isUFkAqxHaCaTCCnUgvCZo8aV7TvMnOugL6LIA + UTCCMKv5WR5LsMtr/HkqvGGoCGA1wWt98YJs8oi+K+kNBwYb7VwAY/K4gXalwJFCG4P4cuH8LArlhFUa + 8LJGRQCrCX4KMEMe/XdluxIE67I9vmmIHy/gBxC5VKAQDg4MhTz0/6sswOWMKgawquAaevgcPbCsaMdN + DApAajC+s6/gZhTWNi7g4nwZZUjpp1CuDqxwWaKyAFYTsgk8/WsvxW5AkJ/S27228TtnJWh3vAnOw2YC + cpSsgMzNKJBDxQiXESoCWE3w/frL04MFnr+IYIwlAaPF5vm1HSNgZxZWWTuwvBsQrjOIqxUIm4zovlmA + 0uijCqsVlQuwmuD7+4VdfcLXogCVtwNH3IQf7qW3CNy1xE0oIj6o6LuDFOYXyFqD9Rsk0G+7wipCZQGs + KgQE4BuCAD5iL6KclvdxAOcyhE0+S1OLZf0AxRUKZR2B7HEGgyjxwh+WB1a4DFARwKpCoPmVKgizlDS4 + IO5tRTlW4K9lucSRh28fHg4WUlHeQjwXek8CFRlcBqgIYDUhj91BoZ+/OPl25r/xwu7lFLI+f1kg0L90 + MYWyG+AP6nZ9+lFja4j9uhL+ywAVAawqqJIWd8j2OQF31oFIRN7au2QBiHI9QiPXSMRbAIawMajMneKX + PnX2CaAXLClFEqjIYJWiIoBVhYIJUHwni9nlqT5T7gQUmvfeagh3ZRaAIwGt+emPHHn4z/dMHwc6wBLQ + JScBTbFReYVVhooAVhNWlH9vskNWHeiIILPoM5jCWeJnCsqCi9nAAD7/5OzRX/zLUy8CLbe03dIFEpa7 + AhURrDJUBLCqoMKgXAlBys6bAwoKcwEWLiWBMRBYBa6a8Okjzanv+8UX92AFvgUsAE33usNyAqjSgqsQ + FQGsJsgKMQCg0N7bC7LxtQHhW0JYTKSk5CaI4tCZVuN7fuGFB/7/9q42Rs7rKj/nvjO7Wcde22s7mzhO + QyFQUSKlcoGo4IoPCQkE6q+qlZr+QSJRW6Bqf5RW4UcVRBCiFVFBtESi4gcI1DYKaRNI67pJkzQkceo6 + SWPXTmzHH5tdr/f7Y3ZnZ+a9hx/n3Pe9887YBgHJ3vF5rKtZrd8d72p9nns+nwNx+RsAlqMTE4BVAhKH + EUBSqJbyrvIsgL6JQxcahsLYUHie0Gjm7T/48ukjlxZbDZQEsIJuD6CDkgBsUihhWCdgSqh2AlYz+/2/ + qHzORWRQNAKFRIFc4n7Xu8HXj+eQRF8T4v7Hrn+I/6u3v+UBEoQRQEpgD9Y//20CCGn+PkfUgGIPALh+ + OKs/8uAnf2189/YMYuih9Bcb/uWM35AYjAASApMDg8AkPf5McsKgX1/EXgMQfRyt/o6+1s0fx1Ys1n/w + tXt/9+Ybx66L3+n//AcyvO0wAkgRLM27zCQCYFfU7dMqQJ8jts9hZKhA7dwTuHU37Xroy5/+PQBDAIb1 + tQ75PxNUCeJjSBBGAEkhlPeoy+y46pB7Lg9QhA3VP4ToOWaw19PZQHbhGex/167bnvz6X3wEwPV6RgBc + h24iiL+5+NWQAIwAEgJDNoPHFy9Vff+eqny/yzoMAqAsLHCpHQLPwNo8sje+jffdvvM9X/jch38TwDYI + CQQCqKHbGzAkCCOApCC25jnOxBGYff8cwFVScwSdAeIgMRgYQL2K9SXUrlvBbx+4/ZcBjEJIYAQSEgQv + wIw/YVgfQFLIwfA65AOAtAjP2tyT+962HE0cVlFoCOmzW+ql9qePBUHPHAYuLDkAWyEewBZIT0CYNIrd + iriryCoDCcAIIClI/M9R7w2RTvOF0mAXAxCAjoYNPe/U1T3I7OHZFV/KQJEfyFdmMsjNH3IAQ5D/OypC + WOwdM8NPDEYAqaHi6zNkC7D08lT3+TEYDtTXS3fFOwCAZ6osB9IVYd7De08Qtz+uBgQPwCHsGjMkByOA + lBDi9NieKdza5a3P1RCAert1icRmi2dZjT6Gvi9LDFGLjkN5+/cLAQyJwAggNfRk/VkMN1hyDt3+A4hN + Bs+8540qb8PRKDBkqQgYpKVBlEYfv1oCMHEYAaQEcrGNliXAXIyVmcv8AENDAqep/up7hZXiKJ5nHycA + wntwGPeJpou63+l/8RMZ3mYYASQEhgP3qfd51fmXrT9CBOXq8Ms16kW3PTPYU89cH5e3v2FAYQSQFHzX + bc56GXvdAei9hAMcNvpyflX7D7JhLLF+D5i5bChEXzVgY4iEYQSQFKKwm6IyHudyAPECcv28Lgvp5zUw + HKh078XTr5qy5zArwCiFQD3QowVoJJAojABSQnybU1nFlxwgg32uYXsupT/WJKDrlwOILD+oBFVEvZgA + NDfw8Ivzr6FXFdg8gQGAEUBS8GANAbqUvnyutzkrG3gwSFeERZ2AkSPApMnB0Aucu8oWcAbnHvf/0/Hn + /vLRyR9DxECCIEgsDW6qwAnDCCAlhNVfUIsLBp3n4gHkHXAeloGGZh7fvwoAr7avDUPMkYy4vPmfPXL+ + hS/+x8VXIapAqxBloDWUJGBeQOIwAkgKQZAHQJgHAOB91AfALElBYjjqvfm74WVTMDl4+CgJSLjvkYnD + f/3ti8cgRr8EEQRdgRBAE6YKPBAwAkgIfm0uUvaJ/HUvdshgeM67jLpIBVTAURWAwOCcJY9IhPu+OfHi + A9+ZPg659Rf1LEBIYBXdBGAhQMKwceCE4BszaE8u98zgySxQRwzfk9TuvZYC4UDk+x4wg5g0bBBv4L5/ + m/jhA9+ZPgEx9CWI4c+jJIBqCBCYyEggQZgHkBCYHVoTqwAItVu2lX+hfQDsNd4n8QfgZY9n/zKgSImx + z8WryHN8/pvTR750aOYkxPiXIYY/q69LKG//IBBq7n/iMAJICh7sgdbEKpgI9Vu26mfVGQjlPN9BIfVT + bP4FKHL4iEhni3KACZ9/dOqlf3hm7hRE/ju4/gsoQ4BVdK8FC70BZvwJwwggNZC06LbOLwPwqL9jVNp4 + AYSFoN5zKQ0QbROKpT+ZGCyjvphb8+sP/2hpAuLWBwJYiU7YCxi7/rHxm+EnCssBJAUuyvZgoPXGCtrn + VoAuXV8Cuax4PvQOVE/R1cvA2AiNPPqFuw6M7xoliJFvoFwEGur/bZQ3v3UBDgiMAJKCdv9xmPwDNs4u + g0FwLnL5w3iwdvYQUc8BEYg9OG8B7HHb3t07vv/gH/3O3j07hlEm90KzT9d84Fv+Yxv+32AEkBAY2urr + IukuvYtF4FN7+32o/bkiKdjvMMLkYA5uNXDL+I6xJx78xIdvGd+5DaL8E9R/qiIg6PNqSBBGAAmBKNMS + oLr14KIfgHQlOLkM5Fwx3UMg0QwNnBCrgnsGcg/OPZonnoRfmca+PaN7vveVj9/zUzeN7UEpAhqUgIMO + YKwGZEgYRgAJgSGXuyeZ0SsL8Or6O6ciQKIcTI7U6HOAclBMAECpJMQM31zD2tFvwS/PYu/Y6Pihv/v4 + J9+5d9deADtQ7gQImoD9FIEBI4TkYASQEshpElDlukjDARLhT3IZHDnAZRLjq2BvGff76OTFODHnORiM + zkYDjaOPoNOYwfjOLTcd/Nt7PvPTN+/ah24SCKFBCAvM6BOGEUBScEBNb/tMF4V6Bue66Zdl/p/IqcE7 + ELVlmSj1hgKF5QaxUc/Imw2s/fAh5I053Di29aaDX7r7sz+zb9ctAHaiJIFYFdi8gIRhBJASXEc0/zKW + Gf+MdTpQSSE0/usYcJapajfp85IpLEeA1f0nOPhODvYyEJQ3N7B6+GEMvfMOjI9t2/sv9931MQgBjKIM + BaokYEgQRgAJgVwdbigD1WQsmGoEOAY7kn2hTm5/x5oPgENncTIaIEL5MVCSBnQmICwHZQ/fXselr/4h + 8uVLqGe0DcB2CAFsQbkfMK4KGBKEEUBqCL+xGgAQKCOw93CaCwAAkIODA7ka2ouX0Dy5IInAUNYnD1BH + KwcOYFcW970qCeuA0fqFp7ExeyGDuP9xMjBUBKrrwgEjhWRgrcApwQFUg9zcLQkBOIh6BNEPJtEDAJAN + y6fWf7IMgDDy7m0oxgeLJCHpIHGmSkKlqhA6DtxsYvX4Uw7d5cCQBKzG/4bEYASQElwG1BzIMQAHzhlE + DKn/u6LDz7ngJqgmIDPWji0C7DHyC9vLHEDoHQhrxHwxW9xFKsxMKLP/8V7A4AGEf8y6BBODEUBKcACI + wQ7gDKDMgdsezKQlPXXpFZRpWKAZ/7VjSwAzRm4fBeB1eZB8DXOYJwhfL3MCnOfQ1YNhLVg1+w+YB5As + LAeQEAg1UF2SgG7IFc25zDr9B721dVwnI7X8mlb8M8La8WWsHxNNAXIqHBo8AS0hSjexg4eEE3qtuz5H + /1FDqjAPICWQlzxfaAGsucLYi+R+MRRIoHpWfIozeY4JWH11Adnu6/UKd/qMgxc2gXgE4lEwO/hSUaRa + 9zfjTxxGACmBtMMvQ+Hwy+3OIPK6F5AKEshqmhdwBOSqB6BeQfPUvAqIhKMtxZpAJB88Ca7uBjTDHyAY + ASQEAksVIJeaP6v8d0/qTaW+XS2TfgBmTQUQuOMLzUDS1eLkHJiyYp8gq5BIEBiKegdiwzcSGABYDiAp + aNyekZQEMzllDqD72awuSQLKHFAPeQBZFcYe0jSkNX8pJmQICkJh5EAag97iH9PwlsEIYPNDfXJiaeYR + rQ5yZeLO+/7XMWWSKKQhEruuU9FLwMxwFEICF7qCtRQo4QDrViEudcW5cgyJwwhg8yJa0xEK8jLwI5N/ + HpTJVF+hA1K0+UvQntVUHyALo8IhP0AaRohhOyq9AiaCL3ICevtTYfC2A2DAYDmAzYmQ42MA3Gx1OgTk + Ze6dijZ+cqSKQAVH6Dt4uJpe8BmLWlAoEWaiBdC1XdgT2EH3CbBWFpwmAF14ax+9VteCGRKEeQAJ4MXX + J5efePnsv750dD9q++5Uk2MEWa+uIJ1lO3jOgKtJooAyB6eHMskjSFUAyJlRKAMEN4IJcBk8iwfQ2Mg3 + UO4li1eEmzBo4jAC2NwIN2z+zLHzE/ff/+AHJpduQu3WXwWzJu9C2a/PXZwNZeIpZFD5DpY8QAZ49kUb + ceAQqfg5efUMnwPLs+vtP3584Ul0rwePV4TbZqCEYQSweREMKhhZ51uHz0z8/t1/89GzF28A7TsAqQqw + Snv1voGrSYLPuaAGLB6Ay1xptkARbDBrHiB0AHrGJx6bOTjTyFdQSoUHbyB4BBYGJAwjgM2NWJ67DaD5 + 7Mmp87f/1uc+9Nq5MfgbfwXsM835dYcBYMA5p0lArfDVtcpXk/IeFc+SeP4qNS79BQ5ffWn16HMTzUl0 + rwdfR//twOjzatjkMALYXIgNKD4ddG/tWfylD9x71/Gze9AZvxP1sR3FEB98WRB0GQGUgxzB1aR/gDIn + YqHcXTpk9mUpkIGnzq6d/eKzC69AjH8F5WbgBsr1YJYMTBxGAJsbIeOeo9zYswrZ2Td34IP3fvTI4yde + bDaaG2BgeHQLsuFaYZZSMnTSQaiVQOdYiCEvh4bKI4mA84udpT/93txhiLEvQ3YDLunHDYgHEOcBzPgT + RXb1RwxvA6p9PfGoT3z8P3//9MtnZjfeWGp0VoZ2bu3s3TW8p726BnjGnttGMTw+jM7UXNHjLyO+jE6j + g6VGHWjnAIBhbsOxx3qL2585NPvU6/PtaYjRzwOY07MI8Qb6EYC5/wnC+gA2PxhiaAQxOlf5fH7o1PKR + Q6eWT+Ppqe03bK3f8N0//40/WTn5ZqERCJUOQ4cBVQ2XjULdeQMG8FfPLT7/wpvNCYihL0IIYAHlevB4 + T2B1O7AhMVgIsDnRLxeQQ4yuBbmBGxCjnAMwDeAigIuXVttn7/jUwc/ODI+cE7/Bi4IQeykDqkIwR8bf + bPs2g/H46caJrx9fOQkx/gV973mUN3+8HtxXvr/4+zYkAgsBNi8uN21X7cgLFYI2xDhbANpfe37yR/u3 + 7xn/+QO79uYTs+BcdUG1zXdjvoOV9Tom5pvLn3rs3FPvuWFo9J5/v/RdSJy/ADH8GZQEsAohng1Y7D8w + MALY3LjSyG1MAKEu39Woc9vNu3e8/xd/7g5urQMbS7pMzIPg0Vxo4fUZrHzsG6efnFxuLTz0k5UfQzyK + YPyz6Db++Pa32H9AYDmAzY0wExA+Bnpd7yIXgNID2ADQ3vDZRPuNI6i/69eBiyfAs6cBsEz3MfDC60vn + 59c7obwX3/xXcv1z9Lr+hkRhHkAa6OcJBA8A6C7mFS26z782NZWvbp+6c+fp99Vu3e/8dTuAlUkQA+tz + bRw9n0/94NzKGYjxx9n+qvGHxF+/mx8wIkgWRgDpoEoC/RKFMREwAPznqZmL7fWx6f1Db94xNH7zUGf7 + z8Itn8XaXBsvX8gnnjm78hrKZOKsvoaaf9X4q51/gBl/0jACSA+X8waqJ3yenj8zO33oROvlD9669v6h + bSNDrV3vxewrJ5Y+/djUo2ttv4jujP8Sum/+FnqN3+L+AYERQJq4kjdQ6AjED0wvra8/cPDiE3e9Y+S9 + o0MLo3d/5fg/HpttTaFM/IUTjD9u9jHjH1AYAaSLK5UJ47/ryg/8/bOTTzcW61PfeGX6VUjyLxBAiPkb + 6HX7LeM/oDBl1/RRVeoN64HCJp8hyDbfrZDFntsge/7qEMNuohz2qWb8+438mvEPEKwMmD4uVyrsVJ7z + 0JFiCCGE330LMvEXJ/yC8Vu5b8BhBDAY6EcCoT8grhDkECNfQxn+VbsIY5e/2u1nRDBgMAIYHFRJoJ/r + HpqF4q2+cTdhNeavvr9hwGA5gMFDv5xAyAtUF3sC3f0DsdeAPq+GAYMRwGCiHwkA5XLP+JnYyPsp/Zrx + DzCMAAYX/fb4XW24KH6tfmwYQBgBDDb6bgy7zLMW81+DMAK4NvA//T2b8V8jMAK4tnC137cZ/jWG/wKj + 5CV8byoSIgAAAABJRU5ErkJggigAAAAwAAAAYAAAAAEAIAAAAAAAgCUAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAABYAAAAdAAAADQAAAAEAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAHQEAAGoAAABJAAAAIQAAAAQA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAkAAAAhGEhmvieH1f8A + AAB1AAAAMQAAAAoAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQAAADAJ + ECGSRsv//zes//8AAACRAAAARwAAABoAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAKyuKvPE5bbb/Qrr+/zOU6v8GFi61AAAAdAAAACwAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAIV2r8ELV//8yaK//N5vn/y+A3P8WZMv/AAAAlgAAADIAAAAJAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI2O2/zm0/P8wZ7X/M5bi/zib3v8VaM3/AAAAjAAAACcA + AAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI2Kz/zOd9/8qY7j/beb//y+Hzv+N + xff/AAAAbgAAABYAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI2Kz/zCX+P8h + XrT/bOb//zGH0v8CAACjAAAAPQAAABYAAAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAImGz/0bF//8hY7P/bOb//zSH0P8AAACQAAAAbwAAACYAAAAJAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAI2G0/1LZ//8oZ7X/a+X//zSAyf8hXYjcAAAAkwAAADAAAAAJAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI2G0/1HQ//8xbbX/a+T//zV6wv9Xtv//BgMCjgAAACcA + AAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI2Gy/1DL//81crP/Zd///zR4wP+r + 4///KCYkdwAAABwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI2G0/0/L//82 + dLL/VM7//zd5wf8HBAGjAAAAVgAAACUAAAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAI2G0/0vI//82cq//S8X//zl3vP8zf7DpAAAAjgAAADEAAAAJAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAI2K0/0fB//8wb6z/S8X//zpytv9Nvv//AAAAlgAAADMAAAAJAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI2K0/0O+//8ra6j/S8X//zxvsf9Luf//AAAAlQAAADIA + AAAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI2K0/0bE//8ta6f/TMb//z5vrv9M + uP//AAAAlQAAADIAAAAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI2G0/1HP//80 + a6f/Ucv//z9sq/9NuP//AAAAlQAAADIAAAAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAI2G0/1va//80aqX/X9n//0Bqqf9NuP//AAAAlQAAADIAAAAJAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAImK0/17f//8yaKP/aeP//0Bopv9LuP//AAAAkwAAADIAAAAJAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJGO1/13d//8sY6D/auX//0JnpP9LuP//AAAAkwAAADIA + AAAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJWW5/1XV//8iWZr/auX//0Nkof9J + uP//AAAAlAAAADUAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABJWe8/1HP//8R + T5T/auT//0Njnv9BtP3/AAAAnAAAAEgAAAAgAAAACQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAQA + AAAQJGa9/2Le//8nbaL/aeH//0Nem/9EZqL/BhAWsQAAAGwAAABQAAAALAAAABIAAAAGAAAAAQAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAABAAAACAAAAB0AAQZVLG2q/2Xh//9m3///Zt///2fc//9n3P//j83k/xEyW+sAAQOKAAAAXQAAAD4A + AAAhAAAACwAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAEAAAAJAAYNMwEYLJZIksfqidDs/2Th//9k4P//ZN///2Xf//9t4f//ndzt/yhttv8Y + R3vxCRgvuQAAA3sAAABPAAAAKgAAAA0AAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgADho6G1J7ymK39P+54f//xOr//2Df//9j3///Y9///2Xf//9p + 3///se/7/zqI4v8zieb/K3C4/xhAcd0CBw6RAAAAUwAAACkAAAALAAAAAQAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQeMDMocaTUTrH5/4PK//95wvP/Vcz9/1nU/f9f + 2f7/YNv+/1/b/v9h2f//se34/1ue0/9Oj9P/PpHm/ziG1f8aSHXgAggPkQAAAE0AAAAgAAAABgAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQ4XFSlsnMNHrfn/Uq32/0Wj6/9N + tff/UMX7/1nQ/P9c1v3/Xdb9/13X/f9a0v3/Vs/9/1HH//9avPH/Xafb/0+f5v9ZouP/FT5o1gABA3oA + AAA9AAAAEgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADKGONflGz9v9k + vP3/QJri/0Sn9P9ItPv/T8L7/1TM/P9Z0fz/WtD8/1jO/P9Vy/z/TcT8/1LE/f9j4f//ZtX8/1uo3v9t + tff/TJ3i/w4oRLgAAABYAAAAJQAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM + KT0VQI/I4pDR/v9eq+v/QKHv/0as+/9Esvr/Sr36/07F+v9Rx/r/Ucf6/1DF+v9Nwfr/S737/2nd/v9n + 4P//Yt///2zM+f9aqOf/SKL0/ydpqO0BBAmAAAAAOAAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAqZIxle8Px/7Db/f84k+L/Ra38/0Kk+P86pvj/Qbf5/0K7+f9CvPn/QLr5/z+5+f88 + t/n/Z9r//2Hc/f9c1f3/WdT8/1bU//9UpOH/Opby/zKJ3/8OJj+sAAAASAAAABQAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzd6e3tN/3/4u/8P88nOz/Qab4/zWV9/9Dsvr/RLr7/z63+/89 + t/v/Q7n7/0a6+/9Rvvv/WMb9/1nI/f9ZyP3/UsT8/0jI+v9frej/N43m/zOJ5v8cTX3PAAAAVAAAABoA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5h8Dd5/T//1me4f89off/Pqj5/4ri///V + +////f/////////7////9f////7////1////3////8L6//+p8P//bNz//0DD//9FsfH/N4vd/zSM7f8n + Z6nqAAAAWwAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+l9f2/////zaG1/9G + ib//XI+6/2yKrP96kKz/hJez/4qfu/+Op8D/i6O8/4mhuv+Cnbf/epq1/3Seu/9snr3/YZq7/0yPuP86 + r/j/OorZ/zWQ8v8tecT5AAAAWwAAAB4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABC + m9v2/////zOC2f82WX/3AAAAXwAAACIAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAACY2WJVCpPL/NYTU/zqa9/8uecH5AAAAVAAAABoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAABFlc7b6/n//1WX5P8uS3P1AAAAbAAAACwAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAis7W51Hmeb/N4jY/0al9/8lYZnoAAAASAAAABQAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABJi7uwx+v//4y79P88X5P/AQECiAAAAEIAAAAUAAAAAgAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABCxEcECU8Xb88hdj/SZzp/1eq7/8aQ2vJAAAAOQAAAA0A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABNhK5zn9z+/9Xr//89cbv/BQkPtAAAAGEA + AAAxAAAADgAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAIEx4yTEhqlfw/iuD/VrD6/1Ge3/8Q + KUOfAAAAJAAAAAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlka8PXp7N6Of6//9+ + rev/OFmG/QABApQAAABZAAAAMQAAABQAAAAHAAAAAgAAAAEAAAACAAAABQAAABAFCA02PlFw0lCM0v9D + lOT/UbP9/zt3q+kDDBVXAAAAEQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAWI+0gJXJ6v/b8f//R4ja/y1DZOkAAAKUAAAAYQAAAEIAAAAtAAAAIwAAACAAAAAiAAAAKgMFCU82 + Q1nGV4TB/0mM2v9lvP7/YK/s/x9DYKIAAAAeAAAABQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAdpGhBU1+p8rG7P//y+f9/0+Q2v87W4T+BgoSswABA4kAAABsAAAAYAAAAGMB + AgR0ChAZmVFge/leiMz/TIfW/3TA+v97w/b/OGiKyAIKEjIAAAAIAAAAAQAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGaEmSJil77XwOn//93x//+Gtub/SoG9/0Jnk/84 + Unb4OEll9kVXc/o+Xo//R3Gt/1WHzv9am9//Zb3//3W76/8/cpTTCiEyOQAAAAkAAAABAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABpfYseT3+p1I7F6v/k + +f//2u///6/T9f92ruj/QYzc/z2I3P9qpeb/jMHy/33H//9gvf//Ya3h/ypOaK8FIDMqAAAABgAAAAEA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAdpGjBnaUrX1fkrznlcbp9L/m///o+v/////////////T7///mc7y+26u2fZEfqjZHT1TXAANFxIA + AAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABFdpghOWiOZDhnjIUyYYeaMWOKtC5gha0oWHyfIk9weR5HZ00Z + QVweAAAABAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///wf//8AAP//+B///wAA///gD///AAD/ + /+AP//8AAP//4A///wAA///gD///AAD//+AP//8AAP//4A///wAA///gD///AAD//+AP//8AAP//4A// + /wAA///gD///AAD//+AP//8AAP//4A///wAA///gD///AAD//+AP//8AAP//4A///wAA///gD///AAD/ + /+AP//8AAP//4A///wAA///gD///AAD//+AP//8AAP//4A///wAA///AA///AAD//wAA//8AAP/+AAB/ + /wAA//wAAD//AAD//AAAH/8AAP/4AAAf/wAA//gAAA//AAD/8AAAD/8AAP/wAAAP/wAA//AAAA//AAD/ + 8AAAD/8AAP/wAAAP/wAA//AAAA//AAD/8B/4D/8AAP/wH/AP/wAA//AP4A//AAD/8AfAD/8AAP/wAAAP + /wAA//gAAB//AAD/+AAAH/8AAP/8AAA//wAA//4AAH//AAD//wAB//8AAP//wAP//wAA////////AAAo + AAAAIAAAAEAAAAABACAAAAAAAIAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAEQAAADEAAABNAAAARAAAAB4A + AAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0ZRHxwJ1+b6RtKguMA + AABrAAAAPgAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHlKVXSVluf85 + pe7/LGWk/xsyT8YAAABQAAAAGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAl + Zbn/X9X//zZ8xP87luz/KFCA6wAAAEYAAAATAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAACVluf9f0f//NnzE/1/B9/8jSnXTAAAANwAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAJWW5/1bA+P86fLr/OYm6+AQGCIMAAAA/AAAAEAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlZbn/Ubn1/zt9uf8+h7v9GSo8vAAAAEIAAAARAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACVluf9Yyv//Pnuy/1S7/P8tWYLdAAAANwAAAAwA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJWW5/1bI//84ea//VsH//wcOE30A + AAA9AAAADwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlZbn/U8H7/zZtof9I + j77/EC5ItgAAAE0AAAAXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACVluf9W + wfb/Nm2g/1bD//8tWH7kAAAAUgAAABkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAJWW5/1/P+/88baD/VsP//y5YfeMAAABSAAAAGQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAlZbn/ad///zpllf9Ww///L1h94wAAAFIAAAAZAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAACVluf9o3f//OWOU/1bD//8vWH3jAAAAUgAAABkAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJWW5/2LY//83apz/VsP//y1YfOMAAABZAAAAIgAAAAQA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAglZbn/X9T//zNso/81e7j/KVV35gAAAGkA + AAA5AAAADwAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAOAAAAKCVluf9p3v//XMz6/1jF9P9D + iKz9FytDswAAAFgAAAArAAAADQAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAEAEBAVIyUFzHbNz//23f//9l + 2///Xt7//1e96f8aR3LhAAAAhgAAAFYAAAAtAAAADgAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkJERZqUYqo6Yfe/v9l + 1Pz/aeL//2Le//9d2f//V8L3/zB9zv8fTn7sAAAAlQAAAFYAAAAoAAAACQAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADBw0RTEyRw+9o + yfr/ULfz/1G++P9b0/z/XdT8/1fO/P9QxPz/Q675/zGR7f8dUoLuAAAAiwAAAEgAAAAYAAAAAgAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4z + XX+/VLH3/0at8v9CqPD/Tr74/1HC+P9Rw/j/Tb74/0y5+P9q3P//TcH//yyQ4P8QK0PUAAAAYwAAACoA + AAAHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAHiozVl2k2vtJrvf/Pafz/0i2+P9Mu/n/T775/02++v9Muff/Zdb+/2LW/f9WzPr/OK///yFkofYA + AACIAAAAOAAAAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAA1TFqMbMT//zul+P920f//svH//8D4//++9///u/P//7vx//+p7v//huH//1jP//87 + q/r/KnrN/w4RFa0AAAA/AAAADwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAEVkdKFrxv//OYC89myKrP9siqz/bIqs/2yKrP9siqz/bIqs/2yKrP9s + iqz/bIqs/zed5fw3ieL/EBUctwAAAD0AAAAPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAR2V0nXzT//8NKE/qAAAAegAAADsAAAAWAAAADAAAAAsA + AAALAAAACwAAAAlIXXN5OY7W9kCU6P8QFhywAAAAMwAAAAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA6T1p6m+X//xk8cfgAAACXAAAAUQAAACcA + AAAOAAAABQAAAAEAAAACAAAACjlQaZ9KnvD+P4rN/Q8SFpEAAAAhAAAABAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACsyOzyQw9X3Z6Tm/wAKINMA + AAB6AAAAVAAAADcAAAAiAAAAGQAAABwAAABAH0yD2mS8//8rVnnoAAAASgAAAA8AAAABAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATFRlG051msbC + +f//PHe1/AAKItwAAxOnAAIIdgAAAFYAAABSAAAAcAojTMppq/P/TqTj/RIdJJkAAAAaAAAABAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAO0JPRW6WtOLY/v//qNnv/1F7mPEDFjLZAA0o1AQVN9krT4zufLb5/2XA+f8nPE6+AAAAIQAAAAYA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAOkFPR1+Cos6Us9H/s9ri/7fn//+04/v/qdz//5DY//9Tlr3yMEFUswAAABoA + AAAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARmOOGT9agGVEZ5OWTXyvyU1+r9s+Z5C1LERWhysxOz0A + AAAHAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAABgAAAAIA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/8B/// + /Af///wH///8B////Af///wH///8B////Af///wH///8B////Af///wH///8B////Af///wD///wAf// + 4AD//8AAf//AAH//gAA//4AAP/+AAD//gAA//4AAP/+AAD//gAA//4AAP/+AAH//wAD//+AB///wA/// + /j//KAAAABgAAAAwAAAAAQAgAAAAAABgCQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPWcEdJWW5/yVluf8PM2IjAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAe + Wqj/M6n3/yWH4v8fTYH/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeWqj/Q7T2/0Kv//9DbJX/AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAeWqj/P6jv/zVfjf8IOXQsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeWqj/P6fq/zaV2v8t + WYn/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeWqj/Pqnl/0S7//8IOXScAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAe + Wqj/OZ7e/0Nslf8IOXQsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeWqj/PZrV/z+2+v85Y4//AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAeWqj/SabV/0C0+v81X43/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeWqj/SqbQ/z+w9/81 + X43/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeWqj/QqPV/zuq8f81X43/AAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9IkAQe + Wqj/S8P0/y2GzP81X43/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4/SlxPxv//X+f9/1Ti/f85Y4//AAAAUAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAALH0lhfFaexPpV0/r/V9/8/0/c/P9Gv/3+CDl04AAAAFoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVQmR2QZG//0W//f9FxPz/TdL8/0jN/P9D + yf7/OLL6/w5fqfAAAABOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAMFy88isz1Na/8/yyr/P82uvz/OLz8/zO4/P9Cvvn/Vt79/zHE//8AMFfFAAAAHQAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACVOcohCqNz/RsL+/5X2//+m + ////ov3//6H5//+a////avH//zfM//8UdtL8AAENZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAC5mlctKuf//bIqs/2yKrP9siqz/bIqs/2yKrP9siqz/bIqs/2yKrP8k + jPb/AxAqmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADBlkcFV + run/AAUjnwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9RjKo2nv//BhUukAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACFQgJeI2//+AAgyqwAAAAYAAAAAAAAAAAAAAAAA + AAAAAAAALTWM3ucyg8f0AAQdbgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAABxKhGRxrdL5hMrw/AAFIr0AAAAQAAAAAAAAAAAAAAAmFUKCul7J//8XRnS5AActMQAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFLhMeXJ7Duer7/a7k/P8n + TG7fBBQ4wQYdRr05bbfpedH//ypso9wABipfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABTMcH2Wty3Oq0eaf1PDwre///5zd//1jseTmPXepywAGK3IA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAgyFR1OjW0bU5SfFUiBrxZIg6cWMmGAIjZnLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAP/D/wD/w/8A/8P/AP/D/wD/w/8A/8P/AP/D/wD/w/8A/8P/AP/D/wD/w/8A/4P/AP+B/wD+ + AP8A/gB/APwAPwD8AD8A/AA/APx+PwD8PD8A/Bg/APwAfwD+AP8A/wH/ACgAAAAQAAAAIAAAAAEAIAAA + AAAAQAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGF25bTJPfv9B + SmBiAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACd+x/9I + zfz/Ol+H/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAn + fsf/QaDS/z1VdXkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAJ37H/0rR/P86X4f/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAACd+x/9DodH/PVV1eQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAnfsf/VOL9/ztbgP8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAJ37H/1vX/P87W4D/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAIWOQRid+x/9x3vz/O1uA/xFRfTUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAALnKgVjSHx/9ewPD/U8v+/1Sz3f8/UGn/EVF9QQAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAO4CxTTSHyP9Vuvf/V8L5/023+f9r1vv/SKbo/z9PZ/8SVIM2AAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAADh+uOFXwfn/U7f5/5Pu/v+P7P7/VbTz/43j/v9SuuL/N1Fu2gAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8g7v8XMb5/2yKrP9siqz/bIqs/2yKrP9siqz/ZdX6/zpQa/wA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPIO851/S+v9NZ4T/AAAAAAAAAAAAAAAAUJDB/1a74f88 + TmjfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEWIwZJJndD/feP6/02Fnv9UZ4f/VHmc/1W/9OFL + jKr/NFt9hQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABMlMYYR4rBrEmazf9x1fX/dOn+/3DU8/9N + krL/OmeMnC9zoiAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEyUxhhIjcOCQ4u7x0OLuvtA + iLfbQXaggjyCsiAAAAAAAAAAAAAAAAAAAAAA/j8AAP4/AAD+PwAA/j8AAP4/AAD+PwAA/j8AAPwfAAD4 + DwAA8AcAAPAHAADwBwAA8ccAAPAHAADwBwAA+A8AAA== + + + \ No newline at end of file diff --git a/DD_Clipboard_Searcher/frmLicense.vb b/DD_Clipboard_Searcher/frmLicense.vb new file mode 100644 index 0000000..3327739 --- /dev/null +++ b/DD_Clipboard_Searcher/frmLicense.vb @@ -0,0 +1,112 @@ +Imports DD_LIB_Standards +Public Class frmLicense + Dim CLIENT_ID As Integer + Public _lizenzManager As clsLicenseManager + Private Sub btnPW_check_Click(sender As System.Object, e As System.EventArgs) Handles btnPW_check.Click + OpenLicenseManager() + End Sub + Sub OpenLicenseManager() + If Me.txtPW.Text <> "" Then + If Me.txtPW.Text = "35452dd!" Then + Me.grbBoxlicense.Visible = True + Refresh_Licence(False) + Me.lblPW.Visible = False + Me.txtPW.Visible = False + Me.btnPW_check.Visible = False + If DT_CLIENT_USER.Rows.Count > 1 Then + lblClient.Visible = True + cmbClients.Visible = True + Try + cmbClients.DataSource = DT_CLIENT_USER + cmbClients.DisplayMember = DT_CLIENT_USER.Columns("CLIENT_NAME").ColumnName + cmbClients.ValueMember = DT_CLIENT_USER.Columns("CLIENT_ID").ColumnName + Catch ex As Exception + MsgBox("Unexpected Error in Loading Clients: " & ex.Message, MsgBoxStyle.Critical) + End Try + ElseIf DT_CLIENT_USER.Rows.Count = 1 Then + lblClient.Visible = False + cmbClients.Visible = False + CLIENT_ID = DT_CLIENT_USER.Rows(0).Item("CLIENT_ID") + End If + + + Else + Me.grbBoxlicense.Visible = False + MsgBox("Das eingegebene Passwort stimmt nicht überein!", MsgBoxStyle.Critical, "Falsche Eingabe:") + Me.txtPW.Text = "" + Me.txtPW.Focus() + End If + End If + End Sub + + Private Sub btnnewLicenses_Click(sender As System.Object, e As System.EventArgs) Handles btnnewLicenses.Click + Try + _lizenzManager = New clsLicenseManager("#DigitalData35452!#", "") + If Me.txtNewlicences.Text <> "" Then + 'Encode the license + Dim result As String = Me._lizenzManager.EncodeLicenseKey(txtNewlicences.Text & "#" & dtpGueltig_GI.Text, "#DigitalData35452!#") + + Dim sql As String = String.Format("UPDATE TBDD_CLIENT SET LICENSE_DDCBSEARCHER = '" & result & "' WHERE GUID = {0}", CLIENT_ID) + If clsDatabase.Execute_non_Query(sql) = True Then + Refresh_Licence(True) + End If + + 'MsgBox("Die Lizenzen wurden erfolgreich aktualisiert!", MsgBoxStyle.Exclamation, "Erfolgsmeldung:") + End If + Catch ex As Exception + MsgBox(ex.Message, MsgBoxStyle.Critical, "Fehler bei New Licenses:") + End Try + End Sub + Sub Refresh_Licence(Neu As Boolean) + Try + clsLicense.Refresh_Licence(CLIENT_ID) + + txtNewlicences.Text = LICENSE_COUNT + dtpGueltig_GI.Value = LICENSE_DATE + + If Neu = True Then + If CInt(LICENSE_COUNT) > 0 Then + Dim msg As String = "Die Lizenz wurde aktualisiert!" & vbNewLine & Now + If USER_LANGUAGE <> "de-DE" Then + msg = "The license was renewed!" & vbNewLine & Now + End If + MsgBox(msg, MsgBoxStyle.Information, "License renewed:") + End If + End If + Catch ex As Exception + MsgBox(ex.Message, MsgBoxStyle.Exclamation, "Error in licensemanager:") + End Try + End Sub + + Private Sub frmLicense_Load(sender As Object, e As System.EventArgs) Handles Me.Load + Try + grbBoxlicense.Visible = False + Me.lblPW.Visible = True + Me.txtPW.Visible = True + Me.btnPW_check.Visible = True + Me.txtPW.Text = "" + Catch ex As Exception + MsgBox(ex.Message, MsgBoxStyle.Exclamation, "Fehler bei Formular Load:") + End Try + End Sub + + Private Sub frmLicense_KeyUp(sender As Object, e As KeyEventArgs) Handles MyBase.KeyUp + If e.KeyCode = Keys.Return Then + If Me.txtPW.Focus = True Then + OpenLicenseManager() + End If + End If + End Sub + + Private Sub cmbClients_SelectedIndexChanged(sender As Object, e As EventArgs) Handles cmbClients.SelectedIndexChanged + If cmbClients.SelectedIndex <> -1 Then + Try + CLIENT_ID = cmbClients.SelectedValue + Refresh_Licence(False) + Catch ex As Exception + CLIENT_ID = 99 + End Try + + End If + End Sub +End Class \ No newline at end of file diff --git a/DD_Clipboard_Searcher/frmMain.Designer.vb b/DD_Clipboard_Searcher/frmMain.Designer.vb new file mode 100644 index 0000000..c7a1f9c --- /dev/null +++ b/DD_Clipboard_Searcher/frmMain.Designer.vb @@ -0,0 +1,98 @@ + _ +Partial Class frmMain + Inherits System.Windows.Forms.Form + + 'Das Formular überschreibt den Löschvorgang, um die Komponentenliste zu bereinigen. + _ + 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 + + 'Wird vom Windows Form-Designer benötigt. + Private components As System.ComponentModel.IContainer + + 'Hinweis: Die folgende Prozedur ist für den Windows Form-Designer erforderlich. + 'Das Bearbeiten ist mit dem Windows Form-Designer möglich. + 'Das Bearbeiten mit dem Code-Editor ist nicht möglich. + _ + Private Sub InitializeComponent() + Me.components = New System.ComponentModel.Container() + Dim resources As System.ComponentModel.ComponentResourceManager = New System.ComponentModel.ComponentResourceManager(GetType(frmMain)) + Me.NotifyIcon1 = New System.Windows.Forms.NotifyIcon(Me.components) + Me.cmstrpNotifyIcon = New System.Windows.Forms.ContextMenuStrip(Me.components) + Me.tsmiChangeState = New System.Windows.Forms.ToolStripMenuItem() + Me.btnUserConfig = New System.Windows.Forms.Button() + Me.TimerTest = New System.Windows.Forms.Timer(Me.components) + Me.cmstrpNotifyIcon.SuspendLayout() + Me.SuspendLayout() + ' + 'NotifyIcon1 + ' + Me.NotifyIcon1.BalloonTipIcon = System.Windows.Forms.ToolTipIcon.Info + Me.NotifyIcon1.BalloonTipText = "Text" + Me.NotifyIcon1.BalloonTipTitle = "Title" + Me.NotifyIcon1.ContextMenuStrip = Me.cmstrpNotifyIcon + Me.NotifyIcon1.Icon = CType(resources.GetObject("NotifyIcon1.Icon"), System.Drawing.Icon) + Me.NotifyIcon1.Text = "Digital Data Clipboard Searcher for windream" + Me.NotifyIcon1.Visible = True + ' + 'cmstrpNotifyIcon + ' + Me.cmstrpNotifyIcon.Items.AddRange(New System.Windows.Forms.ToolStripItem() {Me.tsmiChangeState}) + Me.cmstrpNotifyIcon.Name = "cmstrpNotifyIcon" + Me.cmstrpNotifyIcon.Size = New System.Drawing.Size(250, 26) + ' + 'tsmiChangeState + ' + Me.tsmiChangeState.Image = Global.DD_Clipboard_Searcher.My.Resources.Resources.StatusAnnotations_Stop_16xLG + Me.tsmiChangeState.Name = "tsmiChangeState" + Me.tsmiChangeState.Size = New System.Drawing.Size(249, 22) + Me.tsmiChangeState.Tag = "stop" + Me.tsmiChangeState.Text = "Überwachung Clipboard stoppen" + ' + 'btnUserConfig + ' + Me.btnUserConfig.Image = CType(resources.GetObject("btnUserConfig.Image"), System.Drawing.Image) + Me.btnUserConfig.ImageAlign = System.Drawing.ContentAlignment.MiddleLeft + Me.btnUserConfig.Location = New System.Drawing.Point(582, 12) + Me.btnUserConfig.Name = "btnUserConfig" + Me.btnUserConfig.Size = New System.Drawing.Size(151, 29) + Me.btnUserConfig.TabIndex = 2 + Me.btnUserConfig.Text = "Grundeinstellungen User" + Me.btnUserConfig.TextAlign = System.Drawing.ContentAlignment.MiddleRight + Me.btnUserConfig.UseVisualStyleBackColor = True + ' + 'TimerTest + ' + Me.TimerTest.Interval = 10000 + ' + 'frmMain + ' + Me.AutoScaleDimensions = New System.Drawing.SizeF(6.0!, 13.0!) + Me.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font + Me.ClientSize = New System.Drawing.Size(735, 380) + Me.Controls.Add(Me.btnUserConfig) + Me.Font = New System.Drawing.Font("Tahoma", 8.25!, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, CType(0, Byte)) + Me.Icon = CType(resources.GetObject("$this.Icon"), System.Drawing.Icon) + Me.KeyPreview = True + Me.MaximizeBox = False + Me.Name = "frmMain" + Me.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen + Me.Text = "Form1" + Me.cmstrpNotifyIcon.ResumeLayout(False) + Me.ResumeLayout(False) + + End Sub + Friend WithEvents btnUserConfig As System.Windows.Forms.Button + Friend WithEvents NotifyIcon1 As System.Windows.Forms.NotifyIcon + Friend WithEvents cmstrpNotifyIcon As System.Windows.Forms.ContextMenuStrip + Friend WithEvents tsmiChangeState As System.Windows.Forms.ToolStripMenuItem + Friend WithEvents TimerTest As System.Windows.Forms.Timer + +End Class diff --git a/DD_Clipboard_Searcher/frmMain.resx b/DD_Clipboard_Searcher/frmMain.resx new file mode 100644 index 0000000..412a196 --- /dev/null +++ b/DD_Clipboard_Searcher/frmMain.resx @@ -0,0 +1,243 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + 132, 17 + + + + + AAABAAMAEBAQAAEABAAoAQAANgAAABAQAAABAAgAaAUAAF4BAAAQEAAAAQAgAGgEAADGBgAAKAAAABAA + AAAgAAAAAQAEAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAIAAAACAgACAAAAAgACAAICA + AACAgIAAwMDAAAAA/wAA/wAAAP//AP8AAAD/AP8A//8AAP///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAD///AP//AAAPf38Pd3fwAP9/f/d3d38A93d3d3/3fwD3d3d3f/d/AP////d3d38AAA + AAD3d38AAAAAAA//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP//AAD//wAA//8AAP// + AADBhwAAwQMAAIABAACAAQAAgAEAAIABAAD/AwAA/4cAAP//AAD//wAA//8AAP//AAAoAAAAEAAAACAA + AAABAAgAAAAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAEJCQgBNTU0Ab29vAODg4ADm5OUA6+vrAPb2 + 9gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcHBwcHAAAHBwcHAAAAAAAHAQcB + BwAGAwEBAwYAAAAHBwEHAQcHAwEBAQEDBwAABwEBAQEBAQECBQUBAQUAAAcBAQEBAQEBAgUFAQEHAAAH + BwcHBwcHAwEBAQEDBwAAAAAAAAAAAAYDAQEDBgAAAAAAAAAAAAAABwcHBwAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD//wAA//8AAP// + AAD//wAAwYcAAMEDAACAAQAAgAEAAIABAACAAQAA/wMAAP+HAAD//wAA//8AAP//AAD//wAAKAAAABAA + AAAgAAAAAQAgAAAAAABABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPb2 + 9v/29vb/9vb2//b29v/29vb/AAAAAPb29lD29vbf9vb2//b29v/29vbf9vb2UAAAAAAAAAAAAAAAAAAA + AAD29vb/QkJC//b29v9CQkL/9vb2//b29lDr6+v/b29v/0JCQv9CQkL/b29v/+vr6//29vZQAAAAAAAA + AAD29vb/9vb2/0JCQv/29vb/QkJC//b29v/29vb/b29v/0JCQv9CQkL/QkJC/0JCQv9vb2//9vb23wAA + AAAAAAAA9vb2/0JCQv9CQkL/QkJC/0JCQv9CQkL/QkJC/0JCQv9NTU3/5uTl/+bk5f9CQkL/QkJC/+Dg + 4P8AAAAAAAAAAPb29v9CQkL/QkJC/0JCQv9CQkL/QkJC/0JCQv9CQkL/TU1N/+bk5f/m5OX/QkJC/0JC + Qv/29vb/AAAAAAAAAAD29vb/9vb2//b29v/29vb/9vb2//b29v/29vb/b29v/0JCQv9CQkL/QkJC/0JC + Qv9vb2//9vb23wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9vb2UOvr6/9vb2//QkJC/0JC + Qv9vb2//6+vr//b29lAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD29vZQ9vb23/b2 + 9v/29vb/9vb23/b29lAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD//wAA//8AAP//AAD//wAAwQMAAMAB + AACAAQAAgAEAAIABAACAAQAA/gEAAP8DAAD//wAA//8AAP//AAD//wAA + + + + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAAAlwSFlzAAAO + xAAADsQBlSsOGwAAAJpJREFUOE/dkMENgCAMRR3BUZyBCRyCOwsxFne5c+da+yuSBtGgR5u8hLS/D3Qi + IkFXznllNoYKOK9lLFX3WgGCKSVyzpExRsAZPS15Emx6WUswK7G+gAMzc1k+iTHWmz4JMJMgV1eA4tD3 + T0BxaHn4iUuJXQV43hu6Av1k730N46xnQwIQQhDa/rDAWiu0/WHBHX8WvOHYo2kHvfprYU4ZRYMAAAAA + SUVORK5CYII= + + + + 278, 17 + + + + AAABAAMAEBAQAAEABAAoAQAANgAAABAQAAABAAgAaAUAAF4BAAAQEAAAAQAgAGgEAADGBgAAKAAAABAA + AAAgAAAAAQAEAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAIAAAACAgACAAAAAgACAAICA + AACAgIAAwMDAAAAA/wAA/wAAAP//AP8AAAD/AP8A//8AAP///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAD///AP//AAAPf38Pd3fwAP9/f/d3d38A93d3d3/3fwD3d3d3f/d/AP////d3d38AAA + AAD3d38AAAAAAA//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP//AAD//wAA//8AAP// + AADBhwAAwQMAAIABAACAAQAAgAEAAIABAAD/AwAA/4cAAP//AAD//wAA//8AAP//AAAoAAAAEAAAACAA + AAABAAgAAAAAAAABAAAAAAAAAAAAAAABAAAAAQAAAAAAAEJCQgBNTU0Ab29vAODg4ADm5OUA6+vrAPb2 + 9gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcHBwcHAAAHBwcHAAAAAAAHAQcB + BwAGAwEBAwYAAAAHBwEHAQcHAwEBAQEDBwAABwEBAQEBAQECBQUBAQUAAAcBAQEBAQEBAgUFAQEHAAAH + BwcHBwcHAwEBAQEDBwAAAAAAAAAAAAYDAQEDBgAAAAAAAAAAAAAABwcHBwAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD//wAA//8AAP// + AAD//wAAwYcAAMEDAACAAQAAgAEAAIABAACAAQAA/wMAAP+HAAD//wAA//8AAP//AAD//wAAKAAAABAA + AAAgAAAAAQAgAAAAAABABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPb2 + 9v/29vb/9vb2//b29v/29vb/AAAAAPb29lD29vbf9vb2//b29v/29vbf9vb2UAAAAAAAAAAAAAAAAAAA + AAD29vb/QkJC//b29v9CQkL/9vb2//b29lDr6+v/b29v/0JCQv9CQkL/b29v/+vr6//29vZQAAAAAAAA + AAD29vb/9vb2/0JCQv/29vb/QkJC//b29v/29vb/b29v/0JCQv9CQkL/QkJC/0JCQv9vb2//9vb23wAA + AAAAAAAA9vb2/0JCQv9CQkL/QkJC/0JCQv9CQkL/QkJC/0JCQv9NTU3/5uTl/+bk5f9CQkL/QkJC/+Dg + 4P8AAAAAAAAAAPb29v9CQkL/QkJC/0JCQv9CQkL/QkJC/0JCQv9CQkL/TU1N/+bk5f/m5OX/QkJC/0JC + Qv/29vb/AAAAAAAAAAD29vb/9vb2//b29v/29vb/9vb2//b29v/29vb/b29v/0JCQv9CQkL/QkJC/0JC + Qv9vb2//9vb23wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9vb2UOvr6/9vb2//QkJC/0JC + Qv9vb2//6+vr//b29lAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD29vZQ9vb23/b2 + 9v/29vb/9vb23/b29lAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD//wAA//8AAP//AAD//wAAwQMAAMAB + AACAAQAAgAEAAIABAACAAQAA/gEAAP8DAAD//wAA//8AAP//AAD//wAA + + + \ No newline at end of file diff --git a/DD_Clipboard_Searcher/frmMain.vb b/DD_Clipboard_Searcher/frmMain.vb new file mode 100644 index 0000000..3543f59 --- /dev/null +++ b/DD_Clipboard_Searcher/frmMain.vb @@ -0,0 +1,156 @@ +Imports System.Threading +Imports DD_LIB_Standards +Public Class frmMain + Private WithEvents _Watcher As ClipboardWatcher = ClipboardWatcher.Singleton + Private Sub frmClipboardWatch_Disposed(ByVal sender As Object, _ + ByVal e As EventArgs) Handles Me.Disposed + _Watcher.Dispose() + End Sub + + Private Sub _Watcher_Changed(ByVal sender As Object, _ + ByVal e As EventArgs) Handles _Watcher.Changed + + If MONITORING_ACTIVE = False Then Exit Sub + Dim Data As IDataObject = Clipboard.GetDataObject + Me.TextBox1.Clear() + + Dim RelevantWindow = clsWINDOWSApi.IsRelevantWindow("jonathan") + 'With Me.TextBox1 + ' .AppendText(String.Concat("Available Formats:", vbNewLine)) + ' .AppendText(String.Join(vbNewLine, Data.GetFormats)) + ' .AppendText(String.Concat(vbNewLine, vbNewLine, "Text = '", _ + ' Clipboard.GetText, "'", vbNewLine, vbNewLine)) + 'End With + CLIPBOARD_TEXT = Clipboard.GetText + For Each row As DataRow In DT_USER_PROFILES.Rows + Dim regex_expression = row.Item("REGEX_EXPRESSION") + Dim regex As New System.Text.RegularExpressions.Regex(regex_expression) + Dim match As System.Text.RegularExpressions.Match = regex.Match(CLIPBOARD_TEXT) + If match.Success Then + If match.Groups(0).Value <> CURR_MATCH_RESULT Then + CURR_MATCH_RESULT = match.Groups(0).Value + If Not IsNothing(CURR_MATCH_RESULT) Then + clsSearch.RUN_WD_SEARCH(row.Item("WD_SEARCH")) + End If + Else + Exit For + End If + + End If + Next + + End Sub + + Public Sub New() + Dim splash As New frmSplash() + splash.ShowDialog() + If ERROR_INIT <> "INVALID USER" Then + Dim cultureInfo As System.Globalization.CultureInfo + cultureInfo = New System.Globalization.CultureInfo(USER_LANGUAGE) + 'cultureInfo.DateTimeFormat.ShortDatePattern = USER_DATE_FORMAT + Thread.CurrentThread.CurrentCulture = cultureInfo + Thread.CurrentThread.CurrentUICulture = cultureInfo + Globalization.CultureInfo.DefaultThreadCurrentCulture = cultureInfo + Globalization.CultureInfo.DefaultThreadCurrentUICulture = cultureInfo + End If + ' Dieser Aufruf ist für den Designer erforderlich. + InitializeComponent() + + ' Fügen Sie Initialisierungen nach dem InitializeComponent()-Aufruf hinzu. + + End Sub + + Private Sub btnUserConfig_Click(sender As Object, e As EventArgs) Handles btnUserConfig.Click + frmConfig_Basic.ShowDialog() + End Sub + + Private Sub frmMain_FormClosing(sender As Object, e As FormClosingEventArgs) Handles Me.FormClosing + ClassLogger.Add(">> Logout time: " & Now.ToString, False) + If ERROR_INIT = "INVALID USER" Then + Exit Sub + End If + Try + Dim sql = String.Format("UPDATE TBDD_USER SET LOGGED_IN = 0, LOGGED_WHERE = '{0}' WHERE (LOWER(USERNAME) = LOWER('{1}'))", "", USER_USERNAME) + clsDatabase.Execute_non_Query(sql, True) + sql = "DELETE FROM TBDD_USER_MODULE_LOG_IN WHERE USER_ID = " & USER_GUID & " AND MODULE = 'DD_CLIPB_SEARCH'" + clsDatabase.Execute_non_Query(sql, True) + ClassWindowLocation.SaveFormLocationSize(Me, "") + My.Settings.Save() + + Catch ex As Exception + + End Try + 'TempDateien löschen + Try + For Each _file In TEMP_FILES + System.IO.File.Delete(_file) + Next + Catch ex As Exception + + End Try + If clsLogger.LOGG_MSG <> String.Empty Then + ClassLogger.Add(clsLogger.LOGG_MSG, False) + End If + End Sub + + Private Sub frmMain_Load(sender As Object, e As EventArgs) Handles Me.Load + ClassWindowLocation.LoadFormLocationSize(Me) + If clsDatabase.DB_Connected = True Then + Me.NotifyIcon1.Visible = True + Dim sql = String.Format("SELECT T.* FROM TBCBS_PROFILES T, TBCBS_USER_PROFILE T1 WHERE T.GUID = T1.PROFILE_ID AND T1.USER_ID = {0}", USER_GUID) + DT_USER_PROFILES = clsDatabase.Return_Datatable(sql) + If DT_USER_PROFILES.Rows.Count = 0 Then + MsgBox("Es wurden noch keine Profile für diesen User hinterlegt!", MsgBoxStyle.Exclamation) + End If + End If + TimerTest.Start() + End Sub + + Private Sub frmMain_Shown(sender As Object, e As EventArgs) Handles Me.Shown + If ERROR_INIT <> "INVALID USER" And LICENSE_COUNT > 0 Then + If DT_USER_PROFILES.Rows.Count >= 1 Then + Me.Hide() + End If + Else + If USER_IS_ADMIN = True And ERROR_INIT = "NO LICENSE" Then + MsgBox("As an admin You have exit! Please inform Digital Data to add a valid license!", MsgBoxStyle.Exclamation, "") + Else + MsgBox("Application will close now!", MsgBoxStyle.Critical, "") + Me.Close() + End If + End If + End Sub + + Private Sub NotifyIcon1_DoubleClick(sender As Object, e As EventArgs) Handles NotifyIcon1.DoubleClick + If Me.Visible = False Then + Me.BringToFront() + Me.Visible = True + Else + Me.Hide() + NotifyIcon1.Visible = True + End If + End Sub + + Private Sub frmMain_KeyUp(sender As Object, e As KeyEventArgs) Handles MyBase.KeyUp + If e.KeyCode = Keys.F12 And USER_IS_ADMIN = True Then + frmLicense.ShowDialog() + End If + End Sub + + Private Sub tsmiChangeState_Click(sender As Object, e As EventArgs) Handles tsmiChangeState.Click + If tsmiChangeState.Tag = "stop" Then + tsmiChangeState.Tag = "start" + tsmiChangeState.Image = My.Resources.control_start_blue + tsmiChangeState.Text = "Überwachung Clipboard starten" + MONITORING_ACTIVE = False + Else + tsmiChangeState.Image = My.Resources.StatusAnnotations_Stop_16xLG + tsmiChangeState.Tag = "stop" + tsmiChangeState.Text = "Überwachung Clipboard stoppen" + MONITORING_ACTIVE = True + End If + End Sub + Private Sub Timer1_Tick(sender As Object, e As EventArgs) Handles TimerTest.Tick + clsWINDOWSApi.TEST() + End Sub +End Class diff --git a/DD_Clipboard_Searcher/frmSplash.Designer.vb b/DD_Clipboard_Searcher/frmSplash.Designer.vb new file mode 100644 index 0000000..6c52664 --- /dev/null +++ b/DD_Clipboard_Searcher/frmSplash.Designer.vb @@ -0,0 +1,182 @@ + _ +Partial Class frmSplash + Inherits System.Windows.Forms.Form + + 'Das Formular überschreibt den Löschvorgang, um die Komponentenliste zu bereinigen. + _ + 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 + + 'Wird vom Windows Form-Designer benötigt. + Private components As System.ComponentModel.IContainer + + 'Hinweis: Die folgende Prozedur ist für den Windows Form-Designer erforderlich. + 'Das Bearbeiten ist mit dem Windows Form-Designer möglich. + 'Das Bearbeiten mit dem Code-Editor ist nicht möglich. + _ + Private Sub InitializeComponent() + Dim resources As System.ComponentModel.ComponentResourceManager = New System.ComponentModel.ComponentResourceManager(GetType(frmSplash)) + Me.Copyright = New System.Windows.Forms.Label() + Me.Version = New System.Windows.Forms.Label() + Me.Label1 = New System.Windows.Forms.Label() + Me.ApplicationTitle = New System.Windows.Forms.Label() + Me.PictureBox1 = New System.Windows.Forms.PictureBox() + Me.TableLayoutPanel1 = New System.Windows.Forms.TableLayoutPanel() + Me.lblStatus = New System.Windows.Forms.Label() + Me.pbStatus = New System.Windows.Forms.ProgressBar() + Me.PictureBox2 = New System.Windows.Forms.PictureBox() + CType(Me.PictureBox1, System.ComponentModel.ISupportInitialize).BeginInit() + Me.TableLayoutPanel1.SuspendLayout() + CType(Me.PictureBox2, System.ComponentModel.ISupportInitialize).BeginInit() + Me.SuspendLayout() + ' + 'Copyright + ' + Me.Copyright.Anchor = CType((System.Windows.Forms.AnchorStyles.Bottom Or System.Windows.Forms.AnchorStyles.Left), System.Windows.Forms.AnchorStyles) + Me.Copyright.BackColor = System.Drawing.Color.Transparent + Me.Copyright.Font = New System.Drawing.Font("Segoe UI", 9.0!) + Me.Copyright.ImeMode = System.Windows.Forms.ImeMode.NoControl + Me.Copyright.Location = New System.Drawing.Point(3, 21) + Me.Copyright.Name = "Copyright" + Me.Copyright.Size = New System.Drawing.Size(185, 21) + Me.Copyright.TabIndex = 2 + Me.Copyright.Text = "Copyright" + Me.Copyright.TextAlign = System.Drawing.ContentAlignment.MiddleLeft + ' + 'Version + ' + Me.Version.Anchor = CType((System.Windows.Forms.AnchorStyles.Bottom Or System.Windows.Forms.AnchorStyles.Left), System.Windows.Forms.AnchorStyles) + Me.Version.BackColor = System.Drawing.Color.Transparent + Me.Version.Font = New System.Drawing.Font("Segoe UI", 9.0!) + Me.Version.ImeMode = System.Windows.Forms.ImeMode.NoControl + Me.Version.Location = New System.Drawing.Point(3, 0) + Me.Version.Name = "Version" + Me.Version.Size = New System.Drawing.Size(185, 21) + Me.Version.TabIndex = 1 + Me.Version.Text = "Version {0}.{1:00}" + Me.Version.TextAlign = System.Drawing.ContentAlignment.MiddleLeft + ' + 'Label1 + ' + Me.Label1.AutoSize = True + Me.Label1.Font = New System.Drawing.Font("Segoe UI", 8.25!) + Me.Label1.ImeMode = System.Windows.Forms.ImeMode.NoControl + Me.Label1.Location = New System.Drawing.Point(299, 102) + Me.Label1.Name = "Label1" + Me.Label1.Size = New System.Drawing.Size(182, 13) + Me.Label1.TabIndex = 12 + Me.Label1.Text = "This software is in parts based on:" + ' + 'ApplicationTitle + ' + Me.ApplicationTitle.BackColor = System.Drawing.Color.Transparent + Me.ApplicationTitle.Font = New System.Drawing.Font("Segoe UI", 18.0!) + Me.ApplicationTitle.ImeMode = System.Windows.Forms.ImeMode.NoControl + Me.ApplicationTitle.Location = New System.Drawing.Point(12, 4) + Me.ApplicationTitle.Name = "ApplicationTitle" + Me.ApplicationTitle.Size = New System.Drawing.Size(469, 33) + Me.ApplicationTitle.TabIndex = 6 + Me.ApplicationTitle.Text = "Anwendungstitel" + Me.ApplicationTitle.TextAlign = System.Drawing.ContentAlignment.BottomLeft + ' + 'PictureBox1 + ' + Me.PictureBox1.Image = CType(resources.GetObject("PictureBox1.Image"), System.Drawing.Image) + Me.PictureBox1.ImeMode = System.Windows.Forms.ImeMode.NoControl + Me.PictureBox1.Location = New System.Drawing.Point(304, 118) + Me.PictureBox1.Name = "PictureBox1" + Me.PictureBox1.Size = New System.Drawing.Size(109, 38) + Me.PictureBox1.SizeMode = System.Windows.Forms.PictureBoxSizeMode.Zoom + Me.PictureBox1.TabIndex = 10 + Me.PictureBox1.TabStop = False + ' + 'TableLayoutPanel1 + ' + Me.TableLayoutPanel1.ColumnCount = 1 + Me.TableLayoutPanel1.ColumnStyles.Add(New System.Windows.Forms.ColumnStyle()) + Me.TableLayoutPanel1.Controls.Add(Me.Copyright, 0, 1) + Me.TableLayoutPanel1.Controls.Add(Me.Version, 0, 0) + Me.TableLayoutPanel1.Location = New System.Drawing.Point(304, 51) + Me.TableLayoutPanel1.Name = "TableLayoutPanel1" + Me.TableLayoutPanel1.RowCount = 2 + Me.TableLayoutPanel1.RowStyles.Add(New System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 50.0!)) + Me.TableLayoutPanel1.RowStyles.Add(New System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 50.0!)) + Me.TableLayoutPanel1.RowStyles.Add(New System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Absolute, 20.0!)) + Me.TableLayoutPanel1.Size = New System.Drawing.Size(200, 42) + Me.TableLayoutPanel1.TabIndex = 9 + ' + 'lblStatus + ' + Me.lblStatus.AutoSize = True + Me.lblStatus.BackColor = System.Drawing.SystemColors.Control + Me.lblStatus.Font = New System.Drawing.Font("Segoe UI", 9.0!) + Me.lblStatus.ImeMode = System.Windows.Forms.ImeMode.NoControl + Me.lblStatus.Location = New System.Drawing.Point(9, 157) + Me.lblStatus.Name = "lblStatus" + Me.lblStatus.Size = New System.Drawing.Size(79, 15) + Me.lblStatus.TabIndex = 8 + Me.lblStatus.Text = "Statusanzeige" + Me.lblStatus.TextAlign = System.Drawing.ContentAlignment.MiddleCenter + ' + 'pbStatus + ' + Me.pbStatus.Dock = System.Windows.Forms.DockStyle.Bottom + Me.pbStatus.ImeMode = System.Windows.Forms.ImeMode.NoControl + Me.pbStatus.Location = New System.Drawing.Point(0, 179) + Me.pbStatus.Name = "pbStatus" + Me.pbStatus.Size = New System.Drawing.Size(540, 23) + Me.pbStatus.TabIndex = 7 + ' + 'PictureBox2 + ' + Me.PictureBox2.Image = CType(resources.GetObject("PictureBox2.Image"), System.Drawing.Image) + Me.PictureBox2.ImeMode = System.Windows.Forms.ImeMode.NoControl + Me.PictureBox2.Location = New System.Drawing.Point(12, 51) + Me.PictureBox2.Name = "PictureBox2" + Me.PictureBox2.Size = New System.Drawing.Size(276, 103) + Me.PictureBox2.SizeMode = System.Windows.Forms.PictureBoxSizeMode.CenterImage + Me.PictureBox2.TabIndex = 11 + Me.PictureBox2.TabStop = False + ' + 'frmSplash + ' + Me.AutoScaleDimensions = New System.Drawing.SizeF(6.0!, 13.0!) + Me.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font + Me.ClientSize = New System.Drawing.Size(540, 202) + Me.ControlBox = False + Me.Controls.Add(Me.Label1) + Me.Controls.Add(Me.ApplicationTitle) + Me.Controls.Add(Me.PictureBox1) + Me.Controls.Add(Me.TableLayoutPanel1) + Me.Controls.Add(Me.lblStatus) + Me.Controls.Add(Me.pbStatus) + Me.Controls.Add(Me.PictureBox2) + Me.Font = New System.Drawing.Font("Tahoma", 8.25!, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, CType(0, Byte)) + Me.FormBorderStyle = System.Windows.Forms.FormBorderStyle.None + Me.Name = "frmSplash" + Me.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen + Me.Text = "frmSplash" + CType(Me.PictureBox1, System.ComponentModel.ISupportInitialize).EndInit() + Me.TableLayoutPanel1.ResumeLayout(False) + CType(Me.PictureBox2, System.ComponentModel.ISupportInitialize).EndInit() + Me.ResumeLayout(False) + Me.PerformLayout() + + End Sub + Friend WithEvents Copyright As System.Windows.Forms.Label + Friend WithEvents Version As System.Windows.Forms.Label + Friend WithEvents Label1 As System.Windows.Forms.Label + Friend WithEvents ApplicationTitle As System.Windows.Forms.Label + Friend WithEvents PictureBox1 As System.Windows.Forms.PictureBox + Friend WithEvents TableLayoutPanel1 As System.Windows.Forms.TableLayoutPanel + Friend WithEvents lblStatus As System.Windows.Forms.Label + Friend WithEvents pbStatus As System.Windows.Forms.ProgressBar + Friend WithEvents PictureBox2 As System.Windows.Forms.PictureBox +End Class diff --git a/DD_Clipboard_Searcher/frmSplash.resx b/DD_Clipboard_Searcher/frmSplash.resx new file mode 100644 index 0000000..25d312e --- /dev/null +++ b/DD_Clipboard_Searcher/frmSplash.resx @@ -0,0 +1,2828 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + + iVBORw0KGgoAAAANSUhEUgAABCcAAAE+CAYAAAC+1HpQAAAABGdBTUEAALGOfPtRkwAAACBjSFJNAACH + DwAAjA8AAP1SAACBQAAAfXkAAOmLAAA85QAAGcxzPIV3AAAKOWlDQ1BQaG90b3Nob3AgSUNDIHByb2Zp + bGUAAEjHnZZ3VFTXFofPvXd6oc0wAlKG3rvAANJ7k15FYZgZYCgDDjM0sSGiAhFFRJoiSFDEgNFQJFZE + sRAUVLAHJAgoMRhFVCxvRtaLrqy89/Ly++Osb+2z97n77L3PWhcAkqcvl5cGSwGQyhPwgzyc6RGRUXTs + AIABHmCAKQBMVka6X7B7CBDJy82FniFyAl8EAfB6WLwCcNPQM4BOB/+fpFnpfIHomAARm7M5GSwRF4g4 + JUuQLrbPipgalyxmGCVmvihBEcuJOWGRDT77LLKjmNmpPLaIxTmns1PZYu4V8bZMIUfEiK+ICzO5nCwR + 3xKxRoowlSviN+LYVA4zAwAUSWwXcFiJIjYRMYkfEuQi4uUA4EgJX3HcVyzgZAvEl3JJS8/hcxMSBXQd + li7d1NqaQffkZKVwBALDACYrmcln013SUtOZvBwAFu/8WTLi2tJFRbY0tba0NDQzMv2qUP91829K3NtF + ehn4uWcQrf+L7a/80hoAYMyJarPziy2uCoDOLQDI3fti0zgAgKSobx3Xv7oPTTwviQJBuo2xcVZWlhGX + wzISF/QP/U+Hv6GvvmckPu6P8tBdOfFMYYqALq4bKy0lTcinZ6QzWRy64Z+H+B8H/nUeBkGceA6fwxNF + hImmjMtLELWbx+YKuGk8Opf3n5r4D8P+pMW5FonS+BFQY4yA1HUqQH7tBygKESDR+8Vd/6NvvvgwIH55 + 4SqTi3P/7zf9Z8Gl4iWDm/A5ziUohM4S8jMX98TPEqABAUgCKpAHykAd6ABDYAasgC1wBG7AG/iDEBAJ + VgMWSASpgA+yQB7YBApBMdgJ9oBqUAcaQTNoBcdBJzgFzoNL4Bq4AW6D+2AUTIBnYBa8BgsQBGEhMkSB + 5CEVSBPSh8wgBmQPuUG+UBAUCcVCCRAPEkJ50GaoGCqDqqF6qBn6HjoJnYeuQIPQXWgMmoZ+h97BCEyC + qbASrAUbwwzYCfaBQ+BVcAK8Bs6FC+AdcCXcAB+FO+Dz8DX4NjwKP4PnEIAQERqiihgiDMQF8UeikHiE + j6xHipAKpAFpRbqRPuQmMorMIG9RGBQFRUcZomxRnqhQFAu1BrUeVYKqRh1GdaB6UTdRY6hZ1Ec0Ga2I + 1kfboL3QEegEdBa6EF2BbkK3oy+ib6Mn0K8xGAwNo42xwnhiIjFJmLWYEsw+TBvmHGYQM46Zw2Kx8lh9 + rB3WH8vECrCF2CrsUexZ7BB2AvsGR8Sp4Mxw7rgoHA+Xj6vAHcGdwQ3hJnELeCm8Jt4G749n43PwpfhG + fDf+On4Cv0CQJmgT7AghhCTCJkIloZVwkfCA8JJIJKoRrYmBRC5xI7GSeIx4mThGfEuSIemRXEjRJCFp + B+kQ6RzpLuklmUzWIjuSo8gC8g5yM/kC+RH5jQRFwkjCS4ItsUGiRqJDYkjiuSReUlPSSXK1ZK5kheQJ + yeuSM1J4KS0pFymm1HqpGqmTUiNSc9IUaVNpf+lU6RLpI9JXpKdksDJaMm4ybJkCmYMyF2TGKQhFneJC + YVE2UxopFykTVAxVm+pFTaIWU7+jDlBnZWVkl8mGyWbL1sielh2lITQtmhcthVZKO04bpr1borTEaQln + yfYlrUuGlszLLZVzlOPIFcm1yd2WeydPl3eTT5bfJd8p/1ABpaCnEKiQpbBf4aLCzFLqUtulrKVFS48v + vacIK+opBimuVTyo2K84p6Ss5KGUrlSldEFpRpmm7KicpFyufEZ5WoWiYq/CVSlXOavylC5Ld6Kn0Cvp + vfRZVUVVT1Whar3qgOqCmrZaqFq+WpvaQ3WCOkM9Xr1cvUd9VkNFw08jT6NF454mXpOhmai5V7NPc15L + Wytca6tWp9aUtpy2l3audov2Ax2yjoPOGp0GnVu6GF2GbrLuPt0berCehV6iXo3edX1Y31Kfq79Pf9AA + bWBtwDNoMBgxJBk6GWYathiOGdGMfI3yjTqNnhtrGEcZ7zLuM/5oYmGSYtJoct9UxtTbNN+02/R3Mz0z + llmN2S1zsrm7+QbzLvMXy/SXcZbtX3bHgmLhZ7HVosfig6WVJd+y1XLaSsMq1qrWaoRBZQQwShiXrdHW + ztYbrE9Zv7WxtBHYHLf5zdbQNtn2iO3Ucu3lnOWNy8ft1OyYdvV2o/Z0+1j7A/ajDqoOTIcGh8eO6o5s + xybHSSddpySno07PnU2c+c7tzvMuNi7rXM65Iq4erkWuA24ybqFu1W6P3NXcE9xb3Gc9LDzWepzzRHv6 + eO7yHPFS8mJ5NXvNelt5r/Pu9SH5BPtU+zz21fPl+3b7wX7efrv9HqzQXMFb0ekP/L38d/s/DNAOWBPw + YyAmMCCwJvBJkGlQXlBfMCU4JvhI8OsQ55DSkPuhOqHC0J4wybDosOaw+XDX8LLw0QjjiHUR1yIVIrmR + XVHYqLCopqi5lW4r96yciLaILoweXqW9KnvVldUKq1NWn46RjGHGnIhFx4bHHol9z/RnNjDn4rziauNm + WS6svaxnbEd2OXuaY8cp40zG28WXxU8l2CXsTphOdEisSJzhunCruS+SPJPqkuaT/ZMPJX9KCU9pS8Wl + xqae5Mnwknm9acpp2WmD6frphemja2zW7Fkzy/fhN2VAGasyugRU0c9Uv1BHuEU4lmmfWZP5Jiss60S2 + dDYvuz9HL2d7zmSue+63a1FrWWt78lTzNuWNrXNaV78eWh+3vmeD+oaCDRMbPTYe3kTYlLzpp3yT/LL8 + V5vDN3cXKBVsLBjf4rGlpVCikF84stV2a9021DbutoHt5turtn8sYhddLTYprih+X8IqufqN6TeV33za + Eb9joNSydP9OzE7ezuFdDrsOl0mX5ZaN7/bb3VFOLy8qf7UnZs+VimUVdXsJe4V7Ryt9K7uqNKp2Vr2v + Tqy+XeNc01arWLu9dn4fe9/Qfsf9rXVKdcV17w5wD9yp96jvaNBqqDiIOZh58EljWGPft4xvm5sUmoqb + PhziHRo9HHS4t9mqufmI4pHSFrhF2DJ9NProje9cv+tqNWytb6O1FR8Dx4THnn4f+/3wcZ/jPScYJ1p/ + 0Pyhtp3SXtQBdeR0zHYmdo52RXYNnvQ+2dNt293+o9GPh06pnqo5LXu69AzhTMGZT2dzz86dSz83cz7h + /HhPTM/9CxEXbvUG9g5c9Ll4+ZL7pQt9Tn1nL9tdPnXF5srJq4yrndcsr3X0W/S3/2TxU/uA5UDHdavr + XTesb3QPLh88M+QwdP6m681Lt7xuXbu94vbgcOjwnZHokdE77DtTd1PuvriXeW/h/sYH6AdFD6UeVjxS + fNTws+7PbaOWo6fHXMf6Hwc/vj/OGn/2S8Yv7ycKnpCfVEyqTDZPmU2dmnafvvF05dOJZ+nPFmYKf5X+ + tfa5zvMffnP8rX82YnbiBf/Fp99LXsq/PPRq2aueuYC5R69TXy/MF72Rf3P4LeNt37vwd5MLWe+x7ys/ + 6H7o/ujz8cGn1E+f/gUDmPP8usTo0wAAAAlwSFlzAAAuIwAALiMBeKU/dgAA9UFJREFUeF7sfXd8XVeR + /3WPIbB0dtkF0uPektB3F3aXBRZYYPmxDVggtmRLlu30QEKAQEIvIUDoLSS2ZVuWLdmWe++yJde4d0uy + 3CSrvj6/73fm3qcn6dqWLdfo/PH93Pvuu/fUOXNm5syZ44mIg4ODg4ODg4ODg4ODg4ODw1VD6EMHBwcH + BwcHBwcHBwcHBweHK4XQhw4ODg4ODg4ODg4ODg4ODg5XCqEPHRwcHBwcHBwcHBwcHBwcHK4UQh86ODg4 + ODg4ODg4ODg4ODg4XCmEPnRwcHBwcHBwcHBwcHBwcHC4Ugh96ODg4ODg4ODg4ODg4ODg4HClEPrQwcHB + wcHBwcHBwcHBwcHB4Uoh9KGDg4ODg4ODg4ODg4ODg4PDlULoQwcHBwcHBwcHBwcHBwcHB4crhdCHDg4O + Dg4ODg4ODg4ODg4ODlcKoQ8dHBwcHBwcHBwcHBwcHBwcrhRCHzo4ODg4ODg4ODg4ODg4ODhcKYQ+dHBw + cHBwcHBwcHBwcHBwcLhSCH3o4ODg4ODg4ODg4ODg4ODgcKUQ+tDBwcHBwcHBwcHBwcHBwcHhSiH0oYOD + g4ODg4ODg4ODg4ODg8OVQuhDBwcHBwcHBwcHBwcHBwcHhyuF0IcODg4ODg4ODg4ODg4ODg4OVwqhDx0c + HBwcHBwcHBwcHBwcHByuFEIfOjg4ODg4ODg4ODg4ODg4OFwphD50cHBwcHBwcHBwcHBwcHBwuFIIfejg + 4ODg4ODg4ODg4ODg4OBwpRD60MHBwcHBwcHBwcHBwcHBweFKIfShg4ODg4ODg4ODg4ODg4ODw5VC6EMH + BwcHBwcHBwcHBwcHBweHK4XQhw4ODg4ODg4ODg4ODg4ODg5XCqEPHRwcHBwcHBwcHBwcHBwcHK4UQh86 + ODg4ODg4ODg4ODg4ODg4XCmEPnRwcHBwcHBwcHBwcHBwcHC4Ugh96ODg4ODg4ODg4ODg4ODg4HClEPrQ + wcHBwcHBwcHBwcHBwcHB4Uoh9KGDg4ODg4ODg4ODg4ODg4PDlULoQwcHBwcHB4cujpQP3sebPUnUeSnc + R/ks3tjy/0Uj4iU0rziQRPr1Xiya0vzsuYPDxSMKRHifinmSFC8FmjvVKN4/P7Nabv3KNLn18QXnxB2P + TpO/x7snG5BGIkg35iWQlqbr4ODg4HDJEfrQwcHBwcHBoasjqVc1FKSSXiwW83678rB8Z9ER+eXSvfKz + xQc7hV8u3iM/XFohzyzZJ0VbqoV5UImk4SJJ40Wrsjg4XBhoSIvrfcyTRLM+q4mL94YH5oo3bpF4o4vO + jbEL5cb7S+RUFGmALhNJphHLSNfBwcHB4VIj9KGDg4ODg4NDV0eTl0gl/dVn8SobxHvT2GniZc+SnjkF + 4uXM6hR6j5oiXi7SysqXj/9spTTQMKGgkcI8KBwcLhrxqBrWUmpki4OmYl5zJObd9tBM6ZVbJN6Yc6PP + 6GJ564MzpKk5im/jSCvuxSWhY0Hikfb5OTg4ODh0GqEPHRwcHBwcHLo6mr2kpHzPibjXmBDvxpxC8cbO + g/JWIN06CS8LGD9fvNGF8qGfrRFdjYYSKLFYSFkcHC4UEd3aEeWWDBoUkuLVNSe9275Gr4kZ0n10wTnh + ZRfJW5+YL2caQJNx8yCKIA16TtBwF56ng4ODg0NnEPrQwcHBwcHBoWsjKQlfEQPiEa+mvslc4nOKpVvu + dChvMzuFXqORRu4s6ZFbKB//damoESRmK9LpfB0cLhbJmBfDVWmJnjgp8c40JbxbvrpAvLzZ7Tx52iG3 + RP72sflS2xjXmBM01DGtFL17GMciyMfBwcHB4ZIh9KGDg4ODg4ND14YqdRmxH040RL1XP7REvDHF4o2d + I91x7Qy8nBIzVIyeLh/9VZl5TkhSV6hpGMksi4PDBSMZxC6Je8lEs5dKRr2GaMK77ZEi6T16GugYtHcO + 9M2eJm99cLrUNzOgZsyLJRuQFu6ZZsa4cHBwcHC4dAh96ODg4ODg4NC1YSvODCYY91KplHcGit2N42dL + X3pNZE0Vj1s8OoHu2TOlZ3aB9MmeLJ/4xWroklzdjttpIFQC25THweFCoQYv0BSNCfG4eLW4/t1j88XL + LQg1SLRGobzx0TlyOoaxgG81TYwHek7ESasZ+Tg4ODg4XBqEPnRwcHBwcHDo2gi2Vtg16Z1pinqvemC+ + dBsdpshdDGbZ3v4xRfLvv1iHrJAPXeZ974mgHA4OFwXfuyEzbkp9JOW97bFFoOHCNrQYgtwZ8jePzJPa + 5qR+q1s6NG0G2PTzcHBwcHC4pAh96ODg4ODg4NC14YwTDtc1nHHCwcHB4bpD6EMHBwcHBweHrg1nnHC4 + ruGMEw4ODg7XHUIfOjg4ODg4OHRtOOOEw3UNZ5xwcHBwuO4Q+tDBwcHBwcGha8MZJxyuazjjhIODg8N1 + h9CHDg4ODg4ODl0bzjjhcF3DGSccHBwcrjuEPnRwcHBwcHDo2nDGCYfrGs444eDg4HDdIfShg4ODg4OD + Q9eGM044XNdwxgkHBweH6w6hDx0cHBwcHBy6OJLiRXBVxS4Z8U6dafBe95WF4mW9IF7OXOmWU9QpeDkl + 4mVPl55j58iHfrFKVJlMRjW/mK9YOjhcNJxxwsHBweG6Q+hDBwcHBwcHhy6OWFyVOjNOxLyapoTXN69Q + eudMES9ntnjZUOA6gR45s6AETpNu2dPloz9fBl0S+aQiXjzB/J0C6NBJOOOEg4ODw3WH0IcODg4ODg4O + XRzJiBdLJdV7Ig5UxcR7zf1zpE/2FPGyisXLgYLXCfQYXaTbOvoC/+9Xq6Qe6VMJNONErH15HBwuBM44 + 4eDg4HDdIfShg4ODg4ODQ1dHhudEIqIK2rQdzVK07ZTM2Vkvc7dVdwpF20/IzB2nZdr2M7L6cK3Qa0I9 + J5Bf0m3rcOgsnHHCwcHB4bpD6EMHBwcHQ9wEvKQpKM3+ambixIteat8DInVzPYlUpP+P4/9UKqHvmBDn + 4OBwvSIuCTUU6FhONHgSO+VFeQ9FzQwJvO8EEnW4xv00wTfiNUCz/nbGCYdOw6chZ5xwcHBwuH4Q+tDB + wcGBoFAncdwnkqqkRCiUQSlJ7L9PZN0IiZQOkNSuz4hU/8WThpN4j0YKRtqPexF+1yY9BweH6wcpjGVu + sUgk7Z7GymYofFTQVNnTZxcPpsm0uG3EFEkzfpqxwsrg4HDRcMYJBwcHh+sOoQ8dHBwciBSFO+7/TkVb + VlAbq73otk+IrBomUj5AUutuV8j294tUPSVSv0WD55ky05KWg4PD9YV4ssU7IgkeIKlmT2K4JmhEaFKP + qU4hVe+nBV4RjYBnRL1EIuFF+Rs8JKxMDg4dhjNOODg4OFx3CH3o4ODgQMQh1JlA1mBCGQ0VNeu9um23 + iZTdJMmyAZLaMFhkwwiR0gGSXH+rRDa9V5KHviFSuzI0TQcHh+sDqWBbFxDDbxooeZ8AH7AjRukl1Rkg + TaSnnhLxlmNLNZ9YU2iZHBw6DGeccHBwcLjuEPrQwcHBgVCBjiuYSSonCU+ieHb0xyLrhotsGAIMOCfi + u0eLnJwOxaNRvTBSqRTSpdIBQY8rp1BIuLc8ybQpSNL4kYji/6TXjLzpfcH/9H8VCCkk4p0AGWV1uPRg + H+jWHj+OCOmBCmsyCaXVf6dzsD7V0yCgjJo7f1Sv6urfaaCcSlOmAFPB1t+gO6XtTsJoFPekZa2LKfNJ + /Na6dBLW3rhXL4KIPuPvmJgnU9v328MfMwBjwVg8mJZniiBGDMZmMsln9q3dJ72mdDqoW9wCVrLeLXl0 + BuADbC/SGLd06LhGOfG8Q+3HsoNfsC2i7IMkeAuUSH57KWJWGI3EdCuLlkf7OeZFgy1r/I3/tI+YH2mL + J44kqQwb7+J/RLov0+9ySwsV3qAf/Oe4t+0uaO9ky7iLBfkA2ldoM6Vngt+hLPzNvjEjz6UaoxcP9ksw + zpT3B3Uk0FbpNtHyG23yN8tPumMbptsCVwPeBdSrT3/zP4JjJIZ2iSFfi5Wi6eJ61YwTwXjDtzqv8ZqJ + sG8cHBwcujhCHzo4ODgofGGcQl4cCpFE67zojk+IbLhVZONt7YwRbZHcOFRiG3Hd8R8iJyYjvTOmiDJt + FdwooDVB4CNahL/AKNFaGDSokAvhPxA8HS4f1AjBdqbShasZl9AHUKz0N97pDDSfVNKLqZLnHyGJK5X7 + S9G/qvjFSL+m5MTV0IZnSD9QjDoHKkTWFrFos95r2+AajTWmy3HRSNnYUyU+2GKh/+Eeylx4mVqD8SIs + ZkR7aNn12gJuq4ixzfgb+ZsC3DI2k4mYjuHMdC4WOo7Z1wR5Aa+sY7reHQD6lIYIUz5jaCc7YUT7AtfO + gOknE+hXvw8kRmMI+pW/SUupZrxH4wgVYisDEUfezeSXfhpWJ94n0b5B0GCjk/R/bYH/lE8S2kb0YuMz + /1s1HqFfkFZgVArKrO1HQ03w+yohkeQY4BY/9gnGuRpUzHCjBocU/6fRzeph9ECwfj49BGCb4GpGbqtr + 4M3DNldjVCaCb/jfVTJO8F0azVjGNH2wXLh2NA0HBweHrobQhw4ODg4KXd2iYsTfEDATdV5sywhJlr0t + 1BjRFvHSwSIb34P7uyVWers0bf+wyPE/eBKt1rQpXFJgoxCnAiTyoWIaCIBhq59UkNOrcG3+c7jUgHIK + xT4QrKmIJVNUekwJDP/mQoA0EvVeLM40I0oDfMb8VCls9/6FoRY0okoJQMVOlSLfsGJKXvtvLgh6YoV5 + +jBNVUZwJYJ8OwNVZjBOmF5gEEjGWW7km+hY+5tBKfy/AFRuaZRo9x8URh2LUHYjgVLFFV9CPZz8ZxcN + th/6JMl4EzEzpOA5lf2OKG/N9FLA97znd6xH2vsjcWmU80BptpgbpmRqP2h/s5zsB8s3nkx4CbYNn+nV + ykKvBwYIZhmtPYE4DQh2HyjbCv4XGG1Aq0yXXhuE/k8Dnm+okGQDvjf6098sK+nCT7dtXa44WIZ0fUhf + bC8fvoeUjhN9j+3B5zRUpPx2NiM1jaQtbe23bQBtB38+0LwywN9I5+p5Tlh9gnLq3IXnLEva68XBwcHB + oRVCHzo4ODgYbF+4ntgBQU8VnQP3i5TfKbL+nnbGiPboJ9H1d0jz+qEiG98hUtpP4qU3S3T7RyV55CmR + xv2qRFAgDxRgEzCRD5SfYJUsrFwdFhAdLh4JKI1RXFVRAtAXUVxVcQjtlwtDU4YSoQYwgqvTTFsDJeLa + GahiQEW+GTTMVVozeHE181IoByyzKlC6yguajZMmqWQhv0tivIHyGePKMledWRc8AzhOEsHWgvMg0zhB + A0RaeQfU44Bt7v9W5cl/X40V+F/7Ge3I7QJUJut8YwlpIPjuYqFpaBu23GsdObYjrLe9dzawPPouysd6 + sF/1P+33ztMPy6TlYjv47a9BQmP0poh4ESi9akBlvn7ZVXkNnqlXQAAqqigr2i/l81OtO9PEN4EBgoaM + RIL8z0/Lr59CDUK48hm3hfBdvMPvaXhTQwXe43cRjlf9/urBaMcH6Y5jWj1HfGMBDYU0tnHs8H1AadtH + DO2WQLuxbkE942ibNM2qYcbawwxDNNL46fj0y/eulnEiML7r+0n2DWmAnmH+vOrg4ODg0A6hDx0cHBwI + CoMWGwLCI69E4xYvsekuERocQg0SGeDWj4391Sgh62/HM1zLhkqqbJAky+4Q2fQukUPfkVjjTn/FkYod + FDIIpXEVOlvKYt4bASgcdkxAdLh4UCGjwqRKgW5TiOB30mtWxZsKV9APFwdV+KTJi0Bwp2cAXdGp7Ade + AmFluiBAOeHqelAHGlaYrnlo8J3wcnUUVDACF3WlT+SXUC8A5OcrRp2Btnvc2qORz1TJS3lNzEffCS/X + WcGV9YzfTIN5tBgsbKWe96wD/9d+SDSrQsktDXxftwzQAJOR1sUgrm793BLhx5hB+WJQwDva/+xX9eCB + 0sf3+Vv/Qxpazjb5XQzoOaR0xPTQ9iwb24W/E6BdxjhQIw9+K435V/a/vcNysIwJ9T6pqE95y/fVyeT1 + FfKjRUfk68W75b5JGyX7+TWKCRM3yNeKdskPFhySF9YelMW7Tsrh2rgaG7glxLwI/HSRB/MOtjfYeDIF + OPAoubqIqFGtCeON2zmC+EEsq/Y32pdBl4O241UNDzRWoF4639DIQvB3JvCOvh8CbX/2H9/D/dUyTmh5 + UIfgu6DfaERjGcO+cXBwcOjqCH3o4ODgQKjwz1U+VVgg8MZsP3dkz+dFNtzU2hARgsiGgXqKh6wH1uF+ + 3TBJrr8Lz4aLbBws0Y13mAGj/B0i+74scmazCqJccUulaKSgsB0mCJq7b/vnDpcSCfR3WkGIR7wjRypk + c2WzbKqIyL6jp2VLRX2nsKOiTrYdPCnbKmOy/QTzgWIV5woj7plvSJkuCCgzlcn1R5qltCIh26oisq3i + lGw7clxeOtz58m+qapayA5Wys7rW21RZL1vRJkqvVNx9xahzoBEg6VU2JL0NSH830t9RcVpKq+rlpWNN + oWVqhcozsrWqTq/B/bZj9rz8yGmpPl2n45lKE2NJ2Fgz93MqVfxPlSjGWUhEUJZ6r+xYVHZW1siWS9D/ + L1XVyN6jZ6TsSIPsOsE8QG9RGqiQZwfaj+VTg0vKDARqQPCVyD114oXleSF46cgJ2XG81tte0SDrKs6I + bRVBO2hcEZaBBjorh5ZFlWq2E0CPF5TpeIN487afkkenbpH3PT1XXn9fgXTLnS7eWCi/2TPEGw2MKYIi + XGwYzedQnLOoPM+XbmNL5K/uL5K7n5wtj0zcIMt2nJbTzVTw0V+MDcJ+U8Ou9ZWu1utvK9tVRaoR7WLG + NTMccWywfUjXLJ95HTEWDD1GaiJJ78CpJm/9wdOyYHulLNhsWL7juGw5Ui+VtTGvEe9o+2v8GKRJLxPy + DLY3PUv8tjDasHJctW0d6kFF7w7z6KDXh35LDwqMqSAGx9nAb5JcGGA9APYr6xGcosX7wNDBe9I/A4me + Ar/edbzOW7irWuZuPSrzth6WlburdNweP9PsxTjOkFYD3rX6tKRhcUCa7L6zYLnpGaP5sd5m/Ax4Sx2u + R+tj3uYjp2T5zgot59wtR2TRDvT53hNSWXXYa6iv8VKxqBohacwyAxxArz6kwfRajKtI10/7kpS/07Ay + syxsX21rtgNpPwH5hjQF+gg8iThOOLYPnazzth6slCW7juk4YJvM33YEfXhM+S7bjG2XzDTaKU0yP9JI + HPQDGmN+lxPIl3VqAF2zfupFxjHIBaZETTt6bgstt++FRqMqFz3UuKtjmjRDXhGMaetjtpXFI6PRU7wT + TQlvx7E6WbUHbbXF6GfJruOy9nC9HDsd0/Gh9IAr8+O24YRuBwTwvHNA+ei9xUDRfvp8ToN2M8pbDdn5 + peON3opdlbJo22FZvP2I8J7zcEUzxi7KkfYY9RcOaKCnB9i1Qb9XD6EPHRwcHAJwj7MxSkwimDRU0Dw9 + x5NyHiHa2hjRHoMlufF2iZYDmwZIvIzGCm4JuRn/3WRGiw0DJVHaT5I0Ymx5v8j+R0ROr0ZenEjqLd/0 + xOSXCXDGicuPwJ2a7X0G/fHgxFXyirwC6XnfAnl17lTpnTenU+iTVyQ3jpspr8ybKbc8UiQHochROGlZ + ce4koCxOf6lG3j5+orxqTKG8Lhd5jZ4orxg3Q27ImxtapgtBrwkLkO50+au8QumZUyg33feirKiA2AQ6 + VUG0s4Dgw/H25YLt8qYJU+XVX/qLvBrt1fM+lH309NAyZaLPuBJFr7GzFcF9z9xZ0nfCPCndslMaY6bo + WAwRjjN/rGn+Cdt6g2fsl4N1Ce+mryyQG8dMlb7jw/O8EPRCu904ukBuHFsg//n7dXKawjaEVObVkf6n + J4GWF4oq36eATIH2TDThPTltQ2ieFwK21SvHz5QbsqfL3z0ySw6csP5Il80XSE0oRzkoUKMOtRHxNlbG + ZHzBQXnHkwuk95cmiZc1W7zxy8Qbt0g8pOuB5j3QpGGmdMspUphi7D+nsSJrFq6LxZuwSrzRxdJ91Ivy + 3u8skMdnH5Edp6EYaBmQLwRkCuCBIYBKUdv2uuJgm6Bt2F6qSNGIQOUUv2sguM/b0yw/X3pEsv9UJu/9 + 7lJ566Nz5MYJxdJjLNthOtpoBtrK0HPsdHnNhEK546vz5IPPrpfPv7BbfrXwJVl1sFFqkJ72CZVgfzuH + bntivzBvKEL6P9rpShon0go/kFIlzMaYbk3hc5bvHKgB2JdmoGCecZ33lN4ATdMfm9uqGuVnC3fKf/1y + ldz+xELwVtIN6IzIAUYXSZ+cGfLmB+fIsKdWyr/8fLM8OvMl2VYFFc83ttn4oTIYhfKI+86CZdY6Y0xE + U96GI2fk16sOy+gXy+RDP1kmb/nKInnNgyU61rSMY3AdA5rPKUZ/z5FuqMMbH1kkQ7+5Uv79F6XycOE2 + eb70gGyvOiMsK73JSO80bJmRkso+Y2OZstyuPFcY2k+8ZxuoQQJti9/se5a77LjI1PIqebJwk/zvL1fI + u59aIG//8nx5Jfi7l1Mi3XPQh2OA0ezDEjVUkoe/9sH52nbv/eFK8M1SeWrODpmztUIOnW7Q7U2an9/u + lxV+/TQeD2jT8k16DZGobyg+N07jHbZDkoZver/5RhprN3qt8cp3WRco+3VRb8HO4/LN4m3y2V8vl/5P + r5W3fHmxzkXdc0AvY+cp9B509Ib7S2T4k4vlc79eLc8t3ilbKxuEWxI1/6j1RWdAGtOYRH75Kmuj3ozy + o/LI5FL55E8WyJu+vERuQNm8bPIT9CNpHPe9Qdeve2iBDPnmUvnEc+tRnz0yb+txqarxDa7kXdEr0H/X + MEIfOjg4OCggtCQh7FMI0ECIEDDVqkvmvvnfMowQZwGNDwyKSaghAtg4SBJlwyRaNtwMFWUDJVU2RJIb + B+N6m8TKbpXY5g+I7M6RaOykb6AwRk3jBCcuExI7JiA6dAZJU1rjtpr961JoQ5xocxZLr9EzpDsE/M5A + hVEIXV72HHlF1lRZv6dCONmnhbpOgoLOY8Wbxbv3RSiGK6HoQfHJK0C+U5Hv3NAyXQi46t2X1ywoUxNW + oB758rPFB9U4oaujbcpzwUg1eA1I69+fZdozpUfuPL/NoGiMmRZaprboMWaGdINyHdx7WQXSK7dIXv/l + pVIDJVoVKFVwA6HW2t+UJzMU0GBAAfI0hKZX5HF1H/XNWdAurwuFByGyJ+szaqZ87Lk1onnFa8FfqCAx + 3/PBjBP0+mB5VSFJNKhgfP/kzaF5Xgi8MaBNKKheznzpPbZQqk81Qemlkol8kiZMM7BqSr0UGnQVtKyi + UUZP2Q4Fewq+hYKNfqKXRPdcjBu0fc/sQukzeqb0vBfPc5jHTCjKRWl0h1CtRgr8d8PoSdJrTD7aG2mh + D3tAaeP/Sm+4vvm+afLNeQeEnjUWz4H9Z3wyUISuKvw+VAEefUVj5/ZTUe8bc/fIPU/PBx2SNtEOpE96 + j5CuQOfdxsxW9Mwu0H6gouFBWfWorLFfsqeClvFdHg1tk+Xd35ohP5y/TV46aUE2rX/8lVn8vpoxJ/Re + lS9b6Z1cWiX/8cwy+eeflsuHf7rynPjzwlVCA4Xmqf2JPiZf0frZ801QuO5/cYO8/X60lXrgkJ/OAK2A + X2SDbkZPM3rKZftBOcpCmwNKg9mTZOqGE5heQTf+1jrSNBVMVS47jaRHhfDpefvlnu8s0zKp8YGGk5wC + 6Q1Y/7MvUEbQN9udz3qOBo8Gn9L5ZhSe54D30dAyKl/efP8M+cefbJApyzbLwVozzij/0lV24wnh5bmy + UH6kfcU+i3gNkJ9WV0Tlq3P2yge+vwiKK+rE+ilvJ82jnkr/uGIs9MhC32FsGL+lgcKUWz7rPQbjgv2b + SwMG+3yW/N3DJfL5366XgvJjUt3cuiyXBaRNNWyRvpu1vttrxPvcL5bKPz27JpSmM5Hzs3yp8OkYwh5o + HPf4zXS4XY6eR6TJ0uMiXy3eK0OemCu9MPaNhhaAP4IPoI1I79pmNACQvtE+vUZPxzO0zxjM9+NA++C/ + rxk3Ee2zVJbsPWlzTWcRt22Oq44lZML0HXLbY7Nt3shGf4xeAN7NOZryBune6Lt7LmSQMdONvnMI/Kd0 + P0Nuf3yOPFKwVUorGtT4FppnF0HoQwcHBwcFJ1bA3Oh4QgN+K457dafmeKJxJG6X1ObBElvfT4TbNNYP + l1TpcEmW0zvCN0hcJGjEkAMPiNStgtBEV1MaKeha3SKgsWxk5CbAAbQ647kKo3xOYUuFFYP9xn/83n/H + IRw6QUKwsoky6R2pjXqvHT/LhF1d3eSke/GgMsZV5B4jKVjPkB8t3o8uZF4NLcENzwW/D4MtCaSBQElV + esD/7/7JWulFpSYbSh4E9N4jqWxyNTa8TBeCHhCEWG51zUddKIx84k/lKFKT32adAwWz5uZGj6tDTF8V + qtx5qrSpwBpSplbIKTFhjordSNafyi2ENygm9z5fhizC8w2gbZi+Jr0zTVHvVQ/M1+9D87tgzPKFtyL5 + 91+sQ1bIR/u9g26tNJTqfaCM+J4+UFQemvJSm7wuHD0h8PYcRWF3irzmgZlysOpUhuHG2iVADcr9ZPFO + ef19EDRz5+IbCM0haV5K9KTyNnqWDPrmIincdtoEblXOaKQgr8RYoLeC8ksaUCxwaMA7W7XlxcAff+pu + r8YtjEXwX7aHrvCruz3jgcS9jdWN8oUXyqT3eChYeQtR/mLpnQ3gqko1PSUIGmwI0jgNYTQO5eL3WChq + uWhTCvRq8MG7/A/v9cxDmhiDrxk3Q7Im7ZDy40kUy1zcuRWRZaDBkOOprjHmvfnri1WBCWvTVuikcSJo + H76vbYLf35+zS8cllfPQPDPwf1A0NT+mkzAPJxqgWI/GWBN01Wr52/unq4LG1WIa+XpSgafCqyvupI82 + 8JVhvUceM8pPIHnSi5U1k7ZN6eR/LD+3C7Ad7L9gTtDTY9RLJQ5aq8d/MTXCLNhxSt73qx3y2vugZKNf + dc7gViUqYugr8jLd3oS+7DZmKsrPOrB/8Q556lgocVmom/IrPIOyqf+R16rxhfWbJW94eKHkFuwWGr1I + hzREqXFb28y29ZkiyrLTgIE6BbFzOgttM7QPxhK3J3GrgvEj5BGnl4t5cOw+Ffe+P3+/DP/WItSRxoRi + 5aE90AfdaWzAPcdAN85L9JgibbBteFU6QVuhDdRoivd7+lDFFu1k8w/ayW9jeny96aur5aG5B+QMtzBE + bZsO24H9qAYFn89qm/Cq4DPWpeX+nFC6MHpQuSqZ8HZUNfjz7fnp25swVeqaGjFGkRbKFJdaozHlURFv + Wy2q93ypGmG1jqNMqTc6mY65fKb0QhsqHeUiP/AIbS+Mbbat0Q3blLSPNiOfGDVFXgEe8g+/2SUbj6NV + lL7ZJsYfSLvahywD6qO0pNvFLK5R+lSrWL237LjI//1+tbx2HPLN5tiicdkMg6zfDVnFWj7rT4ALI2PR + h3iH/cgFHh0TY9Fe5OVE1hR53YQi+cifD8nmk37eaJNgzAXzzyWh32sYoQ8dHBwcFDr5+pMPGKS65urE + gckust2TLR8Q2TBCkhtvlXhpf5GyASLr+ktqYz9J8j7E4HAhiG/oJ6nS20Q23SOy/0GRmrL0NhNdHdTy + MXhmHWCrp3bkXIMJTayDIph8weQxiQbbQxzODZ2kE1wRoUHHhOLP/Gazrrx5ozAhtxU2LhScmPNmQUnB + ZA3FeczEjWacSFDIbV2WUKRpwOjT6LTl/+P1Me/mx7mqxNUoCAY5s6VXFvLlKra6zmeU5SJgq91MB4Ih + V24gFA19eq40BavrGWW5GNCtdd3uo9KX5UVeKvTgGij0YWVqjTm2sqT3eJ9CML8dVSi/XnMMWYTnGyBo + S7t2PeOEB1pRzxgoRdxKU1nThDyp7LYoc4K+3neiyfv0M4t0q43SGr/hloywNC8humflI08o67mz5NVj + Jskzs8tRLGsHPdI2SoWtpf+C0yzScQz0eSeQiHmxuK2yaz/46as7dvIM3kl6FU0p78nibfKWB9Em3IoE + 4bxP9mQzsEHZCJSqtGJGRQy/yQ+6QbjvmTVLetGIAUWU6DF6NgT7WdJtFBQNCvkAeVF3bsUZN1e8z/9J + hjycL0/M2iNVVHqUNjAncB+7NHtnIinvzi+zTzvQP1fZODFy0k5JRRkDImhfy3/1vhPy4R8ukNfkvCg9 + 7n3BlFI1SphiRPrTZ3461r7twf/OZZygAkSjTss2NRq5SP9UJPE7MErg++DY5g37m+RTvyqT3jkvyKvy + 0L/3vmh9pF4QvFI5pzLO/jZvDhpW6DlAxd28Bqjckp+yPuwn9BfohTTSg4oc64W5oxvG5ytGT4HCOkVu + +sps+emi3RLhKT9pj6+kBqHVGAa+R4XF/eB/nUeU3jlsE59ntRhzzIOn9HCdPDRlk7z90RKdK0jzfekN + RY8H8mMq8Qrem8eUAv2n7ROsqivQv+xjpR22G4B3tB+p5AIcM9rGvoHilVkvyMBvLJUp6w9haAZBglE+ + en3pPek6ME601KttHI+zoq1xAr93Hmv0erOcHZhfX/XgAqmJcGuS9ZH2WbRZPXN/tOGE3PnoLOmbNVG8 + kcbj2Pc9Sd86lxPMh/VHemyDdHta+ygfJn/hNjq2C9qLBt3uWZPVQHHrA1Plh6tPovqsD/uOV7SNGm/8 + rUEc96ib3sfMyHMyKt4Ts/bJ3z40Q3qNQvmyQYvkPaRtliMLtKrzhl8+7Wte2Y94h95NLB/kBZ1L2b/0 + HhoLPgd5qNu9E6Vvdr7c9OCL8qM1NSga8mZcC7aTLs6hfK3k25cfQh86ODg4GExoCSYgClfpIExkkoef + kmTpEJH1d/rGiH4ipXdIouxW9Z4IMzhcEHjSx8bbJbG+v8RLB0pq6ztEDk4QqVmrghGDG6XLpqsUUZ08 + zPhgzLzFEMHJ1mAGiksnpLx8QeHDVj6DlYM/r6qQbiOnyw2q4F8CQNhQBRqT97u+u8jcGXWlom1ZQkDh + EMikAfuPwkXCW7G/XvrStTOLQh+FEyg6XMmgEDf6EhhXKERDCNOVEBWqZ8tf5U2S3acaUAfSWpvyXjCS + 3o/nQZlBezMPXSmHIqZGCgo5YWVqBQpoEOa4ip9HIw2EKSiIr7l/ruw8TSUjLM8WsE1brl3QOJE3V7qP + Qvnohj5uthyrgyAfj6W3drBdePLGiEcmoU/wzlh6BEAg5WqmCqMhaV5CcFuE3t+LMiLv3rh/Ynq50Fhg + grXxOnoh8bcpU+ThVDL9NuwM4sZvqVRouwPkyfyPBs0VR2LygafRLjRkjl8A+qPxBuOF4y8LCgfb1V8x + pJKlq8ccnwCVVG7dsFVS1E8VDSo8VEJQZ4L7y/FN91FIi8qHKiXz8Q6UXQj8H/nJcg1oyhOGSFcRzgnR + Ou9vHkE/XQeeE1/8E72bzBDA7XU0OK3ZfUz+9tG5ppRm5Ut30KUprWizPLYb2wpt1pGVa+Bcxgne0yCt + +fN/5cstK7k0CBtdAfj/ieId0nMc0r0XPGqMeQ+Rb6lBgTxD+4h8knQAcJzoWMF/7FsqeSg/+51eaPoN + 3jfDL5RM/NatTaAfpSHWezSuo6bgP3w/Kl8++fNlsu1E1Fa8VaHj1lSrTzxubdjM/zA20v10kdAxxuCP + qL+1W1S3wG48FpWHXyiTPlBY6e2gni1Ku6gPy0xPNtIt5iZC6Rx8ULcw+dtuPHpscRyQfyusbbpzKwMU + 6570IkJ6mcaJYAxpO9PwnzvP2gXfZ724WY43kudzLHD8sx/Zr8YTLkoeyjBOBL93VTd5fRgvROdb1Pcc + ePWEhVLfyPHZQmeNkOvuf74U/09GPdhO7GfUifViXzP+Bp8p7eAZaQdpmUdJoc5vbE+2kRnzQWekOb9d + 1MDB9OhJOLoEckyxPDRjm8VdSTa29KXKPShXNPCGsWC0DJT8ju8ul75ZKN9oK59tKWH5WDbSJPpBjRDI + H2Vgv6gXHspHA1VPjH2WT8tG+YHvktZRB5ZPDVO6faVI5ZWsyVvFjg43WrMYK/z98kXoQwcHBweDCbEU + TMioyZx1ogeDVObYtNWLbBohUnqXSPkASa69RWNIJDf0F1k/JNzgcAGIrb3TTvfYMAy4Q5Jr+kt87RBJ + MHDm7i+AV6+CsFmrZeXqjU4iLBtg+5z9sqcnXgokmeAzh7NCt3Sw7Xg2vymzB040e68ZR7dUX9jqBHQf + PiZoc4Evltc/MEcO1PqKU4dWbsxFlf1OmJCE7/xVsh8vPWKKUc5sE+K4SsdyUwBQpbh9mS4MEE6gwDAY + prpKQ0HsNnqS5G85JlwBCi3zBSHm/dfvN6ONZkHgorAKQTcbAi0FcwpBoWXKBIQe1h3tq/WHYEzhlYYA + W1k8NwKhM2jXLmecoOLHNkSb/9XDJbL/eMSUHl+Zm7qjQW66D0JkzlztIxsTFIIhcNKjISzNS4oSpT2l + 6Rwo/7lLoBjmy0OTNwoj6JsSYuOWgr8qmX70+6BvOwXfMJiM2moejzsNVq1/uqJS/uo+P26E3yZUSNNj + hTFaciicA1SsKNBnCvqoH9361e2dzxgzAdB4FHhXFbDR89TwyDx0jznpUpUCX4G5d6IM+MYCmf/SYWFg + VxptaqPi3fKVhTou2rdnG1xl4wS3XqkCDEWSdF208aC8aTzai7FnfMVIwbZVBQ5XepGQr0J50zEfkm6g + zPL+nNs6dCySfgD1ksjgs/q+zbnr952Uf/rBcusnpjtuvvSh8Yl5sVxqlMD44Ao2ymXGXGAU+NkoKpbk + A+TNs9VLht5tvelVw29RB6ZL45/FW0Ed1ZiNKw0YjKEzHnRPb5o81ne63PTQDJm+ucbaLtag5WXf80pY + HW1cdAbaDr6hMoa2qgcenrZVbrofiu+96F+OSdSd9MmtLbaqzxV2tAONM6wflWz+5n/qSULaQP8SHAdU + rGmg0b5EnanQqlLbYpzQ//w+5T3nB302Cgo00ya9jF0sH35muRyssS2HYQHFL9hAcRbjxA15JUaDAb2d + Ba+/v0TqG+vUu4VpHG1MeJ/86TwzKtDYkIs+13RYZ9SdcxnnPfIE/uZ2L77LNiJ/UG8b/sfv8Q1ow4yQ + aBt6NdAoRPrBbxoBrN3oZVIsOX9YKlx4iwFGI5B54gmjFX9emV2+X950X6HRMfqL3ilqSKCMAV6lZeAi + AOqmPJnl4/9h5UPZeoxnn/MdvM/+52IHDVM+XdzIMcDyT5gj//mrBdJwBvwc5WM5acxp1x8vI4Q+dHBw + cFBkuPxxVVr3K0Jh4pFmJqRjctqXqwEvedpGav0dwhM6eAKHGihCDA4XghQNHxtuE1nLWBb9Jb7pFolu + 6ifJjUPVqyJZOkgSh+6TaH25eXTQmJKsV+Xk7AG9WJ8AYf87pIHJWQU8IBBCiPf9aJVNuhmCxkWBAjom + XxVAODlD0Zi0/iBkPeRJxYrXc4EKAwQqltGECJSPyhf6lr8/+Zt1mPAhEKjXAPJQt0sTIlRYDCvThUCF + TQhRFJQhaOvKee50GVew1fay+mW6WDTFot4d32Rbs23YVoXmxq/5Q9hpW562oBIHYZdCWM8sCMxj52s5 + /7BiP5I/f/m0H9LXLmic8OOUcPX+hrHT5eAp5KP9Gvdm76iXvhNK1GhEt+Pe40ljoAEqS1Bqr4RxgkoI + FRIVbJn3WCghUERePerP8r0Fe0054zjyx5K2jY4PuuL7bdgJ0AhhXhgE2yWmQvPTxdukL/uVShHGnCoS + VJxUmUbZqSCgzLqqjvHD1XAzOPB/XCmcM94EFQ/lM77ADnBFtnvOdLQxxy9PVaGBBgI/+IilxfSnWjBI + RsofOVPe8EiJrNhZLSzb6Wbx/uZxepn4ZTkXrrZxYuIOdFUdvk16aw+cklcxXgf5GBVRtgfGD9uNAW7Z + BlSE04Yc8D2O+wBt0w6end840YRro86vpBkzaqK/9cjnpDe7dKfc9Cj7GrwlZ770HDVT+ozCuNFtB8iD + ihmuptDhnnRKHky+PxbfsR2oxKlBBUCbW0wgfEvFXevF/jXjhHrK4F2ij9IA64t3qcTlQvHHNz1Hvqin + lfyx9Jgfh4VbP1luwHeP12Oyg2cXiThlDrQR46ywzQ6fqvduzJ0M2sU8MG6R3Jg7xQzv5Jecgzj/sJzZ + U9FP7H/8VqD87FP2H8aKeVFwa0C+8hGLx2Hec9p/pAHC70vygYAXtALagDEaemG8qQcYvn/Pd+fI0SYb + p6RHxqDRODR+nVov5LQ8D8VZjBMd9pwYVyCNTegP5E957RM/Qlsw+C/ol1u4tK3Y//7Yp+dB71FTpFe2 + bZvg1gdukbFtHkG6GBNjZoMvg/5oACAdaXswHaaPqxo2Z1rAStIg35swX56efURsu4QfZFXrZNuFZ5cf + lNfdhzRJY8hft2ZwTkae5L/aB+w3zLO6gIB7bjnSLTz0ZMooH7cx0RDnkUfSOIF6qXFW5Qn0Iz2N0FcM + eqrtoYa4WfLAtL3SGGWZ/LK9jBH60MHBwYGwLRGcpDAJYdKi0J+CsGKu/pxQ8F/Naq+5fLjE1g4U2TRE + ZK1vnCjr18rQcFHY+DY1cmha5XfiGdIvZdoDJFp2tyT4znpu/RgusifPYlJgoqMgEtNtHRRArPxWn7Ye + FK3r69AGvkBqhigKY2y/pPc1Ctg84s8XMi4WKlRQUOAqBoVMCNTjJ5dh7mV+HRAefQOAKl36205uYJmr + m1LeWx6FYKLeDZjsKaBRgONED+XAlOLwcl0QIHRQaNQAZWMguCD9Ed9dJpfiKL5dJxq9vhCaVBCFIKRG + BpZflTsIR2HlyYAaEbgiiXpznz8VhldBAdhdVYPkz0//gdBp165nnOg9BsoB256C5sOL9ChRidZ7e2ua + vEFP0BA1T/tDXdCpdKEeZphAnXT1vn2alxIU0LnSxiN5uffZVt8g1GZNgiJbLMXb/SCZCbork3dbG9FA + 0aH2PQ909Y4rx7iSN8QSUe+HczfLjWNZLoyxUS+inBiDqqiizKRbtEuP8VBe7p2oyoa6stMwAZAHmNLM + tmSgRArweE7BHf3Ad/UKkAZV4boX44LfjcV4YDr8D2mokQJ9oTFm8ubK2x+aJQePnVDB/m8en+uP1/Pg + KhsnvvinDUgi7h08E/X6fW0Bns02I9io6bpnnt4E9C7pSU+Ce6Hwsp3yyC/I79imVMLC+XRHjBO2Okse + awoaeZptacJv9Pev1x6V14LO1IuD7UkvAW7rwH0vKnFUtNLgc/arua4zfxoatB/xvvat/jZaUM+WLCjm + 4K0ad4LPuKqMqyq+VAyzFmHsTcX8AWhQVCjjqDfjVzBg6uugeE4qr0a1UAduv0C57cjkFt7WGbBN0ttc + E0kNXvzaR+ehHOxflIntgrJoHaCkEuQXus0FdaIBrzcUV/OsAN8ArH94RX1J0zQ0cW4kSNtoL90iAJhH + Eg0aaD/weO3ToM+139k2c6TPyGkaO4eBR7vlTJZ/f261NMWtDYi2Bgqj7w7QeCeNE698cL6k6mvUMDHq + j2u0fbpxvqP3D2mC9fMNE0yP22PIM3Ssj+V4YNsA5Ht8j9vEaNAinYz053vmFYwB0iDanfFptH3ZdmxX + NRzMl1eMmSzzt51CVeLpY6pJ88t3VckbxyONUfiG3hdKp+RbANrcaNnKpx4TaohCPYLyKT0iH5ZRxwEw + CunhXrdxBOUkWHatN57lgZZGFugxyt5ojqcC+dWyQxaXSwMd++3+MkToQwcHBweFCilk0lwZw2+dwExY + 4f9NAqEXk3Jk55ckUdpPEpuGS4rGgvX9JF42sL2x4QLB0zpSZYMktWEo0hwkUnorntM7A2kzACe3k5QO + k+TaAZJcf7PIthEiBx5WIwXLm0g2ovy2ks7y2hYPq9sFuzB2RaCtODmnA4r5bbfh4AkoP5hAgwn1IqFR + 3FUQ9Y/XgqDw9z9eoSu+XC1sV552MIUhEKipQLCvKexQoFABMRuCApQdCjuq9OhETxdiE5Q7A3PVtXse + zWeCxXTpy5gOxyyQXWcwc3Ml0uOKoQk1uvqIvOykAQhiGWUJA4VWCrXWzqgv2uB9P1gpTVw1hCAZlmcm + AqHTrl3POEHjmUVbL5Ib7iuR6pP1Gs39P56FoAjF44Zc0BeUQhUic7n1ZrrRFb1oeLxfSJqXFFC6dWUO + ShwDsnUbacqPxne4d7qMeHyG7NaVNozdpCmYGhMC46S1MnJxUAMc0mKaDbj/zepD8uoxL6A8DHBIAZ0n + NdDlGW1El2woFYwPYUcgcqWRAj7q4SsMKqRD6ew1arK8UlcM8e3YaRDgcT9mEpCPOuN9PRqwRLdymMeA + DygpqrhQsWX0fKRB5V0F/ZGz5cPPLJVTdU3ezV/nto7zj5+rbZwY/cImaU4mvf9+Yae2i7YPjbnczkNP + KNImeIEqvGwHVWQB0J/GI/GVMn6n3zLdtOJqeZzLOMH4CVpXjDPjyfwv4tXh+scNp8SbsMQ8VFCfbnng + C6A/VbyRrvKodF7kPeRZpszpMxoq2A5Q9ugF0SM7H4rnJOmdYzEYuNr8SijTrKfyLip3vlKv/BDt0YfG + rrEYi3yO+nIbgJ7wQWMN6zuqWG55cKosPNAoui3Rn8NIr4HBvTPgMcJMT9sMyn6yqda77ZtLUL5iuSH7 + BTMWUvmlRxANSegj236EcrPvWA/SP2iX/aMeRGgnNTjRcKd0zbZiO0IJVkWacwDSHW3toONHaQJt7ivK + 2sZoLz2GmN+MXqAGrN7j8Bzj5tWj/ihPzd0n3Ial/BII+IHKReCf5jXbur7t0EnjRN+H5qunwnMrjkrv + CVZHBrxl/ch7tS85d+FevSvZZqNwVaMCxw/agO2K97qPnJz2qND38mi8wLujfKN+HtqW/9HrwadLPeFG + jVqgoezJ0je3UAY8OUcO1LEu5l22+3TUu+2r4BejS6Q3aZBtzfrRIwZ9pfxejWjIU/sG7yDfYKsqy6ex + JrLM48PGAd5B+XRMkj+p0Y7GFPYh0mf9lC+ifONmS0/SOMZGD/T5mx+aKdtP+vJY0O4vQ4Q+dHBwcCCo + yCd49BaNEZy8glUCDUTIyTliE9Ph34tsuU0aSweKbO4vsra/xMvoQRFudOgwkI6sH2oGiNIBktxwp6TK + bsN/d4isGyDx0psltel2SZXTWMH3kO+G2yS+5Z9E9t4vkViNGijMoGJ1cug4KKhw9UwNBVx95YTNCPiY + GId/b51Owp2BroRQMIBCwRWkHqPy5W++MkfONEag+HRAOPKVURUOSZP+sVsqPC8sgyCGfGiIyJkufSiw + aWA+Tv50q6RA0L5MFwJGiQ9cRWmcUGVLXY3nyqzSfShi2/JeGH5QsgXCS0bgQwozELz6qADTvjxtESh+ + 6jUBhYblG1ewx9z90ZdheWYiEDrt2gW3dUCQpzs5V2R5XFxTXb33x/Un8R9oh4IjBFw1GKE9VCGg4EpF + g0JpB/qns9Cz8rkqpzEIqJjT6Ib2VDpfrP30rVnbhKd0sK10bzfbV7d5dFDBPid8GoLit+FIo7wmD+UZ + t1jHhBoFuJLJFUUoGFTK1HjHPfdQJmmg0JViKtWqeJqg3gdte8cTy+WDz+2Ur07bIs8sPCBs8z+VnpJf + rKiSJ4oPyP/+eoP8w7fmW2R7Xxmj4se6k6fYKjQVNyrpyJd9NWqh9BwzUcZO3iZvf3It2osGj/Zt2gpX + 2Tjx6KRSmbIzKq+59w9aJ2/sfDXu2Mr7fPxGvdh+pEeuylIpozI0DrRBZWZskfQaN0uPbyVUQVOl0ZQh + 5nEu44TyCQ2CacdkapBp/J63pxl9za0HhVouda0nP+W2MW6jY/mpaJMfAuzn4Kr/Ydz0vm++vOdbc+W/ + fl0qXynaJ4xRQoPHH0pPyo8WH5DHC7bIB369S97+1SVKP+pNQBrxFXIGf9Wgh1RMs6Assu4MfkyDIcff + GPQ32wa8/t1Pz5OKOOqjW1FY10tB++hPqdf0GlUWwjO0zYgfrEF7+MbvLHpEmPGIdbaAiSgry8f/oQzf + MGGm3Py1BfIvP18n2RO3yTdm7ZFfLj0oE9dVybS1B+X5lQfkpwv3y6Mzd8l//6Fc3vHdpfKmhxgoETwd + /IZ0roox2zUN5KV0AfrA7xtAa8qz0U7qcTCqUF71wFw5XFmtcWIC2mypG9unA22EdmwZE/b7QowTf/1o + gazcF5fb7kP/kpeNpxIOnov2MeMWDTrocyr1VOjBO145bo684zuL5UvPr5WnSzbJr1YflBdKj8vvVh6T + r8/aLx/9+Rp588Noj1yOb583cLwwPfYH2iWgS3qs9Aav1FOWyEfHYz7KfkG+Ov8QWBvjTzR7n/rFSrQv + 6Y4G6DnSOytfbmBZycfAV9RLJ92385Qn3fPtRTLyz+vlO/O2aPn+sr5afr+qWr4x+4B87Bdr5a8fYV1o + dEM56QlCPkkayWZsKMaw4vjFeMkBL6OhDeXuxq1CGNu98ezeP2+EuJPRDy9DhD50uIZAxgHGR0K0SPQU + Bmj9xSSRonu9MQZjDv5/ioCx8F3ck5A54fjgBKRCnIIMhhMvvycsbxViMhhUZl5EMIkFjMxc/WMaaMfi + E7TOR9Pxy9EK+hyKSKLJk3itJ9FjnjQf9aTpoCf1GzypW+fJmVWe1Czy5NRcT04UeXJ8OjDVk2N/8PE7 + Rarq116y8leSrHyuFfic0Peqf9/yHdNgWkyTaTOP2pWWZ12pl2w+4KUiB71UtMJLxY9DCKtF+7HdeURb + 0M7WRpn1JXSyUkHQh1/XzPaj5Z0I2ojtFrRdJtLtFNzr75Z+vTDwO4ACKs9sTvrgf35+QR2MNoI6Bgjo + BN+zXoxyHKvyUlv+QVJr75TUprulufwmSa67p72x4QojvvHdIoe+I9K0F+Vl+7LPTMlm2YPI8rpdBfU3 + wZ1XGl1YV/u/q0JpON3vuFfBLqYrat+eCgHfXw3iKrK6tqtgSDdSCpOc0NsLJJnQc94ZFE+D+UEAYTpQ + JlbvPGmui+eBCYQA+ozu67qSxT5MRLxP/rksNM9LiRvoOs3tLdwzPZIeDnT1L5Ibx74oD848akoh2y5z + Fcq/14jb+juiEeStre2a9M/nf+fPtqj7tq7M0DBB5ZfCGld9AkH/XAgEOwpnI+dCkJom5YfrpVGPWGzh + 9WeD8p70tQt6TlCBAD3fMDpf3vRwiSw5eEbe/GX0cd5iWzGGYhQoxyagUkngPb+n4Akhe4ytfJkgSoUK + CjXuTZnKyCtIJ+NZZ8Fz9G+YMF/WH0frJHjcMtuMsKMOW7VlCPgOT2Kw30bHgccZr5oG0jrdGPcGPrUY + Y5n1zAe9LVLaszgn9OIokBupkGtgPtDzWCiXI1FnjHXdTw8aeDV4R87kbbJi93FpaoIsQF6j+Z4dOyvr + 5SdztsuIr0FR4FikwkCeosoH2gBKhxolOXboucF2p3cJtx6ol1Pr9mqHzhonMt7jd5zbv18CuqRC4xsH + zoX/+t12uesH61EPjF+ln4kYw/gOihCNAlSu9D/yHQYHRR1f80Cx/O8fSuU3yw7Ksp3HZcuxJtlfm/J2 + n4x55ZVNsmhPvfxq2QF55IXVMviRfJm06bTx2jjjShjf4dGhEmcsH/RBDMo3nkVpmACv2lHd7L3m8WV6 + zKuuZucYP2CcBzWQ0GDibzu7AfyKRgRdReZ/UO5uemye/LBkh2w7egbNErTTWZCMezwadPHuY/KF5zfK + K/IK9KQFPdGCfQn66TNqkq1+j2E5SANsJ9LAVLSRGaqoNP7fn7cjSZvXtQ8D/tspsH1wVZkK4wDPPvkc + +guKpm5LYDwDf9sGtyD1AP3T2PnW+wt1y07h2r2y+Wi91PlbLGx+NbpXWtOxCjA4tMLG3L6aem/Oxq3y + 6d+tw1z7PNqVW3mmSm/Gu+Aq/AQa4yam6ehs+PAvN1mMBT11B/I7+lrlnkgQW6QjII37wciBPdUN3ivH + kSbRDyF5ZuL1E4rk9m+t8McivqFHVBb6Ev1KoxO31dEAS/p6y4Ml8uScg7KzEnRDg5m/QMY807oLfpPH + 7T2V9H49Z628aoKv7I/GmAfd8MhyL2sJeA7yQVvp3EP5RWUY8CoaCMYulreOL5Aj9eLlb6qR3jQigqZ6 + 8fQMlpN0jLpx+5B6pjAuEery5gfnqHHkpaM1EI0tSKqWUemNuhF0BtAzy7evJu79du5aed39+dKLXkfg + Sd5YGktYlsVWZtAM5SMz9vGkj0nSB+OfBpFXj5koCw82IWmkjzGp260AerhqP0CXMj51/SL0ocM1hAwG + SmJTAsQzPboJ4G99BtCAQYGhhaFxzyCVX7rkUWgztBghbDDruwTSSOfhg/fKJIGACZlia+nzHf1P88Pz + WL0nTceg2O/x5Mw2KP4zPKme4knVnz2peFZSR5+WxKEvS+zgBIkeGCPJnZ+W5I5PSnz7xySx9UMS3/yP + ktj0XomXvVPiG+6WePkIYJiuwnObAGMNpDb2U8iG2wGeCEF3f66cQyFV3BkObjfQ//kuMVhk4x3p9Jg2 + 82BesbKhwHBh4MVE2QhJlt8tyU1QdDf/vcjWfxLZ/kHgwxLd/VmJ7f6CJPaMltS+B0QOfA3K8PdFDv8U + eE4iNS940ZrJXqy2yEueWeRJw3q0z0ueNB/ABHAU7RuBwBIYOoJ+YTv74HFPOlkZAmMBlbAY+iGKZ4Sd + VGEGJk2LCpAqQYyiTs8H836w/21ytr4OaALg+7r6TKA/AdJaKxoIaIX9jwnVlC8+Q/kqn9V4EzxCNFV2 + B+5bjARXC7Gtg6V5w50SK0efHUL56o/qHlHWyepQp20URdvQqMY6Gk2jXh05LeJlDu173aNrNKM06Quw + s7eewGSdr8qWCoN0wdYVPH/VSIXmFkEkFKpsUznlairdN/EthMnfL9kDUmxfnrbQiOOkVbxrwhTKin6N + NCe8gU9DWA/L8xKCAoqeODAWwkQWlU6urkBwyf6LfOLnG/24EyhTgm1oPNp4bdCeQLw5zUfVSKbP415F + fcJ78yNz9Ux2VZIpFKG90ls7VHEOL1cAKrum/NOYMV/ufmqenA7on7xF8zo7gjIGfd/VjBNatlz0Adrv + FfcvlC/+aoEw+KC61VP5GYvyU/Hl+zRO4Kqu1ypUQnlSAwa9VjA2uDqH8UFjHJ/rXvmMvALjxCU1UIyi + W/QM+UohA7T6QQFpkEY72Sk8fjueBen+V5d4fgfaQf8QpGVND+l+pWCL3MCV0iy0l3qMkFbpQcK6kHZL + oGzgf253YWA/rjyOW+6300z59B83y8qDUO20XBYcj6cfBOU4G/gex31Vo3jPLtkvdzLGDNNkYFD0hyqm + 7EOujtIgACWEfdmHPMvvr3PiKhsnXn9fgQYz5Ls8OpKrqeqZAt56w0gobvTaooIERWvA4/PlR3MPy+Ea + zvWZ44LyAJ4lGHOh5T9uTzrUZKeX0Chh8gHaE/2a5NznvxtTQ2ZE32+OJDwez+qN/DPalkeF0lOhRPv6 + hnH+OEC5XgF+2I2xPlg+eq6A9m8cP1uemrNHjkOxZh8zvdZt1R404Gq+AOfkxXtOyL/9ciPyYf8h3zwa + o6ZKr5HkIcgf+VmMEf4POqDHGWiORoE3osyL99djHBjfC2i7M2B/kp/H4mxnUwi/8KsVZvziSQs0mKiR + Hoox+OY//aJU/rT2kFTUmHGQHn6cS7WvOL58zz+mzbT43LyeKJsl0qdH8Bv9FnnP29csH3l2ifIN1rMv + eXNWsfSegGsbemqLV+UWyMajVHIpS1reGmsBY0/HdofA8l6ccYJGd9K0bk1jX9LoxAUOelMybkPWbNDV + bMnN367bJNkmPBGF9KDjEfWnzsMA7Tb3Y/7E/2xbGopWHhIZ9uQc8caXSDeeXIL0NUAm0uZJMTb3oBzc + bqZxcjiW5ulJMxNeKJNh314mvb70PPgG40eYh5DylpHTzWiBMcCTPrInbpFtlXUghRZ6VZnYL5+djNK+ + fKsrRN79dZSHp0JBfupJfk1Dydi58gp6BGGO161BKlNN1WCbLB+9Kcbnb/Y9IG27HvMmPRotRdL9cb0i + 9KHDtQQqrYHiSiZgiiQVShocVDDnJI5BECBgaip8pJ/z+9Zp6QqIKr98RgaI95iWAr8VuKcwE2+EMl3t + SeMuL3VmlRc7PcuLHM/35MB3RPZ9VWTnaJFtn5LUJijv5TxJgXEBbpPYRiiIAAMXEinGCsjExkH+PZRJ + GhA0nsBteH6rD/wOsIEGiQzQ0MA4BGkwDaSVNlLwf24LCMDfRMY3Wgb8l5luZp6McVB6O0ADR2Dc4HYF + GkWG4Z7v+GXjf6oU+3XT4I00oAT/8ZsRSPcduL4L1/dIausnRV76b7RfNtrxUZGD3xM5+luRqsmeVM9E + W6/xpH6jJw3b0P770Q8n0CcQMrQPM/vLR7q/fbR5ph44AOkjYF6kl4BmqEwRZJ6E0obCGKsiI70I6Ebf + Q3lizTu9RPm7bKtFGdp2DdszaJOrg9SGN4uUsQ/7S3z9ndK8418lefy3aMtK1CVmkwjHEAQwjgduJdBx + wXbTejm0DiBGnhNVwaUyIt6tD2NCZ+AzCPo0TqgLPFfrc7ly1AHhhAIkBG9VyHL81U4INVl/KAV5tS9L + O5A2E+ZppPxQI8uLt+VIvdyQB0EiLM9LCB6BZy60ELBYF676UDDOmiS3P1IiJ1SwRxlBa8E4s3JTWPF/ + x01pVLrTOhBxb/muEyY8cV+rKsBIn+0DAZwrKx3ynBg9TSPaq1vquLny4J9X6YkFmq+e2uCX5ywIymvX + rmec0G0TqlxAUL5vqfxV1p98mqVbti/YUskNDBNtDQwUOoMtCzRqEMG9uqi3zq/d950FyspV6zu+PEOO + NdI1H22UMCW7XVuGgUoreL+eyIHf/C4wTFgaMW/jvuPy2gdB8/cCUEq5KknDi+3BRrtx+8QE8AgI3jRg + 6Mq3GjLmaNDOZ1ZVSYPOJ1SGwWt8RUznmKAcZ0PsDK7oe30/7m2tbpaPP7NSjXj0IjDBvsi2RX1psr/S + j3aHYhIY+c6Jq2yc8LivnvFMMI7VmEWlbZTF5lCPEBqCwGtGTS6XIw1stxgUWF/uizXoWCBvUaOoXw4a + HgitR5zeqtz2mMGf9F0qqTRmmFxg3qJJ77tzdivd0gOLp53QOGHtSJ6H+qBMvaHkqdv7SJTNNxIM+eZy + WbqrBslSoSSfY9pcGGgpVxi0TL5xXA284Pf0MvjWvAO2/z9rlvQYN09pSrdwfAkKHr0WaLgl7fmKqCql + o6bKx35tCl0qdmkCwgZtpjIQ2ps89cEpPPoZZaMSm1Ugr5hQIh/7xXpZspuBFvE+6m/tbMYfqxt4MT1Z + VU43muE7LKuWN3gPUMORfs88GYw2qZ4tjxZslRu+OFn6cPtBNuvMxYKAjs6GYhmbvwmiPg0dHONIW1f7 + MebVWGH1PDdYnos0TuTOl75j7CQSHun5Cm7fyeM2GJQftP3GB0rk16WnfSWc3lQ2lzK/TOMqA/Gm5VSe + xqKLZkA85m2uFe92elbRwxHl6pP1otKJxo3g+OI4gsLPMaVBhTnXZhVr/AmeGGTbStCmoC99/95iuWE8 + fmP+fcODJfLc2hM6p6bLRz4BOsjUvyxmF+45t9GQxXt+A/lgf714A55CennID3V+FQ28yJ88kkYI5aNq + WGU58A7KSo/Vtz48S440Mh22h58eYG1lBovM59cbQh86XDvgyrp6OpCYwZTVhYxXXf1oIUoN8AMli2jZ + joH/eU9QAQsMGcEVoMVRJwumF62FErzbS56a70Wrfi+NR78vsmsUlOf/EdnyEUmWvQvKHhVzKus3KxKb + b5V4+W0SK7tdEhvvlPiGO3C9XeMCaGyAjVDgA6gyj+8z0cp44CMwLKhCT68Geksw3kB/izsAJDYMghI8 + UJIbzZuiNegFYUiV91fY7zbv4VumQwTpMo8gP+ad3DjYx1D8P0SRWD9YEuuGKmT9EB9+Gizjhjvx/u0K + WY86+2BQR0XZkDRajBvAxjv0G8ZMYHsSathQA8rdIuV/L7LpwyLbPiOy/f9EdqBvDjwhcvg7IpW/9OTE + NC9eu1yNBLF4NWinAcIomZR5Vajgp7TUghRpibTgM1EDBT0yWQg6+K2CTSaU5pgW6c9XDnR7CK77H0N5 + QRubrH/CDAZXFOgTenMkaIDafCfa8TaJArFd/ylS9ScbC2gDrkiYa6YJBep9RIHXH19dFqQTXNkmqpDo + Cqo94ySY+5dNECqogDHwHQUMCAEUEiFsdCgavgaQsiBhFNZV4cPEO+RrC6SeQjbLcC6wLAmjQRps1RMG + 5fz18sNIxxTGywp6h1DRhIClq5qsM4VhCC4UtJbu4Wow+XDL6oYKpipg+feog/6nQjiQjKgA+svFe0xJ + 1fQzBBSkTa8JXWEJK1MGNJAYBfVRFJZnyLx1B1XQsxU/68dzQcuXvnZB4wTbmCug3C5AoXBUgZ5t38qA + MBr9kfk7ExqvgmODq25TFeZmTuGddNLmfSBIKzS9C0Uu2lfzK5QXNlSI8TWeaMO2Y3udB2rAwvt4l+2a + GUSTcgODDH7ml+t0JbGbHmNqR6syuKEabAJDxMjJ0m0Ctx6gTjxhA2OcgQrnb6sQXUGnogYFgyvl2p9U + RDXWUUt+4cAchTKQpu1Yx7jXgOu4F9Yjb9A8x0w2wBVZjAVT6AGNzYFxEdZmmbjaxgkq4GNt3716IoBm + +kyYq4o269crb6ZMLWuQVH0z+qNBje1sP7ZHDfNDewZl1j5E/5lya/UJ5jttPyBtGMJ9lM8oH/iKztGa + Ru+ND5G/z9Fy0ejFvjVPIdI529vfpncvlL9xS6TbyGnygWdK5WAt8ks2edFYQlf9LdAmDUvWNmcF6QJl + SssgNJKhPPw+f/VOeW3uRORFOpsjvUBTDKjcIw9jbSRXmFlW0BppLgv8ctwCNVbNfqka1Y/5cnLnQI8T + jgNVTsl7IAc9Ousg8kR5MKe9//sLZNHeWlF5Kmqu/tofHDvKg60+xouNVtR4QZkcv1lvBd41A4X/Hg0I + UHK179SoQcU46j1cuA00MsOMcOpVk0FLYchbKG+6f4pUn7KVdpWD0C7xIM6Y1ut8sHLpuAUuyDgxdiHm + zUlKNzqf5UyRbrmMiTFZbnmgQJbvrPSPgkV/RZvMayudJ/uwZQ4L2szoGmX3eZfE673l+xssdgPKxVgW + 6uWFsc15VA2YlGEwd7PPVI5hAEr0Ybesv6CNFoC3gVdjzlNPOb6fVSRvfLhIFm8/4hsmkB8XGfxtFRp8 + FeVrd1yt0rFfRtIgywe+t+pgvW7f7MUgmSNnaPwtb5wfl0Q9p3xexjbj3EsZA+WYVFqBZJkG68w8/PkQ + 5Qn643pF6EOHawdkPnrvE55ZBI3wdXCq8YJbA5oBcwkmUZpnRXPaxcisjGCO8QpPmkqhxM7wmk/80ZOD + XxXZm6vbK2Jb3yWxcirDUC6pWG/sZ0oyFDtV4DcMx7O7AHoAUPnDO+voUUAlkF4I/J8YhveHQDnl9ohb + FckyKN4K20KRNgCoAstvqagHBotA4ScCQwbe03d90OOC2zx8g0ES+V8Y7DszQmSkG+Sj5WC+LGMm/P/X + o50INR4E4P/9WxlRgi0larDwQSNOAJZFDT6sTwCeclGOKxF4cKCtE6V32IkY6A81yhDIg99nQvunbKgI + T8546dMiOz8nsm+cyKEnRSp+JcnqaV7q9CL1gJHIMU9ix8HcakFbXEExZtpCR7znJMjJqgFXxmuglRr0 + yMk9au+mSFsQauKnFnpKP6Vvs7pkGgquAmI0GqE/0oYx0qx6zdBY9HaJv/QpkZP5WnfWI8lJXscZ6q4C + gz/+uip8JZqCq/IiCq9sH22jhDdn6xlMlhAEGXiN+5+pwEEoofLKib+dMNIWnOhx1XgVuKqiCkGB53uX + V9Qh6zblaQv0Uco3TthE36j3n/1tKSZwCBiZeV0OQCjXYFYQamicUKWd8R2gOHD/81NF21BMaysV/gG7 + knf7bYr/Lf4E6Y3vmmfKmL+Uo30glHAVmFAXaeZFZZjPaNBpU562oGGDisOYufK6h2fI6VqWg3vJrSzn + g5WvpZxdLuaEKl4Q9lUgBT2j/RlrQoVG7q1HH7c1JFDIJmgUoMcKFUtCV8BovCLYJ75hLgyXzDhBxYzp + QHljYDdVipR3UzHy2/CcMAUp2NOsCoAvWPP/pQcadJuL7vUfi/xGQTmlYsQ6ahm49SDY64225J7yvDny + urypUrD5BJI3fhuLIT0qIEjf5BXkneSqcNvytAaVVL7LLSBqeFHlNeJBHfQeyV+rbtjdqXjkzLXTQHRb + CQT7cXZqSLv2aourbZzgNi6OdZS7N5VtfY52vHeKvOnhqTK17JApbzQiSBP6yQw81rdoW8bxouKkc1nL + GLE+jKpSze8TCZSPsaN8uTKKuVzTJXwFcOzEMrQd80cfshzcn4+ycGyw/2m08+j2Tp4zbiH6u0Te8+35 + sqeGnmHkd6aMWd/6CPI4G9CXTXhPFUBVyKN+Ofm72fvNqgrbhz8GCi1pkMZD9eAo0LHXk0ERQf+9eXQk + 6Q/j999+vAif83s/j06BXkW2LY/jhNdvzd4pbxv7F/n6vP1g++LxyE6WX+cn8HYaMLR/tI9It1BoURb2 + m45NTTfoo5b3LJZb5vzrp4f/1AMU7XsM737kp8v8OEU+DZ0LVMDHFEjRmr2i+bBtkaf2Ubos5wPLc5HG + CeUbfrwqNVqCf2TPktc9UChTeQSsegmDZqKgSzXCJLSuZgwirRpdsw05vljuKOjE+BTbFu+laASLew/n + 70IeyCdvgRkgwJ8po3AuC3izGiEYfJIeEuNmS9888i3IN1x4AB95pdL8DPUOmrippXwB/2L50ts6tHz2 + vHX56J1r/ajtTB6IZ49P3QM+ae1hMhV4Fg2sLBfHPK6cV7g9RQ3ckLW+8JvlutggcbSD1tWMEknQhfGp + 6xehDx2uIaSZEwk5pm7nSuA+4vjfGBoZFQiUFjS6ejVVe9Kwz5Ojvxc5+F2R3WMlse3fJbHp3VDIR0BJ + A0rvgnL7DihvI3Clsg6FTrdWcMUe4H0Z36XhgEq3r2BT8aYnAb5L6VGP+JaeCRtvBW7Wq8aEoJJNr4F1 + +J6gUqjKPRVHKvN3SKz0doningaQeBljPhhi5QMVpnDzCqhBI/CKCIwdKMs5QEU+QNj/oUaTID/kHSu7 + UxEv76cI3qd3CJE2WtCwESjFG3EfoNT3llCjAerPNlFAYSb47Xq+R+AdNcgMk6RiuH3H9k8bL/Ae6hIY + RAIPFcZ4IKyPzPtD81mHKxHk4deNdecJF4lNeH8z8tr2D5Lc8R+S2j1GUtymc+jHIkd+KbGaeV6qfrUn + EdBSwlaldTLEtZF0F6UiZW6FpEsVLPd+HvkxT5Q7w1BwNWA0xFM86KFyW7ptrf3QDuU3S5z0t+1/JHWi + GHWM6pgL9gWGjsmuBF8gN+WZQogpK/ofhNtjZ8R760PcPkEXREz4KnTz6CwIHjqRtxFGQmBRuaepgKtC + AZUHpPXH0kpk4+d1NqAsNvFTQKHQF9c9qQO+BuHYN3xcVlBxpQABRUMFHSqCugLEZ0Xy8Z+t9uNOUDhl + eW2Vl0KLCREZ/1HA8z3ieCzju7+7QtNIB1dUQwOEEuRr0cc70r4sD9pz7AL5yDOLkRXnjNZ5nwuBgGPX + rmecYLloZKAwy3ISXIEzwxv6gO1AATvoF98wobQAumZAN42vQGGYRixdyadgzEB9XHnGt+3yvHTQfmJM + AIyFN94/Q05CydZYDmi3tHv4OcCxFcgbSrcqY5hHA39/6jflGKtTpBcV51y0DRV+1hMKLNvBGwtlkYHk + RoInqGENdYew/9vSGmE/qdcE+w68hDRGRTSgtZY+PQegvBpvAqiINzemFW5JNXjZf9kkPUf+BeVYBMUE + 5SFPYh9kcX9+B8bPVTZOUAnpfi9oBf3H/eY8WYBK/6sfmCF/XHcAyQZxp/y86DLO/mXf0qjgtw2VX8aP + CrZtsu+sP6k84V1VSsnbqez6Wz70W/yPb9ftPYX8J6Idi211mfyHZaRhAooT6cyOVkRfjzMD9e2PzJb9 + xyMmJ+gCGleykV6Cixx4FuOCGf87BwIlLpFqiUESRT/jGfuZ9JMzaRPKhPFHpY7GQzUGou3oEp/FrTzg + xZyb8IxeHa/MnSalFfiSCmWQz0VClWDUSQNro57ReMRbsatSlu46pUYjxu8wBRl9we0zkC9Yd43lhW84 + BjJhtEWwP1A+9qf2TUtbkbcFyq0apWJcoEzaWEK626vFeyOP22V7tKGnttAtWGNny33PrxIaqJRuWA/m + w99+nucGvrlI44SeYjIK/HVskfSZwBO0OPdPlp+tOCEtRgjW0wyV2kbanoGhhjSOKw0S+C/gVXxP5zff + MMTtHdWN4r3qftAoaFfjkoBvq1Eiq1B4+pXydC6uZDN+VL55f2Gs9ZyAsQqedgNop9u94Oe4fn8Jxh76 + p2XcWfmYP8tBzwk1RpHefaNFu/JxkYDbPXBPD96jKN+bH0CeNIgweC+NaWwnjDH1nBpJPsAgw1O0fFwA + 6fdYkZwiDfj0Z9tJLH/rm+sXoQ8driFwgIHwONDSzIuESIZF5soTJJq3eqnamV6y6llJ7ntEEi99VmKb + 3qdKPxVXNRr4SmuAQNFPewCogg1lspSKm78FgYEN174V/98E0GBBpdhXjhlLYT3TNiU+MHZIaWDMQJqM + HeEr0WkE2xiYHpFW7jPfYV70FuC7/v+Z4Dvr7zQE750NGi8iI722CNJRD4fMPEyRpxdCsAUj7a0ABDE0 + 7HfG1o8Nw32MUGgbBHXWcqPtFMgDaC4fKtHywRIvH6LBOM2Tg+2A99X44ZdN24XfoExqcBgkspZGBhpM + 2JdmVLHjNIfjPeQNWIDPFmSWnWiJw8E0/fIF+bGf11k6UvZOkc3vl+T2T0lqz2iRQ18TqfiBpI7/2UvV + zPKSGhtjLwSHKk8qf4p8/l4iNAowj6sKGkhuldR69gHbxjwo6LFCryBetZ/X3gLgvz3jJHlmCcZYnU5s + oWOyS8FW9ZXv6CRryrUKIvhN9/D//fUqTKKYSCFocEWZQSF1JZWnb7QRRtoBAqNGnIcQbvEquF3BYiqM + m7YDRcgsS3u0KNi2OsH7LRX10nc8BDNNNyTPSwrUORDCuIJMZVNXO3FF3W55fJEch2Kj7UdAmdK2Q3nZ + jkE97H8IeOTtuO48EfXe8MB8FayZlp5/TuEJigF/B2hfntZQ5VRXrWfILxbugQyEeYOCMvKzvM6NoNx2 + 7YLGiWzG62D7oYwQGNUwwdU1CotUxlBu9arAu+wPegnou6OmSG96EnBcBEo50tJVcP5Wrx4et9exfrxY + 8Fx83fuOctIYMh9Kk40ZtBOV0qAdz4YMoVq/A+0w/gQF/rJDtao866on6QFjV42LrDOURaURuiaPKkBb + ob7ZhWqs+exvVqviocYElINpMz01bOtRj3Tlx1joUPnIk/g+xlPcNx6QD1Cxg6BeDR7+vm+hHCNpXJqt + 2yDUqMdTVNgXIW3WClfdc2K6bldQXsa4E6BBHrX6aPFOiIY2hqPahihbDG0HfsznVIoT7C8qtarYshw+ + 8JyGKVOo0XZUmtFW/E/LqPTBb6n8NXkNMZD0i5tBRzNA63NVOVK+jTqolwxXvDGOdTsPYzygbV87Nl/+ + tOogWBkVR5SJ8iryinPVmGnHa1vxv3PCjyfAMU06IZR3MS2U+zju7/km+nLkVOk5fj4Kyy125rlEjyGl + w1HTpSdjDujJCzPlKyUoW1DPzoBtSY8G1lOVebZrYBRq0jqyjGYs4r19xzYIxlTLHBb0C/up5RmhNM33 + 2rwbY56k9ViNtSvGJufkL/6hHPTiK7fnAuYFts09P1gsDK6pNI68SD/GhzsClvfijBOUF5S+R+Hde6fo + 6S7/9MwyadZYTWZ0Uzrx661bt/Q38gTdxgIewf9BY6Qv5f/pb/yYaPGUxmL5zF/WqVdmz1HgR6AHOw0D + fD2XcsdUlIlyzCx9h3xLT8Ah/+Q45MkrePbPP1gkDZQNwb+YttKiX74YnmveOs6aM8qHawKyE/qKnotB + +dLljNnWoC9MLrXxNWqeBV7muM+Zo2NLn9NTE2UkL+ec0mf8TNlc1Yjs/HQwRpTmtE/w+zpG6EOHawlg + PD6hJZONXqp5t5c6XeQlK78nyQMToED+K5Srd6nBgQYIVVBVIaNyeZMqX4EnQCulzd+eYN4OUNJoeEgr + 57jX7QS3Qemlkm0r+OZZkaG8ah7+e8HqPT0bkJbFcmit0Lco8b4iD6S9Cug1kE6/JQ/1XICSbFtLWowB + /IbfqheHou22DYO9FwZrkyB/K5OVM8iPebcYEzLAcrIN+X5mmdPtYW0ijMOB9zLRth1EDTRUnP32xDst + ZWuBflfW4lli3iXIm0aKADQw8PuNyKeM2z9AD2qE8surZQX43lqUlwjJS/NTeuqvXgX0OtH4GNwush5t + qu3AMjM+BspMhZ8Gk43vEdl0lyRe+gR+3yyyGe8w36uJdTQOoZ11qxHaDf1kXj3oW9IYy63tgvbTPvhb + iW0eKNFDD4vUr8sYh10VSS9CoYr3FGKpBOBevQFUyY15P11wyJQtTJR9RuVLtyy62EL40GjW7QWSVoBC + Y9tBGNAMQgAVHH9/+L/8dBWKkFmW9uAKlE3EtpobhfAys3Qv0i5ObxW5nND91RBcdPWcK3RcnYPApbEK + IDzQtfilqhpppvDKMvvbTuiOG/XrQJji53s0QLidvxltmlViBgkqu1Rsca+r8lRm1UuFAmD7MmVCj7BD + uV553xzZd5oKIATlGNoqYyXuXDBBK7h2zYCYFrMBv3MXWV+PtdgJfcdQWER/+Mo431FvAfQXTy74uyfX + SNbz5fL9+QdlWlmVLNt5TJbsOi6TNx6Tx2fslI/9eGna+HS5DBRcfdPy6fgqlB/MpcGPwe58Afl8AE2q + wkT6ZBv7CjpPCnhm2nKk6wedRDtpgEK6IkMx7J2DtqH3FAXsMfP9le3Z8pYHZsqeWqTF7RfckuoL1Mwn + 0yOjGeO4QwI2vqeSzTLxO7p083nwm0bmOYdEbhzH8QmlY2S+9SfjhnSEhq+2cYLtRp5IQ8pYKN7gke/7 + 5hw5E0GaaVduH3piRBwKK1dx+R+UOzwPxpHuz6dnrfajPaNCxHai96PSBMdeWtFhGo3ebvTXGx5AWdGX + vUeSlkrA78HjcM8jGrmaq1s9dAwAefPl3362Wj1juN2T17QHAeMIIf1M3ndOoD/1e8ACDJqhwlz88b/2 + SdL7w5oKuWEsefEs6TMOcxHaTvsXY5b0SH5sXnl8NkPufGK+NHKrQGZeFwOMDTP48t5va79sHCMa20Xf + NcOP1QO/VVm1LQHmrenXi23uv8v3mjC/WjvyG4DppfvH8uN7Nh/TKwPpYFwtP3DKxn1bemoDVXTpQfBg + oRw6zbFj22+sHgCv5wXqcJHGCZ37xy5QbxzOlTQeLj+QRDLgBZyn2CZBPhqHhjSJNvdjO6TpiB6HylMM + gUGI/0elzpMoZJeYeC+sO6I06+UuAS3QCAC65lHHY6ajDDymE7/BzzSA9JiFatztOYrH4fK9ufKK+2bI + gn1N5mWifd6mfH7/0SOC/aLl035D26oMYP9rgGG0L99Jcqt04oz+fnHDCZ9Xcq6ZbPJFDj1KCjVwqMUp + mu97LvG/2VKy6SiSDGgtqd71yjuZb1C26xChDx0yQeKzyTxgArwaw6DF2l8V40AmcSiM0fM9fa5M3gYV + CYYTgDJqJSSmyXfJWPiOpUHiTcZrPN0PX/GMutvLlg+agkilSle76eXgK2EODg6XHPHDj4vUrdUxyXGu + Al4w1jFWlQ8Eqxpc8SB4D2SuiLxsgToeOXPGo8u4HqVJJQuChrpwd2jbQQjwHSffVz+yRGoizbaiyrxU + sAZf9PdTmmID/smrntPOK+SOaXvNbZPKUlj6rQDhTPdJo7z+iiAF7Xd/f7n8x89X6r0KttnTVJHUlRWu + llPw0kBVbdNrAwj0v1xRiWJSwaOwZTQTUYWMtIS5RQUuE2SS/orRQ4V79NvQNC8EEHTYFx/8Abd0QKjT + +Yg0akcDtuvPNtC5LX3tip4Tfh+jHY22AXpN6P56CJH3QsnFvW4RyCpQr59P/3w9BOwzUhfzDVLnwPZ9 + x+VTv1go3njS02SkvRT5zZUbxrwIepvUuiwXA9CuuuFTyAY9/e/zQQyU1tHuzw66jNu9KUAEjxJOeLc+ + XRaeZyaQZx8a10ZiDKGdni4uRfbNaXpqn98lhj/enpiyDn0HpRWK9Q3cz00hn8aTsDJn4iobJ6hYe2ML + pduo2aYwjZ0hpXsrhcp+i+J78SBftfqQtxJmiGKbKc+Nx7xxc07ZMYujQZ/cspNFnoLya2wHU3BVqcuj + olminh07Dx+ViMrOrfO75PCNvI1R8e7+ZrGd9sCtV6q8oUwop564Q282lFONvXkL5Qbw+pIdp4WGMdZV + eUiaJ1NB9+t/uaHjyQd+B54TFj8ug3YgYwRIf6tgeYNnvoEA/JO8ffhT4Z5Zmb/1+O/s2bpKP1ljKGCc + A5qObjEM8jkXWM6LM07wVBHy/2659AQokpzfrxJV5NEe1Iva53URwDhhX7J8VadOeW/Oex550dAHWggr + UyYY2BQ8QE8cAv188TdLNW5P0F+XBGxz1JXlqz512vvb+19AXvOU94SWKQM0WHxn0SFUkWmhH5IWR4b3 + tvUnI5/rDKEPHTLACYDCUsBAeE/wOQVJPCMRRDFh82SEYBAooaRsTxIJLzBqEDbB2YC2dMHEI4c9ObPO + k6qpnuz/hgYyTGy+W6JArMw8BHS1WrdX2Io0V9PbKlMvO6Q9Kc6CsG8cHC4RYmv7S3Tr+yVx5HsiDYd0 + vNIyHdNAbhQMOCHYeOeKAwXGYHzzdyhPeTkB7dEEfPCnq6QnV/YokNAokJ2xL7mDSAtSVAihDPYaN0eW + 7TqiMRuUp1IIgzDKexOoDSpEqkAX0xXXEd+a6yvP55/cGY/Bos77p41AoO0Bgfbr8w7Iz5YdwW8oz1zd + hlBrQh0AIYoKf3o7x7kAoS/n+XIVHriqRfqIgl6M/wO62klFI3ObR9L72LOrVPAPTfNCQGUa+OasXegq + 5MP5Rt2kg3nq3Aja2a5dMebETOmZ1+Z0DvXsMY+EHtyjnAXlB4ra2x6bJxNLKzV6O2F7ojPKGgIa3nje + /UOTy5FPsXo36OkSY7j62wH6PS+gSGI86TYr0Pa/PbcWQwV5o93SsRrOBRoC/f5Q+uQ3kHWW7a2QG8dz + FS8sz0yg3dQlera8bkKRbDyO0Uz6Q1pXRHhGPVnuLSfj3l8/PNdojcYS8BeO6/AyZ+AqGyfYd9wqod4J + GHP/+ftSOQW5U2meirSf9sUiGN9WTio0LQoh76ORlMa+oeeGKpC+wZS0b0EE6c1Fg8V0M2CMmi4f/VmZ + ROIsY+fLd36YUsw+fmrBUVsVVw8ezkEYP3l+sEXQvwbu5Fas3PkaDPX7JTuRhPFE7VdVOllm67OWtrl8 + aG9saAvrl3ZQQ0qLYYX1J7/R7Rgxe/4/mHe0rwK+FQI1TtDrBWP0p0t26VYXjYfBvGnE5vW84HsXaZyA + Es4+6ZEHeWFciczeToMR0mE5LpVxArTI9mH56MH4jz9ajLl1gdY5vEwZ8Pl7T3rlYB6Yse0kioY0WcYg + /U6A/IBpsWxMN5aIe//802UoH/LtgOcn4/k8OnMXqsj0SBcZcTAUrfO7nhD60KEFrZk3GRcVDoIrCgDd + h9LPCLxDxqECQPCtz/D4jHuViObjXrRuuycHfiay5yGJbfu4RDaN0K0E3B5hQQ8BnoaxForSmiG2J57w + TyDgkZNhCpWDg8MlgnopDZUoxlvTSx8UOfYbT6LVyhfUQg2FmSfl0INKJwiOccDOhacBA79fxuAeT/K5 + 7y3YjwkVAglXquiFMBIKm7r7hk+qYaAQlVYYaKAAvj17K4QV8lXLj/zWJl/jqRYFns/5LOZtrW6AIOG7 + Z3ZEOBpN926+W6grJLxnXIFle0/Jqr3H7T/USYVzhSlbquxxv25Ymq1QJMOfKJE6DXzFuQGCiJYVik6G + gJNKBivUSa8+kvBuftTiboSneQEYDSUie6asPlTnCzBAglH9La8g/7MhmP+CsnU540TgMcFtNJkKLe55 + 7ZaL51mz5e2PFcrqfTUiUW5NAL3GSbPnH/8JfRf3CfG+9MdNoHmu6jOOCfLhNpLMslwMuLKNvtL0UIe7 + nlogPD2A7Wbj6NxQIxrpFGPQ2pX3Ee+rM1FWukSH5ZkBiyPD+2nyyefW+MfuIR16C6X77DIC9aQCSNp/ + cMom6a1bzWYJvaE6Zly8ygExSXcjAT1icbos3l6l41h5iG4LyMzrYmDtE9TLlGWWmfWNeZuqmuWVDCia + S+Ue5eB41Xajsc68sshfbGvPdOmTPUUmbjijCuaVMD4pfXK+xRV6o9c3z7yXtLz0OkH/WUBa26vP01u0 + 7cG/P/7T5bbijH5t8XLkooK1w/kNB51HZrtn5qe/GUMB9yxjGPifxfII0vG388TAd5Ix78dLDqTp6Kxg + nIVcGicK5aF88F+kZ2mb0pxZ1rOD9HKRxoncuWYwwri881vLhYHWA/4QpNc5oD/9OnHMsJ3GF+4CLZjH + RmiZMsF4E6Py1fB28xMLhYHfmYbqeJp+5xDwV14tGHbSe6B4H9qjBGU8f/koi3zxT2UafNXox5dDffko + LM/rBaEPHVpA668SEH9zQgiA32nGQuCZutn5g0vfgRCgg43fJo57UrfCk6M/Ftn5BZFN/wDlh/v479Y9 + /gzaZ+hnz6EQyVoGmmwdAyAdQ0BPbuD/bZQpBweHS4YUjYE8VYVjct1wfZbY+UmRE9MwzunebIKCToC6 + +s1j08AzyAuCOAMvY9Bbgbxu7YEzmCwh+DG4FARqnVhVAA+fVAOosp+xstPqNxTAT/5qPbLBRBsEUoNQ + YMH0KIhRkKQSyLbHMwhkL6yHQDaW6UAopULmp3t2zDIPDyqbVD4h2L5+QpGcrm/yTjY0e2+4DwqErmQj + zdFQGqGcMo6DnixCxatdem1RJH1zZ8rWqjqx7RsUGlgPf2uK3gNUZHFN4PnWI/Xqgp+OddAZQPgb+MQ8 + qYmYgKb5ow31PnO/7Fmg5Utfu55xIk2PPn1k0qZ5+EyXVz5YJMv3N0Gwr7c+ZT+my3M+RMxIEI94pxvE + u+mxedJrAtpj5AsWtK1NeS4YXOmm8sixkD1DaPSqYbwCtJsJseeGvsP+AK2wXdXrAnX7h2eWmxIYlmcG + emQzeCgNfJNl2rbTGMqWnkWT98fCZYQqnaR5lH/P8TPejeMxltWoyHbpwPi6ysYJPaZ1FN4dXyDDnl4g + Es3M9xIYv1knKDXs2/R4ozFY+VTce3bFET0lRD2FaJQd48fqUAXfD/A6ajp4rgUgHvz1eXISdKyexUF6 + lxHaHz7vZ7yhwd9arPROF/zuPJZx9BRTfjEvsc8ZkFXHxNi58ncPl8ixRirhETMG+Gkq/1BefSWMKy1o + 9Z/SLcFynAt4J2kGFS6S6NZwBpWNRbypGytbeBdoKc27MpHDYzPRNjkz5bO/XYasjS/EO+D11QLS5MUZ + JyxwNt4FbT1USM8Nlh9549oR/nR+BMY3Bg9F2rg+u+Ko5svtbmFlygTpXvkE3h03lVvi4hb8FOVLj5dO + QPtLy5jQgL68f27NsQ6Xj0a2jzy7KsM44Y9jXdDpKI+6NhH60KEFuiKnDCAAOpwImAOPkPFdjUkgjJBM + xpaK7vGSTcs9OfprkX0PSMO2f5b6zf0luvk2SZXbloTUOgaiHC4MjKjBEkstsKMduWnKEQMbxstvk/im + mxWx8pvw/u1QlJCGGi/aK1QvK7TdxnGhCEvTwaGjKB+uQTSbN75dZAvGHQOZrrlDomV3i+z8kjA4rURr + lTdwFZRbuEzQOL/i93KATq4QCptiSW/otxdAyJmtkdJ1n2YHjAOB8pcpOPG+O7dS4HrL1xbJmSjyoHGC + fBgTrh2ZRgGavyPgwfwf94mkro56Y+drZPYePDowI69Q0CBBIwC9PCiE5M6R9/5wJZI2Jfdfn1mGZyVW + PrqB4j09GnE0o9NDIA9LMxPqjl0kf1p7GNMG5w1zaQ+OlCPMk4KrXaShpPeXlUdQB+6J74Bwcj6gnF8u + fAn1YR7MNzgtxATKzL4MQ/CdXbui54TRZUCP6kGBftGjCukRgOc/XbYTw93cac1wZle97wBY3ggFSyhJ + 35m3W3rQfT67UPp2ZGXvfOA4hJKmxgnQ4uvumyGVVB5Bix0R/tXDhv0Bug3eP94Y91738FxTasLyzED3 + rLnIf7Lc8q35cjKK72mcgHBv9HR++uss2CeqZKJtWYf3/Xi9rfIzqGNHaPgqGyfUOyV7oXjjpskTs7ag + yZCWb/Sm11hLPhcJnx+RBq1/UV7ddmOxJz7+y5Xqbq/bOKj0YzwYv6TySbdz0KjG9qGSOV3ufXETPkW/ + 4tsOjd9LADVAxemxFPG+9JcdKBvmEzWi8DrVxqny6iLpwyCILDf4K+NmLNlDL49M44Q/LtQw0dE+vniQ + HgKasvw7jkAZpfcm6ZxxYILFErb/kgNN5ukVYpxI32sQUVxzZ8lHf27GCX6viw5Mp0NgO12kcYKGo7x5 + 8qrxxbLuYC0+RxrsS8zv5t3XWdiYNVmBSHqFm4+Dhot0kSGsTJmgFyV5Rd+8GbLqUA1EDdI25Y1LUz4u + rtjit09rSLto2ynQLMZbR/g/5JX3fG+5elNxzkvTkTNOdAFwYsbgV8uWKh8txxnRKyJN+IwGW7vBk8pn + RfZ+TmTru6DIDNQTE2h44KkQUmanXsTX9ZMUj+/UmBF/iysUnzIoPjx9YeMgYSyJVDm+BVq2cvAYxBZP + CjvmclCLEuXg4HDpsQZjrOxWkU39MC55wgzGHz2XeKRr6S0Y20NE9t0rcnKlJ1yR1AkhokGldP9nwEde + pgj2THIy/NqcXZhQ7WhNnVgvQIGlsBQmPPEEAD0qi3n4fFhdwzmpa74QpKnU6+qZeO//4VIIpwt0n3HP + rA4IR9y2wS0oedw/j/ezCuXhwh3q7kujwTdm75CeY+eoQK7v5syxAGujGYfi/OmrcSK3SPLyt6MKmC+S + ZpRgWfU36mBCHSOM22pR3gtb1cDSIeXlPOg+coqs2A8BXPNgvv62mEQQlPDcCN6xaxc0TrD/MrfvZNvR + okoPuB/+g6VixqV6j0fxsT+jiXoI2FS8OyDgq3JoWyxo3DxY1+TRc8ebsAz5dUA4PR+4jSHbXO+pRPLU + iv21GLO+J0RomTKg73CcJegRZverD55Rmu4Q/WdDScyeIv/15zLbnsW28o0TaY/Uywi2qyqviUb11vjh + woMaU0YNp3oNKXMmrrJxQrdQjJ4nf3X/DNl6ggthSItAumZM6Cxagj9aDBLUETyC/X6iKeG95WEaZMn/ + /LgX2fQeY9ns6FClA/Jq1Kdb7lR5duUBJAFZGN9Hr4DxKd0O/jaq787dr3TeHWVWYzPoX8ubw/a243TV + OEHjSk6J/GTRISRh41T7FX2s84s+u/z0mQnSBmmVCOjsfGB/SZKGGd5HvATKr/QObKus1bhNSkuZXl9A + +n4snpO/oW///kfLhUGnjQ46wLvSYDtdnHFCt9zkzJXhTy5UxV/7klvlUY9LQ9+kD/I735CD36v3nJZe + oBHy77AyZULnepTvzifmSIRtwzRIGyjfpTJOaLtxew6vSHf9AfYb2q8D5aPR8O5vLxc7sjSzzXyjzHWM + 0IcOmaAQZwQUwFa5jnsSO+jJ4d9COXlMZPvHJbVphBkcaERYP0QS6wdLqmyYHgGZKrsFYIwI/39ey2+T + 5AY7qjNZyq0cwTGNBN/jtg//qEk+47GHPKVDPSwAxqQIU6gcHBwuCXTMlt6FcYexzeN31w/HOLxLUutw + r1uwRuD+ZpGtuD/6sEjdLigonAjBI4IJ5+UMCDI6+ScavJX7zsgN3JcMxZWrEqYEhE+qreALTt25ytPm + OfGnNUeRDfMyF00LNBgzIYorXLjyuNOTdSnvjQ9RGJsnPbLzWwljZ4Nu6WBAQ3oqIK9XjJ4ii3af1JUI + CjKzt1Vr9HkGUNP0INDqvnUIt7qCGJJmK3D1LneavOv7qyEfWZo6h/j3FEaoQFGZZp3qY+Ld8/RSW5VW + 75OQNC8At315jpxuivrpM08TapNpD4pzIxBw7NoFt3XwyEkqsj4tchVW+33UFOk9dqZM31ylLrUSa9C+ + TK9ccvz7Sto5gW/ols72bYZQTrr7/G/WSU/1dKCAH16ujoIrx2xjDYoJ+u07fo7sPgVaUM+djvAnrhTi + irKp0oZ7jke6gXds2xTbrFieWbBHjAZJ80gHgv6lUT7OjWAcB8aY8sNn5Ea2ySgG7D0/f7gWtnWQ7j7w + /SVqMGWfKR+Jd2z8nhd+ndhOamimUop+Yl+v33fSlPlsbmUzo7MGaWWclTHgg0E57y3QcXJDbr6sOlyH + KpvhuONbmzoDoyPbbhT3/rLuIMpEI/JsM574PFrHMI0rOagHA3fqO8Uy6vmtSCboUyAV8+mcnnqBQns5 + QbpC/n5eLAf7lXWyxQ22Id/hPOePnwzYiUuBoQp9yfmRbYFvK2pqvT4T/K1hoCGdv8jH2B7BfW6hejqS + Rwz/znJ0P8aJtiXpgNeOgGW5SOOEyguz5d4/btAtHZoG8k2PWz/NiwbmB00rbkYftuGOilrpMb5jvNWC + ZM+W//ndGiTnl4+LJJr+JShf0HcoH8cMFyj2Hmvwet2H8mncrPByBeA8fNd3VkmcW3lAuy3t1tIf1ytC + Hzq0gB0cDBh13+aJGkd+KPLSJ4WrqNEtgyVajmvZAImX91NlJrmRsSOo3NDgQAMCFBc9bYPbNYaKbBym + HhSJUjxX7wcqOj40ECbf76+GCqYdA/RkDo0zYdA4FNwC0kaZuuLQcp0DYd9kgB4klxNhebZCWJkzEfaN + Q5cBx2C8jGOQnhMc1zQW2vhr2oTfNFhs5JgeJJHSOyW2+QMiR38u0nzUnyhe5gBfjKhQ2+Q1YIJ92+OL + hcfN6VndHdjT3f08bqe8Pl6wRbifmMKL5Zk5EZthggLl6peOQNiisYHH7vFYxvPn742GcKZCQIle3/5w + kdTHU5omhWyG0njNuCLpmWUnenijS0xgh+LYkYBVNE70ypkkr7tvrpyuaVDlouUYQNQnEVP3fxOuI96h + 6ibvr/JQHrpzqzty5/Afv38JTcR2s33J2mZou/T9eRAI7YEw1uU8J0DDqtjoPU8mAE1mT1fDxE1Plwr3 + H2vbaH+Kx4BpKtgDHdrWoXRmp3kxnQTGUP7a3Xq8rRoo2pbnAtGdcWBy56hySYWs74QS2XUSbaUBWDsg + XCcZ2Jf3vtKWTHhPzdqptK8rriF5tkLedPTvbFm89ZgZ/JCvXTvYPp2Elj1el6b1evTT4MeKpNu4uWrA + DC1zJq72to6sqdIjr0AenbpHgxUy6KHVxTytWud1EaASjmt6rHHVGmVuwH3B6t3Gg7hNji7wRB5+czU5 + d5704VGio2jQpWdOkfA46ZNKzwbbT++ne7mAuYBlDwxnJXuq/RXxYpuD2M6BYYVzA551H8c6YFzgvY88 + s1aNxto3uu3OjwGDNrB+vszgijd1CwK/WZbGWNI7UVvvHT5+0ltxoFG3nsx/6aSUbK1WzN12PI2ZL1XL + 0h1VsnDHSVmLupcfOC2bj8Rl77Emb93BY9L3fvBq3xARXElX6Xvw3hvYNqOLZfDTKzFVBH3GrRV+Gc8L + 0vjFGSdUAc8plh/MA33jW/JTppPeuumnedFAHXS8YNzb4oB4R042et0noHw0/IWVKQPqLQkZ5Vtzd4ot + hiAdpKU04m+J6hx84wTnDy1f0quqjXo976dxIrxMmSCt3/O9NRKPNeL7iO/1Yv0R8LzrFaEPryeYUBeg + 5XxgtTDjnm5OZJJqtfeJixOs7asD8ZMomAaep3Q/X8tvHWyRGk9OLvLi+78s8S3/5Lt0M4I/cZGeC61i + IlABboMMgwVP7lBshLKtgMLEMkBh0ve45WPdEKQ12BSldNrMhwaT2yRWdrue7JHccKemYWUA1vXTbSeM + a6HpMk9Nh0C6G4YjHzOGtBhEzGuDW1WIyNo7JLL6Tmlaeac0Lh8o9UsGS8OioVI3f7icmTdMaucOlZqS + IXJ6FjFUThUNk9MzR8ipGcPlZOEIqZ4xVKqAyhmDpKJwoI/+iqMz+kvV1OHnROU0fNsKQ1rhBNIjTiL9 + EzNxLRokp4oHy8lZhppZdytq56C8JUNR5iFStwD1WAgs6i+RpUMlumyIxJYPlviqwZJYgz5ZZ+3ANott + 7J9uC3X51/aix0sAv/20ba1Pre3RR2vR7hsGa7tq22u/gK50RZ7HxQL8rc8sP4L5EMzT3rU+0f7ZiHKW + taB1INWAhlpAOgrSDf1f07c8DH4daHhTBM+7JtSzgluu1o3AFc/KbpYo+ju5/XMih37oCz6cZMmDcE/+ + o7yKQgDg8xpbFcFvvQ/+vwST8xWA8kkoHRQQxzy/VgM56YkdHXH7Pg965M2QYU/RbRF5EHTP5B5hCuYA + 21YFBSg73190DMLyTOnDlT0oRB3Z1mEuygBXlsfOk8/+fImuhGudMHfEEynvvd9eincgmOeWQBCfpgKL + rjZ1YOVVXd+Rdp/xxfLi2r2adiAMmxBhQjBBYaKwvFJ60fBB4bEjykv2XF8B5fsF0geKAhX+PvdOxrOZ + MmdNuVDRsD5C22nMJFNIOiK8BAJ6UN6ut62jRLf6cGtPzywos1Tyxy3E8/nyvelrkWVGWS4CQfsGSiJd + 6ndWn/HodhxangsF6MhiBZgxre/4Itl/PAikGLTZOZAItn/gXXqCYUx84k877HjG7I6UcY68Ytx0OXKq + Gf3abLQf8De9XmZwFR9X1iFQTh56cbW2R0eUk6tunGCgSfCy2Wt36PahoC94b+XoHHSs8B5901I3AIrh + kyU8SjmkTBnoNdpORiJPfNc3iuQg5WfQcjLS6PE40WgscVkRAx01g6c1R2JeA9qk8KVGeX3WH9FuoE09 + XSS83AFufnKRRKADUEdQj4FE3DzZtE064jlh/Utemm5LncsD4waNcWaIM35rdMR8+F1NTLxVe6rlp/Nf + kqy/bJB//MlKufWJBfLaB2dh3HTA+AdwriDoBchjj7mVo/f4EkXY+5lQ5ZvbdnAd/vQyifnH/F4Y2AYX + a5xAP2XNkJJtlWa8ZNvgGnivtM7nYtG6fIdON3uMcRFanrYg78yZKcVlB3T8USajTml93XnjhNELEHhj + YD47Vh/1Xk3jSUeME2OKhZ6WCRq5gvTStHd9I/Th9YrAbdCME9ZRapjglYSlzIbMoeUbDgI7j9lWEnQ1 + IXrIk+NTPNn/NYlt/0dJbBkhSSj5UnoTFBIqakMkUT5IopsylbazIG2ECPmPCFbnoYCm1t+haFFQAXpb + qMdFYDQA/ICZugWEim7w7kZ8W4Zvy80IocolTxhQl3QaG4ghphBDiVZsGKrgtpLEOijiawdL0yoo5sv7 + yZmld0jNggFyeh6U+pKBcnw2FP2iwXKscJBUFgySo1MGybH8d0rV5LulKn+EVE4eCgyWyvxBUjG5v1Tk + 3ymH8A5xeOpgOTLNcHjqADzrLwen3CFVL9xleBFpZODYxHsUR6cMPSc0v0wg76opg9M4hHK1YJiPIWlU + oGwV+YORFoE084f7uEtxeOqgdLmPFuB/HxXThylq0R5niodI7ezBUlcyWOrnDZB6tFnDwv7SuAjXZf2k + cXl/aV45QKJrBkh8HVBqxgVtf98wkDY2KTKMGzQQse+Cfud2At3egys9Z9L0w2dt6IEow3eBcSSgpQCl + 7PsWg1Ng4EgbS/hdkG/6G58GnXFCwS1b3NphY4xtfZvENtwszeiX6Ob3iuz4P5GaGeAvDeAz3Fve6POl + gAdReG7yJzv+Bi8Cr6J1viPK4zUDCLMUwBj40Rs1zVbaLsHKL1d2Xn/fbNl3IlCoCH/yBR+n4Md24n7V + //fLUrw/U3rkUuhnTIiQ9NoB7+pqEgSp3LnyvZJdku4LKPFUaEb9eRP+R33GzpUbGMAL3/UYjbppPmFp + tkD3aevK1Az56tR1mjbLbYpSi0Chp72g3783Z0daIOqQ8pI7Rz05uuuWmBm2Woi60+X6zY/Mkao6WwnU + /NSwwzxpuLfjFVvaNBwBndq1KwbEhFIP4Vm9J0ZNUfd1Kous/5zt1cgyoywXgXT7UqFTD6S4V9UQ8/76 + K4tMcQgr04Wgs8YJKH7p9mW/QKn6wM82os+mapqheWaA7fa2r86X082kvYjW0YwTSE+vlxlQJNQggntT + LpLeMwt3oV0CA2B4udO42sYJoDfeLdt/CklYGibnIs1L0H7p+iQzTg8iUlFvQgfGj/KBnHmozwLpO2Ge + DHx6hQz9RokM+cZc6f+tJTLwqYWXF19fgvyWyD3fnCvv+HqR3PYEykKj9LjF2sdhZc7Emx+dJafqWW8/ + VkOmcaJD7cv5OoZ3feMioB4YuJqxA+CVQHqN0YRXVlEv319ySD79u3J5y2MlZoTI8ufLHG7DADheO2Lc + V++H1kaMwFjREfq+FowTPNZ39cGaEOOE3Xcerct3IcYJ7YOxM2XV3pOYavg9F4wC5b/z5UvTmTNOtEPo + w+sR3GsVukeMXhLsfIDESXCPNFfiNIia2PFfSTDjZEOpJ0efFNn+QUmUD5FIGZQvjfHAVexboXhA2dPY + EFTmB0iCgfJCFJZWOJ9xIvS/DOUyUAJVIaQi6iuNVEqByGYoQZv6SaT8TolsvENiZfSEQBqBksv3oVSm + 1g2W+OpB0rxsoDQsGqTeAWfmD5AzM4ZIzfRBcmJaf6mecqdUTrlDUTH1Dijnd5rCPnmIwowPw6V68gg5 + Nmm4VE0cJoenDDdMG2GYerccnNaCqvxhisBwQUOAYio9G6DkTx2c9nLgPZ8bhskRoOV3OA7hG+Iwvj9c + gGsbHJk6QsH0gm8qmefUgYqjUwcYptDYwrKhTPnDpXLSXQqme4Rpox2sPMAUpAdUAkcnDjb4bXQYdSRo + +OD7VROtrY6hjY4hjWMFQOEQqZ4xWKqLh0pDyUCpnztIGhegb5YMkqYVA6R5Nfp1La7c1oP+i9GAQUMG + A6SW9ce9edNQEebWoHTsETVC0IjAPieoLBudGF3xCgQGBsA8NzLRYpxQA4XCp0s1mt3ug+OBMVT8/7oo + bLxZH5ixkOOU/92KZ29BH/STBPokumuMJM+Av/i8iPyGQhDvOenFU81eTBpUYbRJFJOgL+Rcy9BJUPev + m0CxrybqvfY+buuwvZphE+oFgW6fo4ulePMJC4qJPAI+bjDBoxIT+t88iPcZQ4IrZlwV7cjkrgog3+VW + kGJZtq9OdC5B2hQUKLD+eTVXEJFmTom5xyNtnpOuwQZD0sxE2p0YCuKHfzA37QFiXjQZK0P+Cu9//4qr + umw3CnYdUF5QR3VjhhBFQUr38KIe3cfPk0/8Yq0aQ1Q507kRbaV5ol6gOa3jeRC8Y9euZ5wgTdjedfQH + 3cPz5gi33Pzd/TOlojmjHBeJzD6wPoqpS/Nd31vt73cOL1eH0VnjBGjHjFikHfGi0bg34BuL0BZ2rGRo + nhlg2737x2t8xaP1qQjBeL68wLjy5ULzsk16xdtPq1DfIePPVTdOzNAjL4+T1vxxbHyjo/mfB9omQLzF + c0LLifnps79dF1KeNsiZBp5LL5p8i+WgSjZpreV0j8uKbAYOnqt92W3Ui8gf5QDvIy/s+6XJrcsagleO + m65bINim2q9JC3So9x2hz2TEi6INOfcFxg3tJ3oZ0WhBHSMmXvWpiDdx7VH56LOr5RXcVsJ2Qnv1pGGH + R1WT5+fOxTPwF85but3h/PNLKAKDRRujRRh0DFxF4wQNKK+ZUCx7a21s2VYO2/p4LRgnyP9vQH/tPU0D + FL9nmTB/qu7ojBOXE6EPry+gI8hY/AkoAIU/FcDIKPSZHU9jwhmJyh8Mzfs8qfq9l9z+KT0ykCvbidLh + UC6olL1NEuveBSVjhCr8ui2CcQzokq+KCI0W7RWW8yIwWBDBanRaEWwDekMESBssMtPDb00H9+uGSGrV + EIktHSZN8wZLHbcuzBwqxwupFA+WKjUC0CAAxR/K8+FJNDwMM0yCop1/F5Tuu328Q1GF98yoQKXdFPfg + vcqp98ix/H5SPaW/VE0ZqKAngnkh+IaGgndIZcG7pbLwvVJV+H6pmvkhOVb8UTkx+1Nycu5n5NiiL0n1 + 4nvlxJJsObE8V06vGie1q++TM2selLq1D0nN+q+eE/XrnsB7X5Uza78itWu+jO8fkZMrHkJaD8rxZQ9I + 7eLPS82iz0nNgv9Gfp+W47M/Icdm/ptUFH5Qjk7/Fzky/T1ypPDdchTlPDrtLvOKoJFkSj8fA1Df/uYJ + MnmgHJs8SKonDVacmDhYjTE0ygRGkMCAwfofyUdb+B4Y9MZgmxsCbxJcfa8O/k9jB40Yx6cMlRNo61N4 + t7qwv5yY2V9OFQ+U2pJBUjdviDQuHCqRJSMktgxAv5NulT65PafsDuFRswHSdEZaYTyTIKZJYGSgp4XC + fyegqbPRWjtk/t/1oAYcnuRRzpM7blMPpHQAzXUY1wA9k+Joq1T5O0UOPClSD55D3gQelN53zclOJzwT + YFXI4THFwf/XKJSHopyc+KmAUPn++M/X2nF96jUQPql2FCrwjl0oT8/eowGzKPAxHwqCqoT6+S/dcxpC + Hr6hOy8VpzwKRudX7jS4IcuJ8v71Q7OhBEC59QV1Cgq87qlu8l41gYIeFGkKXLqdAwIwvSlC0mwFPZ4U + bZE7R9720Ew50YA6UJCgQMI8NB8ipnEuBnyNWwa4ekZjQweUl7HTpQcEcQopPVTAnYrnqA+ePbvogBp0 + 9Fz2QEDzBT5V1DLLcBZoO6SvXc840XKkG/pcFUqjgQ//eJkFwuwkVKFBmdm+gXGC5f+359bb1omQMl0Q + LqFxgmWsb4p7f/0A07U0Q/PMAI2U//HbMiTDtKh4tNCSeVBcZgQKDvNSJLyNVU3arx0av1fZOEH+xKMC + jdZoVGR9rCwdGb/nRZBGnJ7Ddk/vYRp9P/bsitAytULObA3a2Xs0aDXwLGLd1KjMmB6s4+WDGpnoIZA9 + VXqBthkfwLZiFcsrOGbDypwBjrENB05lGKQ5vzDoMsZiB9qXPDvNp/C+6h36Heg72ujtrE94T8x+SW56 + Yr6ORcbtYKwTNTzSEMF60LgMkM+ooZlxbsC/dQ4NKXMmMr0kAoS9dzZcdeME8n37V+bKqZifltK1H4ch + GLudRuvyXYhxgh6Sb3hwtpUPfR2MPw0BoOkGeVwcjOYAZ5xoh9CH1xMscnsGkWhHEwFz4WokVyMS6ZVK + idZ5cqLYSxx8QKTs3ZIouwuKHA0EULZofFhLhQ5KR9lwKHP4vdHfKlHO4z2HSDzzSMEQheWcaKUEAukA + mMgjUCTT79A4gXuCsQzoQbF+mCRWD5PoiqHSvGywNM29S+pmQZktNE8AKr6HJw2XQ5PvAd4JBdiU5COT + BqaV6+OTB8tJH/vxzYFp+H+6eQgQ9Jaggs2YDgcL3ilHZv6DVM75kBxb+Gk5seRzcmrlGDmz7n5p2PCo + nHjpF3J612+kds/z0rC/QCKH50mscpWXPLYRbbzFi9Tt9mIN+71k0xEvFTnmpWKnMRGi/RNQvMgINagM + B7wN+sy+JTjIzgXtzzBoWoSfNvPhkUuJRss/Vgs6qPGkodqTugpPag96iVMvebHjm7zmqtVeY8Uyr/HI + IknsnS3RXTOk6aUXpX7rb6Rm04/k1MZvSvX6R+XY2vvl9NIvysmF/ytVcz4hlUUflKOF75XK6XepJ8jR + qf3k6PRh5tVBDxSgcsowOTblLt0GQ48KGjToeXKIbY3/DuG/A1MN+2kkmjRMDUIBAgNHsFWmumC4Gp9O + zBwkp2YPkJq5/eTMov7SsJReGIMkvmq40ktKj6O1bT1pzxs1LvBKOiStBc+I2yVVyq1M5mFhBrRgaxAU + 7zQyaLkrYt3daFffmEmvFvWu4nO08zq0/Wa2G/5jXAr1gkKbbv1HkYrnRCK1ukqqkyZ5VpxGCY4JE4JN + KbgOgPJqHfzVp9+vOqDKsa3ih0+qHYWeNgDh6f89t9Y8J5JmCLFxzd8ABOsfzt+L9yEA0hgw2k5V6Ihy + b8IZDRoz5d+eXYksmKZ5MQSxGShwDv/WAhUY1dAwloaKOR1Tbggq8mNLVABcuecE2BLmLOVRPmgwT0W8 + nSebPR71yPpalPnzl5+raz1UiC2SXlyBo3ECCkPvnGmypQLURe8bFVwosASwfHlKRLoMZ0H6Xb120YCY + 3MpDuho7F0pPofSBAvBoAaP8B3lePIJ2TdfVXzn8/J82+t5HIWW6EKCsndvW0do4cboxaQFb1Qh4fgGf + yt/Iv2wFuZMOje61zui3gLYuKwKDiMbL4O+Ed6i22eOpJbo1JaTMrXCVjRNUYj//500QZy0txtrR/Bm4 + MpOHXCwSlJ9xTfM6Xk05/KcfLw8tUya6ZYP3jJwuvahog85s2xN4WB7rNxO0h/F9GaF0SC85jEt68qhH + W5YZa9uWNQw0/izcWSkti5jG+9VQ2IH2tRV+9LEeZYp73eIR8ehV9f3FlfKWJ+ZIr3HkH6A1lhPgPECY + MR3lJS3QGy9nhpaHxk+u2He0Dp3B1TZO0Cgz9FtLpMmnbwXKYDTu02an0bp8F+Q5kV2kMUAsQHZgtEK5 + /DmqfV4XBq0n6+6ME+0Q+vB6QiBwpZ+RaNKEDkauli6eAwxEq73m6mle0+4vSLL8LpG1UCKoSEB5UDd2 + xmkIVp7pKk+vBhoq1gBrqWAwXgMj8/sKnipxvpJyNrQzOLQFt4bQRZ7eEXhHlUTfmwL5x1YOk8iyYdKw + aLDUlAyS40UDpbJggByePEAOTeovByfdpSvvtmIfbFdgIEmDKsXToNQW4D1Ald5pd6nR4dCMd8vpWZ+U + mnn/IzVLx8hpeh6U/1Bqdv1RGg7PkObqhV7szGEv2XjMFPlkk1oOOVFy8jLrZmuY2yGvZkFu59Hi9xct + 83E1LPFZa/C7ANqf5wLeb5W+5t8CK6flR1gMkky0ztvoBqBQo1b0wH28ZaWWIJNi+txfaMH5QF/xM57E + jnvJuoNeY/Vmr/bwWkns+otEtv9W6jf9WGrXf11q1twnx5ffK1WLPyNH5/+7nJx+lxxH/xybRmMQjUI0 + ENEjg94VA6Ui/51CD5bA+4IeGdyWUjVtgBwrGNgSo4NbRybh+0lDzKAx8W45iufcrsL4IIwTcqJ4kNJQ + /cIh0rRkiNJVYvUQSa4ZKql1oGv1GBoG+qNRjnROhZo0noFMetax08XB7TNrcNWjRcFDdMtNcGww+Mn6 + t0u0rL/EN3Fc34737pD4uhES3fR+kR0fEqmZhbF1WOmMrqEcN7Z6WmcRq69x6EoChPYYx6I/Qe45fsaj + 62q37CmhE+qFoBuDW44skEFPLJR6zSNY4cP4pPCiz8T7zG/LIOhxv/EM6QXlXOMEdECBVuFMFdDp8r05 + 21F8G/8qyCTA68ijMMa/9KdSYWR6NWTkUpmGsteB00BUwGQeGthupjy7aB/yYPnZ1z5vpLCD+uRvPqGC + qQqrHXDJVUDBMiGWbtQQcJEXV9ze953FtoWEHjjke5qH8a5EoJB0ANbWwbUrGidmip7mkgU6zIUigd80 + GvxqGb1SfIWks4BCE5yZb/0U9/ImlRsthJXpQnAJjBPWvjZXnmhIejfSLZ3KJ9MNyzMDVK7HTd6GIeob + E0GTKkiDBgPauhJQ7yHlreLVNka81zy8wKe78HKncbW3dWRNlcdn7wOZk88afWh/XCqvOt8owXLqFekz + Dy7kve97y8LLlAENKEzDHQ2ko+lBMV36Zk+TPlkF0pP8krzycoLbSrIm6RHWPcDze4POefSzeiZ0ULkr + 2HwI7Rv06wWOacxHjHek90n2SdJbdrBRPvDdxTYX+cYIxgLS+EPqbYS5IJfG7dnq9cZTebj9ifRIg77O + eVr+89PHWb0lrpNtHRwD7/3hSijXGFvK+5BG3DcQqe6Wmc/FonX5LtRzYti3l0jclzU0DZYzTS+dg405 + wBkn2iH04fUEU3b9e7+TjRi5Sl4P4Pmpci9+6JsiO/9RFQdVJKj8b75VYhtocKBiAQUDyhaP50ymPSOg + jGn8BhoWcK9bK7iajGuwvaOtstIWmUYJXZnOeE6U2Wo0lcPYSlMaGQvi5Kz+Uj3zDlUsaXQ4kj9QDk8m + cD/Z4h5UTXuHGiOqpg3SLRtUbKnAHs6/RyqmvVeqCv5Rji/4kpxelid1pd+Qhu2/kMb906SpcrkXr93m + pZoOeDyChmfec/AGk7dOgtq2uCfjJeGDeeg7CjIPgzHzAMH/bH8fTDNAum8CtHk3Ay1GDGMIZ0MmLYQi + M/+2AIMJjCxnQ2CkSJeVdcB3QRoMpkrEJAqhK+oz2Mx6+G3p52ffAzGkGcVEEKn1Eg3VXuz0Tq+5apXX + dHCmNOz+o5zZ9ozUbvqO1KwZLadWfEmq5n9ajs76Vzlc+D7dRqIxMvL7y4Gp9wCM+TFMjRpqoJoyxI/z + MVzpxIwaQ9XjwmhogNITUTHtTtBYPzk2o7+cKB4gp+cM1hNLGhYOl8bFw/R0kuRaxizhmPFpmOOhHPRP + BPTcVbGZW2Po9cTfbCOOd26ZYRwKPFcjJp/dJlHwjwj5SRl/gw+V/q2eopPaP1JSp5Z48ai5dKvRjPSi + NMTrtQuld/CGOMqrAaNw3wzh4h9+vALC0SVwS8+bJT1G5curx8+XNYebkWWgjGI8Kl8S70xMvNu+scQP + hElhDxO7KmQdE45oPOC+19IDx6HQ25jVPCCQxP19w79YfkCFX/1m7BRTzilstkuvDVQghaA51lbCvvD7 + DUguaD+/f/2+fnjGThNQc/398B0QLrnS1g1tZMrBdAjBpox+d94hJN1kRtR0foYYeE8QtO18CL61axc0 + TkCJpHEiEOJZbx4rW1B+TMyolFGWi0UyaoZJH6TtR6ZtQf4U8EPKdCHorHGC41rvTWGork9AcAZNU+nq + gHGCBpYHJr8Emm9RDnRRIuEr2ZcZzEMXOQjMu6xDc6Tee+NjSzvm2XUNGCd+tOSwbWnz06HhgIshVo5O + grzbv7f+IF+Nec3gee/53srwMmViNMZEHreiLdDxofxuLJ5ze8I4xvGB0n0ZQaMvPZt60itBt8OVWLlo + MBm3qHVZw4DyP79hr+iWSqV1ynt+23QALYZeW8j6/oK9ot5veYswX0yT3jR8ZzEvlC2X7UTPjkKd0/pk + T8Qz/MdtgqqIcj6h1xwN2b4XSFiZM5C5neOshopz4OobJ2bKB366GvTNfH1dDnxVx1lgvO80WpfvQmNO + vPuHyzHNoHygCxsr5AXBeOkcrL6Az5s4nznjhCH04fUEOzrUvw+URjLYRL0Xaar2ZG+eRLd8RAMLynoo + DTQqQJGgQSJGxYGxIwLDAxULul/r6QhUNm6WOJSJeBlPV6DBgoEwecKFbeno8LYOKnTclkHwHvkk190p + ibV3qBLIozarZw6AotgfCuMgNT4cmTwCuDvtzs94BNwS0IIhiorp75Zjcz4kJ5d+QU6XPia1O38n9UcX + Sbx2NxTgk/6qPgY520Xbxr9m/m4FErkN5mBAB2A7tyX6tv+l//fTD4wM6f8y8jZlJgMcoMqQgjIAmf+H + IDNfQ5CfIahHS5qt31e3RkIto4AO8uAbIMiL7/polX6b/4N0uW/R9i4yCjtpNLNcLe9lIp0H02PbYMIk + M9T/qCTRe6VuvyfHNnixfQukYUehNGz8ppxZ+4icXDZSKud/So4W/aMcnv4O9aTRuB9+AFKjl4B2LJgn + wdgh6ZgYpDs/Jga/DYKEcosKA3iems1jVgdL4+LBElk+SKIrQMth9N6FEAn4SOBNxdgvBAOTkoeoV8UQ + SZCnaIBa8JhSHg08QKL8zdN0wAcSNFIeelCkcZv2vbrcpwWfaxdKm4mI8gBzfbSTRx4q2qOCfdiEekGA + 8NmXR2VmlchvlxyQSMJcjmO+RwB5/tbKkxBEIQhlv6Dv0zDRnYJyR4QjKPQU6G752hKJYbxS8Gf5VQhR + ZcTG+KJ9DdJHFXIIc7mTdaXLhMk26bUDBUa+C2EdAvu7vrVQmuKcq1r4EdOPgvd8/BdrxBs5Sd8z48T5 + y08PEdtmAmUnZxoE3jlqRFlRgZRTtVqPgIckYj6/Yp6AbYls+R2GgC/ZtQsaJ2j0yZ6qBgr2N/uFK7ML + 99Yju4xyXDTYJ3YcLtuYfUVvpC9P36IKSmiZLgSg7c4aJ4xOTBk+Vhf3Xn0/yzUDbdImrzCAhh+YtBVj + y5RgGl01iC3qqNfMvC4DSAtBENpEwjwpY8213pseX3ZdGCfoAfCLFUfVS4flZzpqnEBZ1Ojip33xiGv7 + BLTHdAluV/j7H3QkICZ48+h86ZGHttQTXIyfqpKMvudWuMsJL2uuHr3sjULe48jzue1qsvTNzrf/w8qc + idFz5Q/rdqObWHf2jymhHTXe2viNeuAG3qMzd2m+dkIT0s5leaaBP9Ngw2fTNN6EbidimfMWmzFa5xK8 + j/HUXU9dKlSDS4diznTUw+4suNrGCdLJB5/lkcxcAAxiTaD9fZpsnc/FonX5LsQ4QRp674+XI4mIlkvH + HtMDvQTpdQZaR6TrjBPtEfrwWoK6A6aafeAZ4Vs51TuCTAT3nOhIOIwyLLUrPdmTY4aIEIWiNei54CtZ + XAHV7RU0VHA1FOB/aqgAAs8H/tZAlkMlqtH68X65v3q6fogk1w+TeNlgSWy2oyKptHDlObZigDTM7yc1 + swbJCcZ0ePEeqZx0jxx9cbi541OJnGrBJHWle+oIOfECFMNJdOOHEjn7n+XY8i9Jbfl3Jbq/UKRqrReN + NXrxBAO42eBWwoSCf+msjg7XNPxJVccEJ5bYaS/WsNerO7neO1m1RKK7fif1W34iJ9c8KlULvyhHi/9N + KgreJ1VT75LqfMbFsJNKuP0niH1xaCrupw2RQ9MZfyQwcIBGJ98lFRNH2Ekmk4fbCSyFw+X4zGFquDgz + f5A0LR4o8ZUDJbUG4wNKOY15qrSXYxy0Oi6VY8kPyMmTLRgPQ+8H4ztuKblN4l3AM4OGTp78wzZIld4i + qU0fEjn0G7C2KjtOyw8Uxbg5Kjhyb2ss4iUYJVzHu/1/1UC6A4/WLSgpKD2gxziU761HT0NIy5feFMAp + jI1dhOs06Tl6iu1TprKuLq7hk26A3viWyhWNAZ/+42ZkyTagEZH5UmGKe9+csw8KI5VzRmlHflxFC7wP + QtLMBLeecHV31B9LoQD4AocK6DFrf+RB4b2+Wby3PMygZUgTAmZfFerOX/5uWVDkGZuCkdeBV6NcZZWo + hs5XFASTmk9VYxMEEgizWVD6xk6X3iPzUYfzr5wxBoa6DXNPMyPAj1skwx7Lh5DJOrD8nUMg5ARCT5cz + TqBcGpSVBq9s0tVMuQH9s/NoLZo3oxwXC7+PWrVzMuY9PGN3h+j3vOiscYLvaBnNsN7UFPFecz9XgXmE + bUcUo2K5f+ImsAmkETODRGCIsX6+vGA+qvBATjTFB/k3J7w3fYUBCsPK2wZX2ThBGpi0gQzD0rG86Vl3 + aeQ7pkfDEfuYxllLP6YLRx/80ZrQMmWCyhFPU+JJNr1ojB45WY2xOmbA71j+axn0tHhuxXGxmCTmwaT0 + DlmK9MJjvrVNdHEo4jXinpCEnazF2Gmk7QnTdqEdOAdh3qFhBnNDz+xJcsPoP+vqu3lOYL5AO5G/q9Ei + d5EZJshLNZYR+D0NGwDjCPUYNVP6gt+88f5ZMuhr8+WDP14hn/39RsnL3y6PzNwjjxXvl68V7ZavFu+V + h2fslZzJ2+Tzv18n//7zVfLBX6yXYd9eJr0DLxb2FcsFfmZXegVw6yP76SoaJ1D3f0F5A09RpWvcd8Rw + 3nG0Lt+FGCeIf/jRapSP5QnG8qVT/jUd1t0ZJ9oh9OG1BDYymYASlq5wm+tz+jc6li6Duvf/1GZP9j2g + UfF54kZsEw0P7RWC1qCSRAMEPSj831SeyqAkcc+9bruAsrWe+8d9w4Vu88C7gTJVOlhSa6Fo0AuDbttQ + xOLr+knjijukYfEAqSkZJhWFdL+/R/ZB2ds/rb8cmjZAg1DyOE6eiMEjJumWv3/KMDk4/R+let5npG7F + aDmx67dy5tAMSZzc4kmEcR+CNoGgAMGZxhgzTGCC0cHjD3C2j8PLHrqyyysZnDI5XvEsRUtvYwuT0v84 + wZ7yUnV7veZja7y6Iwsluu330lj2I6lZ+bBUL/isHCv6Vzk27T1SPfluOf6CHQ9LY8XBKYPk4NSBSreH + CwYC/UG/A6TyxcFqWOOJL/S8ODh5sAZYPTRjsBwpHiynZw2RM3MHS+OiQRJZSsPFIEmtGYIxg3FW1g9j + 6R7hFqr4lgGS3OobB9fSowDjajVjXnCMvYxRNtS2j2k8D/KhWyVRPlCSuz8nUvEbCPIc1yYsNqIPI/4Y + Vz5wLYxzpbeEL9RFdHWetFgbF2/EdxarUkdDhLqojp6mq5XdVYjj/trzK/cUrFS4yyqS4d9eZIGzkKcJ + GpgLoDDokXd046UbPF1mOakj7fSK1DlAQZqrVD9bdsSME6yP38bMgytpHEO8/9iv10hPCJH8hnurO+Q5 + MQpCJsszFvngu56jpsvvVlYJhV9bOTZBYumeSl2R19W20VPVHbgjxg+uYFNJ5BGnqijklEjexFJUBfSh + dekcAv5h165pnNA94BnGib55hbKnyo4gb1eeCwXpGddW7XwNGSfYjkZHaFeMtUgk5v3do4tAz7NVoQnN + sxWKJPsvm5Qera5Jja+R3mqRkdflAPPRcQZZUekE9FJTF/de+xCNA+fnDy934wShiiDayZRxwnjex3++ + PrRMrQA+1WMcj8OcIb3GFsvQpxbJzV9fIm95fInc/I3lcus3Fl3TuOuxGTJtzV40L2XoZMvpWexrVUh5 + xDd/A76By/gN5mU1kie8Hyw4IL1HTdH5rMeoyel5R/k+DeX0mhgFPsLtHf4WDgYQ5bYPthsNCD2z8uWG + 7Ily+2PF8h/PrZKnZu2UgvLjsulojRyojXgN6TkP+TKYvG6DQJlZbpRVr1oHbtmzU8CO1DZ5N4xra6Rv + MU7wuTNOnB/OOHF1EPrwWkIQyIiERQHYrJVGwPydEEy0tZs92f+YyLZ71EMhsfZOSW14OxQdej6EKASt + QMWAVyoGUIjWQzHKQHI9A1binXL8R4OFb6jQVV+u7q6DssXtGpsHq5LVtGKAHvl4ctpwOTnxHVDsBmvg + ysoX78TvAXJ68lA57rvP01BxpGC4HJ3xfqla+H9yeuN3JXJoth01yOPsVCigkgnmQwLmoMUz7u9me2hb + kFkpSJzB4HHoKrCgnsm0GxyZfADSi97jOf+3o3W5xaQlZkh6suX7pLdovSdndnuNlYu8WsYnWfe01K18 + RE4t/KJUzfqoVEx/j1TmWwDO6ol3ycGigXKwcIgcLLCTRnQr0mR6BN0l1bo1CdCtIgPVQ4OnwVRMHyrV + xUPlVMkwaV58p0SWD5Do2tslDuU8sZ7jaLDEeSrOlrZj9eUH5SUbGfeGvIWxKm4WWQvetYb3wyS5a7TI + 6VXWN+wj7W/rU/t9daHCBGMz8DeEI7oek56IBwu222pSHhRQP1ijNxZKEj0nsvPx3/mFF3oP2GkUc+Q1 + 46fLnhoKY37wUAjRDdGkN/jrEI6hRFhwtpm2/YLbOjSwWEZaYUDadMXdUAURVOtgQr9N7gyISYEP98jz + +0sOqDBJrwwaA6j4haaZAQpfQWBDFVqzp8v//bnM32PLPMCzoTj9eNEuCKsoL8+65x5qGloo2LZJrz1Q + b00X99zPjGclO08g6UszF1g7BNeua5ygey+Do9E4ceOEIjlwwj9utrPwx3CrdsY4umaME5wngv6AHMLx + Peyp5RpPQI89DMuzFQrl48+tg17n183vLzNOXH55xeY/jjH/BADUYd+JiPfK8SgbV/pDy5yBl7txQumP + dfPlSVwTkDnZR1yl1zKAhgKFtl2gRdxTKe+TPVne/8OlUt3Q5NUjjQbQSSzaAP6M+2sYRxL+dsQUF/qC + eYW/qeyzXSK+4d0H3fvxvhoxEklv+aEm+as8tsUSNUb0yJ6iV/OwIw+fq54S5j0xH+3FbRxTNLiyGucx + P/7NIwvkv35TJvllJ+RUM9LVvk7q1hoaRtgvpJvgOcGy6nYl/MfxmaQHI+cu1RVsy8/RkzVe3/FtjfTO + OOGME9cHQh9eU4iz0RnN2tysCPUUSJ30pLnCk4NPS2zXxyS6ob+k1tIYAeGeRolSxoiggB+uFKShWzdw + pbeEHvUXYKA91xXNO9VrwowS9Kyg2zlPNhghydIhUrd4gJ6iEQSktL37POoRyhiUMp7CcHLaMKlWBW2w + VBV/XOpWPSmyvUDqavZ6iQjqoswQ9Q0YjdYTA4q/QbxGbIEhggJzW6NEAL/dHLoEyDQ5cZE+AvA3XTWj + 9J5QmgomNgpXLQIWjVzB/ykG2ErV4Z0GAN/hfU4Y9EpS4Y5W+cgZPXI1fmyt17C/UE7v/KPULc2Rk/M/ + K5UzPyRHC94hldOGyrEpZoCj8YJH0mrsiqmMqTJQ/7ejagdrsNdDk/jfO+VIwZ1SNXOgNCzF2Cu/U2Kl + t0ui/O/8MfhyBviVGj1HqLeXHs+68S4zjK4hb3qrxLa+S6R6BoQh8r9G9Fuz3ls/GR1cLajQhInRlA2j + LcZaoRBXsvUEhC8IKGOLpcdIKqAQhPLmmqDG7R0qsIVPumnQk4AGAQ18NkWKXzquHg4qMEqzt72iQfqo + EYKnVkzFu8XSl3EYGBxtbAf27I6dL4OemG0ngTBN1EWFQa0PvfTAYzl+IIgu239aPK525ZaYwtcB4cG2 + BKA8EEYZmZ0Gh0HfXo5pjXMY88TYgkD4fy9uFkZtN4EW742GwEhjS0iamaDgaUos2gl1vvXxBXKyGf2Q + tL5o218XiiANu3bFmBPoE3VP940TOTPkVfcVy6FTUV9hyCjLxUBpoE07X0PGCZ0z/P4IvPQ++uxqHdMd + 8Zxg3w765iKJRC2eCxU+26qLeypSrfK6DNCyMx8a43GPsbbyQIPu5+/I+Ooyxgm0U2CcULkT9+MmmXFC + yxEYJzKgz7IxdjFGuKXjnu+tQpLcchgseLTItNcstP6cR40fJzCvmqJHvs//zQtB/4uRboEE9BG8UxsT + 753fXgzejn7E+FIjALfijZwur9Bti2Ys7pPFeQm/0V698Vu93LKnyV+Pmy5Pz9khpScwkyEPizPF+ZTl + yFCGWUYqxxkKMulA+RwQLFbau/zf5uOjJ854r5hgQUlb+s0ZJ5xx4vpA6MNrCaqoK+HSgh+1iTLe6Mnx + SV7kpU9BiIcCs3aoRDcOk+Rmxn4A1tM40d+CzIUqBGGgMSLDIKHbN3gyB13LaZDglg0qCwMlvmqo1M0f + LieKhsvB6XfKoSn9pXLyYDk5ZYQczx8uRycPUY+JwzMZyHKYHJ/zETm59iGp2f2iNJ7Y5MVip0E8EQxA + Hj1khgZdodABYARGkMkH9wHatg+/MYC4L9WE5XD9gIoTx4eOEcIYsXlGcE9+A8B9ky2CFYVM+83/bd8+ + hSZOaAHS72Y8s/RN0DNhz6ffBBTm+mNe7MRLXuTwIq9u5+/l+MYn5OiqMXKi+J+ksvA9uj2EODL1bott + wTgXUwfIiSn9MJTfIYdfwHh5cYScLMaYZVBaBopc5xsOX87YxO1iwLqBfpDeAeBlgyS2aZBEtwyS5JZ3 + WAyK2Ako5LaKk4yjH9Q4wX4I+uUqIqDBREBjoEHw6BON4t3yKAW0Qt3OoMJ47lxV8mhI6JBxgsoVBCfz + PiiU78xj8LKkF/eNMxPXVUAIxH88Uk4NHiXSB8KheiDwqLmwNDOB98ZN3oJqxEzZhPCpJ49ovWicQF20 + bgmvqiHmvfFBCqDz/LKfX7nwciiY0jAxW4+T40pj3wfmyN5TmMM4l3Es4jr8+yulJxUWbh3g6RtZbVe8 + wpE2TuQt0G/vfR51oQANxUDr0EkEadjVGSfY513aOIHy5rywCWlzNfj8ygf79rX3FUl1vW9QBG1q0EG9 + v5QKyFnA9qUhkONb2zrpvbipVrqPolLdgfZ9uRsnyLs5p6Nt1Dih219MkftWEfrZ95KgQtvWQNHqWVah + vO2xRWJbDqydqMSTf17LMO8IX/YmnSutU8aB/M15Fu8Efc64FFavBm2v55Yf0H5kG6iBXD2JZkvP8Zh7 + vjRNeo6l1wTa795C6ZU3U3pzjhoFHjKqSD7zu/Wy5ghGRPIM5sqIpqdgnrgyHxrzbDE26He7BguWyuf4 + OwMco1wcoLHjYE2T98r75tj2knS/OeOEM05cHwh9eC0hwkmFDEOtikDtIk92fkE9FugCLhvfDSGfhoS3 + 6DGhPFmDwSh1i8a6Ee2VgXYYiHdxZcwJ9aKgYQL3Ct9LYv0wia0cJvULh8jJWYP9UzV4FOMgPcpT3dgn + vku9Jg4U9JP9s94rVTy+c+OvpPnkJi/VXKV1IaMhw0moUkELLBVCKof+byV+G0imeAAkOgqbEMRtVZuC + BX4rQVsbOXRhkA4CBJMr4T8zd7+zQ8dWZhpE5jtKiy20aYaNFuiY1DQCGiV98hqsRkBQaTjmNVeu9ep2 + TpLa0u/IqSU5cnz2x+VY4Xtl//QRevTtiSl3y+n8EVI5+VaNTUEPAt0uFTpmXz6gATWxHvWlQZXHFNMo + uolbxYZI85o7pXrORyRxeCa6GkIHBRe2NQQI8g3rE/bRVQTohas8nAy51zWYJAMBNetP61UJoNeAnlqR + A+GNyhIDgun13GCMil7c385o7FAU/vsP5eo5wcmcwiWDgHl5JeKNhaBFAZHGD76LfDToZkiarTCqUAo2 + QfhHe1rZKbT6dYNSY14grE9S3Wg/8OOFKLcJXlT2QtPMBMqscTMgAGrQSgr7uUUybUs1srA2O1wn3qvu + Q5rZxabwUWnKZvlD0msDvm8CJpR81Pv5NYzsb2OWq3taj04gEHICocd5TnRVzwmWDe+jvN+bvwf0ObmD + NICxP2aGrDnYJOY5wTgxVIA6T5sdRpz52RZG/v7a3IN+X4aVtw26hOeE1cuME75BAX3+h+W725cn0yCh + KLKgi7kl8uoHFsnhWlNum5GujkOkdW3D6m2GaevjBOgl8P7QWHa4N4Na0ouqUTym9XvX0/Nsa8aoadYm + 4PNmgMC8M36RnqSk2//yuFWPimSJjpkHCnZJo6bTnKZJzuls+4Af0NBvccP4m+Wi8QQgb1fwXeoIGMv0 + pAz0BZW77GScozX17T0nkL8zTjjjxPWA0IfXFHSwoOFju73U4SdFyt4pUsqtGzQmDJY4BPoE7lMbhtq+ + bT0OlPEiGP2/AyuveuoG732jhCpEQyS1doQkVt0t9Yv6y8lZ/aVq+kA9MaNy6jvlKJQpGiK4jUNPLSh8 + j1Qt+pScKvuaRA/PEWmsALGRgaD8SnhtgHqReIIz9RV4LwAVRg4ks+6aazHPBrfjKYP/7P927eXgENAd + kEkrnGC5n5T76DkZG90FQg5p0fbY28qJCfnq5gh6JHPmHn+d/Dg5csUFyjIn69Y02bJPUp/jW8uLkym/ + A80yjkxzoycNp72G46u9ukNTpX77T6RmzX1yaM4n5dSyD0vjaoxhei6FjdmXEXg8sQbRpUF1/QjlaanS + 26Rp4SCpyX+P7J9xp+zP7y8nFn1eGvZOg/xxWvvKBBEaK/0+v1pA/7N/jQZAY7oShecAaWbG5qMWnZzn + 4asgBGFW4zYE3hDhk24aWfn4pkS667VI+n1zmTQ2GW89BTrq/3Xu42X6BN6HsEiXWRXAqFiGpZmBN0DR + PHiq3tNTnlCHgB9TSKCbLelZeTbyo3HiocKNuvLFvHjMX1iaraAR2vlesQY9Y5m65xYL43HY+Et4U8tO + 4h0o6Fl0+0Ub8YQSemawPmFpZoJGH7Yr2vRvHiySvccaTJnEWGP0/Xb9dYHQtkhfnXGCMSdonDh4kosK + GeW4WHCs4Nqqna9x40T+Zm7X4lGNbfIKAwRsCtC/XLoXrAK8AuOMvIL8q0P921mwfROkCVPYuOL80Z8u + h1JJz6oOKCgvc+NEkB77QvuFijnyogy6eNdJ6cEYQb4yGwqMi95Zk/TKbWmLdp8UU5ypTJuieS0jgna0 + NkDfcCscy83/9DfbPJDRMef47cL/Zm6vAd+aCp5ODwluqZsjPTCn3YBxYW1TosZo3c44Dn2NOYyGigen + 79RxIPEzaG+kT/0GefIZERyRzTxikK845wT/BQg8WdPl9t/Rcvr1oSFw/4mG9jEngjE72jzubE52xolz + wRknrg5CH15LYCMnTxV5yZc+A2GeK4yD1PDA1caobrsYDiWGBoV+vmFimBkqyvtLfHNHYk5AKQi2bSCN + 5Lp+0rR0gJyaPUAqCwaoIYIxJLhvnnvmdf98/nA5UfgBaZjzCTm17bfCPfgSJZMxxcw8I0AsMQ4y312Y + ddGBFyhpqB+tpwFh0pih3xE2+aixwm8DJTa+S/DeH3CBQSOzzRy6DoIJiyBDt+0apCUfam3Hu6S3EPox + 8N6Ym0LfB60SpEcyPv/bgCYpyOiqcvp7/9tWCJ7zynIFE30AfOu7TqoRhO8yr7pyL7L1//xtVCFj9uWE + dTSk0lPkNkluers0lg6UYyV36+knJyYNkOrJA+T4xHfK4fx+UrH4v0RqD6vBp0HbM2jnqwj0H8vRjPKo + sEU6QV/yGYXcY80J71X3YSLNmQeBiPEaiqQPj7ykwEQjRciEm4keetb7fFPa6UEBgWd/xSnIc0lvcwWE + 59wC6QkhURUlbuVQowTS15NBIDSGpJmJu77LM9YDL4NAsWUdbNwoTZJP48rtHr9Zv1960SuDRgZVqsPT + TYPGEnpY4Npr9GSUkR4OBfKvP1wicY5N5PmV/M3aLhRgzbtiip3dTwNFWJqtwPcgZObMkHd9f7V6lWig + NMwzpgR2DgGN2dUFxGS0/a5mnGgpo43vxYdj0jN3WsdoAHTMcXj/X1biU8pHVH6RXtI/ivEyg7ySxokY + 5jEGPqxtaPZuGf+8eKNonOiAd1IXME4EBiPtjwTp2vp5+/G412sclO6x5DEoj78trVUZ8+ZJn5FoTyro + oLNfLNsviThX8jPH5bULzlHqpQBezHqzDajsG81H8Jy0Y56BUZXdI+rBOOr5NUrbGieIp3BwPsiZLt69 + +eLdt1DbiYaKXnqqE+ehIvmHpwtFPS/iUT16mwYEpmt0YfmzPLpo6Svpqitof+N/6gQZ3xDsw7ShQt9H + ffzyV51oaH9ahzNOOOPEdYLQh5cDxkzZgIags+NSb8q7EmRKI9RaZzV7Sbo5Hfi8JMrfL1EaELjCqMft + cbVxsB3BR+OEekoELuB4RqWG7tEbbtd93En1jCB40gaNEHi/bKg+p+s4TwloWj5ETs8dLlUFQzVmROVk + Bva7Sw4W4L5gkByFolA5+Z1yeuFIaXzpjxI5taPFhdnhsoGDTAHBorURBm1PGvKfkXbMu8QYPF1HaRgK + lGl9r9X3BNPwn1OIafNOMNA7ClO+6aHAIJUWqFJXIfzf9p5NNgp/4mmBMZUAOklmGqz8/8lkA2S+G9y3 + lMMUlAD6Hyc4HYst9by6aEZf+fdqqGCZo16sYr6X2oTxW3qTxDcOl8Tmwf72B4zfjYMksQ7jl0eRZir6 + 1yLKaCBluYdZHI1MPoUrt6HF6PmF+jWs6Ke8pmLSu6RiMoOJDpFjk2+R3cV3S9VL34WsdMraSJX/iArc + 7dvzWkPS+/hPl0MY54ka86QnV6Gzp4g3bnGLoHROTIfgNFsNEKrojC6R3y7dLTHU/09rKkPebw11q2Xe + VPrpfgwFTYXIcfMhYRbK4/krpIHlhOBJ7x41uEGZsdVWPIfgap5DrEvE21Z12jeuQDnrgPGgG5Q4Cml9 + aKAYjXLgnsHjXj1upuyrwZiPN3rv/UmpbUlh+VSoRVkp0DKwZ0iamejO1V8GXhs1Q340Z5tQsFX3ea2T + f+0EyDNarl3ROGGCvW6foQcMlMpXQcGnt03QNp2C30et2vkaMk6wPJxLJE4FyeaRmmjc+7v7ITzT2Mg8 + MhVWKj3IU1fbcc/VZW/sfBnx9RJdMVZjAerX4f7tLAIZAfnGYjFv1rYj6EsaCVHm68A4wVXvwDiRlmVU + VsjM4/Kh/zfBp2k4HVukBik1KI+eI71ZftCVxtHJnmsG2OwF8t+/K4U+j2/JT/12Z/tr3dWbGO0BRYxe + XRpo8loHaJVlT9NqslHLfcuTq2xOCumz1sA4Ad949ZhJsmZbldCIbwaK+hY+3QloudjO3LoEWg9OFuE4 + K62oCylPazjjxPnxsjZO+PmSr+tv0ibKQ55Po1xa90D9qcsEuoR9Czrz518uiLQY9S4NQh9earQoRGzA + APafup6yQcjE9HmjNlaqYbOX2PEZNUw0rx8qCZ7AUd7PjBM0RmwcInGNNXGbb4zAcxofGFgOUCWAHhX0 + poAiQENGYuPtfjp8PlASK++U2nn95FTRMD0e8fDEQXJkcj+pmDJAT9VgTIkjk4ZKzaLPSfP25yR2YoOX + itdZ+bSs14NycH2DWxEsuCMRKOgtg88MAMakqVho33CA+DTV8q3BJnamwwBZXMUh02qNzHx0sGVABYQM + tCovfwcgPWv+rRGUNUDm9+0NB1ZPggPfjBX23OrQZiLx80yPJyL4LyhXxvtMN/P31YEdW6Zlg+JNAUaZ + X8N+L7rpkzq2kxtvVQOilL4TY/lmG9N6/CbHfBtjwDWG1LpMzyw8U88v30Ch21b6SXL1QD1+uCJ/uBzO + v0Mqp90mJ6aMUK+JQyWfkeTeYpGoCdkp8Eej4fb0cy2CNPbs4j0QaE0RoBDbm54N9AzIVGrOAhoSOAFT + iFJFHEp79p/o7RDxxk/a0u79tujJCR6KWU/GceAqFgVtKgVZs+QGpD1jUxXIDmXVfek2+ZoAnTDhEWMo + TZ/gGSdi4g39xjJLZ/T5hS/z4phhHhE5803ggFLHM+5Lth4THs14y2M0WnCFzdqlL71FcudCGaCA1ya9 + tqDxBUrCX01YIGsP1KgCqOOaCmDm+L9IBDzCrs440dWME1Y+KpUoG/qF46M5mfT+6fsrpVverLTbf6ZB + IhjX/E1Xd54i8ypc1+4/aUoI+ob1TAu5lxXc3oQxzFMQcB3/wlodf7rSn9UBBaWLGyfGTNyO/kM7ZRWA + Z03UPu3FGD+jCnDv8+/R4M+455HPb3igSI428lu0lfa1yS2UzVSB8p8x7Uux7eyywzdOpGWvVMQ7fCbi + vfYh8OeOBFTV2EeF8r7vLJYGnUt8fhVvvGT0n1YKQZ/07lMjENp/1rbq9uVpA+UxzjhxTry8jROAtrfp + UVF8q16wDGxLgzTfYfkiqL8u2CS9JshBsTjmENJZFHIG/w+QmXYnEfrwUqK9whU89+9xNWs678EIklBW + Tk734lveByXk7eoxoQaFslshzN8usg5C/npTTPg8teHtkiq9xTdC0GjBbR52wgaj4PP7GK6MS8EjCnU/ + 97I75fSsIVI19S494vDoVDNIVE0dLkenMajl3VJV8imJrHtcmk/u9KT5OMpqTEoFH0IZAIPP+PVwuDwg + U8DATRN/QCsBEnS94wCh4SFj8tP/eE/Bis/9/4Lv/Pe0L30wP6XLVv9zoJ8LHMAEmUMGWG5FS1qKjPwU + QXky8lSwzkAUShIZh7VF8B/AuukqOutPq7lNSJZ/S/rgWngPz7gaHLQjnwf/X3X4e4/ZVqgPgyuq9T8B + oXLfr807qgzjdi0Nk3dJqvxmSfIUD4zx68E4IRvuRrkHKN9RLwp6f7HcaqDAdclwOT5zmBykcTT/Djld + MFCq84fIvin3yKmVD4nUHNXtYezzCNpI6Qx9n+Cz64D/sG8Pnmr0XjVhjhkluEeXVyh6qsyETLiZULdY + NQRwiweEYSgVI55arEr43/9wVeg3mVDlCIpZL01jhhk4qKxBKX7bl2dJZRPKyfEUN/4RrGZRwNN7jBcV + IvEODZp8Nur5rSgH0zm/cSUoe8+sKRA2INRTcctmDIOZ8oN5e2T3qZR3g/7H91BWCP76Lk/tUA+NkDQz + AUWLBpgRT69RI4vxCvAB5QtWl84g4BF2dcaJLuc5oeXj2MAV/cK2peLw5WnbNM10PqDrtgYK/c06jDYv + oAkTGcy2RcG/EsYJzs2N/jioiYo34Ks8QYEBCufKDWPMYHpOdHHjxIsrD4J+0Kcob98xk6UX+V4WxgGP + w1SvsGI7kQK8ygISz5FvL9yPT0kzJpeRXkg3Ok5Rh2Sg0FAeycjrmoRvnFAdRZ/FvQ37jxk/IK2H9Fkr + 8CjsMdPlkYKXNCAs+ZLSPeSxS6KAox2ZrqYZhe6k3qfk/Q3es4sPtS9PGzjjxPnxcjZOBJ42wZxrsgPB + +CpxAH2RsdhJIy/bkfTWDL2D9xEd3/wW+VLPYJqXAKEPLy2s0JnPlMkqMQJ6pcWvGQ1S78nR5yS+DorI + 2rebIE/QY4KGifV3mFBfaopJsoxbN6igcGXSFJUU39lAJQAKzKbAYDFYkmv6S83cO+XI9CFycOq7Zf+0 + 98ru/Ls0oOXxye+SihffKVXTPyh1a74sicOLvFhjjQ56WiXZ0ZzkbBXfnxjYWew03jtcPviDggjoxqx8 + ZsXTPgj+x8AgE7E4H+ZxQSaXaUzQiRID2foU3zGNMFARVANU++cK7hcnlClkPM8sO0H6PgesXIGBoy04 + wbMMBtZN60gG4H9P5hAgXSemyzZh2/jvZZYpzFh4tWD9g3sal3RipeUWV5a/bp8X2fAujOURGPdU6m+X + VDnG/QaMa26R0C0TfH7tQreRMdgl+FNyPQ2st4EvDQE/Gi61cwdLVf4IOTBpmOyZ3E+qCt+lpwDtLXqf + 1O+dguaBEoE+ZPtEQQucEDJp1gSRaxumgMS9D/xwhfTgChwnVAhCurXC/30u0MOALsX6O6tYuuUVyeu/ + vFhWHWqWv/ny/Hbvtwe9EGarYskgk924P3h0sfSYMF8+9PPl/gkCBPl7QldZtewYM+QjOvnqZM3xaHX5 + 7cqjSJPeHG3zCgEFWNSTBgeN7M7AlxQ68krkc3/aLH8uq7FjDbmSS+MLhFk75rDt+fTh6M7o8PhmQv4O + Vfzi6gFCIz/K7AssnYHVuYXunHGii3lOqAJpCprOK/pN3Juz5RjSzMgn0yBBmg9+q/IzV3rjnbc+vkxO + 1zNvE3w71L+dhBrrdIEi5k3dgrGGtug2tgS8xAIUtmqrMHRx48TB6jqvby7Kkrcg7TnBY0O9cdzKQW+w + WdI7h0c4oz45M7Sfb/rmCmng3AQF2YwU6Gu0nW6PY7qkeUVH2/AqIkOmC4JhLtl+GH0DXt4RHkgDHnj0 + H1cckSgN4OTRTE/bgm3j53Ox8GlC04z56aU4xmLeF5/fFl6mDDjjxPnxcjZOkG408KvyeftOeSZ1hxj/ + t+0dzdCn4qApxlPUk+Ior4OWqR9TZjIvKJYhaKPOI/ThpUWbAisRtoYSYqLaSxz6MgT6m9UIoVszNvDE + DVwJ9ZigYQLPNkC4h4KSpMGC8SeClcmNt4iU89pfv4+vHiSNiwfLiWJu1xgmh/PfJRX574QCMEQqpvST + Y9P7SeW0D8jppV+Uhl3PSbxmOzonhobmClkTOoJCKa2Q7AhjTuw860AO4mt/5fJ6RwS00wz6oHWOg4QG + CSruNkFz0msZiOm+QV/xSmbUFul3aOCg0MI+BWgdzPyOA44BtIQnAxANoAEgBcahOBNRSANQb88TTRi8 + zVQQkl48kdJ9WBzQGvtCy4txQCZHqGED6bMMCv7H3z7IHDKMCxpzwy97YGhh2i3PrE68BoYbhU6G1m6Z + baDty7SD+6uEoMy2ymJXKuLNFG7QJvGdX5MEt2EpP7hN409I2UBJrRmCsX7tGyfUUBqcGrRxkPIlBtzl + kcRHpwyVA+RDBYPl5NR3yr4pA6VqdY6kTu5UXkOrtp2wwknB+jxBdzo9rhX0QvrMaMtrERqcEbSvAnlW + sQVXo1DHLQsd2BahijqEYwssxpM5pug58p//XTmUxSnt3m8PKO95EJxHWYBMHu9GwZJC2ddLdgrHho1J + 33DJcrNdWW7wfU7eMY7dwDiRinobDzdK7zwaO85fflXQIED0ymasC9aZCi6+Q1n6PbFI/vPXG6UHFRUa + J3wvCxX+ueIW7Ok/B1RBGDNH5m47DvmCbW3zrd7r784h4BV2dcaJLmec0PJRIMVV5yAqQDHveEPKu/nx + eeqJlD7Roa2BAvnzyqOAe46chHG4SCaWVgiVJ9bzihjJWe54vQrgH3l2ndBrSscheIIaSNu2V1t0ceME + 8xv6rSXijWNAY7RXNugpj3zYjKcaJDZrqvSkVxh+99Ujn+fJz5ein0krVHZ92Yb9TQMFxyflNtt+EJ7v + NYMM746g/CWbD2Jc0QsuvM8yYUabaTJlHdvDaIhzSlw9HzmWMvK6CCjv0zHa8jvVfMY7Dfnp1q/ODS1T + Jpxx4vx4ORsntF4cm7jnoiBpk/fUfRpx1cDgmh7TB1hW6iWcC3wDhnlwA/hPdSp+dwkQ+vDSwq8U7o0A + M5/7BNO0z0vtvhdC/FvNsKCeEAyA19+MDxrwEuA9PSFKB9jqaRmgCgA9Kxh/gu8PltjKYVI7d6hUz4Dw + P+0dcnDycDk6cbCcmDJAqqf0l4P5I6Sq5DPSVPpVqavbhIattw7yO8mIBYhFoCCYYqBl5jO/Y/SddF0c + Lht47KRa9nAftDuuqqwDzRLxmoAoQCOATtx8n9sZmvH7TI2XPFbhxfbskujGDRJfulzis0skNqVAIn+e + JPGfPSORH35PGp98Uhoe+Yo0jrtfGu/Nlfr/GSln/t/npf4Tn5S6f/+EnPn4v0vNRz4qpz70ETn5z/8q + xz/wL4raD35Uaj/0Mfz3can52Cek9j8+LbX/+Z9S/7+fk/rP/5+cyXlY6sZ/Reof/bo0fAv5/Pin0vCr + X0vzn/8kkUkvSGPxbGmet1AiK1dLdPNmiR7Y7zWfPOZFm854USiiiWQzaJITBgc9hSNb4Q2MD+29O+yd + AHxmhozAuOPTOK+k5aCdryKCPZLGoE0ZJ5NU3nByu1e/ebjIair3QyVKHqDjnFs7uDUiMAJcoyhnzAnw + p1LwtbXDpGHhcKmcNkQOTRokFVOHyYmCfrq1bHfBMKnb9DORxmajb60/6Rn9hwnEVsLRHgr0YyJmE7nf + htcqrB7irdt3TAUR9QagUMeTNbj6FDLhZsIMAMXSm4p67kLpnjVZn98IpaEjxom0h4YqTlCkNP9Z0uOL + f5F5u0+hqU0YM95vY0jHhfIaEyR1HIEP2biJe2ci4t38ZZ7gEJ5na5iypkaWwBijgS8ZJLNQXp09UQV+ + ukr3gDDCUyEo0HbP84PMtUuvLabJ331lodQ0MECqtTkNQmxzM1Z0DmleoVdnnOhyxgltTyqSuNey+rwa + /33hD1T2UcZMg0SGgcLKwBgqGKdQYDn+/v7HmOfA59Vj6aIUoQuDjmXQCOO70EDZh+XidinSHI84btte + bdHFjROUNZ6Ytx/9PEW6jaPBFLyUivnIQlWMetGQCtrSo48xPvSUIbTv2x9bJntO0XsVacRN4STUgwLP + gvhgYXleS2gpo/Ujeevs8oPafy00fnZou4BHv7COfYj0wJfUEy89llryuhjoijUNKPGo8v9gDvjL+mr0 + SweM2844cV68rGNOoF3imG+CclBmMH33/7P33QF2lOX6kwaoV73Xe20/ywVJ2XZ62d1sCkWqgCgWrhVI + 2VSaolQFBewiiiICCenJbnrvoYS0zW4ahJLetve+p+zze5/3m7PZbA6QkIAkzB/PmZlv5sx887X53ud7 + S6u0qSYLu16zWpevQuuUOWidPA8Ni1ej+fU3EWvm4j2sekELr+f3gfPW0zgnTZp4OmEqlVsDk87Co5f+ + Bkve1Irt/Aaw8ctKLDC0HsmJCM0yCmieQZVok6amHNSYIDGhBIYIJ2rOIedl4t+8xmO0JPJSbe0IP0qm + ZKJMhIAjM/vhwJwBqFh7F6KHV1hoK5N8sFLMqjYLmtDVycTKpM0GEaw8gpWnOEMG17MFZtCStqTqRCLA + iuAeidRb2LffihcUoXneYhH6n0Xzr3+P1jvuRvOPh6Pmm/+H+kuvRPVFl6C8/0CUhbNRGcpEVSiEqqAf + 1X4fqkP9ZT8bVYGwojYYshFAXSDQkV7jN6j1hVHnz0SDDe4zrcafpagKZKFSoPcU1PgCqAkEURuQ6wQ8 + b67h+f6oE1Trtf0lb4LswagZdDmaLvs62q66AQ0/GIaWYbeh7We/QNOjf0SDvGPTrLlof+llYPsriNbV + WO3N0o+ozm2rZ3FCRk0QbZ9U9VPBlgOOGbQUbMMqBPy7IfmyxwjtV3wH2TLdrGrDan5trIwLIugX+NHG + vq+ReHrLOOA3BMAHGAkNsMhaN8rnm3GpOD+EkplBdbp7YPpAHH7+x4iVrzUDPMecKDWyDPlgJtcCDvyq + KitQ0iIxwfmgw7S5mpY2K/DIGp3AKkYu6jDzeDtwZdYasdQIsLLfk2YRnPQMmY1zx7zz5EfJCApQtJUW + wZ+RMkgAXPjzRSiWSYCWJdudliUniyxb03+Yd/PRlzQp+84f3mv/8YLcT+6d5JnHYo4hWHQSL1uZcHSn + mjTPcRVX0G20mej2oFPMoRRYaOIhk5MTmFxSeBo2dauadDBfLGvVVrEFqUR+3y0S9zBbh5z40JETCSJB + rjXzt4ghk6Xcp28+aDSh6INA+kJHyEnBUaJikfGhMmaJlJ+JcPPM+hIYW2fTZt9TSJ7LZXvRH1eLcG3M + S8yYQHLiBPrvh5ycILZVxKzP3m6PRXZbUqe9FLxJ9NAEbewio90mxxrBY/Ry3DRuPWokz2oerQQFy8Is + ruh4q+3pgw0jE8i+PX/i8YpXada30IzXXerrOAyX7430u9+v3KdhnnVByX53LjAke+bJoKM9iiDJvBG1 + Mn5e8jv51qo2S5I8dYJDTrwzzm6HmEfLBW0CjsnRaqt9xSI0DrkdjTkXozSUhSP+EOq9WWjz5KAy62KU + 5A5Fe/7TQEut/L/VauKYlNCg6Hz/U0DSxNOLRIV2hhRIe4PVGqm0sOMitG3NMpE3aL6xIYDoRq6I9lEh + hA7xeI7OL+ljQk05qDFBYmKTG7H1LjSsTEfZvDSd+B+eEcCRvKCuSjLaxpH8vqhY8W3U7/gXItU79dmq + VmUPEMdoQtgDEPPIyjUqKuwwFJLYOHlsQELDrNTL/xy8d6ivtyL791lNL7+Mxrx8tD3+V0R/dg+af3gT + 6q65HtXSecpDA1DhF4HfJ/BnGmIgnIWKYBjVHhIKWajzZysRUBvI7iASuF/h74/KQI6SA1Vh6XghEhiS + Lv8leB+FkhqZqA4akiFBVpCIUDLChrl3tjzToJL36Piv5EvOGeSgOjBA8huS/0k+5b5d761kBokURaY+ + p0LuURkcIMeDUZl5ESouvho1130HDTeNQNNP70HDo79D09PPIjpnHrBqNRp37UOstNxCswi8FPylTNm2 + EziuvN9vtPNjaNTQdZBkP6SqmPRFEofqf2LvMmCrcYoZVT80FypxGaWzySSEwAcKBWkaEUgd787w6dh0 + cDojAblRNieI6m1PAU0H9L2pRsdJO8tBP9aJcckW1shmUzBQfyKaThKD5z7ASJCJsj921hvoOWq+Rq7g + pMgIpck/ukdBAYJqxCQVZpi48ly9G0Oh6AQm95x80Xkbr5f/aihTmRBd8/ROyR7zJ+M5y5KQ9tYebdR+ + wZDWtLdMlLs5H7cidC4r+3cteN2ohyd55jEQgZbCkK6g0VRDCRkKaWZSb42Sd5P3oNYEQ9P1IIGhWiUL + jIO5ZPfsDPnf9G0lhpyQyW5HP7KjSh1TF+8CiXuYrUNOfPg0J4y6L9tXm9YLzRRFgJBvyaHmuPU/979s + SAnpY92VSDTP7SAqKISr5tJ8SaOwshBf+dlC1Dc0yT2Okn3vHaLWn1a8asYMmk0NnY1zE/32BCb/H3py + QubHfOY3/rVFBSFqn5B4Om/4JFisYylLQ0TN0rxaDNOqYaLz0UvGuQkrX1aCQvOtgi+/B4Qca3v6YEPH + Eu5Ln6QMwP21e6s0Ykn3YTOOq6+u4LjB8e3Hz65VAbyR32zZxiKnScCVPqTaEnF7PJJ7L926G+fJt9Ia + uSJpnjrDISfeGWe1WQffSfo4/ZcpYXz4iNXw0B9wKHixykdlIm9UiExVExKZJODvWGit8Wah3jMQdWN/ + Bbz2GmiKrXWo5kqnB0kTTyc0Hr9kOsoJHgtCKlk93za8YWGn3zi11NCe1IZIATb1ETDEHskHL9rlfPtm + F9oLA4gWehDdwsgb/dD6QirqFmRg7wIf9s704dC0ECryRKCcmY59M/rgyPzL0LzhJ6iu3GfF2mrlufYk + tNOAeHo7wNkK1plAV7QFcsxOnoApV54zHYPED5lyTuyNWUGrbI1zysRHVVeEWRf2fwyLLudqyqzW9S+h + +dnxaLv312i+aQxaL74M9TmDlXBgJ+lMArDzUOB38NaoDeegZsBFqLvmm2gYOhw1992Hqif+gqb5edK/ + XkJLdY0VjdAkxh587bqkBgPr0tSvTMrYb7VeoR9Do+7O84k2wetZr+bjwno2k1izr4Sgpslz9BmJ+9rX + sy0IeA3bD59l1Os5gY1bjTtuAooCMi6kypghY0ARQ4r6jpIA7zU4PnWAJiW2493CVMQ2cLySsWsLTc5s + Mw5B24tpKJaxiRGA9uen4/CsDBzR8cmF0jW3IVZcpGVzdsOe0Evdrt9TLpPWOTJplYnT6MXoof4fkn90 + Txe6M4Qpw3iOWYAeQ0mKUPifj3+8fECaFcekZHk+Ch3jpC+oqqO0Vx4zakrhnkoVVkk86EqsTNpVM4JC + BwUheTa1NLrm56RBs5Rhs9CTmhTD5b6jbdJiaB56yLt95s55qG2UfhXjOMs821FGVKh45/d7J5h7JrYO + OfFhJCfeDo8s2oNeI6fIc5bjY9RQGktBlWTcStVM6KWmVyL8iACk+yzD21fhhn9tsJ3RGg0xrTPND+cI + sqXqu5Kv7Hf8NvF7IdcyMpWk6RxC88B03kegpLYpQ3UaLWkv7qsxq/y3voCeQ6aYtjZqiQiXLBNbG+Dt + 8GEnJ1i2sTpr/puNWn/GlIHaYDK22eGh3w5sc+MKy+RWkmdqCkid6BxC2z2PBToXYPkSfJ4NfV/6AjJ+ + uzraBucErG/7XiaSBs9R8BfY47qWFc/Rb5ykN1EIi/BZ9UYQO4E65P0T8xWte2l3JTUR6xO3LpU2P1PL + gf2U5LJqkfCbMNombCick5iTvvG/t0/Dnjb5diR8FzGPmk/zXmz/nFeZuTPznngfuZ5O0CWN1xinosy3 + QWLORDmL+XyzGla/u6ReGJFmtHz3mC/mhcQh2xy3/J5I3+wh/cJof8i3Ua7zP7oWx0WH4/Ydwbw45MS7 + gd6H7/5vIifaaNbKNsQ81B6xmn54oy6W1npF5rIXVN8Ozb4s1F/5NWBHoXRZe87f5RnvFkkTTyvkg8GC + IjNDB5M6yWvcaUV2/giRLfTC7xVkoH0DJ/zUiDACQHthmppxgJE76JV/2wWIb7oATav7onq+FyV5IRyY + EkLx1HRUTA+gjDbcM/uhbNX1qNs5Dq01+82z6E/C7rg6qGknMDCdvFNeHRwHriAalWe7Hu2tDvpap7Ll + eaoEyTGvNQMLB19DTJkPhKTLlnF01YymtMRq2LQVmPgs6n79K5TdPAxll12HsoB0CmoWhPuj2B9Adaat + zUBSolOnIDHhkBPvjLqQbYbiyxb0R703B9WeQaj0X4TK8KVozLkUbdd/F22jbkXLw79Dy7jJaFq6Ci2v + vA5UVlvRKD/mdh1GpP9w0sB9SUtEi4hI36LdWaJudaKgGhHSBuQ6fnj4UT0mJJH8r1mgmgLsm/QtwlVp + qgwzxrKuMNgCV3uj1XZ4DqIU/NWp5AVoV2KCJEASIuE0guGIlZCgphZNzDgmFcg5gvsbZPzalorY1lRj + crKlH+Ib3KhaEsDBmW4cygsbU46ZPpRMS0VZfn80baU6XLWUT52W39mNxIcybhU3xq0LH1yF7qM5KV+A + XhTmk3xwTyeMLbRMpMfKxHHYXPQUQa3H7Quw/pC0PE6Kj8vvsdDxTYk6aZ/2BJXflcO1MeuCe0UAs59j + JqOyT6E94eOCgph9/l1jtORXJilqGqKkBwkPe5Va3udrT6xHVPuhPemVPOrEm/1M8pnsnU4Gpu4SW4ec + cMiJY7Gnut36xJ1SLtSMGMoINiQeF5lIGGy3GolGBCU5Jil5zq1LYN0yD/+VOxG/X/aaTmj1XuyLHPdl + n8KWClxSNty22d+LzjALXua/PGab1+M2eTcRsHj8+pEKuH7G/CyT5y8yoYzHyPOprcSyUSe7ncoqGT70 + Zh2G7GwUXP/XtTLmLLLHnlkyjrPfJs93B6QtfEIE4X++RIeQkm9p2x1ay/a9Occ0ZIUgMUfvuIbCuylD + fffEdZoWUb9cifMaXts+z3LmmE3/Jqy3ihZYDyzchcdXvS7DublG5QO911tD25TKDkeF9gZ5Tt97pQ3d + KnWopksEfRDNQc8x0gf4LZB2z20PEnIjl+oY/pMZBdLe+cyoaiMlSGRDtvAZ7AMybyLoMF2uVWftTO9E + YhCqPZkgOmJSBiLn1Mn+157cKHUzTZ5nnJQqaZIIeS191DhlphYTtyQojpITvkdecsiJJDi7fU6w3cm2 + qcmquffXqAjnqJY5tckbksgTXVEm8kVJ1kBUfCsX8fLD0q7ZTrs+490haeJpBTsfB3WZQBmWpsJqf/PH + Mrm/EK2FMvFXEw5G3CBJ4UZ0Y5o6wqQ5R7zwQhUI4utcaFjuQsVcL47M8ODQNBeOTE9HSX4qqqa5UTI7 + B8Uv3I6m/S9LG2TFMPyJPJOVzo+eDi6m0SfydWxjc/CWkIbLhp5YLdcyFHCfauhqBy/HHHRNVIGIXq8C + qdS97pP5rSy3IuvXou3vT6Jl+FjUXnoVyn1HfTZwS1BtqDoYUjWiymBQrgkbjQl2hpDtn6HDfCLrmI7i + 4HgcycxCsW3iQhMS+tMgYUGfGpUBnylH+t2QQYk+L9TUxDdA/jsYDYOuQOlNQ9H8y4fQPmUCYi8tR3TP + Dgv1ZdIuOJGUgYgTgkQbYZ1zoEtAziWihZC4MNo07HMCtiP5T6I9ER2TUQG3vFY/KPz4NjVazdu/K2NC + H0MMbArJuHGBEgjvKYqMVpeGBE2QEho1iESFF607voK2TUFJ80laX7SscqFsdhgH84PYP8uL0tmpKJ4R + RvEUDypX/AAtxZtM2djvelx/O8ug/Z/70g5Yrz98rkAnR4SaaCT54J5OcPLTXSaH1ujp8swlOEee+eVf + LAVX0U5k/Nc6ouYEvyH8lmi6eZdr/iYTQZpmcPKn0UdkK/vqS0MnrMnzdFIYNsdMdnXFV+5LG2Ypu270 + mC8C39+epwaICa2s5F+M0aaO/dadCrTuOrYOOeGQE10gfSJ3mvRpKReG6VU/MMNnohd9vEh59aT/FHk2 + I+5QYLJumYGeo037+bj0yfz1u1Gj9c17yfeBGg+yz29Ji5YNj4/mk+fjXIGnAMf+2MbFJxFSY01SdvZ1 + cp8NZTG4f7NGykCeP2qlQMYA1W5iWQiGiTCppl52Ob0VPuTkBLWvlPiJtVib9rfiXGlD1jApyxEzZSx9 + Z7MGa8QKfdePjJqNXy05IFMC3tdEa4EufPBdCM4NOF/ge1I4ZrlFdUzjPJJ9mmMxtxRc1UG0atcIohGL + EdJ4jogwnf+Xe1Ngn/NKHS75/VoNS33v3J3QNiZlSUE82Tt3Bu+nxIFsE9FFmPatv74g70WfDjIujJa6 + VA0J+51l7FdiYvRCoz0n/YD+Tv5zxDSs2NckzZMLN3GzMCMgWZPIO8tA24ld12ZB1z4v/aSjbNg35JjO + DBFtVgLvlolF8uypsO6QfMl3otct8i3it0Ker35Ahs0y0ao4HvC7RY0mHXuPkhPU7HDIiWNxVpMTdrk3 + L1uKWs8laPBw8TIT5WGRyzz+4+SJruB11aGBaEobhPJf/Vpumfi2nDqSJp5eSIeWQUI9z7NzHXxIJvXp + QCEn/1yV5GQ/TUmJKH1ObJWJ/za3nHMjujYdJYvcMsEPoGxKGKVTgijO88qk3439c7JwcP5XUbXzr0Dl + K9JBWTFcvaWtbas+S7U2KBhzMOKx3dnYAcxAk2hsDt4KXAk3q+EsK5ajDB4sSy1Plrf9weYHROpAtSxY + 3mUVVltBEdr/9Bs05I5A9UVXo9Y/SITf/sq2kXhoCIVQniWCswjQSjh4paFLx6DviLJgDkozBxr/ETbY + GXgd/UoQDjnxzmCZ1wUGo94/UO3EWMb0Z0H/FqwDJSNoWyblWU4fF5lSN+EASkNelIV9quJVL2XeIP+t + dXMwGoyyq7+OqmHD0HLfPaiYNBnRdS8CFQelTdTLBMJMZii8Edrn7AFQ1XN1VYBmJC1yrfTTNhkX7IGV + k4VWTj55PdtXGyck5mNFkrP5yBxENn1ZxoeQjBkyVrwf5ESCkEiYdDBNnfCmK2HRut2DWIGMYy+50LrI + i8N5fXAwPw0ls/wonuJCCTW6ZntR9epjiPJd5b3a24+WU9f+drYhMclSgknGinHr9skESiYtMjk6LcLX + O0EFSk6m83QyyZWj7z6zDtrmOJZ1yW9X6IRGrtV3UDVceR+ZXPL4nlmvmJVYkiyc7OlKlIE+m+FBu+bn + JKGTSQp6VE0XYYqCZndG9xixDJ+8Yy7eqDBCGsk/Q07Y31rm9zQgMckxW4eccMiJYxGLNVpHGmLW5+6S + NiECGAmAniTqpI1SbVyJCQop0obV54ScZ2hR1abIXYJPjJ6Nv7+wFxSuOiKCkHCIi8Al92d5qDamQOvV + hj4/UXZS10pMtNXI/xqtZbvrkfpLyQ/Nn0gCDJGt9MXuoxbgXEnrOWwGzmHEnMSK8tvBMeuwy5kR0WD9 + eGKhtKmlUseSf3XemzzfCTD/PYbMsX0F5eNb4wqxu1rmATIH0HeJNMr9zXjF+k0QEFpu6ptC3pXjLtsE + r7VNfXgdtQ9UqNX8SfnIuVh7m35Xy2Tuv7TgTVzz59U4b9hEefY8NYN7aN4bIirA+A6iuYc+662h5LQ9 + xnTIDPK8f6x43Qj5HAe1HUnbVoLavDc1KNTEY+QCLQPr5qlK2Ll+uQwFFXLnSJ08X8YQFXrlvtQ0lTbP + dzaaqOb9lIjTObaM7+wfCcg5LsCyTvY2GLLknDHS36iVqPlaapPaBhrOV4Rd4/9I0mgmmCAn5JvIPHp+ + /YJDTiTB2e1zQrYtjVbxzUNR7xN5IHMAKigjZNIXHheKk8sVHfCF0OAboIvKNZmDgZ075LbHP+fdIGni + 6QQ7VSvIastx+UIrXugSwSKAGH1KyES/vciL6OYUxLf0FqGjr070G1f3RdX8FFTOzcDh6UYlmhP8w/kp + ar9duuKHqHtzMtpbD1oRftTIpNq2MwbmWG1uE2mJ/Mj+UWY20dgcvCU4OCYaPssxMTjKvk4a4uwIcl4+ + IG37d1u1M2eh5t4HUXv9jSijU8gwCQWj/WBMM7g63x81vhxUe/vran5FwIDOI3m9EYbDaHCHOjpBwtcE + cUzncPC2YDnX+gegLjBQwWM1m2E9hGRfypOOQuulTug4lB55af7RKHXTLNcywklZyBBCdcEcNIbkHvJ/ + DmC8R6Of0U76o+KiK9Hwfzej9b5fonXcs2h9YTliu7cg2tKsH2B+GPjR1TZltx+qJlJIj0hfPcamVMAP + pPFhETMTBDRb0eYGq2nLlcAWkgN9BPT1YJMI7xE02oaadFBbghGEbPMzOubkNRt7o22NC2WzAjgwxSVj + VF8cyZNxaqoLlTOk3a8egraKtea95F3itInle9oC5TF97SxEBzmhY3Grtauy0frUHTKxVQGGQmnyj+7p + ghIFVGXlhI0CiRxPenGvDGn296JLfrtC884JMvcTk1ONphK1ZhUW6wRUV81IRMgzeo6UyeGwfDMxHHnq + 5IRxkCn356qzlBmPe9H3xPBFuOSvL0m2mD8Ze9lnbHKC372jk/ZTQ2KSY7YOOeGQE8dC25q0uz8t3SV9 + gBN+EhIivGqkAGmzUn6qSTSM/WGRUSenD5ghM9Ht1udFwJ2Nc8cuwbDpu3GoVvqkhnVneDsS2fXyDOZR + wG8H0xJIpEse9PsQjVrNkbj1p9X78Lk7RQBj2Q1lX8lTJ7wqjMmzVJuDk/4T1Wz6kJMTJI10NTTSajWg + xXqzImpdcK+U57Bl8g6rkua5M84bShM02VdCiGY/8/C/d8/Hn1bvRbEI1dpXBVEubjH8u+xTCI9EzTn6 + 92H9EjymlkHim5Iozw4CQ9J3lrTgkSW7Ef6ttC2a8UhbVOfJUuckdR+cuxPGfIj1efz7dgWfZTTT+Cy2 + O367Yb1W2mp9+k5p22zP/MbQOTO/AfyuybO079IHBUPojl6KXmMXo9vQ6dL+5qDfA8sxf2et3J5axoSZ + 73B+ZN6LbUbaGskW5oPjun57eMyQ0dJPmI+2Nmvqlgp471+s3x3ji2gOzhkmfY/E0e2SH377SAyRQKGp + Fc1PRsp+YlzrRE64f/W8Q04kwdlMTugCWWEhSimT9Q/gILWrMwei3ufXQADJZIrOoFxHU/FyTxqassKI + Pf6U3Pb457wbJE08nWCja2FHaiiz4tuvkAl9P8Q3eRGjI7nCfoiJoEF7bUbgaHspHTVLvCif7cfh6Rk4 + OKMvDs+ml/t+OJgfRtkLo9BSvFQq0LbV1gbNTmsqg42P4D47vREEOueFGhOJBmaOO593cDyoXmnK05Qt + mVojLEq5k3nesRPN46eg6paRqBlwCeq8PhFi/agOB0WoDeKw10SXqAsPRo0ItyQoqDlRHg6hUlDnG4AG + npdzFJppxlHml/OBkImS0YmU6ExMcJ8Cc+eO4uB41JPw8QfVdIZedumno6M8g/1VW4JmHSQomJYgkRKR + Q7ilYxzWR0lA6oUmICFqtAzQiCMaRUSeQZOb+lCOkhr1Lvq4GICW7EtRe+0taL2DhMVzaFn7PCKH9lho + rJW2I5MJTnwEHX2X+ypgmfQEiUGzENWykAlL/d6nENvQF20MNSzjR1cy4fTDbcgJ7isxka6mZiQt2tam + oHLOBRq6eP90D8rz+6N6ehiHpvfFoWXXonaLDNRqQyofW3kX7Tc6Zkm/0nSOXeb4rIXWH/dl3FU/JLCu + fOxlmSjx42omSO8ljCAik8jhS+RDnof/uH029hdTrZj56ZLXJGDbNCrkrEP726H/i1i7K9us/xgpQtZw + EcgYiSOXk2951rCZthDGCdrxeToZJEiA7rkU9DiJnG/s+WUy/Kslr0l2pB9RrZkEvfYZ+cbxu6d5PPqt + e7fQ9+/YOuSEQ04cC7Y1ml/UN8Ma/BsRikbNx7lsGzeJYDJWnk2/BCy3YSKMU1AUIai79BlGzbFumWX8 + FwxlO58P/y+XYPzmKpTKOG/U/0Wg0LYgoADK8YNbOeaYwudydbm1LW4t3laNS/68CWpDr74kFqPHyFUa + AYfH+hwKaWNWSn4kX9LmTFqnskqGDzk5QdNdo7EgAr3dVmduPmJrnpzA+DZ6GXrIuNiD70uhmD5Jhkkb + EYE444GFGL/qNbxWaQtJJJ3oQ4JEgxw3Szsw5UeBmWMcBXm+O+tCzsl5CtOvljXiny8fxrVPbMCnbpVn + UjDn8whq60j7pxDXc8wiPLTgFfm7ITIa7fd5R0gbZLmr3yGOt/a3/Lt/Xw1ryAw1idDxXqNHyfPUrI9a + E5IXJeFNPZtvgpTB6BU4d3gefpK3DQcrm6wmyYeOYcwPhUzOC3Rf0lVzgmUgiJi5RI2896Qd5bj2qWVS + jnnyXOlLJIGUiGCI08VmfKYzZZIWNjmjJI0Sdewj+ToeJMgJjjWuh9agRb4lDjlxLM5mcoIhQKN/+5f6 + mWgJBO1FyP5o8ARQETwBciLTmIQ3iyxX4XehbdgdctvkzzpZJE08ndCGHmu2Wt64RwkI+pJg9A0U9tZj + RutofCEFVQtcODLNjUOTvTiSF8Y+wR6Z7O/Lz0Fd4S/RXrNVKy5RkcaWnYOEYR614bAB6XmBbFV7wiYk + Eo3LbO28dSIqHLwFWJ4yIMZi9BvAD0SdFd1ZiObH/oaabw1FbeZgNQugQEutB/o0qHH7UOf2o9kfRkNm + SFm4erfXqA2p/wN7Jd6ThRrfQPVxUOmTRm6H1+QKP4Xbend/JKJydBaq2SlUkBaBu2tncXAsSrPDKM4M + oiQUUFJIfU8IWH5apkGpG6mXBm9QtiQwzP8YBrXOlYn6jGypRxJIOTZZEUK13Kva75W6ccs1ku4dqPXG + +qNWBQc3khqlPnmmz6P+Q1Qzg2Y9g76Gyu/cjKp77kf9E39F4/rNwMHD5sPLyV+iDwt01YKQdqcqvvE2 + K167x2ouvNaO4kMNiq5kwmmG+ptIMSYddIjJqEEv+1CzNA3Fs/vg0IyBJnRxnh8Hp6bJeBVA+ct3IVou + 4xUnMjKR4IeCH0ZOpJs5HnJyJOlGaD/LIWO2Gad5zDG61XrixWIzeeJKT5IP7umEajKI4NM915ATOX9a + JXO/TpOCRD7fCtoGDTnB/xz9X8Rqle9M8HcvotfQqTKR4GTHaEpQQNKJqU4Wj8/TyUBXueTeautN3xkU + aIbNwMfHzMWaNyskK/ZEVrbMm9FmkzQV6k5diNH37dg65IRDTnSBzKE4rnF/64EGfHzUNHxMBUQKh3P1 + mSYfi1R4UpVylqNA/VJIebL+ewwXoZWaVCK8ZfxqDe6euQ0v7q5CZZuMmVJGZvJtJt0U5vbURK2X3izH + XdM2IfTgEumD0+U5FAylD8p9PiZjS7db6BPBFpC4gq2C4kJ8+c7ZuOSxl0+sDX/IyYlWCoucP/NbJvNA + Da8s/fOehTvxieFTkua5M8w4z1DQsj/ckLbaJjg+jl0r9bEIn71rBa5+/GX8fukbWL+3EtUN0j7VKXaz + Po/EhH77JR/VLbDWH2zCX9fsxpjJLyP4m434r1Ez0St3OnqNkfIcKQK3COW9cmfjHPoYkTFfTe3oY0Ta + yC8W7YISWiojHLt4mRTsnwpbg5Mkjf4X1pyig/iI3L/bUDqg5PtSO0HaPM2W6HeC/Vfe25AURhjWd9e6 + X66EzRdum4MfjNuKKZvLQKHZmL0K5Fkk6Eja1LTCeq2syZpUeAjfn7IZ5z+4UvqOtPOhglGrzDeO5T2K + 2krcN+PUucPm4CPDJuOj6utF+gfbP//HupBxgd8pHXvlWuY148HVSk6YNma/d2L/bcE27pAT7wZ6H777 + v4mc4Pyh8ecP6MJxqydb5uoim3kCaPL3Nz7ousgTXUF54VDAmIlXeTxouu5GuW3yZ50skiaeTmiHLn3e + at8eQnPRBWjfGkR8w/lmor8pFS0vpKIkLx0lk0TYnB5C6aw+ODCrL0qWXo940aNoqy+1BwQZpKJU9TYT + fb0/V1iP6UBSQSrc2AKODCIkLjrIC+7LOUdj4sSh5E+00YrvesNqGzcNDT8Yi9rwV9XWqDI7qMyZrryL + UEqzAFXxD+eotgRX1zVOLhuyCKcJqEkB1YgoyIaCHU4wCQrOKjzbJEaCnKDAy/0EOeHgxFDvNmYa9QGS + C/0ViXrgfnmIPidyjJmNHNOEo4S+QOgQhyY5tmYENSqMY1L+1xARJBtIPFRIHZZSU4Z2avJfmvFwsKrJ + 5OBFJpb1GFbtjSapwzpvSImlquwBqPfKNZdehaqbh6Lu4d+gZXo+ooVb0F5ZqX21s6ASpTpjtNlqeuMR + oOB/0VpE3zRJCIXTCZpw2FFB2je60LQmHWXz0nBoRjoOTfeieLoHFTM86qD38NKvo2nfVMlunX4cjAdy + +tewV3y46idpHMOOaiCd5RBBmXXHSZaO220N1pYaWGp3ztXTJB/c04pc+poQoZ6rZzKJHZm3VapA8kFt + lmO+HW8BvYZjoMm/1qlAzQjl+OZ5xfgoJ+k6Cefk0JATuprFyWDX/JwsWEYjF+A8ClcyoeVKWI+RM3Dh + AytQJ+9AtWfNo0zmtc0l8s1vn9pn28fvEolJjtk65AQn8g450QkREq5GiGSf+sPqPfKsufiIrlhzZVbe + QfKgJh9SfueI8KZOMkncieBvjZG+Sc0GEfJUy4Jp0nfoo4DXnX/XImT99iV87YmN+PrfN+Dyx9bC//Dz + +NzPVsp1XIWmaYHcm6FBSUgomSdjy3B5XzrnpPmGCGTaJ+X5Hxk+A3984RAef+nwibXhDzk5YbT75NlS + t/VybJ5PTQqRjaftTprnYyDjF318qP8RrtqrOY0R3FnnPcbIsZYDt/NUI+Pzdy+H5zfrMOAvm/GNvxXi + 2r8V4aLHNsD16+fxWWkP59CvQoL8HWX+S60IbQ/DpL1rm5JnjVqsJIUK60yT8fOBea/La3FcFJAI6Pyu + ySBCo/ZRqXt+sxFvMsfRmEYwGfDP15SgUA0KakZomzLvybo7d5h8GzQ6zBKclztNrp0uBWf7XaGGh7wz + NRuoGffpnyxA4Hdr8dW/FeDaf2zEVY+/gMzfrkLvB5bImEPfFQtkDJJ2PUyeIf2IPlxoNmPKQdK0XNiH + 8rXf9Rq2Al/713aEf78BHyMpouOA6RskCunPyCEn3hlntUNM+dbU/PRnavpdERiII5lh1Mvcnz7qVG57 + BzT6spXEqPCLjNF/AGoHXyW3TfKcd4GkiacMevCXwUwLSCZI8de/g3hBGiJFPqin+/Uy4d96PmJFAbSs + TsWuGX1RnS+C58R0lKz4Jqr2zADtqVRNteu9HZwcOEmVDp8QiEydCKRD6L7Uk14j+7yGnt6VzInFrZbq + Bis++QlUjRyGyuzBaBJBkkJncTisQiwdLCZrsA4cnBR8tFvLUv8VJKDo56LmissRufHbGt60du5stB54 + Qx2ecdWjPVppxTd+wyYQ3Ihu/iJiW9xoZkSNbX2RcGKpoUc1qoatYaG+ImyfETyWa9q29kV0i2BTH0k3 + /iVIQpgQx4KN5rrWl/qheG4qDkwP4vD0MA6SjJiTjoqpfbA/Pwc1m38P1B3RvqTCEQXaE/64n73QCYGO + N0YdtkWEeo4zAx/ipPH5o5M5QoV52XLSxAmXTDD58T0VUNvgIzIx7jZCJmUjV2DS5lKdaOhqr4aZPprX + d4O5G0sk30vsSfA0mWxNUTVmFcaGUiBMnq8ThWqXcOItE0u14xdwQnnf3O0yhCfP02lFVKDfh7hF06Sq + Jlif/OlSmdgu0PdMlueTASfwahYjE+avP71FJlkUGCgQHZ1Mvh1op64kn/ookK2uhsr3S/reT/K2aht6 + OyTLU2eo0DSGE3vZEiIAfOyOOdhTXivPocr1sfk5WbAOFR1ErLTJaIP18znb0YMCRJI8nQzYv1jG7Ff0 + v/DJMXOwt6qxQxMhWZ5OBqqOT7RJ/qOtWhe3z9os/Xem3YdFcJR+ravX8vxzcmfa5J30yZFS92r/Lsck + JQglEeZKf5qPc4bTiaaUAcmNxGS8676MFcYBJ+/FOuU9zGq1Cl6jpc/Y5Mx5w2fjrhlbQaHyb6t2Stri + pGXWGSTPvnzvKtQ2ilAqgmmiz6n/GWrA2cdvBX4DTHQROVYHj23W75bQP4fkaVTyZ3YG29/0oiMm7DHD + tetYKnM5Isnz3m+MmbEP/zFsguSTQq5NNI4yAm+v4SRrpR1QcGbdKqHAfel3rCvb3OGUoAKctBmOv9K2 + 2O56yPMJHus1o6bhXKl/kiC/WPi6DC0Ufs33KNk7nQx2VrZZX7hdnpH7vLZxS9q4hhiVd9QwuvyekSxj + X1DNOsL+tnVqy28J/k+18mSf5CjBsUsdMC+xy1H6Ftv7EFs7Qr4R5+XmI/znQlQ3t1oX/d1E01HyRuqB + 36puucvknlI/LCO5X8+hs9H3gedR08I2LW3NXkhJ9s6doWOvjtec75hF39eLa5RMIfGQrE13BvN15eNr + 5W+8R6Oaiem4z/GJoevt57xbcHwypkA0VyHBELU4/lH4V8I5SZ46g+U86M8vyN/4XWmWvCUIf8lf2+lZ + 5GZbpBNrJXil3Etr2qxPqb+QEyg/aU/Zv30BsbZGuReJJY7pfF+5N8ecLs86Ho1W+533qSl9ZShT5+K1 + WVko8XmPMavnPD2x3xmNgQxU+geiNDAAjUEfaq66Vm6b7Dknj6SJpww2aimYOFeX6tdbsVculgl+P0SL + bCGBE/7CryBa6EfzBhcOzByAg8t+iIbd06WsyuS/7CBSaKdh8Piwg4OHERCkI0Wk0cokjiYx6pxQP3BH + WTZuYw2NVnTDekR+/RvUfPVqVGZ9FZXu/qriz1CfZf4giv0B1WZo9eYcL2g6cHASoHYMNTJISlD7hoMj + B0qGPy0dMED9V7T6rkRr+Do0XfVjVDzwKCIzn0NL/rcR3elCbPNXgCK/jCteY+axJQPxjSQaMmyzD3vM + SUTbUPDYEBfRjSmGMOV1hamIFlyAeOEFwA5jghZZ1wfVi9JwaE429s/KxOH8NByZ4cLhaUGUT/di3/pc + xA4/L32LHwU6q2IkDvY3guOY6VsfVqiZQVQmBZzsyDHJT45H98ym4MgVeK6gJVbSzJbgZEu3FGpOAZwk + 9sydjh5Dp+OTo2dibyVXvqLqgO10TE53lEZ1BYsTQmssJ3yyT/t6ET44KU+Wp5OB2kzbhI01TCYjInxx + 5XDFm5WS/dMzOXp78JvByZNMHONxq1YmZOfeRoHDTJiT5flkQAFN7yWC4pUyidYJpApxnVbw3gEtIiiq + sKiTaTsKgOD2vK26gvh2SJanzuBqZY9R0iaHGx8G1MI5b+wiHKrhajL7/LF5OWnY2i3MMwVZhoTle/xk + vgiwInwky9PJwBrFNknhSLYiDH7k1sV4vZyaDtIvT0P754o6864+T5gmeafwnzturfxMxUcpFKoPAPaP + pSLNSlsemo9z6KNl2GIVrgwkr0rwSb1QaKfQNYQCJtMF0tYS13YIbsSoFfJu0n6G5umYoVFAaP4kghHV + 3c9TfzDyH6nDH47bgFYKFPLeDy/dh/NGTElaZp3B8qPZQQOjO4jg1Cb/5fjF8jOC2dvDaGcZQdiEkIxa + f162WwSLfPU7kOyZnUHhaLKtOcH7aRmrU1D2kYSg9O8DSa6fL3gVPW6VMh4pdTFExqcR0+TdpqPbULZf + 23SAmmSsRyUTWKemro+py3cBmkYoCcY2QJAYJhnFNj9G8kMhfOxsnDtU8ieC/f1L9yAmdaLOqLVuThFy + jwlr38QnxuTp8z82coZpt6PW4Jyxc5UQVEJO65rOWOWdSTBQO4jtMsk7dYaSDlJe7BMk4XRf+k+v4dJ+ + VBtF+hUh76x+PYZJ/5Hvhe8Xi7FHhFwuMl7+5+fRS9I/yjY1WvIxbLLJg3wPtT5upWbHfHz2Z8tR2WK0 + g050/NV+oJFP5FjRbu2X8eUTY9i/ZezkM98G1AS84okNUozyX2rHS3k2231M5ZZTBAk8mnFqOFjKQLGY + dUTK5b9kLFKCPUmeOoPlk/OnNdC2ItBw+XJPmueeSPm8I+Rdo1zMT7THtqhVU9du/TfnEvTVkiRPncFF + EP/Dq+VW8l/5f6u8q4ZhluMTyR/JjLbfPIbDmdmIBMIi7+WgPCOMeHAQanyBpIQEkZi/H870oS5jIOoy + L0G924/6798it03+rJNF0sRTBV+YBaM+Hw4+pE4vUXAh4kUpaC/qLcIABYY+iBVwZVKEgG2jgFilVLhp + 7Fw9idFDsK2q4uAUIA2VqzJk5XTik+gEgoTauaool5dYmL8EzUPGosbTH7UuH6oyg2hy9VfVe5pu0F8E + TS+opq9+BXyO5oSDU4NGAgkZnyWJQU/bmmzpl6Qq7AZDnpaF/eo4lf4tat2ZKLncj8ZlLmD7/wKFOTKO + kFxgRA1qShhywoT8NCYZSjZKGLMAAP/0SURBVD6QhCBsYkKdXW4iUUFyQrZb+gnkv0XpiG7woHaFCyWz + vNid78f+6S5UTMtQE47i6T6ULv4u6rY/BcZ/ZyxyfgQ5KSdTr5NWMu0fBoeX7wR7/CEhwPGH3wX6RHh5 + fwPOVRVsmaBRHZZbgoJqApygJdLfJbpTUJGJ6TkiZPoeWinZoQ+Mo5pkSfN8EmCc+cBD9ipZ7iJ1BsjQ + ed2pYsvJY5I8nQzOGTpZJtbTQMebFLJ6iVDzpZ8vEGGp/aizwPcQKsDqd4IkBaymxoj133fMk4nufPS8 + 5dTfj8QRVZ17jZqL6554WR7JPmO+Uyc0+ZO8aX9jHgWxqBG8+d87Zr6S9JknBdpo07FcQugZPRefGDsL + xTWcn1DY7JSXd4OoURNnfjnpTWgi/GTe66CTyKR5Ogl8ZNRsJeYoGPaS9vifdy7DqyV1Ikd0yccpgOGf + WW/at1kPtsr7qKkFUmYL8BEKjRSGVMOBYQ3lmGXKFWQpU64AkgRSzRT2eZ5PwCYmOggLW2jrAE22RDg1 + RKYR+jo0sAhJp/PNMfmvqMYEIkb74bdLd+uzk5XZMRi9HP9z10pUU2tBxrGOcmOdkRBLHL8l2I5btVzU + 14Hg4SWHJV8iaA7vNO69BWjaMm1zidyKPtY4j5OxlGQHyd7oaWh/pwoRYltirdbTG47gc3csQo+xK+x6 + oU8DqbtcmyCQOqEwbvwjkKyS96NpQ9f6PEl0G0J/E9QGmKtmCgQjGtEsSMMw0wmrPPOcYYtwjrSDBxfR + Iaa0U2ooxbnanOSdTgZyL35Hfr/qdRn7KfTTBI8OP9lupS2SOElo9fC9h85UgkGJiSF5x7xLMhgtB+6z + TbO8lki5cUySvjE0H92G50nfkPMkJyiwyvMCv1qFvXXMm8ztY7Au/vM6OUctIfm/aihJP6HmxWiSNtNs + bZOZ+Myd81BP8yWSDBxLu75rEvD7p2O2ft/NWPxqRaulTjhpStOlPR8H6eOX/X0TqAnExWj2TR3PE21c + 9989jIaYyV9ijN1dG7XUDEiJzCR56gx5j+w/r0VMyoR9WMtEtsbpNN/9+GeeFOyx0/Rvk1bcCIsRjE6o + /CR/nkeeR5vkz5Dbne59IuSl/K/1+RdQln0pil1paKSJvvdiNPkvQo3bo/PwtyImiJbAQDXpqHSFRD4c + hMY/PCa3TfKcd4GkiacK2r2qemas3orvuEom/ueL8NAPcUbqYMhQCgoF/YxjzI0Xom3bIESq59tqN7yH + UYnmCn/Xezs4ObSRfODqjK2eG7FXDsxHUzrXvj1Wzd//jrJrr0eNN6TOUKhWz3AyDRQCM7PVDulIiOE+ + A9JwCblOGmlJphEiHTh4t6jiVgZEbhMEBbVy6ECzwZeNcpp40LGmPwPVWdIGswahyhtGhWcQmu4PADtS + EC30IbqpnyEZ1qcBW1M0JLEhQTuRE0pIcEvtCUb66CPXS1qhC+2FaYjJdbGNXjSu8qBkdrqabhycEULZ + 5HSUz/DhCImJGWHUbXoA8YbXpQ/J+MQPajsd9Bpbd/NxkPGLfU4Z8Q85+CHXcZ2kgCkvrvrRIZnnoWWq + 0k8HZuooLJfmF8ahGbenBTpJlI+4TESGTt0pWZJ6Ysg6rqRI3o7L70mCE4rvP71e8s7JwjK1qSdUjVYm + gEnzdBLoTgd/6gjTvANJm+/8i74ZTk/+3wlsz2ZSZiY6FfWt1sd/Lu9GwW6s1F+SPJ8M6M1fBVd5T2pO + JIgFbTfRE9AMidmkl0zyjKalmeTxHrfn70j6zJOBhkykYzma7txMR3tz8d+j5+Ng6VENjVMG35XzJc2/ + fJNjbdbds7eKkJOXNE8nA2vIbGMLL0K2NWw2PnrbErxZyWg1fO6pz68SRB8jxlDjlVpSiXJhH//Niv34 + xMjn5NnzcY4I5BSm6NBVyTyay6gQJm1b+g8FK0NScHWZZNwcFeq6S5snOgttCaKCwm53uR9XqEm+sC2p + YESBTgRihhV9ev1hNEpe1AF6O8mrduvRFXvkWhEak5RZZ9DR5v/esxTVrRzTjQAWaZW6omBCX2j2u74V + tP+ooGX2KYQ9snif1AfDP9JJb/LnJsBymlF4RG5l1NI5J+a8jfdKCDP/Vsi8knnh+716sB6X//F5KXcZ + s8YKcqfjHGrC5Mp7kKjQepUthWuOj6zrTnX6btCNZjskDqlVRv81HC85FstzSFKo5gwjtoxcKX1hGu7L + WyfZJkkU7yACTwUkvLQepH09u/aI8aFx+1L0GDZV2qS84xgZP/ie0l7ZLjsINpITRJf36Qp1IKu+KaRN + 6zdF3o/3k/1uUsb0Y0FCLqFR8YOn1uFIk028S1th3Qz4s9QJy57hfMcuMmZQN89Hz+GzcM5IjgtyLM/5 + +G1LUVkv/+tslv8OiNMHh3wbItFmfSbL9JWKOuu82+V5o955/DondzaueuwlJUs5BtIEQ+U+kh6nQTPN + +F2KWNFIk9YT87i7rtn6j9vY908sf5dI+VH7wphfRK14G+8paDsN8qmai0Sk/Jo0byyHI41R65N3SF2N + fOf8MTLYgN+9gGiU5Wb7W2LEG5Iykpb0mZ2gddxcb1V98ybUM4JiwIuS8ACUcPE5lFxzQuft9j4XCukz + 8PDATDR6v4qqbaZ/nQ4kTTxVaMcg+1bzgoVNbhEELgBoxy3CAaNz6Kom7cNp5lGUgfZNfdH6qgdo2mg+ + 0K0CaVR6HwenhpghfNgII1K2amtNh0Yb16Ll0d+j9vKrcCQ0GCW+gUpI1ISDqAz6dTW7PHiRRnCgOUdd + IKRhKblP1XsN4xlyzDocnBroRDURISRBUnDQU0eodLDqugQtMlDWhjkI+pSUaPTnoDllAKovCaJxoYwl + O/oispW+JmSMkXGlfUs/xDb3ljHHZxMTNjqTEpsvFMi4VCj7W1PQWpCCutUuVMz148hUPw5P9aB4pgd1 + 09w4MsOH/TP9KHlpGBrKX5L+YwRDYxpVY8Ysm/yLxbgaYwS5E/m4n/Vgmeg+yQlO6GVfJx9R69YZ22Ti + SPLgqLChoKopcQKTt3dCz+HTjPrr0JnI31ouWWKdSf3ww63mg53y+m4g7eDRxbtNXqmKOYSCkkyGRSg8 + t/M7vUv0UDthQwKYSfY8TN98WCcjfHbSPJ1GGO0MEtki0EqdNbRErP/8KQWN2ZIfrn4nz/cJQ4ROhnvk + avp1T6yXV5LJvpJH8t3SVa/j83QMdEImoMmilocIHZJn3ucns3Ykf+ZJQENejpgs+aRgJe87ZgE+duci + 7KltV8EkaZ5OAppXLWNpkzoZ56Q8av10zmsirJ+68GbUf1lPIriJkHjeyLnYW9Nm6vU0kBMJbQIjKEv+ + pU+x7HXsizVo+rItJch+SPLDssxdgu63ciV9LnrdImVKx3nsOyQThttO/2S/G81uKNB2eR+OEwnw+Jxh + U4yDRI4juSK4UfAVIfSTUmeX/nUTivbUSjZNXpRMbjOaKn9YuVsEWanXLvfvivOGTceXf7YI9bTFt1Xd + qU3Edz6R+SnVrPW5rNt2Cg3N1mOLX5Nnz1RSJdkzj4GUzYTCYnV4p2XKNi711hZvt+dy/17o2C55Yt5I + +jZF2q0n1uxDvweWyvjHKEbyDqxLNXGbrcJULwrFMh6fSy2XZO98ElBym4I5ySv9Xgj4TDnX0X5Us2Ap + vnDvajyz4YiOMQxBasaLU4MJ9ck+a4TzKduqkf7LVVK/1IyR5w41WmHq22FIvskn85fQJOr0LkmhBPcC + Y94xNF/NQ84dZZvKaDSSBepE9H9+sgS/nPeKRiJRHycUyuX9uFB80V9ekGvkucwPiRxqTQxfruNLT6bx + OWPmqKPfg+UtHb5NtL29AxL1b77rAinXPaXV1qdunWM0trq+Txd8VNrE1X96QeuE5Ugtbt6Txy06Lp4a + 1O8X78P+p9s260hlvfXpW+fiHProSJKnzmAbvfj3q2Ro4/2YP44DZryLnob8dZSdmp3INtpmVda1WJ+7 + bb4dgSh5vhLoKf0p59E18hk0pKVxvG78ekV5767P64IWvT5qRfPmotY1EEeyfOrY3szLMztIiGSgDFiZ + lSlyYxDlcm3b6J/LK5y6H68EkiaeKvRD1SYfrd23iYAgAgHVqzfRGaYHMTqj6yAnBJtDRljY5Efj9mvQ + 2rBTGqcUmFSWTji63NvByYGDE1e+OHBGZAIU21qIunt/gZIBl6Dc70ezOwe1boaQlIYmDa6CTi8Dg1RY + rBBhsEEaYKMvEw1uabCeoDbKmnCOCpIUIDsLmg4cnCyoHVHjNYQXj2nSkTDr4LY8eKm0uTBKgwFpc351 + vqMRYlwulHoycfCeFBlj3Ii90g+RwjRgSzqim/sa8zElJxKaEhxr5Fodfzj2yBik41IGatf0QcnSNBya + 7cbBSR6UTPWieFYG9s/prQ4wi1d8GzX78mXgJfFgNI50jNPVBQoU5sPQ+SNNbQpNs/vhhxZSFjqB0XKy + V7cpFEVarPnby9CTq0EyQTrq4MmeYOoks8vxu8GYl+T+S/CZO5Zif7OMg6yj9kYNkWfqzs7nu4VMejYe + bFW1WFW7pV09V6lHrJbJaZL8nCR6DJVJyKgVIoyJMDd0Mj7300WobLEFFVWp7ZKf0w0uMkidsazist8g + E1dOtntx1Zdq6UnyfHKQybVM3HsOn4Ov/22tNBczMW2X9nFCarP0ocR6tL2dx2RSrn1T6vn2qZuSPO/k + 0GuYCAXqBV/qdSwduC7Gx0fMQVkVCa765Hk6CWheFbyfWXlk2q3zD8jzlxyXn5MGzR6GinAk+T93zEJ8 + RAS13dVSRlI+p8PnhAre0p/Zx9VMlCEgJa3NnmjHIqzPqFXRCuvn+dvxKWm/uhKsflmkn5Bw4+o6hTau + eA8TQVPaRE8RxjT8YyeCrzMpoWQEV4PHvCjvRrKDJIdg2ByEHl6FZ9buha6Mi8CcaFPaRqS/snwfmL+9 + w9b+bTF2NT75k9WoUC04mfzbIa8TZhrJy6QTWCYsowjJNgoPcevXS/ZKniWvCR81bwcpl0lbq1SjiKrb + RsiStpIQRLo+731GM1jf0k9Vi8Qel6IRq7qRGiJ7ccEvV+JjY0UQpzCuZizU/hLImN8hGJ8COnw45MqW + aWwfJLqkfZCcoPlEfxEuH166B6/WMs+S15jRHOJ4luydTgr6PWPknmaZX0t9iNxSXCdjz4xX8IU7p5v8 + STtWTYfbVkr+bM0OySt93nR+l6Swr1HtJ9nqN5LkAjVFRi/Ff4yYgUv/sg5rdleCc3wdTxiFRNqd9nF5 + x4t/uxIfHZaPj5GkpDmVmnawDvLM/W9jX5yFXoItByq037Cdnsj8hdeyL6iA28br4xZ92qhGy62rJc+d + 2nIyjFqMwY8Xmr7K+0TMPQhNO0WwTJSgYJ+lxoNs99VGrJ4kMTXST5I8dcaYFQj9eYP2P+ZP+7/UMev6 + RMjJdwLvYUwnZQ6p945YhxrbrXPUP88JlN+Ypch49GWte+YvplpdxqnoiZUf+4OMTdEmq+zeh2RufRFa + 00UWFzmPDuoTRERivp44TqApwy8yYyaqbvghUL5P7sOxKdlzTh5JE08VOlmoWmHFtwRFKEhTnxNxqlwX + uBG3PeKbFU4REtanSBq1Kig89EHbnu8AbWUWbbl1YpTk/g5OBlIX0ljbC9aj8c57UR++DA3pYdT6g6gO + B1FOQTAwQEPHVHvCIvwFUKvMWRh1rmwcCoVVtb42nKPCooaUDErDlIbKEJOJRuvAwbsB2xQHOdXE8RnH + mMrICphOJ5kMP0pygmZFFb4gasLGM3Cptz8OXeJF/JmQjCXpiBT1kbHFg5iMLfRvY/xJdNaYkLTNMhZt + cCPykh8tz/tRNSeM/dMC2DPVr6FBK2amo3Rmmjq/PLTiGrTs+peMR2/ImGYm4DoZUS0Jxvc3zh0TiIqg + lAiFZfreO3/cz3bQCZwRhDgO2ZMnTmRkW14Xtf7j9pUwodG40iUTLk5YdfJmg/unAp0U5+O6v65BgzxT + Q21yZYl1pKuapwbWe7UILr0fWITuN09RVXxrCCMSLAdj7yfN00mAtsK0T2dYxk/mTsUNf18PdeYpz1VT + gE55eW8gQpDUYasIIZwAlTbDOvcnrKc5tjZH8nyfMEauUFMJrjJ+/e8b0dBqJn0q5JwIOaGaE2bfCBv2 + 5DbSYv1smm1ucypQ/yEzJZ+2T4Oh0/A/Y+dgb2n9aZk8a17pqI0qzdImeU9u755ViE8OmZA8TycDFQal + /YgQ0OOWqfjk6NnYeahC1ai1jE8R2p9p0iF9if2cx22cbzCdfQx0Ekwh1ly/+0gj7pr5Kj57xxx8TPrH + x3LzdIWQYVpVACMhKflV1XOqq5O0sAW1DmKCpIS0GV6vxBavl3538e/XYGpRKapa26UtcJIcteo0H8bU + pEn3zTj+m5V7TV9NVmadcM4tk/Dlu5egpJ73k7rSe8j7nkgYSkKf3daxQNQs218v2KVt6TxpS8me2Rmf + GjIReet2ya0MqaLfFxIB8h4aMr/zs/4NMEKllE1bs22GLWWk30emR6xy6ZMzCg7jB0+9jC/+VOqUK/d0 + 0konjqdBM8gaJQJ/Lu+1FBQ4uw+Zhk8MnYABv1uD25aUoWhfmbb1o5ondAZvfwdOA7mr2lO8j63J1qbC + WZ1qVW6uAEgyuu4Rwf+Hz6hGnYbwlO8cQ4lSiyTpO3VCz7GypYYJ2wPfT76JPW6ags+NycNljxdgxq52 + 6LvIuJcYB83CiCHPGP4157FCdL9F2pua1Mj9qHUh9dCTpFHCxOaWaThv9Bws3bob7DN6rxP4vqg2pCJq + tUhds42+UlKFj9NsIneGyffb4JyhE3HNX19Gvfp0SYDl2WC2XZ53sjCOek0eW2QOQt97b1bWWsyfNfyd + v8+9hkzCxX9ag0b57inJwfvS1wz9lWh7P/Z5J4sOHzICLphQdt5T22j9520yHxr2zvnrKW0965FVaGi2 + TTq0/Jrte54AUSDtlGWuGhSN1VbV2HtRlf1VlNIXHDWXZQ6emKsnCAmC83bKhFXZl6Dye7nAm69r3pM+ + 410iaeKpgg7Pmg5JhjdSdVqEhm2CAtkvzDDkBM05NqaIACGCA73li0DRRsGBq5nrXIi9cqOMcXs6PmgO + TgFbNqPq/l+hIvsyNHqDqAp7UZwpQllwABoyBkujE6HQH1CzDa5Qk4ggYVHlzRShUBpgaAAqRDgslwbJ + eLZVQSNMUtNCTTw6CZoOHJwsSqT9JcgumndQnYyEhO4LSjN9aPIN1LbZEBiEWr8f1TTt8PA/A1CfMgil + owOIr09FfMtXgPVeGU98qkURp8kGNSfUrEPGl4JURNeloXGVC+Xz3Dg0w42SqX1Rku/DwTwfSmaloHJ2 + P+ybmImDs+8C9m0/KoAk1AJlIOeHX1fdOSmRNBONwnxIdWKQmDQmPmYfaiRCgwlk8pJQI9RVRzle8lot + pq3fj0kv78XUDQcwecN+TN4kW8GkjfsxZeOBU8LUgiP41/pS7Nh7WL4pRvOFdZXQKEue5xOHvpvcd+au + JszYXCqCxF5MKDiEcRsrZPtG0jydDKaKYML7PV1UgX++fBjbD0uLJLnCyUyXvLwXoCMw047lmRRCm6us + p7bV47mNJZi+YV/SPJ8MJmw4gilS///aUI5lb9TKu1VZERH8WD8U5pLl6RjI5EoFZEGCnFDBVMpoSTFM + e3obJMtTZ0woqMNzmw5iIt/15d2YtKUST22QKX9ziwo8x+XnZMFxg+SE9AtOLJujInhG66wN+8vx1Kby + pHk6GczYtAfTNuzCuE2HMH5zGf5RKOJUa60K16ej/XP8M+XPiXCrmo5qe5H30vbJOqGZjpaVCIgycaaw + sKsW1l9fLMfVT+9B7/uex7kjjH8JVXknqKI/3NacUJONhFNBCldz0WvsYvzHT1fhosfW4/75r2Pt7lLQ + MSfHZubHTNT5XPb5VouR43TcZn5EeH7jiNTrhoNJy6wzJkq5PVMk4prkm+ryfCfjSJx45/pXPxHyvsyP + mgHKWPH6kWb8fVOljnvJntkZf9/QhJJqeYd2YyKjxB2/L5KHDmHp3wnmwSYjju2zcZm/y/tyVVau4fu/ + WdFkTd6wF7fO2oqsP6zCp+86Ac2Bd8C5w/Lx+TsXIvzI8/jRuM342/MHsOlwE+oYQYJ9SvNoiAOTVzqw + TpAq5pt9aoiqaRbfO9H2TRQfW5tStgfrWq0ZRaUYPmUbfI+8gP+8daFqD9F8Kdk7HQOaQrEvjFqAj906 + HwP+tBa/XPQGnt9VaWsGsX1TSDbCqZrEUTiNSz9j+4+UWfmvV2H81lqMX38Az8hYNnmzjLkbinVcmLpu + HyavOyjf3go8ua4eNeUleh9tW3wffce3gZSh+mKxy4D9vb2hxnpqYw0mF5QmbdOdwe/I4p01kv1Gi6aK + fCe9jy00J33mycCuexKnprzkuKXO+ueGakzcWJw0T50xQcbgea9VSxE3alviPcy4KffR782pQu4j43+C + vFTtiViT9a9NtZh8QvkrxZxXZHyK1ampF/PX4auRbaHjOcmhhK3df7V86qqt2BOPo3rwV1GalaOyXmKu + zv3EoiGJiYbsQWh65CHEaw5qm6E5kGqm2vc+VSRNPGU0llmxwpAhITrbfCdDAYWICxHd0hvtmz16HNvy + ZcRe/yFQUaQVRnYuQptXViQbLRsFG5w+jx88CgMcEAy0U3bOzxkMdghj224Gee0Y9iDYph89Dg6cjMl5 + KReWibKZr25B3d2/PEYQdODgbEO9K6iOXCv+NgDRAhlvttrk52ZqZQXV6W7rehfqVntQusCDI/luHJrm + wpFpGSjJk21eBvbNzcCBRX6UT5CB+PYwKi8JoWbwNWj5Vi6aHvwb2hetBqoqpV/F7Q/n0T6oW4GZCNvH + dOQn++y71Lg4Rv3WTtdrZct9Pe4EQ3CcPWOYAwcOHCQDJ7WVTRGr6EAN8jYdwCMieA2ftBVf/8dmXPrY + RmT96SUMemwtrvnnRgydsgUPzn8VE17eh/V7q3GoIfk9HXzwQUG0qanJWru/CfO2leIfq97E/bO3Yfjk + Qtzw1CZc9tcNIoi/jP5/2YiBf1mHy/62Ft9+ap2c34j7F2zHEy/tw4QtJdixp1gj5yT8zHR+hmrrdUl7 + v8H2rSGfbRmFBNqhqmbr+Z2HMf2lnfjFwoMYNe0VebdNuPyvazH4j89j8B/W4GuPv4z/e3oL7srbjMdW + voElO0uxp7rZMiEsOZ8wxEeyZzpwcKJImERy3krZUQkKkhtv7rWqJ85G07e+h9LBl6A8EEKDz6+kRNm3 + bkTdP/4O7NqR9J6nC0kTTxm1hVZ8s0894CclJDpDBApqU9D0o73AD2wKCb6ClqIURN/4FuJyL10pksLj + iorGiqYAIJP7o9E9iGPJibNmcq8rK4YVVXaKzKS8WwvLQQY6OiFSkoaEDVWj9u+ymv/8GMovugqHHJ8Q + Ds5yNAUG4KA7E2XX+1A9V9Je6ov651NRv8aL8tVpOLLAjdI5bhRPd6mTy8MzAjgyK6zgftmsAErGZeHI + 3SEUf80lg7BHtTTUOac3jPJMPyoys1Bz5fVo+8n9iE+fg/jO1xBradR+FwGdD8Vk264rR9oXSTywP9JO + OaHiqhMlmjPQXwUJCxmnuNL3NmPVWTOGOXDgwMHb4OhYZ8/jdDFGQKGTcx5uOa4SHFNJAOsKtfm/gzML + rO8YF9T023g8ElohXJHv0PDRrdQ5V79pVhOPWM1ynt9czo15TxISH6TvpuZL9833n1vml5qDahJCkxgu + MNrpXPxQrT4SGpJGLR2d9/PdOYfQRUjj/4faAMme6cDBiUJlaGpY2PPUZjlmJBvVhIs0Wu1t0tb2Hrai + 64rQum4jWvbt0sgsJDGUyHgPkTTxlFEy3tIwobT3TkZIdMamNPVHESnqh1hBX2CjR9Iy5L/nI1r4v2jf + kg1ULJEClPsSHLykU2qHV5WmowNZZ3CA+iANUu8eER3E+b5m8LJXYlkO0qCYRocq8dZ6q3bWFFRfcR2a + 0wKoD2ShOTgwqUDnwMHZgkp/CKXBkDpsrbk9ByXz3SiZcT72zXBhT34KqiZ6UDbNg8N5LhzMz0DJTDcq + Z/rkGj/2T/GhemwAFVemoirDhXp3f9RInynzBFHq9aMyK1sdwpI1Lsm0TZgyMlGWdQlqhw9F5O+/Q9v2 + V4GaahmTSDzYEy4d3ElCyAAvYxMnVxEZ9FXNk2SjTq6k/7IPd/Rzg85j1tkxfjlw4MDBW4FjZReopmgC + VFFv0bGTQlpCgKMWm4Ym7riPAwcOHDg4W5A08VQR238XjI13EjLiOKSqL4rolhREC78CbOor8Mp/A7Kl + t/2voJX3OfiEfLeMWnW03YSDMkyqISeOJyjsD90xaWce1IaI+0rO8P1plyWCjgg2ypxy9eDltaj+8TCN + elCXTSeD9LSag2Kf47DSwdmNKmnntZl+1HkyUZsVRtmfQyien4L9s1NxIC8Dh2en4fDcFBya30eQitJp + PlT+LoyKHwVQNiDDONikjwvvQLmHiRJCUoKaE4zhXOe7CDWSTl8YzdKvmoIh1PgC6qelNizPD2Wi8vpv + ofqh36Bl9ctALT1305szV0Saj656ENJnOU61xY2mBSfYJv0oCfFBW/lx4MCBg/cDHBsTK+VcjNEFqASB + y3HSvs4QGFEBVds7pztw4MCBg7MBSRNPFdHXbwSK+gEFri5ERBIwpKhs24vciBZ6EC1IRayATjIz1F48 + UmRH8tjUD5G9dwCRg8qet6DRTPw7o+sH7CwgJ/iuRo3R7KundhVoIlbrob1Wy8MP4EjmRYi4+6umBMMr + 1gcHqUo6o250FeYcODir4LtUYyyrZ2F/Dkpu9OLg9P6omhNEVV42ivP8ODw+E0d+NwBHRg9A2VUMkRtA + dUZQCY1K3wA5zlFnr9WB/qjx5aBWtnUhOuD0y/FAva+G2Q2GlYzgdQy3W+kdhLaMHLTxPx6/3rfumuvR + ct+vEV2wGthXatHsQyfZnHBL31UiVY6p/RQDVwXbbYeadr/mtQ4cOHDwIcBxC0tq/0xy1szf1IxXNSSO + zuUS1x/zPwcOHDhwcNYgaeIpY8d1QGFvgft4MqIraMJReD7oFFMJiiKGBOxnNCm2yD0K+qGNoUcJOrx7 + 9ftA7YsdKn5v9eFKfNw68nSGIkZ/G/IecdpYxo1KY6ylwYrPmYXyq7+JercfjZkDURkchHJ/fyNEhfyo + CgRR7REkE+gcODhLwBCjlQGzz/C35XJ84JtBFA/1ouomPyq/PghlF4dRFpZ9f0CjgmjEGX826qS/kHxo + 8WSjxRuQe4RMpBqNSCP/CbqkXw1AVThHNSn4DHorrpDnqMfi0AAUh3JQYT+7yR/W+NA8XxYegLqLrkbb + T+5F+6wZaC/fp0SF9mvbvs84H7LBCbkz2XbgwMGHCTTd4DzNHvsS8zqCc52O8VHHSJnfUZOicxqvceDA + gQMHZxWSJp4ytn4D2HyBkg1JCYnOKAwA2xhm9MuCvsCWPqo5EdvsRnwztS8CiMi9IkUMSyrXbzwf2JoD + HH4SdIoTa6cadYs81xARnZn4jpB+ZzIYU1fejV5VGS8br+xA5M4HUesdjJpQWNXNi7P64wBXdcNZaMiU + tIAPNZnZKMlyfE44OLtRmelGbZBhcIOocwfRFr4czf1yUO4Loz4thEaPbF1B1LoCaHBnKhHR6DP/Lc/s + jwbfACUcSFzUBQKoCgVQEgpp+Nw2Tw4awkFUSn8q8/mUkKgL5qjJVC3vIX2v1h+UvpaJCul35X6/Rg5p + 9PdHdSgHR0JyvTeg5lbVg65E1ajb0TgrHyg+IH2aTrCkf3fSmlANCtvEQ33mdB4HHDhw4OCsQ2IRSeY5 + GprZ9stjo0XOEfTZQx8TjH7ECGVRdURsk70OHDhw4OCsQtLEU8aWbyO2mdoQnuPJiC6IbPYZrYgNLmAj + fUz0A51kYpP8t7CPbfaRjvYt6XJPSS8kYXE+2grDwK4RaI1UKkFhNCi65sUQFmc0YlxBkPeINVstc2ej + 7JobUOOy7d59shWhjAIVUe/NQoNrgAhDg0U4GiiCkWPW4eDsRqN3kJIG1HSoyLwIFV6aaDAWcxDVgQEo + C2XJcbaiIpiFCjtOc4PPkBSlSj5QI2KgbHPknpmG7PBno9w/QO9bJ/skMWrl3hX+/vY9M1EZ9KNW/lvh + zVQyg4QETUJIRpA0rJPn1fkGqTZGeRYj52QqoVHx1etQd/cDiOTNQG1l1VGCopP2hENOOHDg4GyHMXF7 + a6jPiQ5tCZkHtceseDyqXuY1DB6vceDAgQMHZxWSJp4ydt6AtqJ+GoUjGSFxWlF0KVA8UYV344OCgrxs + dZIvHzH9qAkSHzg5H0eLxfB/x/ms+DeA+WNe6ESvjXlkujp74koBP9ARCwdfsxrvvceooYsQdCQzW1XN + 1WaeQpIKY1Q1N+rmxj4+C2UivNFGPoFKaleoINcpxKjazxuVdQpavH+NP6xQ8sM+VsFKkHgO75Xsfolj + sxp9NH/mWgM+hwIfYe5vwPQEEvfpmp74XwJUp68NiDAoSOSRz6oIBVXFvzozgMPhTBzJGoTqsAivVMvP + ztRVbvoKYDnRGWKjR/Iswib/SyGUgipXx3mOqv81ci0dJ2p++Ex/EPU+EWz9AUmTY66iSzmqSYCAafVy + HVfjmTf+n/dl9Aem13vlXp4Bct6s+lcGg8angZShPkeur/b2N+8o750oo0S5aBkLOurRwRmJ2sFXoPHu + u9G2ZgXaqivNhNweszTMEx1k2tpTHCOYxq2Oc4lQe4lrNY1jR1S1xjiudB1vHDhw4MCBAwcOHDj4oCJp + 4qkiXnit+oxA0XtPTjD8aHyrC/E9wxGvK9Dnc4LP8JrGFIITdkmjMzoNR0VIOj3iU4WwU77/PZA8MG8J + YkKO1QlULGbF2mU7bx5qrvsRKlNFoBYhm8IzhVeu9jYFBhhBmUKwpNWLcFwngjGREH46hPhOAj7TOwu5 + naEkQidCozwzx6z8CmhbT/DZXCkmEvfXZ3C1mPvy/PpQjqJV0ohmAe3xGeI0kQcK1++UJzo7JEgqKOli + bwn1HxAaqFoiXCWv9Yuw7xugavdNIty3yHEs3YdmP30BhNHqCaHJ5UV9OKQmMOo/IORXIqEiMBgNnoFy + Dz9KM32qkVIa9qMsFFSig+QBfRIQVSHz/4pMro6TQMhU0oEr7ryuXO5fGTbaLLVB2UqZVPkGCy6SPA9A + VaY8L0uuEyQIDSWT7BV5muvUSz00UivGLgeCZZQor87l5uDMBcm6Jr8xL6m6/Ho03P8rRJYvR3tZsYwF + DBtsE5hxm5Tg6mGrjAvxdqtFI36Y84mVxoS9dgfJwa0DBw4cOHDgwIEDB2cAkiaeKurXXQsUpZqIHUkI + hdOKoj5o3/K/iBV+Ae3bwsCBfwHNtEk0q4nNsVaZqHPl0awmxmRy3zFxp4ZFp3y/3yBBwjwyrwnNjpao + EThQXmJFfvN7EZAvQZk3C01ZXGUPqKlGbeYAlMiWq+/HCjpGiKXdO68jOquzUxinWnmN3I//bfDwf0e1 + ITprWFQEQij3B1XwNiv9/I+tDi/CFMF9JSrk2dTSoI39AXnWbn8IO71+vOL2otAVQoE7hE2eENZ5wnhR + ts97gljpDSgWeX2KhR4vFrg9ivkuN+Z5PIpFrqNYLPdb6vJimduH5R6/4vmMDLyY4cLLGW5skPMFcp8t + Hp9im1z3imcgXgn1x2vBEA7Le5XJs8u8YZQG+muUBpITJDpIarB8m4NpaPcGEZeyawv1Q1SubZX3V/JB + 3pXvy+gN1d4BqvlQHDbvzzSN7EASwk+SY5De05RPlhJLJCPKM6mdQd8EUp6uwagJ5oB+DPT5UqZKVkh+ + tPzp7FHqzzhxNHXcQUxIPRKd69/BmQfWe7H0vUNhD2qzA2hhvdPc5JvfR/TRP6Nxy3oZuuplTIhaTbaW + hI5fOmZwLKPdtU3ARmXMUxLWELOtcfrisa914MCBAwcOHDhw4OADjqSJp4qKF78DaAhQ24nlewgNNarP + 6of4unTEiyR9zw1A5XKZvLfqpJ0ri61xhvSTSbw9keck/oNg1kFBIt7WLNuI1Sb5oofq9sKtqPzOj1Ug + JdFQkpOJar8ILhl+FXSLw2bFXgUce+WdoRDLRVAmuPqeMHE4FscKRlzRJ8lA0oEmIoZ4yFGNjGa/AYXu + Mkk/IEL6G5KXLT4/1nl9WONxY4UrHbMkPd8dxHSXH5PSPJiY6sXEdB+eE0yQ/D6X4VKMT3djXJpL8Sy3 + PBZMSDuK51LlWhuJa592uTvwbMbxeM7lxfgMj97rmXQXnslIx7OuDLneYFy6H+MyMjA+tR8mp6ViqlzH + fE6Sa/O8HuS5Algkxyvlf49d/A3kXv8w7rnufvztipvx3MWj8cLgK7Bx0GV4pf8lOBAepGXWIuUQ8wYA + jx9NQRda/T60+YKqIULtEGpXVIZ8Ao8hHKT8CNXUEOFTtV9CWWgI5qA4M4iyUFgJEhIZNCeh/wMSHXR6 + qvUk594KXevUwZmFOlcOGoP0EdMfR3xelAT8RvOGfVjSGryD0PytHyP6z2eBA3t1DON4lrDFJmkRp/YV + TTxsz/dqBkLzjg+EZpgDBw4cOHDgwIEDByeGpImniiMvDkf8Ze/7ozmx0Yf2ot6IbEtHfDudaqYgtu6L + iG2X5++9F6g5bCFao+YcKvhTW0K1FCJHQ/v9OyF5idvq2RQ8GvNmoObyr6E2nK2r+/T70OwTIcWdhSYR + jinsVrlDqM8aiFI5Vy/p1ILgijuFnc7O/2gOQX8G6tPALwKPICHQ1ojgw1V7mkSUyfaQpO0O98c2EZTX + +f1Y5XFhiSsdM90ezHC5RKh3YaII+RT0SRQ8KWn/kHPjU/vgubQUTEhPFYE/Ta+bmpaBKSkG41ypGO9O + 68A4t6R1wvj0dDwn90xggtz3OfdRjJd8dIamkXTISFeMz5D7C55zpRl45H6C8e4UeXY/jPOkYJLkYYr8 + 51l51rPeEMb5wng2xY3JqRnIS+2N6WkufPuqsfjIsPmwxiyHNXYBuo9cil65c9Fz2GJJn4tPD52Bvjc/ + iwE//Au+cePDGPqt+3DbN36Of1w+GhMvHYZFA29EQfY1UoYXKcHQ5s0C3Jlo9QcQ9QZUE4NaGI2+zA7f + EepHgnUq5a+aGX6pK/q9EOG0OhxGvdRjQkMi8Z+ESUuinjsLug7OPNB8h2ZFNNVSs6QAtW7oiDMLFb4g + SrNypJ/b5wdfgdo770LzikVorSqRMYOe7A3JqlphaJXjZqsV9Ggv4wpDlnKMceDAgQMHDhw4cODgDEDS + xFPFkfW/QP0SRurwHk8mnG6s64P4Zh/aGPFjYypQ0BvYkoHo5jAim7+M6KtfBUonWog0H1WJ5sojIZP5 + ZPl/P0HCRDU4Giutxsf/oCFAGYmjNEh/DwPRGhqo9uiHvdk4EuyPluAAFXDLRJDlympC3Z/CqzG9YASD + /h2gCQCJiOrMAajIGoBi2e4NZWGnN4htGV6s9HqUhJidloJpJBnS+uKZ9H74lwj6T3ltcoEEgAj249NJ + JlDLwWhHTEoPYlp6KqZmpGOS3IPEwTifG+NCfjzXP4znBvTHjIuvRN5lX8Oca76BBd+6EYu/fxOW3jIM + y4eNwLLckVh5++2KVXfcgdV33mnw05904KWxt2Pt6Nvw4sixeD53NFYNlf/dNBSLfnATFnzvR1h4/fWY + e801mPnVyzBt4GBMzcrGNCm7aYEwZojQN07ej5oYk9P9qmHxrLzPhLTemJbRD9PkHce7XMi54S5Yo+fB + GrEaHx22ED1G5sMaNVuwQtLnynY+uo2cL+kL0V3QbfQSWGOXwbp1uezLdtRSxTkj5uGzw6bA96O/4+vf + fgRDrn8Av7t6JJ6+7BYsG3wjtmVfh32Zl2u91oSDaAp6EE3PQSwjG1Gpj8ZgQM0+qBnDSBE17os7/Igk + /EuwvklOqKmOoLOg6+DMA+uTYU/V5IrH0g7o76QuFJatH7WhQaoZRW2KCr9XtXOoTVF27Y1o/9PjaN39 + OtBYJ2OJba4WEUTNOEefFMnGHAcOHDhw4MCBAwcOPohImniqaHh9Asry/Wh6wZWcUDiNiBUFgEI/UGDC + lrZvTAfWy3ZTCmJbcxDf2AeRrRmI7R0KVL8oE3eqO8es9vZmm6D494D+JmKxmAgTEQvFB6yqO36COm8A + DSK0lntDsh0I+oE4yGMRRhtCg0UYzcZBCrAiqNAJZn0gB2WZxlEmzTaMY0oRZLnyGhyA8tAAlAQGYa83 + G1tFOH8hJR0LU1KRl5aKySKkU8PgGU8annbTFILkghsTXQFMTAtgkmBKeljJCDWdCGVi4kUXI+/6b2JJ + 7ghs+MUvsf2Pf8Srk/Pwxsx52L9kFY68vAGVO3aift8Bq6mszGqrqbXQ0GChsdFCs5R3lI78qIJOtfOI + rvZ2jmmusP2DvC14j2ir1R5psSKtbVaMaG614vXNVqyq3mo6UmrV7tqP8lffREnRehx8/gXsXrQUb86Z + gTfG/w1vPv57FIlg99Ton8Hz3WfwkREz0T13kcIatQDdRuTJdjJ6DJ+GnsPy0DM3X9JmoVvuHBvzJH0+ + egm6jVikxzxvkdQYLdsxCwWr0WP0i3K8AN1HzEWv4fn46PAZ+MzQyci46Slc9f3f4Yff+SUe+ObteOqq + 4XhxwLdxOHCZhrdskXbQ7A+iiY46bRKCQmyCiCJIRlX7jjfVcXBmoUr6daX0VZpl0dyH5lvVfh8qw8Yx + K0kLkhccD0g2MkwpHbHSHKhUxoI630VoHn47WmfNAyqqpQ/BilEzTMmKfz/56sCBAwcOHDhw4MDBiSJp + 4imjbIV1ZGoIpQveB7OOzV9GTLatm12IFKYCW+SZRelAgZwr/BLim0lcpAAb/heRbTmIlvwZ7bEjqq0Q + 0Un8+wONDtLpmMREJBKxWvLzcfibP0C1Z5AIpoPVUWI1CQm/16j0iwBSHTZq/Y0eOmaU41BAV8+rA4PU + FKDBH9IoGNSQOBzMxCvBINYGvFjhz8BkdxomZqQd1X5wuVSDYJzLYGqqS30wTAiEMf2rl2Pe97+HNT+9 + Q4T33+HNZ/+JPcuWoWz9BjTt2g1Ui/DT2mIxUgDLT81kaO+upIFt7y5pyaIHqJo5020c1V55a/D//B+R + uN9bgaYxHT5FEnnpID+kruUadTTK4xisjYeBix9ZCGvsQiUXrFFzYI2che7DZX/kCli5K/HRIQskfb4c + 2xhhY6SdToyejW4j56JH7gLBInQbscS+bo4hLPT/81TzQjUsxqyW7UqcN2wB/uumfGR85xe48prbcPug + 7+KvwUsw3evHEo9HHYduEmF0n8eHA74AimmWwzoXgZbaFIzwQCKjq7Dr4MwCzXjYh+nzheFja0MXoUr6 + NZ2tNsmYwLpm3ydBVZmVowQVCYqEU9qqoE/7f4U3G+XX34jav/wVsR1bgFhE+0WyfuXAgQMHDhw4cODA + wQcRSRNPGW0R68CLw1AztQ8OL0kDtrqBzW60b/SATjLbt/Yxjiw395NjEhgphmgoSDVbez++8XSQG73l + XnSYSc2KvmgvTEFs53fRXrFAhGxYzSrUSp5JVES50micaDKtTYVcs88oH1EwnB8n/SKgx0Qgt/1XUOil + oM7IG4lwpVoO6jm/Rc63imDepurWFLTVed3qFaj70VANH0kNCZILDHfJlVPamifU9xktw4QL5b4J2UnH + lQl1fwo0B+W6IvnfUncG8tL6qe8H+nP4lztd/S7Q18OzkqZOJAOZmDj4q1jw3R9g0x0/x4Ynn8WuhcvQ + +OYeUMuBzvTi8biGYj2mTj+gSBAfoCZMrF7rgXb46hyQ9djeftR0Js66gDV5WzW+eBcJicWwRtCc4+1A + 0mIeeoyYqxoQ3LdGEdSwWABrtNyD5EbubDnHa0lMSHruQqOJodoYi9BrzDz895CJ8H37N7j5yhH4Y+hy + TEnxGrOY1H4KrTdXKp7KSFWzGtbhBJcbk6TepqRlYGZGOpb5fFgvwmyRCKSv0fRH6pPthAIs20VzQNpH + os3IORJbiQgsCe0LNQuxzQgo9LINJqBCsJynGQnbGh0zEhXyf95D7yPtNOEzIxHhhZo7fF5dIKSgwEx0 + FcYdnF6QoGLdMOxtQyiEVk82yrMvRcVPfgqsXAg02eOU9gfp11ESdjwWcHyjFhPHMnvM0/6kfZ9jH0lH + 7jtw4MCBAwcOHDhw8N4jaeKpgqE74yUvWvtn56ByejoOL+iLeGEfYFNvoDCIls395PgCOQ4fSySQnEgQ + FIXpBp3PvxsUuBDf5EO8ICj7cr+N56N9U19EXrkUbXt+LJP3AgutDNVnJuecpMdiEeMRX00IuOVE3WgF + cNWf5yjAc58r8oi26ySf4fsMyWH+24R6IwQ0H01rW7sS9cNzRfC7GJWei0WgM6EjKRBS6KNzvAYROhjJ + odojQqFvECrCA1GT1R/14ZAII3RsmYnXvJl40eVDfnqGRqEg+UBhlqYZiYgXjJYx9aJrsWbIrdjx+8ex + J38myos2oaWyWASQJiVNVBNC3pf5Z73xHRLl8O8OtXqiiNurxEoSRc27aD3Ksb5TlNoeEatR3ufBuTvx + ydEzoRoNudO6EBFJoGYZ89Fz+Dx0Gz77KAkxYo7Rshg6U/1Q9Bi1TI7n4zy5pmcuzULkmtuWoNuo2fiP + HzyNlGt+gW9ePAR3hy7HY2lujEvpi+kZdCDqVdA5p/r0cGVgglfqNCMdU1NSMT41VR2RkqCYkCb1m5qO + 51LS9PoZrF9Jm8UwrD4fVnp92OgNYKcvEwe8WRqSstrrV9KLpAV9lXCFnqY/1QFj+kNSjGQGw84yZCzJ + sLogtXBsUsN2vMn2adqoISW6hjTlaj7NTNg2OzvuTCZQOzh9qPQZfzJKIvkDSlDRR02FZxDK/F9F5Te/ + iZa/PI62V18FyVYSd9q/4xyz2EfiSsK2SD9RTSOOX+z7ETl/hvR/Bw4cOHDgwIEDB2cHkiaeKnTlWia5 + 1a/+FaVTM3Bgegg1SzKAgr6IbEoBtnmUIEBhF3JCyYRU9Reh+6eDnNiUjvjmVES3pKCdJh8kSTZeKOmy + LeiDpq2XAuUTLLS0W22SZ3rA18k5BVwK6tR+iMmW4fm4L9cYId5E/4jJPuS8OqKT80xrkDRqWTC9VY6J + yGuvovqeh1CSfYmGC6zIpDZEWENTVoiwpxE2MrNQGgxpFA4KdrWhAagLMdJGAEd8QewUQfN5twfT0tPx + lCsd//SLUOv1quD6XKoHE93ZmH3ZDVhx693YNmkqijcXoI3O8ux36aijBPEgeaZgQkQkv9xGE070tAwE + if98UGGTESzjZh63U/NFjukUkHXW1qjC2Iq9jbjssedhDSEhMceYWdCZZTJCojNy56LbsLlKTpCMIFHB + /6ofCTnXK3c2zsmdiR7D82ANp+bEQvQYvRDnDpuCj/7gCXz6ul/j89c8hM9efi8+f+X9+H9X34evfP1u + XDHmNxjzu6ewcsqzWPfsUyh49Hd4YfhYLLjqBkzPvgiTRNgfn+HDv3wuPO0xkU00ookrDRPc6QpqxJCA + oplOIowqI5pMlOunyDmSH0t8fqz2BFDkDmOfCLIVgYGgg0VqSLCtUduBZFhziKYiJBronDGEMml3JVkm + GkyDhwJvfwWJDYLRI6p9WR3aGFXhHFTYKAv3VxSHjxemHZxekJyo99NprtSp1J2GEs7KUa2qJpchkego + t3LQFai95wG0rlsPaogpkSrbJukbSlaQPI1zHGiT8ZuRP3gs4NaBAwcOHDhw4MCBg/cBSRNPFY0CFdrb + aqyKl3+K4unZODy5L8qWeBHZkAqQfCiS/YILgc22f4hOhALJCSUoOpt5vFsw1GhhGiJbe6Nty4WI0S8F + TTyIQrcSFs0F/dC25xagYbstkBvTjoQfAzqWU98KHQJ7s7xfs2pNtKNJr1FhX7UjSG4ISHTw2tISq/Y3 + f0T1oCtR76EwmI2a4EBVqy/O9KNWhDmuRDNkKEFhsT4kwoUIgIy88YYnC+s8Qcx2e/Csy4TxfMYtgqgI + oE970/DMwIux8tZbsWf6ZDS8sgWorVInm9TuIFFCbQISDup8M5H/eLuabVAoUfONRHqn8zSHUKHlg472 + qBWNmVCspuybrTbJvx7Hm7UefrFgD867fZmaZPQanQ9rOB1cLoI1lCYYSQiJTiAZYWCbceQKdMvztgnH + cBIdi9Bj9Hyc86Nx+MQNf8Tnrv01/t+V9+MzV/0Mn7n6Xnzp2gfw9Tv/hSfzX8LWNw6ioZUEFvPId5C6 + oIPU9jYrFm+xIjVlVu0r23Bw+Qq8+dx4bHr4USz/8VDMvvgKTHEHMSndhUkul5qAaDjV9HRJy8A02/xj + fEoaxqWlY6LXi/Fpfjyb5lOTHl47KbUv5ghecKWjwOvGqx4fdvlDOBzqrw5USVyw7dH5YpMvB3S6ylCn + GtpS2izNSBhJppRmIBSEaboh7bZDm0I1KSgQGyQTqB2cPrAO6DC3Usq+WsaNqnB/rZ+SUABlmSGN7FEd + HqRptTKONAUGoOn7w9A6fQbQKGOF9nfTBtkelZRgPxJ0DrWs40EXvzkOHDhw4MCBAwcOHJxOJE08VRh1 + +kYV1ttrj1gla36Mg3kXYt8MD2oXhYCX3aAWBTZfILDJiQSSEQynAJqTxIv6ClJUg4LRPGKbUhEp6oeW + ot7ApvOB7Wlo2fIVtLziBUqetNBKwsG8RxQ0f2iQY0NYqPYEiQiqRet52adwKZN57hvNCpncH95vRf81 + CbWXfU1XN+nAsEEEh3pfEFFXJppE+CvNHIhKl1/V5+v7D1CV+gZvFkpF2HjZ58F0T29MTvFiYqox1RiX + 5sJEEUJmf/O7KPztH1C+fDlaKkTAiNEkgxoQUSuu/i6ikicDY6ZhhA31dWHvM121RCiYdIW+T0JQ+aAj + brWwPmQ/3iptju8t78/8V7bBGj65EOdSq2HECvQaswzdb56C7qMWQJ1T0kwjCSHRGT0SziwTviSIkQvV + jwT9TjAE6bkjZuFjP3oOn/z6H/HpKx/Al6++D18UUFti8Kgn8MikNdi8cx9a2yR/Uj+qPs+8SznHtS0d + Be39tU3Z55X0kjSaEbU11VtVe3fh4OrVeG3cZBT99i9YO2qMhmid0H8QnsogCSHtxRXABJcXT6ekY0J6 + Pw3zOtmdYRyjpkuaR9qT14N/pjEMbKqGVM2X8ws8LrzgDaDIH8YuabMHvYz40l+1IWg6UCNbrsjT3wnN + B4xDTvqVoClHuINgo2mSrtiLsJxMoHZw+tAYCKJW6kA1r/xZqPLKWCJjSMLvCAmlSl8WqulMV/8TwpFA + AIf7D0TDdd9G2xPPAK9vl2bWbLVKX9KxrXObtNtigpxwCAoHDhw4cODAgQMH7xWSJp4yOKmlgKtbEZYb + d1v7VgzD4dlpODAtFaWzvRDpG6AWQyEdVdJhZoKk6KQtcRo0JyJbDTGh99/oAjaRGKGJiYDXrJe8qImJ + oMCFaFE6YntGALWvmHfhRF2FdWojtB59P003hIQKkyIIUyBubauzGmfPRN23vq+rzLVBP6rCWRousNxH + 54EivGXToaAIFW4TIpArzRQs3hTBcI3LhRkZKXg6rS/G+z0ibMo2K4D8G7+FgscfQ+22LUCzrdnBPNCc + RPZJJEQozBIiyKqpCbe2gJEgGwxxZF8Xa1ftDyVVmHYGoj3eZt4tRmekdnp7s1Uv22GTNsMasVhDgZ6X + O8OYXYxdDo22MWQ2rNFLO0iIt4QSGHSEaZxh9hR8JHcOzh06Az1vmYhPfetx/Pd1j+LTV92n2hFfvvY+ + fOWan+KH9z+N2ev3oL2hRcu6o50oIcT6kf1WarcYYinhwJP553U0UzFmQ8dCI52wTqmlI9D7RtushtJi + 6/DLL+HV8eOx6RcPYvWPbsHcy76GadLOqEXxTFqaEhLjPW71T0KSgr4snk1zqVbFM24Pnva4NKzsOLmW + zjlpPrQ8JQUvpGegwOPFTl8IB/zZKPebcLWN/oEdGhPqnDXUX4RfEYaDIhQHQopkArWD04eGDA8aPAE0 + BrKUDKLmC1GtUT6yURyWsSZTxpqAierBaEB0okvSoiYrqPVXdslVqH30UUTf3CbNkuSmtC173Ev0M8Ih + Jxw4cODAgQMHDhy8l0iaeMpoi1jtIniZiW61FZWJbnv1Puvw6u9j/ywvDk4NojTfjbYX3IhvIIngtkmK + Y0081C+Fvf+uUdgf7XSGuVGesVGOef9NJCpkq/AdPS70yvmAXN8bkdeuAkry5V1qbXtsvg/NOejDwBYk + 43QgJ5N1TuTbWqzI86vRPGS0Oges8vlRHxZBTVWu6ZwwbASGoAgG6jwwhMZwFlo9F2Nbmh9zPBkiOKar + w8OJfb2Y7B6A+Vd+CwVPP4mq7QVAjHbikgclfAQi1Eapdt1uHFlSCyIhAJNwoGCrvj+YN6ITSdEh4Ep6 + 4n8J4ZemLFyl13rsIpx8IBGnJoIITbIfjTLfcatB8n1X/hb0HD5L/UWolsNImmjkoQcdVaoZxnL1I5GU + kOgKDRs6F72G5+M/fjwB/3XjP/Bf3/w9/vPrv8KXLr8fX7rmYfz3Ffcg4/8exIPPzMPrB0qlvqRu4jQH + YluxNVmkzI1mjQG1KKJKTkg/YaSYKK/h9QLWGdtdO8kNOvQkIcX+ZLReIlJPLbw3ySn7nqy/qNzLmCE1 + WS0tFVbtoV3WvnUvYNuUyVj38CNY8L0fYULWQDyX7sO0DB8mukKYnBHCVGmDdMw5Jc2DiXS8mWH8XPxT + 2qSJ+pKqhMX09FTMy3BhudeL1f4A9rqzcNCXjbLgQFSHBoqATNIiRzWFmn0kK5IL1Q5ODyqzB5hIK146 + yg2pdkt1qL+aeRiiwq9+KEpD2cYfBUmKUEg1X2pdA1EVCqDaE0Sruz/asr6GhtE/R+zlF4H2RhkL2mzH + vw4h4cCBAwcOHDhw4OC9R9LEUwZX7UWQaqFzRRGcGEZThbG616zaVUNROj0DR/LdODAzA41rLkB0HTUb + OmlPJCJ1aJhROT4VKNnRGyi6AO1bL0RkSxra5DkxPS/P3dIP7VtS0b7ZBSUweO2WC9VPBcOe1pf+Dmh+ + RYVA+meg8EeB0oTbs4X67TvQeP8DqMrujzqPxyYlslESGIBmt4lqQJv95kCOOq4rDeVgX3YOtqW7MM1H + /wHpmCj740Q4zLviGrz80K+w78WViLZVafnxOSQUVEhQwiCuESp0FV6EWCUbWL4kSpQwkXRb6D3OrMM2 + R2G+SWBAHX3GjPNIvTYhONv3S+x/YGEidbSynOJSJoJZr9ThI8NnwBq5FNaYWbBGLJTtCnS/ZSbOGzoL + PUYuUFONbicQraPb8IUajaP7yNk496aJ+Pg3/qymG1+4/A6cf8Wt+Nx19+KqO57As3NexuGSWnm+5EPq + wxAFAtlPaKdou1HiIKo+QdiGtKzt+uN/qDHBaxPpCeJI35WEBa9VLYuEiU6rPFNAMkS1Zcw1/D//q/t2 + G9LrW5useHmxVVFYgJ1z52DTn3+NVT8di/zrr8WkUFj9WUxNd6tPC40ckupXIoOON2kqMk7OjSNxYWN8 + Rj91vjnXnYFVHjc2ef14zRfS8LZlSYRpB6cXVS4TeYXmN+WBkJrX0DyMGhEkRVvdg9DgMT5DSIzS7EOj + tcj1ZVLfNd7BqMwcoD4qqoI+NPvkf1mXouS2OxBfvhDRqAktfLS/OXDgwIEDBw4cOHDw3iBp4ukEhSSu + 5HJFXgWnpt1WcdHd2J3vR9V0Dw5ODqB2USra1/VDtCAVkS0pwDaaWKQDm4KGQFDYZEMH3ir95NC69UIl + KLDJBWwIyHM9iG+WYxIjBT5gY29g5zeAmpWGBEhoSsi7NNVVW23/eBwll1ylUQ1ovlEiwgGjbDCkIm3B + VeXdk6lq1xQa6E+iUISIWSL40UHhxLR0TPAGMfvb38erk6YiUlmpQiWdOupzOpWlg+Oh7YvEil03u+th + ffbuVbBuXQprJH1NJCcdEmCoT/VBQVOPkUybi+65c9BDtsbXhKTnzkOPoTPwqet+hS9fdT8+c+UjCP34 + dxj9uwnYXLgNLa3GpMSEnyWJRWEugWPz+0GDkmvtcSve1mw1Hjlo7V+1Alue+AfW3H4XZn7jRuRl+jVC + CE09JrjceC7Dg/FpXkljlJCAkmpMJ1HxbHq6nHdhsstoZeS5Aljj82BjIKgmIdSwoCCtTjZFQOaW5kwU + mhN+LOgngVpFFQERljNlX4RoRgOppMmImi0MQLWXzmJz0OQbrOcSYAQS+m9JhOQlKLTTHwPPqzAv54iK + oJxzzE7eEbU3DgUWzAGaymRckvbMMTxBdtm+U+hwl9GJSLoloG0/YjSajGNhu6920sJQJ732vgMHDhw4 + cODAgQMHSRNPJzomtKqibk9amyusph3/wO68TFTnpWP/BC8Oz/ai+SVG0khHpNCP1iJqMTCaR2cCwtas + 6IxORMO7Qx8YPxQedZwZ3dIb8a0ZaN8i+dj0ZcR2pCO+PhUxmn6U/RoxVFuRFnmXhcvQ8N3vozh4ka5M + 1oogppE2RMiqFcGJAleTl5ENQmqLT1X3g+5MrBBh7VlXOp5MEyEucwCev/8+VL68WorFdpbYylVwM5Gv + PwOE2387bEKAghLL7P6ZW/GRETMN+TBq7jFERHLM0XChlpp40HzDhApVYkKjccxDr9z5+NQ3foMvX/1z + DHlwHBY8vxWHGylo0ceI0TZRR5YxI3gZAYzq8GeA8GWXn3GQGrXa2lvkfVokrdkC/acUH7FKCwrxxrQ8 + rL//Icz9xncxMZSF8YwWkp6CiRkGCaeb1Lh4JiUFT6em4Dm3W/YZTSQDkzNcmCHb+WlpWJOejkKPF2+E + wqgMZaI2bEgJ+mBp9EtfCQ3Q/sMoFOxDjHJT7bNNpEIkKgwRQb8Jze4sdQBJQZrpNF0gEUHNAaYbPxhG + e0mJQn8C7Kvmfw7eGtT0qvEMQuU3foymKVPRXluiflK0rZM8pTkSNXZ0fD+qrWO0eI4lJ9jOHBMRBw4c + OHDgwIEDB2+FpImnEzpZ5SRWtQDiIvwYoQ6RKqtp70zsnzcY+2ZnoWx6UDUpqpenIkpCoqgP2rZcAHWK + mQDJCSUo6NgywyAp4XAS2Gh8XRhiIkVJiY5Qptvk3AbJz1Z5zg4PYtu9aN44FA0P34HSQH/UuUSAEmGo + ToSs+iAjFIigJellIlgdEQGOqtR1mVS3zsKGQAhTvV5Vk59z6fXY/Mc/ofbVzWinSr5M9jmBT/iKUDV+ + ak5EnZXFd0ScPhiorRC1Dta1Wuf/dC560KRj+GybYOhKRhwLEx50roIhQ/U/DBPK7ahFGq3jEzc+hS9e + fjfG/OIfoB8P9RERaRBwlZjHR4kJIkFOME/H5PWDCLYzwiYptG8SJBRJksl+m2zZLnVFPNpkRQ/uscqe + X4k3Jk3Apgd+jUU35eK5wZfjX64Axqe7McXlxmR3Gsal99bIIHS+Sc0LOuCkLwuai4xzZ6jzzRkZNAlx + q/+KQulDu0LZKCZR4ctCJDQIFdJ/GB6zOsz+FEaVN4hKuVYdy2ZmaiSRRPjTBo8I015qKBnBmv+rl3sR + JD/YHxPoKoQ7SI6KUBAlWSHjr8I3ALU3/Ajtk6cCZYdlbI+oGVKzjF2t7THT3u12pNpfgmPamoB9wyEo + HDhw4MCBAwcOHCRD0sTTCp2s0j+CEeQoSKpwR/Bcyw6rZPVwHJyWirIZ6SiblIrSmSmof8kDFAnoe4Ik + wjEkhRwXkpigdkUnouHdYBPJiT7GlIT30+gdvK8LsXUpiGztDewgEdIXbX90ofxSH6pF+KIApKESRVBi + eNCGUCZKfQFdzW0IDlBTjmbZHnEHsDzgwT9790Fe/8vx+pPPoq28xLx/LHp0Ak/yRgTCRBmpX4GIQ068 + I+iwT7ZxxKy/rXldiYVeoxegO80ySDIkISQ6gz4lSEjw+l6qQSGgeYfco8eoRfj4j57Dp695GD+4Z4JU + l9RNrN5qlOfxmVwtpvCuAr2dn2MdCH7wNV/U3CpxzPewwUgw6si28zlbA4o+LNhGlXjUtLgVramxKl/Z + jjdn52PjIw9j4fd+oI43J7o9xjeFy2U0KdLS8ExKqtGmcHnUISd9rTxDnyvuDEz0pCHPlYqFsl3ld+EV + tx/76D9B+lJTYABa/DnqaFNDZQZMmEySDQnNCIIkBiOG0GyjJkTtCbkmnKUCNlEhQjd9wmiIzS7CuINj + QXMalml5MIDDmTLWhbLRkNYfZVfdgOY//wEtpRU2icp+SO0bOmuNqamQkl7SRrqSEQmCwiEpHDhw4MCB + AwcOHHRG0sTTC64eR1R4NKFFTXo0HtGIA6oO3NpkNWx7HEfy/DiS70XZrByUTfeibmEm4htsDQmSEQw9 + qr4g6Cgz5ShxcSrQe7nRrhoZsr8pFe0bXeowM/5Kb+BVNzD3fERuHozqlItR7fKjOlPy5xmAKu8lxoGc + CEr0mE+beKqSNzNUXzgHm/1eTPCKsNXPgw1j7kD5a1vRKuVBwS6B9hhX2I2AnRAEjRZFu65IHluWDo6D + 3Z7qREDu/5sVsEYwMsdCWMPmoEfuO2tOWEPlGpIRI2eh59DZ6Mb/jKEDzXk4d1g+Pn39HxG+5XHsPlwn + jzECGFeLSVAckw/BmShwaRu0kVC/J+nAdzTRXuR9RMjkdSTSjAaFpLMvt5l0Qu9HMxb62xDEW1qsmrIy + 68gLL2DnlOl46aFHsPCHQzDtoq9Kn/CrBsXEjDR1qDnenSJIwzNy/HR6Gsa5XXjO5ZVzHvzLRZORVMxx + ubBa0grdAeySPnbE1x8VgYHq36VW+hpDmRpywvicqAwGURkOGfOPTjBEBv1b9Eej15h8OHgbyJjGUMeM + vkINFPoDqSPpw1DIWVmov/xbiPzjn2jd97ohq9gf2wRxktFNNqll2lDXtpcY7xw4cODAgQMHDhw4IJIm + nk5EEoQEtwIK4nSgphNTphMkKORc/cHnsXfpVdiXfyGOzPKjZGIqKhf1QeOqDLRv8AJFBDUmUjqRFEkI + h5MBSQ+aiRSkIVbYB5HtFyL+qtx/O/1QSPqfBqEkK4CS9P6ozLwIde4g6kIBjbhBIuJwMBOHsgfIuUGo + S6edezYOZw7ESpcHz6Sl4tlBX8WOedNExquT8rDV/O33NiYCTCNEqIvJhJ622pJOgY9mHp3L0sHxMAJO + 1Fp/oBbn0H8Ew4aSoBg+R800khISndBtmGxHU1tiFroPlf/kyn/HLkK33Bn46Peewhev/gUWbzooVUM/ + DEb7R0N+RswxhS7WmaITMXGmRDhIOPHs6IvMt4Y9pWYPTY5MGZv2GLNaBepzwIbRDumMLvcTqHYJVf7b + Wqz24oNWxZrV2PL4X7Hi9p9i3lWXY0pmGBPSMjAtzY3p6R6NGEJti6ddGZic7lUnnM+4XRrW9El3Gp52 + p2KSNx15AQ9e9rhR6PNjdyCsfdI416TDTeN3osmXoyQETT7YN9UPhaQbwdshJ94Jh0N+2RpfOlVSpiRd + aWpT5g+qyUdVyIUWbyZqL/4mGv/+LFByRNpJm5KrqhXWqR10JijYpkzfdeDAgQMHDhw4cODAIGni6YQR + TGQ/QVKogGeEHiUl0CAwK9JErHm/VVFwN3ZNT8WR2Zk4MC0NJbPTUbfMjcha2+RCTTrS0GHicQpo3+xB + bF0foCgNsW1paCnqDWwLArMHouzWNFT1y0JVZhAlAb8INWERfgajzDsINfQz4ffpii0n7Y1eOvEbiDdy + BmBm7754up8XL4z+KWoP7hMhj+EuacIhwhvLISbCXjvf15RJh1DL8qF5R0SOtWwcvBN0tRYR6y+r9sIa + QnJiqUbfoJmG+o1IQkh0hmpXjJH90XPRc9h8dM9dIvdYgF5DnsOnv/NnjP3NdHkMBak2eU7cikbkeayj + aIPWaYdQTq0Bbd9nDjGhsPNMsD1Sw0m1nOSdCEPAyLuRkKH6Pt+dYLuNxa0m+Q+1LBJtmWURl/pok/Jq + la2J5MBrjLBKkOggKaJjQ1uDVbN/Fw6uWYVX/vEkVg8bjek5F2Nqqg+zU3yY6gpiUpoPE9K8GsqUoEnI + s6lpeC41HdNkOz09FXlpqZgrWJmRodoV+3wiQAcGozw0AIzwURcYqKQFhWwK2wyjWRoOHyOIOzge9KdT + 4w2pzw4lKLyMgpKNFinPhtQQGkP9cTDgRbWUZZsvB1WXX4/6fz0FVB4xbYdthu2CIJFnj3XU0jnGpMiB + AwcOHDhw4MDBhx5JE08r2ptkG9VVV66omUmqEeAiaDICkQjvKuzIfkyFn4gV3zMbZbMvR3Fefxya7seh + vFSUz++HpjXG7ML4mzh1s45IQR9gS8CYcmztB+zwommcC6XXp6M+NUcm6CG1Tzcrsdkokwl7VSigREV5 + aJCqkTMEYp1vALYF/Hj6K5/HjEsHo2rePJHhZHIu70VBjFoQHervujpNDRIKcXY631/AfQpzql0ix8eV + p4NjkCAnRkzZjnPoL2LECvQYNhPdR86GNXrhcWREV3RnlI4xcu1YEhWL0G04Q5DOw38MG4/eP3gMJSU1 + GokDaNXwrlonbL+yVeFKI3LYBAUFc6nbBDlxRoRKlPyrVoPsa1+022GCRGP5KvGg19qwhUxNJ5HGayWd + 5cT2q+n2/xXcT4D/t68x/xfYzyHi7a1WpKbMKi7cgMK8qVj34M+w8ObvY9KAgcbZZoob09K8mJRhzD6e + drnxjJuaFR41B9HwvBlpmCzbaa40rPBn4CW/BzsCARwKGDKCUToaZZ9ObLsK4w6ORZ17EKqzL0JpMBO1 + /iCaQ1myH0CJHNeEB6DWd7GGhy0Ph1AW8KAlmIUa30Acuvb/0P7Us2iqqz+WoGCd23Wv9e/AgQMHDhw4 + cODAgY2kie8nOgvgRqizhbz2Nqu5pd6qWTMW+2cPxr7p/XAk34XDs7JQsjCEprVpwBb6iDBOM+NFNPWQ + NJp/EJtS5fyFxl9FgQvRLX3RtqWP7HvUvwRNOLDZJ+f9AvnfdrnXRj8aHvTiiAgytakXqV11jc8QFHWS + RmFGwxkGsjVEYZWcb/QPxGGZmL+YFsZzX/JgwQ3no3h+f8SL/wljey2QdzThGakxIu/XIaQxDJ99jS3I + mUm7ua7d0Z54Z4gwyzLL/nORRtboMTzPRN+gScfIBceREV3RbZhxgElfE93GzEUPal+MXaMROn779Ex5 + RJJnnkXoIBPYHql2rxogJNUENO3onG7/JyFUaqjUdl5DcsNoAvF+BoyiImn8f1KwH8RscqlTGskS+x5R + SVMfF5LWWlpmHVyxGoWPPYFVw8cg/+LLMMXt1xCmz6WlKLjPUKYT0k340ucyXHgu3Ydn01x4NjUDU1Nd + WOTyYYM7jDc8A3DEO1gdZ2oIYF9YnWw2iECuZh8+7uegLDNTBO9MvY6+LExEnqNIhC5ldJF6TyYaPSY6 + CMlLRhShHwwTutRcQ+g5JUpCxxABZyMqr7oG8elTEK+p1Lo0JBXbk6nzOI+ZTnQQWeYbwPbTcc6BAwcO + HDhw4MDBWY+kie8nupITKvDopDSqBAUdq7XunoXixVfgSH4fHJmejsNTPaicG0TNyj6IbXEjuokkRSpQ + 5NJQoKoBUSTHG9LViWZ0K7Ut6PAyDdEtvREtkP2NfkNmFPjQ/lpvxFf0Q+WQDFS5stBMocUfUqGjPEuE + FhFSKr2DUOLKQSMdw4WNmQcFmddCASzqTQHIh/U/cSH2fAawMwWx19xoee06xKsXWGit0Ym3Clz2Oyvx + IEJdGxpVo8QIcxEDmnxouTiT83dGxGqORK20h1/S6Bzdc2fZxAPJiePJiK7ozlCicp1uc/NxTu5COV6K + L3z3D9i6t0IekeyZZxFILtC3BGGTDNSeYMhfFSaZxvba+Xq9DlaEbdQGTbdU60LSjUkIzbeMKYxeQ4E0 + cQ+9xr6n9O9YLKL+V5SI0DS5NkYtK/5f0vj/xFYFW+k3ddXW4V07sXfmLKx75HeY+e0f4jn/QDzXz4up + 6V5MdLvxVEY/PJvRF+O9qRjvT8c4XwaedaVKX+2HyWmpmJ6WjpluD9Z4g9jhycIhT3/VAiDxSNMPNd0i + eeGXscYbEkiaP0tDlzJccIls6ViTDjaZRl8M5QINfypjA4kJOstlBB+SmkxTyD4JCppKJBPozyZw3Kzw + DUDFd25EdNoUoLpO69HUt01qdYz5ZtxXkkrOk5xKtBcHDhw4cODAgQMHZz+SJv67oKrix0xU41ajTFAp + 1KP2sFW37m6UzPKjNC+AQ9PTcGRaBornpyD6sk+dZcY3p6KtwIWWTR5ENqUAW3qDfimiBRdCzUAKA4gV + 9AV4rsiFplfo/LIvYuNFeLgmiMb0HDS7Rejw+NRLfZPnIhU86PSyKjOMlnAOaiWtxkvtiSy85huMSX0C + mJTjxSuP90V8uwsi5chz+AwSJvKczX7E99+NaPNOFfjUtAXNKrC1xelc0BAWNAGhrX9C2GN5UMW9axk5 + OB5VTa3W5366RMOI9hgxG9Yo+pqg9kRyQuIY5C5EtxGzYA1fgG6jZhqHmHKfG+8fBxXOz3IwrC/7F9+V + fa0pbhMEko54k902DRIRPLhVkiJu/G4YPxW2mQehq9+CWKJtm3t2nCfsfk7/FNrX5dk8b+5PIoNCKtt/ + 1IpEWvX+mk/pM4n8RHiNPkue3dhg1e1+A/sXLkDR7/+A5T8agrzBV5hwpekuTNToIBkYn5GK8Z50PONL + x9/dffBUuhvj5BqGOZ3oycBsnwvP+7141R9CcSAb9e7+qPfSwaYhIWjaRTCCBdOqwv1RGRIhnBpVJCEY + vYekBDWrwjkaxpREB0FSgtcxagj/Q62LZAL92QQNt8z39/qV0KkYPhptK5cBLbXSNqT+pI2QpGhFq9Rp + xDiWlbrVthIjedGpzThw4MCBAwcOHDg4q5E08f1EYlX02LRYB0mhmgayjakWhQg7h9daR5ZdhyMzPCid + lYnyyX7VpKhZ4jbEQ9GFSlSgKIhmHm/uA2wIGA2JApIVaXIuFS2Fct02D2K/ycL+7L6oT7kEjb5LUOp3 + oy4roOrX1YFBRgjJYiQArwofbb4Bkt4fG3xhPPMlN2Z/OxUNC1zAGx5Ei9IRKbjQPKfQI8+mecmXEJdn + tbwyALEjvxWZ77CSMC3tLfpuanNvRysxK8wU+vjuRgDrWjYOjgXLqKwxYn2STi1HLES3XDrFnG+bdsh+ + MkKiM3IXGm2L3EU4Z6xcP0yOR87GM/PW4ozwGXGKSJAHx5ALNtg34+qPwqxuE40iTL6wuwb3zH0N1z+9 + HcPztmH4tC0YNX0L7pq5A79e8Ab+ufogZm+pxfN74qipLrfaGKVD/psgGPjMhKZEgpRQ55sJrQzVzIha + bXKc0MY4mi/7uhjNpEhsJPJ6dMxQratYq1VfV2XVbtqIXZOn4YU770beZdfiufQAJqZlYIrHpSFMTUjT + DDUHGe/KwL9cDGeaqqYhU9LTMMflwWpPANtkHDjkH4BaAR1D0m9FbThTo38YUw0TprQzKJxTi6IyZMgJ + akokriWBURGg4J5cqD9bUOoLoUnG0YaA8VtR7fdK2YRRefMIYMFiqToSFFJnMv6R9NIIRRwPowy57JCz + Dhw4cODAgQMHHyYkTXy/YTQmjqp9c7/DsWAkZsXiJl4+06MxOddWbdW88hgO538V5TNSUZYfxOFpQZTN + SkV0dR9g41fQvqkvsC2A2JZ0Y96xVtILU9C2rTeaX08BVsuk+dY0VPfJQn1wkK5kltArPW3EQ0ERHHzq + zZ8mHDXuAGq9A2U/U4SNMFZ+pT+eyUjD83f1Rvs6ufe2PmgvON9oZxSFEd/YB/GiLyMix7GtAUmX5228 + UNAP7Tu+AZQtlAk5Ixnw/eSd462yb4ca1ZVgCmU09ThaRg6Sg4JuSWPM+sSY+RpGtIOcGEE/EidBToxc + gm6j8vW4x4iZWLllLxLmC2czNHQtSbEEuHIdIRHIdEMS1EsffGFXOX6evxX+h5bjnNyZsG7Jw3kj5+Lc + YbPQa7ggdy56JHx8DJ8t29noPnYBPnn7EvR78EVc9tdNyJ28FX9Z+QaWbj+APeW1hpyI0nyDz5HnJfLE + fHDL45iAfUK2MfpwsfPJcyQutM8IjFmUCLf2Ob1O/sc004+iVqSu0qrYUoDXJk/Amrt+hhnXfwvTRXie + mOrGpBSXhi2d4HIbLQq3CWn6pJfhS1Okv6dgakYqlrjSsdHjwxsyVuz30PSjv0bsoblXoy9b/VYYc41M + VIWzUB4gjvVZQUKDoU0bXGd/KNNa30Wo8BpzFoYerQ3KuEvTOEmrzRyMw7f/BNGX1kr12HUmiCBitdDM + yPG548CBAwcOHDhw8KFC0sR/B7oSFAloxAsK8E20iTerayp8RJusaOXLVvGqYdg/vz8O5fdGybQMlE4L + oHaxG3GSBgUmPKg6v9zqQVtRP7S/kQosDqDuey6UZxghgaEGa0IXqXPLRq+xF2eoQTq8LPfLhFrONbhD + uvI3r18Q//SlYPtvPcCONOCVFMTlOe1FfRHdKMebvMDmALAuDIY8bd8k57f40FYo6RvkPyRKmK9duUD9 + BnkPrg62iqBmIncYu3q+O23/nZXDdwIF1NKGNuu/bhXBeNTiLoTECZATwxag12gK1YthjcxX3xPUnFix + q1Fuf/aTE0bAF0Qipi3S34kcN0n6nopW69HnizHw0WU4Z8hUKaOFsMYsg5VL/xxz0U1DtUq50RRmpJxj + dBQpy26jZqPbiDz0GDlD0pfLNUu0nK3h8zSSyrnD8/DpOxch9ZF1uGvOa5hSVI3dVdK3VRg1ZIMKqiQm + SFrYzjMNYWKnJ2ATF6bP2OA1RPSoiUCCpDARVuzzrVGr7LVC7MibilV3/hxzrrgeU1yZmJDiwaQMt2pV + TElPkf0UjQAywdaooOYFI4bkpfuxwuvCep8XbwazNGxpg4wlJCqoHVERCCHqHoxm70AlPRPhSytIVPiz + 0UAtrE6C/NmIYjoMDWWqQ2E17whfJNuLUe4Jq8NhhnityLwUzfc9iPbXtqMlbkhZ1lltJ8LKgQMHDhw4 + cODAwdmPpIn/LiQjJ8zqp4nIoAIIiQoRLKIwXv3RXGfVvjkOe5ZdgX0zXTiSF8bBaQEU56ejcbkf7Rv7 + oH1rEJFCP7A9gPbJaaj+WgYa0y5BTXCwUbsO+lHt92lkjnrfJWpjXu0LoTarvwgcxs78YFY2Zl6YhqkD + +2H/1FTgzQuBDX5ENl+Adrl3+6YwsDVFI4Go6ciOLwGb+sh+OmKbz0e8qK+c9yuREdvQV66nA890RA4/ + BNQV6rvxfaJxht4z70p7/uPKw8FxKK5ptD516zwRkm2fEyQdTsAZpmKoCNljRKimgD16NnoOp+bFXDz+ + YjliHwLNCSUniHhE29+hZljjNlfh6/8swKfG5EuZLIM1bA660WHoqMWwhks5kWwYIxg+C91Hy7lRRlNC + /XxIHViMfELnpMPnoefIOaqZ0kPOkQTqzmuGzJJ7zkaP0Qs1/Cvr7OO3zUXwkVW4d84bWLu7EU1tMckX + ncXSJ0ZU+juFVuMwlv4JWqT/0zTkaF8x5EME7QKODTbJQc0QhrKMkuCw31XfV/5jr9YzlCp9X7S2Vlvl + b2zDGzOm4KVb78KswddgQppXI3485/JjvJvwqo+KZzPceCbdpdoVkzNcmJ6RgXmyXe12Y7sniCO+/qqR + Rc2BWv8gGWtyVEin9gBJijIR2sszz36zjuZgUP1NMPoJTeRq0kNocGehJSRl4s1CnSsTrcEwGt0e1A6+ + As1//Adihw9LXbK+nPHPgQMHDhw4cODgw4Skie8nuhISHSrdFBoEiVW0OFpE6KCfhogKEgkhQ53zUego + 32PVrX8Ah2cGUDK9H0ryfdgzI4CGWT7Uv3yBRuSIPpuB6q8GUJVmtCMSzum42lnnyUR1KIDSsB/FAXrp + H6ST6MZgAPuCAzH7ix7MuzoVlfM8wM5UtG9IAcOQthdloG1DH6DIrUREtOB/ga1piG4MIrY5Q69BEf1c + XCDn+wFM0zCmhJwrzEDrzuvRWvo00FpphC0RimnKomrvDt4BcetwZY31X2NFOB465yg5oYLyOzvF7CWC + NAXlnqOXyvEs9Bw2U4TwBfjWE2vBtpf8mWcR4o1qGrPhUDMeWPAGfA8txjnDpkjZSTmS4Bk+F91HGLKB + WikJssHKnalEA0OxkoQw0U7o6yNhUmOb1ShZwbLmOVMfJCW6SxlbSgTxXrIdvRjW2OWa9pHcach8dA1G + zjyAF3YcQGXE9PM2akhov6fgaqDhShMr7Dxnh6nUMYPHsk0QFwnQgaf5jzEF0fHD1r7geGSui1t1DbVW + ydrnseO58Vgx+lZ1sDktw4cpqamY6GIUkD6YmBbE+PQgnnZ58a+MdHW4OT09FYtSU7A6NR0vhjOxLTMb + h8NZaJIxJyJCegvNx3zUoDB+Kc5mlMm7VmYPRJlGJ8lCXXYOirNDqkFCE5iKzCyUBDP1uFbG2npfENXX + 3oDm8dOAusaj7dSBAwcOHDhw4MDBWY+kiWcSVLjQVVGSHK1WfPc8FC/6Og7Oc6Nyig+7Z7pRNseHyC9k + 8psTxBFXSO3EafddLAIDQwCWiwBRLhNjeuOvpdaEXybJ4ZB649+aFcLEC/pi0Y9S0bDaD7yepj4lNHQp + o3JsTjs1KGHRG+1FX0H8tRuByuXyLrajPwpLFJxIxtjaIwmihjCri3JehTB7pVjS9D8U0Gzh7GwGhcnq + uoj1xdwJZjU/d4b6PyBRkfA98bYYI9fR5CB3EXqNmImPDM+X9CX45Jhp2F4aBzV0uILbzDJVx30tShoZ + UuyoQ8Z/G+xwmx0aEIT2hU4CeaKNJMwiBExvaI1ZM7Y14TtPrMd/jqTfjYWwxtJEQ8qEx6NZRoZw6NYB + u9xYtqNPoHxPEd1G5MP1yyV4cPGbKCxpBSPeGFMP817qVFYQj7EuJF32E2QE/U+YPiLlQdLPJjd43pSH + uY73MGQFSU+atkS1XTGd/zfn5X7VtdahlatQ8PCDWH7DdZgZSMfMvn2Qn5qKmWlpmNkvDVNSffhD8DIM + vfQmfPWaO/DRm/Lxn0Om4as3/gHjLroR+xiWlE53g1lo8Q2SsediFeIZrpT+GGj+QYebdSK4U1Cv8ueo + c01jAsExyUQLof+KipBfSVb+n2YkBPeVeD1DooGQIOZ43Dn/JDIqcgYidt3X0bxilUb2YFSZFqkL1ldi + zGvVupXxjs5QZV/rlYhKfWvbMP3AgQMHDhw4cODAwZmBpIlnEqhJwYkoBcY2tZmX9LYqq67wMexelo3S + mV4cGRNAXf8wStN9GuKvhT4mZLLPlUuactR6PagPBtWDPkOI1onAsMuTg7VuLyac3weFY/qg/QU/2ren + o20jyQS30ZygA8xkhMNJIF6QpZoW8YIMRDdmoH2H3HvvWLRXb5b3iyjRQOFIhTJOym1V9ETkA55XEqIz + VNCizwojuJ7VEMGkvqnd6jt2Cqxbl4vQPBu9RHDuyZV8ak8kEXiPgQjhPehDYeQSPVbNidEr0GNkPn45 + 51V5RLPVzOew7PV5bGtxexX/A0BO2EJZV3KCx0qgSBvoENajItzJe7xS3mr9YsEupN+3GD1GPyfvPl3e + mf4iliqpc87QPCVqaLbRQU7QF4etQWHKzUbnsnwvMFQwivlciE+MycNVj7+A8RsPokLqnE5ljUAaNXVh + m6awv0Ra6WiTflxoEmKEWi0D6Tc6ZihI+NmEhtRnRPoW/6ukBLUzWJbsb4SaGFBry4QyJfFRU1NnbVm+ + Bs/e/SDGXv5/uObKsej9wyeMZsnoJaqN85FRkv8x0+QdZqL7zfPgu+EvuPur38DSkAtvpLtQFvCCZEOz + jEP0yXAoy4uSgF+1DGgKUkmzCEnnOFXlH4hKQVVgEOp8g9DkGYQKhi8VAT9BUhAkMzSsqSCR9kEF858g + J1SzIthf00pIvuQMRGlgAJpH3inj7QapDtaDXR+st0iz1JUx72O9tkVikmYIiRZtE6wzXuvAgQMHDhw4 + cODgTEDSxDMJiVj5nLA2ygSVE9X2Vq50NlnY8xJK77wExb4w6tyD1GSjKhRClScH9YEcNAey0eANG3vw + oA/N/iCq3ANRkOHDjIwUPJnixqafpwLrMoGdfRDdmqo+JWLr6D8ihMjG06A5sekLsg0CRYzqcQGw8cuq + mRF55VrED/4OaNsnE/I6FZQoNMU5OY/IxDxqv6u8f+dVQ41wogIXBTWGWzxaVmcn4upIMetnIgDSNMAW + mHuOEmFbhWtbyH1LiCCupgjy31GLYA2bK9tlgvno+7MFKG9sNr4NpNxbO1beWeayz4gCx+Tl34B4m67y + U1gmIaEaBIxuE2+U/NXLNXIca7Ea2tqsla+VY8i4Dfjc7XPkfeU9Ry5CD777qKWGmGB55OajmwjSqkEx + ZvkxJATJiWMIivcBPcfKlpoww5ZIPlaK4L8EH7llKjIfXorbF+3DK8WN0PohKIySVLCPo9SoUgHV9BF1 + hqnneA39TJDAsP/bqR+R7FNCUEP6ksTgtRSC2afiVl0E1sb99Rj/wh4Mn/Im0n+5QspQ8jh2GbqRlBhG + Moc+TFh+TJcyHjsH542cLdcxbQXSbvwbhl/yA+RlZOKlVB9ec7lR7A+h0TcYDYFLZJwiCXFUm4DhSOmv + ogPBsDro7UxOKOz/UPui6QwIVXqM5oQ3UzVDmM73ogYFTWAYurks60o03v8oIntelTqQfscoTqw36ftR + 9kvWm9RNk9QVfY6og9eOunXgwIEDBw4cOHBwJiBp4hkFTkCjTVZ7XCasIkC2txjBQlXZ6TzzN39DbfhS + VHp9qjbdFjJq0Vx5LPUzLaBaE1XhHBRkeDE73Yt/XOjHU/7/xc77+5poHNtSNNpG6/oMYEuqIA2RdX2A + 7aeuOYFNvQFG+dgo96UzzSKfif7B0KMF8vwdlwJlk6xYe4O+F1fyVbjiews4UacPjoRgRSeO6sfDPp+0 + zM4m2NElvvnoLBGaacpBp41zjU8DhrxMIvB2Bp059iAhoQ4xl6jpAqNKWGPkPkPn4t45W8By7IjywPKX + Z2pdxD4AK7OSFw2721HXFLLpOJKrx7D21LRZf3nhAEK/Wy/vRcefJG1my3vOQM/R8u7UGhFhmmXWjaFB + pTzOyZXzw6QMhi49hpzQ8so9SlIQncvyPYHUDYmmHsyD5Ks7NRFYtyOlfsaswGfGzsWYaTtQeLBBikLq + I260hYxJh5QHxwHZVzKJZcRjjhNyrD5d2mm2I/2JYH3yWMrQaGJIXWs6rJKaiLVgezXGztgF96/X4mNj + TTvrOSwP3YZIO2O7YdQXEhAs11HSFm/Jx0eGL1byqycjlQw1TkJJZHQbvQznjHgJn73pSdxw5XD8w+PH + zIwLMDfgwlZvf9RlDDThSWV8agoF0RgIqilanXuAOuytJ+Hq86owT20DCvRqzkGiwiYoEoL+BxnMcyIc + q2qL2ARF4p1KsnNQHghpaGdqu5V/9Uo0jn8GaKhSolbr2K7fCKglxPq3x0eO/zzvwIEDBw4cOHDg4IxA + 0sQzC5yIRowJAyekAmpQ0Kt/zf49WHnzTXjF50fMK5N63yUy0c1ErdeFZtmqTXbYje3uTMzzZOOpDD/+ + 2icNC67vh7Jx6cAWL6JbeiNelIb2QpIJdHAp6Zu+gvai3ogV+Y8lGt4FIltCxnfF+hSB3Fv2o0WypbPM + or6Ib+xnTD5e+wFi1fPkfRvMe8q7U11dnYZGzaq5cQ5IosJeNaQgdlx5nWWIGw2Snz+zBOfdPAnW2JUi + 1IqgKMJs92PCiiYHw2GqIK5hMUU4H7lQBU5GoaA2xafvmIs3K2kuRA0EtjW2s7iq/atg9G8GzX0S+YhF + qSkTV1JiS3kUf12yHf0e3ohPjJ6Hc0fMwTmjFhnHn4zAQROY0caUhb46KCx3H74QPYYYp6DdRswy2gAa + jjUBu8w6CAoRxu209wz0HULiROtSMNJECNGoH8NnCxZIXpfgv25bgm88sQGLXq20HZmyD0TU/Ea1IARK + WgrYXkjoxZRoEqFW+k+HXw75D30V7K2DtXhnDUbO34WLn1iH//mJPEfyoISMatpQs2SVbKW9jaKDzxly + fpq2OSW4SKaMnSn5N+3KIllBPx1KrPBe81XDgiZI545Yhi/cMhk3XDMWT3izkN/vQuRn9MF8V19scwWx + 152NSu9g1AUGozZzIGqyGIJUxjF3WB35UqBPaFhUi6CfICmofdCZCPggIkGmkIzoTFDoltoU8j6Vtg8g + ksj18r51/ktw+Mab0TR3BiKReumX7JsklUwdxqU+uVVCyoEDBw4cOHDgwMEZg6SJZxJoV68OIEUIiWga + V7Mbrao3tiLvqu/hKXdfzPb6ZBKco+rQxeEwWsLZKM3Kwt6M/ljszsLTX+mHJ/tmIO+SVOz6UwpA0mG7 + RwmC9o2yLfCpXwiSEljnBgo9iBf2EbiOIRreDVqLzteIH4zaoZoTG71KRkSK+qFN0vQZ8jwUnK9aFu27 + 70B7/Zv2xLvREBAC9T3BslA7egpdXPk1ZXRWg0JIe8wav3gtPv5/fxPhb6lqAFA41NX2ZAJvF3RXrQkR + Gofn49yR83HecBHOc2eoEElTj6HTXlHtCZpHRLklARRpMyvv/3bEdWvqXgSzeFSJEzrwLK2PWW1tLdbu + snrrn0t2YMBt/8J/fuM3+Oj/PYGP/Gg8et40CT1yp4jAPV2FfqMlwXdeqD4mKIQzBCiJACUDOhEUCSeZ + ncvxvUDP0ZIvasAMm4Pu1JZQLQ/mYya6jxbQiSc1X4Ywf0slnwtw5RMbsPzNGikWGQvUzIXkUqsVi0St + iJSLEhTULqLWUcSUG/2KbC1uxN9W7sa3n9iEL961TJ4r96RJxog8ecY0Q9jQNwfzlpuPXiOkjTCNhMWw + Reg1fJEht5i/oVI+o2juIdfTcehoU34a2cTWnrDGzkW34Ys1nOq5su0+fAU+9+Px+O6VI/FX70BMSfPg + X97zMcOThjXuAHZ6wijxeVHt96IuEDDCfCBboYJ8Z4Ii3F/DJHclAz6IoG+MzgRF4l2IBoYf5TY8wET3 + cAfV2WeFpNE0r2HIWBkbX5K6bjQRXQT8DrCOW0hQydaBAwcOHDhw4MDBmYGkiWcSjKmDvYpNNV4RPuJt + zdaa++7H5PQgxqd58ZRM6Nd4U1CR5UONTHJ3egdgfoYLc1Nd+FvfVEwbEMTzYzJweHY/xLe7AJIFmzLQ + vpn7KcAG2W4iWZFmSIRCL9oZraPoNPic2NBPI3ZEt/QVpCBeSK0JIg3xzTznkmf1NelbAuaZW/1oP/AI + 0FYuwleZCF5mBfgoQdFJe8Iup7MW8o7Umil8fTe+8L3HREhlhAcjaJ/Iyj61AIzPBdnmzlAzB/M/EUgZ + TlPOM3zmijeapGkZO3dtcx8UZ3saXcKYcWgfIFnRbtTaI01t1tSVO/CDB55Bn289iE9fdR/+33UP4gtf + k+1VP8cXr7kXX7jmUXz6mkfwiRv+iI/98En0vOU5KUOGEs1XEwpqUfQcbkxmlPTR1X8BiYn3gZygZgR9 + Y6g/kNECEiVjF+EcOdfzFqmjkQvVAeW56sBT6mvEYtWG+e/Refja39dh48FmVDdLudAvQZTmGqaPaN9Q + 8k76iYwXPF75ZiOu/MuL6DV2oTxvhdxbMGyOvmcPap2MIvEwS6FtZCQdsC6S9ib5YsQXEidjBPSTMUrK + b9gMnDOUbWixXEsTGZYXiRUpS4atzZ2O7iPzTXnKe5wj9+zGd7xtPr7047/hu5eNxXiXC+PSU2QcuxAT + M1KQ5/ZilQjoOz0iqHszUZKZjXKSECGbqPBlodpn/FBQiE9GBnyQQDKC2wRBof4nOqHSJ++VORCHfUFU + ZIZRH86U9zQaIdSiqMzKkXe9GM33/grY85r0AWq+sF5Zx4a4c+DAgQMHDhw4cHBmIGniGQXamKuKfVw9 + 83MVXcmKfW9YeVd/DePdfkzK6IuJ6X2w2dMfG1whTPT4MS7Vg8n9Xdg05krs+0cWSudn4MhsF8pme9G8 + xg1s6YdY0fnA5j5AUR/ESEZscSGy5QJECiSt0A+sl21XsuFksdGnRIj6mdicbpuPMBIIfVD0NvuSF2pS + MA/tG0mUeOX5AWBbGA3VS0To2iXv3NoRuUMJCgpfRNfyOstgfC1ErPrmJss17An0HEoyYZYR+LhC3VXY + 7QJqBli5dAY5W1fireEMR7pMhEwRNkfT7EPOi4B86e9Xo0VX2aPGQSZX5SOtx+Tl34FjSAnJU2NTi/Xy + jv2498lFCP3o9/jSNT/D5678Gb5w7YP4zJUP4P9d9QC+9LVf4vNX3o/PXf1LfPaaB/H5q+7Fl666G1++ + 8m5N/59rH8anbvgT/vPbf0GPm2egx1ARtBPkBDVM1LeCjSRlelpBPxNSR92GzzZ1RbJgBLUXSFYs1/Oq + nUDBX+rcmF6wzgQjF6PX2JnIzXsVRUeaEFcHpo1Sh606Xmj52YSell+8WctywZbDyH5gJnrm5hltDSVi + eD/mSba2aQbbl2pJkHAYKxjD/M5V3xLn5C5GD9XIyQPDoaq2hJobSf5yZ8mx7I9Yjl5D6TtD7in5JFHW + jSQH2660P5rgpH7vGXzv8tH4uzeMeSnnY2paCv4uY9pTHh9meDKwNSMNb3q96hyTgj79VNA3RYKg6EwE + fBBBrYgOgkLy29kkhdvSMEOvhtHkzQZDOxcHJD1zgLxflr4nTT5IVjT4BqDyim+jbfwEoKbCjH9KPjlw + 4MCBAwcOHDg4U5A08YyCLYBH4yaknEarYFpb3Nr+0gZMcafh2dQ02XrxXFpfTPb0xXMZLqy47R6U7jqM + 9sZdVvmmX+LQzCwcnp6BA3kG1YtdiL+cBhQI1HwjVfb7mGN1YNkX7YUkEYyWg5II9B2hxAKPJb2A/+P+ + ewiamrz2fbRXLZH3NivoRmXdmLckiIqO0KNaRobEMULZmQ0VzGN0hBe17nlyAT71vcki3HFFe6YIs1xJ + t4Xcdwv6OKBgOWQxHn7+CJqoMSFCbjzKkJTybCXHJI2r8jZBpoIv2yBt3zvl9b1B1NSn7DM/O/dX4skZ + q3DnH2Zg5G9m4Ae/mIxrb/8n+t/8e6Tc8CC+ePV9+H/X/BKfv+5hfOqqh2T7K3zmql/gc1c/gC9c/Qt8 + 8Yp78b9X3Yfzr7wHX7r0p/jy5ffgs3L+v77+W3z0xn+g181SvsPyVWCn4N5ruAjwDJ1pr/4T1CRgmVFw + p4aBQgR1NQOxtS3oiLQ7nUd2Le/TDRIKo5bhMz9ZhocX7kZNi5SZ1Fc0zjCjZp/l1yT1teaVIxj7WD4u + GflX9P76r/Dlax/BR7//DM69ZTp6UnNDNWrmqCaNNcxoT/QimTWUZMhsE+VE3osEhDGLIYnSJT8niW4j + 1so9F6PPD/+CsYP/T0098lL6YryMa8+4XZiY7sOzaf2wwJOOLe4ADnsHoDZ0kUbraHYFTJQPXxBVXjrV + pClEFqo9YSUvasM5qPXZoUdD2SgLZQnCGgmkSv5HvxZdyYQPGhol/6WeEGqyBqojzXJXEA23DANeXCHd + o0H6hyGuta+wP0bQ4YeEaUfHQDq5jat5D81DdFyRNmLOOXDgwIEDBw4cOHg/kDTxTEI7nRTKlsJ3YqJJ + 23JV426LW9v+8Cc868/C9K+kYoLLjQUjR6B04zqgrcUIlbxOJqyR/XNQvvQqlE3zoHi6TwmK0tkBRJb1 + Q2RTGiJb3YhtdgMF6WBEDXVYSZJikzEBUdKigAQGNR5s4kD9SNj77xEikpcoTT+2BoE9PwGqX1XBmJPr + CM1c1AeFISg61NhVgJYJOtPsMjujEaOH/lZrReEBfPobj8G6RYTl20S4UzX/4wW+k0Juvq5gf2R4Pj45 + cho2l7VA201EhNt4TP07JPJBx6QJzZWobUJwTD7fCyTqNc5oIiYvFLwoYDUImBf6WWhqg1VaG7W27CrD + 4pdewT9nrMBDf52KQSP/gdQbfo0vXvlzNff4/Nd+gU9f+QA+87WH8Jlrf43PX3MPvnD1z3DBFT/DVy7/ + Gb589X349HW/xse/8wd89AdPKCnRfdQCYw5DbQCSD6phMMcmh0SQpzA/WvYJRqqQa3oMXYSeQ2yHnO8l + Ri/ER8bMQq/c6dIe5sD7q9WYvqnY+BCJtCpBEaMzRanT13bvx6/+OQee7/xSyZrPXPUgPn/lT/Hf1/4S + n/jeP9FrSL7ckyYf9EexSLaEpNF/BE1PaL4xRJ45fJ4SL0pWJMvTyWDsTJwnbVA1NcbMR+C7f8DvQtdi + Vkoqnvb1xrMZXozP8Knp2tMyvk13ebHc48frrhDKQ/3R5O2PxtAADaFc4feiVs41+fujLjAQJb6BqAr2 + RxWjeviylKiggE9ig4L/meBQszqUg8rsgTjoZ0SPENrCA1CSGsD+nKsQvfUXiO05JOMDiSiGGOU4YROH + 3Cai7TBkLH30sF+zH2l/EjhmIQ4cOHDgwIEDB+8rkiaeUVDhrF2FxOMICjkXbaiz8r4zBIu+9X28sSAP + kaY6JSRiEbPKzUloVB3myf/qDlgVhT/HwbkBFE/34PCkdByckYWKuV60vJyC2A4XomrOQWKAPiK8Rjsi + gQRR0VmboguZcLoR2cJnyXPWpQIbzwdeDwFHHgfqy6Qc7NVhomPCbZtCqMNMRnewz5+pUKFc6jHWbDVE + YGXf8md8/JZJRghWHwVJBL6TAQXPofS7IML20Om45PGNqBVBn89k+FYSAQkHfKYtkjBLaKq898JNnOSa + 1ieFLWpxGOePrPt4jAQcw2E2mbpub7PaNdRmIuys5D/Wbh0uq7JeLHoTT81Zh9F/nIVLxz6JPt9+FP/1 + 1fvw2aseViH9s1fdi89e/XN8/uq7RGD/Gf4fNSuufACfuvYRfPzbj+Gcm55B9xF56EmygloD9BVBUwg6 + qyRZQbMHkhP0DcEIHBTkqeGSrMxPI+hs0hoiz5X663b7Es0LfUHc/MwGvFoqvSMm44FdHho2VMryQEWL + 9fc5m3D12D/hy9c8gM9d/nN87sq78dmv/wr/fePj+OiPn1PNCetWOrycLzA+JPSZ9F9Cp6z0VTIs77j8 + nDQ0yge38hw647x1Kc4ZMQOXf/1u/D50JfLSvoRnMlIwMdWNCalpmJDRB+MzUvGsKx1z093YnBHELn82 + ysL9UZmVifKsMEoyZRsiKZGD2gB9VRgwxHJnMC0pIfABAokVgnmt82ei1u9HjS8g+c9SAqZ60NfQ8vQ4 + xGuqTR1zrECrFWHfYB9QULtC+gmJW+1H0q9aSViYPubAgQMHDhw4cODg/UHSxDMKKhDSjMEIWxFBgqBQ + Ew+ZcDaUlFiRWhFCbH8UPB+xBckYqiSNmgQRq4Uq8rJt2jMHpUu/ibJZARyY2hvFM30onp6NyvkuRAsu + BHakIcawooUXvIUpx/tHTkDy017kFbgNMbKeTjUvRGz3t4HS6fJu9fKejOphnDmqEC2TcxVgSVbYZXXG + IiFA2ATTQ08twMe/+QcjPNJfQDKB7yRAobPbmOXqy0Cjfwyfh58u2CePjKhpgGlPcas1Jm3HblOMAME8 + tZIA6pzX9wAkn0iQmDZvhGtEY0qQcJ9hMQnVlBGQSOE2AW0DNngPppHk2bprH/IWLcP3H52LzKF/Vgea + n73qfnzx64/iM1f/Gv9z5UP4/LWP4vPX/UzO3YXPX3GPOtb8j+/8DT1vmmDKi5oFty2XeliC7kNEuKb5 + gxIVAhIVjMKRpMxPJ6jRcc6oxeqzwho6A9YYaj6wXczFp+9chKdePoh6lkNrjQilpg3FpfxYls2RqJW/ + ciu+e/fT+NLXHsBnrrxPNUzoSPR/vvtHnPfDZ+V9aNLCaCbzVXNEw9KqE0x511tPXTPknOEL0GvoQvSS + +6r5DKN+jKY5yQL8z81zcMtlQ/GkbzDmpl2AmRkX4jm3G89leDCjbwae8XrxjNuDaakuvJDmw+4MmnNk + oUkEdxXiA36U+8LqjJLONKkxkfD/UBHMQmnog++zQiOS+DLR6O2vkT0qqUGRFURV/zBK/R40Bky41crv + /RCRVcthwo5KfavJlfRZO+wo65uERRQx7QPsL8afjQMHDhw4cODAgYP3C0kTzyjIBDJh2kHhqrMGhZIQ + ME7udAIq0FWyqPHOr2FIZcsoDFxVNr4LzMS0vW6v1fDqkyheFEJxfggl0zJE1nfhyJwQqp73GH8TJCIK + vyLobUiKAkbX6GLa8R4jXniBkhHxArccBzTkaXRTH8TWp0uefGh/cwzaaxfIe5KkkDKQiXlCCFV1dtme + ydA6Zt3yOB6ztu6twPnfuB//MSRPhMb/z951x1dV3u/DdNTaOnHWxQgZN7nZgGjbXyvbvbUuSEICalsX + QxFXtbbVVutk7yz2dm+BkADuyd4JhOzkruf3fb7vuSHgbSsSEfT94/mcc95zcs67zs15nvc79p8cmnSk + jKXAuAl0UXgZbQcvwLTijTKF5Jm1nEsUIeqlT5klRerEfpY6meCsbt2+J/iaiA/67DA4r6UeTd8FQo81 + Jon5eworjZByPcf+5N/7zXU7q+qcJZ9swJN5b+CKe15EzJUMoslYFPfi1B5/QbueI3Fi3+E4qd89OKnP + EJzQewSOufTv+MU1z6PVgDwjDNDtYeBiOJm0KhASrxlVmsGy4H+BLiUD89CGwSoZQJMpOzVoJi0emI1j + Nnr88128u64Ofr8Rd/huNKjgKb8d0od+eWeWf7gBdz85A56rH8MxF9yL43rei9P6DcHxlz2GI64fDydL + 5tqgV9Vap3VOoZvOthncVrJf0b5icE4nYyFaDHgdrTOkDaz/4Hk4XJ4b2380Hsn8C+Zen4G8lHRM6RiH + yd5kTOrYHmO9sXghLhqj4uMw1hOHgjgPihKTsUVIe703FTVC8GlxQFK/PUmIfXIqypKTUZ4k8CZFFAQO + JmgcDWlHeUIaypO7oTz1PJQldXFjbDDWRpoG1dyRlqTWIrvuGA58/An4zjRwnvNdrRdQpHDfF8ae4P8J + I25LuYWFhYWFhYWFxQFBxMJDCWGi1fRDMixQMEgmAkGnTsmXnBOSwY9SH8UIOccV0sZYDPw4dT9Q/fAr + QdFzZSucrW9kY31uNLZN74xN+dFYPzUaZXMTUfl2OL1oDFDCLUUJihauOHEAYk6ENJ2pPKeIz+oA/4r2 + 8K+kVQfLOqKmqBNCy9OAL+8CalYa0iztDARCTo3bX4cySMopTuj4Cjhuf/p7Pn5+0d/RlulBIxG+fQHj + KPA+2W5mD3VFmIMT7piLko2VUELTUC9zpVqeX2/iUEgdzLw6AOSGz3ERCtKViYIITddd8JzM/0bwnaDp + Os3b1ce+yT3kfuxH846YgJ8h1Eg5BZh6tcigG8mXW2qcf09/E5fc8XecdukDalXwqx734YyeIzSo5ok9 + h6Jdj7twWs+7cFKfh3HcFf/CkbdM1BgUGhSTGSmYXeNW2Ubq8+bErbQ0oDCyEM4AY92gQkn2dLTNnqwW + HnQx+eWtc/DXl9eiSvvCWMRwLDmmFJm4is4x/XrdDjz4VAG8V47E8X0ewum/G64WI0dc9Qxa3DRe5ksu + Wg2ehTYMDHoLhZEIddoX3JYrdZV7Zci805SkUn9aaWRNx+GZU6VtbM+bOPquN5A55j28Mf9VvDPyPuSd + 2wWj49pjQnwHTIzqgNyYeEzwJOHfcR48GxeNvJhYvO7xYl1iGrYkp6M0lcSebh5pQvaTURmfhCpvYkRB + 4GBCFeNieFNQlsxAnl2wLb4ryhK7oyK1O3Yk0SokBdXJ58v2fD2/Mz4ZO8+/ADXPPItQdalTq6Ki+d0w + 8928RyFfw4F5fy0sLCwsLCwsLBoRsfBQQtPVf7Wg0IBmRrBQ1JPAmvgSaiERLue1AcYN4Ecoj83HqVpZ + aBwDE69BV8HlY7VuzUxsXtAbm/I6YVNBAlbnJ2JdvnzAv+JB/ZsJCC2NN4JAWKBQ8SDs3vE9IpxBhGC6 + 02Wsh2BlFOqZCnUZr4tCoKgjQivPBzb+Vbjpamm3EFMf/azd/jikIWPrjh/3V36yEe0vHIG2N476Jtnb + V+iK/ywczjSjGQvR5hYhi4OEJAqp7f7wS1jTAJNalMH1ZM7Q1UNJDkUzDdTZtJ7fA0imOZdVXCCZ4r7P + WAdBthRPSKzl2jD4d41WEo1/Q+GBJu+uaKHChRzL3/IedJcKSN/S/YltVLcRKf9qzS48l/c6fp/9V41H + cUKv4fhVvwdwVp/7cPoFf8apvYfIdhhOu0DI/KVP4rCbx0j/FUBjKTAeRaQ+b05kyvhlzEcrIfhtKFJo + kFQZy8G03MjTaw7Pno42Ukbx5MJ/v4uPSnfH5WAmj0bLFAo/+psB54vNtXhyyqvwXPMQzux9J0753W0a + UJQpWI+4fizaZM1AC7qQ7F2ffYaxLqGoo64j2dJ3tDihRY/MzVbsx8yJpl05ixF9/+uY+t7XqNy4zlk7 + Yzpe6nMJJntTMb5TLKZ2jsfUGA8mxSZgbKcYjItOkOOOWBwfj4+96ShN6o4ab3d1j2C2jm1pB39AzE1d + umBzaiq2JyehPCUdVSnnY0did5TSkiIl1QTMTEwzGUlkW53YDdWebtieci6qrrgcta/OA8q3y3j7nUoZ + X461ihL6f4XvhnlfLCwsLCwsLCwsvn9ELDyUQKJAgaKpOTqhQoVslbAKkQr4G1SkUCLnpoFk2jgSLiWT + vI5ChJrmG1LGLB5+1Du14ftUb3Uqlj+CbTOTUZrbEdvzUrBmSjS2zoxFzWsehJbSzYPuFGG3ju9fnGC8 + CR8FCgoiJQzMKdul7eWYz06UunQ0okWRXFscBX9JNAIfXw5phNveQxvGWsC46egYcZVfxvvmYRNxxDVP + 7EX0vgNomp8lJDZ7Jg5j5onMuUJ0C4TMkti+hRueysdGzhX2pZtOlHEdaLljVuB31/X7gAnmRxgLEgoJ + OpdZJ0IJloFxM+H+7r/nNY1uKHJMUMzgfZSQh68j3Ou4TzcQxmchqeM1FfVwXluxDn9+cjoSrn1YRYoT + +z2CE/oMw4l9h6Fd3yHqCnJS7/tx3MVP4sgbJxpiHanPmxFtMmaidY4rEmTP0hSmasExcL6M6yuu6w8t + OKScVgiZM3HOkEWYtLxMukr6ym2vEShc9xf9fZBzAb/z1aZqPDjmZSTc+A+TolXaeEK/kTjymlEmc8de + 9dlXtGYaW+6rGLG7nNB0pUx1O3gBWvefi8MHSFuyX4Jz22zcOK4Ia7ZzvH3O+ldexjt33oH887phbEx7 + jI/vhHHxcRqbYkxcLMZGR2NydGfMi43FMm8S1jDuRFJXjeMQSRA4qMBsJN401CUkoSo+SeNP0K2DaVB3 + JXk1lkZVQjKqEpOwLdWrLh7lKSY+BYN+bkv6LaqGPwx89LEMs/tuuDFH6vkO89jCwsLCwsLCwuKAIGKh + xW4YawuuzNe7ZX6nbst7zqbXb8P6/CQVJjZO8WLT1GSUzU1A7dvRQAndPOJM6tEVHdBQ3B71Je3hWxGF + kGbXkGuYhlRdMXYLDd8LaElBYWJZR41NQYFCg3mWpAGf/B6+ijVCssqFbJHkS/u4Ik64ZNUn5IYCjlpa + KEhyDYFl8Li9++vAg1YxNTJODW79g47P53NWrN2FqJ6346g/jBbCJiR40Dy0HTQXbRmscOACNfVvkdkM + MQ8GvYQ7C1ahlsRdyawJqKdWCErmZe5IuZJ+Pc9+ljpLHzPmSeQ2HTpQSyOSOgox0na2c932BufZ3Ddw + YcbDOKX3Yzip1wM4qe+9OOHCoTi27504+cJhmv3j1L4P48j+09BmQK66zLTMYVwPulsI4ZZ948ZA6wpa + DfCYLgx0a2A60plom8WxjDAm+4ywBYc8g9k2BszEMdl5uHnGZlTIOKlAQzN/2VLQNCkp3fH1VcmcCzir + t1Y6I16cg9jLh+CknndLe0egXd8H8YsbxqNt/zy0YL0Z0DK7QOtOS46WmRRN5NmMwcG2EW59eE2bTLl+ + j3r+d+gzuJ8xA60Hz8cxQ99C4fvrwZSynJNVq7/Gqsf+hXm/uRhTY+Iw2nMGcjvFYGJcCsbHJWJc584Y + HRuNcUlJeD0lEZtSojQmhcafEFSl0OUjFbu86UrsCVpY0BVkl5SbcwIeu4goKBxEoHBRw7gU/9cL1c+/ + AFTuUIs5jWMjqEWtjL8RLUw8CrptGTFQRT3ZWlhYWFhYWFhYNA8iFlrshq7G64cqCZgcc58fqzVrnJqv + F2Ld9F9j/cwu2Dg9HhumRGPjtCiULY5Cw9JOQMk5wBJaMzBYpWyXxgqYVSMeoeUx8C9nvIgIgkKzgs+O + kTp0MvEpSjrDXySgaEGBYkUC/BvuR13dh9LW3SKEWiSw7fIBrmKEWiiYY+OLTRN/95ofEAz6aFazpU6s + m5pj+50yP5whT03HsRf/FUdlF4JZNkgAW/WfiZaDhYDKPk3v9yZ4+4o2Ayaj7cCZeGD2x1D3DtbDXyf1 + kX13roStELg1MR9MX1KgiNSmQwmNwUi1/9k209YaaeuOBjgz3i/B1ff8G2f0GIbTez+AE3sPw3H9hgtx + H4FTet2Ho3sOw7FXP20sKfqTvC+UsaIrzWx1pWlNawEdJxL1Gera0ErGzgS0DJP5/YHMh2ze14gETs58 + OZ6HFjdOUYHi/L+9jtVlNdIun1PnN+4d+n74mNnBZEsxZUbE+GTtdtzxj6k4q+/dGhj02AuG4JhLH8dR + N0829x+8WJ7JZ1EQWWDimNAiJ9w+madtwu3by1IiEijiNIoSAiOC8J6zVaCgu8q1Ly7Bll1MJVuv7m31 + NbucT2bMwKJbMjAlzoNnYuIwyuvF1NhOmNYpCpNjkjE+KhFTo2LwVmwK1qT8GuXJ3TV+Q3laCirS0lWg + qEzohmq1QEjHthQDEn5NQSrQGA8HObYJNkm9d8R3QXXy/2HHTQNR9doimcb1u8VDxiKqk/nNd5bHzMbj + 5+9fpTv3LSwsLCwsLCwsmgMRCy12Q1fBScaVkDNlJFfqTbmmkqzd5OxY9hfN6LE9rzO2F3bD5txu2DYj + FlWvnAOUxKowgCUdjbUERYFlHgSKOyPwwYEQJyhMyDYcpLMkxggjckwLCn+xF5pt5OMLENo8Vj68dyrJ + oum6mu2z3UqijTk7iZi6LLDt/GiX4x8UKk64BJFE2Q1iyDFaIUQx5uL7cMw1/zbxBrIWCRlkGsl5ShQP + JwF0Sd13xRGMXyBkkKTwb6+ulSqwDiQyPpMNJigkxhUn9Bz7sYFuKBQoOKdYdujCtIkw74dpU3if7wmz + 5QSd14pW45b789Dpoodweo+hOKnnEBzbd4TGaTi1x904nkLFdeM0RaaKSOrykY8WmUw3KqA1xaCZSuZb + MFaFKyREGpN9QmaB3LNQLTZaU+xgwEyZHxQoaEFx2MDp6HjvYsz7aJs0M6jBTzm+De6Ycox17vF9UOsq + ugPAeeODzbhh6LP4Ve+h+FWPO9RS5MjL/4WWt3C+zEHLWzkfZ5r2SducnBmuy8ks48qxD+1rFCTceWis + TuQ4Y4ZsZb7nLEbnB97AvI+3ok7eXQ2Ey/lXFXS2vLUYr90xBJNTf4NxcXEYFx+DCdEeTIxOxfjYLhgT + m4jRnWOxyJuCr5kNIy4VFZ5U7Erthh1C7DenCrGXbWVSNwVdKrYzvoPs70roFlEQOJiwPVW2SV01JsWO + pGTsivNiZ9ffY9cjfwPWr9bfeRMoOaiugaF6GWcpa5Bx1nhFPG9hYWFhYWFhYdEsiFhosRtcaTTBDeWY + K99y7A/VOf4AszOY1JEs920ucspez8H6yZ2xaUpnlOalo3RKKjYsPAdV79B6IRHB5RQE2iO0opOgM/xL + w4Ezv0eERQk3aCaFCeN20lldPOjqgZIkaOBMxqr49CZgx3sa8JCkSz/OUee2nf1hSLceB5nJwZT/YJB6 + 0Lzaxy2P6VoQrFd3HMZ++Oe4V3BMj7twREauEM+FQtRoNTELrQbNQ6vmCMiYJffjVohtGyG645btEH7K + evidANPTkgSS1ApRJ0y9hbiHLSjC7TjEQQFP3Vc0rgXbRWHLrNYHpJ2cRxyft0pW4/p7J+Ksfvfi9F5D + cGq/ETix1wic3GMoTu9xD0648BEcdu14FQZUoNCUnLPVWkIza9DSwHX1cLL2P+Akybymix2Qr1sl9hQo + KAy4c4XPP+pP8/H8m18DAQpz0uYQTfvrG8eX7Wb79J2RazRbi+zPfm0Vzu3/BE7oPVKFmJMuvA9HX/8i + WmdOR5ucGfIMUw+2T60oWBdC2tdC3T7M+f8I1m+vfbZJBQuW5UxHW7qrDFgs938JT7/0OVBv0iuH3RQo + ItV++jWKRz6G6ef+FlOiYzHBE4PR8VGY6onDhJgYPB/dGS/ExWB+Sio+EzJv4jqkoIqCRWK6xnogKuVc + Zcq5GoiSVgmRBIGDCeVJidiZaiw+mI60KrUrtqakY4O0q/Z3F6OhcIH0V6VTo3OagoTfqaZVhcYu2vMd + sLCwsLCwsLCw2D9ELLTYjaAbbJGEhBkhdJ/nuC8fp34hYUGSUJaFKp3yNZOxYVFPbJrSCaW5aViXm4JN + +ckoX5AE3/sJCH7YGf5VjP1AsSD5m2JCc4PBOTVIJ+NbuFYUUk4XDxUmpCy47Aw0FJ+NwKo4gMLJ8jiE + vhoC1H7USCo1paJ8kFO0oAUFA4WqifMPDa5Yy5Z1JExcB5YzICWcHVVwfj3gYbS5+FEclkUSJ4SPhDDb + TWsZJnbfFRlcmRYim5mL1rcvxM8HzsDEZTtQ46P1gBGwDIE1sSfCmTNoTaF1ZRsOYRj3H5K23WIWg0eG + A0dSNFIyTzKn5/w6b14tWYtr75mEY3sPxWm97kD7fkNx6gVDceLvZXvRA/jF5U/i8JtypW/nGjcLjtWA + mYaAMwsGg1yGg0XuD3hfJfKCDMaCmG0sKHRumGerWJCZL+XzMWzWGpj51SBjSHePsAuUK1CoOMO2mnnY + ICitDDhPTH0LZ1/6EI79/TCc3ncIjrv0UbS5aaq0Zb4GtmyRwWcIWJdBc2VrLEgi1rkJwkJEoxjB/mki + Ujg5zEIyywgUjLFy2yJcOGopynZV6HiokOS6rDG9cP3m9c4Ho/6NSb/vjslxnTGzQwdM6dwJExMSNIAm + rSrGdYrCAo8HK5JSscuTiorELmpJwUCT5Ymp6v6hqT3TDOk/mFGTnIYd8QycmabBNXfEd0Nl8nmolrbV + JsWrwLJj8B9RV7IcagnFPgv/H2iaFcrCwsLCwsLCwmK/EbHQoglcssuP0vpQyKkT0kECRiIW8Eu5nNN4 + DLQukA99XldTvcYpW/V3rCvsiq0Fsdg6NQbbpkRj2/QYlL8Sh4YixnuIAZZ12i0ifF9odOdgJhG6mLhl + jEGxrCPwfmeEVqbA94GgpJMKFYHiDgiuZDrSVKD0GQeVn2sfGCsKAT/MZdt4/IOiTsYgTBK4ek+yJfu6 + um3GreDNFTi1359x1LXPmzgTg0nsphvi2YTofRdo1ocBhRpws1VmnpLao25biDFLtsIEz3Pnh4oofhUn + dO4IlOgc8jB97g+athJGoDD7fH/4jqhIwfEI1jee9zcEnIK3PsDvB/8D7XrchV/1vQ+/6j0cJ/e8F8f3 + uBenyP5h147FYbfkauwJzU6RNU+DYxriTUuKyOPyrTGYGS5k7G5/SY7lngPy1cVDY1DI+ZZZM+XZ8pyM + GZoVgyLCH8atQjnjDpDYuyIY+4LjGcZu4Ynjbn5DVn62CVkPjseJPYfi+IsexTG978cR149H25unqYDA + +dgya/5uUSLH1OG/Qfsh04g2ewgU7vkjMhlUlGDwV7qUyLXSb0mPvY53Vu8AGiisUmis1zEy4yZjtm2j + 8+mkKZh51RUYk5SC8VHRmBQXhynx8ZjYKRrTYr0Y3zkeCxOiUZSUiI0pXbEr5Vy1nNjpTdHAmFWJKREF + gYMJ5d7uxuIjORWVKd1MbI2kbtiakIjyVC/KkhO1TeXd+yD4xHPA9m2aOpgCG4W2Pd8FCwsLCwsLCwuL + /UHEQosmkA92Wgww/kJALQYMTArSBkMwSbwEXA03x0JGfKVObfkHzqa3bsDaWb/D+ikJ2Jobh23Tvdgy + x4Oq12OAFXT3aCIkfB+gKwdTiXKfFhRuWaMVRfGZso1DsCgZPgbPpICxjIE7oxEs7qCuJ4Gv+iFUNsNB + rTEBJ5kxq+E/vM+1xsbQMeKxKwDIvlq5CMnimJBI/PmxcTixz/0aeLH1IJK3Gc2y8t4iexZa5cxXM32S + XF31lnLGonj6tdUok+dzxdWIJiQzboBMwY/CciJCWdiFJXwuFOQ8MaJePU3hOYdCjM9Qo/1QKWXPz1qC + hGsfRLse9+CMPsNw+gV34kwGz+w9Er+84gkcdfMETeXaKosWAOx7kmwGyvzmmOwLVHjQQJy0kDAuHhqD + Ipv3noXDMgrgZMgzBy0WYs85k6dj/Osnl2BDhXkfwtlr9hCd2MYArSpMHArtGzdg6IzXP0TXmx7BSdJO + tu/Yy6V9N43X7CNsnxEn9qF9FCcEYXGC2/B+y6zFaNE/X4PAtuw/C0dQnMicgdZZ+TjxjsWYtmwrKnRM + +HsW1HgUVX4jpvj5DgVqnNUvL8bCrByMjUnEpKgYjIv3YHxiEsZ2jsdzCTEY64nGjNhYLPUkYnNiN9Qm + n48aIfiM4xBJEDiokNIdOxLS1NJja2oqtjDuBNOPJrvxMpLOw1ZvEsqZgjQhBaWXXAPfgrlAqLpJBicL + CwsLCwsLC4vmQMRCi91oJBskGEKk1M+4QcB9JR1ChjUwmllFY/yDxuuVoDQ4VV9Ox+aXrsKmgjhszIvB + htwEbJmegJ3zDoA4UWxSiaq1BF081JKCIoU8W9OMxsl+e9meKcdRsvVoXIqA/G2IwTwFwfc7qXARWjsQ + 2PW+69rBNtJtgdsfDnQh0H4mXHGCdTMwMUGYWWHt5mon7ZpHccSlzwoJLBTCOR2t6eLRlOR9J8zVbB2t + GHxw0CI4g1/WlekjB+aiReYivDh/iQoUakXA+jVxAzBixe62HIqg4NA432kdQrhuAmZM6o0IEz5Wsu5z + AnKNxmXw82/oAgLno43VyPlbPk7pPUSFpHa978eZvf+owTN/3u9xHH79RJPFgm4d2TPVwiHymHx7tO4/ + xQgUtKDIckl9ZoGckzI5T8sJjSuSxSweMsa3UdiajqMyp+A3j72HjaU1u/uALh0cU4p22vbdgkWjcKm/ + GXC+3FLlDPtnLs7scRtO7jUUv7zwbybWRqbcn8EyaTVBYWSv+u6NbwgSrtVES8bO4DW0Lhkk2wFT0eI2 + KcuYi8MGLkRLdUd6Ca1zCvG3l9dIdVn/eifgd4O1NrjCq4p83NY6m956Ba/86TaMio/HuE4dMdkTjQmx + yRgXnYCx0TGYFBONOZ5YLE1IxIbEdNQknftNMeAgQ1mSF6VpXVGWfC4qE7qgLiEFld5kbE9Kw+aU7ij3 + dkOVnNuemIjS9CRNPVqe8GtUDnkEoS++MH1jYWFhYWFhYWHRLIhYaNF8YPBMEpVA5VanrOQJbJx5PrZP + aY9t02KxLjcZGwpjUPUKLRWigGLGgYhR0LUiVHK2KyRQXKALSIcmkOubihDfF5ZJHUpSpC4J8C//FUIf + pAAbHgFqPzeE2/WxZ6A4BthTwukSMYo2vMaIN1VaHj7HcpK6SH3WnNA6CkFm8MLZb67C6Rf8Gb+8+ikh + Z7lCcF0SSCsKxhXImIXWQkRJ3Fowu4dLUPcXQ2d/hDr2C0m7jwIKibwRVRqJLfvGPeYKtl7jZ9+advx4 + 4Qo00nYKexyvWW8UI/2aYTil9zAc0+tBnNT3XpzW8y6ccMEIHHvdOLTNyJNxE+I+mFYUFCloNSDjSEsD + 2bbOmIO2mS45/54R/1ARviynCOZz6lwLEYoTHNPaxjb+Z8x/7zOcd/OjOI2xNnqPwM8veQKHZ9Jigq4Y + L2lbnJyFcjxD29gqey5aDihAa1pL5Ly+R12+G+Q5WXNxz8wPoGlhmwpJjKXjCml09WgIGSFp23vLsHjg + bZjoiccob3uM90Yjz+PFpE7xGBfrVaFiZudoFCenoTQpBRXJ6RrDYVdiMkqTU7E9Vcq9qahLPFfTje7y + dkFNQlfUeruhItEE29yR2AU7vQeH5UVTC5DwPmNsVHc9H7sK84C6MnX1QL3Az3FnXBXpN58Jkmp+90wc + lnowYC8FLPavoMlcsLCwsLCwsLD4qSNioUUzQj9Cw6RFiOe2d52tSzKwdmY8Nud6sTG3KzbmebF9dgLq + 3kiAcb2IQmhpHMDYFBQIijojpFYN3KdoEBYsXHeN7xNL4lWUCK48AyjxSr3iUbc0Br5PrwE2PSfNwm73 + BP0IF0LtunuERYgQ6l2wLwRqQVAjH/IHwCyaQQqVYEEJRM6jU3BMzxE48g/jcDhXqLNnoGWOCYLYImu2 + iWtA4ucGR4xM6L49WmYXCpmcjutfXIpKH/vDWAmoaCJ9oS4PXKnWVJTc9zmBgJsF5idBXszc8TOGg7TX + 7zcBMz/fKd336FSc0udunHaBoN+jmvHiuAvuwi8u+yfaZs5Cy1tlrNx0my0G0oqCVg5zmsRtIMmPPC7N + BbqaeB96Fat3VOqYqThHBKpljM28+2+gy8/mLWXO0CcKcOLvh+Ok3vfjlIsewlF/GC33p9WDSS3KTBuM + idE6c4qxHpFjk2Y1cr2+LVpmmiwztAC6cexS0MJDx0HA9jCugpmzTUBB0lfvbFlRhHdvH4bxCedhTMdY + jI6PxrjEGExOisPY6GiNTTE71ouVsSmoSOqOOgoOCQkoT0nV4JmlienY5WUKz3SUJu8Gj+laUZHctVEU + OFjAujUVKMoTfovKm24F3n1bhpPijfSfX35r9DfRWHHBx3kQ1Kw1RuiBU6nv/e55YGFhYWFhYWFhYcWJ + 7x26GqkfoX7HB5PCD3V+p+bzfKx9qR825nXCpindsHlqV2wqjMGWhZ1Qv8wDMHPG+zEmaCVFAs22QVcM + gvsxrpCxl5jQ3CihK0g06gX+FbTu6AQslbKlUo8VXtR9cS1Q8ap+hHOlWNMr0kpCV1mlrWoWbkgNrQLo + m6/9wXN0j2F/fJ9QM3vZyvOY4nH19lrn1zc9iuMu+huO+MMYIbjzDdkbMFMIrSGDziAhtULYzAp2ZFL3 + 7bFA7jdXhY7fPvkq1pdTzDF1I3klmQ0EjPWJESm4lXnjN/31jfb86GDEid2ZcHyyX6dpYBn/YMzMt9Hx + ouFC3O/DmRfej9P63qcE/thLn0Trm6eB2S6cQUaIaCkkvk2mHDPFKIWl7P0n7/8bnC9z8dvHX8GmnXVC + QKUNzEwSapDxk3egsZ3/AQ21+u7wdyF/4RIkXnE/Tv7dPTj5skdwxHXPSFsKVTxoPWAGWg1k2lqZT5l5 + 6o4RuT77hiMocNCCKJtpdhcic8JSME1muE5hss2tzlUpo3hEoY/jgzo4W5eW4I27hiI3JV3dPUbHdMLE + RC9GxydiQmyKHMdjenwCViWkqDVEVYKQ+/hkIfhpqEhMw46UNGxLS1OLCpJ+Zv+gAEDXiqbCwMEA1quM + dQ4LFNKOhtTzsDP1t6j66z9QW7nFqWa/yHzW7EY+Wo9xPgh8IRVyNYCv9GUNXdJ4rYWFhYWFhYWFhSJi + oUXzoVozNgjpJGkhQZYyjfLur3FQVelULHsEm+f9Bptzz8G2aXFYmxuHNTPiUP6aFypANGbZCMeLiHaF + ihiElh4AceJ9upAkILDCg/qS9ghQnChJVisKph/F8jjUFcehfu3dQMNX2j6Tck8+xmkZwRVxl4yT8Cjk + 45zn9aNdjr9XkCjK8xvq+SyuXMJ5ednXOLPXXTjuksfRKmwiL8S2hWtJQVJLoaJVhvHf3y8wuwRjI+Tk + aayLxAcWo3hdQKpFEUeIqcwLZklgn5H4aWBPl6gzA8Y32vMjg0m/KfsCY4FDQl/vhANJUsx664N1OHfA + Y+rWcWqv+9Tdg4EkT7z4SRzeP0/Gi6KSESVaDWC/yzFjLTAlaKQxaUa0GswsG0Lw+89G73+8ifJqnwl4 + Km3jmEZq8x6Qa9nGBmkrXaM+WLMVvf/0PI7t9YBmK/n5Jf9Em6xZaHX7InmGzM2sBTJP6YqRZyxHItRp + n3CLm7Ums0DaQlEuH1kTl6FOXYrMu6PzkWRb9km4Kaiou4eUUaQIj9uWkqV46bY/Y7y3q2bymBoVi/Ge + OIyJicGLHo9iflIKvkg5FztTugmhT0W1kHym8WRASoL7lVoWWRw40AhbSoTFiL3LKlO6YEt8HCrPTUd5 + opRdeSNq334dtRRp9b2WcWWfue+0znO//P65v0sR54SFhYWFhYWFxU8UEQstmhH8AJUPUn6M+gLGF9nE + FJByfrDKR2xw61Jn+5vZ2JQXh7L8RGzLTcbavGhsnZ+Chre8CC1JAANTooRCwVkC2aqLBwWMvcSEZgbd + OELFUcCKcxAq6ajuJf6ic+BbcRYaVp0NLKFgkqjXNnz4O2DLRAf1FYZcSxvpix8INTg+jTvh9oeAaTbr + aWER7qfvC1IPWiHoKrD2O7OtwHl88svqLnDkFc/jaGbaYJYNrsIPNCkZW3PfdRnYLwyejda3zsbPbs6H + k1GobiMnD5mB/BXbZfilTj7WyRBTFSNIYKR/TPYRI6b8uOG+CwKSdIpWzIxj2k7wOOB8uaPBuWroaPyq + 91Ac12sITup3P07rMQzHXfYvtL1lChwS9kELhVzPQMuB+RqfocVAxmqIMCbNiMOz8mRcZf5oINRFuHXi + W6Ao0eCO455tjQyKGbRGqA5QtPM7O+tCzn3PL8BZPYbghL4Pq5VIK1qJsI0UXVQ0k32mBo1Qp31B65x5 + cAZIXw2eh8MyJsLJLtB5f2v+J6CLTZ30Pd8Zuh+peMY6M9OKr0bnaoPGlTFEmxZB/H3bUvQ+3hj0R4yN + TcbUjudgcnRnTIv3YmJnD8ZEx2G0HC/wePApyX5SV+wShK0lShPTUCZbWlSoG4grCPxQaCpEEHuf35yY + gppEqW9CErameLErOQW18b9F7R0PwL/pC/mt4e+9mdtqgeK6L3G8g+ruZ+aAhYWFhYWFhYWFFSe+f7gm + 0dzXD3v5WOWqsEL2wyvm9OGu+TIfGxf1wdbpcdgxPREbpnbCpsJO2LUoDv53mVUjGgyaaUDriQRT9j0i + tCoOwRLZLqE7h5RpHAzWJQqhIlpORCFQxECejJERBSzrAHx6M7DzNScQqNT2hq0pGDBT+4If6FyJ1f74 + fsFnkDwRusIbNMELK6T8tkcm45Re9+GYa55GW65+qysAY04I+csieWuGbB6D5B435qLN4IVoTULJAJyZ + M3FE1jQ8NO9raGpNJXfVhvTJvgaG1Dmzm7j/eBF0/A0+JWwcK7pzcL74aAYvWwpbSoqDfmdXQ71zy1/G + 4/S+w3DKBfeAgTJPveA+/OLKf6NFZr4RmAYyQGaBCZKZSQIfYUyaEXQlUZeILHnWYNnPmY1H56+Q5kjb + Gv63uBREtXkPON4C3Q8wYwacSQtXIOGqkTi9x5/wy4seQev+09Bi8By0ypmugkjLrP0XXzRuxaDXpO6v + mnvqe0ArlNkYOesjFVoQYDDban2H+d7wXeJ4GIsXGSeBEf8E9dJmuifJXF7zxmuYd2sWxqamYVr7WEyP + jseUOA/GR0djalwixnWMw9vx8fg4IRWlSd3BFKTMjNEoUiSnfkMM+CERUaBITdUAnkxJWp7cTTN9MKPH + jvTzUdrjYmDybKCSATN9Dq1jOK50L2NffZuYJBYWFhYWFhYWPyVELLRoToQ/QEm2SMLk2DXxVQuKEN0+ + gmoerR/41eucshUP4OsZ6diSn4b1uXHYkBeDrTOjUfES03p6gRVJ6u4RWNK+UUT4vuAr6mAsJ4pigCXy + XKLIY7AkEYGSBE09imVMR9pR0VB0Juo+6AKsuVU+zD8UkmYydRgCwz4QuGTsm/3VvFD3ESFPGudByZRP + VyxZl9Jyv3PFH5/A8b/7M4669nm0zZphVpIZayJrFlrcSh//yKTu26JVFi0ymIpSCCVdRgYulvvPxlF0 + Rcieh8sen42SXWYlFf46qbPP8bnZHhoDjf6IERYhmFI04DMBBFWMYJm+I7JlhhPZZzljuDz0/Fyc3GMI + Tul3L067YAja9R2Jn1/9FNowXebAuQITEFNjiEQYk+bFHCH3L6lIYZ43C20HzcT8leugdf8f0HeCohSz + t3COSj/Q7UmzP6De+eirLej9p6dwSq+71M3jiMufQRuKIAMLzdyKWKd9gIplss16WfuNMVicQQvQakCu + vAvz8e8FX6Ke702wXi2/GGdCLSX4TlFklOMgXUA0G4U7Xjz20TJK9qVt2995G68Ouh0vRCdgXLwHoxLj + MTomDgWdkzAquiOmy/77niR85e2qIgVdPnakdm2MQXGwYG9xgvsVCSkaQ4PCxKaUdGxPYRDPNGzzelGe + loay+N9gZ9Zt8C99S7qKQVIZS8aNNXEgYu5YWFhYWFhYWBxCiFho0XwwZIsR7407Qdi/nlC/Y37oa6YG + U6Yklee3vOmUvvVHbMpPVmzITcTG/HiUzolD7RtuDIqVdPOILCo0HzrJs2gVEY/Qis7wrTwb9SVnI1As + z6f1RnFHhIqjVaAILmdcDPmboiQpT4Bv+RmoW9kD2PQ80LBV2+9jKj1XsDHWAd8v/MwKwv5UccLtbx7T + YkH6/9Mtdeh63Qgcc+GjOOIPk9AqoxAthVy2ZKBDWlBEInT7gFYZM3AYM0lQjJB7thJSSRFECaGmiXwZ + 0UPnYfbKHermERQyx7lCVwat517t+bFB5zuhq+1EwIgybDvfDz9dXgzpDXDMpLxWxnLYM7NwYq+ROK3P + UJzW406c2Oc+/Oz6Ua4rx2tqydCC6UYjjEmzgrEfsmaiTfZ8tB0gc4fzRvZPvmsePt32LdyWpC2MOaLt + 04CoQlyljWwzA8yS4DPQ5qCHJ+LkXsNwYr+/4JeXP4MjcuTZg5shpkZ2gYoqR2ZKG5jhROZ8C2kTXZuc + zDk4MmcaCj6rkVfH1FXjTvhrpe60BJAyGSPWlfU0Qgt/10z9GeiVZVouv3HrXpqPBbfcgnGx8ZgUE42x + cR0wwePFqLhYjIrphMLYzngvwYt1iQyU2QW1B0EqUQa/DO9HspzYltwN5YmpqPImojopWV1SyrxdUZ3Y + DVUJqdieloi6uC6oTL0Qtf8YhdD2bdof7J/GuW9hYWFhYWFhYaGIWGhx8KB29VhsXHwJ1k7riM3TY7G+ + MBGr8xNQtshjLCdKzoEGzlziQl0uohEq4jlXLKDIoGICM3/QCiIsIriuIt8rYtBQ3B4Nn18K7JyrBEdF + ChUKTKYCImxZorEWSISUmPu0D75XhOqd14rXIumK4Tih9wj87IbxajWh7hg58zVLgiFxdPGYg9YD56Il + M3uoVcX+x6RoxftmL8bh2TPwwJwvsIvkD24KQt0XMHWjZkExKUaZ5jFc92+050cG9dXnPq1ttP0+JXck + 7vc+9qzGnTjlwpFqVfCrnsNw5C10U5irYhADSUbq8+aEWkvwOXQHypptYpUMyMfPcgpx3oufq+AU8Bki + 6mfcFT8FCPMOqBjD7X+Duv34nSrZHzlurrT3zziu90M45uoXcWT/aTJH5bnMMKOuJfPRlsFANSAoXTOa + Q7yYjXZDXsfKDZVSHTMGFFAa+J7qnGxS1wgIZ6bQ95pjWVPtfD1rOqZfcTnGR0VjXFwsJsd6MC02HmMo + UsTHIi8uBkti5Tcu+deoSkxDeVoXTTFKwYJWCsyQsTMlCTvTklQMYPBMigG7vF3UxaI0rSvKUvg3P7xb + SHVKd2xPTEa1NwVVHmnLtTcg8MYi6Zp6I07I+HJbR8GW/eP+9oUFDBWtBLQY4rbxt5PXEnJsYWFhYWFh + YfFjQcRCi4MIXEmt2+lUf/A0NuenY/PUGGwp9GBLfgxK87qg4uVzTGrRlanwL4tH3fJOCK3yACUpwFKv + OUeoGEFRwoUrHHxTTGhm6LPSEVzuRf2qWITW5AAVK/QjnASTBC2ISqc6VKurr0aoYMaDmt1BNL9H6PPk + I7/wzY9wSr9hmsHj6BvHm9Si2XM0BaiuIjM9ZeZs16LCrMi3YIaIvcncviJjjmbxaEmXD9n2eeo9fLCu + GsyG4BPCoqbxJCyBoBOsY6pKWuHQ3z/gBFzf9R8zjDjDfYpXJPNBDXBKQldeD+e6e0bjhJ734PQ+98r2 + fhx75dNCqGWsBhsRKWKfNyPC4kTLwQvU6oDWMa1z5qBlRq4KFKNf+xycX3TTUEHCJ4Rejr+1ZUxQxl2u + 4zwgni98B2f0vgdH9nnEuLIMzEPbzLkyj2ag1W0U1GSu3pKPo7OlLoMi13mfMGiuusv0fPJt1AqR9vko + lLFuZhy+Ud9vQK6rN+8x21+vATalD7audb6YXYCZF/TGaE+8ChXT4mIxNq4znvfGYpw3AbkxXnwY78HW + FEP0abVQmdQVNd5uqEzsji1J56I8wQTQ3J4q5+WayoR0IwK45XuLBQcadPVgXSqS0zVdaqn3XJSm90PZ + iL8Cm792RaqAzGfjbkZXD405o/3lChZhsCxIyzOz/63mj4WFhYWFhYXFIYSIhRYHD7hK7g8IKSAhKy1x + Kt7OwNbcOGyamoit+V5smNYFW2Z5UfNuJ2BVRwSWR8O3tD38yzsiWJQK45KxFyhKqEghf7O3mNDcWHYO + IPXBUgbL7IRQ0Zlo+KgbAhv/DlSv0Q9sNRkXEsNVccZb0NVyF7ryGqFfmguG4AuBkv3xC4pw8u9uR7uL + HsMv/jAGrZnFY6BxwWiRKcSPAkX2TE0fyUCCrfrzfARCty/InIxWXOXOfEmI5WK5/wx0uGc2nntjta66 + MwYBfCElMUpkpK70/ye5/SmYhZOIaSBVmQsBv5A3zgspC2dgWbfD76Tf8CBO7DkUJ/V9BCdfOBLODRPR + +o8vC2GnWBChz5sRFK8cuukwVgmDqGbI/Bg0TwUKWlB4R8zDjupAY6BP+Oq03iYw7u52/jc0yPhruxmL + RLa5r36AqMuH49ie9+DYK59Bm4EFaEXRTIWz2Thq8AK0GGiyw0Sq876gDduWxWCjC3H/LCO0mHnHgL57 + 1jMSND4FBVbXIop9wL9nH9CtrW7HRqfk+eeR36OvZvIYHxuLCTExGNspBhPjUjApLgYLEuLxUXwKyr3d + NGAmxQrGpqiMOw/l6V3VQmKbN0nKUlSgoCiwy5uOau83xYIDDYoo5YnGimNbSioqU7phV2y61Lc7qvpd + BUyfA9SWm/fbndvGQsjvoMEVsNyYHrrvgn1vrM/Cf2NhYWFhYWFhcegjYqHFwYNgaJds5SPUNQH3B33O + ri9ysXHeBVg/PQbbp3bGpoIErM5LwfYFscbNY0UUAsvi4FvpZvagK4eKBRQlDrA4wTgUyzsgVNJe6iXH + y6Lhfy8awaJk4JPfIrQtXz7CN+jHeaOVgMaDMFk+tO0K0x/NjpDPqXLjGpAAPDluEX7V624cLUT36Bsm + oU3OLLSk6TzN5gcxmKUxm281kLEk9n9lvi2FiYx8tLjNrMK3yqF5/mwcPXAqrhq1HOtLA7tX3Rkwkyvp + LskzKTebtOVHCIowulrsugc0QuaEP8AAonDmvvMRTu473BUo7sWxV/wdzgBatsh4RejzZkXGdGM9QWGA + AoWOpzlWFw+ZJ8++/JkJjklSGTJChXmnuf3vaHwHgvL+E/I7wLm64P1PkXTFEGnzQzjqsr+h9a0zZI4u + QNuBMlc5R6UObQbv//x0+uep9YST/RKOHLwQ73+xTarNoI5Sr8D/tmyqDwd/pDjB95rvtyCk7zgFJ9lK + P9SvXesse+hRTE7rjgmdY5AX78GUzp3xTJwHLyYkqGgxzxOHT5PTNP0o4zlUJgnJT0xGWWIKdiUZ94/t + 6enYnJqubiBMURpJMDiQoKsJM4/sTOuGHUmp2OFJQnVKV9QlC2ITsSYxHb67H4D/o091jqgYRwsK9gvh + 9iOhMYrc+c93wswNCwsLCwsLC4sfDyIWWhxkYAA6psB0P+z5UVpX+ZFTsfwRbC4w4sSGQo9m9mDwzOqX + mWK0I1ASBRSfLWi/l0hx4OBbFYPASlcIWUpRRMDj5VKnd89Bg9Sr5tNLEChb5GiKUbYRJmtFCNWyDYsT + Ybh90kwwBN+IEwGf+fh/bPwitOs7Ar/s8wiO/MM4dbtQwjdoIRwhaMwEoQS0OWIaZL+MFjmFaJk5UdNh + tuDqO1erGcNAzp02ZCFGL9kEJSbBWiW3GoOCq6YkfHu158cGurHo2NDCRcaGsQuCARkzNwZFMFCn5+94 + ZhFO7zccx/e4G6dffD+OGsAx2/9sK/8TGdPRahDdfmQucOzCFhThdLSD5iHpwZewvVba42/Qd9cnhF2t + J0g0uf0vaLzOhZ9uIdJurrK/uWod4q95SDOXHHbdC/LMGTp/WmbOMYFBmYkjUp33BYPna8BPJ0f6Mns+ + +vzrLTCQbYPW51vEnCDC9Zf3jK5K7AOige+6vPOhBvYJz/ud2o8+wLt33Y0XvAl4Nj4KUxMSVKwY0zka + oz1xmOz14HVvPNYmJgvBT0dNQleNRUHiT5GCwSkpVDDmBF0qIgkGBxIm9oUJpEmxhG4p5YlGVNmenorK + 5POMiNK9B2rGj0GgrqJxrBlnokHmObM6MQ0pLSUaBQrpL2OBY2FhYWFhYWHx40HEQouDCK4YwY98fpTW + B2naHTaTlu3W95wNr9+MdbmdsDM/BlvyErA2LxGlCxLR8I4rEhTHCDobhANianms2X6P8BXLdlmCIF6O + Y+AviUb98nj4i+V4BYUKiibtBWcCn18LlC9TMsOsHiYYIi1GCAoThNsvzQQSRb0vn+V+9NdInz84ej5O + 63kPft77IRx38zgcljNdiKiQP6ZbzJqvW10lj0To9gkzBAvQOnuhSRGZbUzx6erRcsB0s/rdfxqunfgR + lm+ugZJyqWfQzznw47ecaApajDRaUOiYsf0yNwJ+59O15eh85f04s89daNfrXvzyWiHrt77apJ+/H6hV + DfcpXqlYJciZZ2JQUGBSq5vZeOWzHeB4hd/lsGtHpHbugUCDkni6QuhvgLRbY1C4wtRbqzYj8Q8jcVLf + ETjimn+j7aC5OIzuR+ri0QzzU2NpzMbhmTIv1YWlEKPfXq/uHeqyEa7nfwIFCM5XFWRoceEXwl2vFmDm + fTbkOxxTQ/tFzm1783XMv/WPmBLVERNjozEp1oPJnT2YEO3B2OhoFMRE4/3EVGxP6I4did1RkSjE35uq + FhXVSemoSO6qwTEjCQYHFPHJ6mpSnkJRgmJFV2xITceW5HTUJnXTGBRVCcnYlZKg8TJqMm5HXXEJ2Ccm + nWxQBYoa6ScKFKZPzTtA8eIb/W1hYWFhYWFhcQgjYqHFwQPj6iAkxt+gq4uG3NCqwJj+6vn6Gsf3yWTX + 1SMO6/OTsHpaAtYXJqDmtQQ0vOVFaGm8K0ZQnAi7c8S42+8RSzrK8zyyn4hAkRcNxR4EV8ZpWtJQ0dly + Ps7EpNCAnecgsErquHY4UPmFfoAHgvRtd0mofpx/C0K0LxAixFVoEl/eW9ObatBJOA+NmYdzet6JX/zu + bhx/02i07Z+L1iRoJG1qwi/EbW8yt48gmVRrCd6XRFbQJmM2Wt+Sj1Y5QggzZqL1YCnPyMfxdy/Ek+9W + QEmL1PGnEHOC8PlkvodCSs5JcmnSznKKWPVqRSLXybg9OP4lnNHrDhx7wUgcc9XTGhQzUp83JzRY6gAT + e4QWFCZAJuM00HLCtVyQ48cWfizVdNvE+grMvHbL/hOkXZyLfO85P0M+eQ/0b6UvXKuRN1duQPyV9+D0 + nvfh51ePkjlUgLasT/bLe9T1u4HzfB4Oz5xs5mf2PHQaOh/bfOE6/Q+4bd3jmKliaQHQYKxAAn5ph4wv + 70fou8hYK9LetfNnIO+qazC2cyKmeZI0o8eYeA8mJ6VgVLQH8zvHYrmQ+02p3VGR3h3lKenGgiIhDdWJ + B4FbR2o37EhINZYTaedqWZW3CyqTuqHMm64xKLYnpWF7Qgq2p5pAntXpPVD396eA2u0O6uR3Xn7/wxYU + 2oeMQSH9aC0nLCwsLCwsLH5siFhocfAgKB/yZjVRoP7ZJOt+JdQsJ0hW9ZqKr5zypSOwaXoytuVGYdvU + JHX1KJ0Tj9rX4xFayngTFAE6CWg9cQDEieXtESzugEBxZ4RoRUEriWVnaXBMChYo6ohAUQIaShIRoiXF + 8jM1Dar/w37A6ofh89eqQNFUnNDVc7a3OcCMA9KXJPqaQSFYLTDpKuny8c+8JejQ+078stdIHHndaLRV + y4YZSkpbZOw/+W2RweCa+ThsYCHaMABnppRztTpnPlpnCPGVbQtNXzpdU2O2kevO/cdbWPD5DumKmsht + +hFBU1ByK2NuXDyMgERSTqhAo4QXzlebduLsS+7HCb0ewlFXPoPWOfkR+7xZkT1X54JaUGTQuma6yfCS + NVPBVLEtsnMxcPIShLPT6Lss+FbZaPRaEnW6OBlhwlhNhQOicr6GnKUlZYi98i/42SWP4MhbJoJpRHX+ + RKrzviDnFZl/BbJf6ApzL8l98/DIy2tk/vGdZB3+G3aPWZD1Zv0FxpJC9tk+t4xjzHdQRRyWy++dCiDl + lc7q3KkouLgPxsZHYYKns1pPTIpNxIueGEyMjcLCuGh8kJSgQSerKAokdVHSv7dYcMDhNSlQ6WrCgJ2E + up54U1WIYB3LmR415TyUJZ+rMSoq4tNRmtoNNZdeho1vLoEKFNKHFCi0T93++lbikIWFhYWFhYXFIYSI + hRaHEMIf9lyJ1DKfU7vlDWfj65lYlx+jmT02TkvExrwk7Jzngf+9KISKo6DpRZfS3aKjbD1goEwNWrm8 + g+x7VTigSBBZcDhw8H/UDdgy1kGdkDBpZzBk4i6E262CBdsvbSfZ8TEWA8tJbr5FwL7/BT5rzOxliOk7 + FCf/7h4cd9WzaDVAyJoGO5yNNow9wfgGObIdLGQwezoOyyhA6wHGBeQbZG8fwXgUzBBiXEgEOQv0+ccI + Ybw6byu2batRkkr4Zey5Gk/SosSP/eA3MRtoYaMCTLhvtO++Dbk82OHGYhHiRpHuijuewa8uGIrjr/ib + 9NUctBxoEBYLCMZQCIPBTZuiRfYs6fMZmtq1xcDpxqJlbzS51hlENw45ZipY3fK8lLlbvUbG7dapq6S6 + Mjc1qKXU12/G6Zvt2TdwNd24P8F5o2iNzNO7cMzFf8ERN+ehzSA3XoTGv5B+yF4AZjBhzJSWTLea9S3E + tey5bkYSk/L28MypUr4Qp/x5NtZVyXP57FC9zC3+/lB4ocDHMjcN7v4iYEg42xnavs1Z+cRTmNj1N5gY + G4vJcZ0wwZOEF2PjMcrjxcSYOLwam4TVdJdITENNchq2pSdiV2qaZu/YkdhNBQC6VjB45rakBHUF0WCa + TPmZmI7K+DR1r6CwsD3tILC8SOqKHfePRGD1V6Y/pL+N5ZxrPSdldTKXKAAZ4StgfgcF+htgYWFhYWFh + YXEIIWKhxaGD3Wk35eNdSIGPxIAkoeorp+arudgwqys2z0jBpvxYrJ4WhQ3Tvah4xaOpRkMfdoBviVcz + exirBgGDVtLVoigOwZI9hYIfAoxPEVzeCaGPr0Bo+0L9KA8oqaZYIVtdjeVqa41+oJOI0+JBTeZd0rY/ + UAIZDDkFb36Gs654BMf2GI4TL/0Ljs7IFWL6kiF4gxcJhOxlCkHNlGOa0+csFgJIK4u9yN4+gllBWpLs + CsGmST23bZim8uYp+Fl2Hk6+Zx7++crnqK+X9gak/Wpdw7r7hKDU7yYozAAQqDV9JucbGoxosXd7DzmE + fE6QgVRl7Cm+3P/8ApzWYxh+dtW/ZAxkLGiJwgCmBPtQ+1HKCOlHBo7U4JGM08CxEzBtLAm8YqCJL6JC + U/g+gpa0ZmFmjAGzhLTPw2Fyvo38basBMmYC7rOcz6G1zTPvbZRuD6plQL1a/sh4BWU89m7PvkLffY6t + IaTjFy7FyT3vxtFXPYHDbihQMUazhlCgkL7QFKecpxTYmIUjwpzbA3I956D2S5b8PdOKZi/G4YNm4t9v + fC2Pl+cHTXpUtTzS+rDM1yzihM5fzmmZ24xZEZA5Xbn6YywZ+QDGxaRiSnScihITO8RgWqwXY+JiMCG6 + I5Z5k/A1M3p40jVTxtbkNNBiodqbphkz6GrBmA8s25FiAmgyNoRaOXjpGpKGbXIukmBwIEExpdYj2159 + satwEhCol741fcK+b3T1kN8oHpvxMKDV3d79aWFhYWFhYWFxMCNiocWhA5LnoJtikGiQj1Szii7wS1nt + 58629+5Uy4my/ATdfp2bii3zUlD2xjkIfBKDhpVnwrfsbDdoJa0mpHz52QiVMFZEZNHggGFpJ2BFHJh1 + JFDcAfgyG6gsMgQIfiFEldJWs1poyDZFCSFLIUNWI/XZPsFdiWR/vrlqNVKvf0jI3734Zb+/4PAbJ4PZ + O5wMIXpEzkty/LpZoR5IYWL/3QpaZcxASxJsIZe62i3HJLyaISIzH20H5unKdvpjb2NGyRaE1NReCLtu + SWTYH1xVlXkiBLbRJYIEWfvwUIe0TQU5ZoJocCbNXYbje92HljdMkLEQUk6BiMFMmbmCYgTdcSg6ZM7T + wKZhkUKFjEHSv4PnoQWFJhJ3+Ru9nnElwtYStLgYKGPhwrlVztFqglYWtKIYJPejpQsJvWyPzsrDpU++ + jLW1ModkXnIe0cKjtr5G6k1Xjb3bs48IiwEq2JlMGI+MnYPjLrgLx13znLSz0NRf2yDtkXq2krnZcpDU + MUvqHGHO7QHpm9ZZMrcpwjEQLC0xmLkjYy66PvIKdlEcDJrYF42xQLRe4VTA+wcGrNXfMhf8fdP5XFvr + bFxWhLdysjHKm4Ix8QkYkxCH8VGdMNnjwQudOmF6fBJWxqZga+J5qEk6F5XJqShPTcauxGQVIcqSuqkg + wWwaW1PSsT3VCBR0CSEYxDKSYHAgUZ2QiF3JiWhIS8eO+G7Ydee9CH75uflt88k7HR5/gYnbwVS1nAt8 + L6w4YWFhYWFhYXFoIWKhxaEDNeWnmwNjJyhJYzDHeiGhJh0nCSnJQtWmRdi++DJsmxaPDbkJWFfgRWle + OkpfaY/Ass7AKgoTCbofKjlb9s9B6P3vP5vH/wLjUASKohBcInWheLLsHARXJCG09i9AzXohelwxFBJO + ccbP3P8mcJwSJO2P/QRJlhB8xvlAsN5Z8clq/HbgP3B8nwfQrvdQHHnNU/gZiSlXyYWwUUxgdo2Wg6Rs + cDNYTmTPEwgxzGD8Ajc7hBJEkukFcAYYtwVDpgtw0eglKNpaK1Vn3QlaSwiJ8ZtVaAMTx4RxS/Zo6yEI + Q4S5TyLmc2a9XIzjLnpESPkM028DFyuMhcR8tXYwVhGMCzEbR9+Si5/fNBU/u2Eijrh+PH52/Vgced0Y + /Oza0YrjL/+X4rjL/oljL30Sx1zyBI659O847pLdOPbiv+n2+Iv/jhMukbkh22MvfFy31z2+CDsapH4U + iXQewakOx1JodMXaD8j8VGsZabu6MQXoYiHT4oEJOLHHn3FY/6lo0Z/zkILLPJk/Mq8y8kC3FRVmIsy5 + PSDXMM4J04iyH40VjyB7AY6Qe72+ukqqYciwCoQyFuGgsjo2+wuKEbJtSsIJPksDw/prnK/mzsacS6/E + +KhojI6PVpFiYkw8RsclYVLnKCzwePBJkvzWJaZjZ3wqdqZ0xa4u3bFd03saEWBHaldFmZTRakJdPFK6 + fUMsONDYkZKEbSnp2JSQhqrU7qiMS8a2X/eAb/x4oLbCuDRJP+j7rO+A+T/AoKLN4lZjYWFhYWFhYXEA + EbHQ4tCBP0ARQvb5QaouDiznB2pATb35AR8iQQ0IifftdHZ8+S9smt0F2yZ3wNapHmyelI6K2Unwv8Vg + mTEIrDDpPunWgWXJ3xALDjTqmMVjZXtgBYN4xqsLSmB5e6lnLAIf/Br+7U85qP5a20rCxw9ybhmbgu4e + e/fXPsONb0GiZciWz9lQVuFcP/w5nNFnCE7ofS+OvPxpHJYx3fj4C+lrlTNdMNOYz0cifPsCZnzgyj5X + 7t1gi0wzGl7J1uCZanZfgBbyfCdrEQ4X0jhoSjE+L+VKvRs81J0bTD9Y7aM7gRDKAEml285DFGECHLYe + KlxUghOv+JsS6iMzCtAmawbaDsjH4TdOxFHXvohjrngKJ1z6N5zc7y84ufeDOLnPCJzU+z606zUMJxM9 + hqhbxKk9DE7oJWNM9L4bJ/YyaNf7HsVJMv4nybWn9R2moBhwSq+7cOZFw3Fan3vkPnfi8VHzoSKEr1pX + toMBionGGiCgosL+wu8EQg1KTvXdD/ocfz2cTbUhp3f2I2jb9zH8/JYpOOLWxSpkcU4ZNw0KDPN2z7P/ + Al5v4qcsQuvs6WiZMdV1FZmNWyctBdvCmDdGnDBtYz0Y9DJynfcB7CMScAGFD30PZRt0M1bwOMA+rdrh + fDl+Iqaf1wPjojwYHR+LSTHRGkDzudiOGOeJxisJSfgq4VzsSjxPLSd2JiRq8EmCgSgbhYqkdJNdwz3+ + IVGa1B0VAmYeqUhK0WCfDLK5pet5qL32D/KbuAJoqJbfeTd7D0XIOiPOhi1ZLCwsLCwsLCwOFUQstDiE + 4JJOfozy47QOdGcwRIErmJoRQEkLISRJSETtjhJnZ8lQbJjqxZbCaGyaeg5Kp3dE7ese+Eri4F/lZvN4 + NymiYHBgEYPA8liEaN3BDB8rPGj4IN4IKMvPBpbGAl9eBv/2OU6g1iUv8qHOlUNmd4jYZ/sIJUP1xg2C + fcx4FhUNAWfo8/OVyJ7S9z4cdcnjaHHLNDi3CmnLocm/EMGsRd8gevsMWkRw9fpWihAUKOhawFV/xgKQ + MnUpmGFiCTB7SPZLaDFoMdpk5uPUu2fiwXkf46Ny0y/w042Aq/dcYZW+EcIcqb2HFlwrGW7lXXi+YClO + vOyvOPL65/HLq57DyX0fwMl9RqoAcVLv4Ti1DzFUcUqfu3FcnxE4XsavXd8ROKnvvWjXZ5iKDnpN33tw + Wu8RjfhVL+Jexek9hytO6XWfihqnyT1O7XMvTuktf3/BPTjxdxQp7kPx19ulmlK3UMBdyaaIYuKjNAt5 + pzghW1rB6Co64c7Tdz5eg06Xj8AvLn4MP9NMMDI3M2YZgUsDYlJwiDDn9gADaMrWjcdxGIU3ihPZZh52 + GjITO93fIBOY04xHMNTQPO2T9vB+dO/QcaYlRT1/0+Q3Lvx+87kk5YJda9c6Sx/8CyZ7kzEuvj2mdY7G + tFgPxgieiYlBnicBy+KSsc6TrKk9y5O7oUKIf2WCyZJBiwlaVhiXjoMg20d8GnakpqM0JRE7vSko99Ka + 43yUelPV5WNdlwtQ+cQ/gdLNMr9CJuaQjEfIR8GKWY7k2MLCwsLCwsLiEEHEQotDCCQFQRICkhQGizQB + I417g08/2knUzcqyfLSGVyJ9252KdbPw1bzfYvX0OGzM64RthfHYsSgWDcujgA87myweEQWDA4hiZhSJ + k7pEI7Q8DiFmEnkvEVgSD/8KqV+JlC/pJFup75r+QPk70j5+lAuawTJAV4FdEqTkSPZJBtWkXAjnhAVF + SLh8CI4XQnrcpY/i8KufRlvGHeg/E23UFL4p0dt3qGtCf7qN0JxejgcxNSVdOSiACHEcNN/En+hfIOVC + PN19taxgYM5bZiJq6Cw88con2FJLUYJWNSaNY42SyUMbIRlrHSPOfyFlgx6diXYXP4KjLxyBYy8YqZYt + J/a5D+3C6CXHPYdr3BAKC+16jVDx4owLH8Q5lzyEzlf8BfHX/BWpN/0T3QY8hd/e+k/8323/wu//+DR6 + //lZ9LvrBVx0z4u4eMgoXDJ0NK4aOg6X3vkirrhnNK4cMkaOR+P6+8bj9n/OxlNzPwIFCQoR7G9d2SZI + 3AVGJNrdlu8CWmLwvab1BOengbz/GiQUztNTXsU5Fw9Fmyv+jSNuX2ziaXB+MH7GoIV7zLXImClzyRW+ + MmV+0SKIbh4yHylOtB40C0vX7oL+DqlIYVKHNqYEbQbQGoP3agjSbcv0ZbDB/LapKwvbL2VarnPa5+xY + 9g5eviUTY+ITMSrag4kxzOYRj+djO+PZ+CjM8MRghScZa1K7YFuqESloPbHTm6auHRQmyhJT9hQKfgBs + 7ZaCrckpKPOmo7rLr3W7Xeq4Pa0bNnfphrLUFFTFd0f1JbcAL70q3VVrfvcDAXnP939+WVhYWFhYWFgc + SEQstDh0YOIHyMcowQ9zfrCTmLgrqCRvXGWkgEES16DCBV1BhHCTTGz+wil7889Ymxetbh5b89KxbV40 + at47G1gRQSw40Fh2JlBMV5MYDYgZLOkox7EA3T2WninlcVLe2Rwv6yDnkoHV9wKVH+8mg/sDf7X2sbGY + kGP2sY8En31uhIr3P9qIy//4DE7tMQTH9bsfP2M2j6w8IXH7bznBVKWH58xHa80MIcQwhyveDGTIOAAU + IeQ6jaEw0xBHihgMnpnDrBOFRtygSDJoLs4aNg+PLfgCG3cZ9wIVcMLtPGRhxImAv86prIaTcsVfcHzf + +3Fq3ztxZo8ROLnXUERd/hC6Z/0LVw4dh9v+UYi/jF+MMbOXIv+VlXiz6CMUffQ1Pl27BRu273LKKmqc + ipp6p7bO79Q3+J06f8ipl/fEL6AlEsmvEQAMeBwua3rO52PfyjwJyZbxX0gU5e9p3aFzSK7R2Ayy3S/w + HjoXKVDWO/UCzkkNGim/BVxJv3LIv3HkFX8HY6GoVQ/joWRzDhnB67/BuIDM1uChGpiVcSpU1JD5xTmZ + vQhjX10FdVFhu0K0zDHWOVqP/QSFCdOPhPRxmHDLfqCBblx8jrRdA8DyHNstkHZzXmxfPAezb7oR42I8 + yI31YJwnCi8IxnpiMSE6Fm926oCP473YltwFFcndjEuHCgNpYIrRSILBgURVQroKJ1sYtJN1S+yiwT3L + 41JRHt8VpWmyTUpGnUfOpfwG5ffej8DqT7TtRrSzsLCwsLCwsDh0ELHQ4qeDWppeB3c45R88ga/zk7E1 + Nw6luUw9Go3K1xOAkrM1KKVvRbRJLUo3iqUmPoVvOS0rYgTcChingiIBy4pdRBIcmhHB4rOMWLFMnr+s + o9T3HDTI80Mr+gFf3yNciUJMjcAl4kqg/EpmwkSSbhuGMArJc0mkIXtuPI//Ag3GKX9XXhVy7vrHbJzT + 816c3GMojr/4YRz9h+eNCX3/6TiM2RIYyDKrUEWElgOmK+E7bMBstGUKSpI/mtkzsCZXqpUccpV6N1H8 + TshaoPduk01CuUCOZ6DDvXPwt0WfY1uFtIFWIYRf2iHEkvt+IXfsF22j9Iu6tXAbLguGXNLoHv+QINmn + eCD7Y2csQXzfO9Ej+1nc9uQcPJH/FpYsX4FN28pUYGjaBkNyiSb3+jFCSP3yNZsRd+n9+OXlo+DcWgjn + NpkXA+gm9O1iTvw3HJ49Az1GfyjTRJ7lZu0w6WyNJUfEOh1AKEGvqXE+mjwZk3r1wujozpjiicZkwfjo + jprlY2JsLBbHx+HLFCNGVCWmoYqWFEnM3tFVUSb7xM4k4/JRnkLrih/esqIyPs3Ez+CxNwUVcryr7xWo + mzRJpnelClQUiShKh+jiR4sK9z1g/BkVyPgOyZZWPup6JOUsM6K37FtYWFhYWFhYHCBELLT4CUE+QpWc + y8epb8NiZ/OiXtg0JRqleV2wPq89yuYnw/d+WHyg4NAJISH/ftkPrDrbiBFhqFARRjRCy6J0+31CBZMS + L7AsUeoQJ/sd4Cs6B7VLPfCX/EbqeAGwfYKQ0QqngR/j7sc5206fbH6k++WjnSn41GefATBlyz75ViuP + QZ9aVRjzfTiFi5ch9soROKb3Azih9wjN8nB4Rj4cBqvMpggxV0idEMOcBWZVOocWENzONKvShEv8aDbf + lAh+J2gsijy0zspHi8GzhJzy+TNx+KBCnHHHTIycXoJPK0396/wBN9OCAfuALkIq2siWMQTYJ0o6Se79 + Qna4/4PC1M8XaHCWf/g5vtxW6+wQQlbL+sv4Nkh7SM4IfyCkAgX/TsWJ5giYepCD4lytbP8+5R0c3/cR + tMqYLOM/C60pVrmuQvuDlgMK0PnBV1DFmCwyDjp/CNk/KMQJplNGUOpV4zRsXesUPfEPjI5LxdT2sRqL + YkpUAiZExWF0bAwmxnTC+54ElCYIwY9PRlk6iX8aSr3JKE1Kwa7ULqhM6qoZP3bINTsPgmweu7zpKpgw + DWppWjoqEpKwKzoN28+/CNtuvh34qFiaX6Hvt7Goka38BjI2kf7OsUwDtjJGSMBYm3H8aH3ns+KEhYWF + hYWFxYFFxEKLnxDkQ9QX8DcGzvRt/cLZ+u4d2DAzCmXTorB5qnz8zklAwxudVWwIFUchUHKWcbEo8vxn + 64hGsWKv8maGf7nUaTktNrxujAx5ZkkHrWNDMVOiUrSQaz+9Ctj1in6M8wOc6UHDJFyJuBBZvxBdfsT7 + wquMrt/+f4X8LS0NaHEQqNmh9y9eW4Frh4/G2T3+hBN734tfXvIo2l43Fq2zFqH1oJfAzBqOBihcBGfQ + TIHs5xAzNG4EY0qo9USjBcX+YIFJq8kghhl5YCBNZ6DUgfEoBgmEpJ41dDHuyFuBFZsqwb4hDMlkVg+2 + zbSVbaO5PmMamBgnJH5N+uIHAFd/TewGWnxIfdzxVHeKUHmjMLGH5cdPCUFjwbB5V8DpdvMj+Pl1o3DY + ra67UVZ+k3nyHZExEz8fXIjV200GGJ++C3y276CwrmnqYqLkPBhydhSXYPFtf8ZoTxryOnowNT4JL8SY + oJkT4j3I83RGcVIKypLPRU1iOmqTuqAyORVliUkqUmhMiqRzUeE9L6JgcEDhTdsdKyNF9tNSUOlNxI6E + VJSmdkdp198i9PyzQOV20yeuJYWxfgqLFPJbqK5BjFcU1HeF16hQYWFhYWFhYWFxABGx0OKngzqEMzb4 + hJTXGguAep9T88HzWF8Qh81Tz8TGKUnYXOhBxWvtgWJaUMS5QSgThPzTOqIJitxMHyoS0P3jm4JCcyK4 + gmlGO8iz+Fx55jLGo+Cz5XzJOXJMgSQBweVSpxLGoxgOVH3iEightEpkhdS6AUP5UW4sJuSj/VtYBrC/ + wLSlvl16zJV6plWsk3s9MfllnH3lfTjj93fjV71G4mdX/gMtBkwxq9b958PJMa4cLTPnqD9/y6yZJshl + 9ixj8cB4EZEI4T6gZdZCjTtB95I2WbNweMZcBWNZOJm55jp1N5mFE+5chMypH6BoUy180hbTD4bccZ9l + SmzC0D78YREWHHwNdWb8hHyp1QstgqScRCssTISv1QCLB4tbyvcOzm22NeiMX/AOTrj472jdn7EiZNyz + 91+cYIpRps9d9vVOeZzpax0HjXWzd10OPPyBWjMPXNcFxuDQed1Q63y9cAFyr7gIo7xeTInyYKonAWPi + PXg+NhrjOnXG3LhkfJ6QgtLkLqhL7ooabwp2JiaZ7Bmp3VCayIwee4kFBxibWZc0up50kfqkqXhSmuRF + WXIidqYmY1eX7ijzdEX1lQMQePctqKuGCo+ET61qVKylKMF3PSi/eWpVxLKfyjtiYWFhYWFhcbAgYqHF + TweGtBkrAhILBtRTEufzO3Vb3nU2vXQ51kxPxvqp0dg6LR6ls2PgeztJiL6g6HQEl3Yy7hsUJRoFClec + oJtFBEGhOUHRIVhMcYLBMKUOFCeWyHO5XRaNgJTxGmb5CC5L0KwfWHEesOFJBPybDdkmiaKowPgUai1g + +uXbfZz7dQWS+z6fMWUnGEyRZStWbcflQ5/FCX3vwCm9h+Okvo/gqBteRKuBhWibswgtMokFMKkam5A+ + ZuTI2X9xosXAAiGhxirDuIzMU+uJFjwenIfWOYVKLhlQk6vgtLT42R8X4bJn3sX8j7bCZEgwhE7nBQMT + CtkNcgWWhI9lPyBM33PVV+atZmkx8TJIuFRoc7H7+p8W4dJ0njq/a51dDSEn9aancMSNhSbl7SCZAxHm + zD6BwVZlri5etQ0Bzg0+V55HyxoV+Paqz4EG0yrrvloKuOUk5vpbJ3O7fovz0ZgXMf283yO3QwwmRsdg + dHwsJiQlY0wUg2jG4pW4eHzhTUdV8rnwJwrRj09VEYDCQCTB4ECi0psq2zSUJjOQZ1eUJ3dHZVI3VHvT + UJeQhC2JXbA9ravUNRXlKb9G4KHHEdqxwamR8dGMQ3yHCfaN9g/7S8D3KmDFCQsLCwsLC4sDi4iFFj8d + hLjq736sQ60oapXwcZVcP16rvnS2FT2IjdPlI3dKLDbnerFxZjyqXo8BiqMEXph4FHT76OiKFBQOXCuG + vcSE5kaoKBGBZXFGIGHWDnUzaYpfacpR34okI14sPx3+5R3RsKI78NElwI4JDurXK/kO+2UzzSNTM6pV + xP9CIKjWF2b10ef4w6kt2Z/q7w5nVzWcf0x5EzHXPYQTet6BU3vfjWPp6nHjpN1WEoPnClkUqMUE403M + VEuKiIRwX0AXEYJCh2b6EGS4sQYYfyJbjgeYIJ3OQLluwEy0zSpUMBtD33+8i+dfW49NZTJP/AK6S0ib + DOH/4ckn+1ndanSf8UJk3y9bIcp+X/1/FCNYrvFHIpz7MYHjpFYDFNFk/5Exr+Poq19w54Rg7/myr6Cb + UPZczCraLEMhz5F+Z+wWdf/RDBp71udAw0fBhO8i4ypIH/jkHa2lhYCWydwRsK6Vaz7DWw/chwlpaZjY + qTMmR0Vpdo/RMXEYExeLvHgP3hKyvy4hHTXebqgT0l+Z+sNn8/DHpqKC1h10N/Gmo9zbHWWJ58sx42Gk + oTKhG8qlrgzyuT09GZuTk1F12R/gn78QdGMLi3maRUb7gkGSKVw0XypYCwsLCwsLC4tvi4iFFj8l+J2g + kIhggGbxgkCDHJOkM/5ClflAra9xqj4aha/n/h/WFqRhfV461uV3RunCjgi8R2FiL4GCwoGm+/z+LSeM + a4lH418Ei+SZJTEaFyO4vJNs5fwyqUNxJ/hWnIXa4g6akhS8ruhsufY0NBR7EFqTA5S/KaTWWD40rhxK + +yP3WROQ5MiWq8YUNlTccF1EKPowSr6KP/Lh/+Hnm3DDfS/g+N5D0K7vCJzW48846vrncMTN49EmKxfO + ICF7g0j2BFmzNFZEREK4L8hZBCdzPpwBc9A607h2tBo4S91IWmTQsoKihVwjaDlwjsIZxEwOc+TcdKkL + Y2PkoeO9C3H//M/x+fZqnSMkM99KvPm+QVJFgUKgY+f2dVhwa0w92QQ/KesJncemb4KBeueTtWU45aq/ + 6Nwy8UcizJl9gApoOQswvWiLPIbP86s4wffgYBAn0CCQeWCyVXAuGBcltZhy4y/4feF54nM2vv8mZmZk + YpTHiwmdYzAtNh5jPXF4Ji4WL8bGYK6Uf5CUji20UmBQzAiCwYEEU4tuSaPwkKrZRXYldMc2r0k9Wpac + iu1JaaiVY6ZI3ZyYhMp0+bv4NGzrcgECd44A1n8mv+87pU+YYtr0FftN3xG+QyyzsLCwsLCwsDhAiFho + 8ROCu1pmVv7lmB+n8tGuwSD5cSqgRYCmzCwrcspey8Sm3M7Ynh+Ldfny8TvvTNS+QVeOeGO1ELacoDih + lgtNhITvAaHiU+VZHTUoJt02QiUezeARKO6sWUXo2qHCSRhSr2CRnNdYFHK81Ct17oDgSqn/6ruByo8a + ie23+ThnADkVM+jXH/479wNfCRAtU6T/2L8UfXz1cKYvWo7zb3kMx/Z7BKf8/l6c0O8v+MU1z+OwAXkm + GKZaOcwxVhURCOE+ITtfXUjaZM3QeBYm8CYzhDC+BcnpArTOnIm2zOjBIJ20rqBgkT0brSiUkMQOlrJs + piFdgOPuegWXPr8UhUVfo7q2orEffjAEme7V59SHTB8r2fQzWKeZ08a6I6hkKyxKcBtJtPhRgulhZW6a + 2Co+Fc4ueWgqWt+Si7Yc50hzZh/QKoMuIotlPmyButhoOlr2vfteRKrTAUQ4GCZ/2/T3je8oBQuZIyoc + BuR3jVYV8psXlN88fWfrapz1s2ai8MprMJGpR6PjMCU2CRM8SRgV59GyV+Pi8NlBkEp0V0I349KRkoKq + hGRUJnTRQJ47UxgjI0nTnm5LTMa2lFRsS+2KHYndUe3ppteWJ8dh8+8vR8OkqUBVqY6Zvhd+eU9kDI1Q + a2FhYWFhYWFx4BCx0MIiDAZKU2GCq9EULBrKnU2fPILPZidgS157rClIwrppsahalI5AkRe+knPUYoGu + FgEKCIzzELag0GCZB9bt439iKetDYaUj6pafDt9H/wdsfA6oWyvtJ7liPAOuANMawhA9k2LT9E2jiMGP + evYRAzJS8HE/7sMf+GYVmfczf7txR7Xz+HPjcfJlD+HUPsNxWs+hOL7vozjy2nFordYMtF4QZM9UiwqW + tRowGy0yKR5IOQWMwfPVGoJWEExRqsE1BbSG0KwfjCsRgVDuG+YY033uZ80yATszZ6Ct1OnUke/hyXkl + +GgnTcHDbQ5qthONdeC2l33QGI9Aypr2hfZRE1EnvKqtq9zsb/0bi+8KteKR/jXWUFJWX+vkvbESLW8c + LXOKc2nv8d43tNK5MQfz3/pQhtRY0zAtr7p3NKnHoQa6/NTX1zuf/POfGHvebzE2JhHj4xIw2hOHUZ4Y + jIuPw/jYWLwVm4IvU7qgIj0VlYle7EpMRgWtKhLTBama4pNWC0z5yXIGrqQ1A8tq1PUisuhwoLC5WzR2 + elNQd/Ng+S1cJj9fQWMR5f7e830MZ+/gO00BilZ1Pv5P0Awfe/abhYWFhYWFhcX+IGKhhUUYJJph4hgI + MSOFkEauPK5ZjI0vXY7tUzth6/QUrCk4C6Wz2gNvJ0MzZQjZp7uHunnQokKtKqLl2A2W2dTK4gdEYGki + AkVSR7p7FKdo7Ira5WfC9+kVwKbx5iNdSbKJLaGEi9k9mDpUEF6R5ce7AUkZr2d8hoomBI1k3KxMMk0n + V/Wr5N4ffrUBGQ9PwIk9hytO7zccx178AA6/frQKDi0GLYRx86D5vAlmSTGiTc4sOAPoCkJrBzmXTSFC + yrJ2W1uoFUYTIvmdkC11ULHD3ItZP5wMeSZX3umGMngujrl9Oi596g0UFG/GjjpmOKGII+2V9hlRgpYL + xoc93F8aWJMxLOQ6E+MkpP2nQg/7PHydxX5BxR++vzovZSuE8uNNlTi+/yidR98Y731F5lwN3Lrg7Q/B + ceO8VmGJ4+rW4WBGU2ua8H74WGOSBBuc+nVfOu+MGIGxneIwPToe02I9GBcVjQkJiRgfHY3pUTFYGpeg + GTyqU7piR1KyWi7sSD5XA1ZWJKerdcOWpFTd7ko7V4WKsvgf3vJiR0IytqV2QTldP9J7oeGf/wYqNjuV + aJB3UvqCViW0CuM7KfsqdrmWJvb9tLCwsLCwsGhuRCy0sAiDUfeZGpPiBMlGvZBHJR0MQrh9o1P+3t34 + usCjbh5l+Qkai6Lq9RSgKAF4P0pI/1nA8nPkmKIEXStoSRFthAlm2IggGBxIBFemwFfiNVYezPpRJGC9 + adVREo/gF9cjULZYibMSLyHSQQ24KH1AIi0gAaeJeL180BsXGFfQkQ969hXFCCWHrsUABQqf9J+ScQaY + DPidea+vwkV/fhEn97sPx/UagnYXjUC7yx5Fq5sm4YismbrKrdk7sgvgZOWh7cCZaNtfyOGgWQbZ0zVG + BANptsiScndFOyKh3CdQGHHvw3gVdPdwBQqNiUHRIoPH89A2cxbiH3gZ98z+BG98WQZ1qwhUmTa67eaW + fUNiU63njVtG2ELFCDtyDedcPffZdxbfFZxjKhYwlgwJZsivaW7PvXuya/UQHufviKz5aJNZgFeLPlNx + otFiRsZa04ruVZ+DGU3FiTBqBMxYQ7Fx09svYdGNN2NclAdTYr2Y3NmDMYmxeDHRixdiPJgdk4iP4lPU + aqIupbsGqKyKT1ILip3M7CHY5U1FeUIKypLSNYtGJMHgQKIqvjv8iedKfbzYmuLFjoQ0VF01AHj5FWl+ + tVOm/cB31ryfRqQwv4W1OtZ79peFhYWFhYWFxf4gYqGFxR6gL7l8oKo4IR+kdULClVjzQxWVTt1nhVg7 + 43yszm2P9QXJWDstCTvnpcK3hAIErSOE7KsYEOOC+1LG7BquSPBDIVB8OrAiDqFiZv3orPEoUJIidUuG + r6gT/MtTNdtH4KtbgYpPtA8IzejBPqAVifaDfMDz410/5OVYsPtanpd9NbF3yTePuTor+z73+tqaoPNC + /mtIufFRtOszHCddcA9O6XsffnnF39Hm5olCBEkIF6FF1mK0yp6H1rfOFmJIcjgXbTPnqDjAgJcmloSg + GSwnwlYTTa0wwgKFxrAYQOFkLg7PmW9SoQ6iq0Ahjh44Gd0ffw1j312PD8oo3rAPKNoYwYH9wi0FCl2B + ZdpCij6aQcP0j8X+g6vf6pblZ8Bb7pv+z3pyrsyVZhAnchbh8BtGYdWXG6HzPjz/D0FxIiIoPsqW85Xz + 1BesdlZOnoBpv+uBcQyWGdMRk2LiMD4mGaM9aZjg8WJRbAy+jveiRsh/TWo37EpKQ1liim4rk9JRkUi3 + Drp8/PABNculfqWeRFSlpGFrajLKunZFdWwXbEv+PzQ8MBJYv1n6oMGpkXGtEDT+7ku/aMwOHltYWFhY + WFhYNBMiFlpYhEFfdbNfJ2SjVj5O6crAuAI+2dYJwZZzAv/2T5xtb/XHppkx2FIQjzV556B0dhLq3qT7 + hhcQgk8Xj+Cyc4woURKH4JJvigUHHr8SMMNIAoLLvWgo7oj6FaejYcVZ8BfHA8s6IVSUbDKBrDgXWPsU + UL9DiYr6ZnNVVQm3Kzq4K4skMw1Spv7ajX1I0r3bgoKiD1dmlag3NLjkEc7G0hrnyWlvo/MVD+P4C+9F + uwvuxBm978Pxlz6JNjfnw7ntJWGXM9EyuxAtMxYJFqBl5jzBHGM1IaTRBNZsBvLpgvdTyw0eh11HZNt6 + cIHsz5B9Pmu+up7wOnU/yVoIJ2MuTrpjMS56ZgkmLN2A0lqKD9JXajHB/jP9w7S1FDBIfnx+ODXSh5rK + 1mK/wP4MBGtkblEYkv2A9L3s/y33PbQIp5TdD7TOmY8TrnsSm3dWGMsDWsfob8Kh4dYRCWxH2IqCVieh + +oATkjmpIoW0LYgGp37zV86Sv/8N+Z50jI1JwLiYWEzuFIeJnT2a3SMvNgrvxnuwPjlV3T3KU8/VOBOl + iWnq8kFXj13xyREFgwMJdTnxJmNzajq2yXGVtKfK2wVljKPBuva8EvV5hfJzZQLOah/x3fXVmxhE4TIL + CwsLCwsLi2ZAxEILizBIMELyMa6EkqRDiGRQzfRJxuWDPdRgSAhJeVWtU1HyOL6cGYtNBR5smRKDLTNi + UL7QA/+7QvRL4oTg03LCdZvQFKSRBIMDiWSpi9RrKa07BIw9ofEnKFjQJeVM3YaWxyPEtKW0BPnwUmBz + ofRHpRIWfrRTqNBVandVkX3T1Cfb52OmBIoTPDYihQGzeUgZ+5YpOn11+nck5mvX78Q9zyxEynUjcUqP + P+HkXsNwQs/7cfwVT+KIW8aixaA8OIPmGmsFZtTgvgoSRqRgytBIhHKfQTEic+YeFhSNlhR0Kcma4QbJ + ZHyK6XAyCo2QkTVPM4FobIMBM1XAOHvEm7hp4gcoKNmI0lqZQz7pA+0XZtioV+K3hwWK9pfFd4VaLzBF + sOwz8Khm1JC+zX1vrQpIe4zzd8Bht+Ti1396EQ0NdSa+COe+jpvJmLJ3fQ42NBUi9i7X/XAGD0LaxRg8 + flo/SVsZc6a0eAVeyr5dU45OjY7C+LhoTIpNwITYRDwfG4s5MVFY5k3CppTzUZn8axPbIbGLBsZUV48m + QsEPge0pXVFKN5TEbqhJ7IotKSkoS0kDXVEoWOyQ/e2xqai/YwgaSt6XbvAZkaZpH1lYWFhYWFhYNBMi + FlpYhKEB0HQ/qMSmkXwL/H7GWOC5aje4oezLed+Gl5xNL12KtbldsG6qB+tzo1E6NxoNb8eDKUcZFFMD + Y1KsiCgYHDg0LPFInbgfAyz1ILSUdZR60VJiaYKWM00pU5NieQeEis5Wq4rAh12Aj/8A7FrpoL6sUaQw + q8UUHOp1n2ktw31phJ7wNexbknLXkkJJJFEv/Vgp5Ux1yOuCzodrynH3vxch7upHcGrvu3FirztxTK8h + OPHyR3H4zaNw2IAJaMVYFAxQSYHCFQ5aMojmXmRyX0GRoRXFD9daQkUJIbV099Ct4MiBc3B4/3y0ypgh + z58vYDYR+fusfLTOyFMXEA3syewQmTOkLB9HZk/HSfe8jDumv4vCj3Zgc530SxNiy/5DqEa2PLb4rlAx + gnEm5L1UCx7XoiG3ZBNaMj3sXuO9rzjq2hdx/9hXwXmr81WeYaytDImNVKeDDf9JoCC0TXTdkjbVhBrk + 2PSfWow1CpE+57OFM1B45RWYEJ2AcVGxGBOfiDGxCXgxLhpTo6PxSud4fBKfhi1J52qqTwbGJCIJBgcS + W1O6odJDV5Mumm6UYgQtJrZ7U1Gaznp2QXW3LqiIj8fG8/8PDZOnyW9eubSZ/WAEagsLCwsLCwuL5kLE + QguL3TDkmsTGBLvjB6lfP86VZLtbfsTTjaEe9G2Xv6n60tmx7C/YXJAmSMKGvBhsLOyAipeE5BfFmzgP + QvQjCQYHEoEP2iPIQJjMKrI8CsGSaPiKYxFYzjSnUcBSr1p5hIp5rqMKFVia7AoXZ6F+ZQJCG+4Faj/R + VWpm9OCHu5JsJS4UdQz5YT/5A2bLaw3JkT4N96Fcz36kFUYDXUWkH43bjImS/9mmnRj63Fx0umwkTur1 + AE7s8QBO6D0Cx1z6OH7+h9E4LKNACOc8OIz/oHEnIhPKfULGjN3uHAIVJTSehbvNkeeR5GYzqwjLGJAz + HJST1hwUJfi3M1WY0DgVtO7IkOPBcm7AQrTOno2zhs3BjeOXYPoHZdhaY+aVkj/pC4v9gbyL/oDOKRUL + gnTJgvOPl1bJeHCeuOP8HfGLK/6JWe98LdO8Wu+r4qRL2DWlqNbh4Mfe4kT4mC5sfCf1PfQLfPLu+l0x + Q4UfXmNS6QYqyp1Pnn0OU9K7YUp0LMbExWBiTDzGxcXpPi0r3vB4sC45HVXJ56I+PrJgcCBBMaJKtuEg + nXTnYNpTde2Q451J56I0oQsqUs9HdbwRMbbfeAsa3nvXBLy1sLCwsLCwsGhGRCy0sGguVK+eibWLL8X6 + 3DOxPd+DLXnp2DIrEZVvdkLwQwajbC8k31gtKOFXKwYjFDRm9eA+xQTN+OEKC7IfXMpz7vEPhg4aRyPw + 4e+BLc87qN+qhIVEzU8xh6RGBR7G6jDpMilEsG+CqDYCBckcryOE3Kn5vZAik/mDYlAYhliuWrcLD46e + j67XDcMpPUbg1B5DNAXpL/qNwGFX/xNtB06Dk50PZ1AhWjAOhIoJQiazZ2qwTDXnz6SQQFHBkEyKBsze + wPSljF/RInORXPNSIwn9vqDWHRQ1BsvzsufJcQE6DpmFWyYU49klO7Bue8XuDDEUfYhgyM08QRg3BQWP + mfaQ7gVEwKR61T6n1U+wQWGud+8ZkGMNUmqg/c17ckx+BOJIo1VOsNKpYhnnlxzfMOY9IxBFGJOmaDlI + rmFsChmjVowtQnHp1lfR5pY5aHPzeKRceRe2aOwB6Tc+i2ODgPQ5LYJ21+PHCp1PbKeAAi7nWdWnH2Hp + fQ9gYmw6xnviMCkqBgXR8ZjcORbPx0RhakKs/NQloTS+O8qSk1GeTtcKExyzjFt1p6BY4MWuJFdESO2m + LhjqhpGcrsIBg2o2FRq+D5QlpyrK5bmV8Wmo9XbDtoRUbPi//wNGDoV/63Z5FylEueJ1QN4z6QOKOny/ + 1NVH55+AFigs47W0Gmt0c7OwsLCwsLCwMIhYaGHRbOBq485NTnnJA1hXGI2Nk2KwJf98bJ7pRfU8DwLL + YhAo6gis6ASsjENoOY+jEFzOzBm0XmgiBFCcCAsUxYwLIWh6/gdAfUksQisTESrxoKG4PfyfUqSY6qC+ + Tj/OSdCMVQkFCrpsSH8o6Q2TYVpWuARbyTbPyd8p3IwHjZAPf70XnHI5Xlftd56fU4zzMx7HCb+/G6f2 + exCn9b4X7Xrfj19e/i8ccd1kaAYNksycuWiTYzJ6tBpQIIRTkD1dztHygaCAERYxpJxuIhQ49iKrzY3D + MvPRMiMPjFvh0EJDs33MRquMQhyeKbh9Dro/uRT3z/sKb31ZjhoSYWm7EW8M0VFIvzZaozQpR7Be+5f7 + vF5JFPtS+5v9b64P93H4bykC/TgCcpp5RdFFA7jK+1hbF3DOHr7QWNnsNR7fQFYhWjCeyYCZaJEzA63p + spM1X+dGu4sex4jnZ6NSn0NxIvwsEtOfhjihAYIb2HYzd2hB4ee7Xr3TKVtRhJduuhEveBMwNjoGk70e + jInrjHFxsZrho8CTjC+8ySgj8U9IR2VSV5TSnSKRgTO7YkfSeWqpQEuGivg0BffDgoVaNuwlJjQ3mPq0 + NCkFO9O6YUdCKqq8XVGd0h0bpI6ru3bDzguugG9moUyrGvO+hUXDoLEQ4/yrl/ePWZ70mOIhwX1ep9dY + WFhYWFhYWBhELLSwaC4wTaZ+lPoDTu3qGVi/6NfYPK09dk5Nw5Zpsdgypz0a3ie5T0B9URT8JXEIFCXA + XxQDfBBBEChivArXkuIgECewsiP8y6M0E4mxAOmEwIpYBL7KALYsVNLCmByhUK1A9nnsFzIjJJFkMSRE + hghbVxiYFUWSuz3ECS0PX0NibYKRlu6scQoXLsXVf34OZ/S+H8f+7gGc1OshnNVvBE64/FEc/Yfn1eWj + 1cAFaCnEkgEqSTSdQYLMGa4bhiGfjoLihGyJSIS1OaHxKea5sSzkeYxtoa4pL8v2VbTJZIBNg7a3z0b8 + Y29gUF4JCorWYnVZ3W53BfYN3YlcdxiuzGqMBRWB/LofFid4vY4FiZNAV3lppk9iRfDvGvv80IZ599hO + tlv6SNr22uc7pX/Z32GXm/+CTMYakTki80KtXGhdc/tCHHfdM4i+aChWri13zfvZ92besn9pPfFTIJ/s + U7UCYFtl7jDTDPuD/a1iUKDK+TR/GqZdcilGe+IxISZGXT7Gx8bjhegETGzfCa/EefF5YhdUJp+Ham8X + FQB2pnTHtuTuKE2mdYRJQVrtTUNVghEqyhPTNetHJEGhOVGVkKqCSVl6N2xP7YKy+FTUeLuhJulc7EhI + 02wfO73pqMv5IwIfl+hc8Esf6Dvpb3DqOOdcsK/Cc5D9ZeaNhYWFhYWFhcVuRCy0sGgu1As5DCiRFshH + abDsK2fbu1lYnXc6ygpSsDk3DRtyE1D1isdYTxDFyQgVJcK3jDEphPCrq8duUJxQgaKpm8cPhaUUJBhU + MwkoiZeyjnIsdVsmZavigC8HA7tWKBlWouir1Q9zfrzrKn54RVHBj3hXfHDJjhEhmOmD8SdcCwumL1Wz + aLkuIPtMDynHDXL9S0Vf4w8jx6L95ffiuJ534tSeD+HEXiPwy4tH4vBrnkDLAVPQKmehYLGmHlUz/SwS + z+lonUnMVPeOFgNJXBfvJqnfG+jOsUDFCboNtM0qRNvs6caFgKKEWnEIKWagT4oqWbO1nm2ycnH8HXNx + 9VMv4W+LPsU7aypN9o+wcONaSzS4fa39q+IFQdNzN/ZHgIE3XSLtgudIrpVgh//2EIWJA2HcW2i5E/QH + nMteXCn9Wyj9+nKE8dgbc9GGQU45DhpsdR7a3DARZ/cYjnufnwHe18xf9rux9DHPErCvw/s/VrhWADqf + Ai7xFoTcIJpMQcr+8JVudVY+9nfkpZ2PiTFxGBfbGdPiYjEmMR3PxSdgfHQ03orzYnNiN1Qld0NFUgp2 + JSdhc2oqtqWlYYebOWNXkhEmiF1J3784UZPUTUWQbSnpKk6oe4cnHdXxXVCX1B0VCSmo7JKG0pRE7Dj3 + AjS8OB5oqJI54f6WuZZONTIXGgUyvmdh6wkLCwsLCwsLiyaIWGhh0VxQywCuSrsf7SSKgWCdU/NlPtbP + +A02FkRh/VQPNk9LQfmsOPjeYhwJxqEQgl/CVKOuOBFGJIHgB4RxPREsi0doSRQCrPvKOKA4HlgibVnm + UbeP4Jp7EaxZq6uFavYNZqIwQgVFGzWB50d7+KOe+3ocTttqfLgbhYzw9fxb2RqSyOuq1YWkeE0pHprw + MmKvegC/6jcUp/QchlN73o+Tej2Moy/8O9peNxpOFjNpzDPm/QxoyRgUWQs0JkWbjNk4PPP7t5xozTgY + WdM1FWlTKw7uK9SyQshxDutm6tqKx7qiL/XOmKXHh986H2cOW4zLn1+Kp1//Aqs27JCuccUcF1zh1rkY + 7kNC+o59yv7j2BBK6Ant/0MbKszUmzgbgUC18+ZXFTgsexbaDMyT/pM+jTAme4ACRv9C6WMZk+wZOCpr + Fk7s9TgSrxmCNaVMUUqyubufKU4YixXBT0KcCL9/DJzpd4KumEhyHhYgeY1xJfI71R+sxLuD/4hJ8YkY + HRulcSgmRsdilNeLf3tjMSUmCiti4zXOw87UZFQkd8OOpHRsT0zG9iST5rMxBan3+3fr2BafrGlPtyXS + 3SQNlSndpE5dVRwxcS+STdaRpHP1erp+lN94I2rfeRUUTdU1im1350Q9BRyWCVSocPctLCwsLCwsLIiI + hRYWzQb9MOXqPuMthDSbhRLsUKVTv73YKX8nA1/OSMOa/ChszvWiNC8eDa/GCKnvrFkylOQv9wjCIsWe + QTGbCgU/BPwrXTeTIgb3PAfBklTUL0uFX+smdS42aVNDRe2BDy8ANo4F6naaPuCHuhswjiusu330SepM + efjDPuzioeKOgORHyTetK7RPGZTOp+RaCSnLGxqcXdsanAkzl6Lvn5/DmZeNRLveQxUn9XsAx138KI69 + +t/4+fVj0aZ/gZBRIauDXzHBKUlGlcBGIKzNiNZZBeouoFlAcmhFIWAQTwomg+aZ4Jy05NDsH6yjEOVs + BvCci9ZNybWen6vX0bLiuD/ORacH3kDGxBV48o11eG9dNcrrKN4Y+GVOqtl9kGlfiRrpQ5Jtt+85FjIm + 35jPhxg0FbA7dyrk+Hd/ex1tBktfZRaizbcIiMmgqK1ukzEYmI8jMnLx837/QMd+Q1Dwxiq1mkCoYfc8 + VbLZJNYEXWzcevxowXeSQSDZbpk7AcY4UXcr8z4Sdfztc6/V995X76yZPRszrr8FM6KjMD4uCqM8MRgX + 48EEbwJGx8diTmwcPvekoTLuPFQlnIfKJIoCJggmY0BovImUbt8QE5ob5jldsSvViBIUHzTNaFpXbEs1 + 11QnnKviBIN5VnWV670p2NC9B7b+9VEENqyR94i//TIXOC/cPmiQ989YV7j9aGFhYWFhYWEhiFhoYdFc + COoHKQlftX6oa7mPx+6qWk2dU/7pc/jylfPxZcE5akGxdWoqts0U4r8kHsElFAE8rkjhChSuMGDiPOw+ + /iHAgJ6hkrMRKpZ9qWeg5BwFA3uy3oFlcbJNVFcVdfdYchaw6lJg8yyHcSgQ2Cb9Q9cCI0Dww91Ym8jH + O4/dD/pwf4ZdDszKLAkRwQ9/Afs57P/O+wm59rniBYniklWf4fbHp8Bz9YM4redd+FWvO9DugjtxQu97 + NR3pUdc+j8NvnqSCQYvsWSYuQSTC2pzQtKd02Zgn2wXGgoPZOzSLyAy0GDAFbaU+bQfOFMxFC15HdxS1 + 9phr0pwyTkU4rSlBq4oM+dvsOWppQfHjyKx8RA+fi5vGLMWYt77CinWl2FUv5JH9xL7VPub8NCvfzKyi + 5PsQh5kbcHbJ/l9fW41WdOPJLESL2+aitRss9b9C+rpNZj6O7j8Jx1/4hM6Xu5+ZBt6T8WT2FCfMex0+ + /imQz8bVf7op+MPvnmz5HlJ8pMuVvJdhl4+w2wv/rq6uxln+3JOYeEEPjO0Qi4meeIyKj8WYmBhMjUvE + 2E5xKIpJwacJ6dic0l0FAgao3ElrhqR0lMvx3mJCc4OWEqWeZOz0pqlLB60oFClpKpJUxEuZJwnlScnq + flKakIZKj5SxrqldUNr7GmDuTGgWI84NNx6FCqj1nC+7+9LCwsLCwsLCImKhhUVzgR/i+jHOVWglLH5d + 3VdCKGXc1xXqzSXOztdvx8bCJGzOj8L6aZ2wcUY0ql8/C/73hNQ3tZ4IZ+rQNKPfFAwOJChKBIvjEVDX + js7AEtkuoZAShYYV58i2PYJS5yDru7Kj4FcIlJyJ4Kpk4OMLUbNrpStQGGJjYlAwSCZFB37EGwsJk7LQ + EJ1G8keCiAbpX4oVpowpNsN/16BEsUH3OQbha7bv9DljF5Tg4nueVwuKk3oPx6k9GJ/iz7p/7GX/wFHX + jcfhNxZGJqzNijluvIlZGvySWTrUrYPiBGMcUGxgBo+ssPhAwWSGuhm0EtLM61SEyJHrGVAzY7oKK63k + b1huXETkHEWN7Jfk7xcr4W4tf3fC3a+i99Nv4I8FHyJ3RRm+LAtp3A7Tv+xnukPI/iEMta6ReTLt3TU4 + KmOCtH0WnNtfk36aIv1FK5XwOPwH/HEOfnbDeJkn/8KxvR7ALX+Zimp5X2kdoARc5ioJt3FbkPlG6xN3 + HjYS9x8x6MYRtnLi+8Xfs8bfN+l3M5fC7yS35lpaNoW0j+DUffEVVox8SMWJSZ06YFJCDEbHxmBCbLKm + Hs2Pi8HShERsSEpFdVI66hg8MyFdA1VGEhSaE3wOM4aoSJGYpu4dGvtCnl2TkIbSNKlHUgp2pKWq2wkz + jvgTz0VFbAq2pMl1icnYkHIeyoY9CGzfqoK0n++Y9M1PYX5YWFhYWFhY7BsiFlpYHDAE6xy/kG5dpW7Y + 5VR89DzWzeuO9fm0okjCmqlJ2D4nBg3vRMNX3BmBlZ2BYgoAslUrCooU3GcgTSH/JbIl5NqDIpvH/0QH + 4MuBQPmrQloqDXkJEx75gDeiglumhFkQJj3uORJQfugTSkY1wKP8TRP/7v+EZR9uxGOj5+G3A/6KX/W9 + D+36PogT+zyAU3rdhzNpUXHZk/jl9S/i8AHT0IoWDYwBIaSVpL9N1gy0GmDSlDo5Qno1eGWTIJZ0Dckx + 4gPdLRiAU4NwZlEocCFkmfdqOXAWWmabmBNKiilGMKZEU6L8fUDqphg4E8cIEU9+5FXcNH45Hn/5S+QW + b8GnG8uwoz6kLiAknYxHocRTx0QQHhPdN30aJqK6Oqyik3suDP17uU733fv8B6jlg1okGPA4qKJJ+Ng8 + LwyKW+ZvWS+fUyfPGL10O068XdrKeCK3yvj1n4LWt8ox43jk5KJFToH0wQwdK/YFhaLWGTJWGYvwi+ue + xC/6PoIzLrgPN97xLLbsMi4LFNBodRJui8V3B+cVx2z7e0uw+MZsTI5KRF7naEzydMC4mGS8EBuPF6M7 + Y0ZsLFYmp2Fzahe1nFA3j8Qu2JnU1cSBSEjTjB4UMLYnJmJrl1SUpbiWDrS0cANpcp9lPKcuGolpWmYE + iTQFBQjGt2A607Kkbnoty8sTUvQ55annojS1O8q9SahJlOfHy/NTz5N6dJPz6aj+v16ovOY6lP/1OQTm + vwr/12ucYB3dpqStMm8Yl8S028LCwsLCwsJiNyIWWlgcMLguDWFzZ5Lw4PblTvnbQ7AxPx5bZnbE2lwv + tuQmo26uB4G3Y9GwMhr1zOpREmsIfliE0JgUPDbljSmp+KHyAABkxklEQVRHD2okAkvO0fgawc+zEdj5 + ugZuVFFCAw2ShJJ4MtieEEPpJ80MgDo93t2PYYJKYmqOg7RICZ//DwgESDThVPjgvP3hetzzdAESrx2B + 43vcieMvHInT+9yPE3sOx3G9R+KYy/+GnzMt6YBphtgPWuSKDST3cpw5U/cPGzgfbTPmo80Aigt0uSAY + J8IQXyIsRjT+7UA3EKZsecwYFC2zm8SU+J7QYqCxtDACBQNvztd6Ung5YmAh2srxaUNfQ9fH38UNY5fj + 0fmfYPrytRpwc0d9wKnzG/cP9iH7k2OmGUACHBsKC25fy3goOD5NAkiGz6u7joz73kE79xQdTFn4bzWe + hO7LcwLVglqnVp7xRQWcSSvKcM/0D9H9ydfxi5xJcDJypW3SzgGFOGKQjAPdXjLoPsOUrQtlTKStA/PU + DcYZ9Cpa3TQFv7jiL/hFz/s0oGrWXyZhW60ruvhl7jF7TGN9LL4rmD1F50VQxp+iU7DWWffSfEy+6FKM + 7pSACZ4Y5MZ6kBsTj3FxcRjVOQrzZbuaaUTj09DgNQEzmU2DgsOupC4qQFBwYKBKxoEICw8mw4exiGAZ + zzElKONZMPMHy/Tv3L/Re6WkanDO7byHXMs0pzVyn6qkROz0xshzk7ErNQ3lclyW5MUXcfF4M/18fPzE + v+Wni3OzQlAlMEFC1c0vDFpQROgTCwsLCwsLi58uIhZaWBwokNgFmG5OPla5Iqsm0fxYr97k1H42FZtm + /RprpyVhQ54HWwo9KJ0dg/q3PAitiIFv1VlC7qOM5YQGn4yXfROngkEoG8WLgxnM9sG4FUXtESg+Hf6V + sv/VzUD5S/LxLuSTH/HsK+mT3TEpDBrFCpYL1KVDhQu/WlH49iC0kWEEISERwToBV8XhbCj3O5Ne+xA5 + f8+F59q/4qy+Q/GrXner68eJPYfi2Isfws8vewJHXfcsWmZOFoJfgFa3LUCLQXSZWGRIL90rcgoN+XcF + ABPHgkKFESFUjMhm8Eu5njEjNM5EEzQKF98fWmTmG4sNihOMfzGIrh9MsSltyX4Jh0nd29JCJKPQTWEq + 12bOwGGD5+G4IW+gy2NvoufTy3DzpA9x79yv8O8316JwxSa8/fVOrNxchY0VDc7WGr+KPxQOOL/3sG5w + x+E/IiikLshAi8Zqo0q2W2rgfLqtzileW46CFVvw9Otf4e7CD3DVqGVq+XHsbTPRckCBWqvomNwidR40 + Hy1vZXwPGQepuyPtoWsMRSAGxmyTKecy5NoBM3HUDc/jhIvvxSm97kJUrzsx8sW52NLgdxpCnCM+Myc5 + 51Rk2au+FvuEBp0Hsi9zg8JPrTsvgps2OctHTcCs9C4ag2K8x4MJcQkY64nDmIQ4jI/qhFe8yfgiJUkD + U1anGJFhuzcN2yhEpJ6LXV4jVjQVJAjGjghn3GCMiFJu5TxThTL4Jc9Vy9/WasrQVJMuVP6OFhlVCanq + 6kFrjdLUbtiU1gVLYuMxLzlFg3mOj/diVKdoPJeQhDduH4yty4ukOT7HH6zXuc826m+Wtv1bzH8LCwsL + CwuLnxQiFlpYHCjUacwE87GqOfHVFcGsympKx/IvnLJ3BmNjfgdszovG2rxErC+IQ8WiOATfEWJPK4ki + 10qCIoXGo6AoIVtm+4gkCBxE8C9vL2Ddecw6dxJQfPkNQp9cBlQvc1BTauJyyEc9+6ReV+Tlw76BH/vM + DsBj6Tc5b0gjBQqfnGMWCin7L1BxSKCCEIP6MY6Aex9ic0WNM2nBO7hxxCjEXvUwTuw1Eif3fQTteo3A + yT2G4pSLHsDR/R7E4df8C61vGqfBNFsPpuAg5H+QgAIDxQe6fgyiACBlGifCWE8Y1w2CQgTPc8u/k3Pf + JpvEfkJdTiicUEDJFMKema9toAjBIJxafxUtFuwGrQsYxJPlmWzHHHV5IbgfPm6dMw9H3ToHJ921CFEj + X0e3v7+Dfv9egutHL8PASUW4fWoxhk7/AMNnfoQRcz7FyHmfK7jPMp4blPsxbpm4Epc9uwznP/4mPCNe + xq/umIdfDmaQz+lSB8aNoIVJuA+lTXSTkXOtBjIGRwFa3b7Q9GfmDLTiGGia1tlyzXwcIW3m3zBmx+HX + v4iTLvkLTrvgbpzR8254rn0UeYtWoFbnCU3yq2Ue0ipE5oYSTJdYW3x38F1jXwrC1mP6W8hy+S0s/3oV + Xhs2HOPiUjApiiJFHEbFdMb42HiMi/JgSvTZGo9im7cbapLOw67Ec9XVgwIELSAYL4LiRFiYIChUsIzn + mJaULhzMAkJLiqaWFkR1WncjbMg1FC82ppyLz5K74+34bpgf1wUTouIwKSYZ46ITMUbqMykuDpNjYzAl + MR4zz++OVx5/Ftheqe2pDhmLsPBvi4qv4X6wsLCwsLCwsBBELLSwOGBQ0/RqId0M3CjHGizN74SC9foh + q0S8Xj7aP52L7fN6YFNuZ2yYliLbFFQUpqD61ViEliQAK5gV4xwEl50h+0L2VwjBX8rAlN8UBA4m+Fe5 + MTJUWIlFQMpqizohuNxYfviWehCgJcWuxdI3tY1khmJECFXSR34ljkHUSJn0lZIaF3rd/4AQBM0kIPsk + RYTfFzY3Z1DNoFMfotABZ1NZrZO7sAT9R05EzJUPoV1v4/Jxcs97cUa/B3B6z/vRrscjOOGKZ/Czmyah + ZUauZtdooe4SQp4Z2FLjGoQJtJB/BqvUNKACWi+okGEIPlf+mwoJ3w/kee5z1NVEIc9mOQm/kPqwgEFS + T9LfOns62gwsdLOaGEFAyb8KALwXyww0wCezY6ggwGtYTiFhgbRzoWxdKxLXsiSMcLneM1xX/VuB1le2 + 7KuBco+c+ZpedXed5G9470Evm3ZksM4zzTkKMPJ3LQbJ+ezFeu0R176Adhc9iFN7342T+w7FKX3uxqBH + pmL9hnojXMkcYIpMzrmgP6TzSucJ45vI1mI/EH5XXfGR/aq/g0SQ75+U+eqc0nffwYKb+mNCdALyPF5M + jInDpFgPpsXGY7LHg5nRMfggjlk8zlOrCbpiVCQkYZc3XTNtUHQICw4qPkgZz9Etoyw5GRVynu4atUnd + NPgls21sS6WrRyq+TkjEksQkzE/wyrMT9Lmjo6IwJjYKk2PjML5zDMbFezChSzrmD7gJH00Yg00rV8jP + lXEZY1vC1hKNbWuQ3/1v4XZmYWFhYWFh8dNCxEILiwMGfqD6ufJPCwC/yepBcGWNgQblw50Cha7wl65z + tr9zOzYUxmBLfhw25sZiY0FH7FwQA59aUcQYYYKBMWmFsDxhDyHgoERxLPxFMahb1tkIEgzkKdvQ8jg0 + FEv9V8Yba4rlHRD87HIEtuc7QV+p6bvwCiQ//F1riUYLijDpadrXEUHSyb/zu4FJQ0og2N/qgkBLCl7H + ZwRMBhGe+2LTNsx85S3c9rfpOO/mR9Gux+04odcQIbcP4PgeI3H8BQ/g5H6P4hdXPYWjr30WP79hDI7s + P00zcrQkYdaUoS8LaTaigCHgLvkWkPRTJGgk5t8XSPBd9xEVQ1RAIKRMjjULiIoEM3b/TViI4N8MlPZk + z3BFDQMKL43iwqBFKh4Ya4vdbWsUPCjWuILNHmgsj3CuyXlmJdE6D+DxAjiDFxvrDqkb69V20Ktwbp6B + w3OMZYeKMVKH1hl5OOymF3H8xU/g+J7DcHLvu1SUuPBPL2D2Gx/LcHNucF5Um1gIMv50G+LqvpLMEAOw + Np1HFt8FDLSq/cjfPL6v8r4F/CbgaYD97jPneV2ousr5YtwUzPi/fhgX48ELiZ0xxpOMSZ3iMaFzDMZ6 + ojE32YPPk9Kw05uuqUfpphEWJJoGxFShQs6VJ6aqBUV1YldUJVPUOBdrk7pglTcJS+O9mJPgQW5sNCbE + dMKo6I4YHx2FqbExmBzdCXnxsZjXtw+KHh6Jj6cXoHL116C1B+cHfztoccO6+2ghwd8kgd9vrOLCvzGR + +sTCwsLCwsLip4uIhRYWBwr+8Go/P859ZlVWy+UjVl0XSLblGl+oXD7QuR90Kr+ahPWLe2BdfooGzVw3 + rTM2FXZC9ask8slC5IXUq6sHRYoIgsBBBH9xokIDY6qLSgdpw9mypSARA7z/K7NfnCTHHk1LGvjoamDz + dAcNO6TPdgqpkX4Khlcm+fFPdw7pVwoXTfo6EgxJCDma5UP7l/EN6t2VcnNf4+7BcSLqhKTW6XmuqBNb + q2qc2Us/xh1PF+LcWx7VGBWn9huB43sN1/SkJ/e6R1OWHn/p33DM1c/jqBsn4fD+hWiTMRuHZebrir8K + FCTdLoE3VghGAPg+ERYkjCvGbDdg5wytUxtNVWqsJ1QkoLuKuqwYgm+EDYoOLKO7RxPQckFAoaIpGgUM + 141kj7q4okXTstZZdDPJR8usAjc2htSFKVb57Jy5aN1/Co7ImYEjBss9eb8BhXoPzaCiIsoMuVa2ckwr + iiOkDj+7ZhROvPBRnHLBPTizxx9xZu9h6DHwaUya+S5oNcMx9an4YN49HX8SSyHPnGPGnUPgvqsW3x0B + nxF5SObr1c2B/WoECpbXyTFJPNOOhsXG2o1rnaK/Po4xnhQVJ56JicOEpGS1YnixU3tM9HbGG4lebIrv + hi3MvJHaVYUKdfGgJQXFCinbmpKO6uTfoCzxfKxO6IJiTxJe9SRghicOk+KYzjQKozsnYEx0PCZ6vBgb + G4sJXbthbv9bUPzisygtfheh2mqtH+tvfsOl/hSbA/J7wt+OBjNPAk0z2gTC80m2/DsLCwsLCwsLCxcR + Cy0sDhQ0NoJ8jJt9Q6z9qNEPc42DwOu4JfmWLUmTlu36zNm17K/YkJuILYWp2JSfjPW5cdg2ywTMVCuK + knMaRYCDF6cL2gNFcQgtj0dQ602rjyhgWWcEPohCkEEzl0qbNBNJewRKzkKIwT5XdEP1theAmiLpH+k7 + 9o/0jd+1QmGQzHA//0ewbwW8lkEXST4by4MuwZDj8GqnjkvjeUGDQImTkA8hINVV9c7yDzfgqWnv4LI7 + n8NpF43AaX3vw6m9huPkHsPRrte9OLHP/Tjhwodw3CUPo+UN49Dy5ikaG0GJN0m3kn4h6q67xfcJFUXU + CmKeERXCQgOtHQbSesMVE1g3/k3YYsIVEVQEYHmmsZggKG4QdAEJ/725R1h4cIUNQQtt53+Gsbhg3Ux9 + jBuM1EGfJ/ssz2Iddt/TiBLmeW0GFcg5E5i0zXXP41jp85N63o3Teg7Fqb1H4teDn8aUVz9GVZ07pgIf + SSbHOcjsEabM73etZhpFq91zw2I/IH0b8Pn3sFAKg+8afIzxIefcd1Pj8JDkS/n2jz/AmwNvwfjEJEzs + EKMuHszoMS4uFuOjOiM3Lh5fxXqwNTkNFWnnoiapG6q8Jh7FFrpryPnX4hIwj9lAYmMxNjYGLwpGxXkw + LtaLSbGJmBoTh5k9e+G9kSOwdtECNGza7MAfMsF3tb4m+G6DK2Dxd6cGDY4G+pR5REFZRS43Q426CMnf + NWbt0PZYWFhYWFhYWBhELLSwOFRQv2EeNr92gwbMLJ3eERsLorG2IAalL3nRUEQLio4qVASKO7uWFJ2E + 9MtW4FcRgKBIENUEPJbyIsaxCIsIBymWSntWdUdg7V0Ilr8hRKZWSQNBAqFBDNV1g+KBHBMu4TRkgte4 + iHC+aV9/F3yxdidy5y/Bnx7PxW8HPokz+gzD8RcMVfePE3uNwGk9/oRTeg/BcRc9gF9c8U8cfv1otLpp + kpDvPDiDZhoLBCHotGxoncksFEL4GcxRSfsCtSgw2UBccq4uI3NVNFC3kGw5n1MoZF2QWbBbKMiQrdxn + t1WDsaLYG84gWh5MN3BdNRqvl3sYseG/YJBcQ2TL34bR5HyrrPnShvnQ2BxEWJQIQ57bImeGcS9h3A7W + SQUKuU5dNKRvKKbIsbrL8G+Y3pXuHoLDB0zBL69+CidfNAKn9ByK0/s+iFN/fw+u/PNzmLagGPX19U6A + q9wRxs7i4ActFr6YuwizrrhBg2ROoOtFXJQGzhwb58W42E6YFd0ZK5PTsTrpXHwUnYK3YlOQ50nCM3Ee + vODpqBYSDGQ5pbNcH52ESeddgJcH3YaPn/43Vq/4CPU7Khp/C8K/Lfr8Zvh9sLCwsLCwsLBoioiFFhaH + DGhJUVfjVK4ahU2F3bA5Nw5bp6dgc14stk6LR+3rHWHSiibBX+yFvyTaWB3QjWIZ3UBkn6BVQhgqWAg0 + 64crAhykYJaS4PvxCC2NQ+jDeAS/ugrYPMlBzUbpG7+SF0ItKoRMGJP8ej1Hq4dgKJztYzfx4DUhtb6g + sBGhz/cBTGdKtxHet6o+5Ly9Yg3+Ov51XH7PBHS+/FG06/MoTu7xIE77/VCc1WMIzrpgGE7teT9O6PsI + jrvoH/jFdc/hZzeOQ5sBuYac3/qSkG4h4yToGdNlnwR9hhD1ArTNLkTbrAINQmkCU5LML5BzC3VrglAy + uwXL5e8YoyEsPDSBih0uWgrRJ1rJ9QQFgKZoKjREhhE0wtYMatHQVPzIkXNhAWNv5FBEoYBhLCxUeJA+ + 0DgTvGdGvmCW1EOuzZL9gdLuW+fr+cNuycXPrxuDE/o9rn3Zru9IHN/jbvz+9mcw4dWPUanCVVCFCcYr + CY+Xxi5xj5uWWxykoNsEraTKtzqfPvcc8n9zgbphjI6OVsFhbIwH4xPi8Xx8Z7yYFI3RyZ0xKrYDxnWm + ZUUCpkTHYUpCKvJ/3wuv3XEPvpo7G3VbN5h78reiPmAso+S3g9Yd4d8ItfSw4oSFhYWFhYVFMyNioYXF + oYKQH0KwTDaJ+vLVzo53/qyBMjdPjcZOBs0sSMPW2QmoeSsKWBmL4HIvfEWdECjugOAyWlbEfRON1hQH + P0IrumhWDyw/C1hyBrDsTARWSTs/vwjB1X9GoGqJEJitjdYQFApMPAGSDNNvaiZOKOEwvuEkJs0RsI73 + V3cRJbq8v1ml9/mDTml5pTO36FM8PvVlXD78ecT94RGc1Hc4TuxNy4qhOK3PPTiuz71CsIVY93sQx1/y + OI656mkced1otL55MtrkUJSgZYUgnE6T1hMk9bQ2GERxYZ6C5N4ICrRMoFjA87INB6sMB59sFBWE8Cvp + d0UBWmGoJYZAg1HKNWFXj/+CVnwuLT3USmM3WA+17AhfK9eFrSbCggihggbFCD5T6yHXZsxCm1tm4ig5 + 32KQ1H9AIVoxU8cgaXf/fBx27Wjpq8dwWo870a7n42opce1dT2PuOyWoDgZkTAzJDMpc2Hu8rCBxaEHj + 8LguFUF5nyu//gLFjzyG8aldNUbEOE8ixkbHYVp0AiZ3jMbETrGY6E1B7v/1wLvZg/Hh2KkoX1IEVNE6 + giKluR/nh77/FCD2EiYUdDWx4oSFhYWFhYVFMyNioYXFoQN3dV8+qEmEmVqzas10bJ3fG+sKOmHDtHOw + tTARm/LSsH0ehYcOwAcxmg0DK86BCTxJou+6cYTFCab2bDx38MJfcrqJQVFMdxRmJ2FsCrqusP5xGkAT + n10ObB3loGqtunqQdBgIqaFoQcgxswMEwUwBDHwpZbq6vp8I1Mv9TTyMBkGdlJlAi7VSXqF1CBOezTtq + nPnvfoxhz83HBX98Hu2v+osQ6/tx+gX34vQe9+C0XnfglF53oV3voTixzwM4od9jOPyqJ3HUDc/jiP4T + 0aZ/HtoIgW89cIG6S7QaMFeIvZD5HCH46k5BFw1ujThhMnDQCsFFlkl7SncJuo2o64ibFUPvofeZLtsm + CIsL/wFNrS3U+qHp+ezZ6o6i4HlBY9wIxpIQqIDCNKQDZqJN5ly00SwnPMe2zZOyAmnzDBzWvxBHXvEs + ju0l/dXrbsVJfYbhsjufxpx3P5Gh5Hj4HL+/wQQi5PhqlpwmY2VxyKExawrHU1Cv4l+9U7H0fbzUfxCm + xSRhUrQXk73pmHfRFXj/3pHYsHARAjtL5Z1z33MBY84wbkR9iJZO5n1keTgWBo/5nEZBy/27pnWxsLCw + sLCwsNhfRCy0sDhUQFcF+OWDvHHVzxDv2spPncpVT2Dt9DhsyE1QN49N+bHYWJiEnS/TlYPxJyhEnKNB + JhtjTezh3nEowAMs9QJL4o0oIfUOFTEDSDx8K8+W80nGrYXt/DgZWDMYKJvroL5URYJgiDEq9loVdcG0 + kZH6fF8QpDjBeBccG/d+vK9aVPCaoJwjWQ6LJLxG4GuAs7Oswlm8/Ev8Y8qruPLu0Yi57GENqnlan/tx + xkX34+Sef8ZpPYZpsM2Teg9X64pfXvY4jrz6WbS9cYKKFc6gfDiDhdwPng1jHTEXrXIWo3X2y2iZtViI + PbNzGLTMmqnYHYfCjS1BSwfX+qG1Yqai7bfJJkJBQkUJPluONSMJ/86gVcYMReNzBxrXkjD4TCdDymmx + oS4sJuAmM4nQeuTIa0bj6Iv+qnE8GOCyXZ9HpC/uw9VDX8TC9z9FnfR9QN14GNzSCHim36XP/XU6Hk1d + OSwOMfB9Ccj7Uk83DLfMb941Chdr58/AyhlTsO3jZUBDuZyvl9/HoFMnf8N5UAef46NIEX4/BcwMotlB + 5H38xm9CU3GCc4j7FhYWFhYWFhbNhIiFFhaHDOQjuR6u37zf/agmGZYPcx8/oLeWOBtfz8T6aR1QXtAR + W/JjsDo/Advnp6D+DddKQjNkxMqWJD5KCD63LD/4Y05gmVe2FFqYflSOKVRoDI1OrjWFtIPHSxMQWhoD + 3/Kz0LBSrvvsGmD140D1Rw4atkh/GXLD2BQmToRLYvcTvA/FiCAFpIAQZIKuIxwb97whzEG13AgESZgp + aNQKEarUv6V1BS0u1u+qcBYs/xSP576BGx7OQ7fMp3H6JSNxYq8hOKHnPTj1wvtwSt/7cGLP4Ti+x71o + 1/sBnNz3Hzj54n/hxCuexzHXjsWRf5iANrdMAQNpKvmnKCHQbBxqITHX3dJqgphv4FoyGAuLBY0Iixf/ + CbvdQWTftcDgs8Iw7iiMfRF+Rvj5BhrrQspaZzMY6BS0/sMLOPqap3DCpX/F8b3ux0k97sdp/R7RLCjn + XDwMN46cgMXLvkKDZlGh6ERLGJd48t3QNI/hNJVmDCIJE1awOETgE+i7FJT3JdAYC4LvsRlfOXbPhcWF + cHYkvVaFDOPGpTEmCPeYwlb4+kguQBYWFhYWFhYWzY2IhRYWhwpqUeNorAQhXiS6hFnlM6uBdCUgIfN9 + PhXr5v4Oa/OisLkgBetyk7E614PqV7yof1OI+5IEI0aEBQol/0Ls9xYDDjYUexAqZpDPjsCKTnIs26IO + wDJpw7LOaJA2BJZLu5iZZEV7Oc9z0salFDCiUSftDX5+A7BtqoOaNdJXrnDAPmUaQ7efvzM0DSIJjzkO + EyRDlniuVs5xZZ8m5oSx4uA4klxxHMNjuee9g059Q7Wz4osyTJm/HHf8PR+9bv0Xoi67D6f2vlMI+xCc + fuFQnNXvXpzS6x6063GPWhS0630/2vV5GCdd9BhOuvivmh3k8D+MxWE3TECbmyejbf/cRleJ1tmz0WYg + 4zm4qUFVxAgLB3SroKtGZFGiEWG3DQH/nhYaeu/M6Qq1hiDUooLuJvlomZGLVhlT0br/FBx57Qs4+opn + 8Mt+f8cJPR+VtjygbTm+15/Q7pK7cUrv4Ui74VEMf7oAH329WbpFSKSKP34n5KO1hOl7Hy2KKE4oMWX6 + XqZ7bNqfu2GFiUMHfFd0zNX6KOTUy3GNQF13GtP88hoKhDKuKljxd5EWFH6dF/puCjjmPnkvWa6uXZo2 + Vs4R7jWExp+w88PCwsLCwsLie0DEQguLQwZBkld+MMs+P8Llw9u4K8g+IR/atXKeH+2hyvVOxXsPYmte + GkpzO2JbQSLWTo3BtlnxqHktAcElHiHvtJigQEHyf/CLE8EV7TWuRGBZnImjURKD0IoY+Evi4CvxGjGC + YsuyWA0AGiyO12wlAb1G/n65tFUtLgRFScBnVwDb/u0EGr5oXFnfH9S7Vg/s/7AVhZ7T8TH+8oomJEkR + PnaJVbgsbG6++1ohUn6KG3Aa5NyG0lrnjVUb8Fzh+7j98WlI6/8UOl32IE7tPUSI/DCc3Hc42vUahhNl + v12f4SaWRc97lOS363MfTuj7II678C849uK/4peX/BW/uPJZHH31Czjq2hdx1B/G4cgbJ+Kw/lPRNiMP + rQURBYkIoNuGunAMKEDrW3LR+uZpaHPTNBx13bP4+TXP4JdX/gvHXvYPnHjho1LHRzRjyenE74fgjF7D + NQ0o6/+r3sxqcjd+J+0a8vRbeKn4Q+yoaxCyuLtfKMgZixR5N6SM70YoZMQgWqGoRUz4etnfm2ha4nno + oFZ+33Q8+V6470aonqICfxdrVWgwAVCbiHs69kbM0H0pM4Kue87FHsd7Xy9zxFpTWFhYWFhYWDQ3IhZa + WPx4wI9yriRz9V2OhczWbHrH2fzG7Vifn4QthcnYMDkBG6fGo2w2U4/SLSJVCH0C/Ms6KOGvL+qEhhUd + 4KflAQNqCtmnAFC/wiX2GkTTowKAHqtLiIsIgsJBBQ2cycCf5yBYfA4CRVEIMs3qyt8AH/eDXwNpvif9 + Vu8EhJhQZGiQ/jTB9FzC00hYGIyPpMgQJoMm17jkmQIFRYsauU5dPgiapDf+rckUQpgx/O6obgg6X2/e + gVeLPsOLM9/B0Ofm4vqRk3HewKfQ8dL70a7vCJzQZxhO6DVURQuKFIqeJpbFKb8fpnEuTu11H04RqPVF + r3tVyDhJ/va4fvfj+AtH4oSLHsCJFz+I4xUP47iLHlK0u2gkTpJr+JyT+t5rIM9jUM92ve/BqT2G4LSe + Q3G6PPv0nnyOwSk978XJAtbrnMsekPo+gYGPTsYL0oYlH63Fjkqmeo3cZouDCPpOyDsg2yDjfuj7YMSC + g2H8+I6pGMX3U99LCh7m3eX7Tesa7vMdDdAag+UKtslYWVEAI8L30P3wu85t498YhIUQI35QSOG9ZBuQ + 3xgpo0uKPp991CiUyTVB/uYQ8rsRdAOBWlhYWFhYWPyoELHQwuLHgt0r8vwAlo9x7vNDt/Jrp+bLBdg8 + 57dYPysN6/PjsSk3BpvyOmDbwrNR+14UUOwFlgp5X+ZFiILF0iRjYbCsgxL6IMWHsBixF0LLhOQvPfiz + fexOnRqlMSroIkI3EBUoitMRKmqP4IpkBD+9FtjwT2DXEgc+ph10CQYDWmr/mv7WvlWyIftKTMJEzKDx + vLobyN9yGx4jbsP7vLcSO7P/3UES36DEkAJImPxU1QeczTsrnDeLv0be4qX465j5GCzk/7K7XkT3rH8h + +ppHcfpFI3H2hcNxRp8hOLXH3Ti5p6DXUA2+SYGCsS3O6DEMv7pgKE7/vcFpgl/1kPKe9+LMXvfhxF4j + jCuJICxsnOyKIKf1vhft+j6Ik/s+gNP7jZBn3Yf4qx9G71ufQeZjMzB81JuY9+pyfLymFJU+1xpC+5SQ + fmP8Dt23OKQg87uRzEc6fyBB140gY73UO4EAAwuzzJwLyPu5W5Aw729YNKRoQZhgtxR+KTIIQnX6voUF + Rp2ntNrRjD27M/PU+QNOeVW188YWgJZVfCeNWOFz/87s830lwn9nxAq5p+z76YImWwsLCwsLC4sfDyIW + Wlj8WMAPXf2gVTJsPpj5Uc1tICAfv7VfOZUr/oHSmb/Btrw4bMpPxIbcRGwpjMaOBR2BJYa8B5dTjOgA + rHAFCIoUjOWgBJ/WB4I9iL9ccygE1CyK323xoYFBY1yBIhp+tmlFlLmGwkxxAoKrEuH/tA+w5kFg82wn + GNwkpKFciL8JsqhEgqJCkCCBlnEg4WkkYhwH91hIUNjsPExAGs8p9p98hElN+HmNYL38Mi/c8vAKL6+t + bwg6O3ZWORu3lDlvf7IJC5d/jbzXVmHU7CX417TX8fDoRRj2r1n489/ycOMjhbj+wTxcPWIKLhs6Hhfe + NRp979iNK+4ZjauHjcMN909E/4enIedvM3D3vxfgwfFv4a/TlmL8grcx650VeO/TNVizfaezq7bW8XOF + WAlfrREgdIWahCyogUWbkry922txcKHRMkgQHi8dv7BFRZNrfwiERYZGIUF+E9FQp0KFig885nwMyFx0 + BQjNwOOKvWZumrZpEE7Z59/xfWbci9J6OB9trsT8VZvx1Gtf4vb8j9Dv2SLEPfAqTvrTXBw9aBYu/Pe7 + +HD9Nrllg6mH3pMwYiLB4MbhfY2nwesOgv6zsLCwsLCwaF5ELLSw+LHABHeTfb9ACSjJcL184FbLvlmZ + 48d1oPRTZ9c7w7E5Px0bcz3YUpCETVM64av8Tih7tTPqlndAYNXZCJW0N6k5lwqRX0ahgsEzaWVBcYJE + vpNaTRiyfwiIExRR1DXF3WedGTyzpLMG2fS5QoURYihi0CKkA3wlnRD4MA7+FV0R+uImhLa96ARrSpxA + aJf0KVdZTf8bkk03kN2rriRq5pybYUBBwh22ruDfkAiREIWv/W4Ik/gw1DxdtmGQUIXNyPUaCllKHDlv + WA+BEiXuNyFDch9eb64zbi4MMukPytziKrT8DbGbhLpQs/TwPQlzLxVHCPdYETCiTYOU1/l3pwHVest5 + bpu21eLAw6zkRz5HBPT3Zm/LIdctShH57w4UmJlH9znfNBhueD7LvAuYucd3tvEd0faadoQtLfz+oFNe + 7XM+3VKNBR9sx79eXY+cyR+g99/exDF3vITDBs9zU+W6MVgGMgCsYOA8tMg0AWfb3bkQY9/+Wqpi+kQt + smQbdovhc2k1tMdviJ4z7bCwsLCwsLD4cSBioYXFjwWBYI3Zlw/bYHgV3z2mYKEfu25QTX4EV218GVtf + vREb8+OwJc+DjYUpWDctFpunx6Lq5QQEliQDKxmTga4PYSGClhN04XCFCj0WQk+LhG+IAQcZmN2jaQBQ + V6Sg9QQFCqzsqCJFaBlh3D7UukKuMW4tRpDBkg7A0jhgVR8EvxqOwLbZTrDqM2OdEHbhUOJhhAoVAtjn + FI3cQH6NpJxwx6fpWH4ncMVX/drNsw2xkrkgpGy3SGLqQpCAhQmQrhzvEQjQkDIKDmHxYY/zTe4XBkld + +H5EWFwIH9ME3sAvxwEli/T7D0PTPcrWgP1IE3lm4Tg4yK3Ff0cQNTK2dC2iUCVzjvPaPadBTJtc+4Mg + JL+PTUQyM8dorSNzS+aYsWwyYgBdUSqqg86yr8sw6t3VuHv2KvQe9QFS/vYeThu2CIcPmglnQAGcrBlo + NWgOWgycLtt5cAYyE81sk+kmi5BjihOCw3Jm6PVOFtPqLsTVo4uxaZcRJVWg8NdJXWipIQg0OPXyWxF+ + j8LvsoWFhYWFhcWPBxELLSx+NODqnpBHEk9+1NbIh/hus2NDEEgcuErP1Uz98A3WOFVf5WPrnKuxpSAe + W3PjsH2KR5CAbQUJqHwtGYEVHvg/OFuIvVfIvEcFCRJ4JeoaDJNWBnQJIdk/eBEqYhuaCBRhKwpXpPAv + jdKgoKESN9PH8ng5R1FCrpf2BooSZJ+uIVK2tL1sz5Tjs8zflyQDn14HrBmG4PZcJ1j9qRPykWzIuBBC + fsJEvV6IOeGTMeBqc1gIiDim+wAVQNznNQ3ap+IHQRN1kv1Gi4Yw6TcIixZNwTobVxQSOfd+Uta4vwd4 + jQt1dRHsUbbX9Vond0uwHkoehdzu5bdP7N1ei4MMHNPweHJL6DkKdJxj4eMfDhTQGART55PU1+eH8/HW + OkxftQ3PvvMlhs76BJe9+AGSH16K0+98GUdlz0DLrAI4g2YJFsHJmgsnc5aUTTdgyt3B8+DkzEebrFy0 + yszTlLyts2fuTsfrWk44/fNlOwctb31ZrSucrPmIeehtzP9oK2gdxDoFG+jeRBHFvI/8veA5K05YWFhY + WFj8+BCx0MLiRwP5iNW8/LoCaIivX7ZcEfTBDSjokgZDOs3fwC8ksr7SqVrxENbNuxJfT03E1vx4bC1M + VkuKTbM6ouatzggtEXJezHgMJO1hgYJEPwYhun7sJQYcbNCgnVpfOeY2vB+2oiiR9mi6UfdYoFYTRbHw + L/Go9USoxKOiBVOaqtDhZv6g5UWtnKNrCK1MUCL99PFFCK67D/6d+Y6vfon09S4BrVuMNQX7n1tD3Op2 + j+N3RFPLBXNvMxfCZvXhoJvmmXKdjL2C+4JGkYTX6bXucbhMhZSmYopB2Ixf03i60Hnlgse05AnPOab4 + pHuL+Xvej6KEmZ+amYD3CF8rfx9uV9O2Whw8UBGJLhAUuxg3hHESwuOvY0yivf/ze78RZIpZM7fCwW0r + ZK6Nfn8bzn9gNo7Img5nwEw4t76iYoPT3wgNziCKCwtweOYMtM2chVZZc9AyS85nzYOTQbFiNloKnJyX + 4GQvVqsIZ6Ccp0sHrx04RwUNZ9Bis39znt6v7eAFaDUgD8cPLsDw+V9iu9SFFkRqMURhU/Y571lfY43V + pC0WFhYWFhYWhzwiFlpY/FgQJn9KQukm0BQkCSR9JBFKGIQICkH0a3BHrlLL31C42PmhU1nyINbM6orV + uWdhc0FnbM1LwdZJ3VA6/yzUvUlCnyDkm24cdO0gSef+wS9OqNVDOGMHrT7U8oNihJxb1hk+aVewRPZL + Okj52XJdRwSXd4ZfygKreI+zBNLmZUylSqEmQS0tKF6olQWznfBe33B5obVFInwf9kTg8/7AhieBna84 + qFsnfe6adQuajuV3glrOcJy5dQmilKuZumx1boTBeaBuGnIN/ybAORFGk3u6f2vq981rGu/X5HxYrGh6 + TrGH4PHNv2+sH+ut9ZfrXEsK49ph/sbih0J47HaDYxqGv77Iqa1c7tRXfy7jtVPOy5hxfrlzKPI9DyR8 + jcKXvhu0JFI3FDi76uCMK6rEbx5ehLYD8+DcOteAFhOZM9Calg902ciRsmy6bsyQ7Uw5lvMELSWypmtM + CVpNcEvriFYDZ8nxbGMpkcFrZuLwHBOPwsmmJcZ8vZauHjc+MBol63bJzzXrZ4QUYzUhoMsHtxYWFhYW + FhY/GkQstLCwcBFiPABuA05g2xJnxzt3YkN+KjZPjVJLinV5HqzPjcbO+YmofzNJrQlIzknssewcJeT+ + FVGoWxWFhpUmXaeJ0+CSdRUCmgTRVEHDxSERUHP/oAIG94vbm9gWq9KBT64Gvr4PWPdvBCved1DzqYP6 + 8t2iEskdSaCSKEP6zVg1Act0ZTVMGlm2m/AbmICTTQWKxnEP/13j/Qya/r2xXDAWGHs8y72eggLjSIRB + 4Sv8nDDC7iFhfFPACJftXR7pfCRE+pvdaNquPfGf/j5cV1oiNe1fYvf9wojYv+E+Fex5b/c898OWByoU + 7Ya6YfFvw9fJc4k96yFo8gxF4/VNwWvZht3t2PP87r9vtHzRe9fIcanj921yUPWeg/KXHWzPc7DpX8Ca + IcAX/dVCCB/8XuZ2MkJLO8C/Zaz8rfQF2+DOF73/wY5QlbN8dRlSbx+Nw26ajJaDF8HJpsvGHEWrAbPR + ZhAtImgJIftSRpcPum84Gf/f3ntH2XFW6d6l4LC4sIZsG2wGsKVW5yBZ2DBkcDbBBJMZsNSKxnA9gBMY + ewjzjclhiEO4WOrcakmtYEXbyqlbsnCSLLXUOedw8nP3s9+q06flAxd9Y+SWvf/4rarzVjgV3jrrPE/t + vV+207T4H7DoEbz536qx/NEjoFHM0WrYn7Q/+Gkeek9i8jst/WX8uRTUaPHnDcMwDMM4K0jbaBhGQJAC + 4IuVaL8XatnodWz7Mp55cDY6KvPRUpaL5pJZaC/NwnDtXCR2ztbRLEKHGI3A2hO+GGeBzD2FGjHASIso + R8XQiAUu980ILTKZUr8iRci/EInuc1EW+lnON7b/MoQPzMRofRbGDtHo+WfED8o6T1yHeMOtiLb+AjER + g/HRIyI+epL3hUKTRS4pTAjTHviGNSIihrDNrZdybyk2GVlBApNBcGkfFOCyHYVpsC6hKGJERUwErTAm + yxh2zjomwXc4oeuL3mC7vwrFbho02oPzabbhMfgEIv6vkYyyOBVGXWjhQ//79JjTkPJdSdId06loBIoc + g15Ldz3T4Y6H05TvTMLrGWwf7MNd4yR6njKV4+LnQJwybSvM+xlnMUWep3wP98lj0+1cWk1wvGo+aGSK + 9AWuHxvxEtFhDyOPeomBDV6iu9xD68+BE3cDT/8rEoevQbz+bUgcKEJ8f6GabGpKar+eJc/4DCUsz3X8 + YD4w/HQyQoGmGs831WSZrIz5qUcHjzTjSz+pwms+/SOcN79CR9xgOsb0RVXwvsAoiYfg3cpIigp481dh + SnEtpi1e8Wyz4XT5kqtj8cp5f8Qdy3aCzzIjJnh/o3I/+ZnX1N1X12eifqrKqediGIZhGMbkJ22jYRgO + LZ7JP8D+sI4Uopxi9ISXaNnk9a39DI6Xvx3HKy5HS00BGktmoGlZDnpXz8boThoMBSJWWDAzG9gtInw3 + 0x9EsNRfhtChNzjDIhkx4QsbUpcB1HPeifgXKuG6NyJ+QIQcP/MasbCmmjKXIi7LEnvnIrGvELEDmQKH + MJ2hpk784FuQOPh2RJ76DBLHvwI0/xToWedh+AkP4Q4RmkNy/0ZlSkFKAUzjwReqWpRS7iFFKcUo76f/ + eQIqdlyY+6mmRcC4kA5g2zgqmmVfDhG/ug6FsjseJ1ZPlxRxL5//Fum3//sZN218ca9tz97/eFtwfv45 + UkwGpFzb5Hf4JgrTbMgEc0mX+9BIUPPA35em3fj3UdeLyfZhgdeUtUScaRGYR844Yj8Yke16PYTa5Blu + 9hJ9tV68q8yLtfwC8YZ7gGe+CDx5A3DoLWoUsq+RmDzDcaYtBWlQe6W/MjoqpRYL053YTyNCuC4TofoM + RA/KOk++Hxjr0f7Cc2bNm+T1kM+TGjlORivwusYSca/+SC++9JONeM2nfoHzipfDW7JZ609MXVTtoikW + sjBmhfvM+hLpDIfTokzTO5jucU5xBT7//dXoHhj24hjW3+bxfiRozQwHj5X3PO05GYZhGIYxaUnbaBiG + g8aEzgeiKOLm+YdYxVNkwBtpqEbbpo+goTQTzWWz0VxZiJayGegtKUTnxgwMbc8RAS6ipp6REW5YThaP + 5AgYSVNCC1H6xgRJFqZ8YRM/kOveOFPwqejj22eaOaxfUShTXgsW2bxMPrPuBaF5wXbZx265rntkuvcy + RGWdyMECxA6LGHzys8DRpRhrfwDRrv/20L/Ow8hhEaXdHqKhcXGYFImBoBbRq0JHYBi5TLWopS+i3Zt1 + GhoU4QL7gwpnB7ejyKYQdeIojbjn9wXoOo5AaOkwpz6pyx3+9wbHm7qvNCTFfYB/jAFJwU/0cwpyXhPW + TX4/v5vnFJJzdG+wXaqHO++kYFRo6ji4XaqxoqQcm+4/OJYA3W582+C6EpoOrqikEB+W+9rrIdwk9/kx + D32PeLEuueetPwOaHgAaviH9YRHw1MeAv7wLiYNFblhcFntlX1KjgWlG0v8OFGg0RGwfR+KRvhakXPlG + BJ9dZ5ZlKKzJQrg/3adGQAl13NdMjO56LwaaH4Weo6Bv/3lN9TryHCcvTEfSeaZTRdjfot6QHPumJ7vx + xf9YgVd+7leuQObitRoxMX1+uYumWFCFKVoAM53h8Pczdf4GnLdkLabS6Fi0EV5xKd575x/wVEOfdEUe + 05gXD9M8dMerI3tolEzw/BmGYRiGcTaRttEwDJ+IiLEER/mgEBORRCFKRGRQkHEdilGERr3QiVq0bbwJ + zcuz0VZWhMaqXJz4cx6ay/PRtSYfw49mi4gRoXOIgkjE9665InZE/ARQJLEGBYXN3hzEGWmRRtC/kGBU + hAuH57nTgLhMIyko/qIiBll40725luvB9I8g0kSv2Qxgt2y7h9dJhKNeO15bLpd2iks1LjJ1tJBIfTZC + h+Yi/JerEXv6k8AzxRhr+k+EW3+NeM9KD4P7RNw2O6GrKQn+vQ7MB19csj0QyePC2wnoiUj/oPj3CQwO + NTm07wRCf5zxFIYA933pcGksfEP813n2/iaaA6d+/7MJjpPI+RP/OqRFC48KyXQZaQu28UV58pqK4A3J + dWP6BZ8tPmPjZgOHjxz1ErEeLx5q9GLDBz2m8yQ6l3lo/QnQ+C2g4WvAkYVIPPk5RB77AML170SUNR50 + uFu5/4xQkj4Tk/uvQ+L6BsR4lBINwpmOA7O0j8T2cT2aEW7d8H5GQsg+pP8R9lWOVkN0e9aQ0X5H40Jg + X9yTJ/2Szzf730y0rSlA14nV0Gsg5x2kCml6R3B9JimMPOGxBmlGnGe/1988uZc7nm7GR+8rx8v+dTm8 + L20GR+U4b+EanFO8Gh4LXKYxHE6H8xesg3eLK6I5pbgS3m0b4M2vQf68X2HDrqekW8pzxyiJqDs2PW7f + PHTPmd9mGIZhGMZZQdpGwzB8KKLkjziHIY1iVKcq6gKxRQHHea7L6eiA1390OZo2fQzHS2ajr6oIHSW5 + aPlzJlpKM9G9JgNDD2cgLmIJrDkR1JlQUS1tFE1so3mhb26diHrBwqFHfSj0EvUcmlSEYF2B4kyHABGH + soxDl0brchHVaJQMuY5y7ZjqIevEZJ9RuY7urTbTRfxrymiMA65YqYpLfheHSdUoDFlv3wx9Ix6tm434 + 4XcDT38IeOZmRBrvQLTpXsTafohY5++9eN8qLzH4qIeRQ14i9JQXi/WLCBqWPjEmhD032osrzHdqFEHQ + RoK0BURFQAXmRzrYp/6BpB7fhH7P5dLPI3IuJIhWOPWcGDkRFMcMDJAJpgaH0YwMa6pNYuyoFxvZ58UG + N3uR/lVepK/KQ/OfPDT+Fjj5Y+D4/Ug88xXEn7oFsSc+idjjNyH62FsRrb9C7wvvtzMFeE+ZMsWCs4T3 + mX2JzxKjFfgsXSZwJBnOCxqBw34g26dMNdJBn0MfGhgB3Ib9I4m0EW5PZB2aGUE6B41HTTuqnylchugh + Z561rC1CYrBRrgcNF3cN49pXzgLxLP0glgjLfY544UTE1emISlvMN2yjzrSq2noY77hnBc6ZvxLegg1a + c4JDhqYzHE6LBeWYslT2xdFAFlf70RjrMH1xJV5/yy9QuWkfglS7UIgGoVzb5HPDfuifh2EYhmEYZwVp + Gw3DcPCtLv/4Bm962TYuwoLPY14sPuLe1PFPMdcdOeH1N5Tg6JrrcHzF29BSUYD20ly0LstHc2kOulZn + YXSLCJpdfMtbKKJHphRH+saW4kiEFofnDET8CxWNcOBb7jzE9wXkJEVjYk+uINdFRanbhgJV19tbgOjB + HDUqmDajNQH41lrrVsg1FBGrYtbfvy5T5NqqwJylBQsjrCdA4XtARGRdgaaaqODcJyJT9kPTQtNwUtNP + aHbsL0Csfi4Sj70DePxG4KnPAUe+Ahy734ntpl8j0rXci3ZXePGeVR76NnkY2OlhsM7D0OMeho948UiH + I9rtJWJ9IvoGRVyNaI6/giFBPis0QII0iVQj4K+TaiTQVIvLtg6KYw6ZGxJGvWhixIvG+4U+Lxrr9iLR + Di8Sa5N+/LSr4zFUL8e9S45/i4f+NV6it8aL91Z4aFrmofFPcr6/BI7/B/DMPYgd+RKiT81D5MnPI/7Y + FY6DlyN2cLYaTnp95XpS2LOWg9ZzkHvONnePffNBU3lo1Pn3XwvK8v7Ks7JXnhlF7jnvrW57itElfSi5 + fzU2Uu4fkX5AM8sZCy41gwZDQKI+Q/sBcc9lhnyXwOFxyW5B+xqP0Uf26www2f+BPIS2FqBz22dAoyki + 1xtxGjnuXgS/H5MbRiZIf9NhdV0b+xLPQX8X5bxoVLDwaHgs5n23ZCcuWrJMi2GeP7/i2WbD6fLltfBu + WY7pSzi06AqhFucsYYpHlSxfhYs/+h38/pEGNSi0qGpU+rZvujmDzB2zYRiGYRhnB2kbDcNwULjpn1y+ + jaPpQPy3yorOj79V1u2CPH5uEx7xho5WoHXDzWipyFODoq10LlrKCtFSmY2OVZdhcKOIIhbK1De/InhU + nPFNL+cDwfYC5dSUFj1vn73OXAhy+TWEXtfzRSiLhmphQkKR6MLtGUERkfUZkp98y+1vlwzhpxDVt+Wy + TvJ7uT9uQzFMwUvhm7KPv4Yvnp1pMi52GQXi3urzuJ2pwqgPGiA6ykO9iPX6Oa6456G3qsnBqI3E4auQ + ePxa4PHr3bCqT3wKePLTMv2sTL8gzPMpRoJpDX8DPPVFx5OfFz4ncD/c58cdj8n3kEPvAw6+W3g7UH+F + XNvL5bpcrmaCHq9vKjizh9eEZMjxZyN2kOdLM8DhzpfmAvE/J68Xtw+gSXDKerxOwf3W7+L1k+WB6SD3 + j2k/OhVYfDIoWqmmhx5jgGyf3C+PgWaDqxPhakVIG2ucKM5YmHAfee/1mcxx/UUI0oyYIhSpy3XmhsD1 + 1cRgn05+30z0bn0bwk/9QsWzE9AsLCnimb8PZ8ubfT1WRyzGaA/+7sX844+qGZA0XBJj3tOtvfjozzb5 + BTLTGA6nw/w1OOfWWpxXXIpziqugw5gukLb5q3DuwtU4f94KvP4j38bytTvksGiS0LgbT51Jez6GYRiG + YUxa0jYahvHcMCron+SxXi90vAKtD38ax6ty0FSSje7St6Ol7C1oLs9Fx8osDKzPRPgREUMUSnUzRBi+ + UQWRRhCoUJN5EdQUgExZ4JvdQHQ5ge+WKyqSDMP4hyLPJFM5Evsvl+e2ANgt84dyEWb9lL2Xo6u6ENG+ + p/0og7j/Vl9EPFMjNLpl4u/FmYepEKxPMm6wRqLuc5jz/pTtakwwOkHrPHA7ZwQofn2HYLjUsEzXb34E + mXfvgLe4Bt5ttXjJgip4t2zBdA5DurgE3iJpT2dInAbTFj+EKfOW4bIPfhsV247JZYUXjwy5Y5T51OK1 + cUZ4+McaZw0NLjcMwzAMY1KRttEwjOcI/ZPMEQ3cH/1YqNsLN65F97YFOFaejbaKTLQtL0DbsjloKclD + S3UuejcUIbyjUIRPtogdvjHOESEk83tlniaEjgJQ4EYToGGhb4gDKJiCN7iGYfxD2cuIipng6B4uAiNT + I2ZidZcCOwvQufZaYKzVmRMxV7SRaTUc5UUL7LL9eSWqYl3NB0Z6JSMi4jocJ0fDYJvO6/G6IUUZmRBE + J1Dop4p97of7C8XgNbQMeQXffQRTl1RiyrwSnL94DaawUOZipmbUpjUcTotFa3DuvGq8+ot/RMYNX8OO + o+2u8GiUNYJ4PM6Y0PNJLdAqmEFhGIZhGJOPtI2GYTw3OFMipvnm/COfTA0ZOemFe7Z5I1vm4eTK9+DJ + yhwcr5yNlpIr0PbgbHSUFqG7Zi4iD+chvjPbmRJMP6AxoVEUDDlnTn6+fGYKgrTTqAhC7oPQ8nSCyjCM + 54bduUgcnAGO5KHpRVo/Q6Z1lyK6NROd228XsRxSIa/FT+U3IJ4I628AR1M59ffizBP3ovGYmglOrEc8 + Hi/icow0KRIsAuxSUoJ1NFJCcKJ/fD9BlAJNAEZf6DrRkNc1Au+q/3wIU768Dl7xg/AWb4Q3jyNwrE1v + OJwOC1bh3Pmy38Ur8bKP/BDvvOU7aOyW46d5wuNMM2JHJOJMoXTLDMMwDMN4fknbaBjGc0OcRTQpTBT+ + gSfus/uDP+pF2vZ4vbvvQ1vtu9FYkYXWyny0VRSiqeRSnCi7HG0rZ6N/cwFCu3I0Z348p11EUGBGqCEh + n5nSUcdICy7zUz0Mw/jHwAKd9TO0fgXrZLhRdmRafxn61mZi8GiJ/Ay4KANoWgSfewp/J55TfyueH1yE + hKabUKzTkIiHvFjUmak0JdRMYRqHrBOT3zO2R/zjH0+RiHuJuIu40HlGY8Rl25gzChr74OXduw7erRu0 + FsVLF1bAu4Ujb6QxHE6DKRwRZN5a2e9GTJF9XnTd/fjsPb/GQES+O2U0FDVVzIwwDMMwjElP2kbDMJ4j + ONSe/GlPxMMqAvj2UU0J+cMO+dNP80KL4/FP/dDT3sDhH6Bh7XvwTMUsnKwuRGNJBppLijSiorW8CL1r + shDelg3sLRJhdDnAmhQpBR0TezlNMSsMw/jHQXPiAItzuhE+3Ogh8nzKM9la+zYkhp/W512fcaZNxBPy + WYS+n/qQ9jfjDJKswyBovQjfVGCdiX6ZDnI9RlLEur1obNQV9eRvlcwj6kaD0X2l1HZwuH0xEiPM85bz + 3/7MKP5pKUfcKIM3vwzTl6xPazicDmpOLBQ4hOmX1+KlH/sNXnvV1/CDkvVyGO5c9Pr7xxkYFIzuCM7d + MAzDMIzJQ9pGwzCeG1SICG74R/eGUt9S8g+7rsPlUS8iBIXnMNrvhZ4uR/vmL6CtKh8t5TnoKMtFZ2ke + Wpdnq2HRvjoDfQ9nIbozS4fb1PQOTfFgyoeIJpJOTBmG8RzC5y3DjS5Sn+meRWkb3Z2Lti1flEd8VAWy + MyMDcczoBJoUwW/A84kzEjTKgccn84yI6BmDV7llL36xrQXH+miuhmQ99xsWi7oRjPT3yhf/rp7DRHOC + aHRIZMA/d3hz7l0Pb8k6LYY5lQUy0xgOp8X8GkxfulqHLvWKV8g+V+CCj/wUb/rArag/3CBfK8cQc9ea + jNeZmHichmEYhmFMDtI2Gobx3KF/3gX+UWeeeQLujz5TPNjOehQx/Szrh4n80WfON9drWuG177oLR2re + g4ZKETzVQkU+mstzcKIiA63VGehZk4PRrYVI7J4jwkhImhQWPWEY/0h0NB3O7+Pwp7OAPfLcybPX+XAe + Bg/+WMVxIiYimMML+78DOloHDQo+7/L5+SQWGx9xQz9H+bvjIicOn+jA+bdvxBvuWIcvVRzBqoOd6Bh0 + 0RL8LRuW3y9GRfCcaGxoNEJS/Af7jHhjMqWJsbZhBNMWV2HKknWYymiHhZXPNhtOl6W18D7/IM5ZXIOp + t3BUkHU47xO/wYUf+AY+efvPERxfYFAEx2bmhGEYhmFMTtI2Gobx3OAiJnwhIn+UdZqCEyopnxPjb/mY + BsKhSDXfu+9JL3zo52hf/RE0l81Ga3mepnm0lM9BU1kemiuy0LFyFgY3zUJkh5/WUWc1JwzjH0m0nqPp + ZKspEd8vzxyHAZbpyQ35iJ2ogdaa0DoOzgSgqI/paBgCTQs+388jPCaN5tL6DPydkt+aWCh5rKueHMYr + v/A7eIs2YOrS9bjkq7W48ee7cd/Kx7H5L63oHhjxhsYiyQiKwJwIPkdGh7yDDaP4SsnjOPe2Uky/dTm8 + 4nWYPq9Gi1imNRxOiypMWboKU+bXuAKbxUz1KMEF138PF99wD9Zv2qoGBY+Fx6TnrNErcpyaivLsa2IY + hmEYxvNH2kbDMCYHLtrCoX+qh9q88PHV6Hx0CY5WXY7mqhw0l+eitbwAbWUFaCnJQUtlNrrW5qB3qwim + XRkuxeNAphbTdEX7RExRRHGEjzpGV/BzvmOPtO8JzA2+BZb1gzQRwu2CbfcxQoP7M4xJRFBzRSOHXCSD + ktqPfeIHZiBRN1OjHhyMgPDhNvLcJPbKs7OPtSUKXJsWmmV9CZmyxsSuQkQOXoZ4PaOW5NnYfSlaat+G + cKgp7TN9VpEY8m5f3YBzF5Zp2oS3dA2mLqzBuQuq5fNqvPIrFZh57zq880cP46Zf78Jn/rAfn/vjQXz0 + N3W45ke78Lp7d+D8W1fDm1+l23kLHFM5jCiHFE1rOJwOKzBtAYclXakpHVPIwgq8/KYf4eJrvor3f/k3 + iKg5wfQ5OZ9YzM37ZvCzztcwDMMwjOeVtI2GYUwSONpH8OZPSBbWG+v1MHDEG939DbQ+9FE0VBXhZHk2 + Wspy0VqaLxRqIc3m0ivQU1uIsUdEYO0RMaVDkRbocIcUZnERZjGZxvaLuJKpFtekwKLxwKKbgRAjuoyC + T+a1+OZMmReRZxjPF0kTIs0ykrqMEQ5Jgn4sz4NvuCWYkpE037htFiKyXlTWc4Vm5fnY/yag/lLgYBai + ddny3LxZ9xc6cDHGZPvww5kYXZOBgU1fgqZopT7LZyPyWzMagXf9Lw9h+iLWdaiGt6DCpVMsrtGICm/x + QzJdreYA60hMW1iDKQtXw1tYq+kW3rxyNSemLXKGwpRFqzBtMUfqYGrHqWbD6eKbE4tXYcoCRk2sxNRF + 1finj/wUF117J950413Y/5eT8jMa0ZFGmEoXiY+aOWEYhmEYk5S0jYZhTBI0FDnqxTDsRTDkheRPtkZR + aFhy2ENMlg+0eeFj1ejesRBNNW9FS0Ue2ssL0bY8D8cqaFowDaQI3ZV5GFwj4mlrBiIituKPZSNR74gJ + gRCbMFxpisijGeEMCZoYDGc3c8J4nvl/mRM049Rsy1KDISC5TdKM8Nfj+mrgyTLdN/cj7fsLZbmwP0/X + je/Ow9gj2RjYVICBNbPRXjUDzSvy9bk7WVaE/iNlcCNbnOVovYyQd7gz4r3p7g04p7hcjQBNyVhSg2kL + VmFqsYtaCMwJRi/QNPCWyDrzq9TQoDGRjJxYuNKZF89R5MTUYh6PHAfNDh6PHNsrPv5LXHDtXbjg6jvw + oz+tA2toRCNyPgmmsLihXN1vq2EYhmEYk4m0jYZhTA6iSHgxsAhdSP5UR+QPdcL9qSYiHLTYm8Apl0U6 + j3p9B3+J9g2fQGv1W9BZVojWshw0lWeisSIXTRVFaK4sROfKHPSuy0R0O98Y+8LsoMzXOVxKB0UcxRnf + NEtbKkGofKoQNIzJQGBYkFTzIejHQd9l366XPn5gJhL7LkN8zwxpozEn7X6EReygPCP7sjG2PQsjm7PQ + v24Wumuz0bqiEI1ll+OZyjw0PFiArpIctMp8+59z0Fj6VsT66r0xcFSL8Wf5bCShxXo5H/FWPtmLly2t + wfmLaqBDeC5ah3MWVGN6MdMpVmLqYkYw1GqKhUcjgsaBTE81JrgeoydoJDzbbDg9GCUxhcOIJs2JlZiy + tBav+MRv8Nrr7sFFN9yHD936AEZ4LvKbmYjxnPwUD79IqWEYhmEYk4e0jYZhTBKC8OPAkPDTPNjmitaN + OYNCPkcZRcF1OQ21ekNdm73e7V9Cy7qbcbzy7ThRSqNiDtrKL0dzWSEaSrPQ9mA+uiqzMbh+FsKPZiK2 + l0ZFnpoTzMVPhsGr8PMFHQlEX6ooNIznmyAiIgkNtgyfU5cJQdqS9nPWUClCfFchQo/mYXhLFrpX5aJ1 + RQFOVM7BMXlunimbjYayXDSXcnjfPLRX5aN1WS66ymfhWOWb0CSfOzd8HBjrlmfx+S94+T+FxudYnOYo + BX3E+7fyg1pvYuo8RkZsdiYDzQjWkFjIVI11wlr5vAZT9LNvJJxqTATt/0Om0ChJNScYxbF4JV558680 + cuK119+HzA9+DU0Dw/rbyOgJjozEIqAvhPtjGIZhGC800jYahjFJCEwJ/pkGhyFligdTO0JemG9maVZE + GXrtRvlwkRRhL46Yv03Iw9gJL9K82hvYfzda116HptICtJfmoresCK1lc12NirIstJVno6M6Dz1rRJg9 + koXoHhFtp4q5ZLpHwKnLDeMMkholkW55HVOQLhOYghT0V5ptwt4cxHYWIfxoIYY25Ui/z0J7TSZaKjPR + VJaNxtIsdD+Yja4H89CxfDY6SovQXp6PllJZR2ivyMHxqhy0rPsYevfcj67DyxBr3+Ul+o7oM+tG5eAz + ePbC3xNGG3C0kXgsop8//Nv9agZ4i5nGUYGpiyoxjfMLazS145wFNTinuArT5lVMMCI47yImXBTFc2FS + 0JyYkNZRLJ8XVeOVH/0JXnft13HBdffhzR+4G39paJKfTzkP+U2MyG+ijqKSMuypYRiGYRiTg7SNhmFM + DigGnOGQ0KFF3ZB/skzf/Em7QFNCTYj4kIdwxEVOcBlDsmU+rPP+OsMnvURDDQa3L0Vr1ZU4VvN2HKuc + jRPlOVqXoq3kSrQsewuaRIg1V+VhYEMOhjfnIrK9ANjDvPt8EXw5MqUYZIHAU8SgYZxJUk2JZISP3040 + GkL67r5CJHYXIbqjECNb8tC3PgudqzJ0ZJtm6fvOjMh2w/KWFaLFH6a3YUUGmqpkvbIMeTZy0FHzTnRt + /jz66r+L0WMPIt5zzENoTJ9Jpg3EEBfxK88ahTCfN33uzmL835m4CnuaLXHvxHDcu/Sb6zBtwTI1A7R2 + BFM0/OgINR2Y3iG42hKrdJpqRjCCYtoSRltMNBtOG5oSxS6VhIU4te7F/FK88kMP4JJrbsdF19yDN37o + Pjx27KTcDldrgr+L+ntokROGYRiGMelI22gYxiQhQeEjosAXCQqFQoC+1Ux4iURMhVFgZui2KijkD7i/ + HU0MhjNzeTgR8obCfR6OLEf/rq+jcfW7cbJiBtoqZqJTjYoCFWknlxeoYGutykHX6hwMbMhEaBtH/pg1 + UQwaxvMF+6HWSaFpJvP73Mg0sd0zMbw5H/3rc9G5Klv6cJYaEc3l+Wq+NZXOQQuNCNZlKS/SPj+O9Hmh + qfYT6N11F0aPPohw9x4vGmrxEvGwGhH67GlhWnmmWJw2ysimASd8ZVnyOTyLicvvBItJ8lwSLI4Zk3OX + +c3P9ONlt63HlOJarT/BophqDiyqhhbDZI0JFs3060BwNA83goczFdSo4NCkqUbD/x8Wr9JjCMyJ6cVV + mDpvGV7xge/hDdf8b1x83Tfxzx/+Npp7++XY3e8ozQktVmrmhGEYhmFMOtI2Gobx4sClf0S8+HCLN9Cw + Em27/g3NtVehvXw2epcVoa1SRFpZlhbVbC/JR9vyArSVFaCrJg/963LQ93AWxnZmI05RWE9xmIPYfpKl + o4BgXx6w10VZsIZFvC5LhzF1tStku305SOzPFWRdFitkIU6BI4bE9s2UdfIde7kfWc7tAkGq0Rv+5yBU + n4UPtfhhgU+w3EiPf93SLhOCmgypBFEJspz3MnFgHN43wnvtapbk6f3VoWv3Z8o6sn2dbFvv1tF1Zbsg + zeLU+6zraxFWN0qGHlOdHJP0I+0D9TMQ3TsDo9szMLA5G/3r89GzOg8dlbloZ02V8ly0lOQIedJvmZYx + W9OYmNbUWZ6nUw6/21xdhJa170PHo7eg77EfInRyPWKdj6V9Zl5U0ISRaVBzguYEBf6gtC3fshvT51di + OlM8ijdh6vy1OoKHV1wKb/F6OGPCpXAwwsKZGAG1E9C6EcUrXaHNhUH0hVtPzYcFjLLgMreco4ScI5w7 + v0S+U753wSZMW7ge580rwUs/+kNcePXdeNPVX8Orb/gePnjrjzAmx6xGEg2KeMyLR2nmppynYRiGYRiT + grSNhmG8OOAfdI4CEk9w7H/5884aFkMt3nBDKRrrvor26veiuepKEW8FaKrOwUmO+FFagOaSIjQvm42+ + /zMXXctF7FVnomt9Jka2UVxSSIoA3ftmHe0gUS/zFJh7CoDds6W9wAnZ+jeLyGQBTl+MBqhYln0wJF/r + BaSpGUChmlqQM1n08BSC5cZfgdea+J9942F8yM3A7JH74Q+jOaEtMCoUbi+oueCWcxSM5H3gfdZtaDZJ + H9jDlAuux++XdQ6wPkSAv7/9RW59mee+EnsuRXTHDIxszkH/2gK0SL9srWTkg8z7URCM+GksFyqL0LZs + jppqrRXZWkviZGUWGqrmoHnl+9C17ia07ftPDBwpBboOeggNasSDizji8+GP6vAixhXd5ZRRBoGwT2gb + DYrP/WkfvIVlzpRYuhbTFlfCu7UW585fBm+RzGsUhbDIh0ZGKktWO4LPyfUYeSEsqnK1LAQtfumbFlqE + k5EZsg5HC3EjhKzEqz71O1x4zZ14/QfudKN1XH0nflWzF1owOBJy99XHpboZhmEYhjGZSNtoGMaLBBaF + 80PUYzKlGAmESDwW8iLRUW+4a7/Xe/iH6Nh0M9oq57ooinIKvtkiAGdp3r5GWJTmo3m5tMu0c0Uu+tZm + Y3jrDER3UugyCoIi1RfDah5cOt5OMRq8DfdFsorjQDSnI1UQJwU238zL/gJO3caYCK8hpxqJElzDv4Fe + c15X3ps05oWaD/J5L4eolf2dck8n3K+6XDWp1KiSdRJ1eUr8QD6ie/MxticXg9tnYWBrDrrXF6BtFeug + 5KNR+h7Nh5byuehePgedZbPRVpGPFhpn5a5YZUdJDnrYH1lPYsWVaNnwUXTsvhMDR5Yj1HnAi492a5pC + PD4iQjWs/Z1v1lnTJSLClXUjmM6Q9pl5EUHzMqLDGcs8a074wp4GBae9IXhX3ktzYS284mpMn7cS3ryH + MHXJJkyZz2gJDjO6YtykWFgNNS0CllTJtoIaGVzm1ktut1hIadPUEd+ooHGh04WrcO6SlXj1Z/4LL3/P + 7XjDDd/EBdfdi5dfdxeu+PgdONruan/EddQRTnnfWVj42edrGIZhGMbzS9pGwzBeJEQpzuJJ0QGwxoXA + eUZRyDrOsJA/9eFRL9L1hDf89IPo3rEYTbXvQoMIxJMVhWisyFGToqUiT4sJUjyeLCtAw3IRjlVFOiRj + 39pMjGzOQnhbNqJ7RKAe9IWrilcK3Qz3dpxv2/dfKu1868635k7sJoWtilyK6hRxHKwzYT3hVHFtTCTV + nAiMowCNdEhZT8mYSJA+o/fAX49RLjSG6mf60Rcp36HfM76/2J58RHblIvRoFka2ZmJwQyZ618xCZ00W + 2iqz0FKWj+ZSFxXBGhAt5bPQXH6ZMEOjIXQEDaZmlGaraXFy1bvQvOWz6Np/D/qe/An6Ovd6ocFnPET6 + nQmXjIpgfZZR17eDvk7BzboKcUZMyLLEoPb/FzMq4uX3Qc0JuXYU9nr94jFN8UjIb8Wu1ihe+9U18G5b + B2/eamEFvKUbNZ2D6RepBKaDsrDKkdJ26vpuGxcVochnLbDpw5SO8xeU4dUf+xEuuOoeXPLh+3DB1V/F + JdfcjQtu+Bb+UPOo3FqeS0TvNY0nd248J5qwwWfDMAzDMCYDaRsNw3hxwD/uAXxbrG8T9Q98VMTZsBbQ + 5NtkF03hCzklKoJv2Btr3uT1H/4lWjffgqbqf0GrCMWOslwRkkVoLLscncuvRFvpXJwsy8Mz5bk4XlmI + horZGnXRXTMHgxuzMbo1T0cDSewO6kTkOWGsYpZ1C4KUDkKxLO2BIcGIC8UXvrodDQp/eSCujb8DXleZ + BgTpGclreUp0hBKYFLJ+8h4I/EwDgkUqZb+JPbmI7cxDeFu+jpYx8FAeetfmomVlhvSbLDRW5KKxpFCY + rSlDraWFaJM+087InNJsNC/PRXOpK1LJKAkaXh3V0q8234jW3QvViBhr3+phuFH6pW+uEa2REAhq6d+x + RLI/c1heNSX8iCGOiBNFTJerieGbcy9qJhiXzqBwQ6QSDmks7dK2bMdxTCsux7RFqzH9ttXwbvk9zl/C + qIdVGtng6k84QyHVeGAhTUIDQs2GAH+b6fNqNAJD0zaWyn7J4jWYumANzp2/Dud8/vd4zU0P4IKr7sKF + 19+P193wPbz66nvw5hu/jjt+XItR3kfe6+iw3uOQfnZtvNcTztUwDMMwjOedtI2GYbw4iMagBoS+QRZ0 + NA/5Ax+0xfSNI4WIL1L8nHyaGBRzKuIoYGKjIgybvUjrNm/w8M/Q/vAXcLL23VpMs6l0pv+mO1PTQTpK + 8tG5LAfdy3O0PgBHT2BIPkcE6VyZo6J1aFMeRrfmI7bLHxlEoyB80RsIX30jf6kjMDEmGBmBmWH8ffD6 + khQT4tTrG1zT4Pon64FI2948xHcVIvwoh+sswNDGArmX+eiuzUX7iiwdLYP3ubk8V0eAIUzB0IKrajoU + av2IlooCXYeGRXNJFtor36r1Ibq334bu+h+g/2gNxtoPe7GBLumbEel/QpxRD+P905kN7Js+vph2yDz7 + N/u+CFQaFW6km6gXkc9MY+C2FvYvMJJErlWcQxTLVCMoBGfuRFx6R5hRFPD+o/Yopt1SBW/hRjUlWMzS + W7rKsUTQWhHOdEiaEBoV4bctpvHAqQ+3WbhBpg/Bu3Wt7Id1KEpxzi1/xEs/82u84uaf4fXX3oXXXnM3 + LrrxXlx0/TfxqvfchTfK9IFlDyMWdf3Ape24yAm9pxzdKB51/cMwDMMwjElF2kbDMF4kaB65L/BoMqjZ + ECyXNl/s6Xoi3jhkqRN0zN9mLrcTewz9jsh6WniOIkYEQTTe70WaNnhDh3+Fvm2LRaS+X9+GN5fm4ERl + EY5WXY7msoDZKUaFrCPilPUCKGg7arLRsyYHgxtzMfZwPqI7cl0xRR3ZgSkFhQKLK8rnZMQF39r7b/SN + vxNeN0Y68LqyZkSuu440JPaxBkgm4ruzENuVq/cgsj0Hw1uydHjZ7jUZaK/JQEtlBporstBUluMoLfLv + bUChK6jq3+uu5e9AR8lbNG2DBSwba96Otg0fQ9+Or2DswHfQ1/YQIn31HiJd0helD7Iv0ogI+m9ECEwJ + +ZyMiCDSpyPsm9LuBLVvvgV9WqApwT6taQpB/RVZJ2luvMgJ87rw98BHn3PfvOFyXr+wXGPW5xgWPvhf + j+Llt5Y702HpGkxfXInpi6owbWGlDjOaWthSi1tqYUvOu1oS0xZW4xxZ99wFpMJFWsyXti8uw//6zG/x + T5/4EV714fvx2uvuxIVX3443XP0NXHz9V/GGa2/HJdd8Fe9a8kOs3v6E3H5GgoWdGaF9IZo0XN25+FEf + hmEYhmFMKtI2Gobx4oB/1vUPu0JR5wwHpm/EfQHHvHP+0Y/Kcv6h5598FXEi8sajLGhWcHsReApNi5CK + A26jREJeqOeoN3piBfoPfgPNWz6C9soCDdPXegJlHNaR86wxkK+ClUUPKWopcilq+badxkUQadG9mukB + +ZomwHSB8LZcFc+akpAaaWH8bTQSIkuLWDJaJbx9FkYfmYHBDfnoX5+r5hCjWtpX5KG10kU9NJYysmGO + G7lFaCmdrek8vH/BPWRdCC2WqvfX1Y9oLZuDruor0bfqnWjb+VX0HXoA4YZKoLvOw3Crl4iMab+h4A0E + JRnvZy6aJ6iF4JY7U8LBeQrnoF/zM/uj65M6pdlG4Z3ssynfkUi45TTskvt4cTImqEGhERTjhSR5rdTc + 4e8ARoUhLyRtoUjYO9o4iH9ftg/n3/xjvOTT/43zP/0HnP/ZP+Lczy3D9C+UYNq8CkwVphRXaxHNKcWV + 2nbOF0txnqzD9V/yyd/jJTf/Fi+/6bt41Qf/XVM2Lr76m3jD+7+JS1hb4ppv4HXX3Y1X33g/Xnv1vZj7 + he/jJ1Xb0D44LMfHY5R7F6c5xePjsdNQlfurxhQ/W+SEYRiGYUxG0jYahmGcEfqe9qJt273Bp/+Irr13 + om3zJ9Gy+n1uVJDSQjSJsGWYP4tstpTPUWFLAeyEbg4aZJ0TIoRZ0+IkR2Yoy3aFEqvz0L0yX0R1FvrW + Z7naFluyEXpkFqLbZiG+YyYSu2YiciAL0TqOFJGjcNQIohEEdbmI1sv6QrzOwZElVMz7tRWC0SYSB2T5 + /owk40UjZT2yV7ZJJWjfz5QIn+Q24wTf677bgTpGhfjUZ8hxy7kIOl/vhm7l+rEDXCbntC8Lkd2ZiOzI + 1mKkoYdzdSjO4Q1ZGFg/G31rC9G9ugAdNazlMB65wmt6oqxIYXFTopEtgXHEaIfyiVERakioOeFqQ7Ss + uhbtGz6B3p23of+x72PwWClG2nd44eHjXiLWk75PGGcNalJwGnepE/GEi1agUXHHt3+KN1z1dVxy9Z24 + mMN7XnsXLrzubh3i87XXfwMX+qkYAa+79hvKRdfco1x49d14/dV34GJZ/8LrZP3rv4XX3Xg/XnPt3bL+ + Pcj+9ANY/O+/xLL1u9DSO+aOhdFfhMfEz4ZhGIZhnFWkbTQMwzgTjCCqQkbfYmpERsTDaJM31rHd6zlW + icE9d6HzkQVoXH8Djq+cg4aqLE0b6CgtQGfJXFd8syxHcZEXTAfhEJL5GmnRWjJb4Vt9olEY5XPRWOHo + rMxAz4os9NXmYGh9DkY2CiLcOarI6BYR9A/nIfpoLiIi6mM7shDfJeJ/t4h+DoG6f4YI/7wkif35PuPF + IwND4a+BA0xF4ba5Pm4fMdmWuMKUmc7Q2JONxK4cxHfmyrHkIro9B6FHCjD2cAFGNxdgeGMBBtcXYWBN + IfpWF6J3pRt6kwYPYQ2HYJqk1NV/0GKTpfloL3E1QbqWO9rKczUVh8uIMybkmlfQBMp0dURq3oLOddeh + c8t8dO+6DwOH/4DwyY1A134PsTGBwpWikVEJFLLuXmtx1ZS+YJx9sGaNu480BFwUSjSW0KiX5p5Rb+lP + H8LN3yzBvxT/GDk334/LPnQv/vnGb2rUw2uuvgsXXXun8rrr7lJoYFwsywI4JOglH7wfGR/5Ft76r9/D + Z+/4L3zv1yuwacdf0N49Jr8fzgjRKBmm52gBVEbEuCiYU4/XMAzDMIzJTdpGwzCMMwFFhcL0kOQwhT4M + wQ4+h0TkDrR58c793nBDKToeux8n9y5FZ+3VaFvxLjSWvw0nSy/XEUJaKy5HG0cESUkvSKYh0LSoKEjC + 6IyWEpkvEaG+PAcnS3J0vUDIB8aHpiUwooAFG6tE9FfPQaPQtjJbaV+VI2SjY3WOwiKQpGONo3Nt3gSC + 9vbaLEG29WmpzU7SvDpLIxkccqyV+YpGkgg8l8YqOVahqZLH7CJHSLNPcNzBNhzi1TFb1p+DpqoMIVO2 + z9b9nKzI16FhT1TOlfO7Qq5jpoumWPUvaH3oJnRuvw0DB3+A8JEKxE9u8EZ6TnjRkTa5Rxx2M+QxrYI1 + CShOKRqdaE1B32zz3rKAZUrtCOOshNEJTK/Re6r317XToHDPNtMnYt5YPOr1jIx5De09Xt1TJ7F1/+NY + v/0g/rzpMfxhfR1+t2oPflW9A79esRO/r92HZRsfQ9nWJ7Cl/gkceKYJJ/qGvX7ZtzMyY7JfpucQfidN + CabhkPFjsMgJwzAMwzj7SNtoGIZxRmBBQy1wyPx+5q4LibCf9w8vIgR1LXR9TlWAuJoA8fiAFxlr9kZ7 + 6rzhpjUYOvrfGDz0bfTtug3dj9yCvtXvRXfNO9BedSU4fCmFOoX8yYoMnCifiSYKdKVIzQon4pnWkKPQ + vAgIUhmCYo6kvWR2CoXoWD6RtpLsvwkjFRyFSur3KWVzhYnpLBohIsdGGPHg6nC441HDgtNKOUahqTxT + I0000qEsx33n8hx0lxSgr7QIXRXvRE/NVehZ9zH0bF2Ant13ofcQR8T4HYZOLMdY+yEv0vOMh5Fu/620 + M5MoEkf1Hsq9CEQpCUyHoOhk0E78dd3oGKwLwDftbDfOVlgcNxqPJZ9XRGPJex2Lh6QPBPU9UvpICtxO + t+X+0ix3RiX7k/SbwKxMXaaFfH1TQtZTgzM4Pq4TzBuGYRiGcVaQttEwDOOMkCo2BL7tHIeCg8iyAIaR + qyhx6/y1fXEdFr/jW91waMgb7TvmDTVv8wafqcDA4Z+hb9+96Nn1NfRu/hy6HvoE2lbfiKYV70Zz1RUq + 6llss60yCydXZKGpOguNVdlqamgUgqaPuBQHF2ngDIEkftQFYZ2MgKA2Q2qbi2pwuBFKXHRHsC8aC0nK + c1x0hBxHQHvZLLSVZ2t9B9bpaKl6B1pWvBetK69H66ob0bNxHnq33or+nXeh/8D/h8HHf4uhY5UYa93o + hbu2e6FQtxeNDohApDFEg4iGAfHFZKrJoMspBgUKRmlzQ3CmhyNl0MQgLEzIYTqDYoUc6cWN9sL9Gmcr + sQQLkPqfpT/o0KKaVsE+xP4SrCd9QuDwwy6igvM0EsbhqCk6csqE9vF9T8BvD8wIHkOyWK8uk3YteDq+ + rmEYhmEYk5+0jYZhGGcGf/QFFtQ7VZiIAOYwhSERtWH5TDFDAvEbpfiJyj4ooJP4ooRvU1UcUXSnjtAg + 6xBuR1TsyPrRMQ+hXi8+3OJFeo54o20HvaGmPd7o0UqMHinHyJN/wuBffoX+Qz9E34HvoHfvPejZeyf6 + dyxA3/Zi9Dw6D10PfxEdWz6P9o2fRetDn0bL+k+hdcOHlZaHPoTm9R9UOB+0t8l6pEO26dr8efRs/QJ6 + H7kF/dvmC8Vo3303Ovfei87930Zv/ffR/9jPMfz47zH6xJ8ReqoEwycfxljzdm+sfZ8X7X7ciw8e9xJj + bXI+fXJeQwLrPTjDgWYPxSGNgiDtIqGjMATXwUeuD99SkyiG5Fpz1BU3SkMgLGkwsN3dk5juNy7oW/Dg + GnM//A4hdd8aLRNcfy4zzmomRCsQuc/xGJ+3lOczpU+4fsBoiNQ+Nd5XUklGUwkJIYox6b8R/T1wKR7j + 2xOaE26UIZokpxyXYRiGYRiTnrSNhmEYhmEYhmEYhmEYZ4q0jYZhGIZhGIZhGIZhGGeKtI2GYRiGYRiG + YRiGYRhnirSNhmEYhmEYhmEYhmEYZ4q0jYZhGIZhGIZhGIZhGGeKtI2GYRiGYRiGYRiGYRhnirSNhmEY + hmEYhmEYhmEYZ4q0jYZhGIZhGIZhGIZhGGeKtI2GYRiGYRiGYRiGYRhnirSNhmEYhmEYhmEYhmEYZ4q0 + jYZhGIZhGIZhGIZhGGeKtI2GYRiGYRiGYRiGYRhnirSNhmEYhmEYhmEYhmEYZ4q0jYZhGIZhGIZhGIZh + GGeKtI2GYRiGYRiGYRiGYRhnirSNhmEYhmEYhmEYhmEYZwZ4/xcjI/zVR2zuVQAAAABJRU5ErkJggg== + + + + + iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAABGdBTUEAALGOfPtRkwAAACBjSFJNAACH + DwAAjA8AAP1SAACBQAAAfXkAAOmLAAA85QAAGcxzPIV3AAAKOWlDQ1BQaG90b3Nob3AgSUNDIHByb2Zp + bGUAAEjHnZZ3VFTXFofPvXd6oc0wAlKG3rvAANJ7k15FYZgZYCgDDjM0sSGiAhFFRJoiSFDEgNFQJFZE + sRAUVLAHJAgoMRhFVCxvRtaLrqy89/Ly++Osb+2z97n77L3PWhcAkqcvl5cGSwGQyhPwgzyc6RGRUXTs + AIABHmCAKQBMVka6X7B7CBDJy82FniFyAl8EAfB6WLwCcNPQM4BOB/+fpFnpfIHomAARm7M5GSwRF4g4 + JUuQLrbPipgalyxmGCVmvihBEcuJOWGRDT77LLKjmNmpPLaIxTmns1PZYu4V8bZMIUfEiK+ICzO5nCwR + 3xKxRoowlSviN+LYVA4zAwAUSWwXcFiJIjYRMYkfEuQi4uUA4EgJX3HcVyzgZAvEl3JJS8/hcxMSBXQd + li7d1NqaQffkZKVwBALDACYrmcln013SUtOZvBwAFu/8WTLi2tJFRbY0tba0NDQzMv2qUP91829K3NtF + ehn4uWcQrf+L7a/80hoAYMyJarPziy2uCoDOLQDI3fti0zgAgKSobx3Xv7oPTTwviQJBuo2xcVZWlhGX + wzISF/QP/U+Hv6GvvmckPu6P8tBdOfFMYYqALq4bKy0lTcinZ6QzWRy64Z+H+B8H/nUeBkGceA6fwxNF + hImmjMtLELWbx+YKuGk8Opf3n5r4D8P+pMW5FonS+BFQY4yA1HUqQH7tBygKESDR+8Vd/6NvvvgwIH55 + 4SqTi3P/7zf9Z8Gl4iWDm/A5ziUohM4S8jMX98TPEqABAUgCKpAHykAd6ABDYAasgC1wBG7AG/iDEBAJ + VgMWSASpgA+yQB7YBApBMdgJ9oBqUAcaQTNoBcdBJzgFzoNL4Bq4AW6D+2AUTIBnYBa8BgsQBGEhMkSB + 5CEVSBPSh8wgBmQPuUG+UBAUCcVCCRAPEkJ50GaoGCqDqqF6qBn6HjoJnYeuQIPQXWgMmoZ+h97BCEyC + qbASrAUbwwzYCfaBQ+BVcAK8Bs6FC+AdcCXcAB+FO+Dz8DX4NjwKP4PnEIAQERqiihgiDMQF8UeikHiE + j6xHipAKpAFpRbqRPuQmMorMIG9RGBQFRUcZomxRnqhQFAu1BrUeVYKqRh1GdaB6UTdRY6hZ1Ec0Ga2I + 1kfboL3QEegEdBa6EF2BbkK3oy+ib6Mn0K8xGAwNo42xwnhiIjFJmLWYEsw+TBvmHGYQM46Zw2Kx8lh9 + rB3WH8vECrCF2CrsUexZ7BB2AvsGR8Sp4Mxw7rgoHA+Xj6vAHcGdwQ3hJnELeCm8Jt4G749n43PwpfhG + fDf+On4Cv0CQJmgT7AghhCTCJkIloZVwkfCA8JJIJKoRrYmBRC5xI7GSeIx4mThGfEuSIemRXEjRJCFp + B+kQ6RzpLuklmUzWIjuSo8gC8g5yM/kC+RH5jQRFwkjCS4ItsUGiRqJDYkjiuSReUlPSSXK1ZK5kheQJ + yeuSM1J4KS0pFymm1HqpGqmTUiNSc9IUaVNpf+lU6RLpI9JXpKdksDJaMm4ybJkCmYMyF2TGKQhFneJC + YVE2UxopFykTVAxVm+pFTaIWU7+jDlBnZWVkl8mGyWbL1sielh2lITQtmhcthVZKO04bpr1borTEaQln + yfYlrUuGlszLLZVzlOPIFcm1yd2WeydPl3eTT5bfJd8p/1ABpaCnEKiQpbBf4aLCzFLqUtulrKVFS48v + vacIK+opBimuVTyo2K84p6Ss5KGUrlSldEFpRpmm7KicpFyufEZ5WoWiYq/CVSlXOavylC5Ld6Kn0Cvp + vfRZVUVVT1Whar3qgOqCmrZaqFq+WpvaQ3WCOkM9Xr1cvUd9VkNFw08jT6NF454mXpOhmai5V7NPc15L + Wytca6tWp9aUtpy2l3audov2Ax2yjoPOGp0GnVu6GF2GbrLuPt0berCehV6iXo3edX1Y31Kfq79Pf9AA + bWBtwDNoMBgxJBk6GWYathiOGdGMfI3yjTqNnhtrGEcZ7zLuM/5oYmGSYtJoct9UxtTbNN+02/R3Mz0z + llmN2S1zsrm7+QbzLvMXy/SXcZbtX3bHgmLhZ7HVosfig6WVJd+y1XLaSsMq1qrWaoRBZQQwShiXrdHW + ztYbrE9Zv7WxtBHYHLf5zdbQNtn2iO3Ucu3lnOWNy8ft1OyYdvV2o/Z0+1j7A/ajDqoOTIcGh8eO6o5s + xybHSSddpySno07PnU2c+c7tzvMuNi7rXM65Iq4erkWuA24ybqFu1W6P3NXcE9xb3Gc9LDzWepzzRHv6 + eO7yHPFS8mJ5NXvNelt5r/Pu9SH5BPtU+zz21fPl+3b7wX7efrv9HqzQXMFb0ekP/L38d/s/DNAOWBPw + YyAmMCCwJvBJkGlQXlBfMCU4JvhI8OsQ55DSkPuhOqHC0J4wybDosOaw+XDX8LLw0QjjiHUR1yIVIrmR + XVHYqLCopqi5lW4r96yciLaILoweXqW9KnvVldUKq1NWn46RjGHGnIhFx4bHHol9z/RnNjDn4rziauNm + WS6svaxnbEd2OXuaY8cp40zG28WXxU8l2CXsTphOdEisSJzhunCruS+SPJPqkuaT/ZMPJX9KCU9pS8Wl + xqae5Mnwknm9acpp2WmD6frphemja2zW7Fkzy/fhN2VAGasyugRU0c9Uv1BHuEU4lmmfWZP5Jiss60S2 + dDYvuz9HL2d7zmSue+63a1FrWWt78lTzNuWNrXNaV78eWh+3vmeD+oaCDRMbPTYe3kTYlLzpp3yT/LL8 + V5vDN3cXKBVsLBjf4rGlpVCikF84stV2a9021DbutoHt5turtn8sYhddLTYprih+X8IqufqN6TeV33za + Eb9joNSydP9OzE7ezuFdDrsOl0mX5ZaN7/bb3VFOLy8qf7UnZs+VimUVdXsJe4V7Ryt9K7uqNKp2Vr2v + Tqy+XeNc01arWLu9dn4fe9/Qfsf9rXVKdcV17w5wD9yp96jvaNBqqDiIOZh58EljWGPft4xvm5sUmoqb + PhziHRo9HHS4t9mqufmI4pHSFrhF2DJ9NProje9cv+tqNWytb6O1FR8Dx4THnn4f+/3wcZ/jPScYJ1p/ + 0Pyhtp3SXtQBdeR0zHYmdo52RXYNnvQ+2dNt293+o9GPh06pnqo5LXu69AzhTMGZT2dzz86dSz83cz7h + /HhPTM/9CxEXbvUG9g5c9Ll4+ZL7pQt9Tn1nL9tdPnXF5srJq4yrndcsr3X0W/S3/2TxU/uA5UDHdavr + XTesb3QPLh88M+QwdP6m681Lt7xuXbu94vbgcOjwnZHokdE77DtTd1PuvriXeW/h/sYH6AdFD6UeVjxS + fNTws+7PbaOWo6fHXMf6Hwc/vj/OGn/2S8Yv7ycKnpCfVEyqTDZPmU2dmnafvvF05dOJZ+nPFmYKf5X+ + tfa5zvMffnP8rX82YnbiBf/Fp99LXsq/PPRq2aueuYC5R69TXy/MF72Rf3P4LeNt37vwd5MLWe+x7ys/ + 6H7o/ujz8cGn1E+f/gUDmPP8usTo0wAAAAlwSFlzAAALEwAACxMBAJqcGAAACNZJREFUWEfFlXlUk1ca + h29nps6oY3EcR63V2qntjEudqQdsxbqvKMcF3EEtalGRg04pKAiIbCIoUlLWsAQB2QmGHQEXVgkoQhJ2 + ENnCHiCQACH85iZqqoV/5nSGuec8J+dc+PJ77vu+3w0B8H9lws3JZMLNyYRUcn1IWa4veZJ6i+QlO5PU + u5Yk2tOE3HE9TcJdD5HYW1tJpKMmYTssI1mO04ibbxyxCJEQY+sEsumPhGyfM4VsVvvPD3LOQy/pMHOv + RCVQmOZGBa4vTww20wm9Zajrd01Pl+WwTzfKddMGKjB1QoEZhGz+03tk5/xp0x0unLS8ZX6I422zpy0z + zhYp4VeQePcKksKt6acVxRoJYdaID7FBSogdjH48CJcCG6lSQFDA/CArzsHm8T2n+qcPmODlheF5TjC4 + nKtI8d4vC7Zdx451WK79wGnqawEpOW8ZR9YQQnZ/+uf3HS6e8q8o9gEv1wG1BYborbXFUNM1jAntIG99 + xWizDYbqzdFfbgK54DvYMHfBPM1ESsoLvKbnpd6MLMvxR09zJsY64gGRF9DrDtRZoCdPD8WBKxBiuawp + 2WbGFne/aHKJ1UdMPcqJ/i59YnvuiHN9mSdKUwwQw9gPWYsdePePg59tCVGt09jgC1vZYN1VDNSYo493 + FqKiQ5Bxt8OKsR5GbAMpyU91sebnsyAf5kFWb4+m2IVIv/4BkhxmoSbiE/lw7j/QnzADXLffI8B6fY+j + f2GNBauz2tSntdqRwamu4V6XV2WdRMC1jWgptUYRRw/NhWfR/fw8uMl70c63GhOVm6JfYAzRsxPoKtgD + ae4GXHZbi2/DD0hJdoJLm7gjH2Pd8RhI/xghplNHjmpvSTI8vNvT7oK2QJSxCn33ZqLejyD00kIwwsvA + yAQ8QovAy7mOumxDeFp8g/ZKFzy5dwosu03oKDqNrqJjeM7ZAH66PtqfmdC94xDm6eBl6jq0Jn4FU+e1 + OBi0Q0oyYpzkGCrBAN8Ug2mz4XZukVh/j9ZiEz1tYnxMN6L9/jdUYDbqfQkiv5+Oqz/lgpnYgOwkO9QV + mIHlvAe8rIsoTDCEn8Vq9NJTZgRsQHrgXkiqTNCWp4XqVC2UxGvjWeQaPA/XgODOEpyz+BLa3mukJD3K + cUwufoL+4hMQZyzEPae/SQ0PbGMY6WzVvXX5yBNx7maI2LQdXr+Bzxk1hMVkgxPrj+5KS3CYBxHjfwGl + j6zga/EV6rKOIC9yFzzMVqMk9SLaig1Rk7ASeT4LkO3xMeJs54BhNBP2+6Zgp95SbGP8U0rig22qu+rY + kJSegij1M7QlLpMXsr6WFwatl7SmbZEOZ69Ey53fgntzCvzMViGLE4hmAQOCh0ZwM9MBy+UMrny3FSnM + QyjmHIGXpSaKYg6g5v46pNxehJM7psNg8/sw3krgsH8xzn97EpuWrA/ZuOWjzHXun8pJaoSTUXGKPVBD + jeM/QhfnQ4w+Xg4UqUOWuwKtkbNR4TUFnKt/gaf5dmRE/oAqrhWuX9iGp7npEPd2QdjUgCimPX66sgnJ + ftoQZB5DqussXNJfiVR2FGqrKlFVzkNJVTvUz3DpPQSydePM2+qnlg+RrBj7eYl+p2ranvwLsqLdaI2Y + g9bouRDGzkdDxFzwfNWQ4TgTwVc0EOttjfxkBtwt9ZF8h6H4IoyNAaPyMYzI5OgS1iLK8zTibmggjXkW + lSXKMNV6W+BrgyO/0zj81z+QLNYxwvbYty/+9q7h9twzGHi4GU0xi/EiZDZKvWci4/o8+F1YiGBnPVTz + uGB6uCA8gKn8wjfhMho+NDIKyZAM1VU14JdXQcAvQ2fvEITdErR0DqKxfRDF5UKVwKrTzkTj8CeEZLIM + SJrPXnLXZoVxuN2aurKIzfLmxNWoCf87in3mws94HuIYBmhuqFCGvlmKQAWy0TH6KafhoxiQjKB3YATd + fcPK8DZluASNHQNoEA4gv7RVJaB+toqoG7i8Ekjx3kfYjsuJz8XFy6Ld94kEEV+AG7IaCe6ayOF4YVDU + gsSsEsTff4qoxCcIZeeoBO5yCt4hOC4H/pEP4RV6H+5BKXDx5cDKLRz1rWI8LG76WeBMIZUoJyQjyIAk + e+uQWPulJNR5D4nyPNXOC12KYtaXtNf0dmvtVDygWrTqytK/EZAOj2JQKkM/PblIPIwuevL2HimEXRI0 + dwyioW0AL2h4bXM/0gteviXAVUJCbh6nHKM/v/ok+OYJEuVxtKM87HMUByyGn40mSp6WYnhIqnhIuWjL + Maos+ysBZfggLT0N7+4bQoeI9v11eKMiXChGXUs/apr6kfC4brxA8I2jKlg39Eik24EO/p3PkPPjfDTd + +xxsDx1kckJ/dQuqqUB0RvV4gSBHXRWBlPCbOh386LXIdPkQ8pT30MRehHCfq8raKyf+rdMrUAxdT79i + 6KSvhq5LMfGKoRMr+64ofXVTH6oa+xCSVDFeIPDaThUBtjvJXWetDn6UJh65zUEJYyqCr2khJy2Mlv5V + +DANldKJfyMgouFdtPTt3VIaLkETDX/ZJlb1veZ1uAJ/Nn+8gL+tlgomJdRpWwc/bAkeuarB12wFfZ/r + IR6Q/OoWKAQ8I8vGCzCv7lThRwl13N5RFrgAGU5qCDBfipQoTzRU8zBCw0ZGZDR0hL7zIyqBLpGEtmAI + nXT4Gtv6Udfch8oGEfh13fTm60SRoB15pULk89pxO6xkvID3tQMqvCiBjnvlD+iPSLzVLAijZyLTZzVi + /W0VD/286DyM0HYoXkExvXx6+keUF09rp5SWfxC1LWJUvuwDr74XJdU94FZ0oYDfCRfWs/ECLmb7Vbia + HSC3zHUcvb9XB9tqNjIdpyE//obyDldQXNEGrkCIgrJWZD9rxoOiRuW7nZRTj/iHtcopv5tSheCECtpv + AbxjeGBElNKTP4dr8DPcCHo6XsD+3PZfsINcOrbFOMx8HnyNFigf+G/zjoDDea13UAj8cFBT7fJRjXzr + I1/EKP75f4FKYKI/TiYTbk4mE25OJhNuTh4g/wb07imJxcC0CgAAAABJRU5ErkJggg== + + + \ No newline at end of file diff --git a/DD_Clipboard_Searcher/frmSplash.vb b/DD_Clipboard_Searcher/frmSplash.vb new file mode 100644 index 0000000..e58d822 --- /dev/null +++ b/DD_Clipboard_Searcher/frmSplash.vb @@ -0,0 +1,122 @@ +Imports System.ComponentModel +Public NotInheritable Class frmSplash + 'TODO: Dieses Formular kann einfach als Begrüßungsbildschirm für die Anwendung festgelegt werden, indem Sie zur Registerkarte "Anwendung" + ' des Projekt-Designers wechseln (Menü "Projekt", Option "Eigenschaften"). + Private InitSteps As Integer = 6 + Private bw As New BackgroundWorker() + Private mainForm As Form + + Private Sub frmSplash_FormClosing(sender As Object, e As FormClosingEventArgs) Handles Me.FormClosing + + End Sub + + Private Sub frmSplash_KeyUp(sender As Object, e As KeyEventArgs) Handles Me.KeyUp + If e.KeyCode = Keys.Escape Then + ESC_Hidden = True + End If + + End Sub + + + Private Sub frmSplash_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load + 'Richten Sie den Dialogtext zur Laufzeit gemäß den Assemblyinformationen der Anwendung ein. + + 'TODO: Die Assemblyinformationen der Anwendung im Bereich "Anwendung" des Dialogfelds für die + ' Projekteigenschaften (im Menü "Projekt") anpassen. + + 'Anwendungstitel + If My.Application.Info.Title <> "" Then + ApplicationTitle.Text = My.Application.Info.Title + Else + 'Wenn der Anwendungstitel fehlt, Anwendungsnamen ohne Erweiterung verwenden + ApplicationTitle.Text = System.IO.Path.GetFileNameWithoutExtension(My.Application.Info.AssemblyName) + End If + + 'Verwenden Sie zum Formatieren der Versionsinformationen den Text, der zur Entwurfszeit in der Versionskontrolle festgelegt wurde, als + ' Formatierungszeichenfolge. Dies ermöglicht ggf. eine effektive Lokalisierung. + ' Build- und Revisionsinformationen können durch Verwendung des folgenden Codes und durch Ändern + ' des Entwurfszeittexts der Versionskontrolle in "Version {0}.{1:00}.{2}.{3}" oder einen ähnlichen Text eingeschlossen werden. Weitere Informationen erhalten Sie unter + ' String.Format() in der Hilfe. + ' + ' Version.Text = System.String.Format(Version.Text, My.Application.Info.Version.Major, My.Application.Info.Version.Minor, My.Application.Info.Version.Build, My.Application.Info.Version.Revision) + + Version.Text = String.Format("Version {0}", My.Application.Info.Version.ToString) + + 'Copyrightinformationen + Copyright.Text = My.Application.Info.Copyright & " " & My.Application.Info.CompanyName + Me.BringToFront() + + InitProgram() + End Sub + + Private Sub InitProgram() + bw.WorkerReportsProgress = True + AddHandler bw.DoWork, AddressOf bw_DoWork + AddHandler bw.ProgressChanged, AddressOf bw_ProgressChanged + AddHandler bw.RunWorkerCompleted, AddressOf bw_RunWorkerCompleted + + ' mainForm = My.Forms.frmMain + + bw.RunWorkerAsync() + End Sub + + Private Function CalcProgress(_step As Integer) + Return _step * (100 / InitSteps) + End Function + + + Private Sub bw_DoWork(sender As Object, e As System.ComponentModel.DoWorkEventArgs) + Try + Dim Init = New ClassInit() + bw.ReportProgress(CalcProgress(1), "Initializing Logger") + Init.InitLogger() + System.Threading.Thread.Sleep(500) + + bw.ReportProgress(CalcProgress(2), "Initializing Database") + Init.InitBasics() + If Init.InitDatabase() = True Then + + System.Threading.Thread.Sleep(500) + + bw.ReportProgress(CalcProgress(4), "Initializing User-Configuration") + If ClassInit.InitUserLogin = False Then + ERROR_INIT = "INVALID USER" + End If + + + System.Threading.Thread.Sleep(500) + + 'bw.ReportProgress(CalcProgress(5), "Initializing Addons") + 'Init.InitAddons() + + 'System.Threading.Thread.Sleep(500) + + bw.ReportProgress(CalcProgress(6), "Initializing Frontend") + ' InitInterface wurde in frmMain integriert + 'Init.InitInterface(mainForm) + + System.Threading.Thread.Sleep(500) + Else + ERROR_INIT = "DATABASE" + End If + Catch ex As Exception + MsgBox("Unexpected Error in bw_DoWork: " & vbNewLine, MsgBoxStyle.Critical) + End Try + End Sub + + Private Sub bw_ProgressChanged(sender As Object, e As System.ComponentModel.ProgressChangedEventArgs) + pbStatus.Value = e.ProgressPercentage + lblStatus.Text = e.UserState.ToString() + End Sub + + Private Sub bw_RunWorkerCompleted(sender As Object, e As System.ComponentModel.RunWorkerCompletedEventArgs) + ' Bei Fehler MsgBox anzeigen und Programm beenden + If e.Error IsNot Nothing Then + MsgBox(e.Error.Message, MsgBoxStyle.Critical, "Unexpected Error in frmSplash") + Application.Exit() + End If + + ' Wenn kein Fehler, Splashscreen schließen + Me.Close() + End Sub +End Class diff --git a/DD_Clipboard_Searcher/modCurrent.vb b/DD_Clipboard_Searcher/modCurrent.vb new file mode 100644 index 0000000..6d39acc --- /dev/null +++ b/DD_Clipboard_Searcher/modCurrent.vb @@ -0,0 +1,37 @@ +Module modCurrent + + Public MyConnectionString As String = "" + Public LogErrorsOnly As Boolean = True + Public USER_LANGUAGE As String = "de-DE" + + Public CURRENT_WINDOW_NAME As String + + Public CURRENT_USER_SHORT As String + Public USER_USERNAME As String + Public USER_GUID As Integer + Public USER_IS_ADMIN As Boolean = False + + Public USERS_LOGGED_IN As Integer + + Public LICENSE_COUNT As Integer + Public LICENSE_DATE As Date + Public LICENSE_EXPIRED As Boolean = False + + Public DT_CLIENT_USER As DataTable + Public ERROR_INIT As String + Public START_INCOMPLETE As Boolean = False + Public CONNECTION_CHANGED As Boolean = False + Public ESC_Hidden As Boolean = False + + Public CURRENT_WD_TEMPSEARCH As String + Public TEMP_FILES As List(Of String) = New List(Of String) + + Public WD_UNICODE As Boolean = False + + Public DT_USER_PROFILES As DataTable + + Public CLIPBOARD_TEXT As String + Public CURR_MATCH_RESULT + + Public MONITORING_ACTIVE As Boolean = True +End Module diff --git a/DD_Clipboard_Searcher/modMySettings.vb b/DD_Clipboard_Searcher/modMySettings.vb new file mode 100644 index 0000000..8648ad5 --- /dev/null +++ b/DD_Clipboard_Searcher/modMySettings.vb @@ -0,0 +1,115 @@ +Imports System.IO +Imports DD_LIB_Standards +Module modMySettings + Dim ConfigPath As String = Path.Combine(Application.UserAppDataPath(), "UserConfig.xml") + + Public Function LoadMyConfig() + Dim rowresult As String = "" + Try + Dim DT As DataTable + 'if file doesn't exist, create the file with its default xml table + If Not File.Exists(ConfigPath) Then + DT = CreateConfigTable() + DT.WriteXml(ConfigPath) + End If + DT = GetTablefromXML() + For Each Row As DataRow In DT.Rows + rowresult &= Row.Item("ConfigName") + Select Row.Item("ConfigName") + Case "MyConnectionString" + Dim connstring As String + 'Den ConnectonString mit verschlüsseltem PW laden + Dim csb As New SqlClient.SqlConnectionStringBuilder + csb.ConnectionString = Row.Item("Value") + If csb.ConnectionString.Contains("Password=") Then + 'SA-Auth + 'Jetzt das Passwort entschlüsseln + Dim PWplainText As String + Dim wrapper As New clsEncryption("!35452didalog=") + ' DecryptData throws if the wrong password is used. + Try + PWplainText = wrapper.DecryptData(csb.Password) + Catch ex As Exception + clsLogger.Add("- the Password '" & csb.Password & "' could not be decrypted", False) + PWplainText = csb.Password + End Try + connstring = Row.Item("Value").ToString.Replace(csb.Password, PWplainText) + Else + 'Win-Auth + connstring = Row.Item("Value").ToString + End If + MyConnectionString = connstring + Case "LogErrorsOnly" + LogErrorsOnly = CBool(Row.Item("Value")) + End Select + Next + Return True + Catch ex As Exception + MsgBox("Error in MySettings-LoadMyConfig" & vbNewLine & ex.Message, MsgBoxStyle.Critical) + Return False + End Try + End Function + Private Function GetTablefromXML() + Try + Dim DS As New DataSet + DS.ReadXml(ConfigPath) + Return DS.Tables(0) + Catch ex As Exception + MsgBox("Error in GetTablefromXML" & vbNewLine & ex.Message, MsgBoxStyle.Critical) + Return Nothing + End Try + + End Function + Private Function CreateConfigTable() As DataTable + Try + ' Create sample Customers table, in order + ' to demonstrate the behavior of the DataTableReader. + Dim table As New DataTable + table.TableName = "MyConfig" + + ' Create two columns, ID and Name. + Dim idColumn As DataColumn = table.Columns.Add("ID", _ + GetType(System.Int32)) + + idColumn.AutoIncrement = True + idColumn.AutoIncrementSeed = 0 + idColumn.AutoIncrementStep = 1 + table.Columns.Add("ConfigName", GetType(System.String)) + table.Columns.Add("Value", GetType(System.String)) + 'Set the ID column as the primary key column. + table.PrimaryKey = New DataColumn() {idColumn} + Dim newRow As DataRow = table.NewRow() + newRow("ConfigName") = "MyConnectionString" + newRow("Value") = "" + table.Rows.Add(newRow) + Dim newRow1 As DataRow = table.NewRow() + newRow1("ConfigName") = "LogErrorsOnly" + newRow1("Value") = "True" + table.Rows.Add(newRow1) + table.AcceptChanges() + Return table + Catch ex As Exception + MsgBox("Error in CreateConfigTable" & vbNewLine & ex.Message, MsgBoxStyle.Critical) + Return Nothing + End Try + End Function + Public Function SaveConfigValue(name As String, value As String) + Try + Dim DT As DataTable + DT = GetTablefromXML() + + For Each Row As DataRow In DT.Rows + If Row.Item("ConfigName") = name Then + Row.Item("Value") = value + End If + Next + DT.AcceptChanges() + DT.WriteXml(ConfigPath) + Catch ex As Exception + MsgBox("Error in SaveConfigValue" & vbNewLine & ex.Message, MsgBoxStyle.Critical) + Return False + End Try + Return True + + End Function +End Module diff --git a/DD_Clipboard_Searcher/obj/Debug/DD_Clipboard_Searcher.Resources.resources b/DD_Clipboard_Searcher/obj/Debug/DD_Clipboard_Searcher.Resources.resources new file mode 100644 index 0000000..58b8699 Binary files /dev/null and b/DD_Clipboard_Searcher/obj/Debug/DD_Clipboard_Searcher.Resources.resources differ diff --git a/DD_Clipboard_Searcher/obj/Debug/DD_Clipboard_Searcher.frmConfig_Basic.resources b/DD_Clipboard_Searcher/obj/Debug/DD_Clipboard_Searcher.frmConfig_Basic.resources new file mode 100644 index 0000000..f6df16a Binary files /dev/null and b/DD_Clipboard_Searcher/obj/Debug/DD_Clipboard_Searcher.frmConfig_Basic.resources differ diff --git a/DD_Clipboard_Searcher/obj/Debug/DD_Clipboard_Searcher.frmLicense.resources b/DD_Clipboard_Searcher/obj/Debug/DD_Clipboard_Searcher.frmLicense.resources new file mode 100644 index 0000000..965ce2a Binary files /dev/null and b/DD_Clipboard_Searcher/obj/Debug/DD_Clipboard_Searcher.frmLicense.resources differ diff --git a/DD_Clipboard_Searcher/obj/Debug/DD_Clipboard_Searcher.frmMain.resources b/DD_Clipboard_Searcher/obj/Debug/DD_Clipboard_Searcher.frmMain.resources new file mode 100644 index 0000000..a2eb9ef Binary files /dev/null and b/DD_Clipboard_Searcher/obj/Debug/DD_Clipboard_Searcher.frmMain.resources differ diff --git a/DD_Clipboard_Searcher/obj/Debug/DD_Clipboard_Searcher.frmSplash.resources b/DD_Clipboard_Searcher/obj/Debug/DD_Clipboard_Searcher.frmSplash.resources new file mode 100644 index 0000000..a22f53f Binary files /dev/null and b/DD_Clipboard_Searcher/obj/Debug/DD_Clipboard_Searcher.frmSplash.resources differ diff --git a/DD_Clipboard_Searcher/obj/Debug/DD_Clipboard_Searcher.pdb b/DD_Clipboard_Searcher/obj/Debug/DD_Clipboard_Searcher.pdb new file mode 100644 index 0000000..fd1637e Binary files /dev/null and b/DD_Clipboard_Searcher/obj/Debug/DD_Clipboard_Searcher.pdb differ diff --git a/DD_Clipboard_Searcher/obj/Debug/DD_Clipboard_Searcher.vbproj.FileListAbsolute.txt b/DD_Clipboard_Searcher/obj/Debug/DD_Clipboard_Searcher.vbproj.FileListAbsolute.txt new file mode 100644 index 0000000..2c05b2f --- /dev/null +++ b/DD_Clipboard_Searcher/obj/Debug/DD_Clipboard_Searcher.vbproj.FileListAbsolute.txt @@ -0,0 +1,20 @@ +E:\SchreiberM\Visual Studio\GIT\DD_Clipboard_Searcher\DD_Clipboard_Searcher\bin\Debug\DD_Clipboard_Searcher.exe.config +E:\SchreiberM\Visual Studio\GIT\DD_Clipboard_Searcher\DD_Clipboard_Searcher\bin\Debug\DD_Clipboard_Searcher.exe +E:\SchreiberM\Visual Studio\GIT\DD_Clipboard_Searcher\DD_Clipboard_Searcher\bin\Debug\DD_Clipboard_Searcher.pdb +E:\SchreiberM\Visual Studio\GIT\DD_Clipboard_Searcher\DD_Clipboard_Searcher\bin\Debug\DD_Clipboard_Searcher.xml +E:\SchreiberM\Visual Studio\GIT\DD_Clipboard_Searcher\DD_Clipboard_Searcher\obj\Debug\DD_Clipboard_Searcher.Resources.resources +E:\SchreiberM\Visual Studio\GIT\DD_Clipboard_Searcher\DD_Clipboard_Searcher\obj\Debug\DD_Clipboard_Searcher.vbproj.GenerateResource.Cache +E:\SchreiberM\Visual Studio\GIT\DD_Clipboard_Searcher\DD_Clipboard_Searcher\obj\Debug\DD_Clipboard_Searcher.exe +E:\SchreiberM\Visual Studio\GIT\DD_Clipboard_Searcher\DD_Clipboard_Searcher\obj\Debug\DD_Clipboard_Searcher.xml +E:\SchreiberM\Visual Studio\GIT\DD_Clipboard_Searcher\DD_Clipboard_Searcher\obj\Debug\DD_Clipboard_Searcher.pdb +E:\SchreiberM\Visual Studio\GIT\DD_Clipboard_Searcher\DD_Clipboard_Searcher\bin\Debug\DD_LIB_Standards.dll +E:\SchreiberM\Visual Studio\GIT\DD_Clipboard_Searcher\DD_Clipboard_Searcher\bin\Debug\DD_LIB_Standards.pdb +E:\SchreiberM\Visual Studio\GIT\DD_Clipboard_Searcher\DD_Clipboard_Searcher\bin\Debug\DD_LIB_Standards.xml +E:\SchreiberM\Visual Studio\GIT\DD_Clipboard_Searcher\DD_Clipboard_Searcher\obj\Debug\DD_Clipboard_Searcher.vbprojResolveAssemblyReference.cache +E:\SchreiberM\Visual Studio\GIT\DD_Clipboard_Searcher\DD_Clipboard_Searcher\obj\Debug\DD_Clipboard_Searcher.frmMain.resources +E:\SchreiberM\Visual Studio\GIT\DD_Clipboard_Searcher\DD_Clipboard_Searcher\obj\Debug\DD_Clipboard_Searcher.frmConfig_Basic.resources +E:\SchreiberM\Visual Studio\GIT\DD_Clipboard_Searcher\DD_Clipboard_Searcher\obj\Debug\DD_Clipboard_Searcher.frmSplash.resources +E:\SchreiberM\Visual Studio\GIT\DD_Clipboard_Searcher\DD_Clipboard_Searcher\obj\Debug\DD_Clipboard_Searcher.frmLicense.resources +E:\SchreiberM\Visual Studio\GIT\DDClipboardSearcher\DD_Clipboard_Searcher\bin\Debug\DD_Clipboard_Searcher.exe.config +E:\SchreiberM\Visual Studio\GIT\DDClipboardSearcher\DD_Clipboard_Searcher\obj\Debug\DD_Clipboard_Searcher.xml +E:\SchreiberM\Visual Studio\GIT\DDClipboardSearcher\DD_Clipboard_Searcher\obj\Debug\DD_Clipboard_Searcher.pdb diff --git a/DD_Clipboard_Searcher/obj/Debug/DD_Clipboard_Searcher.vbproj.GenerateResource.Cache b/DD_Clipboard_Searcher/obj/Debug/DD_Clipboard_Searcher.vbproj.GenerateResource.Cache new file mode 100644 index 0000000..11949ab Binary files /dev/null and b/DD_Clipboard_Searcher/obj/Debug/DD_Clipboard_Searcher.vbproj.GenerateResource.Cache differ diff --git a/DD_Clipboard_Searcher/obj/Debug/DD_Clipboard_Searcher.vbprojResolveAssemblyReference.cache b/DD_Clipboard_Searcher/obj/Debug/DD_Clipboard_Searcher.vbprojResolveAssemblyReference.cache new file mode 100644 index 0000000..d7a3502 Binary files /dev/null and b/DD_Clipboard_Searcher/obj/Debug/DD_Clipboard_Searcher.vbprojResolveAssemblyReference.cache differ diff --git a/DD_Clipboard_Searcher/obj/Debug/DD_Clipboard_Searcher.xml b/DD_Clipboard_Searcher/obj/Debug/DD_Clipboard_Searcher.xml new file mode 100644 index 0000000..8e9dee8 --- /dev/null +++ b/DD_Clipboard_Searcher/obj/Debug/DD_Clipboard_Searcher.xml @@ -0,0 +1,66 @@ + + + + +DD_Clipboard_Searcher + + + + + + Get all top-level window information + + List of window information objects + + + Get all child windows for the specific windows handle (hwnd). + + List of child windows for parent window + + + Callback function that does the work of enumerating top-level windows. + + Discovered Window handle + 1=keep going, 0=stop + + + Callback function that does the work of enumerating child windows. + + Discovered Window handle + 1=keep going, 0=stop + + + Build the ApiWindow object to hold information about the Window object. + + + + Gibt die zwischengespeicherte ResourceManager-Instanz zurück, die von dieser Klasse verwendet wird. + + + + Überschreibt die CurrentUICulture-Eigenschaft des aktuellen Threads für alle + Ressourcenzuordnungen, die diese stark typisierte Ressourcenklasse verwenden. + + + + Sucht eine lokalisierte Ressource vom Typ System.Drawing.Bitmap. + + + + Sucht eine lokalisierte Ressource vom Typ System.Drawing.Bitmap. + + + + Sucht eine lokalisierte Ressource vom Typ System.Drawing.Bitmap. + + + + Sucht eine lokalisierte Ressource vom Typ System.Drawing.Bitmap. + + + + Eine stark typisierte Ressourcenklasse zum Suchen von lokalisierten Zeichenfolgen usw. + + + + \ No newline at end of file diff --git a/DD_Clipboard_Searcher/obj/Debug/DesignTimeResolveAssemblyReferences.cache b/DD_Clipboard_Searcher/obj/Debug/DesignTimeResolveAssemblyReferences.cache new file mode 100644 index 0000000..bf99b8b Binary files /dev/null and b/DD_Clipboard_Searcher/obj/Debug/DesignTimeResolveAssemblyReferences.cache differ diff --git a/DD_Clipboard_Searcher/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache b/DD_Clipboard_Searcher/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache new file mode 100644 index 0000000..9ca9f69 Binary files /dev/null and b/DD_Clipboard_Searcher/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache differ diff --git a/DD_Clipboard_Searcher/obj/Debug/TempPE/My Project.Resources.Designer.vb.dll b/DD_Clipboard_Searcher/obj/Debug/TempPE/My Project.Resources.Designer.vb.dll new file mode 100644 index 0000000..a5db550 Binary files /dev/null and b/DD_Clipboard_Searcher/obj/Debug/TempPE/My Project.Resources.Designer.vb.dll differ