diff --git a/.github/workflows/b2s-backglass.yml b/.github/workflows/b2s-backglass.yml index fec3c38..77218eb 100644 --- a/.github/workflows/b2s-backglass.yml +++ b/.github/workflows/b2s-backglass.yml @@ -19,8 +19,8 @@ jobs: - platform: x86 config: Release steps: - - uses: actions/checkout@v3 - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 + - uses: actions/checkout@v4 with: repository: DirectOutput/B2SServerPluginInterface path: B2SServerPluginInterface @@ -53,7 +53,7 @@ jobs: VERSION=$(grep -Eo "AssemblyVersion\(.*\)" "${ASSEMBLY_INFO}" | grep -Eo "[0-9\.]+" | tail -1) TAG="${VERSION}-${SHA7}" perl -i -pe"s/AssemblyInformationalVersion\(\".*\"\)/AssemblyInformationalVersion\(\"${TAG}\"\)/g" "${ASSEMBLY_INFO}" - - uses: microsoft/setup-msbuild@v1.3 + - uses: microsoft/setup-msbuild@v2 - name: Build B2SServerPluginInterface run: | msbuild B2SServerPluginInterface/B2SServerPluginInterface.sln /t:Rebuild /p:Configuration=${{ matrix.config }} @@ -101,58 +101,7 @@ jobs: cp -r ScreenResTemplates tmp cp -r B2STools tmp cp b2sbackglassserverregisterapp/ScreenResTemplates.cmd tmp - - uses: actions/upload-artifact@v3 + - uses: actions/upload-artifact@v4 with: name: B2SServer-${{ steps.version.outputs.tag }}-${{ matrix.config }}-win-${{ matrix.platform }} path: tmp - - build-betterled: - if: ${{ false }} # disable for now - name: Build BetterLed # -${{ matrix.config }}-win-${{ matrix.platform }} - runs-on: windows-2019 - strategy: - fail-fast: false - matrix: - include: - - platform: x86 - config: Debug - - platform: x86 - config: Release - - platform: x64 - config: Debug - - platform: x64 - config: Release - steps: - - uses: actions/checkout@v3 - - id: version - name: Update AssemblyInformationalVersion - run: | - SHA7="${GITHUB_SHA::7}" - ASSEMBLY_INFO="leds/dream7segments/My Project/AssemblyInfo.vb" - VERSION=$(grep -Eo "AssemblyVersion\(.*\)" "${ASSEMBLY_INFO}" | grep -Eo "[0-9\.]+" | tail -1) - TAG="${VERSION}-${SHA7}" - perl -i -pe"s/AssemblyInformationalVersion\(\".*\"\)/AssemblyInformationalVersion\(\"${TAG}\"\)/g" "${ASSEMBLY_INFO}" - ASSEMBLY_INFO="leds/BetterLed/My Project/AssemblyInfo.vb" - VERSION=$(grep -Eo "AssemblyVersion\(.*\)" "${ASSEMBLY_INFO}" | grep -Eo "[0-9\.]+" | tail -1) - TAG="${VERSION}-${SHA7}" - perl -i -pe"s/AssemblyInformationalVersion\(\".*\"\)/AssemblyInformationalVersion\(\"${TAG}\"\)/g" "${ASSEMBLY_INFO}" - echo "tag=${TAG}" >> $GITHUB_OUTPUT - - uses: microsoft/setup-msbuild@v1.1 - - name: Build - run: | - msbuild leds/BetterLed/BetterLed.sln /t:Rebuild /p:Configuration=${{ matrix.config }} /p:Platform=${{ matrix.platform }} - shell: cmd - - name: Bundle - run: | - mkdir tmp - cp leds/BetterLed/bin/${{ matrix.platform }}/${{ matrix.config }}/BetterLed.exe tmp - cp leds/BetterLed/bin/${{ matrix.platform }}/${{ matrix.config }}/Dream7Display.dll tmp - if [[ "${{ matrix.config }}" == "Debug" ]]; then - cp leds/BetterLed/bin/${{ matrix.platform }}/${{ matrix.config }}/BetterLed.pdb tmp - cp leds/BetterLed/bin/${{ matrix.platform }}/${{ matrix.config }}/Dream7Display.pdb tmp - fi - cp license.txt tmp - - uses: actions/upload-artifact@v3 - with: - name: BetterLed-${{ steps.version.outputs.tag }}-${{ matrix.config }}-win-${{ matrix.platform }} - path: tmp diff --git a/b2s_screenresidentifier/b2s_screenresidentifier/My Project/AssemblyInfo.vb b/b2s_screenresidentifier/b2s_screenresidentifier/My Project/AssemblyInfo.vb index 204d375..c39fed9 100644 --- a/b2s_screenresidentifier/b2s_screenresidentifier/My Project/AssemblyInfo.vb +++ b/b2s_screenresidentifier/b2s_screenresidentifier/My Project/AssemblyInfo.vb @@ -2,33 +2,33 @@ 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. +' General Information about an assembly is controlled through the following +' set of attributes. Change these attribute values to modify the information +' associated with an assembly. -' Die Werte der Assemblyattribute überprüfen +' Review the values of the assembly attributes - - + + -'Die folgende GUID bestimmt die ID der Typbibliothek, wenn dieses Projekt für COM verfügbar gemacht wird +'The following GUID is for the ID of the typelib if this project is exposed to COM -' Versionsinformationen für eine Assembly bestehen aus den folgenden vier Werten: +' Version information for an assembly consists of the following four values: ' -' Hauptversion -' Nebenversion -' Buildnummer +' Major Version +' Minor Version +' Build Number ' Revision ' -' Sie können alle Werte angeben oder die standardmäßigen Build- und Revisionsnummern -' übernehmen, indem Sie "*" eingeben: +' You can specify all the values or you can default the Build and Revision Numbers +' by using the '*' as shown below: ' diff --git a/b2sbackglassserver/b2sbackglassserver/B2SBackglassServer.vbproj b/b2sbackglassserver/b2sbackglassserver/B2SBackglassServer.vbproj index ca0ed5d..95be463 100644 --- a/b2sbackglassserver/b2sbackglassserver/B2SBackglassServer.vbproj +++ b/b2sbackglassserver/b2sbackglassserver/B2SBackglassServer.vbproj @@ -116,6 +116,12 @@ + + Background.vb + + + Form + formBackglass.vb @@ -177,6 +183,9 @@ + + Background.vb + formBackglass.vb Designer diff --git a/b2sbackglassserver/b2sbackglassserver/Classes/B2SData.vb b/b2sbackglassserver/b2sbackglassserver/Classes/B2SData.vb index 29f1b71..1d976a5 100644 --- a/b2sbackglassserver/b2sbackglassserver/Classes/B2SData.vb +++ b/b2sbackglassserver/b2sbackglassserver/Classes/B2SData.vb @@ -443,6 +443,18 @@ Public Class B2SData End Get End Property + Private Shared _ScoreMaxDigit As Integer = 0 + Public Shared Property ScoreMaxDigit() As Integer + Get + Return _ScoreMaxDigit + End Get + Set(value As Integer) + If _ScoreMaxDigit < value Then + _ScoreMaxDigit = value + End If + End Set + End Property + Public Shared Property Players() As B2SPlayer = New B2SPlayer() Public Shared Property IsAPlayerAdded() As Boolean = False diff --git a/b2sbackglassserver/b2sbackglassserver/Classes/B2SScreen.vb b/b2sbackglassserver/b2sbackglassserver/Classes/B2SScreen.vb index 0b2de49..79e7077 100644 --- a/b2sbackglassserver/b2sbackglassserver/Classes/B2SScreen.vb +++ b/b2sbackglassserver/b2sbackglassserver/Classes/B2SScreen.vb @@ -4,6 +4,7 @@ Imports System.Drawing Imports Microsoft.Win32 Imports System.IO Imports System.Reflection +Imports System.Text.RegularExpressions Public Class B2SScreen @@ -12,6 +13,8 @@ Public Class B2SScreen Public Shared formBackglass As formBackglass = Nothing Public formDMD As formDMD = Nothing + Public formbackground As Background = Nothing + Public debugLog As Log = New Log("B2SDebugLog") Public Enum eDMDViewMode NotDefined = 0 @@ -23,6 +26,7 @@ Public Class B2SScreen Public Property PlayfieldSize() As Size = New Size(0, 0) Public Property BackglassMonitor() As String = String.Empty + Public Property BackglassScreen() As Screen = Nothing Public Property BackglassSize() As Size = New Size(0, 0) Public Property BackglassLocation() As Point = New Point(0, 0) Public Property BackglassGrillHeight() As Integer = 0 @@ -40,12 +44,14 @@ Public Class B2SScreen Public Property BackglassCutOff() As Rectangle = Nothing Public Property IsDMDToBeShown() As Boolean = False + Public Property StartBackground() As Boolean = False #Region "constructor and startup" Public Sub New() - Server.errorlog.WriteLogEntry("B2SScreen.New") + debugLog.IsLogOn = B2SSettings.B2SDebugLog + debugLog.WriteLogEntry("B2SScreen.New") @@ -79,6 +85,9 @@ Public Class B2SScreen formBackglass = _formBackglass Me.formDMD = _formDMD + Me.formbackground = New Background + + ' get all backglass settings GetB2SSettings(_DefaultDMDLocation, _DMDViewMode, _BackglassGrillHeight, _BackglassSmallGrillHeight) @@ -140,7 +149,7 @@ Public Class B2SScreen Loop ' close file handle FileClose(1) - + Server.errorlog.WriteLogEntry("B2SScreen.ReadB2SSettingsFromFile A version #2 file " & Me.BackgroundPath) line(i) = 0 line(i + 1) = 0 Me.PlayfieldSize = New Size(CInt(line(0)), CInt(line(1))) @@ -155,6 +164,11 @@ Public Class B2SScreen Me.BackgroundLocation = New Point(CInt(line(12)), CInt(line(13))) Me.BackgroundSize = New Size(CInt(line(14)), CInt(line(15))) Me.BackgroundPath = line(16) + If Me.BackgroundPath.Contains("{") Then + ' We will try to replace the placeholders with the real values + Me.BackgroundPath = GetBackgroundPath(Me.BackgroundPath, B2SData.TableFileName, B2SSettings.GameName) + debugLog.WriteLogEntry("B2SScreen.ReadB2SSettingsFromFile GetBackgroundPath called and returned " & Me.BackgroundPath) + End If Else Me.BackgroundLocation = New Point(0, 0) Me.BackgroundSize = New Size(0, 0) @@ -171,6 +185,54 @@ Public Class B2SScreen End If End Sub + Private Function GetBackgroundPath(BackgroundPath As String, ByVal TableFileName As String, ByVal GameName As String) As String + Dim pattern As String = "^(?'name'[\w \-\!']+)(\((?'manufactor'[A-Za-z ]+)? (?'year'[\d{4}]+)\))?(?'extra'.*)?$" + Dim regex As New Regex(pattern) + Dim replacedSomething As Boolean = False + + Dim newPath As String = BackgroundPath + + Dim allGroupNames As List(Of String) = New List(Of String) From {"tablename", "gamename"} + + allGroupNames.AddRange(regex.GetGroupNames()) + allGroupNames.RemoveAll(Function(s) s.Length = 1) + + If regex.IsMatch(TableFileName) Then + For Each groupName As String In allGroupNames + For Each replaceName As String In allGroupNames + If groupName = replaceName And newPath.Contains("{" + replaceName + "}") Then + Select Case replaceName + Case "tablename" + newPath = newPath.Replace("{" + replaceName + "}", TableFileName) + replacedSomething = True + Case "gamename" + newPath = newPath.Replace("{" + replaceName + "}", GameName) + replacedSomething = True + Case Else + Dim replaceValue As String = regex.Match(TableFileName).Groups(replaceName).Value.Trim() + If Not String.IsNullOrEmpty(replaceValue) Then + replacedSomething = True + newPath = newPath.Replace("{" + replaceName + "}", replaceValue) + End If + End Select + Else + newPath = newPath.Replace("{" + replaceName + "}", "") + End If + Next + If File.Exists(newPath) And replacedSomething Then + Return newPath + Else + newPath = BackgroundPath + replacedSomething = False + End If + Next + End If + For Each replaceName As String In allGroupNames + newPath = newPath.Replace("{" + replaceName + "}", "") + Next + Return newPath + + End Function Private Sub GetB2SSettings(ByVal _DefaultDMDLocation As Point, ByVal _DMDViewMode As eDMDViewMode, ByVal _BackglassGrillHeight As Integer, ByVal _BackglassSmallGrillHeight As Integer) @@ -292,6 +354,10 @@ Public Class B2SScreen 'searchPathLog.WriteLogEntry("Start Show") 'On Error Resume Next + If (Not Me.BackgroundSize.IsEmpty) And ((B2SSettings.StartBackground.HasValue And B2SSettings.StartBackground) Or + (Not B2SSettings.StartBackground.HasValue And B2SSettings.GlobalStartBackground.HasValue And B2SSettings.GlobalStartBackground)) Then + StartBackground = True + End If ' first of all get the info whether the DMD is to be shown or not IsDMDToBeShown = (Me.formDMD IsNot Nothing AndAlso Not Point.Empty.Equals(Me.DMDLocation) AndAlso @@ -302,7 +368,7 @@ Public Class B2SScreen On Error Resume Next ' get the correct screen - Dim screen As Screen = ScreensOrdered(0) + Me.BackglassScreen = ScreensOrdered(0) Dim s As Screen Dim currentScreen = 0 @@ -312,25 +378,64 @@ Public Class B2SScreen 'searchPathLog.WriteLogEntry("Screen: " & (s.DeviceName) & " Location " & s.Bounds.Location.X & " #" & currentScreen) If Left(BackglassMonitor, 1) = "@" Then If s.Bounds.Location.X = CInt(Mid(BackglassMonitor, 2)) Then - screen = s + Me.BackglassScreen = s 'searchPathLog.WriteLogEntry("Found: @" & (s.Bounds.Location.X)) Exit For End If ElseIf Left(BackglassMonitor, 1) = "=" Then If currentScreen = CInt(Mid(BackglassMonitor, 2)) Then - screen = s + Me.BackglassScreen = s 'searchPathLog.WriteLogEntry("Found: =" & currentScreen) Exit For End If ElseIf s.DeviceName = "\\.\DISPLAY" + BackglassMonitor Then 'searchPathLog.WriteLogEntry("Found: " & (s.DeviceName)) - screen = s + Me.BackglassScreen = s Exit For End If Next - On Error GoTo 0 + + ' Westworld show background form, only if background is set and enabled in setting + Dim DMDKeepBackglassLocation = Me.BackglassLocation + If StartBackground Then + If Not VersionTwoFile Then + Dim swapSize = Me.BackgroundSize + Dim swapLocation = Me.BackgroundLocation + Me.BackgroundSize = Me.BackglassSize + Me.BackglassSize = swapSize + Me.BackgroundLocation = Me.BackglassLocation + Me.BackglassLocation = swapLocation + End If + + Me.formbackground.StartPosition = FormStartPosition.Manual + Me.formbackground.BackgroundImageLayout = ImageLayout.Stretch + Me.formbackground.FormBorderStyle = FormBorderStyle.None + Me.formbackground.ControlBox = False + Me.formbackground.MaximizeBox = False + Me.formbackground.MinimizeBox = False + Me.formbackground.Location = Me.BackglassScreen.Bounds.Location + Me.BackgroundLocation + Me.formbackground.Size = Me.BackgroundSize + Me.formbackground.Text = "B2S Backglass Server" + Me.formbackground.BackColor = Color.Black + If (IO.File.Exists(Me.BackgroundPath)) Then + Me.formbackground.BackgroundImage = Image.FromFile(Me.BackgroundPath) ' ("C:\backglass.png") + End If + Me.formbackground.Show() + If Not B2SSettings.PureEXE Then + If B2SSettings.FormToBack Then + Me.formbackground.SendToBack() + Me.formbackground.ShowInTaskbar = False + ElseIf B2SSettings.FormToFront Then + Me.formbackground.BringToFront() + Me.formbackground.TopMost = True + If B2SSettings.FormNoFocus Then Me.formbackground.ShowInTaskbar = False + Else + Me.formbackground.BringToFront() + End If + End If + End If ' set forms to background image size If formBackglass IsNot Nothing AndAlso formBackglass.BackgroundImage IsNot Nothing Then formBackglass.Size = formBackglass.BackgroundImage.Size @@ -378,14 +483,34 @@ Public Class B2SScreen formBackglass.ControlBox = False formBackglass.MaximizeBox = False formBackglass.MinimizeBox = False - formBackglass.Location = screen.Bounds.Location + Me.BackglassLocation + formBackglass.Location = Me.BackglassScreen.Bounds.Location + Me.BackglassLocation formBackglass.Size = Me.BackglassSize + + If Not B2SSettings.PureEXE Then + If B2SSettings.FormToFront Then + ' bring backglass screen to the front and force it to stay + formBackglass.TopMost = True + formBackglass.BringToFront() + If B2SSettings.FormNoFocus Then formBackglass.ShowInTaskbar = False + ElseIf B2SSettings.FormToBack Then + ' bring backglass screen to the back and force it to stay + formBackglass.SendToBack() + formBackglass.ShowInTaskbar = False + Else + formBackglass.BringToFront() + End If + End If + + If StartBackground Then + formBackglass.Text = "B2S Backglass" + formBackglass.ShowInTaskbar = False + + formBackglass.Show(Me.formbackground) + Else + ' Without background picture the backglass is the main form formBackglass.Text = "B2S Backglass Server" formBackglass.Show() - - ' bring backglass screen to the front - If B2SSettings.FormToFront Then formBackglass.TopMost = True - formBackglass.BringToFront() + End If ' maybe show DMD form If IsDMDToBeShown Then @@ -399,10 +524,30 @@ Public Class B2SScreen Me.formDMD.Location = formBackglass.Location + Me.DMDLocation Me.formDMD.Size = Me.DMDSize Me.formDMD.Text = "B2S DMD" - ' show the DMD form + + If B2SSettings.FormToFront Then + If B2SSettings.FormNoFocus Then Me.formDMD.ShowInTaskbar = False + + Me.formDMD.BringToFront() + Me.formDMD.TopMost = True + + If Me.DMDAtDefaultLocation Then + ' DMD and Back Glass one unit, make sure they stay together + Me.formDMD.Show(formBackglass) + Else + ' DMD and Back Glass separate and accessed separately Me.formDMD.Show() + End If + ElseIf B2SSettings.FormToBack Then + ' DMD and Back Glass one unit, make sure they are together and also make sure it is impossible to activate + Me.formDMD.ShowInTaskbar = False + Me.formDMD.SendToBack() + Me.formDMD.Show(formBackglass) + Else + ' show the DMD form without grill Me.formDMD.BringToFront() - Me.formDMD.TopMost = True + Me.formDMD.Show() + End If End If End Sub diff --git a/b2sbackglassserver/b2sbackglassserver/Classes/B2SSettings.vb b/b2sbackglassserver/b2sbackglassserver/Classes/B2SSettings.vb index 5af142b..9bd80e6 100644 --- a/b2sbackglassserver/b2sbackglassserver/Classes/B2SSettings.vb +++ b/b2sbackglassserver/b2sbackglassserver/Classes/B2SSettings.vb @@ -2,6 +2,7 @@ Imports System.IO Imports System.Reflection Imports System.Windows.Forms +Imports System.Xml Imports Microsoft.Win32 Public Class B2SSettings @@ -93,6 +94,7 @@ Public Class B2SSettings End Property Public Shared Property IsPaintingLogOn() As Boolean = True Public Shared Property IsStatisticsBackglassOn() As Boolean = True + Public Shared Property IsBackglassSearchLogOn As Boolean = False Public Shared Property ShowStartupError() As Boolean = False ' set to True to display errors @@ -150,6 +152,7 @@ Public Class B2SSettings End Property Public Shared Property LEDsOff() As Boolean = False Public Shared Property StartAsEXE() As Boolean = True + Public Shared Property PureEXE() As Boolean = False Public Shared Property DefaultStartMode() As eDefaultStartMode = eDefaultStartMode.EXE Public Shared Property DisableFuzzyMatching() As Boolean = True @@ -163,6 +166,7 @@ Public Class B2SSettings Public Shared Property IsGlowBulbOn() As Boolean = False Public Shared Property GlowIndex() As Integer = -1 Public Shared Property DefaultGlow() As Integer = -1 + Public Shared Property DisableBuiltInEMReelSound() As Nullable(Of Boolean) = Nothing Public Shared Property FormToFront() As Boolean = True Public Shared Property FormToBack() As Boolean = False Public Shared Property FormNoFocus() As Boolean = False @@ -235,6 +239,37 @@ Public Class B2SSettings Return filename End Function + Public Shared Sub LoadGlobalAndTableSettings(xmlNode As Xml.XmlNode) + If xmlNode.SelectSingleNode("DisableBuiltInEMReelSound") IsNot Nothing Then DisableBuiltInEMReelSound = (xmlNode.SelectSingleNode("DisableBuiltInEMReelSound").InnerText = "1") + If xmlNode.SelectSingleNode("HideGrill") IsNot Nothing Then HideGrill = CInt(xmlNode.SelectSingleNode("HideGrill").InnerText) + If xmlNode.SelectSingleNode("HideB2SDMD") IsNot Nothing Then HideB2SDMD = (xmlNode.SelectSingleNode("HideB2SDMD").InnerText = "1") + If xmlNode.SelectSingleNode("HideDMD") IsNot Nothing Then HideDMD = CInt(xmlNode.SelectSingleNode("HideDMD").InnerText) + If xmlNode.SelectSingleNode("LampsBlackTurns") IsNot Nothing Then LampsSkipFrames = CInt(xmlNode.SelectSingleNode("LampsBlackTurns").InnerText) + If xmlNode.SelectSingleNode("SolenoidsBlackTurns") IsNot Nothing Then SolenoidsSkipFrames = CInt(xmlNode.SelectSingleNode("SolenoidsBlackTurns").InnerText) + If xmlNode.SelectSingleNode("GIStringsBlackTurns") IsNot Nothing Then GIStringsSkipFrames = CInt(xmlNode.SelectSingleNode("GIStringsBlackTurns").InnerText) + If xmlNode.SelectSingleNode("LEDsBlackTurns") IsNot Nothing Then LEDsSkipFrames = CInt(xmlNode.SelectSingleNode("LEDsBlackTurns").InnerText) + If xmlNode.SelectSingleNode("LampsSkipFrames") IsNot Nothing Then LampsSkipFrames = CInt(xmlNode.SelectSingleNode("LampsSkipFrames").InnerText) + If xmlNode.SelectSingleNode("SolenoidsSkipFrames") IsNot Nothing Then SolenoidsSkipFrames = CInt(xmlNode.SelectSingleNode("SolenoidsSkipFrames").InnerText) + If xmlNode.SelectSingleNode("GIStringsSkipFrames") IsNot Nothing Then GIStringsSkipFrames = CInt(xmlNode.SelectSingleNode("GIStringsSkipFrames").InnerText) + If xmlNode.SelectSingleNode("LEDsSkipFrames") IsNot Nothing Then LEDsSkipFrames = CInt(xmlNode.SelectSingleNode("LEDsSkipFrames").InnerText) + If xmlNode.SelectSingleNode("UsedLEDType") IsNot Nothing Then UsedLEDType = CInt(xmlNode.SelectSingleNode("UsedLEDType").InnerText) + If xmlNode.SelectSingleNode("IsGlowBulbOn") IsNot Nothing Then IsGlowBulbOn = (xmlNode.SelectSingleNode("IsGlowBulbOn").InnerText = "1") + If xmlNode.SelectSingleNode("GlowIndex") IsNot Nothing Then GlowIndex = CInt(xmlNode.SelectSingleNode("GlowIndex").InnerText) + If xmlNode.SelectSingleNode("StartAsEXE") IsNot Nothing Then StartAsEXE = (xmlNode.SelectSingleNode("StartAsEXE").InnerText = "1") + + If Not PureEXE Then + If xmlNode.SelectSingleNode("FormToFront") IsNot Nothing Then FormToFront = (xmlNode.SelectSingleNode("FormToFront").InnerText = "1") + If xmlNode.SelectSingleNode("FormToBack") IsNot Nothing Then + FormToBack = (xmlNode.SelectSingleNode("FormToBack").InnerText = "1") + If FormToBack Then FormToFront = False + FormNoFocus = True + End If + If xmlNode.SelectSingleNode("FormNoFocus") IsNot Nothing Then + FormNoFocus = (xmlNode.SelectSingleNode("FormNoFocus").InnerText = "1") + End If + End If + End Sub + Public Shared Sub Load(Optional ByVal resetLogs As Boolean = True, Optional ByVal justLoadPluginSetting As Boolean = False) ClearAll() @@ -270,19 +305,13 @@ Public Class B2SSettings If nodeHeader.SelectSingleNode("IsLEDsStateLogOn") IsNot Nothing Then IsLEDsStateLogOn = (nodeHeader.SelectSingleNode("IsLEDsStateLogOn").InnerText = "1") If nodeHeader.SelectSingleNode("IsPaintingLogOn") IsNot Nothing Then IsPaintingLogOn = (nodeHeader.SelectSingleNode("IsPaintingLogOn").InnerText = "1") If nodeHeader.SelectSingleNode("IsStatisticsBackglassOn") IsNot Nothing Then IsStatisticsBackglassOn = (nodeHeader.SelectSingleNode("IsStatisticsBackglassOn").InnerText = "1") + If nodeHeader.SelectSingleNode("IsBackglassSearchLogOn") IsNot Nothing Then IsBackglassSearchLogOn = (nodeHeader.SelectSingleNode("IsBackglassSearchLogOn").InnerText = "1") If nodeHeader.SelectSingleNode("ShowStartupError") IsNot Nothing Then ShowStartupError = (nodeHeader.SelectSingleNode("ShowStartupError").InnerText = "1") If nodeHeader.SelectSingleNode("StartBackground") IsNot Nothing Then GlobalStartBackground = (nodeHeader.SelectSingleNode("StartBackground").InnerText = "1") End If - If nodeHeader.SelectSingleNode("FormToFront") IsNot Nothing Then FormToFront = (nodeHeader.SelectSingleNode("FormToFront").InnerText = "1") - If nodeHeader.SelectSingleNode("FormToBack") IsNot Nothing Then - FormToBack = (nodeHeader.SelectSingleNode("FormToBack").InnerText = "1") - If FormToBack Then FormToFront = False - FormNoFocus = True - End If - If nodeHeader.SelectSingleNode("FormNoFocus") IsNot Nothing Then - FormNoFocus = (nodeHeader.SelectSingleNode("FormNoFocus").InnerText = "1") - End If + LoadGlobalAndTableSettings(nodeHeader) + If nodeHeader.SelectSingleNode("ScreenshotPath") IsNot Nothing Then ScreenshotPath = nodeHeader.SelectSingleNode("ScreenshotPath").InnerText ScreenshotFileType = CInt(nodeHeader.SelectSingleNode("ScreenshotFileType").InnerText) @@ -307,31 +336,9 @@ Public Class B2SSettings Dim nodeTable As Xml.XmlElement = nodeHeader.SelectSingleNode(If(Not String.IsNullOrEmpty(GameName), GameName, B2SName)) If nodeTable IsNot Nothing Then _IsGameNameFound = True - If nodeTable.SelectSingleNode("HideGrill") IsNot Nothing Then HideGrill = CInt(nodeTable.SelectSingleNode("HideGrill").InnerText) - If nodeTable.SelectSingleNode("HideB2SDMD") IsNot Nothing Then HideB2SDMD = (nodeTable.SelectSingleNode("HideB2SDMD").InnerText = "1") - If nodeTable.SelectSingleNode("HideDMD") IsNot Nothing Then HideDMD = CInt(nodeTable.SelectSingleNode("HideDMD").InnerText) - If nodeTable.SelectSingleNode("MatchingFileName") IsNot Nothing Then MatchingFileName = nodeTable.SelectSingleNode("MatchingFileName").InnerText - If nodeTable.SelectSingleNode("LampsBlackTurns") IsNot Nothing Then LampsSkipFrames = CInt(nodeTable.SelectSingleNode("LampsBlackTurns").InnerText) - If nodeTable.SelectSingleNode("SolenoidsBlackTurns") IsNot Nothing Then SolenoidsSkipFrames = CInt(nodeTable.SelectSingleNode("SolenoidsBlackTurns").InnerText) - If nodeTable.SelectSingleNode("GIStringsBlackTurns") IsNot Nothing Then GIStringsSkipFrames = CInt(nodeTable.SelectSingleNode("GIStringsBlackTurns").InnerText) - If nodeTable.SelectSingleNode("LEDsBlackTurns") IsNot Nothing Then LEDsSkipFrames = CInt(nodeTable.SelectSingleNode("LEDsBlackTurns").InnerText) - If nodeTable.SelectSingleNode("LampsSkipFrames") IsNot Nothing Then LampsSkipFrames = CInt(nodeTable.SelectSingleNode("LampsSkipFrames").InnerText) - If nodeTable.SelectSingleNode("SolenoidsSkipFrames") IsNot Nothing Then SolenoidsSkipFrames = CInt(nodeTable.SelectSingleNode("SolenoidsSkipFrames").InnerText) - If nodeTable.SelectSingleNode("GIStringsSkipFrames") IsNot Nothing Then GIStringsSkipFrames = CInt(nodeTable.SelectSingleNode("GIStringsSkipFrames").InnerText) - If nodeTable.SelectSingleNode("LEDsSkipFrames") IsNot Nothing Then LEDsSkipFrames = CInt(nodeTable.SelectSingleNode("LEDsSkipFrames").InnerText) - If nodeTable.SelectSingleNode("UsedLEDType") IsNot Nothing Then UsedLEDType = CInt(nodeTable.SelectSingleNode("UsedLEDType").InnerText) - If nodeTable.SelectSingleNode("IsGlowBulbOn") IsNot Nothing Then IsGlowBulbOn = (nodeTable.SelectSingleNode("IsGlowBulbOn").InnerText = "1") - If nodeTable.SelectSingleNode("GlowIndex") IsNot Nothing Then GlowIndex = CInt(nodeTable.SelectSingleNode("GlowIndex").InnerText) - If nodeTable.SelectSingleNode("StartAsEXE") IsNot Nothing Then StartAsEXE = (nodeTable.SelectSingleNode("StartAsEXE").InnerText = "1") - If nodeTable.SelectSingleNode("DualMode") IsNot Nothing Then CurrentDualMode = CInt(nodeTable.SelectSingleNode("DualMode").InnerText) + LoadGlobalAndTableSettings(nodeTable) If nodeTable.SelectSingleNode("StartBackground") IsNot Nothing Then StartBackground = (nodeTable.SelectSingleNode("StartBackground").InnerText = "1") - If nodeTable.SelectSingleNode("FormToFront") IsNot Nothing Then FormToFront = (nodeTable.SelectSingleNode("FormToFront").InnerText = "1") - If nodeTable.SelectSingleNode("FormToBack") IsNot Nothing Then - FormToBack = (nodeTable.SelectSingleNode("FormToBack").InnerText = "1") - If FormToBack Then FormToFront = False - FormNoFocus = True - End If - If nodeTable.SelectSingleNode("FormNoFocus") IsNot Nothing Then FormNoFocus = (nodeTable.SelectSingleNode("FormNoFocus").InnerText = "1") + If nodeTable.SelectSingleNode("MatchingFileName") IsNot Nothing Then MatchingFileName = nodeTable.SelectSingleNode("MatchingFileName").InnerText Dim nodeAnimations As Xml.XmlElement = nodeTable.SelectSingleNode("Animations") If nodeAnimations IsNot Nothing Then @@ -408,6 +415,10 @@ Public Class B2SSettings If StartBackground.HasValue Then AddNode(XML, nodeTable, "StartBackground", If(StartBackground, "1", "0")) End If + If DisableBuiltInEMReelSound.HasValue Then + AddNode(XML, nodeTable, "DisableBuiltInEMReelSound", If(DisableBuiltInEMReelSound, "1", "0")) + End If + AddNode(XML, nodeTable, "FormToFront", If(FormToFront, "1", "0")) AddNode(XML, nodeTable, "FormToBack", If(FormToBack, "1", "0")) AddNode(XML, nodeTable, "FormNoFocus", If(FormNoFocus, "1", "0")) @@ -445,6 +456,7 @@ Public Class B2SSettings IsGIStringsStateLogOn = False IsLEDsStateLogOn = False IsPaintingLogOn = False + IsBackglassSearchLogOn = False IsStatisticsBackglassOn = False ScreenshotPath = String.Empty ScreenshotFileType = eImageFileType.PNG @@ -533,18 +545,50 @@ Public Class B2SSettings Public Shared ReadOnly Property HyperpinName() As String Get Dim ret As String = String.Empty + Dim searchPathLog As Log = New Log("BackglassSearchPath") + searchPathLog.IsLogOn = B2SSettings.IsBackglassSearchLogOn + + searchPathLog.WriteLogEntry("Start Search Hyperpinname") If HyperpinXMLFile <> "Unknown" Then If Not String.IsNullOrEmpty(HyperpinXMLFile) AndAlso IO.File.Exists(HyperpinXMLFile) Then Dim Xml As Xml.XmlDocument = New Xml.XmlDocument Xml.Load(HyperpinXMLFile) + searchPathLog.WriteLogEntry("Loop Hyperpinname") If Xml.SelectNodes("menu") IsNot Nothing Then For Each node As Xml.XmlNode In Xml.SelectNodes("menu") For Each gamenode As Xml.XmlNode In node.SelectNodes("game") If gamenode.Attributes("name") IsNot Nothing Then Dim name As String = gamenode.Attributes("name").InnerText + searchPathLog.WriteLogEntry("Check name: " + name + " compare with: " + B2SData.TableFileName) If name.Equals(B2SData.TableFileName, StringComparison.CurrentCultureIgnoreCase) Then ret = gamenode.SelectSingleNode("description").InnerText + searchPathLog.WriteLogEntry("Found: " + ret + "end search") Exit For + Else 'Westworld, allow optional syntax + If gamenode.SelectSingleNode("gamename") IsNot Nothing Then + Dim gamename As String = gamenode.SelectSingleNode("gamename").InnerText + If Not String.IsNullOrEmpty(gamename) Then + searchPathLog.WriteLogEntry("Check gamename: " + gamename + " compare with: " + B2SSettings.GameName) + If gamename.Equals(B2SSettings.GameName, StringComparison.CurrentCultureIgnoreCase) Then + ret = gamenode.SelectSingleNode("description").InnerText + searchPathLog.WriteLogEntry("Found: " + ret + "end search") + Exit For + End If + End If + End If + + 'last chance, try rom name + If gamenode.SelectSingleNode("rom") IsNot Nothing Then + Dim romname As String = gamenode.SelectSingleNode("rom").InnerText + If Not String.IsNullOrEmpty(romname) Then + searchPathLog.WriteLogEntry("Check rom: " + romname + " compare with: " + B2SSettings.GameName) + If romname.Equals(B2SSettings.GameName, StringComparison.CurrentCultureIgnoreCase) Then + ret = gamenode.SelectSingleNode("description").InnerText + searchPathLog.WriteLogEntry("Found: " + ret + "end search") + Exit For + End If + End If + End If End If End If Next @@ -552,7 +596,10 @@ Public Class B2SSettings Next End If End If - If String.IsNullOrEmpty(ret) Then ret = B2SData.TableFileName + If String.IsNullOrEmpty(ret) Then + ret = B2SData.TableFileName + searchPathLog.WriteLogEntry("Nothing found, using: " + ret + "as replacement") + End If End If ' get out Return ret diff --git a/b2sbackglassserver/b2sbackglassserver/Controls/B2SLEDBox.vb b/b2sbackglassserver/b2sbackglassserver/Controls/B2SLEDBox.vb index 2170d91..1d66edc 100644 --- a/b2sbackglassserver/b2sbackglassserver/Controls/B2SLEDBox.vb +++ b/b2sbackglassserver/b2sbackglassserver/Controls/B2SLEDBox.vb @@ -79,6 +79,7 @@ Public Class B2SLEDBox ' show control Me.Visible = True + Me.BringToFront() End Sub diff --git a/b2sbackglassserver/b2sbackglassserver/Controls/B2SPictureBox.vb b/b2sbackglassserver/b2sbackglassserver/Controls/B2SPictureBox.vb index 09efd9b..cfe762d 100644 --- a/b2sbackglassserver/b2sbackglassserver/Controls/B2SPictureBox.vb +++ b/b2sbackglassserver/b2sbackglassserver/Controls/B2SPictureBox.vb @@ -51,6 +51,7 @@ Public Class B2SPictureBox ' do not show the control MyBase.Visible = False + Me.BringToFront() End Sub Public Property PictureBoxType() As ePictureBoxType = ePictureBoxType.StandardImage diff --git a/b2sbackglassserver/b2sbackglassserver/Controls/B2SReelBox.vb b/b2sbackglassserver/b2sbackglassserver/Controls/B2SReelBox.vb index ad0bc2d..8940ed6 100644 --- a/b2sbackglassserver/b2sbackglassserver/Controls/B2SReelBox.vb +++ b/b2sbackglassserver/b2sbackglassserver/Controls/B2SReelBox.vb @@ -89,6 +89,7 @@ Public Class B2SReelBox Me.SetStyle(ControlStyles.AllPaintingInWmPaint Or ControlStyles.UserPaint Or ControlStyles.DoubleBuffer, True) 'Me.SetStyle(ControlStyles.SupportsTransparentBackColor, True) Me.DoubleBuffered = True + Me.BringToFront() ' back color 'Me.BackColor = Color.Transparent diff --git a/b2sbackglassserver/b2sbackglassserver/Forms/Background.Designer.vb b/b2sbackglassserver/b2sbackglassserver/Forms/Background.Designer.vb new file mode 100644 index 0000000..00cb943 --- /dev/null +++ b/b2sbackglassserver/b2sbackglassserver/Forms/Background.Designer.vb @@ -0,0 +1,40 @@ + _ +Partial Class Background + 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(Background)) + Me.SuspendLayout() + ' + 'Background + ' + Me.AutoScaleDimensions = New System.Drawing.SizeF(6.0!, 13.0!) + Me.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font + Me.ClientSize = New System.Drawing.Size(284, 261) + Me.ControlBox = False + Me.Icon = CType(resources.GetObject("$this.Icon"), System.Drawing.Icon) + Me.Name = "Background" + Me.Text = "B2SServer" + Me.ResumeLayout(False) + + End Sub +End Class diff --git a/b2sbackglassserver/b2sbackglassserver/Forms/Background.resx b/b2sbackglassserver/b2sbackglassserver/Forms/Background.resx new file mode 100644 index 0000000..6a23e00 --- /dev/null +++ b/b2sbackglassserver/b2sbackglassserver/Forms/Background.resx @@ -0,0 +1,1734 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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 + + + + + AAABAAUAAAAAAAEAIADI+wAAVgAAAEBAAAABACAAKEIAAB78AAAwMAAAAQAgAKglAABGPgEAICAAAAEA + IACoEAAA7mMBABAQAAABACAAaAQAAJZ0AQCJUE5HDQoaCgAAAA1JSERSAAABAAAAAQAIBgAAAFxyqGYA + ACAASURBVHja7L1ZkyTZdSb2nXuv7x575FqVtVf13ugN3WgCIEEQJIdGGQ0m2YitGQIyPTT6L/AH6IWm + Nz1pSDPJTKKGHI5kGo5kpMgmCaCJRmPptaqX6tqX3GOP8PD93qsHj8yMzMqsriXRJKh2M6/I8oqK9Lh+ + znfO+c5ygS+OL44vji+OL44vji+O//8d9MUSfHH0/uA1OlgW9H6iogGN2p/+sf5i9b4AgH8+gvxvvkf3 + /B0P/uZ3CHXtf/+XIei9P/gegWjvChD0rtWgXT9pXfxAAPSutdEg6J1rXwDCFwDweQjxf7NHyWmPMN/5 + 3fZ/pX2VXu/5eb/XXzpQ6H3ntenvvvdke17vJhNb66O2X/X2z9trV/vTf/cFEHwBAL8ghS/umvYI616B + 3jp2hPvO/7MfACiANKAnQk07wk2/fILe/85rNLHfDDsnAeC6+JkD4AQIFCfXkzWiO10hTYXiy8mZA5B6 + 8gpAEaD0zitq/9svFxD0/+1rVHg8BwQ+U0f13//L8Hbol0Dh97detK3se0++5+/bwr0HEPZadzUR6q1z + WtDV1KuasoAaBP3PyfXdx9pPr4sxOc3JaU2d5uTfhNaatoBAa2giaEakJ2uQAkgmZwwggUYCIAUhg95e + Ow1A1/7036lfinCR9gv+PsMXmvYI/+yXExA+dwDovfIq7fq1tO89TVvqXZYLtK3IYs9p0ETANWAorUWu + tciUMrXWlgZMvQMENIXxGgRFQE5ASkQJI0oEY4lBlBKQaCABIZ0If1aclANaTrwEtfV5/1RgsEfx9yq9 + CcAG4ABwc6X8REovlsrvJIm3EUZeK4qdME9srWFogGmtSeuC7eNEmjOmDM4zVxjxrGOHRzw3KJtiZDI+ + MhgLGNEIwBhANAGHbA9g/pN5BL1/+5nc0DQfcn8QoPcPEX9ZQOHQAaD3+69OE02fxa8RiKaVke6w4rQt + xGLKaplaw9TQdqaUNc6lNcxyO5a5k8rcjqW0xnlmDtLMXIsSK86lnSppZUoZuVJcac2kLnSWMaYEMWUw + lpmcJ74hIofzaM6xoxnHDquWFdZMc1w2RcCJBQSMiWist6zftsegdwT9cwaBiatP2yC5A4g2AFcDJal1 + ZZRmlY0oqt4cBbVPB6NqJ45K3Tjxe0nm9dPMTaS0tN7xlKb4P82IKcEoszhLqqYIG7Y1qtnW8Gyl3D9V + 8jtHfa9Tt6yuwViPgCGAcAsI9E6IoKufIwgUir9t2vcLGdk+nMi9eAL6Dj5E7+KP9vJJBUn6Z3+i/0UA + QO/3X6W7fCLt71MR7UPd0S7rvmPZd1xVgqW0dnKlnVhKJ5HSTZT0VsPI3Ywit5ckbjdJnEGaO+M8d6O8 + AIBYSjPOlTHMpZkpbeVaG7nSQmrNNUBKF0+MEWlOpDhRbjBKLUaxQRSXTRHXLDOqW2bQtK3RvOsMTpRK + /aOe123YVtfivI8dQY8nFk9uCcTnwQ9MWf3pcGfL2vtK60okZW11PJ65Ohg2b4yCxuo4bNwYhdW1KK0E + ufTCXLqx0naitZXraQ9pl3xoAIoBShClFqPEYRS5ggcLrjlY8uzu2Up58/FabeORWmV91rY3GVEXwGAK + CLZDg8/DE+j9wfdoyqKzfTyj/U62D1AUbFCRD5lWejl1qu1XvU+YOBVq/nPzCughlJ529FpPLRgdxMjT + FBE3/UD4lNJbGoXCK62cVGmvFcd+K45LnTj223Hit+K4FOaZ145Tr5dm7jDNnFEm7UgqK1LKiqS2YqWN + XGuhC1KLT4UJbA9JiB3yb4cDICDjhNRlLCkLFpUNHtYtY7DkO70z5VL7TKWyeapc2lhw3U2TsQ4jGgAY + gz4fQe9/9w53X+hi/bYVP8zyxnoYzX3Q6c5f7Pfnrw/HM2thUu8kWXUjlX6utauL9xsaMFAoPyMCcU5k + CoDzItGXZUCaa600NAiSprgAQRTWBBsuuWbndMXffKxaWX2yUVs57vurddvacDjvABhNgGCbMPxFrE3/ + DwrSc4+F51TIwY5h0YVxUVqbCtrSWpu6+LtIpOTjTCLTigAQB8ESHAzQnDFlEinBKCdQRkDCiTIiyqbC + w3TbK9S7QGI6e/LPJkSg+1R++gz3iUC7Yna6g4wiEphWSl1Y+UQpN8gyt5+mfieO/XaSlIZpUt4I4/JG + FJc6Sep3k8zfiFNvlEsnkspONaxca1PthAjGNJoTgRFAjIMJRsQYGO353kpD68Ib0FpDSQWlFKTW24CQ + Akg5IawKPjzumr1TZW/zbKW8fq5aXnmsWl1p2ta6XQj6EKBoQoj9QkBgj9XfCo9sAB6AyiDNGmthOHdj + NFq41B8svr3ZXbgyCmc2U1lLlC7p4n0WEUxDgB+ZFfzEgsHm6gZzbUZEBEMwsk0O02BQWiNJFMIk171R + rruDXLf6Uq+3ctkdqVxrpABiThjVBe8teVbr0aq/+qVG/dZzzcbNYyV/xRNiE0B/AgLpLwIEimImPS1r + O/I1zX9o7US5dAdp6nYL79EdZ7mTSukkMjfiXPIgz1muNUEDnBEszkCAFoxpi/Hc5jyzhYg9IaIZy4pd + Q8SuEJEnjNAVPKRCBuIpsjTbQyxvewf/1CBA96H4fB/3aefvBEYgPsW4cw3NFEBSa66K09CApaGNTGkz + yHJrmKbOOM+8IM/8VpSUNqKotBnH5bUo8btxUuokmddJpTdU2pFa21RwAFtWi3MGblvEKyXGKh4x1yZm + Gowci1PFF+TaDPMNE7WyIMtgtH9ApyGl1uNIoTPM9Vor1Zu9VPcDqUaBkt2hklGiU6URMyCocNY/4pqt + cxVv9evzszefqNduHfW85ZJpbDCi3h5BPzQQ6H33NdrjOVkAPKV1OVOq0YriuYu9/uInvcGRT/uDhYuD + 8fzlcdqUWlc04JkCVtVn5mydi+MLFju75LCjczYtNC2ql01yrAK3GSMIXrxCA7nSyHOF4TjHaJzrfpBh + rZPoD68G6tMbkVzZlHkQ6kQBYw4MXM7aX274y99YnLvxwkzz+uly6bZvGGsAOhOi8NBAYFLFiN2yqc2J + N+lorf0wl5V2HFcGSVoJsqzSS5LSyjj0W0nsd+LUHWW5G+XSHue5kUolYqlJ6sKrZQQYrAAATqRNznKH + 88w3RFIyRDRrmZFniKhmWeMZ2x7VbWvkCmPUtKxhyTBGFudjTrSXHJ0OF7c4BNT+/PMHgwMBoPdfvzqd + ahN70kem3iHijExrI5HSSJQyMqVMqZSpoY1cK54qxWKpRJTnRiKVlSll50paiZL2MMvtdpw6vST2h1nm + rUeJdztM/Xaau6mCK6Ht6RQVZzAMUSj8XEOwY/MGzdUNqvgGq3gGNaoCZU+QZTAIwWAZnEyDoeILlFwB + Q+wqA6CJ8mtoQCqNJFUYhRL9INPDIEM/yHR3kOnNXqou3YrUteUkX2/LJM0REjB0GLVfninffnm2eePp + Rv3a2Ur5ZtO2VomoM3nghwYCe5TfmKxLOVeqPkizuRuj0ZFPuv2ld9vdIx90hgvXw3Qm1boKoGwI2GeP + GeZjJ21xYsFhC02LluZcNle3UC8bVPIEHJNDiLuXR6apRpopRKnEIMj0rfUIl28H6tKtUH96I8ov30rT + 7lDFAEY2o80X6/7yV+ebN74827z2aLV6vWyaywC6AIKJMjzU2mzH+XfyH16qVHmc5dVOHDduB+OZ66NR + cz2M6r0krbTjpHRpFHu9NHdjpWwJWFrDVDvGaz/d2I7/CcgZUc6BRACJJ1iy5JrhomuPZ2xrWDHN4VHX + 6S26bn/OdXt1y+qXDGNgMTYiomDKO8gAnQMkC+5A69qff75EIR2o/LsZeBeAmyrlpUr6YS79UZa5sVRu + qnIrkdIaZbkZ5Lk9YdztXCkj05LHUolxLnk/zYxRJu1RlllBlltRLs1YKmsklTXIlZMWqTobgLll5Ykg + qiXGZ2uM18qcV0uCzTdMmm8YVPFNmqtbaFZNKrkCri1Q9gQ8h5PgW4mI4pWxSSxAdy9yUxrQSkMqjTTT + CGOJUZjr3ijD9dVQX7oVqI+vjeWHV+N0ZVPGWmNkEm0+UrJvf32+ee2r87OXn59pXPUNY3nK5c22icEH + FfQ7ld8BUImlnGlH8ZErg+HxH6ytH397s7d0PUjmhlLVNVB2LHLnGsx6+owjnnmkxB874dPSnEvVkoF6 + 2SDBGRgDiO6HDC7qg5UC4kyh1UsKILg1VheujNSP3h/l11byGMDQImo/UbaXX55rXP+1xbnLTzcbVxwu + bvOCIAwmAHnf2YHeH7y2dccMeltGLUB7mVLVQZI1NuNoZmUczl0dDucudAdzlwfjxkqUVgOlSrmGM8mQ + mBPuhBPAicA5I7ItgmUCpiBirGD/hoHWaaaRS61VER5KjW0+JAeQEBCbRFFJsGDGFMMnq6X+mUqpu+R7 + nXnH6czYdqduWV1XiL5gRUZpAgbptlcwySZ8Xt6AuAuTzydulK+1rg2yrNGO40YniRubUVxdCaNyJ0n9 + fhI7YV4AQD+T1iiX9iCTZiilkSrN1ISIm5zGFMO/K4/PGYRtkfAc4rUy5/N1wWZqglVKBs03TJqpmlQr + mzRbs7DQtMixOByLwzIZBKd7DGvuvqaMClHgnGAagO9yzNRNKAWcW/LoiVMleuT4iB2d67O3Px6JC5cz + kSrNPx5GXOsW4wTVsK3ssWolYYzltEP+ZAB07zuv0f2CwJTy82nlj/J8fmUcLl3o9k69sbpx6q9WOsci + qWYVULNM8hZnmH12yTKePOPzZ8+V6dETJZpv2OTYDPRQKeAipcYY4FoMx+YdzDdsnD7q8ZNHXOa5nL3x + 7pBur2dsFGr+3iDiw2yTBXmuS6aZnSyVUt8wtpRGAcgnacJ7hyAC6S2rTzCh4WrociJVYz0M5y4Nhosf + dnuL5zv9xQv98Ww3k/VM6/KEJ7EFg+HYZNTKjM83BNUrgvkOI0MQMUZkCA7LYDAEgTOC1hqjUCLLFZJM + IU6UjhKlBiOJ7kjK0VipINQyTnWeaJ0lmYzbmYwvjZOgvtkbHnOt/umS23mkWmk9Vim3Fj1vs25Zbd8w + ugZjAyrAsPAKqCAPe69873MJCcQBcT+foKOfSjkzyrKjF3q9pfPd3uKF3mD20mhc72WyFCntpkrbcrdS + G7SbcactdpkKHeOMgdsmMdch8hxiFZ8xzxHUqHA2UzNprm6xo3MOluYsKnsm6hWTKr6AZRQsHmP0uRUx + EUCcA+WSoR/1DJpv2nRs3qW5epvlssNureU0HGtcDGJVbffSWdeOF1xnXDbNxGSsQPVJGbHW0P3vvkbV + //XeQKC/W/nNSUxbjaWcvx2MT/x0o3X6B6sbp37UGh4fSzUPoFL1yX30lGU+c87jzz1SYc89WqX5pk2W + yYjRL2Z9LJMw37ThOgK+ZzDfMYyfXOizizcSavcVbkSptlq9fMnz4pJhhCbnscVZOsWO6/53XtP6Hryk + /ndeY1OekA3Az7SqR3k+txKMF3+22T72443W0Z+1hwvtTM5ooArAFxx2xWdmvcJ4syb4bM1gR+dsOj7v + 0ELTQrVUhI7EWGGNeGFYJjQIokRCSoU4lRhHEqOx1O1+hnY/MVr9RK93Ur3ZyVR7IGWrq7w001JqJK1M + xq1BGJ4fRsPKeq/3RNVrfblZ23yyVts4UfLXG5a1UTKMNmesPwGCaFJ0JnuvfE/9okGA9on72SSW8jOl + Zjbj+Nhbm5uP/N+3V89e6AdHNzPZBFCZWCJrYr05Z+CCExMCxDl4wSaDBCcyBMg0iSyDYFtEpsHIdwTV + SoKaVQNLcxZVyxYtNm0sztiolw0yDIJlCDCG6TTjgeGZ1gdZi616BNrHE6C7eAe0z/WiVDxOpV7ZiPRf + vrGu/uatbvbx1TSKEt1rGnzly83y5f/u0TMXHq9VL1ZM8xbdSXztpIHuIuy977xGU56YMSH7qomUC1eH + o5N/v7xy5o3V1ul3+9GxTOs5IlQrPjkvPO4av/1yg734ZI2dXHTJc8Tky0x/Z71fncZdvKT912L32u2s + ze2NWP/Dz1vq+z/v5m99EMbjWA9KnK2fKzlXXn3s9EfPNhufLHjODQbanKQIt7Imaquybnptet/ZquQj + miKgHQ1UEylnO3G8eGUwPP53y2vHf9bqLV0JkvlE6wYBZcHh1CrMODIrjBMLNjt11GGnj3o4Pu/S8QWH + Sl5hWISgu4SIO/KjlIZSBTEqpUKaabT6qb69HuLq8hhXl0N9+XakOv1M9YZKjcYqj2KdZhIJgFADwwpn + 3UdKduvZenX9yzONlWebzZWKYaybnG9yoj6AMbSOJ16Srv35n6jPxwOg3XHmMMtqV4ejI//xxvKpDwfj + UwOpFgHUALiT9B0XnFitTKxa4qj4jCo+J99jJDhHyRNUdgXKnoF62UC1bNBs3YDnFOScbXC4NketbIAz + BmI7VuVekxVaA7kEcqkKEzsl55wRTIOBEd0D9UH3RJMQAY7FaWnBxbe/sciGYynCqGd/cj0rdTM5c7Ef + hK8vrw4bljmyGIscIQoOoPiY6fJY3fvua1Q7yBugbWZbTKr5amEuF2+OgpP/59Ub53603j79aZAeU8As + ESqOCedXvuSJ3/+tBfbCY1Waa1hEuyT6bo2S95oYuvsaba3N2WMeBCeWpkqstlLr42uZH0jVuDAI4x+s + rA+btjmq2WbkFmujp7Im+fbafOe1KRAg7CH7bADVTKqF68Pg+I83Nk795fWVk5dH0VKg9JwuZNS3TLLm + Gsz4tecr7Bsv1Onskk+zdYuqJVHI2z1zHztvY4zAWBF7AAyeA1TLBs4suXj56Tq6w5TavZRdWQ71h1eG + +uPrY3HldmzeWpO21nAJKA2lqv28HzY/HkYzP2v3Zn9jcTTz9bnZm6fKvl81rVVG1EZRIBsDyHuvFAD4 + i/AGxD4pPwZAZEo7y+Ow8m6n0/x4EM4FUs0CqFsmSqeOGubTZ13x5SfKZJucHNugkiuo4huolQQqJUGF + z79DvnE+WTg2SS/R9mMlRvfnm2oNJKlEb5Rho5Pg9nqEj66OME4kskyBCHBtgYWGjSfP+Fiad9CoWLBM + BjokN9gQRAtNCy8/XePdYarX2gOnP9Ll9SSf/f5KK3iuWR+VTTNyBM8nisgBRHp3TnhfEJhy/cXE0lWi + PJ+/FYxO/OXN24/8cK199maYLSlghjFUzh4X9le/VDb+y19foEdO+KziG/e/qIccFhyZtfHCExXW6ifi + 5lrHHke6nGqd/qzdO/Z4vRw1HTs/XS4TEQkqCNNAAzFoO0WG3ndf20rV0B63v5IptXBlODzxo7WNs//X + jZUzl0bx8VTrGQ1UGME9tiDMF57wxLdeavKXnqxRo2LCMhkYo0MPhQoRJzg2x6JlY65h63PHffr1Fxq0 + 1onpk+sB++mFPv/+2wNjsyPNKNGW1nBCpf2Lo7jaur5cu9DtVX776ELphWbTPu77QjCmpzoTCg7ple/R + YYOAOADuWCyl0UsS+1YQlvpSljXgGgL273y1ZH7rpab48hM1PlM3STACTWwNYwROBMZ2eu5pHwv6MIcG + 0BtluHB5gHc+6ePijTE2OynW2jnSXEPK4vdaglD2GRbfNfDYKR8vPlnD4ydLmK1be0nDBzoYI9g2p2ce + qWC9E/Nba4nxo/ciL1a6vhxlydutTtS0bWkLLsqmaXOi9lRpbDydC+9997W9tob0lOufStm8OhwtvbG6 + fvr125unb0fZUqL1rGAoP/+EZf/6CzXjd742x04suOTanBj7p2/yNA1Gj5wooR9k7OZ6bPzVPwaO1qgu + R/mRH65tykhK8WwzcR6pVfyqaa7zInU6nIRLWxWVasoF2LL85Vyp+UuD4Ykfra2f/f7qxtlLo/hEovUc + gEq1xJwXn3LNX3+hxr/yVJ2OzTvkO4I4J/yiIZEmxo4xkOActsVQ8gSOzjr07CMV/a2vjOntj3rsvU8D + 8fG12NjoKCvW2l5NcnfcGdmpUlYipRCM4Zjn5US0lRVQe8PHwzq2cp74wyefnyacrEjK8s1xMHu+2z9y + cRwfJaDRqDDvv/h6w3z56QY/fdRlri3IMhmZBoMhGAQn4pyITaz8FvN3WKdGYfl//EEHr/+kjb//WQ/v + fBLjyu0c3YHCINAYjYuzN1LY6ErcXM2w0U0wCFKYBqHsGyh7xlb666FORoBlFmgSJRm9fymkLAeXAA/T + 1OgmkdmNEyuWyhaMWTbnBkfBj0wWe6t0TU8z3CiWziSCC0JjeRwuvdvqnPmbW2vnPhzGJyYxf+Xrzzn2 + 7369afzmV2bZmaM+ORbfFvT9zknlI6TWkFJjHEl0hyn6owxZrgtgnAgx4eHXxzQYGCNIqenC5YDCSHMJ + 8FGaWRthbC8HgbM+Dp1UKkswZpicMTEpupk6iQiCCDYI5UypuWuj0cm/X14998ba5tkPe+GJQOkFzlA7 + tiDc//b3Zsxvf2OOf+WpGjs275LnFmvC7uO+ldKIEoV2P8XyRoTVVoSNTox2L0W7n2IwzpHlGqZg20q/ + r3wUBVVkGZzKnkGLMzadO+azR0/47OicwYlyvtmVIsthxlobgyQXSkkwQrbgupEreEREBT9SzG3Sf/jk + c/RHH777C04DTh4+J9KC0XZzQ5Jq3R1m6AcZ0lzDEIV3tmt6BB2Qebvn63p/V2EitJ1+hnc/6eOnHw7x + 0dUMSt09VEhz4PLNHKNgBGgNRoBrczQqJnb5ggf+3skf+5kPrWEIhtmaTUfnXHZsXhgXb2QAoK+ME9ZN + u9a14bh8sttvni77c+dq1ZVHq5XVGcdetznf8giiqcowrfVu4i/M88blwWDh/Xb36Ef9cDHXugmg9MRp + 0/rWSw3x1Wca7OQRj2yL7+DInnvVuihy6g5SrLVjrHcSZLlEEEoMJspf8gRmaiZqZQszNRPzTRtlT4Dd + 0xrtf11w0EzNwqMnfTx2yhadfgipUGlnSvQGkXV7nPpXhuPap/1h45mZev35mWb5dLnklgxjY1JHEU1y + 4wKAlyhZ78bJkTdW10+9ud46daEXHu9LNW8IVOeb3H3lt5viX/3KLD+x6JHnCNoCtHu9f6WBIMxx+dYY + yxshVlsx1toJoiQvHsokO+DaHPWKgYWmhfmGjYWmjVrFhGNxcHbn5zOmYTKCYRjk2kLXKybNz9js2IIj + luY69NdvDthgqHRfKnm+H8RV0xydKpe6ZbPRNxmLaKqWBIDqvfIqHVbB0EEAoGzG84ppJguuEztEYap1 + PI509t6nQW7bnIIwx3zTYqZR1Iw7FifP4dpzOARntFWIAzpA02kvK72X/rvzulQK3VGOtU6KVk/eVfn3 + HusdiTc/CGBbHCXfxFeersG1+ETA99KOtOc+9yMR9XYFTckzaLZuYmneZJ/eyIyi5hx8M5VmOw39q6O4 + 9nFv1DzVGzRfmmvWnmk2/JPlkl0SwqDp0uGCCd+pwdAo3w7GzU+6/YXz3cFCX6oGEUolj+zf/pWaeOnp + Gjt5xCPHEvvSWVJqhIlCqxdjeT3C1eUAl26OcX0lRpIphJHEaKyRSw3fZWhWBWbqFk4sOnjh8QoePVnG + bN0CZwdVDnz2dc8RtNB08OwjJfzsQiSiRBMAJgGjm0unP5SlW+O0sh4l5SDN/DjP3cdrNatsGuYEBBIQ + hNaoDtNs7uNe/9iP11snLw6ipb5Us5aBymOnTefrz1SN33hplp086lPJFfsQ+nQAhzmRLakxHOd492If + b77XxcfXAixvpljdlBgEhaBZBsE0Cb5DqFc45hoCxxdsnDzi4rGTJZxe8jBbt2CbfPfoRdrh2IUAlTwD + lslR9gzWKJskFfCzCyPn2kpe3khl83ownv+kN9h8pFJpccMYCcbi7RBgMoWg98qrOAwQ2A8AFIDc5Cxp + 2vb4TLnUO2Yb3dtxVo+Vdt79OGadfm5/cjUQxxZs7licuY6gii+oWTVpvmnTfMPWMzWTbJNP0nh3K8LR + 9/yzBpDlCrnEfSn/1rG8IfHOJwEqJQNnjnlYbNow2X6jYD5rXXf/u+twNKsWHV+wYYgxy3KYW2SqAuxu + rtzeKC5fCpJqN0lL/ST1+0nqnqtWrHnHFkTUAW2nCrFDduny9dFo5spgNHdtlDQAlB2b7K8964mXn67z + k0c85jmCdsB08gBVkbfe6Ca4dHOEy7fGuHg9wCfXQ1y6kSGK9QHJvhRChDgyO8JGJ0EYKzz7aBXzTQsH + dVF81voIwVApGXT2uIdmndN6SyLL9baXowBrKJXzbnfs5Eo5iVROprTzVKNmlw1jjRV19DyWeXMjDI++ + tb55/NPB+Gg3k3NEqD5y0nR/9fmq8btfm2dnj/nkOeKAbN7B9yoV0A8yfHhliP/8ww389MIIV29lkHtk + LE414lRjGACrLYmPrqYwRYi55hBfe3aM5x6r4PFTJZw77qPiiwlw3inHRIBlMpqtmTCNMnqjjHeHqbm8 + kTtJpsubcda8HoznYyk3fcMYTjiRyd3o7T6C3iuvFunkhwCCbQ7gjz56d4sHwKRwhxORAcBMZGYNksQc + 54rFuUa7r9SlW6l85+NIfnBxLD+4FKjzlwL9yY0At9cjCsKMbJvDdQRtM++HcCoFBKHEB5cGuLmWYDi+ + /+8dJQqG0Di95GK2buMw7o8zQhgrtHoJvfPxCEm6q/d8u9VZAvZ6lNn9ODFjmQlGRBXTzB0hMkaUTySE + oWhNLQVZvvDW+sbJ9zv9k9fC9IhlUO3oHHe//c1Z46Wn6mymZjG+5eZOzkxq9IYpLt8K8KP3Ovg//m4d + f//TPt7+MMbypkSe3319lAIGI4X1TgqQhO9xHJl1YIgHWyeirVBM00dXhxiOJUWx3tsKbkrAaie5PU5T + K5G5aTDGq5ZJJmMGEZU2wmjhfLd38i9vrJy5FWZHM6BRLZH/jS+XrW++OMOff7zKfFcQY/d/j+NY4urt + Mf7T99fxN2/2sbyR36H8Bx1SAYNA4eZagtsbEYIwg2cz1CvmNgdyaVyfzQAAIABJREFU0O9ljIpybE50 + 8cYI11ZSxInWBpFsWCJ9ul5LLM4zQSQ50VRhC9HO6EbCHz75PP7ow3ceDgAmROBUUhckiMHiHGXT0FJJ + LaAyaJ1qrRMCJVLrJJNIw1jn/ZFSKxs5Pr0e04WrAZU8wlzTQtk3SAh2OCzgxPW+cGWIm2sJOv37dwOy + HOBco+RxnD3mw3MFOGcPfV9hnGOjk+DHHwxoHOm9/frbMw8kYHaS3OzGqUhVzkqmkHOukwjGUka0FQJY + Uuvyahgt/nht88RH3eBYN5Nz1TIrnT1mWv/Vtxb58QWXbHuH8dMgxKnCaivWH1wa4PWftPAXf9vG+58m + GAYaubw/EjwINcI4Q9lnOHHERdk3wfiDrc+WSb5weUCb3ZT6I723q5EDEBIw2om02mFsjbJENGyLVU3L + ZESV66PRwg9W10/8YGNwPNV6lgjlF59y7G++2BAvPlVnjaoJegDWWYPQ6iV472If//N/WsdGW96z8k8f + SQpsdiQG4wxhkmFhxkbFNyYG5i6/XwNJIumDS0NcvR0jCAueymGkq6ZAIiVlSgkCcUGMcwLDFIu8o7vP + 4UHIwV0hQO0//Inu/f6rqohFKRaMhnXLYs83mspkPDrp9zs3g2CmFSf1fpZXhlnuS6W8RClvkMlyN1Pl + JNel1U3pvv5WV5w95qFRsTBn8fvLwOj9a04YAzxXoF4xUfH5hDu7zzSiBto9iXc/HuI3v5KiUbVgiIfI + SU7uk3MGw2BgfIch2FN2t10aLQF2K0rJaA+0b4j0RMkPj/pe4gkhJ3yAoQFzlGZ2O06dVprbAAzHJtGo + Clpo2rAmsYsGSEqNIMz1jZUxfnqhr994r4efvD/Wg7GCEJwEQFpqZEpB3ofTtLIhcelGiPOXR5it2/C4 + wINkGAVn8ByOkitgGXfsS7CV359wA5rfjjOebfZ5yTSMumVV6rYtN8Ko/klveCQuKvz8mRqzXnyyzJ84 + XabZug2iB0vypZlCu5/g0o0AK5vyoRJtSgPXlzOMxgPUSgZcm+P0kg/P4QfLNoFApBkj4pyEBqxAqvKF + YSg7l27QYxXffqJaqT1SKTeP+/7arGNvlgyjzYkGk87CCNBpUTD06qSR6N5DgjtEfwICchJXhpygXMHT + 5xr14NFKpTVI02o7SSobUVxuxXEpV3lllGW1G0E4e743Wrg0TrQG2PlLiX3l9licOe5Ts2bhDkZ2m33d + j5zZn3UnKmLKhRkHs3UDjOLtRPH9HHECrLWL9OCJIy58T9z9fu52n5PrnNOk0OTAMrLpUVtQgFqJ0vz9 + dj/+UqM38gwxtjhPOG2zjoyoaE7Zgk/OAENwGEZhPaQGskzp7iDVH1wa4vWftPCz84G8fCuVlmtQtcq4 + lSlmK6I4kxjmwPg+zFsYa1xZTvDOxwM8+2gFllUQvndkcPQeqd57nTSICIYpwPdv3NrK8xOKKauslUr2 + Dytt8VS9Wp53HbkyHvtXg2SWijJ0++xxUzxxpsKPLXhkmmwfo6F3Ksj3ZgK2csoEjKIcN9dC/Oi9QfFP + D0mq5bLwBP7ib9uYb1pwbYETR12IabJ5z31qaMpzhSTVnIqeD0RKs6thal4Lu97b7UHj0Yo390yjOv9C + o7F6qlxeqxjGuit4y2Csj51monyLG7hXEBB3qXxUE1JKAcgMxsOKyXtl03SXfN8BtKcBV2ldGeX5zAed + 7jHXWMtv3lg3Y62tONXio6tj/syjsT51xIPYr9n8INA+6DojCMFwdM7GbMMA44DK7/8hRYnGp9cz3F4P + 8eSZEhpVc8dNu5/72bquNeJEojvMkKT7GhGaiu+NrScfKp1fD+Lo9dtrw1nXGTjCGNUtM0XRWqodwbOS + IZKSYGknk3kuIaNEqkGQMcPgSmlNa61Yv/V+T//F327SSlvm/UGe1md8MhnZfpLz0yWbck1YGccYBfK+ + 16rVyXF9JcRgnGNWFeN17kyKfNb6FKGrbTJwTnu7EKbXBij6UJBpTctxJv7f22ulo56reklqtVNZBuBx + BvPccY8fnXOoUjJ2itjvhfWnHVDQ0OgNM6y2Eqy180PrLlO6IAl/9F4fx4+4qNdM1MvmgU6kBpArTVmm + tzmgrbBIA/Z6Jsub7WH9o8F45ieb3bmXZxuzLzQb9bPl8vKMba0KxlsEPcDObMp7BoF9AWDyH3Xvle9t + 3Z+clGjGk4mvBkAmATYjKlVNY3CmXJIbUej81e3NWpLLKgH29eXYGI5zlil9KL17RS6WUK+aqJQETIOQ + 5w/ms2VS4/ZGjEEwKeowH/wGNYBRJLGykSAI9N1uX09ZOwuAP8hV40ebg4XHGp1O1TJ7FcscCyLJGJNl + 0wzrljmqmHyEKBtvdmTppxfGxv/4Zzdorm6xJFO4tRbr9y8lGIQ6z1MVHTneVI5plKq9kXiqXsVTtRp+ + uLqOIM0QPEBwGyUaQSSRS32Hob+vB0eAbfFiKMudiZfpcGCbH1CA+MHGwDNpqDW00NAWEUzbJvHoqRLV + qxYJQQ8uW3p6VOWhlwfjrQ/GeOz0EHNNB5WSsZNO3fNGDQ2lFaTS+43cEwBsBfitTJZbvaD23mDc+I3B + sPatxfnK882me8z3DKMIgfqYaj9/qEKgAgj+WPdeebUoBNI04QbAJp5BPCnUSAgEk3PfM4xOzTaG3UBG + muCPYymTTLIs13yvRdhRCX3n9b0FLXp3aGAIDtsSqJY4xtGDI/fqZoogkshkMX54V/ih90khTVs6vXNd + KiBOJQZBiuzugLSr32LyYMuDXDbfb/Vmn6hV1k6XSy1uiICgU1fwUcU0uyVDdATQyHK4rY6i198cWKYJ + rjWBmTalWuScyeD4IwtUtozasX5gPbEwi7pl4eebbXzYG2IlybYZ+ft1abNcQ9/hH9MeV3+fuoDpwhsC + 8lxBqXtan61wiWdaW7netozcNIg/csJm5477VCubYIxhV3fjHc9uj6ztuk8Nw2AwTfbgPNBdjv5I4sqt + MdbbER4/XS7Cn72NmLqYtJRLPb02NKWf03tgmADcRGn/h5t9byOKvdXx2P6NI4viiVoNrNjVatup6L3y + qvosL4B91pfY/gCCmuz6kmNn+ukWCAQmY4OSYQzOlJwRJ4oB5EGo1Ho7RauXag3af3L6ViGs3sdk7Hd9 + 0uhTK5lYmBEPhdCrrRRxIiF3eSi07/YFu+5n+jkRoT/KsbIR4cqt8H44iW0Q0EDpdhDVbo/C+mYUlwhk + MGLSF2L03Gxz89lmdeWYaywzwppU2OwOVHujo9va8nuW7w+g6fbps0uDeceuPZ9K51ebDTriu7g2HOEn + rR6W4+y+yL+9aUGlptutp4JYjX1G7u9/XSmgHySIUvVZILR3fwNT70zuEbYJdnTepLJvwDDYVKPgQc9u + j6zt2vu06BZ1bAbbZoel99vfXing1lqM5fWijHivPZmkR3FtJUJ3IJHlB64Dnyi/A6AEoDlWevGTUXzy + B+utM6+vrJy+FQRHUyVrALkAGQAxgGirk/CBPIC9IDD5MLUHwzIAicV56BsimLetsQDiFMjDSKvOINX9 + ICuA7xC6MQiA7wk06ybmmsYEgx7gcwjoj3JkkzbigyvFPive02j3E9xcD3HpZnKfTvH2g3XX46zSiuNq + P0lLKAanDhmj4cmSv/61hXlDMK7fWGuFF4dxI5HKq854xsLCTJMT9c4uzIVLZf/p2dHYXuSCDMaxMo7w + dqeHlThD+hDd5ER6Kv9PD9TNJaVGnCoEYY400/e6PtMGatt0GwZRs2rAtvmEUKSHCi/LvoFjCx5efKqM + T693HrbdZq95o+WNHJu9ohflyLxzx9szpbHWSjAMZNHIdjB3tHdfA4RK49NRkruiFy263uCbi4vdukmB + YDRdXo6HBoBdIUGxd9/UZprF/nkGY4nDRVS1zNBglJDUeRRr1R9mOgjzHQA+hMO2Ocq+gWpZgLMHqwrc + SgEVHOwD3psGwkTi6q0AFy6N0O6qexVuvScPbg1z5beiqNyOo1IipWVxDg1EJdPcfLxey33DCE+VS62N + MKy24sRxnjzbsG1rrjQaX/Zmm08nQTDLugMmOEcrTvBhb4CLQVQEg3pXxHJfh2Uy2BYH4wwPOocpzhRW + NyPcXk8xCvT94v2u32pZhNmmCd8VMAR7aJlybI6j8w5efKqGn18Y4eqtdK8lvmdbgDsnpujeQFGnn1Jn + kEJKDcZomjuGUkCrFyMI5UHe495vuBUeOQDkSKn6zXEy+36nN/PlmWatZIiWADcBmgxd1fLQAAAoNjOY + AoGtXXNzAUotzuKSYYY2Y1EgVZpLyH6QqWGQ6iRV5Nj8wVsypwd9cEKlZKJZs+C7hGHwYLA93REI+uzf + uzczmEuNK7cCfPDpAOc/DR+kgGTbC5CAc2MUlVbGoT/KMsfinBGQcqKkbluxLfho3nM2RlnmjS3LGZ45 + /nzD9y+WTCt758a1fz3sdE1Da4ykwlqc4FIYI5yI5IGb192TghBKnoBpsKJ5iu59jbYJ11yhPUiwvJFh + NH44Eyt4MavRNNmkMOnBZGhbBjihUbXw6KkSvvJMGZ1+F52eup9Qbocon9oHcQvcs1yz/ihHd5BSJhUs + znfBmtIaQZQhye4pNNobPloAvEEmyzeCca2TJOW6ZbkO58aO10B0t/mCDxT4TG1msLUnmgQhtbmIZmx7 + XDd5ZBKlGsjbvVy1+6keFl7Agz/9KSUlKqawzDVM+B57YEDxHVGQSHdDpQPAIZcKm50Yb73fwTsfD3B7 + LXuQb7MdChBgrYaJ009SN5HSmgCDnGRe+p4Q6/Oue+t0pXzlia++dMubnRmdnZl5u+/Y9W6WL7SHY4rB + 0cs1WplGO1fYHrH0EIfnEOplA9Z249S9r9GW+z8OcyyvR+gPJbLs4USgGNjKwdkD9Pfvc59EgONwHFtw + 8a2XZ/DCkz7mmvx+lT8HkBIwtohGDcGHgoqx8BqQwyBXvWGupdRaT2l5lmsMRhk6/RRRrO5XbrZBIFba + 7aaZtx7GbpRLCzsb5HzmCh0G87EVBmSu4NG8a4/rphhbjBIC8vVWrtu9FME404c5zqDkCVTLJnyXPaj+ + Y2HGgG3y/dMzd0sh5hqdfoqfnG/jjbc7OH8xRpI+lFwzADxV2lBamxp6C8E1iqm5iS6KPXoM1AmefoKF + ntthRxZan/S6T68PBnaoNDTnGEqFbpohlmqHvNP3z/5vHZUyx/yMibJnbOfw7+cIY4mVzQjvfjzEKFAP + VLg1raycEYTgh4FtOz41I1TLBp55tIrf+fosnn/Sw2yT3Y/yJwbR6Omy3f29I42Nbx+b3TxuGz0+6fIc + BFINgkxPPEQ9HYKudxLcXk8xHOkHgTIGQEhoI5LK6qapnShp6ntU/gcKAfaEAsX2i7qoE7A4T2qmGVYt + M7RYHEMib3WkGo1zHcZye9jEYQw2sS0OzxUoeQIPUhLMGXDupIvqpGnjXq1Jkiq0ugnOXxrgP/z1Gs5/ + GqI7eKiZjdvkjtKaa2iud0gf6OmNJwHos6fYpW6n1Dx16vqwXnfX+99/orXR5j4YpNaIc4lxniNTGrrY + 9wwPg7wlj2GmbsH3+M7AkHsl/xTQ6Se4eG2Et94fIpcPr6wawJYVPcwJP4bBMFO38bUXmgBpWCbhzXdH + WG+puym/mghfeMwR3a/O1Vsvz80NGRG7Pho3NhKpR0rRMJBsGGQUp5J7Li9aEECUK43BKMV6K0MQ6geR + G8JkepTSEFJprvUdW/P9YgBgaim2FiIXjMWWEOGs6wTuIIgpk2maaRmEme4PU0i1RYLQITwwDt8VmGuY + 0Dq6L2EwBDDT5Hj0VFEFaJr8nqQ6SRWWNyO881EP/88/bODH744RJ4fi1migmNSjlNJKKY3dOftijQnI + fuubbOX8B0dq8/OfDrPUHgZBdTwakQMDUmok+SSzofQDE3/bIMkJtlWssxAM9ztML05zLG9EePujPtY2 + 5QN7ITsZl8JqjqNiiInStF/p9QOjsGkSji24+NUXZmFbHFwQfvjTITba6iCmXwLIBBA8XvFbzzWbt1+Y + aXa6ScoXXCepDEMxSpQYjKRYa8fs2nJAlllhnitA0DpOJPWGKYZj+Vn1I59171up+ik9uLfPE4eychNX + iECJQSxcdN2xx3lYVKpDbnRydWM10s8/qUgIdijJAEMQqiUTJ5ccEAb35UZWywzPPOrj5FEfJc/8TPBQ + qhC8m6tjvPluG//p79bx4/fC/dI2DwMACoDMtZaZ0koXCq8xGY01eZNWMzNso9Wu/Uq1mlZKpQxCRGmS + QBkM0KqYybi9kfW92X6aqoGafr9jAWVfoF618CCDWzv9FNeWx3j/kzFydThJoDjWWNlIMBrnaNQULHaI + scAE9I4uuBCCYJoMWabx+ptDjMM7Rs9vEX6Zx1lwrlLqLPn+mi3EhicVW/QcNC3DWUlyu91T1jsfBtzg + q+xf/47GkVkXnIFurYX6nY/6FIw1JpOgHlB2SLOiZXh792UQ3ZMFEIcowJITMouzaMGxQ0+wmAGp1JC9 + Ya43O4nO5UTC2J6ikb2j+/cbYb/n+mTQBBZnLQiBe3Ivt5T/3Ekbv/blJk4uefDcSQ8K3Xk/SmvkucYo + zHHtVoB/+Okm/u6tDt69ED1ULHuA8uclIVJHGKnFRUZF7K+mvvZkKorSZ86eaTu+PwDnFjeESrMMGRmA + VjCIYLGdlN3dqv+2dFoQYBZ+KSK5AxqNOsPSgo0zx0sQnOGOhp/9nt3kTtNM4tbaGBevDXHpenpoxbbj + SOPSjaiYY5jpne7C/bY72PtMP0u2aCc8XJhx8OWnGlAaaPczfPhpjMFIbaWcpxMredng6Yxrh3XbHAhG + bd801MlSiS+4ffdqkLiBUtbVWxlb22zjys1AnFzymG1yavcTeuPtIcXFfAR9r277njBEM0AZRNLlXHJi + k/0VtL4XN+DhAIB2CbBiRJnNeTLv2lHZNGKLsTRUSg5GUnUGSeG27WUe9xtRfw8/M05w7IIIrFUFWp38 + M5W/5DE8+7iLb748g9/++hzqVWtvd9r278iVxjDIcHMlxPd/1sI/vt3Bx1cibLblYSn9dBwpNZA2HDPy + TTO0BI8Lj2pq99it/1gq6UuXLjefevLJqlUqj1zHjVOZ6zCLKMwEDMbgGQKmKGYfyKnMyX4j8QQBS46B + mmUiUhrXRhHiSdngiSMWji96mGmY+6fcDtheQAO4tR7hrfe7+Js3e8jl4aFlmgHrrRRJureC8+D7uV/Z + AhXyNduw8dKXmkhTjb/gy/jwcoRW5850HSsmuWqAcgJFFmPRM80GvxkEzmaUWO8PIqYUVBDq8lvvR9aP + 34+2dtZmtFMLsqtl/H5kiRGUxZGXTSMzGNvyANS9kD+HWQGtAOSMsdQVRugZIvQ4pWOFPIqV6o8y3eol + uuQLiMOYy41iNsDirIOnHrHx/Z8E0OpgbZtrcvzuN+r45ldm8NwTdczUJsq/76xPjRsrAd58t43X32zh + /MUxOn1VjNI6YK7kQ1r/DEA075jjhmUGDufhVgppOgSo/i//k179H/57Va1WO1EUQea5PwxGbkoaQRpj + lBqoWjZmbIZ5S+BqmhbDZGmr5WLKzBFgEfBc3cNX52cwY9v4/soGVoMYMTQcm/D0oyU8cbYC1zHumXWX + SmMU5EV69KMBVtYkDvOQucZ6O8PyRoRTx3yUS+JQOKV9lUMQZhsWfvOrc5htWvjrN9bw/Z/0cPlGTlON + vaKX5tatYOyujMferG2bnLHBout0vnVkkQsirbGWnR/GUa51nQB3svnt9N6YW7tuG1PZObpXQ2IAyudc + ztm2cgWXRKQmz1jv6rU5bACo/fs/1r1/871pkirnRHHDtsIFxw6bpog3M5mNAqVa3Uwvr0dYWnBhW4fz + gHxP4NQxH7/7a3NYa6VYWc8QBAXsCQ7YNlDxOX71xQqee7KG5x6vFQMa3Lun/nJZdAtaJseT50o4vuig + M8gwGEr0hhm6A4lhIDEaSyRJsVXUAxBc267/JI0UzjjmqOFYgWOIrQ1EFO78aPnCSy9+aDqusgRP5hYX + bpLrnh622qLDGEwouIxw1jWRJgluZwoZ7a5QFQSUBMNXZir4lfkZzDg2WlGMG0GIaEIenjtp4tiij/kZ + p5h0i4OyNzvXtQaiWOGDSwO8+W4b5z8N77X0956JUqWB4Ujhpx906czxEpo1G7ZNu/szDjHfLDihWjHw + 4lMNlP1iaOp//rtNfHQp3d67IZDK+1mrV6tbZnPGttvHS6WhYDQ+UfLXfuPoYjLvOsHPNzvtC71h82YQ + lwKlbQ2YBpHlMOYQQ2mYyUqqtYcdcLgbCEyHIIoTSVuI3BE8F4zt9Rr13YTzMDkABQ0piNKaaUYN24xK + Bo8BZGGk5WCU6+4ggZR6L115AMG6n2+2u9JScI3Zho3f+toCjs67+PjqCLfXQuRSY75p4/QxF/OzNmbr + NhoVC6XtEU37fb7ehfwnjviYazhIUoU0U4hiiSSVSDOFLC82idzsJPj4yghXb49xYznC7dUcw0Dt64Ue + 8PAkiqaq8Rnf7J8ol7oLnjfgRGPamcWwK5ZbbDb1uxcuZD/6xzce+71vf/sfypXK+fL87K/dXl0XVhTB + 0Bo1y8KCY6FmCGxGCTajBGEmwRjBEwIztomjnoOlkodZx8Yoy3GpN8CtMEWmNTgDzhx1sNS0UXcFdK53 + vIc73OsdNzxKFG6tjfHXP1zD+U+DwwyXpsMmSAV6/2KAF780ooVZB0fn3d1TeA8kAnBXADvovYwIrsvw + 6KkKDIOT7xn6P/71Gt77MCYUg029T4dRvd7qLFRMc1g2zXHZNHJbiPFx349qptk/V62s3RqNy6049GOp + bK217Qnhlk2juhrG8391a3Xx/CDS+e5WYHwGCGgA0uIsK5lGyolSNrW9Gj5LEg8ZADQIioEyi/PYN8zI + ETzmQCYVVJwo3R9lOs0VKQ0w0vf5/PcjPwHL5JifsVHyBR4/V0GSFukm0yjmtzu22Nq05ICUkd6XL3Bs + DtviRb22nmwKOdl7UOmidTNJFF76UgPtfoK1zQg3V0JcuTnG+YsjrGyk6A3UQUM4t5Q/AxBxosGT9XLr + ZLnUnnWcHhUFJNvTX7fc/63/PL+wsD4/P38GgD52/MT5uYWF4DKdt3ppCtJAphTqpgVXCBwvuVjyncJX + ZQROHAYjlAwDJcPAKMtwfRjg/c4QoSz6vKoe4fGjNo74HGaSQef5ZLjOFOG2M6QSxIBMARvtGG+928YP + ftLF8lp+GFmSvVzJ1hqw67dS+v+4e68mu67sTPBbe+/jr0+fCW9IgiABuiKrWMUyUrWkVndLPdGtUISk + p54Jqf/ARNTrROhBrYh+nmg9zMNEq6cnJnrUctNSyZRYVSSLLHoS3gOZSHO9OX6beTj3pgEBAkgkWKw6 + ERlJJC8S956zl/vWWt/38YU+O7AY0EzDheuwezzPh2F4Np+LIfmewNEDZVgWo2KAbJlduJJaw9B4A6Xr + n3bD1KL1xOY8fWV2Rs64rnQ4H0x77qBq2xvznu9EMnek1jYA12a8xIlmb4xG0XvNtrCHiSu1mUzy3a8M + 2DxDLqek7jgRZ6wQEtmuIkQ7JncfKwZQDAQBORGSsm1HvuCxRZQmxsg41XqjnZooUUZpTYzvTfuGqDjY + VWGhXLIK3MNgh2LLo/xu2gQtPwvQlnygXrUwP+Pi6P4STj8l0e1naHYTfHi2i59+0sMHZ6LtS0J3LlGl + gmi46IrW6en6+r5SsBFYomeAmLY8+Q7jn4DhtXq92+/3S0ePH/tgYWnxhqiWG71Wl5RJkWmFSEpUbRsB + F7A5g8UYtGHgpMaYk0GqFFajGOe7A1weJptp/MsnPJzYH2CuLMCkuvs6ybYbK7XBSjvFuxcH+Ls3NnD5 + er4rYs17RTgUWGbOiRQBkMaIYWisj86P+PFDQ7Z/IWAHl3w8btH4wglwHFwMYAlGlkX0F3+/yj46Fzkb + bV1eS6V8vz3Mpbmd59rIr8xMyX1BkNmcxzZngylu6wZsMgYcMA6ByqlSYT+zbYfzKZuxRqRVGYUEmsDn + b1lsTuBWBU8OBl7kCRHzLQegH38X4C5lwPjgJjOuE9ZsK3IZpakychQafX0lNqNIQioYy9rjR0WT7uIX + p4tH48Ukj3N4LketUjiDI2mApSkX+6dcLFbb+NF7A1xb2xyE2QT+CIhrgvVenq1tPFmvrs94XosTDVDs + OKtxVnW3h6hq9Xrn6pUrx55/4YWPnz19+p/Onj37zNs/+LFtcolUaURKoZdlCISAwxhcLuByBl8IVG0b + JctCO0lxbTjChX6ISBsIBsxPcbx2uoYjSz7Kvrh3YJyo6WiD9U6KD8/38f2ftPHjn4Z7afwaQM6A5IBv + x/O+k5Ax+LQXuUOl/UvXEueDsz1rbtpFo2ZTKRDEvoBn7nkc+xZ8fNOeI8tirFZdF2++N3RX1lR1PZP6 + rVZfG0BzgjYGal8pkA7nKWBiArKxaI4FgxSA4IxNuZz3PE5hT2K7AbN7pCmbzlEQZVVbxEuBF/mcJ4Io + /1k4gEkJUGQAhpI5zwvrjh35nCV9pfMw1PrqrbED0HdC0nvwr9ND/Hwvfs/maM4YmTIGpAxsbWAxgyPT + DspPVTHrMSzWLXz/nZ755EqGTG4d7Lpg0Yma1//W4lzrQKnUKttWn4olEnkPAHATB7jdaq1duXTpNICz + U1NT/3DgwIHf+bBSmo+6feSmiO4B5whzCUdwlIVC1bLhCwGbcUhjcHMU4ko/wu24qFNm6hzffq6EF5+s + YK5uF/Rdn9f20Qatfo4PLw3w+odd/NP7IcLE7N152gJIB09Wg+6zU/WBMcZ009vlq2HW6PZ0+d1PBn65 + JDA77fKiYyH2XP0Xd+E8dWyOxVmPvvHiDBybMd8T1g/e6no3V5QZSI13WgPjc6al1kbB4HC5rC1Gagv3 + IQ2AE2jkCT6o2tawInh8O5UZbaXwn3cDhC5CAAAgAElEQVQiNQDpMUoCIaKa44QWYwltOYBHpwR7iE4A + jUsAPRYyzCqWFVVsK6zaPF7NZJblRm20c9MbZqbYw99N8+Ye92ObLzGmoFdKUoUwlpC5ht5mRoVgI4Pj + cHgOh2Wxz5G+2o4TFUZuJgZfAAMwyhRdfK2L70rDaA1LA/MVgdKxCuqBAIEwCNu4taGQZEYDUDWb54cq + pfjZ6cZoynUiQZQZsxn57wdpD4NSae3ChQtPnHzmmXd/8tZb/3DymZP/5ic/etOF1pDj4yM5Qehiicfl + DIFlweIc61GCi70Rro1S5AaYqTE8e8TBd19q4PCCB9/9/I04qQx6YY53L/Tw9+918PoHI7QGeq/MDdsw + knDK5u3j1dLtl+emWwyQK2HYSFQ3uxHn+vK1nAKvT2VfUKVks4NLPjyXb2MJf8AoYD7njNE9Sk9BWJj1 + 8cppRkIwrrWx/+ofu+j2NHWlMq+vd01uNEljGAPR/lLALEacEQ3HCj+SM0rLlhVOOfaobLEQW+y+W7Xa + TnRyR/eoIlhUta1R1XaGbCcRiMEXXgLQlte2OY9rtjOac53o3ChNlS4owlbWEnPiuKT6hIn3YfP8z/m5 + VMXwTquT4PZ6jGu3RugOMkipxu1QgiUYKiUbc9MuluY9zE67qFVseO4dnPdmPIenDczEuLWGUbqY0VO6 + +PPEGdzlVjMCyh7HkQUf337eYKWV4q1PR7i8LEmPVVUZEQkiTgX794QGS5ith0jdf/fvUf8/duIAi9PT + 6sbq6tkfvf76t5988skLv/Gbv/m/E+jk+bNnT4+aHRLjpSubOEpCoG7bmHJdlISFSCp83Orj6ijFUBpY + DDi2aOOVpyt48ckqaiXrnm3SgsZKozPI8NGVIf7ix028cy7CzXW9l5F/0srKGDA6XvWbR6rlW0/UKrdt + xrLX4rnpfparQT6gjlT8wtWUJ3mT5mc8YYsZtjTvw3EmToAe8mg93JlknGhuxjXPn2yQUoa1e7n9D28M + KcsMOlLTWxsDliotMqWtV+dn7Xnfs0vCagpGQxA0B6lAiGjKdQYVSwwEIVQGybgdyO/ypvR2ALlm8dGs + 5/bnPG8oiBIQcpit9P/zAMC9cwD02Tfnch7Pem604DsRAZnRUHFszLXlyETxuB7ew4LNaKDZTvDB2S7e + eLeJt97vYXktQ69vxqSWE8lqQrnMUK8yHN7n4Ttfm8LLp6dx9EAZ5UAU0KsZR/Zcw+QKyBWM1GO1+odj + NSiAI4bj+3z65RcbZhQr6o1CttHVop1I92p/VL7SH9QCWzRs7vZZAeJM7mo2iQbdf/fvC9GHbY7Asqz2 + 4SNHrl6/du3QocOHzxw5dvSvTj136ol3X/+xz6WCzxmqlkDDcTDreajaDnINXO6PcLYfYSiLj7J/1sKz + RwO89FQNUxUL95rTMqZYiFrtJHj/Qh//5e838MmVFJ3hnsvWT8C/dMrig1ONautotbJad51lAuKX52b6 + a1FsemnOPuiEIooNv3ItY//1r2+TYAZfPT3FDiwEcD1BmyQmRI8NHmKcaG7aw3MnG6wfSmp2cly6lvj9 + vkFbKvZWa2h10twZZNL92vyMe6RccuuOsy4YjQoyCEoWgqA753vtaSvqrGeqPB4Mojs6Apv3BUAkgOGU + Y3XnPbdTs0Sf0zgDKPg7H+ih8L24Ad979sUJt/JklNESjErtJG0sj8LZj3qjaQ2UjYbzxFFXPPd0jc00 + XGKfJ5z2EF/GAEmq8P0fr+HPvr+CP/9+GzdXJKLYbNKFTZINpYE4Nuj0NK7cTHHx6ghSycIxOByOUkCc + w0Q5TJwX+uJS41FW2YgIghPqJQujWKI3yrC8IU2ijZFaK0+QnPVd6XBuJuJWrDi6oE3y6uL7955/CX/0 + wbsAgP/4x39s/rc//MP4/Nmzz+/bv/9mvV5f6Xa7r63cuDlLo5BqloVZz8Oi72PK85Abg2uDEG+s9zGQ + BgaE6QrDa6dK+PYLdbz8VBWew++lhI4017i+HuFHH3fwf/7NBt48kyLJ8DiMfwKSjp6bKrW+tTR3++RU + faViW+sM1A2ESAVjKlWSd5LE6mTKlhrW6nrONzZCcqGoLEBlm4FjslI14Q/dJlqIvftijOC5nOoVG1pr + 6vQT1hsonucQmTFOK5XOxf7Q1VpZZduismUZV3DNiGkAJrAsa5Tn9iBNnfU4s2Vhm+zOmn8yN0JAZ8ri + q1+Zrt346tzctf2lYJlAkxbyRGfyvpqBe+cAipi1qfpKREErSRs3RuHMhV44HWtdBeDuWxTi9FOFA3As + tiePQSqDZifF3/5wBW+917vXDvddE5fBSOPy9QjLNwYYtWMsljk8Pr4xexjYGBF8l5PSBr1RhsvLCcUZ + KFKaXR/EvJfEVjtJnERqhzPmeEIIRjRRgduB/m53Av/r976X5Xnu3Lh2feHI0uL5XCkm8/zF/vUbwbRl + YTHwMe8FyDVwvR/hzfU+WgUGA1cQvvVcCf/q69N49dka6mXrnsaf5RqXboX4x/fb+H9+0MYHl/K9Dqjb + a1ZDQG4RJb+6b6b3wsxUe1856HCiPoEiRpTUHFsxIuRa85VRLCKlHQPwtZbi6+2EQStWtRk1HAKlkihT + MLLAawgAMRqrcu2dGygk0Cyan3UxGGbUH6as1VbcGFgasEOlnZUwtpWWwhOcNRzXeJxLAqQrhPa4MIBG + N0nQzSTUVsSfGH4CYERAN2B0+4VG+frX5qavvjwzfaNkWWtjzY50ggHcL/1/HA5gMwMgkNvPs+pKGE5d + HQynO7mqGcCfbnDx7FNVNj/jF5t4k9zhEb6UMWh3M/z04zYuXo3Rf0gwKs0MWj2JjW4CRwAHZl34Ln/o + FdgHKQcYIzR7KS4vx9Tqa2YAESttXx/G3qftQelct1tZC8OSxZkz5TmWYIyPsZIda8Hfe/4l/IcP3sV/ + /OM/Nn/4R380HHQ7B6fL5d5stXq93+2ejJrNI7U04wt+gFhpnOsO8F57gGaqCoTREF552sVv//IsvnKi + hpmac1fj19ogTBTe+LSLv3yzib99u4/zN/K93Ia8W/FtCNCCMWmMzmOZ51Euc06kypYlGWO5xSirOras + 2JYWzNClXsilMcIAvDvUrDPIKExyVi0JqgcCAiDkEiaTMEnxHUrv0AqgPUhIOSdUApvKgYUoyWl5PaHh + SE/ou+xYa3sjTu1EZoIRaNbztCd4zoCsbFvpvOelSyUv0Vpm/TRPM20iXUT8IYAuB5plzm79+uL01V/b + v3D55ZmZq/O+t8yIutiK/vpBov+eOYD/8Ml7+N6pF7fTFDEUohfljTieujoYTa8keZ2AwMCI55+psH3z + PtUq9pbU8WdUgLelag/wcyLgkwtdXL0ZPSg7744rl0CUGiSpxIF5B/WSfc90+BEzAdroZri1kdLl5Zyo + cJoiN3Ajpf1OKoONKC6vjsKgn6YeESxXcOYJoYmKLgsRDBHM9154Cd974SVCvSrdQwfl9ctXji82W8vM + tnOS8qu0vl7WytDZ7gDneyHWEgUFQtkjPHPYxv/8L+bxladqmGs4d637pTJo9TP84P02/uyHLfzkTIgb + axKZxOO8tvQTjUE/k+zWMOSX+33r5nAkYqWo4Tq5I3jiCZFULCudcR3pcWO6SUojqViuwYeR4b1Rzpq9 + lCoBp0pgwbXHyovaANJsOgNMHILU47N0nzOHe59FGpcDgW9RmmmMoowuXUtozNTDAYhEaauX5lYoc66M + oTnfzW3GMpuxxBMinHHd0fFKZfBULegdDJzugcBpHw689acq/srLU9Wbv3146ep3lxaunGzUr0977orF + WBvACIRs3IV7oOi/Zw7gbk6AQDYRyqtR1LgyGE1fDZMGgFKWG+sbL1f5of0l1qi5tCMD2H4E7gbg3uvn + 4+vTC31cvRVhdX13JzSXQG+kUPaB+Skb9fL9e+G7SQMGoaRmL6X3LsQ75MMNYEsDdyS130qyYHkU+oM8 + s23Gedmx4FtCbeMJMJP+Jz97nuypRn6z1zvm2XZlsdvvD/L82Y3VtQNn15rsQi/EaqKQGYJnEU4edvBb + vzSD107VMT/lwLLYZzYu0kzj5kaCNz/t4r+93sJ7FxKstjVy9cUY/+QcZcbwgdRWK5F2O0ntbpqwKcfJ + G66TBMIKHc6jkm0l876XCzI6yTNqp4qlyrBhpPl6J6d+mJJrE3yHk+9y8Elqt9nS1YDUMJkCsgLwLdo0 + 41bOnZnBfc4oESAsBi4Y5bnCWjui9Q3Jxs6eG0BEWluDLLeGWcoZwUy5bu5ZIrEZj1wuRjXH7i36XvfJ + arX14nR9/ZXZ6duvzE4vvzDduPFkrXZj3veXy5a1bjHWRcEXuZX6/5c/eeD8jO/l0xs7AIwPtQMg2EiS + 2koUT5/rh9MaKEsF59QJnx9cKrGZhkt8k951F9rzk96/NtC5wqUrA9y4FeL6Sr6r929QKJpkucTitI2p + qo1aaW/XTYkIcabQ7KX44FJESWbuVMKxNODE2rjNVHr9JLVzLTkjoObYKrCsjAquALVNFkOwCxetqWdO + WuvLyy+x6zfyDUsc/XDl9pPvXF7m64lCogHfJnzjtIffeHUK331pCnNTDmyxcznKGGAUS1y4NcKPPuri + b97u4M1PEgwi8zjS/rt5ALI4IXAZeQ4xY8C0gZAGYqS0CDPJAkH5YuCHVcceOZyPLMaism0lDdfNBUEr + naOV5JQosGFs+GorpzTPCQS4NqeyJyDEHQ/VTFq/psgEMlV0gOS4BTx+dg96VokInstABIqTHOcuh8jz + LQJYA4hYazHMcjHIUuYLrj1L5IElYotRaDE2CiyrX7HsXt1x2lOu05xynY2642yUhdW0Oe8yoj4KZa5s + N8b/uBzAdspif5DntW6STr/f7k3nBlVt4OxftMWxgyW2NO+TZbOHxwAw7s9LDaQSJs6hwxzN9QjLqxHO + XUsfCb/rjwyWZjj2zbhYnHLvTYe9Sxwgzw3agxwXb0VY66rtOBTb7ggMYPVzZQ+zzJJKksWZmg+8VDCW + MmJyvIrHQOSAqMS6vUriewfPXLw8/f76+rHzg8Hhs9c3rEwDjgBeOeHhuy818EsvTGFpxoV1h/ErVbyv + j64M8MOPuviH93p4+0yKJDc7gt6eIn938CucOmrh179apt/5Z1P49vNlOnHIYVWf2DBSfBgblmmDXMls + f9kL644zqNj2gDEa2ozFZdtOyrad+4Iri4wepDmFSrMkA1tpSZZkOeVSE2dEgc9hC0bsXqjnpEyQ4zZw + pgpHMFmvZ1vVK+5RFQjBIASHNobOXu6j2Vbb10uYAUSijNVOcpGrnFkMOhCWrNh2womFBESMKOREQ040 + 4kQDTjQiUEhbhr85Nfqwxr/Xg0B3DnIoRpSVLBHXHTtyGUsirXIi6NWN1AwjWcyM04NOaZnxUI4Zp2sS + JpVFr14qcKkxW+aYLgvYgjYP7W6uJDe4vpZivZsiTBQqwd7eJtfmqPgC01V+Z3GznRaqYAoG6HqYGbbR + UzZn2f5SED1RqybcIjlmkzHGwNPGNNaa7f1vra995WoYmndvrXhdKZUygMWAb5zy8N0XG3j12Tr2zRbG + v/32ZpnGWifFexf6eOtMDz89F+L8jeIZ2QTMezYybTDMFcJHHPZnBJR9wr5ZgcVpC62+xI3VHEkGnD7m + 41vPN/DCExWCATrDnO2fHQghus5fvjEKMmOqFwbJzKed3vS+Uqmy4PuWxVgOUOQLkR6rVnKLsbRkW3HV + tpJ/XGln7Vxlw8g03vg4KXUGyt3o5qIfSv7csQoaFYvuWeaZiRMoCA1NpkBWDrI5YAuQxQHBQJztkB2f + 3FTGCNWKjf2LAZ44HNCZ8ynGZQAmfX4FUE9pvNnsGyJoTqQ9wfN9fpASbSL/W/sBZgdL1K4N/3E5gB2D + HATkDuNpYIm4ZPG0q1ROBrrTy00Y5SbNNcr3+03jSTsjx144L1KzwiNPhnOK+172RUFiWWW4/Yi76DfW + Mqw0E7T7+Z47AMsq0sPAY/eqgbevghoN6BtRnlfbg/j9amsw53sjm7PcYswyAOVaV3pptvBuv3/8I8L8 + xU7Xvj0MZ6WUtsUJr51y8etfncLLJ2o4OO8VoprbgLYwVlhuJnj7TA//4ycdnLmeYqOrAQMsuALHKh4q + joNboxiJSh5Ace7el2MBXz3p4vSxAMeWfNTLFpZbCb7/dheXljMcXXLxxP4Ac/WCNaZRsSmXhlbbKf/b + t0M7k8aPtK5cG0S1XpqWpdGOVdhUAiDzhZCHK+XMFyKt2XZqMUrf3eglN8I0GyVm+qNLWbXV63nrnQy5 + 1Pz0sQrm6jbZFrv/iZYKRimYTIK4hLEYyBYwNgdZvHAEjHZwXtoWQ61i4/jhEog6wPYF020JVU9p/ZPm + QPmCS0+I3J0T2ZRj56yY7Z+M96qxEtcm1/ujGP/jcgA7NrkcwZOSZUXznhOtJnmmYORgJHW3n5n+MDfT + deeeY2dG6S2jnyC224z+zitwBRplC4vTHCst9Ujp6o1VhVsbKVY7KfbPubsSxbinA+AMns0QuOxuo+d0 + x/NxAAS5MY3lMI3fWmsNnpmuDwNLyIptB6nSvBnH05+0Owf/aTB8YtV3py7eWvcZo3mfK+u1Ux5+4+tT + eOXpGpZmXHgO35Hy98Icl1civPVpD3/+ow4u3cqR5AVX4OGSjacbZTxVr6EZp1gNE2T6UQaigNPHbPza + K3W8+GQV+2c92ILh5kaMS7diRKnBbM3ePo9AlkWmURY0V7epWiLe7BkHgDfK8yCWMkiVcn0hxHg+MyMD + 7XKu9pUCWbasNBAimXad5L1mJzvbi+RGpszNdYX1zsiTyiDJFH/hiSqWpl1ybPaAoc3AKAlkgElyQHCQ + zUG2KLKDiTMgAueEUiBweH+AepVhONJQaocTsAD4AHRHKv1uqy8txvKybadfmZ5KPSHyMdvvZD9gz4x/ + zx1A/U//xHR/9w8mA1faALnDeVK2rPBA4IZn+mGSKpOPRlqvt1I0OwmOHAgMbUfZdGH4yBVMIqHjHMhV + gdTe5+MGLke9YmGmJsZZ0+6vJDe4sZ7i5nqM546V4TG+ZwWw4IBjFU7gHhXQnU7ABVDu5Hr6XHcUfdzq + hrOeTxbjw2aS2B+12rN/cfXWodVG5cl+qzMTjRLn0KLvnljg9O3nGvj6qTrm6g4mB9wAkNKg2ctw9voQ + P/q4i798o4+b60Vot4jwXMPDCzN1HK1WwBnH2U4PzTgZk4Y8/GULYKrK8Msv1vDqM3UcXvThORxKGfgO + hy0Ih+ZtNCo23G3RuODr51T2BZtvCNbsZRyAM8ykN8jyYJjJoO44HgwcACkImgwSQdStO7Z+aXY6nwq8 + fKrky9J6U783jNggV5wI4odncxZmXRYmhl59poqDcx7umwnceSkDqPF8Ac+LssC1wNyiRGCcwfcEFmZ9 + 7Fu0cWM5w3Co75YJBAbQN5Jcue2+DCyRTzt2erBUykqWnTMaZwHFwp2p/+mf7Akk+xgyADMWbyENMtLl + LKnaVrTgu6FNSADko5HRzU5qev3MbG4FGhSGn42NPs4LFPYhIo5tEQKXo+RxMMKjCVEQ0OxKdAY5pC6c + LmFvuwFsjH+az2+LTQBVLzemup7I+XfWWtmJRs1NlY4v9vruX19fmX4rSvZVXWtfvzfylqa4++IRbr/2 + bBnfOFVHo2xDCNp8Omle1PtvftrFP33QxY8/irDR2zLsaYfjK3NTeGF2Ch7n+Nsbt/F+s4/bidx15J+p + c7z0lI9vPdfAgTkP/phtSSqDZj9Dd5hj34yD6ZqNOyOxazNUSxYWpgV9fDXjBNijXJeGuayGUjYM0EWx + ex8b21KoVRn5voXphhCVin1ESsfr9YL68opduXHTvdEfoNXu0HAQmp9eisjovkkzje+8wOjA3Gc7Iw+c + 90q9CUzriIN8C+RaEDColS3Mz1hotnMMh595vhNMINAG+nKYSXm7lddtO/6VfUvhwRKPvIIpOh+v3Jvu + 7/4+9sIJPAYHMJ5aI2gDKmTDhYgajhN6nMVM6lxqqDjNTZzmkFLDIsCkEibOgFgWhr8L67UEoewL1MsW + bEFIH5GQMskNMqn3dCR4AmtIpZFKBX1vZH27b+DjVLGUaGN+st7HS3PdCtDL32927Nc7g7pf82d6naFf + 4rn1tacrzi+/UGWvPF3DVGVL+GQy1be8EeMv3mzi9Q/7+PRqjijZKUE07TkoWzbWwwQXe338t6vriLXe + 1W0gAqarxarxr73cwOFFf3PV2BiDKFV4+2wf19YynDwcoOTyO4eSyBbMBC6jSsAnztDtG1MNjZ4PGYVh + vWarRm2UuI4VgbwYqOWA5/heKR4OFj3Linu97r4DBw9kz2glMkukzWYLQnBDnPDTSzFFqaRBKPGbr81g + /6wHx2K7HwLTpjjPuQKiHACB5woWJ7B7Z3x8XO7p3JjGcpJnf3NrfXSwFHQDy+rv435ItLkqfCdF2pcq + A9gs4QvQgjKH83jW90YNR0SdXKWhMrLZzPX67RDd2yM0HDKU5lSMZj6a6ym5Ao2KhcAF0vzRfpeUBkpp + mD32AHGq0RspdAbqfuvq27sD1vjuUk9q8V8v3qrm2uiW0ZZd9UpxlHpC5/TaC2XxK1+psxefqOw0fgN0 + RxLnro/w/77exF+/1Ud3+FmxTgJwcxjj/7p4E9oYbKQK2S5TKSKgXipGjv/ZVxr47ktTqARic9VYKoP+ + SOLq7RBRouE5HEKwuwCHhLIvqFERzLaYcAM78MreXNt3/HMc+5uDfpIO+wNNNJCMZbMz02GjWlEeQKmU + td5oVFnvtA9gecV3la483ajz0ssvWlGaodvrU6/bR6ffx99+GEGjhd/69iyWpp2HLwfu5ulTCZIGbpLB + J3M3g6M72vIOgFKsTePMMF54a6PVmfG87rTjDDzBw20DP3uyf/34ugA0WQ02mc1YXHecMBA8sogykFGt + jVy3V0IzXBmgNuM8tELvvU5cvWJhYcpG2WfoDB+tE6DH4pp7fcWpQn+UY6OjHhRXmKSK1rg1yK+Gqcdt + TrZn8TTOBGROv/xyif3bb8/yZ4+UqLFtsUcboNXP8N6FPv78R038/bsh+uG99egHUmMoi/OlHyEMTFcY + fvWVMn715Sl87WQNtdLOZaNRrHDm2gifXEk3uzjOXYyOCORYDLNVl3nuUEipKE0y/Hityd7v9IzgjIgx + sj0nqE01XL/TrnGpXSdJZp5Y2uc/8cQRdvzVb7DZ2RlyhUAUx7jaauPi6hpurKxixVmFAdDraPzNewkO + zA7w2qkqFqacPZkB4QzwRDGIZfHPxXzYNuC3rICZd5u9xRO1amfB93uHy6UhJvP+BnpCyf+lagNSITFl + xiW4AiAdzrOGYydV20oclmSkIJsdpfvD3ESxNMY4e1JcEwoCjnpJoBIwPEq/ygBwbAZL8D2t/YFis24Y + Sax15MP85k26aMaImMVscKIsyc1MGXTqaZ/9znfn6eThEhXTi9v/PYOrt2N8eGmIa6sZqiWCYzMkqUGa + FRoIY1azB6ORuVtvH4XoauARamWO00c9vHa6iueOlXFw3kMluPM9abT6GX56vo/bLYnnjtlYmHbu0XIl + VAKBEwc9agSGrXWVibWxCahkWgeMaMn1HBZFseiFK8ILPO4HAU3V63QDQCNMUBqM4DgOVKUCy3FxZGq6 + kNUdT+5NPnOn1cFfvz3CQkOg5AtU96IFvEka9bkU/dudgAXAA1C5EWVzH7Q63RnP6cy4TqdkWf0x2PnA + rD9ffAZgDEyxdmEAKIuxLBBWXHWcyOZhglzlUaL1IJSmO8yhtNmzNpvghMATODDv4OMr+SMt85Q9Bs8R + 2NzM35P632CUSHSHOdoPLytOVExOCym1gYQ5NMfZN0+X6H96bZZOHimj7PPPRC2LE44v+WiUBb774hSG + sUR7INEbSoxiiSRTUKood+JMIZMGaW6Q5QW9mlJAnJod2YBggOcWUy2+y1AtCdRKFqaqFg7Medg342Cm + aqPkCVgWfWazMsk1mv0MH14MMYo0Ak+MuwF3zQDgOxzzUw6ePOjSMErEKAcPR6mTpjkYI+r3ws1sjVsc + fuCi1eqgNVUHz3N4ROCMITcENwjgCoGlegMTUS+pFPJcIs8krnd6uHw7xv45v7ifjzgKnuUanV6R8UX3 + 50ykbZhPEBtT/6gzmD1SDmZP1GprJctqAQixNRuA7u/8Pu02C9hzB1D7z//JdH/vD2iirwlAcaLU4Tw6 + WArCM51+vJLkmVRQnYE0y80Up47qz4yl7toBiOIwHl5wYDDavdkaYLYuMF21YLG9ywHiVOP6WoyPr4a7 + mlY02tA4r6Hj+4T5ta9W6bsvTeHUkQoCl901ZeUcqJUFyj6H0gZSA7nUkNJsljnj1g2y3CDXBYuSVMX/ + 19ogG7MqTUZhGRVDLqCiRvcdDsdmBd+izeBaDELQXY3HwKA7zHHxZogrtzPksvhdgt+bxt2yGOplC6eO + Brh8K0H7tiQiIEt2OgoQgTGFPJXIMgklFS5ygSnbAuMMUwRYSiEIyihxgdlyBUZqyCxHHCWIoggbaYLz + N0OcPJSa/bMusUe0EqkMhrFCd6juB0zfrRQo3U7y+s0wmr4+DOsHSkGJEXPGo8DjVVh8ySYBjRkLSRTN + EUaUOZzFB0t+WLV4QkCuDVSrr8zN9cTk0pC5j4bZg9dbBN8VBbUVox2EoA9zuTZhccbG0owDy6I9cU7G + AKvtFJduhfj0arLrNiUBeOqghX/9Wp1eO13HUwdKKPn8c50UZ7QDZymo6e+eoWgzXrCayBKPf7b99YUT + oE06ds63jP1+9yqXBp1BhkvLEdqDortwP9RdMELJEzi+5GO61sdKU3/GgU70D9UmdpOAiLBmd3DFdVH1 + XAjLhkMciebIXRtlJtAIAuyvNrBW66PT7WIwGOLq2hC3NjIcXZKYqVmP9NyVNggTifZAIc0e6PGabU7A + TbQpr8dpbT5JPEsAACAASURBVDWK6lqjzDgK8RCzJR/35XIAW8ZvAGhGyG3GkhnXjUqWiO2xWMgw1LrT + zyCVxl5hbYwA12Ko+AK+QwiT3WH4Tx4QOLzgYXF6bwBKbYAoUTh/I8S5G9GuR5UtDjxxwMJvfWcKX3+2 + hmNLAUqewK7oVe/ylybMpOCPT1+hH0osNxOcvxkjl8Uz8xxe1OOf01FwHYYjSz6O7/Ow3pW4fhfh0Ukc + MdpA5hppnCIcjbDR76Pd7aPi+cgYh9AEpQPAduAZQsUSKNk2HMeBZdtodziavRSDUJqZmvUoiSSkMghj + iWavKK8e8PFMMB9bAX43zSvNOK4N8rxcY7bHiQQIbJM/+kvWBZicrslOgOTE0pJlhSXLikqCpUmuZJJr + PYikGUTKVEsGgj96nCUqwLtaSWBhmuPqbf3QQhUWB5484OHgnIepir0nkT/LFC6vhHjvQh9nria74s+v + +IQjiwL/5tvT+OZzdRyc8xDswvh/lpdUBqutFBduRjh3Lds8KpYoJMY+77PYgmFpxsFzx8tYbadY2Yjv + zk8wkWtQBjKTSKMEvVGIQX+AuByAOTYi4lBGgztjZlStNzW6OSNo4pAF8fPkHO/qNitlMIwkbm0kGEbm + YTLJ7UNgTivNg9tRXL4dReWyJVzOeSEgWhQAu1ZEZY/L+OkODnNGSAPLiiu2FVUETwyQR4lRnaE0G90M + udy7dptnM0xVbeyfFRC7WHg+uk/g9LEAB+Y9eA57ZONPc43b7RT/9EEH75wb4uKthx9QaJQJXznh4N9+ + p9jlP7Lg/9wZP1Dci1sbMc5eC9HaBoJOEHLzOR+Ic0I1EDh9rIQTB33snxX3jLqTm6+kQZbmGAyHiEdD + pGEIFYbI4xDJcIQ4jpDEEeI4QZZLKKWglIZjESxOeFQl+yzX6AxyfHQ5etjouX093G5mymsladBOEl8b + 7NQPpAII/NI4gPp//k+TjH5Cs6AYUVqxrajh2FFlohqcQHeHyjR7RRmwV5drM0zXbBzf58J3H7x+5wyY + qzN8+/kKnj9eweK0+0hkIMYASaaw0kzwxidd/NWbXZy9lj80q850hfDqsx7++Vcb+LWXZ3Bo3ivoyvDz + d/VGOVaaCS6vpDu0OMJEQ2lz37loizMcmvdw8nAJTx924dwrO5+0NTWgpUaUpIhGI6S9HmS/j2zQhRz1 + IYdDxOEIgzBCNwyRpCnyLIcjAM8hssSj1X9RqrDRS3F5OdktjkQAeGaMlSntpEo5GmYiH34/AdGfXQmw + LSfRACQnyiuWFTccOypZPGFAHmdGDUZat/uZyXJDe4QDQgiGRtnCqWNlvPHpCGku79t+sTgwU2f42skA + 332xgWNLPkoueyTjjzOFW+sJ3j7bw//9j02cvZY9NJ9eo0z4+ikfv/JyA187Wce+WQ/s59Hyx/fk1nqC + 66sJVrdhIMYUw1H6AWIAEVAJBJ46WMJKK8W11RRnr+efgyEZKKmRJjlGoxGioY+65wEwIKVh8gxDw7ER + hdjo9TAKQ6RZhrmKQSUQkwyQdvt5u4McV1dirHXkbs1oQh7CMq15KCWX2jBtzE4yE/qSOYCxSu9ELUgT + IbcYS6qOE5VtawIEqijTeq1TqAZLZWgvOPgYAYHH8fShEl45EUDrES4v353MkqiorffPCpw87OKff3Ua + Jw+XUStbu47+xhSe//JyhDc+6eIv3+jg3QvpQwOdRMCpow7+5avTeOXpGhamnD0nKf0ijT+XGuvdBOvd + DN3Rzv2DNNeQSkNrc18AkjPCgTkXLz5RQbufoT/qY7mp7vnvamWgpMIozZFEMXgYISDAAYFyiYEyuNof + YqPdRq83QBJHOHxMYGnGRaW0e9IsqYt165sb8Y7Pu9uYmmnDRrlkudZMG2xpID7Cr368ICBt4rIKgCQy + 6WLgx7OuHfuMskQZOYqMubicmn4oMdvQsMTesJT5DsfRRR//+pvzYLQOY4ZYaRZ9WGMKJ+HYhFqJ4YkD + Nl4+Ucarz9Tx9KESApfvagTUjGvZONV4/2Iff/fTNv7upwNcXpG7cv2ORfjaM1WcPFzGXMPZU27CL/rS + xqAfKdxcz7DSkrgz22v1cmz0MgxjhakHmMGv+AKnjpXBOTAIFf7shwMk2bbWJQrCtE2qP2mwHsYYBQns + LIObCHCK0AojXIxinBsM0R+GGA5DeCbDiQM+FhouHqUCaPczXFuNcfZ6DK0fObulXBvESkGZCSUAfSbd + /hKWAJsqlxqAnPO8bMqxc4+TJAUdpzBXlzPEqYRSewcE0ri19PzxMlyLcGTJx/sXB7i2mkBrA8fiOLLo + 4fSxEp45UsLhBQ+NsgW2y4lEYwziTGOlmeKtT3v4+3c7eP9iXDDr7PIGcla0vhj7+TX87SDfYJThxlqE + a7c/O6H5ydUc750fYrbqoOwJ2PfpvBEVuwNPHijhX31D49ZGik+vpegMdmYWtC0L6Mc5NsIIt4cjzBuD + tX4PF9McF+MEwzRDEmVIkgwvPW3h8LxzT6GUBwU7z98M8c65AT64kO1F5mYEI7ico+DRvb+A6c/MAXR/ + 7w/I3IFkGoADxH0hKLBslG0BZMpMVlT1Y1i6ISoGTE4eLuPQgo9/8bUZ5FJv3jBbMPguh2uzYlVzN1F/ + XOuvtlJ8em2IH3/cw3sXQixvSPTD3TPpFnWxwQ8/6mOmZoNAmKlbd9T/xfANH/evGBEEoy9dmVAIihrc + WEvQ6kuM4s86xSjReP3DAWolAcdhePJAcN/oywioBgKnjpTxv/zLJfzlm028cy7EzTW1JTE0AaI0EOUa + 53ohBlKhZAm0tEZPaYzGW582M3h6keM3Xq3j6JIP3919CbjSTPHhpQF+ei5Eujc6CsZhpEuW0IIxw+6M + +V+uDGAH1bUNwAUoAFDihJIjmOdybhmAGwPKpd5cRHkcTsC2CEIIVAK+ow6fTLPtxmCUNkgyjdutFOdv + jvDx5SE+ujzCxVsZVlsae5HMaAN8dCkBoyYu3gyxNPNZAQ9LFKO3bNxLd6ydE3+TSEHj/578mbOCrkpw + gi0YLMFgW2NRi7FTFHfJhja5LydTgJgwYd/7PmpjiiGomxE2ujlyeffPevFmhh980EWuNKJE4cSBEnz3 + 8zMgzgmNioWvP1vDbMPC04d7+PFHfbxztqAyJ9rqBkgAzTjHMFMQnJCiYP3WIJRs4OkjDn77l6bx0lMV + TFWsXQ2AFZ9V45OrA5y5FuL66iNZ/2YrXRRkoapiWcomptjWrs2XKwPo/t4fbEqlAXAAExigrrSeHeT5 + 0tXBcG41jGv9TPpUUF8zbTZVrx7bxQiPXIQpZRCmCoNQotXPcHk5woVbIS7ejHFpOcX11b1XzWn1NX5y + Jsa12xkaFQbOd94qLgi2KIgmBC+cwPZzuz1V3HR2RBCs0LKzBI0dx3YHwDazoolxM6Li9RYbv7ZwEK5d + vNZ3ip9NjGbiXA2AQTjWGfi4h5vr8p5Z0Sgx+OhyijDpYr2T4VvPZTh1tIzpqn3P3fxCk6/YFnz6YAn1 + soVjSz6eOz7E+xdGuHgzQ3ekkOZFFpAZIFe6cAwo1nMPLwi88pSPb56u4avP1NAoW7sShCmyNo0z14d4 + 45MuzlyLH2T5574+BYB2GUmb88wRIiPa5AOYzNl8OTKAsfFPeO1dABVlTKObZvPXhsN957u9Q5f7w0Of + dPvzzTSvAHAci/j+OYsswejLVurqce2YSY1+KLHaTnBro/i63UpwaTnFtdsZNroaUfr4HNgwMhhEEliZ + nHqzhazckerezUB2ZDyb+AJB8C2nIUTRCiUiuNbYkbCx02DF623B4NgEz2FwrCJ7cB2CZzN4TuFAOCsM + lbHxEI0BBpHEpeUY756PMQw//z51hwYfXcqw1lZo9XOsd1M8e6SMg3M+amVxz6hMBPgux/5ZD/VS4QS+ + eaqOjV6KM9dDXF9L0OrlCJNiscmzCHMNgaUZB88cLuGpgwH2z3po7DLyGwMMY4krKyH+x09aePtsiBvb + SpFdRP7tDiD3GCUe57HHRUQFKcimBiCwe4LQPXMA3d/9fYIxxegiwQVQS5WeXY2ifed6vYNvrjUPnun2 + 998M08V2rmdzYyqeTc7hRcG/+1KdpqsO3W0V9AupUcdPUJtiUSVMFOJUIU6Lvf1mL8VKM8HV1RhXllNc + uZ1hZaOI9uYLeo+0zfDFHaWL0UAOA23ovodUjT+w0mZbtmIe8n1sU8iire3ASdRnDLAFwR4vUWW5QW+k + HxgPySSwvKGw1h5htZ3j1kaK54+XcXx/CXM1G4HH77k+bgtCvWyhEggsTrmIM42nDpXRH+YYRhJRqsbb + h4S5ujWmkCsUoByb72rGwphiwOnScogfvN/B//dWH7db6pEYqbZFdwUg8zmLS5YYlm0rZEQFP+BWFvCz + XQbq/u7vTxQ6JzV/JVFy9upgeOjjdufo2xutI/+01j3QztWcBmoAyrUSeaePOeIbpyrsO883MFtzdohV + PE5ASo3XXbUuNsfiTGEYKoSJxCCSaPVydIY5eqMcrX6OqysJrq9maPY0Rol5oIGVvfcABhYRajbDs40A + LucQjMEAGGYSH7SGGEkNZegLcJbYMcV3t+AVTqjhdlmeGhRk0G+fSbHRlbi+luDZIzGe2B/g4JyL2bqN + sidgWewzRktUlAXC4/BdjlpJQI4zueK5FyvSwZh/cLc4kMHWqO+FmyO88UkP//1HPVxblXt1q4sxeiCZ + dqzRvOcNpxx7xIi2ZwBfAkKQ4u4xFDW9b4xpXBuO9r21vnH0zbXWE++0B4e6Us8DqNVL5B1asJxTRz3x + whNl9tzxKg4veOQ6j84HUCg6mU1AUetipz3NNHKpx4avEaYaw1AiyTSSTKE7zLHcTLHazrDRSbHRVdjo + KbT7GmG6TQ7qZ3VRIS07ZROerPl4aa4BXwhYjCFTBjeGET5uD/ecuWjPMpdHtIKrtxVurY/w3vkYx/b1 + 8dyxEp49EuDggo/Zmo2yL+DaDIyNwci7OYMxXrFXQUQqjTDRuLke4ez1Ed4+N8CPPhzh+praK+M3k+gv + iKKlwB0eKpcGVdsejTOAHSXAz8wBFKk/GIotUltpXRrlcvrdjeb+12+vH36rPToYa7PgWKgvzXD/aycD + 65kjJX7iUMCOLPg0XXPIEg93dLUpADk1juATQ89yjSTTm54+kxphotDu5eiHElEiESYSnaHE7WaO9kCh + 1ZPoDFQhDZ6ZTV5SuiPl/VkaPwGoWIQDZQdPT1Uw57mwOUEwjkGaI84zhFKPCdB+/mcG7nblCri1obDc + jPHTswlOHB7ghScCnDi4lREEnkDJK1iFBKc9I5nZzBzHWUQ8DhrXV2O8/mEX75wb4dyNfC8Av+051Wb6 + 7zGK5jxnsL8U9C1iEW0TA/0yZAAEGIIBB5GTax2sRlHjw3Z37vwgno+1mXFtqh1a4P53ni/bv/TCFH/q + YImmqhZZnH3ucNskoms9qVkLFptMaoxihWGkECUFpdUwUuiFEmvtDOudDL2RxDCSiDON3lBjMNIYRgZh + ajbXg+/VGPjSmNDY+B1usC+wcbgcYNZzMMiSMZcdw3qU4ON2D5kxj7oa/nNxGVN0C945m+LM1Qyz9T4W + pwsw7+ThAIcXXExVbNTKFhplC7YoMgNL0JhxaKtLMWmNTjAgcxdAVWuDVBpkmUI/LPCg5WaKi7civPHx + AOdu5BhEe8ZnsX2DVo+jfDznWsNp1xlMu86QCNG2+v9nWwIUKkAG4/qfARC51l4nTcobUVJrZ6oKIJit + M+e54771m6/N8Sf3B6zkic8Y3tbAxjiqm6LPHqdFT7g7yrHazrDaStEepmj2cqy3c6y2JTa6BcW2NoVy + 2P0exs/FYN3Y+G1usM8XOFL2MB84SFWOMM/hCgFjCN0kRTOVXxgY+aW5PQREqcH1NTVOu1P89x8OUCsz + HF6wcHTJwaEFF/N1FyVfYHHKQqUkYAu2OQPhWGyMo4y5D3URHCY0aVoXugW3NlJcWQlxYz3BhZsxzl7L + HwrU3KUjkCjQ/vB42e8tBUG3atsDFBqI+Y4OwJ9+GViBjSENMGkMH+S5nSjt5MZYAMTClOBP7Avo6KIP + 3+HFmLYBjDFGj0E5pQ3y3KAfSqx3UwzCHDc3Urq2muD67QQrzWxMZGkQbYviAEC/aIFvgvYzjSXPwqlG + BftKHjgB63GETGlMoehjJ1KhL9UvbOr/sGVCs6ex0U3xzrkUthig7Bety0pA8B0G32WolSzM1izsm7VR + 8jm0BoahwiguvqK0KB1HkUJ/JNEaKDS7GskdxKiPA1/dVvvnAOIyY4MDJb+z6PudsmUNCJQYQBa9H5hH + xX3E3rzn8andlAUr5BMnaUp3qPTtVmLWOhmUBhjB5NIgThX1I2lWmilurMVY7xSbYjfWcqx3JHWH2qSZ + ITmO6tunBekX8rybcYvNwGLAomfh5dkaFnwXhgw24gjtJIHF2BgE5AVVFmOQyjwi7v4l94l3qc3uOfsw + fl0mgfZAgwCstbeXfckYHATGYwvQY83ZTQnKbYtEBoAxX9QB2Ez9UwDDoyWndahSas4FfhvA0MAk2BIG + MY8qWrNHXQAYGGMIUIJRWnecqObYwwpPhj2lo5vryvvBB0M+jG7iwJxDjIi6I4m1ToZhlJtRZDAINcJU + myQ1iBJQmhum9GdllH8x89ktZ0owqNuEo2UXL8814AmGWEq0kxjNJEaYSzicI7As1GwOT3DMOBwjmW9W + Y7+I6X7xfWu9bPui2f2M8zMGbLYyhi+P599p/AQMHUatby5Mrz1Vq63NuW4bwAgFAKiBvREIfSQHUKgB + //54+R+KCKnLeXisUm4/P1Vf66RZ4/1e5CeZYTfXpBqGI7dejhgIFCXFcEiWGaM0tNoS4aFicQicivfH + scV8Qr+IB7uI/AaCgH2ehSdrPp6ql+EKhkGWYSMujL+XpkiURskSGGQZfCHgCoajVR+rcR+pAjRtC1+/ + ALdrohzLGDDrcBwueWgmKTYSiaEyMHoM5P38giB3pv4ZgDBg1Hm2FqyeatRXFgN/3eG8C+wAAPfkEnv4 + ITSAzCI2rDl289X5uVux0m6um/TJIMpyhcZGT/vrPW1tO/sa464eAOMzRg2bWxWL2wzwbkWZO1La1js1 + 8ugX5VBvOgAymLIYjlc8HKr4mPEcCEZoJwlaSYxmnKCTpRjmOeT4pPd5Cl8ITLkujlYCwBic7YZYTxSk + GY/lwXy2UruXX7jbawwe4C8+vqxoMv3ICLA5cKTs4OvzU4ilwvutDj7qhYjl9uj+c+cIzB32kwOIBKG3 + 4Frr31qYuXWkUlmu23aTgCF26gJ+OeTBN7OAMXBBhMgi1j5SLtvJvDJV20oOd7rdD9rD6U4mSxqwGMBs + RvA40/8/e28aZEd2nYl9597M914tr/ZCAVWoKgCFfWs0gEZ3A93NnRqJalIcarFGpCV5xqJjPP4hO8Yz + MTFhxyxewxG2FSOPSI9tShSHHmqhqKEokiKbS3ejFwDdjX3fCoVagNq3915m3nv8496befNVoSma3U0M + VBmBQKFQ9V5mvjzbd77zneZQqv6mktra0kRdpWKxIIPm5US3nJ+d4/l4VlY0B5rdSoqHxPjpbQznR/xO + usOBgJCAjqLA1nIJfc0N6CgVUJQCkVKYrkaYqlUwXathJoowH8eoOApiEiOMBYq1KgpSoKPUgB3tZZQC + iVvzFdxdjrAQM2Jm5Hi7f91rWvE9SpXe+Ue4Al7l9vz19CpWTDekNOMgYAw2FdBfbkR3Y9GMF3MCIuDS + 3DJmY4bWBM6Wzf+H4Aj8fr+2kX8ZwFxfMZg42Nkycmz9uuGextJ4Ucpp5LcBvSPp/zuWAVgnoAFKAFQB + nisXQuxsa406isX5LS3NE491LraNV6pNieYwECTaCiE6igVuCAJuLRSop7GhIRSi/X6luu701Ex4v1Ir + V5Rm/VP+JMlG0tVqyNWsYHVwkr38hREQYV1RYqC5iP6mBqxrLCIUBAXGQlTDdLWKqaiG2SjCfBShqjUq + WhuDdhlAFFkZa/OGbcUSNjY3oKNYwOZajNlajFirlMVIjHQHnmZGVNfDUsxItEG5WQMJM7TVdIvtNiEN + 83difzaxyjTMlAKQnDNh+77pefLqN4q9e+QBfkSMUAIDjSF2tjajr6mEmjZqQl0NRezuaEFjIHF5bhmj + lQSajRMwakOU+6z44TN+n+2XwGz6mesIxL3dbc0jx9avu7W5XB5pCsJ7RDb6m6VQ3P6lz71jl/OOtQHb + v/R5nvn0Z93WKhYE3V4s1sphuNDb1Hhve2tb01StVlTMMiAS5UJIrYWQQiGCUIhGBrpvLSwE1+bnu16/ + Nylfn1oIEmbpCYu8pxiAX59zfVpM3vNKD4iazN7/GVS/RUr0NAToLoXoLBXQUSqgOQwAMJbiCLNxhNla + DbNRDXNxjPk4hgKwpBTAjKqnbrFIBIojKGbEWqGqFNoKRTSFEg1BET2NRaMmaXnuvnycZiDyBhpc6yZ2 + /W/rJFLDtXLdRoLeUq1Zp3TrWDNqWiFS5msF06aNNCPW2iLr9mtmKGaTxzIQW4NVDCR2lxwRoygIjYHA + puYSNlonKQRwr7KEhBklIVEOJba2NqEcBrg2v4jhpRiLCaeOwMu3kINGHh7AL233AZjtDuXEk90tw8+u + X3fzUHfXrXIYjklBswDZ2p/fcdjyHTeomU//llUBIrvgkAsAigCFzBzYUCDIEIdCAI0MdF2fn9/8wsjo + zm+NTGx7Y2ZpIGbuAtAEM1z0jkgg+4cQlNOPhyecwchK6LS1xm+X1q9M8cmimB0Fgc5CgI5igJZCiI5S + EY2BQEEKEBiVJMGsF+0XkwRLSYwlG/EjpTLD93LqEhnd+gaSaAnMa7eGBbQUCmgKQjQEEgVh5KMEidy1 + MYwR1r+sYhO/tQvIBEgSRguA/KGZ3M1BpDUipZFo+7rpT1Aa3Z3j0KwRa42EgURrRMpkGorN+ys2qX8o + COVCgI5iAY2hBMBYiGuYiyMkrNEgA7QGRTQGIQgCM5UI1xeWcGepiqlIoaYB1uS1jmlFFsfvrdGviva7 + yN8ViInn1rfffmb9uutPdHdfHSw33RQkxgDMwZF/GPqdjP7vaAaQZgJ/+Hme+fRvOT6ed6EsiOC4mOne + M2amZaXo9OR044n70y2nZ5ZaY+Ym4zQQ/KSGL2Q+1SRJ+d6QfaCdoo0TDGX75JjIYXNoWq0EsBtpiVAS + QFMgURKEpkCioxigrRiirRCiHAYIpUAgCDWVYCGuYSGKMBvVsBjHmE8SVHSCmlaoKJui+1Hfy0cIhCpr + QAnESJAwY1kpLMYJZmoRGgKJohSQJCCJfqzttul+P5BZEyYIoZAIBEGSQGBVhchmDY5Ky/ZeBmR+LxQS + oTDvHwjyigCbJbBhe0ZKZ3RcZBJqBvgTUKyxlESYi2qYjWtYUgkS1ijJAIsyRkehhNawaMooSegohbhX + iXC/GmOqlmBJmRLFbqzO9gVQ7uN7N8oEXqXW90k+NQCLIWG2M5T3jna3Dn+4b8ONA12dNzY2NQ4LogmA + 58Fwgz/vWN3/rjqAzAl8Fh5iqTyTcQ4gJCBMmOlepVq6MDPbcm1+qbXC3ExmN3r447b/hKAsPbfz4pST + x7L/Tg2cbK1pH2pBYJumQmdOwKUEbnZAwszkh4JQEoSWQKBRCjSGEs2BRHMYoCQl2oohSlKCwNCssRBH + mI8jY/BxhKU4wbJKsJDEUMyoaI3Ivrcz/NTIPEfgvq7CSakxYi1QVQoBRShKiYI1vgfDbLyiseJUk8g5 + AmZrwMZxCatBKFYRpBTpa5Dp3wphHId1CIQUiMj6+jCvGQojJOKcFYMRaY25JMFykmAxibGgYiwp4yAV + GKGKUZUJKspkTO2FIlrCIsqFZvQ0JJiqRpioVnGvEmEmUljWZphHc0Yq80uEFQhzXYZgZclY/2j+Lz8A + 5HPBMAJQkYSFzkBODzQVxne0lkc+snHDrb0dHbfXNTTcFUT3AJ4DUAEhAUO9G8b/rjkA4wRMqjLz6c+C + jAOgunlVDVNryoUoKkzXotJMpBp+jMifuyFSGksm6y6EMAYt3AAIZdp1Wfpvo7cQYBIgYrBWUIkClNnG + EBAhtJHNGX2jlGiWAiUp0RhIdBRCNIcBClIgFAIlQagqhYpKMBMZQ19KYizFESqJMl8rhZpWqLlUn13E + 12a2ygOyDLDFKSDp4eTGEWhDr4ysYyhojXCVqE+rAnCrzzoH9nuBheLdv51TYThiDq14fUGEUAq71ypT + CeL0fmdZmLAOQlhHI6yzU2BErFHV5j5VWSFmDcWmKVzTQKQVllVsnGgcob0Qoy0soFwoor3YhL6mBtyr + VjG6XMX9WoTZSGEpdlgHeWvR8yUCPziTZHPg7RT5eZVUP7FRvwpgqUWKufWlcHJXW9PY4e7OkSe6u4YH + y82jzWE4LkDTDCwA6civeqfT/vfEAazmCNL8Na9npomIpfnzoAmn1bpJqaclAhcbQyKCZLtYWQgBaQc/ + SAizeNIakBAEbcYXIaVNbSVBqwQiAaQiBBooCoFGEmgKJJoCgYIIUAwEykGAtkKIgiDEWkMpjYQ1akph + oVZF1Ub2SqJQ1QmqSYJKkqCiFSpKGRSdjeHH9qmLnJaBzncfUl3rNM02z5Zw0cumtVVtdO5KJFKHQm/T + OaUHN/tzSGhBiLdt9qXuwDpIF9mDhMC245E19jnngEwqSCmGYkoOYSZAyWY2zEi0Qg3KZmpOn4GQaI2E + GTXNNlNIMBuEaI1qaCsUUQ4LGGppRn9TI+5Va7i7VMF4pYaFRKGqNGraLO9Q2gc37cnUUYDDggAR6api + xekPrajtfWTf9fUjAVQk0VKRsNAcyJk9bY33D3Z1jB/q7hrd19Fxt6UQjBNoGsA8A8sA19K0/w8//65C + Fe+6A/AdwcynP1tPT0kEUa2tUFjqKhXnOwpyYTxKlm19FCK/K/1BN1sDxIViIMNCIJg1Ek75jwAAIABJ + REFUkRAQgUAQSASBBAn76/aBLAiJABolARSJ0CQlGqRAA2s0KZPSB7byIBulnEx9pBUipbEQ11BTCjWl + UFXGyKtKoZokiJRxBlWdIFImyjujX0pUTqizZljU2ZJGYq+dxh4pRmRfpyUBr2ifRTZbYDuawUQQ/KM0 + 9leqCLusw5UiDUS5lmZOM4EMThJzBpdYPD9fwDmQxVMndutNQ5sVCItAKgAx65zacOK1FZ21alaosEKV + JKpaYUklmIsjTEdVtIQFtIQFtBWK6G0sorexhJpiLCYJxitVjFcqmKzFmE80arYFCiaQa4cyDL8AQKEY + oKGxFCfJQiWqqtUClJ/mx9anVwNgqSWQcxtK4cymlsbpfe1tk4e6O+5ta22511Uq3SfQlAX6llOwD6QA + fteN/z11AKkT+Mxn4eECiSSq9jSUZra1tty/Prc4cWMpaq0xl6zR67pywPew6R8ZUNLZ3dYUFIJCFEUG + bAsDFMIADYFEs5RokQJlW7MXSEBohSbJKNoMOE4UkjhBorRtiWnEyiDWsdZQ2qDckUoQJQqx1qixRqIV + okShliSItEJNmYygohLErBFrhcgjbtbAYNuC82W69YpU3ONG+wYKArOue/bEyiqWzdZo8mfbvQ5Fhsfm + NSVc+wx14EvNhULibOOOTeiEg/fsNbDFSVzSn5YzXo7tirDYljYVzQb0sf3/SGsIIQDmDHNgzpUdZmaW + oFmD2YGhGkVBWEwEFpMYs3GE6biGchCiKQjRKAO0FSS6S2XsaG3GcqKwpGIsRgnuRzHuRRGW4wSxZsS2 + lak00NRUQFO5MUqUHr0/Nq/qwBRNgJZAEhJVi4KqJUmVtkK48Hhny9zu9tbpgebm6aGW8nRzGM40hsFM + Sco5IloA+4afPtPvifG/5w6gLoXUAGIiWg6lnNnf2TE6Wa2V5+KkeGp6kWrMMYCyxQSkhxu4mipikynU + Sg1h1NfXs7kxkC28tEjlsIC2UoiuMDQtJCYwaUitwUohSqqIYxO5l1SCONGItEacmOiubV2eWENXbB5I + nWjEyn7PttJqcWy+p7RtaymwZlOX24e/aiNZBuRxBkIKkUbbB9HX2DZUaFXxdItwg23MVchw/HzkF6CV + nQyvpZH5IP97mRNi6CwvYXidE845M/IaouT+z9VqnhFTmm2bfyd2EpI8Rl8GhK6Ef8wZmSV5sWbErBGA + kWhCDQpVrVFIYjSpEDNCoEkaJ9AgJUoyQCmQKEiJ5kIR60slbPa6EFWtsRArLEQxFhOFoLEBHf29Fe6s + npunkZpPEiFASyFUQxhG3aViZbCpcXldY2mpIOVie6E431EqzjUGwVyDDBaloCVBtEym/Vezhp/T93Nl + 8yPpANq/+DnXIdAgw4AiYK63qWH0iXVdIQFcFKJ6bnZxbi7R7TFzowYC0zaguCgQtQSy2hzK5fWNxeXB + 5sblge62Cjo722RDoZdnC0bPXlqQTMIYaRIj1glqiUKtVkE1jhAnEWJFiLRCnCSGjJJoJCpBYgNjpJTp + U1tVIq2USV8IYKVQTWJopVHTGqwZWitUVWaQ7NfvXvaabk51hJwHgHE++JdjuNUX9JwZhvbMfyWH2kXi + LPJn57ay4ULEuck7eMa/4us6BD3NMFJSDnuKPJQads7Yc1wqzpUkQmSVoGsdCstfcEdsnWkEICYgZIVl + naAkJOZkhFIsUSAD3paCIHUGRWnalqEwIiENQqBBhugpFUynorGBt2zfen9TTb2aNJaX6/qyDEAJojgU + stoYBNXGQFYEqBoKUSlKuSyInMFHqdFzihXo99rwf6oZgMUDXJswArDYGARiS0uZS1JWNzY3zt6aXxy7 + s7TUXkmSJmYOpBBclEHcUgirvY2l5Y5Scak5LCyXC+FSR2db7XJX674FoXfPLM9QFQoJw7LTFGpRjOWo + hjhJEMU1JEmMmmKT9tu+stZG6DFhM5pIsMw0ZrPniK2BsyOtKGhlsoPlJEnly5TWYFo9mGfRb3UOFrGf + 3nJqDQZ29qNt9vr+ph7/58hzCJzrwmfR80Es64zKozODdotomNLpuzxbkvKlfnqJAimVgvJtzZXOjL3X + IPgKB8I5wfT12cMb8q+R2CuMtUKBgFAI1BSjwAJLIkEAgQaWCBNCUUgUpEBBmNZpKExWEJIwpSQJhJAI + lcR8EjVs2Ld3pGl+cRi8CupPlBCQEBARUUKMmI2xx17m6g/zMAjc/sXP/dQIisFP640tHuCK2SqB0FIo + qJKUlXUNpeltra13Z6NaWWldYnAgiFiSSAoyqLYVw2pzGFYLQlYCIaqypwsXW0vJ0sIc7sUREq0QM6Om + YySsEMUJlqMaEhUhjhNbzwOklanRlbLro7SpMZghbF2tiCzt1dJYNUNrUyboRCHR2qbKKgXfDDeeU4JR + muIDhpRSB7a5x0jXM1Pq1r/TA7EBZ/we5ZW8RqdtjWhabZNUPuqzdXiEjP7rXjQdCfJxgpwz0Nn5kDAl + A4kc7OuyAr+lyZzhIaJektUDH905OQ+TsS49bkf6XuZsXRcBADRJkGYUIBEnCiBCiQhSCdvilel+xYKQ + CAIBCYEQAiEpkrVq50hjg94txPAqtRjX9fwV5//td774pxXxHxoHkJYDxgkkACoCSEpSVktSzneWSpMA + F203QKbgH1FMea8aLw/0BcuqWp4Yv0P3o2XzTa2gkwiKNWpJjDhW5usoMUWbMgarLfc90Sqlx7KNPsI9 + sJpNtNcmO9BaQSltHIZmMDuOu05jlodbrTT2uq/rI95qKD17KDqloJqXBRBnLaz6Jp0D4zmfaOfPKzNo + sucvhLT3x9wL9oaKyHc8fqsPKwlMlOtcIGfglJKyeAXBiMjCJJy2QlK4M8s5GHUNkzT7cKxO5yQipU07 + WKi0xNMkAFYQAgg4AZGAVCZrCDSZdjIEgligWwDTYVABY+5HAFwu1eI6lJXdc4+H5Ah+2ifgOYG8Igph + yc4TCPife55dqEHQ0eZNDXMXTpfuL8xhMapBkUYcJ6BEQUOjqmLEUWJqRSv2CIvGawZYEAQkoBVYMbQz + LmZoHUMpZQw9UVCKwUqZ6A+YTMARdTwjYfIrWu1FPVqlts9oqvXg10py2SqG4iA+z8gIXkQm12VwlkGr + OCGTJbgyhUgAgkAaEDpTaiGPCMQ5hR72HB9D2HIEwnQjfKAwd10u+kPnnImbOSAPmGQ2HoC1l5UQgbR/ + nbDXoW13JctmhAUfY80I7RZlpRkQZpxYkQYJDQIjVgKSBSANp6QYC8TMqr2/39XwD66eHkBWe9iM/6Fw + AN5NcS1CY+SMKGt+57Dr/B8GGnbtkLXTJ3WtuoxqXIPi2PRylR1ZdVNqbITfVKKtIdmHz0V9JvtQa9gf + NRFXM5AYdF8nColy2QKnxr/SmDxmWZqyrxb9adV+vP9vU9Ov3Ae4on62DEitdS7sENMK5J/sgJB/Lukm + XZtKu7LIj9u8CkIPqiMveS1OtjPBK7kGbFN+829tSyCRtjrzWVSaWaiUlptP+XMlF0AksutIX9O6KjJO + QAgLmKYZCFCw9yUhDc0EoQFmhQgJYq1FrJQHjuBtANmH0+AfSgfg3Sw9+5nPkvekq7e90fZW61IJC0tL + YaQ1JSqG1gpaOXVSRpzEZtZdm7TdpNGMGAwhGIEITMRwPW6lLdPOUIOhTbZgsICst61XGP5qbp9XbWcR + AatpnBi0u64m52wsdyXqZcsVIVEsNEAIgVq0jFip1PjTdJ0yEDA97xyfLXttrc2cAeVGgXNJvsk7chCC + h9rnRiV952aivhDmWjTcQBEhz3R+gOoKwX5WyOELlGtbck4lKKvF3KvpdJmVPxRkZioUpC3HNCkIDQRC + QmkGAeGN69c7H/fHPz3n1PYHn/sPTpgseNhOqM16TJsNvK30TLu94Xf/l3/JcRJTohSiJIHVGkcMlwFo + aKXtUI7p2pj95aZZFmtl60yTCUgLPrHWgLJRHjAIv32QiFAHitk5A1tP6zq0m3PDPajLDvJDOXmiD/JA + H2X986yUFiiEAZoaGuwkY2zOV6ncRDytRiHIyuu0XUde6GVXMnjvRykk6DgIenU2oVfna0vsIV+fgF3H + hAEWluhDWE1xxd1DN9qcJoGcOaeMFGl7c+xnNpltCpEpHFGO9GRKB42s/NAw484BaTBR6dSpE31/9/c/ + 98isYQge1hP7cVInA9RZAk8Sm6hlhSm0YgPYpdFUQzDZXrnZOmSGg8xDEwBIBEHaBRHk0mBtePouRXbA + Ffm5PdLy2ra/H0TscamqJfewzgXgrFPg1bnMKRpCBDQIRiAI5QAoN2nMVaqIazXMJwDJAsJA2uUWOqXm + kp3Ky5xR/frw/Mw8gaBTKrHOkYvI3T+xknDkO0R3a4TIOhXIZQmcbWhin1SEFd2SXPuQnZO1MwWCDD6z + SgbmwEDyHAnceTvVNK+NqoUpC7R25ybA0lGDtcAjdASPyHWwBiWsNXOSkGKRIvOGDmsfC8UgAWg3nMh2 + PJjNcI0WDGaBAAIqSUCKkWgNTrSp+5VhAGqbCbB9OFxyrLVGTujXpdPpwyyQDaSvwunL0EPLl7clgdcm + K0jgyV0Kz7UrjAeMQBHK6xjVGjC1IPD114HlWoxCoQHStjfhtR45V8tnzsbHAfwMIVtLXjcAYEeRBche + n7DgoYvU9V0NMyZMZEoR7WjE7F07rXIO9nfdTFIuk0pPsg6nQL7ccB0Blzw4R0iCQKyzDocbvNJeAUpk + QULtMMXamgN4+A61cWP/7ZtXLhxIFIg5ASsNRSZKCJc+M4O1TV4ZICGg7OMiCAhI2NTRRE2tFJTdKpzO + gZOAsGu5/Uk9rdWPGK6rT215RXpbpyKWMec4cwiNocZvf+oQDu/4MKLyRszdfgH3xSWoqU348levQAY3 + ESSAUpFJde0wS74MMdeRB/RW0V11vfa3ERThHCPIAztpZdGRazv6uxB+xOtTbhbAvLgUwjhfyjI7Io3V + 9GPTzEqbvhKl/IKML5k6E5FNBUoP7QshEATB3K98+jPnP/evP7fmAB42BxDHyY3u9X3qzt0bgqGhoc1c + lSBoMutenNSVEAKaNDRpkJAmMsETANEKsDMAABCUGlAut+iOru6kvaMzKpfLhWqtysVikSqVSjIzNYXJ + qcnSzNQULS8ukkrinGGTN9VLwiMJ1aXLGW3Wj15kJvqsUc1FhN/4n9/Arz1fxs/94g707PgU7p/4S7z0 + tYv4/vW7aG1QaCkQ7s8DiQhtxNW5Cb56ND8DJ+uYg7SKyi/lzy2XvcDHPLxWHnk9shXYnngAWGpxGMv1 + D4ICGhvL3N7VrdvbO6rtHR1hkiQspQSBaHZmmqenp8LpyXu0tLBAUVTzeI9Ih5ScY/V9sQEgTWDgFMdx + zWcNZkKxqYULxeKcUnpqLQN4+A69Y9eu4yN3bv96EBS7arVFsDZ6dmC78sk95BbcS/UBmI1mAAlwkkAp + BSgNIQN09/by4NC2qLGpeWr7rl2XgkBe3b5j55vnz57tMNiQLqzr6akUCoW2sbGxx6cmJwfHx0YHTr/5 + ZuvYyB1Rq1byUJYnt+X6/05oEytAa5t220Z25hcI81XGv/6jH+D/+pPvo6slAYjR1izw8/uBUjvh7lKC + GzcIF8ckEBCUNTIhDJ9KKw2lnPMRK0A34bIDf27Ak/5yykrOUAVRTkwxyzbyU4qafWahY/JxHeaRZQSC + BBqbWzC4eUgNbds+v3Fj/7XlpaWxD330o9955eWXu4ql4oJ9x6btO3aol374w2MNjQ3rJu9PDt28cb3x + +tUrcm52klQS23MV9hoyqNDHEXwOBVtnLKxqwYb+zbqvf+CNnbt2Da85gIfweOrosdfPnzt7sr9/6KPX + r5wW7MgvMPRdh9ozG+DKtdqEFLb+NA9zEBawrn+T7u3fvLiup+fS+t6+b+/as+el7Tt2XJBSLgJIHj94 + 0Ik9WOFTs8V7fGxs440bNz6wZWjr8zdvXD9w9vSZpuGb14OoVs3Li1tgLTvHLE/N7CjNoz3DM/WzEBLl + QGF9s8aRzYTDWyTaWgP09jXiS6en0N0jUAJjdDLCXFIyMl7CaAQmWllJ8Hz/nHOdLU6NII/uI7dwJJsA + 5FzG4LKseo5BXhycM2ZjaogZvtbU3IIde/YnW7dum1i/off49p07/mzT5i1vrl+/fhJAddfu3QJmjBYA + SgBw+MiRzw/fvr3u9q1bh/bs23tsYnziyPVr17afPf1m8d74XdIq9lDaOo+rOR180gTz+TiB0oYy+gc2 + z/esX/8NmCm+NQfwEF7H8tZtO754f2Li8bG7t3vmFqZMPzdFfyhVnLUYFoQgCJgULwxCrNswoDcODi22 + t3e9Nrhly1eee9/7X2oul+8CKF67erWTiLpPv/nmvh27dl3vHxgYqVYq5ddfe+3Qxv7+28VicWLX7t23 + 12/Y8Lnt27d/7cL58z9z4OChj7/2yitHXnnpxZbZ6UlBXtTL8IOs9hfe5lNGRqEVJhxatJtRLgBDGzRK + 7RpNg4xwiDGxzDhw4Hnsnv4iWhs3oHX7BOSSwp+e1WAIMCvUkthSlymb8svN6NczDDMmY65OT8FByiXv + lCb0WR9e5DqI2gMjM2zCZQ6aACkCDG7eqo8+89y99es3fH//gcf+7b79j70GoBpFUeubb7wxOD42NtTU + 1FQ7cPDgWa1U8Orx44eklGFnV9flvfv3jwwMDn4VwNdGRkY2X7548RP9A/2/MDJ8Z/vpt04VpybGiHQC + 9ioPsiCQlf2z0uQ2U5Ahtu89FA9s2vzdY88+9x2tdTMeISDwkdi19zu/+68ad+/dd3D3nj2Xv/QHX/hv + rl+98ndPvPK9hkp10Tx8MkhHR4WxIqtLxwikRHv7et62c99Se0f3m9t27Px37/vgh/4iDMOZO8PDG4aH + bw8QqLChd8P4up7190qlUiylnIehLAvNXE7iuDBy5866ubm5jiRJks1bttzq6uqaVEqt/8H3vvdLF86f + //TXv/ZnO+8O3xRaq1wJ7MA/Nswiw4pD1poyRmT1DYkQCuDxQY2evgRNsgXrO0P0dwNNzY3YuG0MyX2N + pbkuVIMZYDLGP/xDwnwcQmuGUhlhxpCYstoiRyNOGYj2rhGnLTSdY0/minlznmn70HMKudfDqsAfM6NQ + bMD+xw/Hh488dfrJp5/+nX37939bCBHdvHFj88TExEat1HJXd9e9TZu3zBQKhXmbARCAxiiKWm/euNG6 + vLTUqrRuJWBm/4EDV8MwXL53796WC+fO/eKFc+d+4eqVy1vOvHGitDw/RczaipwaVqAUGV5jMrMAvUN7 + 9MEjT5//xf/oV//+4KZN5189fnzn3/74x19ZcwAP0XF7bCz8/gsv/NLBQ4deE1KGX/nyl/75+Ojdnz/5 + +osN1eWFlKgipbR0WUNIaWoqY8u2fVF3d8/NoW07v/i3PvbzXykWi/enp6d7T504sbu5uXlp1549V9ra + 2kYB1Hq7uh5IAR2dnBQACjPT0/1vvfnmjs7Ozsr+AwfeAhB9+5vf/PVXjr/8T946dWr9tcsXiFnn2lla + czYNyNnATcr7p6ynLiThwHqFPbtb8FjPAeiW6+gtb8L+w++DEn+F+7fexM3RAKAlnH9T4/MvFhAlZJZl + 6JQyk9MDWSFA6t4PeTUv5wBcfZ5bF+ZlK+nwUtrTZ68Nmkf/XTu1WGrEk0efiwcGB49/5jd+8x93d3ef + v3//fu+lCxd2N5fLc/sfe+y8NCuykt6uLn7AZ0C2LGs5d/bsJjCvr1arC489/vjZMAz1xPj49rNnzvz6 + q8df/sXL5893375xUSZxFUQ63UTrbggFBfQN7dX7DhwafuKpo//s/R/84J+ceO21JxsaG6c/+oEPvLHm + AB6y4+Tp09tu3byx6+ljz7w8Pz/f+edf/dN/OHz75t++fuVi29j4sNBJDBIm7S8UG9Dfv01t6O2b7B/Y + /O+PPff+L2wZGjo/MT6+4cxbb+1v7+iY2n/gwMVCoXDv7R64t3kIiyMjI5uvXLq07eljx15qaGhQf/Hv + //w3Tr5+4h+dfP219beuXyZO24dW2luz5wDy6HpuQEYQhloUfu3jJTS0N6Kl96P4mY/8Gto7t2Lq/P+I + M2/937g5ypi8JfG//hUQRdKSZrLoT1ZqC6t0AzJrd00yTnkAfgaQrhwDpUNBeclwXpVbsLLlRwjDAp58 + 5v3xht7elz/z67/xT/o2bnzj5IkTh5I4bjv0xBOnwjCc7O3q+rG24tjPoeH+/fs99yYmemvVaung4cNv + MjNdvnTpIz/8/vc+O3zz5hPnz77VOHN/lEjHEKwhgxCNLZ28dff+aOuOXWf27n/sf3/muee+VqvVypcv + Xdy1/7EDr/V2dS2tOYCH7BidnJSjd0e2T05Obt67b/8ZIkq+/8J3P3Hh3LlPz85N74pqtZZKZZkaGxu5 + UCjOtba2nT5w6In/89gzz76glApPvPbqwcpypXDoiSfebGltHent6op/wvMRtVqtJQyC5Y09PdHo5GTL + N77+9d88dfLEb3/3W9/sn7o/Kkz0R50DsMBY3d6xVAtPaDQIgf/ifQof/fBh7Dn4S5i//wOohjtYjppQ + rb6CP/uLBF/4ToCFWgjSBKXI0Jh1xkJ8OzVgyoT7M8oz1dGE/Q6eZ+gibft5FGTCA/v9Qkjse/xIdPDw + 4Zc+/guf/KcDg4MnmBlTk5M9Xd3dM71dXcs/4edAABovnD+/K47jde3t7TcGBgdHlpaWel/8wfd/6erl + y78yMz01WK1USqwVFUulWktL28TGgYFvHTry5P8ztHXr5Uqlsu7+vXuN/QMDN/q6ux8Z43+kHEDmBO5u + f+PUqYOHDh8+t6G3d3hhfr7t0qVLe8+deetoR2dncWpycmnPvv2vP3bg8dOlUmnp9Ftv7R4fHe3ftWf3 + +YHBTVcAVH+ciP9jnFsBQOn6tWu//Ln/43f/xQvf/kZPZXnJyGjojLrstFD90dm8gg5BCEazYPzsEKGl + GOFv7RPY9bjE8dkYbUXgOz8AvvxaCIbhAcQRkMRsFmNovQq9dvUonRoy2bFe5nRVmOlI+g1Mk+oLysoM + f/x5VSUzImzo28Qf/OjPnP9PP/uf/VZzufyWUkoIIZb7urv5Hb7/QinVdvqtN/cyo2H7jh1XyuXy1PjY + 2MCVS5cev3dvYqsgQkNT052du3a/tXnLluvVarVw5fKl/VOTk4UPfOjDP+zt6lrAI3bQo3ZBo5OTIkmS + rpd++MMjWqvGgU2bbmzevGVMSlmx1qWSJGm+eeNG383r17a2trWNHXnq6TeJaPbtavyf8JzCV46//NSu + XbtvgAivvPzSf/vFL3zhN868eSLUymzwVZqtam/eAdQDdALZ0hOwBjGjHGoc6tE4MAAUmoFvXmZcnSwZ + vXsGtBJQCSNJdNoP9wU/640yq9kzB+BwgYAEpJTQrI0ab53TkJRfSU51DsAvOYqlRnzoZz42/3M///y/ + ePrYsc+/cvz4Y50dHbPbd+489244YfdZTEyMb7x86dJ+QbT89LFnLkkpZy12QAA4SZKuN06dHJibne3c + uLH/+q49ey72dnVV8AgehEf0GJ2cLNRqtZ5XXzm+o1qptJXLZXl3ZGTDtu3bbw7fvh12r1s3+eTTR68K + ISZ6u7qSd/lcaGJiYsvs9HT/jl27Tp49c+bD3/7Lv/ydP/nKlzfOzUyR0Ro0st35qbVsek5rTlV9SXgb + eiyzjbVGMQSKBdP2S1hCJZw+1yYD0KlqUP26scyInbBHVtu79Wpuq5KUBkNgp5dAeaCQma3ICuo2gmel + BQPYufuA+tjzn/jLX/yVX/kHS4uLdOvWrV0HDx16sbera/Hd/jwANIzevbvh9q1b6wc3bZo7dfLE42Bu + 2L13362zp0+37Nqz59aOnTuvAZh/twLDw3AEj+qF9XZ1RQDujE5OjtrrLMLsHFw6cPBQZME9/R6dC49O + Tt6emZ5ed//+/Z59+/e/dGd4+Jvbd+7+zMlXXyrplBHHK1pjWXrtafx7Q+xCCCgFaCZUIkY1DiBEpn5j + Og6w9b8/cryKjkHdOC55e8XJczhKabv92FBn/faer3H4wL1EDJRKTdi7/7HZ7Tt2fLlYLM6cP3v2fdu2 + bz8NYOm9+DwALI9OTt7o7eu7BUD09vWN2tNdHtq6Nflxwd81B/DwOgK3bKEGYP6neB7JnYmJq+fOnj3U + 3d19vH9g4C+2bt/xsTNvneqtLC16qb5vkFbXznIWtMdhF2yiMZHXX7c7BbU2kkpIKa6UXy/mReRV1Xnp + QeCgJQelxB2dLgVNW4nkLwenutIi4x1192zQg5s2ndi5e/eLExMTvSBUyi0tY++l0dn3cs/HNP4GHgJr + x3t2SClnkyRRd+/e7dvQ23t6YGDgYlt7l87vQSXk1T50Ou2mrQQZUhmy7HeE/duttDI8YxP5U6lSprT2 + z8mY8crKkMmbkatzEI7ww8jLnbFfFqy6jozdfcDQtm3Vvo0bv1Mul6dv37o5uGnT5usAkrWnZM0BPMqH + GhgYGF5aXFzX1dU1uXlo6Acb+/urLsKvXNSRpdXOeAHDUjPMPo0k0XZUmVK23kqTy3/UPsBofobz233e + ZvctrZIl+MM8glai/ln5YDsJYZG3DG0d6+rqeo2ZGwqFYtDR2Tn+NyHlXnMAf4OP3q4u7l637t7dkZFm + ALh7585U38Z+LWVgxTEIEmzrd/YkrdxCEc5mBhhmqi+xakXpXIECk86n+pCWhe8cjPl/7Y/gEkNBQXNi + KMm5FT2ZxWs4bX5fqIQ9ENB2KYhXOhrrZJqaypianIw3bd4yOXLnTuvk/XuLMAti1o41B/DIH8tSyjhJ + ksZn3ve+1/s2brwlhOTV4mz92qy6tGCFgfnRluracPW1fH2AdyIpOdTeUxKv/+mVSkLkdRjg4QBOZhxe + +6+kdu/de7YQhnPT09Mte/buu4u3U9pdO9YcwKN03L07slE4RfnBAAAgAElEQVRr3SKI1NTUVJOQpnvO + TrKfsmi6MgU3yDsLWjHZ6nYSEEQ6AWn+Q9dJkFG2/Sf3XZHV/3VrAlNtP7L8A6wmYw6gfuVYbmDI/AkL + BRSLpYlCsbh06+bNvSpJmtaeijUH8Dfl0K2tbTMA9OzsbFMc1ZqkDACsJmi5auhP++hupbgQIuvVe1E/ + lQFnndsFyC68ox7My8Q/UgEQ1Il8wkxUCjyoleiWoKzivMwwAxoaGsXExPgGAEEg5fK69esX1+r/n84R + rN2C9/5g1inrDAALQRBCZnLg7IlZ1qX2K1J9eMs8yZMey79MXXlAma6+7QaIB+ryebwAP6L7mn+UX/Xl + LwTxRMiy/YFG0NPtSKa1QLSWAfxNOuTU5FQnAFq/fv1sY1PTLKA5DCQCt60Hfo1OuVqf65yAJtPmc2r2 + mgBNdrDIVgEsCJoMQJhq6Wujlmz0Ao2GoibD4EsTBG/dly0OzA5Cr/xwOw2ZdG7pCOVEQfPdjeXlJTW4 + efNtAFEcxcVbN2+2WHbe2rHmAB7947HHH78upZy9c2e4q7GxkaQgBKHwFlZ45p/u8/Nm9H2VXC/xz/f3 + V1n/vVqUZ6wKJvprtyidAqRUyttfimKX/KzMInh1ARCVJGJ8bGywVq2W9+zde7G1tbW69lSsOYC/GQCA + 1i0TE+MtUsrqvYl7e0aG7/QKYiqEEmFBpptvuE6Lj7zlQdnCEOHhbP5CjZXGn6rs2haeayuuxvpzoiBO + nCQnCuIVBplhr5LFpyKs7r00nBBYpbIoxsfG9mrmjuZyefGNUycHYIYW1o41B/DoHqOTk3Tj+vWewcFN + wwBkksTbJ++PB01NIVqaiigEAlI6ii9lEZ8zSe18Hc9gT/za/I5Ie/N++y0l+FiE35UKq630SlN/5DmJ + qXNgrE4hXon6pWvYhFsJRkBleYGSJG4/8dpre3r7+ibL5ZYWAM1rT8iaA3jUj0KlUhnYMjQ0ceXy5a1X + Ll360NzM/WJ7WyOKRYFSIUAYBAiESJF2V4uTN2efGjvMxKD7g1wmQNkevjQKr14RuCm/XLbhSYdlC1E5 + 29RLq40TW6cjMiAwtz/RvmESRxi+fbttbnb2WQAolopLI3fubFrDAdYcwCMd/ZcWFzcsLi7KMAxnb9+6 + 9eT09PTm5aU5QhJD2DVbRSkghbCrtWABN0rXgzth0zSq2hrc/Mkwf1plDJcoL/hpug7mT/1yELLlgrYq + uZrZJvFIF3pS3SSgOwu3ecft1UvPIc0aNG7duFoYHr79wfn5+Y179uy9ePXK5e0wE5trx3t4BI+60dmH + qgyAp6emmjs6O9246TyA6D3sPxfeOHVq5+49ey4kSVIqFAqHLl88X4hjhaWqBilGsRhAsUZNCSRKgVZp + A64YzPH099124voZH3/wp14NyK/j/Wk9P6r73xNW9qt+2NcfI2awN7pcN31ovzUzfY/GxkYHv/fd7/7s + Jz75yd+TMlgcuXNny+jk5MX36jMZnZyUMCPivLiw0ERChE1NTVWY6cBFAOpR5ycEj6jhCwDly5cubr99 + 69bQ/PxcePiJIxeuXb3asnnL0OKF8+d2tLS0LG4eGro6Ojl5C8Dyu/lBj05OisuXLg0Nbtp0r7Ora/y1 + V1/9+KvHj3/4zs3rgRQKiQxRKpUhdIJaNQYrZfj9vjKwZ2R5ijDn7IzsMktvbX1dqs4pISczcF5h/Mxs + sAiuTxfzvf3sdzmL8sjkzNMug1vNZkGNJK7i/NnTjRs29P7y1OTkN546evSN82fPPrmxv38MwMy7bfhx + HHe8+srxLVLI7mKpNBLHkUripEEGsjQ3M7spimozTx09dnZ0cnLUaks8ksejKAlWGB8b2/rmG6ceW7eu + Z2r33r1XGxoaZtL81DzBirVuOnXq5N7K8nLr/scOvNHa1nb7JxUCfZDxz8/NrVtYXCz39vbeHxm5s+F7 + 3/nuv/nTP/p3Tw1fvSgKQYDGcjPaOzZjeWEM0/fuYiG2JB4nte0Bea5Gzy36TKXE7N5DrTMR0FWWe7rV + 5D6Y50oK/30d6w+2UJBOmlxQ3bRfXYZinUf6f05rn/LOSAYFvP8jP1955rn3/e7Hnv/4fzc2OtpZLBab + Ozo7r78bqkA2I2w+e/r07pmZmf69+/Zd7OjsvGtvoAuGCQC5tLjY/8rx41sbGxuWjj7z7OsAZh7FbOBR + EwUtnnz9taMLC4vrnj527KVSqbR8Z3h4z5tvnPrQrRvXH2tobGxYWlqs7di5+9Wnjh77y/b29ptLS0s9 + r7z00uGW1pbZw0eePCmEmP5xJajfzvinp6eHvvOtb73/Fz71qa8RUfHlF3/42a98+cv/4NWXv9+aRBEC + KVAUhECGqNWqWIy03VicGZtvZPVjtmZtdcYDcCVBitbrbKKH63cCYCWa74uEpB0AW4oI64QEkSdXTlm3 + Af4yk0wwVNh9Ac65cMpyZLS0reNP/cqnh596+ug/fvzQoa+fO3t2z/TU5Ibn3v+B77yTTmB0crI4MT6+ + +datW7tKpdL07j17zkkpce7s2SdH7979yNUrl3cIIvQPDl5vbm5+9dn3vf94GIbTo3fvbn/j5Mkdx557 + 9sX29o47j5o82KMkC14cGxvdW1muYMvQ0K0oijq/+sd/9PevXb38/PLSYt/M9P2wurxEDY3N3NbeWWtt + 67i6Z/9jX/zY8x//IwBzN65f3z58+/Zgb1/f8PYdOy4CWPxJPmybifRPTk72dHV13V+/YcPYn//ZV//L + V48f/69+8J1vlRcWZsmJZ0CZ0VytkW7lS6O9yEC71Vp2zKt/jGmG4AzekYaYcsh+PjPIv5Zb/+Wn+G7x + B4nMIZgev1sM4gREPTkzm0kw51fzuXMcHNqtn3jy6I1DTxz5px/6yEe+ffLEiR3r1q3T6zdsuF4oFKZ/ + ksg7OjkZVJaX1586dXK/ICH37Nv3Vmtr69y1a1d3nHnr9G9eu3L5E3dH7nTNzc0ErBS1tLYmnV3dS13d + 684ePPTE7x199tlvLizMt968cXPHwODgxba2tuFHKROgR8T46drVq09cuXRp8Oeef/5b586eefKH33vh + vx4bHTl65vTrDUtz9wgcA1B2422A9nWbec++Qwvre3t/+NTRZz7/2OOPv8zMdPH8+Z0LCwvdXd3dN4e2 + br0BYOnHcQSjk5MySZKO4du3d92/f7/pyJNPHq9UKs03rl9/9vsvfPe3v/pH/+/hqXtjggG7p8/+rb2t + POy140Q2suOn2q7tl1cGWt0JrCYAytYatQclpBvKKV8WrJodpLP/RsXY/ZwA2bohv0/Q35DM/kJUAkhI + 7Nx7WH/8k596bcuWof/+wMGD379540bvwsL8UEdn5/DGjf038GPItdtUP4iiqPutN97Yvbi40Pzk00cv + NTU1jdRqtQ2vHn/5ly5dvPipt944tfv8mTdLlaVZCKEhiSGJUCw1oX/zTr3/8SdGezb0/ttf+bVP/87U + 1GTDKy+9/PTHP/nJr/d1d8+sOYCH6Pir732vODU1+bPPvf8DLw7fvr35S3/whX81Pjpy+MzpV6SKl0AC + CCibT9daQzMhoCYMbtundu7ZPzq4ecvXjjz11Jc3bd58HkDp9Vdf3VmtVnv6+vpuD23bNmyBqQgA1z+I + 9oELAXScP3t2aGZmpqOru+vOzl27rwHo+ZOvfOUfvvXGqU+9+vIP26cnx6R2KsCarfF7yD2zFdpE2vv3 + 63+/z48cyp/9X9YFcFThfKeA6zIEwNXplP3Dg/tEuqiYvK5EBu4JacFKkTET5WoMQ/JmB7hOAVmG2Ln3 + kNq9Z9/Nj338E/9sz96936hVq/K1V1890NTcXNiwYcNwb1/fbQDLq6Hz3lqwhpmZmfXnz57ZHMdxecvQ + 1uuDmzbdZOaWs2dOf+DUyZO/eeXSxSfeeuNk472JYWKV2O3JDEmAFGZXYCgkOtYN8sGnn1sc3Lz19/7O + f/zr/9P42NjmN06eaPh7v/mfvLjmAB6i49svvFDq6u7e3NnVNf/VP/6jf/n6q8d/9eSr3ynGSdUuAzVX + Ku0Vk1XTQQIgIZRaunj3gSNRd0/PyMHDT3xlz759f9w/MHBdKdV44dy5LRPj4wNRFMnde/Zcj+J4eWjr + 1iv9PT2V0cnJYOTOnS21WrV89+7d3jiKCv0Dg3e379hxCQCdOnHiubNnTv/n165eferl732nPD83laLz + xglYR6CcrJc1TIP62VVbWfR1XB/ydPfzTsB3AP7O3pU8/xXDRXVtwnxpsPL/yFsESqKOfMRGnXDFfAH5 + TilzBKkTEAH6N23Xz37gw6Mbenv/5Kmjx/5Nf3//zWq12vXiD37wWLlcDsNCOF0slha2btt2s1QqLVvA + rv3atasbarVax/zs3Lo4ieceO/D41d6+vrvM3Hz8xRefOnfuzG9MjI8fO3/2TOutG5dFFC1bfMJuiSbD + oxBEkIIREBAIQnv3Jn7y/T8z/uTRZ/7Rsefe97Xr1671P/vUU+fXHMDDVQJIAE1/9a1v/uorx1/6H374 + 3a+3Ly/PpPUqbGwIkHavwEqDY4ATsx4cVEBrdy/vO3i42t3Tc71/cNM3nnjyyDc2bd5yCUC1Vqu1zs3N + NZ987bX+I08/faKrq2sGQOG7f/VXh/sH+pe2bts+LoRYAtBw+q23Dly6cOETd4ZvP3/+7Oneq+dPy6hW + gdLm8XfoO8MuBFEZIs/MZndffQfAmbJ1ZgYA5FXTe78tmC8ByFvQsdIh1G8ITl9XwBCO6lRK0h2BIttZ + 4AaaRO4ho5TKnEIWbjeizV6EN3DQ0t7Dh44crQ5u2vzWlqGhPz70xJFvdnV1jQCQSZK0fP+FF4Z6+/pu + bhkaWlBJUrx48ULv0uJi+1NHj10vFAqLRFSbm53tPvHaq8dGhod/+fbNG4fv3LndcfnSObm8OJfuX3Bg + pjtnaasXKQihYASkIYVA39bD+vEnn3n9l/7OZ/5e97p1t9/tvQVrDuD/BwYQRdHAl37/C7//3W9/49nh + q28KM/7KKWrNEunqKmaAFIMSQCcMbXX1AYBkAW3d63nb7r3Rup7199b39Z5taW195eljz7xUbmm5VS6X + F2xXLAW54zguzUxPD1y8cOHxibGxD108f+7ovYnxrisXzgZLc9OktIIC0j2AvuElymYCSueFN6zjElJk + DyqoLqA77X/kVoj9dT52J+PND5jYW9kdyJ+bY/YavILNEJNwnQBO5cLJ1x8jtwGZ0xXcTsuA4D4bwzwM + ggK61w/w7r2PLff191/evmPHN/sHBl/p6Oy81dPTM4p6MSMgHB8bG7xy+fKO0ZE7x8bHRo8sLsxtuXX9 + WvnurStifmEWkVLQiqE9LQUhXOnCkDCbjaQw0T+UGqQZhWIzjnzwk5X9h4788+c/+an/rber65GZXnxk + iEAXzp87MHz75p6x4atCmQZ4Os7CdrutsJMwbJUyslXY5gHWmsFJhOmxO3Ty/nixqaWtf93Ggb6+gcEP + njt9eqZ/cPCqlHJ2ZmZGunZbqdSgWlpbStcuX94Z1Wrtw7duNo6P3JbLi7PQWmUGpjknrgkHAtqtPg9M + v+GtBidht/WkvYIMS0sfavIQvbcb2lldYCT/b8pxDnxDdvP+buJP2wLc3GNzXSscjLeOjC1hiL36IOUs + MCNJIoyNXKf7EyNNHV3rH794fuvu/oGB2bBQmNy6bfvl27duFmF1RaSUWNezXl44d3Y7gTtnpiabxkZu + yfnpMYprS1A6UykiIcBar+LsXDkDq7qqobU1ELWI4asXSu2d3T8Xx/GXANxZcwAP1yHOnTlzbGZqqjWO + ljKVHG0/UPuZusUWZNdwpZJ5cDp3IqPf6gSVuSncXpgWw1fOlcJSw4aGppb1jc1lbuvsIiElwIzF+Tme + m5lGdXlBRJVF05e3hu0ANM0EXoVpZzYVGr68y1j8lpwgvwVoxTuQH6xxP6s1I936nSoCcTpTYIBA/YCt + wxmA6HcPUrP1V36BQdreS+HTgTXcJqLVXoeIoNg5r0wPSNT5I7dxCACU1lBJDffGbtHUxJ3S6VPF9eVy + a89LDU27u7p7qFAoAACqlWXMz0xytbIkasvzUDqCZGU/b3Negsx7KWa73MSMU6c8CzBIZAtOBVt1ZjKS + anP3btHc9J4dJ19/bcuaA3gIHUAYhv2T98YEa7Njl7UxamZKa1ApbBuKOJ11z6S3bExlN4abjeLqJEa0 + mKC6OE8zE6DRGyIHbZHw+mg6Kzu0lev2s3auU92tB/EAmA28nhKQsXeRpvpOmINTo1u55cddA8Ok4yvX + fiHl5a8E/TwD5kx2LJ/OUx5nTKO6v4IsjyfQagsHbEnAjJWUYptlmR/RUFEFc9MVmgPR/bFbEI6AxAzB + mmAxEyHgTUHagSlphUxsx8WfUiQiSDJOQhKMiDrlMzBVm4cgNN24dnUAj9DxqDiA4NqVyzu01iZoKqdr + 723OkSYNEOTx14VhyqWO3gMJIVzkVOnruJ9h1rmdeZwahEGzCFmdS0Qm5WRKDXC1gRvhpfSewl7OGDOG + HqVG6Iy03ujdCwmbZgtBdg+AryZEXqmwejkgPEtIR4AsKAnKtx2Js4Wi7heEV0ZoZBlA2oNgynU2jPPI + ZyorNxMxCCp7X1jClM3whJ9REBAYqgLiOoDTJ0mxMNmiKRcdVSoTW2HTPi4M37jWveYAHk4wU2Sx3EZH + tz/PGaO0CLXSJrJr4wAETAruYGpO9ewzje6cwKYD3UQmr537eVtvMvLDMfVqfy4OpTv//JTZI/oY0VBK + oz10xtohm3nUr+HOBdh6Y/YMOcsqVkZ/X6AsyyKyaC89ND+7ImFLFZOdkEA6ECTSML/Kx0fsjy+aNqjJ + r3IzCSnuwGwdkEhrHrKfnLZaCm6LitNaRR2Nmhw9keBlLo6vYLsCQqdfe/jlmgN4yA4mojjNVNmRU40k + vhAWBJTmwdCawAmnAcjt03NquuTIbLlBGja5pTbAYVqfu2zCpfQOLWcvu3Ay2iZu5cAw8vbspQh9Wudn + KaiURjVYa50JcnoWn0mGMSj3ghmXwE/M0xYeCYMvuI4CuE53MAMavH0fpg2J/DWk4iWezqB3WuY+Uf46 + M0FjsotQM7nyLCfK3p8twCvIK0Mou8ewqb8UxqlIyvYtBAKISa+yspxTCeV0/wGM8TtVFiZtz58eqVmA + R0UQJDn4xJGr1t7tPLq1bPu0GDYgQwaMQGbgl4TPtsvimNZZqpq25LyNu8iCkNnU69J1bUAyzfUofobb + k59GrwjblEl21aXszA68YoC0B9JRei2CLeApkK4JF3AsN4YkDSkMYGgIPOYihCMe+UJgRCAh0po8BQsF + p44uFQTV8Byiud8ZNmKjNXtgLLGt1zmVDTPns7JLkYMeREaTJmJIYgiyew+s05bSvK6UBCkZYWDemER+ + ojIDLxmKDUOUvfvMbO6ndFJqjGTj4KaZtQzg4Tu0FGKSyWSfOq3gbHrIWWwjmIdfCou8k5t/hbfR1vaG + /bKAHaLPmVau8NrylK3WSsUzvVpTc/afLgNII72Xgqc1PWeZgtaMWGvvoV1JB64H6tIkwM70Z5JitALh + rwcDhUccQl07L5cYOZ6Q4JyzywBWTpmB7KsNIUsLXDOEoVPchkB5ZiJ72Q4zhLSjyQIwS9UE2DoGKaxj + kRm2IgKgpthrp1IKLubyEX/NgQVxld2BaE856usfmFpzAA/hsbS0hFKxwezAYQZrsmCRfUjSlNryAqQD + BFHXFvRSavuwaNawXBHzsIrMnZBwDxNntYNzOCsGcDIswVvAk9sIlMIOddUHkzNYzkX9+syC7XSei+iG + qUfOxFLyTq40YPN7muv6/2Bv/sAzfu9c/bWBTDZC6wx8TEsKzrcaiTJmIGWIAbTDX2TmvNOyqu7Nya5M + F4JSqTRmDU1knbmGFqYVGBChZn9We/Jn/nCToMwpMWUfRsKMoigAJFRYKCyvOYCH8Lg3Pt7Q1d1DV4QA + tMqj6Zxt1RWkAfcQOHFL15vWWdQSaeqp0+jJRvw+BafcQ2mZu2kdrb2a1yzdNK04BYZSnD7ufkctJ6jl + nvPc7Ky/8BOroOOcju6mWgK5mQGymoFIDdA5PvIinx/p6zMM5zhcnZ3LBJwRIXM4Dpl1W4Kk70EIKQCa + 5mpsuiU5r0LsCY1lZCKlFZgIggQUMhCPSCCxQ1YgQDFBa0Jif0gIQLAZvc4cG3sgo703MKzANBmRTUY1 + RAa85gAewmO5UkmKpZKfS9vM3hiksMWqFBpSA4qQR+1d5k3Zg5Kl7KbO1zb6Z0QSSoEnN8ab9q090E3Y + dJ/YOAOljXIuI+s9OuPj3NZfzsBJ12V07Td/JQhnyKXwft+dDzxBTpMlrE7/Fdo/lwwUzeH1AvnanLNa + P90GZFtpwhVe5Nqq2q4j0/Y6CBKGnKMZmWiAx39gNjlB2tJkhibbuXEOzG42Vun5ZfiKijnNvJQdwKrv + ZpAwmZwhA2XXpl1LWQBMATSzFlKsgYAPIwZw8PDhE0qpZYOgZR7dgU5uK5ZM2ztZCohUd98BZmyithBp + eshmHQ6EJ32dgmzk1HrJA7eylNI9kARtFnYSDOCk3QKOuhkAn2DDLqsgiyM40NEh7pnhCZvuZ+q++dl9 + M6HHuTXgxH70zBaGmOvIFoYag84iJvnDSvYKhd0vLNmjLwOQKRhJduIuMz4NTp2E0yhw52OMP+sSgDid + PITXttPW2ZsyhqA0I1ZArAhKE5Q2TsY4mvx4NQnKNA8cOCky5qa9alBQ4pb2zttbt++4s5YBPIRHe0fH + uBBCCSmhkyTXWNMwE17OcFkyQgFoASQ5RphIe81MHhBHWf+aLaXUjepyrr/OCKSEtg8uKU61+7XijKdf + D/r9qB6nx6336+h0vJnymEJ60eQJgZEtAtjPTbLXd2KJOTYhcn06r5zKcI6MJ8R2ctH8vLRrxKUQHsDn + tVxd25FEluavXGeUtmVTDMcjLjEokzZNMQaRAni2Y2jHjuH9sROAZBhCqagKOXEVRiBSlgW0JkAUuKOj + 815nZ+daF+BhPCbGx8tBGAZShlCoZiw819NlhoBGIMzwDUu7VpvMNCDbCJPVoiaEK3h9afJSfw8kdBNx + sAw12MEiEgTSNmqx7UBow1FwrDjW9GBHwFlJ4iP7LDKgUDhUT8DbIuSYUc78tettpEChV7obZSDWKbjo + jxWRyHcMyGEn3gkJmz1J+BmBTtN+wYCUhnhFDCTEqWFq1vn3lJnT8VuwmfJRXspMW8BF2PJNsJn20y4j + 0Bpgka4tN10L/55Tjr7MMKUE7GxFos17lBpbaG5+voRHbIXZI+MAWlvb5sGoFgoN5Wh5MUV6hUWzfbKP + kGbeOw40IvIRKU6NI5PeonSyUKegYVYnilS6m1PVIeWYbJqhLLruopQks6k3HQ500Qm8cgWXVxYLGwWF + S/Ud591jwaX9es7OK6Wu5ZHGXMuQyWf9GZzCJyY7g/ZpwWnK7JJkkVIxTffFjSc7rr+pn2xEzWcbab4h + MlyifnYhzcCY0o6Dtllbit/Yz1EriylwRm5KCxXyNxhnOU66ugxGnEUTAbH57JglmlrbVbFYugXgkVpk + +shsBnriyScvbR7aOixFwKTZgGHW4CUTSNtxVQIENERACISdPPN4/SkAZfnoTpePpZnNJ1vga1tPGsIQ + W4RdGwwBjECwUZZx6jJk/pZ5TY0c6r5CpLO+P28pwamCjSX0CHLKuxbDsI7BpeXS0nBTvMBlLsgovxm5 + xopiOAdnnZujJov0dRkB2FyXIARWsUiKVNAoLYW0MGqMicHU7D0WICnt/cxmCNxuQymlxybMHI/JGjhl + MboPT1mwN3Fj4OzNKOT0FL0RZd+R2Q/AYAYCSgkkmpAoQqIJRGLx+U9+8htrDuAhPZhZLczPodTQlNWL + Nl3NOGwMEhrFEAiQZQhueEexHRCwTEK/1g8sKCZTINCrkpkQa0KkzN9pwi3IqsxwavhGcUb4c0q5lD9F + 1+v+TwjKjCudVUDKuCOLUwiZLQY1xm/rXQ/QTB0b2TIFmfZfxmcwbEOyA1TCAohwIGcKfmYzCVnnRFs2 + IyFhQqJtA9IORAWBgAyAUBJCIRAIgUAK831JkNLuRqRMedjNVmhbwqRFBLNp9bGN/Lpeb9D+JHlS6ezT + nG07lE2tn6QOIHMGzAHKLa3FF7//gx5gbRbgoTyIqKo1T5Rb2/k+SQJbxNtyzLU12EATwsAoPRAj1/9l + j7GWLc/hlFDEtrYMXFWttan301kWQmSdCXEdj10AJDWEdtRZkU4VegN9mYQZ8qO7jliQjrjWCYcixxK0 + rEbH5hNZj5Nsvax11odH3ZIPWPxC+mw/L332lgplDghIx681m4LBRVZpX8t1J0S6czybyFOabGmQlUfp + TB47EpWFXPPDDul4bx5GyTYXOfSRffIVr8z64AOFymQeWgMyCFBuaV2WUi7iETseGT0AAJUnjx57/fSp + kx9m5gKl3F2YQQ5FEGxI+gIEIRkyFOkDoTxdAHYIN8OCUqYuZjJ1MGvXHTBptwYyJ8CutUdp7evP7adI + nbBORbm+PjwCjK1tU9INpak8CafJD+S4x7b2hj2/9DVt/WsYjNmYq5mS4XR82HAUrGEEnLYHMxYecpyH + fGpte+02GxJEaBCEMCAEgcm2QqEhhEYMINYCDEbMBMUGaPNBOG0N3sdOHK1XOaIUUaon6GMmBGE+K5uH + OUGUFHNJVaAo1QFw1GPFVrxFWXDWsS+F5La29tHnf+EXXrc2E605gIesAgD+P/beLEayLL3v+33nnHtv + rLnvtS+9VHdPT/fMNGchmzNDmqTIESmJJrV6kSnIfpD8YNjwgx5sWCIMQ4BhCYIfvNCGDQuCJJMmKVFc + ZsThDGfrme7pvau6q2uvyszKfYvl3nsWP5wbkVHFoWAI1rCmFB+QyOyo7KysiDjf+Zb/QnjrjTdqs/ML + Aobgi+HuGC94C77UBG/jbWSEVOLceYMAACAASURBVAVyohZ8IIoEj06ZByAeUVLBaEets46hvUPxihGm + 32BNFQWCQqUCHN/wD/hmSsUaHPDqw8jke+gQNKq8e0yEeWhjVv1MXw3GAkqrY+7CYK05KtM1wl8Y0qDV + g1oDSuTBFZw/BggpHROHDyqmOCVkIjQSqGuPUZZEA+LItKL0Ae8iJNd6hSXEHb2XY7BOlRAe9iB8eELi + H9imHnsSSDjGIMpo8qpky0TUsIAZiIHGhK4e2Az4ajVKgHqzJZsb92euXb068dSlS2Mk4CNaAaiPv/TS + 66v37m57ZCmEeBOGwQpQKfI8kKeKPHGQRHBIGJXdHrrnVI/5OCyUigo81Bio3pcaX20NAoEITR3l6vrK + ELP0gndhSOx58MCOKu2MbBnC6JxhFJY34sDLMYjlYeON4W0XGP6ODDYSIyo8g4n68c/wDxiLHvMDIpdA + KcEoP1wReucRZdAEEh2oq0AtcdRwpMaTJQGTQMd5Oj3NodX0HHivh2wBz/Hhd37EPkhiMhtiBkYJVA8u + RuPdr76X2Mmx0rIeTYTV92vkmDM2EDRRIcLJq/dHkiT+3IUL780vLm4Q3YR74wTwCEW/3zdZmramZ2bu + IeJIEpwr8BVNVaOREkqgIwq8p54F8HrYf4dhoR4luQa3X1xxDcpKwQ1Wb4OV0wOil8c96+CtWfpAYSP8 + d0AxPu7lH1LmlYcFPR6EA9vgMYEhXn5QBo8KhI6CBtzIfx7z/Y91Ayt1hCE8+JifL8PvHUirqyGGP2CM + oCWKjRUVHNcoTzPzLLctdROoZdCqB7JMUbrAe/dgu9AULoJ/tPiYQEKsktwAU1BNSkcFQmMiOl7ljkoj + P8hUHJFDG2gciBoxTqkAVBoSHV9TCXGmYL2v+jgPKs4hXEUPbrYnqTcaOzMzM3tbm5uzwM44ATxCkaap + FaU6+3t7qXPOm1o99PtdUaM3hosvfs8JZZHQT6IjT1kel+WD4t+PrI+GmFCJgywfwshue9D/qmpHf7zv + 9tUh8yEmAeeO1WsGphlKybAigO+lCjw66KoqGqWGKkSRCfcQrm+0vH+4RwjRAcf74+Q1yinwUZEjrhGr + 3lgPNh9hsH50GFXpLUogNYIST2IC7ablE5dgqgm9MqAzYePIc2MVNjoJFo3WUZPAmEDphDyPQ8NA5O8P + 6REDtSRFlTgHQ8yHUJvDfl4dt0/DhiAMvRWHbYIirmO1IkEwSuGcJy8URXBD/MTAm0GLML+wwPbmZgrI + 1PR0yWMUj0UC+O9++e8kX/i5P3PxI88//976+vrXv/W1r/7i4e6m9hJ7dxXA4fEu4sKtA1seA0vc4Jap + 3jyGOBBy1S2vKxEMjxoOlcKQTVfdGtXt5b1DgnpAAXwwwQ6VNpXW1ZtTBsnkjx57JaOuwCMY/9FVoopy + 5qOy1jAAPx1r9x+LiAYICq2raiQMaodKPLQ65IYIljKD9WXFMUgkoHU1jPMVMk87GjVLlnpadThywlRL + 0B42D+Cd23B3I8V6weBRJpCaKEpSlBqCoIOAiT/fUz3POHxQ1XCxqrkGVOuRQxoTgxo+N5HmrNADZNKQ + zO9RSpEaTSKRbpygSAJ4paglhl7p6Od5ha50sTIBJicny0vPPvsK4H/vd377LHBrnAAeodjd3pZet9Mw + ScLN69enpqZnZHP11vAQDrjmJbHPFATlGDgFDLH2o5JZIQjBggmCMmAqyGlQx1P3YxIMUVwEHlAUhu8N + 8fU+ILrSKxQ/IobJHxnsDSzClX7o8wD8o45RgaqaxquqlxdRw01B8IOaxh9PxX01bR+2LSqCoxRoE0gl + 3u6KQCqBVMcdf1nGQ6mqw9+sBZJMMElg89Czc1Oxuhu4v6sIuWYqdWRZoKahnQUW2sJMA27veK5tWfb6 + msJHDENQMbk4BO+E4GTEyViGGIqhxIPE11BrVa0jI+VIVwipyn+JEAypUaQKEtGxldGaWoWPcKJIioJ6 + YlE4bAj0i4AXQ5al/vDg4BDQ/V43GVcAj1j83b/39+23vvGNWlwFfuYPvvPKN18WJU03ILlUqq9DJn4Y + dsMPVdthSB/2PiaLJHh0EAp9bNMVJE7YI87AD40wA6OQ4RGxUB5cZ8nIUO57aWTKA7f/AP0HRlciJ0M2 + oqCUj0AlHT3tgoyohQ3wDAM8hPex3Rmsxl1se5yr6LYS5dISJSQKMuNIVAQBeWILZKtqo5Y4JhqOdjP+ + Lo5Asxaf1Z1dWL8fV4HPn3ZcmI/OqQ0TqNXAZ4FWS3ixG7i1Lqzte7a7Qq+EbQer+4ajQlftVsXZCAMu + w4hsu5IHjVOr740lVDVA9JVrkUAiQjNNEIFUazKtqRmDaEEHRz/pY0tL6R1HuccZjyhNmpre0vLyvf39 + /dbAxGWcAB6hEBG2N+6fBF65ce2anZmZ0cYYgrUjODUeUKR1jPb51dfH0v6VgQSUFYwY5+PEuCofpQwo + HWGwWo4VZvzg9h9OlXnQAKBa1TkvyB+DKRuKUlSHX4YowDBEFsbb31dow1iaG1XNBXQse0TJMR4ghEoD + If4NLgREg/cqyqVXGoHxhgykypMqjxmQc1wc9ikRVOqZajoWpoVEVwMzBUvTgU4fbBk41YaVpuNHziua + 04FCwVJD6LvAegf2QuDMivDionCp9BQ9+HAdvnEjoA49WaKoJYHCBQqXULpBBSDV8BNE9LGM2EDYRSJc + O9Gx5A9oFPF1qilFmmkaiSYVITNCTYGmxPs+JhTkocCXjszETKlrdYzQOXP23N1u56jlnR0jAR/BcFPT + 012gBnSajYarmyTeeNUacDDhDw+JTobwkGHliPEGErC+4vEHQQ9u7cFQylaHskLC6QrTPkSVDVJM8Dyg + +VMhjmWEmP+wscfDophDJx4Zgf4SlW7VALkbohquhGp9Kf5YGMPH6TfVuk2FqJtnKyjsgGykJR5qXWVD + V7H5Uu3RmaeeeNIkMDuhqKUV8s8HmnVFlnlmJoS5JLBjAidawsoiHCWBRKCTwkE3+nuXBbyxVbUsXpA8 + 8NYqfLCtyV1Gq+G5sJTjy8DapmW916CweujlZ20Ykn+0Ug/AnQkBU73+WglpYqilipRATQtBChwFWhRp + EPqhT9f2cc7hsGgTqAdHAqTNOkapIk3T8s6tW9Nnz18YawI+irFx79ZUURQz586fu37j3Tf6882kue0t + NgTKcNx7+8F6qDrsfgSAM/TYG5hWDiWn443qGZXlOtb/H5T1SjMUBxlCXN0Dk4URb7wKiPIwDJjRXb+M + kFh8VDaqvh6UvT4ci3IO9LcGZfKAuOMAraJOQeWCFlsdeyxsIlWJbFSUwzaaCjUZK4JGzTI9LTRqcTKe + qDhLsC6QW9jreiY68PIlqE1Cd0EzOS306o5eFwoUb6967u8FFlvCiSZs3oV373oaNTg5qblx31MUNZRo + lA7Um8JS07OSWb5+K7ATQCkdS3vtqq8Nxujq+YzzgSRRlc1bVAgWAokqaWhQ4ihxKClwoeQIR88W9O3A + O8JFZSQVdRUnJmfDwuLSnZnZ2Z2v/cHvv/jsR55/c5wAHr3wy8sr66t3784DPgtlODVXo64OsVbTc4rc + a/rWUTiPC4FyKLr9IB9/VNJrdK32sPvuqG7+cApfld0ShjI7FVz1QZuswWbAD01B1UM/91iG1ldy1YOW + xfpAiFSHeKMPWhyB4CJBx/uAcoMVmAyrH5FjapSPSiVDLwMZcI/jngJrHUYPJMaroWX1k6z1OBEcEcps + iP/2WgFJCIQakDh2PPiD2H5tHXi6h9AMcUMwk0E6ATIPJ6aEVs3hOnDlfp9dm9FIHRtbmjurCZ1uQs9p + jBKs1yRJSqIiz9+YLJb5SlBGo4B2M4VQYAz4UCKhIAEklARKErEQcopgCcFSVMpEPnh8Cc7FpBe8ojm9 + FI46nW2grNdryYUnn9oYJ4BHMCZb9d7lN149+9LLn7/xWqLyhckJWsU9vE/o+oT9ItD1mp4zdPqWrhVc + 8FHwYbQrCA8e/D/OcjseXnmgr5dq1z60kwoPruYZVhfH+Plj7H/4I7v/wfTeWSHogHMjE38Vd/pGV4w/ + EbSWoYsNI3JXQ8ecAYxXRahsqFRzqPwTSxcodWWnhSZRjlRBpgV/BNrEoaER6FvIS2gamG3CZE2x0A5o + A2UZO++yBGcDkw3wNaAVW5FmHZamIrx5LoNTy4LLA4d70PaOdpJzp4DXN1P2+3Vym+BEETCI1ihtqllA + SpLW0FpIE02a1MB3MUlerQtLguuDz8EHSrFxF+R7OBdlWZwPlGWo2rJKvNWDtYEkNUxMzbi5haX3ALW7 + tTHDY4QCfGwSwMrcXLh5986t9fV/fnpicrKfKtldWV5ZOSwuiy9LAnCohcIqrDPcP/TsHAmHVuhbsM7j + KgXZoCJA6MEe/EH5rAcOaDju2b+X81V4uILgQVntB/jpDw0CI6ddRScjH5FzA9jB4JCXVDZiI1qEuhoa + GC0YM5Auh9LGJBKCDP9uFY4FQ7XEYaOWQKqh8NCXQKIViQiFt/SLwMpCnBMcdKGlhCkDSy1PbU5wGnoe + cuexJSwkwnI7rhUP+kJhAzoVlqcVs/NCbuDWUcCEhB81jlZqeHej5Mt/kLDRbVFKgtYZaZLQqKd4D0rr + ahCqSDOHhJJ61iAxRzh7FGHZXmF9DliUdrhQ4kIRLdu9RRPRmaUN2AqzrRW0spi0rFYo08DZ0ukk3fbe + ZyunztwljjDGCeBRi7RW3+93D6eSJOkV1vdnJ6cxDY3yFucts6LwKsEozdk23NwpWO0EjnIoHHSdJrch + stWkkg0Lx3pyDyeDY+MMvmeLMDzUI7r2f9Qn4GGX3EErLyM3dRgqEg1KlSAj9l4RjfSA49CArDBYH2oV + b3hbKeXIiAXYoAnSldVX0FJZlYOSSOApfSAV6DvFYWF5etnz0nnh9n1PvxM4PSnYttANASmEzcNA3ovc + imwKZgyELMKotRKmGpC1DGvB89vvlLx/tUFNzvHyi7t8rGXZubPBmWVB1xT3OykCJKnHpBbRQmo81nqC + B+8txiRIOKQoe4TgRhyGLT44nMtxzuKDxbooTeICOFuJlkokghkNmY5blEICOqvRqNW6F554+uoHV67M + He7t+JEF0jgBPGJxMDO/vO2dqzWm5/eyrgsdUsnEYrTD6BIMJEnKRGapi2NhJrCblxyWQt4TDo8Sdq1w + UEJRKkrvK/x5+GPEO+PQyXv/Pab4VVIID/jh8D2cMR96eABZVcfGl8PfgQd9NEf98dQI3dgfIxtFwA7V + wEYMPgczTgnV4a9o0RA1Dir57ShhJpQEvFNMGIfrBU62YXZSUE6x6QK39z1pCSb37OxCsIF2C3oB7uxC + GSBTgVMzwlNLhrRmeP+DDpv3oEaXo94d1g/PU0xqJNlksuEgzxFrKJzGJIpaYglGUbp+FAXRdij2aoOt + DnwArxBV4IPD+xIJJS4E+rmvhEoj/3vAGSg9GAOpjkzEVAXqqdBqT+P6nXJiaurw6GC/9eSlZ2+OE8Cj + G/bw/p3W2tpaU+oTH7j+7udcmarCdggatLIkBFJM9IubECZ1QWECPRvIc8P+TmCzq9grYLcfOOpr9vue + gkpxZgAZ9n4oRzV686sRR9+hxHclrnGsRvPQEHGkdRg13jjGEQ9O68jQccD7D8dYguBkKPA5bC8GmnzV + zxvw50dhs4Pc46v/N/iqEghRFkybeEh8UBhlaaaeeggcBWEfz7713D2AvR1hqQlTE8JRver1G5AmkZA1 + aYT5aZiYAN203Ok6KGCqERNWuxWYng4Ec4QyHlNTpE3PrLfs5p6JCUPdWLa6PUorBKVA3JDLHzUNFAoF + 2oE3OFvinKd0AesszkZzl+AHEOe45kXi7W90nHO0UkiByckJtDF2cXHRv/nNr3z0h37ks1/jMYvHKQG4 + E2efvLO3vdWeWzmxtX/vfWtlwrhil0TFm0zEI6FDkhmaqWei5kgbgkqhWziOWobt3cBG17LeDewVhlZP + s58LpYfC+sjsi94W+CDf8yp/oE2oPMUGHH8JqrIjG/USGvUlHHHT5VjEYhRLFMKIo/AAAYcMh5kPJIKh + gk71Sw9mDuFYh88T8f/IMfFGiSIxoYIee+Yyy4mpkumm58KCZsd61o6EmoaVTFiYCSxPxsEkDroBpusw + 34JaFnUY+1boFfDBRuDedqDXFZyBpC7U64bpZJMDu82J6QRTNNgxC6jpWXJbknPE3e4aZdBYnVSKRR4f + oHAlwQtCUrH8PNYpbBEorKJvgaAoS4cygldx/emp3KMlblRSDVkKE00hQ7G4sMK+C/rw8LA9NTmpTpy9 + cH9lbm6sB/CorgKzJD24+v7lZ9orp+5uBLEibZwNSBJhpqUEjA60KTETQlKDNAuYupCkgcQXKK9o4Ml0 + IOs7GqmhVRp6Vii9ppMHclvNC0pPQOF8VJKNQzv/wMzgwTZfjhePMmpHPkptZcgN8A/8f8fpIRKSKsei + oXiIDPEHUZFbo0RFstAgIR37dFV/X5QT1wim4hcEz9BNuKaFmnIkSeCpuZLPPQV6IrBTOPZ3oF6DEy2Y + akarrdSE+Dy7wIQIcxPQTuCwDOSlDFelhzuKO2uB3EOjBpMNODGbUwsHXN/SXJz7YV6YV/QOe+zt59xY + v812fkQZ+nhlUBWbUIunlwu+bOK9rloZC16R5zlHeRFpviFURDCFtw5lYksiEkgqlKURSBNhrilM1QKp + GCZarbC55TanZ2b04drtBR4zQdDHKgGszM2F2/fu3r135+6lk6dOrV/Oi/3azEprb+c98iIaSNWq5rnQ + gaaN8FBlQrU6c4hyJAESI9Scp5UJSeqYMR7rMzq50LOK3EM3h8M8VEAYHVdoZYhvMh8Vcb2vCDeV+cSg + xA+MHsIHPysZ+PXJg7OBoXinOp4USLyph/LblfS9VICYSJDRKFNVH06OjUGqjYKGobGmCoAOGKXJtCfV + FSBIwdqBcPWe5clGJPJYH9BGKHKPmxBqGZgEilLIAvR68dD3ikAzFZanDPVkEeWFU6EL2we8149Q7XoN + Zqa6THlFNvscOjnizbU3uLfp2DqIVVQZhAMroByJ5BgT5zKlN/Fmx8Q5gNNYZ8ldGQseH//NhXN4H3kb + pYsIytRE8JbRgUQL9SRQ1zEppKaJIQSr6lsicrR46uytx20D8LhVAJisdrC/tTF7+syZr0u9dauemZVN + tPQKj/WR4lsLkBkoS0g9ZBC9AokvPDaQl1FGrKkgUx5TK0mzjNwa+k4orKdXOPre44OnUwpHfaFTCLYQ + +qVgncE6T+k8RTlQBKqq8H+FBsBo6a8euvsHiiGjNtpqQJYhUmoj7HiQJDRamcgNkMjf975COSpBV5N+ + NeIurJVUPICITbAeUifM1sBmULjAXE0hCRQ+oIGuiytD7aDvAioF4+LjuibsaeH9bct29x5pAoutjEvP + zfDEYY/V3hHJRGCyoZhsL5EU97h27z7v3A7c3xdMPeVsW/Pe7R4HuUQxjwqOTID9Q493elhd5aWjcCVO + XCQ6eU9e2GG7Jv5BR2alIDWKLAk0MiE1ARMCmarjJfVnn/vYW1cvvzuhlRwyUI0bJ4BHdxOwcOb8HYCk + NblrjorgyaQMFu/AV2u+Wgq2BJsHXDNUNyMkZcD2oVPAoffDstoAaQq1uqbhAqWLJ7nwjtJ7umWcDeSl + Ji+F3Am9XCg89Aqh24dOT8gLiQw8f8wMDCP6W875B5LAaG4YKNccA40qN74ACl3RZAMh6Er6ayA6UlFj + RUf0oRSjO02G/ugcU5u1ikPB0iuMOGbSgmdOeE6fFloT4JSnoWGiDbkIB7nQ6wbmW4JWnqCEmZk4N9kv + 4M62Z+tAyG0gMcLeQc6txiYvntY8sSSUBnrec23nHvsHwrVV2MvjGvDknKJ/2EdJJDAlWlXU5zg1dU4R + nMcHQWHwPsd6N0RaWmtHFJCqNm3gDDXwdMSTGUVdhyhmqkClcxx2u25qanoPW4aT55+8wQhmbJwAHs0o + d3e2/NrqvaQ2s/A2xcFPismUFEc4D70yTqdbBmwavxYneB1QPiruKBUZfT2JE3EdPEZCJI/ohLqG1MW2 + wXqPDZ5WFnfSNpQ4J+Qu0C08PYSDrtDNNRvbigNRRNtCXXHvNUYbvFh6eUnZh2CPBb7CQIxz6Gqj0KKr + gWLs+JVKSFONVhqlNFmSkBfxECCCmJHSouLLDzoANcAKVAYfSSX6UU8VWRohyM0EVqYcSStQ6EDhA81E + M9WEI+O5uwO7m4FzC5AmATFQhHhVTrWEg/1Ar4iHfyCKagL0ep731z3JkiLLAkUeuHoHdosIO56bDijt + MVJQGqhngZOZcGDh8BBKo9GJRYIGdPQHwFI6iwseUQ4XLFLNOISB7oIHFVuAQenfyIRWBjVT+T8giG5y + lPujT1565vKrX/xnz578mZ/754/bAPBxTADu5Pnzd4o8Nyvnzq3dufVOkTamE9PfpiTuskOIvftUXdEu + olSY+AA2duaZEcoKJFJWklJZgAyHrjjmqYqHX6tYUhrijWKCRwykwVNLoAyedqrY6Xj2DhJc99gfzxih + XofJCY2jpNOFg0Oh3wlQykMUZYVUaja1tIZJEgKQpIYsq2FMDSOK6YkZmlmdvaNdtg/38WIRA2XZwwdP + aWNp7iv35CxR1LWibYSGjlP/prLMtQI6LfCiqWWQBkMuDl9omvWMhVrAmS67B4G21iTTkV5oEiEHvI17 + dZ0EemWILVAQUg2JiS1YYoRmBlkW0Yr7h540hUYlpGpUhDZ38kBSgyfPaA6OAm/dDZTdNpgUk/bQKlq+ + KwkUpcN6hyhPwKGMx7sBxaEyLVWgtZAlUEvjwW8kFQCoqnxENLXJk/Q3+tY515ucnfPt2YUdHsN43BJA + yGr13ruvfefZSx976caHqH69Xm/mKbjCYxH6ATohDqd8AbYI1BMqLbyAI1AAfR8oiFoAmQ/Uvcf5HDGa + QHxzguDE45WPvWXFKDQ++gmYSvBShYCznrIQfFkh+8RSV55mO6eR9dg7UFiXkXcqJV5/3PMPinOtDI1G + jclmk+nZjMZEWQmEpCQaWvWUek1YKJrsdxUhpCh1RL+T0e978tKCc5TBEnxJTaCdOlZaDVIVSLVjsm6o + 1yxZmmGMorAlSWjRrDtmU81MK6Ux1WM3dKilisma5yDAQQ+2e4GpKUElAVXJeysREg2NLJClkU1Yq8N0 + XZhtKq6veu7sey6eUCxMB3qbcFREi69eN7C2CxIanJwv2Tuy9PqCLTKUM4g3pKrAJ56i7GOr0kaUj7Jn + YSAffszaNDpWKmkiZFUyqmkhEVC+co8WRZo2g6vV15eWl3tf+42rLaV0d5wAfgA2ATfv3tm4cf3aC8sr + K2u61V5N5pZnkqN3xYinLGP/3SlhP4dFG3HfIQiqDNHxJ0Q2mBchd7Hr61mhZz3GlyQIIscW4KYy+vQD + 6Wxf+QYYYDB19/FNNSDe4CvzieDIdM7SlCPVjqNuQkcn9IM7NtoYrPqGLQBMTRqWl/eZmuigxCC6R6oN + WvdQYlASOBMSdHBoq8iPsliGe0thc7QzWG1InaKuNbXEkfmCTAs6i1VMI8moJxmqoVG+z0yaMD1pqE8d + kGRCo4T52UVUc5+jnR69fbAGpiqcQVkCRlhsg5sISCrUsohVKGygyOGdNcfdPWhMGDID9zYs79wBtKCB + ooT9HrSTmDjDQIdBlwSlCYDGkGhPYctIYlJEwRYdWZ+GoYFT5DgYIU2id0Erg0YaE5SuqMPxcxN8CFZq + q8aYo/mlk/cexxXg41gBkNbqhzs7W9P1en23DHKrNTn7rNNavInSWaGstPoFSgsqF0Ip1WAuYFJQBlT1 + feLjGzZ30PAOFUpQLqppeBfRdUqjg+CcRWnBVtDhgSy3r+wChGpF6AKhCDh77LiTGkgTj0kEpRVxHhiB + O0opjDEkiUYZT9bcp1nbpGkgS9ooHeGr2ijqojCkaFWLaD6f4hNHYT25i+jB1CUUIUdyB6oglDk6EbJE + IrVWIlhJhUAj1WSpMN/IMK09gt4k94cstE8R6l3udXocFbGUl0plp1WvM1n7PK2ZCbr9r7E8uUG7eY5+ + sce1O/e5dxDL8VYGFxaFdhumVOCrt4WdgwjGSZMItGqkdc6fLDgz4bmjhPtd6PZyrNVoowhi0UlJJq5S + OY/EqDDo5SWaj4jEtiNRkOlY9jdToZkE6gpq1UemIFEtCuvLpz/x6e+89sq3ZrN6vfM4bgAeywQAdGYX + FncBmVk+dceuHXmd1VRCNAbwxCGUC5A7KD3USiARnA7UNbQN3MvjrltV8lMDjcAoqhOi6o54EIPH4onN + po+L/wp0E5OJzsAkGm3AF4ISjQDWCvvdDHNgsN6QpDXmlyfRSd274AsCTiml2hMTaZYl+LIUfE+SxoZE + BmCOlj5a1UhViiYy+lQlYT7wHzC1BG0tmROCV4iDmo1789IWOHEorTBJQlGp8CqVVNzjLrVajq9vYFUP + JT3wniA75Fg2D+bp20V00qTdnGBhtsb89NMcugPevPcmN9aWKIs5lqYOubBS56kLZ7mQn8Mlhxzllznq + 5cxOCna7pF0L1POEeibUap5Mn2NhaoqF9uts7wXeWw2sbStsL0FjMEqo1xJ0Kmi3jykDea4qe/BQDTdj + a6YFEj34iJVAlkQJtFr1mkcnZ0FlM/Sst5mobfGWE2fPP5YbgMc1ARSi9OHdO3faSWviek9wWb1mPIex + D9QgLmr99SpsgHeCJLHEThLHrI7GndZLBRwJ5CXkPiDekqqEoMAGXbkBVS1AZSihROGDIFqjJaPdypia + bqPSCa915hYWl1SSJJ00TfvNZtYU8eXM7Py6d9hup689HPz4T/7Eb2VZdst7P/XuO+88rZVK0jTJ1u/d + uiRh/9xU00/qYtWE3hXwxbEzb1VT+OAxpHFCXg22jNF4CyFYLBYnDicBtCIojxVbKQZrSvGUWih9Hx1K + RGu86mtA/QAAGztJREFUKdFaUUunSLKTlM2nKbNaKHrW7R/ZYn2nY71dRu9ofX19v7vVuVj082CUuHSf + ZnK/9MnFBZecns1UTQhrnQusdxwfbu3K0sQWn/+hgl7RiRsV32Ky0aLFZV676XjrTmDnQFH0DNpl1NIa + zUzRaPapNXIa3rN/CIRAUR47BWsV+3sEEhVbtroRamZw8IWWCSQKEoREhDSdYueov/v5H3n53S/9+j85 + 98Jf+g+vPI4bgMc1AbjJyYmNztFh/dTZC4dvXXul0K3JLGMzCmsWgaISy3QD7xstiNLRESjL0doPkXa+ + ctWNi4JAEI2TaLcVjTI1KjQQErw0EN1AJ3NktbmQ1md8aZ1vOpM3lvWhDbWbn3n5s6+8/dZbc5eeeeaN + c+fOvfnO22+fbLZa3c/92I+9IyJFnucqy7I+sEc0oVQff+klMzjZvV5v/oMrl59//91X/+zhVvjswvLZ + JXq3TOjeQaGxeAgOJSYq9lCgJIly5r5yN0JwVWsiSmODw4uv4McRSFRayBWxrUincPoOIg70aVTz09wv + jP/DP7yyf2Xn4odL5z/x5pMvPbOfJOn1oihsWRZnP/r8X7zSqDfWO93OVJEXK71uJ7u/vtr45t3bn/6n + X/rKqfbEXCebOOGTNJk8Org/vX60OPGx82LmZxshlLm0ajW1kBby/vUZrm6ukYcOJj2g3VDUVEK7qcgS + Q1arMznbp7A9EhPYUZ5uH0IO2NjfG11JsBGoJ0KWBmqpUE+gnhCrgEpB3aBJmwt0jwpxzsnMzExbRI54 + TONxTABh+dTZjcvvvn3h2Y9+/EZeFj3TaLVNiGV+2Yd+CWIr/3obEAyZnkTEUNgdprI+yxnscyz1LaLx + PsGGFNGTSNKiXl8haywELYkPYnzpvMtz30PXjySpXw9Za216emGtNTn77qnTZ6+cO39hVSm19fJnPzsA + 7mZnz5//LlBeee+9S0VZ1pvN5p0LFy+uffPrX3/x6gcfvKiUkpmZ2Y7RUvR7R41me2Lr5Kkz9/78v/cf + //LtW7f+6Ve/+Jv/gbK9zy0snJru7LwpyhcEsYhPEGUZQo/DwAwk4J0jVAKaXjxBlwQNLrgIWxYTdQV9 + xPHv5gdM1qAx8TJl+kT40nfePHqn+/x3P/uFX/71T545e3f15vtTm1e//KmTy7Onm0oXd/fKk+9u3sxK + F1ZEJWunz5x/XZRKFxYXTyyvnFz7+b/4V29qrXPnXGNnZ8f3ut2Tmxv3X/zqd7+TTE22nRa7sLP69rmV + 5N6ytvV20n5enZgISZI1BOtoZErlxTYHu+tk6gglgSx1TE8UNGqWzR1HqiG3cZ2rK6GUNFHUdEwCrSTy + FFomxN6/msVor0lr7WDaerdWr9v9vT0tSo0TwA/SJuC9q1f63pUnTZJe0UlqW+0ZCif4JJKBGoVgi9jP + Ow/eKbCCC4LvB0ySslhL2VAt8mSCyamlMDM9G9oT7ZA1s1DawhVOSqvSw9JmN6ZmlrdU0vhwYX6pe/rs + uSutVnt9YnJy0xjjlFLu9s2bE71e11+/dm3mu6+++tKZs+c+mF+Y73/31dd+fHll+YMXXnzx6s0bN88g + 2PMXLtwHwjPPPnvz/IULHUSYnZ3tGGOKw/29Vqdz1Lz87hvPXH7n1fnlE2ev/eVf+ht/+5VvfP0r737j + 1/7muRMvXehvv6WcLygVSHCooLDBRmRgNRRDC8E7vA744ChdVMnxKtJpBYcXQXnDgbNcPxBms0+Rbc2X + X37tvavPfOE//ye/+NRTW++/+nuny/uvZqcvPPPW0z/zV/6Bqs8eBpWUK73DVqdzZCp3IiciYePe1RN5 + Z7s86h5OvHLnveWDTm9xZ2dj7uTpi9eL3t4p55T/8Z/4yV9H9PTs/MJmq/VLR/fu3v3YzRvXGy82mtP7 + e7sn76/fq22v3Tq1vXltamZuMctayVyjWc9aNaWUQfC5dDp7SHIf19vk4KhDp9OhsCVaPInyJBqyBJoJ + tHWUkc4C1HRAB8GbWhwkWdnO8xyxhX9cB4CPawXA1PTclknT0Gq1dpPG1FqqustlV0kSfISRJkJIhJrX + aJ2imQE1j0lnCI06TT3FYqi5br/sdiTZDD5szayculv0e1vJ9OLR4vxSvrC0fHtubn51ZnZ2XWtd7Gxv + a+esufzu26d2t9aeMol+tts5ml45ee7O3u6OnWhP7Jw4+8Stj338E+9feOLiXRE5On/hwv9F1Jizf+oL + P3NnUHBU/eZG9fFArG5tydLKyXe8d3PffeWrL/3W//MPf/Slz/z4txaX/+b6v/hHf++/evrCC5c6W2+o + 4Es0Bufje1eFyAp04isvBEVJIBdHEWw0U/WCMZqaygjisFhSSbGNZ1nrzeZX76a/95f/1q/8L1fe+s7Z + D1/9rebHP/NTv9qcPX0Z6KzMzf0rh2SrW1vvc7z0ECLlPgOke7C90Du43+rleXLt6uXZGx/WllPlJ3Y2 + bp09ceLs+t0PP2iffeqFLz/x1FPp1PTMfpqmu/v7+xN3b99e2Nvb+cjqnZsnDrfWz5T9fruezUxMz0zX + avpp5bwxvVLR6RxJ92hHyt4O+B0yc0iij6hrR4aLk/+BQpI0KKwL2dTS/a2N+63J6dlVovLaOAH8AIVd + v3tjularqcLLAVmGZDNoSTG1FlpmSFSbZnOJpklCKGw4CNoddI78/aOis7lz+zC7+PHXnn75M//iwpNP + v7mwuLgFlCGE0Ot15zc3Nuc+eO+ts6u3ri7s7Wy9uHLqzPrW5v1ydm52a2529v4TT1z4cPnkuY2qhz+q + bpCBMREjA6X8X6fCqd6Qa6tbW7+9t7v1xL/8rX/ysx/7zE+++qf+wn/6y7//a//j3zl78rkLnY03ZbAA + l0oq3BEqU09HkBKnKj6DCpTOE1QUH1eiSROhDBayU4R0qby+k33xl/6z//K/f+X3f/MjM1MT+8//7F// + h8Du/9fh2EiCGCjqDJ4bgK3VrS0BOHnh+VcGm1Gg5WxZW7z+1ql+4WpX3viDs7X6Qlo33ee6u5uNpDV/ + 1GzMvvry537iDxaWlsoQQu/w4ODU1Q/eb3YODxb2djZXwtFeo5HMnShDc6I9dbqeSjmz0DDNqUxJwx6J + 6a1jykN0sQ0ux6opjgpfnnjyiffWbt5YnpyY3OSPlXEaJ4BHNbpziyfuhBDKpVMXr9CTT7VP/JnMFkWp + fMLB3v5Rr+9zKYLPnV/vF2r7zLMfvepmWf/0j/zI+vT09KoP4XB/b8+98eorFxKtLuztbi+snDq1f/f2 + tfqJk2c2F+ambz3x7Av3Gs32AXFcUFRv7ocP+b/Jdqdc3dq68qd/4a/aX//H/+vPf+6nfvHLz3765/+3 + 62/91t+aaJxolUd3UCEW9V5sFADxliAWrxzWWzxx+m/1wORD0HgaiSJRNdoLHwlvf7jzwV/+G//NP/jW + v/xnl06fXFq/8MJnf3tlbq7z/3frNkjeDyeI1a2tW4BcfO6HdFU9NIHJ3dUPFzdWb86uX/3GyQ/fJpme + ajf29o9CozV1MDs7u/7Rj33idycmJ3tJknitte/3eo133nrz+Tdf+cOf/PDW1YuTxZ35peULjdlsUdcn + ntc1vDRrU6zd3+nUm617yub9M8++cP1xTgDyOP6jVre2zJf+xa/+ldnFM9utdvv+V7/4a3+9PTm3PLd4 + 8orzHDz51KXVqenpDa0VSml1dHDgbr7/7ulUQmdn7dbF+sTM/ub6HZk7cfZOUqt3Lj7z0ZtTs/M7InJQ + vTEt4B+V1dDq1pba39166ltf//IP/zs//fNv/k9//7/9H84uhk8fbb2ltLdoTCQXeUvpcsQ7rC8p3BGl + K+iXBYUroh24UrSyhOmWojXxDDvd2e7kEz/zdy9evPj1vdUrJz/+uT/7aytzcwePyL97yGKuLrOms0Vr + e/XGyr0bHyzu7u8v9vOiNTM9ne7v7x8trZy5XwSTPPfix++XpZ3Z2d6u37x+/fl7t2+FWpaev/7db52b + UE4WnnjuKz/7H/0n//Pv/qP/46e/8O//tX+8Mjd3e5wAfrASgHzw7hufzks/8dxHX/xWCOE0MHHj+rW5 + o4OddG97Ux/urj3Tak/vd+7frS+vnL41MznVWX76o1eyydlD4KAqz8vqRg+P+h54dWsr+eZXfufnssZ0 + GVAXrnzn1/92JhutsnsXUQkajXd9rCsINsfiKGxO6SylE1woIZQYpWmkKTOtwMLKF8K33rj17t/4r3/l + v/ja7/3fz332p/7dX83qzVs/AM/FIDGY6qMFNDauv72ydvPDM3m3O7V9f3VxfvEUOxv3J888+/Fvd1xY + OfvkpfXWxERHidwUpfZe/8qXfvoTP/ZT/3hlbm7ncU0Aj2ULsDI3F658eHXzN/7h//lzG6t3ntxcvzs1 + PTu922i1dqenJjY++SOfv6WU+naa1XeqGz3/QTno/6p24O7G/W9/8Z//2s/+2E//2W+++rXfvN2amr3U + O7wnwRcRp+ALXChwweO94ILBBk9wTfA53jtyJZTWUfg2tH355A/9ua+sr96tTU60t7J6c/UH4fmpfsdQ + vbYFlZLP6tbWrYXzH3mlet+nwbmmK/LJcm+ruXn1HXvvlS9P7G2sny9U9qypN0xZFgc8hipA/zbMAJiY + mr7zM7/wF/732cWlg2rS3h8p3R9LWKdSeqteb/cA15xYvlbae08V1mp8jRCEMnSQkOA8BG9wVnA2wbt6 + fEw83lqEFGVmWdst9n7x5370lQ/e+vbcs888d/kHfRpeJQZXfeTAIbC+urUlp5dPv1kNHzMgzTuHU64s + i3+dQe04ATwaL3YfeJ9/u8LtbW3MbG5sTLba02/a3c2fcmWigy8IThOYRoUWhENwBu+KCBgKFmyDQIGo + lEDU11eqcTA3P3/7G/fvfoFnLr31GL9XRhPDIMnt/NvwhjGM4/GKoKwxpm+tS1VoirYLse/3FqWi4aUO + U3ivSXyoZgIF4hUqNKL4aNKnpprgQuKs1bnX3a6DmfGzO04A43ikI52cmStm5+Y6Zaf33IQ0dSrzZFpj + pRt9DCvy0oBPX4YezpRYG3A+B/EYadFSiyjTmrx27dq5M+effifv5W0etE8dx+PQNo6fgscjVre25GBn + 92y/l4fO0dFsZ3P3kiFTtWSWNJmiVTtBu36SVmOZRmOJWjpNlk5SS6epp7O06rM0sjka6SyNdJlUWsxM + zDeuvP3O85eee/7O7Ws3nwYa42d6nADG8WhG89U//MZnnvnYi5e/9pWvfn5hZmHF9gJJOkGathHTQJkU + pTNMUkcnNXSSkKYN0rSJMXXStE09m6Ju2mipkel6snbl6s8476es82Ht1q3nV7e2xu+ZcQIYxyN2+6s7 + H954URLjs1qW3nrj8p+baE6meIVWCdpkJEkNk9RJTB2lU0xSI0laaBNFRePnFGVqaBN1BDo7B3J65fTp + r3zxS3/6pZd/9NV3Xnv9E8D0+BkfJ4BxPFox89a3X/v4Jz/38ltf/t0v/qUnT1+4mO92RYJBqQSlDEan + aJWhdVp9naJEo00NZWqkWYM0a2J0DaVqaNMgWEXd1JKdG6s/1+kcLbZnZ7euvPbGZ1a3tsazo3ECGMcj + cvsn77365idPPHHuxvra2snenZ2fSkkTsYJRCVpMJRSaRAFRDEpiAtA6i6Yi1Z8bXSPRNYzOqu9N6Gx1 + 5NzK2ZXf/tXf+KVP/PCnr6zdu3felXZ5/MyPE8A4HoHI+/mJq+9evvTcCx9d/fJv/u5fu3jm4mK+241O + QpVrkMGgg0Kj0Sqp7MA0ikFlkGAkQVcfShKEFBGDCprQc6bta597/bXvfmbhzKnrb379lc+vbm3Vxs/+ + OAGM40/29k9f/8q3PvX0J55/7xtf+9qPTbr6y/7QaqwgIbpcKNEQFIJGxES1Uq9iVRA04jUqGBTVfweN + eIMOgvaCCoLrlJxYWJn87pe/+RcufeS5+zs7O3Pdg6OzAwrvOMYJYBx/AtE96Jzc3tpeOvfExZ3Xf++b + f/7k3ErLHpaokUOOl0rlRyNBIj04RGXgQSUQD331eJDoY+AEZyF4ASfkOz213Jx/8Uu/87t/6okXPvLW + G9/4zieJsNlxjBPAOP4kbv93XnnjpYsvXLr87W9+61MX5s8+Wez0BRsPrwoK5VUs/8UgIToSSYjVQXws + 9v8GjfIKcQrtNTpoxCnEC6EI0UuhY5mfnGu8/423f2FhaaHsdLozZVGeGL8S4wQwjj+BcNbN7+3unzhz + 4Vz3rd//zl+Zn5pv2CNLGMj9BjV0IcKB8grl4u0uXhCv0EEhLn4dHxOUV3gbIireRgMFb+NHvtOTC0vn + nvjql7/yYxeef+qDy6+89dHxRmCcAMbx/b/91fuvXn62Nllfe/P1159ZSOeeyrf6KpSAFcRrxApYibd3 + DqEUXO7jjV4Q/7wEnIAFcRqsIljQ3qCcRnmDOI04QQWN63nmJmezy197/QtLK8vl0f7O08GHMUVgnADG + 8X2OdGN94+yLn/7EvTe//vqfXppeatqDkuDiLU4JvvT43OOLgC88ZbeEUvB5LOldHuKBL6NBqi/j45QK + SkGcjgacLrYDwSmwiuKgkKX24vlr166d8Yre4f2tC+Nh4DgBjOP7G5PWlan3LlM7/nnjUxUKgQJcP+D6 + ntAD3w/4vsf1PKGQ+HgRvRB9GbB9Xz3G8HFsPOzxe0CcEKr2gCDYjmVlYaV9+a13fnTpwpn7tz68cYEo + yTWOcQIYx/eh/Jdb7908V9iyXFtbW5kwk9P5/ZzQE0IfQi8gPXDdgO0EbMcTcsH3IeQa34+Joex6fA4+ + F0Kh8IUQckUoFWI1OEGsqoaBGkFDEJRTtGotvfXh2rMnTp8qjvaPlhhvA35gYzzA+cEL2d3cnTn3zPnb + 197/8OXJdDpz9x2hiEM/RbQ8Cz4gEo0+naoqdAnRb1iiTboLIboJiiYEjyK6JItWKF3J6skxlkBL/DDB + SNpVJ9dWV1Vjop0TWYKd8UszrgDG8X1I2pu3N57QRre317eXaqauQ0+hyjjE84Ui5EIoNL4QfA7SF0IP + XC8Q+uD7QKnBacQlBCuINwSvwOtY+ntTHXpDRBLoIWzY9z3zS4s1W5YnD7f3T9h+OTd+WcYVwDi+TxVA + r9trm8T0QxkuiFPK9aONuSgFPiAORCmstdHglACiIIToE6gkGqLqyk9YBEHjgwMBYyoUoVLDm1+JRqlo + ay42UFNp7YP3P/iY6Qff2dyfXN3aksfVQXecAMbxSEXwkGaZ8s43ggfxCkTw3iOiEFF459GSEEL0AnTO + VQnAx2SBIviA0irapiNoJbE9CAFBRS/BAY6wKv8FIIBRWu13Oq029YPxKzJOAOP4PkbN1Hyv29PW2QNE + ETxoraL7r4o3vVEa56LNuSt9dZCJVmFI9MsOoJRUOl+CSLRN11ojShAFCoVSGq01SgSlBG0S8n5ZnD1/ + 7u3+6sFENtHoj1+VcQIYx/cn7PL5lWsS6EomN8rD8rOI0q4EdLzVQwjVpE9iiR/iLe+Igz6RStpPpLrt + BaMFlBBlAwcHXVBG0FqjRarqAnRNs3/vIH9iZuaa9fWZ2mRjY1z+/2DGeAj4gxe+PT2xevfDuysf/cQL + H+739wtpKJz1sfcPgkbHEl4USlR14KnswauiPihUIH6IwOB7kUgSUtXEX2m0UjEhSPwzXTPhwHXWFxYX + O7s724qorz+OcQIYx7/pWJmbCycunbidhDSdX5x/f21jfb+20gAEW3q8JfIAiLe7D75KAMMmYJAKYjIQ + jUh8XEQwSlePD1oC8N5HJeEQV4u9vB/0fPZe5/Co32w0t4imK+MYJ4BxfD8irSdbZb9UyysrO+5E+bbN + Su9VfDm9l4r1B2Yg6BHigQ/BE5wn+PiZoGKvL/HPvfPgQ3QT9p7gAsF5oqlw/JoU7qzf7V78yFNf/+D1 + 904snjxxk2NH33GME8A4vg/RX1hcvPrKH3xr5eM/8fHfWNtZO1QLirJ0eOdx1uOsi4fYe/A+VgCDMj/E + KiB4X7EAQbxHEW957z3BOry14AKusHhr8d4hDRXu7N/54JOf/tRr9qiYnT+3/MG4/x8ngHF8f9sA9+Qn + n3iz2LGLn/z0p145nNr7pjlpXEgCzlmsdzjvcW6QBALeu2oVCN45vLM473DeYa3FOY+1DuscZVHgXKC0 + ln6eU5aWPM+hBrfv3+5c/OFnfv3ezTuTs4vzH+pEb45fkXECGMf3OUxm7s8vz9987RuvnvnRX/jsr9ze + uLGWXUyDJ1CWFltayrLEOYe1JWVZUJQFRVFQliXeO7xzlP0cW5aURUHZzyl7ObawFHlBWZSUZUmR5zjl + sRPBbia7f/j5n/jx37n8yttPPffDL357ZW6uHL8a4wTw/7ZzJz1RBFEcwP/dM9ODAz0gjKgI6kBwRcHE + jUXFJSpE3GI4eNQv4LfwqolfwLgcvIjGRBNEEtwxOJDIpgY3wgQzQCLQXa+qq8vD8BkUkvc79rFe+l+V + 16+L/ftTQLDrUN373MRMuqameqJ4r3t3IfbHQzkglYQvCFIqCCKQIiilloKAEAQqHwREkCRAvgcpBCQJ + KCUghQdJHoTvgQSBAkK0wtHj2S8f2y533Mi8G9iU3lozGovHfnElOADY/ypexJ7ec2jPq+ddPY0dnWcf + ZOOT3XqDIqw3UIGCkAIkBYgIvvCgJEEpCSIBEj5IeCDhIyAF3/NBvg9/cQGCPJC/FAByEbGNTvh5cvxr + U+fh6zBY/D2RXVfX2PCmIpXi5t8Kxxc5rHBTuVxB5lXmZGCUU3+g4cedm7evFc0Xn9HT2vVHfQvaIDQa + tm3DmBDaBEtTfhZsG1ChhmXlh4JCo2HZAKL5zwjRZBRl9akg5+XG911qvr5t5/bMi0fdrUfPHH+6qjDx + nZt/HABseYRAsqer51xi9Sra33xg6FnX085sf/ZKwiqsmh2aiwSzCkbnX+r8rH+Y/zXYMjBWCADQVv6Z + sQwsB3Crk8bdnFwwCd3dcr71VkXlhqnH9x62Nx5reV2VrhqoSKU0rzwHAFs+IVDS+6S3LV7k+E2tzQOD + A4MNH571X41QrEV7umRmeCaiZlX+os/QIISGNiHsiIUAGmHEwE7YKKoqNKXVpYSY+bwmveb+qQttD6SU + 8dc9L/fv2F03kq5ND3HjjwOALc8QKBzsHzz449v3yiOnWt+7ruu97XvTNPph7KKYE/WOEy+jBXLEH98O + AmVpFSJaEIUds8JEcUJbMczDsSZSlWUvjrWfeFy+tvzX2MjoluHMp9qTHaf73KT7k3d+xhhjjDHGGGOM + McYYY4wxxhhjjDHGGGOMMcYY++/+AtOat9bN6vgLAAAAAElFTkSuQmCCKAAAAEAAAACAAAAAAQAgAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOzs5gG9ubgOinaELHVS + bz15XXQ8m5OWGLWzsQwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAC0q645l2mRt4U1f/5+J3v/eyp4/4FLgfKfip5+u7S3GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAC9r7capHabrqE8mf+gPJn/nkCY/59Hm/+fTpz/oWWk+6ucqnDp6OMCAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAua+zP6NRnPinQ6H/pUKd/6RHnP+lUJ//qFmk/61s + rv+si67Ev7a/GwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKSZn2elVaP/oUef/55G + m/+cSZj/nk+Z/59VnP+maKb/p4Wr4rOpszIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAC6tLY5m2ef95teof+aX57/mV+c/5Vbmf+WXJv/m2ig/6OLp8G+t74aAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAuLG2G56Go7eac6T/m3ek/5h0oP+TbZz/j2mZ/5Z0n/6mnad36+rlAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACsp6xTlX+g95N7n/+Pd5r/h3CU/4Zw + lf+WiJ3HvLq8JgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAure5FZWP + n6p5cZL/dG2O/2hihP9ubIv+paSnY+zs5gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAKmrrQ6gpqceztTRCuzs5gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAOrr5QOLl5ySOm6B/zRofP8vXXL/P2d2+bK3t0QAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADq6uUDtLvLEZuhsSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACzt7Upe5ScoXiOn6yEkqyUlp2oYLm8uiqwtLMmo6uqHM7S + zwrs7OYBAAAAAAAAAAAAAAAAAAAAAAAAAACwtrQwaYmXzz55lv8wcpD/Fmd9/yZ0jf+AlJ+Trrm9FQAA + AAAAAAAAAAAAAAAAAAAAAAAA7OzmA7K9vhGmsrcjuL+/MauxsEqbo6VkgZGjn22GsMSIlbCJys3PCwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu767NDpsifgBUob/Gmm8/y9d + m/5AXW3uWn2K2W6Jk7R6jpSdkpqabq+vqzm7u7crxMS/Gba3sySmratLbIybvUF+n/9EeaL/O2+f/yBm + k/8fa5P/Ooi7+Xmiv6uir7NWsbq7Rbm+uz+WoaJmkaOogYSqwJ90i5bAZ32FzU98h+81ZnH9J1Rg/wZb + fP8BaKn/Z4Krwp2jqh4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJ2i + pVMtUXn+AT96/wJpu/8BR4D/AU1p/wpmh/8FY4X/A19+/xBCUv8pLC/8NlFY+ERDReVLSkviOWBt+iV0 + j/88ep//RHKg/zlmmf8pYZr/Kmun/yiIzv8fp+b/M5W3/Uuo0/o2mb77Np7G/x6OsP8Ucon/C3KN/xNE + U/8OS1j/BD1F/wE7Qf8BSVv/AVyH/1J1ntuwtLcmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAOzs5gGKkJ+BDDdu/wFJkP8Bcbv/AUWD/whVff8QYIn/B1p9/wZRb/8JNUP/Dxoe/xAo + Lf8NDBX/Dw4Y/x8jLv8uNUD/NTlF/ycwOP8cJy7/HTFJ/xlCaP8PXJD/CYzI/wGLuv8Bmsn/AXmU/wF/ + mf8BlsD/AXiU/wJshf8KUF3/EzpI/woxO/8DLTH/ATY9/wFPa/86aZT5s7a4OwAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADCx8sNc3uUqQE9hP8CWKP/A3O2/wZIhf8NPFv/EDBD/w4j + LP8MFxz/ChEU/wkNEv8JDRL/Cg0T/woNFP8LDRX/DhAY/xARGf8WFx3/ExYZ/xMZH/8SHCv/CTdf/wFz + qv8BhsD/AYS6/wOMxf8Ig7X/CIey/yKLwP8YZY3/B1Bb/xNCTP8UPUj/CC81/wEzOP8BQFL/MGSL/5ed + pGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAo6qwH2R0krsGR4v/EEV//woz + VP8LHCz/CRMW/wgRFP8IDxL/CA8S/wcOEf8GDRD/Bg0Q/wgNEv8JDxP/CBEV/wkTF/8LFxv/Dxsf/w8Y + G/8QGR//Dx4q/wsjNv8CXY7/AWyg/wFxnP8BgrP/A5fP/xR7qP8Tcaj/IkBU/yVFUf8mSVL/HkhS/w9C + Sv8DO0X/AThG/xBDXf+PlZlw7OzmAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALCz + syNRWWXNDB0z/woVHf8IERX/BxAU/wgRFf8JExb/CRQZ/woXHP8JERT/Bw4R/wcND/8HDRD/CRca/wkg + Jf8JKDH/CSw4/wouOv8LKzf/DCg0/wsvQv8FOlX/AVFy/wFWf/8Beq//AYCt/wF0of8BZ5n/CEBb/xI5 + Sv8fLTD/KzQ3/ys9Qv8jQEr/F0JV/wo+VP8ENUv/eX+DiszNyQkAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAC6urYYSkxL4ggQGP8IEh7/CBIe/wgVI/8KHS7/CyIv/wskMf8LIiz/CRIW/wkR + FP8HDA//BwwP/wkVGP8KHyX/CyYu/wsoMv8MKDP/DCYv/wwjK/8MKDf/Ci5E/wYxSv8BRWH/AlFs/wNX + gf8DY5D/BlB7/wkrOP8PIST/EiEj/xYjJv8aJyr/Gyov/yE1RP8jOVH/ECw+/2lubpiVmJURAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuLi0GzI0OPoIFyb/BC5A/wYXLf8IGC7/DCI2/wwi + M/8MITD/DB8s/woXH/8JERb/BgsO/wYLDv8IEhX/Chsh/wsdJP8LHSX/DB0l/wwcI/8LGyL/Cxsj/wwd + Kf8KIDD/CSIy/wVDZv8EOVf/CiUz/wwgKv8MHiT/DB0i/w0bHv8PHB7/EB0g/w8dIP8QHyP/ER8n/w4Z + IP9XWVi24uLdBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJqamDMaISr+ByEs/wM1 + RP8GFiv/CRgt/w0gMP8MHi7/DB8x/wwgMf8MHCv/CRAW/wYKDv8HCw7/CBAT/woYH/8LGyP/Cxol/wwa + Jf8MGiP/DBkg/wwYIv8LGSX/Choo/wocLP8LHS7/DCEy/wsiMP8MICr/DR8n/wwdI/8MHCD/DRwe/w0c + Hv8KGhz/CBkc/wgbIP8IGiD/UlRTzuzs5gIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAB8fnxQCxki/wgjK/8FLjj/BhYq/woXLf8NGyv/DBws/w0eMP8NHS7/DBcj/wkNEv8HCw//BwoO/wgO + Ev8KFBr/CxYe/w0YIP8NGCD/DRcg/wwXHv8MFh7/DBYf/wwXIf8LGCT/DBop/wsbKv8LGyb/Chsj/wsb + Iv8LHCL/Cx0i/wwfJP8MHyL/Chse/wcaHf8GHCD/BCEr/0FHS+zl5d8FAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAbW9uZQkXIf8JIyn/CCkv/wgXKP8LFin/DRkp/w0YJv8NGir/DRgo/w0V + H/8LEBX/BwsP/wcLDv8KEBT/ChMX/wsVGv8NFhz/DRce/w0WHf8NFhz/DRQa/w0VGv8MFRz/DBYe/w0Y + If8NGSL/DBok/wsZIv8LGiH/Cxsh/wweJf8MISr/CyUu/wojLf8HGRz/Bhoe/wQgK/8yPkf6rK2qEQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGBjYnIIGSH/CiIn/wkjKv8IFiX/CxUm/w0X + Jv8NFiT/Dhkl/w4ZJf8NFB7/CxEW/wgMD/8IDA//DBMW/wsTFv8LExf/CxMY/wwTGf8MExj/DBMX/wwT + Fv8NExf/DBQY/w0VG/8NFx3/DRgf/w0YH/8NGB7/DBkf/w0ZIP8NGyP/DR8o/wwiLv8LISv/CBYZ/wga + Hv8FHyv/MT5K/W9ydBsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB5e3pVER8l/wof + JP8KHyb/CRUj/yUpMf1RU1XSV1lasFdZWsAzNjv4DBQc/wsRFv8IDA//BwsO/wsRFf8LExb/CxIV/wsR + Ff8LERX/CxEV/wsRFP8LERT/CxIV/wwTF/8NFRr/DRce/w4YH/8NGB7/DRgd/xEbIP9HSknmWVtbtFhb + XLZFSk3pFCEp/wkVGP8JGR3/Bx4p/z5GTvCtrqsMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAuru2G1hbWsgQJCf/Hisv/lpcXLqhop9PxMS/H729uQq/wLsarq6qPl5fXbkOFBj/CAwQ/wgL + Dv8JDxL/ChEV/woRFP8KEBP/ChAT/woQEv8KDxH/Cg8S/wsRFP8MEhX/DRUZ/w4YHf8OGR//Dhke/y0x + Mvt6e3iIv7+6KMXFwBPDxL8Wvb24KIWHhHJJTErhCxgd/yMtMv16fXyCwMC8CAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAANjZ0wS6urYtgoWBd5CRjmPBwr0iz8/KBQAAAAAAAAAAAAAAANjY + 0wPAwLslU1VTyRkfJf8JDhP/CQ8R/woRFP8KEBP/Cg8S/wkND/8JDQ7/CQ0O/woOD/8KDxH/DBMW/w0V + GP8OFxv/Dhge/xIcH/96e3mIycrFFwAAAAAAAAAAAAAAAAAAAADAwbwOvb24LIKDgHSWmJRdxMXAGwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOTk3wXs7OYDAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAxsbBCJiYlV8gLTL+CxAU/wgND/8JDxD/Cg8R/wkNDv8JDA3/CQsM/wkM + Df8JDQ7/CxAS/w0UFv8OFRj/Dhca/w0YHP9GSUjovr65KwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AADk5N4E7OzmAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC6urUuNjg4+AcLDf8IDA3/CA0O/wkN + D/8JDA3/CQoM/woKDf8JCgz/Cw0O/wwRE/8NFBb/DRUY/w0WGf8OFxr/WltasLe4tB0AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAubm0LTY2 + NvgHCgz/BwsM/wcLDv8ICw//CAsO/woJDf8JCQz/CgkN/wsMD/8MEBH/DRMV/w0UF/8OFhn/DhYZ/1la + WLG4uLMcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOzs5gPs7OYBAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAA0NDLBZ6emlgUFxj+BwoL/wgLDP8JDhD/CQ4R/wkMD/8JCw7/CgkN/wsKDv8LDA//DBAR/w0S + FP8NFBf/DRUX/w8WGf9LTUvhxsbBJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADs7OYD7OzmAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA09TPA76+uiiNj4xwmJqWXLy8 + uB/f39oCAAAAAAAAAAAAAAAA5ubgAcDAuxVYWVjBBwwP/wcKDP8IDA3/Dy9I/y9znf8GSWL/CxEU/woK + Dv8KCg//CwwQ/wsPEf8OEhT/DRMU/w4UF/8PFRj/Fhsd/4CAfn/Y2NMHAAAAAAAAAAAAAAAAAAAAAMjI + wwq/wLonjI2La6ChnlDHyMMUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALy9 + uBxfYmG/IC0v/y04Of1jaGezpKWiScjIwxnExL8SwsK9Gbm5tTNeX12wDxMV/wcLDv8HCg3/CQ0P/xRD + Wv9hosH/Cnuk/woSFv8KDRH/CgsP/wsMEP8LDhL/DRAS/w0SE/8OExb/DhQX/w8WGP8rLi76goN/e8XF + wCO/v7oWvb24GMnJxB+Sk49iUFFR2BMdJv8rMTf7gIF/c8TEwAkAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAB6fXtVJTI0/x8tLv8fLi//IjIz/zM6PvtXWFfCXl9dnV5eXKs9Pj3wCg0Q/wkN + D/8IDA3/BwoM/wkND/9IYnr/QHOb/wc5Sf8MERT/Cw4R/wsMEP8LDBD/DA0R/wwPEf8NERL/DRIT/w8U + Ff8PFhf/DxUY/xkeIP9OT07cXl9do19gXqRQUVDaHCAh/g4YHf8NGiP/DBol/0NHSevMzMcIAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAGde8AEAAAAAYWdndio6PP8lMzL/IC4v/yAvMP8eKi3/FRsk/w4R + Fv8LDhL/CQ0Q/wgMDv8JDA3/CAsM/wgLDP8ICw7/CCE2/wswRP8OExf/CgwQ/wkMD/8KCw//CwwQ/wwN + EP8NDhL/DBAR/w0RE/8PExT/DxUX/w8WF/8QFhn/EBgb/w8ZHP8OGRz/DRQY/wwTF/8NGB3/DRoi/w0c + Jv81O0D9dXd3GwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZ13vBWBW3RxbUtIqYVjfH3N2kHw/S1f/MkFG/yg1 + OP8jMDL/ICss/xwjKP8TFx3/DRAU/woOD/8KDA3/CQsM/wkLDP8ICgv/CAsM/wgLDv8JDA//CgwP/woM + Dv8KCw//CwsP/w0NEP8MDRH/DQ4R/w0PEv8NEBL/DxIT/w8UFf8PFRf/DxYZ/xAYGv8PGh3/DRgb/w0V + GP8NFRn/Dhkh/xAcLP8VIjf/OD9Q+qSizRhnXu8IZ17vBmdd7wIAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZ13vA1NJvjYpGUqnIQ4szicX + RL1MR2zJTU5y/01ReP9AR3L/Nj1q/y4zW/8oLE3/ISQ//xYZLf8OEBv/CwwQ/wkMDf8JCw3/CQsM/wkL + DP8KDA3/CQwN/wsLDv8MCw7/DAsP/wsLEP8NDBD/DQ0Q/w0OEf8ODxP/DhAT/w4RFP8PExT/EBQW/w8V + GP8PFxr/Dhkd/w4XG/8QFyX/Gx9B/ycpX/8sLmn/LC1m/z48avdFPYSGOzCBfkI4lGVVSsE8ZVroF2dc + 7wQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZ1zvAWdd + 7ws+M4htHAUL6xwFC/0cBQv9HwwQ/SMVF/8oHh3/KSEk/ysmNP8pJEf/LCVU/y4pX/8uKmX/LCll/yUk + WP8XFzb/DhAb/wwMD/8LCw3/CwwN/wwMEv8QDx7/EBAh/xEQIv8RECL/EhEk/xUULP8WFjD/FhYx/xgZ + N/8bHED/HB1B/x8gSP8fIkr/Fxwz/xEbJ/8eIUj/LCpm/yomXf8hGDn/GwsU/xwID/8fDBH+HAYM+BwF + C/YcBQvwHggY2TAiYaFRRrlIZlzvDQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAZVrqDFRJwDBQRbZBVErAbCgZSdgcBQv8HAUL/xwFC/8cBQv/HAYM/x0GDP8cBwz/HAcM/xwG + DP8cBgz/HAcN/x0MHf8kGUL/LCZf/ysoY/8aGTv/Dw4X/w8PG/8hIE3/Kidh/ywpZv8sKGP/Kydf/yol + XP8sJ2D/LShj/yslXf8qI1f/KyNa/yghVP8mHUr/Jh5K/y0rZv8uL23/KyZd/x0OI/8cBg3/HAUL/xwF + C/8cBQv/HAUL/xwFC/8cBQv/HAUL/xwFC/4cBQv3IQ8vzko/qFxmW+4LAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAZlvvB0c8oVQiGjPHIzBF3yMcOtslFTvrHAUL/RwFC/8cBQv/HAUL/xwF + C/8cBQv/HAUL/xwFC/8cBQv/HAUL/xwFC/8cBQv/HAUL/xwGDP8gEzH/Lill/yMhUv8gH0v/KCJV/xsH + E/8bBQv/GwUL/xsFC/8bBQv/GwUL/xwFC/8cBQv/HAUL/xwFC/8cBQv/HAUL/xwFC/8eDyT/KiFU/xsH + Dv8cBQv/HAUL/xwFC/8cBQv/HAUL/xwFC/8cBQv/HAUL/xwFC/8cBQv/HAUL/xwFC/okEjrDWEzKOGZb + 7wMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGZb7gw5LHp7Llh371Cv6/5NquP+RZbJ/jt8 + p/8wX4D/KERd/yAkNP8dDxn/HAUL/xwFC/8cBQv/HAUL/xwFC/8cBQv/HAUL/xwFC/8cBQv/HAUL/xsH + D/8rJVz/NDJ5/yEVN/8cBQv/HAUL/xwFC/8cBQv/HAUL/xwFC/8cBQv/HAUL/xwFC/8cBQv/HAUL/xwF + C/8cBQv/HAUL/xwGDP8gIjH/LVVz/zh0nf8+hLH/QIq5/z2Cr/81bZP/JTlQ/xwGDP8cBQv/HAUL/xwF + C/8cBQv+HAUL8TsugYBmW+8NAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABnXO8DU0i+Oikc + TbMrT2zxSqTb/1O59/9Tuff/U7j2/1K28/9Qse3/TKjh/0eb0P9Aibj/NWyR/yhEXf8dDxn/HAUL/xwF + C/8cBQv/HAUL/xwFC/8cBQv/HAgW/zIrav8oHEj/HAUL/xwFC/8cBQv/HAUL/xwFC/8cBQv/HAUL/xwG + DP8cCBD/HAcP/xwFC/8cBQv/HAUL/yhDXf9Aibj/T67o/1K29P9QsOv/Tarj/1G18v9Tuff/U7n3/1Cy + 7v89ga7/Hhkm/xwFC/8cBQv/HAUL/xwFC/spGUq0YlfkIGZb7wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAGdc7wZeU9k0MSRmuDh2n/tTuff/U7n3/1O59/9Tuff/U7n3/1K29P9Qs+//U7j2/1O5 + 9/9RtfL/SZ/V/zVrkf8eFyP/HAUL/xwFC/8cBQv/HAUL/y1ScP82b5b/OHSc/zp6pf86e6b/O32o/z6D + sP9BjLz/Q5DC/0WWyf9IntP/SqLZ/0KOv/8dEx7/HAoT/zdymv9Qsez/U7n3/06s5v81a5H/Ii1A/yId + MP8uUm//Tani/1O59/9Tuff/U7j2/z+GtP8cCRH/HAUL/xwFC/8cBQv+IAwn0VlNzTZmW+8CAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABnXO8BZlvtHC0eWK89ga77U7n3/1O59/9Tuff/U7n3/1Cy + 7f8uVXT/Hhso/zFggv9OrOb/U7n3/1O59/9Tufb/SJ3S/yU8U/8cBQv/HAUL/xwGDf9DkcP/U7n3/1O5 + 9/9Tuff/U7n3/1O59/9Tuff/U7n3/1O59/9Tuff/U7n3/1O59/9StvP/J0Jb/ypKZf9StfL/U7n3/0+v + 6v8qTGj/HAUL/yASIP9UUI//Xld0/zxlhv9TuPb/U7n3/1O59/9RtfH/Kkxo/xwFC/8cBQv/HAUL/h4J + HtdUSMA7ZlvvAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZ1zvAl5T2S4jFTXJR5rO/VO5 + 9/9Tuff/U7n3/1O59/9Ek8X/HAYN/xwFC/8cBQv/MF5//1K39f9Tuff/U7n3/1O59/9LpNz/Ii5B/xwF + C/8cBQv/ICQ0/0ORw/9TuPb/U7n3/1O59/9Tuff/U7n3/1O59/9Tuff/U7n3/1O59/9Tuff/U7n3/zt9 + qP8vWnr/U7j2/1O49v86eKH/HAUL/xwGDP83Lz7/h4Gb/5qQrP9GUGD/UbPv/1O59/9Tuff/U7n3/zyA + rP8cBQv/HAUL/xwFC/0hDzDLXFDVMWZb7wIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGdc + 7wNQRbZJISQ33k2r5P5Tuff/U7n3/1O59/9Tuff/O3ym/xwFC/8cBQv/HAUL/x8eLP9NqeL/U7n3/1O5 + 9/9Tuff/U7n3/zt7pv8cBQv/HAUL/xwFC/8fHCn9QIm5/lO49v9Pr+r/Q5HC/z+Htf88gKv/Onmj/zp4 + ov89ga7/RpjM/1K28/9MqOD/Llh3/1O49v9QsOv/JC9B/SMVGPwvJib/c2+F/7SuyP+Oh5j/QGaF/1O4 + 9f9Tuff/U7n3/1O59/9Gl8v/HAoS/xwFC/8cBQv3MCJjnWVa7RcAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAABmXO8IQzeVaCxPXu1cyPX/Vb33/1O59/9Tuff/U7n2/y9be/8cBQv/HAUL/xwF + C/8dERv/S6Xd/1O59/9Tuff/U7n3/1O59/9Gl8v/HAUL/xwFC/8cBQv5LB9S0ykhOt9AhrT8UbPv/zhz + nP8dERv/Kx1O/yYXPv8cBQv/HAUL/xwGDf8zZor/UbTw/zdxmf9Qs+//R5zQ/SgbNN1dWJ+KenemhpCO + u792c4fxQU5g/0ym3v9Tuff/U7n3/1O59/9Uu/f/TaXR/x0NFf8cBQv8Hwoh1E9DtExmW+8FAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZlvvDzcqdYw+e471Z9z7/2bZ+/9fzvn/V8H4/1G0 + 8P8lOlD/HAUL/xwFC/8cBQv/JDRI/1Cw7P9Tuff/U7n3/1O59/9Tuff/RpjM/xwFC/8cBQv8Hgoe1lFK + t1xSS65eOjZH2Tp7pv9RtfH/Qo6//yQsRP8vIVf/HAYO/xwFC/8cBQv/HAcO/zZwlv81ao//SqHX/z6C + r/oqHU+wZV3pKVhPyD8vI12nLExo8Uyn4P9Tuff/U7n3/1a/+P9dy/n/ZNf6/02huP8cBgz9HQcW4EE1 + knJlWuwUZlrvAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRZ6RssHVatSpqz+mXa + +/9l2fv/Zdr7/2XZ+/9awOP/Hxwm/xwFC/8cBQv/HAYM/zl2n/9Tuff/U7n3/1O59/9Tuff/U7n3/z2C + rv8cBQv2IA0o0EI6kW1nYewToZ/bF3BtnZchFzX/O3yn/1K39P9Kotn/KERe/xwFDP8cBQv/HAUL/xwF + C/8cBQv/HAUL/yIwRPwhIDXZRz6ecFRLvlcnGUO+M2iM9U+w6v5VvPf/W8b4/2HR+v9l2Pv/Zdr7/2LS + 8v8xXGv8HggY4EAzjH9eU9o9TECsSlVJxTNmWu0JAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGZb + 7wFcUNUuIxE2ylSy0P1k1/r/ZNf6/2TX+v9k1/r/W8Pj/yU2Qf8cBQv/HhMa/zx4j/9Vu+7/VLr3/1O5 + 9/9Tuff/U7n3/1G08f8rT2v1NSpvp1VNv0JoYu8OgHzvAcXFwShPTlveMCts/yEVM/8/hbP/U7n3/0+u + 6f8vXH3/HAYN/xwFC/8cBQv/HAUL/xwFC/8cBQzySD+gjldPx10kFznHPoGi+VrF9f9g0Pn/Y9b6/2TX + +v9k1/r/ZNf6/2PV+P9EjKT7Hwwi2EI2knVaT9FKJxdGsRwFDOMhDSzDT0K1Q2ZZ7wQAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAABmWu8EUES3SSAbKd5bxOf+YtX6/2LV+v9i1fr/YtX6/2LV+v9dyOz/Vrvc/1rC + 5P9h0/f/YtX6/2HT+v9fzvn/XMn5/1W67v83cZj+HQoX7UpBpXJoYe8NAAAAAMTEvxJ+fnuDGBMk/yMf + Tf8zLXH/ISM4/0mg1v9Tuff/UbPw/zNnjP8cBgz/HAUL/xwFC/8cBQv/HAUL+i8hW8ouIVrFQIOb92HS + 9/9i1fr/YtX6/2LV+v9i1fr/YtX6/2HT9/9ImLP7Ihkz0Eo+pmBlW+wfQjeVbxwFC+wcBQv9HAUL8jwv + hH9mWe8MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZlrvCEQ4mmkqSVntX871/2HT+v9h0/r/YdP6/2HT + +v9Us9X/SZq2/1a52/9g0vn/YdP6/17M8f9Vtdb/T6nI/0GGoP8qSVn/HAYN/xwFC/kqHU+xYVreImhh + 7wHJyMMcU1JY1ywnXv8rI1n/NC1z/zUscv8xXXr/WsX2/1vI+f9aw/D/MmB0/xwFC/8cBQv/HAUL/xwF + C/8cBQv7KENS+1zI7f9h0/r/YdP6/2HT+v9h0/r/YdP6/1/P9v9CiqT9IRcv3E5DsmxTSL9OQTWSbTQm + bbYcBQv4HAUL/xwFC/kwIWKiZFfqFgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGVZ7g44K3mJOnSN9V/Q + +f9g0fr/YNH6/2DR+v9dyvL/KUVU/xwFC/8eFx//RZGu/1/Q+f9dyvL/RpKw/yAlMP8cBQv/HAUL/xwF + C/8cBQv9Hgkc2VNLvT9oYe8Du7u6LkpGZvQvI0r/HAYM/xwGDP8mF0D/Hx8o/1a53v9g0fr/YNH6/1a6 + 3/8iKzb/HAUL/xwFC/8cBQv/HAUL/0CFof9g0fr/YNH6/2DR+v9g0fr/YNH6/13L8v86dIz/HAgP+zUo + cbdUSL9tIRwwzjNiePEeFh75HAUL/xwFC/8cBQv7KRhKsmBT4R1lWO8BAAAAAAAAAAAAAAAAAAAAAAAA + AABjVuYbLR5Yq0aTs/pez/n/Xs/5/17P+f9ez/n/Vrzi/x4XIP8cBQv/HAUL/yMvO/9aw+z/Xs/5/17O + +f9Pqs7/ICcy/xwFC/8cBQv/HAUL/h0GEt9RSbpJaGDvCquqyzNZU3zrMiRJ/xwGDP8cBQv/HAUL/xwF + C/9Jm7z/Xs/5/17P+f9ezvj/PX2Z/xwFC/8cBQv/HAUL/xwFC/9Jnb3/Xs/5/17P+f9ez/n/Xs/5/1zJ + 8v83bof/HAcN/xwFC/4jEjfiMyVqzDlyi/hcyvP/LlVp/xwFC/8cBQv/HAUL+ycVQrZfUt4gZljvAQAA + AAAAAAAAAAAAAAAAAABmWe8DXE/WLyMTNslPq9D9Xsz5/17M+f9ezPn/Xsz5/02lyf8cBgz/HAUL/xwF + C/8eEhr/V73m/17M+f9ezPn/Xsz5/0GJp/8cBQv/HAUL/xwFC/wjETPKXVXWPUY8mlpEPmWgUk171D00 + f/8dCBL/HAUL/xwFC/8cBQv/QIel/17M+f9ezPn/Xsz5/0+q0P8dDRX/HAUL/xwFC/8cBQv+RZGx/17M + +f9ezPn/Xsz5/17M+f9FkbL/HAcO/xwFC/8cBQv/HAUL/hwFC/xEjq7/Xcz4/zp3k/8cBQv/HAUL/RwF + DO40Jm+LY1bqEgAAAAAAAAAAAAAAAGVY7wFkVusQWkzQL0o9qHAhJTLlVrzn/lzK+f9cyvn/XMr5/1zK + +f9Ci6z/HAUL/xwFC/8cBQv/JTlJ/1nC7/9cyvn/XMr5/1zK+f9RsNn/HAkQ/xwFC/8cBQzwNyx1jWJa + 4jkkFzu6PoGg9zdmf/YwJ035KBlF/xwFC/8cBQv/HAUL/0GIqf9cyvn/XMr5/1zK+f9Ts9z/HhUe/xwF + C/4cBQ7vKhtN2zVpgvlbyff/XMr5/1zK+f9cyvn/OHCM/xwFC/8cBQv/HAUL/xwFC/8gIy//U7Te/1zK + +f9Dj7D/HAUL+B8KItg2KHONWk3TKmVY7wMAAAAAAAAAAAAAAABiVOUTNyl3eyMjO80oQFXpQIWo/FrG + 9/9ayPn/Wsj5/1rI+f9ax/j/NGiD/xwFC/8cBQv/HAUL/zp2lf9ax/j/Wsj5/1rI+f9ayPn/UK/a/xwJ + Ef0cBQvtKx1SqFpRzjJiWeIoJhhBuUeZwPtZxPT/RZO4/iU3R/8cBgz/HAUL/yMxQP9Sst7/Wsj5/1rI + +f9ayPn/TKbO/x0NFPwdBhLnNyt1lVNJvmohIjTYTqnS/VrI+f9ayPn/Wsj5/0uhyf8eFyD/HAUL/xwF + C/8hJzT/RpW7/1rH+P9ayPn/QYqt+isbUcFTRr9MZFfrE2ZY7wIAAAAAAAAAAAAAAABlV+8BWEnMJyEP + LL9HmMD6Vr7v/lnF+P9Zxvj/Wcb5/1rG+f9Zxvn/WcX4/z1/of8eGSP/HRAY/yxRaP9Tt+b/Wcb5/1rG + +f9Zxvn/Wcb5/0ONsvwjETbUQDWMelxT1ChnXu8FZ17vDEA1jXEmPlHlUK/d/VnG+P9Vu+z/SqDJ/0aW + vv9RsuD/Wcb4/1nG+f9Zxvn/WcX3/zh0k/kkEzrMQDWNcWFY4R9lW+oWPDGDeiY8T+RNp9L9WcX3/1nG + +f9Zxff/TKXQ/0GKr/9FlLr/UrPi/1nF+P9Xv/D/Rpa9+yU0Rt9CNJNrZVjuDAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAGBS4hc0JW6KIik52StNY+wzZ4TzOXSU9kCHq/lIm8X8UbLh/lfA8/9Ywvb/UrTk/1Cv + 3v9XwPP/WcT4/1nE+P9ZxPj/WMT4/1Ct3P0lNUfjRDqZbWdd7xFnXu8CAAAAAGde8AFjWeQcOS57hCQ0 + R+NJncf8WML1/1nE+P9ZxPj/WMT4/1nE+P9ZxPj/WMP3/0ibxPwhHjPUUEa3U2de7w1nXu8BZ13wAmNZ + 5Rk+Mol2IRkx0TdvjvVKoMv9U7fo/la87v5Wve/+U7bn/kyk0P09f6H5J0BT6ScXRrtEN5plYlXnFmZZ + 7wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlV+8CYVPkF1JEvTxHOaFWQDKPbDstgXo1KHORLB5YryMf + OtAnQVboNWyM9EGMtPlInMn8TajY/U+t3v1OrNz9SJ3J/Dx9ovckMETcOSx6gmNY5BtnXe8BAAAAAAAA + AAAAAAAAZ17vAmNa5RlDOZZrJRs/xTFgffBHmcT8UrTn/lS67v5Uue3+Tqra/Tp5nPciHzfTRDqZamVb + 7BAAAAAAAAAAAAAAAABnXe8BZlvtD1JGukA2KnWIKBpIuyIlO9UkL0LeJDBE3iMjOtYmGUS/MyVrlkc6 + oVxeUdsmZlnvCWZZ7wEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABlV+8CZVfvA2VY + 7wZlWO8IZlnvDGRX6xhZTM4wSTylUzwvhXkyJGeZKxxUsiUUO8QjEjTMJBM3yCkZSrM1KHGOTEGtT2RZ + 6BVnXO8CAAAAAAAAAAAAAAAAAAAAAAAAAABnXe8BZ13vC1lPzTM8MYR6KRlKtiIkOtYkMkbgJC9D3iIY + M80xJGWcT0SySmZc7A9nXe8BAAAAAAAAAAAAAAAAAAAAAAAAAABmXO8DZlvvDWFW4R5XS8gyUES3OlFF + ujtWSsgyYFPfIGZZ7xBmWe8FZlnvAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZlnvAWZZ7wNmWu8HZlrvDmVZ7hdjV+ghY1jnJmNY + 5yNlWusYZlvvDGZc7wQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABnXe8CZ13vCmRa + 6RxaT80xVUvEPVZLxTteVNgrZlztE2dd7wQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAZlvvAWZa7wFmWu8BZlrvAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAZ1zvAWdc7wJnXO8CZ1zvAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////////////////////////8B/////////wD/////// + /+AH////////4Af////////gB////////+AH////////4Af////////wD/////////AP//////h/8B/+ + P///+AHwD4Af///4AAAAAB////gAAAAAH///8AAAAAAf///wAAAAAB////AAAAAAD///8AAAAAAP///w + AAAAAA////AAAAAAD///8AAAAAAP///wAAAAAA////AAAAAAD///8AAAAAAP///wAAAAAA////AAAAAA + D///8DgAADwf///8/AAAfz/////+AAB///////4AAH/////8/AAAfz////A4AAA8H///8AAAAAAP///w + AAAAAA///9AAAAAAD///AAAAAAAB//4AAAAAAAB//AAAAAAAAD/4AAAAAAAAH/AAAAAAAAAP8AAAAAAA + AA/wAAAAAAAAB/gAAAAAAAAH+AAAAAAAAAf4AAAAAAAAB/gAAAAAAAAP+AAAAAAAAA/4AAAAAAAAD/gA + AAAAAAAH8AAAAAAAAAPwAAAgAAAAA/AAAAAAAAAD8AAAAAAAAAHwAAAAAAAAAeAAAAAAAAADgAAAAAAA + AAOAAAAAAAAABwAAAAAAAAAfgAAAgAAAAB+AAAHAAOAAP+AAA+AA+AD//4AP+AP/D///////D////ygA + AAAwAAAAYAAAAAEAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACsnKY+j1eIvn41eux7PHnpkG6Qm7exsx0AAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMC0uhijYZvPoz2c/6BAmf+hSpz/olqi/6iK + qp/Ryc8FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKugpUOlT6D+o0Se/6FG + mv+jUJz/p2Cl/6uBruG2rLUfAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALOs + rzGdYaH6m1qf/5lbm/+XWJn/mmCe/6OCp9a7s7wXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAALmxtw+dhKS+mnek/5d2oP+QbZr/kXCb/6OTpojr6uUBAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACpo6pKjXyb94Z1lv95ao3/iX2X2raztSIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAo6epFLvC + wAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACvsLEaZ32O1kRogP86XHP/doaPqb/F + xwUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOvr5QKnrsEQoaayDgAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AADo6eMBiZuhdmOCmsNwhrKphI6da56mpkOwtbMnq7GvGr/AvAq6urUE3d3XAri9ugiToaVcSn6X+Tdz + lP8XZ4H/S32W4p6qsTzBz9ME0NXSA6ayswiyu7wSqbKzJKqyszeToaNegZCWgW2EmK1df7LSmaCtRwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAC1uLcGaH2QqAFIe/8HZrj/C0Ro/yZogf4/cYfvT3B/0FxdXKVncHGScXBvfWp8 + gaFDfpnyQ3ym/z5vov8lZpr/J3q0/0Si2Oxtobq3d6jBqGqmw75cla7STIml5zlea/kkYm//BUZP/wFP + Zf8QZZz/gpCmcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACxtLcSVWOEyQFChP8BaLT/Akdw/w9hif8GW37/Bkpj/w4b + H/8OLDP/DgwW/x4tOP8xS1r/Mkhd/yU6T/8gQWf/HVeK/xKLyv8Bkb//CZG7/wJ/nP8Bi6//A2+H/wlV + Zv8ROUf/BDE4/wE3P/8BVXn/cYWfn9TX2AIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACprLIlQVeJ6ARTnf8GZKP/CTlh/w8t + QP8MHiX/ChMW/wgOEv8JDRL/Cg0T/wsOFP8NEBf/ExQb/xIWGf8SGB//DyI4/wJnnP8Bgrf/AYK4/waK + vv8TiLX/HnGg/w9QYf8XQ07/DzlC/wIzOf8BRFr/YHiRv7G2ugsAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACnq64zLUdw+g4w + Vv8KGSb/CBEV/wgRFP8JERT/CBEU/wcOEf8GDRD/CBAT/wgYHP8JICb/CyUu/w0kLP8OIy7/Cis//wJP + dP8BaJz/AX+v/wKBs/8Nc6z/E0Rg/yU6Qv8sQkn/I0VO/w9ATv8DOkz/TFxoya6wrxcAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AACYmJU8GyAk/ggSG/8HEhz/CRcl/wsfK/8KIi3/Chsi/wgQE/8HDA//CBET/wofJP8KKDH/Cyo2/wwo + Mv8MJTD/Ci5B/wY4U/8BUHD/Al2E/wNplP8FT3L/DC45/xMjJv8ZJin/HSww/yA3Rf8dOVH/PklS5LCy + rhgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAB2d3VTCBQh/wUtPv8GFiz/Ch4z/wwiM/8MITD/Cxwn/wkSGP8GCw7/Bw0R/woZ + H/8LHST/DB0m/wwcJP8LGiL/DBsm/wseLf8JKDz/Bjxc/womOP8MICr/DB4j/w0cH/8OHB7/Dx0f/w4d + If8PHST/LzI196+vqxcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABeYWFzBxkk/wQwO/8HFiv/DBsu/w0dLf8NHzL/DB4t/woR + Gf8HCg7/BwwQ/woUG/8MGSH/DBgi/w0YIf8MGB//DBch/wsYJf8LGin/Cx0r/wsdKf8LHSX/DB4k/wwd + If8NHiH/Cxwe/wgZHP8HHCH/Gyct/oeIhisAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUVleICRok/wgqMP8IFij/DBgr/w0Z + J/8NGyv/DRcl/wsQFv8ICw//CQ0R/woTF/8MFRv/DRce/w0WHv8NFRz/DRUa/wwVHP8MFh//DRkj/wwa + JP8LGiL/Cxoh/wwdJP8NISn/CyQt/wgaH/8GHCH/ByQx/3B0dUYAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABLT1CUCRsj/wkk + Kf8JFSX/DRYm/xQbJ/8QGib/DRci/wwSF/8ICw//Cg8S/wsTF/8LEhf/DBMY/wwTGP8MEhb/DBIW/wwU + GP8MFRv/DRce/w0XHv8MGB7/DBkf/xIeJP8SISr/DCMu/wgXHP8IGyD/BSIy/19lalIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABzdXRcGSYp/gshJv86PUHnbG1tj4GBgFF/gH9tTU5PyQ8VGf8ICw//CQ4Q/wsSFf8KEhX/ChEU/wsR + FP8LEBP/CxEU/wwTFv8NFhr/Dhgf/w4ZHv8eJSj8Xl9eq4SGg1yDhYNhXmFipiswMPYJGR7/MDlA8pGT + kiUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAC+v7oRfH98dmxvbo+wsKwrxsbBBwAAAADQ0MsCvr+6G1ZXVrYUGB//CA0Q/woQ + E/8LEBP/Cg4R/wkND/8JDQ7/Cg8Q/wwSFf8NFhn/Dhgd/xEaHv91dnSHxsfCEAAAAAAAAAAAwcG9DZ+g + nEBmaGaXj5CNVby9uAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7OzmAebm4AMAAAAAAAAAAAAAAAAAAAAAAAAAAJ+g + nEMiKi7+CQ0P/wkOEP8JDhD/CQwN/wkLDf8JDA3/Cg8Q/w0TFv8OFhn/DRgb/0BDQ+a9vrkdAAAAAAAA + AAAAAAAAAAAAAAAAAADm5uADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAL29uCEvMDD5BwsM/wgMDf8JDA//CQsN/woJDf8KCg3/Cw8Q/w0TFf8NFRj/Dhca/0tN + TMC2trIXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7OzmAezs + 5gEAAAAAAAAAAAAAAAAAAAAAAAAAAKSknz4bHR3+BwsM/wgND/8JDRD/CQsP/woJDf8LCg7/Cw4Q/wwS + E/8NFBf/DhUY/0JEROLExL8ZAAAAAAAAAAAAAAAAAAAAAAAAAADs7OYCAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AADDw74PgoSCbXR4dYqvr6woxsbBBgAAAADS0s0BuLi0EVhZV7IHCw3/CAsN/w8ySP9Lh6v/CSs7/woL + D/8KCw//Cw0Q/w0RE/8NExT/DhUY/xMZHP9zdHF8xsbBCgAAAAAAAAAAx8fCCaOjnzltb26QlJWSScnJ + xAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAB2eXdbKDI0/R8uL/9ETE3jc3RzhJCQjUeKioddU1RSvRASFP8HCw3/CAsN/yAz + QP8vep3/CkZf/wsPE/8KDA//Cw0Q/wwPEf8NERP/DhMV/w8VF/8iJif7ZWZkoo2OilGNjotUaGlnmjI1 + NvINGiT/NDk+7peYlSIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABSWVmWJjU2/yEuL/8gLzD/GiIp/xkcIP8QExb/CQ0P/wkM + Df8ICwz/CAsN/y5GXv8kSWP/Cw8T/woMEP8KDA//CwwQ/wwOEf8NEBL/DhIT/w8VFv8PFhj/EBca/xce + If8WHiH/DRMX/w0XHP8NGiP/Dh4o/2VoaE8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABdUtURRz2gQUtBqj1iZoalQEtd/y07Rf8kMDb/ICgt/xcb + I/8NEBX/Cg0O/wkLDP8JCwz/CAoM/wgLDv8JDA7/CgwO/woLD/8LCw//DA0Q/w0OEf8NDxL/DhET/w8T + FP8PFRf/DxcZ/w8aHP8NFxr/DRUa/xAaJ/8XIT3/ICpP/25um1ZiWeMVZVzrC2dd7wIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGdd7wU5LXtxHAUO6RwGEOszKzrwPjxV/zw9 + Xv80Nl//Ly9f/y0sX/8mJVb/Gho+/w8QH/8LDRD/CgsN/wsMDf8LDA//DQwT/w0ME/8NDRT/Dg4W/w8P + Gv8QEBv/ERMg/xIVIv8TFyj/Ehgl/w8ZH/8VGzL/JSZY/yknW/8nI1H/JR5D/y8kRNYmFkLGLiFdpEA1 + j15gVd4WZ1zvAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABnXO8BXFHUFlFGuDJFO5yDHgkc8hwF + C/8cBQv/HQcN/x0JDv8eCw//HQkP/x0KFP8gESz/Jh1J/ykkWv8kIlP/EhEj/w4NF/8fHkn/JyRa/ygl + W/8mI1b/JyNW/yklXP8nI1f/KSNY/ygjV/8nIVL/KCVY/yorY/8pJVn/HxIt/xwHDv8cBQz/HAUL/xwF + C/8cBQv/HAUL/RwGD/EuIF2mWU7OIgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABhVuESLSZboDJi + huUtSm3lIR4z+BwGDP8cBQv/HAUL/xwFC/8cBQv/HAUL/xwFC/8cBQv/HAUL/xwFDP8hFDb/KiZf/yMh + Uv8kG0X/GwYM/xsFC/8bBQv/GwUL/xwFC/8cBQv/HAUL/xwFC/8cBQv/HAcO/yYbRf8cBg3/HAYN/x0Q + G/8eGCX/HQwU/xwFC/8cBQv/HAUL/xwFC/8cBQz3NShxjGRZ6wsAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABiVuISLSdcpT+GtPdRs+//T67o/0id0v9BjLz/O3um/zNnjP8pSWT/HyEv/xwGDP8cBQv/HAUL/xwF + C/8cBQv/HQsf/zUwdv8lGED/HAUL/xwFC/8cBQv/HAUL/xwFC/8cBQv/HAUL/xwFC/8cBQv/HAkR/ylI + Y/89g6//SJ3T/02p4v9Prej/TKff/0GNvf8nQVr/HAUL/xwFC/8cBQv+IQ0s1ldLyCoAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAABmXO8BWE3KJTImaaxCj7/9U7n3/1O59/9Tuff/U7n2/1G18f9StvP/T67o/0OS + w/8sU3H/HAcP/xwFC/8cBQv/ISg6/zFgg/8zZ4v/NGuR/zVtk/84dJz/O32p/z2Cr/9Ai7v/QYy8/yMy + Rv8fHy7/QIm4/1G18f9NqeH/Nm+W/yxPbf89f6v/Urb0/1O59/9Oruj/KEZh/xwFC/8cBQv/HAUO70Y6 + nk9mW+8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZlzuCTQnbZVFlcj8U7n3/1O59/9Tuff/P4a0/x4b + KP8yZIj/ULLu/1O59/9St/T/P4a0/x4WIf8cBQv/K1Bu/1Cx7f9Tuff/U7n3/1O59/9Tuff/U7n3/1O5 + 9/9Tuff/U7n3/zdymv83cZn/U7n3/06s5v8lOVD/HQkP/1RPgf9kXHX/SJfK/1O59/9Tuff/RJXH/xwG + Df8cBQv/HAUL8kE1k1hmW+8CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZFjnFCsjU7lNqeL+U7n3/1O5 + 9/9St/T/Kk1p/xwFC/8cBQz/P4e1/1O59/9Tuff/U7j2/zl2oP8cBQv/HAUL/yxUcv9Pruj/U7n3/1Cy + 7v9OrOb/TKjg/0um3v9OrOX/Urf0/0mf1f86eaT/U7n3/zh1nf8dBw3/Myow/5aQp/+Ohpv/R5DA/1O5 + 9/9Tuff/T6/q/yAiMv8cBQv/Hgga5E5Csj5mW+8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWU7NJytD + WNdZwfT/U7r3/1O59/9PsOv/ISc4/xwFC/8cBQv/N3KZ/1O59/9Tuff/U7n3/0ie1P8cBQv/HAUL/iUW + POMwUXDrTarj/zt7pv8fGif/KiBN/x0NFv8eFyL/Llh4/06s5/88f6r/UbXx/yxCXetTTYGjfnqgt4+M + p+9OY3v/ULHs/1O59/9Tuff/VLny/yQ3Sf8cBQv6LiBdoGFW4hEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABmW+8BSj6mRjt0hutn2/v/Y9b6/1zJ+f9Mpdj/HAsU/xwFC/8cBQz/QIq5/1O59/9Tuff/U7n3/0mf + 1f8cBQv+HQgY50Y+nGRWUZ1lNU1q7Eym3/9Cj8D/KzJY/x8KHf8cBQv/HAUL/y1VdP8xYoT/RZXI/Csn + VLliWt8wOC55hzJgg+xPr+r/VLv3/1nE+P9g0Pr/Xsfl/x8eJvsmFkS/VkvHNWVa7gcAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAABmW+8DPTGHbEeUrfZk2Pv/ZNj7/2TY+/9QqcX/HAUL/xwFC/8sUGn/ULHs/1O5 + 9/9Tuff/U7n3/z6Fs/wmF0LKQjmRYGVf5wysq7stQ0Bu7ClDYf9Nq+X/SqPa/ydDXf8cBQv/HAUL/xwF + C/8cBQv+JxhD2VBHtGYzKmmhO3yi9Fe+8v9dy/n/YtT7/2TY+/9k1vn/QYOZ+igYR75SRrtaNCZtizMm + bYVZTc4bAAAAAAAAAAAAAAAAAAAAAAAAAABmWu8IMydtlFCsyvxi1fr/YtX6/2LV+v9fzvL/T6nI/0+p + yP9ezPD/YND6/1zK+f9ZxPj/TKXa/yQ1S/JMRKtgaGLvBsPDwApubmuTHRk7/y8paP8uWHr/UbXy/06t + 5/8rT2z/HAUL/xwFC/8cBQv/IxE04DkveqxEjab1YdL3/2LW+v9i1fr/YtX6/2LU+f9ImbT4LSNZrFhN + zDQ5LXyCHAUL9hwFC/FBNZNeZlnvAgAAAAAAAAAAAAAAAAAAAABjV+cUKyVVuVi/4/5h0/r/YdP6/2DS + +f9Jm7j/RpOv/1vF6v9h0/r/VLTW/0eWsv83boT/ICQt/xwFC/swJGGeZ2DtDMPDvxhIRlzmKiJU/y4l + YP8wJmL/SZ3E/1zK+f9Yvuf/J0BO/xwFC/8cBQv/HAUL/ipKW/xezfP/YdP6/2HT+v9h0/r/X8/2/0OM + p/0tI1u/UUa7XTYqdYUpGk7RHAUL/hwFC/s2KHOHZlnvBgAAAAAAAAAAAAAAAAAAAABYTc0nLEVd1l3L + 9P9f0Pr/X9D6/1vH7/8hKDP/HAUL/y1TZf9dzPX/Xcrz/0CGo/8cChH/HAUL/xwFC/4lFj/FY1zkGbi4 + wSRMRW32IhAd/xwFC/8dBxL/NmyD/1/P+f9f0Pr/S6DB/xwHDv8cBQv/HAUL/z6Bnf9f0Pr/X9D6/1/Q + +v9dy/T/PHuV/xwHDv04LHq4LStbxEqdvvojMkD+HAUL/xwFC/wvIGCYZVjuCQAAAAAAAAAAAAAAAGZZ + 7wJLPqlGNm2F617M+P9ezfn/Xs35/1Oz2v8cBw7/HAUL/x0RGf9Zwev/Xs35/13L9/82bIX/HAUL/xwF + C/0rHVG0WlLPNE9Jen5RS4PgKx9M/xwFC/8cBQv/KUZX/1zJ9f9ezfn/WsXv/yMyQP8cBQv/HAUL/j6C + n/9ezfn/Xs35/17N+f9DjKv/HAgO/xwFC/8dBhH6KUZZ+1zJ9P8zZHz/HAUL/xwFC/Q3KXd6ZVjvBgAA + AAAAAAAAXlHbD0Y5oEU1J3GcQ42w+VzK+f9cyvn/XMr5/0iav/8cBQv/HAUL/yY7TP9axfP/XMr5/1zK + +f9JnMH/HAUL/hwGEO1COJNpPTKFczx9m/Q+eZf4LCRO/RwGD/8cBQv/LFBk/1vH9v9cyvn/W8j2/ylF + V/8cBQv5LR9Xzy9Vbe1ax/X/XMr5/1zK+f81aoT/HAUL/xwFC/8cBw7/QYqr/1zK+f88fpz9IQ4w2zcp + d4FbTtUaAAAAAAAAAABlV+8DOy2DXzRnhOZHmMD6V7/v/1rH+f9ax/n/Wsf5/0CGqf8cBQv/HAsS/0GK + rv9ax/n/Wsf5/1rH+f9DjrP9IQ8v2TovfnZiWeMTRTubUjVphelYwfL/S6PN/zVqh/8wXXf/TKbQ/1rH + +f9ax/n/VLjn/iElM/AtIFqkWVDNOjInaJdDkLT3WcX3/1rH+f9PrNj/LVVt/yxRaf9Biq//WMPz/1a9 + 7f4yYHvmSj2nVmVY7QgAAAAAAAAAAAAAAABlV+8CQDKQVC1Ra9k7fJ7xQYuw90aYwPpOqtf9Vr3v/lW8 + 7v9Jnsn/S6TQ/1jB9f9ZxPj/WcT4/1S46P4sSGLaUEa2R2Zd7ggAAAAAYljiEDcsdoM2bo3uVLnq/lnE + +P9Yw/f/WcT4/1nE+P9YwfT/O3ma8jsvgH9hWOEUZ17vAlpQzyAxKWWcN26N7U2m0v1VvO3+Vr3v/lW5 + 6v5Oqdb9P4So9StBXtE9MIduYVTkDQAAAAAAAAAAAAAAAAAAAAAAAAAAZFbsCFRGxClGOaBGPzOPWjot + gHAyJWqWKjFXwzFceuI8gKXxQ4+4+EaZxfpFlsH5PYCl8ixBYM1DN5RaZlzvBwAAAAAAAAAAAAAAAGNa + 5g9ANY5lKztdyT6Cp/NKo9D8TajY/UeaxvsyYn/nNSpwjF9V3BcAAAAAAAAAAGdd7wFiV+MRRDmaTzEl + aJQqK1a6KjJWwispVbowJGaaPzKMYFlMzyRmWe8FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABlWO8BZljvAWZZ7wJmWe8HYFTgFVJFvC5EN5lMPTCGZTougHY7LoFwQjaUUFdMySRnXO4FAAAAAAAA + AAAAAAAAAAAAAAAAAABnXe8EWU/NIkE1j1s1KHCIMydtkzcrdoBJPqRFY1nlDmdd7wEAAAAAAAAAAAAA + AAAAAAAAZ1zvAWZb7wdkWeoPYVXiEWRY6g9mWu8IZlnvAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABmWu8BZlrvAmZa7wNmW+8CZlvvAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGdd7wFnXe8FZ13vBmdd7wRnXO8BAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAD///////8AAP///////wAA///4H///AAD///AP//8AAP//8A///wAA///wD/// + AAD///AP//8AAP//+B///wAA/8/4H+P/AAD/gAAAA/8AAP+AAAAD/wAA/4AAAAH/AAD/gAAAAf8AAP+A + AAAB/wAA/4AAAAH/AAD/gAAAAf8AAP+AAAAB/wAA/4AAAAH/AAD/gAAAAf8AAP+AAAAB/wAA/4IAAMH/ + AAD/z4AB9/8AAP//gAH//wAA/8+AAff/AAD/ggAAwf8AAP+AAAAB/wAA/4AAAAH/AAD8AAAAAD8AAPgA + AAAADwAA4AAAAAAPAADgAAAAAAcAAOAAAAAABwAA4AAAAAADAADwAAAAAAMAAPAAAAAAAwAA8AAAAAAH + AADgAAAAAAcAAOAAAAAAAwAA4AAAAAABAADgAAAAAAEAAOAAAAAAAQAAwAAAAAABAACAAAAAAAMAAAAA + AAAABwAAAAAgAAAPAACAAHADAB8AAOAA+APAfwAA/4P+D///AAAoAAAAIAAAAEAAAAABACAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAKGCmkCBPHyZf0d9kaaVoygAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC6r7QWpFKd6aJBmv+jUJ7/qXqqy8K6wQcAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKyjqCifWaH9m1Sb/5pXm/+jeKbot663EwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAubG2B5yCo8CVd5//jG6X/5yJ + opkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAKiqrAOttLMKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlJagVV1t + iP9WZX79q62uKgAAAAAAAAAAAAAAAAAAAAAAAAAA6urlAaSqug4AAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAuLu4F1R2kdFYd6y8Zn2HhnyQl16doqEqvr66Eayw + rhxlip2vPHWa/x9rjP9plbaTqLS3J6WsrCmMqLZJd4uUcGaDi5pXc4TAX3+tw6uvtQoAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACTmKI1FUV9/wFcof8JW37/BVx8/xcx + PP4sOT33MUBI9zJed/8yVHf/I1SD/xqJxv8tmcT9JY2u/hCFpf8LX3T/DD5J/wE7RP8wYor0srW3GAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHWAmGQHSY3/CEt9/wwp + O/8KGB3/CA8S/wgNEv8KDxT/DRMZ/xIYHP8RGyX/BlJ9/wF6rv8EisD/FoCx/xxQZ/8cRE7/BzhA/xdK + ZP+UmZ80AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYmVpewoW + I/8IEhv/Chok/wodJv8IERT/BwwP/wkbH/8KKTL/Cyo1/wwpN/8GPFj/AVyD/wJtmf8GTHH/FSsz/yMw + NP8eOUb/EzdM/3d8fU8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AABKTE6SBSg3/wcXLf8MITL/DCAw/woWH/8GCw7/CRUb/wscJP8MGyT/DBoi/wscKv8JK0L/Cio+/wwf + KP8MHSH/Dhwf/wwcH/8MGyL/WlxbYwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAD5CRK0HJy//CRcq/w0aKf8NHCz/CxMb/wcLDv8KERb/DBYd/w0XH/8MFhz/DBYd/wwY + I/8MGib/Cxoi/wwdI/8MISj/CBwi/wUeJv9HTVJ/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAPEFCsQohJ/8UGyj+ODtA4DE1Ou0MExr/CAsP/wsTFv8LEhb/DBIX/wwS + Ff8MExf/DRYc/w0YHv8OGR//Njs85jU8QecMHCL/Bxwk/0JLUoUAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB+gH1FUFVVtoOEgkzCwr4KtLWxF1NUU6kOEhf/ChAT/woQ + E/8KDhH/Cg4Q/wsRFP8OFhr/Dxke/2ZoZojBwbwPv7+7EHZ3dGNRVFSzjo+OKQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADo6OICAAAAAAAAAAAAAAAApqeiJR8l + J/0JDQ//CQ0P/wkLDf8KDA3/DBIV/w4WGf82OjrmvLy3EgAAAAAAAAAAAAAAAOfn4QIAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOzs5gEAAAAAAAAAAAAA + AACpqaUjHB4e/QgMDv8JDA//CQoN/wsLDv8MERP/DRUY/zg6OuTAwLsQAAAAAAAAAAAAAAAA7OzmAQAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACChIFCWF1bsoWI + hUfHx8ILvb24E1BQT6EHCw3/Dio7/zd7nv8LDxL/CwsP/wwQEv8NExX/ERcZ/2VmZH/Dw74Ow8O/Dnt7 + eVtWWFmtkpOQJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEVN + TbIhLzD/JjE0/jw+P9c0NTXmCQ0O/wgLDP8lNUX/IUdg/wsOEf8LDA//DA4R/w0REv8PFRb/Ehga/zo8 + PN86PT3fEhkd/w0bJP9FSkyDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZ13vAT4z + iT8yJml1UFNv0TtFX/8rM07/HyM4/w8SHf8KDA7/CQsM/wkLDf8KDA7/CwsO/wwMEP8NDRH/DQ8S/w4S + FP8PFRf/Dxkc/w4WHf8ZHj7/IidS/0VEbqRBN5M8Wk/OFWdc7wEAAAAAAAAAAAAAAAAAAAAAAAAAAGVa + 6gNUScAfMydrpxwFC/4fDBD+IxYY/yQaLf8lG0H/Jh5K/yQfTv8aGT3/DQ0U/x0bQf8hH0z/IB1I/yMf + Tf8iH0r/Ix9N/yMfSv8jJVL/JSFQ/yIWN/8cBw//HQcN/RwFC/khDi3cPDCDYGZb7gMAAAAAAAAAAAAA + AAAAAAAAQziXODZtlOU7eaXxK1Bt/yAmN/8cCA//HAUL/xwFC/8cBQv/HAUL/yIWOv8pJl7/IRQ0/xwF + C/8cBQv/HAUL/xwFC/8cBQv/HAUL/yARL/8iLkH/Llp6/zFhhP8mP1f/HAUL/xwFC/8eCBzrSD2lMgAA + AAAAAAAAAAAAAAAAAABWS8YRMjtxpEum3v5Tuff/Urbz/06r5f9IntP/PIGt/yQ4Tv8cBQv/HAUL/y1K + bv8vV3r/Llp6/zFihf80a5H/OHWd/ylLZ/8lO1L/RZfK/0qj2f89ga3/SqHY/1K39f8/hrT/HAYN/xwF + C/40J253ZlvvAQAAAAAAAAAAAAAAAAAAAAA3K3VxS6Xd/lO59/9Pr+n/Ii1A/zZvlv9Tufb/ULLu/zBe + gP8cBQv/QY2+/1O59/9Tuff/U7n3/1O59/9Tuff/RZXI/0OQwf9NqeH/ICY2/1dRcf9na4X/Urf1/1O4 + 9v8qTGj/HAUL/jEkaIRmW+8BAAAAAAAAAAAAAAAAZlzvAzM+b59Vu/L/U7n3/0aZzf8cBQv/HRAa/1Cx + 7P9Tuff/SqTb/xwFC/8hEy3yQYq69kic0f8zYYb/L1h6/zNni/9Kotn/RJTH/z1+qvZKRGfDj4um7F5+ + oP9Tuff/U7n3/zh0mP8dBhLxQjaVQQAAAAAAAAAAAAAAAAAAAABlWusLPnKOymba+/9g0Pr/Qoyw/xwF + C/8nQlv/Urf0/1O59/9Lpd3/HQcV8Dsyf21aV4l5PYCu/0ORw/8kJkH/HAUL/yQ5UP8zZor+NFSBvUY9 + m187dqHjVLny/1zJ+f9i0/j/M2Fx9joufoRTSMAlZVntAgAAAAAAAAAAAAAAAFZKxh9Fj6rpY9b6/2PW + +v9UtNP/Qoyl/1e74f9axvj/Vr31/zh2n/hFPJlao6HXCFxbYKIqJFz/Qo6//0qj2/8jNUr/HAUL/xwF + C/s9MoOeRpOx7mDQ+f9j1vr/Y9X6/0qbtvE7L4BzMydtlR0HFuVHOqA0AAAAAAAAAAAAAAAAQjaVQk2m + xvhg0vr/YND4/z1+l/9Lob//X872/0aTr/8sT1//HAUL/TMobHu9vMEUQDta8iccSv8sOF3/W8by/1Oy + 2P8dFB3/HAUL/ytNXv1fz/f/YNL6/2DQ+P9Djaj+PDGDmzdIep8iFDTqHAUL/Dcpd2IAAAAAAAAAAGZZ + 7wE1KXNvVbng/V7O+f9YwOn/HQsS/x4YIf9bx/H/W8Xv/ypKXP8cBQv+MyhsjGFckk5HQHLvHAYO/xwF + C/9Ts9n/Xs75/zZuhv8cBQv/Nm6G/17O+f9ezvn/Qoup/xwFDP8kEzrqUKvR/SpLXf8cBQv5OCp5XQAA + AABiVOYFNy95YjRYfc9ZxfT/W8n5/02o0P8cBQv/KENW/1rH9v9byfn/PYGg/iAMJeFPRrNIOG+P2UOK + rvsiHjL/Hhch/1O24f9byfn/PH6e/iIRNNozRnLFWMLw/lvJ+f8zZoD/HAUL/yxSaf9ZxPL/NmqI7Tcp + d3FcT9cMAAAAAFtN1RAzXX7HSJvE902o0/tTuOf+UrXk/z2Cpv9Oq9n/WcX4/1fA8v81Wn/ITEKsLWde + 7wU3Onp9SZ/K91S56v9SteX/WcX4/1W77P4xS3O7TEKsJ0pAqSs4aY3KT6zZ/FS46P9MptL/TqrW/UGH + rOc5N39yZVjuBAAAAAAAAAAAAAAAAFdJyhVFN50zPC+GSDQrcXI1UYCqPXeh0D+ErOM+gKndNlaDrEg9 + oi0AAAAAAAAAAGRb5gc7MoNcOWqSx0KNtu1BibHqNVF+rE5EsiMAAAAAAAAAAFZMxxQ4LHlbMTJqiDIy + a4g2KnZiUEO4ImZZ7wIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGZZ7wNmWu4JY1fnEmRZ + 6Q9mW+8EAAAAAAAAAAAAAAAAAAAAAAAAAABlW+sJWE3JHFpPzhpmXO4GAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAZlrvAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP///////D////gf///4H///+D///Pw+f/wA + AD/8AAA//AAAP/wAAD/8AAA//AAAP/wAAD/8AAA//uAHf/7gB3/8AAA//AAAP+AAAAfAAAADwAAAA8AA + AAHgAAABwAAAA8AAAAHAAAABwAAAAYAAAAEAAAABAAAAA4AYDAf4Ph+/KAAAABAAAAAgAAAAAQAgAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACLWIY2iF+HLgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACyqKwQoFGd+aJn + ouy6sboHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAq7GxAwAAAAAAAAAAubG3Aoh7 + mcWCdpOwAAAAAAAAAAAAAAAApKq6AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFRsjIc7aJbQQ2FxoUdQ + VIdCbInrNHek5EyXuJNGfpWuPVxn1lZ3nHcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9T3G3CS5L/wkW + G/8JEhb/DSEp/wo5VP8CdaX/FFh6/xs6Q/9BVmagAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKjY8zwoa + Lf8MGSb/CA8U/wwZIf8MGCL/CyM0/wwdI/8MHSL/LTU5uAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEJI + SatFR0qNPkBCqwsQFP8LERT/CxEU/w4XHf9DRkafRElKlkNIS5gAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AADp6eMBAAAAAKeooxIVGRr+CQsO/wsPEf8nKyzyvb65CQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAASlBQqUpOToo9Pj2mEyIv/yFJYP8LDRD/DxQW/0NFRJtGSUiSRUlLlQAAAAAAAAAAAAAAAAAA + AABWS8UJLB9YljY2SfMlJD7/Gxg5/xAQIf8XFjT/GRc2/xoZN/8bHTv/HRw8/ygjQegoGUqKPjKJGQAA + AAAAAAAAOFiMdEORw/s9g7D/M2mO/x4bKP8mK0//J0Bc/ylKZf8oR2H/LVV0/zh1nv9Aibj/KEZg/ycX + R6UAAAAAAAAAADY4dEVStfD/OXqk/0GOv/9JoNf/Kkto/Eyo4P1ElMf/RprO/0SUxv1eW3XrW5vM/0SV + yP8mFkStAAAAAAAAAABEf6N3Y9X6/0GHo/9Oqdf/TKje/TUrZnBFXoTGP4W0/yAnN/8wSHLVTZ3FzF3M + +P9LmrrWMSNliUg8pA4AAAAATJvCql7M9f81an//V73k/yQ2RP5PSXtaNS1S+EOMrv9Glrb/KERV/l/P + +f9FkrD/PWyUyCInN/g3KngwOFGFT0uhy/BUuOb/OHOT/1rF9v81XYC1PVyRaUSPtfxMpM//TKLM7jI1 + bHxRsNzxQIit/0eZwfg3VIN0W07VA1dJywVAM5AfNkV8SEF8rHQ+b59nSD2iC2Na5gI8XJJLRIa2gzxQ + jDUAAAAAPjOMHDEya0Q+MoshAAAAAAAAAAD+fwAA/D8AAOx3AADgBwAA4AcAAOAHAADgBwAA6B8AAOAH + AACAAQAAgAEAAIABAACAAAAAgAAAAAAAAAAAIwAA + + + \ No newline at end of file diff --git a/b2sbackglassserver/b2sbackglassserver/Forms/Background.vb b/b2sbackglassserver/b2sbackglassserver/Forms/Background.vb new file mode 100644 index 0000000..c0d36a9 --- /dev/null +++ b/b2sbackglassserver/b2sbackglassserver/Forms/Background.vb @@ -0,0 +1,51 @@ +Imports System +Imports System.Windows.Forms + +Public Class Background + Private Const MA_NOACTIVATE As System.Int32 = 3 + Private Const WM_MOUSEACTIVATE As Integer = &H21 +#Region " Properties " + + Protected Overrides Sub WndProc(ByRef m As Message) + 'Don't allow the window to be activated by swallowing the mouse event. + If B2SSettings.FormNoFocus And m.Msg = WM_MOUSEACTIVATE Then + m.Result = New IntPtr(MA_NOACTIVATE) + Return + End If + MyBase.WndProc(m) + End Sub + + Private Sub Background_Shown(sender As Object, e As System.EventArgs) Handles Me.Shown + + 'If B2SSettings.FormToFront And Me.TopMost = True Then + ' ' We have TopMost set, so it is safe to send back! + ' Me.SendToBack() + ' Me.TopMost = True + 'ElseIf Me.TopMost = False Then + ' Me.BringToFront() + 'End If + + End Sub +#End Region 'Properties +#Region "constructor" + + Public Sub New() + + InitializeComponent() + + ' set some styles + 'Me.SetStyle(ControlStyles.AllPaintingInWmPaint Or ControlStyles.UserPaint Or ControlStyles.OptimizedDoubleBuffer, True) + Me.DoubleBuffered = True + + End Sub + + Private Sub Background_MouseClick(sender As Object, e As MouseEventArgs) Handles MyBase.MouseClick + + If e.Button = Windows.Forms.MouseButtons.Right Then + B2SScreen.formBackglass.formBackglass_MouseClick(sender, e) + End If + End Sub + +#End Region + +End Class \ No newline at end of file diff --git a/b2sbackglassserver/b2sbackglassserver/Forms/formBackglass.vb b/b2sbackglassserver/b2sbackglassserver/Forms/formBackglass.vb index 49a4863..f8b8d2b 100644 --- a/b2sbackglassserver/b2sbackglassserver/Forms/formBackglass.vb +++ b/b2sbackglassserver/b2sbackglassserver/Forms/formBackglass.vb @@ -39,11 +39,10 @@ Public Class formBackglass InitializeComponent() ' set some styles - 'Me.SetStyle(ControlStyles.AllPaintingInWmPaint Or ControlStyles.UserPaint, True) Me.SetStyle(ControlStyles.AllPaintingInWmPaint Or ControlStyles.UserPaint Or ControlStyles.OptimizedDoubleBuffer, True) Me.DoubleBuffered = True - ' set key peview to allow some key reaction + ' set key preview to allow some key action Me.KeyPreview = True ' load settings @@ -68,7 +67,7 @@ Public Class formBackglass startupTimer.Start() ' create rotation timer - rotateTimer = New Timer() + rotateTimer = New Timer If rotateTimerInterval > 0 Then rotateTimer.Interval = rotateTimerInterval End If @@ -688,35 +687,44 @@ Public Class formBackglass Dim shorthyperpinfilename As String = String.Empty ' check whether the table name can be found - If Not IO.File.Exists(filename) AndAlso Not IO.File.Exists(shortfilename) Then - If B2SSettings.LocateHyperpinXMLFile() Then - hyperpinfilename = B2SSettings.HyperpinName & ".directb2s" - shorthyperpinfilename = B2SData.ShortFileName(hyperpinfilename) + If Not String.IsNullOrEmpty(B2SSettings.GameName) And Not IO.File.Exists(filename) AndAlso Not IO.File.Exists(shortfilename) Then + 'Westworld, check for gamename + If IO.File.Exists(B2SSettings.GameName & ".directb2s") Then + filename = B2SSettings.GameName & ".directb2s" End If - ' check whether the hyperpin description can be found - If Not IO.File.Exists(hyperpinfilename) AndAlso Not IO.File.Exists(shorthyperpinfilename) Then - If filename.Length >= 8 Then - ' look for short name - B2SSettings.MatchingFileNames = IO.Directory.GetFiles(IO.Directory.GetCurrentDirectory(), filename.Substring(0, 6) & "*.directb2s") - If B2SSettings.MatchingFileNames Is Nothing OrElse Not IsArray(B2SSettings.MatchingFileNames) OrElse B2SSettings.MatchingFileNames.Length <= 0 Then - B2SSettings.MatchingFileNames = IO.Directory.GetFiles(IO.Directory.GetCurrentDirectory(), filename.Substring(0, 6).Replace(" ", "") & "*.directb2s") - End If - If B2SSettings.MatchingFileNames IsNot Nothing Then - For i As Integer = 0 To B2SSettings.MatchingFileNames.Length - 1 - Dim fileinfo As IO.FileInfo = New IO.FileInfo(B2SSettings.MatchingFileNames(i)) - B2SSettings.MatchingFileNames(i) = fileinfo.Name - Next - End If - shortfilename = String.Empty - For Each file As String In B2SSettings.MatchingFileNames - If String.IsNullOrEmpty(shortfilename) Then - shortfilename = file + End If + + If Not B2SSettings.DisableFuzzyMatching Then + If Not IO.File.Exists(filename) AndAlso Not IO.File.Exists(shortfilename) Then + If B2SSettings.LocateHyperpinXMLFile() Then + hyperpinfilename = B2SSettings.HyperpinName & ".directb2s" + shorthyperpinfilename = B2SData.ShortFileName(hyperpinfilename) + End If + ' check whether the hyperpin description can be found + If Not IO.File.Exists(hyperpinfilename) AndAlso Not IO.File.Exists(shorthyperpinfilename) Then + If filename.Length >= 8 Then + ' look for short name + B2SSettings.MatchingFileNames = IO.Directory.GetFiles(IO.Directory.GetCurrentDirectory(), filename.Substring(0, 6) & "*.directb2s") + If B2SSettings.MatchingFileNames Is Nothing OrElse Not IsArray(B2SSettings.MatchingFileNames) OrElse B2SSettings.MatchingFileNames.Length <= 0 Then + B2SSettings.MatchingFileNames = IO.Directory.GetFiles(IO.Directory.GetCurrentDirectory(), filename.Substring(0, 6).Replace(" ", "") & "*.directb2s") End If - If Not String.IsNullOrEmpty(B2SSettings.MatchingFileName) AndAlso file.Equals(B2SSettings.MatchingFileName, StringComparison.CurrentCultureIgnoreCase) Then - shortfilename = file - Exit For + If B2SSettings.MatchingFileNames IsNot Nothing Then + For i As Integer = 0 To B2SSettings.MatchingFileNames.Length - 1 + Dim fileinfo As IO.FileInfo = New IO.FileInfo(B2SSettings.MatchingFileNames(i)) + B2SSettings.MatchingFileNames(i) = fileinfo.Name + Next End If - Next + shortfilename = String.Empty + For Each file As String In B2SSettings.MatchingFileNames + If String.IsNullOrEmpty(shortfilename) Then + shortfilename = file + End If + If Not String.IsNullOrEmpty(B2SSettings.MatchingFileName) AndAlso file.Equals(B2SSettings.MatchingFileName, StringComparison.CurrentCultureIgnoreCase) Then + shortfilename = file + Exit For + End If + Next + End If End If End If End If @@ -761,8 +769,8 @@ Public Class formBackglass ' current backglass version is not allowed to be larger than server version and to be smaller minimum B2S version If B2SSettings.BackglassFileVersion > B2SSettings.DirectB2SVersion Then - Throw New Exception("B2S backglass server version (" & B2SSettings.DirectB2SVersion & ") doesn't match 'directb2s' file version (" & B2SSettings.BackglassFileVersion & "). " & vbCrLf & vbCrLf & - "Please update the B2S backglass server.") + Throw New Exception("B2S.Server version (" & B2SSettings.DirectB2SVersion & ") doesn't match 'directb2s' file version (" & B2SSettings.BackglassFileVersion & "). " & vbCrLf & vbCrLf & + "Please update the B2S.Server.") ElseIf B2SSettings.BackglassFileVersion < B2SSettings.MinimumDirectB2SVersion Then @@ -922,7 +930,7 @@ Public Class formBackglass End If ' add info to rom collection If romid > 0 AndAlso picboxtype = B2SPictureBox.ePictureBoxType.StandardImage AndAlso romidtype <> B2SBaseBox.eRomIDType.Mech Then - Dim key As String = If(rominverted, "I", "") & Choose(romidtype, "L", "S", "GI") & romid.ToString() + Dim key As String = If(rominverted, "I", "") & Choose(romidtype, "L", "S", "GI") & romid.ToString() & "|" & romidvalue.ToString() If picbox.DualMode = B2SData.eDualMode.Both OrElse picbox.DualMode = B2SData.eDualMode.Authentic Then If roms4Authentic.ContainsKey(key) Then roms4Authentic(key) += size.Width * size.Height Else roms4Authentic.Add(key, size.Width * size.Height) End If @@ -1142,7 +1150,9 @@ Public Class formBackglass ' add digit location info For i = 0 To digits - 1 If isOnBackglass OrElse Not B2SSettings.HideB2SDMD Then - B2SData.LEDDisplayDigits.Add(If(dream7b2sstartdigit > 0, dream7b2sstartdigit, dream7index) - 1, New B2SData.LEDDisplayDigitLocation(led, i, id)) + Dim leddisplayid As Integer = If(dream7b2sstartdigit > 0, dream7b2sstartdigit, dream7index) + B2SData.LEDDisplayDigits.Add(leddisplayid - 1, New B2SData.LEDDisplayDigitLocation(led, i, id)) + B2SData.ScoreMaxDigit = leddisplayid End If dream7index += 1 If dream7b2sstartdigit > 0 Then dream7b2sstartdigit += 1 @@ -1201,6 +1211,7 @@ Public Class formBackglass B2SData.LEDs.Add(led.Name, led) End If End If + B2SData.ScoreMaxDigit = led.ID led.BringToFront() led.Visible = isRenderedLEDs AndAlso Not hidden ' add LED area @@ -1233,7 +1244,7 @@ Public Class formBackglass reel.ScoreType = b2sscoretype reel.SoundName = soundName If rollinginterval >= 10 Then reel.RollingInterval = rollinginterval - 'AddHandler reel.ReelRollOver, AddressOf Reels_ReelRollOver ' no need to add this right now; maybe later + If isOnBackglass Then reel.Type = B2SBaseBox.eType.OnBackglass Me.Controls.Add(reel) @@ -1248,6 +1259,7 @@ Public Class formBackglass B2SData.Reels.Add(reel) End If End If + B2SData.ScoreMaxDigit = reel.ID reel.BringToFront() reel.Visible = Not hidden ' add or update reel display @@ -1464,13 +1476,13 @@ Public Class formBackglass For Each romsize As KeyValuePair(Of String, Integer) In roms4Authentic If romsize.Value > second4Authentic Then second4Authentic = romsize.Value - secondkey4Authentic = romsize.Key + secondkey4Authentic = romsize.Key.Split("|")(0) End If If romsize.Value > top4Authentic Then second4Authentic = top4Authentic secondkey4Authentic = topkey4Authentic top4Authentic = romsize.Value - topkey4Authentic = romsize.Key + topkey4Authentic = romsize.Key.Split("|")(0) End If Next Dim top4Fantasy As Integer = 0 @@ -1481,13 +1493,13 @@ Public Class formBackglass For Each romsize As KeyValuePair(Of String, Integer) In roms4Fantasy If romsize.Value > second4Fantasy Then second4Fantasy = romsize.Value - secondkey4Fantasy = romsize.Key + secondkey4Fantasy = romsize.Key.Split("|")(0) End If If romsize.Value > top4Fantasy Then second4Fantasy = top4Fantasy secondkey4Fantasy = topkey4Fantasy top4Fantasy = romsize.Value - topkey4Fantasy = romsize.Key + topkey4Fantasy = romsize.Key.Split("|")(0) End If Next End If @@ -1537,6 +1549,7 @@ Public Class formBackglass End If ' get all animation info + Dim animationpulseswitch As Boolean = False If topnode.SelectSingleNode("Animations") IsNot Nothing AndAlso topnode.SelectNodes("Animations/Animation") IsNot Nothing Then For Each innerNode As Xml.XmlElement In topnode.SelectNodes("Animations/Animation") Dim name As String = innerNode.Attributes("Name").InnerText @@ -1597,6 +1610,7 @@ Public Class formBackglass Dim pulseswitch As Integer = 0 If stepnode.Attributes("PulseSwitch") IsNot Nothing Then pulseswitch = CInt(stepnode.Attributes("PulseSwitch").InnerText) + If pulseswitch > 0 Then animationpulseswitch = True End If Dim entry As B2SAnimation.PictureBoxAnimationEntry = New B2SAnimation.PictureBoxAnimationEntry([on], waitLoopsAfterOn, off, waitLoopsAfterOff, , , , , pulseswitch) If entries Is Nothing Then @@ -1674,11 +1688,6 @@ Public Class formBackglass Next End If - ' set backglass to topmost window - Me.TopMost = True - Me.BringToFront() - Me.TopMost = False - End If ' set info flags to dirty to load them @@ -1814,24 +1823,28 @@ Public Class formBackglass End Sub Private Sub ShowStartupImages() - ' maybe show some 'startup on' images - Dim topIsOn As Boolean = False - For Each picbox As KeyValuePair(Of String, B2SPictureBox) In B2SData.Illuminations - If picbox.Value.InitialState = 1 AndAlso Not picbox.Value.IsImageSnippit Then - If TopRomID > 0 AndAlso picbox.Value.RomID = TopRomID AndAlso picbox.Value.RomIDType = TopRomIDType AndAlso picbox.Value.RomInverted = TopRomInverted Then - topIsOn = True - If TopLightImage IsNot Nothing AndAlso Not TopLightImage.Equals(Me.BackgroundImage) Then - Me.BackgroundImage = TopLightImage - End If - ElseIf Not topIsOn AndAlso SecondRomID > 0 AndAlso picbox.Value.RomID = SecondRomID AndAlso picbox.Value.RomIDType = SecondRomIDType AndAlso picbox.Value.RomInverted = SecondRomInverted Then - If SecondLightImage IsNot Nothing AndAlso Not SecondLightImage.Equals(Me.BackgroundImage) Then - Me.BackgroundImage = SecondLightImage + Static isdone As Boolean = False + If Not isdone Then + isdone = True + ' maybe show some 'startup on' images + Dim topIsOn As Boolean = False + For Each picbox As KeyValuePair(Of String, B2SPictureBox) In B2SData.Illuminations + If picbox.Value.InitialState = 1 AndAlso Not picbox.Value.IsImageSnippit Then + If TopRomID > 0 AndAlso picbox.Value.RomID = TopRomID AndAlso picbox.Value.RomIDType = TopRomIDType AndAlso picbox.Value.RomInverted = TopRomInverted Then + topIsOn = True + If TopLightImage IsNot Nothing AndAlso Not TopLightImage.Equals(Me.BackgroundImage) Then + Me.BackgroundImage = TopLightImage + End If + ElseIf Not topIsOn AndAlso SecondRomID > 0 AndAlso picbox.Value.RomID = SecondRomID AndAlso picbox.Value.RomIDType = SecondRomIDType AndAlso picbox.Value.RomInverted = SecondRomInverted Then + If SecondLightImage IsNot Nothing AndAlso Not SecondLightImage.Equals(Me.BackgroundImage) Then + Me.BackgroundImage = SecondLightImage + End If + Else + picbox.Value.Visible = True End If - Else - picbox.Value.Visible = True End If - End If - Next + Next + End If End Sub @@ -1999,17 +2012,6 @@ Public Class formBackglass #End Region -#Region "event handling for the created backglass controls" - - Private Sub Reels_ReelRollOver(ByVal sender As Object, ByVal e As B2SReelBox.ReelRollOverEventArgs) - - ' nothing to do for the moment so I removed the AddHandler at the reels - - End Sub - -#End Region - - #Region "more private methods" Private Sub CheckDMDForm() diff --git a/b2sbackglassserver/b2sbackglassserver/Forms/formSettings.vb b/b2sbackglassserver/b2sbackglassserver/Forms/formSettings.vb index 17518e9..572027e 100644 --- a/b2sbackglassserver/b2sbackglassserver/Forms/formSettings.vb +++ b/b2sbackglassserver/b2sbackglassserver/Forms/formSettings.vb @@ -9,7 +9,7 @@ Public Class formSettings Public B2SScreen As B2SScreen = Nothing Public B2SAnimation As B2SAnimation = Nothing - Public formBackglass As formBackglass = Nothing + Public Shared formBackglass As formBackglass = Nothing Public activateMsgBoxAtSaving As Boolean = False Public isSettingsScreenDirty As Boolean = False @@ -239,25 +239,7 @@ Public Class formSettings End If End If End Using - 'Using fbd As FolderBrowserDialog = New FolderBrowserDialog - ' If fbd.ShowDialog(Me) = Windows.Forms.DialogResult.OK Then - ' If IO.File.Exists(IO.Path.Combine(fbd.SelectedPath, "hyperpin.exe")) Then - ' If IO.File.Exists(IO.Path.Combine(fbd.SelectedPath, "Databases", "Visual Pinball", "Visual Pinball.xml")) Then - ' B2SSettings.HyperpinXMLFile = IO.Path.Combine(fbd.SelectedPath, "Databases", "Visual Pinball", "Visual Pinball.xml") - ' B2SSettings.Save(, , , True) - ' MessageBox.Show("'Hyperpin' could be located correctly.", My.Resources.AppTitle, MessageBoxButtons.OK, MessageBoxIcon.Information) - ' Else - ' MessageBox.Show("'Visual Pinball.xml' could not be found in folder '" & IO.Path.Combine(fbd.SelectedPath, "Databases", "Visual Pinball") & "'.", My.Resources.AppTitle, MessageBoxButtons.OK, MessageBoxIcon.Exclamation) - ' End If - ' Else - ' MessageBox.Show("'Hyperpin.exe' could not be found in folder '" & fbd.SelectedPath & "'.", My.Resources.AppTitle, MessageBoxButtons.OK, MessageBoxIcon.Exclamation) - ' End If - ' End If - 'End Using End If - 'Else - 'MessageBox.Show("'Hyperpin' could be found in '" & IO.Directory.GetParent(B2SSettings.HyperpinXMLFile).FullName & "'.", My.Resources.AppTitle, MessageBoxButtons.OK, MessageBoxIcon.Information) - 'End If End Sub Private Sub cmbMatchingFileNames_SelectedIndexChanged(sender As Object, e As System.EventArgs) Handles cmbMatchingFileNames.SelectedIndexChanged isSettingsScreenDirty = True @@ -497,6 +479,6 @@ Public Class formSettings End Sub Private Sub B2SLogo_Click(sender As Object, e As EventArgs) Handles B2SLogo.Click - B2SLogoToolTip.SetToolTip(B2SLogo, B2SSettings.SettingFilePath & vbCrLf & B2SSettings.LoadedResFilePath & vbCrLf & B2SSettings.PluginsFilePath) + B2SLogoToolTip.SetToolTip(B2SLogo, "Settings: " & B2SSettings.SettingFilePath & vbCrLf & "ScreenRes: " & B2SSettings.LoadedResFilePath & vbCrLf & "PluginPath: " & B2SSettings.PluginsFilePath) End Sub End Class \ No newline at end of file diff --git a/b2sbackglassserver/b2sbackglassserver/Forms/formSettingsMore.Designer.vb b/b2sbackglassserver/b2sbackglassserver/Forms/formSettingsMore.Designer.vb index eeb92e5..c8c76b3 100644 --- a/b2sbackglassserver/b2sbackglassserver/Forms/formSettingsMore.Designer.vb +++ b/b2sbackglassserver/b2sbackglassserver/Forms/formSettingsMore.Designer.vb @@ -38,11 +38,11 @@ Partial Class formSettingsMore Me.chkLEDsOff = New System.Windows.Forms.CheckBox() Me.btnCloseSettings = New System.Windows.Forms.Button() Me.GroupRegistrySettings = New System.Windows.Forms.GroupBox() + Me.ChkB2SDebugLog = New System.Windows.Forms.CheckBox() Me.ChkB2STableSettingsExtendedPath = New System.Windows.Forms.CheckBox() Me.lblB2SScreenResFileNameOverride = New System.Windows.Forms.Label() Me.TxtB2SScreenResFileNameOverride = New System.Windows.Forms.TextBox() Me.ChkB2SWindowPunchActive = New System.Windows.Forms.CheckBox() - Me.ChkB2SDebugLog = New System.Windows.Forms.CheckBox() Me.grpLogging.SuspendLayout() Me.grpPerfTests.SuspendLayout() Me.GroupRegistrySettings.SuspendLayout() @@ -58,7 +58,7 @@ Partial Class formSettingsMore Me.grpLogging.Controls.Add(Me.chkLogLamps) Me.grpLogging.Location = New System.Drawing.Point(8, 95) Me.grpLogging.Name = "grpLogging" - Me.grpLogging.Size = New System.Drawing.Size(474, 74) + Me.grpLogging.Size = New System.Drawing.Size(524, 84) Me.grpLogging.TabIndex = 10 Me.grpLogging.TabStop = False Me.grpLogging.Text = "Logging" @@ -66,9 +66,9 @@ Partial Class formSettingsMore 'chkStatisticBackglass ' Me.chkStatisticBackglass.AutoSize = True - Me.chkStatisticBackglass.Location = New System.Drawing.Point(240, 25) + Me.chkStatisticBackglass.Location = New System.Drawing.Point(217, 25) Me.chkStatisticBackglass.Name = "chkStatisticBackglass" - Me.chkStatisticBackglass.Size = New System.Drawing.Size(209, 17) + Me.chkStatisticBackglass.Size = New System.Drawing.Size(203, 17) Me.chkStatisticBackglass.TabIndex = 27 Me.chkStatisticBackglass.Text = "Show statistics backglass after restart" Me.chkStatisticBackglass.UseVisualStyleBackColor = True @@ -76,9 +76,9 @@ Partial Class formSettingsMore 'chkLogLEDs ' Me.chkLogLEDs.AutoSize = True - Me.chkLogLEDs.Location = New System.Drawing.Point(357, 50) + Me.chkLogLEDs.Location = New System.Drawing.Point(411, 54) Me.chkLogLEDs.Name = "chkLogLEDs" - Me.chkLogLEDs.Size = New System.Drawing.Size(69, 17) + Me.chkLogLEDs.Size = New System.Drawing.Size(73, 17) Me.chkLogLEDs.TabIndex = 31 Me.chkLogLEDs.Text = "Log LEDs" Me.chkLogLEDs.UseVisualStyleBackColor = True @@ -87,7 +87,7 @@ Partial Class formSettingsMore ' Me.btnLogPath.Location = New System.Drawing.Point(8, 20) Me.btnLogPath.Name = "btnLogPath" - Me.btnLogPath.Size = New System.Drawing.Size(226, 24) + Me.btnLogPath.Size = New System.Drawing.Size(150, 24) Me.btnLogPath.TabIndex = 26 Me.btnLogPath.Text = "Log path" Me.btnLogPath.UseVisualStyleBackColor = True @@ -95,9 +95,9 @@ Partial Class formSettingsMore 'chkLogSolenoids ' Me.chkLogSolenoids.AutoSize = True - Me.chkLogSolenoids.Location = New System.Drawing.Point(124, 50) + Me.chkLogSolenoids.Location = New System.Drawing.Point(131, 54) Me.chkLogSolenoids.Name = "chkLogSolenoids" - Me.chkLogSolenoids.Size = New System.Drawing.Size(90, 17) + Me.chkLogSolenoids.Size = New System.Drawing.Size(91, 17) Me.chkLogSolenoids.TabIndex = 29 Me.chkLogSolenoids.Text = "Log solenoids" Me.chkLogSolenoids.UseVisualStyleBackColor = True @@ -105,9 +105,9 @@ Partial Class formSettingsMore 'chkLogGIStrings ' Me.chkLogGIStrings.AutoSize = True - Me.chkLogGIStrings.Location = New System.Drawing.Point(240, 50) + Me.chkLogGIStrings.Location = New System.Drawing.Point(271, 54) Me.chkLogGIStrings.Name = "chkLogGIStrings" - Me.chkLogGIStrings.Size = New System.Drawing.Size(92, 17) + Me.chkLogGIStrings.Size = New System.Drawing.Size(91, 17) Me.chkLogGIStrings.TabIndex = 30 Me.chkLogGIStrings.Text = "Log GI strings" Me.chkLogGIStrings.UseVisualStyleBackColor = True @@ -115,9 +115,9 @@ Partial Class formSettingsMore 'chkLogLamps ' Me.chkLogLamps.AutoSize = True - Me.chkLogLamps.Location = New System.Drawing.Point(8, 50) + Me.chkLogLamps.Location = New System.Drawing.Point(8, 54) Me.chkLogLamps.Name = "chkLogLamps" - Me.chkLogLamps.Size = New System.Drawing.Size(73, 17) + Me.chkLogLamps.Size = New System.Drawing.Size(74, 17) Me.chkLogLamps.TabIndex = 28 Me.chkLogLamps.Text = "Log lamps" Me.chkLogLamps.UseVisualStyleBackColor = True @@ -132,7 +132,7 @@ Partial Class formSettingsMore Me.grpPerfTests.Controls.Add(Me.chkLEDsOff) Me.grpPerfTests.Location = New System.Drawing.Point(8, 7) Me.grpPerfTests.Name = "grpPerfTests" - Me.grpPerfTests.Size = New System.Drawing.Size(474, 85) + Me.grpPerfTests.Size = New System.Drawing.Size(524, 85) Me.grpPerfTests.TabIndex = 9 Me.grpPerfTests.TabStop = False Me.grpPerfTests.Text = "Performance tests" @@ -151,7 +151,7 @@ Partial Class formSettingsMore 'chkAllOff ' Me.chkAllOff.Appearance = System.Windows.Forms.Appearance.Button - Me.chkAllOff.Location = New System.Drawing.Point(305, 20) + Me.chkAllOff.Location = New System.Drawing.Point(353, 19) Me.chkAllOff.Name = "chkAllOff" Me.chkAllOff.Size = New System.Drawing.Size(163, 24) Me.chkAllOff.TabIndex = 21 @@ -173,7 +173,7 @@ Partial Class formSettingsMore 'chkSolenoidsOff ' Me.chkSolenoidsOff.Appearance = System.Windows.Forms.Appearance.Button - Me.chkSolenoidsOff.Location = New System.Drawing.Point(123, 50) + Me.chkSolenoidsOff.Location = New System.Drawing.Point(139, 50) Me.chkSolenoidsOff.Name = "chkSolenoidsOff" Me.chkSolenoidsOff.Size = New System.Drawing.Size(111, 24) Me.chkSolenoidsOff.TabIndex = 23 @@ -184,7 +184,7 @@ Partial Class formSettingsMore 'chkGIStringsOff ' Me.chkGIStringsOff.Appearance = System.Windows.Forms.Appearance.Button - Me.chkGIStringsOff.Location = New System.Drawing.Point(240, 50) + Me.chkGIStringsOff.Location = New System.Drawing.Point(272, 50) Me.chkGIStringsOff.Name = "chkGIStringsOff" Me.chkGIStringsOff.Size = New System.Drawing.Size(111, 24) Me.chkGIStringsOff.TabIndex = 24 @@ -195,7 +195,7 @@ Partial Class formSettingsMore 'chkLEDsOff ' Me.chkLEDsOff.Appearance = System.Windows.Forms.Appearance.Button - Me.chkLEDsOff.Location = New System.Drawing.Point(357, 50) + Me.chkLEDsOff.Location = New System.Drawing.Point(405, 50) Me.chkLEDsOff.Name = "chkLEDsOff" Me.chkLEDsOff.Size = New System.Drawing.Size(111, 24) Me.chkLEDsOff.TabIndex = 25 @@ -207,8 +207,7 @@ Partial Class formSettingsMore ' Me.btnCloseSettings.Anchor = CType((System.Windows.Forms.AnchorStyles.Bottom Or System.Windows.Forms.AnchorStyles.Right), System.Windows.Forms.AnchorStyles) Me.btnCloseSettings.DialogResult = System.Windows.Forms.DialogResult.Cancel - Me.btnCloseSettings.Font = New System.Drawing.Font("Tahoma", 8.25!, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, CType(0, Byte)) - Me.btnCloseSettings.Location = New System.Drawing.Point(390, 261) + Me.btnCloseSettings.Location = New System.Drawing.Point(440, 299) Me.btnCloseSettings.Name = "btnCloseSettings" Me.btnCloseSettings.Size = New System.Drawing.Size(92, 24) Me.btnCloseSettings.TabIndex = 35 @@ -222,19 +221,29 @@ Partial Class formSettingsMore Me.GroupRegistrySettings.Controls.Add(Me.lblB2SScreenResFileNameOverride) Me.GroupRegistrySettings.Controls.Add(Me.TxtB2SScreenResFileNameOverride) Me.GroupRegistrySettings.Controls.Add(Me.ChkB2SWindowPunchActive) - Me.GroupRegistrySettings.Location = New System.Drawing.Point(8, 175) + Me.GroupRegistrySettings.Location = New System.Drawing.Point(8, 185) Me.GroupRegistrySettings.Name = "GroupRegistrySettings" - Me.GroupRegistrySettings.Size = New System.Drawing.Size(474, 79) + Me.GroupRegistrySettings.Size = New System.Drawing.Size(524, 110) Me.GroupRegistrySettings.TabIndex = 32 Me.GroupRegistrySettings.TabStop = False Me.GroupRegistrySettings.Text = "Registry settings (HKCU\Software\B2S)" ' + 'ChkB2SDebugLog + ' + Me.ChkB2SDebugLog.AutoSize = True + Me.ChkB2SDebugLog.Location = New System.Drawing.Point(392, 31) + Me.ChkB2SDebugLog.Name = "ChkB2SDebugLog" + Me.ChkB2SDebugLog.Size = New System.Drawing.Size(96, 17) + Me.ChkB2SDebugLog.TabIndex = 36 + Me.ChkB2SDebugLog.Text = "B2SDebugLog" + Me.ChkB2SDebugLog.UseVisualStyleBackColor = True + ' 'ChkB2STableSettingsExtendedPath ' Me.ChkB2STableSettingsExtendedPath.AutoSize = True - Me.ChkB2STableSettingsExtendedPath.Location = New System.Drawing.Point(165, 20) + Me.ChkB2STableSettingsExtendedPath.Location = New System.Drawing.Point(186, 31) Me.ChkB2STableSettingsExtendedPath.Name = "ChkB2STableSettingsExtendedPath" - Me.ChkB2STableSettingsExtendedPath.Size = New System.Drawing.Size(177, 17) + Me.ChkB2STableSettingsExtendedPath.Size = New System.Drawing.Size(178, 17) Me.ChkB2STableSettingsExtendedPath.TabIndex = 35 Me.ChkB2STableSettingsExtendedPath.Text = "B2STableSettingsExtendedPath" Me.ChkB2STableSettingsExtendedPath.UseVisualStyleBackColor = True @@ -242,17 +251,17 @@ Partial Class formSettingsMore 'lblB2SScreenResFileNameOverride ' Me.lblB2SScreenResFileNameOverride.AutoSize = True - Me.lblB2SScreenResFileNameOverride.Location = New System.Drawing.Point(8, 48) + Me.lblB2SScreenResFileNameOverride.Location = New System.Drawing.Point(8, 63) Me.lblB2SScreenResFileNameOverride.Name = "lblB2SScreenResFileNameOverride" - Me.lblB2SScreenResFileNameOverride.Size = New System.Drawing.Size(161, 13) + Me.lblB2SScreenResFileNameOverride.Size = New System.Drawing.Size(164, 13) Me.lblB2SScreenResFileNameOverride.TabIndex = 34 Me.lblB2SScreenResFileNameOverride.Text = "B2SScreenResFileNameOverride" ' 'TxtB2SScreenResFileNameOverride ' - Me.TxtB2SScreenResFileNameOverride.Location = New System.Drawing.Point(187, 45) + Me.TxtB2SScreenResFileNameOverride.Location = New System.Drawing.Point(187, 60) Me.TxtB2SScreenResFileNameOverride.Name = "TxtB2SScreenResFileNameOverride" - Me.TxtB2SScreenResFileNameOverride.Size = New System.Drawing.Size(230, 21) + Me.TxtB2SScreenResFileNameOverride.Size = New System.Drawing.Size(93, 20) Me.TxtB2SScreenResFileNameOverride.TabIndex = 33 Me.TxtB2SScreenResFileNameOverride.TabStop = False Me.TxtB2SScreenResFileNameOverride.WordWrap = False @@ -260,33 +269,22 @@ Partial Class formSettingsMore 'ChkB2SWindowPunchActive ' Me.ChkB2SWindowPunchActive.AutoSize = True - Me.ChkB2SWindowPunchActive.Location = New System.Drawing.Point(8, 20) + Me.ChkB2SWindowPunchActive.Location = New System.Drawing.Point(12, 31) Me.ChkB2SWindowPunchActive.Name = "ChkB2SWindowPunchActive" - Me.ChkB2SWindowPunchActive.Size = New System.Drawing.Size(141, 17) + Me.ChkB2SWindowPunchActive.Size = New System.Drawing.Size(146, 17) Me.ChkB2SWindowPunchActive.TabIndex = 32 Me.ChkB2SWindowPunchActive.Text = "B2SWindowPunchActive" Me.ChkB2SWindowPunchActive.UseVisualStyleBackColor = True ' - 'ChkB2SDebugLog - ' - Me.ChkB2SDebugLog.AutoSize = True - Me.ChkB2SDebugLog.Location = New System.Drawing.Point(357, 20) - Me.ChkB2SDebugLog.Name = "ChkB2SDebugLog" - Me.ChkB2SDebugLog.Size = New System.Drawing.Size(92, 17) - Me.ChkB2SDebugLog.TabIndex = 36 - Me.ChkB2SDebugLog.Text = "B2SDebugLog" - Me.ChkB2SDebugLog.UseVisualStyleBackColor = True - ' 'formSettingsMore ' - Me.AutoScaleDimensions = New System.Drawing.SizeF(6.0!, 13.0!) - Me.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font - Me.ClientSize = New System.Drawing.Size(489, 293) + Me.AutoScaleDimensions = New System.Drawing.SizeF(96.0!, 96.0!) + Me.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi + Me.ClientSize = New System.Drawing.Size(539, 331) Me.Controls.Add(Me.GroupRegistrySettings) Me.Controls.Add(Me.btnCloseSettings) Me.Controls.Add(Me.grpLogging) Me.Controls.Add(Me.grpPerfTests) - Me.Font = New System.Drawing.Font("Tahoma", 8.25!) Me.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedToolWindow Me.KeyPreview = True Me.MaximizeBox = False diff --git a/b2sbackglassserver/b2sbackglassserver/My Project/AssemblyInfo.vb b/b2sbackglassserver/b2sbackglassserver/My Project/AssemblyInfo.vb index 73bc4a2..838a83e 100644 --- a/b2sbackglassserver/b2sbackglassserver/My Project/AssemblyInfo.vb +++ b/b2sbackglassserver/b2sbackglassserver/My Project/AssemblyInfo.vb @@ -2,33 +2,33 @@ 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. +' General Information about an assembly is controlled through the following +' set of attributes. Change these attribute values to modify the information +' associated with an assembly. -' Die Werte der Assemblyattribute überprüfen +' Review the values of the assembly attributes - - + + -'Die folgende GUID bestimmt die ID der Typbibliothek, wenn dieses Projekt für COM verfügbar gemacht wird +'The following GUID is for the ID of the typelib if this project is exposed to COM -' Versionsinformationen für eine Assembly bestehen aus den folgenden vier Werten: +' Version information for an assembly consists of the following four values: ' -' Hauptversion -' Nebenversion -' Buildnummer +' Major Version +' Minor Version +' Build Number ' Revision ' -' Sie können alle Werte angeben oder die standardmäßigen Build- und Revisionsnummern -' übernehmen, indem Sie "*" eingeben: +' You can specify all the values or you can default the Build and Revision Numbers +' by using the '*' as shown below: ' diff --git a/b2sbackglassserver/b2sbackglassserver/Server.vb b/b2sbackglassserver/b2sbackglassserver/Server.vb index f0823a4..f1304e6 100644 --- a/b2sbackglassserver/b2sbackglassserver/Server.vb +++ b/b2sbackglassserver/b2sbackglassserver/Server.vb @@ -125,119 +125,125 @@ Public Class Server End Sub Private Sub Timer_Tick() + Try - ' check whether the table is still running - If tableHandle <> 0 AndAlso Not IsWindow(tableHandle) Then + ' check whether the table is still running + If tableHandle <> 0 AndAlso Not IsWindow(tableHandle) Then - Try - Me.Stop() - Finally - Me.Dispose() - End Try + Try + Me.Stop() + Finally + Me.Dispose() + End Try - Else + Else - ' maybe reload settings - If B2SData.IsBackglassStartedAsEXE Then - Static settingscounter As Integer = 0 - settingscounter += 1 + ' maybe reload settings + If B2SData.IsBackglassStartedAsEXE Then + Static settingscounter As Integer = 0 + settingscounter += 1 - ' check for set switches - Static whatsupwithswitches As Boolean = True - Static look4switches As Boolean = False - If whatsupwithswitches Then - Using regkey As RegistryKey = Registry.CurrentUser.OpenSubKey("Software\B2S", True) - Dim switch As Integer = 0 - If Not look4switches Then - switch = CInt(regkey.GetValue("B2SSetSwitch", "-1")) - If switch > -1 Then - whatsupwithswitches = (switch = 1) - look4switches = (switch = 1) - regkey.DeleteValue("B2SSetSwitch", False) + ' check for set switches + Static whatsupwithswitches As Boolean = True + Static look4switches As Boolean = False + If whatsupwithswitches Then + Using regkey As RegistryKey = Registry.CurrentUser.OpenSubKey("Software\B2S", True) + Dim switch As Integer = 0 + If Not look4switches Then + switch = CInt(regkey.GetValue("B2SSetSwitch", "-1")) + If switch > -1 Then + whatsupwithswitches = (switch = 1) + look4switches = (switch = 1) + regkey.DeleteValue("B2SSetSwitch", False) + End If + End If + If look4switches Then + For i As Integer = 1 To 2 + switch = CInt(regkey.GetValue("B2SSetSwitch" & i.ToString(), "0")) + If switch > 0 Then + B2SAnimation.SetSwitch(switch) + regkey.DeleteValue("B2SSetSwitch" & i.ToString(), False) + End If + Next End If + End Using + End If + + ' maybe reload settings + If settingscounter >= 200 Then + settingscounter = 0 + Dim reloadSettings As Boolean = (Registry.CurrentUser.OpenSubKey("Software\B2S").GetValue("B2SReloadSettings", 0) = 1) + If reloadSettings Then + Registry.CurrentUser.OpenSubKey("Software\B2S", True).SetValue("B2SReloadSettings", 0) + B2SSettings.Load(False) End If - If look4switches Then - For i As Integer = 1 To 2 - switch = CInt(regkey.GetValue("B2SSetSwitch" & i.ToString(), "0")) - If switch > 0 Then - B2SAnimation.SetSwitch(switch) - regkey.DeleteValue("B2SSetSwitch" & i.ToString(), False) + End If + + ' maybe open plugins window + If (settingscounter Mod 10) = 0 AndAlso B2SSettings.ArePluginsOn AndAlso B2SSettings.PluginHost IsNot Nothing AndAlso B2SSettings.PluginHost.Plugins.Count > 0 Then + Dim openPluginWindow As Boolean = (Registry.CurrentUser.OpenSubKey("Software\B2S").GetValue("PluginsOpenDialog", 0) = 1) + If openPluginWindow Then + Dim pluginScreenBounds As System.Drawing.Rectangle = Nothing + Using regkey As RegistryKey = Registry.CurrentUser.OpenSubKey("Software\B2S", True) + Dim screensettings As String = regkey.GetValue("PluginsScreen").ToString + If Not String.IsNullOrEmpty(screensettings) Then + Dim tmp As String() = regkey.GetValue("PluginsScreen").ToString.Split(",") + If tmp.Length >= 4 Then + pluginScreenBounds = New System.Drawing.Rectangle(CInt(tmp(0)), CInt(tmp(1)), CInt(tmp(2)), CInt(tmp(3))) + End If End If - Next + regkey.DeleteValue("PluginsScreen", False) + regkey.DeleteValue("PluginsOpenDialog", False) + End Using + B2SSettings.PluginHost.ShowPluginWindow(, pluginScreenBounds) End If - End Using - End If - - ' maybe reload settings - If settingscounter >= 200 Then - settingscounter = 0 - Dim reloadSettings As Boolean = (Registry.CurrentUser.OpenSubKey("Software\B2S").GetValue("B2SReloadSettings", 0) = 1) - If reloadSettings Then - Registry.CurrentUser.OpenSubKey("Software\B2S", True).SetValue("B2SReloadSettings", 0) - B2SSettings.Load(False) End If End If - ' maybe open plugins window - If (settingscounter Mod 10) = 0 AndAlso B2SSettings.ArePluginsOn AndAlso B2SSettings.PluginHost IsNot Nothing AndAlso B2SSettings.PluginHost.Plugins.Count > 0 Then - Dim openPluginWindow As Boolean = (Registry.CurrentUser.OpenSubKey("Software\B2S").GetValue("PluginsOpenDialog", 0) = 1) - If openPluginWindow Then - Dim pluginScreenBounds As System.Drawing.Rectangle = Nothing - Using regkey As RegistryKey = Registry.CurrentUser.OpenSubKey("Software\B2S", True) - Dim screensettings As String = regkey.GetValue("PluginsScreen").ToString - If Not String.IsNullOrEmpty(screensettings) Then - Dim tmp As String() = regkey.GetValue("PluginsScreen").ToString.Split(",") - If tmp.Length >= 4 Then - pluginScreenBounds = New System.Drawing.Rectangle(CInt(tmp(0)), CInt(tmp(1)), CInt(tmp(2)), CInt(tmp(3))) - End If - End If - regkey.DeleteValue("PluginsScreen", False) - regkey.DeleteValue("PluginsOpenDialog", False) - End Using - B2SSettings.PluginHost.ShowPluginWindow(, pluginScreenBounds) + ' have a look for important pollings + Static counter As Integer = 0 + Static callLamps As Boolean = False + Static callSolenoids As Boolean = False + Static callGIStrings As Boolean = False + Static callLEDs As Boolean = False + If counter <= 25 Then + counter += 1 + callLamps = Not isChangedLampsCalled AndAlso (B2SData.IsBackglassStartedAsEXE OrElse B2SData.UseRomLamps OrElse B2SData.UseAnimationLamps) + callSolenoids = Not isChangedSolenoidsCalled AndAlso (B2SData.IsBackglassStartedAsEXE OrElse B2SData.UseRomSolenoids OrElse B2SData.UseAnimationSolenoids) + callGIStrings = Not isChangedGIStringsCalled AndAlso (B2SData.IsBackglassStartedAsEXE OrElse B2SData.UseRomGIStrings OrElse B2SData.UseAnimationGIStrings) + callLEDs = Not isChangedLEDsCalled AndAlso (B2SData.IsBackglassStartedAsEXE OrElse B2SData.UseLEDs OrElse B2SData.UseLEDDisplays OrElse B2SData.UseReels) + CheckTableHandle() + Else + If B2SSettings.IsROMControlled Then + If callLamps Then Dim chg As Object = ChangedLamps() + If callSolenoids Then Dim chg As Object = ChangedSolenoids() + If callGIStrings Then Dim chg As Object = ChangedGIStrings() + If callLEDs Then Dim chg As Object = ChangedLEDs(&HFFFFFFFF, &HFFFFFFFF) End If End If - End If - ' have a look for important pollings - Static counter As Integer = 0 - Static callLamps As Boolean = False - Static callSolenoids As Boolean = False - Static callGIStrings As Boolean = False - Static callLEDs As Boolean = False - If counter <= 25 Then - counter += 1 - callLamps = Not isChangedLampsCalled AndAlso (B2SData.IsBackglassStartedAsEXE OrElse B2SData.UseRomLamps OrElse B2SData.UseAnimationLamps) - callSolenoids = Not isChangedSolenoidsCalled AndAlso (B2SData.IsBackglassStartedAsEXE OrElse B2SData.UseRomSolenoids OrElse B2SData.UseAnimationSolenoids) - callGIStrings = Not isChangedGIStringsCalled AndAlso (B2SData.IsBackglassStartedAsEXE OrElse B2SData.UseRomGIStrings OrElse B2SData.UseAnimationGIStrings) - callLEDs = Not isChangedLEDsCalled AndAlso (B2SData.IsBackglassStartedAsEXE OrElse B2SData.UseLEDs OrElse B2SData.UseLEDDisplays OrElse B2SData.UseReels) - CheckTableHandle() - Else - If B2SSettings.IsROMControlled Then - If callLamps Then Dim chg As Object = ChangedLamps() - If callSolenoids Then Dim chg As Object = ChangedSolenoids() - If callGIStrings Then Dim chg As Object = ChangedGIStrings() - If callLEDs Then Dim chg As Object = ChangedLEDs(&HFFFFFFFF, &HFFFFFFFF) + ' maybe the table is reseted so reset some stuff + If tableReset Then + tableCount = 0 + counter = 0 + callLamps = False + callSolenoids = False + callGIStrings = False + callLEDs = False + isChangedLampsCalled = False + isChangedSolenoidsCalled = False + isChangedGIStringsCalled = False + isChangedLEDsCalled = False + 'B2SData.IsBackglassStartedAsEXE = False + tableReset = False End If - End If - ' maybe the table is reseted so reset some stuff - If tableReset Then - tableCount = 0 - counter = 0 - callLamps = False - callSolenoids = False - callGIStrings = False - callLEDs = False - isChangedLampsCalled = False - isChangedSolenoidsCalled = False - isChangedGIStringsCalled = False - isChangedLEDsCalled = False - 'B2SData.IsBackglassStartedAsEXE = False - tableReset = False End If - - End If + Catch ex As Exception + Dim st As New StackTrace(ex, True) + errorlog.WriteLogEntry(DateTime.Now & "Line: " & st.GetFrame(0).GetMethod().Name & " : " & st.GetFrame(0).GetFileLineNumber().ToString & " : " & ex.Message) + Throw ex + End Try End Sub diff --git a/b2sbackglassserverexe/b2sbackglassserverexe/Classes/B2SScreen.vb b/b2sbackglassserverexe/b2sbackglassserverexe/Classes/B2SScreen.vb index 062fa48..d07a73c 100644 --- a/b2sbackglassserverexe/b2sbackglassserverexe/Classes/B2SScreen.vb +++ b/b2sbackglassserverexe/b2sbackglassserverexe/Classes/B2SScreen.vb @@ -474,7 +474,6 @@ Public Class B2SScreen ' move and scale all picked objects ScaleAllControls(rescaleBackglassX, rescaleBackglassY, rescaleDMDX, rescaleDMDY) - ' show the backglass form formBackglass.StartPosition = FormStartPosition.Manual formBackglass.BackgroundImageLayout = ImageLayout.Stretch diff --git a/b2sbackglassserverexe/b2sbackglassserverexe/Classes/B2SSettings.vb b/b2sbackglassserverexe/b2sbackglassserverexe/Classes/B2SSettings.vb index a6e28bb..a002f62 100644 --- a/b2sbackglassserverexe/b2sbackglassserverexe/Classes/B2SSettings.vb +++ b/b2sbackglassserverexe/b2sbackglassserverexe/Classes/B2SSettings.vb @@ -49,6 +49,7 @@ Public Class B2SSettings Public Shared Property MatchingFileName() As String = String.Empty Public Shared Property MatchingFileNames() As String() = Nothing + Public Shared Property PluginsFilePath() As String = String.Empty Public Shared Property LoadedResFilePath() As String = String.Empty Public Shared Property LogPath() As String = String.Empty Public Shared Property IsLampsStateLogOn() As Boolean = False diff --git a/b2sbackglassserverexe/b2sbackglassserverexe/Controls/B2SReelBox.vb b/b2sbackglassserverexe/b2sbackglassserverexe/Controls/B2SReelBox.vb index 99d8825..8940ed6 100644 --- a/b2sbackglassserverexe/b2sbackglassserverexe/Controls/B2SReelBox.vb +++ b/b2sbackglassserverexe/b2sbackglassserverexe/Controls/B2SReelBox.vb @@ -39,9 +39,11 @@ Public Class B2SReelBox MyBase.Dispose(disposing) On Error Resume Next If disposing Then - timer.Stop() - RemoveHandler timer.Tick, AddressOf ReelAnimationTimer_Tick - timer.Dispose() + If timer IsNot Nothing Then + timer.Stop() + RemoveHandler timer.Tick, AddressOf ReelAnimationTimer_Tick + timer.Dispose() + End If timer = Nothing End If End Sub diff --git a/b2sbackglassserverexe/b2sbackglassserverexe/Forms/formBackglass.vb b/b2sbackglassserverexe/b2sbackglassserverexe/Forms/formBackglass.vb index 39abf94..6d9f451 100644 --- a/b2sbackglassserverexe/b2sbackglassserverexe/Forms/formBackglass.vb +++ b/b2sbackglassserverexe/b2sbackglassserverexe/Forms/formBackglass.vb @@ -2346,6 +2346,7 @@ Public Class formBackglass If topnode.SelectSingleNode("Reels") IsNot Nothing Then If topnode.SelectNodes("Reels/Image") IsNot Nothing AndAlso topnode.SelectNodes("Reels/Image").Count > 0 Then + For Each innerNode As Xml.XmlElement In topnode.SelectNodes("Reels/Image") Dim name As String = innerNode.Attributes("Name").InnerText Dim image As Image = Base64ToImage(innerNode.Attributes("Image").InnerText) diff --git a/b2sbackglassserverexe/b2sbackglassserverexe/Forms/formSettings.vb b/b2sbackglassserverexe/b2sbackglassserverexe/Forms/formSettings.vb index a86a621..a087bba 100644 --- a/b2sbackglassserverexe/b2sbackglassserverexe/Forms/formSettings.vb +++ b/b2sbackglassserverexe/b2sbackglassserverexe/Forms/formSettings.vb @@ -243,26 +243,6 @@ Public Class formSettings End If End Using End If - 'If MessageBox.Show("To locate 'Hyperpin' correctly please select the 'Hyperpin' folder.", My.Resources.AppTitle, MessageBoxButtons.OK, MessageBoxIcon.Exclamation) = Windows.Forms.DialogResult.OK Then - ' Using fbd As FolderBrowserDialog = New FolderBrowserDialog - ' If fbd.ShowDialog(Me) = Windows.Forms.DialogResult.OK Then - ' If IO.File.Exists(IO.Path.Combine(fbd.SelectedPath, "hyperpin.exe")) Then - ' If IO.File.Exists(IO.Path.Combine(fbd.SelectedPath, "Databases", "Visual Pinball", "Visual Pinball.xml")) Then - ' B2SSettings.HyperpinXMLFile = IO.Path.Combine(fbd.SelectedPath, "Databases", "Visual Pinball", "Visual Pinball.xml") - ' B2SSettings.Save(, , True) - ' MessageBox.Show("'Hyperpin' could be located correctly.", My.Resources.AppTitle, MessageBoxButtons.OK, MessageBoxIcon.Information) - ' Else - ' MessageBox.Show("'Visual Pinball.xml' could not be found in folder '" & IO.Path.Combine(fbd.SelectedPath, "Databases", "Visual Pinball") & "'.", My.Resources.AppTitle, MessageBoxButtons.OK, MessageBoxIcon.Exclamation) - ' End If - ' Else - ' MessageBox.Show("'Hyperpin.exe' could not be found in folder '" & fbd.SelectedPath & "'.", My.Resources.AppTitle, MessageBoxButtons.OK, MessageBoxIcon.Exclamation) - ' End If - ' End If - ' End Using - 'End If - 'Else - 'MessageBox.Show("'Hyperpin' could be found in '" & IO.Directory.GetParent(B2SSettings.HyperpinXMLFile).FullName & "'.", My.Resources.AppTitle, MessageBoxButtons.OK, MessageBoxIcon.Information) - 'End If End Sub Private Sub cmbMatchingFileNames_SelectedIndexChanged(sender As Object, e As System.EventArgs) Handles cmbMatchingFileNames.SelectedIndexChanged isSettingsScreenDirty = True @@ -486,10 +466,12 @@ Public Class formSettings pi.FileName = B2S_Identifier p.StartInfo = pi + Me.Visible = False p.Start() p.WaitForExit() Me.Visible = True + End If End Sub @@ -504,7 +486,7 @@ Public Class formSettings End Sub Private Sub B2SLogo_Click(sender As Object, e As EventArgs) Handles B2SLogo.Click - B2SLogoToolTip.SetToolTip(B2SLogo, B2SSettings.SettingFilePath & vbCrLf & B2SSettings.LoadedResFilePath) ' & vbCrLf & B2SSettings.PluginsFilePath) + B2SLogoToolTip.SetToolTip(B2SLogo, "Settings: " & B2SSettings.SettingFilePath & vbCrLf & "ScreenRes: " & B2SSettings.LoadedResFilePath & vbCrLf & "PluginPath: " & B2SSettings.PluginsFilePath) End Sub End Class \ No newline at end of file diff --git a/b2sbackglassserverexe/b2sbackglassserverexe/Logging/Log.vb b/b2sbackglassserverexe/b2sbackglassserverexe/Logging/Log.vb index f65530c..5d256a6 100644 --- a/b2sbackglassserverexe/b2sbackglassserverexe/Logging/Log.vb +++ b/b2sbackglassserverexe/b2sbackglassserverexe/Logging/Log.vb @@ -19,11 +19,13 @@ Public Class Log End Set End Property + Public Property LogPath() As String = B2SSettings.LogPath + Public Sub WriteLogEntry(ByVal text As String) - If writeLog AndAlso Not String.IsNullOrEmpty(B2SSettings.LogPath) Then + If writeLog AndAlso Not String.IsNullOrEmpty(LogPath) Then ' write to log file On Error Resume Next - Dim log As IO.StreamWriter = New IO.StreamWriter(IO.Path.Combine(B2SSettings.LogPath, filename), True) + Dim log As IO.StreamWriter = New IO.StreamWriter(IO.Path.Combine(LogPath, filename), True) log.WriteLine(text) log.Flush() log.Close() diff --git a/b2sbackglassserverexe/b2sbackglassserverexe/My Project/AssemblyInfo.vb b/b2sbackglassserverexe/b2sbackglassserverexe/My Project/AssemblyInfo.vb index 8eda8c9..a9e4def 100644 --- a/b2sbackglassserverexe/b2sbackglassserverexe/My Project/AssemblyInfo.vb +++ b/b2sbackglassserverexe/b2sbackglassserverexe/My Project/AssemblyInfo.vb @@ -2,33 +2,33 @@ 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. +' General Information about an assembly is controlled through the following +' set of attributes. Change these attribute values to modify the information +' associated with an assembly. -' Die Werte der Assemblyattribute überprüfen +' Review the values of the assembly attributes - + -'Die folgende GUID bestimmt die ID der Typbibliothek, wenn dieses Projekt für COM verfügbar gemacht wird +'The following GUID is for the ID of the typelib if this project is exposed to COM -' Versionsinformationen für eine Assembly bestehen aus den folgenden vier Werten: +' Version information for an assembly consists of the following four values: ' -' Hauptversion -' Nebenversion -' Buildnummer +' Major Version +' Minor Version +' Build Number ' Revision ' -' Sie können alle Werte angeben oder die standardmäßigen Build- und Revisionsnummern -' übernehmen, indem Sie "*" eingeben: +' You can specify all the values or you can default the Build and Revision Numbers +' by using the '*' as shown below: ' diff --git a/b2sbackglassserverexe/b2sbackglassserverexe/Server.vb b/b2sbackglassserverexe/b2sbackglassserverexe/Server.vb index f4c0730..6a81e37 100644 --- a/b2sbackglassserverexe/b2sbackglassserverexe/Server.vb +++ b/b2sbackglassserverexe/b2sbackglassserverexe/Server.vb @@ -1,7 +1,7 @@ Imports System +Imports System.Text Imports System.Runtime.InteropServices Imports Microsoft.Win32 -Imports System.Text _ Public Class Server diff --git a/b2sbackglassserverregisterapp/b2sbackglassserverregisterapp/My Project/AssemblyInfo.vb b/b2sbackglassserverregisterapp/b2sbackglassserverregisterapp/My Project/AssemblyInfo.vb index f6e7e18..63407f8 100644 --- a/b2sbackglassserverregisterapp/b2sbackglassserverregisterapp/My Project/AssemblyInfo.vb +++ b/b2sbackglassserverregisterapp/b2sbackglassserverregisterapp/My Project/AssemblyInfo.vb @@ -9,8 +9,8 @@ Imports System.Runtime.InteropServices ' Review the values of the assembly attributes - - + +