From 67bdfa7d6ee3e6d1f0955041559c63e41f990fd4 Mon Sep 17 00:00:00 2001 From: Haowei Cai Date: Thu, 20 Mar 2025 19:25:08 +0000 Subject: [PATCH 1/7] Add alpha feature gate KubeletPSI --- pkg/features/kube_features.go | 10 ++++++++++ .../reference/versioned_feature_list.yaml | 6 ++++++ 2 files changed, 16 insertions(+) diff --git a/pkg/features/kube_features.go b/pkg/features/kube_features.go index 3c6e9614d98..d5fb3fe16d0 100644 --- a/pkg/features/kube_features.go +++ b/pkg/features/kube_features.go @@ -403,6 +403,12 @@ const ( // Enable POD resources API with Get method KubeletPodResourcesGet featuregate.Feature = "KubeletPodResourcesGet" + // KubeletPSI enables Kubelet to surface PSI metrics + // owner: @roycaihw + // kep: https://kep.k8s.io/4205 + // alpha: v1.33 + KubeletPSI featuregate.Feature = "KubeletPSI" + // owner: @kannon92 // kep: https://kep.k8s.io/4191 // @@ -1417,6 +1423,10 @@ var defaultVersionedKubernetesFeatureGates = map[featuregate.Feature]featuregate {Version: version.MustParse("1.27"), Default: false, PreRelease: featuregate.Alpha}, }, + KubeletPSI: { + {Version: version.MustParse("1.33"), Default: false, PreRelease: featuregate.Alpha}, + }, + KubeletRegistrationGetOnExistsOnly: { {Version: version.MustParse("1.0"), Default: true, PreRelease: featuregate.GA}, {Version: version.MustParse("1.32"), Default: false, PreRelease: featuregate.Deprecated}, diff --git a/test/compatibility_lifecycle/reference/versioned_feature_list.yaml b/test/compatibility_lifecycle/reference/versioned_feature_list.yaml index e6bf4c342fa..04b682f65e1 100644 --- a/test/compatibility_lifecycle/reference/versioned_feature_list.yaml +++ b/test/compatibility_lifecycle/reference/versioned_feature_list.yaml @@ -719,6 +719,12 @@ lockToDefault: false preRelease: Alpha version: "1.27" +- name: KubeletPSI + versionedSpecs: + - default: false + lockToDefault: false + preRelease: Alpha + version: "1.33" - name: KubeletRegistrationGetOnExistsOnly versionedSpecs: - default: true From c7fc9d5f91aed676dcae15679eca42b646302377 Mon Sep 17 00:00:00 2001 From: Haowei Cai Date: Thu, 20 Mar 2025 19:25:38 +0000 Subject: [PATCH 2/7] API definition for PSI metrics --- .../kubelet/pkg/apis/stats/v1alpha1/types.go | 45 +++++++++++++++++++ 1 file changed, 45 insertions(+) diff --git a/staging/src/k8s.io/kubelet/pkg/apis/stats/v1alpha1/types.go b/staging/src/k8s.io/kubelet/pkg/apis/stats/v1alpha1/types.go index b63a17ace5e..5e8553f8a4d 100644 --- a/staging/src/k8s.io/kubelet/pkg/apis/stats/v1alpha1/types.go +++ b/staging/src/k8s.io/kubelet/pkg/apis/stats/v1alpha1/types.go @@ -46,6 +46,9 @@ type NodeStats struct { // Stats pertaining to memory (RAM) resources. // +optional Memory *MemoryStats `json:"memory,omitempty"` + // Stats pertaining to IO resources. + // +optional + IO *IOStats `json:"io,omitempty"` // Stats pertaining to network resources. // +optional Network *NetworkStats `json:"network,omitempty"` @@ -127,6 +130,9 @@ type PodStats struct { // Stats pertaining to memory (RAM) resources consumed by pod cgroup (which includes all containers' resource usage and pod overhead). // +optional Memory *MemoryStats `json:"memory,omitempty"` + // Stats pertaining to IO resources consumed by pod cgroup (which includes all containers' resource usage and pod overhead). + // +optional + IO *IOStats `json:"io,omitempty"` // Stats pertaining to network resources. // +optional Network *NetworkStats `json:"network,omitempty"` @@ -159,6 +165,9 @@ type ContainerStats struct { // Stats pertaining to memory (RAM) resources. // +optional Memory *MemoryStats `json:"memory,omitempty"` + // Stats pertaining to IO resources. + // +optional + IO *IOStats `json:"io,omitempty"` // Metrics for Accelerators. Each Accelerator corresponds to one element in the array. Accelerators []AcceleratorStats `json:"accelerators,omitempty"` // Stats pertaining to container rootfs usage of filesystem resources. @@ -225,6 +234,9 @@ type CPUStats struct { // Cumulative CPU usage (sum of all cores) since object creation. // +optional UsageCoreNanoSeconds *uint64 `json:"usageCoreNanoSeconds,omitempty"` + // CPU PSI stats. + // +optional + PSI *PSIStats `json:"psi,omitempty"` } // MemoryStats contains data about memory usage. @@ -252,6 +264,39 @@ type MemoryStats struct { // Cumulative number of major page faults. // +optional MajorPageFaults *uint64 `json:"majorPageFaults,omitempty"` + // Memory PSI stats. + // +optional + PSI *PSIStats `json:"psi,omitempty"` +} + +// IOStats contains data about IO usage. +type IOStats struct { + // The time at which these stats were updated. + Time metav1.Time `json:"time"` + // IO PSI stats. + // +optional + PSI *PSIStats `json:"psi,omitempty"` +} + +// PSI statistics for an individual resource. +type PSIStats struct { + // PSI data for all tasks in the cgroup. + Full PSIData `json:"full"` + // PSI data for some tasks in the cgroup. + Some PSIData `json:"some"` +} + +// PSI data for an individual resource. +type PSIData struct { + // Total time duration for tasks in the cgroup have waited due to congestion. + // Unit: nanoseconds. + Total uint64 `json:"total"` + // The average (in %) tasks have waited due to congestion over a 10 second window. + Avg10 float64 `json:"avg10"` + // The average (in %) tasks have waited due to congestion over a 60 second window. + Avg60 float64 `json:"avg60"` + // The average (in %) tasks have waited due to congestion over a 300 second window. + Avg300 float64 `json:"avg300"` } // SwapStats contains data about memory usage From 92a42e65ec2fad1ba636d6a53d682ad88c88526a Mon Sep 17 00:00:00 2001 From: Haowei Cai Date: Thu, 20 Mar 2025 19:27:49 +0000 Subject: [PATCH 3/7] Surface cadvisor PSI metrics to summary API and prometheus metrics --- pkg/kubelet/cadvisor/cadvisor_linux.go | 6 +++ pkg/kubelet/server/server.go | 5 ++ pkg/kubelet/server/stats/summary.go | 5 ++ pkg/kubelet/stats/cadvisor_stats_provider.go | 3 ++ pkg/kubelet/stats/helper.go | 49 ++++++++++++++++++++ 5 files changed, 68 insertions(+) diff --git a/pkg/kubelet/cadvisor/cadvisor_linux.go b/pkg/kubelet/cadvisor/cadvisor_linux.go index c2756c6f123..2120adfcf9a 100644 --- a/pkg/kubelet/cadvisor/cadvisor_linux.go +++ b/pkg/kubelet/cadvisor/cadvisor_linux.go @@ -39,7 +39,9 @@ import ( cadvisorapiv2 "github.com/google/cadvisor/info/v2" "github.com/google/cadvisor/manager" "github.com/google/cadvisor/utils/sysfs" + utilfeature "k8s.io/apiserver/pkg/util/feature" "k8s.io/klog/v2" + "k8s.io/kubernetes/pkg/features" "k8s.io/utils/ptr" ) @@ -93,6 +95,10 @@ func New(imageFsInfoProvider ImageFsInfoProvider, rootPath string, cgroupRoots [ cadvisormetrics.OOMMetrics: struct{}{}, } + if utilfeature.DefaultFeatureGate.Enabled(features.KubeletPSI) { + includedMetrics[cadvisormetrics.PressureMetrics] = struct{}{} + } + if usingLegacyStats || localStorageCapacityIsolation { includedMetrics[cadvisormetrics.DiskUsageMetrics] = struct{}{} } diff --git a/pkg/kubelet/server/server.go b/pkg/kubelet/server/server.go index c88e1d60d81..83d344d17b5 100644 --- a/pkg/kubelet/server/server.go +++ b/pkg/kubelet/server/server.go @@ -455,6 +455,11 @@ func (s *Server) InstallAuthNotRequiredHandlers() { cadvisormetrics.ProcessMetrics: struct{}{}, cadvisormetrics.OOMMetrics: struct{}{}, } + + if utilfeature.DefaultFeatureGate.Enabled(features.KubeletPSI) { + includedMetrics[cadvisormetrics.PressureMetrics] = struct{}{} + } + // cAdvisor metrics are exposed under the secured handler as well r := compbasemetrics.NewKubeRegistry() r.RawMustRegister(metrics.NewPrometheusMachineCollector(prometheusHostAdapter{s.host}, includedMetrics)) diff --git a/pkg/kubelet/server/stats/summary.go b/pkg/kubelet/server/stats/summary.go index afc2f475a65..0e21717ddd0 100644 --- a/pkg/kubelet/server/stats/summary.go +++ b/pkg/kubelet/server/stats/summary.go @@ -24,7 +24,9 @@ import ( "k8s.io/klog/v2" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + utilfeature "k8s.io/apiserver/pkg/util/feature" statsapi "k8s.io/kubelet/pkg/apis/stats/v1alpha1" + "k8s.io/kubernetes/pkg/features" "k8s.io/kubernetes/pkg/kubelet/util" ) @@ -113,6 +115,9 @@ func (sp *summaryProviderImpl) Get(ctx context.Context, updateStats bool) (*stat Rlimit: rlimit, SystemContainers: sp.GetSystemContainersStats(nodeConfig, podStats, updateStats), } + if utilfeature.DefaultFeatureGate.Enabled(features.KubeletPSI) { + nodeStats.IO = rootStats.IO + } summary := statsapi.Summary{ Node: nodeStats, Pods: podStats, diff --git a/pkg/kubelet/stats/cadvisor_stats_provider.go b/pkg/kubelet/stats/cadvisor_stats_provider.go index 7813efbd0bc..52ad55a8b1f 100644 --- a/pkg/kubelet/stats/cadvisor_stats_provider.go +++ b/pkg/kubelet/stats/cadvisor_stats_provider.go @@ -156,6 +156,9 @@ func (p *cadvisorStatsProvider) ListPodStats(ctx context.Context) ([]statsapi.Po podStats.CPU = cpu podStats.Memory = memory podStats.Swap = cadvisorInfoToSwapStats(podInfo) + if utilfeature.DefaultFeatureGate.Enabled(features.KubeletPSI) { + podStats.IO = cadvisorInfoToIOStats(podInfo) + } // ProcessStats were accumulated as the containers were iterated. } diff --git a/pkg/kubelet/stats/helper.go b/pkg/kubelet/stats/helper.go index c51d6e4f276..8099be21e7e 100644 --- a/pkg/kubelet/stats/helper.go +++ b/pkg/kubelet/stats/helper.go @@ -24,8 +24,10 @@ import ( cadvisorapiv2 "github.com/google/cadvisor/info/v2" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" + utilfeature "k8s.io/apiserver/pkg/util/feature" "k8s.io/klog/v2" statsapi "k8s.io/kubelet/pkg/apis/stats/v1alpha1" + "k8s.io/kubernetes/pkg/features" "k8s.io/kubernetes/pkg/kubelet/cadvisor" "k8s.io/kubernetes/pkg/kubelet/server/stats" ) @@ -53,6 +55,9 @@ func cadvisorInfoToCPUandMemoryStats(info *cadvisorapiv2.ContainerInfo) (*statsa } if cstat.Cpu != nil { cpuStats.UsageCoreNanoSeconds = &cstat.Cpu.Usage.Total + if utilfeature.DefaultFeatureGate.Enabled(features.KubeletPSI) { + cpuStats.PSI = cadvisorPSIToStatsPSI(&cstat.Cpu.PSI) + } } } if info.Spec.HasMemory && cstat.Memory != nil { @@ -71,6 +76,9 @@ func cadvisorInfoToCPUandMemoryStats(info *cadvisorapiv2.ContainerInfo) (*statsa availableBytes := info.Spec.Memory.Limit - cstat.Memory.WorkingSet memoryStats.AvailableBytes = &availableBytes } + if utilfeature.DefaultFeatureGate.Enabled(features.KubeletPSI) { + memoryStats.PSI = cadvisorPSIToStatsPSI(&cstat.Memory.PSI) + } } else { memoryStats = &statsapi.MemoryStats{ Time: metav1.NewTime(cstat.Timestamp), @@ -96,6 +104,9 @@ func cadvisorInfoToContainerStats(name string, info *cadvisorapiv2.ContainerInfo result.CPU = cpu result.Memory = memory result.Swap = cadvisorInfoToSwapStats(info) + if utilfeature.DefaultFeatureGate.Enabled(features.KubeletPSI) { + result.IO = cadvisorInfoToIOStats(info) + } // NOTE: if they can be found, log stats will be overwritten // by the caller, as it knows more information about the pod, @@ -307,6 +318,24 @@ func cadvisorInfoToSwapStats(info *cadvisorapiv2.ContainerInfo) *statsapi.SwapSt return swapStats } +func cadvisorInfoToIOStats(info *cadvisorapiv2.ContainerInfo) *statsapi.IOStats { + cstat, found := latestContainerStats(info) + if !found { + return nil + } + + var ioStats *statsapi.IOStats + + if info.Spec.HasDiskIo && cstat.DiskIo != nil { + ioStats = &statsapi.IOStats{ + Time: metav1.NewTime(cstat.Timestamp), + PSI: cadvisorPSIToStatsPSI(&cstat.DiskIo.PSI), + } + } + + return ioStats +} + // latestContainerStats returns the latest container stats from cadvisor, or nil if none exist func latestContainerStats(info *cadvisorapiv2.ContainerInfo) (*cadvisorapiv2.ContainerStats, bool) { stats := info.Stats @@ -493,3 +522,23 @@ func makePodStorageStats(s *statsapi.PodStats, rootFsInfo *cadvisorapiv2.FsInfo, } s.EphemeralStorage = calcEphemeralStorage(s.Containers, ephemeralStats, rootFsInfo, logStats, etcHostsStats, isCRIStatsProvider) } + +func cadvisorPSIToStatsPSI(psi *cadvisorapiv1.PSIStats) *statsapi.PSIStats { + if psi == nil { + return nil + } + return &statsapi.PSIStats{ + Full: statsapi.PSIData{ + Total: psi.Full.Total, + Avg10: psi.Full.Avg10, + Avg60: psi.Full.Avg60, + Avg300: psi.Full.Avg300, + }, + Some: statsapi.PSIData{ + Total: psi.Some.Total, + Avg10: psi.Some.Avg10, + Avg60: psi.Some.Avg60, + Avg300: psi.Some.Avg300, + }, + } +} From 77118d4ca062fe6dc75765d447feb3e8dbd49ba7 Mon Sep 17 00:00:00 2001 From: Haowei Cai Date: Thu, 20 Mar 2025 19:28:20 +0000 Subject: [PATCH 4/7] Extend CRI API to support PSI --- .../cri-api/pkg/apis/runtime/v1/api.proto | 36 +++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/staging/src/k8s.io/cri-api/pkg/apis/runtime/v1/api.proto b/staging/src/k8s.io/cri-api/pkg/apis/runtime/v1/api.proto index 2f171610579..8d47df4680c 100644 --- a/staging/src/k8s.io/cri-api/pkg/apis/runtime/v1/api.proto +++ b/staging/src/k8s.io/cri-api/pkg/apis/runtime/v1/api.proto @@ -748,6 +748,8 @@ message LinuxPodSandboxStats { ProcessUsage process = 4; // Stats of containers in the measured pod sandbox. repeated ContainerStats containers = 5; + // IO usage gathered for the pod sandbox. + IoUsage io = 6; } // WindowsPodSandboxStats provides the resource usage statistics for a pod sandbox on windows @@ -1793,6 +1795,8 @@ message ContainerStats { FilesystemUsage writable_layer = 4; // Swap usage gathered from the container. SwapUsage swap = 5; + // IO usage gathered from the container. + IoUsage io = 6; } // WindowsContainerStats provides the resource usage statistics for a container specific for Windows @@ -1807,6 +1811,27 @@ message WindowsContainerStats { WindowsFilesystemUsage writable_layer = 4; } +// PSI statistics for an individual resource. +message PsiStats { + // PSI data for all tasks in the cgroup. + PsiData Full = 1; + // PSI data for some tasks in the cgroup. + PsiData Some = 2; +} + +// PSI data for an individual resource. +message PsiData { + // Total time duration for tasks in the cgroup have waited due to congestion. + // Unit: nanoseconds. + uint64 Total = 1; + // The average (in %) tasks have waited due to congestion over a 10 second window. + double Avg10 = 2; + // The average (in %) tasks have waited due to congestion over a 60 second window. + double Avg60 = 3; + // The average (in %) tasks have waited due to congestion over a 300 second window. + double Avg300 = 4; +} + // CpuUsage provides the CPU usage information. message CpuUsage { // Timestamp in nanoseconds at which the information were collected. Must be > 0. @@ -1816,6 +1841,8 @@ message CpuUsage { // Total CPU usage (sum of all cores) averaged over the sample window. // The "core" unit can be interpreted as CPU core-nanoseconds per second. UInt64Value usage_nano_cores = 3; + // CPU PSI statistics. + PsiStats psi = 4; } // WindowsCpuUsage provides the CPU usage information specific to Windows @@ -1845,6 +1872,15 @@ message MemoryUsage { UInt64Value page_faults = 6; // Cumulative number of major page faults. UInt64Value major_page_faults = 7; + // Memory PSI statistics. + PsiStats psi = 8; +} + +message IoUsage { + // Timestamp in nanoseconds at which the information were collected. Must be > 0. + int64 timestamp = 1; + // IO PSI statistics. + PsiStats psi = 2; } message SwapUsage { From 6bbaf8cb10459f15f61a26db035e79c7baf00437 Mon Sep 17 00:00:00 2001 From: Haowei Cai Date: Thu, 20 Mar 2025 19:28:45 +0000 Subject: [PATCH 5/7] Extend CRI stats provider to support PSI --- pkg/kubelet/stats/cri_stats_provider.go | 81 ++++++++++++++++++- pkg/kubelet/stats/cri_stats_provider_linux.go | 18 +++++ .../stats/cri_stats_provider_others.go | 3 + .../stats/cri_stats_provider_windows.go | 3 + 4 files changed, 103 insertions(+), 2 deletions(-) diff --git a/pkg/kubelet/stats/cri_stats_provider.go b/pkg/kubelet/stats/cri_stats_provider.go index bb42e8470d4..3df4c988ebc 100644 --- a/pkg/kubelet/stats/cri_stats_provider.go +++ b/pkg/kubelet/stats/cri_stats_provider.go @@ -33,11 +33,13 @@ import ( "google.golang.org/grpc/status" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" + utilfeature "k8s.io/apiserver/pkg/util/feature" internalapi "k8s.io/cri-api/pkg/apis" runtimeapi "k8s.io/cri-api/pkg/apis/runtime/v1" "k8s.io/klog/v2" statsapi "k8s.io/kubelet/pkg/apis/stats/v1alpha1" kubetypes "k8s.io/kubelet/pkg/types" + "k8s.io/kubernetes/pkg/features" "k8s.io/kubernetes/pkg/kubelet/cadvisor" "k8s.io/kubernetes/pkg/kubelet/server/stats" "k8s.io/utils/clock" @@ -211,6 +213,7 @@ func (p *criStatsProvider) listPodStatsPartiallyFromCRI(ctx context.Context, upd p.addPodNetworkStats(ps, podSandboxID, caInfos, cs, containerNetworkStats[podSandboxID]) p.addPodCPUMemoryStats(ps, types.UID(podSandbox.Metadata.Uid), allInfos, cs) p.addSwapStats(ps, types.UID(podSandbox.Metadata.Uid), allInfos, cs) + p.addIOStats(ps, types.UID(podSandbox.Metadata.Uid), allInfos, cs) // If cadvisor stats is available for the container, use it to populate // container stats @@ -260,6 +263,7 @@ func (p *criStatsProvider) listPodStatsStrictlyFromCRI(ctx context.Context, upda addCRIPodCPUStats(ps, criSandboxStat) addCRIPodMemoryStats(ps, criSandboxStat) addCRIPodProcessStats(ps, criSandboxStat) + addCRIPodIOStats(ps, criSandboxStat) makePodStorageStats(ps, rootFsInfo, p.resourceAnalyzer, p.hostStatsProvider, true) summarySandboxStats = append(summarySandboxStats, *ps) } @@ -535,6 +539,7 @@ func (p *criStatsProvider) addPodCPUMemoryStats( usageNanoCores := getUint64Value(cs.CPU.UsageNanoCores) + getUint64Value(ps.CPU.UsageNanoCores) ps.CPU.UsageCoreNanoSeconds = &usageCoreNanoSeconds ps.CPU.UsageNanoCores = &usageNanoCores + // Pod level PSI stats cannot be calculated from container level } if cs.Memory != nil { @@ -555,6 +560,7 @@ func (p *criStatsProvider) addPodCPUMemoryStats( ps.Memory.RSSBytes = &rSSBytes ps.Memory.PageFaults = &pageFaults ps.Memory.MajorPageFaults = &majorPageFaults + // Pod level PSI stats cannot be calculated from container level } } @@ -564,14 +570,14 @@ func (p *criStatsProvider) addSwapStats( allInfos map[string]cadvisorapiv2.ContainerInfo, cs *statsapi.ContainerStats, ) { - // try get cpu and memory stats from cadvisor first. + // try get swap stats from cadvisor first. podCgroupInfo := getCadvisorPodInfoFromPodUID(podUID, allInfos) if podCgroupInfo != nil { ps.Swap = cadvisorInfoToSwapStats(podCgroupInfo) return } - // Sum Pod cpu and memory stats from containers stats. + // Sum Pod swap stats from containers stats. if cs.Swap != nil { if ps.Swap == nil { ps.Swap = &statsapi.SwapStats{Time: cs.Swap.Time} @@ -583,6 +589,30 @@ func (p *criStatsProvider) addSwapStats( } } +func (p *criStatsProvider) addIOStats( + ps *statsapi.PodStats, + podUID types.UID, + allInfos map[string]cadvisorapiv2.ContainerInfo, + cs *statsapi.ContainerStats, +) { + if !utilfeature.DefaultFeatureGate.Enabled(features.KubeletPSI) { + return + } + // try get IO stats from cadvisor first. + podCgroupInfo := getCadvisorPodInfoFromPodUID(podUID, allInfos) + if podCgroupInfo != nil { + ps.IO = cadvisorInfoToIOStats(podCgroupInfo) + return + } + + if cs.IO != nil { + if ps.IO == nil { + ps.IO = &statsapi.IOStats{Time: cs.IO.Time} + } + // Pod level PSI stats cannot be calculated from container level + } +} + func (p *criStatsProvider) addProcessStats( ps *statsapi.PodStats, container *cadvisorapiv2.ContainerInfo, @@ -624,6 +654,7 @@ func (p *criStatsProvider) makeContainerStats( if usageNanoCores != nil { result.CPU.UsageNanoCores = usageNanoCores } + result.CPU.PSI = makePSIStats(stats.Cpu.Psi) } else { result.CPU.Time = metav1.NewTime(time.Unix(0, time.Now().UnixNano())) result.CPU.UsageCoreNanoSeconds = uint64Ptr(0) @@ -634,6 +665,7 @@ func (p *criStatsProvider) makeContainerStats( if stats.Memory.WorkingSetBytes != nil { result.Memory.WorkingSetBytes = &stats.Memory.WorkingSetBytes.Value } + result.Memory.PSI = makePSIStats(stats.Memory.Psi) } else { result.Memory.Time = metav1.NewTime(time.Unix(0, time.Now().UnixNano())) result.Memory.WorkingSetBytes = uint64Ptr(0) @@ -651,6 +683,15 @@ func (p *criStatsProvider) makeContainerStats( result.Swap.SwapUsageBytes = uint64Ptr(0) result.Swap.SwapAvailableBytes = uint64Ptr(0) } + if utilfeature.DefaultFeatureGate.Enabled(features.KubeletPSI) { + result.IO = &statsapi.IOStats{} + if stats.Io != nil { + result.IO.Time = metav1.NewTime(time.Unix(0, stats.Io.Timestamp)) + result.IO.PSI = makePSIStats(stats.Io.Psi) + } else { + result.IO.Time = metav1.NewTime(time.Unix(0, time.Now().UnixNano())) + } + } if stats.WritableLayer != nil { result.Rootfs.Time = metav1.NewTime(time.Unix(0, stats.WritableLayer.Timestamp)) if stats.WritableLayer.UsedBytes != nil { @@ -714,6 +755,7 @@ func (p *criStatsProvider) makeContainerCPUAndMemoryStats( if usageNanoCores != nil { result.CPU.UsageNanoCores = usageNanoCores } + result.CPU.PSI = makePSIStats(stats.Cpu.Psi) } else { result.CPU.Time = metav1.NewTime(time.Unix(0, time.Now().UnixNano())) result.CPU.UsageCoreNanoSeconds = uint64Ptr(0) @@ -724,6 +766,7 @@ func (p *criStatsProvider) makeContainerCPUAndMemoryStats( if stats.Memory.WorkingSetBytes != nil { result.Memory.WorkingSetBytes = &stats.Memory.WorkingSetBytes.Value } + result.Memory.PSI = makePSIStats(stats.Memory.Psi) } else { result.Memory.Time = metav1.NewTime(time.Unix(0, time.Now().UnixNano())) result.Memory.WorkingSetBytes = uint64Ptr(0) @@ -732,6 +775,33 @@ func (p *criStatsProvider) makeContainerCPUAndMemoryStats( return result } +func makePSIStats(stats *runtimeapi.PsiStats) *statsapi.PSIStats { + if !utilfeature.DefaultFeatureGate.Enabled(features.KubeletPSI) { + return nil + } + if stats == nil { + return nil + } + result := &statsapi.PSIStats{} + if stats.Full != nil { + result.Full = statsapi.PSIData{ + Total: stats.Full.Total, + Avg10: stats.Full.Avg10, + Avg60: stats.Full.Avg60, + Avg300: stats.Full.Avg300, + } + } + if stats.Some != nil { + result.Some = statsapi.PSIData{ + Total: stats.Some.Total, + Avg10: stats.Some.Avg10, + Avg60: stats.Some.Avg60, + Avg300: stats.Some.Avg300, + } + } + return result +} + // getContainerUsageNanoCores first attempts to get the usage nano cores from the stats reported // by the CRI. If it is unable to, it gets the information from the cache instead. func (p *criStatsProvider) getContainerUsageNanoCores(stats *runtimeapi.ContainerStats) *uint64 { @@ -910,6 +980,13 @@ func (p *criStatsProvider) addCadvisorContainerStats( if swap != nil { cs.Swap = swap } + + if utilfeature.DefaultFeatureGate.Enabled(features.KubeletPSI) { + io := cadvisorInfoToIOStats(caPodStats) + if io != nil { + cs.IO = io + } + } } func (p *criStatsProvider) addCadvisorContainerCPUAndMemoryStats( diff --git a/pkg/kubelet/stats/cri_stats_provider_linux.go b/pkg/kubelet/stats/cri_stats_provider_linux.go index 9d8a0e479fa..953ce522c8d 100644 --- a/pkg/kubelet/stats/cri_stats_provider_linux.go +++ b/pkg/kubelet/stats/cri_stats_provider_linux.go @@ -25,8 +25,10 @@ import ( cadvisorapiv2 "github.com/google/cadvisor/info/v2" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + utilfeature "k8s.io/apiserver/pkg/util/feature" runtimeapi "k8s.io/cri-api/pkg/apis/runtime/v1" statsapi "k8s.io/kubelet/pkg/apis/stats/v1alpha1" + "k8s.io/kubernetes/pkg/features" ) func (p *criStatsProvider) addCRIPodContainerStats(criSandboxStat *runtimeapi.PodSandboxStats, @@ -79,6 +81,7 @@ func addCRIPodMemoryStats(ps *statsapi.PodStats, criPodStat *runtimeapi.PodSandb RSSBytes: valueOfUInt64Value(criMemory.RssBytes), PageFaults: valueOfUInt64Value(criMemory.PageFaults), MajorPageFaults: valueOfUInt64Value(criMemory.MajorPageFaults), + PSI: makePSIStats(criMemory.Psi), } } @@ -91,6 +94,21 @@ func addCRIPodCPUStats(ps *statsapi.PodStats, criPodStat *runtimeapi.PodSandboxS Time: metav1.NewTime(time.Unix(0, criCPU.Timestamp)), UsageNanoCores: valueOfUInt64Value(criCPU.UsageNanoCores), UsageCoreNanoSeconds: valueOfUInt64Value(criCPU.UsageCoreNanoSeconds), + PSI: makePSIStats(criCPU.Psi), + } +} + +func addCRIPodIOStats(ps *statsapi.PodStats, criPodStat *runtimeapi.PodSandboxStats) { + if !utilfeature.DefaultFeatureGate.Enabled(features.KubeletPSI) { + return + } + if criPodStat == nil || criPodStat.Linux == nil || criPodStat.Linux.Io == nil { + return + } + criIO := criPodStat.Linux.Io + ps.IO = &statsapi.IOStats{ + Time: metav1.NewTime(time.Unix(0, criIO.Timestamp)), + PSI: makePSIStats(criIO.Psi), } } diff --git a/pkg/kubelet/stats/cri_stats_provider_others.go b/pkg/kubelet/stats/cri_stats_provider_others.go index 55ed8e7a20b..6d4a6ede772 100644 --- a/pkg/kubelet/stats/cri_stats_provider_others.go +++ b/pkg/kubelet/stats/cri_stats_provider_others.go @@ -50,3 +50,6 @@ func addCRIPodCPUStats(ps *statsapi.PodStats, criPodStat *runtimeapi.PodSandboxS func addCRIPodProcessStats(ps *statsapi.PodStats, criPodStat *runtimeapi.PodSandboxStats) { } + +func addCRIPodIOStats(ps *statsapi.PodStats, criPodStat *runtimeapi.PodSandboxStats) { +} diff --git a/pkg/kubelet/stats/cri_stats_provider_windows.go b/pkg/kubelet/stats/cri_stats_provider_windows.go index 16788a9092a..33c3f6ccd8b 100644 --- a/pkg/kubelet/stats/cri_stats_provider_windows.go +++ b/pkg/kubelet/stats/cri_stats_provider_windows.go @@ -236,6 +236,9 @@ func addCRIPodMemoryStats(ps *statsapi.PodStats, criPodStat *runtimeapi.PodSandb } } +func addCRIPodIOStats(ps *statsapi.PodStats, criPodStat *runtimeapi.PodSandboxStats) { +} + func addCRIPodProcessStats(ps *statsapi.PodStats, criPodStat *runtimeapi.PodSandboxStats) { if criPodStat == nil || criPodStat.Windows == nil || criPodStat.Windows.Process == nil { return From c86ff2339d4b8aae58297500fb9c70615c672afb Mon Sep 17 00:00:00 2001 From: Haowei Cai Date: Thu, 20 Mar 2025 19:29:14 +0000 Subject: [PATCH 6/7] Unit and E2E tests --- pkg/kubelet/server/stats/summary_test.go | 17 ++ .../stats/cadvisor_stats_provider_test.go | 15 ++ pkg/kubelet/stats/cri_stats_provider_test.go | 167 +++++++++++++++++- pkg/kubelet/stats/helper_test.go | 36 ++++ pkg/kubelet/stats/provider_test.go | 53 +++++- test/e2e_node/summary_test.go | 52 +++++- 6 files changed, 328 insertions(+), 12 deletions(-) diff --git a/pkg/kubelet/server/stats/summary_test.go b/pkg/kubelet/server/stats/summary_test.go index 81286856ea1..0fbdd30e888 100644 --- a/pkg/kubelet/server/stats/summary_test.go +++ b/pkg/kubelet/server/stats/summary_test.go @@ -29,7 +29,10 @@ import ( v1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + utilfeature "k8s.io/apiserver/pkg/util/feature" + featuregatetesting "k8s.io/component-base/featuregate/testing" statsapi "k8s.io/kubelet/pkg/apis/stats/v1alpha1" + "k8s.io/kubernetes/pkg/features" "k8s.io/kubernetes/pkg/kubelet/cm" statstest "k8s.io/kubernetes/pkg/kubelet/server/stats/testing" ) @@ -48,6 +51,7 @@ var ( ) func TestSummaryProviderGetStatsNoSplitFileSystem(t *testing.T) { + featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.KubeletPSI, true) ctx := context.Background() assert := assert.New(t) @@ -98,6 +102,7 @@ func TestSummaryProviderGetStatsNoSplitFileSystem(t *testing.T) { assert.Equal(summary.Node.CPU, cgroupStatsMap["/"].cs.CPU) assert.Equal(summary.Node.Memory, cgroupStatsMap["/"].cs.Memory) assert.Equal(summary.Node.Swap, cgroupStatsMap["/"].cs.Swap) + assert.Equal(summary.Node.IO, cgroupStatsMap["/"].cs.IO) assert.Equal(summary.Node.Network, cgroupStatsMap["/"].ns) assert.Equal(summary.Node.Fs, rootFsStats) assert.Equal(&statsapi.RuntimeStats{ContainerFs: imageFsStats, ImageFs: imageFsStats}, summary.Node.Runtime) @@ -111,6 +116,7 @@ func TestSummaryProviderGetStatsNoSplitFileSystem(t *testing.T) { Accelerators: cgroupStatsMap["/kubelet"].cs.Accelerators, UserDefinedMetrics: cgroupStatsMap["/kubelet"].cs.UserDefinedMetrics, Swap: cgroupStatsMap["/kubelet"].cs.Swap, + IO: cgroupStatsMap["/kubelet"].cs.IO, }) assert.Contains(summary.Node.SystemContainers, statsapi.ContainerStats{ Name: "misc", @@ -120,6 +126,7 @@ func TestSummaryProviderGetStatsNoSplitFileSystem(t *testing.T) { Accelerators: cgroupStatsMap["/misc"].cs.Accelerators, UserDefinedMetrics: cgroupStatsMap["/misc"].cs.UserDefinedMetrics, Swap: cgroupStatsMap["/misc"].cs.Swap, + IO: cgroupStatsMap["/misc"].cs.IO, }) assert.Contains(summary.Node.SystemContainers, statsapi.ContainerStats{ Name: "runtime", @@ -129,6 +136,7 @@ func TestSummaryProviderGetStatsNoSplitFileSystem(t *testing.T) { Accelerators: cgroupStatsMap["/runtime"].cs.Accelerators, UserDefinedMetrics: cgroupStatsMap["/runtime"].cs.UserDefinedMetrics, Swap: cgroupStatsMap["/runtime"].cs.Swap, + IO: cgroupStatsMap["/runtime"].cs.IO, }) assert.Contains(summary.Node.SystemContainers, statsapi.ContainerStats{ Name: "pods", @@ -138,11 +146,13 @@ func TestSummaryProviderGetStatsNoSplitFileSystem(t *testing.T) { Accelerators: cgroupStatsMap["/pods"].cs.Accelerators, UserDefinedMetrics: cgroupStatsMap["/pods"].cs.UserDefinedMetrics, Swap: cgroupStatsMap["/pods"].cs.Swap, + IO: cgroupStatsMap["/pods"].cs.IO, }) assert.Equal(summary.Pods, podStats) } func TestSummaryProviderGetStatsSplitImageFs(t *testing.T) { + featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.KubeletPSI, true) ctx := context.Background() assert := assert.New(t) @@ -194,6 +204,7 @@ func TestSummaryProviderGetStatsSplitImageFs(t *testing.T) { assert.Equal(summary.Node.CPU, cgroupStatsMap["/"].cs.CPU) assert.Equal(summary.Node.Memory, cgroupStatsMap["/"].cs.Memory) assert.Equal(summary.Node.Swap, cgroupStatsMap["/"].cs.Swap) + assert.Equal(summary.Node.IO, cgroupStatsMap["/"].cs.IO) assert.Equal(summary.Node.Network, cgroupStatsMap["/"].ns) assert.Equal(summary.Node.Fs, rootFsStats) // Since we are a split filesystem we want root filesystem to be container fs and image to be image filesystem @@ -208,6 +219,7 @@ func TestSummaryProviderGetStatsSplitImageFs(t *testing.T) { Accelerators: cgroupStatsMap["/kubelet"].cs.Accelerators, UserDefinedMetrics: cgroupStatsMap["/kubelet"].cs.UserDefinedMetrics, Swap: cgroupStatsMap["/kubelet"].cs.Swap, + IO: cgroupStatsMap["/kubelet"].cs.IO, }) assert.Contains(summary.Node.SystemContainers, statsapi.ContainerStats{ Name: "misc", @@ -217,6 +229,7 @@ func TestSummaryProviderGetStatsSplitImageFs(t *testing.T) { Accelerators: cgroupStatsMap["/misc"].cs.Accelerators, UserDefinedMetrics: cgroupStatsMap["/misc"].cs.UserDefinedMetrics, Swap: cgroupStatsMap["/misc"].cs.Swap, + IO: cgroupStatsMap["/misc"].cs.IO, }) assert.Contains(summary.Node.SystemContainers, statsapi.ContainerStats{ Name: "runtime", @@ -226,6 +239,7 @@ func TestSummaryProviderGetStatsSplitImageFs(t *testing.T) { Accelerators: cgroupStatsMap["/runtime"].cs.Accelerators, UserDefinedMetrics: cgroupStatsMap["/runtime"].cs.UserDefinedMetrics, Swap: cgroupStatsMap["/runtime"].cs.Swap, + IO: cgroupStatsMap["/runtime"].cs.IO, }) assert.Contains(summary.Node.SystemContainers, statsapi.ContainerStats{ Name: "pods", @@ -235,11 +249,13 @@ func TestSummaryProviderGetStatsSplitImageFs(t *testing.T) { Accelerators: cgroupStatsMap["/pods"].cs.Accelerators, UserDefinedMetrics: cgroupStatsMap["/pods"].cs.UserDefinedMetrics, Swap: cgroupStatsMap["/pods"].cs.Swap, + IO: cgroupStatsMap["/pods"].cs.IO, }) assert.Equal(summary.Pods, podStats) } func TestSummaryProviderGetCPUAndMemoryStats(t *testing.T) { + featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.KubeletPSI, true) ctx := context.Background() assert := assert.New(t) @@ -283,6 +299,7 @@ func TestSummaryProviderGetCPUAndMemoryStats(t *testing.T) { assert.Nil(summary.Node.Network) assert.Nil(summary.Node.Fs) assert.Nil(summary.Node.Runtime) + assert.Nil(summary.Node.IO) assert.Len(summary.Node.SystemContainers, 4) assert.Contains(summary.Node.SystemContainers, statsapi.ContainerStats{ diff --git a/pkg/kubelet/stats/cadvisor_stats_provider_test.go b/pkg/kubelet/stats/cadvisor_stats_provider_test.go index 11a0bc8dd1a..9a8eabae4f0 100644 --- a/pkg/kubelet/stats/cadvisor_stats_provider_test.go +++ b/pkg/kubelet/stats/cadvisor_stats_provider_test.go @@ -114,6 +114,7 @@ func TestFilterTerminatedContainerInfoAndAssembleByPodCgroupKey(t *testing.T) { } func TestCadvisorListPodStats(t *testing.T) { + featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.KubeletPSI, true) ctx := context.Background() const ( namespace0 = "test0" @@ -295,12 +296,14 @@ func TestCadvisorListPodStats(t *testing.T) { checkCPUStats(t, "Pod0Container0", seedPod0Container0, con.CPU) checkMemoryStats(t, "Pod0Conainer0", seedPod0Container0, infos["/pod0-c0"], con.Memory) checkSwapStats(t, "Pod0Conainer0", seedPod0Container0, infos["/pod0-c0"], con.Swap) + checkIOStats(t, "Pod0Conainer0", seedPod0Container0, infos["/pod0-c0"], con.IO) con = indexCon[cName01] assert.EqualValues(t, testTime(creationTime, seedPod0Container1).Unix(), con.StartTime.Time.Unix()) checkCPUStats(t, "Pod0Container1", seedPod0Container1, con.CPU) checkMemoryStats(t, "Pod0Container1", seedPod0Container1, infos["/pod0-c1"], con.Memory) checkSwapStats(t, "Pod0Container1", seedPod0Container1, infos["/pod0-c1"], con.Swap) + checkIOStats(t, "Pod0Container1", seedPod0Container1, infos["/pod0-c1"], con.IO) assert.EqualValues(t, p0Time.Unix(), ps.StartTime.Time.Unix()) checkNetworkStats(t, "Pod0", seedPod0Infra, ps.Network) @@ -315,6 +318,9 @@ func TestCadvisorListPodStats(t *testing.T) { checkSwapStats(t, "Pod0", seedPod0Infra, infos["/pod0-i"], ps.Swap) checkContainersSwapStats(t, ps, infos["/pod0-c0"], infos["/pod0-c1"]) } + if ps.IO != nil { + checkIOStats(t, "Pod0", seedPod0Infra, infos["/pod0-i"], ps.IO) + } // Validate Pod1 Results ps, found = indexPods[prf1] @@ -325,6 +331,7 @@ func TestCadvisorListPodStats(t *testing.T) { checkCPUStats(t, "Pod1Container0", seedPod1Container, con.CPU) checkMemoryStats(t, "Pod1Container0", seedPod1Container, infos["/pod1-c0"], con.Memory) checkSwapStats(t, "Pod1Container0", seedPod1Container, infos["/pod1-c0"], con.Swap) + checkIOStats(t, "Pod1Container0", seedPod1Container, infos["/pod1-c0"], con.IO) checkNetworkStats(t, "Pod1", seedPod1Infra, ps.Network) checkContainersSwapStats(t, ps, infos["/pod1-c0"]) @@ -337,6 +344,7 @@ func TestCadvisorListPodStats(t *testing.T) { checkCPUStats(t, "Pod2Container0", seedPod2Container, con.CPU) checkMemoryStats(t, "Pod2Container0", seedPod2Container, infos["/pod2-c0"], con.Memory) checkSwapStats(t, "Pod2Container0", seedPod2Container, infos["/pod2-c0"], con.Swap) + checkIOStats(t, "Pod2Container0", seedPod2Container, infos["/pod2-c0"], con.IO) checkNetworkStats(t, "Pod2", seedPod2Infra, ps.Network) checkContainersSwapStats(t, ps, infos["/pod2-c0"]) @@ -355,10 +363,12 @@ func TestCadvisorListPodStats(t *testing.T) { checkCPUStats(t, "Pod3Container1", seedPod3Container1, con.CPU) checkMemoryStats(t, "Pod3Container1", seedPod3Container1, infos["/pod3-c1"], con.Memory) checkSwapStats(t, "Pod3Container1", seedPod3Container1, infos["/pod3-c1"], con.Swap) + checkIOStats(t, "Pod3Container1", seedPod3Container1, infos["/pod3-c1"], con.IO) checkContainersSwapStats(t, ps, infos["/pod3-c1"]) } func TestCadvisorListPodCPUAndMemoryStats(t *testing.T) { + featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.KubeletPSI, true) ctx := context.Background() const ( namespace0 = "test0" @@ -476,6 +486,7 @@ func TestCadvisorListPodCPUAndMemoryStats(t *testing.T) { assert.Nil(t, con.Logs) assert.Nil(t, con.Accelerators) assert.Nil(t, con.UserDefinedMetrics) + assert.Nil(t, con.IO) con = indexCon[cName01] assert.EqualValues(t, testTime(creationTime, seedPod0Container1).Unix(), con.StartTime.Time.Unix()) @@ -486,11 +497,13 @@ func TestCadvisorListPodCPUAndMemoryStats(t *testing.T) { assert.Nil(t, con.Logs) assert.Nil(t, con.Accelerators) assert.Nil(t, con.UserDefinedMetrics) + assert.Nil(t, con.IO) assert.EqualValues(t, testTime(creationTime, seedPod0Infra).Unix(), ps.StartTime.Time.Unix()) assert.Nil(t, ps.EphemeralStorage) assert.Nil(t, ps.VolumeStats) assert.Nil(t, ps.Network) + assert.Nil(t, con.IO) if ps.CPU != nil { checkCPUStats(t, "Pod0", seedPod0Infra, ps.CPU) } @@ -515,6 +528,7 @@ func TestCadvisorListPodCPUAndMemoryStats(t *testing.T) { assert.Nil(t, ps.EphemeralStorage) assert.Nil(t, ps.VolumeStats) assert.Nil(t, ps.Network) + assert.Nil(t, con.IO) // Validate Pod2 Results ps, found = indexPods[prf2] @@ -529,6 +543,7 @@ func TestCadvisorListPodCPUAndMemoryStats(t *testing.T) { assert.Nil(t, ps.EphemeralStorage) assert.Nil(t, ps.VolumeStats) assert.Nil(t, ps.Network) + assert.Nil(t, con.IO) } func TestCadvisorImagesFsStatsKubeletSeparateDiskOff(t *testing.T) { diff --git a/pkg/kubelet/stats/cri_stats_provider_test.go b/pkg/kubelet/stats/cri_stats_provider_test.go index 1011b05f0a5..e8694183a89 100644 --- a/pkg/kubelet/stats/cri_stats_provider_test.go +++ b/pkg/kubelet/stats/cri_stats_provider_test.go @@ -27,16 +27,20 @@ import ( "time" cadvisorfs "github.com/google/cadvisor/fs" + cadvisorapiv1 "github.com/google/cadvisor/info/v1" cadvisorapiv2 "github.com/google/cadvisor/info/v2" "github.com/stretchr/testify/assert" "k8s.io/apimachinery/pkg/api/resource" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" "k8s.io/apimachinery/pkg/util/uuid" + utilfeature "k8s.io/apiserver/pkg/util/feature" + featuregatetesting "k8s.io/component-base/featuregate/testing" runtimeapi "k8s.io/cri-api/pkg/apis/runtime/v1" critest "k8s.io/cri-api/pkg/apis/testing" statsapi "k8s.io/kubelet/pkg/apis/stats/v1alpha1" kubelettypes "k8s.io/kubelet/pkg/types" + "k8s.io/kubernetes/pkg/features" cadvisortest "k8s.io/kubernetes/pkg/kubelet/cadvisor/testing" "k8s.io/kubernetes/pkg/kubelet/cm" kubecontainertest "k8s.io/kubernetes/pkg/kubelet/container/testing" @@ -91,6 +95,7 @@ const ( const testPodLogDirectory = "/var/log/kube/pods/" // Use non-default path to ensure stats are collected properly func TestCRIListPodStats(t *testing.T) { + featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.KubeletPSI, true) ctx := context.Background() var ( imageFsMountpoint = "/test/mount/point" @@ -265,6 +270,7 @@ func TestCRIListPodStats(t *testing.T) { c0 := containerStatsMap[cName0] assert.Equal(container0.CreatedAt, c0.StartTime.UnixNano()) checkCRICPUAndMemoryStats(assert, c0, infos[container0.ContainerStatus.Id].Stats[0]) + checkCRIIOStats(assert, c0, infos[container0.ContainerStatus.Id].Stats[0]) assert.Nil(c0.Accelerators) checkCRIRootfsStats(assert, c0, containerStats0, &imageFsInfo) checkCRILogsStats(assert, c0, &rootFsInfo, containerLogStats0) @@ -272,12 +278,14 @@ func TestCRIListPodStats(t *testing.T) { c1 := containerStatsMap[cName1] assert.Equal(container1.CreatedAt, c1.StartTime.UnixNano()) checkCRICPUAndMemoryStats(assert, c1, infos[container1.ContainerStatus.Id].Stats[0]) + checkCRIIOStats(assert, c1, infos[container1.ContainerStatus.Id].Stats[0]) assert.Nil(c0.Accelerators) checkCRIRootfsStats(assert, c1, containerStats1, nil) checkCRILogsStats(assert, c1, &rootFsInfo, containerLogStats1) checkCRINetworkStats(assert, p0.Network, infos[sandbox0.PodSandboxStatus.Id].Stats[0].Network) checkCRIPodCPUAndMemoryStats(assert, p0, infos[sandbox0Cgroup].Stats[0]) checkCRIPodSwapStats(assert, p0, infos[sandbox0Cgroup].Stats[0]) + checkCRIPodIOStats(assert, p0, infos[sandbox0Cgroup].Stats[0]) checkContainersSwapStats(t, p0, infos[container0.Id], infos[container1.Id]) @@ -291,12 +299,14 @@ func TestCRIListPodStats(t *testing.T) { assert.Equal(cName2, c2.Name) assert.Equal(container2.CreatedAt, c2.StartTime.UnixNano()) checkCRICPUAndMemoryStats(assert, c2, infos[container2.ContainerStatus.Id].Stats[0]) + checkCRIIOStats(assert, c2, infos[container2.ContainerStatus.Id].Stats[0]) assert.Nil(c0.Accelerators) checkCRIRootfsStats(assert, c2, containerStats2, &imageFsInfo) checkCRILogsStats(assert, c2, &rootFsInfo, containerLogStats2) checkCRINetworkStats(assert, p1.Network, infos[sandbox1.PodSandboxStatus.Id].Stats[0].Network) checkCRIPodCPUAndMemoryStats(assert, p1, infos[sandbox1Cgroup].Stats[0]) checkCRIPodSwapStats(assert, p1, infos[sandbox1Cgroup].Stats[0]) + checkCRIPodIOStats(assert, p1, infos[sandbox1Cgroup].Stats[0]) checkContainersSwapStats(t, p1, infos[container2.Id]) @@ -311,6 +321,7 @@ func TestCRIListPodStats(t *testing.T) { assert.Equal(cName3, c3.Name) assert.Equal(container4.CreatedAt, c3.StartTime.UnixNano()) checkCRICPUAndMemoryStats(assert, c3, infos[container4.ContainerStatus.Id].Stats[0]) + checkCRIIOStats(assert, c3, infos[container4.ContainerStatus.Id].Stats[0]) assert.Nil(c0.Accelerators) checkCRIRootfsStats(assert, c3, containerStats4, &imageFsInfo) @@ -318,6 +329,7 @@ func TestCRIListPodStats(t *testing.T) { checkCRINetworkStats(assert, p2.Network, infos[sandbox2.PodSandboxStatus.Id].Stats[0].Network) checkCRIPodCPUAndMemoryStats(assert, p2, infos[sandbox2Cgroup].Stats[0]) checkCRIPodSwapStats(assert, p2, infos[sandbox2Cgroup].Stats[0]) + checkCRIPodIOStats(assert, p2, infos[sandbox2Cgroup].Stats[0]) checkContainersSwapStats(t, p2, infos[container4.Id]) @@ -332,9 +344,11 @@ func TestCRIListPodStats(t *testing.T) { assert.NotNil(c8.Memory.Time) checkCRIPodCPUAndMemoryStats(assert, p3, infos[sandbox3Cgroup].Stats[0]) checkCRIPodSwapStats(assert, p3, infos[sandbox3Cgroup].Stats[0]) + checkCRIPodIOStats(assert, p3, infos[sandbox3Cgroup].Stats[0]) } func TestListPodStatsStrictlyFromCRI(t *testing.T) { + featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.KubeletPSI, true) if runtime.GOOS == "windows" { // TODO: remove skip once the failing test has been fixed. t.Skip("Skip failing test on Windows.") @@ -494,6 +508,7 @@ func TestListPodStatsStrictlyFromCRI(t *testing.T) { c0 := containerStatsMap[cName0] assert.Equal(container0.CreatedAt, c0.StartTime.UnixNano()) checkCRICPUAndMemoryStatsForStrictlyFromCRI(assert, c0, exceptedContainerStatsMap[cName0]) + checkCRIIOStatsForStrictlyFromCRI(assert, c0, exceptedContainerStatsMap[cName0]) assert.Nil(c0.Accelerators) checkCRIRootfsStats(assert, c0, containerStats0, &imageFsInfo) checkCRILogsStats(assert, c0, &rootFsInfo, containerLogStats0) @@ -501,10 +516,12 @@ func TestListPodStatsStrictlyFromCRI(t *testing.T) { c1 := containerStatsMap[cName1] assert.Equal(container1.CreatedAt, c1.StartTime.UnixNano()) checkCRICPUAndMemoryStatsForStrictlyFromCRI(assert, c1, exceptedContainerStatsMap[cName1]) + checkCRIIOStatsForStrictlyFromCRI(assert, c1, exceptedContainerStatsMap[cName1]) assert.Nil(c0.Accelerators) checkCRIRootfsStats(assert, c1, containerStats1, nil) checkCRILogsStats(assert, c1, &rootFsInfo, containerLogStats1) checkCRIPodCPUAndMemoryStatsStrictlyFromCRI(assert, p0, exceptedPodStatsMap[prf0]) + checkCRIPodIOStatsStrictlyFromCRI(assert, p0, exceptedPodStatsMap[prf0]) assert.NotNil(cadvisorInfos[sandbox0Cgroup].Stats[0].Cpu) assert.NotNil(cadvisorInfos[sandbox0Cgroup].Stats[0].Memory) @@ -518,10 +535,12 @@ func TestListPodStatsStrictlyFromCRI(t *testing.T) { assert.Equal(cName2, c2.Name) assert.Equal(container2.CreatedAt, c2.StartTime.UnixNano()) checkCRICPUAndMemoryStatsForStrictlyFromCRI(assert, c2, exceptedContainerStatsMap[cName2]) + checkCRIIOStatsForStrictlyFromCRI(assert, c2, exceptedContainerStatsMap[cName2]) assert.Nil(c0.Accelerators) checkCRIRootfsStats(assert, c2, containerStats2, &imageFsInfo) checkCRILogsStats(assert, c2, &rootFsInfo, containerLogStats2) checkCRIPodCPUAndMemoryStatsStrictlyFromCRI(assert, p1, exceptedPodStatsMap[prf1]) + checkCRIPodIOStatsStrictlyFromCRI(assert, p1, exceptedPodStatsMap[prf1]) if runtime.GOOS == "linux" { if _, ok := cadvisorInfos[sandbox1Cgroup]; ok { @@ -530,6 +549,7 @@ func TestListPodStatsStrictlyFromCRI(t *testing.T) { } } func TestCRIListPodCPUAndMemoryStats(t *testing.T) { + featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.KubeletPSI, true) ctx := context.Background() var ( @@ -656,6 +676,7 @@ func TestCRIListPodCPUAndMemoryStats(t *testing.T) { assert.Nil(p0.EphemeralStorage) assert.Nil(p0.VolumeStats) assert.Nil(p0.Network) + assert.Nil(p0.IO) checkCRIPodCPUAndMemoryStats(assert, p0, infos[sandbox0Cgroup].Stats[0]) containerStatsMap := make(map[string]statsapi.ContainerStats) @@ -670,6 +691,7 @@ func TestCRIListPodCPUAndMemoryStats(t *testing.T) { assert.Nil(c0.Logs) assert.Nil(c0.Accelerators) assert.Nil(c0.UserDefinedMetrics) + assert.Nil(c0.IO) c1 := containerStatsMap[cName1] assert.Equal(container1.CreatedAt, c1.StartTime.UnixNano()) checkCRICPUAndMemoryStats(assert, c1, infos[container1.ContainerStatus.Id].Stats[0]) @@ -677,6 +699,7 @@ func TestCRIListPodCPUAndMemoryStats(t *testing.T) { assert.Nil(c1.Logs) assert.Nil(c1.Accelerators) assert.Nil(c1.UserDefinedMetrics) + assert.Nil(c1.IO) p1 := podStatsMap[statsapi.PodReference{Name: "sandbox1-name", UID: "sandbox1-uid", Namespace: "sandbox1-ns"}] assert.Equal(sandbox1.CreatedAt, p1.StartTime.UnixNano()) @@ -684,6 +707,7 @@ func TestCRIListPodCPUAndMemoryStats(t *testing.T) { assert.Nil(p1.EphemeralStorage) assert.Nil(p1.VolumeStats) assert.Nil(p1.Network) + assert.Nil(p1.IO) checkCRIPodCPUAndMemoryStats(assert, p1, infos[sandbox1Cgroup].Stats[0]) c2 := p1.Containers[0] @@ -694,6 +718,7 @@ func TestCRIListPodCPUAndMemoryStats(t *testing.T) { assert.Nil(c2.Logs) assert.Nil(c2.Accelerators) assert.Nil(c2.UserDefinedMetrics) + assert.Nil(c2.IO) p2 := podStatsMap[statsapi.PodReference{Name: "sandbox2-name", UID: "sandbox2-uid", Namespace: "sandbox2-ns"}] assert.Equal(sandbox2.CreatedAt, p2.StartTime.UnixNano()) @@ -701,6 +726,7 @@ func TestCRIListPodCPUAndMemoryStats(t *testing.T) { assert.Nil(p2.EphemeralStorage) assert.Nil(p2.VolumeStats) assert.Nil(p2.Network) + assert.Nil(p2.IO) checkCRIPodCPUAndMemoryStats(assert, p2, infos[sandbox2Cgroup].Stats[0]) c3 := p2.Containers[0] @@ -711,6 +737,7 @@ func TestCRIListPodCPUAndMemoryStats(t *testing.T) { assert.Nil(c2.Logs) assert.Nil(c2.Accelerators) assert.Nil(c2.UserDefinedMetrics) + assert.Nil(c2.IO) p3 := podStatsMap[statsapi.PodReference{Name: "sandbox3-name", UID: "sandbox3-uid", Namespace: "sandbox3-ns"}] assert.Equal(sandbox3.CreatedAt, p3.StartTime.UnixNano()) @@ -881,14 +908,21 @@ func makeFakeContainerStatsStrictlyFromCRI(seed int, container *critest.FakeCont if container.State == runtimeapi.ContainerState_CONTAINER_EXITED { containerStats.Cpu = nil containerStats.Memory = nil + containerStats.Io = nil } else { containerStats.Cpu = &runtimeapi.CpuUsage{ Timestamp: timestamp.UnixNano(), UsageCoreNanoSeconds: &runtimeapi.UInt64Value{Value: uint64(seed + offsetCRI + offsetCPUUsageCoreSeconds)}, + Psi: getCRITestPSIStats(seed), } containerStats.Memory = &runtimeapi.MemoryUsage{ Timestamp: timestamp.UnixNano(), WorkingSetBytes: &runtimeapi.UInt64Value{Value: uint64(seed + offsetCRI + offsetMemWorkingSetBytes)}, + Psi: getCRITestPSIStats(seed), + } + containerStats.Io = &runtimeapi.IoUsage{ + Timestamp: timestamp.UnixNano(), + Psi: getCRITestPSIStats(seed), } } return containerStats @@ -906,19 +940,44 @@ func makeFakePodSandboxStatsStrictlyFromCRI(seed int, podSandbox *critest.FakePo if podSandbox.State == runtimeapi.PodSandboxState_SANDBOX_NOTREADY { podSandboxStats.Linux.Cpu = nil podSandboxStats.Linux.Memory = nil + podSandboxStats.Linux.Io = nil } else { podSandboxStats.Linux.Cpu = &runtimeapi.CpuUsage{ Timestamp: timestamp.UnixNano(), UsageCoreNanoSeconds: &runtimeapi.UInt64Value{Value: uint64(seed + offsetCRI + offsetCPUUsageCoreSeconds)}, + Psi: getCRITestPSIStats(seed), } podSandboxStats.Linux.Memory = &runtimeapi.MemoryUsage{ Timestamp: timestamp.UnixNano(), WorkingSetBytes: &runtimeapi.UInt64Value{Value: uint64(seed + offsetCRI + offsetMemWorkingSetBytes)}, + Psi: getCRITestPSIStats(seed), + } + podSandboxStats.Linux.Io = &runtimeapi.IoUsage{ + Timestamp: timestamp.UnixNano(), + Psi: getCRITestPSIStats(seed), } } return podSandboxStats } + +func getCRITestPSIStats(seed int) *runtimeapi.PsiStats { + return &runtimeapi.PsiStats{ + Full: getCRITestPSIData(seed), + Some: getCRITestPSIData(seed), + } +} + +func getCRITestPSIData(seed int) *runtimeapi.PsiData { + return &runtimeapi.PsiData{ + Total: uint64(seed + offsetPSIDataTotal), + Avg10: float64(10), + Avg60: float64(10), + Avg300: float64(10), + } +} + func getPodSandboxStatsStrictlyFromCRI(seed int, podSandbox *critest.FakePodSandbox) statsapi.PodStats { + psi := getTestPSIStats(seed) podStats := statsapi.PodStats{ PodRef: statsapi.PodReference{ Name: podSandbox.Metadata.Name, @@ -931,16 +990,23 @@ func getPodSandboxStatsStrictlyFromCRI(seed int, podSandbox *critest.FakePodSand if podSandbox.State == runtimeapi.PodSandboxState_SANDBOX_NOTREADY { podStats.CPU = nil podStats.Memory = nil + podStats.IO = nil } else { usageCoreNanoSeconds := uint64(seed + offsetCRI + offsetCPUUsageCoreSeconds) workingSetBytes := uint64(seed + offsetCRI + offsetMemWorkingSetBytes) podStats.CPU = &statsapi.CPUStats{ Time: metav1.NewTime(timestamp), UsageCoreNanoSeconds: &usageCoreNanoSeconds, + PSI: cadvisorPSIToStatsPSI(&psi), } podStats.Memory = &statsapi.MemoryStats{ Time: metav1.NewTime(timestamp), WorkingSetBytes: &workingSetBytes, + PSI: cadvisorPSIToStatsPSI(&psi), + } + podStats.IO = &statsapi.IOStats{ + Time: metav1.NewTime(timestamp), + PSI: cadvisorPSIToStatsPSI(&psi), } } @@ -992,12 +1058,34 @@ func checkCRICPUAndMemoryStats(assert *assert.Assertions, actual statsapi.Contai assert.Equal(cs.Memory.RSS, *actual.Memory.RSSBytes) assert.Equal(cs.Memory.ContainerData.Pgfault, *actual.Memory.PageFaults) assert.Equal(cs.Memory.ContainerData.Pgmajfault, *actual.Memory.MajorPageFaults) + + if utilfeature.DefaultFeatureGate.Enabled(features.KubeletPSI) { + checkCRIPSIStats(assert, &cs.Cpu.PSI, actual.CPU.PSI) + checkCRIPSIStats(assert, &cs.Memory.PSI, actual.Memory.PSI) + } } -func checkCRICPUAndMemoryStatsForStrictlyFromCRI(assert *assert.Assertions, actual statsapi.ContainerStats, excepted statsapi.ContainerStats) { - assert.Equal(excepted.CPU.Time.UnixNano(), actual.CPU.Time.UnixNano()) - assert.Equal(*excepted.CPU.UsageCoreNanoSeconds, *actual.CPU.UsageCoreNanoSeconds) - assert.Equal(*excepted.Memory.WorkingSetBytes, *actual.Memory.WorkingSetBytes) +func checkCRIIOStats(assert *assert.Assertions, actual statsapi.ContainerStats, cs *cadvisorapiv2.ContainerStats) { + if utilfeature.DefaultFeatureGate.Enabled(features.KubeletPSI) { + checkCRIPSIStats(assert, &cs.DiskIo.PSI, actual.IO.PSI) + } +} + +func checkCRICPUAndMemoryStatsForStrictlyFromCRI(assert *assert.Assertions, actual statsapi.ContainerStats, expected statsapi.ContainerStats) { + assert.Equal(expected.CPU.Time.UnixNano(), actual.CPU.Time.UnixNano()) + assert.Equal(*expected.CPU.UsageCoreNanoSeconds, *actual.CPU.UsageCoreNanoSeconds) + assert.Equal(*expected.Memory.WorkingSetBytes, *actual.Memory.WorkingSetBytes) + + if utilfeature.DefaultFeatureGate.Enabled(features.KubeletPSI) { + checkCRIPSIStatsStrictlyFromCRI(assert, expected.CPU.PSI, actual.CPU.PSI) + checkCRIPSIStatsStrictlyFromCRI(assert, expected.Memory.PSI, actual.Memory.PSI) + } +} + +func checkCRIIOStatsForStrictlyFromCRI(assert *assert.Assertions, actual statsapi.ContainerStats, expected statsapi.ContainerStats) { + if utilfeature.DefaultFeatureGate.Enabled(features.KubeletPSI) { + checkCRIPSIStatsStrictlyFromCRI(assert, expected.IO.PSI, actual.IO.PSI) + } } func checkCRIRootfsStats(assert *assert.Assertions, actual statsapi.ContainerStats, cs *runtimeapi.ContainerStats, imageFsInfo *cadvisorapiv2.FsInfo) { @@ -1078,6 +1166,48 @@ func checkCRIPodCPUAndMemoryStats(assert *assert.Assertions, actual statsapi.Pod assert.Equal(cs.Memory.RSS, *actual.Memory.RSSBytes) assert.Equal(cs.Memory.ContainerData.Pgfault, *actual.Memory.PageFaults) assert.Equal(cs.Memory.ContainerData.Pgmajfault, *actual.Memory.MajorPageFaults) + + if utilfeature.DefaultFeatureGate.Enabled(features.KubeletPSI) { + checkCRIPSIStats(assert, &cs.Cpu.PSI, actual.CPU.PSI) + checkCRIPSIStats(assert, &cs.Memory.PSI, actual.Memory.PSI) + } +} + +func checkCRIPodIOStats(assert *assert.Assertions, actual statsapi.PodStats, cs *cadvisorapiv2.ContainerStats) { + if runtime.GOOS != "linux" { + return + } + if utilfeature.DefaultFeatureGate.Enabled(features.KubeletPSI) { + checkCRIPSIStats(assert, &cs.DiskIo.PSI, actual.IO.PSI) + } +} + +func checkCRIPSIStats(assert *assert.Assertions, want *cadvisorapiv1.PSIStats, got *statsapi.PSIStats) { + assert.NotNil(want) + assert.NotNil(got) + checkCRIPSIData(assert, want.Full, got.Full) + checkCRIPSIData(assert, want.Some, got.Some) +} + +func checkCRIPSIData(assert *assert.Assertions, want cadvisorapiv1.PSIData, got statsapi.PSIData) { + assert.Equal(want.Total, got.Total) + assert.InDelta(want.Avg10, got.Avg10, 0.01) + assert.InDelta(want.Avg60, got.Avg60, 0.01) + assert.InDelta(want.Avg300, got.Avg300, 0.01) +} + +func checkCRIPSIStatsStrictlyFromCRI(assert *assert.Assertions, want, got *statsapi.PSIStats) { + assert.NotNil(want) + assert.NotNil(got) + checkCRIPSIDataStrictlyFromCRI(assert, want.Full, got.Full) + checkCRIPSIDataStrictlyFromCRI(assert, want.Some, got.Some) +} + +func checkCRIPSIDataStrictlyFromCRI(assert *assert.Assertions, want, got statsapi.PSIData) { + assert.Equal(want.Total, got.Total) + assert.InDelta(want.Avg10, got.Avg10, 0.01) + assert.InDelta(want.Avg60, got.Avg60, 0.01) + assert.InDelta(want.Avg300, got.Avg300, 0.01) } func checkCRIPodSwapStats(assert *assert.Assertions, actual statsapi.PodStats, cs *cadvisorapiv2.ContainerStats) { @@ -1089,13 +1219,27 @@ func checkCRIPodSwapStats(assert *assert.Assertions, actual statsapi.PodStats, c assert.Equal(cs.Memory.Swap, *actual.Swap.SwapUsageBytes) } -func checkCRIPodCPUAndMemoryStatsStrictlyFromCRI(assert *assert.Assertions, actual statsapi.PodStats, excepted statsapi.PodStats) { +func checkCRIPodCPUAndMemoryStatsStrictlyFromCRI(assert *assert.Assertions, actual statsapi.PodStats, expected statsapi.PodStats) { if runtime.GOOS != "linux" { return } - assert.Equal(excepted.CPU.Time.UnixNano(), actual.CPU.Time.UnixNano()) - assert.Equal(*excepted.CPU.UsageCoreNanoSeconds, *actual.CPU.UsageCoreNanoSeconds) - assert.Equal(*excepted.Memory.WorkingSetBytes, *actual.Memory.WorkingSetBytes) + assert.Equal(expected.CPU.Time.UnixNano(), actual.CPU.Time.UnixNano()) + assert.Equal(*expected.CPU.UsageCoreNanoSeconds, *actual.CPU.UsageCoreNanoSeconds) + assert.Equal(*expected.Memory.WorkingSetBytes, *actual.Memory.WorkingSetBytes) + + if utilfeature.DefaultFeatureGate.Enabled(features.KubeletPSI) { + checkCRIPSIStatsStrictlyFromCRI(assert, expected.CPU.PSI, actual.CPU.PSI) + checkCRIPSIStatsStrictlyFromCRI(assert, expected.Memory.PSI, actual.Memory.PSI) + } +} + +func checkCRIPodIOStatsStrictlyFromCRI(assert *assert.Assertions, actual statsapi.PodStats, expected statsapi.PodStats) { + if runtime.GOOS != "linux" { + return + } + if utilfeature.DefaultFeatureGate.Enabled(features.KubeletPSI) { + checkCRIPSIStatsStrictlyFromCRI(assert, expected.IO.PSI, actual.IO.PSI) + } } func makeFakeLogStats(seed int) *volume.Metrics { @@ -1303,6 +1447,7 @@ func TestExtractIDFromCgroupPath(t *testing.T) { } func getCRIContainerStatsStrictlyFromCRI(seed int, containerName string) statsapi.ContainerStats { + psi := getTestPSIStats(seed) result := statsapi.ContainerStats{ Name: containerName, StartTime: metav1.NewTime(timestamp), @@ -1310,15 +1455,21 @@ func getCRIContainerStatsStrictlyFromCRI(seed int, containerName string) statsap Memory: &statsapi.MemoryStats{}, // UserDefinedMetrics is not supported by CRI. Rootfs: &statsapi.FsStats{}, + IO: &statsapi.IOStats{}, } result.CPU.Time = metav1.NewTime(timestamp) usageCoreNanoSeconds := uint64(seed + offsetCRI + offsetCPUUsageCoreSeconds) result.CPU.UsageCoreNanoSeconds = &usageCoreNanoSeconds + result.CPU.PSI = cadvisorPSIToStatsPSI(&psi) result.Memory.Time = metav1.NewTime(timestamp) workingSetBytes := uint64(seed + offsetCRI + offsetMemWorkingSetBytes) result.Memory.WorkingSetBytes = &workingSetBytes + result.Memory.PSI = cadvisorPSIToStatsPSI(&psi) + + result.IO.Time = metav1.NewTime(timestamp) + result.IO.PSI = cadvisorPSIToStatsPSI(&psi) result.Rootfs.Time = metav1.NewTime(timestamp) usedBytes := uint64(seed + offsetCRI + offsetFsUsage) diff --git a/pkg/kubelet/stats/helper_test.go b/pkg/kubelet/stats/helper_test.go index d0bc23b69fa..3c111363bc1 100644 --- a/pkg/kubelet/stats/helper_test.go +++ b/pkg/kubelet/stats/helper_test.go @@ -17,6 +17,7 @@ limitations under the License. package stats import ( + "reflect" "testing" "time" @@ -26,6 +27,7 @@ import ( "github.com/stretchr/testify/assert" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/util/sets" statsapi "k8s.io/kubelet/pkg/apis/stats/v1alpha1" "k8s.io/utils/ptr" ) @@ -140,3 +142,37 @@ func TestMergeProcessStats(t *testing.T) { }) } } + +// TestCadvisorPSIStruct checks the fields in cadvisor PSI structs. If cadvisor +// PSI structs change, the conversion between cadvisor PSI structs and kubelet stats API structs needs to be re-evaluated and updated. +func TestCadvisorPSIStructs(t *testing.T) { + psiStatsFields := sets.New("Full", "Some") + s := cadvisorapiv1.PSIStats{} + st := reflect.TypeOf(s) + for i := 0; i < st.NumField(); i++ { + field := st.Field(i) + if !psiStatsFields.Has(field.Name) { + t.Errorf("cadvisorapiv1.PSIStats contains unknown field: %s. The conversion between cadvisor PSIStats and kubelet stats API PSIStats needs to be re-evaluated and updated.", field.Name) + } + } + + psiDataFields := map[string]reflect.Kind{ + "Total": reflect.Uint64, + "Avg10": reflect.Float64, + "Avg60": reflect.Float64, + "Avg300": reflect.Float64, + } + d := cadvisorapiv1.PSIData{} + dt := reflect.TypeOf(d) + for i := 0; i < dt.NumField(); i++ { + field := dt.Field(i) + wantKind, fieldExist := psiDataFields[field.Name] + if !fieldExist { + t.Errorf("cadvisorapiv1.PSIData contains unknown field: %s. The conversion between cadvisor PSIData and kubelet stats API PSIData needs to be re-evaluated and updated.", field.Name) + } + if field.Type.Kind() != wantKind { + t.Errorf("unexpected cadvisorapiv1.PSIStats field %s type, want: %s, got: %s. The conversion between cadvisor PSIStats and kubelet stats API PSIStats needs to be re-evaluated and updated.", field.Name, wantKind, field.Type.Kind()) + } + } + +} diff --git a/pkg/kubelet/stats/provider_test.go b/pkg/kubelet/stats/provider_test.go index 0d52a1c468b..81f94c26734 100644 --- a/pkg/kubelet/stats/provider_test.go +++ b/pkg/kubelet/stats/provider_test.go @@ -32,7 +32,9 @@ import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/types" + utilfeature "k8s.io/apiserver/pkg/util/feature" statsapi "k8s.io/kubelet/pkg/apis/stats/v1alpha1" + "k8s.io/kubernetes/pkg/features" cadvisortest "k8s.io/kubernetes/pkg/kubelet/cadvisor/testing" kubecontainertest "k8s.io/kubernetes/pkg/kubelet/container/testing" kubepodtest "k8s.io/kubernetes/pkg/kubelet/pod/testing" @@ -63,6 +65,7 @@ const ( offsetFsInodeUsage offsetAcceleratorDutyCycle offsetMemSwapUsageBytes + offsetPSIDataTotal ) var ( @@ -265,6 +268,7 @@ func getTestContainerInfo(seed int, podName string, podNamespace string, contain CreationTime: testTime(creationTime, seed), HasCpu: true, HasMemory: true, + HasDiskIo: true, HasNetwork: true, Labels: labels, Memory: cadvisorapiv2.MemorySpec{ @@ -280,8 +284,10 @@ func getTestContainerInfo(seed int, podName string, podNamespace string, contain stats := cadvisorapiv2.ContainerStats{ Timestamp: testTime(timestamp, seed), - Cpu: &cadvisorapiv1.CpuStats{}, - CpuInst: &cadvisorapiv2.CpuInstStats{}, + Cpu: &cadvisorapiv1.CpuStats{ + PSI: getTestPSIStats(seed), + }, + CpuInst: &cadvisorapiv2.CpuInstStats{}, Memory: &cadvisorapiv1.MemoryStats{ Usage: uint64(seed + offsetMemUsageBytes), WorkingSet: uint64(seed + offsetMemWorkingSetBytes), @@ -291,6 +297,7 @@ func getTestContainerInfo(seed int, podName string, podNamespace string, contain Pgmajfault: uint64(seed + offsetMemMajorPageFaults), }, Swap: uint64(seed + offsetMemSwapUsageBytes), + PSI: getTestPSIStats(seed), }, Network: &cadvisorapiv2.NetworkStats{ Interfaces: []cadvisorapiv1.InterfaceStats{{ @@ -323,6 +330,9 @@ func getTestContainerInfo(seed int, podName string, podNamespace string, contain DutyCycle: uint64(seed + offsetAcceleratorDutyCycle), }, }, + DiskIo: &cadvisorapiv1.DiskIoStats{ + PSI: getTestPSIStats(seed), + }, } stats.Cpu.Usage.Total = uint64(seed + offsetCPUUsageCoreSeconds) stats.CpuInst.Usage.Total = uint64(seed + offsetCPUUsageCores) @@ -332,6 +342,22 @@ func getTestContainerInfo(seed int, podName string, podNamespace string, contain } } +func getTestPSIStats(seed int) cadvisorapiv1.PSIStats { + return cadvisorapiv1.PSIStats{ + Full: getTestPSIData(seed), + Some: getTestPSIData(seed), + } +} + +func getTestPSIData(seed int) cadvisorapiv1.PSIData { + return cadvisorapiv1.PSIData{ + Total: uint64(seed + offsetPSIDataTotal), + Avg10: float64(10), + Avg60: float64(10), + Avg300: float64(10), + } +} + func getTestFsInfo(seed int) cadvisorapiv2.FsInfo { var ( inodes = uint64(seed + offsetFsInodes) @@ -469,6 +495,7 @@ func checkCPUStats(t *testing.T, label string, seed int, stats *statsapi.CPUStat assert.EqualValues(t, testTime(timestamp, seed).Unix(), stats.Time.Time.Unix(), label+".CPU.Time") assert.EqualValues(t, seed+offsetCPUUsageCores, *stats.UsageNanoCores, label+".CPU.UsageCores") assert.EqualValues(t, seed+offsetCPUUsageCoreSeconds, *stats.UsageCoreNanoSeconds, label+".CPU.UsageCoreSeconds") + checkPSIStats(t, label+".CPU", seed, stats.PSI) } func checkMemoryStats(t *testing.T, label string, seed int, info cadvisorapiv2.ContainerInfo, stats *statsapi.MemoryStats) { @@ -484,6 +511,28 @@ func checkMemoryStats(t *testing.T, label string, seed int, info cadvisorapiv2.C expected := info.Spec.Memory.Limit - *stats.WorkingSetBytes assert.EqualValues(t, expected, *stats.AvailableBytes, label+".Mem.AvailableBytes") } + checkPSIStats(t, label+".Mem", seed, stats.PSI) +} + +func checkIOStats(t *testing.T, label string, seed int, info cadvisorapiv2.ContainerInfo, stats *statsapi.IOStats) { + if utilfeature.DefaultFeatureGate.Enabled(features.KubeletPSI) { + assert.EqualValues(t, testTime(timestamp, seed).Unix(), stats.Time.Time.Unix(), label+".Mem.Time") + checkPSIStats(t, label+".IO", seed, stats.PSI) + } +} + +func checkPSIStats(t *testing.T, label string, seed int, stats *statsapi.PSIStats) { + if utilfeature.DefaultFeatureGate.Enabled(features.KubeletPSI) { + require.NotNil(t, stats, label+".PSI") + assert.EqualValues(t, seed+offsetPSIDataTotal, stats.Full.Total, label+".PSI.Full.Total") + assert.InDelta(t, 10, stats.Full.Avg10, 0.01, label+".PSI.Full.Avg10") + assert.InDelta(t, 10, stats.Full.Avg60, 0.01, label+".PSI.Full.Avg60") + assert.InDelta(t, 10, stats.Full.Avg300, 0.01, label+".PSI.Full.Avg300") + assert.EqualValues(t, seed+offsetPSIDataTotal, stats.Some.Total, label+".PSI.Some.Total") + assert.InDelta(t, 10, stats.Some.Avg10, 0.01, label+".PSI.Some.Avg10") + assert.InDelta(t, 10, stats.Some.Avg60, 0.01, label+".PSI.Some.Avg60") + assert.InDelta(t, 10, stats.Some.Avg300, 0.01, label+".PSI.Some.Avg300") + } } func checkSwapStats(t *testing.T, label string, seed int, info cadvisorapiv2.ContainerInfo, stats *statsapi.SwapStats) { diff --git a/test/e2e_node/summary_test.go b/test/e2e_node/summary_test.go index 77c2fa394a6..d36a662751d 100644 --- a/test/e2e_node/summary_test.go +++ b/test/e2e_node/summary_test.go @@ -19,6 +19,7 @@ package e2enode import ( "context" "fmt" + "math" "os" "strings" "time" @@ -26,7 +27,9 @@ import ( v1 "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/api/resource" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + utilfeature "k8s.io/apiserver/pkg/util/feature" kubeletstatsv1alpha1 "k8s.io/kubelet/pkg/apis/stats/v1alpha1" + "k8s.io/kubernetes/pkg/features" "k8s.io/kubernetes/test/e2e/framework" e2ekubectl "k8s.io/kubernetes/test/e2e/framework/kubectl" e2epod "k8s.io/kubernetes/test/e2e/framework/pod" @@ -100,6 +103,7 @@ var _ = SIGDescribe("Summary API", framework.WithNodeConformance(), func() { // for more information. "UsageNanoCores": gomega.SatisfyAny(gstruct.PointTo(gomega.BeZero()), bounded(10000, 2e9)), "UsageCoreNanoSeconds": bounded(10000000, 1e15), + "PSI": psiExpectation(), }), "Memory": ptrMatchAllFields(gstruct.Fields{ "Time": recent(maxStatsAge), @@ -111,7 +115,9 @@ var _ = SIGDescribe("Summary API", framework.WithNodeConformance(), func() { "RSSBytes": bounded(1*e2evolume.Mb, memoryLimit), "PageFaults": bounded(1000, 1e9), "MajorPageFaults": bounded(0, 1e9), + "PSI": psiExpectation(), }), + "IO": ioExpectation(maxStatsAge), "Swap": swapExpectation(memoryLimit), "Accelerators": gomega.BeEmpty(), "Rootfs": gomega.BeNil(), @@ -138,6 +144,7 @@ var _ = SIGDescribe("Summary API", framework.WithNodeConformance(), func() { "RSSBytes": bounded(1*e2evolume.Kb, memoryLimit), "PageFaults": bounded(0, expectedPageFaultsUpperBound), "MajorPageFaults": bounded(0, expectedMajorPageFaultsUpperBound), + "PSI": psiExpectation(), }) runtimeContExpectations := sysContExpectations().(*gstruct.FieldsMatcher) systemContainers := gstruct.Elements{ @@ -159,6 +166,7 @@ var _ = SIGDescribe("Summary API", framework.WithNodeConformance(), func() { "RSSBytes": bounded(100*e2evolume.Kb, memoryLimit), "PageFaults": bounded(1000, 1e9), "MajorPageFaults": bounded(0, 1e9), + "PSI": psiExpectation(), }) systemContainers["misc"] = miscContExpectations } @@ -174,6 +182,7 @@ var _ = SIGDescribe("Summary API", framework.WithNodeConformance(), func() { "Time": recent(maxStatsAge), "UsageNanoCores": bounded(10000, 1e9), "UsageCoreNanoSeconds": bounded(10000000, 1e11), + "PSI": psiExpectation(), }), "Memory": ptrMatchAllFields(gstruct.Fields{ "Time": recent(maxStatsAge), @@ -183,7 +192,9 @@ var _ = SIGDescribe("Summary API", framework.WithNodeConformance(), func() { "RSSBytes": bounded(1*e2evolume.Kb, 80*e2evolume.Mb), "PageFaults": bounded(100, expectedPageFaultsUpperBound), "MajorPageFaults": bounded(0, expectedMajorPageFaultsUpperBound), + "PSI": psiExpectation(), }), + "IO": ioExpectation(maxStatsAge), "Swap": swapExpectation(memoryLimit), "Accelerators": gomega.BeEmpty(), "Rootfs": ptrMatchAllFields(gstruct.Fields{ @@ -222,6 +233,7 @@ var _ = SIGDescribe("Summary API", framework.WithNodeConformance(), func() { "Time": recent(maxStatsAge), "UsageNanoCores": bounded(10000, 1e9), "UsageCoreNanoSeconds": bounded(10000000, 1e11), + "PSI": psiExpectation(), }), "Memory": ptrMatchAllFields(gstruct.Fields{ "Time": recent(maxStatsAge), @@ -231,7 +243,9 @@ var _ = SIGDescribe("Summary API", framework.WithNodeConformance(), func() { "RSSBytes": bounded(1*e2evolume.Kb, 80*e2evolume.Mb), "PageFaults": bounded(0, expectedPageFaultsUpperBound), "MajorPageFaults": bounded(0, expectedMajorPageFaultsUpperBound), + "PSI": psiExpectation(), }), + "IO": ioExpectation(maxStatsAge), "Swap": swapExpectation(memoryLimit), "VolumeStats": gstruct.MatchAllElements(summaryObjectID, gstruct.Elements{ "test-empty-dir": gstruct.MatchAllFields(gstruct.Fields{ @@ -272,6 +286,7 @@ var _ = SIGDescribe("Summary API", framework.WithNodeConformance(), func() { "Time": recent(maxStatsAge), "UsageNanoCores": bounded(100e3, 2e9), "UsageCoreNanoSeconds": bounded(1e9, 1e15), + "PSI": psiExpectation(), }), "Memory": ptrMatchAllFields(gstruct.Fields{ "Time": recent(maxStatsAge), @@ -282,7 +297,9 @@ var _ = SIGDescribe("Summary API", framework.WithNodeConformance(), func() { "RSSBytes": bounded(1*e2evolume.Kb, memoryLimit), "PageFaults": bounded(1000, 1e9), "MajorPageFaults": bounded(0, 1e9), + "PSI": psiExpectation(), }), + "IO": ioExpectation(maxStatsAge), "Swap": swapExpectation(memoryLimit), // TODO(#28407): Handle non-eth0 network interface names. "Network": ptrMatchAllFields(gstruct.Fields{ @@ -419,9 +436,13 @@ func ptrMatchAllFields(fields gstruct.Fields) types.GomegaMatcher { } func bounded(lower, upper interface{}) types.GomegaMatcher { - return gstruct.PointTo(gomega.And( + return gstruct.PointTo(boundedValue(lower, upper)) +} + +func boundedValue(lower, upper interface{}) types.GomegaMatcher { + return gomega.And( gomega.BeNumerically(">=", lower), - gomega.BeNumerically("<=", upper))) + gomega.BeNumerically("<=", upper)) } func swapExpectation(upper interface{}) types.GomegaMatcher { @@ -492,3 +513,30 @@ func recordSystemCgroupProcesses(ctx context.Context) { } } } + +func psiExpectation() types.GomegaMatcher { + if !utilfeature.DefaultFeatureGate.Enabled(features.KubeletPSI) { + return gomega.BeNil() + } + psiDataExpectation := gstruct.MatchAllFields(gstruct.Fields{ + "Total": boundedValue(0, uint64(math.MaxUint64)), + "Avg10": boundedValue(0, 100), + "Avg60": boundedValue(0, 100), + "Avg300": boundedValue(0, 100), + }) + return ptrMatchAllFields(gstruct.Fields{ + "Full": psiDataExpectation, + "Some": psiDataExpectation, + }) +} + +func ioExpectation(maxStatsAge time.Duration) types.GomegaMatcher { + if !utilfeature.DefaultFeatureGate.Enabled(features.KubeletPSI) { + return gomega.BeNil() + } + return gomega.Or(gomega.BeNil(), + ptrMatchAllFields(gstruct.Fields{ + "Time": recent(maxStatsAge), + "PSI": psiExpectation(), + })) +} From 914a4ba8bfa36c0a491c9be919cb0b5231781387 Mon Sep 17 00:00:00 2001 From: Haowei Cai Date: Thu, 20 Mar 2025 19:29:22 +0000 Subject: [PATCH 7/7] generated --- .../cri-api/pkg/apis/runtime/v1/api.pb.go | 2033 ++++++++++++----- 1 file changed, 1515 insertions(+), 518 deletions(-) diff --git a/staging/src/k8s.io/cri-api/pkg/apis/runtime/v1/api.pb.go b/staging/src/k8s.io/cri-api/pkg/apis/runtime/v1/api.pb.go index 8d261618697..5fa9baab21b 100644 --- a/staging/src/k8s.io/cri-api/pkg/apis/runtime/v1/api.pb.go +++ b/staging/src/k8s.io/cri-api/pkg/apis/runtime/v1/api.pb.go @@ -21,6 +21,7 @@ package v1 import ( context "context" + encoding_binary "encoding/binary" fmt "fmt" _ "github.com/gogo/protobuf/gogoproto" proto "github.com/gogo/protobuf/proto" @@ -3014,9 +3015,11 @@ type LinuxPodSandboxStats struct { // Stats pertaining to processes in the pod sandbox. Process *ProcessUsage `protobuf:"bytes,4,opt,name=process,proto3" json:"process,omitempty"` // Stats of containers in the measured pod sandbox. - Containers []*ContainerStats `protobuf:"bytes,5,rep,name=containers,proto3" json:"containers,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_sizecache int32 `json:"-"` + Containers []*ContainerStats `protobuf:"bytes,5,rep,name=containers,proto3" json:"containers,omitempty"` + // IO usage gathered for the pod sandbox. + Io *IoUsage `protobuf:"bytes,6,opt,name=io,proto3" json:"io,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *LinuxPodSandboxStats) Reset() { *m = LinuxPodSandboxStats{} } @@ -3086,6 +3089,13 @@ func (m *LinuxPodSandboxStats) GetContainers() []*ContainerStats { return nil } +func (m *LinuxPodSandboxStats) GetIo() *IoUsage { + if m != nil { + return m.Io + } + return nil +} + // WindowsPodSandboxStats provides the resource usage statistics for a pod sandbox on windows type WindowsPodSandboxStats struct { // CPU usage gathered for the pod sandbox. @@ -8938,9 +8948,11 @@ type ContainerStats struct { // Usage of the writable layer. WritableLayer *FilesystemUsage `protobuf:"bytes,4,opt,name=writable_layer,json=writableLayer,proto3" json:"writable_layer,omitempty"` // Swap usage gathered from the container. - Swap *SwapUsage `protobuf:"bytes,5,opt,name=swap,proto3" json:"swap,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_sizecache int32 `json:"-"` + Swap *SwapUsage `protobuf:"bytes,5,opt,name=swap,proto3" json:"swap,omitempty"` + // IO usage gathered from the container. + Io *IoUsage `protobuf:"bytes,6,opt,name=io,proto3" json:"io,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *ContainerStats) Reset() { *m = ContainerStats{} } @@ -9010,6 +9022,13 @@ func (m *ContainerStats) GetSwap() *SwapUsage { return nil } +func (m *ContainerStats) GetIo() *IoUsage { + if m != nil { + return m.Io + } + return nil +} + // WindowsContainerStats provides the resource usage statistics for a container specific for Windows type WindowsContainerStats struct { // Information of the container. @@ -9084,6 +9103,137 @@ func (m *WindowsContainerStats) GetWritableLayer() *WindowsFilesystemUsage { return nil } +// PSI statistics for an individual resource. +type PsiStats struct { + // PSI data for all tasks in the cgroup. + Full *PsiData `protobuf:"bytes,1,opt,name=Full,proto3" json:"Full,omitempty"` + // PSI data for some tasks in the cgroup. + Some *PsiData `protobuf:"bytes,2,opt,name=Some,proto3" json:"Some,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PsiStats) Reset() { *m = PsiStats{} } +func (*PsiStats) ProtoMessage() {} +func (*PsiStats) Descriptor() ([]byte, []int) { + return fileDescriptor_00212fb1f9d3bf1c, []int{131} +} +func (m *PsiStats) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PsiStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_PsiStats.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *PsiStats) XXX_Merge(src proto.Message) { + xxx_messageInfo_PsiStats.Merge(m, src) +} +func (m *PsiStats) XXX_Size() int { + return m.Size() +} +func (m *PsiStats) XXX_DiscardUnknown() { + xxx_messageInfo_PsiStats.DiscardUnknown(m) +} + +var xxx_messageInfo_PsiStats proto.InternalMessageInfo + +func (m *PsiStats) GetFull() *PsiData { + if m != nil { + return m.Full + } + return nil +} + +func (m *PsiStats) GetSome() *PsiData { + if m != nil { + return m.Some + } + return nil +} + +// PSI data for an individual resource. +type PsiData struct { + // Total time duration for tasks in the cgroup have waited due to congestion. + // Unit: nanoseconds. + Total uint64 `protobuf:"varint,1,opt,name=Total,proto3" json:"Total,omitempty"` + // The average (in %) tasks have waited due to congestion over a 10 second window. + Avg10 float64 `protobuf:"fixed64,2,opt,name=Avg10,proto3" json:"Avg10,omitempty"` + // The average (in %) tasks have waited due to congestion over a 60 second window. + Avg60 float64 `protobuf:"fixed64,3,opt,name=Avg60,proto3" json:"Avg60,omitempty"` + // The average (in %) tasks have waited due to congestion over a 300 second window. + Avg300 float64 `protobuf:"fixed64,4,opt,name=Avg300,proto3" json:"Avg300,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *PsiData) Reset() { *m = PsiData{} } +func (*PsiData) ProtoMessage() {} +func (*PsiData) Descriptor() ([]byte, []int) { + return fileDescriptor_00212fb1f9d3bf1c, []int{132} +} +func (m *PsiData) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *PsiData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_PsiData.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *PsiData) XXX_Merge(src proto.Message) { + xxx_messageInfo_PsiData.Merge(m, src) +} +func (m *PsiData) XXX_Size() int { + return m.Size() +} +func (m *PsiData) XXX_DiscardUnknown() { + xxx_messageInfo_PsiData.DiscardUnknown(m) +} + +var xxx_messageInfo_PsiData proto.InternalMessageInfo + +func (m *PsiData) GetTotal() uint64 { + if m != nil { + return m.Total + } + return 0 +} + +func (m *PsiData) GetAvg10() float64 { + if m != nil { + return m.Avg10 + } + return 0 +} + +func (m *PsiData) GetAvg60() float64 { + if m != nil { + return m.Avg60 + } + return 0 +} + +func (m *PsiData) GetAvg300() float64 { + if m != nil { + return m.Avg300 + } + return 0 +} + // CpuUsage provides the CPU usage information. type CpuUsage struct { // Timestamp in nanoseconds at which the information were collected. Must be > 0. @@ -9092,15 +9242,17 @@ type CpuUsage struct { UsageCoreNanoSeconds *UInt64Value `protobuf:"bytes,2,opt,name=usage_core_nano_seconds,json=usageCoreNanoSeconds,proto3" json:"usage_core_nano_seconds,omitempty"` // Total CPU usage (sum of all cores) averaged over the sample window. // The "core" unit can be interpreted as CPU core-nanoseconds per second. - UsageNanoCores *UInt64Value `protobuf:"bytes,3,opt,name=usage_nano_cores,json=usageNanoCores,proto3" json:"usage_nano_cores,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_sizecache int32 `json:"-"` + UsageNanoCores *UInt64Value `protobuf:"bytes,3,opt,name=usage_nano_cores,json=usageNanoCores,proto3" json:"usage_nano_cores,omitempty"` + // CPU PSI statistics. + Psi *PsiStats `protobuf:"bytes,4,opt,name=psi,proto3" json:"psi,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *CpuUsage) Reset() { *m = CpuUsage{} } func (*CpuUsage) ProtoMessage() {} func (*CpuUsage) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{131} + return fileDescriptor_00212fb1f9d3bf1c, []int{133} } func (m *CpuUsage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -9150,6 +9302,13 @@ func (m *CpuUsage) GetUsageNanoCores() *UInt64Value { return nil } +func (m *CpuUsage) GetPsi() *PsiStats { + if m != nil { + return m.Psi + } + return nil +} + // WindowsCpuUsage provides the CPU usage information specific to Windows type WindowsCpuUsage struct { // Timestamp in nanoseconds at which the information were collected. Must be > 0. @@ -9166,7 +9325,7 @@ type WindowsCpuUsage struct { func (m *WindowsCpuUsage) Reset() { *m = WindowsCpuUsage{} } func (*WindowsCpuUsage) ProtoMessage() {} func (*WindowsCpuUsage) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{132} + return fileDescriptor_00212fb1f9d3bf1c, []int{134} } func (m *WindowsCpuUsage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -9231,15 +9390,17 @@ type MemoryUsage struct { // Cumulative number of minor page faults. PageFaults *UInt64Value `protobuf:"bytes,6,opt,name=page_faults,json=pageFaults,proto3" json:"page_faults,omitempty"` // Cumulative number of major page faults. - MajorPageFaults *UInt64Value `protobuf:"bytes,7,opt,name=major_page_faults,json=majorPageFaults,proto3" json:"major_page_faults,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_sizecache int32 `json:"-"` + MajorPageFaults *UInt64Value `protobuf:"bytes,7,opt,name=major_page_faults,json=majorPageFaults,proto3" json:"major_page_faults,omitempty"` + // Memory PSI statistics. + Psi *PsiStats `protobuf:"bytes,8,opt,name=psi,proto3" json:"psi,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *MemoryUsage) Reset() { *m = MemoryUsage{} } func (*MemoryUsage) ProtoMessage() {} func (*MemoryUsage) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{133} + return fileDescriptor_00212fb1f9d3bf1c, []int{135} } func (m *MemoryUsage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -9317,6 +9478,68 @@ func (m *MemoryUsage) GetMajorPageFaults() *UInt64Value { return nil } +func (m *MemoryUsage) GetPsi() *PsiStats { + if m != nil { + return m.Psi + } + return nil +} + +type IoUsage struct { + // Timestamp in nanoseconds at which the information were collected. Must be > 0. + Timestamp int64 `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"` + // IO PSI statistics. + Psi *PsiStats `protobuf:"bytes,2,opt,name=psi,proto3" json:"psi,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *IoUsage) Reset() { *m = IoUsage{} } +func (*IoUsage) ProtoMessage() {} +func (*IoUsage) Descriptor() ([]byte, []int) { + return fileDescriptor_00212fb1f9d3bf1c, []int{136} +} +func (m *IoUsage) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *IoUsage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_IoUsage.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *IoUsage) XXX_Merge(src proto.Message) { + xxx_messageInfo_IoUsage.Merge(m, src) +} +func (m *IoUsage) XXX_Size() int { + return m.Size() +} +func (m *IoUsage) XXX_DiscardUnknown() { + xxx_messageInfo_IoUsage.DiscardUnknown(m) +} + +var xxx_messageInfo_IoUsage proto.InternalMessageInfo + +func (m *IoUsage) GetTimestamp() int64 { + if m != nil { + return m.Timestamp + } + return 0 +} + +func (m *IoUsage) GetPsi() *PsiStats { + if m != nil { + return m.Psi + } + return nil +} + type SwapUsage struct { // Timestamp in nanoseconds at which the information were collected. Must be > 0. Timestamp int64 `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"` @@ -9331,7 +9554,7 @@ type SwapUsage struct { func (m *SwapUsage) Reset() { *m = SwapUsage{} } func (*SwapUsage) ProtoMessage() {} func (*SwapUsage) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{134} + return fileDescriptor_00212fb1f9d3bf1c, []int{137} } func (m *SwapUsage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -9400,7 +9623,7 @@ type WindowsMemoryUsage struct { func (m *WindowsMemoryUsage) Reset() { *m = WindowsMemoryUsage{} } func (*WindowsMemoryUsage) ProtoMessage() {} func (*WindowsMemoryUsage) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{135} + return fileDescriptor_00212fb1f9d3bf1c, []int{138} } func (m *WindowsMemoryUsage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -9474,7 +9697,7 @@ type ReopenContainerLogRequest struct { func (m *ReopenContainerLogRequest) Reset() { *m = ReopenContainerLogRequest{} } func (*ReopenContainerLogRequest) ProtoMessage() {} func (*ReopenContainerLogRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{136} + return fileDescriptor_00212fb1f9d3bf1c, []int{139} } func (m *ReopenContainerLogRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -9518,7 +9741,7 @@ type ReopenContainerLogResponse struct { func (m *ReopenContainerLogResponse) Reset() { *m = ReopenContainerLogResponse{} } func (*ReopenContainerLogResponse) ProtoMessage() {} func (*ReopenContainerLogResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{137} + return fileDescriptor_00212fb1f9d3bf1c, []int{140} } func (m *ReopenContainerLogResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -9563,7 +9786,7 @@ type CheckpointContainerRequest struct { func (m *CheckpointContainerRequest) Reset() { *m = CheckpointContainerRequest{} } func (*CheckpointContainerRequest) ProtoMessage() {} func (*CheckpointContainerRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{138} + return fileDescriptor_00212fb1f9d3bf1c, []int{141} } func (m *CheckpointContainerRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -9621,7 +9844,7 @@ type CheckpointContainerResponse struct { func (m *CheckpointContainerResponse) Reset() { *m = CheckpointContainerResponse{} } func (*CheckpointContainerResponse) ProtoMessage() {} func (*CheckpointContainerResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{139} + return fileDescriptor_00212fb1f9d3bf1c, []int{142} } func (m *CheckpointContainerResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -9658,7 +9881,7 @@ type GetEventsRequest struct { func (m *GetEventsRequest) Reset() { *m = GetEventsRequest{} } func (*GetEventsRequest) ProtoMessage() {} func (*GetEventsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{140} + return fileDescriptor_00212fb1f9d3bf1c, []int{143} } func (m *GetEventsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -9705,7 +9928,7 @@ type ContainerEventResponse struct { func (m *ContainerEventResponse) Reset() { *m = ContainerEventResponse{} } func (*ContainerEventResponse) ProtoMessage() {} func (*ContainerEventResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{141} + return fileDescriptor_00212fb1f9d3bf1c, []int{144} } func (m *ContainerEventResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -9777,7 +10000,7 @@ type ListMetricDescriptorsRequest struct { func (m *ListMetricDescriptorsRequest) Reset() { *m = ListMetricDescriptorsRequest{} } func (*ListMetricDescriptorsRequest) ProtoMessage() {} func (*ListMetricDescriptorsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{142} + return fileDescriptor_00212fb1f9d3bf1c, []int{145} } func (m *ListMetricDescriptorsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -9815,7 +10038,7 @@ type ListMetricDescriptorsResponse struct { func (m *ListMetricDescriptorsResponse) Reset() { *m = ListMetricDescriptorsResponse{} } func (*ListMetricDescriptorsResponse) ProtoMessage() {} func (*ListMetricDescriptorsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{143} + return fileDescriptor_00212fb1f9d3bf1c, []int{146} } func (m *ListMetricDescriptorsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -9868,7 +10091,7 @@ type MetricDescriptor struct { func (m *MetricDescriptor) Reset() { *m = MetricDescriptor{} } func (*MetricDescriptor) ProtoMessage() {} func (*MetricDescriptor) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{144} + return fileDescriptor_00212fb1f9d3bf1c, []int{147} } func (m *MetricDescriptor) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -9926,7 +10149,7 @@ type ListPodSandboxMetricsRequest struct { func (m *ListPodSandboxMetricsRequest) Reset() { *m = ListPodSandboxMetricsRequest{} } func (*ListPodSandboxMetricsRequest) ProtoMessage() {} func (*ListPodSandboxMetricsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{145} + return fileDescriptor_00212fb1f9d3bf1c, []int{148} } func (m *ListPodSandboxMetricsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -9964,7 +10187,7 @@ type ListPodSandboxMetricsResponse struct { func (m *ListPodSandboxMetricsResponse) Reset() { *m = ListPodSandboxMetricsResponse{} } func (*ListPodSandboxMetricsResponse) ProtoMessage() {} func (*ListPodSandboxMetricsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{146} + return fileDescriptor_00212fb1f9d3bf1c, []int{149} } func (m *ListPodSandboxMetricsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -10011,7 +10234,7 @@ type PodSandboxMetrics struct { func (m *PodSandboxMetrics) Reset() { *m = PodSandboxMetrics{} } func (*PodSandboxMetrics) ProtoMessage() {} func (*PodSandboxMetrics) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{147} + return fileDescriptor_00212fb1f9d3bf1c, []int{150} } func (m *PodSandboxMetrics) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -10071,7 +10294,7 @@ type ContainerMetrics struct { func (m *ContainerMetrics) Reset() { *m = ContainerMetrics{} } func (*ContainerMetrics) ProtoMessage() {} func (*ContainerMetrics) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{148} + return fileDescriptor_00212fb1f9d3bf1c, []int{151} } func (m *ContainerMetrics) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -10134,7 +10357,7 @@ type Metric struct { func (m *Metric) Reset() { *m = Metric{} } func (*Metric) ProtoMessage() {} func (*Metric) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{149} + return fileDescriptor_00212fb1f9d3bf1c, []int{152} } func (m *Metric) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -10206,7 +10429,7 @@ type RuntimeConfigRequest struct { func (m *RuntimeConfigRequest) Reset() { *m = RuntimeConfigRequest{} } func (*RuntimeConfigRequest) ProtoMessage() {} func (*RuntimeConfigRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{150} + return fileDescriptor_00212fb1f9d3bf1c, []int{153} } func (m *RuntimeConfigRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -10247,7 +10470,7 @@ type RuntimeConfigResponse struct { func (m *RuntimeConfigResponse) Reset() { *m = RuntimeConfigResponse{} } func (*RuntimeConfigResponse) ProtoMessage() {} func (*RuntimeConfigResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{151} + return fileDescriptor_00212fb1f9d3bf1c, []int{154} } func (m *RuntimeConfigResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -10299,7 +10522,7 @@ type LinuxRuntimeConfiguration struct { func (m *LinuxRuntimeConfiguration) Reset() { *m = LinuxRuntimeConfiguration{} } func (*LinuxRuntimeConfiguration) ProtoMessage() {} func (*LinuxRuntimeConfiguration) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{152} + return fileDescriptor_00212fb1f9d3bf1c, []int{155} } func (m *LinuxRuntimeConfiguration) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -10349,7 +10572,7 @@ type UpdatePodSandboxResourcesRequest struct { func (m *UpdatePodSandboxResourcesRequest) Reset() { *m = UpdatePodSandboxResourcesRequest{} } func (*UpdatePodSandboxResourcesRequest) ProtoMessage() {} func (*UpdatePodSandboxResourcesRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{153} + return fileDescriptor_00212fb1f9d3bf1c, []int{156} } func (m *UpdatePodSandboxResourcesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -10407,7 +10630,7 @@ type UpdatePodSandboxResourcesResponse struct { func (m *UpdatePodSandboxResourcesResponse) Reset() { *m = UpdatePodSandboxResourcesResponse{} } func (*UpdatePodSandboxResourcesResponse) ProtoMessage() {} func (*UpdatePodSandboxResourcesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{154} + return fileDescriptor_00212fb1f9d3bf1c, []int{157} } func (m *UpdatePodSandboxResourcesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -10606,9 +10829,12 @@ func init() { proto.RegisterMapType((map[string]string)(nil), "runtime.v1.ContainerAttributes.LabelsEntry") proto.RegisterType((*ContainerStats)(nil), "runtime.v1.ContainerStats") proto.RegisterType((*WindowsContainerStats)(nil), "runtime.v1.WindowsContainerStats") + proto.RegisterType((*PsiStats)(nil), "runtime.v1.PsiStats") + proto.RegisterType((*PsiData)(nil), "runtime.v1.PsiData") proto.RegisterType((*CpuUsage)(nil), "runtime.v1.CpuUsage") proto.RegisterType((*WindowsCpuUsage)(nil), "runtime.v1.WindowsCpuUsage") proto.RegisterType((*MemoryUsage)(nil), "runtime.v1.MemoryUsage") + proto.RegisterType((*IoUsage)(nil), "runtime.v1.IoUsage") proto.RegisterType((*SwapUsage)(nil), "runtime.v1.SwapUsage") proto.RegisterType((*WindowsMemoryUsage)(nil), "runtime.v1.WindowsMemoryUsage") proto.RegisterType((*ReopenContainerLogRequest)(nil), "runtime.v1.ReopenContainerLogRequest") @@ -10635,461 +10861,469 @@ func init() { func init() { proto.RegisterFile("api.proto", fileDescriptor_00212fb1f9d3bf1c) } var fileDescriptor_00212fb1f9d3bf1c = []byte{ - // 7252 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x5d, 0x4d, 0x6c, 0x1c, 0xc9, - 0x75, 0x66, 0xcf, 0x0c, 0xc9, 0x99, 0x47, 0x0e, 0x39, 0x2c, 0x51, 0x24, 0x35, 0xfa, 0x6f, 0xed, - 0x8f, 0xa4, 0x5d, 0xfd, 0xac, 0x56, 0xbb, 0x2b, 0x69, 0xb5, 0xbb, 0x1a, 0x91, 0x94, 0x34, 0x6b, - 0x91, 0x1c, 0xf7, 0x90, 0x6b, 0xef, 0x3a, 0x70, 0xa7, 0x35, 0x5d, 0x1c, 0xf6, 0x6a, 0xa6, 0xbb, - 0xdd, 0xdd, 0x23, 0x89, 0x3e, 0x04, 0x39, 0x05, 0x89, 0x4f, 0x06, 0x12, 0x23, 0x88, 0x11, 0x24, - 0x70, 0x80, 0xfc, 0xdc, 0x92, 0x18, 0x88, 0xe3, 0x20, 0x01, 0x02, 0x04, 0xb1, 0xe1, 0x04, 0x09, - 0x90, 0x43, 0x02, 0xf8, 0x16, 0x7b, 0x13, 0x20, 0x40, 0xce, 0x3e, 0x04, 0xb9, 0x38, 0xa8, 0xbf, - 0xee, 0xae, 0xfe, 0x99, 0x19, 0x72, 0x37, 0xbb, 0xeb, 0x13, 0xa7, 0xab, 0xde, 0x7b, 0x55, 0xf5, - 0xea, 0xd5, 0xab, 0x57, 0x55, 0x5f, 0x15, 0xa1, 0x62, 0xb8, 0xd6, 0x65, 0xd7, 0x73, 0x02, 0x07, - 0x81, 0x37, 0xb0, 0x03, 0xab, 0x8f, 0x2f, 0x3f, 0x79, 0xa5, 0x7e, 0xa9, 0x6b, 0x05, 0x7b, 0x83, - 0x47, 0x97, 0x3b, 0x4e, 0xff, 0x4a, 0xd7, 0xe9, 0x3a, 0x57, 0x28, 0xc9, 0xa3, 0xc1, 0x2e, 0xfd, - 0xa2, 0x1f, 0xf4, 0x17, 0x63, 0x55, 0x2f, 0xc2, 0xdc, 0x7b, 0xd8, 0xf3, 0x2d, 0xc7, 0xd6, 0xf0, - 0xd7, 0x06, 0xd8, 0x0f, 0xd0, 0x0a, 0x4c, 0x3f, 0x61, 0x29, 0x2b, 0xca, 0x19, 0xe5, 0x7c, 0x45, - 0x13, 0x9f, 0xea, 0x1f, 0x2b, 0x30, 0x1f, 0x12, 0xfb, 0xae, 0x63, 0xfb, 0x38, 0x9f, 0x1a, 0x9d, - 0x85, 0x59, 0x5e, 0x2d, 0xdd, 0x36, 0xfa, 0x78, 0xa5, 0x40, 0xb3, 0x67, 0x78, 0xda, 0xa6, 0xd1, - 0xc7, 0xe8, 0x45, 0x98, 0x17, 0x24, 0x42, 0x48, 0x91, 0x52, 0xcd, 0xf1, 0x64, 0x5e, 0x1a, 0xba, - 0x0c, 0x47, 0x04, 0xa1, 0xe1, 0x5a, 0x21, 0x71, 0x89, 0x12, 0x2f, 0xf0, 0xac, 0x86, 0x6b, 0x71, - 0x7a, 0xf5, 0x2b, 0x50, 0x59, 0xdb, 0x6c, 0xaf, 0x3a, 0xf6, 0xae, 0xd5, 0x25, 0x55, 0xf4, 0xb1, - 0x47, 0x78, 0x56, 0x94, 0x33, 0x45, 0x52, 0x45, 0xfe, 0x89, 0xea, 0x50, 0xf6, 0xb1, 0xe1, 0x75, - 0xf6, 0xb0, 0xbf, 0x52, 0xa0, 0x59, 0xe1, 0x37, 0xe1, 0x72, 0xdc, 0xc0, 0x72, 0x6c, 0x7f, 0xa5, - 0xc8, 0xb8, 0xf8, 0xa7, 0xfa, 0xbb, 0x0a, 0xcc, 0xb4, 0x1c, 0x2f, 0xd8, 0x30, 0x5c, 0xd7, 0xb2, - 0xbb, 0xe8, 0x2a, 0x94, 0xa9, 0x2e, 0x3b, 0x4e, 0x8f, 0xea, 0x60, 0xee, 0xda, 0xe2, 0xe5, 0xa8, - 0x43, 0x2e, 0xb7, 0x78, 0x9e, 0x16, 0x52, 0xa1, 0xe7, 0x61, 0xae, 0xe3, 0xd8, 0x81, 0x61, 0xd9, - 0xd8, 0xd3, 0x5d, 0xc7, 0x0b, 0xa8, 0x72, 0x26, 0xb5, 0x6a, 0x98, 0x4a, 0xe4, 0xa3, 0xe3, 0x50, - 0xd9, 0x73, 0xfc, 0x80, 0x51, 0x14, 0x29, 0x45, 0x99, 0x24, 0xd0, 0xcc, 0x65, 0x98, 0xa6, 0x99, - 0x96, 0xcb, 0xd5, 0x30, 0x45, 0x3e, 0x9b, 0xae, 0xfa, 0x83, 0x22, 0x4c, 0x6e, 0x38, 0x03, 0x3b, - 0x48, 0x14, 0x63, 0x04, 0x7b, 0xbc, 0x8b, 0x62, 0xc5, 0x18, 0xc1, 0x5e, 0x54, 0x0c, 0xa1, 0x60, - 0xbd, 0xc4, 0x8a, 0x21, 0x99, 0x75, 0x28, 0x7b, 0xd8, 0x30, 0x1d, 0xbb, 0xb7, 0x4f, 0xab, 0x50, - 0xd6, 0xc2, 0x6f, 0xd2, 0x7d, 0x3e, 0xee, 0x59, 0xf6, 0xe0, 0x99, 0xee, 0xe1, 0x9e, 0xf1, 0x08, - 0xf7, 0x68, 0x55, 0xca, 0xda, 0x1c, 0x4f, 0xd6, 0x58, 0x2a, 0x7a, 0x1b, 0x66, 0x5c, 0xcf, 0x71, - 0x8d, 0xae, 0x41, 0x34, 0xb8, 0x32, 0x49, 0x95, 0x74, 0x22, 0xae, 0x24, 0x5a, 0xe1, 0x56, 0x44, - 0xa3, 0xc5, 0x19, 0xd0, 0x1b, 0x30, 0x33, 0xb0, 0x4c, 0xae, 0x6f, 0x7f, 0x65, 0xea, 0x4c, 0xf1, - 0xfc, 0xcc, 0xb5, 0xa3, 0x71, 0xfe, 0xe6, 0x1a, 0xcf, 0xd5, 0xe2, 0x94, 0x84, 0xb1, 0x1b, 0x63, - 0x9c, 0x1e, 0xca, 0x18, 0xa3, 0xa4, 0x06, 0x87, 0x3b, 0x03, 0xcf, 0xb7, 0x9e, 0x60, 0x9d, 0x34, - 0x58, 0xa7, 0x1a, 0x28, 0xd3, 0xe6, 0x2d, 0x84, 0x59, 0x1a, 0x36, 0xcc, 0x2d, 0xa2, 0x8a, 0x97, - 0x60, 0xd2, 0xea, 0x1b, 0x5d, 0xbc, 0x52, 0x39, 0xa3, 0xa4, 0x8a, 0x20, 0x19, 0x6d, 0x17, 0x77, - 0x34, 0x46, 0x83, 0x9e, 0x83, 0x39, 0xfa, 0x43, 0xf7, 0x07, 0x8f, 0x98, 0xd6, 0x81, 0x6a, 0x7d, - 0x96, 0xa6, 0xb6, 0x07, 0x8f, 0x88, 0xe6, 0x55, 0x1d, 0x2a, 0x61, 0xe5, 0xa2, 0xde, 0x36, 0x69, - 0x1f, 0x56, 0x79, 0x6f, 0x9b, 0x64, 0x94, 0x45, 0x7d, 0x6c, 0x99, 0xb4, 0xff, 0xaa, 0xda, 0x4c, - 0x98, 0xd6, 0x34, 0xd1, 0x12, 0x4c, 0xf5, 0xb0, 0xdd, 0x0d, 0xf6, 0x68, 0x07, 0x56, 0x35, 0xfe, - 0xa5, 0xfe, 0x96, 0x02, 0xd5, 0x1d, 0x1f, 0x7b, 0x64, 0x28, 0xfa, 0xae, 0xd1, 0xc1, 0xe8, 0x12, - 0x94, 0xfa, 0x8e, 0x89, 0xb9, 0x15, 0x1f, 0x8b, 0x37, 0x22, 0x24, 0xda, 0x70, 0x4c, 0xac, 0x51, - 0x32, 0x74, 0x01, 0x4a, 0x03, 0xcb, 0x64, 0x43, 0x27, 0x57, 0xad, 0x94, 0x84, 0x90, 0x76, 0x09, - 0x69, 0x71, 0x28, 0x29, 0x21, 0x51, 0x7f, 0xae, 0xc0, 0x7c, 0x58, 0xda, 0x16, 0x1d, 0x73, 0xe8, - 0x55, 0x98, 0xb6, 0x71, 0xf0, 0xd4, 0xf1, 0x1e, 0x8f, 0xae, 0x9b, 0xa0, 0x44, 0x2f, 0x41, 0xd1, - 0xe5, 0x1a, 0x19, 0xca, 0x40, 0xa8, 0x08, 0xb1, 0xe5, 0x76, 0xa8, 0x86, 0x86, 0x13, 0x5b, 0x6e, - 0x87, 0x8c, 0x98, 0xc0, 0xf0, 0xba, 0x98, 0xf6, 0x07, 0x1b, 0x7d, 0x65, 0x96, 0xd0, 0x34, 0xd1, - 0x1d, 0x98, 0x1b, 0xf8, 0xd8, 0xb3, 0x7d, 0x5d, 0xf8, 0x8f, 0x49, 0x6a, 0x13, 0x92, 0x50, 0x49, - 0xef, 0x5a, 0x95, 0x31, 0x6c, 0x71, 0x07, 0xa3, 0x02, 0x34, 0xed, 0xe0, 0xf5, 0xeb, 0xef, 0x19, - 0xbd, 0x01, 0x46, 0x8b, 0x30, 0xf9, 0x84, 0xfc, 0xa0, 0x2d, 0x2f, 0x6a, 0xec, 0x43, 0xfd, 0xce, - 0x24, 0x1c, 0x7f, 0x48, 0xc6, 0x58, 0xdb, 0xb0, 0xcd, 0x47, 0xce, 0xb3, 0x36, 0x31, 0x49, 0x2b, - 0xd8, 0x5f, 0x75, 0xec, 0x00, 0x3f, 0x0b, 0xd0, 0x03, 0x58, 0xb0, 0x85, 0xfc, 0xb0, 0x22, 0x0a, - 0xad, 0xc8, 0xf1, 0xcc, 0xd6, 0xb1, 0xc2, 0xb5, 0x9a, 0x2d, 0x27, 0xf8, 0xe8, 0x6e, 0x34, 0xca, - 0x85, 0x9c, 0x42, 0xba, 0x41, 0xed, 0x75, 0x5a, 0x1b, 0x2e, 0x45, 0x38, 0x00, 0x21, 0xe3, 0x75, - 0x20, 0x7e, 0x5f, 0x37, 0x7c, 0x9d, 0xb4, 0x94, 0x6a, 0x79, 0xe6, 0xda, 0x92, 0x64, 0x05, 0x61, - 0x83, 0xb5, 0x8a, 0x37, 0xb0, 0x1b, 0x3e, 0xd1, 0x10, 0xba, 0x41, 0xe7, 0x10, 0xc2, 0xd7, 0xf5, - 0x9c, 0x81, 0x4b, 0xc7, 0x5f, 0x3e, 0x23, 0x50, 0xc6, 0xfb, 0x84, 0x92, 0x4e, 0x2d, 0xdc, 0x4f, - 0xe9, 0x9e, 0xe3, 0x04, 0xbb, 0xbe, 0xf0, 0x4d, 0x22, 0x59, 0xa3, 0xa9, 0xe8, 0x0a, 0x1c, 0xf1, - 0x07, 0xae, 0xdb, 0xc3, 0x7d, 0x6c, 0x07, 0x46, 0x8f, 0x15, 0x44, 0xfa, 0xac, 0x78, 0xbe, 0xa8, - 0xa1, 0x78, 0x16, 0x15, 0xec, 0xa3, 0x47, 0x50, 0xcf, 0x60, 0xd0, 0x5d, 0xa7, 0x67, 0x75, 0xf6, - 0x57, 0x66, 0xa8, 0x01, 0x3d, 0x27, 0xa9, 0x26, 0x25, 0xa3, 0x45, 0x69, 0xb5, 0x15, 0x3f, 0x27, - 0x07, 0x9d, 0x02, 0x70, 0x3d, 0xeb, 0x89, 0xd5, 0xc3, 0x5d, 0x6c, 0xae, 0x4c, 0xd1, 0x8a, 0xc7, - 0x52, 0xd0, 0x6b, 0x64, 0x4a, 0xeb, 0x74, 0x9c, 0xbe, 0xcb, 0x1d, 0x8e, 0xd4, 0xa7, 0xc2, 0x16, - 0x5a, 0x9e, 0xb3, 0x6b, 0xf5, 0xb0, 0x26, 0x68, 0xd1, 0x1b, 0x50, 0x36, 0x5c, 0xd7, 0xf0, 0xfa, - 0x8e, 0x47, 0x5d, 0xce, 0x08, 0xbe, 0x90, 0x18, 0x5d, 0x87, 0x45, 0x2e, 0x43, 0x77, 0x59, 0x26, - 0xf3, 0x5b, 0xd3, 0xc4, 0xf6, 0xef, 0x16, 0x56, 0x14, 0x0d, 0xf1, 0x7c, 0xce, 0x4b, 0x3d, 0xd8, - 0xdf, 0x2b, 0x30, 0x9f, 0x90, 0x89, 0xde, 0x85, 0x59, 0x21, 0x21, 0xd8, 0x77, 0x85, 0xab, 0x79, - 0x71, 0x48, 0x35, 0x2e, 0xf3, 0xbf, 0xdb, 0xfb, 0x2e, 0xa6, 0xd3, 0x82, 0xf8, 0x40, 0xe7, 0xa0, - 0xda, 0x73, 0x3a, 0x46, 0x8f, 0x7a, 0x46, 0x0f, 0xef, 0xf2, 0xc9, 0x6b, 0x36, 0x4c, 0xd4, 0xf0, - 0xae, 0x7a, 0x07, 0x66, 0x62, 0x02, 0x10, 0x82, 0x39, 0x8d, 0x15, 0xb5, 0x86, 0x77, 0x8d, 0x41, - 0x2f, 0xa8, 0x4d, 0xa0, 0x39, 0x80, 0x1d, 0xbb, 0x43, 0x82, 0x05, 0x1b, 0x9b, 0x35, 0x05, 0x55, - 0xa1, 0xf2, 0x50, 0x88, 0xa8, 0x15, 0xd4, 0x6f, 0x17, 0xe1, 0x28, 0x35, 0xee, 0x96, 0x63, 0xf2, - 0xd1, 0xc6, 0x23, 0x8b, 0x73, 0x50, 0xed, 0xd0, 0xee, 0xd7, 0x5d, 0xc3, 0xc3, 0x76, 0xc0, 0xe7, - 0xd7, 0x59, 0x96, 0xd8, 0xa2, 0x69, 0x48, 0x83, 0x9a, 0xcf, 0x5b, 0xa4, 0x77, 0xd8, 0xe8, 0xe4, - 0x03, 0x48, 0x6a, 0xf5, 0x90, 0xc1, 0xac, 0xcd, 0xfb, 0xa9, 0xd1, 0x3d, 0xed, 0xef, 0xfb, 0x9d, - 0xa0, 0x27, 0x3c, 0xea, 0xe5, 0x94, 0xa8, 0x64, 0x65, 0x2f, 0xb7, 0x19, 0xc3, 0xba, 0x1d, 0x78, - 0xfb, 0x9a, 0x60, 0x47, 0xef, 0x40, 0xd9, 0x79, 0x82, 0xbd, 0x3d, 0x6c, 0x30, 0x4f, 0x36, 0x73, - 0xed, 0x5c, 0x4a, 0xd4, 0xaa, 0x98, 0x4c, 0x34, 0xec, 0x3b, 0x03, 0xaf, 0x83, 0x7d, 0x2d, 0x64, - 0x42, 0x0d, 0xa8, 0x78, 0x22, 0x99, 0x7b, 0xba, 0xb1, 0x24, 0x44, 0x5c, 0xf5, 0x5b, 0x30, 0x1b, - 0xaf, 0x1c, 0xaa, 0x41, 0xf1, 0x31, 0xde, 0xe7, 0xca, 0x24, 0x3f, 0x23, 0x1f, 0xc8, 0x7a, 0x98, - 0x7d, 0xdc, 0x2a, 0xdc, 0x50, 0x54, 0x0f, 0x50, 0xd4, 0xd2, 0x0d, 0x1c, 0x18, 0xa6, 0x11, 0x18, - 0x08, 0x41, 0x89, 0xc6, 0x9c, 0x4c, 0x04, 0xfd, 0x4d, 0xa4, 0x0e, 0xf8, 0x74, 0x50, 0xd1, 0xc8, - 0x4f, 0x74, 0x02, 0x2a, 0xa1, 0xb7, 0xe3, 0x81, 0x67, 0x94, 0x40, 0x02, 0x40, 0x23, 0x08, 0x70, - 0xdf, 0x0d, 0xa8, 0x62, 0xaa, 0x9a, 0xf8, 0x54, 0x7f, 0x63, 0x12, 0x6a, 0x29, 0x5b, 0xb8, 0x05, - 0xe5, 0x3e, 0x2f, 0x9e, 0xfb, 0xd9, 0x53, 0x52, 0x14, 0x98, 0xaa, 0xa4, 0x16, 0xd2, 0x93, 0x20, - 0x8b, 0xd8, 0x5a, 0x2c, 0x4c, 0x0e, 0xbf, 0x99, 0x91, 0x77, 0x75, 0xd3, 0xf2, 0x70, 0x27, 0x70, - 0xbc, 0x7d, 0x5e, 0xd1, 0xd9, 0x9e, 0xd3, 0x5d, 0x13, 0x69, 0xe8, 0x3a, 0x80, 0x69, 0xfb, 0x3a, - 0xb5, 0xe1, 0x2e, 0xef, 0x47, 0x69, 0x92, 0x0d, 0xa3, 0x61, 0xad, 0x62, 0xda, 0x3e, 0xaf, 0xf2, - 0x6d, 0xa8, 0x92, 0xd0, 0x52, 0xef, 0x8b, 0xf8, 0x68, 0x92, 0xda, 0xd2, 0xb2, 0x5c, 0xef, 0x30, - 0xd0, 0xd5, 0x66, 0xdd, 0xe8, 0xc3, 0x47, 0x77, 0x60, 0x8a, 0x46, 0x77, 0x22, 0x1e, 0x3b, 0x9f, - 0xdd, 0x5c, 0x6e, 0x7d, 0x0f, 0x29, 0x29, 0x33, 0x3e, 0xce, 0x87, 0xb6, 0x60, 0xc6, 0xb0, 0x6d, - 0x27, 0x30, 0xd8, 0xac, 0xc2, 0xa2, 0xb3, 0x4b, 0x43, 0xc5, 0x34, 0x22, 0x7a, 0x26, 0x2b, 0x2e, - 0x01, 0xbd, 0x01, 0x93, 0x74, 0xda, 0xe1, 0xf3, 0xc4, 0xd9, 0x91, 0x83, 0x42, 0x63, 0xf4, 0xe8, - 0x2d, 0x98, 0x7e, 0x6a, 0xd9, 0xa6, 0xf3, 0xd4, 0xe7, 0xfe, 0x54, 0x32, 0xe1, 0x2f, 0xb1, 0xac, - 0x14, 0xb3, 0xe0, 0xa9, 0xdf, 0x84, 0x99, 0x58, 0xfb, 0x0e, 0x62, 0xbf, 0xf5, 0xb7, 0xa1, 0x96, - 0x6c, 0xd3, 0x81, 0xec, 0x7f, 0x00, 0x8b, 0xda, 0xc0, 0x8e, 0xaa, 0x26, 0x56, 0x71, 0xd7, 0x61, - 0x8a, 0x5b, 0x03, 0x33, 0xc6, 0x13, 0xc3, 0xd4, 0xaa, 0x71, 0xda, 0xf8, 0x82, 0x6c, 0xcf, 0xb0, - 0xcd, 0x1e, 0xf6, 0x78, 0x89, 0x62, 0x41, 0xf6, 0x80, 0xa5, 0xaa, 0x6f, 0xc1, 0xd1, 0x44, 0xb1, - 0x7c, 0x3d, 0xf8, 0x1c, 0xcc, 0xb9, 0x8e, 0xa9, 0xfb, 0x2c, 0x59, 0xc4, 0xab, 0x15, 0x62, 0x3b, - 0x82, 0xb6, 0x69, 0x12, 0xf6, 0x76, 0xe0, 0xb8, 0xe9, 0x6a, 0x8f, 0xc7, 0xbe, 0x02, 0x4b, 0x49, - 0x76, 0x56, 0xbc, 0xfa, 0x0e, 0x2c, 0x6b, 0xb8, 0xef, 0x3c, 0xc1, 0x87, 0x15, 0x5d, 0x87, 0x95, - 0xb4, 0x00, 0x2e, 0xfc, 0x7d, 0x58, 0x8e, 0x52, 0xdb, 0x81, 0x11, 0x0c, 0xfc, 0x03, 0x09, 0xe7, - 0x8b, 0xe5, 0x47, 0x8e, 0xcf, 0x3a, 0xb2, 0xac, 0x89, 0x4f, 0x75, 0x19, 0x26, 0x5b, 0x8e, 0xd9, - 0x6c, 0xa1, 0x39, 0x28, 0x58, 0x2e, 0x67, 0x2e, 0x58, 0xae, 0xda, 0x89, 0x97, 0xb9, 0xc9, 0x22, - 0x5b, 0x56, 0x74, 0x92, 0x14, 0xdd, 0x80, 0x39, 0xc3, 0x34, 0x2d, 0x62, 0x48, 0x46, 0x4f, 0xb7, - 0x5c, 0x11, 0x98, 0x2f, 0x24, 0xba, 0xbe, 0xd9, 0xd2, 0xaa, 0x11, 0x61, 0xd3, 0xf5, 0xd5, 0xbb, - 0x50, 0x89, 0x16, 0x01, 0xaf, 0x45, 0x0b, 0xdf, 0xc2, 0xe8, 0x78, 0x31, 0x5c, 0x15, 0x6f, 0xa6, - 0x26, 0x49, 0x5e, 0xcd, 0xd7, 0x00, 0x42, 0xa7, 0x2a, 0x42, 0xd0, 0xa3, 0x99, 0x22, 0xb5, 0x18, - 0xa1, 0xfa, 0xef, 0xa5, 0xb8, 0x93, 0x8d, 0x35, 0xd9, 0x0c, 0x9b, 0x6c, 0x4a, 0x4e, 0xb7, 0x70, - 0x40, 0xa7, 0xfb, 0x0a, 0x4c, 0xfa, 0x81, 0x11, 0x60, 0x1e, 0xf3, 0x1f, 0xcf, 0x66, 0x24, 0x05, - 0x63, 0x8d, 0x51, 0xa2, 0x93, 0x00, 0x1d, 0x0f, 0x1b, 0x01, 0x36, 0x75, 0x83, 0xcd, 0x0a, 0x45, - 0xad, 0xc2, 0x53, 0x1a, 0x01, 0xf1, 0x22, 0x62, 0x95, 0x92, 0x31, 0x11, 0xe6, 0x74, 0x63, 0xb4, - 0x5e, 0x09, 0xbd, 0xd7, 0xd4, 0x48, 0xef, 0xc5, 0x59, 0xb9, 0xf7, 0x8a, 0x3c, 0xf1, 0xf4, 0x30, - 0x4f, 0xcc, 0x98, 0xc6, 0xf1, 0xc4, 0xe5, 0x61, 0x9e, 0x98, 0x8b, 0x19, 0xee, 0x89, 0x33, 0x1c, - 0x49, 0x25, 0xcb, 0x91, 0x7c, 0x96, 0xae, 0xf3, 0xaf, 0x0a, 0xb0, 0x92, 0x1e, 0xcf, 0xdc, 0x8f, - 0x5d, 0x87, 0x29, 0x9f, 0xa6, 0x0c, 0xf7, 0x9f, 0x9c, 0x8b, 0xd3, 0xa2, 0xbb, 0x50, 0xb2, 0xec, - 0x5d, 0x87, 0x0f, 0xbc, 0xcb, 0x43, 0x79, 0x78, 0x49, 0x97, 0x9b, 0xf6, 0xae, 0xc3, 0x34, 0x48, - 0x79, 0xd1, 0x43, 0x38, 0x12, 0xae, 0xde, 0x7d, 0x9d, 0x09, 0xc6, 0x22, 0xce, 0x93, 0xac, 0x34, - 0x8c, 0xaa, 0xb8, 0x44, 0x14, 0xf1, 0xb5, 0x39, 0x1b, 0x89, 0x71, 0x08, 0xb9, 0x1f, 0x18, 0x7d, - 0x57, 0x58, 0x6c, 0x98, 0x50, 0x7f, 0x03, 0x2a, 0x61, 0xf1, 0x07, 0xd2, 0x5d, 0x13, 0x16, 0x13, - 0x63, 0x84, 0x2d, 0x56, 0xc3, 0x41, 0xa5, 0x8c, 0x3b, 0xa8, 0xd4, 0x9f, 0x29, 0xf1, 0x81, 0x7e, - 0xcf, 0xea, 0x05, 0xd8, 0x4b, 0x0d, 0xf4, 0xd7, 0x85, 0x5c, 0x36, 0xca, 0xcf, 0x0c, 0x91, 0xcb, - 0xd6, 0x82, 0x7c, 0xc4, 0xbe, 0x07, 0x73, 0xd4, 0xc4, 0x75, 0x1f, 0xf7, 0x68, 0xac, 0xc4, 0xf5, - 0x78, 0x25, 0x5b, 0x00, 0x2b, 0x9d, 0x0d, 0x91, 0x36, 0xe7, 0x60, 0x7d, 0x53, 0xed, 0xc5, 0xd3, - 0xea, 0x77, 0x00, 0xa5, 0x89, 0x0e, 0xa4, 0xc1, 0x0d, 0xe2, 0x2f, 0xfd, 0x20, 0x73, 0xe6, 0xde, - 0xa5, 0xd5, 0x18, 0x6e, 0x79, 0xac, 0xaa, 0x1a, 0xa7, 0x55, 0xff, 0xad, 0x08, 0x10, 0x65, 0x7e, - 0xce, 0x1d, 0xe5, 0xad, 0xd0, 0x61, 0xb1, 0x88, 0x53, 0xcd, 0x16, 0x99, 0xe9, 0xaa, 0x9a, 0xb2, - 0xab, 0x62, 0xb1, 0xe7, 0x8b, 0x39, 0x02, 0x0e, 0xec, 0xa4, 0xa6, 0x3f, 0x6f, 0x4e, 0xea, 0x1e, - 0x2c, 0x25, 0xcd, 0x84, 0x7b, 0xa8, 0x97, 0x61, 0xd2, 0x0a, 0x70, 0x9f, 0x6d, 0x6a, 0x27, 0x36, - 0x45, 0x62, 0xe4, 0x8c, 0x48, 0x7d, 0x1b, 0x96, 0xe4, 0xbe, 0x3a, 0x58, 0xe8, 0xa2, 0x3e, 0x4c, - 0xc6, 0x3e, 0x91, 0xab, 0xe4, 0xf6, 0x91, 0xb9, 0xbd, 0x94, 0xe4, 0x61, 0x94, 0xea, 0x0f, 0x15, - 0x38, 0x9a, 0xc8, 0xca, 0x19, 0xf8, 0x5f, 0x49, 0x0d, 0x60, 0xe6, 0x5b, 0xaf, 0x0f, 0x29, 0xe5, - 0x53, 0x1c, 0xc5, 0x5f, 0x82, 0xba, 0xdc, 0x3d, 0x92, 0x6a, 0x6f, 0x26, 0x86, 0xf2, 0xd9, 0x91, - 0x95, 0x0e, 0xc7, 0x73, 0x0b, 0x8e, 0x67, 0x0a, 0x4e, 0xeb, 0xbc, 0x38, 0xa6, 0xce, 0xff, 0xa7, - 0x10, 0xf7, 0xd9, 0x8d, 0x20, 0xf0, 0xac, 0x47, 0x83, 0x00, 0x7f, 0xb2, 0x41, 0xd5, 0x5a, 0x38, - 0xb2, 0x99, 0x9f, 0x7d, 0x39, 0x9b, 0x33, 0x2a, 0x3d, 0x73, 0x8c, 0xb7, 0xe5, 0x31, 0x5e, 0xa2, - 0xa2, 0x5e, 0x19, 0x29, 0x6a, 0xe8, 0x68, 0xff, 0x2c, 0x07, 0xf1, 0x3f, 0x28, 0x30, 0x9f, 0xe8, - 0x15, 0x74, 0x07, 0xc0, 0x08, 0xab, 0xce, 0xed, 0xe3, 0xcc, 0xa8, 0x26, 0x6a, 0x31, 0x1e, 0x32, - 0x27, 0xb2, 0x78, 0x31, 0x63, 0x4e, 0xcc, 0x88, 0x17, 0xc3, 0x70, 0xf1, 0x76, 0xb4, 0xd8, 0x65, - 0x1b, 0xb1, 0xea, 0xd0, 0xc5, 0x2e, 0xe3, 0x15, 0x2c, 0xea, 0x6f, 0x16, 0x60, 0x31, 0x4b, 0x3a, - 0x7a, 0x01, 0x8a, 0x1d, 0x77, 0xc0, 0x5b, 0x22, 0x9d, 0x80, 0xad, 0xba, 0x83, 0x1d, 0xdf, 0xe8, - 0x62, 0x8d, 0x10, 0xa0, 0x2b, 0x30, 0xd5, 0xc7, 0x7d, 0xc7, 0xdb, 0xe7, 0xf5, 0x96, 0xb6, 0x1b, - 0x36, 0x68, 0x0e, 0xa3, 0xe6, 0x64, 0xe8, 0x5a, 0x14, 0x56, 0xb3, 0xfa, 0xae, 0x48, 0xab, 0x07, - 0x96, 0xc5, 0x58, 0xc2, 0x58, 0xfa, 0x1a, 0x4c, 0xbb, 0x9e, 0xd3, 0xc1, 0xbe, 0xcf, 0x77, 0x43, - 0x56, 0x12, 0x47, 0x72, 0x24, 0x8b, 0xf3, 0x70, 0x42, 0x74, 0x0b, 0x20, 0x0a, 0xa0, 0xf8, 0xcc, - 0x54, 0xcf, 0x8d, 0xb7, 0x7c, 0x2d, 0x46, 0xad, 0x7e, 0xbf, 0x00, 0x4b, 0xd9, 0x9a, 0x43, 0x97, - 0xe2, 0x7a, 0x39, 0x9e, 0xa1, 0x6a, 0x59, 0x3d, 0xaf, 0x27, 0xd4, 0x73, 0x2a, 0x83, 0x23, 0x4b, - 0x4b, 0x37, 0x93, 0x5a, 0x3a, 0x9d, 0xc1, 0x98, 0xad, 0xac, 0x9b, 0x49, 0x65, 0x65, 0xb1, 0x66, - 0xeb, 0xac, 0x91, 0xa1, 0xb3, 0xb3, 0x59, 0x6d, 0xcc, 0x57, 0xdd, 0xdf, 0x2a, 0x30, 0x1b, 0xaf, - 0x97, 0x1c, 0xb2, 0x2a, 0x89, 0x90, 0x15, 0x6d, 0xc2, 0x82, 0xc9, 0x76, 0x6e, 0x75, 0xcb, 0x0e, - 0xb0, 0xb7, 0x6b, 0x74, 0x44, 0x54, 0x78, 0x36, 0xc3, 0x2e, 0x9a, 0x82, 0x86, 0x55, 0xbc, 0xc6, - 0x79, 0xc3, 0x64, 0xd2, 0x82, 0x50, 0x8e, 0xf0, 0x5a, 0x63, 0x08, 0x8a, 0x31, 0xa9, 0xff, 0xaa, - 0xc0, 0x91, 0x0c, 0x05, 0x8f, 0x68, 0xc8, 0x4e, 0x7e, 0x43, 0xce, 0xe7, 0x77, 0xdd, 0xc8, 0xf6, - 0x3c, 0xc8, 0x68, 0xcf, 0xf8, 0xf2, 0xe2, 0xcd, 0xfa, 0xb9, 0x02, 0x47, 0x33, 0xa9, 0x32, 0xb7, - 0x57, 0xaf, 0x41, 0xd9, 0x7b, 0xa6, 0x3f, 0xda, 0x0f, 0xb0, 0x9f, 0x35, 0xb0, 0x77, 0x62, 0xe7, - 0x34, 0xd3, 0xde, 0xb3, 0xbb, 0x84, 0x0e, 0x5d, 0x87, 0x8a, 0xf7, 0x4c, 0xc7, 0x9e, 0xe7, 0x78, - 0xc2, 0x17, 0xe5, 0x32, 0x95, 0xbd, 0x67, 0xeb, 0x94, 0x90, 0x94, 0x14, 0x88, 0x92, 0x4a, 0x23, - 0x4a, 0x0a, 0xa2, 0x92, 0x82, 0xb0, 0xa4, 0xc9, 0x11, 0x25, 0x05, 0xbc, 0x24, 0xf5, 0x4f, 0x0a, - 0x70, 0x62, 0x98, 0xba, 0x3e, 0x31, 0x45, 0xac, 0x03, 0xf2, 0x9e, 0xe9, 0xae, 0xd1, 0x79, 0x8c, - 0x03, 0x5f, 0x37, 0x3d, 0xc7, 0x75, 0xb1, 0x39, 0x4a, 0x23, 0x35, 0xef, 0x59, 0x8b, 0x71, 0xac, - 0x31, 0x86, 0x43, 0x69, 0x66, 0x1d, 0x50, 0x90, 0x2e, 0x7a, 0x84, 0x8a, 0x6a, 0x41, 0xa2, 0x68, - 0xf5, 0x43, 0x98, 0x8d, 0x7b, 0x88, 0x11, 0xb6, 0x7f, 0x1b, 0xaa, 0xdc, 0x83, 0xe8, 0x1d, 0x67, - 0x60, 0x07, 0xa3, 0x14, 0x35, 0xcb, 0xa9, 0x57, 0x09, 0xb1, 0xfa, 0xb5, 0x70, 0xb8, 0x7d, 0x6a, - 0x45, 0xfe, 0x5a, 0x01, 0x2a, 0xe1, 0x39, 0x3e, 0x99, 0xe9, 0xd9, 0x69, 0x3f, 0xeb, 0x77, 0x7e, - 0xac, 0xff, 0x40, 0x8e, 0x5a, 0x58, 0x9c, 0xfa, 0x42, 0x26, 0x12, 0x60, 0xc4, 0xc2, 0xe4, 0x2a, - 0x2c, 0x0e, 0x7c, 0xec, 0xe9, 0xbe, 0x8b, 0x3b, 0xd6, 0xae, 0x85, 0x4d, 0x9d, 0x15, 0x87, 0x68, - 0x71, 0x88, 0xe4, 0xb5, 0x45, 0x16, 0x95, 0x99, 0xb5, 0x94, 0x39, 0x92, 0xb9, 0x94, 0xf9, 0xb8, - 0xa1, 0xcc, 0x35, 0x28, 0x7f, 0x01, 0xef, 0xb3, 0xc5, 0xfe, 0x98, 0x7c, 0xea, 0xb7, 0x4a, 0xb0, - 0x9c, 0x73, 0x0c, 0x44, 0x57, 0x8a, 0xee, 0x40, 0x77, 0xb1, 0x67, 0x39, 0xa6, 0xe8, 0xb5, 0x8e, - 0x3b, 0x68, 0xd1, 0x04, 0x74, 0x1c, 0xc8, 0x87, 0xfe, 0xb5, 0x81, 0xc3, 0x83, 0xd1, 0xa2, 0x56, - 0xee, 0xb8, 0x83, 0x2f, 0x92, 0x6f, 0xc1, 0xeb, 0xef, 0x19, 0x1e, 0x66, 0xfe, 0x83, 0xf1, 0xb6, - 0x69, 0x02, 0x7a, 0x05, 0x8e, 0xb2, 0xb9, 0x51, 0xef, 0x59, 0x7d, 0x8b, 0x78, 0xd9, 0xd8, 0xd0, - 0x28, 0x6a, 0x88, 0x65, 0x3e, 0x24, 0x79, 0x4d, 0x9b, 0x0d, 0x06, 0x15, 0xaa, 0x8e, 0xd3, 0xd7, - 0xfd, 0x8e, 0xe3, 0x61, 0xdd, 0x30, 0x3f, 0xa4, 0xe3, 0xa0, 0xa8, 0xcd, 0x38, 0x4e, 0xbf, 0x4d, - 0xd2, 0x1a, 0xe6, 0x87, 0xe8, 0x34, 0xcc, 0x74, 0xdc, 0x81, 0x8f, 0x03, 0x9d, 0xfc, 0xa1, 0x9b, - 0x75, 0x15, 0x0d, 0x58, 0xd2, 0xaa, 0x3b, 0xf0, 0x63, 0x04, 0x7d, 0xb2, 0x3c, 0x9b, 0x8e, 0x13, - 0x6c, 0xe0, 0x3e, 0x3d, 0x51, 0xdf, 0x1b, 0x74, 0xb1, 0x6b, 0x74, 0x31, 0xab, 0x9a, 0xd8, 0x71, - 0x93, 0x4e, 0xd4, 0x1f, 0x70, 0x12, 0x5a, 0x41, 0x6d, 0x6e, 0x2f, 0xfe, 0xe9, 0xa3, 0x77, 0x61, - 0x7a, 0x60, 0x53, 0x03, 0x58, 0xa9, 0x50, 0xde, 0xab, 0x63, 0x1c, 0xba, 0x5d, 0xde, 0x61, 0x2c, - 0xfc, 0x0c, 0x90, 0x0b, 0x40, 0xb7, 0xa0, 0xce, 0x15, 0xe5, 0x3f, 0x35, 0xdc, 0xa4, 0xb6, 0x80, - 0xaa, 0x60, 0x89, 0x51, 0xb4, 0x9f, 0x1a, 0x6e, 0x5c, 0x63, 0xf5, 0x5b, 0x30, 0x1b, 0x17, 0x7a, - 0x20, 0x5b, 0xba, 0x0b, 0x55, 0xa9, 0x91, 0xa4, 0xb7, 0xa9, 0x52, 0x7c, 0xeb, 0xeb, 0x62, 0x6c, - 0x95, 0x49, 0x42, 0xdb, 0xfa, 0x3a, 0xc5, 0x41, 0xd0, 0x9a, 0x51, 0x39, 0x25, 0x8d, 0x7d, 0xa8, - 0x06, 0x54, 0x25, 0xe8, 0x01, 0x71, 0xc9, 0x14, 0x63, 0xc0, 0x5d, 0x32, 0xf9, 0x4d, 0xd2, 0x3c, - 0xa7, 0x27, 0x6a, 0x40, 0x7f, 0x93, 0x34, 0x7a, 0x00, 0xcd, 0x8e, 0xd3, 0xe8, 0x6f, 0x5a, 0x04, - 0x7e, 0xc2, 0x61, 0x4c, 0x15, 0x8d, 0x7d, 0xa8, 0xbf, 0xa7, 0x00, 0xac, 0x1a, 0xae, 0xf1, 0xc8, - 0xea, 0x59, 0xc1, 0x3e, 0xba, 0x00, 0x35, 0xc3, 0x34, 0xf5, 0x8e, 0x48, 0xb1, 0xb0, 0xc0, 0x95, - 0xcd, 0x1b, 0xa6, 0xb9, 0x1a, 0x4b, 0x46, 0x2f, 0xc1, 0x02, 0x71, 0xa8, 0x32, 0x2d, 0x03, 0x9a, - 0xd5, 0x48, 0x86, 0x44, 0x7c, 0x03, 0x56, 0x88, 0x5c, 0xa3, 0xff, 0xc8, 0xc2, 0x76, 0x20, 0xf3, - 0x30, 0x04, 0xda, 0x92, 0x61, 0x9a, 0x0d, 0x96, 0x1d, 0xe7, 0x54, 0xff, 0x60, 0x1a, 0x4e, 0xca, - 0x3d, 0x9e, 0x44, 0x83, 0xdc, 0x82, 0xd9, 0x44, 0x7d, 0x53, 0x38, 0x8a, 0xa8, 0x85, 0x9a, 0x44, - 0x9b, 0xc0, 0x22, 0x14, 0x52, 0x58, 0x84, 0x4c, 0xa4, 0x49, 0xf1, 0x13, 0x42, 0x9a, 0x94, 0x3e, - 0x26, 0xd2, 0x64, 0xf2, 0xb0, 0x48, 0x93, 0xd9, 0xb1, 0x91, 0x26, 0x2f, 0x50, 0xd7, 0x2b, 0x4a, - 0xa4, 0xe1, 0x00, 0xf3, 0x09, 0xd5, 0x50, 0xba, 0x2d, 0xc0, 0x8e, 0x09, 0x44, 0xca, 0xf4, 0x41, - 0x10, 0x29, 0xe5, 0x43, 0x22, 0x52, 0x16, 0x3e, 0x11, 0x44, 0xca, 0x19, 0x98, 0xb5, 0x1d, 0xdd, - 0xc6, 0x4f, 0x75, 0xd2, 0xf5, 0x3e, 0xc5, 0xb9, 0x94, 0x35, 0xb0, 0x9d, 0x4d, 0xfc, 0xb4, 0x45, - 0x52, 0xd0, 0x59, 0x98, 0xed, 0x1b, 0xfe, 0x63, 0x6c, 0x52, 0x68, 0x88, 0xbf, 0x52, 0xa5, 0x36, - 0x3b, 0xc3, 0xd2, 0x5a, 0x24, 0x09, 0x3d, 0x0f, 0x61, 0x5b, 0x39, 0xd1, 0x1c, 0x25, 0xaa, 0x8a, - 0x54, 0x46, 0x16, 0x43, 0xb7, 0xcc, 0x1f, 0x12, 0xdd, 0x52, 0x3b, 0x08, 0xba, 0xe5, 0x12, 0xd4, - 0xc4, 0x6f, 0x01, 0x6f, 0x61, 0xa7, 0x15, 0x14, 0xd9, 0x32, 0x2f, 0xf2, 0x04, 0x84, 0x25, 0x0f, - 0x0c, 0x03, 0x43, 0xc1, 0x30, 0x7f, 0xaa, 0xf0, 0x75, 0x73, 0x38, 0x48, 0xf9, 0x29, 0xbc, 0x04, - 0xa0, 0x50, 0x0e, 0x03, 0xa0, 0x40, 0xdb, 0xb9, 0x10, 0x93, 0x0b, 0xf9, 0x92, 0x46, 0x81, 0x4c, - 0x54, 0x0b, 0x90, 0xcc, 0x41, 0x07, 0x0a, 0x87, 0x51, 0xb0, 0x99, 0x9a, 0xc2, 0x28, 0x6a, 0x50, - 0xec, 0x72, 0x60, 0x45, 0x51, 0x23, 0x3f, 0xf3, 0x2c, 0xb8, 0x98, 0x67, 0xc1, 0xea, 0x46, 0xb8, - 0x7a, 0xfe, 0x24, 0x90, 0x7f, 0xea, 0x7f, 0x2a, 0x70, 0x92, 0xcb, 0xcb, 0x81, 0xc7, 0x65, 0x0c, - 0x5a, 0x25, 0x67, 0xd0, 0x76, 0x3c, 0x6c, 0x62, 0x3b, 0xb0, 0x8c, 0x1e, 0x8d, 0xc7, 0xc4, 0x81, - 0x78, 0x94, 0x4c, 0x43, 0xc2, 0xb3, 0x30, 0xcb, 0x40, 0xb4, 0x7c, 0x21, 0xcd, 0xb0, 0xb2, 0x33, - 0x14, 0x47, 0xcb, 0xd7, 0xca, 0x5b, 0x59, 0x8e, 0xb2, 0x94, 0xbb, 0x03, 0x33, 0xd2, 0x5f, 0xaa, - 0x0e, 0x2c, 0xe7, 0x40, 0x13, 0x32, 0x2d, 0x42, 0x49, 0x5b, 0xc4, 0x50, 0x25, 0xa5, 0x2d, 0xe2, - 0x5b, 0x0a, 0x9c, 0x4e, 0x2d, 0xe8, 0x3f, 0x7b, 0xcd, 0xaa, 0x7f, 0xa1, 0x84, 0xf6, 0x93, 0x1c, - 0x5d, 0xab, 0xe9, 0xd1, 0xf5, 0xfc, 0xb0, 0xfd, 0x89, 0xcc, 0xf1, 0xf5, 0x5e, 0xee, 0xf8, 0x7a, - 0x69, 0xe8, 0x5e, 0xc7, 0x28, 0x7d, 0xfe, 0x51, 0x01, 0x8e, 0xe5, 0x56, 0x20, 0x11, 0xde, 0x2a, - 0xc9, 0xf0, 0x96, 0x87, 0xc6, 0xd1, 0x62, 0x86, 0x85, 0xc6, 0x74, 0xbd, 0xc2, 0x63, 0x50, 0xbd, - 0x6f, 0x3c, 0xb3, 0xfa, 0x83, 0x3e, 0x8f, 0x8d, 0x89, 0xb8, 0x0d, 0x96, 0x72, 0x98, 0xe0, 0xf8, - 0x0a, 0x2c, 0xb2, 0x79, 0x8b, 0xc6, 0x67, 0x11, 0x07, 0x8b, 0x91, 0x17, 0x58, 0x1e, 0x09, 0xd5, - 0x04, 0xc3, 0x03, 0xa8, 0x1a, 0xbb, 0xbb, 0x96, 0x4d, 0xd5, 0xc6, 0x62, 0xe5, 0x62, 0x0e, 0xb6, - 0x66, 0xd5, 0x1d, 0x50, 0x57, 0xd0, 0xe0, 0xf4, 0xda, 0xac, 0xe0, 0x24, 0x21, 0xb5, 0xfa, 0xc5, - 0xd0, 0xd2, 0x93, 0x84, 0xe8, 0x18, 0x94, 0x59, 0x4b, 0x7d, 0xe6, 0x21, 0x4a, 0xda, 0x34, 0x6d, - 0xa6, 0xff, 0x58, 0x68, 0x88, 0x4d, 0xe8, 0x0c, 0x18, 0x4d, 0x68, 0x29, 0xbf, 0xda, 0x80, 0x85, - 0x50, 0xe7, 0x43, 0x71, 0x63, 0x31, 0x1c, 0x58, 0x41, 0xc6, 0x81, 0xd9, 0x30, 0xb5, 0x86, 0x9f, - 0x58, 0x1d, 0xfc, 0x89, 0x20, 0xed, 0xcf, 0xc0, 0x8c, 0x8b, 0xbd, 0xbe, 0xe5, 0xfb, 0x61, 0x04, - 0x55, 0xd1, 0xe2, 0x49, 0xea, 0x69, 0xa8, 0xac, 0xae, 0x35, 0x79, 0x91, 0x19, 0x55, 0x55, 0xff, - 0x6b, 0x0a, 0xe6, 0x93, 0x03, 0xe0, 0x66, 0x0a, 0x97, 0x76, 0x32, 0x73, 0x4f, 0x33, 0x63, 0x33, - 0x3f, 0x04, 0xb5, 0x17, 0xc6, 0x00, 0xb5, 0xaf, 0xc0, 0x74, 0xc7, 0xe9, 0xf7, 0x0d, 0xdb, 0x14, - 0xf7, 0x25, 0xf8, 0x27, 0xa9, 0xa9, 0xe1, 0x75, 0xd9, 0x36, 0x7e, 0x45, 0xa3, 0xbf, 0x89, 0x7d, - 0x12, 0x4f, 0x6d, 0xd9, 0x14, 0xd9, 0x46, 0x4d, 0xa8, 0xa2, 0x01, 0x4f, 0x5a, 0xb3, 0x3c, 0x74, - 0x1e, 0x4a, 0xd8, 0x7e, 0x22, 0x4c, 0x46, 0xda, 0x4e, 0x16, 0xeb, 0x4f, 0x8d, 0x52, 0xa0, 0x0b, - 0x30, 0xd5, 0x27, 0x36, 0x2f, 0xd0, 0x0f, 0x0b, 0xa9, 0x7b, 0x05, 0x1a, 0x27, 0x40, 0x2f, 0xc3, - 0xb4, 0x49, 0xb5, 0x27, 0x16, 0x5c, 0x48, 0xc2, 0xc8, 0xd1, 0x2c, 0x4d, 0x90, 0xa0, 0x77, 0xc2, - 0xb3, 0x8c, 0x4a, 0xfa, 0x90, 0x31, 0xa1, 0xe6, 0xcc, 0x63, 0x8c, 0x4d, 0x79, 0x43, 0x00, 0xd2, - 0x27, 0x22, 0x49, 0x29, 0xc3, 0xb7, 0x05, 0x8e, 0x41, 0xb9, 0xe7, 0x74, 0x99, 0xf5, 0xcc, 0xb0, - 0xcb, 0x36, 0x3d, 0xa7, 0x4b, 0x8d, 0x67, 0x11, 0x26, 0xfd, 0xc0, 0xb4, 0x6c, 0x1a, 0xb7, 0x96, - 0x35, 0xf6, 0x41, 0x3c, 0x08, 0xfd, 0xa1, 0x3b, 0x76, 0x07, 0xaf, 0x54, 0x69, 0x56, 0x85, 0xa6, - 0x6c, 0xd9, 0x1d, 0xba, 0x7e, 0x0f, 0x82, 0xfd, 0x95, 0x39, 0x9a, 0x4e, 0x7e, 0x46, 0x47, 0x0a, - 0xf3, 0x39, 0x47, 0x0a, 0x89, 0x0a, 0x67, 0x1c, 0x29, 0xd4, 0x72, 0x27, 0xb4, 0x24, 0xaf, 0x60, - 0x21, 0x31, 0xfb, 0xea, 0x5a, 0x53, 0x17, 0x5d, 0xb3, 0x90, 0xbe, 0x23, 0x10, 0x9a, 0xbd, 0x06, - 0xe1, 0xcf, 0xcf, 0xf4, 0x44, 0xe7, 0xfb, 0x0a, 0x2c, 0xad, 0xd2, 0xf3, 0xec, 0x98, 0xe3, 0x3e, - 0x08, 0x14, 0xec, 0xd5, 0x10, 0x9f, 0x97, 0x01, 0xb2, 0x4a, 0x6a, 0x4a, 0xc0, 0xf3, 0x56, 0x61, - 0x4e, 0x88, 0xe5, 0xcc, 0xc5, 0x31, 0xc0, 0x7d, 0x55, 0x3f, 0xfe, 0xa9, 0xde, 0x86, 0xe5, 0x54, - 0xcd, 0xf9, 0xa9, 0x62, 0xf2, 0x32, 0x09, 0xab, 0x78, 0xfc, 0x32, 0x89, 0x7a, 0x0b, 0x8e, 0xb6, - 0x03, 0xc3, 0x0b, 0x52, 0xcd, 0x1e, 0x83, 0x97, 0xc2, 0xf6, 0x64, 0x5e, 0x8e, 0xac, 0x6b, 0xc3, - 0x62, 0x3b, 0x70, 0xdc, 0x43, 0x08, 0x25, 0x7e, 0x87, 0xb4, 0xdc, 0x19, 0x88, 0x49, 0x50, 0x7c, - 0xaa, 0xcb, 0x0c, 0x64, 0x98, 0x2e, 0xed, 0x4d, 0x58, 0x62, 0x18, 0xbf, 0xc3, 0x34, 0xe2, 0x98, - 0x40, 0x18, 0xa6, 0xe5, 0xde, 0x87, 0x23, 0xd2, 0x39, 0x07, 0xc7, 0xc4, 0x5c, 0x95, 0x31, 0x31, - 0xf9, 0x47, 0x4a, 0x21, 0x24, 0xe6, 0xb7, 0x0b, 0x31, 0x3f, 0x9e, 0x73, 0x30, 0xfe, 0x9a, 0x8c, - 0x88, 0x39, 0x9d, 0x2f, 0x55, 0x02, 0xc4, 0xa4, 0xad, 0xb3, 0x98, 0x61, 0x9d, 0x3b, 0xa9, 0x53, - 0xf7, 0x52, 0x1a, 0xd1, 0x94, 0xa8, 0xe1, 0xa7, 0x72, 0xde, 0xfe, 0x90, 0xa1, 0x66, 0xc2, 0xa2, - 0xc3, 0xa3, 0xf6, 0x57, 0x13, 0x47, 0xed, 0xc7, 0x87, 0xd4, 0x34, 0x3c, 0x64, 0xff, 0x6e, 0x09, - 0x2a, 0x61, 0x5e, 0x4a, 0xc3, 0x69, 0x55, 0x15, 0x32, 0x54, 0x15, 0x9f, 0x5f, 0x8b, 0x87, 0x9c, - 0x5f, 0x4b, 0x63, 0xcc, 0xaf, 0xc7, 0xa1, 0xc2, 0x2e, 0x8d, 0x79, 0x78, 0x97, 0xcf, 0x97, 0x65, - 0x9a, 0xa0, 0xe1, 0xdd, 0xc8, 0xc4, 0xa6, 0xc6, 0x34, 0xb1, 0x04, 0x42, 0x67, 0x3a, 0x89, 0xd0, - 0xb9, 0x19, 0xce, 0x7d, 0xe5, 0xf4, 0x89, 0x58, 0x28, 0x31, 0x73, 0xd6, 0x4b, 0x6c, 0x83, 0x57, - 0xd2, 0xdb, 0xe0, 0x11, 0xff, 0xc8, 0xf9, 0x8e, 0x35, 0xd9, 0x32, 0xf9, 0x0d, 0xb9, 0x69, 0xfa, - 0xdd, 0x34, 0x3f, 0x4b, 0xd7, 0xbf, 0xc5, 0x10, 0x39, 0x71, 0x13, 0xe4, 0xee, 0xf3, 0x35, 0xe9, - 0x30, 0x54, 0xc9, 0x98, 0xc6, 0x42, 0x97, 0x11, 0x3f, 0x00, 0xdd, 0x81, 0xa5, 0x24, 0x92, 0xef, - 0x40, 0xee, 0x2f, 0x07, 0x52, 0xfc, 0x93, 0x78, 0x30, 0x98, 0x83, 0x9f, 0xbd, 0x99, 0x82, 0x7a, - 0x8c, 0x6d, 0xbc, 0x57, 0x65, 0x54, 0xd8, 0x81, 0x4d, 0x2e, 0x05, 0x0a, 0xa3, 0xc1, 0x8a, 0xe1, - 0xf1, 0x6c, 0xb6, 0xa8, 0xa8, 0xf0, 0x94, 0x06, 0x5d, 0xd1, 0x90, 0x88, 0xdf, 0xdf, 0x63, 0xf9, - 0x53, 0x6c, 0x45, 0x23, 0x92, 0x1a, 0x74, 0xf3, 0x18, 0x3f, 0xb3, 0x02, 0xbd, 0xe3, 0x98, 0x98, - 0x1a, 0xf4, 0xa4, 0x56, 0x26, 0x09, 0xab, 0x8e, 0x89, 0xa3, 0xa1, 0x56, 0x3e, 0xe8, 0x50, 0xab, - 0x24, 0x86, 0xda, 0x12, 0x4c, 0x79, 0xd8, 0xf0, 0x1d, 0x9b, 0x9b, 0x24, 0xff, 0x22, 0x1d, 0xd1, - 0xc7, 0xbe, 0x4f, 0xca, 0xe0, 0xb1, 0x19, 0xff, 0x8c, 0xc5, 0x91, 0xb3, 0x43, 0xe2, 0xc8, 0x21, - 0xe8, 0xdc, 0x44, 0x1c, 0x59, 0x1d, 0x12, 0x47, 0x8e, 0x05, 0xce, 0x8d, 0x22, 0xe6, 0xb9, 0x51, - 0x11, 0x73, 0x3c, 0xe4, 0x9c, 0x97, 0x43, 0xce, 0xdb, 0xf1, 0x95, 0x75, 0x2d, 0x8d, 0x55, 0x18, - 0xbe, 0xa4, 0x8e, 0x8f, 0xed, 0x05, 0x69, 0x6c, 0xa3, 0x4b, 0x7c, 0x07, 0x1f, 0xa5, 0xf7, 0x7e, - 0xa5, 0xad, 0x28, 0xb6, 0xb9, 0xff, 0x59, 0xba, 0x82, 0x7f, 0x54, 0x60, 0x39, 0x35, 0x74, 0xb9, - 0x33, 0x78, 0x35, 0x01, 0x20, 0x1e, 0x8a, 0xdc, 0x15, 0xf8, 0xe1, 0x86, 0x84, 0x1f, 0xbe, 0x34, - 0x8c, 0x25, 0x07, 0x3e, 0x7c, 0x78, 0x48, 0xef, 0x37, 0x15, 0x40, 0x19, 0xbb, 0x10, 0x37, 0xc5, - 0x92, 0xe0, 0x00, 0x5b, 0x93, 0x7c, 0x55, 0xf0, 0x4e, 0xb4, 0x2a, 0x28, 0x1c, 0x64, 0xe7, 0x25, - 0xc4, 0x1a, 0xad, 0x43, 0x55, 0xde, 0x7c, 0xbc, 0x2e, 0x57, 0xe6, 0x54, 0x7e, 0x65, 0xa8, 0x81, - 0x30, 0x62, 0xf5, 0x27, 0x05, 0x38, 0xbd, 0xe3, 0x9a, 0x89, 0x90, 0x97, 0x17, 0x36, 0xbe, 0xab, - 0xbd, 0x29, 0xe3, 0xad, 0x0e, 0xa9, 0x89, 0xe2, 0x61, 0x34, 0x81, 0xbe, 0x9a, 0x85, 0x88, 0xbb, - 0x2d, 0x9d, 0x5d, 0x0f, 0x6f, 0xe0, 0x08, 0x70, 0xdc, 0xc7, 0x1d, 0x09, 0x2a, 0x9c, 0xc9, 0xaf, - 0x00, 0x0f, 0x8f, 0x7f, 0x19, 0xe6, 0xd7, 0x9f, 0xe1, 0x4e, 0x7b, 0xdf, 0xee, 0x1c, 0x40, 0xeb, - 0x35, 0x28, 0x76, 0xfa, 0x26, 0x3f, 0x35, 0x23, 0x3f, 0xe3, 0x11, 0x7f, 0x51, 0x8e, 0xf8, 0x75, - 0xa8, 0x45, 0x25, 0xf0, 0x71, 0xb8, 0x44, 0xc6, 0xa1, 0x49, 0x88, 0x89, 0xf0, 0x59, 0x8d, 0x7f, - 0xf1, 0x74, 0xec, 0xb1, 0x1b, 0x4e, 0x2c, 0x1d, 0x7b, 0x9e, 0x3c, 0x8d, 0x14, 0xe5, 0x69, 0x44, - 0xfd, 0xb6, 0x02, 0x33, 0xa4, 0x84, 0x8f, 0x55, 0x7f, 0xbe, 0xec, 0x2e, 0x46, 0xcb, 0xee, 0x70, - 0xf5, 0x5e, 0x8a, 0xaf, 0xde, 0xa3, 0x9a, 0x4f, 0xd2, 0xe4, 0x74, 0xcd, 0xa7, 0xc2, 0x74, 0xec, - 0x79, 0xea, 0x19, 0x98, 0x65, 0x75, 0xe3, 0x2d, 0xaf, 0x41, 0x71, 0xe0, 0xf5, 0x44, 0xff, 0x0d, - 0xbc, 0x9e, 0xfa, 0x0d, 0x05, 0xaa, 0x8d, 0x20, 0x30, 0x3a, 0x7b, 0x07, 0x68, 0x40, 0x58, 0xb9, - 0x42, 0xbc, 0x72, 0xe9, 0x46, 0x44, 0xd5, 0x2d, 0xe5, 0x54, 0x77, 0x52, 0xaa, 0xae, 0x0a, 0x73, - 0xa2, 0x2e, 0xb9, 0x15, 0xde, 0x04, 0xd4, 0x72, 0xbc, 0xe0, 0x9e, 0xe3, 0x3d, 0x35, 0x3c, 0xf3, - 0x60, 0x2b, 0x6c, 0x04, 0x25, 0xfe, 0xb4, 0x46, 0xf1, 0xfc, 0xa4, 0x46, 0x7f, 0xab, 0x2f, 0xc2, - 0x11, 0x49, 0x5e, 0x6e, 0xc1, 0xb7, 0x60, 0x86, 0x86, 0x05, 0x7c, 0xf1, 0xf5, 0x52, 0x1c, 0xf0, - 0x31, 0x22, 0x7c, 0x50, 0xd7, 0x60, 0x81, 0x04, 0x88, 0x34, 0x3d, 0xf4, 0x2f, 0x57, 0x12, 0xeb, - 0x93, 0xe5, 0x94, 0x88, 0xc4, 0xda, 0xe4, 0x67, 0x0a, 0x4c, 0x32, 0x6c, 0x47, 0x32, 0x68, 0x3b, - 0x4e, 0x26, 0x5e, 0xd7, 0xd1, 0x03, 0xa3, 0x1b, 0x3e, 0x5b, 0x42, 0x12, 0xb6, 0x8d, 0x2e, 0x3d, - 0x85, 0xa3, 0x99, 0xa6, 0xd5, 0xc5, 0x7e, 0x20, 0x4e, 0x8e, 0x67, 0x48, 0xda, 0x1a, 0x4b, 0x22, - 0x8a, 0xa1, 0x07, 0xec, 0x25, 0xba, 0x5b, 0x4a, 0x7f, 0xa3, 0xf3, 0xec, 0x54, 0x67, 0xf8, 0x71, - 0x29, 0x3d, 0xed, 0xa9, 0x43, 0x39, 0x71, 0xce, 0x19, 0x7e, 0xa3, 0x0b, 0x50, 0xa2, 0x1b, 0xf9, - 0xd3, 0xc3, 0xb4, 0x44, 0x49, 0x88, 0x55, 0xb8, 0x96, 0x6d, 0x63, 0x93, 0xbf, 0xa9, 0xc1, 0xbf, - 0xd4, 0x77, 0x00, 0xc5, 0x95, 0xc7, 0x3b, 0xe8, 0x02, 0x4c, 0x51, 0xdd, 0x8a, 0xa8, 0x7a, 0x21, - 0x25, 0x5a, 0xe3, 0x04, 0xea, 0x57, 0x00, 0xb1, 0xb2, 0xa4, 0x48, 0xfa, 0x20, 0x1d, 0x38, 0x24, - 0xa6, 0xfe, 0x9e, 0x02, 0x47, 0x24, 0xe9, 0xbc, 0x7e, 0x2f, 0xca, 0xe2, 0x33, 0xaa, 0xc7, 0x45, - 0xbf, 0x25, 0x4d, 0xf0, 0x17, 0xd2, 0xd5, 0xf8, 0x7f, 0x9a, 0xdc, 0xff, 0x59, 0x01, 0x68, 0x0c, - 0x82, 0x3d, 0xbe, 0x29, 0x1c, 0xef, 0x44, 0x25, 0xd1, 0x89, 0x75, 0x28, 0xbb, 0x86, 0xef, 0x3f, - 0x75, 0x3c, 0xb1, 0xe0, 0x0d, 0xbf, 0xe9, 0x56, 0xee, 0x80, 0x3f, 0x24, 0x52, 0xd1, 0xe8, 0x6f, - 0xf4, 0x3c, 0xcc, 0xb1, 0xf7, 0x74, 0x74, 0xc3, 0x34, 0x3d, 0x01, 0x22, 0xad, 0x68, 0x55, 0x96, - 0xda, 0x60, 0x89, 0x84, 0xcc, 0xa2, 0xc7, 0x3a, 0xc1, 0xbe, 0x1e, 0x38, 0x8f, 0xb1, 0xcd, 0x17, - 0xb1, 0x55, 0x91, 0xba, 0x4d, 0x12, 0xd9, 0x11, 0x71, 0xd7, 0xf2, 0x03, 0x4f, 0x90, 0x89, 0xc3, - 0x74, 0x9e, 0x4a, 0xc9, 0xd4, 0x3f, 0x53, 0xa0, 0xd6, 0x1a, 0xf4, 0x7a, 0x4c, 0xb9, 0x87, 0xe9, - 0xe4, 0x8b, 0xbc, 0x29, 0x85, 0xb4, 0xc9, 0x47, 0x8a, 0xe2, 0x4d, 0xfc, 0x44, 0xf6, 0xdd, 0xae, - 0xc2, 0x42, 0xac, 0xc6, 0xdc, 0x70, 0xa4, 0xa5, 0x86, 0x22, 0x2f, 0x35, 0xd4, 0x06, 0x20, 0xb6, - 0xd5, 0x74, 0xe8, 0x56, 0xaa, 0x47, 0xe1, 0x88, 0x24, 0x82, 0x4f, 0xc5, 0x17, 0xa1, 0xca, 0x01, - 0x8d, 0xdc, 0x20, 0x8e, 0x41, 0x99, 0xb8, 0xd4, 0x8e, 0x65, 0x0a, 0xe4, 0xcc, 0xb4, 0xeb, 0x98, - 0xab, 0x96, 0xe9, 0xa9, 0x5f, 0x84, 0x2a, 0x7f, 0x31, 0x81, 0xd3, 0xde, 0x81, 0x39, 0x7e, 0xd0, - 0xaa, 0x4b, 0x57, 0x8c, 0x8f, 0x65, 0xa0, 0x66, 0x85, 0x2a, 0xec, 0xf8, 0xa7, 0xfa, 0x55, 0xa8, - 0xb3, 0x68, 0x41, 0x12, 0x2c, 0x1a, 0x78, 0x07, 0x04, 0x68, 0x6d, 0x88, 0x7c, 0x99, 0xb3, 0xea, - 0xc5, 0x3f, 0xd5, 0x93, 0x70, 0x3c, 0x53, 0x3e, 0x6f, 0xbd, 0x0b, 0xb5, 0x28, 0x83, 0xdd, 0x83, - 0x0d, 0xe1, 0x40, 0x4a, 0x0c, 0x0e, 0xb4, 0x14, 0x86, 0xf0, 0x05, 0x31, 0x73, 0xd1, 0x28, 0x3d, - 0x5a, 0x02, 0x16, 0xf3, 0x96, 0x80, 0x25, 0x69, 0x09, 0xa8, 0x6e, 0x84, 0x3a, 0xe4, 0x0b, 0xf1, - 0xdb, 0x74, 0xab, 0x80, 0x95, 0x2d, 0x9c, 0xda, 0x89, 0xec, 0xf6, 0x31, 0x22, 0x2d, 0x46, 0xaf, - 0x5e, 0x80, 0xaa, 0xec, 0xde, 0x62, 0x1e, 0x4b, 0x91, 0x3d, 0xd6, 0xaf, 0xc0, 0x92, 0x26, 0x21, - 0x00, 0xef, 0x61, 0x23, 0x18, 0x78, 0xd8, 0x47, 0x6f, 0x42, 0x3d, 0xe3, 0x89, 0x23, 0x9d, 0xaf, - 0x0c, 0x99, 0x98, 0xe5, 0xd4, 0x4b, 0x47, 0x1b, 0x6c, 0x5d, 0xf8, 0x22, 0xcc, 0x53, 0x84, 0x62, - 0xec, 0x66, 0x2f, 0xd3, 0x11, 0x7d, 0xfb, 0x66, 0x33, 0xba, 0xc6, 0x6b, 0x86, 0xef, 0x6d, 0xf0, - 0xf2, 0x33, 0xcf, 0xd8, 0xde, 0x86, 0xf2, 0x2e, 0xaf, 0x17, 0x1f, 0x90, 0x6a, 0x86, 0x32, 0x12, - 0x2d, 0xd0, 0x42, 0x1e, 0x75, 0x0b, 0xe6, 0x39, 0x4d, 0xd8, 0xbc, 0xdb, 0x43, 0x41, 0x31, 0xac, - 0x79, 0xb9, 0x70, 0x17, 0xf5, 0x7b, 0x05, 0x98, 0x4b, 0xf8, 0xf8, 0x57, 0x12, 0x0b, 0xba, 0x2c, - 0x73, 0x4c, 0x2c, 0xe7, 0x6e, 0x48, 0xde, 0x5e, 0x86, 0xe0, 0x0c, 0xbf, 0x04, 0xba, 0x0e, 0xb5, - 0x04, 0x9e, 0x53, 0x60, 0xb9, 0xeb, 0xf9, 0x8a, 0xd1, 0xe6, 0x65, 0xb0, 0xa7, 0x8f, 0xde, 0x88, - 0xe9, 0xb5, 0x94, 0x5e, 0x86, 0x26, 0x74, 0x16, 0x29, 0xf4, 0xf0, 0x13, 0xcd, 0x22, 0x9f, 0x7e, - 0xef, 0xf9, 0x84, 0x9f, 0xdb, 0xa7, 0x7a, 0x0e, 0x66, 0x76, 0xf2, 0x9e, 0x34, 0x2a, 0x09, 0x98, - 0xe8, 0xeb, 0xb0, 0x78, 0xcf, 0xea, 0x61, 0x7f, 0xdf, 0x0f, 0x70, 0xbf, 0x49, 0x67, 0x85, 0x5d, - 0x0b, 0x7b, 0xe8, 0x14, 0x00, 0x35, 0x4a, 0xd7, 0xb1, 0xc2, 0x27, 0x56, 0x62, 0x29, 0xea, 0x8f, - 0x15, 0x98, 0x8f, 0x18, 0xc7, 0xc1, 0x02, 0xbf, 0x06, 0x93, 0xbb, 0xbe, 0xd8, 0xd0, 0x4d, 0x1c, - 0x73, 0x65, 0x55, 0x41, 0x2b, 0xed, 0xfa, 0x4d, 0x13, 0xbd, 0x0e, 0x30, 0xf0, 0xb1, 0xc9, 0x8f, - 0xbd, 0x47, 0xa0, 0xb3, 0x2b, 0x84, 0x94, 0x9d, 0x83, 0xdf, 0x80, 0x19, 0xcb, 0x76, 0x4c, 0x4c, - 0x21, 0x11, 0xe6, 0x28, 0x64, 0x36, 0x30, 0xda, 0x1d, 0x1f, 0x9b, 0xea, 0x1f, 0x46, 0xc0, 0x86, - 0xcf, 0x73, 0x0b, 0xd5, 0x3f, 0x17, 0x71, 0x91, 0xe8, 0x76, 0x3e, 0x66, 0x1e, 0xc0, 0x02, 0x9b, - 0xde, 0x76, 0xc3, 0x32, 0x33, 0xaf, 0xac, 0x25, 0x1a, 0xa7, 0xd5, 0x2c, 0x1e, 0x11, 0x0b, 0x26, - 0xd4, 0x82, 0xa3, 0xd1, 0x42, 0x25, 0x2e, 0xad, 0x30, 0x5a, 0xda, 0x62, 0x27, 0xb6, 0xff, 0x2f, - 0x18, 0xd5, 0x5b, 0x70, 0x34, 0x71, 0x2b, 0x65, 0xfc, 0x43, 0xa0, 0x77, 0x13, 0x5b, 0xb6, 0x91, - 0x97, 0xb8, 0x2a, 0x5f, 0x86, 0x1c, 0x76, 0x7f, 0x88, 0xdf, 0xcb, 0xdb, 0x81, 0x63, 0xd2, 0x7e, - 0xb2, 0x54, 0x97, 0x1b, 0x89, 0x65, 0xc3, 0x99, 0x7c, 0x79, 0x89, 0xf5, 0xc3, 0x7f, 0x2b, 0xb0, - 0x98, 0x45, 0x70, 0xc8, 0x63, 0x8e, 0x0f, 0x72, 0x2e, 0x52, 0xbf, 0x3a, 0xaa, 0x42, 0x9f, 0xca, - 0xb1, 0xd0, 0x26, 0xbb, 0x86, 0x39, 0xba, 0x4f, 0x8a, 0xe3, 0xf5, 0xc9, 0xcf, 0x0a, 0xb1, 0xa3, - 0xbc, 0x21, 0x57, 0x25, 0x3f, 0xc6, 0xfe, 0xf9, 0x6a, 0xe2, 0xa6, 0xe4, 0x4b, 0x99, 0x8c, 0x23, - 0x2e, 0x4a, 0x6a, 0x59, 0xdb, 0x42, 0x57, 0x47, 0x49, 0xfa, 0xdc, 0xde, 0x93, 0xfc, 0x9d, 0x02, - 0xcc, 0xc9, 0x1d, 0x82, 0xde, 0xc9, 0xb8, 0x26, 0x79, 0x7a, 0x44, 0x03, 0xa5, 0x5b, 0x92, 0xfc, - 0x5a, 0x62, 0x61, 0xfc, 0x6b, 0x89, 0xc5, 0xf1, 0xae, 0x25, 0xde, 0x85, 0xb9, 0xa7, 0x9e, 0x15, - 0x18, 0x8f, 0x7a, 0x58, 0xef, 0x19, 0xfb, 0xd8, 0xcb, 0x9a, 0x61, 0x93, 0xae, 0xa8, 0x2a, 0x58, - 0x1e, 0x12, 0x0e, 0xba, 0x60, 0x7e, 0x6a, 0xb8, 0x7c, 0xdd, 0x2d, 0x85, 0xf2, 0xed, 0xa7, 0x86, - 0xcb, 0x78, 0x28, 0x89, 0xfa, 0x8d, 0x02, 0x1c, 0xcd, 0xbc, 0x4c, 0xf7, 0xf1, 0x55, 0x74, 0x29, - 0xae, 0xa2, 0x83, 0xdc, 0x50, 0x2c, 0x1e, 0xe8, 0x86, 0x62, 0x33, 0x47, 0x61, 0x59, 0x58, 0x91, - 0xe1, 0x7a, 0x53, 0xff, 0x5a, 0x81, 0xb2, 0xa8, 0xd4, 0xc8, 0xfb, 0x82, 0xcb, 0x03, 0x42, 0xa6, - 0xd3, 0x3b, 0x1d, 0xb6, 0x61, 0x3b, 0xba, 0x8f, 0x49, 0x2c, 0x3d, 0xf2, 0x76, 0xd6, 0x22, 0xe5, - 0x5b, 0x75, 0x3c, 0xbc, 0x69, 0xd8, 0x4e, 0x9b, 0x31, 0xa1, 0x06, 0xd4, 0x98, 0x3c, 0x2a, 0x8a, - 0x08, 0x1d, 0x39, 0x51, 0xce, 0x51, 0x06, 0x22, 0x84, 0x08, 0xf3, 0xd5, 0xbf, 0x53, 0x60, 0x3e, - 0xa1, 0xd9, 0x5f, 0xbc, 0x46, 0x7c, 0xa7, 0x08, 0x33, 0xb1, 0x5e, 0x1e, 0xd1, 0x80, 0x55, 0x58, - 0x10, 0x78, 0x2f, 0x1f, 0x07, 0xe3, 0xdd, 0x8e, 0x9b, 0xe7, 0x1c, 0x6d, 0x1c, 0xb0, 0x38, 0xea, - 0x0e, 0xcc, 0x1b, 0x4f, 0x0c, 0xab, 0x47, 0x2d, 0x68, 0xac, 0x10, 0x65, 0x2e, 0xa4, 0x0f, 0x23, - 0x31, 0xd6, 0xee, 0xb1, 0xee, 0xc8, 0x01, 0xa5, 0x8d, 0xae, 0x2a, 0xfa, 0x7e, 0x0c, 0xf1, 0x38, - 0xf4, 0xaa, 0xa2, 0xef, 0x87, 0xe5, 0xd1, 0x0b, 0x2d, 0xf4, 0x8e, 0xa6, 0xcf, 0x1f, 0xf6, 0xc9, - 0x2f, 0x8f, 0xd0, 0xde, 0xa3, 0xa4, 0x44, 0x61, 0x7d, 0xe3, 0x43, 0xc7, 0xd3, 0xe3, 0xfc, 0xd3, - 0x23, 0x14, 0x46, 0x39, 0x5a, 0xa1, 0x10, 0xf5, 0x2f, 0x15, 0xa8, 0x84, 0x7e, 0x64, 0x44, 0x0f, - 0x35, 0x61, 0x91, 0xde, 0xfe, 0x49, 0x6a, 0x78, 0x44, 0x27, 0x21, 0xc2, 0xd4, 0x90, 0xb5, 0xdc, - 0x80, 0x1a, 0x15, 0x15, 0x57, 0xf5, 0xa8, 0x8e, 0xf2, 0x45, 0x35, 0x59, 0x40, 0xf9, 0x37, 0x05, - 0x40, 0x69, 0x57, 0xf2, 0x0b, 0x63, 0x64, 0xf1, 0x4e, 0x2b, 0x8d, 0xdf, 0xe9, 0xf7, 0xe1, 0x48, - 0xc7, 0xe9, 0xf7, 0x2d, 0x7a, 0x73, 0xcc, 0xf1, 0xf6, 0xc7, 0x33, 0xb7, 0x05, 0xc6, 0xc3, 0xf4, - 0xc4, 0xd4, 0xf7, 0x36, 0x1c, 0xd3, 0xb0, 0xe3, 0x62, 0x3b, 0x74, 0xfd, 0x0f, 0x9d, 0xee, 0x01, - 0xe2, 0xdb, 0x13, 0x50, 0xcf, 0xe2, 0xe7, 0xfb, 0x27, 0x03, 0xa8, 0xaf, 0xee, 0xe1, 0xce, 0x63, - 0xba, 0xfc, 0x3a, 0x0c, 0x66, 0xab, 0x0e, 0xe5, 0x9e, 0xd3, 0x61, 0x8f, 0x41, 0xf3, 0x2d, 0x46, - 0xf1, 0x3d, 0xe4, 0x74, 0xe7, 0x24, 0x1c, 0xcf, 0x2c, 0x96, 0xd7, 0x0a, 0x41, 0xed, 0x3e, 0x0e, - 0xd6, 0x9f, 0x60, 0x3b, 0x0c, 0x9f, 0xd5, 0x1f, 0x16, 0x62, 0x81, 0x3a, 0xcd, 0x3a, 0x00, 0xd6, - 0x0d, 0xb5, 0x20, 0x5a, 0x39, 0xe8, 0x98, 0x70, 0xb3, 0x37, 0x4b, 0xd9, 0x8b, 0xc2, 0xd9, 0x87, - 0xdd, 0xb4, 0x10, 0xfa, 0x54, 0x69, 0xf4, 0x1a, 0x53, 0x98, 0x96, 0x80, 0x40, 0x14, 0x93, 0x10, - 0x88, 0x77, 0x01, 0xc5, 0x43, 0x71, 0xbe, 0xdd, 0x50, 0x1a, 0xe3, 0x01, 0xaa, 0x9a, 0x9b, 0x7c, - 0x2a, 0x2d, 0xe7, 0x19, 0xa9, 0xc9, 0x43, 0x3d, 0x23, 0xa5, 0x9e, 0x82, 0x13, 0x24, 0xc0, 0xde, - 0xc0, 0x81, 0x67, 0x75, 0xd6, 0xb0, 0xdf, 0xf1, 0x2c, 0x37, 0x70, 0x42, 0xf8, 0x95, 0xaa, 0xc3, - 0xc9, 0x9c, 0x7c, 0xae, 0xee, 0xb7, 0x61, 0xc6, 0x8c, 0x92, 0xb3, 0x76, 0xbc, 0x92, 0xbc, 0x5a, - 0x9c, 0x41, 0x7d, 0x1f, 0x6a, 0x49, 0x82, 0xcc, 0x9d, 0x24, 0x04, 0xa5, 0x3d, 0xdc, 0x73, 0xc5, - 0x55, 0x3f, 0xf2, 0x9b, 0x68, 0x9d, 0xad, 0x5d, 0x1e, 0xe3, 0x7d, 0x71, 0x22, 0x52, 0xa1, 0x29, - 0x5f, 0xc0, 0xfb, 0x61, 0xdb, 0xa4, 0x77, 0x4d, 0x3c, 0xab, 0x93, 0x6c, 0x5b, 0x46, 0x7e, 0xd4, - 0x36, 0xd2, 0x6d, 0x7d, 0x96, 0xcc, 0xdb, 0x76, 0x32, 0xf7, 0xcd, 0x14, 0xca, 0x0b, 0xae, 0x63, - 0xf2, 0xdf, 0xea, 0x77, 0x15, 0x58, 0x48, 0x51, 0x8c, 0x79, 0xca, 0xf5, 0x32, 0x4c, 0x8b, 0x72, - 0x0b, 0x69, 0x48, 0x33, 0x93, 0xa5, 0x09, 0x12, 0xd4, 0x84, 0x85, 0xc8, 0xa2, 0x05, 0x5f, 0x31, - 0xdd, 0x17, 0xf1, 0x85, 0x0b, 0xad, 0x6e, 0xad, 0x93, 0x48, 0x51, 0x3b, 0x50, 0x4b, 0x52, 0x8d, - 0x33, 0xa6, 0x0e, 0x54, 0x5f, 0xf5, 0x07, 0x0a, 0x4c, 0xb1, 0xb4, 0xcc, 0xce, 0x96, 0xa6, 0x83, - 0x42, 0x72, 0x3a, 0x78, 0x03, 0x66, 0x98, 0x1c, 0x3d, 0xbc, 0xe8, 0x39, 0x27, 0x6f, 0xf4, 0x33, - 0xd1, 0x74, 0xb4, 0x42, 0x3f, 0xfc, 0x4d, 0x9a, 0xc1, 0xec, 0x85, 0xae, 0x4c, 0x04, 0x70, 0x7d, - 0x86, 0xa6, 0x51, 0x97, 0x4b, 0x42, 0x66, 0xbe, 0x86, 0x19, 0xe1, 0x9b, 0xf9, 0xd6, 0xd6, 0x12, - 0x7d, 0xa5, 0x33, 0xb5, 0xd5, 0xad, 0x6e, 0xd3, 0x67, 0x34, 0xd3, 0x5b, 0xd4, 0xe8, 0x4d, 0x19, - 0xe8, 0xf0, 0x7c, 0x0a, 0x6b, 0x20, 0xb1, 0x0d, 0x3c, 0xf6, 0x68, 0x3e, 0xc7, 0x3b, 0x7c, 0x00, - 0xc7, 0x72, 0x69, 0xd0, 0x5b, 0xe1, 0x9b, 0xc5, 0xa6, 0x67, 0x3d, 0xe1, 0x1b, 0x0b, 0x73, 0xf2, - 0xfb, 0x28, 0xab, 0x94, 0x60, 0x8d, 0xe6, 0x8b, 0xd7, 0x8c, 0xd9, 0x97, 0xfa, 0x4f, 0x8a, 0x38, - 0xe9, 0x97, 0x9e, 0xa4, 0x92, 0xc1, 0x14, 0xe3, 0x99, 0x6e, 0xfc, 0xe9, 0xe1, 0xc2, 0xc7, 0x7e, - 0x7a, 0xb8, 0x78, 0x98, 0x9b, 0x73, 0xea, 0x39, 0x38, 0x3b, 0xa4, 0x35, 0xac, 0x33, 0x2e, 0xbe, - 0x00, 0x65, 0xf1, 0x4f, 0x1c, 0xd0, 0x34, 0x14, 0xb7, 0x57, 0x5b, 0xb5, 0x09, 0xf2, 0x63, 0x67, - 0xad, 0x55, 0x53, 0x50, 0x19, 0x4a, 0xed, 0xd5, 0xed, 0x56, 0xad, 0x70, 0xb1, 0x0f, 0xb5, 0xe4, - 0xff, 0x31, 0x40, 0xcb, 0x70, 0xa4, 0xa5, 0x6d, 0xb5, 0x1a, 0xf7, 0x1b, 0xdb, 0xcd, 0xad, 0x4d, - 0xbd, 0xa5, 0x35, 0xdf, 0x6b, 0x6c, 0xaf, 0xd7, 0x26, 0xd0, 0x59, 0x38, 0x19, 0xcf, 0x78, 0xb0, - 0xd5, 0xde, 0xd6, 0xb7, 0xb7, 0xf4, 0xd5, 0xad, 0xcd, 0xed, 0x46, 0x73, 0x73, 0x5d, 0xab, 0x29, - 0xe8, 0x24, 0x1c, 0x8b, 0x93, 0xdc, 0x6d, 0xae, 0x35, 0xb5, 0xf5, 0x55, 0xf2, 0xbb, 0xf1, 0xb0, - 0x56, 0xb8, 0xf8, 0x16, 0x54, 0xa5, 0xfb, 0x6f, 0xa4, 0x4a, 0xad, 0xad, 0xb5, 0xda, 0x04, 0xaa, - 0x42, 0x25, 0x2e, 0xa7, 0x0c, 0xa5, 0xcd, 0xad, 0xb5, 0xf5, 0x5a, 0x01, 0x01, 0x4c, 0x6d, 0x37, - 0xb4, 0xfb, 0xeb, 0xdb, 0xb5, 0xe2, 0xc5, 0x57, 0x60, 0x25, 0xef, 0x1e, 0x28, 0xaa, 0xc0, 0xe4, - 0x06, 0xf6, 0xba, 0xb8, 0x36, 0x41, 0x58, 0xda, 0x64, 0x64, 0x04, 0x35, 0xe5, 0xe2, 0xad, 0xe4, - 0x33, 0x46, 0x18, 0x2d, 0x40, 0xb5, 0xdd, 0xd8, 0x5c, 0xbb, 0xbb, 0xf5, 0x65, 0x5d, 0x5b, 0x6f, - 0xac, 0xbd, 0x5f, 0x9b, 0x40, 0x8b, 0x50, 0x13, 0x49, 0x9b, 0x5b, 0xdb, 0x2c, 0x55, 0xb9, 0xf8, - 0x38, 0xb1, 0xb4, 0xc7, 0xe8, 0x28, 0x2c, 0x84, 0xb5, 0xd4, 0x57, 0xb5, 0xf5, 0xc6, 0xf6, 0x3a, - 0xa9, 0xbc, 0x94, 0xac, 0xed, 0x6c, 0x6e, 0x36, 0x37, 0xef, 0xd7, 0x14, 0x22, 0x35, 0x4a, 0x5e, - 0xff, 0x72, 0x93, 0x10, 0x17, 0x64, 0xe2, 0x9d, 0xcd, 0x2f, 0x6c, 0x6e, 0x7d, 0x69, 0xb3, 0x56, - 0xbc, 0xf8, 0xeb, 0x71, 0x2c, 0x53, 0x34, 0xfd, 0x1e, 0x87, 0xe5, 0x54, 0x89, 0xfa, 0xfa, 0x7b, - 0xeb, 0x9b, 0xdb, 0xb5, 0x09, 0x39, 0xb3, 0xbd, 0xdd, 0xd0, 0xa2, 0x4c, 0x25, 0x99, 0xb9, 0xd5, - 0x6a, 0x85, 0x99, 0x05, 0x39, 0x73, 0x6d, 0xfd, 0xe1, 0x7a, 0xc4, 0x59, 0xbc, 0xf8, 0x1c, 0x40, - 0xe4, 0x66, 0xd0, 0x0c, 0x4c, 0xaf, 0x6e, 0xed, 0x6c, 0x6e, 0xaf, 0x6b, 0xb5, 0x09, 0xa2, 0xe5, - 0xfb, 0x8d, 0x9d, 0xfb, 0xeb, 0x35, 0xe5, 0xe2, 0x05, 0x98, 0x8d, 0x0f, 0x3a, 0x42, 0xd7, 0x7e, - 0xbf, 0xbd, 0xbd, 0xbe, 0x41, 0x34, 0x32, 0x0b, 0xe5, 0xd5, 0xfb, 0xda, 0xd6, 0x4e, 0xeb, 0x5e, - 0xbb, 0xa6, 0x5c, 0xfb, 0xdf, 0xa3, 0xe1, 0x91, 0x4a, 0x1b, 0x7b, 0xf4, 0x2e, 0xd0, 0x1a, 0x4c, - 0x8b, 0xff, 0x94, 0x22, 0x6d, 0x6e, 0xc9, 0xff, 0xd9, 0xa5, 0x7e, 0x3c, 0x33, 0x8f, 0x87, 0x4f, - 0x13, 0xe8, 0x3d, 0x7a, 0x48, 0x15, 0x7b, 0x44, 0xf0, 0x4c, 0xe2, 0xac, 0x20, 0xf5, 0x56, 0x61, - 0xfd, 0xec, 0x10, 0x8a, 0x50, 0xee, 0xfb, 0x30, 0x27, 0xbf, 0xd6, 0x8b, 0xce, 0xca, 0x27, 0x21, - 0x19, 0x0f, 0x01, 0xd7, 0xd5, 0x61, 0x24, 0xa1, 0x68, 0x1d, 0x6a, 0xc9, 0xd7, 0x7a, 0x91, 0xe4, - 0x02, 0x72, 0x1e, 0x03, 0xae, 0x3f, 0x37, 0x9c, 0x28, 0x5e, 0x40, 0xea, 0x11, 0xda, 0x73, 0xc3, - 0x9f, 0xf5, 0xcc, 0x28, 0x20, 0xef, 0xed, 0x4f, 0xa6, 0x1c, 0x39, 0xb8, 0x40, 0x89, 0x77, 0x5f, - 0x33, 0x9e, 0x88, 0x94, 0x95, 0x93, 0xfd, 0x3c, 0xa0, 0x3a, 0x81, 0x7e, 0x09, 0xe6, 0x13, 0x17, - 0x3d, 0x90, 0xc4, 0x98, 0x7d, 0x7f, 0xa5, 0x7e, 0x6e, 0x28, 0x8d, 0xdc, 0xab, 0xf1, 0xcb, 0x1c, - 0xc9, 0x5e, 0xcd, 0xb8, 0x24, 0x92, 0xec, 0xd5, 0xcc, 0xbb, 0x20, 0xd4, 0x10, 0xa5, 0x8b, 0x1b, - 0xb2, 0x21, 0x66, 0x5d, 0x14, 0xa9, 0x9f, 0x1d, 0x42, 0x11, 0x57, 0x48, 0xe2, 0xea, 0x86, 0xac, - 0x90, 0xec, 0x4b, 0x21, 0xf5, 0x73, 0x43, 0x69, 0x92, 0x3d, 0x19, 0xe1, 0xc2, 0xd3, 0x3d, 0x99, - 0xba, 0xb6, 0x90, 0xee, 0xc9, 0x34, 0xac, 0x9c, 0xf7, 0x64, 0x02, 0xc9, 0xad, 0x0e, 0xc5, 0x86, - 0x66, 0xf5, 0x64, 0x36, 0x7e, 0x54, 0x9d, 0x40, 0x4f, 0x61, 0x25, 0x0f, 0xbb, 0x87, 0x5e, 0x3a, - 0x00, 0xc4, 0xb0, 0xfe, 0xf2, 0x78, 0xc4, 0x61, 0xc1, 0x18, 0x50, 0x7a, 0x95, 0x89, 0x9e, 0x97, - 0xd5, 0x9d, 0xb3, 0x8a, 0xad, 0xbf, 0x30, 0x8a, 0x2c, 0x2c, 0xe6, 0x3e, 0x94, 0x05, 0x2a, 0x10, - 0x49, 0x2e, 0x30, 0x81, 0x46, 0xac, 0x9f, 0xc8, 0xce, 0x0c, 0x05, 0xbd, 0x09, 0x25, 0x92, 0x8a, - 0x96, 0x93, 0x74, 0x42, 0xc0, 0x4a, 0x3a, 0x23, 0x64, 0x6e, 0xc0, 0x14, 0x83, 0xbb, 0x21, 0xe9, - 0xe0, 0x58, 0x82, 0xe3, 0xd5, 0xeb, 0x59, 0x59, 0xa1, 0x88, 0x16, 0xfb, 0xbf, 0x53, 0x1c, 0xbd, - 0x86, 0x4e, 0x25, 0xdf, 0xe9, 0x97, 0x61, 0x72, 0xf5, 0xd3, 0xb9, 0xf9, 0x71, 0x9b, 0x4d, 0x6c, - 0x26, 0x9f, 0x1d, 0x72, 0x38, 0x92, 0x65, 0xb3, 0xd9, 0x47, 0x2e, 0xac, 0x73, 0xd3, 0x47, 0x32, - 0xe8, 0xf9, 0x5c, 0x7b, 0x97, 0x8a, 0x78, 0x61, 0x14, 0x59, 0x7c, 0x68, 0x24, 0x1f, 0xdc, 0x53, - 0x87, 0x3d, 0x86, 0x99, 0x35, 0x34, 0x72, 0x1e, 0xd9, 0x54, 0x27, 0xd0, 0x1e, 0x1c, 0xc9, 0x78, - 0x85, 0x13, 0xbd, 0x90, 0xef, 0x7f, 0xa5, 0x52, 0x5e, 0x1c, 0x49, 0x17, 0x2f, 0x29, 0x03, 0xb2, - 0x22, 0x97, 0x94, 0x8f, 0x99, 0x91, 0x4b, 0x1a, 0x86, 0x7d, 0xa1, 0x86, 0xc8, 0x7d, 0xc8, 0xb1, - 0x2c, 0x40, 0x42, 0x86, 0x21, 0xa6, 0x3c, 0xc6, 0x1e, 0x1c, 0xc9, 0xd8, 0x89, 0x91, 0x2b, 0x9b, - 0xbf, 0x43, 0x24, 0x57, 0x76, 0xd8, 0x96, 0xce, 0x04, 0xfa, 0x00, 0xd0, 0x7d, 0x1c, 0xc8, 0xa1, - 0x9c, 0x8f, 0xa4, 0x81, 0x9a, 0xdc, 0xf4, 0xc9, 0xb1, 0x4f, 0x69, 0xf7, 0x47, 0x9d, 0xb8, 0xaa, - 0x20, 0x9b, 0xdd, 0x25, 0x4b, 0xed, 0x59, 0xa0, 0xf3, 0xc9, 0x6e, 0xcb, 0xdb, 0xf6, 0xa8, 0x5f, - 0x18, 0x83, 0x32, 0x6c, 0x8b, 0x9d, 0x7c, 0xf1, 0x59, 0x2c, 0x9b, 0xcf, 0xe7, 0x9b, 0x89, 0xbc, - 0x15, 0x91, 0x2e, 0x2f, 0x77, 0x53, 0x22, 0x8c, 0xe7, 0x62, 0xc6, 0x74, 0x26, 0x1f, 0x40, 0x95, - 0x13, 0xcf, 0x65, 0x1a, 0xd0, 0xd7, 0xe1, 0x58, 0xee, 0x9a, 0x09, 0x65, 0xcc, 0x01, 0xf9, 0x0b, - 0xc5, 0xfa, 0xa5, 0x31, 0xa9, 0x45, 0xd9, 0xd7, 0x7e, 0xbf, 0x08, 0xb3, 0x0c, 0xe4, 0xc6, 0x43, - 0xdf, 0x0d, 0x80, 0x08, 0x2f, 0x8a, 0x4e, 0x26, 0xf5, 0x23, 0x81, 0x70, 0xeb, 0xa7, 0xf2, 0xb2, - 0xe3, 0x2e, 0x36, 0x86, 0xc3, 0x94, 0x5d, 0x6c, 0x1a, 0x56, 0x2a, 0xbb, 0xd8, 0x0c, 0x00, 0xa7, - 0x3a, 0x81, 0xde, 0x85, 0x4a, 0x08, 0xfb, 0x93, 0x0d, 0x37, 0x89, 0x5f, 0xac, 0x9f, 0xcc, 0xc9, - 0x8d, 0xd7, 0x2e, 0x86, 0xe6, 0x93, 0x6b, 0x97, 0x46, 0x0a, 0xca, 0xb5, 0xcb, 0x82, 0x01, 0x46, - 0xed, 0x65, 0xb8, 0x8d, 0x8c, 0xf6, 0x4a, 0x38, 0x9e, 0x8c, 0xf6, 0xca, 0x80, 0x0f, 0x75, 0xe2, - 0xee, 0x9d, 0x1f, 0xfd, 0xf4, 0x94, 0xf2, 0xe3, 0x9f, 0x9e, 0x9a, 0xf8, 0xd5, 0x8f, 0x4e, 0x29, - 0x3f, 0xfa, 0xe8, 0x94, 0xf2, 0x2f, 0x1f, 0x9d, 0x52, 0x7e, 0xf2, 0xd1, 0x29, 0xe5, 0x9b, 0xff, - 0x71, 0x6a, 0xe2, 0x03, 0xf5, 0xf1, 0x0d, 0xff, 0xb2, 0xe5, 0x5c, 0xe9, 0x78, 0xd6, 0x25, 0xc3, - 0xb5, 0xae, 0xb8, 0x8f, 0xbb, 0x57, 0x0c, 0xd7, 0xf2, 0xaf, 0x70, 0xb9, 0x57, 0x9e, 0xbc, 0xf2, - 0x68, 0x8a, 0xfe, 0x9f, 0xc4, 0x57, 0xff, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x4c, 0xbb, 0xd2, 0x3f, - 0xe1, 0x72, 0x00, 0x00, + // 7391 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x7d, 0x5d, 0x6c, 0x24, 0xc7, + 0x75, 0x2e, 0x7b, 0x66, 0x48, 0xce, 0x1c, 0x72, 0xc8, 0x61, 0x2d, 0x97, 0xe4, 0xce, 0xfe, 0xf7, + 0x4a, 0xda, 0x1f, 0x69, 0x7f, 0xb5, 0x5a, 0xed, 0xae, 0x56, 0xd2, 0xce, 0x92, 0xdc, 0x5d, 0xca, + 0x4b, 0x72, 0xdc, 0x43, 0xca, 0x96, 0x6c, 0xb8, 0x6f, 0xef, 0x74, 0x71, 0xd8, 0xda, 0x99, 0xee, + 0x76, 0x77, 0x0f, 0x77, 0xe9, 0x87, 0x8b, 0xfb, 0x74, 0x71, 0xaf, 0x9f, 0xfc, 0x70, 0x8d, 0x0b, + 0x18, 0x41, 0x82, 0x04, 0xc8, 0xcf, 0x5b, 0x12, 0x03, 0x71, 0x1c, 0x20, 0x48, 0x80, 0x20, 0x36, + 0xec, 0x20, 0x01, 0xf2, 0x90, 0x00, 0x7e, 0x8b, 0x2d, 0x07, 0x08, 0x90, 0x67, 0x3f, 0x04, 0x79, + 0x71, 0x50, 0x7f, 0xdd, 0x5d, 0xfd, 0x33, 0x33, 0xa4, 0x14, 0x49, 0x7e, 0xe2, 0x74, 0xd5, 0x39, + 0xa7, 0xaa, 0x4e, 0x9d, 0x3a, 0x75, 0xaa, 0xea, 0xab, 0x22, 0x54, 0x0c, 0xd7, 0xba, 0xe2, 0x7a, + 0x4e, 0xe0, 0x20, 0xf0, 0xfa, 0x76, 0x60, 0xf5, 0xf0, 0x95, 0xbd, 0xeb, 0xf5, 0xcb, 0x1d, 0x2b, + 0xd8, 0xed, 0x3f, 0xbd, 0xd2, 0x76, 0x7a, 0x57, 0x3b, 0x4e, 0xc7, 0xb9, 0x4a, 0x49, 0x9e, 0xf6, + 0x77, 0xe8, 0x17, 0xfd, 0xa0, 0xbf, 0x18, 0xab, 0x7a, 0x09, 0x66, 0xde, 0xc7, 0x9e, 0x6f, 0x39, + 0xb6, 0x86, 0xbf, 0xd9, 0xc7, 0x7e, 0x80, 0x96, 0x60, 0x72, 0x8f, 0xa5, 0x2c, 0x29, 0x67, 0x94, + 0x0b, 0x15, 0x4d, 0x7c, 0xaa, 0x7f, 0xa8, 0xc0, 0x6c, 0x48, 0xec, 0xbb, 0x8e, 0xed, 0xe3, 0x7c, + 0x6a, 0x74, 0x16, 0xa6, 0x79, 0xb5, 0x74, 0xdb, 0xe8, 0xe1, 0xa5, 0x02, 0xcd, 0x9e, 0xe2, 0x69, + 0x1b, 0x46, 0x0f, 0xa3, 0xf3, 0x30, 0x2b, 0x48, 0x84, 0x90, 0x22, 0xa5, 0x9a, 0xe1, 0xc9, 0xbc, + 0x34, 0x74, 0x05, 0x8e, 0x08, 0x42, 0xc3, 0xb5, 0x42, 0xe2, 0x12, 0x25, 0x9e, 0xe3, 0x59, 0x0d, + 0xd7, 0xe2, 0xf4, 0xea, 0xd7, 0xa0, 0xb2, 0xb2, 0xd1, 0x5a, 0x76, 0xec, 0x1d, 0xab, 0x43, 0xaa, + 0xe8, 0x63, 0x8f, 0xf0, 0x2c, 0x29, 0x67, 0x8a, 0xa4, 0x8a, 0xfc, 0x13, 0xd5, 0xa1, 0xec, 0x63, + 0xc3, 0x6b, 0xef, 0x62, 0x7f, 0xa9, 0x40, 0xb3, 0xc2, 0x6f, 0xc2, 0xe5, 0xb8, 0x81, 0xe5, 0xd8, + 0xfe, 0x52, 0x91, 0x71, 0xf1, 0x4f, 0xf5, 0xb7, 0x14, 0x98, 0x6a, 0x3a, 0x5e, 0xb0, 0x6e, 0xb8, + 0xae, 0x65, 0x77, 0xd0, 0x35, 0x28, 0x53, 0x5d, 0xb6, 0x9d, 0x2e, 0xd5, 0xc1, 0xcc, 0x8d, 0xf9, + 0x2b, 0x51, 0x87, 0x5c, 0x69, 0xf2, 0x3c, 0x2d, 0xa4, 0x42, 0x2f, 0xc3, 0x4c, 0xdb, 0xb1, 0x03, + 0xc3, 0xb2, 0xb1, 0xa7, 0xbb, 0x8e, 0x17, 0x50, 0xe5, 0x8c, 0x6b, 0xd5, 0x30, 0x95, 0xc8, 0x47, + 0xc7, 0xa1, 0xb2, 0xeb, 0xf8, 0x01, 0xa3, 0x28, 0x52, 0x8a, 0x32, 0x49, 0xa0, 0x99, 0x8b, 0x30, + 0x49, 0x33, 0x2d, 0x97, 0xab, 0x61, 0x82, 0x7c, 0xae, 0xb9, 0xea, 0x8f, 0x8a, 0x30, 0xbe, 0xee, + 0xf4, 0xed, 0x20, 0x51, 0x8c, 0x11, 0xec, 0xf2, 0x2e, 0x8a, 0x15, 0x63, 0x04, 0xbb, 0x51, 0x31, + 0x84, 0x82, 0xf5, 0x12, 0x2b, 0x86, 0x64, 0xd6, 0xa1, 0xec, 0x61, 0xc3, 0x74, 0xec, 0xee, 0x3e, + 0xad, 0x42, 0x59, 0x0b, 0xbf, 0x49, 0xf7, 0xf9, 0xb8, 0x6b, 0xd9, 0xfd, 0x17, 0xba, 0x87, 0xbb, + 0xc6, 0x53, 0xdc, 0xa5, 0x55, 0x29, 0x6b, 0x33, 0x3c, 0x59, 0x63, 0xa9, 0xe8, 0x1d, 0x98, 0x72, + 0x3d, 0xc7, 0x35, 0x3a, 0x06, 0xd1, 0xe0, 0xd2, 0x38, 0x55, 0xd2, 0x89, 0xb8, 0x92, 0x68, 0x85, + 0x9b, 0x11, 0x8d, 0x16, 0x67, 0x40, 0x6f, 0xc2, 0x54, 0xdf, 0x32, 0xb9, 0xbe, 0xfd, 0xa5, 0x89, + 0x33, 0xc5, 0x0b, 0x53, 0x37, 0x8e, 0xc6, 0xf9, 0xd7, 0x56, 0x78, 0xae, 0x16, 0xa7, 0x24, 0x8c, + 0x9d, 0x18, 0xe3, 0xe4, 0x40, 0xc6, 0x18, 0x25, 0x35, 0x38, 0xdc, 0xee, 0x7b, 0xbe, 0xb5, 0x87, + 0x75, 0xd2, 0x60, 0x9d, 0x6a, 0xa0, 0x4c, 0x9b, 0x37, 0x17, 0x66, 0x69, 0xd8, 0x30, 0x37, 0x89, + 0x2a, 0x5e, 0x85, 0x71, 0xab, 0x67, 0x74, 0xf0, 0x52, 0xe5, 0x8c, 0x92, 0x2a, 0x82, 0x64, 0xb4, + 0x5c, 0xdc, 0xd6, 0x18, 0x0d, 0x7a, 0x09, 0x66, 0xe8, 0x0f, 0xdd, 0xef, 0x3f, 0x65, 0x5a, 0x07, + 0xaa, 0xf5, 0x69, 0x9a, 0xda, 0xea, 0x3f, 0x25, 0x9a, 0x57, 0x75, 0xa8, 0x84, 0x95, 0x8b, 0x7a, + 0xdb, 0xa4, 0x7d, 0x58, 0xe5, 0xbd, 0x6d, 0x92, 0x51, 0x16, 0xf5, 0xb1, 0x65, 0xd2, 0xfe, 0xab, + 0x6a, 0x53, 0x61, 0xda, 0x9a, 0x89, 0x16, 0x60, 0xa2, 0x8b, 0xed, 0x4e, 0xb0, 0x4b, 0x3b, 0xb0, + 0xaa, 0xf1, 0x2f, 0xf5, 0xff, 0x29, 0x50, 0xdd, 0xf6, 0xb1, 0x47, 0x86, 0xa2, 0xef, 0x1a, 0x6d, + 0x8c, 0x2e, 0x43, 0xa9, 0xe7, 0x98, 0x98, 0x5b, 0xf1, 0xb1, 0x78, 0x23, 0x42, 0xa2, 0x75, 0xc7, + 0xc4, 0x1a, 0x25, 0x43, 0x17, 0xa1, 0xd4, 0xb7, 0x4c, 0x36, 0x74, 0x72, 0xd5, 0x4a, 0x49, 0x08, + 0x69, 0x87, 0x90, 0x16, 0x07, 0x92, 0x12, 0x12, 0xf5, 0xd7, 0x0a, 0xcc, 0x86, 0xa5, 0x6d, 0xd2, + 0x31, 0x87, 0x5e, 0x87, 0x49, 0x1b, 0x07, 0xcf, 0x1d, 0xef, 0xd9, 0xf0, 0xba, 0x09, 0x4a, 0xf4, + 0x2a, 0x14, 0x5d, 0xae, 0x91, 0x81, 0x0c, 0x84, 0x8a, 0x10, 0x5b, 0x6e, 0x9b, 0x6a, 0x68, 0x30, + 0xb1, 0xe5, 0xb6, 0xc9, 0x88, 0x09, 0x0c, 0xaf, 0x83, 0x69, 0x7f, 0xb0, 0xd1, 0x57, 0x66, 0x09, + 0x6b, 0x26, 0xba, 0x0f, 0x33, 0x7d, 0x1f, 0x7b, 0xb6, 0xaf, 0x0b, 0xff, 0x31, 0x4e, 0x6d, 0x42, + 0x12, 0x2a, 0xe9, 0x5d, 0xab, 0x32, 0x86, 0x4d, 0xee, 0x60, 0x54, 0x80, 0x35, 0x3b, 0xb8, 0x75, + 0xf3, 0x7d, 0xa3, 0xdb, 0xc7, 0x68, 0x1e, 0xc6, 0xf7, 0xc8, 0x0f, 0xda, 0xf2, 0xa2, 0xc6, 0x3e, + 0xd4, 0xdf, 0x1d, 0x87, 0xe3, 0x4f, 0xc8, 0x18, 0x6b, 0x19, 0xb6, 0xf9, 0xd4, 0x79, 0xd1, 0x22, + 0x26, 0x69, 0x05, 0xfb, 0xcb, 0x8e, 0x1d, 0xe0, 0x17, 0x01, 0x7a, 0x0c, 0x73, 0xb6, 0x90, 0x1f, + 0x56, 0x44, 0xa1, 0x15, 0x39, 0x9e, 0xd9, 0x3a, 0x56, 0xb8, 0x56, 0xb3, 0xe5, 0x04, 0x1f, 0x3d, + 0x88, 0x46, 0xb9, 0x90, 0x53, 0x48, 0x37, 0xa8, 0xb5, 0x4a, 0x6b, 0xc3, 0xa5, 0x08, 0x07, 0x20, + 0x64, 0xdc, 0x02, 0xe2, 0xf7, 0x75, 0xc3, 0xd7, 0x49, 0x4b, 0xa9, 0x96, 0xa7, 0x6e, 0x2c, 0x48, + 0x56, 0x10, 0x36, 0x58, 0xab, 0x78, 0x7d, 0xbb, 0xe1, 0x13, 0x0d, 0xa1, 0xdb, 0x74, 0x0e, 0x21, + 0x7c, 0x1d, 0xcf, 0xe9, 0xbb, 0x74, 0xfc, 0xe5, 0x33, 0x02, 0x65, 0x7c, 0x44, 0x28, 0xe9, 0xd4, + 0xc2, 0xfd, 0x94, 0xee, 0x39, 0x4e, 0xb0, 0xe3, 0x0b, 0xdf, 0x24, 0x92, 0x35, 0x9a, 0x8a, 0xae, + 0xc2, 0x11, 0xbf, 0xef, 0xba, 0x5d, 0xdc, 0xc3, 0x76, 0x60, 0x74, 0x59, 0x41, 0xa4, 0xcf, 0x8a, + 0x17, 0x8a, 0x1a, 0x8a, 0x67, 0x51, 0xc1, 0x3e, 0x7a, 0x0a, 0xf5, 0x0c, 0x06, 0xdd, 0x75, 0xba, + 0x56, 0x7b, 0x7f, 0x69, 0x8a, 0x1a, 0xd0, 0x4b, 0x92, 0x6a, 0x52, 0x32, 0x9a, 0x94, 0x56, 0x5b, + 0xf2, 0x73, 0x72, 0xd0, 0x29, 0x00, 0xd7, 0xb3, 0xf6, 0xac, 0x2e, 0xee, 0x60, 0x73, 0x69, 0x82, + 0x56, 0x3c, 0x96, 0x82, 0xde, 0x20, 0x53, 0x5a, 0xbb, 0xed, 0xf4, 0x5c, 0xee, 0x70, 0xa4, 0x3e, + 0x15, 0xb6, 0xd0, 0xf4, 0x9c, 0x1d, 0xab, 0x8b, 0x35, 0x41, 0x8b, 0xde, 0x84, 0xb2, 0xe1, 0xba, + 0x86, 0xd7, 0x73, 0x3c, 0xea, 0x72, 0x86, 0xf0, 0x85, 0xc4, 0xe8, 0x26, 0xcc, 0x73, 0x19, 0xba, + 0xcb, 0x32, 0x99, 0xdf, 0x9a, 0x24, 0xb6, 0xff, 0xa0, 0xb0, 0xa4, 0x68, 0x88, 0xe7, 0x73, 0x5e, + 0xea, 0xc1, 0xfe, 0x56, 0x81, 0xd9, 0x84, 0x4c, 0xf4, 0x1e, 0x4c, 0x0b, 0x09, 0xc1, 0xbe, 0x2b, + 0x5c, 0xcd, 0xf9, 0x01, 0xd5, 0xb8, 0xc2, 0xff, 0x6e, 0xed, 0xbb, 0x98, 0x4e, 0x0b, 0xe2, 0x03, + 0x9d, 0x83, 0x6a, 0xd7, 0x69, 0x1b, 0x5d, 0xea, 0x19, 0x3d, 0xbc, 0xc3, 0x27, 0xaf, 0xe9, 0x30, + 0x51, 0xc3, 0x3b, 0xea, 0x7d, 0x98, 0x8a, 0x09, 0x40, 0x08, 0x66, 0x34, 0x56, 0xd4, 0x0a, 0xde, + 0x31, 0xfa, 0xdd, 0xa0, 0x36, 0x86, 0x66, 0x00, 0xb6, 0xed, 0x36, 0x09, 0x16, 0x6c, 0x6c, 0xd6, + 0x14, 0x54, 0x85, 0xca, 0x13, 0x21, 0xa2, 0x56, 0x50, 0xbf, 0x57, 0x84, 0xa3, 0xd4, 0xb8, 0x9b, + 0x8e, 0xc9, 0x47, 0x1b, 0x8f, 0x2c, 0xce, 0x41, 0xb5, 0x4d, 0xbb, 0x5f, 0x77, 0x0d, 0x0f, 0xdb, + 0x01, 0x9f, 0x5f, 0xa7, 0x59, 0x62, 0x93, 0xa6, 0x21, 0x0d, 0x6a, 0x3e, 0x6f, 0x91, 0xde, 0x66, + 0xa3, 0x93, 0x0f, 0x20, 0xa9, 0xd5, 0x03, 0x06, 0xb3, 0x36, 0xeb, 0xa7, 0x46, 0xf7, 0xa4, 0xbf, + 0xef, 0xb7, 0x83, 0xae, 0xf0, 0xa8, 0x57, 0x52, 0xa2, 0x92, 0x95, 0xbd, 0xd2, 0x62, 0x0c, 0xab, + 0x76, 0xe0, 0xed, 0x6b, 0x82, 0x1d, 0xbd, 0x0b, 0x65, 0x67, 0x0f, 0x7b, 0xbb, 0xd8, 0x60, 0x9e, + 0x6c, 0xea, 0xc6, 0xb9, 0x94, 0xa8, 0x65, 0x31, 0x99, 0x68, 0xd8, 0x77, 0xfa, 0x5e, 0x1b, 0xfb, + 0x5a, 0xc8, 0x84, 0x1a, 0x50, 0xf1, 0x44, 0x32, 0xf7, 0x74, 0x23, 0x49, 0x88, 0xb8, 0xea, 0x77, + 0x61, 0x3a, 0x5e, 0x39, 0x54, 0x83, 0xe2, 0x33, 0xbc, 0xcf, 0x95, 0x49, 0x7e, 0x46, 0x3e, 0x90, + 0xf5, 0x30, 0xfb, 0xb8, 0x5b, 0xb8, 0xad, 0xa8, 0x1e, 0xa0, 0xa8, 0xa5, 0xeb, 0x38, 0x30, 0x4c, + 0x23, 0x30, 0x10, 0x82, 0x12, 0x8d, 0x39, 0x99, 0x08, 0xfa, 0x9b, 0x48, 0xed, 0xf3, 0xe9, 0xa0, + 0xa2, 0x91, 0x9f, 0xe8, 0x04, 0x54, 0x42, 0x6f, 0xc7, 0x03, 0xcf, 0x28, 0x81, 0x04, 0x80, 0x46, + 0x10, 0xe0, 0x9e, 0x1b, 0x50, 0xc5, 0x54, 0x35, 0xf1, 0xa9, 0xfe, 0xdf, 0x71, 0xa8, 0xa5, 0x6c, + 0xe1, 0x2e, 0x94, 0x7b, 0xbc, 0x78, 0xee, 0x67, 0x4f, 0x49, 0x51, 0x60, 0xaa, 0x92, 0x5a, 0x48, + 0x4f, 0x82, 0x2c, 0x62, 0x6b, 0xb1, 0x30, 0x39, 0xfc, 0x66, 0x46, 0xde, 0xd1, 0x4d, 0xcb, 0xc3, + 0xed, 0xc0, 0xf1, 0xf6, 0x79, 0x45, 0xa7, 0xbb, 0x4e, 0x67, 0x45, 0xa4, 0xa1, 0x9b, 0x00, 0xa6, + 0xed, 0xeb, 0xd4, 0x86, 0x3b, 0xbc, 0x1f, 0xa5, 0x49, 0x36, 0x8c, 0x86, 0xb5, 0x8a, 0x69, 0xfb, + 0xbc, 0xca, 0xf7, 0xa0, 0x4a, 0x42, 0x4b, 0xbd, 0x27, 0xe2, 0xa3, 0x71, 0x6a, 0x4b, 0x8b, 0x72, + 0xbd, 0xc3, 0x40, 0x57, 0x9b, 0x76, 0xa3, 0x0f, 0x1f, 0xdd, 0x87, 0x09, 0x1a, 0xdd, 0x89, 0x78, + 0xec, 0x42, 0x76, 0x73, 0xb9, 0xf5, 0x3d, 0xa1, 0xa4, 0xcc, 0xf8, 0x38, 0x1f, 0xda, 0x84, 0x29, + 0xc3, 0xb6, 0x9d, 0xc0, 0x60, 0xb3, 0x0a, 0x8b, 0xce, 0x2e, 0x0f, 0x14, 0xd3, 0x88, 0xe8, 0x99, + 0xac, 0xb8, 0x04, 0xf4, 0x26, 0x8c, 0xd3, 0x69, 0x87, 0xcf, 0x13, 0x67, 0x87, 0x0e, 0x0a, 0x8d, + 0xd1, 0xa3, 0xb7, 0x61, 0xf2, 0xb9, 0x65, 0x9b, 0xce, 0x73, 0x9f, 0xfb, 0x53, 0xc9, 0x84, 0xbf, + 0xc2, 0xb2, 0x52, 0xcc, 0x82, 0xa7, 0x7e, 0x07, 0xa6, 0x62, 0xed, 0x3b, 0x88, 0xfd, 0xd6, 0xdf, + 0x81, 0x5a, 0xb2, 0x4d, 0x07, 0xb2, 0xff, 0x3e, 0xcc, 0x6b, 0x7d, 0x3b, 0xaa, 0x9a, 0x58, 0xc5, + 0xdd, 0x84, 0x09, 0x6e, 0x0d, 0xcc, 0x18, 0x4f, 0x0c, 0x52, 0xab, 0xc6, 0x69, 0xe3, 0x0b, 0xb2, + 0x5d, 0xc3, 0x36, 0xbb, 0xd8, 0xe3, 0x25, 0x8a, 0x05, 0xd9, 0x63, 0x96, 0xaa, 0xbe, 0x0d, 0x47, + 0x13, 0xc5, 0xf2, 0xf5, 0xe0, 0x4b, 0x30, 0xe3, 0x3a, 0xa6, 0xee, 0xb3, 0x64, 0x11, 0xaf, 0x56, + 0x88, 0xed, 0x08, 0xda, 0x35, 0x93, 0xb0, 0xb7, 0x02, 0xc7, 0x4d, 0x57, 0x7b, 0x34, 0xf6, 0x25, + 0x58, 0x48, 0xb2, 0xb3, 0xe2, 0xd5, 0x77, 0x61, 0x51, 0xc3, 0x3d, 0x67, 0x0f, 0x1f, 0x56, 0x74, + 0x1d, 0x96, 0xd2, 0x02, 0xb8, 0xf0, 0x0f, 0x60, 0x31, 0x4a, 0x6d, 0x05, 0x46, 0xd0, 0xf7, 0x0f, + 0x24, 0x9c, 0x2f, 0x96, 0x9f, 0x3a, 0x3e, 0xeb, 0xc8, 0xb2, 0x26, 0x3e, 0xd5, 0x45, 0x18, 0x6f, + 0x3a, 0xe6, 0x5a, 0x13, 0xcd, 0x40, 0xc1, 0x72, 0x39, 0x73, 0xc1, 0x72, 0xd5, 0x76, 0xbc, 0xcc, + 0x0d, 0x16, 0xd9, 0xb2, 0xa2, 0x93, 0xa4, 0xe8, 0x36, 0xcc, 0x18, 0xa6, 0x69, 0x11, 0x43, 0x32, + 0xba, 0xba, 0xe5, 0x8a, 0xc0, 0x7c, 0x2e, 0xd1, 0xf5, 0x6b, 0x4d, 0xad, 0x1a, 0x11, 0xae, 0xb9, + 0xbe, 0xfa, 0x00, 0x2a, 0xd1, 0x22, 0xe0, 0x8d, 0x68, 0xe1, 0x5b, 0x18, 0x1e, 0x2f, 0x86, 0xab, + 0xe2, 0x8d, 0xd4, 0x24, 0xc9, 0xab, 0xf9, 0x06, 0x40, 0xe8, 0x54, 0x45, 0x08, 0x7a, 0x34, 0x53, + 0xa4, 0x16, 0x23, 0x54, 0xff, 0xa5, 0x14, 0x77, 0xb2, 0xb1, 0x26, 0x9b, 0x61, 0x93, 0x4d, 0xc9, + 0xe9, 0x16, 0x0e, 0xe8, 0x74, 0xaf, 0xc3, 0xb8, 0x1f, 0x18, 0x01, 0xe6, 0x31, 0xff, 0xf1, 0x6c, + 0x46, 0x52, 0x30, 0xd6, 0x18, 0x25, 0x3a, 0x09, 0xd0, 0xf6, 0xb0, 0x11, 0x60, 0x53, 0x37, 0xd8, + 0xac, 0x50, 0xd4, 0x2a, 0x3c, 0xa5, 0x11, 0x10, 0x2f, 0x22, 0x56, 0x29, 0x19, 0x13, 0x61, 0x4e, + 0x37, 0x46, 0xeb, 0x95, 0xd0, 0x7b, 0x4d, 0x0c, 0xf5, 0x5e, 0x9c, 0x95, 0x7b, 0xaf, 0xc8, 0x13, + 0x4f, 0x0e, 0xf2, 0xc4, 0x8c, 0x69, 0x14, 0x4f, 0x5c, 0x1e, 0xe4, 0x89, 0xb9, 0x98, 0xc1, 0x9e, + 0x38, 0xc3, 0x91, 0x54, 0xb2, 0x1c, 0xc9, 0xe7, 0xe9, 0x3a, 0xff, 0xa2, 0x00, 0x4b, 0xe9, 0xf1, + 0xcc, 0xfd, 0xd8, 0x4d, 0x98, 0xf0, 0x69, 0xca, 0x60, 0xff, 0xc9, 0xb9, 0x38, 0x2d, 0x7a, 0x00, + 0x25, 0xcb, 0xde, 0x71, 0xf8, 0xc0, 0xbb, 0x32, 0x90, 0x87, 0x97, 0x74, 0x65, 0xcd, 0xde, 0x71, + 0x98, 0x06, 0x29, 0x2f, 0x7a, 0x02, 0x47, 0xc2, 0xd5, 0xbb, 0xaf, 0x33, 0xc1, 0x58, 0xc4, 0x79, + 0x92, 0x95, 0x86, 0x51, 0x15, 0x97, 0x88, 0x22, 0xbe, 0x16, 0x67, 0x23, 0x31, 0x0e, 0x21, 0xf7, + 0x03, 0xa3, 0xe7, 0x0a, 0x8b, 0x0d, 0x13, 0xea, 0x6f, 0x42, 0x25, 0x2c, 0xfe, 0x40, 0xba, 0x5b, + 0x83, 0xf9, 0xc4, 0x18, 0x61, 0x8b, 0xd5, 0x70, 0x50, 0x29, 0xa3, 0x0e, 0x2a, 0xf5, 0x57, 0x4a, + 0x7c, 0xa0, 0x3f, 0xb4, 0xba, 0x01, 0xf6, 0x52, 0x03, 0xfd, 0x96, 0x90, 0xcb, 0x46, 0xf9, 0x99, + 0x01, 0x72, 0xd9, 0x5a, 0x90, 0x8f, 0xd8, 0xf7, 0x61, 0x86, 0x9a, 0xb8, 0xee, 0xe3, 0x2e, 0x8d, + 0x95, 0xb8, 0x1e, 0xaf, 0x66, 0x0b, 0x60, 0xa5, 0xb3, 0x21, 0xd2, 0xe2, 0x1c, 0xac, 0x6f, 0xaa, + 0xdd, 0x78, 0x5a, 0xfd, 0x3e, 0xa0, 0x34, 0xd1, 0x81, 0x34, 0xb8, 0x4e, 0xfc, 0xa5, 0x1f, 0x64, + 0xce, 0xdc, 0x3b, 0xb4, 0x1a, 0x83, 0x2d, 0x8f, 0x55, 0x55, 0xe3, 0xb4, 0xea, 0x3f, 0x17, 0x01, + 0xa2, 0xcc, 0x2f, 0xb8, 0xa3, 0xbc, 0x1b, 0x3a, 0x2c, 0x16, 0x71, 0xaa, 0xd9, 0x22, 0x33, 0x5d, + 0xd5, 0x9a, 0xec, 0xaa, 0x58, 0xec, 0x79, 0x3e, 0x47, 0xc0, 0x81, 0x9d, 0xd4, 0xe4, 0x17, 0xcd, + 0x49, 0x3d, 0x84, 0x85, 0xa4, 0x99, 0x70, 0x0f, 0xf5, 0x1a, 0x8c, 0x5b, 0x01, 0xee, 0xb1, 0x4d, + 0xed, 0xc4, 0xa6, 0x48, 0x8c, 0x9c, 0x11, 0xa9, 0xef, 0xc0, 0x82, 0xdc, 0x57, 0x07, 0x0b, 0x5d, + 0xd4, 0x27, 0xc9, 0xd8, 0x27, 0x72, 0x95, 0xdc, 0x3e, 0x32, 0xb7, 0x97, 0x92, 0x3c, 0x8c, 0x52, + 0xfd, 0xb1, 0x02, 0x47, 0x13, 0x59, 0x39, 0x03, 0xff, 0x6b, 0xa9, 0x01, 0xcc, 0x7c, 0xeb, 0xcd, + 0x01, 0xa5, 0x7c, 0x86, 0xa3, 0xf8, 0x2b, 0x50, 0x97, 0xbb, 0x47, 0x52, 0xed, 0x9d, 0xc4, 0x50, + 0x3e, 0x3b, 0xb4, 0xd2, 0xe1, 0x78, 0x6e, 0xc2, 0xf1, 0x4c, 0xc1, 0x69, 0x9d, 0x17, 0x47, 0xd4, + 0xf9, 0x7f, 0x14, 0xe2, 0x3e, 0xbb, 0x11, 0x04, 0x9e, 0xf5, 0xb4, 0x1f, 0xe0, 0x4f, 0x37, 0xa8, + 0x5a, 0x09, 0x47, 0x36, 0xf3, 0xb3, 0xaf, 0x65, 0x73, 0x46, 0xa5, 0x67, 0x8e, 0xf1, 0x96, 0x3c, + 0xc6, 0x4b, 0x54, 0xd4, 0xf5, 0xa1, 0xa2, 0x06, 0x8e, 0xf6, 0xcf, 0x73, 0x10, 0xff, 0x54, 0x81, + 0xd9, 0x44, 0xaf, 0xa0, 0xfb, 0x00, 0x46, 0x58, 0x75, 0x6e, 0x1f, 0x67, 0x86, 0x35, 0x51, 0x8b, + 0xf1, 0x90, 0x39, 0x91, 0xc5, 0x8b, 0x19, 0x73, 0x62, 0x46, 0xbc, 0x18, 0x86, 0x8b, 0xf7, 0xa2, + 0xc5, 0x2e, 0xdb, 0x88, 0x55, 0x07, 0x2e, 0x76, 0x19, 0xaf, 0x60, 0x51, 0x7f, 0x58, 0x80, 0xf9, + 0x2c, 0xe9, 0xe8, 0x15, 0x28, 0xb6, 0xdd, 0x3e, 0x6f, 0x89, 0x74, 0x02, 0xb6, 0xec, 0xf6, 0xb7, + 0x7d, 0xa3, 0x83, 0x35, 0x42, 0x80, 0xae, 0xc2, 0x44, 0x0f, 0xf7, 0x1c, 0x6f, 0x9f, 0xd7, 0x5b, + 0xda, 0x6e, 0x58, 0xa7, 0x39, 0x8c, 0x9a, 0x93, 0xa1, 0x1b, 0x51, 0x58, 0xcd, 0xea, 0xbb, 0x24, + 0xad, 0x1e, 0x58, 0x16, 0x63, 0x09, 0x63, 0xe9, 0x1b, 0x30, 0xe9, 0x7a, 0x4e, 0x1b, 0xfb, 0x3e, + 0xdf, 0x0d, 0x59, 0x4a, 0x1c, 0xc9, 0x91, 0x2c, 0xce, 0xc3, 0x09, 0xd1, 0x5d, 0x80, 0x28, 0x80, + 0xe2, 0x33, 0x53, 0x3d, 0x37, 0xde, 0xf2, 0xb5, 0x18, 0x35, 0x3a, 0x07, 0x05, 0xcb, 0xe1, 0x81, + 0xfb, 0x11, 0x69, 0x7b, 0xda, 0x61, 0xa5, 0x14, 0x2c, 0x87, 0xa8, 0x6e, 0x21, 0x5b, 0xbd, 0xe8, + 0x72, 0x5c, 0x79, 0xc7, 0x33, 0xfa, 0x43, 0xd6, 0xe1, 0xad, 0x84, 0x0e, 0x4f, 0x65, 0x70, 0x64, + 0xa9, 0xf2, 0x4e, 0x52, 0x95, 0xa7, 0x33, 0x18, 0xb3, 0x35, 0x7a, 0x27, 0xa9, 0xd1, 0x2c, 0xd6, + 0x6c, 0xc5, 0x36, 0x32, 0x14, 0x7b, 0x36, 0xab, 0x8d, 0xb9, 0xfa, 0x55, 0xff, 0x5a, 0x81, 0xe9, + 0x78, 0xbd, 0xe4, 0xb8, 0x56, 0x49, 0xc4, 0xb5, 0x68, 0x03, 0xe6, 0x4c, 0xb6, 0xbd, 0xab, 0x5b, + 0x76, 0x80, 0xbd, 0x1d, 0xa3, 0x2d, 0x42, 0xc7, 0xb3, 0x19, 0xc6, 0xb3, 0x26, 0x68, 0x58, 0xc5, + 0x6b, 0x9c, 0x37, 0x4c, 0x26, 0x2d, 0x08, 0xe5, 0x08, 0xd7, 0x36, 0x82, 0xa0, 0x18, 0x93, 0xfa, + 0x4f, 0x0a, 0x1c, 0xc9, 0x50, 0xf0, 0x90, 0x86, 0x6c, 0xe7, 0x37, 0xe4, 0x42, 0x7e, 0xd7, 0x0d, + 0x6d, 0xcf, 0xe3, 0x8c, 0xf6, 0x8c, 0x2e, 0x2f, 0xde, 0xac, 0x5f, 0x2b, 0x70, 0x34, 0x93, 0x2a, + 0x73, 0x0f, 0xf6, 0x06, 0x94, 0xbd, 0x17, 0xfa, 0xd3, 0xfd, 0x00, 0xfb, 0x59, 0xa3, 0x7f, 0x3b, + 0x76, 0x98, 0x33, 0xe9, 0xbd, 0x78, 0x40, 0xe8, 0xd0, 0x4d, 0xa8, 0x78, 0x2f, 0x74, 0xec, 0x79, + 0x8e, 0x27, 0x1c, 0x56, 0x2e, 0x53, 0xd9, 0x7b, 0xb1, 0x4a, 0x09, 0x49, 0x49, 0x81, 0x28, 0xa9, + 0x34, 0xa4, 0xa4, 0x20, 0x2a, 0x29, 0x08, 0x4b, 0x1a, 0x1f, 0x52, 0x52, 0xc0, 0x4b, 0x52, 0xff, + 0xa8, 0x00, 0x27, 0x06, 0xa9, 0xeb, 0x53, 0x53, 0xc4, 0x2a, 0x20, 0xef, 0x85, 0xee, 0x1a, 0xed, + 0x67, 0x38, 0xf0, 0x75, 0xd3, 0x73, 0x5c, 0x17, 0x9b, 0xc3, 0x34, 0x52, 0xf3, 0x5e, 0x34, 0x19, + 0xc7, 0x0a, 0x63, 0x38, 0x94, 0x66, 0x56, 0x01, 0x05, 0xe9, 0xa2, 0x87, 0xa8, 0xa8, 0x16, 0x24, + 0x8a, 0x56, 0x3f, 0x82, 0xe9, 0xb8, 0x87, 0x18, 0x62, 0xfb, 0xf7, 0xa0, 0xca, 0x3d, 0x88, 0xde, + 0x76, 0xfa, 0x76, 0x30, 0x4c, 0x51, 0xd3, 0x9c, 0x7a, 0x99, 0x10, 0xab, 0xdf, 0x0c, 0x87, 0xdb, + 0x67, 0x56, 0xe4, 0xff, 0x2e, 0x40, 0x25, 0x3c, 0xec, 0x27, 0xe1, 0x00, 0x83, 0x04, 0xb0, 0x7e, + 0xe7, 0x67, 0xff, 0x8f, 0xe5, 0xd0, 0x86, 0x05, 0xb3, 0xaf, 0x64, 0xc2, 0x05, 0x86, 0xac, 0x5e, + 0xae, 0xc1, 0x7c, 0xdf, 0xc7, 0x9e, 0xee, 0xbb, 0xb8, 0x6d, 0xed, 0x58, 0xd8, 0xd4, 0x59, 0x71, + 0x88, 0x16, 0x87, 0x48, 0x5e, 0x4b, 0x64, 0x51, 0x99, 0x59, 0xeb, 0x9d, 0x23, 0x99, 0xeb, 0x9d, + 0x4f, 0x1a, 0xef, 0xdc, 0x80, 0xf2, 0x97, 0xf0, 0x3e, 0xdb, 0x11, 0x18, 0x91, 0x4f, 0xfd, 0x6e, + 0x09, 0x16, 0x73, 0xce, 0x8a, 0xe8, 0x72, 0xd2, 0xed, 0xeb, 0x2e, 0xf6, 0x2c, 0xc7, 0x14, 0xbd, + 0xd6, 0x76, 0xfb, 0x4d, 0x9a, 0x80, 0x8e, 0x03, 0xf9, 0xd0, 0xbf, 0xd9, 0x77, 0x78, 0xc4, 0x5a, + 0xd4, 0xca, 0x6d, 0xb7, 0xff, 0x65, 0xf2, 0x2d, 0x78, 0xfd, 0x5d, 0xc3, 0xc3, 0xcc, 0x7f, 0x30, + 0xde, 0x16, 0x4d, 0x40, 0xd7, 0xe1, 0x28, 0x9b, 0x1b, 0xf5, 0xae, 0xd5, 0xb3, 0x88, 0x97, 0x8d, + 0x0d, 0x8d, 0xa2, 0x86, 0x58, 0xe6, 0x13, 0x92, 0xb7, 0x66, 0xb3, 0xc1, 0xa0, 0x42, 0xd5, 0x71, + 0x7a, 0xba, 0xdf, 0x76, 0x3c, 0xac, 0x1b, 0xe6, 0x47, 0x74, 0x1c, 0x14, 0xb5, 0x29, 0xc7, 0xe9, + 0xb5, 0x48, 0x5a, 0xc3, 0xfc, 0x08, 0x9d, 0x86, 0xa9, 0xb6, 0xdb, 0xf7, 0x71, 0xa0, 0x93, 0x3f, + 0x34, 0x30, 0xa8, 0x68, 0xc0, 0x92, 0x96, 0xdd, 0xbe, 0x1f, 0x23, 0xe8, 0x91, 0x35, 0xdc, 0x64, + 0x9c, 0x60, 0x1d, 0xf7, 0xe8, 0xb1, 0xfb, 0x6e, 0xbf, 0x83, 0x5d, 0xa3, 0x83, 0x59, 0xd5, 0xc4, + 0xb6, 0x9c, 0x74, 0xec, 0xfe, 0x98, 0x93, 0xd0, 0x0a, 0x6a, 0x33, 0xbb, 0xf1, 0x4f, 0x1f, 0xbd, + 0x07, 0x93, 0x7d, 0x9b, 0x1a, 0xc0, 0x52, 0x85, 0xf2, 0x5e, 0x1b, 0xe1, 0x64, 0xee, 0xca, 0x36, + 0x63, 0xe1, 0x07, 0x85, 0x5c, 0x00, 0xba, 0x0b, 0x75, 0xae, 0x28, 0xff, 0xb9, 0xe1, 0x26, 0xb5, + 0x05, 0x54, 0x05, 0x0b, 0x8c, 0xa2, 0xf5, 0xdc, 0x70, 0xe3, 0x1a, 0xab, 0xdf, 0x85, 0xe9, 0xb8, + 0xd0, 0x03, 0xd9, 0xd2, 0x03, 0xa8, 0x4a, 0x8d, 0x24, 0xbd, 0x4d, 0x95, 0xe2, 0x5b, 0xdf, 0x12, + 0x63, 0xab, 0x4c, 0x12, 0x5a, 0xd6, 0xb7, 0x28, 0x58, 0x82, 0xd6, 0x8c, 0xca, 0x29, 0x69, 0xec, + 0x43, 0x35, 0xa0, 0x2a, 0xe1, 0x13, 0x88, 0x4b, 0xa6, 0x40, 0x04, 0xee, 0x92, 0xc9, 0x6f, 0x92, + 0xe6, 0x39, 0x5d, 0x51, 0x03, 0xfa, 0x9b, 0xa4, 0xd1, 0x53, 0x6a, 0x76, 0xe6, 0x46, 0x7f, 0xd3, + 0x22, 0xf0, 0x1e, 0xc7, 0x3a, 0x55, 0x34, 0xf6, 0xa1, 0xfe, 0xb6, 0x02, 0xb0, 0x6c, 0xb8, 0xc6, + 0x53, 0xab, 0x6b, 0x05, 0xfb, 0xe8, 0x22, 0xd4, 0x0c, 0xd3, 0xd4, 0xdb, 0x22, 0xc5, 0xc2, 0x02, + 0x7c, 0x36, 0x6b, 0x98, 0xe6, 0x72, 0x2c, 0x19, 0xbd, 0x0a, 0x73, 0xc4, 0xa1, 0xca, 0xb4, 0x0c, + 0x8d, 0x56, 0x23, 0x19, 0x12, 0xf1, 0x6d, 0x58, 0x22, 0x72, 0x8d, 0xde, 0x53, 0x0b, 0xdb, 0x81, + 0xcc, 0xc3, 0x60, 0x6a, 0x0b, 0x86, 0x69, 0x36, 0x58, 0x76, 0x9c, 0x53, 0xfd, 0xbd, 0x49, 0x38, + 0x29, 0xf7, 0x78, 0x12, 0x32, 0x72, 0x17, 0xa6, 0x13, 0xf5, 0x4d, 0x81, 0x2d, 0xa2, 0x16, 0x6a, + 0x12, 0x6d, 0x02, 0xb0, 0x50, 0x48, 0x01, 0x16, 0x32, 0xe1, 0x28, 0xc5, 0x4f, 0x09, 0x8e, 0x52, + 0xfa, 0x84, 0x70, 0x94, 0xf1, 0xc3, 0xc2, 0x51, 0xa6, 0x47, 0x86, 0xa3, 0xbc, 0x42, 0x5d, 0xaf, + 0x28, 0x91, 0x86, 0x03, 0xcc, 0x27, 0x54, 0x43, 0xe9, 0xb6, 0x40, 0x44, 0x26, 0x60, 0x2b, 0x93, + 0x07, 0x81, 0xad, 0x94, 0x0f, 0x09, 0x5b, 0x99, 0xfb, 0x54, 0x60, 0x2b, 0x67, 0x60, 0xda, 0x76, + 0x74, 0x1b, 0x3f, 0xd7, 0x49, 0xd7, 0xfb, 0x14, 0x0c, 0x53, 0xd6, 0xc0, 0x76, 0x36, 0xf0, 0xf3, + 0x26, 0x49, 0x41, 0x67, 0x61, 0xba, 0x67, 0xf8, 0xcf, 0xb0, 0x49, 0xf1, 0x23, 0xfe, 0x52, 0x95, + 0xda, 0xec, 0x14, 0x4b, 0x6b, 0x92, 0x24, 0xf4, 0x32, 0x84, 0x6d, 0xe5, 0x44, 0x33, 0x94, 0xa8, + 0x2a, 0x52, 0x19, 0x59, 0x0c, 0x02, 0x33, 0x7b, 0x48, 0x08, 0x4c, 0xed, 0x20, 0x10, 0x98, 0xcb, + 0x50, 0x13, 0xbf, 0x05, 0x06, 0x86, 0x1d, 0x69, 0x50, 0xf8, 0xcb, 0xac, 0xc8, 0x13, 0x38, 0x97, + 0x3c, 0xc4, 0x0c, 0x0c, 0x44, 0xcc, 0xfc, 0xb1, 0xc2, 0x17, 0xd7, 0xe1, 0x20, 0xe5, 0x47, 0xf5, + 0x12, 0xca, 0x42, 0x39, 0x0c, 0xca, 0x02, 0x6d, 0xe5, 0xe2, 0x50, 0x2e, 0xe6, 0x4b, 0x1a, 0x86, + 0x44, 0x51, 0x2d, 0x40, 0x32, 0x07, 0x1d, 0x28, 0x1c, 0x6b, 0xc1, 0x66, 0x6a, 0x8a, 0xb5, 0xa8, + 0x41, 0xb1, 0xc3, 0xd1, 0x17, 0x45, 0x8d, 0xfc, 0xcc, 0xb3, 0xe0, 0x62, 0x9e, 0x05, 0xab, 0xeb, + 0xe1, 0xea, 0xf9, 0xd3, 0x80, 0x07, 0xaa, 0xff, 0xaa, 0xc0, 0x49, 0x2e, 0x2f, 0x07, 0x43, 0x97, + 0x31, 0x68, 0x95, 0x9c, 0x41, 0xdb, 0xf6, 0xb0, 0x89, 0xed, 0xc0, 0x32, 0xba, 0x34, 0x1e, 0x13, + 0xa7, 0xe6, 0x51, 0x32, 0x0d, 0x09, 0xcf, 0xc2, 0x34, 0x43, 0xda, 0xf2, 0x85, 0x34, 0x03, 0xd4, + 0x4e, 0x51, 0xb0, 0x2d, 0x5f, 0x2b, 0x6f, 0x66, 0x39, 0xca, 0x52, 0xee, 0x36, 0xcd, 0x50, 0x7f, + 0xa9, 0x3a, 0xb0, 0x98, 0x83, 0x5f, 0xc8, 0xb4, 0x08, 0x25, 0x6d, 0x11, 0x03, 0x95, 0x94, 0xb6, + 0x88, 0xef, 0x2a, 0x70, 0x3a, 0xb5, 0xa0, 0xff, 0xfc, 0x35, 0xab, 0xfe, 0x99, 0x12, 0xda, 0x4f, + 0x72, 0x74, 0x2d, 0xa7, 0x47, 0xd7, 0xcb, 0x83, 0xf6, 0x27, 0x32, 0xc7, 0xd7, 0xfb, 0xb9, 0xe3, + 0xeb, 0xd5, 0x81, 0x7b, 0x1d, 0xc3, 0xf4, 0xf9, 0x07, 0x05, 0x38, 0x96, 0x5b, 0x81, 0x44, 0x78, + 0xab, 0x24, 0xc3, 0x5b, 0x1e, 0x1a, 0x47, 0x8b, 0x19, 0x16, 0x1a, 0xd3, 0xf5, 0x0a, 0x8f, 0x41, + 0xf5, 0x9e, 0xf1, 0xc2, 0xea, 0xf5, 0x7b, 0x3c, 0x36, 0x26, 0xe2, 0xd6, 0x59, 0xca, 0x61, 0x82, + 0xe3, 0xab, 0x30, 0xcf, 0xe6, 0x2d, 0x1a, 0x9f, 0x45, 0x1c, 0x2c, 0x46, 0x9e, 0x63, 0x79, 0x24, + 0x54, 0x13, 0x0c, 0x8f, 0xa1, 0x6a, 0xec, 0xec, 0x58, 0x36, 0x55, 0x1b, 0x8b, 0x95, 0x8b, 0x39, + 0x00, 0x9c, 0x65, 0xb7, 0x4f, 0x5d, 0x41, 0x83, 0xd3, 0x6b, 0xd3, 0x82, 0x93, 0x84, 0xd4, 0xea, + 0x97, 0x43, 0x4b, 0x4f, 0x12, 0xa2, 0x63, 0x50, 0x66, 0x2d, 0xf5, 0x99, 0x87, 0x28, 0x69, 0x93, + 0xb4, 0x99, 0xfe, 0x33, 0xa1, 0x21, 0x36, 0xa1, 0x33, 0xf4, 0x34, 0xa1, 0xa5, 0xfc, 0x6a, 0x03, + 0xe6, 0x42, 0x9d, 0x0f, 0x04, 0x97, 0xc5, 0xc0, 0x62, 0x05, 0x19, 0x2c, 0x66, 0xc3, 0xc4, 0x0a, + 0xde, 0xb3, 0xda, 0xf8, 0x53, 0x81, 0xe3, 0x9f, 0x81, 0x29, 0x17, 0x7b, 0x3d, 0xcb, 0xf7, 0xc3, + 0x08, 0xaa, 0xa2, 0xc5, 0x93, 0xd4, 0xd3, 0x50, 0x59, 0x5e, 0x59, 0xe3, 0x45, 0x66, 0x54, 0x55, + 0xfd, 0xb7, 0x09, 0x98, 0x4d, 0x0e, 0x80, 0x3b, 0x29, 0xf0, 0xda, 0xc9, 0xcc, 0x8d, 0xcf, 0x8c, + 0x1d, 0xff, 0x10, 0xf9, 0x5e, 0x18, 0x01, 0xf9, 0xbe, 0x04, 0x93, 0x6d, 0xa7, 0xd7, 0x33, 0x6c, + 0x53, 0x5c, 0xaa, 0xe0, 0x9f, 0xa4, 0xa6, 0x86, 0xd7, 0x61, 0x7b, 0xfd, 0x15, 0x8d, 0xfe, 0x26, + 0xf6, 0x49, 0x3c, 0xb5, 0x65, 0x53, 0xf8, 0x1b, 0x35, 0xa1, 0x8a, 0x06, 0x3c, 0x69, 0xc5, 0xf2, + 0xd0, 0x05, 0x28, 0x61, 0x7b, 0x4f, 0x98, 0x8c, 0xb4, 0xe7, 0x2c, 0xd6, 0x9f, 0x1a, 0xa5, 0x40, + 0x17, 0x61, 0xa2, 0x47, 0x6c, 0x5e, 0x40, 0x24, 0xe6, 0x52, 0x97, 0x0f, 0x34, 0x4e, 0x80, 0x5e, + 0x83, 0x49, 0x93, 0x6a, 0x4f, 0x2c, 0xb8, 0x90, 0x04, 0xa4, 0xa3, 0x59, 0x9a, 0x20, 0x41, 0xef, + 0x86, 0x07, 0x1e, 0x95, 0xf4, 0x49, 0x64, 0x42, 0xcd, 0x99, 0x67, 0x1d, 0x1b, 0xf2, 0x86, 0x00, + 0xa4, 0x8f, 0x4d, 0x92, 0x52, 0x06, 0x6f, 0x0b, 0x1c, 0x83, 0x72, 0xd7, 0xe9, 0x30, 0xeb, 0x99, + 0x62, 0x37, 0x72, 0xba, 0x4e, 0x87, 0x1a, 0xcf, 0x3c, 0x8c, 0xfb, 0x81, 0x69, 0xd9, 0x34, 0x6e, + 0x2d, 0x6b, 0xec, 0x83, 0x78, 0x10, 0xfa, 0x43, 0x77, 0xec, 0x36, 0x5e, 0xaa, 0xd2, 0xac, 0x0a, + 0x4d, 0xd9, 0xb4, 0xdb, 0x74, 0xfd, 0x1e, 0x04, 0xfb, 0x4b, 0x33, 0x34, 0x9d, 0xfc, 0x8c, 0xce, + 0x1d, 0x66, 0x73, 0xce, 0x1d, 0x12, 0x15, 0xce, 0x38, 0x77, 0xa8, 0xe5, 0x4e, 0x68, 0x49, 0x5e, + 0xc1, 0x42, 0x62, 0xf6, 0xe5, 0x95, 0x35, 0x5d, 0x74, 0xcd, 0x5c, 0xfa, 0x22, 0x41, 0x68, 0xf6, + 0x1a, 0x84, 0x3f, 0x3f, 0xd7, 0x63, 0x9f, 0x1f, 0x2a, 0xb0, 0xb0, 0x4c, 0x0f, 0xbd, 0x63, 0x8e, + 0xfb, 0x20, 0x78, 0xb1, 0xd7, 0x43, 0x10, 0x5f, 0x06, 0x12, 0x2b, 0xa9, 0x29, 0x81, 0xe1, 0x5b, + 0x86, 0x19, 0x21, 0x96, 0x33, 0x17, 0x47, 0x40, 0x00, 0x56, 0xfd, 0xf8, 0xa7, 0x7a, 0x0f, 0x16, + 0x53, 0x35, 0xe7, 0x47, 0x8f, 0xc9, 0x1b, 0x27, 0xac, 0xe2, 0xf1, 0x1b, 0x27, 0xea, 0x5d, 0x38, + 0xda, 0x0a, 0x0c, 0x2f, 0x48, 0x35, 0x7b, 0x04, 0x5e, 0x8a, 0xed, 0x93, 0x79, 0x39, 0xfc, 0xae, + 0x05, 0xf3, 0xad, 0xc0, 0x71, 0x0f, 0x21, 0x94, 0xf8, 0x1d, 0xd2, 0x72, 0xa7, 0x2f, 0x26, 0x41, + 0xf1, 0xa9, 0x2e, 0x32, 0x24, 0x62, 0xba, 0xb4, 0xb7, 0x60, 0x81, 0x01, 0x01, 0x0f, 0xd3, 0x88, + 0x63, 0x02, 0x86, 0x98, 0x96, 0xfb, 0x08, 0x8e, 0x48, 0xe7, 0x1c, 0x1c, 0x38, 0x73, 0x4d, 0x06, + 0xce, 0xe4, 0x9f, 0x3b, 0x85, 0xb8, 0x99, 0xff, 0x5f, 0x88, 0xf9, 0xf1, 0x9c, 0xd3, 0xf3, 0x37, + 0x64, 0xd8, 0xcc, 0xe9, 0x7c, 0xa9, 0x12, 0x6a, 0x26, 0x6d, 0x9d, 0xc5, 0x0c, 0xeb, 0xdc, 0x4e, + 0x1d, 0xcd, 0x97, 0xd2, 0xb0, 0xa7, 0x44, 0x0d, 0x3f, 0x93, 0x43, 0xf9, 0x27, 0x0c, 0x5a, 0x13, + 0x16, 0x1d, 0x9e, 0xc7, 0xbf, 0x9e, 0x38, 0x8f, 0x3f, 0x3e, 0xa0, 0xa6, 0xe1, 0x49, 0xfc, 0xf7, + 0x4b, 0x50, 0x09, 0xf3, 0x52, 0x1a, 0x4e, 0xab, 0xaa, 0x90, 0xa1, 0xaa, 0xf8, 0xfc, 0x5a, 0x3c, + 0xe4, 0xfc, 0x5a, 0x1a, 0x61, 0x7e, 0x3d, 0x0e, 0x15, 0x76, 0xb3, 0xcc, 0xc3, 0x3b, 0x7c, 0xbe, + 0x2c, 0xd3, 0x04, 0x0d, 0xef, 0x44, 0x26, 0x36, 0x31, 0xa2, 0x89, 0x25, 0x60, 0x3c, 0x93, 0x49, + 0x18, 0xcf, 0x9d, 0x70, 0xee, 0x2b, 0xa7, 0x4f, 0xc4, 0x42, 0x89, 0x99, 0xb3, 0x5e, 0x62, 0x1b, + 0xbc, 0x92, 0xde, 0x06, 0x8f, 0xf8, 0x87, 0xce, 0x77, 0xac, 0xc9, 0x96, 0xc9, 0xaf, 0xd1, 0x4d, + 0xd2, 0xef, 0x35, 0xf3, 0xf3, 0x74, 0xfd, 0x9b, 0x0c, 0xb6, 0x13, 0x37, 0x41, 0xee, 0x3e, 0xdf, + 0x90, 0x0e, 0x43, 0x95, 0x8c, 0x69, 0x2c, 0x74, 0x19, 0xf1, 0x03, 0xd0, 0x6d, 0x58, 0x48, 0xc2, + 0xfd, 0x0e, 0xe4, 0xfe, 0x72, 0x70, 0xc7, 0x3f, 0x8f, 0x07, 0x83, 0x39, 0x20, 0xdb, 0x3b, 0x29, + 0x3c, 0xc8, 0xc8, 0xc6, 0x7b, 0x4d, 0x86, 0x8e, 0x1d, 0xd8, 0xe4, 0x52, 0xc8, 0x31, 0x1a, 0xac, + 0x18, 0x1e, 0xcf, 0x66, 0x8b, 0x8a, 0x0a, 0x4f, 0x69, 0xd0, 0x15, 0x0d, 0x89, 0xf8, 0xfd, 0x5d, + 0x96, 0x3f, 0xc1, 0x56, 0x34, 0x22, 0xa9, 0x41, 0x37, 0x8f, 0xf1, 0x0b, 0x2b, 0xd0, 0xdb, 0x8e, + 0x89, 0xa9, 0x41, 0x8f, 0x6b, 0x65, 0x92, 0xb0, 0xec, 0x98, 0x38, 0x1a, 0x6a, 0xe5, 0x83, 0x0e, + 0xb5, 0x4a, 0x62, 0xa8, 0x2d, 0xc0, 0x84, 0x87, 0x0d, 0xdf, 0xb1, 0xb9, 0x49, 0xf2, 0x2f, 0xd2, + 0x11, 0x3d, 0xec, 0xfb, 0xa4, 0x0c, 0x1e, 0x9b, 0xf1, 0xcf, 0x58, 0x1c, 0x39, 0x3d, 0x20, 0x8e, + 0x1c, 0x00, 0xe1, 0x4d, 0xc4, 0x91, 0xd5, 0x01, 0x71, 0xe4, 0x48, 0x08, 0xde, 0x28, 0x62, 0x9e, + 0x19, 0x16, 0x31, 0xc7, 0x43, 0xce, 0x59, 0x39, 0xe4, 0xbc, 0x17, 0x5f, 0x59, 0xd7, 0xd2, 0x58, + 0x85, 0xc1, 0x4b, 0xea, 0xf8, 0xd8, 0x9e, 0x93, 0xc6, 0x36, 0xba, 0xcc, 0x77, 0xf0, 0x51, 0x7a, + 0xef, 0x57, 0xda, 0x8a, 0x62, 0x9b, 0xfb, 0x9f, 0xa7, 0x2b, 0xf8, 0x3b, 0x05, 0x16, 0x53, 0x43, + 0x97, 0x3b, 0x83, 0xd7, 0x13, 0x28, 0xe3, 0x81, 0xf0, 0x5e, 0x01, 0x32, 0x6e, 0x48, 0x20, 0xe3, + 0xcb, 0x83, 0x58, 0x72, 0x30, 0xc6, 0x87, 0xc7, 0xfd, 0x7e, 0x47, 0x01, 0x94, 0xb1, 0x0b, 0x71, + 0x47, 0x2c, 0x09, 0x0e, 0xb0, 0x35, 0xc9, 0x57, 0x05, 0xef, 0x46, 0xab, 0x82, 0xc2, 0x41, 0x76, + 0x5e, 0x42, 0x40, 0xd2, 0x2a, 0x54, 0xe5, 0xcd, 0xc7, 0x9b, 0x72, 0x65, 0x4e, 0xe5, 0x57, 0x86, + 0x1a, 0x08, 0x23, 0x56, 0x7f, 0x5e, 0x80, 0xd3, 0xdb, 0xae, 0x99, 0x08, 0x79, 0x79, 0x61, 0xa3, + 0xbb, 0xda, 0x3b, 0x32, 0x28, 0xeb, 0x90, 0x9a, 0x28, 0x1e, 0x46, 0x13, 0xe8, 0x1b, 0x59, 0xb0, + 0xb9, 0x7b, 0xd2, 0xd9, 0xf5, 0xe0, 0x06, 0x0e, 0x41, 0xd0, 0x7d, 0xd2, 0x91, 0xa0, 0xc2, 0x99, + 0xfc, 0x0a, 0xf0, 0xf0, 0xf8, 0x7f, 0xc0, 0xec, 0xea, 0x0b, 0xdc, 0x6e, 0xed, 0xdb, 0xed, 0x03, + 0x68, 0xbd, 0x06, 0xc5, 0x76, 0xcf, 0xe4, 0xa7, 0x66, 0xe4, 0x67, 0x3c, 0xe2, 0x2f, 0xca, 0x11, + 0xbf, 0x0e, 0xb5, 0xa8, 0x04, 0x3e, 0x0e, 0x17, 0xc8, 0x38, 0x34, 0x09, 0x31, 0x11, 0x3e, 0xad, + 0xf1, 0x2f, 0x9e, 0x8e, 0x3d, 0x76, 0x0d, 0x8a, 0xa5, 0x63, 0xcf, 0x93, 0xa7, 0x91, 0xa2, 0x3c, + 0x8d, 0xa8, 0xdf, 0x53, 0x60, 0x8a, 0x94, 0xf0, 0x89, 0xea, 0xcf, 0x97, 0xdd, 0xc5, 0x68, 0xd9, + 0x1d, 0xae, 0xde, 0x4b, 0xf1, 0xd5, 0x7b, 0x54, 0xf3, 0x71, 0x9a, 0x9c, 0xae, 0xf9, 0x44, 0x98, + 0x8e, 0x3d, 0x4f, 0x3d, 0x03, 0xd3, 0xac, 0x6e, 0xbc, 0xe5, 0x35, 0x28, 0xf6, 0xbd, 0xae, 0xe8, + 0xbf, 0xbe, 0xd7, 0x55, 0xbf, 0xad, 0x40, 0xb5, 0x11, 0x04, 0x46, 0x7b, 0xf7, 0x00, 0x0d, 0x08, + 0x2b, 0x57, 0x88, 0x57, 0x2e, 0xdd, 0x88, 0xa8, 0xba, 0xa5, 0x9c, 0xea, 0x8e, 0x4b, 0xd5, 0x55, + 0x61, 0x46, 0xd4, 0x25, 0xb7, 0xc2, 0x1b, 0x80, 0x9a, 0x8e, 0x17, 0x3c, 0x74, 0xbc, 0xe7, 0x86, + 0x67, 0x1e, 0x6c, 0x85, 0x8d, 0xa0, 0xc4, 0xdf, 0xdf, 0x28, 0x5e, 0x18, 0xd7, 0xe8, 0x6f, 0xf5, + 0x3c, 0x1c, 0x91, 0xe4, 0xe5, 0x16, 0x7c, 0x17, 0xa6, 0x68, 0x58, 0xc0, 0x17, 0x5f, 0xaf, 0xc6, + 0x01, 0x1f, 0x43, 0xc2, 0x07, 0x75, 0x05, 0xe6, 0x48, 0x80, 0x48, 0xd3, 0x43, 0xff, 0x72, 0x35, + 0xb1, 0x3e, 0x59, 0x4c, 0x89, 0x48, 0xac, 0x4d, 0x7e, 0xa5, 0xc0, 0x38, 0xc3, 0x76, 0x24, 0x83, + 0xb6, 0xe3, 0x64, 0xe2, 0x75, 0x1d, 0x3d, 0x30, 0x3a, 0xe1, 0xdb, 0x26, 0x24, 0x61, 0xcb, 0xe8, + 0xd0, 0x53, 0x38, 0x9a, 0x69, 0x5a, 0x1d, 0xec, 0x07, 0xe2, 0xe4, 0x78, 0x8a, 0xa4, 0xad, 0xb0, + 0x24, 0xa2, 0x18, 0x7a, 0xc0, 0x5e, 0xa2, 0xbb, 0xa5, 0xf4, 0x37, 0xba, 0xc0, 0x4e, 0x75, 0x06, + 0x1f, 0x97, 0xd2, 0xd3, 0x9e, 0x3a, 0x94, 0x13, 0xe7, 0x9c, 0xe1, 0x37, 0xba, 0x08, 0x25, 0xba, + 0x91, 0x3f, 0x39, 0x48, 0x4b, 0x94, 0x84, 0x58, 0x85, 0x6b, 0xd9, 0x36, 0x36, 0xf9, 0xc3, 0x1b, + 0xfc, 0x4b, 0x7d, 0x17, 0x50, 0x5c, 0x79, 0xbc, 0x83, 0x2e, 0xc2, 0x04, 0xd5, 0xad, 0x88, 0xaa, + 0xe7, 0x52, 0xa2, 0x35, 0x4e, 0xa0, 0x7e, 0x0d, 0x10, 0x2b, 0x4b, 0x8a, 0xa4, 0x0f, 0xd2, 0x81, + 0x03, 0x62, 0xea, 0x1f, 0x28, 0x70, 0x44, 0x92, 0xce, 0xeb, 0x77, 0x5e, 0x16, 0x9f, 0x51, 0x3d, + 0x2e, 0xfa, 0x6d, 0x69, 0x82, 0xbf, 0x98, 0xae, 0xc6, 0x7f, 0xd3, 0xe4, 0xfe, 0x0f, 0x0a, 0x40, + 0xa3, 0x1f, 0xec, 0xf2, 0x4d, 0xe1, 0x78, 0x27, 0x2a, 0x89, 0x4e, 0xac, 0x43, 0xd9, 0x35, 0x7c, + 0xff, 0xb9, 0xe3, 0x89, 0x05, 0x6f, 0xf8, 0x4d, 0xb7, 0x72, 0xfb, 0xfc, 0xb5, 0x91, 0x8a, 0x46, + 0x7f, 0xa3, 0x97, 0x61, 0x86, 0x3d, 0xba, 0xa3, 0x1b, 0xa6, 0xe9, 0x09, 0x10, 0x69, 0x45, 0xab, + 0xb2, 0xd4, 0x06, 0x4b, 0x24, 0x64, 0x16, 0x3d, 0xd6, 0x09, 0xf6, 0xf5, 0xc0, 0x79, 0x86, 0x6d, + 0xbe, 0x88, 0xad, 0x8a, 0xd4, 0x2d, 0x92, 0xc8, 0x8e, 0x88, 0x3b, 0x96, 0x1f, 0x78, 0x82, 0x4c, + 0x1c, 0xa6, 0xf3, 0x54, 0x4a, 0xa6, 0xfe, 0x89, 0x02, 0xb5, 0x66, 0xbf, 0xdb, 0x65, 0xca, 0x3d, + 0x4c, 0x27, 0x5f, 0xe2, 0x4d, 0x29, 0xa4, 0x4d, 0x3e, 0x52, 0x14, 0x6f, 0xe2, 0xa7, 0xb2, 0xef, + 0x76, 0x0d, 0xe6, 0x62, 0x35, 0xe6, 0x86, 0x23, 0x2d, 0x35, 0x14, 0x79, 0xa9, 0xa1, 0x36, 0x00, + 0xb1, 0xad, 0xa6, 0x43, 0xb7, 0x52, 0x3d, 0x0a, 0x47, 0x24, 0x11, 0x7c, 0x2a, 0xbe, 0x04, 0x55, + 0x0e, 0x68, 0xe4, 0x06, 0x71, 0x0c, 0xca, 0xc4, 0xa5, 0xb6, 0x2d, 0x53, 0x20, 0x67, 0x26, 0x5d, + 0xc7, 0x5c, 0xb6, 0x4c, 0x4f, 0xfd, 0x32, 0x54, 0xf9, 0xb3, 0x0a, 0x9c, 0xf6, 0x3e, 0xcc, 0xf0, + 0x83, 0x56, 0x5d, 0xba, 0x87, 0x7c, 0x2c, 0x03, 0x35, 0x2b, 0x54, 0x61, 0xc7, 0x3f, 0xd5, 0x6f, + 0x40, 0x9d, 0x45, 0x0b, 0x92, 0x60, 0xd1, 0xc0, 0xfb, 0x20, 0x40, 0x6b, 0x03, 0xe4, 0xcb, 0x9c, + 0x55, 0x2f, 0xfe, 0xa9, 0x9e, 0x84, 0xe3, 0x99, 0xf2, 0x79, 0xeb, 0x5d, 0xa8, 0x45, 0x19, 0xec, + 0xb2, 0x6c, 0x08, 0x07, 0x52, 0x62, 0x70, 0xa0, 0x85, 0x30, 0x84, 0x2f, 0x88, 0x99, 0x8b, 0x46, + 0xe9, 0xd1, 0x12, 0xb0, 0x98, 0xb7, 0x04, 0x2c, 0x49, 0x4b, 0x40, 0x75, 0x3d, 0xd4, 0x21, 0x5f, + 0x88, 0xdf, 0xa3, 0x5b, 0x05, 0xac, 0x6c, 0xe1, 0xd4, 0x4e, 0x64, 0xb7, 0x8f, 0x11, 0x69, 0x31, + 0x7a, 0xf5, 0x22, 0x54, 0x65, 0xf7, 0x16, 0xf3, 0x58, 0x8a, 0xec, 0xb1, 0xfe, 0x27, 0x2c, 0x68, + 0x12, 0x02, 0xf0, 0x21, 0x36, 0x82, 0xbe, 0x87, 0x7d, 0xf4, 0x16, 0xd4, 0x33, 0xde, 0x41, 0xd2, + 0xf9, 0xca, 0x90, 0x89, 0x59, 0x4c, 0x3d, 0x87, 0xb4, 0xce, 0xd6, 0x85, 0xe7, 0x61, 0x96, 0x22, + 0x14, 0x63, 0xd7, 0x7f, 0x99, 0x8e, 0xe8, 0x03, 0x39, 0x1b, 0xd1, 0x5d, 0x5f, 0x33, 0x7c, 0x94, + 0x83, 0x97, 0x9f, 0x79, 0xc6, 0xf6, 0x0e, 0x94, 0x77, 0x78, 0xbd, 0xf8, 0x80, 0x54, 0x33, 0x94, + 0x91, 0x68, 0x81, 0x16, 0xf2, 0xa8, 0x9b, 0x30, 0xcb, 0x69, 0xc2, 0xe6, 0xdd, 0x1b, 0x08, 0x8a, + 0x61, 0xcd, 0xcb, 0x85, 0xbb, 0xa8, 0x3f, 0x28, 0xc0, 0x4c, 0xc2, 0xc7, 0x5f, 0x4f, 0x2c, 0xe8, + 0xb2, 0xcc, 0x31, 0xb1, 0x9c, 0xbb, 0x2d, 0x79, 0x7b, 0x19, 0x82, 0x33, 0xf8, 0xa6, 0xe8, 0x2a, + 0xd4, 0x12, 0x78, 0x4e, 0x81, 0xe5, 0xae, 0xe7, 0x2b, 0x46, 0x9b, 0x95, 0xc1, 0x9e, 0x3e, 0x7a, + 0x33, 0xa6, 0xd7, 0x52, 0x7a, 0x19, 0x9a, 0xd0, 0x59, 0xa4, 0xd0, 0xc3, 0x4f, 0x34, 0xf3, 0x7c, + 0xfa, 0x7d, 0xe8, 0x13, 0x7e, 0x6e, 0x9f, 0xea, 0x39, 0x98, 0xda, 0xce, 0x7b, 0xf7, 0xa8, 0x24, + 0x60, 0xa2, 0xb7, 0x60, 0xfe, 0xa1, 0xd5, 0xc5, 0xfe, 0xbe, 0x1f, 0xe0, 0xde, 0x1a, 0x9d, 0x15, + 0x76, 0x2c, 0xec, 0xa1, 0x53, 0x00, 0xd4, 0x28, 0x5d, 0xc7, 0x0a, 0xdf, 0x61, 0x89, 0xa5, 0xa8, + 0x3f, 0x53, 0x60, 0x36, 0x62, 0x1c, 0x05, 0x0b, 0xfc, 0x06, 0x8c, 0xef, 0xf8, 0x62, 0x43, 0x37, + 0x71, 0xcc, 0x95, 0x55, 0x05, 0xad, 0xb4, 0xe3, 0xaf, 0x99, 0xe8, 0x16, 0x40, 0xdf, 0xc7, 0x26, + 0x3f, 0xf6, 0x1e, 0x82, 0xce, 0xae, 0x10, 0x52, 0x76, 0x0e, 0x7e, 0x1b, 0xa6, 0x2c, 0xdb, 0x31, + 0x31, 0x85, 0x44, 0x98, 0xc3, 0x90, 0xd9, 0xc0, 0x68, 0xb7, 0x7d, 0x6c, 0xaa, 0xbf, 0x1f, 0x01, + 0x1b, 0xbe, 0xc8, 0x2d, 0x54, 0xff, 0x54, 0xc4, 0x45, 0xa2, 0xdb, 0xf9, 0x98, 0x79, 0x0c, 0x73, + 0x6c, 0x7a, 0xdb, 0x09, 0xcb, 0xcc, 0xbc, 0xd7, 0x96, 0x68, 0x9c, 0x56, 0xb3, 0x78, 0x44, 0x2c, + 0x98, 0x50, 0x13, 0x8e, 0x46, 0x0b, 0x95, 0xb8, 0xb4, 0xc2, 0x70, 0x69, 0xf3, 0xed, 0xd8, 0xfe, + 0xbf, 0x60, 0x54, 0xef, 0xc2, 0xd1, 0xc4, 0xad, 0x94, 0xd1, 0x0f, 0x81, 0xde, 0x4b, 0x6c, 0xd9, + 0x46, 0x5e, 0xe2, 0x9a, 0x7c, 0x63, 0x72, 0xd0, 0x25, 0x23, 0x7e, 0x79, 0x6f, 0x1b, 0x8e, 0x49, + 0xfb, 0xc9, 0x52, 0x5d, 0x6e, 0x27, 0x96, 0x0d, 0x67, 0xf2, 0xe5, 0x25, 0xd6, 0x0f, 0xff, 0xae, + 0xc0, 0x7c, 0x16, 0xc1, 0x21, 0x8f, 0x39, 0x3e, 0xcc, 0xb9, 0x6d, 0xfd, 0xfa, 0xb0, 0x0a, 0x7d, + 0x26, 0xc7, 0x42, 0x1b, 0xec, 0xae, 0xe6, 0xf0, 0x3e, 0x29, 0x8e, 0xd6, 0x27, 0xbf, 0x2a, 0xc4, + 0x8e, 0xf2, 0x06, 0xdc, 0xa7, 0xfc, 0x04, 0xfb, 0xe7, 0xcb, 0x89, 0xeb, 0x94, 0xaf, 0x66, 0x32, + 0x0e, 0xb9, 0x4d, 0xa9, 0x65, 0x6d, 0x0b, 0x5d, 0x1b, 0x26, 0xe9, 0x0b, 0x7b, 0x99, 0xf2, 0xaf, + 0x0a, 0x30, 0x23, 0x77, 0x08, 0x7a, 0x37, 0xe3, 0x2e, 0xe5, 0xe9, 0x21, 0x0d, 0x94, 0xae, 0x52, + 0xf2, 0xbb, 0x8b, 0x85, 0xd1, 0xef, 0x2e, 0x16, 0x47, 0xbb, 0xbb, 0xf8, 0x00, 0x66, 0x9e, 0x7b, + 0x56, 0x60, 0x3c, 0xed, 0x62, 0xbd, 0x6b, 0xec, 0x63, 0x2f, 0x6b, 0x86, 0x4d, 0xba, 0xa2, 0xaa, + 0x60, 0x79, 0x42, 0x38, 0xe8, 0x82, 0xf9, 0xb9, 0xe1, 0xf2, 0x75, 0xb7, 0x14, 0xca, 0xb7, 0x9e, + 0x1b, 0x2e, 0xe3, 0xa1, 0x24, 0xa3, 0x5d, 0x43, 0xfc, 0x76, 0x01, 0x8e, 0x66, 0xde, 0xb8, 0xfb, + 0xe4, 0x7a, 0xbc, 0x1c, 0xd7, 0xe3, 0x41, 0xae, 0x31, 0x16, 0x0f, 0x74, 0x8d, 0x71, 0x2d, 0x47, + 0xab, 0x59, 0x80, 0x92, 0xc1, 0xca, 0x55, 0xbf, 0x0e, 0xe5, 0xa6, 0x6f, 0xb1, 0xe6, 0x9f, 0x87, + 0xd2, 0xc3, 0x7e, 0xb7, 0xcb, 0x1b, 0x2e, 0xe9, 0xaf, 0xe9, 0x5b, 0x2b, 0x64, 0x68, 0x52, 0x02, + 0x42, 0xd8, 0x72, 0x7a, 0xe2, 0x54, 0x3d, 0x9b, 0x90, 0x10, 0xa8, 0x6d, 0x98, 0xe4, 0x09, 0xc4, + 0xa0, 0xb7, 0x9c, 0xc0, 0xe8, 0x8a, 0x70, 0x86, 0x7e, 0x90, 0xd4, 0xc6, 0x5e, 0xe7, 0xfa, 0x35, + 0x2a, 0x4a, 0xd1, 0xd8, 0x07, 0x4f, 0xbd, 0x75, 0x8d, 0xaa, 0x85, 0xa5, 0xde, 0xba, 0x46, 0x56, + 0x14, 0x8d, 0xbd, 0xce, 0xeb, 0xd7, 0xae, 0xd1, 0xd6, 0x2a, 0x1a, 0xff, 0x52, 0x7f, 0xa9, 0x40, + 0x59, 0xe8, 0x75, 0xe8, 0xbd, 0xc8, 0xc5, 0x3e, 0x21, 0xd3, 0xe9, 0xdd, 0x15, 0xdb, 0xb0, 0x1d, + 0xdd, 0xc7, 0x64, 0xcd, 0x30, 0xf4, 0x16, 0xda, 0x3c, 0xe5, 0x5b, 0x76, 0x3c, 0xbc, 0x61, 0xd8, + 0x4e, 0x8b, 0x31, 0xa1, 0x06, 0xd4, 0x98, 0x3c, 0x2a, 0x8a, 0x08, 0x1d, 0x1a, 0x10, 0xcc, 0x50, + 0x06, 0x22, 0x84, 0x08, 0xa3, 0x43, 0xcf, 0xf5, 0x2d, 0xde, 0x81, 0xf3, 0x09, 0x55, 0x32, 0x7f, + 0x4b, 0x08, 0xd4, 0xbf, 0x51, 0x60, 0x36, 0x61, 0x44, 0xbf, 0x71, 0x8d, 0x55, 0x7f, 0x5a, 0x84, + 0xa9, 0x98, 0x41, 0x0f, 0x69, 0xc0, 0x32, 0xcc, 0x09, 0xfc, 0x9b, 0x8f, 0x83, 0xd1, 0x6e, 0x0b, + 0xce, 0x72, 0x8e, 0x16, 0x0e, 0x58, 0x5c, 0x79, 0x1f, 0x66, 0x8d, 0x3d, 0xc3, 0xea, 0xd2, 0xc1, + 0x32, 0x52, 0xc8, 0x36, 0x13, 0xd2, 0x87, 0x91, 0x29, 0x6b, 0xf7, 0x48, 0x77, 0x06, 0x81, 0xd2, + 0x46, 0x57, 0x37, 0x7d, 0x3f, 0x86, 0x00, 0x1d, 0x78, 0x75, 0xd3, 0xf7, 0xc3, 0xf2, 0xe8, 0x05, + 0x1f, 0x7a, 0x67, 0xd5, 0xe7, 0xde, 0x2c, 0xbf, 0x3c, 0x42, 0xfb, 0x90, 0x92, 0x12, 0x85, 0xf5, + 0x8c, 0x8f, 0x1c, 0x4f, 0x8f, 0xf3, 0x4f, 0x0e, 0x51, 0x18, 0xe5, 0x68, 0x46, 0x42, 0xb8, 0x41, + 0x96, 0x87, 0x19, 0xe4, 0x26, 0x4c, 0x72, 0xaf, 0x3a, 0xa4, 0x1b, 0xb9, 0xc0, 0xc2, 0x30, 0x81, + 0x7f, 0xae, 0x40, 0x25, 0x74, 0xe8, 0x43, 0x64, 0xae, 0xc1, 0x3c, 0xbd, 0x86, 0x95, 0xec, 0xda, + 0x21, 0xd6, 0x81, 0x08, 0x53, 0x43, 0xee, 0xde, 0x06, 0xd4, 0xa8, 0xa8, 0x78, 0x1f, 0x0f, 0xb3, + 0x10, 0x5f, 0x54, 0x93, 0x45, 0xf6, 0x7f, 0x59, 0x00, 0x94, 0x76, 0xd7, 0xbf, 0x31, 0xd6, 0x1d, + 0xb7, 0x96, 0xd2, 0xe8, 0xd6, 0xf6, 0x08, 0x8e, 0xb4, 0x9d, 0x5e, 0xcf, 0xa2, 0x57, 0xf8, 0x1c, + 0x6f, 0x7f, 0x34, 0x3b, 0x9f, 0x63, 0x3c, 0x4c, 0x4f, 0x4c, 0x7d, 0xef, 0xc0, 0x31, 0x0d, 0x3b, + 0x2e, 0xb6, 0xc3, 0xe9, 0xf5, 0x89, 0xd3, 0x39, 0xc0, 0x42, 0xe3, 0x04, 0xd4, 0xb3, 0xf8, 0xf9, + 0x46, 0x56, 0x1f, 0xea, 0xcb, 0xbb, 0xb8, 0xfd, 0x8c, 0xae, 0x83, 0x0f, 0x03, 0x9e, 0xab, 0x43, + 0xb9, 0xeb, 0xb4, 0xd9, 0xd3, 0xdd, 0x7c, 0xaf, 0x57, 0x7c, 0x0f, 0x38, 0x66, 0x3b, 0x09, 0xc7, + 0x33, 0x8b, 0xe5, 0xb5, 0x42, 0x50, 0x7b, 0x84, 0x83, 0xd5, 0x3d, 0x6c, 0x87, 0xeb, 0x18, 0xf5, + 0xc7, 0x85, 0xd8, 0x8a, 0x89, 0x66, 0x1d, 0x00, 0x74, 0x88, 0x9a, 0x10, 0x2d, 0xe1, 0x74, 0x4c, + 0xb8, 0xd9, 0x0b, 0xb3, 0xec, 0xfd, 0xe7, 0x6c, 0xd4, 0x01, 0x2d, 0x84, 0x3e, 0x2c, 0x1b, 0xbd, + 0x9d, 0x15, 0xa6, 0x25, 0xb0, 0x28, 0xc5, 0x24, 0x16, 0xe5, 0x3d, 0x40, 0xf1, 0x35, 0x11, 0xdf, + 0xf7, 0x29, 0x8d, 0xf0, 0x5c, 0x58, 0xcd, 0x4d, 0x3e, 0x6c, 0x97, 0xf3, 0xe8, 0xd7, 0xf8, 0xa1, + 0x1e, 0xfd, 0x52, 0x4f, 0xc1, 0x09, 0xb2, 0xd2, 0x59, 0xc7, 0x81, 0x67, 0xb5, 0x57, 0xb0, 0xdf, + 0xf6, 0x2c, 0x37, 0x70, 0x42, 0x1c, 0x9c, 0xaa, 0xc3, 0xc9, 0x9c, 0x7c, 0xae, 0xee, 0x77, 0x60, + 0xca, 0x8c, 0x92, 0xb3, 0xb6, 0x1e, 0x93, 0xbc, 0x5a, 0x9c, 0x41, 0xfd, 0x00, 0x6a, 0x49, 0x82, + 0xcc, 0x2d, 0x3d, 0x04, 0xa5, 0x5d, 0xdc, 0x75, 0xc5, 0x9d, 0x4b, 0xf2, 0x9b, 0x68, 0x9d, 0x2d, + 0x22, 0x9f, 0xe1, 0x7d, 0x71, 0x34, 0x55, 0xa1, 0x29, 0x5f, 0xc2, 0xfb, 0x61, 0xdb, 0xa4, 0x57, + 0x68, 0x3c, 0xab, 0x9d, 0x6c, 0x5b, 0x46, 0x7e, 0xd4, 0x36, 0xd2, 0x6d, 0x3d, 0x96, 0xcc, 0xdb, + 0x76, 0x32, 0xf7, 0x85, 0x1b, 0xca, 0x0b, 0xae, 0x63, 0xf2, 0xdf, 0xea, 0xf7, 0x15, 0x98, 0x4b, + 0x51, 0x8c, 0x78, 0xdc, 0xf8, 0x1a, 0x4c, 0x8a, 0x72, 0x0b, 0x69, 0x6c, 0x39, 0x93, 0xa5, 0x09, + 0x12, 0xb4, 0x06, 0x73, 0x91, 0x45, 0x0b, 0xbe, 0x62, 0xba, 0x2f, 0xe2, 0x2b, 0x48, 0x5a, 0xdd, + 0x5a, 0x3b, 0x91, 0xa2, 0xb6, 0xa1, 0x96, 0xa4, 0x1a, 0x65, 0x4c, 0x1d, 0xa8, 0xbe, 0xea, 0x8f, + 0x14, 0x98, 0x60, 0x69, 0x99, 0x9d, 0x2d, 0x4d, 0x07, 0x85, 0xe4, 0x74, 0xf0, 0x26, 0x4c, 0x31, + 0x39, 0x7a, 0x78, 0xe3, 0x76, 0x46, 0x3e, 0x71, 0x61, 0xa2, 0xe9, 0x68, 0x85, 0x5e, 0xf8, 0x9b, + 0x34, 0x83, 0xd9, 0x0b, 0x5d, 0x22, 0x8a, 0x1b, 0x04, 0x53, 0x34, 0x8d, 0xba, 0x5c, 0xb2, 0x2c, + 0xe1, 0x8b, 0xc9, 0x21, 0xbe, 0x99, 0xef, 0x31, 0x2e, 0xd0, 0x37, 0x55, 0x53, 0x67, 0x0e, 0xea, + 0x16, 0x7d, 0xf4, 0x34, 0x7d, 0x56, 0x80, 0xde, 0x92, 0x11, 0x27, 0x2f, 0xa7, 0x40, 0x1f, 0x12, + 0x5b, 0xdf, 0x63, 0xff, 0xe2, 0x80, 0x03, 0x4f, 0x3e, 0x84, 0x63, 0xb9, 0x34, 0xe8, 0xed, 0xf0, + 0x85, 0x69, 0xd3, 0xb3, 0xf6, 0xf8, 0x0e, 0xcf, 0x8c, 0xfc, 0x9a, 0xcd, 0x32, 0x25, 0x58, 0xa1, + 0xf9, 0xe2, 0xed, 0x69, 0xf6, 0xa5, 0xfe, 0xbd, 0x22, 0x20, 0x17, 0xd2, 0x03, 0x62, 0x32, 0xaa, + 0x65, 0x34, 0xd3, 0x8d, 0x3f, 0x14, 0x5d, 0xf8, 0xc4, 0x0f, 0x45, 0x17, 0x0f, 0x73, 0x85, 0x51, + 0x3d, 0x07, 0x67, 0x07, 0xb4, 0x86, 0x75, 0xc6, 0xa5, 0x57, 0xa0, 0x2c, 0xfe, 0xe5, 0x06, 0x9a, + 0x84, 0xe2, 0xd6, 0x72, 0xb3, 0x36, 0x46, 0x7e, 0x6c, 0xaf, 0x34, 0x6b, 0x0a, 0x2a, 0x43, 0xa9, + 0xb5, 0xbc, 0xd5, 0xac, 0x15, 0x2e, 0xf5, 0xa0, 0x96, 0xfc, 0xaf, 0x13, 0x68, 0x11, 0x8e, 0x34, + 0xb5, 0xcd, 0x66, 0xe3, 0x51, 0x63, 0x6b, 0x6d, 0x73, 0x43, 0x6f, 0x6a, 0x6b, 0xef, 0x37, 0xb6, + 0x56, 0x6b, 0x63, 0xe8, 0x2c, 0x9c, 0x8c, 0x67, 0x3c, 0xde, 0x6c, 0x6d, 0xe9, 0x5b, 0x9b, 0xfa, + 0xf2, 0xe6, 0xc6, 0x56, 0x63, 0x6d, 0x63, 0x55, 0xab, 0x29, 0xe8, 0x24, 0x1c, 0x8b, 0x93, 0x3c, + 0x58, 0x5b, 0x59, 0xd3, 0x56, 0x97, 0xc9, 0xef, 0xc6, 0x93, 0x5a, 0xe1, 0xd2, 0xdb, 0x50, 0x95, + 0x2e, 0x22, 0x92, 0x2a, 0x35, 0x37, 0x57, 0x6a, 0x63, 0xa8, 0x0a, 0x95, 0xb8, 0x9c, 0x32, 0x94, + 0x36, 0x36, 0x57, 0x56, 0x6b, 0x05, 0x04, 0x30, 0xb1, 0xd5, 0xd0, 0x1e, 0xad, 0x6e, 0xd5, 0x8a, + 0x97, 0xae, 0xc3, 0x52, 0xde, 0x85, 0x5c, 0x54, 0x81, 0xf1, 0x75, 0xec, 0x75, 0x70, 0x6d, 0x8c, + 0xb0, 0xb4, 0xc8, 0xc8, 0x08, 0x6a, 0xca, 0xa5, 0xbb, 0xc9, 0x47, 0xa7, 0x30, 0x9a, 0x83, 0x6a, + 0xab, 0xb1, 0xb1, 0xf2, 0x60, 0xf3, 0xab, 0xba, 0xb6, 0xda, 0x58, 0xf9, 0xa0, 0x36, 0x86, 0xe6, + 0xa1, 0x26, 0x92, 0x36, 0x36, 0xb7, 0x58, 0xaa, 0x72, 0xe9, 0x59, 0x62, 0x8f, 0x05, 0xa3, 0xa3, + 0x30, 0x17, 0xd6, 0x52, 0x5f, 0xd6, 0x56, 0x1b, 0x5b, 0xab, 0xa4, 0xf2, 0x52, 0xb2, 0xb6, 0xbd, + 0xb1, 0xb1, 0xb6, 0xf1, 0xa8, 0xa6, 0x10, 0xa9, 0x51, 0xf2, 0xea, 0x57, 0xd7, 0x08, 0x71, 0x41, + 0x26, 0xde, 0xde, 0xf8, 0xd2, 0xc6, 0xe6, 0x57, 0x36, 0x6a, 0xc5, 0x4b, 0xff, 0x27, 0x0e, 0x2a, + 0x8b, 0xa6, 0xdf, 0xe3, 0xb0, 0x98, 0x2a, 0x51, 0x5f, 0x7d, 0x7f, 0x75, 0x63, 0xab, 0x36, 0x26, + 0x67, 0xb6, 0xb6, 0x1a, 0x5a, 0x94, 0xa9, 0x24, 0x33, 0x37, 0x9b, 0xcd, 0x30, 0xb3, 0x20, 0x67, + 0xae, 0xac, 0x3e, 0x59, 0x8d, 0x38, 0x8b, 0x97, 0x5e, 0x02, 0x88, 0xdc, 0x0c, 0x9a, 0x82, 0xc9, + 0xe5, 0xcd, 0xed, 0x8d, 0xad, 0x55, 0xad, 0x36, 0x46, 0xb4, 0xfc, 0xa8, 0xb1, 0xfd, 0x68, 0xb5, + 0xa6, 0x5c, 0xba, 0x08, 0xd3, 0xf1, 0x41, 0x47, 0xe8, 0x5a, 0x1f, 0xb4, 0xb6, 0x56, 0xd7, 0x89, + 0x46, 0xa6, 0xa1, 0xbc, 0xfc, 0x48, 0xdb, 0xdc, 0x6e, 0x3e, 0x6c, 0xd5, 0x94, 0x1b, 0xff, 0x79, + 0x34, 0x3c, 0xdb, 0x6a, 0x61, 0x8f, 0x5e, 0xca, 0x5a, 0x81, 0x49, 0xf1, 0x7f, 0x6d, 0xa4, 0x5d, + 0x46, 0xf9, 0xff, 0xf0, 0xd4, 0x8f, 0x67, 0xe6, 0xf1, 0xf0, 0x69, 0x0c, 0xbd, 0x4f, 0x4f, 0x0b, + 0x63, 0x4f, 0x3e, 0x9e, 0x49, 0x1c, 0xda, 0xa4, 0x5e, 0x96, 0xac, 0x9f, 0x1d, 0x40, 0x11, 0xca, + 0xfd, 0x00, 0x66, 0xe4, 0xb7, 0x95, 0xd1, 0x59, 0xf9, 0x48, 0x2a, 0xe3, 0xd9, 0xe6, 0xba, 0x3a, + 0x88, 0x24, 0x14, 0xad, 0x43, 0x2d, 0xf9, 0xb6, 0x32, 0x92, 0x5c, 0x40, 0xce, 0xd3, 0xcd, 0xf5, + 0x97, 0x06, 0x13, 0xc5, 0x0b, 0x48, 0x3d, 0x19, 0x7c, 0x6e, 0xf0, 0x23, 0xac, 0x19, 0x05, 0xe4, + 0xbd, 0xd4, 0xca, 0x94, 0x23, 0x07, 0x17, 0x28, 0xf1, 0x4a, 0x6f, 0xc6, 0x83, 0x9e, 0xb2, 0x72, + 0xb2, 0x1f, 0x73, 0x54, 0xc7, 0xd0, 0xd7, 0x61, 0x36, 0x71, 0xe3, 0x06, 0x49, 0x8c, 0xd9, 0x17, + 0x89, 0xea, 0xe7, 0x06, 0xd2, 0xc8, 0xbd, 0x1a, 0xbf, 0x55, 0x93, 0xec, 0xd5, 0x8c, 0xdb, 0x3a, + 0xc9, 0x5e, 0xcd, 0xbc, 0x94, 0x43, 0x0d, 0x51, 0xba, 0x41, 0x23, 0x1b, 0x62, 0xd6, 0x8d, 0x9d, + 0xfa, 0xd9, 0x01, 0x14, 0x71, 0x85, 0x24, 0xee, 0xd0, 0xc8, 0x0a, 0xc9, 0xbe, 0x9d, 0x53, 0x3f, + 0x37, 0x90, 0x26, 0xd9, 0x93, 0x11, 0x40, 0x3f, 0xdd, 0x93, 0xa9, 0xfb, 0x23, 0xe9, 0x9e, 0x4c, + 0xe3, 0xfb, 0x79, 0x4f, 0x26, 0x20, 0xf5, 0xea, 0x40, 0x90, 0x6e, 0x56, 0x4f, 0x66, 0x03, 0x79, + 0xd5, 0x31, 0xf4, 0x1c, 0x96, 0xf2, 0x40, 0x94, 0xe8, 0xd5, 0x03, 0x60, 0x3d, 0xeb, 0xaf, 0x8d, + 0x46, 0x1c, 0x16, 0x8c, 0x01, 0xa5, 0x57, 0x99, 0xe8, 0x65, 0x59, 0xdd, 0x39, 0xab, 0xd8, 0xfa, + 0x2b, 0xc3, 0xc8, 0xc2, 0x62, 0x1e, 0x41, 0x59, 0xc0, 0x33, 0x91, 0xe4, 0x02, 0x13, 0xb0, 0xd0, + 0xfa, 0x89, 0xec, 0xcc, 0x50, 0xd0, 0x5b, 0x50, 0x22, 0xa9, 0x68, 0x31, 0x49, 0x27, 0x04, 0x2c, + 0xa5, 0x33, 0x42, 0xe6, 0x06, 0x4c, 0x30, 0xdc, 0x21, 0x92, 0x4e, 0xf0, 0x25, 0x5c, 0x64, 0xbd, + 0x9e, 0x95, 0x15, 0x8a, 0x68, 0xb2, 0xff, 0x12, 0xc6, 0x61, 0x84, 0xe8, 0x54, 0xf2, 0xbf, 0x2a, + 0xc8, 0x78, 0xc5, 0xfa, 0xe9, 0xdc, 0xfc, 0xb8, 0xcd, 0x26, 0x36, 0xec, 0xcf, 0x0e, 0x38, 0xa5, + 0xca, 0xb2, 0xd9, 0xec, 0xb3, 0x2f, 0xd6, 0xb9, 0xe9, 0xb3, 0x31, 0xf4, 0x72, 0xae, 0xbd, 0x4b, + 0x45, 0xbc, 0x32, 0x8c, 0x2c, 0x3e, 0x34, 0x92, 0x2f, 0x1f, 0xaa, 0x83, 0x9e, 0x2e, 0xcd, 0x1a, + 0x1a, 0x39, 0x4f, 0xa2, 0xaa, 0x63, 0x68, 0x17, 0x8e, 0x64, 0xbc, 0x99, 0x8a, 0x5e, 0xc9, 0xf7, + 0xbf, 0x52, 0x29, 0xe7, 0x87, 0xd2, 0xc5, 0x4b, 0xca, 0xc0, 0x0e, 0xc9, 0x25, 0xe5, 0x83, 0x97, + 0xe4, 0x92, 0x06, 0x81, 0x90, 0xa8, 0x21, 0x72, 0x1f, 0x72, 0x2c, 0x0b, 0x19, 0x92, 0x61, 0x88, + 0x29, 0x8f, 0xb1, 0x0b, 0x47, 0x32, 0x76, 0x62, 0xe4, 0xca, 0xe6, 0xef, 0x10, 0xc9, 0x95, 0x1d, + 0xb4, 0xa5, 0x33, 0x86, 0x3e, 0x04, 0xf4, 0x08, 0x07, 0x72, 0x28, 0xe7, 0x23, 0x69, 0xa0, 0x26, + 0x37, 0x7d, 0x72, 0xec, 0x53, 0xda, 0xfd, 0x51, 0xc7, 0xae, 0x29, 0xc8, 0x66, 0x97, 0xfa, 0x52, + 0x7b, 0x16, 0xe8, 0x42, 0xb2, 0xdb, 0xf2, 0xb6, 0x3d, 0xea, 0x17, 0x47, 0xa0, 0x0c, 0xdb, 0x62, + 0x27, 0xdf, 0xe7, 0x16, 0xcb, 0xe6, 0x0b, 0xf9, 0x66, 0x22, 0x6f, 0x45, 0xa4, 0xcb, 0xcb, 0xdd, + 0x94, 0x08, 0xe3, 0xb9, 0x98, 0x31, 0x9d, 0xc9, 0x47, 0xb2, 0xe5, 0xc4, 0x73, 0x99, 0x06, 0xf4, + 0x2d, 0x38, 0x96, 0xbb, 0x66, 0x42, 0x19, 0x73, 0x40, 0xfe, 0x42, 0xb1, 0x7e, 0x79, 0x44, 0x6a, + 0x51, 0xf6, 0x8d, 0xdf, 0x29, 0xc2, 0x34, 0x43, 0x1b, 0xf2, 0xd0, 0x77, 0x1d, 0x20, 0x02, 0xee, + 0xa2, 0x93, 0x49, 0xfd, 0x48, 0x68, 0xe8, 0xfa, 0xa9, 0xbc, 0xec, 0xb8, 0x8b, 0x8d, 0x01, 0x62, + 0x65, 0x17, 0x9b, 0xc6, 0xf7, 0xca, 0x2e, 0x36, 0x03, 0x49, 0xab, 0x8e, 0xa1, 0xf7, 0xa0, 0x12, + 0xe2, 0x2f, 0x65, 0xc3, 0x4d, 0x02, 0x49, 0xeb, 0x27, 0x73, 0x72, 0xe3, 0xb5, 0x8b, 0xc1, 0x2a, + 0xe5, 0xda, 0xa5, 0x21, 0x9b, 0x72, 0xed, 0xb2, 0xf0, 0x98, 0x51, 0x7b, 0x19, 0x80, 0x26, 0xa3, + 0xbd, 0x12, 0xa0, 0x2a, 0xa3, 0xbd, 0x32, 0xf2, 0x46, 0x1d, 0x7b, 0x70, 0xff, 0x27, 0xbf, 0x38, + 0xa5, 0xfc, 0xec, 0x17, 0xa7, 0xc6, 0xfe, 0xd7, 0xc7, 0xa7, 0x94, 0x9f, 0x7c, 0x7c, 0x4a, 0xf9, + 0xc7, 0x8f, 0x4f, 0x29, 0x3f, 0xff, 0xf8, 0x94, 0xf2, 0x9d, 0x5f, 0x9e, 0x1a, 0xfb, 0x50, 0x7d, + 0x76, 0xdb, 0xbf, 0x62, 0x39, 0x57, 0xdb, 0x9e, 0x75, 0xd9, 0x70, 0xad, 0xab, 0xee, 0xb3, 0xce, + 0x55, 0xc3, 0xb5, 0xfc, 0xab, 0x5c, 0xee, 0xd5, 0xbd, 0xeb, 0x4f, 0x27, 0xe8, 0x7f, 0xb5, 0x7c, + 0xfd, 0xbf, 0x02, 0x00, 0x00, 0xff, 0xff, 0x27, 0x51, 0x27, 0xfc, 0x8f, 0x74, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -14707,6 +14941,18 @@ func (m *LinuxPodSandboxStats) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.Io != nil { + { + size, err := m.Io.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApi(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } if len(m.Containers) > 0 { for iNdEx := len(m.Containers) - 1; iNdEx >= 0; iNdEx-- { { @@ -15649,21 +15895,21 @@ func (m *LinuxContainerSecurityContext) MarshalToSizedBuffer(dAtA []byte) (int, dAtA[i] = 0x4a } if len(m.SupplementalGroups) > 0 { - dAtA58 := make([]byte, len(m.SupplementalGroups)*10) - var j57 int + dAtA59 := make([]byte, len(m.SupplementalGroups)*10) + var j58 int for _, num1 := range m.SupplementalGroups { num := uint64(num1) for num >= 1<<7 { - dAtA58[j57] = uint8(uint64(num)&0x7f | 0x80) + dAtA59[j58] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j57++ + j58++ } - dAtA58[j57] = uint8(num) - j57++ + dAtA59[j58] = uint8(num) + j58++ } - i -= j57 - copy(dAtA[i:], dAtA58[:j57]) - i = encodeVarintApi(dAtA, i, uint64(j57)) + i -= j58 + copy(dAtA[i:], dAtA59[:j58]) + i = encodeVarintApi(dAtA, i, uint64(j58)) i-- dAtA[i] = 0x42 } @@ -15813,21 +16059,21 @@ func (m *LinuxContainerUser) MarshalToSizedBuffer(dAtA []byte) (int, error) { var l int _ = l if len(m.SupplementalGroups) > 0 { - dAtA66 := make([]byte, len(m.SupplementalGroups)*10) - var j65 int + dAtA67 := make([]byte, len(m.SupplementalGroups)*10) + var j66 int for _, num1 := range m.SupplementalGroups { num := uint64(num1) for num >= 1<<7 { - dAtA66[j65] = uint8(uint64(num)&0x7f | 0x80) + dAtA67[j66] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j65++ + j66++ } - dAtA66[j65] = uint8(num) - j65++ + dAtA67[j66] = uint8(num) + j66++ } - i -= j65 - copy(dAtA[i:], dAtA66[:j65]) - i = encodeVarintApi(dAtA, i, uint64(j65)) + i -= j66 + copy(dAtA[i:], dAtA67[:j66]) + i = encodeVarintApi(dAtA, i, uint64(j66)) i-- dAtA[i] = 0x1a } @@ -17818,21 +18064,21 @@ func (m *PortForwardRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { var l int _ = l if len(m.Port) > 0 { - dAtA92 := make([]byte, len(m.Port)*10) - var j91 int + dAtA93 := make([]byte, len(m.Port)*10) + var j92 int for _, num1 := range m.Port { num := uint64(num1) for num >= 1<<7 { - dAtA92[j91] = uint8(uint64(num)&0x7f | 0x80) + dAtA93[j92] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j91++ + j92++ } - dAtA92[j91] = uint8(num) - j91++ + dAtA93[j92] = uint8(num) + j92++ } - i -= j91 - copy(dAtA[i:], dAtA92[:j91]) - i = encodeVarintApi(dAtA, i, uint64(j91)) + i -= j92 + copy(dAtA[i:], dAtA93[:j92]) + i = encodeVarintApi(dAtA, i, uint64(j92)) i-- dAtA[i] = 0x12 } @@ -19374,6 +19620,18 @@ func (m *ContainerStats) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.Io != nil { + { + size, err := m.Io.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApi(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x32 + } if m.Swap != nil { { size, err := m.Swap.MarshalToSizedBuffer(dAtA[:i]) @@ -19508,6 +19766,99 @@ func (m *WindowsContainerStats) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *PsiStats) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PsiStats) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PsiStats) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Some != nil { + { + size, err := m.Some.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApi(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Full != nil { + { + size, err := m.Full.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApi(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *PsiData) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *PsiData) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *PsiData) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Avg300 != 0 { + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Avg300)))) + i-- + dAtA[i] = 0x21 + } + if m.Avg60 != 0 { + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Avg60)))) + i-- + dAtA[i] = 0x19 + } + if m.Avg10 != 0 { + i -= 8 + encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Avg10)))) + i-- + dAtA[i] = 0x11 + } + if m.Total != 0 { + i = encodeVarintApi(dAtA, i, uint64(m.Total)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + func (m *CpuUsage) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -19528,6 +19879,18 @@ func (m *CpuUsage) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.Psi != nil { + { + size, err := m.Psi.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApi(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } if m.UsageNanoCores != nil { { size, err := m.UsageNanoCores.MarshalToSizedBuffer(dAtA[:i]) @@ -19632,6 +19995,18 @@ func (m *MemoryUsage) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.Psi != nil { + { + size, err := m.Psi.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApi(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x42 + } if m.MajorPageFaults != nil { { size, err := m.MajorPageFaults.MarshalToSizedBuffer(dAtA[:i]) @@ -19712,6 +20087,46 @@ func (m *MemoryUsage) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *IoUsage) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *IoUsage) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *IoUsage) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Psi != nil { + { + size, err := m.Psi.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApi(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Timestamp != 0 { + i = encodeVarintApi(dAtA, i, uint64(m.Timestamp)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + func (m *SwapUsage) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -21441,6 +21856,10 @@ func (m *LinuxPodSandboxStats) Size() (n int) { n += 1 + l + sovApi(uint64(l)) } } + if m.Io != nil { + l = m.Io.Size() + n += 1 + l + sovApi(uint64(l)) + } return n } @@ -23362,6 +23781,10 @@ func (m *ContainerStats) Size() (n int) { l = m.Swap.Size() n += 1 + l + sovApi(uint64(l)) } + if m.Io != nil { + l = m.Io.Size() + n += 1 + l + sovApi(uint64(l)) + } return n } @@ -23390,6 +23813,44 @@ func (m *WindowsContainerStats) Size() (n int) { return n } +func (m *PsiStats) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Full != nil { + l = m.Full.Size() + n += 1 + l + sovApi(uint64(l)) + } + if m.Some != nil { + l = m.Some.Size() + n += 1 + l + sovApi(uint64(l)) + } + return n +} + +func (m *PsiData) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Total != 0 { + n += 1 + sovApi(uint64(m.Total)) + } + if m.Avg10 != 0 { + n += 9 + } + if m.Avg60 != 0 { + n += 9 + } + if m.Avg300 != 0 { + n += 9 + } + return n +} + func (m *CpuUsage) Size() (n int) { if m == nil { return 0 @@ -23407,6 +23868,10 @@ func (m *CpuUsage) Size() (n int) { l = m.UsageNanoCores.Size() n += 1 + l + sovApi(uint64(l)) } + if m.Psi != nil { + l = m.Psi.Size() + n += 1 + l + sovApi(uint64(l)) + } return n } @@ -23463,6 +23928,26 @@ func (m *MemoryUsage) Size() (n int) { l = m.MajorPageFaults.Size() n += 1 + l + sovApi(uint64(l)) } + if m.Psi != nil { + l = m.Psi.Size() + n += 1 + l + sovApi(uint64(l)) + } + return n +} + +func (m *IoUsage) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Timestamp != 0 { + n += 1 + sovApi(uint64(m.Timestamp)) + } + if m.Psi != nil { + l = m.Psi.Size() + n += 1 + l + sovApi(uint64(l)) + } return n } @@ -24464,6 +24949,7 @@ func (this *LinuxPodSandboxStats) String() string { `Network:` + strings.Replace(this.Network.String(), "NetworkUsage", "NetworkUsage", 1) + `,`, `Process:` + strings.Replace(this.Process.String(), "ProcessUsage", "ProcessUsage", 1) + `,`, `Containers:` + repeatedStringForContainers + `,`, + `Io:` + strings.Replace(this.Io.String(), "IoUsage", "IoUsage", 1) + `,`, `}`, }, "") return s @@ -25780,6 +26266,7 @@ func (this *ContainerStats) String() string { `Memory:` + strings.Replace(this.Memory.String(), "MemoryUsage", "MemoryUsage", 1) + `,`, `WritableLayer:` + strings.Replace(this.WritableLayer.String(), "FilesystemUsage", "FilesystemUsage", 1) + `,`, `Swap:` + strings.Replace(this.Swap.String(), "SwapUsage", "SwapUsage", 1) + `,`, + `Io:` + strings.Replace(this.Io.String(), "IoUsage", "IoUsage", 1) + `,`, `}`, }, "") return s @@ -25797,6 +26284,30 @@ func (this *WindowsContainerStats) String() string { }, "") return s } +func (this *PsiStats) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&PsiStats{`, + `Full:` + strings.Replace(this.Full.String(), "PsiData", "PsiData", 1) + `,`, + `Some:` + strings.Replace(this.Some.String(), "PsiData", "PsiData", 1) + `,`, + `}`, + }, "") + return s +} +func (this *PsiData) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&PsiData{`, + `Total:` + fmt.Sprintf("%v", this.Total) + `,`, + `Avg10:` + fmt.Sprintf("%v", this.Avg10) + `,`, + `Avg60:` + fmt.Sprintf("%v", this.Avg60) + `,`, + `Avg300:` + fmt.Sprintf("%v", this.Avg300) + `,`, + `}`, + }, "") + return s +} func (this *CpuUsage) String() string { if this == nil { return "nil" @@ -25805,6 +26316,7 @@ func (this *CpuUsage) String() string { `Timestamp:` + fmt.Sprintf("%v", this.Timestamp) + `,`, `UsageCoreNanoSeconds:` + strings.Replace(this.UsageCoreNanoSeconds.String(), "UInt64Value", "UInt64Value", 1) + `,`, `UsageNanoCores:` + strings.Replace(this.UsageNanoCores.String(), "UInt64Value", "UInt64Value", 1) + `,`, + `Psi:` + strings.Replace(this.Psi.String(), "PsiStats", "PsiStats", 1) + `,`, `}`, }, "") return s @@ -25833,6 +26345,18 @@ func (this *MemoryUsage) String() string { `RssBytes:` + strings.Replace(this.RssBytes.String(), "UInt64Value", "UInt64Value", 1) + `,`, `PageFaults:` + strings.Replace(this.PageFaults.String(), "UInt64Value", "UInt64Value", 1) + `,`, `MajorPageFaults:` + strings.Replace(this.MajorPageFaults.String(), "UInt64Value", "UInt64Value", 1) + `,`, + `Psi:` + strings.Replace(this.Psi.String(), "PsiStats", "PsiStats", 1) + `,`, + `}`, + }, "") + return s +} +func (this *IoUsage) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&IoUsage{`, + `Timestamp:` + fmt.Sprintf("%v", this.Timestamp) + `,`, + `Psi:` + strings.Replace(this.Psi.String(), "PsiStats", "PsiStats", 1) + `,`, `}`, }, "") return s @@ -32951,6 +33475,42 @@ func (m *LinuxPodSandboxStats) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Io", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Io == nil { + m.Io = &IoUsage{} + } + if err := m.Io.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipApi(dAtA[iNdEx:]) @@ -47019,6 +47579,42 @@ func (m *ContainerStats) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Io", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Io == nil { + m.Io = &IoUsage{} + } + if err := m.Io.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipApi(dAtA[iNdEx:]) @@ -47234,6 +47830,230 @@ func (m *WindowsContainerStats) Unmarshal(dAtA []byte) error { } return nil } +func (m *PsiStats) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PsiStats: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PsiStats: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Full", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Full == nil { + m.Full = &PsiData{} + } + if err := m.Full.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Some", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Some == nil { + m.Some = &PsiData{} + } + if err := m.Some.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipApi(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthApi + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PsiData) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PsiData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PsiData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Total", wireType) + } + m.Total = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Total |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Avg10", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.Avg10 = float64(math.Float64frombits(v)) + case 3: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Avg60", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.Avg60 = float64(math.Float64frombits(v)) + case 4: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field Avg300", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.Avg300 = float64(math.Float64frombits(v)) + default: + iNdEx = preIndex + skippy, err := skipApi(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthApi + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *CpuUsage) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -47354,6 +48174,42 @@ func (m *CpuUsage) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Psi", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Psi == nil { + m.Psi = &PsiStats{} + } + if err := m.Psi.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipApi(dAtA[iNdEx:]) @@ -47780,6 +48636,147 @@ func (m *MemoryUsage) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Psi", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Psi == nil { + m.Psi = &PsiStats{} + } + if err := m.Psi.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipApi(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthApi + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *IoUsage) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: IoUsage: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: IoUsage: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + } + m.Timestamp = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Timestamp |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Psi", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Psi == nil { + m.Psi = &PsiStats{} + } + if err := m.Psi.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipApi(dAtA[iNdEx:])