public/cbb/Get-MBSBackupPlan.ps1

function Get-MBSBackupPlan {
    <#
    .SYNOPSIS
        Get backup plans from MBS backup agent.
    .EXAMPLE
        PS C:\> Get-MBSBackupPlan -StorageType All -PlanFormat All -PlanType All
        Lists all backup plans
    .EXAMPLE
        PS C:\> Get-MBSBackupPlan -StorageType Local -PlanFormat All -PlanType All
        Lists only backup plans with a local destination.
    .EXAMPLE
        PS C:\> Get-MBSBackupPlan -StorageType Cloud -PlanFormat All -PlanType All
        Lists only backup plans with a cloud destination.
    .EXAMPLE
        PS C:\> Get-MBSBackupPlan -StorageType All -PlanFormat CBF -PlanType All
        Lists all CBF (Legacy) backup plans.
    .EXAMPLE
        PS C:\> Get-MBSBackupPlan -StorageType All -PlanFormat NBF -PlanType All
        Lists all NBF backup plans.
    .EXAMPLE
        PS C:\> Get-MBSBackupPlan -StorageType All -PlanFormat All -PlanType File-Level
        Lists all File-level backup plans.
    .EXAMPLE
        PS C:\> Get-MBSBackupPlan -StorageType All -PlanFormat All -PlanType Image-Based
        Lists all Image-Based backup plans.
    .EXAMPLE
        PS C:\> Get-MBSBackupPlan -StorageType Local -PlanFormat CBF -PlanType Image-Based
        Lists CBF (Legacy) Image-Based backup plans with a local destination.
    .EXAMPLE
        PS C:\> Get-MBSBackupPlan -StorageType All -PlanFormat All -PlanType All -OutputType Full
        Get extended parameters of all backup plans.
    .INPUTS
        None
    .OUTPUTS
        System.Management.Automation.PSCustomObject
    .NOTES
        Author: MSP360 Onboarding Team
    .LINK
        https://mspbackups.com/AP/Help/powershell/cmdlets/backup-agent/get-mbsbackupplan
    #>

    [CmdletBinding()]
    param (
        #
        [Parameter(Mandatory=$false, HelpMessage="Backup destination storage type")]
        [ValidateSet("All", "Local", "Cloud", "Hybrid")]
        [string]
        $StorageType = "All",
        #
        [Parameter(Mandatory=$false, HelpMessage="Backup plan format")]
        [ValidateSet("All", "CBF", "Legacy", "NBF")]
        [string]
        $PlanFormat = "All",
        #
        [Parameter(Mandatory=$false, HelpMessage="Backup plan type")]
        [ValidateSet("All", "File-Level", "Image-Based", "MSSQL","MSExchange","VMware","Hyper-V")]
        [string]
        $PlanType = "All",
        #
        [Parameter(Mandatory=$false, HelpMessage="Output type")]
        [ValidateSet("Short", "Full", "Raw")]
        [string]
        $OutputType = "Short"
    )

    begin {
        if (-not($CBB = Get-MBSAgent)) {
            Break
        }
    }

    process {
    function Compare-StorageTypes {
        param (
            $Account,
            [string]$StorageType
        )

        $result = $false
        switch -exact ($StorageType) {
            "All" {$result = $true}
            "Cloud" { 
                if($Account.SGCloudTypeValue -ne "FileSystemConnection" -and $Account.SGCloudTypeValue -ne "PhysicalFile" -and $BackupPlanConvertedObject.HybridID -eq "00000000-0000-0000-0000-000000000000"){
                    $result = $true 
                }else {
                    $result = $false
                }
            }
            "Local" {
                if($Account.Type -eq "FileSystemConnection" -or $Account.SGCloudTypeValue -eq "PhysicalFile"){
                    $result = $true 
                }else {
                    $result = $false
                }
            }
            "Hybrid" {
                if ($BackupPlanConvertedObject.HybridID -ne "00000000-0000-0000-0000-000000000000") {
                    $result = $true 
                }else {
                    $result = $false
                }
            }
            Default {}
        }
        return $result
    }

    function Convert-Output {
        param (
            $InputArray
        )
        $OutputResult = $null
        switch ($OutputType) {
            "Short" {
                $OutputResult = $InputArray | Select-Object ID, Name, Type, Bucket, ConnectionID, UseEncryption, UseCompression, Items, ExcludedItems, DiskInfo, Schedule, ForceFullSchedule
            }
            "Full" {
                $OutputResult = $InputArray | Select-Object -Property * -ExcludeProperty xsd, xsi, Tag
            }
            "Raw" {
                $OutputResult = $InputArray | Select-Object *
            }
            Default {Write-Error -message "Incorrect OutputType parameter"}
        }
        return $OutputResult
    }

    function Convert-NBFFileLevelOutput {
        param (
            $BackupPlanNBFConverted
        )
        $NBFFileLevelOutputResult = New-Object -TypeName MBS.Agent.Plan.NBFFileLevelBackupPlan -Property @{
            Name = $BackupPlanNBFConverted.Name
            ID = $BackupPlanNBFConverted.ID
            StorageAccount = Get-MBSStorageAccount -ID $BackupPlanNBFConverted.ConnectionID
            BackupPlanCommonOption = New-Object -TypeName MBS.Agent.Plan.NBFBackupPlanCommonOption -Property @{
                SyncRepositoryBeforeRun = $BackupPlanNBFConverted.SyncBeforeRun
                UseServerSideEncryption = $BackupPlanNBFConverted.UseServerSideEncryption
                EncryptionAlgorithm = ($BackupPlanNBFConverted.EncryptionAlgorithm+$BackupPlanNBFConverted.EncryptionKeySize)
                EncryptionPassword = $(if($BackupPlanNBFConverted.UseEncryption){ConvertTo-SecureString -string "!<encrypted_string>!" -AsPlainText -Force}else{$null})
                UseCompression = $BackupPlanNBFConverted.UseCompression
                StorageClass = ([MBS.Agent.Plan.StorageClassCBB]$BackupPlanNBFConverted.StorageClass).value__
                FullConsistencyCheck = $BackupPlanNBFConverted.UseFullConsistencyCheck
                StopIfPlanRunsFor = $(if($BackupPlanNBFConverted.Schedule.StopAfterTicks -eq "9223372036854775807"){[timespan]"00:00:00"}else{[timespan]$BackupPlanNBFConverted.Schedule.StopAfterTicks})
                RunMissedPlanImmediately = $BackupPlanNBFConverted.ForceMissedSchedule
                PreActionCommand = $(if($BackupPlanNBFConverted.Actions.Pre.Enabled){$BackupPlanNBFConverted.Actions.Pre.CommandLine + " " + $BackupPlanNBFConverted.Actions.Pre.Arguments})
                PreActionContinueAnyway = $(if($BackupPlanNBFConverted.Actions.Pre.Enabled){-not $BackupPlanNBFConverted.Actions.Pre.TerminateOnFailure})
                PostActionCommand = $(if($BackupPlanNBFConverted.Actions.Post.Enabled){$BackupPlanNBFConverted.Actions.Post.CommandLine + " " + $BackupPlanNBFConverted.Actions.Post.Arguments})
                PostActionRunAnyway = $(if($BackupPlanNBFConverted.Actions.Post.Enabled){$BackupPlanNBFConverted.Actions.Post.RunOnBackupFailure})
                BackupChainPlanID = $(if($BackupPlanNBFConverted.ExecuteNextPlan){$BackupPlanNBFConverted.NextExectutionPlan})
                BackupChainExecuteOnlyAfterSuccess = $(if($BackupPlanNBFConverted.ExecuteNextPlan){$BackupPlanNBFConverted.ExecuteNextPlanOnlyIfSucces})
                BackupChainExecuteForceFull = $(if($BackupPlanNBFConverted.ExecuteNextPlan){$BackupPlanNBFConverted.ForceFullNextPlan})
                ResultEmailNotification = $(if($BackupPlanNBFConverted.Notification.SendNotification -and $BackupPlanNBFConverted.Notification.OnlyOnFailure){
                    [MBS.Agent.Plan.Notification]"errorOnly"
                }elseif ($BackupPlanNBFConverted.Notification.SendNotification -and -not $BackupPlanNBFConverted.Notification.OnlyOnFailure) {
                    [MBS.Agent.Plan.Notification]"on"
                }elseif (-not $BackupPlanNBFConverted.Notification.SendNotification) {
                    [MBS.Agent.Plan.Notification]"off"
                })
                AddEventToWindowsLog = $(if($BackupPlanNBFConverted.WindowsEventLogNotification.SendNotification -and $BackupPlanNBFConverted.WindowsEventLogNotification.OnlyOnFailure){
                    [MBS.Agent.Plan.Notification]"errorOnly"
                }elseif ($BackupPlanNBFConverted.WindowsEventLogNotification.SendNotification -and -not $BackupPlanNBFConverted.WindowsEventLogNotification.OnlyOnFailure) {
                    [MBS.Agent.Plan.Notification]"on"
                }elseif (-not $BackupPlanNBFConverted.WindowsEventLogNotification.SendNotification) {
                    [MBS.Agent.Plan.Notification]"off"
                })
                ForeverForwardIncremental = $BackupPlanNBFConverted.ForwardIncremental
                IntelligentRetention = $BackupPlanNBFConverted.AutomaticallyReduceEarlyDeletionFee
                KeepVersionPeriod = $(if($BackupPlanNBFConverted.SerializationSupportRetentionTime -eq "10675199.02:48:05.4775807") {
                    $null
                }else{
                    [int]([timespan]$BackupPlanNBFConverted.SerializationSupportRetentionTime).TotalDays
                })
                GFSKeepWeekly = $(if($BackupPlanNBFConverted.GFSPolicySettings.IsEnabled -and $BackupPlanNBFConverted.GFSPolicySettings.Weekly.IsEnabled){
                    $BackupPlanNBFConverted.GFSPolicySettings.Weekly.StorePeriod
                }else {
                    $null
                })
                GFSKeepMonthly = $(if($BackupPlanNBFConverted.GFSPolicySettings.IsEnabled -and $BackupPlanNBFConverted.GFSPolicySettings.Monthly.IsEnabled){
                    $BackupPlanNBFConverted.GFSPolicySettings.Monthly.StorePeriod
                }else {
                    $null
                })
                GFSKeepYearly = $(if($BackupPlanNBFConverted.GFSPolicySettings.IsEnabled -and $BackupPlanNBFConverted.GFSPolicySettings.Yearly.IsEnabled){
                    $BackupPlanNBFConverted.GFSPolicySettings.Yearly.StorePeriod
                }else {
                    $null
                })
                GFSMonthOfTheYear = $(if($BackupPlanNBFConverted.GFSPolicySettings.IsEnabled -and $BackupPlanNBFConverted.GFSPolicySettings.Yearly.IsEnabled){
                    $BackupPlanNBFConverted.GFSPolicySettings.Yearly.TakeBackupFromMonth
                }else {
                    0
                })
            }
            Schedule = $(if($BackupPlanNBFConverted.Schedule.Enabled){
                New-Object -TypeName MBS.Agent.Plan.NBFIncrementalSchedule -Property @{
                    Frequency = $(if (($BackupPlanNBFConverted.Schedule.RecurType -eq "Weekly") -And (-not (Compare-Object -ReferenceObject $BackupPlanNBFConverted.Schedule.WeekDays.DayOfWeek -DifferenceObject @("Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday")))) {
                        "Daily"
                    }else {
                        $BackupPlanNBFConverted.Schedule.RecurType
                    })
                    At = $(if (-not $BackupPlanNBFConverted.Schedule.DailyRecurrence) {
                        [datetime]"$($BackupPlanNBFConverted.Schedule.Hour):$($BackupPlanNBFConverted.Schedule.Minutes)"
                    }else{
                        [datetime]"1/1/0001 0:00:00"
                    })
                    DayOfMonth = $(if ($BackupPlanNBFConverted.Schedule.RecurType -eq "DayOfMonth") {
                        $BackupPlanNBFConverted.Schedule.DayOfMonth
                    }else{
                        $null
                    })
                    DayOfWeek = $(if (($BackupPlanNBFConverted.Schedule.RecurType -eq "Weekly") -And (Compare-Object -ReferenceObject $BackupPlanNBFConverted.Schedule.WeekDays.DayOfWeek -DifferenceObject @("Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"))) {
                        $BackupPlanNBFConverted.Schedule.WeekDays.DayOfWeek
                    }elseif($BackupPlanNBFConverted.Schedule.RecurType -eq "Monthly") {
                        $BackupPlanNBFConverted.Schedule.DayOfWeek
                    }else{
                        $null
                    })
                    WeekNumber = $(if ($BackupPlanNBFConverted.Schedule.RecurType -eq "Monthly") {
                        $BackupPlanNBFConverted.Schedule.WeekNumber
                    }else {
                        $null
                    })
                    OccursFrom =  $(if ($BackupPlanNBFConverted.Schedule.DailyRecurrence) {
                        [timespan]"$($BackupPlanNBFConverted.Schedule.DailyFromHour):$($BackupPlanNBFConverted.Schedule.DailyFromMinutes)"
                    }else{
                        [timespan]"00:00:00"
                    })
                    OccursTo =  $(if ($BackupPlanNBFConverted.Schedule.DailyRecurrence) {
                        [timespan]"$($BackupPlanNBFConverted.Schedule.DailyTillHour):$($BackupPlanNBFConverted.Schedule.DailyTillMinutes)"
                    }else{
                        [timespan]"00:00:00"
                    })
                    OccursEvery =  $(if ($BackupPlanNBFConverted.Schedule.DailyRecurrence) {
                        New-TimeSpan -Minutes $BackupPlanNBFConverted.Schedule.DailyRecurrencePeriod
                    }else{
                        [timespan]"00:00:00"
                    })
                    RepeatInterval = $BackupPlanNBFConverted.Schedule.RepeatEvery
                    RepeatStartDate = $BackupPlanNBFConverted.Schedule.OnceDate
                }
            }else {
                $null
            })
            ForceFullSchedule = $(if($BackupPlanNBFConverted.ForceFullSchedule.Enabled){
                New-Object -TypeName MBS.Agent.Plan.NBFFullSchedule -Property @{
                    Frequency = $(if (($BackupPlanNBFConverted.ForceFullSchedule.RecurType -eq "Weekly") -And (-not (Compare-Object -ReferenceObject $BackupPlanNBFConverted.ForceFullSchedule.WeekDays.DayOfWeek -DifferenceObject @("Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday")))) {
                        "Daily"
                    }else {
                        $BackupPlanNBFConverted.ForceFullSchedule.RecurType
                    })
                    DayOfMonth = $(if ($BackupPlanNBFConverted.ForceFullSchedule.RecurType -eq "DayOfMonth") {
                        $BackupPlanNBFConverted.ForceFullSchedule.DayOfMonth
                    }else{
                        $null
                    })
                    DayOfWeek = $(if (($BackupPlanNBFConverted.ForceFullSchedule.RecurType -eq "Weekly") -And (Compare-Object -ReferenceObject $BackupPlanNBFConverted.ForceFullSchedule.WeekDays.DayOfWeek -DifferenceObject @("Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"))) {
                        $BackupPlanNBFConverted.ForceFullSchedule.WeekDays.DayOfWeek
                    }elseif($BackupPlanNBFConverted.ForceFullSchedule.RecurType -eq "Monthly") {
                        $BackupPlanNBFConverted.ForceFullSchedule.DayOfWeek
                    }else{
                        $null
                    })
                    WeekNumber = $(if ($BackupPlanNBFConverted.ForceFullSchedule.RecurType -eq "Monthly") {
                        $BackupPlanNBFConverted.ForceFullSchedule.WeekNumber
                    }else {
                        $null
                    })
                    RepeatInterval = $BackupPlanNBFConverted.ForceFullSchedule.RepeatEvery
                    RepeatStartDate = $BackupPlanNBFConverted.ForceFullSchedule.OnceDate
                }
            }else {
                $null
            })
            BackupNTFSPermissions = $BackupPlanNBFConverted.BackupNTFSPermissions
            FastNTFSScan = $BackupPlanNBFConverted.UseFastNtfsScan
            ForceUsingVSS = $BackupPlanNBFConverted.AlwaysUseVSS
            KeepEFSEncryption = $BackupPlanNBFConverted.BackupEfsFilesAsIs
            UseShareReadWriteModeOnError = $BackupPlanNBFConverted.UseShareReadWriteModeOnError
            BackupEmptyFolders = $BackupPlanNBFConverted.BackupEmptyFolders
            BackupOnlyAfter = [datetime]$BackupPlanNBFConverted.BackupOnlyAfterUTC
            ExcludeSystemHiddenFiles = -not $BackupPlanNBFConverted.BackupFilter.IncludeSystemAndHidden
            SkipFolder = $BackupPlanNBFConverted.ExcludeFodlerList.string
            IncludeFilesMask = $(if ($BackupPlanNBFConverted.BackupFilter.FilterType -eq "UseIncludeMask") {
                $BackupPlanNBFConverted.BackupFilter.Filters.string
            }else {
                $null
            })
            ExcludeFilesMask = $(if ($BackupPlanNBFConverted.BackupFilter.FilterType -eq "UseExcludeMask") {
                $BackupPlanNBFConverted.BackupFilter.Filters.string
            }else {
                $null
            })
            IgnoreErrorPathNotFound = $BackupPlanNBFConverted.UseIgnoreErrorsOnPathNotFound
            BackupItem = $BackupPlanNBFConverted.Items.PlanItem.Path 
            ExcludeItem = $BackupPlanNBFConverted.ExcludedItems.PlanItem.Path 
            
            #| ForEach-Object -Begin {$BackupFileArray = @()} -Process {
            # if(([IO.FileInfo]$_).Extension -ne ""){
            # $BackupFileArray += $_
            # }
            #} -End {if($BackupFileArray){$BackupFileArray}else{$null}})
            #BackupDirectory = $($BackupPlanNBFConverted.Items.PlanItem.Path | ForEach-Object -Begin {$BackupDirectoryArray = @()} -Process {
            # if(([IO.FileInfo]$_).Extension -eq ""){
            # $BackupDirectoryArray += $_
            # }
            #} -End {if($BackupDirectoryArray){$BackupDirectoryArray}else{$null}})
            
            GenerateDetailedReport = $BackupPlanNBFConverted.Notification.GenerateReport
        }
        return $NBFFileLevelOutputResult
    }

    function Convert-NBFImageBasedOutput {
        param (
            $BackupPlanNBFConverted
        )
        $NBFImageBasedOutputResult = New-Object -TypeName MBS.Agent.Plan.NBFImageBasedBackupPlanCBB -Property @{
            Name = $BackupPlanNBFConverted.Name
            ID = $BackupPlanNBFConverted.ID
            StorageAccount = Get-MBSStorageAccount -ID $BackupPlanNBFConverted.ConnectionID
            BackupPlanCommonOption = New-Object -TypeName MBS.Agent.Plan.NBFBackupPlanCommonOption -Property @{
                SyncRepositoryBeforeRun = $BackupPlanNBFConverted.SyncBeforeRun
                UseServerSideEncryption = $BackupPlanNBFConverted.UseServerSideEncryption
                EncryptionAlgorithm = ($BackupPlanNBFConverted.EncryptionAlgorithm+$BackupPlanNBFConverted.EncryptionKeySize)
                EncryptionPassword = $(if($BackupPlanNBFConverted.UseEncryption){ConvertTo-SecureString -string "!<encrypted_string>!" -AsPlainText -Force}else{$null})
                UseCompression = $BackupPlanNBFConverted.UseCompression
                StorageClass = ([MBS.Agent.Plan.StorageClassCBB]$BackupPlanNBFConverted.StorageClass).value__
                FullConsistencyCheck = $BackupPlanNBFConverted.UseFullConsistencyCheck
                StopIfPlanRunsFor = $(if($BackupPlanNBFConverted.Schedule.StopAfterTicks -eq "9223372036854775807"){[timespan]"00:00:00"}else{[timespan]$BackupPlanNBFConverted.Schedule.StopAfterTicks})
                RunMissedPlanImmediately = $BackupPlanNBFConverted.ForceMissedSchedule
                PreActionCommand = $(if($BackupPlanNBFConverted.Actions.Pre.Enabled){$BackupPlanNBFConverted.Actions.Pre.CommandLine + " " + $BackupPlanNBFConverted.Actions.Pre.Arguments})
                PreActionContinueAnyway = $(if($BackupPlanNBFConverted.Actions.Pre.Enabled){-not $BackupPlanNBFConverted.Actions.Pre.TerminateOnFailure})
                PostActionCommand = $(if($BackupPlanNBFConverted.Actions.Post.Enabled){$BackupPlanNBFConverted.Actions.Post.CommandLine + " " + $BackupPlanNBFConverted.Actions.Post.Arguments})
                PostActionRunAnyway = $(if($BackupPlanNBFConverted.Actions.Post.Enabled){$BackupPlanNBFConverted.Actions.Post.RunOnBackupFailure})
                BackupChainPlanID = $(if($BackupPlanNBFConverted.ExecuteNextPlan){$BackupPlanNBFConverted.NextExectutionPlan})
                BackupChainExecuteOnlyAfterSuccess = $(if($BackupPlanNBFConverted.ExecuteNextPlan){$BackupPlanNBFConverted.ExecuteNextPlanOnlyIfSucces})
                BackupChainExecuteForceFull = $(if($BackupPlanNBFConverted.ExecuteNextPlan){$BackupPlanNBFConverted.ForceFullNextPlan})
                ResultEmailNotification = $(if($BackupPlanNBFConverted.Notification.SendNotification -and $BackupPlanNBFConverted.Notification.OnlyOnFailure){
                    [MBS.Agent.Plan.Notification]"errorOnly"
                }elseif ($BackupPlanNBFConverted.Notification.SendNotification -and -not $BackupPlanNBFConverted.Notification.OnlyOnFailure) {
                    [MBS.Agent.Plan.Notification]"on"
                }elseif (-not $BackupPlanNBFConverted.Notification.SendNotification) {
                    [MBS.Agent.Plan.Notification]"off"
                })
                AddEventToWindowsLog = $(if($BackupPlanNBFConverted.WindowsEventLogNotification.SendNotification -and $BackupPlanNBFConverted.WindowsEventLogNotification.OnlyOnFailure){
                    [MBS.Agent.Plan.Notification]"errorOnly"
                }elseif ($BackupPlanNBFConverted.WindowsEventLogNotification.SendNotification -and -not $BackupPlanNBFConverted.WindowsEventLogNotification.OnlyOnFailure) {
                    [MBS.Agent.Plan.Notification]"on"
                }elseif (-not $BackupPlanNBFConverted.WindowsEventLogNotification.SendNotification) {
                    [MBS.Agent.Plan.Notification]"off"
                })
                ForeverForwardIncremental = $BackupPlanNBFConverted.ForwardIncremental
                IntelligentRetention = $BackupPlanNBFConverted.AutomaticallyReduceEarlyDeletionFee
                KeepVersionPeriod = $(if($BackupPlanNBFConverted.SerializationSupportRetentionTime -eq "10675199.02:48:05.4775807") {
                    $null
                }else{
                    [int]([timespan]$BackupPlanNBFConverted.SerializationSupportRetentionTime).TotalDays
                })
                GFSKeepWeekly = $(if($BackupPlanNBFConverted.GFSPolicySettings.IsEnabled -and $BackupPlanNBFConverted.GFSPolicySettings.Weekly.IsEnabled){
                    $BackupPlanNBFConverted.GFSPolicySettings.Weekly.StorePeriod
                }else {
                    $null
                })
                GFSKeepMonthly = $(if($BackupPlanNBFConverted.GFSPolicySettings.IsEnabled -and $BackupPlanNBFConverted.GFSPolicySettings.Monthly.IsEnabled){
                    $BackupPlanNBFConverted.GFSPolicySettings.Monthly.StorePeriod
                }else {
                    $null
                })
                GFSKeepYearly = $(if($BackupPlanNBFConverted.GFSPolicySettings.IsEnabled -and $BackupPlanNBFConverted.GFSPolicySettings.Yearly.IsEnabled){
                    $BackupPlanNBFConverted.GFSPolicySettings.Yearly.StorePeriod
                }else {
                    $null
                })
                GFSMonthOfTheYear = $(if($BackupPlanNBFConverted.GFSPolicySettings.IsEnabled -and $BackupPlanNBFConverted.GFSPolicySettings.Yearly.IsEnabled){
                    $BackupPlanNBFConverted.GFSPolicySettings.Yearly.TakeBackupFromMonth
                }else {
                    0
                })
            }
            Schedule = $(if($BackupPlanNBFConverted.Schedule.Enabled){
                New-Object -TypeName MBS.Agent.Plan.NBFIncrementalSchedule -Property @{
                    Frequency = $(if (($BackupPlanNBFConverted.Schedule.RecurType -eq "Weekly") -And (-not (Compare-Object -ReferenceObject $BackupPlanNBFConverted.Schedule.WeekDays.DayOfWeek -DifferenceObject @("Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday")))) {
                        "Daily"
                    }else {
                        $BackupPlanNBFConverted.Schedule.RecurType
                    })
                    At = $(if (-not $BackupPlanNBFConverted.Schedule.DailyRecurrence) {
                        [datetime]"$($BackupPlanNBFConverted.Schedule.Hour):$($BackupPlanNBFConverted.Schedule.Minutes)"
                    }else{
                        [datetime]"1/1/0001 0:00:00"
                    })
                    DayOfMonth = $(if ($BackupPlanNBFConverted.Schedule.RecurType -eq "DayOfMonth") {
                        $BackupPlanNBFConverted.Schedule.DayOfMonth
                    }else{
                        $null
                    })
                    DayOfWeek = $(if (($BackupPlanNBFConverted.Schedule.RecurType -eq "Weekly") -And (Compare-Object -ReferenceObject $BackupPlanNBFConverted.Schedule.WeekDays.DayOfWeek -DifferenceObject @("Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"))) {
                        $BackupPlanNBFConverted.Schedule.WeekDays.DayOfWeek
                    }elseif($BackupPlanNBFConverted.Schedule.RecurType -eq "Monthly") {
                        $BackupPlanNBFConverted.Schedule.DayOfWeek
                    }else {
                        $null
                    })
                    WeekNumber = $(if ($BackupPlanNBFConverted.Schedule.RecurType -eq "Monthly") {
                        $BackupPlanNBFConverted.Schedule.WeekNumber
                    }else {
                        $null
                    })
                    OccursFrom =  $(if ($BackupPlanNBFConverted.Schedule.DailyRecurrence) {
                        [timespan]"$($BackupPlanNBFConverted.Schedule.DailyFromHour):$($BackupPlanNBFConverted.Schedule.DailyFromMinutes)"
                    }else{
                        [timespan]"00:00:00"
                    })
                    OccursTo =  $(if ($BackupPlanNBFConverted.Schedule.DailyRecurrence) {
                        [timespan]"$($BackupPlanNBFConverted.Schedule.DailyTillHour):$($BackupPlanNBFConverted.Schedule.DailyTillMinutes)"
                    }else{
                        [timespan]"00:00:00"
                    })
                    OccursEvery =  $(if ($BackupPlanNBFConverted.Schedule.DailyRecurrence) {
                        New-TimeSpan -Minutes $BackupPlanNBFConverted.Schedule.DailyRecurrencePeriod
                    }else{
                        [timespan]"00:00:00"
                    })
                    RepeatInterval = $BackupPlanNBFConverted.Schedule.RepeatEvery
                    RepeatStartDate = $BackupPlanNBFConverted.Schedule.OnceDate
                }
            }else {
                $null
            })
            ForceFullSchedule = $(if($BackupPlanNBFConverted.ForceFullSchedule.Enabled){
                New-Object -TypeName MBS.Agent.Plan.NBFFullSchedule -Property @{
                    Frequency = $(if (($BackupPlanNBFConverted.ForceFullSchedule.RecurType -eq "Weekly") -And (-not (Compare-Object -ReferenceObject $BackupPlanNBFConverted.ForceFullSchedule.WeekDays.DayOfWeek -DifferenceObject @("Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday")))) {
                        "Daily"
                    }else {
                        $BackupPlanNBFConverted.ForceFullSchedule.RecurType
                    })
                    DayOfMonth = $(if ($BackupPlanNBFConverted.ForceFullSchedule.RecurType -eq "DayOfMonth") {
                        $BackupPlanNBFConverted.ForceFullSchedule.DayOfMonth
                    }else{
                        $null
                    })
                    DayOfWeek = $(if (($BackupPlanNBFConverted.ForceFullSchedule.RecurType -eq "Weekly") -And (Compare-Object -ReferenceObject $BackupPlanNBFConverted.ForceFullSchedule.WeekDays.DayOfWeek -DifferenceObject @("Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"))) {
                        $BackupPlanNBFConverted.ForceFullSchedule.WeekDays.DayOfWeek
                    }elseif($BackupPlanNBFConverted.ForceFullSchedule.RecurType -eq "Monthly") {
                        $BackupPlanNBFConverted.ForceFullSchedule.DayOfWeek
                    }else{
                        $null
                    })
                    WeekNumber = $(if ($BackupPlanNBFConverted.ForceFullSchedule.RecurType -eq "Monthly") {
                        $BackupPlanNBFConverted.ForceFullSchedule.WeekNumber
                    }else {
                        $null
                    })
                    RepeatInterval = $BackupPlanNBFConverted.ForceFullSchedule.RepeatEvery
                    RepeatStartDate = $BackupPlanNBFConverted.ForceFullSchedule.OnceDate
                }
            }else {
                $null
            })
            BackupVolumes = $(switch ($BackupPlanNBFConverted.BackupVolumes) {
                "AllDrives" {[MBS.Agent.Plan.BackupVolumeType]"AllVolumes"}
                "FixedOnly" {[MBS.Agent.Plan.BackupVolumeType]"FixedVolumes"}
                "SystemRequired" { [MBS.Agent.Plan.BackupVolumeType]"SystemRequired" }
                "SelectedOnly" { [MBS.Agent.Plan.BackupVolumeType]"SelectedVolumes" }
                Default {  }
            })
            Volumes = $(if ($BackupPlanNBFConverted.BackupVolumes -eq "SelectedOnly") {
                $BackupPlanNBFConverted.DiskInfo.DiskInfoCommunication.Volumes.VolumeInfoCommunication | Where-Object Enabled -eq $true | ForEach-Object -Begin {$BackupVolumeArray = [System.Collections.Generic.List[MBS.Agent.IBBVolumeCBB]]::new()} -Process{
                    $BackupVolumeArray += New-Object -TypeName MBS.Agent.IBBVolumeCBB -Property @{
                        MountPoints = $_.MountPoints.string
                        Supported = $_.Supported
                        RequiredBySystem = $_.RequiredBySystem
                        DriveType = $_.DriveType
                        FileSystemType = $_.FileSystemType
                        WindowsVolumeIdentity = $_.WindowsVolumeIdentity
                        Length = $_.Length
                        UsedSpace = $_.UsedSpace
                        Label = $_.Label
                        IsBoot = $_.IsBoot
                        IsActive = $_.BiosIsActive
                        IsBitLocker = $_.IsBitLocker
                        BackupOptions = New-Object -TypeName MBS.Agent.IBBVolumeBackupOptionsCBB -Property @{
                            UseVss = $_.BackupOptions.UseVss
                            ExcludeRules = $(if ($null -ne $_.BackupOptions.ExcludeRules.FileExcludeRule) {
                                $_.BackupOptions.ExcludeRules.FileExcludeRule | ForEach-Object -Begin {$ExcludeRulesArray = [System.Collections.Generic.List[MBS.Agent.IBBVolumeBackupOptionsExcludeRulesCBB]]::new()} -Process{
                                    $ExcludeRulesArray += New-Object -TypeName MBS.Agent.IBBVolumeBackupOptionsExcludeRulesCBB -Property @{
                                        Folder = $_.Folder
                                        Mask = $_.Mask
                                        Recursive = $_.Recursive
                                        DeleteFolder = $_.DeleteFolder
                                    }
                                } -End {if($ExcludeRulesArray){$ExcludeRulesArray}else{}}
                            }else {
                                $null
                            })
                            KeepBitLocker = $_.BackupOptions.KeepBitLocker
                        }
                    }
                } -End {if($BackupVolumeArray){$BackupVolumeArray}else{}}
            }else {
                $null
            })
            DisableVSS = $BackupPlanNBFConverted.DisableVSS
            IgnoreBadSectors = $BackupPlanNBFConverted.IgnoreBadSectors
            UseSystemVSS = $(if ($BackupPlanNBFConverted.VSSProviderID -eq "b5946137-7b9f-4925-af80-51abd60b20d5") {
                $true
            }else {
                $false
            })
            PrefetchBlockCount = $BackupPlanNBFConverted.PrefetchBlockCount
            BlockSize = $BackupPlanNBFConverted.BlockSize / 1024
            RestoreVerificationMode = $(switch ($BackupPlanNBFConverted.RunRestoreVerificationOn) {
                "None" { [MBS.Agent.Plan.RestoreVerificationMode]"DoNotRun" }
                "OnFull" { [MBS.Agent.Plan.RestoreVerificationMode]"RunForFull" }
                "OnDiff" { [MBS.Agent.Plan.RestoreVerificationMode]"RunForIncremental" }
                "OnAll" { [MBS.Agent.Plan.RestoreVerificationMode]"RunForFullAndIncremental" }
                Default {}
            })
        }
        return $NBFImageBasedOutputResult
    }

        #Write-Verbose -Message "$($PSCmdlet.MyInvocation.MyCommand.Name): Arguments: -StorageType $StorageType -PlanFormat $PlanFormat -PlanType $PlanType"
        $BackupPlansCBFArray = @()
        $BackupPlansNBFArray = @()
        $BackupPlansNBFClassArray = @()
        $BackupPlansReturnArray = @()
        foreach ($_ in (Get-ChildItem ("$($CBB.CBBProgramData)\*.cbb")  -ErrorAction SilentlyContinue)){ 
            if (Get-Content $_.FullName){
                $BackupPlan = [xml](Get-Content ($_.FullName))
                $BackupPlanConvertedObject = Convert-XMLtoPSObject $BackupPlan.BasePlan
                switch ($PlanType) {
                    "All" 
                    { 
                        if ($BackupPlanConvertedObject.type -notlike "*Restore*" -and $BackupPlanConvertedObject.type -ne "ConsistencyCheckPlan"){
                            if(Compare-StorageTypes -Account (Get-MBSStorageAccount -ID $BackupPlanConvertedObject.ConnectionID) -StorageType $StorageType){
                                if ($BackupPlanConvertedObject.IsArchive -eq "true"){
                                    if ($OutputType -ne "Raw") {
                                        if ($BackupPlanConvertedObject.type -eq "Plan"){
                                            $BackupPlansNBFClassArray += Convert-NBFFileLevelOutput $BackupPlanConvertedObject
                                        } elseif ($BackupPlanConvertedObject.type -eq "BackupDiskImagePlan") {
                                            $BackupPlansNBFClassArray += Convert-NBFImageBasedOutput $BackupPlanConvertedObject
                                        } else {
                                            $BackupPlansNBFArray += $BackupPlanConvertedObject
                                        }
                                    } else {
                                        $BackupPlansNBFArray += $BackupPlanConvertedObject
                                    }
                                } else {
                                    $BackupPlansCBFArray += $BackupPlanConvertedObject
                                }
                            }
                        }
                    }
                    "File-Level" 
                    { 
                        if ($BackupPlanConvertedObject.type -eq "Plan"){
                            if(Compare-StorageTypes -Account (Get-MBSStorageAccount -ID $BackupPlanConvertedObject.ConnectionID) -StorageType $StorageType){
                                if ($BackupPlanConvertedObject.IsArchive -eq "true") {
                                    if ($OutputType -ne "Raw") {
                                        $BackupPlansNBFClassArray += Convert-NBFFileLevelOutput $BackupPlanConvertedObject
                                    } else {
                                        $BackupPlansNBFArray += $BackupPlanConvertedObject
                                    }
                                }else{
                                    $BackupPlansCBFArray += $BackupPlanConvertedObject
                                }
                            }
                        }
                    }
                    "Image-Based" 
                    {
                        if ($BackupPlanConvertedObject.type -eq "BackupDiskImagePlan") {
                            if(Compare-StorageTypes -Account (Get-MBSStorageAccount -ID $BackupPlanConvertedObject.ConnectionID) -StorageType $StorageType){
                                if ($BackupPlanConvertedObject.IsArchive -eq "true") {
                                    if ($OutputType -ne "Raw") {
                                        $BackupPlansNBFClassArray += Convert-NBFImageBasedOutput $BackupPlanConvertedObject
                                    } else {
                                        $BackupPlansNBFArray += $BackupPlanConvertedObject
                                    }
                                }else{
                                    $BackupPlansCBFArray += $BackupPlanConvertedObject
                                }
                            }
                        }
                    }
                    "MSSQL" 
                    {
                        if ($BackupPlanConvertedObject.type -eq "BackupDatabasePlan") {
                            if(Compare-StorageTypes -Account (Get-MBSStorageAccount -ID $BackupPlanConvertedObject.ConnectionID) -StorageType $StorageType){
                                if ($BackupPlanConvertedObject.IsArchive -eq "true") {
                                    $BackupPlansNBFArray += $BackupPlanConvertedObject
                                } else {
                                    $BackupPlansCBFArray += $BackupPlanConvertedObject
                                }
                            }
                        }
                    }
                    "MSExchange" 
                    {
                        if ($BackupPlanConvertedObject.type -eq "BackupExchangePlan") {
                            if(Compare-StorageTypes -Account (Get-MBSStorageAccount -ID $BackupPlanConvertedObject.ConnectionID) -StorageType $StorageType){
                                if ($BackupPlanConvertedObject.IsArchive -eq "true") {
                                    $BackupPlansNBFArray += $BackupPlanConvertedObject
                                } else {
                                    $BackupPlansCBFArray += $BackupPlanConvertedObject
                                }
                            }
                        }
                    }
                    "VMware" 
                    {
                        if ($BackupPlanConvertedObject.type -eq "BackupVirtualMachinesESXiPlan") {
                            if(Compare-StorageTypes -Account (Get-MBSStorageAccount -ID $BackupPlanConvertedObject.ConnectionID) -StorageType $StorageType){
                                if ($BackupPlanConvertedObject.IsArchive -eq "true") {
                                    $BackupPlansNBFArray += $BackupPlanConvertedObject
                                } else {
                                    $BackupPlansCBFArray += $BackupPlanConvertedObject
                                }
                            }
                        }
                    }
                    "Hyper-V" 
                    {
                        if ($BackupPlanConvertedObject.type -eq "BackupVirtualMachinesHyperVPlan") {
                            if(Compare-StorageTypes -Account (Get-MBSStorageAccount -ID $BackupPlanConvertedObject.ConnectionID) -StorageType $StorageType){
                                if ($BackupPlanConvertedObject.IsArchive -eq "true") {
                                    $BackupPlansNBFArray += $BackupPlanConvertedObject
                                } else {
                                    $BackupPlansCBFArray += $BackupPlanConvertedObject
                                }
                            }
                        }
                    }
                    Default {Write-Error -message "Incorrect PlanType parameter"}
                }
            }
        }
        if ($PlanFormat -eq "Legacy") {$PlanFormat = "CBF"}
        switch ($PlanFormat) {
            "All" {
                $BackupPlansReturnArray += $BackupPlansNBFClassArray
                $BackupPlansReturnArray += Convert-Output -InputArray $BackupPlansNBFArray
                $BackupPlansReturnArray += Convert-Output -InputArray $BackupPlansCBFArray
            }
            "CBF" {
                $BackupPlansReturnArray += Convert-Output -InputArray $BackupPlansCBFArray
            }
            "NBF" {
                $BackupPlansReturnArray += $BackupPlansNBFClassArray
                $BackupPlansReturnArray += Convert-Output -InputArray $BackupPlansNBFArray
            }
            Default {Write-Error -message "Incorrect PlanFormat parameter"}
        }
        
        return $BackupPlansReturnArray
    }

    end{

    }
}

# SIG # Begin signature block
# MIIs5gYJKoZIhvcNAQcCoIIs1zCCLNMCAQExDzANBglghkgBZQMEAgEFADB5Bgor
# BgEEAYI3AgEEoGswaTA0BgorBgEEAYI3AgEeMCYCAwEAAAQQH8w7YFlLCE63JNLG
# KX7zUQIBAAIBAAIBAAIBAAIBADAxMA0GCWCGSAFlAwQCAQUABCAZpqvkU+X7aq9t
# 1mkh0q0i+P3Fax/VDg7zCdZNaehIM6CCEekwggVvMIIEV6ADAgECAhBI/JO0YFWU
# jTanyYqJ1pQWMA0GCSqGSIb3DQEBDAUAMHsxCzAJBgNVBAYTAkdCMRswGQYDVQQI
# DBJHcmVhdGVyIE1hbmNoZXN0ZXIxEDAOBgNVBAcMB1NhbGZvcmQxGjAYBgNVBAoM
# EUNvbW9kbyBDQSBMaW1pdGVkMSEwHwYDVQQDDBhBQUEgQ2VydGlmaWNhdGUgU2Vy
# dmljZXMwHhcNMjEwNTI1MDAwMDAwWhcNMjgxMjMxMjM1OTU5WjBWMQswCQYDVQQG
# EwJHQjEYMBYGA1UEChMPU2VjdGlnbyBMaW1pdGVkMS0wKwYDVQQDEyRTZWN0aWdv
# IFB1YmxpYyBDb2RlIFNpZ25pbmcgUm9vdCBSNDYwggIiMA0GCSqGSIb3DQEBAQUA
# A4ICDwAwggIKAoICAQCN55QSIgQkdC7/FiMCkoq2rjaFrEfUI5ErPtx94jGgUW+s
# hJHjUoq14pbe0IdjJImK/+8Skzt9u7aKvb0Ffyeba2XTpQxpsbxJOZrxbW6q5KCD
# J9qaDStQ6Utbs7hkNqR+Sj2pcaths3OzPAsM79szV+W+NDfjlxtd/R8SPYIDdub7
# P2bSlDFp+m2zNKzBenjcklDyZMeqLQSrw2rq4C+np9xu1+j/2iGrQL+57g2extme
# me/G3h+pDHazJyCh1rr9gOcB0u/rgimVcI3/uxXP/tEPNqIuTzKQdEZrRzUTdwUz
# T2MuuC3hv2WnBGsY2HH6zAjybYmZELGt2z4s5KoYsMYHAXVn3m3pY2MeNn9pib6q
# RT5uWl+PoVvLnTCGMOgDs0DGDQ84zWeoU4j6uDBl+m/H5x2xg3RpPqzEaDux5mcz
# mrYI4IAFSEDu9oJkRqj1c7AGlfJsZZ+/VVscnFcax3hGfHCqlBuCF6yH6bbJDoEc
# QNYWFyn8XJwYK+pF9e+91WdPKF4F7pBMeufG9ND8+s0+MkYTIDaKBOq3qgdGnA2T
# OglmmVhcKaO5DKYwODzQRjY1fJy67sPV+Qp2+n4FG0DKkjXp1XrRtX8ArqmQqsV/
# AZwQsRb8zG4Y3G9i/qZQp7h7uJ0VP/4gDHXIIloTlRmQAOka1cKG8eOO7F/05QID
# AQABo4IBEjCCAQ4wHwYDVR0jBBgwFoAUoBEKIz6W8Qfs4q8p74Klf9AwpLQwHQYD
# VR0OBBYEFDLrkpr/NZZILyhAQnAgNpFcF4XmMA4GA1UdDwEB/wQEAwIBhjAPBgNV
# HRMBAf8EBTADAQH/MBMGA1UdJQQMMAoGCCsGAQUFBwMDMBsGA1UdIAQUMBIwBgYE
# VR0gADAIBgZngQwBBAEwQwYDVR0fBDwwOjA4oDagNIYyaHR0cDovL2NybC5jb21v
# ZG9jYS5jb20vQUFBQ2VydGlmaWNhdGVTZXJ2aWNlcy5jcmwwNAYIKwYBBQUHAQEE
# KDAmMCQGCCsGAQUFBzABhhhodHRwOi8vb2NzcC5jb21vZG9jYS5jb20wDQYJKoZI
# hvcNAQEMBQADggEBABK/oe+LdJqYRLhpRrWrJAoMpIpnuDqBv0WKfVIHqI0fTiGF
# OaNrXi0ghr8QuK55O1PNtPvYRL4G2VxjZ9RAFodEhnIq1jIV9RKDwvnhXRFAZ/ZC
# J3LFI+ICOBpMIOLbAffNRk8monxmwFE2tokCVMf8WPtsAO7+mKYulaEMUykfb9gZ
# pk+e96wJ6l2CxouvgKe9gUhShDHaMuwV5KZMPWw5c9QLhTkg4IUaaOGnSDip0TYl
# d8GNGRbFiExmfS9jzpjoad+sPKhdnckcW67Y8y90z7h+9teDnRGWYpquRRPaf9xH
# +9/DUp/mBlXpnYzyOmJRvOwkDynUWICE5EV7WtgwggYaMIIEAqADAgECAhBiHW0M
# UgGeO5B5FSCJIRwKMA0GCSqGSIb3DQEBDAUAMFYxCzAJBgNVBAYTAkdCMRgwFgYD
# VQQKEw9TZWN0aWdvIExpbWl0ZWQxLTArBgNVBAMTJFNlY3RpZ28gUHVibGljIENv
# ZGUgU2lnbmluZyBSb290IFI0NjAeFw0yMTAzMjIwMDAwMDBaFw0zNjAzMjEyMzU5
# NTlaMFQxCzAJBgNVBAYTAkdCMRgwFgYDVQQKEw9TZWN0aWdvIExpbWl0ZWQxKzAp
# BgNVBAMTIlNlY3RpZ28gUHVibGljIENvZGUgU2lnbmluZyBDQSBSMzYwggGiMA0G
# CSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQCbK51T+jU/jmAGQ2rAz/V/9shTUxjI
# ztNsfvxYB5UXeWUzCxEeAEZGbEN4QMgCsJLZUKhWThj/yPqy0iSZhXkZ6Pg2A2NV
# DgFigOMYzB2OKhdqfWGVoYW3haT29PSTahYkwmMv0b/83nbeECbiMXhSOtbam+/3
# 6F09fy1tsB8je/RV0mIk8XL/tfCK6cPuYHE215wzrK0h1SWHTxPbPuYkRdkP05Zw
# mRmTnAO5/arnY83jeNzhP06ShdnRqtZlV59+8yv+KIhE5ILMqgOZYAENHNX9SJDm
# +qxp4VqpB3MV/h53yl41aHU5pledi9lCBbH9JeIkNFICiVHNkRmq4TpxtwfvjsUe
# dyz8rNyfQJy/aOs5b4s+ac7IH60B+Ja7TVM+EKv1WuTGwcLmoU3FpOFMbmPj8pz4
# 4MPZ1f9+YEQIQty/NQd/2yGgW+ufflcZ/ZE9o1M7a5Jnqf2i2/uMSWymR8r2oQBM
# dlyh2n5HirY4jKnFH/9gRvd+QOfdRrJZb1sCAwEAAaOCAWQwggFgMB8GA1UdIwQY
# MBaAFDLrkpr/NZZILyhAQnAgNpFcF4XmMB0GA1UdDgQWBBQPKssghyi47G9IritU
# pimqF6TNDDAOBgNVHQ8BAf8EBAMCAYYwEgYDVR0TAQH/BAgwBgEB/wIBADATBgNV
# HSUEDDAKBggrBgEFBQcDAzAbBgNVHSAEFDASMAYGBFUdIAAwCAYGZ4EMAQQBMEsG
# A1UdHwREMEIwQKA+oDyGOmh0dHA6Ly9jcmwuc2VjdGlnby5jb20vU2VjdGlnb1B1
# YmxpY0NvZGVTaWduaW5nUm9vdFI0Ni5jcmwwewYIKwYBBQUHAQEEbzBtMEYGCCsG
# AQUFBzAChjpodHRwOi8vY3J0LnNlY3RpZ28uY29tL1NlY3RpZ29QdWJsaWNDb2Rl
# U2lnbmluZ1Jvb3RSNDYucDdjMCMGCCsGAQUFBzABhhdodHRwOi8vb2NzcC5zZWN0
# aWdvLmNvbTANBgkqhkiG9w0BAQwFAAOCAgEABv+C4XdjNm57oRUgmxP/BP6YdURh
# w1aVcdGRP4Wh60BAscjW4HL9hcpkOTz5jUug2oeunbYAowbFC2AKK+cMcXIBD0Zd
# OaWTsyNyBBsMLHqafvIhrCymlaS98+QpoBCyKppP0OcxYEdU0hpsaqBBIZOtBajj
# cw5+w/KeFvPYfLF/ldYpmlG+vd0xqlqd099iChnyIMvY5HexjO2AmtsbpVn0OhNc
# WbWDRF/3sBp6fWXhz7DcML4iTAWS+MVXeNLj1lJziVKEoroGs9Mlizg0bUMbOalO
# hOfCipnx8CaLZeVme5yELg09Jlo8BMe80jO37PU8ejfkP9/uPak7VLwELKxAMcJs
# zkyeiaerlphwoKx1uHRzNyE6bxuSKcutisqmKL5OTunAvtONEoteSiabkPVSZ2z7
# 6mKnzAfZxCl/3dq3dUNw4rg3sTCggkHSRqTqlLMS7gjrhTqBmzu1L90Y1KWN/Y5J
# KdGvspbOrTfOXyXvmPL6E52z1NZJ6ctuMFBQZH3pwWvqURR8AgQdULUvrxjUYbHH
# j95Ejza63zdrEcxWLDX6xWls/GDnVNueKjWUH3fTv1Y8Wdho698YADR7TNx8X8z2
# Bev6SivBBOHY+uqiirZtg0y9ShQoPzmCcn63Syatatvx157YK9hlcPmVoa1oDE5/
# L9Uo2bC5a4CH2RwwggZUMIIEvKADAgECAhBQGj1MeADxcRs/FOU26uyrMA0GCSqG
# SIb3DQEBDAUAMFQxCzAJBgNVBAYTAkdCMRgwFgYDVQQKEw9TZWN0aWdvIExpbWl0
# ZWQxKzApBgNVBAMTIlNlY3RpZ28gUHVibGljIENvZGUgU2lnbmluZyBDQSBSMzYw
# HhcNMjExMjAzMDAwMDAwWhcNMjQxMjAyMjM1OTU5WjBYMQswCQYDVQQGEwJVUzEV
# MBMGA1UECAwMUGVubnN5bHZhbmlhMRgwFgYDVQQKDA9NU1BCeXRlcywgQ29ycC4x
# GDAWBgNVBAMMD01TUEJ5dGVzLCBDb3JwLjCCAiIwDQYJKoZIhvcNAQEBBQADggIP
# ADCCAgoCggIBAKNUOYUGihQGjTJdJ6k5Fm3+6QJGhj2wUbubiiqxJeqmW6616o5e
# ExwiGSxPOqafJzOJNq0XOigb3OQhtdIR4bG38+JghFt8rZe/DxBmPBZDR9bD1hrk
# 9vY714QhqvhIlUDXHnDUc9pnVGFfI945hRgaFHL77GQAEFyMvjNupOvT674/E8rI
# gYKMQBwY0cqiuRQwr3FnRMmNhd8/5mqrZGglDT1JizOnpfFVgNJ0x4ev7mPYIF6T
# rFGPwHsOOujzydmGgqvtGASEuz74A6arzYrhbjXv8XsEdT2tz6hHIpMwsgWMk6BD
# KDCsSIl5oEmVbQNXKrC0k62/XpbWRd+i350k07kl1bdV+nbi1K62TyS+7eVxehC1
# gFp+Knob1aqAJD9sPBLdbN3E4FOB/rvOLP1i2IxAcTGirAyRkkUriD4LUSWO6pju
# Qv2V4ZU/+K/3ZLXYCbIflzpDq6z9FmazK5csv99Coslv9s6lm9s1RRxgRBj5sn1q
# Xe/5l0VbF7tG/cgBvt8aJBD0u8knujI17lDy1TGA77r/KKj65xSsxC6nm0RA9pTw
# 0tz5OQ4ABYrH6TpdUBJz8m8cFgPipvyohN0RdE7InB3Nao11L1UHlnnL0SG1z5qQ
# YU7BhvfiSu44pSY9/uTPmAPlNIj3MO5utjfMD+MX9u86d8h/DWwrvQZzAgMBAAGj
# ggGcMIIBmDAfBgNVHSMEGDAWgBQPKssghyi47G9IritUpimqF6TNDDAdBgNVHQ4E
# FgQU7XGG9N0fpUpnonmgh6+IzR3lGj0wDgYDVR0PAQH/BAQDAgeAMAwGA1UdEwEB
# /wQCMAAwEwYDVR0lBAwwCgYIKwYBBQUHAwMwEQYJYIZIAYb4QgEBBAQDAgQQMEoG
# A1UdIARDMEEwNQYMKwYBBAGyMQECAQMCMCUwIwYIKwYBBQUHAgEWF2h0dHBzOi8v
# c2VjdGlnby5jb20vQ1BTMAgGBmeBDAEEATBJBgNVHR8EQjBAMD6gPKA6hjhodHRw
# Oi8vY3JsLnNlY3RpZ28uY29tL1NlY3RpZ29QdWJsaWNDb2RlU2lnbmluZ0NBUjM2
# LmNybDB5BggrBgEFBQcBAQRtMGswRAYIKwYBBQUHMAKGOGh0dHA6Ly9jcnQuc2Vj
# dGlnby5jb20vU2VjdGlnb1B1YmxpY0NvZGVTaWduaW5nQ0FSMzYuY3J0MCMGCCsG
# AQUFBzABhhdodHRwOi8vb2NzcC5zZWN0aWdvLmNvbTANBgkqhkiG9w0BAQwFAAOC
# AYEAhLlUlrWxmB3MSCX9LcaY3p6jCnaeFR4chgRmhjdH+Gy5UyFpEq1/3X/Pv2Ih
# GGnX0uVbXsQ90D/CwFk7bXCFUUblu4ldzNqjmnf+lcTtv/WJR9FTS9t79WdiWbuN
# /YIEXVDERUGPC7v55aaJvXJbDS+4vYeJPAHl2xsvbARWui1nwBLOSVGTGk6T2Q6s
# BnlHFToFc4UFtMhYUMf8L03jypocNGM9z6yamsOANd/dXt582U5DD0g7SVS2pyHD
# Ot7UvVq6769TGZNwq9s1tFwQjm3IGz4DIO1ADMwoGLzqqalYQ1xq2JAqUq41hSlN
# YHecLTjAOTwA81wv71XbZdARR0DfmpqdzdKkTbVucWhJFWL7clDQ0WzfAx1/ZsjR
# t6X9p+XuLnJPMD3V5swX52ZCcB6LY3FyK7kgwNseH+Xqo+Ln7OtAs3Bwa/Cm9lbL
# xYs8wkDitxFnpKFstyE7EE+wtEJkyszfLqjkmUCw/hjzX6I40hahbPCxaxdlv8+3
# drczMYIaUzCCGk8CAQEwaDBUMQswCQYDVQQGEwJHQjEYMBYGA1UEChMPU2VjdGln
# byBMaW1pdGVkMSswKQYDVQQDEyJTZWN0aWdvIFB1YmxpYyBDb2RlIFNpZ25pbmcg
# Q0EgUjM2AhBQGj1MeADxcRs/FOU26uyrMA0GCWCGSAFlAwQCAQUAoHwwEAYKKwYB
# BAGCNwIBDDECMAAwGQYJKoZIhvcNAQkDMQwGCisGAQQBgjcCAQQwHAYKKwYBBAGC
# NwIBCzEOMAwGCisGAQQBgjcCARUwLwYJKoZIhvcNAQkEMSIEIFV/OqR8kNyloRQx
# c4vrKo8QeUODkJyA7TjyjAecRLWrMA0GCSqGSIb3DQEBAQUABIICAFHf5FsgBc9v
# fIlKeaeZsZJFPXgBFDh/rDbI9gTVFt4WHioDQ3dZixp8QiRjzcK+dObCv0zoc5CT
# 7eL9X7kvS0UO2MtewRgy0kthAfgoMUXwZYLaipPSngA4UaLm5UrjICT6m7sLN6Ju
# tXkqWRpDjBUx3mkNs1EneMix+mwaTqaoaq9w62+1d+K5wwYMOWCEiNOfx61kFjYK
# /hiiX6nYrBmvfrdpRkZ451AhUx9fxboscDA7D4r9H7FqClpIYiKKKZAw02J1BtpB
# BjVadgr4l4Zpa8S7xdKcHNG9UPfmGZOlHxWWciGrDri/rySw4DnpHoZnLK8YjFsI
# cUOK7SX7Mcc+7tEGfXTQFlNo2cWwZ2YzOqC8ZhiAEik6vuZACqq8gQjXBcmVYOGw
# V9T07ydvg1+pG8/nZlXAV2LJTlf65KBODX1APhquKG7wTG0TRHit2mr8s9bQTQLR
# lblP6q14DnmRpM/U7fQDCO4plrYECpVT7krD2oYrCZFAn2SKp31qnEFRz38U7GDB
# D51u5gC0JXSEjpyIRbRN+Qm5/Um6DCFTcj3bYPLg8EObM8M8iDsT6xv3XG51UVTu
# WLteuLs4rKXHlLtt0+4i1UMRBVdTi9ViEklNzp29q+GCrTNt47i6fqi/dv2+Oe/u
# vk5M/UfLi3DMY8y7amoyobm/75Ctf6cooYIXPjCCFzoGCisGAQQBgjcDAwExghcq
# MIIXJgYJKoZIhvcNAQcCoIIXFzCCFxMCAQMxDzANBglghkgBZQMEAgEFADB4Bgsq
# hkiG9w0BCRABBKBpBGcwZQIBAQYJYIZIAYb9bAcBMDEwDQYJYIZIAWUDBAIBBQAE
# INaTOFp+ZqtvbpODFd4NIyjIpmFVAL72ALutuj4o2OqaAhEAieISVP+iIUQwdxvm
# 4hI69RgPMjAyMzA3MjAxNDUyMjhaoIITBzCCBsAwggSooAMCAQICEAxNaXJLlPo8
# Kko9KQeAPVowDQYJKoZIhvcNAQELBQAwYzELMAkGA1UEBhMCVVMxFzAVBgNVBAoT
# DkRpZ2lDZXJ0LCBJbmMuMTswOQYDVQQDEzJEaWdpQ2VydCBUcnVzdGVkIEc0IFJT
# QTQwOTYgU0hBMjU2IFRpbWVTdGFtcGluZyBDQTAeFw0yMjA5MjEwMDAwMDBaFw0z
# MzExMjEyMzU5NTlaMEYxCzAJBgNVBAYTAlVTMREwDwYDVQQKEwhEaWdpQ2VydDEk
# MCIGA1UEAxMbRGlnaUNlcnQgVGltZXN0YW1wIDIwMjIgLSAyMIICIjANBgkqhkiG
# 9w0BAQEFAAOCAg8AMIICCgKCAgEAz+ylJjrGqfJru43BDZrboegUhXQzGias0BxV
# Hh42bbySVQxh9J0Jdz0Vlggva2Sk/QaDFteRkjgcMQKW+3KxlzpVrzPsYYrppijb
# kGNcvYlT4DotjIdCriak5Lt4eLl6FuFWxsC6ZFO7KhbnUEi7iGkMiMbxvuAvfTux
# ylONQIMe58tySSgeTIAehVbnhe3yYbyqOgd99qtu5Wbd4lz1L+2N1E2VhGjjgMtq
# edHSEJFGKes+JvK0jM1MuWbIu6pQOA3ljJRdGVq/9XtAbm8WqJqclUeGhXk+DF5m
# jBoKJL6cqtKctvdPbnjEKD+jHA9QBje6CNk1prUe2nhYHTno+EyREJZ+TeHdwq2l
# fvgtGx/sK0YYoxn2Off1wU9xLokDEaJLu5i/+k/kezbvBkTkVf826uV8MefzwlLE
# 5hZ7Wn6lJXPbwGqZIS1j5Vn1TS+QHye30qsU5Thmh1EIa/tTQznQZPpWz+D0CuYU
# bWR4u5j9lMNzIfMvwi4g14Gs0/EH1OG92V1LbjGUKYvmQaRllMBY5eUuKZCmt2Fk
# +tkgbBhRYLqmgQ8JJVPxvzvpqwcOagc5YhnJ1oV/E9mNec9ixezhe7nMZxMHmsF4
# 7caIyLBuMnnHC1mDjcbu9Sx8e47LZInxscS451NeX1XSfRkpWQNO+l3qRXMchH7X
# zuLUOncCAwEAAaOCAYswggGHMA4GA1UdDwEB/wQEAwIHgDAMBgNVHRMBAf8EAjAA
# MBYGA1UdJQEB/wQMMAoGCCsGAQUFBwMIMCAGA1UdIAQZMBcwCAYGZ4EMAQQCMAsG
# CWCGSAGG/WwHATAfBgNVHSMEGDAWgBS6FtltTYUvcyl2mi91jGogj57IbzAdBgNV
# HQ4EFgQUYore0GH8jzEU7ZcLzT0qlBTfUpwwWgYDVR0fBFMwUTBPoE2gS4ZJaHR0
# cDovL2NybDMuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0VHJ1c3RlZEc0UlNBNDA5NlNI
# QTI1NlRpbWVTdGFtcGluZ0NBLmNybDCBkAYIKwYBBQUHAQEEgYMwgYAwJAYIKwYB
# BQUHMAGGGGh0dHA6Ly9vY3NwLmRpZ2ljZXJ0LmNvbTBYBggrBgEFBQcwAoZMaHR0
# cDovL2NhY2VydHMuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0VHJ1c3RlZEc0UlNBNDA5
# NlNIQTI1NlRpbWVTdGFtcGluZ0NBLmNydDANBgkqhkiG9w0BAQsFAAOCAgEAVaoq
# GvNG83hXNzD8deNP1oUj8fz5lTmbJeb3coqYw3fUZPwV+zbCSVEseIhjVQlGOQD8
# adTKmyn7oz/AyQCbEx2wmIncePLNfIXNU52vYuJhZqMUKkWHSphCK1D8G7WeCDAJ
# +uQt1wmJefkJ5ojOfRu4aqKbwVNgCeijuJ3XrR8cuOyYQfD2DoD75P/fnRCn6wC6
# X0qPGjpStOq/CUkVNTZZmg9U0rIbf35eCa12VIp0bcrSBWcrduv/mLImlTgZiEQU
# 5QpZomvnIj5EIdI/HMCb7XxIstiSDJFPPGaUr10CU+ue4p7k0x+GAWScAMLpWnR1
# DT3heYi/HAGXyRkjgNc2Wl+WFrFjDMZGQDvOXTXUWT5Dmhiuw8nLw/ubE19qtcfg
# 8wXDWd8nYiveQclTuf80EGf2JjKYe/5cQpSBlIKdrAqLxksVStOYkEVgM4DgI974
# A6T2RUflzrgDQkfoQTZxd639ouiXdE4u2h4djFrIHprVwvDGIqhPm73YHJpRxC+a
# 9l+nJ5e6li6FV8Bg53hWf2rvwpWaSxECyIKcyRoFfLpxtU56mWz06J7UWpjIn7+N
# uxhcQ/XQKujiYu54BNu90ftbCqhwfvCXhHjjCANdRyxjqCU4lwHSPzra5eX25pvc
# fizM/xdMTQCi2NYBDriL7ubgclWJLCcZYfZ3AYwwggauMIIElqADAgECAhAHNje3
# JFR82Ees/ShmKl5bMA0GCSqGSIb3DQEBCwUAMGIxCzAJBgNVBAYTAlVTMRUwEwYD
# VQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5jb20xITAf
# BgNVBAMTGERpZ2lDZXJ0IFRydXN0ZWQgUm9vdCBHNDAeFw0yMjAzMjMwMDAwMDBa
# Fw0zNzAzMjIyMzU5NTlaMGMxCzAJBgNVBAYTAlVTMRcwFQYDVQQKEw5EaWdpQ2Vy
# dCwgSW5jLjE7MDkGA1UEAxMyRGlnaUNlcnQgVHJ1c3RlZCBHNCBSU0E0MDk2IFNI
# QTI1NiBUaW1lU3RhbXBpbmcgQ0EwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIK
# AoICAQDGhjUGSbPBPXJJUVXHJQPE8pE3qZdRodbSg9GeTKJtoLDMg/la9hGhRBVC
# X6SI82j6ffOciQt/nR+eDzMfUBMLJnOWbfhXqAJ9/UO0hNoR8XOxs+4rgISKIhjf
# 69o9xBd/qxkrPkLcZ47qUT3w1lbU5ygt69OxtXXnHwZljZQp09nsad/ZkIdGAHvb
# REGJ3HxqV3rwN3mfXazL6IRktFLydkf3YYMZ3V+0VAshaG43IbtArF+y3kp9zvU5
# EmfvDqVjbOSmxR3NNg1c1eYbqMFkdECnwHLFuk4fsbVYTXn+149zk6wsOeKlSNbw
# sDETqVcplicu9Yemj052FVUmcJgmf6AaRyBD40NjgHt1biclkJg6OBGz9vae5jtb
# 7IHeIhTZgirHkr+g3uM+onP65x9abJTyUpURK1h0QCirc0PO30qhHGs4xSnzyqqW
# c0Jon7ZGs506o9UD4L/wojzKQtwYSH8UNM/STKvvmz3+DrhkKvp1KCRB7UK/BZxm
# SVJQ9FHzNklNiyDSLFc1eSuo80VgvCONWPfcYd6T/jnA+bIwpUzX6ZhKWD7TA4j+
# s4/TXkt2ElGTyYwMO1uKIqjBJgj5FBASA31fI7tk42PgpuE+9sJ0sj8eCXbsq11G
# deJgo1gJASgADoRU7s7pXcheMBK9Rp6103a50g5rmQzSM7TNsQIDAQABo4IBXTCC
# AVkwEgYDVR0TAQH/BAgwBgEB/wIBADAdBgNVHQ4EFgQUuhbZbU2FL3MpdpovdYxq
# II+eyG8wHwYDVR0jBBgwFoAU7NfjgtJxXWRM3y5nP+e6mK4cD08wDgYDVR0PAQH/
# BAQDAgGGMBMGA1UdJQQMMAoGCCsGAQUFBwMIMHcGCCsGAQUFBwEBBGswaTAkBggr
# BgEFBQcwAYYYaHR0cDovL29jc3AuZGlnaWNlcnQuY29tMEEGCCsGAQUFBzAChjVo
# dHRwOi8vY2FjZXJ0cy5kaWdpY2VydC5jb20vRGlnaUNlcnRUcnVzdGVkUm9vdEc0
# LmNydDBDBgNVHR8EPDA6MDigNqA0hjJodHRwOi8vY3JsMy5kaWdpY2VydC5jb20v
# RGlnaUNlcnRUcnVzdGVkUm9vdEc0LmNybDAgBgNVHSAEGTAXMAgGBmeBDAEEAjAL
# BglghkgBhv1sBwEwDQYJKoZIhvcNAQELBQADggIBAH1ZjsCTtm+YqUQiAX5m1tgh
# QuGwGC4QTRPPMFPOvxj7x1Bd4ksp+3CKDaopafxpwc8dB+k+YMjYC+VcW9dth/qE
# ICU0MWfNthKWb8RQTGIdDAiCqBa9qVbPFXONASIlzpVpP0d3+3J0FNf/q0+KLHqr
# hc1DX+1gtqpPkWaeLJ7giqzl/Yy8ZCaHbJK9nXzQcAp876i8dU+6WvepELJd6f8o
# VInw1YpxdmXazPByoyP6wCeCRK6ZJxurJB4mwbfeKuv2nrF5mYGjVoarCkXJ38SN
# oOeY+/umnXKvxMfBwWpx2cYTgAnEtp/Nh4cku0+jSbl3ZpHxcpzpSwJSpzd+k1Os
# Ox0ISQ+UzTl63f8lY5knLD0/a6fxZsNBzU+2QJshIUDQtxMkzdwdeDrknq3lNHGS
# 1yZr5Dhzq6YBT70/O3itTK37xJV77QpfMzmHQXh6OOmc4d0j/R0o08f56PGYX/sr
# 2H7yRp11LB4nLCbbbxV7HhmLNriT1ObyF5lZynDwN7+YAN8gFk8n+2BnFqFmut1V
# wDophrCYoCvtlUG3OtUVmDG0YgkPCr2B2RP+v6TR81fZvAT6gt4y3wSJ8ADNXcL5
# 0CN/AAvkdgIm2fBldkKmKYcJRyvmfxqkhQ/8mJb2VVQrH4D6wPIOK+XW+6kvRBVK
# 5xMOHds3OBqhK/bt1nz8MIIFjTCCBHWgAwIBAgIQDpsYjvnQLefv21DiCEAYWjAN
# BgkqhkiG9w0BAQwFADBlMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQg
# SW5jMRkwFwYDVQQLExB3d3cuZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2Vy
# dCBBc3N1cmVkIElEIFJvb3QgQ0EwHhcNMjIwODAxMDAwMDAwWhcNMzExMTA5MjM1
# OTU5WjBiMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYD
# VQQLExB3d3cuZGlnaWNlcnQuY29tMSEwHwYDVQQDExhEaWdpQ2VydCBUcnVzdGVk
# IFJvb3QgRzQwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC/5pBzaN67
# 5F1KPDAiMGkz7MKnJS7JIT3yithZwuEppz1Yq3aaza57G4QNxDAf8xukOBbrVsaX
# bR2rsnnyyhHS5F/WBTxSD1Ifxp4VpX6+n6lXFllVcq9ok3DCsrp1mWpzMpTREEQQ
# Lt+C8weE5nQ7bXHiLQwb7iDVySAdYyktzuxeTsiT+CFhmzTrBcZe7FsavOvJz82s
# NEBfsXpm7nfISKhmV1efVFiODCu3T6cw2Vbuyntd463JT17lNecxy9qTXtyOj4Da
# tpGYQJB5w3jHtrHEtWoYOAMQjdjUN6QuBX2I9YI+EJFwq1WCQTLX2wRzKm6RAXwh
# TNS8rhsDdV14Ztk6MUSaM0C/CNdaSaTC5qmgZ92kJ7yhTzm1EVgX9yRcRo9k98Fp
# iHaYdj1ZXUJ2h4mXaXpI8OCiEhtmmnTK3kse5w5jrubU75KSOp493ADkRSWJtppE
# GSt+wJS00mFt6zPZxd9LBADMfRyVw4/3IbKyEbe7f/LVjHAsQWCqsWMYRJUadmJ+
# 9oCw++hkpjPRiQfhvbfmQ6QYuKZ3AeEPlAwhHbJUKSWJbOUOUlFHdL4mrLZBdd56
# rF+NP8m800ERElvlEFDrMcXKchYiCd98THU/Y+whX8QgUWtvsauGi0/C1kVfnSD8
# oR7FwI+isX4KJpn15GkvmB0t9dmpsh3lGwIDAQABo4IBOjCCATYwDwYDVR0TAQH/
# BAUwAwEB/zAdBgNVHQ4EFgQU7NfjgtJxXWRM3y5nP+e6mK4cD08wHwYDVR0jBBgw
# FoAUReuir/SSy4IxLVGLp6chnfNtyA8wDgYDVR0PAQH/BAQDAgGGMHkGCCsGAQUF
# BwEBBG0wazAkBggrBgEFBQcwAYYYaHR0cDovL29jc3AuZGlnaWNlcnQuY29tMEMG
# CCsGAQUFBzAChjdodHRwOi8vY2FjZXJ0cy5kaWdpY2VydC5jb20vRGlnaUNlcnRB
# c3N1cmVkSURSb290Q0EuY3J0MEUGA1UdHwQ+MDwwOqA4oDaGNGh0dHA6Ly9jcmwz
# LmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydEFzc3VyZWRJRFJvb3RDQS5jcmwwEQYDVR0g
# BAowCDAGBgRVHSAAMA0GCSqGSIb3DQEBDAUAA4IBAQBwoL9DXFXnOF+go3QbPbYW
# 1/e/Vwe9mqyhhyzshV6pGrsi+IcaaVQi7aSId229GhT0E0p6Ly23OO/0/4C5+KH3
# 8nLeJLxSA8hO0Cre+i1Wz/n096wwepqLsl7Uz9FDRJtDIeuWcqFItJnLnU+nBgMT
# dydE1Od/6Fmo8L8vC6bp8jQ87PcDx4eo0kxAGTVGamlUsLihVo7spNU96LHc/RzY
# 9HdaXFSMb++hUD38dglohJ9vytsgjTVgHAIDyyCwrFigDkBjxZgiwbJZ9VVrzyer
# bHbObyMt9H5xaiNrIv8SuFQtJ37YOtnwtoeW/VvRXKwYw02fc7cBqZ9Xql4o4rmU
# MYIDdjCCA3ICAQEwdzBjMQswCQYDVQQGEwJVUzEXMBUGA1UEChMORGlnaUNlcnQs
# IEluYy4xOzA5BgNVBAMTMkRpZ2lDZXJ0IFRydXN0ZWQgRzQgUlNBNDA5NiBTSEEy
# NTYgVGltZVN0YW1waW5nIENBAhAMTWlyS5T6PCpKPSkHgD1aMA0GCWCGSAFlAwQC
# AQUAoIHRMBoGCSqGSIb3DQEJAzENBgsqhkiG9w0BCRABBDAcBgkqhkiG9w0BCQUx
# DxcNMjMwNzIwMTQ1MjI4WjArBgsqhkiG9w0BCRACDDEcMBowGDAWBBTzhyJNhjOC
# kjWplLy9j5bp/hx8czAvBgkqhkiG9w0BCQQxIgQg6/TdGc3Vb7evMpB6/wLQYpyl
# E2BYwGJYjuWP9kKaH50wNwYLKoZIhvcNAQkQAi8xKDAmMCQwIgQgx/ThvjIoiSCr
# 4iY6vhrE/E/meBwtZNBMgHVXoCO1tvowDQYJKoZIhvcNAQEBBQAEggIAWxX1PDr9
# 7uMlYgVu00q57877hBMLX9ybfcte59hpN18CXXeqSoM6jITVOfSlobhUYIHLZQ9k
# sPWxOtv1kkmLpMtcuiLqR46aHiAxJDlSCT1umjxIeFNnIL1/3dQX06vd7ywb73Lh
# /Gz5YdI9cnHmUQslJff0aLCVQ92JaU/bP7kSfgPlTiGpOQAlZJG0iWVLV/gyEXUW
# +jnWxe0gc+cIrN4BGSB1aM5FA4l7LZx2DwqaRfTuDkwtls0MQw2OLK3TmK/p90PX
# d1VnS4LB9lS4biyU09NK9v5gqdV0vfN7+ZOtH9KuMWBPHR3ZJ3KX/9eTHq6j62Vt
# ZjpqpT58ec25L+GIyZ0odhB6gq8qCXOSaZ/gDq0uf37mJz3BEdFXQMU/Ac77IV5a
# ekyI6QGCPszFh9PK2caBriuGcB49QzbFZfYLkQKdgOr+Ph9RKFDoJO/nPC4G554J
# M7J0QQ8XBQuWhbQ95pqR48g3hteWgjyrMZ1qIdRvVRnwMdjUnf2fgda305QzuaKZ
# ekJClE8ZM5vMzLYCAm8XqGZl2Ama22/a+BasRTNEw++vFLTZSPuUk5/cqedTIwEy
# 07GOFhO1eT9AFLivdaembGQKvTy8ZvSJYavAfElTgfQeiSpocpShd0Yv4hOwcqOi
# Jpvsp7DQFnyAAjnmWg2/v0Xbe8lU/c9zZ3s=
# SIG # End signature block