How to set network state private or public using AutoIt ?

t0nZ · August 3, 2022

Hi to all, I was wondering how to do something like this powershell command:

Get-NetConnectionProfile -InterfaceAlias "Ethernet" | Set-NetConnectionProfile -NetworkCategory Private -Confirm:$false -PassThru

natively, or bypassing powershell, in AutoIt.

My goal is to change the state of the current network connection from public to private and viceversa.

And looking beyond, to enable/disable network discovery, network crypt properties, sharing options etc....

Edited August 3, 2022 by t0nZ

rsn · August 4, 2022

You could set the registry values directly at

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\NetworkList\Profiles\<guid>

Category will be a DWORD with one of the following values:

0 for Public network

1 for Private network

2 for Domain network

t0nZ · August 4, 2022

Thank you @rsn.

I am exploring also the registry way, it's seems interesting, and maybe easier.

My final goal is to have a solution to execute a script on a "random" machine and have:

current connected network to private
allow sharing without password
set up a folder shared to everyone R/W
transfer some data
revert all this.

I have already solutions for points 3 and 4.. working on 1 and 2.

Returning to powershell way, I come up with this :

Func _Set_Network_Private() ; 
    ShellExecuteWait("powershell.exe", "start-process -verb runas 'powershell.exe' " & _
            "-argumentlist @('-executionpolicy unrestricted',' -command Get-NetConnectionProfile -InterfaceAlias Ethernet | Set-NetConnectionProfile -NetworkCategory Private -Confirm:$false -PassThru')", '', '', @SW_SHOW)
EndFunc

This can be run inside a non admin script, and it asks for elevation. Moreover, if you want to set private/public the current active connection, you can change this

-InterfaceAlias Ethernet

with this:

-IPv4Connectivity Internet

...quick and dirty.... keeping in mind this command output in powershell :

Quote

PS C:\Windows\system32> powershell.exe -executionpolicy unrestricted -command 'Get-NetConnectionProfile -IPv4Connectivity Internet| Set-NetConnectionProfile -NetworkCategory Private -Confirm:$false -PassThru'

Name : guest
InterfaceAlias : Wi-Fi
InterfaceIndex : 6
NetworkCategory : Private
IPv4Connectivity : Internet
IPv6Connectivity : NoTraffic

rsn · August 4, 2022

If you're an admin on the remote PC, you don't have to set up sharing. The admin share will be accessible by either IP or hostname:

\\<hostname>\c$\path\to\whatever or \\<IPAddress>\c$\path\to\whatever

If you aren't an admin, you probably shouldn't be doing this kind of stuff... :think:

t0nZ · August 5, 2022

Quote

If you aren't an admin, you probably shouldn't be doing this kind of stuff...

@rsn I am improving 2 existing scripts of mine capable of moving data between two PCs, and these scripts are working one on the source and one on the destination, and they use a shared folder to pass files.

In my typical scenario, I have to move data between heterogeneous machines (one in domain one not, or different domains, or no domain at all, user already admin or not, or admin disabled) so c$ it's not an option, and for years I went through shared folders...

But 🤔 ... I should create two identical hidden admin users on both machines, to work like you suggest...

jguinch · August 5, 2022

Here is a way to do it without using any external command (just use COM objects)

#RequireAdmin ; Needed

_NetSetCategory("LAN", 1) ; Sets the Private category to the network connection called "LAN"


; #FUNCTION# ====================================================================================================================
; Name...........: _NetSetCategory
; Description....: Sets the category of a network. Changes made take effect immediately
; Syntax.........: _NetSetCategory($sNetworkId, $iNetCategory)
; Parameters.....: $sNetworkId     - Name of the network connection
;                  $iNetCategory   - New category of the network. Can be one of :
;                   0 : Public
;                   1 : Private
;                   2 : Domain
; Return values..: Success  - 1
;                  Failure  - 0 and sets the @error flag to non-zero
; Remarks........: The function requires administrator privileges
; ===============================================================================================================================
Func _NetSetCategory($sNetworkId, $iNetCategory)
    Local $iRet = 1, $iNetFound = 0, $oNetwork, $oNetConnection
    If Not IsAdmin() Then Return SetError(4, 0, 0)
    If Not IsInt($iNetCategory) Or $iNetCategory < 0 Or $iNetCategory > 2 Then Return SetError(5, 0, 0)
    Local $INetListManager = ObjCreate("{DCB00C01-570F-4A9B-8D69-199FDBA5723B}")
    If Not IsObj($INetListManager) Then Return SetError($iRet, 0, 0)
    Local $oNetConnections = $INetListManager.GetNetworkConnections()
    If IsObj($oNetConnections) Then
        For $oNetConnection In $oNetConnections
            $oNetwork = $oNetConnection.GetNetwork
            If $oNetwork.GetName = $sNetworkId Then
                $iNetFound = 1
                Execute("$oNetwork.SetCategory($iNetCategory)")
                $iRet = (@error ? 2 : 0)
            EndIf
        Next
        If Not $iNetFound Then $iRet = 3
    EndIf
    $INetListManager = 0
    If $iRet Then Return SetError($iRet, 0, 0)
    Return 1
EndFunc ; ===> _NetSetCategory

Inspired from @Danyfirex code (thanks)

rudi · August 9, 2022

Hi.

As you write, that you have a mixture of stand alone PCs and Domain PCs I'd like to mention, that there is another registry value that can be a bad constraint:

Windows Registry Editor Version 5.00
[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa]
"lmcompatibilitylevel"=dword:00000005

If the destination computer providing the share has this value set to 5, and a computer from a different domain or a stand alone PC is set to 0, 1 or 2 trying to use this share, then this will only work, if specifying a AD-user account with access rights from the domain, the sharing computer is a member of.

Using a local user account of the PC/Win-Server presenting the share will not work. The error message will give you an "invalid username or password" error. Any AD account will work smoothly (but that was not possible for my scenario)

https://docs.microsoft.com/en-us/windows/security/threat-protection/security-policy-settings/network-security-lan-manager-authentication-level

Seting both sides to "2" solves this issue immediately, a reboot is not required.

If this should switch back to 5 check for the GPO pushing the value and exclude the sharing server from receiving that particular GPO.

Regards, Rudi.

t0nZ · August 24, 2022

Thank you to all guys.

@rudi very interesting, I think can explain some problems I experienced sometimes, thanks.

Thanks also to august month, I had some time to explore the winsows smb sharing world, and thank also to @jguinch I assembled a testbed to manage:

the public/private state of the current connected network
so you have to find the current connected network
once you have set the network to private I have to :
go to the advanced sharing setting center
enable the network discovery (and these are a group of firewall rules and the name of the group change with the windows language (! blame M$)
enable "file and printers sharing" same story, a group of firewall rules changing with the win language
turning off the "password protected sharing option" in "all networks".

image.png.e77f9e70b89558ffee357e28240abd2f.png

I managed to accomplish all the tasks with various powershell commands (althought I have to launch some .ps1 files because I am not able to launch some complex commands), but the last one "password protected sharing option" is a mess and I tried a lot of cmd line solutions, but none is workin' well, the most promising was this.

So I "solved" in an ugly mode with a bunch of sendkeys.

Also the code is ugly but is intended as a testbed:

#Region ;**** Directives created by AutoIt3Wrapper_GUI ****
#AutoIt3Wrapper_Icon=Icone\netUtilS.ico
#EndRegion ;**** Directives created by AutoIt3Wrapper_GUI ****
;Net Utils

;network utils testbed

;(c)NSC 2022

#include <_GOLLOG.au3>
#include <File.au3>
#include <Array.au3>
#include <GUIConstantsEx.au3>
#include <MsgBoxConstants.au3>


Global $NetworkName = "test", $newPCname = "DeskNEW1", $Ver = "V.0.5 alpha", $mygui = "Net Utils" & "        " & $Ver & "                          NSC 2022"
Global $BsetPrivate, $BsetDiscovery, $bUnSetPrivate, $BUnsetDiscovery, $bComGETNETworks, $bnetList
Global $bcomNETcat, $bRenamePC, $Bsetshare, $bUnsetshare, $Badvshare, $Bsend1, $Bsend2
Global $niv = "NetworkInterfacesView.exe", $apppath = "c:\autoit\NetUtils", $NetListFile = "nets.csv"
Global $aNetsList = 0, $DevActive, $NetActive, $IPAddress, $NetSpeed, $aNetsList = 0


;region Get Network connected
Global $NLM_ENUM_NETWORK_CONNECTED = 0x01
Global $NLM_ENUM_NETWORK_DISCONNECTED = 0x02
;Global $NLM_ENUM_NETWORK_ALL = 0x03
Global Enum $eName, $eIsConnectedtoInternet


Gui()

prepare()

GenerarateNetList()

ReadNetList()

InputCycle()



Func Gui()
    GUICreate($mygui, 600, 455, 200, 200)
    GUISetState(@SW_SHOW)

    gollog_ini($mygui, 5, 5, 590, 290, "0x0033cc", "0xffff00", "courier") ; initialization with colors and font choice, more options see the UDF
    Gollog(">>> START Net Utils |nocrlf50")
    Gollog(" - " & $Ver)
    ;sleep(1000)
    GUICtrlCreateLabel("PowerShell commands:", 5, 305, 150, 25)
    $BsetPrivate = GUICtrlCreateButton("Set Private", 155, 305, 100, 25)
    $bUnSetPrivate = GUICtrlCreateButton("Set Public", 260, 305, 100, 25)

    $BsetDiscovery = GUICtrlCreateButton("Set Discovery", 365, 305, 100, 25)
    GUICtrlSetBkColor(-1, "0xd4bed0")
    $bUnSetDiscovery = GUICtrlCreateButton("UnSet Discovery", 470, 305, 100, 25)
    GUICtrlSetBkColor(-1, "0xd4bed0")

    $Bsetshare = GUICtrlCreateButton("Set Share", 155, 335, 100, 25)
    GUICtrlSetBkColor(-1, "0xc1b6f0")
    $bUnSetshare = GUICtrlCreateButton("UnSet Share", 260, 335, 100, 25)
    GUICtrlSetBkColor(-1, "0xc1b6f0")

    GUICtrlCreateLabel("Ugly workarounds:", 5, 365, 150, 25)
    $Badvshare = GUICtrlCreateButton("Open Adv.Sharing", 155, 365, 100, 25)
    GUICtrlSetBkColor(-1, "0xc1c6f5")

    $Bsend1 = GUICtrlCreateButton("OFF psw sharing", 365, 365, 100, 25)
    GUICtrlSetBkColor(-1, "0xc1c6f6")
    $Bsend2 = GUICtrlCreateButton("ON psw sharing", 470, 365, 100, 25)
    GUICtrlSetBkColor(-1, "0xc1c6f6")

    GUICtrlCreateLabel("COM commands:", 5, 395, 150, 25)
    $bcomNETcat = GUICtrlCreateButton("Set Private/Public (admin req.)", 155, 395, 205, 25)

    GUICtrlCreateLabel("Misc:", 5, 415, 150, 25)
    $bnetList = GUICtrlCreateButton("List Networks (NirSoft)", 155, 425, 150, 25)
    $bComGETNETworks = GUICtrlCreateButton("Get Connected (COM)", 310, 425, 150, 25)
    $bRenamePC = GUICtrlCreateButton("Rename PC", 465, 425, 100, 25)
    GUICtrlSetBkColor(-1, "0x8de3a8")
EndFunc   ;==>Gui


Func prepare()

    If Not FileExists($apppath) Then
        DirCreate($apppath)
        gollog("created " & $apppath)
    Else
        Gollog("already present " & $apppath)
    EndIf

    ;nirsoft program
    If FileExists($apppath & "\" & $niv) Then
        FileDelete($apppath & "\" & $niv)
        gollog("deleted " & "\" & $niv)
    Else
        Gollog("not present " & "\" & $niv)
    EndIf

    _NirSoft_NetworkInterfacesView(True, $apppath)
    Gollog("deployed " & $niv)

    ;Powershell.ps1 scripts
    If FileExists($apppath & "\" & "*.ps1") Then
        FileDelete($apppath & "\" & "*.ps1")
        gollog("deleted some " & "*.ps1")
    Else
        Gollog("not present " & "*.ps1")
    EndIf

    _CondivisioneFileEStampantiPRIVATETRUE(True, $apppath)
    _CondivisioneFileEStampantiPRIVATEFALSE(True, $apppath)
    _IndividuazioneRetePRIVATETRUE(True, $apppath)
    _IndividuazioneRetePRIVATEFALSE(True, $apppath)
    Gollog("deployed .ps1 files")

EndFunc   ;==>prepare

Func InputCycle()

    While 1
        Switch GUIGetMsg()
            Case $GUI_EVENT_CLOSE
                ExitLoop

            Case $BsetPrivate
                Gollog("Set " & $NetActive & " as Private")
                _Set_Network_Private($NetActive, "Private")


            Case $BsetDiscovery
                Gollog("Activate network discovery on Private network")
                ExecuteElevatedPS1($apppath & "\individuazioneRetePRIVATETRUE.ps1")

                ;not working maybe due to bracket ?
                ;_Set_Network_Discovery("Individuazione Rete", "Private", "true")

            Case $bUnSetDiscovery
                Gollog("Deactivate network discovery on Private network")
                ExecuteElevatedPS1($apppath & "\individuazioneRetePRIVATEFALSE.ps1")

                ;not working maybe due to bracket ?
                ;_Set_Network_Discovery("Individuazione Rete", "Private", "False")

            Case $bUnSetPrivate
                Gollog("Set " & $NetActive & " as Public")
                _Set_Network_Private($NetActive, "Public")

            Case $Bsetshare
                Gollog("Activate sharing on private network")
                ExecuteElevatedPS1($apppath & "\CondivisioneFileEStampantiPRIVATETRUE.ps1")

            Case $bUnSetshare
                Gollog("DeActivate sharing on private network")
                ExecuteElevatedPS1($apppath & "\CondivisioneFileEStampantiPRIVATEFALSE.ps1")

            Case $bComGETNETworks
                Gollog("using COM to read networks")
                displayActNET(GetNetworks_COM())

            Case $bnetList
                Gollog("listing networks from NirSoft Util")
                netlist()

            Case $bcomNETcat
                Gollog("set network category via COM")
                NetSetCategory(GetNetworks_COM())

            Case $bRenamePC
                Gollog("renamin'PC")
                Local $Newname = InputBox("Change PC Name...", "Enter NEW name:", "PC" & @SEC & @MSEC)
                _RenamePC($Newname)

            Case $Badvshare
                Gollog("opening Advanced Sharing Center")
                ShellExecuteWait("control.exe", "/name Microsoft.NetworkAndSharingCenter /page Advanced")
                Sleep(400)
                WinActivate($mygui)

            Case $Bsend1
                Gollog("turning OFF Password protected Sharing")
                TogglePassProtSharing("0")

            Case $Bsend2
                Gollog("turning ON Password protected Sharing")
                TogglePassProtSharing("1")

        EndSwitch
    WEnd

    Exit

EndFunc   ;==>InputCycle


Func GenerarateNetList()

    If FileExists($apppath & "\" & $NetListFile) Then
        FileDelete($apppath & "\" & $NetListFile)
        gollog("deleted " & "\" & $NetListFile)
    Else
        Gollog("not present " & "\" & $NetListFile)
    EndIf

    Gollog("retrieving list of networks")
    ShellExecuteWait($apppath & "\" & $niv, "/scomma " & $apppath & "\" & $NetListFile)

EndFunc   ;==>GenerarateNetList

Func ReadNetList()
    _FileReadToArray($apppath & "\" & $NetListFile, $aNetsList, 1, ",")

    ;_ArrayDisplay($aNetsList)

    For $i = 1 To $aNetsList[0][0]

        If $aNetsList[$i][17] = "Operational" Then

            $DevActive = $aNetsList[$i][0]
            $NetActive = $aNetsList[$i][1]
            $IPAddress = $aNetsList[$i][2]
            $NetSpeed = $aNetsList[$i][19]
            ExitLoop

        EndIf

    Next

    Gollog("Detected Active Network:")
    Gollog($DevActive)
    Gollog($NetActive)
    Gollog($IPAddress)
    Gollog($NetSpeed)


EndFunc   ;==>ReadNetList

Func netlist()
    _ArrayDisplay($aNetsList)

EndFunc   ;==>netlist

Func NetSetCategory($netname)  ;requires admin

    Local $NetCAT = InputBox("Please enter Network Category for: " & $netname[0][0], "0 Public, 1 Private, 2 Domain", 1)


    Gollog("Setting network type " & $NetCAT & " for network " & $netname[0][0])
    _NetSetCategory($netname[0][0], $NetCAT) ; Sets the Private category to the network connection called "LAN"

EndFunc   ;==>NetSetCategory

;_RenamePC($newPCname)

; perla pearl -> launch elevated powershell script from a non elevated (non admin) AutoIT script.
#cs
Func _Set_Network_Private($NetworkName) ; OK working
    ShellExecuteWait("powershell.exe", "start-process -verb runas 'powershell.exe' "& _
    "-argumentlist '-executionpolicy unrestricted -File  C:\temp\ps.ps1'", "", "", @SW_show)
EndFunc
#ce

#cs
Func _Set_Network_Private($NetworkName) ;
    ShellExecuteWait("powershell.exe", "start-process -verb runas 'powershell.exe' " & _
            "-argumentlist '-executionpolicy unrestricted -command 'Get-NetConnectionProfile -InterfaceAlias Ethernet ; Set-NetConnectionProfile -NetworkCategory Private -Confirm:$false -PassThru''", "", "", @SW_SHOW)
EndFunc   ;==>_Set_Network_Private

-ArgumentList @("/s", "/v", 'INSTALLDIR="D:\Software\App"', "AllUser=1", 'RebootYeNo="No"', 'AddLocal="Runtime"', "REBOOT=ReallySuppress", "/qn", '/l*v "C:\Temp\Log.txt"')

#ce
Func _Set_Network_Private($NetworkName, $nType) ; pearl perla
    ShellExecuteWait("powershell.exe", "start-process -verb runas 'powershell.exe' " & _
            "-argumentlist @('-executionpolicy unrestricted',' -command Get-NetConnectionProfile -InterfaceAlias " & $NetworkName & " | Set-NetConnectionProfile -NetworkCategory " & $nType & " -Confirm:$false -PassThru')", '', '', @SW_SHOW)
EndFunc   ;==>_Set_Network_Private

;example line working from admin CMD
;powershell.exe -executionpolicy unrestricted -command 'Get-NetConnectionProfile -InterfaceAlias "Ethernet" | Set-NetConnectionProfile -NetworkCategory Private -Confirm:$false -PassThru'


Func _Set_Network_Discovery($NetGroup, $Profile, $Enable) ; NOT used
    Gollog("SET : " & $NetGroup & " - " & $Profile & " - " & $Enable)
    $NetGroup = '"' & $NetGroup & '"'
    Local $StartProcess = "start-process -verb runas 'powershell.exe' " & _
            "-argumentlist @('-executionpolicy unrestricted',' -command Set-NetFirewallRule -DisplayGroup " & $NetGroup & " -Profile " & $Profile & " -Enabled " & $Enable & "')"
    ;"-argumentlist @('-executionpolicy unrestricted',' -command Get-NetFirewallRule -DisplayGroup " & $NetGroup & "|Set-NetFirewallRule -Profile " & $Profile & " -Enabled " & $Enable & "|Out-File -FilePath C:\temp\out.txt')"
    ;"-argumentlist -executionpolicy unrestricted,-command Get-NetFirewallRule -DisplayGroup '" & $NetGroup & "'|Set-NetFirewallRule -Profile " & $Profile & " -Enabled " & $Enable ;& "


    Gollog($StartProcess)

    ShellExecuteWait("powershell.exe", $StartProcess, '', '', @SW_SHOW)
EndFunc   ;==>_Set_Network_Discovery


;EXAMPLE
Func _RenamePC($Name)
    ShellExecuteWait("C:\Windows\system32\WindowsPowerShell\v1.0\powershell.exe", "start-process -verb runas 'C:\windows\system32\WindowsPowerShell\v1.0\powershell.exe' " & _
            "-argumentlist '$compcname = get-wmiobject win32_computersystem; foreach($comp in $compcname){$oreturn = " & _
            "$comp.rename(''" & $Name & "'')}" & _
            "'", "", "", @SW_SHOW)
EndFunc   ;==>_RenamePC

Func ExecuteElevatedPS1($PS1) ; $PS1 -> complete path to PS1 file
    ShellExecuteWait("powershell.exe", "start-process -verb runas 'powershell.exe' " & _
            "-argumentlist '-executionpolicy unrestricted -File  " & $PS1 & "'", "", "", @SW_SHOW)
EndFunc   ;==>ExecuteElevatedPS1

Func TogglePassProtSharing($action)
    Local $wintitle = "Impostazioni di condivisione avanzate"
    If WinActivate($wintitle) <> 0 Then

        For $i = 1 To 8
            Send("{TAB}")
            Sleep(200)
        Next

        Send("{SPACE}")

        For $i = 1 To 4
            Send("{TAB}")
            Sleep(200)
        Next

        If $action = 0 Then
            Send("{DOWN}")
        Else
            Send("{UP}")
        EndIf

        Sleep(300)
        Send("{TAB}")
        Sleep(400)
        Send("{ENTER}")

    Else
        MsgBox(48, "NetUtils", "error activating: " & $wintitle)
    EndIf

EndFunc   ;==>TogglePassProtSharing

;;;
;----
#Region Get network connected



Func GetNetworks_COM()
    Local $aNetworks = GetNetWorks()

    If @extended Then
        For $i = 0 To @extended - 1
            ConsoleWrite("NetWork Name: " & $aNetworks[$i][$eName] & "| IsConnectedToInternet: " & $aNetworks[$i][$eIsConnectedtoInternet] & @CRLF)
        Next

    EndIf
    Return $aNetworks
EndFunc   ;==>GetNetworks_COM

Func displayActNET($aNetworks)
    _ArrayDisplay($aNetworks, "NetWork Name|NetWork Is Connected to Internet")
EndFunc   ;==>displayActNET

;~ Success: Return an 2DArray[][]  and sets @extended Ubound of Array
;~ Failure: Return 0 and set @extended 0
Func GetNetWorks($NLM_ENUM_NETWORK = $NLM_ENUM_NETWORK_CONNECTED)
    Local $aNetworks[0][2] ;[n][0]NetWorks Name|[n][1]isConnectedtoInternet
    Local $INetworks = 0
    Local $ReDim = 0
    Local $oErrorHandler = ObjEvent("AutoIt.Error", "_ErrFunc")
    Local $oINetworkListManager = ObjCreate("{DCB00C01-570F-4A9B-8D69-199FDBA5723B}") ;Create INetworkListManager Object by CLSID

    If Not IsObj($oINetworkListManager) Then Return 0

    $INetworks = $oINetworkListManager.GetNetworks($NLM_ENUM_NETWORK)

    If Not IsObj($INetworks) Then Return 0

    For $INetwork In $INetworks
        $ReDim = UBound($aNetworks, 1) + 1
        ReDim $aNetworks[$ReDim][2]
        $aNetworks[$ReDim - 1][0] = $INetwork.GetName
        $aNetworks[$ReDim - 1][1] = $INetwork.isConnectedtoInternet

    Next
    $oINetworkListManager = 0 ;Free
    Return SetExtended($ReDim, $aNetworks)

EndFunc   ;==>GetNetWorks


; User's COM error function. Will be called if COM error occurs
Func _ErrFunc($oError)
    ; Do anything here.
    ConsoleWrite(@ScriptName & " (" & $oError.scriptline & ") : ==> COM Error intercepted !" & @CRLF & _
            @TAB & "err.number is: " & @TAB & @TAB & "0x" & Hex($oError.number) & @CRLF & _
            @TAB & "err.windescription:" & @TAB & $oError.windescription & @CRLF & _
            @TAB & "err.description is: " & @TAB & $oError.description & @CRLF & _
            @TAB & "err.source is: " & @TAB & @TAB & $oError.source & @CRLF & _
            @TAB & "err.helpfile is: " & @TAB & $oError.helpfile & @CRLF & _
            @TAB & "err.helpcontext is: " & @TAB & $oError.helpcontext & @CRLF & _
            @TAB & "err.lastdllerror is: " & @TAB & $oError.lastdllerror & @CRLF & _
            @TAB & "err.scriptline is: " & @TAB & $oError.scriptline & @CRLF & _
            @TAB & "err.retcode is: " & @TAB & "0x" & Hex($oError.retcode) & @CRLF & @CRLF)
EndFunc   ;==>_ErrFunc

#EndRegion Get network connected

#Region SETnetCategory
;#RequireAdmin ; Needed

;_NetSetCategory("LAN", 1) ; Sets the Private category to the network connection called "LAN"


; #FUNCTION# ====================================================================================================================
; Name...........: _NetSetCategory
; Description....: Sets the category of a network. Changes made take effect immediately
; Syntax.........: _NetSetCategory($sNetworkId, $iNetCategory)
; Parameters.....: $sNetworkId     - Name of the network connection
;                  $iNetCategory   - New category of the network. Can be one of :
;                   0 : Public
;                   1 : Private
;                   2 : Domain
; Return values..: Success  - 1
;                  Failure  - 0 and sets the @error flag to non-zero
; Remarks........: The function requires administrator privileges
; ===============================================================================================================================
Func _NetSetCategory($sNetworkId, $iNetCategory)
    Local $iRet = 1, $iNetFound = 0, $oNetwork, $oNetConnection
    If Not IsAdmin() Then Return SetError(4, 0, 0)
    If Not IsInt($iNetCategory) Or $iNetCategory < 0 Or $iNetCategory > 2 Then Return SetError(5, 0, 0)
    Local $INetListManager = ObjCreate("{DCB00C01-570F-4A9B-8D69-199FDBA5723B}")
    If Not IsObj($INetListManager) Then Return SetError($iRet, 0, 0)
    Local $oNetConnections = $INetListManager.GetNetworkConnections()
    If IsObj($oNetConnections) Then
        For $oNetConnection In $oNetConnections
            $oNetwork = $oNetConnection.GetNetwork
            If $oNetwork.GetName = $sNetworkId Then
                $iNetFound = 1
                Execute("$oNetwork.SetCategory($iNetCategory)")
                $iRet = (@error ? 2 : 0)
            EndIf
        Next
        If Not $iNetFound Then $iRet = 3
    EndIf
    $INetListManager = 0
    If $iRet Then Return SetError($iRet, 0, 0)
    Return 1
EndFunc   ;==>_NetSetCategory
#EndRegion SETnetCategory


;_________________________________________________________
#Region Base64

;Code below was generated by: 'File to Base64 String' Code Generator v1.20 Build 2020-06-05


Func _CondivisioneFileEStampantiPRIVATETRUE($bSaveBinary = False, $sSavePath = @ScriptDir)
    Local $Base64String
    $Base64String &= 'U2V0LU5ldEZpcmV3YWxsUnVsZSAtRGlzcGxheUdyb3VwICJDb25kaXZpc2lvbmUgRmlsZSBlIFN0YW1wYW50aSIgLUVuYWJsZWQgVHJ1ZSAtUHJvZmlsZSBQcml2YXRl'
    Local $bString = _WinAPI_Base64Decode($Base64String)
    If @error Then Return SetError(1, 0, 0)
    $bString = Binary($bString)
    If $bSaveBinary Then
        Local Const $hFile = FileOpen($sSavePath & "\CondivisioneFileEStampantiPRIVATETRUE.ps1", 18)
        If @error Then Return SetError(2, 0, $bString)
        FileWrite($hFile, $bString)
        FileClose($hFile)
    EndIf
    Return $bString
EndFunc   ;==>_CondivisioneFileEStampantiPRIVATETRUE

Func _CondivisioneFileEStampantiPRIVATEFALSE($bSaveBinary = False, $sSavePath = @ScriptDir)
    Local $Base64String
    $Base64String &= 'U2V0LU5ldEZpcmV3YWxsUnVsZSAtRGlzcGxheUdyb3VwICJDb25kaXZpc2lvbmUgRmlsZSBlIFN0YW1wYW50aSIgLUVuYWJsZWQgRmFsc2UgLVByb2ZpbGUgUHJpdmF0ZQ=='
    Local $bString = _WinAPI_Base64Decode($Base64String)
    If @error Then Return SetError(1, 0, 0)
    $bString = Binary($bString)
    If $bSaveBinary Then
        Local Const $hFile = FileOpen($sSavePath & "\CondivisioneFileEStampantiPRIVATEFALSE.ps1", 18)
        If @error Then Return SetError(2, 0, $bString)
        FileWrite($hFile, $bString)
        FileClose($hFile)
    EndIf
    Return $bString

EndFunc   ;==>_CondivisioneFileEStampantiPRIVATEFALSE

Func _IndividuazioneRetePRIVATETRUE($bSaveBinary = False, $sSavePath = @ScriptDir)
    Local $Base64String
    $Base64String &= 'R2V0LU5ldEZpcmV3YWxsUnVsZSAtRGlzcGxheUdyb3VwICdJbmRpdmlkdWF6aW9uZSBSZXRlJ3xTZXQtTmV0RmlyZXdhbGxSdWxlIC1Qcm9maWxlIFByaXZhdGUgLUVuYWJsZWQgdHJ1ZQ=='
    Local $bString = _WinAPI_Base64Decode($Base64String)
    If @error Then Return SetError(1, 0, 0)
    $bString = Binary($bString)
    If $bSaveBinary Then
        Local Const $hFile = FileOpen($sSavePath & "\IndividuazioneRetePRIVATETRUE.ps1", 18)
        If @error Then Return SetError(2, 0, $bString)
        FileWrite($hFile, $bString)
        FileClose($hFile)
    EndIf
    Return $bString
EndFunc   ;==>_IndividuazioneRetePRIVATETRUE

Func _IndividuazioneRetePRIVATEFALSE($bSaveBinary = False, $sSavePath = @ScriptDir)
    Local $Base64String
    $Base64String &= 'R2V0LU5ldEZpcmV3YWxsUnVsZSAtRGlzcGxheUdyb3VwICdJbmRpdmlkdWF6aW9uZSBSZXRlJ3xTZXQtTmV0RmlyZXdhbGxSdWxlIC1Qcm9maWxlIFByaXZhdGUgLUVuYWJsZWQgZmFsc2U='
    Local $bString = _WinAPI_Base64Decode($Base64String)
    If @error Then Return SetError(1, 0, 0)
    $bString = Binary($bString)
    If $bSaveBinary Then
        Local Const $hFile = FileOpen($sSavePath & "\IndividuazioneRetePRIVATEFALSE.ps1", 18)
        If @error Then Return SetError(2, 0, $bString)
        FileWrite($hFile, $bString)
        FileClose($hFile)
    EndIf
    Return $bString
EndFunc   ;==>_IndividuazioneRetePRIVATEFALSE


Func _NirSoft_NetworkInterfacesView($bSaveBinary = False, $sSavePath = @ScriptDir)
    Local $Base64String
    $Base64String &= 'Ab8ATVqQAAMAAACCBAAw//8AALgAOC0BAEAEOBkA6AAMDh8Aug4AtAnNIbgAAUzNIVRoaXMAIHByb2dyYW0AIGNhbm5vdCAAYmUgcnVuIGkAbiBET1MgbW+AZGUuDQ0KJASGAJoT3rvecrDoQQUDHX3v6NwCB+0E6MwAByRR8OjaQQAHBFGs6NUCI7GI6MNzARep6N0ADyD5tMLoxQIHzOgK3wIHyAIHUmljaAMBTwWrUEUAAEwBQAMAxoPKXgUT4AAAAwELAQgAAAaQARCAATABAFDOtgEAfoAB0IABgYIQAAPOAoOPAQCFAwAgAAqADfgLewEBDwAAAAaBFYYDgwYDAgC4EAIAGAEUBYAruAmu2AAAaCHDILY0AFVQWDACBIBttwZIBmIDAICAQsAJMQIDH8FCwT/BAcwJgC3gLnKYc3JjAlTDMgBEwAH6lM4JwH8uPwA/AD8APwAhNgAzLjk1wX8hDQAJAgmnZQVKSQDpi2KirgEATgKOQAdsAQAmAQAAel/+//9Vi+wAUVYz9maJM4oAB+spNEJmD7YAwLnyACvOZjMA///b/8EPt8AAiUX8agGNBFAAU+gBALMsg8QADEaKBD6EwHUAtn9799NeycMAPYPsXFcgagoAaPjTQAAnpH0A+87sJSOXClAA/xVw0BSLPawA0e/+7b8FagAAUGowaOwDWf8AdhCJhjwECNcAZoM90r3b7dAAIEEJdBQe/7YAEyPu3/6xbR0AX2BRUYtFCC0AEFYAU1ZXtpsArfuL8Q+ExQoASAZ/g+gnCBgA3szNbS3IshoAiwAbhSwCbDMA21Y1EHm4xNgAd9ubuz3B6HoAXfjSXP91/AcADH67ubVTFCUAHZz/0zsOdRkAjYY+3f6d6zsAUBbIKAJZWTMAwEDpCQMEbpkA2Yaqb8+kR70AbXvbi/gE+AwAQsd7sB5QmCAA+yrruoIdCnQArmGzN9hqZ0AAkBcGjEVyyc4AhgEdSPtms80AKeu0'
    $Base64String &= 'fnsmOZEAa7atcHUmrigADGN0aBc72zcAdsAADWxxD2kAlPCbG8gL3gAAQl3L3Tf3mwAAt4tNDIvB0CoA+QF0CgUC+LAA3WwZsWaFwAgAqJG3wW4R3nYASlWw3uDLeNAAbGefS1B1LKYAamXtYMcWhhEAmPnTanqFZO8ALg7rE2gzEykAf49nf98U1EAADcTRbxONRkAAEoIw7FBo6jkA1gjDk4XC3eUAOiZd5KNtN34AX15bycIMUGYAEIYsO4/+5sMAvVDHBlRW9XYAi8bDULlYFLwA/4PdescAFjEA7cP/dCQIi0AAEAbXXp40q7gAJNLCCABTT/0Ax499agxoSPEALbYcgX0MxXUAHot1CPdv3C0AcskTPJZZIhQAiXAQVlC+WvYAg22/VFf/HbgADDIoi/CJDssAQvv/M/8793QAeol+CIl95AIA5wYU5Rs3bAIAELaLzv9NReQAg01/t5Xb6y0ASgj/Bew5kPQAWcOLZeiGoXUAC2CUSQJC8kMAh7n2ytApToAAjAzbbXnGagMA6zv2OWJ0DQ4ADNduZ4RXS7QAXOsCyb+74V0A4VXCGugEo8gAH39fE0ANTJMAbvcQUBo53fUAZLDXuUIyvwwAkg1wqgW3LFsAJAIgHBi8wnQAs8UOr8FmqF0AwiCHPOyD3bcAXgRWXBhTaC0AwtYw3h/LNLIAjsINsVewlWoABVcXX9gG850AmLTMy8IEq64A9Lu3TkEEUSsABCpI99gbyRYAb7mXa8ylV5sAPk50Jwa3fccALcKodBlIdAQAGuumQcJvjgsAVxFQ1nhSEOsAEos6bzvS+1AAFOsLGDdQGK0ADOepu20bvn0ASVazdScJDAAAusILbwkGayEA6weh9VB2v4wA5n1J/usIZoEAMAN159627B4Ai84cbl5JQS8ADhjBTAEXlV4Aw/gPMTaKBN0AZ7N8i0QkDI0AVi5Qpj0EAssAXYDjN+QQaDgAgnUaTo3uRqkAA5YpiAgi'
    $Base64String &= 'UVYA/wM5kGRk4IUA9nReg2XkcEMAGLcAA/wAUygANfZYu8pQi0sA+QtWuW7gkn0AHO04ElNGyQYADLME9EgMA+0AT5i9sasfWVEAU4vYi/jT//0Ag4V8dCCLix8Ahcl0KY2DRMUAngXD0lGCLLMAVtwTTdLjma8AF2+sBoe2wNMAFItRiuIkVzAAuLu1DKPndQUAIgb1W7o3TNcAexCDu1vjl4AAjbO/3dy7YA4AjX3wpQDC+IsACSvHg/gU27cA79t+eQz8K0UA9ApuR/gFfmgABfQN/2P99nwAYos15Lj/1oMAxxQ7+H1RF9YAeH/bCn8owQ0AyH1Di7NMus0AZmdbaDlocKkAv13vj69YHAoAfQeDows9sxIAY80JC9SJPF8AZrRSYWsvOdUARQRNE/4t34AAInUBQVFbHiwAucanMwYw6w8ANiXnMlKrH/4AYQg80rhNtocAEFlWsNA4aBIATbTNHY4gu30AHOp0hnzf/wUAg8gE6wUl+/8AAA5QIxFKCx0AMat/BJtc9hsAL707tIOmDLIAlHwkFJEoJRMAuzdIiZ4wBokAvn5Rl7eXlkEAN2ADdCsEDHQALT108LfC7hgALcMwdUidQ88AwekQV1FW3roA7ZdxNxBXCAgA6y4G0nvx8xAA6ycM6yAT6+wAcv8aLRP4LhQAx4ZAE/OHtuEAu3u+gT0Ii4YAEPXQXG7rDUUANSXjc5OPZ+AABYDrZLDGaH0AnvAEuABzj4wAbsPbl7elAOAA//Ro/h+hhQIAC/WaYRhLQhAAHJYz/o6yaKAABP8PAGkyIJ4Awc8NwgwkLmgAaBUsY6XTuzcAtlmjCBR0EWgAgLkotQ72msgAoyctdBW3I7wAIZ1WUBwX6IEA+WzH4uw0AuoAM9uPAc79aeYALnRTUKGdzAgAlcvYH+yj/00AvRIif4vHalwAlEf69suIGDsAw3QDLxi+yCMAja4D9C7s3KEA5AkVEmq+jY0ANMpbbLpi/9AA'
    $Base64String &= 'XesDjPyDfd8AcG2WAcRqBnQA/tDzq8cLkWcA7kXMHBA9ACQACk1Ba/G2zDcAU69tPtuute4AGBVyBSwnClAAOOzEC3S4qwAAf12YEg+VtjUAt7ZUiRFI9AEAQGzwiti7fXIA/BFqFE7oUVIATYOdnB0kJPgADB5X0VaBZB8ApJUI2cnZs1cAxPgr6A9G94kAQrIcEdPDVwkAndy6AY6NTwQACuTUBKU7uZwAEQwA1QgjAckANiGXCCDVEBEAOO1Ctm8jFDUAVBgjD2S7kHgAHEegg8d0GBwA8iBXaMxffvgA78IdLIwbbQUAxAcggcEF25MAhVrbH9AMVh8ADLL9Is91EKQABeveFA0nyzMAcqysyQ60crIAPCO0tA+8gxIAyzO8nwuF4aMAW2/3gKAPi4kABal2BeZ83i4AsetNIetJIAoAdT+Q0GTskvkAgNTtsdAt1DUAb2d/fBV/BDsA8jMRDn8LfHMAxmg9dDz/pF4AQZxdraVTLw0Avl4mJeAGCmwAF8ZOWfmrqmAA695YVAhngccAlEuNE1dfomQARrSUN4yhFBwAQYmX/wKtQBQAg/gCai1ZajoAWU6hbyVaDDQAWMlWUVeMzNQAKrIyjRvFLbYAubt4g3gcxoMAuZBPugNocJ8ALNvDERgJBXUA7qax3cZGcA0ALewqeRAeDbQAhGm6WfRRmswA3Is2R9s2xQQAiRGJj92V9P0A4DXsaCdHolkAZirk+PrWlm4ArFUIlotqT4MA+hNXdvQdX18ABg+HNtr/JJUAhB5vgZC5pNsA4PS3DnYKBAUAcslJLgYQBQYAN8yDXAc5gdwA7GoK5LDdC1EAaglbjTh3RAIA/RKOPUEQB4sAgZuL0AvR2OsAzSzJoNtomNYArJR4loYwa+oA6IEKH23zUE0Ad4Lrc1VbVmwAY7R3EAzj62UADVTwB7T2LM8A8ui84MTYSe8AbjfGkFBM5IsA2VwNoVE6DJcA2Pxa6yqNudgAOQe0'
    $Base64String &= 'u5UaZmMAL8S3ZDdoqIoAA2OPS4YHNxQAwZ2L5SSmaboA7ZBJHR1UA18AanWapmmagJYAi6+6wjTNsmkA6QUeExsj2zQATdMrM0ZOuOAAhMHunZSbxgUAc0ki94Yps64A2OAbx0ZMnMAAmSM7BihAHAgAiA0rtOTdk8AA9gfhLm30q44AN1kWWUAefeQAFpgGn/xdrNkAXsLBb4o5ezQAiVz+Agx+HMMA3NAPZovzp0UA4f8gq+0/dHgABq87QzR85I0ACBhQTde5WwQAJCBqLhwDKCAA324Gdi6RzTEACiSJHhAPjrcA7u/aA9dMLRgAEWFmObiABDAAJ7jXcEaxDBwAwI277utubDgAZkAsBC4DMF0AKLSpe/wMZ1EAtGg/dDBeD3wAojEkFwO5io0A3egMbytE86UA92Uo1MtmcJcAOto4MgGvTIAAdROxbne3FZcA0ig1U8CL2+sAFDvarcVuK3gAEDw4LkAGCOAAYHeuQ61AO0QAtoxJAXmI0FIADQkjeKtUaLQABcYCSAQBE3cAh3AUEN3wGHQACq796Bm/n8oAWQ3DuOvDU60AF89oH/Nbw3EAhD1VapmQBcsAogtc1u9qCaMAD5TBQYvBAyAAfKkfTFS39kAAJIkLg2AwbDsAzi/XQDTg4OAAolT4Uw7+JZoAhsXwXTleNFcAfllTwg1exaUAySeNR/Pb6ZsACMFZdEaNh8YAujhzYAZoWuEAGyqA20NIAA4AQztZfKf/dgMA91Kfhuv2F3wADjtBDH0JiIAAuetpwNClAwEAwxu5nRvvR2gAXNdAhEX4BvwA/z0bFJqcX8YAqPAsugYdPCgAXiJWR2Cr1cAAJQm7jUdopysA1eskE9SCX5cA2V4kw+sJDSwA74V8deteXIgAF0yQ17YEUBwAjFyJcwDSEiAA/7UWmBos6KQABXRyhC7cRdQA7ysQFdmCVHsAJiWjFyyMgs0A3OgYPUYNbOEAXDkwWFnHE20ApbaTgQ1U'
    $Base64String &= '9AUAVwHb1NiLanMAMCDRTeAYaGwAv20UBegeTeQAeewFdSsXRzwAmlkhivQAZGQAi2yS+JHgYdoAmJstSLG36FsACQ4058JFArwATQHksIJCOWAAme1rtChaE4YA2P8/gAzIXHnBhnTc//+TjY6M7V5Nx0UYWRzYUGYDbAuQTVhMbZvNxdk2XkX0jWdR3GyBsqXcjkw0uUawR8SuAkCuuqXWhfxQia2QEF1LlJp7EGqJSBARfDqF8KMgdMtoH4gd++CA5XioWR0AEpAfzV5EGuNoQOVG7kZnav99TaDfN5gbbXrAVpi/QbgCIKnNLG+Yah9exOGsP5lgCcPJpgxgF2RbyCx+UxbUExlKlyMvhbpIbvsLsweyzE28/wPkLvZvu7nYQ819sI6/81eJdawCPTaa1dR4PNZp7htftxpXCVNQvOpHO8dZZfeeKfd+a74AL42jB6LXAWeN97NQiscy2ZBu9heaVr0SDCQ22fayERb8qCwmCBQywK1dDG2+fJpWQnfpYHw0RmgEd1M24/ffejP2CEY7/n4hagJWMxIb0krftjHnRklWsdfklZma3iD3fN9iw8BCk1zZpbTrHD0BTrybatt54TpZO+P2VlY5wHSDPdEcPPh8KYd1k00bQREPFBQWC9LymcmE11mMy8NURmoKvNgahLLkeBrUHdh/4PR7xscInxhoDBKMTfB1vQnDOF/FEpPerTbsH5KnYn4YlAoYGtYTk6Jo18bB9IODTS8Qh1im1wq9JCgR9Nc6XtuL8QcECwKJMC0hY3w6ys8yVGe0boMBLengBiHvBFlvYyHh8A+RNRGET8HoDEgITUVY7+o11OQphEDB4Azgm2zNVjJO3CV/+0IOdItIFPxaI8p0BYRyz3aDULYJOwgJBMZnBIbg3ToM2MgDP5AMEoV15BH44uG9WJkDzqwG4R0+nVDiA+EUfa+Rs+woFJCj7DBAHniEGHO0HdIsPezwxwYig25gDb1fK5MXVugMW60F'
    $Base64String &= 'TvEGswj8bLNIVpuY50s8Nx4HHpxDpeZuVoT54BTWSAi3i83R9hRerTBQNKsAd8bSi2/aGMtUKlGKZzoxaNK9bt2DWiNjOSgLENJxrL2H3FglZhLTOUxDrnPTCRhUCL5vwqXrETQNDJ4A7QPRb9egV+EmdQZp62Zv0Xa79MHqL7bMAtK8A8oD/xe6wMiJNiDbbCDcDcjwQADZwN+//BowSigX2mTZ7tjZ3/rcb/Xg9sRBVtng3B3AJA4BQ1s0llIBnFUFZoZw9rtKi8jB4QgLBFGbLYbF68Zg08z9NE1nljRiERAQOHTBtrNCLiT1BlyJYHHIXen+oGDQwl7pxsZgSfT/AR3AoXZ/YZb/PeYVdyGGB9n1hHP8WRZ4i0ZIN2qKQPL8CDyIxhfkrHAQulp3TlO0cHWLR0DkWlXJswtw9H5IelBTShIz4/Y38i6LR/gXjTSIUV4CnUIbehHXxCEGfLd4d4GVPgAKxwZkAOdd9BA5C9p8uM22QI/CwgrdeuRzIgfNWOkJUPo6F2Nb1SYNNpMMGRwZakfDC4PwaMxaYIiuFA+4dZRCu8T7pGSdC4sYrGNTG+3Ezq0pF9ZPt/+37XX0Aux49MHnAg+/RDsCO0UZhZ2X5YQwQcZWtcSGgoMgsAwPyxLvqQgHjRas0MTQIZelUTP0xARQrZuks5HUOEqW9FG3x46dxKJqBZ3nA/t6DzMkt4u30pkPn8IKUlAbxxbGbh0kOQB1EXJEXez9Ylc3sEQIHQf/W+iDtbPRLtAUOQkxPLh6t8yyC/AqcFhQYJkl574I9aYKNRQDGbQXqqE+FqzMBAYr6sYnVQyaUf5SZT7V01RCwildhUht0P9fi10MwesQOUZIdRhmgfu5EQG2xgbBDKAdKtzbZ7YfGXVmhdsNHBnwITOUaBsfjVhlyRdBl5bHKA2bjQSISFd+RE+8/W/5fBcMQYPCFDvLETh84RAaf4xRv0E6+wMCuzp1Dmr77CLUAVPwIBu2+gMV'
    $Base64String &= 'N1uOpADrCxMS8jyQZxT47BU77vM1HtgQURV3zhfvGw4KyQDJsrCiUxU2dQeCToi173befov+8s1JFJA+bj7BKANoxSztyAmjZuas112+hIFM80Akg38I/bctxc/mETlfBP53Ajd9b3x3ZRd2G5t10BbL7RSoAv8l/oO7w3QG9kcYawmLTxgzyIXLi8Qw93RNaAIVNospAQ4tfHQ3I8N1PUAa7U71a4mdxlElIwM6Hb0LsIKBmQAgHYvvl7ZYcxcfGVsUNIRZaObmHHBlCYVPLZJugQUeX3WVKuvboK3DzUFIikdd0IZsmx3BYOyuhb60LWFOHgkEBIFTUNOz1XoIEEeJaoLgrDZR6F5IhdodYvlvRYkWYyd9iUdE0dDtT5KsO8NZ6YkYPAKRam2714l3SwYR9I2jWy6Wph46OkYIMv+2RRtZgl1aDQT34g+QwfcC25iB2Z5CWYIEralN2toCWykG5kY57tfb73Y2RXXSRHU+RXAEQLZ7yNoUWsM/O/NZjX4T/3dB04VrRMeleDHAFE4ZqCzAde+ZAXmLRzlqg9RUrQK5Z+4ZY2BE2lsekyXTxHBmyLAM02yhtTnkyK9Eyr3ARQulhcN/sdfUDwTgo5AUQdE1BvCGA7MRWSmNj8z3sGHY0JX2xfmDVxYRm+4NdQ4Xj2gQ2EArIDvGWwe2EsgYGTnI/KuAi9pRvp/R47q9OnBkOHYl7dvjUc69KVlzDQzMVXcPaopfDBX8Cg/o0dWBZRnevVDurIau5wJoAYBr+CwC8ixnGAIBQAhwuvi2aoP8T8+xeNEDT6/w0Fb60g5iF1p+FWB8Rv5cgPJ1FyNoKM1WeTityRMVcKUQqEs0gd75hT7eP/iWCLYrGh+bC04s0StL5D+v8P7NJsEgpRgIGhYQCV4PDGAwAw4IbgmroJ3w1S/wKfCHfAXg769/JI08NoveNiNWTdxeVrAT/+NGRgn4Qw9qxX7k/3FNoeSIbOv2V7gavAtH3GN0A2oI'
    $Base64String &= 'HcuoZIcLAwTxzsJ8BlwLDIWFRofQBNLWICQtVt0Bfn50cQEtRLXttdAqo8toIxBwWwWeENjEVlNS8DY4vJtyplDNLjwWdIfoiRnR7rskd7NtgK/4HN1qDWgg4EXpAorExWwBi/y2SNEWJ1jjKRzO0gip8JrbogAPfANpfQAWQC3c9wxXFaBjdQRvfNv2x14tizA71i5Tix/aLvHWLgE4CDvR+Q+vDAzXupdHxNyF9gd+G50QFUJGdLFWVg1EP1Nrvs21IUMHW9xMMwPJ9m1hIcYgGUEGPEggdOXczgLlBEjHBM0M0Wy3W9cHGkYiBUhUf/QLZDBbJCgneM3kuJGBjo//DTjD63Zou5Uhj2Y7iwQj8lvtiKUUQCN16bcED6enkQEI8+wj7iNKs8akZAUNYwNsQOvefHn2w+9GIFpcMKsVCiMYB8um2Dqx9xzS2op1LP8v214EAggMiF4WxkYXAYheGBnfDP2yGhvHRhC8jAkUiEYVGuBq7IPGHD98T7ALu23XpKOD+mgGBS91a0GYFHz7AkFBD7cThdJ1588WSME71Q5oJOPO4HZ9C649HBxBXL4YBng+fm/FVscFCBQBOEDGcEMrV1U3DBl4EAKgoVlzj3UQLDshtGpVPuru9SFtH7OblXZy4v1n1ISh4l9eWAB5nqYyov4B/jQ9yCWc5dz+cj0zh0QPaEgS5LYNBMm/ZsAQJFQPh3MQJJvr4PDGZtymHCZBepihDlOFzjIFJ90zNnhzf7sIHCQexN3YfRX4333iSYCNIPg6HIP/uwMT0G/o7yZY2zaVbqKUw5MIUdrmrnZjtTxcnRAHGN3H++2Zq9yVUCUkao1P/jvBK3FzZft+BosHTCo+BIZTYGqoV1fc6XEdiVbbiBQFoefcbL0XwI1CECsFyyvIV+bqe+04pmVd2nZhsm2lGzkPBBkrzwGkc+aJTB0pGIvsNZ4ODTJYLIDtt4lZk4roLgeKGgZcH7NqM8HnUjBoBU2YheDk'
    $Base64String &= '9BFtC7Vy/zpzasvwfqNVogV0WfY7+3UmU2i9frYUNDVQ0H3iqxHtjSNqClMeKn8C89yq8E9A0rzwjdBwqOrT7xwXyCFcwBYiK9AFuFQ7oOiPReRP04uyVaut430eMItqqin+K/gr8UdGfU181L99+zfh3CvDjUQ4/yDgmSvCQotF2CvHtfXvbhAw/w3R+QNN+NH4A/V5243aGtZcfYMrfR9dqc99g9TwR1dDU1t7TJKGzAkwBRg9tcTfCqvxdQQ5GHR8jOx3dAIdaLwxbXjswQdxNjrgdmW/ZFe07DAJE0tf7EazFYZ8zgXgGv0+h0Qws0DcLp5osGCTxHDYqzgvDlRKwsH1zIfhaMzzqWr24rKCB9gcwRAFaVCzgOv9gWh0VWn5aFoo0tIgs8iyCfzXLemEGwR8POwsMdeaBggMDb9GEdJrsYIMQTc7yaWkLVa6/MrDtTiwGyfm6KhKS9ICcQQGr9PIMsUCl0TQEOR+bipIsy1wV6IAfhfI5mq3eZn3CMocgMNnwQoaDkaB/npVBAe3FXyZT7ZjKQcv0exMQO35A0BQB812xAAD2OCnzGPjJDLGI/AzuEUDbkBXAbQVtEwiEvAqf4lNwIl90EAEm0RD8AYICLvSG0+ECy+EWcyJA4DQV4EskhDbaFlkHrUXmlAlRGg43zVic28JHR90lhjUb8CFnDl1LjB2cFNXo4mbo1daDXZYQWbqCRtiZOjqe2arMyi1Q8sDiASMObzqcE8tagYMFvy/E28lTAdd48QcPeexwW2jBYNHBkMiAyA6cG9oDHKucNx4WHAAbiNfQFvLT9qmITRXrDp1AhVqp0oZB+vCnWjf4CZM/H5AQwRfZj1UsDXRN1JD6ypmyDtyZm13N8A17l8CCPJzGIjwaPES/ZMn8Vl8iAQO4O6hCr/hfMTN2QjCS9bjFRqjN2HEI2ZEeIuiFIx4iYKZjFgoNIFcAtR/wogdcUXQfnX0fQwjtloPS1N8UeSMKAt7PXFY'
    $Base64String &= '2CgCrddU2OAXW9tuq348CtQH0Cm4pqC5tgdToBhIISLEsOwQ/1Bl2d5aAhrUfNcK+PhkhLi12Mgf6FPwUynHstqiGx2RLD8ugBv+B/n691cXDPIWlb3493WPz60WNhE7kQRw+Ac2MrzVaygfYvxomNixaBYw1xiuCLbURZtEXlAT7twsNi979KNBfAcBW8BcwiUSIHI00a/VaG946yd1juOl7bSSe4cDZ61fi8MCMKRbDzxqYUXIqdKJSO2p+xwCE6P+qM3ExDzC0CTZ0JoVD7HgBTdknInDOXn+CPgEyZpNJOT4miAmvsrmJfEFmRjRLCh3JOKk6VYNjbUMjT0ViztaxhU4NpfZoAdAqCXo1nCvYCNPBb/HRTZHJ5AABwxsDdgwjc8GRgIMpGrAshAcYJe/0CU1rYtrjRQDiVW2G6rQ+EIyDotGFDdW07GN3hN+EHXQN0rrC8PNXXY0edwirVYcKCXWyiXbGFkiDAwzYLkBWrAjRhKLRhBSuMlCjVgOfoZbo6H+SDmNiw8RhDB194kcgf8KdhxfFvnqF7pBinwSRhx9DYtQ5KhRXBIMioCzvCPoHId1Vu83i/8/RxD8G6xEjeRAeQKNRwQFupmaH5OLP/eWa6nxA2YhN53LBq0sbYFCcMqqSmZig65WaAOrGMZ1GaFW7TZafCQVDbUrsJ0QFPDD1kALeLA1sC3JjRKCNj2pe1IvlG2LB8hwpRawkXt3CF60CQzQpDpWinFWdAhmx04i3rbxVk0uZczQTO2D+/9cgsEaJWtFstscA/Nt62wbZIR2G1BeOUgHcW2RIplvIA0kwUwvLIdVEbv045C1GgrfU0ZZZxgoAzD4XRvrDxh2O3MKfx+NLDZVA10CFGmLGNkEMLFFRzU7Eo30NpD7XVtZYO3r8r1Fi93CDqELW0dU0MJvoEYRfEo7+X1GdQvtWPe2zX722SvfI1Z3K8+FkaZb+yvLA8lRvGwERqx+6i0MmOJXkIlBCDtwwMUB'
    $Base64String &= 'fgyI0KuLWBSrXVYoVjEhl0dHEZbtc4OO7AFd8ALg1CC+LlrY/wES3L1fcOGT+hw5Hg+EDBPAAq1opHevAKm+3Y6uQjk1dT0E7A+Fr8lqm2Co11lmBzupmLFRKn54AsxvyVzfGA7vcLD763uhF7psRyIGg10B62zHK2jQr0pXdGII9qJUa2A53zZ9ExuXtFGAlAgMDpIEpZpRMNSUHuBYuhFUWX1lRzdhY9utBdUMsED8pzCTaHPdLZE0eM1H9n7s16gZHkP0Rd2aLCvsZmCFIiqDfifH2h3bDDvKxsnrAwyLfngQY1/2fjCNdS3/Ne2oS4agYDB9iS2wY98aJgBvOSZ+H4vPPDE9SUCMFe32DUc7IhLwuB584R71L5WDra5+1TgRiw5qvL3wi9GDOhNtQINZO8d8y8lGvNEG8B4Dx8cIUYiPWMYDQbQAPBjHwecDMDYxYheDWRxZB1NNCw1oFTP5LQdsjr96CAQHBFs0gwjXXbi0VKrB4FEUAX9UJP23BXxUCATr4/xxlvZXfhSLy7YFv5n6ix87XFAQmsfGGy5YwHzwtzmDAvoqW2xECREIRefammjUbtTv0jkVrbhEBdWKOTtU699k+3QPRoPBOvL7BPDr9lSllxkZDqZT60CLHWAUV/HnEGdwwYyGBEBsFOmiUDRoEALk7CTPIRnu7NPstobw1AQmViBCBYKtUYA4kz4g1dRwYb1tAFN9d7G1soJ1ndnG9fsGfHNwZImgnxBoXLM9PTaptzM3oR0D0OsFCbzA8BYnT7sSofhB8///AD6haNn28AWtJcU7FzZi0ilCq7m326DhMQqLXxi6MPtMNG002IZx/HBeJ1NNwCWSaHYYAGB0KVx5igmU1J8JDplqsjAR32A4bGypnjBI8LkPrFC8g9WNjdD24FGmNwqVGIQPhgqxiYc+BZQyaRI7dT1HNmRXRglXWmmIkkDNzEXN5LaWdPhDwQo5ChvmFq9oYXHE/Bdq7oVKpf/PWVCJ'
    $Base64String &= 'tbgQnhnKbAW8cgbM/hCVwuwTvcB6qzNP0LKAssw5h5jUBs/cPByNc/BWSCxQwsZyRklK3YWTrzk2EfwcAztGq7kmWzz+KHo/+9daZEYF3h8DPrnHYr8H7tiN86Wu88CFQVu4QnOEr/IlT1w1BLed+aBYBw/ChdAaUB0SES7fAPKEW1j5jmlzFAGZhAxcPgV2DNY1V0kDPWUh5gNgyvU5B3Ze/UyveAna6nsouz1njUscB3QzO6U3iBkFFNPJisNuBlD8BZQddru24RqBH2z/MTQ7Q/jXzugofMOOgRXUOwdyqLWA/RWXb2BoQMbztGXbBiMIZBi/EJujPwv28EMYOTD+yuIb6uBUUIj8qtD9Ok+IN410AQh30v2CLmelbd3GfdxeWwBGK+gt6VkFAGdsCy3JCAjeBbItSFAe5MALoIAh6h7gbuo7+rUPtNxnd2io7mpAhVuBSd98+EQ5J+gtocB+LlklKJQEovDt839WwICh9BNSji2CoXbqfNKb2lMafA838/xIBXOCIf7/TGLsgLuERWiI2W/Q7gxwCtIDu6Vls7DNGCQCjIClgqOGG5ocFqHHgKAgR/GWxszTtRiAnsrw6BBMRvAogRE4eW8HWQYMCiYvgxjDJhwDuWC7K56JSBgDiFlycnLyBgQGCApA/XVyDA6dPYgjNt1B2b2FlGcCuAByWqPm3mPwFW7HBYwgtgn3MijPkBCCo3AShcGhXqEha6DkmUi2HXh8kLlNjeQCl6N0G7p/iIahkjfViw2ADVZ/S5UOmckFFWE7HII2dVDodDJAQFr/ZoUrLQb87az3w7N0L1cUNn3jbXxnSdE1U0HLUet+9doGrxOAhoEIxVRmV2/QQevBWDgdVSvquj0k2n5IxAKzO4tEOFOaPWlUMJoZrxIv7AOs8S43821T6xPlV7SsUYJErt9/78xwOX52oYSATDACOw3sfU/2bLNl5g2MV6CNRDZ7Y1CwAkXyoSYeW+IVXj4LzuKCE4q5'
    $Base64String &= 'OgQZFVqNKLyO3QUWHrXCwYvfAaMTdQexfLOy4f7Lw6Ew9nB1wsEgnhWjuEwZiiWIRaAy0sGmKGSdKuGJXMsFDQ1zJ26/J751Q4BbE05TpA1IOOJH0SU81GoBM9mN0VHaMP0MCiw2rTsQnQdQz0xYXqXbQZiMLsAAEjltey1UwZ94PChec3dB7oQkVmbknCRcCWmgsWoXXlRqANYVHEXXvDMsayO9o9gaUwQMlYHGcRG93a2oHWcFNOSLNQXCg125E1gVUVAgUdfU5kYooDRANxObEaczLB1UHizwiBMkXPl1Cz3zEIh0G1MTMAnB4VmMOe5y/CcEDj4UD4zew9RXGIY5jFYChHM13hat35ElnN/drPAtLViSGTYrThASTwoMp732RQdhaBiCQaWUhTPEWNXwNAxN0UVj9OCapJUCP9RDfBdWHChJ6CtFLmBrAYwE4JZd87lSPx1DeF5WAtGjP1pxWCg/WR30nkvu4HETzB80IAbt3VYabCxXv4hLBSbp3gm2YFc3kg0BUWszNwRF8O0c5iVNRAT83zCJBnIJ1/7flRIKvOaQjSXylw70StFgEs2EPXeov6CfXdpGtKJvJAaiZJPkonzLXHQONlkIaQVeaPDWCvSEqD3FGXh2ZloKVns8FA822sAhCKmD+EMLaOVqh9BfM7N6cKyrghkPENqbpc4VyUWSLQZljlqjXl3+YBo6oSWsNGjq5EANWxY608C/PsKrGATaGsUMwLnoumiw53wOqyCvJh3oo9dH8ZFW0+Es1DtzWnFMjHC6NwhLGhAL2AyaGyZRQRWTcGS9dBYnDKyxspXDcnR0OcCeC79Xdb7hoIbsVnYKk1XnXl8VDp4mIVDQQiB8RslHFcO6RJdJPg8kyftKLVrJPCBwTOzVWqpp3veixGkO5Nb2RlZANNfpeqYQOfYg85qIM0gkSBZmt9bD6gRQ93Rm8w5AdNqqYb1JRNTsWdXdroGoMBoki0p0HTlOxmqo9aGH1hCh'
    $Base64String &= 'G9vG+gQF1Ew7Uc2xOFlDNF4zxI8o8Mmtj+I+6tz7kED/AwUZIaIiSzuBOASc3RH8CCG0UpKksKdW3h3S3SGAxjv+fmAyKLakOnRXiUg0AFKZYY9EBrskyBQtD2RXQMFBwdZ64YaMNQI+EAMIErVhAb4EsHU7lMGiDoFGWeOCgQmUhGMynAPgENxWFxNW1MEW3WfSQblDBUfEKPAP/ngN0CJB8Mt0FOvJ1RDcANSEre3BTb5LbFYBBHXuZAUGvqtqdX9ZU7+ZUB8EYGKwU3LWKuYaGbiuFFNlaNQXog6CGxVl+t9PCAhPufjfHFr4348VJiMMViN0FVP9R7JmGa64DFNo30+OGpt8mQwIdHZIFrhEoUBbLBDKhlxC5t+A2TAV5/yro3BUEIYdfg8Uiy/TDigp6HbOcvW5TJsNtSM1dHk2iqRYsSbSFevI10DzwA98V1BoFSMAmCa3VIBqDw+a7z9ocCnQo3xgoAhW4nQVgIUQBoZ8x0BooBPQthz5KBfORwz0/byX/PoIAm72/Y21Gu4Y1BSSIxVCJJAblvRZOLgsFPwo/AFvyUE+8vvw+1m1IId8G/39E0adgO4KIVDDX+yrc+zY6xo3nZK9EbbTNR2xkvwVFe8G+xMYUmB0ieDIcwlAu1NWvluHcXgdVhcGHJ1XwRqXbBCgDOdRQYsK2Gi8FWmv3Bj2eNASvljRGN0Ypce/nsA7pmoJBaxZDCKzdkqveg/0QcNMJZ3bNNBnAaxqLlYXiFJwQ4wEXWjY2rJLTk5InRTwLCQMDkMMoPAjDKmAXanq+r8Jakaai9mF23UDamRbahSGL6sllFhmx0YEwHZUA1apibOLDgBLvRefRIECBhlAEAS2C6Z87Vhb7whUyQSnpTdWS1WKWkTSZPU/Ifh+GIsGnQZHg/8CfWZCjHXtW9c70XzsHx1YI0qwBku9D79YvPuPHaJEt3rw6zZkCGaCVmr7hRP50Ad9ESBAugS5dwP0wVBS+SLrDRDT'
    $Base64String &= 'Ac+Gjg4gWOQSrU6DQAe+kvl8qF+XzCQVMtRU0jnv9H4IDb3WweAC6DYjOX4EfgtMVSIE5SQC1Da4jRy4y9wgyoxiIwq1Ipi6rQQHD2Zk/QMG+FCBrV1DAmw/fEzd9gJ4OFiBCGQPb6AWqK9QAziNQRjDA+DvEZ6DVrj0l2UB4IIR4UC/4AFgw0PmKHy+mNLuqtzv5B6G6AX+iX4gCQBbKawP3Im8hZGIPce6uw5F9/Yblol4DIk4BASJWAoIwoZFMAbGJiCD5Cg5DBC+uh22Xx8U9OUwU8hX1j7QCWQkRkAODZwH5l6G1LYQvsA7YBEv5BaLB3MfVwhr2982WJ4giV4wAkALPd3hjdplkffHBy4jRhW+EvTPi3cUUb8tS0quZJs1EhAMYgen5AjPXqtHl986HKaaHQYYBDR+E1cTL3xQqovHyP9S6FFHcDQS49j/MJ5wgSBDprCguxaY+rBQlI2oiLdRUZoRe9yBaC82HTIRoLcLuouAD5ZiEcFmFUC3oWbDgqIUKYSAVzGMpxCwEPCLQ6RWB6E43KUOi7cjaouPxeMlfg2LQUwJixPY7hoCGiqHy7r/dyDeiNci0JfnA2jgDA8BzxdQCJ8SDaGrRcJLLw5WJmSQLYIiBwwQ3VY4GRQHNUJAUEeS7UQb5db3CQyhJplkEBQIjDA3mPuJR2AoCmQpCrDqYG5oKgpsXhNs26zQGGgd9xcE0VqAJvlHZ0RroT28nVuJhyUzWlfTqmQbWB+Jn9ACqSDUcauWLRqIR0AdVeBGY5gQcQYwABy7xWv2WFCLMAPGL1l7k6rAFSkSIE20aA2YMOAgIKnBdwQNNf/dRDEQdSosvKgWdfGM1Nrsnf5d+IHLrhwXM4VbwNe2DVsGKIF+cFu227gTfXyA0QxEJkdIVH/WInWtzF8sx0coQywvc761agwwJ1FboU6sBFJYjbOdjiZEk5LxwGr7tH1rSSlMiU9QELRJj7gF8/n1GbyHxGCHyIfwfjj6'
    $Base64String &= 'VDJIR1zEyEii4Vg0oZAYi4NTESZc1CO91HeBlXu2OZMhWS5w+E1kVf8/9H5zi4uVr3UabYGP0QmTCY0MkaIxAn6pWtBJAkGp6xlSUY3G9gjU/CUXxos1WdSAQtWKROZr7u2mdfB+HwT8fQMpQVrb397dDXwESQ4CiQyQ6wSDBP/uYbvYQjt2cnyNg34tPw4q8WMyfho5FIjuhB17a8VzMJM2vkE7GXzmutCKgzl806UfSyyDYBbBc60xiS0qheLAdSkPvN1Ro7dABANJBLpmIwoGCeDCI8q6AuSHQWBkpAj/UARG5SLUSBLnwP+sLoPYRn48ixZQU4Hn0Fth487Xzi40Ung9lSFY+nd1Hnlk4NOlJcDiQnYgA1egL0EzKuMi90Y8wKxtqAA2dAJzZk4Ehg+/gfuxEIBOnLaVnt93Uu/WWx+GC7SB4Wpugnt79HUHNYAvg76kGDLDWNuxK3RybLZlvg1GLLyo0uUI1+GivqgaH9vEh5psuwA5FcC2baJtFP+2Pnzhk8NU7BZdohZ+RJl+SEq724DYRHJYVctqJIBr9A4wQDtNgFMtcWTkXjw9U9Udgfbua0YEUDvrG7QZ3VthWAIPgzAfJipHDMDfX5O1rYO1SER0BdYke1/xn7AELF5PDEl0KYHpqxwCHFR7ByQuhd0GXm0WV1C0koQ0agK4brM1FyIUfd5Kpgx7+EWsW20WuNgXOd8KRMCwdTTGg2tAFyLQDd0+O984RY8oOUSgdgEMDUkM/3zrobKFEzjrFN1XADK/x4LF4l96TDwTvKTo1sWL6PHtTCpTqpEp2FEYaB1qtsOtSo0UDmjVER7YIb5NYP183lv9RQdCyEX+Wa6AJAtG8ZRREjqgFsBQxLWSoV6fKz4gRTDBAbhixT50seUB7F6Lg7g+oBrEXJeT7+xdrUshEZqYD4kOwxTVhgExVi84m2pLhY1WqE7DZQqSgSYrc8kaixOtWl6Bi+AugjybBldTUqWxttBnCAsK'
    $Base64String &= 'ROqrUC0UtkNfUlp6W5FC+I6mA60UNGjYEP8sFh7dHp5VCvYJIshZH4HpbdZZ5ILM86v/LUeqSmF7Qwg7LwSbCtDPWwwQdCPBOGpr/OMIO13UdJlgUGIDy3gEqef9pBidUBDsUVNFI41RcH5aUkDFxwAPO0GgMReaJpMrbS8g4zfu6WdHMxAkJU6z0OyJoAGKTMcxdmxSlT1ZfKZsgCO5okw1R8uw5IsGFBVgtujwnohkM/COnvSInVRwXSozwVWtGarXV2OkfTyhuXpOfFffT87K4c6VgFh8U9euuL2tBJrMEHYHYHDQaFCRj2Y8EG5LjK/2xgJTdAuQpnfXQZooEgF0GfuYIngTrxTDPCSLfyCASZB7MllcIpoTDC4R1NNHVxxRE00OR6REMw0buRcAyxNkBjPdwajZFB8tEHJb+6pnB2gEz3KME+W61BDKTcjVXuCa53bq3kQ3gZpDjH/xgI0OS9meJbZTLcBELZqBbAb4iv0+U1ODx3DfNRd24AvAQX1j4Sw5oQ+nENq2ghjhCXFqAVVMnNyo7b5S6VJBLlP4BWOGLxcEAXUVKLhwsRFLNI5mcQZzBQVh7AL2BgBd0tu4ZMG97utdjXKmw0vtRlAo9ZxmOTUiZDdoSEZoCILM3rUtAokaZwJ1IFPw2Tb+LZXHByiDflAJCwVMA3NvXW1PIUt5oPufJ9CgbRZ/jDmTUBFglrL8MZ85W8iejStbxA/1FsjY1oA43wFXSGjGBOpIGYZLjQDz8dhPCBEZJoST8SQkENxQoAcDaydI1LSAjBDc3AuRsZJR3MjsKF58q2d0NJn3vtDBIy7RjzQhlf4kIlJ0blI2SRsNn+kGVV48VjI4NJoFMIpQ7xMskjx8ZgsEaewn9HzpwENnwDmGmDRmM1WDAzDpLJxi7F5zEQgcF5CAtb4p4PkJiMMgrzlGTFekJ1qhW7VvG4WbRUzCBzjvHa1Ua3185YNLdwPG4AfQXokoai0IyaJEOyuLg6Xq'
    $Base64String &= 'bSRgCe0xrC7QRbiGqQRqAiZqT5+Sb2PrNR3XBHMjAd/0RjiL+clZ/3Y9vMcXNvg4MiH/GOGor3nRONONEUrEiGgx2yGHHPYjSmpcCC8olGgsyCky+lMiRrgwurfFzmKbCX5YYArEUB5K9dpKjuTn+vCxIaDsmyVKjINJFBtsrTcD/18aXgjXjZB2RL7/D+JTLBSerf35iJ0mRRuQd1MgYKWoGQKKDjR6wQ6YJAIYKsMqhjV9DQ4IAjwCBHgkAI8ou9IRSCBSrZlVOkB84DCbIPl7LO/IYboaD47NjqRDMIsE21y6g4jMO891I4vUa8DUoG2Bf3QBEOsK/3MZEWYS9tMEXDEsVkHWHmoiDTu+rwMQVtfDaqUoVrcjYmsB0GHgi1qgNfDoUJuNDAnwgu9BPJEWBvQfxA3gmj6A6x4dCkO0a8Ro7Ccs6wdB3eiYCVYdRkbNBmbsuZ2jZj5FddRaURvDIlpAFH4OsMSyUIKw4PHmvvDW6dksSDk7fQ9o9FshTW/BWKodD4z8NF4Qj0rYaPge/IaGxj/NLH5Fhdu8H7gawWXkkI5EdhNQco8D0TIS50A7JVjmNkvbSg+FDmLZ7Cx8u2AVAPGC01gSBG9tBYhvuspqGQJZuD0APbZMGkqU/PDm/WduUGszOiZg/kGtYKdev1G1UZmylPttq0mpPJiYmwy3bOA+a/8UUOkDBwSYKDBxIPTMxdxTQWPGxkRC2LJzc7iqvL93XiTABDZXCl92UP0OwigvXFOEHLgKGozQ6sMrCBeshgBXj3zxFK+dibPYn39TchlQ3hvWYJpgz8WaJZPwEkWmW6fGoUdohEag2WoNWTh3U/B3vjRqvWT/01m+aA1iB+HtfcAKaJDb42alPZ1eS5EIBdHfAWd7Z7iyS0CAs4N8CAhChX2LaNR1Ax5Mg03o/xAGYrMD7PD/WNjg1RyYcNM8BSAati6bNCeYL+jkejK3ia8FOc7At/36NjZLZBU2zQNWF2QvgYoV'
    $Base64String &= '21BzZCZnANwWtPkgj5ygvq11wXAljUwFaDnVh5xw5gde+CVzHHC7JXxlwyXQjC+2KifhyNBeKcADO4POpYhA/NtCDcLCIZUhGDSwQui24TlA/mYoamIjEv/Ib/IMixD/Far+5LABOaj+eit4ifq2NvisMPcUCbtkalZjBBCNjYm4UTjAcTYDFNw+hOr3e2FqMppoMNzKHNbAzL5KQvvVZHnkMMQ0iAi/C7wQhSEWOXwGABNBIvdrR31ofDxPh9AgcIV/y42oQbBtC1FJ8MV4DwvwUf8GxoXJZDk5acnkB8/4+SZZDvhXA9gYu7VCgB/UBQ4Q1od0awlB2IzcfHNdCeCQaOvwLQauMl6wEBOgFOTDzgZZbGziULMZ52RrRhAQQCwuBJYMKAO4YSSEL0zEZECRwX5dAKto3C3HUZccAAv6fVaUGMkhg/ziLkWQLqU0mPfgYFaNMEwaTk+ysaKDVQ8JjSRUsjLJwlb1JWQ58HdyWc0dGAp5tl9ZA7vAhcMM3ZKZ4fwLIMgQg/gCUQLeFF8iXc5W8+t2e7AuaL4P8t5NxOtiE/LOVW8DJeslWB3rUEK2T8gFWJvrPDkG7QOyfFnF6ygBV1TrFiUAx5OTB/5cBrEsAJwk67hwx8INBe5UOwWNhGO7apKAILq+INYYreQMS4582RCRBC/Dk4UU53x8f7oTuGo25FBmpRU5HDshUmi+FF8AilGJDpO+pNcvyJMOYa4A+BRDBuSQ+vr8BYIni/y1JIN90EtII7cpdQD2GMtSLNuE0agYLhw6ZOQgkxy83foN2dQlEPzD4N11ss0MmVMw8HZb2IU8CD92/gdCd6tiFO+OnFZT+5Cvo40Lw4wYzf4vQQHr/qYGOHQckcCgbl9I3lhrmgVrnzGcdvy3gewmNZaZYN5S1FYyHIpVunho+BgPhW/NW6UYDdAxJF1huQhZYnGjWyxOLIJ+JZJLfQe38FZArQPQiVTPC5bo9o9A5wIQiQTPQTsmfNux'
    $Base64String &= 'jATPqRhQ4RQsFn3oQf25XcW5YILoCHi4BTDMSU1Dw+EEH9sGBeHbJ1T5952Q5sA4DFOdblHaGhgIJIFuaIAhuRsZA31ouAaoSEhHohgkUOQCWI1cLRjf/NCsgCUdXtLVgw0r2aNtqlb5Yi1ZcKmNH/yYm6zZqokHpokjViATKFEP4hERLzCiREmoBFapOABtth2AagL3YlFBCoPo6JuqAxSIPzPSQjvKEtDChRVgJCkXGaLCbaPJiZPrDeSzNwCaSQQuiUgk76wmXQAn+GxVjllxYU8OSLFxJMigMiA5G1myRHAzG0Nq9dTQIsILMPhwD4QSzCA2aiUXQSokSdWCR+opdFmgnbkCLuAfdPmDBbqx4GzZC7RYEAf9VHHm+Q0oxhA5ngIlaFPXdB9/SS0Y5C4VBHURCTSCWRCB3kwfgi2WrR3bVMMQ25HgwCI4vmEVPhTmgK4V+xEmhF7N3umAmXSGEEzFAwxJlRkzcfgF8t98susEFL3f55xrW7YFBLWkJz0wxtvaVA+0Cgz8LAVwgoYnMo1Riu9s8o4jVRAj4hB1GFk0AHCrYjVTKEEcpTBQAzgNpNVA6IhgHFsgluQC4cVClwlFG8LGEQiSRUewYCisl5LvTLaShUJ+/IxT1OENVkwJSljSh8J54aRT/4YRg76HHPIW5CJTFQR1FQwQQXgUCIpiEIKMP0LOMIeQhLHRDDhiCBrt/QXF0esO4UeTsBcl/MaZWW3rCkl2hpgQeVmaHSwT/d8CR3VdV41+cFPHByhyu3cnYEZ08gh4jYaYEVfH+Pu+6EZ8AQ2EBYapZseGAMa6Lp//FJAalFqgVsXwmm3DA1jibUNfo1pvwclLp4BCuRtalLxhIERzv/mDv9DZUAA6M8UMXQiKzTDWrWwL5Xfb38rsHnX81wz2wQJ0HgQEoDFMQLgws+5kAZwrP+shHeszEnQcUIX8IVQXDUhGQAe37YEGoReBhy2Nmqo6KAgPUPRQjTBEUxqY2Kgi'
    $Base64String &= 'PbT8Sc9TKJNAJh1xBkNHRSuM9BB26P2NevZADAFDdANH6wFPKehZGhA5FE4I+NhdwQtEnPB1JTTu3oI4dAr19HwORwdPeV8A3Nb7C0+fcAF2uOtLk+KtK8hTav8i3WggxUKKE8tBG8SgLU/wZUjMOMJwO8ktKMZ8LL3NVr60iz00AKEV7mfLM7xpaLAG5FJhLuUwAuQ0AoOFGMEfti5roRoG7VwXafl2hIDdFyBQl2gBA1Ddy7YEtEZQUx0suwtvs5ZghqgSmmoBARlqZpttlxD/1bVQF0Ew7bLba9ILHmgD39egGeTBnrgvNyBqIKywhH0BC1M2Zp7tozAByFMypNUZtncgXRkxhQHMAJ1VqlNVHPdaQCaGVjsi8qzqWRxyag+jLTTvdSeAlBwgJmLbZbET5gMPECp4YmPde6sLZ4uMi60VYaKBnRJAwy5qiyVM176BxL560BPQwwPDRgQBC9jCCx4tzAJyFyzRuPzwA+IXnTcQ4dn/1l9gAx3FENULw6j30/8/I8MEjna6UBs2GehDxYNh3nQqMbB6qSdopN1zBnILVnoXPN9qRO6FF1m+UBFXkMARlAvw1EQEghRDvgx2kg/LABhoeEjxJld1FkC/YWMLckgXy/DwFJABOeT4+OgQrUvq6AJmwY3eX3Svv5Z0GmgLn2RxahZNW0kuO+C1JtObAPBw4IRmZ0kSUDGzAo3QGyDbrmWM7OfsMYwSCpBoqOBkQswGZOgUD7w2uHZYYwwPIl9rIsgIQRyAFrGEA3l/2O4ANhmAUauB5jgbuG4JZqkA4ZYIABowFBDuEgTMQwXGAjUSYIBBryv6B8AGjQYY6R6qZ0YHDoDP0AAkAxnwXhYZCAcVwMDq/h2G+SYz9usJRjs11H99VBfxq5Rp00TsgZYEJn6mPJUkMLQxy10HdxOVuFTO/gEkeGAD6go7JgMFB3ZFFIdl6w9hh0nOlk0NWFHnA0Y9mFDY4CX6AUTqU09iTPR+8FJgANi+'
    $Base64String &= 'D6/zUCuwNXn3AgOBENceNBbW9HGNDBiLcjMJElUBJcBRNjcDDb6dmn2BT0z4f85eLmajWjUYuVGTSkdg6bCJDWyE6A/Qv4d3o0/1C9cOxwWrbnHGif51I4XHdR+LbA1oRBPKQUXoAB67+ytq1aYLxzlFdSKFYke22wYdKn40Lccs/1yPtfscaH96NyFQV2oAbGc+Jp/uT1+JTu+jklRr+1dKIkxUF9YzHsFC9VZL+w+3DNTQFsGGb6UJd0RAcXzqqA3ElyA+WXMyVoa+xy5wLw+M48xmjdpENRnU1Uu4gWQECL5BW/f4M20jObujsat6HX2tfloRvhfDBe+DJhc9EdxkK8T45BAwsHtVOCrXlCozgswWTgZPOxJ/El6DxhQ7g2Gug1sEvNtCJVhZObMPh+SRNcFLZCFUIVTZQDYjfXwMXS7AUR21OvFAjBfwB4FN+L110+ERDITSiQSN8XkNVw2p0/gBUN3uwZgGcmpNkHiGKXfrN8NP998b/0euSZwaw3uontQnB6H1DhhZiwg1fmAyADlCtixwcJaQI2RtbZs++yIyALoBPg+dwY1shT6TxjVIQVM8A8iEnUFIAcgAMoBIZYQMYEdlLGb72QJyZiZKAl9XJR0DmA3cmmhMtzSQzBwZbiSOXQKzfKZEXQT41kCXlc9gEIxqj4jedxOUUP9wBGhFTSEf9jCXIawZCGhWPIB9DxBoV2cDGhhoYuRtY4GXQDgcaGDipewjIGhkbfICVYgVQfXQa1isI+KfwQNG/t4P7wlu0Fu/The1+FsWgiVfDFf+u48NmPaLZYt4FGqMVoFxKPjix3SkJSyqhsCNAW7WAvCIHnK7dxlodQSX0jgLZkOsm3tXRwI6CzEEjlC/BYNkQSzljSAYh8oQnT+SdEG2LS8FKvw+YjYJvD6EOACW2mu+sH2vGhcxZEg4FFWLAANS8AVomnzXuIwHYDQARNgwCrrDOoAtZApqDHx0sljtHHBe/SxIDGQp65b1'
    $Base64String &= 'U15lQAkjbMgAMCnjLWywL/h9POVFbKsBOxQFS4vHIhoDp4fABv0Ar97AEFgwfk4mVTGKXbNo1LHg2GcnKyomjU4BHovIDdqvXfE5fhNWdQeQAgR7YqsCaFNZa1DwOeFLx3AwfLIoh4lYs98lbI+PHLckaOBkAoUuwDElEHVDFiswEjA2t1UVpqOcwZI4Lg66WAYWBpdTuXqiH4KH6WVW63K0XjyOfKS+LIO+QMcAWURNMhXwEgnLKogkKvilglLB0+fCVd01ZxEYRxJF7Cssm+m2nl0YXdgMDvDoZDZcbOdDKcScCJepUDMPg7O9Zo7uNxccuEfHTzsuagYvK8dAZWpiqHa7sB/0PyvDHUCOnWDfsFMmsKCCDMTYCICgGuHTZmzIsHeNuFgG+1gq5HYZ0UEfFw6IYqflCLlLEKcOS28UjWwkiF7gBG1aK/gW1mzGRaG8NLUs35b3mAKciE2goqMAF4ouVqSr26wHtt0OPKawcim0BBm1Ashna8u2tzIhuMAGWZZm5MRmyMnKy92Wb+XMVNSJTdjcHN0BtjvPsjve3+CWdFZdWZZm5OxB8PHy82bsyOf0/AUARCEEyOdZlgUGBwgQAlmWZuQUSBgZGhtm5MjnHCQDKEkse57tly0ug01o/6UvMDhDLEszcjxOQEFCQzN25PNETARQQiFUu/8sS1VWV1iramZeq8w7Ssd4BKhQl4mDHFvo0aKZwwGQuBa2olysG0nwOGvA9nVfjYlRbdxADNhcFzgUNzngBbBCEPkDeoyAUvS+KpVQm7tVocf5aAJSRwlbM1uwAW5NPEMaGJ5ibHsvRBgUKPp03Ng67jgYD1ZWdAxwRSTQpYqR7gh4dF8/Woy9BKAz19xKObAteDtBxjsJCIG+1gGtfAgYrsBWJE3RZbdMaAPUyIKQkjvWQHpWTvDhJFdnv1nPqLOwvA7WW4sUoU/FiNBni7BGaAHsDiGYfick2+WNXoZ0/zbsBP92TvgF9M10qnCo'
    $Base64String &= '0toewXewyxT/dd9FixQ3iPcYzBzfZZtmNGrE04MHKhAEcGZJvjPCqCEgG2hCJpmSAWkCPFaLcGhe3Wi1DOJAOhHLNOF0u0LXoFUYDMT5jc5qtt3LFXzMppTHtYO5UZAE87cwKIr4i54F9SN2VnjBrcYeqK4MVs4XmJRZPChIoccEUu/H3CQkcQ2NRAcBPSJcWvHshdKNg4SDJHVZtyDY21mjDmx2MFlyb4JZBy9zkGg8Q4jA9tlqoHVsvpz1hjsYRzRtUIhFYPiIh2A7K5zHECytjhq/qmTv11PL0giFBxIg12gveoDpRjwI3FOzaOhtxAimmFucQrAnFTwW+IPFeN9AkAqWI8D3U+A34E5ywvehZKxjoWjiMOB+RZC79YZYEAbckdi+bBR1trFjC9HEELv3HcgPzCfbQ0XZ0B3U+MxdIiKL3Hg4QpGT7eSE4CTk+qpSRLboD+wTf3J7OxCNnaM59KArY1lqBxE1YBZee2qCZzNdIoVQOohDAncQYyj+sl5oGFFNFBjfHYDMJQNhfOaeBHpBawvGXl1ddWCpny1rpHRwQTz+Jkh1XI27rHLBMIIHI++NRhD7fpRtwN4hIgGBxpDnQuEgcrEJisGCmoUG/qhfr4Im4gEZwEtdtMSNKXhlPLfS90XxgvreG/aB5urFRry+Y1BGg78UhLcJRi5POREXQSsfPhqwRoEQGj73iihQJJtHf63UZy76eVBfY3mdXviYYHpzDyUUEHEGZaotpr9hJpj04lcG0xdsBUSK4m/4meGh94UGsqyeIu9u8jU8eIYBAo2NJqAeL79R/3kyX3REnjYFi2wRSNJISSHZVkEiWAa/PoJNaLMovqAm9CZEONB5tUFFOha2i8/01Mqggs3MhJNNWQrwHSwgliXsWWEMWZd00l9aDDtIXEAMXsB7L+z0YBBji571Y6K2HIQpHr3YEXVPO3hDyxwtjpQKFR1MFWhBJOqF4dUjHBVMAJnceX6AdJ+hWjroWTLy'
    $Base64String &= 'XgFBtqjTp+X3AHxEk/dvEEuaXbWK1fDw9wOiZjFocPgaEGSIFvzwTqJo/MqKO6wghlG8jkkPWPi7hF0rHvZIV39FjbkMA9QWJNwLixdjCVS7E9tdE2lYxwlknwdgAagB6icYKORAPlwxBtABfpYoaFbVgnJv8AIdnVwINAb5/be8BULlPtgPhdhC0XkAGGHGLqiIWTmeDRZotJdsbm4Tqu4G2PnHhdBzi6BtNOwd+Nj5p6vc5eL7ndQMcHxtRPyz0A2nnjvedB/QAijYAagDQU3R0xEBRPJIh6uxg40KtTMK3e4GcI/4RmK/Hd77NvGBBgpWNMuNCT6kI1CxBVcfdA5XIGZVTddTkAv0pEIMItEiXiYqAXUwwUV1Yb61+Br0aoJXSUvSEnCsx1xxj4tsM/98E/jt04TXPTVc4HUkagtIQCyqBqe3UxGAkg9yxjALhWB/SnKPvgldASeNFbGc1ZBNc/ZXvfSEQ7oDlxjd3bUgx4SXI7KQwLkChtNlFB/gB3AhifzipBDjTYK4rCLG+XenGpskFprcBwPGPa2AzUAWJX0gmxTEGsdtmy5slZYFb9pQEc06vHiwsgdKPJRoAn0xioXAkaC+EscHyJNHNb5wNUiTw8WkCB2aAEaYGoauxs6vYIF2zuitf4LUdI1EJaheThmlziVonAQo5LWA76YPEHQLDwFrCm+CMKHsgf5tnAPzLd0xK3vdDWoFCw4L4ABLcDe9UegtJKsUDoUyPGa5Y7eoBZCOt8QivFRwpi8I8x49YXS/pms5XmZW0n35DVeki5+xHqmDcBABgMeyNLvYZSRQV2QzeMCAHCD3uSbAWS2FqFMbsp0dgkTLYDkadL+AHBwGcV4gYlxIyYAYX4tbuPG+NTE9VXcli48l28YtC9gCLsYvFKM3CYHSJVFCuKTZPQ1RSd9yfFpWrlBIBgiXQbrIQ5tEaBZHxxJDHR/pWmPzaI2cJKj2v65x8+vQE0HbaEzobH5gGHRNVc2m'
    $Base64String &= 'AhRMWxCLQAMzDCYvP2xLFsy6G3BY/3MXlhNOoGgM/jFBDjkz0RFYe26DFEc0WMBsMO7dFtWv4FRPY2r/mWttOuGggz+RAQ+QC1m6Nk8mDLuk21E268csAEh4A8IlD3pYRSsEFaIcIEbtSr5Ljjd9x0oWAe6kg2VLTjoYTBZQa4OxgZ1kKABWoDMq1zCJHLSAI0VF+ACxPG8eTDbhtXB3IC9UTEC6k7ELC03wEVtHKkvzTjZOEfW3mNAQiCdkXPDMhgGYdZcyGAXEqq+ldEdIDQR6X3KiwQl4LyNPzTJbAWgiiy6kNE0W1EhWgdoB/wfxFd4M5kuDewj+dUUC2iBqBZY/1Gu0QhrnGYPNjhKFRxN8w1AD4I1yAU1PgXsEn2d3G/R1I1P0dR2ji/s6x9CpA8CGDODzKhm4jRH/LQjuAsdDnmKDViNQGC5Fv9U5A/hXak+NQwlzBIu9G9kZHFDLibuwAMVpMz24GXz9dQq6SYVEK0DbD5SAN+jIj3jd9kxAOblyELmvOBB3mDW5e2p/w6m3rJt1M2pwLBIoGBcijdxQLRUS7nymOHUS1bI6AqdoAsyoCAwYTBg+uKPYXbO4EyY7yHiHTgFGtruOTzkFg/kGCBIM9sjyXOsAILMrdCofJmiG+XsPhWsjYtn0bI+IchRW906DSC2KQrWGq4IzUgBm7DuHFB04gmCsMOR2GLwNbOC5c5u5t5BLDos1ZNY4qWqDlsBYix4oWjmYyzgcFO6SoyR0BY7ZJehDLEkYdIXeh1zQCBV1hFiVmDXnFz/Ug8ywAnCHgLciZJz4HIR9Lva87VGEcpIlxvhCUayZgB4dEcDHBzByEigGt4GxkwBd61scVXu88cM/j+tMi8EtgHQsg4R0HkhWkt5KEwcSdTZYvBEcO+zrKSsXCHD4g2DwsJmnwwAbUItdmAGczTE5V7CwFUA3VVhKI/HZQrIITXQKUstlgltbiXGcFECmgyWiK/8/mDkfZWjP0EjHhL8J'
    $Base64String &= 'Kgw6tKgZ37QNdkBjA+ZXBVO9FQ34BTm25f/TQBExUhtpBJnsVjErqnYHXK0z0IBBASf4+tSomYD8KStWrgkM0RngxyS4HS1CreGAUFDizwsOHpWlihBCiAgFYCEw5UNsKg6duhQNXORNfyPba+GH5h8FQHBYAD8iGmok+UJAezzHQBDeCVdRmKhOB6MNBADz24Vo9DGFlKAXN8D2O/cfDbr/xwaTbIeHoma1Nl54MWLT2YuFPw1QRP0ou2ZvSCQKaL9kR9Fnc0hTkMR3JsjI9lpQDToFgHwxGIfIdKdiZTabOgh+i/WpBZzFXQ/R6AIkVjdNB5LRE3r5HY23f9mMitcKaZ2SvUSG7oMmLGRHJWhA40oEAwbKBK1IniHpFFAGZOQZkmcHcAJ8RAx5hgOQwQbe3uJZg+D8A8AEw+pVVnBU3ZgGnlNTB3PhRKcOKFOfCN5dg/pAMDPtNxwQfn8Zsj3RI0hr8G0wiMvuEwNA6wkNiLV2B+9mrQ7pjVwyRkNIO9gBhQ/BfL51djZ49ghOmpg3zwBc20socs14YxOcQyJXgHJ+Kgi2CyZPn6DjsnxNTodksEfrK0zOEPAXHKNXRx1TUHfsXRa1thfJZ2KZkgkZtE4swFznIA9bY60KwxnIBkxwwKlH3R87cJJqqpFZH0QJ1xbsDv8dEXZnBtLMx3fRjuKu1mgBgJe0b7qBG7Vo7L0nxwUQNUQzIhENmY4ZsGycU3jPTVWnv2G4QAAERDRN03V/LAMwODxIZ6nKFbjcVF1N020LTANYUFx7h2z7FZh+rYmESAfnGNKwfS+oi7RABynEHQVtA4QUipV0tzsCAUVESreN2y31SzhkQqzgVzvzfFdsurELuTtMbBADFBi/jqduE5R9D28oRrBJkn227iTrBLokLAJ9CxvqKDgiI8k+LGDYCRobHLZyJIeVEZevqPTYmDO3GIyW1VZ8eAt+btgggANKLiSJb6HwXwfXO8N8Yf6n+Pe5EHGAPubx'
    $Base64String &= 'RgeC5yYHTAcVC6C2V0OGizxZE8B0wQQeRH9Z7PWCWTwosg2+lzwsrgzkjfTHhJtd90eDeDABfBG0eB2JNoXWR/WfMz8Qhv2DvCRQCgWFUwP9HyLLmTHYT4TcmAzqSyKyxGDMQrUD8avsqzWs6me+1+BQcaAKsVNSX0Cnnox0jRHAg+49tCShl44CceHgkFxRlKYj31u6RSVctD1oiPjfOaQzHCiELhbfYKY7eaAKiJRT1B3sZW11mOaIed4oJLvuAQkISBE3b6/gsKCyEDYgQHDIKCYMdoAmXvt0fEgPTtRExkPBg6nxNq/o4B1Ro3bO/gJ1Dc6NRRVUs7CHEiuqi7YDIoxJ6g4vAHOydQg1VAjYBE2Av/hXUH2zUut91ricKQtXIcptiAfakOsJSH50idovM/4P5drZYEVPIKfY2Zk8sfn9BVlo9gEb7Pm+dEy9DmDsQ5bzpSG+aCZHLlSbAf8A/+d3BvkT/v4s/gfiZYdsaOnpLdrxuR3yDCXY8UjeiNAYFS7ihA3eEzco3o1iLFwVN/TaGQVNARY/FqzxzC3FUJ5UKGTNMmG2GcCuMlCS7+x7rDEVFVMw8T8K01CZJIWbj1sHxT+bCzkdXAEIB2A7t1M3dHlonj7o+69BcQty5PumdBdvZSPqPbDQGx3sGTci9lh0nQ05CvE7aADlfrEcPTVo8BO7BMyGSCJdjexRDGJSPCPsA/Bmyb6XqhTpzyGMjGwTDgVMNDiMjIyMQEQ8SHfPyM48dBfZaAtoiOTZZMVTNwiMRB41BsTjUL5r1NiBajIMa3ZQO7g9BAVLEPo9WKtoE2EgDHQFagTH3u1qITZoXONozOibwF+ABGiYivUYSG8jWC9GizU4+Y4AwS2EDp4HamsjWwQIA1gloz0DKLmUOCqoHFaqB9BXUebDd9sBOOSpZscEsgcFAJhuc+oBAOYBVcA7iNtPO/gz0m4L8ALKuht9oeKAlpizA/ATyjYzJ7Ch4IlLBBG40DUo'
    $Base64String &= '5eyr+ShZx4aACuLGbwzbADhVZm/lUOHI1W6+y4BW3ajhD5pRt0poEOYiOLiNmBEPGHnZg+htq14TBPx0GO7v+54Ue5RCEgUP1iEq0lB0CfjpyRaFmmDwSRBn4nuEiAdqP1hZwyFqVgHOWQ9yJ6k3eIWlnHIAd8MA7RCRXVnipS7Cnj0IaIe0B2Yz27N1qJEMkLNEudvoexE6FCLMFFZoTJVcoQEM7g1NB65bwQTRNYAFwXgkh3xLkpQXtAZ7ySDfzC/0ABTnFzWTDLI05wZMU4WYma3ffADloXzvrrUU6XkZjZ+UkypkRi4Za6gQnLCkQJKRS7isyDGsqoo93xJ1xZCgsv6i0a2CDPxqwOdmh4Q0nPxjFEEoEQePC/W9gK2DKBJOvuhvyR5Cub6ABKZoWBX32IFXtyoXgceMfcUgzDZndB5jHGzJGFblA6+oDAahaATH92FjhULQkgE4DBiloAK7rXxgQftgPB4Lshpo1Osu/Z0/USzhfQSB9KOFDf99L9Jl6ZV7NRDT7D6bB7JM9KgAzAdg8y3gQnZC5TtcwKlA3RnHhdzLKneEIlYCwpKSoX8FHSNNk5IRDDv7Ad2gAPz0g/+dbjRhexao12h4CflkAX2LfeBZJuqZz9AH9AF01DUKw4T0Lhw/JyOYksdhFP6EsjBzrhfhEis+6BzIwsjYEDzoQ4QMyID7+5gpOsj7lt2bEOBAli1M6BDNJd/pug5+Sf9G/z0kJISin2g86WwyXouc5TFJVBXRey7GQxowF3fsmWv5FdpmOWR0VQi1vlDN/UypXwx+RcDFWeJYJxFhOyxWk0HRGeAsCAKNIBj+dwx82+sedEOfGia8EzZr0WBZD+SQE2H76PL+kRuHPOjYoGzpDe4lCxTYdXKNJn4qgjWqYV2R4O0BlIn4shh0PwOybA8jNdj4KDci2N6Bxo0hHuN46ey1JTX4SsCOeJjbdluhEFg7R8yfRIyBcMhy8JDwoRhnAORFAfsEZPnh'
    $Base64String &= 'FskHmM4MngNZuvBEDLb8j3AhzIDSWZ1ZfikYFhIJnlxcHmy3aiOi1zCddF/S+OBFNLkg6qxssmxDoxn0MBPE3xBAHlX0M8kPpMHehru/Z//B4BiB4mAAC8/QC8IVzt105zUWiYbAXomOxAU7kpssCU7VENhSESYjBwnw1eAwRxtma9rIsBki1aeOO1bopBBGobDSEN8H9uVKuaptCFsiWCyGjO8LB7cNg/uQDGLfWZZt95W4iBOvXawCsLi82F2WZcjUzMSNF0W0xgJUC/M1ICc8o4B7M6PxLX8PjpCDyzj6g1N27StgR/Zs/0VWD2MFvEayC0k5LSCyfVYMMwLHgWCMoMja+IHBABRa2QoBuFVk82dsg8AIULQGCvqIOIv7OXSiUcF1km4iBJ9UW4uAIPjQFye++oaIKhjd9hEvxA+LiacIYwQ/eBPcAPGLiLQE5YuQsDB5WyJgVdzwdxnTdl58921mqEmsH8MTy3ZKi3+2f2MLRpcwlxZ3JnIOD7CGl/pFLHMWFUBCD+iPVqC24ALcAgfGx/bVs1UVUFGmzJXICxlO/YRxRdQPjN9Dbaq2JGMRu899rLYRPhARjXUVbwe4UeAebDJUqwb1I+gg/z1ck3pXogm1qMZH5oGWoq8oZw3Irk59qqNMtVeXo9wDpWeyJU9oENQ9+TnJz2Qh0CxoiGQX9H4muRtomMgKxwV2kaWgHateX7lgzSK6lYqHqOpgSQ5b4IYDd4e85GSSk+jQ4OQjJzmZ2PwMHAwFGeSQ6+RgMSvog4RedQdXuYn/gFB6fgI6dQNW6xUGNkYeuGo6UKDWEVf+bHh1At4Cqp0JDnpQtyRjVkbKwPSC2zvYGHxCA1cBOEsHTzz20f0s2Ask8AtOjUReFvbtp+IK4CDrVIM+XHVFR1QtOwFqBEnbsFZ8TGd5Sp0JAdTisFawWwK4jIqHInRIJf/4dYAt5hhvUR0BPOAWWR45CxEBsKbYNG8tEAQAgDvHu0FMAG4a'
    $Base64String &= 'yAFfB5Whf7iNjCSIzwlg2X0HnUedIMFsArB9EC7YT98UiBqEmBH3JXaQqHcODeG8JHwGMiFidmQcOFfrqjZIlLuEnJhdN4l2M0Cc3SxwdAb1kZ7qm608eNiNtCRwBgowva+rXpwnajogJDQoXIkisp3kChYYgWILvjz4HFlAZ465digKXohf758txFNDO/kPgkcbWeiad+kXGBxcxtMqQAnqXRmDALlWcSsNiFzU7CZon0gCvj+wPaopYSBnnlDIYZ9e9krreuosDe5EbYUJ/Bt0+ZqiezkdQGg8IHyrYLGndIRGLiibBQuZvmbF7IUT9ZxMjGkCITDAkdB1gteEbvJAgLcYCgqeiApujDn2B1q3RHIv6DED0TlUDS6dYOxzIbBQLEvsGdQIEkw1/WAWBAuEwEpGoXAcpDr5IDYFkIw8vnRTT93aAZwlSleJZwCOE2MFtitOzMvWWhM6aqUYG/gERiYKJvRjgYJy6Q+VyEAqBIDLZg/wV78QX0GIk9GT5JhC6gDiCMBGRChTV6gZBMwxmJVmG7128ugNwNLtqq0LHwza8FMaGL6mO7QIMwso7BQsBugN9ggUdC+D1xo1dAswfHCPEQd1z21CSGlMHSgCEnTGNspUcJXTDUwGuA1DblArMBC3AGzdeBIrBnTmFFB13QnDLN68HngOXI+qR9MqWFAdSapYOgwYbxySz7hbePhEIyE1OYHQQhR+rPRah2TXsuUGTO8JFe5QElCaWQx2stCVFKsoaUgUdQ7Vdws2CjtDBNnFrsnwjUN3g0sUO+s+vU8MfKs/VivDuymfNqNqczABA9jIMIRZArrKDFTQsKM6s7cLQiA1EAthrXsRxQ4kCabNos66DIlRDEJFwF3XClgdeCcUUwNhoNTypXwwmnXnPuBcLUp8BEwh50BdFdsYdUgDNAavs+71OlQ1VAHbDrNWvDUgMjzcRw0TARycHVgf3rYQAj0ZmA8oiED05Uc3UtfuGwGNlBbUUkIQ'
    $Base64String &= 'Hdj9sMkgfgNGTINaFAEx4aRZPRAMDDhCAR8tsRl9ARnGCRsYRzhR2NcfOoNoMjz7Heg7nQnsiYg007bT8R0QCdckjAaUuQ33YAUrPpV4OFvnON0JYGgGvmEDbDYIanWuRYsIGWRWjyTfCfBP15D7mbu7PEVEK8g9RGgELEFRFH3d2LZIKwNACXRJ+/ZICipVzqQFdWJGEEGPzS2q/Bcw8XRDg+godUy8AkIQzSSaP5zJQxCnAapMQcCuS/tEB+seSFcNuWuf8uXOAJwqeATztiCATElG/NaA3oN6H5aTIJo9erPo6U4iR6pGfsl3AAIsUOwKhHRSYDzaO2BAM3QuaEn3lZuA/2DrQAxoD/fZtgw4URwWUOsEC8SwSEVWSGQ7rIsFKhQUF0x8lSwIJgTTv4hEwfVNXwT8vwsW3z3+BYv5UHQzCBUzsXPbwjdKEP8/KZQjWUQFbJgWdEGwJWwXQQkhWTCIThmpiPtbAG5Mgcgb9leNvSYE2i7g98sqHfleW0XOsBhFTDZYw+xmOPej4QPUbHIPDFQaBhLRaBngDMYwVC0UhgxGikEgSVEzEBaiRwT/AkAE0U2OUJQU0CYD2aMwAS8jKVR1kCwizxTRfyugLYhyCNHpZiEEThCkKhZXKAiCxXhV7muAd9isiUIQZYB3lKcaCLoPv00QyL1tphkHB55NDFElbWdENOEDfp11BownRXUPX4EG9q8jVE6+/unZOXsEDYIZsYBXi8gFki+Q/o/3KFqdxgB5F5hoasZWUuvd6cugDAFJFEbRxWUeAwVWsOJVvTeNF7FhkAzS7bKnl3/6+mUri2BXlDnZvmx13UUUkiz+znQhOfyN/JQqwBCQ+q5sqBtE5+kFEkPA4tThk0XFw41BCN6CGV8DAcEdUcG751yPaFcXIR8UjRPcDpyBhQ5xBBcwg4NcUXTwlCTXwJlkDAxrICiSA3NmpKskThiR5WBvGFxSpC4Y4q7gQOalD7cDIlYItgh5KjrB'
    $Base64String &= 'ThSNSR2ttJqdSjQOitKIQdR8KUUDzWEPR/EtwowAUHCWpg8wCCGC7b8kCHQOOUgEdAkECIEQLWQt4X4RlWIlD9uBRXRhnVabJsCR5PDh25PJwRpVTRxY7A2L6GwZBKxIJrCUfn194MIm5Fd0YCMdveGqa7HHuEAGPlStSET5XRiMmhsyqKwETV/1usUKVShGuUud5/ZVzQgtfNHp4IuqRQ2GLYoENSHPsYONcKC8ydYQAYHB/SRPddteX1bDCCZ0F191CVMP/2/0rAgpiumKyIDpYYD5GXcCBMM2RbXgP+NoAj+8IngQDZ3ZwOQ40pL0tZRme0QwCyJw0KiIbI54eVSECh6ESkaAqzqodksXfQhafWolVhZz7k0yqd9qJwz+DJWISRWNFnJF6fbfR4pEB/48XIhFTASERruN6gYNK8FBHi+NHNhW0ZtPqhmAfWENQu5LwEsSTHQHRoNI8EGz0+u4e3nQx6AjtoJ3reguXBdPBMvr7MRhZIq3+saD4P7iCA+PSJAjKlLl/4WkgkKz6hYMLUrEN+yP+HKrePoOuAbAsGzrRgY73U8cEBoMlHmmpHk0HLgZBpiHpCgPaNzcTACUCGXVuYgBrjb5hW4VLaoTWJmqoAdtRUz1d9aiYFW4EvgBGMxD3QwKaQRoARqAwqm91a5eBpw5NTx5dRex7z9iUMefclnHBRQBHkXPgp5AdW329ZYATZ7K9PX9xUqAzhj95K4D6nWZhTKsoO8C9JZF9BijxLbQFr8JOMd7KywYPuOpwhP0BUs3Vwczm6WYFXRYxf6LFUA3wNcgdApqCT26E/AQ8Qd0rAyz/aFxJqsaamQ8kBNcrUaUTyT0fM5xipldDQdhSVfUFG/DLwwosozFDG4ICIw4Vm01ZVehLNFljkR0dnZTDxTTRVAJ6JOtdvQ6i8/6XLiwVDrPgcFtKnQc/bftC2YUsIvaEN4C32vbEQPRM9odwT8ocj1y5luhzwN1qqb3wTPHowiEQIPB'
    $Base64String &= 'SZFbrma9aFjZiK6CNIM+b8kARwzyyOw9Zw1ovZZy5JhaB052rof4OjZjCxTtCAZpBmksDEAQBmkGaVgUdBgGaQZpjBysIAZpBmnAJNgoOdmc7Hfw7SwM7jAySDPYCzREOBCxKbYEPEZoI+TzkjeZJWhg7mgjeO4CgpSbZBKZRN/t1drLA0UJBAhYBKGukShoCmgfFXQwDO9dPQjxDi4V1PFf7WY9PAAZ2XYdBrAt62ENPrxa+KHiUwAVagxZ7rtQmUGgoBbrSjlKFVhoyJGwX3AhP8vX7isNJgpo5JZlK3UK51QKE/ChAPTAGQP3sprgArF0RkbcOxFDQ686EGzxr0BZQoJTTwBwv+2QwaAnCP7P/EkGi14UOfzwSpShGMMgOHUQcRdNXgh/KDnR0magAgwpH/KEVKphfSzuXyWi2IJNO34nt+/MlgHBYSkQig0YUsCFBCheiwZRNPZ0fADsMCEgOyBoPO+BLUkE2poMycwQsEZzEacKt2TX3BoNHEjvwVClJTsR4N3GPpt5OCUtCH34VO9FMzeEbk4TyyDPJvAfKNg4EKlTbiCffEXTESDYFom2csSJCANEIlK5E5+bPPj7gQf+y6hu1oFyL4449QhHmd0VJfSDvwJcRng7xnGGbIhwvwcPOTedVAbrTMRBSAtWcX7qsLH3hIytU4Qm21LtG2pIMIlPBAWzDwoUL8uyLQwFEAgkEItABORy9iiJRxQ89HjvQbQbHTf0tEgCA5CGil1hrO/3yIJ3ykHHYBJVdcalnbXIY7GNZXTX9BATaMTvw+9rxN5mO2N3GFMl2BE5mCkOt10UEPDkkkkmBCgGkkkumUgIYEkumeQKfAy4MOSSnA51U0Y3YYCTGlvXCsz/JZYZ2dqM0ygFiIRnZram4EwqqwYOCIcgFeC6DWgSYTgIUeW19j+zPka2x4gmWUjDQ4B8RkZGxgV4dHBsRkZGRmhkYFxGRkZGWFRQTEZGRkZIREAsRkZGRigkIBxt'
    $Base64String &= 'RkZGGBQQanAuqIMrHQbvb7wBaBBeroE4TVro+m8Rrkg8A8iBOVBFExLRtiPeAUEYPbF0HwYCgr/+A7l95Osng7kZDnby2wXIXZq5+ArKeXQP4o1WHDo7o8BgIRcUxhlb9nDniFtsWYMNNP8GKbjZzkwUBIsNjEEd+TpoiTrSDYih4MGdW+AMskQoo1M+OS7gokHyV1xCY2zxuifV5B5ZvB64iN+DPYy0ywKhhD9F4K4C9wEXNYAMXGwU0GwD2NRP7DTkK/DQwDWUxY2+Wx+h8HEwzXUOZRjJAeu96dXfb9EW6syEInVFA/MKizYCC9AGZjsG7O0Ytu1DMgUgAHbt97RviAAbvWyk0PZFtHATHLlbqBzCEDEgdtPr8xAKVQv/WLx8VGH3UzGKyYtvhDlhYb4uCnQT0uv4KjUwRPW3uOKn2iBRgA+1/FnbbnGCqK6Agy0ALlg99xwA0zwFwUPib6TjtlV/DPxMJejSvhv7PmEDBAH8ZkjMzGhwxkDvzd0YZKH0iGSJJQfLxGbbIYlsA40r4AZQLnBBrYlxkTXZbq+i/4GDTfAvDY10T9QVUW80OKwZeY4FyNLEwMwAl35REMFzDiEDxAG3L0BkhQCUi3fDUf7s972TCIHpGi0EhQEm7CvIi8TXDkXcDIvhvyc/0FYDNY4sC3EYK0z8MxKqM9L38aZjdFvVXQfT60G1XBlULvz/rxPR6dHb0erR2AvJdfT382X3ZHuhS9c9IUT35lNyDjsnq929kM9yBzsrdgFOTAhGgG6oW0togMe7ZAMyYBclaJELouMlAzIg9PWHBYDjoViKD6Yn5JF0EGRwI6F4IUMyZA90fJrBAGABdNTEZORmEcgjDqjKNhuzyMMAAOmWqqtakm4DhJ9pmqaYqLhMAMoNqGm29wPi8hFGZ5quqQbTIAM2TACmabbdAivqAgPczL6apmmasqaainRk7dmmaU5CMgJfIvwDZtksmw76++ww/Di2r2maTlhughP5'
    $Base64String &= 'H9Ysm6ZryAO4qLr40mmWTdPq+gz5JkimaZqmVmp8lKqbpmmatszY6PYC+jRN0ywYJDRATtM0TdNedISWrGXTNE28ztzuAPuapmmaFCQyQFx6NA2faZIA/E/q2qbZdoMK9/QBA+DSuq5pmr6wnKLnrgO8c7umadDeiBcI/aMDpmmapipATF5smqZpmnyMnrDA0DTLpmnm+A7+HjLTNE3TPFBgcopN0zRNnKq2xNbkmmbZNPAA/wwgMGmapmlCTFpidKZpmqaGkqKywOuqaZrS5vgITR4DpmmapjBGWmh4mqZpmoicrrrI3DTLpmns+gYBHDbYNE3TSFpodPb8Bmk6Tl+Yi35sMjTbQRprHnj3A2hU0zRN00g2LCQaZtk0TQwEiPD24pqmaZrKvrSqopo0y6ZpkIaW96i2aZpm2fr2fHJqYqZpmqZaTkQ0JDq3aZoaEAb69WsD5mmapmnc0si6sNN1dZgAOCJEA1AozDRNXGh0AM132+b/wcU31QMlADIALlhd6gp3F00AU9cDYWEAc77rvo0JZccAaQBmG04LdAB3AG/M3evuEWsASSF0HRthAGOZrmveL1YAaXcrJVUwt9svtgVkOwBaE2tRfQPaFHcN2CyKdxZCL3YAbf/Pdd0AZ0cuDWwBv0RldmljZVBy3CH//29wZXJ0aWVzX1J1bkRMTFcvqZq7rvt1aHFuQ06xbQBlIrGxrutzcwUgI0RdaZ2u+5a5SQ0dAFM9b63uDda9R+F7TEtzG0/vBeuadkYTbOfxr3XdF7B4OxNmCVQncObvvYAXD48fRwBN97lusACxQUNkTWdzX27CugdNbRl0k05TdO975m4AT3kdaREnbN1Y141ICXJHdwdl22ls7It1TWMjw2OzZCvufW5kTWtNeUXXI7g7e7FSZ+tPSxlZAF81d91mBSdDpUwLTQBBSK7bXNfFTh1cnSFTy0UZvY/nmlx1V30JQ3u8N0bTB3JsN3Qxvzt03SSDcxFUCXAt'
    $Base64String &= 'CzdhQqxQmbljIY73rYxZFSWrUxGhtJl4ITZFh7htD/ZfIBskHUBpGwP+VcIst4VDFAu9HPpsT247AptXG6Ag4m8D6HbNctnYdOZy/OwPkHB9XbPcJ2Nt5EUz6S93t81yuROkYAwfBvlkA1h4tjvbLLpbbS8rG9QeC26XXXeqK7YDnFt/YY+7bAfXnVzBII8HlQOljEgNh22hJzN79964/b9Jbml0Q29tbW9uBW50/mxzRfYeh/bmj2krDA91I00TOq9Dbg90kbpD1w1sB2EXDWgThPAOZ3FtoQ2p6eHhvg9sL41pLqs3woUc8ituoW0fwoRNWGevXIsgj8YYkzA6kQCDadtW9iIMa9NJ98HG6IDlb+1uD1eyZX0RAJsPldM03dgoBykhezg4spU0XS0LNDRFhK1sWQkVCbFuyR19e0F1rUHpvwtb/0dldEFkYXB0rXPCZm8PSWZ7sX/7VGFibGUtRnJlZU1pYg3DG9Q1nC4AB6NsBWHaWQnhFRMPTz+RRuqaM1dnUoNNSxMjdQ9vcwNmZVc/DUhyXUMrVgVVG5ustwBjf2UAO27fYzyYrl8hZMVhWWd5IMZkE3NDM2f3vRcbZzNhKR95A+wEIl1kiXQRcL9ApBtjawEAK3TGPh7vybWDLVRFbiaBx+k/bF3jAAloGMIfVSFMY5luspnzyzAxUozGPvcbXy+vLrdpa0pDg8EPLIkNdHQ8xgsJayMxWXMdvLNk0R0lGd9kyX2PIJEAPId1xmNP7mJfY2yVPQAjtV7Dewqfd7cDPhM7G5bKMyUncg+9bnOfACZJL3NFOw5vZbOEH09vGaHsdbNiTwkvC3tWNoRlfxMp67a3JE1LZ2IZZSfc2YkXHyslMQMezDi9Z/nriVvWfDM5HzU+Z7nYYH0JW2axIH2EYf8/yxLVJyd3eMveEZXvBxdlAzbGaZFtczzvsjebvTcNHQ8x4I3AlhNoD2xXe2+yd2XTP3QvdVGWvYQtEw8zIVj38FGd'
    $Base64String &= 'bw15D8E3C9g3WTNDDR9KWLay3xcvAEJKuAAtv2EgzBiDOcvKeHDod1uJL8uSLWFocwPDVKiDiT/fXx59prOEz48u1ZM/eCXClms3qTQCB3YbxUltLZuyU9fxONE5/WM83xIeGSEr//6XLeG9twAdF+VDly3jDUO/IcvXwNYhga9ZyUV/6dpcXUgLTb0JUONCOrqzkctDoS8VVyasG2tDCUQpRDEzZvRoDK8gxz3wElL3J1VOcXeg4XNnLWErlXTlLRYNm+kDcTl2Hyc3J7oTSu8tA3mx872QdRkgGy0LeGFI4DLlO+U9OUnHyhgnf3lphaw3gx+r4Zmn2CWHYhUpNN5HsyE3x5tmR7mxscnTOv93AS6r4XtD4mdHD5cv9fcGGRt0qWciGzUkTFiHR3Nhy5wwWtY0Y3f+VSVPXoD8ZEJjl8sr5PZi9hQExMx0Z09eIDtdtHgDL4s0cHjpUWMvD+IAJy5TqwF2Ighw1cejK0hGB1gRXRLOTpy7zUEu5YsXyWgAbckti7FtxnsNUi9sfUGMFgQnH9cdmGu/PQtja3YL7AVsslU7C2EbxReb7HhvcBM5Zo0NSdOLAEdXg1BXk03ox1f5ALl4wOu6I3VNbh059mbJ+IFzkRNREWH2YlsAQf1fWwmbTcbxAA+v95bNeg+PFRPD4cDesj9dC3Ute5MwG3ITV2EPoUCYkikAL7NhmBtrYeVmMxu9y2hC6mefL9He7PABpW0za0PqqZeMTTfLeZvthewnb7M4FQOC8RR7Yb8ZexufECP3lAcvm+VyrY+ck3SugsWDQG4SXVPLVW9r/QVAOhqrfVt4m2VFaEBqIPEg+wvZkuAFUyHDoUj36iD7xXXL0JvxLlLL89mEdd2b6Rl3QT09SQAZQLYTQkPbmIVkRFFzSSklX1kAE0IAUACbsjNTUUkV1z0VY1M7YSBdYQ0dHgmjv+3PYA5pgR0bZhQSvFlbEvnj0L1gdy9Vw5XqXtctc0gvUB4LaOxC'
    $Base64String &= 'iHe7xRUAEwLdYQkvU31iq7BXvmDbcwAXlSOGjTcNC1bb4/sFIUeX5TVbZe95Jh9H782CZIfbBR6FLUthF7cX4J6I0UwBC0+3zYjT44mrkT3ZpNiEI1Q3k5nTvW7ZcycJMVIHMgsphoSTXLtiIbqmXGs0lzNHRcUDruvpNzUtCe81TXPXjfcxQUUJQgBGMTC6rtscYQMwIUIZMQkzHjPgAR19RRUQJi0jfa0XPbhHkCwT8W6KIcVg426bGJFsQFNjOz9IMCwEAD293gwSn3s9woCUsa9U41OdFEdCT0ONcxe7LICz/USJfR5MWtZpzx99MGxYMoM5L2EIcYDPQ7PL4uwtAgDbQyBxJURLqWR/mmxG3UkfVAEzTN1AoDEtZCm7csf6//9lYXRlVG9vbGhlbHAzMlNuYXBzaG8kTW/2gP32ZHVsZRNGaXJzdA9OZXgfLNk3KAFjZXNzIA9IiG6WIH1zOfg/K8RfRkJhc2VOYW1lV2BnwW5jbnVtOxtzJxLmjjxGaWxFeCkr24ZY9iYn2XJty2kBs2CMb5xc4T3w3OEZmQGTJ0E4gXfKA6UA5VQmgDuMvzoHCRc2AoF7J0N9OOIF6w+rX9cNSdcNUyNSTEFTGYmsa7odX08BVEe6WddtD08JRnNHJ0NNQC57yXstC1JmOfZZ5y22QAPSt/xc0zXLIbhPMhO1ZwcyGumMZ1RXZWdskLEYUpFFXw8r/B2Fb2VnZWRpdC75F1gShWwvHfdSnFVCW2l1X9RR+AFDTV9M5Zpf3j0KW21O4ScTUmVxdfaPRRf3dF+CX0VqZWN0Vy9AbsYEXzAX/dt+t6xuJl9NYWNoaQlXE0Rpc2OMjbCRFl9JU9vY0W5ndXA1bkNsuXMfNtxhr3NeF0Q0lXkCtn3MNopMYHQfHsNm31dtb3ZlHhPKeyt7yzArY3oXrrXYD0NhbGwYLlsL+rJz2WVyM1MaUGFyl/ywVzKga09wZW5XXTdsIBY4bgdkMujRqVcd'
    $Base64String &= 'Uwmt7dY9U0guU0ljaWJGMEUCvbVkgGd0aFeNpzhhihOzD+wDlnQLZ8FvDw6MfQWXZw0mmYgZMClFR3vg1EI/9/N6MwkxGaM9V2RZYjZgHCNzPk+gr9kQZwkvUxg1qUsxRotByh4MdlwjVksdS2JkxfFfY8mSQekJFzASbmwzAzkHRQN/kg4mdXIJm3Q2wiDZb6MfRraQGAdPd5jByB23Y7kFS2LZeW+j2Fksm5UZ82cVO8Dnvj1wN41nOQCyWRDsTw/Rm589G1hDAOA/B8A/Uh3w//9TRFPuj5lNvax1RZJK0d3Znq8rATs64/+TgVzqgnNcVlMyMDA1XE6AS9RYYHfma63MZiiVvoNhBVZpZXdcXQwAfoE5Th0ucGRimNuqSVcf1ywDDxMCcHnLE9sTo5Q2A5iS/MyfJwC5kgde+D5eyQFsFDvW9g4EglfySiYCrvgymaQwGyaTyWRkMplMTCaTyclkMpmZTCaTk8lkMjKZTCYmk8lkZDKZTEwmk8nJZDKZmUwmk5PJZDIymUwmJpPJZGQymUxMJpPJyWQymZlMJpOTyWQyMplMJiaTyWRkMplMTCaTyclkMpmZTCaTk8lkMjSZTCZLBAQCm1vkCKgIAf///x/+1sbaw93F4Mbfz9fCxsXE0/XL+Ou/6Ki2qauY/////57U+eHp4fvq5Puuoeuiqre0trOhraOwzc7P3reRidqm/v//85uRk4PYx8bdloCB3t/chMvN1dXOxteM8/nr7f//b9rA/sPJ2onu2c/A08bUxI6DgvXo6+6jSChT/f/t4uO5+Pji4P3r+KHg7LYZ5HOn6AOzBpa27Fmy6QMyCyeQDSET6gJPMiRDyOsD7IQMyRAE7QwhQzIF7gYMIc2AZO8HJEPYkPAnCAzJEDbxTwnyNAMyhAp4/DQDMoQLUPNhQzKEDPQnQ8iQDA31DskQMiT2D0MyhAz3EPjNgAwhEYL5zYAMIRKM+s2ADCETWvutbA8h///wA/AC'
    $Base64String &= 'EYCUsP8LxwGF7LAACAusoMp20msAAGIERJXgJKAG9yg/QGSkoK8LAfcBEyABI3r+Rm6WZwMB/wMH/4APy2aQR8AAHzkx/mFpTkaWtgEAsIAtlHwrAP92jNz8ZQP8AH//+PAAP+A0zTeLfQOAhAw0S3PTHPwAP/8BDzuUF9I//n8virI3GeEQJhgGAk8gf6CQX1qMXFmaYlfK/gFhceW5feYvQEKkCnskSwAneyI7EAJuPjwsXyb5sGT/JoE0NIEtLZ8AAoEeHv+/MvM0NGWTY1z/x7H/zLz/y7o/Cf9/CMew/8Kp/8Gm/72ff9jEumBIVyAssjACf+FLgR3MtHiC6QL8Kci4d0VCk19fX1hWc5f/hd/yy8D/z8Acuv/Kt//JtP/Gxaz9k/8LH6f/xJn/wJVwQD+mbFq9S0vL9r/BAmGahISxWlrPoKD6AOvcK5tNKH8dawvbsv2YZl3/2bVZkY5Wi3yJ/xK+LYhchv+xp3/Juv748P6//P/28ODw6ALg0PDQwPDIsODAoOC4sJDgqJCy2QMJfzVVfQIR3+5mf+O2e+U4PwIXgpauP1ru2cb228J3Av/hxOrV/dqP1Kv/06f4Er7dyp7pxY8CjHpIRGQq+f8vZcaDTb1sSr5rXs6Af96g/6/sf35+0WhoyW9v0BpLj78vaMVyZYzat/Ll27etksX/3sC2/9Wtm86gCTcsG6iaky51Q0F/mND+X8Gjo6Q3N61zc84AglZ2vkh/nmtfAoUvnBB/xP59wKigsNYMy94MggWQsJgCgmsgpDL/f39dRTu75UE+AqgAZ2Xh/3/3XO/gzwIAgQCazIlVtVQolRtmqULqx5B//wi5GYx+S0dqw4Qlo0NC+G//A5QlApwpAp4ClSQXoTZZ0X6CkP//P3V1yiUksQoKrw0NtQ4OtBERrkFBwAC5+T8okP8+qvwwZsHeuq//K+HmnHhHRX/Yt7eSKiqTW66ECa5beYJ/lfTPDLRz9gKkcGP/3buf'
    $Base64String &= 'liW3XJZQBZKQCMKKENJbCX8CBT/sAIR/oADnu4DkuN+52Uk9Ag4dnGle8OLTAk4LAzN/AoUaAj+B8OaYAoJOSXxtxIgZnpD///87Cac4DrxJDsVMCcZGBL0+A6kwB5IlWc98X/j/JxISsRMSwxgYzxYW0xMT0X/IEBC3/wfCArm2gku9/1Cf3DNgt09G/v94Z4v43snuzLXpwKn2zq+nfUts/6+ESX/RuLi7f3+7nZ2TAJ98IDe8ysHBf4QgIJpoXmWmxw7wArF7ZvUCDJErY/+wgh5KODL/wH/sYSRu9g9rmADpvYLjUjwCDv8J7ncgo29i8ufcAn8GhwXByoz/wO7a+dy4EIsM6QKHUUtc//8XmDdtE61FJsljL9VwK9dwH9VlD9JVwkP2/wXDQwKlLReZNH/ani8oKLkPYeFf+MkwL9kM3y8u3yMj3oXZkf8PpH/LEA+yVlbFBbB1Xlyw8GZ0kcfCk/z/lXvLlnTGi2rOmnrRoIeBUE1/k7DIQgJ/oOODm8BtYPMCf+bO9uTACNkC/84iIYQ0BX/gw97FrexjIpAA68CFuN+5zxHjWzsOIKp1ZPTq4QI3uWFg/H/q1Kfs/w9JZ4tUAonVoyewVC3HaErckP///4hS4ZBK4Is43X0i2GkL0FEEtTgBiR1dyH3+//8/hIXSHx/CPDzbUlHmVFToSUnmNzbiIyLeFBTWeEjYWL6kq3//9u4v8P9fcInZqoDu16H8+tTu2snXrZX+gP/XAyHhhq+ChFVRf/Y9JCQwAn+mc2Owkn+23bsCuoJp/+3ZyR9hkH+CwMjAQGBwQ7KvhH8tND0Cfwx/7AeCZCGIAOzCh+JjOn989jvnBQ4ssn1n9u/qAv/w4SNhMJ/q2rSFi6n/fwDhj1hPf9mmSb13XdmTbOelc+qqA/n//2bnoU7ijjHbdxXSWwS8PQGOIUm2Z0v/9v+AgNFfXtZiYuZzcu0C7mJh60lI5gXh/4F84xgX2f/EDg2hun5k'
    $Base64String &= '//fyzrZWqOOYd+6o9wKKAvMIn8EXgrfJlXULiVlWf1wIaxhn+AAad78+EH+teGVhx5ICwIdrJS786v/y5f379+7r/wX/NiT8/+vY/9jFf4AA4OjwYHiA4H+5YCh/fNBQMKjQIDhAGX8SXJR/qbOOQIBQ89nvvrIC7GUgR+3EieJqOQJwsN25Diy7g2ro7qpDbklJfAWnDv9/JXzYsZJbUX+S3q5YxYaP4ban78qXyC///+/Be+ywXOWaOt1/G9JfBbuMIEy3al/4/x+Njdd4d9ulpO2npPOPjfF0glRT6DXAlpb4NOIZGdmLwwKiLBe2///Eh2f//vzFimn83aP/+Le/zILV/F0JN//4xsSIaOrQwo5eWX+whP8/MjKyALK1t3/CY6+vtX9ncwLHjm3csweEw/B/gp5lWAIb/sgJf+KQqLCA0OB2sLhv/pu7wAVgwOAwuPAQKDAQMEB2dHRAtpVC+HhAUKhgf4V4AJybvcDvSeFyNwIOLHDxst3jbfcA+gaIBv/NtARnfwV/Auz/fwLrl15T3GTNj4zds7fv08Hz2qHwh+z//8dw56c/3YMZzlsDsjQCgx1mx4QvdnX4jb/w16em60T0vrv1k5JRXuo0M+EJq8U3AtUJCry2f9Ldh+HMkGwS/9OAqv/0jBk39P/ur+7VnsmQcNXEzBGQYlz/J7DxBb2GauTZ584wEFzhk3D/1GiCCPKM33nQjF29gWb/4tNzw8F8guDwiILQ8ECS/38hBCCY0CCIsCBQcFCIYFCwYA1ikxB8cAAvHndu9o3heTYCDiDOknD8ERJy1AB5AicQ7mYM7JlgVn9/3fb///+mcc+bnOW/rO3Nou7Hh+i2Yd+ZNc9zEqxELqZOL+L/31bH2I6N4q6t7rOy8qSj8YmHH9j23x1g5DY11BwctYvIKdeYb/1f4HeS2bSk1aqS/7z85qru0JnRmnQSfquwDpWOH8+6lWRff1mWZbutAK+xsrReXwlltX/Fi2xz'
    $Base64String &= 'GELyxwLVmXPRk21/DUmgWoCVf9AltLpGZALAa4LNvPD54PBAWFDIhcDwICKbQOLCYJiCuHB/aABzbvYP8sqP4IE1Ag4gg6QlnK37AP+CAhBi+8N8uLH/nABjDP///yes6cV12aBtzpmA3Kp836tn25tHzoAiuFcmqf//AfJOeNGWe3rYhIPfj47nhYXnbm7iz76Q/1BP2DEwxF5exuCfdJLZtoz///+mypZ3xYlpzpd42bGd79G876qd7ouElmdi//y68ILMkdn373D++2XB+b/t//Tn+ODL6p1yPcnPEx7WyoJAWHDY8JLYuiuLcKiAl4CL24A1sW1gAPOB4BF759yINAILIN2fdvwA/ltgSIhv86Hy4/DUwP8D2QQMm67qxoLfql/Ojh/I/v9MxX88vW8zvGVKxHSA1p/FhobabPGV/f9s11xb005Nz1FRy3190yPmp3eGTExYHfyOERgMC3uMkn9bAS6ENWS0ABrCq/WA/NOYc2dzghNCKkvjgtf6E2aTywKCYLDQgIiAAJe2DsAg0KB/3FsXdlgA9fjfkDMIhBe7C5GleP4AkILkdy0u8gmY55E6vIBlwIj/qZnlt5HhsJXgsQVLCe8D7ax6joKPpci+lEKGz52CWWXZnlqUWfsA9vIIgfzu7evqU92sf8eKarRyt1mCzZCgAqCAmAYQCq03fL63s6Cjgn/RLIEtAh1ZtmCwOXl8APj0b+63XZXu7Zfn4+LPwpuYacKG/yCyR0kC98+u47ylg7J/JcOgmOfHtVlKoq/s7MWrU+S+pgNkCewh9Myt6ZvTHUTy37qjKAMOzu75oicEcAPEDpPupSTRAgaAPWjdewESBMAA/t17k+4CBv8BEgSIu+7KZgAHjx34B4d4j/w0z4iPiIh3iP+HiPitpDsnf0d/WaqylQfXp2Vv2Sy3x9fnUtl2sveHdwB416CAyqhSBFUhwRxUBElJGwIFXxAAJrcAMTCC+GWcRM8WFGNEeWzJBwhA'
    $Base64String &= 'XCDXCS8gjnVFNkFmnGfFIwNkPzdtnE8qOJsBfykgdd22MGEpQwVyUyuMKL7MGQBBnCYtFvtG2HUJbWtBosCMXVM7STdY90VBeXIdaZVBJUu+ZF10J0Wzo3BgBwYQKSBFGxhATCDZ6Wa4BOoy1UIvfTfsGN5424/pmWzCZs1ORj23Rh1sEgVmSJvz2MtaIAkAR5w1m7DPHSB98WwvQac2sOcYTxnNLSusKGZXRMOBxXvNtmNFaPtfUhSHFOUg5+gm5FslVlQJb6J45kZ7ad0hZJyToniTQSFFKA4pii9HIMI8LKRJH0aJiEkog1InQEi2LQ0tvycpO7DfAEqcMyY17MsGCWcAS5xDzzKIGGFvMyDduodn7iatKUycb3U9byQMWfdX63orbrtV9iw2UBc9W5w7x6witjFI35GQNT28S2VpeXRNEA/ujI1EkSdmIIxxUu9orzXV+JZRwU+LNRACEZGAHfkSqFjIQU9khygedaRY6wVBduQbJ3Y6AAWPBPa+p3cnAUsmBRGQV5vNoGKyTSYHgYpllwBgLc8KgYojINExNmDbhWI5TiEtwR1hUCuQeYtjI3zubB8Aaml1k0G3JCIOM+txDUmH2XRDR/kxujEuwQGxQ0NiJ3VjdacRa1CubVAXdQhUCXQDMdlVSKsSIcekVGVwAIP15yPgK8AAyL8D4ltZ7EQB4gdhyQhEMciotdNdd/MTUAsBzX0OD///gC/XnAQISQJAB0mw7VZVPNHpAx+Co1ZVN/YIgRtFHfidyGFn3egbgYtBowYAo4jzDgF9sXb2qewhpUQIoVCDEp2WbAuKcepnv4zTNVwHH1C/A11nyVa2cdc3X8MhySABz5UGGbKNCWUrtgJrZRFxcy1seYDicMVpYXEsmMGGAsMGyesY+XAjR1RRk2ZsEkj3xQdPZ0th7rKo2BdlUWgZT891Dy1vI2OxGUM6N3IzZHNSEgDsSW0bG4sK/Wk7cE3N4J0VP20PlSWh62bvAywT'
    $Base64String &= 'Y08wSF/vN7Fxb/1l2OG9ldXF1SG9jV12So1FY99w1+NN4EvjbQMHlL1mp9sJiTuQnfDcYe8LCW/VxoVUxHOnLpcgpPMEwwBOJ73TSn6RADkAK4sfwnZw3xkPABUAFB1rA2WHSU10Aykbgp/qQ7YZnmwbKAAiTYXsG4jT/AAHADMALe2m7AIj6zozPXJLshmVT+77yAhJUDxyDtgA1+GsQTob9XQBZ0ErWEGEldvDIH/ubB1vDUCBHBsgIQpXgR8tI491WAADc58AHuvHVjKeA01P91UTMrItJHsrL+xM2UhTRDVuL0AbFu6M7iUTI2qQkQtR70hnZMhGA2UjYvDCFgIUBSeBVGTkc/u/QUYubFeE+vJHCKkmxweAIIPCss4/fACmABoADf9LWAiBbpXBv28UcdZsH7tDBVLGYbNsN8t9JxznygATN2WPa9lAIiGzPxeR7sXYYbF57wd3SepOp2y53z1lvb1OzF4NDxtlLDs0Z3kuVQFpbFmPJeUPFxd3tpKw+w1iY1ScXrKVbflhIyxJrcP/ewxSd6gpCKNXETVLWUzWYXOtS2s+9y2HKDEHcHgrBPAA0Is6gxmEYM9juomoCLakm4TYIA+93QNpKD+V0IvADRcZL4HJPsMQpedhkWKpMk56EcnFGY9gFjwYYXFfUhRL+LttnxVaCFAcEsVdpy4wRwJh+1nFznBjDVwHAW19C6CQ8Gt105uyqHiuLaHfhQ9vJRDFk10g4oWECVXLrxRFQorpZMi2hOUdbsNpXK9ZrIHJs3ZCBCq9NS4BHQc2IXUABH9ii4vsAf8ACSHcIcQbeOfNFxNenGb0nR0bP+Jc2RC3LxEcYMuK6yMWEgxbEk0TE2bxKDZI9/fVjKawr/MULVY5DFnTm2MpA1gnGcDKWUSxbcEkdYWNAAshQhSDMU6JDyug47IBHwqJUDCiODLdC+HgMKI4IOMPwohiSLMgu4whkewMV/GT0ZCiOAyPbPYu40VVZLkZM40s'
    $Base64String &= 'KIYLEV8AaTs1Kw47h1VxVhRjHQMLExHFZUTPILBJgpH1MxUnC2BEkfkrkCHrLgcJMQ8yNhCoGA3lR6TPDdh5GwbbgXTDwC6wYAtVD9sh7D2aU0W3+wQXWZBMAA++WHeRvwtFbolXaI6wYBKhDB8KQvaUMlvpCRUOW2AT43MAFUY2CAuVANhJuwXvC3NInAVPB3vVPPJGAE5BAEcDfwdD81jHW2YXUgBtE7ORx9pYSQ9TKQd6AGqbx5rmawBMB1s3dABEgwAjFdCAcZXNAYg+EHWjQAU0ARlBlR0EAIqhICpNIaBSXDqAwEHVfJtAkAwMUmVhZO1GQINNbXJ5Etl2R0BJdXJyJHQlB/aXPUV4aQxTbGVlcCZUcre33WhyRUlkE1dpbiplYzBbuzUCpVpzbyAzVBMIerd5cHNXMHQC+tj2SGFuZAVBEVN0YXL2GAE1U18BTG9HvwB2+0xpYnITeVeIYkRl6Q4EbTp03yFTG6xrbUUgtVdlTmRd27e/Ng0iVGltA29TeXMxbQ1rS34LAAEXIf7FZo85TGFzSw1wQWRkcq6AlsXwSSy2UNGybDbWcKrmomjZZRAXv/pmKQvv0CdGb5g9CHIPMWRvd3P2b9jbRGk5Y3Rv9lFBdHRySvTeZOF1dKZXFB20bmEQ4h1XKG4IHyYSQWNreKC5WRIMmCy8oQvN/bYKTT90aUJ5dNKAOkPu2wrdaGH2bAA0cIFGlP622WFEVxhBbppsb2Itm7DdQ0FsBmOsascSNsGXW8ovVW5eIyE0a90ltiYka8F6hI8jN7wC2kRwI65pemUR3mzZb2ZlUORN23C25ERhdAhNsmFntvQtIdhJJxFWJTguVM5pb6VoCMKyvWNZQ3Op8DrcwQFpdl0IZiMLYUPYi25nahs1gfQaKdWXC6RZKryIz4wcAN6sLYQGawu2Cf2wLIKa/2dRdffc4be6eRRLZVoROwyzZe89yw5nDi+LDWuFViwGEeIhZPg0m34pIElt'
    $Base64String &= 'K7u9dRB1Xx9wbGGGSWNuGJhp2RYEDsw0sM9QAP8RFIUMpSFrbUPi8DxNVkummWvLQjjt7HMZBbkZ85NG3GxtIdRypZc20MIAeJAWZoG8eCRTYXak02zL7r1DRPBezHFHC09ianIPNM96+9pJdDNvQ3QzMiVCawyCJm2cbNu6LNYo6EOxDjxhbQ3Cvmm9bGNgzWHvREM6E1NjLNiG07C5/6BibCvCkGZvfWh6TYZFaoUbyhKJs81ms6xjT/hajW3bT9xfX3ACY1dtJF/C2xouMGp1SGZBdhu+1rWPhj5lFWgFZF/iWvu5jY50EBx3Zx0ZGze30BFKZ9kOY23LbgbrzAK7ZQ5jB1jBnHuU4vU0DBMb1oJ9c2ZxsBQ9WsGVbGwMATPs7rHW7QlwdcthGmFzbHdG2mu3WR4HcXP4LDEzXaEV3QaqxHaTbFtsVi++0XBsdCMB9RwRkg9mjnRrsXCJoJhfaIByM9agC/YdnWVjYAd7XaxvgWbBrWaCajY3c25pBmueJBF113z/75w/PzJAWUFQQVhJQFoNM1gOsZjLPQ0t5yy3scneew880EZydNx777VfS8wQMirEtukRzg9hGG53cP50ZhM2mwU3bhTMZWDBU0gKg0GwYt5TtWsGThQKINUGEMFptiFXOHFwlsEkkhha/mtacj1B58tya2Qjm7UO3p0qYa4ragWDWW1wTHRb0qyw8QxkbmZWEBjdpAW6EkSFdyuGREugOUqsx0E7TcAQiVN6z7UcYwicC1fl4kJygWHtbYpowlGHzJG2wVrrlEagbYGYqbBsalRuaAxeSE1PIthsaaNSTNydMAs3FmWwbGdJ2zm5AH7LHE2SxGlhAHhnnRsCbRYtAJt4LtksIAQ6AFsasAJmYIw5AFzMbQVaFK6JAGR+ikKYJflVAHBkhxOyGQhCAEAoT2XIljVsAF6tJCk2IRaDAEPbVScUWuxzACALsGtBME00ALVjNwJhQnOZACFgYK3Txl6AAAWE'
    $Base64String &= 'jxJXWzVQADMwgex/DuFgAO5U3Q9AQm9dAIFhB95k5gquAIawEt65VOoxAIFGMHalMRmaAICbDZgzAZq4AH2Y5dRwYlJyAGSXYRAMQR2xABFM2SNY6U35ALoWOwPJfrP1AGl1YgtLsGStANJFhSROSkJBABPeIuW7gsR7AG8qkObjzDVgACcUOE2CdthAACLZcK9RslnMAGC6BD3Zsg3HANAVa3UOY1aiADBSNpYTk3CAAMgwWT2nYbNkANQWE43JJgxIABxzeYgxbAZEAAenC10QlmhiAB9r2HDvLYxlAMfES5Va2Lu9AFfumGZ5DN9sAAOT9IAoQ69JAER2fLSdkHhLAJ1snHKMkdVsAD1CbjBScCxjADYSkYEes61WABMhdHBHrw2kAAIterjsJhwsACFDZElzIlliAGHLG3ETfBAKAAKnwES6DoVsAFnKFMdELQvnABgR+v8uqmZaAMhMAQQAxoPKAF6oYhhRBT1rALYXdgsBCAy6AK4TEMQgzr7uAAQD0A1ACwKRAN1sZj0ABwywAAFsYGfv8D4CAB40EAcGl2c5AJY3VPHIMPBxACE/hVX3wNMAAAAceoXtAqeUAAMeLnQv2JEiAFMNuJDrNTq4ALAEIyCsLuzSAA1yM7H7GjQ2ACe+z+51F0ACAC4mT1AaAWhTANJsJwb0wE9mAHPPmT8L6/NPAHKDELyS+gCgAM/8AAAA4KwBAAAAkAAA/wAAAGC+AEBBAI2+AADQ/v9Xg83/COsQkAIAigZGiAAHRwHbdQeLHgCD7vwR23LtuAUADQBIBBHAAdtzCO91CYQDc+QxyQCD6ANyDcHgCAFAD4Pw/3R0icXFyQvJCgN1IEEMBwoTAIPBAoH9APP/AP+D0QGNFC+DgP38dg+KAkIAJQBJdffpY////wCQiwKDwgSJBwCDxwSD6QR38RABz+lMgAVeifcAudsEAACKB0cALOg8AXf3gD8AAXXyiweKXwQAZsHoCMHAEIYAxCn4'
    $Base64String &= 'gOvoAfBBwQ4FiNji2cA/oAABAIsHCcB0RQCLXwSNhDC4AAACAAHzUIPHCID/lqABAgCVgBMACMB03In5eQcAD7cHR1BHuVeASPKuVf+WqEAHAcANB4kDg8ME6xDY/5akAASLrqwDQAGAFfD//7sAEAAAAFBUagRTVwD/1Y2HBwIAAACAIH+AYCh/WAhQVFABBVhhjUQAJIBqADnEdfqAg+yA6Sf0/oBmpxoAABwAAAsAYTJoAAopgAoAqOAAA+AASAEEAIDhAwgDAIAFFeAAeOAABuECBACAQgnhBAUAgAzgAOiF4AAO4AAoBgCAQBTAACgHAIAY4QngAF3rDAHiDIAC7gIJAAGYoWEKNwEANIAE5AMDUewUAwBuoADQ4AeF1eAA+OAAhuAAIOAU7QkKDQAB6CAB3DgBAC4ogBHzCeMOEOANBFE4AQDYIAL5BEAJANy1+gQJoD0AQUDiJ8jkJ6bw4ADhJxgC4ydA4ADWB+Ej4AAI4ACQ4ADhKXq44AAKwWrgAPEZAWescNcBAKiALPUU4QTgweAEWOgBAGhgAfkEcgiAFcTs4CP2LeMEMLngBPDt4AmAGPkEWOAETFzz/w6BTMj3/wmo6eAENP3/CdDgBGFr/Qka+OAEDMBm9wkCAGZn4VfgXGBhAFDgAPFAQMGAO1yGAQDW+A3hBIJo4AQ0jAEATOAOsfMEBABpYV7gDGvhWp3gAHDhWuAAYGwAIOBsBfEYwOAKgI4BAKIH+FXiX+AEJI8BAJYL9g9zAhAwALyRAQAO+v8E+y8xKJIBAJpXcAV/AgEAB/I9kHALGtvxLHAAIPEscAA/cURwQqpAcAAwcABFcABYcAA+RvFAcAD/BnARMABUli4B8TT/BngC0DAA9JcXcCz/C3oC+DAAHJgBLAAY/wR6AiBwHTSZWAEAzP8EegJIQT2aWAEAUP8EegJwcAJQXptDSn8C+E9wAtBwAnJrfwJ2AmdQAMD/EnIc2OHwA0ScAQAxJP8D'
    $Base64String &= '9wNeAHBa/wfwScBJtPADFKP/A3QCBQBlUABg8ANtcTKIcADxBLBwAPEy2F9wAPEsYCD/CYAAePAFeLALAgAi/wV6AqBwAq6gcAJ/CHsCyHACuP8EtX4C8HAC4H8CfgIYQFnsCAx/Av1rQP8N80/wA/ow8AMY/zH7b/8D8x/wAyBMDwIAavgktFL3cy1xNLEzAZIADwAPAA8A/w8ADwAPAA8ADwAPAA8ADwADDwAPAJSMjiZMScBKKBERERLfAQ8ABw8ADwAPAAAAR0ZGoBZHR0coMAAUMAAAE0hISCNWVVUAV6ijpN2ooaIAkxEQER0RERB+FHAIoX0PAA8ADwBxBkcESAHwBQZHPz4NAEc6OA5HOTMUAEhAOR5JPzodUEdCPyqwATAwAC4ASEJIJLu3uOQA7u3t/rWur9WwEBERFjAA8QcRXwUDDwA6B0hJCEhAPwAOSTgyDEgyLAEhhgBIcX4WSHgAiElHgJNyR5EAqKxAjKawOTYCQlorwb2+9+zrwOv/s62u2LAP4Ac8EA5gACGfDwAPAABMQDcyAkg7NGE8AABGlrEWSYicTgBHh5uGR4idtgBGl7LQOaTK8wAtkLD+RMry/4Aywv3/VFpZsgIAV19TLG18W0UAwcC6/+vq6v9Qtq6w2fAXCjAACHgQEBAhlA8ADADwBiUBMABKNX2VpUiPAKbDRpaw2kWlAMnkPrjq+0DLAPb/Ocv//zjCAPL/NZjD/zSQALXyQoWI/3eFAEjMcoxH2UdeACv/U2FA/769ALf/5uTl/7ew1LHSYBcFMAAEQBAhngMPAAwAQ6DCv0SuANr6KY6t/zbWAPr/ONT//0DEAP//ObPo/ziQALD/Q3h7/0JSAC3/NjMA/y0fAAD/MCcA/yI6AB//IDEf/1taAEz/fH99/7y4ALj/5eTk/7ixfLLRsA+hQw8ADwACADEAxf//K7Tm/y4Ai6fkMH+U/zgAYV3/OEQX/1QATBH/PjUA/7a6AFtVFP9d'
    $Base64String &= 'Xyj/AENNLv8PHAX/ABYjCP8UIAD/AEJOMP95enr/AGdoYv+/urv/AOXi4/+6srPJAgAoAFF9UVJ6nQCQ/1RVVP8rHAAA5DorAP1bSQAn/3x7Uf9fZgBN/0tWSv9HRgBL/0xVSf9/jAB2/2Nwa/9jdQBt/yQ1FP9mcQBe/z02R/8wKwAy/7y4uP++v0C5/2x0YvApf1sAdSvghHVh/6EAiJf/IikO/zQATxr/jZGL/2AAXmj/MDE5/zgBAAMgFyn/TlFNAP9RZD3/LjceAP8zPSn/OE8yAP9qeF//VUxUAP9GP0v/ubW2AP/i4eH/sKusAumNMZSMjiZMSUBKKBERERKNDXcAlFnvi4+J/5UAiqD/HCcX/zoAXCT/VVlR/0kARk7/Q0NE/0kASkn/OTE7/z0ARTb/fIlx/yoAQC3/HCgJ/zsAUjP/YWxU/20AY3L/cmp4/7sAtrj/1dTU/6GAnZ3yR0dHFIABABNISEgjVlVVAFeoo6TdqKGiAJMREBEdEREQChSAQwOFP4OdZu4AfX15/3p8e/8AM0En/0NhLP8AnKGY/0lHS/8ATkpQ/1NUU/8AMy41/0ZLPf8ASFw1/0VmV/8AQko8/zZJLv8AbXZm/5eekP8Abnlj/7GsrP8A0s/O/6Cbm/AFwB4wwAAuSEJIJAC7t7jk7u3t/gC1rq/VEBERFgvAAMEfEcUffJZi7gAYIRH/eIJy/wB+jnP/L08V/0BUWVD/R0TAH0kAVP9dVV7/XlYAZf9udGv/fIYAc/9QX0X/ZnQAaP8mMBj/Z3EAYv9iemb/QGIAWP9tnqz/aZ5Arv+Eh3zxyVfBAL2+9+zr6/+zmK2u2MA+gB8QDoABAgzGH5le7jhIKwD/dXhs/1BhQAD/SGM1/6KmnwD/aWRr/6KkoAD/dodo/5aejAD/bHVe/1BlTAD/P15M/z1oYQD/PHFz/1GUqAD/PaPH/y2PrwD/RMry/zLC/SD/qqWl7cEVV18AUyxtfFtF'
    $Base64String &= 'wcAAuv/r6ur/tq4UsNnAXwrAAAgQEAQQBsd/WO5PVUgA/4mUgP8uRRsA/0heNf9rdl4A/2mCWP9Tek8A/0FxT/82bWsA/0R+if9Di5sA/0uiwP89tuYA/0DL9v85y/8A/zjC8v81mMMA/zqQtP9ChYgA/3eDT/lyjEdA2UdeK/9TwDO+AL23/+bk5f+3qLCx0oBdBcAABABBAgLFH2+LVdNxbgB5/5OZif9NcAA1/1V0OP9gegBO/1VrQv9IlACi/0Ws2P8pjgCt/zbW+v841AD//0DE//85swDo/ziQsP9DeAB7/0JSLf82MwAA/y0fAP8wJwAA/yI6H/8gMQAf/1taTP98fwJ94nLl5OT/uLEUstFgHwHtX8fQtwDCoZun/yA9CAD/c5Rc/3xzgQD/RkxA/1iAPgD/McX//yu05gD/M4ag/zB/lAD/OGFd/zhEFwD/VEwR/z41AAb//5L/kr7HvMKdAJak/ytME/9wAI5a/6aPtv9sgGty/1V4Sv/lkgAxJAv/OisB/wf/kv+SDQB2kVrgOABDMv9PU0n/agBwaP9SW0P/WIBnRv9aci7//5IH/5L5kgEAfqNX6VsAfjX/aXxN/3cAklb/ZIk5/3DomUj/4FL//5L/kuGSgOPi4v+zrq/yHwCAol26gaxT3gB3pEqKdqNJWgB8pUxCdqJKGwv/kvCSS+CSSi7/cAB5af+cpJb/cgB/aP+/u7z/5PHgD7Sur+JyHwD/kumSAHB2bf+Ai3f/gFFhRv9od2vikgBqcmD/bXtZ/wA8Syr/vrm3/4DGx8L/hol96pID/g/8kneIaf+dpwKU4pJRYUP/PEwAKv8zRiL/IjsAC/+EjHz/jo8Ajf9we2L/takAqf/c3Nv/sqwcreu/DunS95JWdj8A/0BjKP84USAA/zhJLP84TiMA/4KKdP87USgQ/0ZQO7Amrv9OBFdG8A8r/7OiowD/ur22/3h+bx7hXwYPAH9Jf0lXdEMA/3t3ev9B'
    $Base64String &= 'P0AA/2uCXf9BTzQA/3WCZ/8uPCAA/1FSUP+SoJUA/ytFGv9MT0cA/7Genv/m5eTg/6+qqeBfBg8Af0kBf0lzlVn/tqm9AP9mXGr/XXpEAP80SiL/kJyKAP//+///Ki0fAP8bRTf/KjswAP8xLiL/rpeYoP/h39//8G/nXwYHDwB/SXtJWHdI/1YAbEv/hYGF/2sEb2uwKYr/LjsdAP80RCr/hIt7AP9GUir/PE8dAfBDO/9kgj7/qhCQkP/k8D+2r7Ae3l8GDwB/SXtJVGBEAP9LXjb/TGMtAP9aeDf/d5NXAP9yk0r/cJhDAP9wmkH1gKtNAMGBrVKhf6dPAIh8qFB0qo6PAP7AsrP+u7Kz4Nu8sbIfnwYPAH9JAXdJeqNM+4KsUwDUfqpOrH2oTACFd6NKX3ijSwA4d6JLKHagSgH+ldfFypeskZIA/7qur9q5sLF/PyAPAH9JeEmfAg8ACQDgANnbGq6UlWe3gJ+g5MO0tf1wIOD/zLq7IZ8CDwAPAI8PAA8ADwAPAAAA/wIAAPj///4AP/+AAAA//CBwP/IADEA/ABIxAP/gAAFk/8AzAOPA8AIzAAGmwDAAtAAAAzAABz0ABv8/ADUAA/8AA8MQ/wP/wJEHXGMBVAAocAQQMAAgMAABH1IADwAPAA8AeLYKLi0MLQ6fAQ8AR0NCBQBHOTUISEE9FABHRUUmR0ZHIgCpp6fGX1xcZxAQERAPHwMAAEoAOTMGR19oC0gAXmU6R4WZZz0Ai6WrP6rP1kYASE0GYm1XHNaA1NP9Yl9fc/CdAgq9A0SbuTk6kwCzuj+z0+c/tQDm9z2nyP85dwB4/zRWT/xKXygz6VwwhdHws2RgDGFq+ZkFAFSfoJQANmx48j9VRv4AWVwx/0pJKv9AWmNF/zpJsIBFACj/U1BV/8fEQMP/k5OKbp8LAAAAeINb811YVxD/VGVGcItM/zYAMDn/VmBM/ykQNx//T7BrXlZiAP/KyMj/iIWFAnyw'
    $Base64String &= 'uw6GgYJWRRhCQzrwsrKqZXRUAPZoc2H/WGpKAP9LR07/UEtSAP9eaFT/T2BQEP9MWENwOmz/lgCttf95eHSER4BERxTV09P2sBAGdbAQIR4AXnJK9gBfbFH/Z3dZ/wBxgWz/YIBr/wBQeHP/QYeU/wBBpsT/NaPK/wA8qMr/hpFpsABXZkac1NLQ/1BjX2Bu4AMF8QOSAJmL5Vx2SP9dAmswiJGI/zOdwgD/NaK6/0GBgxD/RWRPsFkg/yAAIQP/JjYb/20Abmn/0c7O/4EIe3xn9Q+CjHvoAFVnR/9vb2z/AGt/Wv9SSkH/AFVVM/9aXE//ADo5Pf9aZVL/AElWR/9LW0D/gEI7Rv/Fw8IwdASHdvZQm0/gc5UATbhxmkWXgI8AcPtXW1b/W20ITv9IMKBCP0P/CFFdRvB3Mv9QYABH/3t8ev/QzQrOMY93nxgAAFJmAD/2bnpk/1tsAE7/aGVq/3N2CHD/a7CeSlo//wJNMABpdFz/xcFgv/+cmpX/AwAAaQB4W/BleFb/WhJwcKJ1RzADQP9HAFo4/1hmSP92AHtz/0BNNP/BgLi2/5OUjHDfAwAAALCyr+BLagEwc256/15+Sv8Ag32F/09jQ/8AkZmL/zFEJ/+ARlcy/8e5ujFrAnHxApy6AgAMAGF9RvJmdABV/195Qv9mgwBG82iLP8x2mwBNpXOdRoyArABPWH2nTz+7pcCn5Lqwsa0N7AEAAICnWGZ2o0k5MHmjSxcRPgEAx7YAuCC9qap4wLQAtUj/z6xB+AeorEHAAAOAAQMPAAMqAAgDAQcD8AwD8fiArEHEZwEAKABTihAAAyAAAwEABAJjEsAVfACAAgIAgIDHAwaBAAAEwMDAgAOBCOL/AgEA//8DA4EAAQkTAQIXAIiIAgMId3fBASEAh3d3eAMHAgiVhgN/hQP3AxSH94ITH4YbhSMTAINDgwH8PwAAAPgfAADwDwD4AOAHiwGBCYENgRGJGRTsaI2VCJlp'
    $Base64String &= 'AAB2ALYABn63AAB5ALoAAH++AAWGAL8AAITBAAGAAsRAKscAAInJAEAUksMAFJPAA5gA1QAFmNQAAJkA2AAAn90ADKoA1wAAot0AB6WA3gAOqd8AF8ADACOw3AAqut0AACm/3QACoeAAAAGn4AAGp+IAAAOu5gAFr+cAIAq46QAPwAAOvwDrABe85gARvADqABi/7AAlxgDfACnB3wAcwgDrAB7G7gAkxgDlACLH7gAoxgDsACbP7wAm1wDnADHZ5AAy3QDmADbR6gAy0wDvADXe7gAx0QDwADfU8QAw4gjrADzAAEXN5gAAR9PmAEbV5AAASdLpAE3d6AAAUd3vAELb8gACRsAAStjyAE7ZAPAAV97wAFXkAOoAXuTrAEDnAPEATev1AFDhAPUAWeP0AGHnAPYAZOX2AGrhCPEAbsACbur3AABn6/gAZ+z4AABs7vkAcufyAABy7/kAdfD6AAJ9wACH7fgAj/AA9gCN8vkAmfEA9gCe8fUAk/IA+gCe8/oAovMA+ACo9/sAs/aA+QCy+PsAucAACNT/0caaFC8AAAAiUAAAMHAAAAA9kAAATLAAAABZzwAAZ/AAAAB4/xEAiv8xAACc/1EArv9xAADA/5EA0v+xAKrkyA8mwA9AwA9awA+qdMAPjsAPqcAPwsAPqtHAD9jAD97gB+PgByrp4Afv4Af26AcvJgAAAFBBAABwWwAAAJB0AACwjlAAAM+p4EvD4EnSABEA/9gxAP/dAFEA/+RxAP/qAJEA//CxAP/2VegHFOAHIuAHMOAHPk3gB03gB2AJ8GngB3lV4AeK4Aed4Aev4AfB1eAH0uAH5egHA+AHwHlUcAbgBwngBwrgBwwF4AcO4AcgEgD/PlXgB1zgB3rgB5fgB7YF4AfU6AcADgBQAAAXAHAAIQCQAAArALAANgDPAABAAPAASQD/EQBaAP8xcAD/UQCGAP9xnAD/kQCyAP+xyAD/0arf6Acg4Ac24AdM4AeqYuAH'
    $Base64String &= 'eOAHjuAHpOAHarPgB77gB8fgB2AOkarc4Afl4Afw5gcsIAiqSyAIaSAIhyAIpSAICsQgCOEgCPAR/wAA8jH/APRR/wAA9nH/APeR/wDA+bH/APvR4Y3jB6ob4Act4Ac/4AdS4AeqY+AHduAHiOAHmeAHqqbgB7TgB8LgB8/gB6rc4Afr6AcIJCAV4AeqG+AHIeAHJuAHLOAHqj7gB1jgB3HgB4zgB2qm4Ae/4Afa6AcfAEYYODU/AEwEAEsVByAHBwMLOsQBTRSADRIaGA4JAgQCAC4QICUiHhwPBAgKQgZRJCcvMkAxKCEbDAHglAAAAE83SEVEPC8gJh0RBDXhAVA5AFVYUkc7Kh8ZBAY44gc0Vl1cV0BJPSkTBUbiAUMAQVtdWlRKPhYBBM1RQkBVWVNOCDYjTAQQUUMzLRgsKzCgTgYAUE9R278aaa38aazgUcBoAOEB5Wmu/uitVG5traEAHwAQCOn3AWAAAwnrAPgICez4DQnrpPkQYwD4DuABCmADIAUI5/cBcgfo9wACCer3CArt+QAWCef3LQjl9gBCB+T2Twfj9gBQCOT2SAjm9wA1Cuv4HQnr9zAMCOb1oBdqBwEKIfAFCer4ITEDBuMA9n4E2fGgA8EA47gDvd+8BM9A6qoF5PaKsARgxbAFLrACDwjlNwRwAwoGsAUf8AFZBN/0AJoBpNfcAH/EAPwAgcb/AIHEAv8wZP8AisDrA+jO6bCwBXExBLAKcQgWAXELMAsRMApFBeJA9ZUCotTpsGT/VbBj//Bh/7Bi/3Bl/wHwZv8Ae7b5A87c6LBxCLEM8AMFsAcxAIIgcAVtBcblzbBnqv/wY//wYv/wY/8wZWr/8GX/cGn/cGtwBL5G67EM8RAJ6fcxDwcB8QgF4/aFHL7dKvDwZf8wZP+wY/8wqNDw/7Bm/7Bo/3BqCv9wbv9wcf8EzukWqjEV8AMO8AMICeYE9zQwBY9E1eT8VbBh/7Bi/zBj/3Bl/1Az0/H/'
    $Base64String &= 'cGv/8G3/BTBx/7B0/wO83bwrcRnwAxD0AzPwA41KgN3o+prx9//wYar/sGP/sGb/8Gn/cG4q/3Bx/zBz/zB4/wMYwuG4cRr0AwYJ6AT3KvAPfyjf6edBMGb/uvj7/zBl/1WwZv9wav+wbf/wcv8BsHj/A4W//ATaVPGg8CFD8AMNMAAEBbAUG/AIYQ7k8rtQXeTr/TBp//Bo/1Xwaf+wa/9wbv+wcf/B8Hv/CLXY3PEhMSYQCej2CDErCu75CbAc9zcwFIIW4u7A0VTk6v2YcAgwbir/8G//cHH/sHf/EYDB3ekE4fSasQtPcSo1JDII8gD2RHAQggoNcAgbsAwu3eb6AC/Z5PwZ1ebwAATX680F4/WVZzEmcSqyB+b2sjDwAwHwCur3BjIEcAixDPEQ/zEVcRmxHfEhMSZxKrEusAfGAjkwMgTp9gSxDPEQmzEVMA4zsR3zKvggcSrhcAIGCOf2ugN6BLA0NTARBPAtBrIdMQDp99YHszt/A+DxrwN0rjCvXgA/ADoAdbExA/DwsrwOcn+dDwAHAAOEHgAEAoowAI4hAAOWACUABJUmAAiTACYAA54qABiaADUAGp88AAOmAC4ABKoxAAqoADkAGKI3AASzADUABbY5AAW9AD4AE61FABSuAEYAD71KACakAEQAL6dPACeqAE8AKLFVACO5AFgAOLJbADS9AGYAPb5wAEq3AGgATbhrAEu/AGwATr5tAEq+AHgABsREAArHAEcAD8ZNABrPAFwADNFSABDTAFYAFtNcABzTAGAAJ8pkAC7IAGkAINZmACPZAGoALNhxADDWAHEANtB0ADLcAHgAOd5+AEvFAHUAXsl+AFrRAH4AO96AAE3GAIAASM+BAFnGCIcAX3AAQN6EAABL3YkAXtqUAABmx4QAa8SFAABnyIUAbsWJAABgz48AZc6QAABuz5oAaNycAAB50pcActCcAABL4YwAT+OPAABT4pEAXeabAABi4JoAdtqhAABn'
    $Base64String &= '6KIAbeimAAB94KwAceioAAB066sAfO2xAACA258AgdegAACK1qQAgN+hAACA3qcAitqnAACB3asAk9+vAACN3rQAg+CrAACI6bcAkuKxAACW4bIAkOK3AACa5rgAnebAAACY8MIArurGAACj78gAre7OAACi8cgAqPDLAIC48NQAwvTbf53/f51/nX+df51/nX+df51/nf9/nX+df51/nX+df51/nX+d/3+df51/nX+df51/nX+df53/f51/nX+df51/nX+df51/nQF/nQDYvIIAEgA9Hx45VgZoAD4UBQcHBA00AQQ4QAkMEyMiEAQLBgRAGRIpLi1AKyYhCghTARxVABcqO0lHMSwlCA8CMwEeWCA8TgBRTUgwJxADHAEBHlo4YGhjUkogNSgQAx0CfkJbAGlqZ1A6JA4BAj8CD1dGYmZlXRBLLxEVA19kTEOAWU9ENxgWRQSAAGRcQTYbGjJUMQiwYV5fE8kNAP//AQMD/B8AAPAPAAgA4AeAAQMAAMDfiAGBB4ILgAGBEf6AS4UboCR4AQAogCMQgAEaIIABAYICHwATl0IAAROZQwMTnUYACBahRg0UqEwAEBWtURAZs04ADhuxUwocuFQgBRy5VgGRHRGVAD8CEphACBWYAEUWFplHLRSiAEhCEqtJTxOzAE1QF7ZRSB65AFk1ILpcHR66YFsMHblXgF6JHUAAARKNPwoUkkIAIRKYQk8PoD8AfgynO6AKpjYAuAupOLwPuEMAqhbFUoobwVcAYCG8Wy4frVkIDx64xxARl0EGABKVQh8Olj5ZAAqeNpoElifcAAKUJPwDnSr/BAOfwACWJf8FmwAn6xC/RrAawgBWcSK6Wy4gtwBaDB61VgEanwBLAhecRhEQmABCRQidNpUFlgAq6QqoOf8PvQBK/w/GTf8KxwBH/wW+P/8EqgAx/wORIfkQvABEsB29VmAmtgBcHR2zUwUiogBSBR+hUSAToQBEbQigM80UrgBG/yfK'
    $Base64String &= 'ZP8w1gBx/yzYcf8g1gBm/xDTVv8GxABE/wOmLv8FkgAk6xa9T4ogsgBWNR6rUworrgBeBy6sXi4gsQBShRutS/AuyABp/0vdif9T4gCR/0vhjP853gB+/yPZav8M0QBS/wW2Of8CigAe/w6vPqoWrQBOSBipSg48sgBpCDy2azQwvgBjj0i+d/xe2gCU/23opv906wCr/2foov9P4wCP/zLceP8W0wBc/wW9Pv8CjwAi/wqeM7wSpwBHUBOiSRBHugByCEm+dTM9xgBwjVbFhfqQ4gC3/6jwy/+Y8ADC/3ztsf9d5gCb/zvegP8c0xBg/wa8wA+NIf8ACZ0yuBGjRE8AE59GEE3CfgYAVsV/KkvLfX8AVcmF543etP8AuPDU/8L02/8AovHI/3HoqP8AQN6E/xrPXP8ABLM1/wGDHPwADqg+oBWkSUMAGKBHDVnIhQQAYcuOG17Qi2EAU9KIu3HQnP0AnebA/63uzv8Ao+/I/4jpt/8AYuCa/zbQdP8AE61F/w6aNNwAHa5PfiSmUi0AHqVNCGDMigEAbtOWDG7TkzcAX9aRgljSjdEAbc+a/YHdq/8AfeCs/2jcnP8ASM+B/yO5WP8AE6M/6SK1VJoAK61bTzCpXRYIIqZRYkhr0pMEAHXVnBZv1pdEAGTYk4JX1o27AFDLhOdKxX76ADu+b/wouV3wACC4VM0pvF2VAC+zYFkyq2IhQCqsWggnqWNhbQDUlQFt05EGegDXnRZ015k3aQDWlWFZ1Yx/SgDSgI0+zHSPNwDHbYU3vmltNwC3aEU3tGgfMoCmXwosrlwCaWAQcdaYAWAABHfYAJsMctSZG2XRAI8qWM6GM03HAHw0RcN0LkG7AG0gO7puETS4YGQGMbNiagcJAGwA1JQBZ9ORBGAA0o0GV8uECE4Ax3wIQsR1Bz1AwG0FObtq7gbgAAesQcADrEGAwgFgAACsQQB8AGEEA2EFYQbwD6xBjHwFbY0IeowPDqIAEQAR'
    $Base64String &= 'owASEq8ACwALsAAODrUACgALvQASEbIAHRQdtmADuGAAvwAhACGsACsrrAAmACWyAC4utwApBCm6YAXEABEQxRAAFBPE4AfJABMAE8wAHx/KABQAFNIAFhbVABlAGdAAFxfa4ADaAAAgIMMAMjHFAAAkI98AJCTfAAA3NtUAMTDaAAA9PdwAMC/hAAA1NOEAODfjAABCQsEAV1fGAABfX8cAUlLMAABPTtAAXVzUAABRUNkAYF/XAABpacoAcXHJAAB2dssAbW3YAABwcNEAf3/SAAB+ftQAd3bYAAB8e9kAeXjcAABKSecAU1LnAABVVOkAYV/rAABiYuYAb2/jAABjYuwAdHPuAACBgdIAhYbTAeAA2QCHh9sAjgCO2ACFhOAAjwCO4wCGhugAigCI7QCQj+gAkACO8gCUk/EApgCl7gCop+wArwCu7wClpPIAqACl9AC0s/MAvwC89gDHxfUABgBwAAAIkAAACgCwAAALzwAADgLw4C//EgA9/zEAAFv/UQB5/3EAAJj/kQC1/7FwANT/0eDCAMMAABQALwAAIlAAADBV4Ac94AdM4AdZ4AdnQeAHeP8RAIrgB5xV4Aeu4AfA4AfS4AfkVegHJuAHQOAHWuAHdFXgB47gB6ngB8LgB9FV4AfY4Afe4Afj4AfpFeAH7+AH9ugHLyYABABQIElwWwAAkAB0AACwjgAAzwqpYNjDYNfSEQD/ANgxAP/dUQD/AORxAP/qkQD/oPCxAP/2+AMU8AOqIvADMPADPvADTfADqbAE8GnwA3nwA4rwA6qd8AOv8APB8APS8AOm5fgDED9QBPADBvADqgnwAwrwAwzwAw7wA6AgEgD/PvADXPADqnrwA5fwA7bwA9T4AwAADgBQABcAcAAAIQCQACsAsAAANgDPAEAA8AAASQD/EVoA/wAxcAD/UYYA/wBxnAD/kbIA/0CxyAD/0d/4AyBV8AM28ANM8ANi8AN4VfADjvADpPADs/ADvk3w'
    $Base64String &= 'A8fwAzAHkdzwA+VV8APw9gMsEARLEARpVRAEhxAEpRAExBAE4QEQBPAR/wDyMf8AAPRR/wD2cf8AAPeR/wD5sf9QAPvR//YDG/ADLVXwAz/wA1LwA2PwA3ZV8AOI8AOZ8AOm8AO0VfADwvADz/AD3PAD61X4AwgUEBXwAxvwAyFV8AMm8AMs8AM+8ANYVfADcfADjPADpvADvx3wA9r4Aw8ADQA/LTEB2AAvDQQFBQMlAeYABxIYFxYUCQPQGuNEFSAjIh4ZDBQHYCVhnxshODlANyQeFwoLswQsADs+Pj03IhoRAUOLQzZLT0k+OQgjGhCEUDRMUlFgSjojFwYgIAEAQQBFTVBORzsfCAIuBAY1REhGPCsEHCcGCUIwKiko30KjDwAPAH+dcZ1/8CawndrgtJ3AOAA5nfgwAjUDeTEA9IF/nQ8ADwC2Vw8AqQIREa8EFRUAswUXF7gFGRlgvwMXF7//nAwACwALogINDaMLEQAQqBwSEqwrFAAUtDIWFroxGAAYwicZGcUWGRwZxBALDwABAAkJoQADCwuhFg0NogA9EBCnYxAQqwCIERGsoBMTswCaFxe+exkZxgBYGxvJLxgYxQYNvQiwAwEGBpsVAAsLn0oLC6OPEAoJqOEwY/8ODiC2/w8PtTAArvsQEhKyyzAIdBkZYMM2GBi/0DwHAAgACp8JCAieOgmoCaKOcAP2cGP/MGKg/xcX1P8wY/8wZCb/8GYwAK3fsANtGEAXuSQVFbYygRcAGKYBDAyiFwmACZ9gDQ2x4XBmAv/wY/81NeD/MJgv4P8wZXAE2v8waBD/ERCzcACwtRdAF7ZFFRWyMgghACGrAhwcpyUaqButh7Bo/3Bn//BhAP9VVen/SkrnCv+wZ/+waf8VFdeB8Ae//w0NpelwFSBcFRWtE3I+La4AAjEysyw2NriCn3Bo/2Nj5/9wZGkwAO//MGX/8GZwCOIQ/xkY2vAHxf8MAAuh+xMSsGUUCBSrF3Ir'
    $Base64String &= 'NbQCO4A7uCtDQ7+Z8Gkq//Bk/zBk//Bl/3UDMARwav82NeP/GgQa2vAUxP8KCqEA9xERq2MSEqgCFtLVPbsBQUG7ACFFRsF5dXTYqvuwaP9wZ//wZ//waUL/MG7/NTTiMBDWBv/we/ADn9wREaYOVjAA4SkCAEdHwBIARETBVWFh0MtVcG7/sGz/MGz/8Gz/QfBu/2Jh5f9wef8AHBy2/RkZqJ0wGBinOzAABoRKSQDDBUhIxC1KSkDGc2pp1N/wcv/VMHL/8HL/sHX/MHowGQDF/SYms7soKACvWiIiqxobGwKpOiRMTMYMSEgAxTdKSsduVlYAzbVgYNXpW1oA1PtKSc/3NzcAxdwvL7qdLi4As1srK7AlJCQGr1BhCwBOTscBTQhNxQvwAyhGRsUASUNDw18/P8AAaDs7vWY4OLmgWjQ0tz/wiR0wBAO+A3wIBEhIxg5EAETGGD4+vh08ADy8HDg4vRU1wDW5CjMzuf+cDwABE0xDwwFAQMECgD09vwI5Oby/O8EEAPgfrEHg8Jmynd30nQA/AHOf9JzAsKAxnUD8P6xByJyhBQEsAAKQlJNGqHAdAgBWEFAA0QBoMHQDkHzsFXQCAZABEFAABAAoGwABwAGd9QMTAwgAaFAFAAAH+gMI8AMkC38CcAIFegLmugAGAFBBSJ0BAAAAAAEAAgAQEAEBcAgAaAUAAAkBBGggAGgEAAAKRQCcbACcGAM0AKxWEABTAF8AFEUAUkEAEkkATwBOAB5JDQAKRgAWAQC9BO/+FwOmBbYDDj8COgAABCcAAgEiCQB2AgEhUwAAdAByAGkAbgCCZwBNaQBsAGUAWaBuAGYAbwAjUgIjqDAANAADOQIHYgAFKgAAAwgAF0MAI20AqHAAYQAveQCNYQANqmUCW04ASXIAW28AR2J0AA9UABYALwVfRFGAAXMAY4I7cIAPaVWAE26EG2WAB3eAB3JUAGuCQ3SACHKAImErgBeBGlaAFmWAEAAA'
    $Base64String &= 'qCoABYgpVoITc4glYDEALgAygAIBAExrgj+HJ26AJ2yIWKk7aNQAIoAlTIAGZ4IigYJ2cIB/gWZngA6Bd48JIBQAqYABMkBOMQAzrUACLUQDwQAgxEsgRExBQR4AAFwAGsAZT7/EEEFoQRvFO0ED7S4uQAEWeMIMw0NQQAlvAGS0AHXACXTMb+dDLsJhV8sSTWPJYkRCplZAEnKxUJwAACTAqkGMcsKVCnPAB2HKiAkEsAQAhKABADxhc3MAZW1ibHkgeG0AbG5zPSJ1cm4AOnNjaGVtYXMALW1pY3Jvc28AZnQtY29tOmEAc20udjEiIG0AYW5pZmVzdFYAZXJzaW9uPSIAMS4wIj4NCiAAIDxkZXBlbmQwZW5jecIDSAR0QS/EGQQGgAZFHkmBB2l0AHkgdHlwZT0iAFdpbjMyIiBuVGFtAANNRSAugAVkAG93cy5Db21tAG9uLUNvbnRyQG9scyIgdsUQNgQuMCEAIiBwcm8AY2Vzc29yQXIAY2hpdGVjdHUicmAJWDg2YAN1YgBsaWNLZXlUbwRrZYEGNTk1YjYANDE0NGNjZjEAZGYiIGxhbmcIdWFnAAYqIj489i+tFAUbLzMb5wJiIOcHCD5QQemG1BECAFaAYAAJAOHgAYhsAu5V4AGQbAL74AGYbAIFUBICAKBsAhJgArRVbAIdYAK8bAIpYALEtWwCNGACzGwCBQBAYANhAQARAACA4lzkAVpV5ACC4ABkYAByYACQVWQCoOQApuQAtuQAvgHkAEFEVkFQSTMQMi5kbICBT01DjFRMhAFAT2RsZ4QBBEdEZQRLRVJORQFhBERMTABtc3YIY3J04gJTSEVMIUUHVVNFUkQBVkVgUlNJT05iASCyZcBnQ2xvc2XgQKABgkZAS1RleHRXYAGAR2V0UGl4ZYAE4EV4aXRQI0nkAoABEEFkZHICAkxvYQBkTGlicmFyeQHgOlZpcnR1YWwjIAShTQAAZWAHAAAAU2hlbGxF'
    $Base64String &= 'eGWQY3V0ZWQLREMh0QBlclF1ZXJ5VvhhbHUCAx8AHwAfAB8Anx8AHwAfAB8AHABoIUAAAAICADCCIVYGAAkqhkiG9w0BQAcCoIIhRyABQwACAQExDzANBgAJYIZIAWUDBAACAQUAMFwGCgArBgEEAYI3AgABBKBOMEwwFwEYAQ8wCQMBAKCABKICgAAwMbwDAAQgGYL2pDsIABjyVAVBSrJnAGzG2CS61kszAISflUcly1LsAFWMoIILHTCCAAUgMIIECKADAAIBAgIRAPegAKcwyH2UzYMCwOPqf2Ybt0EFpAoEAQsACXwxCzAJAAYDVQQGEwJHIEIxGzAZwQAIEwASR3JlYXRlclAgTWFuYFhzoAAxCBAwDsEBBxMHUwBhbGZvcmQxGIQwFhEBChMPUwAngGlnbyBMaW2gTiBkMSQwIpEBAxMCG5UBUlNBIENvAGRlIFNpZ25pAG5nIENBMB4XMA0xOTARAAIAWhdIDTIz4QAyM/BQOUhaMHHYCUlMBQgRAAwHNzEzNTExIDcxDDAKIgkMA4BMb2QxGjAY0QAACQwRRGFrYXIAIDIxLCBVbmkAdCA4MjESMBABogoMCU5pciBTLG9mAA00AQM4ATCCDAEiORKAFwOCAQ8BQB4BCgKCAQEAALiH5K4VucnMAEIrLr/+ULBfALXRVoLPZ4lxAFAJ0mq0y62TAC2oa+lM3YBqAOs54Us/Olc4ALn/7K4hWg4RAK7jC2C7LB1RAAoxt5jZsPqZAJnUuU0FRgdyAP09miDvdu35ACaOkqfkGRW7ALupI+R1uS+8AEuZV1dLN1D+AN8XHAptTB8JAJYjd0H/mKxwAIeLrSUCOfcEAHnH6rm59FgHAIJYgtpD/yEJAOjpU6Ml3pbPAGQtUyGukF4uAG8gM9R1uCTaAOycHQfk60fFADkGPPM519joAIdXfC1L2uUVABLs7K36tKFgABbr+yHwij1uAIDYXSPPESoNAEQWejmGqVHPAKLo'
    $Base64String &= 'cDtUUxlVAL4bld8qRDPRADbvTAKXbJX3ggIQKgGjggGmEBGIojAf8BMdIwRwIACAFA7hOqhTOgAx1Yq+wbutZwAaA4WtNA4wHQEBAg4EFgQUpY0A1OIK0icPTwcAzhRESmevXMMErX3yHB0PAQH/AAQEAwIHgDAMBfEAE/EAAjAAMBMp0QAlBEEeCEAyBQUgBwMDMBFTMYb4CEIBAVEDBBAwQAFxAiAEOTA3MDUEBgziNLIxAQIBQAMCMCUwI7UDAgABFhdodHRwc1A6Ly9zQykuUF0vIENQUzBDEQQfBAA8MDowOKA2oBg0hjKRAoACY3JsPi7JAtQswCyxLKQsQ0EyLnACMHOVBoAJZzBIZTA+9QAwAvgEdBf/BP8E8AR0lwswAYZDkgvwA29jc3AJBDACHpELEQQXMBWBABNzdXBwb3J0EEBuaXLCim5ldAP8PrAsAQCBcAU2APbFyiSQRMQQAE/vXdLWSwv6AJx6E9TmCtOvAE5ZDHup6aJIAGwd1XLadhdFAAC+Llb8v6FRAIaX67lvO+wCAPxDzGDMIRb5ANwAIa2V5AAMAFlqLrDBCePRABRpaIlE5McBAJxRDFQCtw5/AEpNOXCZmYAIAM40gfadG922AM1a79/wAirxADbUqhF8INaXACJwe5ANpycqAKDcuC2ceTdyADTtrWXsHG8+AOWC23a7LVRMAFlaNb9sHFetAKe8wjKFLO+GAJN4gs3zQs8yAAdnON+AWL/HADUN8ZZ71+l8AB/BSbwY0XQUAJYWn9jOK/FyAAMYIOtT7Z/0ALPmw4o2xD4kAO53NJpFFEXHAGBkcKYlJW38EG7gQ2QwUvUwggQD3TNSEB2iSDAAb5smGNCC4JZQfTPTaikTDCBSgcKIWEhVUzETICgyUkAKTmV3IEpwn2WgeTEUMBKzUQsDAYQgQ0CaMR4wHPNRIBVUaGUgcYBUUgBVU1QgTmV0d6hvcmsQqyxTUiWyARBydXN0c1JlcnRA'
    $Base64String &= 'aWZpY2F0IKUgwEF1dGhvcvAE8lIgODExMDL2UjMw+DEyMyAA81LfXN9c31w/31zfXN9c31yvU6tThiIAjTKFehifSfAAli9jCB4t3HwAnxTP4ya2JWYAKUCGVEZ0MWIAxRDtsocnppkAy5UwwFb1pHUAxqkOUGKlUZEAEGrgS2Ku/fAA+Bisp//uLjMAIPoMGYmobHsArQDDYaHcaWUAbR9uJ5bXl1EAhqb0J+V8aosAlR5bYNV+1xYAkpwAL2j3l+0AanK+ODtj3o8Av25MQV0SIAgAWeg5zY/S1s8ABrRXBbZOoT4AV2sfmLzEYtYAGwuNx2YbSp8AnYHEckC14l8A7wtF/6POF6YALVWwt7C8VGoAnbyNVlPG8LoAeVBJLPc0vQADuf4vZTXyIgDqLAevRtn5RgAc3Ix8cSjz/gCnxhTdVZFuigARDd8GJJV9DwCnoXw62oY1YQDTAgMBAAGjggABZDCCAWAwHwAGA1UdIwQYMAAWgBRTeb9aqgArSs9UgOHYmwDAnfKyA2bLMAIdAUAOBBYEFA4A4TqoUzox1YoAvsG7rWcaA4UgrTQOMA4BPA8BAAH/BAQDAgGGFDASAQ8TAQ8IMAYRAAYCAQADQiUEFgAwFAYIKwYBBRAFBwMDBgkIMBEhAR4gBAowADEGBBEACgAwUAESHwRJADBHMEWgQ6BBAIY/aHR0cDovAC9jcmwudXNlAHJ0cnVzdC5jAG9tL1VTRVJUIYEGUlNBQwAMaWYAaWNhdGlvbkEAdXRob3JpdHkSLgAaMHYFOAEBBCBqMGgwP4UHMAIUhjMGLnQYLkFkZIkCBUNBACh0MCUGIAgBhhkEIG9jc3ABiyAwDQYJKoZIAIb3DQEBDAUABAOCgIdNY1DtRwA0SmGk295qKgCMm/EAAB4dYgB7Otcywvaz4ABjs/thAIiaGwBtEAcET7646gCJeCLrD0bs8wBGXkBGiRL0CwB3WpwqQTr81gD06+f3FZUzwwCh'
    $Base64String &= 'gyi33i/klAD3hTODLUpASAC/msJPSrGPJAD0s4E307dksACmI2pZaFJCXwD/BOvhdGV5CAD1qZPea3FAmQCWunjxucjiwwAIFrGrY1rIFQCAbXReSnV+pQC4w2y1z99KeQCHXMdATWM19gAw08+1Cg4LBAB/oEuuu6Ol0ACEAJM+U100pQAANWlsvp8gJQAQDRn7UJBhvgA5j3qOTfafDgAe/gdREmaDJgAZSJXOSsnBfwDzOgWb+W/fiAB/wCOe0h5DegBFMcGcTanwWQCyWRnoao0pBAACd3xLS81wvgA6slVaeD68uwBvAxAldxU0igD5NsxDkuS6TwDxYpMoJVcp+wBRGcehJUBqhABXxrKdsbwcCgDafGd+fS7pKABMGH7EezFBcQCaSynsCz1XUADSyt39ngVR5QBEeN0B3rF1mAANVCT98E7j4gD4g71yuss9OgDu8F4XkmhtyABh+abxKgoLpQC59J7umDIFhQCe6/mDKdPGLAB9vTp3Los3QgCgaoLtO0qqlAAQpOEN+BfFtgBaeTMYkuO1dQD4oemOCiUe5AAe8Z9ahyP/nwCkUZ77OYARzQDbtcSnqIBv5QBT1ODjosLSWwAa+jImLWpXcAAcPKRYLqPzWwBLB9wyWfOHpwAabVgxghWsMACCFagCAQEwgYCRMHwxCzAJwLsABAYTAkdCMRsEMBkBAwgTEkdyAGVhdGVyIE1hIG5jaGVzgAIxEAHC2wQHEwdTYWxgZm9yZDEA7iECCgATD1NlY3RpZwBvIExpbWl0ZSBkMSQwIiEDAxMGGyUDgFggQ29kZQAgU2lnbmluZwAgQ0ECEQD3oACnMMh9lM2DAkDj6n9mG7dBVmAAhkgBZQMEAgEABQCgfDAQBgoBQF0EAYI3AgEMMDECMABAFKVaCQNEMQzIAwQwHKgBC4gxDjCpAxUwLwcHAAQxIgQgfHOAAL5O7+FKgo2cAHDv3eWKv0ABAJZVMZLZJVbvYMKjAjc1'
    $Base64String &= '6WeAEQQAggEANqzwIBAAEgM1zn7uup4AP4dMXcSy3mcA+HG07bdgBucA8Y/tB0r3O/sAHzzoqUdX11UAHNKqDDVY9MgAvoI3YwqPi/0Ae/BKSrAOpb0A37LbZKINOC8A+K7JdNXReogAunFuQboB8DIAO9rETHtKRMMAU6h8GpvxjtsA/PgBwfwDfBcAC7rIJbw3l1gAFT3jPvpHNgkARZwpNNyv8HcAdRpkOApKMakAFmbuHxY8lX4A3O9HyQanz0gA5Qt8LbV8UywAd1kRtuuyF0oAazdu0Xt9/z0Ap+mZp8ELBasAC+CfTAnoh1gAbBMslKsmh5oAXBz5+CF1tM0AV3zC6pAuGhMA5fXaNIQq3sIAwCIDUW2I82IA563899n6NUQAgklDoYITbTAIghNp5ioDAwExKIITWWACVYYlBwIQoIITRkACQgIBGAMxD2w6IL8MBgsBBTEQAQSggfwEYIH5MIH2YFLkCrIKMeFTMSwHBCBAHQAecRgXsghUpgD4e/FUXtO/1wC/ykg4xJifkQC0HeaGX2sCFAAgR+0vGSnkjwD/7i09lAPUGABRAD1VGA8yMAAyMDA1MjQxNAAyNzA0WqCBikCkgYcwgYSzXwwVuV8Mrl8Mrl8sMCqJol8MI6lfVGltoF9wdGFtcMFfwWAgDCMAMaCCDfowggdABjCCBO6gwNgCAAIQPRo1cjAVAIJjMNATcX6C5EEIDLkwfb92v3awdiglMCOjdhz3FkNBADAeFw0xOTA1A2EqAQBaFw0zMDAAODAxMjM1OTX8OVp/FX8V/wl/FX8VfxXD/wl2FTCCAiIcPBBwIg/wJwIKAqFwy1EAUP9W/vx4Y3AAAZNanhj0O1MA9gevIWz1og8AfR1wLYR0SIsAnIqVBT1ZhPkAkYB5USzZircAwQuaugqKzWYATwOLAbswyqsAvdvATxJe/AoAzOJFsAE4irsATefUHFSY7TkAWM9bwi9FmDEACvk1OLgxLm0A'
    $Base64String &= 'tB45cuG4Kr4An4yMGqVGrgsAK0yZ/ixL/CgAuSI6ZhfQqlYAiiHA85YktNAAhSZruvBvZJgAeaatvVzYU2sAKwrWcoqFRuMADRgG2sZ7QVYANpsVPvFqEaAA92b1GNCAVWMAh2hm6w55VYIAXKPtSbhxhp4Akzewa6PqYmwAo66W6Ln9i6sAxvZZWwA8VyAAGC1wA6ec75IA63mhx13sfLQAj0vf6138oyAA3ZI45WpROmsAhZxMoJgIaVsABucqGdCVk4sAO2uKBQkp2NYA2tvjcvpcSi8AexVWhjK/fwUACZ0tKs9Q4eYAYSDbxwaAXE4AFEa+rldxoqoAbDCTHH53ywYA6VfNkfXVM3IAHOHaym7r8w8A7Hlbuyee6B4A/i/yu3/p5dAAZ+u4DXykK1kAA4uV7SIozfoALDvHFhGv49YAsVBnacWO9XkA0K3/h8z4f6oA+aLtYfjIjWkA2rH0UZHrZ1cA0WQR62TLA70ASVU6RUMYLCUAbNEvDC1v9UEANSSg8mNZFl8A2aTpLE7buzEAEsZt+FtuA9wAyxWPG41y7NsADxWQ1hJO7uIAADElkzVvalsApRJjQAGKuWlAiDqIuA8Ztah4BRBJdLqoGqH4YRkAIA/DQXdFKI6A0TVfBhIEVbioAG9NhgfYMieeACwp0tATA4CBkN0Fgym7qAbAoGcntagxaxEtHSXRAAwwCgrop0DjpzkwNzAoNQYMtE8BYFMIMEPBOIQCAgEWF1Gecw1gnnOTLxKiQ1BTMAJE06o9MDswOaDIN6A1CKVsLskCJDOPEDMBM/UyAqVsMHQYqvhoMGYfqhSqDwUPBRKqP7YLEKqyCxWqGAT/qQEAAMBo7bPY1FCbAO/TdcsPO/ckANN6N0WNLO8WAPtRqSwftSW1AIqfXQvCGyB0AI1mDzbLqvY2AA0Pfo9LSnRDAGWsDSr2Cu1rAG3FCTjtABv4AOXcpgpABUfvAITKCbxDZoO/AJ/t24490UFk'
    $Base64String &= 'ALFwAi0DV1sYAG8cLMsesgDoALoJL1uBBDW5AKljbY4IxRjRAOEhrPkSChTAABLbfiWdrB0QAMBapYPSHxpmAFX8myri7DdXAI7l35Yw+MCTAAtDGPkCb6lRAK+4VwrzHAdpADmPN5xt15GuAKUuSelK3rPQAIy/OZANwIHOAPAqBzoMpi1RANJy81PG+b3vAO8MaUl3nyxWAMTpoQg9B67FAB7WhCLHvH1DABtYOGJO0QUlAITFQvgfL/bbAPqrjFTsRYpsABJNMFpS5aQXAAki5u9v9V+GAEPfoS29SkaSAKCBlixhl39AAG/YP4w1WqvRAMagO4VmVIDvAB8a9fGbsKEnAH2y5wvP9i2cAFgTlKmG/EVSAKIobX90D1KRAEl66RL4qTuwAJL9fZEU6VttAEiU8siW7gU4ALPF7DA/4QcgAASx2Iu8/bM+AG/yAlMG9KDtAMmacqOXXwD7AMtj0OjNdP11AMnUNkW6exJZAHLt5/J6UAB4APhDmkbY379UANRescfRvBuDAPQr5wvoR8hTAJ7MGqz2+op1AFNsIIWp1bhqALokjoorCJGfADcEHPZvot00AKqR/8YVLh5CABoJKU/0xs3iAJGi00AMjnjjUDCCBuyQcNSUcDAAD2+s3WaYdHyAqUY2p3gtuZ1whIGIqGZVUzETAt0BoHAKTmV3IEplwHJzZXkxFILhIHCSCwMBIEOA2TEe0KJBYnAVVGhlIMLWUgBVU1QgTmV0d4BvcmsxLjAsw3BuJYbYQ6x53iCG3l9xDfIzMHExOFVxT3tPe097P097T3tPe09733DccMgbAAGv2Sx+iJl9AAGYPyCQvZyAACFUk7nPoD5TAO+zWsB21hoEAKXOR4O168TMAEk0y/NFZbn5AKdkFoy5ACYJ+9UyUnkuAMljwhObtoY/AAEFkmZvIavVAHEQeYf0RirNAMRaydvXXUlNAHJWD9zJ41OYADoqHvzOWEnTAL/zObu5pCNCAKzQ'
    $Base64String &= 'FcN/nqJcANc48RaycNOjAMTfs8VyrC4KAHf8DZRSt/wfAJVzJD0BKLwPAA1Ps5EBjm6dACd1VdEXOzQhAHuXAZSvf4DPANERCleEyX9WAOC9RpyCvpSdAL+0ILBgfrhNAPUNP9vQ6oWMAIpWcdEtlEzIAIw80xSinL0mAP/TUyDHYGmbAFgKVPQF5/0xAKz5yIUXx7gpABmkKS9G493bAJFfnz82Pg4wAGcrRrc1r5a+ANpMYMyou58NABTUGMQwmHSCACHPYla1IXMSAB79qsoIWId3AKQV6xlV/9A5AFQtJu5FGjpvAM3XhPDX8CjFAE9kgwLU++LeAPG8Aij0bdonAIoG0paH3uhrAA7wW33pdmmTACAcSpcsdxkrAJOVmJyXnuuOAMF4VsZEJd8GABKaBi2fA179AIOiU2fKsfqNAKFkyYiSWcuoAEbAyfKm/31XANsSdvqKQSTUABv8cqUUotStAEMcpEmLQTkUAAMeKfobpSKuAKXDTYLQjdprALfb9xhAV3PwAHGj+0p9RTbBAPeNgvq5yQ1TAIB9+rY5WDLvAG8YUInXT50zAL0atZ2h3pVBAHqngwIDAQABAKOCAVowggFWADAfBgNVHSMEABgwFoAUU3m/AFqqK0rPVIDhANibwJ3ysgNmCMswHQEQDgQWBAAUGqH4YRkgDwDDQXdFKI7RNYBfBhIEVTAOgQcADwEB/wQEAwJQAYYwEsEDE8EDCAQwBoABAgEAMBMBwQQlBAwwCgYIACsGAQUFBwMIhDARAQUgBAowwAlEBgSAAgAwUIEEHwAESTBHMEWgQwCgQYY/aHR0cAA6Ly9jcmwudQBzZXJ0cnVzdAAuY29tL1VTRYRSVEEDUlNBQwAGAGlmaWNhdGlvAG5BdXRob3JpSHR5LgANMHYFHAGAAQRqMGgwP8UDUDAChjMGF3QYF0EkZGSCAkNBABR0MCIlBhABhhkEEG9jBHNwSxAwDQYJKgCGSIb3DQEBDBAF'
    $Base64String &= 'AAOCQEFtVIEApTNdFuG1U4EAkXXfA3oyCy0AJYQRsrDbKn0AKgX1vDsn9FoAoLlJWZApbGEAy7VQ2+J9+Z8AAO9Aw63T4uQAVvlYQc/xQuUAEH3/sHQfj8YAXAn5M17qoBwAJlhc87QRD9UA1cPivNVYeL8ASHbhRGdtj7AAQxAPjeT5OGIAvxMBxYWjTMUAzLJTMJWk1vQAllYIuM1cfwEAlr5yUmo7QjcAfBZ4OZOTlJsAsdyybUFtZ80AyW+QPX9FcsEAGyPWwlWEZuQAs8VmBvbz1ksAXq2jK0KKIZIA/qhvWiVwYoEAc2NeoLvY3NcAStM9r4MGOBIAHSSHLeT8AtYAPncEvAQ2tecAd8ucLo0jGLkAo8JHHfBd1qEAc1cFaJqnyTcAZR2+6rzYQoMAQwWli6YJ/9EAoZSmTqo9CfUABWy30mRa2CoAIsJLnfE5XkwA3kg9mzSWmgkAX47997FSkc4AP4n2HKG1qXUAH3G/W0NdZT0AUIFuq/DQ0/wAsrMftpmWJvQAPHmLXGTMze4AJ5rloMAMcocAwW5NWtMe6vAAROYybxzrF04AlMN4ZSA7D0EAqh/poUGd/rEAuKBlKjTg3qgA+TzmwTC7wKAAYyz8XBYAqNAAxH/qEZ0eBsYApm0yXbQ4CSsASQeq/eww2vEApy/Pt/360KMAhNknnvsBZncAuVYQ4SBuxq4Asfm2usg1XTMAdo7xfCAMKncArrWiAoa6Ke4AtFoAsYyr4/kACslUXdS5anQAnr1IrpgxggQAHDCCBBgCAQEAMIGRMH0xCzACCeBdBAYTAkdCEDEbMBmBAQgTEgBHcmVhdGVyIIBNYW5jaGVzQAEEMRCibAQHEwdTgGFsZm9yZDHAdQEhAgoTD1NlY3QAaWdvIExpbWmAdGVkMSUwIyEDGAMTHCUDgFggVGkAbWUgU3RhbXAAaW5nIENBAhAAPRo1cjAVgmMAMNATcX6CQQgBQVZghkgBZQMEAAIB'
    $Base64String &= 'BQCgggFbBDAaplgJAzENBoILhQEQAQQwHGcDAAUxDxcNMjAwADUyNDE0MjcwEDRaMC+nAwQxIgAEIBXN7GeQagBv9+sM8UvJFgAdAEBoAhTMqgA8/8E1Xt+WEiBc4TCB7cgLAgwAMYHdMIHaMIEE1zDgjiXIrHNOAEhQt/jZE5GoABuSSTZln2EwAIG8BBQC1luVAOKDcMFXAJX6AIj5I92Tf62PADCBozCBjqSBEIswgYhILFVTMQYTQo5ALApOZXcgAEplcnNleTEUSwKWQCsLAwIgQ0CHMQYewBvCKxVUaGUgAcKBUlVTVCBOZQB0d29yazEuMLosgywlRoXCLCqRIEaRAAIQMA9vrN1mAJh0fKlGNqd4DC25CYSgLQSCAgAAQkFhpg5IrwQAW4QpmkEeFcoAWjmJLwnUuZ0ATr1M8YIYaS4AcL8GcRyac9cAFqSKm6pfIDkAxpWlucPp+94AkUSFxsKAr20AU9IhBKu4lBYABcf/LO+oaEcAkExp9IxcgeAAjz2VJAcjpj8AomqgUXkumfEA/Fp6y1AvDYcArLliG+66vEoA1PBNApIE+44ASDJq659lB2wAj2gKrWqew0EAyKGeHTXtz70AnyQRF9t1LMcAdo5R+sqQNewAGc02GQVq9W0AFIJ0/m7XJrIAxCpsZYIfOMwAsOj9fsTJyqYA/3I+ksmvlpQAFCan38P/zzYAf7CUAQwfqHkAvqtgAHRhdOIAw+76cxWjyGkA2n4qWQPV3RgAwt3sdagqXEkAnotqb1KFUMEAzuDAEG1XrFoABYwpLTgNm/gAU6bDv5iK3acABpkTajyoJx8AuKm7M2VhJu0A6XdI9nikU4EAiUTrWHds8oEALcVe6cXKGmwA9efr64Fp7WIARyrJ6FW9lKkA680yYW2Au10A7r46MzFbV5wAMJLPLQpdCDsAA4Xgdj8Qb6oAKiDMbnftAq8Amsaa967wfZ8AROJQkkRVnFgASibrMPyLkd8A'
    $Base64String &= 'F22PWnnQmUkAkcCSojvD12AAgRknLpXwix8Ae25AWc1p5gAAlMwJCRaKnuUA7scbi4IYNG8AYLo1X7mONg0A9N9YjuVa1m8AGjOjHN/BNuwAA8QYmvBKfbUAbyuTyzmo4fYA7FehrnTJUhgAWsBPwCzu0wkCAAIA'
    $Base64String = _WinAPI_Base64Decode($Base64String)
    If @error Then Return SetError(1, 0, 0)
    Local $tSource = DllStructCreate('byte[' & BinaryLen($Base64String) & ']')
    DllStructSetData($tSource, 1, $Base64String)
    Local $tDecompress
    _WinAPI_LZNTDecompress($tSource, $tDecompress, 63848)
    If @error Then Return SetError(3, 0, 0)
    $tSource = 0
    Local Const $bString = Binary(DllStructGetData($tDecompress, 1))
    If $bSaveBinary Then
        Local Const $hFile = FileOpen($sSavePath & "\NetworkInterfacesView.exe", 18)
        If @error Then Return SetError(2, 0, $bString)
        FileWrite($hFile, $bString)
        FileClose($hFile)
    EndIf
    Return $bString
EndFunc   ;==>_NirSoft_NetworkInterfacesView

Func _WinAPI_Base64Decode($sB64String)
    Local $aCrypt = DllCall("Crypt32.dll", "bool", "CryptStringToBinaryA", "str", $sB64String, "dword", 0, "dword", 1, "ptr", 0, "dword*", 0, "ptr", 0, "ptr", 0)
    If @error Or Not $aCrypt[0] Then Return SetError(1, 0, "")
    Local $bBuffer = DllStructCreate("byte[" & $aCrypt[5] & "]")
    $aCrypt = DllCall("Crypt32.dll", "bool", "CryptStringToBinaryA", "str", $sB64String, "dword", 0, "dword", 1, "struct*", $bBuffer, "dword*", $aCrypt[5], "ptr", 0, "ptr", 0)
    If @error Or Not $aCrypt[0] Then Return SetError(2, 0, "")
    Return DllStructGetData($bBuffer, 1)
EndFunc   ;==>_WinAPI_Base64Decode

Func _WinAPI_LZNTDecompress(ByRef $tInput, ByRef $tOutput, $iBufferSize)
    $tOutput = DllStructCreate("byte[" & $iBufferSize & "]")
    If @error Then Return SetError(1, 0, 0)
    Local $aRet = DllCall("ntdll.dll", "uint", "RtlDecompressBuffer", "ushort", 0x0002, "struct*", $tOutput, "ulong", $iBufferSize, "struct*", $tInput, "ulong", DllStructGetSize($tInput), "ulong*", 0)
    If @error Then Return SetError(2, 0, 0)
    If $aRet[0] Then Return SetError(3, $aRet[0], 0)
    Return $aRet[6]
EndFunc   ;==>_WinAPI_LZNTDecompress

#EndRegion Base64

Remarks:

I used also an utility from Nirsoft - NetworkInterfacesView, and an UDF from mine some powershell scripts, you can find all attached.
as stated, some firewall rules namings are dependant from the Win language, and mine is italian, please modify according to you language.
you can position and launch the executable where you want, and it creates a folder c:\autoit\netutils only to extract needed external files.

CondivisioneFileEStampantiPRIVATEFALSE.ps1 CondivisioneFileEStampantiPRIVATETRUE.ps1 IndividuazioneRetePRIVATEFALSE.ps1 IndividuazioneRetePRIVATETRUE.ps1 NetUtils.exe NetUtils.au3 _GOLLOG.au3 networkinterfacesview.zip

Edited August 25, 2022 by t0nZ
added more remarks

How to set network state private or public using AutoIt ?

Recommended Posts

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Create an account or sign in to comment

Create an account

Sign in

Recently Browsing 0 members

Similar Content