AzStackHci.EnvironmentChecker

10.2509.0.2010

AzStackHciSBEHealth/AzStackHciSBEHealth.psm1

                                <#############################################################

 #                                                           #

 # Copyright (C) Microsoft Corporation. All rights reserved. #

 #                                                           #

 #############################################################>

 $MetaData = @{

    "OperationType" =  @("PreUpdate", "PreUpdateJIT") # PreUpdateJIT should be removed after 2508

    "UIName" = 'Azure Stack HCI SBE Health'

    "UIDescription" = 'Check SBE Health requirements'

}

Import-Module $PSScriptRoot\..\AzStackHci.EnvironmentChecker.Reporting.psm1 -Force -DisableNameChecking -Global

Import-Module $PSScriptRoot\AzStackHci.SBEHealth.Helpers.psm1 -Force -DisableNameChecking -Global

function Test-AzStackHciSBEHealth

{

    param (

        [parameter(Mandatory = $true)]

        [ValidateNotNullOrEmpty()]

        $Parameters,

        [parameter(Mandatory = $true)]

        [ValidateNotNullOrEmpty()]

        $OperationType,

        [parameter(Mandatory = $false)]

        [ValidateSet('Small','Medium','Large')]

        [String]

        $HardwareClass = "Medium",

        [parameter(Mandatory = $false)]

        [ValidateSet('Standard','Stretch','RackAware')]

        [String]

        $ClusterPattern = "Standard",

        [parameter(Mandatory = $false)]

        [switch]

        $FailFast

    )

    try

    {

        $backupPSModuleAutoLoadingPreference = $PSModuleAutoLoadingPreference

        # Disable module auto-loading and explicitly import modules needed.

        $PSModuleAutoLoadingPreference = [System.Management.Automation.PSModuleAutoLoadingPreference]::None

        Import-Module Microsoft.PowerShell.Utility -Verbose:$false

        Import-Module Microsoft.PowerShell.Management -Verbose:$false

        Import-Module NetTCPIP -Verbose:$false

        Import-Module DnsClient -Verbose:$false

        Import-Module PackageManagement -Verbose:$false

        # Import Module via Helper in case this is update

        [EnvironmentValidator]::EnvironmentValidatorImport($Parameters)

        $ENV:EnvChkrOp = $OperationType

        Trace-Execution "Starting SBE Health validation for $OperationType"

        $allResult = @()

        $exitEarly = $false

        # Start with default of running SBE from local SBE Cache paths (needed for Deployment and AddNode since CSV doesn't exist or isn't accessible yet)

        $runFrom = "LOCAL"

        if ($OperationType -eq 'Deployment')

        {

            Trace-Execution "Checking SBE Configuration"

            $sbeConfigNuget = Get-ASArtifactPath -NugetName "Microsoft.AzureStack.SBEConfiguration"

            # Only run tests if the SBE Package is 4.1.x.x or later

            $sbeVerMatch = "[4-9]\.[1-9]\."

            if ($sbeConfigNuget -notmatch $sbeVerMatch)

            {

                $detailedMessage = "SBE Configuration nuget '$($sbeConfigNuget)' does not support this test. Must be version 4.1.x.x or later."

                Trace-Execution $detailedMessage

                $allResult += (New-Object -TypeName PsObject -Property @{Result = 'INFORMATIONAL'; FailedResult = $null; ExecutionDetail = $detailedMessage})

                $exitEarly = $true

            }

            $sbeMetadataPath = Join-Path -Path $sbeConfigNuget -ChildPath "content"

            $oemMetadataXmlPath = Join-Path -Path $sbeMetadataPath -ChildPath "oemMetadata.xml"

            if ($false -eq (Test-Path -Path $oemMetadataXmlPath))

            {

                throw "Unable to locate oemMetadata.xml file at $oemMetadataXmlPath"

            }

            [xml]$oemMetadata = Get-Content -Path $oemMetadataXmlPath

            $sbeVersion = $oemMetadata.UpdatePackageManifest.UpdateInfo.Version

            Trace-Execution "Getting SBE Package source local path"

            $sbeSourcePath = $Parameters.Roles["SBE"].PublicConfiguration.PublicInfo.SBEContentPaths.SBESeedNodePath

            if ($null -eq $sbeSourcePath)

            {

                $detailedMessage = "SBE Seed Node Path property did not get populated. Please retry the deployment."

                Trace-Execution $detailedMessage

                throw $detailedMessage

            }

        }

        elseif ($OperationType -eq 'PreUpdate')

        {

            # First, make sure firewall rules are not blocking access to the manifest endpoint

            try {

                $diagnosticInfo = Get-SolutionDiscoveryDiagnosticInfo 3>$null 4>$null

                $sbeEndpoint = $diagnosticInfo.Configuration.ComponentUris["SBE"]

                Trace-Execution "SBE manifest endpoint: $sbeEndpoint"

            }

            catch {

                Trace-Execution "Failed to get SBE manifest endpoint from Get-SolutionDiscoveryDiagnosticInfo. Error: $($PSItem.Exception.Message)"

            }

            $endpointAccessResult = New-SBEHealthResultObject -TestName 'Test-Endpoint-Connectivity' -TargetName $env:ComputerName -Severity 'CRITICAL' -Status 'SUCCESS' -Description "Validate SBE manifest reachable: $sbeEndpoint"

            $endpointAccessResult.TargetResourceID = $sbeEndpoint

            $endpointAccessResult.TargetResourceName = 'Hardware vendor Solution Builder Extension manifest'

            if ([System.String]::IsNullOrWhiteSpace($sbeEndpoint))

            {

                Trace-Execution "SBE manifest endpoint not reported by Get-SolutionDiscoveryDiagnosticInfo."

                $endpointAccessResult.Status = 'FAILURE'

                # don't want to block updates if there is a bug with Get-SolutionDiscoveryDiagnosticInfo reporting the endpoint

                $endpointAccessResult.Severity = 'WARNING'

                $endpointAccessResult.Description = "SBE manifest endpoint not reported by Get-SolutionDiscoveryDiagnosticInfo."

                $endpointAccessResult.Remediation = "Check the Get-SolutionDiscoveryDiagnosticInfo output for the SBE manifest endpoint. If it is missing, check the Solution Discovery service configuration."

            }

            else

            {

                try

                {

                    Trace-Execution = "Checking connectivity to SBE manifest endpoint: $sbeEndpoint"

                    # Need to use try/catch.  Apparently Invoke-WebRequest doesn't really support SilentlyContinue

                    $manifestResponse = Invoke-WebRequest -Uri $sbeEndpoint -UseBasicParsing -ErrorAction SilentlyContinue

                    Trace-Execution "SBE manifest response: $($manifestResponse.StatusCode)"

                }

                catch

                {

                    $msg = "Failed to reach SBE manifest endpoint: $sbeEndpoint. Error: $($PSItem.Exception.Message)"

                    Trace-Execution $msg

                    $endpointAccessResult.Status = 'FAILURE'

                    $endpointAccessResult.Description = $msg

                }

                if ($null -eq $manifestResponse)

                {

                    $msg = "Failed to reach SBE manifest endpoint: $sbeEndpoint. No response received."

                    Trace-Execution $msg

                    $endpointAccessResult.Status = 'FAILURE'

                    $endpointAccessResult.Description = $msg

                }

                elseif ($manifestResponse.StatusCode -ne 200)

                {

                    $msg = "Failed to reach SBE manifest endpoint: $sbeEndpoint. Response code: $($manifestResponse.StatusCode)"

                    Trace-Execution $msg

                    $endpointAccessResult.Status = 'FAILURE'

                    $endpointAccessResult.Description = $msg

                }

                if ($endpointAccessResult.Status -eq 'FAILURE')

                {

                    $endpointAccessResult.Remediation = "Check firewall rules to ensure the SBE manifest endpoint $sbeEndpoint is reachable."

                    if ($sbeEndpoint -like "*aka.ms*")

                    {

                        $endpointAccessResult.Remediation += " NOTE: Because aka.ms redirects, you will need to allow HTTPS(443) to aka.ms, redirectiontool.trafficmanager.net, and to the target of $sbeEndpoint. To determine the redirection target, browse to $sbeEndpoint and note the URL that it redirects to in your browser address bar."

                    }

                }

            }

            # continue with other tests - having bad firewall rules doesn't mean we can skip the rest of the tests

            $allResult += $endpointAccessResult

            # Next, get the installed SBE info - we might need to fall back to this SBE

            $sbeVersion = '1.0'

            $sbeSourcePath = [System.Environment]::GetEnvironmentVariable("SBEInstalledContent", "Machine")

            $sbeMetadataPath = [System.Environment]::GetEnvironmentVariable("SBEInstalledMetadata", "Machine")

            if ($null -ne $sbeMetadataPath)

            {

                $oemMetadataXmlPath = Join-Path -Path $sbeMetadataPath -ChildPath "oemMetadata.xml"

                if ($true -eq (Test-Path -Path $oemMetadataXmlPath))

                {

                    [xml]$oemMetadata = Get-Content -Path $oemMetadataXmlPath

                    $sbeVersion = $oemMetadata.UpdatePackageManifest.UpdateInfo.Version

                }

            }

            $sbeInstalled = $false

            $installSBEResult = New-SBEHealthResultObject -TestName 'Test-Installed-SBE-Env-Vars' -TargetName $env:ComputerName -Status 'SUCCESS' -Description "Validate Installed SBE Env Vars"

            if (($null -ne $sbeSourcePath) -and ($null -ne $sbeMetadataPath) -and ($null -ne $sbeVersion))

            {

                $detailedMessage = "Detected SBE $sbeVersion is installed. TBD if we will use this or a newer version for checks."

                $sbeInstalled = $true

            }

            elseif ((($null -eq $sbeSourcePath) -and ($null -eq $sbeMetadataPath) -and ($null -eq $sbeVersion)) -or ($sbeVersion -eq '1.0'))

            {

                Trace-Execution "SBE ENV vars - content: [$sbeSourcePath], metadata: [$sbeMetadataPath], sbeVersion [$sbeVersion]"

                $detailedMessage = "No SBE installed. May be skipping checks if this isn't an update including an SBE."

            }

            else

            {

                $detailedMessage = "Inconsistent SBE ENV vars!! content: [$sbeSourcePath], metadata: [$sbeMetadataPath], sbeVersion [$sbeVersion]"

                $installSBEResult.Severity = 'WARNING'

                $installSBEResult.Remediation = "Update to latest available Solution Builder Extension to restore consistent SBE state."

            }

            Trace-Execution $detailedMessage

            $installSBEResult.AdditionalData.Detail = $detailedMessage

            $allResult += $installSBEResult

            # Figure out if this is a period "system" healthcheck or "preUpdate" HealthCheck

            $runtimeParameters = $Parameters.RunInformation['RuntimeParameter']

            $packagePath = $runtimeParameters["UpdatePackagePath"]

            $updateVersion = $runtimeParameters["UpdateVersion"]

            if ($null -eq $packagePath)

            {

                Trace-Execution "System HealthCheck detected."

                if ($sbeInstalled)

                {

                    Trace-Execution -Message "System check scenario - Using installed SBE - content: [$sbeSourcePath], metadata: [$sbeMetadataPath], sbeVersion [$sbeVersion]"

                    # For the "installed" system check scenario we want to just run from the installed CSV dir as it is already properly organzied (with split content and metadata)

                    #   Note: We can't run from the update CSV as it is messy - has combined content and metadata as well as the zip files

                    $runFrom = "CSV"

                }

                else

                {

                    # Early exit, there is no SBE to test with

                    $exitEarly = $true

                }

            }

            else

            {

                Trace-Execution "Update package @: [$packagePath]"

                Trace-Execution "Update version @: [$updateVersion]"

                $updateEnvVarsForSBE = $false

                # The package path is expected to be a full path to an update package file (e.g. a self-

                # extracting .exe, metadata.xml, or oemMetadata.xml file). The content is in the same dir.

                # Also paths from runtime params often have extra \\ in them like: C:\\ClusterStorage\\Infrastructure_1\\Shares\\SU1_Infrastructure_1\\Updates\\Packages\Solution99.9999.9.11\metadata.xml

                $updatePackageBaseDir = (Split-Path $packagePath -Parent).Replace( '\\', '\')

                if ($updateVersion -match '^\d{2}\.\d{4}\..*')

                {

                    # Version is something like 10.2405.1.13 and indicates this is a solution update

                    $potentialSBEPath = "$updatePackageBaseDir\SBE"

                    if (Test-Path -Path $potentialSBEPath)

                    {

                        $sbeSourcePath = $potentialSBEPath

                        $sbeMetadataPath = $potentialSBEPath

                        $oemMetadataXmlPath = Join-Path -Path $sbeMetadataPath -ChildPath "oemMetadata.xml"

                        if ($false -eq (Test-Path -Path $oemMetadataXmlPath))

                        {

                            throw "Unable to locate oemMetadata.xml file at $oemMetadataXmlPath"

                        }

                        [xml]$oemMetadata = Get-Content -Path $oemMetadataXmlPath

                        $sbeVersion = $oemMetadata.UpdatePackageManifest.UpdateInfo.Version

                        Trace-Execution "Using SBE from Solution Update - content: [$sbeSourcePath], metadata: [$sbeMetadataPath], sbeVersion [$sbeVersion]"

                        $updateEnvVarsForSBE = $true

                    }

                    elseif ($sbeInstalled)

                    {

                        Trace-Execution -Message "Non-SBE Solution update scenario - Using installed SBE - content: [$sbeSourcePath], metadata: [$sbeMetadataPath], sbeVersion [$sbeVersion]"

                        # run from the installed CSV dir as it is already properly organzied (with split content and metadata)

                        $runFrom = "CSV"

                    }

                    else

                    {

                        # Early exit, this is a Solution update w/o an SBE and there is no SBE installed

                        Trace-Execution "Skipping tests as no SBE is installed and there is no SBE from this Solution Update"

                        $exitEarly = $true

                    }

                }

                elseif ($updateVersion -match '\d\.\d\.\d{4}\..*')

                {

                    $sbeSourcePath = $updatePackageBaseDir

                    $sbeMetadataPath = $updatePackageBaseDir

                    $sbeVersion = $updateVersion

                    $updateEnvVarsForSBE = $true

                    Trace-Execution "Using SBE from SBE-only Update - content: [$sbeSourcePath], metadata: [$sbeMetadataPath], sbeVersion [$sbeVersion]"

                }

            }

            $sbeVersionFormatted = "1.0"

            if ([System.Version]::TryParse($sbeVersion,[ref]$sbeVersionFormatted))

            {

                if($sbeVersionFormatted -lt [System.Version]"4.1")

                {

                    $versionResult = New-SBEHealthResultObject -TestName 'Test-Version-Supports-$OperationType-Tests' -TargetName $env:ComputerName -Status 'SUCCESS' -Description "Validate SBE Version supports $OperationType type tests."

                    $detailedMessage = "Skipping tests. SBE '$OperationType' type Health Checks are only supported with version 4.1.x.x or later (SBE version was $sbeVersion)."

                    Trace-Execution $detailedMessage

                    $versionResult.AdditionalData.Detail = $detailedMessage

                    $allResult += $versionResult

                    $exitEarly = $true

                }

            }

        }

        elseif ($OperationType -eq 'PreAddNode')

        {

            # TODO : Future placeholder for when AddNode tests are implemented

            Trace-Execution "SBE Health validation for $OperationType has not been implemented yet"

            $allResult += (New-Object -TypeName PsObject -Property @{Result = 'INFORMATIONAL'; FailedResult = $null; ExecutionDetail = 'SBE Health validation has been skipped as this OperationType is not yet supported.'})

            $exitEarly = $true

        }

        else

        {

            Trace-Execution "OperationType $OperationType is not implemented"

            $allResult += (New-Object -TypeName PsObject -Property @{Result = 'INFORMATIONAL'; FailedResult = $null; ExecutionDetail = 'SBE Health validation has been skipped as this OperationType is not yet supported.'})

            $exitEarly = $true

        }

        # Done with built-in checks - send result to telemetry channel

        foreach ($res in $allResult)

        {

            Write-ETWResult -Result $res

        }

        if ($exitEarly)

        {

            Trace-Execution "SBE Health built-in tests failed. Exit early before partner tests."

            return [EnvironmentValidator]::ParseResult($allResult, 'SBEHealth', $FailFast)

        }

        $priorStageVersion = $null

        $priorStageRootPath = $null

        $priorSBEMeatadataPath = $null

        if ($true -eq $updateEnvVarsForSBE)

        {

            # While we haven't technically staged the SBE yet, set the env vars so some of the helper functions know where to find the metadata files or SBE content

            # IMPORTANT: We MUST put these values back to their prior values when we are done (success or fail).  If we don't we will get new + old mismatches:

            #  - scenario 1: system checks will fail (old install dir + new metadata path)

            #  - scenario 2: after scenario 1 fails we have pre-update checks will fail due to both new and old files being at the cache path (since we do pssession copy-item copy first instead of a robocopy /MIR type copy)

            $priorStageVersion = [System.Environment]::GetEnvironmentVariable("SBEStageVersion", "Machine")

            Trace-Execution "Temporarily changing SBEStageVersion from '$priorStageVersion' to '$sbeVersion'"

            [System.Environment]::SetEnvironmentVariable("SBEStageVersion", $sbeVersion, "Machine")

            $priorStageRootPath = [System.Environment]::GetEnvironmentVariable("SBEStageRootPath", "Machine")

            Trace-Execution "Temporarily changing SBEStageRootPath from '$priorStageRootPath' to '$sbeSourcePath'"

            [System.Environment]::SetEnvironmentVariable("SBEStageRootPath", $sbeSourcePath, "Machine")

            $priorSBEMeatadataPath = [System.Environment]::GetEnvironmentVariable("SBEStagedMetadata", "Machine")

            Trace-Execution "Temporarily changing SBEStagedMetadata from '$priorSBEMeatadataPath' to '$sbeMetadataPath'"

            [System.Environment]::SetEnvironmentVariable("SBEStagedMetadata", $sbeMetadataPath, "Machine")

        }

        Trace-Execution "Getting PSSessions for all hosts"

        # No prep for the partner validators

        $psSession = [EnvironmentValidator]::NewPsSessionAllHosts($Parameters)

        # Update mapping as needed each time envChecker adds a new OperationType that we want to translate to an SBE healthCheck "tag"

        $envCheckerToSBEPrecheckTagMap = @{

            PreUpdate = "Update"

            PostUpdate = "Update"

            PreAddNode = "AddNode"

        }

        $tag = $OperationType

        if ($null -ne $envCheckerToSBEPrecheckTagMap.$OperationType)

        {

            # EnvChecker has invented some new test types that SBE doesn't support - use mapping table to translate to SBE equivalent

            $tag = $envCheckerToSBEPrecheckTagMap.$OperationType

        }

        $params = @{

            PsSession = $psSession

            PassThru = $true

            OutputPath = "$($env:LocalRootFolderPath)\MASLogs\"

            HardwareClass = $HardwareClass

            ClusterPattern = $ClusterPattern

            Tag = $tag

            SBESourcePath = $sbeSourcePath

            SBEMetadataPath = $sbeMetadataPath

            SBEVersion = $sbeVersion

            ECEParameters = $Parameters

            RunFrom = $runFrom

        }

        # Run Partner SBE Health Checks

        [array]$partnerResults = AzStackHci.EnvironmentChecker\Invoke-AzStackHciSBEHealthValidation @params

        if ($null -ne $partnerResults -and $partnerResults.Count -gt 0)

        {

            $allResult += $partnerResults

        }

        return [EnvironmentValidator]::ParseResult($allResult, 'SBEHealth', $FailFast)

    }

    catch

    {

        Trace-Execution "Validator failed. $PSItem"

        Trace-Execution "$($PSItem.ScriptStackTrace)"

        throw $PSItem

    }

    finally

    {

        #return the EnvVars to default values

        if ($OperationType -eq 'PreUpdate')

        {

            try {

                Trace-Execution "Reverting SBE env vars to default values"

                $templatedSBEPath = $Parameters.Roles["SBE"].PublicConfiguration.PublicInfo.SBEContentPaths.SBESharePath

                $sbeCSVDir = $templatedSBEPath.Replace('{DefaultClusterShare}', $env:InfraCSVRootFolderPath)

                if ($false -eq (Test-Path -Path $sbeCSVDir))

                {

                    Trace-Execution "Unable to locate SBE CSV path at $sbeCSVDir"

                }

                else

                {

                    Trace-Execution "Resolved SBE CSV path to '$sbeCSVDir'"

                    $defaultStagedMetadata  = Join-Path -Path $sbeCSVDir -ChildPath $Parameters.Roles["SBE"].PublicConfiguration.PublicInfo.SBEContentPaths.RelativePaths.CSVStagedMetadataPath

                    $defaultStagedRoot = Join-Path -Path $sbeCSVDir -ChildPath $Parameters.Roles["SBE"].PublicConfiguration.PublicInfo.SBEContentPaths.RelativePaths.CSVStagedContentPath

                    if ($false -eq [System.String]::IsNullOrWhiteSpace($defaultStagedMetadata) -and (Test-Path -Path $defaultStagedMetadata))

                    {

                        $newSBEMeatadataPath = [System.Environment]::GetEnvironmentVariable("SBEStagedMetadata", "Machine")

                        Trace-Execution "Reverting changing SBEStagedMetadata from '$newSBEMeatadataPath' to default '$defaultStagedMetadata'"

                        [System.Environment]::SetEnvironmentVariable("SBEStagedMetadata", $defaultStagedMetadata, "Machine")

                    }

                    if ($false -eq [System.String]::IsNullOrWhiteSpace($defaultStagedRoot) -and (Test-Path -Path $defaultStagedRoot))

                    {

                        $newStageRootPath = [System.Environment]::GetEnvironmentVariable("SBEStageRootPath", "Machine")

                        Trace-Execution "Reverting changing SBEStageRootPath from '$newStageRootPath' to default '$defaultStagedRoot'"

                        [System.Environment]::SetEnvironmentVariable("SBEStageRootPath", $defaultStagedRoot, "Machine")

                    }

                    $installedSBEVersion = [System.Environment]::GetEnvironmentVariable("SBEInstallVersion", "Machine")

                    if ([System.String]::IsNullOrWhiteSpace($installedSBEVersion) -or $false -eq $installedSBEVersion.StartsWith("4"))

                    {

                        $installedSBEVersion = "2.1.0.0"

                        Trace-Execution "No SBEis installed, will revert staged SBE back to '$installedSBEVersion'"

                    }

                    $sbeVersion = [System.Environment]::GetEnvironmentVariable("SBEStageVersion", "Machine")

                    Trace-Execution "Reverting changing SBEStageVersion from '$sbeVersion' to the actual installed value '$installedSBEVersion'"

                    [System.Environment]::SetEnvironmentVariable("SBEStageVersion", $installedSBEVersion, "Machine")

                }

            }

            catch

            {

                Trace-Execution "Failed to revert SBE env vars. $($PSItem.Exception.Message)"

                Trace-Execution "$($PSItem.ScriptStackTrace)"

            }

        }

        if ($psSession)

        {

            if ($backupPSModuleAutoLoadingPreference)

            {

                $PSModuleAutoLoadingPreference = $backupPSModuleAutoLoadingPreference

            }

            $psSession | Microsoft.PowerShell.Core\Remove-PSSession

        }

    }

}

Export-ModuleMember -Function Test-AzStackHciSBEHealth -Variable MetaData

# SIG # Begin signature block

# MIIoRgYJKoZIhvcNAQcCoIIoNzCCKDMCAQExDzANBglghkgBZQMEAgEFADB5Bgor

# BgEEAYI3AgEEoGswaTA0BgorBgEEAYI3AgEeMCYCAwEAAAQQH8w7YFlLCE63JNLG

# KX7zUQIBAAIBAAIBAAIBAAIBADAxMA0GCWCGSAFlAwQCAQUABCCUd3v627VWopCY

# M2uzAQjmGXQJpadPtRz7/A+tgC5/NKCCDXYwggX0MIID3KADAgECAhMzAAAEhV6Z

# 7A5ZL83XAAAAAASFMA0GCSqGSIb3DQEBCwUAMH4xCzAJBgNVBAYTAlVTMRMwEQYD

# VQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNy

# b3NvZnQgQ29ycG9yYXRpb24xKDAmBgNVBAMTH01pY3Jvc29mdCBDb2RlIFNpZ25p

# bmcgUENBIDIwMTEwHhcNMjUwNjE5MTgyMTM3WhcNMjYwNjE3MTgyMTM3WjB0MQsw

# CQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9u

# ZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMR4wHAYDVQQDExVNaWNy

# b3NvZnQgQ29ycG9yYXRpb24wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB

# AQDASkh1cpvuUqfbqxele7LCSHEamVNBfFE4uY1FkGsAdUF/vnjpE1dnAD9vMOqy

# 5ZO49ILhP4jiP/P2Pn9ao+5TDtKmcQ+pZdzbG7t43yRXJC3nXvTGQroodPi9USQi

# 9rI+0gwuXRKBII7L+k3kMkKLmFrsWUjzgXVCLYa6ZH7BCALAcJWZTwWPoiT4HpqQ

# hJcYLB7pfetAVCeBEVZD8itKQ6QA5/LQR+9X6dlSj4Vxta4JnpxvgSrkjXCz+tlJ

# 67ABZ551lw23RWU1uyfgCfEFhBfiyPR2WSjskPl9ap6qrf8fNQ1sGYun2p4JdXxe

# UAKf1hVa/3TQXjvPTiRXCnJPAgMBAAGjggFzMIIBbzAfBgNVHSUEGDAWBgorBgEE

# AYI3TAgBBggrBgEFBQcDAzAdBgNVHQ4EFgQUuCZyGiCuLYE0aU7j5TFqY05kko0w

# RQYDVR0RBD4wPKQ6MDgxHjAcBgNVBAsTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEW

# MBQGA1UEBRMNMjMwMDEyKzUwNTM1OTAfBgNVHSMEGDAWgBRIbmTlUAXTgqoXNzci

# tW2oynUClTBUBgNVHR8ETTBLMEmgR6BFhkNodHRwOi8vd3d3Lm1pY3Jvc29mdC5j

# b20vcGtpb3BzL2NybC9NaWNDb2RTaWdQQ0EyMDExXzIwMTEtMDctMDguY3JsMGEG

# CCsGAQUFBwEBBFUwUzBRBggrBgEFBQcwAoZFaHR0cDovL3d3dy5taWNyb3NvZnQu

# Y29tL3BraW9wcy9jZXJ0cy9NaWNDb2RTaWdQQ0EyMDExXzIwMTEtMDctMDguY3J0

# MAwGA1UdEwEB/wQCMAAwDQYJKoZIhvcNAQELBQADggIBACjmqAp2Ci4sTHZci+qk

# tEAKsFk5HNVGKyWR2rFGXsd7cggZ04H5U4SV0fAL6fOE9dLvt4I7HBHLhpGdE5Uj

# Ly4NxLTG2bDAkeAVmxmd2uKWVGKym1aarDxXfv3GCN4mRX+Pn4c+py3S/6Kkt5eS

# DAIIsrzKw3Kh2SW1hCwXX/k1v4b+NH1Fjl+i/xPJspXCFuZB4aC5FLT5fgbRKqns

# WeAdn8DsrYQhT3QXLt6Nv3/dMzv7G/Cdpbdcoul8FYl+t3dmXM+SIClC3l2ae0wO

# lNrQ42yQEycuPU5OoqLT85jsZ7+4CaScfFINlO7l7Y7r/xauqHbSPQ1r3oIC+e71

# 5s2G3ClZa3y99aYx2lnXYe1srcrIx8NAXTViiypXVn9ZGmEkfNcfDiqGQwkml5z9

# nm3pWiBZ69adaBBbAFEjyJG4y0a76bel/4sDCVvaZzLM3TFbxVO9BQrjZRtbJZbk

# C3XArpLqZSfx53SuYdddxPX8pvcqFuEu8wcUeD05t9xNbJ4TtdAECJlEi0vvBxlm

# M5tzFXy2qZeqPMXHSQYqPgZ9jvScZ6NwznFD0+33kbzyhOSz/WuGbAu4cHZG8gKn

# lQVT4uA2Diex9DMs2WHiokNknYlLoUeWXW1QrJLpqO82TLyKTbBM/oZHAdIc0kzo

# STro9b3+vjn2809D0+SOOCVZMIIHejCCBWKgAwIBAgIKYQ6Q0gAAAAAAAzANBgkq

# hkiG9w0BAQsFADCBiDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24x

# EDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlv

# bjEyMDAGA1UEAxMpTWljcm9zb2Z0IFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5

# IDIwMTEwHhcNMTEwNzA4MjA1OTA5WhcNMjYwNzA4MjEwOTA5WjB+MQswCQYDVQQG

# EwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwG

# A1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMSgwJgYDVQQDEx9NaWNyb3NvZnQg

# Q29kZSBTaWduaW5nIFBDQSAyMDExMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIIC

# CgKCAgEAq/D6chAcLq3YbqqCEE00uvK2WCGfQhsqa+laUKq4BjgaBEm6f8MMHt03

# a8YS2AvwOMKZBrDIOdUBFDFC04kNeWSHfpRgJGyvnkmc6Whe0t+bU7IKLMOv2akr

# rnoJr9eWWcpgGgXpZnboMlImEi/nqwhQz7NEt13YxC4Ddato88tt8zpcoRb0Rrrg

# OGSsbmQ1eKagYw8t00CT+OPeBw3VXHmlSSnnDb6gE3e+lD3v++MrWhAfTVYoonpy

# 4BI6t0le2O3tQ5GD2Xuye4Yb2T6xjF3oiU+EGvKhL1nkkDstrjNYxbc+/jLTswM9

# sbKvkjh+0p2ALPVOVpEhNSXDOW5kf1O6nA+tGSOEy/S6A4aN91/w0FK/jJSHvMAh

# dCVfGCi2zCcoOCWYOUo2z3yxkq4cI6epZuxhH2rhKEmdX4jiJV3TIUs+UsS1Vz8k

# A/DRelsv1SPjcF0PUUZ3s/gA4bysAoJf28AVs70b1FVL5zmhD+kjSbwYuER8ReTB

# w3J64HLnJN+/RpnF78IcV9uDjexNSTCnq47f7Fufr/zdsGbiwZeBe+3W7UvnSSmn

# Eyimp31ngOaKYnhfsi+E11ecXL93KCjx7W3DKI8sj0A3T8HhhUSJxAlMxdSlQy90

# lfdu+HggWCwTXWCVmj5PM4TasIgX3p5O9JawvEagbJjS4NaIjAsCAwEAAaOCAe0w

# ggHpMBAGCSsGAQQBgjcVAQQDAgEAMB0GA1UdDgQWBBRIbmTlUAXTgqoXNzcitW2o

# ynUClTAZBgkrBgEEAYI3FAIEDB4KAFMAdQBiAEMAQTALBgNVHQ8EBAMCAYYwDwYD

# VR0TAQH/BAUwAwEB/zAfBgNVHSMEGDAWgBRyLToCMZBDuRQFTuHqp8cx0SOJNDBa

# BgNVHR8EUzBRME+gTaBLhklodHRwOi8vY3JsLm1pY3Jvc29mdC5jb20vcGtpL2Ny

# bC9wcm9kdWN0cy9NaWNSb29DZXJBdXQyMDExXzIwMTFfMDNfMjIuY3JsMF4GCCsG

# AQUFBwEBBFIwUDBOBggrBgEFBQcwAoZCaHR0cDovL3d3dy5taWNyb3NvZnQuY29t

# L3BraS9jZXJ0cy9NaWNSb29DZXJBdXQyMDExXzIwMTFfMDNfMjIuY3J0MIGfBgNV

# HSAEgZcwgZQwgZEGCSsGAQQBgjcuAzCBgzA/BggrBgEFBQcCARYzaHR0cDovL3d3

# dy5taWNyb3NvZnQuY29tL3BraW9wcy9kb2NzL3ByaW1hcnljcHMuaHRtMEAGCCsG

# AQUFBwICMDQeMiAdAEwAZQBnAGEAbABfAHAAbwBsAGkAYwB5AF8AcwB0AGEAdABl

# AG0AZQBuAHQALiAdMA0GCSqGSIb3DQEBCwUAA4ICAQBn8oalmOBUeRou09h0ZyKb

# C5YR4WOSmUKWfdJ5DJDBZV8uLD74w3LRbYP+vj/oCso7v0epo/Np22O/IjWll11l

# hJB9i0ZQVdgMknzSGksc8zxCi1LQsP1r4z4HLimb5j0bpdS1HXeUOeLpZMlEPXh6

# I/MTfaaQdION9MsmAkYqwooQu6SpBQyb7Wj6aC6VoCo/KmtYSWMfCWluWpiW5IP0

# wI/zRive/DvQvTXvbiWu5a8n7dDd8w6vmSiXmE0OPQvyCInWH8MyGOLwxS3OW560

# STkKxgrCxq2u5bLZ2xWIUUVYODJxJxp/sfQn+N4sOiBpmLJZiWhub6e3dMNABQam

# ASooPoI/E01mC8CzTfXhj38cbxV9Rad25UAqZaPDXVJihsMdYzaXht/a8/jyFqGa

# J+HNpZfQ7l1jQeNbB5yHPgZ3BtEGsXUfFL5hYbXw3MYbBL7fQccOKO7eZS/sl/ah

# XJbYANahRr1Z85elCUtIEJmAH9AAKcWxm6U/RXceNcbSoqKfenoi+kiVH6v7RyOA

# 9Z74v2u3S5fi63V4GuzqN5l5GEv/1rMjaHXmr/r8i+sLgOppO6/8MO0ETI7f33Vt

# Y5E90Z1WTk+/gFcioXgRMiF670EKsT/7qMykXcGhiJtXcVZOSEXAQsmbdlsKgEhr

# /Xmfwb1tbWrJUnMTDXpQzTGCGiYwghoiAgEBMIGVMH4xCzAJBgNVBAYTAlVTMRMw

# EQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVN

# aWNyb3NvZnQgQ29ycG9yYXRpb24xKDAmBgNVBAMTH01pY3Jvc29mdCBDb2RlIFNp

# Z25pbmcgUENBIDIwMTECEzMAAASFXpnsDlkvzdcAAAAABIUwDQYJYIZIAWUDBAIB

# BQCgga4wGQYJKoZIhvcNAQkDMQwGCisGAQQBgjcCAQQwHAYKKwYBBAGCNwIBCzEO

# MAwGCisGAQQBgjcCARUwLwYJKoZIhvcNAQkEMSIEICJnVhUpwRc5Mq2u0HkGWVnR

# toNu4A5XZ4TzEXiypntoMEIGCisGAQQBgjcCAQwxNDAyoBSAEgBNAGkAYwByAG8A

# cwBvAGYAdKEagBhodHRwOi8vd3d3Lm1pY3Jvc29mdC5jb20wDQYJKoZIhvcNAQEB

# BQAEggEAKI4NOKxHlHY3X4IlMVtuYb3Y5M5oA7AL3Df1v8pRfgDqpunvcN9MIJdG

# j6tzMqGHprWli1UTzw3ShJhK/ZbyxhaJUHYbZ5puuDwQy93/IFSHzgm9sOfpoSzS

# gPexBSynZ85n6x7weplVzmupDTnEFXYGk6IJcXHpXzk9psn/gd/q6NuW8bJiJfN7

# iNy0NIbHr4zakhFeF4QvZ8ZmzDVRhxNQlftUE4SHVNkth+88CTlJDyIved0YUh1W

# 5Q0/MNAhsliwLzc3h1us6TTgnQKa1wpofAGwm0Mnbk53LRo6Rnng/y7nksn36A4K

# 7XRoY0s6APIelgVMdWaUdI8txHUjV6GCF7AwghesBgorBgEEAYI3AwMBMYIXnDCC

# F5gGCSqGSIb3DQEHAqCCF4kwgheFAgEDMQ8wDQYJYIZIAWUDBAIBBQAwggFaBgsq

# hkiG9w0BCRABBKCCAUkEggFFMIIBQQIBAQYKKwYBBAGEWQoDATAxMA0GCWCGSAFl

# AwQCAQUABCD67hfTHHzLlIajOjy2XHWsJPiffEN6jbHHIZ9s/AbhSQIGaK4AZHhD

# GBMyMDI1MDkwOTE5MjIwNC4xODhaMASAAgH0oIHZpIHWMIHTMQswCQYDVQQGEwJV

# UzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UE

# ChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMS0wKwYDVQQLEyRNaWNyb3NvZnQgSXJl

# bGFuZCBPcGVyYXRpb25zIExpbWl0ZWQxJzAlBgNVBAsTHm5TaGllbGQgVFNTIEVT

# TjozNjA1LTA1RTAtRDk0NzElMCMGA1UEAxMcTWljcm9zb2Z0IFRpbWUtU3RhbXAg

# U2VydmljZaCCEf4wggcoMIIFEKADAgECAhMzAAAB91ggdQTK+8L0AAEAAAH3MA0G

# CSqGSIb3DQEBCwUAMHwxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9u

# MRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNyb3NvZnQgQ29ycG9yYXRp

# b24xJjAkBgNVBAMTHU1pY3Jvc29mdCBUaW1lLVN0YW1wIFBDQSAyMDEwMB4XDTI0

# MDcyNTE4MzEwNloXDTI1MTAyMjE4MzEwNlowgdMxCzAJBgNVBAYTAlVTMRMwEQYD

# VQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNy

# b3NvZnQgQ29ycG9yYXRpb24xLTArBgNVBAsTJE1pY3Jvc29mdCBJcmVsYW5kIE9w

# ZXJhdGlvbnMgTGltaXRlZDEnMCUGA1UECxMeblNoaWVsZCBUU1MgRVNOOjM2MDUt

# MDVFMC1EOTQ3MSUwIwYDVQQDExxNaWNyb3NvZnQgVGltZS1TdGFtcCBTZXJ2aWNl

# MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA0OdHTBNom6/uXKaEKP9r

# PITkT6QxF11tjzB0Nk1byDpPrFTHha3hxwSdTcr8Y0a3k6EQlwqy6ROz42e0R5eD

# W+dCoQapipDIFUOYp3oNuqwX/xepATEkY17MyXFx6rQW2NcWUJW3Qo2AuJ0HOtbl

# SpItQZPGmHnGqkt/DB45Fwxk6VoSvxNcQKhKETkuzrt8U6DRccQm1FdhmPKgDzgc

# fDPM5o+GnzbiMu6y069A4EHmLMmkecSkVvBmcZ8VnzFHTDkGLdpnDV5FXjVObAgb

# SM0cnqYSGfRp7VGHBRqyoscvR4bcQ+CV9pDjbJ6S5rZn1uA8hRhj09Hs33HRevt4

# oWAVYGItgEsG+BrCYbpgWMDEIVnAgPZEiPAaI8wBGemE4feEkuz7TAwgkRBcUzLg

# Q4uvPqRD1A+Jkt26+pDqWYSn0MA8j0zacQk9q/AvciPXD9It2ez+mqEzgFRRsJGL

# tcf9HksvK8Jsd6I5zFShlqi5bpzf1Y4NOiNOh5QwW1pIvA5irlal7qFhkAeeeZqm

# op8+uNxZXxFCQG3R3s5pXW89FiCh9rmXrVqOCwgcXFIJQAQkllKsI+UJqGq9rmRA

# BJz5lHKTFYmFwcM52KWWjNx3z6odwz2h+sxaxewToe9GqtDx3/aU+yqNRcB8w0tS

# XUf+ylN4uk5xHEpLpx+ZNNsCAwEAAaOCAUkwggFFMB0GA1UdDgQWBBTfRqQzP3m9

# PZWuLf1p8/meFfkmmDAfBgNVHSMEGDAWgBSfpxVdAF5iXYP05dJlpxtTNRnpcjBf

# BgNVHR8EWDBWMFSgUqBQhk5odHRwOi8vd3d3Lm1pY3Jvc29mdC5jb20vcGtpb3Bz

# L2NybC9NaWNyb3NvZnQlMjBUaW1lLVN0YW1wJTIwUENBJTIwMjAxMCgxKS5jcmww

# bAYIKwYBBQUHAQEEYDBeMFwGCCsGAQUFBzAChlBodHRwOi8vd3d3Lm1pY3Jvc29m

# dC5jb20vcGtpb3BzL2NlcnRzL01pY3Jvc29mdCUyMFRpbWUtU3RhbXAlMjBQQ0El

# MjAyMDEwKDEpLmNydDAMBgNVHRMBAf8EAjAAMBYGA1UdJQEB/wQMMAoGCCsGAQUF

# BwMIMA4GA1UdDwEB/wQEAwIHgDANBgkqhkiG9w0BAQsFAAOCAgEAN0ajafILeL6S

# QIMIMAXM1Qd6xaoci2mOrpR8vKWyyTsL3b83A7XGLiAbQxTrqnXvVWWeNst5YQD8

# saO+UTgOLJdTdfUADhLXoK+RlwjfndimIJT9MH9tUYXLzJXKhZM09ouPwNsrn8YO

# LIpdAi5TPyN8Cl11OGZSlP9r8JnvomW00AoJ4Pl9rlg0G5lcQknAXqHa9nQdWp1Z

# xXqNd+0JsKmlR8tcANX33ClM9NnaClJExLQHiKeHUUWtqyLMl65TW6wRM7XlF7Y+

# PTnC8duNWn4uLng+ON/Z39GO6qBj7IEZxoq4o3avEh9ba43UU6TgzVZaBm8VaA0w

# SwUe/pqpTOYFWN62XL3gl/JC2pzfIPxP66XfRLIxafjBVXm8KVDn2cML9IvRK02s

# 941Y5+RR4gSAOhLiQQ6A03VNRup+spMa0k+XTPAi+2aMH5xa1Zjb/K8u9f9M05U0

# /bUMJXJDP++ysWpJbVRDiHG7szaca+r3HiUPjQJyQl2NiOcYTGV/DcLrLCBK2zG5

# 03FGb04N5Kf10XgAwFaXlod5B9eKh95PnXKx2LNBgLwG85anlhhGxxBQ5mFsJGkB

# n0PZPtAzZyfr96qxzpp2pH9DJJcjKCDrMmZziXazpa5VVN36CO1kDU4ABkSYTXOM

# 8RmJXuQm7mUF3bWmj+hjAJb4pz6hT5UwggdxMIIFWaADAgECAhMzAAAAFcXna54C

# m0mZAAAAAAAVMA0GCSqGSIb3DQEBCwUAMIGIMQswCQYDVQQGEwJVUzETMBEGA1UE

# CBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9z

# b2Z0IENvcnBvcmF0aW9uMTIwMAYDVQQDEylNaWNyb3NvZnQgUm9vdCBDZXJ0aWZp

# Y2F0ZSBBdXRob3JpdHkgMjAxMDAeFw0yMTA5MzAxODIyMjVaFw0zMDA5MzAxODMy

# MjVaMHwxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQH

# EwdSZWRtb25kMR4wHAYDVQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xJjAkBgNV

# BAMTHU1pY3Jvc29mdCBUaW1lLVN0YW1wIFBDQSAyMDEwMIICIjANBgkqhkiG9w0B

# AQEFAAOCAg8AMIICCgKCAgEA5OGmTOe0ciELeaLL1yR5vQ7VgtP97pwHB9KpbE51

# yMo1V/YBf2xK4OK9uT4XYDP/XE/HZveVU3Fa4n5KWv64NmeFRiMMtY0Tz3cywBAY

# 6GB9alKDRLemjkZrBxTzxXb1hlDcwUTIcVxRMTegCjhuje3XD9gmU3w5YQJ6xKr9

# cmmvHaus9ja+NSZk2pg7uhp7M62AW36MEBydUv626GIl3GoPz130/o5Tz9bshVZN

# 7928jaTjkY+yOSxRnOlwaQ3KNi1wjjHINSi947SHJMPgyY9+tVSP3PoFVZhtaDua

# Rr3tpK56KTesy+uDRedGbsoy1cCGMFxPLOJiss254o2I5JasAUq7vnGpF1tnYN74

# kpEeHT39IM9zfUGaRnXNxF803RKJ1v2lIH1+/NmeRd+2ci/bfV+AutuqfjbsNkz2

# K26oElHovwUDo9Fzpk03dJQcNIIP8BDyt0cY7afomXw/TNuvXsLz1dhzPUNOwTM5

# TI4CvEJoLhDqhFFG4tG9ahhaYQFzymeiXtcodgLiMxhy16cg8ML6EgrXY28MyTZk

# i1ugpoMhXV8wdJGUlNi5UPkLiWHzNgY1GIRH29wb0f2y1BzFa/ZcUlFdEtsluq9Q

# BXpsxREdcu+N+VLEhReTwDwV2xo3xwgVGD94q0W29R6HXtqPnhZyacaue7e3Pmri

# Lq0CAwEAAaOCAd0wggHZMBIGCSsGAQQBgjcVAQQFAgMBAAEwIwYJKwYBBAGCNxUC

# BBYEFCqnUv5kxJq+gpE8RjUpzxD/LwTuMB0GA1UdDgQWBBSfpxVdAF5iXYP05dJl

# pxtTNRnpcjBcBgNVHSAEVTBTMFEGDCsGAQQBgjdMg30BATBBMD8GCCsGAQUFBwIB

# FjNodHRwOi8vd3d3Lm1pY3Jvc29mdC5jb20vcGtpb3BzL0RvY3MvUmVwb3NpdG9y

# eS5odG0wEwYDVR0lBAwwCgYIKwYBBQUHAwgwGQYJKwYBBAGCNxQCBAweCgBTAHUA

# YgBDAEEwCwYDVR0PBAQDAgGGMA8GA1UdEwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAU

# 1fZWy4/oolxiaNE9lJBb186aGMQwVgYDVR0fBE8wTTBLoEmgR4ZFaHR0cDovL2Ny

# bC5taWNyb3NvZnQuY29tL3BraS9jcmwvcHJvZHVjdHMvTWljUm9vQ2VyQXV0XzIw

# MTAtMDYtMjMuY3JsMFoGCCsGAQUFBwEBBE4wTDBKBggrBgEFBQcwAoY+aHR0cDov

# L3d3dy5taWNyb3NvZnQuY29tL3BraS9jZXJ0cy9NaWNSb29DZXJBdXRfMjAxMC0w

# Ni0yMy5jcnQwDQYJKoZIhvcNAQELBQADggIBAJ1VffwqreEsH2cBMSRb4Z5yS/yp

# b+pcFLY+TkdkeLEGk5c9MTO1OdfCcTY/2mRsfNB1OW27DzHkwo/7bNGhlBgi7ulm

# ZzpTTd2YurYeeNg2LpypglYAA7AFvonoaeC6Ce5732pvvinLbtg/SHUB2RjebYIM

# 9W0jVOR4U3UkV7ndn/OOPcbzaN9l9qRWqveVtihVJ9AkvUCgvxm2EhIRXT0n4ECW

# OKz3+SmJw7wXsFSFQrP8DJ6LGYnn8AtqgcKBGUIZUnWKNsIdw2FzLixre24/LAl4

# FOmRsqlb30mjdAy87JGA0j3mSj5mO0+7hvoyGtmW9I/2kQH2zsZ0/fZMcm8Qq3Uw

# xTSwethQ/gpY3UA8x1RtnWN0SCyxTkctwRQEcb9k+SS+c23Kjgm9swFXSVRk2XPX

# fx5bRAGOWhmRaw2fpCjcZxkoJLo4S5pu+yFUa2pFEUep8beuyOiJXk+d0tBMdrVX

# VAmxaQFEfnyhYWxz/gq77EFmPWn9y8FBSX5+k77L+DvktxW/tM4+pTFRhLy/AsGC

# onsXHRWJjXD+57XQKBqJC4822rpM+Zv/Cuk0+CQ1ZyvgDbjmjJnW4SLq8CdCPSWU

# 5nR0W2rRnj7tfqAxM328y+l7vzhwRNGQ8cirOoo6CGJ/2XBjU02N7oJtpQUQwXEG

# ahC0HVUzWLOhcGbyoYIDWTCCAkECAQEwggEBoYHZpIHWMIHTMQswCQYDVQQGEwJV

# UzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UE

# ChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMS0wKwYDVQQLEyRNaWNyb3NvZnQgSXJl

# bGFuZCBPcGVyYXRpb25zIExpbWl0ZWQxJzAlBgNVBAsTHm5TaGllbGQgVFNTIEVT

# TjozNjA1LTA1RTAtRDk0NzElMCMGA1UEAxMcTWljcm9zb2Z0IFRpbWUtU3RhbXAg

# U2VydmljZaIjCgEBMAcGBSsOAwIaAxUAb28KDG/xXbNBjmM7/nqw3bgrEOaggYMw

# gYCkfjB8MQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UE

# BxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMSYwJAYD

# VQQDEx1NaWNyb3NvZnQgVGltZS1TdGFtcCBQQ0EgMjAxMDANBgkqhkiG9w0BAQsF

# AAIFAOxq8pcwIhgPMjAyNTA5MDkxODM4MTVaGA8yMDI1MDkxMDE4MzgxNVowdzA9

# BgorBgEEAYRZCgQBMS8wLTAKAgUA7GrylwIBADAKAgEAAgINHwIB/zAHAgEAAgIS

# bTAKAgUA7GxEFwIBADA2BgorBgEEAYRZCgQCMSgwJjAMBgorBgEEAYRZCgMCoAow

# CAIBAAIDB6EgoQowCAIBAAIDAYagMA0GCSqGSIb3DQEBCwUAA4IBAQCci/U8+1q6

# fcU7WFBoNUIo+2hatCWHaQ4tU2U4J+IKP29VQcsCVisbBwEgK2iP8uo25iJcEmE2

# ZVesSvXILY1V1jl9aIF2NHeUrLCYVxKeZeJD2DSH2hGN8bAr8RhYYBtkBaJTXhg7

# c26HFOx/2hni7hW558CrWN0FLsiWwADg+vCETkazCOtr2qlYeviS1RzPk8GO8Azm

# 7pIHCNm+Ikw+R0cl35488IJ1z6tTTp3rB40hPzJpoHQwxHtMZwbDuuLEUqfDLyD9

# H0GoiN4JyxfGUFb8TwndHCT042+UMZ+moiKDlYsVlczZWQF+gUj5r1tZePB4iTqI

# +Qgrdmc7K0wrMYIEDTCCBAkCAQEwgZMwfDELMAkGA1UEBhMCVVMxEzARBgNVBAgT

# Cldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29m

# dCBDb3Jwb3JhdGlvbjEmMCQGA1UEAxMdTWljcm9zb2Z0IFRpbWUtU3RhbXAgUENB

# IDIwMTACEzMAAAH3WCB1BMr7wvQAAQAAAfcwDQYJYIZIAWUDBAIBBQCgggFKMBoG

# CSqGSIb3DQEJAzENBgsqhkiG9w0BCRABBDAvBgkqhkiG9w0BCQQxIgQguR5Z/Yeq

# 8sHehFUXI/UpM3q4BtF0Cx34U6ztINKbifEwgfoGCyqGSIb3DQEJEAIvMYHqMIHn

# MIHkMIG9BCAh2pjaa3ca0ecYuhu60uYHP/IKnPbedbVQJ5SoIH5Z4jCBmDCBgKR+

# MHwxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdS

# ZWRtb25kMR4wHAYDVQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xJjAkBgNVBAMT

# HU1pY3Jvc29mdCBUaW1lLVN0YW1wIFBDQSAyMDEwAhMzAAAB91ggdQTK+8L0AAEA

# AAH3MCIEIL+6hbbv23au5YgRuXSXMgngfLinSQ+d36lqwsYVtvLCMA0GCSqGSIb3

# DQEBCwUABIICABI9gtZdcvF+RbMjFI255io43UTPSw2QKKw7Zk8FLlBol/oXylq9

# GeyU/YhNYEAz/oixajmhPJfaM19z4nprOodWmVyib316kcS05YuuQ8h3YOCxbF6f

# YhVh9EFtlTXcLB8KqkYMPasDR2qLEcHwSEI5wTBVpmyD9jskKePtA8NePg36RNEj

# pFhWRRfk+1Hnq9vFkRseLpyUXBoDBa5up+N6Mg/mTKG4XpiLbuiVd8CA3JdVz8Qc

# nzSDOHcJqjTMDObDZ0e0eSzlY7GSk/RpxwV4X67eLSigodJVtX2jUSqT7e9ooL8o

# wpvKEaCEJNEnZQ19AF5vApexg1s1BBEtxVG3TKrkLKP/HfKN8mpVkqkOErfhWxjn

# //sTWrPhX8pktcY8NFuTIEC0/yVg7sSxE1t/UBktMXvcvSVjU66sWfAE8mOb9Jnw

# /WbP/FR6QXoB+r+n5qSPfOc8+jEuaDJgf47QwE8OmSSt5H7lIQeadHpBxpqXMQh9

# oQ3kdJoQfHOGHcKAXxe4u/V+wkBSpnohH0C6rW/AR2T7eLCwTzpcAgXgZbN95HCY

# ItuU7u6T/TnZ37ZW3f9wHWVjNKMITOKzYSVvxLqij93fh6jb1kL/jJgtiiQHtvxU

# ewT1i8H1eWu0eUuWP0aQ2aba7rTF2cohmozBV8TjLQvljaiOcOM7RInk

# SIG # End signature block