function findEligibleVirtualSwitch
{
    $switches = Get-VMSwitch
    if ($switches.Count -eq 1)
    {
        $vs = $switches[0]
        if (($vs.SwitchType -eq "External") -Or ($vs.SwitchType -eq "Internal"))
        {
            $vsName = $vs.Name
            Write-host "Select $vsName as the virtual switch for the VM" -BackgroundColor DarkGray
            return $vsName
        }
    }

    Write-host "Please specify an Internal or External virtual switch" -BackgroundColor Red
    return
}

function GetVhdArchitecture($VhdPath)
{
    $local:DismResult = dism /get-imageinfo /imagefile:$VhdPath /index:1

    $local:checkError = $local:DismResult | findstr /i "Error"
    if ($local:checkError)
    {
        Write-Host "Failed to get architecture from VHD: $VhdPath" -BackgroundColor Red
        Write-Host "Error: $local:DismResult" -BackgroundColor Red
        onCmdletStop
    }

    $local:architecture = $local:DismResult | findstr /i "Architecture" | findstr /i "x86"
    if ($local:architecture)
    {
        return ("x86")
    }
    
    $local:architecture = $local:DismResult | findstr /i "Architecture" | findstr /i "x64"
    if ($local:architecture)
    {
        return ("amd64")
    }
    
    Write-Host "Get unknown architecture: $local:architecture, from VHD: $VhdPath" -BackgroundColor Red
    onCmdletStop
}

function handleDismErrorAndStop($mountPoint)
{
    $local:DismResult = dism /Remount-Image /MountDir:"$mountPoint"
    $local:checkError = $local:DismResult | findstr /i "Error"

    if ($local:checkError)
    {
        Write-Host "Failed to cleanup remount" -BackgroundColor Red
        Write-Host $local:DismResult -BackgroundColor Red
        onCmdletStop
    }

    $local:DismResult = Dism /Unmount-Image /MountDir:"$mountPoint" /Discard
    $local:checkError = $local:DismResult | findstr /i "Error"

    if ($local:checkError)
    {
        Write-Host "Failed to cleanup unmount" -BackgroundColor Red
        Write-Host $local:DismResult -BackgroundColor Red
    }
    onCmdletStop
}

function GenerateComputerName($VmName)
{
    # Unattend xml has a limitation on computer name length to 15
    $local:MaxComputerNameLength  = 15
    $local:VmComputerName = $VmName
    if ($local:VmComputerName.length -gt $local:MaxComputerNameLength )
    {
        # In case there could be duplicate VM host name, using first half char from VmName as identity, plus second half from middle of ticks
        # Note, we take the middle part of ticks because its far left part is too big and will be a constant in relative long time, while the
        # far right part is too small and keep changing very fast. The middle part has we expected change (roughly in milliseconds) but keep
        # in order in a relative long time.
        $local:firstHalf = [int]($local:MaxComputerNameLength / 2)
        $local:appendixTicks = [System.DateTime]::Now.Ticks.ToString().SubString(4, ($local:MaxComputerNameLength - $local:firstHalf))
        $local:VmComputerName = $local:VmComputerName.SubString(0, $local:firstHalf) + $local:appendixTicks
    }
    Write-Host
    Write-Host "The VM computer will be created with ComputerName: $local:VmComputerName"
    Write-Host
    return ($local:VmComputerName)
}

function SetupUnattendXml($VmName, $ComputerName, $VhdPath)
{
    #prepare replacements
    $local:Replacements:ArchitectureReplacement = GetVhdArchitecture($VhdPath)
    $local:Replacements:AppVSequencerVmComputerName = $ComputerName
    $local:Replacements:GeneratedPasswordReplacement = GenerateRandomPassword
    $local:Replacements:PlainTestReplacement = "true"
    $local:Replacements:AppVSequencerUser = "AppVSequencerUser"
    
    #The unattend template file should be located in the same directory as this script
    $local:UnattendXml:TemplateFileLocation = $Script:AutoSequencingRoot + "\Unattend_Sequencer_User_Setup_Template.xml"
    $local:rootDataFolder = GetAutoSeqRootDataFolder
    $local:UnattendXml:MountRoot = $local:rootDataFolder + "\MountSequencerVhd"

    if (Test-Path "$local:UnattendXml:MountRoot")
    {
        Remove-Item "$local:UnattendXml:MountRoot" -Recurse | out-null
    }

    $local:DismResult = New-Item "$local:UnattendXml:MountRoot" -Type Directory -Force
    if (!$local:DismResult)
    {
        Write-Host "Failed to create directory: $local:UnattendXml:MountRoot" -BackgroundColor Red
        onCmdletStop
    }

    $local:DismResult = Dism /Mount-Image /ImageFile:"$VhdPath" /Index:1 /MountDir:"$local:UnattendXml:MountRoot"
    $local:checkError = $local:DismResult | findstr /i "Error"
    if ($local:checkError)
    {
        Write-Host "Failed to mount image: $VhdPath" -BackgroundColor Red
        Write-Host $local:DismResult -BackgroundColor Red
        handleDismErrorAndStop $local:UnattendXml:MountRoot
    }

    $local:UnattendXml:TargetDirectory = $local:UnattendXml:MountRoot + "\Windows\Panther"
    $local:UnattendXml:TargetFilePath = $local:UnattendXml:TargetDirectory + "\Unattend.xml"

    $local:DismResult = New-Item "$local:UnattendXml:TargetDirectory" -Type Directory -Force

    if ($local:DismResult)
    {
        $local:UnattendXml:Content = Get-Content $local:UnattendXml:TemplateFileLocation
        
        $local:UnattendXml:Content = $local:UnattendXml:Content.Replace('[{ArchitectureReplacement}]', $local:Replacements:ArchitectureReplacement)
        $local:UnattendXml:Content = $local:UnattendXml:Content.Replace('[{AppVSequencerVmComputerName}]', $local:Replacements:AppVSequencerVmComputerName)

        $local:UnattendXml:XmlSanitizedPassword = [Security.SecurityElement]::Escape($local:Replacements:GeneratedPasswordReplacement)
        $local:UnattendXml:Content = $local:UnattendXml:Content.Replace('[{GeneratedPasswordReplacement}]', $local:UnattendXml:XmlSanitizedPassword)
        $local:UnattendXml:Content = $local:UnattendXml:Content.Replace('[{PlainTestReplacement}]', $local:Replacements:PlainTestReplacement)
        $local:UnattendXml:Content = $local:UnattendXml:Content.Replace('[{AppVSequencerUser}]', $local:Replacements:AppVSequencerUser)

        $local:UnattendXml:Content | Set-Content $local:UnattendXml:TargetFilePath

        if ($Script:AUTOSEQ_DEBUG)
        {
            $local:UnattendXml:DebugFilePath = $local:rootDataFolder + "\" + $VmName + "_Unattend_debug.xml"
            $local:UnattendXml:Content | Set-Content $local:UnattendXml:DebugFilePath
        }
    }

    $local:DismResult = Dism /Unmount-Image /MountDir:"$local:UnattendXml:MountRoot" /Commit
    $local:checkError = $local:DismResult | findstr /i "Error"

    if ($local:checkError)
    {
        Write-Host "Error in unmounting $VhdPath. Exiting.." -BackgroundColor Red
        Write-Host $local:DismResult -BackgroundColor Red
        handleDismErrorAndStop $local:UnattendXml:MountRoot
    }
    
    #build credential for return
    $local:Replacements:securePassword = ConvertTo-SecureString -string "$local:Replacements:GeneratedPasswordReplacement" -AsPlainText -Force
    $local:Replacements:credAppVSequencerUser = New-Object system.management.automation.pscredential $local:Replacements:AppVSequencerUser, $local:Replacements:securePassword

    return ($local:Replacements:credAppVSequencerUser)
}

function enableRDP
{
    set-ItemProperty -Path 'HKLM:\System\CurrentControlSet\Control\Terminal Server' -name "fDenyTSConnections" -Value 0
    Enable-NetFirewallRule -DisplayGroup "Remote Desktop"
    set-ItemProperty -Path 'HKLM:\System\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp' -name "UserAuthentication" -Value 1
}

function New-AppVSequencerVM
{
    [CmdletBinding()]
    param(
        [Parameter(Mandatory = $true, ParameterSetName="VHD")]
        [Parameter(Mandatory = $true, ParameterSetName="VM")]
        [ValidateNotNullOrEmpty()]
        [string]$VMName,
        [Parameter(Mandatory = $true, ParameterSetName="VM")]
        [ValidateNotNullOrEmpty()]
        [string]$VMComputerName,
        [Parameter(Mandatory = $false, ParameterSetName="VM")]
        [ValidateNotNullOrEmpty()]
        [string]$VMCheckpoint,
        [Parameter(Mandatory = $true, ParameterSetName="VHD")]
        [Parameter(Mandatory = $true, ParameterSetName="VM")]
        [ValidateNotNullOrEmpty()]
        [string]$ADKPath,
        [Parameter(Mandatory = $true, ParameterSetName="VHD")]
        [ValidateNotNullOrEmpty()]
        [string]$VHDPath,
        [Parameter(Mandatory = $false, ParameterSetName="VHD")]
        [ValidateRange(0,[int64]::MaxValue)]
        [Int64]$VMMemory,
        [Parameter(Mandatory = $false, ParameterSetName="VHD")]
        [ValidateNotNullOrEmpty()]
        [string]$VMSwitch,
        [Parameter(Mandatory = $false, ParameterSetName="VHD")]
        [ValidateRange(1,64)]
        [int]$CPUCount,
        [ValidateRange(1,[int64]::MaxValue)]
        [Int64]$SessionSetupTimeout,
        [switch]$UseADKWebInstaller,
        [switch]$UseDynamicMemory
    )

    process {
        $Script:AUTOSEQ_DEBUG = $false

        $Script:AutoSequencingRoot = "$PSScriptRoot\.."

        Import-module "$Script:AutoSequencingRoot\AutoSequencingUtils.psm1" -Force
        Import-module "$Script:AutoSequencingRoot\AutoSequencingTelemetry.psm1" -Force

        onCmdletStart $MyInvocation.MyCommand

        $telemetryProviderLoaded = LoadAutoSequencingTelemetryProvider($Script:AutoSequencingRoot)
        if ($telemetryProviderLoaded -eq $false)
        {
            Write-host "Failed to initialize Auto-Sequencer telemetry provider" -BackgroundColor Red
            onCmdletStop
        }

        $telemetryId = New-Guid
        LogNewAppVSequencerVMStart -TelemetryId $telemetryId -VMMemory $VMMemory -CPUCount $CPUCount -SessionSetupTimeout $SessionSetupTimeout -UseADKWebInstaller $UseADKWebInstaller

        $reportFilePath = createReportFile $MyInvocation.MyCommand

        $DEFAULT_MEMORY_SIZE = 1024MB
        $VM_STATE_RUNNING = 2

        $VM_VIRTUAL_CPU_COUNT_MAX = 64

        if (!(checkHyperV))
        {
            LogNewAppVSequencerVMStatus -TelemetryId $telemetryId -Message "Check Hyper-V failed"
            onCmdletStop
        }

        $vm = get-vm -name $VMName -erroraction ignore
        
        $local:cred = $null

        if ($PSCmdlet.ParameterSetName -eq "VM")
        {
            if (!$vm)
            {
                $invalidVMError = "Invalid VM name $VMName"
                LogNewAppVSequencerVMStatus -TelemetryId $telemetryId -Message $invalidVMError
                Write-host $invalidVMError -BackgroundColor Red
                onCmdletStop
            }

            # If a VM Checkpoint was specified then apply that now
            if ($VMCheckpoint)
            {
                # Check if a snapshot by name $VMCheckpoint-sequencer-base already exist
                $sequencerBaseSnapshotName = getSequencerBaseSnapshotName($VMCheckpoint)
                $snapshot = Get-VMSnapshot -VMName $VMName -Name $sequencerBaseSnapshotName -ErrorAction SilentlyContinue
                if ($snapshot)
                {
                    Write-host "A checkpoint with the name $sequencerBaseSnapshotName already exists." -BackgroundColor Red
                    LogNewAppVSequencerVMStatus -TelemetryId $telemetryId -Message "Invalid VM Checkpoint given"
                    onCmdletStop
                }

                Write-host "Will restore the VM $VMName to Checkpoint $VMCheckpoint"
                Restore-VMSnapshot -VMName $VMName -Name $VMCheckpoint -Confir:$false
                if ($? -eq $false)
                {
                    LogNewAppVSequencerVMStatus -TelemetryId $telemetryId -Message "Restore-VMSnapshot failed"
                    onCmdletStop
                }
            }

            if ($vm.state -ne $VM_STATE_RUNNING)
            {
                start-vm $vm
            }

            #best effort to see if we already have user credential for the machine.
            $local:cred = RetrieveUserCredential $VMName

            if (!$SessionSetupTimeout)
            {
                $SessionSetupTimeout = getDefaultShortTimeout
            }

            $local:vmSession = GetVmSession $VMName $VMComputerName ([REF]$local:cred) $true $SessionSetupTimeout $reportFilePath
            if (!$local:vmSession)
            {
                $getVMSessionError = "Failed to get VM session"
                LogNewAppVSequencerVMStatus -TelemetryId $telemetryId -Message $getVMSessionError
                Write-host $getVMSessionError -BackgroundColor Red
                onCmdletStop
            }

            # enable remote desktop for VM
            $ret = Invoke-Command -session $local:vmSession -ScriptBlock ${function:enableRDP}

            StoreUserCredential $VMName $local:cred $VMComputerName

            if (!(provisionVM $local:vmSession $ADKPath $UseADKWebInstaller))
            {
                LogNewAppVSequencerVMStatus -TelemetryId $telemetryId -Message "Failed to provision VM for sequencing"
                onCmdletStop
            }
        }
        elseif ($PSCmdlet.ParameterSetName -eq "VHD")
        {
            #clean up old VM

            if ($vm)
            {
                $removeVM = Read-host -prompt "$VMName already exists. Remove? (Y/N)"
                if ($removeVM -ne "Y")
                {
                    LogNewAppVSequencerVMStatus -TelemetryId $telemetryId -Message "User chose not to remove the existing VM"
                    onCmdletStop
                }
                stop-vm $vm -force
                remove-vm $vm -force
            }

            if (!$VMMemory)
            {
                # sequencer minimum requirement
                $VMMemory = $DEFAULT_MEMORY_SIZE
            }
            else
            {
                $totalMemory = (Get-WmiObject -Class Win32_ComputerSystem).TotalPhysicalMemory
                if ($VMMemory -gt $totalMemory)
                {
                    $invalidMemoryError = "Invalid memory value: $VMMemory. Please specify a value less than $totalMemory"
                    LogNewAppVSequencerVMStatus -TelemetryId $telemetryId -Message $invalidMemoryError
                    Write-host $invalidMemoryError -BackgroundColor Red
                    onCmdletStop
                }
            }

            if (!$VMSwitch)
            {
                $VMSwitch = findEligibleVirtualSwitch
                if (!$VMSwitch)
                {
                    LogNewAppVSequencerVMStatus -TelemetryId $telemetryId -Message "Failed to find eligible Virtual Switch"
                    onCmdletStop
                }
            }

            #In clean VHD scenario, we always regenerate the password.
            $local:VmComputerName = GenerateComputerName($VMName)
            $local:cred = SetupUnattendXml $VMName $local:VmComputerName $VHDPath

            # we need to store the user credential once it is generated
            StoreUserCredential $VMName $local:cred $local:VmComputerName

            $vm = New-VM -Name $VMName -MemoryStartupBytes $VMMemory -VHDPath $VHDPath -SwitchName $VMSwitch

            if (!$vm)
            {
                $errorCreatingVM = "Failed to create VM: $VMName"
                LogNewAppVSequencerVMStatus -TelemetryId $telemetryId -Message $errorCreatingVM
                Write-host $errorCreatingVM -BackgroundColor Red
                onCmdletStop
            }

            if (!$CPUCount)
            {
                $cpuInfo = Get-WmiObject -class win32_processor
                if (!$cpuInfo)
                {
                    $errorCpuInfo = "Failed to get CPU information"
                    LogNewAppVSequencerVMStatus -TelemetryId $telemetryId -Message $errorCpuInfo
                    Write-host $errorCpuInfo -BackgroundColor Red
                    onCmdletStop
                }

                $CPUCount = $cpuInfo.NumberOfCores
                if ($CPUCount -gt $VM_VIRTUAL_CPU_COUNT_MAX)
                {
                    $CPUCount = $VM_VIRTUAL_CPU_COUNT_MAX
                }

                if ($CPUCount -le 0)
                {
                    $CPUCount = 1
                }
            }

            writeToReport $reportFilePath "Setting CPU count to $CPUCount"
            Set-VMProcessor $VMName -Count $CPUCount

            # Setting dynamic memory to $true could cause unpredictable VM performance due to varying memory size
            # Recommend disabling dynamic memory on the VM and select VM memory that is possible with the available memory 
            # on the host machine
            if (!$UseDynamicMemory)
            {
                $UseDynamicMemory = $false
            }

            if ($UseDynamicMemory)
            {
                writeToReport $reportFilePath "Will enable Dynamic Memory for the VM $VMName"
                Set-VMMemory $VMName -DynamicMemoryEnabled $true
            }
            else
            {
                writeToReport $reportFilePath "Will disable Dynamic Memory for the VM $VMName"
                Set-VMMemory $VMName -DynamicMemoryEnabled $false
            }

            Write-host "VM $VMName created and starting, please wait for few minutes for the first time machine boot up ..."

            start-vm $vm

            if (!$SessionSetupTimeout)
            {
                $SessionSetupTimeout = getDefaultLongTimeout
            }

            $local:vmSession = GetVmSession $VMName $local:VmComputerName ([REF]$local:cred) $false $SessionSetupTimeout $reportFilePath

            if (!$local:vmSession)
            {
                $failedGetVMSession = "Failed to get VM session"
                LogNewAppVSequencerVMStatus -TelemetryId $telemetryId -Message $failedGetVMSession
                Write-host $failedGetVMSession -BackgroundColor Red
                onCmdletStop
            }

            if (!(provisionVM $local:vmSession $ADKPath $UseADKWebInstaller))
            {
                LogNewAppVSequencerVMStatus -TelemetryId $telemetryId -Message "Failed to provision VM for sequencing"
                onCmdletStop
            }
        }
        else
        {
            $invalidParam = "Invalid Parameter Set. Exiting.."
            LogNewAppVSequencerVMStatus -TelemetryId $telemetryId -Message $invalidParam
            Write-host $invalidParam -BackgroundColor Red
            onCmdletStop
        }

        # Create the sequencer base snapshot
        if (!(createSequencerBaseVMSnapshot $VMName $VMCheckpoint))
        {
            $vmSnapshotError = "Create Sequencer Base VM Snapshot failed for $VMName"
            LogNewAppVSequencerVMStatus -TelemetryId $telemetryId -Message $vmSnapshotError
            Write-host $vmSnapshotError -BackgroundColor Red
            onCmdletStop
        }

        remove-pssession $local:vmSession
        RemoveHostFromTrustedHostsList($local:VmComputerName)

        $vmProvisioningComplete = "VM provisioning complete."
        LogNewAppVSequencerVMStatus -TelemetryId $telemetryId -Message $vmProvisioningComplete
        Write-host $vmProvisioningComplete -BackgroundColor DarkGreen

        onCmdletCompletion
    }
}

function Connect-AppVSequencerVM
{
    [CmdletBinding()]
    param(
        [Parameter(Mandatory=$true)]
        [ValidateNotNullOrEmpty()]
        [string]$VMName,
        [ValidateRange(1,[int64]::MaxValue)]
        [Int64]$SessionSetupTimeout = 3
    )

    process {
        Import-module "$PSScriptRoot\..\AutoSequencingUtils.psm1" -Force
        Import-module "$PSScriptRoot\..\AutoSequencingTelemetry.psm1" -Force

        onCmdletStart $MyInvocation.MyCommand

        $telemetryProviderLoaded = LoadAutoSequencingTelemetryProvider($Script:AutoSequencingRoot)
        if ($telemetryProviderLoaded -eq $false)
        {
            Write-host "Failed to initialize Auto-Sequencer telemetry provider" -BackgroundColor Red
            onCmdletStop
        }

        $telemetryId = New-Guid
        LogConnectAppVSequencerVMStart -TelemetryId $telemetryId -SessionSetupTimeout $SessionSetupTimeout

        $VM_STATE_RUNNING = 2

        $reportFilePath = createReportFile $MyInvocation.MyCommand

        $cred = RetrieveUserCredential $VMName
        if (!$cred)
        {
            $getCredError = "Failed to get credential for the VM $VMName"
            LogConnectAppVSequencerVMStatus -TelemetryId $telemetryId -Message $getCredError
            Write-host $getCredError -BackgroundColor Red
            return
        }

        $VmComputerName = RetrieveVmComputerName $VMName
        if (!$VmComputerName)
        {
            $getComputerNameError = "Failed to get computer name for the VM $VMName"
            LogConnectAppVSequencerVMStatus -TelemetryId $telemetryId -Message $getComputerNameError
            Write-host $getComputerNameError -BackgroundColor Red
            return
        }

        $vm = get-vm -name $VMName -ErrorAction SilentlyContinue
        if (!$vm)
        {
            $vmNotFoundError = "VM $VMName does not exist"
            LogConnectAppVSequencerVMStatus -TelemetryId $telemetryId -Message $vmNotFoundError
            Write-host $vmNotFoundError -BackgroundColor Red
            return
        }

        if ($vm.state -ne $VM_STATE_RUNNING)
        {
            start-vm -Name $VMName
        }

        $s = GetVmSession $VMName $VmComputerName ([REF]$cred) $true $SessionSetupTimeout $reportFilePath
        if (!$s)
        {
            $vmGetSessionError = "Failed to get VM session"
            LogConnectAppVSequencerVMStatus -TelemetryId $telemetryId -Message $vmGetSessionError
            Write-host $vmGetSessionError -BackgroundColor Red
            return
        }

        $dnsResult = dnsResolve $s
        if (!$dnsResult)
        {
            $dnsResolveError = "Failed to DNS resolve for VM"
            LogConnectAppVSequencerVMStatus -TelemetryId $telemetryId -Message $dnsResolveError
            Write-host $dnsResolveError -BackgroundColor Red
            return
        }

        $procMstsc = setupAndShowVM $dnsResult $cred
        if (!$procMstsc)
        {
            $remoteError = "Failed to launch remote desktop session"
            LogConnectAppVSequencerVMStatus -TelemetryId $telemetryId -Message $remoteError
            Write-host $remoteError -BackgroundColor Red
        }

        LogConnectAppVSequencerVMStatus -TelemetryId $telemetryId -Message "Connect-AppVSequencerVM completed successfully"

        RemoveHostFromTrustedHostsList($local:VmComputerName)

        onCmdletCompletion
    }
}

Export-ModuleMember -Function New-AppVSequencerVM
Export-ModuleMember -Function Connect-AppVSequencerVM

# SIG # Begin signature block
# MIIiOwYJKoZIhvcNAQcCoIIiLDCCIigCAQExDzANBglghkgBZQMEAgEFADB5Bgor
# BgEEAYI3AgEEoGswaTA0BgorBgEEAYI3AgEeMCYCAwEAAAQQH8w7YFlLCE63JNLG
# KX7zUQIBAAIBAAIBAAIBAAIBADAxMA0GCWCGSAFlAwQCAQUABCDWE6EWxU1sBLSE
# jka4Eqyw4r0u2Hu9D47fajLL1PTWvKCCC34wggUGMIID7qADAgECAhMzAAABswyw
# gExVVE3DAAAAAAGzMA0GCSqGSIb3DQEBCwUAMH4xCzAJBgNVBAYTAlVTMRMwEQYD
# VQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNy
# b3NvZnQgQ29ycG9yYXRpb24xKDAmBgNVBAMTH01pY3Jvc29mdCBDb2RlIFNpZ25p
# bmcgUENBIDIwMTAwHhcNMTcwNzE4MTc1MDQxWhcNMTgwNzEwMTc1MDQxWjB/MQsw
# CQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9u
# ZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMSkwJwYDVQQDEyBNaWNy
# b3NvZnQgV2luZG93cyBLaXRzIFB1Ymxpc2hlcjCCASIwDQYJKoZIhvcNAQEBBQAD
# ggEPADCCAQoCggEBAOP85kiLpaS9v/uqxuT0fO3b0Wc9NPGOUXWJ64gNZsUfo3rt
# F4nqKu39PAhpRvtSFu2dmVO/eMwJ6hKfXoEi7p/HnJiAJsM2KBNuAMr9W0u2U8zU
# mEGwdI86J8xA4NQbLPgRLLiI+5KOhncDPEIg8ejBTCEsp384wIj1kfiQ4JYlHsU7
# QbxyfMaDXhgtD4zKPWB8lQ00nf0bon2uSRJo/eqEMMWVIS8DUtP+0N2F3zSWTXmU
# Av1eLEdBaotG4MS+xL4+1R2288dx3RrxIJ2DANKZFMIxyBX/5j1fE/FmBWFHgT6j
# GNvdM6yo4289niiSZfJ6CSlUZItMp2+Vqhv1q3UCAwEAAaOCAXowggF2MB8GA1Ud
# JQQYMBYGCisGAQQBgjcKAxQGCCsGAQUFBwMDMB0GA1UdDgQWBBQQ638EyhqeAHDv
# ddaB2xCoBuYWQDBRBgNVHREESjBIpEYwRDEMMAoGA1UECxMDQU9DMTQwMgYDVQQF
# EysyMjk5MDMrZmQ2YjllNWQtZWI3My00MTg5LWFiYzItZjdjYWNkYTM4MWFjMB8G
# A1UdIwQYMBaAFOb8X3u7IgBY5HJOtfQhdCMy5u+sMFYGA1UdHwRPME0wS6BJoEeG
# RWh0dHA6Ly9jcmwubWljcm9zb2Z0LmNvbS9wa2kvY3JsL3Byb2R1Y3RzL01pY0Nv
# ZFNpZ1BDQV8yMDEwLTA3LTA2LmNybDBaBggrBgEFBQcBAQROMEwwSgYIKwYBBQUH
# MAKGPmh0dHA6Ly93d3cubWljcm9zb2Z0LmNvbS9wa2kvY2VydHMvTWljQ29kU2ln
# UENBXzIwMTAtMDctMDYuY3J0MAwGA1UdEwEB/wQCMAAwDQYJKoZIhvcNAQELBQAD
# ggEBAJl59WeeQK+g1o1JbJfI95BZ4VvnwGqOd2FSqQJOxmRwAKjXq9U70yxBawxv
# YkheZdLhmeto4TlMBvcj3HrregpzaS4nQvcKhME9eroEFhP5fL4mxZwNSoHajalU
# c6w8Rpu3728wHHqCKVmlLGtSxeFy12f7FVOyxEYSQEewMuFeegHBAW+BmAb889Di
# LemKdr9ilLoQh60EJnLxKqSl0uiN/ft+DHVEDCZLb16LztE4FQaol74OhC7B4Vpz
# 8iBstQ2EgTdHTqVrHd9aK5xqIzEiRurd0rL2+nOJlMVMu0b2gTBca5BEakXyzWE3
# 0nDDShDOiYjQsXmdUzOdTm6e0PwwggZwMIIEWKADAgECAgphDFJMAAAAAAADMA0G
# CSqGSIb3DQEBCwUAMIGIMQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3Rv
# bjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0
# aW9uMTIwMAYDVQQDEylNaWNyb3NvZnQgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3Jp
# dHkgMjAxMDAeFw0xMDA3MDYyMDQwMTdaFw0yNTA3MDYyMDUwMTdaMH4xCzAJBgNV
# BAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4w
# HAYDVQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xKDAmBgNVBAMTH01pY3Jvc29m
# dCBDb2RlIFNpZ25pbmcgUENBIDIwMTAwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAw
# ggEKAoIBAQDpDmRQeWe1xOP9CQBMnpSs91Zo6kTYz8VYT6mldnxtRbrTOZK0pB75
# +WWC5BfSj/1EnAjoZZPOLFWEv30I4y4rqEErGLeiS25JTGsVB97R0sKJHnGUzbV/
# S7SvCNjMiNZrF5Q6k84mP+zm/jSYV9UdXUn2siou1YW7WT/4kLQrg3TKK7M7RuPw
# RknBF2ZUyRy9HcRVYldy+Ge5JSA03l2mpZVeqyiAzdWynuUDtWPTshTIwciKJgpZ
# fwfs/w7tgBI1TBKmvlJb9aba4IsLSHfWhUfVELnG6Krui2otBVxgxrQqW5wjHF9F
# 4xoUHm83yxkzgGqJTaNqZmN4k9Uwz5UfAgMBAAGjggHjMIIB3zAQBgkrBgEEAYI3
# FQEEAwIBADAdBgNVHQ4EFgQU5vxfe7siAFjkck619CF0IzLm76wwGQYJKwYBBAGC
# NxQCBAweCgBTAHUAYgBDAEEwCwYDVR0PBAQDAgGGMA8GA1UdEwEB/wQFMAMBAf8w
# HwYDVR0jBBgwFoAU1fZWy4/oolxiaNE9lJBb186aGMQwVgYDVR0fBE8wTTBLoEmg
# R4ZFaHR0cDovL2NybC5taWNyb3NvZnQuY29tL3BraS9jcmwvcHJvZHVjdHMvTWlj
# Um9vQ2VyQXV0XzIwMTAtMDYtMjMuY3JsMFoGCCsGAQUFBwEBBE4wTDBKBggrBgEF
# BQcwAoY+aHR0cDovL3d3dy5taWNyb3NvZnQuY29tL3BraS9jZXJ0cy9NaWNSb29D
# ZXJBdXRfMjAxMC0wNi0yMy5jcnQwgZ0GA1UdIASBlTCBkjCBjwYJKwYBBAGCNy4D
# MIGBMD0GCCsGAQUFBwIBFjFodHRwOi8vd3d3Lm1pY3Jvc29mdC5jb20vUEtJL2Rv
# Y3MvQ1BTL2RlZmF1bHQuaHRtMEAGCCsGAQUFBwICMDQeMiAdAEwAZQBnAGEAbABf
# AFAAbwBsAGkAYwB5AF8AUwB0AGEAdABlAG0AZQBuAHQALiAdMA0GCSqGSIb3DQEB
# CwUAA4ICAQAadO9XTyl7xBaFeLhQ0yL8CZ2sgpf4NP8qLJeVEuXkv8+/k8jjNKnb
# gbjcHgC+0jVvr+V/eZV35QLU8evYzU4eG2GiwlojGvCMqGJRRWcI4z88HpP4MIUX
# yDlAptcOsyEp5aWhaYwik8x0mOehR0PyU6zADzBpf/7SJSBtb2HT3wfV2XIALGmG
# dj1R26Y5SMk3YW0H3VMZy6fWYcK/4oOrD+Brm5XWfShRsIlKUaSabMi3H0oaDmmp
# 19zBftFJcKq2rbtyR2MX+qbWoqaG7KgQRJtjtrJpiQbHRoZ6GD/oxR0h1Xv5AiMt
# xUHLvx1MyBbvsZx//CJLSYpuFeOmf3Zb0VN5kYWd1dLbPXM18zyuVLJSR2rAqhOV
# 0o4R2plnXjKM+zeF0dx1hZyHxlpXhcK/3Q2PjJst67TuzyfTtV5p+qQWBAGnJGdz
# z01Ptt4FVpd69+lSTfR3BU+FxtgL8Y7tQgnRDXbjI1Z4IiY2vsqxjG6qHeSF2kcz
# Yo+kyZEzX3EeQK+YZcki6EIhJYocLWDZN4lBiSoWD9dhPJRoYFLv1keZoIBA7hWB
# dz6c4FMYGlAdOJWbHmYzEyc5F3iHNs5Ow1+y9T1HU7bg5dsLYT0q15IszjdaPkBC
# MaQfEAjCVpy/JF1RAp1qedIX09rBlI4HeyVxRKsGaubUxt8jmpZ1xTGCFhMwghYP
# AgEBMIGVMH4xCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYD
# VQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xKDAm
# BgNVBAMTH01pY3Jvc29mdCBDb2RlIFNpZ25pbmcgUENBIDIwMTACEzMAAAGzDLCA
# TFVUTcMAAAAAAbMwDQYJYIZIAWUDBAIBBQCgggEEMBkGCSqGSIb3DQEJAzEMBgor
# BgEEAYI3AgEEMBwGCisGAQQBgjcCAQsxDjAMBgorBgEEAYI3AgEVMC8GCSqGSIb3
# DQEJBDEiBCCjhIFvp2605r6uTOEDtEt+jDy+Enu00ERty3R+yGcMKzA8BgorBgEE
# AYI3CgMcMS4MLFNJMW1VeE03V1AwaEdESjQ4MFlqeVlYMUltREk4bEZEUUJpanAr
# NGpaMWc9MFoGCisGAQQBgjcCAQwxTDBKoCSAIgBNAGkAYwByAG8AcwBvAGYAdAAg
# AFcAaQBuAGQAbwB3AHOhIoAgaHR0cDovL3d3dy5taWNyb3NvZnQuY29tL3dpbmRv
# d3MwDQYJKoZIhvcNAQEBBQAEggEAGxUzQWgh6fisiOCdFJTd/nwuG/Rmw1KBtx0v
# sq/H6R5cT/CAKoRpf2ciOeJI4EpYt5SUPVU9bR5pBlSdlQu0d+SMihip8SPlOIHE
# p6HDy59tH4dbxeKYEmGbLjnIpjoNeZFeMvXKUQw37oyuf2UMRNRQJTyVuGNnlfka
# s4ho7tqU95KlOSE2OMuJRdK+sLbiHoVml27PfdfcR13p9zJoFmOzQkNCtowRqdTM
# TQ5YkxVcp6JewRIGYXBtlWGznx5PL74q2Hlxu1za9H/DRN3E4XVzKptMpRvQwDE6
# cW4TcjSzBHZ8LQ0x0CFwDW4/vxidjgFXJvoRMqAIFqhuISF9daGCE0YwghNCBgor
# BgEEAYI3AwMBMYITMjCCEy4GCSqGSIb3DQEHAqCCEx8wghMbAgEDMQ8wDQYJYIZI
# AWUDBAIBBQAwggE8BgsqhkiG9w0BCRABBKCCASsEggEnMIIBIwIBAQYKKwYBBAGE
# WQoDATAxMA0GCWCGSAFlAwQCAQUABCDLcpeEd0yKD8KqrFxbhFpsiUzrjdWqrOXX
# xcfpaRPLswIGWc1BKnqNGBMyMDE3MDkyOTAzNDk0My41MjJaMAcCAQGAAgH0oIG4
# pIG1MIGyMQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UE
# BxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMQwwCgYD
# VQQLEwNBT0MxJzAlBgNVBAsTHm5DaXBoZXIgRFNFIEVTTjoxMkU3LTMwNjQtNjEx
# MjElMCMGA1UEAxMcTWljcm9zb2Z0IFRpbWUtU3RhbXAgU2VydmljZaCCDsowggZx
# MIIEWaADAgECAgphCYEqAAAAAAACMA0GCSqGSIb3DQEBCwUAMIGIMQswCQYDVQQG
# EwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwG
# A1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMTIwMAYDVQQDEylNaWNyb3NvZnQg
# Um9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgMjAxMDAeFw0xMDA3MDEyMTM2NTVa
# Fw0yNTA3MDEyMTQ2NTVaMHwxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5n
# dG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNyb3NvZnQgQ29ycG9y
# YXRpb24xJjAkBgNVBAMTHU1pY3Jvc29mdCBUaW1lLVN0YW1wIFBDQSAyMDEwMIIB
# IjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAqR0NvHcRijog7PwTl/X6f2mU
# a3RUENWlCgCChfvtfGhLLF/Fw+Vhwna3PmYrW/AVUycEMR9BGxqVHc4JE458YTBZ
# sTBED/FgiIRUQwzXTbg4CLNC3ZOs1nMwVyaCo0UN0Or1R4HNvyRgMlhgRvJYR4Yy
# hB50YWeRX4FUsc+TTJLBxKZd0WETbijGGvmGgLvfYfxGwScdJGcSchohiq9LZIlQ
# YrFd/XcfPfBXday9ikJNQFHRD5wGPmd/9WbAA5ZEfu/QS/1u5ZrKsajyeioKMfDa
# TgaRtogINeh4HLDpmc085y9Euqf03GS9pAHBIAmTeM38vMDJRF1eFpwBBU8iTQID
# AQABo4IB5jCCAeIwEAYJKwYBBAGCNxUBBAMCAQAwHQYDVR0OBBYEFNVjOlyKMZDz
# Q3t8RhvFM2hahW1VMBkGCSsGAQQBgjcUAgQMHgoAUwB1AGIAQwBBMAsGA1UdDwQE
# AwIBhjAPBgNVHRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFNX2VsuP6KJcYmjRPZSQ
# W9fOmhjEMFYGA1UdHwRPME0wS6BJoEeGRWh0dHA6Ly9jcmwubWljcm9zb2Z0LmNv
# bS9wa2kvY3JsL3Byb2R1Y3RzL01pY1Jvb0NlckF1dF8yMDEwLTA2LTIzLmNybDBa
# BggrBgEFBQcBAQROMEwwSgYIKwYBBQUHMAKGPmh0dHA6Ly93d3cubWljcm9zb2Z0
# LmNvbS9wa2kvY2VydHMvTWljUm9vQ2VyQXV0XzIwMTAtMDYtMjMuY3J0MIGgBgNV
# HSABAf8EgZUwgZIwgY8GCSsGAQQBgjcuAzCBgTA9BggrBgEFBQcCARYxaHR0cDov
# L3d3dy5taWNyb3NvZnQuY29tL1BLSS9kb2NzL0NQUy9kZWZhdWx0Lmh0bTBABggr
# BgEFBQcCAjA0HjIgHQBMAGUAZwBhAGwAXwBQAG8AbABpAGMAeQBfAFMAdABhAHQA
# ZQBtAGUAbgB0AC4gHTANBgkqhkiG9w0BAQsFAAOCAgEAB+aIUQ3ixuCYP4FxAz2d
# o6Ehb7Prpsz1Mb7PBeKp/vpXbRkws8LFZslq3/Xn8Hi9x6ieJeP5vO1rVFcIK1GC
# RBL7uVOMzPRgEop2zEBAQZvcXBf/XPleFzWYJFZLdO9CEMivv3/Gf/I3fVo/HPKZ
# eUqRUgCvOA8X9S95gWXZqbVr5MfO9sp6AG9LMEQkIjzP7QOllo9ZKby2/QThcJ8y
# Sif9Va8v/rbljjO7Yl+a21dA6fHOmWaQjP9qYn/dxUoLkSbiOewZSnFjnXshbcOc
# o6I8+n99lmqQeKZt0uGc+R38ONiU9MalCpaGpL2eGq4EQoO4tYCbIjggtSXlZOz3
# 9L9+Y1klD3ouOVd2onGqBooPiRa6YacRy5rYDkeagMXQzafQ732D8OE7cQnfXXSY
# Ighh2rBQHm+98eEA3+cxB6STOvdlR3jo+KhIq/fecn5ha293qYHLpwmsObvsxsvY
# grRyzR30uIUBHoD7G4kqVDmyW9rIDVWZeodzOwjmmC3qjeAzLhIp9cAvVCch98is
# TtoouLGp25ayp0Kiyc8ZQU3ghvkqmqMRZjDTu3QyS99je/WZii8bxyGvWbWu3EQ8
# l1Bx16HSxVXjad5XwdHeMMD9zOZN+w2/XU/pnR4ZOC+8z1gFLu8NoFA12u8JJxzV
# s341Hgi62jbb01+P3nSISRIwggTZMIIDwaADAgECAhMzAAAArIohvHrSm3L0AAAA
# AACsMA0GCSqGSIb3DQEBCwUAMHwxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNo
# aW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNyb3NvZnQgQ29y
# cG9yYXRpb24xJjAkBgNVBAMTHU1pY3Jvc29mdCBUaW1lLVN0YW1wIFBDQSAyMDEw
# MB4XDTE2MDkwNzE3NTY1NFoXDTE4MDkwNzE3NTY1NFowgbIxCzAJBgNVBAYTAlVT
# MRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQK
# ExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xDDAKBgNVBAsTA0FPQzEnMCUGA1UECxMe
# bkNpcGhlciBEU0UgRVNOOjEyRTctMzA2NC02MTEyMSUwIwYDVQQDExxNaWNyb3Nv
# ZnQgVGltZS1TdGFtcCBTZXJ2aWNlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB
# CgKCAQEAocT0PKWOczGhF0Fcq3cIt6nRQ6q739x0+bo1VmqECdipu/tU9xjZxqWz
# Q+j6JgHMPTX1fgvkTJgq04aVJQVc3rs7DS9i7I/ZjHSvN4sXm2s3p0qwNK1yyIn1
# gcyh1T+o87EFqPenB7pB2aiPMUad7WIr4GqbeSy65/UZtiZ/hNIdpSgzsObCLXmY
# q4jjDx9me5rYGF5sgfE4YHQeOqen6zRqXF69daWtVZJXZdImOqAQCkEEsSeQZ+De
# 7ouVo+cA5A2cxgIOp9abTD0zyYS9rqLFvOGI50qf9rLjWqd6joyhGF5qRs72rKua
# sqj8r36n5LDnzQWiZ7X6QvHSAySq5wIDAQABo4IBGzCCARcwHQYDVR0OBBYEFNhH
# cKiFNYsTYa+HkOhFFyTgmKcNMB8GA1UdIwQYMBaAFNVjOlyKMZDzQ3t8RhvFM2ha
# hW1VMFYGA1UdHwRPME0wS6BJoEeGRWh0dHA6Ly9jcmwubWljcm9zb2Z0LmNvbS9w
# a2kvY3JsL3Byb2R1Y3RzL01pY1RpbVN0YVBDQV8yMDEwLTA3LTAxLmNybDBaBggr
# BgEFBQcBAQROMEwwSgYIKwYBBQUHMAKGPmh0dHA6Ly93d3cubWljcm9zb2Z0LmNv
# bS9wa2kvY2VydHMvTWljVGltU3RhUENBXzIwMTAtMDctMDEuY3J0MAwGA1UdEwEB
# /wQCMAAwEwYDVR0lBAwwCgYIKwYBBQUHAwgwDQYJKoZIhvcNAQELBQADggEBAEjs
# 6F4nwxsYnF20znZuNwwfXWMcDV2kI9IVtM7QQAnlm1+s8XntcO0yXl0MdSH089QV
# iQH1ZWuxwNaMWtC4hf1H+q30bxBJhph6/cFhG698YhK5ZUxRNlf5nWAUhMHY++Jv
# ECwXhWN+wo8eExXvgAfxUJct5L36ySg2mGE010wBWACqYtAHA03BEl2XLISfzvFG
# bPX69AYKzpuYe6nkNQiTZgzFRKhJULf3BTt3caqwCr9xbv57E+RpAAbvryIm4MV+
# rTZqnHCCFygC4L+8wyGkQAFrV1fS8J5rLQ1GyKfHR/6ElZt7T5wj5awd/gtvLz57
# yXW7SYv8jrhE3fqy5/qhggN0MIICXAIBATCB4qGBuKSBtTCBsjELMAkGA1UEBhMC
# VVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNV
# BAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEMMAoGA1UECxMDQU9DMScwJQYDVQQL
# Ex5uQ2lwaGVyIERTRSBFU046MTJFNy0zMDY0LTYxMTIxJTAjBgNVBAMTHE1pY3Jv
# c29mdCBUaW1lLVN0YW1wIFNlcnZpY2WiJQoBATAJBgUrDgMCGgUAAxUAOXAlixTI
# ed1fDF3pi5yzlJn3HLeggcEwgb6kgbswgbgxCzAJBgNVBAYTAlVTMRMwEQYDVQQI
# EwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNyb3Nv
# ZnQgQ29ycG9yYXRpb24xDDAKBgNVBAsTA0FPQzEnMCUGA1UECxMebkNpcGhlciBO
# VFMgRVNOOjI2NjUtNEMzRi1DNURFMSswKQYDVQQDEyJNaWNyb3NvZnQgVGltZSBT
# b3VyY2UgTWFzdGVyIENsb2NrMA0GCSqGSIb3DQEBBQUAAgUA3Xg9rzAiGA8yMDE3
# MDkyOTAzMzQwN1oYDzIwMTcwOTMwMDMzNDA3WjB0MDoGCisGAQQBhFkKBAExLDAq
# MAoCBQDdeD2vAgEAMAcCAQACAhkhMAcCAQACAhkSMAoCBQDdeY8vAgEAMDYGCisG
# AQQBhFkKBAIxKDAmMAwGCisGAQQBhFkKAwGgCjAIAgEAAgMW42ChCjAIAgEAAgMH
# oSAwDQYJKoZIhvcNAQEFBQADggEBACdn4ea1vsjQI3PdSoXjTqTIrJYy6Qq+87XA
# Fc7nZnmBCFs1mGojAAErXrsdJ3T6VsOTR7fkIB/+S3lhB10zSU8adL+o3qTgksbj
# A8Kq7dfC8v2l/gnX631kyEoWzJc8FuuTtnHWrfOCcDsfA5Dzbj5d+3YS8AKZ0Tih
# dtTBvHctfljBbIMzFN6V2ET07rnNhCcvGaiPuu8hgTc72Pkr7G9EPS51dbswxi3v
# mhZeZRChFPe13w0m2tE5HptMaeE8aK0DdhGzCfqMiJsgaKLDVY5t/7dTlYbXNOdq
# 4eibI8aMHlzMB9vkZvDFTMR+vq7YU8KbB7zVQsHxVFNxdiG0xUsxggL1MIIC8QIB
# ATCBkzB8MQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UE
# BxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMSYwJAYD
# VQQDEx1NaWNyb3NvZnQgVGltZS1TdGFtcCBQQ0EgMjAxMAITMwAAAKyKIbx60pty
# 9AAAAAAArDANBglghkgBZQMEAgEFAKCCATIwGgYJKoZIhvcNAQkDMQ0GCyqGSIb3
# DQEJEAEEMC8GCSqGSIb3DQEJBDEiBCCxjfy6Vrf8lGrY5jDXYBwKPDERDzV4reKF
# lHJgAc2cCDCB4gYLKoZIhvcNAQkQAgwxgdIwgc8wgcwwgbEEFDlwJYsUyHndXwxd
# 6Yucs5SZ9xy3MIGYMIGApH4wfDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hp
# bmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jw
# b3JhdGlvbjEmMCQGA1UEAxMdTWljcm9zb2Z0IFRpbWUtU3RhbXAgUENBIDIwMTAC
# EzMAAACsiiG8etKbcvQAAAAAAKwwFgQUmIO90ze9QYVmuUyWTTfn3QKIgPwwDQYJ
# KoZIhvcNAQELBQAEggEAYvl+PRZ29Y3HpX3P26jXfdQ2UkD0mMqmybGk6EX4VAyX
# ya1O0lPcp89UQyORDzfxb4HF8Bzjv8hxcsqdLchZ/XpnDNZoeoCs2YypGpKwDy1l
# qMxRjRPPuFD/XdUXwNVSqJ6je7obedtPa4oIprD4T96tEC4iG6d874gusMLmpNSP
# zp2Ly040z3Blm7+cXWOAUpk+K9KOO3gAEuuuSmFrRyBuaPA/m9hDUgn6DRnDBatA
# q5f+CRXvfgFoas0G9WzTAoN4iZ74a4U6mNpC34pF4C2Vg00wssC98lCgWXRSDU5v
# PAiTTvAzWk4z/bHdCO7Z4rLVXuDrZbQUr8NjubXsmg==
# SIG # End signature block
