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
# MIIiPAYJKoZIhvcNAQcCoIIiLTCCIikCAQExDzANBglghkgBZQMEAgEFADB5Bgor
# BgEEAYI3AgEEoGswaTA0BgorBgEEAYI3AgEeMCYCAwEAAAQQH8w7YFlLCE63JNLG
# KX7zUQIBAAIBAAIBAAIBAAIBADAxMA0GCWCGSAFlAwQCAQUABCDWE6EWxU1sBLSE
# jka4Eqyw4r0u2Hu9D47fajLL1PTWvKCCC38wggUHMIID76ADAgECAhMzAAABtGsb
# Q7hXc1IAAAAAAAG0MA0GCSqGSIb3DQEBCwUAMH4xCzAJBgNVBAYTAlVTMRMwEQYD
# VQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNy
# b3NvZnQgQ29ycG9yYXRpb24xKDAmBgNVBAMTH01pY3Jvc29mdCBDb2RlIFNpZ25p
# bmcgUENBIDIwMTAwHhcNMTcwNzE4MTc1MDQyWhcNMTgwNzEwMTc1MDQyWjB/MQsw
# CQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9u
# ZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMSkwJwYDVQQDEyBNaWNy
# b3NvZnQgV2luZG93cyBLaXRzIFB1Ymxpc2hlcjCCASIwDQYJKoZIhvcNAQEBBQAD
# ggEPADCCAQoCggEBALoNUC4sIGNyRsCwy4Hz1lNmFXull+eDYoV8icPzo7fp48hp
# WfrMVqFCARGABNkFu7NG+9vJw2ZxMGjOF/PPqLUnYr9wOuEqozMtkvKpR8mU0he4
# gzoPoYfVl3D2M/UPVyvfkeLiIIZ0KqrGkjE5Nib/Xcngu6gLGXj9dUXHA8dA40Hg
# BaIls59ygmky4zuMiH59X3ZFQ5PFuT7CLZLt0IDuHUUL6Cv2JgicUoerLEdWrTq9
# vtEtPGlM9ygDgOpM00ws9yRliMxiUhuCQbwJSNKhkDs/rNSrB6KCpKC8MWdIs0Wk
# Oac3y/1LRJB0T/XUvCUsq3Z89eBrAgs6Izqu5QsCAwEAAaOCAXswggF3MB8GA1Ud
# JQQYMBYGCisGAQQBgjcKAxQGCCsGAQUFBwMDMB0GA1UdDgQWBBRn2V9L5fyECUI1
# 7j47Ui+9hpG8pDBSBgNVHREESzBJpEcwRTENMAsGA1UECxMETU9QUjE0MDIGA1UE
# BRMrMjI5OTAzK2ZkNmI5ZTVkLWViNzMtNDE4OS1hYmMyLWY3Y2FjZGEzODFhYzAf
# BgNVHSMEGDAWgBTm/F97uyIAWORyTrX0IXQjMubvrDBWBgNVHR8ETzBNMEugSaBH
# hkVodHRwOi8vY3JsLm1pY3Jvc29mdC5jb20vcGtpL2NybC9wcm9kdWN0cy9NaWND
# b2RTaWdQQ0FfMjAxMC0wNy0wNi5jcmwwWgYIKwYBBQUHAQEETjBMMEoGCCsGAQUF
# BzAChj5odHRwOi8vd3d3Lm1pY3Jvc29mdC5jb20vcGtpL2NlcnRzL01pY0NvZFNp
# Z1BDQV8yMDEwLTA3LTA2LmNydDAMBgNVHRMBAf8EAjAAMA0GCSqGSIb3DQEBCwUA
# A4IBAQCir8BXOUv+Q73WyLmTPSVPGlvkmzwOjxOXAiyZAWIdvY1Bz0kGpMv4UMBw
# 6LCcY/niXi2Tq0ji3rTYzs+QSg+hKgAJp6KP8lIM9L5uyPa9jF0F6TK15mH58XSt
# 7ed6evQ+rNqFCcfFacX/KHfEq/SWJ0yiUHhKBzKGv940rzQuzN30TuCYxzKR85hl
# fGn3xz1EN3Knbkm7j5S9HIaaz1i4sDBp1V6qLY2wCgNdaTnyC8vjWfya+91wigW8
# i5EyWwmCgKqP828UHGWUO5J1WWzKZSOmQmpZo0sDRts7M4J8X8laqtbBi2qN5Om4
# PDTVwzIiL04c5IWK3sq4srU+WKBIMIIGcDCCBFigAwIBAgIKYQxSTAAAAAAAAzAN
# BgkqhkiG9w0BAQsFADCBiDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0
# b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3Jh
# dGlvbjEyMDAGA1UEAxMpTWljcm9zb2Z0IFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9y
# aXR5IDIwMTAwHhcNMTAwNzA2MjA0MDE3WhcNMjUwNzA2MjA1MDE3WjB+MQswCQYD
# VQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEe
# MBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMSgwJgYDVQQDEx9NaWNyb3Nv
# ZnQgQ29kZSBTaWduaW5nIFBDQSAyMDEwMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A
# MIIBCgKCAQEA6Q5kUHlntcTj/QkATJ6UrPdWaOpE2M/FWE+ppXZ8bUW60zmStKQe
# +fllguQX0o/9RJwI6GWTzixVhL99COMuK6hBKxi3oktuSUxrFQfe0dLCiR5xlM21
# f0u0rwjYzIjWaxeUOpPOJj/s5v40mFfVHV1J9rIqLtWFu1k/+JC0K4N0yiuzO0bj
# 8EZJwRdmVMkcvR3EVWJXcvhnuSUgNN5dpqWVXqsogM3Vsp7lA7Vj07IUyMHIiiYK
# WX8H7P8O7YASNUwSpr5SW/Wm2uCLC0h31oVH1RC5xuiq7otqLQVcYMa0KlucIxxf
# ReMaFB5vN8sZM4BqiU2jamZjeJPVMM+VHwIDAQABo4IB4zCCAd8wEAYJKwYBBAGC
# NxUBBAMCAQAwHQYDVR0OBBYEFOb8X3u7IgBY5HJOtfQhdCMy5u+sMBkGCSsGAQQB
# gjcUAgQMHgoAUwB1AGIAQwBBMAsGA1UdDwQEAwIBhjAPBgNVHRMBAf8EBTADAQH/
# MB8GA1UdIwQYMBaAFNX2VsuP6KJcYmjRPZSQW9fOmhjEMFYGA1UdHwRPME0wS6BJ
# oEeGRWh0dHA6Ly9jcmwubWljcm9zb2Z0LmNvbS9wa2kvY3JsL3Byb2R1Y3RzL01p
# Y1Jvb0NlckF1dF8yMDEwLTA2LTIzLmNybDBaBggrBgEFBQcBAQROMEwwSgYIKwYB
# BQUHMAKGPmh0dHA6Ly93d3cubWljcm9zb2Z0LmNvbS9wa2kvY2VydHMvTWljUm9v
# Q2VyQXV0XzIwMTAtMDYtMjMuY3J0MIGdBgNVHSAEgZUwgZIwgY8GCSsGAQQBgjcu
# AzCBgTA9BggrBgEFBQcCARYxaHR0cDovL3d3dy5taWNyb3NvZnQuY29tL1BLSS9k
# b2NzL0NQUy9kZWZhdWx0Lmh0bTBABggrBgEFBQcCAjA0HjIgHQBMAGUAZwBhAGwA
# XwBQAG8AbABpAGMAeQBfAFMAdABhAHQAZQBtAGUAbgB0AC4gHTANBgkqhkiG9w0B
# AQsFAAOCAgEAGnTvV08pe8QWhXi4UNMi/AmdrIKX+DT/KiyXlRLl5L/Pv5PI4zSp
# 24G43B4AvtI1b6/lf3mVd+UC1PHr2M1OHhthosJaIxrwjKhiUUVnCOM/PB6T+DCF
# F8g5QKbXDrMhKeWloWmMIpPMdJjnoUdD8lOswA8waX/+0iUgbW9h098H1dlyACxp
# hnY9UdumOUjJN2FtB91TGcun1mHCv+KDqw/ga5uV1n0oUbCJSlGkmmzItx9KGg5p
# qdfcwX7RSXCqtq27ckdjF/qm1qKmhuyoEESbY7ayaYkGx0aGehg/6MUdIdV7+QIj
# LcVBy78dTMgW77Gcf/wiS0mKbhXjpn92W9FTeZGFndXS2z1zNfM8rlSyUkdqwKoT
# ldKOEdqZZ14yjPs3hdHcdYWch8ZaV4XCv90Nj4ybLeu07s8n07VeafqkFgQBpyRn
# c89NT7beBVaXevfpUk30dwVPhcbYC/GO7UIJ0Q124yNWeCImNr7KsYxuqh3khdpH
# M2KPpMmRM19xHkCvmGXJIuhCISWKHC1g2TeJQYkqFg/XYTyUaGBS79ZHmaCAQO4V
# gXc+nOBTGBpQHTiVmx5mMxMnORd4hzbOTsNfsvU9R1O24OXbC2E9KteSLM43Wj5A
# QjGkHxAIwlacvyRdUQKdannSF9PawZSOB3slcUSrBmrm1MbfI5qWdcUxghYTMIIW
# DwIBATCBlTB+MQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4G
# A1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMSgw
# JgYDVQQDEx9NaWNyb3NvZnQgQ29kZSBTaWduaW5nIFBDQSAyMDEwAhMzAAABtGsb
# Q7hXc1IAAAAAAAG0MA0GCWCGSAFlAwQCAQUAoIIBBDAZBgkqhkiG9w0BCQMxDAYK
# KwYBBAGCNwIBBDAcBgorBgEEAYI3AgELMQ4wDAYKKwYBBAGCNwIBFTAvBgkqhkiG
# 9w0BCQQxIgQgo4SBb6dutOa+rkzhA7RLfow8vhJ7tNBEbct0fshnDCswPAYKKwYB
# BAGCNwoDHDEuDCxTSTFtVXhNN1dQMGhHREo0ODBZanlZWDFJbURJOGxGRFFCaWpw
# KzRqWjFnPTBaBgorBgEEAYI3AgEMMUwwSqAkgCIATQBpAGMAcgBvAHMAbwBmAHQA
# IABXAGkAbgBkAG8AdwBzoSKAIGh0dHA6Ly93d3cubWljcm9zb2Z0LmNvbS93aW5k
# b3dzMA0GCSqGSIb3DQEBAQUABIIBADW5rSeftmcC7IbfW6T/lv10xu4sET5/Hwfa
# 5zNOI8tO8gLX8BAuTkqDBDQOtWprou1HJBzCbzIGGQ5p/A5GvgAYmRiWfCkRpxGN
# sUgJvkJ1A073Dook1jWDFYNWdXRIs6aTs8tIDT7QwzdIVwzJZlbDHAbiF4/9jMlj
# 5lXFcO+AWeBnV9R8SHQZnZnsJjOiqXHeYjl91kh9SS1WrxCztO8JVh9N4uyaIr7m
# 2liDI+VU800SKC04+QUEoFdPuZMGIrAKzMk0juXldvt0Z+eB/h9ty4XQIctVoLn1
# qM3fpWvduknXaVkP3gpQjtlstYGkV2xixqDblaf17TzZmhXUrKahghNGMIITQgYK
# KwYBBAGCNwMDATGCEzIwghMuBgkqhkiG9w0BBwKgghMfMIITGwIBAzEPMA0GCWCG
# SAFlAwQCAQUAMIIBPAYLKoZIhvcNAQkQAQSgggErBIIBJzCCASMCAQEGCisGAQQB
# hFkKAwEwMTANBglghkgBZQMEAgEFAAQgnGDdvF7AwTVDtMfwkxAN0+tS8DwKeS4D
# DT9gCoMy1VACBlqyryTDjBgTMjAxODA0MTExMzUyNTIuNzM0WjAHAgEBgAIB9KCB
# uKSBtTCBsjELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNV
# BAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEMMAoG
# A1UECxMDQU9DMScwJQYDVQQLEx5uQ2lwaGVyIERTRSBFU046MjEzNy0zN0EwLTRB
# QUExJTAjBgNVBAMTHE1pY3Jvc29mdCBUaW1lLVN0YW1wIFNlcnZpY2Wggg7KMIIG
# cTCCBFmgAwIBAgIKYQmBKgAAAAAAAjANBgkqhkiG9w0BAQsFADCBiDELMAkGA1UE
# BhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAc
# BgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEyMDAGA1UEAxMpTWljcm9zb2Z0
# IFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IDIwMTAwHhcNMTAwNzAxMjEzNjU1
# WhcNMjUwNzAxMjE0NjU1WjB8MQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGlu
# Z3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBv
# cmF0aW9uMSYwJAYDVQQDEx1NaWNyb3NvZnQgVGltZS1TdGFtcCBQQ0EgMjAxMDCC
# ASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKkdDbx3EYo6IOz8E5f1+n9p
# lGt0VBDVpQoAgoX77XxoSyxfxcPlYcJ2tz5mK1vwFVMnBDEfQRsalR3OCROOfGEw
# WbEwRA/xYIiEVEMM1024OAizQt2TrNZzMFcmgqNFDdDq9UeBzb8kYDJYYEbyWEeG
# MoQedGFnkV+BVLHPk0ySwcSmXdFhE24oxhr5hoC732H8RsEnHSRnEnIaIYqvS2SJ
# UGKxXf13Hz3wV3WsvYpCTUBR0Q+cBj5nf/VmwAOWRH7v0Ev9buWayrGo8noqCjHw
# 2k4GkbaICDXoeByw6ZnNPOcvRLqn9NxkvaQBwSAJk3jN/LzAyURdXhacAQVPIk0C
# AwEAAaOCAeYwggHiMBAGCSsGAQQBgjcVAQQDAgEAMB0GA1UdDgQWBBTVYzpcijGQ
# 80N7fEYbxTNoWoVtVTAZBgkrBgEEAYI3FAIEDB4KAFMAdQBiAEMAQTALBgNVHQ8E
# BAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAfBgNVHSMEGDAWgBTV9lbLj+iiXGJo0T2U
# kFvXzpoYxDBWBgNVHR8ETzBNMEugSaBHhkVodHRwOi8vY3JsLm1pY3Jvc29mdC5j
# b20vcGtpL2NybC9wcm9kdWN0cy9NaWNSb29DZXJBdXRfMjAxMC0wNi0yMy5jcmww
# WgYIKwYBBQUHAQEETjBMMEoGCCsGAQUFBzAChj5odHRwOi8vd3d3Lm1pY3Jvc29m
# dC5jb20vcGtpL2NlcnRzL01pY1Jvb0NlckF1dF8yMDEwLTA2LTIzLmNydDCBoAYD
# VR0gAQH/BIGVMIGSMIGPBgkrBgEEAYI3LgMwgYEwPQYIKwYBBQUHAgEWMWh0dHA6
# Ly93d3cubWljcm9zb2Z0LmNvbS9QS0kvZG9jcy9DUFMvZGVmYXVsdC5odG0wQAYI
# KwYBBQUHAgIwNB4yIB0ATABlAGcAYQBsAF8AUABvAGwAaQBjAHkAXwBTAHQAYQB0
# AGUAbQBlAG4AdAAuIB0wDQYJKoZIhvcNAQELBQADggIBAAfmiFEN4sbgmD+BcQM9
# naOhIW+z66bM9TG+zwXiqf76V20ZMLPCxWbJat/15/B4vceoniXj+bzta1RXCCtR
# gkQS+7lTjMz0YBKKdsxAQEGb3FwX/1z5Xhc1mCRWS3TvQhDIr79/xn/yN31aPxzy
# mXlKkVIArzgPF/UveYFl2am1a+THzvbKegBvSzBEJCI8z+0DpZaPWSm8tv0E4XCf
# Mkon/VWvL/625Y4zu2JfmttXQOnxzplmkIz/amJ/3cVKC5Em4jnsGUpxY517IW3D
# nKOiPPp/fZZqkHimbdLhnPkd/DjYlPTGpQqWhqS9nhquBEKDuLWAmyI4ILUl5WTs
# 9/S/fmNZJQ96LjlXdqJxqgaKD4kWumGnEcua2A5HmoDF0M2n0O99g/DhO3EJ3110
# mCIIYdqwUB5vvfHhAN/nMQekkzr3ZUd46PioSKv33nJ+YWtvd6mBy6cJrDm77MbL
# 2IK0cs0d9LiFAR6A+xuJKlQ5slvayA1VmXqHczsI5pgt6o3gMy4SKfXAL1QnIffI
# rE7aKLixqduWsqdCosnPGUFN4Ib5KpqjEWYw07t0MkvfY3v1mYovG8chr1m1rtxE
# PJdQcdeh0sVV42neV8HR3jDA/czmTfsNv11P6Z0eGTgvvM9YBS7vDaBQNdrvCScc
# 1bN+NR4Iuto229Nfj950iEkSMIIE2TCCA8GgAwIBAgITMwAAAK81j//TIkV2SwAA
# AAAArzANBgkqhkiG9w0BAQsFADB8MQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2Fz
# aGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENv
# cnBvcmF0aW9uMSYwJAYDVQQDEx1NaWNyb3NvZnQgVGltZS1TdGFtcCBQQ0EgMjAx
# MDAeFw0xNjA5MDcxNzU2NTZaFw0xODA5MDcxNzU2NTZaMIGyMQswCQYDVQQGEwJV
# UzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UE
# ChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMQwwCgYDVQQLEwNBT0MxJzAlBgNVBAsT
# Hm5DaXBoZXIgRFNFIEVTTjoyMTM3LTM3QTAtNEFBQTElMCMGA1UEAxMcTWljcm9z
# b2Z0IFRpbWUtU3RhbXAgU2VydmljZTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCC
# AQoCggEBAJPoQIYOGstx8AMNpo+k52ES0GHqkGqVVrq3oE1LKWTYUZo7XWeTrYju
# Q9TdXdTvEnGfbT/16pcqyDq3VRHUpzO1dERNmE3heqXH3akszIgfCG8+8c+E5eFs
# D+fD7jmBiykzJ1n4T86lm40GA67e1ElTYuNZJ/XoCky8xuAfV93Rm/9OB9BsYJiX
# ga5hDpB55Asoy/m9EGs8wXMREF7i41L2P2F65EWvdUGtSwy16TQaETdwoD/orCu0
# B5O+roPJ2eJ0kXBhsBV6RPSEkQ382yQzZgDMIIvuwWg9cR+ffQvl0mgnhp5psqqz
# HEoXVPkHaf53b8c/xpzS8VJQq8eXOKMCAwEAAaOCARswggEXMB0GA1UdDgQWBBR9
# HlXGMYraYAsGZrAU2Wr8exL24TAfBgNVHSMEGDAWgBTVYzpcijGQ80N7fEYbxTNo
# WoVtVTBWBgNVHR8ETzBNMEugSaBHhkVodHRwOi8vY3JsLm1pY3Jvc29mdC5jb20v
# cGtpL2NybC9wcm9kdWN0cy9NaWNUaW1TdGFQQ0FfMjAxMC0wNy0wMS5jcmwwWgYI
# KwYBBQUHAQEETjBMMEoGCCsGAQUFBzAChj5odHRwOi8vd3d3Lm1pY3Jvc29mdC5j
# b20vcGtpL2NlcnRzL01pY1RpbVN0YVBDQV8yMDEwLTA3LTAxLmNydDAMBgNVHRMB
# Af8EAjAAMBMGA1UdJQQMMAoGCCsGAQUFBwMIMA0GCSqGSIb3DQEBCwUAA4IBAQBq
# yACGePsMQpwQ1vcorA+Eaov83VvqH1pARKkuE1+LGkl2aRIq5oTm+Oa60Y88Lint
# SzUg4IG6+tWDFxWbdVOaPH9jkMugCGQv82HzSvCK8EVOiI08a5CNAOJrI0mseWcg
# 52UzrvrkIsFCDXVlD9SdzR7jMN6sWoYawoWHRyTufDzicjg5GG48dY3mAdnHd3Cj
# 2vpZuYlAWZG2xfK7hS2d1Rh/45Mbcn+xCa0QA67FJSbnzaN+orW49UrVNBR8j/KC
# wzYI0jCINnXXCBlrYheR0wNCsnOM0RWodSms/4BFC0Wx3XL2WTW5UgbO5oh//y2s
# rNH84KPP/Bw5H9vQENPboYIDdDCCAlwCAQEwgeKhgbikgbUwgbIxCzAJBgNVBAYT
# AlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYD
# VQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xDDAKBgNVBAsTA0FPQzEnMCUGA1UE
# CxMebkNpcGhlciBEU0UgRVNOOjIxMzctMzdBMC00QUFBMSUwIwYDVQQDExxNaWNy
# b3NvZnQgVGltZS1TdGFtcCBTZXJ2aWNloiUKAQEwCQYFKw4DAhoFAAMVANjqrBUt
# by6lLab9AgNQ4oAb/k4joIHBMIG+pIG7MIG4MQswCQYDVQQGEwJVUzETMBEGA1UE
# CBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9z
# b2Z0IENvcnBvcmF0aW9uMQwwCgYDVQQLEwNBT0MxJzAlBgNVBAsTHm5DaXBoZXIg
# TlRTIEVTTjoyNjY1LTRDM0YtQzVERTErMCkGA1UEAxMiTWljcm9zb2Z0IFRpbWUg
# U291cmNlIE1hc3RlciBDbG9jazANBgkqhkiG9w0BAQUFAAIFAN54UQQwIhgPMjAx
# ODA0MTEwOTE2NTJaGA8yMDE4MDQxMjA5MTY1MlowdDA6BgorBgEEAYRZCgQBMSww
# KjAKAgUA3nhRBAIBADAHAgEAAgInMTAHAgEAAgIZczAKAgUA3nmihAIBADA2Bgor
# BgEEAYRZCgQCMSgwJjAMBgorBgEEAYRZCgMBoAowCAIBAAIDFuNgoQowCAIBAAID
# HoSAMA0GCSqGSIb3DQEBBQUAA4IBAQA+9PcTzqZe/L5R+kcnApt4hF6835V9noCJ
# wSumBzLGDlGLgcPaC2+xF3wJnrQIFTFH9YzhAguiL27Zb03MuMzkhm2rpNpzTr8z
# KCkfhryDJjJ84mp3bfXo+ZVhRVdILiTt7vSzsso3frZWkMSgZIICs5GGpfh3Mqt/
# gyO1cyRAyC8QPdaZNoLIeMhyke2j+Jx1Ea4jhIkQjg09XZqw8qExgXA2QIQsVQts
# 8lG/hvEdjga4WD3H4QsZtr5fdvxtVwFUnlGQ0N1wXcxhT69YJwmSa05OUmV4P0xP
# t7F0qYneXY1nGjQn1OZ/XSUciWF53lXWldbKqIYTzL8w6dmFynyYMYIC9TCCAvEC
# AQEwgZMwfDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNV
# BAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEmMCQG
# A1UEAxMdTWljcm9zb2Z0IFRpbWUtU3RhbXAgUENBIDIwMTACEzMAAACvNY//0yJF
# dksAAAAAAK8wDQYJYIZIAWUDBAIBBQCgggEyMBoGCSqGSIb3DQEJAzENBgsqhkiG
# 9w0BCRABBDAvBgkqhkiG9w0BCQQxIgQg6QvYEiwXnHHvYpuKowIoQeO/F/CZfT8C
# HBwHAGiL4QAwgeIGCyqGSIb3DQEJEAIMMYHSMIHPMIHMMIGxBBTY6qwVLW8upS2m
# /QIDUOKAG/5OIzCBmDCBgKR+MHwxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNo
# aW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNyb3NvZnQgQ29y
# cG9yYXRpb24xJjAkBgNVBAMTHU1pY3Jvc29mdCBUaW1lLVN0YW1wIFBDQSAyMDEw
# AhMzAAAArzWP/9MiRXZLAAAAAACvMBYEFOZmRolbaEEICckP7ezbXzJ4ewHMMA0G
# CSqGSIb3DQEBCwUABIIBAFTRuLHcKeNe2Lr8O0obkZQa7mt0HZLe9v5mS5ILL/Hn
# 3+MWmE3KWO+FhUdnlnU1amqo9jGZzuUGSSfQlfGc/aC2ML1WlJFJe5WVDDOKXh7w
# nWVblvKzcwemuepSqmQadsffDC/cxS6la+qKQc70hpCiIpdEo5eYzAsxvluq/QTj
# iZGgNQqA9+5joNk55jsOLXM4lnzxmMtHWPwxy3UShoqT6A08+cmAF9XdO2PXDzXi
# bzrSFtPNcfkQIvrHtbrM10DrfoLTgj31vKSTWV2fguM+/f8CsV2FOAdgKXA6QH8X
# x35fcTtxjkCrgmeYSYzKLS2LeMra5mu/mgzaxbztUag=
# SIG # End signature block
