TurnKeySdn

0.0.31

ConfigManager.psm1

Import-Module $PSScriptRoot\Utils.psm1
Import-Module $PSScriptRoot\ClusUtils.psm1

$script:CMap = @{}

$script:CMap["turnKeySdnPath"] = ""
$script:CMap["storePath"] = ""
$script:CMap["state"] = "state.json"
$script:CMap["credential"] = "cred.json"
$script:CMap["workloadcredential"] = "workloadcred.json"
$script:CMap["userConfigPath"] = "$PSScriptRoot\config\deployment"
$script:CMap["deploymentConfigPath"] = "$PSScriptRoot\config\deployment"
$script:CMap["deploymentFile"] = "deployment.json"
$script:CMap["hnvpaNetworkFile"] = "networkconfig\logicalnetworks\hnvpa.json"
$script:CMap["mgmtNetworkFile"] = "networkconfig\logicalnetworks\management.json"
$script:CMap["greNetworkFile"] = "networkconfig\logicalnetworks\grevip.json"
$script:CMap["publicVIPNetworkFile"] = "networkconfig\logicalnetworks\publicvip.json"
$script:CMap["privateVIPNetworkFile"] = "networkconfig\logicalnetworks\privatevip.json"
$script:CMap["macpoolFile"] = "networkconfig\macpools\defaultMacPool.json"
$script:CMap["sdnConfigFile"] = "sdnconfig.json"

$script:CMap["sdnExpressConfigPath"] = "$PSScriptRoot\config\sdnexpress"
$script:CMap["sdnExpressTemplateFile"] = "template.psd1"
$script:CMap["sdnExpressGeneratedFile"] = "sdnExpGenerated.psd1"


$script:CMap["userWorkloadConfigPath"] = "$PSScriptRoot\config\workload"
$script:CMap["workloadConfigPath"] = "$PSScriptRoot\config\workload"
$script:CMap["workload"] = "workloadconfig.json"

$script:CMap["vhdStore"] = ""

$script:MgmtHostNicName = "TurnKeySdn-Mgmt"

$script:DefaultTestVhdShare = "\\sesdfs.redmond.corp.microsoft.com\1windows\testcontent\core\io-fabrics\sdn\netcdev\SDN_ADOArtifacts\TestArtifacts\mariner_workload_vhd"
$script:DefaultTestVhdFile = "full-2.0.20231004.vhdx"

$script:InstallStateInstalled = "installed"
$script:InstallStateInstallFailed = "installFailed"
$script:InstallStateInstalling = "installing"
$script:InstallStateNone = "none"

$script:InternetSwitchDefaultName = "turnkeysdn-internet"
$script:SdnSwitchDefaultName = "turnkeysdn-sdnswitch"

# Corp network routes, used on the management nic of gateway VMs to allow access to corp network
$script:MSFTCorpRoutes = @("10.0.0.0/8")
function Initialize-StorePath {

    if (-not [String]::IsNullOrEmpty($script:CMap["turnKeySdnPath"]) -and `
            -not ([String]::IsNullOrEmpty($script:CMap["storePath"]))) {
        return
    }

    $csv = Get-CSV

    if ($null -ne $csv) {
        $script:CMap["turnKeySdnPath"] = Join-Path $csv "TurnKeySdn"
        $script:CMap["vhdStore"] = Join-Path $csv "TurnKeySdnVhdStore"
    }
    else {
        $script:CMap["turnKeySdnPath"] = Join-Path $Env:SystemDrive "TurnKeySdn"
        $script:CMap["vhdStore"] = Join-Path $Env:SystemDrive "TurnKeySdnVhdStore"
    }

    $script:CMap["storePath"] = Join-Path $script:CMap["turnKeySdnPath"] ".store"

    if (Test-IsInitialized) {
        $script:CMap["deploymentConfigPath"] = Join-Path $script:CMap["turnKeySdnPath"] "DeploymentConfig"
        $script:CMap["workloadConfigPath"] = Join-Path $script:CMap["turnKeySdnPath"] "WorkloadConfig"
    }
    
    if (-not $(Test-Path (Get-TurnKeySdnPath))) {
        New-Item (Get-TurnKeySdnPath) -ItemType Directory -ErrorAction Stop | Out-Null
    }

    if (-not $(Test-Path (Get-StorePath))) {
        New-Item (Get-StorePath) -ItemType Directory -ErrorAction Stop | Out-Null
    }

}

function Undo-StorePathInitialization {
    $script:CMap["turnKeySdnPath"] = ""
    $script:CMap["storePath"] = ""
    $script:CMap["deploymentConfigPath"] = $script:CMap["userConfigPath"] 
    $script:CMap["workloadConfigPath"] = $script:CMap["userWorkloadConfigPath"]
    $script:CMap["vhdStore"] = ""

}

function Get-StorePath {
    Initialize-StorePath
    return $script:CMap["storePath"]
}

function Get-TurnKeySdnPath {
    Initialize-StorePath
    return $script:CMap["turnKeySdnPath"]
}

function Get-InternalDeploymentConfigPath {
    Initialize-StorePath
    return $script:CMap["deploymentConfigPath"]
}

function Get-InternalWorkloadConfigPath {
    Initialize-StorePath
    return $script:CMap["workloadConfigPath"]
}

function Get-VhdStore {
    Initialize-StorePath
    return $script:CMap["vhdStore"]
}

function Get-SdnExpressPath {

    param (
        [parameter(Mandatory = $false)][switch] $SkipConfigPath
    )

    if (-not $($SkipConfigPath.IsPresent)) {
        $infraconfig = Get-DeploymentConfig
        $sdnExpPath = $infraconfig.sdnexpressPath
    
        if (-not [String]::IsNullOrEmpty($sdnExpPath)) {
            $sdnExpPSM1 = Join-Path $sdnExpPath "SDNExpress.psm1"
            if ($(Test-Path $sdnExpPSM1)) {
                return $sdnExpPath
            }
        }
    }

    $sdnExpPath = Join-Path $PSScriptRoot "..\..\SDNExpress"
    $sdnExpPSM1 = Join-Path $sdnExpPath "SDNExpress.psm1"
    if ($(Test-Path $sdnExpPSM1)) {
        return $sdnExpPath
    }

    Import-Module -Name SdnExpress -ErrorAction SilentlyContinue
    $module = Get-Module SdnExpress
    if ($null -ne $module) {
        return $module.ModuleBase
    }

    return $null
}


function Set-SdnExpressPathInternal {
    param(
        [parameter(Mandatory = $true)][string] $sdnExpressPath
    )
 
    $infraconfig = Get-DeploymentConfig
    $infraconfig.sdnexpressPath = $sdnExpressPath
    Set-DeploymentConfig -deploymentConfig $infraconfig
    Write-TraceLog "Set-SdnExpressPath: Updated path to $sdnExpressPath"
}

function Get-SdnExpressModule {
    $sdnExpPath = Get-SdnExpressPath
    $sdnexpress = Join-Path $sdnExpPath SDNExpress.psm1
    return $sdnexpress
}

function Get-SdnExpressScript {
    $sdnExpPath = Get-SdnExpressPath
    $sdnexpress = Join-Path $sdnExpPath SDNExpress.ps1
    return $sdnexpress
}

function Get-RestoreReplayScriptPath {
    
    param (
        [parameter(Mandatory = $false)][switch] $SkipConfigPath
    )

    if (-not $($SkipConfigPath.IsPresent)) {
        $infraconfig = Get-DeploymentConfig
        $restoreReplayScriptPath = $infraconfig.restoreReplayScriptPath

        if (-not [String]::IsNullOrEmpty($restoreReplayScriptPath)) {
            $restoreReplayScript = Join-Path $restoreReplayScriptPath RestoreReplay.ps1
            if ($(Test-Path $restoreReplayScript)) {
                return $restoreReplayScriptPath
            }
        }
    }

    $restoreReplayScriptPath = Join-Path $PSScriptRoot "..\BCDR"
    $restoreReplayScript = Join-Path $restoreReplayScriptPath RestoreReplay.ps1
    if ($(Test-Path $restoreReplayScript)) {
        return $restoreReplayScriptPath
    }

    $script = Get-InstalledScript RestoreReplay -ErrorAction SilentlyContinue

    if ($null -ne $script) {
        return $script.InstalledLocation
    }

    return $null
}

function Get-RestoreReplayScript {
    $restoreReplayScriptPath = Get-RestoreReplayScriptPath
    $restoreReplay = Join-Path $restoreReplayScriptPath RestoreReplay.ps1
    return $restoreReplay
}

function Get-DefaultNetworkControllerPsModulePath {
    return Join-Path $env:SystemRoot "system32\WindowsPowerShell\v1.0\Modules\NetworkControllerFc"
}
function Get-DefaultNetworkControllerPackageLocation {
    return (Join-Path $env:SystemRoot "NetworkController")
}

function Get-DefaultNetworkControllerDBLocation {
    $csv = Get-CSV

    if ($csv -ne $null) {
        return (Join-Path $csv "FCNCDB")
    }

    return (Join-Path $env:SystemDrive "FCNCDB")
}

function Set-AddressRandmoizerSeed {
    param(
        [parameter(Mandatory = $true)][int] $seed
    )

    $internalConfig = Get-TurnKeySdnInternalConfig -configType state
    $internalConfig.randomizerSeed = $seed
    Set-TurnKeySdnInternalConfig -configType state -config $internalConfig
}

function Get-AddressRandmoizerSeed {
    $internalConfig = Get-TurnKeySdnInternalConfig -configType state
    if (-not [String]::IsNullOrEmpty($internalConfig.randomizerSeed)) {
        return [int]$internalConfig.randomizerSeed
    }

    $curhost = (hostname)
    $hostIndex = $curhost.Substring($($curhost.Length - 2))
    $result = 0

    if (-not [int]::TryParse($hostIndex, [ref]$result)) {
        $result = Get-Random -Minimum 1 -Maximum 60
    }

    return $result
}

function Get-RandomizedIPv4Address {
    param(
        $address,
        $randomizer
    )

    $addresses = $address.Split(".")
    $addresses[1] = ([int]$addresses[1] + $randomizer) % 255
    return $addresses -join '.'
}

function Update-IPv4Address {
    param(
        $Address
    )

    $depConfig = Get-DeploymentConfig

    if (-not $depConfig.randomizeAddresses) {
        return $Address
    }

    $randomizer = Get-AddressRandmoizerSeed
    $addr = Get-RandomizedIPv4Address -address $Address -randomizer $randomizer
    return $addr
}

function Update-LoadbalancerFrontEndIPAddress {
    param(
        $loadbalancer
    )

    $loadbalancer.properties.frontendIPConfigurations | ForEach-Object {
        $frontendIPProp = $_.properties
        if(-not [String]::IsNullOrEmpty($frontendIPProp.privateIPAddress)) {

            $subnetInfo = $frontendIPProp.subnet.resourceRef  -split '/'
            # No need to randomize ILB Vip, as it won't be configured on the Mux external interface (BgpLessMux)
            if($subnetInfo[1] -eq "virtualNetworks") {
                continue;
            }
            
            $frontendIPProp.privateIPAddress = Update-IPv4Address -Address $frontendIPProp.privateIPAddress
            # Randomizing the subnet ref for PublicVIP lnet
            if($subnetInfo[2] -eq "PublicVIP") {
                $subnetInfo[4] = Update-IPv4Address -Address $subnetInfo[4]
                $frontendIPProp.subnet.resourceRef = $subnetInfo -join '/'
            }
        }
    }

    return $loadbalancer
}


function Update-LogicalNetworkAddresses {
    param(
        $network
    )
    $depConfig = Get-DeploymentConfig

    if (-not $depConfig.randomizeAddresses) {
        return $network
    }

    $isOneNode = $depConfig.hyperVHosts.Count -eq 1
    $randomizer = Get-AddressRandmoizerSeed
    $network.properties.subnets | ForEach-Object {
        $subnetProp = $_.properties
        $subnetProp.addressPrefix = Get-RandomizedIPv4Address -address $subnetProp.addressPrefix -randomizer $randomizer

        $newGateways = @()
        $subnetProp.defaultGateways | ForEach-Object {
            $newGateways += Get-RandomizedIPv4Address -address $_ -randomizer $randomizer
        }

        $subnetProp.defaultGateways = $newGateways

        $subnetProp.ipPools | Foreach-Object {
            $poolProp = $_.Properties
            $poolProp.startIpAddress = Get-RandomizedIPv4Address -address $poolProp.startIpAddress -randomizer $randomizer
            $poolProp.endIpAddress = Get-RandomizedIPv4Address -address $poolProp.endIpAddress -randomizer $randomizer
        }

        if ($isOneNode -and (-not ([string]::IsNullOrEmpty($subnetProp.vlanID)) -and ($subnetProp.vlanID -ne 0))) {
            $subnetProp.vlanID = $([int]$subnetProp.vlanID) + $randomizer
        }
    }
    return $network
}

function Set-TurnKeySdnInternalConfig {

    param(
        [ValidateSet("workloadcredential","credential", "state")]
        [parameter(Mandatory = $true)][string] $configType,
        [parameter(Mandatory = $true)] $config
    )

    $configFile = Join-Path (Get-StorePath) $script:CMap[$configType]
    $value = $(ConvertTo-Json $config -Depth 10)
    Set-Content -Path $configFile -Value $value -Encoding UTF8
}

function Get-TurnKeySdnInternalConfig {

    param(
        [ValidateSet("workloadcredential","credential", "state")]
        [parameter(Mandatory = $true)][string] $configType
    )

    $configFile = Join-Path (Get-StorePath) $script:CMap[$configType]
    return $(Get-Config $configFile)
}

function Test-TurnKeySdnStateConfigExist {   
    $configFile = Get-StateFileWithoutInit
    return $(Test-Path $configFile)
}

function Get-TurnKeySdnCred {

    $configFile = Join-Path (Get-StorePath) $script:CMap["credential"]
    try {
        $c = Get-Config $configFile
    } catch {
    }
    
    if ([String]::IsNullOrEmpty($c.username) -or [String]::IsNullOREmpty($c.password)) {
        Write-TraceLog "Get-TurnKeySdnCred: Failed to get credentials, defaulting to empty cred"    
        return [pscredential]::Empty
    }

    $cred = [pscredential]::new($c.username, $($c.password | ConvertTo-SecureString -ErrorAction Stop))
    return $cred
}
function Get-TurnKeySdnWorkloadVmCred {
    
    $configFile = Join-Path (Get-StorePath) $script:CMap["workloadcredential"]
    try {
        $c = Get-Config $configFile
    } catch {
    }
    
    if([string]::IsNullOrEmpty($c.username) -or [string]::IsNullOrEmpty($c.password)) {
        Write-TraceLog "Get-TurnKeySdnWorkloadVmCred: Failed to get credentials, defaulting to $Env:TURNKEY_WORKLOAD_USERNAME cred"
        $vmUserName = $Env:TURNKEY_WORKLOAD_USERNAME
        $vmUserPassword = $Env:TURNKEY_WORKLOAD_PASSWORD
        return [pscredential]::new($vmUserName, $($vmUserPassword | ConvertTo-SecureString -AsPlainText -Force))
    } else {
        $vmUserName = $c.username
        $vmUserPassword = $c.password
    }
    $cred = [pscredential]::new($vmUserName, $($vmUserPassword | ConvertTo-SecureString -ErrorAction Stop))
    return $cred
}


function Get-Config {
    param(
        [parameter(Mandatory = $true)][string] $file
    )

    Test-FileExist -path $file
    $config = Get-Content $file -ErrorAction Stop | ConvertFrom-Json
    return $config
}

function Get-GreVipLogicalNetworkConfig {
    param(
        [Parameter(Mandatory = $false)][bool] $RandomizeAddress = $true
    )

    $greNetworkFile = Join-Path (Get-InternalDeploymentConfigPath) $script:CMap["greNetworkFile"]
    $network = Get-Config $greNetworkFile
    if ($RandomizeAddress) {
        $network = Update-LogicalNetworkAddresses $network
    }
    return $network
}

function Set-GreVipNetworkConfig {
    param(
        [parameter(Mandatory = $true)][PSCustomObject]$Network
    )

    $greNetworkFile = Join-Path (Get-InternalDeploymentConfigPath) $script:CMap["greNetworkFile"]
    $Network | ConvertTo-Json -Depth 100 | Out-File $greNetworkFile -Force
}

function Get-HnvPaNetworkConfig {
    param(
        [Parameter(Mandatory = $false)][bool] $RandomizeAddress = $true
    )

    $hnvpaNetworkFile = Join-Path (Get-InternalDeploymentConfigPath) $script:CMap["hnvpaNetworkFile"]
    $hnvPaNetwork = Get-Config $hnvpaNetworkFile
    if ($RandomizeAddress) {
        $hnvPaNetwork = Update-LogicalNetworkAddresses $hnvPaNetwork
    }
    return $hnvPaNetwork
}

function Set-HnvPaNetworkConfig {
    param(
        [parameter(Mandatory = $true)][PSCustomObject]$Network
    )
    $hnvpaNetworkFile = Join-Path (Get-InternalDeploymentConfigPath) $script:CMap["hnvpaNetworkFile"]
    $Network | ConvertTo-Json -Depth 100 | Out-File $hnvpaNetworkFile -Force
}

function Get-MgmtNetworkConfig {
    param(
        [Parameter(Mandatory = $false)][bool] $RandomizeAddress = $true
    )
    $mgmtNetworkFile = Join-Path (Get-InternalDeploymentConfigPath) $script:CMap["mgmtNetworkFile"]
    $mgmtNetwork = Get-Config $mgmtNetworkFile
    if ($RandomizeAddress) {
        $mgmtNetwork = Update-LogicalNetworkAddresses $mgmtNetwork
    }
    return $mgmtNetwork
}
function Set-MgmtNetworkConfig {
    param(
        [parameter(Mandatory = $true)][PSCustomObject]$Network
    )

    $mgmtNetworkFile = Join-Path (Get-InternalDeploymentConfigPath) $script:CMap["mgmtNetworkFile"]
    $Network | ConvertTo-Json -Depth 100 | Out-File $mgmtNetworkFile -Force
}
function Get-PublicVipNetworkConfig {
    param(
        [Parameter(Mandatory = $false)][bool] $RandomizeAddress = $true
    )
    
    $publicVipNetworkFile = Join-Path (Get-InternalDeploymentConfigPath) $script:CMap["publicVipNetworkFile"]   
    $publicVipNetwork = Get-Config $publicVipNetworkFile
    if ($RandomizeAddress) {
        $publicVipNetwork = Update-LogicalNetworkAddresses $publicVipNetwork
    }
    return $publicVipNetwork
}

function Set-PublicVipNetworkConfig {
    param(
        [parameter(Mandatory = $true)][PSCustomObject]$Network
    )

    $publicVipNetworkFile = Join-Path (Get-InternalDeploymentConfigPath) $script:CMap["publicVipNetworkFile"]   
    $Network | ConvertTo-Json -Depth 100 | Out-File $publicVipNetworkFile -Force
}

function Get-PrivateVipNetworkConfig {
    param(
        [Parameter(Mandatory = $false)][bool] $RandomizeAddress = $true
    )

    $privateVipNetworkFile = Join-Path (Get-InternalDeploymentConfigPath) $script:CMap["privateVipNetworkFile"]
    $privateVipNetwork = Get-Config $privateVipNetworkFile
    if ($RandomizeAddress) {
        $privateVipNetwork = Update-LogicalNetworkAddresses $privateVipNetwork
    }
    return $privateVipNetwork
}

function Set-PrivateVipNetworkConfig {
    param(
        [parameter(Mandatory = $true)][PSCustomObject]$Network
    )

    $privateVipNetworkFile = Join-Path (Get-InternalDeploymentConfigPath) $script:CMap["privateVipNetworkFile"]   
    $Network | ConvertTo-Json -Depth 100 | Out-File $privateVipNetworkFile -Force
}

function Get-DeploymentConfig {
    $config = Get-Config $(Get-DeploymentFile)
    
    # config upgrade for productkey
    $p = $config | Get-Member -Name productKey -ErrorAction SilentlyContinue
    if ($null -eq $p) {
        $config | add-member -NotePropertyName productKey -NotePropertyValue ""
    }
    
    # fix up booleans strings in the config file
    $config.useRRASRouter = Parse-TurnkeyBoolean $config.useRRASRouter
    $config.randomizeAddresses = Parse-TurnkeyBoolean $config.randomizeAddresses
    $config.bypassTORForLBDataPath = Parse-TurnkeyBoolean $config.bypassTORForLBDataPath

    # config upgrade for preferTestReadyVHD
    $preferTestReadyVHDKey = $config | Get-Member -Name preferTestReadyVHD -ErrorAction SilentlyContinue

    if ($null -eq $preferTestReadyVHDKey) {
        $config | add-member -NotePropertyName preferTestReadyVHD -NotePropertyValue $false
    } else {
        $config.preferTestReadyVHD = Parse-TurnkeyBoolean $config.preferTestReadyVHD
    }

    return $config
}

function Get-TorVmConfig {
    $config = Get-DeploymentConfig
    return $config.torVmConfig
}

function Set-TorVmConfig {
    param(
        [parameter(Mandatory = $true)][PSCustomObject]$Config
    )

    $depConfig = Get-DeploymentConfig
    $depConfig.torVmConfig = $Config
    Set-DeploymentConfig -deploymentConfig $depConfig
}

function Update-MacAddress {
    param($mac)

    $net = Get-MgmtNetworkConfig
    # Generate a mac address based on the managment network.
    $prefixElements = $net.properties.subnets[0].properties.addressPrefix.Split("/")
    $prefixLen = [int]$prefixElements[1]
    $ip = $prefixElements[0]
    if ($prefixLen -gt 24) {
         $secLast_hex = "{0:X2}" -f [int]($ip.Split('.')[-2])
         $last_hex = "{0:X2}" -f [int]($ip.Split('.')[-1])
    } elseif ($prefixLen -gt 8 -and $prefixLen -le 24) {
         $secLast_hex = "{0:X2}" -f [int]($ip.Split('.')[-3])
         $last_hex = "{0:X2}" -f [int]($ip.Split('.')[-2])
    } else {
         $secLast_hex = "{0:X2}" -f [int]($ip.Split('.')[-4])
         $last_hex = "{0:X2}" -f [int]($ip.Split('.')[-3])
    }

    $macEle = $mac.Split("-")
    
    $macEle[3] = $secLast_hex
    $macEle[4] = $last_hex
    $result = $macEle -join '-'

    return $result
}

function Get-DefaultMacPoolConfig {
    $configFileName = Join-Path (Get-InternalDeploymentConfigPath) $script:CMap["macpoolFile"]
    $config = Get-Config $configFileName

    # Always randomize mac addresses, if needed expose a separate flag to disable.
    $config.properties.startMacAddress = Update-MacAddress -mac $config.properties.startMacAddress
    $config.properties.endMacAddress = Update-MacAddress -mac $config.properties.endMacAddress

    return $config
}

function Set-MacPoolConfig {
    param(
        [parameter(Mandatory = $true)][PSCustomObject]$Config
    )

    $configFileName = Join-Path (Get-InternalDeploymentConfigPath) $script:CMap["macpoolFile"]
    $Config | ConvertTo-Json -Depth 100 | Out-File $configFileName -Force
}

function Get-SdnConfig {
    $configFileName = Join-Path (Get-InternalDeploymentConfigPath) $script:CMap["sdnConfigFile"]
    $config = Get-Config $configFileName
    return $config
}

function Test-ValidDepId {
    param(
        [parameter(Mandatory = $true)][string] $id
    )

    if ($id.Length -gt 9) {
        Write-TraceLog "Test-ValidDepId failed, id $id must be less than 9 characters"
        return $false
    }

    $names = @("NC-$id", "$id-$(Get-RouterVMSuffix)", "$id-$(Get-NCVMSuffix)0", "$id-$(Get-MUXVMSuffix)0", "$id-$(Get-GWVMSuffix)0")
    foreach($name in $names) {
        $result = (Resolve-DnsName $name -ErrorAction SilentlyContinue)

        if ($result -ne $null) {
            Write-TraceLog "Test-ValidDepId failed, another deployment with id $id already exists"
            return $false
        }
    }
   
    Write-TraceLog "Test-ValidDepId $id passed all validations"
    return $true
}
function Get-NewDepId {
    while($true) {
        $id = ((New-Guid).guid).split("-")[0]
        # Skip if the name is already in use
        if ($(Test-ValidDepId -id $id)) {
            return $id
        }        
    }
}

function Set-DeploymentId {
    param(
        [parameter(Mandatory = $false)][string] $id
    )

    $internalConfig = Get-TurnKeySdnInternalConfig -configType state
    $internalConfig.depId = $id

    if ([String]::IsNullOrEmpty($internalConfig.torId)) {
        $internalConfig.torId = $id
    }

    Set-TurnKeySdnInternalConfig -configType state -config $internalConfig
}

function Get-TurnKeySdnDeploymentId {

    $configFileName = Join-Path (Get-StorePath) $script:CMap["state"]
    $config = Get-Config $configFileName
    return $config.depId
}

function Get-TorId {

    $configFileName = Join-Path (Get-StorePath) $script:CMap["state"]
    $config = Get-Config $configFileName
    return $config.torId
}

function Get-StateFileWithoutInit {
    $csv = Get-CSV

    if ($csv -ne $null) {
        $installPath = Join-Path $csv "TurnKeySdn"
    }
    else {
        $installPath = Join-Path $Env:SystemDrive "TurnKeySdn"
    }

    $storePath = Join-Path $installPath ".store"
    $configFileName = Join-Path $storePath $script:CMap["state"]

    return $configFileName
}

function Remove-TurnKeySdnStore {

    param (
        [parameter(Mandatory = $false)][switch] $SkipStore
    )

    try {
        $depConfig = Get-DeploymentConfig
        $deployFolder = $depConfig.vmLocation

        if (-not [string]::IsNullOrEmpty($deployFolder)) {
            Write-TraceLog "Remove-TurnKeySdnStore removing deployment folder $deployFolder"
            Remove-Item $depConfig.vmLocation -Recurse -Force -ErrorAction SilentlyContinue
        }
    }
    catch {
        Write-TraceLog "Remove-TurnKeySdnStore: Failed to remove vmLocation $deployFolder, error $_"
    }

    try {
        $workloadConfig = Get-TurnKeySdnWorkloadConfig
        $workloadDeployFolder = $workloadConfig.deploymentpath

        if (-not [String]::IsNullOrEmpty($workloadDeployFolder)) {
            Write-TraceLog "Remove-TurnKeySdnStore removing workload folder $workloadDeployFolder"
            Remove-Item $workloadDeployFolder -Recurse -Force -ErrorAction SilentlyContinue
        }
    }
    catch {
        Write-TraceLog "Remove-TurnKeySdnStore: Failed to remove deploymentpath $workloadDeployFolder, error $_"
    }

    if (Test-IsInitialized) {
        try {
            $inernalWorkConfig = Get-InternalWorkloadConfigPath
            
            if (-not [String]::IsNullOrEmpty($inernalWorkConfig)) {
                Write-TraceLog "Remove-TurnKeySdnStore removing workload config folder $inernalWorkConfig"
                Remove-Item $inernalWorkConfig -Recurse -Force -ErrorAction SilentlyContinue
            }
        }
        catch {
            Write-TraceLog "Remove-TurnKeySdnStore: Failed to remove deploymentpath $inernalWorkConfig, error $_"
        }


        try {
            $inernalDepConfig = Get-InternalDeploymentConfigPath
            
            if (-not [String]::IsNullOrEmpty($inernalDepConfig)) {
                Write-TraceLog "Remove-TurnKeySdnStore removing deployment config folder $inernalDepConfig"
                Remove-Item $inernalDepConfig -Recurse -Force -ErrorAction SilentlyContinue
            }
        }
        catch {
            Write-TraceLog "Remove-TurnKeySdnStore: Failed to remove deploymentpath $inernalDepConfig, error $_"
        }
    }

    $configPresent = Test-TurnKeySdnStateConfigExist
    if ($($SkipStore.IsPresent) -and $configPresent) {
        Write-TraceLog "Remove-TurnKeySdnStore: Resetting install states"
        $state = Get-StateInternal
        $state.depId = ""
        $state.initialized = $false
        $state.installState = $script:InstallStateNone
        $state.mgmtIPOffset = "0"
        Set-TurnKeySdnInternalConfig -configType state -config $state
        Reset-Credential
        Write-TraceLog "Remove-TurnKeySdnStore: Skipping store path removal"
        return
    }

    try {
        $storePath = Get-TurnKeySdnPath

        if (-not [String]::IsNullOrEmpty($storePath)) {
            Write-TraceLog "Remove-TurnKeySdnStore removing storePath $storePath"
            Remove-Item $storePath -Recurse -Force -ErrorAction SilentlyContinue
        }
    }
    catch {
        Write-TraceLog "Remove-TurnKeySdnStore: Failed to remove storePath $storePath, error $_"
    }
}

function Get-TurnKeySdnRestEndpoint {
    $sdnConfig = Get-SdnConfig

    $endpoint = $sdnConfig.networkController.restName

    if (-not [String]::IsNullOrEmpty($endpoint)) {
        return $endpoint
    }

    if ([String]::IsNullOrEmpty($sdnConfig.networkController.restIpAddress)) {
        throw "Invalid sdn configuration, both restname and IP are empty"
    }

    return $sdnConfig.networkController.restIpAddress.split("/")[0]
}
function Get-TurnKeySdnNCRuntime() {
    $sdnConfig = Get-SdnConfig
    return $sdnConfig.networkController.runtime
}

function Set-TurnKeySdnConfig {
    param(
        [parameter(Mandatory = $true)][PSCustomObject]$sdnConfig
    )

    $configString = $sdnConfig | ConvertTo-Json -Depth 10
    $configFile = Join-Path (Get-InternalDeploymentConfigPath) $script:CMap["sdnConfigFile"]
    Set-Content -Path $configFile -Value $configString -Encoding UTF8
}

function Set-DeploymentConfig {
    param(
        [parameter(Mandatory = $true)][PSCustomObject]$deploymentConfig
    )    

    $configString = $deploymentConfig | ConvertTo-Json -Depth 10
    Set-Content -Path $(Get-DeploymentFile) -Value $configString -Encoding UTF8
}

function LoadSdnExpressConfig {
    $sdnexpress = Import-LocalizedData `
        -BaseDirectory $script:CMap["sdnExpressConfigPath"] `
        -FileName $script:CMap["sdnExpressTemplateFile"]

    return $sdnexpress
}
function Get-SdnExpressGeneratedFilePath {
    # returns the path for a rendered copy of sdnexpress
    return Join-Path -Path $script:CMap["sdnExpressConfigPath"] -ChildPath $script:CMap["sdnExpressGeneratedFile"]
}

function Get-WorkloadConfigPath {
    param(
        [ValidateSet("LoadBalancer", "LoadBalancer_Static", "VNET", "VNET_Static", "LogicalNetwork", "Gateway", "Gateway_Static", "None", "HLK", "MultiVlanVip")]
        [Parameter(Mandatory = $false)] $WorkloadType,
        [Parameter(Mandatory = $false)] $WorkloadFolder
    )

    if ($WorkloadType -eq "None" -or [String]::IsNullOrEmpty($WorkloadType)) {
        $WorkloadType = "LoadBalancer"
    }

    if ([String]::IsNullOrEmpty($WorkloadFolder)) {
        $WorkloadFolder = $WorkloadType
    }

    $path = Join-Path(Get-InternalWorkloadConfigPath) $WorkloadFolder

    if (-not (Test-Path $path)) {
        throw "Workload $WorkloadType not found at $path"
    }

    return $path
}
function Get-TurnKeySdnWorkloadConfig {
    $workloadConfigFile = Join-Path (Get-InternalWorkloadConfigPath) $script:CMap["workload"]
    $workloadConfig = Get-Config $workloadConfigFile
    return $workloadConfig
}
function Get-SdnWorkloadDeploymentPath {
    $workloadConfig = Get-TurnKeySdnWorkloadConfig

    if (-not [String]::isnullorempty($workloadConfig.deploymentpath)) {
        return $workloadConfig.deploymentpath
    }
}

function Set-TurnKeySdnWorkloadConfig {
    param(
        [parameter(Mandatory = $true)][PSCustomObject]$config
    )    

    $configString = $config | ConvertTo-Json -Depth 10
    $configFile = Join-Path (Get-InternalWorkloadConfigPath) $script:CMap["workload"]
    Set-Content -Path $configFile -Value $configString -Encoding UTF8
}

function Get-SdnWorkloadVirtualGateways {
    param(
        [Parameter(Mandatory = $true)] $WorkloadConfigPath
    )

    $jsonPath = Join-Path $workloadConfigPath "jsons\virtualgateways"

    if (-not $(Test-Path $jsonPath)) {
        return $null
    }

    Get-ChildItem $jsonPath
}
function Get-SdnWorkloadLogicalNetworks {
    param(
        [Parameter(Mandatory = $true)] $WorkloadConfigPath
    )

    $jsonPath = Join-Path $workloadConfigPath "jsons\logicalnetworks"

    if (-not $(Test-Path $jsonPath)) {
        return $null
    }

    Get-ChildItem $jsonPath
}

function Get-SdnWorkloadNetworkInterfaces {
    param(
        [Parameter(Mandatory = $true)] $WorkloadConfigPath
    )

    $nicJsonPath = Join-Path $workloadConfigPath "jsons\networkinterfaces"

    if (-not $(Test-Path $nicJsonPath)) {
        return $null
    }

    Get-ChildItem $nicJsonPath
}


function Get-SdnWorkloadLoadbalancers {
    param(
        [Parameter(Mandatory=$true)] $WorkloadConfigPath
    )

    $lbJsonPath = Join-Path $workloadConfigPath "jsons\loadbalancers"

    if (-not $(Test-Path $lbJsonPath)) {
        return $null
    }

    Get-ChildItem $lbJsonPath
}

function Get-TurnKeySdnHyperVHosts {
    $depConfig = Get-DeploymentConfig

    if ($depConfig.hyperVHosts.Count -gt 0) {
        return $depConfig.hyperVHosts
    }

    if (Test-IsCluster) {
        $sdnConfig = get-sdnconfig
        Write-TraceLog "Get-TurnKeySdnHyperVHosts: No hosts found, defaulting to clusternodes"
        if ($sdnConfig.networkController.FC.siteAware) {
            $infraconfig.hyperVHosts = @(Get-NodesInSiteFaultDomain)
        }
        else {
            $hypervHosts = (get-cluster | get-clusternode).Name
        }
    }
    else {
        Write-TraceLog "Get-TurnKeySdnHyperVHosts: No hosts found, defaulting to local host"
        $hypervHosts = @($(hostname))
    }

    return $hypervHosts
}

function Get-SdnSwitchName {
    $depConfig = Get-DeploymentConfig
    return $depConfig.sdnSwitchName
}

function Initialize-TurnKeySdnDeploymentId {

    $config = Get-TurnKeySdnInternalConfig -configType state
    $updated = $false

    if ([String]::IsNullOrEmpty($config.depId)) {
        $config.depId = Get-NewDepId
        $updated = $true
    }

    if ([String]::IsNullOrEmpty($config.torId)) {
        $config.torId = $config.depId
        $updated = $true
    }

    if ([String]::IsNullOrEmpty($config.randomizerSeed)) {
        $config.randomizerSeed = Get-AddressRandmoizerSeed
        $updated = $true
    }

    if ($updated) {       
        Set-TurnKeySdnInternalConfig -configType state -config $config
    }
}


function Initialize-Store {

    Initialize-StorePath
    
    $script:CMap["deploymentConfigPath"] = Join-Path $script:CMap["turnKeySdnPath"] "DeploymentConfig"
    $script:CMap["workloadConfigPath"] = Join-Path $script:CMap["turnKeySdnPath"] "WorkloadConfig"

    $internalConfigPath = $script:CMap["deploymentConfigPath"]
    $internalWorkloadConfigPath = $script:CMap["workloadConfigPath"]

    if (-not (Test-Path $internalConfigPath)) {
        New-Item $internalConfigPath -ItemType Directory -ErrorAction Stop | Out-Null
    }

    if (-not (Test-Path $internalWorkloadConfigPath)) {
        New-Item $internalWorkloadConfigPath -ItemType Directory -ErrorAction Stop | Out-Null
    }

    $userConfigPath = $script:CMap["userConfigPath"]
    Write-TraceLog "Copying user config from $userConfigPath to $internalConfigPath"

    robocopy $userConfigPath $script:CMap["deploymentConfigPath"] /E /XO /NC /NS /NP /NFL /NDL /NJH /NJS

    $userWorkloadConfigPath = $script:CMap["userWorkloadConfigPath"]
    Write-TraceLog "Copying user workload config from $userWorkloadConfigPath to $internalWorkloadConfigPath"

    robocopy $userWorkloadConfigPath $internalWorkloadConfigPath /E /XO /NC /NS /NP /NFL /NDL /NJH /NJS

    $vhdStore = Get-VhdStore

    if (-not (Test-Path $vhdStore)) {
        New-Item $vhdStore -ItemType Directory -ErrorAction Stop | Out-Null
    }

    $credFile = Join-Path (Get-StorePath) $script:CMap["credential"]
    if (-not $(Test-Path $credFile)) {
        Reset-Credential
    }

    $stateFile = Join-Path (Get-StorePath) $script:CMap["state"]
    if (-not $(Test-Path $stateFile)) {
        $state = @{}
        $state["depId"] = ""
        $state["torId"] = ""
        $state["randomizerSeed"] = ""
        $state["initialized"] = $false
        $state["installState"] = $script:InstallStateNone
        $state["mgmtIPOffset"] = "0"
        Set-TurnKeySdnInternalConfig -configType state -config $state
    }

    Initialize-TurnKeySdnDeploymentId
}

function Get-DeploymentFile {
    return Join-Path (Get-InternalDeploymentConfigPath) $script:CMap["deploymentFile"]
}

function Get-MgmtNicName {
    return $script:MgmtHostNicName
}

function Get-DefaultWorkloadVhdShare {
    return $script:DefaultTestVhdShare
}

function Get-DefaultWorkloadVhdFile {
    return $script:DefaultTestVhdFile
}

function Get-StateInternal {
    $stateFile = Get-StateFileWithoutInit
    $config = Get-Config $stateFile
    return $config
}

function Set-InstallState {
    param(
        [ValidateSet("installed", "installFailed", "installing", "none")]
        [parameter(Mandatory = $true)][string] $state
    )

    $config = Get-StateInternal
    $config.installState = $state
    Set-TurnKeySdnInternalConfig -configType state -config $config
}

function Test-IsInstalled {
    try {
        $config = Get-StateInternal
    }
    catch {
        return $false
    }
    return $config.installState -ieq "installed"
}

function Test-IsInitialized {

    try {
        $config = Get-StateInternal
    }
    catch {
        return $false
    }

    return $config.initialized
}

function Set-Initialized {
    $config = Get-TurnKeySdnInternalConfig -configType state
    $config.initialized = $true
    Set-TurnKeySdnInternalConfig -configType state -config $config
}

function Get-NextManagementIPOffset {

    $config = Get-StateInternal
    [int]$offset = $config.mgmtIPOffset
    $config.mgmtIPOffset = $offset + 1
    Set-TurnKeySdnInternalConfig -configType state -config $config
    return $offset
}

function Initialize-ManagementIPOffset {
    $config = Get-StateInternal
    $config.mgmtIPOffset = 0
    Set-TurnKeySdnInternalConfig -configType state -config $config
}

function Get-MsftCorpRoutes {
    return $script:MSFTCorpRoutes
}

function Test-RRASRouterEnabled {
    $depConfig = Get-DeploymentConfig
    return $depConfig.useRRASRouter
}

function Get-DefaultInternetSwitchName {
    return $script:InternetSwitchDefaultName
}

function Get-DefaultSdnSwitchName {
    return $script:SdnSwitchDefaultName
}

function Get-RouterVMSuffix {
    "-TOR"
}

function Get-NCVMSuffix {
    "-NC"
}

function Get-MUXVMSuffix {
    "-MUX"
}

function Get-GWVMSuffix {
    "-GW"
}

function Get-DefaultCtsTrafficFolder {
    if (-not (Test-IsCluster)) {
        return "$env:SystemDrive\Tools" 
    }

    $csvPath = Get-CSV
    return $(Join-Path -Path $csvPath -ChildPath "WorkloadTools")
}

function Get-DefaultCtsTrafficFile {
    return $(Join-Path -Path (Get-DefaultCtsTrafficFolder) -ChildPath "CtsTraffic.exe")
}

function Get-CtsTrafficGitHubUri {
    return "https://github.com/microsoft/ctsTraffic/raw/master/Releases/2.0.3.2/x64/ctsTraffic.exe"
}

function Copy-OrGetCtsTraffficExe {
    param(
        [parameter(Mandatory = $false)][string] $SourceFolder
    )

    
    $defaultCtsTrafficFolder = Get-DefaultCtsTrafficFolder

    if (-not (Test-Path $defaultCtsTrafficFolder)) {
        New-item -Path $defaultCtsTrafficFolder -ItemType Directory -Force -ErrorAction Stop | Out-Null
    }

    $ctsTraffic = Get-DefaultCtsTrafficFile

    $source = Join-Path $SourceFolder "CtsTraffic.exe"

    if (-not $(Test-Path $source) -and -not $(Test-Path $ctsTraffic)) {
        Write-TraceLog "Copy-OrGetCtsTraffficExe: Ctstraffic not found at $source, downloading from github and copying to $ctsTraffic"
        Invoke-WebRequest   $(Get-CtsTrafficGitHubUri) -outfile $ctsTraffic
        return
    }

    if ($(Test-Path $source)) {
        Write-TraceLog "Copy-OrGetCtsTraffficExe: Ctstraffic found locally at $source, copying to $ctsTraffic"
        Copy-Item -Path $source -Destination $ctsTraffic -Force 
        return
    }   

    Write-TraceLog "Copy-OrGetCtsTraffficExe: Using existing ctstraffic from $ctsTraffic"
}

function Reset-Credential {
    $cred = @{}
    $cred["username"] = ""
    $cred["password"] = ""
    Set-TurnKeySdnInternalConfig -configType credential -config $cred
}
# SIG # Begin signature block
# MIIoKgYJKoZIhvcNAQcCoIIoGzCCKBcCAQExDzANBglghkgBZQMEAgEFADB5Bgor
# BgEEAYI3AgEEoGswaTA0BgorBgEEAYI3AgEeMCYCAwEAAAQQH8w7YFlLCE63JNLG
# KX7zUQIBAAIBAAIBAAIBAAIBADAxMA0GCWCGSAFlAwQCAQUABCBOlLD++Erg57HK
# TWbMGdH8WAgoooT44mT5FYclOj9fyqCCDXYwggX0MIID3KADAgECAhMzAAAEBGx0
# Bv9XKydyAAAAAAQEMA0GCSqGSIb3DQEBCwUAMH4xCzAJBgNVBAYTAlVTMRMwEQYD
# VQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNy
# b3NvZnQgQ29ycG9yYXRpb24xKDAmBgNVBAMTH01pY3Jvc29mdCBDb2RlIFNpZ25p
# bmcgUENBIDIwMTEwHhcNMjQwOTEyMjAxMTE0WhcNMjUwOTExMjAxMTE0WjB0MQsw
# CQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9u
# ZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMR4wHAYDVQQDExVNaWNy
# b3NvZnQgQ29ycG9yYXRpb24wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB
# AQC0KDfaY50MDqsEGdlIzDHBd6CqIMRQWW9Af1LHDDTuFjfDsvna0nEuDSYJmNyz
# NB10jpbg0lhvkT1AzfX2TLITSXwS8D+mBzGCWMM/wTpciWBV/pbjSazbzoKvRrNo
# DV/u9omOM2Eawyo5JJJdNkM2d8qzkQ0bRuRd4HarmGunSouyb9NY7egWN5E5lUc3
# a2AROzAdHdYpObpCOdeAY2P5XqtJkk79aROpzw16wCjdSn8qMzCBzR7rvH2WVkvF
# HLIxZQET1yhPb6lRmpgBQNnzidHV2Ocxjc8wNiIDzgbDkmlx54QPfw7RwQi8p1fy
# 4byhBrTjv568x8NGv3gwb0RbAgMBAAGjggFzMIIBbzAfBgNVHSUEGDAWBgorBgEE
# AYI3TAgBBggrBgEFBQcDAzAdBgNVHQ4EFgQU8huhNbETDU+ZWllL4DNMPCijEU4w
# RQYDVR0RBD4wPKQ6MDgxHjAcBgNVBAsTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEW
# MBQGA1UEBRMNMjMwMDEyKzUwMjkyMzAfBgNVHSMEGDAWgBRIbmTlUAXTgqoXNzci
# tW2oynUClTBUBgNVHR8ETTBLMEmgR6BFhkNodHRwOi8vd3d3Lm1pY3Jvc29mdC5j
# b20vcGtpb3BzL2NybC9NaWNDb2RTaWdQQ0EyMDExXzIwMTEtMDctMDguY3JsMGEG
# CCsGAQUFBwEBBFUwUzBRBggrBgEFBQcwAoZFaHR0cDovL3d3dy5taWNyb3NvZnQu
# Y29tL3BraW9wcy9jZXJ0cy9NaWNDb2RTaWdQQ0EyMDExXzIwMTEtMDctMDguY3J0
# MAwGA1UdEwEB/wQCMAAwDQYJKoZIhvcNAQELBQADggIBAIjmD9IpQVvfB1QehvpC
# Ge7QeTQkKQ7j3bmDMjwSqFL4ri6ae9IFTdpywn5smmtSIyKYDn3/nHtaEn0X1NBj
# L5oP0BjAy1sqxD+uy35B+V8wv5GrxhMDJP8l2QjLtH/UglSTIhLqyt8bUAqVfyfp
# h4COMRvwwjTvChtCnUXXACuCXYHWalOoc0OU2oGN+mPJIJJxaNQc1sjBsMbGIWv3
# cmgSHkCEmrMv7yaidpePt6V+yPMik+eXw3IfZ5eNOiNgL1rZzgSJfTnvUqiaEQ0X
# dG1HbkDv9fv6CTq6m4Ty3IzLiwGSXYxRIXTxT4TYs5VxHy2uFjFXWVSL0J2ARTYL
# E4Oyl1wXDF1PX4bxg1yDMfKPHcE1Ijic5lx1KdK1SkaEJdto4hd++05J9Bf9TAmi
# u6EK6C9Oe5vRadroJCK26uCUI4zIjL/qG7mswW+qT0CW0gnR9JHkXCWNbo8ccMk1
# sJatmRoSAifbgzaYbUz8+lv+IXy5GFuAmLnNbGjacB3IMGpa+lbFgih57/fIhamq
# 5VhxgaEmn/UjWyr+cPiAFWuTVIpfsOjbEAww75wURNM1Imp9NJKye1O24EspEHmb
# DmqCUcq7NqkOKIG4PVm3hDDED/WQpzJDkvu4FrIbvyTGVU01vKsg4UfcdiZ0fQ+/
# V0hf8yrtq9CkB8iIuk5bBxuPMIIHejCCBWKgAwIBAgIKYQ6Q0gAAAAAAAzANBgkq
# 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
# /Xmfwb1tbWrJUnMTDXpQzTGCGgowghoGAgEBMIGVMH4xCzAJBgNVBAYTAlVTMRMw
# EQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVN
# aWNyb3NvZnQgQ29ycG9yYXRpb24xKDAmBgNVBAMTH01pY3Jvc29mdCBDb2RlIFNp
# Z25pbmcgUENBIDIwMTECEzMAAAQEbHQG/1crJ3IAAAAABAQwDQYJYIZIAWUDBAIB
# BQCgga4wGQYJKoZIhvcNAQkDMQwGCisGAQQBgjcCAQQwHAYKKwYBBAGCNwIBCzEO
# MAwGCisGAQQBgjcCARUwLwYJKoZIhvcNAQkEMSIEIFCPogm1iFZ45CI5z7iXBHNp
# DKqOwJ7NpaVz+Lxm5hv6MEIGCisGAQQBgjcCAQwxNDAyoBSAEgBNAGkAYwByAG8A
# cwBvAGYAdKEagBhodHRwOi8vd3d3Lm1pY3Jvc29mdC5jb20wDQYJKoZIhvcNAQEB
# BQAEggEATaP8PLpMcHEvV0pcXUE2UXSwJ3haBQCk0MAsCsLbIVYGqpscb+jg/OFC
# 9ckWNMSTVcyOh8RQZy3ytwy4Ua5EahKifTbEoCrGjNVhkwjo7eII3tr2PG8vwKin
# in/CAuU13HBNZQwJFi2ywiybGfQ/5omlotDXrBCv9PB2khoYUX0scqbo7Xc1wTxT
# dfI/iI+AFEVrwCeNTk47dm9WU7GrtMLuAVRndtM7HbI3dCeGTy1Z+4D8TxqHgJ41
# XVgGFnMFBdhBINfbJlk3pp3262DejqMs6g3xSe8wiq62ab/CNE+4M8nBawFbiCFj
# XK/dpT2GCsHTsOr/UFrgxwfuOVjGnKGCF5QwgheQBgorBgEEAYI3AwMBMYIXgDCC
# F3wGCSqGSIb3DQEHAqCCF20wghdpAgEDMQ8wDQYJYIZIAWUDBAIBBQAwggFSBgsq
# hkiG9w0BCRABBKCCAUEEggE9MIIBOQIBAQYKKwYBBAGEWQoDATAxMA0GCWCGSAFl
# AwQCAQUABCC5E0k+mf8wQ4W/YOchjphkiB4dFyB4HXGLpkCa3WXyFwIGZ9xawvTs
# GBMyMDI1MDMyMTIxMjQ0OC45NTJaMASAAgH0oIHRpIHOMIHLMQswCQYDVQQGEwJV
# UzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UE
# ChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMSUwIwYDVQQLExxNaWNyb3NvZnQgQW1l
# cmljYSBPcGVyYXRpb25zMScwJQYDVQQLEx5uU2hpZWxkIFRTUyBFU046OTYwMC0w
# NUUwLUQ5NDcxJTAjBgNVBAMTHE1pY3Jvc29mdCBUaW1lLVN0YW1wIFNlcnZpY2Wg
# ghHqMIIHIDCCBQigAwIBAgITMwAAAgTY4A4HlzJYmAABAAACBDANBgkqhkiG9w0B
# AQsFADB8MQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UE
# BxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMSYwJAYD
# VQQDEx1NaWNyb3NvZnQgVGltZS1TdGFtcCBQQ0EgMjAxMDAeFw0yNTAxMzAxOTQy
# NDdaFw0yNjA0MjIxOTQyNDdaMIHLMQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2Fz
# aGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENv
# cnBvcmF0aW9uMSUwIwYDVQQLExxNaWNyb3NvZnQgQW1lcmljYSBPcGVyYXRpb25z
# MScwJQYDVQQLEx5uU2hpZWxkIFRTUyBFU046OTYwMC0wNUUwLUQ5NDcxJTAjBgNV
# BAMTHE1pY3Jvc29mdCBUaW1lLVN0YW1wIFNlcnZpY2UwggIiMA0GCSqGSIb3DQEB
# AQUAA4ICDwAwggIKAoICAQDw3Sbcee2d66vkWGTIXhfGqqgQGxQXTnq44XlUvNzF
# St7ELtO4B939jwZFX7DrRt/4fpzGNkFdGpc7EL5S86qKYv360eXjW+fIv1lAqDD3
# 1d/p8Ai9/AZz8M95zo0rDpK2csz9WAyR9FtUDx52VOs9qP3/pgpHvgUvD8s6/3KN
# ITzms8QC1tJ3TMw1cRn9CZgVIYzw2iD/ZvOW0sbF/DRdgM8UdtxjFIKTXTaI/bJh
# sQge3TwayKQ2j85RafFFVCR5/ChapkrBQWGwNFaPzpmYN46mPiOvUxriISC9nQ/G
# rDXUJWzLDmchrmr2baABJevvw31UYlTlLZY6zUmjkgaRfpozd+Glq9TY2E3Dglr6
# PtTEKgPu2hM6v8NiU5nTvxhDnxdmcf8UN7goeVlELXbOm7j8yw1xM9IyyQuUMWko
# rBaN/5r9g4lvYkMohRXEYB0tMaOPt0FmZmQMLBFpNRVnXBTa4haXvn1adKrvTz8V
# lfnHxkH6riA/h2AlqYWhv0YULsEcHnaDWgqA29ry+jH097MpJ/FHGHxk+d9kH2L5
# aJPpAYuNmMNPB7FDTPWAx7Apjr/J5MhUx0i07gV2brAZ9J9RHi+fMPbS+Qm4AonC
# 5iOTj+dKCttVRs+jKKuO63CLwqlljvnUCmuSavOX54IXOtKcFZkfDdOZ7cE4DioP
# 1QIDAQABo4IBSTCCAUUwHQYDVR0OBBYEFBp1dktAcGpW/Km6qm+vu4M1GaJfMB8G
# A1UdIwQYMBaAFJ+nFV0AXmJdg/Tl0mWnG1M1GelyMF8GA1UdHwRYMFYwVKBSoFCG
# Tmh0dHA6Ly93d3cubWljcm9zb2Z0LmNvbS9wa2lvcHMvY3JsL01pY3Jvc29mdCUy
# MFRpbWUtU3RhbXAlMjBQQ0ElMjAyMDEwKDEpLmNybDBsBggrBgEFBQcBAQRgMF4w
# XAYIKwYBBQUHMAKGUGh0dHA6Ly93d3cubWljcm9zb2Z0LmNvbS9wa2lvcHMvY2Vy
# dHMvTWljcm9zb2Z0JTIwVGltZS1TdGFtcCUyMFBDQSUyMDIwMTAoMSkuY3J0MAwG
# A1UdEwEB/wQCMAAwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwgwDgYDVR0PAQH/BAQD
# AgeAMA0GCSqGSIb3DQEBCwUAA4ICAQBecv6sRw2HTLMyUC1WJJ+FR+DgA9Jkv0lG
# sIt4y69CmOj8R63oFbhSmcdpakxqNbr8v9dyTb4RDyNqtohiiXbtrXmQK5X7y/Q+
# +F0zMotTtTpTPvG3eltyV/LvO15mrLoNQ7W4VH58aLt030tORxs8VnAQQF5BmQQM
# Oua+EQgH4f1F4uF6rl3EC17JBSJ0wjHSea/n0WYiHPR0qkz/NRAf8lSUUV0gbIMa
# wGIjn7+RKyCr+8l1xdNkK/F0UYuX3hG0nE+9Wc0L4A/enluUN7Pa9vOV6Vi3BOJS
# T0RY/ax7iZ45leM8kqCw7BFPcTIkWzxpjr2nCtirnkw7OBQ6FNgwIuAvYNTU7r60
# W421YFOL5pTsMZcNDOOsA01xv7ymCF6zknMGpRHuw0Rb2BAJC9quU7CXWbMbAJLd
# Z6XINKariSmCX3/MLdzcW5XOycK0QhoRNRf4WqXRshEBaY2ymJvHO48oSSY/kpuY
# vBS3ljAAuLN7Rp8jWS7t916paGeE7prmrP9FJsoy1LFKmFnW+vg43ANhByuAEXq9
# Cay5o7K2H5NFnR5wj/SLRKwK1iyUX926i1TEviEiAh/PVyJbAD4koipig28p/6HD
# uiYOZ0wUkm/a5W8orIjoOdU3XsJ4i08CfNp5I73CsvB5QPYMcLpF9NO/1LvoQAw3
# UPdL55M5HTCCB3EwggVZoAMCAQICEzMAAAAVxedrngKbSZkAAAAAABUwDQYJKoZI
# hvcNAQELBQAwgYgxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAw
# DgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24x
# MjAwBgNVBAMTKU1pY3Jvc29mdCBSb290IENlcnRpZmljYXRlIEF1dGhvcml0eSAy
# MDEwMB4XDTIxMDkzMDE4MjIyNVoXDTMwMDkzMDE4MzIyNVowfDELMAkGA1UEBhMC
# VVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNV
# BAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEmMCQGA1UEAxMdTWljcm9zb2Z0IFRp
# bWUtU3RhbXAgUENBIDIwMTAwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoIC
# AQDk4aZM57RyIQt5osvXJHm9DtWC0/3unAcH0qlsTnXIyjVX9gF/bErg4r25Phdg
# M/9cT8dm95VTcVrifkpa/rg2Z4VGIwy1jRPPdzLAEBjoYH1qUoNEt6aORmsHFPPF
# dvWGUNzBRMhxXFExN6AKOG6N7dcP2CZTfDlhAnrEqv1yaa8dq6z2Nr41JmTamDu6
# GnszrYBbfowQHJ1S/rboYiXcag/PXfT+jlPP1uyFVk3v3byNpOORj7I5LFGc6XBp
# Dco2LXCOMcg1KL3jtIckw+DJj361VI/c+gVVmG1oO5pGve2krnopN6zL64NF50Zu
# yjLVwIYwXE8s4mKyzbnijYjklqwBSru+cakXW2dg3viSkR4dPf0gz3N9QZpGdc3E
# XzTdEonW/aUgfX782Z5F37ZyL9t9X4C626p+Nuw2TPYrbqgSUei/BQOj0XOmTTd0
# lBw0gg/wEPK3Rxjtp+iZfD9M269ewvPV2HM9Q07BMzlMjgK8QmguEOqEUUbi0b1q
# GFphAXPKZ6Je1yh2AuIzGHLXpyDwwvoSCtdjbwzJNmSLW6CmgyFdXzB0kZSU2LlQ
# +QuJYfM2BjUYhEfb3BvR/bLUHMVr9lxSUV0S2yW6r1AFemzFER1y7435UsSFF5PA
# PBXbGjfHCBUYP3irRbb1Hode2o+eFnJpxq57t7c+auIurQIDAQABo4IB3TCCAdkw
# EgYJKwYBBAGCNxUBBAUCAwEAATAjBgkrBgEEAYI3FQIEFgQUKqdS/mTEmr6CkTxG
# NSnPEP8vBO4wHQYDVR0OBBYEFJ+nFV0AXmJdg/Tl0mWnG1M1GelyMFwGA1UdIARV
# MFMwUQYMKwYBBAGCN0yDfQEBMEEwPwYIKwYBBQUHAgEWM2h0dHA6Ly93d3cubWlj
# cm9zb2Z0LmNvbS9wa2lvcHMvRG9jcy9SZXBvc2l0b3J5Lmh0bTATBgNVHSUEDDAK
# BggrBgEFBQcDCDAZBgkrBgEEAYI3FAIEDB4KAFMAdQBiAEMAQTALBgNVHQ8EBAMC
# AYYwDwYDVR0TAQH/BAUwAwEB/zAfBgNVHSMEGDAWgBTV9lbLj+iiXGJo0T2UkFvX
# zpoYxDBWBgNVHR8ETzBNMEugSaBHhkVodHRwOi8vY3JsLm1pY3Jvc29mdC5jb20v
# cGtpL2NybC9wcm9kdWN0cy9NaWNSb29DZXJBdXRfMjAxMC0wNi0yMy5jcmwwWgYI
# KwYBBQUHAQEETjBMMEoGCCsGAQUFBzAChj5odHRwOi8vd3d3Lm1pY3Jvc29mdC5j
# b20vcGtpL2NlcnRzL01pY1Jvb0NlckF1dF8yMDEwLTA2LTIzLmNydDANBgkqhkiG
# 9w0BAQsFAAOCAgEAnVV9/Cqt4SwfZwExJFvhnnJL/Klv6lwUtj5OR2R4sQaTlz0x
# M7U518JxNj/aZGx80HU5bbsPMeTCj/ts0aGUGCLu6WZnOlNN3Zi6th542DYunKmC
# VgADsAW+iehp4LoJ7nvfam++Kctu2D9IdQHZGN5tggz1bSNU5HhTdSRXud2f8449
# xvNo32X2pFaq95W2KFUn0CS9QKC/GbYSEhFdPSfgQJY4rPf5KYnDvBewVIVCs/wM
# nosZiefwC2qBwoEZQhlSdYo2wh3DYXMuLGt7bj8sCXgU6ZGyqVvfSaN0DLzskYDS
# PeZKPmY7T7uG+jIa2Zb0j/aRAfbOxnT99kxybxCrdTDFNLB62FD+CljdQDzHVG2d
# Y3RILLFORy3BFARxv2T5JL5zbcqOCb2zAVdJVGTZc9d/HltEAY5aGZFrDZ+kKNxn
# GSgkujhLmm77IVRrakURR6nxt67I6IleT53S0Ex2tVdUCbFpAUR+fKFhbHP+Crvs
# QWY9af3LwUFJfn6Tvsv4O+S3Fb+0zj6lMVGEvL8CwYKiexcdFYmNcP7ntdAoGokL
# jzbaukz5m/8K6TT4JDVnK+ANuOaMmdbhIurwJ0I9JZTmdHRbatGePu1+oDEzfbzL
# 6Xu/OHBE0ZDxyKs6ijoIYn/ZcGNTTY3ugm2lBRDBcQZqELQdVTNYs6FwZvKhggNN
# MIICNQIBATCB+aGB0aSBzjCByzELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hp
# bmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jw
# b3JhdGlvbjElMCMGA1UECxMcTWljcm9zb2Z0IEFtZXJpY2EgT3BlcmF0aW9uczEn
# MCUGA1UECxMeblNoaWVsZCBUU1MgRVNOOjk2MDAtMDVFMC1EOTQ3MSUwIwYDVQQD
# ExxNaWNyb3NvZnQgVGltZS1TdGFtcCBTZXJ2aWNloiMKAQEwBwYFKw4DAhoDFQC6
# PYHRw9+9SH+1pwy6qzVG3k9lbqCBgzCBgKR+MHwxCzAJBgNVBAYTAlVTMRMwEQYD
# VQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNy
# b3NvZnQgQ29ycG9yYXRpb24xJjAkBgNVBAMTHU1pY3Jvc29mdCBUaW1lLVN0YW1w
# IFBDQSAyMDEwMA0GCSqGSIb3DQEBCwUAAgUA64eB5zAiGA8yMDI1MDMyMTA2MTI1
# NVoYDzIwMjUwMzIyMDYxMjU1WjB0MDoGCisGAQQBhFkKBAExLDAqMAoCBQDrh4Hn
# AgEAMAcCAQACAhdxMAcCAQACAhMuMAoCBQDriNNnAgEAMDYGCisGAQQBhFkKBAIx
# KDAmMAwGCisGAQQBhFkKAwKgCjAIAgEAAgMHoSChCjAIAgEAAgMBhqAwDQYJKoZI
# hvcNAQELBQADggEBAH/4eA8oH50sNnyDX64iemSI2coXm2P2AmnX9JZ+iLoBRRv+
# G9QCNlukkBygNJ40Inmr/zuVq9Mv5s9phbZt1aU5Sk/FCNjQXcI4a4Ah+eAWsDaB
# VXZSJbckfPpdA0sY7MhW2MA3mkH4gQsO3hEKqEKuQ9h7IGh2K6MtokAz430hNb0n
# GYAfXWjjX9ydApQbwkgcj+fSXZAUKLxWIaoam/LFCXZFs+Hr/0pwTuUJy3MelIvq
# JTMyXV8maINlWehgAWqWUGALME6WakFJ4WdICIhOZR2aJu5IJOB4i3hXYSvhdo7P
# UA1mAhHUlCo4HtCCwqbzEh5AzzmxgBsDe069kKIxggQNMIIECQIBATCBkzB8MQsw
# CQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9u
# ZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMSYwJAYDVQQDEx1NaWNy
# b3NvZnQgVGltZS1TdGFtcCBQQ0EgMjAxMAITMwAAAgTY4A4HlzJYmAABAAACBDAN
# BglghkgBZQMEAgEFAKCCAUowGgYJKoZIhvcNAQkDMQ0GCyqGSIb3DQEJEAEEMC8G
# CSqGSIb3DQEJBDEiBCD+Mg6vgKIjPqR3A1IcvuzExrI9eXihE1RJvCaPD5X7UzCB
# +gYLKoZIhvcNAQkQAi8xgeowgecwgeQwgb0EIPnteGX9Wwq8VdJM6mjfx1GEJsu7
# /6kU6l0SS5rcebn+MIGYMIGApH4wfDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldh
# c2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBD
# b3Jwb3JhdGlvbjEmMCQGA1UEAxMdTWljcm9zb2Z0IFRpbWUtU3RhbXAgUENBIDIw
# MTACEzMAAAIE2OAOB5cyWJgAAQAAAgQwIgQgAcEhD2Q+O2nRvv/LrGTZzcK16gRN
# aW3zKnnkGJCcNIEwDQYJKoZIhvcNAQELBQAEggIAtrcKAXx4seNPCSSzWnLRp9GV
# DNapI1OGfaf3onr74sH5ftZka8NPhekkzkdBcUPNMyN6injkf3orCmn/gn69eGqq
# XbQB3LHF2vPwzB6JWDvWjL+CV35NigNVF4bHLOtQmWLSjttBG7ODukZgQjF9Lzsq
# iWJKPNsIguj9NTbzeYUAqKIDYcjY43T9eq0Dls7shY3RfX8uLf0uanqmDEerpGaF
# P9/8aMoTJ+0/ST/u8rYcHcMA3YB1gIap1C8b4Pt5DHZE/m2IokscaBihmq0Q4qQs
# uodW62spcYEHQSI/nWPO2psXEr01AW9ivYZY4BEVY8JfvYJF+AwF17QN1jWloG2y
# AZR+in1W5zgekIfAz2zSpb4By7t+AQy6Mfoi+k+I6B5bjpnotne24IDi5sd9tC0w
# c5gyWAq1xQoDVSd2tYnV/wFeHfQNHccVJjtrtVoLSqcns98/Gwf43nt9e1LXfsvc
# h1XM1IdACFdiF0AOrXXzSCedh55oLpkYLtoiifSO/1SFatyqfsyro8JYA05J7PD1
# 0M294LheUEkAT+DaK4lZ+uOWZTzjdmAcCKYctDBEsfcfkknIrw9Vo1CrLX3g5+M7
# NUEurXa6mNlY5PpS6gw4xFJYGLsZKCL2zL1rUcsMNncjYDi/aI0njaLd1eWL56T6
# 2PvCBHq0gEsKj2L0fYw=
# SIG # End signature block