Pester

5.0.0-rc1

new-runtimepoc/Pester.Utility.ps1

                                
# TODO: Consider removing usage of Write-Host in favor of a solution that does not use any cmdlet

$_write_host = Get-Command -CommandType Cmdlet -Name Write-Host

# TODO: Remove this types import once this becomes just ps1

. $PSScriptRoot/Pester.Types.ps1

function or {

    [CmdletBinding()]

    param (

        [Parameter(Mandatory = $true, Position = 0)]

        $DefaultValue,

        [Parameter(ValueFromPipeline = $true)]

        $InputObject

    )

    if ($InputObject) {

        $InputObject

    }

    else {

        $DefaultValue

    }

}

# looks for a property on object that might be null

function tryGetProperty {

    [CmdletBinding()]

    param (

        [Parameter(Position = 0)]

        $InputObject,

        [Parameter(Mandatory = $true, Position = 1)]

        $PropertyName

    )

    if ($null -eq $InputObject) {

        return

    }

    $InputObject.$PropertyName

    # this would be useful if we looked for property that might not exist

    # but that is not the case so-far. Originally I implemented this incorrectly

    # so I will keep this here for reference in case I was wrong the second time as well

    # $property = $InputObject.PSObject.Properties.Item($PropertyName)

    # if ($null -ne $property) {

    #     $property.Value

    # }

}

function trySetProperty {

    [CmdletBinding()]

    param (

        [Parameter(Position = 0)]

        $InputObject,

        [Parameter(Mandatory = $true, Position = 1)]

        $PropertyName,

        [Parameter(Mandatory = $true, Position = 2)]

        $Value

    )

    if ($null -eq $InputObject) {

        return

    }

    $InputObject.$PropertyName = $Value

}

# combines collections that are not null or empty, but does not remove null values

# from collections so e.g. combineNonNull @(@(1,$null), @(1,2,3), $null, $null, 10)

# returns 1, $null, 1, 2, 3, 10

function combineNonNull ($Array) {

    foreach ($i in $Array) {

        $arr = @($i)

        if ($null -ne $i -and $arr.Length -gt 0) {

            foreach ($a in $arr) {

                $a

            }

        }

    }

}

filter selectNonNull {

    param($Collection)

    @(foreach ($i in $Collection) {

        if ($i) { $i }

    })

}

function any ($InputObject) {

    if (-not $InputObject) {

        return $false

    }

    @($InputObject).Length -gt 0

}

function none ($InputObject) {

    -not (any $InputObject)

}

function defined {

    param(

        [Parameter(Mandatory)]

        [String] $Name

    )

    # gets a variable via the provider and returns it's value, the name is slightly misleading

    # because it indicates that the variable is not defined when it is null, but that is fine

    # the call to the provider is slightly more expensive (at least it seems) so this should be

    # used only when we want a value that we will further inspect, and we don't want to add the overhead of

    # first checking that the variable exists and then getting it's value like here:

    # defined v & hasValue v & $v.Name -eq "abc"

    $ExecutionContext.SessionState.PSVariable.GetValue($Name)

}

function notDefined {

    param(

        [Parameter(Mandatory)]

        [String] $Name

    )

    # gets a variable via the provider and returns it's value, the name is slightly misleading

    # because it indicates that the variable is not defined when it is null, but that is fine

    # the call to the provider is slightly more expensive (at least it seems) so this should be

    # used only when we want a value that we will further inspect

    $null -eq ($ExecutionContext.SessionState.PSVariable.GetValue($Name))

}

function sum ($InputObject, $PropertyName, $Zero) {

    if (none $InputObject.Length) {

        return $Zero

    }

    $acc = $Zero

    foreach ($i in $InputObject) {

        $acc += $i.$PropertyName

    }

    $acc

}

function tryGetValue {

    [CmdletBinding()]

    param(

        $Hashtable,

        $Key

    )

    if ($Hashtable.ContainsKey($Key)) {

        # do not enumerate so we get the same thing back

        # even if it is a collection

        $PSCmdlet.WriteObject($Hashtable.$Key, $false)

    }

}

function tryAddValue {

    [CmdletBinding()]

    param(

        $Hashtable,

        $Key,

        $Value

    )

    if (-not $Hashtable.ContainsKey($Key)) {

        $null = $Hashtable.Add($Key, $Value)

    }

}

function getOrUpdateValue {

    [CmdletBinding()]

    param(

        $Hashtable,

        $Key,

        $DefaultValue

    )

    if ($Hashtable.ContainsKey($Key)) {

        # do not enumerate so we get the same thing back

        # even if it is a collection

        $PSCmdlet.WriteObject($Hashtable.$Key, $false)

    }

    else {

        $Hashtable.Add($Key, $DefaultValue)

        # do not enumerate so we get the same thing back

        # even if it is a collection

        $PSCmdlet.WriteObject($DefaultValue, $false)

    }

}

function tryRemoveKey ($Hashtable, $Key) {

    if ($Hashtable.ContainsKey($Key)) {

        $Hashtable.Remove($Key)

    }

}

function Merge-Hashtable ($Source, $Destination) {

    foreach ($p in $Source.GetEnumerator()) {

        # only add non existing keys so in case of conflict

        # the framework name wins, as if we had explicit parameters

        # on a scriptblock, then the parameter would also win

        if (-not $Destination.ContainsKey($p.Key)) {

            $Destination.Add($p.Key, $p.Value)

        }

    }

}

function Merge-HashtableOrObject ($Source, $Destination) {

    if ($Source -isnot [Collections.IDictionary] -and $Source -isnot [PSObject]) {

        throw "Source must be a Hashtable, IDictionary or a PSObject."

    }

    if ($Destination -isnot [PSObject]) {

        throw "Destination must be a PSObject."

    }

    $sourceIsPSObject = $Source -is [PSObject]

    $sourceIsDictionary = $Source -is [Collections.IDictionary]

    $destinationIsPSObject = $Destination -is [PSObject]

    $destinationIsDictionary = $Destination -is [Collections.IDictionary]

    $items = if ($sourceIsDictionary) { $Source.GetEnumerator() } else { $Source.PSObject.Properties }

    foreach ($p in $items) {

        if ($null -eq $Destination.PSObject.Properties.Item($p.Key)) {

            $Destination.PSObject.Properties.Add([Pester.Factory]::CreateNoteProperty($p.Key, $p.Value))

        }

        else {

            if ($p.Value -is [hashtable] -or $p.Value -is [PSObject]) {

                Merge-HashtableOrObject -Source $p.Value -Destination $Destination.($p.Key)

            }

            else {

                $Destination.($p.Key) = $p.Value

            }

        }

    }

}

function Write-PesterDebugMessage {

    [CmdletBinding(DefaultParameterSetName = "Default")]

    param (

        [Parameter(Mandatory = $true, Position = 0)]

        [ValidateSet("RuntimeCore", "RuntimeFilter", "RuntimeSkip", "Runtime", "Mock", "MockCore", "Discovery", "DiscoveryCore", "SessionState", "Timing", "TimingCore", "Plugin", "PluginCore")]

        [String] $Scope,

        [Parameter(Mandatory = $true, Position = 1, ParameterSetName = "Default")]

        [String] $Message,

        [Parameter(Mandatory = $true, Position = 1, ParameterSetName = "Lazy")]

        [ScriptBlock] $LazyMessage,

        [Parameter(Position = 2)]

        [Management.Automation.ErrorRecord] $ErrorRecord

    )

    if (-not $PesterPreference.Debug.WriteDebugMessages.Value) {

        throw "This should never happen. All calls to Write-PesterDebugMessage should be wrapped in `if` to avoid perfomace hit of allocating the message and calling the function. Inspect the call stack to know where this call came from. This can also happen if `$PesterPreference is different from the `$PesterPreference that utilities see because of incorrect scoping."

    }

    $messagePreference = $PesterPreference.Debug.WriteDebugMessagesFrom.Value

    if ($Scope -notlike $messagePreference) {

        return

    }

    $color =

        if ($null -ne $ErrorRecord) {

            "Red"

        }

        else {

            switch ($Scope) {

                "RuntimeCore" { "Cyan" }

                "RuntimeFilter" { "Cyan" }

                "RuntimeSkip" { "Cyan" }

                "Runtime" { "DarkGray" }

                "Mock" { "DarkYellow" }

                "Discovery" { "DarkMagenta" }

                "DiscoveryCore" { "DarkMagenta" }

                "SessionState" { "Gray" }

                "Timing" { "Gray" }

                "TimingCore" { "Gray" }

                "PluginCore" { "Blue" }

                "Plugin" { "Blue" }

                default { "Cyan" }

            }

        }

    # this evaluates a message that is expensive to produce so we only evaluate it

    # when we know that we will write it. All messages could be provided as scriptblocks

    # but making a script block is slightly more expensive than making a string, so lazy approach

    # is used only when the message is obviously expensive, like folding the whole tree to get

    # count of found tests

    #TODO: remove this, it was clever but the best performance is achieved by putting an if around the whole call which is what I do in hopefully all places, that way the scriptblock nor the string are allocated

    if ($null -ne $LazyMessage) {

        $Message = (&$LazyMessage) -join "`n"

    }

    & $_Write_Host -ForegroundColor Black -BackgroundColor $color  "${Scope}: $Message "

    if ($null -ne $ErrorRecord) {

        & $_Write_Host -ForegroundColor Black -BackgroundColor $color "$ErrorRecord"

    }

}

function Fold-Block {

    param(

        [Parameter(Mandatory, ValueFromPipeline)]

        $Block,

        $OnBlock = {},

        $OnTest = {},

        $Accumulator

    )

    process {

        foreach ($b in $Block) {

            $Accumulator = & $OnBlock $Block $Accumulator

            foreach ($test in $Block.Tests) {

                $Accumulator = &$OnTest $test $Accumulator

            }

            foreach ($b in $Block.Blocks) {

                Fold-Block -Block $b -OnTest $OnTest -OnBlock $OnBlock -Accumulator $Accumulator

            }

        }

    }

}

function Fold-Container {

    param (

        [Parameter(Mandatory, ValueFromPipeline)]

        $Container,

        $OnContainer = {},

        $OnBlock = {},

        $OnTest = {},

        $Accumulator

    )

    process {

        foreach ($c in $Container) {

            $Accumulator = & $OnContainer $c $Accumulator

            foreach ($block in $c.Blocks) {

                Fold-Block -Block $block -OnBlock $OnBlock -OnTest $OnTest -Accumulator $Accumulator

            }

        }

    }

}

function Fold-Run {

    param (

        [Parameter(Mandatory, ValueFromPipeline)]

        $Run,

        $OnRun = {},

        $OnContainer = {},

        $OnBlock = {},

        $OnTest = {},

        $Accumulator

    )

    process {

        foreach ($r in $Run) {

            $Accumulator = & $OnRun $r $Accumulator

            foreach ($container in $r.Containers) {

                Fold-Container -Container $container -OnContainer $OnContainer -OnBlock $OnBlock -OnTest $OnTest -Accumulator $Accumulator

            }

        }

    }

}

function Test-NullOrWhiteSpace ($Value) {

    # psv2 compatibility, on newer .net we would simply use

    # [string]::isnullorwhitespace

    $null -eq $Value -or $Value -match "^\s*$"

}

function New_PSObject {

    [CmdletBinding()]

    param (

        [Parameter(Mandatory = $true)]

        [Collections.IDictionary] $Property,

        [String] $Type

    )

    # TODO: is calling the function unnecessary overhead?

    if (-not (Test-NullOrWhiteSpace $Type) ) {

        # -and -not $Property.ContainsKey("PSTypeName")) {

        $Property.Add("PSTypeName", $Type)

    }

    [PSCustomObject]$Property

}

# SIG # Begin signature block

# MIIcVgYJKoZIhvcNAQcCoIIcRzCCHEMCAQExCzAJBgUrDgMCGgUAMGkGCisGAQQB

# gjcCAQSgWzBZMDQGCisGAQQBgjcCAR4wJgIDAQAABBAfzDtgWUsITrck0sYpfvNR

# AgEAAgEAAgEAAgEAAgEAMCEwCQYFKw4DAhoFAAQUeH8TGdSqLzbF1bF1lpWHxnQM

# gJyggheFMIIFDjCCA/agAwIBAgIQCIQ1OU/QbU6rESO7M78utDANBgkqhkiG9w0B

# AQsFADByMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYD

# VQQLExB3d3cuZGlnaWNlcnQuY29tMTEwLwYDVQQDEyhEaWdpQ2VydCBTSEEyIEFz

# c3VyZWQgSUQgQ29kZSBTaWduaW5nIENBMB4XDTIwMDEzMTAwMDAwMFoXDTIxMDEw

# NTEyMDAwMFowSzELMAkGA1UEBhMCQ1oxDjAMBgNVBAcTBVByYWhhMRUwEwYDVQQK

# DAxKYWt1YiBKYXJlxaExFTATBgNVBAMMDEpha3ViIEphcmXFoTCCASIwDQYJKoZI

# hvcNAQEBBQADggEPADCCAQoCggEBALYF0cDtFUyYgraHpHdObGJM9dxjfRr0WaPN

# kVZcEHdPXk4bVCPZLSca3Byybx745CpB3oejDHEbohLSTrbunoSA9utpwxVQSutt

# /H1onVexiJgwGJ6xoQgR17FGLBGiIHgyPhFJhba9yENh0dqargLWllsg070WE2yb

# gz3m659gmfuCuSZOhQ2nCHvOjEocTiI67mZlHvN7axg+pCgdEJrtIyvhHPqXeE2j

# cdMrfmYY1lq2FBpELEW1imYlu5BnaJd/5IT7WjHL3LWx5Su9FkY5RwrA6+X78+j+

# vKv00JtDjM0dT+4A/m65jXSywxa4YoGDqQ5n+BwDMQlWCzfu37sCAwEAAaOCAcUw

# ggHBMB8GA1UdIwQYMBaAFFrEuXsqCqOl6nEDwGD5LfZldQ5YMB0GA1UdDgQWBBRE

# 05R/U5mVzc4vKq4rvKyyPm12EzAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYI

# KwYBBQUHAwMwdwYDVR0fBHAwbjA1oDOgMYYvaHR0cDovL2NybDMuZGlnaWNlcnQu

# Y29tL3NoYTItYXNzdXJlZC1jcy1nMS5jcmwwNaAzoDGGL2h0dHA6Ly9jcmw0LmRp

# Z2ljZXJ0LmNvbS9zaGEyLWFzc3VyZWQtY3MtZzEuY3JsMEwGA1UdIARFMEMwNwYJ

# YIZIAYb9bAMBMCowKAYIKwYBBQUHAgEWHGh0dHBzOi8vd3d3LmRpZ2ljZXJ0LmNv

# bS9DUFMwCAYGZ4EMAQQBMIGEBggrBgEFBQcBAQR4MHYwJAYIKwYBBQUHMAGGGGh0

# dHA6Ly9vY3NwLmRpZ2ljZXJ0LmNvbTBOBggrBgEFBQcwAoZCaHR0cDovL2NhY2Vy

# dHMuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0U0hBMkFzc3VyZWRJRENvZGVTaWduaW5n

# Q0EuY3J0MAwGA1UdEwEB/wQCMAAwDQYJKoZIhvcNAQELBQADggEBADAk7PRuDcdl

# lPZQSfZ1Y0jeItmEWPMNcAL0LQaa6M5Slrznjxv1ZiseT9SMWTxOQylfPvpOSo1x

# xV3kD7qf7tf2EuicKkV6dBgGiHb0riWZ3+wMA6C8IK3cGesJ4jgpTtYEzbh88pxT

# g2MSzpRnwyXHhrgcKSps1z34JmmmHP1lncxNC6DTM6yEUwE7XiDD2xNoeLITgdTQ

# jjMMT6nDJe8+xL0Zyh32OPIyrG7qPjG6MmEjzlCaWsE/trVo7I9CSOjwpp8721Hj

# q/tIHzPFg1C3dYmDh8Kbmr21dHWBLYQF4P8lq8u8AYDa6H7xvkx7G0i2jglAA4YK

# i1V8AlyTwRkwggUwMIIEGKADAgECAhAECRgbX9W7ZnVTQ7VvlVAIMA0GCSqGSIb3

# DQEBCwUAMGUxCzAJBgNVBAYTAlVTMRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAX

# BgNVBAsTEHd3dy5kaWdpY2VydC5jb20xJDAiBgNVBAMTG0RpZ2lDZXJ0IEFzc3Vy

# ZWQgSUQgUm9vdCBDQTAeFw0xMzEwMjIxMjAwMDBaFw0yODEwMjIxMjAwMDBaMHIx

# CzAJBgNVBAYTAlVTMRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3

# dy5kaWdpY2VydC5jb20xMTAvBgNVBAMTKERpZ2lDZXJ0IFNIQTIgQXNzdXJlZCBJ

# RCBDb2RlIFNpZ25pbmcgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB

# AQD407Mcfw4Rr2d3B9MLMUkZz9D7RZmxOttE9X/lqJ3bMtdx6nadBS63j/qSQ8Cl

# +YnUNxnXtqrwnIal2CWsDnkoOn7p0WfTxvspJ8fTeyOU5JEjlpB3gvmhhCNmElQz

# UHSxKCa7JGnCwlLyFGeKiUXULaGj6YgsIJWuHEqHCN8M9eJNYBi+qsSyrnAxZjNx

# PqxwoqvOf+l8y5Kh5TsxHM/q8grkV7tKtel05iv+bMt+dDk2DZDv5LVOpKnqagqr

# hPOsZ061xPeM0SAlI+sIZD5SlsHyDxL0xY4PwaLoLFH3c7y9hbFig3NBggfkOItq

# cyDQD2RzPJ6fpjOp/RnfJZPRAgMBAAGjggHNMIIByTASBgNVHRMBAf8ECDAGAQH/

# AgEAMA4GA1UdDwEB/wQEAwIBhjATBgNVHSUEDDAKBggrBgEFBQcDAzB5BggrBgEF

# BQcBAQRtMGswJAYIKwYBBQUHMAGGGGh0dHA6Ly9vY3NwLmRpZ2ljZXJ0LmNvbTBD

# BggrBgEFBQcwAoY3aHR0cDovL2NhY2VydHMuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0

# QXNzdXJlZElEUm9vdENBLmNydDCBgQYDVR0fBHoweDA6oDigNoY0aHR0cDovL2Ny

# bDQuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0QXNzdXJlZElEUm9vdENBLmNybDA6oDig

# NoY0aHR0cDovL2NybDMuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0QXNzdXJlZElEUm9v

# dENBLmNybDBPBgNVHSAESDBGMDgGCmCGSAGG/WwAAgQwKjAoBggrBgEFBQcCARYc

# aHR0cHM6Ly93d3cuZGlnaWNlcnQuY29tL0NQUzAKBghghkgBhv1sAzAdBgNVHQ4E

# FgQUWsS5eyoKo6XqcQPAYPkt9mV1DlgwHwYDVR0jBBgwFoAUReuir/SSy4IxLVGL

# p6chnfNtyA8wDQYJKoZIhvcNAQELBQADggEBAD7sDVoks/Mi0RXILHwlKXaoHV0c

# LToaxO8wYdd+C2D9wz0PxK+L/e8q3yBVN7Dh9tGSdQ9RtG6ljlriXiSBThCk7j9x

# jmMOE0ut119EefM2FAaK95xGTlz/kLEbBw6RFfu6r7VRwo0kriTGxycqoSkoGjpx

# KAI8LpGjwCUR4pwUR6F6aGivm6dcIFzZcbEMj7uo+MUSaJ/PQMtARKUT8OZkDCUI

# QjKyNookAv4vcn4c10lFluhZHen6dGRrsutmQ9qzsIzV6Q3d9gEgzpkxYz0IGhiz

# gZtPxpMQBvwHgfqL2vmCSfdibqFT+hKUGIUukpHqaGxEMrJmoecYpJpkUe8wggZq

# MIIFUqADAgECAhADAZoCOv9YsWvW1ermF/BmMA0GCSqGSIb3DQEBBQUAMGIxCzAJ

# BgNVBAYTAlVTMRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5k

# aWdpY2VydC5jb20xITAfBgNVBAMTGERpZ2lDZXJ0IEFzc3VyZWQgSUQgQ0EtMTAe

# Fw0xNDEwMjIwMDAwMDBaFw0yNDEwMjIwMDAwMDBaMEcxCzAJBgNVBAYTAlVTMREw

# DwYDVQQKEwhEaWdpQ2VydDElMCMGA1UEAxMcRGlnaUNlcnQgVGltZXN0YW1wIFJl

# c3BvbmRlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKNkXfx8s+CC

# NeDg9sYq5kl1O8xu4FOpnx9kWeZ8a39rjJ1V+JLjntVaY1sCSVDZg85vZu7dy4Xp

# X6X51Id0iEQ7Gcnl9ZGfxhQ5rCTqqEsskYnMXij0ZLZQt/USs3OWCmejvmGfrvP9

# Enh1DqZbFP1FI46GRFV9GIYFjFWHeUhG98oOjafeTl/iqLYtWQJhiGFyGGi5uHzu

# 5uc0LzF3gTAfuzYBje8n4/ea8EwxZI3j6/oZh6h+z+yMDDZbesF6uHjHyQYuRhDI

# jegEYNu8c3T6Ttj+qkDxss5wRoPp2kChWTrZFQlXmVYwk/PJYczQCMxr7GJCkawC

# wO+k8IkRj3cCAwEAAaOCAzUwggMxMA4GA1UdDwEB/wQEAwIHgDAMBgNVHRMBAf8E

# AjAAMBYGA1UdJQEB/wQMMAoGCCsGAQUFBwMIMIIBvwYDVR0gBIIBtjCCAbIwggGh

# BglghkgBhv1sBwEwggGSMCgGCCsGAQUFBwIBFhxodHRwczovL3d3dy5kaWdpY2Vy

# dC5jb20vQ1BTMIIBZAYIKwYBBQUHAgIwggFWHoIBUgBBAG4AeQAgAHUAcwBlACAA

# bwBmACAAdABoAGkAcwAgAEMAZQByAHQAaQBmAGkAYwBhAHQAZQAgAGMAbwBuAHMA

# dABpAHQAdQB0AGUAcwAgAGEAYwBjAGUAcAB0AGEAbgBjAGUAIABvAGYAIAB0AGgA

# ZQAgAEQAaQBnAGkAQwBlAHIAdAAgAEMAUAAvAEMAUABTACAAYQBuAGQAIAB0AGgA

# ZQAgAFIAZQBsAHkAaQBuAGcAIABQAGEAcgB0AHkAIABBAGcAcgBlAGUAbQBlAG4A

# dAAgAHcAaABpAGMAaAAgAGwAaQBtAGkAdAAgAGwAaQBhAGIAaQBsAGkAdAB5ACAA

# YQBuAGQAIABhAHIAZQAgAGkAbgBjAG8AcgBwAG8AcgBhAHQAZQBkACAAaABlAHIA

# ZQBpAG4AIABiAHkAIAByAGUAZgBlAHIAZQBuAGMAZQAuMAsGCWCGSAGG/WwDFTAf

# BgNVHSMEGDAWgBQVABIrE5iymQftHt+ivlcNK2cCzTAdBgNVHQ4EFgQUYVpNJLZJ

# Mp1KKnkag0v0HonByn0wfQYDVR0fBHYwdDA4oDagNIYyaHR0cDovL2NybDMuZGln

# aWNlcnQuY29tL0RpZ2lDZXJ0QXNzdXJlZElEQ0EtMS5jcmwwOKA2oDSGMmh0dHA6

# Ly9jcmw0LmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydEFzc3VyZWRJRENBLTEuY3JsMHcG

# CCsGAQUFBwEBBGswaTAkBggrBgEFBQcwAYYYaHR0cDovL29jc3AuZGlnaWNlcnQu

# Y29tMEEGCCsGAQUFBzAChjVodHRwOi8vY2FjZXJ0cy5kaWdpY2VydC5jb20vRGln

# aUNlcnRBc3N1cmVkSURDQS0xLmNydDANBgkqhkiG9w0BAQUFAAOCAQEAnSV+GzNN

# siaBXJuGziMgD4CH5Yj//7HUaiwx7ToXGXEXzakbvFoWOQCd42yE5FpA+94GAYw3

# +puxnSR+/iCkV61bt5qwYCbqaVchXTQvH3Gwg5QZBWs1kBCge5fH9j/n4hFBpr1i

# 2fAnPTgdKG86Ugnw7HBi02JLsOBzppLA044x2C/jbRcTBu7kA7YUq/OPQ6dxnSHd

# FMoVXZJB2vkPgdGZdA0mxA5/G7X1oPHGdwYoFenYk+VVFvC7Cqsc21xIJ2bIo4sK

# HOWV2q7ELlmgYd3a822iYemKC23sEhi991VUQAOSK2vCUcIKSK+w1G7g9BQKOhvj

# jz3Kr2qNe9zYRDCCBs0wggW1oAMCAQICEAb9+QOWA63qAArrPye7uhswDQYJKoZI

# hvcNAQEFBQAwZTELMAkGA1UEBhMCVVMxFTATBgNVBAoTDERpZ2lDZXJ0IEluYzEZ

# MBcGA1UECxMQd3d3LmRpZ2ljZXJ0LmNvbTEkMCIGA1UEAxMbRGlnaUNlcnQgQXNz

# dXJlZCBJRCBSb290IENBMB4XDTA2MTExMDAwMDAwMFoXDTIxMTExMDAwMDAwMFow

# YjELMAkGA1UEBhMCVVMxFTATBgNVBAoTDERpZ2lDZXJ0IEluYzEZMBcGA1UECxMQ

# d3d3LmRpZ2ljZXJ0LmNvbTEhMB8GA1UEAxMYRGlnaUNlcnQgQXNzdXJlZCBJRCBD

# QS0xMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA6IItmfnKwkKVpYBz

# QHDSnlZUXKnE0kEGj8kz/E1FkVyBn+0snPgWWd+etSQVwpi5tHdJ3InECtqvy15r

# 7a2wcTHrzzpADEZNk+yLejYIA6sMNP4YSYL+x8cxSIB8HqIPkg5QycaH6zY/2DDD

# /6b3+6LNb3Mj/qxWBZDwMiEWicZwiPkFl32jx0PdAug7Pe2xQaPtP77blUjE7h6z

# 8rwMK5nQxl0SQoHhg26Ccz8mSxSQrllmCsSNvtLOBq6thG9IhJtPQLnxTPKvmPv2

# zkBdXPao8S+v7Iki8msYZbHBc63X8djPHgp0XEK4aH631XcKJ1Z8D2KkPzIUYJX9

# BwSiCQIDAQABo4IDejCCA3YwDgYDVR0PAQH/BAQDAgGGMDsGA1UdJQQ0MDIGCCsG

# AQUFBwMBBggrBgEFBQcDAgYIKwYBBQUHAwMGCCsGAQUFBwMEBggrBgEFBQcDCDCC

# AdIGA1UdIASCAckwggHFMIIBtAYKYIZIAYb9bAABBDCCAaQwOgYIKwYBBQUHAgEW

# Lmh0dHA6Ly93d3cuZGlnaWNlcnQuY29tL3NzbC1jcHMtcmVwb3NpdG9yeS5odG0w

# ggFkBggrBgEFBQcCAjCCAVYeggFSAEEAbgB5ACAAdQBzAGUAIABvAGYAIAB0AGgA

# aQBzACAAQwBlAHIAdABpAGYAaQBjAGEAdABlACAAYwBvAG4AcwB0AGkAdAB1AHQA

# ZQBzACAAYQBjAGMAZQBwAHQAYQBuAGMAZQAgAG8AZgAgAHQAaABlACAARABpAGcA

# aQBDAGUAcgB0ACAAQwBQAC8AQwBQAFMAIABhAG4AZAAgAHQAaABlACAAUgBlAGwA

# eQBpAG4AZwAgAFAAYQByAHQAeQAgAEEAZwByAGUAZQBtAGUAbgB0ACAAdwBoAGkA

# YwBoACAAbABpAG0AaQB0ACAAbABpAGEAYgBpAGwAaQB0AHkAIABhAG4AZAAgAGEA

# cgBlACAAaQBuAGMAbwByAHAAbwByAGEAdABlAGQAIABoAGUAcgBlAGkAbgAgAGIA

# eQAgAHIAZQBmAGUAcgBlAG4AYwBlAC4wCwYJYIZIAYb9bAMVMBIGA1UdEwEB/wQI

# MAYBAf8CAQAweQYIKwYBBQUHAQEEbTBrMCQGCCsGAQUFBzABhhhodHRwOi8vb2Nz

# cC5kaWdpY2VydC5jb20wQwYIKwYBBQUHMAKGN2h0dHA6Ly9jYWNlcnRzLmRpZ2lj

# ZXJ0LmNvbS9EaWdpQ2VydEFzc3VyZWRJRFJvb3RDQS5jcnQwgYEGA1UdHwR6MHgw

# OqA4oDaGNGh0dHA6Ly9jcmwzLmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydEFzc3VyZWRJ

# RFJvb3RDQS5jcmwwOqA4oDaGNGh0dHA6Ly9jcmw0LmRpZ2ljZXJ0LmNvbS9EaWdp

# Q2VydEFzc3VyZWRJRFJvb3RDQS5jcmwwHQYDVR0OBBYEFBUAEisTmLKZB+0e36K+

# Vw0rZwLNMB8GA1UdIwQYMBaAFEXroq/0ksuCMS1Ri6enIZ3zbcgPMA0GCSqGSIb3

# DQEBBQUAA4IBAQBGUD7Jtygkpzgdtlspr1LPUukxR6tWXHvVDQtBs+/sdR90OPKy

# XGGinJXDUOSCuSPRujqGcq04eKx1XRcXNHJHhZRW0eu7NoR3zCSl8wQZVann4+er

# Ys37iy2QwsDStZS9Xk+xBdIOPRqpFFumhjFiqKgz5Js5p8T1zh14dpQlc+Qqq8+c

# dkvtX8JLFuRLcEwAiR78xXm8TBJX/l/hHrwCXaj++wc4Tw3GXZG5D2dFzdaD7eeS

# DY2xaYxP+1ngIw/Sqq4AfO6cQg7PkdcntxbuD8O9fAqg7iwIVYUiuOsYGk38KiGt

# STGDR5V3cdyxG0tLHBCcdxTBnU8vWpUIKRAmMYIEOzCCBDcCAQEwgYYwcjELMAkG

# A1UEBhMCVVMxFTATBgNVBAoTDERpZ2lDZXJ0IEluYzEZMBcGA1UECxMQd3d3LmRp

# Z2ljZXJ0LmNvbTExMC8GA1UEAxMoRGlnaUNlcnQgU0hBMiBBc3N1cmVkIElEIENv

# ZGUgU2lnbmluZyBDQQIQCIQ1OU/QbU6rESO7M78utDAJBgUrDgMCGgUAoHgwGAYK

# KwYBBAGCNwIBDDEKMAigAoAAoQKAADAZBgkqhkiG9w0BCQMxDAYKKwYBBAGCNwIB

# BDAcBgorBgEEAYI3AgELMQ4wDAYKKwYBBAGCNwIBFTAjBgkqhkiG9w0BCQQxFgQU

# kCNHNqgOaDGSOZ8vJg5on+YYD1kwDQYJKoZIhvcNAQEBBQAEggEAOyGrENlkTVLJ

# PFdXAPXDwXmP0JyDtnFrXIUDoMhfD1hb7cZWe0Ltzjq43iRAdaLtIyMOxCz9DXLP

# EEFQDiDQo2p8uB6v5eHYm1rJiwundkuGnqkuYhiCuJgCexPWPD8MyBtZ9BKnNvN+

# xCiCTE9i+mTv79luhx514Uxfag7U++A9lvNRSHAyvVM6wWrUWnZlfKAPZc+14xQA

# 2tEMEYO1W5tGja2rYQjgh6ggnw5wn/MHguctFZEUNkx7ayikanGp2Ywg6afgZH1h

# pZKQfGpubKjIEAMlsbeamVwNQnIkIXr+sXNa8OYghlJNdqDPlp8K1HQZ3GVdQzUK

# Rr26fB7ZhaGCAg8wggILBgkqhkiG9w0BCQYxggH8MIIB+AIBATB2MGIxCzAJBgNV

# BAYTAlVTMRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdp

# Y2VydC5jb20xITAfBgNVBAMTGERpZ2lDZXJ0IEFzc3VyZWQgSUQgQ0EtMQIQAwGa

# Ajr/WLFr1tXq5hfwZjAJBgUrDgMCGgUAoF0wGAYJKoZIhvcNAQkDMQsGCSqGSIb3

# DQEHATAcBgkqhkiG9w0BCQUxDxcNMjAwNDA0MTc1MTQ1WjAjBgkqhkiG9w0BCQQx

# FgQUfB8qu9zN77J4dMXOcIcBCj79Wc8wDQYJKoZIhvcNAQEBBQAEggEAimMtUey4

# HXacaihS+tgkJ3AjO4bT6XQnUJEBtura8LzaZCrVcpKvh+zRB0GbFEKjzYPO4D8Y

# U6U4OfKRMc10OkaFJeSr8TZ9yMxhIuIoKjXW4xmF2wGCyFyJJEUFF7l43H/FVFYe

# q32/MmrRK+3h1/oSLUl4QEjP/cAUuQb498W9EZCnC5A5QmXiZUvn2ZuifKAIrKhf

# fZbrFkWwGrFy8zVDVqdAM50yvwCl0tFB5QKd7XVHasgM3bVTpGmK5/P3pXlYbqKl

# YitzWc8xT32XASiZUgGHL+x7sICoY8cz5/kzMDHoX8IacB5DYwEdVs4tugnBF6cW

# srZg691aTuUcqg==

# SIG # End signature block