Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
ASDK Bare Metal test Netsed edit
<###################################################
# #
# Copyright (c) Microsoft. All rights reserved. #
# #
##################################################>
# These tests are expected to run only as part of initial deployment of a stamp.
Import-LocalizedData CommonLocalizedStrings -BaseDirectory $PSScriptRoot\..\..\Common -FileName Roles.Strings.psd1 -ErrorAction SilentlyContinue
Import-LocalizedData BareMetalLocalizedStrings -BaseDirectory $PSScriptRoot\.. -FileName PhysicalMachines.Strings.psd1 -ErrorAction SilentlyContinue
Import-Module -Name "$PSScriptRoot\..\..\Common\RoleHelpers.psm1"
Import-Module -Name "$PSScriptRoot\..\..\..\ECEngine\Telemetry.dll"
# Disk information of the physical host.
# Some fields are used telemetry/logging only:
# FriendlyName/SerialNumber/DeviceId/Manufacturer/Model/MediaType/FirmwareVersion
class Disk : System.IComparable
{
[string] $FriendlyName
[string] $SerialNumber
[string] $BusType
[string] $DeviceId
[string] $Manufacturer
[string] $Model
[string] $MediaType
[string] $HealthStatus
[long] $Size
[string] $FirmwareVersion
[string] $UniqueId
[int] $IndexWithinSimilarDisks
[int] CompareTo([object] $obj)
{
[Disk] $other = $obj -as [Disk]
if (-not $other)
{
throw new System.ArgumentException("The object to compare with is not of type Disk.")
}
[int] $busTypeComparisonResult = $this.BusType.CompareTo($other.BusType)
if ($busTypeComparisonResult -ne 0)
{
return $busTypeComparisonResult
}
[int] $indexComparisonResult = $this.IndexWithinSimilarDisks.CompareTo($other.IndexWithinSimilarDisks)
if ($indexComparisonResult -ne 0)
{
return $indexComparisonResult
}
[int] $sizeComparisonResult = $this.Size.CompareTo($other.Size)
return $sizeComparisonResult
}
[bool] Equals([object] $other)
{
return $this.CompareTo($other) -eq 0
}
[int] GetHashCode()
{
return [Tuple]::Create($this.BusType, $this.Size, $this.IndexWithinSimilarDisks).GetHashCode()
}
}
class NetworkAdapter : System.IComparable
{
[long] $Speed
[string] $IsRdmaEnabled
[string] $Name
[string] $InterfaceIndex
[string] $InterfaceDescription
[string] $DriverInformation
[string] $DriverName
[int] $MtuSize
[int] CompareTo([object] $obj)
{
[NetworkAdapter] $other = $obj -as [NetworkAdapter]
if (-not $other)
{
throw new System.ArgumentException("The object to compare with is not of type NetworkAdapter.")
}
[int] $speedComparisonResult = $this.Speed.CompareTo($other.Speed)
if ($speedComparisonResult -ne 0)
{
return $speedComparisonResult
}
[int] $isRdmaEnabledComparisonResult = $this.IsRdmaEnabled.CompareTo($other.IsRdmaEnabled)
return $isRdmaEnabledComparisonResult
}
[bool] Equals([object] $other)
{
return $this.CompareTo($other) -eq 0
}
[int] GetHashCode()
{
return [Tuple]::Create($this.Speed, $this.IsRdmaEnabled).GetHashCode()
}
}
class ScsiAdapter
{
[string] $DeviceName
[string] $Description
[string] $DriverVersion
[string] $DriverDate
[string] $Location
[string] $HardWareID
}
class Processor
{
[string] $NumberOfEnabledCores
[bool] $HasVMMonitorModeExtensions
[bool] $IsVirtualizationEnabled
[bool] $SupportsSecondLevelAddressTranslation
[string] $Name
[string] $Caption
[string] $Model
[string] $Socket
[string] $DriverVersion
[string] $DriverDate
[string] $TotalCores
[string] $TotalThreads
[string] $MicrocodeVersion
}
# BIOS information of the physical host. Used for telemetry only
class Bios
{
[string] $Name
[string] $Manufacturer
[string] $SerialNumber
[string] $Version
[string] $SMBIOSBIOSVersion
[string] $SMBIOSMajorVersion
[string] $SMBIOSMinorVersion
[string] $UUID
}
class Memory
{
[string] $Name
[string] $Manufacturer
[uint64] $Capacity
[string] $SerialNumber
[string] $MemoryType
[string] $PartNumber
[string] $DeviceLocator
[uint32] $ConfiguredClockSpeed
[string] $Model
[string] $PoweredOn
[string] $Status
}
class PcieDevices
{
[string] $Name
[string] $Id
[string] $ManufacturerName
[string] $DriverVersion
[string] $PNPDeviceID
[string] $Status
}
class PhysicalMachine
{
[string] $ComputerName
[string] $IPAddress
[bool] $IsVirtualMachine
[bool] $IsHyperVServiceRunning
[bool] $IsDataExecutionPreventionEnabled
[string] $OSVersion
[int] $OSSku
[bool] $IsPartOfDomain
[long] $TotalPhysicalMemory
[Processor[]] $Processors
[Disk] $SystemDisk
[Disk[]] $NonSystemDisks
[NetworkAdapter[]] $NetworkAdapters
[Disk[]] $PhysicalDisks
[Bios] $Bios
[ScsiAdapter[]] $ScsiAdapters
[Memory[]] $Memories
[PcieDevices[]] $Gpu
}
# Validation is done on three stages.
# First, data about the configuration of the machines is retrieved from all of the machines.
# Second, the hardware is emitted for telemetry purpose. (not related to the validation itself).
# After that, the data is checked to find potential problems.
Describe "Validate-Role" `
{
# Before we start, validate that the expected parameters have been passed.
It ($CommonLocalizedStrings.TestParameterShouldBeProvided -f "MachineNameToIPAddress") `
{
$Parameters.MachineNameToIPAddress | Should Not BeNullOrEmpty
}
It ($CommonLocalizedStrings.TestParameterShouldBeProvided -f "Credential") `
{
($Parameters.Credential -eq $null) | Should Be $false
}
It ($CommonLocalizedStrings.TestParameterShouldBeProvided -f "Topology") `
{
$Parameters.Topology | Should Not BeNullOrEmpty
}
It ($CommonLocalizedStrings.TestParameterShouldBeProvided -f "PhysicalMachinesRole") `
{
$Parameters.PhysicalMachinesRole | Should Not BeNullOrEmpty
}
It ($CommonLocalizedStrings.TestParameterShouldBeProvided -f "DeploymentGuid") `
{
$Parameters.DeploymentGuid | Should Not BeNullOrEmpty
}
It ($CommonLocalizedStrings.TestParameterShouldBeProvided -f "ClusterRole") `
{
$Parameters.OEMPublisher | Should Not BeNullOrEmpty
}
It ($CommonLocalizedStrings.TestParameterShouldBeProvided -f "OEMPublisher") `
{
$Parameters.OEMPublisher | Should Not BeNullOrEmpty
}
$isOneNode = ($Parameters.Topology -eq 'OneNode')
$isVirtualizedDeployment = ($Parameters.OEMModel -eq 'Hyper-V')
$physicalMachinesRole = $Parameters.PhysicalMachinesRole
$clusterRole = $Parameters.ClusterRole
# Validate that the expected settings that are needed for validation have been specified in CustomerConfig.xml.
It ($BareMetalLocalizedStrings.TestCustomerConfigParameters) `
{
$script:minimumOperatingSystemVersion = New-Object Version($physicalMachinesRole.PrivateInfo.ValidationRequirements.MinimumOperatingSystemVersion)
$script:minimumNumberOfCoresPerMachine = [int]::Parse($physicalMachinesRole.PrivateInfo.ValidationRequirements.MinimumNumberOfCoresPerMachine)
$script:minimumPhysicalMemoryPerMachineGB = [long]::Parse($physicalMachinesRole.PrivateInfo.ValidationRequirements.MinimumPhysicalMemoryPerMachineGB)
$script:minimumNumberOfAdaptersPerMachine = [int]::Parse($physicalMachinesRole.PrivateInfo.ValidationRequirements.MinimumNumberOfAdaptersPerMachine)
$script:minimumAdapterSpeedBitsPerSecond = [long]::Parse($physicalMachinesRole.PrivateInfo.ValidationRequirements.MinimumAdapterSpeedBitsPerSecond)
$script:minimumSizeOfSystemDiskGB = [long]::Parse($physicalMachinesRole.PrivateInfo.ValidationRequirements.MinimumSizeOfSystemDiskGB)
$script:minimumSizeOfDataDisksGB = [long]::Parse($physicalMachinesRole.PrivateInfo.ValidationRequirements.MinimumSizeOfDataDisksGB)
$script:minimumNumberOfDataDisksPerMachine = [int]::Parse($physicalMachinesRole.PrivateInfo.ValidationRequirements.MinimumNumberOfDataDisksPerMachine)
$script:maximumNumberOfMissingDisksPerMachine = [int]::Parse($physicalMachinesRole.PrivateInfo.ValidationRequirements.MaximumNumberOfMissingDisksPerMachine)
$script:sizeComparisonTolerancePercentage = [int]::Parse($physicalMachinesRole.PrivateInfo.ValidationRequirements.SizeComparisonTolerancePercentage)
$script:toleranceMultiplier = 1 + ($sizeComparisonTolerancePercentage / 100.0)
}
# Validate the number of machines and that, in the one-node case, the test is running on the physical machine.
if ($isOneNode)
{
It ($BareMetalLocalizedStrings.TestExactlyOneMachine) `
{
$Parameters.MachineNameToIPAddress.Count | Should Be 1
}
foreach ($physicalMachineName in $Parameters.MachineNameToIPAddress.Keys)
{
It ($BareMetalLocalizedStrings.TestRunningOnPhysicalMachine -f $physicalMachineName) `
{
$physicalMachineName | Should Be $env:COMPUTERNAME
}
}
# For OneNode, there is no need to use the IPv4 address because there will not be any IPv6 address problems. Use
# "localhost" for the host address instead of the IPv4 address so that CredSSP is not needed.
$Parameters.MachineNameToIPAddress[$env:COMPUTERNAME] = "localhost"
}
###################################################################################################################################################
# Stage 1: Query for machine information
# Querying for machine information will be kept separate from the checks that use this information, because in the future this machine information
# may be retrieved as part of a discovery stage.
###################################################################################################################################################
$physicalMachines = [PhysicalMachine[]]@()
[System.Collections.Hashtable[]] $physicalMachinesInventoryInfo = @()
foreach ($machineName in $Parameters.MachineNameToIPAddress.Keys)
{
$ipAddress = $Parameters.MachineNameToIPAddress[$machineName];
$physicalMachine = New-Object PhysicalMachine -Property @{ ComputerName=$machineName; IPAddress=$ipAddress }
Trace-Execution "Querying machine information for machine $machineName with address $ipAddress"
It ($CommonLocalizedStrings.TestConnection -f $machineName) `
{
if($machineName -eq $env:COMPUTERNAME)
{
$script:cimSession = New-CimSession -Credential $Parameters.Credential
}
else
{
$script:cimSession = New-CimSession -ComputerName $ipAddress -Credential $Parameters.Credential
}
$currentMachineIdString = Invoke-CimMethod -CimSession $cimSession -NameSpace "root/cimv2" -Class "StdRegProv" -MethodName "GetStringValue" -Arguments @{
'hDefKey' = [uint32]'0x80000002'
'sSubKeyName' = "Software\Microsoft\SQMClient"
'sValueName' = "MachineId"
}
[System.Guid] $tmpGuid = [System.Guid]::Empty
if ([System.Guid]::TryParse($currentMachineIdString.sValue, [ref]$tmpGuid))
{
$script:machineId = $tmpGuid.ToString()
}
else
{
$script:machineId = ""
}
}
#
# Start: Computer and OS information
#
It ($BareMetalLocalizedStrings.TestRetrieveComputerSystemInformation -f $machineName) `
{
Trace-Execution "Querying Win32_ComputerSystem."
$computerSystemWmiResults = Get-CimInstance -CimSession $cimSession -Query "select TotalPhysicalMemory, PartOfDomain, Manufacturer from Win32_ComputerSystem"
$physicalMachine.TotalPhysicalMemory = $computerSystemWmiResults.TotalPhysicalMemory
$physicalMachine.IsPartOfDomain = $computerSystemWmiResults.PartOfDomain
$physicalMachine.IsVirtualMachine = $computerSystemWmiResults.Manufacturer.ToLower() -match 'microsoft corporation' -or `
$computerSystemWmiResults.Manufacturer.ToLower() -match 'vmware'
Trace-Execution "Manufacturer reported by Win32_ComputerSystem is $($computerSystemWmiResults.Manufacturer)"
Trace-Execution "Total physical memory is $($computerSystemWmiResults.TotalPhysicalMemory)"
Trace-Execution "PartOfDomain is $($computerSystemWmiResults.PartOfDomain)"
}
It ($BareMetalLocalizedStrings.TestRetrieveOperatingSystemInformation -f $machineName) `
{
Trace-Execution "Querying Win32_OperatingSystem."
$operatingSystemWmiResults = Get-CimInstance -CimSession $cimSession -Query "select Version, OperatingSystemSKU, DataExecutionPrevention_Available from Win32_OperatingSystem"
$physicalMachine.OSVersion = $operatingSystemWmiResults.Version
$physicalMachine.OSSku = $operatingSystemWmiResults.OperatingSystemSKU
$physicalMachine.IsDataExecutionPreventionEnabled = $operatingSystemWmiResults.DataExecutionPrevention_Available
Trace-Execution "OS version is $($operatingSystemWmiResults.Version)"
Trace-Execution "OS SKU is $($operatingSystemWmiResults.OperatingSystemSKU)"
Trace-Execution "DataExecutionPreventionAvailable is $($operatingSystemWmiResults.DataExecutionPrevention_Available)"
}
It ($BareMetalLocalizedStrings.TestRetrieveHyperVServiceInformation -f $machineName) `
{
Trace-Execution "Querying Win32_Service."
$hyperVServiceWmiResults = Get-CimInstance -CimSession $cimSession -Query "select State from Win32_Service where name='vmms'"
$physicalMachine.IsHyperVServiceRunning = $false
if ($hyperVServiceWmiResults)
{
Trace-Execution "Hyper-V service was found."
Trace-Execution "State of Hyper-V service is $($hyperVServiceWmiResults.State)"
$physicalMachine.IsHyperVServiceRunning = ($hyperVServiceWmiResults.State -eq 'Running')
}
}
#
# End: Computer and OS information
#
#
# Start: Processor information
#
It ($BareMetalLocalizedStrings.TestRetrieveProcessorInformation -f $machineName) `
{
function GetCpuMicrocodeVersionString
{
[CmdletBinding()]
Param (
[Parameter(Mandatory = $true)]
[Byte[]] $littleEndianBytes
)
$retStr = ""
if ($null -eq $littleEndianBytes -or $littleEndianBytes.Length -eq 0 -or $littleEndianBytes.Length % 4 -ne 0)
{
return $retStr
}
# We are expecting an array that represents one INT32 integer.
# For some OEM, the array might contains multiple INT32 numbers. In that case the leading number should
# be 0: the 1st 4 bytes represents 1st integer, the 2nd 4 bytes represents 2nd integer, etc.
# So cannot just revert the byte array to get the correct HEX string: should do some workaround here.
[String] $littleEndianString = [System.BitConverter]::ToString($littleEndianBytes).Replace("-", "")
[int] $littleEndianNumber = 0
try
{
$littleEndianNumber = [System.Convert]::ToInt32($littleEndianString, 16)
}
catch [System.OverflowException]
{
# In case the input array contains multiple INT32 numbers, but the leading numbers are not 0
return $retStr
}
[Byte[]] $bytes = [System.BitConverter]::GetBytes($littleEndianNumber)
foreach ($b in $bytes)
{
$retStr += $b.ToString("X2");
}
return $retStr
}
Trace-Execution "Querying processor information."
$currentCpuMicrocodeBinaryArray = Invoke-CimMethod -CimSession $cimSession -NameSpace "root/cimv2" -Class "StdRegProv" -MethodName "GetBinaryValue" -Arguments @{
'hDefKey' = [uint32]'0x80000002'
'sSubKeyName' = "HARDWARE\DESCRIPTION\System\CentralProcessor\0"
'sValueName' = "Update Revision"
}
$currentCpuMicrocodeVersion = GetCpuMicrocodeVersionString -littleEndianBytes $currentCpuMicrocodeBinaryArray.uValue
$processorWmiResults = Get-CimInstance -CimSession $cimSession -Class Win32_Processor
$physicalMachine.Processors = [Processor[]]@()
$processorWmiResults | % `
{
$physicalMachine.Processors += (New-Object Processor -Property @{ NumberOfEnabledCores=$_.NumberOfEnabledCore;
HasVMMonitorModeExtensions=$_.VMMonitorModeExtensions;
IsVirtualizationEnabled=$_.VirtualizationFirmwareEnabled;
SupportsSecondLevelAddressTranslation=$_.SecondLevelAddressTranslationExtensions;
Name = $_.DeviceId;
Caption = $_.Caption;
Model = $_.Name;
Socket = $_.SocketDesignation;
TotalCores = $_.NumberOfCores;
TotalThreads = $_.NumberOfLogicalProcessors;
MicrocodeVersion = $currentCpuMicrocodeVersion
})
}
$pnpSignedDrivers = Get-CimInstance -CimSession $cimSession -ClassName "Win32_PnPSignedDriver" `
| Where-Object FriendlyName -ne $null `
| Select-Object FriendlyName, DriverVersion, DriverDate
foreach ($processor in $physicalMachine.Processors)
{
foreach ($pnpSignedDriver in $pnpSignedDrivers)
{
if ($pnpSignedDriver.FriendlyName -eq $processor.Model)
{
$processor.DriverVersion = $pnpSignedDriver.DriverVersion
$processor.DriverDate = $pnpSignedDriver.DriverDate
}
}
}
Trace-Execution "Found processors with the following properties:"
Trace-Execution ($physicalMachine.Processors | out-string)
}
#
# End: Processor information
#
#
# Start: Disk information
#
It ($BareMetalLocalizedStrings.TestRetrieveDiskInformation -f $machineName) `
{
Trace-Execution "Querying disk information."
$systemDisk = Get-Disk -CimSession $cimSession | ? { $_.IsSystem }
$physicalMachine.SystemDisk = New-Object Disk -Property @{ BusType=$systemDisk.BusType; Size=$systemDisk.Size }
$physicalMachine.NonSystemDisks = [Disk[]]@()
Get-PhysicalDisk -CimSession $cimSession | ? DeviceId -ne $systemDisk.Number | % `
{
$physicalMachine.NonSystemDisks += New-Object Disk -Property @{
BusType=$_.BusType
Size=$_.Size
FriendlyName = $_.FriendlyName
SerialNumber = $_.SerialNumber
Manufacturer = $_.Manufacturer
DeviceId = $_.DeviceId
Model = $_.Model
MediaType = $_.MediaType
HealthStatus = $_.HealthStatus
FirmwareVersion = $_.FirmwareVersion
}
}
$physicalMachine.NonSystemDisks = ($physicalMachine.NonSystemDisks | sort)
$physicalMachine.NonSystemDisks[0].IndexWithinSimilarDisks = 0
for ($i = 1; $i -lt $physicalMachine.NonSystemDisks.Count; $i++)
{
if ($physicalMachine.NonSystemDisks[$i].BusType -eq $physicalMachine.NonSystemDisks[$i-1].BusType -and
$physicalMachine.NonSystemDisks[$i].Size * $toleranceMultiplier -ge $physicalMachine.NonSystemDisks[$i-1].Size -and
$physicalMachine.NonSystemDisks[$i].Size -le $physicalMachine.NonSystemDisks[$i-1].Size * $toleranceMultiplier)
{
$physicalMachine.NonSystemDisks[$i].IndexWithinSimilarDisks = $physicalMachine.NonSystemDisks[$i-1].IndexWithinSimilarDisks + 1
}
else
{
$physicalMachine.NonSystemDisks[$i].IndexWithinSimilarDisks = 0
}
}
# Get information check for physical disk that attached to current machine only
$hostLocalStorageSubSystems = Get-StorageSubSystem -CimSession $cimSession | Where-Object { $_.FriendlyName -like "Cluster*" }
if ($hostLocalStorageSubSystems.Count -eq 0)
{
# No SOFS enabled, try to get Windows Storage itself
$hostLocalStorageSubSystems = Get-StorageSubSystem -CimSession $cimSession | Where-Object { $_.FriendlyName -like "Windows Storage*" }
}
$hostLocalStorageNodes = Get-StorageNode -StorageSubSystem $hostLocalStorageSubSystems[0] -CimSession $cimSession
$currentHostStorageNode = $hostLocalStorageNodes | Where-Object { $_.Name -like "$($machineName)*" }
Get-PhysicalDisk -PhysicallyConnected -StorageNode $currentHostStorageNode -CimSession $cimSession | Where-Object Model -ne "Virtual Disk" | ForEach-Object `
{
$physicalMachine.PhysicalDisks += New-Object Disk -Property @{
BusType=$_.BusType
Size=$_.Size
FriendlyName = $_.FriendlyName
SerialNumber = $_.SerialNumber
Manufacturer = $_.Manufacturer
DeviceId = $_.DeviceId
Model = $_.Model
MediaType = $_.MediaType
HealthStatus = $_.HealthStatus
FirmwareVersion = $_.FirmwareVersion
UniqueId = $_.UniqueId.Trim()
}
}
Trace-Execution "Found system disk with the following properties:"
Trace-Execution ($physicalMachine.SystemDisk | out-string)
Trace-Execution "Found non-system disks with the following properties:"
Trace-Execution ($physicalMachine.NonSystemDisks | out-string)
}
#
# End: Disk information
#
#
# Start: BIOS information
#
It ($BareMetalLocalizedStrings.TestRetrieveBIOSInformation -f $machineName) `
{
Trace-Execution "Querying BIOS information."
# BIOS properties need to be collected
Get-CimInstance -CimSession $cimSession -ClassName "Win32_BIOS" | Select-Object -First 1 | ForEach-Object `
{
$physicalMachine.Bios = New-Object Bios -Property @{
Name = $_.Name
Manufacturer = $_.Manufacturer
SerialNumber = $_.SerialNumber
Version = $_.Version
SMBIOSBIOSVersion = $_.SMBIOSBIOSVersion
SMBIOSMajorVersion = $_.SMBIOSMajorVersion
SMBIOSMinorVersion = $_.SMBIOSMinorVersion
}
}
Get-CimInstance -CimSession $cimSession -ClassName "Win32_ComputerSystemProduct" | Select-Object -First 1 | ForEach-Object `
{
$physicalMachine.Bios.UUID = $_.UUID
}
}
#
# End: BIOS information
#
#
# Start: Network adapter information
#
#
# Start: Memory information
#
{
# Get memory type string from CIM memory type number
# Refer to https://docs.microsoft.com/en-us/windows/desktop/cimwin32prov/win32-physicalmemory
function Get-MemoryTypeString
{
[CmdletBinding()]
Param (
[Parameter(Mandatory = $true)]
[string] $MemoryType
)
switch ($MemoryType)
{
"0"
{
$retVal = "Unknown"
break
}
"1"
{
$retVal = "Other"
break
}
"2"
{
$retVal = "DRAM"
break
}
"3"
{
$retVal = "Synchronous DRAM"
break
}
"4"
{
$retVal = "Cache DRAM"
break
}
"5"
{
$retVal = "EDO"
break
}
"6"
{
$retVal = "EDRAM"
break
}
"7"
{
$retVal = "VRAM"
break
}
"8"
{
$retVal = "SRAM"
break
}
"9"
{
$retVal = "RAM"
break
}
"10"
{
$retVal = "ROM"
break
}
"11"
{
$retVal = "Flash"
break
}
"12"
{
$retVal = "EEPROM"
break
}
"13"
{
$retVal = "FEPROM"
break
}
"14"
{
$retVal = "EPROM"
break
}
"15"
{
$retVal = "CDRAM"
break
}
"16"
{
$retVal = "3DRAM"
break
}
"17"
{
$retVal = "SDRAM"
break
}
"18"
{
$retVal = "SGRAM"
break
}
"19"
{
$retVal = "RDRAM"
break
}
"20"
{
$retVal = "DDR"
break
}
"21"
{
$retVal = "DDR2"
break
}
"22"
{
$retVal = "DDR2 FB-DIMM"
break
}
"24"
{
$retVal = "DDR3"
break
}
"25"
{
$retVal = "FBD2"
break
}
default
{
$retVal = "Unknown"
break
}
}
return $retVal
}
Trace-Execution "Querying Memory information."
$memoryWmiResults = Get-CimInstance -CimSession $cimSession -Class Win32_PhysicalMemory
$physicalMachine.Memories = [Memory[]]@()
$memoryWmiResults | ForEach-Object `
{
$currentMemoryTypeString = Get-MemoryTypeString -MemoryType $_.MemoryType
$physicalMachine.Memories += (New-Object Memory -Property @{ Name = $_.Name;
Manufacturer = $_.Manufacturer;
Capacity = $_.Capacity;
SerialNumber = $_.SerialNumber;
MemoryType = $currentMemoryTypeString;
DeviceLocator = $_.DeviceLocator;
ConfiguredClockSpeed = $_.ConfiguredClockSpeed;
Model = $_.Model;
PoweredOn = $_.PoweredOn;
Status = $_.Status })
}
Trace-Execution "Found memories with the following properties:"
Trace-Execution ($physicalMachine.Memories | out-string)
}
#
# Start: SCSI Adapter information
#
It ($BareMetalLocalizedStrings.TestRetrieveScsiAdapterInformation -f $machineName) `
{
Trace-Execution "Querying SCSI Adapter information."
# SCSI properties need to be collected
$scsiAdapterWmiResults = Get-CimInstance -CimSession $cimSession -ClassName "Win32_PnPSignedDriver" `
| Where-Object DeviceClass -eq "SCSIADAPTER" `
| Where-Object Location -ne $null
$physicalMachine.ScsiAdapters = [ScsiAdapter[]]@()
$scsiAdapterWmiResults | ForEach-Object `
{
$physicalMachine.ScsiAdapters += (New-Object ScsiAdapter -Property @{
DeviceName = $_.DeviceName
Description = $_.Description
DriverVersion = $_.DriverVersion
DriverDate = $_.DriverDate
HardWareID = $_.HardWareID
})
}
Trace-Execution "Found SCSI adapters with the following properties:"
Trace-Execution ($physicalMachine.ScsiAdapters | out-string)
Trace-Execution "Completed querying machine information for machine $machineName with address $physicalMachine"
}
#
# Start: GPU Adapter information
#
It ($BareMetalLocalizedStrings.TestRetrieveGPUInformation -f $machineName) `
{
Trace-Execution "Querying GPU information."
# GPU properties need to be collected
$gpuWmiResults = Get-CimInstance -CimSession $cimSession -ClassName "Win32_VideoController" `
| Where-Object Name -NotLike "*Microsoft*"
$physicalMachine.Gpu = [PcieDevices[]]@()
$gpuWmiResults | ForEach-Object `
{
$physicalMachine.Gpu += (New-Object PcieDevices -Property @{
Id = $_.DeviceId
Name = $_.Name
DriverVersion = $_.DriverVersion
PNPDeviceID = $_.PNPDeviceID
Status = $_.Status
ManufacturerName = $_.AdapterCompatibility
})
}
Trace-Execution "Found GPU adapters with the following properties:"
Trace-Execution ($gpuData | out-string)
Remove-CimSession -CimSession $cimSession
Trace-Execution "Completed querying machine information for machine $machineName with address $physicalMachine"
}
$physicalMachines += $physicalMachine
# BIOS JSON be saved into hardware inventory information (ECE store and stamp info file)
$biosJson = [PSCustomObject]@{
'@odata.context' = '/redfish/v1/$metadata#ComputerSystem.ComputerSystem'
'@odata.id' = "/redfish/v1/Systems/$machineName"
'@odata.type' = "#ComputerSystem.v1_5_0.ComputerSystem"
Id = $machineName
Name = $machineName
SerialNumber = $physicalMachine.Bios.SerialNumber
BiosVersion = $physicalMachine.Bios.SMBIOSBIOSVersion
UUID = $physicalMachine.Bios.UUID
Oem = [PSCustomObject]@{
$Parameters.oemPublisher = [PSCustomObject]@{
Name = $physicalMachine.Bios.Name
BIOS_Manufacturer = $physicalMachine.Bios.Manufacturer
BIOS_Version = $physicalMachine.Bios.Version
BIOS_SMBIOSMajorVersion = $physicalMachine.Bios.SMBIOSMajorVersion
BIOS_SMBIOSMinorVersion = $physicalMachine.Bios.SMBIOSMinorVersion
MachineId = $machineId
}
}
}
$processorsJson = [PSCustomObject[]]@()
foreach ($processor in $physicalMachine.Processors)
{
$processorsJson += [PSCustomObject]@{
'@odata.context' = '/redfish/v1/$metadata#Processor.Processor'
'@odata.id' = "/redfish/v1/Systems/$machineName/Processors/$($processor.Name)"
'@odata.type' = "#Processor.v1_3_0.Processor"
Id = $processor.Name
Name = $processor.Name
Model = $processor.Model
Socket = $processor.Socket
TotalCores = $processor.TotalCores
TotalThreads = $processor.TotalThreads
Oem = [PSCustomObject]@{
$Parameters.oemPublisher = [PSCustomObject]@{
Caption = $processor.Caption
NumberOfEnabledCores = $processor.NumberOfEnabledCores
MicrocodeVersion = $processor.MicrocodeVersion
DriverDate = $processor.DriverDate
DriverVersion = $processor.DriverVersion
}
}
}
}
$netAdaptersJson = [PSCustomObject[]] @()
foreach ($netAdapter in $physicalMachine.NetworkAdapters)
{
$netAdaptersJson += [PSCustomObject]@{
'@odata.context' = '/redfish/v1/$metadata#EthernetInterface.EthernetInterface'
'@odata.id' = "/redfish/v1/Systems/$machineName/EthernetInterfaces/$($netAdapter.InterfaceIndex)"
'@odata.type' = "#EthernetInterface.v1_4_0.EthernetInterface"
Id = $netAdapter.InterfaceIndex
Name = $netAdapter.InterfaceDescription
SpeedMbps = $netAdapter.Speed / 1000000
MtuSize = $netAdapter.MtuSize
Oem = [PSCustomObject]@{
$Parameters.oemPublisher = [PSCustomObject]@{
DriverName = $netAdapter.DriverName
IsRdmaEnabled = $netAdapter.IsRdmaEnabled
DriverInformation = $netAdapter.DriverInformation
}
}
}
}
$diskDrivesJson = [PSCustomObject[]] @()
foreach ($diskDrive in $physicalMachine.PhysicalDisks)
{
$diskStatus = "Warning"
switch ($diskDrive.HealthStatus)
{
"Healthy" { $diskStatus = "OK" }
"Warning" { $diskStatus = "Warning" }
"Unhealthy" { $diskStatus = "Critical" }
Default { $diskStatus = "Warning" }
}
$diskDrivesJson += [PSCustomObject]@{
'@odata.context' = '/redfish/v1/$metadata#Drive.Drive'
'@odata.id' = "/redfish/v1/Systems/$machineName/Storage/1/Drives/$($diskDrive.SerialNumber)"
'@odata.type' = "#Drive.v1_4_0.Drive"
Id = $diskDrive.SerialNumber
Name = $diskDrive.FriendlyName
SerialNumber = $diskDrive.SerialNumber
Protocol = $diskDrive.BusType
Manufacturer = $diskDrive.Manufacturer
Model = $diskDrive.Model
MediaType = $diskDrive.MediaType
Status = [PSCustomObject] @{
Health = $diskStatus
}
CapacityBytes = $diskDrive.Size
Revision = $diskDrive.FirmwareVersion
Oem = [PSCustomObject]@{
$Parameters.oemPublisher = [PSCustomObject]@{
DeviceId = $diskDrive.DeviceId
UniqueId = $diskDrive.UniqueId
}
}
}
}
$memoriesJson = [PSCustomObject[]] @()
foreach ($memory in $physicalMachine.Memories)
{
$currentMemoryCapacityMiB = $memory.Capacity/(1024*1024)
$memoriesJson += [PSCustomObject] @{
'@odata.context' = '/redfish/v1/$metadata#Memory.Memory'
'@odata.id' = "/redfish/v1/Systems/$machineName/Memory/$($memory.DeviceLocator)"
'@odata.type' = "#Memory.v1_5_0.Memory"
Id = $memory.DeviceLocator
Name = $memory.Name
CapacityMiB = $currentMemoryCapacityMiB
DeviceLocator = $memory.DeviceLocator
Manufacturer = $memory.Manufacturer
MemoryType = $memory.MemoryType
OperatingSpeedMhz = $memory.ConfiguredClockSpeed
PartNumber = $memory.PartNumber
SerialNumber = $memory.SerialNumber
Oem = [PSCustomObject]@{
$Parameters.oemPublisher = [PSCustomObject]@{
Model = $memory.Model
PoweredOn = $memory.PoweredOn
Status = $memory.Status
}
}
}
}
$gpuDataJson = [PSCustomObject[]] @()
foreach ($gpudata in $physicalMachine.GPU)
{
$gpuDataJson += [PSCustomObject] @{
'@odata.context' = '/redfish/v1/$metadata#PCIeDevice.PCIeDevice'
'@odata.id' = "/redfish/v1/Systems/$machineName/PCIeDevice/$($gpudata.Id)"
'@odata.type' = "#PCIeDevice.v1_3_1.PCIeDevice"
Id = $gpudata.Id
Name = $gpudata.Name
Oem = [PSCustomObject]@{
$gpudata.ManufacturerName = [PSCustomObject]@{
DriverVersion = $gpudata.DriverVersion
PNPDeviceID = $gpudata.PNPDeviceID
Status = $gpudata.Status
}
}
}
}
$physicalMachinesInventoryInfo += @{
"$machineName" = @{
"ComputerSystem" = $biosJson
"Memory" = $memoriesJson
"Processor" = $processorsJson
"Drive" = $diskDrivesJson
"EthernetInterface" = $netAdaptersJson
"ScsiAdapters" = $physicalMachine.ScsiAdapters
"PcieDevices" = $gpuDataJson
}
}
}
# Got inventory info for all hosts in $physicalMachinesInventoryInfo. Now output to JSON
$hostInventoryLog = $physicalMachinesRole.PublicInfo.HardwareInventoryInformaton.Path
$hostInventoryLog = $ExecutionContext.InvokeCommand.ExpandString($hostInventoryLog)
$hostInventoryLogFolder = Split-Path -Path $hostInventoryLog -Parent
if (-not (Test-Path -Path $hostInventoryLogFolder -PathType Container))
{
New-Item -Path $hostInventoryLogFolder -ItemType Container
}
if (Test-Path -Path $hostInventoryLog -PathType Leaf)
{
Trace-Execution "Remove existing hardware inventory log file [$hostInventoryLog]."
Remove-Item -Path $hostInventoryLog -Force -ErrorAction Ignore | Out-null
}
# Now getting the information formatted as expected. For example
# "TimeOfCollection":
# "HardwareInventoryInfo": {
# "s-cluster" : {
# "NODE1": {
# ...
# },
# "NODE2": {
# ...
# },
# ...
# "NODEx": {
# ...
# }
# }
# }
$clusters = $ClusterRole.Clusters.Node
$finalInventoryJsonData = @{}
foreach ($cluster in $clusters)
{
# Get machines' name in current cluster
$currentClusterMachines = ($physicalMachinesRole.Nodes.Node | Where-Object {$_.RefClusterId -eq $cluster.Id}).Name
# Prepare information for current cluster
$currentClusterInfo = @{}
foreach ($machine in $currentClusterMachines)
{
if ($physicalMachinesInventoryInfo.$machine)
{
$currentClusterInfo += @{ $machine = $physicalMachinesInventoryInfo.$machine }
}
}
$finalInventoryJsonData += @{ $cluster.Name = $currentClusterInfo}
}
Trace-Execution "Saving new host hardware inventory information at [$hostInventoryLog]..."
$hardwareInventoryInfoJson = @{
"TimeOfCollection" = (Get-Date).ToString("yyyy-MM-ddTHH:mm:ss")
"HardwareInventoryInfo" = $finalInventoryJsonData
}
ConvertTo-Json $hardwareInventoryInfoJson -Depth 99 | Add-Content -Path $hostInventoryLog
###################################################################################################################################################
# Stage 2: Emit the hardware information for telemetry purpose
###################################################################################################################################################
$physicalMachines | ForEach-Object {
Send-HardwareTelemetry -DeploymentGuid $Parameters.DeploymentGuid -ValidationRequirements ($physicalMachinesRole.PrivateInfo.ValidationRequirements.InnerXml) -HardwareInformation ($_ | ConvertTo-Json -Depth 10 -Compress)
}
Trace-Execution "Hardware information for Deployment $($Parameters.DeploymentGuid) has been emitted."
###################################################################################################################################################
# Stage 3: Run validations based on the machine information that has been retrieved.
###################################################################################################################################################
# Validate this is not a virtual machine.
if ($isVirtualizedDeployment)
{
foreach ($physicalMachine in $physicalMachines)
{
It ($BareMetalLocalizedStrings.TestNotVirtualMachine -f @($physicalMachine.ComputerName)) `
{
$physicalMachine.IsVirtualMachine | Should Be $true
}
}
}
# Validate Hyper-V support. Validation is based partially on code in http://wincode/View.aspx?File=%2f%2fdepot%2fth2%2fvm%2fsetup%2fServerManager%2fHyper-V%2fPlugin%2fHardwareDetectionUtilities.cs%232&SDPort=vmdepot.sys-ntgroup.ntdev.microsoft.com:2022&Query=VirtualizationFirmwareEnabled&Catalog=th2(dev)
foreach ($physicalMachine in $physicalMachines)
{
if ($physicalMachine.IsHyperVServiceRunning)
{
Trace-Execution "The Hyper-V service is running on physical machine $($physicalMachine.ComputerName). There is no need to check for virtualization support on this machine."
continue
}
It ($BareMetalLocalizedStrings.TestVMMonitorModeExtensions -f @($($physicalMachine.ComputerName))) `
{
($physicalMachine.Processors.HasVMMonitorModeExtensions | Measure-Object -Minimum).Minimum | Should Be $true
}
It ($BareMetalLocalizedStrings.TestVirtualizationIsEnabled -f @($($physicalMachine.ComputerName))) `
{
($physicalMachine.Processors.IsVirtualizationEnabled | Measure-Object -Minimum).Minimum | Should Be $true
}
It ($BareMetalLocalizedStrings.TestSecondLevelAddressTranslation -f @($($physicalMachine.ComputerName))) `
{
($physicalMachine.Processors.SupportsSecondLevelAddressTranslation | Measure-Object -Minimum).Minimum | Should Be $true
}
It ($BareMetalLocalizedStrings.TestDataExecutionPrevention -f @($($physicalMachine.ComputerName))) `
{
$physicalMachine.IsDataExecutionPreventionEnabled | Should Be $true
}
}
# Validate the OS version
foreach ($physicalMachine in $physicalMachines)
{
It ($BareMetalLocalizedStrings.TestOperatingSystemVersion -f @($physicalMachine.ComputerName)) `
{
New-Object Version($physicalMachine.OSVersion) | Should Not BeLessThan $minimumOperatingSystemVersion
}
}
# In the case of OneNode, validate the OS SKU is a Datacenter SKU.
if ($isOneNode)
{
It ($BareMetalLocalizedStrings.TestDatacenterSku -f @($env:COMPUTERNAME)) `
{
$serverDatacenterSku = 8
$serverDatacenterEvalSku = 80
($physicalMachine.OSSku -in @($serverDatacenterSku, $serverDatacenterEvalSku)) | Should Be $true
}
}
# In the case of OneNode, validate that the computer name is not AzureStack, because this is used as the domain name.
if ($isOneNode)
{
It ($BareMetalLocalizedStrings.TestComputerNameIsNotAzureStack -f @($env:COMPUTERNAME)) `
{
$env:COMPUTERNAME | Should Not Be 'AzureStack'
}
}
# In the case of OneNode, validate that the computer is not already joined to a domain.
if ($isOneNode)
{
It ($BareMetalLocalizedStrings.TestNotPartOfDomain -f @($env:COMPUTERNAME)) `
{
$physicalMachine.IsPartOfDomain | Should Be $false
}
}
# Validate the number of cores on each of the machines meets the required minimum.
if ($isVirtualizedDeployment)
{
foreach ($physicalMachine in $physicalMachines)
{
It ($BareMetalLocalizedStrings.TestMinimumNumberOfCores -f @($minimumNumberOfCoresPerMachine.ToString(), $physicalMachine.ComputerName)) `
{
($physicalMachine.Processors.NumberOfEnabledCores | Measure-Object -Sum).Sum | Should Not BeLessThan $minimumNumberOfCoresPerMachine
}
}
}
# Validate the amount of memory on each of the machines meets the required minimum.
if ($isVirtualizedDeployment)
{
foreach ($physicalMachine in $physicalMachines)
{
It ($BareMetalLocalizedStrings.TestMinimumPhysicalMemory -f @($minimumPhysicalMemoryPerMachineGB.ToString(), $physicalMachine.ComputerName)) `
{
($physicalMachine.TotalPhysicalMemory * $toleranceMultiplier) | Should Not BeLessThan ($minimumPhysicalMemoryPerMachineGB * 1GB)
}
}
}
# For multi-node, validate that each machine has the minimum required number of network adapters with the required speed.
if (-not $isOneNode)
{
foreach ($physicalMachine in $physicalMachines)
{
It ($BareMetalLocalizedStrings.TestMinimumNumberOfNetworkAdapters -f @($minimumNumberOfAdaptersPerMachine.ToString(),
$minimumAdapterSpeedBitsPerSecond.ToString(),
$($physicalMachine.ComputerName))) `
{
($physicalMachine.NetworkAdapters | ? Speed -ge $minimumAdapterSpeedBitsPerSecond).Count |
Should Not BeLessThan $minimumNumberOfAdaptersPerMachine
}
}
}
# For multi-node, validate that all machines have the same network adapter configuration in terms of speed and whether RDMA is enabled.
if (-not $isOneNode)
{
foreach ($physicalMachine in $physicalMachines)
{
if ($physicalMachine -eq $physicalMachines[0])
{
continue;
}
It ($BareMetalLocalizedStrings.TestSameNetworkAdapterConfiguration -f @($($physicalMachine.ComputerName),
$($physicalMachines[0].ComputerName))) `
{
$physicalMachine.NetworkAdapters.Count | Should Be $physicalMachines[0].NetworkAdapters.Count
# Adapters have already been sorted. We only need to compare each network adapter to the one with the same index on the other machine.
for ($i = 0; $i -lt $physicalMachine.NetworkAdapters.Count; $i++)
{
$physicalMachine.NetworkAdapters[$i] | Should Be $physicalMachines[0].NetworkAdapters[$i]
}
}
}
}
# Validate the size of the system disk.
It ($BareMetalLocalizedStrings.TestSystemDiskMeetsMinimumSize -f @($physicalMachine.ComputerName,
$minimumSizeOfSystemDiskGB.ToString())) `
{
($physicalMachine.SystemDisk.Size * $toleranceMultiplier) | Should Not BeLessThan ($minimumSizeOfSystemDiskGB * 1GB)
}
# $disksUnion is the minimum-size superset of all disks. It is calculated to allow for performing checks even if some machines are missing some disks.
foreach ($physicalMachine in $physicalMachines)
{
$combinedListOfDisksOnAllMachines += $physicalMachine.NonSystemDisks
}
$combinedListOfDisksOnAllMachines = ($combinedListOfDisksOnAllMachines | sort)
$disksUnion = @($combinedListOfDisksOnAllMachines[0])
for ($i = 1; $i -lt $combinedListOfDisksOnAllMachines.Count; $i++)
{
if ($combinedListOfDisksOnAllMachines[$i].BusType -ne $combinedListOfDisksOnAllMachines[$i-1].BusType -or
$combinedListOfDisksOnAllMachines[$i].IndexWithinSimilarDisks -ne $combinedListOfDisksOnAllMachines[$i-1].IndexWithinSimilarDisks -or
($combinedListOfDisksOnAllMachines[$i].Size * $toleranceMultiplier) -lt $combinedListOfDisksOnAllMachines[$i-1].Size -or
$combinedListOfDisksOnAllMachines[$i].Size -gt ($combinedListOfDisksOnAllMachines[$i-1].Size * $toleranceMultiplier))
{
# Disk does not have the same properties as the previous disks (Comparison with only one
# disk is sufficent because the disks have been sorted). Include disk in union.
$disksUnion += $combinedListOfDisksOnAllMachines[$i]
}
}
# Validate that the machines have at least the minimum number of required data disks that meet the minimum required size.
It ($BareMetalLocalizedStrings.TestNumberOfDisksMeetingMinimumSize -f @($minimumNumberOfDataDisksPerMachine.ToString(),
$minimumSizeOfDataDisksGB.ToString(),
$physicalMachine.ComputerName)) `
{
if ($isOneNode)
{
$supportedBusTypes = @('SATA', 'SAS', 'RAID', 'NVMe')
}
else
{
$supportedBusTypes = @('SATA', 'SAS', 'NVMe')
}
(($disksUnion | ? BusType -in $supportedBusTypes | sort -Property Size -Descending |
select -Skip ($minimumNumberOfDataDisksPerMachine-1) -First 1 -ExpandProperty Size) * $toleranceMultiplier) |
Should Not BeLessThan ($minimumSizeOfDataDisksGB * 1GB)
}
# For multi-node, validate that the number of disks that may be missing from any machine compared to other machines is not more than the maximum.
if (-not $isOneNode)
{
foreach ($physicalMachine in $physicalMachines)
{
It ($BareMetalLocalizedStrings.TestMaximumMissingDisksPerMachine -f @($maximumNumberOfMissingDisksPerMachine.ToString(),
$physicalMachine.ComputerName)) `
{
($disksUnion.Count - $physicalMachine.NonSystemDisks.Count) | Should Not BeGreaterThan $maximumNumberOfMissingDisksPerMachine
}
}
}
}
# SIG # Begin signature block
# MIIkWAYJKoZIhvcNAQcCoIIkSTCCJEUCAQExDzANBglghkgBZQMEAgEFADB5Bgor
# BgEEAYI3AgEEoGswaTA0BgorBgEEAYI3AgEeMCYCAwEAAAQQH8w7YFlLCE63JNLG
# KX7zUQIBAAIBAAIBAAIBAAIBADAxMA0GCWCGSAFlAwQCAQUABCBjDMN+D61uPMUu
# bVMHPDOv4RiJSm/OfpegnFZy7IAj9KCCDYEwggX/MIID56ADAgECAhMzAAABUZ6N
# j0Bxow5BAAAAAAFRMA0GCSqGSIb3DQEBCwUAMH4xCzAJBgNVBAYTAlVTMRMwEQYD
# VQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNy
# b3NvZnQgQ29ycG9yYXRpb24xKDAmBgNVBAMTH01pY3Jvc29mdCBDb2RlIFNpZ25p
# bmcgUENBIDIwMTEwHhcNMTkwNTAyMjEzNzQ2WhcNMjAwNTAyMjEzNzQ2WjB0MQsw
# CQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9u
# ZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMR4wHAYDVQQDExVNaWNy
# b3NvZnQgQ29ycG9yYXRpb24wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB
# AQCVWsaGaUcdNB7xVcNmdfZiVBhYFGcn8KMqxgNIvOZWNH9JYQLuhHhmJ5RWISy1
# oey3zTuxqLbkHAdmbeU8NFMo49Pv71MgIS9IG/EtqwOH7upan+lIq6NOcw5fO6Os
# +12R0Q28MzGn+3y7F2mKDnopVu0sEufy453gxz16M8bAw4+QXuv7+fR9WzRJ2CpU
# 62wQKYiFQMfew6Vh5fuPoXloN3k6+Qlz7zgcT4YRmxzx7jMVpP/uvK6sZcBxQ3Wg
# B/WkyXHgxaY19IAzLq2QiPiX2YryiR5EsYBq35BP7U15DlZtpSs2wIYTkkDBxhPJ
# IDJgowZu5GyhHdqrst3OjkSRAgMBAAGjggF+MIIBejAfBgNVHSUEGDAWBgorBgEE
# AYI3TAgBBggrBgEFBQcDAzAdBgNVHQ4EFgQUV4Iarkq57esagu6FUBb270Zijc8w
# UAYDVR0RBEkwR6RFMEMxKTAnBgNVBAsTIE1pY3Jvc29mdCBPcGVyYXRpb25zIFB1
# ZXJ0byBSaWNvMRYwFAYDVQQFEw0yMzAwMTIrNDU0MTM1MB8GA1UdIwQYMBaAFEhu
# ZOVQBdOCqhc3NyK1bajKdQKVMFQGA1UdHwRNMEswSaBHoEWGQ2h0dHA6Ly93d3cu
# bWljcm9zb2Z0LmNvbS9wa2lvcHMvY3JsL01pY0NvZFNpZ1BDQTIwMTFfMjAxMS0w
# Ny0wOC5jcmwwYQYIKwYBBQUHAQEEVTBTMFEGCCsGAQUFBzAChkVodHRwOi8vd3d3
# Lm1pY3Jvc29mdC5jb20vcGtpb3BzL2NlcnRzL01pY0NvZFNpZ1BDQTIwMTFfMjAx
# MS0wNy0wOC5jcnQwDAYDVR0TAQH/BAIwADANBgkqhkiG9w0BAQsFAAOCAgEAWg+A
# rS4Anq7KrogslIQnoMHSXUPr/RqOIhJX+32ObuY3MFvdlRElbSsSJxrRy/OCCZdS
# se+f2AqQ+F/2aYwBDmUQbeMB8n0pYLZnOPifqe78RBH2fVZsvXxyfizbHubWWoUf
# NW/FJlZlLXwJmF3BoL8E2p09K3hagwz/otcKtQ1+Q4+DaOYXWleqJrJUsnHs9UiL
# crVF0leL/Q1V5bshob2OTlZq0qzSdrMDLWdhyrUOxnZ+ojZ7UdTY4VnCuogbZ9Zs
# 9syJbg7ZUS9SVgYkowRsWv5jV4lbqTD+tG4FzhOwcRQwdb6A8zp2Nnd+s7VdCuYF
# sGgI41ucD8oxVfcAMjF9YX5N2s4mltkqnUe3/htVrnxKKDAwSYliaux2L7gKw+bD
# 1kEZ/5ozLRnJ3jjDkomTrPctokY/KaZ1qub0NUnmOKH+3xUK/plWJK8BOQYuU7gK
# YH7Yy9WSKNlP7pKj6i417+3Na/frInjnBkKRCJ/eYTvBH+s5guezpfQWtU4bNo/j
# 8Qw2vpTQ9w7flhH78Rmwd319+YTmhv7TcxDbWlyteaj4RK2wk3pY1oSz2JPE5PNu
# Nmd9Gmf6oePZgy7Ii9JLLq8SnULV7b+IP0UXRY9q+GdRjM2AEX6msZvvPCIoG0aY
# HQu9wZsKEK2jqvWi8/xdeeeSI9FN6K1w4oVQM4Mwggd6MIIFYqADAgECAgphDpDS
# AAAAAAADMA0GCSqGSIb3DQEBCwUAMIGIMQswCQYDVQQGEwJVUzETMBEGA1UECBMK
# V2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0
# IENvcnBvcmF0aW9uMTIwMAYDVQQDEylNaWNyb3NvZnQgUm9vdCBDZXJ0aWZpY2F0
# ZSBBdXRob3JpdHkgMjAxMTAeFw0xMTA3MDgyMDU5MDlaFw0yNjA3MDgyMTA5MDla
# MH4xCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdS
# ZWRtb25kMR4wHAYDVQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xKDAmBgNVBAMT
# H01pY3Jvc29mdCBDb2RlIFNpZ25pbmcgUENBIDIwMTEwggIiMA0GCSqGSIb3DQEB
# AQUAA4ICDwAwggIKAoICAQCr8PpyEBwurdhuqoIQTTS68rZYIZ9CGypr6VpQqrgG
# OBoESbp/wwwe3TdrxhLYC/A4wpkGsMg51QEUMULTiQ15ZId+lGAkbK+eSZzpaF7S
# 35tTsgosw6/ZqSuuegmv15ZZymAaBelmdugyUiYSL+erCFDPs0S3XdjELgN1q2jz
# y23zOlyhFvRGuuA4ZKxuZDV4pqBjDy3TQJP4494HDdVceaVJKecNvqATd76UPe/7
# 4ytaEB9NViiienLgEjq3SV7Y7e1DkYPZe7J7hhvZPrGMXeiJT4Qa8qEvWeSQOy2u
# M1jFtz7+MtOzAz2xsq+SOH7SnYAs9U5WkSE1JcM5bmR/U7qcD60ZI4TL9LoDho33
# X/DQUr+MlIe8wCF0JV8YKLbMJyg4JZg5SjbPfLGSrhwjp6lm7GEfauEoSZ1fiOIl
# XdMhSz5SxLVXPyQD8NF6Wy/VI+NwXQ9RRnez+ADhvKwCgl/bwBWzvRvUVUvnOaEP
# 6SNJvBi4RHxF5MHDcnrgcuck379GmcXvwhxX24ON7E1JMKerjt/sW5+v/N2wZuLB
# l4F77dbtS+dJKacTKKanfWeA5opieF+yL4TXV5xcv3coKPHtbcMojyyPQDdPweGF
# RInECUzF1KVDL3SV9274eCBYLBNdYJWaPk8zhNqwiBfenk70lrC8RqBsmNLg1oiM
# CwIDAQABo4IB7TCCAekwEAYJKwYBBAGCNxUBBAMCAQAwHQYDVR0OBBYEFEhuZOVQ
# BdOCqhc3NyK1bajKdQKVMBkGCSsGAQQBgjcUAgQMHgoAUwB1AGIAQwBBMAsGA1Ud
# DwQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFHItOgIxkEO5FAVO
# 4eqnxzHRI4k0MFoGA1UdHwRTMFEwT6BNoEuGSWh0dHA6Ly9jcmwubWljcm9zb2Z0
# LmNvbS9wa2kvY3JsL3Byb2R1Y3RzL01pY1Jvb0NlckF1dDIwMTFfMjAxMV8wM18y
# Mi5jcmwwXgYIKwYBBQUHAQEEUjBQME4GCCsGAQUFBzAChkJodHRwOi8vd3d3Lm1p
# Y3Jvc29mdC5jb20vcGtpL2NlcnRzL01pY1Jvb0NlckF1dDIwMTFfMjAxMV8wM18y
# Mi5jcnQwgZ8GA1UdIASBlzCBlDCBkQYJKwYBBAGCNy4DMIGDMD8GCCsGAQUFBwIB
# FjNodHRwOi8vd3d3Lm1pY3Jvc29mdC5jb20vcGtpb3BzL2RvY3MvcHJpbWFyeWNw
# cy5odG0wQAYIKwYBBQUHAgIwNB4yIB0ATABlAGcAYQBsAF8AcABvAGwAaQBjAHkA
# XwBzAHQAYQB0AGUAbQBlAG4AdAAuIB0wDQYJKoZIhvcNAQELBQADggIBAGfyhqWY
# 4FR5Gi7T2HRnIpsLlhHhY5KZQpZ90nkMkMFlXy4sPvjDctFtg/6+P+gKyju/R6mj
# 82nbY78iNaWXXWWEkH2LRlBV2AySfNIaSxzzPEKLUtCw/WvjPgcuKZvmPRul1LUd
# d5Q54ulkyUQ9eHoj8xN9ppB0g430yyYCRirCihC7pKkFDJvtaPpoLpWgKj8qa1hJ
# Yx8JaW5amJbkg/TAj/NGK978O9C9Ne9uJa7lryft0N3zDq+ZKJeYTQ49C/IIidYf
# wzIY4vDFLc5bnrRJOQrGCsLGra7lstnbFYhRRVg4MnEnGn+x9Cf43iw6IGmYslmJ
# aG5vp7d0w0AFBqYBKig+gj8TTWYLwLNN9eGPfxxvFX1Fp3blQCplo8NdUmKGwx1j
# NpeG39rz+PIWoZon4c2ll9DuXWNB41sHnIc+BncG0QaxdR8UvmFhtfDcxhsEvt9B
# xw4o7t5lL+yX9qFcltgA1qFGvVnzl6UJS0gQmYAf0AApxbGbpT9Fdx41xtKiop96
# eiL6SJUfq/tHI4D1nvi/a7dLl+LrdXga7Oo3mXkYS//WsyNodeav+vyL6wuA6mk7
# r/ww7QRMjt/fdW1jkT3RnVZOT7+AVyKheBEyIXrvQQqxP/uozKRdwaGIm1dxVk5I
# RcBCyZt2WwqASGv9eZ/BvW1taslScxMNelDNMYIWLTCCFikCAQEwgZUwfjELMAkG
# A1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQx
# HjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEoMCYGA1UEAxMfTWljcm9z
# b2Z0IENvZGUgU2lnbmluZyBQQ0EgMjAxMQITMwAAAVGejY9AcaMOQQAAAAABUTAN
# BglghkgBZQMEAgEFAKCBrjAZBgkqhkiG9w0BCQMxDAYKKwYBBAGCNwIBBDAcBgor
# BgEEAYI3AgELMQ4wDAYKKwYBBAGCNwIBFTAvBgkqhkiG9w0BCQQxIgQgN8Bc9FSk
# 8kjAYMW4BmgBoTkeWLixZPUESgxCzA9pE+wwQgYKKwYBBAGCNwIBDDE0MDKgFIAS
# AE0AaQBjAHIAbwBzAG8AZgB0oRqAGGh0dHA6Ly93d3cubWljcm9zb2Z0LmNvbTAN
# BgkqhkiG9w0BAQEFAASCAQAa3huY7aEY7gU0UzcAS2uYeuSJUdpjGDXZXAiMHFQa
# YDGonlsABE1sW+aOmVZJu+jWy6DmB4oQRaepY+vWgYTYwGUqGxS3F9fJU/zqyIsd
# CTIjhxbeU540rS9U+yEfhDKuQDhD/M0U6+r6qYd2BdS8LiJ5TguNiE+HK9kkXtcx
# KfjsG7RT60sYv0BRwYzhAPD+JayzGGsA6G5d1/1vDFNQybAfbneGb72I9JrNjK9O
# 4vkXGQv0ZTN+3AVtqpxeFBSCzTkqaEF6uX7lS3j2gF8eHuW4LFJnIdJCWEcuPiLx
# cpbujrX4j4fTurBTeSA2ERirPow6krsYP6hinSf+VVEUoYITtzCCE7MGCisGAQQB
# gjcDAwExghOjMIITnwYJKoZIhvcNAQcCoIITkDCCE4wCAQMxDzANBglghkgBZQME
# AgEFADCCAVUGCyqGSIb3DQEJEAEEoIIBRASCAUAwggE8AgEBBgorBgEEAYRZCgMB
# MDEwDQYJYIZIAWUDBAIBBQAEIBJo7Ly5gCr25XZQDrroahGZ6Pq+67+gFRsFyAXj
# ghlIAgZdPyaQfvQYEzIwMTkwODE1MDgyODEwLjE0M1owBIACAfSggdSkgdEwgc4x
# CzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRt
# b25kMR4wHAYDVQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xKTAnBgNVBAsTIE1p
# Y3Jvc29mdCBPcGVyYXRpb25zIFB1ZXJ0byBSaWNvMSYwJAYDVQQLEx1UaGFsZXMg
# VFNTIEVTTjoxNDhDLUM0QjktMjA2NjElMCMGA1UEAxMcTWljcm9zb2Z0IFRpbWUt
# U3RhbXAgU2VydmljZaCCDyIwggT1MIID3aADAgECAhMzAAAA1acj5XiVagn/AAAA
# AADVMA0GCSqGSIb3DQEBCwUAMHwxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNo
# aW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNyb3NvZnQgQ29y
# cG9yYXRpb24xJjAkBgNVBAMTHU1pY3Jvc29mdCBUaW1lLVN0YW1wIFBDQSAyMDEw
# MB4XDTE4MDgyMzIwMjY0NVoXDTE5MTEyMzIwMjY0NVowgc4xCzAJBgNVBAYTAlVT
# MRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQK
# ExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xKTAnBgNVBAsTIE1pY3Jvc29mdCBPcGVy
# YXRpb25zIFB1ZXJ0byBSaWNvMSYwJAYDVQQLEx1UaGFsZXMgVFNTIEVTTjoxNDhD
# LUM0QjktMjA2NjElMCMGA1UEAxMcTWljcm9zb2Z0IFRpbWUtU3RhbXAgU2Vydmlj
# ZTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMIUCSuuF/E0gjL87onw
# du50M1BwUxQwtrZWEQYCmLMhGhNR/3eQxBD9lqY4FYxhRZ1bxfsIjs7SKvcF0m1Y
# fhgK5j9BdZvzueedkEY8MVUu41zB18dn+Nmaelz5vFz9BLq5hJPAEdZg3ZR+4dP7
# 19tVXJP/iVkslLTTKH/YqT8VciemXOUaCsK/Re7xdBe8qBShsOwbgD7xVYwgmevz
# +bSZ3UsWClccBB9kMhNHhniIKkuMo4BNJ5te+yp8KBVyzontKmtOhS1XKNSIywEW
# AzRGKZtlP36DVGOy9SGajweV0RjHkqZMUD1tEiIaDoBpiZXacHPne1FQGwSjK4NM
# lEsCAwEAAaOCARswggEXMB0GA1UdDgQWBBQpaKMxlHZD2V9dDZuf07KE9mI3hDAf
# BgNVHSMEGDAWgBTVYzpcijGQ80N7fEYbxTNoWoVtVTBWBgNVHR8ETzBNMEugSaBH
# hkVodHRwOi8vY3JsLm1pY3Jvc29mdC5jb20vcGtpL2NybC9wcm9kdWN0cy9NaWNU
# aW1TdGFQQ0FfMjAxMC0wNy0wMS5jcmwwWgYIKwYBBQUHAQEETjBMMEoGCCsGAQUF
# BzAChj5odHRwOi8vd3d3Lm1pY3Jvc29mdC5jb20vcGtpL2NlcnRzL01pY1RpbVN0
# YVBDQV8yMDEwLTA3LTAxLmNydDAMBgNVHRMBAf8EAjAAMBMGA1UdJQQMMAoGCCsG
# AQUFBwMIMA0GCSqGSIb3DQEBCwUAA4IBAQB52cvC6cTRwKstDtImv9pnoAv99sC2
# wQLy4rmBzWL2kI/sleBNXo74cqdAWoYfLRCQo+DuW2m5/0mMe4DpvPDLYCQSSJkA
# tu/hUL80wik5ZqaNvIfp7h1/CJ/KMuIgd8WbhNZxLyG5S4W7As667QNifweCrjFq
# ZMV9XtBO2wjz9Qti1RjdOImhX7V4kdCYKStdQg2xJhUU9ZtPqGprthaPqto9Fheq
# s37Cw2vO3tAjYqMXTZCvybz+4bUHxIWvqvJIXLpuPPz1zCvCotLfBzzBiV9miIEB
# Xsnv2qIIkdDnISqlrIZ1nXdRHdXl4ZhBf3wAZR/EwILvKaksKFYzrk4LMIIGcTCC
# BFmgAwIBAgIKYQmBKgAAAAAAAjANBgkqhkiG9w0BAQsFADCBiDELMAkGA1UEBhMC
# VVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNV
# BAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEyMDAGA1UEAxMpTWljcm9zb2Z0IFJv
# b3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IDIwMTAwHhcNMTAwNzAxMjEzNjU1WhcN
# MjUwNzAxMjE0NjU1WjB8MQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3Rv
# bjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0
# aW9uMSYwJAYDVQQDEx1NaWNyb3NvZnQgVGltZS1TdGFtcCBQQ0EgMjAxMDCCASIw
# DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKkdDbx3EYo6IOz8E5f1+n9plGt0
# VBDVpQoAgoX77XxoSyxfxcPlYcJ2tz5mK1vwFVMnBDEfQRsalR3OCROOfGEwWbEw
# RA/xYIiEVEMM1024OAizQt2TrNZzMFcmgqNFDdDq9UeBzb8kYDJYYEbyWEeGMoQe
# dGFnkV+BVLHPk0ySwcSmXdFhE24oxhr5hoC732H8RsEnHSRnEnIaIYqvS2SJUGKx
# Xf13Hz3wV3WsvYpCTUBR0Q+cBj5nf/VmwAOWRH7v0Ev9buWayrGo8noqCjHw2k4G
# kbaICDXoeByw6ZnNPOcvRLqn9NxkvaQBwSAJk3jN/LzAyURdXhacAQVPIk0CAwEA
# AaOCAeYwggHiMBAGCSsGAQQBgjcVAQQDAgEAMB0GA1UdDgQWBBTVYzpcijGQ80N7
# fEYbxTNoWoVtVTAZBgkrBgEEAYI3FAIEDB4KAFMAdQBiAEMAQTALBgNVHQ8EBAMC
# AYYwDwYDVR0TAQH/BAUwAwEB/zAfBgNVHSMEGDAWgBTV9lbLj+iiXGJo0T2UkFvX
# zpoYxDBWBgNVHR8ETzBNMEugSaBHhkVodHRwOi8vY3JsLm1pY3Jvc29mdC5jb20v
# cGtpL2NybC9wcm9kdWN0cy9NaWNSb29DZXJBdXRfMjAxMC0wNi0yMy5jcmwwWgYI
# KwYBBQUHAQEETjBMMEoGCCsGAQUFBzAChj5odHRwOi8vd3d3Lm1pY3Jvc29mdC5j
# b20vcGtpL2NlcnRzL01pY1Jvb0NlckF1dF8yMDEwLTA2LTIzLmNydDCBoAYDVR0g
# AQH/BIGVMIGSMIGPBgkrBgEEAYI3LgMwgYEwPQYIKwYBBQUHAgEWMWh0dHA6Ly93
# d3cubWljcm9zb2Z0LmNvbS9QS0kvZG9jcy9DUFMvZGVmYXVsdC5odG0wQAYIKwYB
# BQUHAgIwNB4yIB0ATABlAGcAYQBsAF8AUABvAGwAaQBjAHkAXwBTAHQAYQB0AGUA
# bQBlAG4AdAAuIB0wDQYJKoZIhvcNAQELBQADggIBAAfmiFEN4sbgmD+BcQM9naOh
# IW+z66bM9TG+zwXiqf76V20ZMLPCxWbJat/15/B4vceoniXj+bzta1RXCCtRgkQS
# +7lTjMz0YBKKdsxAQEGb3FwX/1z5Xhc1mCRWS3TvQhDIr79/xn/yN31aPxzymXlK
# kVIArzgPF/UveYFl2am1a+THzvbKegBvSzBEJCI8z+0DpZaPWSm8tv0E4XCfMkon
# /VWvL/625Y4zu2JfmttXQOnxzplmkIz/amJ/3cVKC5Em4jnsGUpxY517IW3DnKOi
# PPp/fZZqkHimbdLhnPkd/DjYlPTGpQqWhqS9nhquBEKDuLWAmyI4ILUl5WTs9/S/
# fmNZJQ96LjlXdqJxqgaKD4kWumGnEcua2A5HmoDF0M2n0O99g/DhO3EJ3110mCII
# YdqwUB5vvfHhAN/nMQekkzr3ZUd46PioSKv33nJ+YWtvd6mBy6cJrDm77MbL2IK0
# cs0d9LiFAR6A+xuJKlQ5slvayA1VmXqHczsI5pgt6o3gMy4SKfXAL1QnIffIrE7a
# KLixqduWsqdCosnPGUFN4Ib5KpqjEWYw07t0MkvfY3v1mYovG8chr1m1rtxEPJdQ
# cdeh0sVV42neV8HR3jDA/czmTfsNv11P6Z0eGTgvvM9YBS7vDaBQNdrvCScc1bN+
# NR4Iuto229Nfj950iEkSoYIDsDCCApgCAQEwgf6hgdSkgdEwgc4xCzAJBgNVBAYT
# AlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYD
# VQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xKTAnBgNVBAsTIE1pY3Jvc29mdCBP
# cGVyYXRpb25zIFB1ZXJ0byBSaWNvMSYwJAYDVQQLEx1UaGFsZXMgVFNTIEVTTjox
# NDhDLUM0QjktMjA2NjElMCMGA1UEAxMcTWljcm9zb2Z0IFRpbWUtU3RhbXAgU2Vy
# dmljZaIlCgEBMAkGBSsOAwIaBQADFQCtwyS80dl18F3Q3UUfOTGebtaesaCB3jCB
# 26SB2DCB1TELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNV
# BAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEpMCcG
# A1UECxMgTWljcm9zb2Z0IE9wZXJhdGlvbnMgUHVlcnRvIFJpY28xJzAlBgNVBAsT
# Hm5DaXBoZXIgTlRTIEVTTjo1N0Y2LUMxRTAtNTU0QzErMCkGA1UEAxMiTWljcm9z
# b2Z0IFRpbWUgU291cmNlIE1hc3RlciBDbG9jazANBgkqhkiG9w0BAQUFAAIFAOD/
# ZMYwIhgPMjAxOTA4MTUxMjU3NDJaGA8yMDE5MDgxNjEyNTc0MlowdzA9BgorBgEE
# AYRZCgQBMS8wLTAKAgUA4P9kxgIBADAKAgEAAgIXtQIB/zAHAgEAAgIYWDAKAgUA
# 4QC2RgIBADA2BgorBgEEAYRZCgQCMSgwJjAMBgorBgEEAYRZCgMBoAowCAIBAAID
# B6EgoQowCAIBAAIDB6EgMA0GCSqGSIb3DQEBBQUAA4IBAQDBgvAxiKFLeeT0hB1Y
# Tx6QE7j+AZnFUzikHZ63ysIelO3sSOIlL95ZcMFhpFibvTBldIqXttijClwsrX08
# cZzj7mI7SkZf4MueKY7fXNu2oAMaQci67y+Geo9uoN2RI0Sy32de0Ha+Xnb/PM7M
# 2hwBibw2nYKEF7BKH9jx7kX/mho9HAoc5VzawuUrlufVsWqV8dsvFcBqaOq7gShx
# kxejh6paJz0UCrO6L+5ePXZ3EYLGHLHyOvZOBIHdkSeUrrPPZyFTxnZHwSUtC5fS
# HyetvEcZ6US7299P5JIWEO9+QzeoCSzAkSskC2s3CbMdGtY/q35PwY/CIusUc0l1
# SGUcMYIC9TCCAvECAQEwgZMwfDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hp
# bmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jw
# b3JhdGlvbjEmMCQGA1UEAxMdTWljcm9zb2Z0IFRpbWUtU3RhbXAgUENBIDIwMTAC
# EzMAAADVpyPleJVqCf8AAAAAANUwDQYJYIZIAWUDBAIBBQCgggEyMBoGCSqGSIb3
# DQEJAzENBgsqhkiG9w0BCRABBDAvBgkqhkiG9w0BCQQxIgQgyGlMFOmhYMKcYevJ
# 462GJKJPvp/b6OkHp2cm5QgdxxcwgeIGCyqGSIb3DQEJEAIMMYHSMIHPMIHMMIGx
# BBStwyS80dl18F3Q3UUfOTGebtaesTCBmDCBgKR+MHwxCzAJBgNVBAYTAlVTMRMw
# EQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVN
# aWNyb3NvZnQgQ29ycG9yYXRpb24xJjAkBgNVBAMTHU1pY3Jvc29mdCBUaW1lLVN0
# YW1wIFBDQSAyMDEwAhMzAAAA1acj5XiVagn/AAAAAADVMBYEFNFDfAWvn2fpcC4T
# kL+KEq5Te55SMA0GCSqGSIb3DQEBCwUABIIBABnq/RH7vrYyv8D9r/kNRjzdXqZ7
# QLf4Zc0dD912qL/c5D5FA/oK0bNcHPP9Ag04IBQC7LU9HJoegpONjtaq5uKADofk
# AnJjLTHR5gJaVmgpVMVo+29GWYQfncIpK4vbFlJTgSpAHf50rXC7NBwm+MsL0dFW
# X48bKLceVC6+bPHXYcqvWK1CQUBgXNnN9MgzDD0kgJSyHvBuMTYnTdkYBojRnRHO
# dVxY2+UXwle12VSmK3xhGHYT4+luH2K1Hne04wttUx5nJD+peXx7wjsX5RCXZUlc
# vTus+izrjXKqzyLsiYEb/54Q8XDxwgtGfza26rQJGKC6YoLqdF5mMcJij0c=
# SIG # End signature block
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.