AzStackHci.EnvironmentChecker

10.2506.0.2017

AzStackHciSBEHealth/AzStackHciSBEHealth.psm1

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

 #                                                           #

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

 #                                                           #

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

 $MetaData = @{

    "OperationType" =  @("Deployment", "Update", "PreUpdate", "PostUpdate")

    "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

    {

        # 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)

        {

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

        }

    }

}

Export-ModuleMember -Function Test-AzStackHciSBEHealth -Variable MetaData

# SIG # Begin signature block

# MIIoUQYJKoZIhvcNAQcCoIIoQjCCKD4CAQExDzANBglghkgBZQMEAgEFADB5Bgor

# BgEEAYI3AgEEoGswaTA0BgorBgEEAYI3AgEeMCYCAwEAAAQQH8w7YFlLCE63JNLG

# KX7zUQIBAAIBAAIBAAIBAAIBADAxMA0GCWCGSAFlAwQCAQUABCBF73EDae78V4+d

# peZ7Mabfa/QEjPmrQ8AG3NIFaomc/aCCDYUwggYDMIID66ADAgECAhMzAAAEA73V

# lV0POxitAAAAAAQDMA0GCSqGSIb3DQEBCwUAMH4xCzAJBgNVBAYTAlVTMRMwEQYD

# VQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNy

# b3NvZnQgQ29ycG9yYXRpb24xKDAmBgNVBAMTH01pY3Jvc29mdCBDb2RlIFNpZ25p

# bmcgUENBIDIwMTEwHhcNMjQwOTEyMjAxMTEzWhcNMjUwOTExMjAxMTEzWjB0MQsw

# CQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9u

# ZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMR4wHAYDVQQDExVNaWNy

# b3NvZnQgQ29ycG9yYXRpb24wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB

# AQCfdGddwIOnbRYUyg03O3iz19XXZPmuhEmW/5uyEN+8mgxl+HJGeLGBR8YButGV

# LVK38RxcVcPYyFGQXcKcxgih4w4y4zJi3GvawLYHlsNExQwz+v0jgY/aejBS2EJY

# oUhLVE+UzRihV8ooxoftsmKLb2xb7BoFS6UAo3Zz4afnOdqI7FGoi7g4vx/0MIdi

# kwTn5N56TdIv3mwfkZCFmrsKpN0zR8HD8WYsvH3xKkG7u/xdqmhPPqMmnI2jOFw/

# /n2aL8W7i1Pasja8PnRXH/QaVH0M1nanL+LI9TsMb/enWfXOW65Gne5cqMN9Uofv

# ENtdwwEmJ3bZrcI9u4LZAkujAgMBAAGjggGCMIIBfjAfBgNVHSUEGDAWBgorBgEE

# AYI3TAgBBggrBgEFBQcDAzAdBgNVHQ4EFgQU6m4qAkpz4641iK2irF8eWsSBcBkw

# VAYDVR0RBE0wS6RJMEcxLTArBgNVBAsTJE1pY3Jvc29mdCBJcmVsYW5kIE9wZXJh

# dGlvbnMgTGltaXRlZDEWMBQGA1UEBRMNMjMwMDEyKzUwMjkyNjAfBgNVHSMEGDAW

# gBRIbmTlUAXTgqoXNzcitW2oynUClTBUBgNVHR8ETTBLMEmgR6BFhkNodHRwOi8v

# d3d3Lm1pY3Jvc29mdC5jb20vcGtpb3BzL2NybC9NaWNDb2RTaWdQQ0EyMDExXzIw

# MTEtMDctMDguY3JsMGEGCCsGAQUFBwEBBFUwUzBRBggrBgEFBQcwAoZFaHR0cDov

# L3d3dy5taWNyb3NvZnQuY29tL3BraW9wcy9jZXJ0cy9NaWNDb2RTaWdQQ0EyMDEx

# XzIwMTEtMDctMDguY3J0MAwGA1UdEwEB/wQCMAAwDQYJKoZIhvcNAQELBQADggIB

# AFFo/6E4LX51IqFuoKvUsi80QytGI5ASQ9zsPpBa0z78hutiJd6w154JkcIx/f7r

# EBK4NhD4DIFNfRiVdI7EacEs7OAS6QHF7Nt+eFRNOTtgHb9PExRy4EI/jnMwzQJV

# NokTxu2WgHr/fBsWs6G9AcIgvHjWNN3qRSrhsgEdqHc0bRDUf8UILAdEZOMBvKLC

# rmf+kJPEvPldgK7hFO/L9kmcVe67BnKejDKO73Sa56AJOhM7CkeATrJFxO9GLXos

# oKvrwBvynxAg18W+pagTAkJefzneuWSmniTurPCUE2JnvW7DalvONDOtG01sIVAB

# +ahO2wcUPa2Zm9AiDVBWTMz9XUoKMcvngi2oqbsDLhbK+pYrRUgRpNt0y1sxZsXO

# raGRF8lM2cWvtEkV5UL+TQM1ppv5unDHkW8JS+QnfPbB8dZVRyRmMQ4aY/tx5x5+

# sX6semJ//FbiclSMxSI+zINu1jYerdUwuCi+P6p7SmQmClhDM+6Q+btE2FtpsU0W

# +r6RdYFf/P+nK6j2otl9Nvr3tWLu+WXmz8MGM+18ynJ+lYbSmFWcAj7SYziAfT0s

# IwlQRFkyC71tsIZUhBHtxPliGUu362lIO0Lpe0DOrg8lspnEWOkHnCT5JEnWCbzu

# iVt8RX1IV07uIveNZuOBWLVCzWJjEGa+HhaEtavjy6i7MIIHejCCBWKgAwIBAgIK

# YQ6Q0gAAAAAAAzANBgkqhkiG9w0BAQsFADCBiDELMAkGA1UEBhMCVVMxEzARBgNV

# BAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jv

# c29mdCBDb3Jwb3JhdGlvbjEyMDAGA1UEAxMpTWljcm9zb2Z0IFJvb3QgQ2VydGlm

# aWNhdGUgQXV0aG9yaXR5IDIwMTEwHhcNMTEwNzA4MjA1OTA5WhcNMjYwNzA4MjEw

# OTA5WjB+MQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UE

# BxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMSgwJgYD

# VQQDEx9NaWNyb3NvZnQgQ29kZSBTaWduaW5nIFBDQSAyMDExMIICIjANBgkqhkiG

# 9w0BAQEFAAOCAg8AMIICCgKCAgEAq/D6chAcLq3YbqqCEE00uvK2WCGfQhsqa+la

# UKq4BjgaBEm6f8MMHt03a8YS2AvwOMKZBrDIOdUBFDFC04kNeWSHfpRgJGyvnkmc

# 6Whe0t+bU7IKLMOv2akrrnoJr9eWWcpgGgXpZnboMlImEi/nqwhQz7NEt13YxC4D

# dato88tt8zpcoRb0RrrgOGSsbmQ1eKagYw8t00CT+OPeBw3VXHmlSSnnDb6gE3e+

# lD3v++MrWhAfTVYoonpy4BI6t0le2O3tQ5GD2Xuye4Yb2T6xjF3oiU+EGvKhL1nk

# kDstrjNYxbc+/jLTswM9sbKvkjh+0p2ALPVOVpEhNSXDOW5kf1O6nA+tGSOEy/S6

# A4aN91/w0FK/jJSHvMAhdCVfGCi2zCcoOCWYOUo2z3yxkq4cI6epZuxhH2rhKEmd

# X4jiJV3TIUs+UsS1Vz8kA/DRelsv1SPjcF0PUUZ3s/gA4bysAoJf28AVs70b1FVL

# 5zmhD+kjSbwYuER8ReTBw3J64HLnJN+/RpnF78IcV9uDjexNSTCnq47f7Fufr/zd

# sGbiwZeBe+3W7UvnSSmnEyimp31ngOaKYnhfsi+E11ecXL93KCjx7W3DKI8sj0A3

# T8HhhUSJxAlMxdSlQy90lfdu+HggWCwTXWCVmj5PM4TasIgX3p5O9JawvEagbJjS

# 4NaIjAsCAwEAAaOCAe0wggHpMBAGCSsGAQQBgjcVAQQDAgEAMB0GA1UdDgQWBBRI

# bmTlUAXTgqoXNzcitW2oynUClTAZBgkrBgEEAYI3FAIEDB4KAFMAdQBiAEMAQTAL

# BgNVHQ8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAfBgNVHSMEGDAWgBRyLToCMZBD

# uRQFTuHqp8cx0SOJNDBaBgNVHR8EUzBRME+gTaBLhklodHRwOi8vY3JsLm1pY3Jv

# c29mdC5jb20vcGtpL2NybC9wcm9kdWN0cy9NaWNSb29DZXJBdXQyMDExXzIwMTFf

# MDNfMjIuY3JsMF4GCCsGAQUFBwEBBFIwUDBOBggrBgEFBQcwAoZCaHR0cDovL3d3

# dy5taWNyb3NvZnQuY29tL3BraS9jZXJ0cy9NaWNSb29DZXJBdXQyMDExXzIwMTFf

# MDNfMjIuY3J0MIGfBgNVHSAEgZcwgZQwgZEGCSsGAQQBgjcuAzCBgzA/BggrBgEF

# BQcCARYzaHR0cDovL3d3dy5taWNyb3NvZnQuY29tL3BraW9wcy9kb2NzL3ByaW1h

# cnljcHMuaHRtMEAGCCsGAQUFBwICMDQeMiAdAEwAZQBnAGEAbABfAHAAbwBsAGkA

# YwB5AF8AcwB0AGEAdABlAG0AZQBuAHQALiAdMA0GCSqGSIb3DQEBCwUAA4ICAQBn

# 8oalmOBUeRou09h0ZyKbC5YR4WOSmUKWfdJ5DJDBZV8uLD74w3LRbYP+vj/oCso7

# v0epo/Np22O/IjWll11lhJB9i0ZQVdgMknzSGksc8zxCi1LQsP1r4z4HLimb5j0b

# pdS1HXeUOeLpZMlEPXh6I/MTfaaQdION9MsmAkYqwooQu6SpBQyb7Wj6aC6VoCo/

# KmtYSWMfCWluWpiW5IP0wI/zRive/DvQvTXvbiWu5a8n7dDd8w6vmSiXmE0OPQvy

# CInWH8MyGOLwxS3OW560STkKxgrCxq2u5bLZ2xWIUUVYODJxJxp/sfQn+N4sOiBp

# mLJZiWhub6e3dMNABQamASooPoI/E01mC8CzTfXhj38cbxV9Rad25UAqZaPDXVJi

# hsMdYzaXht/a8/jyFqGaJ+HNpZfQ7l1jQeNbB5yHPgZ3BtEGsXUfFL5hYbXw3MYb

# BL7fQccOKO7eZS/sl/ahXJbYANahRr1Z85elCUtIEJmAH9AAKcWxm6U/RXceNcbS

# oqKfenoi+kiVH6v7RyOA9Z74v2u3S5fi63V4GuzqN5l5GEv/1rMjaHXmr/r8i+sL

# gOppO6/8MO0ETI7f33VtY5E90Z1WTk+/gFcioXgRMiF670EKsT/7qMykXcGhiJtX

# cVZOSEXAQsmbdlsKgEhr/Xmfwb1tbWrJUnMTDXpQzTGCGiIwghoeAgEBMIGVMH4x

# CzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRt

# b25kMR4wHAYDVQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xKDAmBgNVBAMTH01p

# Y3Jvc29mdCBDb2RlIFNpZ25pbmcgUENBIDIwMTECEzMAAAQDvdWVXQ87GK0AAAAA

# BAMwDQYJYIZIAWUDBAIBBQCgga4wGQYJKoZIhvcNAQkDMQwGCisGAQQBgjcCAQQw

# HAYKKwYBBAGCNwIBCzEOMAwGCisGAQQBgjcCARUwLwYJKoZIhvcNAQkEMSIEILor

# 2MTmh89twzmUmy8hhJDOgpXkX1vIqEbjpXIoBKeGMEIGCisGAQQBgjcCAQwxNDAy

# oBSAEgBNAGkAYwByAG8AcwBvAGYAdKEagBhodHRwOi8vd3d3Lm1pY3Jvc29mdC5j

# b20wDQYJKoZIhvcNAQEBBQAEggEAJ6wIMk8G9hpp6lupGhB2bzUbyG3mDNujvJ4N

# bp+u0+7WE69ZrjRIcFI5pgXNjk97lSM4BzOr4SZfzHSPmZNeQEm0SYf0ACIVIRIv

# TXoN0LN3oSnqfdV7NpMxnmdJI0YBMx2UJDmk+UM3yOVK/QeVzxWBTMyLZ3Pj8dZ8

# NIcWyS8+5oAjXphbm7PUlkQhj18ptWCsFQ9OISjO14NKkgP7v3h1DErkI6urumwp

# 469ZZCPhrjMej8mYRYCrRBhgIP5+NLJpXQ8gHNDS+GJlvOCWeZlFF6MXrCiGXvH1

# nIXCNzKMFWfmBKAdhLAtZ8LaH2vQxEcwleDoLO8QAMjktCDPlqGCF6wwgheoBgor

# BgEEAYI3AwMBMYIXmDCCF5QGCSqGSIb3DQEHAqCCF4UwgheBAgEDMQ8wDQYJYIZI

# AWUDBAIBBQAwggFZBgsqhkiG9w0BCRABBKCCAUgEggFEMIIBQAIBAQYKKwYBBAGE

# WQoDATAxMA0GCWCGSAFlAwQCAQUABCBYz3EpWPJB7A34XhRuzHYu8JwpqzlPFZAN

# MIPkcEndhwIGaC4KsIG6GBIyMDI1MDYxMDE1NDgzMS45OVowBIACAfSggdmkgdYw

# gdMxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdS

# ZWRtb25kMR4wHAYDVQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xLTArBgNVBAsT

# JE1pY3Jvc29mdCBJcmVsYW5kIE9wZXJhdGlvbnMgTGltaXRlZDEnMCUGA1UECxMe

# blNoaWVsZCBUU1MgRVNOOjRDMUEtMDVFMC1EOTQ3MSUwIwYDVQQDExxNaWNyb3Nv

# ZnQgVGltZS1TdGFtcCBTZXJ2aWNloIIR+zCCBygwggUQoAMCAQICEzMAAAH/Ejh8

# 98Fl1qEAAQAAAf8wDQYJKoZIhvcNAQELBQAwfDELMAkGA1UEBhMCVVMxEzARBgNV

# BAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jv

# c29mdCBDb3Jwb3JhdGlvbjEmMCQGA1UEAxMdTWljcm9zb2Z0IFRpbWUtU3RhbXAg

# UENBIDIwMTAwHhcNMjQwNzI1MTgzMTE5WhcNMjUxMDIyMTgzMTE5WjCB0zELMAkG

# A1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQx

# HjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEtMCsGA1UECxMkTWljcm9z

# b2Z0IElyZWxhbmQgT3BlcmF0aW9ucyBMaW1pdGVkMScwJQYDVQQLEx5uU2hpZWxk

# IFRTUyBFU046NEMxQS0wNUUwLUQ5NDcxJTAjBgNVBAMTHE1pY3Jvc29mdCBUaW1l

# LVN0YW1wIFNlcnZpY2UwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDJ

# 6JXSkHtuDz+pz+aSIN0lefMlY9iCT2ZMZ4jenNCmzKtElERZwpgd3/11v6DfPh1T

# hUKQBkReq+TE/lA1O0Ebkil7GmmHg+FuIkrC9f5RLgqRIWF/XB+UMBjW270JCqGH

# F8cVXu+G2aocsIKYPGFk+YIGH39d8UlAhTBVlHxG1SSDOY31uZaJiB9fRH5sMCed

# xR22nXGMaYKl0EzKCT8rSHdtRNTNAdviQ9/bKWQo+hYVifYY1iBbDw8YFQ7S9Mwq

# NgPqkt4E/SFkOHk/d/jGEYubrH3zG4hCn9EWfMFuC2HJJcaX41PVxkCobISFPsvR

# J1HupCW/mnAM16tsrdhIQMqTewOH1LrSEsk2o/vWIcqQbXvkcDKDrOYTmnd842v3

# 98gSk8CULxiKzFdoZfhGkMFhUqkaPQUJnCKyJmzGbRf3DplKTw45d/wnFNhYip9G

# 5bN1SKvRneOI461oOrtd3KkHiBmuGv3Qpw9MNHC/LrTOtBxr/UPUns9AkAk5tuJp

# uiLXa6xXxrG2VP90J48Lid1wVxqvW/5+cKWGz27cWfouQcNFl83OFeAsMTBvp0Dj

# Lezob6BDfmj3SPaLpqZprwmxX9wIX6INIbMDFljWxDWat0ybPF9bNc3qw8kzLj21

# 2xZMiBlZU5JL25QeFJiRuAzGct6Ipd4HkwH1Axw5JwIDAQABo4IBSTCCAUUwHQYD

# VR0OBBYEFMP6leT+tP93sT/RATuEfTDP7pRhMB8GA1UdIwQYMBaAFJ+nFV0AXmJd

# g/Tl0mWnG1M1GelyMF8GA1UdHwRYMFYwVKBSoFCGTmh0dHA6Ly93d3cubWljcm9z

# b2Z0LmNvbS9wa2lvcHMvY3JsL01pY3Jvc29mdCUyMFRpbWUtU3RhbXAlMjBQQ0El

# MjAyMDEwKDEpLmNybDBsBggrBgEFBQcBAQRgMF4wXAYIKwYBBQUHMAKGUGh0dHA6

# Ly93d3cubWljcm9zb2Z0LmNvbS9wa2lvcHMvY2VydHMvTWljcm9zb2Z0JTIwVGlt

# ZS1TdGFtcCUyMFBDQSUyMDIwMTAoMSkuY3J0MAwGA1UdEwEB/wQCMAAwFgYDVR0l

# AQH/BAwwCgYIKwYBBQUHAwgwDgYDVR0PAQH/BAQDAgeAMA0GCSqGSIb3DQEBCwUA

# A4ICAQA5I03kykuLK6ebzrp+tYiLSF1rMo0uBGndZk9+FiA8Lcr8M0zMuWJhBQCn

# pa2CiUitq2K9eM4bWUiNrIb2vp7DgfWfldl0N8nXYMuOilqnl7WJT9iTR660/J86

# J699uwjNOT8bnX66JQmTvvadXNq7qEjYobIYEk68BsBUVHSDymlnAuCFPjPeaQZm

# Or87hn89yZUa2MamzZMK0jitmM81bw7hz/holGZhD811b3UlGs5dGnJetMpQ97eQ

# 3w3nqOmX2Si0uF293z1Fs6wk1/ZfOpsBXteNXhxoKCUDZu3MPFzJ9/BeEu70cxTd

# 0thMAj3WBM1QXsED2rUS9KUIoqU3w3XRjiJTSfIiR+lHFjIBtHKrlA9g8kcYDRPL

# Q8PzdoK3v1FrQh0MgxK7BeWlSfIjLHCsPKWB84bLKxYHBD+Ozbj1upA5g92nI52B

# F7y1d0auAOgF65U4r5xEKVemKY1jCvrWhnb+Q8zNWvNFRgyQFd71ap1J7OHy3K26

# 6VhhxEr3mqKEXSKtCzr9Y5AmW1Bfv2XMVcT0UWWf0yLHRqz4Lgc/N35LRsE3cDdd

# FE7AC/TXogK5PyFjUifJbuPBWY346RDXN6LroutTlG0DPSdPHHk54/KOdNoi1NJj

# g4a4ZTVJdofj0lI/e3zIZgD++ittbhWd54PvbUWDBolOgcWQ4jCCB3EwggVZoAMC

# AQICEzMAAAAVxedrngKbSZkAAAAAABUwDQYJKoZIhvcNAQELBQAwgYgxCzAJBgNV

# BAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4w

# HAYDVQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xMjAwBgNVBAMTKU1pY3Jvc29m

# dCBSb290IENlcnRpZmljYXRlIEF1dGhvcml0eSAyMDEwMB4XDTIxMDkzMDE4MjIy

# NVoXDTMwMDkzMDE4MzIyNVowfDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hp

# bmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jw

# b3JhdGlvbjEmMCQGA1UEAxMdTWljcm9zb2Z0IFRpbWUtU3RhbXAgUENBIDIwMTAw

# ggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDk4aZM57RyIQt5osvXJHm9

# DtWC0/3unAcH0qlsTnXIyjVX9gF/bErg4r25PhdgM/9cT8dm95VTcVrifkpa/rg2

# Z4VGIwy1jRPPdzLAEBjoYH1qUoNEt6aORmsHFPPFdvWGUNzBRMhxXFExN6AKOG6N

# 7dcP2CZTfDlhAnrEqv1yaa8dq6z2Nr41JmTamDu6GnszrYBbfowQHJ1S/rboYiXc

# ag/PXfT+jlPP1uyFVk3v3byNpOORj7I5LFGc6XBpDco2LXCOMcg1KL3jtIckw+DJ

# j361VI/c+gVVmG1oO5pGve2krnopN6zL64NF50ZuyjLVwIYwXE8s4mKyzbnijYjk

# lqwBSru+cakXW2dg3viSkR4dPf0gz3N9QZpGdc3EXzTdEonW/aUgfX782Z5F37Zy

# L9t9X4C626p+Nuw2TPYrbqgSUei/BQOj0XOmTTd0lBw0gg/wEPK3Rxjtp+iZfD9M

# 269ewvPV2HM9Q07BMzlMjgK8QmguEOqEUUbi0b1qGFphAXPKZ6Je1yh2AuIzGHLX

# pyDwwvoSCtdjbwzJNmSLW6CmgyFdXzB0kZSU2LlQ+QuJYfM2BjUYhEfb3BvR/bLU

# HMVr9lxSUV0S2yW6r1AFemzFER1y7435UsSFF5PAPBXbGjfHCBUYP3irRbb1Hode

# 2o+eFnJpxq57t7c+auIurQIDAQABo4IB3TCCAdkwEgYJKwYBBAGCNxUBBAUCAwEA

# ATAjBgkrBgEEAYI3FQIEFgQUKqdS/mTEmr6CkTxGNSnPEP8vBO4wHQYDVR0OBBYE

# FJ+nFV0AXmJdg/Tl0mWnG1M1GelyMFwGA1UdIARVMFMwUQYMKwYBBAGCN0yDfQEB

# MEEwPwYIKwYBBQUHAgEWM2h0dHA6Ly93d3cubWljcm9zb2Z0LmNvbS9wa2lvcHMv

# RG9jcy9SZXBvc2l0b3J5Lmh0bTATBgNVHSUEDDAKBggrBgEFBQcDCDAZBgkrBgEE

# AYI3FAIEDB4KAFMAdQBiAEMAQTALBgNVHQ8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB

# /zAfBgNVHSMEGDAWgBTV9lbLj+iiXGJo0T2UkFvXzpoYxDBWBgNVHR8ETzBNMEug

# SaBHhkVodHRwOi8vY3JsLm1pY3Jvc29mdC5jb20vcGtpL2NybC9wcm9kdWN0cy9N

# aWNSb29DZXJBdXRfMjAxMC0wNi0yMy5jcmwwWgYIKwYBBQUHAQEETjBMMEoGCCsG

# AQUFBzAChj5odHRwOi8vd3d3Lm1pY3Jvc29mdC5jb20vcGtpL2NlcnRzL01pY1Jv

# b0NlckF1dF8yMDEwLTA2LTIzLmNydDANBgkqhkiG9w0BAQsFAAOCAgEAnVV9/Cqt

# 4SwfZwExJFvhnnJL/Klv6lwUtj5OR2R4sQaTlz0xM7U518JxNj/aZGx80HU5bbsP

# MeTCj/ts0aGUGCLu6WZnOlNN3Zi6th542DYunKmCVgADsAW+iehp4LoJ7nvfam++

# Kctu2D9IdQHZGN5tggz1bSNU5HhTdSRXud2f8449xvNo32X2pFaq95W2KFUn0CS9

# QKC/GbYSEhFdPSfgQJY4rPf5KYnDvBewVIVCs/wMnosZiefwC2qBwoEZQhlSdYo2

# wh3DYXMuLGt7bj8sCXgU6ZGyqVvfSaN0DLzskYDSPeZKPmY7T7uG+jIa2Zb0j/aR

# AfbOxnT99kxybxCrdTDFNLB62FD+CljdQDzHVG2dY3RILLFORy3BFARxv2T5JL5z

# bcqOCb2zAVdJVGTZc9d/HltEAY5aGZFrDZ+kKNxnGSgkujhLmm77IVRrakURR6nx

# t67I6IleT53S0Ex2tVdUCbFpAUR+fKFhbHP+CrvsQWY9af3LwUFJfn6Tvsv4O+S3

# Fb+0zj6lMVGEvL8CwYKiexcdFYmNcP7ntdAoGokLjzbaukz5m/8K6TT4JDVnK+AN

# uOaMmdbhIurwJ0I9JZTmdHRbatGePu1+oDEzfbzL6Xu/OHBE0ZDxyKs6ijoIYn/Z

# cGNTTY3ugm2lBRDBcQZqELQdVTNYs6FwZvKhggNWMIICPgIBATCCAQGhgdmkgdYw

# gdMxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdS

# ZWRtb25kMR4wHAYDVQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xLTArBgNVBAsT

# JE1pY3Jvc29mdCBJcmVsYW5kIE9wZXJhdGlvbnMgTGltaXRlZDEnMCUGA1UECxMe

# blNoaWVsZCBUU1MgRVNOOjRDMUEtMDVFMC1EOTQ3MSUwIwYDVQQDExxNaWNyb3Nv

# ZnQgVGltZS1TdGFtcCBTZXJ2aWNloiMKAQEwBwYFKw4DAhoDFQCpE4xsxLwlxSVy

# c+TBEsVE9cWymaCBgzCBgKR+MHwxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNo

# aW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNyb3NvZnQgQ29y

# cG9yYXRpb24xJjAkBgNVBAMTHU1pY3Jvc29mdCBUaW1lLVN0YW1wIFBDQSAyMDEw

# MA0GCSqGSIb3DQEBCwUAAgUA6/I8kjAiGA8yMDI1MDYxMDA1MDkzOFoYDzIwMjUw

# NjExMDUwOTM4WjB0MDoGCisGAQQBhFkKBAExLDAqMAoCBQDr8jySAgEAMAcCAQAC

# Agi3MAcCAQACAhNBMAoCBQDr844SAgEAMDYGCisGAQQBhFkKBAIxKDAmMAwGCisG

# AQQBhFkKAwKgCjAIAgEAAgMHoSChCjAIAgEAAgMBhqAwDQYJKoZIhvcNAQELBQAD

# ggEBAI3IPjO5X7RFSj3jdX4vFhZVS5JCfozPhaPv6WK7Ct8/J2/67IIhND8I7Ouq

# 142JNot7ysnl9I15NcNcChUgzaw00Q8ScdFQIkC4sn+CCt7CE3Buo2WVEHP0pK3D

# v7XkmnR6LoBZRJrHW+v83dTD+0z6CP3wzgN9JD3monVoOl2pM226kczx61zI8AUV

# nmn7ar8s5CJqTgCjmvdfearft2/Cj2g0pOdeSzD8kp9swk2amek+4zHkyKzZywcw

# OuT+zjG0VhP6tOhKsdfCeyM2HHL8eepLg5bdajoFuGml5wiH2l7XOICUEUwiGnbX

# KltGnjccwyUuZnZbfmnOFEUK/5YxggQNMIIECQIBATCBkzB8MQswCQYDVQQGEwJV

# UzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UE

# ChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMSYwJAYDVQQDEx1NaWNyb3NvZnQgVGlt

# ZS1TdGFtcCBQQ0EgMjAxMAITMwAAAf8SOHz3wWXWoQABAAAB/zANBglghkgBZQME

# AgEFAKCCAUowGgYJKoZIhvcNAQkDMQ0GCyqGSIb3DQEJEAEEMC8GCSqGSIb3DQEJ

# BDEiBCAUaIup4qIyySsWJZ1fQtSGWzEFODmnUwftl7kpXi+fPzCB+gYLKoZIhvcN

# AQkQAi8xgeowgecwgeQwgb0EIOQy777JAndprJwi4xPq8Dsk24xpU4jeoONIRXy6

# nKf9MIGYMIGApH4wfDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24x

# EDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlv

# bjEmMCQGA1UEAxMdTWljcm9zb2Z0IFRpbWUtU3RhbXAgUENBIDIwMTACEzMAAAH/

# Ejh898Fl1qEAAQAAAf8wIgQgboVxZUKU+LyOJzlvs3Ly5/3BFe9dvgxc19Q1VZyL

# MfwwDQYJKoZIhvcNAQELBQAEggIAQgcTq29la60Dba5AEZ82ELgda4PqMKmPKsi/

# kpU+wBSAkNf+Ku83orxrCvh4Dj+d3SkN0FUTibC1TVBHZnJaIDPjy4TkIBQ9U5SW

# EBIfysizi4p9KD/GFe01ZeJI1YLIx0LpgZ+7mvkvfFinFZAvKQvO8uaou+TGn45r

# 9EXrBvoRW/a9avdOv3NWv8NjjS8N+iFxu3u4DlwYRG4G5X4MGya2RGSR3R0PXukC

# L1sMWgkbswm0MyY443D1YW6/yR0g9cJGe4T8izxph63SEiZ5NnZIGpgh5tjdAhTL

# TRv8SLszxvxmk8aGpOFILqfchn/dmIcvooy70q3FQ7L8hbjMonxRIhjLW769IXL6

# zkbCPni3J5Tir9H2c/sphhxrMApDyp91qWQ6EzVF+U1xgDea4jJRGyyXrjM1XM9S

# kLNUnhcZXsX5h/cKI/Yzj5wWYLzoDLNnwSMoEd9nU/f3pO5GQydaqDrQgGeLu0vU

# c3bGRPwBlbq+pZeqpQsHvtHCu/AZz5+sflMPlFed2QkHMbLmsUHqDQqHXt2GEN1i

# 9cuYR6XlxB+f89JW0QGB9bq2XqA451C88X5vqoMbCd4aLnP8RV8BJXbIaeCM67IG

# gV6rDp6WkcXqQr8nCMl+WSx4XnTD4HQuyB+Gxz0y2An/mfZC+1RsUtgln61Mssja

# xP+I7z0=

# SIG # End signature block